586 files changed, 19105 insertions, 4178 deletions

diff --git a/net/802/garp.c b/net/802/garp.c
index 1dcb0660c49d..941f2a324d3a 100644
--- a/net/802/garp.c
+++ b/net/802/garp.c
@@ -14,6 +14,7 @@
 #include <linux/etherdevice.h>
 #include <linux/rtnetlink.h>
 #include <linux/llc.h>
+#include <linux/slab.h>
 #include <net/llc.h>
 #include <net/llc_pdu.h>
 #include <net/garp.h>
@@ -575,7 +576,7 @@ int garp_init_applicant(struct net_device *dev, struct garp_application *appl)
         if (!app)
                 goto err2;
 
-        err = dev_mc_add(dev, appl->proto.group_address, ETH_ALEN, 0);
+        err = dev_mc_add(dev, appl->proto.group_address);
         if (err < 0)
                 goto err3;
 
@@ -615,7 +616,7 @@ void garp_uninit_applicant(struct net_device *dev, struct garp_application *appl
         garp_pdu_queue(app);
         garp_queue_xmit(app);
 
-        dev_mc_delete(dev, appl->proto.group_address, ETH_ALEN, 0);
+        dev_mc_del(dev, appl->proto.group_address);
         kfree(app);
         garp_release_port(dev);
 }
diff --git a/net/802/p8022.c b/net/802/p8022.c
index 2530f35241cd..7f353c4f437a 100644
--- a/net/802/p8022.c
+++ b/net/802/p8022.c
@@ -18,6 +18,7 @@
 #include <linux/module.h>
 #include <linux/netdevice.h>
 #include <linux/skbuff.h>
+#include <linux/slab.h>
 #include <net/datalink.h>
 #include <linux/mm.h>
 #include <linux/in.h>
diff --git a/net/802/p8023.c b/net/802/p8023.c
index 6ab1835041a7..1256a40da43c 100644
--- a/net/802/p8023.c
+++ b/net/802/p8023.c
@@ -18,6 +18,7 @@
 #include <linux/module.h>
 #include <linux/netdevice.h>
 #include <linux/skbuff.h>
+#include <linux/slab.h>
 
 #include <net/datalink.h>
 #include <net/p8022.h>
diff --git a/net/802/psnap.c b/net/802/psnap.c
index 6fea0750662b..21cde8fd5795 100644
--- a/net/802/psnap.c
+++ b/net/802/psnap.c
@@ -14,6 +14,7 @@
 #include <linux/module.h>
 #include <linux/netdevice.h>
 #include <linux/skbuff.h>
+#include <linux/slab.h>
 #include <net/datalink.h>
 #include <net/llc.h>
 #include <net/psnap.h>
diff --git a/net/802/stp.c b/net/802/stp.c
index 0b7a24452d11..53c8f77f0ccd 100644
--- a/net/802/stp.c
+++ b/net/802/stp.c
@@ -11,6 +11,7 @@
 #include <linux/skbuff.h>
 #include <linux/etherdevice.h>
 #include <linux/llc.h>
+#include <linux/slab.h>
 #include <net/llc.h>
 #include <net/llc_pdu.h>
 #include <net/stp.h>
diff --git a/net/802/tr.c b/net/802/tr.c
index 44acce47fcdc..1c6e596074df 100644
--- a/net/802/tr.c
+++ b/net/802/tr.c
@@ -36,6 +36,7 @@
 #include <linux/seq_file.h>
 #include <linux/init.h>
 #include <linux/sysctl.h>
+#include <linux/slab.h>
 #include <net/arp.h>
 #include <net/net_namespace.h>
 
diff --git a/net/8021q/vlan.c b/net/8021q/vlan.c
index 453512266ea1..3c1c8c14e929 100644
--- a/net/8021q/vlan.c
+++ b/net/8021q/vlan.c
@@ -22,6 +22,7 @@
 #include <linux/module.h>
 #include <linux/netdevice.h>
 #include <linux/skbuff.h>
+#include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/rculist.h>
 #include <net/p8022.h>
@@ -356,13 +357,13 @@ static void vlan_sync_address(struct net_device *dev,
          * the new address */
         if (compare_ether_addr(vlandev->dev_addr, vlan->real_dev_addr) &&
             !compare_ether_addr(vlandev->dev_addr, dev->dev_addr))
-                dev_unicast_delete(dev, vlandev->dev_addr);
+                dev_uc_del(dev, vlandev->dev_addr);
 
         /* vlan address was equal to the old address and is different from
          * the new address */
         if (!compare_ether_addr(vlandev->dev_addr, vlan->real_dev_addr) &&
             compare_ether_addr(vlandev->dev_addr, dev->dev_addr))
-                dev_unicast_add(dev, vlandev->dev_addr);
+                dev_uc_add(dev, vlandev->dev_addr);
 
         memcpy(vlan->real_dev_addr, dev->dev_addr, ETH_ALEN);
 }
@@ -378,6 +379,8 @@ static void vlan_transfer_features(struct net_device *dev,
 #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
         vlandev->fcoe_ddp_xid = dev->fcoe_ddp_xid;
 #endif
+        vlandev->real_num_tx_queues = dev->real_num_tx_queues;
+        BUG_ON(vlandev->real_num_tx_queues > vlandev->num_tx_queues);
 
         if (old_features != vlandev->features)
                 netdev_features_change(vlandev);
@@ -530,6 +533,10 @@ static int vlan_device_event(struct notifier_block *unused, unsigned long event,
                 }
                 unregister_netdevice_many(&list);
                 break;
+
+        case NETDEV_PRE_TYPE_CHANGE:
+                /* Forbid underlaying device to change its type. */
+                return NOTIFY_BAD;
         }
 
 out:
diff --git a/net/8021q/vlan_core.c b/net/8021q/vlan_core.c
index c0316e0ca6e8..c584a0af77d3 100644
--- a/net/8021q/vlan_core.c
+++ b/net/8021q/vlan_core.c
@@ -11,7 +11,7 @@ int __vlan_hwaccel_rx(struct sk_buff *skb, struct vlan_group *grp,
         if (netpoll_rx(skb))
                 return NET_RX_DROP;
 
-        if (skb_bond_should_drop(skb))
+        if (skb_bond_should_drop(skb, ACCESS_ONCE(skb->dev->master)))
                 goto drop;
 
         skb->skb_iif = skb->dev->ifindex;
@@ -83,7 +83,7 @@ vlan_gro_common(struct napi_struct *napi, struct vlan_group *grp,
 {
         struct sk_buff *p;
 
-        if (skb_bond_should_drop(skb))
+        if (skb_bond_should_drop(skb, ACCESS_ONCE(skb->dev->master)))
                 goto drop;
 
         skb->skb_iif = skb->dev->ifindex;
diff --git a/net/8021q/vlan_dev.c b/net/8021q/vlan_dev.c
index 9e83272fc5b0..b5249c5fd4d3 100644
--- a/net/8021q/vlan_dev.c
+++ b/net/8021q/vlan_dev.c
@@ -21,6 +21,7 @@
  */
 
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/skbuff.h>
 #include <linux/netdevice.h>
 #include <linux/etherdevice.h>
@@ -361,6 +362,14 @@ static netdev_tx_t vlan_dev_hwaccel_hard_start_xmit(struct sk_buff *skb,
         return ret;
 }
 
+static u16 vlan_dev_select_queue(struct net_device *dev, struct sk_buff *skb)
+{
+        struct net_device *rdev = vlan_dev_info(dev)->real_dev;
+        const struct net_device_ops *ops = rdev->netdev_ops;
+
+        return ops->ndo_select_queue(rdev, skb);
+}
+
 static int vlan_dev_change_mtu(struct net_device *dev, int new_mtu)
 {
         /* TODO: gotta make sure the underlying layer can handle it,
@@ -461,7 +470,7 @@ static int vlan_dev_open(struct net_device *dev)
                 return -ENETDOWN;
 
         if (compare_ether_addr(dev->dev_addr, real_dev->dev_addr)) {
-                err = dev_unicast_add(real_dev, dev->dev_addr);
+                err = dev_uc_add(real_dev, dev->dev_addr);
                 if (err < 0)
                         goto out;
         }
@@ -490,7 +499,7 @@ clear_allmulti:
                 dev_set_allmulti(real_dev, -1);
 del_unicast:
         if (compare_ether_addr(dev->dev_addr, real_dev->dev_addr))
-                dev_unicast_delete(real_dev, dev->dev_addr);
+                dev_uc_del(real_dev, dev->dev_addr);
 out:
         netif_carrier_off(dev);
         return err;
@@ -505,14 +514,14 @@ static int vlan_dev_stop(struct net_device *dev)
                 vlan_gvrp_request_leave(dev);
 
         dev_mc_unsync(real_dev, dev);
-        dev_unicast_unsync(real_dev, dev);
+        dev_uc_unsync(real_dev, dev);
         if (dev->flags & IFF_ALLMULTI)
                 dev_set_allmulti(real_dev, -1);
         if (dev->flags & IFF_PROMISC)
                 dev_set_promiscuity(real_dev, -1);
 
         if (compare_ether_addr(dev->dev_addr, real_dev->dev_addr))
-                dev_unicast_delete(real_dev, dev->dev_addr);
+                dev_uc_del(real_dev, dev->dev_addr);
 
         netif_carrier_off(dev);
         return 0;
@@ -531,13 +540,13 @@ static int vlan_dev_set_mac_address(struct net_device *dev, void *p)
                 goto out;
 
         if (compare_ether_addr(addr->sa_data, real_dev->dev_addr)) {
-                err = dev_unicast_add(real_dev, addr->sa_data);
+                err = dev_uc_add(real_dev, addr->sa_data);
                 if (err < 0)
                         return err;
         }
 
         if (compare_ether_addr(dev->dev_addr, real_dev->dev_addr))
-                dev_unicast_delete(real_dev, dev->dev_addr);
+                dev_uc_del(real_dev, dev->dev_addr);
 
 out:
         memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
@@ -654,7 +663,7 @@ static void vlan_dev_change_rx_flags(struct net_device *dev, int change)
 static void vlan_dev_set_rx_mode(struct net_device *vlan_dev)
 {
         dev_mc_sync(vlan_dev_info(vlan_dev)->real_dev, vlan_dev);
-        dev_unicast_sync(vlan_dev_info(vlan_dev)->real_dev, vlan_dev);
+        dev_uc_sync(vlan_dev_info(vlan_dev)->real_dev, vlan_dev);
 }
 
 /*
@@ -688,7 +697,8 @@ static const struct header_ops vlan_header_ops = {
         .parse   = eth_header_parse,
 };
 
-static const struct net_device_ops vlan_netdev_ops, vlan_netdev_accel_ops;
+static const struct net_device_ops vlan_netdev_ops, vlan_netdev_accel_ops,
+                    vlan_netdev_ops_sq, vlan_netdev_accel_ops_sq;
 
 static int vlan_dev_init(struct net_device *dev)
 {
@@ -722,11 +732,17 @@ static int vlan_dev_init(struct net_device *dev)
         if (real_dev->features & NETIF_F_HW_VLAN_TX) {
                 dev->header_ops      = real_dev->header_ops;
                 dev->hard_header_len = real_dev->hard_header_len;
-                dev->netdev_ops         = &vlan_netdev_accel_ops;
+                if (real_dev->netdev_ops->ndo_select_queue)
+                        dev->netdev_ops = &vlan_netdev_accel_ops_sq;
+                else
+                        dev->netdev_ops = &vlan_netdev_accel_ops;
         } else {
                 dev->header_ops      = &vlan_header_ops;
                 dev->hard_header_len = real_dev->hard_header_len + VLAN_HLEN;
-                dev->netdev_ops         = &vlan_netdev_ops;
+                if (real_dev->netdev_ops->ndo_select_queue)
+                        dev->netdev_ops = &vlan_netdev_ops_sq;
+                else
+                        dev->netdev_ops = &vlan_netdev_ops;
         }
 
         if (is_vlan_dev(real_dev))
@@ -865,6 +881,56 @@ static const struct net_device_ops vlan_netdev_accel_ops = {
 #endif
 };
 
+static const struct net_device_ops vlan_netdev_ops_sq = {
+        .ndo_select_queue       = vlan_dev_select_queue,
+        .ndo_change_mtu         = vlan_dev_change_mtu,
+        .ndo_init               = vlan_dev_init,
+        .ndo_uninit             = vlan_dev_uninit,
+        .ndo_open               = vlan_dev_open,
+        .ndo_stop               = vlan_dev_stop,
+        .ndo_start_xmit =  vlan_dev_hard_start_xmit,
+        .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = vlan_dev_set_mac_address,
+        .ndo_set_rx_mode        = vlan_dev_set_rx_mode,
+        .ndo_set_multicast_list = vlan_dev_set_rx_mode,
+        .ndo_change_rx_flags    = vlan_dev_change_rx_flags,
+        .ndo_do_ioctl           = vlan_dev_ioctl,
+        .ndo_neigh_setup        = vlan_dev_neigh_setup,
+        .ndo_get_stats          = vlan_dev_get_stats,
+#if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
+        .ndo_fcoe_ddp_setup     = vlan_dev_fcoe_ddp_setup,
+        .ndo_fcoe_ddp_done      = vlan_dev_fcoe_ddp_done,
+        .ndo_fcoe_enable        = vlan_dev_fcoe_enable,
+        .ndo_fcoe_disable       = vlan_dev_fcoe_disable,
+        .ndo_fcoe_get_wwn       = vlan_dev_fcoe_get_wwn,
+#endif
+};
+
+static const struct net_device_ops vlan_netdev_accel_ops_sq = {
+        .ndo_select_queue       = vlan_dev_select_queue,
+        .ndo_change_mtu         = vlan_dev_change_mtu,
+        .ndo_init               = vlan_dev_init,
+        .ndo_uninit             = vlan_dev_uninit,
+        .ndo_open               = vlan_dev_open,
+        .ndo_stop               = vlan_dev_stop,
+        .ndo_start_xmit =  vlan_dev_hwaccel_hard_start_xmit,
+        .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = vlan_dev_set_mac_address,
+        .ndo_set_rx_mode        = vlan_dev_set_rx_mode,
+        .ndo_set_multicast_list = vlan_dev_set_rx_mode,
+        .ndo_change_rx_flags    = vlan_dev_change_rx_flags,
+        .ndo_do_ioctl           = vlan_dev_ioctl,
+        .ndo_neigh_setup        = vlan_dev_neigh_setup,
+        .ndo_get_stats          = vlan_dev_get_stats,
+#if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
+        .ndo_fcoe_ddp_setup     = vlan_dev_fcoe_ddp_setup,
+        .ndo_fcoe_ddp_done      = vlan_dev_fcoe_ddp_done,
+        .ndo_fcoe_enable        = vlan_dev_fcoe_enable,
+        .ndo_fcoe_disable       = vlan_dev_fcoe_disable,
+        .ndo_fcoe_get_wwn       = vlan_dev_fcoe_get_wwn,
+#endif
+};
+
 void vlan_setup(struct net_device *dev)
 {
         ether_setup(dev);
diff --git a/net/9p/client.c b/net/9p/client.c
index 09d4f1e2e4a8..0aa79faa9850 100644
--- a/net/9p/client.c
+++ b/net/9p/client.c
@@ -29,6 +29,7 @@
 #include <linux/poll.h>
 #include <linux/idr.h>
 #include <linux/mutex.h>
+#include <linux/slab.h>
 #include <linux/sched.h>
 #include <linux/uaccess.h>
 #include <net/9p/9p.h>
@@ -46,6 +47,7 @@ enum {
         Opt_msize,
         Opt_trans,
         Opt_legacy,
+        Opt_version,
         Opt_err,
 };
 
@@ -53,9 +55,43 @@ static const match_table_t tokens = {
         {Opt_msize, "msize=%u"},
         {Opt_legacy, "noextend"},
         {Opt_trans, "trans=%s"},
+        {Opt_version, "version=%s"},
         {Opt_err, NULL},
 };
 
+inline int p9_is_proto_dotl(struct p9_client *clnt)
+{
+        return (clnt->proto_version == p9_proto_2000L);
+}
+EXPORT_SYMBOL(p9_is_proto_dotl);
+
+inline int p9_is_proto_dotu(struct p9_client *clnt)
+{
+        return (clnt->proto_version == p9_proto_2000u);
+}
+EXPORT_SYMBOL(p9_is_proto_dotu);
+
+/* Interpret mount option for protocol version */
+static int get_protocol_version(const substring_t *name)
+{
+        int version = -EINVAL;
+
+        if (!strncmp("9p2000", name->from, name->to-name->from)) {
+                version = p9_proto_legacy;
+                P9_DPRINTK(P9_DEBUG_9P, "Protocol version: Legacy\n");
+        } else if (!strncmp("9p2000.u", name->from, name->to-name->from)) {
+                version = p9_proto_2000u;
+                P9_DPRINTK(P9_DEBUG_9P, "Protocol version: 9P2000.u\n");
+        } else if (!strncmp("9p2000.L", name->from, name->to-name->from)) {
+                version = p9_proto_2000L;
+                P9_DPRINTK(P9_DEBUG_9P, "Protocol version: 9P2000.L\n");
+        } else {
+                P9_DPRINTK(P9_DEBUG_ERROR, "Unknown protocol version %s. ",
+                                                        name->from);
+        }
+        return version;
+}
+
 static struct p9_req_t *
 p9_client_rpc(struct p9_client *c, int8_t type, const char *fmt, ...);
 
@@ -75,7 +111,7 @@ static int parse_opts(char *opts, struct p9_client *clnt)
         int option;
         int ret = 0;
 
-        clnt->dotu = 1;
+        clnt->proto_version = p9_proto_2000u;
         clnt->msize = 8192;
 
         if (!opts)
@@ -118,7 +154,13 @@ static int parse_opts(char *opts, struct p9_client *clnt)
                         }
                         break;
                 case Opt_legacy:
-                        clnt->dotu = 0;
+                        clnt->proto_version = p9_proto_legacy;
+                        break;
+                case Opt_version:
+                        ret = get_protocol_version(&args[0]);
+                        if (ret == -EINVAL)
+                                goto free_and_return;
+                        clnt->proto_version = ret;
                         break;
                 default:
                         continue;
@@ -410,14 +452,15 @@ static int p9_check_errors(struct p9_client *c, struct p9_req_t *req)
                 int ecode;
                 char *ename;
 
-                err = p9pdu_readf(req->rc, c->dotu, "s?d", &ename, &ecode);
+                err = p9pdu_readf(req->rc, c->proto_version, "s?d",
+                                                        &ename, &ecode);
                 if (err) {
                         P9_DPRINTK(P9_DEBUG_ERROR, "couldn't parse error%d\n",
                                                                         err);
                         return err;
                 }
 
-                if (c->dotu)
+                if (p9_is_proto_dotu(c))
                         err = -ecode;
 
                 if (!err || !IS_ERR_VALUE(err))
@@ -492,7 +535,12 @@ p9_client_rpc(struct p9_client *c, int8_t type, const char *fmt, ...)
 
         P9_DPRINTK(P9_DEBUG_MUX, "client %p op %d\n", c, type);
 
-        if (c->status != Connected)
+        /* we allow for any status other than disconnected */
+        if (c->status == Disconnected)
+                return ERR_PTR(-EIO);
+
+        /* if status is begin_disconnected we allow only clunk request */
+        if ((c->status == BeginDisconnect) && (type != P9_TCLUNK))
                 return ERR_PTR(-EIO);
 
         if (signal_pending(current)) {
@@ -515,7 +563,7 @@ p9_client_rpc(struct p9_client *c, int8_t type, const char *fmt, ...)
         /* marshall the data */
         p9pdu_prepare(req->tc, tag, type);
         va_start(ap, fmt);
-        err = p9pdu_vwritef(req->tc, c->dotu, fmt, ap);
+        err = p9pdu_vwritef(req->tc, c->proto_version, fmt, ap);
         va_end(ap);
         p9pdu_finalize(req->tc);
 
@@ -627,14 +675,31 @@ int p9_client_version(struct p9_client *c)
         char *version;
         int msize;
 
-        P9_DPRINTK(P9_DEBUG_9P, ">>> TVERSION msize %d extended %d\n",
-                                                        c->msize, c->dotu);
-        req = p9_client_rpc(c, P9_TVERSION, "ds", c->msize,
-                                c->dotu ? "9P2000.u" : "9P2000");
+        P9_DPRINTK(P9_DEBUG_9P, ">>> TVERSION msize %d protocol %d\n",
+                                                c->msize, c->proto_version);
+
+        switch (c->proto_version) {
+        case p9_proto_2000L:
+                req = p9_client_rpc(c, P9_TVERSION, "ds",
+                                        c->msize, "9P2000.L");
+                break;
+        case p9_proto_2000u:
+                req = p9_client_rpc(c, P9_TVERSION, "ds",
+                                        c->msize, "9P2000.u");
+                break;
+        case p9_proto_legacy:
+                req = p9_client_rpc(c, P9_TVERSION, "ds",
+                                        c->msize, "9P2000");
+                break;
+        default:
+                return -EINVAL;
+                break;
+        }
+
         if (IS_ERR(req))
                 return PTR_ERR(req);
 
-        err = p9pdu_readf(req->rc, c->dotu, "ds", &msize, &version);
+        err = p9pdu_readf(req->rc, c->proto_version, "ds", &msize, &version);
         if (err) {
                 P9_DPRINTK(P9_DEBUG_9P, "version error %d\n", err);
                 p9pdu_dump(1, req->rc);
@@ -642,10 +707,12 @@ int p9_client_version(struct p9_client *c)
         }
 
         P9_DPRINTK(P9_DEBUG_9P, "<<< RVERSION msize %d %s\n", msize, version);
-        if (!memcmp(version, "9P2000.u", 8))
-                c->dotu = 1;
-        else if (!memcmp(version, "9P2000", 6))
-                c->dotu = 0;
+        if (!strncmp(version, "9P2000.L", 8))
+                c->proto_version = p9_proto_2000L;
+        else if (!strncmp(version, "9P2000.u", 8))
+                c->proto_version = p9_proto_2000u;
+        else if (!strncmp(version, "9P2000", 6))
+                c->proto_version = p9_proto_legacy;
         else {
                 err = -EREMOTEIO;
                 goto error;
@@ -700,8 +767,8 @@ struct p9_client *p9_client_create(const char *dev_name, char *options)
                 goto put_trans;
         }
 
-        P9_DPRINTK(P9_DEBUG_MUX, "clnt %p trans %p msize %d dotu %d\n",
-                clnt, clnt->trans_mod, clnt->msize, clnt->dotu);
+        P9_DPRINTK(P9_DEBUG_MUX, "clnt %p trans %p msize %d protocol %d\n",
+                clnt, clnt->trans_mod, clnt->msize, clnt->proto_version);
 
         err = clnt->trans_mod->create(clnt, dev_name, options);
         if (err)
@@ -739,8 +806,10 @@ void p9_client_destroy(struct p9_client *clnt)
 
         v9fs_put_trans(clnt->trans_mod);
 
-        list_for_each_entry_safe(fid, fidptr, &clnt->fidlist, flist)
+        list_for_each_entry_safe(fid, fidptr, &clnt->fidlist, flist) {
+                printk(KERN_INFO "Found fid %d not clunked\n", fid->fid);
                 p9_fid_destroy(fid);
+        }
 
         if (clnt->fidpool)
                 p9_idpool_destroy(clnt->fidpool);
@@ -758,6 +827,13 @@ void p9_client_disconnect(struct p9_client *clnt)
 }
 EXPORT_SYMBOL(p9_client_disconnect);
 
+void p9_client_begin_disconnect(struct p9_client *clnt)
+{
+        P9_DPRINTK(P9_DEBUG_9P, "clnt %p\n", clnt);
+        clnt->status = BeginDisconnect;
+}
+EXPORT_SYMBOL(p9_client_begin_disconnect);
+
 struct p9_fid *p9_client_attach(struct p9_client *clnt, struct p9_fid *afid,
         char *uname, u32 n_uname, char *aname)
 {
@@ -784,7 +860,7 @@ struct p9_fid *p9_client_attach(struct p9_client *clnt, struct p9_fid *afid,
                 goto error;
         }
 
-        err = p9pdu_readf(req->rc, clnt->dotu, "Q", &qid);
+        err = p9pdu_readf(req->rc, clnt->proto_version, "Q", &qid);
         if (err) {
                 p9pdu_dump(1, req->rc);
                 p9_free_req(clnt, req);
@@ -833,7 +909,7 @@ p9_client_auth(struct p9_client *clnt, char *uname, u32 n_uname, char *aname)
                 goto error;
         }
 
-        err = p9pdu_readf(req->rc, clnt->dotu, "Q", &qid);
+        err = p9pdu_readf(req->rc, clnt->proto_version, "Q", &qid);
         if (err) {
                 p9pdu_dump(1, req->rc);
                 p9_free_req(clnt, req);
@@ -891,7 +967,7 @@ struct p9_fid *p9_client_walk(struct p9_fid *oldfid, int nwname, char **wnames,
                 goto error;
         }
 
-        err = p9pdu_readf(req->rc, clnt->dotu, "R", &nwqids, &wqids);
+        err = p9pdu_readf(req->rc, clnt->proto_version, "R", &nwqids, &wqids);
         if (err) {
                 p9pdu_dump(1, req->rc);
                 p9_free_req(clnt, req);
@@ -952,7 +1028,7 @@ int p9_client_open(struct p9_fid *fid, int mode)
                 goto error;
         }
 
-        err = p9pdu_readf(req->rc, clnt->dotu, "Qd", &qid, &iounit);
+        err = p9pdu_readf(req->rc, clnt->proto_version, "Qd", &qid, &iounit);
         if (err) {
                 p9pdu_dump(1, req->rc);
                 goto free_and_error;
@@ -997,7 +1073,7 @@ int p9_client_fcreate(struct p9_fid *fid, char *name, u32 perm, int mode,
                 goto error;
         }
 
-        err = p9pdu_readf(req->rc, clnt->dotu, "Qd", &qid, &iounit);
+        err = p9pdu_readf(req->rc, clnt->proto_version, "Qd", &qid, &iounit);
         if (err) {
                 p9pdu_dump(1, req->rc);
                 goto free_and_error;
@@ -1098,7 +1174,7 @@ p9_client_read(struct p9_fid *fid, char *data, char __user *udata, u64 offset,
                 goto error;
         }
 
-        err = p9pdu_readf(req->rc, clnt->dotu, "D", &count, &dataptr);
+        err = p9pdu_readf(req->rc, clnt->proto_version, "D", &count, &dataptr);
         if (err) {
                 p9pdu_dump(1, req->rc);
                 goto free_and_error;
@@ -1159,7 +1235,7 @@ p9_client_write(struct p9_fid *fid, char *data, const char __user *udata,
                 goto error;
         }
 
-        err = p9pdu_readf(req->rc, clnt->dotu, "d", &count);
+        err = p9pdu_readf(req->rc, clnt->proto_version, "d", &count);
         if (err) {
                 p9pdu_dump(1, req->rc);
                 goto free_and_error;
@@ -1199,7 +1275,7 @@ struct p9_wstat *p9_client_stat(struct p9_fid *fid)
                 goto error;
         }
 
-        err = p9pdu_readf(req->rc, clnt->dotu, "wS", &ignored, ret);
+        err = p9pdu_readf(req->rc, clnt->proto_version, "wS", &ignored, ret);
         if (err) {
                 p9pdu_dump(1, req->rc);
                 p9_free_req(clnt, req);
@@ -1226,7 +1302,7 @@ error:
 }
 EXPORT_SYMBOL(p9_client_stat);
 
-static int p9_client_statsize(struct p9_wstat *wst, int optional)
+static int p9_client_statsize(struct p9_wstat *wst, int proto_version)
 {
         int ret;
 
@@ -1245,7 +1321,7 @@ static int p9_client_statsize(struct p9_wstat *wst, int optional)
         if (wst->muid)
                 ret += strlen(wst->muid);
 
-        if (optional) {
+        if (proto_version == p9_proto_2000u) {
                 ret += 2+4+4+4; /* extension[s] n_uid[4] n_gid[4] n_muid[4] */
                 if (wst->extension)
                         ret += strlen(wst->extension);
@@ -1262,7 +1338,7 @@ int p9_client_wstat(struct p9_fid *fid, struct p9_wstat *wst)
 
         err = 0;
         clnt = fid->clnt;
-        wst->size = p9_client_statsize(wst, clnt->dotu);
+        wst->size = p9_client_statsize(wst, clnt->proto_version);
         P9_DPRINTK(P9_DEBUG_9P, ">>> TWSTAT fid %d\n", fid->fid);
         P9_DPRINTK(P9_DEBUG_9P,
                 "     sz=%x type=%x dev=%x qid=%x.%llx.%x\n"
diff --git a/net/9p/protocol.c b/net/9p/protocol.c
index fc70147c771e..e7541d5b0118 100644
--- a/net/9p/protocol.c
+++ b/net/9p/protocol.c
@@ -28,6 +28,7 @@
 #include <linux/module.h>
 #include <linux/errno.h>
 #include <linux/uaccess.h>
+#include <linux/slab.h>
 #include <linux/sched.h>
 #include <linux/types.h>
 #include <net/9p/9p.h>
@@ -52,7 +53,7 @@
 #endif
 
 static int
-p9pdu_writef(struct p9_fcall *pdu, int optional, const char *fmt, ...);
+p9pdu_writef(struct p9_fcall *pdu, int proto_version, const char *fmt, ...);
 
 #ifdef CONFIG_NET_9P_DEBUG
 void
@@ -144,7 +145,8 @@ pdu_write_u(struct p9_fcall *pdu, const char __user *udata, size_t size)
 */
 
 static int
-p9pdu_vreadf(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
+p9pdu_vreadf(struct p9_fcall *pdu, int proto_version, const char *fmt,
+        va_list ap)
 {
         const char *ptr;
         int errcode = 0;
@@ -194,7 +196,8 @@ p9pdu_vreadf(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
                                 int16_t len;
                                 int size;
 
-                                errcode = p9pdu_readf(pdu, optional, "w", &len);
+                                errcode = p9pdu_readf(pdu, proto_version,
+                                                                "w", &len);
                                 if (errcode)
                                         break;
 
@@ -217,7 +220,7 @@ p9pdu_vreadf(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
                                 struct p9_qid *qid =
                                     va_arg(ap, struct p9_qid *);
 
-                                errcode = p9pdu_readf(pdu, optional, "bdq",
+                                errcode = p9pdu_readf(pdu, proto_version, "bdq",
                                                       &qid->type, &qid->version,
                                                       &qid->path);
                         }
@@ -230,7 +233,7 @@ p9pdu_vreadf(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
                                 stbuf->n_uid = stbuf->n_gid = stbuf->n_muid =
                                                                         -1;
                                 errcode =
-                                    p9pdu_readf(pdu, optional,
+                                    p9pdu_readf(pdu, proto_version,
                                                 "wwdQdddqssss?sddd",
                                                 &stbuf->size, &stbuf->type,
                                                 &stbuf->dev, &stbuf->qid,
@@ -250,7 +253,7 @@ p9pdu_vreadf(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
                                 void **data = va_arg(ap, void **);
 
                                 errcode =
-                                    p9pdu_readf(pdu, optional, "d", count);
+                                    p9pdu_readf(pdu, proto_version, "d", count);
                                 if (!errcode) {
                                         *count =
                                             MIN(*count,
@@ -263,8 +266,8 @@ p9pdu_vreadf(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
                                 int16_t *nwname = va_arg(ap, int16_t *);
                                 char ***wnames = va_arg(ap, char ***);
 
-                                errcode =
-                                    p9pdu_readf(pdu, optional, "w", nwname);
+                                errcode = p9pdu_readf(pdu, proto_version,
+                                                                "w", nwname);
                                 if (!errcode) {
                                         *wnames =
                                             kmalloc(sizeof(char *) * *nwname,
@@ -278,7 +281,8 @@ p9pdu_vreadf(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
 
                                         for (i = 0; i < *nwname; i++) {
                                                 errcode =
-                                                    p9pdu_readf(pdu, optional,
+                                                    p9pdu_readf(pdu,
+                                                                proto_version,
                                                                 "s",
                                                                 &(*wnames)[i]);
                                                 if (errcode)
@@ -306,7 +310,7 @@ p9pdu_vreadf(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
                                 *wqids = NULL;
 
                                 errcode =
-                                    p9pdu_readf(pdu, optional, "w", nwqid);
+                                    p9pdu_readf(pdu, proto_version, "w", nwqid);
                                 if (!errcode) {
                                         *wqids =
                                             kmalloc(*nwqid *
@@ -321,7 +325,8 @@ p9pdu_vreadf(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
 
                                         for (i = 0; i < *nwqid; i++) {
                                                 errcode =
-                                                    p9pdu_readf(pdu, optional,
+                                                    p9pdu_readf(pdu,
+                                                                proto_version,
                                                                 "Q",
                                                                 &(*wqids)[i]);
                                                 if (errcode)
@@ -336,7 +341,7 @@ p9pdu_vreadf(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
                         }
                         break;
                 case '?':
-                        if (!optional)
+                        if (proto_version != p9_proto_2000u)
                                 return 0;
                         break;
                 default:
@@ -352,7 +357,8 @@ p9pdu_vreadf(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
 }
 
 int
-p9pdu_vwritef(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
+p9pdu_vwritef(struct p9_fcall *pdu, int proto_version, const char *fmt,
+        va_list ap)
 {
         const char *ptr;
         int errcode = 0;
@@ -389,7 +395,8 @@ p9pdu_vwritef(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
                                 if (sptr)
                                         len = MIN(strlen(sptr), USHORT_MAX);
 
-                                errcode = p9pdu_writef(pdu, optional, "w", len);
+                                errcode = p9pdu_writef(pdu, proto_version,
+                                                                "w", len);
                                 if (!errcode && pdu_write(pdu, sptr, len))
                                         errcode = -EFAULT;
                         }
@@ -398,7 +405,7 @@ p9pdu_vwritef(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
                                 const struct p9_qid *qid =
                                     va_arg(ap, const struct p9_qid *);
                                 errcode =
-                                    p9pdu_writef(pdu, optional, "bdq",
+                                    p9pdu_writef(pdu, proto_version, "bdq",
                                                  qid->type, qid->version,
                                                  qid->path);
                         } break;
@@ -406,7 +413,7 @@ p9pdu_vwritef(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
                                 const struct p9_wstat *stbuf =
                                     va_arg(ap, const struct p9_wstat *);
                                 errcode =
-                                    p9pdu_writef(pdu, optional,
+                                    p9pdu_writef(pdu, proto_version,
                                                  "wwdQdddqssss?sddd",
                                                  stbuf->size, stbuf->type,
                                                  stbuf->dev, &stbuf->qid,
@@ -421,8 +428,8 @@ p9pdu_vwritef(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
                                 int32_t count = va_arg(ap, int32_t);
                                 const void *data = va_arg(ap, const void *);
 
-                                errcode =
-                                    p9pdu_writef(pdu, optional, "d", count);
+                                errcode = p9pdu_writef(pdu, proto_version, "d",
+                                                                        count);
                                 if (!errcode && pdu_write(pdu, data, count))
                                         errcode = -EFAULT;
                         }
@@ -431,8 +438,8 @@ p9pdu_vwritef(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
                                 int32_t count = va_arg(ap, int32_t);
                                 const char __user *udata =
                                                 va_arg(ap, const void __user *);
-                                errcode =
-                                    p9pdu_writef(pdu, optional, "d", count);
+                                errcode = p9pdu_writef(pdu, proto_version, "d",
+                                                                        count);
                                 if (!errcode && pdu_write_u(pdu, udata, count))
                                         errcode = -EFAULT;
                         }
@@ -441,14 +448,15 @@ p9pdu_vwritef(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
                                 int16_t nwname = va_arg(ap, int);
                                 const char **wnames = va_arg(ap, const char **);
 
-                                errcode =
-                                    p9pdu_writef(pdu, optional, "w", nwname);
+                                errcode = p9pdu_writef(pdu, proto_version, "w",
+                                                                        nwname);
                                 if (!errcode) {
                                         int i;
 
                                         for (i = 0; i < nwname; i++) {
                                                 errcode =
-                                                    p9pdu_writef(pdu, optional,
+                                                    p9pdu_writef(pdu,
+                                                                proto_version,
                                                                  "s",
                                                                  wnames[i]);
                                                 if (errcode)
@@ -462,14 +470,15 @@ p9pdu_vwritef(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
                                 struct p9_qid *wqids =
                                     va_arg(ap, struct p9_qid *);
 
-                                errcode =
-                                    p9pdu_writef(pdu, optional, "w", nwqid);
+                                errcode = p9pdu_writef(pdu, proto_version, "w",
+                                                                        nwqid);
                                 if (!errcode) {
                                         int i;
 
                                         for (i = 0; i < nwqid; i++) {
                                                 errcode =
-                                                    p9pdu_writef(pdu, optional,
+                                                    p9pdu_writef(pdu,
+                                                                proto_version,
                                                                  "Q",
                                                                  &wqids[i]);
                                                 if (errcode)
@@ -479,7 +488,7 @@ p9pdu_vwritef(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
                         }
                         break;
                 case '?':
-                        if (!optional)
+                        if (proto_version != p9_proto_2000u)
                                 return 0;
                         break;
                 default:
@@ -494,32 +503,32 @@ p9pdu_vwritef(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap)
         return errcode;
 }
 
-int p9pdu_readf(struct p9_fcall *pdu, int optional, const char *fmt, ...)
+int p9pdu_readf(struct p9_fcall *pdu, int proto_version, const char *fmt, ...)
 {
         va_list ap;
         int ret;
 
         va_start(ap, fmt);
-        ret = p9pdu_vreadf(pdu, optional, fmt, ap);
+        ret = p9pdu_vreadf(pdu, proto_version, fmt, ap);
         va_end(ap);
 
         return ret;
 }
 
 static int
-p9pdu_writef(struct p9_fcall *pdu, int optional, const char *fmt, ...)
+p9pdu_writef(struct p9_fcall *pdu, int proto_version, const char *fmt, ...)
 {
         va_list ap;
         int ret;
 
         va_start(ap, fmt);
-        ret = p9pdu_vwritef(pdu, optional, fmt, ap);
+        ret = p9pdu_vwritef(pdu, proto_version, fmt, ap);
         va_end(ap);
 
         return ret;
 }
 
-int p9stat_read(char *buf, int len, struct p9_wstat *st, int dotu)
+int p9stat_read(char *buf, int len, struct p9_wstat *st, int proto_version)
 {
         struct p9_fcall fake_pdu;
         int ret;
@@ -529,7 +538,7 @@ int p9stat_read(char *buf, int len, struct p9_wstat *st, int dotu)
         fake_pdu.sdata = buf;
         fake_pdu.offset = 0;
 
-        ret = p9pdu_readf(&fake_pdu, dotu, "S", st);
+        ret = p9pdu_readf(&fake_pdu, proto_version, "S", st);
         if (ret) {
                 P9_DPRINTK(P9_DEBUG_9P, "<<< p9stat_read failed: %d\n", ret);
                 p9pdu_dump(1, &fake_pdu);
diff --git a/net/9p/protocol.h b/net/9p/protocol.h
index ccde462e7ac5..2431c0f38d56 100644
--- a/net/9p/protocol.h
+++ b/net/9p/protocol.h
@@ -25,9 +25,9 @@
  *
  */
 
-int
-p9pdu_vwritef(struct p9_fcall *pdu, int optional, const char *fmt, va_list ap);
-int p9pdu_readf(struct p9_fcall *pdu, int optional, const char *fmt, ...);
+int p9pdu_vwritef(struct p9_fcall *pdu, int proto_version, const char *fmt,
+                                                                va_list ap);
+int p9pdu_readf(struct p9_fcall *pdu, int proto_version, const char *fmt, ...);
 int p9pdu_prepare(struct p9_fcall *pdu, int16_t tag, int8_t type);
 int p9pdu_finalize(struct p9_fcall *pdu);
 void p9pdu_dump(int, struct p9_fcall *);
diff --git a/net/9p/trans_fd.c b/net/9p/trans_fd.c
index 31d0b05582a9..98ce9bcb0e15 100644
--- a/net/9p/trans_fd.c
+++ b/net/9p/trans_fd.c
@@ -38,6 +38,7 @@
 #include <linux/idr.h>
 #include <linux/file.h>
 #include <linux/parser.h>
+#include <linux/slab.h>
 #include <net/9p/9p.h>
 #include <net/9p/client.h>
 #include <net/9p/transport.h>
diff --git a/net/9p/trans_rdma.c b/net/9p/trans_rdma.c
index 2c95a89c0f46..041101ab4aa5 100644
--- a/net/9p/trans_rdma.c
+++ b/net/9p/trans_rdma.c
@@ -40,6 +40,7 @@
 #include <linux/file.h>
 #include <linux/parser.h>
 #include <linux/semaphore.h>
+#include <linux/slab.h>
 #include <net/9p/9p.h>
 #include <net/9p/client.h>
 #include <net/9p/transport.h>
diff --git a/net/9p/trans_virtio.c b/net/9p/trans_virtio.c
index cb50f4ae5eef..7eb78ecc1618 100644
--- a/net/9p/trans_virtio.c
+++ b/net/9p/trans_virtio.c
@@ -37,6 +37,7 @@
 #include <linux/inet.h>
 #include <linux/idr.h>
 #include <linux/file.h>
+#include <linux/slab.h>
 #include <net/9p/9p.h>
 #include <linux/parser.h>
 #include <net/9p/client.h>
@@ -49,8 +50,6 @@
 
 /* a single mutex to manage channel initialization and attachment */
 static DEFINE_MUTEX(virtio_9p_lock);
-/* global which tracks highest initialized channel */
-static int chan_index;
 
 /**
  * struct virtio_chan - per-instance transport information
@@ -68,8 +67,7 @@ static int chan_index;
  *
  */
 
-static struct virtio_chan {
-        bool initialized;
+struct virtio_chan {
         bool inuse;
 
         spinlock_t lock;
@@ -80,7 +78,17 @@ static struct virtio_chan {
 
         /* Scatterlist: can be too big for stack. */
         struct scatterlist sg[VIRTQUEUE_NUM];
-} channels[MAX_9P_CHAN];
+
+        int tag_len;
+        /*
+         * tag name to identify a mount Non-null terminated
+         */
+        char *tag;
+
+        struct list_head chan_list;
+};
+
+static struct list_head virtio_chan_list;
 
 /* How many bytes left in this page. */
 static unsigned int rest_of_page(void *data)
@@ -213,30 +221,38 @@ p9_virtio_request(struct p9_client *client, struct p9_req_t *req)
         return 0;
 }
 
+static ssize_t p9_mount_tag_show(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        struct virtio_chan *chan;
+        struct virtio_device *vdev;
+
+        vdev = dev_to_virtio(dev);
+        chan = vdev->priv;
+
+        return snprintf(buf, chan->tag_len + 1, "%s", chan->tag);
+}
+
+static DEVICE_ATTR(mount_tag, 0444, p9_mount_tag_show, NULL);
+
 /**
  * p9_virtio_probe - probe for existence of 9P virtio channels
  * @vdev: virtio device to probe
  *
- * This probes for existing virtio channels.  At present only
- * a single channel is in use, so in the future more work may need
- * to be done here.
+ * This probes for existing virtio channels.
  *
  */
 
 static int p9_virtio_probe(struct virtio_device *vdev)
 {
+        __u16 tag_len;
+        char *tag;
         int err;
         struct virtio_chan *chan;
-        int index;
 
-        mutex_lock(&virtio_9p_lock);
-        index = chan_index++;
-        chan = &channels[index];
-        mutex_unlock(&virtio_9p_lock);
-
-        if (chan_index > MAX_9P_CHAN) {
-                printk(KERN_ERR "9p: virtio: Maximum channels exceeded\n");
-                BUG();
+        chan = kmalloc(sizeof(struct virtio_chan), GFP_KERNEL);
+        if (!chan) {
+                printk(KERN_ERR "9p: Failed to allocate virtio 9P channel\n");
                 err = -ENOMEM;
                 goto fail;
         }
@@ -255,15 +271,37 @@ static int p9_virtio_probe(struct virtio_device *vdev)
         sg_init_table(chan->sg, VIRTQUEUE_NUM);
 
         chan->inuse = false;
-        chan->initialized = true;
+        if (virtio_has_feature(vdev, VIRTIO_9P_MOUNT_TAG)) {
+                vdev->config->get(vdev,
+                                offsetof(struct virtio_9p_config, tag_len),
+                                &tag_len, sizeof(tag_len));
+        } else {
+                err = -EINVAL;
+                goto out_free_vq;
+        }
+        tag = kmalloc(tag_len, GFP_KERNEL);
+        if (!tag) {
+                err = -ENOMEM;
+                goto out_free_vq;
+        }
+        vdev->config->get(vdev, offsetof(struct virtio_9p_config, tag),
+                        tag, tag_len);
+        chan->tag = tag;
+        chan->tag_len = tag_len;
+        err = sysfs_create_file(&(vdev->dev.kobj), &dev_attr_mount_tag.attr);
+        if (err) {
+                kfree(tag);
+                goto out_free_vq;
+        }
+        mutex_lock(&virtio_9p_lock);
+        list_add_tail(&chan->chan_list, &virtio_chan_list);
+        mutex_unlock(&virtio_9p_lock);
         return 0;
 
 out_free_vq:
         vdev->config->del_vqs(vdev);
+        kfree(chan);
 fail:
-        mutex_lock(&virtio_9p_lock);
-        chan_index--;
-        mutex_unlock(&virtio_9p_lock);
         return err;
 }
 
@@ -280,35 +318,31 @@ fail:
  * We use a simple reference count mechanism to ensure that only a single
  * mount has a channel open at a time.
  *
- * Bugs: doesn't allow identification of a specific channel
- * to allocate, channels are allocated sequentially. This was
- * a pragmatic decision to get things rolling, but ideally some
- * way of identifying the channel to attach to would be nice
- * if we are going to support multiple channels.
- *
  */
 
 static int
 p9_virtio_create(struct p9_client *client, const char *devname, char *args)
 {
-        struct virtio_chan *chan = channels;
-        int index = 0;
+        struct virtio_chan *chan;
+        int ret = -ENOENT;
+        int found = 0;
 
         mutex_lock(&virtio_9p_lock);
-        while (index < MAX_9P_CHAN) {
-                if (chan->initialized && !chan->inuse) {
-                        chan->inuse = true;
-                        break;
-                } else {
-                        index++;
-                        chan = &channels[index];
+        list_for_each_entry(chan, &virtio_chan_list, chan_list) {
+                if (!strncmp(devname, chan->tag, chan->tag_len)) {
+                        if (!chan->inuse) {
+                                chan->inuse = true;
+                                found = 1;
+                                break;
+                        }
+                        ret = -EBUSY;
                 }
         }
         mutex_unlock(&virtio_9p_lock);
 
-        if (index >= MAX_9P_CHAN) {
+        if (!found) {
                 printk(KERN_ERR "9p: no channels available\n");
-                return -ENODEV;
+                return ret;
         }
 
         client->trans = (void *)chan;
@@ -329,11 +363,15 @@ static void p9_virtio_remove(struct virtio_device *vdev)
         struct virtio_chan *chan = vdev->priv;
 
         BUG_ON(chan->inuse);
+        vdev->config->del_vqs(vdev);
+
+        mutex_lock(&virtio_9p_lock);
+        list_del(&chan->chan_list);
+        mutex_unlock(&virtio_9p_lock);
+        sysfs_remove_file(&(vdev->dev.kobj), &dev_attr_mount_tag.attr);
+        kfree(chan->tag);
+        kfree(chan);
 
-        if (chan->initialized) {
-                vdev->config->del_vqs(vdev);
-                chan->initialized = false;
-        }
 }
 
 static struct virtio_device_id id_table[] = {
@@ -341,13 +379,19 @@ static struct virtio_device_id id_table[] = {
         { 0 },
 };
 
+static unsigned int features[] = {
+        VIRTIO_9P_MOUNT_TAG,
+};
+
 /* The standard "struct lguest_driver": */
 static struct virtio_driver p9_virtio_drv = {
-        .driver.name =  KBUILD_MODNAME,
-        .driver.owner = THIS_MODULE,
-        .id_table =     id_table,
-        .probe =        p9_virtio_probe,
-        .remove =       p9_virtio_remove,
+        .feature_table  = features,
+        .feature_table_size = ARRAY_SIZE(features),
+        .driver.name    = KBUILD_MODNAME,
+        .driver.owner   = THIS_MODULE,
+        .id_table       = id_table,
+        .probe          = p9_virtio_probe,
+        .remove         = p9_virtio_remove,
 };
 
 static struct p9_trans_module p9_virtio_trans = {
@@ -364,10 +408,7 @@ static struct p9_trans_module p9_virtio_trans = {
 /* The standard init function */
 static int __init p9_virtio_init(void)
 {
-        int count;
-
-        for (count = 0; count < MAX_9P_CHAN; count++)
-                channels[count].initialized = false;
+        INIT_LIST_HEAD(&virtio_chan_list);
 
         v9fs_register_trans(&p9_virtio_trans);
         return register_virtio_driver(&p9_virtio_drv);
diff --git a/net/9p/util.c b/net/9p/util.c
index dc4ec05ad93d..e048701a72d2 100644
--- a/net/9p/util.c
+++ b/net/9p/util.c
@@ -30,6 +30,7 @@
 #include <linux/sched.h>
 #include <linux/parser.h>
 #include <linux/idr.h>
+#include <linux/slab.h>
 #include <net/9p/9p.h>
 
 /**
diff --git a/net/Kconfig b/net/Kconfig
index 041c35edb763..0d68b40fc0e6 100644
--- a/net/Kconfig
+++ b/net/Kconfig
@@ -186,6 +186,7 @@ source "net/sctp/Kconfig"
 source "net/rds/Kconfig"
 source "net/tipc/Kconfig"
 source "net/atm/Kconfig"
+source "net/l2tp/Kconfig"
 source "net/802/Kconfig"
 source "net/bridge/Kconfig"
 source "net/dsa/Kconfig"
@@ -203,6 +204,11 @@ source "net/ieee802154/Kconfig"
 source "net/sched/Kconfig"
 source "net/dcb/Kconfig"
 
+config RPS
+        boolean
+        depends on SMP && SYSFS
+        default y
+
 menu "Network testing"
 
 config NET_PKTGEN
@@ -275,5 +281,7 @@ source "net/wimax/Kconfig"
 
 source "net/rfkill/Kconfig"
 source "net/9p/Kconfig"
+source "net/caif/Kconfig"
+
 
 endif   # if NET
diff --git a/net/Makefile b/net/Makefile
index 1542e7268a7b..cb7bdc1210cb 100644
--- a/net/Makefile
+++ b/net/Makefile
@@ -40,6 +40,7 @@ obj-$(CONFIG_BT)		+= bluetooth/
 obj-$(CONFIG_SUNRPC)            += sunrpc/
 obj-$(CONFIG_AF_RXRPC)          += rxrpc/
 obj-$(CONFIG_ATM)               += atm/
+obj-$(CONFIG_L2TP)              += l2tp/
 obj-$(CONFIG_DECNET)            += decnet/
 obj-$(CONFIG_ECONET)            += econet/
 obj-$(CONFIG_PHONET)            += phonet/
@@ -56,6 +57,7 @@ obj-$(CONFIG_NETLABEL)		+= netlabel/
 obj-$(CONFIG_IUCV)              += iucv/
 obj-$(CONFIG_RFKILL)            += rfkill/
 obj-$(CONFIG_NET_9P)            += 9p/
+obj-$(CONFIG_CAIF)              += caif/
 ifneq ($(CONFIG_DCB),)
 obj-y                           += dcb/
 endif
diff --git a/net/appletalk/aarp.c b/net/appletalk/aarp.c
index f2b3b56aa779..50dce7981321 100644
--- a/net/appletalk/aarp.c
+++ b/net/appletalk/aarp.c
@@ -30,6 +30,7 @@
  */
 
 #include <linux/if_arp.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 #include <net/datalink.h>
 #include <net/psnap.h>
diff --git a/net/appletalk/ddp.c b/net/appletalk/ddp.c
index 9fc4da56fb1d..c410b93fda2e 100644
--- a/net/appletalk/ddp.c
+++ b/net/appletalk/ddp.c
@@ -57,6 +57,7 @@
 #include <linux/smp_lock.h>
 #include <linux/termios.h>      /* For TIOCOUTQ/INQ */
 #include <linux/compat.h>
+#include <linux/slab.h>
 #include <net/datalink.h>
 #include <net/psnap.h>
 #include <net/sock.h>
@@ -781,7 +782,7 @@ static int atif_ioctl(int cmd, void __user *arg)
                                                 atrtr_create(&rtdef, dev);
                                         }
                         }
-                        dev_mc_add(dev, aarp_mcast, 6, 1);
+                        dev_mc_add_global(dev, aarp_mcast);
                         return 0;
 
                 case SIOCGIFADDR:
diff --git a/net/atm/addr.c b/net/atm/addr.c
index cf3ae8b47572..dcda35c66f15 100644
--- a/net/atm/addr.c
+++ b/net/atm/addr.c
@@ -4,6 +4,7 @@
 
 #include <linux/atm.h>
 #include <linux/atmdev.h>
+#include <linux/slab.h>
 #include <linux/uaccess.h>
 
 #include "signaling.h"
diff --git a/net/atm/atm_sysfs.c b/net/atm/atm_sysfs.c
index f693b78eb467..799c631f0fed 100644
--- a/net/atm/atm_sysfs.c
+++ b/net/atm/atm_sysfs.c
@@ -1,6 +1,7 @@
 /* ATM driver model support. */
 
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/kobject.h>
 #include <linux/atmdev.h>
diff --git a/net/atm/br2684.c b/net/atm/br2684.c
index 4d64d87e7578..d6c7ceaf13e9 100644
--- a/net/atm/br2684.c
+++ b/net/atm/br2684.c
@@ -18,6 +18,7 @@
 #include <linux/rtnetlink.h>
 #include <linux/ip.h>
 #include <linux/uaccess.h>
+#include <linux/slab.h>
 #include <net/arp.h>
 #include <linux/atm.h>
 #include <linux/atmdev.h>
diff --git a/net/atm/clip.c b/net/atm/clip.c
index ebfa022008f7..313aba11316b 100644
--- a/net/atm/clip.c
+++ b/net/atm/clip.c
@@ -30,6 +30,7 @@
 #include <linux/seq_file.h>
 #include <linux/rcupdate.h>
 #include <linux/jhash.h>
+#include <linux/slab.h>
 #include <net/route.h> /* for struct rtable and routing */
 #include <net/icmp.h> /* icmp_send */
 #include <linux/param.h> /* for HZ */
diff --git a/net/atm/common.c b/net/atm/common.c
index 74d095a081e3..b43feb1a3995 100644
--- a/net/atm/common.c
+++ b/net/atm/common.c
@@ -18,6 +18,7 @@
 #include <linux/skbuff.h>
 #include <linux/bitops.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <net/sock.h>           /* struct sock */
 #include <linux/uaccess.h>
 #include <linux/poll.h>
@@ -89,10 +90,13 @@ static void vcc_sock_destruct(struct sock *sk)
 
 static void vcc_def_wakeup(struct sock *sk)
 {
-        read_lock(&sk->sk_callback_lock);
-        if (sk_has_sleeper(sk))
-                wake_up(sk->sk_sleep);
-        read_unlock(&sk->sk_callback_lock);
+        struct socket_wq *wq;
+
+        rcu_read_lock();
+        wq = rcu_dereference(sk->sk_wq);
+        if (wq_has_sleeper(wq))
+                wake_up(&wq->wait);
+        rcu_read_unlock();
 }
 
 static inline int vcc_writable(struct sock *sk)
@@ -105,16 +109,19 @@ static inline int vcc_writable(struct sock *sk)
 
 static void vcc_write_space(struct sock *sk)
 {
-        read_lock(&sk->sk_callback_lock);
+        struct socket_wq *wq;
+
+        rcu_read_lock();
 
         if (vcc_writable(sk)) {
-                if (sk_has_sleeper(sk))
-                        wake_up_interruptible(sk->sk_sleep);
+                wq = rcu_dereference(sk->sk_wq);
+                if (wq_has_sleeper(wq))
+                        wake_up_interruptible(&wq->wait);
 
                 sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
         }
 
-        read_unlock(&sk->sk_callback_lock);
+        rcu_read_unlock();
 }
 
 static struct proto vcc_proto = {
@@ -548,7 +555,7 @@ int vcc_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m,
         }
 
         eff = (size+3) & ~3; /* align to word boundary */
-        prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+        prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
         error = 0;
         while (!(skb = alloc_tx(vcc, eff))) {
                 if (m->msg_flags & MSG_DONTWAIT) {
@@ -567,9 +574,9 @@ int vcc_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m,
                         send_sig(SIGPIPE, current, 0);
                         break;
                 }
-                prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+                prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
         }
-        finish_wait(sk->sk_sleep, &wait);
+        finish_wait(sk_sleep(sk), &wait);
         if (error)
                 goto out;
         skb->dev = NULL; /* for paths shared with net_device interfaces */
@@ -594,7 +601,7 @@ unsigned int vcc_poll(struct file *file, struct socket *sock, poll_table *wait)
         struct atm_vcc *vcc;
         unsigned int mask;
 
-        sock_poll_wait(file, sk->sk_sleep, wait);
+        sock_poll_wait(file, sk_sleep(sk), wait);
         mask = 0;
 
         vcc = ATM_SD(sock);
diff --git a/net/atm/lec.c b/net/atm/lec.c
index 5da5753157f9..feeaf5718472 100644
--- a/net/atm/lec.c
+++ b/net/atm/lec.c
@@ -6,6 +6,7 @@
 
 #define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__
 
+#include <linux/slab.h>
 #include <linux/kernel.h>
 #include <linux/bitops.h>
 #include <linux/capability.h>
diff --git a/net/atm/mpc.c b/net/atm/mpc.c
index a6521c8aa88b..436f2e177657 100644
--- a/net/atm/mpc.c
+++ b/net/atm/mpc.c
@@ -2,6 +2,7 @@
 
 #include <linux/kernel.h>
 #include <linux/string.h>
+#include <linux/slab.h>
 #include <linux/timer.h>
 #include <linux/init.h>
 #include <linux/bitops.h>
diff --git a/net/atm/mpoa_caches.c b/net/atm/mpoa_caches.c
index 4c141810eb6d..e773d8336918 100644
--- a/net/atm/mpoa_caches.c
+++ b/net/atm/mpoa_caches.c
@@ -1,5 +1,6 @@
 #include <linux/types.h>
 #include <linux/atmmpc.h>
+#include <linux/slab.h>
 #include <linux/time.h>
 
 #include "mpoa_caches.h"
diff --git a/net/atm/mpoa_proc.c b/net/atm/mpoa_proc.c
index b9bdb98427e4..53e500292271 100644
--- a/net/atm/mpoa_proc.c
+++ b/net/atm/mpoa_proc.c
@@ -12,6 +12,7 @@
 #include <linux/uaccess.h>
 #include <linux/atmmpc.h>
 #include <linux/atm.h>
+#include <linux/gfp.h>
 #include "mpc.h"
 #include "mpoa_caches.h"
 
diff --git a/net/atm/pppoatm.c b/net/atm/pppoatm.c
index 400839273c67..e49bb6d948a1 100644
--- a/net/atm/pppoatm.c
+++ b/net/atm/pppoatm.c
@@ -38,6 +38,7 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/skbuff.h>
+#include <linux/slab.h>
 #include <linux/atm.h>
 #include <linux/atmdev.h>
 #include <linux/capability.h>
diff --git a/net/atm/proc.c b/net/atm/proc.c
index 7a96b2376bd7..6262aeae398e 100644
--- a/net/atm/proc.c
+++ b/net/atm/proc.c
@@ -22,6 +22,7 @@
 #include <linux/netdevice.h>
 #include <linux/atmclip.h>
 #include <linux/init.h> /* for __init */
+#include <linux/slab.h>
 #include <net/net_namespace.h>
 #include <net/atmclip.h>
 #include <linux/uaccess.h>
@@ -406,7 +407,6 @@ EXPORT_SYMBOL(atm_proc_root);
 
 int atm_proc_dev_register(struct atm_dev *dev)
 {
-        int digits, num;
         int error;
 
         /* No proc info */
@@ -414,16 +414,9 @@ int atm_proc_dev_register(struct atm_dev *dev)
                 return 0;
 
         error = -ENOMEM;
-        digits = 0;
-        for (num = dev->number; num; num /= 10)
-                digits++;
-        if (!digits)
-                digits++;
-
-        dev->proc_name = kmalloc(strlen(dev->type) + digits + 2, GFP_KERNEL);
+        dev->proc_name = kasprintf(GFP_KERNEL, "%s:%d", dev->type, dev->number);
         if (!dev->proc_name)
                 goto err_out;
-        sprintf(dev->proc_name, "%s:%d", dev->type, dev->number);
 
         dev->proc_entry = proc_create_data(dev->proc_name, 0, atm_proc_root,
                                            &proc_atm_dev_ops, dev);
diff --git a/net/atm/raw.c b/net/atm/raw.c
index d0c4bd047dc4..b4f7b9ff3c74 100644
--- a/net/atm/raw.c
+++ b/net/atm/raw.c
@@ -10,6 +10,7 @@
 #include <linux/kernel.h>
 #include <linux/skbuff.h>
 #include <linux/mm.h>
+#include <linux/slab.h>
 
 #include "common.h"
 #include "protocols.h"
diff --git a/net/atm/resources.c b/net/atm/resources.c
index 90082904f20d..d29e58261511 100644
--- a/net/atm/resources.c
+++ b/net/atm/resources.c
@@ -19,6 +19,7 @@
 #include <linux/capability.h>
 #include <linux/delay.h>
 #include <linux/mutex.h>
+#include <linux/slab.h>
 
 #include <net/sock.h>    /* for struct sock */
 
diff --git a/net/atm/signaling.c b/net/atm/signaling.c
index ad1d28ae512b..509c8ac02b63 100644
--- a/net/atm/signaling.c
+++ b/net/atm/signaling.c
@@ -14,6 +14,7 @@
 #include <linux/atmsvc.h>
 #include <linux/atmdev.h>
 #include <linux/bitops.h>
+#include <linux/slab.h>
 
 #include "resources.h"
 #include "signaling.h"
@@ -130,7 +131,7 @@ static int sigd_send(struct atm_vcc *vcc, struct sk_buff *skb)
                 }
                 sk->sk_ack_backlog++;
                 skb_queue_tail(&sk->sk_receive_queue, skb);
-                pr_debug("waking sk->sk_sleep 0x%p\n", sk->sk_sleep);
+                pr_debug("waking sk_sleep(sk) 0x%p\n", sk_sleep(sk));
                 sk->sk_state_change(sk);
 as_indicate_complete:
                 release_sock(sk);
diff --git a/net/atm/svc.c b/net/atm/svc.c
index 3ba9a45a51ac..754ee4791d96 100644
--- a/net/atm/svc.c
+++ b/net/atm/svc.c
@@ -49,14 +49,14 @@ static void svc_disconnect(struct atm_vcc *vcc)
 
         pr_debug("%p\n", vcc);
         if (test_bit(ATM_VF_REGIS, &vcc->flags)) {
-                prepare_to_wait(sk->sk_sleep, &wait, TASK_UNINTERRUPTIBLE);
+                prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE);
                 sigd_enq(vcc, as_close, NULL, NULL, NULL);
                 while (!test_bit(ATM_VF_RELEASED, &vcc->flags) && sigd) {
                         schedule();
-                        prepare_to_wait(sk->sk_sleep, &wait,
+                        prepare_to_wait(sk_sleep(sk), &wait,
                                         TASK_UNINTERRUPTIBLE);
                 }
-                finish_wait(sk->sk_sleep, &wait);
+                finish_wait(sk_sleep(sk), &wait);
         }
         /* beware - socket is still in use by atmsigd until the last
            as_indicate has been answered */
@@ -125,13 +125,13 @@ static int svc_bind(struct socket *sock, struct sockaddr *sockaddr,
         }
         vcc->local = *addr;
         set_bit(ATM_VF_WAITING, &vcc->flags);
-        prepare_to_wait(sk->sk_sleep, &wait, TASK_UNINTERRUPTIBLE);
+        prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE);
         sigd_enq(vcc, as_bind, NULL, NULL, &vcc->local);
         while (test_bit(ATM_VF_WAITING, &vcc->flags) && sigd) {
                 schedule();
-                prepare_to_wait(sk->sk_sleep, &wait, TASK_UNINTERRUPTIBLE);
+                prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE);
         }
-        finish_wait(sk->sk_sleep, &wait);
+        finish_wait(sk_sleep(sk), &wait);
         clear_bit(ATM_VF_REGIS, &vcc->flags); /* doesn't count */
         if (!sigd) {
                 error = -EUNATCH;
@@ -201,10 +201,10 @@ static int svc_connect(struct socket *sock, struct sockaddr *sockaddr,
                 }
                 vcc->remote = *addr;
                 set_bit(ATM_VF_WAITING, &vcc->flags);
-                prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+                prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
                 sigd_enq(vcc, as_connect, NULL, NULL, &vcc->remote);
                 if (flags & O_NONBLOCK) {
-                        finish_wait(sk->sk_sleep, &wait);
+                        finish_wait(sk_sleep(sk), &wait);
                         sock->state = SS_CONNECTING;
                         error = -EINPROGRESS;
                         goto out;
@@ -213,7 +213,7 @@ static int svc_connect(struct socket *sock, struct sockaddr *sockaddr,
                 while (test_bit(ATM_VF_WAITING, &vcc->flags) && sigd) {
                         schedule();
                         if (!signal_pending(current)) {
-                                prepare_to_wait(sk->sk_sleep, &wait,
+                                prepare_to_wait(sk_sleep(sk), &wait,
                                                 TASK_INTERRUPTIBLE);
                                 continue;
                         }
@@ -232,14 +232,14 @@ static int svc_connect(struct socket *sock, struct sockaddr *sockaddr,
                          */
                         sigd_enq(vcc, as_close, NULL, NULL, NULL);
                         while (test_bit(ATM_VF_WAITING, &vcc->flags) && sigd) {
-                                prepare_to_wait(sk->sk_sleep, &wait,
+                                prepare_to_wait(sk_sleep(sk), &wait,
                                                 TASK_INTERRUPTIBLE);
                                 schedule();
                         }
                         if (!sk->sk_err)
                                 while (!test_bit(ATM_VF_RELEASED, &vcc->flags) &&
                                        sigd) {
-                                        prepare_to_wait(sk->sk_sleep, &wait,
+                                        prepare_to_wait(sk_sleep(sk), &wait,
                                                         TASK_INTERRUPTIBLE);
                                         schedule();
                                 }
@@ -250,7 +250,7 @@ static int svc_connect(struct socket *sock, struct sockaddr *sockaddr,
                         error = -EINTR;
                         break;
                 }
-                finish_wait(sk->sk_sleep, &wait);
+                finish_wait(sk_sleep(sk), &wait);
                 if (error)
                         goto out;
                 if (!sigd) {
@@ -302,13 +302,13 @@ static int svc_listen(struct socket *sock, int backlog)
                 goto out;
         }
         set_bit(ATM_VF_WAITING, &vcc->flags);
-        prepare_to_wait(sk->sk_sleep, &wait, TASK_UNINTERRUPTIBLE);
+        prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE);
         sigd_enq(vcc, as_listen, NULL, NULL, &vcc->local);
         while (test_bit(ATM_VF_WAITING, &vcc->flags) && sigd) {
                 schedule();
-                prepare_to_wait(sk->sk_sleep, &wait, TASK_UNINTERRUPTIBLE);
+                prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE);
         }
-        finish_wait(sk->sk_sleep, &wait);
+        finish_wait(sk_sleep(sk), &wait);
         if (!sigd) {
                 error = -EUNATCH;
                 goto out;
@@ -343,7 +343,7 @@ static int svc_accept(struct socket *sock, struct socket *newsock, int flags)
         while (1) {
                 DEFINE_WAIT(wait);
 
-                prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+                prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
                 while (!(skb = skb_dequeue(&sk->sk_receive_queue)) &&
                        sigd) {
                         if (test_bit(ATM_VF_RELEASED, &old_vcc->flags))
@@ -363,10 +363,10 @@ static int svc_accept(struct socket *sock, struct socket *newsock, int flags)
                                 error = -ERESTARTSYS;
                                 break;
                         }
-                        prepare_to_wait(sk->sk_sleep, &wait,
+                        prepare_to_wait(sk_sleep(sk), &wait,
                                         TASK_INTERRUPTIBLE);
                 }
-                finish_wait(sk->sk_sleep, &wait);
+                finish_wait(sk_sleep(sk), &wait);
                 if (error)
                         goto out;
                 if (!skb) {
@@ -392,17 +392,17 @@ static int svc_accept(struct socket *sock, struct socket *newsock, int flags)
                 }
                 /* wait should be short, so we ignore the non-blocking flag */
                 set_bit(ATM_VF_WAITING, &new_vcc->flags);
-                prepare_to_wait(sk_atm(new_vcc)->sk_sleep, &wait,
+                prepare_to_wait(sk_sleep(sk_atm(new_vcc)), &wait,
                                 TASK_UNINTERRUPTIBLE);
                 sigd_enq(new_vcc, as_accept, old_vcc, NULL, NULL);
                 while (test_bit(ATM_VF_WAITING, &new_vcc->flags) && sigd) {
                         release_sock(sk);
                         schedule();
                         lock_sock(sk);
-                        prepare_to_wait(sk_atm(new_vcc)->sk_sleep, &wait,
+                        prepare_to_wait(sk_sleep(sk_atm(new_vcc)), &wait,
                                         TASK_UNINTERRUPTIBLE);
                 }
-                finish_wait(sk_atm(new_vcc)->sk_sleep, &wait);
+                finish_wait(sk_sleep(sk_atm(new_vcc)), &wait);
                 if (!sigd) {
                         error = -EUNATCH;
                         goto out;
@@ -438,14 +438,14 @@ int svc_change_qos(struct atm_vcc *vcc, struct atm_qos *qos)
         DEFINE_WAIT(wait);
 
         set_bit(ATM_VF_WAITING, &vcc->flags);
-        prepare_to_wait(sk->sk_sleep, &wait, TASK_UNINTERRUPTIBLE);
+        prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE);
         sigd_enq2(vcc, as_modify, NULL, NULL, &vcc->local, qos, 0);
         while (test_bit(ATM_VF_WAITING, &vcc->flags) &&
                !test_bit(ATM_VF_RELEASED, &vcc->flags) && sigd) {
                 schedule();
-                prepare_to_wait(sk->sk_sleep, &wait, TASK_UNINTERRUPTIBLE);
+                prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE);
         }
-        finish_wait(sk->sk_sleep, &wait);
+        finish_wait(sk_sleep(sk), &wait);
         if (!sigd)
                 return -EUNATCH;
         return -sk->sk_err;
@@ -534,20 +534,20 @@ static int svc_addparty(struct socket *sock, struct sockaddr *sockaddr,
 
         lock_sock(sk);
         set_bit(ATM_VF_WAITING, &vcc->flags);
-        prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+        prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
         sigd_enq(vcc, as_addparty, NULL, NULL,
                  (struct sockaddr_atmsvc *) sockaddr);
         if (flags & O_NONBLOCK) {
-                finish_wait(sk->sk_sleep, &wait);
+                finish_wait(sk_sleep(sk), &wait);
                 error = -EINPROGRESS;
                 goto out;
         }
         pr_debug("added wait queue\n");
         while (test_bit(ATM_VF_WAITING, &vcc->flags) && sigd) {
                 schedule();
-                prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+                prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
         }
-        finish_wait(sk->sk_sleep, &wait);
+        finish_wait(sk_sleep(sk), &wait);
         error = xchg(&sk->sk_err_soft, 0);
 out:
         release_sock(sk);
@@ -563,13 +563,13 @@ static int svc_dropparty(struct socket *sock, int ep_ref)
 
         lock_sock(sk);
         set_bit(ATM_VF_WAITING, &vcc->flags);
-        prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+        prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
         sigd_enq2(vcc, as_dropparty, NULL, NULL, NULL, NULL, ep_ref);
         while (test_bit(ATM_VF_WAITING, &vcc->flags) && sigd) {
                 schedule();
-                prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+                prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
         }
-        finish_wait(sk->sk_sleep, &wait);
+        finish_wait(sk_sleep(sk), &wait);
         if (!sigd) {
                 error = -EUNATCH;
                 goto out;
diff --git a/net/ax25/af_ax25.c b/net/ax25/af_ax25.c
index a5beedf43e2d..cfdfd7e2a172 100644
--- a/net/ax25/af_ax25.c
+++ b/net/ax25/af_ax25.c
@@ -25,6 +25,7 @@
 #include <linux/string.h>
 #include <linux/sockios.h>
 #include <linux/net.h>
+#include <linux/slab.h>
 #include <net/ax25.h>
 #include <linux/inet.h>
 #include <linux/netdevice.h>
@@ -1280,7 +1281,7 @@ static int __must_check ax25_connect(struct socket *sock,
                 DEFINE_WAIT(wait);
 
                 for (;;) {
-                        prepare_to_wait(sk->sk_sleep, &wait,
+                        prepare_to_wait(sk_sleep(sk), &wait,
                                         TASK_INTERRUPTIBLE);
                         if (sk->sk_state != TCP_SYN_SENT)
                                 break;
@@ -1293,7 +1294,7 @@ static int __must_check ax25_connect(struct socket *sock,
                         err = -ERESTARTSYS;
                         break;
                 }
-                finish_wait(sk->sk_sleep, &wait);
+                finish_wait(sk_sleep(sk), &wait);
 
                 if (err)
                         goto out_release;
@@ -1345,7 +1346,7 @@ static int ax25_accept(struct socket *sock, struct socket *newsock, int flags)
          *      hooked into the SABM we saved
          */
         for (;;) {
-                prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+                prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
                 skb = skb_dequeue(&sk->sk_receive_queue);
                 if (skb)
                         break;
@@ -1363,7 +1364,7 @@ static int ax25_accept(struct socket *sock, struct socket *newsock, int flags)
                 err = -ERESTARTSYS;
                 break;
         }
-        finish_wait(sk->sk_sleep, &wait);
+        finish_wait(sk_sleep(sk), &wait);
 
         if (err)
                 goto out;
diff --git a/net/ax25/ax25_dev.c b/net/ax25/ax25_dev.c
index a7a0e0c9698b..c1cb982f6e86 100644
--- a/net/ax25/ax25_dev.c
+++ b/net/ax25/ax25_dev.c
@@ -9,6 +9,7 @@
 #include <linux/errno.h>
 #include <linux/types.h>
 #include <linux/socket.h>
+#include <linux/slab.h>
 #include <linux/in.h>
 #include <linux/kernel.h>
 #include <linux/timer.h>
diff --git a/net/ax25/ax25_ds_subr.c b/net/ax25/ax25_ds_subr.c
index b5e59787be2f..85816e612dc0 100644
--- a/net/ax25/ax25_ds_subr.c
+++ b/net/ax25/ax25_ds_subr.c
@@ -17,6 +17,7 @@
 #include <linux/sockios.h>
 #include <linux/spinlock.h>
 #include <linux/net.h>
+#include <linux/gfp.h>
 #include <net/ax25.h>
 #include <linux/inet.h>
 #include <linux/netdevice.h>
diff --git a/net/ax25/ax25_iface.c b/net/ax25/ax25_iface.c
index 71338f112108..5a0dda8df492 100644
--- a/net/ax25/ax25_iface.c
+++ b/net/ax25/ax25_iface.c
@@ -17,6 +17,7 @@
 #include <linux/string.h>
 #include <linux/sockios.h>
 #include <linux/net.h>
+#include <linux/slab.h>
 #include <net/ax25.h>
 #include <linux/inet.h>
 #include <linux/netdevice.h>
diff --git a/net/ax25/ax25_in.c b/net/ax25/ax25_in.c
index de56d3983de0..9bb776541203 100644
--- a/net/ax25/ax25_in.c
+++ b/net/ax25/ax25_in.c
@@ -18,6 +18,7 @@
 #include <linux/string.h>
 #include <linux/sockios.h>
 #include <linux/net.h>
+#include <linux/slab.h>
 #include <net/ax25.h>
 #include <linux/inet.h>
 #include <linux/netdevice.h>
diff --git a/net/ax25/ax25_ip.c b/net/ax25/ax25_ip.c
index f047a57aa95c..cf0c47a26530 100644
--- a/net/ax25/ax25_ip.c
+++ b/net/ax25/ax25_ip.c
@@ -16,6 +16,7 @@
 #include <linux/string.h>
 #include <linux/sockios.h>
 #include <linux/net.h>
+#include <linux/slab.h>
 #include <net/ax25.h>
 #include <linux/inet.h>
 #include <linux/netdevice.h>
diff --git a/net/ax25/ax25_out.c b/net/ax25/ax25_out.c
index 14912600ec57..37507d806f65 100644
--- a/net/ax25/ax25_out.c
+++ b/net/ax25/ax25_out.c
@@ -19,6 +19,7 @@
 #include <linux/sockios.h>
 #include <linux/spinlock.h>
 #include <linux/net.h>
+#include <linux/slab.h>
 #include <net/ax25.h>
 #include <linux/inet.h>
 #include <linux/netdevice.h>
diff --git a/net/ax25/ax25_route.c b/net/ax25/ax25_route.c
index c833ba4c45a5..7805945a5fd6 100644
--- a/net/ax25/ax25_route.c
+++ b/net/ax25/ax25_route.c
@@ -23,6 +23,7 @@
 #include <linux/string.h>
 #include <linux/sockios.h>
 #include <linux/net.h>
+#include <linux/slab.h>
 #include <net/ax25.h>
 #include <linux/inet.h>
 #include <linux/netdevice.h>
diff --git a/net/ax25/ax25_subr.c b/net/ax25/ax25_subr.c
index 034aa10a5198..c6715ee4ab8f 100644
--- a/net/ax25/ax25_subr.c
+++ b/net/ax25/ax25_subr.c
@@ -18,6 +18,7 @@
 #include <linux/string.h>
 #include <linux/sockios.h>
 #include <linux/net.h>
+#include <linux/slab.h>
 #include <net/ax25.h>
 #include <linux/inet.h>
 #include <linux/netdevice.h>
diff --git a/net/ax25/ax25_uid.c b/net/ax25/ax25_uid.c
index 9f13f6eefcba..d349be9578f5 100644
--- a/net/ax25/ax25_uid.c
+++ b/net/ax25/ax25_uid.c
@@ -18,6 +18,7 @@
 #include <linux/sockios.h>
 #include <linux/net.h>
 #include <linux/spinlock.h>
+#include <linux/slab.h>
 #include <net/ax25.h>
 #include <linux/inet.h>
 #include <linux/netdevice.h>
diff --git a/net/ax25/sysctl_net_ax25.c b/net/ax25/sysctl_net_ax25.c
index 5159be6b2625..ebe0ef3f1d83 100644
--- a/net/ax25/sysctl_net_ax25.c
+++ b/net/ax25/sysctl_net_ax25.c
@@ -7,6 +7,7 @@
  * Copyright (C) 1996 Mike Shaver (shaver@zeroknowledge.com)
  */
 #include <linux/mm.h>
+#include <linux/slab.h>
 #include <linux/sysctl.h>
 #include <linux/spinlock.h>
 #include <net/ax25.h>
diff --git a/net/bluetooth/af_bluetooth.c b/net/bluetooth/af_bluetooth.c
index 087cc51f5927..421c45bd1b95 100644
--- a/net/bluetooth/af_bluetooth.c
+++ b/net/bluetooth/af_bluetooth.c
@@ -31,7 +31,6 @@
 #include <linux/errno.h>
 #include <linux/kernel.h>
 #include <linux/sched.h>
-#include <linux/slab.h>
 #include <linux/skbuff.h>
 #include <linux/init.h>
 #include <linux/poll.h>
@@ -289,7 +288,7 @@ unsigned int bt_sock_poll(struct file * file, struct socket *sock, poll_table *w
 
         BT_DBG("sock %p, sk %p", sock, sk);
 
-        poll_wait(file, sk->sk_sleep, wait);
+        poll_wait(file, sk_sleep(sk), wait);
 
         if (sk->sk_state == BT_LISTEN)
                 return bt_accept_poll(sk);
@@ -379,7 +378,7 @@ int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
 
         BT_DBG("sk %p", sk);
 
-        add_wait_queue(sk->sk_sleep, &wait);
+        add_wait_queue(sk_sleep(sk), &wait);
         while (sk->sk_state != state) {
                 set_current_state(TASK_INTERRUPTIBLE);
 
@@ -402,7 +401,7 @@ int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
                         break;
         }
         set_current_state(TASK_RUNNING);
-        remove_wait_queue(sk->sk_sleep, &wait);
+        remove_wait_queue(sk_sleep(sk), &wait);
         return err;
 }
 EXPORT_SYMBOL(bt_sock_wait_state);
diff --git a/net/bluetooth/bnep/core.c b/net/bluetooth/bnep/core.c
index ef09c7b3a858..f10b41fb05a0 100644
--- a/net/bluetooth/bnep/core.c
+++ b/net/bluetooth/bnep/core.c
@@ -35,6 +35,7 @@
 #include <linux/freezer.h>
 #include <linux/errno.h>
 #include <linux/net.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 
 #include <linux/socket.h>
@@ -473,7 +474,7 @@ static int bnep_session(void *arg)
         set_user_nice(current, -15);
 
         init_waitqueue_entry(&wait, current);
-        add_wait_queue(sk->sk_sleep, &wait);
+        add_wait_queue(sk_sleep(sk), &wait);
         while (!atomic_read(&s->killed)) {
                 set_current_state(TASK_INTERRUPTIBLE);
 
@@ -495,7 +496,7 @@ static int bnep_session(void *arg)
                 schedule();
         }
         set_current_state(TASK_RUNNING);
-        remove_wait_queue(sk->sk_sleep, &wait);
+        remove_wait_queue(sk_sleep(sk), &wait);
 
         /* Cleanup session */
         down_write(&bnep_session_sem);
@@ -506,7 +507,7 @@ static int bnep_session(void *arg)
         /* Wakeup user-space polling for socket errors */
         s->sock->sk->sk_err = EUNATCH;
 
-        wake_up_interruptible(s->sock->sk->sk_sleep);
+        wake_up_interruptible(sk_sleep(s->sock->sk));
 
         /* Release the socket */
         fput(s->sock->file);
@@ -637,7 +638,7 @@ int bnep_del_connection(struct bnep_conndel_req *req)
 
                 /* Kill session thread */
                 atomic_inc(&s->killed);
-                wake_up_interruptible(s->sock->sk->sk_sleep);
+                wake_up_interruptible(sk_sleep(s->sock->sk));
         } else
                 err = -ENOENT;
 
diff --git a/net/bluetooth/bnep/netdev.c b/net/bluetooth/bnep/netdev.c
index b6234b73c4cf..0faad5ce6dc4 100644
--- a/net/bluetooth/bnep/netdev.c
+++ b/net/bluetooth/bnep/netdev.c
@@ -26,6 +26,7 @@
 */
 
 #include <linux/module.h>
+#include <linux/slab.h>
 
 #include <linux/socket.h>
 #include <linux/netdevice.h>
@@ -87,7 +88,7 @@ static void bnep_net_set_mc_list(struct net_device *dev)
                 memcpy(__skb_put(skb, ETH_ALEN), dev->broadcast, ETH_ALEN);
                 r->len = htons(ETH_ALEN * 2);
         } else {
-                struct dev_mc_list *dmi = dev->mc_list;
+                struct netdev_hw_addr *ha;
                 int i, len = skb->len;
 
                 if (dev->flags & IFF_BROADCAST) {
@@ -97,18 +98,18 @@ static void bnep_net_set_mc_list(struct net_device *dev)
 
                 /* FIXME: We should group addresses here. */
 
-                for (i = 0;
-                     i < netdev_mc_count(dev) && i < BNEP_MAX_MULTICAST_FILTERS;
-                     i++) {
-                        memcpy(__skb_put(skb, ETH_ALEN), dmi->dmi_addr, ETH_ALEN);
-                        memcpy(__skb_put(skb, ETH_ALEN), dmi->dmi_addr, ETH_ALEN);
-                        dmi = dmi->next;
+                i = 0;
+                netdev_for_each_mc_addr(ha, dev) {
+                        if (i == BNEP_MAX_MULTICAST_FILTERS)
+                                break;
+                        memcpy(__skb_put(skb, ETH_ALEN), ha->addr, ETH_ALEN);
+                        memcpy(__skb_put(skb, ETH_ALEN), ha->addr, ETH_ALEN);
                 }
                 r->len = htons(skb->len - len);
         }
 
         skb_queue_tail(&sk->sk_write_queue, skb);
-        wake_up_interruptible(sk->sk_sleep);
+        wake_up_interruptible(sk_sleep(sk));
 #endif
 }
 
@@ -192,11 +193,11 @@ static netdev_tx_t bnep_net_xmit(struct sk_buff *skb,
         /*
          * We cannot send L2CAP packets from here as we are potentially in a bh.
          * So we have to queue them and wake up session thread which is sleeping
-         * on the sk->sk_sleep.
+         * on the sk_sleep(sk).
          */
         dev->trans_start = jiffies;
         skb_queue_tail(&sk->sk_write_queue, skb);
-        wake_up_interruptible(sk->sk_sleep);
+        wake_up_interruptible(sk_sleep(sk));
 
         if (skb_queue_len(&sk->sk_write_queue) >= BNEP_TX_QUEUE_LEN) {
                 BT_DBG("tx queue is full");
diff --git a/net/bluetooth/bnep/sock.c b/net/bluetooth/bnep/sock.c
index 2ff6ac7b2ed4..2862f53b66b1 100644
--- a/net/bluetooth/bnep/sock.c
+++ b/net/bluetooth/bnep/sock.c
@@ -30,7 +30,6 @@
 #include <linux/capability.h>
 #include <linux/errno.h>
 #include <linux/kernel.h>
-#include <linux/slab.h>
 #include <linux/poll.h>
 #include <linux/fcntl.h>
 #include <linux/skbuff.h>
@@ -39,6 +38,7 @@
 #include <linux/file.h>
 #include <linux/init.h>
 #include <linux/compat.h>
+#include <linux/gfp.h>
 #include <net/sock.h>
 
 #include <asm/system.h>
diff --git a/net/bluetooth/cmtp/cmtp.h b/net/bluetooth/cmtp/cmtp.h
index e4663aa14d26..785e79e953c5 100644
--- a/net/bluetooth/cmtp/cmtp.h
+++ b/net/bluetooth/cmtp/cmtp.h
@@ -125,7 +125,7 @@ static inline void cmtp_schedule(struct cmtp_session *session)
 {
         struct sock *sk = session->sock->sk;
 
-        wake_up_interruptible(sk->sk_sleep);
+        wake_up_interruptible(sk_sleep(sk));
 }
 
 /* CMTP init defines */
diff --git a/net/bluetooth/cmtp/core.c b/net/bluetooth/cmtp/core.c
index 0073ec8495da..d4c6af082d48 100644
--- a/net/bluetooth/cmtp/core.c
+++ b/net/bluetooth/cmtp/core.c
@@ -284,7 +284,7 @@ static int cmtp_session(void *arg)
         set_user_nice(current, -15);
 
         init_waitqueue_entry(&wait, current);
-        add_wait_queue(sk->sk_sleep, &wait);
+        add_wait_queue(sk_sleep(sk), &wait);
         while (!atomic_read(&session->terminate)) {
                 set_current_state(TASK_INTERRUPTIBLE);
 
@@ -301,7 +301,7 @@ static int cmtp_session(void *arg)
                 schedule();
         }
         set_current_state(TASK_RUNNING);
-        remove_wait_queue(sk->sk_sleep, &wait);
+        remove_wait_queue(sk_sleep(sk), &wait);
 
         down_write(&cmtp_session_sem);
 
diff --git a/net/bluetooth/cmtp/sock.c b/net/bluetooth/cmtp/sock.c
index 978cc3a718ad..7ea1979a8e4f 100644
--- a/net/bluetooth/cmtp/sock.c
+++ b/net/bluetooth/cmtp/sock.c
@@ -26,7 +26,6 @@
 #include <linux/capability.h>
 #include <linux/errno.h>
 #include <linux/kernel.h>
-#include <linux/slab.h>
 #include <linux/poll.h>
 #include <linux/fcntl.h>
 #include <linux/skbuff.h>
@@ -34,6 +33,7 @@
 #include <linux/ioctl.h>
 #include <linux/file.h>
 #include <linux/compat.h>
+#include <linux/gfp.h>
 #include <net/sock.h>
 
 #include <linux/isdn/capilli.h>
diff --git a/net/bluetooth/hci_sysfs.c b/net/bluetooth/hci_sysfs.c
index cafb55b0cea5..0e8e1a59856c 100644
--- a/net/bluetooth/hci_sysfs.c
+++ b/net/bluetooth/hci_sysfs.c
@@ -1,6 +1,7 @@
 /* Bluetooth HCI driver model support. */
 
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/debugfs.h>
 #include <linux/seq_file.h>
@@ -8,8 +9,7 @@
 #include <net/bluetooth/bluetooth.h>
 #include <net/bluetooth/hci_core.h>
 
-struct class *bt_class = NULL;
-EXPORT_SYMBOL_GPL(bt_class);
+static struct class *bt_class;
 
 struct dentry *bt_debugfs = NULL;
 EXPORT_SYMBOL_GPL(bt_debugfs);
diff --git a/net/bluetooth/hidp/core.c b/net/bluetooth/hidp/core.c
index 280529ad9274..bfe641b7dfaf 100644
--- a/net/bluetooth/hidp/core.c
+++ b/net/bluetooth/hidp/core.c
@@ -561,8 +561,8 @@ static int hidp_session(void *arg)
 
         init_waitqueue_entry(&ctrl_wait, current);
         init_waitqueue_entry(&intr_wait, current);
-        add_wait_queue(ctrl_sk->sk_sleep, &ctrl_wait);
-        add_wait_queue(intr_sk->sk_sleep, &intr_wait);
+        add_wait_queue(sk_sleep(ctrl_sk), &ctrl_wait);
+        add_wait_queue(sk_sleep(intr_sk), &intr_wait);
         while (!atomic_read(&session->terminate)) {
                 set_current_state(TASK_INTERRUPTIBLE);
 
@@ -584,8 +584,8 @@ static int hidp_session(void *arg)
                 schedule();
         }
         set_current_state(TASK_RUNNING);
-        remove_wait_queue(intr_sk->sk_sleep, &intr_wait);
-        remove_wait_queue(ctrl_sk->sk_sleep, &ctrl_wait);
+        remove_wait_queue(sk_sleep(intr_sk), &intr_wait);
+        remove_wait_queue(sk_sleep(ctrl_sk), &ctrl_wait);
 
         down_write(&hidp_session_sem);
 
@@ -609,7 +609,7 @@ static int hidp_session(void *arg)
 
         fput(session->intr_sock->file);
 
-        wait_event_timeout(*(ctrl_sk->sk_sleep),
+        wait_event_timeout(*(sk_sleep(ctrl_sk)),
                 (ctrl_sk->sk_state == BT_CLOSED), msecs_to_jiffies(500));
 
         fput(session->ctrl_sock->file);
diff --git a/net/bluetooth/hidp/hidp.h b/net/bluetooth/hidp/hidp.h
index a4e215d50c10..8d934a19da0a 100644
--- a/net/bluetooth/hidp/hidp.h
+++ b/net/bluetooth/hidp/hidp.h
@@ -164,8 +164,8 @@ static inline void hidp_schedule(struct hidp_session *session)
         struct sock *ctrl_sk = session->ctrl_sock->sk;
         struct sock *intr_sk = session->intr_sock->sk;
 
-        wake_up_interruptible(ctrl_sk->sk_sleep);
-        wake_up_interruptible(intr_sk->sk_sleep);
+        wake_up_interruptible(sk_sleep(ctrl_sk));
+        wake_up_interruptible(sk_sleep(intr_sk));
 }
 
 /* HIDP init defines */
diff --git a/net/bluetooth/hidp/sock.c b/net/bluetooth/hidp/sock.c
index 9cfef68b9fec..250dfd46237d 100644
--- a/net/bluetooth/hidp/sock.c
+++ b/net/bluetooth/hidp/sock.c
@@ -26,7 +26,6 @@
 #include <linux/capability.h>
 #include <linux/errno.h>
 #include <linux/kernel.h>
-#include <linux/slab.h>
 #include <linux/poll.h>
 #include <linux/fcntl.h>
 #include <linux/skbuff.h>
@@ -35,6 +34,7 @@
 #include <linux/file.h>
 #include <linux/init.h>
 #include <linux/compat.h>
+#include <linux/gfp.h>
 #include <net/sock.h>
 
 #include "hidp.h"
diff --git a/net/bluetooth/l2cap.c b/net/bluetooth/l2cap.c
index 400efa26ddba..864c76f4a678 100644
--- a/net/bluetooth/l2cap.c
+++ b/net/bluetooth/l2cap.c
@@ -40,6 +40,8 @@
 #include <linux/skbuff.h>
 #include <linux/list.h>
 #include <linux/device.h>
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
 #include <linux/uaccess.h>
 #include <linux/crc16.h>
 #include <net/sock.h>
@@ -1000,7 +1002,8 @@ static int l2cap_sock_connect(struct socket *sock, struct sockaddr *addr, int al
 
         BT_DBG("sk %p", sk);
 
-        if (!addr || addr->sa_family != AF_BLUETOOTH)
+        if (!addr || alen < sizeof(addr->sa_family) ||
+            addr->sa_family != AF_BLUETOOTH)
                 return -EINVAL;
 
         memset(&la, 0, sizeof(la));
@@ -1144,7 +1147,7 @@ static int l2cap_sock_accept(struct socket *sock, struct socket *newsock, int fl
         BT_DBG("sk %p timeo %ld", sk, timeo);
 
         /* Wait for an incoming connection. (wake-one). */
-        add_wait_queue_exclusive(sk->sk_sleep, &wait);
+        add_wait_queue_exclusive(sk_sleep(sk), &wait);
         while (!(nsk = bt_accept_dequeue(sk, newsock))) {
                 set_current_state(TASK_INTERRUPTIBLE);
                 if (!timeo) {
@@ -1167,7 +1170,7 @@ static int l2cap_sock_accept(struct socket *sock, struct socket *newsock, int fl
                 }
         }
         set_current_state(TASK_RUNNING);
-        remove_wait_queue(sk->sk_sleep, &wait);
+        remove_wait_queue(sk_sleep(sk), &wait);
 
         if (err)
                 goto done;
@@ -1623,7 +1626,10 @@ static int l2cap_sock_sendmsg(struct kiocb *iocb, struct socket *sock, struct ms
         /* Connectionless channel */
         if (sk->sk_type == SOCK_DGRAM) {
                 skb = l2cap_create_connless_pdu(sk, msg, len);
-                err = l2cap_do_send(sk, skb);
+                if (IS_ERR(skb))
+                        err = PTR_ERR(skb);
+                else
+                        err = l2cap_do_send(sk, skb);
                 goto done;
         }
 
@@ -2830,6 +2836,11 @@ static inline int l2cap_config_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hdr
                         int len = cmd->len - sizeof(*rsp);
                         char req[64];
 
+                        if (len > sizeof(req) - sizeof(struct l2cap_conf_req)) {
+                                l2cap_send_disconn_req(conn, sk);
+                                goto done;
+                        }
+
                         /* throw out any old stored conf requests */
                         result = L2CAP_CONF_SUCCESS;
                         len = l2cap_parse_conf_rsp(sk, rsp->data,
@@ -3937,29 +3948,42 @@ drop:
         return 0;
 }
 
-static ssize_t l2cap_sysfs_show(struct class *dev, char *buf)
+static int l2cap_debugfs_show(struct seq_file *f, void *p)
 {
         struct sock *sk;
         struct hlist_node *node;
-        char *str = buf;
 
         read_lock_bh(&l2cap_sk_list.lock);
 
         sk_for_each(sk, node, &l2cap_sk_list.head) {
                 struct l2cap_pinfo *pi = l2cap_pi(sk);
 
-                str += sprintf(str, "%s %s %d %d 0x%4.4x 0x%4.4x %d %d %d\n",
-                                batostr(&bt_sk(sk)->src), batostr(&bt_sk(sk)->dst),
-                                sk->sk_state, __le16_to_cpu(pi->psm), pi->scid,
-                                pi->dcid, pi->imtu, pi->omtu, pi->sec_level);
+                seq_printf(f, "%s %s %d %d 0x%4.4x 0x%4.4x %d %d %d\n",
+                                        batostr(&bt_sk(sk)->src),
+                                        batostr(&bt_sk(sk)->dst),
+                                        sk->sk_state, __le16_to_cpu(pi->psm),
+                                        pi->scid, pi->dcid,
+                                        pi->imtu, pi->omtu, pi->sec_level);
         }
 
         read_unlock_bh(&l2cap_sk_list.lock);
 
-        return str - buf;
+        return 0;
 }
 
-static CLASS_ATTR(l2cap, S_IRUGO, l2cap_sysfs_show, NULL);
+static int l2cap_debugfs_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, l2cap_debugfs_show, inode->i_private);
+}
+
+static const struct file_operations l2cap_debugfs_fops = {
+        .open           = l2cap_debugfs_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
+static struct dentry *l2cap_debugfs;
 
 static const struct proto_ops l2cap_sock_ops = {
         .family         = PF_BLUETOOTH,
@@ -4019,8 +4043,12 @@ static int __init l2cap_init(void)
                 goto error;
         }
 
-        if (class_create_file(bt_class, &class_attr_l2cap) < 0)
-                BT_ERR("Failed to create L2CAP info file");
+        if (bt_debugfs) {
+                l2cap_debugfs = debugfs_create_file("l2cap", 0444,
+                                        bt_debugfs, NULL, &l2cap_debugfs_fops);
+                if (!l2cap_debugfs)
+                        BT_ERR("Failed to create L2CAP debug file");
+        }
 
         BT_INFO("L2CAP ver %s", VERSION);
         BT_INFO("L2CAP socket layer initialized");
@@ -4034,7 +4062,7 @@ error:
 
 static void __exit l2cap_exit(void)
 {
-        class_remove_file(bt_class, &class_attr_l2cap);
+        debugfs_remove(l2cap_debugfs);
 
         if (bt_sock_unregister(BTPROTO_L2CAP) < 0)
                 BT_ERR("L2CAP socket unregistration failed");
diff --git a/net/bluetooth/rfcomm/core.c b/net/bluetooth/rfcomm/core.c
index 89f4a59eb82b..7dca91bb8c57 100644
--- a/net/bluetooth/rfcomm/core.c
+++ b/net/bluetooth/rfcomm/core.c
@@ -33,9 +33,12 @@
 #include <linux/init.h>
 #include <linux/wait.h>
 #include <linux/device.h>
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
 #include <linux/net.h>
 #include <linux/mutex.h>
 #include <linux/kthread.h>
+#include <linux/slab.h>
 
 #include <net/sock.h>
 #include <asm/uaccess.h>
@@ -2098,11 +2101,10 @@ static struct hci_cb rfcomm_cb = {
         .security_cfm   = rfcomm_security_cfm
 };
 
-static ssize_t rfcomm_dlc_sysfs_show(struct class *dev, char *buf)
+static int rfcomm_dlc_debugfs_show(struct seq_file *f, void *x)
 {
         struct rfcomm_session *s;
         struct list_head *pp, *p;
-        char *str = buf;
 
         rfcomm_lock();
 
@@ -2112,18 +2114,32 @@ static ssize_t rfcomm_dlc_sysfs_show(struct class *dev, char *buf)
                         struct sock *sk = s->sock->sk;
                         struct rfcomm_dlc *d = list_entry(pp, struct rfcomm_dlc, list);
 
-                        str += sprintf(str, "%s %s %ld %d %d %d %d\n",
-                                        batostr(&bt_sk(sk)->src), batostr(&bt_sk(sk)->dst),
-                                        d->state, d->dlci, d->mtu, d->rx_credits, d->tx_credits);
+                        seq_printf(f, "%s %s %ld %d %d %d %d\n",
+                                                batostr(&bt_sk(sk)->src),
+                                                batostr(&bt_sk(sk)->dst),
+                                                d->state, d->dlci, d->mtu,
+                                                d->rx_credits, d->tx_credits);
                 }
         }
 
         rfcomm_unlock();
 
-        return (str - buf);
+        return 0;
 }
 
-static CLASS_ATTR(rfcomm_dlc, S_IRUGO, rfcomm_dlc_sysfs_show, NULL);
+static int rfcomm_dlc_debugfs_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, rfcomm_dlc_debugfs_show, inode->i_private);
+}
+
+static const struct file_operations rfcomm_dlc_debugfs_fops = {
+        .open           = rfcomm_dlc_debugfs_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
+static struct dentry *rfcomm_dlc_debugfs;
 
 /* ---- Initialization ---- */
 static int __init rfcomm_init(void)
@@ -2140,8 +2156,12 @@ static int __init rfcomm_init(void)
                 goto unregister;
         }
 
-        if (class_create_file(bt_class, &class_attr_rfcomm_dlc) < 0)
-                BT_ERR("Failed to create RFCOMM info file");
+        if (bt_debugfs) {
+                rfcomm_dlc_debugfs = debugfs_create_file("rfcomm_dlc", 0444,
+                                bt_debugfs, NULL, &rfcomm_dlc_debugfs_fops);
+                if (!rfcomm_dlc_debugfs)
+                        BT_ERR("Failed to create RFCOMM debug file");
+        }
 
         err = rfcomm_init_ttys();
         if (err < 0)
@@ -2169,7 +2189,7 @@ unregister:
 
 static void __exit rfcomm_exit(void)
 {
-        class_remove_file(bt_class, &class_attr_rfcomm_dlc);
+        debugfs_remove(rfcomm_dlc_debugfs);
 
         hci_unregister_cb(&rfcomm_cb);
 
diff --git a/net/bluetooth/rfcomm/sock.c b/net/bluetooth/rfcomm/sock.c
index 4b5968dda673..43fbf6b4b4bf 100644
--- a/net/bluetooth/rfcomm/sock.c
+++ b/net/bluetooth/rfcomm/sock.c
@@ -40,6 +40,8 @@
 #include <linux/skbuff.h>
 #include <linux/list.h>
 #include <linux/device.h>
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
 #include <net/sock.h>
 
 #include <asm/system.h>
@@ -395,7 +397,8 @@ static int rfcomm_sock_connect(struct socket *sock, struct sockaddr *addr, int a
 
         BT_DBG("sk %p", sk);
 
-        if (addr->sa_family != AF_BLUETOOTH || alen < sizeof(struct sockaddr_rc))
+        if (alen < sizeof(struct sockaddr_rc) ||
+            addr->sa_family != AF_BLUETOOTH)
                 return -EINVAL;
 
         lock_sock(sk);
@@ -500,7 +503,7 @@ static int rfcomm_sock_accept(struct socket *sock, struct socket *newsock, int f
         BT_DBG("sk %p timeo %ld", sk, timeo);
 
         /* Wait for an incoming connection. (wake-one). */
-        add_wait_queue_exclusive(sk->sk_sleep, &wait);
+        add_wait_queue_exclusive(sk_sleep(sk), &wait);
         while (!(nsk = bt_accept_dequeue(sk, newsock))) {
                 set_current_state(TASK_INTERRUPTIBLE);
                 if (!timeo) {
@@ -523,7 +526,7 @@ static int rfcomm_sock_accept(struct socket *sock, struct socket *newsock, int f
                 }
         }
         set_current_state(TASK_RUNNING);
-        remove_wait_queue(sk->sk_sleep, &wait);
+        remove_wait_queue(sk_sleep(sk), &wait);
 
         if (err)
                 goto done;
@@ -618,7 +621,7 @@ static long rfcomm_sock_data_wait(struct sock *sk, long timeo)
 {
         DECLARE_WAITQUEUE(wait, current);
 
-        add_wait_queue(sk->sk_sleep, &wait);
+        add_wait_queue(sk_sleep(sk), &wait);
         for (;;) {
                 set_current_state(TASK_INTERRUPTIBLE);
 
@@ -637,7 +640,7 @@ static long rfcomm_sock_data_wait(struct sock *sk, long timeo)
         }
 
         __set_current_state(TASK_RUNNING);
-        remove_wait_queue(sk->sk_sleep, &wait);
+        remove_wait_queue(sk_sleep(sk), &wait);
         return timeo;
 }
 
@@ -1061,26 +1064,38 @@ done:
         return result;
 }
 
-static ssize_t rfcomm_sock_sysfs_show(struct class *dev, char *buf)
+static int rfcomm_sock_debugfs_show(struct seq_file *f, void *p)
 {
         struct sock *sk;
         struct hlist_node *node;
-        char *str = buf;
 
         read_lock_bh(&rfcomm_sk_list.lock);
 
         sk_for_each(sk, node, &rfcomm_sk_list.head) {
-                str += sprintf(str, "%s %s %d %d\n",
-                                batostr(&bt_sk(sk)->src), batostr(&bt_sk(sk)->dst),
+                seq_printf(f, "%s %s %d %d\n",
+                                batostr(&bt_sk(sk)->src),
+                                batostr(&bt_sk(sk)->dst),
                                 sk->sk_state, rfcomm_pi(sk)->channel);
         }
 
         read_unlock_bh(&rfcomm_sk_list.lock);
 
-        return (str - buf);
+        return 0;
 }
 
-static CLASS_ATTR(rfcomm, S_IRUGO, rfcomm_sock_sysfs_show, NULL);
+static int rfcomm_sock_debugfs_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, rfcomm_sock_debugfs_show, inode->i_private);
+}
+
+static const struct file_operations rfcomm_sock_debugfs_fops = {
+        .open           = rfcomm_sock_debugfs_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
+static struct dentry *rfcomm_sock_debugfs;
 
 static const struct proto_ops rfcomm_sock_ops = {
         .family         = PF_BLUETOOTH,
@@ -1120,8 +1135,12 @@ int __init rfcomm_init_sockets(void)
         if (err < 0)
                 goto error;
 
-        if (class_create_file(bt_class, &class_attr_rfcomm) < 0)
-                BT_ERR("Failed to create RFCOMM info file");
+        if (bt_debugfs) {
+                rfcomm_sock_debugfs = debugfs_create_file("rfcomm", 0444,
+                                bt_debugfs, NULL, &rfcomm_sock_debugfs_fops);
+                if (!rfcomm_sock_debugfs)
+                        BT_ERR("Failed to create RFCOMM debug file");
+        }
 
         BT_INFO("RFCOMM socket layer initialized");
 
@@ -1135,7 +1154,7 @@ error:
 
 void rfcomm_cleanup_sockets(void)
 {
-        class_remove_file(bt_class, &class_attr_rfcomm);
+        debugfs_remove(rfcomm_sock_debugfs);
 
         if (bt_sock_unregister(BTPROTO_RFCOMM) < 0)
                 BT_ERR("RFCOMM socket layer unregistration failed");
diff --git a/net/bluetooth/sco.c b/net/bluetooth/sco.c
index dd8f6ec57dce..b406d3eff53a 100644
--- a/net/bluetooth/sco.c
+++ b/net/bluetooth/sco.c
@@ -38,6 +38,8 @@
 #include <linux/socket.h>
 #include <linux/skbuff.h>
 #include <linux/device.h>
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
 #include <linux/list.h>
 #include <net/sock.h>
 
@@ -497,7 +499,8 @@ static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen
 
         BT_DBG("sk %p", sk);
 
-        if (addr->sa_family != AF_BLUETOOTH || alen < sizeof(struct sockaddr_sco))
+        if (alen < sizeof(struct sockaddr_sco) ||
+            addr->sa_family != AF_BLUETOOTH)
                 return -EINVAL;
 
         if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
@@ -564,7 +567,7 @@ static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flag
         BT_DBG("sk %p timeo %ld", sk, timeo);
 
         /* Wait for an incoming connection. (wake-one). */
-        add_wait_queue_exclusive(sk->sk_sleep, &wait);
+        add_wait_queue_exclusive(sk_sleep(sk), &wait);
         while (!(ch = bt_accept_dequeue(sk, newsock))) {
                 set_current_state(TASK_INTERRUPTIBLE);
                 if (!timeo) {
@@ -587,7 +590,7 @@ static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flag
                 }
         }
         set_current_state(TASK_RUNNING);
-        remove_wait_queue(sk->sk_sleep, &wait);
+        remove_wait_queue(sk_sleep(sk), &wait);
 
         if (err)
                 goto done;
@@ -953,26 +956,36 @@ drop:
         return 0;
 }
 
-static ssize_t sco_sysfs_show(struct class *dev, char *buf)
+static int sco_debugfs_show(struct seq_file *f, void *p)
 {
         struct sock *sk;
         struct hlist_node *node;
-        char *str = buf;
 
         read_lock_bh(&sco_sk_list.lock);
 
         sk_for_each(sk, node, &sco_sk_list.head) {
-                str += sprintf(str, "%s %s %d\n",
-                                batostr(&bt_sk(sk)->src), batostr(&bt_sk(sk)->dst),
-                                sk->sk_state);
+                seq_printf(f, "%s %s %d\n", batostr(&bt_sk(sk)->src),
+                                batostr(&bt_sk(sk)->dst), sk->sk_state);
         }
 
         read_unlock_bh(&sco_sk_list.lock);
 
-        return (str - buf);
+        return 0;
 }
 
-static CLASS_ATTR(sco, S_IRUGO, sco_sysfs_show, NULL);
+static int sco_debugfs_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, sco_debugfs_show, inode->i_private);
+}
+
+static const struct file_operations sco_debugfs_fops = {
+        .open           = sco_debugfs_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
+static struct dentry *sco_debugfs;
 
 static const struct proto_ops sco_sock_ops = {
         .family         = PF_BLUETOOTH,
@@ -1030,8 +1043,12 @@ static int __init sco_init(void)
                 goto error;
         }
 
-        if (class_create_file(bt_class, &class_attr_sco) < 0)
-                BT_ERR("Failed to create SCO info file");
+        if (bt_debugfs) {
+                sco_debugfs = debugfs_create_file("sco", 0444,
+                                        bt_debugfs, NULL, &sco_debugfs_fops);
+                if (!sco_debugfs)
+                        BT_ERR("Failed to create SCO debug file");
+        }
 
         BT_INFO("SCO (Voice Link) ver %s", VERSION);
         BT_INFO("SCO socket layer initialized");
@@ -1045,7 +1062,7 @@ error:
 
 static void __exit sco_exit(void)
 {
-        class_remove_file(bt_class, &class_attr_sco);
+        debugfs_remove(sco_debugfs);
 
         if (bt_sock_unregister(BTPROTO_SCO) < 0)
                 BT_ERR("SCO socket unregistration failed");
diff --git a/net/bridge/Kconfig b/net/bridge/Kconfig
index d115d5cea5b6..9190ae462cb4 100644
--- a/net/bridge/Kconfig
+++ b/net/bridge/Kconfig
@@ -33,14 +33,14 @@ config BRIDGE
           If unsure, say N.
 
 config BRIDGE_IGMP_SNOOPING
-        bool "IGMP snooping"
+        bool "IGMP/MLD snooping"
         depends on BRIDGE
         depends on INET
         default y
         ---help---
           If you say Y here, then the Ethernet bridge will be able selectively
-          forward multicast traffic based on IGMP traffic received from each
-          port.
+          forward multicast traffic based on IGMP/MLD traffic received from
+          each port.
 
           Say N to exclude this support and reduce the binary size.
 
diff --git a/net/bridge/br_device.c b/net/bridge/br_device.c
index eb7062d2e9e5..82599405dc15 100644
--- a/net/bridge/br_device.c
+++ b/net/bridge/br_device.c
@@ -26,21 +26,22 @@ netdev_tx_t br_dev_xmit(struct sk_buff *skb, struct net_device *dev)
         const unsigned char *dest = skb->data;
         struct net_bridge_fdb_entry *dst;
         struct net_bridge_mdb_entry *mdst;
+        struct br_cpu_netstats *brstats = this_cpu_ptr(br->stats);
 
-        BR_INPUT_SKB_CB(skb)->brdev = dev;
+        brstats->tx_packets++;
+        brstats->tx_bytes += skb->len;
 
-        dev->stats.tx_packets++;
-        dev->stats.tx_bytes += skb->len;
+        BR_INPUT_SKB_CB(skb)->brdev = dev;
 
         skb_reset_mac_header(skb);
         skb_pull(skb, ETH_HLEN);
 
-        if (dest[0] & 1) {
+        if (is_multicast_ether_addr(dest)) {
                 if (br_multicast_rcv(br, NULL, skb))
                         goto out;
 
                 mdst = br_mdb_get(br, skb);
-                if (mdst || BR_INPUT_SKB_CB(skb)->mrouters_only)
+                if (mdst || BR_INPUT_SKB_CB_MROUTERS_ONLY(skb))
                         br_multicast_deliver(mdst, skb);
                 else
                         br_flood_deliver(br, skb);
@@ -81,6 +82,31 @@ static int br_dev_stop(struct net_device *dev)
         return 0;
 }
 
+static struct net_device_stats *br_get_stats(struct net_device *dev)
+{
+        struct net_bridge *br = netdev_priv(dev);
+        struct net_device_stats *stats = &dev->stats;
+        struct br_cpu_netstats sum = { 0 };
+        unsigned int cpu;
+
+        for_each_possible_cpu(cpu) {
+                const struct br_cpu_netstats *bstats
+                        = per_cpu_ptr(br->stats, cpu);
+
+                sum.tx_bytes   += bstats->tx_bytes;
+                sum.tx_packets += bstats->tx_packets;
+                sum.rx_bytes   += bstats->rx_bytes;
+                sum.rx_packets += bstats->rx_packets;
+        }
+
+        stats->tx_bytes   = sum.tx_bytes;
+        stats->tx_packets = sum.tx_packets;
+        stats->rx_bytes   = sum.rx_bytes;
+        stats->rx_packets = sum.rx_packets;
+
+        return stats;
+}
+
 static int br_change_mtu(struct net_device *dev, int new_mtu)
 {
         struct net_bridge *br = netdev_priv(dev);
@@ -180,19 +206,28 @@ static const struct net_device_ops br_netdev_ops = {
         .ndo_open                = br_dev_open,
         .ndo_stop                = br_dev_stop,
         .ndo_start_xmit          = br_dev_xmit,
+        .ndo_get_stats           = br_get_stats,
         .ndo_set_mac_address     = br_set_mac_address,
         .ndo_set_multicast_list  = br_dev_set_multicast_list,
         .ndo_change_mtu          = br_change_mtu,
         .ndo_do_ioctl            = br_dev_ioctl,
 };
 
+static void br_dev_free(struct net_device *dev)
+{
+        struct net_bridge *br = netdev_priv(dev);
+
+        free_percpu(br->stats);
+        free_netdev(dev);
+}
+
 void br_dev_setup(struct net_device *dev)
 {
         random_ether_addr(dev->dev_addr);
         ether_setup(dev);
 
         dev->netdev_ops = &br_netdev_ops;
-        dev->destructor = free_netdev;
+        dev->destructor = br_dev_free;
         SET_ETHTOOL_OPS(dev, &br_ethtool_ops);
         dev->tx_queue_len = 0;
         dev->priv_flags = IFF_EBRIDGE;
diff --git a/net/bridge/br_fdb.c b/net/bridge/br_fdb.c
index 3b8e038ab32c..9101a4e56201 100644
--- a/net/bridge/br_fdb.c
+++ b/net/bridge/br_fdb.c
@@ -20,6 +20,7 @@
 #include <linux/etherdevice.h>
 #include <linux/jhash.h>
 #include <linux/random.h>
+#include <linux/slab.h>
 #include <asm/atomic.h>
 #include <asm/unaligned.h>
 #include "br_private.h"
diff --git a/net/bridge/br_forward.c b/net/bridge/br_forward.c
index d61e6f741125..396f077216a3 100644
--- a/net/bridge/br_forward.c
+++ b/net/bridge/br_forward.c
@@ -12,6 +12,7 @@
  */
 
 #include <linux/err.h>
+#include <linux/slab.h>
 #include <linux/kernel.h>
 #include <linux/netdevice.h>
 #include <linux/skbuff.h>
@@ -19,6 +20,11 @@
 #include <linux/netfilter_bridge.h>
 #include "br_private.h"
 
+static int deliver_clone(const struct net_bridge_port *prev,
+                         struct sk_buff *skb,
+                         void (*__packet_hook)(const struct net_bridge_port *p,
+                                               struct sk_buff *skb));
+
 /* Don't forward packets to originating port or forwarding diasabled */
 static inline int should_deliver(const struct net_bridge_port *p,
                                  const struct sk_buff *skb)
@@ -94,17 +100,22 @@ void br_deliver(const struct net_bridge_port *to, struct sk_buff *skb)
 }
 
 /* called with rcu_read_lock */
-void br_forward(const struct net_bridge_port *to, struct sk_buff *skb)
+void br_forward(const struct net_bridge_port *to, struct sk_buff *skb, struct sk_buff *skb0)
 {
         if (should_deliver(to, skb)) {
-                __br_forward(to, skb);
+                if (skb0)
+                        deliver_clone(to, skb, __br_forward);
+                else
+                        __br_forward(to, skb);
                 return;
         }
 
-        kfree_skb(skb);
+        if (!skb0)
+                kfree_skb(skb);
 }
 
-static int deliver_clone(struct net_bridge_port *prev, struct sk_buff *skb,
+static int deliver_clone(const struct net_bridge_port *prev,
+                         struct sk_buff *skb,
                          void (*__packet_hook)(const struct net_bridge_port *p,
                                                struct sk_buff *skb))
 {
@@ -197,17 +208,15 @@ static void br_multicast_flood(struct net_bridge_mdb_entry *mdst,
 {
         struct net_device *dev = BR_INPUT_SKB_CB(skb)->brdev;
         struct net_bridge *br = netdev_priv(dev);
-        struct net_bridge_port *port;
-        struct net_bridge_port *lport, *rport;
-        struct net_bridge_port *prev;
+        struct net_bridge_port *prev = NULL;
         struct net_bridge_port_group *p;
         struct hlist_node *rp;
 
-        prev = NULL;
-
-        rp = br->router_list.first;
-        p = mdst ? mdst->ports : NULL;
+        rp = rcu_dereference(br->router_list.first);
+        p = mdst ? rcu_dereference(mdst->ports) : NULL;
         while (p || rp) {
+                struct net_bridge_port *port, *lport, *rport;
+
                 lport = p ? p->port : NULL;
                 rport = rp ? hlist_entry(rp, struct net_bridge_port, rlist) :
                              NULL;
@@ -220,9 +229,9 @@ static void br_multicast_flood(struct net_bridge_mdb_entry *mdst,
                         goto out;
 
                 if ((unsigned long)lport >= (unsigned long)port)
-                        p = p->next;
+                        p = rcu_dereference(p->next);
                 if ((unsigned long)rport >= (unsigned long)port)
-                        rp = rp->next;
+                        rp = rcu_dereference(rp->next);
         }
 
         if (!prev)
diff --git a/net/bridge/br_if.c b/net/bridge/br_if.c
index b6a3872f5681..521439333316 100644
--- a/net/bridge/br_if.c
+++ b/net/bridge/br_if.c
@@ -19,6 +19,7 @@
 #include <linux/init.h>
 #include <linux/rtnetlink.h>
 #include <linux/if_ether.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 
 #include "br_private.h"
@@ -185,6 +186,12 @@ static struct net_device *new_bridge_dev(struct net *net, const char *name)
         br = netdev_priv(dev);
         br->dev = dev;
 
+        br->stats = alloc_percpu(struct br_cpu_netstats);
+        if (!br->stats) {
+                free_netdev(dev);
+                return NULL;
+        }
+
         spin_lock_init(&br->lock);
         INIT_LIST_HEAD(&br->port_list);
         spin_lock_init(&br->hash_lock);
diff --git a/net/bridge/br_input.c b/net/bridge/br_input.c
index 53b39851d87d..e7f4c1d02f57 100644
--- a/net/bridge/br_input.c
+++ b/net/bridge/br_input.c
@@ -11,6 +11,7 @@
  *      2 of the License, or (at your option) any later version.
  */
 
+#include <linux/slab.h>
 #include <linux/kernel.h>
 #include <linux/netdevice.h>
 #include <linux/etherdevice.h>
@@ -23,9 +24,11 @@ const u8 br_group_address[ETH_ALEN] = { 0x01, 0x80, 0xc2, 0x00, 0x00, 0x00 };
 static int br_pass_frame_up(struct sk_buff *skb)
 {
         struct net_device *indev, *brdev = BR_INPUT_SKB_CB(skb)->brdev;
+        struct net_bridge *br = netdev_priv(brdev);
+        struct br_cpu_netstats *brstats = this_cpu_ptr(br->stats);
 
-        brdev->stats.rx_packets++;
-        brdev->stats.rx_bytes += skb->len;
+        brstats->rx_packets++;
+        brstats->rx_bytes += skb->len;
 
         indev = skb->dev;
         skb->dev = brdev;
@@ -70,7 +73,7 @@ int br_handle_frame_finish(struct sk_buff *skb)
 
         if (is_multicast_ether_addr(dest)) {
                 mdst = br_mdb_get(br, skb);
-                if (mdst || BR_INPUT_SKB_CB(skb)->mrouters_only) {
+                if (mdst || BR_INPUT_SKB_CB_MROUTERS_ONLY(skb)) {
                         if ((mdst && !hlist_unhashed(&mdst->mglist)) ||
                             br_multicast_is_router(br))
                                 skb2 = skb;
@@ -90,7 +93,7 @@ int br_handle_frame_finish(struct sk_buff *skb)
 
         if (skb) {
                 if (dst)
-                        br_forward(dst->dst, skb);
+                        br_forward(dst->dst, skb, skb2);
                 else
                         br_flood_forward(br, skb, skb2);
         }
diff --git a/net/bridge/br_ioctl.c b/net/bridge/br_ioctl.c
index 2af6e4a90262..995afc4b04dc 100644
--- a/net/bridge/br_ioctl.c
+++ b/net/bridge/br_ioctl.c
@@ -15,6 +15,7 @@
 #include <linux/kernel.h>
 #include <linux/if_bridge.h>
 #include <linux/netdevice.h>
+#include <linux/slab.h>
 #include <linux/times.h>
 #include <net/net_namespace.h>
 #include <asm/uaccess.h>
diff --git a/net/bridge/br_multicast.c b/net/bridge/br_multicast.c
index 12ce1eaa4f3e..7128abdce45f 100644
--- a/net/bridge/br_multicast.c
+++ b/net/bridge/br_multicast.c
@@ -24,31 +24,108 @@
 #include <linux/slab.h>
 #include <linux/timer.h>
 #include <net/ip.h>
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
+#include <net/ipv6.h>
+#include <net/mld.h>
+#include <net/addrconf.h>
+#include <net/ip6_checksum.h>
+#endif
 
 #include "br_private.h"
 
-static inline int br_ip_hash(struct net_bridge_mdb_htable *mdb, __be32 ip)
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
+static inline int ipv6_is_local_multicast(const struct in6_addr *addr)
 {
-        return jhash_1word(mdb->secret, (u32)ip) & (mdb->max - 1);
+        if (ipv6_addr_is_multicast(addr) &&
+            IPV6_ADDR_MC_SCOPE(addr) <= IPV6_ADDR_SCOPE_LINKLOCAL)
+                return 1;
+        return 0;
+}
+#endif
+
+static inline int br_ip_equal(const struct br_ip *a, const struct br_ip *b)
+{
+        if (a->proto != b->proto)
+                return 0;
+        switch (a->proto) {
+        case htons(ETH_P_IP):
+                return a->u.ip4 == b->u.ip4;
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
+        case htons(ETH_P_IPV6):
+                return ipv6_addr_equal(&a->u.ip6, &b->u.ip6);
+#endif
+        }
+        return 0;
+}
+
+static inline int __br_ip4_hash(struct net_bridge_mdb_htable *mdb, __be32 ip)
+{
+        return jhash_1word(mdb->secret, (__force u32)ip) & (mdb->max - 1);
+}
+
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
+static inline int __br_ip6_hash(struct net_bridge_mdb_htable *mdb,
+                                const struct in6_addr *ip)
+{
+        return jhash2((__force u32 *)ip->s6_addr32, 4, mdb->secret) & (mdb->max - 1);
+}
+#endif
+
+static inline int br_ip_hash(struct net_bridge_mdb_htable *mdb,
+                             struct br_ip *ip)
+{
+        switch (ip->proto) {
+        case htons(ETH_P_IP):
+                return __br_ip4_hash(mdb, ip->u.ip4);
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
+        case htons(ETH_P_IPV6):
+                return __br_ip6_hash(mdb, &ip->u.ip6);
+#endif
+        }
+        return 0;
 }
 
 static struct net_bridge_mdb_entry *__br_mdb_ip_get(
-        struct net_bridge_mdb_htable *mdb, __be32 dst, int hash)
+        struct net_bridge_mdb_htable *mdb, struct br_ip *dst, int hash)
 {
         struct net_bridge_mdb_entry *mp;
         struct hlist_node *p;
 
         hlist_for_each_entry_rcu(mp, p, &mdb->mhash[hash], hlist[mdb->ver]) {
-                if (dst == mp->addr)
+                if (br_ip_equal(&mp->addr, dst))
                         return mp;
         }
 
         return NULL;
 }
 
-static struct net_bridge_mdb_entry *br_mdb_ip_get(
+static struct net_bridge_mdb_entry *br_mdb_ip4_get(
         struct net_bridge_mdb_htable *mdb, __be32 dst)
 {
+        struct br_ip br_dst;
+
+        br_dst.u.ip4 = dst;
+        br_dst.proto = htons(ETH_P_IP);
+
+        return __br_mdb_ip_get(mdb, &br_dst, __br_ip4_hash(mdb, dst));
+}
+
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
+static struct net_bridge_mdb_entry *br_mdb_ip6_get(
+        struct net_bridge_mdb_htable *mdb, const struct in6_addr *dst)
+{
+        struct br_ip br_dst;
+
+        ipv6_addr_copy(&br_dst.u.ip6, dst);
+        br_dst.proto = htons(ETH_P_IPV6);
+
+        return __br_mdb_ip_get(mdb, &br_dst, __br_ip6_hash(mdb, dst));
+}
+#endif
+
+static struct net_bridge_mdb_entry *br_mdb_ip_get(
+        struct net_bridge_mdb_htable *mdb, struct br_ip *dst)
+{
         return __br_mdb_ip_get(mdb, dst, br_ip_hash(mdb, dst));
 }
 
@@ -56,18 +133,30 @@ struct net_bridge_mdb_entry *br_mdb_get(struct net_bridge *br,
                                         struct sk_buff *skb)
 {
         struct net_bridge_mdb_htable *mdb = br->mdb;
+        struct br_ip ip;
 
         if (!mdb || br->multicast_disabled)
                 return NULL;
 
+        if (BR_INPUT_SKB_CB(skb)->igmp)
+                return NULL;
+
+        ip.proto = skb->protocol;
+
         switch (skb->protocol) {
         case htons(ETH_P_IP):
-                if (BR_INPUT_SKB_CB(skb)->igmp)
-                        break;
-                return br_mdb_ip_get(mdb, ip_hdr(skb)->daddr);
+                ip.u.ip4 = ip_hdr(skb)->daddr;
+                break;
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
+        case htons(ETH_P_IPV6):
+                ipv6_addr_copy(&ip.u.ip6, &ipv6_hdr(skb)->daddr);
+                break;
+#endif
+        default:
+                return NULL;
         }
 
-        return NULL;
+        return br_mdb_ip_get(mdb, &ip);
 }
 
 static void br_mdb_free(struct rcu_head *head)
@@ -94,7 +183,7 @@ static int br_mdb_copy(struct net_bridge_mdb_htable *new,
         for (i = 0; i < old->max; i++)
                 hlist_for_each_entry(mp, p, &old->mhash[i], hlist[old->ver])
                         hlist_add_head(&mp->hlist[new->ver],
-                                       &new->mhash[br_ip_hash(new, mp->addr)]);
+                                       &new->mhash[br_ip_hash(new, &mp->addr)]);
 
         if (!elasticity)
                 return 0;
@@ -162,7 +251,7 @@ static void br_multicast_del_pg(struct net_bridge *br,
         struct net_bridge_port_group *p;
         struct net_bridge_port_group **pp;
 
-        mp = br_mdb_ip_get(mdb, pg->addr);
+        mp = br_mdb_ip_get(mdb, &pg->addr);
         if (WARN_ON(!mp))
                 return;
 
@@ -170,7 +259,7 @@ static void br_multicast_del_pg(struct net_bridge *br,
                 if (p != pg)
                         continue;
 
-                *pp = p->next;
+                rcu_assign_pointer(*pp, p->next);
                 hlist_del_init(&p->mglist);
                 del_timer(&p->timer);
                 del_timer(&p->query_timer);
@@ -248,8 +337,8 @@ out:
         return 0;
 }
 
-static struct sk_buff *br_multicast_alloc_query(struct net_bridge *br,
-                                                __be32 group)
+static struct sk_buff *br_ip4_multicast_alloc_query(struct net_bridge *br,
+                                                    __be32 group)
 {
         struct sk_buff *skb;
         struct igmphdr *ih;
@@ -313,12 +402,104 @@ out:
         return skb;
 }
 
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
+static struct sk_buff *br_ip6_multicast_alloc_query(struct net_bridge *br,
+                                                    struct in6_addr *group)
+{
+        struct sk_buff *skb;
+        struct ipv6hdr *ip6h;
+        struct mld_msg *mldq;
+        struct ethhdr *eth;
+        u8 *hopopt;
+        unsigned long interval;
+
+        skb = netdev_alloc_skb_ip_align(br->dev, sizeof(*eth) + sizeof(*ip6h) +
+                                                 8 + sizeof(*mldq));
+        if (!skb)
+                goto out;
+
+        skb->protocol = htons(ETH_P_IPV6);
+
+        /* Ethernet header */
+        skb_reset_mac_header(skb);
+        eth = eth_hdr(skb);
+
+        memcpy(eth->h_source, br->dev->dev_addr, 6);
+        ipv6_eth_mc_map(group, eth->h_dest);
+        eth->h_proto = htons(ETH_P_IPV6);
+        skb_put(skb, sizeof(*eth));
+
+        /* IPv6 header + HbH option */
+        skb_set_network_header(skb, skb->len);
+        ip6h = ipv6_hdr(skb);
+
+        *(__force __be32 *)ip6h = htonl(0x60000000);
+        ip6h->payload_len = 8 + sizeof(*mldq);
+        ip6h->nexthdr = IPPROTO_HOPOPTS;
+        ip6h->hop_limit = 1;
+        ipv6_addr_set(&ip6h->saddr, 0, 0, 0, 0);
+        ipv6_addr_set(&ip6h->daddr, htonl(0xff020000), 0, 0, htonl(1));
+
+        hopopt = (u8 *)(ip6h + 1);
+        hopopt[0] = IPPROTO_ICMPV6;             /* next hdr */
+        hopopt[1] = 0;                          /* length of HbH */
+        hopopt[2] = IPV6_TLV_ROUTERALERT;       /* Router Alert */
+        hopopt[3] = 2;                          /* Length of RA Option */
+        hopopt[4] = 0;                          /* Type = 0x0000 (MLD) */
+        hopopt[5] = 0;
+        hopopt[6] = IPV6_TLV_PAD0;              /* Pad0 */
+        hopopt[7] = IPV6_TLV_PAD0;              /* Pad0 */
+
+        skb_put(skb, sizeof(*ip6h) + 8);
+
+        /* ICMPv6 */
+        skb_set_transport_header(skb, skb->len);
+        mldq = (struct mld_msg *) icmp6_hdr(skb);
+
+        interval = ipv6_addr_any(group) ? br->multicast_last_member_interval :
+                                          br->multicast_query_response_interval;
+
+        mldq->mld_type = ICMPV6_MGM_QUERY;
+        mldq->mld_code = 0;
+        mldq->mld_cksum = 0;
+        mldq->mld_maxdelay = htons((u16)jiffies_to_msecs(interval));
+        mldq->mld_reserved = 0;
+        ipv6_addr_copy(&mldq->mld_mca, group);
+
+        /* checksum */
+        mldq->mld_cksum = csum_ipv6_magic(&ip6h->saddr, &ip6h->daddr,
+                                          sizeof(*mldq), IPPROTO_ICMPV6,
+                                          csum_partial(mldq,
+                                                       sizeof(*mldq), 0));
+        skb_put(skb, sizeof(*mldq));
+
+        __skb_pull(skb, sizeof(*eth));
+
+out:
+        return skb;
+}
+#endif
+
+static struct sk_buff *br_multicast_alloc_query(struct net_bridge *br,
+                                                struct br_ip *addr)
+{
+        switch (addr->proto) {
+        case htons(ETH_P_IP):
+                return br_ip4_multicast_alloc_query(br, addr->u.ip4);
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
+        case htons(ETH_P_IPV6):
+                return br_ip6_multicast_alloc_query(br, &addr->u.ip6);
+#endif
+        }
+        return NULL;
+}
+
 static void br_multicast_send_group_query(struct net_bridge_mdb_entry *mp)
 {
         struct net_bridge *br = mp->br;
         struct sk_buff *skb;
 
-        skb = br_multicast_alloc_query(br, mp->addr);
+        skb = br_multicast_alloc_query(br, &mp->addr);
         if (!skb)
                 goto timer;
 
@@ -352,7 +533,7 @@ static void br_multicast_send_port_group_query(struct net_bridge_port_group *pg)
         struct net_bridge *br = port->br;
         struct sk_buff *skb;
 
-        skb = br_multicast_alloc_query(br, pg->addr);
+        skb = br_multicast_alloc_query(br, &pg->addr);
         if (!skb)
                 goto timer;
 
@@ -382,8 +563,8 @@ out:
 }
 
 static struct net_bridge_mdb_entry *br_multicast_get_group(
-        struct net_bridge *br, struct net_bridge_port *port, __be32 group,
-        int hash)
+        struct net_bridge *br, struct net_bridge_port *port,
+        struct br_ip *group, int hash)
 {
         struct net_bridge_mdb_htable *mdb = br->mdb;
         struct net_bridge_mdb_entry *mp;
@@ -395,9 +576,8 @@ static struct net_bridge_mdb_entry *br_multicast_get_group(
 
         hlist_for_each_entry(mp, p, &mdb->mhash[hash], hlist[mdb->ver]) {
                 count++;
-                if (unlikely(group == mp->addr)) {
+                if (unlikely(br_ip_equal(group, &mp->addr)))
                         return mp;
-                }
         }
 
         elasticity = 0;
@@ -462,7 +642,8 @@ err:
 }
 
 static struct net_bridge_mdb_entry *br_multicast_new_group(
-        struct net_bridge *br, struct net_bridge_port *port, __be32 group)
+        struct net_bridge *br, struct net_bridge_port *port,
+        struct br_ip *group)
 {
         struct net_bridge_mdb_htable *mdb = br->mdb;
         struct net_bridge_mdb_entry *mp;
@@ -495,7 +676,7 @@ rehash:
                 goto out;
 
         mp->br = br;
-        mp->addr = group;
+        mp->addr = *group;
         setup_timer(&mp->timer, br_multicast_group_expired,
                     (unsigned long)mp);
         setup_timer(&mp->query_timer, br_multicast_group_query_expired,
@@ -509,7 +690,8 @@ out:
 }
 
 static int br_multicast_add_group(struct net_bridge *br,
-                                  struct net_bridge_port *port, __be32 group)
+                                  struct net_bridge_port *port,
+                                  struct br_ip *group)
 {
         struct net_bridge_mdb_entry *mp;
         struct net_bridge_port_group *p;
@@ -517,9 +699,6 @@ static int br_multicast_add_group(struct net_bridge *br,
         unsigned long now = jiffies;
         int err;
 
-        if (ipv4_is_local_multicast(group))
-                return 0;
-
         spin_lock(&br->multicast_lock);
         if (!netif_running(br->dev) ||
             (port && port->state == BR_STATE_DISABLED))
@@ -548,7 +727,7 @@ static int br_multicast_add_group(struct net_bridge *br,
         if (unlikely(!p))
                 goto err;
 
-        p->addr = group;
+        p->addr = *group;
         p->port = port;
         p->next = *pp;
         hlist_add_head(&p->mglist, &port->mglist);
@@ -569,6 +748,38 @@ err:
         return err;
 }
 
+static int br_ip4_multicast_add_group(struct net_bridge *br,
+                                      struct net_bridge_port *port,
+                                      __be32 group)
+{
+        struct br_ip br_group;
+
+        if (ipv4_is_local_multicast(group))
+                return 0;
+
+        br_group.u.ip4 = group;
+        br_group.proto = htons(ETH_P_IP);
+
+        return br_multicast_add_group(br, port, &br_group);
+}
+
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
+static int br_ip6_multicast_add_group(struct net_bridge *br,
+                                      struct net_bridge_port *port,
+                                      const struct in6_addr *group)
+{
+        struct br_ip br_group;
+
+        if (ipv6_is_local_multicast(group))
+                return 0;
+
+        ipv6_addr_copy(&br_group.u.ip6, group);
+        br_group.proto = htons(ETH_P_IP);
+
+        return br_multicast_add_group(br, port, &br_group);
+}
+#endif
+
 static void br_multicast_router_expired(unsigned long data)
 {
         struct net_bridge_port *port = (void *)data;
@@ -590,19 +801,15 @@ static void br_multicast_local_router_expired(unsigned long data)
 {
 }
 
-static void br_multicast_send_query(struct net_bridge *br,
-                                    struct net_bridge_port *port, u32 sent)
+static void __br_multicast_send_query(struct net_bridge *br,
+                                      struct net_bridge_port *port,
+                                      struct br_ip *ip)
 {
-        unsigned long time;
         struct sk_buff *skb;
 
-        if (!netif_running(br->dev) || br->multicast_disabled ||
-            timer_pending(&br->multicast_querier_timer))
-                return;
-
-        skb = br_multicast_alloc_query(br, 0);
+        skb = br_multicast_alloc_query(br, ip);
         if (!skb)
-                goto timer;
+                return;
 
         if (port) {
                 __skb_push(skb, sizeof(struct ethhdr));
@@ -611,8 +818,28 @@ static void br_multicast_send_query(struct net_bridge *br,
                         dev_queue_xmit);
         } else
                 netif_rx(skb);
+}
+
+static void br_multicast_send_query(struct net_bridge *br,
+                                    struct net_bridge_port *port, u32 sent)
+{
+        unsigned long time;
+        struct br_ip br_group;
+
+        if (!netif_running(br->dev) || br->multicast_disabled ||
+            timer_pending(&br->multicast_querier_timer))
+                return;
+
+        memset(&br_group.u, 0, sizeof(br_group.u));
+
+        br_group.proto = htons(ETH_P_IP);
+        __br_multicast_send_query(br, port, &br_group);
+
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
+        br_group.proto = htons(ETH_P_IPV6);
+        __br_multicast_send_query(br, port, &br_group);
+#endif
 
-timer:
         time = jiffies;
         time += sent < br->multicast_startup_query_count ?
                 br->multicast_startup_query_interval :
@@ -697,9 +924,9 @@ void br_multicast_disable_port(struct net_bridge_port *port)
         spin_unlock(&br->multicast_lock);
 }
 
-static int br_multicast_igmp3_report(struct net_bridge *br,
-                                     struct net_bridge_port *port,
-                                     struct sk_buff *skb)
+static int br_ip4_multicast_igmp3_report(struct net_bridge *br,
+                                         struct net_bridge_port *port,
+                                         struct sk_buff *skb)
 {
         struct igmpv3_report *ih;
         struct igmpv3_grec *grec;
@@ -722,11 +949,11 @@ static int br_multicast_igmp3_report(struct net_bridge *br,
                 if (!pskb_may_pull(skb, len))
                         return -EINVAL;
 
-                grec = (void *)(skb->data + len);
+                grec = (void *)(skb->data + len - sizeof(*grec));
                 group = grec->grec_mca;
                 type = grec->grec_type;
 
-                len += grec->grec_nsrcs * 4;
+                len += ntohs(grec->grec_nsrcs) * 4;
                 if (!pskb_may_pull(skb, len))
                         return -EINVAL;
 
@@ -744,7 +971,7 @@ static int br_multicast_igmp3_report(struct net_bridge *br,
                         continue;
                 }
 
-                err = br_multicast_add_group(br, port, group);
+                err = br_ip4_multicast_add_group(br, port, group);
                 if (err)
                         break;
         }
@@ -752,24 +979,87 @@ static int br_multicast_igmp3_report(struct net_bridge *br,
         return err;
 }
 
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
+static int br_ip6_multicast_mld2_report(struct net_bridge *br,
+                                        struct net_bridge_port *port,
+                                        struct sk_buff *skb)
+{
+        struct icmp6hdr *icmp6h;
+        struct mld2_grec *grec;
+        int i;
+        int len;
+        int num;
+        int err = 0;
+
+        if (!pskb_may_pull(skb, sizeof(*icmp6h)))
+                return -EINVAL;
+
+        icmp6h = icmp6_hdr(skb);
+        num = ntohs(icmp6h->icmp6_dataun.un_data16[1]);
+        len = sizeof(*icmp6h);
+
+        for (i = 0; i < num; i++) {
+                __be16 *nsrcs, _nsrcs;
+
+                nsrcs = skb_header_pointer(skb,
+                                           len + offsetof(struct mld2_grec,
+                                                          grec_mca),
+                                           sizeof(_nsrcs), &_nsrcs);
+                if (!nsrcs)
+                        return -EINVAL;
+
+                if (!pskb_may_pull(skb,
+                                   len + sizeof(*grec) +
+                                   sizeof(struct in6_addr) * (*nsrcs)))
+                        return -EINVAL;
+
+                grec = (struct mld2_grec *)(skb->data + len);
+                len += sizeof(*grec) + sizeof(struct in6_addr) * (*nsrcs);
+
+                /* We treat these as MLDv1 reports for now. */
+                switch (grec->grec_type) {
+                case MLD2_MODE_IS_INCLUDE:
+                case MLD2_MODE_IS_EXCLUDE:
+                case MLD2_CHANGE_TO_INCLUDE:
+                case MLD2_CHANGE_TO_EXCLUDE:
+                case MLD2_ALLOW_NEW_SOURCES:
+                case MLD2_BLOCK_OLD_SOURCES:
+                        break;
+
+                default:
+                        continue;
+                }
+
+                err = br_ip6_multicast_add_group(br, port, &grec->grec_mca);
+                if (!err)
+                        break;
+        }
+
+        return err;
+}
+#endif
+
+/*
+ * Add port to rotuer_list
+ *  list is maintained ordered by pointer value
+ *  and locked by br->multicast_lock and RCU
+ */
 static void br_multicast_add_router(struct net_bridge *br,
                                     struct net_bridge_port *port)
 {
-        struct hlist_node *p;
-        struct hlist_node **h;
-
-        for (h = &br->router_list.first;
-             (p = *h) &&
-             (unsigned long)container_of(p, struct net_bridge_port, rlist) >
-             (unsigned long)port;
-             h = &p->next)
-                ;
-
-        port->rlist.pprev = h;
-        port->rlist.next = p;
-        rcu_assign_pointer(*h, &port->rlist);
-        if (p)
-                p->pprev = &port->rlist.next;
+        struct net_bridge_port *p;
+        struct hlist_node *n, *slot = NULL;
+
+        hlist_for_each_entry(p, n, &br->router_list, rlist) {
+                if ((unsigned long) port >= (unsigned long) p)
+                        break;
+                slot = n;
+        }
+
+        if (slot)
+                hlist_add_after_rcu(slot, &port->rlist);
+        else
+                hlist_add_head_rcu(&port->rlist, &br->router_list);
 }
 
 static void br_multicast_mark_router(struct net_bridge *br,
@@ -799,7 +1089,7 @@ timer:
 
 static void br_multicast_query_received(struct net_bridge *br,
                                         struct net_bridge_port *port,
-                                        __be32 saddr)
+                                        int saddr)
 {
         if (saddr)
                 mod_timer(&br->multicast_querier_timer,
@@ -810,9 +1100,9 @@ static void br_multicast_query_received(struct net_bridge *br,
         br_multicast_mark_router(br, port);
 }
 
-static int br_multicast_query(struct net_bridge *br,
-                              struct net_bridge_port *port,
-                              struct sk_buff *skb)
+static int br_ip4_multicast_query(struct net_bridge *br,
+                                  struct net_bridge_port *port,
+                                  struct sk_buff *skb)
 {
         struct iphdr *iph = ip_hdr(skb);
         struct igmphdr *ih = igmp_hdr(skb);
@@ -823,13 +1113,14 @@ static int br_multicast_query(struct net_bridge *br,
         unsigned long max_delay;
         unsigned long now = jiffies;
         __be32 group;
+        int err = 0;
 
         spin_lock(&br->multicast_lock);
         if (!netif_running(br->dev) ||
             (port && port->state == BR_STATE_DISABLED))
                 goto out;
 
-        br_multicast_query_received(br, port, iph->saddr);
+        br_multicast_query_received(br, port, !!iph->saddr);
 
         group = ih->group;
 
@@ -841,21 +1132,23 @@ static int br_multicast_query(struct net_bridge *br,
                         group = 0;
                 }
         } else {
-                if (!pskb_may_pull(skb, sizeof(struct igmpv3_query)))
-                        return -EINVAL;
+                if (!pskb_may_pull(skb, sizeof(struct igmpv3_query))) {
+                        err = -EINVAL;
+                        goto out;
+                }
 
                 ih3 = igmpv3_query_hdr(skb);
                 if (ih3->nsrcs)
-                        return 0;
+                        goto out;
 
-                max_delay = ih3->code ? 1 :
-                            IGMPV3_MRC(ih3->code) * (HZ / IGMP_TIMER_SCALE);
+                max_delay = ih3->code ?
+                            IGMPV3_MRC(ih3->code) * (HZ / IGMP_TIMER_SCALE) : 1;
         }
 
         if (!group)
                 goto out;
 
-        mp = br_mdb_ip_get(br->mdb, group);
+        mp = br_mdb_ip4_get(br->mdb, group);
         if (!mp)
                 goto out;
 
@@ -876,12 +1169,81 @@ static int br_multicast_query(struct net_bridge *br,
 
 out:
         spin_unlock(&br->multicast_lock);
-        return 0;
+        return err;
 }
 
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
+static int br_ip6_multicast_query(struct net_bridge *br,
+                                  struct net_bridge_port *port,
+                                  struct sk_buff *skb)
+{
+        struct ipv6hdr *ip6h = ipv6_hdr(skb);
+        struct mld_msg *mld = (struct mld_msg *) icmp6_hdr(skb);
+        struct net_bridge_mdb_entry *mp;
+        struct mld2_query *mld2q;
+        struct net_bridge_port_group *p, **pp;
+        unsigned long max_delay;
+        unsigned long now = jiffies;
+        struct in6_addr *group = NULL;
+        int err = 0;
+
+        spin_lock(&br->multicast_lock);
+        if (!netif_running(br->dev) ||
+            (port && port->state == BR_STATE_DISABLED))
+                goto out;
+
+        br_multicast_query_received(br, port, !ipv6_addr_any(&ip6h->saddr));
+
+        if (skb->len == sizeof(*mld)) {
+                if (!pskb_may_pull(skb, sizeof(*mld))) {
+                        err = -EINVAL;
+                        goto out;
+                }
+                mld = (struct mld_msg *) icmp6_hdr(skb);
+                max_delay = msecs_to_jiffies(htons(mld->mld_maxdelay));
+                if (max_delay)
+                        group = &mld->mld_mca;
+        } else if (skb->len >= sizeof(*mld2q)) {
+                if (!pskb_may_pull(skb, sizeof(*mld2q))) {
+                        err = -EINVAL;
+                        goto out;
+                }
+                mld2q = (struct mld2_query *)icmp6_hdr(skb);
+                if (!mld2q->mld2q_nsrcs)
+                        group = &mld2q->mld2q_mca;
+                max_delay = mld2q->mld2q_mrc ? MLDV2_MRC(mld2q->mld2q_mrc) : 1;
+        }
+
+        if (!group)
+                goto out;
+
+        mp = br_mdb_ip6_get(br->mdb, group);
+        if (!mp)
+                goto out;
+
+        max_delay *= br->multicast_last_member_count;
+        if (!hlist_unhashed(&mp->mglist) &&
+            (timer_pending(&mp->timer) ?
+             time_after(mp->timer.expires, now + max_delay) :
+             try_to_del_timer_sync(&mp->timer) >= 0))
+                mod_timer(&mp->timer, now + max_delay);
+
+        for (pp = &mp->ports; (p = *pp); pp = &p->next) {
+                if (timer_pending(&p->timer) ?
+                    time_after(p->timer.expires, now + max_delay) :
+                    try_to_del_timer_sync(&p->timer) >= 0)
+                        mod_timer(&mp->timer, now + max_delay);
+        }
+
+out:
+        spin_unlock(&br->multicast_lock);
+        return err;
+}
+#endif
+
 static void br_multicast_leave_group(struct net_bridge *br,
                                      struct net_bridge_port *port,
-                                     __be32 group)
+                                     struct br_ip *group)
 {
         struct net_bridge_mdb_htable *mdb;
         struct net_bridge_mdb_entry *mp;
@@ -889,9 +1251,6 @@ static void br_multicast_leave_group(struct net_bridge *br,
         unsigned long now;
         unsigned long time;
 
-        if (ipv4_is_local_multicast(group))
-                return;
-
         spin_lock(&br->multicast_lock);
         if (!netif_running(br->dev) ||
             (port && port->state == BR_STATE_DISABLED) ||
@@ -942,6 +1301,38 @@ out:
         spin_unlock(&br->multicast_lock);
 }
 
+static void br_ip4_multicast_leave_group(struct net_bridge *br,
+                                         struct net_bridge_port *port,
+                                         __be32 group)
+{
+        struct br_ip br_group;
+
+        if (ipv4_is_local_multicast(group))
+                return;
+
+        br_group.u.ip4 = group;
+        br_group.proto = htons(ETH_P_IP);
+
+        br_multicast_leave_group(br, port, &br_group);
+}
+
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
+static void br_ip6_multicast_leave_group(struct net_bridge *br,
+                                         struct net_bridge_port *port,
+                                         const struct in6_addr *group)
+{
+        struct br_ip br_group;
+
+        if (ipv6_is_local_multicast(group))
+                return;
+
+        ipv6_addr_copy(&br_group.u.ip6, group);
+        br_group.proto = htons(ETH_P_IPV6);
+
+        br_multicast_leave_group(br, port, &br_group);
+}
+#endif
+
 static int br_multicast_ipv4_rcv(struct net_bridge *br,
                                  struct net_bridge_port *port,
                                  struct sk_buff *skb)
@@ -953,9 +1344,6 @@ static int br_multicast_ipv4_rcv(struct net_bridge *br,
         unsigned offset;
         int err;
 
-        BR_INPUT_SKB_CB(skb)->igmp = 0;
-        BR_INPUT_SKB_CB(skb)->mrouters_only = 0;
-
         /* We treat OOM as packet loss for now. */
         if (!pskb_may_pull(skb, sizeof(*iph)))
                 return -EINVAL;
@@ -987,7 +1375,7 @@ static int br_multicast_ipv4_rcv(struct net_bridge *br,
 
                 err = pskb_trim_rcsum(skb2, len);
                 if (err)
-                        return err;
+                        goto err_out;
         }
 
         len -= ip_hdrlen(skb2);
@@ -999,8 +1387,6 @@ static int br_multicast_ipv4_rcv(struct net_bridge *br,
         if (!pskb_may_pull(skb2, sizeof(*ih)))
                 goto out;
 
-        iph = ip_hdr(skb2);
-
         switch (skb2->ip_summed) {
         case CHECKSUM_COMPLETE:
                 if (!csum_fold(skb2->csum))
@@ -1009,7 +1395,7 @@ static int br_multicast_ipv4_rcv(struct net_bridge *br,
         case CHECKSUM_NONE:
                 skb2->csum = 0;
                 if (skb_checksum_complete(skb2))
-                        return -EINVAL;
+                        goto out;
         }
 
         err = 0;
@@ -1021,17 +1407,134 @@ static int br_multicast_ipv4_rcv(struct net_bridge *br,
         case IGMP_HOST_MEMBERSHIP_REPORT:
         case IGMPV2_HOST_MEMBERSHIP_REPORT:
                 BR_INPUT_SKB_CB(skb2)->mrouters_only = 1;
-                err = br_multicast_add_group(br, port, ih->group);
+                err = br_ip4_multicast_add_group(br, port, ih->group);
                 break;
         case IGMPV3_HOST_MEMBERSHIP_REPORT:
-                err = br_multicast_igmp3_report(br, port, skb2);
+                err = br_ip4_multicast_igmp3_report(br, port, skb2);
                 break;
         case IGMP_HOST_MEMBERSHIP_QUERY:
-                err = br_multicast_query(br, port, skb2);
+                err = br_ip4_multicast_query(br, port, skb2);
                 break;
         case IGMP_HOST_LEAVE_MESSAGE:
-                br_multicast_leave_group(br, port, ih->group);
+                br_ip4_multicast_leave_group(br, port, ih->group);
+                break;
+        }
+
+out:
+        __skb_push(skb2, offset);
+err_out:
+        if (skb2 != skb)
+                kfree_skb(skb2);
+        return err;
+}
+
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
+static int br_multicast_ipv6_rcv(struct net_bridge *br,
+                                 struct net_bridge_port *port,
+                                 struct sk_buff *skb)
+{
+        struct sk_buff *skb2 = skb;
+        struct ipv6hdr *ip6h;
+        struct icmp6hdr *icmp6h;
+        u8 nexthdr;
+        unsigned len;
+        unsigned offset;
+        int err;
+
+        if (!pskb_may_pull(skb, sizeof(*ip6h)))
+                return -EINVAL;
+
+        ip6h = ipv6_hdr(skb);
+
+        /*
+         * We're interested in MLD messages only.
+         *  - Version is 6
+         *  - MLD has always Router Alert hop-by-hop option
+         *  - But we do not support jumbrograms.
+         */
+        if (ip6h->version != 6 ||
+            ip6h->nexthdr != IPPROTO_HOPOPTS ||
+            ip6h->payload_len == 0)
+                return 0;
+
+        len = ntohs(ip6h->payload_len);
+        if (skb->len < len)
+                return -EINVAL;
+
+        nexthdr = ip6h->nexthdr;
+        offset = ipv6_skip_exthdr(skb, sizeof(*ip6h), &nexthdr);
+
+        if (offset < 0 || nexthdr != IPPROTO_ICMPV6)
+                return 0;
+
+        /* Okay, we found ICMPv6 header */
+        skb2 = skb_clone(skb, GFP_ATOMIC);
+        if (!skb2)
+                return -ENOMEM;
+
+        len -= offset - skb_network_offset(skb2);
+
+        __skb_pull(skb2, offset);
+        skb_reset_transport_header(skb2);
+
+        err = -EINVAL;
+        if (!pskb_may_pull(skb2, sizeof(*icmp6h)))
+                goto out;
+
+        icmp6h = icmp6_hdr(skb2);
+
+        switch (icmp6h->icmp6_type) {
+        case ICMPV6_MGM_QUERY:
+        case ICMPV6_MGM_REPORT:
+        case ICMPV6_MGM_REDUCTION:
+        case ICMPV6_MLD2_REPORT:
+                break;
+        default:
+                err = 0;
+                goto out;
+        }
+
+        /* Okay, we found MLD message. Check further. */
+        if (skb2->len > len) {
+                err = pskb_trim_rcsum(skb2, len);
+                if (err)
+                        goto out;
+        }
+
+        switch (skb2->ip_summed) {
+        case CHECKSUM_COMPLETE:
+                if (!csum_fold(skb2->csum))
+                        break;
+                /*FALLTHROUGH*/
+        case CHECKSUM_NONE:
+                skb2->csum = 0;
+                if (skb_checksum_complete(skb2))
+                        goto out;
+        }
+
+        err = 0;
+
+        BR_INPUT_SKB_CB(skb)->igmp = 1;
+
+        switch (icmp6h->icmp6_type) {
+        case ICMPV6_MGM_REPORT:
+            {
+                struct mld_msg *mld = (struct mld_msg *)icmp6h;
+                BR_INPUT_SKB_CB(skb2)->mrouters_only = 1;
+                err = br_ip6_multicast_add_group(br, port, &mld->mld_mca);
+                break;
+            }
+        case ICMPV6_MLD2_REPORT:
+                err = br_ip6_multicast_mld2_report(br, port, skb2);
                 break;
+        case ICMPV6_MGM_QUERY:
+                err = br_ip6_multicast_query(br, port, skb2);
+                break;
+        case ICMPV6_MGM_REDUCTION:
+            {
+                struct mld_msg *mld = (struct mld_msg *)icmp6h;
+                br_ip6_multicast_leave_group(br, port, &mld->mld_mca);
+            }
         }
 
 out:
@@ -1040,16 +1543,24 @@ out:
                 kfree_skb(skb2);
         return err;
 }
+#endif
 
 int br_multicast_rcv(struct net_bridge *br, struct net_bridge_port *port,
                      struct sk_buff *skb)
 {
+        BR_INPUT_SKB_CB(skb)->igmp = 0;
+        BR_INPUT_SKB_CB(skb)->mrouters_only = 0;
+
         if (br->multicast_disabled)
                 return 0;
 
         switch (skb->protocol) {
         case htons(ETH_P_IP):
                 return br_multicast_ipv4_rcv(br, port, skb);
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
+        case htons(ETH_P_IPV6):
+                return br_multicast_ipv6_rcv(br, port, skb);
+#endif
         }
 
         return 0;
diff --git a/net/bridge/br_netfilter.c b/net/bridge/br_netfilter.c
index 268e2e725888..4c4977d12fd6 100644
--- a/net/bridge/br_netfilter.c
+++ b/net/bridge/br_netfilter.c
@@ -23,6 +23,7 @@
 
 #include <linux/module.h>
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/ip.h>
 #include <linux/netdevice.h>
 #include <linux/skbuff.h>
diff --git a/net/bridge/br_netlink.c b/net/bridge/br_netlink.c
index fcffb3fb1177..aa56ac2c8829 100644
--- a/net/bridge/br_netlink.c
+++ b/net/bridge/br_netlink.c
@@ -11,6 +11,7 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <net/rtnetlink.h>
 #include <net/net_namespace.h>
 #include <net/sock.h>
diff --git a/net/bridge/br_notify.c b/net/bridge/br_notify.c
index 763a3ec292e5..1413b72acc7f 100644
--- a/net/bridge/br_notify.c
+++ b/net/bridge/br_notify.c
@@ -82,6 +82,10 @@ static int br_device_event(struct notifier_block *unused, unsigned long event, v
         case NETDEV_UNREGISTER:
                 br_del_if(br, dev);
                 break;
+
+        case NETDEV_PRE_TYPE_CHANGE:
+                /* Forbid underlaying device to change its type. */
+                return NOTIFY_BAD;
         }
 
         /* Events that may cause spanning tree to refresh */
diff --git a/net/bridge/br_private.h b/net/bridge/br_private.h
index 1cf2cef78584..018499ebe19d 100644
--- a/net/bridge/br_private.h
+++ b/net/bridge/br_private.h
@@ -45,6 +45,17 @@ struct mac_addr
         unsigned char   addr[6];
 };
 
+struct br_ip
+{
+        union {
+                __be32  ip4;
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
+                struct in6_addr ip6;
+#endif
+        } u;
+        __be16          proto;
+};
+
 struct net_bridge_fdb_entry
 {
         struct hlist_node               hlist;
@@ -64,7 +75,7 @@ struct net_bridge_port_group {
         struct rcu_head                 rcu;
         struct timer_list               timer;
         struct timer_list               query_timer;
-        __be32                          addr;
+        struct br_ip                    addr;
         u32                             queries_sent;
 };
 
@@ -77,7 +88,7 @@ struct net_bridge_mdb_entry
         struct rcu_head                 rcu;
         struct timer_list               timer;
         struct timer_list               query_timer;
-        __be32                          addr;
+        struct br_ip                    addr;
         u32                             queries_sent;
 };
 
@@ -130,11 +141,20 @@ struct net_bridge_port
 #endif
 };
 
+struct br_cpu_netstats {
+        unsigned long   rx_packets;
+        unsigned long   rx_bytes;
+        unsigned long   tx_packets;
+        unsigned long   tx_bytes;
+};
+
 struct net_bridge
 {
         spinlock_t                      lock;
         struct list_head                port_list;
         struct net_device               *dev;
+
+        struct br_cpu_netstats __percpu *stats;
         spinlock_t                      hash_lock;
         struct hlist_head               hash[BR_HASH_SIZE];
         unsigned long                   feature_mask;
@@ -206,12 +226,20 @@ struct net_bridge
 
 struct br_input_skb_cb {
         struct net_device *brdev;
+#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
         int igmp;
         int mrouters_only;
+#endif
 };
 
 #define BR_INPUT_SKB_CB(__skb)  ((struct br_input_skb_cb *)(__skb)->cb)
 
+#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
+# define BR_INPUT_SKB_CB_MROUTERS_ONLY(__skb)   (BR_INPUT_SKB_CB(__skb)->mrouters_only)
+#else
+# define BR_INPUT_SKB_CB_MROUTERS_ONLY(__skb)   (0)
+#endif
+
 extern struct notifier_block br_device_notifier;
 extern const u8 br_group_address[ETH_ALEN];
 
@@ -252,7 +280,7 @@ extern void br_deliver(const struct net_bridge_port *to,
                 struct sk_buff *skb);
 extern int br_dev_queue_push_xmit(struct sk_buff *skb);
 extern void br_forward(const struct net_bridge_port *to,
-                struct sk_buff *skb);
+                struct sk_buff *skb, struct sk_buff *skb0);
 extern int br_forward_finish(struct sk_buff *skb);
 extern void br_flood_deliver(struct net_bridge *br, struct sk_buff *skb);
 extern void br_flood_forward(struct net_bridge *br, struct sk_buff *skb,
@@ -423,7 +451,7 @@ extern void br_ifinfo_notify(int event, struct net_bridge_port *port);
 
 #ifdef CONFIG_SYSFS
 /* br_sysfs_if.c */
-extern struct sysfs_ops brport_sysfs_ops;
+extern const struct sysfs_ops brport_sysfs_ops;
 extern int br_sysfs_addif(struct net_bridge_port *p);
 
 /* br_sysfs_br.c */
diff --git a/net/bridge/br_stp_bpdu.c b/net/bridge/br_stp_bpdu.c
index 81ae40b3f655..d66cce11f3bf 100644
--- a/net/bridge/br_stp_bpdu.c
+++ b/net/bridge/br_stp_bpdu.c
@@ -15,6 +15,7 @@
 #include <linux/netfilter_bridge.h>
 #include <linux/etherdevice.h>
 #include <linux/llc.h>
+#include <linux/slab.h>
 #include <net/net_namespace.h>
 #include <net/llc.h>
 #include <net/llc_pdu.h>
diff --git a/net/bridge/br_sysfs_if.c b/net/bridge/br_sysfs_if.c
index 696596cd3384..0b9916489d6b 100644
--- a/net/bridge/br_sysfs_if.c
+++ b/net/bridge/br_sysfs_if.c
@@ -238,7 +238,7 @@ static ssize_t brport_store(struct kobject * kobj,
         return ret;
 }
 
-struct sysfs_ops brport_sysfs_ops = {
+const struct sysfs_ops brport_sysfs_ops = {
         .show = brport_show,
         .store = brport_store,
 };
diff --git a/net/bridge/netfilter/ebt_ulog.c b/net/bridge/netfilter/ebt_ulog.c
index c6ac657074a6..f9560f3dbdc7 100644
--- a/net/bridge/netfilter/ebt_ulog.c
+++ b/net/bridge/netfilter/ebt_ulog.c
@@ -29,6 +29,7 @@
  */
 
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/spinlock.h>
 #include <linux/socket.h>
 #include <linux/skbuff.h>
diff --git a/net/bridge/netfilter/ebtables.c b/net/bridge/netfilter/ebtables.c
index dfb58056a89a..f0865fd1e3ec 100644
--- a/net/bridge/netfilter/ebtables.c
+++ b/net/bridge/netfilter/ebtables.c
@@ -23,6 +23,7 @@
 #include <linux/netfilter_bridge/ebtables.h>
 #include <linux/spinlock.h>
 #include <linux/mutex.h>
+#include <linux/slab.h>
 #include <asm/uaccess.h>
 #include <linux/smp.h>
 #include <linux/cpumask.h>
diff --git a/net/caif/Kconfig b/net/caif/Kconfig
new file mode 100644
index 000000000000..cd1daf6008bd
--- /dev/null
+++ b/net/caif/Kconfig
@@ -0,0 +1,48 @@
+#
+# CAIF net configurations
+#
+
+#menu "CAIF Support"
+comment "CAIF Support"
+menuconfig CAIF
+        tristate "Enable CAIF support"
+        select CRC_CCITT
+        default n
+        ---help---
+        The "Communication CPU to Application CPU Interface" (CAIF) is a packet
+        based connection-oriented MUX protocol developed by ST-Ericsson for use
+        with its modems. It is accessed from user space as sockets (PF_CAIF).
+
+        Say Y (or M) here if you build for a phone product (e.g. Android or
+        MeeGo ) that uses CAIF as transport, if unsure say N.
+
+        If you select to build it as module then CAIF_NETDEV also needs to be
+        built as modules. You will also need to say yes to any CAIF physical
+        devices that your platform requires.
+
+        See Documentation/networking/caif for a further explanation on how to
+        use and configure CAIF.
+
+if CAIF
+
+config  CAIF_DEBUG
+        bool "Enable Debug"
+        default n
+        --- help ---
+        Enable the inclusion of debug code in the CAIF stack.
+        Be aware that doing this will impact performance.
+        If unsure say N.
+
+
+config CAIF_NETDEV
+        tristate "CAIF GPRS Network device"
+        default CAIF
+        ---help---
+        Say Y if you will be using a CAIF based GPRS network device.
+        This can be either built-in or a loadable module,
+        If you select to build it as a built-in then the main CAIF device must
+        also be a built-in.
+        If unsure say Y.
+
+endif
+#endmenu
diff --git a/net/caif/Makefile b/net/caif/Makefile
new file mode 100644
index 000000000000..34852af2595e
--- /dev/null
+++ b/net/caif/Makefile
@@ -0,0 +1,26 @@
+ifeq ($(CONFIG_CAIF_DEBUG),1)
+CAIF_DBG_FLAGS := -DDEBUG
+endif
+
+ccflags-y := $(CAIF_FLAGS) $(CAIF_DBG_FLAGS)
+
+caif-objs := caif_dev.o \
+        cfcnfg.o cfmuxl.o cfctrl.o  \
+        cffrml.o cfveil.o cfdbgl.o\
+        cfserl.o cfdgml.o  \
+        cfrfml.o cfvidl.o cfutill.o \
+        cfsrvl.o cfpkt_skbuff.o caif_config_util.o
+clean-dirs:= .tmp_versions
+
+clean-files:= \
+        Module.symvers \
+        modules.order \
+        *.cmd \
+        *.o \
+        *~
+
+obj-$(CONFIG_CAIF) += caif.o
+obj-$(CONFIG_CAIF_NETDEV) += chnl_net.o
+obj-$(CONFIG_CAIF) += caif_socket.o
+
+export-objs := caif.o
diff --git a/net/caif/caif_config_util.c b/net/caif/caif_config_util.c
new file mode 100644
index 000000000000..6f36580366f0
--- /dev/null
+++ b/net/caif/caif_config_util.c
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) ST-Ericsson AB 2010
+ * Author:      Sjur Brendeland sjur.brandeland@stericsson.com
+ * License terms: GNU General Public License (GPL) version 2
+ */
+
+#include <linux/module.h>
+#include <linux/spinlock.h>
+#include <net/caif/cfctrl.h>
+#include <net/caif/cfcnfg.h>
+#include <net/caif/caif_dev.h>
+
+int connect_req_to_link_param(struct cfcnfg *cnfg,
+                                struct caif_connect_request *s,
+                                struct cfctrl_link_param *l)
+{
+        struct dev_info *dev_info;
+        enum cfcnfg_phy_preference pref;
+        memset(l, 0, sizeof(*l));
+        l->priority = s->priority;
+
+        if (s->link_name[0] != '\0')
+                l->phyid = cfcnfg_get_named(cnfg, s->link_name);
+        else {
+                switch (s->link_selector) {
+                case CAIF_LINK_HIGH_BANDW:
+                        pref = CFPHYPREF_HIGH_BW;
+                        break;
+                case CAIF_LINK_LOW_LATENCY:
+                        pref = CFPHYPREF_LOW_LAT;
+                        break;
+                default:
+                        return -EINVAL;
+                }
+                dev_info = cfcnfg_get_phyid(cnfg, pref);
+                if (dev_info == NULL)
+                        return -ENODEV;
+                l->phyid = dev_info->id;
+        }
+        switch (s->protocol) {
+        case CAIFPROTO_AT:
+                l->linktype = CFCTRL_SRV_VEI;
+                if (s->sockaddr.u.at.type == CAIF_ATTYPE_PLAIN)
+                        l->chtype = 0x02;
+                else
+                        l->chtype = s->sockaddr.u.at.type;
+                l->endpoint = 0x00;
+                break;
+        case CAIFPROTO_DATAGRAM:
+                l->linktype = CFCTRL_SRV_DATAGRAM;
+                l->chtype = 0x00;
+                l->u.datagram.connid = s->sockaddr.u.dgm.connection_id;
+                break;
+        case CAIFPROTO_DATAGRAM_LOOP:
+                l->linktype = CFCTRL_SRV_DATAGRAM;
+                l->chtype = 0x03;
+                l->endpoint = 0x00;
+                l->u.datagram.connid = s->sockaddr.u.dgm.connection_id;
+                break;
+        case CAIFPROTO_RFM:
+                l->linktype = CFCTRL_SRV_RFM;
+                l->u.datagram.connid = s->sockaddr.u.rfm.connection_id;
+                strncpy(l->u.rfm.volume, s->sockaddr.u.rfm.volume,
+                        sizeof(l->u.rfm.volume)-1);
+                l->u.rfm.volume[sizeof(l->u.rfm.volume)-1] = 0;
+                break;
+        case CAIFPROTO_UTIL:
+                l->linktype = CFCTRL_SRV_UTIL;
+                l->endpoint = 0x00;
+                l->chtype = 0x00;
+                strncpy(l->u.utility.name, s->sockaddr.u.util.service,
+                        sizeof(l->u.utility.name)-1);
+                l->u.utility.name[sizeof(l->u.utility.name)-1] = 0;
+                caif_assert(sizeof(l->u.utility.name) > 10);
+                l->u.utility.paramlen = s->param.size;
+                if (l->u.utility.paramlen > sizeof(l->u.utility.params))
+                        l->u.utility.paramlen = sizeof(l->u.utility.params);
+
+                memcpy(l->u.utility.params, s->param.data,
+                       l->u.utility.paramlen);
+
+                break;
+        default:
+                return -EINVAL;
+        }
+        return 0;
+}
diff --git a/net/caif/caif_dev.c b/net/caif/caif_dev.c
new file mode 100644
index 000000000000..024fd5bb2d39
--- /dev/null
+++ b/net/caif/caif_dev.c
@@ -0,0 +1,418 @@
+/*
+ * CAIF Interface registration.
+ * Copyright (C) ST-Ericsson AB 2010
+ * Author:      Sjur Brendeland/sjur.brandeland@stericsson.com
+ * License terms: GNU General Public License (GPL) version 2
+ *
+ * Borrowed heavily from file: pn_dev.c. Thanks to
+ *  Remi Denis-Courmont <remi.denis-courmont@nokia.com>
+ *  and Sakari Ailus <sakari.ailus@nokia.com>
+ */
+
+#include <linux/version.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/if_arp.h>
+#include <linux/net.h>
+#include <linux/netdevice.h>
+#include <linux/skbuff.h>
+#include <linux/sched.h>
+#include <linux/wait.h>
+#include <net/netns/generic.h>
+#include <net/net_namespace.h>
+#include <net/pkt_sched.h>
+#include <net/caif/caif_device.h>
+#include <net/caif/caif_dev.h>
+#include <net/caif/caif_layer.h>
+#include <net/caif/cfpkt.h>
+#include <net/caif/cfcnfg.h>
+
+MODULE_LICENSE("GPL");
+#define TIMEOUT (HZ*5)
+
+/* Used for local tracking of the CAIF net devices */
+struct caif_device_entry {
+        struct cflayer layer;
+        struct list_head list;
+        atomic_t in_use;
+        atomic_t state;
+        u16 phyid;
+        struct net_device *netdev;
+        wait_queue_head_t event;
+};
+
+struct caif_device_entry_list {
+        struct list_head list;
+        /* Protects simulanous deletes in list */
+        spinlock_t lock;
+};
+
+struct caif_net {
+        struct caif_device_entry_list caifdevs;
+};
+
+static int caif_net_id;
+static struct cfcnfg *cfg;
+
+static struct caif_device_entry_list *caif_device_list(struct net *net)
+{
+        struct caif_net *caifn;
+        BUG_ON(!net);
+        caifn = net_generic(net, caif_net_id);
+        BUG_ON(!caifn);
+        return &caifn->caifdevs;
+}
+
+/* Allocate new CAIF device. */
+static struct caif_device_entry *caif_device_alloc(struct net_device *dev)
+{
+        struct caif_device_entry_list *caifdevs;
+        struct caif_device_entry *caifd;
+        caifdevs = caif_device_list(dev_net(dev));
+        BUG_ON(!caifdevs);
+        caifd = kzalloc(sizeof(*caifd), GFP_ATOMIC);
+        if (!caifd)
+                return NULL;
+        caifd->netdev = dev;
+        list_add(&caifd->list, &caifdevs->list);
+        init_waitqueue_head(&caifd->event);
+        return caifd;
+}
+
+static struct caif_device_entry *caif_get(struct net_device *dev)
+{
+        struct caif_device_entry_list *caifdevs =
+            caif_device_list(dev_net(dev));
+        struct caif_device_entry *caifd;
+        BUG_ON(!caifdevs);
+        list_for_each_entry(caifd, &caifdevs->list, list) {
+                if (caifd->netdev == dev)
+                        return caifd;
+        }
+        return NULL;
+}
+
+static void caif_device_destroy(struct net_device *dev)
+{
+        struct caif_device_entry_list *caifdevs =
+            caif_device_list(dev_net(dev));
+        struct caif_device_entry *caifd;
+        ASSERT_RTNL();
+        if (dev->type != ARPHRD_CAIF)
+                return;
+
+        spin_lock_bh(&caifdevs->lock);
+        caifd = caif_get(dev);
+        if (caifd == NULL) {
+                spin_unlock_bh(&caifdevs->lock);
+                return;
+        }
+
+        list_del(&caifd->list);
+        spin_unlock_bh(&caifdevs->lock);
+
+        kfree(caifd);
+        return;
+}
+
+static int transmit(struct cflayer *layer, struct cfpkt *pkt)
+{
+        struct caif_device_entry *caifd =
+            container_of(layer, struct caif_device_entry, layer);
+        struct sk_buff *skb, *skb2;
+        int ret = -EINVAL;
+        skb = cfpkt_tonative(pkt);
+        skb->dev = caifd->netdev;
+        /*
+         * Don't allow SKB to be destroyed upon error, but signal resend
+         * notification to clients. We can't rely on the return value as
+         * congestion (NET_XMIT_CN) sometimes drops the packet, sometimes don't.
+         */
+        if (netif_queue_stopped(caifd->netdev))
+                return -EAGAIN;
+        skb2 = skb_get(skb);
+
+        ret = dev_queue_xmit(skb2);
+
+        if (!ret)
+                kfree_skb(skb);
+        else
+                return -EAGAIN;
+
+        return 0;
+}
+
+static int modemcmd(struct cflayer *layr, enum caif_modemcmd ctrl)
+{
+        struct caif_device_entry *caifd;
+        struct caif_dev_common *caifdev;
+        caifd = container_of(layr, struct caif_device_entry, layer);
+        caifdev = netdev_priv(caifd->netdev);
+        if (ctrl == _CAIF_MODEMCMD_PHYIF_USEFULL) {
+                atomic_set(&caifd->in_use, 1);
+                wake_up_interruptible(&caifd->event);
+
+        } else if (ctrl == _CAIF_MODEMCMD_PHYIF_USELESS) {
+                atomic_set(&caifd->in_use, 0);
+                wake_up_interruptible(&caifd->event);
+        }
+        return 0;
+}
+
+/*
+ * Stuff received packets to associated sockets.
+ * On error, returns non-zero and releases the skb.
+ */
+static int receive(struct sk_buff *skb, struct net_device *dev,
+                   struct packet_type *pkttype, struct net_device *orig_dev)
+{
+        struct net *net;
+        struct cfpkt *pkt;
+        struct caif_device_entry *caifd;
+        net = dev_net(dev);
+        pkt = cfpkt_fromnative(CAIF_DIR_IN, skb);
+        caifd = caif_get(dev);
+        if (!caifd || !caifd->layer.up || !caifd->layer.up->ctrlcmd)
+                return NET_RX_DROP;
+
+        if (caifd->layer.up->receive(caifd->layer.up, pkt))
+                return NET_RX_DROP;
+
+        return 0;
+}
+
+static struct packet_type caif_packet_type __read_mostly = {
+        .type = cpu_to_be16(ETH_P_CAIF),
+        .func = receive,
+};
+
+static void dev_flowctrl(struct net_device *dev, int on)
+{
+        struct caif_device_entry *caifd = caif_get(dev);
+        if (!caifd || !caifd->layer.up || !caifd->layer.up->ctrlcmd)
+                return;
+
+        caifd->layer.up->ctrlcmd(caifd->layer.up,
+                                 on ?
+                                 _CAIF_CTRLCMD_PHYIF_FLOW_ON_IND :
+                                 _CAIF_CTRLCMD_PHYIF_FLOW_OFF_IND,
+                                 caifd->layer.id);
+}
+
+/* notify Caif of device events */
+static int caif_device_notify(struct notifier_block *me, unsigned long what,
+                              void *arg)
+{
+        struct net_device *dev = arg;
+        struct caif_device_entry *caifd = NULL;
+        struct caif_dev_common *caifdev;
+        enum cfcnfg_phy_preference pref;
+        int res = -EINVAL;
+        enum cfcnfg_phy_type phy_type;
+
+        if (dev->type != ARPHRD_CAIF)
+                return 0;
+
+        switch (what) {
+        case NETDEV_REGISTER:
+                pr_info("CAIF: %s():register %s\n", __func__, dev->name);
+                caifd = caif_device_alloc(dev);
+                if (caifd == NULL)
+                        break;
+                caifdev = netdev_priv(dev);
+                caifdev->flowctrl = dev_flowctrl;
+                atomic_set(&caifd->state, what);
+                res = 0;
+                break;
+
+        case NETDEV_UP:
+                pr_info("CAIF: %s(): up %s\n", __func__, dev->name);
+                caifd = caif_get(dev);
+                if (caifd == NULL)
+                        break;
+                caifdev = netdev_priv(dev);
+                if (atomic_read(&caifd->state) == NETDEV_UP) {
+                        pr_info("CAIF: %s():%s already up\n",
+                                __func__, dev->name);
+                        break;
+                }
+                atomic_set(&caifd->state, what);
+                caifd->layer.transmit = transmit;
+                caifd->layer.modemcmd = modemcmd;
+
+                if (caifdev->use_frag)
+                        phy_type = CFPHYTYPE_FRAG;
+                else
+                        phy_type = CFPHYTYPE_CAIF;
+
+                switch (caifdev->link_select) {
+                case CAIF_LINK_HIGH_BANDW:
+                        pref = CFPHYPREF_HIGH_BW;
+                        break;
+                case CAIF_LINK_LOW_LATENCY:
+                        pref = CFPHYPREF_LOW_LAT;
+                        break;
+                default:
+                        pref = CFPHYPREF_HIGH_BW;
+                        break;
+                }
+
+                cfcnfg_add_phy_layer(get_caif_conf(),
+                                     phy_type,
+                                     dev,
+                                     &caifd->layer,
+                                     &caifd->phyid,
+                                     pref,
+                                     caifdev->use_fcs,
+                                     caifdev->use_stx);
+                strncpy(caifd->layer.name, dev->name,
+                        sizeof(caifd->layer.name) - 1);
+                caifd->layer.name[sizeof(caifd->layer.name) - 1] = 0;
+                break;
+
+        case NETDEV_GOING_DOWN:
+                caifd = caif_get(dev);
+                if (caifd == NULL)
+                        break;
+                pr_info("CAIF: %s():going down %s\n", __func__, dev->name);
+
+                if (atomic_read(&caifd->state) == NETDEV_GOING_DOWN ||
+                        atomic_read(&caifd->state) == NETDEV_DOWN)
+                        break;
+
+                atomic_set(&caifd->state, what);
+                if (!caifd || !caifd->layer.up || !caifd->layer.up->ctrlcmd)
+                        return -EINVAL;
+                caifd->layer.up->ctrlcmd(caifd->layer.up,
+                                         _CAIF_CTRLCMD_PHYIF_DOWN_IND,
+                                         caifd->layer.id);
+                res = wait_event_interruptible_timeout(caifd->event,
+                                        atomic_read(&caifd->in_use) == 0,
+                                        TIMEOUT);
+                break;
+
+        case NETDEV_DOWN:
+                caifd = caif_get(dev);
+                if (caifd == NULL)
+                        break;
+                pr_info("CAIF: %s(): down %s\n", __func__, dev->name);
+                if (atomic_read(&caifd->in_use))
+                        pr_warning("CAIF: %s(): "
+                                   "Unregistering an active CAIF device: %s\n",
+                                   __func__, dev->name);
+                cfcnfg_del_phy_layer(get_caif_conf(), &caifd->layer);
+                atomic_set(&caifd->state, what);
+                break;
+
+        case NETDEV_UNREGISTER:
+                caifd = caif_get(dev);
+                pr_info("CAIF: %s(): unregister %s\n", __func__, dev->name);
+                atomic_set(&caifd->state, what);
+                caif_device_destroy(dev);
+                break;
+        }
+        return 0;
+}
+
+static struct notifier_block caif_device_notifier = {
+        .notifier_call = caif_device_notify,
+        .priority = 0,
+};
+
+
+struct cfcnfg *get_caif_conf(void)
+{
+        return cfg;
+}
+EXPORT_SYMBOL(get_caif_conf);
+
+int caif_connect_client(struct caif_connect_request *conn_req,
+                           struct cflayer *client_layer)
+{
+        struct cfctrl_link_param param;
+        int ret;
+        ret = connect_req_to_link_param(get_caif_conf(), conn_req, &param);
+        if (ret)
+                return ret;
+        /* Hook up the adaptation layer. */
+        return cfcnfg_add_adaptation_layer(get_caif_conf(),
+                                                &param, client_layer);
+}
+EXPORT_SYMBOL(caif_connect_client);
+
+int caif_disconnect_client(struct cflayer *adap_layer)
+{
+       return cfcnfg_disconn_adapt_layer(get_caif_conf(), adap_layer);
+}
+EXPORT_SYMBOL(caif_disconnect_client);
+
+void caif_release_client(struct cflayer *adap_layer)
+{
+       cfcnfg_release_adap_layer(adap_layer);
+}
+EXPORT_SYMBOL(caif_release_client);
+
+/* Per-namespace Caif devices handling */
+static int caif_init_net(struct net *net)
+{
+        struct caif_net *caifn = net_generic(net, caif_net_id);
+        INIT_LIST_HEAD(&caifn->caifdevs.list);
+        spin_lock_init(&caifn->caifdevs.lock);
+        return 0;
+}
+
+static void caif_exit_net(struct net *net)
+{
+        struct net_device *dev;
+        int res;
+        rtnl_lock();
+        for_each_netdev(net, dev) {
+                if (dev->type != ARPHRD_CAIF)
+                        continue;
+                res = dev_close(dev);
+                caif_device_destroy(dev);
+        }
+        rtnl_unlock();
+}
+
+static struct pernet_operations caif_net_ops = {
+        .init = caif_init_net,
+        .exit = caif_exit_net,
+        .id   = &caif_net_id,
+        .size = sizeof(struct caif_net),
+};
+
+/* Initialize Caif devices list */
+static int __init caif_device_init(void)
+{
+        int result;
+        cfg = cfcnfg_create();
+        if (!cfg) {
+                pr_warning("CAIF: %s(): can't create cfcnfg.\n", __func__);
+                goto err_cfcnfg_create_failed;
+        }
+        result = register_pernet_device(&caif_net_ops);
+
+        if (result) {
+                kfree(cfg);
+                cfg = NULL;
+                return result;
+        }
+        dev_add_pack(&caif_packet_type);
+        register_netdevice_notifier(&caif_device_notifier);
+
+        return result;
+err_cfcnfg_create_failed:
+        return -ENODEV;
+}
+
+static void __exit caif_device_exit(void)
+{
+        dev_remove_pack(&caif_packet_type);
+        unregister_pernet_device(&caif_net_ops);
+        unregister_netdevice_notifier(&caif_device_notifier);
+        cfcnfg_remove(cfg);
+}
+
+module_init(caif_device_init);
+module_exit(caif_device_exit);
diff --git a/net/caif/caif_socket.c b/net/caif/caif_socket.c
new file mode 100644
index 000000000000..c3a70c5c893a
--- /dev/null
+++ b/net/caif/caif_socket.c
@@ -0,0 +1,1252 @@
+/*
+ * Copyright (C) ST-Ericsson AB 2010
+ * Author:      Sjur Brendeland sjur.brandeland@stericsson.com
+ * License terms: GNU General Public License (GPL) version 2
+ */
+
+#include <linux/fs.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/sched.h>
+#include <linux/spinlock.h>
+#include <linux/mutex.h>
+#include <linux/list.h>
+#include <linux/wait.h>
+#include <linux/poll.h>
+#include <linux/tcp.h>
+#include <linux/uaccess.h>
+#include <linux/mutex.h>
+#include <linux/debugfs.h>
+#include <linux/caif/caif_socket.h>
+#include <asm/atomic.h>
+#include <net/sock.h>
+#include <net/tcp_states.h>
+#include <net/caif/caif_layer.h>
+#include <net/caif/caif_dev.h>
+#include <net/caif/cfpkt.h>
+
+MODULE_LICENSE("GPL");
+MODULE_ALIAS_NETPROTO(AF_CAIF);
+
+#define CAIF_DEF_SNDBUF (CAIF_MAX_PAYLOAD_SIZE*10)
+#define CAIF_DEF_RCVBUF (CAIF_MAX_PAYLOAD_SIZE*100)
+
+/*
+ * CAIF state is re-using the TCP socket states.
+ * caif_states stored in sk_state reflect the state as reported by
+ * the CAIF stack, while sk_socket->state is the state of the socket.
+ */
+enum caif_states {
+        CAIF_CONNECTED          = TCP_ESTABLISHED,
+        CAIF_CONNECTING = TCP_SYN_SENT,
+        CAIF_DISCONNECTED       = TCP_CLOSE
+};
+
+#define TX_FLOW_ON_BIT  1
+#define RX_FLOW_ON_BIT  2
+
+static struct dentry *debugfsdir;
+
+#ifdef CONFIG_DEBUG_FS
+struct debug_fs_counter {
+        atomic_t caif_nr_socks;
+        atomic_t num_connect_req;
+        atomic_t num_connect_resp;
+        atomic_t num_connect_fail_resp;
+        atomic_t num_disconnect;
+        atomic_t num_remote_shutdown_ind;
+        atomic_t num_tx_flow_off_ind;
+        atomic_t num_tx_flow_on_ind;
+        atomic_t num_rx_flow_off;
+        atomic_t num_rx_flow_on;
+};
+struct debug_fs_counter cnt;
+#define dbfs_atomic_inc(v) atomic_inc(v)
+#define dbfs_atomic_dec(v) atomic_dec(v)
+#else
+#define dbfs_atomic_inc(v)
+#define dbfs_atomic_dec(v)
+#endif
+
+struct caifsock {
+        struct sock sk; /* must be first member */
+        struct cflayer layer;
+        char name[CAIF_LAYER_NAME_SZ]; /* Used for debugging */
+        u32 flow_state;
+        struct caif_connect_request conn_req;
+        struct mutex readlock;
+        struct dentry *debugfs_socket_dir;
+};
+
+static int rx_flow_is_on(struct caifsock *cf_sk)
+{
+        return test_bit(RX_FLOW_ON_BIT,
+                        (void *) &cf_sk->flow_state);
+}
+
+static int tx_flow_is_on(struct caifsock *cf_sk)
+{
+        return test_bit(TX_FLOW_ON_BIT,
+                        (void *) &cf_sk->flow_state);
+}
+
+static void set_rx_flow_off(struct caifsock *cf_sk)
+{
+         clear_bit(RX_FLOW_ON_BIT,
+                 (void *) &cf_sk->flow_state);
+}
+
+static void set_rx_flow_on(struct caifsock *cf_sk)
+{
+         set_bit(RX_FLOW_ON_BIT,
+                        (void *) &cf_sk->flow_state);
+}
+
+static void set_tx_flow_off(struct caifsock *cf_sk)
+{
+         clear_bit(TX_FLOW_ON_BIT,
+                (void *) &cf_sk->flow_state);
+}
+
+static void set_tx_flow_on(struct caifsock *cf_sk)
+{
+         set_bit(TX_FLOW_ON_BIT,
+                (void *) &cf_sk->flow_state);
+}
+
+static void caif_read_lock(struct sock *sk)
+{
+        struct caifsock *cf_sk;
+        cf_sk = container_of(sk, struct caifsock, sk);
+        mutex_lock(&cf_sk->readlock);
+}
+
+static void caif_read_unlock(struct sock *sk)
+{
+        struct caifsock *cf_sk;
+        cf_sk = container_of(sk, struct caifsock, sk);
+        mutex_unlock(&cf_sk->readlock);
+}
+
+int sk_rcvbuf_lowwater(struct caifsock *cf_sk)
+{
+        /* A quarter of full buffer is used a low water mark */
+        return cf_sk->sk.sk_rcvbuf / 4;
+}
+
+void caif_flow_ctrl(struct sock *sk, int mode)
+{
+        struct caifsock *cf_sk;
+        cf_sk = container_of(sk, struct caifsock, sk);
+        if (cf_sk->layer.dn)
+                cf_sk->layer.dn->modemcmd(cf_sk->layer.dn, mode);
+}
+
+/*
+ * Copied from sock.c:sock_queue_rcv_skb(), but changed so packets are
+ * not dropped, but CAIF is sending flow off instead.
+ */
+int caif_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
+{
+        int err;
+        int skb_len;
+        unsigned long flags;
+        struct sk_buff_head *list = &sk->sk_receive_queue;
+        struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
+
+        if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >=
+                (unsigned)sk->sk_rcvbuf && rx_flow_is_on(cf_sk)) {
+                trace_printk("CAIF: %s():"
+                        " sending flow OFF (queue len = %d %d)\n",
+                        __func__,
+                        atomic_read(&cf_sk->sk.sk_rmem_alloc),
+                        sk_rcvbuf_lowwater(cf_sk));
+                set_rx_flow_off(cf_sk);
+                if (cf_sk->layer.dn)
+                        cf_sk->layer.dn->modemcmd(cf_sk->layer.dn,
+                                                CAIF_MODEMCMD_FLOW_OFF_REQ);
+        }
+
+        err = sk_filter(sk, skb);
+        if (err)
+                return err;
+        if (!sk_rmem_schedule(sk, skb->truesize) && rx_flow_is_on(cf_sk)) {
+                set_rx_flow_off(cf_sk);
+                trace_printk("CAIF: %s():"
+                        " sending flow OFF due to rmem_schedule\n",
+                        __func__);
+                if (cf_sk->layer.dn)
+                        cf_sk->layer.dn->modemcmd(cf_sk->layer.dn,
+                                                CAIF_MODEMCMD_FLOW_OFF_REQ);
+        }
+        skb->dev = NULL;
+        skb_set_owner_r(skb, sk);
+        /* Cache the SKB length before we tack it onto the receive
+         * queue. Once it is added it no longer belongs to us and
+         * may be freed by other threads of control pulling packets
+         * from the queue.
+         */
+        skb_len = skb->len;
+        spin_lock_irqsave(&list->lock, flags);
+        if (!sock_flag(sk, SOCK_DEAD))
+                __skb_queue_tail(list, skb);
+        spin_unlock_irqrestore(&list->lock, flags);
+
+        if (!sock_flag(sk, SOCK_DEAD))
+                sk->sk_data_ready(sk, skb_len);
+        else
+                kfree_skb(skb);
+        return 0;
+}
+
+/* Packet Receive Callback function called from CAIF Stack */
+static int caif_sktrecv_cb(struct cflayer *layr, struct cfpkt *pkt)
+{
+        struct caifsock *cf_sk;
+        struct sk_buff *skb;
+
+        cf_sk = container_of(layr, struct caifsock, layer);
+        skb = cfpkt_tonative(pkt);
+
+        if (unlikely(cf_sk->sk.sk_state != CAIF_CONNECTED)) {
+                cfpkt_destroy(pkt);
+                return 0;
+        }
+        caif_queue_rcv_skb(&cf_sk->sk, skb);
+        return 0;
+}
+
+/* Packet Control Callback function called from CAIF */
+static void caif_ctrl_cb(struct cflayer *layr,
+                                enum caif_ctrlcmd flow,
+                                int phyid)
+{
+        struct caifsock *cf_sk = container_of(layr, struct caifsock, layer);
+        switch (flow) {
+        case CAIF_CTRLCMD_FLOW_ON_IND:
+                /* OK from modem to start sending again */
+                dbfs_atomic_inc(&cnt.num_tx_flow_on_ind);
+                set_tx_flow_on(cf_sk);
+                cf_sk->sk.sk_state_change(&cf_sk->sk);
+                break;
+
+        case CAIF_CTRLCMD_FLOW_OFF_IND:
+                /* Modem asks us to shut up */
+                dbfs_atomic_inc(&cnt.num_tx_flow_off_ind);
+                set_tx_flow_off(cf_sk);
+                cf_sk->sk.sk_state_change(&cf_sk->sk);
+                break;
+
+        case CAIF_CTRLCMD_INIT_RSP:
+                /* We're now connected */
+                dbfs_atomic_inc(&cnt.num_connect_resp);
+                cf_sk->sk.sk_state = CAIF_CONNECTED;
+                set_tx_flow_on(cf_sk);
+                cf_sk->sk.sk_state_change(&cf_sk->sk);
+                break;
+
+        case CAIF_CTRLCMD_DEINIT_RSP:
+                /* We're now disconnected */
+                cf_sk->sk.sk_state = CAIF_DISCONNECTED;
+                cf_sk->sk.sk_state_change(&cf_sk->sk);
+                cfcnfg_release_adap_layer(&cf_sk->layer);
+                break;
+
+        case CAIF_CTRLCMD_INIT_FAIL_RSP:
+                /* Connect request failed */
+                dbfs_atomic_inc(&cnt.num_connect_fail_resp);
+                cf_sk->sk.sk_err = ECONNREFUSED;
+                cf_sk->sk.sk_state = CAIF_DISCONNECTED;
+                cf_sk->sk.sk_shutdown = SHUTDOWN_MASK;
+                /*
+                 * Socket "standards" seems to require POLLOUT to
+                 * be set at connect failure.
+                 */
+                set_tx_flow_on(cf_sk);
+                cf_sk->sk.sk_state_change(&cf_sk->sk);
+                break;
+
+        case CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND:
+                /* Modem has closed this connection, or device is down. */
+                dbfs_atomic_inc(&cnt.num_remote_shutdown_ind);
+                cf_sk->sk.sk_shutdown = SHUTDOWN_MASK;
+                cf_sk->sk.sk_err = ECONNRESET;
+                set_rx_flow_on(cf_sk);
+                cf_sk->sk.sk_error_report(&cf_sk->sk);
+                break;
+
+        default:
+                pr_debug("CAIF: %s(): Unexpected flow command %d\n",
+                                __func__, flow);
+        }
+}
+
+static void caif_check_flow_release(struct sock *sk)
+{
+        struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
+
+        if (cf_sk->layer.dn == NULL || cf_sk->layer.dn->modemcmd == NULL)
+                return;
+        if (rx_flow_is_on(cf_sk))
+                return;
+
+        if (atomic_read(&sk->sk_rmem_alloc) <= sk_rcvbuf_lowwater(cf_sk)) {
+                        dbfs_atomic_inc(&cnt.num_rx_flow_on);
+                        set_rx_flow_on(cf_sk);
+                        cf_sk->layer.dn->modemcmd(cf_sk->layer.dn,
+                                                CAIF_MODEMCMD_FLOW_ON_REQ);
+        }
+}
+/*
+ * Copied from sock.c:sock_queue_rcv_skb(), and added check that user buffer
+ * has sufficient size.
+ */
+
+static int caif_seqpkt_recvmsg(struct kiocb *iocb, struct socket *sock,
+                                struct msghdr *m, size_t buf_len, int flags)
+
+{
+        struct sock *sk = sock->sk;
+        struct sk_buff *skb;
+        int ret = 0;
+        int len;
+
+        if (unlikely(!buf_len))
+                return -EINVAL;
+
+        skb = skb_recv_datagram(sk, flags, 0 , &ret);
+        if (!skb)
+                goto read_error;
+
+        len = skb->len;
+
+        if (skb && skb->len > buf_len && !(flags & MSG_PEEK)) {
+                len = buf_len;
+                /*
+                 * Push skb back on receive queue if buffer too small.
+                 * This has a built-in race where multi-threaded receive
+                 * may get packet in wrong order, but multiple read does
+                 * not really guarantee ordered delivery anyway.
+                 * Let's optimize for speed without taking locks.
+                 */
+
+                skb_queue_head(&sk->sk_receive_queue, skb);
+                ret = -EMSGSIZE;
+                goto read_error;
+        }
+
+        ret = skb_copy_datagram_iovec(skb, 0, m->msg_iov, len);
+        if (ret)
+                goto read_error;
+
+        skb_free_datagram(sk, skb);
+
+        caif_check_flow_release(sk);
+
+        return len;
+
+read_error:
+        return ret;
+}
+
+
+/* Copied from unix_stream_wait_data, identical except for lock call. */
+static long caif_stream_data_wait(struct sock *sk, long timeo)
+{
+        DEFINE_WAIT(wait);
+        lock_sock(sk);
+
+        for (;;) {
+                prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
+
+                if (!skb_queue_empty(&sk->sk_receive_queue) ||
+                        sk->sk_err ||
+                        sk->sk_state != CAIF_CONNECTED ||
+                        sock_flag(sk, SOCK_DEAD) ||
+                        (sk->sk_shutdown & RCV_SHUTDOWN) ||
+                        signal_pending(current) ||
+                        !timeo)
+                        break;
+
+                set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
+                release_sock(sk);
+                timeo = schedule_timeout(timeo);
+                lock_sock(sk);
+                clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
+        }
+
+        finish_wait(sk_sleep(sk), &wait);
+        release_sock(sk);
+        return timeo;
+}
+
+
+/*
+ * Copied from unix_stream_recvmsg, but removed credit checks,
+ * changed locking calls, changed address handling.
+ */
+static int caif_stream_recvmsg(struct kiocb *iocb, struct socket *sock,
+                                struct msghdr *msg, size_t size,
+                                int flags)
+{
+        struct sock *sk = sock->sk;
+        int copied = 0;
+        int target;
+        int err = 0;
+        long timeo;
+
+        err = -EOPNOTSUPP;
+        if (flags&MSG_OOB)
+                goto out;
+
+        msg->msg_namelen = 0;
+
+        /*
+         * Lock the socket to prevent queue disordering
+         * while sleeps in memcpy_tomsg
+         */
+        err = -EAGAIN;
+        if (sk->sk_state == CAIF_CONNECTING)
+                goto out;
+
+        caif_read_lock(sk);
+        target = sock_rcvlowat(sk, flags&MSG_WAITALL, size);
+        timeo = sock_rcvtimeo(sk, flags&MSG_DONTWAIT);
+
+        do {
+                int chunk;
+                struct sk_buff *skb;
+
+                lock_sock(sk);
+                skb = skb_dequeue(&sk->sk_receive_queue);
+                caif_check_flow_release(sk);
+
+                if (skb == NULL) {
+                        if (copied >= target)
+                                goto unlock;
+                        /*
+                         *      POSIX 1003.1g mandates this order.
+                         */
+                        err = sock_error(sk);
+                        if (err)
+                                goto unlock;
+                        err = -ECONNRESET;
+                        if (sk->sk_shutdown & RCV_SHUTDOWN)
+                                goto unlock;
+
+                        err = -EPIPE;
+                        if (sk->sk_state != CAIF_CONNECTED)
+                                goto unlock;
+                        if (sock_flag(sk, SOCK_DEAD))
+                                goto unlock;
+
+                        release_sock(sk);
+
+                        err = -EAGAIN;
+                        if (!timeo)
+                                break;
+
+                        caif_read_unlock(sk);
+
+                        timeo = caif_stream_data_wait(sk, timeo);
+
+                        if (signal_pending(current)) {
+                                err = sock_intr_errno(timeo);
+                                goto out;
+                        }
+                        caif_read_lock(sk);
+                        continue;
+unlock:
+                        release_sock(sk);
+                        break;
+                }
+                release_sock(sk);
+                chunk = min_t(unsigned int, skb->len, size);
+                if (memcpy_toiovec(msg->msg_iov, skb->data, chunk)) {
+                        skb_queue_head(&sk->sk_receive_queue, skb);
+                        if (copied == 0)
+                                copied = -EFAULT;
+                        break;
+                }
+                copied += chunk;
+                size -= chunk;
+
+                /* Mark read part of skb as used */
+                if (!(flags & MSG_PEEK)) {
+                        skb_pull(skb, chunk);
+
+                        /* put the skb back if we didn't use it up. */
+                        if (skb->len) {
+                                skb_queue_head(&sk->sk_receive_queue, skb);
+                                break;
+                        }
+                        kfree_skb(skb);
+
+                } else {
+                        /*
+                         * It is questionable, see note in unix_dgram_recvmsg.
+                         */
+                        /* put message back and return */
+                        skb_queue_head(&sk->sk_receive_queue, skb);
+                        break;
+                }
+        } while (size);
+        caif_read_unlock(sk);
+
+out:
+        return copied ? : err;
+}
+
+/*
+ * Copied from sock.c:sock_wait_for_wmem, but change to wait for
+ * CAIF flow-on and sock_writable.
+ */
+static long caif_wait_for_flow_on(struct caifsock *cf_sk,
+                                int wait_writeable, long timeo, int *err)
+{
+        struct sock *sk = &cf_sk->sk;
+        DEFINE_WAIT(wait);
+        for (;;) {
+                *err = 0;
+                if (tx_flow_is_on(cf_sk) &&
+                        (!wait_writeable || sock_writeable(&cf_sk->sk)))
+                        break;
+                *err = -ETIMEDOUT;
+                if (!timeo)
+                        break;
+                *err = -ERESTARTSYS;
+                if (signal_pending(current))
+                        break;
+                prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
+                *err = -ECONNRESET;
+                if (sk->sk_shutdown & SHUTDOWN_MASK)
+                        break;
+                *err = -sk->sk_err;
+                if (sk->sk_err)
+                        break;
+                *err = -EPIPE;
+                if (cf_sk->sk.sk_state != CAIF_CONNECTED)
+                        break;
+                timeo = schedule_timeout(timeo);
+        }
+        finish_wait(sk_sleep(sk), &wait);
+        return timeo;
+}
+
+/*
+ * Transmit a SKB. The device may temporarily request re-transmission
+ * by returning EAGAIN.
+ */
+static int transmit_skb(struct sk_buff *skb, struct caifsock *cf_sk,
+                        int noblock, long timeo)
+{
+        struct cfpkt *pkt;
+        int ret, loopcnt = 0;
+
+        pkt = cfpkt_fromnative(CAIF_DIR_OUT, skb);
+        memset(cfpkt_info(pkt), 0, sizeof(struct caif_payload_info));
+        do {
+
+                ret = -ETIMEDOUT;
+
+                /* Slight paranoia, probably not needed. */
+                if (unlikely(loopcnt++ > 1000)) {
+                        pr_warning("CAIF: %s(): transmit retries failed,"
+                                " error = %d\n", __func__, ret);
+                        break;
+                }
+
+                if (cf_sk->layer.dn != NULL)
+                        ret = cf_sk->layer.dn->transmit(cf_sk->layer.dn, pkt);
+                if (likely(ret >= 0))
+                        break;
+                /* if transmit return -EAGAIN, then retry */
+                if (noblock && ret == -EAGAIN)
+                        break;
+                timeo = caif_wait_for_flow_on(cf_sk, 0, timeo, &ret);
+                if (signal_pending(current)) {
+                        ret = sock_intr_errno(timeo);
+                        break;
+                }
+                if (ret)
+                        break;
+                if (cf_sk->sk.sk_state != CAIF_CONNECTED ||
+                        sock_flag(&cf_sk->sk, SOCK_DEAD) ||
+                        (cf_sk->sk.sk_shutdown & RCV_SHUTDOWN)) {
+                        ret = -EPIPE;
+                        cf_sk->sk.sk_err = EPIPE;
+                        break;
+                }
+        } while (ret == -EAGAIN);
+        return ret;
+}
+
+/* Copied from af_unix:unix_dgram_sendmsg, and adapted to CAIF */
+static int caif_seqpkt_sendmsg(struct kiocb *kiocb, struct socket *sock,
+                        struct msghdr *msg, size_t len)
+{
+        struct sock *sk = sock->sk;
+        struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
+        int buffer_size;
+        int ret = 0;
+        struct sk_buff *skb = NULL;
+        int noblock;
+        long timeo;
+        caif_assert(cf_sk);
+        ret = sock_error(sk);
+        if (ret)
+                goto err;
+
+        ret = -EOPNOTSUPP;
+        if (msg->msg_flags&MSG_OOB)
+                goto err;
+
+        ret = -EOPNOTSUPP;
+        if (msg->msg_namelen)
+                goto err;
+
+        ret = -EINVAL;
+        if (unlikely(msg->msg_iov->iov_base == NULL))
+                goto err;
+        noblock = msg->msg_flags & MSG_DONTWAIT;
+
+        buffer_size = len + CAIF_NEEDED_HEADROOM + CAIF_NEEDED_TAILROOM;
+
+        ret = -EMSGSIZE;
+        if (buffer_size > CAIF_MAX_PAYLOAD_SIZE)
+                goto err;
+
+        timeo = sock_sndtimeo(sk, noblock);
+        timeo = caif_wait_for_flow_on(container_of(sk, struct caifsock, sk),
+                                1, timeo, &ret);
+
+        ret = -EPIPE;
+        if (cf_sk->sk.sk_state != CAIF_CONNECTED ||
+                sock_flag(sk, SOCK_DEAD) ||
+                (sk->sk_shutdown & RCV_SHUTDOWN))
+                goto err;
+
+        ret = -ENOMEM;
+        skb = sock_alloc_send_skb(sk, buffer_size, noblock, &ret);
+        if (!skb)
+                goto err;
+        skb_reserve(skb, CAIF_NEEDED_HEADROOM);
+
+        ret = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
+
+        if (ret)
+                goto err;
+        ret = transmit_skb(skb, cf_sk, noblock, timeo);
+        if (ret < 0)
+                goto err;
+        return len;
+err:
+        kfree_skb(skb);
+        return ret;
+}
+
+/*
+ * Copied from unix_stream_sendmsg and adapted to CAIF:
+ * Changed removed permission handling and added waiting for flow on
+ * and other minor adaptations.
+ */
+static int caif_stream_sendmsg(struct kiocb *kiocb, struct socket *sock,
+                                struct msghdr *msg, size_t len)
+{
+        struct sock *sk = sock->sk;
+        struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
+        int err, size;
+        struct sk_buff *skb;
+        int sent = 0;
+        long timeo;
+
+        err = -EOPNOTSUPP;
+
+        if (unlikely(msg->msg_flags&MSG_OOB))
+                goto out_err;
+
+        if (unlikely(msg->msg_namelen))
+                goto out_err;
+
+        timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);
+        timeo = caif_wait_for_flow_on(cf_sk, 1, timeo, &err);
+
+        if (unlikely(sk->sk_shutdown & SEND_SHUTDOWN))
+                goto pipe_err;
+
+        while (sent < len) {
+
+                size = len-sent;
+
+                if (size > CAIF_MAX_PAYLOAD_SIZE)
+                        size = CAIF_MAX_PAYLOAD_SIZE;
+
+                /* If size is more than half of sndbuf, chop up message */
+                if (size > ((sk->sk_sndbuf >> 1) - 64))
+                        size = (sk->sk_sndbuf >> 1) - 64;
+
+                if (size > SKB_MAX_ALLOC)
+                        size = SKB_MAX_ALLOC;
+
+                skb = sock_alloc_send_skb(sk,
+                                        size + CAIF_NEEDED_HEADROOM
+                                        + CAIF_NEEDED_TAILROOM,
+                                        msg->msg_flags&MSG_DONTWAIT,
+                                        &err);
+                if (skb == NULL)
+                        goto out_err;
+
+                skb_reserve(skb, CAIF_NEEDED_HEADROOM);
+                /*
+                 *      If you pass two values to the sock_alloc_send_skb
+                 *      it tries to grab the large buffer with GFP_NOFS
+                 *      (which can fail easily), and if it fails grab the
+                 *      fallback size buffer which is under a page and will
+                 *      succeed. [Alan]
+                 */
+                size = min_t(int, size, skb_tailroom(skb));
+
+                err = memcpy_fromiovec(skb_put(skb, size), msg->msg_iov, size);
+                if (err) {
+                        kfree_skb(skb);
+                        goto out_err;
+                }
+                err = transmit_skb(skb, cf_sk,
+                                msg->msg_flags&MSG_DONTWAIT, timeo);
+                if (err < 0) {
+                        kfree_skb(skb);
+                        goto pipe_err;
+                }
+                sent += size;
+        }
+
+        return sent;
+
+pipe_err:
+        if (sent == 0 && !(msg->msg_flags&MSG_NOSIGNAL))
+                send_sig(SIGPIPE, current, 0);
+        err = -EPIPE;
+out_err:
+        return sent ? : err;
+}
+
+static int setsockopt(struct socket *sock,
+                        int lvl, int opt, char __user *ov, unsigned int ol)
+{
+        struct sock *sk = sock->sk;
+        struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
+        int prio, linksel;
+        struct ifreq ifreq;
+
+        if (cf_sk->sk.sk_socket->state != SS_UNCONNECTED)
+                return -ENOPROTOOPT;
+
+        switch (opt) {
+        case CAIFSO_LINK_SELECT:
+                if (ol < sizeof(int))
+                        return -EINVAL;
+                if (lvl != SOL_CAIF)
+                        goto bad_sol;
+                if (copy_from_user(&linksel, ov, sizeof(int)))
+                        return -EINVAL;
+                lock_sock(&(cf_sk->sk));
+                cf_sk->conn_req.link_selector = linksel;
+                release_sock(&cf_sk->sk);
+                return 0;
+
+        case SO_PRIORITY:
+                if (lvl != SOL_SOCKET)
+                        goto bad_sol;
+                if (ol < sizeof(int))
+                        return -EINVAL;
+                if (copy_from_user(&prio, ov, sizeof(int)))
+                        return -EINVAL;
+                lock_sock(&(cf_sk->sk));
+                cf_sk->conn_req.priority = prio;
+                release_sock(&cf_sk->sk);
+                return 0;
+
+        case SO_BINDTODEVICE:
+                if (lvl != SOL_SOCKET)
+                        goto bad_sol;
+                if (ol < sizeof(struct ifreq))
+                        return -EINVAL;
+                if (copy_from_user(&ifreq, ov, sizeof(ifreq)))
+                        return -EFAULT;
+                lock_sock(&(cf_sk->sk));
+                strncpy(cf_sk->conn_req.link_name, ifreq.ifr_name,
+                        sizeof(cf_sk->conn_req.link_name));
+                cf_sk->conn_req.link_name
+                        [sizeof(cf_sk->conn_req.link_name)-1] = 0;
+                release_sock(&cf_sk->sk);
+                return 0;
+
+        case CAIFSO_REQ_PARAM:
+                if (lvl != SOL_CAIF)
+                        goto bad_sol;
+                if (cf_sk->sk.sk_protocol != CAIFPROTO_UTIL)
+                        return -ENOPROTOOPT;
+                lock_sock(&(cf_sk->sk));
+                cf_sk->conn_req.param.size = ol;
+                if (ol > sizeof(cf_sk->conn_req.param.data) ||
+                        copy_from_user(&cf_sk->conn_req.param.data, ov, ol)) {
+                        release_sock(&cf_sk->sk);
+                        return -EINVAL;
+                }
+                release_sock(&cf_sk->sk);
+                return 0;
+
+        default:
+                return -ENOPROTOOPT;
+        }
+
+        return 0;
+bad_sol:
+        return -ENOPROTOOPT;
+
+}
+
+/*
+ * caif_connect() - Connect a CAIF Socket
+ * Copied and modified af_irda.c:irda_connect().
+ *
+ * Note : by consulting "errno", the user space caller may learn the cause
+ * of the failure. Most of them are visible in the function, others may come
+ * from subroutines called and are listed here :
+ *  o -EAFNOSUPPORT: bad socket family or type.
+ *  o -ESOCKTNOSUPPORT: bad socket type or protocol
+ *  o -EINVAL: bad socket address, or CAIF link type
+ *  o -ECONNREFUSED: remote end refused the connection.
+ *  o -EINPROGRESS: connect request sent but timed out (or non-blocking)
+ *  o -EISCONN: already connected.
+ *  o -ETIMEDOUT: Connection timed out (send timeout)
+ *  o -ENODEV: No link layer to send request
+ *  o -ECONNRESET: Received Shutdown indication or lost link layer
+ *  o -ENOMEM: Out of memory
+ *
+ *  State Strategy:
+ *  o sk_state: holds the CAIF_* protocol state, it's updated by
+ *      caif_ctrl_cb.
+ *  o sock->state: holds the SS_* socket state and is updated by connect and
+ *      disconnect.
+ */
+static int caif_connect(struct socket *sock, struct sockaddr *uaddr,
+                        int addr_len, int flags)
+{
+        struct sock *sk = sock->sk;
+        struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
+        long timeo;
+        int err;
+        lock_sock(sk);
+
+        err = -EAFNOSUPPORT;
+        if (uaddr->sa_family != AF_CAIF)
+                goto out;
+
+        err = -ESOCKTNOSUPPORT;
+        if (unlikely(!(sk->sk_type == SOCK_STREAM &&
+                       cf_sk->sk.sk_protocol == CAIFPROTO_AT) &&
+                       sk->sk_type != SOCK_SEQPACKET))
+                goto out;
+        switch (sock->state) {
+        case SS_UNCONNECTED:
+                /* Normal case, a fresh connect */
+                caif_assert(sk->sk_state == CAIF_DISCONNECTED);
+                break;
+        case SS_CONNECTING:
+                switch (sk->sk_state) {
+                case CAIF_CONNECTED:
+                        sock->state = SS_CONNECTED;
+                        err = -EISCONN;
+                        goto out;
+                case CAIF_DISCONNECTED:
+                        /* Reconnect allowed */
+                        break;
+                case CAIF_CONNECTING:
+                        err = -EALREADY;
+                        if (flags & O_NONBLOCK)
+                                goto out;
+                        goto wait_connect;
+                }
+                break;
+        case SS_CONNECTED:
+                caif_assert(sk->sk_state == CAIF_CONNECTED ||
+                                sk->sk_state == CAIF_DISCONNECTED);
+                if (sk->sk_shutdown & SHUTDOWN_MASK) {
+                        /* Allow re-connect after SHUTDOWN_IND */
+                        caif_disconnect_client(&cf_sk->layer);
+                        break;
+                }
+                /* No reconnect on a seqpacket socket */
+                err = -EISCONN;
+                goto out;
+        case SS_DISCONNECTING:
+        case SS_FREE:
+                caif_assert(1); /*Should never happen */
+                break;
+        }
+        sk->sk_state = CAIF_DISCONNECTED;
+        sock->state = SS_UNCONNECTED;
+        sk_stream_kill_queues(&cf_sk->sk);
+
+        err = -EINVAL;
+        if (addr_len != sizeof(struct sockaddr_caif) ||
+                !uaddr)
+                goto out;
+
+        memcpy(&cf_sk->conn_req.sockaddr, uaddr,
+                sizeof(struct sockaddr_caif));
+
+        /* Move to connecting socket, start sending Connect Requests */
+        sock->state = SS_CONNECTING;
+        sk->sk_state = CAIF_CONNECTING;
+
+        dbfs_atomic_inc(&cnt.num_connect_req);
+        cf_sk->layer.receive = caif_sktrecv_cb;
+        err = caif_connect_client(&cf_sk->conn_req,
+                                &cf_sk->layer);
+        if (err < 0) {
+                cf_sk->sk.sk_socket->state = SS_UNCONNECTED;
+                cf_sk->sk.sk_state = CAIF_DISCONNECTED;
+                goto out;
+        }
+
+        err = -EINPROGRESS;
+wait_connect:
+
+        if (sk->sk_state != CAIF_CONNECTED && (flags & O_NONBLOCK))
+                goto out;
+
+        timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
+
+        release_sock(sk);
+        err = wait_event_interruptible_timeout(*sk_sleep(sk),
+                        sk->sk_state != CAIF_CONNECTING,
+                        timeo);
+        lock_sock(sk);
+        if (err < 0)
+                goto out; /* -ERESTARTSYS */
+        if (err == 0 && sk->sk_state != CAIF_CONNECTED) {
+                err = -ETIMEDOUT;
+                goto out;
+        }
+
+        if (sk->sk_state != CAIF_CONNECTED) {
+                sock->state = SS_UNCONNECTED;
+                err = sock_error(sk);
+                if (!err)
+                        err = -ECONNREFUSED;
+                goto out;
+        }
+        sock->state = SS_CONNECTED;
+        err = 0;
+out:
+        release_sock(sk);
+        return err;
+}
+
+
+/*
+ * caif_release() - Disconnect a CAIF Socket
+ * Copied and modified af_irda.c:irda_release().
+ */
+static int caif_release(struct socket *sock)
+{
+        struct sock *sk = sock->sk;
+        struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
+        int res = 0;
+
+        if (!sk)
+                return 0;
+
+        set_tx_flow_off(cf_sk);
+
+        /*
+         * Ensure that packets are not queued after this point in time.
+         * caif_queue_rcv_skb checks SOCK_DEAD holding the queue lock,
+         * this ensures no packets when sock is dead.
+         */
+        spin_lock(&sk->sk_receive_queue.lock);
+        sock_set_flag(sk, SOCK_DEAD);
+        spin_unlock(&sk->sk_receive_queue.lock);
+        sock->sk = NULL;
+
+        dbfs_atomic_inc(&cnt.num_disconnect);
+
+        if (cf_sk->debugfs_socket_dir != NULL)
+                debugfs_remove_recursive(cf_sk->debugfs_socket_dir);
+
+        lock_sock(&(cf_sk->sk));
+        sk->sk_state = CAIF_DISCONNECTED;
+        sk->sk_shutdown = SHUTDOWN_MASK;
+
+        if (cf_sk->sk.sk_socket->state == SS_CONNECTED ||
+                cf_sk->sk.sk_socket->state == SS_CONNECTING)
+                res = caif_disconnect_client(&cf_sk->layer);
+
+        cf_sk->sk.sk_socket->state = SS_DISCONNECTING;
+        wake_up_interruptible_poll(sk_sleep(sk), POLLERR|POLLHUP);
+
+        sock_orphan(sk);
+        cf_sk->layer.dn = NULL;
+        sk_stream_kill_queues(&cf_sk->sk);
+        release_sock(sk);
+        sock_put(sk);
+        return res;
+}
+
+/* Copied from af_unix.c:unix_poll(), added CAIF tx_flow handling */
+static unsigned int caif_poll(struct file *file,
+                                struct socket *sock, poll_table *wait)
+{
+        struct sock *sk = sock->sk;
+        unsigned int mask;
+        struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
+
+        sock_poll_wait(file, sk_sleep(sk), wait);
+        mask = 0;
+
+        /* exceptional events? */
+        if (sk->sk_err)
+                mask |= POLLERR;
+        if (sk->sk_shutdown == SHUTDOWN_MASK)
+                mask |= POLLHUP;
+        if (sk->sk_shutdown & RCV_SHUTDOWN)
+                mask |= POLLRDHUP;
+
+        /* readable? */
+        if (!skb_queue_empty(&sk->sk_receive_queue) ||
+                (sk->sk_shutdown & RCV_SHUTDOWN))
+                mask |= POLLIN | POLLRDNORM;
+
+        /* Connection-based need to check for termination and startup */
+        if (sk->sk_state == CAIF_DISCONNECTED)
+                mask |= POLLHUP;
+
+        /*
+         * we set writable also when the other side has shut down the
+         * connection. This prevents stuck sockets.
+         */
+        if (sock_writeable(sk) && tx_flow_is_on(cf_sk))
+                mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
+
+        return mask;
+}
+
+static const struct proto_ops caif_seqpacket_ops = {
+        .family = PF_CAIF,
+        .owner = THIS_MODULE,
+        .release = caif_release,
+        .bind = sock_no_bind,
+        .connect = caif_connect,
+        .socketpair = sock_no_socketpair,
+        .accept = sock_no_accept,
+        .getname = sock_no_getname,
+        .poll = caif_poll,
+        .ioctl = sock_no_ioctl,
+        .listen = sock_no_listen,
+        .shutdown = sock_no_shutdown,
+        .setsockopt = setsockopt,
+        .getsockopt = sock_no_getsockopt,
+        .sendmsg = caif_seqpkt_sendmsg,
+        .recvmsg = caif_seqpkt_recvmsg,
+        .mmap = sock_no_mmap,
+        .sendpage = sock_no_sendpage,
+};
+
+static const struct proto_ops caif_stream_ops = {
+        .family = PF_CAIF,
+        .owner = THIS_MODULE,
+        .release = caif_release,
+        .bind = sock_no_bind,
+        .connect = caif_connect,
+        .socketpair = sock_no_socketpair,
+        .accept = sock_no_accept,
+        .getname = sock_no_getname,
+        .poll = caif_poll,
+        .ioctl = sock_no_ioctl,
+        .listen = sock_no_listen,
+        .shutdown = sock_no_shutdown,
+        .setsockopt = setsockopt,
+        .getsockopt = sock_no_getsockopt,
+        .sendmsg = caif_stream_sendmsg,
+        .recvmsg = caif_stream_recvmsg,
+        .mmap = sock_no_mmap,
+        .sendpage = sock_no_sendpage,
+};
+
+/* This function is called when a socket is finally destroyed. */
+static void caif_sock_destructor(struct sock *sk)
+{
+        struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
+        caif_assert(!atomic_read(&sk->sk_wmem_alloc));
+        caif_assert(sk_unhashed(sk));
+        caif_assert(!sk->sk_socket);
+        if (!sock_flag(sk, SOCK_DEAD)) {
+                pr_info("Attempt to release alive CAIF socket: %p\n", sk);
+                return;
+        }
+        sk_stream_kill_queues(&cf_sk->sk);
+        dbfs_atomic_dec(&cnt.caif_nr_socks);
+}
+
+static int caif_create(struct net *net, struct socket *sock, int protocol,
+                        int kern)
+{
+        struct sock *sk = NULL;
+        struct caifsock *cf_sk = NULL;
+        static struct proto prot = {.name = "PF_CAIF",
+                .owner = THIS_MODULE,
+                .obj_size = sizeof(struct caifsock),
+        };
+
+        if (!capable(CAP_SYS_ADMIN) && !capable(CAP_NET_ADMIN))
+                return -EPERM;
+        /*
+         * The sock->type specifies the socket type to use.
+         * The CAIF socket is a packet stream in the sense
+         * that it is packet based. CAIF trusts the reliability
+         * of the link, no resending is implemented.
+         */
+        if (sock->type == SOCK_SEQPACKET)
+                sock->ops = &caif_seqpacket_ops;
+        else if (sock->type == SOCK_STREAM)
+                sock->ops = &caif_stream_ops;
+        else
+                return -ESOCKTNOSUPPORT;
+
+        if (protocol < 0 || protocol >= CAIFPROTO_MAX)
+                return -EPROTONOSUPPORT;
+        /*
+         * Set the socket state to unconnected.  The socket state
+         * is really not used at all in the net/core or socket.c but the
+         * initialization makes sure that sock->state is not uninitialized.
+         */
+        sk = sk_alloc(net, PF_CAIF, GFP_KERNEL, &prot);
+        if (!sk)
+                return -ENOMEM;
+
+        cf_sk = container_of(sk, struct caifsock, sk);
+
+        /* Store the protocol */
+        sk->sk_protocol = (unsigned char) protocol;
+
+        /* Sendbuf dictates the amount of outbound packets not yet sent */
+        sk->sk_sndbuf = CAIF_DEF_SNDBUF;
+        sk->sk_rcvbuf = CAIF_DEF_RCVBUF;
+
+        /*
+         * Lock in order to try to stop someone from opening the socket
+         * too early.
+         */
+        lock_sock(&(cf_sk->sk));
+
+        /* Initialize the nozero default sock structure data. */
+        sock_init_data(sock, sk);
+        sk->sk_destruct = caif_sock_destructor;
+
+        mutex_init(&cf_sk->readlock); /* single task reading lock */
+        cf_sk->layer.ctrlcmd = caif_ctrl_cb;
+        cf_sk->sk.sk_socket->state = SS_UNCONNECTED;
+        cf_sk->sk.sk_state = CAIF_DISCONNECTED;
+
+        set_tx_flow_off(cf_sk);
+        set_rx_flow_on(cf_sk);
+
+        /* Set default options on configuration */
+        cf_sk->conn_req.priority = CAIF_PRIO_NORMAL;
+        cf_sk->conn_req.link_selector = CAIF_LINK_LOW_LATENCY;
+        cf_sk->conn_req.protocol = protocol;
+        /* Increase the number of sockets created. */
+        dbfs_atomic_inc(&cnt.caif_nr_socks);
+#ifdef CONFIG_DEBUG_FS
+        if (!IS_ERR(debugfsdir)) {
+                /* Fill in some information concerning the misc socket. */
+                snprintf(cf_sk->name, sizeof(cf_sk->name), "cfsk%d",
+                                atomic_read(&cnt.caif_nr_socks));
+
+                cf_sk->debugfs_socket_dir =
+                        debugfs_create_dir(cf_sk->name, debugfsdir);
+                debugfs_create_u32("sk_state", S_IRUSR | S_IWUSR,
+                                cf_sk->debugfs_socket_dir,
+                                (u32 *) &cf_sk->sk.sk_state);
+                debugfs_create_u32("flow_state", S_IRUSR | S_IWUSR,
+                                cf_sk->debugfs_socket_dir, &cf_sk->flow_state);
+                debugfs_create_u32("sk_rmem_alloc", S_IRUSR | S_IWUSR,
+                                cf_sk->debugfs_socket_dir,
+                                (u32 *) &cf_sk->sk.sk_rmem_alloc);
+                debugfs_create_u32("sk_wmem_alloc", S_IRUSR | S_IWUSR,
+                                cf_sk->debugfs_socket_dir,
+                                (u32 *) &cf_sk->sk.sk_wmem_alloc);
+                debugfs_create_u32("identity", S_IRUSR | S_IWUSR,
+                                cf_sk->debugfs_socket_dir,
+                                (u32 *) &cf_sk->layer.id);
+        }
+#endif
+        release_sock(&cf_sk->sk);
+        return 0;
+}
+
+
+static struct net_proto_family caif_family_ops = {
+        .family = PF_CAIF,
+        .create = caif_create,
+        .owner = THIS_MODULE,
+};
+
+int af_caif_init(void)
+{
+        int err = sock_register(&caif_family_ops);
+        if (!err)
+                return err;
+        return 0;
+}
+
+static int __init caif_sktinit_module(void)
+{
+#ifdef CONFIG_DEBUG_FS
+        debugfsdir = debugfs_create_dir("caif_sk", NULL);
+        if (!IS_ERR(debugfsdir)) {
+                debugfs_create_u32("num_sockets", S_IRUSR | S_IWUSR,
+                                debugfsdir,
+                                (u32 *) &cnt.caif_nr_socks);
+                debugfs_create_u32("num_connect_req", S_IRUSR | S_IWUSR,
+                                debugfsdir,
+                                (u32 *) &cnt.num_connect_req);
+                debugfs_create_u32("num_connect_resp", S_IRUSR | S_IWUSR,
+                                debugfsdir,
+                                (u32 *) &cnt.num_connect_resp);
+                debugfs_create_u32("num_connect_fail_resp", S_IRUSR | S_IWUSR,
+                                debugfsdir,
+                                (u32 *) &cnt.num_connect_fail_resp);
+                debugfs_create_u32("num_disconnect", S_IRUSR | S_IWUSR,
+                                debugfsdir,
+                                (u32 *) &cnt.num_disconnect);
+                debugfs_create_u32("num_remote_shutdown_ind",
+                                S_IRUSR | S_IWUSR, debugfsdir,
+                                (u32 *) &cnt.num_remote_shutdown_ind);
+                debugfs_create_u32("num_tx_flow_off_ind", S_IRUSR | S_IWUSR,
+                                debugfsdir,
+                                (u32 *) &cnt.num_tx_flow_off_ind);
+                debugfs_create_u32("num_tx_flow_on_ind", S_IRUSR | S_IWUSR,
+                                debugfsdir,
+                                (u32 *) &cnt.num_tx_flow_on_ind);
+                debugfs_create_u32("num_rx_flow_off", S_IRUSR | S_IWUSR,
+                                debugfsdir,
+                                (u32 *) &cnt.num_rx_flow_off);
+                debugfs_create_u32("num_rx_flow_on", S_IRUSR | S_IWUSR,
+                                debugfsdir,
+                                (u32 *) &cnt.num_rx_flow_on);
+        }
+#endif
+        return af_caif_init();
+}
+
+static void __exit caif_sktexit_module(void)
+{
+        sock_unregister(PF_CAIF);
+        if (debugfsdir != NULL)
+                debugfs_remove_recursive(debugfsdir);
+}
+module_init(caif_sktinit_module);
+module_exit(caif_sktexit_module);
diff --git a/net/caif/cfcnfg.c b/net/caif/cfcnfg.c
new file mode 100644
index 000000000000..471c62939fad
--- /dev/null
+++ b/net/caif/cfcnfg.c
@@ -0,0 +1,471 @@
+/*
+ * Copyright (C) ST-Ericsson AB 2010
+ * Author:      Sjur Brendeland/sjur.brandeland@stericsson.com
+ * License terms: GNU General Public License (GPL) version 2
+ */
+#include <linux/kernel.h>
+#include <linux/stddef.h>
+#include <linux/slab.h>
+#include <net/caif/caif_layer.h>
+#include <net/caif/cfpkt.h>
+#include <net/caif/cfcnfg.h>
+#include <net/caif/cfctrl.h>
+#include <net/caif/cfmuxl.h>
+#include <net/caif/cffrml.h>
+#include <net/caif/cfserl.h>
+#include <net/caif/cfsrvl.h>
+
+#include <linux/module.h>
+#include <asm/atomic.h>
+
+#define MAX_PHY_LAYERS 7
+#define PHY_NAME_LEN 20
+
+#define container_obj(layr) container_of(layr, struct cfcnfg, layer)
+
+/* Information about CAIF physical interfaces held by Config Module in order
+ * to manage physical interfaces
+ */
+struct cfcnfg_phyinfo {
+        /* Pointer to the layer below the MUX (framing layer) */
+        struct cflayer *frm_layer;
+        /* Pointer to the lowest actual physical layer */
+        struct cflayer *phy_layer;
+        /* Unique identifier of the physical interface */
+        unsigned int id;
+        /* Preference of the physical in interface */
+        enum cfcnfg_phy_preference pref;
+
+        /* Reference count, number of channels using the device */
+        int phy_ref_count;
+
+        /* Information about the physical device */
+        struct dev_info dev_info;
+};
+
+struct cfcnfg {
+        struct cflayer layer;
+        struct cflayer *ctrl;
+        struct cflayer *mux;
+        u8 last_phyid;
+        struct cfcnfg_phyinfo phy_layers[MAX_PHY_LAYERS];
+};
+
+static void cfcnfg_linkup_rsp(struct cflayer *layer, u8 channel_id,
+                             enum cfctrl_srv serv, u8 phyid,
+                             struct cflayer *adapt_layer);
+static void cfcnfg_linkdestroy_rsp(struct cflayer *layer, u8 channel_id);
+static void cfcnfg_reject_rsp(struct cflayer *layer, u8 channel_id,
+                             struct cflayer *adapt_layer);
+static void cfctrl_resp_func(void);
+static void cfctrl_enum_resp(void);
+
+struct cfcnfg *cfcnfg_create(void)
+{
+        struct cfcnfg *this;
+        struct cfctrl_rsp *resp;
+        /* Initiate this layer */
+        this = kmalloc(sizeof(struct cfcnfg), GFP_ATOMIC);
+        if (!this) {
+                pr_warning("CAIF: %s(): Out of memory\n", __func__);
+                return NULL;
+        }
+        memset(this, 0, sizeof(struct cfcnfg));
+        this->mux = cfmuxl_create();
+        if (!this->mux)
+                goto out_of_mem;
+        this->ctrl = cfctrl_create();
+        if (!this->ctrl)
+                goto out_of_mem;
+        /* Initiate response functions */
+        resp = cfctrl_get_respfuncs(this->ctrl);
+        resp->enum_rsp = cfctrl_enum_resp;
+        resp->linkerror_ind = cfctrl_resp_func;
+        resp->linkdestroy_rsp = cfcnfg_linkdestroy_rsp;
+        resp->sleep_rsp = cfctrl_resp_func;
+        resp->wake_rsp = cfctrl_resp_func;
+        resp->restart_rsp = cfctrl_resp_func;
+        resp->radioset_rsp = cfctrl_resp_func;
+        resp->linksetup_rsp = cfcnfg_linkup_rsp;
+        resp->reject_rsp = cfcnfg_reject_rsp;
+
+        this->last_phyid = 1;
+
+        cfmuxl_set_uplayer(this->mux, this->ctrl, 0);
+        layer_set_dn(this->ctrl, this->mux);
+        layer_set_up(this->ctrl, this);
+        return this;
+out_of_mem:
+        pr_warning("CAIF: %s(): Out of memory\n", __func__);
+        kfree(this->mux);
+        kfree(this->ctrl);
+        kfree(this);
+        return NULL;
+}
+EXPORT_SYMBOL(cfcnfg_create);
+
+void cfcnfg_remove(struct cfcnfg *cfg)
+{
+        if (cfg) {
+                kfree(cfg->mux);
+                kfree(cfg->ctrl);
+                kfree(cfg);
+        }
+}
+
+static void cfctrl_resp_func(void)
+{
+}
+
+static void cfctrl_enum_resp(void)
+{
+}
+
+struct dev_info *cfcnfg_get_phyid(struct cfcnfg *cnfg,
+                                  enum cfcnfg_phy_preference phy_pref)
+{
+        u16 i;
+
+        /* Try to match with specified preference */
+        for (i = 1; i < MAX_PHY_LAYERS; i++) {
+                if (cnfg->phy_layers[i].id == i &&
+                     cnfg->phy_layers[i].pref == phy_pref &&
+                     cnfg->phy_layers[i].frm_layer != NULL) {
+                        caif_assert(cnfg->phy_layers != NULL);
+                        caif_assert(cnfg->phy_layers[i].id == i);
+                        return &cnfg->phy_layers[i].dev_info;
+                }
+        }
+        /* Otherwise just return something */
+        for (i = 1; i < MAX_PHY_LAYERS; i++) {
+                if (cnfg->phy_layers[i].id == i) {
+                        caif_assert(cnfg->phy_layers != NULL);
+                        caif_assert(cnfg->phy_layers[i].id == i);
+                        return &cnfg->phy_layers[i].dev_info;
+                }
+        }
+
+        return NULL;
+}
+
+static struct cfcnfg_phyinfo *cfcnfg_get_phyinfo(struct cfcnfg *cnfg,
+                                                        u8 phyid)
+{
+        int i;
+        /* Try to match with specified preference */
+        for (i = 0; i < MAX_PHY_LAYERS; i++)
+                if (cnfg->phy_layers[i].frm_layer != NULL &&
+                    cnfg->phy_layers[i].id == phyid)
+                        return &cnfg->phy_layers[i];
+        return NULL;
+}
+
+int cfcnfg_get_named(struct cfcnfg *cnfg, char *name)
+{
+        int i;
+
+        /* Try to match with specified name */
+        for (i = 0; i < MAX_PHY_LAYERS; i++) {
+                if (cnfg->phy_layers[i].frm_layer != NULL
+                    && strcmp(cnfg->phy_layers[i].phy_layer->name,
+                              name) == 0)
+                        return cnfg->phy_layers[i].frm_layer->id;
+        }
+        return 0;
+}
+
+int cfcnfg_disconn_adapt_layer(struct cfcnfg *cnfg, struct cflayer *adap_layer)
+{
+        u8 channel_id = 0;
+        int ret = 0;
+        struct cflayer *servl = NULL;
+        struct cfcnfg_phyinfo *phyinfo = NULL;
+        u8 phyid = 0;
+        caif_assert(adap_layer != NULL);
+        channel_id = adap_layer->id;
+        if (adap_layer->dn == NULL || channel_id == 0) {
+                pr_err("CAIF: %s():adap_layer->id is 0\n", __func__);
+                ret = -ENOTCONN;
+                goto end;
+        }
+        servl = cfmuxl_remove_uplayer(cnfg->mux, channel_id);
+        if (servl == NULL)
+                goto end;
+        layer_set_up(servl, NULL);
+        ret = cfctrl_linkdown_req(cnfg->ctrl, channel_id, adap_layer);
+        if (servl == NULL) {
+                pr_err("CAIF: %s(): PROTOCOL ERROR "
+                       "- Error removing service_layer Channel_Id(%d)",
+                        __func__, channel_id);
+                ret = -EINVAL;
+                goto end;
+        }
+        caif_assert(channel_id == servl->id);
+        if (adap_layer->dn != NULL) {
+                phyid = cfsrvl_getphyid(adap_layer->dn);
+
+                phyinfo = cfcnfg_get_phyinfo(cnfg, phyid);
+                if (phyinfo == NULL) {
+                        pr_warning("CAIF: %s(): "
+                                "No interface to send disconnect to\n",
+                                __func__);
+                        ret = -ENODEV;
+                        goto end;
+                }
+                if (phyinfo->id != phyid ||
+                        phyinfo->phy_layer->id != phyid ||
+                        phyinfo->frm_layer->id != phyid) {
+                        pr_err("CAIF: %s(): "
+                                "Inconsistency in phy registration\n",
+                                __func__);
+                        ret = -EINVAL;
+                        goto end;
+                }
+        }
+        if (phyinfo != NULL && --phyinfo->phy_ref_count == 0 &&
+                phyinfo->phy_layer != NULL &&
+                phyinfo->phy_layer->modemcmd != NULL) {
+                phyinfo->phy_layer->modemcmd(phyinfo->phy_layer,
+                                             _CAIF_MODEMCMD_PHYIF_USELESS);
+        }
+end:
+        cfsrvl_put(servl);
+        cfctrl_cancel_req(cnfg->ctrl, adap_layer);
+        if (adap_layer->ctrlcmd != NULL)
+                adap_layer->ctrlcmd(adap_layer, CAIF_CTRLCMD_DEINIT_RSP, 0);
+        return ret;
+
+}
+EXPORT_SYMBOL(cfcnfg_disconn_adapt_layer);
+
+void cfcnfg_release_adap_layer(struct cflayer *adap_layer)
+{
+        if (adap_layer->dn)
+                cfsrvl_put(adap_layer->dn);
+}
+EXPORT_SYMBOL(cfcnfg_release_adap_layer);
+
+static void cfcnfg_linkdestroy_rsp(struct cflayer *layer, u8 channel_id)
+{
+}
+
+int cfcnfg_add_adaptation_layer(struct cfcnfg *cnfg,
+                                struct cfctrl_link_param *param,
+                                struct cflayer *adap_layer)
+{
+        struct cflayer *frml;
+        if (adap_layer == NULL) {
+                pr_err("CAIF: %s(): adap_layer is zero", __func__);
+                return -EINVAL;
+        }
+        if (adap_layer->receive == NULL) {
+                pr_err("CAIF: %s(): adap_layer->receive is NULL", __func__);
+                return -EINVAL;
+        }
+        if (adap_layer->ctrlcmd == NULL) {
+                pr_err("CAIF: %s(): adap_layer->ctrlcmd == NULL", __func__);
+                return -EINVAL;
+        }
+        frml = cnfg->phy_layers[param->phyid].frm_layer;
+        if (frml == NULL) {
+                pr_err("CAIF: %s(): Specified PHY type does not exist!",
+                        __func__);
+                return -ENODEV;
+        }
+        caif_assert(param->phyid == cnfg->phy_layers[param->phyid].id);
+        caif_assert(cnfg->phy_layers[param->phyid].frm_layer->id ==
+                     param->phyid);
+        caif_assert(cnfg->phy_layers[param->phyid].phy_layer->id ==
+                     param->phyid);
+        /* FIXME: ENUMERATE INITIALLY WHEN ACTIVATING PHYSICAL INTERFACE */
+        cfctrl_enum_req(cnfg->ctrl, param->phyid);
+        return cfctrl_linkup_request(cnfg->ctrl, param, adap_layer);
+}
+EXPORT_SYMBOL(cfcnfg_add_adaptation_layer);
+
+static void cfcnfg_reject_rsp(struct cflayer *layer, u8 channel_id,
+                             struct cflayer *adapt_layer)
+{
+        if (adapt_layer != NULL && adapt_layer->ctrlcmd != NULL)
+                adapt_layer->ctrlcmd(adapt_layer,
+                                     CAIF_CTRLCMD_INIT_FAIL_RSP, 0);
+}
+
+static void
+cfcnfg_linkup_rsp(struct cflayer *layer, u8 channel_id, enum cfctrl_srv serv,
+                 u8 phyid, struct cflayer *adapt_layer)
+{
+        struct cfcnfg *cnfg = container_obj(layer);
+        struct cflayer *servicel = NULL;
+        struct cfcnfg_phyinfo *phyinfo;
+        if (adapt_layer == NULL) {
+                pr_debug("CAIF: %s(): link setup response "
+                                "but no client exist, send linkdown back\n",
+                                __func__);
+                cfctrl_linkdown_req(cnfg->ctrl, channel_id, NULL);
+                return;
+        }
+
+        caif_assert(cnfg != NULL);
+        caif_assert(phyid != 0);
+        phyinfo = &cnfg->phy_layers[phyid];
+        caif_assert(phyinfo != NULL);
+        caif_assert(phyinfo->id == phyid);
+        caif_assert(phyinfo->phy_layer != NULL);
+        caif_assert(phyinfo->phy_layer->id == phyid);
+
+        if (phyinfo != NULL &&
+            phyinfo->phy_ref_count++ == 0 &&
+            phyinfo->phy_layer != NULL &&
+            phyinfo->phy_layer->modemcmd != NULL) {
+                caif_assert(phyinfo->phy_layer->id == phyid);
+                phyinfo->phy_layer->modemcmd(phyinfo->phy_layer,
+                                             _CAIF_MODEMCMD_PHYIF_USEFULL);
+
+        }
+        adapt_layer->id = channel_id;
+
+        switch (serv) {
+        case CFCTRL_SRV_VEI:
+                servicel = cfvei_create(channel_id, &phyinfo->dev_info);
+                break;
+        case CFCTRL_SRV_DATAGRAM:
+                servicel = cfdgml_create(channel_id, &phyinfo->dev_info);
+                break;
+        case CFCTRL_SRV_RFM:
+                servicel = cfrfml_create(channel_id, &phyinfo->dev_info);
+                break;
+        case CFCTRL_SRV_UTIL:
+                servicel = cfutill_create(channel_id, &phyinfo->dev_info);
+                break;
+        case CFCTRL_SRV_VIDEO:
+                servicel = cfvidl_create(channel_id, &phyinfo->dev_info);
+                break;
+        case CFCTRL_SRV_DBG:
+                servicel = cfdbgl_create(channel_id, &phyinfo->dev_info);
+                break;
+        default:
+                pr_err("CAIF: %s(): Protocol error. "
+                        "Link setup response - unknown channel type\n",
+                        __func__);
+                return;
+        }
+        if (!servicel) {
+                pr_warning("CAIF: %s(): Out of memory\n", __func__);
+                return;
+        }
+        layer_set_dn(servicel, cnfg->mux);
+        cfmuxl_set_uplayer(cnfg->mux, servicel, channel_id);
+        layer_set_up(servicel, adapt_layer);
+        layer_set_dn(adapt_layer, servicel);
+        cfsrvl_get(servicel);
+        servicel->ctrlcmd(servicel, CAIF_CTRLCMD_INIT_RSP, 0);
+}
+
+void
+cfcnfg_add_phy_layer(struct cfcnfg *cnfg, enum cfcnfg_phy_type phy_type,
+                     void *dev, struct cflayer *phy_layer, u16 *phyid,
+                     enum cfcnfg_phy_preference pref,
+                     bool fcs, bool stx)
+{
+        struct cflayer *frml;
+        struct cflayer *phy_driver = NULL;
+        int i;
+
+
+        if (cnfg->phy_layers[cnfg->last_phyid].frm_layer == NULL) {
+                *phyid = cnfg->last_phyid;
+
+                /* range: * 1..(MAX_PHY_LAYERS-1) */
+                cnfg->last_phyid =
+                    (cnfg->last_phyid % (MAX_PHY_LAYERS - 1)) + 1;
+        } else {
+                *phyid = 0;
+                for (i = 1; i < MAX_PHY_LAYERS; i++) {
+                        if (cnfg->phy_layers[i].frm_layer == NULL) {
+                                *phyid = i;
+                                break;
+                        }
+                }
+        }
+        if (*phyid == 0) {
+                pr_err("CAIF: %s(): No Available PHY ID\n", __func__);
+                return;
+        }
+
+        switch (phy_type) {
+        case CFPHYTYPE_FRAG:
+                phy_driver =
+                    cfserl_create(CFPHYTYPE_FRAG, *phyid, stx);
+                if (!phy_driver) {
+                        pr_warning("CAIF: %s(): Out of memory\n", __func__);
+                        return;
+                }
+
+                break;
+        case CFPHYTYPE_CAIF:
+                phy_driver = NULL;
+                break;
+        default:
+                pr_err("CAIF: %s(): %d", __func__, phy_type);
+                return;
+                break;
+        }
+
+        phy_layer->id = *phyid;
+        cnfg->phy_layers[*phyid].pref = pref;
+        cnfg->phy_layers[*phyid].id = *phyid;
+        cnfg->phy_layers[*phyid].dev_info.id = *phyid;
+        cnfg->phy_layers[*phyid].dev_info.dev = dev;
+        cnfg->phy_layers[*phyid].phy_layer = phy_layer;
+        cnfg->phy_layers[*phyid].phy_ref_count = 0;
+        phy_layer->type = phy_type;
+        frml = cffrml_create(*phyid, fcs);
+        if (!frml) {
+                pr_warning("CAIF: %s(): Out of memory\n", __func__);
+                return;
+        }
+        cnfg->phy_layers[*phyid].frm_layer = frml;
+        cfmuxl_set_dnlayer(cnfg->mux, frml, *phyid);
+        layer_set_up(frml, cnfg->mux);
+
+        if (phy_driver != NULL) {
+                phy_driver->id = *phyid;
+                layer_set_dn(frml, phy_driver);
+                layer_set_up(phy_driver, frml);
+                layer_set_dn(phy_driver, phy_layer);
+                layer_set_up(phy_layer, phy_driver);
+        } else {
+                layer_set_dn(frml, phy_layer);
+                layer_set_up(phy_layer, frml);
+        }
+}
+EXPORT_SYMBOL(cfcnfg_add_phy_layer);
+
+int cfcnfg_del_phy_layer(struct cfcnfg *cnfg, struct cflayer *phy_layer)
+{
+        struct cflayer *frml, *frml_dn;
+        u16 phyid;
+        phyid = phy_layer->id;
+        caif_assert(phyid == cnfg->phy_layers[phyid].id);
+        caif_assert(phy_layer == cnfg->phy_layers[phyid].phy_layer);
+        caif_assert(phy_layer->id == phyid);
+        caif_assert(cnfg->phy_layers[phyid].frm_layer->id == phyid);
+
+        memset(&cnfg->phy_layers[phy_layer->id], 0,
+               sizeof(struct cfcnfg_phyinfo));
+        frml = cfmuxl_remove_dnlayer(cnfg->mux, phy_layer->id);
+        frml_dn = frml->dn;
+        cffrml_set_uplayer(frml, NULL);
+        cffrml_set_dnlayer(frml, NULL);
+        kfree(frml);
+
+        if (phy_layer != frml_dn) {
+                layer_set_up(frml_dn, NULL);
+                layer_set_dn(frml_dn, NULL);
+                kfree(frml_dn);
+        }
+        layer_set_up(phy_layer, NULL);
+        return 0;
+}
+EXPORT_SYMBOL(cfcnfg_del_phy_layer);
diff --git a/net/caif/cfctrl.c b/net/caif/cfctrl.c
new file mode 100644
index 000000000000..a521d32cfe56
--- /dev/null
+++ b/net/caif/cfctrl.c
@@ -0,0 +1,693 @@
+/*
+ * Copyright (C) ST-Ericsson AB 2010
+ * Author:      Sjur Brendeland/sjur.brandeland@stericsson.com
+ * License terms: GNU General Public License (GPL) version 2
+ */
+
+#include <linux/stddef.h>
+#include <linux/spinlock.h>
+#include <linux/slab.h>
+#include <net/caif/caif_layer.h>
+#include <net/caif/cfpkt.h>
+#include <net/caif/cfctrl.h>
+
+#define container_obj(layr) container_of(layr, struct cfctrl, serv.layer)
+#define UTILITY_NAME_LENGTH 16
+#define CFPKT_CTRL_PKT_LEN 20
+
+
+#ifdef CAIF_NO_LOOP
+static int handle_loop(struct cfctrl *ctrl,
+                              int cmd, struct cfpkt *pkt){
+        return CAIF_FAILURE;
+}
+#else
+static int handle_loop(struct cfctrl *ctrl,
+                int cmd, struct cfpkt *pkt);
+#endif
+static int cfctrl_recv(struct cflayer *layr, struct cfpkt *pkt);
+static void cfctrl_ctrlcmd(struct cflayer *layr, enum caif_ctrlcmd ctrl,
+                           int phyid);
+
+
+struct cflayer *cfctrl_create(void)
+{
+        struct dev_info dev_info;
+        struct cfctrl *this =
+                kmalloc(sizeof(struct cfctrl), GFP_ATOMIC);
+        if (!this) {
+                pr_warning("CAIF: %s(): Out of memory\n", __func__);
+                return NULL;
+        }
+        caif_assert(offsetof(struct cfctrl, serv.layer) == 0);
+        memset(&dev_info, 0, sizeof(dev_info));
+        dev_info.id = 0xff;
+        memset(this, 0, sizeof(*this));
+        cfsrvl_init(&this->serv, 0, &dev_info);
+        spin_lock_init(&this->info_list_lock);
+        atomic_set(&this->req_seq_no, 1);
+        atomic_set(&this->rsp_seq_no, 1);
+        this->serv.layer.receive = cfctrl_recv;
+        sprintf(this->serv.layer.name, "ctrl");
+        this->serv.layer.ctrlcmd = cfctrl_ctrlcmd;
+        spin_lock_init(&this->loop_linkid_lock);
+        this->loop_linkid = 1;
+        return &this->serv.layer;
+}
+
+static bool param_eq(struct cfctrl_link_param *p1, struct cfctrl_link_param *p2)
+{
+        bool eq =
+            p1->linktype == p2->linktype &&
+            p1->priority == p2->priority &&
+            p1->phyid == p2->phyid &&
+            p1->endpoint == p2->endpoint && p1->chtype == p2->chtype;
+
+        if (!eq)
+                return false;
+
+        switch (p1->linktype) {
+        case CFCTRL_SRV_VEI:
+                return true;
+        case CFCTRL_SRV_DATAGRAM:
+                return p1->u.datagram.connid == p2->u.datagram.connid;
+        case CFCTRL_SRV_RFM:
+                return
+                    p1->u.rfm.connid == p2->u.rfm.connid &&
+                    strcmp(p1->u.rfm.volume, p2->u.rfm.volume) == 0;
+        case CFCTRL_SRV_UTIL:
+                return
+                    p1->u.utility.fifosize_kb == p2->u.utility.fifosize_kb
+                    && p1->u.utility.fifosize_bufs ==
+                    p2->u.utility.fifosize_bufs
+                    && strcmp(p1->u.utility.name, p2->u.utility.name) == 0
+                    && p1->u.utility.paramlen == p2->u.utility.paramlen
+                    && memcmp(p1->u.utility.params, p2->u.utility.params,
+                              p1->u.utility.paramlen) == 0;
+
+        case CFCTRL_SRV_VIDEO:
+                return p1->u.video.connid == p2->u.video.connid;
+        case CFCTRL_SRV_DBG:
+                return true;
+        case CFCTRL_SRV_DECM:
+                return false;
+        default:
+                return false;
+        }
+        return false;
+}
+
+bool cfctrl_req_eq(struct cfctrl_request_info *r1,
+                   struct cfctrl_request_info *r2)
+{
+        if (r1->cmd != r2->cmd)
+                return false;
+        if (r1->cmd == CFCTRL_CMD_LINK_SETUP)
+                return param_eq(&r1->param, &r2->param);
+        else
+                return r1->channel_id == r2->channel_id;
+}
+
+/* Insert request at the end */
+void cfctrl_insert_req(struct cfctrl *ctrl,
+                              struct cfctrl_request_info *req)
+{
+        struct cfctrl_request_info *p;
+        spin_lock(&ctrl->info_list_lock);
+        req->next = NULL;
+        atomic_inc(&ctrl->req_seq_no);
+        req->sequence_no = atomic_read(&ctrl->req_seq_no);
+        if (ctrl->first_req == NULL) {
+                ctrl->first_req = req;
+                spin_unlock(&ctrl->info_list_lock);
+                return;
+        }
+        p = ctrl->first_req;
+        while (p->next != NULL)
+                p = p->next;
+        p->next = req;
+        spin_unlock(&ctrl->info_list_lock);
+}
+
+/* Compare and remove request */
+struct cfctrl_request_info *cfctrl_remove_req(struct cfctrl *ctrl,
+                                              struct cfctrl_request_info *req)
+{
+        struct cfctrl_request_info *p;
+        struct cfctrl_request_info *ret;
+
+        spin_lock(&ctrl->info_list_lock);
+        if (ctrl->first_req == NULL) {
+                spin_unlock(&ctrl->info_list_lock);
+                return NULL;
+        }
+
+        if (cfctrl_req_eq(req, ctrl->first_req)) {
+                ret = ctrl->first_req;
+                caif_assert(ctrl->first_req);
+                atomic_set(&ctrl->rsp_seq_no,
+                                 ctrl->first_req->sequence_no);
+                ctrl->first_req = ctrl->first_req->next;
+                spin_unlock(&ctrl->info_list_lock);
+                return ret;
+        }
+
+        p = ctrl->first_req;
+
+        while (p->next != NULL) {
+                if (cfctrl_req_eq(req, p->next)) {
+                        pr_warning("CAIF: %s(): Requests are not "
+                                        "received in order\n",
+                                        __func__);
+                        ret = p->next;
+                        atomic_set(&ctrl->rsp_seq_no,
+                                        p->next->sequence_no);
+                        p->next = p->next->next;
+                        spin_unlock(&ctrl->info_list_lock);
+                        return ret;
+                }
+                p = p->next;
+        }
+        spin_unlock(&ctrl->info_list_lock);
+
+        pr_warning("CAIF: %s(): Request does not match\n",
+                   __func__);
+        return NULL;
+}
+
+struct cfctrl_rsp *cfctrl_get_respfuncs(struct cflayer *layer)
+{
+        struct cfctrl *this = container_obj(layer);
+        return &this->res;
+}
+
+void cfctrl_set_dnlayer(struct cflayer *this, struct cflayer *dn)
+{
+        this->dn = dn;
+}
+
+void cfctrl_set_uplayer(struct cflayer *this, struct cflayer *up)
+{
+        this->up = up;
+}
+
+static void init_info(struct caif_payload_info *info, struct cfctrl *cfctrl)
+{
+        info->hdr_len = 0;
+        info->channel_id = cfctrl->serv.layer.id;
+        info->dev_info = &cfctrl->serv.dev_info;
+}
+
+void cfctrl_enum_req(struct cflayer *layer, u8 physlinkid)
+{
+        struct cfctrl *cfctrl = container_obj(layer);
+        int ret;
+        struct cfpkt *pkt = cfpkt_create(CFPKT_CTRL_PKT_LEN);
+        if (!pkt) {
+                pr_warning("CAIF: %s(): Out of memory\n", __func__);
+                return;
+        }
+        caif_assert(offsetof(struct cfctrl, serv.layer) == 0);
+        init_info(cfpkt_info(pkt), cfctrl);
+        cfpkt_info(pkt)->dev_info->id = physlinkid;
+        cfctrl->serv.dev_info.id = physlinkid;
+        cfpkt_addbdy(pkt, CFCTRL_CMD_ENUM);
+        cfpkt_addbdy(pkt, physlinkid);
+        ret =
+            cfctrl->serv.layer.dn->transmit(cfctrl->serv.layer.dn, pkt);
+        if (ret < 0) {
+                pr_err("CAIF: %s(): Could not transmit enum message\n",
+                        __func__);
+                cfpkt_destroy(pkt);
+        }
+}
+
+int cfctrl_linkup_request(struct cflayer *layer,
+                           struct cfctrl_link_param *param,
+                           struct cflayer *user_layer)
+{
+        struct cfctrl *cfctrl = container_obj(layer);
+        u32 tmp32;
+        u16 tmp16;
+        u8 tmp8;
+        struct cfctrl_request_info *req;
+        int ret;
+        char utility_name[16];
+        struct cfpkt *pkt = cfpkt_create(CFPKT_CTRL_PKT_LEN);
+        if (!pkt) {
+                pr_warning("CAIF: %s(): Out of memory\n", __func__);
+                return -ENOMEM;
+        }
+        cfpkt_addbdy(pkt, CFCTRL_CMD_LINK_SETUP);
+        cfpkt_addbdy(pkt, (param->chtype << 4) + param->linktype);
+        cfpkt_addbdy(pkt, (param->priority << 3) + param->phyid);
+        cfpkt_addbdy(pkt, param->endpoint & 0x03);
+
+        switch (param->linktype) {
+        case CFCTRL_SRV_VEI:
+                break;
+        case CFCTRL_SRV_VIDEO:
+                cfpkt_addbdy(pkt, (u8) param->u.video.connid);
+                break;
+        case CFCTRL_SRV_DBG:
+                break;
+        case CFCTRL_SRV_DATAGRAM:
+                tmp32 = cpu_to_le32(param->u.datagram.connid);
+                cfpkt_add_body(pkt, &tmp32, 4);
+                break;
+        case CFCTRL_SRV_RFM:
+                /* Construct a frame, convert DatagramConnectionID to network
+                 * format long and copy it out...
+                 */
+                tmp32 = cpu_to_le32(param->u.rfm.connid);
+                cfpkt_add_body(pkt, &tmp32, 4);
+                /* Add volume name, including zero termination... */
+                cfpkt_add_body(pkt, param->u.rfm.volume,
+                               strlen(param->u.rfm.volume) + 1);
+                break;
+        case CFCTRL_SRV_UTIL:
+                tmp16 = cpu_to_le16(param->u.utility.fifosize_kb);
+                cfpkt_add_body(pkt, &tmp16, 2);
+                tmp16 = cpu_to_le16(param->u.utility.fifosize_bufs);
+                cfpkt_add_body(pkt, &tmp16, 2);
+                memset(utility_name, 0, sizeof(utility_name));
+                strncpy(utility_name, param->u.utility.name,
+                        UTILITY_NAME_LENGTH - 1);
+                cfpkt_add_body(pkt, utility_name, UTILITY_NAME_LENGTH);
+                tmp8 = param->u.utility.paramlen;
+                cfpkt_add_body(pkt, &tmp8, 1);
+                cfpkt_add_body(pkt, param->u.utility.params,
+                               param->u.utility.paramlen);
+                break;
+        default:
+                pr_warning("CAIF: %s():Request setup of bad link type = %d\n",
+                           __func__, param->linktype);
+                return -EINVAL;
+        }
+        req = kmalloc(sizeof(*req), GFP_KERNEL);
+        if (!req) {
+                pr_warning("CAIF: %s(): Out of memory\n", __func__);
+                return -ENOMEM;
+        }
+        memset(req, 0, sizeof(*req));
+        req->client_layer = user_layer;
+        req->cmd = CFCTRL_CMD_LINK_SETUP;
+        req->param = *param;
+        cfctrl_insert_req(cfctrl, req);
+        init_info(cfpkt_info(pkt), cfctrl);
+        /*
+         * NOTE:Always send linkup and linkdown request on the same
+         *      device as the payload. Otherwise old queued up payload
+         *      might arrive with the newly allocated channel ID.
+         */
+        cfpkt_info(pkt)->dev_info->id = param->phyid;
+        ret =
+            cfctrl->serv.layer.dn->transmit(cfctrl->serv.layer.dn, pkt);
+        if (ret < 0) {
+                pr_err("CAIF: %s(): Could not transmit linksetup request\n",
+                        __func__);
+                cfpkt_destroy(pkt);
+                return -ENODEV;
+        }
+        return 0;
+}
+
+int cfctrl_linkdown_req(struct cflayer *layer, u8 channelid,
+                                struct cflayer *client)
+{
+        int ret;
+        struct cfctrl *cfctrl = container_obj(layer);
+        struct cfpkt *pkt = cfpkt_create(CFPKT_CTRL_PKT_LEN);
+        if (!pkt) {
+                pr_warning("CAIF: %s(): Out of memory\n", __func__);
+                return -ENOMEM;
+        }
+        cfpkt_addbdy(pkt, CFCTRL_CMD_LINK_DESTROY);
+        cfpkt_addbdy(pkt, channelid);
+        init_info(cfpkt_info(pkt), cfctrl);
+        ret =
+            cfctrl->serv.layer.dn->transmit(cfctrl->serv.layer.dn, pkt);
+        if (ret < 0) {
+                pr_err("CAIF: %s(): Could not transmit link-down request\n",
+                        __func__);
+                cfpkt_destroy(pkt);
+        }
+        return ret;
+}
+
+void cfctrl_sleep_req(struct cflayer *layer)
+{
+        int ret;
+        struct cfctrl *cfctrl = container_obj(layer);
+        struct cfpkt *pkt = cfpkt_create(CFPKT_CTRL_PKT_LEN);
+        if (!pkt) {
+                pr_warning("CAIF: %s(): Out of memory\n", __func__);
+                return;
+        }
+        cfpkt_addbdy(pkt, CFCTRL_CMD_SLEEP);
+        init_info(cfpkt_info(pkt), cfctrl);
+        ret =
+            cfctrl->serv.layer.dn->transmit(cfctrl->serv.layer.dn, pkt);
+        if (ret < 0)
+                cfpkt_destroy(pkt);
+}
+
+void cfctrl_wake_req(struct cflayer *layer)
+{
+        int ret;
+        struct cfctrl *cfctrl = container_obj(layer);
+        struct cfpkt *pkt = cfpkt_create(CFPKT_CTRL_PKT_LEN);
+        if (!pkt) {
+                pr_warning("CAIF: %s(): Out of memory\n", __func__);
+                return;
+        }
+        cfpkt_addbdy(pkt, CFCTRL_CMD_WAKE);
+        init_info(cfpkt_info(pkt), cfctrl);
+        ret =
+            cfctrl->serv.layer.dn->transmit(cfctrl->serv.layer.dn, pkt);
+        if (ret < 0)
+                cfpkt_destroy(pkt);
+}
+
+void cfctrl_getstartreason_req(struct cflayer *layer)
+{
+        int ret;
+        struct cfctrl *cfctrl = container_obj(layer);
+        struct cfpkt *pkt = cfpkt_create(CFPKT_CTRL_PKT_LEN);
+        if (!pkt) {
+                pr_warning("CAIF: %s(): Out of memory\n", __func__);
+                return;
+        }
+        cfpkt_addbdy(pkt, CFCTRL_CMD_START_REASON);
+        init_info(cfpkt_info(pkt), cfctrl);
+        ret =
+            cfctrl->serv.layer.dn->transmit(cfctrl->serv.layer.dn, pkt);
+        if (ret < 0)
+                cfpkt_destroy(pkt);
+}
+
+
+void cfctrl_cancel_req(struct cflayer *layr, struct cflayer *adap_layer)
+{
+        struct cfctrl_request_info *p, *req;
+        struct cfctrl *ctrl = container_obj(layr);
+        spin_lock(&ctrl->info_list_lock);
+
+        if (ctrl->first_req == NULL) {
+                spin_unlock(&ctrl->info_list_lock);
+                return;
+        }
+
+        if (ctrl->first_req->client_layer == adap_layer) {
+
+                req = ctrl->first_req;
+                ctrl->first_req = ctrl->first_req->next;
+                kfree(req);
+        }
+
+        p = ctrl->first_req;
+        while (p != NULL && p->next != NULL) {
+                if (p->next->client_layer == adap_layer) {
+
+                        req = p->next;
+                        p->next = p->next->next;
+                        kfree(p->next);
+                }
+                p = p->next;
+        }
+
+        spin_unlock(&ctrl->info_list_lock);
+}
+
+static int cfctrl_recv(struct cflayer *layer, struct cfpkt *pkt)
+{
+        u8 cmdrsp;
+        u8 cmd;
+        int ret = -1;
+        u16 tmp16;
+        u8 len;
+        u8 param[255];
+        u8 linkid;
+        struct cfctrl *cfctrl = container_obj(layer);
+        struct cfctrl_request_info rsp, *req;
+
+
+        cfpkt_extr_head(pkt, &cmdrsp, 1);
+        cmd = cmdrsp & CFCTRL_CMD_MASK;
+        if (cmd != CFCTRL_CMD_LINK_ERR
+            && CFCTRL_RSP_BIT != (CFCTRL_RSP_BIT & cmdrsp)) {
+                if (handle_loop(cfctrl, cmd, pkt) == CAIF_FAILURE)
+                        cmdrsp |= CFCTRL_ERR_BIT;
+        }
+
+        switch (cmd) {
+        case CFCTRL_CMD_LINK_SETUP:
+                {
+                        enum cfctrl_srv serv;
+                        enum cfctrl_srv servtype;
+                        u8 endpoint;
+                        u8 physlinkid;
+                        u8 prio;
+                        u8 tmp;
+                        u32 tmp32;
+                        u8 *cp;
+                        int i;
+                        struct cfctrl_link_param linkparam;
+                        memset(&linkparam, 0, sizeof(linkparam));
+
+                        cfpkt_extr_head(pkt, &tmp, 1);
+
+                        serv = tmp & CFCTRL_SRV_MASK;
+                        linkparam.linktype = serv;
+
+                        servtype = tmp >> 4;
+                        linkparam.chtype = servtype;
+
+                        cfpkt_extr_head(pkt, &tmp, 1);
+                        physlinkid = tmp & 0x07;
+                        prio = tmp >> 3;
+
+                        linkparam.priority = prio;
+                        linkparam.phyid = physlinkid;
+                        cfpkt_extr_head(pkt, &endpoint, 1);
+                        linkparam.endpoint = endpoint & 0x03;
+
+                        switch (serv) {
+                        case CFCTRL_SRV_VEI:
+                        case CFCTRL_SRV_DBG:
+                                if (CFCTRL_ERR_BIT & cmdrsp)
+                                        break;
+                                /* Link ID */
+                                cfpkt_extr_head(pkt, &linkid, 1);
+                                break;
+                        case CFCTRL_SRV_VIDEO:
+                                cfpkt_extr_head(pkt, &tmp, 1);
+                                linkparam.u.video.connid = tmp;
+                                if (CFCTRL_ERR_BIT & cmdrsp)
+                                        break;
+                                /* Link ID */
+                                cfpkt_extr_head(pkt, &linkid, 1);
+                                break;
+
+                        case CFCTRL_SRV_DATAGRAM:
+                                cfpkt_extr_head(pkt, &tmp32, 4);
+                                linkparam.u.datagram.connid =
+                                    le32_to_cpu(tmp32);
+                                if (CFCTRL_ERR_BIT & cmdrsp)
+                                        break;
+                                /* Link ID */
+                                cfpkt_extr_head(pkt, &linkid, 1);
+                                break;
+                        case CFCTRL_SRV_RFM:
+                                /* Construct a frame, convert
+                                 * DatagramConnectionID
+                                 * to network format long and copy it out...
+                                 */
+                                cfpkt_extr_head(pkt, &tmp32, 4);
+                                linkparam.u.rfm.connid =
+                                  le32_to_cpu(tmp32);
+                                cp = (u8 *) linkparam.u.rfm.volume;
+                                for (cfpkt_extr_head(pkt, &tmp, 1);
+                                     cfpkt_more(pkt) && tmp != '\0';
+                                     cfpkt_extr_head(pkt, &tmp, 1))
+                                        *cp++ = tmp;
+                                *cp = '\0';
+
+                                if (CFCTRL_ERR_BIT & cmdrsp)
+                                        break;
+                                /* Link ID */
+                                cfpkt_extr_head(pkt, &linkid, 1);
+
+                                break;
+                        case CFCTRL_SRV_UTIL:
+                                /* Construct a frame, convert
+                                 * DatagramConnectionID
+                                 * to network format long and copy it out...
+                                 */
+                                /* Fifosize KB */
+                                cfpkt_extr_head(pkt, &tmp16, 2);
+                                linkparam.u.utility.fifosize_kb =
+                                    le16_to_cpu(tmp16);
+                                /* Fifosize bufs */
+                                cfpkt_extr_head(pkt, &tmp16, 2);
+                                linkparam.u.utility.fifosize_bufs =
+                                    le16_to_cpu(tmp16);
+                                /* name */
+                                cp = (u8 *) linkparam.u.utility.name;
+                                caif_assert(sizeof(linkparam.u.utility.name)
+                                             >= UTILITY_NAME_LENGTH);
+                                for (i = 0;
+                                     i < UTILITY_NAME_LENGTH
+                                     && cfpkt_more(pkt); i++) {
+                                        cfpkt_extr_head(pkt, &tmp, 1);
+                                        *cp++ = tmp;
+                                }
+                                /* Length */
+                                cfpkt_extr_head(pkt, &len, 1);
+                                linkparam.u.utility.paramlen = len;
+                                /* Param Data */
+                                cp = linkparam.u.utility.params;
+                                while (cfpkt_more(pkt) && len--) {
+                                        cfpkt_extr_head(pkt, &tmp, 1);
+                                        *cp++ = tmp;
+                                }
+                                if (CFCTRL_ERR_BIT & cmdrsp)
+                                        break;
+                                /* Link ID */
+                                cfpkt_extr_head(pkt, &linkid, 1);
+                                /* Length */
+                                cfpkt_extr_head(pkt, &len, 1);
+                                /* Param Data */
+                                cfpkt_extr_head(pkt, &param, len);
+                                break;
+                        default:
+                                pr_warning("CAIF: %s(): Request setup "
+                                           "- invalid link type (%d)",
+                                           __func__, serv);
+                                goto error;
+                        }
+
+                        rsp.cmd = cmd;
+                        rsp.param = linkparam;
+                        req = cfctrl_remove_req(cfctrl, &rsp);
+
+                        if (CFCTRL_ERR_BIT == (CFCTRL_ERR_BIT & cmdrsp) ||
+                                cfpkt_erroneous(pkt)) {
+                                pr_err("CAIF: %s(): Invalid O/E bit or parse "
+                                       "error on CAIF control channel",
+                                        __func__);
+                                cfctrl->res.reject_rsp(cfctrl->serv.layer.up,
+                                                       0,
+                                                       req ? req->client_layer
+                                                       : NULL);
+                        } else {
+                                cfctrl->res.linksetup_rsp(cfctrl->serv.
+                                                          layer.up, linkid,
+                                                          serv, physlinkid,
+                                                          req ? req->
+                                                          client_layer : NULL);
+                        }
+
+                        if (req != NULL)
+                                kfree(req);
+                }
+                break;
+        case CFCTRL_CMD_LINK_DESTROY:
+                cfpkt_extr_head(pkt, &linkid, 1);
+                cfctrl->res.linkdestroy_rsp(cfctrl->serv.layer.up, linkid);
+                break;
+        case CFCTRL_CMD_LINK_ERR:
+                pr_err("CAIF: %s(): Frame Error Indication received\n",
+                        __func__);
+                cfctrl->res.linkerror_ind();
+                break;
+        case CFCTRL_CMD_ENUM:
+                cfctrl->res.enum_rsp();
+                break;
+        case CFCTRL_CMD_SLEEP:
+                cfctrl->res.sleep_rsp();
+                break;
+        case CFCTRL_CMD_WAKE:
+                cfctrl->res.wake_rsp();
+                break;
+        case CFCTRL_CMD_LINK_RECONF:
+                cfctrl->res.restart_rsp();
+                break;
+        case CFCTRL_CMD_RADIO_SET:
+                cfctrl->res.radioset_rsp();
+                break;
+        default:
+                pr_err("CAIF: %s(): Unrecognized Control Frame\n", __func__);
+                goto error;
+                break;
+        }
+        ret = 0;
+error:
+        cfpkt_destroy(pkt);
+        return ret;
+}
+
+static void cfctrl_ctrlcmd(struct cflayer *layr, enum caif_ctrlcmd ctrl,
+                        int phyid)
+{
+        struct cfctrl *this = container_obj(layr);
+        switch (ctrl) {
+        case _CAIF_CTRLCMD_PHYIF_FLOW_OFF_IND:
+        case CAIF_CTRLCMD_FLOW_OFF_IND:
+                spin_lock(&this->info_list_lock);
+                if (this->first_req != NULL) {
+                        pr_debug("CAIF: %s(): Received flow off in "
+                                   "control layer", __func__);
+                }
+                spin_unlock(&this->info_list_lock);
+                break;
+        default:
+                break;
+        }
+}
+
+#ifndef CAIF_NO_LOOP
+static int handle_loop(struct cfctrl *ctrl, int cmd, struct cfpkt *pkt)
+{
+        static int last_linkid;
+        u8 linkid, linktype, tmp;
+        switch (cmd) {
+        case CFCTRL_CMD_LINK_SETUP:
+                spin_lock(&ctrl->loop_linkid_lock);
+                for (linkid = last_linkid + 1; linkid < 255; linkid++)
+                        if (!ctrl->loop_linkused[linkid])
+                                goto found;
+                for (linkid = last_linkid - 1; linkid > 0; linkid--)
+                        if (!ctrl->loop_linkused[linkid])
+                                goto found;
+                spin_unlock(&ctrl->loop_linkid_lock);
+                pr_err("CAIF: %s(): Out of link-ids\n", __func__);
+                return -EINVAL;
+found:
+                if (!ctrl->loop_linkused[linkid])
+                        ctrl->loop_linkused[linkid] = 1;
+
+                last_linkid = linkid;
+
+                cfpkt_add_trail(pkt, &linkid, 1);
+                spin_unlock(&ctrl->loop_linkid_lock);
+                cfpkt_peek_head(pkt, &linktype, 1);
+                if (linktype ==  CFCTRL_SRV_UTIL) {
+                        tmp = 0x01;
+                        cfpkt_add_trail(pkt, &tmp, 1);
+                        cfpkt_add_trail(pkt, &tmp, 1);
+                }
+                break;
+
+        case CFCTRL_CMD_LINK_DESTROY:
+                spin_lock(&ctrl->loop_linkid_lock);
+                cfpkt_peek_head(pkt, &linkid, 1);
+                ctrl->loop_linkused[linkid] = 0;
+                spin_unlock(&ctrl->loop_linkid_lock);
+                break;
+        default:
+                break;
+        }
+        return CAIF_SUCCESS;
+}
+#endif
diff --git a/net/caif/cfdbgl.c b/net/caif/cfdbgl.c
new file mode 100644
index 000000000000..ab6b6dc34cf8
--- /dev/null
+++ b/net/caif/cfdbgl.c
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) ST-Ericsson AB 2010
+ * Author:      Sjur Brendeland/sjur.brandeland@stericsson.com
+ * License terms: GNU General Public License (GPL) version 2
+ */
+
+#include <linux/stddef.h>
+#include <linux/slab.h>
+#include <net/caif/caif_layer.h>
+#include <net/caif/cfsrvl.h>
+#include <net/caif/cfpkt.h>
+
+static int cfdbgl_receive(struct cflayer *layr, struct cfpkt *pkt);
+static int cfdbgl_transmit(struct cflayer *layr, struct cfpkt *pkt);
+
+struct cflayer *cfdbgl_create(u8 channel_id, struct dev_info *dev_info)
+{
+        struct cfsrvl *dbg = kmalloc(sizeof(struct cfsrvl), GFP_ATOMIC);
+        if (!dbg) {
+                pr_warning("CAIF: %s(): Out of memory\n", __func__);
+                return NULL;
+        }
+        caif_assert(offsetof(struct cfsrvl, layer) == 0);
+        memset(dbg, 0, sizeof(struct cfsrvl));
+        cfsrvl_init(dbg, channel_id, dev_info);
+        dbg->layer.receive = cfdbgl_receive;
+        dbg->layer.transmit = cfdbgl_transmit;
+        snprintf(dbg->layer.name, CAIF_LAYER_NAME_SZ - 1, "dbg%d", channel_id);
+        return &dbg->layer;
+}
+
+static int cfdbgl_receive(struct cflayer *layr, struct cfpkt *pkt)
+{
+        return layr->up->receive(layr->up, pkt);
+}
+
+static int cfdbgl_transmit(struct cflayer *layr, struct cfpkt *pkt)
+{
+        return layr->dn->transmit(layr->dn, pkt);
+}
diff --git a/net/caif/cfdgml.c b/net/caif/cfdgml.c
new file mode 100644
index 000000000000..53194840ecb6
--- /dev/null
+++ b/net/caif/cfdgml.c
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) ST-Ericsson AB 2010
+ * Author:      Sjur Brendeland/sjur.brandeland@stericsson.com
+ * License terms: GNU General Public License (GPL) version 2
+ */
+
+#include <linux/stddef.h>
+#include <linux/spinlock.h>
+#include <linux/slab.h>
+#include <net/caif/caif_layer.h>
+#include <net/caif/cfsrvl.h>
+#include <net/caif/cfpkt.h>
+
+#define container_obj(layr) ((struct cfsrvl *) layr)
+
+#define DGM_CMD_BIT  0x80
+#define DGM_FLOW_OFF 0x81
+#define DGM_FLOW_ON  0x80
+#define DGM_CTRL_PKT_SIZE 1
+
+static int cfdgml_receive(struct cflayer *layr, struct cfpkt *pkt);
+static int cfdgml_transmit(struct cflayer *layr, struct cfpkt *pkt);
+
+struct cflayer *cfdgml_create(u8 channel_id, struct dev_info *dev_info)
+{
+        struct cfsrvl *dgm = kmalloc(sizeof(struct cfsrvl), GFP_ATOMIC);
+        if (!dgm) {
+                pr_warning("CAIF: %s(): Out of memory\n", __func__);
+                return NULL;
+        }
+        caif_assert(offsetof(struct cfsrvl, layer) == 0);
+        memset(dgm, 0, sizeof(struct cfsrvl));
+        cfsrvl_init(dgm, channel_id, dev_info);
+        dgm->layer.receive = cfdgml_receive;
+        dgm->layer.transmit = cfdgml_transmit;
+        snprintf(dgm->layer.name, CAIF_LAYER_NAME_SZ - 1, "dgm%d", channel_id);
+        dgm->layer.name[CAIF_LAYER_NAME_SZ - 1] = '\0';
+        return &dgm->layer;
+}
+
+static int cfdgml_receive(struct cflayer *layr, struct cfpkt *pkt)
+{
+        u8 cmd = -1;
+        u8 dgmhdr[3];
+        int ret;
+        caif_assert(layr->up != NULL);
+        caif_assert(layr->receive != NULL);
+        caif_assert(layr->ctrlcmd != NULL);
+
+        if (cfpkt_extr_head(pkt, &cmd, 1) < 0) {
+                pr_err("CAIF: %s(): Packet is erroneous!\n", __func__);
+                cfpkt_destroy(pkt);
+                return -EPROTO;
+        }
+
+        if ((cmd & DGM_CMD_BIT) == 0) {
+                if (cfpkt_extr_head(pkt, &dgmhdr, 3) < 0) {
+                        pr_err("CAIF: %s(): Packet is erroneous!\n", __func__);
+                        cfpkt_destroy(pkt);
+                        return -EPROTO;
+                }
+                ret = layr->up->receive(layr->up, pkt);
+                return ret;
+        }
+
+        switch (cmd) {
+        case DGM_FLOW_OFF:      /* FLOW OFF */
+                layr->ctrlcmd(layr, CAIF_CTRLCMD_FLOW_OFF_IND, 0);
+                cfpkt_destroy(pkt);
+                return 0;
+        case DGM_FLOW_ON:       /* FLOW ON */
+                layr->ctrlcmd(layr, CAIF_CTRLCMD_FLOW_ON_IND, 0);
+                cfpkt_destroy(pkt);
+                return 0;
+        default:
+                cfpkt_destroy(pkt);
+                pr_info("CAIF: %s(): Unknown datagram control %d (0x%x)\n",
+                        __func__, cmd, cmd);
+                return -EPROTO;
+        }
+}
+
+static int cfdgml_transmit(struct cflayer *layr, struct cfpkt *pkt)
+{
+        u32 zero = 0;
+        struct caif_payload_info *info;
+        struct cfsrvl *service = container_obj(layr);
+        int ret;
+        if (!cfsrvl_ready(service, &ret))
+                return ret;
+
+        cfpkt_add_head(pkt, &zero, 4);
+
+        /* Add info for MUX-layer to route the packet out. */
+        info = cfpkt_info(pkt);
+        info->channel_id = service->layer.id;
+        /* To optimize alignment, we add up the size of CAIF header
+         * before payload.
+         */
+        info->hdr_len = 4;
+        info->dev_info = &service->dev_info;
+        ret = layr->dn->transmit(layr->dn, pkt);
+        if (ret < 0) {
+                u32 tmp32;
+                cfpkt_extr_head(pkt, &tmp32, 4);
+        }
+        return ret;
+}
diff --git a/net/caif/cffrml.c b/net/caif/cffrml.c
new file mode 100644
index 000000000000..e86a4ca3b217
--- /dev/null
+++ b/net/caif/cffrml.c
@@ -0,0 +1,151 @@
+/*
+ * CAIF Framing Layer.
+ *
+ * Copyright (C) ST-Ericsson AB 2010
+ * Author:      Sjur Brendeland/sjur.brandeland@stericsson.com
+ * License terms: GNU General Public License (GPL) version 2
+ */
+
+#include <linux/stddef.h>
+#include <linux/spinlock.h>
+#include <linux/slab.h>
+#include <linux/crc-ccitt.h>
+#include <net/caif/caif_layer.h>
+#include <net/caif/cfpkt.h>
+#include <net/caif/cffrml.h>
+
+#define container_obj(layr) container_of(layr, struct cffrml, layer)
+
+struct cffrml {
+        struct cflayer layer;
+        bool dofcs;             /* !< FCS active */
+};
+
+static int cffrml_receive(struct cflayer *layr, struct cfpkt *pkt);
+static int cffrml_transmit(struct cflayer *layr, struct cfpkt *pkt);
+static void cffrml_ctrlcmd(struct cflayer *layr, enum caif_ctrlcmd ctrl,
+                                int phyid);
+
+static u32 cffrml_rcv_error;
+static u32 cffrml_rcv_checsum_error;
+struct cflayer *cffrml_create(u16 phyid, bool use_fcs)
+{
+        struct cffrml *this = kmalloc(sizeof(struct cffrml), GFP_ATOMIC);
+        if (!this) {
+                pr_warning("CAIF: %s(): Out of memory\n", __func__);
+                return NULL;
+        }
+        caif_assert(offsetof(struct cffrml, layer) == 0);
+
+        memset(this, 0, sizeof(struct cflayer));
+        this->layer.receive = cffrml_receive;
+        this->layer.transmit = cffrml_transmit;
+        this->layer.ctrlcmd = cffrml_ctrlcmd;
+        snprintf(this->layer.name, CAIF_LAYER_NAME_SZ, "frm%d", phyid);
+        this->dofcs = use_fcs;
+        this->layer.id = phyid;
+        return (struct cflayer *) this;
+}
+
+void cffrml_set_uplayer(struct cflayer *this, struct cflayer *up)
+{
+        this->up = up;
+}
+
+void cffrml_set_dnlayer(struct cflayer *this, struct cflayer *dn)
+{
+        this->dn = dn;
+}
+
+static u16 cffrml_checksum(u16 chks, void *buf, u16 len)
+{
+        /* FIXME: FCS should be moved to glue in order to use OS-Specific
+         * solutions
+         */
+        return crc_ccitt(chks, buf, len);
+}
+
+static int cffrml_receive(struct cflayer *layr, struct cfpkt *pkt)
+{
+        u16 tmp;
+        u16 len;
+        u16 hdrchks;
+        u16 pktchks;
+        struct cffrml *this;
+        this = container_obj(layr);
+
+        cfpkt_extr_head(pkt, &tmp, 2);
+        len = le16_to_cpu(tmp);
+
+        /* Subtract for FCS on length if FCS is not used. */
+        if (!this->dofcs)
+                len -= 2;
+
+        if (cfpkt_setlen(pkt, len) < 0) {
+                ++cffrml_rcv_error;
+                pr_err("CAIF: %s():Framing length error (%d)\n", __func__, len);
+                cfpkt_destroy(pkt);
+                return -EPROTO;
+        }
+        /*
+         * Don't do extract if FCS is false, rather do setlen - then we don't
+         * get a cache-miss.
+         */
+        if (this->dofcs) {
+                cfpkt_extr_trail(pkt, &tmp, 2);
+                hdrchks = le16_to_cpu(tmp);
+                pktchks = cfpkt_iterate(pkt, cffrml_checksum, 0xffff);
+                if (pktchks != hdrchks) {
+                        cfpkt_add_trail(pkt, &tmp, 2);
+                        ++cffrml_rcv_error;
+                        ++cffrml_rcv_checsum_error;
+                        pr_info("CAIF: %s(): Frame checksum error "
+                                "(0x%x != 0x%x)\n", __func__, hdrchks, pktchks);
+                        return -EILSEQ;
+                }
+        }
+        if (cfpkt_erroneous(pkt)) {
+                ++cffrml_rcv_error;
+                pr_err("CAIF: %s(): Packet is erroneous!\n", __func__);
+                cfpkt_destroy(pkt);
+                return -EPROTO;
+        }
+        return layr->up->receive(layr->up, pkt);
+}
+
+static int cffrml_transmit(struct cflayer *layr, struct cfpkt *pkt)
+{
+        int tmp;
+        u16 chks;
+        u16 len;
+        int ret;
+        struct cffrml *this = container_obj(layr);
+        if (this->dofcs) {
+                chks = cfpkt_iterate(pkt, cffrml_checksum, 0xffff);
+                tmp = cpu_to_le16(chks);
+                cfpkt_add_trail(pkt, &tmp, 2);
+        } else {
+                cfpkt_pad_trail(pkt, 2);
+        }
+        len = cfpkt_getlen(pkt);
+        tmp = cpu_to_le16(len);
+        cfpkt_add_head(pkt, &tmp, 2);
+        cfpkt_info(pkt)->hdr_len += 2;
+        if (cfpkt_erroneous(pkt)) {
+                pr_err("CAIF: %s(): Packet is erroneous!\n", __func__);
+                return -EPROTO;
+        }
+        ret = layr->dn->transmit(layr->dn, pkt);
+        if (ret < 0) {
+                /* Remove header on faulty packet. */
+                cfpkt_extr_head(pkt, &tmp, 2);
+        }
+        return ret;
+}
+
+static void cffrml_ctrlcmd(struct cflayer *layr, enum caif_ctrlcmd ctrl,
+                                        int phyid)
+{
+        if (layr->up->ctrlcmd)
+                layr->up->ctrlcmd(layr->up, ctrl, layr->id);
+}
diff --git a/net/caif/cfmuxl.c b/net/caif/cfmuxl.c
new file mode 100644
index 000000000000..7372f27f1d32
--- /dev/null
+++ b/net/caif/cfmuxl.c
@@ -0,0 +1,251 @@
+/*
+ * Copyright (C) ST-Ericsson AB 2010
+ * Author:      Sjur Brendeland/sjur.brandeland@stericsson.com
+ * License terms: GNU General Public License (GPL) version 2
+ */
+#include <linux/stddef.h>
+#include <linux/spinlock.h>
+#include <linux/slab.h>
+#include <net/caif/cfpkt.h>
+#include <net/caif/cfmuxl.h>
+#include <net/caif/cfsrvl.h>
+#include <net/caif/cffrml.h>
+
+#define container_obj(layr) container_of(layr, struct cfmuxl, layer)
+
+#define CAIF_CTRL_CHANNEL 0
+#define UP_CACHE_SIZE 8
+#define DN_CACHE_SIZE 8
+
+struct cfmuxl {
+        struct cflayer layer;
+        struct list_head srvl_list;
+        struct list_head frml_list;
+        struct cflayer *up_cache[UP_CACHE_SIZE];
+        struct cflayer *dn_cache[DN_CACHE_SIZE];
+        /*
+         * Set when inserting or removing downwards layers.
+         */
+        spinlock_t transmit_lock;
+
+        /*
+         * Set when inserting or removing upwards layers.
+         */
+        spinlock_t receive_lock;
+
+};
+
+static int cfmuxl_receive(struct cflayer *layr, struct cfpkt *pkt);
+static int cfmuxl_transmit(struct cflayer *layr, struct cfpkt *pkt);
+static void cfmuxl_ctrlcmd(struct cflayer *layr, enum caif_ctrlcmd ctrl,
+                                int phyid);
+static struct cflayer *get_up(struct cfmuxl *muxl, u16 id);
+
+struct cflayer *cfmuxl_create(void)
+{
+        struct cfmuxl *this = kmalloc(sizeof(struct cfmuxl), GFP_ATOMIC);
+        if (!this)
+                return NULL;
+        memset(this, 0, sizeof(*this));
+        this->layer.receive = cfmuxl_receive;
+        this->layer.transmit = cfmuxl_transmit;
+        this->layer.ctrlcmd = cfmuxl_ctrlcmd;
+        INIT_LIST_HEAD(&this->srvl_list);
+        INIT_LIST_HEAD(&this->frml_list);
+        spin_lock_init(&this->transmit_lock);
+        spin_lock_init(&this->receive_lock);
+        snprintf(this->layer.name, CAIF_LAYER_NAME_SZ, "mux");
+        return &this->layer;
+}
+
+int cfmuxl_set_uplayer(struct cflayer *layr, struct cflayer *up, u8 linkid)
+{
+        struct cfmuxl *muxl = container_obj(layr);
+        spin_lock(&muxl->receive_lock);
+        cfsrvl_get(up);
+        list_add(&up->node, &muxl->srvl_list);
+        spin_unlock(&muxl->receive_lock);
+        return 0;
+}
+
+bool cfmuxl_is_phy_inuse(struct cflayer *layr, u8 phyid)
+{
+        struct list_head *node;
+        struct cflayer *layer;
+        struct cfmuxl *muxl = container_obj(layr);
+        bool match = false;
+        spin_lock(&muxl->receive_lock);
+
+        list_for_each(node, &muxl->srvl_list) {
+                layer = list_entry(node, struct cflayer, node);
+                if (cfsrvl_phyid_match(layer, phyid)) {
+                        match = true;
+                        break;
+                }
+
+        }
+        spin_unlock(&muxl->receive_lock);
+        return match;
+}
+
+u8 cfmuxl_get_phyid(struct cflayer *layr, u8 channel_id)
+{
+        struct cflayer *up;
+        int phyid;
+        struct cfmuxl *muxl = container_obj(layr);
+        spin_lock(&muxl->receive_lock);
+        up = get_up(muxl, channel_id);
+        if (up != NULL)
+                phyid = cfsrvl_getphyid(up);
+        else
+                phyid = 0;
+        spin_unlock(&muxl->receive_lock);
+        return phyid;
+}
+
+int cfmuxl_set_dnlayer(struct cflayer *layr, struct cflayer *dn, u8 phyid)
+{
+        struct cfmuxl *muxl = (struct cfmuxl *) layr;
+        spin_lock(&muxl->transmit_lock);
+        list_add(&dn->node, &muxl->frml_list);
+        spin_unlock(&muxl->transmit_lock);
+        return 0;
+}
+
+static struct cflayer *get_from_id(struct list_head *list, u16 id)
+{
+        struct list_head *node;
+        struct cflayer *layer;
+        list_for_each(node, list) {
+                layer = list_entry(node, struct cflayer, node);
+                if (layer->id == id)
+                        return layer;
+        }
+        return NULL;
+}
+
+struct cflayer *cfmuxl_remove_dnlayer(struct cflayer *layr, u8 phyid)
+{
+        struct cfmuxl *muxl = container_obj(layr);
+        struct cflayer *dn;
+        spin_lock(&muxl->transmit_lock);
+        memset(muxl->dn_cache, 0, sizeof(muxl->dn_cache));
+        dn = get_from_id(&muxl->frml_list, phyid);
+        if (dn == NULL) {
+                spin_unlock(&muxl->transmit_lock);
+                return NULL;
+        }
+        list_del(&dn->node);
+        caif_assert(dn != NULL);
+        spin_unlock(&muxl->transmit_lock);
+        return dn;
+}
+
+/* Invariant: lock is taken */
+static struct cflayer *get_up(struct cfmuxl *muxl, u16 id)
+{
+        struct cflayer *up;
+        int idx = id % UP_CACHE_SIZE;
+        up = muxl->up_cache[idx];
+        if (up == NULL || up->id != id) {
+                up = get_from_id(&muxl->srvl_list, id);
+                muxl->up_cache[idx] = up;
+        }
+        return up;
+}
+
+/* Invariant: lock is taken */
+static struct cflayer *get_dn(struct cfmuxl *muxl, struct dev_info *dev_info)
+{
+        struct cflayer *dn;
+        int idx = dev_info->id % DN_CACHE_SIZE;
+        dn = muxl->dn_cache[idx];
+        if (dn == NULL || dn->id != dev_info->id) {
+                dn = get_from_id(&muxl->frml_list, dev_info->id);
+                muxl->dn_cache[idx] = dn;
+        }
+        return dn;
+}
+
+struct cflayer *cfmuxl_remove_uplayer(struct cflayer *layr, u8 id)
+{
+        struct cflayer *up;
+        struct cfmuxl *muxl = container_obj(layr);
+        spin_lock(&muxl->receive_lock);
+        up = get_up(muxl, id);
+        if (up == NULL)
+                return NULL;
+        memset(muxl->up_cache, 0, sizeof(muxl->up_cache));
+        list_del(&up->node);
+        cfsrvl_put(up);
+        spin_unlock(&muxl->receive_lock);
+        return up;
+}
+
+static int cfmuxl_receive(struct cflayer *layr, struct cfpkt *pkt)
+{
+        int ret;
+        struct cfmuxl *muxl = container_obj(layr);
+        u8 id;
+        struct cflayer *up;
+        if (cfpkt_extr_head(pkt, &id, 1) < 0) {
+                pr_err("CAIF: %s(): erroneous Caif Packet\n", __func__);
+                cfpkt_destroy(pkt);
+                return -EPROTO;
+        }
+
+        spin_lock(&muxl->receive_lock);
+        up = get_up(muxl, id);
+        spin_unlock(&muxl->receive_lock);
+        if (up == NULL) {
+                pr_info("CAIF: %s():Received data on unknown link ID = %d "
+                        "(0x%x)  up == NULL", __func__, id, id);
+                cfpkt_destroy(pkt);
+                /*
+                 * Don't return ERROR, since modem misbehaves and sends out
+                 * flow on before linksetup response.
+                 */
+                return /* CFGLU_EPROT; */ 0;
+        }
+        cfsrvl_get(up);
+        ret = up->receive(up, pkt);
+        cfsrvl_put(up);
+        return ret;
+}
+
+static int cfmuxl_transmit(struct cflayer *layr, struct cfpkt *pkt)
+{
+        int ret;
+        struct cfmuxl *muxl = container_obj(layr);
+        u8 linkid;
+        struct cflayer *dn;
+        struct caif_payload_info *info = cfpkt_info(pkt);
+        dn = get_dn(muxl, cfpkt_info(pkt)->dev_info);
+        if (dn == NULL) {
+                pr_warning("CAIF: %s(): Send data on unknown phy "
+                           "ID = %d (0x%x)\n",
+                           __func__, info->dev_info->id, info->dev_info->id);
+                return -ENOTCONN;
+        }
+        info->hdr_len += 1;
+        linkid = info->channel_id;
+        cfpkt_add_head(pkt, &linkid, 1);
+        ret = dn->transmit(dn, pkt);
+        /* Remove MUX protocol header upon error. */
+        if (ret < 0)
+                cfpkt_extr_head(pkt, &linkid, 1);
+        return ret;
+}
+
+static void cfmuxl_ctrlcmd(struct cflayer *layr, enum caif_ctrlcmd ctrl,
+                                int phyid)
+{
+        struct cfmuxl *muxl = container_obj(layr);
+        struct list_head *node;
+        struct cflayer *layer;
+        list_for_each(node, &muxl->srvl_list) {
+                layer = list_entry(node, struct cflayer, node);
+                if (cfsrvl_phyid_match(layer, phyid))
+                        layer->ctrlcmd(layer, ctrl, phyid);
+        }
+}
diff --git a/net/caif/cfpkt_skbuff.c b/net/caif/cfpkt_skbuff.c
new file mode 100644
index 000000000000..83fff2ff6658
--- /dev/null
+++ b/net/caif/cfpkt_skbuff.c
@@ -0,0 +1,571 @@
+/*
+ * Copyright (C) ST-Ericsson AB 2010
+ * Author:      Sjur Brendeland/sjur.brandeland@stericsson.com
+ * License terms: GNU General Public License (GPL) version 2
+ */
+
+#include <linux/string.h>
+#include <linux/skbuff.h>
+#include <linux/hardirq.h>
+#include <net/caif/cfpkt.h>
+
+#define PKT_PREFIX CAIF_NEEDED_HEADROOM
+#define PKT_POSTFIX CAIF_NEEDED_TAILROOM
+#define PKT_LEN_WHEN_EXTENDING 128
+#define PKT_ERROR(pkt, errmsg) do {        \
+    cfpkt_priv(pkt)->erronous = true;      \
+    skb_reset_tail_pointer(&pkt->skb);     \
+    pr_warning("CAIF: " errmsg);\
+  } while (0)
+
+struct cfpktq {
+        struct sk_buff_head head;
+        atomic_t count;
+        /* Lock protects count updates */
+        spinlock_t lock;
+};
+
+/*
+ * net/caif/ is generic and does not
+ * understand SKB, so we do this typecast
+ */
+struct cfpkt {
+        struct sk_buff skb;
+};
+
+/* Private data inside SKB */
+struct cfpkt_priv_data {
+        struct dev_info dev_info;
+        bool erronous;
+};
+
+inline struct cfpkt_priv_data *cfpkt_priv(struct cfpkt *pkt)
+{
+        return (struct cfpkt_priv_data *) pkt->skb.cb;
+}
+
+inline bool is_erronous(struct cfpkt *pkt)
+{
+        return cfpkt_priv(pkt)->erronous;
+}
+
+inline struct sk_buff *pkt_to_skb(struct cfpkt *pkt)
+{
+        return &pkt->skb;
+}
+
+inline struct cfpkt *skb_to_pkt(struct sk_buff *skb)
+{
+        return (struct cfpkt *) skb;
+}
+
+
+struct cfpkt *cfpkt_fromnative(enum caif_direction dir, void *nativepkt)
+{
+        struct cfpkt *pkt = skb_to_pkt(nativepkt);
+        cfpkt_priv(pkt)->erronous = false;
+        return pkt;
+}
+EXPORT_SYMBOL(cfpkt_fromnative);
+
+void *cfpkt_tonative(struct cfpkt *pkt)
+{
+        return (void *) pkt;
+}
+EXPORT_SYMBOL(cfpkt_tonative);
+
+static struct cfpkt *cfpkt_create_pfx(u16 len, u16 pfx)
+{
+        struct sk_buff *skb;
+
+        if (likely(in_interrupt()))
+                skb = alloc_skb(len + pfx, GFP_ATOMIC);
+        else
+                skb = alloc_skb(len + pfx, GFP_KERNEL);
+
+        if (unlikely(skb == NULL))
+                return NULL;
+
+        skb_reserve(skb, pfx);
+        return skb_to_pkt(skb);
+}
+
+inline struct cfpkt *cfpkt_create(u16 len)
+{
+        return cfpkt_create_pfx(len + PKT_POSTFIX, PKT_PREFIX);
+}
+EXPORT_SYMBOL(cfpkt_create);
+
+void cfpkt_destroy(struct cfpkt *pkt)
+{
+        struct sk_buff *skb = pkt_to_skb(pkt);
+        kfree_skb(skb);
+}
+EXPORT_SYMBOL(cfpkt_destroy);
+
+inline bool cfpkt_more(struct cfpkt *pkt)
+{
+        struct sk_buff *skb = pkt_to_skb(pkt);
+        return skb->len > 0;
+}
+EXPORT_SYMBOL(cfpkt_more);
+
+int cfpkt_peek_head(struct cfpkt *pkt, void *data, u16 len)
+{
+        struct sk_buff *skb = pkt_to_skb(pkt);
+        if (skb_headlen(skb) >= len) {
+                memcpy(data, skb->data, len);
+                return 0;
+        }
+        return !cfpkt_extr_head(pkt, data, len) &&
+            !cfpkt_add_head(pkt, data, len);
+}
+EXPORT_SYMBOL(cfpkt_peek_head);
+
+int cfpkt_extr_head(struct cfpkt *pkt, void *data, u16 len)
+{
+        struct sk_buff *skb = pkt_to_skb(pkt);
+        u8 *from;
+        if (unlikely(is_erronous(pkt)))
+                return -EPROTO;
+
+        if (unlikely(len > skb->len)) {
+                PKT_ERROR(pkt, "cfpkt_extr_head read beyond end of packet\n");
+                return -EPROTO;
+        }
+
+        if (unlikely(len > skb_headlen(skb))) {
+                if (unlikely(skb_linearize(skb) != 0)) {
+                        PKT_ERROR(pkt, "cfpkt_extr_head linearize failed\n");
+                        return -EPROTO;
+                }
+        }
+        from = skb_pull(skb, len);
+        from -= len;
+        memcpy(data, from, len);
+        return 0;
+}
+EXPORT_SYMBOL(cfpkt_extr_head);
+
+int cfpkt_extr_trail(struct cfpkt *pkt, void *dta, u16 len)
+{
+        struct sk_buff *skb = pkt_to_skb(pkt);
+        u8 *data = dta;
+        u8 *from;
+        if (unlikely(is_erronous(pkt)))
+                return -EPROTO;
+
+        if (unlikely(skb_linearize(skb) != 0)) {
+                PKT_ERROR(pkt, "cfpkt_extr_trail linearize failed\n");
+                return -EPROTO;
+        }
+        if (unlikely(skb->data + len > skb_tail_pointer(skb))) {
+                PKT_ERROR(pkt, "cfpkt_extr_trail read beyond end of packet\n");
+                return -EPROTO;
+        }
+        from = skb_tail_pointer(skb) - len;
+        skb_trim(skb, skb->len - len);
+        memcpy(data, from, len);
+        return 0;
+}
+EXPORT_SYMBOL(cfpkt_extr_trail);
+
+int cfpkt_pad_trail(struct cfpkt *pkt, u16 len)
+{
+        return cfpkt_add_body(pkt, NULL, len);
+}
+EXPORT_SYMBOL(cfpkt_pad_trail);
+
+int cfpkt_add_body(struct cfpkt *pkt, const void *data, u16 len)
+{
+        struct sk_buff *skb = pkt_to_skb(pkt);
+        struct sk_buff *lastskb;
+        u8 *to;
+        u16 addlen = 0;
+
+
+        if (unlikely(is_erronous(pkt)))
+                return -EPROTO;
+
+        lastskb = skb;
+
+        /* Check whether we need to add space at the tail */
+        if (unlikely(skb_tailroom(skb) < len)) {
+                if (likely(len < PKT_LEN_WHEN_EXTENDING))
+                        addlen = PKT_LEN_WHEN_EXTENDING;
+                else
+                        addlen = len;
+        }
+
+        /* Check whether we need to change the SKB before writing to the tail */
+        if (unlikely((addlen > 0) || skb_cloned(skb) || skb_shared(skb))) {
+
+                /* Make sure data is writable */
+                if (unlikely(skb_cow_data(skb, addlen, &lastskb) < 0)) {
+                        PKT_ERROR(pkt, "cfpkt_add_body: cow failed\n");
+                        return -EPROTO;
+                }
+                /*
+                 * Is the SKB non-linear after skb_cow_data()? If so, we are
+                 * going to add data to the last SKB, so we need to adjust
+                 * lengths of the top SKB.
+                 */
+                if (lastskb != skb) {
+                        pr_warning("CAIF: %s(): Packet is non-linear\n",
+                                   __func__);
+                        skb->len += len;
+                        skb->data_len += len;
+                }
+        }
+
+        /* All set to put the last SKB and optionally write data there. */
+        to = skb_put(lastskb, len);
+        if (likely(data))
+                memcpy(to, data, len);
+        return 0;
+}
+EXPORT_SYMBOL(cfpkt_add_body);
+
+inline int cfpkt_addbdy(struct cfpkt *pkt, u8 data)
+{
+        return cfpkt_add_body(pkt, &data, 1);
+}
+EXPORT_SYMBOL(cfpkt_addbdy);
+
+int cfpkt_add_head(struct cfpkt *pkt, const void *data2, u16 len)
+{
+        struct sk_buff *skb = pkt_to_skb(pkt);
+        struct sk_buff *lastskb;
+        u8 *to;
+        const u8 *data = data2;
+        if (unlikely(is_erronous(pkt)))
+                return -EPROTO;
+        if (unlikely(skb_headroom(skb) < len)) {
+                PKT_ERROR(pkt, "cfpkt_add_head: no headroom\n");
+                return -EPROTO;
+        }
+
+        /* Make sure data is writable */
+        if (unlikely(skb_cow_data(skb, 0, &lastskb) < 0)) {
+                PKT_ERROR(pkt, "cfpkt_add_head: cow failed\n");
+                return -EPROTO;
+        }
+
+        to = skb_push(skb, len);
+        memcpy(to, data, len);
+        return 0;
+}
+EXPORT_SYMBOL(cfpkt_add_head);
+
+inline int cfpkt_add_trail(struct cfpkt *pkt, const void *data, u16 len)
+{
+        return cfpkt_add_body(pkt, data, len);
+}
+EXPORT_SYMBOL(cfpkt_add_trail);
+
+inline u16 cfpkt_getlen(struct cfpkt *pkt)
+{
+        struct sk_buff *skb = pkt_to_skb(pkt);
+        return skb->len;
+}
+EXPORT_SYMBOL(cfpkt_getlen);
+
+inline u16 cfpkt_iterate(struct cfpkt *pkt,
+                            u16 (*iter_func)(u16, void *, u16),
+                            u16 data)
+{
+        /*
+         * Don't care about the performance hit of linearizing,
+         * Checksum should not be used on high-speed interfaces anyway.
+         */
+        if (unlikely(is_erronous(pkt)))
+                return -EPROTO;
+        if (unlikely(skb_linearize(&pkt->skb) != 0)) {
+                PKT_ERROR(pkt, "cfpkt_iterate: linearize failed\n");
+                return -EPROTO;
+        }
+        return iter_func(data, pkt->skb.data, cfpkt_getlen(pkt));
+}
+EXPORT_SYMBOL(cfpkt_iterate);
+
+int cfpkt_setlen(struct cfpkt *pkt, u16 len)
+{
+        struct sk_buff *skb = pkt_to_skb(pkt);
+
+
+        if (unlikely(is_erronous(pkt)))
+                return -EPROTO;
+
+        if (likely(len <= skb->len)) {
+                if (unlikely(skb->data_len))
+                        ___pskb_trim(skb, len);
+                else
+                        skb_trim(skb, len);
+
+                        return cfpkt_getlen(pkt);
+        }
+
+        /* Need to expand SKB */
+        if (unlikely(!cfpkt_pad_trail(pkt, len - skb->len)))
+                PKT_ERROR(pkt, "cfpkt_setlen: skb_pad_trail failed\n");
+
+        return cfpkt_getlen(pkt);
+}
+EXPORT_SYMBOL(cfpkt_setlen);
+
+struct cfpkt *cfpkt_create_uplink(const unsigned char *data, unsigned int len)
+{
+        struct cfpkt *pkt = cfpkt_create_pfx(len + PKT_POSTFIX, PKT_PREFIX);
+        if (unlikely(data != NULL))
+                cfpkt_add_body(pkt, data, len);
+        return pkt;
+}
+EXPORT_SYMBOL(cfpkt_create_uplink);
+
+struct cfpkt *cfpkt_append(struct cfpkt *dstpkt,
+                             struct cfpkt *addpkt,
+                             u16 expectlen)
+{
+        struct sk_buff *dst = pkt_to_skb(dstpkt);
+        struct sk_buff *add = pkt_to_skb(addpkt);
+        u16 addlen = skb_headlen(add);
+        u16 neededtailspace;
+        struct sk_buff *tmp;
+        u16 dstlen;
+        u16 createlen;
+        if (unlikely(is_erronous(dstpkt) || is_erronous(addpkt))) {
+                cfpkt_destroy(addpkt);
+                return dstpkt;
+        }
+        if (expectlen > addlen)
+                neededtailspace = expectlen;
+        else
+                neededtailspace = addlen;
+
+        if (dst->tail + neededtailspace > dst->end) {
+                /* Create a dumplicate of 'dst' with more tail space */
+                dstlen = skb_headlen(dst);
+                createlen = dstlen + neededtailspace;
+                tmp = pkt_to_skb(
+                        cfpkt_create(createlen + PKT_PREFIX + PKT_POSTFIX));
+                if (!tmp)
+                        return NULL;
+                skb_set_tail_pointer(tmp, dstlen);
+                tmp->len = dstlen;
+                memcpy(tmp->data, dst->data, dstlen);
+                cfpkt_destroy(dstpkt);
+                dst = tmp;
+        }
+        memcpy(skb_tail_pointer(dst), add->data, skb_headlen(add));
+        cfpkt_destroy(addpkt);
+        dst->tail += addlen;
+        dst->len += addlen;
+        return skb_to_pkt(dst);
+}
+EXPORT_SYMBOL(cfpkt_append);
+
+struct cfpkt *cfpkt_split(struct cfpkt *pkt, u16 pos)
+{
+        struct sk_buff *skb2;
+        struct sk_buff *skb = pkt_to_skb(pkt);
+        u8 *split = skb->data + pos;
+        u16 len2nd = skb_tail_pointer(skb) - split;
+
+        if (unlikely(is_erronous(pkt)))
+                return NULL;
+
+        if (skb->data + pos > skb_tail_pointer(skb)) {
+                PKT_ERROR(pkt,
+                          "cfpkt_split: trying to split beyond end of packet");
+                return NULL;
+        }
+
+        /* Create a new packet for the second part of the data */
+        skb2 = pkt_to_skb(
+                cfpkt_create_pfx(len2nd + PKT_PREFIX + PKT_POSTFIX,
+                                 PKT_PREFIX));
+
+        if (skb2 == NULL)
+                return NULL;
+
+        /* Reduce the length of the original packet */
+        skb_set_tail_pointer(skb, pos);
+        skb->len = pos;
+
+        memcpy(skb2->data, split, len2nd);
+        skb2->tail += len2nd;
+        skb2->len += len2nd;
+        return skb_to_pkt(skb2);
+}
+EXPORT_SYMBOL(cfpkt_split);
+
+char *cfpkt_log_pkt(struct cfpkt *pkt, char *buf, int buflen)
+{
+        struct sk_buff *skb = pkt_to_skb(pkt);
+        char *p = buf;
+        int i;
+
+        /*
+         * Sanity check buffer length, it needs to be at least as large as
+         * the header info: ~=50+ bytes
+         */
+        if (buflen < 50)
+                return NULL;
+
+        snprintf(buf, buflen, "%s: pkt:%p len:%ld(%ld+%ld) {%ld,%ld} data: [",
+                is_erronous(pkt) ? "ERRONOUS-SKB" :
+                 (skb->data_len != 0 ? "COMPLEX-SKB" : "SKB"),
+                 skb,
+                 (long) skb->len,
+                 (long) (skb_tail_pointer(skb) - skb->data),
+                 (long) skb->data_len,
+                 (long) (skb->data - skb->head),
+                 (long) (skb_tail_pointer(skb) - skb->head));
+        p = buf + strlen(buf);
+
+        for (i = 0; i < skb_tail_pointer(skb) - skb->data && i < 300; i++) {
+                if (p > buf + buflen - 10) {
+                        sprintf(p, "...");
+                        p = buf + strlen(buf);
+                        break;
+                }
+                sprintf(p, "%02x,", skb->data[i]);
+                p = buf + strlen(buf);
+        }
+        sprintf(p, "]\n");
+        return buf;
+}
+EXPORT_SYMBOL(cfpkt_log_pkt);
+
+int cfpkt_raw_append(struct cfpkt *pkt, void **buf, unsigned int buflen)
+{
+        struct sk_buff *skb = pkt_to_skb(pkt);
+        struct sk_buff *lastskb;
+
+        caif_assert(buf != NULL);
+        if (unlikely(is_erronous(pkt)))
+                return -EPROTO;
+        /* Make sure SKB is writable */
+        if (unlikely(skb_cow_data(skb, 0, &lastskb) < 0)) {
+                PKT_ERROR(pkt, "cfpkt_raw_append: skb_cow_data failed\n");
+                return -EPROTO;
+        }
+
+        if (unlikely(skb_linearize(skb) != 0)) {
+                PKT_ERROR(pkt, "cfpkt_raw_append: linearize failed\n");
+                return -EPROTO;
+        }
+
+        if (unlikely(skb_tailroom(skb) < buflen)) {
+                PKT_ERROR(pkt, "cfpkt_raw_append: buffer too short - failed\n");
+                return -EPROTO;
+        }
+
+        *buf = skb_put(skb, buflen);
+        return 1;
+}
+EXPORT_SYMBOL(cfpkt_raw_append);
+
+int cfpkt_raw_extract(struct cfpkt *pkt, void **buf, unsigned int buflen)
+{
+        struct sk_buff *skb = pkt_to_skb(pkt);
+
+        caif_assert(buf != NULL);
+        if (unlikely(is_erronous(pkt)))
+                return -EPROTO;
+
+        if (unlikely(buflen > skb->len)) {
+                PKT_ERROR(pkt, "cfpkt_raw_extract: buflen too large "
+                                "- failed\n");
+                return -EPROTO;
+        }
+
+        if (unlikely(buflen > skb_headlen(skb))) {
+                if (unlikely(skb_linearize(skb) != 0)) {
+                        PKT_ERROR(pkt, "cfpkt_raw_extract: linearize failed\n");
+                        return -EPROTO;
+                }
+        }
+
+        *buf = skb->data;
+        skb_pull(skb, buflen);
+
+        return 1;
+}
+EXPORT_SYMBOL(cfpkt_raw_extract);
+
+inline bool cfpkt_erroneous(struct cfpkt *pkt)
+{
+        return cfpkt_priv(pkt)->erronous;
+}
+EXPORT_SYMBOL(cfpkt_erroneous);
+
+struct cfpktq *cfpktq_create(void)
+{
+        struct cfpktq *q = kmalloc(sizeof(struct cfpktq), GFP_ATOMIC);
+        if (!q)
+                return NULL;
+        skb_queue_head_init(&q->head);
+        atomic_set(&q->count, 0);
+        spin_lock_init(&q->lock);
+        return q;
+}
+EXPORT_SYMBOL(cfpktq_create);
+
+void cfpkt_queue(struct cfpktq *pktq, struct cfpkt *pkt, unsigned short prio)
+{
+        atomic_inc(&pktq->count);
+        spin_lock(&pktq->lock);
+        skb_queue_tail(&pktq->head, pkt_to_skb(pkt));
+        spin_unlock(&pktq->lock);
+
+}
+EXPORT_SYMBOL(cfpkt_queue);
+
+struct cfpkt *cfpkt_qpeek(struct cfpktq *pktq)
+{
+        struct cfpkt *tmp;
+        spin_lock(&pktq->lock);
+        tmp = skb_to_pkt(skb_peek(&pktq->head));
+        spin_unlock(&pktq->lock);
+        return tmp;
+}
+EXPORT_SYMBOL(cfpkt_qpeek);
+
+struct cfpkt *cfpkt_dequeue(struct cfpktq *pktq)
+{
+        struct cfpkt *pkt;
+        spin_lock(&pktq->lock);
+        pkt = skb_to_pkt(skb_dequeue(&pktq->head));
+        if (pkt) {
+                atomic_dec(&pktq->count);
+                caif_assert(atomic_read(&pktq->count) >= 0);
+        }
+        spin_unlock(&pktq->lock);
+        return pkt;
+}
+EXPORT_SYMBOL(cfpkt_dequeue);
+
+int cfpkt_qcount(struct cfpktq *pktq)
+{
+        return atomic_read(&pktq->count);
+}
+EXPORT_SYMBOL(cfpkt_qcount);
+
+struct cfpkt *cfpkt_clone_release(struct cfpkt *pkt)
+{
+        struct cfpkt *clone;
+        clone  = skb_to_pkt(skb_clone(pkt_to_skb(pkt), GFP_ATOMIC));
+        /* Free original packet. */
+        cfpkt_destroy(pkt);
+        if (!clone)
+                return NULL;
+        return clone;
+}
+EXPORT_SYMBOL(cfpkt_clone_release);
+
+struct caif_payload_info *cfpkt_info(struct cfpkt *pkt)
+{
+        return (struct caif_payload_info *)&pkt_to_skb(pkt)->cb;
+}
+EXPORT_SYMBOL(cfpkt_info);
diff --git a/net/caif/cfrfml.c b/net/caif/cfrfml.c
new file mode 100644
index 000000000000..cd2830fec935
--- /dev/null
+++ b/net/caif/cfrfml.c
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) ST-Ericsson AB 2010
+ * Author:      Sjur Brendeland/sjur.brandeland@stericsson.com
+ * License terms: GNU General Public License (GPL) version 2
+ */
+
+#include <linux/stddef.h>
+#include <linux/spinlock.h>
+#include <linux/slab.h>
+#include <net/caif/caif_layer.h>
+#include <net/caif/cfsrvl.h>
+#include <net/caif/cfpkt.h>
+
+#define container_obj(layr) container_of(layr, struct cfsrvl, layer)
+
+#define RFM_SEGMENTATION_BIT 0x01
+#define RFM_PAYLOAD  0x00
+#define RFM_CMD_BIT  0x80
+#define RFM_FLOW_OFF 0x81
+#define RFM_FLOW_ON  0x80
+#define RFM_SET_PIN  0x82
+#define RFM_CTRL_PKT_SIZE 1
+
+static int cfrfml_receive(struct cflayer *layr, struct cfpkt *pkt);
+static int cfrfml_transmit(struct cflayer *layr, struct cfpkt *pkt);
+static int cfservl_modemcmd(struct cflayer *layr, enum caif_modemcmd ctrl);
+
+struct cflayer *cfrfml_create(u8 channel_id, struct dev_info *dev_info)
+{
+        struct cfsrvl *rfm = kmalloc(sizeof(struct cfsrvl), GFP_ATOMIC);
+        if (!rfm) {
+                pr_warning("CAIF: %s(): Out of memory\n", __func__);
+                return NULL;
+        }
+        caif_assert(offsetof(struct cfsrvl, layer) == 0);
+        memset(rfm, 0, sizeof(struct cfsrvl));
+        cfsrvl_init(rfm, channel_id, dev_info);
+        rfm->layer.modemcmd = cfservl_modemcmd;
+        rfm->layer.receive = cfrfml_receive;
+        rfm->layer.transmit = cfrfml_transmit;
+        snprintf(rfm->layer.name, CAIF_LAYER_NAME_SZ, "rfm%d", channel_id);
+        return &rfm->layer;
+}
+
+static int cfservl_modemcmd(struct cflayer *layr, enum caif_modemcmd ctrl)
+{
+       return -EPROTO;
+}
+
+static int cfrfml_receive(struct cflayer *layr, struct cfpkt *pkt)
+{
+        u8 tmp;
+        bool segmented;
+        int ret;
+        caif_assert(layr->up != NULL);
+        caif_assert(layr->receive != NULL);
+
+        /*
+         * RFM is taking care of segmentation and stripping of
+         * segmentation bit.
+         */
+        if (cfpkt_extr_head(pkt, &tmp, 1) < 0) {
+                pr_err("CAIF: %s(): Packet is erroneous!\n", __func__);
+                cfpkt_destroy(pkt);
+                return -EPROTO;
+        }
+        segmented = tmp & RFM_SEGMENTATION_BIT;
+        caif_assert(!segmented);
+
+        ret = layr->up->receive(layr->up, pkt);
+        return ret;
+}
+
+static int cfrfml_transmit(struct cflayer *layr, struct cfpkt *pkt)
+{
+        u8 tmp = 0;
+        int ret;
+        struct cfsrvl *service = container_obj(layr);
+
+        caif_assert(layr->dn != NULL);
+        caif_assert(layr->dn->transmit != NULL);
+
+        if (!cfsrvl_ready(service, &ret))
+                return ret;
+
+        if (!cfpkt_getlen(pkt) > CAIF_MAX_PAYLOAD_SIZE) {
+                pr_err("CAIF: %s():Packet too large - size=%d\n",
+                        __func__, cfpkt_getlen(pkt));
+                return -EOVERFLOW;
+        }
+        if (cfpkt_add_head(pkt, &tmp, 1) < 0) {
+                pr_err("CAIF: %s(): Packet is erroneous!\n", __func__);
+                return -EPROTO;
+        }
+
+        /* Add info for MUX-layer to route the packet out. */
+        cfpkt_info(pkt)->channel_id = service->layer.id;
+        /*
+         * To optimize alignment, we add up the size of CAIF header before
+         * payload.
+         */
+        cfpkt_info(pkt)->hdr_len = 1;
+        cfpkt_info(pkt)->dev_info = &service->dev_info;
+        ret = layr->dn->transmit(layr->dn, pkt);
+        if (ret < 0)
+                cfpkt_extr_head(pkt, &tmp, 1);
+        return ret;
+}
diff --git a/net/caif/cfserl.c b/net/caif/cfserl.c
new file mode 100644
index 000000000000..06029ea2da2f
--- /dev/null
+++ b/net/caif/cfserl.c
@@ -0,0 +1,192 @@
+/*
+ * Copyright (C) ST-Ericsson AB 2010
+ * Author:      Sjur Brendeland/sjur.brandeland@stericsson.com
+ * License terms: GNU General Public License (GPL) version 2
+ */
+
+#include <linux/stddef.h>
+#include <linux/spinlock.h>
+#include <linux/slab.h>
+#include <net/caif/caif_layer.h>
+#include <net/caif/cfpkt.h>
+#include <net/caif/cfserl.h>
+
+#define container_obj(layr) ((struct cfserl *) layr)
+
+#define CFSERL_STX 0x02
+#define CAIF_MINIUM_PACKET_SIZE 4
+struct cfserl {
+        struct cflayer layer;
+        struct cfpkt *incomplete_frm;
+        /* Protects parallel processing of incoming packets */
+        spinlock_t sync;
+        bool usestx;
+};
+#define STXLEN(layr) (layr->usestx ? 1 : 0)
+
+static int cfserl_receive(struct cflayer *layr, struct cfpkt *pkt);
+static int cfserl_transmit(struct cflayer *layr, struct cfpkt *pkt);
+static void cfserl_ctrlcmd(struct cflayer *layr, enum caif_ctrlcmd ctrl,
+                                int phyid);
+
+struct cflayer *cfserl_create(int type, int instance, bool use_stx)
+{
+        struct cfserl *this = kmalloc(sizeof(struct cfserl), GFP_ATOMIC);
+        if (!this) {
+                pr_warning("CAIF: %s(): Out of memory\n", __func__);
+                return NULL;
+        }
+        caif_assert(offsetof(struct cfserl, layer) == 0);
+        memset(this, 0, sizeof(struct cfserl));
+        this->layer.receive = cfserl_receive;
+        this->layer.transmit = cfserl_transmit;
+        this->layer.ctrlcmd = cfserl_ctrlcmd;
+        this->layer.type = type;
+        this->usestx = use_stx;
+        spin_lock_init(&this->sync);
+        snprintf(this->layer.name, CAIF_LAYER_NAME_SZ, "ser1");
+        return &this->layer;
+}
+
+static int cfserl_receive(struct cflayer *l, struct cfpkt *newpkt)
+{
+        struct cfserl *layr = container_obj(l);
+        u16 pkt_len;
+        struct cfpkt *pkt = NULL;
+        struct cfpkt *tail_pkt = NULL;
+        u8 tmp8;
+        u16 tmp;
+        u8 stx = CFSERL_STX;
+        int ret;
+        u16 expectlen = 0;
+        caif_assert(newpkt != NULL);
+        spin_lock(&layr->sync);
+
+        if (layr->incomplete_frm != NULL) {
+
+                layr->incomplete_frm =
+                    cfpkt_append(layr->incomplete_frm, newpkt, expectlen);
+                pkt = layr->incomplete_frm;
+        } else {
+                pkt = newpkt;
+        }
+        layr->incomplete_frm = NULL;
+
+        do {
+                /* Search for STX at start of pkt if STX is used */
+                if (layr->usestx) {
+                        cfpkt_extr_head(pkt, &tmp8, 1);
+                        if (tmp8 != CFSERL_STX) {
+                                while (cfpkt_more(pkt)
+                                       && tmp8 != CFSERL_STX) {
+                                        cfpkt_extr_head(pkt, &tmp8, 1);
+                                }
+                                if (!cfpkt_more(pkt)) {
+                                        cfpkt_destroy(pkt);
+                                        layr->incomplete_frm = NULL;
+                                        spin_unlock(&layr->sync);
+                                        return -EPROTO;
+                                }
+                        }
+                }
+
+                pkt_len = cfpkt_getlen(pkt);
+
+                /*
+                 *  pkt_len is the accumulated length of the packet data
+                 *  we have received so far.
+                 *  Exit if frame doesn't hold length.
+                 */
+
+                if (pkt_len < 2) {
+                        if (layr->usestx)
+                                cfpkt_add_head(pkt, &stx, 1);
+                        layr->incomplete_frm = pkt;
+                        spin_unlock(&layr->sync);
+                        return 0;
+                }
+
+                /*
+                 *  Find length of frame.
+                 *  expectlen is the length we need for a full frame.
+                 */
+                cfpkt_peek_head(pkt, &tmp, 2);
+                expectlen = le16_to_cpu(tmp) + 2;
+                /*
+                 * Frame error handling
+                 */
+                if (expectlen < CAIF_MINIUM_PACKET_SIZE
+                    || expectlen > CAIF_MAX_FRAMESIZE) {
+                        if (!layr->usestx) {
+                                if (pkt != NULL)
+                                        cfpkt_destroy(pkt);
+                                layr->incomplete_frm = NULL;
+                                expectlen = 0;
+                                spin_unlock(&layr->sync);
+                                return -EPROTO;
+                        }
+                        continue;
+                }
+
+                if (pkt_len < expectlen) {
+                        /* Too little received data */
+                        if (layr->usestx)
+                                cfpkt_add_head(pkt, &stx, 1);
+                        layr->incomplete_frm = pkt;
+                        spin_unlock(&layr->sync);
+                        return 0;
+                }
+
+                /*
+                 * Enough data for at least one frame.
+                 * Split the frame, if too long
+                 */
+                if (pkt_len > expectlen)
+                        tail_pkt = cfpkt_split(pkt, expectlen);
+                else
+                        tail_pkt = NULL;
+
+                /* Send the first part of packet upwards.*/
+                spin_unlock(&layr->sync);
+                ret = layr->layer.up->receive(layr->layer.up, pkt);
+                spin_lock(&layr->sync);
+                if (ret == -EILSEQ) {
+                        if (layr->usestx) {
+                                if (tail_pkt != NULL)
+                                        pkt = cfpkt_append(pkt, tail_pkt, 0);
+
+                                /* Start search for next STX if frame failed */
+                                continue;
+                        } else {
+                                cfpkt_destroy(pkt);
+                                pkt = NULL;
+                        }
+                }
+
+                pkt = tail_pkt;
+
+        } while (pkt != NULL);
+
+        spin_unlock(&layr->sync);
+        return 0;
+}
+
+static int cfserl_transmit(struct cflayer *layer, struct cfpkt *newpkt)
+{
+        struct cfserl *layr = container_obj(layer);
+        int ret;
+        u8 tmp8 = CFSERL_STX;
+        if (layr->usestx)
+                cfpkt_add_head(newpkt, &tmp8, 1);
+        ret = layer->dn->transmit(layer->dn, newpkt);
+        if (ret < 0)
+                cfpkt_extr_head(newpkt, &tmp8, 1);
+
+        return ret;
+}
+
+static void cfserl_ctrlcmd(struct cflayer *layr, enum caif_ctrlcmd ctrl,
+                                int phyid)
+{
+        layr->up->ctrlcmd(layr->up, ctrl, phyid);
+}
diff --git a/net/caif/cfsrvl.c b/net/caif/cfsrvl.c
new file mode 100644
index 000000000000..aff31f34528f
--- /dev/null
+++ b/net/caif/cfsrvl.c
@@ -0,0 +1,192 @@
+/*
+ * Copyright (C) ST-Ericsson AB 2010
+ * Author:      Sjur Brendeland/sjur.brandeland@stericsson.com
+ * License terms: GNU General Public License (GPL) version 2
+ */
+
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/errno.h>
+#include <linux/slab.h>
+#include <net/caif/caif_layer.h>
+#include <net/caif/cfsrvl.h>
+#include <net/caif/cfpkt.h>
+
+#define SRVL_CTRL_PKT_SIZE 1
+#define SRVL_FLOW_OFF 0x81
+#define SRVL_FLOW_ON  0x80
+#define SRVL_SET_PIN  0x82
+#define SRVL_CTRL_PKT_SIZE 1
+
+#define container_obj(layr) container_of(layr, struct cfsrvl, layer)
+
+static void cfservl_ctrlcmd(struct cflayer *layr, enum caif_ctrlcmd ctrl,
+                                int phyid)
+{
+        struct cfsrvl *service = container_obj(layr);
+        caif_assert(layr->up != NULL);
+        caif_assert(layr->up->ctrlcmd != NULL);
+        switch (ctrl) {
+        case CAIF_CTRLCMD_INIT_RSP:
+                service->open = true;
+                layr->up->ctrlcmd(layr->up, ctrl, phyid);
+                break;
+        case CAIF_CTRLCMD_DEINIT_RSP:
+        case CAIF_CTRLCMD_INIT_FAIL_RSP:
+                service->open = false;
+                layr->up->ctrlcmd(layr->up, ctrl, phyid);
+                break;
+        case _CAIF_CTRLCMD_PHYIF_FLOW_OFF_IND:
+                if (phyid != service->dev_info.id)
+                        break;
+                if (service->modem_flow_on)
+                        layr->up->ctrlcmd(layr->up,
+                                          CAIF_CTRLCMD_FLOW_OFF_IND, phyid);
+                service->phy_flow_on = false;
+                break;
+        case _CAIF_CTRLCMD_PHYIF_FLOW_ON_IND:
+                if (phyid != service->dev_info.id)
+                        return;
+                if (service->modem_flow_on) {
+                        layr->up->ctrlcmd(layr->up,
+                                           CAIF_CTRLCMD_FLOW_ON_IND,
+                                           phyid);
+                }
+                service->phy_flow_on = true;
+                break;
+        case CAIF_CTRLCMD_FLOW_OFF_IND:
+                if (service->phy_flow_on) {
+                        layr->up->ctrlcmd(layr->up,
+                                          CAIF_CTRLCMD_FLOW_OFF_IND, phyid);
+                }
+                service->modem_flow_on = false;
+                break;
+        case CAIF_CTRLCMD_FLOW_ON_IND:
+                if (service->phy_flow_on) {
+                        layr->up->ctrlcmd(layr->up,
+                                          CAIF_CTRLCMD_FLOW_ON_IND, phyid);
+                }
+                service->modem_flow_on = true;
+                break;
+        case _CAIF_CTRLCMD_PHYIF_DOWN_IND:
+                /* In case interface is down, let's fake a remove shutdown */
+                layr->up->ctrlcmd(layr->up,
+                                CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND, phyid);
+                break;
+        case CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND:
+                layr->up->ctrlcmd(layr->up, ctrl, phyid);
+                break;
+        default:
+                pr_warning("CAIF: %s(): "
+                           "Unexpected ctrl in cfsrvl (%d)\n", __func__, ctrl);
+                /* We have both modem and phy flow on, send flow on */
+                layr->up->ctrlcmd(layr->up, ctrl, phyid);
+                service->phy_flow_on = true;
+                break;
+        }
+}
+
+static int cfservl_modemcmd(struct cflayer *layr, enum caif_modemcmd ctrl)
+{
+        struct cfsrvl *service = container_obj(layr);
+        caif_assert(layr != NULL);
+        caif_assert(layr->dn != NULL);
+        caif_assert(layr->dn->transmit != NULL);
+        switch (ctrl) {
+        case CAIF_MODEMCMD_FLOW_ON_REQ:
+                {
+                        struct cfpkt *pkt;
+                        struct caif_payload_info *info;
+                        u8 flow_on = SRVL_FLOW_ON;
+                        pkt = cfpkt_create(SRVL_CTRL_PKT_SIZE);
+                        if (!pkt) {
+                                pr_warning("CAIF: %s(): Out of memory\n",
+                                        __func__);
+                                return -ENOMEM;
+                        }
+
+                        if (cfpkt_add_head(pkt, &flow_on, 1) < 0) {
+                                pr_err("CAIF: %s(): Packet is erroneous!\n",
+                                        __func__);
+                                cfpkt_destroy(pkt);
+                                return -EPROTO;
+                        }
+                        info = cfpkt_info(pkt);
+                        info->channel_id = service->layer.id;
+                        info->hdr_len = 1;
+                        info->dev_info = &service->dev_info;
+                        return layr->dn->transmit(layr->dn, pkt);
+                }
+        case CAIF_MODEMCMD_FLOW_OFF_REQ:
+                {
+                        struct cfpkt *pkt;
+                        struct caif_payload_info *info;
+                        u8 flow_off = SRVL_FLOW_OFF;
+                        pkt = cfpkt_create(SRVL_CTRL_PKT_SIZE);
+                        if (cfpkt_add_head(pkt, &flow_off, 1) < 0) {
+                                pr_err("CAIF: %s(): Packet is erroneous!\n",
+                                        __func__);
+                                cfpkt_destroy(pkt);
+                                return -EPROTO;
+                        }
+                        info = cfpkt_info(pkt);
+                        info->channel_id = service->layer.id;
+                        info->hdr_len = 1;
+                        info->dev_info = &service->dev_info;
+                        return layr->dn->transmit(layr->dn, pkt);
+                }
+        default:
+          break;
+        }
+        return -EINVAL;
+}
+
+void cfservl_destroy(struct cflayer *layer)
+{
+        kfree(layer);
+}
+
+void cfsrvl_init(struct cfsrvl *service,
+                 u8 channel_id,
+                 struct dev_info *dev_info)
+{
+        caif_assert(offsetof(struct cfsrvl, layer) == 0);
+        service->open = false;
+        service->modem_flow_on = true;
+        service->phy_flow_on = true;
+        service->layer.id = channel_id;
+        service->layer.ctrlcmd = cfservl_ctrlcmd;
+        service->layer.modemcmd = cfservl_modemcmd;
+        service->dev_info = *dev_info;
+        kref_init(&service->ref);
+}
+
+void cfsrvl_release(struct kref *kref)
+{
+        struct cfsrvl *service = container_of(kref, struct cfsrvl, ref);
+        kfree(service);
+}
+
+bool cfsrvl_ready(struct cfsrvl *service, int *err)
+{
+        if (service->open && service->modem_flow_on && service->phy_flow_on)
+                return true;
+        if (!service->open) {
+                *err = -ENOTCONN;
+                return false;
+        }
+        caif_assert(!(service->modem_flow_on && service->phy_flow_on));
+        *err = -EAGAIN;
+        return false;
+}
+u8 cfsrvl_getphyid(struct cflayer *layer)
+{
+        struct cfsrvl *servl = container_obj(layer);
+        return servl->dev_info.id;
+}
+
+bool cfsrvl_phyid_match(struct cflayer *layer, int phyid)
+{
+        struct cfsrvl *servl = container_obj(layer);
+        return servl->dev_info.id == phyid;
+}
diff --git a/net/caif/cfutill.c b/net/caif/cfutill.c
new file mode 100644
index 000000000000..5fd2c9ea8b42
--- /dev/null
+++ b/net/caif/cfutill.c
@@ -0,0 +1,115 @@
+/*
+ * Copyright (C) ST-Ericsson AB 2010
+ * Author:      Sjur Brendeland/sjur.brandeland@stericsson.com
+ * License terms: GNU General Public License (GPL) version 2
+ */
+
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/slab.h>
+#include <linux/errno.h>
+#include <net/caif/caif_layer.h>
+#include <net/caif/cfsrvl.h>
+#include <net/caif/cfpkt.h>
+
+#define container_obj(layr) ((struct cfsrvl *) layr)
+#define UTIL_PAYLOAD  0x00
+#define UTIL_CMD_BIT  0x80
+#define UTIL_REMOTE_SHUTDOWN 0x82
+#define UTIL_FLOW_OFF 0x81
+#define UTIL_FLOW_ON  0x80
+#define UTIL_CTRL_PKT_SIZE 1
+static int cfutill_receive(struct cflayer *layr, struct cfpkt *pkt);
+static int cfutill_transmit(struct cflayer *layr, struct cfpkt *pkt);
+
+struct cflayer *cfutill_create(u8 channel_id, struct dev_info *dev_info)
+{
+        struct cfsrvl *util = kmalloc(sizeof(struct cfsrvl), GFP_ATOMIC);
+        if (!util) {
+                pr_warning("CAIF: %s(): Out of memory\n", __func__);
+                return NULL;
+        }
+        caif_assert(offsetof(struct cfsrvl, layer) == 0);
+        memset(util, 0, sizeof(struct cfsrvl));
+        cfsrvl_init(util, channel_id, dev_info);
+        util->layer.receive = cfutill_receive;
+        util->layer.transmit = cfutill_transmit;
+        snprintf(util->layer.name, CAIF_LAYER_NAME_SZ - 1, "util1");
+        return &util->layer;
+}
+
+static int cfutill_receive(struct cflayer *layr, struct cfpkt *pkt)
+{
+        u8 cmd = -1;
+        struct cfsrvl *service = container_obj(layr);
+        caif_assert(layr != NULL);
+        caif_assert(layr->up != NULL);
+        caif_assert(layr->up->receive != NULL);
+        caif_assert(layr->up->ctrlcmd != NULL);
+        if (cfpkt_extr_head(pkt, &cmd, 1) < 0) {
+                pr_err("CAIF: %s(): Packet is erroneous!\n", __func__);
+                cfpkt_destroy(pkt);
+                return -EPROTO;
+        }
+
+        switch (cmd) {
+        case UTIL_PAYLOAD:
+                return layr->up->receive(layr->up, pkt);
+        case UTIL_FLOW_OFF:
+                layr->ctrlcmd(layr, CAIF_CTRLCMD_FLOW_OFF_IND, 0);
+                cfpkt_destroy(pkt);
+                return 0;
+        case UTIL_FLOW_ON:
+                layr->ctrlcmd(layr, CAIF_CTRLCMD_FLOW_ON_IND, 0);
+                cfpkt_destroy(pkt);
+                return 0;
+        case UTIL_REMOTE_SHUTDOWN:      /* Remote Shutdown Request */
+                pr_err("CAIF: %s(): REMOTE SHUTDOWN REQUEST RECEIVED\n",
+                        __func__);
+                layr->ctrlcmd(layr, CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND, 0);
+                service->open = false;
+                cfpkt_destroy(pkt);
+                return 0;
+        default:
+                cfpkt_destroy(pkt);
+                pr_warning("CAIF: %s(): Unknown service control %d (0x%x)\n",
+                           __func__, cmd, cmd);
+                return -EPROTO;
+        }
+}
+
+static int cfutill_transmit(struct cflayer *layr, struct cfpkt *pkt)
+{
+        u8 zero = 0;
+        struct caif_payload_info *info;
+        int ret;
+        struct cfsrvl *service = container_obj(layr);
+        caif_assert(layr != NULL);
+        caif_assert(layr->dn != NULL);
+        caif_assert(layr->dn->transmit != NULL);
+        if (!cfsrvl_ready(service, &ret))
+                return ret;
+
+        if (cfpkt_getlen(pkt) > CAIF_MAX_PAYLOAD_SIZE) {
+                pr_err("CAIF: %s(): packet too large size=%d\n",
+                        __func__, cfpkt_getlen(pkt));
+                return -EOVERFLOW;
+        }
+
+        cfpkt_add_head(pkt, &zero, 1);
+        /* Add info for MUX-layer to route the packet out. */
+        info = cfpkt_info(pkt);
+        info->channel_id = service->layer.id;
+        /*
+         * To optimize alignment, we add up the size of CAIF header before
+         * payload.
+         */
+        info->hdr_len = 1;
+        info->dev_info = &service->dev_info;
+        ret = layr->dn->transmit(layr->dn, pkt);
+        if (ret < 0) {
+                u32 tmp32;
+                cfpkt_extr_head(pkt, &tmp32, 4);
+        }
+        return ret;
+}
diff --git a/net/caif/cfveil.c b/net/caif/cfveil.c
new file mode 100644
index 000000000000..0fd827f49491
--- /dev/null
+++ b/net/caif/cfveil.c
@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) ST-Ericsson AB 2010
+ * Author:      Sjur Brendeland/sjur.brandeland@stericsson.com
+ * License terms: GNU General Public License (GPL) version 2
+ */
+
+#include <linux/stddef.h>
+#include <linux/slab.h>
+#include <net/caif/caif_layer.h>
+#include <net/caif/cfsrvl.h>
+#include <net/caif/cfpkt.h>
+
+#define VEI_PAYLOAD  0x00
+#define VEI_CMD_BIT  0x80
+#define VEI_FLOW_OFF 0x81
+#define VEI_FLOW_ON  0x80
+#define VEI_SET_PIN  0x82
+#define VEI_CTRL_PKT_SIZE 1
+#define container_obj(layr) container_of(layr, struct cfsrvl, layer)
+
+static int cfvei_receive(struct cflayer *layr, struct cfpkt *pkt);
+static int cfvei_transmit(struct cflayer *layr, struct cfpkt *pkt);
+
+struct cflayer *cfvei_create(u8 channel_id, struct dev_info *dev_info)
+{
+        struct cfsrvl *vei = kmalloc(sizeof(struct cfsrvl), GFP_ATOMIC);
+        if (!vei) {
+                pr_warning("CAIF: %s(): Out of memory\n", __func__);
+                return NULL;
+        }
+        caif_assert(offsetof(struct cfsrvl, layer) == 0);
+        memset(vei, 0, sizeof(struct cfsrvl));
+        cfsrvl_init(vei, channel_id, dev_info);
+        vei->layer.receive = cfvei_receive;
+        vei->layer.transmit = cfvei_transmit;
+        snprintf(vei->layer.name, CAIF_LAYER_NAME_SZ - 1, "vei%d", channel_id);
+        return &vei->layer;
+}
+
+static int cfvei_receive(struct cflayer *layr, struct cfpkt *pkt)
+{
+        u8 cmd;
+        int ret;
+        caif_assert(layr->up != NULL);
+        caif_assert(layr->receive != NULL);
+        caif_assert(layr->ctrlcmd != NULL);
+
+
+        if (cfpkt_extr_head(pkt, &cmd, 1) < 0) {
+                pr_err("CAIF: %s(): Packet is erroneous!\n", __func__);
+                cfpkt_destroy(pkt);
+                return -EPROTO;
+        }
+        switch (cmd) {
+        case VEI_PAYLOAD:
+                ret = layr->up->receive(layr->up, pkt);
+                return ret;
+        case VEI_FLOW_OFF:
+                layr->ctrlcmd(layr, CAIF_CTRLCMD_FLOW_OFF_IND, 0);
+                cfpkt_destroy(pkt);
+                return 0;
+        case VEI_FLOW_ON:
+                layr->ctrlcmd(layr, CAIF_CTRLCMD_FLOW_ON_IND, 0);
+                cfpkt_destroy(pkt);
+                return 0;
+        case VEI_SET_PIN:       /* SET RS232 PIN */
+                cfpkt_destroy(pkt);
+                return 0;
+        default:                /* SET RS232 PIN */
+                pr_warning("CAIF: %s():Unknown VEI control packet %d (0x%x)!\n",
+                           __func__, cmd, cmd);
+                cfpkt_destroy(pkt);
+                return -EPROTO;
+        }
+}
+
+static int cfvei_transmit(struct cflayer *layr, struct cfpkt *pkt)
+{
+        u8 tmp = 0;
+        struct caif_payload_info *info;
+        int ret;
+        struct cfsrvl *service = container_obj(layr);
+        if (!cfsrvl_ready(service, &ret))
+                return ret;
+        caif_assert(layr->dn != NULL);
+        caif_assert(layr->dn->transmit != NULL);
+        if (!cfpkt_getlen(pkt) > CAIF_MAX_PAYLOAD_SIZE) {
+                pr_warning("CAIF: %s(): Packet too large - size=%d\n",
+                           __func__, cfpkt_getlen(pkt));
+                return -EOVERFLOW;
+        }
+
+        if (cfpkt_add_head(pkt, &tmp, 1) < 0) {
+                pr_err("CAIF: %s(): Packet is erroneous!\n", __func__);
+                return -EPROTO;
+        }
+
+        /* Add info-> for MUX-layer to route the packet out. */
+        info = cfpkt_info(pkt);
+        info->channel_id = service->layer.id;
+        info->hdr_len = 1;
+        info->dev_info = &service->dev_info;
+        ret = layr->dn->transmit(layr->dn, pkt);
+        if (ret < 0)
+                cfpkt_extr_head(pkt, &tmp, 1);
+        return ret;
+}
diff --git a/net/caif/cfvidl.c b/net/caif/cfvidl.c
new file mode 100644
index 000000000000..89ad4ea239f1
--- /dev/null
+++ b/net/caif/cfvidl.c
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) ST-Ericsson AB 2010
+ * Author:      Sjur Brendeland/sjur.brandeland@stericsson.com
+ * License terms: GNU General Public License (GPL) version 2
+ */
+
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/slab.h>
+#include <linux/errno.h>
+#include <net/caif/caif_layer.h>
+#include <net/caif/cfsrvl.h>
+#include <net/caif/cfpkt.h>
+
+#define container_obj(layr) ((struct cfsrvl *) layr)
+
+static int cfvidl_receive(struct cflayer *layr, struct cfpkt *pkt);
+static int cfvidl_transmit(struct cflayer *layr, struct cfpkt *pkt);
+
+struct cflayer *cfvidl_create(u8 channel_id, struct dev_info *dev_info)
+{
+        struct cfsrvl *vid = kmalloc(sizeof(struct cfsrvl), GFP_ATOMIC);
+        if (!vid) {
+                pr_warning("CAIF: %s(): Out of memory\n", __func__);
+                return NULL;
+        }
+        caif_assert(offsetof(struct cfsrvl, layer) == 0);
+
+        memset(vid, 0, sizeof(struct cfsrvl));
+        cfsrvl_init(vid, channel_id, dev_info);
+        vid->layer.receive = cfvidl_receive;
+        vid->layer.transmit = cfvidl_transmit;
+        snprintf(vid->layer.name, CAIF_LAYER_NAME_SZ - 1, "vid1");
+        return &vid->layer;
+}
+
+static int cfvidl_receive(struct cflayer *layr, struct cfpkt *pkt)
+{
+        u32 videoheader;
+        if (cfpkt_extr_head(pkt, &videoheader, 4) < 0) {
+                pr_err("CAIF: %s(): Packet is erroneous!\n", __func__);
+                cfpkt_destroy(pkt);
+                return -EPROTO;
+        }
+        return layr->up->receive(layr->up, pkt);
+}
+
+static int cfvidl_transmit(struct cflayer *layr, struct cfpkt *pkt)
+{
+        struct cfsrvl *service = container_obj(layr);
+        struct caif_payload_info *info;
+        u32 videoheader = 0;
+        int ret;
+        if (!cfsrvl_ready(service, &ret))
+                return ret;
+        cfpkt_add_head(pkt, &videoheader, 4);
+        /* Add info for MUX-layer to route the packet out */
+        info = cfpkt_info(pkt);
+        info->channel_id = service->layer.id;
+        info->dev_info = &service->dev_info;
+        ret = layr->dn->transmit(layr->dn, pkt);
+        if (ret < 0)
+                cfpkt_extr_head(pkt, &videoheader, 4);
+        return ret;
+}
diff --git a/net/caif/chnl_net.c b/net/caif/chnl_net.c
new file mode 100644
index 000000000000..610966abe2dc
--- /dev/null
+++ b/net/caif/chnl_net.c
@@ -0,0 +1,467 @@
+/*
+ * Copyright (C) ST-Ericsson AB 2010
+ * Authors:     Sjur Brendeland/sjur.brandeland@stericsson.com
+ *              Daniel Martensson / Daniel.Martensson@stericsson.com
+ * License terms: GNU General Public License (GPL) version 2
+ */
+
+#include <linux/version.h>
+#include <linux/fs.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/netdevice.h>
+#include <linux/if_ether.h>
+#include <linux/moduleparam.h>
+#include <linux/ip.h>
+#include <linux/sched.h>
+#include <linux/sockios.h>
+#include <linux/caif/if_caif.h>
+#include <net/rtnetlink.h>
+#include <net/caif/caif_layer.h>
+#include <net/caif/cfcnfg.h>
+#include <net/caif/cfpkt.h>
+#include <net/caif/caif_dev.h>
+
+/* GPRS PDP connection has MTU to 1500 */
+#define SIZE_MTU 1500
+/* 5 sec. connect timeout */
+#define CONNECT_TIMEOUT (5 * HZ)
+#define CAIF_NET_DEFAULT_QUEUE_LEN 500
+
+#undef pr_debug
+#define pr_debug pr_warning
+
+/*This list is protected by the rtnl lock. */
+static LIST_HEAD(chnl_net_list);
+
+MODULE_LICENSE("GPL");
+MODULE_ALIAS_RTNL_LINK("caif");
+
+enum caif_states {
+        CAIF_CONNECTED          = 1,
+        CAIF_CONNECTING,
+        CAIF_DISCONNECTED,
+        CAIF_SHUTDOWN
+};
+
+struct chnl_net {
+        struct cflayer chnl;
+        struct net_device_stats stats;
+        struct caif_connect_request conn_req;
+        struct list_head list_field;
+        struct net_device *netdev;
+        char name[256];
+        wait_queue_head_t netmgmt_wq;
+        /* Flow status to remember and control the transmission. */
+        bool flowenabled;
+        enum caif_states state;
+};
+
+static void robust_list_del(struct list_head *delete_node)
+{
+        struct list_head *list_node;
+        struct list_head *n;
+        ASSERT_RTNL();
+        list_for_each_safe(list_node, n, &chnl_net_list) {
+                if (list_node == delete_node) {
+                        list_del(list_node);
+                        return;
+                }
+        }
+        WARN_ON(1);
+}
+
+static int chnl_recv_cb(struct cflayer *layr, struct cfpkt *pkt)
+{
+        struct sk_buff *skb;
+        struct chnl_net *priv  = container_of(layr, struct chnl_net, chnl);
+        int pktlen;
+        int err = 0;
+
+        priv = container_of(layr, struct chnl_net, chnl);
+
+        if (!priv)
+                return -EINVAL;
+
+        /* Get length of CAIF packet. */
+        pktlen = cfpkt_getlen(pkt);
+
+        skb = (struct sk_buff *) cfpkt_tonative(pkt);
+        /* Pass some minimum information and
+         * send the packet to the net stack.
+         */
+        skb->dev = priv->netdev;
+        skb->protocol = htons(ETH_P_IP);
+
+        /* If we change the header in loop mode, the checksum is corrupted. */
+        if (priv->conn_req.protocol == CAIFPROTO_DATAGRAM_LOOP)
+                skb->ip_summed = CHECKSUM_UNNECESSARY;
+        else
+                skb->ip_summed = CHECKSUM_NONE;
+
+        if (in_interrupt())
+                netif_rx(skb);
+        else
+                netif_rx_ni(skb);
+
+        /* Update statistics. */
+        priv->netdev->stats.rx_packets++;
+        priv->netdev->stats.rx_bytes += pktlen;
+
+        return err;
+}
+
+static int delete_device(struct chnl_net *dev)
+{
+        ASSERT_RTNL();
+        if (dev->netdev)
+                unregister_netdevice(dev->netdev);
+        return 0;
+}
+
+static void close_work(struct work_struct *work)
+{
+        struct chnl_net *dev = NULL;
+        struct list_head *list_node;
+        struct list_head *_tmp;
+        /* May be called with or without RTNL lock held */
+        int islocked = rtnl_is_locked();
+        if (!islocked)
+                rtnl_lock();
+        list_for_each_safe(list_node, _tmp, &chnl_net_list) {
+                dev = list_entry(list_node, struct chnl_net, list_field);
+                if (dev->state == CAIF_SHUTDOWN)
+                        dev_close(dev->netdev);
+        }
+        if (!islocked)
+                rtnl_unlock();
+}
+static DECLARE_WORK(close_worker, close_work);
+
+static void chnl_flowctrl_cb(struct cflayer *layr, enum caif_ctrlcmd flow,
+                                int phyid)
+{
+        struct chnl_net *priv = container_of(layr, struct chnl_net, chnl);
+        pr_debug("CAIF: %s(): NET flowctrl func called flow: %s\n",
+                __func__,
+                flow == CAIF_CTRLCMD_FLOW_ON_IND ? "ON" :
+                flow == CAIF_CTRLCMD_INIT_RSP ? "INIT" :
+                flow == CAIF_CTRLCMD_FLOW_OFF_IND ? "OFF" :
+                flow == CAIF_CTRLCMD_DEINIT_RSP ? "CLOSE/DEINIT" :
+                flow == CAIF_CTRLCMD_INIT_FAIL_RSP ? "OPEN_FAIL" :
+                flow == CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND ?
+                 "REMOTE_SHUTDOWN" : "UKNOWN CTRL COMMAND");
+
+
+
+        switch (flow) {
+        case CAIF_CTRLCMD_FLOW_OFF_IND:
+                priv->flowenabled = false;
+                netif_stop_queue(priv->netdev);
+                break;
+        case CAIF_CTRLCMD_DEINIT_RSP:
+                priv->state = CAIF_DISCONNECTED;
+                break;
+        case CAIF_CTRLCMD_INIT_FAIL_RSP:
+                priv->state = CAIF_DISCONNECTED;
+                wake_up_interruptible(&priv->netmgmt_wq);
+                break;
+        case CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND:
+                priv->state = CAIF_SHUTDOWN;
+                netif_tx_disable(priv->netdev);
+                schedule_work(&close_worker);
+                break;
+        case CAIF_CTRLCMD_FLOW_ON_IND:
+                priv->flowenabled = true;
+                netif_wake_queue(priv->netdev);
+                break;
+        case CAIF_CTRLCMD_INIT_RSP:
+                priv->state = CAIF_CONNECTED;
+                priv->flowenabled = true;
+                netif_wake_queue(priv->netdev);
+                wake_up_interruptible(&priv->netmgmt_wq);
+                break;
+        default:
+                break;
+        }
+}
+
+static int chnl_net_start_xmit(struct sk_buff *skb, struct net_device *dev)
+{
+        struct chnl_net *priv;
+        struct cfpkt *pkt = NULL;
+        int len;
+        int result = -1;
+        /* Get our private data. */
+        priv = netdev_priv(dev);
+
+        if (skb->len > priv->netdev->mtu) {
+                pr_warning("CAIF: %s(): Size of skb exceeded MTU\n", __func__);
+                return -ENOSPC;
+        }
+
+        if (!priv->flowenabled) {
+                pr_debug("CAIF: %s(): dropping packets flow off\n", __func__);
+                return NETDEV_TX_BUSY;
+        }
+
+        if (priv->conn_req.protocol == CAIFPROTO_DATAGRAM_LOOP)
+                swap(ip_hdr(skb)->saddr, ip_hdr(skb)->daddr);
+
+        /* Store original SKB length. */
+        len = skb->len;
+
+        pkt = cfpkt_fromnative(CAIF_DIR_OUT, (void *) skb);
+
+        /* Send the packet down the stack. */
+        result = priv->chnl.dn->transmit(priv->chnl.dn, pkt);
+        if (result) {
+                if (result == -EAGAIN)
+                        result = NETDEV_TX_BUSY;
+                return result;
+        }
+
+        /* Update statistics. */
+        dev->stats.tx_packets++;
+        dev->stats.tx_bytes += len;
+
+        return NETDEV_TX_OK;
+}
+
+static int chnl_net_open(struct net_device *dev)
+{
+        struct chnl_net *priv = NULL;
+        int result = -1;
+        ASSERT_RTNL();
+        priv = netdev_priv(dev);
+        if (!priv) {
+                pr_debug("CAIF: %s(): chnl_net_open: no priv\n", __func__);
+                return -ENODEV;
+        }
+
+        if (priv->state != CAIF_CONNECTING) {
+                priv->state = CAIF_CONNECTING;
+                result = caif_connect_client(&priv->conn_req, &priv->chnl);
+                if (result != 0) {
+                                priv->state = CAIF_DISCONNECTED;
+                                pr_debug("CAIF: %s(): err: "
+                                        "Unable to register and open device,"
+                                        " Err:%d\n",
+                                        __func__,
+                                        result);
+                                return result;
+                }
+        }
+
+        result = wait_event_interruptible_timeout(priv->netmgmt_wq,
+                                                priv->state != CAIF_CONNECTING,
+                                                CONNECT_TIMEOUT);
+
+        if (result == -ERESTARTSYS) {
+                pr_debug("CAIF: %s(): wait_event_interruptible"
+                         " woken by a signal\n", __func__);
+                return -ERESTARTSYS;
+        }
+        if (result == 0) {
+                pr_debug("CAIF: %s(): connect timeout\n", __func__);
+                caif_disconnect_client(&priv->chnl);
+                priv->state = CAIF_DISCONNECTED;
+                pr_debug("CAIF: %s(): state disconnected\n", __func__);
+                return -ETIMEDOUT;
+        }
+
+        if (priv->state != CAIF_CONNECTED) {
+                pr_debug("CAIF: %s(): connect failed\n", __func__);
+                return -ECONNREFUSED;
+        }
+        pr_debug("CAIF: %s(): CAIF Netdevice connected\n", __func__);
+        return 0;
+}
+
+static int chnl_net_stop(struct net_device *dev)
+{
+        struct chnl_net *priv;
+
+        ASSERT_RTNL();
+        priv = netdev_priv(dev);
+        priv->state = CAIF_DISCONNECTED;
+        caif_disconnect_client(&priv->chnl);
+        return 0;
+}
+
+static int chnl_net_init(struct net_device *dev)
+{
+        struct chnl_net *priv;
+        ASSERT_RTNL();
+        priv = netdev_priv(dev);
+        strncpy(priv->name, dev->name, sizeof(priv->name));
+        return 0;
+}
+
+static void chnl_net_uninit(struct net_device *dev)
+{
+        struct chnl_net *priv;
+        ASSERT_RTNL();
+        priv = netdev_priv(dev);
+        robust_list_del(&priv->list_field);
+}
+
+static const struct net_device_ops netdev_ops = {
+        .ndo_open = chnl_net_open,
+        .ndo_stop = chnl_net_stop,
+        .ndo_init = chnl_net_init,
+        .ndo_uninit = chnl_net_uninit,
+        .ndo_start_xmit = chnl_net_start_xmit,
+};
+
+static void ipcaif_net_setup(struct net_device *dev)
+{
+        struct chnl_net *priv;
+        dev->netdev_ops = &netdev_ops;
+        dev->destructor = free_netdev;
+        dev->flags |= IFF_NOARP;
+        dev->flags |= IFF_POINTOPOINT;
+        dev->needed_headroom = CAIF_NEEDED_HEADROOM;
+        dev->needed_tailroom = CAIF_NEEDED_TAILROOM;
+        dev->mtu = SIZE_MTU;
+        dev->tx_queue_len = CAIF_NET_DEFAULT_QUEUE_LEN;
+
+        priv = netdev_priv(dev);
+        priv->chnl.receive = chnl_recv_cb;
+        priv->chnl.ctrlcmd = chnl_flowctrl_cb;
+        priv->netdev = dev;
+        priv->conn_req.protocol = CAIFPROTO_DATAGRAM;
+        priv->conn_req.link_selector = CAIF_LINK_HIGH_BANDW;
+        priv->conn_req.priority = CAIF_PRIO_LOW;
+        /* Insert illegal value */
+        priv->conn_req.sockaddr.u.dgm.connection_id = -1;
+        priv->flowenabled = false;
+
+        ASSERT_RTNL();
+        init_waitqueue_head(&priv->netmgmt_wq);
+        list_add(&priv->list_field, &chnl_net_list);
+}
+
+
+static int ipcaif_fill_info(struct sk_buff *skb, const struct net_device *dev)
+{
+        struct chnl_net *priv;
+        u8 loop;
+        priv = netdev_priv(dev);
+        NLA_PUT_U32(skb, IFLA_CAIF_IPV4_CONNID,
+                    priv->conn_req.sockaddr.u.dgm.connection_id);
+        NLA_PUT_U32(skb, IFLA_CAIF_IPV6_CONNID,
+                    priv->conn_req.sockaddr.u.dgm.connection_id);
+        loop = priv->conn_req.protocol == CAIFPROTO_DATAGRAM_LOOP;
+        NLA_PUT_U8(skb, IFLA_CAIF_LOOPBACK, loop);
+
+
+        return 0;
+nla_put_failure:
+        return -EMSGSIZE;
+
+}
+
+static void caif_netlink_parms(struct nlattr *data[],
+                                struct caif_connect_request *conn_req)
+{
+        if (!data) {
+                pr_warning("CAIF: %s: no params data found\n", __func__);
+                return;
+        }
+        if (data[IFLA_CAIF_IPV4_CONNID])
+                conn_req->sockaddr.u.dgm.connection_id =
+                        nla_get_u32(data[IFLA_CAIF_IPV4_CONNID]);
+        if (data[IFLA_CAIF_IPV6_CONNID])
+                conn_req->sockaddr.u.dgm.connection_id =
+                        nla_get_u32(data[IFLA_CAIF_IPV6_CONNID]);
+        if (data[IFLA_CAIF_LOOPBACK]) {
+                if (nla_get_u8(data[IFLA_CAIF_LOOPBACK]))
+                        conn_req->protocol = CAIFPROTO_DATAGRAM_LOOP;
+                else
+                        conn_req->protocol = CAIFPROTO_DATAGRAM;
+        }
+}
+
+static int ipcaif_newlink(struct net *src_net, struct net_device *dev,
+                          struct nlattr *tb[], struct nlattr *data[])
+{
+        int ret;
+        struct chnl_net *caifdev;
+        ASSERT_RTNL();
+        caifdev = netdev_priv(dev);
+        caif_netlink_parms(data, &caifdev->conn_req);
+        dev_net_set(caifdev->netdev, src_net);
+
+        ret = register_netdevice(dev);
+        if (ret)
+                pr_warning("CAIF: %s(): device rtml registration failed\n",
+                           __func__);
+        return ret;
+}
+
+static int ipcaif_changelink(struct net_device *dev, struct nlattr *tb[],
+                                struct nlattr *data[])
+{
+        struct chnl_net *caifdev;
+        ASSERT_RTNL();
+        caifdev = netdev_priv(dev);
+        caif_netlink_parms(data, &caifdev->conn_req);
+        netdev_state_change(dev);
+        return 0;
+}
+
+static size_t ipcaif_get_size(const struct net_device *dev)
+{
+        return
+                /* IFLA_CAIF_IPV4_CONNID */
+                nla_total_size(4) +
+                /* IFLA_CAIF_IPV6_CONNID */
+                nla_total_size(4) +
+                /* IFLA_CAIF_LOOPBACK */
+                nla_total_size(2) +
+                0;
+}
+
+static const struct nla_policy ipcaif_policy[IFLA_CAIF_MAX + 1] = {
+        [IFLA_CAIF_IPV4_CONNID]       = { .type = NLA_U32 },
+        [IFLA_CAIF_IPV6_CONNID]       = { .type = NLA_U32 },
+        [IFLA_CAIF_LOOPBACK]          = { .type = NLA_U8 }
+};
+
+
+static struct rtnl_link_ops ipcaif_link_ops __read_mostly = {
+        .kind           = "caif",
+        .priv_size      = sizeof(struct chnl_net),
+        .setup          = ipcaif_net_setup,
+        .maxtype        = IFLA_CAIF_MAX,
+        .policy         = ipcaif_policy,
+        .newlink        = ipcaif_newlink,
+        .changelink     = ipcaif_changelink,
+        .get_size       = ipcaif_get_size,
+        .fill_info      = ipcaif_fill_info,
+
+};
+
+static int __init chnl_init_module(void)
+{
+        return rtnl_link_register(&ipcaif_link_ops);
+}
+
+static void __exit chnl_exit_module(void)
+{
+        struct chnl_net *dev = NULL;
+        struct list_head *list_node;
+        struct list_head *_tmp;
+        rtnl_link_unregister(&ipcaif_link_ops);
+        rtnl_lock();
+        list_for_each_safe(list_node, _tmp, &chnl_net_list) {
+                dev = list_entry(list_node, struct chnl_net, list_field);
+                list_del(list_node);
+                delete_device(dev);
+        }
+        rtnl_unlock();
+}
+
+module_init(chnl_init_module);
+module_exit(chnl_exit_module);
diff --git a/net/can/bcm.c b/net/can/bcm.c
index e32af52238a2..907dc871fac8 100644
--- a/net/can/bcm.c
+++ b/net/can/bcm.c
@@ -56,6 +56,7 @@
 #include <linux/can.h>
 #include <linux/can/core.h>
 #include <linux/can/bcm.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 #include <net/net_namespace.h>
 
@@ -1478,6 +1479,9 @@ static int bcm_connect(struct socket *sock, struct sockaddr *uaddr, int len,
         struct sock *sk = sock->sk;
         struct bcm_sock *bo = bcm_sk(sk);
 
+        if (len < sizeof(*addr))
+                return -EINVAL;
+
         if (bo->bound)
                 return -EISCONN;
 
diff --git a/net/can/raw.c b/net/can/raw.c
index abca920440b5..da99cf153b33 100644
--- a/net/can/raw.c
+++ b/net/can/raw.c
@@ -45,6 +45,7 @@
 #include <linux/init.h>
 #include <linux/uio.h>
 #include <linux/net.h>
+#include <linux/slab.h>
 #include <linux/netdevice.h>
 #include <linux/socket.h>
 #include <linux/if_arp.h>
@@ -444,7 +445,7 @@ static int raw_setsockopt(struct socket *sock, int level, int optname,
                                 return -EFAULT;
                         }
                 } else if (count == 1) {
-                        if (copy_from_user(&sfilter, optval, optlen))
+                        if (copy_from_user(&sfilter, optval, sizeof(sfilter)))
                                 return -EFAULT;
                 }
 
diff --git a/net/compat.c b/net/compat.c
index a1fb1b079a82..ec24d9edb025 100644
--- a/net/compat.c
+++ b/net/compat.c
@@ -12,6 +12,7 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/gfp.h>
 #include <linux/fs.h>
 #include <linux/types.h>
 #include <linux/file.h>
diff --git a/net/core/Makefile b/net/core/Makefile
index 08791ac3e05a..51c3eec850ef 100644
--- a/net/core/Makefile
+++ b/net/core/Makefile
@@ -7,7 +7,7 @@ obj-y := sock.o request_sock.o skbuff.o iovec.o datagram.o stream.o scm.o \
 
 obj-$(CONFIG_SYSCTL) += sysctl_net_core.o
 
-obj-y                += dev.o ethtool.o dev_mcast.o dst.o netevent.o \
+obj-y                += dev.o ethtool.o dev_addr_lists.o dst.o netevent.o \
                         neighbour.o rtnetlink.o utils.o link_watch.o filter.o
 
 obj-$(CONFIG_XFRM) += flow.o
diff --git a/net/core/datagram.c b/net/core/datagram.c
index 95c2e0840d0d..e0097531417a 100644
--- a/net/core/datagram.c
+++ b/net/core/datagram.c
@@ -48,6 +48,7 @@
 #include <linux/poll.h>
 #include <linux/highmem.h>
 #include <linux/spinlock.h>
+#include <linux/slab.h>
 
 #include <net/protocol.h>
 #include <linux/skbuff.h>
@@ -85,7 +86,7 @@ static int wait_for_packet(struct sock *sk, int *err, long *timeo_p)
         int error;
         DEFINE_WAIT_FUNC(wait, receiver_wake_function);
 
-        prepare_to_wait_exclusive(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+        prepare_to_wait_exclusive(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
 
         /* Socket errors? */
         error = sock_error(sk);
@@ -114,7 +115,7 @@ static int wait_for_packet(struct sock *sk, int *err, long *timeo_p)
         error = 0;
         *timeo_p = schedule_timeout(*timeo_p);
 out:
-        finish_wait(sk->sk_sleep, &wait);
+        finish_wait(sk_sleep(sk), &wait);
         return error;
 interrupted:
         error = sock_intr_errno(*timeo_p);
@@ -228,9 +229,18 @@ EXPORT_SYMBOL(skb_free_datagram);
 
 void skb_free_datagram_locked(struct sock *sk, struct sk_buff *skb)
 {
-        lock_sock(sk);
-        skb_free_datagram(sk, skb);
-        release_sock(sk);
+        if (likely(atomic_read(&skb->users) == 1))
+                smp_rmb();
+        else if (likely(!atomic_dec_and_test(&skb->users)))
+                return;
+
+        lock_sock_bh(sk);
+        skb_orphan(skb);
+        sk_mem_reclaim_partial(sk);
+        unlock_sock_bh(sk);
+
+        /* skb is now orphaned, can be freed outside of locked section */
+        __kfree_skb(skb);
 }
 EXPORT_SYMBOL(skb_free_datagram_locked);
 
@@ -725,7 +735,7 @@ unsigned int datagram_poll(struct file *file, struct socket *sock,
         struct sock *sk = sock->sk;
         unsigned int mask;
 
-        sock_poll_wait(file, sk->sk_sleep, wait);
+        sock_poll_wait(file, sk_sleep(sk), wait);
         mask = 0;
 
         /* exceptional events? */
diff --git a/net/core/dev.c b/net/core/dev.c
index bcc490cc9452..36d53be4fca6 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -80,6 +80,7 @@
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/hash.h>
+#include <linux/slab.h>
 #include <linux/sched.h>
 #include <linux/mutex.h>
 #include <linux/string.h>
@@ -129,6 +130,7 @@
 #include <linux/jhash.h>
 #include <linux/random.h>
 #include <trace/events/napi.h>
+#include <linux/pci.h>
 
 #include "net-sysfs.h"
 
@@ -206,6 +208,20 @@ static inline struct hlist_head *dev_index_hash(struct net *net, int ifindex)
         return &net->dev_index_head[ifindex & (NETDEV_HASHENTRIES - 1)];
 }
 
+static inline void rps_lock(struct softnet_data *sd)
+{
+#ifdef CONFIG_RPS
+        spin_lock(&sd->input_pkt_queue.lock);
+#endif
+}
+
+static inline void rps_unlock(struct softnet_data *sd)
+{
+#ifdef CONFIG_RPS
+        spin_unlock(&sd->input_pkt_queue.lock);
+#endif
+}
+
 /* Device list insertion */
 static int list_netdevice(struct net_device *dev)
 {
@@ -248,7 +264,7 @@ static RAW_NOTIFIER_HEAD(netdev_chain);
  *      queue in the local softnet handler.
  */
 
-DEFINE_PER_CPU(struct softnet_data, softnet_data);
+DEFINE_PER_CPU_ALIGNED(struct softnet_data, softnet_data);
 EXPORT_PER_CPU_SYMBOL(softnet_data);
 
 #ifdef CONFIG_LOCKDEP
@@ -772,14 +788,17 @@ EXPORT_SYMBOL(__dev_getfirstbyhwtype);
 
 struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type)
 {
-        struct net_device *dev;
+        struct net_device *dev, *ret = NULL;
 
-        rtnl_lock();
-        dev = __dev_getfirstbyhwtype(net, type);
-        if (dev)
-                dev_hold(dev);
-        rtnl_unlock();
-        return dev;
+        rcu_read_lock();
+        for_each_netdev_rcu(net, dev)
+                if (dev->type == type) {
+                        dev_hold(dev);
+                        ret = dev;
+                        break;
+                }
+        rcu_read_unlock();
+        return ret;
 }
 EXPORT_SYMBOL(dev_getfirstbyhwtype);
 
@@ -1084,9 +1103,9 @@ void netdev_state_change(struct net_device *dev)
 }
 EXPORT_SYMBOL(netdev_state_change);
 
-void netdev_bonding_change(struct net_device *dev, unsigned long event)
+int netdev_bonding_change(struct net_device *dev, unsigned long event)
 {
-        call_netdevice_notifiers(event, dev);
+        return call_netdevice_notifiers(event, dev);
 }
 EXPORT_SYMBOL(netdev_bonding_change);
 
@@ -1416,6 +1435,7 @@ EXPORT_SYMBOL(unregister_netdevice_notifier);
 
 int call_netdevice_notifiers(unsigned long val, struct net_device *dev)
 {
+        ASSERT_RTNL();
         return raw_notifier_call_chain(&netdev_chain, val, dev);
 }
 
@@ -1537,8 +1557,9 @@ static inline void __netif_reschedule(struct Qdisc *q)
 
         local_irq_save(flags);
         sd = &__get_cpu_var(softnet_data);
-        q->next_sched = sd->output_queue;
-        sd->output_queue = q;
+        q->next_sched = NULL;
+        *sd->output_queue_tailp = q;
+        sd->output_queue_tailp = &q->next_sched;
         raise_softirq_irqoff(NET_TX_SOFTIRQ);
         local_irq_restore(flags);
 }
@@ -1783,18 +1804,27 @@ EXPORT_SYMBOL(netdev_rx_csum_fault);
  * 2. No high memory really exists on this machine.
  */
 
-static inline int illegal_highdma(struct net_device *dev, struct sk_buff *skb)
+static int illegal_highdma(struct net_device *dev, struct sk_buff *skb)
 {
 #ifdef CONFIG_HIGHMEM
         int i;
+        if (!(dev->features & NETIF_F_HIGHDMA)) {
+                for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
+                        if (PageHighMem(skb_shinfo(skb)->frags[i].page))
+                                return 1;
+        }
 
-        if (dev->features & NETIF_F_HIGHDMA)
-                return 0;
-
-        for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
-                if (PageHighMem(skb_shinfo(skb)->frags[i].page))
-                        return 1;
+        if (PCI_DMA_BUS_IS_PHYS) {
+                struct device *pdev = dev->dev.parent;
 
+                if (!pdev)
+                        return 0;
+                for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
+                        dma_addr_t addr = page_to_phys(skb_shinfo(skb)->frags[i].page);
+                        if (!pdev->dma_mask || addr + PAGE_SIZE - 1 > *pdev->dma_mask)
+                                return 1;
+                }
+        }
 #endif
         return 0;
 }
@@ -1852,6 +1882,17 @@ static int dev_gso_segment(struct sk_buff *skb)
         return 0;
 }
 
+/*
+ * Try to orphan skb early, right before transmission by the device.
+ * We cannot orphan skb if tx timestamp is requested, since
+ * drivers need to call skb_tstamp_tx() to send the timestamp.
+ */
+static inline void skb_orphan_try(struct sk_buff *skb)
+{
+        if (!skb_tx(skb)->flags)
+                skb_orphan(skb);
+}
+
 int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev,
                         struct netdev_queue *txq)
 {
@@ -1862,13 +1903,6 @@ int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev,
                 if (!list_empty(&ptype_all))
                         dev_queue_xmit_nit(skb, dev);
 
-                if (netif_needs_gso(dev, skb)) {
-                        if (unlikely(dev_gso_segment(skb)))
-                                goto out_kfree_skb;
-                        if (skb->next)
-                                goto gso;
-                }
-
                 /*
                  * If device doesnt need skb->dst, release it right now while
                  * its hot in this cpu cache
@@ -1876,23 +1910,18 @@ int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev,
                 if (dev->priv_flags & IFF_XMIT_DST_RELEASE)
                         skb_dst_drop(skb);
 
+                skb_orphan_try(skb);
+
+                if (netif_needs_gso(dev, skb)) {
+                        if (unlikely(dev_gso_segment(skb)))
+                                goto out_kfree_skb;
+                        if (skb->next)
+                                goto gso;
+                }
+
                 rc = ops->ndo_start_xmit(skb, dev);
                 if (rc == NETDEV_TX_OK)
                         txq_trans_update(txq);
-                /*
-                 * TODO: if skb_orphan() was called by
-                 * dev->hard_start_xmit() (for example, the unmodified
-                 * igb driver does that; bnx2 doesn't), then
-                 * skb_tx_software_timestamp() will be unable to send
-                 * back the time stamp.
-                 *
-                 * How can this be prevented? Always create another
-                 * reference to the socket before calling
-                 * dev->hard_start_xmit()? Prevent that skb_orphan()
-                 * does anything in dev->hard_start_xmit() by clearing
-                 * the skb destructor before the call and restoring it
-                 * afterwards, then doing the skb_orphan() ourselves?
-                 */
                 return rc;
         }
 
@@ -1931,7 +1960,7 @@ out_kfree_skb:
         return rc;
 }
 
-static u32 skb_tx_hashrnd;
+static u32 hashrnd __read_mostly;
 
 u16 skb_tx_hash(const struct net_device *dev, const struct sk_buff *skb)
 {
@@ -1947,9 +1976,9 @@ u16 skb_tx_hash(const struct net_device *dev, const struct sk_buff *skb)
         if (skb->sk && skb->sk->sk_hash)
                 hash = skb->sk->sk_hash;
         else
-                hash = skb->protocol;
+                hash = (__force u16) skb->protocol;
 
-        hash = jhash_1word(hash, skb_tx_hashrnd);
+        hash = jhash_1word(hash, hashrnd);
 
         return (u16) (((u64) hash * dev->real_num_tx_queues) >> 32);
 }
@@ -1959,10 +1988,9 @@ static inline u16 dev_cap_txqueue(struct net_device *dev, u16 queue_index)
 {
         if (unlikely(queue_index >= dev->real_num_tx_queues)) {
                 if (net_ratelimit()) {
-                        WARN(1, "%s selects TX queue %d, but "
-                             "real number of TX queues is %d\n",
-                             dev->name, queue_index,
-                             dev->real_num_tx_queues);
+                        pr_warning("%s selects TX queue %d, but "
+                                "real number of TX queues is %d\n",
+                                dev->name, queue_index, dev->real_num_tx_queues);
                 }
                 return 0;
         }
@@ -1988,8 +2016,12 @@ static struct netdev_queue *dev_pick_tx(struct net_device *dev,
                         if (dev->real_num_tx_queues > 1)
                                 queue_index = skb_tx_hash(dev, skb);
 
-                        if (sk && sk->sk_dst_cache)
-                                sk_tx_queue_set(sk, queue_index);
+                        if (sk) {
+                                struct dst_entry *dst = rcu_dereference_check(sk->sk_dst_cache, 1);
+
+                                if (dst && skb_dst(skb) == dst)
+                                        sk_tx_queue_set(sk, queue_index);
+                        }
                 }
         }
 
@@ -2173,8 +2205,235 @@ int netdev_max_backlog __read_mostly = 1000;
 int netdev_budget __read_mostly = 300;
 int weight_p __read_mostly = 64;            /* old backlog weight */
 
-DEFINE_PER_CPU(struct netif_rx_stats, netdev_rx_stat) = { 0, };
+#ifdef CONFIG_RPS
+
+/* One global table that all flow-based protocols share. */
+struct rps_sock_flow_table *rps_sock_flow_table __read_mostly;
+EXPORT_SYMBOL(rps_sock_flow_table);
+
+/*
+ * get_rps_cpu is called from netif_receive_skb and returns the target
+ * CPU from the RPS map of the receiving queue for a given skb.
+ * rcu_read_lock must be held on entry.
+ */
+static int get_rps_cpu(struct net_device *dev, struct sk_buff *skb,
+                       struct rps_dev_flow **rflowp)
+{
+        struct ipv6hdr *ip6;
+        struct iphdr *ip;
+        struct netdev_rx_queue *rxqueue;
+        struct rps_map *map;
+        struct rps_dev_flow_table *flow_table;
+        struct rps_sock_flow_table *sock_flow_table;
+        int cpu = -1;
+        u8 ip_proto;
+        u16 tcpu;
+        u32 addr1, addr2, ihl;
+        union {
+                u32 v32;
+                u16 v16[2];
+        } ports;
+
+        if (skb_rx_queue_recorded(skb)) {
+                u16 index = skb_get_rx_queue(skb);
+                if (unlikely(index >= dev->num_rx_queues)) {
+                        if (net_ratelimit()) {
+                                pr_warning("%s received packet on queue "
+                                        "%u, but number of RX queues is %u\n",
+                                        dev->name, index, dev->num_rx_queues);
+                        }
+                        goto done;
+                }
+                rxqueue = dev->_rx + index;
+        } else
+                rxqueue = dev->_rx;
+
+        if (!rxqueue->rps_map && !rxqueue->rps_flow_table)
+                goto done;
+
+        if (skb->rxhash)
+                goto got_hash; /* Skip hash computation on packet header */
+
+        switch (skb->protocol) {
+        case __constant_htons(ETH_P_IP):
+                if (!pskb_may_pull(skb, sizeof(*ip)))
+                        goto done;
+
+                ip = (struct iphdr *) skb->data;
+                ip_proto = ip->protocol;
+                addr1 = (__force u32) ip->saddr;
+                addr2 = (__force u32) ip->daddr;
+                ihl = ip->ihl;
+                break;
+        case __constant_htons(ETH_P_IPV6):
+                if (!pskb_may_pull(skb, sizeof(*ip6)))
+                        goto done;
+
+                ip6 = (struct ipv6hdr *) skb->data;
+                ip_proto = ip6->nexthdr;
+                addr1 = (__force u32) ip6->saddr.s6_addr32[3];
+                addr2 = (__force u32) ip6->daddr.s6_addr32[3];
+                ihl = (40 >> 2);
+                break;
+        default:
+                goto done;
+        }
+        switch (ip_proto) {
+        case IPPROTO_TCP:
+        case IPPROTO_UDP:
+        case IPPROTO_DCCP:
+        case IPPROTO_ESP:
+        case IPPROTO_AH:
+        case IPPROTO_SCTP:
+        case IPPROTO_UDPLITE:
+                if (pskb_may_pull(skb, (ihl * 4) + 4)) {
+                        ports.v32 = * (__force u32 *) (skb->data + (ihl * 4));
+                        if (ports.v16[1] < ports.v16[0])
+                                swap(ports.v16[0], ports.v16[1]);
+                        break;
+                }
+        default:
+                ports.v32 = 0;
+                break;
+        }
+
+        /* get a consistent hash (same value on both flow directions) */
+        if (addr2 < addr1)
+                swap(addr1, addr2);
+        skb->rxhash = jhash_3words(addr1, addr2, ports.v32, hashrnd);
+        if (!skb->rxhash)
+                skb->rxhash = 1;
+
+got_hash:
+        flow_table = rcu_dereference(rxqueue->rps_flow_table);
+        sock_flow_table = rcu_dereference(rps_sock_flow_table);
+        if (flow_table && sock_flow_table) {
+                u16 next_cpu;
+                struct rps_dev_flow *rflow;
+
+                rflow = &flow_table->flows[skb->rxhash & flow_table->mask];
+                tcpu = rflow->cpu;
 
+                next_cpu = sock_flow_table->ents[skb->rxhash &
+                    sock_flow_table->mask];
+
+                /*
+                 * If the desired CPU (where last recvmsg was done) is
+                 * different from current CPU (one in the rx-queue flow
+                 * table entry), switch if one of the following holds:
+                 *   - Current CPU is unset (equal to RPS_NO_CPU).
+                 *   - Current CPU is offline.
+                 *   - The current CPU's queue tail has advanced beyond the
+                 *     last packet that was enqueued using this table entry.
+                 *     This guarantees that all previous packets for the flow
+                 *     have been dequeued, thus preserving in order delivery.
+                 */
+                if (unlikely(tcpu != next_cpu) &&
+                    (tcpu == RPS_NO_CPU || !cpu_online(tcpu) ||
+                     ((int)(per_cpu(softnet_data, tcpu).input_queue_head -
+                      rflow->last_qtail)) >= 0)) {
+                        tcpu = rflow->cpu = next_cpu;
+                        if (tcpu != RPS_NO_CPU)
+                                rflow->last_qtail = per_cpu(softnet_data,
+                                    tcpu).input_queue_head;
+                }
+                if (tcpu != RPS_NO_CPU && cpu_online(tcpu)) {
+                        *rflowp = rflow;
+                        cpu = tcpu;
+                        goto done;
+                }
+        }
+
+        map = rcu_dereference(rxqueue->rps_map);
+        if (map) {
+                tcpu = map->cpus[((u64) skb->rxhash * map->len) >> 32];
+
+                if (cpu_online(tcpu)) {
+                        cpu = tcpu;
+                        goto done;
+                }
+        }
+
+done:
+        return cpu;
+}
+
+/* Called from hardirq (IPI) context */
+static void rps_trigger_softirq(void *data)
+{
+        struct softnet_data *sd = data;
+
+        __napi_schedule(&sd->backlog);
+        sd->received_rps++;
+}
+
+#endif /* CONFIG_RPS */
+
+/*
+ * Check if this softnet_data structure is another cpu one
+ * If yes, queue it to our IPI list and return 1
+ * If no, return 0
+ */
+static int rps_ipi_queued(struct softnet_data *sd)
+{
+#ifdef CONFIG_RPS
+        struct softnet_data *mysd = &__get_cpu_var(softnet_data);
+
+        if (sd != mysd) {
+                sd->rps_ipi_next = mysd->rps_ipi_list;
+                mysd->rps_ipi_list = sd;
+
+                __raise_softirq_irqoff(NET_RX_SOFTIRQ);
+                return 1;
+        }
+#endif /* CONFIG_RPS */
+        return 0;
+}
+
+/*
+ * enqueue_to_backlog is called to queue an skb to a per CPU backlog
+ * queue (may be a remote CPU queue).
+ */
+static int enqueue_to_backlog(struct sk_buff *skb, int cpu,
+                              unsigned int *qtail)
+{
+        struct softnet_data *sd;
+        unsigned long flags;
+
+        sd = &per_cpu(softnet_data, cpu);
+
+        local_irq_save(flags);
+
+        rps_lock(sd);
+        if (skb_queue_len(&sd->input_pkt_queue) <= netdev_max_backlog) {
+                if (skb_queue_len(&sd->input_pkt_queue)) {
+enqueue:
+                        __skb_queue_tail(&sd->input_pkt_queue, skb);
+#ifdef CONFIG_RPS
+                        *qtail = sd->input_queue_head +
+                                        skb_queue_len(&sd->input_pkt_queue);
+#endif
+                        rps_unlock(sd);
+                        local_irq_restore(flags);
+                        return NET_RX_SUCCESS;
+                }
+
+                /* Schedule NAPI for backlog device */
+                if (napi_schedule_prep(&sd->backlog)) {
+                        if (!rps_ipi_queued(sd))
+                                __napi_schedule(&sd->backlog);
+                }
+                goto enqueue;
+        }
+
+        sd->dropped++;
+        rps_unlock(sd);
+
+        local_irq_restore(flags);
+
+        kfree_skb(skb);
+        return NET_RX_DROP;
+}
 
 /**
  *      netif_rx        -       post buffer to the network code
@@ -2193,8 +2452,7 @@ DEFINE_PER_CPU(struct netif_rx_stats, netdev_rx_stat) = { 0, };
 
 int netif_rx(struct sk_buff *skb)
 {
-        struct softnet_data *queue;
-        unsigned long flags;
+        int ret;
 
         /* if netpoll wants it, pretend we never saw it */
         if (netpoll_rx(skb))
@@ -2203,31 +2461,29 @@ int netif_rx(struct sk_buff *skb)
         if (!skb->tstamp.tv64)
                 net_timestamp(skb);
 
-        /*
-         * The code is rearranged so that the path is the most
-         * short when CPU is congested, but is still operating.
-         */
-        local_irq_save(flags);
-        queue = &__get_cpu_var(softnet_data);
+#ifdef CONFIG_RPS
+        {
+                struct rps_dev_flow voidflow, *rflow = &voidflow;
+                int cpu;
 
-        __get_cpu_var(netdev_rx_stat).total++;
-        if (queue->input_pkt_queue.qlen <= netdev_max_backlog) {
-                if (queue->input_pkt_queue.qlen) {
-enqueue:
-                        __skb_queue_tail(&queue->input_pkt_queue, skb);
-                        local_irq_restore(flags);
-                        return NET_RX_SUCCESS;
-                }
+                rcu_read_lock();
 
-                napi_schedule(&queue->backlog);
-                goto enqueue;
-        }
+                cpu = get_rps_cpu(skb->dev, skb, &rflow);
+                if (cpu < 0)
+                        cpu = smp_processor_id();
 
-        __get_cpu_var(netdev_rx_stat).dropped++;
-        local_irq_restore(flags);
+                ret = enqueue_to_backlog(skb, cpu, &rflow->last_qtail);
 
-        kfree_skb(skb);
-        return NET_RX_DROP;
+                rcu_read_unlock();
+        }
+#else
+        {
+                unsigned int qtail;
+                ret = enqueue_to_backlog(skb, get_cpu(), &qtail);
+                put_cpu();
+        }
+#endif
+        return ret;
 }
 EXPORT_SYMBOL(netif_rx);
 
@@ -2272,6 +2528,7 @@ static void net_tx_action(struct softirq_action *h)
                 local_irq_disable();
                 head = sd->output_queue;
                 sd->output_queue = NULL;
+                sd->output_queue_tailp = &sd->output_queue;
                 local_irq_enable();
 
                 while (head) {
@@ -2464,25 +2721,60 @@ void netif_nit_deliver(struct sk_buff *skb)
         rcu_read_unlock();
 }
 
-/**
- *      netif_receive_skb - process receive buffer from network
- *      @skb: buffer to process
- *
- *      netif_receive_skb() is the main receive data processing function.
- *      It always succeeds. The buffer may be dropped during processing
- *      for congestion control or by the protocol layers.
- *
- *      This function may only be called from softirq context and interrupts
- *      should be enabled.
- *
- *      Return values (usually ignored):
- *      NET_RX_SUCCESS: no congestion
- *      NET_RX_DROP: packet was dropped
+static inline void skb_bond_set_mac_by_master(struct sk_buff *skb,
+                                              struct net_device *master)
+{
+        if (skb->pkt_type == PACKET_HOST) {
+                u16 *dest = (u16 *) eth_hdr(skb)->h_dest;
+
+                memcpy(dest, master->dev_addr, ETH_ALEN);
+        }
+}
+
+/* On bonding slaves other than the currently active slave, suppress
+ * duplicates except for 802.3ad ETH_P_SLOW, alb non-mcast/bcast, and
+ * ARP on active-backup slaves with arp_validate enabled.
  */
-int netif_receive_skb(struct sk_buff *skb)
+int __skb_bond_should_drop(struct sk_buff *skb, struct net_device *master)
+{
+        struct net_device *dev = skb->dev;
+
+        if (master->priv_flags & IFF_MASTER_ARPMON)
+                dev->last_rx = jiffies;
+
+        if ((master->priv_flags & IFF_MASTER_ALB) && master->br_port) {
+                /* Do address unmangle. The local destination address
+                 * will be always the one master has. Provides the right
+                 * functionality in a bridge.
+                 */
+                skb_bond_set_mac_by_master(skb, master);
+        }
+
+        if (dev->priv_flags & IFF_SLAVE_INACTIVE) {
+                if ((dev->priv_flags & IFF_SLAVE_NEEDARP) &&
+                    skb->protocol == __cpu_to_be16(ETH_P_ARP))
+                        return 0;
+
+                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 == __cpu_to_be16(ETH_P_SLOW))
+                        return 0;
+
+                return 1;
+        }
+        return 0;
+}
+EXPORT_SYMBOL(__skb_bond_should_drop);
+
+static int __netif_receive_skb(struct sk_buff *skb)
 {
         struct packet_type *ptype, *pt_prev;
         struct net_device *orig_dev;
+        struct net_device *master;
         struct net_device *null_or_orig;
         struct net_device *null_or_bond;
         int ret = NET_RX_DROP;
@@ -2503,14 +2795,15 @@ int netif_receive_skb(struct sk_buff *skb)
 
         null_or_orig = NULL;
         orig_dev = skb->dev;
-        if (orig_dev->master) {
-                if (skb_bond_should_drop(skb))
+        master = ACCESS_ONCE(orig_dev->master);
+        if (master) {
+                if (skb_bond_should_drop(skb, master))
                         null_or_orig = orig_dev; /* deliver only exact match */
                 else
-                        skb->dev = orig_dev->master;
+                        skb->dev = master;
         }
 
-        __get_cpu_var(netdev_rx_stat).total++;
+        __get_cpu_var(softnet_data).processed++;
 
         skb_reset_network_header(skb);
         skb_reset_transport_header(skb);
@@ -2588,20 +2881,72 @@ out:
         rcu_read_unlock();
         return ret;
 }
+
+/**
+ *      netif_receive_skb - process receive buffer from network
+ *      @skb: buffer to process
+ *
+ *      netif_receive_skb() is the main receive data processing function.
+ *      It always succeeds. The buffer may be dropped during processing
+ *      for congestion control or by the protocol layers.
+ *
+ *      This function may only be called from softirq context and interrupts
+ *      should be enabled.
+ *
+ *      Return values (usually ignored):
+ *      NET_RX_SUCCESS: no congestion
+ *      NET_RX_DROP: packet was dropped
+ */
+int netif_receive_skb(struct sk_buff *skb)
+{
+#ifdef CONFIG_RPS
+        struct rps_dev_flow voidflow, *rflow = &voidflow;
+        int cpu, ret;
+
+        rcu_read_lock();
+
+        cpu = get_rps_cpu(skb->dev, skb, &rflow);
+
+        if (cpu >= 0) {
+                ret = enqueue_to_backlog(skb, cpu, &rflow->last_qtail);
+                rcu_read_unlock();
+        } else {
+                rcu_read_unlock();
+                ret = __netif_receive_skb(skb);
+        }
+
+        return ret;
+#else
+        return __netif_receive_skb(skb);
+#endif
+}
 EXPORT_SYMBOL(netif_receive_skb);
 
-/* Network device is going away, flush any packets still pending  */
+/* Network device is going away, flush any packets still pending
+ * Called with irqs disabled.
+ */
 static void flush_backlog(void *arg)
 {
         struct net_device *dev = arg;
-        struct softnet_data *queue = &__get_cpu_var(softnet_data);
+        struct softnet_data *sd = &__get_cpu_var(softnet_data);
         struct sk_buff *skb, *tmp;
 
-        skb_queue_walk_safe(&queue->input_pkt_queue, skb, tmp)
+        rps_lock(sd);
+        skb_queue_walk_safe(&sd->input_pkt_queue, skb, tmp) {
                 if (skb->dev == dev) {
-                        __skb_unlink(skb, &queue->input_pkt_queue);
+                        __skb_unlink(skb, &sd->input_pkt_queue);
                         kfree_skb(skb);
+                        input_queue_head_add(sd, 1);
                 }
+        }
+        rps_unlock(sd);
+
+        skb_queue_walk_safe(&sd->process_queue, skb, tmp) {
+                if (skb->dev == dev) {
+                        __skb_unlink(skb, &sd->process_queue);
+                        kfree_skb(skb);
+                }
+        }
 }
 
 static int napi_gro_complete(struct sk_buff *skb)
@@ -2904,27 +3249,76 @@ gro_result_t napi_gro_frags(struct napi_struct *napi)
 }
 EXPORT_SYMBOL(napi_gro_frags);
 
+/*
+ * net_rps_action sends any pending IPI's for rps.
+ * Note: called with local irq disabled, but exits with local irq enabled.
+ */
+static void net_rps_action_and_irq_enable(struct softnet_data *sd)
+{
+#ifdef CONFIG_RPS
+        struct softnet_data *remsd = sd->rps_ipi_list;
+
+        if (remsd) {
+                sd->rps_ipi_list = NULL;
+
+                local_irq_enable();
+
+                /* Send pending IPI's to kick RPS processing on remote cpus. */
+                while (remsd) {
+                        struct softnet_data *next = remsd->rps_ipi_next;
+
+                        if (cpu_online(remsd->cpu))
+                                __smp_call_function_single(remsd->cpu,
+                                                           &remsd->csd, 0);
+                        remsd = next;
+                }
+        } else
+#endif
+                local_irq_enable();
+}
+
 static int process_backlog(struct napi_struct *napi, int quota)
 {
         int work = 0;
-        struct softnet_data *queue = &__get_cpu_var(softnet_data);
-        unsigned long start_time = jiffies;
+        struct softnet_data *sd = &__get_cpu_var(softnet_data);
 
+#ifdef CONFIG_RPS
+        /* Check if we have pending ipi, its better to send them now,
+         * not waiting net_rx_action() end.
+         */
+        if (sd->rps_ipi_list) {
+                local_irq_disable();
+                net_rps_action_and_irq_enable(sd);
+        }
+#endif
         napi->weight = weight_p;
-        do {
+        local_irq_disable();
+        while (work < quota) {
                 struct sk_buff *skb;
+                unsigned int qlen;
 
-                local_irq_disable();
-                skb = __skb_dequeue(&queue->input_pkt_queue);
-                if (!skb) {
-                        __napi_complete(napi);
+                while ((skb = __skb_dequeue(&sd->process_queue))) {
                         local_irq_enable();
-                        break;
+                        __netif_receive_skb(skb);
+                        if (++work >= quota)
+                                return work;
+                        local_irq_disable();
                 }
-                local_irq_enable();
 
-                netif_receive_skb(skb);
-        } while (++work < quota && jiffies == start_time);
+                rps_lock(sd);
+                qlen = skb_queue_len(&sd->input_pkt_queue);
+                if (qlen) {
+                        input_queue_head_add(sd, qlen);
+                        skb_queue_splice_tail_init(&sd->input_pkt_queue,
+                                                   &sd->process_queue);
+                }
+                if (qlen < quota - work) {
+                        __napi_complete(napi);
+                        quota = work + qlen;
+                }
+                rps_unlock(sd);
+        }
+        local_irq_enable();
 
         return work;
 }
@@ -3012,17 +3406,16 @@ void netif_napi_del(struct napi_struct *napi)
 }
 EXPORT_SYMBOL(netif_napi_del);
 
-
 static void net_rx_action(struct softirq_action *h)
 {
-        struct list_head *list = &__get_cpu_var(softnet_data).poll_list;
+        struct softnet_data *sd = &__get_cpu_var(softnet_data);
         unsigned long time_limit = jiffies + 2;
         int budget = netdev_budget;
         void *have;
 
         local_irq_disable();
 
-        while (!list_empty(list)) {
+        while (!list_empty(&sd->poll_list)) {
                 struct napi_struct *n;
                 int work, weight;
 
@@ -3040,7 +3433,7 @@ static void net_rx_action(struct softirq_action *h)
                  * entries to the tail of this list, and only ->poll()
                  * calls can remove this head entry from the list.
                  */
-                n = list_first_entry(list, struct napi_struct, poll_list);
+                n = list_first_entry(&sd->poll_list, struct napi_struct, poll_list);
 
                 have = netpoll_poll_lock(n);
 
@@ -3075,13 +3468,13 @@ static void net_rx_action(struct softirq_action *h)
                                 napi_complete(n);
                                 local_irq_disable();
                         } else
-                                list_move_tail(&n->poll_list, list);
+                                list_move_tail(&n->poll_list, &sd->poll_list);
                 }
 
                 netpoll_poll_unlock(have);
         }
 out:
-        local_irq_enable();
+        net_rps_action_and_irq_enable(sd);
 
 #ifdef CONFIG_NET_DMA
         /*
@@ -3094,7 +3487,7 @@ out:
         return;
 
 softnet_break:
-        __get_cpu_var(netdev_rx_stat).time_squeeze++;
+        sd->time_squeeze++;
         __raise_softirq_irqoff(NET_RX_SOFTIRQ);
         goto out;
 }
@@ -3295,17 +3688,17 @@ static int dev_seq_show(struct seq_file *seq, void *v)
         return 0;
 }
 
-static struct netif_rx_stats *softnet_get_online(loff_t *pos)
+static struct softnet_data *softnet_get_online(loff_t *pos)
 {
-        struct netif_rx_stats *rc = NULL;
+        struct softnet_data *sd = NULL;
 
         while (*pos < nr_cpu_ids)
                 if (cpu_online(*pos)) {
-                        rc = &per_cpu(netdev_rx_stat, *pos);
+                        sd = &per_cpu(softnet_data, *pos);
                         break;
                 } else
                         ++*pos;
-        return rc;
+        return sd;
 }
 
 static void *softnet_seq_start(struct seq_file *seq, loff_t *pos)
@@ -3325,12 +3718,12 @@ static void softnet_seq_stop(struct seq_file *seq, void *v)
 
 static int softnet_seq_show(struct seq_file *seq, void *v)
 {
-        struct netif_rx_stats *s = v;
+        struct softnet_data *sd = v;
 
-        seq_printf(seq, "%08x %08x %08x %08x %08x %08x %08x %08x %08x\n",
-                   s->total, s->dropped, s->time_squeeze, 0,
+        seq_printf(seq, "%08x %08x %08x %08x %08x %08x %08x %08x %08x %08x\n",
+                   sd->processed, sd->dropped, sd->time_squeeze, 0,
                    0, 0, 0, 0, /* was fastroute */
-                   s->cpu_collision);
+                   sd->cpu_collision, sd->received_rps);
         return 0;
 }
 
@@ -3553,11 +3946,10 @@ int netdev_set_master(struct net_device *slave, struct net_device *master)
 
         slave->master = master;
 
-        synchronize_net();
-
-        if (old)
+        if (old) {
+                synchronize_net();
                 dev_put(old);
-
+        }
         if (master)
                 slave->flags |= IFF_SLAVE;
         else
@@ -3734,562 +4126,6 @@ void dev_set_rx_mode(struct net_device *dev)
         netif_addr_unlock_bh(dev);
 }
 
-/* hw addresses list handling functions */
-
-static int __hw_addr_add(struct netdev_hw_addr_list *list, unsigned char *addr,
-                         int addr_len, unsigned char addr_type)
-{
-        struct netdev_hw_addr *ha;
-        int alloc_size;
-
-        if (addr_len > MAX_ADDR_LEN)
-                return -EINVAL;
-
-        list_for_each_entry(ha, &list->list, list) {
-                if (!memcmp(ha->addr, addr, addr_len) &&
-                    ha->type == addr_type) {
-                        ha->refcount++;
-                        return 0;
-                }
-        }
-
-
-        alloc_size = sizeof(*ha);
-        if (alloc_size < L1_CACHE_BYTES)
-                alloc_size = L1_CACHE_BYTES;
-        ha = kmalloc(alloc_size, GFP_ATOMIC);
-        if (!ha)
-                return -ENOMEM;
-        memcpy(ha->addr, addr, addr_len);
-        ha->type = addr_type;
-        ha->refcount = 1;
-        ha->synced = false;
-        list_add_tail_rcu(&ha->list, &list->list);
-        list->count++;
-        return 0;
-}
-
-static void ha_rcu_free(struct rcu_head *head)
-{
-        struct netdev_hw_addr *ha;
-
-        ha = container_of(head, struct netdev_hw_addr, rcu_head);
-        kfree(ha);
-}
-
-static int __hw_addr_del(struct netdev_hw_addr_list *list, unsigned char *addr,
-                         int addr_len, unsigned char addr_type)
-{
-        struct netdev_hw_addr *ha;
-
-        list_for_each_entry(ha, &list->list, list) {
-                if (!memcmp(ha->addr, addr, addr_len) &&
-                    (ha->type == addr_type || !addr_type)) {
-                        if (--ha->refcount)
-                                return 0;
-                        list_del_rcu(&ha->list);
-                        call_rcu(&ha->rcu_head, ha_rcu_free);
-                        list->count--;
-                        return 0;
-                }
-        }
-        return -ENOENT;
-}
-
-static int __hw_addr_add_multiple(struct netdev_hw_addr_list *to_list,
-                                  struct netdev_hw_addr_list *from_list,
-                                  int addr_len,
-                                  unsigned char addr_type)
-{
-        int err;
-        struct netdev_hw_addr *ha, *ha2;
-        unsigned char type;
-
-        list_for_each_entry(ha, &from_list->list, list) {
-                type = addr_type ? addr_type : ha->type;
-                err = __hw_addr_add(to_list, ha->addr, addr_len, type);
-                if (err)
-                        goto unroll;
-        }
-        return 0;
-
-unroll:
-        list_for_each_entry(ha2, &from_list->list, list) {
-                if (ha2 == ha)
-                        break;
-                type = addr_type ? addr_type : ha2->type;
-                __hw_addr_del(to_list, ha2->addr, addr_len, type);
-        }
-        return err;
-}
-
-static void __hw_addr_del_multiple(struct netdev_hw_addr_list *to_list,
-                                   struct netdev_hw_addr_list *from_list,
-                                   int addr_len,
-                                   unsigned char addr_type)
-{
-        struct netdev_hw_addr *ha;
-        unsigned char type;
-
-        list_for_each_entry(ha, &from_list->list, list) {
-                type = addr_type ? addr_type : ha->type;
-                __hw_addr_del(to_list, ha->addr, addr_len, addr_type);
-        }
-}
-
-static int __hw_addr_sync(struct netdev_hw_addr_list *to_list,
-                          struct netdev_hw_addr_list *from_list,
-                          int addr_len)
-{
-        int err = 0;
-        struct netdev_hw_addr *ha, *tmp;
-
-        list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
-                if (!ha->synced) {
-                        err = __hw_addr_add(to_list, ha->addr,
-                                            addr_len, ha->type);
-                        if (err)
-                                break;
-                        ha->synced = true;
-                        ha->refcount++;
-                } else if (ha->refcount == 1) {
-                        __hw_addr_del(to_list, ha->addr, addr_len, ha->type);
-                        __hw_addr_del(from_list, ha->addr, addr_len, ha->type);
-                }
-        }
-        return err;
-}
-
-static void __hw_addr_unsync(struct netdev_hw_addr_list *to_list,
-                             struct netdev_hw_addr_list *from_list,
-                             int addr_len)
-{
-        struct netdev_hw_addr *ha, *tmp;
-
-        list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
-                if (ha->synced) {
-                        __hw_addr_del(to_list, ha->addr,
-                                      addr_len, ha->type);
-                        ha->synced = false;
-                        __hw_addr_del(from_list, ha->addr,
-                                      addr_len, ha->type);
-                }
-        }
-}
-
-static void __hw_addr_flush(struct netdev_hw_addr_list *list)
-{
-        struct netdev_hw_addr *ha, *tmp;
-
-        list_for_each_entry_safe(ha, tmp, &list->list, list) {
-                list_del_rcu(&ha->list);
-                call_rcu(&ha->rcu_head, ha_rcu_free);
-        }
-        list->count = 0;
-}
-
-static void __hw_addr_init(struct netdev_hw_addr_list *list)
-{
-        INIT_LIST_HEAD(&list->list);
-        list->count = 0;
-}
-
-/* Device addresses handling functions */
-
-static void dev_addr_flush(struct net_device *dev)
-{
-        /* rtnl_mutex must be held here */
-
-        __hw_addr_flush(&dev->dev_addrs);
-        dev->dev_addr = NULL;
-}
-
-static int dev_addr_init(struct net_device *dev)
-{
-        unsigned char addr[MAX_ADDR_LEN];
-        struct netdev_hw_addr *ha;
-        int err;
-
-        /* rtnl_mutex must be held here */
-
-        __hw_addr_init(&dev->dev_addrs);
-        memset(addr, 0, sizeof(addr));
-        err = __hw_addr_add(&dev->dev_addrs, addr, sizeof(addr),
-                            NETDEV_HW_ADDR_T_LAN);
-        if (!err) {
-                /*
-                 * Get the first (previously created) address from the list
-                 * and set dev_addr pointer to this location.
-                 */
-                ha = list_first_entry(&dev->dev_addrs.list,
-                                      struct netdev_hw_addr, list);
-                dev->dev_addr = ha->addr;
-        }
-        return err;
-}
-
-/**
- *      dev_addr_add    - Add a device address
- *      @dev: device
- *      @addr: address to add
- *      @addr_type: address type
- *
- *      Add a device address to the device or increase the reference count if
- *      it already exists.
- *
- *      The caller must hold the rtnl_mutex.
- */
-int dev_addr_add(struct net_device *dev, unsigned char *addr,
-                 unsigned char addr_type)
-{
-        int err;
-
-        ASSERT_RTNL();
-
-        err = __hw_addr_add(&dev->dev_addrs, addr, dev->addr_len, addr_type);
-        if (!err)
-                call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
-        return err;
-}
-EXPORT_SYMBOL(dev_addr_add);
-
-/**
- *      dev_addr_del    - Release a device address.
- *      @dev: device
- *      @addr: address to delete
- *      @addr_type: address type
- *
- *      Release reference to a device address and remove it from the device
- *      if the reference count drops to zero.
- *
- *      The caller must hold the rtnl_mutex.
- */
-int dev_addr_del(struct net_device *dev, unsigned char *addr,
-                 unsigned char addr_type)
-{
-        int err;
-        struct netdev_hw_addr *ha;
-
-        ASSERT_RTNL();
-
-        /*
-         * We can not remove the first address from the list because
-         * dev->dev_addr points to that.
-         */
-        ha = list_first_entry(&dev->dev_addrs.list,
-                              struct netdev_hw_addr, list);
-        if (ha->addr == dev->dev_addr && ha->refcount == 1)
-                return -ENOENT;
-
-        err = __hw_addr_del(&dev->dev_addrs, addr, dev->addr_len,
-                            addr_type);
-        if (!err)
-                call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
-        return err;
-}
-EXPORT_SYMBOL(dev_addr_del);
-
-/**
- *      dev_addr_add_multiple   - Add device addresses from another device
- *      @to_dev: device to which addresses will be added
- *      @from_dev: device from which addresses will be added
- *      @addr_type: address type - 0 means type will be used from from_dev
- *
- *      Add device addresses of the one device to another.
- **
- *      The caller must hold the rtnl_mutex.
- */
-int dev_addr_add_multiple(struct net_device *to_dev,
-                          struct net_device *from_dev,
-                          unsigned char addr_type)
-{
-        int err;
-
-        ASSERT_RTNL();
-
-        if (from_dev->addr_len != to_dev->addr_len)
-                return -EINVAL;
-        err = __hw_addr_add_multiple(&to_dev->dev_addrs, &from_dev->dev_addrs,
-                                     to_dev->addr_len, addr_type);
-        if (!err)
-                call_netdevice_notifiers(NETDEV_CHANGEADDR, to_dev);
-        return err;
-}
-EXPORT_SYMBOL(dev_addr_add_multiple);
-
-/**
- *      dev_addr_del_multiple   - Delete device addresses by another device
- *      @to_dev: device where the addresses will be deleted
- *      @from_dev: device by which addresses the addresses will be deleted
- *      @addr_type: address type - 0 means type will used from from_dev
- *
- *      Deletes addresses in to device by the list of addresses in from device.
- *
- *      The caller must hold the rtnl_mutex.
- */
-int dev_addr_del_multiple(struct net_device *to_dev,
-                          struct net_device *from_dev,
-                          unsigned char addr_type)
-{
-        ASSERT_RTNL();
-
-        if (from_dev->addr_len != to_dev->addr_len)
-                return -EINVAL;
-        __hw_addr_del_multiple(&to_dev->dev_addrs, &from_dev->dev_addrs,
-                               to_dev->addr_len, addr_type);
-        call_netdevice_notifiers(NETDEV_CHANGEADDR, to_dev);
-        return 0;
-}
-EXPORT_SYMBOL(dev_addr_del_multiple);
-
-/* multicast addresses handling functions */
-
-int __dev_addr_delete(struct dev_addr_list **list, int *count,
-                      void *addr, int alen, int glbl)
-{
-        struct dev_addr_list *da;
-
-        for (; (da = *list) != NULL; list = &da->next) {
-                if (memcmp(da->da_addr, addr, da->da_addrlen) == 0 &&
-                    alen == da->da_addrlen) {
-                        if (glbl) {
-                                int old_glbl = da->da_gusers;
-                                da->da_gusers = 0;
-                                if (old_glbl == 0)
-                                        break;
-                        }
-                        if (--da->da_users)
-                                return 0;
-
-                        *list = da->next;
-                        kfree(da);
-                        (*count)--;
-                        return 0;
-                }
-        }
-        return -ENOENT;
-}
-
-int __dev_addr_add(struct dev_addr_list **list, int *count,
-                   void *addr, int alen, int glbl)
-{
-        struct dev_addr_list *da;
-
-        for (da = *list; da != NULL; da = da->next) {
-                if (memcmp(da->da_addr, addr, da->da_addrlen) == 0 &&
-                    da->da_addrlen == alen) {
-                        if (glbl) {
-                                int old_glbl = da->da_gusers;
-                                da->da_gusers = 1;
-                                if (old_glbl)
-                                        return 0;
-                        }
-                        da->da_users++;
-                        return 0;
-                }
-        }
-
-        da = kzalloc(sizeof(*da), GFP_ATOMIC);
-        if (da == NULL)
-                return -ENOMEM;
-        memcpy(da->da_addr, addr, alen);
-        da->da_addrlen = alen;
-        da->da_users = 1;
-        da->da_gusers = glbl ? 1 : 0;
-        da->next = *list;
-        *list = da;
-        (*count)++;
-        return 0;
-}
-
-/**
- *      dev_unicast_delete      - Release secondary unicast address.
- *      @dev: device
- *      @addr: address to delete
- *
- *      Release reference to a secondary unicast address and remove it
- *      from the device if the reference count drops to zero.
- *
- *      The caller must hold the rtnl_mutex.
- */
-int dev_unicast_delete(struct net_device *dev, void *addr)
-{
-        int err;
-
-        ASSERT_RTNL();
-
-        netif_addr_lock_bh(dev);
-        err = __hw_addr_del(&dev->uc, addr, dev->addr_len,
-                            NETDEV_HW_ADDR_T_UNICAST);
-        if (!err)
-                __dev_set_rx_mode(dev);
-        netif_addr_unlock_bh(dev);
-        return err;
-}
-EXPORT_SYMBOL(dev_unicast_delete);
-
-/**
- *      dev_unicast_add         - add a secondary unicast address
- *      @dev: device
- *      @addr: address to add
- *
- *      Add a secondary unicast address to the device or increase
- *      the reference count if it already exists.
- *
- *      The caller must hold the rtnl_mutex.
- */
-int dev_unicast_add(struct net_device *dev, void *addr)
-{
-        int err;
-
-        ASSERT_RTNL();
-
-        netif_addr_lock_bh(dev);
-        err = __hw_addr_add(&dev->uc, addr, dev->addr_len,
-                            NETDEV_HW_ADDR_T_UNICAST);
-        if (!err)
-                __dev_set_rx_mode(dev);
-        netif_addr_unlock_bh(dev);
-        return err;
-}
-EXPORT_SYMBOL(dev_unicast_add);
-
-int __dev_addr_sync(struct dev_addr_list **to, int *to_count,
-                    struct dev_addr_list **from, int *from_count)
-{
-        struct dev_addr_list *da, *next;
-        int err = 0;
-
-        da = *from;
-        while (da != NULL) {
-                next = da->next;
-                if (!da->da_synced) {
-                        err = __dev_addr_add(to, to_count,
-                                             da->da_addr, da->da_addrlen, 0);
-                        if (err < 0)
-                                break;
-                        da->da_synced = 1;
-                        da->da_users++;
-                } else if (da->da_users == 1) {
-                        __dev_addr_delete(to, to_count,
-                                          da->da_addr, da->da_addrlen, 0);
-                        __dev_addr_delete(from, from_count,
-                                          da->da_addr, da->da_addrlen, 0);
-                }
-                da = next;
-        }
-        return err;
-}
-EXPORT_SYMBOL_GPL(__dev_addr_sync);
-
-void __dev_addr_unsync(struct dev_addr_list **to, int *to_count,
-                       struct dev_addr_list **from, int *from_count)
-{
-        struct dev_addr_list *da, *next;
-
-        da = *from;
-        while (da != NULL) {
-                next = da->next;
-                if (da->da_synced) {
-                        __dev_addr_delete(to, to_count,
-                                          da->da_addr, da->da_addrlen, 0);
-                        da->da_synced = 0;
-                        __dev_addr_delete(from, from_count,
-                                          da->da_addr, da->da_addrlen, 0);
-                }
-                da = next;
-        }
-}
-EXPORT_SYMBOL_GPL(__dev_addr_unsync);
-
-/**
- *      dev_unicast_sync - Synchronize device's unicast list to another device
- *      @to: destination device
- *      @from: source device
- *
- *      Add newly added addresses to the destination device and release
- *      addresses that have no users left. The source device must be
- *      locked by netif_tx_lock_bh.
- *
- *      This function is intended to be called from the dev->set_rx_mode
- *      function of layered software devices.
- */
-int dev_unicast_sync(struct net_device *to, struct net_device *from)
-{
-        int err = 0;
-
-        if (to->addr_len != from->addr_len)
-                return -EINVAL;
-
-        netif_addr_lock_bh(to);
-        err = __hw_addr_sync(&to->uc, &from->uc, to->addr_len);
-        if (!err)
-                __dev_set_rx_mode(to);
-        netif_addr_unlock_bh(to);
-        return err;
-}
-EXPORT_SYMBOL(dev_unicast_sync);
-
-/**
- *      dev_unicast_unsync - Remove synchronized addresses from the destination device
- *      @to: destination device
- *      @from: source device
- *
- *      Remove all addresses that were added to the destination device by
- *      dev_unicast_sync(). This function is intended to be called from the
- *      dev->stop function of layered software devices.
- */
-void dev_unicast_unsync(struct net_device *to, struct net_device *from)
-{
-        if (to->addr_len != from->addr_len)
-                return;
-
-        netif_addr_lock_bh(from);
-        netif_addr_lock(to);
-        __hw_addr_unsync(&to->uc, &from->uc, to->addr_len);
-        __dev_set_rx_mode(to);
-        netif_addr_unlock(to);
-        netif_addr_unlock_bh(from);
-}
-EXPORT_SYMBOL(dev_unicast_unsync);
-
-static void dev_unicast_flush(struct net_device *dev)
-{
-        netif_addr_lock_bh(dev);
-        __hw_addr_flush(&dev->uc);
-        netif_addr_unlock_bh(dev);
-}
-
-static void dev_unicast_init(struct net_device *dev)
-{
-        __hw_addr_init(&dev->uc);
-}
-
-
-static void __dev_addr_discard(struct dev_addr_list **list)
-{
-        struct dev_addr_list *tmp;
-
-        while (*list != NULL) {
-                tmp = *list;
-                *list = tmp->next;
-                if (tmp->da_users > tmp->da_gusers)
-                        printk("__dev_addr_discard: address leakage! "
-                               "da_users=%d\n", tmp->da_users);
-                kfree(tmp);
-        }
-}
-
-static void dev_addr_discard(struct net_device *dev)
-{
-        netif_addr_lock_bh(dev);
-
-        __dev_addr_discard(&dev->mc_list);
-        netdev_mc_count(dev) = 0;
-
-        netif_addr_unlock_bh(dev);
-}
-
 /**
  *      dev_get_flags - get flags reported to userspace
  *      @dev: device
@@ -4600,8 +4436,7 @@ static int dev_ifsioc(struct net *net, struct ifreq *ifr, unsigned int cmd)
                         return -EINVAL;
                 if (!netif_device_present(dev))
                         return -ENODEV;
-                return dev_mc_add(dev, ifr->ifr_hwaddr.sa_data,
-                                  dev->addr_len, 1);
+                return dev_mc_add_global(dev, ifr->ifr_hwaddr.sa_data);
 
         case SIOCDELMULTI:
                 if ((!ops->ndo_set_multicast_list && !ops->ndo_set_rx_mode) ||
@@ -4609,8 +4444,7 @@ static int dev_ifsioc(struct net *net, struct ifreq *ifr, unsigned int cmd)
                         return -EINVAL;
                 if (!netif_device_present(dev))
                         return -ENODEV;
-                return dev_mc_delete(dev, ifr->ifr_hwaddr.sa_data,
-                                     dev->addr_len, 1);
+                return dev_mc_del_global(dev, ifr->ifr_hwaddr.sa_data);
 
         case SIOCSIFTXQLEN:
                 if (ifr->ifr_qlen < 0)
@@ -4917,8 +4751,8 @@ static void rollback_registered_many(struct list_head *head)
                 /*
                  *      Flush the unicast and multicast chains
                  */
-                dev_unicast_flush(dev);
-                dev_addr_discard(dev);
+                dev_uc_flush(dev);
+                dev_mc_flush(dev);
 
                 if (dev->netdev_ops->ndo_uninit)
                         dev->netdev_ops->ndo_uninit(dev);
@@ -5067,6 +4901,24 @@ int register_netdevice(struct net_device *dev)
 
         dev->iflink = -1;
 
+#ifdef CONFIG_RPS
+        if (!dev->num_rx_queues) {
+                /*
+                 * Allocate a single RX queue if driver never called
+                 * alloc_netdev_mq
+                 */
+
+                dev->_rx = kzalloc(sizeof(struct netdev_rx_queue), GFP_KERNEL);
+                if (!dev->_rx) {
+                        ret = -ENOMEM;
+                        goto out;
+                }
+
+                dev->_rx->first = dev->_rx;
+                atomic_set(&dev->_rx->count, 1);
+                dev->num_rx_queues = 1;
+        }
+#endif
         /* Init, if this function is available */
         if (dev->netdev_ops->ndo_init) {
                 ret = dev->netdev_ops->ndo_init(dev);
@@ -5427,6 +5279,10 @@ struct net_device *alloc_netdev_mq(int sizeof_priv, const char *name,
         struct net_device *dev;
         size_t alloc_size;
         struct net_device *p;
+#ifdef CONFIG_RPS
+        struct netdev_rx_queue *rx;
+        int i;
+#endif
 
         BUG_ON(strlen(name) >= sizeof(dev->name));
 
@@ -5452,13 +5308,32 @@ struct net_device *alloc_netdev_mq(int sizeof_priv, const char *name,
                 goto free_p;
         }
 
+#ifdef CONFIG_RPS
+        rx = kcalloc(queue_count, sizeof(struct netdev_rx_queue), GFP_KERNEL);
+        if (!rx) {
+                printk(KERN_ERR "alloc_netdev: Unable to allocate "
+                       "rx queues.\n");
+                goto free_tx;
+        }
+
+        atomic_set(&rx->count, queue_count);
+
+        /*
+         * Set a pointer to first element in the array which holds the
+         * reference count.
+         */
+        for (i = 0; i < queue_count; i++)
+                rx[i].first = rx;
+#endif
+
         dev = PTR_ALIGN(p, NETDEV_ALIGN);
         dev->padded = (char *)dev - (char *)p;
 
         if (dev_addr_init(dev))
-                goto free_tx;
+                goto free_rx;
 
-        dev_unicast_init(dev);
+        dev_mc_init(dev);
+        dev_uc_init(dev);
 
         dev_net_set(dev, &init_net);
 
@@ -5466,6 +5341,11 @@ struct net_device *alloc_netdev_mq(int sizeof_priv, const char *name,
         dev->num_tx_queues = queue_count;
         dev->real_num_tx_queues = queue_count;
 
+#ifdef CONFIG_RPS
+        dev->_rx = rx;
+        dev->num_rx_queues = queue_count;
+#endif
+
         dev->gso_max_size = GSO_MAX_SIZE;
 
         netdev_init_queues(dev);
@@ -5480,9 +5360,12 @@ struct net_device *alloc_netdev_mq(int sizeof_priv, const char *name,
         strcpy(dev->name, name);
         return dev;
 
+free_rx:
+#ifdef CONFIG_RPS
+        kfree(rx);
 free_tx:
+#endif
         kfree(tx);
-
 free_p:
         kfree(p);
         return NULL;
@@ -5684,8 +5567,8 @@ int dev_change_net_namespace(struct net_device *dev, struct net *net, const char
         /*
          *      Flush the unicast and multicast chains
          */
-        dev_unicast_flush(dev);
-        dev_addr_discard(dev);
+        dev_uc_flush(dev);
+        dev_mc_flush(dev);
 
         netdev_unregister_kobject(dev);
 
@@ -5728,7 +5611,6 @@ static int dev_cpu_callback(struct notifier_block *nfb,
                             void *ocpu)
 {
         struct sk_buff **list_skb;
-        struct Qdisc **list_net;
         struct sk_buff *skb;
         unsigned int cpu, oldcpu = (unsigned long)ocpu;
         struct softnet_data *sd, *oldsd;
@@ -5749,19 +5631,23 @@ static int dev_cpu_callback(struct notifier_block *nfb,
         *list_skb = oldsd->completion_queue;
         oldsd->completion_queue = NULL;
 
-        /* Find end of our output_queue. */
-        list_net = &sd->output_queue;
-        while (*list_net)
-                list_net = &(*list_net)->next_sched;
         /* Append output queue from offline CPU. */
-        *list_net = oldsd->output_queue;
-        oldsd->output_queue = NULL;
+        if (oldsd->output_queue) {
+                *sd->output_queue_tailp = oldsd->output_queue;
+                sd->output_queue_tailp = oldsd->output_queue_tailp;
+                oldsd->output_queue = NULL;
+                oldsd->output_queue_tailp = &oldsd->output_queue;
+        }
 
         raise_softirq_irqoff(NET_TX_SOFTIRQ);
         local_irq_enable();
 
         /* Process offline CPU's input_pkt_queue */
-        while ((skb = __skb_dequeue(&oldsd->input_pkt_queue)))
+        while ((skb = __skb_dequeue(&oldsd->input_pkt_queue))) {
+                netif_rx(skb);
+                input_queue_head_add(oldsd, 1);
+        }
+        while ((skb = __skb_dequeue(&oldsd->process_queue)))
                 netif_rx(skb);
 
         return NOTIFY_OK;
@@ -5978,17 +5864,26 @@ static int __init net_dev_init(void)
          */
 
         for_each_possible_cpu(i) {
-                struct softnet_data *queue;
+                struct softnet_data *sd = &per_cpu(softnet_data, i);
 
-                queue = &per_cpu(softnet_data, i);
-                skb_queue_head_init(&queue->input_pkt_queue);
-                queue->completion_queue = NULL;
-                INIT_LIST_HEAD(&queue->poll_list);
+                memset(sd, 0, sizeof(*sd));
+                skb_queue_head_init(&sd->input_pkt_queue);
+                skb_queue_head_init(&sd->process_queue);
+                sd->completion_queue = NULL;
+                INIT_LIST_HEAD(&sd->poll_list);
+                sd->output_queue = NULL;
+                sd->output_queue_tailp = &sd->output_queue;
+#ifdef CONFIG_RPS
+                sd->csd.func = rps_trigger_softirq;
+                sd->csd.info = sd;
+                sd->csd.flags = 0;
+                sd->cpu = i;
+#endif
 
-                queue->backlog.poll = process_backlog;
-                queue->backlog.weight = weight_p;
-                queue->backlog.gro_list = NULL;
-                queue->backlog.gro_count = 0;
+                sd->backlog.poll = process_backlog;
+                sd->backlog.weight = weight_p;
+                sd->backlog.gro_list = NULL;
+                sd->backlog.gro_count = 0;
         }
 
         dev_boot_phase = 0;
@@ -6023,7 +5918,7 @@ subsys_initcall(net_dev_init);
 
 static int __init initialize_hashrnd(void)
 {
-        get_random_bytes(&skb_tx_hashrnd, sizeof(skb_tx_hashrnd));
+        get_random_bytes(&hashrnd, sizeof(hashrnd));
         return 0;
 }
 
diff --git a/net/core/dev_addr_lists.c b/net/core/dev_addr_lists.c
new file mode 100644
index 000000000000..508f9c18992f
--- /dev/null
+++ b/net/core/dev_addr_lists.c
@@ -0,0 +1,741 @@
+/*
+ * net/core/dev_addr_lists.c - Functions for handling net device lists
+ * Copyright (c) 2010 Jiri Pirko <jpirko@redhat.com>
+ *
+ * This file contains functions for working with unicast, multicast and device
+ * addresses lists.
+ *
+ * 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.
+ */
+
+#include <linux/netdevice.h>
+#include <linux/rtnetlink.h>
+#include <linux/list.h>
+#include <linux/proc_fs.h>
+
+/*
+ * General list handling functions
+ */
+
+static int __hw_addr_add_ex(struct netdev_hw_addr_list *list,
+                            unsigned char *addr, int addr_len,
+                            unsigned char addr_type, bool global)
+{
+        struct netdev_hw_addr *ha;
+        int alloc_size;
+
+        if (addr_len > MAX_ADDR_LEN)
+                return -EINVAL;
+
+        list_for_each_entry(ha, &list->list, list) {
+                if (!memcmp(ha->addr, addr, addr_len) &&
+                    ha->type == addr_type) {
+                        if (global) {
+                                /* check if addr is already used as global */
+                                if (ha->global_use)
+                                        return 0;
+                                else
+                                        ha->global_use = true;
+                        }
+                        ha->refcount++;
+                        return 0;
+                }
+        }
+
+
+        alloc_size = sizeof(*ha);
+        if (alloc_size < L1_CACHE_BYTES)
+                alloc_size = L1_CACHE_BYTES;
+        ha = kmalloc(alloc_size, GFP_ATOMIC);
+        if (!ha)
+                return -ENOMEM;
+        memcpy(ha->addr, addr, addr_len);
+        ha->type = addr_type;
+        ha->refcount = 1;
+        ha->global_use = global;
+        ha->synced = false;
+        list_add_tail_rcu(&ha->list, &list->list);
+        list->count++;
+        return 0;
+}
+
+static int __hw_addr_add(struct netdev_hw_addr_list *list, unsigned char *addr,
+                         int addr_len, unsigned char addr_type)
+{
+        return __hw_addr_add_ex(list, addr, addr_len, addr_type, false);
+}
+
+static void ha_rcu_free(struct rcu_head *head)
+{
+        struct netdev_hw_addr *ha;
+
+        ha = container_of(head, struct netdev_hw_addr, rcu_head);
+        kfree(ha);
+}
+
+static int __hw_addr_del_ex(struct netdev_hw_addr_list *list,
+                            unsigned char *addr, int addr_len,
+                            unsigned char addr_type, bool global)
+{
+        struct netdev_hw_addr *ha;
+
+        list_for_each_entry(ha, &list->list, list) {
+                if (!memcmp(ha->addr, addr, addr_len) &&
+                    (ha->type == addr_type || !addr_type)) {
+                        if (global) {
+                                if (!ha->global_use)
+                                        break;
+                                else
+                                        ha->global_use = false;
+                        }
+                        if (--ha->refcount)
+                                return 0;
+                        list_del_rcu(&ha->list);
+                        call_rcu(&ha->rcu_head, ha_rcu_free);
+                        list->count--;
+                        return 0;
+                }
+        }
+        return -ENOENT;
+}
+
+static int __hw_addr_del(struct netdev_hw_addr_list *list, unsigned char *addr,
+                         int addr_len, unsigned char addr_type)
+{
+        return __hw_addr_del_ex(list, addr, addr_len, addr_type, false);
+}
+
+int __hw_addr_add_multiple(struct netdev_hw_addr_list *to_list,
+                           struct netdev_hw_addr_list *from_list,
+                           int addr_len, unsigned char addr_type)
+{
+        int err;
+        struct netdev_hw_addr *ha, *ha2;
+        unsigned char type;
+
+        list_for_each_entry(ha, &from_list->list, list) {
+                type = addr_type ? addr_type : ha->type;
+                err = __hw_addr_add(to_list, ha->addr, addr_len, type);
+                if (err)
+                        goto unroll;
+        }
+        return 0;
+
+unroll:
+        list_for_each_entry(ha2, &from_list->list, list) {
+                if (ha2 == ha)
+                        break;
+                type = addr_type ? addr_type : ha2->type;
+                __hw_addr_del(to_list, ha2->addr, addr_len, type);
+        }
+        return err;
+}
+EXPORT_SYMBOL(__hw_addr_add_multiple);
+
+void __hw_addr_del_multiple(struct netdev_hw_addr_list *to_list,
+                            struct netdev_hw_addr_list *from_list,
+                            int addr_len, unsigned char addr_type)
+{
+        struct netdev_hw_addr *ha;
+        unsigned char type;
+
+        list_for_each_entry(ha, &from_list->list, list) {
+                type = addr_type ? addr_type : ha->type;
+                __hw_addr_del(to_list, ha->addr, addr_len, addr_type);
+        }
+}
+EXPORT_SYMBOL(__hw_addr_del_multiple);
+
+int __hw_addr_sync(struct netdev_hw_addr_list *to_list,
+                   struct netdev_hw_addr_list *from_list,
+                   int addr_len)
+{
+        int err = 0;
+        struct netdev_hw_addr *ha, *tmp;
+
+        list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
+                if (!ha->synced) {
+                        err = __hw_addr_add(to_list, ha->addr,
+                                            addr_len, ha->type);
+                        if (err)
+                                break;
+                        ha->synced = true;
+                        ha->refcount++;
+                } else if (ha->refcount == 1) {
+                        __hw_addr_del(to_list, ha->addr, addr_len, ha->type);
+                        __hw_addr_del(from_list, ha->addr, addr_len, ha->type);
+                }
+        }
+        return err;
+}
+EXPORT_SYMBOL(__hw_addr_sync);
+
+void __hw_addr_unsync(struct netdev_hw_addr_list *to_list,
+                      struct netdev_hw_addr_list *from_list,
+                      int addr_len)
+{
+        struct netdev_hw_addr *ha, *tmp;
+
+        list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
+                if (ha->synced) {
+                        __hw_addr_del(to_list, ha->addr,
+                                      addr_len, ha->type);
+                        ha->synced = false;
+                        __hw_addr_del(from_list, ha->addr,
+                                      addr_len, ha->type);
+                }
+        }
+}
+EXPORT_SYMBOL(__hw_addr_unsync);
+
+void __hw_addr_flush(struct netdev_hw_addr_list *list)
+{
+        struct netdev_hw_addr *ha, *tmp;
+
+        list_for_each_entry_safe(ha, tmp, &list->list, list) {
+                list_del_rcu(&ha->list);
+                call_rcu(&ha->rcu_head, ha_rcu_free);
+        }
+        list->count = 0;
+}
+EXPORT_SYMBOL(__hw_addr_flush);
+
+void __hw_addr_init(struct netdev_hw_addr_list *list)
+{
+        INIT_LIST_HEAD(&list->list);
+        list->count = 0;
+}
+EXPORT_SYMBOL(__hw_addr_init);
+
+/*
+ * Device addresses handling functions
+ */
+
+/**
+ *      dev_addr_flush - Flush device address list
+ *      @dev: device
+ *
+ *      Flush device address list and reset ->dev_addr.
+ *
+ *      The caller must hold the rtnl_mutex.
+ */
+void dev_addr_flush(struct net_device *dev)
+{
+        /* rtnl_mutex must be held here */
+
+        __hw_addr_flush(&dev->dev_addrs);
+        dev->dev_addr = NULL;
+}
+EXPORT_SYMBOL(dev_addr_flush);
+
+/**
+ *      dev_addr_init - Init device address list
+ *      @dev: device
+ *
+ *      Init device address list and create the first element,
+ *      used by ->dev_addr.
+ *
+ *      The caller must hold the rtnl_mutex.
+ */
+int dev_addr_init(struct net_device *dev)
+{
+        unsigned char addr[MAX_ADDR_LEN];
+        struct netdev_hw_addr *ha;
+        int err;
+
+        /* rtnl_mutex must be held here */
+
+        __hw_addr_init(&dev->dev_addrs);
+        memset(addr, 0, sizeof(addr));
+        err = __hw_addr_add(&dev->dev_addrs, addr, sizeof(addr),
+                            NETDEV_HW_ADDR_T_LAN);
+        if (!err) {
+                /*
+                 * Get the first (previously created) address from the list
+                 * and set dev_addr pointer to this location.
+                 */
+                ha = list_first_entry(&dev->dev_addrs.list,
+                                      struct netdev_hw_addr, list);
+                dev->dev_addr = ha->addr;
+        }
+        return err;
+}
+EXPORT_SYMBOL(dev_addr_init);
+
+/**
+ *      dev_addr_add - Add a device address
+ *      @dev: device
+ *      @addr: address to add
+ *      @addr_type: address type
+ *
+ *      Add a device address to the device or increase the reference count if
+ *      it already exists.
+ *
+ *      The caller must hold the rtnl_mutex.
+ */
+int dev_addr_add(struct net_device *dev, unsigned char *addr,
+                 unsigned char addr_type)
+{
+        int err;
+
+        ASSERT_RTNL();
+
+        err = __hw_addr_add(&dev->dev_addrs, addr, dev->addr_len, addr_type);
+        if (!err)
+                call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
+        return err;
+}
+EXPORT_SYMBOL(dev_addr_add);
+
+/**
+ *      dev_addr_del - Release a device address.
+ *      @dev: device
+ *      @addr: address to delete
+ *      @addr_type: address type
+ *
+ *      Release reference to a device address and remove it from the device
+ *      if the reference count drops to zero.
+ *
+ *      The caller must hold the rtnl_mutex.
+ */
+int dev_addr_del(struct net_device *dev, unsigned char *addr,
+                 unsigned char addr_type)
+{
+        int err;
+        struct netdev_hw_addr *ha;
+
+        ASSERT_RTNL();
+
+        /*
+         * We can not remove the first address from the list because
+         * dev->dev_addr points to that.
+         */
+        ha = list_first_entry(&dev->dev_addrs.list,
+                              struct netdev_hw_addr, list);
+        if (ha->addr == dev->dev_addr && ha->refcount == 1)
+                return -ENOENT;
+
+        err = __hw_addr_del(&dev->dev_addrs, addr, dev->addr_len,
+                            addr_type);
+        if (!err)
+                call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
+        return err;
+}
+EXPORT_SYMBOL(dev_addr_del);
+
+/**
+ *      dev_addr_add_multiple - Add device addresses from another device
+ *      @to_dev: device to which addresses will be added
+ *      @from_dev: device from which addresses will be added
+ *      @addr_type: address type - 0 means type will be used from from_dev
+ *
+ *      Add device addresses of the one device to another.
+ **
+ *      The caller must hold the rtnl_mutex.
+ */
+int dev_addr_add_multiple(struct net_device *to_dev,
+                          struct net_device *from_dev,
+                          unsigned char addr_type)
+{
+        int err;
+
+        ASSERT_RTNL();
+
+        if (from_dev->addr_len != to_dev->addr_len)
+                return -EINVAL;
+        err = __hw_addr_add_multiple(&to_dev->dev_addrs, &from_dev->dev_addrs,
+                                     to_dev->addr_len, addr_type);
+        if (!err)
+                call_netdevice_notifiers(NETDEV_CHANGEADDR, to_dev);
+        return err;
+}
+EXPORT_SYMBOL(dev_addr_add_multiple);
+
+/**
+ *      dev_addr_del_multiple - Delete device addresses by another device
+ *      @to_dev: device where the addresses will be deleted
+ *      @from_dev: device by which addresses the addresses will be deleted
+ *      @addr_type: address type - 0 means type will used from from_dev
+ *
+ *      Deletes addresses in to device by the list of addresses in from device.
+ *
+ *      The caller must hold the rtnl_mutex.
+ */
+int dev_addr_del_multiple(struct net_device *to_dev,
+                          struct net_device *from_dev,
+                          unsigned char addr_type)
+{
+        ASSERT_RTNL();
+
+        if (from_dev->addr_len != to_dev->addr_len)
+                return -EINVAL;
+        __hw_addr_del_multiple(&to_dev->dev_addrs, &from_dev->dev_addrs,
+                               to_dev->addr_len, addr_type);
+        call_netdevice_notifiers(NETDEV_CHANGEADDR, to_dev);
+        return 0;
+}
+EXPORT_SYMBOL(dev_addr_del_multiple);
+
+/*
+ * Unicast list handling functions
+ */
+
+/**
+ *      dev_uc_add - Add a secondary unicast address
+ *      @dev: device
+ *      @addr: address to add
+ *
+ *      Add a secondary unicast address to the device or increase
+ *      the reference count if it already exists.
+ */
+int dev_uc_add(struct net_device *dev, unsigned char *addr)
+{
+        int err;
+
+        netif_addr_lock_bh(dev);
+        err = __hw_addr_add(&dev->uc, addr, dev->addr_len,
+                            NETDEV_HW_ADDR_T_UNICAST);
+        if (!err)
+                __dev_set_rx_mode(dev);
+        netif_addr_unlock_bh(dev);
+        return err;
+}
+EXPORT_SYMBOL(dev_uc_add);
+
+/**
+ *      dev_uc_del - Release secondary unicast address.
+ *      @dev: device
+ *      @addr: address to delete
+ *
+ *      Release reference to a secondary unicast address and remove it
+ *      from the device if the reference count drops to zero.
+ */
+int dev_uc_del(struct net_device *dev, unsigned char *addr)
+{
+        int err;
+
+        netif_addr_lock_bh(dev);
+        err = __hw_addr_del(&dev->uc, addr, dev->addr_len,
+                            NETDEV_HW_ADDR_T_UNICAST);
+        if (!err)
+                __dev_set_rx_mode(dev);
+        netif_addr_unlock_bh(dev);
+        return err;
+}
+EXPORT_SYMBOL(dev_uc_del);
+
+/**
+ *      dev_uc_sync - Synchronize device's unicast list to another device
+ *      @to: destination device
+ *      @from: source device
+ *
+ *      Add newly added addresses to the destination device and release
+ *      addresses that have no users left. The source device must be
+ *      locked by netif_tx_lock_bh.
+ *
+ *      This function is intended to be called from the dev->set_rx_mode
+ *      function of layered software devices.
+ */
+int dev_uc_sync(struct net_device *to, struct net_device *from)
+{
+        int err = 0;
+
+        if (to->addr_len != from->addr_len)
+                return -EINVAL;
+
+        netif_addr_lock_bh(to);
+        err = __hw_addr_sync(&to->uc, &from->uc, to->addr_len);
+        if (!err)
+                __dev_set_rx_mode(to);
+        netif_addr_unlock_bh(to);
+        return err;
+}
+EXPORT_SYMBOL(dev_uc_sync);
+
+/**
+ *      dev_uc_unsync - Remove synchronized addresses from the destination device
+ *      @to: destination device
+ *      @from: source device
+ *
+ *      Remove all addresses that were added to the destination device by
+ *      dev_uc_sync(). This function is intended to be called from the
+ *      dev->stop function of layered software devices.
+ */
+void dev_uc_unsync(struct net_device *to, struct net_device *from)
+{
+        if (to->addr_len != from->addr_len)
+                return;
+
+        netif_addr_lock_bh(from);
+        netif_addr_lock(to);
+        __hw_addr_unsync(&to->uc, &from->uc, to->addr_len);
+        __dev_set_rx_mode(to);
+        netif_addr_unlock(to);
+        netif_addr_unlock_bh(from);
+}
+EXPORT_SYMBOL(dev_uc_unsync);
+
+/**
+ *      dev_uc_flush - Flush unicast addresses
+ *      @dev: device
+ *
+ *      Flush unicast addresses.
+ */
+void dev_uc_flush(struct net_device *dev)
+{
+        netif_addr_lock_bh(dev);
+        __hw_addr_flush(&dev->uc);
+        netif_addr_unlock_bh(dev);
+}
+EXPORT_SYMBOL(dev_uc_flush);
+
+/**
+ *      dev_uc_flush - Init unicast address list
+ *      @dev: device
+ *
+ *      Init unicast address list.
+ */
+void dev_uc_init(struct net_device *dev)
+{
+        __hw_addr_init(&dev->uc);
+}
+EXPORT_SYMBOL(dev_uc_init);
+
+/*
+ * Multicast list handling functions
+ */
+
+static int __dev_mc_add(struct net_device *dev, unsigned char *addr,
+                        bool global)
+{
+        int err;
+
+        netif_addr_lock_bh(dev);
+        err = __hw_addr_add_ex(&dev->mc, addr, dev->addr_len,
+                               NETDEV_HW_ADDR_T_MULTICAST, global);
+        if (!err)
+                __dev_set_rx_mode(dev);
+        netif_addr_unlock_bh(dev);
+        return err;
+}
+/**
+ *      dev_mc_add - Add a multicast address
+ *      @dev: device
+ *      @addr: address to add
+ *
+ *      Add a multicast address to the device or increase
+ *      the reference count if it already exists.
+ */
+int dev_mc_add(struct net_device *dev, unsigned char *addr)
+{
+        return __dev_mc_add(dev, addr, false);
+}
+EXPORT_SYMBOL(dev_mc_add);
+
+/**
+ *      dev_mc_add_global - Add a global multicast address
+ *      @dev: device
+ *      @addr: address to add
+ *
+ *      Add a global multicast address to the device.
+ */
+int dev_mc_add_global(struct net_device *dev, unsigned char *addr)
+{
+        return __dev_mc_add(dev, addr, true);
+}
+EXPORT_SYMBOL(dev_mc_add_global);
+
+static int __dev_mc_del(struct net_device *dev, unsigned char *addr,
+                        bool global)
+{
+        int err;
+
+        netif_addr_lock_bh(dev);
+        err = __hw_addr_del_ex(&dev->mc, addr, dev->addr_len,
+                               NETDEV_HW_ADDR_T_MULTICAST, global);
+        if (!err)
+                __dev_set_rx_mode(dev);
+        netif_addr_unlock_bh(dev);
+        return err;
+}
+
+/**
+ *      dev_mc_del - Delete a multicast address.
+ *      @dev: device
+ *      @addr: address to delete
+ *
+ *      Release reference to a multicast address and remove it
+ *      from the device if the reference count drops to zero.
+ */
+int dev_mc_del(struct net_device *dev, unsigned char *addr)
+{
+        return __dev_mc_del(dev, addr, false);
+}
+EXPORT_SYMBOL(dev_mc_del);
+
+/**
+ *      dev_mc_del_global - Delete a global multicast address.
+ *      @dev: device
+ *      @addr: address to delete
+ *
+ *      Release reference to a multicast address and remove it
+ *      from the device if the reference count drops to zero.
+ */
+int dev_mc_del_global(struct net_device *dev, unsigned char *addr)
+{
+        return __dev_mc_del(dev, addr, true);
+}
+EXPORT_SYMBOL(dev_mc_del_global);
+
+/**
+ *      dev_mc_sync - Synchronize device's unicast list to another device
+ *      @to: destination device
+ *      @from: source device
+ *
+ *      Add newly added addresses to the destination device and release
+ *      addresses that have no users left. The source device must be
+ *      locked by netif_tx_lock_bh.
+ *
+ *      This function is intended to be called from the dev->set_multicast_list
+ *      or dev->set_rx_mode function of layered software devices.
+ */
+int dev_mc_sync(struct net_device *to, struct net_device *from)
+{
+        int err = 0;
+
+        if (to->addr_len != from->addr_len)
+                return -EINVAL;
+
+        netif_addr_lock_bh(to);
+        err = __hw_addr_sync(&to->mc, &from->mc, to->addr_len);
+        if (!err)
+                __dev_set_rx_mode(to);
+        netif_addr_unlock_bh(to);
+        return err;
+}
+EXPORT_SYMBOL(dev_mc_sync);
+
+/**
+ *      dev_mc_unsync - Remove synchronized addresses from the destination device
+ *      @to: destination device
+ *      @from: source device
+ *
+ *      Remove all addresses that were added to the destination device by
+ *      dev_mc_sync(). This function is intended to be called from the
+ *      dev->stop function of layered software devices.
+ */
+void dev_mc_unsync(struct net_device *to, struct net_device *from)
+{
+        if (to->addr_len != from->addr_len)
+                return;
+
+        netif_addr_lock_bh(from);
+        netif_addr_lock(to);
+        __hw_addr_unsync(&to->mc, &from->mc, to->addr_len);
+        __dev_set_rx_mode(to);
+        netif_addr_unlock(to);
+        netif_addr_unlock_bh(from);
+}
+EXPORT_SYMBOL(dev_mc_unsync);
+
+/**
+ *      dev_mc_flush - Flush multicast addresses
+ *      @dev: device
+ *
+ *      Flush multicast addresses.
+ */
+void dev_mc_flush(struct net_device *dev)
+{
+        netif_addr_lock_bh(dev);
+        __hw_addr_flush(&dev->mc);
+        netif_addr_unlock_bh(dev);
+}
+EXPORT_SYMBOL(dev_mc_flush);
+
+/**
+ *      dev_mc_flush - Init multicast address list
+ *      @dev: device
+ *
+ *      Init multicast address list.
+ */
+void dev_mc_init(struct net_device *dev)
+{
+        __hw_addr_init(&dev->mc);
+}
+EXPORT_SYMBOL(dev_mc_init);
+
+#ifdef CONFIG_PROC_FS
+#include <linux/seq_file.h>
+
+static int dev_mc_seq_show(struct seq_file *seq, void *v)
+{
+        struct netdev_hw_addr *ha;
+        struct net_device *dev = v;
+
+        if (v == SEQ_START_TOKEN)
+                return 0;
+
+        netif_addr_lock_bh(dev);
+        netdev_for_each_mc_addr(ha, dev) {
+                int i;
+
+                seq_printf(seq, "%-4d %-15s %-5d %-5d ", dev->ifindex,
+                           dev->name, ha->refcount, ha->global_use);
+
+                for (i = 0; i < dev->addr_len; i++)
+                        seq_printf(seq, "%02x", ha->addr[i]);
+
+                seq_putc(seq, '\n');
+        }
+        netif_addr_unlock_bh(dev);
+        return 0;
+}
+
+static const struct seq_operations dev_mc_seq_ops = {
+        .start = dev_seq_start,
+        .next  = dev_seq_next,
+        .stop  = dev_seq_stop,
+        .show  = dev_mc_seq_show,
+};
+
+static int dev_mc_seq_open(struct inode *inode, struct file *file)
+{
+        return seq_open_net(inode, file, &dev_mc_seq_ops,
+                            sizeof(struct seq_net_private));
+}
+
+static const struct file_operations dev_mc_seq_fops = {
+        .owner   = THIS_MODULE,
+        .open    = dev_mc_seq_open,
+        .read    = seq_read,
+        .llseek  = seq_lseek,
+        .release = seq_release_net,
+};
+
+#endif
+
+static int __net_init dev_mc_net_init(struct net *net)
+{
+        if (!proc_net_fops_create(net, "dev_mcast", 0, &dev_mc_seq_fops))
+                return -ENOMEM;
+        return 0;
+}
+
+static void __net_exit dev_mc_net_exit(struct net *net)
+{
+        proc_net_remove(net, "dev_mcast");
+}
+
+static struct pernet_operations __net_initdata dev_mc_net_ops = {
+        .init = dev_mc_net_init,
+        .exit = dev_mc_net_exit,
+};
+
+void __init dev_mcast_init(void)
+{
+        register_pernet_subsys(&dev_mc_net_ops);
+}
+
diff --git a/net/core/dev_mcast.c b/net/core/dev_mcast.c
deleted file mode 100644
index fd91569e2394..000000000000
--- a/net/core/dev_mcast.c
+++ /dev/null
@@ -1,231 +0,0 @@
-/*
- *      Linux NET3:     Multicast List maintenance.
- *
- *      Authors:
- *              Tim Kordas <tjk@nostromo.eeap.cwru.edu>
- *              Richard Underwood <richard@wuzz.demon.co.uk>
- *
- *      Stir fried together from the IP multicast and CAP patches above
- *              Alan Cox <alan@lxorguk.ukuu.org.uk>
- *
- *      Fixes:
- *              Alan Cox        :       Update the device on a real delete
- *                                      rather than any time but...
- *              Alan Cox        :       IFF_ALLMULTI support.
- *              Alan Cox        :       New format set_multicast_list() calls.
- *              Gleb Natapov    :       Remove dev_mc_lock.
- *
- *      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.
- */
-
-#include <linux/module.h>
-#include <asm/uaccess.h>
-#include <asm/system.h>
-#include <linux/bitops.h>
-#include <linux/types.h>
-#include <linux/kernel.h>
-#include <linux/string.h>
-#include <linux/mm.h>
-#include <linux/socket.h>
-#include <linux/sockios.h>
-#include <linux/in.h>
-#include <linux/errno.h>
-#include <linux/interrupt.h>
-#include <linux/if_ether.h>
-#include <linux/inet.h>
-#include <linux/netdevice.h>
-#include <linux/etherdevice.h>
-#include <linux/proc_fs.h>
-#include <linux/seq_file.h>
-#include <linux/init.h>
-#include <net/net_namespace.h>
-#include <net/ip.h>
-#include <net/route.h>
-#include <linux/skbuff.h>
-#include <net/sock.h>
-#include <net/arp.h>
-
-
-/*
- *      Device multicast list maintenance.
- *
- *      This is used both by IP and by the user level maintenance functions.
- *      Unlike BSD we maintain a usage count on a given multicast address so
- *      that a casual user application can add/delete multicasts used by
- *      protocols without doing damage to the protocols when it deletes the
- *      entries. It also helps IP as it tracks overlapping maps.
- *
- *      Device mc lists are changed by bh at least if IPv6 is enabled,
- *      so that it must be bh protected.
- *
- *      We block accesses to device mc filters with netif_tx_lock.
- */
-
-/*
- *      Delete a device level multicast
- */
-
-int dev_mc_delete(struct net_device *dev, void *addr, int alen, int glbl)
-{
-        int err;
-
-        netif_addr_lock_bh(dev);
-        err = __dev_addr_delete(&dev->mc_list, &dev->mc_count,
-                                addr, alen, glbl);
-        if (!err) {
-                /*
-                 *      We have altered the list, so the card
-                 *      loaded filter is now wrong. Fix it
-                 */
-
-                __dev_set_rx_mode(dev);
-        }
-        netif_addr_unlock_bh(dev);
-        return err;
-}
-
-/*
- *      Add a device level multicast
- */
-
-int dev_mc_add(struct net_device *dev, void *addr, int alen, int glbl)
-{
-        int err;
-
-        netif_addr_lock_bh(dev);
-        if (alen != dev->addr_len)
-                return -EINVAL;
-        err = __dev_addr_add(&dev->mc_list, &dev->mc_count, addr, alen, glbl);
-        if (!err)
-                __dev_set_rx_mode(dev);
-        netif_addr_unlock_bh(dev);
-        return err;
-}
-
-/**
- *      dev_mc_sync     - Synchronize device's multicast list to another device
- *      @to: destination device
- *      @from: source device
- *
- *      Add newly added addresses to the destination device and release
- *      addresses that have no users left. The source device must be
- *      locked by netif_tx_lock_bh.
- *
- *      This function is intended to be called from the dev->set_multicast_list
- *      or dev->set_rx_mode function of layered software devices.
- */
-int dev_mc_sync(struct net_device *to, struct net_device *from)
-{
-        int err = 0;
-
-        netif_addr_lock_bh(to);
-        err = __dev_addr_sync(&to->mc_list, &to->mc_count,
-                              &from->mc_list, &from->mc_count);
-        if (!err)
-                __dev_set_rx_mode(to);
-        netif_addr_unlock_bh(to);
-
-        return err;
-}
-EXPORT_SYMBOL(dev_mc_sync);
-
-
-/**
- *      dev_mc_unsync   - Remove synchronized addresses from the destination
- *                        device
- *      @to: destination device
- *      @from: source device
- *
- *      Remove all addresses that were added to the destination device by
- *      dev_mc_sync(). This function is intended to be called from the
- *      dev->stop function of layered software devices.
- */
-void dev_mc_unsync(struct net_device *to, struct net_device *from)
-{
-        netif_addr_lock_bh(from);
-        netif_addr_lock(to);
-
-        __dev_addr_unsync(&to->mc_list, &to->mc_count,
-                          &from->mc_list, &from->mc_count);
-        __dev_set_rx_mode(to);
-
-        netif_addr_unlock(to);
-        netif_addr_unlock_bh(from);
-}
-EXPORT_SYMBOL(dev_mc_unsync);
-
-#ifdef CONFIG_PROC_FS
-static int dev_mc_seq_show(struct seq_file *seq, void *v)
-{
-        struct dev_addr_list *m;
-        struct net_device *dev = v;
-
-        if (v == SEQ_START_TOKEN)
-                return 0;
-
-        netif_addr_lock_bh(dev);
-        for (m = dev->mc_list; m; m = m->next) {
-                int i;
-
-                seq_printf(seq, "%-4d %-15s %-5d %-5d ", dev->ifindex,
-                           dev->name, m->dmi_users, m->dmi_gusers);
-
-                for (i = 0; i < m->dmi_addrlen; i++)
-                        seq_printf(seq, "%02x", m->dmi_addr[i]);
-
-                seq_putc(seq, '\n');
-        }
-        netif_addr_unlock_bh(dev);
-        return 0;
-}
-
-static const struct seq_operations dev_mc_seq_ops = {
-        .start = dev_seq_start,
-        .next  = dev_seq_next,
-        .stop  = dev_seq_stop,
-        .show  = dev_mc_seq_show,
-};
-
-static int dev_mc_seq_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &dev_mc_seq_ops,
-                            sizeof(struct seq_net_private));
-}
-
-static const struct file_operations dev_mc_seq_fops = {
-        .owner   = THIS_MODULE,
-        .open    = dev_mc_seq_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release_net,
-};
-
-#endif
-
-static int __net_init dev_mc_net_init(struct net *net)
-{
-        if (!proc_net_fops_create(net, "dev_mcast", 0, &dev_mc_seq_fops))
-                return -ENOMEM;
-        return 0;
-}
-
-static void __net_exit dev_mc_net_exit(struct net *net)
-{
-        proc_net_remove(net, "dev_mcast");
-}
-
-static struct pernet_operations __net_initdata dev_mc_net_ops = {
-        .init = dev_mc_net_init,
-        .exit = dev_mc_net_exit,
-};
-
-void __init dev_mcast_init(void)
-{
-        register_pernet_subsys(&dev_mc_net_ops);
-}
-
-EXPORT_SYMBOL(dev_mc_add);
-EXPORT_SYMBOL(dev_mc_delete);
diff --git a/net/core/drop_monitor.c b/net/core/drop_monitor.c
index f8c874975350..cf208d8042b1 100644
--- a/net/core/drop_monitor.c
+++ b/net/core/drop_monitor.c
@@ -21,6 +21,7 @@
 #include <linux/percpu.h>
 #include <linux/timer.h>
 #include <linux/bitops.h>
+#include <linux/slab.h>
 #include <net/genetlink.h>
 #include <net/netevent.h>
 
diff --git a/net/core/dst.c b/net/core/dst.c
index cb1b3488b739..9920722cc82b 100644
--- a/net/core/dst.c
+++ b/net/core/dst.c
@@ -12,6 +12,7 @@
 #include <linux/workqueue.h>
 #include <linux/mm.h>
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/netdevice.h>
 #include <linux/skbuff.h>
 #include <linux/string.h>
@@ -43,7 +44,7 @@ static atomic_t			 dst_total = ATOMIC_INIT(0);
  */
 static struct {
         spinlock_t              lock;
-        struct dst_entry        *list;
+        struct dst_entry        *list;
         unsigned long           timer_inc;
         unsigned long           timer_expires;
 } dst_garbage = {
@@ -51,7 +52,7 @@ static struct {
         .timer_inc = DST_GC_MAX,
 };
 static void dst_gc_task(struct work_struct *work);
-static void ___dst_free(struct dst_entry * dst);
+static void ___dst_free(struct dst_entry *dst);
 
 static DECLARE_DELAYED_WORK(dst_gc_work, dst_gc_task);
 
@@ -135,8 +136,8 @@ loop:
                 }
                 expires = dst_garbage.timer_expires;
                 /*
-                 * if the next desired timer is more than 4 seconds in the future
-                 * then round the timer to whole seconds
+                 * if the next desired timer is more than 4 seconds in the
+                 * future then round the timer to whole seconds
                  */
                 if (expires > 4*HZ)
                         expires = round_jiffies_relative(expires);
@@ -151,7 +152,8 @@ loop:
                 " expires: %lu elapsed: %lu us\n",
                 atomic_read(&dst_total), delayed, work_performed,
                 expires,
-                elapsed.tv_sec * USEC_PER_SEC + elapsed.tv_nsec / NSEC_PER_USEC);
+                elapsed.tv_sec * USEC_PER_SEC +
+                  elapsed.tv_nsec / NSEC_PER_USEC);
 #endif
 }
 
@@ -162,9 +164,9 @@ int dst_discard(struct sk_buff *skb)
 }
 EXPORT_SYMBOL(dst_discard);
 
-void * dst_alloc(struct dst_ops * ops)
+void *dst_alloc(struct dst_ops *ops)
 {
-        struct dst_entry * dst;
+        struct dst_entry *dst;
 
         if (ops->gc && atomic_read(&ops->entries) > ops->gc_thresh) {
                 if (ops->gc(ops))
@@ -184,19 +186,20 @@ void * dst_alloc(struct dst_ops * ops)
         atomic_inc(&ops->entries);
         return dst;
 }
+EXPORT_SYMBOL(dst_alloc);
 
-static void ___dst_free(struct dst_entry * dst)
+static void ___dst_free(struct dst_entry *dst)
 {
         /* The first case (dev==NULL) is required, when
            protocol module is unloaded.
          */
-        if (dst->dev == NULL || !(dst->dev->flags&IFF_UP)) {
+        if (dst->dev == NULL || !(dst->dev->flags&IFF_UP))
                 dst->input = dst->output = dst_discard;
-        }
         dst->obsolete = 2;
 }
+EXPORT_SYMBOL(__dst_free);
 
-void __dst_free(struct dst_entry * dst)
+void __dst_free(struct dst_entry *dst)
 {
         spin_lock_bh(&dst_garbage.lock);
         ___dst_free(dst);
@@ -261,15 +264,16 @@ again:
         }
         return NULL;
 }
+EXPORT_SYMBOL(dst_destroy);
 
 void dst_release(struct dst_entry *dst)
 {
         if (dst) {
-               int newrefcnt;
+                int newrefcnt;
 
                 smp_mb__before_atomic_dec();
-               newrefcnt = atomic_dec_return(&dst->__refcnt);
-               WARN_ON(newrefcnt < 0);
+                newrefcnt = atomic_dec_return(&dst->__refcnt);
+                WARN_ON(newrefcnt < 0);
         }
 }
 EXPORT_SYMBOL(dst_release);
@@ -282,8 +286,8 @@ EXPORT_SYMBOL(dst_release);
  *
  * Commented and originally written by Alexey.
  */
-static inline void dst_ifdown(struct dst_entry *dst, struct net_device *dev,
-                              int unregister)
+static void dst_ifdown(struct dst_entry *dst, struct net_device *dev,
+                       int unregister)
 {
         if (dst->ops->ifdown)
                 dst->ops->ifdown(dst, dev, unregister);
@@ -305,7 +309,8 @@ static inline void dst_ifdown(struct dst_entry *dst, struct net_device *dev,
         }
 }
 
-static int dst_dev_event(struct notifier_block *this, unsigned long event, void *ptr)
+static int dst_dev_event(struct notifier_block *this, unsigned long event,
+                         void *ptr)
 {
         struct net_device *dev = ptr;
         struct dst_entry *dst, *last = NULL;
@@ -328,9 +333,8 @@ static int dst_dev_event(struct notifier_block *this, unsigned long event, void
                         last->next = dst;
                 else
                         dst_busy_list = dst;
-                for (; dst; dst = dst->next) {
+                for (; dst; dst = dst->next)
                         dst_ifdown(dst, dev, event != NETDEV_DOWN);
-                }
                 mutex_unlock(&dst_gc_mutex);
                 break;
         }
@@ -345,7 +349,3 @@ void __init dst_init(void)
 {
         register_netdevice_notifier(&dst_dev_notifier);
 }
-
-EXPORT_SYMBOL(__dst_free);
-EXPORT_SYMBOL(dst_alloc);
-EXPORT_SYMBOL(dst_destroy);
diff --git a/net/core/ethtool.c b/net/core/ethtool.c
index f4cb6b6299d9..1a7db92037fa 100644
--- a/net/core/ethtool.c
+++ b/net/core/ethtool.c
@@ -18,7 +18,8 @@
 #include <linux/ethtool.h>
 #include <linux/netdevice.h>
 #include <linux/bitops.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
+#include <linux/slab.h>
 
 /*
  * Some useful ethtool_ops methods that're device independent.
@@ -30,6 +31,7 @@ u32 ethtool_op_get_link(struct net_device *dev)
 {
         return netif_carrier_ok(dev) ? 1 : 0;
 }
+EXPORT_SYMBOL(ethtool_op_get_link);
 
 u32 ethtool_op_get_rx_csum(struct net_device *dev)
 {
@@ -62,6 +64,7 @@ int ethtool_op_set_tx_hw_csum(struct net_device *dev, u32 data)
 
         return 0;
 }
+EXPORT_SYMBOL(ethtool_op_set_tx_hw_csum);
 
 int ethtool_op_set_tx_ipv6_csum(struct net_device *dev, u32 data)
 {
@@ -72,11 +75,13 @@ int ethtool_op_set_tx_ipv6_csum(struct net_device *dev, u32 data)
 
         return 0;
 }
+EXPORT_SYMBOL(ethtool_op_set_tx_ipv6_csum);
 
 u32 ethtool_op_get_sg(struct net_device *dev)
 {
         return (dev->features & NETIF_F_SG) != 0;
 }
+EXPORT_SYMBOL(ethtool_op_get_sg);
 
 int ethtool_op_set_sg(struct net_device *dev, u32 data)
 {
@@ -87,11 +92,13 @@ int ethtool_op_set_sg(struct net_device *dev, u32 data)
 
         return 0;
 }
+EXPORT_SYMBOL(ethtool_op_set_sg);
 
 u32 ethtool_op_get_tso(struct net_device *dev)
 {
         return (dev->features & NETIF_F_TSO) != 0;
 }
+EXPORT_SYMBOL(ethtool_op_get_tso);
 
 int ethtool_op_set_tso(struct net_device *dev, u32 data)
 {
@@ -102,11 +109,13 @@ int ethtool_op_set_tso(struct net_device *dev, u32 data)
 
         return 0;
 }
+EXPORT_SYMBOL(ethtool_op_set_tso);
 
 u32 ethtool_op_get_ufo(struct net_device *dev)
 {
         return (dev->features & NETIF_F_UFO) != 0;
 }
+EXPORT_SYMBOL(ethtool_op_get_ufo);
 
 int ethtool_op_set_ufo(struct net_device *dev, u32 data)
 {
@@ -116,12 +125,13 @@ int ethtool_op_set_ufo(struct net_device *dev, u32 data)
                 dev->features &= ~NETIF_F_UFO;
         return 0;
 }
+EXPORT_SYMBOL(ethtool_op_set_ufo);
 
 /* the following list of flags are the same as their associated
  * NETIF_F_xxx values in include/linux/netdevice.h
  */
 static const u32 flags_dup_features =
-        (ETH_FLAG_LRO | ETH_FLAG_NTUPLE);
+        (ETH_FLAG_LRO | ETH_FLAG_NTUPLE | ETH_FLAG_RXHASH);
 
 u32 ethtool_op_get_flags(struct net_device *dev)
 {
@@ -132,6 +142,7 @@ u32 ethtool_op_get_flags(struct net_device *dev)
 
         return dev->features & flags_dup_features;
 }
+EXPORT_SYMBOL(ethtool_op_get_flags);
 
 int ethtool_op_set_flags(struct net_device *dev, u32 data)
 {
@@ -152,9 +163,15 @@ int ethtool_op_set_flags(struct net_device *dev, u32 data)
                 features &= ~NETIF_F_NTUPLE;
         }
 
+        if (data & ETH_FLAG_RXHASH)
+                features |= NETIF_F_RXHASH;
+        else
+                features &= ~NETIF_F_RXHASH;
+
         dev->features = features;
         return 0;
 }
+EXPORT_SYMBOL(ethtool_op_set_flags);
 
 void ethtool_ntuple_flush(struct net_device *dev)
 {
@@ -200,7 +217,8 @@ static int ethtool_set_settings(struct net_device *dev, void __user *useraddr)
         return dev->ethtool_ops->set_settings(dev, &cmd);
 }
 
-static noinline_for_stack int ethtool_get_drvinfo(struct net_device *dev, void __user *useraddr)
+static noinline_for_stack int ethtool_get_drvinfo(struct net_device *dev,
+                                                  void __user *useraddr)
 {
         struct ethtool_drvinfo info;
         const struct ethtool_ops *ops = dev->ethtool_ops;
@@ -240,7 +258,7 @@ static noinline_for_stack int ethtool_get_drvinfo(struct net_device *dev, void _
 }
 
 static noinline_for_stack int ethtool_get_sset_info(struct net_device *dev,
-                                          void __user *useraddr)
+                                                    void __user *useraddr)
 {
         struct ethtool_sset_info info;
         const struct ethtool_ops *ops = dev->ethtool_ops;
@@ -299,7 +317,8 @@ out:
         return ret;
 }
 
-static noinline_for_stack int ethtool_set_rxnfc(struct net_device *dev, void __user *useraddr)
+static noinline_for_stack int ethtool_set_rxnfc(struct net_device *dev,
+                                                void __user *useraddr)
 {
         struct ethtool_rxnfc cmd;
 
@@ -312,7 +331,8 @@ static noinline_for_stack int ethtool_set_rxnfc(struct net_device *dev, void __u
         return dev->ethtool_ops->set_rxnfc(dev, &cmd);
 }
 
-static noinline_for_stack int ethtool_get_rxnfc(struct net_device *dev, void __user *useraddr)
+static noinline_for_stack int ethtool_get_rxnfc(struct net_device *dev,
+                                                void __user *useraddr)
 {
         struct ethtool_rxnfc info;
         const struct ethtool_ops *ops = dev->ethtool_ops;
@@ -357,8 +377,8 @@ err_out:
 }
 
 static void __rx_ntuple_filter_add(struct ethtool_rx_ntuple_list *list,
-                              struct ethtool_rx_ntuple_flow_spec *spec,
-                              struct ethtool_rx_ntuple_flow_spec_container *fsc)
+                        struct ethtool_rx_ntuple_flow_spec *spec,
+                        struct ethtool_rx_ntuple_flow_spec_container *fsc)
 {
 
         /* don't add filters forever */
@@ -384,7 +404,8 @@ static void __rx_ntuple_filter_add(struct ethtool_rx_ntuple_list *list,
         list->count++;
 }
 
-static noinline_for_stack int ethtool_set_rx_ntuple(struct net_device *dev, void __user *useraddr)
+static noinline_for_stack int ethtool_set_rx_ntuple(struct net_device *dev,
+                                                    void __user *useraddr)
 {
         struct ethtool_rx_ntuple cmd;
         const struct ethtool_ops *ops = dev->ethtool_ops;
@@ -509,125 +530,125 @@ static int ethtool_get_rx_ntuple(struct net_device *dev, void __user *useraddr)
                 case UDP_V4_FLOW:
                 case SCTP_V4_FLOW:
                         sprintf(p, "\tSrc IP addr: 0x%x\n",
-                                fsc->fs.h_u.tcp_ip4_spec.ip4src);
+                                fsc->fs.h_u.tcp_ip4_spec.ip4src);
                         p += ETH_GSTRING_LEN;
                         num_strings++;
                         sprintf(p, "\tSrc IP mask: 0x%x\n",
-                                fsc->fs.m_u.tcp_ip4_spec.ip4src);
+                                fsc->fs.m_u.tcp_ip4_spec.ip4src);
                         p += ETH_GSTRING_LEN;
                         num_strings++;
                         sprintf(p, "\tDest IP addr: 0x%x\n",
-                                fsc->fs.h_u.tcp_ip4_spec.ip4dst);
+                                fsc->fs.h_u.tcp_ip4_spec.ip4dst);
                         p += ETH_GSTRING_LEN;
                         num_strings++;
                         sprintf(p, "\tDest IP mask: 0x%x\n",
-                                fsc->fs.m_u.tcp_ip4_spec.ip4dst);
+                                fsc->fs.m_u.tcp_ip4_spec.ip4dst);
                         p += ETH_GSTRING_LEN;
                         num_strings++;
                         sprintf(p, "\tSrc Port: %d, mask: 0x%x\n",
-                                fsc->fs.h_u.tcp_ip4_spec.psrc,
-                                fsc->fs.m_u.tcp_ip4_spec.psrc);
+                                fsc->fs.h_u.tcp_ip4_spec.psrc,
+                                fsc->fs.m_u.tcp_ip4_spec.psrc);
                         p += ETH_GSTRING_LEN;
                         num_strings++;
                         sprintf(p, "\tDest Port: %d, mask: 0x%x\n",
-                                fsc->fs.h_u.tcp_ip4_spec.pdst,
-                                fsc->fs.m_u.tcp_ip4_spec.pdst);
+                                fsc->fs.h_u.tcp_ip4_spec.pdst,
+                                fsc->fs.m_u.tcp_ip4_spec.pdst);
                         p += ETH_GSTRING_LEN;
                         num_strings++;
                         sprintf(p, "\tTOS: %d, mask: 0x%x\n",
-                                fsc->fs.h_u.tcp_ip4_spec.tos,
-                                fsc->fs.m_u.tcp_ip4_spec.tos);
+                                fsc->fs.h_u.tcp_ip4_spec.tos,
+                                fsc->fs.m_u.tcp_ip4_spec.tos);
                         p += ETH_GSTRING_LEN;
                         num_strings++;
                         break;
                 case AH_ESP_V4_FLOW:
                 case ESP_V4_FLOW:
                         sprintf(p, "\tSrc IP addr: 0x%x\n",
-                                fsc->fs.h_u.ah_ip4_spec.ip4src);
+                                fsc->fs.h_u.ah_ip4_spec.ip4src);
                         p += ETH_GSTRING_LEN;
                         num_strings++;
                         sprintf(p, "\tSrc IP mask: 0x%x\n",
-                                fsc->fs.m_u.ah_ip4_spec.ip4src);
+                                fsc->fs.m_u.ah_ip4_spec.ip4src);
                         p += ETH_GSTRING_LEN;
                         num_strings++;
                         sprintf(p, "\tDest IP addr: 0x%x\n",
-                                fsc->fs.h_u.ah_ip4_spec.ip4dst);
+                                fsc->fs.h_u.ah_ip4_spec.ip4dst);
                         p += ETH_GSTRING_LEN;
                         num_strings++;
                         sprintf(p, "\tDest IP mask: 0x%x\n",
-                                fsc->fs.m_u.ah_ip4_spec.ip4dst);
+                                fsc->fs.m_u.ah_ip4_spec.ip4dst);
                         p += ETH_GSTRING_LEN;
                         num_strings++;
                         sprintf(p, "\tSPI: %d, mask: 0x%x\n",
-                                fsc->fs.h_u.ah_ip4_spec.spi,
-                                fsc->fs.m_u.ah_ip4_spec.spi);
+                                fsc->fs.h_u.ah_ip4_spec.spi,
+                                fsc->fs.m_u.ah_ip4_spec.spi);
                         p += ETH_GSTRING_LEN;
                         num_strings++;
                         sprintf(p, "\tTOS: %d, mask: 0x%x\n",
-                                fsc->fs.h_u.ah_ip4_spec.tos,
-                                fsc->fs.m_u.ah_ip4_spec.tos);
+                                fsc->fs.h_u.ah_ip4_spec.tos,
+                                fsc->fs.m_u.ah_ip4_spec.tos);
                         p += ETH_GSTRING_LEN;
                         num_strings++;
                         break;
                 case IP_USER_FLOW:
                         sprintf(p, "\tSrc IP addr: 0x%x\n",
-                                fsc->fs.h_u.raw_ip4_spec.ip4src);
+                                fsc->fs.h_u.raw_ip4_spec.ip4src);
                         p += ETH_GSTRING_LEN;
                         num_strings++;
                         sprintf(p, "\tSrc IP mask: 0x%x\n",
-                                fsc->fs.m_u.raw_ip4_spec.ip4src);
+                                fsc->fs.m_u.raw_ip4_spec.ip4src);
                         p += ETH_GSTRING_LEN;
                         num_strings++;
                         sprintf(p, "\tDest IP addr: 0x%x\n",
-                                fsc->fs.h_u.raw_ip4_spec.ip4dst);
+                                fsc->fs.h_u.raw_ip4_spec.ip4dst);
                         p += ETH_GSTRING_LEN;
                         num_strings++;
                         sprintf(p, "\tDest IP mask: 0x%x\n",
-                                fsc->fs.m_u.raw_ip4_spec.ip4dst);
+                                fsc->fs.m_u.raw_ip4_spec.ip4dst);
                         p += ETH_GSTRING_LEN;
                         num_strings++;
                         break;
                 case IPV4_FLOW:
                         sprintf(p, "\tSrc IP addr: 0x%x\n",
-                                fsc->fs.h_u.usr_ip4_spec.ip4src);
+                                fsc->fs.h_u.usr_ip4_spec.ip4src);
                         p += ETH_GSTRING_LEN;
                         num_strings++;
                         sprintf(p, "\tSrc IP mask: 0x%x\n",
-                                fsc->fs.m_u.usr_ip4_spec.ip4src);
+                                fsc->fs.m_u.usr_ip4_spec.ip4src);
                         p += ETH_GSTRING_LEN;
                         num_strings++;
                         sprintf(p, "\tDest IP addr: 0x%x\n",
-                                fsc->fs.h_u.usr_ip4_spec.ip4dst);
+                                fsc->fs.h_u.usr_ip4_spec.ip4dst);
                         p += ETH_GSTRING_LEN;
                         num_strings++;
                         sprintf(p, "\tDest IP mask: 0x%x\n",
-                                fsc->fs.m_u.usr_ip4_spec.ip4dst);
+                                fsc->fs.m_u.usr_ip4_spec.ip4dst);
                         p += ETH_GSTRING_LEN;
                         num_strings++;
                         sprintf(p, "\tL4 bytes: 0x%x, mask: 0x%x\n",
-                                fsc->fs.h_u.usr_ip4_spec.l4_4_bytes,
-                                fsc->fs.m_u.usr_ip4_spec.l4_4_bytes);
+                                fsc->fs.h_u.usr_ip4_spec.l4_4_bytes,
+                                fsc->fs.m_u.usr_ip4_spec.l4_4_bytes);
                         p += ETH_GSTRING_LEN;
                         num_strings++;
                         sprintf(p, "\tTOS: %d, mask: 0x%x\n",
-                                fsc->fs.h_u.usr_ip4_spec.tos,
-                                fsc->fs.m_u.usr_ip4_spec.tos);
+                                fsc->fs.h_u.usr_ip4_spec.tos,
+                                fsc->fs.m_u.usr_ip4_spec.tos);
                         p += ETH_GSTRING_LEN;
                         num_strings++;
                         sprintf(p, "\tIP Version: %d, mask: 0x%x\n",
-                                fsc->fs.h_u.usr_ip4_spec.ip_ver,
-                                fsc->fs.m_u.usr_ip4_spec.ip_ver);
+                                fsc->fs.h_u.usr_ip4_spec.ip_ver,
+                                fsc->fs.m_u.usr_ip4_spec.ip_ver);
                         p += ETH_GSTRING_LEN;
                         num_strings++;
                         sprintf(p, "\tProtocol: %d, mask: 0x%x\n",
-                                fsc->fs.h_u.usr_ip4_spec.proto,
-                                fsc->fs.m_u.usr_ip4_spec.proto);
+                                fsc->fs.h_u.usr_ip4_spec.proto,
+                                fsc->fs.m_u.usr_ip4_spec.proto);
                         p += ETH_GSTRING_LEN;
                         num_strings++;
                         break;
                 };
                 sprintf(p, "\tVLAN: %d, mask: 0x%x\n",
-                        fsc->fs.vlan_tag, fsc->fs.vlan_tag_mask);
+                        fsc->fs.vlan_tag, fsc->fs.vlan_tag_mask);
                 p += ETH_GSTRING_LEN;
                 num_strings++;
                 sprintf(p, "\tUser-defined: 0x%Lx\n", fsc->fs.data);
@@ -640,7 +661,7 @@ static int ethtool_get_rx_ntuple(struct net_device *dev, void __user *useraddr)
                         sprintf(p, "\tAction: Drop\n");
                 else
                         sprintf(p, "\tAction: Direct to queue %d\n",
-                                fsc->fs.action);
+                                fsc->fs.action);
                 p += ETH_GSTRING_LEN;
                 num_strings++;
 unknown_filter:
@@ -852,7 +873,8 @@ static int ethtool_set_eeprom(struct net_device *dev, void __user *useraddr)
         return ret;
 }
 
-static noinline_for_stack int ethtool_get_coalesce(struct net_device *dev, void __user *useraddr)
+static noinline_for_stack int ethtool_get_coalesce(struct net_device *dev,
+                                                   void __user *useraddr)
 {
         struct ethtool_coalesce coalesce = { .cmd = ETHTOOL_GCOALESCE };
 
@@ -866,7 +888,8 @@ static noinline_for_stack int ethtool_get_coalesce(struct net_device *dev, void
         return 0;
 }
 
-static noinline_for_stack int ethtool_set_coalesce(struct net_device *dev, void __user *useraddr)
+static noinline_for_stack int ethtool_set_coalesce(struct net_device *dev,
+                                                   void __user *useraddr)
 {
         struct ethtool_coalesce coalesce;
 
@@ -970,6 +993,7 @@ static int ethtool_set_tx_csum(struct net_device *dev, char __user *useraddr)
 
         return dev->ethtool_ops->set_tx_csum(dev, edata.data);
 }
+EXPORT_SYMBOL(ethtool_op_set_tx_csum);
 
 static int ethtool_set_rx_csum(struct net_device *dev, char __user *useraddr)
 {
@@ -1041,7 +1065,7 @@ static int ethtool_get_gso(struct net_device *dev, char __user *useraddr)
 
         edata.data = dev->features & NETIF_F_GSO;
         if (copy_to_user(useraddr, &edata, sizeof(edata)))
-                 return -EFAULT;
+                return -EFAULT;
         return 0;
 }
 
@@ -1064,7 +1088,7 @@ static int ethtool_get_gro(struct net_device *dev, char __user *useraddr)
 
         edata.data = dev->features & NETIF_F_GRO;
         if (copy_to_user(useraddr, &edata, sizeof(edata)))
-                 return -EFAULT;
+                return -EFAULT;
         return 0;
 }
 
@@ -1276,7 +1300,8 @@ static int ethtool_set_value(struct net_device *dev, char __user *useraddr,
         return actor(dev, edata.data);
 }
 
-static noinline_for_stack int ethtool_flash_device(struct net_device *dev, char __user *useraddr)
+static noinline_for_stack int ethtool_flash_device(struct net_device *dev,
+                                                   char __user *useraddr)
 {
         struct ethtool_flash efl;
 
@@ -1305,11 +1330,11 @@ int dev_ethtool(struct net *net, struct ifreq *ifr)
         if (!dev->ethtool_ops)
                 return -EOPNOTSUPP;
 
-        if (copy_from_user(&ethcmd, useraddr, sizeof (ethcmd)))
+        if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
                 return -EFAULT;
 
         /* Allow some commands to be done by anyone */
-        switch(ethcmd) {
+        switch (ethcmd) {
         case ETHTOOL_GDRVINFO:
         case ETHTOOL_GMSGLVL:
         case ETHTOOL_GCOALESCE:
@@ -1337,10 +1362,11 @@ int dev_ethtool(struct net *net, struct ifreq *ifr)
                         return -EPERM;
         }
 
-        if (dev->ethtool_ops->begin)
-                if ((rc = dev->ethtool_ops->begin(dev)) < 0)
+        if (dev->ethtool_ops->begin) {
+                rc = dev->ethtool_ops->begin(dev);
+                if (rc  < 0)
                         return rc;
-
+        }
         old_features = dev->features;
 
         switch (ethcmd) {
@@ -1530,16 +1556,3 @@ int dev_ethtool(struct net *net, struct ifreq *ifr)
 
         return rc;
 }
-
-EXPORT_SYMBOL(ethtool_op_get_link);
-EXPORT_SYMBOL(ethtool_op_get_sg);
-EXPORT_SYMBOL(ethtool_op_get_tso);
-EXPORT_SYMBOL(ethtool_op_set_sg);
-EXPORT_SYMBOL(ethtool_op_set_tso);
-EXPORT_SYMBOL(ethtool_op_set_tx_csum);
-EXPORT_SYMBOL(ethtool_op_set_tx_hw_csum);
-EXPORT_SYMBOL(ethtool_op_set_tx_ipv6_csum);
-EXPORT_SYMBOL(ethtool_op_set_ufo);
-EXPORT_SYMBOL(ethtool_op_get_ufo);
-EXPORT_SYMBOL(ethtool_op_set_flags);
-EXPORT_SYMBOL(ethtool_op_get_flags);
diff --git a/net/core/fib_rules.c b/net/core/fib_rules.c
index 9a24377146bf..42e84e08a1be 100644
--- a/net/core/fib_rules.c
+++ b/net/core/fib_rules.c
@@ -10,6 +10,7 @@
 
 #include <linux/types.h>
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/list.h>
 #include <net/net_namespace.h>
 #include <net/sock.h>
@@ -38,6 +39,24 @@ int fib_default_rule_add(struct fib_rules_ops *ops,
 }
 EXPORT_SYMBOL(fib_default_rule_add);
 
+u32 fib_default_rule_pref(struct fib_rules_ops *ops)
+{
+        struct list_head *pos;
+        struct fib_rule *rule;
+
+        if (!list_empty(&ops->rules_list)) {
+                pos = ops->rules_list.next;
+                if (pos->next != &ops->rules_list) {
+                        rule = list_entry(pos->next, struct fib_rule, list);
+                        if (rule->pref)
+                                return rule->pref - 1;
+                }
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL(fib_default_rule_pref);
+
 static void notify_rule_change(int event, struct fib_rule *rule,
                                struct fib_rules_ops *ops, struct nlmsghdr *nlh,
                                u32 pid);
@@ -103,12 +122,12 @@ errout:
 }
 
 struct fib_rules_ops *
-fib_rules_register(struct fib_rules_ops *tmpl, struct net *net)
+fib_rules_register(const struct fib_rules_ops *tmpl, struct net *net)
 {
         struct fib_rules_ops *ops;
         int err;
 
-        ops = kmemdup(tmpl, sizeof (*ops), GFP_KERNEL);
+        ops = kmemdup(tmpl, sizeof(*ops), GFP_KERNEL);
         if (ops == NULL)
                 return ERR_PTR(-ENOMEM);
 
@@ -123,7 +142,6 @@ fib_rules_register(struct fib_rules_ops *tmpl, struct net *net)
 
         return ops;
 }
-
 EXPORT_SYMBOL_GPL(fib_rules_register);
 
 void fib_rules_cleanup_ops(struct fib_rules_ops *ops)
@@ -157,7 +175,6 @@ void fib_rules_unregister(struct fib_rules_ops *ops)
 
         call_rcu(&ops->rcu, fib_rules_put_rcu);
 }
-
 EXPORT_SYMBOL_GPL(fib_rules_unregister);
 
 static int fib_rule_match(struct fib_rule *rule, struct fib_rules_ops *ops,
@@ -220,7 +237,6 @@ out:
 
         return err;
 }
-
 EXPORT_SYMBOL_GPL(fib_rules_lookup);
 
 static int validate_rulemsg(struct fib_rule_hdr *frh, struct nlattr **tb,
@@ -519,6 +535,7 @@ static int fib_nl_fill_rule(struct sk_buff *skb, struct fib_rule *rule,
                 return -EMSGSIZE;
 
         frh = nlmsg_data(nlh);
+        frh->family = ops->family;
         frh->table = rule->table;
         NLA_PUT_U32(skb, FRA_TABLE, rule->table);
         frh->res1 = 0;
@@ -613,7 +630,7 @@ static int fib_nl_dumprule(struct sk_buff *skb, struct netlink_callback *cb)
                         break;
 
                 cb->args[1] = 0;
-        skip:
+skip:
                 idx++;
         }
         rcu_read_unlock();
@@ -685,7 +702,6 @@ static int fib_rules_event(struct notifier_block *this, unsigned long event,
         struct fib_rules_ops *ops;
 
         ASSERT_RTNL();
-        rcu_read_lock();
 
         switch (event) {
         case NETDEV_REGISTER:
@@ -699,8 +715,6 @@ static int fib_rules_event(struct notifier_block *this, unsigned long event,
                 break;
         }
 
-        rcu_read_unlock();
-
         return NOTIFY_DONE;
 }
 
diff --git a/net/core/filter.c b/net/core/filter.c
index d38ef7fd50f0..da69fb728d32 100644
--- a/net/core/filter.c
+++ b/net/core/filter.c
@@ -25,6 +25,7 @@
 #include <linux/inet.h>
 #include <linux/netdevice.h>
 #include <linux/if_packet.h>
+#include <linux/gfp.h>
 #include <net/ip.h>
 #include <net/protocol.h>
 #include <net/netlink.h>
@@ -301,6 +302,8 @@ load_b:
                         A = skb->pkt_type;
                         continue;
                 case SKF_AD_IFINDEX:
+                        if (!skb->dev)
+                                return 0;
                         A = skb->dev->ifindex;
                         continue;
                 case SKF_AD_MARK:
@@ -309,6 +312,11 @@ load_b:
                 case SKF_AD_QUEUE:
                         A = skb->queue_mapping;
                         continue;
+                case SKF_AD_HATYPE:
+                        if (!skb->dev)
+                                return 0;
+                        A = skb->dev->type;
+                        continue;
                 case SKF_AD_NLATTR: {
                         struct nlattr *nla;
 
diff --git a/net/core/flow.c b/net/core/flow.c
index 96015871ecea..161900674009 100644
--- a/net/core/flow.c
+++ b/net/core/flow.c
@@ -26,113 +26,158 @@
 #include <linux/security.h>
 
 struct flow_cache_entry {
-        struct flow_cache_entry *next;
-        u16                     family;
-        u8                      dir;
-        u32                     genid;
-        struct flowi            key;
-        void                    *object;
-        atomic_t                *object_ref;
+        union {
+                struct hlist_node       hlist;
+                struct list_head        gc_list;
+        } u;
+        u16                             family;
+        u8                              dir;
+        u32                             genid;
+        struct flowi                    key;
+        struct flow_cache_object        *object;
 };
 
-atomic_t flow_cache_genid = ATOMIC_INIT(0);
-
-static u32 flow_hash_shift;
-#define flow_hash_size  (1 << flow_hash_shift)
-static DEFINE_PER_CPU(struct flow_cache_entry **, flow_tables) = { NULL };
-
-#define flow_table(cpu) (per_cpu(flow_tables, cpu))
-
-static struct kmem_cache *flow_cachep __read_mostly;
+struct flow_cache_percpu {
+        struct hlist_head               *hash_table;
+        int                             hash_count;
+        u32                             hash_rnd;
+        int                             hash_rnd_recalc;
+        struct tasklet_struct           flush_tasklet;
+};
 
-static int flow_lwm, flow_hwm;
+struct flow_flush_info {
+        struct flow_cache               *cache;
+        atomic_t                        cpuleft;
+        struct completion               completion;
+};
 
-struct flow_percpu_info {
-        int hash_rnd_recalc;
-        u32 hash_rnd;
-        int count;
+struct flow_cache {
+        u32                             hash_shift;
+        unsigned long                   order;
+        struct flow_cache_percpu        *percpu;
+        struct notifier_block           hotcpu_notifier;
+        int                             low_watermark;
+        int                             high_watermark;
+        struct timer_list               rnd_timer;
 };
-static DEFINE_PER_CPU(struct flow_percpu_info, flow_hash_info) = { 0 };
 
-#define flow_hash_rnd_recalc(cpu) \
-        (per_cpu(flow_hash_info, cpu).hash_rnd_recalc)
-#define flow_hash_rnd(cpu) \
-        (per_cpu(flow_hash_info, cpu).hash_rnd)
-#define flow_count(cpu) \
-        (per_cpu(flow_hash_info, cpu).count)
+atomic_t flow_cache_genid = ATOMIC_INIT(0);
+static struct flow_cache flow_cache_global;
+static struct kmem_cache *flow_cachep;
 
-static struct timer_list flow_hash_rnd_timer;
+static DEFINE_SPINLOCK(flow_cache_gc_lock);
+static LIST_HEAD(flow_cache_gc_list);
 
-#define FLOW_HASH_RND_PERIOD    (10 * 60 * HZ)
-
-struct flow_flush_info {
-        atomic_t cpuleft;
-        struct completion completion;
-};
-static DEFINE_PER_CPU(struct tasklet_struct, flow_flush_tasklets) = { NULL };
-
-#define flow_flush_tasklet(cpu) (&per_cpu(flow_flush_tasklets, cpu))
+#define flow_cache_hash_size(cache)     (1 << (cache)->hash_shift)
+#define FLOW_HASH_RND_PERIOD            (10 * 60 * HZ)
 
 static void flow_cache_new_hashrnd(unsigned long arg)
 {
+        struct flow_cache *fc = (void *) arg;
         int i;
 
         for_each_possible_cpu(i)
-                flow_hash_rnd_recalc(i) = 1;
+                per_cpu_ptr(fc->percpu, i)->hash_rnd_recalc = 1;
 
-        flow_hash_rnd_timer.expires = jiffies + FLOW_HASH_RND_PERIOD;
-        add_timer(&flow_hash_rnd_timer);
+        fc->rnd_timer.expires = jiffies + FLOW_HASH_RND_PERIOD;
+        add_timer(&fc->rnd_timer);
+}
+
+static int flow_entry_valid(struct flow_cache_entry *fle)
+{
+        if (atomic_read(&flow_cache_genid) != fle->genid)
+                return 0;
+        if (fle->object && !fle->object->ops->check(fle->object))
+                return 0;
+        return 1;
 }
 
-static void flow_entry_kill(int cpu, struct flow_cache_entry *fle)
+static void flow_entry_kill(struct flow_cache_entry *fle)
 {
         if (fle->object)
-                atomic_dec(fle->object_ref);
+                fle->object->ops->delete(fle->object);
         kmem_cache_free(flow_cachep, fle);
-        flow_count(cpu)--;
 }
 
-static void __flow_cache_shrink(int cpu, int shrink_to)
+static void flow_cache_gc_task(struct work_struct *work)
 {
-        struct flow_cache_entry *fle, **flp;
-        int i;
+        struct list_head gc_list;
+        struct flow_cache_entry *fce, *n;
 
-        for (i = 0; i < flow_hash_size; i++) {
-                int k = 0;
+        INIT_LIST_HEAD(&gc_list);
+        spin_lock_bh(&flow_cache_gc_lock);
+        list_splice_tail_init(&flow_cache_gc_list, &gc_list);
+        spin_unlock_bh(&flow_cache_gc_lock);
 
-                flp = &flow_table(cpu)[i];
-                while ((fle = *flp) != NULL && k < shrink_to) {
-                        k++;
-                        flp = &fle->next;
-                }
-                while ((fle = *flp) != NULL) {
-                        *flp = fle->next;
-                        flow_entry_kill(cpu, fle);
-                }
+        list_for_each_entry_safe(fce, n, &gc_list, u.gc_list)
+                flow_entry_kill(fce);
+}
+static DECLARE_WORK(flow_cache_gc_work, flow_cache_gc_task);
+
+static void flow_cache_queue_garbage(struct flow_cache_percpu *fcp,
+                                     int deleted, struct list_head *gc_list)
+{
+        if (deleted) {
+                fcp->hash_count -= deleted;
+                spin_lock_bh(&flow_cache_gc_lock);
+                list_splice_tail(gc_list, &flow_cache_gc_list);
+                spin_unlock_bh(&flow_cache_gc_lock);
+                schedule_work(&flow_cache_gc_work);
         }
 }
 
-static void flow_cache_shrink(int cpu)
+static void __flow_cache_shrink(struct flow_cache *fc,
+                                struct flow_cache_percpu *fcp,
+                                int shrink_to)
 {
-        int shrink_to = flow_lwm / flow_hash_size;
+        struct flow_cache_entry *fle;
+        struct hlist_node *entry, *tmp;
+        LIST_HEAD(gc_list);
+        int i, deleted = 0;
+
+        for (i = 0; i < flow_cache_hash_size(fc); i++) {
+                int saved = 0;
+
+                hlist_for_each_entry_safe(fle, entry, tmp,
+                                          &fcp->hash_table[i], u.hlist) {
+                        if (saved < shrink_to &&
+                            flow_entry_valid(fle)) {
+                                saved++;
+                        } else {
+                                deleted++;
+                                hlist_del(&fle->u.hlist);
+                                list_add_tail(&fle->u.gc_list, &gc_list);
+                        }
+                }
+        }
 
-        __flow_cache_shrink(cpu, shrink_to);
+        flow_cache_queue_garbage(fcp, deleted, &gc_list);
 }
 
-static void flow_new_hash_rnd(int cpu)
+static void flow_cache_shrink(struct flow_cache *fc,
+                              struct flow_cache_percpu *fcp)
 {
-        get_random_bytes(&flow_hash_rnd(cpu), sizeof(u32));
-        flow_hash_rnd_recalc(cpu) = 0;
+        int shrink_to = fc->low_watermark / flow_cache_hash_size(fc);
 
-        __flow_cache_shrink(cpu, 0);
+        __flow_cache_shrink(fc, fcp, shrink_to);
 }
 
-static u32 flow_hash_code(struct flowi *key, int cpu)
+static void flow_new_hash_rnd(struct flow_cache *fc,
+                              struct flow_cache_percpu *fcp)
+{
+        get_random_bytes(&fcp->hash_rnd, sizeof(u32));
+        fcp->hash_rnd_recalc = 0;
+        __flow_cache_shrink(fc, fcp, 0);
+}
+
+static u32 flow_hash_code(struct flow_cache *fc,
+                          struct flow_cache_percpu *fcp,
+                          struct flowi *key)
 {
         u32 *k = (u32 *) key;
 
-        return (jhash2(k, (sizeof(*key) / sizeof(u32)), flow_hash_rnd(cpu)) &
-                (flow_hash_size - 1));
+        return (jhash2(k, (sizeof(*key) / sizeof(u32)), fcp->hash_rnd)
+                & (flow_cache_hash_size(fc) - 1));
 }
 
 #if (BITS_PER_LONG == 64)
@@ -165,114 +210,117 @@ static int flow_key_compare(struct flowi *key1, struct flowi *key2)
         return 0;
 }
 
-void *flow_cache_lookup(struct net *net, struct flowi *key, u16 family, u8 dir,
-                        flow_resolve_t resolver)
+struct flow_cache_object *
+flow_cache_lookup(struct net *net, struct flowi *key, u16 family, u8 dir,
+                  flow_resolve_t resolver, void *ctx)
 {
-        struct flow_cache_entry *fle, **head;
+        struct flow_cache *fc = &flow_cache_global;
+        struct flow_cache_percpu *fcp;
+        struct flow_cache_entry *fle, *tfle;
+        struct hlist_node *entry;
+        struct flow_cache_object *flo;
         unsigned int hash;
-        int cpu;
 
         local_bh_disable();
-        cpu = smp_processor_id();
+        fcp = per_cpu_ptr(fc->percpu, smp_processor_id());
 
         fle = NULL;
+        flo = NULL;
         /* Packet really early in init?  Making flow_cache_init a
          * pre-smp initcall would solve this.  --RR */
-        if (!flow_table(cpu))
+        if (!fcp->hash_table)
                 goto nocache;
 
-        if (flow_hash_rnd_recalc(cpu))
-                flow_new_hash_rnd(cpu);
-        hash = flow_hash_code(key, cpu);
+        if (fcp->hash_rnd_recalc)
+                flow_new_hash_rnd(fc, fcp);
 
-        head = &flow_table(cpu)[hash];
-        for (fle = *head; fle; fle = fle->next) {
-                if (fle->family == family &&
-                    fle->dir == dir &&
-                    flow_key_compare(key, &fle->key) == 0) {
-                        if (fle->genid == atomic_read(&flow_cache_genid)) {
-                                void *ret = fle->object;
-
-                                if (ret)
-                                        atomic_inc(fle->object_ref);
-                                local_bh_enable();
-
-                                return ret;
-                        }
+        hash = flow_hash_code(fc, fcp, key);
+        hlist_for_each_entry(tfle, entry, &fcp->hash_table[hash], u.hlist) {
+                if (tfle->family == family &&
+                    tfle->dir == dir &&
+                    flow_key_compare(key, &tfle->key) == 0) {
+                        fle = tfle;
                         break;
                 }
         }
 
-        if (!fle) {
-                if (flow_count(cpu) > flow_hwm)
-                        flow_cache_shrink(cpu);
+        if (unlikely(!fle)) {
+                if (fcp->hash_count > fc->high_watermark)
+                        flow_cache_shrink(fc, fcp);
 
                 fle = kmem_cache_alloc(flow_cachep, GFP_ATOMIC);
                 if (fle) {
-                        fle->next = *head;
-                        *head = fle;
                         fle->family = family;
                         fle->dir = dir;
                         memcpy(&fle->key, key, sizeof(*key));
                         fle->object = NULL;
-                        flow_count(cpu)++;
+                        hlist_add_head(&fle->u.hlist, &fcp->hash_table[hash]);
+                        fcp->hash_count++;
                 }
+        } else if (likely(fle->genid == atomic_read(&flow_cache_genid))) {
+                flo = fle->object;
+                if (!flo)
+                        goto ret_object;
+                flo = flo->ops->get(flo);
+                if (flo)
+                        goto ret_object;
+        } else if (fle->object) {
+                flo = fle->object;
+                flo->ops->delete(flo);
+                fle->object = NULL;
         }
 
 nocache:
-        {
-                int err;
-                void *obj;
-                atomic_t *obj_ref;
-
-                err = resolver(net, key, family, dir, &obj, &obj_ref);
-
-                if (fle && !err) {
-                        fle->genid = atomic_read(&flow_cache_genid);
-
-                        if (fle->object)
-                                atomic_dec(fle->object_ref);
-
-                        fle->object = obj;
-                        fle->object_ref = obj_ref;
-                        if (obj)
-                                atomic_inc(fle->object_ref);
-                }
-                local_bh_enable();
-
-                if (err)
-                        obj = ERR_PTR(err);
-                return obj;
+        flo = NULL;
+        if (fle) {
+                flo = fle->object;
+                fle->object = NULL;
         }
+        flo = resolver(net, key, family, dir, flo, ctx);
+        if (fle) {
+                fle->genid = atomic_read(&flow_cache_genid);
+                if (!IS_ERR(flo))
+                        fle->object = flo;
+                else
+                        fle->genid--;
+        } else {
+                if (flo && !IS_ERR(flo))
+                        flo->ops->delete(flo);
+        }
+ret_object:
+        local_bh_enable();
+        return flo;
 }
 
 static void flow_cache_flush_tasklet(unsigned long data)
 {
         struct flow_flush_info *info = (void *)data;
-        int i;
-        int cpu;
-
-        cpu = smp_processor_id();
-        for (i = 0; i < flow_hash_size; i++) {
-                struct flow_cache_entry *fle;
-
-                fle = flow_table(cpu)[i];
-                for (; fle; fle = fle->next) {
-                        unsigned genid = atomic_read(&flow_cache_genid);
-
-                        if (!fle->object || fle->genid == genid)
+        struct flow_cache *fc = info->cache;
+        struct flow_cache_percpu *fcp;
+        struct flow_cache_entry *fle;
+        struct hlist_node *entry, *tmp;
+        LIST_HEAD(gc_list);
+        int i, deleted = 0;
+
+        fcp = per_cpu_ptr(fc->percpu, smp_processor_id());
+        for (i = 0; i < flow_cache_hash_size(fc); i++) {
+                hlist_for_each_entry_safe(fle, entry, tmp,
+                                          &fcp->hash_table[i], u.hlist) {
+                        if (flow_entry_valid(fle))
                                 continue;
 
-                        fle->object = NULL;
-                        atomic_dec(fle->object_ref);
+                        deleted++;
+                        hlist_del(&fle->u.hlist);
+                        list_add_tail(&fle->u.gc_list, &gc_list);
                 }
         }
 
+        flow_cache_queue_garbage(fcp, deleted, &gc_list);
+
         if (atomic_dec_and_test(&info->cpuleft))
                 complete(&info->completion);
 }
 
-static void flow_cache_flush_per_cpu(void *) __attribute__((__unused__));
 static void flow_cache_flush_per_cpu(void *data)
 {
         struct flow_flush_info *info = data;
@@ -280,8 +328,7 @@ static void flow_cache_flush_per_cpu(void *data)
         struct tasklet_struct *tasklet;
 
         cpu = smp_processor_id();
-
-        tasklet = flow_flush_tasklet(cpu);
+        tasklet = &per_cpu_ptr(info->cache->percpu, cpu)->flush_tasklet;
         tasklet->data = (unsigned long)info;
         tasklet_schedule(tasklet);
 }
@@ -294,6 +341,7 @@ void flow_cache_flush(void)
         /* Don't want cpus going down or up during this. */
         get_online_cpus();
         mutex_lock(&flow_flush_sem);
+        info.cache = &flow_cache_global;
         atomic_set(&info.cpuleft, num_online_cpus());
         init_completion(&info.completion);
 
@@ -307,62 +355,75 @@ void flow_cache_flush(void)
         put_online_cpus();
 }
 
-static void __init flow_cache_cpu_prepare(int cpu)
+static void __init flow_cache_cpu_prepare(struct flow_cache *fc,
+                                          struct flow_cache_percpu *fcp)
 {
-        struct tasklet_struct *tasklet;
-        unsigned long order;
-
-        for (order = 0;
-             (PAGE_SIZE << order) <
-                     (sizeof(struct flow_cache_entry *)*flow_hash_size);
-             order++)
-                /* NOTHING */;
-
-        flow_table(cpu) = (struct flow_cache_entry **)
-                __get_free_pages(GFP_KERNEL|__GFP_ZERO, order);
-        if (!flow_table(cpu))
-                panic("NET: failed to allocate flow cache order %lu\n", order);
-
-        flow_hash_rnd_recalc(cpu) = 1;
-        flow_count(cpu) = 0;
-
-        tasklet = flow_flush_tasklet(cpu);
-        tasklet_init(tasklet, flow_cache_flush_tasklet, 0);
+        fcp->hash_table = (struct hlist_head *)
+                __get_free_pages(GFP_KERNEL|__GFP_ZERO, fc->order);
+        if (!fcp->hash_table)
+                panic("NET: failed to allocate flow cache order %lu\n", fc->order);
+
+        fcp->hash_rnd_recalc = 1;
+        fcp->hash_count = 0;
+        tasklet_init(&fcp->flush_tasklet, flow_cache_flush_tasklet, 0);
 }
 
 static int flow_cache_cpu(struct notifier_block *nfb,
                           unsigned long action,
                           void *hcpu)
 {
+        struct flow_cache *fc = container_of(nfb, struct flow_cache, hotcpu_notifier);
+        int cpu = (unsigned long) hcpu;
+        struct flow_cache_percpu *fcp = per_cpu_ptr(fc->percpu, cpu);
+
         if (action == CPU_DEAD || action == CPU_DEAD_FROZEN)
-                __flow_cache_shrink((unsigned long)hcpu, 0);
+                __flow_cache_shrink(fc, fcp, 0);
         return NOTIFY_OK;
 }
 
-static int __init flow_cache_init(void)
+static int flow_cache_init(struct flow_cache *fc)
 {
+        unsigned long order;
         int i;
 
-        flow_cachep = kmem_cache_create("flow_cache",
-                                        sizeof(struct flow_cache_entry),
-                                        0, SLAB_PANIC,
-                                        NULL);
-        flow_hash_shift = 10;
-        flow_lwm = 2 * flow_hash_size;
-        flow_hwm = 4 * flow_hash_size;
+        fc->hash_shift = 10;
+        fc->low_watermark = 2 * flow_cache_hash_size(fc);
+        fc->high_watermark = 4 * flow_cache_hash_size(fc);
+
+        for (order = 0;
+             (PAGE_SIZE << order) <
+                     (sizeof(struct hlist_head)*flow_cache_hash_size(fc));
+             order++)
+                /* NOTHING */;
+        fc->order = order;
+        fc->percpu = alloc_percpu(struct flow_cache_percpu);
 
-        setup_timer(&flow_hash_rnd_timer, flow_cache_new_hashrnd, 0);
-        flow_hash_rnd_timer.expires = jiffies + FLOW_HASH_RND_PERIOD;
-        add_timer(&flow_hash_rnd_timer);
+        setup_timer(&fc->rnd_timer, flow_cache_new_hashrnd,
+                    (unsigned long) fc);
+        fc->rnd_timer.expires = jiffies + FLOW_HASH_RND_PERIOD;
+        add_timer(&fc->rnd_timer);
 
         for_each_possible_cpu(i)
-                flow_cache_cpu_prepare(i);
+                flow_cache_cpu_prepare(fc, per_cpu_ptr(fc->percpu, i));
+
+        fc->hotcpu_notifier = (struct notifier_block){
+                .notifier_call = flow_cache_cpu,
+        };
+        register_hotcpu_notifier(&fc->hotcpu_notifier);
 
-        hotcpu_notifier(flow_cache_cpu, 0);
         return 0;
 }
 
-module_init(flow_cache_init);
+static int __init flow_cache_init_global(void)
+{
+        flow_cachep = kmem_cache_create("flow_cache",
+                                        sizeof(struct flow_cache_entry),
+                                        0, SLAB_PANIC, NULL);
+
+        return flow_cache_init(&flow_cache_global);
+}
+
+module_init(flow_cache_init_global);
 
 EXPORT_SYMBOL(flow_cache_genid);
 EXPORT_SYMBOL(flow_cache_lookup);
diff --git a/net/core/gen_estimator.c b/net/core/gen_estimator.c
index 493775f4f2f1..cf8e70392fe0 100644
--- a/net/core/gen_estimator.c
+++ b/net/core/gen_estimator.c
@@ -32,6 +32,7 @@
 #include <linux/rtnetlink.h>
 #include <linux/init.h>
 #include <linux/rbtree.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 #include <net/gen_stats.h>
 
diff --git a/net/core/iovec.c b/net/core/iovec.c
index 16ad45d4882b..1e7f4e91a935 100644
--- a/net/core/iovec.c
+++ b/net/core/iovec.c
@@ -20,7 +20,6 @@
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/mm.h>
-#include <linux/slab.h>
 #include <linux/net.h>
 #include <linux/in6.h>
 #include <asm/uaccess.h>
diff --git a/net/core/link_watch.c b/net/core/link_watch.c
index 5910b555a54a..bdbce2f5875b 100644
--- a/net/core/link_watch.c
+++ b/net/core/link_watch.c
@@ -19,7 +19,6 @@
 #include <linux/rtnetlink.h>
 #include <linux/jiffies.h>
 #include <linux/spinlock.h>
-#include <linux/slab.h>
 #include <linux/workqueue.h>
 #include <linux/bitops.h>
 #include <asm/types.h>
diff --git a/net/core/neighbour.c b/net/core/neighbour.c
index d102f6d9abdc..bff37908bd55 100644
--- a/net/core/neighbour.c
+++ b/net/core/neighbour.c
@@ -15,6 +15,7 @@
  *      Harald Welte            Add neighbour cache statistics like rtstat
  */
 
+#include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
@@ -771,6 +772,8 @@ static __inline__ int neigh_max_probes(struct neighbour *n)
 }
 
 static void neigh_invalidate(struct neighbour *neigh)
+        __releases(neigh->lock)
+        __acquires(neigh->lock)
 {
         struct sk_buff *skb;
 
diff --git a/net/core/net-sysfs.c b/net/core/net-sysfs.c
index 099c753c4213..c57c4b228bb5 100644
--- a/net/core/net-sysfs.c
+++ b/net/core/net-sysfs.c
@@ -13,9 +13,11 @@
 #include <linux/kernel.h>
 #include <linux/netdevice.h>
 #include <linux/if_arp.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 #include <linux/rtnetlink.h>
 #include <linux/wireless.h>
+#include <linux/vmalloc.h>
 #include <net/wext.h>
 
 #include "net-sysfs.h"
@@ -466,6 +468,304 @@ static struct attribute_group wireless_group = {
 };
 #endif
 
+#ifdef CONFIG_RPS
+/*
+ * RX queue sysfs structures and functions.
+ */
+struct rx_queue_attribute {
+        struct attribute attr;
+        ssize_t (*show)(struct netdev_rx_queue *queue,
+            struct rx_queue_attribute *attr, char *buf);
+        ssize_t (*store)(struct netdev_rx_queue *queue,
+            struct rx_queue_attribute *attr, const char *buf, size_t len);
+};
+#define to_rx_queue_attr(_attr) container_of(_attr,             \
+    struct rx_queue_attribute, attr)
+
+#define to_rx_queue(obj) container_of(obj, struct netdev_rx_queue, kobj)
+
+static ssize_t rx_queue_attr_show(struct kobject *kobj, struct attribute *attr,
+                                  char *buf)
+{
+        struct rx_queue_attribute *attribute = to_rx_queue_attr(attr);
+        struct netdev_rx_queue *queue = to_rx_queue(kobj);
+
+        if (!attribute->show)
+                return -EIO;
+
+        return attribute->show(queue, attribute, buf);
+}
+
+static ssize_t rx_queue_attr_store(struct kobject *kobj, struct attribute *attr,
+                                   const char *buf, size_t count)
+{
+        struct rx_queue_attribute *attribute = to_rx_queue_attr(attr);
+        struct netdev_rx_queue *queue = to_rx_queue(kobj);
+
+        if (!attribute->store)
+                return -EIO;
+
+        return attribute->store(queue, attribute, buf, count);
+}
+
+static struct sysfs_ops rx_queue_sysfs_ops = {
+        .show = rx_queue_attr_show,
+        .store = rx_queue_attr_store,
+};
+
+static ssize_t show_rps_map(struct netdev_rx_queue *queue,
+                            struct rx_queue_attribute *attribute, char *buf)
+{
+        struct rps_map *map;
+        cpumask_var_t mask;
+        size_t len = 0;
+        int i;
+
+        if (!zalloc_cpumask_var(&mask, GFP_KERNEL))
+                return -ENOMEM;
+
+        rcu_read_lock();
+        map = rcu_dereference(queue->rps_map);
+        if (map)
+                for (i = 0; i < map->len; i++)
+                        cpumask_set_cpu(map->cpus[i], mask);
+
+        len += cpumask_scnprintf(buf + len, PAGE_SIZE, mask);
+        if (PAGE_SIZE - len < 3) {
+                rcu_read_unlock();
+                free_cpumask_var(mask);
+                return -EINVAL;
+        }
+        rcu_read_unlock();
+
+        free_cpumask_var(mask);
+        len += sprintf(buf + len, "\n");
+        return len;
+}
+
+static void rps_map_release(struct rcu_head *rcu)
+{
+        struct rps_map *map = container_of(rcu, struct rps_map, rcu);
+
+        kfree(map);
+}
+
+static ssize_t store_rps_map(struct netdev_rx_queue *queue,
+                      struct rx_queue_attribute *attribute,
+                      const char *buf, size_t len)
+{
+        struct rps_map *old_map, *map;
+        cpumask_var_t mask;
+        int err, cpu, i;
+        static DEFINE_SPINLOCK(rps_map_lock);
+
+        if (!capable(CAP_NET_ADMIN))
+                return -EPERM;
+
+        if (!alloc_cpumask_var(&mask, GFP_KERNEL))
+                return -ENOMEM;
+
+        err = bitmap_parse(buf, len, cpumask_bits(mask), nr_cpumask_bits);
+        if (err) {
+                free_cpumask_var(mask);
+                return err;
+        }
+
+        map = kzalloc(max_t(unsigned,
+            RPS_MAP_SIZE(cpumask_weight(mask)), L1_CACHE_BYTES),
+            GFP_KERNEL);
+        if (!map) {
+                free_cpumask_var(mask);
+                return -ENOMEM;
+        }
+
+        i = 0;
+        for_each_cpu_and(cpu, mask, cpu_online_mask)
+                map->cpus[i++] = cpu;
+
+        if (i)
+                map->len = i;
+        else {
+                kfree(map);
+                map = NULL;
+        }
+
+        spin_lock(&rps_map_lock);
+        old_map = queue->rps_map;
+        rcu_assign_pointer(queue->rps_map, map);
+        spin_unlock(&rps_map_lock);
+
+        if (old_map)
+                call_rcu(&old_map->rcu, rps_map_release);
+
+        free_cpumask_var(mask);
+        return len;
+}
+
+static ssize_t show_rps_dev_flow_table_cnt(struct netdev_rx_queue *queue,
+                                           struct rx_queue_attribute *attr,
+                                           char *buf)
+{
+        struct rps_dev_flow_table *flow_table;
+        unsigned int val = 0;
+
+        rcu_read_lock();
+        flow_table = rcu_dereference(queue->rps_flow_table);
+        if (flow_table)
+                val = flow_table->mask + 1;
+        rcu_read_unlock();
+
+        return sprintf(buf, "%u\n", val);
+}
+
+static void rps_dev_flow_table_release_work(struct work_struct *work)
+{
+        struct rps_dev_flow_table *table = container_of(work,
+            struct rps_dev_flow_table, free_work);
+
+        vfree(table);
+}
+
+static void rps_dev_flow_table_release(struct rcu_head *rcu)
+{
+        struct rps_dev_flow_table *table = container_of(rcu,
+            struct rps_dev_flow_table, rcu);
+
+        INIT_WORK(&table->free_work, rps_dev_flow_table_release_work);
+        schedule_work(&table->free_work);
+}
+
+static ssize_t store_rps_dev_flow_table_cnt(struct netdev_rx_queue *queue,
+                                     struct rx_queue_attribute *attr,
+                                     const char *buf, size_t len)
+{
+        unsigned int count;
+        char *endp;
+        struct rps_dev_flow_table *table, *old_table;
+        static DEFINE_SPINLOCK(rps_dev_flow_lock);
+
+        if (!capable(CAP_NET_ADMIN))
+                return -EPERM;
+
+        count = simple_strtoul(buf, &endp, 0);
+        if (endp == buf)
+                return -EINVAL;
+
+        if (count) {
+                int i;
+
+                if (count > 1<<30) {
+                        /* Enforce a limit to prevent overflow */
+                        return -EINVAL;
+                }
+                count = roundup_pow_of_two(count);
+                table = vmalloc(RPS_DEV_FLOW_TABLE_SIZE(count));
+                if (!table)
+                        return -ENOMEM;
+
+                table->mask = count - 1;
+                for (i = 0; i < count; i++)
+                        table->flows[i].cpu = RPS_NO_CPU;
+        } else
+                table = NULL;
+
+        spin_lock(&rps_dev_flow_lock);
+        old_table = queue->rps_flow_table;
+        rcu_assign_pointer(queue->rps_flow_table, table);
+        spin_unlock(&rps_dev_flow_lock);
+
+        if (old_table)
+                call_rcu(&old_table->rcu, rps_dev_flow_table_release);
+
+        return len;
+}
+
+static struct rx_queue_attribute rps_cpus_attribute =
+        __ATTR(rps_cpus, S_IRUGO | S_IWUSR, show_rps_map, store_rps_map);
+
+
+static struct rx_queue_attribute rps_dev_flow_table_cnt_attribute =
+        __ATTR(rps_flow_cnt, S_IRUGO | S_IWUSR,
+            show_rps_dev_flow_table_cnt, store_rps_dev_flow_table_cnt);
+
+static struct attribute *rx_queue_default_attrs[] = {
+        &rps_cpus_attribute.attr,
+        &rps_dev_flow_table_cnt_attribute.attr,
+        NULL
+};
+
+static void rx_queue_release(struct kobject *kobj)
+{
+        struct netdev_rx_queue *queue = to_rx_queue(kobj);
+        struct netdev_rx_queue *first = queue->first;
+
+        if (queue->rps_map)
+                call_rcu(&queue->rps_map->rcu, rps_map_release);
+
+        if (queue->rps_flow_table)
+                call_rcu(&queue->rps_flow_table->rcu,
+                    rps_dev_flow_table_release);
+
+        if (atomic_dec_and_test(&first->count))
+                kfree(first);
+}
+
+static struct kobj_type rx_queue_ktype = {
+        .sysfs_ops = &rx_queue_sysfs_ops,
+        .release = rx_queue_release,
+        .default_attrs = rx_queue_default_attrs,
+};
+
+static int rx_queue_add_kobject(struct net_device *net, int index)
+{
+        struct netdev_rx_queue *queue = net->_rx + index;
+        struct kobject *kobj = &queue->kobj;
+        int error = 0;
+
+        kobj->kset = net->queues_kset;
+        error = kobject_init_and_add(kobj, &rx_queue_ktype, NULL,
+            "rx-%u", index);
+        if (error) {
+                kobject_put(kobj);
+                return error;
+        }
+
+        kobject_uevent(kobj, KOBJ_ADD);
+
+        return error;
+}
+
+static int rx_queue_register_kobjects(struct net_device *net)
+{
+        int i;
+        int error = 0;
+
+        net->queues_kset = kset_create_and_add("queues",
+            NULL, &net->dev.kobj);
+        if (!net->queues_kset)
+                return -ENOMEM;
+        for (i = 0; i < net->num_rx_queues; i++) {
+                error = rx_queue_add_kobject(net, i);
+                if (error)
+                        break;
+        }
+
+        if (error)
+                while (--i >= 0)
+                        kobject_put(&net->_rx[i].kobj);
+
+        return error;
+}
+
+static void rx_queue_remove_kobjects(struct net_device *net)
+{
+        int i;
+
+        for (i = 0; i < net->num_rx_queues; i++)
+                kobject_put(&net->_rx[i].kobj);
+        kset_unregister(net->queues_kset);
+}
+#endif /* CONFIG_RPS */
 #endif /* CONFIG_SYSFS */
 
 #ifdef CONFIG_HOTPLUG
@@ -529,6 +829,10 @@ void netdev_unregister_kobject(struct net_device * net)
         if (!net_eq(dev_net(net), &init_net))
                 return;
 
+#ifdef CONFIG_RPS
+        rx_queue_remove_kobjects(net);
+#endif
+
         device_del(dev);
 }
 
@@ -537,6 +841,7 @@ int netdev_register_kobject(struct net_device *net)
 {
         struct device *dev = &(net->dev);
         const struct attribute_group **groups = net->sysfs_groups;
+        int error = 0;
 
         dev->class = &net_class;
         dev->platform_data = net;
@@ -563,7 +868,19 @@ int netdev_register_kobject(struct net_device *net)
         if (!net_eq(dev_net(net), &init_net))
                 return 0;
 
-        return device_add(dev);
+        error = device_add(dev);
+        if (error)
+                return error;
+
+#ifdef CONFIG_RPS
+        error = rx_queue_register_kobjects(net);
+        if (error) {
+                device_del(dev);
+                return error;
+        }
+#endif
+
+        return error;
 }
 
 int netdev_class_create_file(struct class_attribute *class_attr)
diff --git a/net/core/net-traces.c b/net/core/net-traces.c
index f1e982c508bb..afa6380ed88a 100644
--- a/net/core/net-traces.c
+++ b/net/core/net-traces.c
@@ -19,6 +19,7 @@
 #include <linux/workqueue.h>
 #include <linux/netlink.h>
 #include <linux/net_dropmon.h>
+#include <linux/slab.h>
 
 #include <asm/unaligned.h>
 #include <asm/bitops.h>
diff --git a/net/core/net_namespace.c b/net/core/net_namespace.c
index bd8c4712ea24..c988e685433a 100644
--- a/net/core/net_namespace.c
+++ b/net/core/net_namespace.c
@@ -27,6 +27,51 @@ EXPORT_SYMBOL(init_net);
 
 #define INITIAL_NET_GEN_PTRS    13 /* +1 for len +2 for rcu_head */
 
+static void net_generic_release(struct rcu_head *rcu)
+{
+        struct net_generic *ng;
+
+        ng = container_of(rcu, struct net_generic, rcu);
+        kfree(ng);
+}
+
+static int net_assign_generic(struct net *net, int id, void *data)
+{
+        struct net_generic *ng, *old_ng;
+
+        BUG_ON(!mutex_is_locked(&net_mutex));
+        BUG_ON(id == 0);
+
+        ng = old_ng = net->gen;
+        if (old_ng->len >= id)
+                goto assign;
+
+        ng = kzalloc(sizeof(struct net_generic) +
+                        id * sizeof(void *), GFP_KERNEL);
+        if (ng == NULL)
+                return -ENOMEM;
+
+        /*
+         * Some synchronisation notes:
+         *
+         * The net_generic explores the net->gen array inside rcu
+         * read section. Besides once set the net->gen->ptr[x]
+         * pointer never changes (see rules in netns/generic.h).
+         *
+         * That said, we simply duplicate this array and schedule
+         * the old copy for kfree after a grace period.
+         */
+
+        ng->len = id;
+        memcpy(&ng->ptr, &old_ng->ptr, old_ng->len * sizeof(void*));
+
+        rcu_assign_pointer(net->gen, ng);
+        call_rcu(&old_ng->rcu, net_generic_release);
+assign:
+        ng->ptr[id - 1] = data;
+        return 0;
+}
+
 static int ops_init(const struct pernet_operations *ops, struct net *net)
 {
         int err;
@@ -469,10 +514,10 @@ EXPORT_SYMBOL_GPL(register_pernet_subsys);
  *      addition run the exit method for all existing network
  *      namespaces.
  */
-void unregister_pernet_subsys(struct pernet_operations *module)
+void unregister_pernet_subsys(struct pernet_operations *ops)
 {
         mutex_lock(&net_mutex);
-        unregister_pernet_operations(module);
+        unregister_pernet_operations(ops);
         mutex_unlock(&net_mutex);
 }
 EXPORT_SYMBOL_GPL(unregister_pernet_subsys);
@@ -526,49 +571,3 @@ void unregister_pernet_device(struct pernet_operations *ops)
         mutex_unlock(&net_mutex);
 }
 EXPORT_SYMBOL_GPL(unregister_pernet_device);
-
-static void net_generic_release(struct rcu_head *rcu)
-{
-        struct net_generic *ng;
-
-        ng = container_of(rcu, struct net_generic, rcu);
-        kfree(ng);
-}
-
-int net_assign_generic(struct net *net, int id, void *data)
-{
-        struct net_generic *ng, *old_ng;
-
-        BUG_ON(!mutex_is_locked(&net_mutex));
-        BUG_ON(id == 0);
-
-        ng = old_ng = net->gen;
-        if (old_ng->len >= id)
-                goto assign;
-
-        ng = kzalloc(sizeof(struct net_generic) +
-                        id * sizeof(void *), GFP_KERNEL);
-        if (ng == NULL)
-                return -ENOMEM;
-
-        /*
-         * Some synchronisation notes:
-         *
-         * The net_generic explores the net->gen array inside rcu
-         * read section. Besides once set the net->gen->ptr[x]
-         * pointer never changes (see rules in netns/generic.h).
-         *
-         * That said, we simply duplicate this array and schedule
-         * the old copy for kfree after a grace period.
-         */
-
-        ng->len = id;
-        memcpy(&ng->ptr, &old_ng->ptr, old_ng->len * sizeof(void*));
-
-        rcu_assign_pointer(net->gen, ng);
-        call_rcu(&old_ng->rcu, net_generic_release);
-assign:
-        ng->ptr[id - 1] = data;
-        return 0;
-}
-EXPORT_SYMBOL_GPL(net_assign_generic);
diff --git a/net/core/netpoll.c b/net/core/netpoll.c
index 7aa697253765..a58f59b97597 100644
--- a/net/core/netpoll.c
+++ b/net/core/netpoll.c
@@ -22,6 +22,7 @@
 #include <linux/delay.h>
 #include <linux/rcupdate.h>
 #include <linux/workqueue.h>
+#include <linux/slab.h>
 #include <net/tcp.h>
 #include <net/udp.h>
 #include <asm/unaligned.h>
@@ -614,7 +615,7 @@ void netpoll_print_options(struct netpoll *np)
                          np->name, np->local_port);
         printk(KERN_INFO "%s: local IP %pI4\n",
                          np->name, &np->local_ip);
-        printk(KERN_INFO "%s: interface %s\n",
+        printk(KERN_INFO "%s: interface '%s'\n",
                          np->name, np->dev_name);
         printk(KERN_INFO "%s: remote port %d\n",
                          np->name, np->remote_port);
@@ -661,6 +662,9 @@ int netpoll_parse_options(struct netpoll *np, char *opt)
                 if ((delim = strchr(cur, '@')) == NULL)
                         goto parse_failed;
                 *delim = 0;
+                if (*cur == ' ' || *cur == '\t')
+                        printk(KERN_INFO "%s: warning: whitespace"
+                                        "is not allowed\n", np->name);
                 np->remote_port = simple_strtol(cur, NULL, 10);
                 cur = delim;
         }
@@ -708,7 +712,7 @@ int netpoll_parse_options(struct netpoll *np, char *opt)
         return 0;
 
  parse_failed:
-        printk(KERN_INFO "%s: couldn't parse config at %s!\n",
+        printk(KERN_INFO "%s: couldn't parse config at '%s'!\n",
                np->name, cur);
         return -1;
 }
@@ -735,7 +739,7 @@ int netpoll_setup(struct netpoll *np)
                 npinfo = kmalloc(sizeof(*npinfo), GFP_KERNEL);
                 if (!npinfo) {
                         err = -ENOMEM;
-                        goto release;
+                        goto put;
                 }
 
                 npinfo->rx_flags = 0;
@@ -845,7 +849,7 @@ int netpoll_setup(struct netpoll *np)
 
                 kfree(npinfo);
         }
-
+put:
         dev_put(ndev);
         return err;
 }
diff --git a/net/core/pktgen.c b/net/core/pktgen.c
index 43923811bd6a..2ad68da418df 100644
--- a/net/core/pktgen.c
+++ b/net/core/pktgen.c
@@ -169,7 +169,7 @@
 #include <asm/dma.h>
 #include <asm/div64.h>          /* do_div */
 
-#define VERSION         "2.72"
+#define VERSION         "2.73"
 #define IP_NAME_SZ 32
 #define MAX_MPLS_LABELS 16 /* This is the max label stack depth */
 #define MPLS_STACK_BOTTOM htonl(0x00000100)
@@ -190,6 +190,7 @@
 #define F_IPSEC_ON    (1<<12)   /* ipsec on for flows */
 #define F_QUEUE_MAP_RND (1<<13) /* queue map Random */
 #define F_QUEUE_MAP_CPU (1<<14) /* queue map mirrors smp_processor_id() */
+#define F_NODE          (1<<15) /* Node memory alloc*/
 
 /* Thread control flag bits */
 #define T_STOP        (1<<0)    /* Stop run */
@@ -372,6 +373,7 @@ struct pktgen_dev {
 
         u16 queue_map_min;
         u16 queue_map_max;
+        int node;               /* Memory node */
 
 #ifdef CONFIG_XFRM
         __u8    ipsmode;                /* IPSEC mode (config) */
@@ -607,6 +609,9 @@ static int pktgen_if_show(struct seq_file *seq, void *v)
         if (pkt_dev->traffic_class)
                 seq_printf(seq, "     traffic_class: 0x%02x\n", pkt_dev->traffic_class);
 
+        if (pkt_dev->node >= 0)
+                seq_printf(seq, "     node: %d\n", pkt_dev->node);
+
         seq_printf(seq, "     Flags: ");
 
         if (pkt_dev->flags & F_IPV6)
@@ -660,6 +665,9 @@ static int pktgen_if_show(struct seq_file *seq, void *v)
         if (pkt_dev->flags & F_SVID_RND)
                 seq_printf(seq, "SVID_RND  ");
 
+        if (pkt_dev->flags & F_NODE)
+                seq_printf(seq, "NODE_ALLOC  ");
+
         seq_puts(seq, "\n");
 
         /* not really stopped, more like last-running-at */
@@ -1074,6 +1082,21 @@ static ssize_t pktgen_if_write(struct file *file,
                         pkt_dev->dst_mac_count);
                 return count;
         }
+        if (!strcmp(name, "node")) {
+                len = num_arg(&user_buffer[i], 10, &value);
+                if (len < 0)
+                        return len;
+
+                i += len;
+
+                if (node_possible(value)) {
+                        pkt_dev->node = value;
+                        sprintf(pg_result, "OK: node=%d", pkt_dev->node);
+                }
+                else
+                        sprintf(pg_result, "ERROR: node not possible");
+                return count;
+        }
         if (!strcmp(name, "flag")) {
                 char f[32];
                 memset(f, 0, 32);
@@ -1166,12 +1189,18 @@ static ssize_t pktgen_if_write(struct file *file,
                 else if (strcmp(f, "!IPV6") == 0)
                         pkt_dev->flags &= ~F_IPV6;
 
+                else if (strcmp(f, "NODE_ALLOC") == 0)
+                        pkt_dev->flags |= F_NODE;
+
+                else if (strcmp(f, "!NODE_ALLOC") == 0)
+                        pkt_dev->flags &= ~F_NODE;
+
                 else {
                         sprintf(pg_result,
                                 "Flag -:%s:- unknown\nAvailable flags, (prepend ! to un-set flag):\n%s",
                                 f,
                                 "IPSRC_RND, IPDST_RND, UDPSRC_RND, UDPDST_RND, "
-                                "MACSRC_RND, MACDST_RND, TXSIZE_RND, IPV6, MPLS_RND, VID_RND, SVID_RND, FLOW_SEQ, IPSEC\n");
+                                "MACSRC_RND, MACDST_RND, TXSIZE_RND, IPV6, MPLS_RND, VID_RND, SVID_RND, FLOW_SEQ, IPSEC, NODE_ALLOC\n");
                         return count;
                 }
                 sprintf(pg_result, "OK: flags=0x%x", pkt_dev->flags);
@@ -2572,9 +2601,27 @@ static struct sk_buff *fill_packet_ipv4(struct net_device *odev,
         mod_cur_headers(pkt_dev);
 
         datalen = (odev->hard_header_len + 16) & ~0xf;
-        skb = __netdev_alloc_skb(odev,
-                                 pkt_dev->cur_pkt_size + 64
-                                 + datalen + pkt_dev->pkt_overhead, GFP_NOWAIT);
+
+        if (pkt_dev->flags & F_NODE) {
+                int node;
+
+                if (pkt_dev->node >= 0)
+                        node = pkt_dev->node;
+                else
+                        node =  numa_node_id();
+
+                skb = __alloc_skb(NET_SKB_PAD + pkt_dev->cur_pkt_size + 64
+                                  + datalen + pkt_dev->pkt_overhead, GFP_NOWAIT, 0, node);
+                if (likely(skb)) {
+                        skb_reserve(skb, NET_SKB_PAD);
+                        skb->dev = odev;
+                }
+        }
+        else
+          skb = __netdev_alloc_skb(odev,
+                                   pkt_dev->cur_pkt_size + 64
+                                   + datalen + pkt_dev->pkt_overhead, GFP_NOWAIT);
+
         if (!skb) {
                 sprintf(pkt_dev->result, "No memory");
                 return NULL;
@@ -3674,6 +3721,7 @@ static int pktgen_add_device(struct pktgen_thread *t, const char *ifname)
         pkt_dev->svlan_p = 0;
         pkt_dev->svlan_cfi = 0;
         pkt_dev->svlan_id = 0xffff;
+        pkt_dev->node = -1;
 
         err = pktgen_setup_dev(pkt_dev, ifname);
         if (err)
diff --git a/net/core/rtnetlink.c b/net/core/rtnetlink.c
index 4568120d8533..23a71cb21273 100644
--- a/net/core/rtnetlink.c
+++ b/net/core/rtnetlink.c
@@ -98,7 +98,7 @@ int lockdep_rtnl_is_held(void)
 EXPORT_SYMBOL(lockdep_rtnl_is_held);
 #endif /* #ifdef CONFIG_PROVE_LOCKING */
 
-static struct rtnl_link *rtnl_msg_handlers[NPROTO];
+static struct rtnl_link *rtnl_msg_handlers[RTNL_FAMILY_MAX + 1];
 
 static inline int rtm_msgindex(int msgtype)
 {
@@ -118,7 +118,11 @@ static rtnl_doit_func rtnl_get_doit(int protocol, int msgindex)
 {
         struct rtnl_link *tab;
 
-        tab = rtnl_msg_handlers[protocol];
+        if (protocol <= RTNL_FAMILY_MAX)
+                tab = rtnl_msg_handlers[protocol];
+        else
+                tab = NULL;
+
         if (tab == NULL || tab[msgindex].doit == NULL)
                 tab = rtnl_msg_handlers[PF_UNSPEC];
 
@@ -129,7 +133,11 @@ static rtnl_dumpit_func rtnl_get_dumpit(int protocol, int msgindex)
 {
         struct rtnl_link *tab;
 
-        tab = rtnl_msg_handlers[protocol];
+        if (protocol <= RTNL_FAMILY_MAX)
+                tab = rtnl_msg_handlers[protocol];
+        else
+                tab = NULL;
+
         if (tab == NULL || tab[msgindex].dumpit == NULL)
                 tab = rtnl_msg_handlers[PF_UNSPEC];
 
@@ -159,7 +167,7 @@ int __rtnl_register(int protocol, int msgtype,
         struct rtnl_link *tab;
         int msgindex;
 
-        BUG_ON(protocol < 0 || protocol >= NPROTO);
+        BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX);
         msgindex = rtm_msgindex(msgtype);
 
         tab = rtnl_msg_handlers[protocol];
@@ -211,7 +219,7 @@ int rtnl_unregister(int protocol, int msgtype)
 {
         int msgindex;
 
-        BUG_ON(protocol < 0 || protocol >= NPROTO);
+        BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX);
         msgindex = rtm_msgindex(msgtype);
 
         if (rtnl_msg_handlers[protocol] == NULL)
@@ -233,7 +241,7 @@ EXPORT_SYMBOL_GPL(rtnl_unregister);
  */
 void rtnl_unregister_all(int protocol)
 {
-        BUG_ON(protocol < 0 || protocol >= NPROTO);
+        BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX);
 
         kfree(rtnl_msg_handlers[protocol]);
         rtnl_msg_handlers[protocol] = NULL;
@@ -600,7 +608,41 @@ static void copy_rtnl_link_stats(struct rtnl_link_stats *a,
 
         a->rx_compressed = b->rx_compressed;
         a->tx_compressed = b->tx_compressed;
-};
+}
+
+static void copy_rtnl_link_stats64(void *v, const struct net_device_stats *b)
+{
+        struct rtnl_link_stats64 a;
+
+        a.rx_packets = b->rx_packets;
+        a.tx_packets = b->tx_packets;
+        a.rx_bytes = b->rx_bytes;
+        a.tx_bytes = b->tx_bytes;
+        a.rx_errors = b->rx_errors;
+        a.tx_errors = b->tx_errors;
+        a.rx_dropped = b->rx_dropped;
+        a.tx_dropped = b->tx_dropped;
+
+        a.multicast = b->multicast;
+        a.collisions = b->collisions;
+
+        a.rx_length_errors = b->rx_length_errors;
+        a.rx_over_errors = b->rx_over_errors;
+        a.rx_crc_errors = b->rx_crc_errors;
+        a.rx_frame_errors = b->rx_frame_errors;
+        a.rx_fifo_errors = b->rx_fifo_errors;
+        a.rx_missed_errors = b->rx_missed_errors;
+
+        a.tx_aborted_errors = b->tx_aborted_errors;
+        a.tx_carrier_errors = b->tx_carrier_errors;
+        a.tx_fifo_errors = b->tx_fifo_errors;
+        a.tx_heartbeat_errors = b->tx_heartbeat_errors;
+        a.tx_window_errors = b->tx_window_errors;
+
+        a.rx_compressed = b->rx_compressed;
+        a.tx_compressed = b->tx_compressed;
+        memcpy(v, &a, sizeof(a));
+}
 
 static inline int rtnl_vfinfo_size(const struct net_device *dev)
 {
@@ -619,6 +661,7 @@ static inline size_t if_nlmsg_size(const struct net_device *dev)
                + nla_total_size(IFNAMSIZ) /* IFLA_QDISC */
                + nla_total_size(sizeof(struct rtnl_link_ifmap))
                + nla_total_size(sizeof(struct rtnl_link_stats))
+               + nla_total_size(sizeof(struct rtnl_link_stats64))
                + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */
                + nla_total_size(MAX_ADDR_LEN) /* IFLA_BROADCAST */
                + nla_total_size(4) /* IFLA_TXQLEN */
@@ -698,6 +741,12 @@ static int rtnl_fill_ifinfo(struct sk_buff *skb, struct net_device *dev,
         stats = dev_get_stats(dev);
         copy_rtnl_link_stats(nla_data(attr), stats);
 
+        attr = nla_reserve(skb, IFLA_STATS64,
+                        sizeof(struct rtnl_link_stats64));
+        if (attr == NULL)
+                goto nla_put_failure;
+        copy_rtnl_link_stats64(nla_data(attr), stats);
+
         if (dev->netdev_ops->ndo_get_vf_config && dev->dev.parent) {
                 int i;
                 struct ifla_vf_info ivi;
@@ -1270,10 +1319,11 @@ replay:
                         err = ops->newlink(net, dev, tb, data);
                 else
                         err = register_netdevice(dev);
-                if (err < 0 && !IS_ERR(dev)) {
+
+                if (err < 0 && !IS_ERR(dev))
                         free_netdev(dev);
+                if (err < 0)
                         goto out;
-                }
 
                 err = rtnl_configure_link(dev, ifm);
                 if (err < 0)
@@ -1335,7 +1385,7 @@ static int rtnl_dump_all(struct sk_buff *skb, struct netlink_callback *cb)
 
         if (s_idx == 0)
                 s_idx = 1;
-        for (idx = 1; idx < NPROTO; idx++) {
+        for (idx = 1; idx <= RTNL_FAMILY_MAX; idx++) {
                 int type = cb->nlh->nlmsg_type-RTM_BASE;
                 if (idx < s_idx || idx == PF_PACKET)
                         continue;
@@ -1403,9 +1453,6 @@ static int rtnetlink_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
                 return 0;
 
         family = ((struct rtgenmsg *)NLMSG_DATA(nlh))->rtgen_family;
-        if (family >= NPROTO)
-                return -EAFNOSUPPORT;
-
         sz_idx = type>>2;
         kind = type&3;
 
@@ -1473,6 +1520,7 @@ static int rtnetlink_event(struct notifier_block *this, unsigned long event, voi
         case NETDEV_POST_INIT:
         case NETDEV_REGISTER:
         case NETDEV_CHANGE:
+        case NETDEV_PRE_TYPE_CHANGE:
         case NETDEV_GOING_DOWN:
         case NETDEV_UNREGISTER:
         case NETDEV_UNREGISTER_BATCH:
diff --git a/net/core/scm.c b/net/core/scm.c
index 9b264634acfd..b88f6f9d0b97 100644
--- a/net/core/scm.c
+++ b/net/core/scm.c
@@ -26,6 +26,7 @@
 #include <linux/security.h>
 #include <linux/pid.h>
 #include <linux/nsproxy.h>
+#include <linux/slab.h>
 
 #include <asm/system.h>
 #include <asm/uaccess.h>
diff --git a/net/core/skbuff.c b/net/core/skbuff.c
index 93c4e060c91e..8b9c109166a7 100644
--- a/net/core/skbuff.c
+++ b/net/core/skbuff.c
@@ -117,7 +117,7 @@ static const struct pipe_buf_operations sock_pipe_buf_ops = {
  *
  *      Out of line support code for skb_put(). Not user callable.
  */
-void skb_over_panic(struct sk_buff *skb, int sz, void *here)
+static void skb_over_panic(struct sk_buff *skb, int sz, void *here)
 {
         printk(KERN_EMERG "skb_over_panic: text:%p len:%d put:%d head:%p "
                           "data:%p tail:%#lx end:%#lx dev:%s\n",
@@ -126,7 +126,6 @@ void skb_over_panic(struct sk_buff *skb, int sz, void *here)
                skb->dev ? skb->dev->name : "<NULL>");
         BUG();
 }
-EXPORT_SYMBOL(skb_over_panic);
 
 /**
  *      skb_under_panic -       private function
@@ -137,7 +136,7 @@ EXPORT_SYMBOL(skb_over_panic);
  *      Out of line support code for skb_push(). Not user callable.
  */
 
-void skb_under_panic(struct sk_buff *skb, int sz, void *here)
+static void skb_under_panic(struct sk_buff *skb, int sz, void *here)
 {
         printk(KERN_EMERG "skb_under_panic: text:%p len:%d put:%d head:%p "
                           "data:%p tail:%#lx end:%#lx dev:%s\n",
@@ -146,7 +145,6 @@ void skb_under_panic(struct sk_buff *skb, int sz, void *here)
                skb->dev ? skb->dev->name : "<NULL>");
         BUG();
 }
-EXPORT_SYMBOL(skb_under_panic);
 
 /*      Allocate a new skbuff. We do this ourselves so we can fill in a few
  *      'private' fields and also do memory statistics to find all the
@@ -534,6 +532,7 @@ static void __copy_skb_header(struct sk_buff *new, const struct sk_buff *old)
         new->network_header     = old->network_header;
         new->mac_header         = old->mac_header;
         skb_dst_set(new, dst_clone(skb_dst(old)));
+        new->rxhash             = old->rxhash;
 #ifdef CONFIG_XFRM
         new->sp                 = secpath_get(old->sp);
 #endif
@@ -581,6 +580,7 @@ static struct sk_buff *__skb_clone(struct sk_buff *n, struct sk_buff *skb)
         C(len);
         C(data_len);
         C(mac_len);
+        C(rxhash);
         n->hdr_len = skb->nohdr ? skb_headroom(skb) : skb->hdr_len;
         n->cloned = 1;
         n->nohdr = 0;
@@ -1051,7 +1051,7 @@ EXPORT_SYMBOL(skb_push);
  */
 unsigned char *skb_pull(struct sk_buff *skb, unsigned int len)
 {
-        return unlikely(len > skb->len) ? NULL : __skb_pull(skb, len);
+        return skb_pull_inline(skb, len);
 }
 EXPORT_SYMBOL(skb_pull);
 
diff --git a/net/core/sock.c b/net/core/sock.c
index c5812bbc2cc9..94c4affdda9b 100644
--- a/net/core/sock.c
+++ b/net/core/sock.c
@@ -327,6 +327,10 @@ int sk_receive_skb(struct sock *sk, struct sk_buff *skb, const int nested)
 
         skb->dev = NULL;
 
+        if (sk_rcvqueues_full(sk, skb)) {
+                atomic_inc(&sk->sk_drops);
+                goto discard_and_relse;
+        }
         if (nested)
                 bh_lock_sock_nested(sk);
         else
@@ -364,11 +368,11 @@ EXPORT_SYMBOL(sk_reset_txq);
 
 struct dst_entry *__sk_dst_check(struct sock *sk, u32 cookie)
 {
-        struct dst_entry *dst = sk->sk_dst_cache;
+        struct dst_entry *dst = __sk_dst_get(sk);
 
         if (dst && dst->obsolete && dst->ops->check(dst, cookie) == NULL) {
                 sk_tx_queue_clear(sk);
-                sk->sk_dst_cache = NULL;
+                rcu_assign_pointer(sk->sk_dst_cache, NULL);
                 dst_release(dst);
                 return NULL;
         }
@@ -1157,7 +1161,7 @@ struct sock *sk_clone(const struct sock *sk, const gfp_t priority)
                 skb_queue_head_init(&newsk->sk_async_wait_queue);
 #endif
 
-                rwlock_init(&newsk->sk_dst_lock);
+                spin_lock_init(&newsk->sk_dst_lock);
                 rwlock_init(&newsk->sk_callback_lock);
                 lockdep_set_class_and_name(&newsk->sk_callback_lock,
                                 af_callback_keys + newsk->sk_family,
@@ -1207,7 +1211,7 @@ struct sock *sk_clone(const struct sock *sk, const gfp_t priority)
                  */
                 sk_refcnt_debug_inc(newsk);
                 sk_set_socket(newsk, NULL);
-                newsk->sk_sleep  = NULL;
+                newsk->sk_wq = NULL;
 
                 if (newsk->sk_prot->sockets_allocated)
                         percpu_counter_inc(newsk->sk_prot->sockets_allocated);
@@ -1395,7 +1399,7 @@ static long sock_wait_for_wmem(struct sock *sk, long timeo)
                 if (signal_pending(current))
                         break;
                 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
-                prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+                prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
                 if (atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf)
                         break;
                 if (sk->sk_shutdown & SEND_SHUTDOWN)
@@ -1404,7 +1408,7 @@ static long sock_wait_for_wmem(struct sock *sk, long timeo)
                         break;
                 timeo = schedule_timeout(timeo);
         }
-        finish_wait(sk->sk_sleep, &wait);
+        finish_wait(sk_sleep(sk), &wait);
         return timeo;
 }
 
@@ -1570,11 +1574,11 @@ int sk_wait_data(struct sock *sk, long *timeo)
         int rc;
         DEFINE_WAIT(wait);
 
-        prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+        prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
         set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
         rc = sk_wait_event(sk, timeo, !skb_queue_empty(&sk->sk_receive_queue));
         clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
-        finish_wait(sk->sk_sleep, &wait);
+        finish_wait(sk_sleep(sk), &wait);
         return rc;
 }
 EXPORT_SYMBOL(sk_wait_data);
@@ -1796,41 +1800,53 @@ EXPORT_SYMBOL(sock_no_sendpage);
 
 static void sock_def_wakeup(struct sock *sk)
 {
-        read_lock(&sk->sk_callback_lock);
-        if (sk_has_sleeper(sk))
-                wake_up_interruptible_all(sk->sk_sleep);
-        read_unlock(&sk->sk_callback_lock);
+        struct socket_wq *wq;
+
+        rcu_read_lock();
+        wq = rcu_dereference(sk->sk_wq);
+        if (wq_has_sleeper(wq))
+                wake_up_interruptible_all(&wq->wait);
+        rcu_read_unlock();
 }
 
 static void sock_def_error_report(struct sock *sk)
 {
-        read_lock(&sk->sk_callback_lock);
-        if (sk_has_sleeper(sk))
-                wake_up_interruptible_poll(sk->sk_sleep, POLLERR);
+        struct socket_wq *wq;
+
+        rcu_read_lock();
+        wq = rcu_dereference(sk->sk_wq);
+        if (wq_has_sleeper(wq))
+                wake_up_interruptible_poll(&wq->wait, POLLERR);
         sk_wake_async(sk, SOCK_WAKE_IO, POLL_ERR);
-        read_unlock(&sk->sk_callback_lock);
+        rcu_read_unlock();
 }
 
 static void sock_def_readable(struct sock *sk, int len)
 {
-        read_lock(&sk->sk_callback_lock);
-        if (sk_has_sleeper(sk))
-                wake_up_interruptible_sync_poll(sk->sk_sleep, POLLIN |
+        struct socket_wq *wq;
+
+        rcu_read_lock();
+        wq = rcu_dereference(sk->sk_wq);
+        if (wq_has_sleeper(wq))
+                wake_up_interruptible_sync_poll(&wq->wait, POLLIN |
                                                 POLLRDNORM | POLLRDBAND);
         sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
-        read_unlock(&sk->sk_callback_lock);
+        rcu_read_unlock();
 }
 
 static void sock_def_write_space(struct sock *sk)
 {
-        read_lock(&sk->sk_callback_lock);
+        struct socket_wq *wq;
+
+        rcu_read_lock();
 
         /* Do not wake up a writer until he can make "significant"
          * progress.  --DaveM
          */
         if ((atomic_read(&sk->sk_wmem_alloc) << 1) <= sk->sk_sndbuf) {
-                if (sk_has_sleeper(sk))
-                        wake_up_interruptible_sync_poll(sk->sk_sleep, POLLOUT |
+                wq = rcu_dereference(sk->sk_wq);
+                if (wq_has_sleeper(wq))
+                        wake_up_interruptible_sync_poll(&wq->wait, POLLOUT |
                                                 POLLWRNORM | POLLWRBAND);
 
                 /* Should agree with poll, otherwise some programs break */
@@ -1838,7 +1854,7 @@ static void sock_def_write_space(struct sock *sk)
                         sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
         }
 
-        read_unlock(&sk->sk_callback_lock);
+        rcu_read_unlock();
 }
 
 static void sock_def_destruct(struct sock *sk)
@@ -1885,7 +1901,6 @@ void sock_init_data(struct socket *sock, struct sock *sk)
         sk->sk_allocation       =       GFP_KERNEL;
         sk->sk_rcvbuf           =       sysctl_rmem_default;
         sk->sk_sndbuf           =       sysctl_wmem_default;
-        sk->sk_backlog.limit    =       sk->sk_rcvbuf << 1;
         sk->sk_state            =       TCP_CLOSE;
         sk_set_socket(sk, sock);
 
@@ -1893,12 +1908,12 @@ void sock_init_data(struct socket *sock, struct sock *sk)
 
         if (sock) {
                 sk->sk_type     =       sock->type;
-                sk->sk_sleep    =       &sock->wait;
+                sk->sk_wq       =       sock->wq;
                 sock->sk        =       sk;
         } else
-                sk->sk_sleep    =       NULL;
+                sk->sk_wq       =       NULL;
 
-        rwlock_init(&sk->sk_dst_lock);
+        spin_lock_init(&sk->sk_dst_lock);
         rwlock_init(&sk->sk_callback_lock);
         lockdep_set_class_and_name(&sk->sk_callback_lock,
                         af_callback_keys + sk->sk_family,
diff --git a/net/core/stream.c b/net/core/stream.c
index a37debfeb1b2..cc196f42b8d8 100644
--- a/net/core/stream.c
+++ b/net/core/stream.c
@@ -28,15 +28,19 @@
 void sk_stream_write_space(struct sock *sk)
 {
         struct socket *sock = sk->sk_socket;
+        struct socket_wq *wq;
 
         if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk) && sock) {
                 clear_bit(SOCK_NOSPACE, &sock->flags);
 
-                if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
-                        wake_up_interruptible_poll(sk->sk_sleep, POLLOUT |
+                rcu_read_lock();
+                wq = rcu_dereference(sk->sk_wq);
+                if (wq_has_sleeper(wq))
+                        wake_up_interruptible_poll(&wq->wait, POLLOUT |
                                                 POLLWRNORM | POLLWRBAND);
-                if (sock->fasync_list && !(sk->sk_shutdown & SEND_SHUTDOWN))
+                if (wq && wq->fasync_list && !(sk->sk_shutdown & SEND_SHUTDOWN))
                         sock_wake_async(sock, SOCK_WAKE_SPACE, POLL_OUT);
+                rcu_read_unlock();
         }
 }
 
@@ -66,13 +70,13 @@ int sk_stream_wait_connect(struct sock *sk, long *timeo_p)
                 if (signal_pending(tsk))
                         return sock_intr_errno(*timeo_p);
 
-                prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+                prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
                 sk->sk_write_pending++;
                 done = sk_wait_event(sk, timeo_p,
                                      !sk->sk_err &&
                                      !((1 << sk->sk_state) &
                                        ~(TCPF_ESTABLISHED | TCPF_CLOSE_WAIT)));
-                finish_wait(sk->sk_sleep, &wait);
+                finish_wait(sk_sleep(sk), &wait);
                 sk->sk_write_pending--;
         } while (!done);
         return 0;
@@ -96,13 +100,13 @@ void sk_stream_wait_close(struct sock *sk, long timeout)
                 DEFINE_WAIT(wait);
 
                 do {
-                        prepare_to_wait(sk->sk_sleep, &wait,
+                        prepare_to_wait(sk_sleep(sk), &wait,
                                         TASK_INTERRUPTIBLE);
                         if (sk_wait_event(sk, &timeout, !sk_stream_closing(sk)))
                                 break;
                 } while (!signal_pending(current) && timeout);
 
-                finish_wait(sk->sk_sleep, &wait);
+                finish_wait(sk_sleep(sk), &wait);
         }
 }
 
@@ -126,7 +130,7 @@ int sk_stream_wait_memory(struct sock *sk, long *timeo_p)
         while (1) {
                 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
 
-                prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+                prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
 
                 if (sk->sk_err || (sk->sk_shutdown & SEND_SHUTDOWN))
                         goto do_error;
@@ -157,7 +161,7 @@ int sk_stream_wait_memory(struct sock *sk, long *timeo_p)
                 *timeo_p = current_timeo;
         }
 out:
-        finish_wait(sk->sk_sleep, &wait);
+        finish_wait(sk_sleep(sk), &wait);
         return err;
 
 do_error:
diff --git a/net/core/sysctl_net_core.c b/net/core/sysctl_net_core.c
index 06124872af5b..dcc7d25996ab 100644
--- a/net/core/sysctl_net_core.c
+++ b/net/core/sysctl_net_core.c
@@ -11,11 +11,72 @@
 #include <linux/socket.h>
 #include <linux/netdevice.h>
 #include <linux/ratelimit.h>
+#include <linux/vmalloc.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 
 #include <net/ip.h>
 #include <net/sock.h>
 
+#ifdef CONFIG_RPS
+static int rps_sock_flow_sysctl(ctl_table *table, int write,
+                                void __user *buffer, size_t *lenp, loff_t *ppos)
+{
+        unsigned int orig_size, size;
+        int ret, i;
+        ctl_table tmp = {
+                .data = &size,
+                .maxlen = sizeof(size),
+                .mode = table->mode
+        };
+        struct rps_sock_flow_table *orig_sock_table, *sock_table;
+        static DEFINE_MUTEX(sock_flow_mutex);
+
+        mutex_lock(&sock_flow_mutex);
+
+        orig_sock_table = rps_sock_flow_table;
+        size = orig_size = orig_sock_table ? orig_sock_table->mask + 1 : 0;
+
+        ret = proc_dointvec(&tmp, write, buffer, lenp, ppos);
+
+        if (write) {
+                if (size) {
+                        if (size > 1<<30) {
+                                /* Enforce limit to prevent overflow */
+                                mutex_unlock(&sock_flow_mutex);
+                                return -EINVAL;
+                        }
+                        size = roundup_pow_of_two(size);
+                        if (size != orig_size) {
+                                sock_table =
+                                    vmalloc(RPS_SOCK_FLOW_TABLE_SIZE(size));
+                                if (!sock_table) {
+                                        mutex_unlock(&sock_flow_mutex);
+                                        return -ENOMEM;
+                                }
+
+                                sock_table->mask = size - 1;
+                        } else
+                                sock_table = orig_sock_table;
+
+                        for (i = 0; i < size; i++)
+                                sock_table->ents[i] = RPS_NO_CPU;
+                } else
+                        sock_table = NULL;
+
+                if (sock_table != orig_sock_table) {
+                        rcu_assign_pointer(rps_sock_flow_table, sock_table);
+                        synchronize_rcu();
+                        vfree(orig_sock_table);
+                }
+        }
+
+        mutex_unlock(&sock_flow_mutex);
+
+        return ret;
+}
+#endif /* CONFIG_RPS */
+
 static struct ctl_table net_core_table[] = {
 #ifdef CONFIG_NET
         {
@@ -81,6 +142,14 @@ static struct ctl_table net_core_table[] = {
                 .mode           = 0644,
                 .proc_handler   = proc_dointvec
         },
+#ifdef CONFIG_RPS
+        {
+                .procname       = "rps_sock_flow_entries",
+                .maxlen         = sizeof(int),
+                .mode           = 0644,
+                .proc_handler   = rps_sock_flow_sysctl
+        },
+#endif
 #endif /* CONFIG_NET */
         {
                 .procname       = "netdev_budget",
diff --git a/net/dcb/dcbnl.c b/net/dcb/dcbnl.c
index 813e399220a7..19ac2b985485 100644
--- a/net/dcb/dcbnl.c
+++ b/net/dcb/dcbnl.c
@@ -19,6 +19,7 @@
 
 #include <linux/netdevice.h>
 #include <linux/netlink.h>
+#include <linux/slab.h>
 #include <net/netlink.h>
 #include <net/rtnetlink.h>
 #include <linux/dcbnl.h>
diff --git a/net/dccp/ccid.c b/net/dccp/ccid.c
index 49d27c556bec..36479ca61e03 100644
--- a/net/dccp/ccid.c
+++ b/net/dccp/ccid.c
@@ -11,6 +11,8 @@
  *      published by the Free Software Foundation.
  */
 
+#include <linux/slab.h>
+
 #include "ccid.h"
 #include "ccids/lib/tfrc.h"
 
diff --git a/net/dccp/ccids/ccid2.c b/net/dccp/ccids/ccid2.c
index a47a8c918ee8..9b3ae9922be1 100644
--- a/net/dccp/ccids/ccid2.c
+++ b/net/dccp/ccids/ccid2.c
@@ -23,6 +23,7 @@
 /*
  * This implementation should follow RFC 4341
  */
+#include <linux/slab.h>
 #include "../feat.h"
 #include "../ccid.h"
 #include "../dccp.h"
diff --git a/net/dccp/ccids/ccid3.c b/net/dccp/ccids/ccid3.c
index bcd7632299f5..d3235899c7e3 100644
--- a/net/dccp/ccids/ccid3.c
+++ b/net/dccp/ccids/ccid3.c
@@ -208,7 +208,7 @@ static void ccid3_hc_tx_no_feedback_timer(unsigned long data)
                 goto restart_timer;
         }
 
-        ccid3_pr_debug("%s(%p, state=%s) - entry \n", dccp_role(sk), sk,
+        ccid3_pr_debug("%s(%p, state=%s) - entry\n", dccp_role(sk), sk,
                        ccid3_tx_state_name(hc->tx_state));
 
         if (hc->tx_state == TFRC_SSTATE_FBACK)
diff --git a/net/dccp/dccp.h b/net/dccp/dccp.h
index 5ef32c2f0d6a..a10a61a1ded2 100644
--- a/net/dccp/dccp.h
+++ b/net/dccp/dccp.h
@@ -189,7 +189,7 @@ enum {
 #define DCCP_MIB_MAX    __DCCP_MIB_MAX
 struct dccp_mib {
         unsigned long   mibs[DCCP_MIB_MAX];
-} __SNMP_MIB_ALIGN__;
+};
 
 DECLARE_SNMP_STAT(struct dccp_mib, dccp_statistics);
 #define DCCP_INC_STATS(field)       SNMP_INC_STATS(dccp_statistics, field)
@@ -223,7 +223,7 @@ static inline void dccp_csum_outgoing(struct sk_buff *skb)
         skb->csum = skb_checksum(skb, 0, (cov > skb->len)? skb->len : cov, 0);
 }
 
-extern void dccp_v4_send_check(struct sock *sk, int len, struct sk_buff *skb);
+extern void dccp_v4_send_check(struct sock *sk, struct sk_buff *skb);
 
 extern int  dccp_retransmit_skb(struct sock *sk);
 
diff --git a/net/dccp/feat.c b/net/dccp/feat.c
index 972b8dc918d6..df7dd26cf07e 100644
--- a/net/dccp/feat.c
+++ b/net/dccp/feat.c
@@ -22,6 +22,7 @@
  *  2 of the License, or (at your option) any later version.
  */
 #include <linux/module.h>
+#include <linux/slab.h>
 #include "ccid.h"
 #include "feat.h"
 
diff --git a/net/dccp/input.c b/net/dccp/input.c
index 7648f316310f..58f7bc156850 100644
--- a/net/dccp/input.c
+++ b/net/dccp/input.c
@@ -12,6 +12,7 @@
 
 #include <linux/dccp.h>
 #include <linux/skbuff.h>
+#include <linux/slab.h>
 
 #include <net/sock.h>
 
@@ -414,7 +415,7 @@ static int dccp_rcv_request_sent_state_process(struct sock *sk,
                 if (!between48(DCCP_SKB_CB(skb)->dccpd_ack_seq,
                                dp->dccps_awl, dp->dccps_awh)) {
                         dccp_pr_debug("invalid ackno: S.AWL=%llu, "
-                                      "P.ackno=%llu, S.AWH=%llu \n",
+                                      "P.ackno=%llu, S.AWH=%llu\n",
                                       (unsigned long long)dp->dccps_awl,
                            (unsigned long long)DCCP_SKB_CB(skb)->dccpd_ack_seq,
                                       (unsigned long long)dp->dccps_awh);
diff --git a/net/dccp/ipv4.c b/net/dccp/ipv4.c
index b195c4feaa0a..d9b11ef8694c 100644
--- a/net/dccp/ipv4.c
+++ b/net/dccp/ipv4.c
@@ -12,6 +12,7 @@
 
 #include <linux/dccp.h>
 #include <linux/icmp.h>
+#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/skbuff.h>
 #include <linux/random.h>
@@ -348,7 +349,7 @@ static inline __sum16 dccp_v4_csum_finish(struct sk_buff *skb,
         return csum_tcpudp_magic(src, dst, skb->len, IPPROTO_DCCP, skb->csum);
 }
 
-void dccp_v4_send_check(struct sock *sk, int unused, struct sk_buff *skb)
+void dccp_v4_send_check(struct sock *sk, struct sk_buff *skb)
 {
         const struct inet_sock *inet = inet_sk(sk);
         struct dccp_hdr *dh = dccp_hdr(skb);
@@ -998,11 +999,11 @@ static struct inet_protosw dccp_v4_protosw = {
 
 static int __net_init dccp_v4_init_net(struct net *net)
 {
-        int err;
+        if (dccp_hashinfo.bhash == NULL)
+                return -ESOCKTNOSUPPORT;
 
-        err = inet_ctl_sock_create(&net->dccp.v4_ctl_sk, PF_INET,
-                                   SOCK_DCCP, IPPROTO_DCCP, net);
-        return err;
+        return inet_ctl_sock_create(&net->dccp.v4_ctl_sk, PF_INET,
+                                    SOCK_DCCP, IPPROTO_DCCP, net);
 }
 
 static void __net_exit dccp_v4_exit_net(struct net *net)
diff --git a/net/dccp/ipv6.c b/net/dccp/ipv6.c
index 1aec6349e858..091698899594 100644
--- a/net/dccp/ipv6.c
+++ b/net/dccp/ipv6.c
@@ -14,6 +14,7 @@
 
 #include <linux/module.h>
 #include <linux/random.h>
+#include <linux/slab.h>
 #include <linux/xfrm.h>
 
 #include <net/addrconf.h>
@@ -59,8 +60,7 @@ static inline __sum16 dccp_v6_csum_finish(struct sk_buff *skb,
         return csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_DCCP, skb->csum);
 }
 
-static inline void dccp_v6_send_check(struct sock *sk, int unused_value,
-                                      struct sk_buff *skb)
+static inline void dccp_v6_send_check(struct sock *sk, struct sk_buff *skb)
 {
         struct ipv6_pinfo *np = inet6_sk(sk);
         struct dccp_hdr *dh = dccp_hdr(skb);
@@ -292,7 +292,7 @@ static int dccp_v6_send_response(struct sock *sk, struct request_sock *req,
                                                          &ireq6->loc_addr,
                                                          &ireq6->rmt_addr);
                 ipv6_addr_copy(&fl.fl6_dst, &ireq6->rmt_addr);
-                err = ip6_xmit(sk, skb, &fl, opt, 0);
+                err = ip6_xmit(sk, skb, &fl, opt);
                 err = net_xmit_eval(err);
         }
 
@@ -347,7 +347,7 @@ static void dccp_v6_ctl_send_reset(struct sock *sk, struct sk_buff *rxskb)
         if (!ip6_dst_lookup(ctl_sk, &dst, &fl)) {
                 if (xfrm_lookup(net, &dst, &fl, NULL, 0) >= 0) {
                         skb_dst_set(skb, dst);
-                        ip6_xmit(ctl_sk, skb, &fl, NULL, 0);
+                        ip6_xmit(ctl_sk, skb, &fl, NULL);
                         DCCP_INC_STATS_BH(DCCP_MIB_OUTSEGS);
                         DCCP_INC_STATS_BH(DCCP_MIB_OUTRSTS);
                         return;
@@ -1191,11 +1191,11 @@ static struct inet_protosw dccp_v6_protosw = {
 
 static int __net_init dccp_v6_init_net(struct net *net)
 {
-        int err;
+        if (dccp_hashinfo.bhash == NULL)
+                return -ESOCKTNOSUPPORT;
 
-        err = inet_ctl_sock_create(&net->dccp.v6_ctl_sk, PF_INET6,
-                                   SOCK_DCCP, IPPROTO_DCCP, net);
-        return err;
+        return inet_ctl_sock_create(&net->dccp.v6_ctl_sk, PF_INET6,
+                                    SOCK_DCCP, IPPROTO_DCCP, net);
 }
 
 static void __net_exit dccp_v6_exit_net(struct net *net)
diff --git a/net/dccp/minisocks.c b/net/dccp/minisocks.c
index 0d508c359fa9..128b089d3aef 100644
--- a/net/dccp/minisocks.c
+++ b/net/dccp/minisocks.c
@@ -11,6 +11,7 @@
  */
 
 #include <linux/dccp.h>
+#include <linux/gfp.h>
 #include <linux/kernel.h>
 #include <linux/skbuff.h>
 #include <linux/timer.h>
diff --git a/net/dccp/output.c b/net/dccp/output.c
index d6bb753bf6ad..aadbdb58758b 100644
--- a/net/dccp/output.c
+++ b/net/dccp/output.c
@@ -13,6 +13,7 @@
 #include <linux/dccp.h>
 #include <linux/kernel.h>
 #include <linux/skbuff.h>
+#include <linux/slab.h>
 
 #include <net/inet_sock.h>
 #include <net/sock.h>
@@ -128,14 +129,14 @@ static int dccp_transmit_skb(struct sock *sk, struct sk_buff *skb)
                         break;
                 }
 
-                icsk->icsk_af_ops->send_check(sk, 0, skb);
+                icsk->icsk_af_ops->send_check(sk, skb);
 
                 if (set_ack)
                         dccp_event_ack_sent(sk);
 
                 DCCP_INC_STATS(DCCP_MIB_OUTSEGS);
 
-                err = icsk->icsk_af_ops->queue_xmit(skb, 0);
+                err = icsk->icsk_af_ops->queue_xmit(skb);
                 return net_xmit_eval(err);
         }
         return -ENOBUFS;
@@ -194,15 +195,17 @@ EXPORT_SYMBOL_GPL(dccp_sync_mss);
 
 void dccp_write_space(struct sock *sk)
 {
-        read_lock(&sk->sk_callback_lock);
+        struct socket_wq *wq;
 
-        if (sk_has_sleeper(sk))
-                wake_up_interruptible(sk->sk_sleep);
+        rcu_read_lock();
+        wq = rcu_dereference(sk->sk_wq);
+        if (wq_has_sleeper(wq))
+                wake_up_interruptible(&wq->wait);
         /* Should agree with poll, otherwise some programs break */
         if (sock_writeable(sk))
                 sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
 
-        read_unlock(&sk->sk_callback_lock);
+        rcu_read_unlock();
 }
 
 /**
@@ -224,7 +227,7 @@ static int dccp_wait_for_ccid(struct sock *sk, struct sk_buff *skb, int delay)
                 dccp_pr_debug("delayed send by %d msec\n", delay);
                 jiffdelay = msecs_to_jiffies(delay);
 
-                prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+                prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
 
                 sk->sk_write_pending++;
                 release_sock(sk);
@@ -240,7 +243,7 @@ static int dccp_wait_for_ccid(struct sock *sk, struct sk_buff *skb, int delay)
                 rc = ccid_hc_tx_send_packet(dp->dccps_hc_tx_ccid, sk, skb);
         } while ((delay = rc) > 0);
 out:
-        finish_wait(sk->sk_sleep, &wait);
+        finish_wait(sk_sleep(sk), &wait);
         return rc;
 
 do_error:
diff --git a/net/dccp/probe.c b/net/dccp/probe.c
index f5b3464f1242..078e48d442fd 100644
--- a/net/dccp/probe.c
+++ b/net/dccp/probe.c
@@ -30,6 +30,7 @@
 #include <linux/module.h>
 #include <linux/kfifo.h>
 #include <linux/vmalloc.h>
+#include <linux/gfp.h>
 #include <net/net_namespace.h>
 
 #include "dccp.h"
diff --git a/net/dccp/proto.c b/net/dccp/proto.c
index 0ef7061920c0..b03ecf6b2bb0 100644
--- a/net/dccp/proto.c
+++ b/net/dccp/proto.c
@@ -20,6 +20,7 @@
 #include <linux/if_arp.h>
 #include <linux/init.h>
 #include <linux/random.h>
+#include <linux/slab.h>
 #include <net/checksum.h>
 
 #include <net/inet_sock.h>
@@ -311,7 +312,7 @@ unsigned int dccp_poll(struct file *file, struct socket *sock,
         unsigned int mask;
         struct sock *sk = sock->sk;
 
-        sock_poll_wait(file, sk->sk_sleep, wait);
+        sock_poll_wait(file, sk_sleep(sk), wait);
         if (sk->sk_state == DCCP_LISTEN)
                 return inet_csk_listen_poll(sk);
 
@@ -1036,7 +1037,7 @@ static int __init dccp_init(void)
                      FIELD_SIZEOF(struct sk_buff, cb));
         rc = percpu_counter_init(&dccp_orphan_count, 0);
         if (rc)
-                goto out;
+                goto out_fail;
         rc = -ENOBUFS;
         inet_hashinfo_init(&dccp_hashinfo);
         dccp_hashinfo.bind_bucket_cachep =
@@ -1125,8 +1126,9 @@ static int __init dccp_init(void)
                 goto out_sysctl_exit;
 
         dccp_timestamping_init();
-out:
-        return rc;
+
+        return 0;
+
 out_sysctl_exit:
         dccp_sysctl_exit();
 out_ackvec_exit:
@@ -1135,18 +1137,19 @@ out_free_dccp_mib:
         dccp_mib_exit();
 out_free_dccp_bhash:
         free_pages((unsigned long)dccp_hashinfo.bhash, bhash_order);
-        dccp_hashinfo.bhash = NULL;
 out_free_dccp_locks:
         inet_ehash_locks_free(&dccp_hashinfo);
 out_free_dccp_ehash:
         free_pages((unsigned long)dccp_hashinfo.ehash, ehash_order);
-        dccp_hashinfo.ehash = NULL;
 out_free_bind_bucket_cachep:
         kmem_cache_destroy(dccp_hashinfo.bind_bucket_cachep);
-        dccp_hashinfo.bind_bucket_cachep = NULL;
 out_free_percpu:
         percpu_counter_destroy(&dccp_orphan_count);
-        goto out;
+out_fail:
+        dccp_hashinfo.bhash = NULL;
+        dccp_hashinfo.ehash = NULL;
+        dccp_hashinfo.bind_bucket_cachep = NULL;
+        return rc;
 }
 
 static void __exit dccp_fini(void)
diff --git a/net/dccp/timer.c b/net/dccp/timer.c
index bbfeb5eae46a..1a9aa05d4dc4 100644
--- a/net/dccp/timer.c
+++ b/net/dccp/timer.c
@@ -38,7 +38,7 @@ static int dccp_write_timeout(struct sock *sk)
 
         if (sk->sk_state == DCCP_REQUESTING || sk->sk_state == DCCP_PARTOPEN) {
                 if (icsk->icsk_retransmits != 0)
-                        dst_negative_advice(&sk->sk_dst_cache, sk);
+                        dst_negative_advice(sk);
                 retry_until = icsk->icsk_syn_retries ?
                             : sysctl_dccp_request_retries;
         } else {
@@ -63,7 +63,7 @@ static int dccp_write_timeout(struct sock *sk)
                            Golden words :-).
                    */
 
-                        dst_negative_advice(&sk->sk_dst_cache, sk);
+                        dst_negative_advice(sk);
                 }
 
                 retry_until = sysctl_dccp_retries2;
diff --git a/net/decnet/af_decnet.c b/net/decnet/af_decnet.c
index 2b494fac9468..d6b93d19790f 100644
--- a/net/decnet/af_decnet.c
+++ b/net/decnet/af_decnet.c
@@ -446,7 +446,7 @@ static void dn_destruct(struct sock *sk)
         skb_queue_purge(&scp->other_xmit_queue);
         skb_queue_purge(&scp->other_receive_queue);
 
-        dst_release(xchg(&sk->sk_dst_cache, NULL));
+        dst_release(rcu_dereference_check(sk->sk_dst_cache, 1));
 }
 
 static int dn_memory_pressure;
@@ -832,7 +832,7 @@ static int dn_confirm_accept(struct sock *sk, long *timeo, gfp_t allocation)
         scp->segsize_loc = dst_metric(__sk_dst_get(sk), RTAX_ADVMSS);
         dn_send_conn_conf(sk, allocation);
 
-        prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+        prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
         for(;;) {
                 release_sock(sk);
                 if (scp->state == DN_CC)
@@ -850,9 +850,9 @@ static int dn_confirm_accept(struct sock *sk, long *timeo, gfp_t allocation)
                 err = -EAGAIN;
                 if (!*timeo)
                         break;
-                prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+                prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
         }
-        finish_wait(sk->sk_sleep, &wait);
+        finish_wait(sk_sleep(sk), &wait);
         if (err == 0) {
                 sk->sk_socket->state = SS_CONNECTED;
         } else if (scp->state != DN_CC) {
@@ -873,7 +873,7 @@ static int dn_wait_run(struct sock *sk, long *timeo)
         if (!*timeo)
                 return -EALREADY;
 
-        prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+        prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
         for(;;) {
                 release_sock(sk);
                 if (scp->state == DN_CI || scp->state == DN_CC)
@@ -891,9 +891,9 @@ static int dn_wait_run(struct sock *sk, long *timeo)
                 err = -ETIMEDOUT;
                 if (!*timeo)
                         break;
-                prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+                prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
         }
-        finish_wait(sk->sk_sleep, &wait);
+        finish_wait(sk_sleep(sk), &wait);
 out:
         if (err == 0) {
                 sk->sk_socket->state = SS_CONNECTED;
@@ -1040,7 +1040,7 @@ static struct sk_buff *dn_wait_for_connect(struct sock *sk, long *timeo)
         struct sk_buff *skb = NULL;
         int err = 0;
 
-        prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+        prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
         for(;;) {
                 release_sock(sk);
                 skb = skb_dequeue(&sk->sk_receive_queue);
@@ -1060,9 +1060,9 @@ static struct sk_buff *dn_wait_for_connect(struct sock *sk, long *timeo)
                 err = -EAGAIN;
                 if (!*timeo)
                         break;
-                prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+                prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
         }
-        finish_wait(sk->sk_sleep, &wait);
+        finish_wait(sk_sleep(sk), &wait);
 
         return skb == NULL ? ERR_PTR(err) : skb;
 }
@@ -1105,7 +1105,7 @@ static int dn_accept(struct socket *sock, struct socket *newsock, int flags)
         release_sock(sk);
 
         dst = skb_dst(skb);
-        dst_release(xchg(&newsk->sk_dst_cache, dst));
+        sk_dst_set(newsk, dst);
         skb_dst_set(skb, NULL);
 
         DN_SK(newsk)->state        = DN_CR;
@@ -1746,11 +1746,11 @@ static int dn_recvmsg(struct kiocb *iocb, struct socket *sock,
                         goto out;
                 }
 
-                prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+                prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
                 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
                 sk_wait_event(sk, &timeo, dn_data_ready(sk, queue, flags, target));
                 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
-                finish_wait(sk->sk_sleep, &wait);
+                finish_wait(sk_sleep(sk), &wait);
         }
 
         skb_queue_walk_safe(queue, skb, n) {
@@ -1956,7 +1956,7 @@ static int dn_sendmsg(struct kiocb *iocb, struct socket *sock,
         }
 
         if ((flags & MSG_TRYHARD) && sk->sk_dst_cache)
-                dst_negative_advice(&sk->sk_dst_cache, sk);
+                dst_negative_advice(sk);
 
         mss = scp->segsize_rem;
         fctype = scp->services_rem & NSP_FC_MASK;
@@ -2003,12 +2003,12 @@ static int dn_sendmsg(struct kiocb *iocb, struct socket *sock,
                                 goto out;
                         }
 
-                        prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+                        prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
                         set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
                         sk_wait_event(sk, &timeo,
                                       !dn_queue_too_long(scp, queue, flags));
                         clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
-                        finish_wait(sk->sk_sleep, &wait);
+                        finish_wait(sk_sleep(sk), &wait);
                         continue;
                 }
 
diff --git a/net/decnet/dn_dev.c b/net/decnet/dn_dev.c
index 238af093495b..615dbe3b43f9 100644
--- a/net/decnet/dn_dev.c
+++ b/net/decnet/dn_dev.c
@@ -40,6 +40,7 @@
 #include <linux/skbuff.h>
 #include <linux/sysctl.h>
 #include <linux/notifier.h>
+#include <linux/slab.h>
 #include <asm/uaccess.h>
 #include <asm/system.h>
 #include <net/net_namespace.h>
@@ -349,7 +350,7 @@ static void dn_dev_del_ifa(struct dn_dev *dn_db, struct dn_ifaddr **ifap, int de
         if (dn_db->dev->type == ARPHRD_ETHER) {
                 if (ifa1->ifa_local != dn_eth2dn(dev->dev_addr)) {
                         dn_dn2eth(mac_addr, ifa1->ifa_local);
-                        dev_mc_delete(dev, mac_addr, ETH_ALEN, 0);
+                        dev_mc_del(dev, mac_addr);
                 }
         }
 
@@ -380,7 +381,7 @@ static int dn_dev_insert_ifa(struct dn_dev *dn_db, struct dn_ifaddr *ifa)
         if (dev->type == ARPHRD_ETHER) {
                 if (ifa->ifa_local != dn_eth2dn(dev->dev_addr)) {
                         dn_dn2eth(mac_addr, ifa->ifa_local);
-                        dev_mc_add(dev, mac_addr, ETH_ALEN, 0);
+                        dev_mc_add(dev, mac_addr);
                 }
         }
 
@@ -1000,9 +1001,9 @@ static int dn_eth_up(struct net_device *dev)
         struct dn_dev *dn_db = dev->dn_ptr;
 
         if (dn_db->parms.forwarding == 0)
-                dev_mc_add(dev, dn_rt_all_end_mcast, ETH_ALEN, 0);
+                dev_mc_add(dev, dn_rt_all_end_mcast);
         else
-                dev_mc_add(dev, dn_rt_all_rt_mcast, ETH_ALEN, 0);
+                dev_mc_add(dev, dn_rt_all_rt_mcast);
 
         dn_db->use_long = 1;
 
@@ -1014,9 +1015,9 @@ static void dn_eth_down(struct net_device *dev)
         struct dn_dev *dn_db = dev->dn_ptr;
 
         if (dn_db->parms.forwarding == 0)
-                dev_mc_delete(dev, dn_rt_all_end_mcast, ETH_ALEN, 0);
+                dev_mc_del(dev, dn_rt_all_end_mcast);
         else
-                dev_mc_delete(dev, dn_rt_all_rt_mcast, ETH_ALEN, 0);
+                dev_mc_del(dev, dn_rt_all_rt_mcast);
 }
 
 static void dn_dev_set_timer(struct net_device *dev);
diff --git a/net/decnet/dn_fib.c b/net/decnet/dn_fib.c
index e9d48700e83a..4ab96c15166d 100644
--- a/net/decnet/dn_fib.c
+++ b/net/decnet/dn_fib.c
@@ -20,6 +20,7 @@
 #include <linux/string.h>
 #include <linux/net.h>
 #include <linux/socket.h>
+#include <linux/slab.h>
 #include <linux/sockios.h>
 #include <linux/init.h>
 #include <linux/skbuff.h>
diff --git a/net/decnet/dn_neigh.c b/net/decnet/dn_neigh.c
index 794b5bf95af1..deb723dba44b 100644
--- a/net/decnet/dn_neigh.c
+++ b/net/decnet/dn_neigh.c
@@ -28,6 +28,7 @@
 #include <linux/module.h>
 #include <linux/socket.h>
 #include <linux/if_arp.h>
+#include <linux/slab.h>
 #include <linux/if_ether.h>
 #include <linux/init.h>
 #include <linux/proc_fs.h>
diff --git a/net/decnet/dn_nsp_in.c b/net/decnet/dn_nsp_in.c
index 932408dca86d..25a37299bc65 100644
--- a/net/decnet/dn_nsp_in.c
+++ b/net/decnet/dn_nsp_in.c
@@ -57,6 +57,7 @@
 #include <linux/netdevice.h>
 #include <linux/inet.h>
 #include <linux/route.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 #include <net/tcp_states.h>
 #include <asm/system.h>
diff --git a/net/decnet/dn_nsp_out.c b/net/decnet/dn_nsp_out.c
index a65e929ce76c..baeb1eaf011b 100644
--- a/net/decnet/dn_nsp_out.c
+++ b/net/decnet/dn_nsp_out.c
@@ -50,6 +50,7 @@
 #include <linux/netdevice.h>
 #include <linux/inet.h>
 #include <linux/route.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 #include <asm/system.h>
 #include <linux/fcntl.h>
diff --git a/net/decnet/dn_route.c b/net/decnet/dn_route.c
index a7bf03ca0a36..70ebe74027d5 100644
--- a/net/decnet/dn_route.c
+++ b/net/decnet/dn_route.c
@@ -66,6 +66,7 @@
 #include <linux/inet.h>
 #include <linux/route.h>
 #include <linux/in_route.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 #include <linux/mm.h>
 #include <linux/proc_fs.h>
diff --git a/net/decnet/dn_rules.c b/net/decnet/dn_rules.c
index 7466c546f286..48fdf10be7a1 100644
--- a/net/decnet/dn_rules.c
+++ b/net/decnet/dn_rules.c
@@ -196,7 +196,6 @@ static int dn_fib_rule_fill(struct fib_rule *rule, struct sk_buff *skb,
 {
         struct dn_fib_rule *r = (struct dn_fib_rule *)rule;
 
-        frh->family = AF_DECnet;
         frh->dst_len = r->dst_len;
         frh->src_len = r->src_len;
         frh->tos = 0;
@@ -212,29 +211,12 @@ nla_put_failure:
         return -ENOBUFS;
 }
 
-static u32 dn_fib_rule_default_pref(struct fib_rules_ops *ops)
-{
-        struct list_head *pos;
-        struct fib_rule *rule;
-
-        if (!list_empty(&dn_fib_rules_ops->rules_list)) {
-                pos = dn_fib_rules_ops->rules_list.next;
-                if (pos->next != &dn_fib_rules_ops->rules_list) {
-                        rule = list_entry(pos->next, struct fib_rule, list);
-                        if (rule->pref)
-                                return rule->pref - 1;
-                }
-        }
-
-        return 0;
-}
-
 static void dn_fib_rule_flush_cache(struct fib_rules_ops *ops)
 {
         dn_rt_cache_flush(-1);
 }
 
-static struct fib_rules_ops dn_fib_rules_ops_template = {
+static const struct fib_rules_ops __net_initdata dn_fib_rules_ops_template = {
         .family         = AF_DECnet,
         .rule_size      = sizeof(struct dn_fib_rule),
         .addr_size      = sizeof(u16),
@@ -243,7 +225,7 @@ static struct fib_rules_ops dn_fib_rules_ops_template = {
         .configure      = dn_fib_rule_configure,
         .compare        = dn_fib_rule_compare,
         .fill           = dn_fib_rule_fill,
-        .default_pref   = dn_fib_rule_default_pref,
+        .default_pref   = fib_default_rule_pref,
         .flush_cache    = dn_fib_rule_flush_cache,
         .nlgroup        = RTNLGRP_DECnet_RULE,
         .policy         = dn_fib_rule_policy,
diff --git a/net/decnet/dn_table.c b/net/decnet/dn_table.c
index b9a33bb5e9cc..f2abd3755690 100644
--- a/net/decnet/dn_table.c
+++ b/net/decnet/dn_table.c
@@ -15,6 +15,7 @@
 #include <linux/string.h>
 #include <linux/net.h>
 #include <linux/socket.h>
+#include <linux/slab.h>
 #include <linux/sockios.h>
 #include <linux/init.h>
 #include <linux/skbuff.h>
diff --git a/net/decnet/netfilter/dn_rtmsg.c b/net/decnet/netfilter/dn_rtmsg.c
index 6d2bd3202048..64a7f39e069f 100644
--- a/net/decnet/netfilter/dn_rtmsg.c
+++ b/net/decnet/netfilter/dn_rtmsg.c
@@ -14,6 +14,7 @@
  */
 #include <linux/module.h>
 #include <linux/skbuff.h>
+#include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/netdevice.h>
 #include <linux/netfilter.h>
diff --git a/net/dsa/dsa.c b/net/dsa/dsa.c
index 71489f69a42c..6112a12578b2 100644
--- a/net/dsa/dsa.c
+++ b/net/dsa/dsa.c
@@ -11,6 +11,7 @@
 #include <linux/list.h>
 #include <linux/netdevice.h>
 #include <linux/platform_device.h>
+#include <linux/slab.h>
 #include <net/dsa.h>
 #include "dsa_priv.h"
 
diff --git a/net/dsa/slave.c b/net/dsa/slave.c
index 2175e6d5cc8d..8fdca56bb08f 100644
--- a/net/dsa/slave.c
+++ b/net/dsa/slave.c
@@ -67,7 +67,7 @@ static int dsa_slave_open(struct net_device *dev)
                 return -ENETDOWN;
 
         if (compare_ether_addr(dev->dev_addr, master->dev_addr)) {
-                err = dev_unicast_add(master, dev->dev_addr);
+                err = dev_uc_add(master, dev->dev_addr);
                 if (err < 0)
                         goto out;
         }
@@ -90,7 +90,7 @@ clear_allmulti:
                 dev_set_allmulti(master, -1);
 del_unicast:
         if (compare_ether_addr(dev->dev_addr, master->dev_addr))
-                dev_unicast_delete(master, dev->dev_addr);
+                dev_uc_del(master, dev->dev_addr);
 out:
         return err;
 }
@@ -101,14 +101,14 @@ static int dsa_slave_close(struct net_device *dev)
         struct net_device *master = p->parent->dst->master_netdev;
 
         dev_mc_unsync(master, dev);
-        dev_unicast_unsync(master, dev);
+        dev_uc_unsync(master, dev);
         if (dev->flags & IFF_ALLMULTI)
                 dev_set_allmulti(master, -1);
         if (dev->flags & IFF_PROMISC)
                 dev_set_promiscuity(master, -1);
 
         if (compare_ether_addr(dev->dev_addr, master->dev_addr))
-                dev_unicast_delete(master, dev->dev_addr);
+                dev_uc_del(master, dev->dev_addr);
 
         return 0;
 }
@@ -130,7 +130,7 @@ static void dsa_slave_set_rx_mode(struct net_device *dev)
         struct net_device *master = p->parent->dst->master_netdev;
 
         dev_mc_sync(master, dev);
-        dev_unicast_sync(master, dev);
+        dev_uc_sync(master, dev);
 }
 
 static int dsa_slave_set_mac_address(struct net_device *dev, void *a)
@@ -147,13 +147,13 @@ static int dsa_slave_set_mac_address(struct net_device *dev, void *a)
                 goto out;
 
         if (compare_ether_addr(addr->sa_data, master->dev_addr)) {
-                err = dev_unicast_add(master, addr->sa_data);
+                err = dev_uc_add(master, addr->sa_data);
                 if (err < 0)
                         return err;
         }
 
         if (compare_ether_addr(dev->dev_addr, master->dev_addr))
-                dev_unicast_delete(master, dev->dev_addr);
+                dev_uc_del(master, dev->dev_addr);
 
 out:
         memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
diff --git a/net/dsa/tag_dsa.c b/net/dsa/tag_dsa.c
index cdf2d28a0297..98dfe80b4538 100644
--- a/net/dsa/tag_dsa.c
+++ b/net/dsa/tag_dsa.c
@@ -11,6 +11,7 @@
 #include <linux/etherdevice.h>
 #include <linux/list.h>
 #include <linux/netdevice.h>
+#include <linux/slab.h>
 #include "dsa_priv.h"
 
 #define DSA_HLEN        4
diff --git a/net/dsa/tag_edsa.c b/net/dsa/tag_edsa.c
index 8f53948cff4f..6f383322ad25 100644
--- a/net/dsa/tag_edsa.c
+++ b/net/dsa/tag_edsa.c
@@ -11,6 +11,7 @@
 #include <linux/etherdevice.h>
 #include <linux/list.h>
 #include <linux/netdevice.h>
+#include <linux/slab.h>
 #include "dsa_priv.h"
 
 #define DSA_HLEN        4
diff --git a/net/dsa/tag_trailer.c b/net/dsa/tag_trailer.c
index a85c829853c0..d6d7d0add3cb 100644
--- a/net/dsa/tag_trailer.c
+++ b/net/dsa/tag_trailer.c
@@ -11,6 +11,7 @@
 #include <linux/etherdevice.h>
 #include <linux/list.h>
 #include <linux/netdevice.h>
+#include <linux/slab.h>
 #include "dsa_priv.h"
 
 netdev_tx_t trailer_xmit(struct sk_buff *skb, struct net_device *dev)
diff --git a/net/econet/af_econet.c b/net/econet/af_econet.c
index 29b4931aae52..2a5a8053e000 100644
--- a/net/econet/af_econet.c
+++ b/net/econet/af_econet.c
@@ -30,6 +30,7 @@
 #include <linux/wireless.h>
 #include <linux/skbuff.h>
 #include <linux/udp.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 #include <net/inet_common.h>
 #include <linux/stat.h>
diff --git a/net/ethernet/eth.c b/net/ethernet/eth.c
index 205a1c12f3c0..61ec0329316c 100644
--- a/net/ethernet/eth.c
+++ b/net/ethernet/eth.c
@@ -136,7 +136,7 @@ int eth_rebuild_header(struct sk_buff *skb)
         default:
                 printk(KERN_DEBUG
                        "%s: unable to resolve type %X addresses.\n",
-                       dev->name, (int)eth->h_proto);
+                       dev->name, ntohs(eth->h_proto));
 
                 memcpy(eth->h_source, dev->dev_addr, ETH_ALEN);
                 break;
@@ -162,7 +162,7 @@ __be16 eth_type_trans(struct sk_buff *skb, struct net_device *dev)
 
         skb->dev = dev;
         skb_reset_mac_header(skb);
-        skb_pull(skb, ETH_HLEN);
+        skb_pull_inline(skb, ETH_HLEN);
         eth = eth_hdr(skb);
 
         if (unlikely(is_multicast_ether_addr(eth->h_dest))) {
diff --git a/net/ethernet/pe2.c b/net/ethernet/pe2.c
index d60e15d9365e..eb00796758c3 100644
--- a/net/ethernet/pe2.c
+++ b/net/ethernet/pe2.c
@@ -3,6 +3,7 @@
 #include <linux/module.h>
 #include <linux/netdevice.h>
 #include <linux/skbuff.h>
+#include <linux/slab.h>
 
 #include <net/datalink.h>
 
diff --git a/net/ieee802154/af_ieee802154.c b/net/ieee802154/af_ieee802154.c
index bad1c49fd960..93c91b633a56 100644
--- a/net/ieee802154/af_ieee802154.c
+++ b/net/ieee802154/af_ieee802154.c
@@ -28,6 +28,7 @@
 #include <linux/if.h>
 #include <linux/termios.h>      /* For TIOCOUTQ/INQ */
 #include <linux/list.h>
+#include <linux/slab.h>
 #include <net/datalink.h>
 #include <net/psnap.h>
 #include <net/sock.h>
@@ -126,6 +127,9 @@ static int ieee802154_sock_connect(struct socket *sock, struct sockaddr *uaddr,
 {
         struct sock *sk = sock->sk;
 
+        if (addr_len < sizeof(uaddr->sa_family))
+                return -EINVAL;
+
         if (uaddr->sa_family == AF_UNSPEC)
                 return sk->sk_prot->disconnect(sk, flags);
 
@@ -147,6 +151,9 @@ static int ieee802154_dev_ioctl(struct sock *sk, struct ifreq __user *arg,
         dev_load(sock_net(sk), ifr.ifr_name);
         dev = dev_get_by_name(sock_net(sk), ifr.ifr_name);
 
+        if (!dev)
+                return -ENODEV;
+
         if (dev->type == ARPHRD_IEEE802154 && dev->netdev_ops->ndo_do_ioctl)
                 ret = dev->netdev_ops->ndo_do_ioctl(dev, &ifr, cmd);
 
diff --git a/net/ieee802154/dgram.c b/net/ieee802154/dgram.c
index 9aac5aee1575..1a3334c2609a 100644
--- a/net/ieee802154/dgram.c
+++ b/net/ieee802154/dgram.c
@@ -25,6 +25,7 @@
 #include <linux/module.h>
 #include <linux/if_arp.h>
 #include <linux/list.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 #include <net/af_ieee802154.h>
 #include <net/ieee802154.h>
diff --git a/net/ieee802154/netlink.c b/net/ieee802154/netlink.c
index 33137b99e471..c8097ae2482f 100644
--- a/net/ieee802154/netlink.c
+++ b/net/ieee802154/netlink.c
@@ -23,6 +23,7 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/gfp.h>
 #include <net/genetlink.h>
 #include <linux/nl802154.h>
 
diff --git a/net/ieee802154/nl-mac.c b/net/ieee802154/nl-mac.c
index 135c1678fb11..71ee1108d4f8 100644
--- a/net/ieee802154/nl-mac.c
+++ b/net/ieee802154/nl-mac.c
@@ -22,6 +22,7 @@
  * Maxim Osipov <maxim.osipov@siemens.com>
  */
 
+#include <linux/gfp.h>
 #include <linux/kernel.h>
 #include <linux/if_arp.h>
 #include <linux/netdevice.h>
diff --git a/net/ieee802154/nl-phy.c b/net/ieee802154/nl-phy.c
index 199a2d9d12f9..ed0eab39f531 100644
--- a/net/ieee802154/nl-phy.c
+++ b/net/ieee802154/nl-phy.c
@@ -23,6 +23,7 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <net/netlink.h>
 #include <net/genetlink.h>
 #include <net/wpan-phy.h>
diff --git a/net/ieee802154/raw.c b/net/ieee802154/raw.c
index 9c9b85c00033..10970ca85748 100644
--- a/net/ieee802154/raw.c
+++ b/net/ieee802154/raw.c
@@ -25,6 +25,7 @@
 #include <linux/module.h>
 #include <linux/if_arp.h>
 #include <linux/list.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 #include <net/af_ieee802154.h>
 
diff --git a/net/ieee802154/wpan-class.c b/net/ieee802154/wpan-class.c
index 268691256a6d..3d803a1b9fb6 100644
--- a/net/ieee802154/wpan-class.c
+++ b/net/ieee802154/wpan-class.c
@@ -16,6 +16,7 @@
  *
  */
 
+#include <linux/slab.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/device.h>
diff --git a/net/ipv4/Kconfig b/net/ipv4/Kconfig
index 0c94a1ac2946..8e3a1fd938ab 100644
--- a/net/ipv4/Kconfig
+++ b/net/ipv4/Kconfig
@@ -250,6 +250,20 @@ config IP_MROUTE
           <file:Documentation/networking/multicast.txt>. If you haven't heard
           about it, you don't need it.
 
+config IP_MROUTE_MULTIPLE_TABLES
+        bool "IP: multicast policy routing"
+        depends on IP_MROUTE && IP_ADVANCED_ROUTER
+        select FIB_RULES
+        help
+          Normally, a multicast router runs a userspace daemon and decides
+          what to do with a multicast packet based on the source and
+          destination addresses. If you say Y here, the multicast router
+          will also be able to take interfaces and packet marks into
+          account and run multiple instances of userspace daemons
+          simultaneously, each one handling a single table.
+
+          If unsure, say N.
+
 config IP_PIMSM_V1
         bool "IP: PIM-SM version 1 support"
         depends on IP_MROUTE
@@ -587,9 +601,15 @@ choice
         config DEFAULT_HTCP
                 bool "Htcp" if TCP_CONG_HTCP=y
 
+        config DEFAULT_HYBLA
+                bool "Hybla" if TCP_CONG_HYBLA=y
+
         config DEFAULT_VEGAS
                 bool "Vegas" if TCP_CONG_VEGAS=y
 
+        config DEFAULT_VENO
+                bool "Veno" if TCP_CONG_VENO=y
+
         config DEFAULT_WESTWOOD
                 bool "Westwood" if TCP_CONG_WESTWOOD=y
 
@@ -610,8 +630,10 @@ config DEFAULT_TCP_CONG
         default "bic" if DEFAULT_BIC
         default "cubic" if DEFAULT_CUBIC
         default "htcp" if DEFAULT_HTCP
+        default "hybla" if DEFAULT_HYBLA
         default "vegas" if DEFAULT_VEGAS
         default "westwood" if DEFAULT_WESTWOOD
+        default "veno" if DEFAULT_VENO
         default "reno" if DEFAULT_RENO
         default "cubic"
 
diff --git a/net/ipv4/af_inet.c b/net/ipv4/af_inet.c
index 33b7dffa7732..c6c43bcd1c6f 100644
--- a/net/ipv4/af_inet.c
+++ b/net/ipv4/af_inet.c
@@ -86,6 +86,7 @@
 #include <linux/poll.h>
 #include <linux/netfilter_ipv4.h>
 #include <linux/random.h>
+#include <linux/slab.h>
 
 #include <asm/uaccess.h>
 #include <asm/system.h>
@@ -153,7 +154,7 @@ void inet_sock_destruct(struct sock *sk)
         WARN_ON(sk->sk_forward_alloc);
 
         kfree(inet->opt);
-        dst_release(sk->sk_dst_cache);
+        dst_release(rcu_dereference_check(sk->sk_dst_cache, 1));
         sk_refcnt_debug_dec(sk);
 }
 EXPORT_SYMBOL(inet_sock_destruct);
@@ -418,6 +419,8 @@ int inet_release(struct socket *sock)
         if (sk) {
                 long timeout;
 
+                sock_rps_reset_flow(sk);
+
                 /* Applications forget to leave groups before exiting */
                 ip_mc_drop_socket(sk);
 
@@ -530,6 +533,8 @@ int inet_dgram_connect(struct socket *sock, struct sockaddr * uaddr,
 {
         struct sock *sk = sock->sk;
 
+        if (addr_len < sizeof(uaddr->sa_family))
+                return -EINVAL;
         if (uaddr->sa_family == AF_UNSPEC)
                 return sk->sk_prot->disconnect(sk, flags);
 
@@ -543,7 +548,7 @@ static long inet_wait_for_connect(struct sock *sk, long timeo)
 {
         DEFINE_WAIT(wait);
 
-        prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+        prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
 
         /* Basic assumption: if someone sets sk->sk_err, he _must_
          * change state of the socket from TCP_SYN_*.
@@ -556,9 +561,9 @@ static long inet_wait_for_connect(struct sock *sk, long timeo)
                 lock_sock(sk);
                 if (signal_pending(current) || !timeo)
                         break;
-                prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+                prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
         }
-        finish_wait(sk->sk_sleep, &wait);
+        finish_wait(sk_sleep(sk), &wait);
         return timeo;
 }
 
@@ -573,6 +578,9 @@ int inet_stream_connect(struct socket *sock, struct sockaddr *uaddr,
         int err;
         long timeo;
 
+        if (addr_len < sizeof(uaddr->sa_family))
+                return -EINVAL;
+
         lock_sock(sk);
 
         if (uaddr->sa_family == AF_UNSPEC) {
@@ -714,6 +722,8 @@ int inet_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
 {
         struct sock *sk = sock->sk;
 
+        sock_rps_record_flow(sk);
+
         /* We may need to bind the socket. */
         if (!inet_sk(sk)->inet_num && inet_autobind(sk))
                 return -EAGAIN;
@@ -722,12 +732,13 @@ int inet_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
 }
 EXPORT_SYMBOL(inet_sendmsg);
 
-
 static ssize_t inet_sendpage(struct socket *sock, struct page *page, int offset,
                              size_t size, int flags)
 {
         struct sock *sk = sock->sk;
 
+        sock_rps_record_flow(sk);
+
         /* We may need to bind the socket. */
         if (!inet_sk(sk)->inet_num && inet_autobind(sk))
                 return -EAGAIN;
@@ -737,6 +748,22 @@ static ssize_t inet_sendpage(struct socket *sock, struct page *page, int offset,
         return sock_no_sendpage(sock, page, offset, size, flags);
 }
 
+int inet_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
+                 size_t size, int flags)
+{
+        struct sock *sk = sock->sk;
+        int addr_len = 0;
+        int err;
+
+        sock_rps_record_flow(sk);
+
+        err = sk->sk_prot->recvmsg(iocb, sk, msg, size, flags & MSG_DONTWAIT,
+                                   flags & ~MSG_DONTWAIT, &addr_len);
+        if (err >= 0)
+                msg->msg_namelen = addr_len;
+        return err;
+}
+EXPORT_SYMBOL(inet_recvmsg);
 
 int inet_shutdown(struct socket *sock, int how)
 {
@@ -866,7 +893,7 @@ const struct proto_ops inet_stream_ops = {
         .setsockopt        = sock_common_setsockopt,
         .getsockopt        = sock_common_getsockopt,
         .sendmsg           = tcp_sendmsg,
-        .recvmsg           = sock_common_recvmsg,
+        .recvmsg           = inet_recvmsg,
         .mmap              = sock_no_mmap,
         .sendpage          = tcp_sendpage,
         .splice_read       = tcp_splice_read,
@@ -893,7 +920,7 @@ const struct proto_ops inet_dgram_ops = {
         .setsockopt        = sock_common_setsockopt,
         .getsockopt        = sock_common_getsockopt,
         .sendmsg           = inet_sendmsg,
-        .recvmsg           = sock_common_recvmsg,
+        .recvmsg           = inet_recvmsg,
         .mmap              = sock_no_mmap,
         .sendpage          = inet_sendpage,
 #ifdef CONFIG_COMPAT
@@ -923,7 +950,7 @@ static const struct proto_ops inet_sockraw_ops = {
         .setsockopt        = sock_common_setsockopt,
         .getsockopt        = sock_common_getsockopt,
         .sendmsg           = inet_sendmsg,
-        .recvmsg           = sock_common_recvmsg,
+        .recvmsg           = inet_recvmsg,
         .mmap              = sock_no_mmap,
         .sendpage          = inet_sendpage,
 #ifdef CONFIG_COMPAT
@@ -1296,8 +1323,8 @@ static struct sk_buff **inet_gro_receive(struct sk_buff **head,
         if (unlikely(ip_fast_csum((u8 *)iph, iph->ihl)))
                 goto out_unlock;
 
-        id = ntohl(*(u32 *)&iph->id);
-        flush = (u16)((ntohl(*(u32 *)iph) ^ skb_gro_len(skb)) | (id ^ IP_DF));
+        id = ntohl(*(__be32 *)&iph->id);
+        flush = (u16)((ntohl(*(__be32 *)iph) ^ skb_gro_len(skb)) | (id ^ IP_DF));
         id >>= 16;
 
         for (p = *head; p; p = p->next) {
@@ -1310,8 +1337,8 @@ static struct sk_buff **inet_gro_receive(struct sk_buff **head,
 
                 if ((iph->protocol ^ iph2->protocol) |
                     (iph->tos ^ iph2->tos) |
-                    (iph->saddr ^ iph2->saddr) |
-                    (iph->daddr ^ iph2->daddr)) {
+                    ((__force u32)iph->saddr ^ (__force u32)iph2->saddr) |
+                    ((__force u32)iph->daddr ^ (__force u32)iph2->daddr)) {
                         NAPI_GRO_CB(p)->same_flow = 0;
                         continue;
                 }
@@ -1401,10 +1428,10 @@ EXPORT_SYMBOL_GPL(snmp_fold_field);
 int snmp_mib_init(void __percpu *ptr[2], size_t mibsize)
 {
         BUG_ON(ptr == NULL);
-        ptr[0] = __alloc_percpu(mibsize, __alignof__(unsigned long long));
+        ptr[0] = __alloc_percpu(mibsize, __alignof__(unsigned long));
         if (!ptr[0])
                 goto err0;
-        ptr[1] = __alloc_percpu(mibsize, __alignof__(unsigned long long));
+        ptr[1] = __alloc_percpu(mibsize, __alignof__(unsigned long));
         if (!ptr[1])
                 goto err1;
         return 0;
diff --git a/net/ipv4/ah4.c b/net/ipv4/ah4.c
index 987b47dc69ad..880a5ec6dce0 100644
--- a/net/ipv4/ah4.c
+++ b/net/ipv4/ah4.c
@@ -1,6 +1,7 @@
 #include <crypto/hash.h>
 #include <linux/err.h>
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <net/ip.h>
 #include <net/xfrm.h>
 #include <net/ah.h>
diff --git a/net/ipv4/arp.c b/net/ipv4/arp.c
index c4dd13542802..6e747065c202 100644
--- a/net/ipv4/arp.c
+++ b/net/ipv4/arp.c
@@ -98,6 +98,7 @@
 #include <linux/net.h>
 #include <linux/rcupdate.h>
 #include <linux/jhash.h>
+#include <linux/slab.h>
 #ifdef CONFIG_SYSCTL
 #include <linux/sysctl.h>
 #endif
diff --git a/net/ipv4/cipso_ipv4.c b/net/ipv4/cipso_ipv4.c
index 1e029dc75455..c97cd9ff697e 100644
--- a/net/ipv4/cipso_ipv4.c
+++ b/net/ipv4/cipso_ipv4.c
@@ -44,6 +44,7 @@
 #include <linux/string.h>
 #include <linux/jhash.h>
 #include <linux/audit.h>
+#include <linux/slab.h>
 #include <net/ip.h>
 #include <net/icmp.h>
 #include <net/tcp.h>
diff --git a/net/ipv4/devinet.c b/net/ipv4/devinet.c
index 51ca946e3392..382bc768ed56 100644
--- a/net/ipv4/devinet.c
+++ b/net/ipv4/devinet.c
@@ -50,6 +50,7 @@
 #include <linux/notifier.h>
 #include <linux/inetdevice.h>
 #include <linux/igmp.h>
+#include <linux/slab.h>
 #ifdef CONFIG_SYSCTL
 #include <linux/sysctl.h>
 #endif
@@ -1095,10 +1096,10 @@ static int inetdev_event(struct notifier_block *this, unsigned long event,
         case NETDEV_DOWN:
                 ip_mc_down(in_dev);
                 break;
-        case NETDEV_BONDING_OLDTYPE:
+        case NETDEV_PRE_TYPE_CHANGE:
                 ip_mc_unmap(in_dev);
                 break;
-        case NETDEV_BONDING_NEWTYPE:
+        case NETDEV_POST_TYPE_CHANGE:
                 ip_mc_remap(in_dev);
                 break;
         case NETDEV_CHANGEMTU:
@@ -1194,7 +1195,7 @@ static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
                 hlist_for_each_entry_rcu(dev, node, head, index_hlist) {
                         if (idx < s_idx)
                                 goto cont;
-                        if (idx > s_idx)
+                        if (h > s_h || idx > s_idx)
                                 s_ip_idx = 0;
                         in_dev = __in_dev_get_rcu(dev);
                         if (!in_dev)
diff --git a/net/ipv4/fib_frontend.c b/net/ipv4/fib_frontend.c
index 9b3e28ed5240..4f0ed458c883 100644
--- a/net/ipv4/fib_frontend.c
+++ b/net/ipv4/fib_frontend.c
@@ -34,6 +34,7 @@
 #include <linux/skbuff.h>
 #include <linux/init.h>
 #include <linux/list.h>
+#include <linux/slab.h>
 
 #include <net/ip.h>
 #include <net/protocol.h>
diff --git a/net/ipv4/fib_hash.c b/net/ipv4/fib_hash.c
index 14972017b9c2..4ed7e0dea1bc 100644
--- a/net/ipv4/fib_hash.c
+++ b/net/ipv4/fib_hash.c
@@ -32,6 +32,7 @@
 #include <linux/skbuff.h>
 #include <linux/netlink.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 
 #include <net/net_namespace.h>
 #include <net/ip.h>
diff --git a/net/ipv4/fib_rules.c b/net/ipv4/fib_rules.c
index ca2d07b1c706..76daeb5ff564 100644
--- a/net/ipv4/fib_rules.c
+++ b/net/ipv4/fib_rules.c
@@ -213,7 +213,6 @@ static int fib4_rule_fill(struct fib_rule *rule, struct sk_buff *skb,
 {
         struct fib4_rule *rule4 = (struct fib4_rule *) rule;
 
-        frh->family = AF_INET;
         frh->dst_len = rule4->dst_len;
         frh->src_len = rule4->src_len;
         frh->tos = rule4->tos;
@@ -234,23 +233,6 @@ nla_put_failure:
         return -ENOBUFS;
 }
 
-static u32 fib4_rule_default_pref(struct fib_rules_ops *ops)
-{
-        struct list_head *pos;
-        struct fib_rule *rule;
-
-        if (!list_empty(&ops->rules_list)) {
-                pos = ops->rules_list.next;
-                if (pos->next != &ops->rules_list) {
-                        rule = list_entry(pos->next, struct fib_rule, list);
-                        if (rule->pref)
-                                return rule->pref - 1;
-                }
-        }
-
-        return 0;
-}
-
 static size_t fib4_rule_nlmsg_payload(struct fib_rule *rule)
 {
         return nla_total_size(4) /* dst */
@@ -263,7 +245,7 @@ static void fib4_rule_flush_cache(struct fib_rules_ops *ops)
         rt_cache_flush(ops->fro_net, -1);
 }
 
-static struct fib_rules_ops fib4_rules_ops_template = {
+static const struct fib_rules_ops __net_initdata fib4_rules_ops_template = {
         .family         = AF_INET,
         .rule_size      = sizeof(struct fib4_rule),
         .addr_size      = sizeof(u32),
@@ -272,7 +254,7 @@ static struct fib_rules_ops fib4_rules_ops_template = {
         .configure      = fib4_rule_configure,
         .compare        = fib4_rule_compare,
         .fill           = fib4_rule_fill,
-        .default_pref   = fib4_rule_default_pref,
+        .default_pref   = fib_default_rule_pref,
         .nlmsg_payload  = fib4_rule_nlmsg_payload,
         .flush_cache    = fib4_rule_flush_cache,
         .nlgroup        = RTNLGRP_IPV4_RULE,
diff --git a/net/ipv4/fib_semantics.c b/net/ipv4/fib_semantics.c
index 1af0ea0fb6a2..20f09c5b31e8 100644
--- a/net/ipv4/fib_semantics.c
+++ b/net/ipv4/fib_semantics.c
@@ -32,6 +32,7 @@
 #include <linux/proc_fs.h>
 #include <linux/skbuff.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 
 #include <net/arp.h>
 #include <net/ip.h>
diff --git a/net/ipv4/fib_trie.c b/net/ipv4/fib_trie.c
index af5d89792860..c98f115fb0fd 100644
--- a/net/ipv4/fib_trie.c
+++ b/net/ipv4/fib_trie.c
@@ -71,6 +71,7 @@
 #include <linux/netlink.h>
 #include <linux/init.h>
 #include <linux/list.h>
+#include <linux/slab.h>
 #include <net/net_namespace.h>
 #include <net/ip.h>
 #include <net/protocol.h>
@@ -208,7 +209,9 @@ static inline struct node *tnode_get_child_rcu(struct tnode *tn, unsigned int i)
 {
         struct node *ret = tnode_get_child(tn, i);
 
-        return rcu_dereference(ret);
+        return rcu_dereference_check(ret,
+                                     rcu_read_lock_held() ||
+                                     lockdep_rtnl_is_held());
 }
 
 static inline int tnode_child_length(const struct tnode *tn)
@@ -961,7 +964,9 @@ fib_find_node(struct trie *t, u32 key)
         struct node *n;
 
         pos = 0;
-        n = rcu_dereference(t->trie);
+        n = rcu_dereference_check(t->trie,
+                                  rcu_read_lock_held() ||
+                                  lockdep_rtnl_is_held());
 
         while (n != NULL &&  NODE_TYPE(n) == T_TNODE) {
                 tn = (struct tnode *) n;
diff --git a/net/ipv4/icmp.c b/net/ipv4/icmp.c
index 4b4c2bcd15db..f3d339f728b0 100644
--- a/net/ipv4/icmp.c
+++ b/net/ipv4/icmp.c
@@ -74,6 +74,7 @@
 #include <linux/netdevice.h>
 #include <linux/string.h>
 #include <linux/netfilter_ipv4.h>
+#include <linux/slab.h>
 #include <net/snmp.h>
 #include <net/ip.h>
 #include <net/route.h>
@@ -330,9 +331,10 @@ static void icmp_push_reply(struct icmp_bxm *icmp_param,
         if (ip_append_data(sk, icmp_glue_bits, icmp_param,
                            icmp_param->data_len+icmp_param->head_len,
                            icmp_param->head_len,
-                           ipc, rt, MSG_DONTWAIT) < 0)
+                           ipc, rt, MSG_DONTWAIT) < 0) {
+                ICMP_INC_STATS_BH(sock_net(sk), ICMP_MIB_OUTERRORS);
                 ip_flush_pending_frames(sk);
-        else if ((skb = skb_peek(&sk->sk_write_queue)) != NULL) {
+        } else if ((skb = skb_peek(&sk->sk_write_queue)) != NULL) {
                 struct icmphdr *icmph = icmp_hdr(skb);
                 __wsum csum = 0;
                 struct sk_buff *skb1;
diff --git a/net/ipv4/igmp.c b/net/ipv4/igmp.c
index 63bf298ca109..5fff865a4fa7 100644
--- a/net/ipv4/igmp.c
+++ b/net/ipv4/igmp.c
@@ -71,6 +71,7 @@
  */
 
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <asm/uaccess.h>
 #include <asm/system.h>
 #include <linux/types.h>
@@ -997,7 +998,7 @@ static void ip_mc_filter_add(struct in_device *in_dev, __be32 addr)
            --ANK
            */
         if (arp_mc_map(addr, buf, dev, 0) == 0)
-                dev_mc_add(dev, buf, dev->addr_len, 0);
+                dev_mc_add(dev, buf);
 }
 
 /*
@@ -1010,7 +1011,7 @@ static void ip_mc_filter_del(struct in_device *in_dev, __be32 addr)
         struct net_device *dev = in_dev->dev;
 
         if (arp_mc_map(addr, buf, dev, 0) == 0)
-                dev_mc_delete(dev, buf, dev->addr_len, 0);
+                dev_mc_del(dev, buf);
 }
 
 #ifdef CONFIG_IP_MULTICAST
diff --git a/net/ipv4/inet_connection_sock.c b/net/ipv4/inet_connection_sock.c
index 8da6429269dd..e0a3e3537b14 100644
--- a/net/ipv4/inet_connection_sock.c
+++ b/net/ipv4/inet_connection_sock.c
@@ -234,7 +234,7 @@ static int inet_csk_wait_for_connect(struct sock *sk, long timeo)
          * having to remove and re-insert us on the wait queue.
          */
         for (;;) {
-                prepare_to_wait_exclusive(sk->sk_sleep, &wait,
+                prepare_to_wait_exclusive(sk_sleep(sk), &wait,
                                           TASK_INTERRUPTIBLE);
                 release_sock(sk);
                 if (reqsk_queue_empty(&icsk->icsk_accept_queue))
@@ -253,7 +253,7 @@ static int inet_csk_wait_for_connect(struct sock *sk, long timeo)
                 if (!timeo)
                         break;
         }
-        finish_wait(sk->sk_sleep, &wait);
+        finish_wait(sk_sleep(sk), &wait);
         return err;
 }
 
diff --git a/net/ipv4/inet_diag.c b/net/ipv4/inet_diag.c
index 1aaa8110d84b..e5fa2ddce320 100644
--- a/net/ipv4/inet_diag.c
+++ b/net/ipv4/inet_diag.c
@@ -14,6 +14,7 @@
 #include <linux/types.h>
 #include <linux/fcntl.h>
 #include <linux/random.h>
+#include <linux/slab.h>
 #include <linux/cache.h>
 #include <linux/init.h>
 #include <linux/time.h>
diff --git a/net/ipv4/inet_fragment.c b/net/ipv4/inet_fragment.c
index eaf3e2c8646a..a2ca6aed763b 100644
--- a/net/ipv4/inet_fragment.c
+++ b/net/ipv4/inet_fragment.c
@@ -19,6 +19,7 @@
 #include <linux/random.h>
 #include <linux/skbuff.h>
 #include <linux/rtnetlink.h>
+#include <linux/slab.h>
 
 #include <net/inet_frag.h>
 
diff --git a/net/ipv4/inet_timewait_sock.c b/net/ipv4/inet_timewait_sock.c
index cc94cc2d8b2d..c5af909cf701 100644
--- a/net/ipv4/inet_timewait_sock.c
+++ b/net/ipv4/inet_timewait_sock.c
@@ -10,6 +10,7 @@
 
 #include <linux/kernel.h>
 #include <linux/kmemcheck.h>
+#include <linux/slab.h>
 #include <net/inet_hashtables.h>
 #include <net/inet_timewait_sock.h>
 #include <net/ip.h>
diff --git a/net/ipv4/ip_forward.c b/net/ipv4/ip_forward.c
index a2991bc8e32e..af10942b326c 100644
--- a/net/ipv4/ip_forward.c
+++ b/net/ipv4/ip_forward.c
@@ -25,6 +25,7 @@
 #include <linux/ip.h>
 #include <linux/icmp.h>
 #include <linux/netdevice.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 #include <net/ip.h>
 #include <net/tcp.h>
diff --git a/net/ipv4/ip_fragment.c b/net/ipv4/ip_fragment.c
index b59430bc041c..75347ea70ea0 100644
--- a/net/ipv4/ip_fragment.c
+++ b/net/ipv4/ip_fragment.c
@@ -32,6 +32,7 @@
 #include <linux/netdevice.h>
 #include <linux/jhash.h>
 #include <linux/random.h>
+#include <linux/slab.h>
 #include <net/route.h>
 #include <net/dst.h>
 #include <net/sock.h>
diff --git a/net/ipv4/ip_gre.c b/net/ipv4/ip_gre.c
index f47c9f76754b..fe381d12ecdd 100644
--- a/net/ipv4/ip_gre.c
+++ b/net/ipv4/ip_gre.c
@@ -14,6 +14,7 @@
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <asm/uaccess.h>
 #include <linux/skbuff.h>
 #include <linux/netdevice.h>
@@ -810,11 +811,13 @@ static netdev_tx_t ipgre_tunnel_xmit(struct sk_buff *skb, struct net_device *dev
                         tunnel->err_count = 0;
         }
 
-        max_headroom = LL_RESERVED_SPACE(tdev) + gre_hlen;
+        max_headroom = LL_RESERVED_SPACE(tdev) + gre_hlen + rt->u.dst.header_len;
 
         if (skb_headroom(skb) < max_headroom || skb_shared(skb)||
             (skb_cloned(skb) && !skb_clone_writable(skb, 0))) {
                 struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
+                if (max_headroom > dev->needed_headroom)
+                        dev->needed_headroom = max_headroom;
                 if (!new_skb) {
                         ip_rt_put(rt);
                         txq->tx_dropped++;
diff --git a/net/ipv4/ip_input.c b/net/ipv4/ip_input.c
index c29de9879fda..f8ab7a380d4a 100644
--- a/net/ipv4/ip_input.c
+++ b/net/ipv4/ip_input.c
@@ -119,6 +119,7 @@
 #include <linux/kernel.h>
 #include <linux/string.h>
 #include <linux/errno.h>
+#include <linux/slab.h>
 
 #include <linux/net.h>
 #include <linux/socket.h>
diff --git a/net/ipv4/ip_options.c b/net/ipv4/ip_options.c
index 94bf105ef3c9..4c09a31fd140 100644
--- a/net/ipv4/ip_options.c
+++ b/net/ipv4/ip_options.c
@@ -11,6 +11,7 @@
 
 #include <linux/capability.h>
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/types.h>
 #include <asm/uaccess.h>
 #include <linux/skbuff.h>
diff --git a/net/ipv4/ip_output.c b/net/ipv4/ip_output.c
index 3451799e3dbf..f0392191740b 100644
--- a/net/ipv4/ip_output.c
+++ b/net/ipv4/ip_output.c
@@ -51,6 +51,7 @@
 #include <linux/string.h>
 #include <linux/errno.h>
 #include <linux/highmem.h>
+#include <linux/slab.h>
 
 #include <linux/socket.h>
 #include <linux/sockios.h>
@@ -119,7 +120,7 @@ static int ip_dev_loopback_xmit(struct sk_buff *newskb)
         newskb->pkt_type = PACKET_LOOPBACK;
         newskb->ip_summed = CHECKSUM_UNNECESSARY;
         WARN_ON(!skb_dst(newskb));
-        netif_rx(newskb);
+        netif_rx_ni(newskb);
         return 0;
 }
 
@@ -310,7 +311,7 @@ int ip_output(struct sk_buff *skb)
                             !(IPCB(skb)->flags & IPSKB_REROUTED));
 }
 
-int ip_queue_xmit(struct sk_buff *skb, int ipfragok)
+int ip_queue_xmit(struct sk_buff *skb)
 {
         struct sock *sk = skb->sk;
         struct inet_sock *inet = inet_sk(sk);
@@ -369,7 +370,7 @@ packet_routed:
         skb_reset_network_header(skb);
         iph = ip_hdr(skb);
         *((__be16 *)iph) = htons((4 << 12) | (5 << 8) | (inet->tos & 0xff));
-        if (ip_dont_fragment(sk, &rt->u.dst) && !ipfragok)
+        if (ip_dont_fragment(sk, &rt->u.dst) && !skb->local_df)
                 iph->frag_off = htons(IP_DF);
         else
                 iph->frag_off = 0;
diff --git a/net/ipv4/ip_sockglue.c b/net/ipv4/ip_sockglue.c
index 644dc43a55de..ce231780a2b1 100644
--- a/net/ipv4/ip_sockglue.c
+++ b/net/ipv4/ip_sockglue.c
@@ -23,6 +23,7 @@
 #include <linux/icmp.h>
 #include <linux/inetdevice.h>
 #include <linux/netdevice.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 #include <net/ip.h>
 #include <net/icmp.h>
@@ -286,12 +287,8 @@ int ip_ra_control(struct sock *sk, unsigned char on,
 void ip_icmp_error(struct sock *sk, struct sk_buff *skb, int err,
                    __be16 port, u32 info, u8 *payload)
 {
-        struct inet_sock *inet = inet_sk(sk);
         struct sock_exterr_skb *serr;
 
-        if (!inet->recverr)
-                return;
-
         skb = skb_clone(skb, GFP_ATOMIC);
         if (!skb)
                 return;
@@ -957,6 +954,22 @@ e_inval:
         return -EINVAL;
 }
 
+/**
+ * ip_queue_rcv_skb - Queue an skb into sock receive queue
+ * @sk: socket
+ * @skb: buffer
+ *
+ * Queues an skb into socket receive queue. If IP_CMSG_PKTINFO option
+ * is not set, we drop skb dst entry now, while dst cache line is hot.
+ */
+int ip_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
+{
+        if (!(inet_sk(sk)->cmsg_flags & IP_CMSG_PKTINFO))
+                skb_dst_drop(skb);
+        return sock_queue_rcv_skb(sk, skb);
+}
+EXPORT_SYMBOL(ip_queue_rcv_skb);
+
 int ip_setsockopt(struct sock *sk, int level,
                 int optname, char __user *optval, unsigned int optlen)
 {
diff --git a/net/ipv4/ipconfig.c b/net/ipv4/ipconfig.c
index 10a6a604bf32..b9d84e800cf4 100644
--- a/net/ipv4/ipconfig.c
+++ b/net/ipv4/ipconfig.c
@@ -53,6 +53,7 @@
 #include <linux/root_dev.h>
 #include <linux/delay.h>
 #include <linux/nfs_fs.h>
+#include <linux/slab.h>
 #include <net/net_namespace.h>
 #include <net/arp.h>
 #include <net/ip.h>
@@ -187,6 +188,16 @@ struct ic_device {
 static struct ic_device *ic_first_dev __initdata = NULL;/* List of open device */
 static struct net_device *ic_dev __initdata = NULL;     /* Selected device */
 
+static bool __init ic_device_match(struct net_device *dev)
+{
+        if (user_dev_name[0] ? !strcmp(dev->name, user_dev_name) :
+            (!(dev->flags & IFF_LOOPBACK) &&
+             (dev->flags & (IFF_POINTOPOINT|IFF_BROADCAST)) &&
+             strncmp(dev->name, "dummy", 5)))
+                return true;
+        return false;
+}
+
 static int __init ic_open_devs(void)
 {
         struct ic_device *d, **last;
@@ -207,10 +218,7 @@ static int __init ic_open_devs(void)
         for_each_netdev(&init_net, dev) {
                 if (dev->flags & IFF_LOOPBACK)
                         continue;
-                if (user_dev_name[0] ? !strcmp(dev->name, user_dev_name) :
-                    (!(dev->flags & IFF_LOOPBACK) &&
-                     (dev->flags & (IFF_POINTOPOINT|IFF_BROADCAST)) &&
-                     strncmp(dev->name, "dummy", 5))) {
+                if (ic_device_match(dev)) {
                         int able = 0;
                         if (dev->mtu >= 364)
                                 able |= IC_BOOTP;
@@ -228,7 +236,7 @@ static int __init ic_open_devs(void)
                         }
                         if (!(d = kmalloc(sizeof(struct ic_device), GFP_KERNEL))) {
                                 rtnl_unlock();
-                                return -1;
+                                return -ENOMEM;
                         }
                         d->dev = dev;
                         *last = d;
@@ -253,7 +261,7 @@ static int __init ic_open_devs(void)
                         printk(KERN_ERR "IP-Config: Device `%s' not found.\n", user_dev_name);
                 else
                         printk(KERN_ERR "IP-Config: No network devices available.\n");
-                return -1;
+                return -ENODEV;
         }
         return 0;
 }
@@ -968,7 +976,7 @@ static int __init ic_bootp_recv(struct sk_buff *skb, struct net_device *dev, str
         /* Is it a reply for the device we are configuring? */
         if (b->xid != ic_dev_xid) {
                 if (net_ratelimit())
-                        printk(KERN_ERR "DHCP/BOOTP: Ignoring delayed packet \n");
+                        printk(KERN_ERR "DHCP/BOOTP: Ignoring delayed packet\n");
                 goto drop_unlock;
         }
 
@@ -1303,6 +1311,32 @@ __be32 __init root_nfs_parse_addr(char *name)
         return addr;
 }
 
+#define DEVICE_WAIT_MAX         12 /* 12 seconds */
+
+static int __init wait_for_devices(void)
+{
+        int i;
+
+        msleep(CONF_PRE_OPEN);
+        for (i = 0; i < DEVICE_WAIT_MAX; i++) {
+                struct net_device *dev;
+                int found = 0;
+
+                rtnl_lock();
+                for_each_netdev(&init_net, dev) {
+                        if (ic_device_match(dev)) {
+                                found = 1;
+                                break;
+                        }
+                }
+                rtnl_unlock();
+                if (found)
+                        return 0;
+                ssleep(1);
+        }
+        return -ENODEV;
+}
+
 /*
  *      IP Autoconfig dispatcher.
  */
@@ -1313,6 +1347,7 @@ static int __init ip_auto_config(void)
 #ifdef IPCONFIG_DYNAMIC
         int retries = CONF_OPEN_RETRIES;
 #endif
+        int err;
 
 #ifdef CONFIG_PROC_FS
         proc_net_fops_create(&init_net, "pnp", S_IRUGO, &pnp_seq_fops);
@@ -1325,12 +1360,15 @@ static int __init ip_auto_config(void)
 #ifdef IPCONFIG_DYNAMIC
  try_try_again:
 #endif
-        /* Give hardware a chance to settle */
-        msleep(CONF_PRE_OPEN);
+        /* Wait for devices to appear */
+        err = wait_for_devices();
+        if (err)
+                return err;
 
         /* Setup all network devices */
-        if (ic_open_devs() < 0)
-                return -1;
+        err = ic_open_devs();
+        if (err)
+                return err;
 
         /* Give drivers a chance to settle */
         ssleep(CONF_POST_OPEN);
diff --git a/net/ipv4/ipip.c b/net/ipv4/ipip.c
index 2f302d3ac9a3..0b27b14dcc9d 100644
--- a/net/ipv4/ipip.c
+++ b/net/ipv4/ipip.c
@@ -95,6 +95,7 @@
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <asm/uaccess.h>
 #include <linux/skbuff.h>
 #include <linux/netdevice.h>
diff --git a/net/ipv4/ipmr.c b/net/ipv4/ipmr.c
index 8582e12e4a62..eddfd12f55b8 100644
--- a/net/ipv4/ipmr.c
+++ b/net/ipv4/ipmr.c
@@ -47,6 +47,7 @@
 #include <linux/mroute.h>
 #include <linux/init.h>
 #include <linux/if_ether.h>
+#include <linux/slab.h>
 #include <net/net_namespace.h>
 #include <net/ip.h>
 #include <net/protocol.h>
@@ -62,11 +63,40 @@
 #include <net/ipip.h>
 #include <net/checksum.h>
 #include <net/netlink.h>
+#include <net/fib_rules.h>
 
 #if defined(CONFIG_IP_PIMSM_V1) || defined(CONFIG_IP_PIMSM_V2)
 #define CONFIG_IP_PIMSM 1
 #endif
 
+struct mr_table {
+        struct list_head        list;
+#ifdef CONFIG_NET_NS
+        struct net              *net;
+#endif
+        u32                     id;
+        struct sock             *mroute_sk;
+        struct timer_list       ipmr_expire_timer;
+        struct list_head        mfc_unres_queue;
+        struct list_head        mfc_cache_array[MFC_LINES];
+        struct vif_device       vif_table[MAXVIFS];
+        int                     maxvif;
+        atomic_t                cache_resolve_queue_len;
+        int                     mroute_do_assert;
+        int                     mroute_do_pim;
+#if defined(CONFIG_IP_PIMSM_V1) || defined(CONFIG_IP_PIMSM_V2)
+        int                     mroute_reg_vif_num;
+#endif
+};
+
+struct ipmr_rule {
+        struct fib_rule         common;
+};
+
+struct ipmr_result {
+        struct mr_table         *mrt;
+};
+
 /* Big lock, protecting vif table, mrt cache and mroute socket state.
    Note that the changes are semaphored via rtnl_lock.
  */
@@ -77,9 +107,7 @@ static DEFINE_RWLOCK(mrt_lock);
  *      Multicast router control variables
  */
 
-#define VIF_EXISTS(_net, _idx) ((_net)->ipv4.vif_table[_idx].dev != NULL)
-
-static struct mfc_cache *mfc_unres_queue;               /* Queue of unresolved entries */
+#define VIF_EXISTS(_mrt, _idx) ((_mrt)->vif_table[_idx].dev != NULL)
 
 /* Special spinlock for queue of unresolved entries */
 static DEFINE_SPINLOCK(mfc_unres_lock);
@@ -94,12 +122,215 @@ static DEFINE_SPINLOCK(mfc_unres_lock);
 
 static struct kmem_cache *mrt_cachep __read_mostly;
 
-static int ip_mr_forward(struct sk_buff *skb, struct mfc_cache *cache, int local);
-static int ipmr_cache_report(struct net *net,
+static struct mr_table *ipmr_new_table(struct net *net, u32 id);
+static int ip_mr_forward(struct net *net, struct mr_table *mrt,
+                         struct sk_buff *skb, struct mfc_cache *cache,
+                         int local);
+static int ipmr_cache_report(struct mr_table *mrt,
                              struct sk_buff *pkt, vifi_t vifi, int assert);
-static int ipmr_fill_mroute(struct sk_buff *skb, struct mfc_cache *c, struct rtmsg *rtm);
+static int __ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
+                              struct mfc_cache *c, struct rtmsg *rtm);
+static void ipmr_expire_process(unsigned long arg);
+
+#ifdef CONFIG_IP_MROUTE_MULTIPLE_TABLES
+#define ipmr_for_each_table(mrt, net) \
+        list_for_each_entry_rcu(mrt, &net->ipv4.mr_tables, list)
+
+static struct mr_table *ipmr_get_table(struct net *net, u32 id)
+{
+        struct mr_table *mrt;
+
+        ipmr_for_each_table(mrt, net) {
+                if (mrt->id == id)
+                        return mrt;
+        }
+        return NULL;
+}
+
+static int ipmr_fib_lookup(struct net *net, struct flowi *flp,
+                           struct mr_table **mrt)
+{
+        struct ipmr_result res;
+        struct fib_lookup_arg arg = { .result = &res, };
+        int err;
+
+        err = fib_rules_lookup(net->ipv4.mr_rules_ops, flp, 0, &arg);
+        if (err < 0)
+                return err;
+        *mrt = res.mrt;
+        return 0;
+}
+
+static int ipmr_rule_action(struct fib_rule *rule, struct flowi *flp,
+                            int flags, struct fib_lookup_arg *arg)
+{
+        struct ipmr_result *res = arg->result;
+        struct mr_table *mrt;
+
+        switch (rule->action) {
+        case FR_ACT_TO_TBL:
+                break;
+        case FR_ACT_UNREACHABLE:
+                return -ENETUNREACH;
+        case FR_ACT_PROHIBIT:
+                return -EACCES;
+        case FR_ACT_BLACKHOLE:
+        default:
+                return -EINVAL;
+        }
+
+        mrt = ipmr_get_table(rule->fr_net, rule->table);
+        if (mrt == NULL)
+                return -EAGAIN;
+        res->mrt = mrt;
+        return 0;
+}
+
+static int ipmr_rule_match(struct fib_rule *rule, struct flowi *fl, int flags)
+{
+        return 1;
+}
+
+static const struct nla_policy ipmr_rule_policy[FRA_MAX + 1] = {
+        FRA_GENERIC_POLICY,
+};
+
+static int ipmr_rule_configure(struct fib_rule *rule, struct sk_buff *skb,
+                               struct fib_rule_hdr *frh, struct nlattr **tb)
+{
+        return 0;
+}
+
+static int ipmr_rule_compare(struct fib_rule *rule, struct fib_rule_hdr *frh,
+                             struct nlattr **tb)
+{
+        return 1;
+}
+
+static int ipmr_rule_fill(struct fib_rule *rule, struct sk_buff *skb,
+                          struct fib_rule_hdr *frh)
+{
+        frh->dst_len = 0;
+        frh->src_len = 0;
+        frh->tos     = 0;
+        return 0;
+}
+
+static const struct fib_rules_ops __net_initdata ipmr_rules_ops_template = {
+        .family         = RTNL_FAMILY_IPMR,
+        .rule_size      = sizeof(struct ipmr_rule),
+        .addr_size      = sizeof(u32),
+        .action         = ipmr_rule_action,
+        .match          = ipmr_rule_match,
+        .configure      = ipmr_rule_configure,
+        .compare        = ipmr_rule_compare,
+        .default_pref   = fib_default_rule_pref,
+        .fill           = ipmr_rule_fill,
+        .nlgroup        = RTNLGRP_IPV4_RULE,
+        .policy         = ipmr_rule_policy,
+        .owner          = THIS_MODULE,
+};
+
+static int __net_init ipmr_rules_init(struct net *net)
+{
+        struct fib_rules_ops *ops;
+        struct mr_table *mrt;
+        int err;
+
+        ops = fib_rules_register(&ipmr_rules_ops_template, net);
+        if (IS_ERR(ops))
+                return PTR_ERR(ops);
+
+        INIT_LIST_HEAD(&net->ipv4.mr_tables);
+
+        mrt = ipmr_new_table(net, RT_TABLE_DEFAULT);
+        if (mrt == NULL) {
+                err = -ENOMEM;
+                goto err1;
+        }
 
-static struct timer_list ipmr_expire_timer;
+        err = fib_default_rule_add(ops, 0x7fff, RT_TABLE_DEFAULT, 0);
+        if (err < 0)
+                goto err2;
+
+        net->ipv4.mr_rules_ops = ops;
+        return 0;
+
+err2:
+        kfree(mrt);
+err1:
+        fib_rules_unregister(ops);
+        return err;
+}
+
+static void __net_exit ipmr_rules_exit(struct net *net)
+{
+        struct mr_table *mrt, *next;
+
+        list_for_each_entry_safe(mrt, next, &net->ipv4.mr_tables, list)
+                kfree(mrt);
+        fib_rules_unregister(net->ipv4.mr_rules_ops);
+}
+#else
+#define ipmr_for_each_table(mrt, net) \
+        for (mrt = net->ipv4.mrt; mrt; mrt = NULL)
+
+static struct mr_table *ipmr_get_table(struct net *net, u32 id)
+{
+        return net->ipv4.mrt;
+}
+
+static int ipmr_fib_lookup(struct net *net, struct flowi *flp,
+                           struct mr_table **mrt)
+{
+        *mrt = net->ipv4.mrt;
+        return 0;
+}
+
+static int __net_init ipmr_rules_init(struct net *net)
+{
+        net->ipv4.mrt = ipmr_new_table(net, RT_TABLE_DEFAULT);
+        return net->ipv4.mrt ? 0 : -ENOMEM;
+}
+
+static void __net_exit ipmr_rules_exit(struct net *net)
+{
+        kfree(net->ipv4.mrt);
+}
+#endif
+
+static struct mr_table *ipmr_new_table(struct net *net, u32 id)
+{
+        struct mr_table *mrt;
+        unsigned int i;
+
+        mrt = ipmr_get_table(net, id);
+        if (mrt != NULL)
+                return mrt;
+
+        mrt = kzalloc(sizeof(*mrt), GFP_KERNEL);
+        if (mrt == NULL)
+                return NULL;
+        write_pnet(&mrt->net, net);
+        mrt->id = id;
+
+        /* Forwarding cache */
+        for (i = 0; i < MFC_LINES; i++)
+                INIT_LIST_HEAD(&mrt->mfc_cache_array[i]);
+
+        INIT_LIST_HEAD(&mrt->mfc_unres_queue);
+
+        setup_timer(&mrt->ipmr_expire_timer, ipmr_expire_process,
+                    (unsigned long)mrt);
+
+#ifdef CONFIG_IP_PIMSM
+        mrt->mroute_reg_vif_num = -1;
+#endif
+#ifdef CONFIG_IP_MROUTE_MULTIPLE_TABLES
+        list_add_tail_rcu(&mrt->list, &net->ipv4.mr_tables);
+#endif
+        return mrt;
+}
 
 /* Service routines creating virtual interfaces: DVMRP tunnels and PIMREG */
 
@@ -200,12 +431,22 @@ failure:
 static netdev_tx_t reg_vif_xmit(struct sk_buff *skb, struct net_device *dev)
 {
         struct net *net = dev_net(dev);
+        struct mr_table *mrt;
+        struct flowi fl = {
+                .oif            = dev->ifindex,
+                .iif            = skb->skb_iif,
+                .mark           = skb->mark,
+        };
+        int err;
+
+        err = ipmr_fib_lookup(net, &fl, &mrt);
+        if (err < 0)
+                return err;
 
         read_lock(&mrt_lock);
         dev->stats.tx_bytes += skb->len;
         dev->stats.tx_packets++;
-        ipmr_cache_report(net, skb, net->ipv4.mroute_reg_vif_num,
-                          IGMPMSG_WHOLEPKT);
+        ipmr_cache_report(mrt, skb, mrt->mroute_reg_vif_num, IGMPMSG_WHOLEPKT);
         read_unlock(&mrt_lock);
         kfree_skb(skb);
         return NETDEV_TX_OK;
@@ -225,12 +466,18 @@ static void reg_vif_setup(struct net_device *dev)
         dev->features           |= NETIF_F_NETNS_LOCAL;
 }
 
-static struct net_device *ipmr_reg_vif(struct net *net)
+static struct net_device *ipmr_reg_vif(struct net *net, struct mr_table *mrt)
 {
         struct net_device *dev;
         struct in_device *in_dev;
+        char name[IFNAMSIZ];
 
-        dev = alloc_netdev(0, "pimreg", reg_vif_setup);
+        if (mrt->id == RT_TABLE_DEFAULT)
+                sprintf(name, "pimreg");
+        else
+                sprintf(name, "pimreg%u", mrt->id);
+
+        dev = alloc_netdev(0, name, reg_vif_setup);
 
         if (dev == NULL)
                 return NULL;
@@ -275,17 +522,17 @@ failure:
  *      @notify: Set to 1, if the caller is a notifier_call
  */
 
-static int vif_delete(struct net *net, int vifi, int notify,
+static int vif_delete(struct mr_table *mrt, int vifi, int notify,
                       struct list_head *head)
 {
         struct vif_device *v;
         struct net_device *dev;
         struct in_device *in_dev;
 
-        if (vifi < 0 || vifi >= net->ipv4.maxvif)
+        if (vifi < 0 || vifi >= mrt->maxvif)
                 return -EADDRNOTAVAIL;
 
-        v = &net->ipv4.vif_table[vifi];
+        v = &mrt->vif_table[vifi];
 
         write_lock_bh(&mrt_lock);
         dev = v->dev;
@@ -297,17 +544,17 @@ static int vif_delete(struct net *net, int vifi, int notify,
         }
 
 #ifdef CONFIG_IP_PIMSM
-        if (vifi == net->ipv4.mroute_reg_vif_num)
-                net->ipv4.mroute_reg_vif_num = -1;
+        if (vifi == mrt->mroute_reg_vif_num)
+                mrt->mroute_reg_vif_num = -1;
 #endif
 
-        if (vifi+1 == net->ipv4.maxvif) {
+        if (vifi+1 == mrt->maxvif) {
                 int tmp;
                 for (tmp=vifi-1; tmp>=0; tmp--) {
-                        if (VIF_EXISTS(net, tmp))
+                        if (VIF_EXISTS(mrt, tmp))
                                 break;
                 }
-                net->ipv4.maxvif = tmp+1;
+                mrt->maxvif = tmp+1;
         }
 
         write_unlock_bh(&mrt_lock);
@@ -328,7 +575,6 @@ static int vif_delete(struct net *net, int vifi, int notify,
 
 static inline void ipmr_cache_free(struct mfc_cache *c)
 {
-        release_net(mfc_net(c));
         kmem_cache_free(mrt_cachep, c);
 }
 
@@ -336,13 +582,13 @@ static inline void ipmr_cache_free(struct mfc_cache *c)
    and reporting error to netlink readers.
  */
 
-static void ipmr_destroy_unres(struct mfc_cache *c)
+static void ipmr_destroy_unres(struct mr_table *mrt, struct mfc_cache *c)
 {
+        struct net *net = read_pnet(&mrt->net);
         struct sk_buff *skb;
         struct nlmsgerr *e;
-        struct net *net = mfc_net(c);
 
-        atomic_dec(&net->ipv4.cache_resolve_queue_len);
+        atomic_dec(&mrt->cache_resolve_queue_len);
 
         while ((skb = skb_dequeue(&c->mfc_un.unres.unresolved))) {
                 if (ip_hdr(skb)->version == 0) {
@@ -363,42 +609,40 @@ static void ipmr_destroy_unres(struct mfc_cache *c)
 }
 
 
-/* Single timer process for all the unresolved queue. */
+/* Timer process for the unresolved queue. */
 
-static void ipmr_expire_process(unsigned long dummy)
+static void ipmr_expire_process(unsigned long arg)
 {
+        struct mr_table *mrt = (struct mr_table *)arg;
         unsigned long now;
         unsigned long expires;
-        struct mfc_cache *c, **cp;
+        struct mfc_cache *c, *next;
 
         if (!spin_trylock(&mfc_unres_lock)) {
-                mod_timer(&ipmr_expire_timer, jiffies+HZ/10);
+                mod_timer(&mrt->ipmr_expire_timer, jiffies+HZ/10);
                 return;
         }
 
-        if (mfc_unres_queue == NULL)
+        if (list_empty(&mrt->mfc_unres_queue))
                 goto out;
 
         now = jiffies;
         expires = 10*HZ;
-        cp = &mfc_unres_queue;
 
-        while ((c=*cp) != NULL) {
+        list_for_each_entry_safe(c, next, &mrt->mfc_unres_queue, list) {
                 if (time_after(c->mfc_un.unres.expires, now)) {
                         unsigned long interval = c->mfc_un.unres.expires - now;
                         if (interval < expires)
                                 expires = interval;
-                        cp = &c->next;
                         continue;
                 }
 
-                *cp = c->next;
-
-                ipmr_destroy_unres(c);
+                list_del(&c->list);
+                ipmr_destroy_unres(mrt, c);
         }
 
-        if (mfc_unres_queue != NULL)
-                mod_timer(&ipmr_expire_timer, jiffies + expires);
+        if (!list_empty(&mrt->mfc_unres_queue))
+                mod_timer(&mrt->ipmr_expire_timer, jiffies + expires);
 
 out:
         spin_unlock(&mfc_unres_lock);
@@ -406,17 +650,17 @@ out:
 
 /* Fill oifs list. It is called under write locked mrt_lock. */
 
-static void ipmr_update_thresholds(struct mfc_cache *cache, unsigned char *ttls)
+static void ipmr_update_thresholds(struct mr_table *mrt, struct mfc_cache *cache,
+                                   unsigned char *ttls)
 {
         int vifi;
-        struct net *net = mfc_net(cache);
 
         cache->mfc_un.res.minvif = MAXVIFS;
         cache->mfc_un.res.maxvif = 0;
         memset(cache->mfc_un.res.ttls, 255, MAXVIFS);
 
-        for (vifi = 0; vifi < net->ipv4.maxvif; vifi++) {
-                if (VIF_EXISTS(net, vifi) &&
+        for (vifi = 0; vifi < mrt->maxvif; vifi++) {
+                if (VIF_EXISTS(mrt, vifi) &&
                     ttls[vifi] && ttls[vifi] < 255) {
                         cache->mfc_un.res.ttls[vifi] = ttls[vifi];
                         if (cache->mfc_un.res.minvif > vifi)
@@ -427,16 +671,17 @@ static void ipmr_update_thresholds(struct mfc_cache *cache, unsigned char *ttls)
         }
 }
 
-static int vif_add(struct net *net, struct vifctl *vifc, int mrtsock)
+static int vif_add(struct net *net, struct mr_table *mrt,
+                   struct vifctl *vifc, int mrtsock)
 {
         int vifi = vifc->vifc_vifi;
-        struct vif_device *v = &net->ipv4.vif_table[vifi];
+        struct vif_device *v = &mrt->vif_table[vifi];
         struct net_device *dev;
         struct in_device *in_dev;
         int err;
 
         /* Is vif busy ? */
-        if (VIF_EXISTS(net, vifi))
+        if (VIF_EXISTS(mrt, vifi))
                 return -EADDRINUSE;
 
         switch (vifc->vifc_flags) {
@@ -446,9 +691,9 @@ static int vif_add(struct net *net, struct vifctl *vifc, int mrtsock)
                  * Special Purpose VIF in PIM
                  * All the packets will be sent to the daemon
                  */
-                if (net->ipv4.mroute_reg_vif_num >= 0)
+                if (mrt->mroute_reg_vif_num >= 0)
                         return -EADDRINUSE;
-                dev = ipmr_reg_vif(net);
+                dev = ipmr_reg_vif(net, mrt);
                 if (!dev)
                         return -ENOBUFS;
                 err = dev_set_allmulti(dev, 1);
@@ -524,49 +769,47 @@ static int vif_add(struct net *net, struct vifctl *vifc, int mrtsock)
         v->dev = dev;
 #ifdef CONFIG_IP_PIMSM
         if (v->flags&VIFF_REGISTER)
-                net->ipv4.mroute_reg_vif_num = vifi;
+                mrt->mroute_reg_vif_num = vifi;
 #endif
-        if (vifi+1 > net->ipv4.maxvif)
-                net->ipv4.maxvif = vifi+1;
+        if (vifi+1 > mrt->maxvif)
+                mrt->maxvif = vifi+1;
         write_unlock_bh(&mrt_lock);
         return 0;
 }
 
-static struct mfc_cache *ipmr_cache_find(struct net *net,
+static struct mfc_cache *ipmr_cache_find(struct mr_table *mrt,
                                          __be32 origin,
                                          __be32 mcastgrp)
 {
         int line = MFC_HASH(mcastgrp, origin);
         struct mfc_cache *c;
 
-        for (c = net->ipv4.mfc_cache_array[line]; c; c = c->next) {
-                if (c->mfc_origin==origin && c->mfc_mcastgrp==mcastgrp)
-                        break;
+        list_for_each_entry(c, &mrt->mfc_cache_array[line], list) {
+                if (c->mfc_origin == origin && c->mfc_mcastgrp == mcastgrp)
+                        return c;
         }
-        return c;
+        return NULL;
 }
 
 /*
  *      Allocate a multicast cache entry
  */
-static struct mfc_cache *ipmr_cache_alloc(struct net *net)
+static struct mfc_cache *ipmr_cache_alloc(void)
 {
         struct mfc_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
         if (c == NULL)
                 return NULL;
         c->mfc_un.res.minvif = MAXVIFS;
-        mfc_net_set(c, net);
         return c;
 }
 
-static struct mfc_cache *ipmr_cache_alloc_unres(struct net *net)
+static struct mfc_cache *ipmr_cache_alloc_unres(void)
 {
         struct mfc_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC);
         if (c == NULL)
                 return NULL;
         skb_queue_head_init(&c->mfc_un.unres.unresolved);
         c->mfc_un.unres.expires = jiffies + 10*HZ;
-        mfc_net_set(c, net);
         return c;
 }
 
@@ -574,7 +817,8 @@ static struct mfc_cache *ipmr_cache_alloc_unres(struct net *net)
  *      A cache entry has gone into a resolved state from queued
  */
 
-static void ipmr_cache_resolve(struct mfc_cache *uc, struct mfc_cache *c)
+static void ipmr_cache_resolve(struct net *net, struct mr_table *mrt,
+                               struct mfc_cache *uc, struct mfc_cache *c)
 {
         struct sk_buff *skb;
         struct nlmsgerr *e;
@@ -587,7 +831,7 @@ static void ipmr_cache_resolve(struct mfc_cache *uc, struct mfc_cache *c)
                 if (ip_hdr(skb)->version == 0) {
                         struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr));
 
-                        if (ipmr_fill_mroute(skb, c, NLMSG_DATA(nlh)) > 0) {
+                        if (__ipmr_fill_mroute(mrt, skb, c, NLMSG_DATA(nlh)) > 0) {
                                 nlh->nlmsg_len = (skb_tail_pointer(skb) -
                                                   (u8 *)nlh);
                         } else {
@@ -599,9 +843,9 @@ static void ipmr_cache_resolve(struct mfc_cache *uc, struct mfc_cache *c)
                                 memset(&e->msg, 0, sizeof(e->msg));
                         }
 
-                        rtnl_unicast(skb, mfc_net(c), NETLINK_CB(skb).pid);
+                        rtnl_unicast(skb, net, NETLINK_CB(skb).pid);
                 } else
-                        ip_mr_forward(skb, c, 0);
+                        ip_mr_forward(net, mrt, skb, c, 0);
         }
 }
 
@@ -612,7 +856,7 @@ static void ipmr_cache_resolve(struct mfc_cache *uc, struct mfc_cache *c)
  *      Called under mrt_lock.
  */
 
-static int ipmr_cache_report(struct net *net,
+static int ipmr_cache_report(struct mr_table *mrt,
                              struct sk_buff *pkt, vifi_t vifi, int assert)
 {
         struct sk_buff *skb;
@@ -645,7 +889,7 @@ static int ipmr_cache_report(struct net *net,
                 memcpy(msg, skb_network_header(pkt), sizeof(struct iphdr));
                 msg->im_msgtype = IGMPMSG_WHOLEPKT;
                 msg->im_mbz = 0;
-                msg->im_vif = net->ipv4.mroute_reg_vif_num;
+                msg->im_vif = mrt->mroute_reg_vif_num;
                 ip_hdr(skb)->ihl = sizeof(struct iphdr) >> 2;
                 ip_hdr(skb)->tot_len = htons(ntohs(ip_hdr(pkt)->tot_len) +
                                              sizeof(struct iphdr));
@@ -677,7 +921,7 @@ static int ipmr_cache_report(struct net *net,
         skb->transport_header = skb->network_header;
         }
 
-        if (net->ipv4.mroute_sk == NULL) {
+        if (mrt->mroute_sk == NULL) {
                 kfree_skb(skb);
                 return -EINVAL;
         }
@@ -685,7 +929,7 @@ static int ipmr_cache_report(struct net *net,
         /*
          *      Deliver to mrouted
          */
-        ret = sock_queue_rcv_skb(net->ipv4.mroute_sk, skb);
+        ret = sock_queue_rcv_skb(mrt->mroute_sk, skb);
         if (ret < 0) {
                 if (net_ratelimit())
                         printk(KERN_WARNING "mroute: pending queue full, dropping entries.\n");
@@ -700,27 +944,29 @@ static int ipmr_cache_report(struct net *net,
  */
 
 static int
-ipmr_cache_unresolved(struct net *net, vifi_t vifi, struct sk_buff *skb)
+ipmr_cache_unresolved(struct mr_table *mrt, vifi_t vifi, struct sk_buff *skb)
 {
+        bool found = false;
         int err;
         struct mfc_cache *c;
         const struct iphdr *iph = ip_hdr(skb);
 
         spin_lock_bh(&mfc_unres_lock);
-        for (c=mfc_unres_queue; c; c=c->next) {
-                if (net_eq(mfc_net(c), net) &&
-                    c->mfc_mcastgrp == iph->daddr &&
-                    c->mfc_origin == iph->saddr)
+        list_for_each_entry(c, &mrt->mfc_unres_queue, list) {
+                if (c->mfc_mcastgrp == iph->daddr &&
+                    c->mfc_origin == iph->saddr) {
+                        found = true;
                         break;
+                }
         }
 
-        if (c == NULL) {
+        if (!found) {
                 /*
                  *      Create a new entry if allowable
                  */
 
-                if (atomic_read(&net->ipv4.cache_resolve_queue_len) >= 10 ||
-                    (c = ipmr_cache_alloc_unres(net)) == NULL) {
+                if (atomic_read(&mrt->cache_resolve_queue_len) >= 10 ||
+                    (c = ipmr_cache_alloc_unres()) == NULL) {
                         spin_unlock_bh(&mfc_unres_lock);
 
                         kfree_skb(skb);
@@ -737,7 +983,7 @@ ipmr_cache_unresolved(struct net *net, vifi_t vifi, struct sk_buff *skb)
                 /*
                  *      Reflect first query at mrouted.
                  */
-                err = ipmr_cache_report(net, skb, vifi, IGMPMSG_NOCACHE);
+                err = ipmr_cache_report(mrt, skb, vifi, IGMPMSG_NOCACHE);
                 if (err < 0) {
                         /* If the report failed throw the cache entry
                            out - Brad Parker
@@ -749,11 +995,10 @@ ipmr_cache_unresolved(struct net *net, vifi_t vifi, struct sk_buff *skb)
                         return err;
                 }
 
-                atomic_inc(&net->ipv4.cache_resolve_queue_len);
-                c->next = mfc_unres_queue;
-                mfc_unres_queue = c;
+                atomic_inc(&mrt->cache_resolve_queue_len);
+                list_add(&c->list, &mrt->mfc_unres_queue);
 
-                mod_timer(&ipmr_expire_timer, c->mfc_un.unres.expires);
+                mod_timer(&mrt->ipmr_expire_timer, c->mfc_un.unres.expires);
         }
 
         /*
@@ -775,19 +1020,18 @@ ipmr_cache_unresolved(struct net *net, vifi_t vifi, struct sk_buff *skb)
  *      MFC cache manipulation by user space mroute daemon
  */
 
-static int ipmr_mfc_delete(struct net *net, struct mfcctl *mfc)
+static int ipmr_mfc_delete(struct mr_table *mrt, struct mfcctl *mfc)
 {
         int line;
-        struct mfc_cache *c, **cp;
+        struct mfc_cache *c, *next;
 
         line = MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr);
 
-        for (cp = &net->ipv4.mfc_cache_array[line];
-             (c = *cp) != NULL; cp = &c->next) {
+        list_for_each_entry_safe(c, next, &mrt->mfc_cache_array[line], list) {
                 if (c->mfc_origin == mfc->mfcc_origin.s_addr &&
                     c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr) {
                         write_lock_bh(&mrt_lock);
-                        *cp = c->next;
+                        list_del(&c->list);
                         write_unlock_bh(&mrt_lock);
 
                         ipmr_cache_free(c);
@@ -797,24 +1041,30 @@ static int ipmr_mfc_delete(struct net *net, struct mfcctl *mfc)
         return -ENOENT;
 }
 
-static int ipmr_mfc_add(struct net *net, struct mfcctl *mfc, int mrtsock)
+static int ipmr_mfc_add(struct net *net, struct mr_table *mrt,
+                        struct mfcctl *mfc, int mrtsock)
 {
+        bool found = false;
         int line;
-        struct mfc_cache *uc, *c, **cp;
+        struct mfc_cache *uc, *c;
+
+        if (mfc->mfcc_parent >= MAXVIFS)
+                return -ENFILE;
 
         line = MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr);
 
-        for (cp = &net->ipv4.mfc_cache_array[line];
-             (c = *cp) != NULL; cp = &c->next) {
+        list_for_each_entry(c, &mrt->mfc_cache_array[line], list) {
                 if (c->mfc_origin == mfc->mfcc_origin.s_addr &&
-                    c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr)
+                    c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr) {
+                        found = true;
                         break;
+                }
         }
 
-        if (c != NULL) {
+        if (found) {
                 write_lock_bh(&mrt_lock);
                 c->mfc_parent = mfc->mfcc_parent;
-                ipmr_update_thresholds(c, mfc->mfcc_ttls);
+                ipmr_update_thresholds(mrt, c, mfc->mfcc_ttls);
                 if (!mrtsock)
                         c->mfc_flags |= MFC_STATIC;
                 write_unlock_bh(&mrt_lock);
@@ -824,43 +1074,42 @@ static int ipmr_mfc_add(struct net *net, struct mfcctl *mfc, int mrtsock)
         if (!ipv4_is_multicast(mfc->mfcc_mcastgrp.s_addr))
                 return -EINVAL;
 
-        c = ipmr_cache_alloc(net);
+        c = ipmr_cache_alloc();
         if (c == NULL)
                 return -ENOMEM;
 
         c->mfc_origin = mfc->mfcc_origin.s_addr;
         c->mfc_mcastgrp = mfc->mfcc_mcastgrp.s_addr;
         c->mfc_parent = mfc->mfcc_parent;
-        ipmr_update_thresholds(c, mfc->mfcc_ttls);
+        ipmr_update_thresholds(mrt, c, mfc->mfcc_ttls);
         if (!mrtsock)
                 c->mfc_flags |= MFC_STATIC;
 
         write_lock_bh(&mrt_lock);
-        c->next = net->ipv4.mfc_cache_array[line];
-        net->ipv4.mfc_cache_array[line] = c;
+        list_add(&c->list, &mrt->mfc_cache_array[line]);
         write_unlock_bh(&mrt_lock);
 
         /*
          *      Check to see if we resolved a queued list. If so we
          *      need to send on the frames and tidy up.
          */
+        found = false;
         spin_lock_bh(&mfc_unres_lock);
-        for (cp = &mfc_unres_queue; (uc=*cp) != NULL;
-             cp = &uc->next) {
-                if (net_eq(mfc_net(uc), net) &&
-                    uc->mfc_origin == c->mfc_origin &&
+        list_for_each_entry(uc, &mrt->mfc_unres_queue, list) {
+                if (uc->mfc_origin == c->mfc_origin &&
                     uc->mfc_mcastgrp == c->mfc_mcastgrp) {
-                        *cp = uc->next;
-                        atomic_dec(&net->ipv4.cache_resolve_queue_len);
+                        list_del(&uc->list);
+                        atomic_dec(&mrt->cache_resolve_queue_len);
+                        found = true;
                         break;
                 }
         }
-        if (mfc_unres_queue == NULL)
-                del_timer(&ipmr_expire_timer);
+        if (list_empty(&mrt->mfc_unres_queue))
+                del_timer(&mrt->ipmr_expire_timer);
         spin_unlock_bh(&mfc_unres_lock);
 
-        if (uc) {
-                ipmr_cache_resolve(uc, c);
+        if (found) {
+                ipmr_cache_resolve(net, mrt, uc, c);
                 ipmr_cache_free(uc);
         }
         return 0;
@@ -870,53 +1119,41 @@ static int ipmr_mfc_add(struct net *net, struct mfcctl *mfc, int mrtsock)
  *      Close the multicast socket, and clear the vif tables etc
  */
 
-static void mroute_clean_tables(struct net *net)
+static void mroute_clean_tables(struct mr_table *mrt)
 {
         int i;
         LIST_HEAD(list);
+        struct mfc_cache *c, *next;
 
         /*
          *      Shut down all active vif entries
          */
-        for (i = 0; i < net->ipv4.maxvif; i++) {
-                if (!(net->ipv4.vif_table[i].flags&VIFF_STATIC))
-                        vif_delete(net, i, 0, &list);
+        for (i = 0; i < mrt->maxvif; i++) {
+                if (!(mrt->vif_table[i].flags&VIFF_STATIC))
+                        vif_delete(mrt, i, 0, &list);
         }
         unregister_netdevice_many(&list);
 
         /*
          *      Wipe the cache
          */
-        for (i=0; i<MFC_LINES; i++) {
-                struct mfc_cache *c, **cp;
-
-                cp = &net->ipv4.mfc_cache_array[i];
-                while ((c = *cp) != NULL) {
-                        if (c->mfc_flags&MFC_STATIC) {
-                                cp = &c->next;
+        for (i = 0; i < MFC_LINES; i++) {
+                list_for_each_entry_safe(c, next, &mrt->mfc_cache_array[i], list) {
+                        if (c->mfc_flags&MFC_STATIC)
                                 continue;
-                        }
                         write_lock_bh(&mrt_lock);
-                        *cp = c->next;
+                        list_del(&c->list);
                         write_unlock_bh(&mrt_lock);
 
                         ipmr_cache_free(c);
                 }
         }
 
-        if (atomic_read(&net->ipv4.cache_resolve_queue_len) != 0) {
-                struct mfc_cache *c, **cp;
-
+        if (atomic_read(&mrt->cache_resolve_queue_len) != 0) {
                 spin_lock_bh(&mfc_unres_lock);
-                cp = &mfc_unres_queue;
-                while ((c = *cp) != NULL) {
-                        if (!net_eq(mfc_net(c), net)) {
-                                cp = &c->next;
-                                continue;
-                        }
-                        *cp = c->next;
-
-                        ipmr_destroy_unres(c);
+                list_for_each_entry_safe(c, next, &mrt->mfc_unres_queue, list) {
+                        list_del(&c->list);
+                        ipmr_destroy_unres(mrt, c);
                 }
                 spin_unlock_bh(&mfc_unres_lock);
         }
@@ -925,16 +1162,19 @@ static void mroute_clean_tables(struct net *net)
 static void mrtsock_destruct(struct sock *sk)
 {
         struct net *net = sock_net(sk);
+        struct mr_table *mrt;
 
         rtnl_lock();
-        if (sk == net->ipv4.mroute_sk) {
-                IPV4_DEVCONF_ALL(net, MC_FORWARDING)--;
+        ipmr_for_each_table(mrt, net) {
+                if (sk == mrt->mroute_sk) {
+                        IPV4_DEVCONF_ALL(net, MC_FORWARDING)--;
 
-                write_lock_bh(&mrt_lock);
-                net->ipv4.mroute_sk = NULL;
-                write_unlock_bh(&mrt_lock);
+                        write_lock_bh(&mrt_lock);
+                        mrt->mroute_sk = NULL;
+                        write_unlock_bh(&mrt_lock);
 
-                mroute_clean_tables(net);
+                        mroute_clean_tables(mrt);
+                }
         }
         rtnl_unlock();
 }
@@ -952,9 +1192,14 @@ int ip_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsi
         struct vifctl vif;
         struct mfcctl mfc;
         struct net *net = sock_net(sk);
+        struct mr_table *mrt;
+
+        mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
+        if (mrt == NULL)
+                return -ENOENT;
 
         if (optname != MRT_INIT) {
-                if (sk != net->ipv4.mroute_sk && !capable(CAP_NET_ADMIN))
+                if (sk != mrt->mroute_sk && !capable(CAP_NET_ADMIN))
                         return -EACCES;
         }
 
@@ -967,7 +1212,7 @@ int ip_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsi
                         return -ENOPROTOOPT;
 
                 rtnl_lock();
-                if (net->ipv4.mroute_sk) {
+                if (mrt->mroute_sk) {
                         rtnl_unlock();
                         return -EADDRINUSE;
                 }
@@ -975,7 +1220,7 @@ int ip_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsi
                 ret = ip_ra_control(sk, 1, mrtsock_destruct);
                 if (ret == 0) {
                         write_lock_bh(&mrt_lock);
-                        net->ipv4.mroute_sk = sk;
+                        mrt->mroute_sk = sk;
                         write_unlock_bh(&mrt_lock);
 
                         IPV4_DEVCONF_ALL(net, MC_FORWARDING)++;
@@ -983,7 +1228,7 @@ int ip_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsi
                 rtnl_unlock();
                 return ret;
         case MRT_DONE:
-                if (sk != net->ipv4.mroute_sk)
+                if (sk != mrt->mroute_sk)
                         return -EACCES;
                 return ip_ra_control(sk, 0, NULL);
         case MRT_ADD_VIF:
@@ -996,9 +1241,9 @@ int ip_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsi
                         return -ENFILE;
                 rtnl_lock();
                 if (optname == MRT_ADD_VIF) {
-                        ret = vif_add(net, &vif, sk == net->ipv4.mroute_sk);
+                        ret = vif_add(net, mrt, &vif, sk == mrt->mroute_sk);
                 } else {
-                        ret = vif_delete(net, vif.vifc_vifi, 0, NULL);
+                        ret = vif_delete(mrt, vif.vifc_vifi, 0, NULL);
                 }
                 rtnl_unlock();
                 return ret;
@@ -1015,9 +1260,9 @@ int ip_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsi
                         return -EFAULT;
                 rtnl_lock();
                 if (optname == MRT_DEL_MFC)
-                        ret = ipmr_mfc_delete(net, &mfc);
+                        ret = ipmr_mfc_delete(mrt, &mfc);
                 else
-                        ret = ipmr_mfc_add(net, &mfc, sk == net->ipv4.mroute_sk);
+                        ret = ipmr_mfc_add(net, mrt, &mfc, sk == mrt->mroute_sk);
                 rtnl_unlock();
                 return ret;
                 /*
@@ -1028,7 +1273,7 @@ int ip_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsi
                 int v;
                 if (get_user(v,(int __user *)optval))
                         return -EFAULT;
-                net->ipv4.mroute_do_assert = (v) ? 1 : 0;
+                mrt->mroute_do_assert = (v) ? 1 : 0;
                 return 0;
         }
 #ifdef CONFIG_IP_PIMSM
@@ -1042,14 +1287,35 @@ int ip_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsi
 
                 rtnl_lock();
                 ret = 0;
-                if (v != net->ipv4.mroute_do_pim) {
-                        net->ipv4.mroute_do_pim = v;
-                        net->ipv4.mroute_do_assert = v;
+                if (v != mrt->mroute_do_pim) {
+                        mrt->mroute_do_pim = v;
+                        mrt->mroute_do_assert = v;
                 }
                 rtnl_unlock();
                 return ret;
         }
 #endif
+#ifdef CONFIG_IP_MROUTE_MULTIPLE_TABLES
+        case MRT_TABLE:
+        {
+                u32 v;
+
+                if (optlen != sizeof(u32))
+                        return -EINVAL;
+                if (get_user(v, (u32 __user *)optval))
+                        return -EFAULT;
+                if (sk == mrt->mroute_sk)
+                        return -EBUSY;
+
+                rtnl_lock();
+                ret = 0;
+                if (!ipmr_new_table(net, v))
+                        ret = -ENOMEM;
+                raw_sk(sk)->ipmr_table = v;
+                rtnl_unlock();
+                return ret;
+        }
+#endif
         /*
          *      Spurious command, or MRT_VERSION which you cannot
          *      set.
@@ -1068,6 +1334,11 @@ int ip_mroute_getsockopt(struct sock *sk, int optname, char __user *optval, int
         int olr;
         int val;
         struct net *net = sock_net(sk);
+        struct mr_table *mrt;
+
+        mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
+        if (mrt == NULL)
+                return -ENOENT;
 
         if (optname != MRT_VERSION &&
 #ifdef CONFIG_IP_PIMSM
@@ -1089,10 +1360,10 @@ int ip_mroute_getsockopt(struct sock *sk, int optname, char __user *optval, int
                 val = 0x0305;
 #ifdef CONFIG_IP_PIMSM
         else if (optname == MRT_PIM)
-                val = net->ipv4.mroute_do_pim;
+                val = mrt->mroute_do_pim;
 #endif
         else
-                val = net->ipv4.mroute_do_assert;
+                val = mrt->mroute_do_assert;
         if (copy_to_user(optval, &val, olr))
                 return -EFAULT;
         return 0;
@@ -1109,16 +1380,21 @@ int ipmr_ioctl(struct sock *sk, int cmd, void __user *arg)
         struct vif_device *vif;
         struct mfc_cache *c;
         struct net *net = sock_net(sk);
+        struct mr_table *mrt;
+
+        mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
+        if (mrt == NULL)
+                return -ENOENT;
 
         switch (cmd) {
         case SIOCGETVIFCNT:
                 if (copy_from_user(&vr, arg, sizeof(vr)))
                         return -EFAULT;
-                if (vr.vifi >= net->ipv4.maxvif)
+                if (vr.vifi >= mrt->maxvif)
                         return -EINVAL;
                 read_lock(&mrt_lock);
-                vif = &net->ipv4.vif_table[vr.vifi];
-                if (VIF_EXISTS(net, vr.vifi)) {
+                vif = &mrt->vif_table[vr.vifi];
+                if (VIF_EXISTS(mrt, vr.vifi)) {
                         vr.icount = vif->pkt_in;
                         vr.ocount = vif->pkt_out;
                         vr.ibytes = vif->bytes_in;
@@ -1136,7 +1412,7 @@ int ipmr_ioctl(struct sock *sk, int cmd, void __user *arg)
                         return -EFAULT;
 
                 read_lock(&mrt_lock);
-                c = ipmr_cache_find(net, sr.src.s_addr, sr.grp.s_addr);
+                c = ipmr_cache_find(mrt, sr.src.s_addr, sr.grp.s_addr);
                 if (c) {
                         sr.pktcnt = c->mfc_un.res.pkt;
                         sr.bytecnt = c->mfc_un.res.bytes;
@@ -1159,16 +1435,20 @@ static int ipmr_device_event(struct notifier_block *this, unsigned long event, v
 {
         struct net_device *dev = ptr;
         struct net *net = dev_net(dev);
+        struct mr_table *mrt;
         struct vif_device *v;
         int ct;
         LIST_HEAD(list);
 
         if (event != NETDEV_UNREGISTER)
                 return NOTIFY_DONE;
-        v = &net->ipv4.vif_table[0];
-        for (ct = 0; ct < net->ipv4.maxvif; ct++, v++) {
-                if (v->dev == dev)
-                        vif_delete(net, ct, 1, &list);
+
+        ipmr_for_each_table(mrt, net) {
+                v = &mrt->vif_table[0];
+                for (ct = 0; ct < mrt->maxvif; ct++, v++) {
+                        if (v->dev == dev)
+                                vif_delete(mrt, ct, 1, &list);
+                }
         }
         unregister_netdevice_many(&list);
         return NOTIFY_DONE;
@@ -1227,11 +1507,11 @@ static inline int ipmr_forward_finish(struct sk_buff *skb)
  *      Processing handlers for ipmr_forward
  */
 
-static void ipmr_queue_xmit(struct sk_buff *skb, struct mfc_cache *c, int vifi)
+static void ipmr_queue_xmit(struct net *net, struct mr_table *mrt,
+                            struct sk_buff *skb, struct mfc_cache *c, int vifi)
 {
-        struct net *net = mfc_net(c);
         const struct iphdr *iph = ip_hdr(skb);
-        struct vif_device *vif = &net->ipv4.vif_table[vifi];
+        struct vif_device *vif = &mrt->vif_table[vifi];
         struct net_device *dev;
         struct rtable *rt;
         int    encap = 0;
@@ -1245,7 +1525,7 @@ static void ipmr_queue_xmit(struct sk_buff *skb, struct mfc_cache *c, int vifi)
                 vif->bytes_out += skb->len;
                 vif->dev->stats.tx_bytes += skb->len;
                 vif->dev->stats.tx_packets++;
-                ipmr_cache_report(net, skb, vifi, IGMPMSG_WHOLEPKT);
+                ipmr_cache_report(mrt, skb, vifi, IGMPMSG_WHOLEPKT);
                 goto out_free;
         }
 #endif
@@ -1328,12 +1608,12 @@ out_free:
         return;
 }
 
-static int ipmr_find_vif(struct net_device *dev)
+static int ipmr_find_vif(struct mr_table *mrt, struct net_device *dev)
 {
-        struct net *net = dev_net(dev);
         int ct;
-        for (ct = net->ipv4.maxvif-1; ct >= 0; ct--) {
-                if (net->ipv4.vif_table[ct].dev == dev)
+
+        for (ct = mrt->maxvif-1; ct >= 0; ct--) {
+                if (mrt->vif_table[ct].dev == dev)
                         break;
         }
         return ct;
@@ -1341,11 +1621,12 @@ static int ipmr_find_vif(struct net_device *dev)
 
 /* "local" means that we should preserve one skb (for local delivery) */
 
-static int ip_mr_forward(struct sk_buff *skb, struct mfc_cache *cache, int local)
+static int ip_mr_forward(struct net *net, struct mr_table *mrt,
+                         struct sk_buff *skb, struct mfc_cache *cache,
+                         int local)
 {
         int psend = -1;
         int vif, ct;
-        struct net *net = mfc_net(cache);
 
         vif = cache->mfc_parent;
         cache->mfc_un.res.pkt++;
@@ -1354,7 +1635,7 @@ static int ip_mr_forward(struct sk_buff *skb, struct mfc_cache *cache, int local
         /*
          * Wrong interface: drop packet and (maybe) send PIM assert.
          */
-        if (net->ipv4.vif_table[vif].dev != skb->dev) {
+        if (mrt->vif_table[vif].dev != skb->dev) {
                 int true_vifi;
 
                 if (skb_rtable(skb)->fl.iif == 0) {
@@ -1373,26 +1654,26 @@ static int ip_mr_forward(struct sk_buff *skb, struct mfc_cache *cache, int local
                 }
 
                 cache->mfc_un.res.wrong_if++;
-                true_vifi = ipmr_find_vif(skb->dev);
+                true_vifi = ipmr_find_vif(mrt, skb->dev);
 
-                if (true_vifi >= 0 && net->ipv4.mroute_do_assert &&
+                if (true_vifi >= 0 && mrt->mroute_do_assert &&
                     /* pimsm uses asserts, when switching from RPT to SPT,
                        so that we cannot check that packet arrived on an oif.
                        It is bad, but otherwise we would need to move pretty
                        large chunk of pimd to kernel. Ough... --ANK
                      */
-                    (net->ipv4.mroute_do_pim ||
+                    (mrt->mroute_do_pim ||
                      cache->mfc_un.res.ttls[true_vifi] < 255) &&
                     time_after(jiffies,
                                cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
                         cache->mfc_un.res.last_assert = jiffies;
-                        ipmr_cache_report(net, skb, true_vifi, IGMPMSG_WRONGVIF);
+                        ipmr_cache_report(mrt, skb, true_vifi, IGMPMSG_WRONGVIF);
                 }
                 goto dont_forward;
         }
 
-        net->ipv4.vif_table[vif].pkt_in++;
-        net->ipv4.vif_table[vif].bytes_in += skb->len;
+        mrt->vif_table[vif].pkt_in++;
+        mrt->vif_table[vif].bytes_in += skb->len;
 
         /*
          *      Forward the frame
@@ -1402,7 +1683,8 @@ static int ip_mr_forward(struct sk_buff *skb, struct mfc_cache *cache, int local
                         if (psend != -1) {
                                 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
                                 if (skb2)
-                                        ipmr_queue_xmit(skb2, cache, psend);
+                                        ipmr_queue_xmit(net, mrt, skb2, cache,
+                                                        psend);
                         }
                         psend = ct;
                 }
@@ -1411,9 +1693,9 @@ static int ip_mr_forward(struct sk_buff *skb, struct mfc_cache *cache, int local
                 if (local) {
                         struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
                         if (skb2)
-                                ipmr_queue_xmit(skb2, cache, psend);
+                                ipmr_queue_xmit(net, mrt, skb2, cache, psend);
                 } else {
-                        ipmr_queue_xmit(skb, cache, psend);
+                        ipmr_queue_xmit(net, mrt, skb, cache, psend);
                         return 0;
                 }
         }
@@ -1434,6 +1716,8 @@ int ip_mr_input(struct sk_buff *skb)
         struct mfc_cache *cache;
         struct net *net = dev_net(skb->dev);
         int local = skb_rtable(skb)->rt_flags & RTCF_LOCAL;
+        struct mr_table *mrt;
+        int err;
 
         /* Packet is looped back after forward, it should not be
            forwarded second time, but still can be delivered locally.
@@ -1441,6 +1725,10 @@ int ip_mr_input(struct sk_buff *skb)
         if (IPCB(skb)->flags&IPSKB_FORWARDED)
                 goto dont_forward;
 
+        err = ipmr_fib_lookup(net, &skb_rtable(skb)->fl, &mrt);
+        if (err < 0)
+                return err;
+
         if (!local) {
                     if (IPCB(skb)->opt.router_alert) {
                             if (ip_call_ra_chain(skb))
@@ -1453,9 +1741,9 @@ int ip_mr_input(struct sk_buff *skb)
                                that we can forward NO IGMP messages.
                              */
                             read_lock(&mrt_lock);
-                            if (net->ipv4.mroute_sk) {
+                            if (mrt->mroute_sk) {
                                     nf_reset(skb);
-                                    raw_rcv(net->ipv4.mroute_sk, skb);
+                                    raw_rcv(mrt->mroute_sk, skb);
                                     read_unlock(&mrt_lock);
                                     return 0;
                             }
@@ -1464,7 +1752,7 @@ int ip_mr_input(struct sk_buff *skb)
         }
 
         read_lock(&mrt_lock);
-        cache = ipmr_cache_find(net, ip_hdr(skb)->saddr, ip_hdr(skb)->daddr);
+        cache = ipmr_cache_find(mrt, ip_hdr(skb)->saddr, ip_hdr(skb)->daddr);
 
         /*
          *      No usable cache entry
@@ -1482,19 +1770,19 @@ int ip_mr_input(struct sk_buff *skb)
                         skb = skb2;
                 }
 
-                vif = ipmr_find_vif(skb->dev);
+                vif = ipmr_find_vif(mrt, skb->dev);
                 if (vif >= 0) {
-                        int err = ipmr_cache_unresolved(net, vif, skb);
+                        int err2 = ipmr_cache_unresolved(mrt, vif, skb);
                         read_unlock(&mrt_lock);
 
-                        return err;
+                        return err2;
                 }
                 read_unlock(&mrt_lock);
                 kfree_skb(skb);
                 return -ENODEV;
         }
 
-        ip_mr_forward(skb, cache, local);
+        ip_mr_forward(net, mrt, skb, cache, local);
 
         read_unlock(&mrt_lock);
 
@@ -1511,11 +1799,11 @@ dont_forward:
 }
 
 #ifdef CONFIG_IP_PIMSM
-static int __pim_rcv(struct sk_buff *skb, unsigned int pimlen)
+static int __pim_rcv(struct mr_table *mrt, struct sk_buff *skb,
+                     unsigned int pimlen)
 {
         struct net_device *reg_dev = NULL;
         struct iphdr *encap;
-        struct net *net = dev_net(skb->dev);
 
         encap = (struct iphdr *)(skb_transport_header(skb) + pimlen);
         /*
@@ -1530,8 +1818,8 @@ static int __pim_rcv(struct sk_buff *skb, unsigned int pimlen)
                 return 1;
 
         read_lock(&mrt_lock);
-        if (net->ipv4.mroute_reg_vif_num >= 0)
-                reg_dev = net->ipv4.vif_table[net->ipv4.mroute_reg_vif_num].dev;
+        if (mrt->mroute_reg_vif_num >= 0)
+                reg_dev = mrt->vif_table[mrt->mroute_reg_vif_num].dev;
         if (reg_dev)
                 dev_hold(reg_dev);
         read_unlock(&mrt_lock);
@@ -1566,17 +1854,21 @@ int pim_rcv_v1(struct sk_buff * skb)
 {
         struct igmphdr *pim;
         struct net *net = dev_net(skb->dev);
+        struct mr_table *mrt;
 
         if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(struct iphdr)))
                 goto drop;
 
         pim = igmp_hdr(skb);
 
-        if (!net->ipv4.mroute_do_pim ||
+        if (ipmr_fib_lookup(net, &skb_rtable(skb)->fl, &mrt) < 0)
+                goto drop;
+
+        if (!mrt->mroute_do_pim ||
             pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
                 goto drop;
 
-        if (__pim_rcv(skb, sizeof(*pim))) {
+        if (__pim_rcv(mrt, skb, sizeof(*pim))) {
 drop:
                 kfree_skb(skb);
         }
@@ -1588,6 +1880,8 @@ drop:
 static int pim_rcv(struct sk_buff * skb)
 {
         struct pimreghdr *pim;
+        struct net *net = dev_net(skb->dev);
+        struct mr_table *mrt;
 
         if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(struct iphdr)))
                 goto drop;
@@ -1599,7 +1893,10 @@ static int pim_rcv(struct sk_buff * skb)
              csum_fold(skb_checksum(skb, 0, skb->len, 0))))
                 goto drop;
 
-        if (__pim_rcv(skb, sizeof(*pim))) {
+        if (ipmr_fib_lookup(net, &skb_rtable(skb)->fl, &mrt) < 0)
+                goto drop;
+
+        if (__pim_rcv(mrt, skb, sizeof(*pim))) {
 drop:
                 kfree_skb(skb);
         }
@@ -1607,29 +1904,31 @@ drop:
 }
 #endif
 
-static int
-ipmr_fill_mroute(struct sk_buff *skb, struct mfc_cache *c, struct rtmsg *rtm)
+static int __ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
+                              struct mfc_cache *c, struct rtmsg *rtm)
 {
         int ct;
         struct rtnexthop *nhp;
-        struct net *net = mfc_net(c);
-        struct net_device *dev = net->ipv4.vif_table[c->mfc_parent].dev;
         u8 *b = skb_tail_pointer(skb);
         struct rtattr *mp_head;
 
-        if (dev)
-                RTA_PUT(skb, RTA_IIF, 4, &dev->ifindex);
+        /* If cache is unresolved, don't try to parse IIF and OIF */
+        if (c->mfc_parent > MAXVIFS)
+                return -ENOENT;
+
+        if (VIF_EXISTS(mrt, c->mfc_parent))
+                RTA_PUT(skb, RTA_IIF, 4, &mrt->vif_table[c->mfc_parent].dev->ifindex);
 
         mp_head = (struct rtattr *)skb_put(skb, RTA_LENGTH(0));
 
         for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
-                if (c->mfc_un.res.ttls[ct] < 255) {
+                if (VIF_EXISTS(mrt, ct) && c->mfc_un.res.ttls[ct] < 255) {
                         if (skb_tailroom(skb) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp)) + 4))
                                 goto rtattr_failure;
                         nhp = (struct rtnexthop *)skb_put(skb, RTA_ALIGN(sizeof(*nhp)));
                         nhp->rtnh_flags = 0;
                         nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
-                        nhp->rtnh_ifindex = net->ipv4.vif_table[ct].dev->ifindex;
+                        nhp->rtnh_ifindex = mrt->vif_table[ct].dev->ifindex;
                         nhp->rtnh_len = sizeof(*nhp);
                 }
         }
@@ -1647,11 +1946,16 @@ int ipmr_get_route(struct net *net,
                    struct sk_buff *skb, struct rtmsg *rtm, int nowait)
 {
         int err;
+        struct mr_table *mrt;
         struct mfc_cache *cache;
         struct rtable *rt = skb_rtable(skb);
 
+        mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
+        if (mrt == NULL)
+                return -ENOENT;
+
         read_lock(&mrt_lock);
-        cache = ipmr_cache_find(net, rt->rt_src, rt->rt_dst);
+        cache = ipmr_cache_find(mrt, rt->rt_src, rt->rt_dst);
 
         if (cache == NULL) {
                 struct sk_buff *skb2;
@@ -1665,7 +1969,7 @@ int ipmr_get_route(struct net *net,
                 }
 
                 dev = skb->dev;
-                if (dev == NULL || (vif = ipmr_find_vif(dev)) < 0) {
+                if (dev == NULL || (vif = ipmr_find_vif(mrt, dev)) < 0) {
                         read_unlock(&mrt_lock);
                         return -ENODEV;
                 }
@@ -1682,24 +1986,107 @@ int ipmr_get_route(struct net *net,
                 iph->saddr = rt->rt_src;
                 iph->daddr = rt->rt_dst;
                 iph->version = 0;
-                err = ipmr_cache_unresolved(net, vif, skb2);
+                err = ipmr_cache_unresolved(mrt, vif, skb2);
                 read_unlock(&mrt_lock);
                 return err;
         }
 
         if (!nowait && (rtm->rtm_flags&RTM_F_NOTIFY))
                 cache->mfc_flags |= MFC_NOTIFY;
-        err = ipmr_fill_mroute(skb, cache, rtm);
+        err = __ipmr_fill_mroute(mrt, skb, cache, rtm);
         read_unlock(&mrt_lock);
         return err;
 }
 
+static int ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
+                            u32 pid, u32 seq, struct mfc_cache *c)
+{
+        struct nlmsghdr *nlh;
+        struct rtmsg *rtm;
+
+        nlh = nlmsg_put(skb, pid, seq, RTM_NEWROUTE, sizeof(*rtm), NLM_F_MULTI);
+        if (nlh == NULL)
+                return -EMSGSIZE;
+
+        rtm = nlmsg_data(nlh);
+        rtm->rtm_family   = RTNL_FAMILY_IPMR;
+        rtm->rtm_dst_len  = 32;
+        rtm->rtm_src_len  = 32;
+        rtm->rtm_tos      = 0;
+        rtm->rtm_table    = mrt->id;
+        NLA_PUT_U32(skb, RTA_TABLE, mrt->id);
+        rtm->rtm_type     = RTN_MULTICAST;
+        rtm->rtm_scope    = RT_SCOPE_UNIVERSE;
+        rtm->rtm_protocol = RTPROT_UNSPEC;
+        rtm->rtm_flags    = 0;
+
+        NLA_PUT_BE32(skb, RTA_SRC, c->mfc_origin);
+        NLA_PUT_BE32(skb, RTA_DST, c->mfc_mcastgrp);
+
+        if (__ipmr_fill_mroute(mrt, skb, c, rtm) < 0)
+                goto nla_put_failure;
+
+        return nlmsg_end(skb, nlh);
+
+nla_put_failure:
+        nlmsg_cancel(skb, nlh);
+        return -EMSGSIZE;
+}
+
+static int ipmr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb)
+{
+        struct net *net = sock_net(skb->sk);
+        struct mr_table *mrt;
+        struct mfc_cache *mfc;
+        unsigned int t = 0, s_t;
+        unsigned int h = 0, s_h;
+        unsigned int e = 0, s_e;
+
+        s_t = cb->args[0];
+        s_h = cb->args[1];
+        s_e = cb->args[2];
+
+        read_lock(&mrt_lock);
+        ipmr_for_each_table(mrt, net) {
+                if (t < s_t)
+                        goto next_table;
+                if (t > s_t)
+                        s_h = 0;
+                for (h = s_h; h < MFC_LINES; h++) {
+                        list_for_each_entry(mfc, &mrt->mfc_cache_array[h], list) {
+                                if (e < s_e)
+                                        goto next_entry;
+                                if (ipmr_fill_mroute(mrt, skb,
+                                                     NETLINK_CB(cb->skb).pid,
+                                                     cb->nlh->nlmsg_seq,
+                                                     mfc) < 0)
+                                        goto done;
+next_entry:
+                                e++;
+                        }
+                        e = s_e = 0;
+                }
+                s_h = 0;
+next_table:
+                t++;
+        }
+done:
+        read_unlock(&mrt_lock);
+
+        cb->args[2] = e;
+        cb->args[1] = h;
+        cb->args[0] = t;
+
+        return skb->len;
+}
+
 #ifdef CONFIG_PROC_FS
 /*
  *      The /proc interfaces to multicast routing /proc/ip_mr_cache /proc/ip_mr_vif
  */
 struct ipmr_vif_iter {
         struct seq_net_private p;
+        struct mr_table *mrt;
         int ct;
 };
 
@@ -1707,11 +2094,13 @@ static struct vif_device *ipmr_vif_seq_idx(struct net *net,
                                            struct ipmr_vif_iter *iter,
                                            loff_t pos)
 {
-        for (iter->ct = 0; iter->ct < net->ipv4.maxvif; ++iter->ct) {
-                if (!VIF_EXISTS(net, iter->ct))
+        struct mr_table *mrt = iter->mrt;
+
+        for (iter->ct = 0; iter->ct < mrt->maxvif; ++iter->ct) {
+                if (!VIF_EXISTS(mrt, iter->ct))
                         continue;
                 if (pos-- == 0)
-                        return &net->ipv4.vif_table[iter->ct];
+                        return &mrt->vif_table[iter->ct];
         }
         return NULL;
 }
@@ -1719,7 +2108,15 @@ static struct vif_device *ipmr_vif_seq_idx(struct net *net,
 static void *ipmr_vif_seq_start(struct seq_file *seq, loff_t *pos)
         __acquires(mrt_lock)
 {
+        struct ipmr_vif_iter *iter = seq->private;
         struct net *net = seq_file_net(seq);
+        struct mr_table *mrt;
+
+        mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
+        if (mrt == NULL)
+                return ERR_PTR(-ENOENT);
+
+        iter->mrt = mrt;
 
         read_lock(&mrt_lock);
         return *pos ? ipmr_vif_seq_idx(net, seq->private, *pos - 1)
@@ -1730,15 +2127,16 @@ static void *ipmr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 {
         struct ipmr_vif_iter *iter = seq->private;
         struct net *net = seq_file_net(seq);
+        struct mr_table *mrt = iter->mrt;
 
         ++*pos;
         if (v == SEQ_START_TOKEN)
                 return ipmr_vif_seq_idx(net, iter, 0);
 
-        while (++iter->ct < net->ipv4.maxvif) {
-                if (!VIF_EXISTS(net, iter->ct))
+        while (++iter->ct < mrt->maxvif) {
+                if (!VIF_EXISTS(mrt, iter->ct))
                         continue;
-                return &net->ipv4.vif_table[iter->ct];
+                return &mrt->vif_table[iter->ct];
         }
         return NULL;
 }
@@ -1751,7 +2149,8 @@ static void ipmr_vif_seq_stop(struct seq_file *seq, void *v)
 
 static int ipmr_vif_seq_show(struct seq_file *seq, void *v)
 {
-        struct net *net = seq_file_net(seq);
+        struct ipmr_vif_iter *iter = seq->private;
+        struct mr_table *mrt = iter->mrt;
 
         if (v == SEQ_START_TOKEN) {
                 seq_puts(seq,
@@ -1762,7 +2161,7 @@ static int ipmr_vif_seq_show(struct seq_file *seq, void *v)
 
                 seq_printf(seq,
                            "%2Zd %-10s %8ld %7ld  %8ld %7ld %05X %08X %08X\n",
-                           vif - net->ipv4.vif_table,
+                           vif - mrt->vif_table,
                            name, vif->bytes_in, vif->pkt_in,
                            vif->bytes_out, vif->pkt_out,
                            vif->flags, vif->local, vif->remote);
@@ -1793,7 +2192,8 @@ static const struct file_operations ipmr_vif_fops = {
 
 struct ipmr_mfc_iter {
         struct seq_net_private p;
-        struct mfc_cache **cache;
+        struct mr_table *mrt;
+        struct list_head *cache;
         int ct;
 };
 
@@ -1801,22 +2201,22 @@ struct ipmr_mfc_iter {
 static struct mfc_cache *ipmr_mfc_seq_idx(struct net *net,
                                           struct ipmr_mfc_iter *it, loff_t pos)
 {
+        struct mr_table *mrt = it->mrt;
         struct mfc_cache *mfc;
 
-        it->cache = net->ipv4.mfc_cache_array;
         read_lock(&mrt_lock);
-        for (it->ct = 0; it->ct < MFC_LINES; it->ct++)
-                for (mfc = net->ipv4.mfc_cache_array[it->ct];
-                     mfc; mfc = mfc->next)
+        for (it->ct = 0; it->ct < MFC_LINES; it->ct++) {
+                it->cache = &mrt->mfc_cache_array[it->ct];
+                list_for_each_entry(mfc, it->cache, list)
                         if (pos-- == 0)
                                 return mfc;
+        }
         read_unlock(&mrt_lock);
 
-        it->cache = &mfc_unres_queue;
         spin_lock_bh(&mfc_unres_lock);
-        for (mfc = mfc_unres_queue; mfc; mfc = mfc->next)
-                if (net_eq(mfc_net(mfc), net) &&
-                    pos-- == 0)
+        it->cache = &mrt->mfc_unres_queue;
+        list_for_each_entry(mfc, it->cache, list)
+                if (pos-- == 0)
                         return mfc;
         spin_unlock_bh(&mfc_unres_lock);
 
@@ -1829,7 +2229,13 @@ static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
 {
         struct ipmr_mfc_iter *it = seq->private;
         struct net *net = seq_file_net(seq);
+        struct mr_table *mrt;
 
+        mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
+        if (mrt == NULL)
+                return ERR_PTR(-ENOENT);
+
+        it->mrt = mrt;
         it->cache = NULL;
         it->ct = 0;
         return *pos ? ipmr_mfc_seq_idx(net, seq->private, *pos - 1)
@@ -1841,37 +2247,36 @@ static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
         struct mfc_cache *mfc = v;
         struct ipmr_mfc_iter *it = seq->private;
         struct net *net = seq_file_net(seq);
+        struct mr_table *mrt = it->mrt;
 
         ++*pos;
 
         if (v == SEQ_START_TOKEN)
                 return ipmr_mfc_seq_idx(net, seq->private, 0);
 
-        if (mfc->next)
-                return mfc->next;
+        if (mfc->list.next != it->cache)
+                return list_entry(mfc->list.next, struct mfc_cache, list);
 
-        if (it->cache == &mfc_unres_queue)
+        if (it->cache == &mrt->mfc_unres_queue)
                 goto end_of_list;
 
-        BUG_ON(it->cache != net->ipv4.mfc_cache_array);
+        BUG_ON(it->cache != &mrt->mfc_cache_array[it->ct]);
 
         while (++it->ct < MFC_LINES) {
-                mfc = net->ipv4.mfc_cache_array[it->ct];
-                if (mfc)
-                        return mfc;
+                it->cache = &mrt->mfc_cache_array[it->ct];
+                if (list_empty(it->cache))
+                        continue;
+                return list_first_entry(it->cache, struct mfc_cache, list);
         }
 
         /* exhausted cache_array, show unresolved */
         read_unlock(&mrt_lock);
-        it->cache = &mfc_unres_queue;
+        it->cache = &mrt->mfc_unres_queue;
         it->ct = 0;
 
         spin_lock_bh(&mfc_unres_lock);
-        mfc = mfc_unres_queue;
-        while (mfc && !net_eq(mfc_net(mfc), net))
-                mfc = mfc->next;
-        if (mfc)
-                return mfc;
+        if (!list_empty(it->cache))
+                return list_first_entry(it->cache, struct mfc_cache, list);
 
  end_of_list:
         spin_unlock_bh(&mfc_unres_lock);
@@ -1883,18 +2288,17 @@ static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 static void ipmr_mfc_seq_stop(struct seq_file *seq, void *v)
 {
         struct ipmr_mfc_iter *it = seq->private;
-        struct net *net = seq_file_net(seq);
+        struct mr_table *mrt = it->mrt;
 
-        if (it->cache == &mfc_unres_queue)
+        if (it->cache == &mrt->mfc_unres_queue)
                 spin_unlock_bh(&mfc_unres_lock);
-        else if (it->cache == net->ipv4.mfc_cache_array)
+        else if (it->cache == &mrt->mfc_cache_array[it->ct])
                 read_unlock(&mrt_lock);
 }
 
 static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
 {
         int n;
-        struct net *net = seq_file_net(seq);
 
         if (v == SEQ_START_TOKEN) {
                 seq_puts(seq,
@@ -1902,20 +2306,21 @@ static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
         } else {
                 const struct mfc_cache *mfc = v;
                 const struct ipmr_mfc_iter *it = seq->private;
+                const struct mr_table *mrt = it->mrt;
 
-                seq_printf(seq, "%08lX %08lX %-3hd",
-                           (unsigned long) mfc->mfc_mcastgrp,
-                           (unsigned long) mfc->mfc_origin,
+                seq_printf(seq, "%08X %08X %-3hd",
+                           (__force u32) mfc->mfc_mcastgrp,
+                           (__force u32) mfc->mfc_origin,
                            mfc->mfc_parent);
 
-                if (it->cache != &mfc_unres_queue) {
+                if (it->cache != &mrt->mfc_unres_queue) {
                         seq_printf(seq, " %8lu %8lu %8lu",
                                    mfc->mfc_un.res.pkt,
                                    mfc->mfc_un.res.bytes,
                                    mfc->mfc_un.res.wrong_if);
                         for (n = mfc->mfc_un.res.minvif;
                              n < mfc->mfc_un.res.maxvif; n++ ) {
-                                if (VIF_EXISTS(net, n) &&
+                                if (VIF_EXISTS(mrt, n) &&
                                     mfc->mfc_un.res.ttls[n] < 255)
                                         seq_printf(seq,
                                            " %2d:%-3d",
@@ -1967,27 +2372,11 @@ static const struct net_protocol pim_protocol = {
  */
 static int __net_init ipmr_net_init(struct net *net)
 {
-        int err = 0;
+        int err;
 
-        net->ipv4.vif_table = kcalloc(MAXVIFS, sizeof(struct vif_device),
-                                      GFP_KERNEL);
-        if (!net->ipv4.vif_table) {
-                err = -ENOMEM;
+        err = ipmr_rules_init(net);
+        if (err < 0)
                 goto fail;
-        }
-
-        /* Forwarding cache */
-        net->ipv4.mfc_cache_array = kcalloc(MFC_LINES,
-                                            sizeof(struct mfc_cache *),
-                                            GFP_KERNEL);
-        if (!net->ipv4.mfc_cache_array) {
-                err = -ENOMEM;
-                goto fail_mfc_cache;
-        }
-
-#ifdef CONFIG_IP_PIMSM
-        net->ipv4.mroute_reg_vif_num = -1;
-#endif
 
 #ifdef CONFIG_PROC_FS
         err = -ENOMEM;
@@ -2002,10 +2391,8 @@ static int __net_init ipmr_net_init(struct net *net)
 proc_cache_fail:
         proc_net_remove(net, "ip_mr_vif");
 proc_vif_fail:
-        kfree(net->ipv4.mfc_cache_array);
+        ipmr_rules_exit(net);
 #endif
-fail_mfc_cache:
-        kfree(net->ipv4.vif_table);
 fail:
         return err;
 }
@@ -2016,8 +2403,7 @@ static void __net_exit ipmr_net_exit(struct net *net)
         proc_net_remove(net, "ip_mr_cache");
         proc_net_remove(net, "ip_mr_vif");
 #endif
-        kfree(net->ipv4.mfc_cache_array);
-        kfree(net->ipv4.vif_table);
+        ipmr_rules_exit(net);
 }
 
 static struct pernet_operations ipmr_net_ops = {
@@ -2040,7 +2426,6 @@ int __init ip_mr_init(void)
         if (err)
                 goto reg_pernet_fail;
 
-        setup_timer(&ipmr_expire_timer, ipmr_expire_process, 0);
         err = register_netdevice_notifier(&ip_mr_notifier);
         if (err)
                 goto reg_notif_fail;
@@ -2051,6 +2436,7 @@ int __init ip_mr_init(void)
                 goto add_proto_fail;
         }
 #endif
+        rtnl_register(RTNL_FAMILY_IPMR, RTM_GETROUTE, NULL, ipmr_rtm_dumproute);
         return 0;
 
 #ifdef CONFIG_IP_PIMSM_V2
@@ -2058,7 +2444,6 @@ add_proto_fail:
         unregister_netdevice_notifier(&ip_mr_notifier);
 #endif
 reg_notif_fail:
-        del_timer(&ipmr_expire_timer);
         unregister_pernet_subsys(&ipmr_net_ops);
 reg_pernet_fail:
         kmem_cache_destroy(mrt_cachep);
diff --git a/net/ipv4/netfilter.c b/net/ipv4/netfilter.c
index c14623fc4d5e..82fb43c5c59e 100644
--- a/net/ipv4/netfilter.c
+++ b/net/ipv4/netfilter.c
@@ -4,6 +4,7 @@
 #include <linux/netfilter_ipv4.h>
 #include <linux/ip.h>
 #include <linux/skbuff.h>
+#include <linux/gfp.h>
 #include <net/route.h>
 #include <net/xfrm.h>
 #include <net/ip.h>
diff --git a/net/ipv4/netfilter/arptable_filter.c b/net/ipv4/netfilter/arptable_filter.c
index bfe26f32b930..79ca5e70d497 100644
--- a/net/ipv4/netfilter/arptable_filter.c
+++ b/net/ipv4/netfilter/arptable_filter.c
@@ -8,6 +8,7 @@
 #include <linux/module.h>
 #include <linux/netfilter/x_tables.h>
 #include <linux/netfilter_arp/arp_tables.h>
+#include <linux/slab.h>
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("David S. Miller <davem@redhat.com>");
diff --git a/net/ipv4/netfilter/ip_queue.c b/net/ipv4/netfilter/ip_queue.c
index 2855f1f38cbc..e2787048aa0a 100644
--- a/net/ipv4/netfilter/ip_queue.c
+++ b/net/ipv4/netfilter/ip_queue.c
@@ -26,6 +26,7 @@
 #include <linux/security.h>
 #include <linux/net.h>
 #include <linux/mutex.h>
+#include <linux/slab.h>
 #include <net/net_namespace.h>
 #include <net/sock.h>
 #include <net/route.h>
diff --git a/net/ipv4/netfilter/ipt_CLUSTERIP.c b/net/ipv4/netfilter/ipt_CLUSTERIP.c
index 0886f96c736b..a992dc826f1c 100644
--- a/net/ipv4/netfilter/ipt_CLUSTERIP.c
+++ b/net/ipv4/netfilter/ipt_CLUSTERIP.c
@@ -14,6 +14,7 @@
 #include <linux/jhash.h>
 #include <linux/bitops.h>
 #include <linux/skbuff.h>
+#include <linux/slab.h>
 #include <linux/ip.h>
 #include <linux/tcp.h>
 #include <linux/udp.h>
@@ -87,7 +88,7 @@ clusterip_config_entry_put(struct clusterip_config *c)
                 list_del(&c->list);
                 write_unlock_bh(&clusterip_lock);
 
-                dev_mc_delete(c->dev, c->clustermac, ETH_ALEN, 0);
+                dev_mc_del(c->dev, c->clustermac);
                 dev_put(c->dev);
 
                 /* In case anyone still accesses the file, the open/close
@@ -396,7 +397,7 @@ static bool clusterip_tg_check(const struct xt_tgchk_param *par)
                                 dev_put(dev);
                                 return false;
                         }
-                        dev_mc_add(config->dev,config->clustermac, ETH_ALEN, 0);
+                        dev_mc_add(config->dev, config->clustermac);
                 }
         }
         cipinfo->config = config;
diff --git a/net/ipv4/netfilter/ipt_REJECT.c b/net/ipv4/netfilter/ipt_REJECT.c
index 5113b8f1a379..a0e8bcf04159 100644
--- a/net/ipv4/netfilter/ipt_REJECT.c
+++ b/net/ipv4/netfilter/ipt_REJECT.c
@@ -12,6 +12,7 @@
 
 #include <linux/module.h>
 #include <linux/skbuff.h>
+#include <linux/slab.h>
 #include <linux/ip.h>
 #include <linux/udp.h>
 #include <linux/icmp.h>
diff --git a/net/ipv4/netfilter/ipt_ULOG.c b/net/ipv4/netfilter/ipt_ULOG.c
index 09a5d3f7cc41..0dbe697f164f 100644
--- a/net/ipv4/netfilter/ipt_ULOG.c
+++ b/net/ipv4/netfilter/ipt_ULOG.c
@@ -33,6 +33,7 @@
 #include <linux/module.h>
 #include <linux/spinlock.h>
 #include <linux/socket.h>
+#include <linux/slab.h>
 #include <linux/skbuff.h>
 #include <linux/kernel.h>
 #include <linux/timer.h>
diff --git a/net/ipv4/netfilter/iptable_filter.c b/net/ipv4/netfilter/iptable_filter.c
index c8dc9800d620..55392466daa4 100644
--- a/net/ipv4/netfilter/iptable_filter.c
+++ b/net/ipv4/netfilter/iptable_filter.c
@@ -13,6 +13,7 @@
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/netfilter_ipv4/ip_tables.h>
+#include <linux/slab.h>
 #include <net/ip.h>
 
 MODULE_LICENSE("GPL");
diff --git a/net/ipv4/netfilter/iptable_mangle.c b/net/ipv4/netfilter/iptable_mangle.c
index b9b83464cbf4..294a2a32f293 100644
--- a/net/ipv4/netfilter/iptable_mangle.c
+++ b/net/ipv4/netfilter/iptable_mangle.c
@@ -12,6 +12,7 @@
 #include <linux/netfilter_ipv4/ip_tables.h>
 #include <linux/netdevice.h>
 #include <linux/skbuff.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 #include <net/route.h>
 #include <linux/ip.h>
diff --git a/net/ipv4/netfilter/iptable_raw.c b/net/ipv4/netfilter/iptable_raw.c
index 06fb9d11953c..07fb710cd722 100644
--- a/net/ipv4/netfilter/iptable_raw.c
+++ b/net/ipv4/netfilter/iptable_raw.c
@@ -5,6 +5,7 @@
  */
 #include <linux/module.h>
 #include <linux/netfilter_ipv4/ip_tables.h>
+#include <linux/slab.h>
 #include <net/ip.h>
 
 #define RAW_VALID_HOOKS ((1 << NF_INET_PRE_ROUTING) | (1 << NF_INET_LOCAL_OUT))
diff --git a/net/ipv4/netfilter/iptable_security.c b/net/ipv4/netfilter/iptable_security.c
index cce2f64e6f21..be45bdc4c602 100644
--- a/net/ipv4/netfilter/iptable_security.c
+++ b/net/ipv4/netfilter/iptable_security.c
@@ -17,6 +17,7 @@
  */
 #include <linux/module.h>
 #include <linux/netfilter_ipv4/ip_tables.h>
+#include <linux/slab.h>
 #include <net/ip.h>
 
 MODULE_LICENSE("GPL");
diff --git a/net/ipv4/netfilter/nf_nat_core.c b/net/ipv4/netfilter/nf_nat_core.c
index 4595281c2863..4f8bddb760c9 100644
--- a/net/ipv4/netfilter/nf_nat_core.c
+++ b/net/ipv4/netfilter/nf_nat_core.c
@@ -12,6 +12,7 @@
 #include <linux/types.h>
 #include <linux/timer.h>
 #include <linux/skbuff.h>
+#include <linux/gfp.h>
 #include <net/checksum.h>
 #include <net/icmp.h>
 #include <net/ip.h>
diff --git a/net/ipv4/netfilter/nf_nat_helper.c b/net/ipv4/netfilter/nf_nat_helper.c
index 4b6af4bb1f50..4a0c6b548eee 100644
--- a/net/ipv4/netfilter/nf_nat_helper.c
+++ b/net/ipv4/netfilter/nf_nat_helper.c
@@ -8,6 +8,7 @@
  * published by the Free Software Foundation.
  */
 #include <linux/module.h>
+#include <linux/gfp.h>
 #include <linux/kmod.h>
 #include <linux/types.h>
 #include <linux/timer.h>
diff --git a/net/ipv4/netfilter/nf_nat_rule.c b/net/ipv4/netfilter/nf_nat_rule.c
index ab74cc0535e2..26de2c1f7fab 100644
--- a/net/ipv4/netfilter/nf_nat_rule.c
+++ b/net/ipv4/netfilter/nf_nat_rule.c
@@ -15,6 +15,7 @@
 #include <linux/kmod.h>
 #include <linux/skbuff.h>
 #include <linux/proc_fs.h>
+#include <linux/slab.h>
 #include <net/checksum.h>
 #include <net/route.h>
 #include <linux/bitops.h>
diff --git a/net/ipv4/netfilter/nf_nat_snmp_basic.c b/net/ipv4/netfilter/nf_nat_snmp_basic.c
index 0b9c7ce3d6c5..4d85b6e55f29 100644
--- a/net/ipv4/netfilter/nf_nat_snmp_basic.c
+++ b/net/ipv4/netfilter/nf_nat_snmp_basic.c
@@ -43,6 +43,7 @@
 #include <linux/moduleparam.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/in.h>
 #include <linux/ip.h>
 #include <linux/udp.h>
diff --git a/net/ipv4/netfilter/nf_nat_standalone.c b/net/ipv4/netfilter/nf_nat_standalone.c
index 5678e9562c15..c39c9cf6bee6 100644
--- a/net/ipv4/netfilter/nf_nat_standalone.c
+++ b/net/ipv4/netfilter/nf_nat_standalone.c
@@ -7,6 +7,7 @@
  */
 #include <linux/types.h>
 #include <linux/icmp.h>
+#include <linux/gfp.h>
 #include <linux/ip.h>
 #include <linux/netfilter.h>
 #include <linux/netfilter_ipv4.h>
diff --git a/net/ipv4/proc.c b/net/ipv4/proc.c
index 4f1f337f4337..3dc9914c1dce 100644
--- a/net/ipv4/proc.c
+++ b/net/ipv4/proc.c
@@ -251,6 +251,7 @@ static const struct snmp_mib snmp4_net_list[] = {
         SNMP_MIB_ITEM("TCPSackShiftFallback", LINUX_MIB_SACKSHIFTFALLBACK),
         SNMP_MIB_ITEM("TCPBacklogDrop", LINUX_MIB_TCPBACKLOGDROP),
         SNMP_MIB_ITEM("TCPMinTTLDrop", LINUX_MIB_TCPMINTTLDROP),
+        SNMP_MIB_ITEM("TCPDeferAcceptDrop", LINUX_MIB_TCPDEFERACCEPTDROP),
         SNMP_MIB_SENTINEL
 };
 
diff --git a/net/ipv4/raw.c b/net/ipv4/raw.c
index ce154b47f1da..52ef5af78a45 100644
--- a/net/ipv4/raw.c
+++ b/net/ipv4/raw.c
@@ -60,7 +60,6 @@
 #include <net/net_namespace.h>
 #include <net/dst.h>
 #include <net/sock.h>
-#include <linux/gfp.h>
 #include <linux/ip.h>
 #include <linux/net.h>
 #include <net/ip.h>
@@ -291,7 +290,7 @@ static int raw_rcv_skb(struct sock * sk, struct sk_buff * skb)
 {
         /* Charge it to the socket. */
 
-        if (sock_queue_rcv_skb(sk, skb) < 0) {
+        if (ip_queue_rcv_skb(sk, skb) < 0) {
                 kfree_skb(skb);
                 return NET_RX_DROP;
         }
diff --git a/net/ipv4/route.c b/net/ipv4/route.c
index d9b40248b97f..a947428ef0ae 100644
--- a/net/ipv4/route.c
+++ b/net/ipv4/route.c
@@ -90,6 +90,7 @@
 #include <linux/jhash.h>
 #include <linux/rcupdate.h>
 #include <linux/times.h>
+#include <linux/slab.h>
 #include <net/dst.h>
 #include <net/net_namespace.h>
 #include <net/protocol.h>
@@ -257,10 +258,9 @@ static DEFINE_PER_CPU(struct rt_cache_stat, rt_cache_stat);
         (__raw_get_cpu_var(rt_cache_stat).field++)
 
 static inline unsigned int rt_hash(__be32 daddr, __be32 saddr, int idx,
-                int genid)
+                                   int genid)
 {
-        return jhash_3words((__force u32)(__be32)(daddr),
-                            (__force u32)(__be32)(saddr),
+        return jhash_3words((__force u32)daddr, (__force u32)saddr,
                             idx, genid)
                 & rt_hash_mask;
 }
@@ -377,12 +377,13 @@ static int rt_cache_seq_show(struct seq_file *seq, void *v)
                 struct rtable *r = v;
                 int len;
 
-                seq_printf(seq, "%s\t%08lX\t%08lX\t%8X\t%d\t%u\t%d\t"
-                              "%08lX\t%d\t%u\t%u\t%02X\t%d\t%1d\t%08X%n",
+                seq_printf(seq, "%s\t%08X\t%08X\t%8X\t%d\t%u\t%d\t"
+                              "%08X\t%d\t%u\t%u\t%02X\t%d\t%1d\t%08X%n",
                         r->u.dst.dev ? r->u.dst.dev->name : "*",
-                        (unsigned long)r->rt_dst, (unsigned long)r->rt_gateway,
+                        (__force u32)r->rt_dst,
+                        (__force u32)r->rt_gateway,
                         r->rt_flags, atomic_read(&r->u.dst.__refcnt),
-                        r->u.dst.__use, 0, (unsigned long)r->rt_src,
+                        r->u.dst.__use, 0, (__force u32)r->rt_src,
                         (dst_metric(&r->u.dst, RTAX_ADVMSS) ?
                              (int)dst_metric(&r->u.dst, RTAX_ADVMSS) + 40 : 0),
                         dst_metric(&r->u.dst, RTAX_WINDOW),
@@ -684,18 +685,17 @@ static inline bool rt_caching(const struct net *net)
 static inline bool compare_hash_inputs(const struct flowi *fl1,
                                         const struct flowi *fl2)
 {
-        return (__force u32)(((fl1->nl_u.ip4_u.daddr ^ fl2->nl_u.ip4_u.daddr) |
-                (fl1->nl_u.ip4_u.saddr ^ fl2->nl_u.ip4_u.saddr) |
+        return ((((__force u32)fl1->nl_u.ip4_u.daddr ^ (__force u32)fl2->nl_u.ip4_u.daddr) |
+                ((__force u32)fl1->nl_u.ip4_u.saddr ^ (__force u32)fl2->nl_u.ip4_u.saddr) |
                 (fl1->iif ^ fl2->iif)) == 0);
 }
 
 static inline int compare_keys(struct flowi *fl1, struct flowi *fl2)
 {
-        return ((__force u32)((fl1->nl_u.ip4_u.daddr ^ fl2->nl_u.ip4_u.daddr) |
-                (fl1->nl_u.ip4_u.saddr ^ fl2->nl_u.ip4_u.saddr)) |
+        return (((__force u32)fl1->nl_u.ip4_u.daddr ^ (__force u32)fl2->nl_u.ip4_u.daddr) |
+                ((__force u32)fl1->nl_u.ip4_u.saddr ^ (__force u32)fl2->nl_u.ip4_u.saddr) |
                 (fl1->mark ^ fl2->mark) |
-                (*(u16 *)&fl1->nl_u.ip4_u.tos ^
-                 *(u16 *)&fl2->nl_u.ip4_u.tos) |
+                (*(u16 *)&fl1->nl_u.ip4_u.tos ^ *(u16 *)&fl2->nl_u.ip4_u.tos) |
                 (fl1->oif ^ fl2->oif) |
                 (fl1->iif ^ fl2->iif)) == 0;
 }
@@ -932,10 +932,8 @@ static void rt_secret_rebuild_oneshot(struct net *net)
 {
         del_timer_sync(&net->ipv4.rt_secret_timer);
         rt_cache_invalidate(net);
-        if (ip_rt_secret_interval) {
-                net->ipv4.rt_secret_timer.expires += ip_rt_secret_interval;
-                add_timer(&net->ipv4.rt_secret_timer);
-        }
+        if (ip_rt_secret_interval)
+                mod_timer(&net->ipv4.rt_secret_timer, jiffies + ip_rt_secret_interval);
 }
 
 static void rt_emergency_hash_rebuild(struct net *net)
@@ -1099,7 +1097,7 @@ static int slow_chain_length(const struct rtable *head)
 }
 
 static int rt_intern_hash(unsigned hash, struct rtable *rt,
-                          struct rtable **rp, struct sk_buff *skb)
+                          struct rtable **rp, struct sk_buff *skb, int ifindex)
 {
         struct rtable   *rth, **rthp;
         unsigned long   now;
@@ -1214,11 +1212,16 @@ restart:
                     slow_chain_length(rt_hash_table[hash].chain) > rt_chain_length_max) {
                         struct net *net = dev_net(rt->u.dst.dev);
                         int num = ++net->ipv4.current_rt_cache_rebuild_count;
-                        if (!rt_caching(dev_net(rt->u.dst.dev))) {
+                        if (!rt_caching(net)) {
                                 printk(KERN_WARNING "%s: %d rebuilds is over limit, route caching disabled\n",
                                         rt->u.dst.dev->name, num);
                         }
-                        rt_emergency_hash_rebuild(dev_net(rt->u.dst.dev));
+                        rt_emergency_hash_rebuild(net);
+                        spin_unlock_bh(rt_hash_lock_addr(hash));
+
+                        hash = rt_hash(rt->fl.fl4_dst, rt->fl.fl4_src,
+                                        ifindex, rt_genid(net));
+                        goto restart;
                 }
         }
 
@@ -1443,7 +1446,7 @@ void ip_rt_redirect(__be32 old_gw, __be32 daddr, __be32 new_gw,
                                         dev_hold(rt->u.dst.dev);
                                 if (rt->idev)
                                         in_dev_hold(rt->idev);
-                                rt->u.dst.obsolete      = 0;
+                                rt->u.dst.obsolete      = -1;
                                 rt->u.dst.lastuse       = jiffies;
                                 rt->u.dst.path          = &rt->u.dst;
                                 rt->u.dst.neighbour     = NULL;
@@ -1479,7 +1482,7 @@ void ip_rt_redirect(__be32 old_gw, __be32 daddr, __be32 new_gw,
                                                         &netevent);
 
                                 rt_del(hash, rth);
-                                if (!rt_intern_hash(hash, rt, &rt, NULL))
+                                if (!rt_intern_hash(hash, rt, &rt, NULL, rt->fl.oif))
                                         ip_rt_put(rt);
                                 goto do_next;
                         }
@@ -1508,11 +1511,12 @@ static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst)
         struct dst_entry *ret = dst;
 
         if (rt) {
-                if (dst->obsolete) {
+                if (dst->obsolete > 0) {
                         ip_rt_put(rt);
                         ret = NULL;
                 } else if ((rt->rt_flags & RTCF_REDIRECTED) ||
-                           rt->u.dst.expires) {
+                           (rt->u.dst.expires &&
+                            time_after_eq(jiffies, rt->u.dst.expires))) {
                         unsigned hash = rt_hash(rt->fl.fl4_dst, rt->fl.fl4_src,
                                                 rt->fl.oif,
                                                 rt_genid(dev_net(dst->dev)));
@@ -1728,7 +1732,9 @@ static void ip_rt_update_pmtu(struct dst_entry *dst, u32 mtu)
 
 static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie)
 {
-        return NULL;
+        if (rt_is_expired((struct rtable *)dst))
+                return NULL;
+        return dst;
 }
 
 static void ipv4_dst_destroy(struct dst_entry *dst)
@@ -1890,7 +1896,8 @@ static int ip_route_input_mc(struct sk_buff *skb, __be32 daddr, __be32 saddr,
         if (!rth)
                 goto e_nobufs;
 
-        rth->u.dst.output= ip_rt_bug;
+        rth->u.dst.output = ip_rt_bug;
+        rth->u.dst.obsolete = -1;
 
         atomic_set(&rth->u.dst.__refcnt, 1);
         rth->u.dst.flags= DST_HOST;
@@ -1929,7 +1936,7 @@ static int ip_route_input_mc(struct sk_buff *skb, __be32 daddr, __be32 saddr,
 
         in_dev_put(in_dev);
         hash = rt_hash(daddr, saddr, dev->ifindex, rt_genid(dev_net(dev)));
-        return rt_intern_hash(hash, rth, NULL, skb);
+        return rt_intern_hash(hash, rth, NULL, skb, dev->ifindex);
 
 e_nobufs:
         in_dev_put(in_dev);
@@ -2056,6 +2063,7 @@ static int __mkroute_input(struct sk_buff *skb,
         rth->fl.oif     = 0;
         rth->rt_spec_dst= spec_dst;
 
+        rth->u.dst.obsolete = -1;
         rth->u.dst.input = ip_forward;
         rth->u.dst.output = ip_output;
         rth->rt_genid = rt_genid(dev_net(rth->u.dst.dev));
@@ -2095,7 +2103,7 @@ static int ip_mkroute_input(struct sk_buff *skb,
         /* put it into the cache */
         hash = rt_hash(daddr, saddr, fl->iif,
                        rt_genid(dev_net(rth->u.dst.dev)));
-        return rt_intern_hash(hash, rth, NULL, skb);
+        return rt_intern_hash(hash, rth, NULL, skb, fl->iif);
 }
 
 /*
@@ -2220,6 +2228,7 @@ local_input:
                 goto e_nobufs;
 
         rth->u.dst.output= ip_rt_bug;
+        rth->u.dst.obsolete = -1;
         rth->rt_genid = rt_genid(net);
 
         atomic_set(&rth->u.dst.__refcnt, 1);
@@ -2251,7 +2260,7 @@ local_input:
         }
         rth->rt_type    = res.type;
         hash = rt_hash(daddr, saddr, fl.iif, rt_genid(net));
-        err = rt_intern_hash(hash, rth, NULL, skb);
+        err = rt_intern_hash(hash, rth, NULL, skb, fl.iif);
         goto done;
 
 no_route:
@@ -2309,8 +2318,8 @@ int ip_route_input(struct sk_buff *skb, __be32 daddr, __be32 saddr,
         rcu_read_lock();
         for (rth = rcu_dereference(rt_hash_table[hash].chain); rth;
              rth = rcu_dereference(rth->u.dst.rt_next)) {
-                if (((rth->fl.fl4_dst ^ daddr) |
-                     (rth->fl.fl4_src ^ saddr) |
+                if ((((__force u32)rth->fl.fl4_dst ^ (__force u32)daddr) |
+                     ((__force u32)rth->fl.fl4_src ^ (__force u32)saddr) |
                      (rth->fl.iif ^ iif) |
                      rth->fl.oif |
                      (rth->fl.fl4_tos ^ tos)) == 0 &&
@@ -2446,6 +2455,7 @@ static int __mkroute_output(struct rtable **result,
         rth->rt_spec_dst= fl->fl4_src;
 
         rth->u.dst.output=ip_output;
+        rth->u.dst.obsolete = -1;
         rth->rt_genid = rt_genid(dev_net(dev_out));
 
         RT_CACHE_STAT_INC(out_slow_tot);
@@ -2497,7 +2507,7 @@ static int ip_mkroute_output(struct rtable **rp,
         if (err == 0) {
                 hash = rt_hash(oldflp->fl4_dst, oldflp->fl4_src, oldflp->oif,
                                rt_genid(dev_net(dev_out)));
-                err = rt_intern_hash(hash, rth, rp, NULL);
+                err = rt_intern_hash(hash, rth, rp, NULL, oldflp->oif);
         }
 
         return err;
@@ -3103,22 +3113,20 @@ static void rt_secret_reschedule(int old)
         rtnl_lock();
         for_each_net(net) {
                 int deleted = del_timer_sync(&net->ipv4.rt_secret_timer);
+                long time;
 
                 if (!new)
                         continue;
 
                 if (deleted) {
-                        long time = net->ipv4.rt_secret_timer.expires - jiffies;
+                        time = net->ipv4.rt_secret_timer.expires - jiffies;
 
                         if (time <= 0 || (time += diff) <= 0)
                                 time = 0;
-
-                        net->ipv4.rt_secret_timer.expires = time;
                 } else
-                        net->ipv4.rt_secret_timer.expires = new;
+                        time = new;
 
-                net->ipv4.rt_secret_timer.expires += jiffies;
-                add_timer(&net->ipv4.rt_secret_timer);
+                mod_timer(&net->ipv4.rt_secret_timer, jiffies + time);
         }
         rtnl_unlock();
 }
diff --git a/net/ipv4/sysctl_net_ipv4.c b/net/ipv4/sysctl_net_ipv4.c
index c1bc074f61b7..1cd5c15174b8 100644
--- a/net/ipv4/sysctl_net_ipv4.c
+++ b/net/ipv4/sysctl_net_ipv4.c
@@ -12,6 +12,7 @@
 #include <linux/inetdevice.h>
 #include <linux/seqlock.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <net/snmp.h>
 #include <net/icmp.h>
 #include <net/ip.h>
diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
index 5901010fad55..8ce29747ad9b 100644
--- a/net/ipv4/tcp.c
+++ b/net/ipv4/tcp.c
@@ -265,6 +265,7 @@
 #include <linux/err.h>
 #include <linux/crypto.h>
 #include <linux/time.h>
+#include <linux/slab.h>
 
 #include <net/icmp.h>
 #include <net/tcp.h>
@@ -377,7 +378,7 @@ unsigned int tcp_poll(struct file *file, struct socket *sock, poll_table *wait)
         struct sock *sk = sock->sk;
         struct tcp_sock *tp = tcp_sk(sk);
 
-        sock_poll_wait(file, sk->sk_sleep, wait);
+        sock_poll_wait(file, sk_sleep(sk), wait);
         if (sk->sk_state == TCP_LISTEN)
                 return inet_csk_listen_poll(sk);
 
@@ -429,7 +430,7 @@ unsigned int tcp_poll(struct file *file, struct socket *sock, poll_table *wait)
                 if (tp->urg_seq == tp->copied_seq &&
                     !sock_flag(sk, SOCK_URGINLINE) &&
                     tp->urg_data)
-                        target--;
+                        target++;
 
                 /* Potential race condition. If read of tp below will
                  * escape above sk->sk_state, we can be illegally awaken
@@ -1254,6 +1255,39 @@ static void tcp_prequeue_process(struct sock *sk)
         tp->ucopy.memory = 0;
 }
 
+#ifdef CONFIG_NET_DMA
+static void tcp_service_net_dma(struct sock *sk, bool wait)
+{
+        dma_cookie_t done, used;
+        dma_cookie_t last_issued;
+        struct tcp_sock *tp = tcp_sk(sk);
+
+        if (!tp->ucopy.dma_chan)
+                return;
+
+        last_issued = tp->ucopy.dma_cookie;
+        dma_async_memcpy_issue_pending(tp->ucopy.dma_chan);
+
+        do {
+                if (dma_async_memcpy_complete(tp->ucopy.dma_chan,
+                                              last_issued, &done,
+                                              &used) == DMA_SUCCESS) {
+                        /* Safe to free early-copied skbs now */
+                        __skb_queue_purge(&sk->sk_async_wait_queue);
+                        break;
+                } else {
+                        struct sk_buff *skb;
+                        while ((skb = skb_peek(&sk->sk_async_wait_queue)) &&
+                               (dma_async_is_complete(skb->dma_cookie, done,
+                                                      used) == DMA_SUCCESS)) {
+                                __skb_dequeue(&sk->sk_async_wait_queue);
+                                kfree_skb(skb);
+                        }
+                }
+        } while (wait);
+}
+#endif
+
 static inline struct sk_buff *tcp_recv_skb(struct sock *sk, u32 seq, u32 *off)
 {
         struct sk_buff *skb;
@@ -1335,6 +1369,7 @@ int tcp_read_sock(struct sock *sk, read_descriptor_t *desc,
                 sk_eat_skb(sk, skb, 0);
                 if (!desc->count)
                         break;
+                tp->copied_seq = seq;
         }
         tp->copied_seq = seq;
 
@@ -1546,6 +1581,10 @@ int tcp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
                         /* __ Set realtime policy in scheduler __ */
                 }
 
+#ifdef CONFIG_NET_DMA
+                if (tp->ucopy.dma_chan)
+                        dma_async_memcpy_issue_pending(tp->ucopy.dma_chan);
+#endif
                 if (copied >= target) {
                         /* Do not sleep, just process backlog. */
                         release_sock(sk);
@@ -1554,6 +1593,7 @@ int tcp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
                         sk_wait_data(sk, &timeo);
 
 #ifdef CONFIG_NET_DMA
+                tcp_service_net_dma(sk, false);  /* Don't block */
                 tp->ucopy.wakeup = 0;
 #endif
 
@@ -1633,6 +1673,9 @@ do_prequeue:
                                                 copied = -EFAULT;
                                         break;
                                 }
+
+                                dma_async_memcpy_issue_pending(tp->ucopy.dma_chan);
+
                                 if ((offset + used) == skb->len)
                                         copied_early = 1;
 
@@ -1702,27 +1745,9 @@ skip_copy:
         }
 
 #ifdef CONFIG_NET_DMA
-        if (tp->ucopy.dma_chan) {
-                dma_cookie_t done, used;
-
-                dma_async_memcpy_issue_pending(tp->ucopy.dma_chan);
-
-                while (dma_async_memcpy_complete(tp->ucopy.dma_chan,
-                                                 tp->ucopy.dma_cookie, &done,
-                                                 &used) == DMA_IN_PROGRESS) {
-                        /* do partial cleanup of sk_async_wait_queue */
-                        while ((skb = skb_peek(&sk->sk_async_wait_queue)) &&
-                               (dma_async_is_complete(skb->dma_cookie, done,
-                                                      used) == DMA_SUCCESS)) {
-                                __skb_dequeue(&sk->sk_async_wait_queue);
-                                kfree_skb(skb);
-                        }
-                }
+        tcp_service_net_dma(sk, true);  /* Wait for queue to drain */
+        tp->ucopy.dma_chan = NULL;
 
-                /* Safe to free early-copied skbs now */
-                __skb_queue_purge(&sk->sk_async_wait_queue);
-                tp->ucopy.dma_chan = NULL;
-        }
         if (tp->ucopy.pinned_list) {
                 dma_unpin_iovec_pages(tp->ucopy.pinned_list);
                 tp->ucopy.pinned_list = NULL;
@@ -2273,7 +2298,7 @@ static int do_tcp_setsockopt(struct sock *sk, int level,
                         if (sock_flag(sk, SOCK_KEEPOPEN) &&
                             !((1 << sk->sk_state) &
                               (TCPF_CLOSE | TCPF_LISTEN))) {
-                                __u32 elapsed = tcp_time_stamp - tp->rcv_tstamp;
+                                u32 elapsed = keepalive_time_elapsed(tp);
                                 if (tp->keepalive_time > elapsed)
                                         elapsed = tp->keepalive_time - elapsed;
                                 else
@@ -2696,7 +2721,7 @@ struct sk_buff **tcp_gro_receive(struct sk_buff **head, struct sk_buff *skb)
         struct tcphdr *th2;
         unsigned int len;
         unsigned int thlen;
-        unsigned int flags;
+        __be32 flags;
         unsigned int mss = 1;
         unsigned int hlen;
         unsigned int off;
@@ -2746,10 +2771,10 @@ struct sk_buff **tcp_gro_receive(struct sk_buff **head, struct sk_buff *skb)
 
 found:
         flush = NAPI_GRO_CB(p)->flush;
-        flush |= flags & TCP_FLAG_CWR;
-        flush |= (flags ^ tcp_flag_word(th2)) &
-                  ~(TCP_FLAG_CWR | TCP_FLAG_FIN | TCP_FLAG_PSH);
-        flush |= th->ack_seq ^ th2->ack_seq;
+        flush |= (__force int)(flags & TCP_FLAG_CWR);
+        flush |= (__force int)((flags ^ tcp_flag_word(th2)) &
+                  ~(TCP_FLAG_CWR | TCP_FLAG_FIN | TCP_FLAG_PSH));
+        flush |= (__force int)(th->ack_seq ^ th2->ack_seq);
         for (i = sizeof(*th); i < thlen; i += 4)
                 flush |= *(u32 *)((u8 *)th + i) ^
                          *(u32 *)((u8 *)th2 + i);
@@ -2770,8 +2795,9 @@ found:
 
 out_check_final:
         flush = len < mss;
-        flush |= flags & (TCP_FLAG_URG | TCP_FLAG_PSH | TCP_FLAG_RST |
-                          TCP_FLAG_SYN | TCP_FLAG_FIN);
+        flush |= (__force int)(flags & (TCP_FLAG_URG | TCP_FLAG_PSH |
+                                        TCP_FLAG_RST | TCP_FLAG_SYN |
+                                        TCP_FLAG_FIN));
 
         if (p && (!NAPI_GRO_CB(skb)->same_flow || flush))
                 pp = head;
diff --git a/net/ipv4/tcp_cong.c b/net/ipv4/tcp_cong.c
index 6428b342b164..0ec9bd0ae94f 100644
--- a/net/ipv4/tcp_cong.c
+++ b/net/ipv4/tcp_cong.c
@@ -10,6 +10,7 @@
 #include <linux/mm.h>
 #include <linux/types.h>
 #include <linux/list.h>
+#include <linux/gfp.h>
 #include <net/tcp.h>
 
 int sysctl_tcp_max_ssthresh = 0;
diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index 788851ca8c5d..e82162c211bf 100644
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -62,6 +62,7 @@
  */
 
 #include <linux/mm.h>
+#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/sysctl.h>
 #include <linux/kernel.h>
@@ -2511,6 +2512,9 @@ static void tcp_mark_head_lost(struct sock *sk, int packets)
         int err;
         unsigned int mss;
 
+        if (packets == 0)
+                return;
+
         WARN_ON(packets > tp->packets_out);
         if (tp->lost_skb_hint) {
                 skb = tp->lost_skb_hint;
@@ -3706,7 +3710,7 @@ static int tcp_ack(struct sock *sk, struct sk_buff *skb, int flag)
         }
 
         if ((flag & FLAG_FORWARD_PROGRESS) || !(flag & FLAG_NOT_DUP))
-                dst_confirm(sk->sk_dst_cache);
+                dst_confirm(__sk_dst_get(sk));
 
         return 1;
 
@@ -4315,7 +4319,7 @@ static void tcp_ofo_queue(struct sock *sk)
                 }
 
                 if (!after(TCP_SKB_CB(skb)->end_seq, tp->rcv_nxt)) {
-                        SOCK_DEBUG(sk, "ofo packet was already received \n");
+                        SOCK_DEBUG(sk, "ofo packet was already received\n");
                         __skb_unlink(skb, &tp->out_of_order_queue);
                         __kfree_skb(skb);
                         continue;
@@ -4363,6 +4367,7 @@ static void tcp_data_queue(struct sock *sk, struct sk_buff *skb)
         if (TCP_SKB_CB(skb)->seq == TCP_SKB_CB(skb)->end_seq)
                 goto drop;
 
+        skb_dst_drop(skb);
         __skb_pull(skb, th->doff * 4);
 
         TCP_ECN_accept_cwr(tp, skb);
@@ -5829,7 +5834,7 @@ int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb,
                         if (tp->snd_una == tp->write_seq) {
                                 tcp_set_state(sk, TCP_FIN_WAIT2);
                                 sk->sk_shutdown |= SEND_SHUTDOWN;
-                                dst_confirm(sk->sk_dst_cache);
+                                dst_confirm(__sk_dst_get(sk));
 
                                 if (!sock_flag(sk, SOCK_DEAD))
                                         /* Wake up lingering close() */
diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c
index 8d51d39ad1bb..771f8146a2e5 100644
--- a/net/ipv4/tcp_ipv4.c
+++ b/net/ipv4/tcp_ipv4.c
@@ -60,6 +60,7 @@
 #include <linux/jhash.h>
 #include <linux/init.h>
 #include <linux/times.h>
+#include <linux/slab.h>
 
 #include <net/net_namespace.h>
 #include <net/icmp.h>
@@ -370,6 +371,11 @@ void tcp_v4_err(struct sk_buff *icmp_skb, u32 info)
         if (sk->sk_state == TCP_CLOSE)
                 goto out;
 
+        if (unlikely(iph->ttl < inet_sk(sk)->min_ttl)) {
+                NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
+                goto out;
+        }
+
         icsk = inet_csk(sk);
         tp = tcp_sk(sk);
         seq = ntohl(th->seq);
@@ -513,26 +519,31 @@ out:
         sock_put(sk);
 }
 
-/* This routine computes an IPv4 TCP checksum. */
-void tcp_v4_send_check(struct sock *sk, int len, struct sk_buff *skb)
+static void __tcp_v4_send_check(struct sk_buff *skb,
+                                __be32 saddr, __be32 daddr)
 {
-        struct inet_sock *inet = inet_sk(sk);
         struct tcphdr *th = tcp_hdr(skb);
 
         if (skb->ip_summed == CHECKSUM_PARTIAL) {
-                th->check = ~tcp_v4_check(len, inet->inet_saddr,
-                                          inet->inet_daddr, 0);
+                th->check = ~tcp_v4_check(skb->len, saddr, daddr, 0);
                 skb->csum_start = skb_transport_header(skb) - skb->head;
                 skb->csum_offset = offsetof(struct tcphdr, check);
         } else {
-                th->check = tcp_v4_check(len, inet->inet_saddr,
-                                         inet->inet_daddr,
+                th->check = tcp_v4_check(skb->len, saddr, daddr,
                                          csum_partial(th,
                                                       th->doff << 2,
                                                       skb->csum));
         }
 }
 
+/* This routine computes an IPv4 TCP checksum. */
+void tcp_v4_send_check(struct sock *sk, struct sk_buff *skb)
+{
+        struct inet_sock *inet = inet_sk(sk);
+
+        __tcp_v4_send_check(skb, inet->inet_saddr, inet->inet_daddr);
+}
+
 int tcp_v4_gso_send_check(struct sk_buff *skb)
 {
         const struct iphdr *iph;
@@ -545,10 +556,8 @@ int tcp_v4_gso_send_check(struct sk_buff *skb)
         th = tcp_hdr(skb);
 
         th->check = 0;
-        th->check = ~tcp_v4_check(skb->len, iph->saddr, iph->daddr, 0);
-        skb->csum_start = skb_transport_header(skb) - skb->head;
-        skb->csum_offset = offsetof(struct tcphdr, check);
         skb->ip_summed = CHECKSUM_PARTIAL;
+        __tcp_v4_send_check(skb, iph->saddr, iph->daddr);
         return 0;
 }
 
@@ -757,13 +766,7 @@ static int tcp_v4_send_synack(struct sock *sk, struct dst_entry *dst,
         skb = tcp_make_synack(sk, dst, req, rvp);
 
         if (skb) {
-                struct tcphdr *th = tcp_hdr(skb);
-
-                th->check = tcp_v4_check(skb->len,
-                                         ireq->loc_addr,
-                                         ireq->rmt_addr,
-                                         csum_partial(th, skb->len,
-                                                      skb->csum));
+                __tcp_v4_send_check(skb, ireq->loc_addr, ireq->rmt_addr);
 
                 err = ip_build_and_send_pkt(skb, sk, ireq->loc_addr,
                                             ireq->rmt_addr,
@@ -1283,8 +1286,8 @@ int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
                         goto drop_and_release;
 
                 /* Secret recipe starts with IP addresses */
-                *mess++ ^= daddr;
-                *mess++ ^= saddr;
+                *mess++ ^= (__force u32)daddr;
+                *mess++ ^= (__force u32)saddr;
 
                 /* plus variable length Initiator Cookie */
                 c = (u8 *)mess;
@@ -1651,15 +1654,15 @@ int tcp_v4_rcv(struct sk_buff *skb)
         if (!sk)
                 goto no_tcp_socket;
 
+process:
+        if (sk->sk_state == TCP_TIME_WAIT)
+                goto do_time_wait;
+
         if (unlikely(iph->ttl < inet_sk(sk)->min_ttl)) {
                 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
                 goto discard_and_relse;
         }
 
-process:
-        if (sk->sk_state == TCP_TIME_WAIT)
-                goto do_time_wait;
-
         if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
                 goto discard_and_relse;
         nf_reset(skb);
@@ -1669,6 +1672,8 @@ process:
 
         skb->dev = NULL;
 
+        sock_rps_save_rxhash(sk, skb->rxhash);
+
         bh_lock_sock_nested(sk);
         ret = 0;
         if (!sock_owned_by_user(sk)) {
diff --git a/net/ipv4/tcp_minisocks.c b/net/ipv4/tcp_minisocks.c
index 4199bc6915c5..794c2e122a41 100644
--- a/net/ipv4/tcp_minisocks.c
+++ b/net/ipv4/tcp_minisocks.c
@@ -20,6 +20,7 @@
 
 #include <linux/mm.h>
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/sysctl.h>
 #include <linux/workqueue.h>
 #include <net/tcp.h>
@@ -671,6 +672,7 @@ struct sock *tcp_check_req(struct sock *sk, struct sk_buff *skb,
         if (req->retrans < inet_csk(sk)->icsk_accept_queue.rskq_defer_accept &&
             TCP_SKB_CB(skb)->end_seq == tcp_rsk(req)->rcv_isn + 1) {
                 inet_rsk(req)->acked = 1;
+                NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPDEFERACCEPTDROP);
                 return NULL;
         }
 
diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index f181b78f2385..5db3a2c6cb33 100644
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -37,6 +37,7 @@
 #include <net/tcp.h>
 
 #include <linux/compiler.h>
+#include <linux/gfp.h>
 #include <linux/module.h>
 
 /* People can turn this off for buggy TCP's found in printers etc. */
@@ -349,6 +350,7 @@ static inline void TCP_ECN_send(struct sock *sk, struct sk_buff *skb,
  */
 static void tcp_init_nondata_skb(struct sk_buff *skb, u32 seq, u8 flags)
 {
+        skb->ip_summed = CHECKSUM_PARTIAL;
         skb->csum = 0;
 
         TCP_SKB_CB(skb)->flags = flags;
@@ -859,7 +861,7 @@ static int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it,
                         th->urg_ptr = htons(tp->snd_up - tcb->seq);
                         th->urg = 1;
                 } else if (after(tcb->seq + 0xFFFF, tp->snd_nxt)) {
-                        th->urg_ptr = 0xFFFF;
+                        th->urg_ptr = htons(0xFFFF);
                         th->urg = 1;
                 }
         }
@@ -877,7 +879,7 @@ static int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it,
         }
 #endif
 
-        icsk->icsk_af_ops->send_check(sk, skb->len, skb);
+        icsk->icsk_af_ops->send_check(sk, skb);
 
         if (likely(tcb->flags & TCPCB_FLAG_ACK))
                 tcp_event_ack_sent(sk, tcp_skb_pcount(skb));
@@ -886,9 +888,10 @@ static int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it,
                 tcp_event_data_sent(tp, skb, sk);
 
         if (after(tcb->end_seq, tp->snd_nxt) || tcb->seq == tcb->end_seq)
-                TCP_INC_STATS(sock_net(sk), TCP_MIB_OUTSEGS);
+                TCP_ADD_STATS(sock_net(sk), TCP_MIB_OUTSEGS,
+                              tcp_skb_pcount(skb));
 
-        err = icsk->icsk_af_ops->queue_xmit(skb, 0);
+        err = icsk->icsk_af_ops->queue_xmit(skb);
         if (likely(err <= 0))
                 return err;
 
@@ -2483,7 +2486,7 @@ struct sk_buff *tcp_make_synack(struct sock *sk, struct dst_entry *dst,
                         *tail-- ^= TCP_SKB_CB(skb)->seq + 1;
 
                         /* recommended */
-                        *tail-- ^= ((th->dest << 16) | th->source);
+                        *tail-- ^= (((__force u32)th->dest << 16) | (__force u32)th->source);
                         *tail-- ^= (u32)(unsigned long)cvp; /* per sockopt */
 
                         sha_transform((__u32 *)&xvp->cookie_bakery[0],
@@ -2501,7 +2504,7 @@ struct sk_buff *tcp_make_synack(struct sock *sk, struct dst_entry *dst,
         th->window = htons(min(req->rcv_wnd, 65535U));
         tcp_options_write((__be32 *)(th + 1), tp, &opts);
         th->doff = (tcp_header_size >> 2);
-        TCP_INC_STATS(sock_net(sk), TCP_MIB_OUTSEGS);
+        TCP_ADD_STATS(sock_net(sk), TCP_MIB_OUTSEGS, tcp_skb_pcount(skb));
 
 #ifdef CONFIG_TCP_MD5SIG
         /* Okay, we have all we need - do the md5 hash if needed */
diff --git a/net/ipv4/tcp_probe.c b/net/ipv4/tcp_probe.c
index 9bc805df95d2..f8efada580e8 100644
--- a/net/ipv4/tcp_probe.c
+++ b/net/ipv4/tcp_probe.c
@@ -22,6 +22,7 @@
 #include <linux/kprobes.h>
 #include <linux/socket.h>
 #include <linux/tcp.h>
+#include <linux/slab.h>
 #include <linux/proc_fs.h>
 #include <linux/module.h>
 #include <linux/ktime.h>
diff --git a/net/ipv4/tcp_timer.c b/net/ipv4/tcp_timer.c
index a17629b8912e..440a5c6004f6 100644
--- a/net/ipv4/tcp_timer.c
+++ b/net/ipv4/tcp_timer.c
@@ -19,6 +19,7 @@
  */
 
 #include <linux/module.h>
+#include <linux/gfp.h>
 #include <net/tcp.h>
 
 int sysctl_tcp_syn_retries __read_mostly = TCP_SYN_RETRIES;
@@ -134,7 +135,7 @@ static void tcp_mtu_probing(struct inet_connection_sock *icsk, struct sock *sk)
 }
 
 /* This function calculates a "timeout" which is equivalent to the timeout of a
- * TCP connection after "boundary" unsucessful, exponentially backed-off
+ * TCP connection after "boundary" unsuccessful, exponentially backed-off
  * retransmissions with an initial RTO of TCP_RTO_MIN.
  */
 static bool retransmits_timed_out(struct sock *sk,
@@ -171,14 +172,14 @@ static int tcp_write_timeout(struct sock *sk)
 
         if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV)) {
                 if (icsk->icsk_retransmits)
-                        dst_negative_advice(&sk->sk_dst_cache, sk);
+                        dst_negative_advice(sk);
                 retry_until = icsk->icsk_syn_retries ? : sysctl_tcp_syn_retries;
         } else {
                 if (retransmits_timed_out(sk, sysctl_tcp_retries1)) {
                         /* Black hole detection */
                         tcp_mtu_probing(icsk, sk);
 
-                        dst_negative_advice(&sk->sk_dst_cache, sk);
+                        dst_negative_advice(sk);
                 }
 
                 retry_until = sysctl_tcp_retries2;
@@ -516,7 +517,7 @@ static void tcp_keepalive_timer (unsigned long data)
         struct sock *sk = (struct sock *) data;
         struct inet_connection_sock *icsk = inet_csk(sk);
         struct tcp_sock *tp = tcp_sk(sk);
-        __u32 elapsed;
+        u32 elapsed;
 
         /* Only process if socket is not in use. */
         bh_lock_sock(sk);
@@ -553,7 +554,7 @@ static void tcp_keepalive_timer (unsigned long data)
         if (tp->packets_out || tcp_send_head(sk))
                 goto resched;
 
-        elapsed = tcp_time_stamp - tp->rcv_tstamp;
+        elapsed = keepalive_time_elapsed(tp);
 
         if (elapsed >= keepalive_time_when(tp)) {
                 if (icsk->icsk_probes_out >= keepalive_probes(tp)) {
diff --git a/net/ipv4/tunnel4.c b/net/ipv4/tunnel4.c
index 3959e0ca456a..3b3813cc80b9 100644
--- a/net/ipv4/tunnel4.c
+++ b/net/ipv4/tunnel4.c
@@ -8,6 +8,7 @@
 #include <linux/mutex.h>
 #include <linux/netdevice.h>
 #include <linux/skbuff.h>
+#include <linux/slab.h>
 #include <net/icmp.h>
 #include <net/ip.h>
 #include <net/protocol.h>
diff --git a/net/ipv4/udp.c b/net/ipv4/udp.c
index 7af756d0f931..4560b291180b 100644
--- a/net/ipv4/udp.c
+++ b/net/ipv4/udp.c
@@ -95,6 +95,7 @@
 #include <linux/mm.h>
 #include <linux/inet.h>
 #include <linux/netdevice.h>
+#include <linux/slab.h>
 #include <net/tcp_states.h>
 #include <linux/skbuff.h>
 #include <linux/proc_fs.h>
@@ -306,13 +307,13 @@ static int ipv4_rcv_saddr_equal(const struct sock *sk1, const struct sock *sk2)
 static unsigned int udp4_portaddr_hash(struct net *net, __be32 saddr,
                                        unsigned int port)
 {
-        return jhash_1word(saddr, net_hash_mix(net)) ^ port;
+        return jhash_1word((__force u32)saddr, net_hash_mix(net)) ^ port;
 }
 
 int udp_v4_get_port(struct sock *sk, unsigned short snum)
 {
         unsigned int hash2_nulladdr =
-                udp4_portaddr_hash(sock_net(sk), INADDR_ANY, snum);
+                udp4_portaddr_hash(sock_net(sk), htonl(INADDR_ANY), snum);
         unsigned int hash2_partial =
                 udp4_portaddr_hash(sock_net(sk), inet_sk(sk)->inet_rcv_saddr, 0);
 
@@ -465,14 +466,14 @@ static struct sock *__udp4_lib_lookup(struct net *net, __be32 saddr,
                                           daddr, hnum, dif,
                                           hslot2, slot2);
                 if (!result) {
-                        hash2 = udp4_portaddr_hash(net, INADDR_ANY, hnum);
+                        hash2 = udp4_portaddr_hash(net, htonl(INADDR_ANY), hnum);
                         slot2 = hash2 & udptable->mask;
                         hslot2 = &udptable->hash2[slot2];
                         if (hslot->count < hslot2->count)
                                 goto begin;
 
-                        result = udp4_lib_lookup2(net, INADDR_ANY, sport,
-                                                  daddr, hnum, dif,
+                        result = udp4_lib_lookup2(net, saddr, sport,
+                                                  htonl(INADDR_ANY), hnum, dif,
                                                   hslot2, slot2);
                 }
                 rcu_read_unlock();
@@ -1061,10 +1062,10 @@ static unsigned int first_packet_length(struct sock *sk)
         spin_unlock_bh(&rcvq->lock);
 
         if (!skb_queue_empty(&list_kill)) {
-                lock_sock(sk);
+                lock_sock_bh(sk);
                 __skb_queue_purge(&list_kill);
                 sk_mem_reclaim_partial(sk);
-                release_sock(sk);
+                unlock_sock_bh(sk);
         }
         return res;
 }
@@ -1195,10 +1196,10 @@ out:
         return err;
 
 csum_copy_err:
-        lock_sock(sk);
+        lock_sock_bh(sk);
         if (!skb_kill_datagram(sk, skb, flags))
                 UDP_INC_STATS_USER(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
-        release_sock(sk);
+        unlock_sock_bh(sk);
 
         if (noblock)
                 return -EAGAIN;
@@ -1216,6 +1217,7 @@ int udp_disconnect(struct sock *sk, int flags)
         sk->sk_state = TCP_CLOSE;
         inet->inet_daddr = 0;
         inet->inet_dport = 0;
+        sock_rps_save_rxhash(sk, 0);
         sk->sk_bound_dev_if = 0;
         if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK))
                 inet_reset_saddr(sk);
@@ -1257,8 +1259,12 @@ EXPORT_SYMBOL(udp_lib_unhash);
 
 static int __udp_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
 {
-        int rc = sock_queue_rcv_skb(sk, skb);
+        int rc;
+
+        if (inet_sk(sk)->inet_daddr)
+                sock_rps_save_rxhash(sk, skb->rxhash);
 
+        rc = ip_queue_rcv_skb(sk, skb);
         if (rc < 0) {
                 int is_udplite = IS_UDPLITE(sk);
 
@@ -1366,6 +1372,10 @@ int udp_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
                         goto drop;
         }
 
+
+        if (sk_rcvqueues_full(sk, skb))
+                goto drop;
+
         rc = 0;
 
         bh_lock_sock(sk);
@@ -1614,9 +1624,9 @@ int udp_rcv(struct sk_buff *skb)
 
 void udp_destroy_sock(struct sock *sk)
 {
-        lock_sock(sk);
+        lock_sock_bh(sk);
         udp_flush_pending_frames(sk);
-        release_sock(sk);
+        unlock_sock_bh(sk);
 }
 
 /*
diff --git a/net/ipv4/xfrm4_input.c b/net/ipv4/xfrm4_input.c
index f9f922a0ba88..c791bb63203f 100644
--- a/net/ipv4/xfrm4_input.c
+++ b/net/ipv4/xfrm4_input.c
@@ -9,6 +9,7 @@
  *
  */
 
+#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/string.h>
 #include <linux/netfilter.h>
diff --git a/net/ipv4/xfrm4_mode_tunnel.c b/net/ipv4/xfrm4_mode_tunnel.c
index 3444f3b34eca..6f368413eb0e 100644
--- a/net/ipv4/xfrm4_mode_tunnel.c
+++ b/net/ipv4/xfrm4_mode_tunnel.c
@@ -4,6 +4,7 @@
  * Copyright (c) 2004-2006 Herbert Xu <herbert@gondor.apana.org.au>
  */
 
+#include <linux/gfp.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
diff --git a/net/ipv4/xfrm4_policy.c b/net/ipv4/xfrm4_policy.c
index e4a1483fba77..1705476670ef 100644
--- a/net/ipv4/xfrm4_policy.c
+++ b/net/ipv4/xfrm4_policy.c
@@ -59,27 +59,6 @@ static int xfrm4_get_saddr(struct net *net,
         return 0;
 }
 
-static struct dst_entry *
-__xfrm4_find_bundle(struct flowi *fl, struct xfrm_policy *policy)
-{
-        struct dst_entry *dst;
-
-        read_lock_bh(&policy->lock);
-        for (dst = policy->bundles; dst; dst = dst->next) {
-                struct xfrm_dst *xdst = (struct xfrm_dst *)dst;
-                if (xdst->u.rt.fl.oif == fl->oif &&     /*XXX*/
-                    xdst->u.rt.fl.fl4_dst == fl->fl4_dst &&
-                    xdst->u.rt.fl.fl4_src == fl->fl4_src &&
-                    xdst->u.rt.fl.fl4_tos == fl->fl4_tos &&
-                    xfrm_bundle_ok(policy, xdst, fl, AF_INET, 0)) {
-                        dst_clone(dst);
-                        break;
-                }
-        }
-        read_unlock_bh(&policy->lock);
-        return dst;
-}
-
 static int xfrm4_get_tos(struct flowi *fl)
 {
         return fl->fl4_tos;
@@ -259,7 +238,6 @@ static struct xfrm_policy_afinfo xfrm4_policy_afinfo = {
         .dst_ops =              &xfrm4_dst_ops,
         .dst_lookup =           xfrm4_dst_lookup,
         .get_saddr =            xfrm4_get_saddr,
-        .find_bundle =          __xfrm4_find_bundle,
         .decode_session =       _decode_session4,
         .get_tos =              xfrm4_get_tos,
         .init_path =            xfrm4_init_path,
diff --git a/net/ipv6/addrconf.c b/net/ipv6/addrconf.c
index 6cf3ee14ace3..3984f52181f4 100644
--- a/net/ipv6/addrconf.c
+++ b/net/ipv6/addrconf.c
@@ -53,6 +53,7 @@
 #include <linux/route.h>
 #include <linux/inetdevice.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 #ifdef CONFIG_SYSCTL
 #include <linux/sysctl.h>
 #endif
@@ -81,7 +82,7 @@
 #include <linux/random.h>
 #endif
 
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 #include <asm/unaligned.h>
 
 #include <linux/proc_fs.h>
@@ -97,7 +98,11 @@
 #endif
 
 #define INFINITY_LIFE_TIME      0xFFFFFFFF
-#define TIME_DELTA(a,b) ((unsigned long)((long)(a) - (long)(b)))
+#define TIME_DELTA(a, b) ((unsigned long)((long)(a) - (long)(b)))
+
+#define ADDRCONF_TIMER_FUZZ_MINUS       (HZ > 50 ? HZ/50 : 1)
+#define ADDRCONF_TIMER_FUZZ             (HZ / 4)
+#define ADDRCONF_TIMER_FUZZ_MAX         (HZ)
 
 #ifdef CONFIG_SYSCTL
 static void addrconf_sysctl_register(struct inet6_dev *idev);
@@ -126,8 +131,8 @@ static int ipv6_count_addresses(struct inet6_dev *idev);
 /*
  *      Configured unicast address hash table
  */
-static struct inet6_ifaddr              *inet6_addr_lst[IN6_ADDR_HSIZE];
-static DEFINE_RWLOCK(addrconf_hash_lock);
+static struct hlist_head inet6_addr_lst[IN6_ADDR_HSIZE];
+static DEFINE_SPINLOCK(addrconf_hash_lock);
 
 static void addrconf_verify(unsigned long);
 
@@ -137,8 +142,8 @@ static DEFINE_SPINLOCK(addrconf_verify_lock);
 static void addrconf_join_anycast(struct inet6_ifaddr *ifp);
 static void addrconf_leave_anycast(struct inet6_ifaddr *ifp);
 
-static void addrconf_bonding_change(struct net_device *dev,
-                                    unsigned long event);
+static void addrconf_type_change(struct net_device *dev,
+                                 unsigned long event);
 static int addrconf_ifdown(struct net_device *dev, int how);
 
 static void addrconf_dad_start(struct inet6_ifaddr *ifp, u32 flags);
@@ -151,8 +156,8 @@ static void ipv6_ifa_notify(int event, struct inet6_ifaddr *ifa);
 
 static void inet6_prefix_notify(int event, struct inet6_dev *idev,
                                 struct prefix_info *pinfo);
-static int ipv6_chk_same_addr(struct net *net, const struct in6_addr *addr,
-                              struct net_device *dev);
+static bool ipv6_chk_same_addr(struct net *net, const struct in6_addr *addr,
+                               struct net_device *dev);
 
 static ATOMIC_NOTIFIER_HEAD(inet6addr_chain);
 
@@ -249,8 +254,7 @@ static void addrconf_del_timer(struct inet6_ifaddr *ifp)
                 __in6_ifa_put(ifp);
 }
 
-enum addrconf_timer_t
-{
+enum addrconf_timer_t {
         AC_NONE,
         AC_DAD,
         AC_RS,
@@ -270,7 +274,8 @@ static void addrconf_mod_timer(struct inet6_ifaddr *ifp,
         case AC_RS:
                 ifp->timer.function = addrconf_rs_timer;
                 break;
-        default:;
+        default:
+                break;
         }
         ifp->timer.expires = jiffies + when;
         add_timer(&ifp->timer);
@@ -317,7 +322,7 @@ void in6_dev_finish_destroy(struct inet6_dev *idev)
 {
         struct net_device *dev = idev->dev;
 
-        WARN_ON(idev->addr_list != NULL);
+        WARN_ON(!list_empty(&idev->addr_list));
         WARN_ON(idev->mc_list != NULL);
 
 #ifdef NET_REFCNT_DEBUG
@@ -325,7 +330,7 @@ void in6_dev_finish_destroy(struct inet6_dev *idev)
 #endif
         dev_put(dev);
         if (!idev->dead) {
-                printk("Freeing alive inet6 device %p\n", idev);
+                pr_warning("Freeing alive inet6 device %p\n", idev);
                 return;
         }
         snmp6_free_dev(idev);
@@ -350,6 +355,8 @@ static struct inet6_dev * ipv6_add_dev(struct net_device *dev)
 
         rwlock_init(&ndev->lock);
         ndev->dev = dev;
+        INIT_LIST_HEAD(&ndev->addr_list);
+
         memcpy(&ndev->cnf, dev_net(dev)->ipv6.devconf_dflt, sizeof(ndev->cnf));
         ndev->cnf.mtu6 = dev->mtu;
         ndev->cnf.sysctl = NULL;
@@ -401,6 +408,7 @@ static struct inet6_dev * ipv6_add_dev(struct net_device *dev)
 #endif
 
 #ifdef CONFIG_IPV6_PRIVACY
+        INIT_LIST_HEAD(&ndev->tempaddr_list);
         setup_timer(&ndev->regen_timer, ipv6_regen_rndid, (unsigned long)ndev);
         if ((dev->flags&IFF_LOOPBACK) ||
             dev->type == ARPHRD_TUNNEL ||
@@ -438,8 +446,10 @@ static struct inet6_dev * ipv6_find_idev(struct net_device *dev)
 
         ASSERT_RTNL();
 
-        if ((idev = __in6_dev_get(dev)) == NULL) {
-                if ((idev = ipv6_add_dev(dev)) == NULL)
+        idev = __in6_dev_get(dev);
+        if (!idev) {
+                idev = ipv6_add_dev(dev);
+                if (!idev)
                         return NULL;
         }
 
@@ -465,7 +475,8 @@ static void dev_forward_change(struct inet6_dev *idev)
                 else
                         ipv6_dev_mc_dec(dev, &in6addr_linklocal_allrouters);
         }
-        for (ifa=idev->addr_list; ifa; ifa=ifa->if_next) {
+
+        list_for_each_entry(ifa, &idev->addr_list, if_list) {
                 if (ifa->flags&IFA_F_TENTATIVE)
                         continue;
                 if (idev->cnf.forwarding)
@@ -522,12 +533,16 @@ static int addrconf_fixup_forwarding(struct ctl_table *table, int *p, int old)
 }
 #endif
 
-/* Nobody refers to this ifaddr, destroy it */
+static void inet6_ifa_finish_destroy_rcu(struct rcu_head *head)
+{
+        struct inet6_ifaddr *ifp = container_of(head, struct inet6_ifaddr, rcu);
+        kfree(ifp);
+}
 
+/* Nobody refers to this ifaddr, destroy it */
 void inet6_ifa_finish_destroy(struct inet6_ifaddr *ifp)
 {
-        WARN_ON(ifp->if_next != NULL);
-        WARN_ON(ifp->lst_next != NULL);
+        WARN_ON(!hlist_unhashed(&ifp->addr_lst));
 
 #ifdef NET_REFCNT_DEBUG
         printk(KERN_DEBUG "inet6_ifa_finish_destroy\n");
@@ -536,54 +551,46 @@ void inet6_ifa_finish_destroy(struct inet6_ifaddr *ifp)
         in6_dev_put(ifp->idev);
 
         if (del_timer(&ifp->timer))
-                printk("Timer is still running, when freeing ifa=%p\n", ifp);
+                pr_notice("Timer is still running, when freeing ifa=%p\n", ifp);
 
         if (!ifp->dead) {
-                printk("Freeing alive inet6 address %p\n", ifp);
+                pr_warning("Freeing alive inet6 address %p\n", ifp);
                 return;
         }
         dst_release(&ifp->rt->u.dst);
 
-        kfree(ifp);
+        call_rcu(&ifp->rcu, inet6_ifa_finish_destroy_rcu);
 }
 
 static void
 ipv6_link_dev_addr(struct inet6_dev *idev, struct inet6_ifaddr *ifp)
 {
-        struct inet6_ifaddr *ifa, **ifap;
+        struct list_head *p;
         int ifp_scope = ipv6_addr_src_scope(&ifp->addr);
 
         /*
          * Each device address list is sorted in order of scope -
          * global before linklocal.
          */
-        for (ifap = &idev->addr_list; (ifa = *ifap) != NULL;
-             ifap = &ifa->if_next) {
+        list_for_each(p, &idev->addr_list) {
+                struct inet6_ifaddr *ifa
+                        = list_entry(p, struct inet6_ifaddr, if_list);
                 if (ifp_scope >= ipv6_addr_src_scope(&ifa->addr))
                         break;
         }
 
-        ifp->if_next = *ifap;
-        *ifap = ifp;
+        list_add_tail(&ifp->if_list, p);
 }
 
-/*
- *      Hash function taken from net_alias.c
- */
-static u8 ipv6_addr_hash(const struct in6_addr *addr)
+static u32 ipv6_addr_hash(const struct in6_addr *addr)
 {
-        __u32 word;
-
         /*
          * We perform the hash function over the last 64 bits of the address
          * This will include the IEEE address token on links that support it.
          */
-
-        word = (__force u32)(addr->s6_addr32[2] ^ addr->s6_addr32[3]);
-        word ^= (word >> 16);
-        word ^= (word >> 8);
-
-        return ((word ^ (word >> 4)) & 0x0f);
+        return jhash_2words((__force u32)addr->s6_addr32[2],
+                            (__force u32)addr->s6_addr32[3], 0)
+                & (IN6_ADDR_HSIZE - 1);
 }
 
 /* On success it returns ifp with increased reference count */
@@ -594,7 +601,7 @@ ipv6_add_addr(struct inet6_dev *idev, const struct in6_addr *addr, int pfxlen,
 {
         struct inet6_ifaddr *ifa = NULL;
         struct rt6_info *rt;
-        int hash;
+        unsigned int hash;
         int err = 0;
         int addr_type = ipv6_addr_type(addr);
 
@@ -615,7 +622,7 @@ ipv6_add_addr(struct inet6_dev *idev, const struct in6_addr *addr, int pfxlen,
                 goto out2;
         }
 
-        write_lock(&addrconf_hash_lock);
+        spin_lock(&addrconf_hash_lock);
 
         /* Ignore adding duplicate addresses on an interface */
         if (ipv6_chk_same_addr(dev_net(idev->dev), addr, idev->dev)) {
@@ -642,6 +649,7 @@ ipv6_add_addr(struct inet6_dev *idev, const struct in6_addr *addr, int pfxlen,
 
         spin_lock_init(&ifa->lock);
         init_timer(&ifa->timer);
+        INIT_HLIST_NODE(&ifa->addr_lst);
         ifa->timer.data = (unsigned long) ifa;
         ifa->scope = scope;
         ifa->prefix_len = pfxlen;
@@ -668,10 +676,8 @@ ipv6_add_addr(struct inet6_dev *idev, const struct in6_addr *addr, int pfxlen,
         /* Add to big hash table */
         hash = ipv6_addr_hash(addr);
 
-        ifa->lst_next = inet6_addr_lst[hash];
-        inet6_addr_lst[hash] = ifa;
-        in6_ifa_hold(ifa);
-        write_unlock(&addrconf_hash_lock);
+        hlist_add_head_rcu(&ifa->addr_lst, &inet6_addr_lst[hash]);
+        spin_unlock(&addrconf_hash_lock);
 
         write_lock(&idev->lock);
         /* Add to inet6_dev unicast addr list. */
@@ -679,8 +685,7 @@ ipv6_add_addr(struct inet6_dev *idev, const struct in6_addr *addr, int pfxlen,
 
 #ifdef CONFIG_IPV6_PRIVACY
         if (ifa->flags&IFA_F_TEMPORARY) {
-                ifa->tmp_next = idev->tempaddr_list;
-                idev->tempaddr_list = ifa;
+                list_add(&ifa->tmp_list, &idev->tempaddr_list);
                 in6_ifa_hold(ifa);
         }
 #endif
@@ -699,7 +704,7 @@ out2:
 
         return ifa;
 out:
-        write_unlock(&addrconf_hash_lock);
+        spin_unlock(&addrconf_hash_lock);
         goto out2;
 }
 
@@ -707,7 +712,7 @@ out:
 
 static void ipv6_del_addr(struct inet6_ifaddr *ifp)
 {
-        struct inet6_ifaddr *ifa, **ifap;
+        struct inet6_ifaddr *ifa, *ifn;
         struct inet6_dev *idev = ifp->idev;
         int hash;
         int deleted = 0, onlink = 0;
@@ -717,42 +722,27 @@ static void ipv6_del_addr(struct inet6_ifaddr *ifp)
 
         ifp->dead = 1;
 
-        write_lock_bh(&addrconf_hash_lock);
-        for (ifap = &inet6_addr_lst[hash]; (ifa=*ifap) != NULL;
-             ifap = &ifa->lst_next) {
-                if (ifa == ifp) {
-                        *ifap = ifa->lst_next;
-                        __in6_ifa_put(ifp);
-                        ifa->lst_next = NULL;
-                        break;
-                }
-        }
-        write_unlock_bh(&addrconf_hash_lock);
+        spin_lock_bh(&addrconf_hash_lock);
+        hlist_del_init_rcu(&ifp->addr_lst);
+        spin_unlock_bh(&addrconf_hash_lock);
 
         write_lock_bh(&idev->lock);
 #ifdef CONFIG_IPV6_PRIVACY
         if (ifp->flags&IFA_F_TEMPORARY) {
-                for (ifap = &idev->tempaddr_list; (ifa=*ifap) != NULL;
-                     ifap = &ifa->tmp_next) {
-                        if (ifa == ifp) {
-                                *ifap = ifa->tmp_next;
-                                if (ifp->ifpub) {
-                                        in6_ifa_put(ifp->ifpub);
-                                        ifp->ifpub = NULL;
-                                }
-                                __in6_ifa_put(ifp);
-                                ifa->tmp_next = NULL;
-                                break;
-                        }
+                list_del(&ifp->tmp_list);
+                if (ifp->ifpub) {
+                        in6_ifa_put(ifp->ifpub);
+                        ifp->ifpub = NULL;
                 }
+                __in6_ifa_put(ifp);
         }
 #endif
 
-        for (ifap = &idev->addr_list; (ifa=*ifap) != NULL;) {
+        list_for_each_entry_safe(ifa, ifn, &idev->addr_list, if_list) {
                 if (ifa == ifp) {
-                        *ifap = ifa->if_next;
+                        list_del_init(&ifp->if_list);
                         __in6_ifa_put(ifp);
-                        ifa->if_next = NULL;
+
                         if (!(ifp->flags & IFA_F_PERMANENT) || onlink > 0)
                                 break;
                         deleted = 1;
@@ -785,7 +775,6 @@ static void ipv6_del_addr(struct inet6_ifaddr *ifp)
                                 }
                         }
                 }
-                ifap = &ifa->if_next;
         }
         write_unlock_bh(&idev->lock);
 
@@ -1164,7 +1153,7 @@ int ipv6_dev_get_saddr(struct net *net, struct net_device *dst_dev,
                         continue;
 
                 read_lock_bh(&idev->lock);
-                for (score->ifa = idev->addr_list; score->ifa; score->ifa = score->ifa->if_next) {
+                list_for_each_entry(score->ifa, &idev->addr_list, if_list) {
                         int i;
 
                         /*
@@ -1242,7 +1231,6 @@ try_nextdev:
         in6_ifa_put(hiscore->ifa);
         return 0;
 }
-
 EXPORT_SYMBOL(ipv6_dev_get_saddr);
 
 int ipv6_get_lladdr(struct net_device *dev, struct in6_addr *addr,
@@ -1252,12 +1240,14 @@ int ipv6_get_lladdr(struct net_device *dev, struct in6_addr *addr,
         int err = -EADDRNOTAVAIL;
 
         rcu_read_lock();
-        if ((idev = __in6_dev_get(dev)) != NULL) {
+        idev = __in6_dev_get(dev);
+        if (idev) {
                 struct inet6_ifaddr *ifp;
 
                 read_lock_bh(&idev->lock);
-                for (ifp=idev->addr_list; ifp; ifp=ifp->if_next) {
-                        if (ifp->scope == IFA_LINK && !(ifp->flags & banned_flags)) {
+                list_for_each_entry(ifp, &idev->addr_list, if_list) {
+                        if (ifp->scope == IFA_LINK &&
+                            !(ifp->flags & banned_flags)) {
                                 ipv6_addr_copy(addr, &ifp->addr);
                                 err = 0;
                                 break;
@@ -1275,7 +1265,7 @@ static int ipv6_count_addresses(struct inet6_dev *idev)
         struct inet6_ifaddr *ifp;
 
         read_lock_bh(&idev->lock);
-        for (ifp=idev->addr_list; ifp; ifp=ifp->if_next)
+        list_for_each_entry(ifp, &idev->addr_list, if_list)
                 cnt++;
         read_unlock_bh(&idev->lock);
         return cnt;
@@ -1284,11 +1274,12 @@ static int ipv6_count_addresses(struct inet6_dev *idev)
 int ipv6_chk_addr(struct net *net, struct in6_addr *addr,
                   struct net_device *dev, int strict)
 {
-        struct inet6_ifaddr * ifp;
-        u8 hash = ipv6_addr_hash(addr);
+        struct inet6_ifaddr *ifp = NULL;
+        struct hlist_node *node;
+        unsigned int hash = ipv6_addr_hash(addr);
 
-        read_lock_bh(&addrconf_hash_lock);
-        for(ifp = inet6_addr_lst[hash]; ifp; ifp=ifp->lst_next) {
+        rcu_read_lock_bh();
+        hlist_for_each_entry_rcu(ifp, node, &inet6_addr_lst[hash], addr_lst) {
                 if (!net_eq(dev_net(ifp->idev->dev), net))
                         continue;
                 if (ipv6_addr_equal(&ifp->addr, addr) &&
@@ -1298,27 +1289,28 @@ int ipv6_chk_addr(struct net *net, struct in6_addr *addr,
                                 break;
                 }
         }
-        read_unlock_bh(&addrconf_hash_lock);
+        rcu_read_unlock_bh();
+
         return ifp != NULL;
 }
 EXPORT_SYMBOL(ipv6_chk_addr);
 
-static
-int ipv6_chk_same_addr(struct net *net, const struct in6_addr *addr,
-                       struct net_device *dev)
+static bool ipv6_chk_same_addr(struct net *net, const struct in6_addr *addr,
+                               struct net_device *dev)
 {
-        struct inet6_ifaddr * ifp;
-        u8 hash = ipv6_addr_hash(addr);
+        unsigned int hash = ipv6_addr_hash(addr);
+        struct inet6_ifaddr *ifp;
+        struct hlist_node *node;
 
-        for(ifp = inet6_addr_lst[hash]; ifp; ifp=ifp->lst_next) {
+        hlist_for_each_entry(ifp, node, &inet6_addr_lst[hash], addr_lst) {
                 if (!net_eq(dev_net(ifp->idev->dev), net))
                         continue;
                 if (ipv6_addr_equal(&ifp->addr, addr)) {
                         if (dev == NULL || ifp->idev->dev == dev)
-                                break;
+                                return true;
                 }
         }
-        return ifp != NULL;
+        return false;
 }
 
 int ipv6_chk_prefix(struct in6_addr *addr, struct net_device *dev)
@@ -1332,7 +1324,7 @@ int ipv6_chk_prefix(struct in6_addr *addr, struct net_device *dev)
         idev = __in6_dev_get(dev);
         if (idev) {
                 read_lock_bh(&idev->lock);
-                for (ifa = idev->addr_list; ifa; ifa = ifa->if_next) {
+                list_for_each_entry(ifa, &idev->addr_list, if_list) {
                         onlink = ipv6_prefix_equal(addr, &ifa->addr,
                                                    ifa->prefix_len);
                         if (onlink)
@@ -1349,24 +1341,26 @@ EXPORT_SYMBOL(ipv6_chk_prefix);
 struct inet6_ifaddr *ipv6_get_ifaddr(struct net *net, const struct in6_addr *addr,
                                      struct net_device *dev, int strict)
 {
-        struct inet6_ifaddr * ifp;
-        u8 hash = ipv6_addr_hash(addr);
+        struct inet6_ifaddr *ifp, *result = NULL;
+        unsigned int hash = ipv6_addr_hash(addr);
+        struct hlist_node *node;
 
-        read_lock_bh(&addrconf_hash_lock);
-        for(ifp = inet6_addr_lst[hash]; ifp; ifp=ifp->lst_next) {
+        rcu_read_lock_bh();
+        hlist_for_each_entry_rcu_bh(ifp, node, &inet6_addr_lst[hash], addr_lst) {
                 if (!net_eq(dev_net(ifp->idev->dev), net))
                         continue;
                 if (ipv6_addr_equal(&ifp->addr, addr)) {
                         if (dev == NULL || ifp->idev->dev == dev ||
                             !(ifp->scope&(IFA_LINK|IFA_HOST) || strict)) {
+                                result = ifp;
                                 in6_ifa_hold(ifp);
                                 break;
                         }
                 }
         }
-        read_unlock_bh(&addrconf_hash_lock);
+        rcu_read_unlock_bh();
 
-        return ifp;
+        return result;
 }
 
 /* Gets referenced address, destroys ifaddr */
@@ -1380,6 +1374,8 @@ static void addrconf_dad_stop(struct inet6_ifaddr *ifp, int dad_failed)
                 if (dad_failed)
                         ifp->flags |= IFA_F_DADFAILED;
                 spin_unlock_bh(&ifp->lock);
+                if (dad_failed)
+                        ipv6_ifa_notify(0, ifp);
                 in6_ifa_put(ifp);
 #ifdef CONFIG_IPV6_PRIVACY
         } else if (ifp->flags&IFA_F_TEMPORARY) {
@@ -1567,7 +1563,7 @@ static int ipv6_inherit_eui64(u8 *eui, struct inet6_dev *idev)
         struct inet6_ifaddr *ifp;
 
         read_lock_bh(&idev->lock);
-        for (ifp=idev->addr_list; ifp; ifp=ifp->if_next) {
+        list_for_each_entry(ifp, &idev->addr_list, if_list) {
                 if (ifp->scope == IFA_LINK && !(ifp->flags&IFA_F_TENTATIVE)) {
                         memcpy(eui, ifp->addr.s6_addr+8, 8);
                         err = 0;
@@ -1735,7 +1731,8 @@ static struct inet6_dev *addrconf_add_dev(struct net_device *dev)
 
         ASSERT_RTNL();
 
-        if ((idev = ipv6_find_idev(dev)) == NULL)
+        idev = ipv6_find_idev(dev);
+        if (!idev)
                 return NULL;
 
         /* Add default multicast route */
@@ -1968,7 +1965,7 @@ ok:
 #ifdef CONFIG_IPV6_PRIVACY
                         read_lock_bh(&in6_dev->lock);
                         /* update all temporary addresses in the list */
-                        for (ift=in6_dev->tempaddr_list; ift; ift=ift->tmp_next) {
+                        list_for_each_entry(ift, &in6_dev->tempaddr_list, tmp_list) {
                                 /*
                                  * When adjusting the lifetimes of an existing
                                  * temporary address, only lower the lifetimes.
@@ -2171,7 +2168,7 @@ static int inet6_addr_del(struct net *net, int ifindex, struct in6_addr *pfx,
                 return -ENXIO;
 
         read_lock_bh(&idev->lock);
-        for (ifp = idev->addr_list; ifp; ifp=ifp->if_next) {
+        list_for_each_entry(ifp, &idev->addr_list, if_list) {
                 if (ifp->prefix_len == plen &&
                     ipv6_addr_equal(pfx, &ifp->addr)) {
                         in6_ifa_hold(ifp);
@@ -2182,7 +2179,7 @@ static int inet6_addr_del(struct net *net, int ifindex, struct in6_addr *pfx,
                         /* If the last address is deleted administratively,
                            disable IPv6 on this interface.
                          */
-                        if (idev->addr_list == NULL)
+                        if (list_empty(&idev->addr_list))
                                 addrconf_ifdown(idev->dev, 1);
                         return 0;
                 }
@@ -2443,7 +2440,8 @@ static void addrconf_ip6_tnl_config(struct net_device *dev)
 
         ASSERT_RTNL();
 
-        if ((idev = addrconf_add_dev(dev)) == NULL) {
+        idev = addrconf_add_dev(dev);
+        if (!idev) {
                 printk(KERN_DEBUG "init ip6-ip6: add_dev failed\n");
                 return;
         }
@@ -2458,7 +2456,7 @@ static int addrconf_notify(struct notifier_block *this, unsigned long event,
         int run_pending = 0;
         int err;
 
-        switch(event) {
+        switch (event) {
         case NETDEV_REGISTER:
                 if (!idev && dev->mtu >= IPV6_MIN_MTU) {
                         idev = ipv6_add_dev(dev);
@@ -2466,6 +2464,7 @@ static int addrconf_notify(struct notifier_block *this, unsigned long event,
                                 return notifier_from_errno(-ENOMEM);
                 }
                 break;
+
         case NETDEV_UP:
         case NETDEV_CHANGE:
                 if (dev->flags & IFF_SLAVE)
@@ -2495,10 +2494,9 @@ static int addrconf_notify(struct notifier_block *this, unsigned long event,
                         }
 
                         if (idev) {
-                                if (idev->if_flags & IF_READY) {
+                                if (idev->if_flags & IF_READY)
                                         /* device is already configured. */
                                         break;
-                                }
                                 idev->if_flags |= IF_READY;
                         }
 
@@ -2510,7 +2508,7 @@ static int addrconf_notify(struct notifier_block *this, unsigned long event,
                         run_pending = 1;
                 }
 
-                switch(dev->type) {
+                switch (dev->type) {
 #if defined(CONFIG_IPV6_SIT) || defined(CONFIG_IPV6_SIT_MODULE)
                 case ARPHRD_SIT:
                         addrconf_sit_config(dev);
@@ -2527,25 +2525,30 @@ static int addrconf_notify(struct notifier_block *this, unsigned long event,
                         addrconf_dev_config(dev);
                         break;
                 }
+
                 if (idev) {
                         if (run_pending)
                                 addrconf_dad_run(idev);
 
-                        /* If the MTU changed during the interface down, when the
-                           interface up, the changed MTU must be reflected in the
-                           idev as well as routers.
+                        /*
+                         * If the MTU changed during the interface down,
+                         * when the interface up, the changed MTU must be
+                         * reflected in the idev as well as routers.
                          */
-                        if (idev->cnf.mtu6 != dev->mtu && dev->mtu >= IPV6_MIN_MTU) {
+                        if (idev->cnf.mtu6 != dev->mtu &&
+                            dev->mtu >= IPV6_MIN_MTU) {
                                 rt6_mtu_change(dev, dev->mtu);
                                 idev->cnf.mtu6 = dev->mtu;
                         }
                         idev->tstamp = jiffies;
                         inet6_ifinfo_notify(RTM_NEWLINK, idev);
-                        /* If the changed mtu during down is lower than IPV6_MIN_MTU
-                           stop IPv6 on this interface.
+
+                        /*
+                         * If the changed mtu during down is lower than
+                         * IPV6_MIN_MTU stop IPv6 on this interface.
                          */
                         if (dev->mtu < IPV6_MIN_MTU)
-                                addrconf_ifdown(dev, event != NETDEV_DOWN);
+                                addrconf_ifdown(dev, 1);
                 }
                 break;
 
@@ -2562,7 +2565,10 @@ static int addrconf_notify(struct notifier_block *this, unsigned long event,
                                 break;
                 }
 
-                /* MTU falled under IPV6_MIN_MTU. Stop IPv6 on this interface. */
+                /*
+                 * MTU falled under IPV6_MIN_MTU.
+                 * Stop IPv6 on this interface.
+                 */
 
         case NETDEV_DOWN:
         case NETDEV_UNREGISTER:
@@ -2582,9 +2588,10 @@ static int addrconf_notify(struct notifier_block *this, unsigned long event,
                                 return notifier_from_errno(err);
                 }
                 break;
-        case NETDEV_BONDING_OLDTYPE:
-        case NETDEV_BONDING_NEWTYPE:
-                addrconf_bonding_change(dev, event);
+
+        case NETDEV_PRE_TYPE_CHANGE:
+        case NETDEV_POST_TYPE_CHANGE:
+                addrconf_type_change(dev, event);
                 break;
         }
 
@@ -2596,28 +2603,27 @@ static int addrconf_notify(struct notifier_block *this, unsigned long event,
  */
 static struct notifier_block ipv6_dev_notf = {
         .notifier_call = addrconf_notify,
-        .priority = 0
 };
 
-static void addrconf_bonding_change(struct net_device *dev, unsigned long event)
+static void addrconf_type_change(struct net_device *dev, unsigned long event)
 {
         struct inet6_dev *idev;
         ASSERT_RTNL();
 
         idev = __in6_dev_get(dev);
 
-        if (event == NETDEV_BONDING_NEWTYPE)
+        if (event == NETDEV_POST_TYPE_CHANGE)
                 ipv6_mc_remap(idev);
-        else if (event == NETDEV_BONDING_OLDTYPE)
+        else if (event == NETDEV_PRE_TYPE_CHANGE)
                 ipv6_mc_unmap(idev);
 }
 
 static int addrconf_ifdown(struct net_device *dev, int how)
 {
-        struct inet6_dev *idev;
-        struct inet6_ifaddr *ifa, *keep_list, **bifa;
         struct net *net = dev_net(dev);
-        int i;
+        struct inet6_dev *idev;
+        struct inet6_ifaddr *ifa;
+        LIST_HEAD(keep_list);
 
         ASSERT_RTNL();
 
@@ -2628,8 +2634,9 @@ static int addrconf_ifdown(struct net_device *dev, int how)
         if (idev == NULL)
                 return -ENODEV;
 
-        /* Step 1: remove reference to ipv6 device from parent device.
-                   Do not dev_put!
+        /*
+         * Step 1: remove reference to ipv6 device from parent device.
+         *         Do not dev_put!
          */
         if (how) {
                 idev->dead = 1;
@@ -2642,40 +2649,21 @@ static int addrconf_ifdown(struct net_device *dev, int how)
 
         }
 
-        /* Step 2: clear hash table */
-        for (i=0; i<IN6_ADDR_HSIZE; i++) {
-                bifa = &inet6_addr_lst[i];
-
-                write_lock_bh(&addrconf_hash_lock);
-                while ((ifa = *bifa) != NULL) {
-                        if (ifa->idev == idev &&
-                            (how || !(ifa->flags&IFA_F_PERMANENT) ||
-                             ipv6_addr_type(&ifa->addr) & IPV6_ADDR_LINKLOCAL)) {
-                                *bifa = ifa->lst_next;
-                                ifa->lst_next = NULL;
-                                __in6_ifa_put(ifa);
-                                continue;
-                        }
-                        bifa = &ifa->lst_next;
-                }
-                write_unlock_bh(&addrconf_hash_lock);
-        }
-
         write_lock_bh(&idev->lock);
 
-        /* Step 3: clear flags for stateless addrconf */
+        /* Step 2: clear flags for stateless addrconf */
         if (!how)
                 idev->if_flags &= ~(IF_RS_SENT|IF_RA_RCVD|IF_READY);
 
-        /* Step 4: clear address list */
 #ifdef CONFIG_IPV6_PRIVACY
         if (how && del_timer(&idev->regen_timer))
                 in6_dev_put(idev);
 
-        /* clear tempaddr list */
-        while ((ifa = idev->tempaddr_list) != NULL) {
-                idev->tempaddr_list = ifa->tmp_next;
-                ifa->tmp_next = NULL;
+        /* Step 3: clear tempaddr list */
+        while (!list_empty(&idev->tempaddr_list)) {
+                ifa = list_first_entry(&idev->tempaddr_list,
+                                       struct inet6_ifaddr, tmp_list);
+                list_del(&ifa->tmp_list);
                 ifa->dead = 1;
                 write_unlock_bh(&idev->lock);
                 spin_lock_bh(&ifa->lock);
@@ -2689,23 +2677,18 @@ static int addrconf_ifdown(struct net_device *dev, int how)
                 write_lock_bh(&idev->lock);
         }
 #endif
-        keep_list = NULL;
-        bifa = &keep_list;
-        while ((ifa = idev->addr_list) != NULL) {
-                idev->addr_list = ifa->if_next;
-                ifa->if_next = NULL;
 
+        while (!list_empty(&idev->addr_list)) {
+                ifa = list_first_entry(&idev->addr_list,
+                                       struct inet6_ifaddr, if_list);
                 addrconf_del_timer(ifa);
 
                 /* If just doing link down, and address is permanent
                    and not link-local, then retain it. */
-                if (how == 0 &&
+                if (!how &&
                     (ifa->flags&IFA_F_PERMANENT) &&
                     !(ipv6_addr_type(&ifa->addr) & IPV6_ADDR_LINKLOCAL)) {
-
-                        /* Move to holding list */
-                        *bifa = ifa;
-                        bifa = &ifa->if_next;
+                        list_move_tail(&ifa->if_list, &keep_list);
 
                         /* If not doing DAD on this address, just keep it. */
                         if ((dev->flags&(IFF_NOARP|IFF_LOOPBACK)) ||
@@ -2720,24 +2703,32 @@ static int addrconf_ifdown(struct net_device *dev, int how)
                         /* Flag it for later restoration when link comes up */
                         ifa->flags |= IFA_F_TENTATIVE;
                         in6_ifa_hold(ifa);
+                        write_unlock_bh(&idev->lock);
                 } else {
+                        list_del(&ifa->if_list);
                         ifa->dead = 1;
+                        write_unlock_bh(&idev->lock);
+
+                        /* clear hash table */
+                        spin_lock_bh(&addrconf_hash_lock);
+                        hlist_del_init_rcu(&ifa->addr_lst);
+                        spin_unlock_bh(&addrconf_hash_lock);
                 }
-                write_unlock_bh(&idev->lock);
 
                 __ipv6_ifa_notify(RTM_DELADDR, ifa);
-                atomic_notifier_call_chain(&inet6addr_chain, NETDEV_DOWN, ifa);
+                if (ifa->dead)
+                        atomic_notifier_call_chain(&inet6addr_chain,
+                                                   NETDEV_DOWN, ifa);
                 in6_ifa_put(ifa);
 
                 write_lock_bh(&idev->lock);
         }
 
-        idev->addr_list = keep_list;
+        list_splice(&keep_list, &idev->addr_list);
 
         write_unlock_bh(&idev->lock);
 
         /* Step 5: Discard multicast list */
-
         if (how)
                 ipv6_mc_destroy_dev(idev);
         else
@@ -2745,8 +2736,7 @@ static int addrconf_ifdown(struct net_device *dev, int how)
 
         idev->tstamp = jiffies;
 
-        /* Shot the device (if unregistered) */
-
+        /* Last: Shot the device (if unregistered) */
         if (how) {
                 addrconf_sysctl_unregister(idev);
                 neigh_parms_release(&nd_tbl, idev->nd_parms);
@@ -2857,7 +2847,7 @@ static void addrconf_dad_start(struct inet6_ifaddr *ifp, u32 flags)
          * Optimistic nodes can start receiving
          * Frames right away
          */
-        if(ifp->flags & IFA_F_OPTIMISTIC)
+        if (ifp->flags & IFA_F_OPTIMISTIC)
                 ip6_ins_rt(ifp->rt);
 
         addrconf_dad_kick(ifp);
@@ -2907,7 +2897,7 @@ out:
 
 static void addrconf_dad_completed(struct inet6_ifaddr *ifp)
 {
-        struct net_device *     dev = ifp->idev->dev;
+        struct net_device *dev = ifp->idev->dev;
 
         /*
          *      Configure the address for reception. Now it is valid.
@@ -2938,11 +2928,12 @@ static void addrconf_dad_completed(struct inet6_ifaddr *ifp)
         }
 }
 
-static void addrconf_dad_run(struct inet6_dev *idev) {
+static void addrconf_dad_run(struct inet6_dev *idev)
+{
         struct inet6_ifaddr *ifp;
 
         read_lock_bh(&idev->lock);
-        for (ifp = idev->addr_list; ifp; ifp = ifp->if_next) {
+        list_for_each_entry(ifp, &idev->addr_list, if_list) {
                 spin_lock(&ifp->lock);
                 if (!(ifp->flags & IFA_F_TENTATIVE)) {
                         spin_unlock(&ifp->lock);
@@ -2967,36 +2958,35 @@ static struct inet6_ifaddr *if6_get_first(struct seq_file *seq)
         struct net *net = seq_file_net(seq);
 
         for (state->bucket = 0; state->bucket < IN6_ADDR_HSIZE; ++state->bucket) {
-                ifa = inet6_addr_lst[state->bucket];
-
-                while (ifa && !net_eq(dev_net(ifa->idev->dev), net))
-                        ifa = ifa->lst_next;
-                if (ifa)
-                        break;
+                struct hlist_node *n;
+                hlist_for_each_entry_rcu_bh(ifa, n, &inet6_addr_lst[state->bucket],
+                                         addr_lst)
+                        if (net_eq(dev_net(ifa->idev->dev), net))
+                                return ifa;
         }
-        return ifa;
+        return NULL;
 }
 
-static struct inet6_ifaddr *if6_get_next(struct seq_file *seq, struct inet6_ifaddr *ifa)
+static struct inet6_ifaddr *if6_get_next(struct seq_file *seq,
+                                         struct inet6_ifaddr *ifa)
 {
         struct if6_iter_state *state = seq->private;
         struct net *net = seq_file_net(seq);
+        struct hlist_node *n = &ifa->addr_lst;
 
-        ifa = ifa->lst_next;
-try_again:
-        if (ifa) {
-                if (!net_eq(dev_net(ifa->idev->dev), net)) {
-                        ifa = ifa->lst_next;
-                        goto try_again;
-                }
-        }
+        hlist_for_each_entry_continue_rcu_bh(ifa, n, addr_lst)
+                if (net_eq(dev_net(ifa->idev->dev), net))
+                        return ifa;
 
-        if (!ifa && ++state->bucket < IN6_ADDR_HSIZE) {
-                ifa = inet6_addr_lst[state->bucket];
-                goto try_again;
+        while (++state->bucket < IN6_ADDR_HSIZE) {
+                hlist_for_each_entry_rcu_bh(ifa, n,
+                                     &inet6_addr_lst[state->bucket], addr_lst) {
+                        if (net_eq(dev_net(ifa->idev->dev), net))
+                                return ifa;
+                }
         }
 
-        return ifa;
+        return NULL;
 }
 
 static struct inet6_ifaddr *if6_get_idx(struct seq_file *seq, loff_t pos)
@@ -3004,15 +2994,15 @@ static struct inet6_ifaddr *if6_get_idx(struct seq_file *seq, loff_t pos)
         struct inet6_ifaddr *ifa = if6_get_first(seq);
 
         if (ifa)
-                while(pos && (ifa = if6_get_next(seq, ifa)) != NULL)
+                while (pos && (ifa = if6_get_next(seq, ifa)) != NULL)
                         --pos;
         return pos ? NULL : ifa;
 }
 
 static void *if6_seq_start(struct seq_file *seq, loff_t *pos)
-        __acquires(addrconf_hash_lock)
+        __acquires(rcu_bh)
 {
-        read_lock_bh(&addrconf_hash_lock);
+        rcu_read_lock_bh();
         return if6_get_idx(seq, *pos);
 }
 
@@ -3026,9 +3016,9 @@ static void *if6_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 }
 
 static void if6_seq_stop(struct seq_file *seq, void *v)
-        __releases(addrconf_hash_lock)
+        __releases(rcu_bh)
 {
-        read_unlock_bh(&addrconf_hash_lock);
+        rcu_read_unlock_bh();
 }
 
 static int if6_seq_show(struct seq_file *seq, void *v)
@@ -3098,10 +3088,12 @@ void if6_proc_exit(void)
 int ipv6_chk_home_addr(struct net *net, struct in6_addr *addr)
 {
         int ret = 0;
-        struct inet6_ifaddr * ifp;
-        u8 hash = ipv6_addr_hash(addr);
-        read_lock_bh(&addrconf_hash_lock);
-        for (ifp = inet6_addr_lst[hash]; ifp; ifp = ifp->lst_next) {
+        struct inet6_ifaddr *ifp = NULL;
+        struct hlist_node *n;
+        unsigned int hash = ipv6_addr_hash(addr);
+
+        rcu_read_lock_bh();
+        hlist_for_each_entry_rcu_bh(ifp, n, &inet6_addr_lst[hash], addr_lst) {
                 if (!net_eq(dev_net(ifp->idev->dev), net))
                         continue;
                 if (ipv6_addr_equal(&ifp->addr, addr) &&
@@ -3110,7 +3102,7 @@ int ipv6_chk_home_addr(struct net *net, struct in6_addr *addr)
                         break;
                 }
         }
-        read_unlock_bh(&addrconf_hash_lock);
+        rcu_read_unlock_bh();
         return ret;
 }
 #endif
@@ -3121,43 +3113,35 @@ int ipv6_chk_home_addr(struct net *net, struct in6_addr *addr)
 
 static void addrconf_verify(unsigned long foo)
 {
+        unsigned long now, next, next_sec, next_sched;
         struct inet6_ifaddr *ifp;
-        unsigned long now, next;
+        struct hlist_node *node;
         int i;
 
-        spin_lock_bh(&addrconf_verify_lock);
+        rcu_read_lock_bh();
+        spin_lock(&addrconf_verify_lock);
         now = jiffies;
-        next = now + ADDR_CHECK_FREQUENCY;
+        next = round_jiffies_up(now + ADDR_CHECK_FREQUENCY);
 
         del_timer(&addr_chk_timer);
 
-        for (i=0; i < IN6_ADDR_HSIZE; i++) {
-
+        for (i = 0; i < IN6_ADDR_HSIZE; i++) {
 restart:
-                read_lock(&addrconf_hash_lock);
-                for (ifp=inet6_addr_lst[i]; ifp; ifp=ifp->lst_next) {
+                hlist_for_each_entry_rcu_bh(ifp, node,
+                                         &inet6_addr_lst[i], addr_lst) {
                         unsigned long age;
-#ifdef CONFIG_IPV6_PRIVACY
-                        unsigned long regen_advance;
-#endif
 
                         if (ifp->flags & IFA_F_PERMANENT)
                                 continue;
 
                         spin_lock(&ifp->lock);
-                        age = (now - ifp->tstamp) / HZ;
-
-#ifdef CONFIG_IPV6_PRIVACY
-                        regen_advance = ifp->idev->cnf.regen_max_retry *
-                                        ifp->idev->cnf.dad_transmits *
-                                        ifp->idev->nd_parms->retrans_time / HZ;
-#endif
+                        /* We try to batch several events at once. */
+                        age = (now - ifp->tstamp + ADDRCONF_TIMER_FUZZ_MINUS) / HZ;
 
                         if (ifp->valid_lft != INFINITY_LIFE_TIME &&
                             age >= ifp->valid_lft) {
                                 spin_unlock(&ifp->lock);
                                 in6_ifa_hold(ifp);
-                                read_unlock(&addrconf_hash_lock);
                                 ipv6_del_addr(ifp);
                                 goto restart;
                         } else if (ifp->prefered_lft == INFINITY_LIFE_TIME) {
@@ -3179,7 +3163,6 @@ restart:
 
                                 if (deprecate) {
                                         in6_ifa_hold(ifp);
-                                        read_unlock(&addrconf_hash_lock);
 
                                         ipv6_ifa_notify(0, ifp);
                                         in6_ifa_put(ifp);
@@ -3188,6 +3171,10 @@ restart:
 #ifdef CONFIG_IPV6_PRIVACY
                         } else if ((ifp->flags&IFA_F_TEMPORARY) &&
                                    !(ifp->flags&IFA_F_TENTATIVE)) {
+                                unsigned long regen_advance = ifp->idev->cnf.regen_max_retry *
+                                        ifp->idev->cnf.dad_transmits *
+                                        ifp->idev->nd_parms->retrans_time / HZ;
+
                                 if (age >= ifp->prefered_lft - regen_advance) {
                                         struct inet6_ifaddr *ifpub = ifp->ifpub;
                                         if (time_before(ifp->tstamp + ifp->prefered_lft * HZ, next))
@@ -3197,7 +3184,7 @@ restart:
                                                 in6_ifa_hold(ifp);
                                                 in6_ifa_hold(ifpub);
                                                 spin_unlock(&ifp->lock);
-                                                read_unlock(&addrconf_hash_lock);
+
                                                 spin_lock(&ifpub->lock);
                                                 ifpub->regen_count = 0;
                                                 spin_unlock(&ifpub->lock);
@@ -3217,12 +3204,26 @@ restart:
                                 spin_unlock(&ifp->lock);
                         }
                 }
-                read_unlock(&addrconf_hash_lock);
         }
 
-        addr_chk_timer.expires = time_before(next, jiffies + HZ) ? jiffies + HZ : next;
+        next_sec = round_jiffies_up(next);
+        next_sched = next;
+
+        /* If rounded timeout is accurate enough, accept it. */
+        if (time_before(next_sec, next + ADDRCONF_TIMER_FUZZ))
+                next_sched = next_sec;
+
+        /* And minimum interval is ADDRCONF_TIMER_FUZZ_MAX. */
+        if (time_before(next_sched, jiffies + ADDRCONF_TIMER_FUZZ_MAX))
+                next_sched = jiffies + ADDRCONF_TIMER_FUZZ_MAX;
+
+        ADBG((KERN_DEBUG "now = %lu, schedule = %lu, rounded schedule = %lu => %lu\n",
+              now, next, next_sec, next_sched));
+
+        addr_chk_timer.expires = next_sched;
         add_timer(&addr_chk_timer);
-        spin_unlock_bh(&addrconf_verify_lock);
+        spin_unlock(&addrconf_verify_lock);
+        rcu_read_unlock_bh();
 }
 
 static struct in6_addr *extract_addr(struct nlattr *addr, struct nlattr *local)
@@ -3512,8 +3513,7 @@ static int inet6_fill_ifacaddr(struct sk_buff *skb, struct ifacaddr6 *ifaca,
         return nlmsg_end(skb, nlh);
 }
 
-enum addr_type_t
-{
+enum addr_type_t {
         UNICAST_ADDR,
         MULTICAST_ADDR,
         ANYCAST_ADDR,
@@ -3524,7 +3524,6 @@ static int in6_dump_addrs(struct inet6_dev *idev, struct sk_buff *skb,
                           struct netlink_callback *cb, enum addr_type_t type,
                           int s_ip_idx, int *p_ip_idx)
 {
-        struct inet6_ifaddr *ifa;
         struct ifmcaddr6 *ifmca;
         struct ifacaddr6 *ifaca;
         int err = 1;
@@ -3532,11 +3531,12 @@ static int in6_dump_addrs(struct inet6_dev *idev, struct sk_buff *skb,
 
         read_lock_bh(&idev->lock);
         switch (type) {
-        case UNICAST_ADDR:
+        case UNICAST_ADDR: {
+                struct inet6_ifaddr *ifa;
+
                 /* unicast address incl. temp addr */
-                for (ifa = idev->addr_list; ifa;
-                     ifa = ifa->if_next, ip_idx++) {
-                        if (ip_idx < s_ip_idx)
+                list_for_each_entry(ifa, &idev->addr_list, if_list) {
+                        if (++ip_idx < s_ip_idx)
                                 continue;
                         err = inet6_fill_ifaddr(skb, ifa,
                                                 NETLINK_CB(cb->skb).pid,
@@ -3547,6 +3547,7 @@ static int in6_dump_addrs(struct inet6_dev *idev, struct sk_buff *skb,
                                 break;
                 }
                 break;
+        }
         case MULTICAST_ADDR:
                 /* multicast address */
                 for (ifmca = idev->mc_list; ifmca;
@@ -3608,10 +3609,11 @@ static int inet6_dump_addr(struct sk_buff *skb, struct netlink_callback *cb,
                 hlist_for_each_entry_rcu(dev, node, head, index_hlist) {
                         if (idx < s_idx)
                                 goto cont;
-                        if (idx > s_idx)
+                        if (h > s_h || idx > s_idx)
                                 s_ip_idx = 0;
                         ip_idx = 0;
-                        if ((idev = __in6_dev_get(dev)) == NULL)
+                        idev = __in6_dev_get(dev);
+                        if (!idev)
                                 goto cont;
 
                         if (in6_dump_addrs(idev, skb, cb, type,
@@ -3678,12 +3680,14 @@ static int inet6_rtm_getaddr(struct sk_buff *in_skb, struct nlmsghdr* nlh,
         if (ifm->ifa_index)
                 dev = __dev_get_by_index(net, ifm->ifa_index);
 
-        if ((ifa = ipv6_get_ifaddr(net, addr, dev, 1)) == NULL) {
+        ifa = ipv6_get_ifaddr(net, addr, dev, 1);
+        if (!ifa) {
                 err = -EADDRNOTAVAIL;
                 goto errout;
         }
 
-        if ((skb = nlmsg_new(inet6_ifaddr_msgsize(), GFP_KERNEL)) == NULL) {
+        skb = nlmsg_new(inet6_ifaddr_msgsize(), GFP_KERNEL);
+        if (!skb) {
                 err = -ENOBUFS;
                 goto errout_ifa;
         }
@@ -3808,7 +3812,7 @@ static inline void __snmp6_fill_stats(u64 *stats, void __percpu **mib,
 static void snmp6_fill_stats(u64 *stats, struct inet6_dev *idev, int attrtype,
                              int bytes)
 {
-        switch(attrtype) {
+        switch (attrtype) {
         case IFLA_INET6_STATS:
                 __snmp6_fill_stats(stats, (void __percpu **)idev->stats.ipv6, IPSTATS_MIB_MAX, bytes);
                 break;
@@ -4044,7 +4048,8 @@ static void __ipv6_ifa_notify(int event, struct inet6_ifaddr *ifp)
                         addrconf_leave_anycast(ifp);
                 addrconf_leave_solict(ifp->idev, &ifp->addr);
                 dst_hold(&ifp->rt->u.dst);
-                if (ip6_del_rt(ifp->rt))
+
+                if (ifp->dead && ip6_del_rt(ifp->rt))
                         dst_free(&ifp->rt->u.dst);
                 break;
         }
@@ -4160,211 +4165,211 @@ static struct addrconf_sysctl_table
         .sysctl_header = NULL,
         .addrconf_vars = {
                 {
-                        .procname       =       "forwarding",
-                        .data           =       &ipv6_devconf.forwarding,
-                        .maxlen         =       sizeof(int),
-                        .mode           =       0644,
-                        .proc_handler   =       addrconf_sysctl_forward,
+                        .procname       = "forwarding",
+                        .data           = &ipv6_devconf.forwarding,
+                        .maxlen         = sizeof(int),
+                        .mode           = 0644,
+                        .proc_handler   = addrconf_sysctl_forward,
                 },
                 {
-                        .procname       =       "hop_limit",
-                        .data           =       &ipv6_devconf.hop_limit,
-                        .maxlen         =       sizeof(int),
-                        .mode           =       0644,
-                        .proc_handler   =       proc_dointvec,
+                        .procname       = "hop_limit",
+                        .data           = &ipv6_devconf.hop_limit,
+                        .maxlen         = sizeof(int),
+                        .mode           = 0644,
+                        .proc_handler   = proc_dointvec,
                 },
                 {
-                        .procname       =       "mtu",
-                        .data           =       &ipv6_devconf.mtu6,
-                        .maxlen         =       sizeof(int),
-                        .mode           =       0644,
-                        .proc_handler   =       proc_dointvec,
+                        .procname       = "mtu",
+                        .data           = &ipv6_devconf.mtu6,
+                        .maxlen         = sizeof(int),
+                        .mode           = 0644,
+                        .proc_handler   = proc_dointvec,
                 },
                 {
-                        .procname       =       "accept_ra",
-                        .data           =       &ipv6_devconf.accept_ra,
-                        .maxlen         =       sizeof(int),
-                        .mode           =       0644,
-                        .proc_handler   =       proc_dointvec,
+                        .procname       = "accept_ra",
+                        .data           = &ipv6_devconf.accept_ra,
+                        .maxlen         = sizeof(int),
+                        .mode           = 0644,
+                        .proc_handler   = proc_dointvec,
                 },
                 {
-                        .procname       =       "accept_redirects",
-                        .data           =       &ipv6_devconf.accept_redirects,
-                        .maxlen         =       sizeof(int),
-                        .mode           =       0644,
-                        .proc_handler   =       proc_dointvec,
+                        .procname       = "accept_redirects",
+                        .data           = &ipv6_devconf.accept_redirects,
+                        .maxlen         = sizeof(int),
+                        .mode           = 0644,
+                        .proc_handler   = proc_dointvec,
                 },
                 {
-                        .procname       =       "autoconf",
-                        .data           =       &ipv6_devconf.autoconf,
-                        .maxlen         =       sizeof(int),
-                        .mode           =       0644,
-                        .proc_handler   =       proc_dointvec,
+                        .procname       = "autoconf",
+                        .data           = &ipv6_devconf.autoconf,
+                        .maxlen         = sizeof(int),
+                        .mode           = 0644,
+                        .proc_handler   = proc_dointvec,
                 },
                 {
-                        .procname       =       "dad_transmits",
-                        .data           =       &ipv6_devconf.dad_transmits,
-                        .maxlen         =       sizeof(int),
-                        .mode           =       0644,
-                        .proc_handler   =       proc_dointvec,
+                        .procname       = "dad_transmits",
+                        .data           = &ipv6_devconf.dad_transmits,
+                        .maxlen         = sizeof(int),
+                        .mode           = 0644,
+                        .proc_handler   = proc_dointvec,
                 },
                 {
-                        .procname       =       "router_solicitations",
-                        .data           =       &ipv6_devconf.rtr_solicits,
-                        .maxlen         =       sizeof(int),
-                        .mode           =       0644,
-                        .proc_handler   =       proc_dointvec,
+                        .procname       = "router_solicitations",
+                        .data           = &ipv6_devconf.rtr_solicits,
+                        .maxlen         = sizeof(int),
+                        .mode           = 0644,
+                        .proc_handler   = proc_dointvec,
                 },
                 {
-                        .procname       =       "router_solicitation_interval",
-                        .data           =       &ipv6_devconf.rtr_solicit_interval,
-                        .maxlen         =       sizeof(int),
-                        .mode           =       0644,
-                        .proc_handler   =       proc_dointvec_jiffies,
+                        .procname       = "router_solicitation_interval",
+                        .data           = &ipv6_devconf.rtr_solicit_interval,
+                        .maxlen         = sizeof(int),
+                        .mode           = 0644,
+                        .proc_handler   = proc_dointvec_jiffies,
                 },
                 {
-                        .procname       =       "router_solicitation_delay",
-                        .data           =       &ipv6_devconf.rtr_solicit_delay,
-                        .maxlen         =       sizeof(int),
-                        .mode           =       0644,
-                        .proc_handler   =       proc_dointvec_jiffies,
+                        .procname       = "router_solicitation_delay",
+                        .data           = &ipv6_devconf.rtr_solicit_delay,
+                        .maxlen         = sizeof(int),
+                        .mode           = 0644,
+                        .proc_handler   = proc_dointvec_jiffies,
                 },
                 {
-                        .procname       =       "force_mld_version",
-                        .data           =       &ipv6_devconf.force_mld_version,
-                        .maxlen         =       sizeof(int),
-                        .mode           =       0644,
-                        .proc_handler   =       proc_dointvec,
+                        .procname       = "force_mld_version",
+                        .data           = &ipv6_devconf.force_mld_version,
+                        .maxlen         = sizeof(int),
+                        .mode           = 0644,
+                        .proc_handler   = proc_dointvec,
                 },
 #ifdef CONFIG_IPV6_PRIVACY
                 {
-                        .procname       =       "use_tempaddr",
-                        .data           =       &ipv6_devconf.use_tempaddr,
-                        .maxlen         =       sizeof(int),
-                        .mode           =       0644,
-                        .proc_handler   =       proc_dointvec,
+                        .procname       = "use_tempaddr",
+                        .data           = &ipv6_devconf.use_tempaddr,
+                        .maxlen         = sizeof(int),
+                        .mode           = 0644,
+                        .proc_handler   = proc_dointvec,
                 },
                 {
-                        .procname       =       "temp_valid_lft",
-                        .data           =       &ipv6_devconf.temp_valid_lft,
-                        .maxlen         =       sizeof(int),
-                        .mode           =       0644,
-                        .proc_handler   =       proc_dointvec,
+                        .procname       = "temp_valid_lft",
+                        .data           = &ipv6_devconf.temp_valid_lft,
+                        .maxlen         = sizeof(int),
+                        .mode           = 0644,
+                        .proc_handler   = proc_dointvec,
                 },
                 {
-                        .procname       =       "temp_prefered_lft",
-                        .data           =       &ipv6_devconf.temp_prefered_lft,
-                        .maxlen         =       sizeof(int),
-                        .mode           =       0644,
-                        .proc_handler   =       proc_dointvec,
+                        .procname       = "temp_prefered_lft",
+                        .data           = &ipv6_devconf.temp_prefered_lft,
+                        .maxlen         = sizeof(int),
+                        .mode           = 0644,
+                        .proc_handler   = proc_dointvec,
                 },
                 {
-                        .procname       =       "regen_max_retry",
-                        .data           =       &ipv6_devconf.regen_max_retry,
-                        .maxlen         =       sizeof(int),
-                        .mode           =       0644,
-                        .proc_handler   =       proc_dointvec,
+                        .procname       = "regen_max_retry",
+                        .data           = &ipv6_devconf.regen_max_retry,
+                        .maxlen         = sizeof(int),
+                        .mode           = 0644,
+                        .proc_handler   = proc_dointvec,
                 },
                 {
-                        .procname       =       "max_desync_factor",
-                        .data           =       &ipv6_devconf.max_desync_factor,
-                        .maxlen         =       sizeof(int),
-                        .mode           =       0644,
-                        .proc_handler   =       proc_dointvec,
+                        .procname       = "max_desync_factor",
+                        .data           = &ipv6_devconf.max_desync_factor,
+                        .maxlen         = sizeof(int),
+                        .mode           = 0644,
+                        .proc_handler   = proc_dointvec,
                 },
 #endif
                 {
-                        .procname       =       "max_addresses",
-                        .data           =       &ipv6_devconf.max_addresses,
-                        .maxlen         =       sizeof(int),
-                        .mode           =       0644,
-                        .proc_handler   =       proc_dointvec,
+                        .procname       = "max_addresses",
+                        .data           = &ipv6_devconf.max_addresses,
+                        .maxlen         = sizeof(int),
+                        .mode           = 0644,
+                        .proc_handler   = proc_dointvec,
                 },
                 {
-                        .procname       =       "accept_ra_defrtr",
-                        .data           =       &ipv6_devconf.accept_ra_defrtr,
-                        .maxlen         =       sizeof(int),
-                        .mode           =       0644,
-                        .proc_handler   =       proc_dointvec,
+                        .procname       = "accept_ra_defrtr",
+                        .data           = &ipv6_devconf.accept_ra_defrtr,
+                        .maxlen         = sizeof(int),
+                        .mode           = 0644,
+                        .proc_handler   = proc_dointvec,
                 },
                 {
-                        .procname       =       "accept_ra_pinfo",
-                        .data           =       &ipv6_devconf.accept_ra_pinfo,
-                        .maxlen         =       sizeof(int),
-                        .mode           =       0644,
-                        .proc_handler   =       proc_dointvec,
+                        .procname       = "accept_ra_pinfo",
+                        .data           = &ipv6_devconf.accept_ra_pinfo,
+                        .maxlen         = sizeof(int),
+                        .mode           = 0644,
+                        .proc_handler   = proc_dointvec,
                 },
 #ifdef CONFIG_IPV6_ROUTER_PREF
                 {
-                        .procname       =       "accept_ra_rtr_pref",
-                        .data           =       &ipv6_devconf.accept_ra_rtr_pref,
-                        .maxlen         =       sizeof(int),
-                        .mode           =       0644,
-                        .proc_handler   =       proc_dointvec,
+                        .procname       = "accept_ra_rtr_pref",
+                        .data           = &ipv6_devconf.accept_ra_rtr_pref,
+                        .maxlen         = sizeof(int),
+                        .mode           = 0644,
+                        .proc_handler   = proc_dointvec,
                 },
                 {
-                        .procname       =       "router_probe_interval",
-                        .data           =       &ipv6_devconf.rtr_probe_interval,
-                        .maxlen         =       sizeof(int),
-                        .mode           =       0644,
-                        .proc_handler   =       proc_dointvec_jiffies,
+                        .procname       = "router_probe_interval",
+                        .data           = &ipv6_devconf.rtr_probe_interval,
+                        .maxlen         = sizeof(int),
+                        .mode           = 0644,
+                        .proc_handler   = proc_dointvec_jiffies,
                 },
 #ifdef CONFIG_IPV6_ROUTE_INFO
                 {
-                        .procname       =       "accept_ra_rt_info_max_plen",
-                        .data           =       &ipv6_devconf.accept_ra_rt_info_max_plen,
-                        .maxlen         =       sizeof(int),
-                        .mode           =       0644,
-                        .proc_handler   =       proc_dointvec,
+                        .procname       = "accept_ra_rt_info_max_plen",
+                        .data           = &ipv6_devconf.accept_ra_rt_info_max_plen,
+                        .maxlen         = sizeof(int),
+                        .mode           = 0644,
+                        .proc_handler   = proc_dointvec,
                 },
 #endif
 #endif
                 {
-                        .procname       =       "proxy_ndp",
-                        .data           =       &ipv6_devconf.proxy_ndp,
-                        .maxlen         =       sizeof(int),
-                        .mode           =       0644,
-                        .proc_handler   =       proc_dointvec,
+                        .procname       = "proxy_ndp",
+                        .data           = &ipv6_devconf.proxy_ndp,
+                        .maxlen         = sizeof(int),
+                        .mode           = 0644,
+                        .proc_handler   = proc_dointvec,
                 },
                 {
-                        .procname       =       "accept_source_route",
-                        .data           =       &ipv6_devconf.accept_source_route,
-                        .maxlen         =       sizeof(int),
-                        .mode           =       0644,
-                        .proc_handler   =       proc_dointvec,
+                        .procname       = "accept_source_route",
+                        .data           = &ipv6_devconf.accept_source_route,
+                        .maxlen         = sizeof(int),
+                        .mode           = 0644,
+                        .proc_handler   = proc_dointvec,
                 },
 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
                 {
-                        .procname       =       "optimistic_dad",
-                        .data           =       &ipv6_devconf.optimistic_dad,
-                        .maxlen         =       sizeof(int),
-                        .mode           =       0644,
-                        .proc_handler   =       proc_dointvec,
+                        .procname       = "optimistic_dad",
+                        .data           = &ipv6_devconf.optimistic_dad,
+                        .maxlen         = sizeof(int),
+                        .mode           = 0644,
+                        .proc_handler   = proc_dointvec,
 
                 },
 #endif
 #ifdef CONFIG_IPV6_MROUTE
                 {
-                        .procname       =       "mc_forwarding",
-                        .data           =       &ipv6_devconf.mc_forwarding,
-                        .maxlen         =       sizeof(int),
-                        .mode           =       0444,
-                        .proc_handler   =       proc_dointvec,
+                        .procname       = "mc_forwarding",
+                        .data           = &ipv6_devconf.mc_forwarding,
+                        .maxlen         = sizeof(int),
+                        .mode           = 0444,
+                        .proc_handler   = proc_dointvec,
                 },
 #endif
                 {
-                        .procname       =       "disable_ipv6",
-                        .data           =       &ipv6_devconf.disable_ipv6,
-                        .maxlen         =       sizeof(int),
-                        .mode           =       0644,
-                        .proc_handler   =       addrconf_sysctl_disable,
+                        .procname       = "disable_ipv6",
+                        .data           = &ipv6_devconf.disable_ipv6,
+                        .maxlen         = sizeof(int),
+                        .mode           = 0644,
+                        .proc_handler   = addrconf_sysctl_disable,
                 },
                 {
-                        .procname       =       "accept_dad",
-                        .data           =       &ipv6_devconf.accept_dad,
-                        .maxlen         =       sizeof(int),
-                        .mode           =       0644,
-                        .proc_handler   =       proc_dointvec,
+                        .procname       = "accept_dad",
+                        .data           = &ipv6_devconf.accept_dad,
+                        .maxlen         = sizeof(int),
+                        .mode           = 0644,
+                        .proc_handler   = proc_dointvec,
                 },
                 {
                         .procname       = "force_tllao",
@@ -4400,8 +4405,8 @@ static int __addrconf_sysctl_register(struct net *net, char *dev_name,
         if (t == NULL)
                 goto out;
 
-        for (i=0; t->addrconf_vars[i].data; i++) {
-                t->addrconf_vars[i].data += (char*)p - (char*)&ipv6_devconf;
+        for (i = 0; t->addrconf_vars[i].data; i++) {
+                t->addrconf_vars[i].data += (char *)p - (char *)&ipv6_devconf;
                 t->addrconf_vars[i].extra1 = idev; /* embedded; no ref */
                 t->addrconf_vars[i].extra2 = net;
         }
@@ -4538,14 +4543,12 @@ int register_inet6addr_notifier(struct notifier_block *nb)
 {
         return atomic_notifier_chain_register(&inet6addr_chain, nb);
 }
-
 EXPORT_SYMBOL(register_inet6addr_notifier);
 
 int unregister_inet6addr_notifier(struct notifier_block *nb)
 {
-        return atomic_notifier_chain_unregister(&inet6addr_chain,nb);
+        return atomic_notifier_chain_unregister(&inet6addr_chain, nb);
 }
-
 EXPORT_SYMBOL(unregister_inet6addr_notifier);
 
 /*
@@ -4554,11 +4557,12 @@ EXPORT_SYMBOL(unregister_inet6addr_notifier);
 
 int __init addrconf_init(void)
 {
-        int err;
+        int i, err;
 
-        if ((err = ipv6_addr_label_init()) < 0) {
-                printk(KERN_CRIT "IPv6 Addrconf: cannot initialize default policy table: %d.\n",
-                        err);
+        err = ipv6_addr_label_init();
+        if (err < 0) {
+                printk(KERN_CRIT "IPv6 Addrconf:"
+                       " cannot initialize default policy table: %d.\n", err);
                 return err;
         }
 
@@ -4589,6 +4593,9 @@ int __init addrconf_init(void)
         if (err)
                 goto errlo;
 
+        for (i = 0; i < IN6_ADDR_HSIZE; i++)
+                INIT_HLIST_HEAD(&inet6_addr_lst[i]);
+
         register_netdevice_notifier(&ipv6_dev_notf);
 
         addrconf_verify(0);
@@ -4617,7 +4624,6 @@ errlo:
 
 void addrconf_cleanup(void)
 {
-        struct inet6_ifaddr *ifa;
         struct net_device *dev;
         int i;
 
@@ -4637,20 +4643,10 @@ void addrconf_cleanup(void)
         /*
          *      Check hash table.
          */
-        write_lock_bh(&addrconf_hash_lock);
-        for (i=0; i < IN6_ADDR_HSIZE; i++) {
-                for (ifa=inet6_addr_lst[i]; ifa; ) {
-                        struct inet6_ifaddr *bifa;
-
-                        bifa = ifa;
-                        ifa = ifa->lst_next;
-                        printk(KERN_DEBUG "bug: IPv6 address leakage detected: ifa=%p\n", bifa);
-                        /* Do not free it; something is wrong.
-                           Now we can investigate it with debugger.
-                         */
-                }
-        }
-        write_unlock_bh(&addrconf_hash_lock);
+        spin_lock_bh(&addrconf_hash_lock);
+        for (i = 0; i < IN6_ADDR_HSIZE; i++)
+                WARN_ON(!hlist_empty(&inet6_addr_lst[i]));
+        spin_unlock_bh(&addrconf_hash_lock);
 
         del_timer(&addr_chk_timer);
         rtnl_unlock();
diff --git a/net/ipv6/addrlabel.c b/net/ipv6/addrlabel.c
index 6ff73c4c126a..ae404c9a746c 100644
--- a/net/ipv6/addrlabel.c
+++ b/net/ipv6/addrlabel.c
@@ -13,6 +13,7 @@
 #include <linux/list.h>
 #include <linux/rcupdate.h>
 #include <linux/in6.h>
+#include <linux/slab.h>
 #include <net/addrconf.h>
 #include <linux/if_addrlabel.h>
 #include <linux/netlink.h>
diff --git a/net/ipv6/af_inet6.c b/net/ipv6/af_inet6.c
index 37d14e735c27..d2df3144429b 100644
--- a/net/ipv6/af_inet6.c
+++ b/net/ipv6/af_inet6.c
@@ -36,6 +36,7 @@
 #include <linux/proc_fs.h>
 #include <linux/stat.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 
 #include <linux/inet.h>
 #include <linux/netdevice.h>
@@ -416,6 +417,9 @@ void inet6_destroy_sock(struct sock *sk)
         if ((skb = xchg(&np->pktoptions, NULL)) != NULL)
                 kfree_skb(skb);
 
+        if ((skb = xchg(&np->rxpmtu, NULL)) != NULL)
+                kfree_skb(skb);
+
         /* Free flowlabels */
         fl6_free_socklist(sk);
 
diff --git a/net/ipv6/ah6.c b/net/ipv6/ah6.c
index 5ac89025f9de..ee82d4ef26ce 100644
--- a/net/ipv6/ah6.c
+++ b/net/ipv6/ah6.c
@@ -26,6 +26,7 @@
 
 #include <crypto/hash.h>
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <net/ip.h>
 #include <net/ah.h>
 #include <linux/crypto.h>
diff --git a/net/ipv6/anycast.c b/net/ipv6/anycast.c
index c4f6ca32fa74..b5b07054508a 100644
--- a/net/ipv6/anycast.c
+++ b/net/ipv6/anycast.c
@@ -29,6 +29,7 @@
 #include <linux/init.h>
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
+#include <linux/slab.h>
 
 #include <net/net_namespace.h>
 #include <net/sock.h>
diff --git a/net/ipv6/datagram.c b/net/ipv6/datagram.c
index e6f9cdf780fe..5959230bc6c1 100644
--- a/net/ipv6/datagram.c
+++ b/net/ipv6/datagram.c
@@ -21,6 +21,7 @@
 #include <linux/in6.h>
 #include <linux/ipv6.h>
 #include <linux/route.h>
+#include <linux/slab.h>
 
 #include <net/ipv6.h>
 #include <net/ndisc.h>
@@ -277,6 +278,45 @@ void ipv6_local_error(struct sock *sk, int err, struct flowi *fl, u32 info)
                 kfree_skb(skb);
 }
 
+void ipv6_local_rxpmtu(struct sock *sk, struct flowi *fl, u32 mtu)
+{
+        struct ipv6_pinfo *np = inet6_sk(sk);
+        struct ipv6hdr *iph;
+        struct sk_buff *skb;
+        struct ip6_mtuinfo *mtu_info;
+
+        if (!np->rxopt.bits.rxpmtu)
+                return;
+
+        skb = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC);
+        if (!skb)
+                return;
+
+        skb_put(skb, sizeof(struct ipv6hdr));
+        skb_reset_network_header(skb);
+        iph = ipv6_hdr(skb);
+        ipv6_addr_copy(&iph->daddr, &fl->fl6_dst);
+
+        mtu_info = IP6CBMTU(skb);
+        if (!mtu_info) {
+                kfree_skb(skb);
+                return;
+        }
+
+        mtu_info->ip6m_mtu = mtu;
+        mtu_info->ip6m_addr.sin6_family = AF_INET6;
+        mtu_info->ip6m_addr.sin6_port = 0;
+        mtu_info->ip6m_addr.sin6_flowinfo = 0;
+        mtu_info->ip6m_addr.sin6_scope_id = fl->oif;
+        ipv6_addr_copy(&mtu_info->ip6m_addr.sin6_addr, &ipv6_hdr(skb)->daddr);
+
+        __skb_pull(skb, skb_tail_pointer(skb) - skb->data);
+        skb_reset_transport_header(skb);
+
+        skb = xchg(&np->rxpmtu, skb);
+        kfree_skb(skb);
+}
+
 /*
  *      Handle MSG_ERRQUEUE
  */
@@ -380,6 +420,54 @@ out:
         return err;
 }
 
+/*
+ *      Handle IPV6_RECVPATHMTU
+ */
+int ipv6_recv_rxpmtu(struct sock *sk, struct msghdr *msg, int len)
+{
+        struct ipv6_pinfo *np = inet6_sk(sk);
+        struct sk_buff *skb;
+        struct sockaddr_in6 *sin;
+        struct ip6_mtuinfo mtu_info;
+        int err;
+        int copied;
+
+        err = -EAGAIN;
+        skb = xchg(&np->rxpmtu, NULL);
+        if (skb == NULL)
+                goto out;
+
+        copied = skb->len;
+        if (copied > len) {
+                msg->msg_flags |= MSG_TRUNC;
+                copied = len;
+        }
+        err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
+        if (err)
+                goto out_free_skb;
+
+        sock_recv_timestamp(msg, sk, skb);
+
+        memcpy(&mtu_info, IP6CBMTU(skb), sizeof(mtu_info));
+
+        sin = (struct sockaddr_in6 *)msg->msg_name;
+        if (sin) {
+                sin->sin6_family = AF_INET6;
+                sin->sin6_flowinfo = 0;
+                sin->sin6_port = 0;
+                sin->sin6_scope_id = mtu_info.ip6m_addr.sin6_scope_id;
+                ipv6_addr_copy(&sin->sin6_addr, &mtu_info.ip6m_addr.sin6_addr);
+        }
+
+        put_cmsg(msg, SOL_IPV6, IPV6_PATHMTU, sizeof(mtu_info), &mtu_info);
+
+        err = copied;
+
+out_free_skb:
+        kfree_skb(skb);
+out:
+        return err;
+}
 
 
 int datagram_recv_ctl(struct sock *sk, struct msghdr *msg, struct sk_buff *skb)
@@ -496,7 +584,7 @@ int datagram_recv_ctl(struct sock *sk, struct msghdr *msg, struct sk_buff *skb)
 int datagram_send_ctl(struct net *net,
                       struct msghdr *msg, struct flowi *fl,
                       struct ipv6_txoptions *opt,
-                      int *hlimit, int *tclass)
+                      int *hlimit, int *tclass, int *dontfrag)
 {
         struct in6_pktinfo *src_info;
         struct cmsghdr *cmsg;
@@ -736,6 +824,25 @@ int datagram_send_ctl(struct net *net,
 
                         break;
                     }
+
+                case IPV6_DONTFRAG:
+                    {
+                        int df;
+
+                        err = -EINVAL;
+                        if (cmsg->cmsg_len != CMSG_LEN(sizeof(int))) {
+                                goto exit_f;
+                        }
+
+                        df = *(int *)CMSG_DATA(cmsg);
+                        if (df < 0 || df > 1)
+                                goto exit_f;
+
+                        err = 0;
+                        *dontfrag = df;
+
+                        break;
+                    }
                 default:
                         LIMIT_NETDEBUG(KERN_DEBUG "invalid cmsg type: %d\n",
                                        cmsg->cmsg_type);
diff --git a/net/ipv6/exthdrs.c b/net/ipv6/exthdrs.c
index 074f2c084f9f..8a659f92d17a 100644
--- a/net/ipv6/exthdrs.c
+++ b/net/ipv6/exthdrs.c
@@ -29,6 +29,7 @@
 #include <linux/netdevice.h>
 #include <linux/in6.h>
 #include <linux/icmpv6.h>
+#include <linux/slab.h>
 
 #include <net/dst.h>
 #include <net/sock.h>
diff --git a/net/ipv6/fib6_rules.c b/net/ipv6/fib6_rules.c
index 5e463c43fcc2..8e44f8f9c188 100644
--- a/net/ipv6/fib6_rules.c
+++ b/net/ipv6/fib6_rules.c
@@ -208,7 +208,6 @@ static int fib6_rule_fill(struct fib_rule *rule, struct sk_buff *skb,
 {
         struct fib6_rule *rule6 = (struct fib6_rule *) rule;
 
-        frh->family = AF_INET6;
         frh->dst_len = rule6->dst.plen;
         frh->src_len = rule6->src.plen;
         frh->tos = rule6->tclass;
@@ -238,7 +237,7 @@ static size_t fib6_rule_nlmsg_payload(struct fib_rule *rule)
                + nla_total_size(16); /* src */
 }
 
-static struct fib_rules_ops fib6_rules_ops_template = {
+static const struct fib_rules_ops __net_initdata fib6_rules_ops_template = {
         .family                 = AF_INET6,
         .rule_size              = sizeof(struct fib6_rule),
         .addr_size              = sizeof(struct in6_addr),
diff --git a/net/ipv6/icmp.c b/net/ipv6/icmp.c
index eb9abe24bdf0..ce7992982557 100644
--- a/net/ipv6/icmp.c
+++ b/net/ipv6/icmp.c
@@ -40,6 +40,7 @@
 #include <linux/skbuff.h>
 #include <linux/init.h>
 #include <linux/netfilter.h>
+#include <linux/slab.h>
 
 #ifdef CONFIG_SYSCTL
 #include <linux/sysctl.h>
@@ -480,8 +481,9 @@ route_done:
                               len + sizeof(struct icmp6hdr),
                               sizeof(struct icmp6hdr), hlimit,
                               np->tclass, NULL, &fl, (struct rt6_info*)dst,
-                              MSG_DONTWAIT);
+                              MSG_DONTWAIT, np->dontfrag);
         if (err) {
+                ICMP6_INC_STATS_BH(net, idev, ICMP6_MIB_OUTMSGS);
                 ip6_flush_pending_frames(sk);
                 goto out_put;
         }
@@ -559,9 +561,11 @@ static void icmpv6_echo_reply(struct sk_buff *skb)
 
         err = ip6_append_data(sk, icmpv6_getfrag, &msg, skb->len + sizeof(struct icmp6hdr),
                                 sizeof(struct icmp6hdr), hlimit, np->tclass, NULL, &fl,
-                                (struct rt6_info*)dst, MSG_DONTWAIT);
+                                (struct rt6_info*)dst, MSG_DONTWAIT,
+                                np->dontfrag);
 
         if (err) {
+                ICMP6_INC_STATS_BH(net, idev, ICMP6_MIB_OUTMSGS);
                 ip6_flush_pending_frames(sk);
                 goto out_put;
         }
diff --git a/net/ipv6/inet6_connection_sock.c b/net/ipv6/inet6_connection_sock.c
index 3516e6fe2e56..0c5e3c3b7fd5 100644
--- a/net/ipv6/inet6_connection_sock.c
+++ b/net/ipv6/inet6_connection_sock.c
@@ -17,6 +17,7 @@
 #include <linux/in6.h>
 #include <linux/ipv6.h>
 #include <linux/jhash.h>
+#include <linux/slab.h>
 
 #include <net/addrconf.h>
 #include <net/inet_connection_sock.h>
@@ -177,7 +178,7 @@ struct dst_entry *__inet6_csk_dst_check(struct sock *sk, u32 cookie)
         return dst;
 }
 
-int inet6_csk_xmit(struct sk_buff *skb, int ipfragok)
+int inet6_csk_xmit(struct sk_buff *skb)
 {
         struct sock *sk = skb->sk;
         struct inet_sock *inet = inet_sk(sk);
@@ -233,7 +234,7 @@ int inet6_csk_xmit(struct sk_buff *skb, int ipfragok)
         /* Restore final destination back after routing done */
         ipv6_addr_copy(&fl.fl6_dst, &np->daddr);
 
-        return ip6_xmit(sk, skb, &fl, np->opt, 0);
+        return ip6_xmit(sk, skb, &fl, np->opt);
 }
 
 EXPORT_SYMBOL_GPL(inet6_csk_xmit);
diff --git a/net/ipv6/ip6_fib.c b/net/ipv6/ip6_fib.c
index 2f9847924fa5..92a122b7795d 100644
--- a/net/ipv6/ip6_fib.c
+++ b/net/ipv6/ip6_fib.c
@@ -26,6 +26,7 @@
 #include <linux/in6.h>
 #include <linux/init.h>
 #include <linux/list.h>
+#include <linux/slab.h>
 
 #ifdef  CONFIG_PROC_FS
 #include <linux/proc_fs.h>
@@ -127,12 +128,24 @@ static __inline__ u32 fib6_new_sernum(void)
 /*
  *      test bit
  */
+#if defined(__LITTLE_ENDIAN)
+# define BITOP_BE32_SWIZZLE     (0x1F & ~7)
+#else
+# define BITOP_BE32_SWIZZLE     0
+#endif
 
 static __inline__ __be32 addr_bit_set(void *token, int fn_bit)
 {
         __be32 *addr = token;
-
-        return htonl(1 << ((~fn_bit)&0x1F)) & addr[fn_bit>>5];
+        /*
+         * Here,
+         *      1 << ((~fn_bit ^ BITOP_BE32_SWIZZLE) & 0x1f)
+         * is optimized version of
+         *      htonl(1 << ((~fn_bit)&0x1F))
+         * See include/asm-generic/bitops/le.h.
+         */
+        return (__force __be32)(1 << ((~fn_bit ^ BITOP_BE32_SWIZZLE) & 0x1f)) &
+               addr[fn_bit >> 5];
 }
 
 static __inline__ struct fib6_node * node_alloc(void)
diff --git a/net/ipv6/ip6_flowlabel.c b/net/ipv6/ip6_flowlabel.c
index e41eba8aacf1..13654686aeab 100644
--- a/net/ipv6/ip6_flowlabel.c
+++ b/net/ipv6/ip6_flowlabel.c
@@ -20,6 +20,7 @@
 #include <linux/route.h>
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
+#include <linux/slab.h>
 
 #include <net/net_namespace.h>
 #include <net/sock.h>
@@ -359,7 +360,8 @@ fl_create(struct net *net, struct in6_flowlabel_req *freq, char __user *optval,
                 msg.msg_control = (void*)(fl->opt+1);
                 flowi.oif = 0;
 
-                err = datagram_send_ctl(net, &msg, &flowi, fl->opt, &junk, &junk);
+                err = datagram_send_ctl(net, &msg, &flowi, fl->opt, &junk,
+                                        &junk, &junk);
                 if (err)
                         goto done;
                 err = -EINVAL;
diff --git a/net/ipv6/ip6_input.c b/net/ipv6/ip6_input.c
index e28f9203deca..6aa7ee1295c2 100644
--- a/net/ipv6/ip6_input.c
+++ b/net/ipv6/ip6_input.c
@@ -28,6 +28,7 @@
 #include <linux/in6.h>
 #include <linux/icmpv6.h>
 #include <linux/mroute6.h>
+#include <linux/slab.h>
 
 #include <linux/netfilter.h>
 #include <linux/netfilter_ipv6.h>
diff --git a/net/ipv6/ip6_output.c b/net/ipv6/ip6_output.c
index dabf108ad811..e7a5f17d5e95 100644
--- a/net/ipv6/ip6_output.c
+++ b/net/ipv6/ip6_output.c
@@ -37,6 +37,7 @@
 #include <linux/tcp.h>
 #include <linux/route.h>
 #include <linux/module.h>
+#include <linux/slab.h>
 
 #include <linux/netfilter.h>
 #include <linux/netfilter_ipv6.h>
@@ -107,7 +108,7 @@ static int ip6_dev_loopback_xmit(struct sk_buff *newskb)
         newskb->ip_summed = CHECKSUM_UNNECESSARY;
         WARN_ON(!skb_dst(newskb));
 
-        netif_rx(newskb);
+        netif_rx_ni(newskb);
         return 0;
 }
 
@@ -180,11 +181,11 @@ int ip6_output(struct sk_buff *skb)
 }
 
 /*
- *      xmit an sk_buff (used by TCP)
+ *      xmit an sk_buff (used by TCP, SCTP and DCCP)
  */
 
 int ip6_xmit(struct sock *sk, struct sk_buff *skb, struct flowi *fl,
-             struct ipv6_txoptions *opt, int ipfragok)
+             struct ipv6_txoptions *opt)
 {
         struct net *net = sock_net(sk);
         struct ipv6_pinfo *np = inet6_sk(sk);
@@ -217,8 +218,7 @@ int ip6_xmit(struct sock *sk, struct sk_buff *skb, struct flowi *fl,
                         }
                         kfree_skb(skb);
                         skb = skb2;
-                        if (sk)
-                                skb_set_owner_w(skb, sk);
+                        skb_set_owner_w(skb, sk);
                 }
                 if (opt->opt_flen)
                         ipv6_push_frag_opts(skb, opt, &proto);
@@ -230,10 +230,6 @@ int ip6_xmit(struct sock *sk, struct sk_buff *skb, struct flowi *fl,
         skb_reset_network_header(skb);
         hdr = ipv6_hdr(skb);
 
-        /* Allow local fragmentation. */
-        if (ipfragok)
-                skb->local_df = 1;
-
         /*
          *      Fill in the IPv6 header
          */
@@ -628,7 +624,7 @@ static int ip6_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *))
         /* We must not fragment if the socket is set to force MTU discovery
          * or if the skb it not generated by a local socket.
          */
-        if (!skb->local_df) {
+        if (!skb->local_df && skb->len > mtu) {
                 skb->dev = skb_dst(skb)->dev;
                 icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
                 IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
@@ -1108,7 +1104,7 @@ int ip6_append_data(struct sock *sk, int getfrag(void *from, char *to,
         int offset, int len, int odd, struct sk_buff *skb),
         void *from, int length, int transhdrlen,
         int hlimit, int tclass, struct ipv6_txoptions *opt, struct flowi *fl,
-        struct rt6_info *rt, unsigned int flags)
+        struct rt6_info *rt, unsigned int flags, int dontfrag)
 {
         struct inet_sock *inet = inet_sk(sk);
         struct ipv6_pinfo *np = inet6_sk(sk);
@@ -1222,15 +1218,23 @@ int ip6_append_data(struct sock *sk, int getfrag(void *from, char *to,
          */
 
         inet->cork.length += length;
-        if (((length > mtu) && (sk->sk_protocol == IPPROTO_UDP)) &&
-            (rt->u.dst.dev->features & NETIF_F_UFO)) {
+        if (length > mtu) {
+                int proto = sk->sk_protocol;
+                if (dontfrag && (proto == IPPROTO_UDP || proto == IPPROTO_RAW)){
+                        ipv6_local_rxpmtu(sk, fl, mtu-exthdrlen);
+                        return -EMSGSIZE;
+                }
 
-                err = ip6_ufo_append_data(sk, getfrag, from, length, hh_len,
-                                          fragheaderlen, transhdrlen, mtu,
-                                          flags);
-                if (err)
-                        goto error;
-                return 0;
+                if (proto == IPPROTO_UDP &&
+                    (rt->u.dst.dev->features & NETIF_F_UFO)) {
+
+                        err = ip6_ufo_append_data(sk, getfrag, from, length,
+                                                  hh_len, fragheaderlen,
+                                                  transhdrlen, mtu, flags);
+                        if (err)
+                                goto error;
+                        return 0;
+                }
         }
 
         if ((skb = skb_peek_tail(&sk->sk_write_queue)) == NULL)
diff --git a/net/ipv6/ip6_tunnel.c b/net/ipv6/ip6_tunnel.c
index 138980eec214..2599870747ec 100644
--- a/net/ipv6/ip6_tunnel.c
+++ b/net/ipv6/ip6_tunnel.c
@@ -37,6 +37,7 @@
 #include <linux/route.h>
 #include <linux/rtnetlink.h>
 #include <linux/netfilter_ipv6.h>
+#include <linux/slab.h>
 
 #include <asm/uaccess.h>
 #include <asm/atomic.h>
diff --git a/net/ipv6/ip6mr.c b/net/ipv6/ip6mr.c
index 52e0f74fdfe0..3e333268db89 100644
--- a/net/ipv6/ip6mr.c
+++ b/net/ipv6/ip6mr.c
@@ -33,6 +33,7 @@
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <net/protocol.h>
 #include <linux/skbuff.h>
 #include <net/sock.h>
@@ -1113,6 +1114,9 @@ static int ip6mr_mfc_add(struct net *net, struct mf6cctl *mfc, int mrtsock)
         unsigned char ttls[MAXMIFS];
         int i;
 
+        if (mfc->mf6cc_parent >= MAXMIFS)
+                return -ENFILE;
+
         memset(ttls, 255, MAXMIFS);
         for (i = 0; i < MAXMIFS; i++) {
                 if (IF_ISSET(i, &mfc->mf6cc_ifset))
@@ -1692,17 +1696,20 @@ ip6mr_fill_mroute(struct sk_buff *skb, struct mfc6_cache *c, struct rtmsg *rtm)
         int ct;
         struct rtnexthop *nhp;
         struct net *net = mfc6_net(c);
-        struct net_device *dev = net->ipv6.vif6_table[c->mf6c_parent].dev;
         u8 *b = skb_tail_pointer(skb);
         struct rtattr *mp_head;
 
-        if (dev)
-                RTA_PUT(skb, RTA_IIF, 4, &dev->ifindex);
+        /* If cache is unresolved, don't try to parse IIF and OIF */
+        if (c->mf6c_parent > MAXMIFS)
+                return -ENOENT;
+
+        if (MIF_EXISTS(net, c->mf6c_parent))
+                RTA_PUT(skb, RTA_IIF, 4, &net->ipv6.vif6_table[c->mf6c_parent].dev->ifindex);
 
         mp_head = (struct rtattr *)skb_put(skb, RTA_LENGTH(0));
 
         for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
-                if (c->mfc_un.res.ttls[ct] < 255) {
+                if (MIF_EXISTS(net, ct) && c->mfc_un.res.ttls[ct] < 255) {
                         if (skb_tailroom(skb) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp)) + 4))
                                 goto rtattr_failure;
                         nhp = (struct rtnexthop *)skb_put(skb, RTA_ALIGN(sizeof(*nhp)));
diff --git a/net/ipv6/ipv6_sockglue.c b/net/ipv6/ipv6_sockglue.c
index 430454ee5ead..bd43f0152c21 100644
--- a/net/ipv6/ipv6_sockglue.c
+++ b/net/ipv6/ipv6_sockglue.c
@@ -36,6 +36,7 @@
 #include <linux/init.h>
 #include <linux/sysctl.h>
 #include <linux/netfilter.h>
+#include <linux/slab.h>
 
 #include <net/sock.h>
 #include <net/snmp.h>
@@ -113,9 +114,9 @@ struct ipv6_txoptions *ipv6_update_options(struct sock *sk,
                 }
                 opt = xchg(&inet6_sk(sk)->opt, opt);
         } else {
-                write_lock(&sk->sk_dst_lock);
+                spin_lock(&sk->sk_dst_lock);
                 opt = xchg(&inet6_sk(sk)->opt, opt);
-                write_unlock(&sk->sk_dst_lock);
+                spin_unlock(&sk->sk_dst_lock);
         }
         sk_dst_reset(sk);
 
@@ -336,6 +337,13 @@ static int do_ipv6_setsockopt(struct sock *sk, int level, int optname,
                 retv = 0;
                 break;
 
+        case IPV6_RECVPATHMTU:
+                if (optlen < sizeof(int))
+                        goto e_inval;
+                np->rxopt.bits.rxpmtu = valbool;
+                retv = 0;
+                break;
+
         case IPV6_HOPOPTS:
         case IPV6_RTHDRDSTOPTS:
         case IPV6_RTHDR:
@@ -450,7 +458,8 @@ sticky_done:
                 msg.msg_controllen = optlen;
                 msg.msg_control = (void*)(opt+1);
 
-                retv = datagram_send_ctl(net, &msg, &fl, opt, &junk, &junk);
+                retv = datagram_send_ctl(net, &msg, &fl, opt, &junk, &junk,
+                                         &junk);
                 if (retv)
                         goto done;
 update:
@@ -766,6 +775,17 @@ pref_skip_coa:
 
                 break;
             }
+        case IPV6_MINHOPCOUNT:
+                if (optlen < sizeof(int))
+                        goto e_inval;
+                if (val < 0 || val > 255)
+                        goto e_inval;
+                np->min_hopcount = val;
+                break;
+        case IPV6_DONTFRAG:
+                np->dontfrag = valbool;
+                retv = 0;
+                break;
         }
 
         release_sock(sk);
@@ -970,14 +990,13 @@ static int do_ipv6_getsockopt(struct sock *sk, int level, int optname,
         case IPV6_MTU:
         {
                 struct dst_entry *dst;
+
                 val = 0;
-                lock_sock(sk);
-                dst = sk_dst_get(sk);
-                if (dst) {
+                rcu_read_lock();
+                dst = __sk_dst_get(sk);
+                if (dst)
                         val = dst_mtu(dst);
-                        dst_release(dst);
-                }
-                release_sock(sk);
+                rcu_read_unlock();
                 if (!val)
                         return -ENOTCONN;
                 break;
@@ -1055,6 +1074,38 @@ static int do_ipv6_getsockopt(struct sock *sk, int level, int optname,
                 val = np->rxopt.bits.rxflow;
                 break;
 
+        case IPV6_RECVPATHMTU:
+                val = np->rxopt.bits.rxpmtu;
+                break;
+
+        case IPV6_PATHMTU:
+        {
+                struct dst_entry *dst;
+                struct ip6_mtuinfo mtuinfo;
+
+                if (len < sizeof(mtuinfo))
+                        return -EINVAL;
+
+                len = sizeof(mtuinfo);
+                memset(&mtuinfo, 0, sizeof(mtuinfo));
+
+                rcu_read_lock();
+                dst = __sk_dst_get(sk);
+                if (dst)
+                        mtuinfo.ip6m_mtu = dst_mtu(dst);
+                rcu_read_unlock();
+                if (!mtuinfo.ip6m_mtu)
+                        return -ENOTCONN;
+
+                if (put_user(len, optlen))
+                        return -EFAULT;
+                if (copy_to_user(optval, &mtuinfo, len))
+                        return -EFAULT;
+
+                return 0;
+                break;
+        }
+
         case IPV6_UNICAST_HOPS:
         case IPV6_MULTICAST_HOPS:
         {
@@ -1065,12 +1116,14 @@ static int do_ipv6_getsockopt(struct sock *sk, int level, int optname,
                 else
                         val = np->mcast_hops;
 
-                dst = sk_dst_get(sk);
-                if (dst) {
-                        if (val < 0)
+                if (val < 0) {
+                        rcu_read_lock();
+                        dst = __sk_dst_get(sk);
+                        if (dst)
                                 val = ip6_dst_hoplimit(dst);
-                        dst_release(dst);
+                        rcu_read_unlock();
                 }
+
                 if (val < 0)
                         val = sock_net(sk)->ipv6.devconf_all->hop_limit;
                 break;
@@ -1114,6 +1167,14 @@ static int do_ipv6_getsockopt(struct sock *sk, int level, int optname,
                         val |= IPV6_PREFER_SRC_HOME;
                 break;
 
+        case IPV6_MINHOPCOUNT:
+                val = np->min_hopcount;
+                break;
+
+        case IPV6_DONTFRAG:
+                val = np->dontfrag;
+                break;
+
         default:
                 return -ENOPROTOOPT;
         }
diff --git a/net/ipv6/mcast.c b/net/ipv6/mcast.c
index bcd971915969..006aee683a0f 100644
--- a/net/ipv6/mcast.c
+++ b/net/ipv6/mcast.c
@@ -43,6 +43,8 @@
 #include <linux/init.h>
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
+#include <linux/slab.h>
+#include <net/mld.h>
 
 #include <linux/netfilter.h>
 #include <linux/netfilter_ipv6.h>
@@ -70,54 +72,11 @@
 #define MDBG(x)
 #endif
 
-/*
- *  These header formats should be in a separate include file, but icmpv6.h
- *  doesn't have in6_addr defined in all cases, there is no __u128, and no
- *  other files reference these.
- *
- *                      +-DLS 4/14/03
- */
-
-/* Multicast Listener Discovery version 2 headers */
-
-struct mld2_grec {
-        __u8            grec_type;
-        __u8            grec_auxwords;
-        __be16          grec_nsrcs;
-        struct in6_addr grec_mca;
-        struct in6_addr grec_src[0];
-};
-
-struct mld2_report {
-        __u8    type;
-        __u8    resv1;
-        __sum16 csum;
-        __be16  resv2;
-        __be16  ngrec;
-        struct mld2_grec grec[0];
-};
-
-struct mld2_query {
-        __u8 type;
-        __u8 code;
-        __sum16 csum;
-        __be16 mrc;
-        __be16 resv1;
-        struct in6_addr mca;
-#if defined(__LITTLE_ENDIAN_BITFIELD)
-        __u8 qrv:3,
-             suppress:1,
-             resv2:4;
-#elif defined(__BIG_ENDIAN_BITFIELD)
-        __u8 resv2:4,
-             suppress:1,
-             qrv:3;
-#else
-#error "Please fix <asm/byteorder.h>"
-#endif
-        __u8 qqic;
-        __be16 nsrcs;
-        struct in6_addr srcs[0];
+/* Ensure that we have struct in6_addr aligned on 32bit word. */
+static void *__mld2_query_bugs[] __attribute__((__unused__)) = {
+        BUILD_BUG_ON_NULL(offsetof(struct mld2_query, mld2q_srcs) % 4),
+        BUILD_BUG_ON_NULL(offsetof(struct mld2_report, mld2r_grec) % 4),
+        BUILD_BUG_ON_NULL(offsetof(struct mld2_grec, grec_mca) % 4)
 };
 
 static struct in6_addr mld2_all_mcr = MLD2_ALL_MCR_INIT;
@@ -156,14 +115,6 @@ static int ip6_mc_leave_src(struct sock *sk, struct ipv6_mc_socklist *iml,
                 ((idev)->mc_v1_seen && \
                 time_before(jiffies, (idev)->mc_v1_seen)))
 
-#define MLDV2_MASK(value, nb) ((nb)>=32 ? (value) : ((1<<(nb))-1) & (value))
-#define MLDV2_EXP(thresh, nbmant, nbexp, value) \
-        ((value) < (thresh) ? (value) : \
-        ((MLDV2_MASK(value, nbmant) | (1<<(nbmant))) << \
-        (MLDV2_MASK((value) >> (nbmant), nbexp) + (nbexp))))
-
-#define MLDV2_MRC(value) MLDV2_EXP(0x8000, 12, 3, value)
-
 #define IPV6_MLD_MAX_MSF        64
 
 int sysctl_mld_max_msf __read_mostly = IPV6_MLD_MAX_MSF;
@@ -714,7 +665,7 @@ static void igmp6_group_added(struct ifmcaddr6 *mc)
         if (!(mc->mca_flags&MAF_LOADED)) {
                 mc->mca_flags |= MAF_LOADED;
                 if (ndisc_mc_map(&mc->mca_addr, buf, dev, 0) == 0)
-                        dev_mc_add(dev, buf, dev->addr_len, 0);
+                        dev_mc_add(dev, buf);
         }
         spin_unlock_bh(&mc->mca_lock);
 
@@ -740,7 +691,7 @@ static void igmp6_group_dropped(struct ifmcaddr6 *mc)
         if (mc->mca_flags&MAF_LOADED) {
                 mc->mca_flags &= ~MAF_LOADED;
                 if (ndisc_mc_map(&mc->mca_addr, buf, dev, 0) == 0)
-                        dev_mc_delete(dev, buf, dev->addr_len, 0);
+                        dev_mc_del(dev, buf);
         }
 
         if (mc->mca_flags & MAF_NOREPORT)
@@ -1160,7 +1111,7 @@ int igmp6_event_query(struct sk_buff *skb)
         struct in6_addr *group;
         unsigned long max_delay;
         struct inet6_dev *idev;
-        struct icmp6hdr *hdr;
+        struct mld_msg *mld;
         int group_type;
         int mark = 0;
         int len;
@@ -1181,8 +1132,8 @@ int igmp6_event_query(struct sk_buff *skb)
         if (idev == NULL)
                 return 0;
 
-        hdr = icmp6_hdr(skb);
-        group = (struct in6_addr *) (hdr + 1);
+        mld = (struct mld_msg *)icmp6_hdr(skb);
+        group = &mld->mld_mca;
         group_type = ipv6_addr_type(group);
 
         if (group_type != IPV6_ADDR_ANY &&
@@ -1196,7 +1147,7 @@ int igmp6_event_query(struct sk_buff *skb)
                 /* MLDv1 router present */
 
                 /* Translate milliseconds to jiffies */
-                max_delay = (ntohs(hdr->icmp6_maxdelay)*HZ)/1000;
+                max_delay = (ntohs(mld->mld_maxdelay)*HZ)/1000;
 
                 switchback = (idev->mc_qrv + 1) * max_delay;
                 idev->mc_v1_seen = jiffies + switchback;
@@ -1215,14 +1166,14 @@ int igmp6_event_query(struct sk_buff *skb)
                         return -EINVAL;
                 }
                 mlh2 = (struct mld2_query *)skb_transport_header(skb);
-                max_delay = (MLDV2_MRC(ntohs(mlh2->mrc))*HZ)/1000;
+                max_delay = (MLDV2_MRC(ntohs(mlh2->mld2q_mrc))*HZ)/1000;
                 if (!max_delay)
                         max_delay = 1;
                 idev->mc_maxdelay = max_delay;
-                if (mlh2->qrv)
-                        idev->mc_qrv = mlh2->qrv;
+                if (mlh2->mld2q_qrv)
+                        idev->mc_qrv = mlh2->mld2q_qrv;
                 if (group_type == IPV6_ADDR_ANY) { /* general query */
-                        if (mlh2->nsrcs) {
+                        if (mlh2->mld2q_nsrcs) {
                                 in6_dev_put(idev);
                                 return -EINVAL; /* no sources allowed */
                         }
@@ -1231,9 +1182,9 @@ int igmp6_event_query(struct sk_buff *skb)
                         return 0;
                 }
                 /* mark sources to include, if group & source-specific */
-                if (mlh2->nsrcs != 0) {
+                if (mlh2->mld2q_nsrcs != 0) {
                         if (!pskb_may_pull(skb, srcs_offset +
-                            ntohs(mlh2->nsrcs) * sizeof(struct in6_addr))) {
+                            ntohs(mlh2->mld2q_nsrcs) * sizeof(struct in6_addr))) {
                                 in6_dev_put(idev);
                                 return -EINVAL;
                         }
@@ -1269,7 +1220,7 @@ int igmp6_event_query(struct sk_buff *skb)
                                         ma->mca_flags &= ~MAF_GSQUERY;
                         }
                         if (!(ma->mca_flags & MAF_GSQUERY) ||
-                            mld_marksources(ma, ntohs(mlh2->nsrcs), mlh2->srcs))
+                            mld_marksources(ma, ntohs(mlh2->mld2q_nsrcs), mlh2->mld2q_srcs))
                                 igmp6_group_queried(ma, max_delay);
                         spin_unlock_bh(&ma->mca_lock);
                         break;
@@ -1285,9 +1236,8 @@ int igmp6_event_query(struct sk_buff *skb)
 int igmp6_event_report(struct sk_buff *skb)
 {
         struct ifmcaddr6 *ma;
-        struct in6_addr *addrp;
         struct inet6_dev *idev;
-        struct icmp6hdr *hdr;
+        struct mld_msg *mld;
         int addr_type;
 
         /* Our own report looped back. Ignore it. */
@@ -1299,10 +1249,10 @@ int igmp6_event_report(struct sk_buff *skb)
             skb->pkt_type != PACKET_BROADCAST)
                 return 0;
 
-        if (!pskb_may_pull(skb, sizeof(struct in6_addr)))
+        if (!pskb_may_pull(skb, sizeof(*mld) - sizeof(struct icmp6hdr)))
                 return -EINVAL;
 
-        hdr = icmp6_hdr(skb);
+        mld = (struct mld_msg *)icmp6_hdr(skb);
 
         /* Drop reports with not link local source */
         addr_type = ipv6_addr_type(&ipv6_hdr(skb)->saddr);
@@ -1310,8 +1260,6 @@ int igmp6_event_report(struct sk_buff *skb)
             !(addr_type&IPV6_ADDR_LINKLOCAL))
                 return -EINVAL;
 
-        addrp = (struct in6_addr *) (hdr + 1);
-
         idev = in6_dev_get(skb->dev);
         if (idev == NULL)
                 return -ENODEV;
@@ -1322,7 +1270,7 @@ int igmp6_event_report(struct sk_buff *skb)
 
         read_lock_bh(&idev->lock);
         for (ma = idev->mc_list; ma; ma=ma->next) {
-                if (ipv6_addr_equal(&ma->mca_addr, addrp)) {
+                if (ipv6_addr_equal(&ma->mca_addr, &mld->mld_mca)) {
                         spin_lock(&ma->mca_lock);
                         if (del_timer(&ma->mca_timer))
                                 atomic_dec(&ma->mca_refcnt);
@@ -1431,11 +1379,11 @@ static struct sk_buff *mld_newpack(struct net_device *dev, int size)
         skb_set_transport_header(skb, skb_tail_pointer(skb) - skb->data);
         skb_put(skb, sizeof(*pmr));
         pmr = (struct mld2_report *)skb_transport_header(skb);
-        pmr->type = ICMPV6_MLD2_REPORT;
-        pmr->resv1 = 0;
-        pmr->csum = 0;
-        pmr->resv2 = 0;
-        pmr->ngrec = 0;
+        pmr->mld2r_type = ICMPV6_MLD2_REPORT;
+        pmr->mld2r_resv1 = 0;
+        pmr->mld2r_cksum = 0;
+        pmr->mld2r_resv2 = 0;
+        pmr->mld2r_ngrec = 0;
         return skb;
 }
 
@@ -1457,9 +1405,10 @@ static void mld_sendpack(struct sk_buff *skb)
         mldlen = skb->tail - skb->transport_header;
         pip6->payload_len = htons(payload_len);
 
-        pmr->csum = csum_ipv6_magic(&pip6->saddr, &pip6->daddr, mldlen,
-                IPPROTO_ICMPV6, csum_partial(skb_transport_header(skb),
-                                             mldlen, 0));
+        pmr->mld2r_cksum = csum_ipv6_magic(&pip6->saddr, &pip6->daddr, mldlen,
+                                           IPPROTO_ICMPV6,
+                                           csum_partial(skb_transport_header(skb),
+                                                        mldlen, 0));
 
         dst = icmp6_dst_alloc(skb->dev, NULL, &ipv6_hdr(skb)->daddr);
 
@@ -1520,7 +1469,7 @@ static struct sk_buff *add_grhead(struct sk_buff *skb, struct ifmcaddr6 *pmc,
         pgr->grec_nsrcs = 0;
         pgr->grec_mca = pmc->mca_addr;  /* structure copy */
         pmr = (struct mld2_report *)skb_transport_header(skb);
-        pmr->ngrec = htons(ntohs(pmr->ngrec)+1);
+        pmr->mld2r_ngrec = htons(ntohs(pmr->mld2r_ngrec)+1);
         *ppgr = pgr;
         return skb;
 }
@@ -1556,7 +1505,7 @@ static struct sk_buff *add_grec(struct sk_buff *skb, struct ifmcaddr6 *pmc,
 
         /* EX and TO_EX get a fresh packet, if needed */
         if (truncate) {
-                if (pmr && pmr->ngrec &&
+                if (pmr && pmr->mld2r_ngrec &&
                     AVAILABLE(skb) < grec_size(pmc, type, gdeleted, sdeleted)) {
                         if (skb)
                                 mld_sendpack(skb);
@@ -1769,9 +1718,8 @@ static void igmp6_send(struct in6_addr *addr, struct net_device *dev, int type)
         struct sock *sk = net->ipv6.igmp_sk;
         struct inet6_dev *idev;
         struct sk_buff *skb;
-        struct icmp6hdr *hdr;
+        struct mld_msg *hdr;
         const struct in6_addr *snd_addr, *saddr;
-        struct in6_addr *addrp;
         struct in6_addr addr_buf;
         int err, len, payload_len, full_len;
         u8 ra[8] = { IPPROTO_ICMPV6, 0,
@@ -1819,16 +1767,14 @@ static void igmp6_send(struct in6_addr *addr, struct net_device *dev, int type)
 
         memcpy(skb_put(skb, sizeof(ra)), ra, sizeof(ra));
 
-        hdr = (struct icmp6hdr *) skb_put(skb, sizeof(struct icmp6hdr));
-        memset(hdr, 0, sizeof(struct icmp6hdr));
-        hdr->icmp6_type = type;
+        hdr = (struct mld_msg *) skb_put(skb, sizeof(struct mld_msg));
+        memset(hdr, 0, sizeof(struct mld_msg));
+        hdr->mld_type = type;
+        ipv6_addr_copy(&hdr->mld_mca, addr);
 
-        addrp = (struct in6_addr *) skb_put(skb, sizeof(struct in6_addr));
-        ipv6_addr_copy(addrp, addr);
-
-        hdr->icmp6_cksum = csum_ipv6_magic(saddr, snd_addr, len,
-                                           IPPROTO_ICMPV6,
-                                           csum_partial(hdr, len, 0));
+        hdr->mld_cksum = csum_ipv6_magic(saddr, snd_addr, len,
+                                         IPPROTO_ICMPV6,
+                                         csum_partial(hdr, len, 0));
 
         idev = in6_dev_get(skb->dev);
 
diff --git a/net/ipv6/ndisc.c b/net/ipv6/ndisc.c
index 8bcc4b7db3bf..da0a4d2adc69 100644
--- a/net/ipv6/ndisc.c
+++ b/net/ipv6/ndisc.c
@@ -59,6 +59,7 @@
 #include <linux/route.h>
 #include <linux/init.h>
 #include <linux/rcupdate.h>
+#include <linux/slab.h>
 #ifdef CONFIG_SYSCTL
 #include <linux/sysctl.h>
 #endif
diff --git a/net/ipv6/netfilter/ip6_queue.c b/net/ipv6/netfilter/ip6_queue.c
index 7854052be60b..6a68a74d14a3 100644
--- a/net/ipv6/netfilter/ip6_queue.c
+++ b/net/ipv6/netfilter/ip6_queue.c
@@ -25,6 +25,7 @@
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
 #include <linux/mutex.h>
+#include <linux/slab.h>
 #include <net/net_namespace.h>
 #include <net/sock.h>
 #include <net/ipv6.h>
diff --git a/net/ipv6/netfilter/ip6t_REJECT.c b/net/ipv6/netfilter/ip6t_REJECT.c
index dd8afbaf00a8..39b50c3768e8 100644
--- a/net/ipv6/netfilter/ip6t_REJECT.c
+++ b/net/ipv6/netfilter/ip6t_REJECT.c
@@ -15,6 +15,7 @@
  * 2 of the License, or (at your option) any later version.
  */
 
+#include <linux/gfp.h>
 #include <linux/module.h>
 #include <linux/skbuff.h>
 #include <linux/icmpv6.h>
diff --git a/net/ipv6/netfilter/ip6t_hbh.c b/net/ipv6/netfilter/ip6t_hbh.c
index cbe8dec9744b..e60677519e40 100644
--- a/net/ipv6/netfilter/ip6t_hbh.c
+++ b/net/ipv6/netfilter/ip6t_hbh.c
@@ -141,11 +141,11 @@ hbh_mt6(const struct sk_buff *skb, const struct xt_match_param *par)
                         }
 
                         /* Step to the next */
-                        pr_debug("len%04X \n", optlen);
+                        pr_debug("len%04X\n", optlen);
 
                         if ((ptr > skb->len - optlen || hdrlen < optlen) &&
                             temp < optinfo->optsnr - 1) {
-                                pr_debug("new pointer is too large! \n");
+                                pr_debug("new pointer is too large!\n");
                                 break;
                         }
                         ptr += optlen;
diff --git a/net/ipv6/netfilter/ip6table_filter.c b/net/ipv6/netfilter/ip6table_filter.c
index 36b72cafc227..d6fc9aff3163 100644
--- a/net/ipv6/netfilter/ip6table_filter.c
+++ b/net/ipv6/netfilter/ip6table_filter.c
@@ -12,6 +12,7 @@
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/netfilter_ipv6/ip6_tables.h>
+#include <linux/slab.h>
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Netfilter Core Team <coreteam@netfilter.org>");
diff --git a/net/ipv6/netfilter/ip6table_mangle.c b/net/ipv6/netfilter/ip6table_mangle.c
index 7844e557c0ec..6a102b57f356 100644
--- a/net/ipv6/netfilter/ip6table_mangle.c
+++ b/net/ipv6/netfilter/ip6table_mangle.c
@@ -10,6 +10,7 @@
  */
 #include <linux/module.h>
 #include <linux/netfilter_ipv6/ip6_tables.h>
+#include <linux/slab.h>
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Netfilter Core Team <coreteam@netfilter.org>");
diff --git a/net/ipv6/netfilter/ip6table_raw.c b/net/ipv6/netfilter/ip6table_raw.c
index aef31a29de9e..5b9926a011bd 100644
--- a/net/ipv6/netfilter/ip6table_raw.c
+++ b/net/ipv6/netfilter/ip6table_raw.c
@@ -5,6 +5,7 @@
  */
 #include <linux/module.h>
 #include <linux/netfilter_ipv6/ip6_tables.h>
+#include <linux/slab.h>
 
 #define RAW_VALID_HOOKS ((1 << NF_INET_PRE_ROUTING) | (1 << NF_INET_LOCAL_OUT))
 
@@ -13,7 +14,7 @@ static const struct xt_table packet_raw = {
         .valid_hooks = RAW_VALID_HOOKS,
         .me = THIS_MODULE,
         .af = NFPROTO_IPV6,
-        .priority = NF_IP6_PRI_FIRST,
+        .priority = NF_IP6_PRI_RAW,
 };
 
 /* The work comes in here from netfilter.c. */
diff --git a/net/ipv6/netfilter/ip6table_security.c b/net/ipv6/netfilter/ip6table_security.c
index 0824d865aa9b..91aa2b4d83c9 100644
--- a/net/ipv6/netfilter/ip6table_security.c
+++ b/net/ipv6/netfilter/ip6table_security.c
@@ -17,6 +17,7 @@
  */
 #include <linux/module.h>
 #include <linux/netfilter_ipv6/ip6_tables.h>
+#include <linux/slab.h>
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("James Morris <jmorris <at> redhat.com>");
diff --git a/net/ipv6/netfilter/nf_conntrack_reasm.c b/net/ipv6/netfilter/nf_conntrack_reasm.c
index f1171b744650..dd5b9bd61c62 100644
--- a/net/ipv6/netfilter/nf_conntrack_reasm.c
+++ b/net/ipv6/netfilter/nf_conntrack_reasm.c
@@ -27,6 +27,7 @@
 #include <linux/ipv6.h>
 #include <linux/icmpv6.h>
 #include <linux/random.h>
+#include <linux/slab.h>
 
 #include <net/sock.h>
 #include <net/snmp.h>
diff --git a/net/ipv6/proc.c b/net/ipv6/proc.c
index 58344c0fbd13..458eabfbe130 100644
--- a/net/ipv6/proc.c
+++ b/net/ipv6/proc.c
@@ -97,6 +97,7 @@ static const struct snmp_mib snmp6_icmp6_list[] = {
         SNMP_MIB_ITEM("Icmp6InMsgs", ICMP6_MIB_INMSGS),
         SNMP_MIB_ITEM("Icmp6InErrors", ICMP6_MIB_INERRORS),
         SNMP_MIB_ITEM("Icmp6OutMsgs", ICMP6_MIB_OUTMSGS),
+        SNMP_MIB_ITEM("Icmp6OutErrors", ICMP6_MIB_OUTERRORS),
         SNMP_MIB_SENTINEL
 };
 
diff --git a/net/ipv6/raw.c b/net/ipv6/raw.c
index ed31c37c6e39..0e3d2dd92078 100644
--- a/net/ipv6/raw.c
+++ b/net/ipv6/raw.c
@@ -21,6 +21,7 @@
 #include <linux/errno.h>
 #include <linux/types.h>
 #include <linux/socket.h>
+#include <linux/slab.h>
 #include <linux/sockios.h>
 #include <linux/net.h>
 #include <linux/in6.h>
@@ -380,7 +381,7 @@ static inline int rawv6_rcv_skb(struct sock * sk, struct sk_buff * skb)
         }
 
         /* Charge it to the socket. */
-        if (sock_queue_rcv_skb(sk, skb) < 0) {
+        if (ip_queue_rcv_skb(sk, skb) < 0) {
                 kfree_skb(skb);
                 return NET_RX_DROP;
         }
@@ -460,6 +461,9 @@ static int rawv6_recvmsg(struct kiocb *iocb, struct sock *sk,
         if (flags & MSG_ERRQUEUE)
                 return ipv6_recv_error(sk, msg, len);
 
+        if (np->rxpmtu && np->rxopt.bits.rxpmtu)
+                return ipv6_recv_rxpmtu(sk, msg, len);
+
         skb = skb_recv_datagram(sk, flags, noblock, &err);
         if (!skb)
                 goto out;
@@ -732,6 +736,7 @@ static int rawv6_sendmsg(struct kiocb *iocb, struct sock *sk,
         int addr_len = msg->msg_namelen;
         int hlimit = -1;
         int tclass = -1;
+        int dontfrag = -1;
         u16 proto;
         int err;
 
@@ -810,7 +815,8 @@ static int rawv6_sendmsg(struct kiocb *iocb, struct sock *sk,
                 memset(opt, 0, sizeof(struct ipv6_txoptions));
                 opt->tot_len = sizeof(struct ipv6_txoptions);
 
-                err = datagram_send_ctl(sock_net(sk), msg, &fl, opt, &hlimit, &tclass);
+                err = datagram_send_ctl(sock_net(sk), msg, &fl, opt, &hlimit,
+                                        &tclass, &dontfrag);
                 if (err < 0) {
                         fl6_sock_release(flowlabel);
                         return err;
@@ -879,6 +885,9 @@ static int rawv6_sendmsg(struct kiocb *iocb, struct sock *sk,
         if (tclass < 0)
                 tclass = np->tclass;
 
+        if (dontfrag < 0)
+                dontfrag = np->dontfrag;
+
         if (msg->msg_flags&MSG_CONFIRM)
                 goto do_confirm;
 
@@ -889,7 +898,7 @@ back_from_confirm:
                 lock_sock(sk);
                 err = ip6_append_data(sk, ip_generic_getfrag, msg->msg_iov,
                         len, 0, hlimit, tclass, opt, &fl, (struct rt6_info*)dst,
-                        msg->msg_flags);
+                        msg->msg_flags, dontfrag);
 
                 if (err)
                         ip6_flush_pending_frames(sk);
diff --git a/net/ipv6/reassembly.c b/net/ipv6/reassembly.c
index a555156e9779..6d4292ff5854 100644
--- a/net/ipv6/reassembly.c
+++ b/net/ipv6/reassembly.c
@@ -41,6 +41,7 @@
 #include <linux/random.h>
 #include <linux/jhash.h>
 #include <linux/skbuff.h>
+#include <linux/slab.h>
 
 #include <net/sock.h>
 #include <net/snmp.h>
diff --git a/net/ipv6/route.c b/net/ipv6/route.c
index 52cd3eff31dc..05ebd7833043 100644
--- a/net/ipv6/route.c
+++ b/net/ipv6/route.c
@@ -40,6 +40,7 @@
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
 #include <linux/nsproxy.h>
+#include <linux/slab.h>
 #include <net/net_namespace.h>
 #include <net/snmp.h>
 #include <net/ipv6.h>
@@ -814,7 +815,7 @@ struct dst_entry * ip6_route_output(struct net *net, struct sock *sk,
 {
         int flags = 0;
 
-        if (rt6_need_strict(&fl->fl6_dst))
+        if (fl->oif || rt6_need_strict(&fl->fl6_dst))
                 flags |= RT6_LOOKUP_F_IFACE;
 
         if (!ipv6_addr_any(&fl->fl6_src))
@@ -879,7 +880,7 @@ static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
 
         rt = (struct rt6_info *) dst;
 
-        if (rt && rt->rt6i_node && (rt->rt6i_node->fn_sernum == cookie))
+        if (rt->rt6i_node && (rt->rt6i_node->fn_sernum == cookie))
                 return dst;
 
         return NULL;
@@ -890,12 +891,17 @@ static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
         struct rt6_info *rt = (struct rt6_info *) dst;
 
         if (rt) {
-                if (rt->rt6i_flags & RTF_CACHE)
-                        ip6_del_rt(rt);
-                else
+                if (rt->rt6i_flags & RTF_CACHE) {
+                        if (rt6_check_expired(rt)) {
+                                ip6_del_rt(rt);
+                                dst = NULL;
+                        }
+                } else {
                         dst_release(dst);
+                        dst = NULL;
+                }
         }
-        return NULL;
+        return dst;
 }
 
 static void ip6_link_failure(struct sk_buff *skb)
diff --git a/net/ipv6/sit.c b/net/ipv6/sit.c
index b1eea811be48..5abae10cd884 100644
--- a/net/ipv6/sit.c
+++ b/net/ipv6/sit.c
@@ -28,6 +28,7 @@
 #include <linux/netdevice.h>
 #include <linux/if_arp.h>
 #include <linux/icmp.h>
+#include <linux/slab.h>
 #include <asm/uaccess.h>
 #include <linux/init.h>
 #include <linux/netfilter_ipv4.h>
diff --git a/net/ipv6/sysctl_net_ipv6.c b/net/ipv6/sysctl_net_ipv6.c
index f841d93bf987..fa1d8f4e0051 100644
--- a/net/ipv6/sysctl_net_ipv6.c
+++ b/net/ipv6/sysctl_net_ipv6.c
@@ -9,6 +9,7 @@
 #include <linux/sysctl.h>
 #include <linux/in6.h>
 #include <linux/ipv6.h>
+#include <linux/slab.h>
 #include <net/ndisc.h>
 #include <net/ipv6.h>
 #include <net/addrconf.h>
diff --git a/net/ipv6/tcp_ipv6.c b/net/ipv6/tcp_ipv6.c
index 9b6dbba80d31..6603511e3673 100644
--- a/net/ipv6/tcp_ipv6.c
+++ b/net/ipv6/tcp_ipv6.c
@@ -38,6 +38,7 @@
 #include <linux/jhash.h>
 #include <linux/ipsec.h>
 #include <linux/times.h>
+#include <linux/slab.h>
 
 #include <linux/ipv6.h>
 #include <linux/icmpv6.h>
@@ -74,6 +75,9 @@ static void	tcp_v6_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
                                       struct request_sock *req);
 
 static int      tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb);
+static void     __tcp_v6_send_check(struct sk_buff *skb,
+                                    struct in6_addr *saddr,
+                                    struct in6_addr *daddr);
 
 static const struct inet_connection_sock_af_ops ipv6_mapped;
 static const struct inet_connection_sock_af_ops ipv6_specific;
@@ -349,6 +353,11 @@ static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
         if (sk->sk_state == TCP_CLOSE)
                 goto out;
 
+        if (ipv6_hdr(skb)->hop_limit < inet6_sk(sk)->min_hopcount) {
+                NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
+                goto out;
+        }
+
         tp = tcp_sk(sk);
         seq = ntohl(th->seq);
         if (sk->sk_state != TCP_LISTEN &&
@@ -502,14 +511,10 @@ static int tcp_v6_send_synack(struct sock *sk, struct request_sock *req,
 
         skb = tcp_make_synack(sk, dst, req, rvp);
         if (skb) {
-                struct tcphdr *th = tcp_hdr(skb);
-
-                th->check = tcp_v6_check(skb->len,
-                                         &treq->loc_addr, &treq->rmt_addr,
-                                         csum_partial(th, skb->len, skb->csum));
+                __tcp_v6_send_check(skb, &treq->loc_addr, &treq->rmt_addr);
 
                 ipv6_addr_copy(&fl.fl6_dst, &treq->rmt_addr);
-                err = ip6_xmit(sk, skb, &fl, opt, 0);
+                err = ip6_xmit(sk, skb, &fl, opt);
                 err = net_xmit_eval(err);
         }
 
@@ -917,22 +922,29 @@ static struct timewait_sock_ops tcp6_timewait_sock_ops = {
         .twsk_destructor= tcp_twsk_destructor,
 };
 
-static void tcp_v6_send_check(struct sock *sk, int len, struct sk_buff *skb)
+static void __tcp_v6_send_check(struct sk_buff *skb,
+                                struct in6_addr *saddr, struct in6_addr *daddr)
 {
-        struct ipv6_pinfo *np = inet6_sk(sk);
         struct tcphdr *th = tcp_hdr(skb);
 
         if (skb->ip_summed == CHECKSUM_PARTIAL) {
-                th->check = ~csum_ipv6_magic(&np->saddr, &np->daddr, len, IPPROTO_TCP,  0);
+                th->check = ~tcp_v6_check(skb->len, saddr, daddr, 0);
                 skb->csum_start = skb_transport_header(skb) - skb->head;
                 skb->csum_offset = offsetof(struct tcphdr, check);
         } else {
-                th->check = csum_ipv6_magic(&np->saddr, &np->daddr, len, IPPROTO_TCP,
-                                            csum_partial(th, th->doff<<2,
-                                                         skb->csum));
+                th->check = tcp_v6_check(skb->len, saddr, daddr,
+                                         csum_partial(th, th->doff << 2,
+                                                      skb->csum));
         }
 }
 
+static void tcp_v6_send_check(struct sock *sk, struct sk_buff *skb)
+{
+        struct ipv6_pinfo *np = inet6_sk(sk);
+
+        __tcp_v6_send_check(skb, &np->saddr, &np->daddr);
+}
+
 static int tcp_v6_gso_send_check(struct sk_buff *skb)
 {
         struct ipv6hdr *ipv6h;
@@ -945,11 +957,8 @@ static int tcp_v6_gso_send_check(struct sk_buff *skb)
         th = tcp_hdr(skb);
 
         th->check = 0;
-        th->check = ~csum_ipv6_magic(&ipv6h->saddr, &ipv6h->daddr, skb->len,
-                                     IPPROTO_TCP, 0);
-        skb->csum_start = skb_transport_header(skb) - skb->head;
-        skb->csum_offset = offsetof(struct tcphdr, check);
         skb->ip_summed = CHECKSUM_PARTIAL;
+        __tcp_v6_send_check(skb, &ipv6h->saddr, &ipv6h->daddr);
         return 0;
 }
 
@@ -1014,7 +1023,7 @@ static void tcp_v6_send_response(struct sk_buff *skb, u32 seq, u32 ack, u32 win,
         skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr) + tot_len);
 
         t1 = (struct tcphdr *) skb_push(buff, tot_len);
-        skb_reset_transport_header(skb);
+        skb_reset_transport_header(buff);
 
         /* Swap the send and the receive. */
         memset(t1, 0, sizeof(*t1));
@@ -1046,15 +1055,14 @@ static void tcp_v6_send_response(struct sk_buff *skb, u32 seq, u32 ack, u32 win,
         }
 #endif
 
-        buff->csum = csum_partial(t1, tot_len, 0);
-
         memset(&fl, 0, sizeof(fl));
         ipv6_addr_copy(&fl.fl6_dst, &ipv6_hdr(skb)->saddr);
         ipv6_addr_copy(&fl.fl6_src, &ipv6_hdr(skb)->daddr);
 
-        t1->check = csum_ipv6_magic(&fl.fl6_src, &fl.fl6_dst,
-                                    tot_len, IPPROTO_TCP,
-                                    buff->csum);
+        buff->ip_summed = CHECKSUM_PARTIAL;
+        buff->csum = 0;
+
+        __tcp_v6_send_check(buff, &fl.fl6_src, &fl.fl6_dst);
 
         fl.proto = IPPROTO_TCP;
         fl.oif = inet6_iif(skb);
@@ -1069,7 +1077,7 @@ static void tcp_v6_send_response(struct sk_buff *skb, u32 seq, u32 ack, u32 win,
         if (!ip6_dst_lookup(ctl_sk, &dst, &fl)) {
                 if (xfrm_lookup(net, &dst, &fl, NULL, 0) >= 0) {
                         skb_dst_set(buff, dst);
-                        ip6_xmit(ctl_sk, buff, &fl, NULL, 0);
+                        ip6_xmit(ctl_sk, buff, &fl, NULL);
                         TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
                         if (rst)
                                 TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS);
@@ -1232,12 +1240,12 @@ static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
                         goto drop_and_free;
 
                 /* Secret recipe starts with IP addresses */
-                d = &ipv6_hdr(skb)->daddr.s6_addr32[0];
+                d = (__force u32 *)&ipv6_hdr(skb)->daddr.s6_addr32[0];
                 *mess++ ^= *d++;
                 *mess++ ^= *d++;
                 *mess++ ^= *d++;
                 *mess++ ^= *d++;
-                d = &ipv6_hdr(skb)->saddr.s6_addr32[0];
+                d = (__force u32 *)&ipv6_hdr(skb)->saddr.s6_addr32[0];
                 *mess++ ^= *d++;
                 *mess++ ^= *d++;
                 *mess++ ^= *d++;
@@ -1675,6 +1683,7 @@ ipv6_pktoptions:
 static int tcp_v6_rcv(struct sk_buff *skb)
 {
         struct tcphdr *th;
+        struct ipv6hdr *hdr;
         struct sock *sk;
         int ret;
         struct net *net = dev_net(skb->dev);
@@ -1701,12 +1710,13 @@ static int tcp_v6_rcv(struct sk_buff *skb)
                 goto bad_packet;
 
         th = tcp_hdr(skb);
+        hdr = ipv6_hdr(skb);
         TCP_SKB_CB(skb)->seq = ntohl(th->seq);
         TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
                                     skb->len - th->doff*4);
         TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
         TCP_SKB_CB(skb)->when = 0;
-        TCP_SKB_CB(skb)->flags = ipv6_get_dsfield(ipv6_hdr(skb));
+        TCP_SKB_CB(skb)->flags = ipv6_get_dsfield(hdr);
         TCP_SKB_CB(skb)->sacked = 0;
 
         sk = __inet6_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest);
@@ -1717,6 +1727,11 @@ process:
         if (sk->sk_state == TCP_TIME_WAIT)
                 goto do_time_wait;
 
+        if (hdr->hop_limit < inet6_sk(sk)->min_hopcount) {
+                NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
+                goto discard_and_relse;
+        }
+
         if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
                 goto discard_and_relse;
 
diff --git a/net/ipv6/tunnel6.c b/net/ipv6/tunnel6.c
index e17bc1dfc1a4..fc3c86a47452 100644
--- a/net/ipv6/tunnel6.c
+++ b/net/ipv6/tunnel6.c
@@ -25,6 +25,7 @@
 #include <linux/mutex.h>
 #include <linux/netdevice.h>
 #include <linux/skbuff.h>
+#include <linux/slab.h>
 #include <net/ipv6.h>
 #include <net/protocol.h>
 #include <net/xfrm.h>
diff --git a/net/ipv6/udp.c b/net/ipv6/udp.c
index 3c0c9c755c92..79359c8380bc 100644
--- a/net/ipv6/udp.c
+++ b/net/ipv6/udp.c
@@ -34,6 +34,7 @@
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/skbuff.h>
+#include <linux/slab.h>
 #include <asm/uaccess.h>
 
 #include <net/ndisc.h>
@@ -90,9 +91,9 @@ static unsigned int udp6_portaddr_hash(struct net *net,
         if (ipv6_addr_any(addr6))
                 hash = jhash_1word(0, mix);
         else if (ipv6_addr_v4mapped(addr6))
-                hash = jhash_1word(addr6->s6_addr32[3], mix);
+                hash = jhash_1word((__force u32)addr6->s6_addr32[3], mix);
         else
-                hash = jhash2(addr6->s6_addr32, 4, mix);
+                hash = jhash2((__force u32 *)addr6->s6_addr32, 4, mix);
 
         return hash ^ port;
 }
@@ -258,8 +259,8 @@ static struct sock *__udp6_lib_lookup(struct net *net,
                         if (hslot->count < hslot2->count)
                                 goto begin;
 
-                        result = udp6_lib_lookup2(net, &in6addr_any, sport,
-                                                  daddr, hnum, dif,
+                        result = udp6_lib_lookup2(net, saddr, sport,
+                                                  &in6addr_any, hnum, dif,
                                                   hslot2, slot2);
                 }
                 rcu_read_unlock();
@@ -334,6 +335,9 @@ int udpv6_recvmsg(struct kiocb *iocb, struct sock *sk,
         if (flags & MSG_ERRQUEUE)
                 return ipv6_recv_error(sk, msg, len);
 
+        if (np->rxpmtu && np->rxopt.bits.rxpmtu)
+                return ipv6_recv_rxpmtu(sk, msg, len);
+
 try_again:
         skb = __skb_recv_datagram(sk, flags | (noblock ? MSG_DONTWAIT : 0),
                                   &peeked, &err);
@@ -420,7 +424,7 @@ out:
         return err;
 
 csum_copy_err:
-        lock_sock(sk);
+        lock_sock_bh(sk);
         if (!skb_kill_datagram(sk, skb, flags)) {
                 if (is_udp4)
                         UDP_INC_STATS_USER(sock_net(sk),
@@ -429,7 +433,7 @@ csum_copy_err:
                         UDP6_INC_STATS_USER(sock_net(sk),
                                         UDP_MIB_INERRORS, is_udplite);
         }
-        release_sock(sk);
+        unlock_sock_bh(sk);
 
         if (flags & MSG_DONTWAIT)
                 return -EAGAIN;
@@ -510,7 +514,7 @@ int udpv6_queue_rcv_skb(struct sock * sk, struct sk_buff *skb)
                         goto drop;
         }
 
-        if ((rc = sock_queue_rcv_skb(sk, skb)) < 0) {
+        if ((rc = ip_queue_rcv_skb(sk, skb)) < 0) {
                 /* Note that an ENOMEM error is charged twice */
                 if (rc == -ENOMEM)
                         UDP6_INC_STATS_BH(sock_net(sk),
@@ -580,6 +584,10 @@ static void flush_stack(struct sock **stack, unsigned int count,
 
                 sk = stack[i];
                 if (skb1) {
+                        if (sk_rcvqueues_full(sk, skb)) {
+                                kfree_skb(skb1);
+                                goto drop;
+                        }
                         bh_lock_sock(sk);
                         if (!sock_owned_by_user(sk))
                                 udpv6_queue_rcv_skb(sk, skb1);
@@ -755,6 +763,10 @@ int __udp6_lib_rcv(struct sk_buff *skb, struct udp_table *udptable,
 
         /* deliver */
 
+        if (sk_rcvqueues_full(sk, skb)) {
+                sock_put(sk);
+                goto discard;
+        }
         bh_lock_sock(sk);
         if (!sock_owned_by_user(sk))
                 udpv6_queue_rcv_skb(sk, skb);
@@ -918,6 +930,7 @@ int udpv6_sendmsg(struct kiocb *iocb, struct sock *sk,
         int ulen = len;
         int hlimit = -1;
         int tclass = -1;
+        int dontfrag = -1;
         int corkreq = up->corkflag || msg->msg_flags&MSG_MORE;
         int err;
         int connected = 0;
@@ -1048,7 +1061,8 @@ do_udp_sendmsg:
                 memset(opt, 0, sizeof(struct ipv6_txoptions));
                 opt->tot_len = sizeof(*opt);
 
-                err = datagram_send_ctl(sock_net(sk), msg, &fl, opt, &hlimit, &tclass);
+                err = datagram_send_ctl(sock_net(sk), msg, &fl, opt, &hlimit,
+                                        &tclass, &dontfrag);
                 if (err < 0) {
                         fl6_sock_release(flowlabel);
                         return err;
@@ -1119,6 +1133,9 @@ do_udp_sendmsg:
         if (tclass < 0)
                 tclass = np->tclass;
 
+        if (dontfrag < 0)
+                dontfrag = np->dontfrag;
+
         if (msg->msg_flags&MSG_CONFIRM)
                 goto do_confirm;
 back_from_confirm:
@@ -1142,7 +1159,7 @@ do_append_data:
         err = ip6_append_data(sk, getfrag, msg->msg_iov, ulen,
                 sizeof(struct udphdr), hlimit, tclass, opt, &fl,
                 (struct rt6_info*)dst,
-                corkreq ? msg->msg_flags|MSG_MORE : msg->msg_flags);
+                corkreq ? msg->msg_flags|MSG_MORE : msg->msg_flags, dontfrag);
         if (err)
                 udp_v6_flush_pending_frames(sk);
         else if (!corkreq)
diff --git a/net/ipv6/xfrm6_mode_tunnel.c b/net/ipv6/xfrm6_mode_tunnel.c
index 3927832227b9..b809812c8d30 100644
--- a/net/ipv6/xfrm6_mode_tunnel.c
+++ b/net/ipv6/xfrm6_mode_tunnel.c
@@ -5,6 +5,7 @@
  * Copyright (c) 2004-2006 Herbert Xu <herbert@gondor.apana.org.au>
  */
 
+#include <linux/gfp.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
diff --git a/net/ipv6/xfrm6_policy.c b/net/ipv6/xfrm6_policy.c
index ae181651c75a..4a0e77e14468 100644
--- a/net/ipv6/xfrm6_policy.c
+++ b/net/ipv6/xfrm6_policy.c
@@ -67,36 +67,6 @@ static int xfrm6_get_saddr(struct net *net,
         return 0;
 }
 
-static struct dst_entry *
-__xfrm6_find_bundle(struct flowi *fl, struct xfrm_policy *policy)
-{
-        struct dst_entry *dst;
-
-        /* Still not clear if we should set fl->fl6_{src,dst}... */
-        read_lock_bh(&policy->lock);
-        for (dst = policy->bundles; dst; dst = dst->next) {
-                struct xfrm_dst *xdst = (struct xfrm_dst*)dst;
-                struct in6_addr fl_dst_prefix, fl_src_prefix;
-
-                ipv6_addr_prefix(&fl_dst_prefix,
-                                 &fl->fl6_dst,
-                                 xdst->u.rt6.rt6i_dst.plen);
-                ipv6_addr_prefix(&fl_src_prefix,
-                                 &fl->fl6_src,
-                                 xdst->u.rt6.rt6i_src.plen);
-                if (ipv6_addr_equal(&xdst->u.rt6.rt6i_dst.addr, &fl_dst_prefix) &&
-                    ipv6_addr_equal(&xdst->u.rt6.rt6i_src.addr, &fl_src_prefix) &&
-                    xfrm_bundle_ok(policy, xdst, fl, AF_INET6,
-                                   (xdst->u.rt6.rt6i_dst.plen != 128 ||
-                                    xdst->u.rt6.rt6i_src.plen != 128))) {
-                        dst_clone(dst);
-                        break;
-                }
-        }
-        read_unlock_bh(&policy->lock);
-        return dst;
-}
-
 static int xfrm6_get_tos(struct flowi *fl)
 {
         return 0;
@@ -124,7 +94,7 @@ static int xfrm6_fill_dst(struct xfrm_dst *xdst, struct net_device *dev,
         xdst->u.dst.dev = dev;
         dev_hold(dev);
 
-        xdst->u.rt6.rt6i_idev = in6_dev_get(rt->u.dst.dev);
+        xdst->u.rt6.rt6i_idev = in6_dev_get(dev);
         if (!xdst->u.rt6.rt6i_idev)
                 return -ENODEV;
 
@@ -291,7 +261,6 @@ static struct xfrm_policy_afinfo xfrm6_policy_afinfo = {
         .dst_ops =              &xfrm6_dst_ops,
         .dst_lookup =           xfrm6_dst_lookup,
         .get_saddr =            xfrm6_get_saddr,
-        .find_bundle =          __xfrm6_find_bundle,
         .decode_session =       _decode_session6,
         .get_tos =              xfrm6_get_tos,
         .init_path =            xfrm6_init_path,
diff --git a/net/ipv6/xfrm6_tunnel.c b/net/ipv6/xfrm6_tunnel.c
index fa85a7d22dc4..2ce3a8278f26 100644
--- a/net/ipv6/xfrm6_tunnel.c
+++ b/net/ipv6/xfrm6_tunnel.c
@@ -23,6 +23,7 @@
  */
 #include <linux/module.h>
 #include <linux/xfrm.h>
+#include <linux/slab.h>
 #include <linux/rculist.h>
 #include <net/ip.h>
 #include <net/xfrm.h>
diff --git a/net/ipx/af_ipx.c b/net/ipx/af_ipx.c
index f9759b54a6de..da3d21c41d90 100644
--- a/net/ipx/af_ipx.c
+++ b/net/ipx/af_ipx.c
@@ -40,6 +40,7 @@
 #include <linux/net.h>
 #include <linux/netdevice.h>
 #include <linux/uio.h>
+#include <linux/slab.h>
 #include <linux/skbuff.h>
 #include <linux/smp_lock.h>
 #include <linux/socket.h>
diff --git a/net/ipx/ipx_route.c b/net/ipx/ipx_route.c
index e16c11423527..30f4519b092f 100644
--- a/net/ipx/ipx_route.c
+++ b/net/ipx/ipx_route.c
@@ -9,6 +9,7 @@
 
 #include <linux/list.h>
 #include <linux/route.h>
+#include <linux/slab.h>
 #include <linux/spinlock.h>
 
 #include <net/ipx.h>
diff --git a/net/irda/af_irda.c b/net/irda/af_irda.c
index 10093aab6173..79986a674f6e 100644
--- a/net/irda/af_irda.c
+++ b/net/irda/af_irda.c
@@ -48,6 +48,7 @@
 #include <linux/smp_lock.h>
 #include <linux/socket.h>
 #include <linux/sockios.h>
+#include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/net.h>
 #include <linux/irda.h>
@@ -346,7 +347,7 @@ static void irda_flow_indication(void *instance, void *sap, LOCAL_FLOW flow)
                 self->tx_flow = flow;
                 IRDA_DEBUG(1, "%s(), IrTTP wants us to start again\n",
                            __func__);
-                wake_up_interruptible(sk->sk_sleep);
+                wake_up_interruptible(sk_sleep(sk));
                 break;
         default:
                 IRDA_DEBUG(0, "%s(), Unknown flow command!\n", __func__);
@@ -899,7 +900,7 @@ static int irda_accept(struct socket *sock, struct socket *newsock, int flags)
                 if (flags & O_NONBLOCK)
                         goto out;
 
-                err = wait_event_interruptible(*(sk->sk_sleep),
+                err = wait_event_interruptible(*(sk_sleep(sk)),
                                         skb_peek(&sk->sk_receive_queue));
                 if (err)
                         goto out;
@@ -1065,7 +1066,7 @@ static int irda_connect(struct socket *sock, struct sockaddr *uaddr,
                 goto out;
 
         err = -ERESTARTSYS;
-        if (wait_event_interruptible(*(sk->sk_sleep),
+        if (wait_event_interruptible(*(sk_sleep(sk)),
                                      (sk->sk_state != TCP_SYN_SENT)))
                 goto out;
 
@@ -1317,7 +1318,7 @@ static int irda_sendmsg(struct kiocb *iocb, struct socket *sock,
 
         /* Check if IrTTP is wants us to slow down */
 
-        if (wait_event_interruptible(*(sk->sk_sleep),
+        if (wait_event_interruptible(*(sk_sleep(sk)),
             (self->tx_flow != FLOW_STOP  ||  sk->sk_state != TCP_ESTABLISHED))) {
                 err = -ERESTARTSYS;
                 goto out;
@@ -1476,7 +1477,7 @@ static int irda_recvmsg_stream(struct kiocb *iocb, struct socket *sock,
                         if (copied >= target)
                                 break;
 
-                        prepare_to_wait_exclusive(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+                        prepare_to_wait_exclusive(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
 
                         /*
                          *      POSIX 1003.1g mandates this order.
@@ -1496,7 +1497,7 @@ static int irda_recvmsg_stream(struct kiocb *iocb, struct socket *sock,
                                 /* Wait process until data arrives */
                                 schedule();
 
-                        finish_wait(sk->sk_sleep, &wait);
+                        finish_wait(sk_sleep(sk), &wait);
 
                         if (err)
                                 goto out;
@@ -1786,7 +1787,7 @@ static unsigned int irda_poll(struct file * file, struct socket *sock,
         IRDA_DEBUG(4, "%s()\n", __func__);
 
         lock_kernel();
-        poll_wait(file, sk->sk_sleep, wait);
+        poll_wait(file, sk_sleep(sk), wait);
         mask = 0;
 
         /* Exceptional events? */
diff --git a/net/irda/discovery.c b/net/irda/discovery.c
index a6f99b5a1499..c1c8ae939126 100644
--- a/net/irda/discovery.c
+++ b/net/irda/discovery.c
@@ -34,6 +34,7 @@
 #include <linux/socket.h>
 #include <linux/fs.h>
 #include <linux/seq_file.h>
+#include <linux/slab.h>
 
 #include <net/irda/irda.h>
 #include <net/irda/irlmp.h>
diff --git a/net/irda/ircomm/ircomm_core.c b/net/irda/ircomm/ircomm_core.c
index 018c92941aba..e97082017f4f 100644
--- a/net/irda/ircomm/ircomm_core.c
+++ b/net/irda/ircomm/ircomm_core.c
@@ -33,6 +33,7 @@
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 
 #include <net/irda/irda.h>
 #include <net/irda/irmod.h>
diff --git a/net/irda/ircomm/ircomm_lmp.c b/net/irda/ircomm/ircomm_lmp.c
index 7ba96618660e..08fb54dc8c41 100644
--- a/net/irda/ircomm/ircomm_lmp.c
+++ b/net/irda/ircomm/ircomm_lmp.c
@@ -31,6 +31,7 @@
  ********************************************************************/
 
 #include <linux/init.h>
+#include <linux/gfp.h>
 
 #include <net/irda/irda.h>
 #include <net/irda/irlmp.h>
diff --git a/net/irda/ircomm/ircomm_param.c b/net/irda/ircomm/ircomm_param.c
index d57aefd9fe77..8b915f3ac3b9 100644
--- a/net/irda/ircomm/ircomm_param.c
+++ b/net/irda/ircomm/ircomm_param.c
@@ -28,6 +28,7 @@
  *
  ********************************************************************/
 
+#include <linux/gfp.h>
 #include <linux/workqueue.h>
 #include <linux/interrupt.h>
 
@@ -474,7 +475,7 @@ static int ircomm_param_dce(void *instance, irda_param_t *param, int get)
         /* Check if any of the settings have changed */
         if (dce & 0x0f) {
                 if (dce & IRCOMM_DELTA_CTS) {
-                        IRDA_DEBUG(2, "%s(), CTS \n", __func__ );
+                        IRDA_DEBUG(2, "%s(), CTS\n", __func__ );
                 }
         }
 
diff --git a/net/irda/ircomm/ircomm_tty.c b/net/irda/ircomm/ircomm_tty.c
index 8b85d774e47f..faa82ca2dfdc 100644
--- a/net/irda/ircomm/ircomm_tty.c
+++ b/net/irda/ircomm/ircomm_tty.c
@@ -33,6 +33,7 @@
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/fs.h>
+#include <linux/slab.h>
 #include <linux/sched.h>
 #include <linux/seq_file.h>
 #include <linux/termios.h>
diff --git a/net/irda/irda_device.c b/net/irda/irda_device.c
index bf92e1473447..25cc2e695158 100644
--- a/net/irda/irda_device.c
+++ b/net/irda/irda_device.c
@@ -41,6 +41,7 @@
 #include <linux/tty.h>
 #include <linux/kmod.h>
 #include <linux/spinlock.h>
+#include <linux/slab.h>
 
 #include <asm/ioctls.h>
 #include <asm/uaccess.h>
diff --git a/net/irda/iriap.c b/net/irda/iriap.c
index 294e34d3517c..79a1e5a23e10 100644
--- a/net/irda/iriap.c
+++ b/net/irda/iriap.c
@@ -31,6 +31,7 @@
 #include <linux/string.h>
 #include <linux/init.h>
 #include <linux/seq_file.h>
+#include <linux/slab.h>
 
 #include <asm/byteorder.h>
 #include <asm/unaligned.h>
diff --git a/net/irda/iriap_event.c b/net/irda/iriap_event.c
index a301cbd93785..703774e29e32 100644
--- a/net/irda/iriap_event.c
+++ b/net/irda/iriap_event.c
@@ -24,6 +24,8 @@
  *
  ********************************************************************/
 
+#include <linux/slab.h>
+
 #include <net/irda/irda.h>
 #include <net/irda/irlmp.h>
 #include <net/irda/iriap.h>
diff --git a/net/irda/irias_object.c b/net/irda/irias_object.c
index 99ebb96f1386..f07ed9fd5792 100644
--- a/net/irda/irias_object.c
+++ b/net/irda/irias_object.c
@@ -22,6 +22,7 @@
  *
  ********************************************************************/
 
+#include <linux/slab.h>
 #include <linux/string.h>
 #include <linux/socket.h>
 #include <linux/module.h>
diff --git a/net/irda/irlan/irlan_client.c b/net/irda/irlan/irlan_client.c
index 42f7d960d055..7ed3af957935 100644
--- a/net/irda/irlan/irlan_client.c
+++ b/net/irda/irlan/irlan_client.c
@@ -28,6 +28,7 @@
 
 #include <linux/kernel.h>
 #include <linux/string.h>
+#include <linux/slab.h>
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/netdevice.h>
diff --git a/net/irda/irlan/irlan_common.c b/net/irda/irlan/irlan_common.c
index e486dc89ea59..a788f9e9427d 100644
--- a/net/irda/irlan/irlan_common.c
+++ b/net/irda/irlan/irlan_common.c
@@ -27,6 +27,7 @@
 
 #include <linux/kernel.h>
 #include <linux/string.h>
+#include <linux/gfp.h>
 #include <linux/init.h>
 #include <linux/errno.h>
 #include <linux/proc_fs.h>
diff --git a/net/irda/irlan/irlan_provider.c b/net/irda/irlan/irlan_provider.c
index 3f81f81b2dfa..5cf5e6c872bb 100644
--- a/net/irda/irlan/irlan_provider.c
+++ b/net/irda/irlan/irlan_provider.c
@@ -34,6 +34,7 @@
 #include <linux/init.h>
 #include <linux/random.h>
 #include <linux/bitops.h>
+#include <linux/slab.h>
 
 #include <asm/system.h>
 #include <asm/byteorder.h>
diff --git a/net/irda/irlap_event.c b/net/irda/irlap_event.c
index 94a9884d7146..d434c8880745 100644
--- a/net/irda/irlap_event.c
+++ b/net/irda/irlap_event.c
@@ -29,6 +29,7 @@
 #include <linux/kernel.h>
 #include <linux/delay.h>
 #include <linux/skbuff.h>
+#include <linux/slab.h>
 
 #include <net/irda/irda.h>
 #include <net/irda/irlap_event.h>
diff --git a/net/irda/irlap_frame.c b/net/irda/irlap_frame.c
index 7af2e74deda8..688222cbf55b 100644
--- a/net/irda/irlap_frame.c
+++ b/net/irda/irlap_frame.c
@@ -29,6 +29,7 @@
 #include <linux/if_ether.h>
 #include <linux/netdevice.h>
 #include <linux/irda.h>
+#include <linux/slab.h>
 
 #include <net/pkt_sched.h>
 #include <net/sock.h>
diff --git a/net/irda/irnet/irnet_irda.c b/net/irda/irnet/irnet_irda.c
index b26dee784aba..df18ab4b6c5e 100644
--- a/net/irda/irnet/irnet_irda.c
+++ b/net/irda/irnet/irnet_irda.c
@@ -11,6 +11,7 @@
 #include "irnet_irda.h"         /* Private header */
 #include <linux/sched.h>
 #include <linux/seq_file.h>
+#include <linux/slab.h>
 #include <asm/unaligned.h>
 
 /*
diff --git a/net/irda/irnet/irnet_ppp.c b/net/irda/irnet/irnet_ppp.c
index 6b3602de359a..6a1a202710c5 100644
--- a/net/irda/irnet/irnet_ppp.c
+++ b/net/irda/irnet/irnet_ppp.c
@@ -14,6 +14,7 @@
  */
 
 #include <linux/sched.h>
+#include <linux/slab.h>
 #include <linux/smp_lock.h>
 #include "irnet_ppp.h"          /* Private header */
 /* Please put other headers in irnet.h - Thanks */
diff --git a/net/irda/irnetlink.c b/net/irda/irnetlink.c
index 69b5b75f5431..6c7c4b92e4f8 100644
--- a/net/irda/irnetlink.c
+++ b/net/irda/irnetlink.c
@@ -15,6 +15,7 @@
 
 #include <linux/socket.h>
 #include <linux/irda.h>
+#include <linux/gfp.h>
 #include <net/net_namespace.h>
 #include <net/sock.h>
 #include <net/irda/irda.h>
diff --git a/net/irda/irqueue.c b/net/irda/irqueue.c
index ba01938becb5..849aaf0dabb5 100644
--- a/net/irda/irqueue.c
+++ b/net/irda/irqueue.c
@@ -192,6 +192,7 @@
  * Jean II
  */
 #include <linux/module.h>
+#include <linux/slab.h>
 
 #include <net/irda/irda.h>
 #include <net/irda/irqueue.h>
diff --git a/net/irda/irttp.c b/net/irda/irttp.c
index 9cb79f95bf63..47db1d8a0d92 100644
--- a/net/irda/irttp.c
+++ b/net/irda/irttp.c
@@ -28,6 +28,7 @@
 #include <linux/init.h>
 #include <linux/fs.h>
 #include <linux/seq_file.h>
+#include <linux/slab.h>
 
 #include <asm/byteorder.h>
 #include <asm/unaligned.h>
diff --git a/net/iucv/af_iucv.c b/net/iucv/af_iucv.c
index c18286a2167b..8be324fe08b9 100644
--- a/net/iucv/af_iucv.c
+++ b/net/iucv/af_iucv.c
@@ -59,7 +59,7 @@ do {									\
         DEFINE_WAIT(__wait);                                            \
         long __timeo = timeo;                                           \
         ret = 0;                                                        \
-        prepare_to_wait(sk->sk_sleep, &__wait, TASK_INTERRUPTIBLE);     \
+        prepare_to_wait(sk_sleep(sk), &__wait, TASK_INTERRUPTIBLE);     \
         while (!(condition)) {                                          \
                 if (!__timeo) {                                         \
                         ret = -EAGAIN;                                  \
@@ -76,7 +76,7 @@ do {									\
                 if (ret)                                                \
                         break;                                          \
         }                                                               \
-        finish_wait(sk->sk_sleep, &__wait);                             \
+        finish_wait(sk_sleep(sk), &__wait);                             \
 } while (0)
 
 #define iucv_sock_wait(sk, condition, timeo)                            \
@@ -305,11 +305,14 @@ static inline int iucv_below_msglim(struct sock *sk)
  */
 static void iucv_sock_wake_msglim(struct sock *sk)
 {
-        read_lock(&sk->sk_callback_lock);
-        if (sk_has_sleeper(sk))
-                wake_up_interruptible_all(sk->sk_sleep);
+        struct socket_wq *wq;
+
+        rcu_read_lock();
+        wq = rcu_dereference(sk->sk_wq);
+        if (wq_has_sleeper(wq))
+                wake_up_interruptible_all(&wq->wait);
         sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
-        read_unlock(&sk->sk_callback_lock);
+        rcu_read_unlock();
 }
 
 /* Timers */
@@ -795,7 +798,7 @@ static int iucv_sock_accept(struct socket *sock, struct socket *newsock,
         timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
 
         /* Wait for an incoming connection */
-        add_wait_queue_exclusive(sk->sk_sleep, &wait);
+        add_wait_queue_exclusive(sk_sleep(sk), &wait);
         while (!(nsk = iucv_accept_dequeue(sk, newsock))) {
                 set_current_state(TASK_INTERRUPTIBLE);
                 if (!timeo) {
@@ -819,7 +822,7 @@ static int iucv_sock_accept(struct socket *sock, struct socket *newsock,
         }
 
         set_current_state(TASK_RUNNING);
-        remove_wait_queue(sk->sk_sleep, &wait);
+        remove_wait_queue(sk_sleep(sk), &wait);
 
         if (err)
                 goto done;
@@ -1269,7 +1272,7 @@ unsigned int iucv_sock_poll(struct file *file, struct socket *sock,
         struct sock *sk = sock->sk;
         unsigned int mask = 0;
 
-        sock_poll_wait(file, sk->sk_sleep, wait);
+        sock_poll_wait(file, sk_sleep(sk), wait);
 
         if (sk->sk_state == IUCV_LISTEN)
                 return iucv_accept_poll(sk);
diff --git a/net/key/af_key.c b/net/key/af_key.c
index 368707882647..ba9a3fcc2fed 100644
--- a/net/key/af_key.c
+++ b/net/key/af_key.c
@@ -26,6 +26,7 @@
 #include <linux/in6.h>
 #include <linux/proc_fs.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <net/net_namespace.h>
 #include <net/netns/generic.h>
 #include <net/xfrm.h>
@@ -2129,10 +2130,9 @@ static int key_notify_policy(struct xfrm_policy *xp, int dir, struct km_event *c
         int err;
 
         out_skb = pfkey_xfrm_policy2msg_prep(xp);
-        if (IS_ERR(out_skb)) {
-                err = PTR_ERR(out_skb);
-                goto out;
-        }
+        if (IS_ERR(out_skb))
+                return PTR_ERR(out_skb);
+
         err = pfkey_xfrm_policy2msg(out_skb, xp, dir);
         if (err < 0)
                 return err;
@@ -2148,7 +2148,6 @@ static int key_notify_policy(struct xfrm_policy *xp, int dir, struct km_event *c
         out_hdr->sadb_msg_seq = c->seq;
         out_hdr->sadb_msg_pid = c->pid;
         pfkey_broadcast(out_skb, GFP_ATOMIC, BROADCAST_ALL, NULL, xp_net(xp));
-out:
         return 0;
 
 }
diff --git a/net/l2tp/Kconfig b/net/l2tp/Kconfig
new file mode 100644
index 000000000000..4b1e71751e10
--- /dev/null
+++ b/net/l2tp/Kconfig
@@ -0,0 +1,107 @@
+#
+# Layer Two Tunneling Protocol (L2TP)
+#
+
+menuconfig L2TP
+        tristate "Layer Two Tunneling Protocol (L2TP)"
+        depends on INET
+        ---help---
+          Layer Two Tunneling Protocol
+
+          From RFC 2661 <http://www.ietf.org/rfc/rfc2661.txt>.
+
+          L2TP facilitates the tunneling of packets across an
+          intervening network in a way that is as transparent as
+          possible to both end-users and applications.
+
+          L2TP is often used to tunnel PPP traffic over IP
+          tunnels. One IP tunnel may carry thousands of individual PPP
+          connections. L2TP is also used as a VPN protocol, popular
+          with home workers to connect to their offices.
+
+          L2TPv3 allows other protocols as well as PPP to be carried
+          over L2TP tunnels. L2TPv3 is defined in RFC 3931
+          <http://www.ietf.org/rfc/rfc3931.txt>.
+
+          The kernel component handles only L2TP data packets: a
+          userland daemon handles L2TP the control protocol (tunnel
+          and session setup). One such daemon is OpenL2TP
+          (http://openl2tp.org/).
+
+          If you don't need L2TP, say N. To compile all L2TP code as
+          modules, choose M here.
+
+config L2TP_DEBUGFS
+        tristate "L2TP debugfs support"
+        depends on L2TP && DEBUG_FS
+        help
+          Support for l2tp directory in debugfs filesystem. This may be
+          used to dump internal state of the l2tp drivers for problem
+          analysis.
+
+          If unsure, say 'Y'.
+
+          To compile this driver as a module, choose M here. The module
+          will be called l2tp_debugfs.
+
+config L2TP_V3
+        bool "L2TPv3 support (EXPERIMENTAL)"
+        depends on EXPERIMENTAL && L2TP
+        help
+          Layer Two Tunneling Protocol Version 3
+
+          From RFC 3931 <http://www.ietf.org/rfc/rfc3931.txt>.
+
+          The Layer Two Tunneling Protocol (L2TP) provides a dynamic
+          mechanism for tunneling Layer 2 (L2) "circuits" across a
+          packet-oriented data network (e.g., over IP).  L2TP, as
+          originally defined in RFC 2661, is a standard method for
+          tunneling Point-to-Point Protocol (PPP) [RFC1661] sessions.
+          L2TP has since been adopted for tunneling a number of other
+          L2 protocols, including ATM, Frame Relay, HDLC and even raw
+          ethernet frames.
+
+          If you are connecting to L2TPv3 equipment, or you want to
+          tunnel raw ethernet frames using L2TP, say Y here. If
+          unsure, say N.
+
+config L2TP_IP
+        tristate "L2TP IP encapsulation for L2TPv3"
+        depends on L2TP_V3
+        help
+          Support for L2TP-over-IP socket family.
+
+          The L2TPv3 protocol defines two possible encapsulations for
+          L2TP frames, namely UDP and plain IP (without UDP). This
+          driver provides a new L2TPIP socket family with which
+          userspace L2TPv3 daemons may create L2TP/IP tunnel sockets
+          when UDP encapsulation is not required. When L2TP is carried
+          in IP packets, it used IP protocol number 115, so this port
+          must be enabled in firewalls.
+
+          To compile this driver as a module, choose M here. The module
+          will be called l2tp_ip.
+
+config L2TP_ETH
+        tristate "L2TP ethernet pseudowire support for L2TPv3"
+        depends on L2TP_V3
+        help
+          Support for carrying raw ethernet frames over L2TPv3.
+
+          From RFC 4719 <http://www.ietf.org/rfc/rfc4719.txt>.
+
+          The Layer 2 Tunneling Protocol, Version 3 (L2TPv3) can be
+          used as a control protocol and for data encapsulation to set
+          up Pseudowires for transporting layer 2 Packet Data Units
+          across an IP network [RFC3931].
+
+          This driver provides an ethernet virtual interface for each
+          L2TP ethernet pseudowire instance. Standard Linux tools may
+          be used to assign an IP address to the local virtual
+          interface, or add the interface to a bridge.
+
+          If you are using L2TPv3, you will almost certainly want to
+          enable this option.
+
+          To compile this driver as a module, choose M here. The module
+          will be called l2tp_eth.
diff --git a/net/l2tp/Makefile b/net/l2tp/Makefile
new file mode 100644
index 000000000000..110e7bc2de5e
--- /dev/null
+++ b/net/l2tp/Makefile
@@ -0,0 +1,12 @@
+#
+# Makefile for the L2TP.
+#
+
+obj-$(CONFIG_L2TP) += l2tp_core.o
+
+# Build l2tp as modules if L2TP is M
+obj-$(subst y,$(CONFIG_L2TP),$(CONFIG_PPPOL2TP)) += l2tp_ppp.o
+obj-$(subst y,$(CONFIG_L2TP),$(CONFIG_L2TP_IP)) += l2tp_ip.o
+obj-$(subst y,$(CONFIG_L2TP),$(CONFIG_L2TP_V3)) += l2tp_netlink.o
+obj-$(subst y,$(CONFIG_L2TP),$(CONFIG_L2TP_ETH)) += l2tp_eth.o
+obj-$(subst y,$(CONFIG_L2TP),$(CONFIG_L2TP_DEBUGFS)) += l2tp_debugfs.o
diff --git a/net/l2tp/l2tp_core.c b/net/l2tp/l2tp_core.c
new file mode 100644
index 000000000000..1712af1c7b3f
--- /dev/null
+++ b/net/l2tp/l2tp_core.c
@@ -0,0 +1,1666 @@
+/*
+ * L2TP core.
+ *
+ * Copyright (c) 2008,2009,2010 Katalix Systems Ltd
+ *
+ * This file contains some code of the original L2TPv2 pppol2tp
+ * driver, which has the following copyright:
+ *
+ * Authors:     Martijn van Oosterhout <kleptog@svana.org>
+ *              James Chapman (jchapman@katalix.com)
+ * Contributors:
+ *              Michal Ostrowski <mostrows@speakeasy.net>
+ *              Arnaldo Carvalho de Melo <acme@xconectiva.com.br>
+ *              David S. Miller (davem@redhat.com)
+ *
+ * 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.
+ */
+
+#include <linux/module.h>
+#include <linux/string.h>
+#include <linux/list.h>
+#include <linux/rculist.h>
+#include <linux/uaccess.h>
+
+#include <linux/kernel.h>
+#include <linux/spinlock.h>
+#include <linux/kthread.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
+#include <linux/errno.h>
+#include <linux/jiffies.h>
+
+#include <linux/netdevice.h>
+#include <linux/net.h>
+#include <linux/inetdevice.h>
+#include <linux/skbuff.h>
+#include <linux/init.h>
+#include <linux/in.h>
+#include <linux/ip.h>
+#include <linux/udp.h>
+#include <linux/l2tp.h>
+#include <linux/hash.h>
+#include <linux/sort.h>
+#include <linux/file.h>
+#include <linux/nsproxy.h>
+#include <net/net_namespace.h>
+#include <net/netns/generic.h>
+#include <net/dst.h>
+#include <net/ip.h>
+#include <net/udp.h>
+#include <net/inet_common.h>
+#include <net/xfrm.h>
+#include <net/protocol.h>
+
+#include <asm/byteorder.h>
+#include <asm/atomic.h>
+
+#include "l2tp_core.h"
+
+#define L2TP_DRV_VERSION        "V2.0"
+
+/* L2TP header constants */
+#define L2TP_HDRFLAG_T     0x8000
+#define L2TP_HDRFLAG_L     0x4000
+#define L2TP_HDRFLAG_S     0x0800
+#define L2TP_HDRFLAG_O     0x0200
+#define L2TP_HDRFLAG_P     0x0100
+
+#define L2TP_HDR_VER_MASK  0x000F
+#define L2TP_HDR_VER_2     0x0002
+#define L2TP_HDR_VER_3     0x0003
+
+/* L2TPv3 default L2-specific sublayer */
+#define L2TP_SLFLAG_S      0x40000000
+#define L2TP_SL_SEQ_MASK   0x00ffffff
+
+#define L2TP_HDR_SIZE_SEQ               10
+#define L2TP_HDR_SIZE_NOSEQ             6
+
+/* Default trace flags */
+#define L2TP_DEFAULT_DEBUG_FLAGS        0
+
+#define PRINTK(_mask, _type, _lvl, _fmt, args...)                       \
+        do {                                                            \
+                if ((_mask) & (_type))                                  \
+                        printk(_lvl "L2TP: " _fmt, ##args);             \
+        } while (0)
+
+/* Private data stored for received packets in the skb.
+ */
+struct l2tp_skb_cb {
+        u32                     ns;
+        u16                     has_seq;
+        u16                     length;
+        unsigned long           expires;
+};
+
+#define L2TP_SKB_CB(skb)        ((struct l2tp_skb_cb *) &skb->cb[sizeof(struct inet_skb_parm)])
+
+static atomic_t l2tp_tunnel_count;
+static atomic_t l2tp_session_count;
+
+/* per-net private data for this module */
+static unsigned int l2tp_net_id;
+struct l2tp_net {
+        struct list_head l2tp_tunnel_list;
+        spinlock_t l2tp_tunnel_list_lock;
+        struct hlist_head l2tp_session_hlist[L2TP_HASH_SIZE_2];
+        spinlock_t l2tp_session_hlist_lock;
+};
+
+static inline struct l2tp_net *l2tp_pernet(struct net *net)
+{
+        BUG_ON(!net);
+
+        return net_generic(net, l2tp_net_id);
+}
+
+/* Session hash global list for L2TPv3.
+ * The session_id SHOULD be random according to RFC3931, but several
+ * L2TP implementations use incrementing session_ids.  So we do a real
+ * hash on the session_id, rather than a simple bitmask.
+ */
+static inline struct hlist_head *
+l2tp_session_id_hash_2(struct l2tp_net *pn, u32 session_id)
+{
+        return &pn->l2tp_session_hlist[hash_32(session_id, L2TP_HASH_BITS_2)];
+
+}
+
+/* Lookup a session by id in the global session list
+ */
+static struct l2tp_session *l2tp_session_find_2(struct net *net, u32 session_id)
+{
+        struct l2tp_net *pn = l2tp_pernet(net);
+        struct hlist_head *session_list =
+                l2tp_session_id_hash_2(pn, session_id);
+        struct l2tp_session *session;
+        struct hlist_node *walk;
+
+        rcu_read_lock_bh();
+        hlist_for_each_entry_rcu(session, walk, session_list, global_hlist) {
+                if (session->session_id == session_id) {
+                        rcu_read_unlock_bh();
+                        return session;
+                }
+        }
+        rcu_read_unlock_bh();
+
+        return NULL;
+}
+
+/* Session hash list.
+ * The session_id SHOULD be random according to RFC2661, but several
+ * L2TP implementations (Cisco and Microsoft) use incrementing
+ * session_ids.  So we do a real hash on the session_id, rather than a
+ * simple bitmask.
+ */
+static inline struct hlist_head *
+l2tp_session_id_hash(struct l2tp_tunnel *tunnel, u32 session_id)
+{
+        return &tunnel->session_hlist[hash_32(session_id, L2TP_HASH_BITS)];
+}
+
+/* Lookup a session by id
+ */
+struct l2tp_session *l2tp_session_find(struct net *net, struct l2tp_tunnel *tunnel, u32 session_id)
+{
+        struct hlist_head *session_list;
+        struct l2tp_session *session;
+        struct hlist_node *walk;
+
+        /* In L2TPv3, session_ids are unique over all tunnels and we
+         * sometimes need to look them up before we know the
+         * tunnel.
+         */
+        if (tunnel == NULL)
+                return l2tp_session_find_2(net, session_id);
+
+        session_list = l2tp_session_id_hash(tunnel, session_id);
+        read_lock_bh(&tunnel->hlist_lock);
+        hlist_for_each_entry(session, walk, session_list, hlist) {
+                if (session->session_id == session_id) {
+                        read_unlock_bh(&tunnel->hlist_lock);
+                        return session;
+                }
+        }
+        read_unlock_bh(&tunnel->hlist_lock);
+
+        return NULL;
+}
+EXPORT_SYMBOL_GPL(l2tp_session_find);
+
+struct l2tp_session *l2tp_session_find_nth(struct l2tp_tunnel *tunnel, int nth)
+{
+        int hash;
+        struct hlist_node *walk;
+        struct l2tp_session *session;
+        int count = 0;
+
+        read_lock_bh(&tunnel->hlist_lock);
+        for (hash = 0; hash < L2TP_HASH_SIZE; hash++) {
+                hlist_for_each_entry(session, walk, &tunnel->session_hlist[hash], hlist) {
+                        if (++count > nth) {
+                                read_unlock_bh(&tunnel->hlist_lock);
+                                return session;
+                        }
+                }
+        }
+
+        read_unlock_bh(&tunnel->hlist_lock);
+
+        return NULL;
+}
+EXPORT_SYMBOL_GPL(l2tp_session_find_nth);
+
+/* Lookup a session by interface name.
+ * This is very inefficient but is only used by management interfaces.
+ */
+struct l2tp_session *l2tp_session_find_by_ifname(struct net *net, char *ifname)
+{
+        struct l2tp_net *pn = l2tp_pernet(net);
+        int hash;
+        struct hlist_node *walk;
+        struct l2tp_session *session;
+
+        rcu_read_lock_bh();
+        for (hash = 0; hash < L2TP_HASH_SIZE_2; hash++) {
+                hlist_for_each_entry_rcu(session, walk, &pn->l2tp_session_hlist[hash], global_hlist) {
+                        if (!strcmp(session->ifname, ifname)) {
+                                rcu_read_unlock_bh();
+                                return session;
+                        }
+                }
+        }
+
+        rcu_read_unlock_bh();
+
+        return NULL;
+}
+EXPORT_SYMBOL_GPL(l2tp_session_find_by_ifname);
+
+/* Lookup a tunnel by id
+ */
+struct l2tp_tunnel *l2tp_tunnel_find(struct net *net, u32 tunnel_id)
+{
+        struct l2tp_tunnel *tunnel;
+        struct l2tp_net *pn = l2tp_pernet(net);
+
+        rcu_read_lock_bh();
+        list_for_each_entry_rcu(tunnel, &pn->l2tp_tunnel_list, list) {
+                if (tunnel->tunnel_id == tunnel_id) {
+                        rcu_read_unlock_bh();
+                        return tunnel;
+                }
+        }
+        rcu_read_unlock_bh();
+
+        return NULL;
+}
+EXPORT_SYMBOL_GPL(l2tp_tunnel_find);
+
+struct l2tp_tunnel *l2tp_tunnel_find_nth(struct net *net, int nth)
+{
+        struct l2tp_net *pn = l2tp_pernet(net);
+        struct l2tp_tunnel *tunnel;
+        int count = 0;
+
+        rcu_read_lock_bh();
+        list_for_each_entry_rcu(tunnel, &pn->l2tp_tunnel_list, list) {
+                if (++count > nth) {
+                        rcu_read_unlock_bh();
+                        return tunnel;
+                }
+        }
+
+        rcu_read_unlock_bh();
+
+        return NULL;
+}
+EXPORT_SYMBOL_GPL(l2tp_tunnel_find_nth);
+
+/*****************************************************************************
+ * Receive data handling
+ *****************************************************************************/
+
+/* Queue a skb in order. We come here only if the skb has an L2TP sequence
+ * number.
+ */
+static void l2tp_recv_queue_skb(struct l2tp_session *session, struct sk_buff *skb)
+{
+        struct sk_buff *skbp;
+        struct sk_buff *tmp;
+        u32 ns = L2TP_SKB_CB(skb)->ns;
+
+        spin_lock_bh(&session->reorder_q.lock);
+        skb_queue_walk_safe(&session->reorder_q, skbp, tmp) {
+                if (L2TP_SKB_CB(skbp)->ns > ns) {
+                        __skb_queue_before(&session->reorder_q, skbp, skb);
+                        PRINTK(session->debug, L2TP_MSG_SEQ, KERN_DEBUG,
+                               "%s: pkt %hu, inserted before %hu, reorder_q len=%d\n",
+                               session->name, ns, L2TP_SKB_CB(skbp)->ns,
+                               skb_queue_len(&session->reorder_q));
+                        session->stats.rx_oos_packets++;
+                        goto out;
+                }
+        }
+
+        __skb_queue_tail(&session->reorder_q, skb);
+
+out:
+        spin_unlock_bh(&session->reorder_q.lock);
+}
+
+/* Dequeue a single skb.
+ */
+static void l2tp_recv_dequeue_skb(struct l2tp_session *session, struct sk_buff *skb)
+{
+        struct l2tp_tunnel *tunnel = session->tunnel;
+        int length = L2TP_SKB_CB(skb)->length;
+
+        /* We're about to requeue the skb, so return resources
+         * to its current owner (a socket receive buffer).
+         */
+        skb_orphan(skb);
+
+        tunnel->stats.rx_packets++;
+        tunnel->stats.rx_bytes += length;
+        session->stats.rx_packets++;
+        session->stats.rx_bytes += length;
+
+        if (L2TP_SKB_CB(skb)->has_seq) {
+                /* Bump our Nr */
+                session->nr++;
+                if (tunnel->version == L2TP_HDR_VER_2)
+                        session->nr &= 0xffff;
+                else
+                        session->nr &= 0xffffff;
+
+                PRINTK(session->debug, L2TP_MSG_SEQ, KERN_DEBUG,
+                       "%s: updated nr to %hu\n", session->name, session->nr);
+        }
+
+        /* call private receive handler */
+        if (session->recv_skb != NULL)
+                (*session->recv_skb)(session, skb, L2TP_SKB_CB(skb)->length);
+        else
+                kfree_skb(skb);
+
+        if (session->deref)
+                (*session->deref)(session);
+}
+
+/* Dequeue skbs from the session's reorder_q, subject to packet order.
+ * Skbs that have been in the queue for too long are simply discarded.
+ */
+static void l2tp_recv_dequeue(struct l2tp_session *session)
+{
+        struct sk_buff *skb;
+        struct sk_buff *tmp;
+
+        /* If the pkt at the head of the queue has the nr that we
+         * expect to send up next, dequeue it and any other
+         * in-sequence packets behind it.
+         */
+        spin_lock_bh(&session->reorder_q.lock);
+        skb_queue_walk_safe(&session->reorder_q, skb, tmp) {
+                if (time_after(jiffies, L2TP_SKB_CB(skb)->expires)) {
+                        session->stats.rx_seq_discards++;
+                        session->stats.rx_errors++;
+                        PRINTK(session->debug, L2TP_MSG_SEQ, KERN_DEBUG,
+                               "%s: oos pkt %u len %d discarded (too old), "
+                               "waiting for %u, reorder_q_len=%d\n",
+                               session->name, L2TP_SKB_CB(skb)->ns,
+                               L2TP_SKB_CB(skb)->length, session->nr,
+                               skb_queue_len(&session->reorder_q));
+                        __skb_unlink(skb, &session->reorder_q);
+                        kfree_skb(skb);
+                        if (session->deref)
+                                (*session->deref)(session);
+                        continue;
+                }
+
+                if (L2TP_SKB_CB(skb)->has_seq) {
+                        if (L2TP_SKB_CB(skb)->ns != session->nr) {
+                                PRINTK(session->debug, L2TP_MSG_SEQ, KERN_DEBUG,
+                                       "%s: holding oos pkt %u len %d, "
+                                       "waiting for %u, reorder_q_len=%d\n",
+                                       session->name, L2TP_SKB_CB(skb)->ns,
+                                       L2TP_SKB_CB(skb)->length, session->nr,
+                                       skb_queue_len(&session->reorder_q));
+                                goto out;
+                        }
+                }
+                __skb_unlink(skb, &session->reorder_q);
+
+                /* Process the skb. We release the queue lock while we
+                 * do so to let other contexts process the queue.
+                 */
+                spin_unlock_bh(&session->reorder_q.lock);
+                l2tp_recv_dequeue_skb(session, skb);
+                spin_lock_bh(&session->reorder_q.lock);
+        }
+
+out:
+        spin_unlock_bh(&session->reorder_q.lock);
+}
+
+static inline int l2tp_verify_udp_checksum(struct sock *sk,
+                                           struct sk_buff *skb)
+{
+        struct udphdr *uh = udp_hdr(skb);
+        u16 ulen = ntohs(uh->len);
+        struct inet_sock *inet;
+        __wsum psum;
+
+        if (sk->sk_no_check || skb_csum_unnecessary(skb) || !uh->check)
+                return 0;
+
+        inet = inet_sk(sk);
+        psum = csum_tcpudp_nofold(inet->inet_saddr, inet->inet_daddr, ulen,
+                                  IPPROTO_UDP, 0);
+
+        if ((skb->ip_summed == CHECKSUM_COMPLETE) &&
+            !csum_fold(csum_add(psum, skb->csum)))
+                return 0;
+
+        skb->csum = psum;
+
+        return __skb_checksum_complete(skb);
+}
+
+/* Do receive processing of L2TP data frames. We handle both L2TPv2
+ * and L2TPv3 data frames here.
+ *
+ * L2TPv2 Data Message Header
+ *
+ *  0                   1                   2                   3
+ *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * |T|L|x|x|S|x|O|P|x|x|x|x|  Ver  |          Length (opt)         |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * |           Tunnel ID           |           Session ID          |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * |             Ns (opt)          |             Nr (opt)          |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * |      Offset Size (opt)        |    Offset pad... (opt)
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *
+ * Data frames are marked by T=0. All other fields are the same as
+ * those in L2TP control frames.
+ *
+ * L2TPv3 Data Message Header
+ *
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * |                      L2TP Session Header                      |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * |                      L2-Specific Sublayer                     |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * |                        Tunnel Payload                      ...
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *
+ * L2TPv3 Session Header Over IP
+ *
+ *  0                   1                   2                   3
+ *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * |                           Session ID                          |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * |               Cookie (optional, maximum 64 bits)...
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *                                                                 |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *
+ * L2TPv3 L2-Specific Sublayer Format
+ *
+ *  0                   1                   2                   3
+ *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * |x|S|x|x|x|x|x|x|              Sequence Number                  |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *
+ * Cookie value, sublayer format and offset (pad) are negotiated with
+ * the peer when the session is set up. Unlike L2TPv2, we do not need
+ * to parse the packet header to determine if optional fields are
+ * present.
+ *
+ * Caller must already have parsed the frame and determined that it is
+ * a data (not control) frame before coming here. Fields up to the
+ * session-id have already been parsed and ptr points to the data
+ * after the session-id.
+ */
+void l2tp_recv_common(struct l2tp_session *session, struct sk_buff *skb,
+                      unsigned char *ptr, unsigned char *optr, u16 hdrflags,
+                      int length, int (*payload_hook)(struct sk_buff *skb))
+{
+        struct l2tp_tunnel *tunnel = session->tunnel;
+        int offset;
+        u32 ns, nr;
+
+        /* The ref count is increased since we now hold a pointer to
+         * the session. Take care to decrement the refcnt when exiting
+         * this function from now on...
+         */
+        l2tp_session_inc_refcount(session);
+        if (session->ref)
+                (*session->ref)(session);
+
+        /* Parse and check optional cookie */
+        if (session->peer_cookie_len > 0) {
+                if (memcmp(ptr, &session->peer_cookie[0], session->peer_cookie_len)) {
+                        PRINTK(tunnel->debug, L2TP_MSG_DATA, KERN_INFO,
+                               "%s: cookie mismatch (%u/%u). Discarding.\n",
+                               tunnel->name, tunnel->tunnel_id, session->session_id);
+                        session->stats.rx_cookie_discards++;
+                        goto discard;
+                }
+                ptr += session->peer_cookie_len;
+        }
+
+        /* Handle the optional sequence numbers. Sequence numbers are
+         * in different places for L2TPv2 and L2TPv3.
+         *
+         * If we are the LAC, enable/disable sequence numbers under
+         * the control of the LNS.  If no sequence numbers present but
+         * we were expecting them, discard frame.
+         */
+        ns = nr = 0;
+        L2TP_SKB_CB(skb)->has_seq = 0;
+        if (tunnel->version == L2TP_HDR_VER_2) {
+                if (hdrflags & L2TP_HDRFLAG_S) {
+                        ns = ntohs(*(__be16 *) ptr);
+                        ptr += 2;
+                        nr = ntohs(*(__be16 *) ptr);
+                        ptr += 2;
+
+                        /* Store L2TP info in the skb */
+                        L2TP_SKB_CB(skb)->ns = ns;
+                        L2TP_SKB_CB(skb)->has_seq = 1;
+
+                        PRINTK(session->debug, L2TP_MSG_SEQ, KERN_DEBUG,
+                               "%s: recv data ns=%u, nr=%u, session nr=%u\n",
+                               session->name, ns, nr, session->nr);
+                }
+        } else if (session->l2specific_type == L2TP_L2SPECTYPE_DEFAULT) {
+                u32 l2h = ntohl(*(__be32 *) ptr);
+
+                if (l2h & 0x40000000) {
+                        ns = l2h & 0x00ffffff;
+
+                        /* Store L2TP info in the skb */
+                        L2TP_SKB_CB(skb)->ns = ns;
+                        L2TP_SKB_CB(skb)->has_seq = 1;
+
+                        PRINTK(session->debug, L2TP_MSG_SEQ, KERN_DEBUG,
+                               "%s: recv data ns=%u, session nr=%u\n",
+                               session->name, ns, session->nr);
+                }
+        }
+
+        /* Advance past L2-specific header, if present */
+        ptr += session->l2specific_len;
+
+        if (L2TP_SKB_CB(skb)->has_seq) {
+                /* Received a packet with sequence numbers. If we're the LNS,
+                 * check if we sre sending sequence numbers and if not,
+                 * configure it so.
+                 */
+                if ((!session->lns_mode) && (!session->send_seq)) {
+                        PRINTK(session->debug, L2TP_MSG_SEQ, KERN_INFO,
+                               "%s: requested to enable seq numbers by LNS\n",
+                               session->name);
+                        session->send_seq = -1;
+                        l2tp_session_set_header_len(session, tunnel->version);
+                }
+        } else {
+                /* No sequence numbers.
+                 * If user has configured mandatory sequence numbers, discard.
+                 */
+                if (session->recv_seq) {
+                        PRINTK(session->debug, L2TP_MSG_SEQ, KERN_WARNING,
+                               "%s: recv data has no seq numbers when required. "
+                               "Discarding\n", session->name);
+                        session->stats.rx_seq_discards++;
+                        goto discard;
+                }
+
+                /* If we're the LAC and we're sending sequence numbers, the
+                 * LNS has requested that we no longer send sequence numbers.
+                 * If we're the LNS and we're sending sequence numbers, the
+                 * LAC is broken. Discard the frame.
+                 */
+                if ((!session->lns_mode) && (session->send_seq)) {
+                        PRINTK(session->debug, L2TP_MSG_SEQ, KERN_INFO,
+                               "%s: requested to disable seq numbers by LNS\n",
+                               session->name);
+                        session->send_seq = 0;
+                        l2tp_session_set_header_len(session, tunnel->version);
+                } else if (session->send_seq) {
+                        PRINTK(session->debug, L2TP_MSG_SEQ, KERN_WARNING,
+                               "%s: recv data has no seq numbers when required. "
+                               "Discarding\n", session->name);
+                        session->stats.rx_seq_discards++;
+                        goto discard;
+                }
+        }
+
+        /* Session data offset is handled differently for L2TPv2 and
+         * L2TPv3. For L2TPv2, there is an optional 16-bit value in
+         * the header. For L2TPv3, the offset is negotiated using AVPs
+         * in the session setup control protocol.
+         */
+        if (tunnel->version == L2TP_HDR_VER_2) {
+                /* If offset bit set, skip it. */
+                if (hdrflags & L2TP_HDRFLAG_O) {
+                        offset = ntohs(*(__be16 *)ptr);
+                        ptr += 2 + offset;
+                }
+        } else
+                ptr += session->offset;
+
+        offset = ptr - optr;
+        if (!pskb_may_pull(skb, offset))
+                goto discard;
+
+        __skb_pull(skb, offset);
+
+        /* If caller wants to process the payload before we queue the
+         * packet, do so now.
+         */
+        if (payload_hook)
+                if ((*payload_hook)(skb))
+                        goto discard;
+
+        /* Prepare skb for adding to the session's reorder_q.  Hold
+         * packets for max reorder_timeout or 1 second if not
+         * reordering.
+         */
+        L2TP_SKB_CB(skb)->length = length;
+        L2TP_SKB_CB(skb)->expires = jiffies +
+                (session->reorder_timeout ? session->reorder_timeout : HZ);
+
+        /* Add packet to the session's receive queue. Reordering is done here, if
+         * enabled. Saved L2TP protocol info is stored in skb->sb[].
+         */
+        if (L2TP_SKB_CB(skb)->has_seq) {
+                if (session->reorder_timeout != 0) {
+                        /* Packet reordering enabled. Add skb to session's
+                         * reorder queue, in order of ns.
+                         */
+                        l2tp_recv_queue_skb(session, skb);
+                } else {
+                        /* Packet reordering disabled. Discard out-of-sequence
+                         * packets
+                         */
+                        if (L2TP_SKB_CB(skb)->ns != session->nr) {
+                                session->stats.rx_seq_discards++;
+                                PRINTK(session->debug, L2TP_MSG_SEQ, KERN_DEBUG,
+                                       "%s: oos pkt %u len %d discarded, "
+                                       "waiting for %u, reorder_q_len=%d\n",
+                                       session->name, L2TP_SKB_CB(skb)->ns,
+                                       L2TP_SKB_CB(skb)->length, session->nr,
+                                       skb_queue_len(&session->reorder_q));
+                                goto discard;
+                        }
+                        skb_queue_tail(&session->reorder_q, skb);
+                }
+        } else {
+                /* No sequence numbers. Add the skb to the tail of the
+                 * reorder queue. This ensures that it will be
+                 * delivered after all previous sequenced skbs.
+                 */
+                skb_queue_tail(&session->reorder_q, skb);
+        }
+
+        /* Try to dequeue as many skbs from reorder_q as we can. */
+        l2tp_recv_dequeue(session);
+
+        l2tp_session_dec_refcount(session);
+
+        return;
+
+discard:
+        session->stats.rx_errors++;
+        kfree_skb(skb);
+
+        if (session->deref)
+                (*session->deref)(session);
+
+        l2tp_session_dec_refcount(session);
+}
+EXPORT_SYMBOL(l2tp_recv_common);
+
+/* Internal UDP receive frame. Do the real work of receiving an L2TP data frame
+ * here. The skb is not on a list when we get here.
+ * Returns 0 if the packet was a data packet and was successfully passed on.
+ * Returns 1 if the packet was not a good data packet and could not be
+ * forwarded.  All such packets are passed up to userspace to deal with.
+ */
+int l2tp_udp_recv_core(struct l2tp_tunnel *tunnel, struct sk_buff *skb,
+                       int (*payload_hook)(struct sk_buff *skb))
+{
+        struct l2tp_session *session = NULL;
+        unsigned char *ptr, *optr;
+        u16 hdrflags;
+        u32 tunnel_id, session_id;
+        int offset;
+        u16 version;
+        int length;
+
+        if (tunnel->sock && l2tp_verify_udp_checksum(tunnel->sock, skb))
+                goto discard_bad_csum;
+
+        /* UDP always verifies the packet length. */
+        __skb_pull(skb, sizeof(struct udphdr));
+
+        /* Short packet? */
+        if (!pskb_may_pull(skb, L2TP_HDR_SIZE_SEQ)) {
+                PRINTK(tunnel->debug, L2TP_MSG_DATA, KERN_INFO,
+                       "%s: recv short packet (len=%d)\n", tunnel->name, skb->len);
+                goto error;
+        }
+
+        /* Point to L2TP header */
+        optr = ptr = skb->data;
+
+        /* Trace packet contents, if enabled */
+        if (tunnel->debug & L2TP_MSG_DATA) {
+                length = min(32u, skb->len);
+                if (!pskb_may_pull(skb, length))
+                        goto error;
+
+                printk(KERN_DEBUG "%s: recv: ", tunnel->name);
+
+                offset = 0;
+                do {
+                        printk(" %02X", ptr[offset]);
+                } while (++offset < length);
+
+                printk("\n");
+        }
+
+        /* Get L2TP header flags */
+        hdrflags = ntohs(*(__be16 *) ptr);
+
+        /* Check protocol version */
+        version = hdrflags & L2TP_HDR_VER_MASK;
+        if (version != tunnel->version) {
+                PRINTK(tunnel->debug, L2TP_MSG_DATA, KERN_INFO,
+                       "%s: recv protocol version mismatch: got %d expected %d\n",
+                       tunnel->name, version, tunnel->version);
+                goto error;
+        }
+
+        /* Get length of L2TP packet */
+        length = skb->len;
+
+        /* If type is control packet, it is handled by userspace. */
+        if (hdrflags & L2TP_HDRFLAG_T) {
+                PRINTK(tunnel->debug, L2TP_MSG_DATA, KERN_DEBUG,
+                       "%s: recv control packet, len=%d\n", tunnel->name, length);
+                goto error;
+        }
+
+        /* Skip flags */
+        ptr += 2;
+
+        if (tunnel->version == L2TP_HDR_VER_2) {
+                /* If length is present, skip it */
+                if (hdrflags & L2TP_HDRFLAG_L)
+                        ptr += 2;
+
+                /* Extract tunnel and session ID */
+                tunnel_id = ntohs(*(__be16 *) ptr);
+                ptr += 2;
+                session_id = ntohs(*(__be16 *) ptr);
+                ptr += 2;
+        } else {
+                ptr += 2;       /* skip reserved bits */
+                tunnel_id = tunnel->tunnel_id;
+                session_id = ntohl(*(__be32 *) ptr);
+                ptr += 4;
+        }
+
+        /* Find the session context */
+        session = l2tp_session_find(tunnel->l2tp_net, tunnel, session_id);
+        if (!session || !session->recv_skb) {
+                /* Not found? Pass to userspace to deal with */
+                PRINTK(tunnel->debug, L2TP_MSG_DATA, KERN_INFO,
+                       "%s: no session found (%u/%u). Passing up.\n",
+                       tunnel->name, tunnel_id, session_id);
+                goto error;
+        }
+
+        l2tp_recv_common(session, skb, ptr, optr, hdrflags, length, payload_hook);
+
+        return 0;
+
+discard_bad_csum:
+        LIMIT_NETDEBUG("%s: UDP: bad checksum\n", tunnel->name);
+        UDP_INC_STATS_USER(tunnel->l2tp_net, UDP_MIB_INERRORS, 0);
+        tunnel->stats.rx_errors++;
+        kfree_skb(skb);
+
+        return 0;
+
+error:
+        /* Put UDP header back */
+        __skb_push(skb, sizeof(struct udphdr));
+
+        return 1;
+}
+EXPORT_SYMBOL_GPL(l2tp_udp_recv_core);
+
+/* UDP encapsulation receive handler. See net/ipv4/udp.c.
+ * Return codes:
+ * 0 : success.
+ * <0: error
+ * >0: skb should be passed up to userspace as UDP.
+ */
+int l2tp_udp_encap_recv(struct sock *sk, struct sk_buff *skb)
+{
+        struct l2tp_tunnel *tunnel;
+
+        tunnel = l2tp_sock_to_tunnel(sk);
+        if (tunnel == NULL)
+                goto pass_up;
+
+        PRINTK(tunnel->debug, L2TP_MSG_DATA, KERN_DEBUG,
+               "%s: received %d bytes\n", tunnel->name, skb->len);
+
+        if (l2tp_udp_recv_core(tunnel, skb, tunnel->recv_payload_hook))
+                goto pass_up_put;
+
+        sock_put(sk);
+        return 0;
+
+pass_up_put:
+        sock_put(sk);
+pass_up:
+        return 1;
+}
+EXPORT_SYMBOL_GPL(l2tp_udp_encap_recv);
+
+/************************************************************************
+ * Transmit handling
+ ***********************************************************************/
+
+/* Build an L2TP header for the session into the buffer provided.
+ */
+static int l2tp_build_l2tpv2_header(struct l2tp_session *session, void *buf)
+{
+        struct l2tp_tunnel *tunnel = session->tunnel;
+        __be16 *bufp = buf;
+        __be16 *optr = buf;
+        u16 flags = L2TP_HDR_VER_2;
+        u32 tunnel_id = tunnel->peer_tunnel_id;
+        u32 session_id = session->peer_session_id;
+
+        if (session->send_seq)
+                flags |= L2TP_HDRFLAG_S;
+
+        /* Setup L2TP header. */
+        *bufp++ = htons(flags);
+        *bufp++ = htons(tunnel_id);
+        *bufp++ = htons(session_id);
+        if (session->send_seq) {
+                *bufp++ = htons(session->ns);
+                *bufp++ = 0;
+                session->ns++;
+                session->ns &= 0xffff;
+                PRINTK(session->debug, L2TP_MSG_SEQ, KERN_DEBUG,
+                       "%s: updated ns to %u\n", session->name, session->ns);
+        }
+
+        return bufp - optr;
+}
+
+static int l2tp_build_l2tpv3_header(struct l2tp_session *session, void *buf)
+{
+        struct l2tp_tunnel *tunnel = session->tunnel;
+        char *bufp = buf;
+        char *optr = bufp;
+
+        /* Setup L2TP header. The header differs slightly for UDP and
+         * IP encapsulations. For UDP, there is 4 bytes of flags.
+         */
+        if (tunnel->encap == L2TP_ENCAPTYPE_UDP) {
+                u16 flags = L2TP_HDR_VER_3;
+                *((__be16 *) bufp) = htons(flags);
+                bufp += 2;
+                *((__be16 *) bufp) = 0;
+                bufp += 2;
+        }
+
+        *((__be32 *) bufp) = htonl(session->peer_session_id);
+        bufp += 4;
+        if (session->cookie_len) {
+                memcpy(bufp, &session->cookie[0], session->cookie_len);
+                bufp += session->cookie_len;
+        }
+        if (session->l2specific_len) {
+                if (session->l2specific_type == L2TP_L2SPECTYPE_DEFAULT) {
+                        u32 l2h = 0;
+                        if (session->send_seq) {
+                                l2h = 0x40000000 | session->ns;
+                                session->ns++;
+                                session->ns &= 0xffffff;
+                                PRINTK(session->debug, L2TP_MSG_SEQ, KERN_DEBUG,
+                                       "%s: updated ns to %u\n", session->name, session->ns);
+                        }
+
+                        *((__be32 *) bufp) = htonl(l2h);
+                }
+                bufp += session->l2specific_len;
+        }
+        if (session->offset)
+                bufp += session->offset;
+
+        return bufp - optr;
+}
+
+int l2tp_xmit_core(struct l2tp_session *session, struct sk_buff *skb, size_t data_len)
+{
+        struct l2tp_tunnel *tunnel = session->tunnel;
+        unsigned int len = skb->len;
+        int error;
+
+        /* Debug */
+        if (session->send_seq)
+                PRINTK(session->debug, L2TP_MSG_DATA, KERN_DEBUG,
+                       "%s: send %Zd bytes, ns=%u\n", session->name,
+                       data_len, session->ns - 1);
+        else
+                PRINTK(session->debug, L2TP_MSG_DATA, KERN_DEBUG,
+                       "%s: send %Zd bytes\n", session->name, data_len);
+
+        if (session->debug & L2TP_MSG_DATA) {
+                int i;
+                int uhlen = (tunnel->encap == L2TP_ENCAPTYPE_UDP) ? sizeof(struct udphdr) : 0;
+                unsigned char *datap = skb->data + uhlen;
+
+                printk(KERN_DEBUG "%s: xmit:", session->name);
+                for (i = 0; i < (len - uhlen); i++) {
+                        printk(" %02X", *datap++);
+                        if (i == 31) {
+                                printk(" ...");
+                                break;
+                        }
+                }
+                printk("\n");
+        }
+
+        /* Queue the packet to IP for output */
+        skb->local_df = 1;
+        error = ip_queue_xmit(skb);
+
+        /* Update stats */
+        if (error >= 0) {
+                tunnel->stats.tx_packets++;
+                tunnel->stats.tx_bytes += len;
+                session->stats.tx_packets++;
+                session->stats.tx_bytes += len;
+        } else {
+                tunnel->stats.tx_errors++;
+                session->stats.tx_errors++;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(l2tp_xmit_core);
+
+/* Automatically called when the skb is freed.
+ */
+static void l2tp_sock_wfree(struct sk_buff *skb)
+{
+        sock_put(skb->sk);
+}
+
+/* For data skbs that we transmit, we associate with the tunnel socket
+ * but don't do accounting.
+ */
+static inline void l2tp_skb_set_owner_w(struct sk_buff *skb, struct sock *sk)
+{
+        sock_hold(sk);
+        skb->sk = sk;
+        skb->destructor = l2tp_sock_wfree;
+}
+
+/* If caller requires the skb to have a ppp header, the header must be
+ * inserted in the skb data before calling this function.
+ */
+int l2tp_xmit_skb(struct l2tp_session *session, struct sk_buff *skb, int hdr_len)
+{
+        int data_len = skb->len;
+        struct l2tp_tunnel *tunnel = session->tunnel;
+        struct sock *sk = tunnel->sock;
+        struct udphdr *uh;
+        struct inet_sock *inet;
+        __wsum csum;
+        int old_headroom;
+        int new_headroom;
+        int headroom;
+        int uhlen = (tunnel->encap == L2TP_ENCAPTYPE_UDP) ? sizeof(struct udphdr) : 0;
+        int udp_len;
+
+        /* Check that there's enough headroom in the skb to insert IP,
+         * UDP and L2TP headers. If not enough, expand it to
+         * make room. Adjust truesize.
+         */
+        headroom = NET_SKB_PAD + sizeof(struct iphdr) +
+                uhlen + hdr_len;
+        old_headroom = skb_headroom(skb);
+        if (skb_cow_head(skb, headroom))
+                goto abort;
+
+        new_headroom = skb_headroom(skb);
+        skb_orphan(skb);
+        skb->truesize += new_headroom - old_headroom;
+
+        /* Setup L2TP header */
+        session->build_header(session, __skb_push(skb, hdr_len));
+
+        /* Reset skb netfilter state */
+        memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
+        IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED |
+                              IPSKB_REROUTED);
+        nf_reset(skb);
+
+        /* Get routing info from the tunnel socket */
+        skb_dst_drop(skb);
+        skb_dst_set(skb, dst_clone(__sk_dst_get(sk)));
+
+        switch (tunnel->encap) {
+        case L2TP_ENCAPTYPE_UDP:
+                /* Setup UDP header */
+                inet = inet_sk(sk);
+                __skb_push(skb, sizeof(*uh));
+                skb_reset_transport_header(skb);
+                uh = udp_hdr(skb);
+                uh->source = inet->inet_sport;
+                uh->dest = inet->inet_dport;
+                udp_len = uhlen + hdr_len + data_len;
+                uh->len = htons(udp_len);
+                uh->check = 0;
+
+                /* Calculate UDP checksum if configured to do so */
+                if (sk->sk_no_check == UDP_CSUM_NOXMIT)
+                        skb->ip_summed = CHECKSUM_NONE;
+                else if ((skb_dst(skb) && skb_dst(skb)->dev) &&
+                         (!(skb_dst(skb)->dev->features & NETIF_F_V4_CSUM))) {
+                        skb->ip_summed = CHECKSUM_COMPLETE;
+                        csum = skb_checksum(skb, 0, udp_len, 0);
+                        uh->check = csum_tcpudp_magic(inet->inet_saddr,
+                                                      inet->inet_daddr,
+                                                      udp_len, IPPROTO_UDP, csum);
+                        if (uh->check == 0)
+                                uh->check = CSUM_MANGLED_0;
+                } else {
+                        skb->ip_summed = CHECKSUM_PARTIAL;
+                        skb->csum_start = skb_transport_header(skb) - skb->head;
+                        skb->csum_offset = offsetof(struct udphdr, check);
+                        uh->check = ~csum_tcpudp_magic(inet->inet_saddr,
+                                                       inet->inet_daddr,
+                                                       udp_len, IPPROTO_UDP, 0);
+                }
+                break;
+
+        case L2TP_ENCAPTYPE_IP:
+                break;
+        }
+
+        l2tp_skb_set_owner_w(skb, sk);
+
+        l2tp_xmit_core(session, skb, data_len);
+
+abort:
+        return 0;
+}
+EXPORT_SYMBOL_GPL(l2tp_xmit_skb);
+
+/*****************************************************************************
+ * Tinnel and session create/destroy.
+ *****************************************************************************/
+
+/* Tunnel socket destruct hook.
+ * The tunnel context is deleted only when all session sockets have been
+ * closed.
+ */
+void l2tp_tunnel_destruct(struct sock *sk)
+{
+        struct l2tp_tunnel *tunnel;
+
+        tunnel = sk->sk_user_data;
+        if (tunnel == NULL)
+                goto end;
+
+        PRINTK(tunnel->debug, L2TP_MSG_CONTROL, KERN_INFO,
+               "%s: closing...\n", tunnel->name);
+
+        /* Close all sessions */
+        l2tp_tunnel_closeall(tunnel);
+
+        switch (tunnel->encap) {
+        case L2TP_ENCAPTYPE_UDP:
+                /* No longer an encapsulation socket. See net/ipv4/udp.c */
+                (udp_sk(sk))->encap_type = 0;
+                (udp_sk(sk))->encap_rcv = NULL;
+                break;
+        case L2TP_ENCAPTYPE_IP:
+                break;
+        }
+
+        /* Remove hooks into tunnel socket */
+        tunnel->sock = NULL;
+        sk->sk_destruct = tunnel->old_sk_destruct;
+        sk->sk_user_data = NULL;
+
+        /* Call the original destructor */
+        if (sk->sk_destruct)
+                (*sk->sk_destruct)(sk);
+
+        /* We're finished with the socket */
+        l2tp_tunnel_dec_refcount(tunnel);
+
+end:
+        return;
+}
+EXPORT_SYMBOL(l2tp_tunnel_destruct);
+
+/* When the tunnel is closed, all the attached sessions need to go too.
+ */
+void l2tp_tunnel_closeall(struct l2tp_tunnel *tunnel)
+{
+        int hash;
+        struct hlist_node *walk;
+        struct hlist_node *tmp;
+        struct l2tp_session *session;
+
+        BUG_ON(tunnel == NULL);
+
+        PRINTK(tunnel->debug, L2TP_MSG_CONTROL, KERN_INFO,
+               "%s: closing all sessions...\n", tunnel->name);
+
+        write_lock_bh(&tunnel->hlist_lock);
+        for (hash = 0; hash < L2TP_HASH_SIZE; hash++) {
+again:
+                hlist_for_each_safe(walk, tmp, &tunnel->session_hlist[hash]) {
+                        session = hlist_entry(walk, struct l2tp_session, hlist);
+
+                        PRINTK(session->debug, L2TP_MSG_CONTROL, KERN_INFO,
+                               "%s: closing session\n", session->name);
+
+                        hlist_del_init(&session->hlist);
+
+                        /* Since we should hold the sock lock while
+                         * doing any unbinding, we need to release the
+                         * lock we're holding before taking that lock.
+                         * Hold a reference to the sock so it doesn't
+                         * disappear as we're jumping between locks.
+                         */
+                        if (session->ref != NULL)
+                                (*session->ref)(session);
+
+                        write_unlock_bh(&tunnel->hlist_lock);
+
+                        if (tunnel->version != L2TP_HDR_VER_2) {
+                                struct l2tp_net *pn = l2tp_pernet(tunnel->l2tp_net);
+
+                                spin_lock_bh(&pn->l2tp_session_hlist_lock);
+                                hlist_del_init_rcu(&session->global_hlist);
+                                spin_unlock_bh(&pn->l2tp_session_hlist_lock);
+                                synchronize_rcu();
+                        }
+
+                        if (session->session_close != NULL)
+                                (*session->session_close)(session);
+
+                        if (session->deref != NULL)
+                                (*session->deref)(session);
+
+                        write_lock_bh(&tunnel->hlist_lock);
+
+                        /* Now restart from the beginning of this hash
+                         * chain.  We always remove a session from the
+                         * list so we are guaranteed to make forward
+                         * progress.
+                         */
+                        goto again;
+                }
+        }
+        write_unlock_bh(&tunnel->hlist_lock);
+}
+EXPORT_SYMBOL_GPL(l2tp_tunnel_closeall);
+
+/* Really kill the tunnel.
+ * Come here only when all sessions have been cleared from the tunnel.
+ */
+void l2tp_tunnel_free(struct l2tp_tunnel *tunnel)
+{
+        struct l2tp_net *pn = l2tp_pernet(tunnel->l2tp_net);
+
+        BUG_ON(atomic_read(&tunnel->ref_count) != 0);
+        BUG_ON(tunnel->sock != NULL);
+
+        PRINTK(tunnel->debug, L2TP_MSG_CONTROL, KERN_INFO,
+               "%s: free...\n", tunnel->name);
+
+        /* Remove from tunnel list */
+        spin_lock_bh(&pn->l2tp_tunnel_list_lock);
+        list_del_rcu(&tunnel->list);
+        spin_unlock_bh(&pn->l2tp_tunnel_list_lock);
+        synchronize_rcu();
+
+        atomic_dec(&l2tp_tunnel_count);
+        kfree(tunnel);
+}
+EXPORT_SYMBOL_GPL(l2tp_tunnel_free);
+
+/* Create a socket for the tunnel, if one isn't set up by
+ * userspace. This is used for static tunnels where there is no
+ * managing L2TP daemon.
+ */
+static int l2tp_tunnel_sock_create(u32 tunnel_id, u32 peer_tunnel_id, struct l2tp_tunnel_cfg *cfg, struct socket **sockp)
+{
+        int err = -EINVAL;
+        struct sockaddr_in udp_addr;
+        struct sockaddr_l2tpip ip_addr;
+        struct socket *sock = NULL;
+
+        switch (cfg->encap) {
+        case L2TP_ENCAPTYPE_UDP:
+                err = sock_create(AF_INET, SOCK_DGRAM, 0, sockp);
+                if (err < 0)
+                        goto out;
+
+                sock = *sockp;
+
+                memset(&udp_addr, 0, sizeof(udp_addr));
+                udp_addr.sin_family = AF_INET;
+                udp_addr.sin_addr = cfg->local_ip;
+                udp_addr.sin_port = htons(cfg->local_udp_port);
+                err = kernel_bind(sock, (struct sockaddr *) &udp_addr, sizeof(udp_addr));
+                if (err < 0)
+                        goto out;
+
+                udp_addr.sin_family = AF_INET;
+                udp_addr.sin_addr = cfg->peer_ip;
+                udp_addr.sin_port = htons(cfg->peer_udp_port);
+                err = kernel_connect(sock, (struct sockaddr *) &udp_addr, sizeof(udp_addr), 0);
+                if (err < 0)
+                        goto out;
+
+                if (!cfg->use_udp_checksums)
+                        sock->sk->sk_no_check = UDP_CSUM_NOXMIT;
+
+                break;
+
+        case L2TP_ENCAPTYPE_IP:
+                err = sock_create(AF_INET, SOCK_DGRAM, IPPROTO_L2TP, sockp);
+                if (err < 0)
+                        goto out;
+
+                sock = *sockp;
+
+                memset(&ip_addr, 0, sizeof(ip_addr));
+                ip_addr.l2tp_family = AF_INET;
+                ip_addr.l2tp_addr = cfg->local_ip;
+                ip_addr.l2tp_conn_id = tunnel_id;
+                err = kernel_bind(sock, (struct sockaddr *) &ip_addr, sizeof(ip_addr));
+                if (err < 0)
+                        goto out;
+
+                ip_addr.l2tp_family = AF_INET;
+                ip_addr.l2tp_addr = cfg->peer_ip;
+                ip_addr.l2tp_conn_id = peer_tunnel_id;
+                err = kernel_connect(sock, (struct sockaddr *) &ip_addr, sizeof(ip_addr), 0);
+                if (err < 0)
+                        goto out;
+
+                break;
+
+        default:
+                goto out;
+        }
+
+out:
+        if ((err < 0) && sock) {
+                sock_release(sock);
+                *sockp = NULL;
+        }
+
+        return err;
+}
+
+int l2tp_tunnel_create(struct net *net, int fd, int version, u32 tunnel_id, u32 peer_tunnel_id, struct l2tp_tunnel_cfg *cfg, struct l2tp_tunnel **tunnelp)
+{
+        struct l2tp_tunnel *tunnel = NULL;
+        int err;
+        struct socket *sock = NULL;
+        struct sock *sk = NULL;
+        struct l2tp_net *pn;
+        enum l2tp_encap_type encap = L2TP_ENCAPTYPE_UDP;
+
+        /* Get the tunnel socket from the fd, which was opened by
+         * the userspace L2TP daemon. If not specified, create a
+         * kernel socket.
+         */
+        if (fd < 0) {
+                err = l2tp_tunnel_sock_create(tunnel_id, peer_tunnel_id, cfg, &sock);
+                if (err < 0)
+                        goto err;
+        } else {
+                err = -EBADF;
+                sock = sockfd_lookup(fd, &err);
+                if (!sock) {
+                        printk(KERN_ERR "tunl %hu: sockfd_lookup(fd=%d) returned %d\n",
+                               tunnel_id, fd, err);
+                        goto err;
+                }
+        }
+
+        sk = sock->sk;
+
+        if (cfg != NULL)
+                encap = cfg->encap;
+
+        /* Quick sanity checks */
+        switch (encap) {
+        case L2TP_ENCAPTYPE_UDP:
+                err = -EPROTONOSUPPORT;
+                if (sk->sk_protocol != IPPROTO_UDP) {
+                        printk(KERN_ERR "tunl %hu: fd %d wrong protocol, got %d, expected %d\n",
+                               tunnel_id, fd, sk->sk_protocol, IPPROTO_UDP);
+                        goto err;
+                }
+                break;
+        case L2TP_ENCAPTYPE_IP:
+                err = -EPROTONOSUPPORT;
+                if (sk->sk_protocol != IPPROTO_L2TP) {
+                        printk(KERN_ERR "tunl %hu: fd %d wrong protocol, got %d, expected %d\n",
+                               tunnel_id, fd, sk->sk_protocol, IPPROTO_L2TP);
+                        goto err;
+                }
+                break;
+        }
+
+        /* Check if this socket has already been prepped */
+        tunnel = (struct l2tp_tunnel *)sk->sk_user_data;
+        if (tunnel != NULL) {
+                /* This socket has already been prepped */
+                err = -EBUSY;
+                goto err;
+        }
+
+        tunnel = kzalloc(sizeof(struct l2tp_tunnel), GFP_KERNEL);
+        if (tunnel == NULL) {
+                err = -ENOMEM;
+                goto err;
+        }
+
+        tunnel->version = version;
+        tunnel->tunnel_id = tunnel_id;
+        tunnel->peer_tunnel_id = peer_tunnel_id;
+        tunnel->debug = L2TP_DEFAULT_DEBUG_FLAGS;
+
+        tunnel->magic = L2TP_TUNNEL_MAGIC;
+        sprintf(&tunnel->name[0], "tunl %u", tunnel_id);
+        rwlock_init(&tunnel->hlist_lock);
+
+        /* The net we belong to */
+        tunnel->l2tp_net = net;
+        pn = l2tp_pernet(net);
+
+        if (cfg != NULL)
+                tunnel->debug = cfg->debug;
+
+        /* Mark socket as an encapsulation socket. See net/ipv4/udp.c */
+        tunnel->encap = encap;
+        if (encap == L2TP_ENCAPTYPE_UDP) {
+                /* Mark socket as an encapsulation socket. See net/ipv4/udp.c */
+                udp_sk(sk)->encap_type = UDP_ENCAP_L2TPINUDP;
+                udp_sk(sk)->encap_rcv = l2tp_udp_encap_recv;
+        }
+
+        sk->sk_user_data = tunnel;
+
+        /* Hook on the tunnel socket destructor so that we can cleanup
+         * if the tunnel socket goes away.
+         */
+        tunnel->old_sk_destruct = sk->sk_destruct;
+        sk->sk_destruct = &l2tp_tunnel_destruct;
+        tunnel->sock = sk;
+        sk->sk_allocation = GFP_ATOMIC;
+
+        /* Add tunnel to our list */
+        INIT_LIST_HEAD(&tunnel->list);
+        spin_lock_bh(&pn->l2tp_tunnel_list_lock);
+        list_add_rcu(&tunnel->list, &pn->l2tp_tunnel_list);
+        spin_unlock_bh(&pn->l2tp_tunnel_list_lock);
+        synchronize_rcu();
+        atomic_inc(&l2tp_tunnel_count);
+
+        /* Bump the reference count. The tunnel context is deleted
+         * only when this drops to zero.
+         */
+        l2tp_tunnel_inc_refcount(tunnel);
+
+        err = 0;
+err:
+        if (tunnelp)
+                *tunnelp = tunnel;
+
+        /* If tunnel's socket was created by the kernel, it doesn't
+         *  have a file.
+         */
+        if (sock && sock->file)
+                sockfd_put(sock);
+
+        return err;
+}
+EXPORT_SYMBOL_GPL(l2tp_tunnel_create);
+
+/* This function is used by the netlink TUNNEL_DELETE command.
+ */
+int l2tp_tunnel_delete(struct l2tp_tunnel *tunnel)
+{
+        int err = 0;
+        struct socket *sock = tunnel->sock ? tunnel->sock->sk_socket : NULL;
+
+        /* Force the tunnel socket to close. This will eventually
+         * cause the tunnel to be deleted via the normal socket close
+         * mechanisms when userspace closes the tunnel socket.
+         */
+        if (sock != NULL) {
+                err = inet_shutdown(sock, 2);
+
+                /* If the tunnel's socket was created by the kernel,
+                 * close the socket here since the socket was not
+                 * created by userspace.
+                 */
+                if (sock->file == NULL)
+                        err = inet_release(sock);
+        }
+
+        return err;
+}
+EXPORT_SYMBOL_GPL(l2tp_tunnel_delete);
+
+/* Really kill the session.
+ */
+void l2tp_session_free(struct l2tp_session *session)
+{
+        struct l2tp_tunnel *tunnel;
+
+        BUG_ON(atomic_read(&session->ref_count) != 0);
+
+        tunnel = session->tunnel;
+        if (tunnel != NULL) {
+                BUG_ON(tunnel->magic != L2TP_TUNNEL_MAGIC);
+
+                /* Delete the session from the hash */
+                write_lock_bh(&tunnel->hlist_lock);
+                hlist_del_init(&session->hlist);
+                write_unlock_bh(&tunnel->hlist_lock);
+
+                /* Unlink from the global hash if not L2TPv2 */
+                if (tunnel->version != L2TP_HDR_VER_2) {
+                        struct l2tp_net *pn = l2tp_pernet(tunnel->l2tp_net);
+
+                        spin_lock_bh(&pn->l2tp_session_hlist_lock);
+                        hlist_del_init_rcu(&session->global_hlist);
+                        spin_unlock_bh(&pn->l2tp_session_hlist_lock);
+                        synchronize_rcu();
+                }
+
+                if (session->session_id != 0)
+                        atomic_dec(&l2tp_session_count);
+
+                sock_put(tunnel->sock);
+
+                /* This will delete the tunnel context if this
+                 * is the last session on the tunnel.
+                 */
+                session->tunnel = NULL;
+                l2tp_tunnel_dec_refcount(tunnel);
+        }
+
+        kfree(session);
+
+        return;
+}
+EXPORT_SYMBOL_GPL(l2tp_session_free);
+
+/* This function is used by the netlink SESSION_DELETE command and by
+   pseudowire modules.
+ */
+int l2tp_session_delete(struct l2tp_session *session)
+{
+        if (session->session_close != NULL)
+                (*session->session_close)(session);
+
+        l2tp_session_dec_refcount(session);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(l2tp_session_delete);
+
+
+/* We come here whenever a session's send_seq, cookie_len or
+ * l2specific_len parameters are set.
+ */
+void l2tp_session_set_header_len(struct l2tp_session *session, int version)
+{
+        if (version == L2TP_HDR_VER_2) {
+                session->hdr_len = 6;
+                if (session->send_seq)
+                        session->hdr_len += 4;
+        } else {
+                session->hdr_len = 4 + session->cookie_len + session->l2specific_len + session->offset;
+                if (session->tunnel->encap == L2TP_ENCAPTYPE_UDP)
+                        session->hdr_len += 4;
+        }
+
+}
+EXPORT_SYMBOL_GPL(l2tp_session_set_header_len);
+
+struct l2tp_session *l2tp_session_create(int priv_size, struct l2tp_tunnel *tunnel, u32 session_id, u32 peer_session_id, struct l2tp_session_cfg *cfg)
+{
+        struct l2tp_session *session;
+
+        session = kzalloc(sizeof(struct l2tp_session) + priv_size, GFP_KERNEL);
+        if (session != NULL) {
+                session->magic = L2TP_SESSION_MAGIC;
+                session->tunnel = tunnel;
+
+                session->session_id = session_id;
+                session->peer_session_id = peer_session_id;
+                session->nr = 1;
+
+                sprintf(&session->name[0], "sess %u/%u",
+                        tunnel->tunnel_id, session->session_id);
+
+                skb_queue_head_init(&session->reorder_q);
+
+                INIT_HLIST_NODE(&session->hlist);
+                INIT_HLIST_NODE(&session->global_hlist);
+
+                /* Inherit debug options from tunnel */
+                session->debug = tunnel->debug;
+
+                if (cfg) {
+                        session->pwtype = cfg->pw_type;
+                        session->debug = cfg->debug;
+                        session->mtu = cfg->mtu;
+                        session->mru = cfg->mru;
+                        session->send_seq = cfg->send_seq;
+                        session->recv_seq = cfg->recv_seq;
+                        session->lns_mode = cfg->lns_mode;
+                        session->reorder_timeout = cfg->reorder_timeout;
+                        session->offset = cfg->offset;
+                        session->l2specific_type = cfg->l2specific_type;
+                        session->l2specific_len = cfg->l2specific_len;
+                        session->cookie_len = cfg->cookie_len;
+                        memcpy(&session->cookie[0], &cfg->cookie[0], cfg->cookie_len);
+                        session->peer_cookie_len = cfg->peer_cookie_len;
+                        memcpy(&session->peer_cookie[0], &cfg->peer_cookie[0], cfg->peer_cookie_len);
+                }
+
+                if (tunnel->version == L2TP_HDR_VER_2)
+                        session->build_header = l2tp_build_l2tpv2_header;
+                else
+                        session->build_header = l2tp_build_l2tpv3_header;
+
+                l2tp_session_set_header_len(session, tunnel->version);
+
+                /* Bump the reference count. The session context is deleted
+                 * only when this drops to zero.
+                 */
+                l2tp_session_inc_refcount(session);
+                l2tp_tunnel_inc_refcount(tunnel);
+
+                /* Ensure tunnel socket isn't deleted */
+                sock_hold(tunnel->sock);
+
+                /* Add session to the tunnel's hash list */
+                write_lock_bh(&tunnel->hlist_lock);
+                hlist_add_head(&session->hlist,
+                               l2tp_session_id_hash(tunnel, session_id));
+                write_unlock_bh(&tunnel->hlist_lock);
+
+                /* And to the global session list if L2TPv3 */
+                if (tunnel->version != L2TP_HDR_VER_2) {
+                        struct l2tp_net *pn = l2tp_pernet(tunnel->l2tp_net);
+
+                        spin_lock_bh(&pn->l2tp_session_hlist_lock);
+                        hlist_add_head_rcu(&session->global_hlist,
+                                           l2tp_session_id_hash_2(pn, session_id));
+                        spin_unlock_bh(&pn->l2tp_session_hlist_lock);
+                        synchronize_rcu();
+                }
+
+                /* Ignore management session in session count value */
+                if (session->session_id != 0)
+                        atomic_inc(&l2tp_session_count);
+        }
+
+        return session;
+}
+EXPORT_SYMBOL_GPL(l2tp_session_create);
+
+/*****************************************************************************
+ * Init and cleanup
+ *****************************************************************************/
+
+static __net_init int l2tp_init_net(struct net *net)
+{
+        struct l2tp_net *pn = net_generic(net, l2tp_net_id);
+        int hash;
+
+        INIT_LIST_HEAD(&pn->l2tp_tunnel_list);
+        spin_lock_init(&pn->l2tp_tunnel_list_lock);
+
+        for (hash = 0; hash < L2TP_HASH_SIZE_2; hash++)
+                INIT_HLIST_HEAD(&pn->l2tp_session_hlist[hash]);
+
+        spin_lock_init(&pn->l2tp_session_hlist_lock);
+
+        return 0;
+}
+
+static struct pernet_operations l2tp_net_ops = {
+        .init = l2tp_init_net,
+        .id   = &l2tp_net_id,
+        .size = sizeof(struct l2tp_net),
+};
+
+static int __init l2tp_init(void)
+{
+        int rc = 0;
+
+        rc = register_pernet_device(&l2tp_net_ops);
+        if (rc)
+                goto out;
+
+        printk(KERN_INFO "L2TP core driver, %s\n", L2TP_DRV_VERSION);
+
+out:
+        return rc;
+}
+
+static void __exit l2tp_exit(void)
+{
+        unregister_pernet_device(&l2tp_net_ops);
+}
+
+module_init(l2tp_init);
+module_exit(l2tp_exit);
+
+MODULE_AUTHOR("James Chapman <jchapman@katalix.com>");
+MODULE_DESCRIPTION("L2TP core");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(L2TP_DRV_VERSION);
+
diff --git a/net/l2tp/l2tp_core.h b/net/l2tp/l2tp_core.h
new file mode 100644
index 000000000000..f0f318edd3f1
--- /dev/null
+++ b/net/l2tp/l2tp_core.h
@@ -0,0 +1,304 @@
+/*
+ * L2TP internal definitions.
+ *
+ * Copyright (c) 2008,2009 Katalix Systems Ltd
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef _L2TP_CORE_H_
+#define _L2TP_CORE_H_
+
+/* Just some random numbers */
+#define L2TP_TUNNEL_MAGIC       0x42114DDA
+#define L2TP_SESSION_MAGIC      0x0C04EB7D
+
+/* Per tunnel, session hash table size */
+#define L2TP_HASH_BITS  4
+#define L2TP_HASH_SIZE  (1 << L2TP_HASH_BITS)
+
+/* System-wide, session hash table size */
+#define L2TP_HASH_BITS_2        8
+#define L2TP_HASH_SIZE_2        (1 << L2TP_HASH_BITS_2)
+
+/* Debug message categories for the DEBUG socket option */
+enum {
+        L2TP_MSG_DEBUG          = (1 << 0),     /* verbose debug (if
+                                                 * compiled in) */
+        L2TP_MSG_CONTROL        = (1 << 1),     /* userspace - kernel
+                                                 * interface */
+        L2TP_MSG_SEQ            = (1 << 2),     /* sequence numbers */
+        L2TP_MSG_DATA           = (1 << 3),     /* data packets */
+};
+
+struct sk_buff;
+
+struct l2tp_stats {
+        u64                     tx_packets;
+        u64                     tx_bytes;
+        u64                     tx_errors;
+        u64                     rx_packets;
+        u64                     rx_bytes;
+        u64                     rx_seq_discards;
+        u64                     rx_oos_packets;
+        u64                     rx_errors;
+        u64                     rx_cookie_discards;
+};
+
+struct l2tp_tunnel;
+
+/* Describes a session. Contains information to determine incoming
+ * packets and transmit outgoing ones.
+ */
+struct l2tp_session_cfg {
+        enum l2tp_pwtype        pw_type;
+        unsigned                data_seq:2;     /* data sequencing level
+                                                 * 0 => none, 1 => IP only,
+                                                 * 2 => all
+                                                 */
+        unsigned                recv_seq:1;     /* expect receive packets with
+                                                 * sequence numbers? */
+        unsigned                send_seq:1;     /* send packets with sequence
+                                                 * numbers? */
+        unsigned                lns_mode:1;     /* behave as LNS? LAC enables
+                                                 * sequence numbers under
+                                                 * control of LNS. */
+        int                     debug;          /* bitmask of debug message
+                                                 * categories */
+        u16                     vlan_id;        /* VLAN pseudowire only */
+        u16                     offset;         /* offset to payload */
+        u16                     l2specific_len; /* Layer 2 specific length */
+        u16                     l2specific_type; /* Layer 2 specific type */
+        u8                      cookie[8];      /* optional cookie */
+        int                     cookie_len;     /* 0, 4 or 8 bytes */
+        u8                      peer_cookie[8]; /* peer's cookie */
+        int                     peer_cookie_len; /* 0, 4 or 8 bytes */
+        int                     reorder_timeout; /* configured reorder timeout
+                                                  * (in jiffies) */
+        int                     mtu;
+        int                     mru;
+        char                    *ifname;
+};
+
+struct l2tp_session {
+        int                     magic;          /* should be
+                                                 * L2TP_SESSION_MAGIC */
+
+        struct l2tp_tunnel      *tunnel;        /* back pointer to tunnel
+                                                 * context */
+        u32                     session_id;
+        u32                     peer_session_id;
+        u8                      cookie[8];
+        int                     cookie_len;
+        u8                      peer_cookie[8];
+        int                     peer_cookie_len;
+        u16                     offset;         /* offset from end of L2TP header
+                                                   to beginning of data */
+        u16                     l2specific_len;
+        u16                     l2specific_type;
+        u16                     hdr_len;
+        u32                     nr;             /* session NR state (receive) */
+        u32                     ns;             /* session NR state (send) */
+        struct sk_buff_head     reorder_q;      /* receive reorder queue */
+        struct hlist_node       hlist;          /* Hash list node */
+        atomic_t                ref_count;
+
+        char                    name[32];       /* for logging */
+        char                    ifname[IFNAMSIZ];
+        unsigned                data_seq:2;     /* data sequencing level
+                                                 * 0 => none, 1 => IP only,
+                                                 * 2 => all
+                                                 */
+        unsigned                recv_seq:1;     /* expect receive packets with
+                                                 * sequence numbers? */
+        unsigned                send_seq:1;     /* send packets with sequence
+                                                 * numbers? */
+        unsigned                lns_mode:1;     /* behave as LNS? LAC enables
+                                                 * sequence numbers under
+                                                 * control of LNS. */
+        int                     debug;          /* bitmask of debug message
+                                                 * categories */
+        int                     reorder_timeout; /* configured reorder timeout
+                                                  * (in jiffies) */
+        int                     mtu;
+        int                     mru;
+        enum l2tp_pwtype        pwtype;
+        struct l2tp_stats       stats;
+        struct hlist_node       global_hlist;   /* Global hash list node */
+
+        int (*build_header)(struct l2tp_session *session, void *buf);
+        void (*recv_skb)(struct l2tp_session *session, struct sk_buff *skb, int data_len);
+        void (*session_close)(struct l2tp_session *session);
+        void (*ref)(struct l2tp_session *session);
+        void (*deref)(struct l2tp_session *session);
+#if defined(CONFIG_L2TP_DEBUGFS) || defined(CONFIG_L2TP_DEBUGFS_MODULE)
+        void (*show)(struct seq_file *m, void *priv);
+#endif
+        uint8_t                 priv[0];        /* private data */
+};
+
+/* Describes the tunnel. It contains info to track all the associated
+ * sessions so incoming packets can be sorted out
+ */
+struct l2tp_tunnel_cfg {
+        int                     debug;          /* bitmask of debug message
+                                                 * categories */
+        enum l2tp_encap_type    encap;
+
+        /* Used only for kernel-created sockets */
+        struct in_addr          local_ip;
+        struct in_addr          peer_ip;
+        u16                     local_udp_port;
+        u16                     peer_udp_port;
+        unsigned int            use_udp_checksums:1;
+};
+
+struct l2tp_tunnel {
+        int                     magic;          /* Should be L2TP_TUNNEL_MAGIC */
+        rwlock_t                hlist_lock;     /* protect session_hlist */
+        struct hlist_head       session_hlist[L2TP_HASH_SIZE];
+                                                /* hashed list of sessions,
+                                                 * hashed by id */
+        u32                     tunnel_id;
+        u32                     peer_tunnel_id;
+        int                     version;        /* 2=>L2TPv2, 3=>L2TPv3 */
+
+        char                    name[20];       /* for logging */
+        int                     debug;          /* bitmask of debug message
+                                                 * categories */
+        enum l2tp_encap_type    encap;
+        struct l2tp_stats       stats;
+
+        struct list_head        list;           /* Keep a list of all tunnels */
+        struct net              *l2tp_net;      /* the net we belong to */
+
+        atomic_t                ref_count;
+#ifdef CONFIG_DEBUG_FS
+        void (*show)(struct seq_file *m, void *arg);
+#endif
+        int (*recv_payload_hook)(struct sk_buff *skb);
+        void (*old_sk_destruct)(struct sock *);
+        struct sock             *sock;          /* Parent socket */
+        int                     fd;
+
+        uint8_t                 priv[0];        /* private data */
+};
+
+struct l2tp_nl_cmd_ops {
+        int (*session_create)(struct net *net, u32 tunnel_id, u32 session_id, u32 peer_session_id, struct l2tp_session_cfg *cfg);
+        int (*session_delete)(struct l2tp_session *session);
+};
+
+static inline void *l2tp_tunnel_priv(struct l2tp_tunnel *tunnel)
+{
+        return &tunnel->priv[0];
+}
+
+static inline void *l2tp_session_priv(struct l2tp_session *session)
+{
+        return &session->priv[0];
+}
+
+static inline struct l2tp_tunnel *l2tp_sock_to_tunnel(struct sock *sk)
+{
+        struct l2tp_tunnel *tunnel;
+
+        if (sk == NULL)
+                return NULL;
+
+        sock_hold(sk);
+        tunnel = (struct l2tp_tunnel *)(sk->sk_user_data);
+        if (tunnel == NULL) {
+                sock_put(sk);
+                goto out;
+        }
+
+        BUG_ON(tunnel->magic != L2TP_TUNNEL_MAGIC);
+
+out:
+        return tunnel;
+}
+
+extern struct l2tp_session *l2tp_session_find(struct net *net, struct l2tp_tunnel *tunnel, u32 session_id);
+extern struct l2tp_session *l2tp_session_find_nth(struct l2tp_tunnel *tunnel, int nth);
+extern struct l2tp_session *l2tp_session_find_by_ifname(struct net *net, char *ifname);
+extern struct l2tp_tunnel *l2tp_tunnel_find(struct net *net, u32 tunnel_id);
+extern struct l2tp_tunnel *l2tp_tunnel_find_nth(struct net *net, int nth);
+
+extern int l2tp_tunnel_create(struct net *net, int fd, int version, u32 tunnel_id, u32 peer_tunnel_id, struct l2tp_tunnel_cfg *cfg, struct l2tp_tunnel **tunnelp);
+extern int l2tp_tunnel_delete(struct l2tp_tunnel *tunnel);
+extern struct l2tp_session *l2tp_session_create(int priv_size, struct l2tp_tunnel *tunnel, u32 session_id, u32 peer_session_id, struct l2tp_session_cfg *cfg);
+extern int l2tp_session_delete(struct l2tp_session *session);
+extern void l2tp_tunnel_free(struct l2tp_tunnel *tunnel);
+extern void l2tp_session_free(struct l2tp_session *session);
+extern void l2tp_recv_common(struct l2tp_session *session, struct sk_buff *skb, unsigned char *ptr, unsigned char *optr, u16 hdrflags, int length, int (*payload_hook)(struct sk_buff *skb));
+extern int l2tp_udp_recv_core(struct l2tp_tunnel *tunnel, struct sk_buff *skb, int (*payload_hook)(struct sk_buff *skb));
+extern int l2tp_udp_encap_recv(struct sock *sk, struct sk_buff *skb);
+
+extern int l2tp_xmit_core(struct l2tp_session *session, struct sk_buff *skb, size_t data_len);
+extern int l2tp_xmit_skb(struct l2tp_session *session, struct sk_buff *skb, int hdr_len);
+extern void l2tp_tunnel_destruct(struct sock *sk);
+extern void l2tp_tunnel_closeall(struct l2tp_tunnel *tunnel);
+extern void l2tp_session_set_header_len(struct l2tp_session *session, int version);
+
+extern int l2tp_nl_register_ops(enum l2tp_pwtype pw_type, const struct l2tp_nl_cmd_ops *ops);
+extern void l2tp_nl_unregister_ops(enum l2tp_pwtype pw_type);
+
+/* Tunnel reference counts. Incremented per session that is added to
+ * the tunnel.
+ */
+static inline void l2tp_tunnel_inc_refcount_1(struct l2tp_tunnel *tunnel)
+{
+        atomic_inc(&tunnel->ref_count);
+}
+
+static inline void l2tp_tunnel_dec_refcount_1(struct l2tp_tunnel *tunnel)
+{
+        if (atomic_dec_and_test(&tunnel->ref_count))
+                l2tp_tunnel_free(tunnel);
+}
+#ifdef L2TP_REFCNT_DEBUG
+#define l2tp_tunnel_inc_refcount(_t) do { \
+                printk(KERN_DEBUG "l2tp_tunnel_inc_refcount: %s:%d %s: cnt=%d\n", __func__, __LINE__, (_t)->name, atomic_read(&_t->ref_count)); \
+                l2tp_tunnel_inc_refcount_1(_t);                         \
+        } while (0)
+#define l2tp_tunnel_dec_refcount(_t) do { \
+                printk(KERN_DEBUG "l2tp_tunnel_dec_refcount: %s:%d %s: cnt=%d\n", __func__, __LINE__, (_t)->name, atomic_read(&_t->ref_count)); \
+                l2tp_tunnel_dec_refcount_1(_t);                         \
+        } while (0)
+#else
+#define l2tp_tunnel_inc_refcount(t) l2tp_tunnel_inc_refcount_1(t)
+#define l2tp_tunnel_dec_refcount(t) l2tp_tunnel_dec_refcount_1(t)
+#endif
+
+/* Session reference counts. Incremented when code obtains a reference
+ * to a session.
+ */
+static inline void l2tp_session_inc_refcount_1(struct l2tp_session *session)
+{
+        atomic_inc(&session->ref_count);
+}
+
+static inline void l2tp_session_dec_refcount_1(struct l2tp_session *session)
+{
+        if (atomic_dec_and_test(&session->ref_count))
+                l2tp_session_free(session);
+}
+
+#ifdef L2TP_REFCNT_DEBUG
+#define l2tp_session_inc_refcount(_s) do { \
+                printk(KERN_DEBUG "l2tp_session_inc_refcount: %s:%d %s: cnt=%d\n", __func__, __LINE__, (_s)->name, atomic_read(&_s->ref_count)); \
+                l2tp_session_inc_refcount_1(_s);                                \
+        } while (0)
+#define l2tp_session_dec_refcount(_s) do { \
+                printk(KERN_DEBUG "l2tp_session_dec_refcount: %s:%d %s: cnt=%d\n", __func__, __LINE__, (_s)->name, atomic_read(&_s->ref_count)); \
+                l2tp_session_dec_refcount_1(_s);                                \
+        } while (0)
+#else
+#define l2tp_session_inc_refcount(s) l2tp_session_inc_refcount_1(s)
+#define l2tp_session_dec_refcount(s) l2tp_session_dec_refcount_1(s)
+#endif
+
+#endif /* _L2TP_CORE_H_ */
diff --git a/net/l2tp/l2tp_debugfs.c b/net/l2tp/l2tp_debugfs.c
new file mode 100644
index 000000000000..104ec3b283d4
--- /dev/null
+++ b/net/l2tp/l2tp_debugfs.c
@@ -0,0 +1,341 @@
+/*
+ * L2TP subsystem debugfs
+ *
+ * Copyright (c) 2010 Katalix Systems Ltd
+ *
+ *      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.
+ */
+
+#include <linux/module.h>
+#include <linux/skbuff.h>
+#include <linux/socket.h>
+#include <linux/hash.h>
+#include <linux/l2tp.h>
+#include <linux/in.h>
+#include <linux/etherdevice.h>
+#include <linux/spinlock.h>
+#include <linux/debugfs.h>
+#include <net/sock.h>
+#include <net/ip.h>
+#include <net/icmp.h>
+#include <net/udp.h>
+#include <net/inet_common.h>
+#include <net/inet_hashtables.h>
+#include <net/tcp_states.h>
+#include <net/protocol.h>
+#include <net/xfrm.h>
+#include <net/net_namespace.h>
+#include <net/netns/generic.h>
+
+#include "l2tp_core.h"
+
+static struct dentry *rootdir;
+static struct dentry *tunnels;
+
+struct l2tp_dfs_seq_data {
+        struct net *net;
+        int tunnel_idx;                 /* current tunnel */
+        int session_idx;                /* index of session within current tunnel */
+        struct l2tp_tunnel *tunnel;
+        struct l2tp_session *session;   /* NULL means get next tunnel */
+};
+
+static void l2tp_dfs_next_tunnel(struct l2tp_dfs_seq_data *pd)
+{
+        pd->tunnel = l2tp_tunnel_find_nth(pd->net, pd->tunnel_idx);
+        pd->tunnel_idx++;
+}
+
+static void l2tp_dfs_next_session(struct l2tp_dfs_seq_data *pd)
+{
+        pd->session = l2tp_session_find_nth(pd->tunnel, pd->session_idx);
+        pd->session_idx++;
+
+        if (pd->session == NULL) {
+                pd->session_idx = 0;
+                l2tp_dfs_next_tunnel(pd);
+        }
+
+}
+
+static void *l2tp_dfs_seq_start(struct seq_file *m, loff_t *offs)
+{
+        struct l2tp_dfs_seq_data *pd = SEQ_START_TOKEN;
+        loff_t pos = *offs;
+
+        if (!pos)
+                goto out;
+
+        BUG_ON(m->private == NULL);
+        pd = m->private;
+
+        if (pd->tunnel == NULL)
+                l2tp_dfs_next_tunnel(pd);
+        else
+                l2tp_dfs_next_session(pd);
+
+        /* NULL tunnel and session indicates end of list */
+        if ((pd->tunnel == NULL) && (pd->session == NULL))
+                pd = NULL;
+
+out:
+        return pd;
+}
+
+
+static void *l2tp_dfs_seq_next(struct seq_file *m, void *v, loff_t *pos)
+{
+        (*pos)++;
+        return NULL;
+}
+
+static void l2tp_dfs_seq_stop(struct seq_file *p, void *v)
+{
+        /* nothing to do */
+}
+
+static void l2tp_dfs_seq_tunnel_show(struct seq_file *m, void *v)
+{
+        struct l2tp_tunnel *tunnel = v;
+        int session_count = 0;
+        int hash;
+        struct hlist_node *walk;
+        struct hlist_node *tmp;
+
+        read_lock_bh(&tunnel->hlist_lock);
+        for (hash = 0; hash < L2TP_HASH_SIZE; hash++) {
+                hlist_for_each_safe(walk, tmp, &tunnel->session_hlist[hash]) {
+                        struct l2tp_session *session;
+
+                        session = hlist_entry(walk, struct l2tp_session, hlist);
+                        if (session->session_id == 0)
+                                continue;
+
+                        session_count++;
+                }
+        }
+        read_unlock_bh(&tunnel->hlist_lock);
+
+        seq_printf(m, "\nTUNNEL %u peer %u", tunnel->tunnel_id, tunnel->peer_tunnel_id);
+        if (tunnel->sock) {
+                struct inet_sock *inet = inet_sk(tunnel->sock);
+                seq_printf(m, " from %pI4 to %pI4\n",
+                           &inet->inet_saddr, &inet->inet_daddr);
+                if (tunnel->encap == L2TP_ENCAPTYPE_UDP)
+                        seq_printf(m, " source port %hu, dest port %hu\n",
+                                   ntohs(inet->inet_sport), ntohs(inet->inet_dport));
+        }
+        seq_printf(m, " L2TPv%d, %s\n", tunnel->version,
+                   tunnel->encap == L2TP_ENCAPTYPE_UDP ? "UDP" :
+                   tunnel->encap == L2TP_ENCAPTYPE_IP ? "IP" :
+                   "");
+        seq_printf(m, " %d sessions, refcnt %d/%d\n", session_count,
+                   tunnel->sock ? atomic_read(&tunnel->sock->sk_refcnt) : 0,
+                   atomic_read(&tunnel->ref_count));
+
+        seq_printf(m, " %08x rx %llu/%llu/%llu rx %llu/%llu/%llu\n",
+                   tunnel->debug,
+                   (unsigned long long)tunnel->stats.tx_packets,
+                   (unsigned long long)tunnel->stats.tx_bytes,
+                   (unsigned long long)tunnel->stats.tx_errors,
+                   (unsigned long long)tunnel->stats.rx_packets,
+                   (unsigned long long)tunnel->stats.rx_bytes,
+                   (unsigned long long)tunnel->stats.rx_errors);
+
+        if (tunnel->show != NULL)
+                tunnel->show(m, tunnel);
+}
+
+static void l2tp_dfs_seq_session_show(struct seq_file *m, void *v)
+{
+        struct l2tp_session *session = v;
+
+        seq_printf(m, "  SESSION %u, peer %u, %s\n", session->session_id,
+                   session->peer_session_id,
+                   session->pwtype == L2TP_PWTYPE_ETH ? "ETH" :
+                   session->pwtype == L2TP_PWTYPE_PPP ? "PPP" :
+                   "");
+        if (session->send_seq || session->recv_seq)
+                seq_printf(m, "   nr %hu, ns %hu\n", session->nr, session->ns);
+        seq_printf(m, "   refcnt %d\n", atomic_read(&session->ref_count));
+        seq_printf(m, "   config %d/%d/%c/%c/%s/%s %08x %u\n",
+                   session->mtu, session->mru,
+                   session->recv_seq ? 'R' : '-',
+                   session->send_seq ? 'S' : '-',
+                   session->data_seq == 1 ? "IPSEQ" :
+                   session->data_seq == 2 ? "DATASEQ" : "-",
+                   session->lns_mode ? "LNS" : "LAC",
+                   session->debug,
+                   jiffies_to_msecs(session->reorder_timeout));
+        seq_printf(m, "   offset %hu l2specific %hu/%hu\n",
+                   session->offset, session->l2specific_type, session->l2specific_len);
+        if (session->cookie_len) {
+                seq_printf(m, "   cookie %02x%02x%02x%02x",
+                           session->cookie[0], session->cookie[1],
+                           session->cookie[2], session->cookie[3]);
+                if (session->cookie_len == 8)
+                        seq_printf(m, "%02x%02x%02x%02x",
+                                   session->cookie[4], session->cookie[5],
+                                   session->cookie[6], session->cookie[7]);
+                seq_printf(m, "\n");
+        }
+        if (session->peer_cookie_len) {
+                seq_printf(m, "   peer cookie %02x%02x%02x%02x",
+                           session->peer_cookie[0], session->peer_cookie[1],
+                           session->peer_cookie[2], session->peer_cookie[3]);
+                if (session->peer_cookie_len == 8)
+                        seq_printf(m, "%02x%02x%02x%02x",
+                                   session->peer_cookie[4], session->peer_cookie[5],
+                                   session->peer_cookie[6], session->peer_cookie[7]);
+                seq_printf(m, "\n");
+        }
+
+        seq_printf(m, "   %hu/%hu tx %llu/%llu/%llu rx %llu/%llu/%llu\n",
+                   session->nr, session->ns,
+                   (unsigned long long)session->stats.tx_packets,
+                   (unsigned long long)session->stats.tx_bytes,
+                   (unsigned long long)session->stats.tx_errors,
+                   (unsigned long long)session->stats.rx_packets,
+                   (unsigned long long)session->stats.rx_bytes,
+                   (unsigned long long)session->stats.rx_errors);
+
+        if (session->show != NULL)
+                session->show(m, session);
+}
+
+static int l2tp_dfs_seq_show(struct seq_file *m, void *v)
+{
+        struct l2tp_dfs_seq_data *pd = v;
+
+        /* display header on line 1 */
+        if (v == SEQ_START_TOKEN) {
+                seq_puts(m, "TUNNEL ID, peer ID from IP to IP\n");
+                seq_puts(m, " L2TPv2/L2TPv3, UDP/IP\n");
+                seq_puts(m, " sessions session-count, refcnt refcnt/sk->refcnt\n");
+                seq_puts(m, " debug tx-pkts/bytes/errs rx-pkts/bytes/errs\n");
+                seq_puts(m, "  SESSION ID, peer ID, PWTYPE\n");
+                seq_puts(m, "   refcnt cnt\n");
+                seq_puts(m, "   offset OFFSET l2specific TYPE/LEN\n");
+                seq_puts(m, "   [ cookie ]\n");
+                seq_puts(m, "   [ peer cookie ]\n");
+                seq_puts(m, "   config mtu/mru/rcvseq/sendseq/dataseq/lns debug reorderto\n");
+                seq_puts(m, "   nr/ns tx-pkts/bytes/errs rx-pkts/bytes/errs\n");
+                goto out;
+        }
+
+        /* Show the tunnel or session context */
+        if (pd->session == NULL)
+                l2tp_dfs_seq_tunnel_show(m, pd->tunnel);
+        else
+                l2tp_dfs_seq_session_show(m, pd->session);
+
+out:
+        return 0;
+}
+
+static const struct seq_operations l2tp_dfs_seq_ops = {
+        .start          = l2tp_dfs_seq_start,
+        .next           = l2tp_dfs_seq_next,
+        .stop           = l2tp_dfs_seq_stop,
+        .show           = l2tp_dfs_seq_show,
+};
+
+static int l2tp_dfs_seq_open(struct inode *inode, struct file *file)
+{
+        struct l2tp_dfs_seq_data *pd;
+        struct seq_file *seq;
+        int rc = -ENOMEM;
+
+        pd = kzalloc(GFP_KERNEL, sizeof(*pd));
+        if (pd == NULL)
+                goto out;
+
+        /* Derive the network namespace from the pid opening the
+         * file.
+         */
+        pd->net = get_net_ns_by_pid(current->pid);
+        if (IS_ERR(pd->net)) {
+                rc = -PTR_ERR(pd->net);
+                goto err_free_pd;
+        }
+
+        rc = seq_open(file, &l2tp_dfs_seq_ops);
+        if (rc)
+                goto err_free_net;
+
+        seq = file->private_data;
+        seq->private = pd;
+
+out:
+        return rc;
+
+err_free_net:
+        put_net(pd->net);
+err_free_pd:
+        kfree(pd);
+        goto out;
+}
+
+static int l2tp_dfs_seq_release(struct inode *inode, struct file *file)
+{
+        struct l2tp_dfs_seq_data *pd;
+        struct seq_file *seq;
+
+        seq = file->private_data;
+        pd = seq->private;
+        if (pd->net)
+                put_net(pd->net);
+        kfree(pd);
+        seq_release(inode, file);
+
+        return 0;
+}
+
+static const struct file_operations l2tp_dfs_fops = {
+        .owner          = THIS_MODULE,
+        .open           = l2tp_dfs_seq_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = l2tp_dfs_seq_release,
+};
+
+static int __init l2tp_debugfs_init(void)
+{
+        int rc = 0;
+
+        rootdir = debugfs_create_dir("l2tp", NULL);
+        if (IS_ERR(rootdir)) {
+                rc = PTR_ERR(rootdir);
+                rootdir = NULL;
+                goto out;
+        }
+
+        tunnels = debugfs_create_file("tunnels", 0600, rootdir, NULL, &l2tp_dfs_fops);
+        if (tunnels == NULL)
+                rc = -EIO;
+
+        printk(KERN_INFO "L2TP debugfs support\n");
+
+out:
+        if (rc)
+                printk(KERN_WARNING "l2tp debugfs: unable to init\n");
+
+        return rc;
+}
+
+static void __exit l2tp_debugfs_exit(void)
+{
+        debugfs_remove(tunnels);
+        debugfs_remove(rootdir);
+}
+
+module_init(l2tp_debugfs_init);
+module_exit(l2tp_debugfs_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("James Chapman <jchapman@katalix.com>");
+MODULE_DESCRIPTION("L2TP debugfs driver");
+MODULE_VERSION("1.0");
diff --git a/net/l2tp/l2tp_eth.c b/net/l2tp/l2tp_eth.c
new file mode 100644
index 000000000000..58c6c4cda73b
--- /dev/null
+++ b/net/l2tp/l2tp_eth.c
@@ -0,0 +1,334 @@
+/*
+ * L2TPv3 ethernet pseudowire driver
+ *
+ * Copyright (c) 2008,2009,2010 Katalix Systems Ltd
+ *
+ *      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.
+ */
+
+#include <linux/module.h>
+#include <linux/skbuff.h>
+#include <linux/socket.h>
+#include <linux/hash.h>
+#include <linux/l2tp.h>
+#include <linux/in.h>
+#include <linux/etherdevice.h>
+#include <linux/spinlock.h>
+#include <net/sock.h>
+#include <net/ip.h>
+#include <net/icmp.h>
+#include <net/udp.h>
+#include <net/inet_common.h>
+#include <net/inet_hashtables.h>
+#include <net/tcp_states.h>
+#include <net/protocol.h>
+#include <net/xfrm.h>
+#include <net/net_namespace.h>
+#include <net/netns/generic.h>
+
+#include "l2tp_core.h"
+
+/* Default device name. May be overridden by name specified by user */
+#define L2TP_ETH_DEV_NAME       "l2tpeth%d"
+
+/* via netdev_priv() */
+struct l2tp_eth {
+        struct net_device       *dev;
+        struct sock             *tunnel_sock;
+        struct l2tp_session     *session;
+        struct list_head        list;
+};
+
+/* via l2tp_session_priv() */
+struct l2tp_eth_sess {
+        struct net_device       *dev;
+};
+
+/* per-net private data for this module */
+static unsigned int l2tp_eth_net_id;
+struct l2tp_eth_net {
+        struct list_head l2tp_eth_dev_list;
+        spinlock_t l2tp_eth_lock;
+};
+
+static inline struct l2tp_eth_net *l2tp_eth_pernet(struct net *net)
+{
+        return net_generic(net, l2tp_eth_net_id);
+}
+
+static int l2tp_eth_dev_init(struct net_device *dev)
+{
+        struct l2tp_eth *priv = netdev_priv(dev);
+
+        priv->dev = dev;
+        random_ether_addr(dev->dev_addr);
+        memset(&dev->broadcast[0], 0xff, 6);
+
+        return 0;
+}
+
+static void l2tp_eth_dev_uninit(struct net_device *dev)
+{
+        struct l2tp_eth *priv = netdev_priv(dev);
+        struct l2tp_eth_net *pn = l2tp_eth_pernet(dev_net(dev));
+
+        spin_lock(&pn->l2tp_eth_lock);
+        list_del_init(&priv->list);
+        spin_unlock(&pn->l2tp_eth_lock);
+        dev_put(dev);
+}
+
+static int l2tp_eth_dev_xmit(struct sk_buff *skb, struct net_device *dev)
+{
+        struct l2tp_eth *priv = netdev_priv(dev);
+        struct l2tp_session *session = priv->session;
+
+        l2tp_xmit_skb(session, skb, session->hdr_len);
+
+        dev->stats.tx_bytes += skb->len;
+        dev->stats.tx_packets++;
+
+        return 0;
+}
+
+static struct net_device_ops l2tp_eth_netdev_ops = {
+        .ndo_init               = l2tp_eth_dev_init,
+        .ndo_uninit             = l2tp_eth_dev_uninit,
+        .ndo_start_xmit         = l2tp_eth_dev_xmit,
+};
+
+static void l2tp_eth_dev_setup(struct net_device *dev)
+{
+        ether_setup(dev);
+
+        dev->netdev_ops         = &l2tp_eth_netdev_ops;
+        dev->destructor         = free_netdev;
+}
+
+static void l2tp_eth_dev_recv(struct l2tp_session *session, struct sk_buff *skb, int data_len)
+{
+        struct l2tp_eth_sess *spriv = l2tp_session_priv(session);
+        struct net_device *dev = spriv->dev;
+
+        if (session->debug & L2TP_MSG_DATA) {
+                unsigned int length;
+                int offset;
+                u8 *ptr = skb->data;
+
+                length = min(32u, skb->len);
+                if (!pskb_may_pull(skb, length))
+                        goto error;
+
+                printk(KERN_DEBUG "%s: eth recv: ", session->name);
+
+                offset = 0;
+                do {
+                        printk(" %02X", ptr[offset]);
+                } while (++offset < length);
+
+                printk("\n");
+        }
+
+        if (data_len < ETH_HLEN)
+                goto error;
+
+        secpath_reset(skb);
+
+        /* checksums verified by L2TP */
+        skb->ip_summed = CHECKSUM_NONE;
+
+        skb_dst_drop(skb);
+        nf_reset(skb);
+
+        if (dev_forward_skb(dev, skb) == NET_RX_SUCCESS) {
+                dev->last_rx = jiffies;
+                dev->stats.rx_packets++;
+                dev->stats.rx_bytes += data_len;
+        } else
+                dev->stats.rx_errors++;
+
+        return;
+
+error:
+        dev->stats.rx_errors++;
+        kfree_skb(skb);
+}
+
+static void l2tp_eth_delete(struct l2tp_session *session)
+{
+        struct l2tp_eth_sess *spriv;
+        struct net_device *dev;
+
+        if (session) {
+                spriv = l2tp_session_priv(session);
+                dev = spriv->dev;
+                if (dev) {
+                        unregister_netdev(dev);
+                        spriv->dev = NULL;
+                }
+        }
+}
+
+#if defined(CONFIG_L2TP_DEBUGFS) || defined(CONFIG_L2TP_DEBUGFS_MODULE)
+static void l2tp_eth_show(struct seq_file *m, void *arg)
+{
+        struct l2tp_session *session = arg;
+        struct l2tp_eth_sess *spriv = l2tp_session_priv(session);
+        struct net_device *dev = spriv->dev;
+
+        seq_printf(m, "   interface %s\n", dev->name);
+}
+#endif
+
+static int l2tp_eth_create(struct net *net, u32 tunnel_id, u32 session_id, u32 peer_session_id, struct l2tp_session_cfg *cfg)
+{
+        struct net_device *dev;
+        char name[IFNAMSIZ];
+        struct l2tp_tunnel *tunnel;
+        struct l2tp_session *session;
+        struct l2tp_eth *priv;
+        struct l2tp_eth_sess *spriv;
+        int rc;
+        struct l2tp_eth_net *pn;
+
+        tunnel = l2tp_tunnel_find(net, tunnel_id);
+        if (!tunnel) {
+                rc = -ENODEV;
+                goto out;
+        }
+
+        session = l2tp_session_find(net, tunnel, session_id);
+        if (session) {
+                rc = -EEXIST;
+                goto out;
+        }
+
+        if (cfg->ifname) {
+                dev = dev_get_by_name(net, cfg->ifname);
+                if (dev) {
+                        dev_put(dev);
+                        rc = -EEXIST;
+                        goto out;
+                }
+                strlcpy(name, cfg->ifname, IFNAMSIZ);
+        } else
+                strcpy(name, L2TP_ETH_DEV_NAME);
+
+        session = l2tp_session_create(sizeof(*spriv), tunnel, session_id,
+                                      peer_session_id, cfg);
+        if (!session) {
+                rc = -ENOMEM;
+                goto out;
+        }
+
+        dev = alloc_netdev(sizeof(*priv), name, l2tp_eth_dev_setup);
+        if (!dev) {
+                rc = -ENOMEM;
+                goto out_del_session;
+        }
+
+        dev_net_set(dev, net);
+        if (session->mtu == 0)
+                session->mtu = dev->mtu - session->hdr_len;
+        dev->mtu = session->mtu;
+        dev->needed_headroom += session->hdr_len;
+
+        priv = netdev_priv(dev);
+        priv->dev = dev;
+        priv->session = session;
+        INIT_LIST_HEAD(&priv->list);
+
+        priv->tunnel_sock = tunnel->sock;
+        session->recv_skb = l2tp_eth_dev_recv;
+        session->session_close = l2tp_eth_delete;
+#if defined(CONFIG_L2TP_DEBUGFS) || defined(CONFIG_L2TP_DEBUGFS_MODULE)
+        session->show = l2tp_eth_show;
+#endif
+
+        spriv = l2tp_session_priv(session);
+        spriv->dev = dev;
+
+        rc = register_netdev(dev);
+        if (rc < 0)
+                goto out_del_dev;
+
+        /* Must be done after register_netdev() */
+        strlcpy(session->ifname, dev->name, IFNAMSIZ);
+
+        dev_hold(dev);
+        pn = l2tp_eth_pernet(dev_net(dev));
+        spin_lock(&pn->l2tp_eth_lock);
+        list_add(&priv->list, &pn->l2tp_eth_dev_list);
+        spin_unlock(&pn->l2tp_eth_lock);
+
+        return 0;
+
+out_del_dev:
+        free_netdev(dev);
+out_del_session:
+        l2tp_session_delete(session);
+out:
+        return rc;
+}
+
+static __net_init int l2tp_eth_init_net(struct net *net)
+{
+        struct l2tp_eth_net *pn = net_generic(net, l2tp_eth_net_id);
+
+        INIT_LIST_HEAD(&pn->l2tp_eth_dev_list);
+        spin_lock_init(&pn->l2tp_eth_lock);
+
+        return 0;
+}
+
+static __net_initdata struct pernet_operations l2tp_eth_net_ops = {
+        .init = l2tp_eth_init_net,
+        .id   = &l2tp_eth_net_id,
+        .size = sizeof(struct l2tp_eth_net),
+};
+
+
+static const struct l2tp_nl_cmd_ops l2tp_eth_nl_cmd_ops = {
+        .session_create = l2tp_eth_create,
+        .session_delete = l2tp_session_delete,
+};
+
+
+static int __init l2tp_eth_init(void)
+{
+        int err = 0;
+
+        err = l2tp_nl_register_ops(L2TP_PWTYPE_ETH, &l2tp_eth_nl_cmd_ops);
+        if (err)
+                goto out;
+
+        err = register_pernet_device(&l2tp_eth_net_ops);
+        if (err)
+                goto out_unreg;
+
+        printk(KERN_INFO "L2TP ethernet pseudowire support (L2TPv3)\n");
+
+        return 0;
+
+out_unreg:
+        l2tp_nl_unregister_ops(L2TP_PWTYPE_ETH);
+out:
+        return err;
+}
+
+static void __exit l2tp_eth_exit(void)
+{
+        unregister_pernet_device(&l2tp_eth_net_ops);
+        l2tp_nl_unregister_ops(L2TP_PWTYPE_ETH);
+}
+
+module_init(l2tp_eth_init);
+module_exit(l2tp_eth_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("James Chapman <jchapman@katalix.com>");
+MODULE_DESCRIPTION("L2TP ethernet pseudowire driver");
+MODULE_VERSION("1.0");
diff --git a/net/l2tp/l2tp_ip.c b/net/l2tp/l2tp_ip.c
new file mode 100644
index 000000000000..0852512d392c
--- /dev/null
+++ b/net/l2tp/l2tp_ip.c
@@ -0,0 +1,679 @@
+/*
+ * L2TPv3 IP encapsulation support
+ *
+ * Copyright (c) 2008,2009,2010 Katalix Systems Ltd
+ *
+ *      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.
+ */
+
+#include <linux/icmp.h>
+#include <linux/module.h>
+#include <linux/skbuff.h>
+#include <linux/random.h>
+#include <linux/socket.h>
+#include <linux/l2tp.h>
+#include <linux/in.h>
+#include <net/sock.h>
+#include <net/ip.h>
+#include <net/icmp.h>
+#include <net/udp.h>
+#include <net/inet_common.h>
+#include <net/inet_hashtables.h>
+#include <net/tcp_states.h>
+#include <net/protocol.h>
+#include <net/xfrm.h>
+
+#include "l2tp_core.h"
+
+struct l2tp_ip_sock {
+        /* inet_sock has to be the first member of l2tp_ip_sock */
+        struct inet_sock        inet;
+
+        __u32                   conn_id;
+        __u32                   peer_conn_id;
+
+        __u64                   tx_packets;
+        __u64                   tx_bytes;
+        __u64                   tx_errors;
+        __u64                   rx_packets;
+        __u64                   rx_bytes;
+        __u64                   rx_errors;
+};
+
+static DEFINE_RWLOCK(l2tp_ip_lock);
+static struct hlist_head l2tp_ip_table;
+static struct hlist_head l2tp_ip_bind_table;
+
+static inline struct l2tp_ip_sock *l2tp_ip_sk(const struct sock *sk)
+{
+        return (struct l2tp_ip_sock *)sk;
+}
+
+static struct sock *__l2tp_ip_bind_lookup(struct net *net, __be32 laddr, int dif, u32 tunnel_id)
+{
+        struct hlist_node *node;
+        struct sock *sk;
+
+        sk_for_each_bound(sk, node, &l2tp_ip_bind_table) {
+                struct inet_sock *inet = inet_sk(sk);
+                struct l2tp_ip_sock *l2tp = l2tp_ip_sk(sk);
+
+                if (l2tp == NULL)
+                        continue;
+
+                if ((l2tp->conn_id == tunnel_id) &&
+#ifdef CONFIG_NET_NS
+                    (sk->sk_net == net) &&
+#endif
+                    !(inet->inet_rcv_saddr && inet->inet_rcv_saddr != laddr) &&
+                    !(sk->sk_bound_dev_if && sk->sk_bound_dev_if != dif))
+                        goto found;
+        }
+
+        sk = NULL;
+found:
+        return sk;
+}
+
+static inline struct sock *l2tp_ip_bind_lookup(struct net *net, __be32 laddr, int dif, u32 tunnel_id)
+{
+        struct sock *sk = __l2tp_ip_bind_lookup(net, laddr, dif, tunnel_id);
+        if (sk)
+                sock_hold(sk);
+
+        return sk;
+}
+
+/* When processing receive frames, there are two cases to
+ * consider. Data frames consist of a non-zero session-id and an
+ * optional cookie. Control frames consist of a regular L2TP header
+ * preceded by 32-bits of zeros.
+ *
+ * L2TPv3 Session Header Over IP
+ *
+ *  0                   1                   2                   3
+ *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * |                           Session ID                          |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * |               Cookie (optional, maximum 64 bits)...
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *                                                                 |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *
+ * L2TPv3 Control Message Header Over IP
+ *
+ *  0                   1                   2                   3
+ *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * |                      (32 bits of zeros)                       |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * |T|L|x|x|S|x|x|x|x|x|x|x|  Ver  |             Length            |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * |                     Control Connection ID                     |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * |               Ns              |               Nr              |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *
+ * All control frames are passed to userspace.
+ */
+static int l2tp_ip_recv(struct sk_buff *skb)
+{
+        struct sock *sk;
+        u32 session_id;
+        u32 tunnel_id;
+        unsigned char *ptr, *optr;
+        struct l2tp_session *session;
+        struct l2tp_tunnel *tunnel = NULL;
+        int length;
+        int offset;
+
+        /* Point to L2TP header */
+        optr = ptr = skb->data;
+
+        if (!pskb_may_pull(skb, 4))
+                goto discard;
+
+        session_id = ntohl(*((__be32 *) ptr));
+        ptr += 4;
+
+        /* RFC3931: L2TP/IP packets have the first 4 bytes containing
+         * the session_id. If it is 0, the packet is a L2TP control
+         * frame and the session_id value can be discarded.
+         */
+        if (session_id == 0) {
+                __skb_pull(skb, 4);
+                goto pass_up;
+        }
+
+        /* Ok, this is a data packet. Lookup the session. */
+        session = l2tp_session_find(&init_net, NULL, session_id);
+        if (session == NULL)
+                goto discard;
+
+        tunnel = session->tunnel;
+        if (tunnel == NULL)
+                goto discard;
+
+        /* Trace packet contents, if enabled */
+        if (tunnel->debug & L2TP_MSG_DATA) {
+                length = min(32u, skb->len);
+                if (!pskb_may_pull(skb, length))
+                        goto discard;
+
+                printk(KERN_DEBUG "%s: ip recv: ", tunnel->name);
+
+                offset = 0;
+                do {
+                        printk(" %02X", ptr[offset]);
+                } while (++offset < length);
+
+                printk("\n");
+        }
+
+        l2tp_recv_common(session, skb, ptr, optr, 0, skb->len, tunnel->recv_payload_hook);
+
+        return 0;
+
+pass_up:
+        /* Get the tunnel_id from the L2TP header */
+        if (!pskb_may_pull(skb, 12))
+                goto discard;
+
+        if ((skb->data[0] & 0xc0) != 0xc0)
+                goto discard;
+
+        tunnel_id = ntohl(*(__be32 *) &skb->data[4]);
+        tunnel = l2tp_tunnel_find(&init_net, tunnel_id);
+        if (tunnel != NULL)
+                sk = tunnel->sock;
+        else {
+                struct iphdr *iph = (struct iphdr *) skb_network_header(skb);
+
+                read_lock_bh(&l2tp_ip_lock);
+                sk = __l2tp_ip_bind_lookup(&init_net, iph->daddr, 0, tunnel_id);
+                read_unlock_bh(&l2tp_ip_lock);
+        }
+
+        if (sk == NULL)
+                goto discard;
+
+        sock_hold(sk);
+
+        if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
+                goto discard_put;
+
+        nf_reset(skb);
+
+        return sk_receive_skb(sk, skb, 1);
+
+discard_put:
+        sock_put(sk);
+
+discard:
+        kfree_skb(skb);
+        return 0;
+}
+
+static int l2tp_ip_open(struct sock *sk)
+{
+        /* Prevent autobind. We don't have ports. */
+        inet_sk(sk)->inet_num = IPPROTO_L2TP;
+
+        write_lock_bh(&l2tp_ip_lock);
+        sk_add_node(sk, &l2tp_ip_table);
+        write_unlock_bh(&l2tp_ip_lock);
+
+        return 0;
+}
+
+static void l2tp_ip_close(struct sock *sk, long timeout)
+{
+        write_lock_bh(&l2tp_ip_lock);
+        hlist_del_init(&sk->sk_bind_node);
+        hlist_del_init(&sk->sk_node);
+        write_unlock_bh(&l2tp_ip_lock);
+        sk_common_release(sk);
+}
+
+static void l2tp_ip_destroy_sock(struct sock *sk)
+{
+        struct sk_buff *skb;
+
+        while ((skb = __skb_dequeue_tail(&sk->sk_write_queue)) != NULL)
+                kfree_skb(skb);
+
+        sk_refcnt_debug_dec(sk);
+}
+
+static int l2tp_ip_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len)
+{
+        struct inet_sock *inet = inet_sk(sk);
+        struct sockaddr_l2tpip *addr = (struct sockaddr_l2tpip *) uaddr;
+        int ret = -EINVAL;
+        int chk_addr_ret;
+
+        ret = -EADDRINUSE;
+        read_lock_bh(&l2tp_ip_lock);
+        if (__l2tp_ip_bind_lookup(&init_net, addr->l2tp_addr.s_addr, sk->sk_bound_dev_if, addr->l2tp_conn_id))
+                goto out_in_use;
+
+        read_unlock_bh(&l2tp_ip_lock);
+
+        lock_sock(sk);
+        if (sk->sk_state != TCP_CLOSE || addr_len < sizeof(struct sockaddr_l2tpip))
+                goto out;
+
+        chk_addr_ret = inet_addr_type(&init_net, addr->l2tp_addr.s_addr);
+        ret = -EADDRNOTAVAIL;
+        if (addr->l2tp_addr.s_addr && chk_addr_ret != RTN_LOCAL &&
+            chk_addr_ret != RTN_MULTICAST && chk_addr_ret != RTN_BROADCAST)
+                goto out;
+
+        inet->inet_rcv_saddr = inet->inet_saddr = addr->l2tp_addr.s_addr;
+        if (chk_addr_ret == RTN_MULTICAST || chk_addr_ret == RTN_BROADCAST)
+                inet->inet_saddr = 0;  /* Use device */
+        sk_dst_reset(sk);
+
+        l2tp_ip_sk(sk)->conn_id = addr->l2tp_conn_id;
+
+        write_lock_bh(&l2tp_ip_lock);
+        sk_add_bind_node(sk, &l2tp_ip_bind_table);
+        sk_del_node_init(sk);
+        write_unlock_bh(&l2tp_ip_lock);
+        ret = 0;
+out:
+        release_sock(sk);
+
+        return ret;
+
+out_in_use:
+        read_unlock_bh(&l2tp_ip_lock);
+
+        return ret;
+}
+
+static int l2tp_ip_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
+{
+        int rc;
+        struct inet_sock *inet = inet_sk(sk);
+        struct sockaddr_l2tpip *lsa = (struct sockaddr_l2tpip *) uaddr;
+        struct rtable *rt;
+        __be32 saddr;
+        int oif;
+
+        rc = -EINVAL;
+        if (addr_len < sizeof(*lsa))
+                goto out;
+
+        rc = -EAFNOSUPPORT;
+        if (lsa->l2tp_family != AF_INET)
+                goto out;
+
+        sk_dst_reset(sk);
+
+        oif = sk->sk_bound_dev_if;
+        saddr = inet->inet_saddr;
+
+        rc = -EINVAL;
+        if (ipv4_is_multicast(lsa->l2tp_addr.s_addr))
+                goto out;
+
+        rc = ip_route_connect(&rt, lsa->l2tp_addr.s_addr, saddr,
+                              RT_CONN_FLAGS(sk), oif,
+                              IPPROTO_L2TP,
+                              0, 0, sk, 1);
+        if (rc) {
+                if (rc == -ENETUNREACH)
+                        IP_INC_STATS_BH(&init_net, IPSTATS_MIB_OUTNOROUTES);
+                goto out;
+        }
+
+        rc = -ENETUNREACH;
+        if (rt->rt_flags & (RTCF_MULTICAST | RTCF_BROADCAST)) {
+                ip_rt_put(rt);
+                goto out;
+        }
+
+        l2tp_ip_sk(sk)->peer_conn_id = lsa->l2tp_conn_id;
+
+        if (!inet->inet_saddr)
+                inet->inet_saddr = rt->rt_src;
+        if (!inet->inet_rcv_saddr)
+                inet->inet_rcv_saddr = rt->rt_src;
+        inet->inet_daddr = rt->rt_dst;
+        sk->sk_state = TCP_ESTABLISHED;
+        inet->inet_id = jiffies;
+
+        sk_dst_set(sk, &rt->u.dst);
+
+        write_lock_bh(&l2tp_ip_lock);
+        hlist_del_init(&sk->sk_bind_node);
+        sk_add_bind_node(sk, &l2tp_ip_bind_table);
+        write_unlock_bh(&l2tp_ip_lock);
+
+        rc = 0;
+out:
+        return rc;
+}
+
+static int l2tp_ip_getname(struct socket *sock, struct sockaddr *uaddr,
+                           int *uaddr_len, int peer)
+{
+        struct sock *sk         = sock->sk;
+        struct inet_sock *inet  = inet_sk(sk);
+        struct l2tp_ip_sock *lsk = l2tp_ip_sk(sk);
+        struct sockaddr_l2tpip *lsa = (struct sockaddr_l2tpip *)uaddr;
+
+        memset(lsa, 0, sizeof(*lsa));
+        lsa->l2tp_family = AF_INET;
+        if (peer) {
+                if (!inet->inet_dport)
+                        return -ENOTCONN;
+                lsa->l2tp_conn_id = lsk->peer_conn_id;
+                lsa->l2tp_addr.s_addr = inet->inet_daddr;
+        } else {
+                __be32 addr = inet->inet_rcv_saddr;
+                if (!addr)
+                        addr = inet->inet_saddr;
+                lsa->l2tp_conn_id = lsk->conn_id;
+                lsa->l2tp_addr.s_addr = addr;
+        }
+        *uaddr_len = sizeof(*lsa);
+        return 0;
+}
+
+static int l2tp_ip_backlog_recv(struct sock *sk, struct sk_buff *skb)
+{
+        int rc;
+
+        if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
+                goto drop;
+
+        nf_reset(skb);
+
+        /* Charge it to the socket, dropping if the queue is full. */
+        rc = sock_queue_rcv_skb(sk, skb);
+        if (rc < 0)
+                goto drop;
+
+        return 0;
+
+drop:
+        IP_INC_STATS(&init_net, IPSTATS_MIB_INDISCARDS);
+        kfree_skb(skb);
+        return -1;
+}
+
+/* Userspace will call sendmsg() on the tunnel socket to send L2TP
+ * control frames.
+ */
+static int l2tp_ip_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg, size_t len)
+{
+        struct sk_buff *skb;
+        int rc;
+        struct l2tp_ip_sock *lsa = l2tp_ip_sk(sk);
+        struct inet_sock *inet = inet_sk(sk);
+        struct ip_options *opt = inet->opt;
+        struct rtable *rt = NULL;
+        int connected = 0;
+        __be32 daddr;
+
+        if (sock_flag(sk, SOCK_DEAD))
+                return -ENOTCONN;
+
+        /* Get and verify the address. */
+        if (msg->msg_name) {
+                struct sockaddr_l2tpip *lip = (struct sockaddr_l2tpip *) msg->msg_name;
+                if (msg->msg_namelen < sizeof(*lip))
+                        return -EINVAL;
+
+                if (lip->l2tp_family != AF_INET) {
+                        if (lip->l2tp_family != AF_UNSPEC)
+                                return -EAFNOSUPPORT;
+                }
+
+                daddr = lip->l2tp_addr.s_addr;
+        } else {
+                if (sk->sk_state != TCP_ESTABLISHED)
+                        return -EDESTADDRREQ;
+
+                daddr = inet->inet_daddr;
+                connected = 1;
+        }
+
+        /* Allocate a socket buffer */
+        rc = -ENOMEM;
+        skb = sock_wmalloc(sk, 2 + NET_SKB_PAD + sizeof(struct iphdr) +
+                           4 + len, 0, GFP_KERNEL);
+        if (!skb)
+                goto error;
+
+        /* Reserve space for headers, putting IP header on 4-byte boundary. */
+        skb_reserve(skb, 2 + NET_SKB_PAD);
+        skb_reset_network_header(skb);
+        skb_reserve(skb, sizeof(struct iphdr));
+        skb_reset_transport_header(skb);
+
+        /* Insert 0 session_id */
+        *((__be32 *) skb_put(skb, 4)) = 0;
+
+        /* Copy user data into skb */
+        rc = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
+        if (rc < 0) {
+                kfree_skb(skb);
+                goto error;
+        }
+
+        if (connected)
+                rt = (struct rtable *) __sk_dst_check(sk, 0);
+
+        if (rt == NULL) {
+                /* Use correct destination address if we have options. */
+                if (opt && opt->srr)
+                        daddr = opt->faddr;
+
+                {
+                        struct flowi fl = { .oif = sk->sk_bound_dev_if,
+                                            .nl_u = { .ip4_u = {
+                                                        .daddr = daddr,
+                                                        .saddr = inet->inet_saddr,
+                                                        .tos = RT_CONN_FLAGS(sk) } },
+                                            .proto = sk->sk_protocol,
+                                            .flags = inet_sk_flowi_flags(sk),
+                                            .uli_u = { .ports = {
+                                                         .sport = inet->inet_sport,
+                                                         .dport = inet->inet_dport } } };
+
+                        /* If this fails, retransmit mechanism of transport layer will
+                         * keep trying until route appears or the connection times
+                         * itself out.
+                         */
+                        security_sk_classify_flow(sk, &fl);
+                        if (ip_route_output_flow(sock_net(sk), &rt, &fl, sk, 0))
+                                goto no_route;
+                }
+                sk_setup_caps(sk, &rt->u.dst);
+        }
+        skb_dst_set(skb, dst_clone(&rt->u.dst));
+
+        /* Queue the packet to IP for output */
+        rc = ip_queue_xmit(skb);
+
+error:
+        /* Update stats */
+        if (rc >= 0) {
+                lsa->tx_packets++;
+                lsa->tx_bytes += len;
+                rc = len;
+        } else {
+                lsa->tx_errors++;
+        }
+
+        return rc;
+
+no_route:
+        IP_INC_STATS(sock_net(sk), IPSTATS_MIB_OUTNOROUTES);
+        kfree_skb(skb);
+        return -EHOSTUNREACH;
+}
+
+static int l2tp_ip_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
+                           size_t len, int noblock, int flags, int *addr_len)
+{
+        struct inet_sock *inet = inet_sk(sk);
+        struct l2tp_ip_sock *lsk = l2tp_ip_sk(sk);
+        size_t copied = 0;
+        int err = -EOPNOTSUPP;
+        struct sockaddr_in *sin = (struct sockaddr_in *)msg->msg_name;
+        struct sk_buff *skb;
+
+        if (flags & MSG_OOB)
+                goto out;
+
+        if (addr_len)
+                *addr_len = sizeof(*sin);
+
+        skb = skb_recv_datagram(sk, flags, noblock, &err);
+        if (!skb)
+                goto out;
+
+        copied = skb->len;
+        if (len < copied) {
+                msg->msg_flags |= MSG_TRUNC;
+                copied = len;
+        }
+
+        err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
+        if (err)
+                goto done;
+
+        sock_recv_timestamp(msg, sk, skb);
+
+        /* Copy the address. */
+        if (sin) {
+                sin->sin_family = AF_INET;
+                sin->sin_addr.s_addr = ip_hdr(skb)->saddr;
+                sin->sin_port = 0;
+                memset(&sin->sin_zero, 0, sizeof(sin->sin_zero));
+        }
+        if (inet->cmsg_flags)
+                ip_cmsg_recv(msg, skb);
+        if (flags & MSG_TRUNC)
+                copied = skb->len;
+done:
+        skb_free_datagram(sk, skb);
+out:
+        if (err) {
+                lsk->rx_errors++;
+                return err;
+        }
+
+        lsk->rx_packets++;
+        lsk->rx_bytes += copied;
+
+        return copied;
+}
+
+struct proto l2tp_ip_prot = {
+        .name              = "L2TP/IP",
+        .owner             = THIS_MODULE,
+        .init              = l2tp_ip_open,
+        .close             = l2tp_ip_close,
+        .bind              = l2tp_ip_bind,
+        .connect           = l2tp_ip_connect,
+        .disconnect        = udp_disconnect,
+        .ioctl             = udp_ioctl,
+        .destroy           = l2tp_ip_destroy_sock,
+        .setsockopt        = ip_setsockopt,
+        .getsockopt        = ip_getsockopt,
+        .sendmsg           = l2tp_ip_sendmsg,
+        .recvmsg           = l2tp_ip_recvmsg,
+        .backlog_rcv       = l2tp_ip_backlog_recv,
+        .hash              = inet_hash,
+        .unhash            = inet_unhash,
+        .obj_size          = sizeof(struct l2tp_ip_sock),
+#ifdef CONFIG_COMPAT
+        .compat_setsockopt = compat_ip_setsockopt,
+        .compat_getsockopt = compat_ip_getsockopt,
+#endif
+};
+
+static const struct proto_ops l2tp_ip_ops = {
+        .family            = PF_INET,
+        .owner             = THIS_MODULE,
+        .release           = inet_release,
+        .bind              = inet_bind,
+        .connect           = inet_dgram_connect,
+        .socketpair        = sock_no_socketpair,
+        .accept            = sock_no_accept,
+        .getname           = l2tp_ip_getname,
+        .poll              = datagram_poll,
+        .ioctl             = inet_ioctl,
+        .listen            = sock_no_listen,
+        .shutdown          = inet_shutdown,
+        .setsockopt        = sock_common_setsockopt,
+        .getsockopt        = sock_common_getsockopt,
+        .sendmsg           = inet_sendmsg,
+        .recvmsg           = sock_common_recvmsg,
+        .mmap              = sock_no_mmap,
+        .sendpage          = sock_no_sendpage,
+#ifdef CONFIG_COMPAT
+        .compat_setsockopt = compat_sock_common_setsockopt,
+        .compat_getsockopt = compat_sock_common_getsockopt,
+#endif
+};
+
+static struct inet_protosw l2tp_ip_protosw = {
+        .type           = SOCK_DGRAM,
+        .protocol       = IPPROTO_L2TP,
+        .prot           = &l2tp_ip_prot,
+        .ops            = &l2tp_ip_ops,
+        .no_check       = 0,
+};
+
+static struct net_protocol l2tp_ip_protocol __read_mostly = {
+        .handler        = l2tp_ip_recv,
+};
+
+static int __init l2tp_ip_init(void)
+{
+        int err;
+
+        printk(KERN_INFO "L2TP IP encapsulation support (L2TPv3)\n");
+
+        err = proto_register(&l2tp_ip_prot, 1);
+        if (err != 0)
+                goto out;
+
+        err = inet_add_protocol(&l2tp_ip_protocol, IPPROTO_L2TP);
+        if (err)
+                goto out1;
+
+        inet_register_protosw(&l2tp_ip_protosw);
+        return 0;
+
+out1:
+        proto_unregister(&l2tp_ip_prot);
+out:
+        return err;
+}
+
+static void __exit l2tp_ip_exit(void)
+{
+        inet_unregister_protosw(&l2tp_ip_protosw);
+        inet_del_protocol(&l2tp_ip_protocol, IPPROTO_L2TP);
+        proto_unregister(&l2tp_ip_prot);
+}
+
+module_init(l2tp_ip_init);
+module_exit(l2tp_ip_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("James Chapman <jchapman@katalix.com>");
+MODULE_DESCRIPTION("L2TP over IP");
+MODULE_VERSION("1.0");
+MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_INET, SOCK_DGRAM, IPPROTO_L2TP);
diff --git a/net/l2tp/l2tp_netlink.c b/net/l2tp/l2tp_netlink.c
new file mode 100644
index 000000000000..4c1e540732d7
--- /dev/null
+++ b/net/l2tp/l2tp_netlink.c
@@ -0,0 +1,840 @@
+/*
+ * L2TP netlink layer, for management
+ *
+ * Copyright (c) 2008,2009,2010 Katalix Systems Ltd
+ *
+ * Partly based on the IrDA nelink implementation
+ * (see net/irda/irnetlink.c) which is:
+ * Copyright (c) 2007 Samuel Ortiz <samuel@sortiz.org>
+ * which is in turn partly based on the wireless netlink code:
+ * Copyright 2006 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
+ * published by the Free Software Foundation.
+ */
+
+#include <net/sock.h>
+#include <net/genetlink.h>
+#include <net/udp.h>
+#include <linux/in.h>
+#include <linux/udp.h>
+#include <linux/socket.h>
+#include <linux/module.h>
+#include <linux/list.h>
+#include <net/net_namespace.h>
+
+#include <linux/l2tp.h>
+
+#include "l2tp_core.h"
+
+
+static struct genl_family l2tp_nl_family = {
+        .id             = GENL_ID_GENERATE,
+        .name           = L2TP_GENL_NAME,
+        .version        = L2TP_GENL_VERSION,
+        .hdrsize        = 0,
+        .maxattr        = L2TP_ATTR_MAX,
+};
+
+/* Accessed under genl lock */
+static const struct l2tp_nl_cmd_ops *l2tp_nl_cmd_ops[__L2TP_PWTYPE_MAX];
+
+static struct l2tp_session *l2tp_nl_session_find(struct genl_info *info)
+{
+        u32 tunnel_id;
+        u32 session_id;
+        char *ifname;
+        struct l2tp_tunnel *tunnel;
+        struct l2tp_session *session = NULL;
+        struct net *net = genl_info_net(info);
+
+        if (info->attrs[L2TP_ATTR_IFNAME]) {
+                ifname = nla_data(info->attrs[L2TP_ATTR_IFNAME]);
+                session = l2tp_session_find_by_ifname(net, ifname);
+        } else if ((info->attrs[L2TP_ATTR_SESSION_ID]) &&
+                   (info->attrs[L2TP_ATTR_CONN_ID])) {
+                tunnel_id = nla_get_u32(info->attrs[L2TP_ATTR_CONN_ID]);
+                session_id = nla_get_u32(info->attrs[L2TP_ATTR_SESSION_ID]);
+                tunnel = l2tp_tunnel_find(net, tunnel_id);
+                if (tunnel)
+                        session = l2tp_session_find(net, tunnel, session_id);
+        }
+
+        return session;
+}
+
+static int l2tp_nl_cmd_noop(struct sk_buff *skb, struct genl_info *info)
+{
+        struct sk_buff *msg;
+        void *hdr;
+        int ret = -ENOBUFS;
+
+        msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
+        if (!msg) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        hdr = genlmsg_put(msg, info->snd_pid, info->snd_seq,
+                          &l2tp_nl_family, 0, L2TP_CMD_NOOP);
+        if (IS_ERR(hdr)) {
+                ret = PTR_ERR(hdr);
+                goto err_out;
+        }
+
+        genlmsg_end(msg, hdr);
+
+        return genlmsg_unicast(genl_info_net(info), msg, info->snd_pid);
+
+err_out:
+        nlmsg_free(msg);
+
+out:
+        return ret;
+}
+
+static int l2tp_nl_cmd_tunnel_create(struct sk_buff *skb, struct genl_info *info)
+{
+        u32 tunnel_id;
+        u32 peer_tunnel_id;
+        int proto_version;
+        int fd;
+        int ret = 0;
+        struct l2tp_tunnel_cfg cfg = { 0, };
+        struct l2tp_tunnel *tunnel;
+        struct net *net = genl_info_net(info);
+
+        if (!info->attrs[L2TP_ATTR_CONN_ID]) {
+                ret = -EINVAL;
+                goto out;
+        }
+        tunnel_id = nla_get_u32(info->attrs[L2TP_ATTR_CONN_ID]);
+
+        if (!info->attrs[L2TP_ATTR_PEER_CONN_ID]) {
+                ret = -EINVAL;
+                goto out;
+        }
+        peer_tunnel_id = nla_get_u32(info->attrs[L2TP_ATTR_PEER_CONN_ID]);
+
+        if (!info->attrs[L2TP_ATTR_PROTO_VERSION]) {
+                ret = -EINVAL;
+                goto out;
+        }
+        proto_version = nla_get_u8(info->attrs[L2TP_ATTR_PROTO_VERSION]);
+
+        if (!info->attrs[L2TP_ATTR_ENCAP_TYPE]) {
+                ret = -EINVAL;
+                goto out;
+        }
+        cfg.encap = nla_get_u16(info->attrs[L2TP_ATTR_ENCAP_TYPE]);
+
+        fd = -1;
+        if (info->attrs[L2TP_ATTR_FD]) {
+                fd = nla_get_u32(info->attrs[L2TP_ATTR_FD]);
+        } else {
+                if (info->attrs[L2TP_ATTR_IP_SADDR])
+                        cfg.local_ip.s_addr = nla_get_be32(info->attrs[L2TP_ATTR_IP_SADDR]);
+                if (info->attrs[L2TP_ATTR_IP_DADDR])
+                        cfg.peer_ip.s_addr = nla_get_be32(info->attrs[L2TP_ATTR_IP_DADDR]);
+                if (info->attrs[L2TP_ATTR_UDP_SPORT])
+                        cfg.local_udp_port = nla_get_u16(info->attrs[L2TP_ATTR_UDP_SPORT]);
+                if (info->attrs[L2TP_ATTR_UDP_DPORT])
+                        cfg.peer_udp_port = nla_get_u16(info->attrs[L2TP_ATTR_UDP_DPORT]);
+                if (info->attrs[L2TP_ATTR_UDP_CSUM])
+                        cfg.use_udp_checksums = nla_get_flag(info->attrs[L2TP_ATTR_UDP_CSUM]);
+        }
+
+        if (info->attrs[L2TP_ATTR_DEBUG])
+                cfg.debug = nla_get_u32(info->attrs[L2TP_ATTR_DEBUG]);
+
+        tunnel = l2tp_tunnel_find(net, tunnel_id);
+        if (tunnel != NULL) {
+                ret = -EEXIST;
+                goto out;
+        }
+
+        ret = -EINVAL;
+        switch (cfg.encap) {
+        case L2TP_ENCAPTYPE_UDP:
+        case L2TP_ENCAPTYPE_IP:
+                ret = l2tp_tunnel_create(net, fd, proto_version, tunnel_id,
+                                         peer_tunnel_id, &cfg, &tunnel);
+                break;
+        }
+
+out:
+        return ret;
+}
+
+static int l2tp_nl_cmd_tunnel_delete(struct sk_buff *skb, struct genl_info *info)
+{
+        struct l2tp_tunnel *tunnel;
+        u32 tunnel_id;
+        int ret = 0;
+        struct net *net = genl_info_net(info);
+
+        if (!info->attrs[L2TP_ATTR_CONN_ID]) {
+                ret = -EINVAL;
+                goto out;
+        }
+        tunnel_id = nla_get_u32(info->attrs[L2TP_ATTR_CONN_ID]);
+
+        tunnel = l2tp_tunnel_find(net, tunnel_id);
+        if (tunnel == NULL) {
+                ret = -ENODEV;
+                goto out;
+        }
+
+        (void) l2tp_tunnel_delete(tunnel);
+
+out:
+        return ret;
+}
+
+static int l2tp_nl_cmd_tunnel_modify(struct sk_buff *skb, struct genl_info *info)
+{
+        struct l2tp_tunnel *tunnel;
+        u32 tunnel_id;
+        int ret = 0;
+        struct net *net = genl_info_net(info);
+
+        if (!info->attrs[L2TP_ATTR_CONN_ID]) {
+                ret = -EINVAL;
+                goto out;
+        }
+        tunnel_id = nla_get_u32(info->attrs[L2TP_ATTR_CONN_ID]);
+
+        tunnel = l2tp_tunnel_find(net, tunnel_id);
+        if (tunnel == NULL) {
+                ret = -ENODEV;
+                goto out;
+        }
+
+        if (info->attrs[L2TP_ATTR_DEBUG])
+                tunnel->debug = nla_get_u32(info->attrs[L2TP_ATTR_DEBUG]);
+
+out:
+        return ret;
+}
+
+static int l2tp_nl_tunnel_send(struct sk_buff *skb, u32 pid, u32 seq, int flags,
+                               struct l2tp_tunnel *tunnel)
+{
+        void *hdr;
+        struct nlattr *nest;
+        struct sock *sk = NULL;
+        struct inet_sock *inet;
+
+        hdr = genlmsg_put(skb, pid, seq, &l2tp_nl_family, flags,
+                          L2TP_CMD_TUNNEL_GET);
+        if (IS_ERR(hdr))
+                return PTR_ERR(hdr);
+
+        NLA_PUT_U8(skb, L2TP_ATTR_PROTO_VERSION, tunnel->version);
+        NLA_PUT_U32(skb, L2TP_ATTR_CONN_ID, tunnel->tunnel_id);
+        NLA_PUT_U32(skb, L2TP_ATTR_PEER_CONN_ID, tunnel->peer_tunnel_id);
+        NLA_PUT_U32(skb, L2TP_ATTR_DEBUG, tunnel->debug);
+        NLA_PUT_U16(skb, L2TP_ATTR_ENCAP_TYPE, tunnel->encap);
+
+        nest = nla_nest_start(skb, L2TP_ATTR_STATS);
+        if (nest == NULL)
+                goto nla_put_failure;
+
+        NLA_PUT_U64(skb, L2TP_ATTR_TX_PACKETS, tunnel->stats.tx_packets);
+        NLA_PUT_U64(skb, L2TP_ATTR_TX_BYTES, tunnel->stats.tx_bytes);
+        NLA_PUT_U64(skb, L2TP_ATTR_TX_ERRORS, tunnel->stats.tx_errors);
+        NLA_PUT_U64(skb, L2TP_ATTR_RX_PACKETS, tunnel->stats.rx_packets);
+        NLA_PUT_U64(skb, L2TP_ATTR_RX_BYTES, tunnel->stats.rx_bytes);
+        NLA_PUT_U64(skb, L2TP_ATTR_RX_SEQ_DISCARDS, tunnel->stats.rx_seq_discards);
+        NLA_PUT_U64(skb, L2TP_ATTR_RX_OOS_PACKETS, tunnel->stats.rx_oos_packets);
+        NLA_PUT_U64(skb, L2TP_ATTR_RX_ERRORS, tunnel->stats.rx_errors);
+        nla_nest_end(skb, nest);
+
+        sk = tunnel->sock;
+        if (!sk)
+                goto out;
+
+        inet = inet_sk(sk);
+
+        switch (tunnel->encap) {
+        case L2TP_ENCAPTYPE_UDP:
+                NLA_PUT_U16(skb, L2TP_ATTR_UDP_SPORT, ntohs(inet->inet_sport));
+                NLA_PUT_U16(skb, L2TP_ATTR_UDP_DPORT, ntohs(inet->inet_dport));
+                NLA_PUT_U8(skb, L2TP_ATTR_UDP_CSUM, (sk->sk_no_check != UDP_CSUM_NOXMIT));
+                /* NOBREAK */
+        case L2TP_ENCAPTYPE_IP:
+                NLA_PUT_BE32(skb, L2TP_ATTR_IP_SADDR, inet->inet_saddr);
+                NLA_PUT_BE32(skb, L2TP_ATTR_IP_DADDR, inet->inet_daddr);
+                break;
+        }
+
+out:
+        return genlmsg_end(skb, hdr);
+
+nla_put_failure:
+        genlmsg_cancel(skb, hdr);
+        return -1;
+}
+
+static int l2tp_nl_cmd_tunnel_get(struct sk_buff *skb, struct genl_info *info)
+{
+        struct l2tp_tunnel *tunnel;
+        struct sk_buff *msg;
+        u32 tunnel_id;
+        int ret = -ENOBUFS;
+        struct net *net = genl_info_net(info);
+
+        if (!info->attrs[L2TP_ATTR_CONN_ID]) {
+                ret = -EINVAL;
+                goto out;
+        }
+
+        tunnel_id = nla_get_u32(info->attrs[L2TP_ATTR_CONN_ID]);
+
+        tunnel = l2tp_tunnel_find(net, tunnel_id);
+        if (tunnel == NULL) {
+                ret = -ENODEV;
+                goto out;
+        }
+
+        msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
+        if (!msg) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        ret = l2tp_nl_tunnel_send(msg, info->snd_pid, info->snd_seq,
+                                  NLM_F_ACK, tunnel);
+        if (ret < 0)
+                goto err_out;
+
+        return genlmsg_unicast(net, msg, info->snd_pid);
+
+err_out:
+        nlmsg_free(msg);
+
+out:
+        return ret;
+}
+
+static int l2tp_nl_cmd_tunnel_dump(struct sk_buff *skb, struct netlink_callback *cb)
+{
+        int ti = cb->args[0];
+        struct l2tp_tunnel *tunnel;
+        struct net *net = sock_net(skb->sk);
+
+        for (;;) {
+                tunnel = l2tp_tunnel_find_nth(net, ti);
+                if (tunnel == NULL)
+                        goto out;
+
+                if (l2tp_nl_tunnel_send(skb, NETLINK_CB(cb->skb).pid,
+                                        cb->nlh->nlmsg_seq, NLM_F_MULTI,
+                                        tunnel) <= 0)
+                        goto out;
+
+                ti++;
+        }
+
+out:
+        cb->args[0] = ti;
+
+        return skb->len;
+}
+
+static int l2tp_nl_cmd_session_create(struct sk_buff *skb, struct genl_info *info)
+{
+        u32 tunnel_id = 0;
+        u32 session_id;
+        u32 peer_session_id;
+        int ret = 0;
+        struct l2tp_tunnel *tunnel;
+        struct l2tp_session *session;
+        struct l2tp_session_cfg cfg = { 0, };
+        struct net *net = genl_info_net(info);
+
+        if (!info->attrs[L2TP_ATTR_CONN_ID]) {
+                ret = -EINVAL;
+                goto out;
+        }
+        tunnel_id = nla_get_u32(info->attrs[L2TP_ATTR_CONN_ID]);
+        tunnel = l2tp_tunnel_find(net, tunnel_id);
+        if (!tunnel) {
+                ret = -ENODEV;
+                goto out;
+        }
+
+        if (!info->attrs[L2TP_ATTR_SESSION_ID]) {
+                ret = -EINVAL;
+                goto out;
+        }
+        session_id = nla_get_u32(info->attrs[L2TP_ATTR_SESSION_ID]);
+        session = l2tp_session_find(net, tunnel, session_id);
+        if (session) {
+                ret = -EEXIST;
+                goto out;
+        }
+
+        if (!info->attrs[L2TP_ATTR_PEER_SESSION_ID]) {
+                ret = -EINVAL;
+                goto out;
+        }
+        peer_session_id = nla_get_u32(info->attrs[L2TP_ATTR_PEER_SESSION_ID]);
+
+        if (!info->attrs[L2TP_ATTR_PW_TYPE]) {
+                ret = -EINVAL;
+                goto out;
+        }
+        cfg.pw_type = nla_get_u16(info->attrs[L2TP_ATTR_PW_TYPE]);
+        if (cfg.pw_type >= __L2TP_PWTYPE_MAX) {
+                ret = -EINVAL;
+                goto out;
+        }
+
+        if (tunnel->version > 2) {
+                if (info->attrs[L2TP_ATTR_OFFSET])
+                        cfg.offset = nla_get_u16(info->attrs[L2TP_ATTR_OFFSET]);
+
+                if (info->attrs[L2TP_ATTR_DATA_SEQ])
+                        cfg.data_seq = nla_get_u8(info->attrs[L2TP_ATTR_DATA_SEQ]);
+
+                cfg.l2specific_type = L2TP_L2SPECTYPE_DEFAULT;
+                if (info->attrs[L2TP_ATTR_L2SPEC_TYPE])
+                        cfg.l2specific_type = nla_get_u8(info->attrs[L2TP_ATTR_L2SPEC_TYPE]);
+
+                cfg.l2specific_len = 4;
+                if (info->attrs[L2TP_ATTR_L2SPEC_LEN])
+                        cfg.l2specific_len = nla_get_u8(info->attrs[L2TP_ATTR_L2SPEC_LEN]);
+
+                if (info->attrs[L2TP_ATTR_COOKIE]) {
+                        u16 len = nla_len(info->attrs[L2TP_ATTR_COOKIE]);
+                        if (len > 8) {
+                                ret = -EINVAL;
+                                goto out;
+                        }
+                        cfg.cookie_len = len;
+                        memcpy(&cfg.cookie[0], nla_data(info->attrs[L2TP_ATTR_COOKIE]), len);
+                }
+                if (info->attrs[L2TP_ATTR_PEER_COOKIE]) {
+                        u16 len = nla_len(info->attrs[L2TP_ATTR_PEER_COOKIE]);
+                        if (len > 8) {
+                                ret = -EINVAL;
+                                goto out;
+                        }
+                        cfg.peer_cookie_len = len;
+                        memcpy(&cfg.peer_cookie[0], nla_data(info->attrs[L2TP_ATTR_PEER_COOKIE]), len);
+                }
+                if (info->attrs[L2TP_ATTR_IFNAME])
+                        cfg.ifname = nla_data(info->attrs[L2TP_ATTR_IFNAME]);
+
+                if (info->attrs[L2TP_ATTR_VLAN_ID])
+                        cfg.vlan_id = nla_get_u16(info->attrs[L2TP_ATTR_VLAN_ID]);
+        }
+
+        if (info->attrs[L2TP_ATTR_DEBUG])
+                cfg.debug = nla_get_u32(info->attrs[L2TP_ATTR_DEBUG]);
+
+        if (info->attrs[L2TP_ATTR_RECV_SEQ])
+                cfg.recv_seq = nla_get_u8(info->attrs[L2TP_ATTR_RECV_SEQ]);
+
+        if (info->attrs[L2TP_ATTR_SEND_SEQ])
+                cfg.send_seq = nla_get_u8(info->attrs[L2TP_ATTR_SEND_SEQ]);
+
+        if (info->attrs[L2TP_ATTR_LNS_MODE])
+                cfg.lns_mode = nla_get_u8(info->attrs[L2TP_ATTR_LNS_MODE]);
+
+        if (info->attrs[L2TP_ATTR_RECV_TIMEOUT])
+                cfg.reorder_timeout = nla_get_msecs(info->attrs[L2TP_ATTR_RECV_TIMEOUT]);
+
+        if (info->attrs[L2TP_ATTR_MTU])
+                cfg.mtu = nla_get_u16(info->attrs[L2TP_ATTR_MTU]);
+
+        if (info->attrs[L2TP_ATTR_MRU])
+                cfg.mru = nla_get_u16(info->attrs[L2TP_ATTR_MRU]);
+
+        if ((l2tp_nl_cmd_ops[cfg.pw_type] == NULL) ||
+            (l2tp_nl_cmd_ops[cfg.pw_type]->session_create == NULL)) {
+                ret = -EPROTONOSUPPORT;
+                goto out;
+        }
+
+        /* Check that pseudowire-specific params are present */
+        switch (cfg.pw_type) {
+        case L2TP_PWTYPE_NONE:
+                break;
+        case L2TP_PWTYPE_ETH_VLAN:
+                if (!info->attrs[L2TP_ATTR_VLAN_ID]) {
+                        ret = -EINVAL;
+                        goto out;
+                }
+                break;
+        case L2TP_PWTYPE_ETH:
+                break;
+        case L2TP_PWTYPE_PPP:
+        case L2TP_PWTYPE_PPP_AC:
+                break;
+        case L2TP_PWTYPE_IP:
+        default:
+                ret = -EPROTONOSUPPORT;
+                break;
+        }
+
+        ret = -EPROTONOSUPPORT;
+        if (l2tp_nl_cmd_ops[cfg.pw_type]->session_create)
+                ret = (*l2tp_nl_cmd_ops[cfg.pw_type]->session_create)(net, tunnel_id,
+                        session_id, peer_session_id, &cfg);
+
+out:
+        return ret;
+}
+
+static int l2tp_nl_cmd_session_delete(struct sk_buff *skb, struct genl_info *info)
+{
+        int ret = 0;
+        struct l2tp_session *session;
+        u16 pw_type;
+
+        session = l2tp_nl_session_find(info);
+        if (session == NULL) {
+                ret = -ENODEV;
+                goto out;
+        }
+
+        pw_type = session->pwtype;
+        if (pw_type < __L2TP_PWTYPE_MAX)
+                if (l2tp_nl_cmd_ops[pw_type] && l2tp_nl_cmd_ops[pw_type]->session_delete)
+                        ret = (*l2tp_nl_cmd_ops[pw_type]->session_delete)(session);
+
+out:
+        return ret;
+}
+
+static int l2tp_nl_cmd_session_modify(struct sk_buff *skb, struct genl_info *info)
+{
+        int ret = 0;
+        struct l2tp_session *session;
+
+        session = l2tp_nl_session_find(info);
+        if (session == NULL) {
+                ret = -ENODEV;
+                goto out;
+        }
+
+        if (info->attrs[L2TP_ATTR_DEBUG])
+                session->debug = nla_get_u32(info->attrs[L2TP_ATTR_DEBUG]);
+
+        if (info->attrs[L2TP_ATTR_DATA_SEQ])
+                session->data_seq = nla_get_u8(info->attrs[L2TP_ATTR_DATA_SEQ]);
+
+        if (info->attrs[L2TP_ATTR_RECV_SEQ])
+                session->recv_seq = nla_get_u8(info->attrs[L2TP_ATTR_RECV_SEQ]);
+
+        if (info->attrs[L2TP_ATTR_SEND_SEQ])
+                session->send_seq = nla_get_u8(info->attrs[L2TP_ATTR_SEND_SEQ]);
+
+        if (info->attrs[L2TP_ATTR_LNS_MODE])
+                session->lns_mode = nla_get_u8(info->attrs[L2TP_ATTR_LNS_MODE]);
+
+        if (info->attrs[L2TP_ATTR_RECV_TIMEOUT])
+                session->reorder_timeout = nla_get_msecs(info->attrs[L2TP_ATTR_RECV_TIMEOUT]);
+
+        if (info->attrs[L2TP_ATTR_MTU])
+                session->mtu = nla_get_u16(info->attrs[L2TP_ATTR_MTU]);
+
+        if (info->attrs[L2TP_ATTR_MRU])
+                session->mru = nla_get_u16(info->attrs[L2TP_ATTR_MRU]);
+
+out:
+        return ret;
+}
+
+static int l2tp_nl_session_send(struct sk_buff *skb, u32 pid, u32 seq, int flags,
+                                struct l2tp_session *session)
+{
+        void *hdr;
+        struct nlattr *nest;
+        struct l2tp_tunnel *tunnel = session->tunnel;
+        struct sock *sk = NULL;
+
+        sk = tunnel->sock;
+
+        hdr = genlmsg_put(skb, pid, seq, &l2tp_nl_family, flags, L2TP_CMD_SESSION_GET);
+        if (IS_ERR(hdr))
+                return PTR_ERR(hdr);
+
+        NLA_PUT_U32(skb, L2TP_ATTR_CONN_ID, tunnel->tunnel_id);
+        NLA_PUT_U32(skb, L2TP_ATTR_SESSION_ID, session->session_id);
+        NLA_PUT_U32(skb, L2TP_ATTR_PEER_CONN_ID, tunnel->peer_tunnel_id);
+        NLA_PUT_U32(skb, L2TP_ATTR_PEER_SESSION_ID, session->peer_session_id);
+        NLA_PUT_U32(skb, L2TP_ATTR_DEBUG, session->debug);
+        NLA_PUT_U16(skb, L2TP_ATTR_PW_TYPE, session->pwtype);
+        NLA_PUT_U16(skb, L2TP_ATTR_MTU, session->mtu);
+        if (session->mru)
+                NLA_PUT_U16(skb, L2TP_ATTR_MRU, session->mru);
+
+        if (session->ifname && session->ifname[0])
+                NLA_PUT_STRING(skb, L2TP_ATTR_IFNAME, session->ifname);
+        if (session->cookie_len)
+                NLA_PUT(skb, L2TP_ATTR_COOKIE, session->cookie_len, &session->cookie[0]);
+        if (session->peer_cookie_len)
+                NLA_PUT(skb, L2TP_ATTR_PEER_COOKIE, session->peer_cookie_len, &session->peer_cookie[0]);
+        NLA_PUT_U8(skb, L2TP_ATTR_RECV_SEQ, session->recv_seq);
+        NLA_PUT_U8(skb, L2TP_ATTR_SEND_SEQ, session->send_seq);
+        NLA_PUT_U8(skb, L2TP_ATTR_LNS_MODE, session->lns_mode);
+#ifdef CONFIG_XFRM
+        if ((sk) && (sk->sk_policy[0] || sk->sk_policy[1]))
+                NLA_PUT_U8(skb, L2TP_ATTR_USING_IPSEC, 1);
+#endif
+        if (session->reorder_timeout)
+                NLA_PUT_MSECS(skb, L2TP_ATTR_RECV_TIMEOUT, session->reorder_timeout);
+
+        nest = nla_nest_start(skb, L2TP_ATTR_STATS);
+        if (nest == NULL)
+                goto nla_put_failure;
+        NLA_PUT_U64(skb, L2TP_ATTR_TX_PACKETS, session->stats.tx_packets);
+        NLA_PUT_U64(skb, L2TP_ATTR_TX_BYTES, session->stats.tx_bytes);
+        NLA_PUT_U64(skb, L2TP_ATTR_TX_ERRORS, session->stats.tx_errors);
+        NLA_PUT_U64(skb, L2TP_ATTR_RX_PACKETS, session->stats.rx_packets);
+        NLA_PUT_U64(skb, L2TP_ATTR_RX_BYTES, session->stats.rx_bytes);
+        NLA_PUT_U64(skb, L2TP_ATTR_RX_SEQ_DISCARDS, session->stats.rx_seq_discards);
+        NLA_PUT_U64(skb, L2TP_ATTR_RX_OOS_PACKETS, session->stats.rx_oos_packets);
+        NLA_PUT_U64(skb, L2TP_ATTR_RX_ERRORS, session->stats.rx_errors);
+        nla_nest_end(skb, nest);
+
+        return genlmsg_end(skb, hdr);
+
+ nla_put_failure:
+        genlmsg_cancel(skb, hdr);
+        return -1;
+}
+
+static int l2tp_nl_cmd_session_get(struct sk_buff *skb, struct genl_info *info)
+{
+        struct l2tp_session *session;
+        struct sk_buff *msg;
+        int ret;
+
+        session = l2tp_nl_session_find(info);
+        if (session == NULL) {
+                ret = -ENODEV;
+                goto out;
+        }
+
+        msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
+        if (!msg) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        ret = l2tp_nl_session_send(msg, info->snd_pid, info->snd_seq,
+                                   0, session);
+        if (ret < 0)
+                goto err_out;
+
+        return genlmsg_unicast(genl_info_net(info), msg, info->snd_pid);
+
+err_out:
+        nlmsg_free(msg);
+
+out:
+        return ret;
+}
+
+static int l2tp_nl_cmd_session_dump(struct sk_buff *skb, struct netlink_callback *cb)
+{
+        struct net *net = sock_net(skb->sk);
+        struct l2tp_session *session;
+        struct l2tp_tunnel *tunnel = NULL;
+        int ti = cb->args[0];
+        int si = cb->args[1];
+
+        for (;;) {
+                if (tunnel == NULL) {
+                        tunnel = l2tp_tunnel_find_nth(net, ti);
+                        if (tunnel == NULL)
+                                goto out;
+                }
+
+                session = l2tp_session_find_nth(tunnel, si);
+                if (session == NULL) {
+                        ti++;
+                        tunnel = NULL;
+                        si = 0;
+                        continue;
+                }
+
+                if (l2tp_nl_session_send(skb, NETLINK_CB(cb->skb).pid,
+                                         cb->nlh->nlmsg_seq, NLM_F_MULTI,
+                                         session) <= 0)
+                        break;
+
+                si++;
+        }
+
+out:
+        cb->args[0] = ti;
+        cb->args[1] = si;
+
+        return skb->len;
+}
+
+static struct nla_policy l2tp_nl_policy[L2TP_ATTR_MAX + 1] = {
+        [L2TP_ATTR_NONE]                = { .type = NLA_UNSPEC, },
+        [L2TP_ATTR_PW_TYPE]             = { .type = NLA_U16, },
+        [L2TP_ATTR_ENCAP_TYPE]          = { .type = NLA_U16, },
+        [L2TP_ATTR_OFFSET]              = { .type = NLA_U16, },
+        [L2TP_ATTR_DATA_SEQ]            = { .type = NLA_U8, },
+        [L2TP_ATTR_L2SPEC_TYPE]         = { .type = NLA_U8, },
+        [L2TP_ATTR_L2SPEC_LEN]          = { .type = NLA_U8, },
+        [L2TP_ATTR_PROTO_VERSION]       = { .type = NLA_U8, },
+        [L2TP_ATTR_CONN_ID]             = { .type = NLA_U32, },
+        [L2TP_ATTR_PEER_CONN_ID]        = { .type = NLA_U32, },
+        [L2TP_ATTR_SESSION_ID]          = { .type = NLA_U32, },
+        [L2TP_ATTR_PEER_SESSION_ID]     = { .type = NLA_U32, },
+        [L2TP_ATTR_UDP_CSUM]            = { .type = NLA_U8, },
+        [L2TP_ATTR_VLAN_ID]             = { .type = NLA_U16, },
+        [L2TP_ATTR_DEBUG]               = { .type = NLA_U32, },
+        [L2TP_ATTR_RECV_SEQ]            = { .type = NLA_U8, },
+        [L2TP_ATTR_SEND_SEQ]            = { .type = NLA_U8, },
+        [L2TP_ATTR_LNS_MODE]            = { .type = NLA_U8, },
+        [L2TP_ATTR_USING_IPSEC]         = { .type = NLA_U8, },
+        [L2TP_ATTR_RECV_TIMEOUT]        = { .type = NLA_MSECS, },
+        [L2TP_ATTR_FD]                  = { .type = NLA_U32, },
+        [L2TP_ATTR_IP_SADDR]            = { .type = NLA_U32, },
+        [L2TP_ATTR_IP_DADDR]            = { .type = NLA_U32, },
+        [L2TP_ATTR_UDP_SPORT]           = { .type = NLA_U16, },
+        [L2TP_ATTR_UDP_DPORT]           = { .type = NLA_U16, },
+        [L2TP_ATTR_MTU]                 = { .type = NLA_U16, },
+        [L2TP_ATTR_MRU]                 = { .type = NLA_U16, },
+        [L2TP_ATTR_STATS]               = { .type = NLA_NESTED, },
+        [L2TP_ATTR_IFNAME] = {
+                .type = NLA_NUL_STRING,
+                .len = IFNAMSIZ - 1,
+        },
+        [L2TP_ATTR_COOKIE] = {
+                .type = NLA_BINARY,
+                .len = 8,
+        },
+        [L2TP_ATTR_PEER_COOKIE] = {
+                .type = NLA_BINARY,
+                .len = 8,
+        },
+};
+
+static struct genl_ops l2tp_nl_ops[] = {
+        {
+                .cmd = L2TP_CMD_NOOP,
+                .doit = l2tp_nl_cmd_noop,
+                .policy = l2tp_nl_policy,
+                /* can be retrieved by unprivileged users */
+        },
+        {
+                .cmd = L2TP_CMD_TUNNEL_CREATE,
+                .doit = l2tp_nl_cmd_tunnel_create,
+                .policy = l2tp_nl_policy,
+                .flags = GENL_ADMIN_PERM,
+        },
+        {
+                .cmd = L2TP_CMD_TUNNEL_DELETE,
+                .doit = l2tp_nl_cmd_tunnel_delete,
+                .policy = l2tp_nl_policy,
+                .flags = GENL_ADMIN_PERM,
+        },
+        {
+                .cmd = L2TP_CMD_TUNNEL_MODIFY,
+                .doit = l2tp_nl_cmd_tunnel_modify,
+                .policy = l2tp_nl_policy,
+                .flags = GENL_ADMIN_PERM,
+        },
+        {
+                .cmd = L2TP_CMD_TUNNEL_GET,
+                .doit = l2tp_nl_cmd_tunnel_get,
+                .dumpit = l2tp_nl_cmd_tunnel_dump,
+                .policy = l2tp_nl_policy,
+                .flags = GENL_ADMIN_PERM,
+        },
+        {
+                .cmd = L2TP_CMD_SESSION_CREATE,
+                .doit = l2tp_nl_cmd_session_create,
+                .policy = l2tp_nl_policy,
+                .flags = GENL_ADMIN_PERM,
+        },
+        {
+                .cmd = L2TP_CMD_SESSION_DELETE,
+                .doit = l2tp_nl_cmd_session_delete,
+                .policy = l2tp_nl_policy,
+                .flags = GENL_ADMIN_PERM,
+        },
+        {
+                .cmd = L2TP_CMD_SESSION_MODIFY,
+                .doit = l2tp_nl_cmd_session_modify,
+                .policy = l2tp_nl_policy,
+                .flags = GENL_ADMIN_PERM,
+        },
+        {
+                .cmd = L2TP_CMD_SESSION_GET,
+                .doit = l2tp_nl_cmd_session_get,
+                .dumpit = l2tp_nl_cmd_session_dump,
+                .policy = l2tp_nl_policy,
+                .flags = GENL_ADMIN_PERM,
+        },
+};
+
+int l2tp_nl_register_ops(enum l2tp_pwtype pw_type, const struct l2tp_nl_cmd_ops *ops)
+{
+        int ret;
+
+        ret = -EINVAL;
+        if (pw_type >= __L2TP_PWTYPE_MAX)
+                goto err;
+
+        genl_lock();
+        ret = -EBUSY;
+        if (l2tp_nl_cmd_ops[pw_type])
+                goto out;
+
+        l2tp_nl_cmd_ops[pw_type] = ops;
+
+out:
+        genl_unlock();
+err:
+        return 0;
+}
+EXPORT_SYMBOL_GPL(l2tp_nl_register_ops);
+
+void l2tp_nl_unregister_ops(enum l2tp_pwtype pw_type)
+{
+        if (pw_type < __L2TP_PWTYPE_MAX) {
+                genl_lock();
+                l2tp_nl_cmd_ops[pw_type] = NULL;
+                genl_unlock();
+        }
+}
+EXPORT_SYMBOL_GPL(l2tp_nl_unregister_ops);
+
+static int l2tp_nl_init(void)
+{
+        int err;
+
+        printk(KERN_INFO "L2TP netlink interface\n");
+        err = genl_register_family_with_ops(&l2tp_nl_family, l2tp_nl_ops,
+                                            ARRAY_SIZE(l2tp_nl_ops));
+
+        return err;
+}
+
+static void l2tp_nl_cleanup(void)
+{
+        genl_unregister_family(&l2tp_nl_family);
+}
+
+module_init(l2tp_nl_init);
+module_exit(l2tp_nl_cleanup);
+
+MODULE_AUTHOR("James Chapman <jchapman@katalix.com>");
+MODULE_DESCRIPTION("L2TP netlink");
+MODULE_LICENSE("GPL");
+MODULE_VERSION("1.0");
+MODULE_ALIAS("net-pf-" __stringify(PF_NETLINK) "-proto-" \
+             __stringify(NETLINK_GENERIC) "-type-" "l2tp");
diff --git a/net/l2tp/l2tp_ppp.c b/net/l2tp/l2tp_ppp.c
new file mode 100644
index 000000000000..90d82b3f2889
--- /dev/null
+++ b/net/l2tp/l2tp_ppp.c
@@ -0,0 +1,1837 @@
+/*****************************************************************************
+ * Linux PPP over L2TP (PPPoX/PPPoL2TP) Sockets
+ *
+ * PPPoX    --- Generic PPP encapsulation socket family
+ * PPPoL2TP --- PPP over L2TP (RFC 2661)
+ *
+ * Version:     2.0.0
+ *
+ * Authors:     James Chapman (jchapman@katalix.com)
+ *
+ * Based on original work by Martijn van Oosterhout <kleptog@svana.org>
+ *
+ * License:
+ *              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 driver handles only L2TP data frames; control frames are handled by a
+ * userspace application.
+ *
+ * To send data in an L2TP session, userspace opens a PPPoL2TP socket and
+ * attaches it to a bound UDP socket with local tunnel_id / session_id and
+ * peer tunnel_id / session_id set. Data can then be sent or received using
+ * regular socket sendmsg() / recvmsg() calls. Kernel parameters of the socket
+ * can be read or modified using ioctl() or [gs]etsockopt() calls.
+ *
+ * When a PPPoL2TP socket is connected with local and peer session_id values
+ * zero, the socket is treated as a special tunnel management socket.
+ *
+ * Here's example userspace code to create a socket for sending/receiving data
+ * over an L2TP session:-
+ *
+ *      struct sockaddr_pppol2tp sax;
+ *      int fd;
+ *      int session_fd;
+ *
+ *      fd = socket(AF_PPPOX, SOCK_DGRAM, PX_PROTO_OL2TP);
+ *
+ *      sax.sa_family = AF_PPPOX;
+ *      sax.sa_protocol = PX_PROTO_OL2TP;
+ *      sax.pppol2tp.fd = tunnel_fd;    // bound UDP socket
+ *      sax.pppol2tp.addr.sin_addr.s_addr = addr->sin_addr.s_addr;
+ *      sax.pppol2tp.addr.sin_port = addr->sin_port;
+ *      sax.pppol2tp.addr.sin_family = AF_INET;
+ *      sax.pppol2tp.s_tunnel  = tunnel_id;
+ *      sax.pppol2tp.s_session = session_id;
+ *      sax.pppol2tp.d_tunnel  = peer_tunnel_id;
+ *      sax.pppol2tp.d_session = peer_session_id;
+ *
+ *      session_fd = connect(fd, (struct sockaddr *)&sax, sizeof(sax));
+ *
+ * A pppd plugin that allows PPP traffic to be carried over L2TP using
+ * this driver is available from the OpenL2TP project at
+ * http://openl2tp.sourceforge.net.
+ */
+
+#include <linux/module.h>
+#include <linux/string.h>
+#include <linux/list.h>
+#include <linux/uaccess.h>
+
+#include <linux/kernel.h>
+#include <linux/spinlock.h>
+#include <linux/kthread.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
+#include <linux/errno.h>
+#include <linux/jiffies.h>
+
+#include <linux/netdevice.h>
+#include <linux/net.h>
+#include <linux/inetdevice.h>
+#include <linux/skbuff.h>
+#include <linux/init.h>
+#include <linux/ip.h>
+#include <linux/udp.h>
+#include <linux/if_pppox.h>
+#include <linux/if_pppol2tp.h>
+#include <net/sock.h>
+#include <linux/ppp_channel.h>
+#include <linux/ppp_defs.h>
+#include <linux/if_ppp.h>
+#include <linux/file.h>
+#include <linux/hash.h>
+#include <linux/sort.h>
+#include <linux/proc_fs.h>
+#include <linux/l2tp.h>
+#include <linux/nsproxy.h>
+#include <net/net_namespace.h>
+#include <net/netns/generic.h>
+#include <net/dst.h>
+#include <net/ip.h>
+#include <net/udp.h>
+#include <net/xfrm.h>
+
+#include <asm/byteorder.h>
+#include <asm/atomic.h>
+
+#include "l2tp_core.h"
+
+#define PPPOL2TP_DRV_VERSION    "V2.0"
+
+/* Space for UDP, L2TP and PPP headers */
+#define PPPOL2TP_HEADER_OVERHEAD        40
+
+#define PRINTK(_mask, _type, _lvl, _fmt, args...)                       \
+        do {                                                            \
+                if ((_mask) & (_type))                                  \
+                        printk(_lvl "PPPOL2TP: " _fmt, ##args);         \
+        } while (0)
+
+/* Number of bytes to build transmit L2TP headers.
+ * Unfortunately the size is different depending on whether sequence numbers
+ * are enabled.
+ */
+#define PPPOL2TP_L2TP_HDR_SIZE_SEQ              10
+#define PPPOL2TP_L2TP_HDR_SIZE_NOSEQ            6
+
+/* Private data of each session. This data lives at the end of struct
+ * l2tp_session, referenced via session->priv[].
+ */
+struct pppol2tp_session {
+        int                     owner;          /* pid that opened the socket */
+
+        struct sock             *sock;          /* Pointer to the session
+                                                 * PPPoX socket */
+        struct sock             *tunnel_sock;   /* Pointer to the tunnel UDP
+                                                 * socket */
+        int                     flags;          /* accessed by PPPIOCGFLAGS.
+                                                 * Unused. */
+};
+
+static int pppol2tp_xmit(struct ppp_channel *chan, struct sk_buff *skb);
+
+static struct ppp_channel_ops pppol2tp_chan_ops = { pppol2tp_xmit , NULL };
+static const struct proto_ops pppol2tp_ops;
+
+/* Helpers to obtain tunnel/session contexts from sockets.
+ */
+static inline struct l2tp_session *pppol2tp_sock_to_session(struct sock *sk)
+{
+        struct l2tp_session *session;
+
+        if (sk == NULL)
+                return NULL;
+
+        sock_hold(sk);
+        session = (struct l2tp_session *)(sk->sk_user_data);
+        if (session == NULL) {
+                sock_put(sk);
+                goto out;
+        }
+
+        BUG_ON(session->magic != L2TP_SESSION_MAGIC);
+
+out:
+        return session;
+}
+
+/*****************************************************************************
+ * Receive data handling
+ *****************************************************************************/
+
+static int pppol2tp_recv_payload_hook(struct sk_buff *skb)
+{
+        /* Skip PPP header, if present.  In testing, Microsoft L2TP clients
+         * don't send the PPP header (PPP header compression enabled), but
+         * other clients can include the header. So we cope with both cases
+         * here. The PPP header is always FF03 when using L2TP.
+         *
+         * Note that skb->data[] isn't dereferenced from a u16 ptr here since
+         * the field may be unaligned.
+         */
+        if (!pskb_may_pull(skb, 2))
+                return 1;
+
+        if ((skb->data[0] == 0xff) && (skb->data[1] == 0x03))
+                skb_pull(skb, 2);
+
+        return 0;
+}
+
+/* Receive message. This is the recvmsg for the PPPoL2TP socket.
+ */
+static int pppol2tp_recvmsg(struct kiocb *iocb, struct socket *sock,
+                            struct msghdr *msg, size_t len,
+                            int flags)
+{
+        int err;
+        struct sk_buff *skb;
+        struct sock *sk = sock->sk;
+
+        err = -EIO;
+        if (sk->sk_state & PPPOX_BOUND)
+                goto end;
+
+        msg->msg_namelen = 0;
+
+        err = 0;
+        skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
+                                flags & MSG_DONTWAIT, &err);
+        if (!skb)
+                goto end;
+
+        if (len > skb->len)
+                len = skb->len;
+        else if (len < skb->len)
+                msg->msg_flags |= MSG_TRUNC;
+
+        err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, len);
+        if (likely(err == 0))
+                err = len;
+
+        kfree_skb(skb);
+end:
+        return err;
+}
+
+static void pppol2tp_recv(struct l2tp_session *session, struct sk_buff *skb, int data_len)
+{
+        struct pppol2tp_session *ps = l2tp_session_priv(session);
+        struct sock *sk = NULL;
+
+        /* If the socket is bound, send it in to PPP's input queue. Otherwise
+         * queue it on the session socket.
+         */
+        sk = ps->sock;
+        if (sk == NULL)
+                goto no_sock;
+
+        if (sk->sk_state & PPPOX_BOUND) {
+                struct pppox_sock *po;
+                PRINTK(session->debug, PPPOL2TP_MSG_DATA, KERN_DEBUG,
+                       "%s: recv %d byte data frame, passing to ppp\n",
+                       session->name, data_len);
+
+                /* We need to forget all info related to the L2TP packet
+                 * gathered in the skb as we are going to reuse the same
+                 * skb for the inner packet.
+                 * Namely we need to:
+                 * - reset xfrm (IPSec) information as it applies to
+                 *   the outer L2TP packet and not to the inner one
+                 * - release the dst to force a route lookup on the inner
+                 *   IP packet since skb->dst currently points to the dst
+                 *   of the UDP tunnel
+                 * - reset netfilter information as it doesn't apply
+                 *   to the inner packet either
+                 */
+                secpath_reset(skb);
+                skb_dst_drop(skb);
+                nf_reset(skb);
+
+                po = pppox_sk(sk);
+                ppp_input(&po->chan, skb);
+        } else {
+                PRINTK(session->debug, PPPOL2TP_MSG_DATA, KERN_INFO,
+                       "%s: socket not bound\n", session->name);
+
+                /* Not bound. Nothing we can do, so discard. */
+                session->stats.rx_errors++;
+                kfree_skb(skb);
+        }
+
+        return;
+
+no_sock:
+        PRINTK(session->debug, PPPOL2TP_MSG_DATA, KERN_INFO,
+               "%s: no socket\n", session->name);
+        kfree_skb(skb);
+}
+
+static void pppol2tp_session_sock_hold(struct l2tp_session *session)
+{
+        struct pppol2tp_session *ps = l2tp_session_priv(session);
+
+        if (ps->sock)
+                sock_hold(ps->sock);
+}
+
+static void pppol2tp_session_sock_put(struct l2tp_session *session)
+{
+        struct pppol2tp_session *ps = l2tp_session_priv(session);
+
+        if (ps->sock)
+                sock_put(ps->sock);
+}
+
+/************************************************************************
+ * Transmit handling
+ ***********************************************************************/
+
+/* This is the sendmsg for the PPPoL2TP pppol2tp_session socket.  We come here
+ * when a user application does a sendmsg() on the session socket. L2TP and
+ * PPP headers must be inserted into the user's data.
+ */
+static int pppol2tp_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m,
+                            size_t total_len)
+{
+        static const unsigned char ppph[2] = { 0xff, 0x03 };
+        struct sock *sk = sock->sk;
+        struct sk_buff *skb;
+        int error;
+        struct l2tp_session *session;
+        struct l2tp_tunnel *tunnel;
+        struct pppol2tp_session *ps;
+        int uhlen;
+
+        error = -ENOTCONN;
+        if (sock_flag(sk, SOCK_DEAD) || !(sk->sk_state & PPPOX_CONNECTED))
+                goto error;
+
+        /* Get session and tunnel contexts */
+        error = -EBADF;
+        session = pppol2tp_sock_to_session(sk);
+        if (session == NULL)
+                goto error;
+
+        ps = l2tp_session_priv(session);
+        tunnel = l2tp_sock_to_tunnel(ps->tunnel_sock);
+        if (tunnel == NULL)
+                goto error_put_sess;
+
+        uhlen = (tunnel->encap == L2TP_ENCAPTYPE_UDP) ? sizeof(struct udphdr) : 0;
+
+        /* Allocate a socket buffer */
+        error = -ENOMEM;
+        skb = sock_wmalloc(sk, NET_SKB_PAD + sizeof(struct iphdr) +
+                           uhlen + session->hdr_len +
+                           sizeof(ppph) + total_len,
+                           0, GFP_KERNEL);
+        if (!skb)
+                goto error_put_sess_tun;
+
+        /* Reserve space for headers. */
+        skb_reserve(skb, NET_SKB_PAD);
+        skb_reset_network_header(skb);
+        skb_reserve(skb, sizeof(struct iphdr));
+        skb_reset_transport_header(skb);
+        skb_reserve(skb, uhlen);
+
+        /* Add PPP header */
+        skb->data[0] = ppph[0];
+        skb->data[1] = ppph[1];
+        skb_put(skb, 2);
+
+        /* Copy user data into skb */
+        error = memcpy_fromiovec(skb->data, m->msg_iov, total_len);
+        if (error < 0) {
+                kfree_skb(skb);
+                goto error_put_sess_tun;
+        }
+        skb_put(skb, total_len);
+
+        l2tp_xmit_skb(session, skb, session->hdr_len);
+
+        sock_put(ps->tunnel_sock);
+
+        return error;
+
+error_put_sess_tun:
+        sock_put(ps->tunnel_sock);
+error_put_sess:
+        sock_put(sk);
+error:
+        return error;
+}
+
+/* Transmit function called by generic PPP driver.  Sends PPP frame
+ * over PPPoL2TP socket.
+ *
+ * This is almost the same as pppol2tp_sendmsg(), but rather than
+ * being called with a msghdr from userspace, it is called with a skb
+ * from the kernel.
+ *
+ * The supplied skb from ppp doesn't have enough headroom for the
+ * insertion of L2TP, UDP and IP headers so we need to allocate more
+ * headroom in the skb. This will create a cloned skb. But we must be
+ * careful in the error case because the caller will expect to free
+ * the skb it supplied, not our cloned skb. So we take care to always
+ * leave the original skb unfreed if we return an error.
+ */
+static int pppol2tp_xmit(struct ppp_channel *chan, struct sk_buff *skb)
+{
+        static const u8 ppph[2] = { 0xff, 0x03 };
+        struct sock *sk = (struct sock *) chan->private;
+        struct sock *sk_tun;
+        struct l2tp_session *session;
+        struct l2tp_tunnel *tunnel;
+        struct pppol2tp_session *ps;
+        int old_headroom;
+        int new_headroom;
+
+        if (sock_flag(sk, SOCK_DEAD) || !(sk->sk_state & PPPOX_CONNECTED))
+                goto abort;
+
+        /* Get session and tunnel contexts from the socket */
+        session = pppol2tp_sock_to_session(sk);
+        if (session == NULL)
+                goto abort;
+
+        ps = l2tp_session_priv(session);
+        sk_tun = ps->tunnel_sock;
+        if (sk_tun == NULL)
+                goto abort_put_sess;
+        tunnel = l2tp_sock_to_tunnel(sk_tun);
+        if (tunnel == NULL)
+                goto abort_put_sess;
+
+        old_headroom = skb_headroom(skb);
+        if (skb_cow_head(skb, sizeof(ppph)))
+                goto abort_put_sess_tun;
+
+        new_headroom = skb_headroom(skb);
+        skb->truesize += new_headroom - old_headroom;
+
+        /* Setup PPP header */
+        __skb_push(skb, sizeof(ppph));
+        skb->data[0] = ppph[0];
+        skb->data[1] = ppph[1];
+
+        l2tp_xmit_skb(session, skb, session->hdr_len);
+
+        sock_put(sk_tun);
+        sock_put(sk);
+        return 1;
+
+abort_put_sess_tun:
+        sock_put(sk_tun);
+abort_put_sess:
+        sock_put(sk);
+abort:
+        /* Free the original skb */
+        kfree_skb(skb);
+        return 1;
+}
+
+/*****************************************************************************
+ * Session (and tunnel control) socket create/destroy.
+ *****************************************************************************/
+
+/* Called by l2tp_core when a session socket is being closed.
+ */
+static void pppol2tp_session_close(struct l2tp_session *session)
+{
+        struct pppol2tp_session *ps = l2tp_session_priv(session);
+        struct sock *sk = ps->sock;
+        struct sk_buff *skb;
+
+        BUG_ON(session->magic != L2TP_SESSION_MAGIC);
+
+        if (session->session_id == 0)
+                goto out;
+
+        if (sk != NULL) {
+                lock_sock(sk);
+
+                if (sk->sk_state & (PPPOX_CONNECTED | PPPOX_BOUND)) {
+                        pppox_unbind_sock(sk);
+                        sk->sk_state = PPPOX_DEAD;
+                        sk->sk_state_change(sk);
+                }
+
+                /* Purge any queued data */
+                skb_queue_purge(&sk->sk_receive_queue);
+                skb_queue_purge(&sk->sk_write_queue);
+                while ((skb = skb_dequeue(&session->reorder_q))) {
+                        kfree_skb(skb);
+                        sock_put(sk);
+                }
+
+                release_sock(sk);
+        }
+
+out:
+        return;
+}
+
+/* Really kill the session socket. (Called from sock_put() if
+ * refcnt == 0.)
+ */
+static void pppol2tp_session_destruct(struct sock *sk)
+{
+        struct l2tp_session *session;
+
+        if (sk->sk_user_data != NULL) {
+                session = sk->sk_user_data;
+                if (session == NULL)
+                        goto out;
+
+                sk->sk_user_data = NULL;
+                BUG_ON(session->magic != L2TP_SESSION_MAGIC);
+                l2tp_session_dec_refcount(session);
+        }
+
+out:
+        return;
+}
+
+/* Called when the PPPoX socket (session) is closed.
+ */
+static int pppol2tp_release(struct socket *sock)
+{
+        struct sock *sk = sock->sk;
+        struct l2tp_session *session;
+        int error;
+
+        if (!sk)
+                return 0;
+
+        error = -EBADF;
+        lock_sock(sk);
+        if (sock_flag(sk, SOCK_DEAD) != 0)
+                goto error;
+
+        pppox_unbind_sock(sk);
+
+        /* Signal the death of the socket. */
+        sk->sk_state = PPPOX_DEAD;
+        sock_orphan(sk);
+        sock->sk = NULL;
+
+        session = pppol2tp_sock_to_session(sk);
+
+        /* Purge any queued data */
+        skb_queue_purge(&sk->sk_receive_queue);
+        skb_queue_purge(&sk->sk_write_queue);
+        if (session != NULL) {
+                struct sk_buff *skb;
+                while ((skb = skb_dequeue(&session->reorder_q))) {
+                        kfree_skb(skb);
+                        sock_put(sk);
+                }
+                sock_put(sk);
+        }
+
+        release_sock(sk);
+
+        /* This will delete the session context via
+         * pppol2tp_session_destruct() if the socket's refcnt drops to
+         * zero.
+         */
+        sock_put(sk);
+
+        return 0;
+
+error:
+        release_sock(sk);
+        return error;
+}
+
+static struct proto pppol2tp_sk_proto = {
+        .name     = "PPPOL2TP",
+        .owner    = THIS_MODULE,
+        .obj_size = sizeof(struct pppox_sock),
+};
+
+static int pppol2tp_backlog_recv(struct sock *sk, struct sk_buff *skb)
+{
+        int rc;
+
+        rc = l2tp_udp_encap_recv(sk, skb);
+        if (rc)
+                kfree_skb(skb);
+
+        return NET_RX_SUCCESS;
+}
+
+/* socket() handler. Initialize a new struct sock.
+ */
+static int pppol2tp_create(struct net *net, struct socket *sock)
+{
+        int error = -ENOMEM;
+        struct sock *sk;
+
+        sk = sk_alloc(net, PF_PPPOX, GFP_KERNEL, &pppol2tp_sk_proto);
+        if (!sk)
+                goto out;
+
+        sock_init_data(sock, sk);
+
+        sock->state  = SS_UNCONNECTED;
+        sock->ops    = &pppol2tp_ops;
+
+        sk->sk_backlog_rcv = pppol2tp_backlog_recv;
+        sk->sk_protocol    = PX_PROTO_OL2TP;
+        sk->sk_family      = PF_PPPOX;
+        sk->sk_state       = PPPOX_NONE;
+        sk->sk_type        = SOCK_STREAM;
+        sk->sk_destruct    = pppol2tp_session_destruct;
+
+        error = 0;
+
+out:
+        return error;
+}
+
+#if defined(CONFIG_L2TP_DEBUGFS) || defined(CONFIG_L2TP_DEBUGFS_MODULE)
+static void pppol2tp_show(struct seq_file *m, void *arg)
+{
+        struct l2tp_session *session = arg;
+        struct pppol2tp_session *ps = l2tp_session_priv(session);
+
+        if (ps) {
+                struct pppox_sock *po = pppox_sk(ps->sock);
+                if (po)
+                        seq_printf(m, "   interface %s\n", ppp_dev_name(&po->chan));
+        }
+}
+#endif
+
+/* connect() handler. Attach a PPPoX socket to a tunnel UDP socket
+ */
+static int pppol2tp_connect(struct socket *sock, struct sockaddr *uservaddr,
+                            int sockaddr_len, int flags)
+{
+        struct sock *sk = sock->sk;
+        struct sockaddr_pppol2tp *sp = (struct sockaddr_pppol2tp *) uservaddr;
+        struct sockaddr_pppol2tpv3 *sp3 = (struct sockaddr_pppol2tpv3 *) uservaddr;
+        struct pppox_sock *po = pppox_sk(sk);
+        struct l2tp_session *session = NULL;
+        struct l2tp_tunnel *tunnel;
+        struct pppol2tp_session *ps;
+        struct dst_entry *dst;
+        struct l2tp_session_cfg cfg = { 0, };
+        int error = 0;
+        u32 tunnel_id, peer_tunnel_id;
+        u32 session_id, peer_session_id;
+        int ver = 2;
+        int fd;
+
+        lock_sock(sk);
+
+        error = -EINVAL;
+        if (sp->sa_protocol != PX_PROTO_OL2TP)
+                goto end;
+
+        /* Check for already bound sockets */
+        error = -EBUSY;
+        if (sk->sk_state & PPPOX_CONNECTED)
+                goto end;
+
+        /* We don't supporting rebinding anyway */
+        error = -EALREADY;
+        if (sk->sk_user_data)
+                goto end; /* socket is already attached */
+
+        /* Get params from socket address. Handle L2TPv2 and L2TPv3 */
+        if (sockaddr_len == sizeof(struct sockaddr_pppol2tp)) {
+                fd = sp->pppol2tp.fd;
+                tunnel_id = sp->pppol2tp.s_tunnel;
+                peer_tunnel_id = sp->pppol2tp.d_tunnel;
+                session_id = sp->pppol2tp.s_session;
+                peer_session_id = sp->pppol2tp.d_session;
+        } else if (sockaddr_len == sizeof(struct sockaddr_pppol2tpv3)) {
+                ver = 3;
+                fd = sp3->pppol2tp.fd;
+                tunnel_id = sp3->pppol2tp.s_tunnel;
+                peer_tunnel_id = sp3->pppol2tp.d_tunnel;
+                session_id = sp3->pppol2tp.s_session;
+                peer_session_id = sp3->pppol2tp.d_session;
+        } else {
+                error = -EINVAL;
+                goto end; /* bad socket address */
+        }
+
+        /* Don't bind if tunnel_id is 0 */
+        error = -EINVAL;
+        if (tunnel_id == 0)
+                goto end;
+
+        tunnel = l2tp_tunnel_find(sock_net(sk), tunnel_id);
+
+        /* Special case: create tunnel context if session_id and
+         * peer_session_id is 0. Otherwise look up tunnel using supplied
+         * tunnel id.
+         */
+        if ((session_id == 0) && (peer_session_id == 0)) {
+                if (tunnel == NULL) {
+                        struct l2tp_tunnel_cfg tcfg = {
+                                .encap = L2TP_ENCAPTYPE_UDP,
+                                .debug = 0,
+                        };
+                        error = l2tp_tunnel_create(sock_net(sk), fd, ver, tunnel_id, peer_tunnel_id, &tcfg, &tunnel);
+                        if (error < 0)
+                                goto end;
+                }
+        } else {
+                /* Error if we can't find the tunnel */
+                error = -ENOENT;
+                if (tunnel == NULL)
+                        goto end;
+
+                /* Error if socket is not prepped */
+                if (tunnel->sock == NULL)
+                        goto end;
+        }
+
+        if (tunnel->recv_payload_hook == NULL)
+                tunnel->recv_payload_hook = pppol2tp_recv_payload_hook;
+
+        if (tunnel->peer_tunnel_id == 0) {
+                if (ver == 2)
+                        tunnel->peer_tunnel_id = sp->pppol2tp.d_tunnel;
+                else
+                        tunnel->peer_tunnel_id = sp3->pppol2tp.d_tunnel;
+        }
+
+        /* Create session if it doesn't already exist. We handle the
+         * case where a session was previously created by the netlink
+         * interface by checking that the session doesn't already have
+         * a socket and its tunnel socket are what we expect. If any
+         * of those checks fail, return EEXIST to the caller.
+         */
+        session = l2tp_session_find(sock_net(sk), tunnel, session_id);
+        if (session == NULL) {
+                /* Default MTU must allow space for UDP/L2TP/PPP
+                 * headers.
+                 */
+                cfg.mtu = cfg.mru = 1500 - PPPOL2TP_HEADER_OVERHEAD;
+
+                /* Allocate and initialize a new session context. */
+                session = l2tp_session_create(sizeof(struct pppol2tp_session),
+                                              tunnel, session_id,
+                                              peer_session_id, &cfg);
+                if (session == NULL) {
+                        error = -ENOMEM;
+                        goto end;
+                }
+        } else {
+                ps = l2tp_session_priv(session);
+                error = -EEXIST;
+                if (ps->sock != NULL)
+                        goto end;
+
+                /* consistency checks */
+                if (ps->tunnel_sock != tunnel->sock)
+                        goto end;
+        }
+
+        /* Associate session with its PPPoL2TP socket */
+        ps = l2tp_session_priv(session);
+        ps->owner            = current->pid;
+        ps->sock             = sk;
+        ps->tunnel_sock = tunnel->sock;
+
+        session->recv_skb       = pppol2tp_recv;
+        session->session_close  = pppol2tp_session_close;
+#if defined(CONFIG_L2TP_DEBUGFS) || defined(CONFIG_L2TP_DEBUGFS_MODULE)
+        session->show           = pppol2tp_show;
+#endif
+
+        /* We need to know each time a skb is dropped from the reorder
+         * queue.
+         */
+        session->ref = pppol2tp_session_sock_hold;
+        session->deref = pppol2tp_session_sock_put;
+
+        /* If PMTU discovery was enabled, use the MTU that was discovered */
+        dst = sk_dst_get(sk);
+        if (dst != NULL) {
+                u32 pmtu = dst_mtu(__sk_dst_get(sk));
+                if (pmtu != 0)
+                        session->mtu = session->mru = pmtu -
+                                PPPOL2TP_HEADER_OVERHEAD;
+                dst_release(dst);
+        }
+
+        /* Special case: if source & dest session_id == 0x0000, this
+         * socket is being created to manage the tunnel. Just set up
+         * the internal context for use by ioctl() and sockopt()
+         * handlers.
+         */
+        if ((session->session_id == 0) &&
+            (session->peer_session_id == 0)) {
+                error = 0;
+                goto out_no_ppp;
+        }
+
+        /* The only header we need to worry about is the L2TP
+         * header. This size is different depending on whether
+         * sequence numbers are enabled for the data channel.
+         */
+        po->chan.hdrlen = PPPOL2TP_L2TP_HDR_SIZE_NOSEQ;
+
+        po->chan.private = sk;
+        po->chan.ops     = &pppol2tp_chan_ops;
+        po->chan.mtu     = session->mtu;
+
+        error = ppp_register_net_channel(sock_net(sk), &po->chan);
+        if (error)
+                goto end;
+
+out_no_ppp:
+        /* This is how we get the session context from the socket. */
+        sk->sk_user_data = session;
+        sk->sk_state = PPPOX_CONNECTED;
+        PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
+               "%s: created\n", session->name);
+
+end:
+        release_sock(sk);
+
+        return error;
+}
+
+#ifdef CONFIG_L2TP_V3
+
+/* Called when creating sessions via the netlink interface.
+ */
+static int pppol2tp_session_create(struct net *net, u32 tunnel_id, u32 session_id, u32 peer_session_id, struct l2tp_session_cfg *cfg)
+{
+        int error;
+        struct l2tp_tunnel *tunnel;
+        struct l2tp_session *session;
+        struct pppol2tp_session *ps;
+
+        tunnel = l2tp_tunnel_find(net, tunnel_id);
+
+        /* Error if we can't find the tunnel */
+        error = -ENOENT;
+        if (tunnel == NULL)
+                goto out;
+
+        /* Error if tunnel socket is not prepped */
+        if (tunnel->sock == NULL)
+                goto out;
+
+        /* Check that this session doesn't already exist */
+        error = -EEXIST;
+        session = l2tp_session_find(net, tunnel, session_id);
+        if (session != NULL)
+                goto out;
+
+        /* Default MTU values. */
+        if (cfg->mtu == 0)
+                cfg->mtu = 1500 - PPPOL2TP_HEADER_OVERHEAD;
+        if (cfg->mru == 0)
+                cfg->mru = cfg->mtu;
+
+        /* Allocate and initialize a new session context. */
+        error = -ENOMEM;
+        session = l2tp_session_create(sizeof(struct pppol2tp_session),
+                                      tunnel, session_id,
+                                      peer_session_id, cfg);
+        if (session == NULL)
+                goto out;
+
+        ps = l2tp_session_priv(session);
+        ps->tunnel_sock = tunnel->sock;
+
+        PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
+               "%s: created\n", session->name);
+
+        error = 0;
+
+out:
+        return error;
+}
+
+/* Called when deleting sessions via the netlink interface.
+ */
+static int pppol2tp_session_delete(struct l2tp_session *session)
+{
+        struct pppol2tp_session *ps = l2tp_session_priv(session);
+
+        if (ps->sock == NULL)
+                l2tp_session_dec_refcount(session);
+
+        return 0;
+}
+
+#endif /* CONFIG_L2TP_V3 */
+
+/* getname() support.
+ */
+static int pppol2tp_getname(struct socket *sock, struct sockaddr *uaddr,
+                            int *usockaddr_len, int peer)
+{
+        int len = 0;
+        int error = 0;
+        struct l2tp_session *session;
+        struct l2tp_tunnel *tunnel;
+        struct sock *sk = sock->sk;
+        struct inet_sock *inet;
+        struct pppol2tp_session *pls;
+
+        error = -ENOTCONN;
+        if (sk == NULL)
+                goto end;
+        if (sk->sk_state != PPPOX_CONNECTED)
+                goto end;
+
+        error = -EBADF;
+        session = pppol2tp_sock_to_session(sk);
+        if (session == NULL)
+                goto end;
+
+        pls = l2tp_session_priv(session);
+        tunnel = l2tp_sock_to_tunnel(pls->tunnel_sock);
+        if (tunnel == NULL) {
+                error = -EBADF;
+                goto end_put_sess;
+        }
+
+        inet = inet_sk(sk);
+        if (tunnel->version == 2) {
+                struct sockaddr_pppol2tp sp;
+                len = sizeof(sp);
+                memset(&sp, 0, len);
+                sp.sa_family    = AF_PPPOX;
+                sp.sa_protocol  = PX_PROTO_OL2TP;
+                sp.pppol2tp.fd  = tunnel->fd;
+                sp.pppol2tp.pid = pls->owner;
+                sp.pppol2tp.s_tunnel = tunnel->tunnel_id;
+                sp.pppol2tp.d_tunnel = tunnel->peer_tunnel_id;
+                sp.pppol2tp.s_session = session->session_id;
+                sp.pppol2tp.d_session = session->peer_session_id;
+                sp.pppol2tp.addr.sin_family = AF_INET;
+                sp.pppol2tp.addr.sin_port = inet->inet_dport;
+                sp.pppol2tp.addr.sin_addr.s_addr = inet->inet_daddr;
+                memcpy(uaddr, &sp, len);
+        } else if (tunnel->version == 3) {
+                struct sockaddr_pppol2tpv3 sp;
+                len = sizeof(sp);
+                memset(&sp, 0, len);
+                sp.sa_family    = AF_PPPOX;
+                sp.sa_protocol  = PX_PROTO_OL2TP;
+                sp.pppol2tp.fd  = tunnel->fd;
+                sp.pppol2tp.pid = pls->owner;
+                sp.pppol2tp.s_tunnel = tunnel->tunnel_id;
+                sp.pppol2tp.d_tunnel = tunnel->peer_tunnel_id;
+                sp.pppol2tp.s_session = session->session_id;
+                sp.pppol2tp.d_session = session->peer_session_id;
+                sp.pppol2tp.addr.sin_family = AF_INET;
+                sp.pppol2tp.addr.sin_port = inet->inet_dport;
+                sp.pppol2tp.addr.sin_addr.s_addr = inet->inet_daddr;
+                memcpy(uaddr, &sp, len);
+        }
+
+        *usockaddr_len = len;
+
+        sock_put(pls->tunnel_sock);
+end_put_sess:
+        sock_put(sk);
+        error = 0;
+
+end:
+        return error;
+}
+
+/****************************************************************************
+ * ioctl() handlers.
+ *
+ * The PPPoX socket is created for L2TP sessions: tunnels have their own UDP
+ * sockets. However, in order to control kernel tunnel features, we allow
+ * userspace to create a special "tunnel" PPPoX socket which is used for
+ * control only.  Tunnel PPPoX sockets have session_id == 0 and simply allow
+ * the user application to issue L2TP setsockopt(), getsockopt() and ioctl()
+ * calls.
+ ****************************************************************************/
+
+static void pppol2tp_copy_stats(struct pppol2tp_ioc_stats *dest,
+                                struct l2tp_stats *stats)
+{
+        dest->tx_packets = stats->tx_packets;
+        dest->tx_bytes = stats->tx_bytes;
+        dest->tx_errors = stats->tx_errors;
+        dest->rx_packets = stats->rx_packets;
+        dest->rx_bytes = stats->rx_bytes;
+        dest->rx_seq_discards = stats->rx_seq_discards;
+        dest->rx_oos_packets = stats->rx_oos_packets;
+        dest->rx_errors = stats->rx_errors;
+}
+
+/* Session ioctl helper.
+ */
+static int pppol2tp_session_ioctl(struct l2tp_session *session,
+                                  unsigned int cmd, unsigned long arg)
+{
+        struct ifreq ifr;
+        int err = 0;
+        struct sock *sk;
+        int val = (int) arg;
+        struct pppol2tp_session *ps = l2tp_session_priv(session);
+        struct l2tp_tunnel *tunnel = session->tunnel;
+        struct pppol2tp_ioc_stats stats;
+
+        PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_DEBUG,
+               "%s: pppol2tp_session_ioctl(cmd=%#x, arg=%#lx)\n",
+               session->name, cmd, arg);
+
+        sk = ps->sock;
+        sock_hold(sk);
+
+        switch (cmd) {
+        case SIOCGIFMTU:
+                err = -ENXIO;
+                if (!(sk->sk_state & PPPOX_CONNECTED))
+                        break;
+
+                err = -EFAULT;
+                if (copy_from_user(&ifr, (void __user *) arg, sizeof(struct ifreq)))
+                        break;
+                ifr.ifr_mtu = session->mtu;
+                if (copy_to_user((void __user *) arg, &ifr, sizeof(struct ifreq)))
+                        break;
+
+                PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
+                       "%s: get mtu=%d\n", session->name, session->mtu);
+                err = 0;
+                break;
+
+        case SIOCSIFMTU:
+                err = -ENXIO;
+                if (!(sk->sk_state & PPPOX_CONNECTED))
+                        break;
+
+                err = -EFAULT;
+                if (copy_from_user(&ifr, (void __user *) arg, sizeof(struct ifreq)))
+                        break;
+
+                session->mtu = ifr.ifr_mtu;
+
+                PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
+                       "%s: set mtu=%d\n", session->name, session->mtu);
+                err = 0;
+                break;
+
+        case PPPIOCGMRU:
+                err = -ENXIO;
+                if (!(sk->sk_state & PPPOX_CONNECTED))
+                        break;
+
+                err = -EFAULT;
+                if (put_user(session->mru, (int __user *) arg))
+                        break;
+
+                PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
+                       "%s: get mru=%d\n", session->name, session->mru);
+                err = 0;
+                break;
+
+        case PPPIOCSMRU:
+                err = -ENXIO;
+                if (!(sk->sk_state & PPPOX_CONNECTED))
+                        break;
+
+                err = -EFAULT;
+                if (get_user(val, (int __user *) arg))
+                        break;
+
+                session->mru = val;
+                PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
+                       "%s: set mru=%d\n", session->name, session->mru);
+                err = 0;
+                break;
+
+        case PPPIOCGFLAGS:
+                err = -EFAULT;
+                if (put_user(ps->flags, (int __user *) arg))
+                        break;
+
+                PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
+                       "%s: get flags=%d\n", session->name, ps->flags);
+                err = 0;
+                break;
+
+        case PPPIOCSFLAGS:
+                err = -EFAULT;
+                if (get_user(val, (int __user *) arg))
+                        break;
+                ps->flags = val;
+                PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
+                       "%s: set flags=%d\n", session->name, ps->flags);
+                err = 0;
+                break;
+
+        case PPPIOCGL2TPSTATS:
+                err = -ENXIO;
+                if (!(sk->sk_state & PPPOX_CONNECTED))
+                        break;
+
+                memset(&stats, 0, sizeof(stats));
+                stats.tunnel_id = tunnel->tunnel_id;
+                stats.session_id = session->session_id;
+                pppol2tp_copy_stats(&stats, &session->stats);
+                if (copy_to_user((void __user *) arg, &stats,
+                                 sizeof(stats)))
+                        break;
+                PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
+                       "%s: get L2TP stats\n", session->name);
+                err = 0;
+                break;
+
+        default:
+                err = -ENOSYS;
+                break;
+        }
+
+        sock_put(sk);
+
+        return err;
+}
+
+/* Tunnel ioctl helper.
+ *
+ * Note the special handling for PPPIOCGL2TPSTATS below. If the ioctl data
+ * specifies a session_id, the session ioctl handler is called. This allows an
+ * application to retrieve session stats via a tunnel socket.
+ */
+static int pppol2tp_tunnel_ioctl(struct l2tp_tunnel *tunnel,
+                                 unsigned int cmd, unsigned long arg)
+{
+        int err = 0;
+        struct sock *sk;
+        struct pppol2tp_ioc_stats stats;
+
+        PRINTK(tunnel->debug, PPPOL2TP_MSG_CONTROL, KERN_DEBUG,
+               "%s: pppol2tp_tunnel_ioctl(cmd=%#x, arg=%#lx)\n",
+               tunnel->name, cmd, arg);
+
+        sk = tunnel->sock;
+        sock_hold(sk);
+
+        switch (cmd) {
+        case PPPIOCGL2TPSTATS:
+                err = -ENXIO;
+                if (!(sk->sk_state & PPPOX_CONNECTED))
+                        break;
+
+                if (copy_from_user(&stats, (void __user *) arg,
+                                   sizeof(stats))) {
+                        err = -EFAULT;
+                        break;
+                }
+                if (stats.session_id != 0) {
+                        /* resend to session ioctl handler */
+                        struct l2tp_session *session =
+                                l2tp_session_find(sock_net(sk), tunnel, stats.session_id);
+                        if (session != NULL)
+                                err = pppol2tp_session_ioctl(session, cmd, arg);
+                        else
+                                err = -EBADR;
+                        break;
+                }
+#ifdef CONFIG_XFRM
+                stats.using_ipsec = (sk->sk_policy[0] || sk->sk_policy[1]) ? 1 : 0;
+#endif
+                pppol2tp_copy_stats(&stats, &tunnel->stats);
+                if (copy_to_user((void __user *) arg, &stats, sizeof(stats))) {
+                        err = -EFAULT;
+                        break;
+                }
+                PRINTK(tunnel->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
+                       "%s: get L2TP stats\n", tunnel->name);
+                err = 0;
+                break;
+
+        default:
+                err = -ENOSYS;
+                break;
+        }
+
+        sock_put(sk);
+
+        return err;
+}
+
+/* Main ioctl() handler.
+ * Dispatch to tunnel or session helpers depending on the socket.
+ */
+static int pppol2tp_ioctl(struct socket *sock, unsigned int cmd,
+                          unsigned long arg)
+{
+        struct sock *sk = sock->sk;
+        struct l2tp_session *session;
+        struct l2tp_tunnel *tunnel;
+        struct pppol2tp_session *ps;
+        int err;
+
+        if (!sk)
+                return 0;
+
+        err = -EBADF;
+        if (sock_flag(sk, SOCK_DEAD) != 0)
+                goto end;
+
+        err = -ENOTCONN;
+        if ((sk->sk_user_data == NULL) ||
+            (!(sk->sk_state & (PPPOX_CONNECTED | PPPOX_BOUND))))
+                goto end;
+
+        /* Get session context from the socket */
+        err = -EBADF;
+        session = pppol2tp_sock_to_session(sk);
+        if (session == NULL)
+                goto end;
+
+        /* Special case: if session's session_id is zero, treat ioctl as a
+         * tunnel ioctl
+         */
+        ps = l2tp_session_priv(session);
+        if ((session->session_id == 0) &&
+            (session->peer_session_id == 0)) {
+                err = -EBADF;
+                tunnel = l2tp_sock_to_tunnel(ps->tunnel_sock);
+                if (tunnel == NULL)
+                        goto end_put_sess;
+
+                err = pppol2tp_tunnel_ioctl(tunnel, cmd, arg);
+                sock_put(ps->tunnel_sock);
+                goto end_put_sess;
+        }
+
+        err = pppol2tp_session_ioctl(session, cmd, arg);
+
+end_put_sess:
+        sock_put(sk);
+end:
+        return err;
+}
+
+/*****************************************************************************
+ * setsockopt() / getsockopt() support.
+ *
+ * The PPPoX socket is created for L2TP sessions: tunnels have their own UDP
+ * sockets. In order to control kernel tunnel features, we allow userspace to
+ * create a special "tunnel" PPPoX socket which is used for control only.
+ * Tunnel PPPoX sockets have session_id == 0 and simply allow the user
+ * application to issue L2TP setsockopt(), getsockopt() and ioctl() calls.
+ *****************************************************************************/
+
+/* Tunnel setsockopt() helper.
+ */
+static int pppol2tp_tunnel_setsockopt(struct sock *sk,
+                                      struct l2tp_tunnel *tunnel,
+                                      int optname, int val)
+{
+        int err = 0;
+
+        switch (optname) {
+        case PPPOL2TP_SO_DEBUG:
+                tunnel->debug = val;
+                PRINTK(tunnel->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
+                       "%s: set debug=%x\n", tunnel->name, tunnel->debug);
+                break;
+
+        default:
+                err = -ENOPROTOOPT;
+                break;
+        }
+
+        return err;
+}
+
+/* Session setsockopt helper.
+ */
+static int pppol2tp_session_setsockopt(struct sock *sk,
+                                       struct l2tp_session *session,
+                                       int optname, int val)
+{
+        int err = 0;
+        struct pppol2tp_session *ps = l2tp_session_priv(session);
+
+        switch (optname) {
+        case PPPOL2TP_SO_RECVSEQ:
+                if ((val != 0) && (val != 1)) {
+                        err = -EINVAL;
+                        break;
+                }
+                session->recv_seq = val ? -1 : 0;
+                PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
+                       "%s: set recv_seq=%d\n", session->name, session->recv_seq);
+                break;
+
+        case PPPOL2TP_SO_SENDSEQ:
+                if ((val != 0) && (val != 1)) {
+                        err = -EINVAL;
+                        break;
+                }
+                session->send_seq = val ? -1 : 0;
+                {
+                        struct sock *ssk      = ps->sock;
+                        struct pppox_sock *po = pppox_sk(ssk);
+                        po->chan.hdrlen = val ? PPPOL2TP_L2TP_HDR_SIZE_SEQ :
+                                PPPOL2TP_L2TP_HDR_SIZE_NOSEQ;
+                }
+                PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
+                       "%s: set send_seq=%d\n", session->name, session->send_seq);
+                break;
+
+        case PPPOL2TP_SO_LNSMODE:
+                if ((val != 0) && (val != 1)) {
+                        err = -EINVAL;
+                        break;
+                }
+                session->lns_mode = val ? -1 : 0;
+                PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
+                       "%s: set lns_mode=%d\n", session->name, session->lns_mode);
+                break;
+
+        case PPPOL2TP_SO_DEBUG:
+                session->debug = val;
+                PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
+                       "%s: set debug=%x\n", session->name, session->debug);
+                break;
+
+        case PPPOL2TP_SO_REORDERTO:
+                session->reorder_timeout = msecs_to_jiffies(val);
+                PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
+                       "%s: set reorder_timeout=%d\n", session->name, session->reorder_timeout);
+                break;
+
+        default:
+                err = -ENOPROTOOPT;
+                break;
+        }
+
+        return err;
+}
+
+/* Main setsockopt() entry point.
+ * Does API checks, then calls either the tunnel or session setsockopt
+ * handler, according to whether the PPPoL2TP socket is a for a regular
+ * session or the special tunnel type.
+ */
+static int pppol2tp_setsockopt(struct socket *sock, int level, int optname,
+                               char __user *optval, unsigned int optlen)
+{
+        struct sock *sk = sock->sk;
+        struct l2tp_session *session;
+        struct l2tp_tunnel *tunnel;
+        struct pppol2tp_session *ps;
+        int val;
+        int err;
+
+        if (level != SOL_PPPOL2TP)
+                return udp_prot.setsockopt(sk, level, optname, optval, optlen);
+
+        if (optlen < sizeof(int))
+                return -EINVAL;
+
+        if (get_user(val, (int __user *)optval))
+                return -EFAULT;
+
+        err = -ENOTCONN;
+        if (sk->sk_user_data == NULL)
+                goto end;
+
+        /* Get session context from the socket */
+        err = -EBADF;
+        session = pppol2tp_sock_to_session(sk);
+        if (session == NULL)
+                goto end;
+
+        /* Special case: if session_id == 0x0000, treat as operation on tunnel
+         */
+        ps = l2tp_session_priv(session);
+        if ((session->session_id == 0) &&
+            (session->peer_session_id == 0)) {
+                err = -EBADF;
+                tunnel = l2tp_sock_to_tunnel(ps->tunnel_sock);
+                if (tunnel == NULL)
+                        goto end_put_sess;
+
+                err = pppol2tp_tunnel_setsockopt(sk, tunnel, optname, val);
+                sock_put(ps->tunnel_sock);
+        } else
+                err = pppol2tp_session_setsockopt(sk, session, optname, val);
+
+        err = 0;
+
+end_put_sess:
+        sock_put(sk);
+end:
+        return err;
+}
+
+/* Tunnel getsockopt helper. Called with sock locked.
+ */
+static int pppol2tp_tunnel_getsockopt(struct sock *sk,
+                                      struct l2tp_tunnel *tunnel,
+                                      int optname, int *val)
+{
+        int err = 0;
+
+        switch (optname) {
+        case PPPOL2TP_SO_DEBUG:
+                *val = tunnel->debug;
+                PRINTK(tunnel->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
+                       "%s: get debug=%x\n", tunnel->name, tunnel->debug);
+                break;
+
+        default:
+                err = -ENOPROTOOPT;
+                break;
+        }
+
+        return err;
+}
+
+/* Session getsockopt helper. Called with sock locked.
+ */
+static int pppol2tp_session_getsockopt(struct sock *sk,
+                                       struct l2tp_session *session,
+                                       int optname, int *val)
+{
+        int err = 0;
+
+        switch (optname) {
+        case PPPOL2TP_SO_RECVSEQ:
+                *val = session->recv_seq;
+                PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
+                       "%s: get recv_seq=%d\n", session->name, *val);
+                break;
+
+        case PPPOL2TP_SO_SENDSEQ:
+                *val = session->send_seq;
+                PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
+                       "%s: get send_seq=%d\n", session->name, *val);
+                break;
+
+        case PPPOL2TP_SO_LNSMODE:
+                *val = session->lns_mode;
+                PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
+                       "%s: get lns_mode=%d\n", session->name, *val);
+                break;
+
+        case PPPOL2TP_SO_DEBUG:
+                *val = session->debug;
+                PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
+                       "%s: get debug=%d\n", session->name, *val);
+                break;
+
+        case PPPOL2TP_SO_REORDERTO:
+                *val = (int) jiffies_to_msecs(session->reorder_timeout);
+                PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
+                       "%s: get reorder_timeout=%d\n", session->name, *val);
+                break;
+
+        default:
+                err = -ENOPROTOOPT;
+        }
+
+        return err;
+}
+
+/* Main getsockopt() entry point.
+ * Does API checks, then calls either the tunnel or session getsockopt
+ * handler, according to whether the PPPoX socket is a for a regular session
+ * or the special tunnel type.
+ */
+static int pppol2tp_getsockopt(struct socket *sock, int level,
+                               int optname, char __user *optval, int __user *optlen)
+{
+        struct sock *sk = sock->sk;
+        struct l2tp_session *session;
+        struct l2tp_tunnel *tunnel;
+        int val, len;
+        int err;
+        struct pppol2tp_session *ps;
+
+        if (level != SOL_PPPOL2TP)
+                return udp_prot.getsockopt(sk, level, optname, optval, optlen);
+
+        if (get_user(len, (int __user *) optlen))
+                return -EFAULT;
+
+        len = min_t(unsigned int, len, sizeof(int));
+
+        if (len < 0)
+                return -EINVAL;
+
+        err = -ENOTCONN;
+        if (sk->sk_user_data == NULL)
+                goto end;
+
+        /* Get the session context */
+        err = -EBADF;
+        session = pppol2tp_sock_to_session(sk);
+        if (session == NULL)
+                goto end;
+
+        /* Special case: if session_id == 0x0000, treat as operation on tunnel */
+        ps = l2tp_session_priv(session);
+        if ((session->session_id == 0) &&
+            (session->peer_session_id == 0)) {
+                err = -EBADF;
+                tunnel = l2tp_sock_to_tunnel(ps->tunnel_sock);
+                if (tunnel == NULL)
+                        goto end_put_sess;
+
+                err = pppol2tp_tunnel_getsockopt(sk, tunnel, optname, &val);
+                sock_put(ps->tunnel_sock);
+        } else
+                err = pppol2tp_session_getsockopt(sk, session, optname, &val);
+
+        err = -EFAULT;
+        if (put_user(len, (int __user *) optlen))
+                goto end_put_sess;
+
+        if (copy_to_user((void __user *) optval, &val, len))
+                goto end_put_sess;
+
+        err = 0;
+
+end_put_sess:
+        sock_put(sk);
+end:
+        return err;
+}
+
+/*****************************************************************************
+ * /proc filesystem for debug
+ * Since the original pppol2tp driver provided /proc/net/pppol2tp for
+ * L2TPv2, we dump only L2TPv2 tunnels and sessions here.
+ *****************************************************************************/
+
+static unsigned int pppol2tp_net_id;
+
+#ifdef CONFIG_PROC_FS
+
+struct pppol2tp_seq_data {
+        struct seq_net_private p;
+        int tunnel_idx;                 /* current tunnel */
+        int session_idx;                /* index of session within current tunnel */
+        struct l2tp_tunnel *tunnel;
+        struct l2tp_session *session;   /* NULL means get next tunnel */
+};
+
+static void pppol2tp_next_tunnel(struct net *net, struct pppol2tp_seq_data *pd)
+{
+        for (;;) {
+                pd->tunnel = l2tp_tunnel_find_nth(net, pd->tunnel_idx);
+                pd->tunnel_idx++;
+
+                if (pd->tunnel == NULL)
+                        break;
+
+                /* Ignore L2TPv3 tunnels */
+                if (pd->tunnel->version < 3)
+                        break;
+        }
+}
+
+static void pppol2tp_next_session(struct net *net, struct pppol2tp_seq_data *pd)
+{
+        pd->session = l2tp_session_find_nth(pd->tunnel, pd->session_idx);
+        pd->session_idx++;
+
+        if (pd->session == NULL) {
+                pd->session_idx = 0;
+                pppol2tp_next_tunnel(net, pd);
+        }
+}
+
+static void *pppol2tp_seq_start(struct seq_file *m, loff_t *offs)
+{
+        struct pppol2tp_seq_data *pd = SEQ_START_TOKEN;
+        loff_t pos = *offs;
+        struct net *net;
+
+        if (!pos)
+                goto out;
+
+        BUG_ON(m->private == NULL);
+        pd = m->private;
+        net = seq_file_net(m);
+
+        if (pd->tunnel == NULL)
+                pppol2tp_next_tunnel(net, pd);
+        else
+                pppol2tp_next_session(net, pd);
+
+        /* NULL tunnel and session indicates end of list */
+        if ((pd->tunnel == NULL) && (pd->session == NULL))
+                pd = NULL;
+
+out:
+        return pd;
+}
+
+static void *pppol2tp_seq_next(struct seq_file *m, void *v, loff_t *pos)
+{
+        (*pos)++;
+        return NULL;
+}
+
+static void pppol2tp_seq_stop(struct seq_file *p, void *v)
+{
+        /* nothing to do */
+}
+
+static void pppol2tp_seq_tunnel_show(struct seq_file *m, void *v)
+{
+        struct l2tp_tunnel *tunnel = v;
+
+        seq_printf(m, "\nTUNNEL '%s', %c %d\n",
+                   tunnel->name,
+                   (tunnel == tunnel->sock->sk_user_data) ? 'Y' : 'N',
+                   atomic_read(&tunnel->ref_count) - 1);
+        seq_printf(m, " %08x %llu/%llu/%llu %llu/%llu/%llu\n",
+                   tunnel->debug,
+                   (unsigned long long)tunnel->stats.tx_packets,
+                   (unsigned long long)tunnel->stats.tx_bytes,
+                   (unsigned long long)tunnel->stats.tx_errors,
+                   (unsigned long long)tunnel->stats.rx_packets,
+                   (unsigned long long)tunnel->stats.rx_bytes,
+                   (unsigned long long)tunnel->stats.rx_errors);
+}
+
+static void pppol2tp_seq_session_show(struct seq_file *m, void *v)
+{
+        struct l2tp_session *session = v;
+        struct l2tp_tunnel *tunnel = session->tunnel;
+        struct pppol2tp_session *ps = l2tp_session_priv(session);
+        struct pppox_sock *po = pppox_sk(ps->sock);
+        u32 ip = 0;
+        u16 port = 0;
+
+        if (tunnel->sock) {
+                struct inet_sock *inet = inet_sk(tunnel->sock);
+                ip = ntohl(inet->inet_saddr);
+                port = ntohs(inet->inet_sport);
+        }
+
+        seq_printf(m, "  SESSION '%s' %08X/%d %04X/%04X -> "
+                   "%04X/%04X %d %c\n",
+                   session->name, ip, port,
+                   tunnel->tunnel_id,
+                   session->session_id,
+                   tunnel->peer_tunnel_id,
+                   session->peer_session_id,
+                   ps->sock->sk_state,
+                   (session == ps->sock->sk_user_data) ?
+                   'Y' : 'N');
+        seq_printf(m, "   %d/%d/%c/%c/%s %08x %u\n",
+                   session->mtu, session->mru,
+                   session->recv_seq ? 'R' : '-',
+                   session->send_seq ? 'S' : '-',
+                   session->lns_mode ? "LNS" : "LAC",
+                   session->debug,
+                   jiffies_to_msecs(session->reorder_timeout));
+        seq_printf(m, "   %hu/%hu %llu/%llu/%llu %llu/%llu/%llu\n",
+                   session->nr, session->ns,
+                   (unsigned long long)session->stats.tx_packets,
+                   (unsigned long long)session->stats.tx_bytes,
+                   (unsigned long long)session->stats.tx_errors,
+                   (unsigned long long)session->stats.rx_packets,
+                   (unsigned long long)session->stats.rx_bytes,
+                   (unsigned long long)session->stats.rx_errors);
+
+        if (po)
+                seq_printf(m, "   interface %s\n", ppp_dev_name(&po->chan));
+}
+
+static int pppol2tp_seq_show(struct seq_file *m, void *v)
+{
+        struct pppol2tp_seq_data *pd = v;
+
+        /* display header on line 1 */
+        if (v == SEQ_START_TOKEN) {
+                seq_puts(m, "PPPoL2TP driver info, " PPPOL2TP_DRV_VERSION "\n");
+                seq_puts(m, "TUNNEL name, user-data-ok session-count\n");
+                seq_puts(m, " debug tx-pkts/bytes/errs rx-pkts/bytes/errs\n");
+                seq_puts(m, "  SESSION name, addr/port src-tid/sid "
+                         "dest-tid/sid state user-data-ok\n");
+                seq_puts(m, "   mtu/mru/rcvseq/sendseq/lns debug reorderto\n");
+                seq_puts(m, "   nr/ns tx-pkts/bytes/errs rx-pkts/bytes/errs\n");
+                goto out;
+        }
+
+        /* Show the tunnel or session context.
+         */
+        if (pd->session == NULL)
+                pppol2tp_seq_tunnel_show(m, pd->tunnel);
+        else
+                pppol2tp_seq_session_show(m, pd->session);
+
+out:
+        return 0;
+}
+
+static const struct seq_operations pppol2tp_seq_ops = {
+        .start          = pppol2tp_seq_start,
+        .next           = pppol2tp_seq_next,
+        .stop           = pppol2tp_seq_stop,
+        .show           = pppol2tp_seq_show,
+};
+
+/* Called when our /proc file is opened. We allocate data for use when
+ * iterating our tunnel / session contexts and store it in the private
+ * data of the seq_file.
+ */
+static int pppol2tp_proc_open(struct inode *inode, struct file *file)
+{
+        return seq_open_net(inode, file, &pppol2tp_seq_ops,
+                            sizeof(struct pppol2tp_seq_data));
+}
+
+static const struct file_operations pppol2tp_proc_fops = {
+        .owner          = THIS_MODULE,
+        .open           = pppol2tp_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = seq_release_net,
+};
+
+#endif /* CONFIG_PROC_FS */
+
+/*****************************************************************************
+ * Network namespace
+ *****************************************************************************/
+
+static __net_init int pppol2tp_init_net(struct net *net)
+{
+        struct proc_dir_entry *pde;
+        int err = 0;
+
+        pde = proc_net_fops_create(net, "pppol2tp", S_IRUGO, &pppol2tp_proc_fops);
+        if (!pde) {
+                err = -ENOMEM;
+                goto out;
+        }
+
+out:
+        return err;
+}
+
+static __net_exit void pppol2tp_exit_net(struct net *net)
+{
+        proc_net_remove(net, "pppol2tp");
+}
+
+static struct pernet_operations pppol2tp_net_ops = {
+        .init = pppol2tp_init_net,
+        .exit = pppol2tp_exit_net,
+        .id   = &pppol2tp_net_id,
+};
+
+/*****************************************************************************
+ * Init and cleanup
+ *****************************************************************************/
+
+static const struct proto_ops pppol2tp_ops = {
+        .family         = AF_PPPOX,
+        .owner          = THIS_MODULE,
+        .release        = pppol2tp_release,
+        .bind           = sock_no_bind,
+        .connect        = pppol2tp_connect,
+        .socketpair     = sock_no_socketpair,
+        .accept         = sock_no_accept,
+        .getname        = pppol2tp_getname,
+        .poll           = datagram_poll,
+        .listen         = sock_no_listen,
+        .shutdown       = sock_no_shutdown,
+        .setsockopt     = pppol2tp_setsockopt,
+        .getsockopt     = pppol2tp_getsockopt,
+        .sendmsg        = pppol2tp_sendmsg,
+        .recvmsg        = pppol2tp_recvmsg,
+        .mmap           = sock_no_mmap,
+        .ioctl          = pppox_ioctl,
+};
+
+static struct pppox_proto pppol2tp_proto = {
+        .create         = pppol2tp_create,
+        .ioctl          = pppol2tp_ioctl
+};
+
+#ifdef CONFIG_L2TP_V3
+
+static const struct l2tp_nl_cmd_ops pppol2tp_nl_cmd_ops = {
+        .session_create = pppol2tp_session_create,
+        .session_delete = pppol2tp_session_delete,
+};
+
+#endif /* CONFIG_L2TP_V3 */
+
+static int __init pppol2tp_init(void)
+{
+        int err;
+
+        err = register_pernet_device(&pppol2tp_net_ops);
+        if (err)
+                goto out;
+
+        err = proto_register(&pppol2tp_sk_proto, 0);
+        if (err)
+                goto out_unregister_pppol2tp_pernet;
+
+        err = register_pppox_proto(PX_PROTO_OL2TP, &pppol2tp_proto);
+        if (err)
+                goto out_unregister_pppol2tp_proto;
+
+#ifdef CONFIG_L2TP_V3
+        err = l2tp_nl_register_ops(L2TP_PWTYPE_PPP, &pppol2tp_nl_cmd_ops);
+        if (err)
+                goto out_unregister_pppox;
+#endif
+
+        printk(KERN_INFO "PPPoL2TP kernel driver, %s\n",
+               PPPOL2TP_DRV_VERSION);
+
+out:
+        return err;
+
+#ifdef CONFIG_L2TP_V3
+out_unregister_pppox:
+        unregister_pppox_proto(PX_PROTO_OL2TP);
+#endif
+out_unregister_pppol2tp_proto:
+        proto_unregister(&pppol2tp_sk_proto);
+out_unregister_pppol2tp_pernet:
+        unregister_pernet_device(&pppol2tp_net_ops);
+        goto out;
+}
+
+static void __exit pppol2tp_exit(void)
+{
+#ifdef CONFIG_L2TP_V3
+        l2tp_nl_unregister_ops(L2TP_PWTYPE_PPP);
+#endif
+        unregister_pppox_proto(PX_PROTO_OL2TP);
+        proto_unregister(&pppol2tp_sk_proto);
+        unregister_pernet_device(&pppol2tp_net_ops);
+}
+
+module_init(pppol2tp_init);
+module_exit(pppol2tp_exit);
+
+MODULE_AUTHOR("James Chapman <jchapman@katalix.com>");
+MODULE_DESCRIPTION("PPP over L2TP over UDP");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(PPPOL2TP_DRV_VERSION);
diff --git a/net/lapb/lapb_iface.c b/net/lapb/lapb_iface.c
index bda96d18fd98..d5d8d555c410 100644
--- a/net/lapb/lapb_iface.c
+++ b/net/lapb/lapb_iface.c
@@ -29,6 +29,7 @@
 #include <linux/inet.h>
 #include <linux/if_arp.h>
 #include <linux/skbuff.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 #include <asm/uaccess.h>
 #include <asm/system.h>
diff --git a/net/lapb/lapb_in.c b/net/lapb/lapb_in.c
index 6762e7c751eb..21904a002449 100644
--- a/net/lapb/lapb_in.c
+++ b/net/lapb/lapb_in.c
@@ -27,6 +27,7 @@
 #include <linux/inet.h>
 #include <linux/netdevice.h>
 #include <linux/skbuff.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 #include <asm/uaccess.h>
 #include <asm/system.h>
diff --git a/net/lapb/lapb_out.c b/net/lapb/lapb_out.c
index 339cc5f2684f..c75a79540f9f 100644
--- a/net/lapb/lapb_out.c
+++ b/net/lapb/lapb_out.c
@@ -25,6 +25,7 @@
 #include <linux/net.h>
 #include <linux/inet.h>
 #include <linux/skbuff.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 #include <asm/uaccess.h>
 #include <asm/system.h>
diff --git a/net/lapb/lapb_subr.c b/net/lapb/lapb_subr.c
index b827f47ac133..43a2a7fb327b 100644
--- a/net/lapb/lapb_subr.c
+++ b/net/lapb/lapb_subr.c
@@ -24,6 +24,7 @@
 #include <linux/net.h>
 #include <linux/inet.h>
 #include <linux/skbuff.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 #include <asm/uaccess.h>
 #include <asm/system.h>
diff --git a/net/llc/af_llc.c b/net/llc/af_llc.c
index e35d907fba2c..023ba820236f 100644
--- a/net/llc/af_llc.c
+++ b/net/llc/af_llc.c
@@ -25,6 +25,7 @@
 #include <linux/module.h>
 #include <linux/rtnetlink.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <net/llc.h>
 #include <net/llc_sap.h>
 #include <net/llc_pdu.h>
@@ -535,7 +536,7 @@ static int llc_ui_wait_for_disc(struct sock *sk, long timeout)
         int rc = 0;
 
         while (1) {
-                prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+                prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
                 if (sk_wait_event(sk, &timeout, sk->sk_state == TCP_CLOSE))
                         break;
                 rc = -ERESTARTSYS;
@@ -546,7 +547,7 @@ static int llc_ui_wait_for_disc(struct sock *sk, long timeout)
                         break;
                 rc = 0;
         }
-        finish_wait(sk->sk_sleep, &wait);
+        finish_wait(sk_sleep(sk), &wait);
         return rc;
 }
 
@@ -555,13 +556,13 @@ static int llc_ui_wait_for_conn(struct sock *sk, long timeout)
         DEFINE_WAIT(wait);
 
         while (1) {
-                prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+                prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
                 if (sk_wait_event(sk, &timeout, sk->sk_state != TCP_SYN_SENT))
                         break;
                 if (signal_pending(current) || !timeout)
                         break;
         }
-        finish_wait(sk->sk_sleep, &wait);
+        finish_wait(sk_sleep(sk), &wait);
         return timeout;
 }
 
@@ -572,7 +573,7 @@ static int llc_ui_wait_for_busy_core(struct sock *sk, long timeout)
         int rc;
 
         while (1) {
-                prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+                prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
                 rc = 0;
                 if (sk_wait_event(sk, &timeout,
                                   (sk->sk_shutdown & RCV_SHUTDOWN) ||
@@ -587,7 +588,7 @@ static int llc_ui_wait_for_busy_core(struct sock *sk, long timeout)
                 if (!timeout)
                         break;
         }
-        finish_wait(sk->sk_sleep, &wait);
+        finish_wait(sk_sleep(sk), &wait);
         return rc;
 }
 
diff --git a/net/llc/llc_c_ac.c b/net/llc/llc_c_ac.c
index 86d6985b9d49..ea225bd2672c 100644
--- a/net/llc/llc_c_ac.c
+++ b/net/llc/llc_c_ac.c
@@ -18,6 +18,7 @@
  * See the GNU General Public License for more details.
  */
 #include <linux/netdevice.h>
+#include <linux/slab.h>
 #include <net/llc_conn.h>
 #include <net/llc_sap.h>
 #include <net/sock.h>
diff --git a/net/llc/llc_conn.c b/net/llc/llc_conn.c
index a12144da7974..ba137a6a224d 100644
--- a/net/llc/llc_conn.c
+++ b/net/llc/llc_conn.c
@@ -13,6 +13,7 @@
  */
 
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <net/llc_sap.h>
 #include <net/llc_conn.h>
 #include <net/sock.h>
diff --git a/net/llc/llc_core.c b/net/llc/llc_core.c
index 78167e81dfeb..2bb0ddff8c0f 100644
--- a/net/llc/llc_core.c
+++ b/net/llc/llc_core.c
@@ -144,12 +144,6 @@ static struct packet_type llc_tr_packet_type __read_mostly = {
 
 static int __init llc_init(void)
 {
-        struct net_device *dev;
-
-        dev = first_net_device(&init_net);
-        if (dev != NULL)
-                dev = next_net_device(dev);
-
         dev_add_pack(&llc_packet_type);
         dev_add_pack(&llc_tr_packet_type);
         return 0;
diff --git a/net/llc/llc_if.c b/net/llc/llc_if.c
index a89917130a7b..25c31c0a3fdb 100644
--- a/net/llc/llc_if.c
+++ b/net/llc/llc_if.c
@@ -11,6 +11,7 @@
  *
  * See the GNU General Public License for more details.
  */
+#include <linux/gfp.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/netdevice.h>
diff --git a/net/llc/llc_input.c b/net/llc/llc_input.c
index 57ad974e4d94..f99687439139 100644
--- a/net/llc/llc_input.c
+++ b/net/llc/llc_input.c
@@ -12,6 +12,7 @@
  * See the GNU General Public License for more details.
  */
 #include <linux/netdevice.h>
+#include <linux/slab.h>
 #include <net/net_namespace.h>
 #include <net/llc.h>
 #include <net/llc_pdu.h>
diff --git a/net/llc/llc_sap.c b/net/llc/llc_sap.c
index ad6e6e1cf22f..a432f0ec051c 100644
--- a/net/llc/llc_sap.c
+++ b/net/llc/llc_sap.c
@@ -23,6 +23,7 @@
 #include <net/sock.h>
 #include <net/tcp_states.h>
 #include <linux/llc.h>
+#include <linux/slab.h>
 
 static int llc_mac_header_len(unsigned short devtype)
 {
diff --git a/net/llc/llc_station.c b/net/llc/llc_station.c
index 83da13339490..e4dae0244d76 100644
--- a/net/llc/llc_station.c
+++ b/net/llc/llc_station.c
@@ -13,6 +13,7 @@
  */
 #include <linux/init.h>
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <net/llc.h>
 #include <net/llc_sap.h>
 #include <net/llc_conn.h>
diff --git a/net/mac80211/agg-rx.c b/net/mac80211/agg-rx.c
index 1771dd9bd137..6bb9a9a94960 100644
--- a/net/mac80211/agg-rx.c
+++ b/net/mac80211/agg-rx.c
@@ -14,6 +14,7 @@
  */
 
 #include <linux/ieee80211.h>
+#include <linux/slab.h>
 #include <net/mac80211.h>
 #include "ieee80211_i.h"
 #include "driver-ops.h"
diff --git a/net/mac80211/agg-tx.c b/net/mac80211/agg-tx.c
index 2b6a0c47ed53..c163d0a149f4 100644
--- a/net/mac80211/agg-tx.c
+++ b/net/mac80211/agg-tx.c
@@ -14,6 +14,7 @@
  */
 
 #include <linux/ieee80211.h>
+#include <linux/slab.h>
 #include <net/mac80211.h>
 #include "ieee80211_i.h"
 #include "driver-ops.h"
diff --git a/net/mac80211/cfg.c b/net/mac80211/cfg.c
index b575a5066219..ae37270a0633 100644
--- a/net/mac80211/cfg.c
+++ b/net/mac80211/cfg.c
@@ -9,6 +9,7 @@
 #include <linux/ieee80211.h>
 #include <linux/nl80211.h>
 #include <linux/rtnetlink.h>
+#include <linux/slab.h>
 #include <net/net_namespace.h>
 #include <linux/rcupdate.h>
 #include <net/cfg80211.h>
diff --git a/net/mac80211/debugfs_key.c b/net/mac80211/debugfs_key.c
index d12e743cb4e1..97c9e46e859e 100644
--- a/net/mac80211/debugfs_key.c
+++ b/net/mac80211/debugfs_key.c
@@ -9,6 +9,7 @@
  */
 
 #include <linux/kobject.h>
+#include <linux/slab.h>
 #include "ieee80211_i.h"
 #include "key.h"
 #include "debugfs.h"
diff --git a/net/mac80211/debugfs_netdev.c b/net/mac80211/debugfs_netdev.c
index 623e6644b80c..20b2998fa0ed 100644
--- a/net/mac80211/debugfs_netdev.c
+++ b/net/mac80211/debugfs_netdev.c
@@ -13,6 +13,7 @@
 #include <linux/interrupt.h>
 #include <linux/netdevice.h>
 #include <linux/rtnetlink.h>
+#include <linux/slab.h>
 #include <linux/notifier.h>
 #include <net/mac80211.h>
 #include <net/cfg80211.h>
diff --git a/net/mac80211/driver-ops.h b/net/mac80211/driver-ops.h
index 997008e236ff..ee8b63f92f71 100644
--- a/net/mac80211/driver-ops.h
+++ b/net/mac80211/driver-ops.h
@@ -84,16 +84,14 @@ static inline void drv_bss_info_changed(struct ieee80211_local *local,
 }
 
 static inline u64 drv_prepare_multicast(struct ieee80211_local *local,
-                                        int mc_count,
-                                        struct dev_addr_list *mc_list)
+                                        struct netdev_hw_addr_list *mc_list)
 {
         u64 ret = 0;
 
         if (local->ops->prepare_multicast)
-                ret = local->ops->prepare_multicast(&local->hw, mc_count,
-                                                    mc_list);
+                ret = local->ops->prepare_multicast(&local->hw, mc_list);
 
-        trace_drv_prepare_multicast(local, mc_count, ret);
+        trace_drv_prepare_multicast(local, mc_list->count, ret);
 
         return ret;
 }
diff --git a/net/mac80211/ibss.c b/net/mac80211/ibss.c
index d5855ae387e8..b72ee6435fa3 100644
--- a/net/mac80211/ibss.c
+++ b/net/mac80211/ibss.c
@@ -13,6 +13,7 @@
  */
 
 #include <linux/delay.h>
+#include <linux/slab.h>
 #include <linux/if_ether.h>
 #include <linux/skbuff.h>
 #include <linux/if_arp.h>
diff --git a/net/mac80211/ieee80211_i.h b/net/mac80211/ieee80211_i.h
index c8077a3647c6..cbaf4981e110 100644
--- a/net/mac80211/ieee80211_i.h
+++ b/net/mac80211/ieee80211_i.h
@@ -665,8 +665,7 @@ struct ieee80211_local {
         struct work_struct recalc_smps;
 
         /* aggregated multicast list */
-        struct dev_addr_list *mc_list;
-        int mc_count;
+        struct netdev_hw_addr_list mc_list;
 
         bool tim_in_locked_section; /* see ieee80211_beacon_get() */
 
diff --git a/net/mac80211/iface.c b/net/mac80211/iface.c
index b4ec59a8dc03..50deb017fd6e 100644
--- a/net/mac80211/iface.c
+++ b/net/mac80211/iface.c
@@ -10,6 +10,7 @@
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
+#include <linux/slab.h>
 #include <linux/kernel.h>
 #include <linux/if_arp.h>
 #include <linux/netdevice.h>
@@ -412,8 +413,7 @@ static int ieee80211_stop(struct net_device *dev)
 
         netif_addr_lock_bh(dev);
         spin_lock_bh(&local->filter_lock);
-        __dev_addr_unsync(&local->mc_list, &local->mc_count,
-                          &dev->mc_list, &dev->mc_count);
+        __hw_addr_unsync(&local->mc_list, &dev->mc, dev->addr_len);
         spin_unlock_bh(&local->filter_lock);
         netif_addr_unlock_bh(dev);
 
@@ -596,8 +596,7 @@ static void ieee80211_set_multicast_list(struct net_device *dev)
                 sdata->flags ^= IEEE80211_SDATA_PROMISC;
         }
         spin_lock_bh(&local->filter_lock);
-        __dev_addr_sync(&local->mc_list, &local->mc_count,
-                        &dev->mc_list, &dev->mc_count);
+        __hw_addr_sync(&local->mc_list, &dev->mc, dev->addr_len);
         spin_unlock_bh(&local->filter_lock);
         ieee80211_queue_work(&local->hw, &local->reconfig_filter);
 }
diff --git a/net/mac80211/key.c b/net/mac80211/key.c
index 75705bd41956..8d4b41787dcf 100644
--- a/net/mac80211/key.c
+++ b/net/mac80211/key.c
@@ -14,6 +14,7 @@
 #include <linux/list.h>
 #include <linux/rcupdate.h>
 #include <linux/rtnetlink.h>
+#include <linux/slab.h>
 #include <net/mac80211.h>
 #include "ieee80211_i.h"
 #include "driver-ops.h"
diff --git a/net/mac80211/led.c b/net/mac80211/led.c
index 162a643f16b6..063aad944246 100644
--- a/net/mac80211/led.c
+++ b/net/mac80211/led.c
@@ -8,6 +8,7 @@
 
 /* just for IFNAMSIZ */
 #include <linux/if.h>
+#include <linux/slab.h>
 #include "led.h"
 
 void ieee80211_led_rx(struct ieee80211_local *local)
diff --git a/net/mac80211/main.c b/net/mac80211/main.c
index 353b6b42d9c5..bd632e1ee2c5 100644
--- a/net/mac80211/main.c
+++ b/net/mac80211/main.c
@@ -71,7 +71,7 @@ void ieee80211_configure_filter(struct ieee80211_local *local)
         spin_lock_bh(&local->filter_lock);
         changed_flags = local->filter_flags ^ new_flags;
 
-        mc = drv_prepare_multicast(local, local->mc_count, local->mc_list);
+        mc = drv_prepare_multicast(local, &local->mc_list);
         spin_unlock_bh(&local->filter_lock);
 
         /* be a bit nasty */
@@ -390,6 +390,9 @@ struct ieee80211_hw *ieee80211_alloc_hw(size_t priv_data_len,
         local->uapsd_max_sp_len = IEEE80211_DEFAULT_MAX_SP_LEN;
 
         INIT_LIST_HEAD(&local->interfaces);
+
+        __hw_addr_init(&local->mc_list);
+
         mutex_init(&local->iflist_mtx);
         mutex_init(&local->scan_mtx);
 
diff --git a/net/mac80211/mesh.c b/net/mac80211/mesh.c
index 2669fbf8c812..7e93524459fc 100644
--- a/net/mac80211/mesh.c
+++ b/net/mac80211/mesh.c
@@ -8,6 +8,7 @@
  * published by the Free Software Foundation.
  */
 
+#include <linux/slab.h>
 #include <asm/unaligned.h>
 #include "ieee80211_i.h"
 #include "mesh.h"
diff --git a/net/mac80211/mesh_hwmp.c b/net/mac80211/mesh_hwmp.c
index 36141d6e701b..d89ed7f2592b 100644
--- a/net/mac80211/mesh_hwmp.c
+++ b/net/mac80211/mesh_hwmp.c
@@ -7,6 +7,7 @@
  * published by the Free Software Foundation.
  */
 
+#include <linux/slab.h>
 #include "mesh.h"
 
 #ifdef CONFIG_MAC80211_VERBOSE_MHWMP_DEBUG
diff --git a/net/mac80211/mesh_pathtbl.c b/net/mac80211/mesh_pathtbl.c
index 2312efe04c62..181ffd6efd81 100644
--- a/net/mac80211/mesh_pathtbl.c
+++ b/net/mac80211/mesh_pathtbl.c
@@ -10,6 +10,7 @@
 #include <linux/etherdevice.h>
 #include <linux/list.h>
 #include <linux/random.h>
+#include <linux/slab.h>
 #include <linux/spinlock.h>
 #include <linux/string.h>
 #include <net/mac80211.h>
diff --git a/net/mac80211/mesh_plink.c b/net/mac80211/mesh_plink.c
index c384154ac895..3cd5f7b5d693 100644
--- a/net/mac80211/mesh_plink.c
+++ b/net/mac80211/mesh_plink.c
@@ -6,6 +6,7 @@
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
+#include <linux/gfp.h>
 #include <linux/kernel.h>
 #include <linux/random.h>
 #include "ieee80211_i.h"
@@ -744,7 +745,7 @@ void mesh_rx_plink_frame(struct ieee80211_sub_if_data *sdata, struct ieee80211_m
                 break;
         default:
                 /* should not get here, PLINK_BLOCKED is dealt with at the
-                 * beggining of the function
+                 * beginning of the function
                  */
                 spin_unlock_bh(&sta->lock);
                 break;
diff --git a/net/mac80211/mlme.c b/net/mac80211/mlme.c
index 17cb8ae912bc..358226f63b81 100644
--- a/net/mac80211/mlme.c
+++ b/net/mac80211/mlme.c
@@ -19,6 +19,7 @@
 #include <linux/rtnetlink.h>
 #include <linux/pm_qos_params.h>
 #include <linux/crc32.h>
+#include <linux/slab.h>
 #include <net/mac80211.h>
 #include <asm/unaligned.h>
 
diff --git a/net/mac80211/rate.c b/net/mac80211/rate.c
index 0b299d236fa1..6d0bd198af19 100644
--- a/net/mac80211/rate.c
+++ b/net/mac80211/rate.c
@@ -10,6 +10,7 @@
 
 #include <linux/kernel.h>
 #include <linux/rtnetlink.h>
+#include <linux/slab.h>
 #include "rate.h"
 #include "ieee80211_i.h"
 #include "debugfs.h"
diff --git a/net/mac80211/rc80211_minstrel.c b/net/mac80211/rc80211_minstrel.c
index 4926d929fd9f..f65ce6dcc8e2 100644
--- a/net/mac80211/rc80211_minstrel.c
+++ b/net/mac80211/rc80211_minstrel.c
@@ -50,6 +50,7 @@
 #include <linux/debugfs.h>
 #include <linux/random.h>
 #include <linux/ieee80211.h>
+#include <linux/slab.h>
 #include <net/mac80211.h>
 #include "rate.h"
 #include "rc80211_minstrel.h"
diff --git a/net/mac80211/rc80211_minstrel_debugfs.c b/net/mac80211/rc80211_minstrel_debugfs.c
index 56d0f24957d9..241e76f3fdf2 100644
--- a/net/mac80211/rc80211_minstrel_debugfs.c
+++ b/net/mac80211/rc80211_minstrel_debugfs.c
@@ -49,6 +49,7 @@
 #include <linux/skbuff.h>
 #include <linux/debugfs.h>
 #include <linux/ieee80211.h>
+#include <linux/slab.h>
 #include <net/mac80211.h>
 #include "rc80211_minstrel.h"
 
diff --git a/net/mac80211/rc80211_pid_algo.c b/net/mac80211/rc80211_pid_algo.c
index 2652a374974e..aeda65466f3e 100644
--- a/net/mac80211/rc80211_pid_algo.c
+++ b/net/mac80211/rc80211_pid_algo.c
@@ -13,6 +13,7 @@
 #include <linux/types.h>
 #include <linux/skbuff.h>
 #include <linux/debugfs.h>
+#include <linux/slab.h>
 #include <net/mac80211.h>
 #include "rate.h"
 #include "mesh.h"
diff --git a/net/mac80211/rc80211_pid_debugfs.c b/net/mac80211/rc80211_pid_debugfs.c
index 45667054a5f3..47438b4a9af5 100644
--- a/net/mac80211/rc80211_pid_debugfs.c
+++ b/net/mac80211/rc80211_pid_debugfs.c
@@ -12,6 +12,7 @@
 #include <linux/netdevice.h>
 #include <linux/types.h>
 #include <linux/skbuff.h>
+#include <linux/slab.h>
 
 #include <net/mac80211.h>
 #include "rate.h"
diff --git a/net/mac80211/rx.c b/net/mac80211/rx.c
index e4f325f68fd3..9a08f2c446c6 100644
--- a/net/mac80211/rx.c
+++ b/net/mac80211/rx.c
@@ -10,6 +10,7 @@
  */
 
 #include <linux/jiffies.h>
+#include <linux/slab.h>
 #include <linux/kernel.h>
 #include <linux/skbuff.h>
 #include <linux/netdevice.h>
diff --git a/net/mac80211/scan.c b/net/mac80211/scan.c
index 414651217b49..e14c44195ae9 100644
--- a/net/mac80211/scan.c
+++ b/net/mac80211/scan.c
@@ -16,6 +16,7 @@
 #include <linux/rtnetlink.h>
 #include <linux/pm_qos_params.h>
 #include <net/sch_generic.h>
+#include <linux/slab.h>
 #include <net/mac80211.h>
 
 #include "ieee80211_i.h"
diff --git a/net/mac80211/wep.c b/net/mac80211/wep.c
index 5d745f2d7236..5f3a4113bda1 100644
--- a/net/mac80211/wep.c
+++ b/net/mac80211/wep.c
@@ -17,6 +17,7 @@
 #include <linux/err.h>
 #include <linux/mm.h>
 #include <linux/scatterlist.h>
+#include <linux/slab.h>
 #include <asm/unaligned.h>
 
 #include <net/mac80211.h>
diff --git a/net/mac80211/work.c b/net/mac80211/work.c
index 4c7de72c27e7..3dd07600199d 100644
--- a/net/mac80211/work.c
+++ b/net/mac80211/work.c
@@ -19,6 +19,7 @@
 #include <linux/if_arp.h>
 #include <linux/etherdevice.h>
 #include <linux/crc32.h>
+#include <linux/slab.h>
 #include <net/mac80211.h>
 #include <asm/unaligned.h>
 
diff --git a/net/mac80211/wpa.c b/net/mac80211/wpa.c
index f4971cd45c64..0adbcc941ac9 100644
--- a/net/mac80211/wpa.c
+++ b/net/mac80211/wpa.c
@@ -9,10 +9,10 @@
 
 #include <linux/netdevice.h>
 #include <linux/types.h>
-#include <linux/slab.h>
 #include <linux/skbuff.h>
 #include <linux/compiler.h>
 #include <linux/ieee80211.h>
+#include <linux/gfp.h>
 #include <asm/unaligned.h>
 #include <net/mac80211.h>
 
diff --git a/net/netfilter/core.c b/net/netfilter/core.c
index 60ec4e4badaa..78b505d33bfb 100644
--- a/net/netfilter/core.c
+++ b/net/netfilter/core.c
@@ -19,6 +19,7 @@
 #include <linux/inetdevice.h>
 #include <linux/proc_fs.h>
 #include <linux/mutex.h>
+#include <linux/slab.h>
 #include <net/net_namespace.h>
 #include <net/sock.h>
 
diff --git a/net/netfilter/ipvs/ip_vs_app.c b/net/netfilter/ipvs/ip_vs_app.c
index 3c7e42735b60..1cb0e834f8ff 100644
--- a/net/netfilter/ipvs/ip_vs_app.c
+++ b/net/netfilter/ipvs/ip_vs_app.c
@@ -27,6 +27,7 @@
 #include <linux/in.h>
 #include <linux/ip.h>
 #include <linux/netfilter.h>
+#include <linux/slab.h>
 #include <net/net_namespace.h>
 #include <net/protocol.h>
 #include <net/tcp.h>
diff --git a/net/netfilter/ipvs/ip_vs_conn.c b/net/netfilter/ipvs/ip_vs_conn.c
index 60bb41a8d8d4..d8f7e8ef67b4 100644
--- a/net/netfilter/ipvs/ip_vs_conn.c
+++ b/net/netfilter/ipvs/ip_vs_conn.c
@@ -32,6 +32,7 @@
 #include <linux/module.h>
 #include <linux/vmalloc.h>
 #include <linux/proc_fs.h>              /* for proc_net_* */
+#include <linux/slab.h>
 #include <linux/seq_file.h>
 #include <linux/jhash.h>
 #include <linux/random.h>
diff --git a/net/netfilter/ipvs/ip_vs_core.c b/net/netfilter/ipvs/ip_vs_core.c
index 44590887a92c..1cd6e3fd058b 100644
--- a/net/netfilter/ipvs/ip_vs_core.c
+++ b/net/netfilter/ipvs/ip_vs_core.c
@@ -33,6 +33,7 @@
 #include <linux/tcp.h>
 #include <linux/sctp.h>
 #include <linux/icmp.h>
+#include <linux/slab.h>
 
 #include <net/ip.h>
 #include <net/tcp.h>
diff --git a/net/netfilter/ipvs/ip_vs_ctl.c b/net/netfilter/ipvs/ip_vs_ctl.c
index 7ee9c3426f44..36dc1d88c2fa 100644
--- a/net/netfilter/ipvs/ip_vs_ctl.c
+++ b/net/netfilter/ipvs/ip_vs_ctl.c
@@ -31,6 +31,7 @@
 #include <linux/workqueue.h>
 #include <linux/swap.h>
 #include <linux/seq_file.h>
+#include <linux/slab.h>
 
 #include <linux/netfilter.h>
 #include <linux/netfilter_ipv4.h>
diff --git a/net/netfilter/ipvs/ip_vs_dh.c b/net/netfilter/ipvs/ip_vs_dh.c
index fe3e18834b91..95fd0d14200b 100644
--- a/net/netfilter/ipvs/ip_vs_dh.c
+++ b/net/netfilter/ipvs/ip_vs_dh.c
@@ -39,6 +39,7 @@
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 
 #include <linux/ip.h>
+#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/skbuff.h>
diff --git a/net/netfilter/ipvs/ip_vs_est.c b/net/netfilter/ipvs/ip_vs_est.c
index 702b53ca937c..ff28801962e0 100644
--- a/net/netfilter/ipvs/ip_vs_est.c
+++ b/net/netfilter/ipvs/ip_vs_est.c
@@ -17,7 +17,6 @@
 
 #include <linux/kernel.h>
 #include <linux/jiffies.h>
-#include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/interrupt.h>
 #include <linux/sysctl.h>
diff --git a/net/netfilter/ipvs/ip_vs_ftp.c b/net/netfilter/ipvs/ip_vs_ftp.c
index 73f38ea98f25..2c7f185dfae4 100644
--- a/net/netfilter/ipvs/ip_vs_ftp.c
+++ b/net/netfilter/ipvs/ip_vs_ftp.c
@@ -32,6 +32,7 @@
 #include <linux/in.h>
 #include <linux/ip.h>
 #include <linux/netfilter.h>
+#include <linux/gfp.h>
 #include <net/protocol.h>
 #include <net/tcp.h>
 #include <asm/unaligned.h>
diff --git a/net/netfilter/ipvs/ip_vs_lblc.c b/net/netfilter/ipvs/ip_vs_lblc.c
index 1b9370db2305..94a45213faa6 100644
--- a/net/netfilter/ipvs/ip_vs_lblc.c
+++ b/net/netfilter/ipvs/ip_vs_lblc.c
@@ -43,6 +43,7 @@
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 
 #include <linux/ip.h>
+#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/skbuff.h>
diff --git a/net/netfilter/ipvs/ip_vs_lblcr.c b/net/netfilter/ipvs/ip_vs_lblcr.c
index caa58fa1438a..535dc2b419d8 100644
--- a/net/netfilter/ipvs/ip_vs_lblcr.c
+++ b/net/netfilter/ipvs/ip_vs_lblcr.c
@@ -46,6 +46,7 @@
 #include <linux/skbuff.h>
 #include <linux/jiffies.h>
 #include <linux/list.h>
+#include <linux/slab.h>
 
 /* for sysctl */
 #include <linux/fs.h>
diff --git a/net/netfilter/ipvs/ip_vs_proto.c b/net/netfilter/ipvs/ip_vs_proto.c
index 0e584553819d..7fc49f4cf5ad 100644
--- a/net/netfilter/ipvs/ip_vs_proto.c
+++ b/net/netfilter/ipvs/ip_vs_proto.c
@@ -19,6 +19,7 @@
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/skbuff.h>
+#include <linux/gfp.h>
 #include <linux/in.h>
 #include <linux/ip.h>
 #include <net/protocol.h>
diff --git a/net/netfilter/ipvs/ip_vs_sh.c b/net/netfilter/ipvs/ip_vs_sh.c
index 8e6cfd36e6f0..e6cc174fbc06 100644
--- a/net/netfilter/ipvs/ip_vs_sh.c
+++ b/net/netfilter/ipvs/ip_vs_sh.c
@@ -36,6 +36,7 @@
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 
 #include <linux/ip.h>
+#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/skbuff.h>
diff --git a/net/netfilter/ipvs/ip_vs_sync.c b/net/netfilter/ipvs/ip_vs_sync.c
index 8fb0ae616761..7ba06939829f 100644
--- a/net/netfilter/ipvs/ip_vs_sync.c
+++ b/net/netfilter/ipvs/ip_vs_sync.c
@@ -802,7 +802,7 @@ static int sync_thread_backup(void *data)
                 ip_vs_backup_mcast_ifn, ip_vs_backup_syncid);
 
         while (!kthread_should_stop()) {
-                wait_event_interruptible(*tinfo->sock->sk->sk_sleep,
+                wait_event_interruptible(*sk_sleep(tinfo->sock->sk),
                          !skb_queue_empty(&tinfo->sock->sk->sk_receive_queue)
                          || kthread_should_stop());
 
diff --git a/net/netfilter/ipvs/ip_vs_wrr.c b/net/netfilter/ipvs/ip_vs_wrr.c
index 3c115fc19784..30db633f88f1 100644
--- a/net/netfilter/ipvs/ip_vs_wrr.c
+++ b/net/netfilter/ipvs/ip_vs_wrr.c
@@ -23,6 +23,7 @@
 
 #include <linux/module.h>
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/net.h>
 #include <linux/gcd.h>
 
diff --git a/net/netfilter/ipvs/ip_vs_xmit.c b/net/netfilter/ipvs/ip_vs_xmit.c
index 223b5018c7dc..e450cd6f4eb5 100644
--- a/net/netfilter/ipvs/ip_vs_xmit.c
+++ b/net/netfilter/ipvs/ip_vs_xmit.c
@@ -17,6 +17,7 @@
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/tcp.h>                  /* for tcphdr */
 #include <net/ip.h>
 #include <net/tcp.h>                    /* for csum_tcpudp_magic */
diff --git a/net/netfilter/nf_conntrack_acct.c b/net/netfilter/nf_conntrack_acct.c
index 018f90db511c..ab81b380eae6 100644
--- a/net/netfilter/nf_conntrack_acct.c
+++ b/net/netfilter/nf_conntrack_acct.c
@@ -9,6 +9,7 @@
  */
 
 #include <linux/netfilter.h>
+#include <linux/slab.h>
 #include <linux/kernel.h>
 #include <linux/moduleparam.h>
 
diff --git a/net/netfilter/nf_conntrack_amanda.c b/net/netfilter/nf_conntrack_amanda.c
index 07d9d8857e5d..372e80f07a81 100644
--- a/net/netfilter/nf_conntrack_amanda.c
+++ b/net/netfilter/nf_conntrack_amanda.c
@@ -16,6 +16,7 @@
 #include <linux/in.h>
 #include <linux/udp.h>
 #include <linux/netfilter.h>
+#include <linux/gfp.h>
 
 #include <net/netfilter/nf_conntrack.h>
 #include <net/netfilter/nf_conntrack_expect.h>
diff --git a/net/netfilter/nf_conntrack_ecache.c b/net/netfilter/nf_conntrack_ecache.c
index d5a9bcd7d61b..f516961a83b4 100644
--- a/net/netfilter/nf_conntrack_ecache.c
+++ b/net/netfilter/nf_conntrack_ecache.c
@@ -18,6 +18,7 @@
 #include <linux/percpu.h>
 #include <linux/kernel.h>
 #include <linux/netdevice.h>
+#include <linux/slab.h>
 
 #include <net/netfilter/nf_conntrack.h>
 #include <net/netfilter/nf_conntrack_core.h>
diff --git a/net/netfilter/nf_conntrack_ftp.c b/net/netfilter/nf_conntrack_ftp.c
index f0732aa18e4f..2ae3169e7633 100644
--- a/net/netfilter/nf_conntrack_ftp.c
+++ b/net/netfilter/nf_conntrack_ftp.c
@@ -13,6 +13,7 @@
 #include <linux/moduleparam.h>
 #include <linux/netfilter.h>
 #include <linux/ip.h>
+#include <linux/slab.h>
 #include <linux/ipv6.h>
 #include <linux/ctype.h>
 #include <linux/inet.h>
diff --git a/net/netfilter/nf_conntrack_h323_main.c b/net/netfilter/nf_conntrack_h323_main.c
index a1c8dd917e12..a487c8038044 100644
--- a/net/netfilter/nf_conntrack_h323_main.c
+++ b/net/netfilter/nf_conntrack_h323_main.c
@@ -17,6 +17,7 @@
 #include <linux/inet.h>
 #include <linux/in.h>
 #include <linux/ip.h>
+#include <linux/slab.h>
 #include <linux/udp.h>
 #include <linux/tcp.h>
 #include <linux/skbuff.h>
diff --git a/net/netfilter/nf_conntrack_helper.c b/net/netfilter/nf_conntrack_helper.c
index 4509fa6726f8..59e1a4cd4e8b 100644
--- a/net/netfilter/nf_conntrack_helper.c
+++ b/net/netfilter/nf_conntrack_helper.c
@@ -15,7 +15,6 @@
 #include <linux/skbuff.h>
 #include <linux/vmalloc.h>
 #include <linux/stddef.h>
-#include <linux/slab.h>
 #include <linux/random.h>
 #include <linux/err.h>
 #include <linux/kernel.h>
diff --git a/net/netfilter/nf_conntrack_irc.c b/net/netfilter/nf_conntrack_irc.c
index 8bd98c84f77e..7673930ca342 100644
--- a/net/netfilter/nf_conntrack_irc.c
+++ b/net/netfilter/nf_conntrack_irc.c
@@ -15,6 +15,7 @@
 #include <linux/ip.h>
 #include <linux/tcp.h>
 #include <linux/netfilter.h>
+#include <linux/slab.h>
 
 #include <net/netfilter/nf_conntrack.h>
 #include <net/netfilter/nf_conntrack_expect.h>
diff --git a/net/netfilter/nf_conntrack_netlink.c b/net/netfilter/nf_conntrack_netlink.c
index 2b2af631d2b8..afc52f2ee4ac 100644
--- a/net/netfilter/nf_conntrack_netlink.c
+++ b/net/netfilter/nf_conntrack_netlink.c
@@ -27,6 +27,7 @@
 #include <linux/netlink.h>
 #include <linux/spinlock.h>
 #include <linux/interrupt.h>
+#include <linux/slab.h>
 
 #include <linux/netfilter.h>
 #include <net/netlink.h>
@@ -582,7 +583,9 @@ nla_put_failure:
 nlmsg_failure:
         kfree_skb(skb);
 errout:
-        nfnetlink_set_err(net, 0, group, -ENOBUFS);
+        if (nfnetlink_set_err(net, 0, group, -ENOBUFS) > 0)
+                return -ENOBUFS;
+
         return 0;
 }
 #endif /* CONFIG_NF_CONNTRACK_EVENTS */
diff --git a/net/netfilter/nf_conntrack_proto.c b/net/netfilter/nf_conntrack_proto.c
index 1a4568bf7ea5..a44fa75b5178 100644
--- a/net/netfilter/nf_conntrack_proto.c
+++ b/net/netfilter/nf_conntrack_proto.c
@@ -12,6 +12,7 @@
 #include <linux/types.h>
 #include <linux/netfilter.h>
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/mutex.h>
 #include <linux/skbuff.h>
 #include <linux/vmalloc.h>
diff --git a/net/netfilter/nf_conntrack_proto_dccp.c b/net/netfilter/nf_conntrack_proto_dccp.c
index 9a2815549375..5292560d6d4a 100644
--- a/net/netfilter/nf_conntrack_proto_dccp.c
+++ b/net/netfilter/nf_conntrack_proto_dccp.c
@@ -15,6 +15,7 @@
 #include <linux/spinlock.h>
 #include <linux/skbuff.h>
 #include <linux/dccp.h>
+#include <linux/slab.h>
 
 #include <net/net_namespace.h>
 #include <net/netns/generic.h>
diff --git a/net/netfilter/nf_conntrack_proto_gre.c b/net/netfilter/nf_conntrack_proto_gre.c
index d899b1a69940..cf616e55ca41 100644
--- a/net/netfilter/nf_conntrack_proto_gre.c
+++ b/net/netfilter/nf_conntrack_proto_gre.c
@@ -31,6 +31,7 @@
 #include <linux/in.h>
 #include <linux/netdevice.h>
 #include <linux/skbuff.h>
+#include <linux/slab.h>
 #include <net/dst.h>
 #include <net/net_namespace.h>
 #include <net/netns/generic.h>
diff --git a/net/netfilter/nf_conntrack_sane.c b/net/netfilter/nf_conntrack_sane.c
index dcfecbb81c46..d9e27734b2a2 100644
--- a/net/netfilter/nf_conntrack_sane.c
+++ b/net/netfilter/nf_conntrack_sane.c
@@ -20,6 +20,7 @@
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/netfilter.h>
+#include <linux/slab.h>
 #include <linux/in.h>
 #include <linux/tcp.h>
 #include <net/netfilter/nf_conntrack.h>
diff --git a/net/netfilter/nf_conntrack_sip.c b/net/netfilter/nf_conntrack_sip.c
index 8dd75d90efc0..c6cd1b84eddd 100644
--- a/net/netfilter/nf_conntrack_sip.c
+++ b/net/netfilter/nf_conntrack_sip.c
@@ -284,7 +284,7 @@ EXPORT_SYMBOL_GPL(ct_sip_parse_request);
  * tabs, spaces and continuation lines, which are treated as a single whitespace
  * character.
  *
- * Some headers may appear multiple times. A comma seperated list of values is
+ * Some headers may appear multiple times. A comma separated list of values is
  * equivalent to multiple headers.
  */
 static const struct sip_header ct_sip_hdrs[] = {
@@ -421,7 +421,7 @@ int ct_sip_get_header(const struct nf_conn *ct, const char *dptr,
 }
 EXPORT_SYMBOL_GPL(ct_sip_get_header);
 
-/* Get next header field in a list of comma seperated values */
+/* Get next header field in a list of comma separated values */
 static int ct_sip_next_header(const struct nf_conn *ct, const char *dptr,
                               unsigned int dataoff, unsigned int datalen,
                               enum sip_header_types type,
diff --git a/net/netfilter/nf_conntrack_standalone.c b/net/netfilter/nf_conntrack_standalone.c
index 24a42efe62ef..faa8eb3722b9 100644
--- a/net/netfilter/nf_conntrack_standalone.c
+++ b/net/netfilter/nf_conntrack_standalone.c
@@ -8,6 +8,7 @@
 
 #include <linux/types.h>
 #include <linux/netfilter.h>
+#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/skbuff.h>
 #include <linux/proc_fs.h>
diff --git a/net/netfilter/nf_queue.c b/net/netfilter/nf_queue.c
index ba095fd014e5..c49ef219899e 100644
--- a/net/netfilter/nf_queue.c
+++ b/net/netfilter/nf_queue.c
@@ -1,4 +1,5 @@
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/proc_fs.h>
diff --git a/net/netfilter/nfnetlink.c b/net/netfilter/nfnetlink.c
index 8eb0cc23ada3..6afa3d52ea5f 100644
--- a/net/netfilter/nfnetlink.c
+++ b/net/netfilter/nfnetlink.c
@@ -113,9 +113,9 @@ int nfnetlink_send(struct sk_buff *skb, struct net *net, u32 pid,
 }
 EXPORT_SYMBOL_GPL(nfnetlink_send);
 
-void nfnetlink_set_err(struct net *net, u32 pid, u32 group, int error)
+int nfnetlink_set_err(struct net *net, u32 pid, u32 group, int error)
 {
-        netlink_set_err(net->nfnl, pid, group, error);
+        return netlink_set_err(net->nfnl, pid, group, error);
 }
 EXPORT_SYMBOL_GPL(nfnetlink_set_err);
 
diff --git a/net/netfilter/nfnetlink_log.c b/net/netfilter/nfnetlink_log.c
index d9b8fb8ab340..203643fb2c52 100644
--- a/net/netfilter/nfnetlink_log.c
+++ b/net/netfilter/nfnetlink_log.c
@@ -28,6 +28,7 @@
 #include <linux/list.h>
 #include <linux/jhash.h>
 #include <linux/random.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 #include <net/netfilter/nf_log.h>
 #include <net/netfilter/nfnetlink_log.h>
diff --git a/net/netfilter/nfnetlink_queue.c b/net/netfilter/nfnetlink_queue.c
index 7ba4abc405c9..e70a6ef1f4f2 100644
--- a/net/netfilter/nfnetlink_queue.c
+++ b/net/netfilter/nfnetlink_queue.c
@@ -18,6 +18,7 @@
 #include <linux/skbuff.h>
 #include <linux/init.h>
 #include <linux/spinlock.h>
+#include <linux/slab.h>
 #include <linux/notifier.h>
 #include <linux/netdevice.h>
 #include <linux/netfilter.h>
diff --git a/net/netfilter/x_tables.c b/net/netfilter/x_tables.c
index 0a12cedfe9e3..665f5beef6ad 100644
--- a/net/netfilter/x_tables.c
+++ b/net/netfilter/x_tables.c
@@ -22,6 +22,7 @@
 #include <linux/vmalloc.h>
 #include <linux/mutex.h>
 #include <linux/mm.h>
+#include <linux/slab.h>
 #include <net/net_namespace.h>
 
 #include <linux/netfilter/x_tables.h>
diff --git a/net/netfilter/xt_CT.c b/net/netfilter/xt_CT.c
index 61c50fa84703..ee18b231b950 100644
--- a/net/netfilter/xt_CT.c
+++ b/net/netfilter/xt_CT.c
@@ -7,6 +7,7 @@
  */
 
 #include <linux/module.h>
+#include <linux/gfp.h>
 #include <linux/skbuff.h>
 #include <linux/selinux.h>
 #include <linux/netfilter_ipv4/ip_tables.h>
diff --git a/net/netfilter/xt_LED.c b/net/netfilter/xt_LED.c
index 8ff7843bb921..3271c8e52153 100644
--- a/net/netfilter/xt_LED.c
+++ b/net/netfilter/xt_LED.c
@@ -22,6 +22,7 @@
 #include <linux/module.h>
 #include <linux/skbuff.h>
 #include <linux/netfilter/x_tables.h>
+#include <linux/slab.h>
 #include <linux/leds.h>
 #include <linux/mutex.h>
 
diff --git a/net/netfilter/xt_RATEEST.c b/net/netfilter/xt_RATEEST.c
index 87ae97e5516f..d16d55df4f61 100644
--- a/net/netfilter/xt_RATEEST.c
+++ b/net/netfilter/xt_RATEEST.c
@@ -11,6 +11,7 @@
 #include <linux/jhash.h>
 #include <linux/rtnetlink.h>
 #include <linux/random.h>
+#include <linux/slab.h>
 #include <net/gen_stats.h>
 #include <net/netlink.h>
 
diff --git a/net/netfilter/xt_TCPMSS.c b/net/netfilter/xt_TCPMSS.c
index 0e357ac9a2a8..c5f4b9919e9a 100644
--- a/net/netfilter/xt_TCPMSS.c
+++ b/net/netfilter/xt_TCPMSS.c
@@ -11,6 +11,7 @@
 #include <linux/module.h>
 #include <linux/skbuff.h>
 #include <linux/ip.h>
+#include <linux/gfp.h>
 #include <linux/ipv6.h>
 #include <linux/tcp.h>
 #include <net/dst.h>
diff --git a/net/netfilter/xt_connlimit.c b/net/netfilter/xt_connlimit.c
index 26997ce90e48..388ca4596098 100644
--- a/net/netfilter/xt_connlimit.c
+++ b/net/netfilter/xt_connlimit.c
@@ -17,6 +17,7 @@
 #include <linux/ip.h>
 #include <linux/ipv6.h>
 #include <linux/jhash.h>
+#include <linux/slab.h>
 #include <linux/list.h>
 #include <linux/module.h>
 #include <linux/random.h>
diff --git a/net/netfilter/xt_dccp.c b/net/netfilter/xt_dccp.c
index 0989f29ade2e..395af5943ffd 100644
--- a/net/netfilter/xt_dccp.c
+++ b/net/netfilter/xt_dccp.c
@@ -10,6 +10,7 @@
 
 #include <linux/module.h>
 #include <linux/skbuff.h>
+#include <linux/slab.h>
 #include <linux/spinlock.h>
 #include <net/ip.h>
 #include <linux/dccp.h>
diff --git a/net/netfilter/xt_hashlimit.c b/net/netfilter/xt_hashlimit.c
index d952806b6469..215a64835de8 100644
--- a/net/netfilter/xt_hashlimit.c
+++ b/net/netfilter/xt_hashlimit.c
@@ -1,6 +1,6 @@
 /*
  *      xt_hashlimit - Netfilter module to limit the number of packets per time
- *      seperately for each hashbucket (sourceip/sourceport/dstip/dstport)
+ *      separately for each hashbucket (sourceip/sourceport/dstip/dstport)
  *
  *      (C) 2003-2004 by Harald Welte <laforge@netfilter.org>
  *      Copyright © CC Computer Consultants GmbH, 2007 - 2008
@@ -493,6 +493,7 @@ static void hashlimit_ipv6_mask(__be32 *i, unsigned int p)
         case 64 ... 95:
                 i[2] = maskl(i[2], p - 64);
                 i[3] = 0;
+                break;
         case 96 ... 127:
                 i[3] = maskl(i[3], p - 96);
                 break;
@@ -879,7 +880,8 @@ static void dl_seq_stop(struct seq_file *s, void *v)
         struct xt_hashlimit_htable *htable = s->private;
         unsigned int *bucket = (unsigned int *)v;
 
-        kfree(bucket);
+        if (!IS_ERR(bucket))
+                kfree(bucket);
         spin_unlock_bh(&htable->lock);
 }
 
diff --git a/net/netfilter/xt_limit.c b/net/netfilter/xt_limit.c
index a0ca5339af41..e5d7e1ffb1a4 100644
--- a/net/netfilter/xt_limit.c
+++ b/net/netfilter/xt_limit.c
@@ -6,6 +6,7 @@
  * published by the Free Software Foundation.
  */
 
+#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/skbuff.h>
 #include <linux/spinlock.h>
diff --git a/net/netfilter/xt_quota.c b/net/netfilter/xt_quota.c
index 390b7d09fe51..2d5562498c43 100644
--- a/net/netfilter/xt_quota.c
+++ b/net/netfilter/xt_quota.c
@@ -4,6 +4,7 @@
  * Sam Johnston <samj@samj.net>
  */
 #include <linux/skbuff.h>
+#include <linux/slab.h>
 #include <linux/spinlock.h>
 
 #include <linux/netfilter/x_tables.h>
diff --git a/net/netfilter/xt_recent.c b/net/netfilter/xt_recent.c
index 7073dbb8100c..834b736857cb 100644
--- a/net/netfilter/xt_recent.c
+++ b/net/netfilter/xt_recent.c
@@ -27,6 +27,7 @@
 #include <linux/bitops.h>
 #include <linux/skbuff.h>
 #include <linux/inet.h>
+#include <linux/slab.h>
 #include <net/net_namespace.h>
 #include <net/netns/generic.h>
 
@@ -267,7 +268,7 @@ recent_mt(const struct sk_buff *skb, const struct xt_match_param *par)
                 for (i = 0; i < e->nstamps; i++) {
                         if (info->seconds && time_after(time, e->stamps[i]))
                                 continue;
-                        if (info->hit_count && ++hits >= info->hit_count) {
+                        if (!info->hit_count || ++hits >= info->hit_count) {
                                 ret = !ret;
                                 break;
                         }
diff --git a/net/netfilter/xt_statistic.c b/net/netfilter/xt_statistic.c
index d8c0f8f1a78e..937ce0633e99 100644
--- a/net/netfilter/xt_statistic.c
+++ b/net/netfilter/xt_statistic.c
@@ -12,6 +12,7 @@
 #include <linux/spinlock.h>
 #include <linux/skbuff.h>
 #include <linux/net.h>
+#include <linux/slab.h>
 
 #include <linux/netfilter/xt_statistic.h>
 #include <linux/netfilter/x_tables.h>
diff --git a/net/netfilter/xt_string.c b/net/netfilter/xt_string.c
index b4d774111311..96801ffd8af8 100644
--- a/net/netfilter/xt_string.c
+++ b/net/netfilter/xt_string.c
@@ -7,6 +7,7 @@
  * published by the Free Software Foundation.
  */
 
+#include <linux/gfp.h>
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
diff --git a/net/netlabel/netlabel_cipso_v4.c b/net/netlabel/netlabel_cipso_v4.c
index e639298bc9c8..5f14c8462e30 100644
--- a/net/netlabel/netlabel_cipso_v4.c
+++ b/net/netlabel/netlabel_cipso_v4.c
@@ -33,6 +33,7 @@
 #include <linux/string.h>
 #include <linux/skbuff.h>
 #include <linux/audit.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 #include <net/netlink.h>
 #include <net/genetlink.h>
diff --git a/net/netlabel/netlabel_domainhash.c b/net/netlabel/netlabel_domainhash.c
index 0bfeaab88ef5..d37b7f80fa37 100644
--- a/net/netlabel/netlabel_domainhash.c
+++ b/net/netlabel/netlabel_domainhash.c
@@ -35,6 +35,7 @@
 #include <linux/spinlock.h>
 #include <linux/string.h>
 #include <linux/audit.h>
+#include <linux/slab.h>
 #include <net/netlabel.h>
 #include <net/cipso_ipv4.h>
 #include <asm/bug.h>
@@ -50,9 +51,12 @@ struct netlbl_domhsh_tbl {
 };
 
 /* Domain hash table */
-/* XXX - updates should be so rare that having one spinlock for the entire
- * hash table should be okay */
+/* updates should be so rare that having one spinlock for the entire hash table
+ * should be okay */
 static DEFINE_SPINLOCK(netlbl_domhsh_lock);
+#define netlbl_domhsh_rcu_deref(p) \
+        rcu_dereference_check(p, rcu_read_lock_held() || \
+                                 lockdep_is_held(&netlbl_domhsh_lock))
 static struct netlbl_domhsh_tbl *netlbl_domhsh = NULL;
 static struct netlbl_dom_map *netlbl_domhsh_def = NULL;
 
@@ -106,7 +110,8 @@ static void netlbl_domhsh_free_entry(struct rcu_head *entry)
  * Description:
  * This is the hashing function for the domain hash table, it returns the
  * correct bucket number for the domain.  The caller is responsibile for
- * calling the rcu_read_[un]lock() functions.
+ * ensuring that the hash table is protected with either a RCU read lock or the
+ * hash table lock.
  *
  */
 static u32 netlbl_domhsh_hash(const char *key)
@@ -120,7 +125,7 @@ static u32 netlbl_domhsh_hash(const char *key)
 
         for (iter = 0, val = 0, len = strlen(key); iter < len; iter++)
                 val = (val << 4 | (val >> (8 * sizeof(u32) - 4))) ^ key[iter];
-        return val & (rcu_dereference(netlbl_domhsh)->size - 1);
+        return val & (netlbl_domhsh_rcu_deref(netlbl_domhsh)->size - 1);
 }
 
 /**
@@ -130,7 +135,8 @@ static u32 netlbl_domhsh_hash(const char *key)
  * Description:
  * Searches the domain hash table and returns a pointer to the hash table
  * entry if found, otherwise NULL is returned.  The caller is responsibile for
- * the rcu hash table locks (i.e. the caller much call rcu_read_[un]lock()).
+ * ensuring that the hash table is protected with either a RCU read lock or the
+ * hash table lock.
  *
  */
 static struct netlbl_dom_map *netlbl_domhsh_search(const char *domain)
@@ -141,7 +147,7 @@ static struct netlbl_dom_map *netlbl_domhsh_search(const char *domain)
 
         if (domain != NULL) {
                 bkt = netlbl_domhsh_hash(domain);
-                bkt_list = &rcu_dereference(netlbl_domhsh)->tbl[bkt];
+                bkt_list = &netlbl_domhsh_rcu_deref(netlbl_domhsh)->tbl[bkt];
                 list_for_each_entry_rcu(iter, bkt_list, list)
                         if (iter->valid && strcmp(iter->domain, domain) == 0)
                                 return iter;
@@ -159,8 +165,8 @@ static struct netlbl_dom_map *netlbl_domhsh_search(const char *domain)
  * Searches the domain hash table and returns a pointer to the hash table
  * entry if an exact match is found, if an exact match is not present in the
  * hash table then the default entry is returned if valid otherwise NULL is
- * returned.  The caller is responsibile for the rcu hash table locks
- * (i.e. the caller much call rcu_read_[un]lock()).
+ * returned.  The caller is responsibile ensuring that the hash table is
+ * protected with either a RCU read lock or the hash table lock.
  *
  */
 static struct netlbl_dom_map *netlbl_domhsh_search_def(const char *domain)
@@ -169,7 +175,7 @@ static struct netlbl_dom_map *netlbl_domhsh_search_def(const char *domain)
 
         entry = netlbl_domhsh_search(domain);
         if (entry == NULL) {
-                entry = rcu_dereference(netlbl_domhsh_def);
+                entry = netlbl_domhsh_rcu_deref(netlbl_domhsh_def);
                 if (entry != NULL && !entry->valid)
                         entry = NULL;
         }
@@ -306,8 +312,11 @@ int netlbl_domhsh_add(struct netlbl_dom_map *entry,
         struct netlbl_af6list *tmp6;
 #endif /* IPv6 */
 
+        /* XXX - we can remove this RCU read lock as the spinlock protects the
+         *       entire function, but before we do we need to fixup the
+         *       netlbl_af[4,6]list RCU functions to do "the right thing" with
+         *       respect to rcu_dereference() when only a spinlock is held. */
         rcu_read_lock();
-
         spin_lock(&netlbl_domhsh_lock);
         if (entry->domain != NULL)
                 entry_old = netlbl_domhsh_search(entry->domain);
diff --git a/net/netlabel/netlabel_kapi.c b/net/netlabel/netlabel_kapi.c
index 6ce00205f342..1b83e0009d8d 100644
--- a/net/netlabel/netlabel_kapi.c
+++ b/net/netlabel/netlabel_kapi.c
@@ -30,6 +30,7 @@
 
 #include <linux/init.h>
 #include <linux/types.h>
+#include <linux/slab.h>
 #include <linux/audit.h>
 #include <linux/in.h>
 #include <linux/in6.h>
diff --git a/net/netlabel/netlabel_mgmt.c b/net/netlabel/netlabel_mgmt.c
index 8203623e65ad..998e85e895d0 100644
--- a/net/netlabel/netlabel_mgmt.c
+++ b/net/netlabel/netlabel_mgmt.c
@@ -34,6 +34,7 @@
 #include <linux/skbuff.h>
 #include <linux/in.h>
 #include <linux/in6.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 #include <net/netlink.h>
 #include <net/genetlink.h>
diff --git a/net/netlabel/netlabel_unlabeled.c b/net/netlabel/netlabel_unlabeled.c
index 852d9d7976b9..a3d64aabe2f7 100644
--- a/net/netlabel/netlabel_unlabeled.c
+++ b/net/netlabel/netlabel_unlabeled.c
@@ -43,6 +43,7 @@
 #include <linux/notifier.h>
 #include <linux/netdevice.h>
 #include <linux/security.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 #include <net/netlink.h>
 #include <net/genetlink.h>
@@ -114,6 +115,9 @@ struct netlbl_unlhsh_walk_arg {
 /* updates should be so rare that having one spinlock for the entire
  * hash table should be okay */
 static DEFINE_SPINLOCK(netlbl_unlhsh_lock);
+#define netlbl_unlhsh_rcu_deref(p) \
+        rcu_dereference_check(p, rcu_read_lock_held() || \
+                                 lockdep_is_held(&netlbl_unlhsh_lock))
 static struct netlbl_unlhsh_tbl *netlbl_unlhsh = NULL;
 static struct netlbl_unlhsh_iface *netlbl_unlhsh_def = NULL;
 
@@ -235,15 +239,13 @@ static void netlbl_unlhsh_free_iface(struct rcu_head *entry)
  * Description:
  * This is the hashing function for the unlabeled hash table, it returns the
  * bucket number for the given device/interface.  The caller is responsible for
- * calling the rcu_read_[un]lock() functions.
+ * ensuring that the hash table is protected with either a RCU read lock or
+ * the hash table lock.
  *
  */
 static u32 netlbl_unlhsh_hash(int ifindex)
 {
-        /* this is taken _almost_ directly from
-         * security/selinux/netif.c:sel_netif_hasfn() as they do pretty much
-         * the same thing */
-        return ifindex & (rcu_dereference(netlbl_unlhsh)->size - 1);
+        return ifindex & (netlbl_unlhsh_rcu_deref(netlbl_unlhsh)->size - 1);
 }
 
 /**
@@ -253,7 +255,8 @@ static u32 netlbl_unlhsh_hash(int ifindex)
  * Description:
  * Searches the unlabeled connection hash table and returns a pointer to the
  * interface entry which matches @ifindex, otherwise NULL is returned.  The
- * caller is responsible for calling the rcu_read_[un]lock() functions.
+ * caller is responsible for ensuring that the hash table is protected with
+ * either a RCU read lock or the hash table lock.
  *
  */
 static struct netlbl_unlhsh_iface *netlbl_unlhsh_search_iface(int ifindex)
@@ -263,7 +266,7 @@ static struct netlbl_unlhsh_iface *netlbl_unlhsh_search_iface(int ifindex)
         struct netlbl_unlhsh_iface *iter;
 
         bkt = netlbl_unlhsh_hash(ifindex);
-        bkt_list = &rcu_dereference(netlbl_unlhsh)->tbl[bkt];
+        bkt_list = &netlbl_unlhsh_rcu_deref(netlbl_unlhsh)->tbl[bkt];
         list_for_each_entry_rcu(iter, bkt_list, list)
                 if (iter->valid && iter->ifindex == ifindex)
                         return iter;
@@ -272,33 +275,6 @@ static struct netlbl_unlhsh_iface *netlbl_unlhsh_search_iface(int ifindex)
 }
 
 /**
- * netlbl_unlhsh_search_iface_def - Search for a matching interface entry
- * @ifindex: the network interface
- *
- * Description:
- * Searches the unlabeled connection hash table and returns a pointer to the
- * interface entry which matches @ifindex.  If an exact match can not be found
- * and there is a valid default entry, the default entry is returned, otherwise
- * NULL is returned.  The caller is responsible for calling the
- * rcu_read_[un]lock() functions.
- *
- */
-static struct netlbl_unlhsh_iface *netlbl_unlhsh_search_iface_def(int ifindex)
-{
-        struct netlbl_unlhsh_iface *entry;
-
-        entry = netlbl_unlhsh_search_iface(ifindex);
-        if (entry != NULL)
-                return entry;
-
-        entry = rcu_dereference(netlbl_unlhsh_def);
-        if (entry != NULL && entry->valid)
-                return entry;
-
-        return NULL;
-}
-
-/**
  * netlbl_unlhsh_add_addr4 - Add a new IPv4 address entry to the hash table
  * @iface: the associated interface entry
  * @addr: IPv4 address in network byte order
@@ -308,8 +284,7 @@ static struct netlbl_unlhsh_iface *netlbl_unlhsh_search_iface_def(int ifindex)
  * Description:
  * Add a new address entry into the unlabeled connection hash table using the
  * interface entry specified by @iface.  On success zero is returned, otherwise
- * a negative value is returned.  The caller is responsible for calling the
- * rcu_read_[un]lock() functions.
+ * a negative value is returned.
  *
  */
 static int netlbl_unlhsh_add_addr4(struct netlbl_unlhsh_iface *iface,
@@ -349,8 +324,7 @@ static int netlbl_unlhsh_add_addr4(struct netlbl_unlhsh_iface *iface,
  * Description:
  * Add a new address entry into the unlabeled connection hash table using the
  * interface entry specified by @iface.  On success zero is returned, otherwise
- * a negative value is returned.  The caller is responsible for calling the
- * rcu_read_[un]lock() functions.
+ * a negative value is returned.
  *
  */
 static int netlbl_unlhsh_add_addr6(struct netlbl_unlhsh_iface *iface,
@@ -391,8 +365,7 @@ static int netlbl_unlhsh_add_addr6(struct netlbl_unlhsh_iface *iface,
  * Description:
  * Add a new, empty, interface entry into the unlabeled connection hash table.
  * On success a pointer to the new interface entry is returned, on failure NULL
- * is returned.  The caller is responsible for calling the rcu_read_[un]lock()
- * functions.
+ * is returned.
  *
  */
 static struct netlbl_unlhsh_iface *netlbl_unlhsh_add_iface(int ifindex)
@@ -415,10 +388,10 @@ static struct netlbl_unlhsh_iface *netlbl_unlhsh_add_iface(int ifindex)
                 if (netlbl_unlhsh_search_iface(ifindex) != NULL)
                         goto add_iface_failure;
                 list_add_tail_rcu(&iface->list,
-                                  &rcu_dereference(netlbl_unlhsh)->tbl[bkt]);
+                             &netlbl_unlhsh_rcu_deref(netlbl_unlhsh)->tbl[bkt]);
         } else {
                 INIT_LIST_HEAD(&iface->list);
-                if (rcu_dereference(netlbl_unlhsh_def) != NULL)
+                if (netlbl_unlhsh_rcu_deref(netlbl_unlhsh_def) != NULL)
                         goto add_iface_failure;
                 rcu_assign_pointer(netlbl_unlhsh_def, iface);
         }
@@ -548,8 +521,7 @@ unlhsh_add_return:
  *
  * Description:
  * Remove an IP address entry from the unlabeled connection hash table.
- * Returns zero on success, negative values on failure.  The caller is
- * responsible for calling the rcu_read_[un]lock() functions.
+ * Returns zero on success, negative values on failure.
  *
  */
 static int netlbl_unlhsh_remove_addr4(struct net *net,
@@ -611,8 +583,7 @@ static int netlbl_unlhsh_remove_addr4(struct net *net,
  *
  * Description:
  * Remove an IP address entry from the unlabeled connection hash table.
- * Returns zero on success, negative values on failure.  The caller is
- * responsible for calling the rcu_read_[un]lock() functions.
+ * Returns zero on success, negative values on failure.
  *
  */
 static int netlbl_unlhsh_remove_addr6(struct net *net,
@@ -1547,8 +1518,10 @@ int netlbl_unlabel_getattr(const struct sk_buff *skb,
         struct netlbl_unlhsh_iface *iface;
 
         rcu_read_lock();
-        iface = netlbl_unlhsh_search_iface_def(skb->skb_iif);
+        iface = netlbl_unlhsh_search_iface(skb->skb_iif);
         if (iface == NULL)
+                iface = rcu_dereference(netlbl_unlhsh_def);
+        if (iface == NULL || !iface->valid)
                 goto unlabel_getattr_nolabel;
         switch (family) {
         case PF_INET: {
diff --git a/net/netlabel/netlabel_user.c b/net/netlabel/netlabel_user.c
index 68706b4e3bf8..a3fd75ac3fa5 100644
--- a/net/netlabel/netlabel_user.c
+++ b/net/netlabel/netlabel_user.c
@@ -35,6 +35,7 @@
 #include <linux/audit.h>
 #include <linux/tty.h>
 #include <linux/security.h>
+#include <linux/gfp.h>
 #include <net/sock.h>
 #include <net/netlink.h>
 #include <net/genetlink.h>
diff --git a/net/netlink/af_netlink.c b/net/netlink/af_netlink.c
index 320d0423a240..6464a1972a69 100644
--- a/net/netlink/af_netlink.c
+++ b/net/netlink/af_netlink.c
@@ -545,7 +545,7 @@ static int netlink_autobind(struct socket *sock)
         struct hlist_head *head;
         struct sock *osk;
         struct hlist_node *node;
-        s32 pid = current->tgid;
+        s32 pid = task_tgid_vnr(current);
         int err;
         static s32 rover = -4097;
 
@@ -683,6 +683,9 @@ static int netlink_connect(struct socket *sock, struct sockaddr *addr,
         struct netlink_sock *nlk = nlk_sk(sk);
         struct sockaddr_nl *nladdr = (struct sockaddr_nl *)addr;
 
+        if (alen < sizeof(addr->sa_family))
+                return -EINVAL;
+
         if (addr->sa_family == AF_UNSPEC) {
                 sk->sk_state    = NETLINK_UNCONNECTED;
                 nlk->dst_pid    = 0;
@@ -1093,6 +1096,7 @@ static inline int do_one_set_err(struct sock *sk,
                                  struct netlink_set_err_data *p)
 {
         struct netlink_sock *nlk = nlk_sk(sk);
+        int ret = 0;
 
         if (sk == p->exclude_sk)
                 goto out;
@@ -1104,10 +1108,15 @@ static inline int do_one_set_err(struct sock *sk,
             !test_bit(p->group - 1, nlk->groups))
                 goto out;
 
+        if (p->code == ENOBUFS && nlk->flags & NETLINK_RECV_NO_ENOBUFS) {
+                ret = 1;
+                goto out;
+        }
+
         sk->sk_err = p->code;
         sk->sk_error_report(sk);
 out:
-        return 0;
+        return ret;
 }
 
 /**
@@ -1116,12 +1125,16 @@ out:
  * @pid: the PID of a process that we want to skip (if any)
  * @groups: the broadcast group that will notice the error
  * @code: error code, must be negative (as usual in kernelspace)
+ *
+ * This function returns the number of broadcast listeners that have set the
+ * NETLINK_RECV_NO_ENOBUFS socket option.
  */
-void netlink_set_err(struct sock *ssk, u32 pid, u32 group, int code)
+int netlink_set_err(struct sock *ssk, u32 pid, u32 group, int code)
 {
         struct netlink_set_err_data info;
         struct hlist_node *node;
         struct sock *sk;
+        int ret = 0;
 
         info.exclude_sk = ssk;
         info.pid = pid;
@@ -1132,9 +1145,10 @@ void netlink_set_err(struct sock *ssk, u32 pid, u32 group, int code)
         read_lock(&nl_table_lock);
 
         sk_for_each_bound(sk, node, &nl_table[ssk->sk_protocol].mc_list)
-                do_one_set_err(sk, &info);
+                ret += do_one_set_err(sk, &info);
 
         read_unlock(&nl_table_lock);
+        return ret;
 }
 EXPORT_SYMBOL(netlink_set_err);
 
diff --git a/net/netlink/genetlink.c b/net/netlink/genetlink.c
index a4b6e148c5de..aa4308afcc7f 100644
--- a/net/netlink/genetlink.c
+++ b/net/netlink/genetlink.c
@@ -8,6 +8,7 @@
 
 #include <linux/module.h>
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/errno.h>
 #include <linux/types.h>
 #include <linux/socket.h>
@@ -20,15 +21,17 @@
 
 static DEFINE_MUTEX(genl_mutex); /* serialization of message processing */
 
-static inline void genl_lock(void)
+void genl_lock(void)
 {
         mutex_lock(&genl_mutex);
 }
+EXPORT_SYMBOL(genl_lock);
 
-static inline void genl_unlock(void)
+void genl_unlock(void)
 {
         mutex_unlock(&genl_mutex);
 }
+EXPORT_SYMBOL(genl_unlock);
 
 #define GENL_FAM_TAB_SIZE       16
 #define GENL_FAM_TAB_MASK       (GENL_FAM_TAB_SIZE - 1)
diff --git a/net/netrom/af_netrom.c b/net/netrom/af_netrom.c
index a249127020a5..06cb02796a0e 100644
--- a/net/netrom/af_netrom.c
+++ b/net/netrom/af_netrom.c
@@ -15,6 +15,7 @@
 #include <linux/types.h>
 #include <linux/socket.h>
 #include <linux/in.h>
+#include <linux/slab.h>
 #include <linux/kernel.h>
 #include <linux/sched.h>
 #include <linux/timer.h>
@@ -738,7 +739,7 @@ static int nr_connect(struct socket *sock, struct sockaddr *uaddr,
                 DEFINE_WAIT(wait);
 
                 for (;;) {
-                        prepare_to_wait(sk->sk_sleep, &wait,
+                        prepare_to_wait(sk_sleep(sk), &wait,
                                         TASK_INTERRUPTIBLE);
                         if (sk->sk_state != TCP_SYN_SENT)
                                 break;
@@ -751,7 +752,7 @@ static int nr_connect(struct socket *sock, struct sockaddr *uaddr,
                         err = -ERESTARTSYS;
                         break;
                 }
-                finish_wait(sk->sk_sleep, &wait);
+                finish_wait(sk_sleep(sk), &wait);
                 if (err)
                         goto out_release;
         }
@@ -797,7 +798,7 @@ static int nr_accept(struct socket *sock, struct socket *newsock, int flags)
          *      hooked into the SABM we saved
          */
         for (;;) {
-                prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+                prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
                 skb = skb_dequeue(&sk->sk_receive_queue);
                 if (skb)
                         break;
@@ -815,7 +816,7 @@ static int nr_accept(struct socket *sock, struct socket *newsock, int flags)
                 err = -ERESTARTSYS;
                 break;
         }
-        finish_wait(sk->sk_sleep, &wait);
+        finish_wait(sk_sleep(sk), &wait);
         if (err)
                 goto out_release;
 
diff --git a/net/netrom/nr_dev.c b/net/netrom/nr_dev.c
index 7aa11b01b2e2..64e6dde9749d 100644
--- a/net/netrom/nr_dev.c
+++ b/net/netrom/nr_dev.c
@@ -19,6 +19,7 @@
 #include <linux/fcntl.h>
 #include <linux/in.h>
 #include <linux/if_ether.h>     /* For the statistics structure. */
+#include <linux/slab.h>
 
 #include <asm/system.h>
 #include <asm/uaccess.h>
diff --git a/net/netrom/nr_in.c b/net/netrom/nr_in.c
index 68176483617f..6d4ef6d65b3d 100644
--- a/net/netrom/nr_in.c
+++ b/net/netrom/nr_in.c
@@ -16,6 +16,7 @@
 #include <linux/string.h>
 #include <linux/sockios.h>
 #include <linux/net.h>
+#include <linux/slab.h>
 #include <net/ax25.h>
 #include <linux/inet.h>
 #include <linux/netdevice.h>
diff --git a/net/netrom/nr_loopback.c b/net/netrom/nr_loopback.c
index f324d5df4186..94d4e922af53 100644
--- a/net/netrom/nr_loopback.c
+++ b/net/netrom/nr_loopback.c
@@ -7,6 +7,7 @@
  * Copyright Tomi Manninen OH2BNS (oh2bns@sral.fi)
  */
 #include <linux/types.h>
+#include <linux/slab.h>
 #include <linux/socket.h>
 #include <linux/timer.h>
 #include <net/ax25.h>
diff --git a/net/netrom/nr_out.c b/net/netrom/nr_out.c
index e3e6c44e1890..607fddb4fdbb 100644
--- a/net/netrom/nr_out.c
+++ b/net/netrom/nr_out.c
@@ -16,6 +16,7 @@
 #include <linux/string.h>
 #include <linux/sockios.h>
 #include <linux/net.h>
+#include <linux/slab.h>
 #include <net/ax25.h>
 #include <linux/inet.h>
 #include <linux/netdevice.h>
diff --git a/net/netrom/nr_route.c b/net/netrom/nr_route.c
index 5cc648012f50..44059d0c8dd1 100644
--- a/net/netrom/nr_route.c
+++ b/net/netrom/nr_route.c
@@ -17,6 +17,7 @@
 #include <linux/string.h>
 #include <linux/sockios.h>
 #include <linux/net.h>
+#include <linux/slab.h>
 #include <net/ax25.h>
 #include <linux/inet.h>
 #include <linux/netdevice.h>
diff --git a/net/netrom/nr_subr.c b/net/netrom/nr_subr.c
index 04e7d0d2fd8f..6a947ae50dbd 100644
--- a/net/netrom/nr_subr.c
+++ b/net/netrom/nr_subr.c
@@ -15,6 +15,7 @@
 #include <linux/string.h>
 #include <linux/sockios.h>
 #include <linux/net.h>
+#include <linux/slab.h>
 #include <net/ax25.h>
 #include <linux/inet.h>
 #include <linux/netdevice.h>
diff --git a/net/packet/af_packet.c b/net/packet/af_packet.c
index 1612d417d10c..2078a277e06b 100644
--- a/net/packet/af_packet.c
+++ b/net/packet/af_packet.c
@@ -60,6 +60,7 @@
 #include <linux/wireless.h>
 #include <linux/kernel.h>
 #include <linux/kmod.h>
+#include <linux/slab.h>
 #include <net/net_namespace.h>
 #include <net/ip.h>
 #include <net/protocol.h>
@@ -81,6 +82,7 @@
 #include <linux/mutex.h>
 #include <linux/if_vlan.h>
 #include <linux/virtio_net.h>
+#include <linux/errqueue.h>
 
 #ifdef CONFIG_INET
 #include <net/inet_common.h>
@@ -314,6 +316,8 @@ static inline struct packet_sock *pkt_sk(struct sock *sk)
 
 static void packet_sock_destruct(struct sock *sk)
 {
+        skb_queue_purge(&sk->sk_error_queue);
+
         WARN_ON(atomic_read(&sk->sk_rmem_alloc));
         WARN_ON(atomic_read(&sk->sk_wmem_alloc));
 
@@ -482,6 +486,9 @@ retry:
         skb->dev = dev;
         skb->priority = sk->sk_priority;
         skb->mark = sk->sk_mark;
+        err = sock_tx_timestamp(msg, sk, skb_tx(skb));
+        if (err < 0)
+                goto out_unlock;
 
         dev_queue_xmit(skb);
         rcu_read_unlock();
@@ -1187,6 +1194,9 @@ static int packet_snd(struct socket *sock,
         err = skb_copy_datagram_from_iovec(skb, offset, msg->msg_iov, 0, len);
         if (err)
                 goto out_free;
+        err = sock_tx_timestamp(msg, sk, skb_tx(skb));
+        if (err < 0)
+                goto out_free;
 
         skb->protocol = proto;
         skb->dev = dev;
@@ -1486,6 +1496,51 @@ out:
         return err;
 }
 
+static int packet_recv_error(struct sock *sk, struct msghdr *msg, int len)
+{
+        struct sock_exterr_skb *serr;
+        struct sk_buff *skb, *skb2;
+        int copied, err;
+
+        err = -EAGAIN;
+        skb = skb_dequeue(&sk->sk_error_queue);
+        if (skb == NULL)
+                goto out;
+
+        copied = skb->len;
+        if (copied > len) {
+                msg->msg_flags |= MSG_TRUNC;
+                copied = len;
+        }
+        err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
+        if (err)
+                goto out_free_skb;
+
+        sock_recv_timestamp(msg, sk, skb);
+
+        serr = SKB_EXT_ERR(skb);
+        put_cmsg(msg, SOL_PACKET, PACKET_TX_TIMESTAMP,
+                 sizeof(serr->ee), &serr->ee);
+
+        msg->msg_flags |= MSG_ERRQUEUE;
+        err = copied;
+
+        /* Reset and regenerate socket error */
+        spin_lock_bh(&sk->sk_error_queue.lock);
+        sk->sk_err = 0;
+        if ((skb2 = skb_peek(&sk->sk_error_queue)) != NULL) {
+                sk->sk_err = SKB_EXT_ERR(skb2)->ee.ee_errno;
+                spin_unlock_bh(&sk->sk_error_queue.lock);
+                sk->sk_error_report(sk);
+        } else
+                spin_unlock_bh(&sk->sk_error_queue.lock);
+
+out_free_skb:
+        kfree_skb(skb);
+out:
+        return err;
+}
+
 /*
  *      Pull a packet from our receive queue and hand it to the user.
  *      If necessary we block.
@@ -1501,7 +1556,7 @@ static int packet_recvmsg(struct kiocb *iocb, struct socket *sock,
         int vnet_hdr_len = 0;
 
         err = -EINVAL;
-        if (flags & ~(MSG_PEEK|MSG_DONTWAIT|MSG_TRUNC|MSG_CMSG_COMPAT))
+        if (flags & ~(MSG_PEEK|MSG_DONTWAIT|MSG_TRUNC|MSG_CMSG_COMPAT|MSG_ERRQUEUE))
                 goto out;
 
 #if 0
@@ -1510,6 +1565,11 @@ static int packet_recvmsg(struct kiocb *iocb, struct socket *sock,
                 return -ENODEV;
 #endif
 
+        if (flags & MSG_ERRQUEUE) {
+                err = packet_recv_error(sk, msg, len);
+                goto out;
+        }
+
         /*
          *      Call the generic datagram receiver. This handles all sorts
          *      of horrible races and re-entrancy so we can forget about it
@@ -1691,9 +1751,9 @@ static int packet_dev_mc(struct net_device *dev, struct packet_mclist *i,
                 if (i->alen != dev->addr_len)
                         return -EINVAL;
                 if (what > 0)
-                        return dev_mc_add(dev, i->addr, i->alen, 0);
+                        return dev_mc_add(dev, i->addr);
                 else
-                        return dev_mc_delete(dev, i->addr, i->alen, 0);
+                        return dev_mc_del(dev, i->addr);
                 break;
         case PACKET_MR_PROMISC:
                 return dev_set_promiscuity(dev, what);
@@ -1705,9 +1765,9 @@ static int packet_dev_mc(struct net_device *dev, struct packet_mclist *i,
                 if (i->alen != dev->addr_len)
                         return -EINVAL;
                 if (what > 0)
-                        return dev_unicast_add(dev, i->addr);
+                        return dev_uc_add(dev, i->addr);
                 else
-                        return dev_unicast_delete(dev, i->addr);
+                        return dev_uc_del(dev, i->addr);
                 break;
         default:
                 break;
@@ -2168,8 +2228,6 @@ static int packet_ioctl(struct socket *sock, unsigned int cmd,
         case SIOCGIFDSTADDR:
         case SIOCSIFDSTADDR:
         case SIOCSIFFLAGS:
-                if (!net_eq(sock_net(sk), &init_net))
-                        return -ENOIOCTLCMD;
                 return inet_dgram_ops.ioctl(sock, cmd, arg);
 #endif
 
diff --git a/net/phonet/af_phonet.c b/net/phonet/af_phonet.c
index 526d0273991a..73aee7f2fcdc 100644
--- a/net/phonet/af_phonet.c
+++ b/net/phonet/af_phonet.c
@@ -25,6 +25,7 @@
 
 #include <linux/kernel.h>
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <asm/unaligned.h>
 #include <net/sock.h>
 
diff --git a/net/phonet/datagram.c b/net/phonet/datagram.c
index 387197b579b1..1bd38db4fe1e 100644
--- a/net/phonet/datagram.c
+++ b/net/phonet/datagram.c
@@ -24,6 +24,7 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/socket.h>
 #include <asm/ioctls.h>
 #include <net/sock.h>
diff --git a/net/phonet/pep.c b/net/phonet/pep.c
index 360cf377693e..af4d38bc3b22 100644
--- a/net/phonet/pep.c
+++ b/net/phonet/pep.c
@@ -23,6 +23,7 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/socket.h>
 #include <net/sock.h>
 #include <net/tcp_states.h>
@@ -663,12 +664,12 @@ static int pep_wait_connreq(struct sock *sk, int noblock)
                 if (signal_pending(tsk))
                         return sock_intr_errno(timeo);
 
-                prepare_to_wait_exclusive(&sk->sk_socket->wait, &wait,
+                prepare_to_wait_exclusive(sk_sleep(sk), &wait,
                                                 TASK_INTERRUPTIBLE);
                 release_sock(sk);
                 timeo = schedule_timeout(timeo);
                 lock_sock(sk);
-                finish_wait(&sk->sk_socket->wait, &wait);
+                finish_wait(sk_sleep(sk), &wait);
         }
 
         return 0;
@@ -909,10 +910,10 @@ disabled:
                         goto out;
                 }
 
-                prepare_to_wait(&sk->sk_socket->wait, &wait,
+                prepare_to_wait(sk_sleep(sk), &wait,
                                 TASK_INTERRUPTIBLE);
                 done = sk_wait_event(sk, &timeo, atomic_read(&pn->tx_credits));
-                finish_wait(&sk->sk_socket->wait, &wait);
+                finish_wait(sk_sleep(sk), &wait);
 
                 if (sk->sk_state != TCP_ESTABLISHED)
                         goto disabled;
diff --git a/net/phonet/pn_dev.c b/net/phonet/pn_dev.c
index c597cc53a6fb..c33da6576942 100644
--- a/net/phonet/pn_dev.c
+++ b/net/phonet/pn_dev.c
@@ -25,6 +25,7 @@
 
 #include <linux/kernel.h>
 #include <linux/net.h>
+#include <linux/slab.h>
 #include <linux/netdevice.h>
 #include <linux/phonet.h>
 #include <linux/proc_fs.h>
@@ -45,9 +46,16 @@ struct phonet_net {
 
 int phonet_net_id __read_mostly;
 
+static struct phonet_net *phonet_pernet(struct net *net)
+{
+        BUG_ON(!net);
+
+        return net_generic(net, phonet_net_id);
+}
+
 struct phonet_device_list *phonet_device_list(struct net *net)
 {
-        struct phonet_net *pnn = net_generic(net, phonet_net_id);
+        struct phonet_net *pnn = phonet_pernet(net);
         return &pnn->pndevs;
 }
 
@@ -107,8 +115,7 @@ static void phonet_device_destroy(struct net_device *dev)
         if (pnd) {
                 u8 addr;
 
-                for (addr = find_first_bit(pnd->addrs, 64); addr < 64;
-                        addr = find_next_bit(pnd->addrs, 64, 1+addr))
+                for_each_set_bit(addr, pnd->addrs, 64)
                         phonet_address_notify(RTM_DELADDR, dev, addr);
                 kfree(pnd);
         }
@@ -261,7 +268,7 @@ static int phonet_device_autoconf(struct net_device *dev)
 
 static void phonet_route_autodel(struct net_device *dev)
 {
-        struct phonet_net *pnn = net_generic(dev_net(dev), phonet_net_id);
+        struct phonet_net *pnn = phonet_pernet(dev_net(dev));
         unsigned i;
         DECLARE_BITMAP(deleted, 64);
 
@@ -313,7 +320,7 @@ static struct notifier_block phonet_device_notifier = {
 /* Per-namespace Phonet devices handling */
 static int __net_init phonet_init_net(struct net *net)
 {
-        struct phonet_net *pnn = net_generic(net, phonet_net_id);
+        struct phonet_net *pnn = phonet_pernet(net);
 
         if (!proc_net_fops_create(net, "phonet", 0, &pn_sock_seq_fops))
                 return -ENOMEM;
@@ -326,7 +333,7 @@ static int __net_init phonet_init_net(struct net *net)
 
 static void __net_exit phonet_exit_net(struct net *net)
 {
-        struct phonet_net *pnn = net_generic(net, phonet_net_id);
+        struct phonet_net *pnn = phonet_pernet(net);
         struct net_device *dev;
         unsigned i;
 
@@ -376,7 +383,7 @@ void phonet_device_exit(void)
 
 int phonet_route_add(struct net_device *dev, u8 daddr)
 {
-        struct phonet_net *pnn = net_generic(dev_net(dev), phonet_net_id);
+        struct phonet_net *pnn = phonet_pernet(dev_net(dev));
         struct phonet_routes *routes = &pnn->routes;
         int err = -EEXIST;
 
@@ -393,7 +400,7 @@ int phonet_route_add(struct net_device *dev, u8 daddr)
 
 int phonet_route_del(struct net_device *dev, u8 daddr)
 {
-        struct phonet_net *pnn = net_generic(dev_net(dev), phonet_net_id);
+        struct phonet_net *pnn = phonet_pernet(dev_net(dev));
         struct phonet_routes *routes = &pnn->routes;
 
         daddr = daddr >> 2;
@@ -413,7 +420,7 @@ int phonet_route_del(struct net_device *dev, u8 daddr)
 
 struct net_device *phonet_route_get(struct net *net, u8 daddr)
 {
-        struct phonet_net *pnn = net_generic(net, phonet_net_id);
+        struct phonet_net *pnn = phonet_pernet(net);
         struct phonet_routes *routes = &pnn->routes;
         struct net_device *dev;
 
@@ -428,7 +435,7 @@ struct net_device *phonet_route_get(struct net *net, u8 daddr)
 
 struct net_device *phonet_route_output(struct net *net, u8 daddr)
 {
-        struct phonet_net *pnn = net_generic(net, phonet_net_id);
+        struct phonet_net *pnn = phonet_pernet(net);
         struct phonet_routes *routes = &pnn->routes;
         struct net_device *dev;
 
diff --git a/net/phonet/pn_netlink.c b/net/phonet/pn_netlink.c
index 2e6c7eb8e76a..58b3b1f991ed 100644
--- a/net/phonet/pn_netlink.c
+++ b/net/phonet/pn_netlink.c
@@ -26,6 +26,7 @@
 #include <linux/kernel.h>
 #include <linux/netlink.h>
 #include <linux/phonet.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 #include <net/phonet/pn_dev.h>
 
@@ -141,8 +142,7 @@ static int getaddr_dumpit(struct sk_buff *skb, struct netlink_callback *cb)
                         continue;
 
                 addr_idx = 0;
-                for (addr = find_first_bit(pnd->addrs, 64); addr < 64;
-                        addr = find_next_bit(pnd->addrs, 64, 1+addr)) {
+                for_each_set_bit(addr, pnd->addrs, 64) {
                         if (addr_idx++ < addr_start_idx)
                                 continue;
 
diff --git a/net/phonet/socket.c b/net/phonet/socket.c
index 69c8b826a0ce..6e9848bf0370 100644
--- a/net/phonet/socket.c
+++ b/net/phonet/socket.c
@@ -23,6 +23,7 @@
  * 02110-1301 USA
  */
 
+#include <linux/gfp.h>
 #include <linux/kernel.h>
 #include <linux/net.h>
 #include <linux/poll.h>
@@ -264,7 +265,7 @@ static unsigned int pn_socket_poll(struct file *file, struct socket *sock,
         struct pep_sock *pn = pep_sk(sk);
         unsigned int mask = 0;
 
-        poll_wait(file, &sock->wait, wait);
+        poll_wait(file, sk_sleep(sk), wait);
 
         switch (sk->sk_state) {
         case TCP_LISTEN:
diff --git a/net/rds/af_rds.c b/net/rds/af_rds.c
index 853c52be781f..aebfecbdb841 100644
--- a/net/rds/af_rds.c
+++ b/net/rds/af_rds.c
@@ -33,6 +33,7 @@
 #include <linux/module.h>
 #include <linux/errno.h>
 #include <linux/kernel.h>
+#include <linux/gfp.h>
 #include <linux/in.h>
 #include <linux/poll.h>
 #include <net/sock.h>
@@ -157,9 +158,10 @@ static unsigned int rds_poll(struct file *file, struct socket *sock,
         unsigned int mask = 0;
         unsigned long flags;
 
-        poll_wait(file, sk->sk_sleep, wait);
+        poll_wait(file, sk_sleep(sk), wait);
 
-        poll_wait(file, &rds_poll_waitq, wait);
+        if (rs->rs_seen_congestion)
+                poll_wait(file, &rds_poll_waitq, wait);
 
         read_lock_irqsave(&rs->rs_recv_lock, flags);
         if (!rs->rs_cong_monitor) {
@@ -181,6 +183,10 @@ static unsigned int rds_poll(struct file *file, struct socket *sock,
                 mask |= (POLLOUT | POLLWRNORM);
         read_unlock_irqrestore(&rs->rs_recv_lock, flags);
 
+        /* clear state any time we wake a seen-congested socket */
+        if (mask)
+                rs->rs_seen_congestion = 0;
+
         return mask;
 }
 
@@ -446,7 +452,6 @@ static void rds_sock_inc_info(struct socket *sock, unsigned int len,
                               struct rds_info_lengths *lens)
 {
         struct rds_sock *rs;
-        struct sock *sk;
         struct rds_incoming *inc;
         unsigned long flags;
         unsigned int total = 0;
@@ -456,7 +461,6 @@ static void rds_sock_inc_info(struct socket *sock, unsigned int len,
         spin_lock_irqsave(&rds_sock_lock, flags);
 
         list_for_each_entry(rs, &rds_sock_list, rs_item) {
-                sk = rds_rs_to_sk(rs);
                 read_lock(&rs->rs_recv_lock);
 
                 /* XXX too lazy to maintain counts.. */
diff --git a/net/rds/cong.c b/net/rds/cong.c
index 6d06cac2649c..0871a29f0780 100644
--- a/net/rds/cong.c
+++ b/net/rds/cong.c
@@ -30,6 +30,7 @@
  * SOFTWARE.
  *
  */
+#include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/rbtree.h>
 
@@ -218,8 +219,6 @@ void rds_cong_queue_updates(struct rds_cong_map *map)
         spin_lock_irqsave(&rds_cong_lock, flags);
 
         list_for_each_entry(conn, &map->m_conn_list, c_map_item) {
-                if (conn->c_loopback)
-                        continue;
                 if (!test_and_set_bit(0, &conn->c_map_queued)) {
                         rds_stats_inc(s_cong_update_queued);
                         queue_delayed_work(rds_wq, &conn->c_send_w, 0);
diff --git a/net/rds/connection.c b/net/rds/connection.c
index 278f607ab603..7619b671ca28 100644
--- a/net/rds/connection.c
+++ b/net/rds/connection.c
@@ -32,6 +32,7 @@
  */
 #include <linux/kernel.h>
 #include <linux/list.h>
+#include <linux/slab.h>
 #include <net/inet_hashtables.h>
 
 #include "rds.h"
diff --git a/net/rds/ib.c b/net/rds/ib.c
index 3b8992361042..8f2d6dd7700a 100644
--- a/net/rds/ib.c
+++ b/net/rds/ib.c
@@ -37,6 +37,7 @@
 #include <linux/inetdevice.h>
 #include <linux/if_arp.h>
 #include <linux/delay.h>
+#include <linux/slab.h>
 
 #include "rds.h"
 #include "ib.h"
diff --git a/net/rds/ib_cm.c b/net/rds/ib_cm.c
index 647cb8ffc39b..10ed0d55f759 100644
--- a/net/rds/ib_cm.c
+++ b/net/rds/ib_cm.c
@@ -32,6 +32,7 @@
  */
 #include <linux/kernel.h>
 #include <linux/in.h>
+#include <linux/slab.h>
 #include <linux/vmalloc.h>
 
 #include "rds.h"
@@ -203,9 +204,10 @@ static void rds_ib_qp_event_handler(struct ib_event *event, void *data)
                 rdma_notify(ic->i_cm_id, IB_EVENT_COMM_EST);
                 break;
         default:
-                rds_ib_conn_error(conn, "RDS/IB: Fatal QP Event %u "
+                rdsdebug("Fatal QP Event %u "
                         "- connection %pI4->%pI4, reconnecting\n",
                         event->event, &conn->c_laddr, &conn->c_faddr);
+                rds_conn_drop(conn);
                 break;
         }
 }
diff --git a/net/rds/ib_rdma.c b/net/rds/ib_rdma.c
index 4b0da865a72c..a54cd63f9e35 100644
--- a/net/rds/ib_rdma.c
+++ b/net/rds/ib_rdma.c
@@ -31,6 +31,7 @@
  *
  */
 #include <linux/kernel.h>
+#include <linux/slab.h>
 
 #include "rds.h"
 #include "rdma.h"
@@ -234,8 +235,8 @@ void rds_ib_destroy_mr_pool(struct rds_ib_mr_pool *pool)
 {
         flush_workqueue(rds_wq);
         rds_ib_flush_mr_pool(pool, 1);
-        BUG_ON(atomic_read(&pool->item_count));
-        BUG_ON(atomic_read(&pool->free_pinned));
+        WARN_ON(atomic_read(&pool->item_count));
+        WARN_ON(atomic_read(&pool->free_pinned));
         kfree(pool);
 }
 
@@ -440,6 +441,7 @@ static void __rds_ib_teardown_mr(struct rds_ib_mr *ibmr)
 
                         /* FIXME we need a way to tell a r/w MR
                          * from a r/o MR */
+                        BUG_ON(in_interrupt());
                         set_page_dirty(page);
                         put_page(page);
                 }
diff --git a/net/rds/ib_recv.c b/net/rds/ib_recv.c
index 04dc0d3f3c95..c74e9904a6b2 100644
--- a/net/rds/ib_recv.c
+++ b/net/rds/ib_recv.c
@@ -31,6 +31,7 @@
  *
  */
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/pci.h>
 #include <linux/dma-mapping.h>
 #include <rdma/rdma_cm.h>
@@ -468,8 +469,8 @@ static void rds_ib_send_ack(struct rds_ib_connection *ic, unsigned int adv_credi
                 set_bit(IB_ACK_REQUESTED, &ic->i_ack_flags);
 
                 rds_ib_stats_inc(s_ib_ack_send_failure);
-                /* Need to finesse this later. */
-                BUG();
+
+                rds_ib_conn_error(ic->conn, "sending ack failed\n");
         } else
                 rds_ib_stats_inc(s_ib_ack_sent);
 }
diff --git a/net/rds/ib_send.c b/net/rds/ib_send.c
index a10fab6886d1..17fa80803ab0 100644
--- a/net/rds/ib_send.c
+++ b/net/rds/ib_send.c
@@ -243,8 +243,12 @@ void rds_ib_send_cq_comp_handler(struct ib_cq *cq, void *context)
                                 struct rds_message *rm;
 
                                 rm = rds_send_get_message(conn, send->s_op);
-                                if (rm)
+                                if (rm) {
+                                        if (rm->m_rdma_op)
+                                                rds_ib_send_unmap_rdma(ic, rm->m_rdma_op);
                                         rds_ib_send_rdma_complete(rm, wc.status);
+                                        rds_message_put(rm);
+                                }
                         }
 
                         oldest = (oldest + 1) % ic->i_send_ring.w_nr;
@@ -482,6 +486,13 @@ int rds_ib_xmit(struct rds_connection *conn, struct rds_message *rm,
         BUG_ON(off % RDS_FRAG_SIZE);
         BUG_ON(hdr_off != 0 && hdr_off != sizeof(struct rds_header));
 
+        /* Do not send cong updates to IB loopback */
+        if (conn->c_loopback
+            && rm->m_inc.i_hdr.h_flags & RDS_FLAG_CONG_BITMAP) {
+                rds_cong_map_updated(conn->c_fcong, ~(u64) 0);
+                return sizeof(struct rds_header) + RDS_CONG_MAP_BYTES;
+        }
+
         /* FIXME we may overallocate here */
         if (be32_to_cpu(rm->m_inc.i_hdr.h_len) == 0)
                 i = 1;
@@ -574,8 +585,7 @@ int rds_ib_xmit(struct rds_connection *conn, struct rds_message *rm,
                 rds_ib_send_grab_credits(ic, 0, &posted, 1, RDS_MAX_ADV_CREDIT - adv_credits);
                 adv_credits += posted;
                 BUG_ON(adv_credits > 255);
-        } else if (ic->i_rm != rm)
-                BUG();
+        }
 
         send = &ic->i_sends[pos];
         first = send;
@@ -714,8 +724,8 @@ add_header:
                         ic->i_rm = prev->s_rm;
                         prev->s_rm = NULL;
                 }
-                /* Finesse this later */
-                BUG();
+
+                rds_ib_conn_error(ic->conn, "ib_post_send failed\n");
                 goto out;
         }
 
diff --git a/net/rds/info.c b/net/rds/info.c
index 814a91a6f4a7..c45c4173a44d 100644
--- a/net/rds/info.c
+++ b/net/rds/info.c
@@ -32,6 +32,7 @@
  */
 #include <linux/percpu.h>
 #include <linux/seq_file.h>
+#include <linux/slab.h>
 #include <linux/proc_fs.h>
 
 #include "rds.h"
diff --git a/net/rds/iw.c b/net/rds/iw.c
index b28fa8525b24..c8f3d3525cb9 100644
--- a/net/rds/iw.c
+++ b/net/rds/iw.c
@@ -37,6 +37,7 @@
 #include <linux/inetdevice.h>
 #include <linux/if_arp.h>
 #include <linux/delay.h>
+#include <linux/slab.h>
 
 #include "rds.h"
 #include "iw.h"
diff --git a/net/rds/iw_cm.c b/net/rds/iw_cm.c
index 394cf6b4d0aa..a9d951b4fbae 100644
--- a/net/rds/iw_cm.c
+++ b/net/rds/iw_cm.c
@@ -32,6 +32,7 @@
  */
 #include <linux/kernel.h>
 #include <linux/in.h>
+#include <linux/slab.h>
 #include <linux/vmalloc.h>
 
 #include "rds.h"
@@ -156,9 +157,11 @@ static void rds_iw_qp_event_handler(struct ib_event *event, void *data)
         case IB_EVENT_QP_REQ_ERR:
         case IB_EVENT_QP_FATAL:
         default:
-                rds_iw_conn_error(conn, "RDS/IW: Fatal QP Event %u - connection %pI4->%pI4...reconnecting\n",
+                rdsdebug("Fatal QP Event %u "
+                        "- connection %pI4->%pI4, reconnecting\n",
                         event->event, &conn->c_laddr,
                         &conn->c_faddr);
+                rds_conn_drop(conn);
                 break;
         }
 }
diff --git a/net/rds/iw_rdma.c b/net/rds/iw_rdma.c
index 9eda11cca956..13dc1862d862 100644
--- a/net/rds/iw_rdma.c
+++ b/net/rds/iw_rdma.c
@@ -31,6 +31,7 @@
  *
  */
 #include <linux/kernel.h>
+#include <linux/slab.h>
 
 #include "rds.h"
 #include "rdma.h"
diff --git a/net/rds/iw_recv.c b/net/rds/iw_recv.c
index 54af7d6b92da..3d479067d54d 100644
--- a/net/rds/iw_recv.c
+++ b/net/rds/iw_recv.c
@@ -31,6 +31,7 @@
  *
  */
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/pci.h>
 #include <linux/dma-mapping.h>
 #include <rdma/rdma_cm.h>
@@ -468,8 +469,8 @@ static void rds_iw_send_ack(struct rds_iw_connection *ic, unsigned int adv_credi
                 set_bit(IB_ACK_REQUESTED, &ic->i_ack_flags);
 
                 rds_iw_stats_inc(s_iw_ack_send_failure);
-                /* Need to finesse this later. */
-                BUG();
+
+                rds_iw_conn_error(ic->conn, "sending ack failed\n");
         } else
                 rds_iw_stats_inc(s_iw_ack_sent);
 }
diff --git a/net/rds/iw_send.c b/net/rds/iw_send.c
index 1379e9d66a78..52182ff7519e 100644
--- a/net/rds/iw_send.c
+++ b/net/rds/iw_send.c
@@ -616,8 +616,7 @@ int rds_iw_xmit(struct rds_connection *conn, struct rds_message *rm,
                 rds_iw_send_grab_credits(ic, 0, &posted, 1, RDS_MAX_ADV_CREDIT - adv_credits);
                 adv_credits += posted;
                 BUG_ON(adv_credits > 255);
-        } else if (ic->i_rm != rm)
-                BUG();
+        }
 
         send = &ic->i_sends[pos];
         first = send;
diff --git a/net/rds/loop.c b/net/rds/loop.c
index 4a61997f554d..dd9879379457 100644
--- a/net/rds/loop.c
+++ b/net/rds/loop.c
@@ -31,6 +31,7 @@
  *
  */
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/in.h>
 
 #include "rds.h"
@@ -80,16 +81,9 @@ static int rds_loop_xmit_cong_map(struct rds_connection *conn,
                                   struct rds_cong_map *map,
                                   unsigned long offset)
 {
-        unsigned long i;
-
         BUG_ON(offset);
         BUG_ON(map != conn->c_lcong);
 
-        for (i = 0; i < RDS_CONG_MAP_PAGES; i++) {
-                memcpy((void *)conn->c_fcong->m_page_addrs[i],
-                       (void *)map->m_page_addrs[i], PAGE_SIZE);
-        }
-
         rds_cong_map_updated(conn->c_fcong, ~(u64) 0);
 
         return sizeof(struct rds_header) + RDS_CONG_MAP_BYTES;
diff --git a/net/rds/message.c b/net/rds/message.c
index 73e600ffd87f..9a1d67e001ba 100644
--- a/net/rds/message.c
+++ b/net/rds/message.c
@@ -31,6 +31,7 @@
  *
  */
 #include <linux/kernel.h>
+#include <linux/slab.h>
 
 #include "rds.h"
 #include "rdma.h"
diff --git a/net/rds/page.c b/net/rds/page.c
index 36790122dfd4..595a952d4b17 100644
--- a/net/rds/page.c
+++ b/net/rds/page.c
@@ -31,6 +31,7 @@
  *
  */
 #include <linux/highmem.h>
+#include <linux/gfp.h>
 
 #include "rds.h"
 
diff --git a/net/rds/rdma.c b/net/rds/rdma.c
index 4c64daa1f5d5..75fd13bb631b 100644
--- a/net/rds/rdma.c
+++ b/net/rds/rdma.c
@@ -31,6 +31,7 @@
  *
  */
 #include <linux/pagemap.h>
+#include <linux/slab.h>
 #include <linux/rbtree.h>
 #include <linux/dma-mapping.h> /* for DMA_*_DEVICE */
 
@@ -438,8 +439,10 @@ void rds_rdma_free_op(struct rds_rdma_op *ro)
                 /* Mark page dirty if it was possibly modified, which
                  * is the case for a RDMA_READ which copies from remote
                  * to local memory */
-                if (!ro->r_write)
+                if (!ro->r_write) {
+                        BUG_ON(in_interrupt());
                         set_page_dirty(page);
+                }
                 put_page(page);
         }
 
diff --git a/net/rds/rdma_transport.c b/net/rds/rdma_transport.c
index 9ece910ea394..e599ba2f950d 100644
--- a/net/rds/rdma_transport.c
+++ b/net/rds/rdma_transport.c
@@ -101,7 +101,7 @@ int rds_rdma_cm_event_handler(struct rdma_cm_id *cm_id,
                 break;
 
         case RDMA_CM_EVENT_DISCONNECTED:
-                printk(KERN_WARNING "RDS/RDMA: DISCONNECT event - dropping connection "
+                rdsdebug("DISCONNECT event - dropping connection "
                         "%pI4->%pI4\n", &conn->c_laddr,
                          &conn->c_faddr);
                 rds_conn_drop(conn);
@@ -109,8 +109,7 @@ int rds_rdma_cm_event_handler(struct rdma_cm_id *cm_id,
 
         default:
                 /* things like device disconnect? */
-                printk(KERN_ERR "unknown event %u\n", event->event);
-                BUG();
+                printk(KERN_ERR "RDS: unknown event %u!\n", event->event);
                 break;
         }
 
@@ -134,7 +133,7 @@ static int __init rds_rdma_listen_init(void)
                 ret = PTR_ERR(cm_id);
                 printk(KERN_ERR "RDS/RDMA: failed to setup listener, "
                        "rdma_create_id() returned %d\n", ret);
-                goto out;
+                return ret;
         }
 
         sin.sin_family = AF_INET,
diff --git a/net/rds/rds.h b/net/rds/rds.h
index 85d6f897ecc7..c224b5bb3ba9 100644
--- a/net/rds/rds.h
+++ b/net/rds/rds.h
@@ -388,6 +388,8 @@ struct rds_sock {
 
         /* flag indicating we were congested or not */
         int                     rs_congested;
+        /* seen congestion (ENOBUFS) when sending? */
+        int                     rs_seen_congestion;
 
         /* rs_lock protects all these adjacent members before the newline */
         spinlock_t              rs_lock;
@@ -490,7 +492,7 @@ void rds_sock_put(struct rds_sock *rs);
 void rds_wake_sk_sleep(struct rds_sock *rs);
 static inline void __rds_wake_sk_sleep(struct sock *sk)
 {
-        wait_queue_head_t *waitq = sk->sk_sleep;
+        wait_queue_head_t *waitq = sk_sleep(sk);
 
         if (!sock_flag(sk, SOCK_DEAD) && waitq)
                 wake_up(waitq);
diff --git a/net/rds/recv.c b/net/rds/recv.c
index b426d67f760c..795a00b7f2cb 100644
--- a/net/rds/recv.c
+++ b/net/rds/recv.c
@@ -31,6 +31,7 @@
  *
  */
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 #include <linux/in.h>
 
@@ -431,7 +432,7 @@ int rds_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
                                 break;
                         }
 
-                        timeo = wait_event_interruptible_timeout(*sk->sk_sleep,
+                        timeo = wait_event_interruptible_timeout(*sk_sleep(sk),
                                         (!list_empty(&rs->rs_notify_queue) ||
                                          rs->rs_cong_notify ||
                                          rds_next_incoming(rs, &inc)), timeo);
diff --git a/net/rds/send.c b/net/rds/send.c
index b2fccfc20769..9c1c6bcaa6c9 100644
--- a/net/rds/send.c
+++ b/net/rds/send.c
@@ -31,6 +31,7 @@
  *
  */
 #include <linux/kernel.h>
+#include <linux/gfp.h>
 #include <net/sock.h>
 #include <linux/in.h>
 #include <linux/list.h>
@@ -507,12 +508,13 @@ EXPORT_SYMBOL_GPL(rds_send_get_message);
  */
 void rds_send_remove_from_sock(struct list_head *messages, int status)
 {
-        unsigned long flags = 0; /* silence gcc :P */
+        unsigned long flags;
         struct rds_sock *rs = NULL;
         struct rds_message *rm;
 
-        local_irq_save(flags);
         while (!list_empty(messages)) {
+                int was_on_sock = 0;
+
                 rm = list_entry(messages->next, struct rds_message,
                                 m_conn_item);
                 list_del_init(&rm->m_conn_item);
@@ -527,20 +529,19 @@ void rds_send_remove_from_sock(struct list_head *messages, int status)
                  * while we're messing with it. It does not prevent the
                  * message from being removed from the socket, though.
                  */
-                spin_lock(&rm->m_rs_lock);
+                spin_lock_irqsave(&rm->m_rs_lock, flags);
                 if (!test_bit(RDS_MSG_ON_SOCK, &rm->m_flags))
                         goto unlock_and_drop;
 
                 if (rs != rm->m_rs) {
                         if (rs) {
-                                spin_unlock(&rs->rs_lock);
                                 rds_wake_sk_sleep(rs);
                                 sock_put(rds_rs_to_sk(rs));
                         }
                         rs = rm->m_rs;
-                        spin_lock(&rs->rs_lock);
                         sock_hold(rds_rs_to_sk(rs));
                 }
+                spin_lock(&rs->rs_lock);
 
                 if (test_and_clear_bit(RDS_MSG_ON_SOCK, &rm->m_flags)) {
                         struct rds_rdma_op *ro = rm->m_rdma_op;
@@ -557,21 +558,22 @@ void rds_send_remove_from_sock(struct list_head *messages, int status)
                                         notifier->n_status = status;
                                 rm->m_rdma_op->r_notifier = NULL;
                         }
-                        rds_message_put(rm);
+                        was_on_sock = 1;
                         rm->m_rs = NULL;
                 }
+                spin_unlock(&rs->rs_lock);
 
 unlock_and_drop:
-                spin_unlock(&rm->m_rs_lock);
+                spin_unlock_irqrestore(&rm->m_rs_lock, flags);
                 rds_message_put(rm);
+                if (was_on_sock)
+                        rds_message_put(rm);
         }
 
         if (rs) {
-                spin_unlock(&rs->rs_lock);
                 rds_wake_sk_sleep(rs);
                 sock_put(rds_rs_to_sk(rs));
         }
-        local_irq_restore(flags);
 }
 
 /*
@@ -633,9 +635,6 @@ void rds_send_drop_to(struct rds_sock *rs, struct sockaddr_in *dest)
                 list_move(&rm->m_sock_item, &list);
                 rds_send_sndbuf_remove(rs, rm);
                 clear_bit(RDS_MSG_ON_SOCK, &rm->m_flags);
-
-                /* If this is a RDMA operation, notify the app. */
-                __rds_rdma_send_complete(rs, rm, RDS_RDMA_CANCELED);
         }
 
         /* order flag updates with the rs lock */
@@ -644,9 +643,6 @@ void rds_send_drop_to(struct rds_sock *rs, struct sockaddr_in *dest)
 
         spin_unlock_irqrestore(&rs->rs_lock, flags);
 
-        if (wake)
-                rds_wake_sk_sleep(rs);
-
         conn = NULL;
 
         /* now remove the messages from the conn list as needed */
@@ -654,6 +650,10 @@ void rds_send_drop_to(struct rds_sock *rs, struct sockaddr_in *dest)
                 /* We do this here rather than in the loop above, so that
                  * we don't have to nest m_rs_lock under rs->rs_lock */
                 spin_lock_irqsave(&rm->m_rs_lock, flags2);
+                /* If this is a RDMA operation, notify the app. */
+                spin_lock(&rs->rs_lock);
+                __rds_rdma_send_complete(rs, rm, RDS_RDMA_CANCELED);
+                spin_unlock(&rs->rs_lock);
                 rm->m_rs = NULL;
                 spin_unlock_irqrestore(&rm->m_rs_lock, flags2);
 
@@ -682,6 +682,9 @@ void rds_send_drop_to(struct rds_sock *rs, struct sockaddr_in *dest)
         if (conn)
                 spin_unlock_irqrestore(&conn->c_lock, flags);
 
+        if (wake)
+                rds_wake_sk_sleep(rs);
+
         while (!list_empty(&list)) {
                 rm = list_entry(list.next, struct rds_message, m_sock_item);
                 list_del_init(&rm->m_sock_item);
@@ -815,7 +818,7 @@ int rds_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
         int ret = 0;
         int queued = 0, allocated_mr = 0;
         int nonblock = msg->msg_flags & MSG_DONTWAIT;
-        long timeo = sock_rcvtimeo(sk, nonblock);
+        long timeo = sock_sndtimeo(sk, nonblock);
 
         /* Mirror Linux UDP mirror of BSD error message compatibility */
         /* XXX: Perhaps MSG_MORE someday */
@@ -894,8 +897,10 @@ int rds_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
                 queue_delayed_work(rds_wq, &conn->c_conn_w, 0);
 
         ret = rds_cong_wait(conn->c_fcong, dport, nonblock, rs);
-        if (ret)
+        if (ret) {
+                rs->rs_seen_congestion = 1;
                 goto out;
+        }
 
         while (!rds_send_queue_rm(rs, conn, rm, rs->rs_bound_port,
                                   dport, &queued)) {
@@ -910,7 +915,7 @@ int rds_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
                         goto out;
                 }
 
-                timeo = wait_event_interruptible_timeout(*sk->sk_sleep,
+                timeo = wait_event_interruptible_timeout(*sk_sleep(sk),
                                         rds_send_queue_rm(rs, conn, rm,
                                                           rs->rs_bound_port,
                                                           dport,
diff --git a/net/rds/tcp.c b/net/rds/tcp.c
index b5198aee45d3..babf4577ff7d 100644
--- a/net/rds/tcp.c
+++ b/net/rds/tcp.c
@@ -31,6 +31,7 @@
  *
  */
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/in.h>
 #include <net/tcp.h>
 
diff --git a/net/rds/tcp_listen.c b/net/rds/tcp_listen.c
index 53cb1b54165d..975183fe6950 100644
--- a/net/rds/tcp_listen.c
+++ b/net/rds/tcp_listen.c
@@ -31,6 +31,7 @@
  *
  */
 #include <linux/kernel.h>
+#include <linux/gfp.h>
 #include <linux/in.h>
 #include <net/tcp.h>
 
diff --git a/net/rds/tcp_recv.c b/net/rds/tcp_recv.c
index c00dafffbb5a..1aba6878fa5d 100644
--- a/net/rds/tcp_recv.c
+++ b/net/rds/tcp_recv.c
@@ -31,6 +31,7 @@
  *
  */
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <net/tcp.h>
 
 #include "rds.h"
@@ -97,6 +98,7 @@ int rds_tcp_inc_copy_to_user(struct rds_incoming *inc, struct iovec *first_iov,
                                 goto out;
                         }
 
+                        rds_stats_add(s_copy_to_user, to_copy);
                         size -= to_copy;
                         ret += to_copy;
                         skb_off += to_copy;
diff --git a/net/rds/tcp_send.c b/net/rds/tcp_send.c
index 34fdcc059e54..a28b895ff0d1 100644
--- a/net/rds/tcp_send.c
+++ b/net/rds/tcp_send.c
@@ -240,7 +240,9 @@ void rds_tcp_write_space(struct sock *sk)
         tc->t_last_seen_una = rds_tcp_snd_una(tc);
         rds_send_drop_acked(conn, rds_tcp_snd_una(tc), rds_tcp_is_acked);
 
-        queue_delayed_work(rds_wq, &conn->c_send_w, 0);
+        if ((atomic_read(&sk->sk_wmem_alloc) << 1) <= sk->sk_sndbuf)
+                queue_delayed_work(rds_wq, &conn->c_send_w, 0);
+
 out:
         read_unlock(&sk->sk_callback_lock);
 
diff --git a/net/rds/threads.c b/net/rds/threads.c
index 00fa10e59af8..786c20eaaf5e 100644
--- a/net/rds/threads.c
+++ b/net/rds/threads.c
@@ -259,7 +259,7 @@ void rds_threads_exit(void)
 
 int __init rds_threads_init(void)
 {
-        rds_wq = create_singlethread_workqueue("krdsd");
+        rds_wq = create_workqueue("krdsd");
         if (rds_wq == NULL)
                 return -ENOMEM;
 
diff --git a/net/rfkill/core.c b/net/rfkill/core.c
index 7ae58b5b5a08..51875a0c5d48 100644
--- a/net/rfkill/core.c
+++ b/net/rfkill/core.c
@@ -33,6 +33,7 @@
 #include <linux/wait.h>
 #include <linux/poll.h>
 #include <linux/fs.h>
+#include <linux/slab.h>
 
 #include "rfkill.h"
 
diff --git a/net/rose/af_rose.c b/net/rose/af_rose.c
index e90b9b6c16ae..8e45e76a95f5 100644
--- a/net/rose/af_rose.c
+++ b/net/rose/af_rose.c
@@ -18,6 +18,7 @@
 #include <linux/types.h>
 #include <linux/socket.h>
 #include <linux/in.h>
+#include <linux/slab.h>
 #include <linux/kernel.h>
 #include <linux/sched.h>
 #include <linux/spinlock.h>
@@ -844,7 +845,7 @@ rose_try_next_neigh:
                 DEFINE_WAIT(wait);
 
                 for (;;) {
-                        prepare_to_wait(sk->sk_sleep, &wait,
+                        prepare_to_wait(sk_sleep(sk), &wait,
                                         TASK_INTERRUPTIBLE);
                         if (sk->sk_state != TCP_SYN_SENT)
                                 break;
@@ -857,7 +858,7 @@ rose_try_next_neigh:
                         err = -ERESTARTSYS;
                         break;
                 }
-                finish_wait(sk->sk_sleep, &wait);
+                finish_wait(sk_sleep(sk), &wait);
 
                 if (err)
                         goto out_release;
@@ -910,7 +911,7 @@ static int rose_accept(struct socket *sock, struct socket *newsock, int flags)
          *      hooked into the SABM we saved
          */
         for (;;) {
-                prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+                prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
 
                 skb = skb_dequeue(&sk->sk_receive_queue);
                 if (skb)
@@ -929,7 +930,7 @@ static int rose_accept(struct socket *sock, struct socket *newsock, int flags)
                 err = -ERESTARTSYS;
                 break;
         }
-        finish_wait(sk->sk_sleep, &wait);
+        finish_wait(sk_sleep(sk), &wait);
         if (err)
                 goto out_release;
 
diff --git a/net/rose/rose_dev.c b/net/rose/rose_dev.c
index 424b893d1450..178ff4f73c85 100644
--- a/net/rose/rose_dev.c
+++ b/net/rose/rose_dev.c
@@ -19,6 +19,7 @@
 #include <linux/fcntl.h>
 #include <linux/in.h>
 #include <linux/if_ether.h>
+#include <linux/slab.h>
 
 #include <asm/system.h>
 #include <asm/io.h>
diff --git a/net/rose/rose_link.c b/net/rose/rose_link.c
index 5ef5f6988a2e..a750a28e0221 100644
--- a/net/rose/rose_link.c
+++ b/net/rose/rose_link.c
@@ -16,6 +16,7 @@
 #include <linux/string.h>
 #include <linux/sockios.h>
 #include <linux/net.h>
+#include <linux/slab.h>
 #include <net/ax25.h>
 #include <linux/inet.h>
 #include <linux/netdevice.h>
diff --git a/net/rose/rose_loopback.c b/net/rose/rose_loopback.c
index 968e8bac1b5d..ae4a9d99aec7 100644
--- a/net/rose/rose_loopback.c
+++ b/net/rose/rose_loopback.c
@@ -7,6 +7,7 @@
  * Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
  */
 #include <linux/types.h>
+#include <linux/slab.h>
 #include <linux/socket.h>
 #include <linux/timer.h>
 #include <net/ax25.h>
diff --git a/net/rose/rose_out.c b/net/rose/rose_out.c
index 69820f93414b..4ebf33afbe47 100644
--- a/net/rose/rose_out.c
+++ b/net/rose/rose_out.c
@@ -15,6 +15,7 @@
 #include <linux/string.h>
 #include <linux/sockios.h>
 #include <linux/net.h>
+#include <linux/gfp.h>
 #include <net/ax25.h>
 #include <linux/inet.h>
 #include <linux/netdevice.h>
diff --git a/net/rose/rose_route.c b/net/rose/rose_route.c
index 70a0b3b4b4d2..cbc244a128bd 100644
--- a/net/rose/rose_route.c
+++ b/net/rose/rose_route.c
@@ -16,6 +16,7 @@
 #include <linux/string.h>
 #include <linux/sockios.h>
 #include <linux/net.h>
+#include <linux/slab.h>
 #include <net/ax25.h>
 #include <linux/inet.h>
 #include <linux/netdevice.h>
diff --git a/net/rose/rose_subr.c b/net/rose/rose_subr.c
index b05108f382da..1734abba26a2 100644
--- a/net/rose/rose_subr.c
+++ b/net/rose/rose_subr.c
@@ -15,6 +15,7 @@
 #include <linux/string.h>
 #include <linux/sockios.h>
 #include <linux/net.h>
+#include <linux/slab.h>
 #include <net/ax25.h>
 #include <linux/inet.h>
 #include <linux/netdevice.h>
diff --git a/net/rxrpc/af_rxrpc.c b/net/rxrpc/af_rxrpc.c
index 287b1415cee9..0b9bb2085ce4 100644
--- a/net/rxrpc/af_rxrpc.c
+++ b/net/rxrpc/af_rxrpc.c
@@ -11,6 +11,7 @@
 
 #include <linux/module.h>
 #include <linux/net.h>
+#include <linux/slab.h>
 #include <linux/skbuff.h>
 #include <linux/poll.h>
 #include <linux/proc_fs.h>
@@ -61,13 +62,15 @@ static inline int rxrpc_writable(struct sock *sk)
 static void rxrpc_write_space(struct sock *sk)
 {
         _enter("%p", sk);
-        read_lock(&sk->sk_callback_lock);
+        rcu_read_lock();
         if (rxrpc_writable(sk)) {
-                if (sk_has_sleeper(sk))
-                        wake_up_interruptible(sk->sk_sleep);
+                struct socket_wq *wq = rcu_dereference(sk->sk_wq);
+
+                if (wq_has_sleeper(wq))
+                        wake_up_interruptible(&wq->wait);
                 sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
         }
-        read_unlock(&sk->sk_callback_lock);
+        rcu_read_unlock();
 }
 
 /*
@@ -588,7 +591,7 @@ static unsigned int rxrpc_poll(struct file *file, struct socket *sock,
         unsigned int mask;
         struct sock *sk = sock->sk;
 
-        sock_poll_wait(file, sk->sk_sleep, wait);
+        sock_poll_wait(file, sk_sleep(sk), wait);
         mask = 0;
 
         /* the socket is readable if there are any messages waiting on the Rx
diff --git a/net/rxrpc/ar-accept.c b/net/rxrpc/ar-accept.c
index 77228f28fa36..6d79310fcaae 100644
--- a/net/rxrpc/ar-accept.c
+++ b/net/rxrpc/ar-accept.c
@@ -17,6 +17,7 @@
 #include <linux/in.h>
 #include <linux/in6.h>
 #include <linux/icmp.h>
+#include <linux/gfp.h>
 #include <net/sock.h>
 #include <net/af_rxrpc.h>
 #include <net/ip.h>
@@ -88,6 +89,11 @@ static int rxrpc_accept_incoming_call(struct rxrpc_local *local,
 
         /* get a notification message to send to the server app */
         notification = alloc_skb(0, GFP_NOFS);
+        if (!notification) {
+                _debug("no memory");
+                ret = -ENOMEM;
+                goto error_nofree;
+        }
         rxrpc_new_skb(notification);
         notification->mark = RXRPC_SKB_MARK_NEW_CALL;
 
@@ -189,6 +195,7 @@ invalid_service:
         ret = -ECONNREFUSED;
 error:
         rxrpc_free_skb(notification);
+error_nofree:
         _leave(" = %d", ret);
         return ret;
 }
diff --git a/net/rxrpc/ar-ack.c b/net/rxrpc/ar-ack.c
index b4a220977031..2714da167fb8 100644
--- a/net/rxrpc/ar-ack.c
+++ b/net/rxrpc/ar-ack.c
@@ -13,6 +13,7 @@
 #include <linux/circ_buf.h>
 #include <linux/net.h>
 #include <linux/skbuff.h>
+#include <linux/slab.h>
 #include <linux/udp.h>
 #include <net/sock.h>
 #include <net/af_rxrpc.h>
diff --git a/net/rxrpc/ar-call.c b/net/rxrpc/ar-call.c
index bc0019f704fe..909d092de9f4 100644
--- a/net/rxrpc/ar-call.c
+++ b/net/rxrpc/ar-call.c
@@ -9,6 +9,7 @@
  * 2 of the License, or (at your option) any later version.
  */
 
+#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/circ_buf.h>
 #include <net/sock.h>
diff --git a/net/rxrpc/ar-connection.c b/net/rxrpc/ar-connection.c
index 9f1ce841a0bb..4106ca95ec86 100644
--- a/net/rxrpc/ar-connection.c
+++ b/net/rxrpc/ar-connection.c
@@ -10,6 +10,7 @@
  */
 
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/net.h>
 #include <linux/skbuff.h>
 #include <linux/crypto.h>
diff --git a/net/rxrpc/ar-input.c b/net/rxrpc/ar-input.c
index f98c8027e5c1..89315009bab1 100644
--- a/net/rxrpc/ar-input.c
+++ b/net/rxrpc/ar-input.c
@@ -17,6 +17,7 @@
 #include <linux/in.h>
 #include <linux/in6.h>
 #include <linux/icmp.h>
+#include <linux/gfp.h>
 #include <net/sock.h>
 #include <net/af_rxrpc.h>
 #include <net/ip.h>
diff --git a/net/rxrpc/ar-key.c b/net/rxrpc/ar-key.c
index 74697b200496..5ee16f0353fe 100644
--- a/net/rxrpc/ar-key.c
+++ b/net/rxrpc/ar-key.c
@@ -18,6 +18,7 @@
 #include <linux/key-type.h>
 #include <linux/crypto.h>
 #include <linux/ctype.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 #include <net/af_rxrpc.h>
 #include <keys/rxrpc-type.h>
diff --git a/net/rxrpc/ar-local.c b/net/rxrpc/ar-local.c
index 807535ff29b5..87f7135d238b 100644
--- a/net/rxrpc/ar-local.c
+++ b/net/rxrpc/ar-local.c
@@ -12,6 +12,7 @@
 #include <linux/module.h>
 #include <linux/net.h>
 #include <linux/skbuff.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 #include <net/af_rxrpc.h>
 #include "ar-internal.h"
diff --git a/net/rxrpc/ar-output.c b/net/rxrpc/ar-output.c
index cc9102c5b588..5f22e263eda7 100644
--- a/net/rxrpc/ar-output.c
+++ b/net/rxrpc/ar-output.c
@@ -10,6 +10,7 @@
  */
 
 #include <linux/net.h>
+#include <linux/gfp.h>
 #include <linux/skbuff.h>
 #include <linux/circ_buf.h>
 #include <net/sock.h>
diff --git a/net/rxrpc/ar-peer.c b/net/rxrpc/ar-peer.c
index edc026c1eb76..f0f85b0123f7 100644
--- a/net/rxrpc/ar-peer.c
+++ b/net/rxrpc/ar-peer.c
@@ -16,6 +16,7 @@
 #include <linux/in.h>
 #include <linux/in6.h>
 #include <linux/icmp.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 #include <net/af_rxrpc.h>
 #include <net/ip.h>
diff --git a/net/rxrpc/ar-recvmsg.c b/net/rxrpc/ar-recvmsg.c
index 60c2b94e6b54..0c65013e3bfe 100644
--- a/net/rxrpc/ar-recvmsg.c
+++ b/net/rxrpc/ar-recvmsg.c
@@ -91,7 +91,7 @@ int rxrpc_recvmsg(struct kiocb *iocb, struct socket *sock,
 
                         /* wait for a message to turn up */
                         release_sock(&rx->sk);
-                        prepare_to_wait_exclusive(rx->sk.sk_sleep, &wait,
+                        prepare_to_wait_exclusive(sk_sleep(&rx->sk), &wait,
                                                   TASK_INTERRUPTIBLE);
                         ret = sock_error(&rx->sk);
                         if (ret)
@@ -102,7 +102,7 @@ int rxrpc_recvmsg(struct kiocb *iocb, struct socket *sock,
                                         goto wait_interrupted;
                                 timeo = schedule_timeout(timeo);
                         }
-                        finish_wait(rx->sk.sk_sleep, &wait);
+                        finish_wait(sk_sleep(&rx->sk), &wait);
                         lock_sock(&rx->sk);
                         continue;
                 }
@@ -356,7 +356,7 @@ csum_copy_error:
 wait_interrupted:
         ret = sock_intr_errno(timeo);
 wait_error:
-        finish_wait(rx->sk.sk_sleep, &wait);
+        finish_wait(sk_sleep(&rx->sk), &wait);
         if (continue_call)
                 rxrpc_put_call(continue_call);
         if (copied)
diff --git a/net/rxrpc/ar-transport.c b/net/rxrpc/ar-transport.c
index 0936e1acc30e..5e0226fe587e 100644
--- a/net/rxrpc/ar-transport.c
+++ b/net/rxrpc/ar-transport.c
@@ -12,6 +12,7 @@
 #include <linux/module.h>
 #include <linux/net.h>
 #include <linux/skbuff.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 #include <net/af_rxrpc.h>
 #include "ar-internal.h"
diff --git a/net/rxrpc/rxkad.c b/net/rxrpc/rxkad.c
index 713ac593e2e9..7635107726ce 100644
--- a/net/rxrpc/rxkad.c
+++ b/net/rxrpc/rxkad.c
@@ -16,6 +16,7 @@
 #include <linux/crypto.h>
 #include <linux/scatterlist.h>
 #include <linux/ctype.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 #include <net/af_rxrpc.h>
 #include <keys/rxrpc-type.h>
diff --git a/net/sched/Kconfig b/net/sched/Kconfig
index 21f9c7678aa3..2f691fb180d1 100644
--- a/net/sched/Kconfig
+++ b/net/sched/Kconfig
@@ -328,13 +328,16 @@ config NET_CLS_FLOW
           module will be called cls_flow.
 
 config NET_CLS_CGROUP
-        bool "Control Group Classifier"
+        tristate "Control Group Classifier"
         select NET_CLS
         depends on CGROUPS
         ---help---
           Say Y here if you want to classify packets based on the control
           cgroup of their process.
 
+          To compile this code as a module, choose M here: the
+          module will be called cls_cgroup.
+
 config NET_EMATCH
         bool "Extended Matches"
         select NET_CLS
diff --git a/net/sched/act_api.c b/net/sched/act_api.c
index 64f5e328cee9..019045174fc3 100644
--- a/net/sched/act_api.c
+++ b/net/sched/act_api.c
@@ -15,6 +15,7 @@
 #include <linux/kernel.h>
 #include <linux/string.h>
 #include <linux/errno.h>
+#include <linux/slab.h>
 #include <linux/skbuff.h>
 #include <linux/init.h>
 #include <linux/kmod.h>
@@ -667,7 +668,8 @@ nlmsg_failure:
 }
 
 static int
-act_get_notify(u32 pid, struct nlmsghdr *n, struct tc_action *a, int event)
+act_get_notify(struct net *net, u32 pid, struct nlmsghdr *n,
+               struct tc_action *a, int event)
 {
         struct sk_buff *skb;
 
@@ -679,7 +681,7 @@ act_get_notify(u32 pid, struct nlmsghdr *n, struct tc_action *a, int event)
                 return -EINVAL;
         }
 
-        return rtnl_unicast(skb, &init_net, pid);
+        return rtnl_unicast(skb, net, pid);
 }
 
 static struct tc_action *
@@ -749,7 +751,8 @@ static struct tc_action *create_a(int i)
         return act;
 }
 
-static int tca_action_flush(struct nlattr *nla, struct nlmsghdr *n, u32 pid)
+static int tca_action_flush(struct net *net, struct nlattr *nla,
+                            struct nlmsghdr *n, u32 pid)
 {
         struct sk_buff *skb;
         unsigned char *b;
@@ -808,7 +811,7 @@ static int tca_action_flush(struct nlattr *nla, struct nlmsghdr *n, u32 pid)
         nlh->nlmsg_flags |= NLM_F_ROOT;
         module_put(a->ops->owner);
         kfree(a);
-        err = rtnetlink_send(skb, &init_net, pid, RTNLGRP_TC, n->nlmsg_flags&NLM_F_ECHO);
+        err = rtnetlink_send(skb, net, pid, RTNLGRP_TC, n->nlmsg_flags&NLM_F_ECHO);
         if (err > 0)
                 return 0;
 
@@ -825,7 +828,8 @@ noflush_out:
 }
 
 static int
-tca_action_gd(struct nlattr *nla, struct nlmsghdr *n, u32 pid, int event)
+tca_action_gd(struct net *net, struct nlattr *nla, struct nlmsghdr *n,
+              u32 pid, int event)
 {
         int i, ret;
         struct nlattr *tb[TCA_ACT_MAX_PRIO+1];
@@ -837,7 +841,7 @@ tca_action_gd(struct nlattr *nla, struct nlmsghdr *n, u32 pid, int event)
 
         if (event == RTM_DELACTION && n->nlmsg_flags&NLM_F_ROOT) {
                 if (tb[1] != NULL)
-                        return tca_action_flush(tb[1], n, pid);
+                        return tca_action_flush(net, tb[1], n, pid);
                 else
                         return -EINVAL;
         }
@@ -858,7 +862,7 @@ tca_action_gd(struct nlattr *nla, struct nlmsghdr *n, u32 pid, int event)
         }
 
         if (event == RTM_GETACTION)
-                ret = act_get_notify(pid, n, head, event);
+                ret = act_get_notify(net, pid, n, head, event);
         else { /* delete */
                 struct sk_buff *skb;
 
@@ -877,7 +881,7 @@ tca_action_gd(struct nlattr *nla, struct nlmsghdr *n, u32 pid, int event)
 
                 /* now do the delete */
                 tcf_action_destroy(head, 0);
-                ret = rtnetlink_send(skb, &init_net, pid, RTNLGRP_TC,
+                ret = rtnetlink_send(skb, net, pid, RTNLGRP_TC,
                                      n->nlmsg_flags&NLM_F_ECHO);
                 if (ret > 0)
                         return 0;
@@ -888,8 +892,8 @@ err:
         return ret;
 }
 
-static int tcf_add_notify(struct tc_action *a, u32 pid, u32 seq, int event,
-                          u16 flags)
+static int tcf_add_notify(struct net *net, struct tc_action *a,
+                          u32 pid, u32 seq, int event, u16 flags)
 {
         struct tcamsg *t;
         struct nlmsghdr *nlh;
@@ -922,7 +926,7 @@ static int tcf_add_notify(struct tc_action *a, u32 pid, u32 seq, int event,
         nlh->nlmsg_len = skb_tail_pointer(skb) - b;
         NETLINK_CB(skb).dst_group = RTNLGRP_TC;
 
-        err = rtnetlink_send(skb, &init_net, pid, RTNLGRP_TC, flags&NLM_F_ECHO);
+        err = rtnetlink_send(skb, net, pid, RTNLGRP_TC, flags&NLM_F_ECHO);
         if (err > 0)
                 err = 0;
         return err;
@@ -935,7 +939,8 @@ nlmsg_failure:
 
 
 static int
-tcf_action_add(struct nlattr *nla, struct nlmsghdr *n, u32 pid, int ovr)
+tcf_action_add(struct net *net, struct nlattr *nla, struct nlmsghdr *n,
+               u32 pid, int ovr)
 {
         int ret = 0;
         struct tc_action *act;
@@ -953,7 +958,7 @@ tcf_action_add(struct nlattr *nla, struct nlmsghdr *n, u32 pid, int ovr)
         /* dump then free all the actions after update; inserted policy
          * stays intact
          * */
-        ret = tcf_add_notify(act, pid, seq, RTM_NEWACTION, n->nlmsg_flags);
+        ret = tcf_add_notify(net, act, pid, seq, RTM_NEWACTION, n->nlmsg_flags);
         for (a = act; a; a = act) {
                 act = a->next;
                 kfree(a);
@@ -969,9 +974,6 @@ static int tc_ctl_action(struct sk_buff *skb, struct nlmsghdr *n, void *arg)
         u32 pid = skb ? NETLINK_CB(skb).pid : 0;
         int ret = 0, ovr = 0;
 
-        if (!net_eq(net, &init_net))
-                return -EINVAL;
-
         ret = nlmsg_parse(n, sizeof(struct tcamsg), tca, TCA_ACT_MAX, NULL);
         if (ret < 0)
                 return ret;
@@ -994,15 +996,17 @@ static int tc_ctl_action(struct sk_buff *skb, struct nlmsghdr *n, void *arg)
                 if (n->nlmsg_flags&NLM_F_REPLACE)
                         ovr = 1;
 replay:
-                ret = tcf_action_add(tca[TCA_ACT_TAB], n, pid, ovr);
+                ret = tcf_action_add(net, tca[TCA_ACT_TAB], n, pid, ovr);
                 if (ret == -EAGAIN)
                         goto replay;
                 break;
         case RTM_DELACTION:
-                ret = tca_action_gd(tca[TCA_ACT_TAB], n, pid, RTM_DELACTION);
+                ret = tca_action_gd(net, tca[TCA_ACT_TAB], n,
+                                    pid, RTM_DELACTION);
                 break;
         case RTM_GETACTION:
-                ret = tca_action_gd(tca[TCA_ACT_TAB], n, pid, RTM_GETACTION);
+                ret = tca_action_gd(net, tca[TCA_ACT_TAB], n,
+                                    pid, RTM_GETACTION);
                 break;
         default:
                 BUG();
@@ -1042,7 +1046,6 @@ find_dump_kind(const struct nlmsghdr *n)
 static int
 tc_dump_action(struct sk_buff *skb, struct netlink_callback *cb)
 {
-        struct net *net = sock_net(skb->sk);
         struct nlmsghdr *nlh;
         unsigned char *b = skb_tail_pointer(skb);
         struct nlattr *nest;
@@ -1052,9 +1055,6 @@ tc_dump_action(struct sk_buff *skb, struct netlink_callback *cb)
         struct tcamsg *t = (struct tcamsg *) NLMSG_DATA(cb->nlh);
         struct nlattr *kind = find_dump_kind(cb->nlh);
 
-        if (!net_eq(net, &init_net))
-                return 0;
-
         if (kind == NULL) {
                 printk("tc_dump_action: action bad kind\n");
                 return 0;
diff --git a/net/sched/act_ipt.c b/net/sched/act_ipt.c
index 082c520b0def..da27a170b6b7 100644
--- a/net/sched/act_ipt.c
+++ b/net/sched/act_ipt.c
@@ -19,6 +19,7 @@
 #include <linux/rtnetlink.h>
 #include <linux/module.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <net/netlink.h>
 #include <net/pkt_sched.h>
 #include <linux/tc_act/tc_ipt.h>
diff --git a/net/sched/act_mirred.c b/net/sched/act_mirred.c
index d329170243cb..c046682054eb 100644
--- a/net/sched/act_mirred.c
+++ b/net/sched/act_mirred.c
@@ -20,6 +20,7 @@
 #include <linux/rtnetlink.h>
 #include <linux/module.h>
 #include <linux/init.h>
+#include <linux/gfp.h>
 #include <net/net_namespace.h>
 #include <net/netlink.h>
 #include <net/pkt_sched.h>
diff --git a/net/sched/act_pedit.c b/net/sched/act_pedit.c
index 6b0359a500e6..b7dcfedc802e 100644
--- a/net/sched/act_pedit.c
+++ b/net/sched/act_pedit.c
@@ -17,6 +17,7 @@
 #include <linux/rtnetlink.h>
 #include <linux/module.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <net/netlink.h>
 #include <net/pkt_sched.h>
 #include <linux/tc_act/tc_pedit.h>
diff --git a/net/sched/act_police.c b/net/sched/act_police.c
index 723964c3ee4f..654f73dff7c1 100644
--- a/net/sched/act_police.c
+++ b/net/sched/act_police.c
@@ -18,6 +18,7 @@
 #include <linux/skbuff.h>
 #include <linux/rtnetlink.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <net/act_api.h>
 #include <net/netlink.h>
 
diff --git a/net/sched/act_simple.c b/net/sched/act_simple.c
index 8daa1ebc7413..622ca809c15c 100644
--- a/net/sched/act_simple.c
+++ b/net/sched/act_simple.c
@@ -11,6 +11,7 @@
  */
 
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/skbuff.h>
diff --git a/net/sched/cls_api.c b/net/sched/cls_api.c
index 3725d8fa29db..5fd0c28ef79a 100644
--- a/net/sched/cls_api.c
+++ b/net/sched/cls_api.c
@@ -24,6 +24,7 @@
 #include <linux/kmod.h>
 #include <linux/netlink.h>
 #include <linux/err.h>
+#include <linux/slab.h>
 #include <net/net_namespace.h>
 #include <net/sock.h>
 #include <net/netlink.h>
@@ -98,8 +99,9 @@ out:
 }
 EXPORT_SYMBOL(unregister_tcf_proto_ops);
 
-static int tfilter_notify(struct sk_buff *oskb, struct nlmsghdr *n,
-                          struct tcf_proto *tp, unsigned long fh, int event);
+static int tfilter_notify(struct net *net, struct sk_buff *oskb,
+                          struct nlmsghdr *n, struct tcf_proto *tp,
+                          unsigned long fh, int event);
 
 
 /* Select new prio value from the range, managed by kernel. */
@@ -137,9 +139,6 @@ static int tc_ctl_tfilter(struct sk_buff *skb, struct nlmsghdr *n, void *arg)
         int err;
         int tp_created = 0;
 
-        if (!net_eq(net, &init_net))
-                return -EINVAL;
-
 replay:
         t = NLMSG_DATA(n);
         protocol = TC_H_MIN(t->tcm_info);
@@ -158,7 +157,7 @@ replay:
         /* Find head of filter chain. */
 
         /* Find link */
-        dev = __dev_get_by_index(&init_net, t->tcm_ifindex);
+        dev = __dev_get_by_index(net, t->tcm_ifindex);
         if (dev == NULL)
                 return -ENODEV;
 
@@ -282,7 +281,7 @@ replay:
                         *back = tp->next;
                         spin_unlock_bh(root_lock);
 
-                        tfilter_notify(skb, n, tp, fh, RTM_DELTFILTER);
+                        tfilter_notify(net, skb, n, tp, fh, RTM_DELTFILTER);
                         tcf_destroy(tp);
                         err = 0;
                         goto errout;
@@ -305,10 +304,10 @@ replay:
                 case RTM_DELTFILTER:
                         err = tp->ops->delete(tp, fh);
                         if (err == 0)
-                                tfilter_notify(skb, n, tp, fh, RTM_DELTFILTER);
+                                tfilter_notify(net, skb, n, tp, fh, RTM_DELTFILTER);
                         goto errout;
                 case RTM_GETTFILTER:
-                        err = tfilter_notify(skb, n, tp, fh, RTM_NEWTFILTER);
+                        err = tfilter_notify(net, skb, n, tp, fh, RTM_NEWTFILTER);
                         goto errout;
                 default:
                         err = -EINVAL;
@@ -324,7 +323,7 @@ replay:
                         *back = tp;
                         spin_unlock_bh(root_lock);
                 }
-                tfilter_notify(skb, n, tp, fh, RTM_NEWTFILTER);
+                tfilter_notify(net, skb, n, tp, fh, RTM_NEWTFILTER);
         } else {
                 if (tp_created)
                         tcf_destroy(tp);
@@ -370,8 +369,9 @@ nla_put_failure:
         return -1;
 }
 
-static int tfilter_notify(struct sk_buff *oskb, struct nlmsghdr *n,
-                          struct tcf_proto *tp, unsigned long fh, int event)
+static int tfilter_notify(struct net *net, struct sk_buff *oskb,
+                          struct nlmsghdr *n, struct tcf_proto *tp,
+                          unsigned long fh, int event)
 {
         struct sk_buff *skb;
         u32 pid = oskb ? NETLINK_CB(oskb).pid : 0;
@@ -385,7 +385,7 @@ static int tfilter_notify(struct sk_buff *oskb, struct nlmsghdr *n,
                 return -EINVAL;
         }
 
-        return rtnetlink_send(skb, &init_net, pid, RTNLGRP_TC,
+        return rtnetlink_send(skb, net, pid, RTNLGRP_TC,
                               n->nlmsg_flags & NLM_F_ECHO);
 }
 
@@ -418,12 +418,9 @@ static int tc_dump_tfilter(struct sk_buff *skb, struct netlink_callback *cb)
         const struct Qdisc_class_ops *cops;
         struct tcf_dump_args arg;
 
-        if (!net_eq(net, &init_net))
-                return 0;
-
         if (cb->nlh->nlmsg_len < NLMSG_LENGTH(sizeof(*tcm)))
                 return skb->len;
-        if ((dev = __dev_get_by_index(&init_net, tcm->tcm_ifindex)) == NULL)
+        if ((dev = __dev_get_by_index(net, tcm->tcm_ifindex)) == NULL)
                 return skb->len;
 
         if (!tcm->tcm_parent)
diff --git a/net/sched/cls_basic.c b/net/sched/cls_basic.c
index 4e2bda854119..efd4f95fd050 100644
--- a/net/sched/cls_basic.c
+++ b/net/sched/cls_basic.c
@@ -10,6 +10,7 @@
  */
 
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/string.h>
diff --git a/net/sched/cls_cgroup.c b/net/sched/cls_cgroup.c
index e4877ca6727c..221180384fd7 100644
--- a/net/sched/cls_cgroup.c
+++ b/net/sched/cls_cgroup.c
@@ -10,6 +10,7 @@
  */
 
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/string.h>
 #include <linux/errno.h>
@@ -24,6 +25,25 @@ struct cgroup_cls_state
         u32 classid;
 };
 
+static struct cgroup_subsys_state *cgrp_create(struct cgroup_subsys *ss,
+                                               struct cgroup *cgrp);
+static void cgrp_destroy(struct cgroup_subsys *ss, struct cgroup *cgrp);
+static int cgrp_populate(struct cgroup_subsys *ss, struct cgroup *cgrp);
+
+struct cgroup_subsys net_cls_subsys = {
+        .name           = "net_cls",
+        .create         = cgrp_create,
+        .destroy        = cgrp_destroy,
+        .populate       = cgrp_populate,
+#ifdef CONFIG_NET_CLS_CGROUP
+        .subsys_id      = net_cls_subsys_id,
+#else
+#define net_cls_subsys_id net_cls_subsys.subsys_id
+#endif
+        .module         = THIS_MODULE,
+};
+
+
 static inline struct cgroup_cls_state *cgrp_cls_state(struct cgroup *cgrp)
 {
         return container_of(cgroup_subsys_state(cgrp, net_cls_subsys_id),
@@ -79,14 +99,6 @@ static int cgrp_populate(struct cgroup_subsys *ss, struct cgroup *cgrp)
         return cgroup_add_files(cgrp, ss, ss_files, ARRAY_SIZE(ss_files));
 }
 
-struct cgroup_subsys net_cls_subsys = {
-        .name           = "net_cls",
-        .create         = cgrp_create,
-        .destroy        = cgrp_destroy,
-        .populate       = cgrp_populate,
-        .subsys_id      = net_cls_subsys_id,
-};
-
 struct cls_cgroup_head
 {
         u32                     handle;
@@ -277,12 +289,19 @@ static struct tcf_proto_ops cls_cgroup_ops __read_mostly = {
 
 static int __init init_cgroup_cls(void)
 {
-        return register_tcf_proto_ops(&cls_cgroup_ops);
+        int ret = register_tcf_proto_ops(&cls_cgroup_ops);
+        if (ret)
+                return ret;
+        ret = cgroup_load_subsys(&net_cls_subsys);
+        if (ret)
+                unregister_tcf_proto_ops(&cls_cgroup_ops);
+        return ret;
 }
 
 static void __exit exit_cgroup_cls(void)
 {
         unregister_tcf_proto_ops(&cls_cgroup_ops);
+        cgroup_unload_subsys(&net_cls_subsys);
 }
 
 module_init(init_cgroup_cls);
diff --git a/net/sched/cls_flow.c b/net/sched/cls_flow.c
index e054c62857e1..6ed61b10e002 100644
--- a/net/sched/cls_flow.c
+++ b/net/sched/cls_flow.c
@@ -20,6 +20,7 @@
 #include <linux/ip.h>
 #include <linux/ipv6.h>
 #include <linux/if_vlan.h>
+#include <linux/slab.h>
 
 #include <net/pkt_cls.h>
 #include <net/ip.h>
diff --git a/net/sched/cls_fw.c b/net/sched/cls_fw.c
index 6d6e87585fb1..93b0a7b6f9b4 100644
--- a/net/sched/cls_fw.c
+++ b/net/sched/cls_fw.c
@@ -19,6 +19,7 @@
  */
 
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/string.h>
diff --git a/net/sched/cls_route.c b/net/sched/cls_route.c
index dd872d5383ef..694dcd85dec8 100644
--- a/net/sched/cls_route.c
+++ b/net/sched/cls_route.c
@@ -10,6 +10,7 @@
  */
 
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/string.h>
diff --git a/net/sched/cls_tcindex.c b/net/sched/cls_tcindex.c
index e806f2314b5e..20ef330bb918 100644
--- a/net/sched/cls_tcindex.c
+++ b/net/sched/cls_tcindex.c
@@ -9,6 +9,7 @@
 #include <linux/kernel.h>
 #include <linux/skbuff.h>
 #include <linux/errno.h>
+#include <linux/slab.h>
 #include <net/act_api.h>
 #include <net/netlink.h>
 #include <net/pkt_cls.h>
diff --git a/net/sched/cls_u32.c b/net/sched/cls_u32.c
index 07372f60bee3..593eac056e8d 100644
--- a/net/sched/cls_u32.c
+++ b/net/sched/cls_u32.c
@@ -31,6 +31,7 @@
  */
 
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/string.h>
@@ -772,10 +773,10 @@ static int __init init_u32(void)
         printk("    Performance counters on\n");
 #endif
 #ifdef CONFIG_NET_CLS_IND
-        printk("    input device check on \n");
+        printk("    input device check on\n");
 #endif
 #ifdef CONFIG_NET_CLS_ACT
-        printk("    Actions configured \n");
+        printk("    Actions configured\n");
 #endif
         return register_tcf_proto_ops(&cls_u32_ops);
 }
diff --git a/net/sched/em_meta.c b/net/sched/em_meta.c
index 24dce8b648a4..3bcac8aa333c 100644
--- a/net/sched/em_meta.c
+++ b/net/sched/em_meta.c
@@ -58,6 +58,7 @@
  *            only available if that subsystem is enabled in the kernel.
  */
 
+#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
diff --git a/net/sched/em_nbyte.c b/net/sched/em_nbyte.c
index 370a1b2ea317..1a4176aee6e5 100644
--- a/net/sched/em_nbyte.c
+++ b/net/sched/em_nbyte.c
@@ -9,6 +9,7 @@
  * Authors:     Thomas Graf <tgraf@suug.ch>
  */
 
+#include <linux/gfp.h>
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
diff --git a/net/sched/em_text.c b/net/sched/em_text.c
index 853c5ead87fd..763253257411 100644
--- a/net/sched/em_text.c
+++ b/net/sched/em_text.c
@@ -9,6 +9,7 @@
  * Authors:     Thomas Graf <tgraf@suug.ch>
  */
 
+#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
diff --git a/net/sched/ematch.c b/net/sched/ematch.c
index aab59409728b..e782bdeedc58 100644
--- a/net/sched/ematch.c
+++ b/net/sched/ematch.c
@@ -82,6 +82,7 @@
  */
 
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/errno.h>
diff --git a/net/sched/sch_api.c b/net/sched/sch_api.c
index 6cd491013b50..9839b26674f4 100644
--- a/net/sched/sch_api.c
+++ b/net/sched/sch_api.c
@@ -28,16 +28,19 @@
 #include <linux/list.h>
 #include <linux/hrtimer.h>
 #include <linux/lockdep.h>
+#include <linux/slab.h>
 
 #include <net/net_namespace.h>
 #include <net/sock.h>
 #include <net/netlink.h>
 #include <net/pkt_sched.h>
 
-static int qdisc_notify(struct sk_buff *oskb, struct nlmsghdr *n, u32 clid,
+static int qdisc_notify(struct net *net, struct sk_buff *oskb,
+                        struct nlmsghdr *n, u32 clid,
                         struct Qdisc *old, struct Qdisc *new);
-static int tclass_notify(struct sk_buff *oskb, struct nlmsghdr *n,
-                         struct Qdisc *q, unsigned long cl, int event);
+static int tclass_notify(struct net *net, struct sk_buff *oskb,
+                         struct nlmsghdr *n, struct Qdisc *q,
+                         unsigned long cl, int event);
 
 /*
 
@@ -638,11 +641,12 @@ void qdisc_tree_decrease_qlen(struct Qdisc *sch, unsigned int n)
 }
 EXPORT_SYMBOL(qdisc_tree_decrease_qlen);
 
-static void notify_and_destroy(struct sk_buff *skb, struct nlmsghdr *n, u32 clid,
+static void notify_and_destroy(struct net *net, struct sk_buff *skb,
+                               struct nlmsghdr *n, u32 clid,
                                struct Qdisc *old, struct Qdisc *new)
 {
         if (new || old)
-                qdisc_notify(skb, n, clid, old, new);
+                qdisc_notify(net, skb, n, clid, old, new);
 
         if (old)
                 qdisc_destroy(old);
@@ -662,6 +666,7 @@ static int qdisc_graft(struct net_device *dev, struct Qdisc *parent,
                        struct Qdisc *new, struct Qdisc *old)
 {
         struct Qdisc *q = old;
+        struct net *net = dev_net(dev);
         int err = 0;
 
         if (parent == NULL) {
@@ -698,12 +703,13 @@ static int qdisc_graft(struct net_device *dev, struct Qdisc *parent,
                 }
 
                 if (!ingress) {
-                        notify_and_destroy(skb, n, classid, dev->qdisc, new);
+                        notify_and_destroy(net, skb, n, classid,
+                                           dev->qdisc, new);
                         if (new && !new->ops->attach)
                                 atomic_inc(&new->refcnt);
                         dev->qdisc = new ? : &noop_qdisc;
                 } else {
-                        notify_and_destroy(skb, n, classid, old, new);
+                        notify_and_destroy(net, skb, n, classid, old, new);
                 }
 
                 if (dev->flags & IFF_UP)
@@ -721,7 +727,7 @@ static int qdisc_graft(struct net_device *dev, struct Qdisc *parent,
                                 err = -ENOENT;
                 }
                 if (!err)
-                        notify_and_destroy(skb, n, classid, old, new);
+                        notify_and_destroy(net, skb, n, classid, old, new);
         }
         return err;
 }
@@ -947,10 +953,7 @@ static int tc_get_qdisc(struct sk_buff *skb, struct nlmsghdr *n, void *arg)
         struct Qdisc *p = NULL;
         int err;
 
-        if (!net_eq(net, &init_net))
-                return -EINVAL;
-
-        if ((dev = __dev_get_by_index(&init_net, tcm->tcm_ifindex)) == NULL)
+        if ((dev = __dev_get_by_index(net, tcm->tcm_ifindex)) == NULL)
                 return -ENODEV;
 
         err = nlmsg_parse(n, sizeof(*tcm), tca, TCA_MAX, NULL);
@@ -990,7 +993,7 @@ static int tc_get_qdisc(struct sk_buff *skb, struct nlmsghdr *n, void *arg)
                 if ((err = qdisc_graft(dev, p, skb, n, clid, NULL, q)) != 0)
                         return err;
         } else {
-                qdisc_notify(skb, n, clid, NULL, q);
+                qdisc_notify(net, skb, n, clid, NULL, q);
         }
         return 0;
 }
@@ -1009,16 +1012,13 @@ static int tc_modify_qdisc(struct sk_buff *skb, struct nlmsghdr *n, void *arg)
         struct Qdisc *q, *p;
         int err;
 
-        if (!net_eq(net, &init_net))
-                return -EINVAL;
-
 replay:
         /* Reinit, just in case something touches this. */
         tcm = NLMSG_DATA(n);
         clid = tcm->tcm_parent;
         q = p = NULL;
 
-        if ((dev = __dev_get_by_index(&init_net, tcm->tcm_ifindex)) == NULL)
+        if ((dev = __dev_get_by_index(net, tcm->tcm_ifindex)) == NULL)
                 return -ENODEV;
 
         err = nlmsg_parse(n, sizeof(*tcm), tca, TCA_MAX, NULL);
@@ -1105,7 +1105,7 @@ replay:
                 return -EINVAL;
         err = qdisc_change(q, tca);
         if (err == 0)
-                qdisc_notify(skb, n, clid, NULL, q);
+                qdisc_notify(net, skb, n, clid, NULL, q);
         return err;
 
 create_n_graft:
@@ -1195,8 +1195,9 @@ nla_put_failure:
         return -1;
 }
 
-static int qdisc_notify(struct sk_buff *oskb, struct nlmsghdr *n,
-                        u32 clid, struct Qdisc *old, struct Qdisc *new)
+static int qdisc_notify(struct net *net, struct sk_buff *oskb,
+                        struct nlmsghdr *n, u32 clid,
+                        struct Qdisc *old, struct Qdisc *new)
 {
         struct sk_buff *skb;
         u32 pid = oskb ? NETLINK_CB(oskb).pid : 0;
@@ -1215,7 +1216,7 @@ static int qdisc_notify(struct sk_buff *oskb, struct nlmsghdr *n,
         }
 
         if (skb->len)
-                return rtnetlink_send(skb, &init_net, pid, RTNLGRP_TC, n->nlmsg_flags&NLM_F_ECHO);
+                return rtnetlink_send(skb, net, pid, RTNLGRP_TC, n->nlmsg_flags&NLM_F_ECHO);
 
 err_out:
         kfree_skb(skb);
@@ -1274,15 +1275,12 @@ static int tc_dump_qdisc(struct sk_buff *skb, struct netlink_callback *cb)
         int s_idx, s_q_idx;
         struct net_device *dev;
 
-        if (!net_eq(net, &init_net))
-                return 0;
-
         s_idx = cb->args[0];
         s_q_idx = q_idx = cb->args[1];
 
         rcu_read_lock();
         idx = 0;
-        for_each_netdev_rcu(&init_net, dev) {
+        for_each_netdev_rcu(net, dev) {
                 struct netdev_queue *dev_queue;
 
                 if (idx < s_idx)
@@ -1334,10 +1332,7 @@ static int tc_ctl_tclass(struct sk_buff *skb, struct nlmsghdr *n, void *arg)
         u32 qid = TC_H_MAJ(clid);
         int err;
 
-        if (!net_eq(net, &init_net))
-                return -EINVAL;
-
-        if ((dev = __dev_get_by_index(&init_net, tcm->tcm_ifindex)) == NULL)
+        if ((dev = __dev_get_by_index(net, tcm->tcm_ifindex)) == NULL)
                 return -ENODEV;
 
         err = nlmsg_parse(n, sizeof(*tcm), tca, TCA_MAX, NULL);
@@ -1418,10 +1413,10 @@ static int tc_ctl_tclass(struct sk_buff *skb, struct nlmsghdr *n, void *arg)
                         if (cops->delete)
                                 err = cops->delete(q, cl);
                         if (err == 0)
-                                tclass_notify(skb, n, q, cl, RTM_DELTCLASS);
+                                tclass_notify(net, skb, n, q, cl, RTM_DELTCLASS);
                         goto out;
                 case RTM_GETTCLASS:
-                        err = tclass_notify(skb, n, q, cl, RTM_NEWTCLASS);
+                        err = tclass_notify(net, skb, n, q, cl, RTM_NEWTCLASS);
                         goto out;
                 default:
                         err = -EINVAL;
@@ -1434,7 +1429,7 @@ static int tc_ctl_tclass(struct sk_buff *skb, struct nlmsghdr *n, void *arg)
         if (cops->change)
                 err = cops->change(q, clid, pid, tca, &new_cl);
         if (err == 0)
-                tclass_notify(skb, n, q, new_cl, RTM_NEWTCLASS);
+                tclass_notify(net, skb, n, q, new_cl, RTM_NEWTCLASS);
 
 out:
         if (cl)
@@ -1486,8 +1481,9 @@ nla_put_failure:
         return -1;
 }
 
-static int tclass_notify(struct sk_buff *oskb, struct nlmsghdr *n,
-                          struct Qdisc *q, unsigned long cl, int event)
+static int tclass_notify(struct net *net, struct sk_buff *oskb,
+                         struct nlmsghdr *n, struct Qdisc *q,
+                         unsigned long cl, int event)
 {
         struct sk_buff *skb;
         u32 pid = oskb ? NETLINK_CB(oskb).pid : 0;
@@ -1501,7 +1497,7 @@ static int tclass_notify(struct sk_buff *oskb, struct nlmsghdr *n,
                 return -EINVAL;
         }
 
-        return rtnetlink_send(skb, &init_net, pid, RTNLGRP_TC, n->nlmsg_flags&NLM_F_ECHO);
+        return rtnetlink_send(skb, net, pid, RTNLGRP_TC, n->nlmsg_flags&NLM_F_ECHO);
 }
 
 struct qdisc_dump_args
@@ -1576,12 +1572,9 @@ static int tc_dump_tclass(struct sk_buff *skb, struct netlink_callback *cb)
         struct net_device *dev;
         int t, s_t;
 
-        if (!net_eq(net, &init_net))
-                return 0;
-
         if (cb->nlh->nlmsg_len < NLMSG_LENGTH(sizeof(*tcm)))
                 return 0;
-        if ((dev = dev_get_by_index(&init_net, tcm->tcm_ifindex)) == NULL)
+        if ((dev = dev_get_by_index(net, tcm->tcm_ifindex)) == NULL)
                 return 0;
 
         s_t = cb->args[0];
@@ -1691,7 +1684,7 @@ static int psched_show(struct seq_file *seq, void *v)
 
 static int psched_open(struct inode *inode, struct file *file)
 {
-        return single_open(file, psched_show, PDE(inode)->data);
+        return single_open(file, psched_show, NULL);
 }
 
 static const struct file_operations psched_fops = {
@@ -1701,15 +1694,53 @@ static const struct file_operations psched_fops = {
         .llseek = seq_lseek,
         .release = single_release,
 };
+
+static int __net_init psched_net_init(struct net *net)
+{
+        struct proc_dir_entry *e;
+
+        e = proc_net_fops_create(net, "psched", 0, &psched_fops);
+        if (e == NULL)
+                return -ENOMEM;
+
+        return 0;
+}
+
+static void __net_exit psched_net_exit(struct net *net)
+{
+        proc_net_remove(net, "psched");
+}
+#else
+static int __net_init psched_net_init(struct net *net)
+{
+        return 0;
+}
+
+static void __net_exit psched_net_exit(struct net *net)
+{
+}
 #endif
 
+static struct pernet_operations psched_net_ops = {
+        .init = psched_net_init,
+        .exit = psched_net_exit,
+};
+
 static int __init pktsched_init(void)
 {
+        int err;
+
+        err = register_pernet_subsys(&psched_net_ops);
+        if (err) {
+                printk(KERN_ERR "pktsched_init: "
+                       "cannot initialize per netns operations\n");
+                return err;
+        }
+
         register_qdisc(&pfifo_qdisc_ops);
         register_qdisc(&bfifo_qdisc_ops);
         register_qdisc(&pfifo_head_drop_qdisc_ops);
         register_qdisc(&mq_qdisc_ops);
-        proc_net_fops_create(&init_net, "psched", 0, &psched_fops);
 
         rtnl_register(PF_UNSPEC, RTM_NEWQDISC, tc_modify_qdisc, NULL);
         rtnl_register(PF_UNSPEC, RTM_DELQDISC, tc_get_qdisc, NULL);
diff --git a/net/sched/sch_atm.c b/net/sched/sch_atm.c
index ab82f145f689..fcbb86a486a2 100644
--- a/net/sched/sch_atm.c
+++ b/net/sched/sch_atm.c
@@ -3,6 +3,7 @@
 /* Written 1998-2000 by Werner Almesberger, EPFL ICA */
 
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/string.h>
 #include <linux/errno.h>
diff --git a/net/sched/sch_cbq.c b/net/sched/sch_cbq.c
index 3846d65bc03e..28c01ef5abc8 100644
--- a/net/sched/sch_cbq.c
+++ b/net/sched/sch_cbq.c
@@ -11,6 +11,7 @@
  */
 
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/string.h>
diff --git a/net/sched/sch_drr.c b/net/sched/sch_drr.c
index a65604f8f2b8..b74046a95397 100644
--- a/net/sched/sch_drr.c
+++ b/net/sched/sch_drr.c
@@ -9,6 +9,7 @@
  */
 
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/errno.h>
 #include <linux/netdevice.h>
diff --git a/net/sched/sch_dsmark.c b/net/sched/sch_dsmark.c
index d303daa45d49..63d41f86679c 100644
--- a/net/sched/sch_dsmark.c
+++ b/net/sched/sch_dsmark.c
@@ -5,6 +5,7 @@
 
 #include <linux/module.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/string.h>
 #include <linux/errno.h>
diff --git a/net/sched/sch_fifo.c b/net/sched/sch_fifo.c
index 4b0a6cc44c77..5948bafa8ce2 100644
--- a/net/sched/sch_fifo.c
+++ b/net/sched/sch_fifo.c
@@ -10,6 +10,7 @@
  */
 
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/errno.h>
diff --git a/net/sched/sch_generic.c b/net/sched/sch_generic.c
index 5173c1e1b19c..a969b111bd76 100644
--- a/net/sched/sch_generic.c
+++ b/net/sched/sch_generic.c
@@ -24,6 +24,7 @@
 #include <linux/init.h>
 #include <linux/rcupdate.h>
 #include <linux/list.h>
+#include <linux/slab.h>
 #include <net/pkt_sched.h>
 
 /* Main transmission queue. */
@@ -93,7 +94,7 @@ static inline int handle_dev_cpu_collision(struct sk_buff *skb,
                  * Another cpu is holding lock, requeue & delay xmits for
                  * some time.
                  */
-                __get_cpu_var(netdev_rx_stat).cpu_collision++;
+                __get_cpu_var(softnet_data).cpu_collision++;
                 ret = dev_requeue_skb(skb, q);
         }
 
@@ -528,7 +529,7 @@ struct Qdisc *qdisc_alloc(struct netdev_queue *dev_queue,
         unsigned int size;
         int err = -ENOBUFS;
 
-        /* ensure that the Qdisc and the private data are 32-byte aligned */
+        /* ensure that the Qdisc and the private data are 64-byte aligned */
         size = QDISC_ALIGN(sizeof(*sch));
         size += ops->priv_size + (QDISC_ALIGNTO - 1);
 
@@ -590,6 +591,13 @@ void qdisc_reset(struct Qdisc *qdisc)
 }
 EXPORT_SYMBOL(qdisc_reset);
 
+static void qdisc_rcu_free(struct rcu_head *head)
+{
+        struct Qdisc *qdisc = container_of(head, struct Qdisc, rcu_head);
+
+        kfree((char *) qdisc - qdisc->padded);
+}
+
 void qdisc_destroy(struct Qdisc *qdisc)
 {
         const struct Qdisc_ops  *ops = qdisc->ops;
@@ -613,7 +621,11 @@ void qdisc_destroy(struct Qdisc *qdisc)
         dev_put(qdisc_dev(qdisc));
 
         kfree_skb(qdisc->gso_skb);
-        kfree((char *) qdisc - qdisc->padded);
+        /*
+         * gen_estimator est_timer() might access qdisc->q.lock,
+         * wait a RCU grace period before freeing qdisc.
+         */
+        call_rcu(&qdisc->rcu_head, qdisc_rcu_free);
 }
 EXPORT_SYMBOL(qdisc_destroy);
 
diff --git a/net/sched/sch_gred.c b/net/sched/sch_gred.c
index 40408d595c08..51dcc2aa5c92 100644
--- a/net/sched/sch_gred.c
+++ b/net/sched/sch_gred.c
@@ -18,6 +18,7 @@
  *  For all the glorious comments look at include/net/red.h
  */
 
+#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
diff --git a/net/sched/sch_htb.c b/net/sched/sch_htb.c
index 508cf5f3a6d5..0b52b8de562c 100644
--- a/net/sched/sch_htb.c
+++ b/net/sched/sch_htb.c
@@ -36,6 +36,7 @@
 #include <linux/compiler.h>
 #include <linux/rbtree.h>
 #include <linux/workqueue.h>
+#include <linux/slab.h>
 #include <net/netlink.h>
 #include <net/pkt_sched.h>
 
diff --git a/net/sched/sch_mq.c b/net/sched/sch_mq.c
index d1dea3d5dc92..b2aba3f5e6fa 100644
--- a/net/sched/sch_mq.c
+++ b/net/sched/sch_mq.c
@@ -9,6 +9,7 @@
  */
 
 #include <linux/types.h>
+#include <linux/slab.h>
 #include <linux/kernel.h>
 #include <linux/string.h>
 #include <linux/errno.h>
diff --git a/net/sched/sch_multiq.c b/net/sched/sch_multiq.c
index 7db2c88ce585..c50876cd8704 100644
--- a/net/sched/sch_multiq.c
+++ b/net/sched/sch_multiq.c
@@ -18,6 +18,7 @@
  */
 
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/string.h>
diff --git a/net/sched/sch_netem.c b/net/sched/sch_netem.c
index d8b10e054627..4714ff162bbd 100644
--- a/net/sched/sch_netem.c
+++ b/net/sched/sch_netem.c
@@ -14,6 +14,7 @@
  */
 
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/errno.h>
diff --git a/net/sched/sch_prio.c b/net/sched/sch_prio.c
index 93285cecb246..81672e0c1b25 100644
--- a/net/sched/sch_prio.c
+++ b/net/sched/sch_prio.c
@@ -12,6 +12,7 @@
  */
 
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/string.h>
diff --git a/net/sched/sch_sfq.c b/net/sched/sch_sfq.c
index cb21380c0605..c65762823f5e 100644
--- a/net/sched/sch_sfq.c
+++ b/net/sched/sch_sfq.c
@@ -20,6 +20,7 @@
 #include <linux/ipv6.h>
 #include <linux/skbuff.h>
 #include <linux/jhash.h>
+#include <linux/slab.h>
 #include <net/ip.h>
 #include <net/netlink.h>
 #include <net/pkt_sched.h>
@@ -122,8 +123,8 @@ static unsigned sfq_hash(struct sfq_sched_data *q, struct sk_buff *skb)
         case htons(ETH_P_IP):
         {
                 const struct iphdr *iph = ip_hdr(skb);
-                h = iph->daddr;
-                h2 = iph->saddr ^ iph->protocol;
+                h = (__force u32)iph->daddr;
+                h2 = (__force u32)iph->saddr ^ iph->protocol;
                 if (!(iph->frag_off&htons(IP_MF|IP_OFFSET)) &&
                     (iph->protocol == IPPROTO_TCP ||
                      iph->protocol == IPPROTO_UDP ||
@@ -137,8 +138,8 @@ static unsigned sfq_hash(struct sfq_sched_data *q, struct sk_buff *skb)
         case htons(ETH_P_IPV6):
         {
                 struct ipv6hdr *iph = ipv6_hdr(skb);
-                h = iph->daddr.s6_addr32[3];
-                h2 = iph->saddr.s6_addr32[3] ^ iph->nexthdr;
+                h = (__force u32)iph->daddr.s6_addr32[3];
+                h2 = (__force u32)iph->saddr.s6_addr32[3] ^ iph->nexthdr;
                 if (iph->nexthdr == IPPROTO_TCP ||
                     iph->nexthdr == IPPROTO_UDP ||
                     iph->nexthdr == IPPROTO_UDPLITE ||
@@ -149,7 +150,7 @@ static unsigned sfq_hash(struct sfq_sched_data *q, struct sk_buff *skb)
                 break;
         }
         default:
-                h = (unsigned long)skb_dst(skb) ^ skb->protocol;
+                h = (unsigned long)skb_dst(skb) ^ (__force u32)skb->protocol;
                 h2 = (unsigned long)skb->sk;
         }
 
diff --git a/net/sched/sch_teql.c b/net/sched/sch_teql.c
index db69637069c4..3415b6ce1c0a 100644
--- a/net/sched/sch_teql.c
+++ b/net/sched/sch_teql.c
@@ -11,6 +11,7 @@
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/string.h>
 #include <linux/errno.h>
 #include <linux/if_arp.h>
diff --git a/net/sctp/Kconfig b/net/sctp/Kconfig
index 58b3e882a187..126b014eb79b 100644
--- a/net/sctp/Kconfig
+++ b/net/sctp/Kconfig
@@ -37,6 +37,18 @@ menuconfig IP_SCTP
 
 if IP_SCTP
 
+config NET_SCTPPROBE
+        tristate "SCTP: Association probing"
+        depends on PROC_FS && KPROBES
+        ---help---
+        This module allows for capturing the changes to SCTP association
+        state in response to incoming packets. It is used for debugging
+        SCTP congestion control algorithms. If you don't understand
+        what was just said, you don't need it: say N.
+
+        To compile this code as a module, choose M here: the
+        module will be called sctp_probe.
+
 config SCTP_DBG_MSG
         bool "SCTP: Debug messages"
         help
diff --git a/net/sctp/Makefile b/net/sctp/Makefile
index 6b794734380a..5c30b7a873df 100644
--- a/net/sctp/Makefile
+++ b/net/sctp/Makefile
@@ -3,6 +3,7 @@
 #
 
 obj-$(CONFIG_IP_SCTP) += sctp.o
+obj-$(CONFIG_NET_SCTPPROBE) += sctp_probe.o
 
 sctp-y := sm_statetable.o sm_statefuns.o sm_sideeffect.o \
           protocol.o endpointola.o associola.o \
@@ -11,6 +12,8 @@ sctp-y := sm_statetable.o sm_statefuns.o sm_sideeffect.o \
           tsnmap.o bind_addr.o socket.o primitive.o \
           output.o input.o debug.o ssnmap.o auth.o
 
+sctp_probe-y := probe.o
+
 sctp-$(CONFIG_SCTP_DBG_OBJCNT) += objcnt.o
 sctp-$(CONFIG_PROC_FS) += proc.o
 sctp-$(CONFIG_SYSCTL) += sysctl.o
diff --git a/net/sctp/associola.c b/net/sctp/associola.c
index df5abbff63e2..3912420cedcc 100644
--- a/net/sctp/associola.c
+++ b/net/sctp/associola.c
@@ -87,9 +87,6 @@ static struct sctp_association *sctp_association_init(struct sctp_association *a
         /* Retrieve the SCTP per socket area.  */
         sp = sctp_sk((struct sock *)sk);
 
-        /* Init all variables to a known value.  */
-        memset(asoc, 0, sizeof(struct sctp_association));
-
         /* Discarding const is appropriate here.  */
         asoc->ep = (struct sctp_endpoint *)ep;
         sctp_endpoint_hold(asoc->ep);
@@ -762,7 +759,8 @@ struct sctp_transport *sctp_assoc_add_peer(struct sctp_association *asoc,
                 asoc->peer.retran_path = peer;
         }
 
-        if (asoc->peer.active_path == asoc->peer.retran_path) {
+        if (asoc->peer.active_path == asoc->peer.retran_path &&
+            peer->state != SCTP_UNCONFIRMED) {
                 asoc->peer.retran_path = peer;
         }
 
@@ -1194,8 +1192,10 @@ void sctp_assoc_update(struct sctp_association *asoc,
         /* Remove any peer addresses not present in the new association. */
         list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {
                 trans = list_entry(pos, struct sctp_transport, transports);
-                if (!sctp_assoc_lookup_paddr(new, &trans->ipaddr))
-                        sctp_assoc_del_peer(asoc, &trans->ipaddr);
+                if (!sctp_assoc_lookup_paddr(new, &trans->ipaddr)) {
+                        sctp_assoc_rm_peer(asoc, trans);
+                        continue;
+                }
 
                 if (asoc->state >= SCTP_STATE_ESTABLISHED)
                         sctp_transport_reset(trans);
@@ -1318,12 +1318,13 @@ void sctp_assoc_update_retran_path(struct sctp_association *asoc)
                         /* Keep track of the next transport in case
                          * we don't find any active transport.
                          */
-                        if (!next)
+                        if (t->state != SCTP_UNCONFIRMED && !next)
                                 next = t;
                 }
         }
 
-        asoc->peer.retran_path = t;
+        if (t)
+                asoc->peer.retran_path = t;
 
         SCTP_DEBUG_PRINTK_IPADDR("sctp_assoc_update_retran_path:association"
                                  " %p addr: ",
@@ -1483,7 +1484,7 @@ void sctp_assoc_rwnd_decrease(struct sctp_association *asoc, unsigned len)
         if (asoc->rwnd >= len) {
                 asoc->rwnd -= len;
                 if (over) {
-                        asoc->rwnd_press = asoc->rwnd;
+                        asoc->rwnd_press += asoc->rwnd;
                         asoc->rwnd = 0;
                 }
         } else {
diff --git a/net/sctp/auth.c b/net/sctp/auth.c
index 56935bbc1496..86366390038a 100644
--- a/net/sctp/auth.c
+++ b/net/sctp/auth.c
@@ -34,6 +34,7 @@
  * be incorporated into the next SCTP release.
  */
 
+#include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/crypto.h>
 #include <linux/scatterlist.h>
diff --git a/net/sctp/bind_addr.c b/net/sctp/bind_addr.c
index bef133731683..faf71d179e46 100644
--- a/net/sctp/bind_addr.c
+++ b/net/sctp/bind_addr.c
@@ -43,6 +43,7 @@
  */
 
 #include <linux/types.h>
+#include <linux/slab.h>
 #include <linux/in.h>
 #include <net/sock.h>
 #include <net/ipv6.h>
diff --git a/net/sctp/chunk.c b/net/sctp/chunk.c
index 8e4320040f05..476caaf100ed 100644
--- a/net/sctp/chunk.c
+++ b/net/sctp/chunk.c
@@ -42,6 +42,7 @@
 #include <linux/net.h>
 #include <linux/inet.h>
 #include <linux/skbuff.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 #include <net/sctp/sctp.h>
 #include <net/sctp/sm.h>
@@ -57,9 +58,9 @@ static void sctp_datamsg_init(struct sctp_datamsg *msg)
         msg->send_failed = 0;
         msg->send_error = 0;
         msg->can_abandon = 0;
+        msg->can_delay = 1;
         msg->expires_at = 0;
         INIT_LIST_HEAD(&msg->chunks);
-        msg->msg_size = 0;
 }
 
 /* Allocate and initialize datamsg. */
@@ -156,7 +157,6 @@ static void sctp_datamsg_assign(struct sctp_datamsg *msg, struct sctp_chunk *chu
 {
         sctp_datamsg_hold(msg);
         chunk->msg = msg;
-        msg->msg_size += chunk->skb->len;
 }
 
 
@@ -246,6 +246,7 @@ struct sctp_datamsg *sctp_datamsg_from_user(struct sctp_association *asoc,
         if (msg_len >= first_len) {
                 msg_len -= first_len;
                 whole = 1;
+                msg->can_delay = 0;
         }
 
         /* How many full sized?  How many bytes leftover? */
diff --git a/net/sctp/endpointola.c b/net/sctp/endpointola.c
index 905fda582b92..e10acc01c75f 100644
--- a/net/sctp/endpointola.c
+++ b/net/sctp/endpointola.c
@@ -70,8 +70,6 @@ static struct sctp_endpoint *sctp_endpoint_init(struct sctp_endpoint *ep,
         struct sctp_shared_key *null_key;
         int err;
 
-        memset(ep, 0, sizeof(struct sctp_endpoint));
-
         ep->digest = kzalloc(SCTP_SIGNATURE_SIZE, gfp);
         if (!ep->digest)
                 return NULL;
@@ -144,6 +142,7 @@ static struct sctp_endpoint *sctp_endpoint_init(struct sctp_endpoint *ep,
         /* Use SCTP specific send buffer space queues.  */
         ep->sndbuf_policy = sctp_sndbuf_policy;
 
+        sk->sk_data_ready = sctp_data_ready;
         sk->sk_write_space = sctp_write_space;
         sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
 
diff --git a/net/sctp/input.c b/net/sctp/input.c
index 3d74b264ea22..2a570184e5a9 100644
--- a/net/sctp/input.c
+++ b/net/sctp/input.c
@@ -53,6 +53,7 @@
 #include <linux/socket.h>
 #include <linux/ip.h>
 #include <linux/time.h> /* For struct timeval */
+#include <linux/slab.h>
 #include <net/ip.h>
 #include <net/icmp.h>
 #include <net/snmp.h>
diff --git a/net/sctp/inqueue.c b/net/sctp/inqueue.c
index bbf5dd2a97c4..ccb6dc48d15b 100644
--- a/net/sctp/inqueue.c
+++ b/net/sctp/inqueue.c
@@ -46,6 +46,7 @@
 #include <net/sctp/sctp.h>
 #include <net/sctp/sm.h>
 #include <linux/interrupt.h>
+#include <linux/slab.h>
 
 /* Initialize an SCTP inqueue.  */
 void sctp_inq_init(struct sctp_inq *queue)
diff --git a/net/sctp/ipv6.c b/net/sctp/ipv6.c
index 1d7ac70ba39f..732689140fb8 100644
--- a/net/sctp/ipv6.c
+++ b/net/sctp/ipv6.c
@@ -58,6 +58,7 @@
 #include <linux/netdevice.h>
 #include <linux/init.h>
 #include <linux/ipsec.h>
+#include <linux/slab.h>
 
 #include <linux/ipv6.h>
 #include <linux/icmpv6.h>
@@ -231,7 +232,7 @@ static int sctp_v6_xmit(struct sk_buff *skb, struct sctp_transport *transport)
         if (!(transport->param_flags & SPP_PMTUD_ENABLE))
                 skb->local_df = 1;
 
-        return ip6_xmit(sk, skb, &fl, np->opt, 0);
+        return ip6_xmit(sk, skb, &fl, np->opt);
 }
 
 /* Returns the dst cache entry for the given source and destination ip
@@ -276,20 +277,7 @@ static struct dst_entry *sctp_v6_get_dst(struct sctp_association *asoc,
 static inline int sctp_v6_addr_match_len(union sctp_addr *s1,
                                          union sctp_addr *s2)
 {
-        struct in6_addr *a1 = &s1->v6.sin6_addr;
-        struct in6_addr *a2 = &s2->v6.sin6_addr;
-        int i, j;
-
-        for (i = 0; i < 4 ; i++) {
-                __be32 a1xora2;
-
-                a1xora2 = a1->s6_addr32[i] ^ a2->s6_addr32[i];
-
-                if ((j = fls(ntohl(a1xora2))))
-                        return (i * 32 + 32 - j);
-        }
-
-        return (i*32);
+        return ipv6_addr_diff(&s1->v6.sin6_addr, &s2->v6.sin6_addr);
 }
 
 /* Fills in the source address(saddr) based on the destination address(daddr)
@@ -371,13 +359,13 @@ static void sctp_v6_copy_addrlist(struct list_head *addrlist,
         }
 
         read_lock_bh(&in6_dev->lock);
-        for (ifp = in6_dev->addr_list; ifp; ifp = ifp->if_next) {
+        list_for_each_entry(ifp, &in6_dev->addr_list, if_list) {
                 /* Add the address to the local list.  */
                 addr = t_new(struct sctp_sockaddr_entry, GFP_ATOMIC);
                 if (addr) {
                         addr->a.v6.sin6_family = AF_INET6;
                         addr->a.v6.sin6_port = 0;
-                        addr->a.v6.sin6_addr = ifp->addr;
+                        ipv6_addr_copy(&addr->a.v6.sin6_addr, &ifp->addr);
                         addr->a.v6.sin6_scope_id = dev->ifindex;
                         addr->valid = 1;
                         INIT_LIST_HEAD(&addr->list);
@@ -418,7 +406,7 @@ static void sctp_v6_from_sk(union sctp_addr *addr, struct sock *sk)
 {
         addr->v6.sin6_family = AF_INET6;
         addr->v6.sin6_port = 0;
-        addr->v6.sin6_addr = inet6_sk(sk)->rcv_saddr;
+        ipv6_addr_copy(&addr->v6.sin6_addr, &inet6_sk(sk)->rcv_saddr);
 }
 
 /* Initialize sk->sk_rcv_saddr from sctp_addr. */
@@ -431,7 +419,7 @@ static void sctp_v6_to_sk_saddr(union sctp_addr *addr, struct sock *sk)
                 inet6_sk(sk)->rcv_saddr.s6_addr32[3] =
                         addr->v4.sin_addr.s_addr;
         } else {
-                inet6_sk(sk)->rcv_saddr = addr->v6.sin6_addr;
+                ipv6_addr_copy(&inet6_sk(sk)->rcv_saddr, &addr->v6.sin6_addr);
         }
 }
 
@@ -444,7 +432,7 @@ static void sctp_v6_to_sk_daddr(union sctp_addr *addr, struct sock *sk)
                 inet6_sk(sk)->daddr.s6_addr32[2] = htonl(0x0000ffff);
                 inet6_sk(sk)->daddr.s6_addr32[3] = addr->v4.sin_addr.s_addr;
         } else {
-                inet6_sk(sk)->daddr = addr->v6.sin6_addr;
+                ipv6_addr_copy(&inet6_sk(sk)->daddr, &addr->v6.sin6_addr);
         }
 }
 
diff --git a/net/sctp/output.c b/net/sctp/output.c
index 7c5589363433..a646681f5acd 100644
--- a/net/sctp/output.c
+++ b/net/sctp/output.c
@@ -48,6 +48,7 @@
 #include <linux/ip.h>
 #include <linux/ipv6.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <net/inet_ecn.h>
 #include <net/ip.h>
 #include <net/icmp.h>
@@ -428,24 +429,17 @@ int sctp_packet_transmit(struct sctp_packet *packet)
         list_for_each_entry_safe(chunk, tmp, &packet->chunk_list, list) {
                 list_del_init(&chunk->list);
                 if (sctp_chunk_is_data(chunk)) {
+                        /* 6.3.1 C4) When data is in flight and when allowed
+                         * by rule C5, a new RTT measurement MUST be made each
+                         * round trip.  Furthermore, new RTT measurements
+                         * SHOULD be made no more than once per round-trip
+                         * for a given destination transport address.
+                         */
 
-                        if (!chunk->resent) {
-
-                                /* 6.3.1 C4) When data is in flight and when allowed
-                                 * by rule C5, a new RTT measurement MUST be made each
-                                 * round trip.  Furthermore, new RTT measurements
-                                 * SHOULD be made no more than once per round-trip
-                                 * for a given destination transport address.
-                                 */
-
-                                if (!tp->rto_pending) {
-                                        chunk->rtt_in_progress = 1;
-                                        tp->rto_pending = 1;
-                                }
+                        if (!tp->rto_pending) {
+                                chunk->rtt_in_progress = 1;
+                                tp->rto_pending = 1;
                         }
-
-                        chunk->resent = 1;
-
                         has_data = 1;
                 }
 
@@ -680,7 +674,7 @@ static sctp_xmit_t sctp_packet_can_append_data(struct sctp_packet *packet,
                  * Don't delay large message writes that may have been
                  * fragmeneted into small peices.
                  */
-                if ((len < max) && (chunk->msg->msg_size < max)) {
+                if ((len < max) && chunk->msg->can_delay) {
                         retval = SCTP_XMIT_NAGLE_DELAY;
                         goto finish;
                 }
diff --git a/net/sctp/outqueue.c b/net/sctp/outqueue.c
index 229690f02a1d..5d057178ce0c 100644
--- a/net/sctp/outqueue.c
+++ b/net/sctp/outqueue.c
@@ -50,6 +50,7 @@
 #include <linux/list.h>   /* For struct list_head */
 #include <linux/socket.h>
 #include <linux/ip.h>
+#include <linux/slab.h>
 #include <net/sock.h>     /* For skb_set_owner_w */
 
 #include <net/sctp/sctp.h>
@@ -61,7 +62,7 @@ static void sctp_check_transmitted(struct sctp_outq *q,
                                    struct list_head *transmitted_queue,
                                    struct sctp_transport *transport,
                                    struct sctp_sackhdr *sack,
-                                   __u32 highest_new_tsn);
+                                   __u32 *highest_new_tsn);
 
 static void sctp_mark_missing(struct sctp_outq *q,
                               struct list_head *transmitted_queue,
@@ -307,7 +308,7 @@ int sctp_outq_tail(struct sctp_outq *q, struct sctp_chunk *chunk)
         /* If it is data, queue it up, otherwise, send it
          * immediately.
          */
-        if (SCTP_CID_DATA == chunk->chunk_hdr->type) {
+        if (sctp_chunk_is_data(chunk)) {
                 /* Is it OK to queue data chunks?  */
                 /* From 9. Termination of Association
                  *
@@ -597,11 +598,23 @@ static int sctp_outq_flush_rtx(struct sctp_outq *q, struct sctp_packet *pkt,
                 if (fast_rtx && !chunk->fast_retransmit)
                         continue;
 
+redo:
                 /* Attempt to append this chunk to the packet. */
                 status = sctp_packet_append_chunk(pkt, chunk);
 
                 switch (status) {
                 case SCTP_XMIT_PMTU_FULL:
+                        if (!pkt->has_data && !pkt->has_cookie_echo) {
+                                /* If this packet did not contain DATA then
+                                 * retransmission did not happen, so do it
+                                 * again.  We'll ignore the error here since
+                                 * control chunks are already freed so there
+                                 * is nothing we can do.
+                                 */
+                                sctp_packet_transmit(pkt);
+                                goto redo;
+                        }
+
                         /* Send this packet.  */
                         error = sctp_packet_transmit(pkt);
 
@@ -646,14 +659,6 @@ static int sctp_outq_flush_rtx(struct sctp_outq *q, struct sctp_packet *pkt,
                         if (chunk->fast_retransmit == SCTP_NEED_FRTX)
                                 chunk->fast_retransmit = SCTP_DONT_FRTX;
 
-                        /* Force start T3-rtx timer when fast retransmitting
-                         * the earliest outstanding TSN
-                         */
-                        if (!timer && fast_rtx &&
-                            ntohl(chunk->subh.data_hdr->tsn) ==
-                                             asoc->ctsn_ack_point + 1)
-                                timer = 2;
-
                         q->empty = 0;
                         break;
                 }
@@ -853,6 +858,12 @@ static int sctp_outq_flush(struct sctp_outq *q, int rtx_timeout)
                         if (status  != SCTP_XMIT_OK) {
                                 /* put the chunk back */
                                 list_add(&chunk->list, &q->control_chunk_list);
+                        } else if (chunk->chunk_hdr->type == SCTP_CID_FWD_TSN) {
+                                /* PR-SCTP C5) If a FORWARD TSN is sent, the
+                                 * sender MUST assure that at least one T3-rtx
+                                 * timer is running.
+                                 */
+                                sctp_transport_reset_timers(transport);
                         }
                         break;
 
@@ -905,8 +916,7 @@ static int sctp_outq_flush(struct sctp_outq *q, int rtx_timeout)
                                                     rtx_timeout, &start_timer);
 
                         if (start_timer)
-                                sctp_transport_reset_timers(transport,
-                                                            start_timer-1);
+                                sctp_transport_reset_timers(transport);
 
                         /* This can happen on COOKIE-ECHO resend.  Only
                          * one chunk can get bundled with a COOKIE-ECHO.
@@ -1039,7 +1049,7 @@ static int sctp_outq_flush(struct sctp_outq *q, int rtx_timeout)
                         list_add_tail(&chunk->transmitted_list,
                                       &transport->transmitted);
 
-                        sctp_transport_reset_timers(transport, 0);
+                        sctp_transport_reset_timers(transport);
 
                         q->empty = 0;
 
@@ -1099,32 +1109,6 @@ static void sctp_sack_update_unack_data(struct sctp_association *assoc,
         assoc->unack_data = unack_data;
 }
 
-/* Return the highest new tsn that is acknowledged by the given SACK chunk. */
-static __u32 sctp_highest_new_tsn(struct sctp_sackhdr *sack,
-                                  struct sctp_association *asoc)
-{
-        struct sctp_transport *transport;
-        struct sctp_chunk *chunk;
-        __u32 highest_new_tsn, tsn;
-        struct list_head *transport_list = &asoc->peer.transport_addr_list;
-
-        highest_new_tsn = ntohl(sack->cum_tsn_ack);
-
-        list_for_each_entry(transport, transport_list, transports) {
-                list_for_each_entry(chunk, &transport->transmitted,
-                                transmitted_list) {
-                        tsn = ntohl(chunk->subh.data_hdr->tsn);
-
-                        if (!chunk->tsn_gap_acked &&
-                            TSN_lt(highest_new_tsn, tsn) &&
-                            sctp_acked(sack, tsn))
-                                highest_new_tsn = tsn;
-                }
-        }
-
-        return highest_new_tsn;
-}
-
 /* This is where we REALLY process a SACK.
  *
  * Process the SACK against the outqueue.  Mostly, this just frees
@@ -1144,6 +1128,7 @@ int sctp_outq_sack(struct sctp_outq *q, struct sctp_sackhdr *sack)
         struct sctp_transport *primary = asoc->peer.primary_path;
         int count_of_newacks = 0;
         int gap_ack_blocks;
+        u8 accum_moved = 0;
 
         /* Grab the association's destination address list. */
         transport_list = &asoc->peer.transport_addr_list;
@@ -1192,18 +1177,15 @@ int sctp_outq_sack(struct sctp_outq *q, struct sctp_sackhdr *sack)
         if (gap_ack_blocks)
                 highest_tsn += ntohs(frags[gap_ack_blocks - 1].gab.end);
 
-        if (TSN_lt(asoc->highest_sacked, highest_tsn)) {
-                highest_new_tsn = highest_tsn;
+        if (TSN_lt(asoc->highest_sacked, highest_tsn))
                 asoc->highest_sacked = highest_tsn;
-        } else {
-                highest_new_tsn = sctp_highest_new_tsn(sack, asoc);
-        }
 
+        highest_new_tsn = sack_ctsn;
 
         /* Run through the retransmit queue.  Credit bytes received
          * and free those chunks that we can.
          */
-        sctp_check_transmitted(q, &q->retransmit, NULL, sack, highest_new_tsn);
+        sctp_check_transmitted(q, &q->retransmit, NULL, sack, &highest_new_tsn);
 
         /* Run through the transmitted queue.
          * Credit bytes received and free those chunks which we can.
@@ -1212,7 +1194,7 @@ int sctp_outq_sack(struct sctp_outq *q, struct sctp_sackhdr *sack)
          */
         list_for_each_entry(transport, transport_list, transports) {
                 sctp_check_transmitted(q, &transport->transmitted,
-                                       transport, sack, highest_new_tsn);
+                                       transport, sack, &highest_new_tsn);
                 /*
                  * SFR-CACC algorithm:
                  * C) Let count_of_newacks be the number of
@@ -1222,16 +1204,22 @@ int sctp_outq_sack(struct sctp_outq *q, struct sctp_sackhdr *sack)
                         count_of_newacks ++;
         }
 
+        /* Move the Cumulative TSN Ack Point if appropriate.  */
+        if (TSN_lt(asoc->ctsn_ack_point, sack_ctsn)) {
+                asoc->ctsn_ack_point = sack_ctsn;
+                accum_moved = 1;
+        }
+
         if (gap_ack_blocks) {
+
+                if (asoc->fast_recovery && accum_moved)
+                        highest_new_tsn = highest_tsn;
+
                 list_for_each_entry(transport, transport_list, transports)
                         sctp_mark_missing(q, &transport->transmitted, transport,
                                           highest_new_tsn, count_of_newacks);
         }
 
-        /* Move the Cumulative TSN Ack Point if appropriate.  */
-        if (TSN_lt(asoc->ctsn_ack_point, sack_ctsn))
-                asoc->ctsn_ack_point = sack_ctsn;
-
         /* Update unack_data field in the assoc. */
         sctp_sack_update_unack_data(asoc, sack);
 
@@ -1314,7 +1302,7 @@ static void sctp_check_transmitted(struct sctp_outq *q,
                                    struct list_head *transmitted_queue,
                                    struct sctp_transport *transport,
                                    struct sctp_sackhdr *sack,
-                                   __u32 highest_new_tsn_in_sack)
+                                   __u32 *highest_new_tsn_in_sack)
 {
         struct list_head *lchunk;
         struct sctp_chunk *tchunk;
@@ -1386,7 +1374,6 @@ static void sctp_check_transmitted(struct sctp_outq *q,
                                  * instance).
                                  */
                                 if (!tchunk->tsn_gap_acked &&
-                                    !tchunk->resent &&
                                     tchunk->rtt_in_progress) {
                                         tchunk->rtt_in_progress = 0;
                                         rtt = jiffies - tchunk->sent_at;
@@ -1403,6 +1390,7 @@ static void sctp_check_transmitted(struct sctp_outq *q,
                          */
                         if (!tchunk->tsn_gap_acked) {
                                 tchunk->tsn_gap_acked = 1;
+                                *highest_new_tsn_in_sack = tsn;
                                 bytes_acked += sctp_data_size(tchunk);
                                 if (!tchunk->transport)
                                         migrate_bytes += sctp_data_size(tchunk);
@@ -1676,7 +1664,8 @@ static void sctp_mark_missing(struct sctp_outq *q,
         struct sctp_chunk *chunk;
         __u32 tsn;
         char do_fast_retransmit = 0;
-        struct sctp_transport *primary = q->asoc->peer.primary_path;
+        struct sctp_association *asoc = q->asoc;
+        struct sctp_transport *primary = asoc->peer.primary_path;
 
         list_for_each_entry(chunk, transmitted_queue, transmitted_list) {
 
diff --git a/net/sctp/primitive.c b/net/sctp/primitive.c
index 8cb4f060bce6..534c7eae9d15 100644
--- a/net/sctp/primitive.c
+++ b/net/sctp/primitive.c
@@ -50,6 +50,7 @@
 #include <linux/socket.h>
 #include <linux/ip.h>
 #include <linux/time.h> /* For struct timeval */
+#include <linux/gfp.h>
 #include <net/sock.h>
 #include <net/sctp/sctp.h>
 #include <net/sctp/sm.h>
diff --git a/net/sctp/probe.c b/net/sctp/probe.c
new file mode 100644
index 000000000000..db3a42b8b349
--- /dev/null
+++ b/net/sctp/probe.c
@@ -0,0 +1,214 @@
+/*
+ * sctp_probe - Observe the SCTP flow with kprobes.
+ *
+ * The idea for this came from Werner Almesberger's umlsim
+ * Copyright (C) 2004, Stephen Hemminger <shemminger@osdl.org>
+ *
+ * Modified for SCTP from Stephen Hemminger's code
+ * Copyright (C) 2010, Wei Yongjun <yjwei@cn.fujitsu.com>
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/kernel.h>
+#include <linux/kprobes.h>
+#include <linux/socket.h>
+#include <linux/sctp.h>
+#include <linux/proc_fs.h>
+#include <linux/vmalloc.h>
+#include <linux/module.h>
+#include <linux/kfifo.h>
+#include <linux/time.h>
+#include <net/net_namespace.h>
+
+#include <net/sctp/sctp.h>
+#include <net/sctp/sm.h>
+
+MODULE_AUTHOR("Wei Yongjun <yjwei@cn.fujitsu.com>");
+MODULE_DESCRIPTION("SCTP snooper");
+MODULE_LICENSE("GPL");
+
+static int port __read_mostly = 0;
+MODULE_PARM_DESC(port, "Port to match (0=all)");
+module_param(port, int, 0);
+
+static int bufsize __read_mostly = 64 * 1024;
+MODULE_PARM_DESC(bufsize, "Log buffer size (default 64k)");
+module_param(bufsize, int, 0);
+
+static int full __read_mostly = 1;
+MODULE_PARM_DESC(full, "Full log (1=every ack packet received,  0=only cwnd changes)");
+module_param(full, int, 0);
+
+static const char procname[] = "sctpprobe";
+
+static struct {
+        struct kfifo      fifo;
+        spinlock_t        lock;
+        wait_queue_head_t wait;
+        struct timespec   tstart;
+} sctpw;
+
+static void printl(const char *fmt, ...)
+{
+        va_list args;
+        int len;
+        char tbuf[256];
+
+        va_start(args, fmt);
+        len = vscnprintf(tbuf, sizeof(tbuf), fmt, args);
+        va_end(args);
+
+        kfifo_in_locked(&sctpw.fifo, tbuf, len, &sctpw.lock);
+        wake_up(&sctpw.wait);
+}
+
+static int sctpprobe_open(struct inode *inode, struct file *file)
+{
+        kfifo_reset(&sctpw.fifo);
+        getnstimeofday(&sctpw.tstart);
+
+        return 0;
+}
+
+static ssize_t sctpprobe_read(struct file *file, char __user *buf,
+                              size_t len, loff_t *ppos)
+{
+        int error = 0, cnt = 0;
+        unsigned char *tbuf;
+
+        if (!buf)
+                return -EINVAL;
+
+        if (len == 0)
+                return 0;
+
+        tbuf = vmalloc(len);
+        if (!tbuf)
+                return -ENOMEM;
+
+        error = wait_event_interruptible(sctpw.wait,
+                                         kfifo_len(&sctpw.fifo) != 0);
+        if (error)
+                goto out_free;
+
+        cnt = kfifo_out_locked(&sctpw.fifo, tbuf, len, &sctpw.lock);
+        error = copy_to_user(buf, tbuf, cnt) ? -EFAULT : 0;
+
+out_free:
+        vfree(tbuf);
+
+        return error ? error : cnt;
+}
+
+static const struct file_operations sctpprobe_fops = {
+        .owner  = THIS_MODULE,
+        .open   = sctpprobe_open,
+        .read   = sctpprobe_read,
+};
+
+sctp_disposition_t jsctp_sf_eat_sack(const struct sctp_endpoint *ep,
+                                     const struct sctp_association *asoc,
+                                     const sctp_subtype_t type,
+                                     void *arg,
+                                     sctp_cmd_seq_t *commands)
+{
+        struct sctp_transport *sp;
+        static __u32 lcwnd = 0;
+        struct timespec now;
+
+        sp = asoc->peer.primary_path;
+
+        if ((full || sp->cwnd != lcwnd) &&
+            (!port || asoc->peer.port == port ||
+             ep->base.bind_addr.port == port)) {
+                lcwnd = sp->cwnd;
+
+                getnstimeofday(&now);
+                now = timespec_sub(now, sctpw.tstart);
+
+                printl("%lu.%06lu ", (unsigned long) now.tv_sec,
+                       (unsigned long) now.tv_nsec / NSEC_PER_USEC);
+
+                printl("%p %5d %5d %5d %8d %5d ", asoc,
+                       ep->base.bind_addr.port, asoc->peer.port,
+                       asoc->pathmtu, asoc->peer.rwnd, asoc->unack_data);
+
+                list_for_each_entry(sp, &asoc->peer.transport_addr_list,
+                                        transports) {
+                        if (sp == asoc->peer.primary_path)
+                                printl("*");
+
+                        if (sp->ipaddr.sa.sa_family == AF_INET)
+                                printl("%pI4 ", &sp->ipaddr.v4.sin_addr);
+                        else
+                                printl("%pI6 ", &sp->ipaddr.v6.sin6_addr);
+
+                        printl("%2u %8u %8u %8u %8u %8u ",
+                               sp->state, sp->cwnd, sp->ssthresh,
+                               sp->flight_size, sp->partial_bytes_acked,
+                               sp->pathmtu);
+                }
+                printl("\n");
+        }
+
+        jprobe_return();
+        return 0;
+}
+
+static struct jprobe sctp_recv_probe = {
+        .kp     = {
+                .symbol_name = "sctp_sf_eat_sack_6_2",
+        },
+        .entry  = jsctp_sf_eat_sack,
+};
+
+static __init int sctpprobe_init(void)
+{
+        int ret = -ENOMEM;
+
+        init_waitqueue_head(&sctpw.wait);
+        spin_lock_init(&sctpw.lock);
+        if (kfifo_alloc(&sctpw.fifo, bufsize, GFP_KERNEL))
+                return ret;
+
+        if (!proc_net_fops_create(&init_net, procname, S_IRUSR,
+                                  &sctpprobe_fops))
+                goto free_kfifo;
+
+        ret = register_jprobe(&sctp_recv_probe);
+        if (ret)
+                goto remove_proc;
+
+        pr_info("SCTP probe registered (port=%d)\n", port);
+
+        return 0;
+
+remove_proc:
+        proc_net_remove(&init_net, procname);
+free_kfifo:
+        kfifo_free(&sctpw.fifo);
+        return ret;
+}
+
+static __exit void sctpprobe_exit(void)
+{
+        kfifo_free(&sctpw.fifo);
+        proc_net_remove(&init_net, procname);
+        unregister_jprobe(&sctp_recv_probe);
+}
+
+module_init(sctpprobe_init);
+module_exit(sctpprobe_exit);
diff --git a/net/sctp/protocol.c b/net/sctp/protocol.c
index e771690f6d5d..182749867c72 100644
--- a/net/sctp/protocol.c
+++ b/net/sctp/protocol.c
@@ -54,6 +54,7 @@
 #include <linux/bootmem.h>
 #include <linux/highmem.h>
 #include <linux/swap.h>
+#include <linux/slab.h>
 #include <net/net_namespace.h>
 #include <net/protocol.h>
 #include <net/ip.h>
@@ -473,13 +474,17 @@ static struct dst_entry *sctp_v4_get_dst(struct sctp_association *asoc,
 
         memset(&fl, 0x0, sizeof(struct flowi));
         fl.fl4_dst  = daddr->v4.sin_addr.s_addr;
+        fl.fl_ip_dport = daddr->v4.sin_port;
         fl.proto = IPPROTO_SCTP;
         if (asoc) {
                 fl.fl4_tos = RT_CONN_FLAGS(asoc->base.sk);
                 fl.oif = asoc->base.sk->sk_bound_dev_if;
+                fl.fl_ip_sport = htons(asoc->base.bind_addr.port);
         }
-        if (saddr)
+        if (saddr) {
                 fl.fl4_src = saddr->v4.sin_addr.s_addr;
+                fl.fl_ip_sport = saddr->v4.sin_port;
+        }
 
         SCTP_DEBUG_PRINTK("%s: DST:%pI4, SRC:%pI4 - ",
                           __func__, &fl.fl4_dst, &fl.fl4_src);
@@ -527,6 +532,7 @@ static struct dst_entry *sctp_v4_get_dst(struct sctp_association *asoc,
                 if ((laddr->state == SCTP_ADDR_SRC) &&
                     (AF_INET == laddr->a.sa.sa_family)) {
                         fl.fl4_src = laddr->a.v4.sin_addr.s_addr;
+                        fl.fl_ip_sport = laddr->a.v4.sin_port;
                         if (!ip_route_output_key(&init_net, &rt, &fl)) {
                                 dst = &rt->u.dst;
                                 goto out_unlock;
@@ -853,7 +859,7 @@ static inline int sctp_v4_xmit(struct sk_buff *skb,
                          IP_PMTUDISC_DO : IP_PMTUDISC_DONT;
 
         SCTP_INC_STATS(SCTP_MIB_OUTSCTPPACKS);
-        return ip_queue_xmit(skb, 0);
+        return ip_queue_xmit(skb);
 }
 
 static struct sctp_af sctp_af_inet;
diff --git a/net/sctp/sm_make_chunk.c b/net/sctp/sm_make_chunk.c
index 9e732916b671..d8261f3d7715 100644
--- a/net/sctp/sm_make_chunk.c
+++ b/net/sctp/sm_make_chunk.c
@@ -58,6 +58,7 @@
 #include <linux/inet.h>
 #include <linux/scatterlist.h>
 #include <linux/crypto.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 
 #include <linux/skbuff.h>
@@ -107,7 +108,7 @@ static const struct sctp_paramhdr prsctp_param = {
         cpu_to_be16(sizeof(struct sctp_paramhdr)),
 };
 
-/* A helper to initialize to initialize an op error inside a
+/* A helper to initialize an op error inside a
  * provided chunk, as most cause codes will be embedded inside an
  * abort chunk.
  */
@@ -124,6 +125,29 @@ void  sctp_init_cause(struct sctp_chunk *chunk, __be16 cause_code,
         chunk->subh.err_hdr = sctp_addto_chunk(chunk, sizeof(sctp_errhdr_t), &err);
 }
 
+/* A helper to initialize an op error inside a
+ * provided chunk, as most cause codes will be embedded inside an
+ * abort chunk.  Differs from sctp_init_cause in that it won't oops
+ * if there isn't enough space in the op error chunk
+ */
+int sctp_init_cause_fixed(struct sctp_chunk *chunk, __be16 cause_code,
+                      size_t paylen)
+{
+        sctp_errhdr_t err;
+        __u16 len;
+
+        /* Cause code constants are now defined in network order.  */
+        err.cause = cause_code;
+        len = sizeof(sctp_errhdr_t) + paylen;
+        err.length  = htons(len);
+
+        if (skb_tailroom(chunk->skb) >  len)
+                return -ENOSPC;
+        chunk->subh.err_hdr = sctp_addto_chunk_fixed(chunk,
+                                                     sizeof(sctp_errhdr_t),
+                                                     &err);
+        return 0;
+}
 /* 3.3.2 Initiation (INIT) (1)
  *
  * This chunk is used to initiate a SCTP association between two
@@ -207,7 +231,8 @@ struct sctp_chunk *sctp_make_init(const struct sctp_association *asoc,
         sp = sctp_sk(asoc->base.sk);
         num_types = sp->pf->supported_addrs(sp, types);
 
-        chunksize = sizeof(init) + addrs_len + SCTP_SAT_LEN(num_types);
+        chunksize = sizeof(init) + addrs_len;
+        chunksize += WORD_ROUND(SCTP_SAT_LEN(num_types));
         chunksize += sizeof(ecap_param);
 
         if (sctp_prsctp_enable)
@@ -237,14 +262,14 @@ struct sctp_chunk *sctp_make_init(const struct sctp_association *asoc,
                 /* Add HMACS parameter length if any were defined */
                 auth_hmacs = (sctp_paramhdr_t *)asoc->c.auth_hmacs;
                 if (auth_hmacs->length)
-                        chunksize += ntohs(auth_hmacs->length);
+                        chunksize += WORD_ROUND(ntohs(auth_hmacs->length));
                 else
                         auth_hmacs = NULL;
 
                 /* Add CHUNKS parameter length */
                 auth_chunks = (sctp_paramhdr_t *)asoc->c.auth_chunks;
                 if (auth_chunks->length)
-                        chunksize += ntohs(auth_chunks->length);
+                        chunksize += WORD_ROUND(ntohs(auth_chunks->length));
                 else
                         auth_chunks = NULL;
 
@@ -254,7 +279,8 @@ struct sctp_chunk *sctp_make_init(const struct sctp_association *asoc,
 
         /* If we have any extensions to report, account for that */
         if (num_ext)
-                chunksize += sizeof(sctp_supported_ext_param_t) + num_ext;
+                chunksize += WORD_ROUND(sizeof(sctp_supported_ext_param_t) +
+                                        num_ext);
 
         /* RFC 2960 3.3.2 Initiation (INIT) (1)
          *
@@ -396,13 +422,13 @@ struct sctp_chunk *sctp_make_init_ack(const struct sctp_association *asoc,
 
                 auth_hmacs = (sctp_paramhdr_t *)asoc->c.auth_hmacs;
                 if (auth_hmacs->length)
-                        chunksize += ntohs(auth_hmacs->length);
+                        chunksize += WORD_ROUND(ntohs(auth_hmacs->length));
                 else
                         auth_hmacs = NULL;
 
                 auth_chunks = (sctp_paramhdr_t *)asoc->c.auth_chunks;
                 if (auth_chunks->length)
-                        chunksize += ntohs(auth_chunks->length);
+                        chunksize += WORD_ROUND(ntohs(auth_chunks->length));
                 else
                         auth_chunks = NULL;
 
@@ -411,17 +437,25 @@ struct sctp_chunk *sctp_make_init_ack(const struct sctp_association *asoc,
         }
 
         if (num_ext)
-                chunksize += sizeof(sctp_supported_ext_param_t) + num_ext;
+                chunksize += WORD_ROUND(sizeof(sctp_supported_ext_param_t) +
+                                        num_ext);
 
         /* Now allocate and fill out the chunk.  */
         retval = sctp_make_chunk(asoc, SCTP_CID_INIT_ACK, 0, chunksize);
         if (!retval)
                 goto nomem_chunk;
 
-        /* Per the advice in RFC 2960 6.4, send this reply to
-         * the source of the INIT packet.
+        /* RFC 2960 6.4 Multi-homed SCTP Endpoints
+         *
+         * An endpoint SHOULD transmit reply chunks (e.g., SACK,
+         * HEARTBEAT ACK, * etc.) to the same destination transport
+         * address from which it received the DATA or control chunk
+         * to which it is replying.
+         *
+         * [INIT ACK back to where the INIT came from.]
          */
         retval->transport = chunk->transport;
+
         retval->subh.init_hdr =
                 sctp_addto_chunk(retval, sizeof(initack), &initack);
         retval->param_hdr.v = sctp_addto_chunk(retval, addrs_len, addrs.v);
@@ -460,18 +494,6 @@ struct sctp_chunk *sctp_make_init_ack(const struct sctp_association *asoc,
         /* We need to remove the const qualifier at this point.  */
         retval->asoc = (struct sctp_association *) asoc;
 
-        /* RFC 2960 6.4 Multi-homed SCTP Endpoints
-         *
-         * An endpoint SHOULD transmit reply chunks (e.g., SACK,
-         * HEARTBEAT ACK, * etc.) to the same destination transport
-         * address from which it received the DATA or control chunk
-         * to which it is replying.
-         *
-         * [INIT ACK back to where the INIT came from.]
-         */
-        if (chunk)
-                retval->transport = chunk->transport;
-
 nomem_chunk:
         kfree(cookie);
 nomem_cookie:
@@ -1128,6 +1150,24 @@ nodata:
         return retval;
 }
 
+/* Create an Operation Error chunk of a fixed size,
+ * specifically, max(asoc->pathmtu, SCTP_DEFAULT_MAXSEGMENT)
+ * This is a helper function to allocate an error chunk for
+ * for those invalid parameter codes in which we may not want
+ * to report all the errors, if the incomming chunk is large
+ */
+static inline struct sctp_chunk *sctp_make_op_error_fixed(
+        const struct sctp_association *asoc,
+        const struct sctp_chunk *chunk)
+{
+        size_t size = asoc ? asoc->pathmtu : 0;
+
+        if (!size)
+                size = SCTP_DEFAULT_MAXSEGMENT;
+
+        return sctp_make_op_error_space(asoc, chunk, size);
+}
+
 /* Create an Operation Error chunk.  */
 struct sctp_chunk *sctp_make_op_error(const struct sctp_association *asoc,
                                  const struct sctp_chunk *chunk,
@@ -1209,7 +1249,6 @@ struct sctp_chunk *sctp_chunkify(struct sk_buff *skb,
         INIT_LIST_HEAD(&retval->list);
         retval->skb             = skb;
         retval->asoc            = (struct sctp_association *)asoc;
-        retval->resent          = 0;
         retval->has_tsn         = 0;
         retval->has_ssn         = 0;
         retval->rtt_in_progress = 0;
@@ -1370,6 +1409,18 @@ void *sctp_addto_chunk(struct sctp_chunk *chunk, int len, const void *data)
         return target;
 }
 
+/* Append bytes to the end of a chunk. Returns NULL if there isn't sufficient
+ * space in the chunk
+ */
+void *sctp_addto_chunk_fixed(struct sctp_chunk *chunk,
+                             int len, const void *data)
+{
+        if (skb_tailroom(chunk->skb) > len)
+                return sctp_addto_chunk(chunk, len, data);
+        else
+                return NULL;
+}
+
 /* Append bytes from user space to the end of a chunk.  Will panic if
  * chunk is not big enough.
  * Returns a kernel err value.
@@ -1973,13 +2024,12 @@ static sctp_ierror_t sctp_process_unk_param(const struct sctp_association *asoc,
                  * returning multiple unknown parameters.
                  */
                 if (NULL == *errp)
-                        *errp = sctp_make_op_error_space(asoc, chunk,
-                                        ntohs(chunk->chunk_hdr->length));
+                        *errp = sctp_make_op_error_fixed(asoc, chunk);
 
                 if (*errp) {
-                        sctp_init_cause(*errp, SCTP_ERROR_UNKNOWN_PARAM,
+                        sctp_init_cause_fixed(*errp, SCTP_ERROR_UNKNOWN_PARAM,
                                         WORD_ROUND(ntohs(param.p->length)));
-                        sctp_addto_chunk(*errp,
+                        sctp_addto_chunk_fixed(*errp,
                                         WORD_ROUND(ntohs(param.p->length)),
                                         param.v);
                 } else {
@@ -3314,21 +3364,6 @@ int sctp_process_asconf_ack(struct sctp_association *asoc,
         sctp_chunk_free(asconf);
         asoc->addip_last_asconf = NULL;
 
-        /* Send the next asconf chunk from the addip chunk queue. */
-        if (!list_empty(&asoc->addip_chunk_list)) {
-                struct list_head *entry = asoc->addip_chunk_list.next;
-                asconf = list_entry(entry, struct sctp_chunk, list);
-
-                list_del_init(entry);
-
-                /* Hold the chunk until an ASCONF_ACK is received. */
-                sctp_chunk_hold(asconf);
-                if (sctp_primitive_ASCONF(asoc, asconf))
-                        sctp_chunk_free(asconf);
-                else
-                        asoc->addip_last_asconf = asconf;
-        }
-
         return retval;
 }
 
diff --git a/net/sctp/sm_sideeffect.c b/net/sctp/sm_sideeffect.c
index 4e4ca65cd320..3b7230ef77c2 100644
--- a/net/sctp/sm_sideeffect.c
+++ b/net/sctp/sm_sideeffect.c
@@ -51,6 +51,7 @@
 #include <linux/types.h>
 #include <linux/socket.h>
 #include <linux/ip.h>
+#include <linux/gfp.h>
 #include <net/sock.h>
 #include <net/sctp/sctp.h>
 #include <net/sctp/sm.h>
@@ -475,7 +476,7 @@ static void sctp_do_8_2_transport_strike(struct sctp_association *asoc,
          * used to provide an upper bound to this doubling operation.
          *
          * Special Case:  the first HB doesn't trigger exponential backoff.
-         * The first unacknowleged HB triggers it.  We do this with a flag
+         * The first unacknowledged HB triggers it.  We do this with a flag
          * that indicates that we have an outstanding HB.
          */
         if (!is_hb || transport->hb_sent) {
@@ -696,11 +697,15 @@ static void sctp_cmd_setup_t2(sctp_cmd_seq_t *cmds,
 {
         struct sctp_transport *t;
 
-        t = sctp_assoc_choose_alter_transport(asoc,
+        if (chunk->transport)
+                t = chunk->transport;
+        else {
+                t = sctp_assoc_choose_alter_transport(asoc,
                                               asoc->shutdown_last_sent_to);
+                chunk->transport = t;
+        }
         asoc->shutdown_last_sent_to = t;
         asoc->timeouts[SCTP_EVENT_TIMEOUT_T2_SHUTDOWN] = t->rto;
-        chunk->transport = t;
 }
 
 /* Helper function to change the state of an association. */
@@ -961,6 +966,29 @@ static int sctp_cmd_send_msg(struct sctp_association *asoc,
 }
 
 
+/* Sent the next ASCONF packet currently stored in the association.
+ * This happens after the ASCONF_ACK was succeffully processed.
+ */
+static void sctp_cmd_send_asconf(struct sctp_association *asoc)
+{
+        /* Send the next asconf chunk from the addip chunk
+         * queue.
+         */
+        if (!list_empty(&asoc->addip_chunk_list)) {
+                struct list_head *entry = asoc->addip_chunk_list.next;
+                struct sctp_chunk *asconf = list_entry(entry,
+                                                struct sctp_chunk, list);
+                list_del_init(entry);
+
+                /* Hold the chunk until an ASCONF_ACK is received. */
+                sctp_chunk_hold(asconf);
+                if (sctp_primitive_ASCONF(asoc, asconf))
+                        sctp_chunk_free(asconf);
+                else
+                        asoc->addip_last_asconf = asconf;
+        }
+}
+
 
 /* These three macros allow us to pull the debugging code out of the
  * main flow of sctp_do_sm() to keep attention focused on the real
@@ -1616,6 +1644,9 @@ static int sctp_cmd_interpreter(sctp_event_t event_type,
                         }
                         error = sctp_cmd_send_msg(asoc, cmd->obj.msg);
                         break;
+                case SCTP_CMD_SEND_NEXT_ASCONF:
+                        sctp_cmd_send_asconf(asoc);
+                        break;
                 default:
                         printk(KERN_WARNING "Impossible command: %u, %p\n",
                                cmd->verb, cmd->obj.ptr);
diff --git a/net/sctp/sm_statefuns.c b/net/sctp/sm_statefuns.c
index 47bc20d3a85b..24b2cd555637 100644
--- a/net/sctp/sm_statefuns.c
+++ b/net/sctp/sm_statefuns.c
@@ -56,6 +56,7 @@
 #include <linux/ipv6.h>
 #include <linux/net.h>
 #include <linux/inet.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 #include <net/inet_ecn.h>
 #include <linux/skbuff.h>
@@ -3675,8 +3676,14 @@ sctp_disposition_t sctp_sf_do_asconf_ack(const struct sctp_endpoint *ep,
                                 SCTP_TO(SCTP_EVENT_TIMEOUT_T4_RTO));
 
                 if (!sctp_process_asconf_ack((struct sctp_association *)asoc,
-                                             asconf_ack))
+                                             asconf_ack)) {
+                        /* Successfully processed ASCONF_ACK.  We can
+                         * release the next asconf if we have one.
+                         */
+                        sctp_add_cmd_sf(commands, SCTP_CMD_SEND_NEXT_ASCONF,
+                                        SCTP_NULL());
                         return SCTP_DISPOSITION_CONSUME;
+                }
 
                 abort = sctp_make_abort(asoc, asconf_ack,
                                         sizeof(sctp_errhdr_t));
diff --git a/net/sctp/socket.c b/net/sctp/socket.c
index dfc5c127efd4..ba1add0b13c3 100644
--- a/net/sctp/socket.c
+++ b/net/sctp/socket.c
@@ -67,6 +67,7 @@
 #include <linux/poll.h>
 #include <linux/init.h>
 #include <linux/crypto.h>
+#include <linux/slab.h>
 
 #include <net/ip.h>
 #include <net/icmp.h>
@@ -3718,12 +3719,9 @@ SCTP_STATIC int sctp_init_sock(struct sock *sk)
         sp->hmac = NULL;
 
         SCTP_DBG_OBJCNT_INC(sock);
-        percpu_counter_inc(&sctp_sockets_allocated);
-
-        /* Set socket backlog limit. */
-        sk->sk_backlog.limit = sysctl_sctp_rmem[1];
 
         local_bh_disable();
+        percpu_counter_inc(&sctp_sockets_allocated);
         sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
         local_bh_enable();
 
@@ -3740,8 +3738,8 @@ SCTP_STATIC void sctp_destroy_sock(struct sock *sk)
         /* Release our hold on the endpoint. */
         ep = sctp_sk(sk)->ep;
         sctp_endpoint_free(ep);
-        percpu_counter_dec(&sctp_sockets_allocated);
         local_bh_disable();
+        percpu_counter_dec(&sctp_sockets_allocated);
         sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
         local_bh_enable();
 }
@@ -4386,7 +4384,7 @@ static int sctp_getsockopt_peer_addrs(struct sock *sk, int len,
                                 transports) {
                 memcpy(&temp, &from->ipaddr, sizeof(temp));
                 sctp_get_pf_specific(sk->sk_family)->addr_v4map(sp, &temp);
-                addrlen = sctp_get_af_specific(sk->sk_family)->sockaddr_len;
+                addrlen = sctp_get_af_specific(temp.sa.sa_family)->sockaddr_len;
                 if (space_left < addrlen)
                         return -ENOMEM;
                 if (copy_to_user(to, &temp, addrlen))
@@ -5481,7 +5479,6 @@ pp_found:
                  */
                 int reuse = sk->sk_reuse;
                 struct sock *sk2;
-                struct hlist_node *node;
 
                 SCTP_DEBUG_PRINTK("sctp_get_port() found a possible match\n");
                 if (pp->fastreuse && sk->sk_reuse &&
@@ -5702,7 +5699,7 @@ unsigned int sctp_poll(struct file *file, struct socket *sock, poll_table *wait)
         struct sctp_sock *sp = sctp_sk(sk);
         unsigned int mask;
 
-        poll_wait(file, sk->sk_sleep, wait);
+        poll_wait(file, sk_sleep(sk), wait);
 
         /* A TCP-style listening socket becomes readable when the accept queue
          * is not empty.
@@ -5943,7 +5940,7 @@ static int sctp_wait_for_packet(struct sock * sk, int *err, long *timeo_p)
         int error;
         DEFINE_WAIT(wait);
 
-        prepare_to_wait_exclusive(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+        prepare_to_wait_exclusive(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
 
         /* Socket errors? */
         error = sock_error(sk);
@@ -5980,14 +5977,14 @@ static int sctp_wait_for_packet(struct sock * sk, int *err, long *timeo_p)
         sctp_lock_sock(sk);
 
 ready:
-        finish_wait(sk->sk_sleep, &wait);
+        finish_wait(sk_sleep(sk), &wait);
         return 0;
 
 interrupted:
         error = sock_intr_errno(*timeo_p);
 
 out:
-        finish_wait(sk->sk_sleep, &wait);
+        finish_wait(sk_sleep(sk), &wait);
         *err = error;
         return error;
 }
@@ -6061,14 +6058,14 @@ static void __sctp_write_space(struct sctp_association *asoc)
                         wake_up_interruptible(&asoc->wait);
 
                 if (sctp_writeable(sk)) {
-                        if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
-                                wake_up_interruptible(sk->sk_sleep);
+                        if (sk_sleep(sk) && waitqueue_active(sk_sleep(sk)))
+                                wake_up_interruptible(sk_sleep(sk));
 
                         /* Note that we try to include the Async I/O support
                          * here by modeling from the current TCP/UDP code.
                          * We have not tested with it yet.
                          */
-                        if (sock->fasync_list &&
+                        if (sock->wq->fasync_list &&
                             !(sk->sk_shutdown & SEND_SHUTDOWN))
                                 sock_wake_async(sock,
                                                 SOCK_WAKE_SPACE, POLL_OUT);
@@ -6188,6 +6185,19 @@ do_nonblock:
         goto out;
 }
 
+void sctp_data_ready(struct sock *sk, int len)
+{
+        struct socket_wq *wq;
+
+        rcu_read_lock();
+        wq = rcu_dereference(sk->sk_wq);
+        if (wq_has_sleeper(wq))
+                wake_up_interruptible_sync_poll(&wq->wait, POLLIN |
+                                                POLLRDNORM | POLLRDBAND);
+        sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
+        rcu_read_unlock();
+}
+
 /* If socket sndbuf has changed, wake up all per association waiters.  */
 void sctp_write_space(struct sock *sk)
 {
@@ -6296,7 +6306,7 @@ static int sctp_wait_for_accept(struct sock *sk, long timeo)
 
 
         for (;;) {
-                prepare_to_wait_exclusive(sk->sk_sleep, &wait,
+                prepare_to_wait_exclusive(sk_sleep(sk), &wait,
                                           TASK_INTERRUPTIBLE);
 
                 if (list_empty(&ep->asocs)) {
@@ -6322,7 +6332,7 @@ static int sctp_wait_for_accept(struct sock *sk, long timeo)
                         break;
         }
 
-        finish_wait(sk->sk_sleep, &wait);
+        finish_wait(sk_sleep(sk), &wait);
 
         return err;
 }
@@ -6332,7 +6342,7 @@ static void sctp_wait_for_close(struct sock *sk, long timeout)
         DEFINE_WAIT(wait);
 
         do {
-                prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+                prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
                 if (list_empty(&sctp_sk(sk)->ep->asocs))
                         break;
                 sctp_release_sock(sk);
@@ -6340,7 +6350,7 @@ static void sctp_wait_for_close(struct sock *sk, long timeout)
                 sctp_lock_sock(sk);
         } while (!signal_pending(current) && timeout);
 
-        finish_wait(sk->sk_sleep, &wait);
+        finish_wait(sk_sleep(sk), &wait);
 }
 
 static void sctp_skb_set_owner_r_frag(struct sk_buff *skb, struct sock *sk)
diff --git a/net/sctp/ssnmap.c b/net/sctp/ssnmap.c
index 737d330e5ffc..442ad4ed6315 100644
--- a/net/sctp/ssnmap.c
+++ b/net/sctp/ssnmap.c
@@ -37,6 +37,7 @@
  */
 
 #include <linux/types.h>
+#include <linux/slab.h>
 #include <net/sctp/sctp.h>
 #include <net/sctp/sm.h>
 
diff --git a/net/sctp/transport.c b/net/sctp/transport.c
index b827d21dbe54..fccf4947aff1 100644
--- a/net/sctp/transport.c
+++ b/net/sctp/transport.c
@@ -48,6 +48,7 @@
  * be incorporated into the next SCTP release.
  */
 
+#include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/random.h>
 #include <net/sctp/sctp.h>
@@ -63,9 +64,6 @@ static struct sctp_transport *sctp_transport_init(struct sctp_transport *peer,
         /* Copy in the address.  */
         peer->ipaddr = *addr;
         peer->af_specific = sctp_get_af_specific(addr->sa.sa_family);
-        peer->asoc = NULL;
-
-        peer->dst = NULL;
         memset(&peer->saddr, 0, sizeof(union sctp_addr));
 
         /* From 6.3.1 RTO Calculation:
@@ -75,34 +73,21 @@ static struct sctp_transport *sctp_transport_init(struct sctp_transport *peer,
          * parameter 'RTO.Initial'.
          */
         peer->rto = msecs_to_jiffies(sctp_rto_initial);
-        peer->rtt = 0;
-        peer->rttvar = 0;
-        peer->srtt = 0;
-        peer->rto_pending = 0;
-        peer->hb_sent = 0;
-        peer->fast_recovery = 0;
 
         peer->last_time_heard = jiffies;
         peer->last_time_ecne_reduced = jiffies;
 
-        peer->init_sent_count = 0;
-
         peer->param_flags = SPP_HB_DISABLE |
                             SPP_PMTUD_ENABLE |
                             SPP_SACKDELAY_ENABLE;
-        peer->hbinterval  = 0;
 
         /* Initialize the default path max_retrans.  */
         peer->pathmaxrxt  = sctp_max_retrans_path;
-        peer->error_count = 0;
 
         INIT_LIST_HEAD(&peer->transmitted);
         INIT_LIST_HEAD(&peer->send_ready);
         INIT_LIST_HEAD(&peer->transports);
 
-        peer->T3_rtx_timer.expires = 0;
-        peer->hb_timer.expires = 0;
-
         setup_timer(&peer->T3_rtx_timer, sctp_generate_t3_rtx_event,
                         (unsigned long)peer);
         setup_timer(&peer->hb_timer, sctp_generate_heartbeat_event,
@@ -112,15 +97,6 @@ static struct sctp_transport *sctp_transport_init(struct sctp_transport *peer,
         get_random_bytes(&peer->hb_nonce, sizeof(peer->hb_nonce));
 
         atomic_set(&peer->refcnt, 1);
-        peer->dead = 0;
-
-        peer->malloced = 0;
-
-        /* Initialize the state information for SFR-CACC */
-        peer->cacc.changeover_active = 0;
-        peer->cacc.cycling_changeover = 0;
-        peer->cacc.next_tsn_at_change = 0;
-        peer->cacc.cacc_saw_newack = 0;
 
         return peer;
 }
@@ -194,7 +170,7 @@ static void sctp_transport_destroy(struct sctp_transport *transport)
 /* Start T3_rtx timer if it is not already running and update the heartbeat
  * timer.  This routine is called every time a DATA chunk is sent.
  */
-void sctp_transport_reset_timers(struct sctp_transport *transport, int force)
+void sctp_transport_reset_timers(struct sctp_transport *transport)
 {
         /* RFC 2960 6.3.2 Retransmission Timer Rules
          *
@@ -204,7 +180,7 @@ void sctp_transport_reset_timers(struct sctp_transport *transport, int force)
          * address.
          */
 
-        if (force || !timer_pending(&transport->T3_rtx_timer))
+        if (!timer_pending(&transport->T3_rtx_timer))
                 if (!mod_timer(&transport->T3_rtx_timer,
                                jiffies + transport->rto))
                         sctp_transport_hold(transport);
@@ -402,15 +378,16 @@ void sctp_transport_update_rto(struct sctp_transport *tp, __u32 rtt)
 void sctp_transport_raise_cwnd(struct sctp_transport *transport,
                                __u32 sack_ctsn, __u32 bytes_acked)
 {
+        struct sctp_association *asoc = transport->asoc;
         __u32 cwnd, ssthresh, flight_size, pba, pmtu;
 
         cwnd = transport->cwnd;
         flight_size = transport->flight_size;
 
         /* See if we need to exit Fast Recovery first */
-        if (transport->fast_recovery &&
-            TSN_lte(transport->fast_recovery_exit, sack_ctsn))
-                transport->fast_recovery = 0;
+        if (asoc->fast_recovery &&
+            TSN_lte(asoc->fast_recovery_exit, sack_ctsn))
+                asoc->fast_recovery = 0;
 
         /* The appropriate cwnd increase algorithm is performed if, and only
          * if the cumulative TSN whould advanced and the congestion window is
@@ -439,7 +416,7 @@ void sctp_transport_raise_cwnd(struct sctp_transport *transport,
                  *    2) the destination's path MTU.  This upper bound protects
                  *    against the ACK-Splitting attack outlined in [SAVAGE99].
                  */
-                if (transport->fast_recovery)
+                if (asoc->fast_recovery)
                         return;
 
                 if (bytes_acked > pmtu)
@@ -490,6 +467,8 @@ void sctp_transport_raise_cwnd(struct sctp_transport *transport,
 void sctp_transport_lower_cwnd(struct sctp_transport *transport,
                                sctp_lower_cwnd_t reason)
 {
+        struct sctp_association *asoc = transport->asoc;
+
         switch (reason) {
         case SCTP_LOWER_CWND_T3_RTX:
                 /* RFC 2960 Section 7.2.3, sctpimpguide
@@ -500,11 +479,11 @@ void sctp_transport_lower_cwnd(struct sctp_transport *transport,
                  *      partial_bytes_acked = 0
                  */
                 transport->ssthresh = max(transport->cwnd/2,
-                                          4*transport->asoc->pathmtu);
-                transport->cwnd = transport->asoc->pathmtu;
+                                          4*asoc->pathmtu);
+                transport->cwnd = asoc->pathmtu;
 
-                /* T3-rtx also clears fast recovery on the transport */
-                transport->fast_recovery = 0;
+                /* T3-rtx also clears fast recovery */
+                asoc->fast_recovery = 0;
                 break;
 
         case SCTP_LOWER_CWND_FAST_RTX:
@@ -520,15 +499,15 @@ void sctp_transport_lower_cwnd(struct sctp_transport *transport,
                  *      cwnd = ssthresh
                  *      partial_bytes_acked = 0
                  */
-                if (transport->fast_recovery)
+                if (asoc->fast_recovery)
                         return;
 
                 /* Mark Fast recovery */
-                transport->fast_recovery = 1;
-                transport->fast_recovery_exit = transport->asoc->next_tsn - 1;
+                asoc->fast_recovery = 1;
+                asoc->fast_recovery_exit = asoc->next_tsn - 1;
 
                 transport->ssthresh = max(transport->cwnd/2,
-                                          4*transport->asoc->pathmtu);
+                                          4*asoc->pathmtu);
                 transport->cwnd = transport->ssthresh;
                 break;
 
@@ -548,7 +527,7 @@ void sctp_transport_lower_cwnd(struct sctp_transport *transport,
                 if (time_after(jiffies, transport->last_time_ecne_reduced +
                                         transport->rtt)) {
                         transport->ssthresh = max(transport->cwnd/2,
-                                                  4*transport->asoc->pathmtu);
+                                                  4*asoc->pathmtu);
                         transport->cwnd = transport->ssthresh;
                         transport->last_time_ecne_reduced = jiffies;
                 }
@@ -564,7 +543,7 @@ void sctp_transport_lower_cwnd(struct sctp_transport *transport,
                  * interval.
                  */
                 transport->cwnd = max(transport->cwnd/2,
-                                         4*transport->asoc->pathmtu);
+                                         4*asoc->pathmtu);
                 break;
         }
 
@@ -649,7 +628,6 @@ void sctp_transport_reset(struct sctp_transport *t)
         t->error_count = 0;
         t->rto_pending = 0;
         t->hb_sent = 0;
-        t->fast_recovery = 0;
 
         /* Initialize the state information for SFR-CACC */
         t->cacc.changeover_active = 0;
diff --git a/net/sctp/tsnmap.c b/net/sctp/tsnmap.c
index 9bd64565021a..747d5412c463 100644
--- a/net/sctp/tsnmap.c
+++ b/net/sctp/tsnmap.c
@@ -42,6 +42,7 @@
  * be incorporated into the next SCTP release.
  */
 
+#include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/bitmap.h>
 #include <net/sctp/sctp.h>
diff --git a/net/sctp/ulpevent.c b/net/sctp/ulpevent.c
index 8b3560fd876d..aa72e89c3ee1 100644
--- a/net/sctp/ulpevent.c
+++ b/net/sctp/ulpevent.c
@@ -43,6 +43,7 @@
  * be incorporated into the next SCTP release.
  */
 
+#include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/skbuff.h>
 #include <net/sctp/structs.h>
diff --git a/net/sctp/ulpqueue.c b/net/sctp/ulpqueue.c
index 7b23803343cc..3a448536f0b6 100644
--- a/net/sctp/ulpqueue.c
+++ b/net/sctp/ulpqueue.c
@@ -41,6 +41,7 @@
  * be incorporated into the next SCTP release.
  */
 
+#include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/skbuff.h>
 #include <net/sock.h>
diff --git a/net/socket.c b/net/socket.c
index 769c386bd428..dae8c6b84a09 100644
--- a/net/socket.c
+++ b/net/socket.c
@@ -87,6 +87,7 @@
 #include <linux/wireless.h>
 #include <linux/nsproxy.h>
 #include <linux/magic.h>
+#include <linux/slab.h>
 
 #include <asm/uaccess.h>
 #include <asm/unistd.h>
@@ -251,9 +252,14 @@ static struct inode *sock_alloc_inode(struct super_block *sb)
         ei = kmem_cache_alloc(sock_inode_cachep, GFP_KERNEL);
         if (!ei)
                 return NULL;
-        init_waitqueue_head(&ei->socket.wait);
+        ei->socket.wq = kmalloc(sizeof(struct socket_wq), GFP_KERNEL);
+        if (!ei->socket.wq) {
+                kmem_cache_free(sock_inode_cachep, ei);
+                return NULL;
+        }
+        init_waitqueue_head(&ei->socket.wq->wait);
+        ei->socket.wq->fasync_list = NULL;
 
-        ei->socket.fasync_list = NULL;
         ei->socket.state = SS_UNCONNECTED;
         ei->socket.flags = 0;
         ei->socket.ops = NULL;
@@ -263,10 +269,21 @@ static struct inode *sock_alloc_inode(struct super_block *sb)
         return &ei->vfs_inode;
 }
 
+
+static void wq_free_rcu(struct rcu_head *head)
+{
+        struct socket_wq *wq = container_of(head, struct socket_wq, rcu);
+
+        kfree(wq);
+}
+
 static void sock_destroy_inode(struct inode *inode)
 {
-        kmem_cache_free(sock_inode_cachep,
-                        container_of(inode, struct socket_alloc, vfs_inode));
+        struct socket_alloc *ei;
+
+        ei = container_of(inode, struct socket_alloc, vfs_inode);
+        call_rcu(&ei->socket.wq->rcu, wq_free_rcu);
+        kmem_cache_free(sock_inode_cachep, ei);
 }
 
 static void init_once(void *foo)
@@ -512,7 +529,7 @@ void sock_release(struct socket *sock)
                 module_put(owner);
         }
 
-        if (sock->fasync_list)
+        if (sock->wq->fasync_list)
                 printk(KERN_ERR "sock_release: fasync list not empty!\n");
 
         percpu_sub(sockets_in_use, 1);
@@ -619,10 +636,9 @@ void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
                         put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMP,
                                  sizeof(tv), &tv);
                 } else {
-                        struct timespec ts;
-                        skb_get_timestampns(skb, &ts);
+                        skb_get_timestampns(skb, &ts[0]);
                         put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMPNS,
-                                 sizeof(ts), &ts);
+                                 sizeof(ts[0]), &ts[0]);
                 }
         }
 
@@ -655,13 +671,13 @@ inline void sock_recv_drops(struct msghdr *msg, struct sock *sk, struct sk_buff
                         sizeof(__u32), &skb->dropcount);
 }
 
-void sock_recv_ts_and_drops(struct msghdr *msg, struct sock *sk,
+void __sock_recv_ts_and_drops(struct msghdr *msg, struct sock *sk,
         struct sk_buff *skb)
 {
         sock_recv_timestamp(msg, sk, skb);
         sock_recv_drops(msg, sk, skb);
 }
-EXPORT_SYMBOL_GPL(sock_recv_ts_and_drops);
+EXPORT_SYMBOL_GPL(__sock_recv_ts_and_drops);
 
 static inline int __sock_recvmsg_nosec(struct kiocb *iocb, struct socket *sock,
                                        struct msghdr *msg, size_t size, int flags)
@@ -1067,87 +1083,44 @@ static int sock_close(struct inode *inode, struct file *filp)
  *      1. fasync_list is modified only under process context socket lock
  *         i.e. under semaphore.
  *      2. fasync_list is used under read_lock(&sk->sk_callback_lock)
- *         or under socket lock.
- *      3. fasync_list can be used from softirq context, so that
- *         modification under socket lock have to be enhanced with
- *         write_lock_bh(&sk->sk_callback_lock).
- *                                                      --ANK (990710)
+ *         or under socket lock
  */
 
 static int sock_fasync(int fd, struct file *filp, int on)
 {
-        struct fasync_struct *fa, *fna = NULL, **prev;
-        struct socket *sock;
-        struct sock *sk;
-
-        if (on) {
-                fna = kmalloc(sizeof(struct fasync_struct), GFP_KERNEL);
-                if (fna == NULL)
-                        return -ENOMEM;
-        }
-
-        sock = filp->private_data;
+        struct socket *sock = filp->private_data;
+        struct sock *sk = sock->sk;
 
-        sk = sock->sk;
-        if (sk == NULL) {
-                kfree(fna);
+        if (sk == NULL)
                 return -EINVAL;
-        }
 
         lock_sock(sk);
 
-        spin_lock(&filp->f_lock);
-        if (on)
-                filp->f_flags |= FASYNC;
-        else
-                filp->f_flags &= ~FASYNC;
-        spin_unlock(&filp->f_lock);
+        fasync_helper(fd, filp, on, &sock->wq->fasync_list);
 
-        prev = &(sock->fasync_list);
-
-        for (fa = *prev; fa != NULL; prev = &fa->fa_next, fa = *prev)
-                if (fa->fa_file == filp)
-                        break;
-
-        if (on) {
-                if (fa != NULL) {
-                        write_lock_bh(&sk->sk_callback_lock);
-                        fa->fa_fd = fd;
-                        write_unlock_bh(&sk->sk_callback_lock);
-
-                        kfree(fna);
-                        goto out;
-                }
-                fna->fa_file = filp;
-                fna->fa_fd = fd;
-                fna->magic = FASYNC_MAGIC;
-                fna->fa_next = sock->fasync_list;
-                write_lock_bh(&sk->sk_callback_lock);
-                sock->fasync_list = fna;
+        if (!sock->wq->fasync_list)
+                sock_reset_flag(sk, SOCK_FASYNC);
+        else
                 sock_set_flag(sk, SOCK_FASYNC);
-                write_unlock_bh(&sk->sk_callback_lock);
-        } else {
-                if (fa != NULL) {
-                        write_lock_bh(&sk->sk_callback_lock);
-                        *prev = fa->fa_next;
-                        if (!sock->fasync_list)
-                                sock_reset_flag(sk, SOCK_FASYNC);
-                        write_unlock_bh(&sk->sk_callback_lock);
-                        kfree(fa);
-                }
-        }
 
-out:
-        release_sock(sock->sk);
+        release_sock(sk);
         return 0;
 }
 
-/* This function may be called only under socket lock or callback_lock */
+/* This function may be called only under socket lock or callback_lock or rcu_lock */
 
 int sock_wake_async(struct socket *sock, int how, int band)
 {
-        if (!sock || !sock->fasync_list)
+        struct socket_wq *wq;
+
+        if (!sock)
                 return -1;
+        rcu_read_lock();
+        wq = rcu_dereference(sock->wq);
+        if (!wq || !wq->fasync_list) {
+                rcu_read_unlock();
+                return -1;
+        }
         switch (how) {
         case SOCK_WAKE_WAITD:
                 if (test_bit(SOCK_ASYNC_WAITDATA, &sock->flags))
@@ -1159,11 +1132,12 @@ int sock_wake_async(struct socket *sock, int how, int band)
                 /* fall through */
         case SOCK_WAKE_IO:
 call_kill:
-                __kill_fasync(sock->fasync_list, SIGIO, band);
+                kill_fasync(&wq->fasync_list, SIGIO, band);
                 break;
         case SOCK_WAKE_URG:
-                __kill_fasync(sock->fasync_list, SIGURG, band);
+                kill_fasync(&wq->fasync_list, SIGURG, band);
         }
+        rcu_read_unlock();
         return 0;
 }
 
@@ -2135,6 +2109,10 @@ int __sys_recvmmsg(int fd, struct mmsghdr __user *mmsg, unsigned int vlen,
                         break;
                 ++datagrams;
 
+                /* MSG_WAITFORONE turns on MSG_DONTWAIT after one packet */
+                if (flags & MSG_WAITFORONE)
+                        flags |= MSG_DONTWAIT;
+
                 if (timeout) {
                         ktime_get_ts(timeout);
                         *timeout = timespec_sub(end_time, *timeout);
diff --git a/net/sunrpc/addr.c b/net/sunrpc/addr.c
index 6dcdd2517819..1419d0cdbbac 100644
--- a/net/sunrpc/addr.c
+++ b/net/sunrpc/addr.c
@@ -18,6 +18,7 @@
 
 #include <net/ipv6.h>
 #include <linux/sunrpc/clnt.h>
+#include <linux/slab.h>
 
 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
 
@@ -71,8 +72,9 @@ static size_t rpc_ntop6(const struct sockaddr *sap,
         if (unlikely(len == 0))
                 return len;
 
-        if (!(ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_LINKLOCAL) &&
-            !(ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_SITELOCAL))
+        if (!(ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_LINKLOCAL))
+                return len;
+        if (sin6->sin6_scope_id == 0)
                 return len;
 
         rc = snprintf(scopebuf, sizeof(scopebuf), "%c%u",
@@ -165,8 +167,7 @@ static int rpc_parse_scope_id(const char *buf, const size_t buflen,
         if (*delim != IPV6_SCOPE_DELIMITER)
                 return 0;
 
-        if (!(ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_LINKLOCAL) &&
-            !(ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_SITELOCAL))
+        if (!(ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_LINKLOCAL))
                 return 0;
 
         len = (buf + buflen) - delim - 1;
diff --git a/net/sunrpc/auth_generic.c b/net/sunrpc/auth_generic.c
index bf88bf8e9365..8f623b0f03dd 100644
--- a/net/sunrpc/auth_generic.c
+++ b/net/sunrpc/auth_generic.c
@@ -5,6 +5,7 @@
  */
 
 #include <linux/err.h>
+#include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/module.h>
 #include <linux/sched.h>
diff --git a/net/sunrpc/auth_gss/auth_gss.c b/net/sunrpc/auth_gss/auth_gss.c
index f7a7f8380e38..c389ccf6437d 100644
--- a/net/sunrpc/auth_gss/auth_gss.c
+++ b/net/sunrpc/auth_gss/auth_gss.c
@@ -206,8 +206,14 @@ gss_fill_context(const void *p, const void *end, struct gss_cl_ctx *ctx, struct
         ctx->gc_win = window_size;
         /* gssd signals an error by passing ctx->gc_win = 0: */
         if (ctx->gc_win == 0) {
-                /* in which case, p points to  an error code which we ignore */
-                p = ERR_PTR(-EACCES);
+                /*
+                 * in which case, p points to an error code. Anything other
+                 * than -EKEYEXPIRED gets converted to -EACCES.
+                 */
+                p = simple_get_bytes(p, end, &ret, sizeof(ret));
+                if (!IS_ERR(p))
+                        p = (ret == -EKEYEXPIRED) ? ERR_PTR(-EKEYEXPIRED) :
+                                                    ERR_PTR(-EACCES);
                 goto err;
         }
         /* copy the opaque wire context */
@@ -646,6 +652,7 @@ gss_pipe_downcall(struct file *filp, const char __user *src, size_t mlen)
                 err = PTR_ERR(p);
                 switch (err) {
                 case -EACCES:
+                case -EKEYEXPIRED:
                         gss_msg->msg.errno = err;
                         err = mlen;
                         break;
@@ -1273,9 +1280,8 @@ alloc_enc_pages(struct rpc_rqst *rqstp)
         rqstp->rq_release_snd_buf = priv_release_snd_buf;
         return 0;
 out_free:
-        for (i--; i >= 0; i--) {
-                __free_page(rqstp->rq_enc_pages[i]);
-        }
+        rqstp->rq_enc_pages_num = i;
+        priv_release_snd_buf(rqstp);
 out:
         return -EAGAIN;
 }
diff --git a/net/sunrpc/auth_gss/gss_generic_token.c b/net/sunrpc/auth_gss/gss_generic_token.c
index c0ba39c4f5f2..310b78e99456 100644
--- a/net/sunrpc/auth_gss/gss_generic_token.c
+++ b/net/sunrpc/auth_gss/gss_generic_token.c
@@ -33,7 +33,6 @@
 
 #include <linux/types.h>
 #include <linux/module.h>
-#include <linux/slab.h>
 #include <linux/string.h>
 #include <linux/sunrpc/sched.h>
 #include <linux/sunrpc/gss_asn1.h>
diff --git a/net/sunrpc/auth_gss/gss_krb5_crypto.c b/net/sunrpc/auth_gss/gss_krb5_crypto.c
index c93fca204558..e9b636176687 100644
--- a/net/sunrpc/auth_gss/gss_krb5_crypto.c
+++ b/net/sunrpc/auth_gss/gss_krb5_crypto.c
@@ -37,7 +37,6 @@
 #include <linux/err.h>
 #include <linux/types.h>
 #include <linux/mm.h>
-#include <linux/slab.h>
 #include <linux/scatterlist.h>
 #include <linux/crypto.h>
 #include <linux/highmem.h>
diff --git a/net/sunrpc/auth_gss/gss_krb5_seal.c b/net/sunrpc/auth_gss/gss_krb5_seal.c
index b8f42ef7178e..88fe6e75ed7e 100644
--- a/net/sunrpc/auth_gss/gss_krb5_seal.c
+++ b/net/sunrpc/auth_gss/gss_krb5_seal.c
@@ -59,7 +59,6 @@
  */
 
 #include <linux/types.h>
-#include <linux/slab.h>
 #include <linux/jiffies.h>
 #include <linux/sunrpc/gss_krb5.h>
 #include <linux/random.h>
diff --git a/net/sunrpc/auth_gss/gss_krb5_seqnum.c b/net/sunrpc/auth_gss/gss_krb5_seqnum.c
index 17562b4c35f6..6331cd6866ec 100644
--- a/net/sunrpc/auth_gss/gss_krb5_seqnum.c
+++ b/net/sunrpc/auth_gss/gss_krb5_seqnum.c
@@ -32,7 +32,6 @@
  */
 
 #include <linux/types.h>
-#include <linux/slab.h>
 #include <linux/sunrpc/gss_krb5.h>
 #include <linux/crypto.h>
 
diff --git a/net/sunrpc/auth_gss/gss_krb5_unseal.c b/net/sunrpc/auth_gss/gss_krb5_unseal.c
index 066ec73c84d6..ce6c247edad0 100644
--- a/net/sunrpc/auth_gss/gss_krb5_unseal.c
+++ b/net/sunrpc/auth_gss/gss_krb5_unseal.c
@@ -58,7 +58,6 @@
  */
 
 #include <linux/types.h>
-#include <linux/slab.h>
 #include <linux/jiffies.h>
 #include <linux/sunrpc/gss_krb5.h>
 #include <linux/crypto.h>
diff --git a/net/sunrpc/auth_gss/gss_krb5_wrap.c b/net/sunrpc/auth_gss/gss_krb5_wrap.c
index ae8e69b59c4c..a6e905637e03 100644
--- a/net/sunrpc/auth_gss/gss_krb5_wrap.c
+++ b/net/sunrpc/auth_gss/gss_krb5_wrap.c
@@ -1,5 +1,4 @@
 #include <linux/types.h>
-#include <linux/slab.h>
 #include <linux/jiffies.h>
 #include <linux/sunrpc/gss_krb5.h>
 #include <linux/random.h>
diff --git a/net/sunrpc/auth_gss/gss_spkm3_seal.c b/net/sunrpc/auth_gss/gss_spkm3_seal.c
index c832712f8d55..5a3a65a0e2b4 100644
--- a/net/sunrpc/auth_gss/gss_spkm3_seal.c
+++ b/net/sunrpc/auth_gss/gss_spkm3_seal.c
@@ -34,7 +34,6 @@
  */
 
 #include <linux/types.h>
-#include <linux/slab.h>
 #include <linux/jiffies.h>
 #include <linux/sunrpc/gss_spkm3.h>
 #include <linux/random.h>
diff --git a/net/sunrpc/auth_gss/gss_spkm3_token.c b/net/sunrpc/auth_gss/gss_spkm3_token.c
index 3308157436d2..a99825d7caa0 100644
--- a/net/sunrpc/auth_gss/gss_spkm3_token.c
+++ b/net/sunrpc/auth_gss/gss_spkm3_token.c
@@ -223,7 +223,7 @@ spkm3_verify_mic_token(unsigned char **tokp, int *mic_hdrlen, unsigned char **ck
 
         /* only support SPKM_MIC_TOK */
         if((ptr[6] != 0x01) || (ptr[7] != 0x01)) {
-                dprintk("RPC:       ERROR unsupported SPKM3 token \n");
+                dprintk("RPC:       ERROR unsupported SPKM3 token\n");
                 goto out;
         }
 
diff --git a/net/sunrpc/auth_gss/svcauth_gss.c b/net/sunrpc/auth_gss/svcauth_gss.c
index e34bc531fcb9..b81e790ef9f4 100644
--- a/net/sunrpc/auth_gss/svcauth_gss.c
+++ b/net/sunrpc/auth_gss/svcauth_gss.c
@@ -37,6 +37,7 @@
  *
  */
 
+#include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/module.h>
 #include <linux/pagemap.h>
diff --git a/net/sunrpc/auth_unix.c b/net/sunrpc/auth_unix.c
index 46b2647c5bd2..aac2f8b4ee21 100644
--- a/net/sunrpc/auth_unix.c
+++ b/net/sunrpc/auth_unix.c
@@ -6,6 +6,7 @@
  * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
  */
 
+#include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/sched.h>
 #include <linux/module.h>
diff --git a/net/sunrpc/backchannel_rqst.c b/net/sunrpc/backchannel_rqst.c
index 553621fb2c41..cf06af3b63c6 100644
--- a/net/sunrpc/backchannel_rqst.c
+++ b/net/sunrpc/backchannel_rqst.c
@@ -22,6 +22,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ******************************************************************************/
 
 #include <linux/tcp.h>
+#include <linux/slab.h>
 #include <linux/sunrpc/xprt.h>
 
 #ifdef RPC_DEBUG
diff --git a/net/sunrpc/bc_svc.c b/net/sunrpc/bc_svc.c
index 13f214f53120..7dcfe0cc3500 100644
--- a/net/sunrpc/bc_svc.c
+++ b/net/sunrpc/bc_svc.c
@@ -37,21 +37,6 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #define RPCDBG_FACILITY RPCDBG_SVCDSP
 
-void bc_release_request(struct rpc_task *task)
-{
-        struct rpc_rqst *req = task->tk_rqstp;
-
-        dprintk("RPC:       bc_release_request: task= %p\n", task);
-
-        /*
-         * Release this request only if it's a backchannel
-         * preallocated request
-         */
-        if (!bc_prealloc(req))
-                return;
-        xprt_free_bc_request(req);
-}
-
 /* Empty callback ops */
 static const struct rpc_call_ops nfs41_callback_ops = {
 };
@@ -75,7 +60,7 @@ int bc_send(struct rpc_rqst *req)
                 rpc_put_task(task);
         }
         return ret;
-        dprintk("RPC:       bc_send ret= %d \n", ret);
+        dprintk("RPC:       bc_send ret= %d\n", ret);
 }
 
 #endif /* CONFIG_NFS_V4_1 */
diff --git a/net/sunrpc/clnt.c b/net/sunrpc/clnt.c
index 154034b675bd..19c9983d5360 100644
--- a/net/sunrpc/clnt.c
+++ b/net/sunrpc/clnt.c
@@ -659,6 +659,7 @@ struct rpc_task *rpc_run_bc_task(struct rpc_rqst *req,
         task = rpc_new_task(&task_setup_data);
         if (!task) {
                 xprt_free_bc_request(req);
+                task = ERR_PTR(-ENOMEM);
                 goto out;
         }
         task->tk_rqstp = req;
diff --git a/net/sunrpc/rpc_pipe.c b/net/sunrpc/rpc_pipe.c
index 9ea45383480e..20e30c6f8355 100644
--- a/net/sunrpc/rpc_pipe.c
+++ b/net/sunrpc/rpc_pipe.c
@@ -587,6 +587,8 @@ static struct dentry *__rpc_lookup_create_exclusive(struct dentry *parent,
         struct dentry *dentry;
 
         dentry = __rpc_lookup_create(parent, name);
+        if (IS_ERR(dentry))
+                return dentry;
         if (dentry->d_inode == NULL)
                 return dentry;
         dput(dentry);
@@ -999,19 +1001,14 @@ rpc_fill_super(struct super_block *sb, void *data, int silent)
         inode = rpc_get_inode(sb, S_IFDIR | 0755);
         if (!inode)
                 return -ENOMEM;
-        root = d_alloc_root(inode);
+        sb->s_root = root = d_alloc_root(inode);
         if (!root) {
                 iput(inode);
                 return -ENOMEM;
         }
         if (rpc_populate(root, files, RPCAUTH_lockd, RPCAUTH_RootEOF, NULL))
-                goto out;
-        sb->s_root = root;
+                return -ENOMEM;
         return 0;
-out:
-        d_genocide(root);
-        dput(root);
-        return -ENOMEM;
 }
 
 static int
diff --git a/net/sunrpc/rpcb_clnt.c b/net/sunrpc/rpcb_clnt.c
index 3e3772d8eb92..121105355f60 100644
--- a/net/sunrpc/rpcb_clnt.c
+++ b/net/sunrpc/rpcb_clnt.c
@@ -21,6 +21,7 @@
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/mutex.h>
+#include <linux/slab.h>
 #include <net/ipv6.h>
 
 #include <linux/sunrpc/clnt.h>
diff --git a/net/sunrpc/socklib.c b/net/sunrpc/socklib.c
index a661a3acb37e..10b4319ebbca 100644
--- a/net/sunrpc/socklib.c
+++ b/net/sunrpc/socklib.c
@@ -8,6 +8,7 @@
 
 #include <linux/compiler.h>
 #include <linux/netdevice.h>
+#include <linux/gfp.h>
 #include <linux/skbuff.h>
 #include <linux/types.h>
 #include <linux/pagemap.h>
diff --git a/net/sunrpc/stats.c b/net/sunrpc/stats.c
index 1b4e6791ecf3..5785d2037f45 100644
--- a/net/sunrpc/stats.c
+++ b/net/sunrpc/stats.c
@@ -13,6 +13,7 @@
  */
 
 #include <linux/module.h>
+#include <linux/slab.h>
 
 #include <linux/init.h>
 #include <linux/kernel.h>
diff --git a/net/sunrpc/svc.c b/net/sunrpc/svc.c
index 538ca433a56c..d9017d64597e 100644
--- a/net/sunrpc/svc.c
+++ b/net/sunrpc/svc.c
@@ -19,6 +19,7 @@
 #include <linux/interrupt.h>
 #include <linux/module.h>
 #include <linux/kthread.h>
+#include <linux/slab.h>
 
 #include <linux/sunrpc/types.h>
 #include <linux/sunrpc/xdr.h>
@@ -133,7 +134,7 @@ svc_pool_map_choose_mode(void)
                 return SVC_POOL_PERNODE;
         }
 
-        node = any_online_node(node_online_map);
+        node = first_online_node;
         if (nr_cpus_node(node) > 2) {
                 /*
                  * Non-trivial SMP, or CONFIG_NUMA on
@@ -506,6 +507,10 @@ svc_init_buffer(struct svc_rqst *rqstp, unsigned int size)
 {
         unsigned int pages, arghi;
 
+        /* bc_xprt uses fore channel allocated buffers */
+        if (svc_is_backchannel(rqstp))
+                return 1;
+
         pages = size / PAGE_SIZE + 1; /* extra page as we hold both request and reply.
                                        * We assume one is at most one page
                                        */
diff --git a/net/sunrpc/svc_xprt.c b/net/sunrpc/svc_xprt.c
index 7d1f9e928f69..061b2e0f9118 100644
--- a/net/sunrpc/svc_xprt.c
+++ b/net/sunrpc/svc_xprt.c
@@ -9,6 +9,7 @@
 #include <linux/errno.h>
 #include <linux/freezer.h>
 #include <linux/kthread.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 #include <linux/sunrpc/stats.h>
 #include <linux/sunrpc/svc_xprt.h>
@@ -173,11 +174,13 @@ static struct svc_xprt *__svc_xpo_create(struct svc_xprt_class *xcl,
                 .sin_addr.s_addr        = htonl(INADDR_ANY),
                 .sin_port               = htons(port),
         };
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
         struct sockaddr_in6 sin6 = {
                 .sin6_family            = AF_INET6,
                 .sin6_addr              = IN6ADDR_ANY_INIT,
                 .sin6_port              = htons(port),
         };
+#endif  /* defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) */
         struct sockaddr *sap;
         size_t len;
 
@@ -186,10 +189,12 @@ static struct svc_xprt *__svc_xpo_create(struct svc_xprt_class *xcl,
                 sap = (struct sockaddr *)&sin;
                 len = sizeof(sin);
                 break;
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
         case PF_INET6:
                 sap = (struct sockaddr *)&sin6;
                 len = sizeof(sin6);
                 break;
+#endif  /* defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) */
         default:
                 return ERR_PTR(-EAFNOSUPPORT);
         }
@@ -231,7 +236,10 @@ int svc_create_xprt(struct svc_serv *serv, const char *xprt_name,
  err:
         spin_unlock(&svc_xprt_class_lock);
         dprintk("svc: transport %s not found\n", xprt_name);
-        return -ENOENT;
+
+        /* This errno is exposed to user space.  Provide a reasonable
+         * perror msg for a bad transport. */
+        return -EPROTONOSUPPORT;
 }
 EXPORT_SYMBOL_GPL(svc_create_xprt);
 
@@ -699,8 +707,10 @@ int svc_recv(struct svc_rqst *rqstp, long timeout)
         spin_unlock_bh(&pool->sp_lock);
 
         len = 0;
-        if (test_bit(XPT_LISTENER, &xprt->xpt_flags) &&
-            !test_bit(XPT_CLOSE, &xprt->xpt_flags)) {
+        if (test_bit(XPT_CLOSE, &xprt->xpt_flags)) {
+                dprintk("svc_recv: found XPT_CLOSE\n");
+                svc_delete_xprt(xprt);
+        } else if (test_bit(XPT_LISTENER, &xprt->xpt_flags)) {
                 struct svc_xprt *newxpt;
                 newxpt = xprt->xpt_ops->xpo_accept(xprt);
                 if (newxpt) {
@@ -726,7 +736,7 @@ int svc_recv(struct svc_rqst *rqstp, long timeout)
                         svc_xprt_received(newxpt);
                 }
                 svc_xprt_received(xprt);
-        } else if (!test_bit(XPT_CLOSE, &xprt->xpt_flags)) {
+        } else {
                 dprintk("svc: server %p, pool %u, transport %p, inuse=%d\n",
                         rqstp, pool->sp_id, xprt,
                         atomic_read(&xprt->xpt_ref.refcount));
@@ -739,11 +749,6 @@ int svc_recv(struct svc_rqst *rqstp, long timeout)
                 dprintk("svc: got len=%d\n", len);
         }
 
-        if (test_bit(XPT_CLOSE, &xprt->xpt_flags)) {
-                dprintk("svc_recv: found XPT_CLOSE\n");
-                svc_delete_xprt(xprt);
-        }
-
         /* No data, incomplete (TCP) read, or accept() */
         if (len == 0 || len == -EAGAIN) {
                 rqstp->rq_res.len = 0;
@@ -889,11 +894,8 @@ void svc_delete_xprt(struct svc_xprt *xprt)
         if (test_bit(XPT_TEMP, &xprt->xpt_flags))
                 serv->sv_tmpcnt--;
 
-        for (dr = svc_deferred_dequeue(xprt); dr;
-             dr = svc_deferred_dequeue(xprt)) {
-                svc_xprt_put(xprt);
+        while ((dr = svc_deferred_dequeue(xprt)) != NULL)
                 kfree(dr);
-        }
 
         svc_xprt_put(xprt);
         spin_unlock_bh(&serv->sv_lock);
diff --git a/net/sunrpc/svcauth_unix.c b/net/sunrpc/svcauth_unix.c
index d8c041114497..207311610988 100644
--- a/net/sunrpc/svcauth_unix.c
+++ b/net/sunrpc/svcauth_unix.c
@@ -10,11 +10,13 @@
 #include <linux/seq_file.h>
 #include <linux/hash.h>
 #include <linux/string.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 #include <net/ipv6.h>
 #include <linux/kernel.h>
 #define RPCDBG_FACILITY RPCDBG_AUTH
 
+#include <linux/sunrpc/clnt.h>
 
 /*
  * AUTHUNIX and AUTHNULL credentials are both handled here.
@@ -187,10 +189,13 @@ static int ip_map_parse(struct cache_detail *cd,
          * for scratch: */
         char *buf = mesg;
         int len;
-        int b1, b2, b3, b4, b5, b6, b7, b8;
-        char c;
         char class[8];
-        struct in6_addr addr;
+        union {
+                struct sockaddr         sa;
+                struct sockaddr_in      s4;
+                struct sockaddr_in6     s6;
+        } address;
+        struct sockaddr_in6 sin6;
         int err;
 
         struct ip_map *ipmp;
@@ -209,24 +214,24 @@ static int ip_map_parse(struct cache_detail *cd,
         len = qword_get(&mesg, buf, mlen);
         if (len <= 0) return -EINVAL;
 
-        if (sscanf(buf, "%u.%u.%u.%u%c", &b1, &b2, &b3, &b4, &c) == 4) {
-                addr.s6_addr32[0] = 0;
-                addr.s6_addr32[1] = 0;
-                addr.s6_addr32[2] = htonl(0xffff);
-                addr.s6_addr32[3] =
-                        htonl((((((b1<<8)|b2)<<8)|b3)<<8)|b4);
-       } else if (sscanf(buf, "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x%c",
-                        &b1, &b2, &b3, &b4, &b5, &b6, &b7, &b8, &c) == 8) {
-                addr.s6_addr16[0] = htons(b1);
-                addr.s6_addr16[1] = htons(b2);
-                addr.s6_addr16[2] = htons(b3);
-                addr.s6_addr16[3] = htons(b4);
-                addr.s6_addr16[4] = htons(b5);
-                addr.s6_addr16[5] = htons(b6);
-                addr.s6_addr16[6] = htons(b7);
-                addr.s6_addr16[7] = htons(b8);
-       } else
+        if (rpc_pton(buf, len, &address.sa, sizeof(address)) == 0)
                 return -EINVAL;
+        switch (address.sa.sa_family) {
+        case AF_INET:
+                /* Form a mapped IPv4 address in sin6 */
+                memset(&sin6, 0, sizeof(sin6));
+                sin6.sin6_family = AF_INET6;
+                sin6.sin6_addr.s6_addr32[2] = htonl(0xffff);
+                sin6.sin6_addr.s6_addr32[3] = address.s4.sin_addr.s_addr;
+                break;
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
+        case AF_INET6:
+                memcpy(&sin6, &address.s6, sizeof(sin6));
+                break;
+#endif
+        default:
+                return -EINVAL;
+        }
 
         expiry = get_expiry(&mesg);
         if (expiry ==0)
@@ -243,7 +248,8 @@ static int ip_map_parse(struct cache_detail *cd,
         } else
                 dom = NULL;
 
-        ipmp = ip_map_lookup(class, &addr);
+        /* IPv6 scope IDs are ignored for now */
+        ipmp = ip_map_lookup(class, &sin6.sin6_addr);
         if (ipmp) {
                 err = ip_map_update(ipmp,
                              container_of(dom, struct unix_domain, h),
@@ -619,7 +625,7 @@ static int unix_gid_show(struct seq_file *m,
         else
                 glen = 0;
 
-        seq_printf(m, "%d %d:", ug->uid, glen);
+        seq_printf(m, "%u %d:", ug->uid, glen);
         for (i = 0; i < glen; i++)
                 seq_printf(m, " %d", GROUP_AT(ug->gi, i));
         seq_printf(m, "\n");
diff --git a/net/sunrpc/svcsock.c b/net/sunrpc/svcsock.c
index 870929e08e5d..ce0d5b35c2ac 100644
--- a/net/sunrpc/svcsock.c
+++ b/net/sunrpc/svcsock.c
@@ -419,8 +419,8 @@ static void svc_udp_data_ready(struct sock *sk, int count)
                 set_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags);
                 svc_xprt_enqueue(&svsk->sk_xprt);
         }
-        if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
-                wake_up_interruptible(sk->sk_sleep);
+        if (sk_sleep(sk) && waitqueue_active(sk_sleep(sk)))
+                wake_up_interruptible(sk_sleep(sk));
 }
 
 /*
@@ -436,10 +436,10 @@ static void svc_write_space(struct sock *sk)
                 svc_xprt_enqueue(&svsk->sk_xprt);
         }
 
-        if (sk->sk_sleep && waitqueue_active(sk->sk_sleep)) {
+        if (sk_sleep(sk) && waitqueue_active(sk_sleep(sk))) {
                 dprintk("RPC svc_write_space: someone sleeping on %p\n",
                        svsk);
-                wake_up_interruptible(sk->sk_sleep);
+                wake_up_interruptible(sk_sleep(sk));
         }
 }
 
@@ -757,8 +757,8 @@ static void svc_tcp_listen_data_ready(struct sock *sk, int count_unused)
                         printk("svc: socket %p: no user data\n", sk);
         }
 
-        if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
-                wake_up_interruptible_all(sk->sk_sleep);
+        if (sk_sleep(sk) && waitqueue_active(sk_sleep(sk)))
+                wake_up_interruptible_all(sk_sleep(sk));
 }
 
 /*
@@ -777,8 +777,8 @@ static void svc_tcp_state_change(struct sock *sk)
                 set_bit(XPT_CLOSE, &svsk->sk_xprt.xpt_flags);
                 svc_xprt_enqueue(&svsk->sk_xprt);
         }
-        if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
-                wake_up_interruptible_all(sk->sk_sleep);
+        if (sk_sleep(sk) && waitqueue_active(sk_sleep(sk)))
+                wake_up_interruptible_all(sk_sleep(sk));
 }
 
 static void svc_tcp_data_ready(struct sock *sk, int count)
@@ -791,8 +791,8 @@ static void svc_tcp_data_ready(struct sock *sk, int count)
                 set_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags);
                 svc_xprt_enqueue(&svsk->sk_xprt);
         }
-        if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
-                wake_up_interruptible(sk->sk_sleep);
+        if (sk_sleep(sk) && waitqueue_active(sk_sleep(sk)))
+                wake_up_interruptible(sk_sleep(sk));
 }
 
 /*
@@ -968,6 +968,7 @@ static int svc_tcp_recv_record(struct svc_sock *svsk, struct svc_rqst *rqstp)
         return len;
  err_delete:
         set_bit(XPT_CLOSE, &svsk->sk_xprt.xpt_flags);
+        svc_xprt_received(&svsk->sk_xprt);
  err_again:
         return -EAGAIN;
 }
@@ -1357,7 +1358,7 @@ int svc_addsock(struct svc_serv *serv, const int fd, char *name_return,
 
         if (!so)
                 return err;
-        if (so->sk->sk_family != AF_INET)
+        if ((so->sk->sk_family != PF_INET) && (so->sk->sk_family != PF_INET6))
                 err =  -EAFNOSUPPORT;
         else if (so->sk->sk_protocol != IPPROTO_TCP &&
             so->sk->sk_protocol != IPPROTO_UDP)
@@ -1493,8 +1494,8 @@ static void svc_sock_detach(struct svc_xprt *xprt)
         sk->sk_data_ready = svsk->sk_odata;
         sk->sk_write_space = svsk->sk_owspace;
 
-        if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
-                wake_up_interruptible(sk->sk_sleep);
+        if (sk_sleep(sk) && waitqueue_active(sk_sleep(sk)))
+                wake_up_interruptible(sk_sleep(sk));
 }
 
 /*
diff --git a/net/sunrpc/xdr.c b/net/sunrpc/xdr.c
index 8bd690c48b69..2763fde88499 100644
--- a/net/sunrpc/xdr.c
+++ b/net/sunrpc/xdr.c
@@ -7,6 +7,7 @@
  */
 
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/string.h>
 #include <linux/kernel.h>
diff --git a/net/sunrpc/xprt.c b/net/sunrpc/xprt.c
index 469de292c23c..699ade68aac1 100644
--- a/net/sunrpc/xprt.c
+++ b/net/sunrpc/xprt.c
@@ -46,6 +46,7 @@
 
 #include <linux/sunrpc/clnt.h>
 #include <linux/sunrpc/metrics.h>
+#include <linux/sunrpc/bc_xprt.h>
 
 #include "sunrpc.h"
 
@@ -973,7 +974,7 @@ void xprt_reserve(struct rpc_task *task)
 
 static inline __be32 xprt_alloc_xid(struct rpc_xprt *xprt)
 {
-        return xprt->xid++;
+        return (__force __be32)xprt->xid++;
 }
 
 static inline void xprt_init_xid(struct rpc_xprt *xprt)
@@ -1032,21 +1033,16 @@ void xprt_release(struct rpc_task *task)
         if (req->rq_release_snd_buf)
                 req->rq_release_snd_buf(req);
 
-        /*
-         * Early exit if this is a backchannel preallocated request.
-         * There is no need to have it added to the RPC slot list.
-         */
-        if (is_bc_request)
-                return;
-
-        memset(req, 0, sizeof(*req));   /* mark unused */
-
         dprintk("RPC: %5u release request %p\n", task->tk_pid, req);
+        if (likely(!is_bc_request)) {
+                memset(req, 0, sizeof(*req));   /* mark unused */
 
-        spin_lock(&xprt->reserve_lock);
-        list_add(&req->rq_list, &xprt->free);
-        rpc_wake_up_next(&xprt->backlog);
-        spin_unlock(&xprt->reserve_lock);
+                spin_lock(&xprt->reserve_lock);
+                list_add(&req->rq_list, &xprt->free);
+                rpc_wake_up_next(&xprt->backlog);
+                spin_unlock(&xprt->reserve_lock);
+        } else
+                xprt_free_bc_request(req);
 }
 
 /**
diff --git a/net/sunrpc/xprtrdma/svc_rdma.c b/net/sunrpc/xprtrdma/svc_rdma.c
index 5b8a8ff93a25..d718b8fa9525 100644
--- a/net/sunrpc/xprtrdma/svc_rdma.c
+++ b/net/sunrpc/xprtrdma/svc_rdma.c
@@ -40,6 +40,7 @@
  */
 #include <linux/module.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <linux/fs.h>
 #include <linux/sysctl.h>
 #include <linux/sunrpc/clnt.h>
diff --git a/net/sunrpc/xprtrdma/svc_rdma_transport.c b/net/sunrpc/xprtrdma/svc_rdma_transport.c
index 3fa5751af0ec..edea15a54e51 100644
--- a/net/sunrpc/xprtrdma/svc_rdma_transport.c
+++ b/net/sunrpc/xprtrdma/svc_rdma_transport.c
@@ -43,6 +43,7 @@
 #include <linux/sunrpc/debug.h>
 #include <linux/sunrpc/rpc_rdma.h>
 #include <linux/sched.h>
+#include <linux/slab.h>
 #include <linux/spinlock.h>
 #include <rdma/ib_verbs.h>
 #include <rdma/rdma_cm.h>
@@ -678,7 +679,10 @@ static struct svc_xprt *svc_rdma_create(struct svc_serv *serv,
         int ret;
 
         dprintk("svcrdma: Creating RDMA socket\n");
-
+        if (sa->sa_family != AF_INET) {
+                dprintk("svcrdma: Address family %d is not supported.\n", sa->sa_family);
+                return ERR_PTR(-EAFNOSUPPORT);
+        }
         cma_xprt = rdma_create_xprt(serv, 1);
         if (!cma_xprt)
                 return ERR_PTR(-ENOMEM);
diff --git a/net/sunrpc/xprtrdma/transport.c b/net/sunrpc/xprtrdma/transport.c
index f96c2fe6137b..187257b1d880 100644
--- a/net/sunrpc/xprtrdma/transport.c
+++ b/net/sunrpc/xprtrdma/transport.c
@@ -49,6 +49,7 @@
 
 #include <linux/module.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <linux/seq_file.h>
 
 #include "xprt_rdma.h"
diff --git a/net/sunrpc/xprtrdma/verbs.c b/net/sunrpc/xprtrdma/verbs.c
index 2209aa87d899..27015c6d8eb5 100644
--- a/net/sunrpc/xprtrdma/verbs.c
+++ b/net/sunrpc/xprtrdma/verbs.c
@@ -48,6 +48,7 @@
  */
 
 #include <linux/pci.h>  /* for Tavor hack below */
+#include <linux/slab.h>
 
 #include "xprt_rdma.h"
 
diff --git a/net/sunrpc/xprtsock.c b/net/sunrpc/xprtsock.c
index 4f55ab7ec1b1..9847c30b5001 100644
--- a/net/sunrpc/xprtsock.c
+++ b/net/sunrpc/xprtsock.c
@@ -548,8 +548,6 @@ static int xs_udp_send_request(struct rpc_task *task)
                 /* Still some bytes left; set up for a retry later. */
                 status = -EAGAIN;
         }
-        if (!transport->sock)
-                goto out;
 
         switch (status) {
         case -ENOTSOCK:
@@ -569,7 +567,7 @@ static int xs_udp_send_request(struct rpc_task *task)
                  * prompts ECONNREFUSED. */
                 clear_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags);
         }
-out:
+
         return status;
 }
 
@@ -651,8 +649,6 @@ static int xs_tcp_send_request(struct rpc_task *task)
                 status = -EAGAIN;
                 break;
         }
-        if (!transport->sock)
-                goto out;
 
         switch (status) {
         case -ENOTSOCK:
@@ -672,7 +668,7 @@ static int xs_tcp_send_request(struct rpc_task *task)
         case -ENOTCONN:
                 clear_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags);
         }
-out:
+
         return status;
 }
 
@@ -1911,6 +1907,11 @@ static void xs_tcp_setup_socket(struct rpc_xprt *xprt,
         case -EALREADY:
                 xprt_clear_connecting(xprt);
                 return;
+        case -EINVAL:
+                /* Happens, for instance, if the user specified a link
+                 * local IPv6 address without a scope-id.
+                 */
+                goto out;
         }
 out_eagain:
         status = -EAGAIN;
@@ -2099,7 +2100,7 @@ static void xs_tcp_print_stats(struct rpc_xprt *xprt, struct seq_file *seq)
  * we allocate pages instead doing a kmalloc like rpc_malloc is because we want
  * to use the server side send routines.
  */
-void *bc_malloc(struct rpc_task *task, size_t size)
+static void *bc_malloc(struct rpc_task *task, size_t size)
 {
         struct page *page;
         struct rpc_buffer *buf;
@@ -2119,7 +2120,7 @@ void *bc_malloc(struct rpc_task *task, size_t size)
 /*
  * Free the space allocated in the bc_alloc routine
  */
-void bc_free(void *buffer)
+static void bc_free(void *buffer)
 {
         struct rpc_buffer *buf;
 
@@ -2250,9 +2251,6 @@ static struct rpc_xprt_ops xs_tcp_ops = {
         .buf_free               = rpc_free,
         .send_request           = xs_tcp_send_request,
         .set_retrans_timeout    = xprt_set_retrans_timeout_def,
-#if defined(CONFIG_NFS_V4_1)
-        .release_request        = bc_release_request,
-#endif /* CONFIG_NFS_V4_1 */
         .close                  = xs_tcp_close,
         .destroy                = xs_destroy,
         .print_stats            = xs_tcp_print_stats,
diff --git a/net/tipc/bcast.c b/net/tipc/bcast.c
index a3bfd4064912..90a051912c03 100644
--- a/net/tipc/bcast.c
+++ b/net/tipc/bcast.c
@@ -558,10 +558,7 @@ static int tipc_bcbearer_send(struct sk_buff *buf,
                               struct tipc_bearer *unused1,
                               struct tipc_media_addr *unused2)
 {
-        static int send_count = 0;
-
         int bp_index;
-        int swap_time;
 
         /* Prepare buffer for broadcasting (if first time trying to send it) */
 
@@ -575,11 +572,6 @@ static int tipc_bcbearer_send(struct sk_buff *buf,
                 msg_set_mc_netid(msg, tipc_net_id);
         }
 
-        /* Determine if bearer pairs should be swapped following this attempt */
-
-        if ((swap_time = (++send_count >= 10)))
-                send_count = 0;
-
         /* Send buffer over bearers until all targets reached */
 
         bcbearer->remains = tipc_cltr_bcast_nodes;
@@ -595,21 +587,22 @@ static int tipc_bcbearer_send(struct sk_buff *buf,
                 if (bcbearer->remains_new.count == bcbearer->remains.count)
                         continue;       /* bearer pair doesn't add anything */
 
-                if (!p->publ.blocked &&
-                    !p->media->send_msg(buf, &p->publ, &p->media->bcast_addr)) {
-                        if (swap_time && s && !s->publ.blocked)
-                                goto swap;
-                        else
-                                goto update;
+                if (p->publ.blocked ||
+                    p->media->send_msg(buf, &p->publ, &p->media->bcast_addr)) {
+                        /* unable to send on primary bearer */
+                        if (!s || s->publ.blocked ||
+                            s->media->send_msg(buf, &s->publ,
+                                               &s->media->bcast_addr)) {
+                                /* unable to send on either bearer */
+                                continue;
+                        }
+                }
+
+                if (s) {
+                        bcbearer->bpairs[bp_index].primary = s;
+                        bcbearer->bpairs[bp_index].secondary = p;
                 }
 
-                if (!s || s->publ.blocked ||
-                    s->media->send_msg(buf, &s->publ, &s->media->bcast_addr))
-                        continue;       /* unable to send using bearer pair */
-swap:
-                bcbearer->bpairs[bp_index].primary = s;
-                bcbearer->bpairs[bp_index].secondary = p;
-update:
                 if (bcbearer->remains_new.count == 0)
                         return 0;
 
diff --git a/net/tipc/core.c b/net/tipc/core.c
index 52c571fedbe0..4e84c8431f32 100644
--- a/net/tipc/core.c
+++ b/net/tipc/core.c
@@ -49,7 +49,7 @@
 #include "config.h"
 
 
-#define TIPC_MOD_VER "1.6.4"
+#define TIPC_MOD_VER "2.0.0"
 
 #ifndef CONFIG_TIPC_ZONES
 #define CONFIG_TIPC_ZONES 3
diff --git a/net/tipc/core.h b/net/tipc/core.h
index a881f92a8537..c58a1d16563a 100644
--- a/net/tipc/core.h
+++ b/net/tipc/core.h
@@ -56,6 +56,7 @@
 #include <linux/netdevice.h>
 #include <linux/in.h>
 #include <linux/list.h>
+#include <linux/slab.h>
 #include <linux/vmalloc.h>
 
 /*
diff --git a/net/tipc/eth_media.c b/net/tipc/eth_media.c
index 524ba5696d4d..6230d16020c4 100644
--- a/net/tipc/eth_media.c
+++ b/net/tipc/eth_media.c
@@ -38,6 +38,7 @@
 #include <net/tipc/tipc_bearer.h>
 #include <net/tipc/tipc_msg.h>
 #include <linux/netdevice.h>
+#include <linux/slab.h>
 #include <net/net_namespace.h>
 
 #define MAX_ETH_BEARERS         2
diff --git a/net/tipc/link.c b/net/tipc/link.c
index 1a7e4665af80..c76e82e5f982 100644
--- a/net/tipc/link.c
+++ b/net/tipc/link.c
@@ -877,7 +877,7 @@ static void link_state_event(struct link *l_ptr, unsigned event)
                 case TIMEOUT_EVT:
                         dbg_link("TIM ");
                         if (l_ptr->next_in_no != l_ptr->checkpoint) {
-                                dbg_link("-> WW \n");
+                                dbg_link("-> WW\n");
                                 l_ptr->state = WORKING_WORKING;
                                 l_ptr->fsm_msg_cnt = 0;
                                 l_ptr->checkpoint = l_ptr->next_in_no;
@@ -934,7 +934,7 @@ static void link_state_event(struct link *l_ptr, unsigned event)
                         link_set_timer(l_ptr, cont_intv);
                         break;
                 case RESET_MSG:
-                        dbg_link("RES \n");
+                        dbg_link("RES\n");
                         dbg_link(" -> RR\n");
                         l_ptr->state = RESET_RESET;
                         l_ptr->fsm_msg_cnt = 0;
@@ -947,7 +947,7 @@ static void link_state_event(struct link *l_ptr, unsigned event)
                         l_ptr->started = 1;
                         /* fall through */
                 case TIMEOUT_EVT:
-                        dbg_link("TIM \n");
+                        dbg_link("TIM\n");
                         tipc_link_send_proto_msg(l_ptr, RESET_MSG, 0, 0, 0, 0, 0);
                         l_ptr->fsm_msg_cnt++;
                         link_set_timer(l_ptr, cont_intv);
@@ -1553,7 +1553,7 @@ u32 tipc_link_push_packet(struct link *l_ptr)
 
         /* Continue retransmission now, if there is anything: */
 
-        if (r_q_size && buf && !skb_cloned(buf)) {
+        if (r_q_size && buf) {
                 msg_set_ack(buf_msg(buf), mod(l_ptr->next_in_no - 1));
                 msg_set_bcast_ack(buf_msg(buf), l_ptr->owner->bclink.last_in);
                 if (tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr)) {
@@ -1722,15 +1722,16 @@ void tipc_link_retransmit(struct link *l_ptr, struct sk_buff *buf,
         dbg("Retransmitting %u in link %x\n", retransmits, l_ptr);
 
         if (tipc_bearer_congested(l_ptr->b_ptr, l_ptr)) {
-                if (!skb_cloned(buf)) {
+                if (l_ptr->retransm_queue_size == 0) {
                         msg_dbg(msg, ">NO_RETR->BCONG>");
                         dbg_print_link(l_ptr, "   ");
                         l_ptr->retransm_queue_head = msg_seqno(msg);
                         l_ptr->retransm_queue_size = retransmits;
-                        return;
                 } else {
-                        /* Don't retransmit if driver already has the buffer */
+                        err("Unexpected retransmit on link %s (qsize=%d)\n",
+                            l_ptr->name, l_ptr->retransm_queue_size);
                 }
+                return;
         } else {
                 /* Detect repeated retransmit failures on uncongested bearer */
 
@@ -1745,7 +1746,7 @@ void tipc_link_retransmit(struct link *l_ptr, struct sk_buff *buf,
                 }
         }
 
-        while (retransmits && (buf != l_ptr->next_out) && buf && !skb_cloned(buf)) {
+        while (retransmits && (buf != l_ptr->next_out) && buf) {
                 msg = buf_msg(buf);
                 msg_set_ack(msg, mod(l_ptr->next_in_no - 1));
                 msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
@@ -3294,7 +3295,7 @@ static void link_dump_rec_queue(struct link *l_ptr)
                         info("buffer %x invalid\n", crs);
                         return;
                 }
-                msg_dbg(buf_msg(crs), "In rec queue: \n");
+                msg_dbg(buf_msg(crs), "In rec queue:\n");
                 crs = crs->next;
         }
 }
diff --git a/net/tipc/net.c b/net/tipc/net.c
index f25b1cdb64eb..d7cd1e064a80 100644
--- a/net/tipc/net.c
+++ b/net/tipc/net.c
@@ -116,7 +116,7 @@
 */
 
 DEFINE_RWLOCK(tipc_net_lock);
-struct _zone *tipc_zones[256] = { NULL, };
+static struct _zone *tipc_zones[256] = { NULL, };
 struct network tipc_net = { tipc_zones };
 
 struct tipc_node *tipc_net_select_remote_node(u32 addr, u32 ref)
@@ -291,6 +291,6 @@ void tipc_net_stop(void)
         tipc_bclink_stop();
         net_stop();
         write_unlock_bh(&tipc_net_lock);
-        info("Left network mode \n");
+        info("Left network mode\n");
 }
 
diff --git a/net/tipc/node.c b/net/tipc/node.c
index 2c24e7d6d950..17cc394f424f 100644
--- a/net/tipc/node.c
+++ b/net/tipc/node.c
@@ -278,7 +278,7 @@ struct tipc_node *tipc_node_attach_link(struct link *l_ptr)
                         n_ptr->link_cnt++;
                         return n_ptr;
                 }
-                err("Attempt to establish second link on <%s> to %s \n",
+                err("Attempt to establish second link on <%s> to %s\n",
                     l_ptr->b_ptr->publ.name,
                     addr_string_fill(addr_string, l_ptr->addr));
         }
diff --git a/net/tipc/ref.c b/net/tipc/ref.c
index 414fc34b8bea..8dea66500cf5 100644
--- a/net/tipc/ref.c
+++ b/net/tipc/ref.c
@@ -153,11 +153,11 @@ void tipc_ref_table_stop(void)
 
 u32 tipc_ref_acquire(void *object, spinlock_t **lock)
 {
-        struct reference *entry;
         u32 index;
         u32 index_mask;
         u32 next_plus_upper;
         u32 ref;
+        struct reference *entry = NULL;
 
         if (!object) {
                 err("Attempt to acquire reference to non-existent object\n");
@@ -175,30 +175,36 @@ u32 tipc_ref_acquire(void *object, spinlock_t **lock)
                 index = tipc_ref_table.first_free;
                 entry = &(tipc_ref_table.entries[index]);
                 index_mask = tipc_ref_table.index_mask;
-                /* take lock in case a previous user of entry still holds it */
-                spin_lock_bh(&entry->lock);
                 next_plus_upper = entry->ref;
                 tipc_ref_table.first_free = next_plus_upper & index_mask;
                 ref = (next_plus_upper & ~index_mask) + index;
-                entry->ref = ref;
-                entry->object = object;
-                *lock = &entry->lock;
         }
         else if (tipc_ref_table.init_point < tipc_ref_table.capacity) {
                 index = tipc_ref_table.init_point++;
                 entry = &(tipc_ref_table.entries[index]);
                 spin_lock_init(&entry->lock);
-                spin_lock_bh(&entry->lock);
                 ref = tipc_ref_table.start_mask + index;
-                entry->ref = ref;
-                entry->object = object;
-                *lock = &entry->lock;
         }
         else {
                 ref = 0;
         }
         write_unlock_bh(&ref_table_lock);
 
+        /*
+         * Grab the lock so no one else can modify this entry
+         * While we assign its ref value & object pointer
+         */
+        if (entry) {
+                spin_lock_bh(&entry->lock);
+                entry->ref = ref;
+                entry->object = object;
+                *lock = &entry->lock;
+                /*
+                 * keep it locked, the caller is responsible
+                 * for unlocking this when they're done with it
+                 */
+        }
+
         return ref;
 }
 
diff --git a/net/tipc/socket.c b/net/tipc/socket.c
index 4b235fc1c70f..66e889ba48fd 100644
--- a/net/tipc/socket.c
+++ b/net/tipc/socket.c
@@ -40,9 +40,9 @@
 #include <linux/socket.h>
 #include <linux/errno.h>
 #include <linux/mm.h>
-#include <linux/slab.h>
 #include <linux/poll.h>
 #include <linux/fcntl.h>
+#include <linux/gfp.h>
 #include <asm/string.h>
 #include <asm/atomic.h>
 #include <net/sock.h>
@@ -446,7 +446,7 @@ static unsigned int poll(struct file *file, struct socket *sock,
         struct sock *sk = sock->sk;
         u32 mask;
 
-        poll_wait(file, sk->sk_sleep, wait);
+        poll_wait(file, sk_sleep(sk), wait);
 
         if (!skb_queue_empty(&sk->sk_receive_queue) ||
             (sock->state == SS_UNCONNECTED) ||
@@ -591,7 +591,7 @@ static int send_msg(struct kiocb *iocb, struct socket *sock,
                         break;
                 }
                 release_sock(sk);
-                res = wait_event_interruptible(*sk->sk_sleep,
+                res = wait_event_interruptible(*sk_sleep(sk),
                                                !tport->congested);
                 lock_sock(sk);
                 if (res)
@@ -650,7 +650,7 @@ static int send_packet(struct kiocb *iocb, struct socket *sock,
                         break;
                 }
                 release_sock(sk);
-                res = wait_event_interruptible(*sk->sk_sleep,
+                res = wait_event_interruptible(*sk_sleep(sk),
                         (!tport->congested || !tport->connected));
                 lock_sock(sk);
                 if (res)
@@ -931,7 +931,7 @@ restart:
                         goto exit;
                 }
                 release_sock(sk);
-                res = wait_event_interruptible(*sk->sk_sleep,
+                res = wait_event_interruptible(*sk_sleep(sk),
                         (!skb_queue_empty(&sk->sk_receive_queue) ||
                          (sock->state == SS_DISCONNECTING)));
                 lock_sock(sk);
@@ -1064,7 +1064,7 @@ restart:
                         goto exit;
                 }
                 release_sock(sk);
-                res = wait_event_interruptible(*sk->sk_sleep,
+                res = wait_event_interruptible(*sk_sleep(sk),
                         (!skb_queue_empty(&sk->sk_receive_queue) ||
                          (sock->state == SS_DISCONNECTING)));
                 lock_sock(sk);
@@ -1271,8 +1271,8 @@ static u32 filter_rcv(struct sock *sk, struct sk_buff *buf)
                 tipc_disconnect_port(tipc_sk_port(sk));
         }
 
-        if (waitqueue_active(sk->sk_sleep))
-                wake_up_interruptible(sk->sk_sleep);
+        if (waitqueue_active(sk_sleep(sk)))
+                wake_up_interruptible(sk_sleep(sk));
         return TIPC_OK;
 }
 
@@ -1343,8 +1343,8 @@ static void wakeupdispatch(struct tipc_port *tport)
 {
         struct sock *sk = (struct sock *)tport->usr_handle;
 
-        if (waitqueue_active(sk->sk_sleep))
-                wake_up_interruptible(sk->sk_sleep);
+        if (waitqueue_active(sk_sleep(sk)))
+                wake_up_interruptible(sk_sleep(sk));
 }
 
 /**
@@ -1426,7 +1426,7 @@ static int connect(struct socket *sock, struct sockaddr *dest, int destlen,
         /* Wait until an 'ACK' or 'RST' arrives, or a timeout occurs */
 
         release_sock(sk);
-        res = wait_event_interruptible_timeout(*sk->sk_sleep,
+        res = wait_event_interruptible_timeout(*sk_sleep(sk),
                         (!skb_queue_empty(&sk->sk_receive_queue) ||
                         (sock->state != SS_CONNECTING)),
                         sk->sk_rcvtimeo);
@@ -1521,7 +1521,7 @@ static int accept(struct socket *sock, struct socket *new_sock, int flags)
                         goto exit;
                 }
                 release_sock(sk);
-                res = wait_event_interruptible(*sk->sk_sleep,
+                res = wait_event_interruptible(*sk_sleep(sk),
                                 (!skb_queue_empty(&sk->sk_receive_queue)));
                 lock_sock(sk);
                 if (res)
@@ -1632,8 +1632,8 @@ restart:
                 /* Discard any unreceived messages; wake up sleeping tasks */
 
                 discard_rx_queue(sk);
-                if (waitqueue_active(sk->sk_sleep))
-                        wake_up_interruptible(sk->sk_sleep);
+                if (waitqueue_active(sk_sleep(sk)))
+                        wake_up_interruptible(sk_sleep(sk));
                 res = 0;
                 break;
 
diff --git a/net/tipc/subscr.c b/net/tipc/subscr.c
index ff123e56114a..ab6eab4c45e2 100644
--- a/net/tipc/subscr.c
+++ b/net/tipc/subscr.c
@@ -274,7 +274,7 @@ static void subscr_cancel(struct tipc_subscr *s,
 {
         struct subscription *sub;
         struct subscription *sub_temp;
-        __u32 type, lower, upper;
+        __u32 type, lower, upper, timeout, filter;
         int found = 0;
 
         /* Find first matching subscription, exit if not found */
@@ -282,12 +282,18 @@ static void subscr_cancel(struct tipc_subscr *s,
         type = ntohl(s->seq.type);
         lower = ntohl(s->seq.lower);
         upper = ntohl(s->seq.upper);
+        timeout = ntohl(s->timeout);
+        filter = ntohl(s->filter) & ~TIPC_SUB_CANCEL;
 
         list_for_each_entry_safe(sub, sub_temp, &subscriber->subscription_list,
                                  subscription_list) {
                         if ((type == sub->seq.type) &&
                             (lower == sub->seq.lower) &&
-                            (upper == sub->seq.upper)) {
+                            (upper == sub->seq.upper) &&
+                            (timeout == sub->timeout) &&
+                            (filter == sub->filter) &&
+                             !memcmp(s->usr_handle,sub->evt.s.usr_handle,
+                                     sizeof(s->usr_handle)) ){
                                 found = 1;
                                 break;
                         }
@@ -304,7 +310,7 @@ static void subscr_cancel(struct tipc_subscr *s,
                 k_term_timer(&sub->timer);
                 spin_lock_bh(subscriber->lock);
         }
-        dbg("Cancel: removing sub %u,%u,%u from subscriber %x list\n",
+        dbg("Cancel: removing sub %u,%u,%u from subscriber %p list\n",
             sub->seq.type, sub->seq.lower, sub->seq.upper, subscriber);
         subscr_del(sub);
 }
@@ -352,8 +358,7 @@ static struct subscription *subscr_subscribe(struct tipc_subscr *s,
         sub->seq.upper = ntohl(s->seq.upper);
         sub->timeout = ntohl(s->timeout);
         sub->filter = ntohl(s->filter);
-        if ((!(sub->filter & TIPC_SUB_PORTS) ==
-             !(sub->filter & TIPC_SUB_SERVICE)) ||
+        if ((sub->filter && (sub->filter != TIPC_SUB_PORTS)) ||
             (sub->seq.lower > sub->seq.upper)) {
                 warn("Subscription rejected, illegal request\n");
                 kfree(sub);
diff --git a/net/unix/af_unix.c b/net/unix/af_unix.c
index 3d9122e78f41..fef2cc5e9d2b 100644
--- a/net/unix/af_unix.c
+++ b/net/unix/af_unix.c
@@ -313,13 +313,16 @@ static inline int unix_writable(struct sock *sk)
 
 static void unix_write_space(struct sock *sk)
 {
-        read_lock(&sk->sk_callback_lock);
+        struct socket_wq *wq;
+
+        rcu_read_lock();
         if (unix_writable(sk)) {
-                if (sk_has_sleeper(sk))
-                        wake_up_interruptible_sync(sk->sk_sleep);
+                wq = rcu_dereference(sk->sk_wq);
+                if (wq_has_sleeper(wq))
+                        wake_up_interruptible_sync(&wq->wait);
                 sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
         }
-        read_unlock(&sk->sk_callback_lock);
+        rcu_read_unlock();
 }
 
 /* When dgram socket disconnects (or changes its peer), we clear its receive
@@ -406,9 +409,7 @@ static int unix_release_sock(struct sock *sk, int embrion)
                                 skpair->sk_err = ECONNRESET;
                         unix_state_unlock(skpair);
                         skpair->sk_state_change(skpair);
-                        read_lock(&skpair->sk_callback_lock);
                         sk_wake_async(skpair, SOCK_WAKE_WAITD, POLL_HUP);
-                        read_unlock(&skpair->sk_callback_lock);
                 }
                 sock_put(skpair); /* It may now die */
                 unix_peer(sk) = NULL;
@@ -1142,7 +1143,7 @@ restart:
         newsk->sk_peercred.pid  = task_tgid_vnr(current);
         current_euid_egid(&newsk->sk_peercred.uid, &newsk->sk_peercred.gid);
         newu = unix_sk(newsk);
-        newsk->sk_sleep         = &newu->peer_wait;
+        newsk->sk_wq            = &newu->peer_wq;
         otheru = unix_sk(other);
 
         /* copy address information from listening to new sock*/
@@ -1736,7 +1737,7 @@ static long unix_stream_data_wait(struct sock *sk, long timeo)
         unix_state_lock(sk);
 
         for (;;) {
-                prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+                prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
 
                 if (!skb_queue_empty(&sk->sk_receive_queue) ||
                     sk->sk_err ||
@@ -1752,7 +1753,7 @@ static long unix_stream_data_wait(struct sock *sk, long timeo)
                 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
         }
 
-        finish_wait(sk->sk_sleep, &wait);
+        finish_wait(sk_sleep(sk), &wait);
         unix_state_unlock(sk);
         return timeo;
 }
@@ -1931,12 +1932,10 @@ static int unix_shutdown(struct socket *sock, int mode)
                         other->sk_shutdown |= peer_mode;
                         unix_state_unlock(other);
                         other->sk_state_change(other);
-                        read_lock(&other->sk_callback_lock);
                         if (peer_mode == SHUTDOWN_MASK)
                                 sk_wake_async(other, SOCK_WAKE_WAITD, POLL_HUP);
                         else if (peer_mode & RCV_SHUTDOWN)
                                 sk_wake_async(other, SOCK_WAKE_WAITD, POLL_IN);
-                        read_unlock(&other->sk_callback_lock);
                 }
                 if (other)
                         sock_put(other);
@@ -1991,7 +1990,7 @@ static unsigned int unix_poll(struct file *file, struct socket *sock, poll_table
         struct sock *sk = sock->sk;
         unsigned int mask;
 
-        sock_poll_wait(file, sk->sk_sleep, wait);
+        sock_poll_wait(file, sk_sleep(sk), wait);
         mask = 0;
 
         /* exceptional events? */
@@ -2028,7 +2027,7 @@ static unsigned int unix_dgram_poll(struct file *file, struct socket *sock,
         struct sock *sk = sock->sk, *other;
         unsigned int mask, writable;
 
-        sock_poll_wait(file, sk->sk_sleep, wait);
+        sock_poll_wait(file, sk_sleep(sk), wait);
         mask = 0;
 
         /* exceptional events? */
diff --git a/net/unix/garbage.c b/net/unix/garbage.c
index 19c17e4a0c8b..c8df6fda0b1f 100644
--- a/net/unix/garbage.c
+++ b/net/unix/garbage.c
@@ -74,7 +74,6 @@
 #include <linux/un.h>
 #include <linux/net.h>
 #include <linux/fs.h>
-#include <linux/slab.h>
 #include <linux/skbuff.h>
 #include <linux/netdevice.h>
 #include <linux/file.h>
@@ -154,15 +153,6 @@ void unix_notinflight(struct file *fp)
         }
 }
 
-static inline struct sk_buff *sock_queue_head(struct sock *sk)
-{
-        return (struct sk_buff *)&sk->sk_receive_queue;
-}
-
-#define receive_queue_for_each_skb(sk, next, skb) \
-        for (skb = sock_queue_head(sk)->next, next = skb->next; \
-             skb != sock_queue_head(sk); skb = next, next = skb->next)
-
 static void scan_inflight(struct sock *x, void (*func)(struct unix_sock *),
                           struct sk_buff_head *hitlist)
 {
@@ -170,7 +160,7 @@ static void scan_inflight(struct sock *x, void (*func)(struct unix_sock *),
         struct sk_buff *next;
 
         spin_lock(&x->sk_receive_queue.lock);
-        receive_queue_for_each_skb(x, next, skb) {
+        skb_queue_walk_safe(&x->sk_receive_queue, skb, next) {
                 /*
                  *      Do we have file descriptors ?
                  */
@@ -226,7 +216,7 @@ static void scan_children(struct sock *x, void (*func)(struct unix_sock *),
                  * and perform a scan on them as well.
                  */
                 spin_lock(&x->sk_receive_queue.lock);
-                receive_queue_for_each_skb(x, next, skb) {
+                skb_queue_walk_safe(&x->sk_receive_queue, skb, next) {
                         u = unix_sk(skb->sk);
 
                         /*
diff --git a/net/unix/sysctl_net_unix.c b/net/unix/sysctl_net_unix.c
index d095c7be10d0..397cffebb3b6 100644
--- a/net/unix/sysctl_net_unix.c
+++ b/net/unix/sysctl_net_unix.c
@@ -10,6 +10,7 @@
  */
 
 #include <linux/mm.h>
+#include <linux/slab.h>
 #include <linux/sysctl.h>
 
 #include <net/af_unix.h>
diff --git a/net/wimax/op-msg.c b/net/wimax/op-msg.c
index 7718657e93dc..d5b7c3779c43 100644
--- a/net/wimax/op-msg.c
+++ b/net/wimax/op-msg.c
@@ -72,6 +72,7 @@
  *   wimax_msg_send()
  */
 #include <linux/device.h>
+#include <linux/slab.h>
 #include <net/genetlink.h>
 #include <linux/netdevice.h>
 #include <linux/wimax.h>
diff --git a/net/wimax/op-reset.c b/net/wimax/op-reset.c
index 4dc82a54ba30..68bedf3e5443 100644
--- a/net/wimax/op-reset.c
+++ b/net/wimax/op-reset.c
@@ -110,7 +110,6 @@ int wimax_gnl_doit_reset(struct sk_buff *skb, struct genl_info *info)
 {
         int result, ifindex;
         struct wimax_dev *wimax_dev;
-        struct device *dev;
 
         d_fnstart(3, NULL, "(skb %p info %p)\n", skb, info);
         result = -ENODEV;
@@ -123,7 +122,6 @@ int wimax_gnl_doit_reset(struct sk_buff *skb, struct genl_info *info)
         wimax_dev = wimax_dev_get_by_genl_info(info, ifindex);
         if (wimax_dev == NULL)
                 goto error_no_wimax_dev;
-        dev = wimax_dev_to_dev(wimax_dev);
         /* Execute the operation and send the result back to user space */
         result = wimax_reset(wimax_dev);
         dev_put(wimax_dev->net_dev);
diff --git a/net/wimax/op-state-get.c b/net/wimax/op-state-get.c
index 11ad3356eb56..aff8776e2d41 100644
--- a/net/wimax/op-state-get.c
+++ b/net/wimax/op-state-get.c
@@ -53,7 +53,6 @@ int wimax_gnl_doit_state_get(struct sk_buff *skb, struct genl_info *info)
 {
         int result, ifindex;
         struct wimax_dev *wimax_dev;
-        struct device *dev;
 
         d_fnstart(3, NULL, "(skb %p info %p)\n", skb, info);
         result = -ENODEV;
@@ -66,7 +65,6 @@ int wimax_gnl_doit_state_get(struct sk_buff *skb, struct genl_info *info)
         wimax_dev = wimax_dev_get_by_genl_info(info, ifindex);
         if (wimax_dev == NULL)
                 goto error_no_wimax_dev;
-        dev = wimax_dev_to_dev(wimax_dev);
         /* Execute the operation and send the result back to user space */
         result = wimax_state_get(wimax_dev);
         dev_put(wimax_dev->net_dev);
diff --git a/net/wimax/stack.c b/net/wimax/stack.c
index 813e1eaea29b..1ed65dbdab03 100644
--- a/net/wimax/stack.c
+++ b/net/wimax/stack.c
@@ -51,6 +51,7 @@
  *   wimax_rfkill_rm()
  */
 #include <linux/device.h>
+#include <linux/gfp.h>
 #include <net/genetlink.h>
 #include <linux/netdevice.h>
 #include <linux/wimax.h>
diff --git a/net/wireless/core.c b/net/wireless/core.c
index 40cbbbfbccbf..37d0e0ab4432 100644
--- a/net/wireless/core.c
+++ b/net/wireless/core.c
@@ -8,6 +8,7 @@
 #include <linux/module.h>
 #include <linux/err.h>
 #include <linux/list.h>
+#include <linux/slab.h>
 #include <linux/nl80211.h>
 #include <linux/debugfs.h>
 #include <linux/notifier.h>
diff --git a/net/wireless/debugfs.c b/net/wireless/debugfs.c
index 2e4895615037..a4991a3efec0 100644
--- a/net/wireless/debugfs.c
+++ b/net/wireless/debugfs.c
@@ -9,6 +9,7 @@
  * published by the Free Software Foundation.
  */
 
+#include <linux/slab.h>
 #include "core.h"
 #include "debugfs.h"
 
diff --git a/net/wireless/ibss.c b/net/wireless/ibss.c
index 6ef5a491fb4b..6a5acf750174 100644
--- a/net/wireless/ibss.c
+++ b/net/wireless/ibss.c
@@ -6,6 +6,7 @@
 
 #include <linux/etherdevice.h>
 #include <linux/if_arp.h>
+#include <linux/slab.h>
 #include <net/cfg80211.h>
 #include "wext-compat.h"
 #include "nl80211.h"
diff --git a/net/wireless/mlme.c b/net/wireless/mlme.c
index 387dd2a27d2f..48ead6f0426d 100644
--- a/net/wireless/mlme.c
+++ b/net/wireless/mlme.c
@@ -8,6 +8,7 @@
 #include <linux/module.h>
 #include <linux/netdevice.h>
 #include <linux/nl80211.h>
+#include <linux/slab.h>
 #include <linux/wireless.h>
 #include <net/cfg80211.h>
 #include <net/iw_handler.h>
diff --git a/net/wireless/nl80211.c b/net/wireless/nl80211.c
index c27bef8e0c11..01da83ddcff7 100644
--- a/net/wireless/nl80211.c
+++ b/net/wireless/nl80211.c
@@ -7,6 +7,7 @@
 #include <linux/if.h>
 #include <linux/module.h>
 #include <linux/err.h>
+#include <linux/slab.h>
 #include <linux/list.h>
 #include <linux/if_ether.h>
 #include <linux/ieee80211.h>
diff --git a/net/wireless/reg.c b/net/wireless/reg.c
index 496348c48506..8f0d97dd3109 100644
--- a/net/wireless/reg.c
+++ b/net/wireless/reg.c
@@ -33,6 +33,7 @@
  *
  */
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/list.h>
 #include <linux/random.h>
 #include <linux/nl80211.h>
diff --git a/net/wireless/scan.c b/net/wireless/scan.c
index 978cac3414b5..a026c6d56bd3 100644
--- a/net/wireless/scan.c
+++ b/net/wireless/scan.c
@@ -4,6 +4,7 @@
  * Copyright 2008 Johannes Berg <johannes@sipsolutions.net>
  */
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/netdevice.h>
 #include <linux/wireless.h>
diff --git a/net/wireless/sme.c b/net/wireless/sme.c
index dcd7685242f7..8ddf5ae0dd03 100644
--- a/net/wireless/sme.c
+++ b/net/wireless/sme.c
@@ -7,6 +7,7 @@
 
 #include <linux/etherdevice.h>
 #include <linux/if_arp.h>
+#include <linux/slab.h>
 #include <linux/workqueue.h>
 #include <linux/wireless.h>
 #include <net/iw_handler.h>
diff --git a/net/wireless/util.c b/net/wireless/util.c
index 7acb81b9675d..3416373a9c0c 100644
--- a/net/wireless/util.c
+++ b/net/wireless/util.c
@@ -5,6 +5,7 @@
  */
 #include <linux/bitops.h>
 #include <linux/etherdevice.h>
+#include <linux/slab.h>
 #include <net/cfg80211.h>
 #include <net/ip.h>
 #include "core.h"
diff --git a/net/wireless/wext-compat.c b/net/wireless/wext-compat.c
index 9ab51838849e..a60a2773b497 100644
--- a/net/wireless/wext-compat.c
+++ b/net/wireless/wext-compat.c
@@ -12,6 +12,7 @@
 #include <linux/nl80211.h>
 #include <linux/if_arp.h>
 #include <linux/etherdevice.h>
+#include <linux/slab.h>
 #include <net/iw_handler.h>
 #include <net/cfg80211.h>
 #include "wext-compat.h"
diff --git a/net/wireless/wext-core.c b/net/wireless/wext-core.c
index bfcbeee23f9c..0ef17bc42bac 100644
--- a/net/wireless/wext-core.c
+++ b/net/wireless/wext-core.c
@@ -10,6 +10,7 @@
 #include <linux/kernel.h>
 #include <linux/netdevice.h>
 #include <linux/rtnetlink.h>
+#include <linux/slab.h>
 #include <linux/wireless.h>
 #include <linux/uaccess.h>
 #include <net/cfg80211.h>
diff --git a/net/wireless/wext-priv.c b/net/wireless/wext-priv.c
index a3c2277de9e5..3feb28e41c53 100644
--- a/net/wireless/wext-priv.c
+++ b/net/wireless/wext-priv.c
@@ -7,6 +7,7 @@
  *
  * (As all part of the Linux kernel, this file is GPL)
  */
+#include <linux/slab.h>
 #include <linux/wireless.h>
 #include <linux/netdevice.h>
 #include <net/iw_handler.h>
diff --git a/net/wireless/wext-sme.c b/net/wireless/wext-sme.c
index 5615a8802536..d5c6140f4cb8 100644
--- a/net/wireless/wext-sme.c
+++ b/net/wireless/wext-sme.c
@@ -7,6 +7,7 @@
 
 #include <linux/etherdevice.h>
 #include <linux/if_arp.h>
+#include <linux/slab.h>
 #include <net/cfg80211.h>
 #include "wext-compat.h"
 #include "nl80211.h"
diff --git a/net/x25/af_x25.c b/net/x25/af_x25.c
index 9796f3ed1edb..296e65e01064 100644
--- a/net/x25/af_x25.c
+++ b/net/x25/af_x25.c
@@ -47,6 +47,7 @@
 #include <linux/netdevice.h>
 #include <linux/if_arp.h>
 #include <linux/skbuff.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 #include <net/tcp_states.h>
 #include <asm/uaccess.h>
@@ -82,6 +83,41 @@ struct compat_x25_subscrip_struct {
 };
 #endif
 
+
+int x25_parse_address_block(struct sk_buff *skb,
+                struct x25_address *called_addr,
+                struct x25_address *calling_addr)
+{
+        unsigned char len;
+        int needed;
+        int rc;
+
+        if (skb->len < 1) {
+                /* packet has no address block */
+                rc = 0;
+                goto empty;
+        }
+
+        len = *skb->data;
+        needed = 1 + (len >> 4) + (len & 0x0f);
+
+        if (skb->len < needed) {
+                /* packet is too short to hold the addresses it claims
+                   to hold */
+                rc = -1;
+                goto empty;
+        }
+
+        return x25_addr_ntoa(skb->data, called_addr, calling_addr);
+
+empty:
+        *called_addr->x25_addr = 0;
+        *calling_addr->x25_addr = 0;
+
+        return rc;
+}
+
+
 int x25_addr_ntoa(unsigned char *p, struct x25_address *called_addr,
                   struct x25_address *calling_addr)
 {
@@ -366,6 +402,7 @@ static void __x25_destroy_socket(struct sock *sk)
                         /*
                          * Queue the unaccepted socket for death
                          */
+                        skb->sk->sk_state = TCP_LISTEN;
                         sock_set_flag(skb->sk, SOCK_DEAD);
                         x25_start_heartbeat(skb->sk);
                         x25_sk(skb->sk)->state = X25_STATE_0;
@@ -553,7 +590,8 @@ static int x25_create(struct net *net, struct socket *sock, int protocol,
         x25->facilities.winsize_out = X25_DEFAULT_WINDOW_SIZE;
         x25->facilities.pacsize_in  = X25_DEFAULT_PACKET_SIZE;
         x25->facilities.pacsize_out = X25_DEFAULT_PACKET_SIZE;
-        x25->facilities.throughput  = X25_DEFAULT_THROUGHPUT;
+        x25->facilities.throughput  = 0;        /* by default don't negotiate
+                                                   throughput */
         x25->facilities.reverse     = X25_DEFAULT_REVERSE;
         x25->dte_facilities.calling_len = 0;
         x25->dte_facilities.called_len = 0;
@@ -681,7 +719,7 @@ static int x25_wait_for_connection_establishment(struct sock *sk)
         DECLARE_WAITQUEUE(wait, current);
         int rc;
 
-        add_wait_queue_exclusive(sk->sk_sleep, &wait);
+        add_wait_queue_exclusive(sk_sleep(sk), &wait);
         for (;;) {
                 __set_current_state(TASK_INTERRUPTIBLE);
                 rc = -ERESTARTSYS;
@@ -701,7 +739,7 @@ static int x25_wait_for_connection_establishment(struct sock *sk)
                         break;
         }
         __set_current_state(TASK_RUNNING);
-        remove_wait_queue(sk->sk_sleep, &wait);
+        remove_wait_queue(sk_sleep(sk), &wait);
         return rc;
 }
 
@@ -801,7 +839,7 @@ static int x25_wait_for_data(struct sock *sk, long timeout)
         DECLARE_WAITQUEUE(wait, current);
         int rc = 0;
 
-        add_wait_queue_exclusive(sk->sk_sleep, &wait);
+        add_wait_queue_exclusive(sk_sleep(sk), &wait);
         for (;;) {
                 __set_current_state(TASK_INTERRUPTIBLE);
                 if (sk->sk_shutdown & RCV_SHUTDOWN)
@@ -821,7 +859,7 @@ static int x25_wait_for_data(struct sock *sk, long timeout)
                         break;
         }
         __set_current_state(TASK_RUNNING);
-        remove_wait_queue(sk->sk_sleep, &wait);
+        remove_wait_queue(sk_sleep(sk), &wait);
         return rc;
 }
 
@@ -921,16 +959,26 @@ int x25_rx_call_request(struct sk_buff *skb, struct x25_neigh *nb,
         /*
          *      Extract the X.25 addresses and convert them to ASCII strings,
          *      and remove them.
+         *
+         *      Address block is mandatory in call request packets
          */
-        addr_len = x25_addr_ntoa(skb->data, &source_addr, &dest_addr);
+        addr_len = x25_parse_address_block(skb, &source_addr, &dest_addr);
+        if (addr_len <= 0)
+                goto out_clear_request;
         skb_pull(skb, addr_len);
 
         /*
          *      Get the length of the facilities, skip past them for the moment
          *      get the call user data because this is needed to determine
          *      the correct listener
+         *
+         *      Facilities length is mandatory in call request packets
          */
+        if (skb->len < 1)
+                goto out_clear_request;
         len = skb->data[0] + 1;
+        if (skb->len < len)
+                goto out_clear_request;
         skb_pull(skb,len);
 
         /*
@@ -1414,9 +1462,20 @@ static int x25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
                         if (facilities.winsize_in < 1 ||
                             facilities.winsize_in > 127)
                                 break;
-                        if (facilities.throughput < 0x03 ||
-                            facilities.throughput > 0xDD)
-                                break;
+                        if (facilities.throughput) {
+                                int out = facilities.throughput & 0xf0;
+                                int in  = facilities.throughput & 0x0f;
+                                if (!out)
+                                        facilities.throughput |=
+                                                X25_DEFAULT_THROUGHPUT << 4;
+                                else if (out < 0x30 || out > 0xD0)
+                                        break;
+                                if (!in)
+                                        facilities.throughput |=
+                                                X25_DEFAULT_THROUGHPUT;
+                                else if (in < 0x03 || in > 0x0D)
+                                        break;
+                        }
                         if (facilities.reverse &&
                                 (facilities.reverse & 0x81) != 0x81)
                                 break;
diff --git a/net/x25/x25_dev.c b/net/x25/x25_dev.c
index 52e304212241..9005f6daeab5 100644
--- a/net/x25/x25_dev.c
+++ b/net/x25/x25_dev.c
@@ -20,9 +20,11 @@
 #include <linux/kernel.h>
 #include <linux/netdevice.h>
 #include <linux/skbuff.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 #include <linux/if_arp.h>
 #include <net/x25.h>
+#include <net/x25device.h>
 
 static int x25_receive_data(struct sk_buff *skb, struct x25_neigh *nb)
 {
@@ -114,19 +116,22 @@ int x25_lapb_receive_frame(struct sk_buff *skb, struct net_device *dev,
         }
 
         switch (skb->data[0]) {
-                case 0x00:
-                        skb_pull(skb, 1);
-                        if (x25_receive_data(skb, nb)) {
-                                x25_neigh_put(nb);
-                                goto out;
-                        }
-                        break;
-                case 0x01:
-                        x25_link_established(nb);
-                        break;
-                case 0x02:
-                        x25_link_terminated(nb);
-                        break;
+
+        case X25_IFACE_DATA:
+                skb_pull(skb, 1);
+                if (x25_receive_data(skb, nb)) {
+                        x25_neigh_put(nb);
+                        goto out;
+                }
+                break;
+
+        case X25_IFACE_CONNECT:
+                x25_link_established(nb);
+                break;
+
+        case X25_IFACE_DISCONNECT:
+                x25_link_terminated(nb);
+                break;
         }
         x25_neigh_put(nb);
 drop:
@@ -147,7 +152,7 @@ void x25_establish_link(struct x25_neigh *nb)
                                 return;
                         }
                         ptr  = skb_put(skb, 1);
-                        *ptr = 0x01;
+                        *ptr = X25_IFACE_CONNECT;
                         break;
 
 #if defined(CONFIG_LLC) || defined(CONFIG_LLC_MODULE)
@@ -183,7 +188,7 @@ void x25_terminate_link(struct x25_neigh *nb)
         }
 
         ptr  = skb_put(skb, 1);
-        *ptr = 0x02;
+        *ptr = X25_IFACE_DISCONNECT;
 
         skb->protocol = htons(ETH_P_X25);
         skb->dev      = nb->dev;
@@ -199,7 +204,7 @@ void x25_send_frame(struct sk_buff *skb, struct x25_neigh *nb)
         switch (nb->dev->type) {
                 case ARPHRD_X25:
                         dptr  = skb_push(skb, 1);
-                        *dptr = 0x00;
+                        *dptr = X25_IFACE_DATA;
                         break;
 
 #if defined(CONFIG_LLC) || defined(CONFIG_LLC_MODULE)
diff --git a/net/x25/x25_facilities.c b/net/x25/x25_facilities.c
index a21f6646eb3a..771bab00754b 100644
--- a/net/x25/x25_facilities.c
+++ b/net/x25/x25_facilities.c
@@ -35,7 +35,7 @@ int x25_parse_facilities(struct sk_buff *skb, struct x25_facilities *facilities,
                 struct x25_dte_facilities *dte_facs, unsigned long *vc_fac_mask)
 {
         unsigned char *p = skb->data;
-        unsigned int len = *p++;
+        unsigned int len;
 
         *vc_fac_mask = 0;
 
@@ -50,6 +50,14 @@ int x25_parse_facilities(struct sk_buff *skb, struct x25_facilities *facilities,
         memset(dte_facs->called_ae, '\0', sizeof(dte_facs->called_ae));
         memset(dte_facs->calling_ae, '\0', sizeof(dte_facs->calling_ae));
 
+        if (skb->len < 1)
+                return 0;
+
+        len = *p++;
+
+        if (len >= skb->len)
+                return -1;
+
         while (len > 0) {
                 switch (*p & X25_FAC_CLASS_MASK) {
                 case X25_FAC_CLASS_A:
@@ -247,6 +255,8 @@ int x25_negotiate_facilities(struct sk_buff *skb, struct sock *sk,
         memcpy(new, ours, sizeof(*new));
 
         len = x25_parse_facilities(skb, &theirs, dte, &x25->vc_facil_mask);
+        if (len < 0)
+                return len;
 
         /*
          *      They want reverse charging, we won't accept it.
@@ -259,9 +269,18 @@ int x25_negotiate_facilities(struct sk_buff *skb, struct sock *sk,
         new->reverse = theirs.reverse;
 
         if (theirs.throughput) {
-                if (theirs.throughput < ours->throughput) {
-                        SOCK_DEBUG(sk, "X.25: throughput negotiated down\n");
-                        new->throughput = theirs.throughput;
+                int theirs_in =  theirs.throughput & 0x0f;
+                int theirs_out = theirs.throughput & 0xf0;
+                int ours_in  = ours->throughput & 0x0f;
+                int ours_out = ours->throughput & 0xf0;
+                if (!ours_in || theirs_in < ours_in) {
+                        SOCK_DEBUG(sk, "X.25: inbound throughput negotiated\n");
+                        new->throughput = (new->throughput & 0xf0) | theirs_in;
+                }
+                if (!ours_out || theirs_out < ours_out) {
+                        SOCK_DEBUG(sk,
+                                "X.25: outbound throughput negotiated\n");
+                        new->throughput = (new->throughput & 0x0f) | theirs_out;
                 }
         }
 
diff --git a/net/x25/x25_forward.c b/net/x25/x25_forward.c
index 056a55f3a871..25a810793968 100644
--- a/net/x25/x25_forward.c
+++ b/net/x25/x25_forward.c
@@ -10,6 +10,7 @@
  */
 #include <linux/if_arp.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <net/x25.h>
 
 LIST_HEAD(x25_forward_list);
diff --git a/net/x25/x25_in.c b/net/x25/x25_in.c
index 96d922783547..372ac226e648 100644
--- a/net/x25/x25_in.c
+++ b/net/x25/x25_in.c
@@ -23,6 +23,7 @@
  *                                        i-frames.
  */
 
+#include <linux/slab.h>
 #include <linux/errno.h>
 #include <linux/kernel.h>
 #include <linux/string.h>
@@ -89,6 +90,7 @@ static int x25_queue_rx_frame(struct sock *sk, struct sk_buff *skb, int more)
 static int x25_state1_machine(struct sock *sk, struct sk_buff *skb, int frametype)
 {
         struct x25_address source_addr, dest_addr;
+        int len;
 
         switch (frametype) {
                 case X25_CALL_ACCEPTED: {
@@ -106,11 +108,17 @@ static int x25_state1_machine(struct sock *sk, struct sk_buff *skb, int frametyp
                          *      Parse the data in the frame.
                          */
                         skb_pull(skb, X25_STD_MIN_LEN);
-                        skb_pull(skb, x25_addr_ntoa(skb->data, &source_addr, &dest_addr));
-                        skb_pull(skb,
-                                 x25_parse_facilities(skb, &x25->facilities,
+
+                        len = x25_parse_address_block(skb, &source_addr,
+                                                &dest_addr);
+                        if (len > 0)
+                                skb_pull(skb, len);
+
+                        len = x25_parse_facilities(skb, &x25->facilities,
                                                 &x25->dte_facilities,
-                                                &x25->vc_facil_mask));
+                                                &x25->vc_facil_mask);
+                        if (len > 0)
+                                skb_pull(skb, len);
                         /*
                          *      Copy any Call User Data.
                          */
diff --git a/net/x25/x25_link.c b/net/x25/x25_link.c
index e4e1b6e49538..73e7b954ad28 100644
--- a/net/x25/x25_link.c
+++ b/net/x25/x25_link.c
@@ -24,6 +24,7 @@
 #include <linux/kernel.h>
 #include <linux/jiffies.h>
 #include <linux/timer.h>
+#include <linux/slab.h>
 #include <linux/netdevice.h>
 #include <linux/skbuff.h>
 #include <asm/uaccess.h>
diff --git a/net/x25/x25_out.c b/net/x25/x25_out.c
index 2b96b52114d6..52351a26b6fc 100644
--- a/net/x25/x25_out.c
+++ b/net/x25/x25_out.c
@@ -22,6 +22,7 @@
  *                                      needed cleaned seq-number fields.
  */
 
+#include <linux/slab.h>
 #include <linux/socket.h>
 #include <linux/kernel.h>
 #include <linux/string.h>
diff --git a/net/x25/x25_route.c b/net/x25/x25_route.c
index b95fae9ab393..97d77c532d8c 100644
--- a/net/x25/x25_route.c
+++ b/net/x25/x25_route.c
@@ -19,6 +19,7 @@
 
 #include <linux/if_arp.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <net/x25.h>
 
 LIST_HEAD(x25_route_list);
diff --git a/net/x25/x25_subr.c b/net/x25/x25_subr.c
index 352b32d216fc..dc20cf12f39b 100644
--- a/net/x25/x25_subr.c
+++ b/net/x25/x25_subr.c
@@ -23,6 +23,7 @@
  *                                              restriction on response.
  */
 
+#include <linux/slab.h>
 #include <linux/kernel.h>
 #include <linux/string.h>
 #include <linux/skbuff.h>
diff --git a/net/xfrm/xfrm_hash.h b/net/xfrm/xfrm_hash.h
index e5195c99f71e..1396572d2ade 100644
--- a/net/xfrm/xfrm_hash.h
+++ b/net/xfrm/xfrm_hash.h
@@ -16,7 +16,8 @@ static inline unsigned int __xfrm6_addr_hash(xfrm_address_t *addr)
 
 static inline unsigned int __xfrm4_daddr_saddr_hash(xfrm_address_t *daddr, xfrm_address_t *saddr)
 {
-        return ntohl(daddr->a4 + saddr->a4);
+        u32 sum = (__force u32)daddr->a4 + (__force u32)saddr->a4;
+        return ntohl((__force __be32)sum);
 }
 
 static inline unsigned int __xfrm6_daddr_saddr_hash(xfrm_address_t *daddr, xfrm_address_t *saddr)
diff --git a/net/xfrm/xfrm_ipcomp.c b/net/xfrm/xfrm_ipcomp.c
index 0fc5ff66d1fa..fc91ad7ee26e 100644
--- a/net/xfrm/xfrm_ipcomp.c
+++ b/net/xfrm/xfrm_ipcomp.c
@@ -17,11 +17,11 @@
 
 #include <linux/crypto.h>
 #include <linux/err.h>
-#include <linux/gfp.h>
 #include <linux/list.h>
 #include <linux/module.h>
 #include <linux/mutex.h>
 #include <linux/percpu.h>
+#include <linux/slab.h>
 #include <linux/smp.h>
 #include <linux/vmalloc.h>
 #include <net/ip.h>
diff --git a/net/xfrm/xfrm_output.c b/net/xfrm/xfrm_output.c
index b9fe13138c07..6a329158bdfa 100644
--- a/net/xfrm/xfrm_output.c
+++ b/net/xfrm/xfrm_output.c
@@ -14,6 +14,7 @@
 #include <linux/netdevice.h>
 #include <linux/netfilter.h>
 #include <linux/skbuff.h>
+#include <linux/slab.h>
 #include <linux/spinlock.h>
 #include <net/dst.h>
 #include <net/xfrm.h>
diff --git a/net/xfrm/xfrm_policy.c b/net/xfrm/xfrm_policy.c
index 843e066649cb..31f4ba43b48f 100644
--- a/net/xfrm/xfrm_policy.c
+++ b/net/xfrm/xfrm_policy.c
@@ -37,6 +37,8 @@
 DEFINE_MUTEX(xfrm_cfg_mutex);
 EXPORT_SYMBOL(xfrm_cfg_mutex);
 
+static DEFINE_SPINLOCK(xfrm_policy_sk_bundle_lock);
+static struct dst_entry *xfrm_policy_sk_bundles;
 static DEFINE_RWLOCK(xfrm_policy_lock);
 
 static DEFINE_RWLOCK(xfrm_policy_afinfo_lock);
@@ -44,12 +46,10 @@ static struct xfrm_policy_afinfo *xfrm_policy_afinfo[NPROTO];
 
 static struct kmem_cache *xfrm_dst_cache __read_mostly;
 
-static HLIST_HEAD(xfrm_policy_gc_list);
-static DEFINE_SPINLOCK(xfrm_policy_gc_lock);
-
 static struct xfrm_policy_afinfo *xfrm_policy_get_afinfo(unsigned short family);
 static void xfrm_policy_put_afinfo(struct xfrm_policy_afinfo *afinfo);
 static void xfrm_init_pmtu(struct dst_entry *dst);
+static int stale_bundle(struct dst_entry *dst);
 
 static struct xfrm_policy *__xfrm_policy_unlink(struct xfrm_policy *pol,
                                                 int dir);
@@ -156,7 +156,7 @@ static void xfrm_policy_timer(unsigned long data)
 
         read_lock(&xp->lock);
 
-        if (xp->walk.dead)
+        if (unlikely(xp->walk.dead))
                 goto out;
 
         dir = xfrm_policy_id2dir(xp->index);
@@ -216,6 +216,35 @@ expired:
         xfrm_pol_put(xp);
 }
 
+static struct flow_cache_object *xfrm_policy_flo_get(struct flow_cache_object *flo)
+{
+        struct xfrm_policy *pol = container_of(flo, struct xfrm_policy, flo);
+
+        if (unlikely(pol->walk.dead))
+                flo = NULL;
+        else
+                xfrm_pol_hold(pol);
+
+        return flo;
+}
+
+static int xfrm_policy_flo_check(struct flow_cache_object *flo)
+{
+        struct xfrm_policy *pol = container_of(flo, struct xfrm_policy, flo);
+
+        return !pol->walk.dead;
+}
+
+static void xfrm_policy_flo_delete(struct flow_cache_object *flo)
+{
+        xfrm_pol_put(container_of(flo, struct xfrm_policy, flo));
+}
+
+static const struct flow_cache_ops xfrm_policy_fc_ops = {
+        .get = xfrm_policy_flo_get,
+        .check = xfrm_policy_flo_check,
+        .delete = xfrm_policy_flo_delete,
+};
 
 /* Allocate xfrm_policy. Not used here, it is supposed to be used by pfkeyv2
  * SPD calls.
@@ -236,6 +265,7 @@ struct xfrm_policy *xfrm_policy_alloc(struct net *net, gfp_t gfp)
                 atomic_set(&policy->refcnt, 1);
                 setup_timer(&policy->timer, xfrm_policy_timer,
                                 (unsigned long)policy);
+                policy->flo.ops = &xfrm_policy_fc_ops;
         }
         return policy;
 }
@@ -247,8 +277,6 @@ void xfrm_policy_destroy(struct xfrm_policy *policy)
 {
         BUG_ON(!policy->walk.dead);
 
-        BUG_ON(policy->bundles);
-
         if (del_timer(&policy->timer))
                 BUG();
 
@@ -257,63 +285,20 @@ void xfrm_policy_destroy(struct xfrm_policy *policy)
 }
 EXPORT_SYMBOL(xfrm_policy_destroy);
 
-static void xfrm_policy_gc_kill(struct xfrm_policy *policy)
-{
-        struct dst_entry *dst;
-
-        while ((dst = policy->bundles) != NULL) {
-                policy->bundles = dst->next;
-                dst_free(dst);
-        }
-
-        if (del_timer(&policy->timer))
-                atomic_dec(&policy->refcnt);
-
-        if (atomic_read(&policy->refcnt) > 1)
-                flow_cache_flush();
-
-        xfrm_pol_put(policy);
-}
-
-static void xfrm_policy_gc_task(struct work_struct *work)
-{
-        struct xfrm_policy *policy;
-        struct hlist_node *entry, *tmp;
-        struct hlist_head gc_list;
-
-        spin_lock_bh(&xfrm_policy_gc_lock);
-        gc_list.first = xfrm_policy_gc_list.first;
-        INIT_HLIST_HEAD(&xfrm_policy_gc_list);
-        spin_unlock_bh(&xfrm_policy_gc_lock);
-
-        hlist_for_each_entry_safe(policy, entry, tmp, &gc_list, bydst)
-                xfrm_policy_gc_kill(policy);
-}
-static DECLARE_WORK(xfrm_policy_gc_work, xfrm_policy_gc_task);
-
 /* Rule must be locked. Release descentant resources, announce
  * entry dead. The rule must be unlinked from lists to the moment.
  */
 
 static void xfrm_policy_kill(struct xfrm_policy *policy)
 {
-        int dead;
-
-        write_lock_bh(&policy->lock);
-        dead = policy->walk.dead;
         policy->walk.dead = 1;
-        write_unlock_bh(&policy->lock);
 
-        if (unlikely(dead)) {
-                WARN_ON(1);
-                return;
-        }
+        atomic_inc(&policy->genid);
 
-        spin_lock_bh(&xfrm_policy_gc_lock);
-        hlist_add_head(&policy->bydst, &xfrm_policy_gc_list);
-        spin_unlock_bh(&xfrm_policy_gc_lock);
+        if (del_timer(&policy->timer))
+                xfrm_pol_put(policy);
 
-        schedule_work(&xfrm_policy_gc_work);
+        xfrm_pol_put(policy);
 }
 
 static unsigned int xfrm_policy_hashmax __read_mostly = 1 * 1024 * 1024;
@@ -555,7 +540,6 @@ int xfrm_policy_insert(int dir, struct xfrm_policy *policy, int excl)
         struct xfrm_policy *delpol;
         struct hlist_head *chain;
         struct hlist_node *entry, *newpos;
-        struct dst_entry *gc_list;
         u32 mark = policy->mark.v & policy->mark.m;
 
         write_lock_bh(&xfrm_policy_lock);
@@ -605,34 +589,6 @@ int xfrm_policy_insert(int dir, struct xfrm_policy *policy, int excl)
         else if (xfrm_bydst_should_resize(net, dir, NULL))
                 schedule_work(&net->xfrm.policy_hash_work);
 
-        read_lock_bh(&xfrm_policy_lock);
-        gc_list = NULL;
-        entry = &policy->bydst;
-        hlist_for_each_entry_continue(policy, entry, bydst) {
-                struct dst_entry *dst;
-
-                write_lock(&policy->lock);
-                dst = policy->bundles;
-                if (dst) {
-                        struct dst_entry *tail = dst;
-                        while (tail->next)
-                                tail = tail->next;
-                        tail->next = gc_list;
-                        gc_list = dst;
-
-                        policy->bundles = NULL;
-                }
-                write_unlock(&policy->lock);
-        }
-        read_unlock_bh(&xfrm_policy_lock);
-
-        while (gc_list) {
-                struct dst_entry *dst = gc_list;
-
-                gc_list = dst->next;
-                dst_free(dst);
-        }
-
         return 0;
 }
 EXPORT_SYMBOL(xfrm_policy_insert);
@@ -671,10 +627,8 @@ struct xfrm_policy *xfrm_policy_bysel_ctx(struct net *net, u32 mark, u8 type,
         }
         write_unlock_bh(&xfrm_policy_lock);
 
-        if (ret && delete) {
-                atomic_inc(&flow_cache_genid);
+        if (ret && delete)
                 xfrm_policy_kill(ret);
-        }
         return ret;
 }
 EXPORT_SYMBOL(xfrm_policy_bysel_ctx);
@@ -713,10 +667,8 @@ struct xfrm_policy *xfrm_policy_byid(struct net *net, u32 mark, u8 type,
         }
         write_unlock_bh(&xfrm_policy_lock);
 
-        if (ret && delete) {
-                atomic_inc(&flow_cache_genid);
+        if (ret && delete)
                 xfrm_policy_kill(ret);
-        }
         return ret;
 }
 EXPORT_SYMBOL(xfrm_policy_byid);
@@ -776,7 +728,6 @@ xfrm_policy_flush_secctx_check(struct net *net, u8 type, struct xfrm_audit *audi
 int xfrm_policy_flush(struct net *net, u8 type, struct xfrm_audit *audit_info)
 {
         int dir, err = 0, cnt = 0;
-        struct xfrm_policy *dp;
 
         write_lock_bh(&xfrm_policy_lock);
 
@@ -794,10 +745,9 @@ int xfrm_policy_flush(struct net *net, u8 type, struct xfrm_audit *audit_info)
                                      &net->xfrm.policy_inexact[dir], bydst) {
                         if (pol->type != type)
                                 continue;
-                        dp = __xfrm_policy_unlink(pol, dir);
+                        __xfrm_policy_unlink(pol, dir);
                         write_unlock_bh(&xfrm_policy_lock);
-                        if (dp)
-                                cnt++;
+                        cnt++;
 
                         xfrm_audit_policy_delete(pol, 1, audit_info->loginuid,
                                                  audit_info->sessionid,
@@ -816,10 +766,9 @@ int xfrm_policy_flush(struct net *net, u8 type, struct xfrm_audit *audit_info)
                                              bydst) {
                                 if (pol->type != type)
                                         continue;
-                                dp = __xfrm_policy_unlink(pol, dir);
+                                __xfrm_policy_unlink(pol, dir);
                                 write_unlock_bh(&xfrm_policy_lock);
-                                if (dp)
-                                        cnt++;
+                                cnt++;
 
                                 xfrm_audit_policy_delete(pol, 1,
                                                          audit_info->loginuid,
@@ -835,7 +784,6 @@ int xfrm_policy_flush(struct net *net, u8 type, struct xfrm_audit *audit_info)
         }
         if (!cnt)
                 err = -ESRCH;
-        atomic_inc(&flow_cache_genid);
 out:
         write_unlock_bh(&xfrm_policy_lock);
         return err;
@@ -989,32 +937,37 @@ fail:
         return ret;
 }
 
-static int xfrm_policy_lookup(struct net *net, struct flowi *fl, u16 family,
-                              u8 dir, void **objp, atomic_t **obj_refp)
+static struct xfrm_policy *
+__xfrm_policy_lookup(struct net *net, struct flowi *fl, u16 family, u8 dir)
 {
+#ifdef CONFIG_XFRM_SUB_POLICY
         struct xfrm_policy *pol;
-        int err = 0;
 
-#ifdef CONFIG_XFRM_SUB_POLICY
         pol = xfrm_policy_lookup_bytype(net, XFRM_POLICY_TYPE_SUB, fl, family, dir);
-        if (IS_ERR(pol)) {
-                err = PTR_ERR(pol);
-                pol = NULL;
-        }
-        if (pol || err)
-                goto end;
-#endif
-        pol = xfrm_policy_lookup_bytype(net, XFRM_POLICY_TYPE_MAIN, fl, family, dir);
-        if (IS_ERR(pol)) {
-                err = PTR_ERR(pol);
-                pol = NULL;
-        }
-#ifdef CONFIG_XFRM_SUB_POLICY
-end:
+        if (pol != NULL)
+                return pol;
 #endif
-        if ((*objp = (void *) pol) != NULL)
-                *obj_refp = &pol->refcnt;
-        return err;
+        return xfrm_policy_lookup_bytype(net, XFRM_POLICY_TYPE_MAIN, fl, family, dir);
+}
+
+static struct flow_cache_object *
+xfrm_policy_lookup(struct net *net, struct flowi *fl, u16 family,
+                   u8 dir, struct flow_cache_object *old_obj, void *ctx)
+{
+        struct xfrm_policy *pol;
+
+        if (old_obj)
+                xfrm_pol_put(container_of(old_obj, struct xfrm_policy, flo));
+
+        pol = __xfrm_policy_lookup(net, fl, family, dir);
+        if (IS_ERR_OR_NULL(pol))
+                return ERR_CAST(pol);
+
+        /* Resolver returns two references:
+         * one for cache and one for caller of flow_cache_lookup() */
+        xfrm_pol_hold(pol);
+
+        return &pol->flo;
 }
 
 static inline int policy_to_flow_dir(int dir)
@@ -1104,8 +1057,6 @@ int xfrm_policy_delete(struct xfrm_policy *pol, int dir)
         pol = __xfrm_policy_unlink(pol, dir);
         write_unlock_bh(&xfrm_policy_lock);
         if (pol) {
-                if (dir < XFRM_POLICY_MAX)
-                        atomic_inc(&flow_cache_genid);
                 xfrm_policy_kill(pol);
                 return 0;
         }
@@ -1132,6 +1083,9 @@ int xfrm_sk_policy_insert(struct sock *sk, int dir, struct xfrm_policy *pol)
                 __xfrm_policy_link(pol, XFRM_POLICY_MAX+dir);
         }
         if (old_pol)
+                /* Unlinking succeeds always. This is the only function
+                 * allowed to delete or replace socket policy.
+                 */
                 __xfrm_policy_unlink(old_pol, XFRM_POLICY_MAX+dir);
         write_unlock_bh(&xfrm_policy_lock);
 
@@ -1300,18 +1254,6 @@ xfrm_tmpl_resolve(struct xfrm_policy **pols, int npols, struct flowi *fl,
  * still valid.
  */
 
-static struct dst_entry *
-xfrm_find_bundle(struct flowi *fl, struct xfrm_policy *policy, unsigned short family)
-{
-        struct dst_entry *x;
-        struct xfrm_policy_afinfo *afinfo = xfrm_policy_get_afinfo(family);
-        if (unlikely(afinfo == NULL))
-                return ERR_PTR(-EINVAL);
-        x = afinfo->find_bundle(fl, policy);
-        xfrm_policy_put_afinfo(afinfo);
-        return x;
-}
-
 static inline int xfrm_get_tos(struct flowi *fl, int family)
 {
         struct xfrm_policy_afinfo *afinfo = xfrm_policy_get_afinfo(family);
@@ -1327,6 +1269,54 @@ static inline int xfrm_get_tos(struct flowi *fl, int family)
         return tos;
 }
 
+static struct flow_cache_object *xfrm_bundle_flo_get(struct flow_cache_object *flo)
+{
+        struct xfrm_dst *xdst = container_of(flo, struct xfrm_dst, flo);
+        struct dst_entry *dst = &xdst->u.dst;
+
+        if (xdst->route == NULL) {
+                /* Dummy bundle - if it has xfrms we were not
+                 * able to build bundle as template resolution failed.
+                 * It means we need to try again resolving. */
+                if (xdst->num_xfrms > 0)
+                        return NULL;
+        } else {
+                /* Real bundle */
+                if (stale_bundle(dst))
+                        return NULL;
+        }
+
+        dst_hold(dst);
+        return flo;
+}
+
+static int xfrm_bundle_flo_check(struct flow_cache_object *flo)
+{
+        struct xfrm_dst *xdst = container_of(flo, struct xfrm_dst, flo);
+        struct dst_entry *dst = &xdst->u.dst;
+
+        if (!xdst->route)
+                return 0;
+        if (stale_bundle(dst))
+                return 0;
+
+        return 1;
+}
+
+static void xfrm_bundle_flo_delete(struct flow_cache_object *flo)
+{
+        struct xfrm_dst *xdst = container_of(flo, struct xfrm_dst, flo);
+        struct dst_entry *dst = &xdst->u.dst;
+
+        dst_free(dst);
+}
+
+static const struct flow_cache_ops xfrm_bundle_fc_ops = {
+        .get = xfrm_bundle_flo_get,
+        .check = xfrm_bundle_flo_check,
+        .delete = xfrm_bundle_flo_delete,
+};
+
 static inline struct xfrm_dst *xfrm_alloc_dst(struct net *net, int family)
 {
         struct xfrm_policy_afinfo *afinfo = xfrm_policy_get_afinfo(family);
@@ -1349,9 +1339,10 @@ static inline struct xfrm_dst *xfrm_alloc_dst(struct net *net, int family)
                 BUG();
         }
         xdst = dst_alloc(dst_ops) ?: ERR_PTR(-ENOBUFS);
-
         xfrm_policy_put_afinfo(afinfo);
 
+        xdst->flo.ops = &xfrm_bundle_fc_ops;
+
         return xdst;
 }
 
@@ -1389,6 +1380,7 @@ static inline int xfrm_fill_dst(struct xfrm_dst *xdst, struct net_device *dev,
         return err;
 }
 
+
 /* Allocate chain of dst_entry's, attach known xfrm's, calculate
  * all the metrics... Shortly, bundle a bundle.
  */
@@ -1452,7 +1444,7 @@ static struct dst_entry *xfrm_bundle_create(struct xfrm_policy *policy,
                         dst_hold(dst);
 
                 dst1->xfrm = xfrm[i];
-                xdst->genid = xfrm[i]->genid;
+                xdst->xfrm_genid = xfrm[i]->genid;
 
                 dst1->obsolete = -1;
                 dst1->flags |= DST_HOST;
@@ -1545,7 +1537,186 @@ xfrm_dst_update_origin(struct dst_entry *dst, struct flowi *fl)
 #endif
 }
 
-static int stale_bundle(struct dst_entry *dst);
+static int xfrm_expand_policies(struct flowi *fl, u16 family,
+                                struct xfrm_policy **pols,
+                                int *num_pols, int *num_xfrms)
+{
+        int i;
+
+        if (*num_pols == 0 || !pols[0]) {
+                *num_pols = 0;
+                *num_xfrms = 0;
+                return 0;
+        }
+        if (IS_ERR(pols[0]))
+                return PTR_ERR(pols[0]);
+
+        *num_xfrms = pols[0]->xfrm_nr;
+
+#ifdef CONFIG_XFRM_SUB_POLICY
+        if (pols[0] && pols[0]->action == XFRM_POLICY_ALLOW &&
+            pols[0]->type != XFRM_POLICY_TYPE_MAIN) {
+                pols[1] = xfrm_policy_lookup_bytype(xp_net(pols[0]),
+                                                    XFRM_POLICY_TYPE_MAIN,
+                                                    fl, family,
+                                                    XFRM_POLICY_OUT);
+                if (pols[1]) {
+                        if (IS_ERR(pols[1])) {
+                                xfrm_pols_put(pols, *num_pols);
+                                return PTR_ERR(pols[1]);
+                        }
+                        (*num_pols) ++;
+                        (*num_xfrms) += pols[1]->xfrm_nr;
+                }
+        }
+#endif
+        for (i = 0; i < *num_pols; i++) {
+                if (pols[i]->action != XFRM_POLICY_ALLOW) {
+                        *num_xfrms = -1;
+                        break;
+                }
+        }
+
+        return 0;
+
+}
+
+static struct xfrm_dst *
+xfrm_resolve_and_create_bundle(struct xfrm_policy **pols, int num_pols,
+                               struct flowi *fl, u16 family,
+                               struct dst_entry *dst_orig)
+{
+        struct net *net = xp_net(pols[0]);
+        struct xfrm_state *xfrm[XFRM_MAX_DEPTH];
+        struct dst_entry *dst;
+        struct xfrm_dst *xdst;
+        int err;
+
+        /* Try to instantiate a bundle */
+        err = xfrm_tmpl_resolve(pols, num_pols, fl, xfrm, family);
+        if (err < 0) {
+                if (err != -EAGAIN)
+                        XFRM_INC_STATS(net, LINUX_MIB_XFRMOUTPOLERROR);
+                return ERR_PTR(err);
+        }
+
+        dst = xfrm_bundle_create(pols[0], xfrm, err, fl, dst_orig);
+        if (IS_ERR(dst)) {
+                XFRM_INC_STATS(net, LINUX_MIB_XFRMOUTBUNDLEGENERROR);
+                return ERR_CAST(dst);
+        }
+
+        xdst = (struct xfrm_dst *)dst;
+        xdst->num_xfrms = err;
+        if (num_pols > 1)
+                err = xfrm_dst_update_parent(dst, &pols[1]->selector);
+        else
+                err = xfrm_dst_update_origin(dst, fl);
+        if (unlikely(err)) {
+                dst_free(dst);
+                XFRM_INC_STATS(net, LINUX_MIB_XFRMOUTBUNDLECHECKERROR);
+                return ERR_PTR(err);
+        }
+
+        xdst->num_pols = num_pols;
+        memcpy(xdst->pols, pols, sizeof(struct xfrm_policy*) * num_pols);
+        xdst->policy_genid = atomic_read(&pols[0]->genid);
+
+        return xdst;
+}
+
+static struct flow_cache_object *
+xfrm_bundle_lookup(struct net *net, struct flowi *fl, u16 family, u8 dir,
+                   struct flow_cache_object *oldflo, void *ctx)
+{
+        struct dst_entry *dst_orig = (struct dst_entry *)ctx;
+        struct xfrm_policy *pols[XFRM_POLICY_TYPE_MAX];
+        struct xfrm_dst *xdst, *new_xdst;
+        int num_pols = 0, num_xfrms = 0, i, err, pol_dead;
+
+        /* Check if the policies from old bundle are usable */
+        xdst = NULL;
+        if (oldflo) {
+                xdst = container_of(oldflo, struct xfrm_dst, flo);
+                num_pols = xdst->num_pols;
+                num_xfrms = xdst->num_xfrms;
+                pol_dead = 0;
+                for (i = 0; i < num_pols; i++) {
+                        pols[i] = xdst->pols[i];
+                        pol_dead |= pols[i]->walk.dead;
+                }
+                if (pol_dead) {
+                        dst_free(&xdst->u.dst);
+                        xdst = NULL;
+                        num_pols = 0;
+                        num_xfrms = 0;
+                        oldflo = NULL;
+                }
+        }
+
+        /* Resolve policies to use if we couldn't get them from
+         * previous cache entry */
+        if (xdst == NULL) {
+                num_pols = 1;
+                pols[0] = __xfrm_policy_lookup(net, fl, family, dir);
+                err = xfrm_expand_policies(fl, family, pols,
+                                           &num_pols, &num_xfrms);
+                if (err < 0)
+                        goto inc_error;
+                if (num_pols == 0)
+                        return NULL;
+                if (num_xfrms <= 0)
+                        goto make_dummy_bundle;
+        }
+
+        new_xdst = xfrm_resolve_and_create_bundle(pols, num_pols, fl, family, dst_orig);
+        if (IS_ERR(new_xdst)) {
+                err = PTR_ERR(new_xdst);
+                if (err != -EAGAIN)
+                        goto error;
+                if (oldflo == NULL)
+                        goto make_dummy_bundle;
+                dst_hold(&xdst->u.dst);
+                return oldflo;
+        }
+
+        /* Kill the previous bundle */
+        if (xdst) {
+                /* The policies were stolen for newly generated bundle */
+                xdst->num_pols = 0;
+                dst_free(&xdst->u.dst);
+        }
+
+        /* Flow cache does not have reference, it dst_free()'s,
+         * but we do need to return one reference for original caller */
+        dst_hold(&new_xdst->u.dst);
+        return &new_xdst->flo;
+
+make_dummy_bundle:
+        /* We found policies, but there's no bundles to instantiate:
+         * either because the policy blocks, has no transformations or
+         * we could not build template (no xfrm_states).*/
+        xdst = xfrm_alloc_dst(net, family);
+        if (IS_ERR(xdst)) {
+                xfrm_pols_put(pols, num_pols);
+                return ERR_CAST(xdst);
+        }
+        xdst->num_pols = num_pols;
+        xdst->num_xfrms = num_xfrms;
+        memcpy(xdst->pols, pols, sizeof(struct xfrm_policy*) * num_pols);
+
+        dst_hold(&xdst->u.dst);
+        return &xdst->flo;
+
+inc_error:
+        XFRM_INC_STATS(net, LINUX_MIB_XFRMOUTPOLERROR);
+error:
+        if (xdst != NULL)
+                dst_free(&xdst->u.dst);
+        else
+                xfrm_pols_put(pols, num_pols);
+        return ERR_PTR(err);
+}
 
 /* Main function: finds/creates a bundle for given flow.
  *
@@ -1555,245 +1726,152 @@ static int stale_bundle(struct dst_entry *dst);
 int __xfrm_lookup(struct net *net, struct dst_entry **dst_p, struct flowi *fl,
                   struct sock *sk, int flags)
 {
-        struct xfrm_policy *policy;
         struct xfrm_policy *pols[XFRM_POLICY_TYPE_MAX];
-        int npols;
-        int pol_dead;
-        int xfrm_nr;
-        int pi;
-        struct xfrm_state *xfrm[XFRM_MAX_DEPTH];
-        struct dst_entry *dst, *dst_orig = *dst_p;
-        int nx = 0;
-        int err;
-        u32 genid;
-        u16 family;
+        struct flow_cache_object *flo;
+        struct xfrm_dst *xdst;
+        struct dst_entry *dst, *dst_orig = *dst_p, *route;
+        u16 family = dst_orig->ops->family;
         u8 dir = policy_to_flow_dir(XFRM_POLICY_OUT);
+        int i, err, num_pols, num_xfrms = 0, drop_pols = 0;
 
 restart:
-        genid = atomic_read(&flow_cache_genid);
-        policy = NULL;
-        for (pi = 0; pi < ARRAY_SIZE(pols); pi++)
-                pols[pi] = NULL;
-        npols = 0;
-        pol_dead = 0;
-        xfrm_nr = 0;
+        dst = NULL;
+        xdst = NULL;
+        route = NULL;
 
         if (sk && sk->sk_policy[XFRM_POLICY_OUT]) {
-                policy = xfrm_sk_policy_lookup(sk, XFRM_POLICY_OUT, fl);
-                err = PTR_ERR(policy);
-                if (IS_ERR(policy)) {
-                        XFRM_INC_STATS(net, LINUX_MIB_XFRMOUTPOLERROR);
+                num_pols = 1;
+                pols[0] = xfrm_sk_policy_lookup(sk, XFRM_POLICY_OUT, fl);
+                err = xfrm_expand_policies(fl, family, pols,
+                                           &num_pols, &num_xfrms);
+                if (err < 0)
                         goto dropdst;
+
+                if (num_pols) {
+                        if (num_xfrms <= 0) {
+                                drop_pols = num_pols;
+                                goto no_transform;
+                        }
+
+                        xdst = xfrm_resolve_and_create_bundle(
+                                        pols, num_pols, fl,
+                                        family, dst_orig);
+                        if (IS_ERR(xdst)) {
+                                xfrm_pols_put(pols, num_pols);
+                                err = PTR_ERR(xdst);
+                                goto dropdst;
+                        }
+
+                        spin_lock_bh(&xfrm_policy_sk_bundle_lock);
+                        xdst->u.dst.next = xfrm_policy_sk_bundles;
+                        xfrm_policy_sk_bundles = &xdst->u.dst;
+                        spin_unlock_bh(&xfrm_policy_sk_bundle_lock);
+
+                        route = xdst->route;
                 }
         }
 
-        if (!policy) {
+        if (xdst == NULL) {
                 /* To accelerate a bit...  */
                 if ((dst_orig->flags & DST_NOXFRM) ||
                     !net->xfrm.policy_count[XFRM_POLICY_OUT])
                         goto nopol;
 
-                policy = flow_cache_lookup(net, fl, dst_orig->ops->family,
-                                           dir, xfrm_policy_lookup);
-                err = PTR_ERR(policy);
-                if (IS_ERR(policy)) {
-                        XFRM_INC_STATS(net, LINUX_MIB_XFRMOUTPOLERROR);
+                flo = flow_cache_lookup(net, fl, family, dir,
+                                        xfrm_bundle_lookup, dst_orig);
+                if (flo == NULL)
+                        goto nopol;
+                if (IS_ERR(flo)) {
+                        err = PTR_ERR(flo);
                         goto dropdst;
                 }
+                xdst = container_of(flo, struct xfrm_dst, flo);
+
+                num_pols = xdst->num_pols;
+                num_xfrms = xdst->num_xfrms;
+                memcpy(pols, xdst->pols, sizeof(struct xfrm_policy*) * num_pols);
+                route = xdst->route;
+        }
+
+        dst = &xdst->u.dst;
+        if (route == NULL && num_xfrms > 0) {
+                /* The only case when xfrm_bundle_lookup() returns a
+                 * bundle with null route, is when the template could
+                 * not be resolved. It means policies are there, but
+                 * bundle could not be created, since we don't yet
+                 * have the xfrm_state's. We need to wait for KM to
+                 * negotiate new SA's or bail out with error.*/
+                if (net->xfrm.sysctl_larval_drop) {
+                        /* EREMOTE tells the caller to generate
+                         * a one-shot blackhole route. */
+                        dst_release(dst);
+                        xfrm_pols_put(pols, num_pols);
+                        XFRM_INC_STATS(net, LINUX_MIB_XFRMOUTNOSTATES);
+                        return -EREMOTE;
+                }
+                if (flags & XFRM_LOOKUP_WAIT) {
+                        DECLARE_WAITQUEUE(wait, current);
+
+                        add_wait_queue(&net->xfrm.km_waitq, &wait);
+                        set_current_state(TASK_INTERRUPTIBLE);
+                        schedule();
+                        set_current_state(TASK_RUNNING);
+                        remove_wait_queue(&net->xfrm.km_waitq, &wait);
+
+                        if (!signal_pending(current)) {
+                                dst_release(dst);
+                                goto restart;
+                        }
+
+                        err = -ERESTART;
+                } else
+                        err = -EAGAIN;
+
+                XFRM_INC_STATS(net, LINUX_MIB_XFRMOUTNOSTATES);
+                goto error;
         }
 
-        if (!policy)
+no_transform:
+        if (num_pols == 0)
                 goto nopol;
 
-        family = dst_orig->ops->family;
-        pols[0] = policy;
-        npols ++;
-        xfrm_nr += pols[0]->xfrm_nr;
-
-        err = -ENOENT;
-        if ((flags & XFRM_LOOKUP_ICMP) && !(policy->flags & XFRM_POLICY_ICMP))
+        if ((flags & XFRM_LOOKUP_ICMP) &&
+            !(pols[0]->flags & XFRM_POLICY_ICMP)) {
+                err = -ENOENT;
                 goto error;
+        }
 
-        policy->curlft.use_time = get_seconds();
+        for (i = 0; i < num_pols; i++)
+                pols[i]->curlft.use_time = get_seconds();
 
-        switch (policy->action) {
-        default:
-        case XFRM_POLICY_BLOCK:
+        if (num_xfrms < 0) {
                 /* Prohibit the flow */
                 XFRM_INC_STATS(net, LINUX_MIB_XFRMOUTPOLBLOCK);
                 err = -EPERM;
                 goto error;
-
-        case XFRM_POLICY_ALLOW:
-#ifndef CONFIG_XFRM_SUB_POLICY
-                if (policy->xfrm_nr == 0) {
-                        /* Flow passes not transformed. */
-                        xfrm_pol_put(policy);
-                        return 0;
-                }
-#endif
-
-                /* Try to find matching bundle.
-                 *
-                 * LATER: help from flow cache. It is optional, this
-                 * is required only for output policy.
-                 */
-                dst = xfrm_find_bundle(fl, policy, family);
-                if (IS_ERR(dst)) {
-                        XFRM_INC_STATS(net, LINUX_MIB_XFRMOUTBUNDLECHECKERROR);
-                        err = PTR_ERR(dst);
-                        goto error;
-                }
-
-                if (dst)
-                        break;
-
-#ifdef CONFIG_XFRM_SUB_POLICY
-                if (pols[0]->type != XFRM_POLICY_TYPE_MAIN) {
-                        pols[1] = xfrm_policy_lookup_bytype(net,
-                                                            XFRM_POLICY_TYPE_MAIN,
-                                                            fl, family,
-                                                            XFRM_POLICY_OUT);
-                        if (pols[1]) {
-                                if (IS_ERR(pols[1])) {
-                                        XFRM_INC_STATS(net, LINUX_MIB_XFRMOUTPOLERROR);
-                                        err = PTR_ERR(pols[1]);
-                                        goto error;
-                                }
-                                if (pols[1]->action == XFRM_POLICY_BLOCK) {
-                                        XFRM_INC_STATS(net, LINUX_MIB_XFRMOUTPOLBLOCK);
-                                        err = -EPERM;
-                                        goto error;
-                                }
-                                npols ++;
-                                xfrm_nr += pols[1]->xfrm_nr;
-                        }
-                }
-
-                /*
-                 * Because neither flowi nor bundle information knows about
-                 * transformation template size. On more than one policy usage
-                 * we can realize whether all of them is bypass or not after
-                 * they are searched. See above not-transformed bypass
-                 * is surrounded by non-sub policy configuration, too.
-                 */
-                if (xfrm_nr == 0) {
-                        /* Flow passes not transformed. */
-                        xfrm_pols_put(pols, npols);
-                        return 0;
-                }
-
-#endif
-                nx = xfrm_tmpl_resolve(pols, npols, fl, xfrm, family);
-
-                if (unlikely(nx<0)) {
-                        err = nx;
-                        if (err == -EAGAIN && net->xfrm.sysctl_larval_drop) {
-                                /* EREMOTE tells the caller to generate
-                                 * a one-shot blackhole route.
-                                 */
-                                XFRM_INC_STATS(net, LINUX_MIB_XFRMOUTNOSTATES);
-                                xfrm_pol_put(policy);
-                                return -EREMOTE;
-                        }
-                        if (err == -EAGAIN && (flags & XFRM_LOOKUP_WAIT)) {
-                                DECLARE_WAITQUEUE(wait, current);
-
-                                add_wait_queue(&net->xfrm.km_waitq, &wait);
-                                set_current_state(TASK_INTERRUPTIBLE);
-                                schedule();
-                                set_current_state(TASK_RUNNING);
-                                remove_wait_queue(&net->xfrm.km_waitq, &wait);
-
-                                nx = xfrm_tmpl_resolve(pols, npols, fl, xfrm, family);
-
-                                if (nx == -EAGAIN && signal_pending(current)) {
-                                        XFRM_INC_STATS(net, LINUX_MIB_XFRMOUTNOSTATES);
-                                        err = -ERESTART;
-                                        goto error;
-                                }
-                                if (nx == -EAGAIN ||
-                                    genid != atomic_read(&flow_cache_genid)) {
-                                        xfrm_pols_put(pols, npols);
-                                        goto restart;
-                                }
-                                err = nx;
-                        }
-                        if (err < 0) {
-                                XFRM_INC_STATS(net, LINUX_MIB_XFRMOUTNOSTATES);
-                                goto error;
-                        }
-                }
-                if (nx == 0) {
-                        /* Flow passes not transformed. */
-                        xfrm_pols_put(pols, npols);
-                        return 0;
-                }
-
-                dst = xfrm_bundle_create(policy, xfrm, nx, fl, dst_orig);
-                err = PTR_ERR(dst);
-                if (IS_ERR(dst)) {
-                        XFRM_INC_STATS(net, LINUX_MIB_XFRMOUTBUNDLEGENERROR);
-                        goto error;
-                }
-
-                for (pi = 0; pi < npols; pi++) {
-                        read_lock_bh(&pols[pi]->lock);
-                        pol_dead |= pols[pi]->walk.dead;
-                        read_unlock_bh(&pols[pi]->lock);
-                }
-
-                write_lock_bh(&policy->lock);
-                if (unlikely(pol_dead || stale_bundle(dst))) {
-                        /* Wow! While we worked on resolving, this
-                         * policy has gone. Retry. It is not paranoia,
-                         * we just cannot enlist new bundle to dead object.
-                         * We can't enlist stable bundles either.
-                         */
-                        write_unlock_bh(&policy->lock);
-                        dst_free(dst);
-
-                        if (pol_dead)
-                                XFRM_INC_STATS(net, LINUX_MIB_XFRMOUTPOLDEAD);
-                        else
-                                XFRM_INC_STATS(net, LINUX_MIB_XFRMOUTBUNDLECHECKERROR);
-                        err = -EHOSTUNREACH;
-                        goto error;
-                }
-
-                if (npols > 1)
-                        err = xfrm_dst_update_parent(dst, &pols[1]->selector);
-                else
-                        err = xfrm_dst_update_origin(dst, fl);
-                if (unlikely(err)) {
-                        write_unlock_bh(&policy->lock);
-                        dst_free(dst);
-                        XFRM_INC_STATS(net, LINUX_MIB_XFRMOUTBUNDLECHECKERROR);
-                        goto error;
-                }
-
-                dst->next = policy->bundles;
-                policy->bundles = dst;
-                dst_hold(dst);
-                write_unlock_bh(&policy->lock);
+        } else if (num_xfrms > 0) {
+                /* Flow transformed */
+                *dst_p = dst;
+                dst_release(dst_orig);
+        } else {
+                /* Flow passes untransformed */
+                dst_release(dst);
         }
-        *dst_p = dst;
-        dst_release(dst_orig);
-        xfrm_pols_put(pols, npols);
+ok:
+        xfrm_pols_put(pols, drop_pols);
         return 0;
 
+nopol:
+        if (!(flags & XFRM_LOOKUP_ICMP))
+                goto ok;
+        err = -ENOENT;
 error:
-        xfrm_pols_put(pols, npols);
+        dst_release(dst);
 dropdst:
         dst_release(dst_orig);
         *dst_p = NULL;
+        xfrm_pols_put(pols, drop_pols);
         return err;
-
-nopol:
-        err = -ENOENT;
-        if (flags & XFRM_LOOKUP_ICMP)
-                goto dropdst;
-        return 0;
 }
 EXPORT_SYMBOL(__xfrm_lookup);
 
@@ -1952,9 +2030,16 @@ int __xfrm_policy_check(struct sock *sk, int dir, struct sk_buff *skb,
                 }
         }
 
-        if (!pol)
-                pol = flow_cache_lookup(net, &fl, family, fl_dir,
-                                        xfrm_policy_lookup);
+        if (!pol) {
+                struct flow_cache_object *flo;
+
+                flo = flow_cache_lookup(net, &fl, family, fl_dir,
+                                        xfrm_policy_lookup, NULL);
+                if (IS_ERR_OR_NULL(flo))
+                        pol = ERR_CAST(flo);
+                else
+                        pol = container_of(flo, struct xfrm_policy, flo);
+        }
 
         if (IS_ERR(pol)) {
                 XFRM_INC_STATS(net, LINUX_MIB_XFRMINPOLERROR);
@@ -2138,71 +2223,24 @@ static struct dst_entry *xfrm_negative_advice(struct dst_entry *dst)
         return dst;
 }
 
-static void prune_one_bundle(struct xfrm_policy *pol, int (*func)(struct dst_entry *), struct dst_entry **gc_list_p)
-{
-        struct dst_entry *dst, **dstp;
-
-        write_lock(&pol->lock);
-        dstp = &pol->bundles;
-        while ((dst=*dstp) != NULL) {
-                if (func(dst)) {
-                        *dstp = dst->next;
-                        dst->next = *gc_list_p;
-                        *gc_list_p = dst;
-                } else {
-                        dstp = &dst->next;
-                }
-        }
-        write_unlock(&pol->lock);
-}
-
-static void xfrm_prune_bundles(struct net *net, int (*func)(struct dst_entry *))
+static void __xfrm_garbage_collect(struct net *net)
 {
-        struct dst_entry *gc_list = NULL;
-        int dir;
+        struct dst_entry *head, *next;
 
-        read_lock_bh(&xfrm_policy_lock);
-        for (dir = 0; dir < XFRM_POLICY_MAX * 2; dir++) {
-                struct xfrm_policy *pol;
-                struct hlist_node *entry;
-                struct hlist_head *table;
-                int i;
+        flow_cache_flush();
 
-                hlist_for_each_entry(pol, entry,
-                                     &net->xfrm.policy_inexact[dir], bydst)
-                        prune_one_bundle(pol, func, &gc_list);
+        spin_lock_bh(&xfrm_policy_sk_bundle_lock);
+        head = xfrm_policy_sk_bundles;
+        xfrm_policy_sk_bundles = NULL;
+        spin_unlock_bh(&xfrm_policy_sk_bundle_lock);
 
-                table = net->xfrm.policy_bydst[dir].table;
-                for (i = net->xfrm.policy_bydst[dir].hmask; i >= 0; i--) {
-                        hlist_for_each_entry(pol, entry, table + i, bydst)
-                                prune_one_bundle(pol, func, &gc_list);
-                }
-        }
-        read_unlock_bh(&xfrm_policy_lock);
-
-        while (gc_list) {
-                struct dst_entry *dst = gc_list;
-                gc_list = dst->next;
-                dst_free(dst);
+        while (head) {
+                next = head->next;
+                dst_free(head);
+                head = next;
         }
 }
 
-static int unused_bundle(struct dst_entry *dst)
-{
-        return !atomic_read(&dst->__refcnt);
-}
-
-static void __xfrm_garbage_collect(struct net *net)
-{
-        xfrm_prune_bundles(net, unused_bundle);
-}
-
-static int xfrm_flush_bundles(struct net *net)
-{
-        xfrm_prune_bundles(net, stale_bundle);
-        return 0;
-}
-
 static void xfrm_init_pmtu(struct dst_entry *dst)
 {
         do {
@@ -2260,7 +2298,9 @@ int xfrm_bundle_ok(struct xfrm_policy *pol, struct xfrm_dst *first,
                         return 0;
                 if (dst->xfrm->km.state != XFRM_STATE_VALID)
                         return 0;
-                if (xdst->genid != dst->xfrm->genid)
+                if (xdst->xfrm_genid != dst->xfrm->genid)
+                        return 0;
+                if (xdst->policy_genid != atomic_read(&xdst->pols[0]->genid))
                         return 0;
 
                 if (strict && fl &&
@@ -2425,7 +2465,7 @@ static int xfrm_dev_event(struct notifier_block *this, unsigned long event, void
 
         switch (event) {
         case NETDEV_DOWN:
-                xfrm_flush_bundles(dev_net(dev));
+                __xfrm_garbage_collect(dev_net(dev));
         }
         return NOTIFY_DONE;
 }
@@ -2531,7 +2571,6 @@ static void xfrm_policy_fini(struct net *net)
         audit_info.sessionid = -1;
         audit_info.secid = 0;
         xfrm_policy_flush(net, XFRM_POLICY_TYPE_MAIN, &audit_info);
-        flush_work(&xfrm_policy_gc_work);
 
         WARN_ON(!list_empty(&net->xfrm.policy_all));
 
@@ -2757,7 +2796,6 @@ static int xfrm_policy_migrate(struct xfrm_policy *pol,
                                struct xfrm_migrate *m, int num_migrate)
 {
         struct xfrm_migrate *mp;
-        struct dst_entry *dst;
         int i, j, n = 0;
 
         write_lock_bh(&pol->lock);
@@ -2782,10 +2820,7 @@ static int xfrm_policy_migrate(struct xfrm_policy *pol,
                                sizeof(pol->xfrm_vec[i].saddr));
                         pol->xfrm_vec[i].encap_family = mp->new_family;
                         /* flush bundles */
-                        while ((dst = pol->bundles) != NULL) {
-                                pol->bundles = dst->next;
-                                dst_free(dst);
-                        }
+                        atomic_inc(&pol->genid);
                 }
         }
 
diff --git a/net/xfrm/xfrm_state.c b/net/xfrm/xfrm_state.c
index 17d5b96f2fc8..5208b12fbfb4 100644
--- a/net/xfrm/xfrm_state.c
+++ b/net/xfrm/xfrm_state.c
@@ -22,6 +22,7 @@
 #include <linux/audit.h>
 #include <asm/uaccess.h>
 #include <linux/ktime.h>
+#include <linux/slab.h>
 #include <linux/interrupt.h>
 #include <linux/kernel.h>
 
@@ -37,7 +38,6 @@
 static DEFINE_SPINLOCK(xfrm_state_lock);
 
 static unsigned int xfrm_state_hashmax __read_mostly = 1 * 1024 * 1024;
-static unsigned int xfrm_state_genid;
 
 static struct xfrm_state_afinfo *xfrm_state_get_afinfo(unsigned int family);
 static void xfrm_state_put_afinfo(struct xfrm_state_afinfo *afinfo);
@@ -923,8 +923,6 @@ static void __xfrm_state_insert(struct xfrm_state *x)
         struct net *net = xs_net(x);
         unsigned int h;
 
-        x->genid = ++xfrm_state_genid;
-
         list_add(&x->km.all, &net->xfrm.state_all);
 
         h = xfrm_dst_hash(net, &x->id.daddr, &x->props.saddr,
@@ -970,7 +968,7 @@ static void __xfrm_state_bump_genids(struct xfrm_state *xnew)
                     (mark & x->mark.m) == x->mark.v &&
                     !xfrm_addr_cmp(&x->id.daddr, &xnew->id.daddr, family) &&
                     !xfrm_addr_cmp(&x->props.saddr, &xnew->props.saddr, family))
-                        x->genid = xfrm_state_genid;
+                        x->genid++;
         }
 }
 
diff --git a/net/xfrm/xfrm_sysctl.c b/net/xfrm/xfrm_sysctl.c
index 2c4d6cdcba49..05640bc9594b 100644
--- a/net/xfrm/xfrm_sysctl.c
+++ b/net/xfrm/xfrm_sysctl.c
@@ -1,4 +1,5 @@
 #include <linux/sysctl.h>
+#include <linux/slab.h>
 #include <net/net_namespace.h>
 #include <net/xfrm.h>
 
diff --git a/net/xfrm/xfrm_user.c b/net/xfrm/xfrm_user.c
index 6106b72826d3..a267fbdda525 100644
--- a/net/xfrm/xfrm_user.c
+++ b/net/xfrm/xfrm_user.c
@@ -1741,6 +1741,10 @@ static int xfrm_add_pol_expire(struct sk_buff *skb, struct nlmsghdr *nlh,
         if (err)
                 return err;
 
+        err = verify_policy_dir(p->dir);
+        if (err)
+                return err;
+
         if (p->index)
                 xp = xfrm_policy_byid(net, mark, type, p->dir, p->index, 0, &err);
         else {
@@ -1766,13 +1770,9 @@ static int xfrm_add_pol_expire(struct sk_buff *skb, struct nlmsghdr *nlh,
         if (xp == NULL)
                 return -ENOENT;
 
-        read_lock(&xp->lock);
-        if (xp->walk.dead) {
-                read_unlock(&xp->lock);
+        if (unlikely(xp->walk.dead))
                 goto out;
-        }
 
-        read_unlock(&xp->lock);
         err = 0;
         if (up->hard) {
                 uid_t loginuid = NETLINK_CB(skb).loginuid;