290 files changed, 14397 insertions, 6816 deletions

diff --git a/net/802/fddi.c b/net/802/fddi.c
index 539e6064e6d4..3ef0ab0a543a 100644
--- a/net/802/fddi.c
+++ b/net/802/fddi.c
@@ -185,10 +185,6 @@ static const struct header_ops fddi_header_ops = {
 static void fddi_setup(struct net_device *dev)
 {
         dev->header_ops         = &fddi_header_ops;
-#ifdef CONFIG_COMPAT_NET_DEV_OPS
-        dev->change_mtu         = fddi_change_mtu,
-#endif
-
         dev->type               = ARPHRD_FDDI;
         dev->hard_header_len    = FDDI_K_SNAP_HLEN+3;   /* Assume 802.2 SNAP hdr len + 3 pad bytes */
         dev->mtu                = FDDI_K_SNAP_DLEN;     /* Assume max payload of 802.2 SNAP frame */
diff --git a/net/802/hippi.c b/net/802/hippi.c
index 313b9ebf92ee..cd3e8e929529 100644
--- a/net/802/hippi.c
+++ b/net/802/hippi.c
@@ -193,11 +193,6 @@ static const struct header_ops hippi_header_ops = {
 
 static void hippi_setup(struct net_device *dev)
 {
-#ifdef CONFIG_COMPAT_NET_DEV_OPS
-        dev->change_mtu                 = hippi_change_mtu;
-        dev->set_mac_address            = hippi_mac_addr;
-        dev->neigh_setup                = hippi_neigh_setup_dev;
-#endif
         dev->header_ops                 = &hippi_header_ops;
 
         /*
diff --git a/net/8021q/vlan.c b/net/8021q/vlan.c
index d1e10546eb85..fe649081fbdc 100644
--- a/net/8021q/vlan.c
+++ b/net/8021q/vlan.c
@@ -378,13 +378,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, ETH_ALEN);
+                dev_unicast_delete(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, ETH_ALEN);
+                dev_unicast_add(dev, vlandev->dev_addr);
 
         memcpy(vlan->real_dev_addr, dev->dev_addr, ETH_ALEN);
 }
@@ -758,7 +758,7 @@ static void __exit vlan_cleanup_module(void)
                 BUG_ON(!hlist_empty(&vlan_group_hash[i]));
 
         unregister_pernet_gen_device(vlan_net_id, &vlan_net_ops);
-        synchronize_net();
+        rcu_barrier(); /* Wait for completion of call_rcu()'s */
 
         vlan_gvrp_uninit();
 }
diff --git a/net/8021q/vlan_core.c b/net/8021q/vlan_core.c
index c67fe6f75653..7f7de1a04de6 100644
--- a/net/8021q/vlan_core.c
+++ b/net/8021q/vlan_core.c
@@ -114,9 +114,9 @@ int vlan_gro_receive(struct napi_struct *napi, struct vlan_group *grp,
 EXPORT_SYMBOL(vlan_gro_receive);
 
 int vlan_gro_frags(struct napi_struct *napi, struct vlan_group *grp,
-                   unsigned int vlan_tci, struct napi_gro_fraginfo *info)
+                   unsigned int vlan_tci)
 {
-        struct sk_buff *skb = napi_fraginfo_skb(napi, info);
+        struct sk_buff *skb = napi_frags_skb(napi);
 
         if (!skb)
                 return NET_RX_DROP;
diff --git a/net/8021q/vlan_dev.c b/net/8021q/vlan_dev.c
index b4b9068e55a7..96bad8f233e2 100644
--- a/net/8021q/vlan_dev.c
+++ b/net/8021q/vlan_dev.c
@@ -290,7 +290,7 @@ static int vlan_dev_hard_header(struct sk_buff *skb, struct net_device *dev,
 
 static int vlan_dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
 {
-        struct net_device_stats *stats = &dev->stats;
+        struct netdev_queue *txq = netdev_get_tx_queue(dev, 0);
         struct vlan_ethhdr *veth = (struct vlan_ethhdr *)(skb->data);
 
         /* Handle non-VLAN frames if they are sent to us, for example by DHCP.
@@ -309,7 +309,7 @@ static int vlan_dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
                 vlan_tci |= vlan_dev_get_egress_qos_mask(dev, skb);
                 skb = __vlan_put_tag(skb, vlan_tci);
                 if (!skb) {
-                        stats->tx_dropped++;
+                        txq->tx_dropped++;
                         return NETDEV_TX_OK;
                 }
 
@@ -317,8 +317,8 @@ static int vlan_dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
                         vlan_dev_info(dev)->cnt_inc_headroom_on_tx++;
         }
 
-        stats->tx_packets++;
-        stats->tx_bytes += skb->len;
+        txq->tx_packets++;
+        txq->tx_bytes += skb->len;
 
         skb->dev = vlan_dev_info(dev)->real_dev;
         dev_queue_xmit(skb);
@@ -328,15 +328,15 @@ static int vlan_dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
 static int vlan_dev_hwaccel_hard_start_xmit(struct sk_buff *skb,
                                             struct net_device *dev)
 {
-        struct net_device_stats *stats = &dev->stats;
+        struct netdev_queue *txq = netdev_get_tx_queue(dev, 0);
         u16 vlan_tci;
 
         vlan_tci = vlan_dev_info(dev)->vlan_id;
         vlan_tci |= vlan_dev_get_egress_qos_mask(dev, skb);
         skb = __vlan_hwaccel_put_tag(skb, vlan_tci);
 
-        stats->tx_packets++;
-        stats->tx_bytes += skb->len;
+        txq->tx_packets++;
+        txq->tx_bytes += skb->len;
 
         skb->dev = vlan_dev_info(dev)->real_dev;
         dev_queue_xmit(skb);
@@ -441,7 +441,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, ETH_ALEN);
+                err = dev_unicast_add(real_dev, dev->dev_addr);
                 if (err < 0)
                         goto out;
         }
@@ -470,7 +470,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, ETH_ALEN);
+                dev_unicast_delete(real_dev, dev->dev_addr);
 out:
         netif_carrier_off(dev);
         return err;
@@ -492,7 +492,7 @@ static int vlan_dev_stop(struct net_device *dev)
                 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->addr_len);
+                dev_unicast_delete(real_dev, dev->dev_addr);
 
         netif_carrier_off(dev);
         return 0;
@@ -511,13 +511,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, ETH_ALEN);
+                err = dev_unicast_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, ETH_ALEN);
+                dev_unicast_delete(real_dev, dev->dev_addr);
 
 out:
         memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
@@ -644,7 +644,6 @@ static int vlan_dev_init(struct net_device *dev)
                 dev->hard_header_len = real_dev->hard_header_len + VLAN_HLEN;
                 dev->netdev_ops         = &vlan_netdev_ops;
         }
-        netdev_resync_ops(dev);
 
         if (is_vlan_dev(real_dev))
                 subclass = 1;
@@ -671,13 +670,7 @@ static int vlan_ethtool_get_settings(struct net_device *dev,
                                      struct ethtool_cmd *cmd)
 {
         const struct vlan_dev_info *vlan = vlan_dev_info(dev);
-        struct net_device *real_dev = vlan->real_dev;
-
-        if (!real_dev->ethtool_ops ||
-            !real_dev->ethtool_ops->get_settings)
-                return -EOPNOTSUPP;
-
-        return real_dev->ethtool_ops->get_settings(real_dev, cmd);
+        return dev_ethtool_get_settings(vlan->real_dev, cmd);
 }
 
 static void vlan_ethtool_get_drvinfo(struct net_device *dev,
@@ -691,24 +684,13 @@ static void vlan_ethtool_get_drvinfo(struct net_device *dev,
 static u32 vlan_ethtool_get_rx_csum(struct net_device *dev)
 {
         const struct vlan_dev_info *vlan = vlan_dev_info(dev);
-        struct net_device *real_dev = vlan->real_dev;
-
-        if (real_dev->ethtool_ops == NULL ||
-            real_dev->ethtool_ops->get_rx_csum == NULL)
-                return 0;
-        return real_dev->ethtool_ops->get_rx_csum(real_dev);
+        return dev_ethtool_get_rx_csum(vlan->real_dev);
 }
 
 static u32 vlan_ethtool_get_flags(struct net_device *dev)
 {
         const struct vlan_dev_info *vlan = vlan_dev_info(dev);
-        struct net_device *real_dev = vlan->real_dev;
-
-        if (!(real_dev->features & NETIF_F_HW_VLAN_RX) ||
-            real_dev->ethtool_ops == NULL ||
-            real_dev->ethtool_ops->get_flags == NULL)
-                return 0;
-        return real_dev->ethtool_ops->get_flags(real_dev);
+        return dev_ethtool_get_flags(vlan->real_dev);
 }
 
 static const struct ethtool_ops vlan_ethtool_ops = {
@@ -756,6 +738,7 @@ void vlan_setup(struct net_device *dev)
         ether_setup(dev);
 
         dev->priv_flags         |= IFF_802_1Q_VLAN;
+        dev->priv_flags         &= ~IFF_XMIT_DST_RELEASE;
         dev->tx_queue_len       = 0;
 
         dev->netdev_ops         = &vlan_netdev_ops;
diff --git a/net/8021q/vlanproc.c b/net/8021q/vlanproc.c
index 3628e0a81b40..b55a091a33df 100644
--- a/net/8021q/vlanproc.c
+++ b/net/8021q/vlanproc.c
@@ -279,13 +279,14 @@ static int vlandev_seq_show(struct seq_file *seq, void *offset)
 {
         struct net_device *vlandev = (struct net_device *) seq->private;
         const struct vlan_dev_info *dev_info = vlan_dev_info(vlandev);
-        struct net_device_stats *stats = &vlandev->stats;
+        const struct net_device_stats *stats;
         static const char fmt[] = "%30s %12lu\n";
         int i;
 
         if (!is_vlan_dev(vlandev))
                 return 0;
 
+        stats = dev_get_stats(vlandev);
         seq_printf(seq,
                    "%s  VID: %d  REORDER_HDR: %i  dev->priv_flags: %hx\n",
                    vlandev->name, dev_info->vlan_id,
diff --git a/net/9p/trans_virtio.c b/net/9p/trans_virtio.c
index bb8579a141a8..a49484e67e1d 100644
--- a/net/9p/trans_virtio.c
+++ b/net/9p/trans_virtio.c
@@ -246,7 +246,7 @@ static int p9_virtio_probe(struct virtio_device *vdev)
         chan->vdev = vdev;
 
         /* We expect one virtqueue, for requests. */
-        chan->vq = vdev->config->find_vq(vdev, 0, req_done);
+        chan->vq = virtio_find_single_vq(vdev, req_done, "requests");
         if (IS_ERR(chan->vq)) {
                 err = PTR_ERR(chan->vq);
                 goto out_free_vq;
@@ -261,7 +261,7 @@ static int p9_virtio_probe(struct virtio_device *vdev)
         return 0;
 
 out_free_vq:
-        vdev->config->del_vq(chan->vq);
+        vdev->config->del_vqs(vdev);
 fail:
         mutex_lock(&virtio_9p_lock);
         chan_index--;
@@ -332,7 +332,7 @@ static void p9_virtio_remove(struct virtio_device *vdev)
         BUG_ON(chan->inuse);
 
         if (chan->initialized) {
-                vdev->config->del_vq(chan->vq);
+                vdev->config->del_vqs(vdev);
                 chan->initialized = false;
         }
 }
diff --git a/net/Kconfig b/net/Kconfig
index c19f549c8e74..7051b9710675 100644
--- a/net/Kconfig
+++ b/net/Kconfig
@@ -179,6 +179,7 @@ source "net/lapb/Kconfig"
 source "net/econet/Kconfig"
 source "net/wanrouter/Kconfig"
 source "net/phonet/Kconfig"
+source "net/ieee802154/Kconfig"
 source "net/sched/Kconfig"
 source "net/dcb/Kconfig"
 
diff --git a/net/Makefile b/net/Makefile
index 9e00a55a901b..ba324aefda73 100644
--- a/net/Makefile
+++ b/net/Makefile
@@ -60,6 +60,7 @@ obj-$(CONFIG_NET_9P)		+= 9p/
 ifneq ($(CONFIG_DCB),)
 obj-y                           += dcb/
 endif
+obj-y                           += ieee802154/
 
 ifeq ($(CONFIG_NET),y)
 obj-$(CONFIG_SYSCTL)            += sysctl_net.o
diff --git a/net/appletalk/ddp.c b/net/appletalk/ddp.c
index d6a9243641af..b603cbacdc58 100644
--- a/net/appletalk/ddp.c
+++ b/net/appletalk/ddp.c
@@ -939,6 +939,7 @@ static unsigned long atalk_sum_skb(const struct sk_buff *skb, int offset,
                                    int len, unsigned long sum)
 {
         int start = skb_headlen(skb);
+        struct sk_buff *frag_iter;
         int i, copy;
 
         /* checksum stuff in header space */
@@ -977,26 +978,22 @@ static unsigned long atalk_sum_skb(const struct sk_buff *skb, int offset,
                 start = end;
         }
 
-        if (skb_shinfo(skb)->frag_list) {
-                struct sk_buff *list = skb_shinfo(skb)->frag_list;
-
-                for (; list; list = list->next) {
-                        int end;
+        skb_walk_frags(skb, frag_iter) {
+                int end;
 
-                        WARN_ON(start > offset + len);
+                WARN_ON(start > offset + len);
 
-                        end = start + list->len;
-                        if ((copy = end - offset) > 0) {
-                                if (copy > len)
-                                        copy = len;
-                                sum = atalk_sum_skb(list, offset - start,
-                                                    copy, sum);
-                                if ((len -= copy) == 0)
-                                        return sum;
-                                offset += copy;
-                        }
-                        start = end;
+                end = start + frag_iter->len;
+                if ((copy = end - offset) > 0) {
+                        if (copy > len)
+                                copy = len;
+                        sum = atalk_sum_skb(frag_iter, offset - start,
+                                            copy, sum);
+                        if ((len -= copy) == 0)
+                                return sum;
+                        offset += copy;
                 }
+                start = end;
         }
 
         BUG_ON(len > 0);
diff --git a/net/appletalk/dev.c b/net/appletalk/dev.c
index 72277d70c980..6c8016f61866 100644
--- a/net/appletalk/dev.c
+++ b/net/appletalk/dev.c
@@ -9,21 +9,10 @@
 #include <linux/if_arp.h>
 #include <linux/if_ltalk.h>
 
-#ifdef CONFIG_COMPAT_NET_DEV_OPS
-static int ltalk_change_mtu(struct net_device *dev, int mtu)
-{
-        return -EINVAL;
-}
-#endif
-
 static void ltalk_setup(struct net_device *dev)
 {
         /* Fill in the fields of the device structure with localtalk-generic values. */
 
-#ifdef CONFIG_COMPAT_NET_DEV_OPS
-        dev->change_mtu         = ltalk_change_mtu;
-#endif
-
         dev->type               = ARPHRD_LOCALTLK;
         dev->hard_header_len    = LTALK_HLEN;
         dev->mtu                = LTALK_MTU;
diff --git a/net/atm/br2684.c b/net/atm/br2684.c
index 3100a8940afc..2912665fc58c 100644
--- a/net/atm/br2684.c
+++ b/net/atm/br2684.c
@@ -228,7 +228,7 @@ static int br2684_start_xmit(struct sk_buff *skb, struct net_device *dev)
         struct br2684_dev *brdev = BRPRIV(dev);
         struct br2684_vcc *brvcc;
 
-        pr_debug("br2684_start_xmit, skb->dst=%p\n", skb->dst);
+        pr_debug("br2684_start_xmit, skb_dst(skb)=%p\n", skb_dst(skb));
         read_lock(&devs_lock);
         brvcc = pick_outgoing_vcc(skb, brdev);
         if (brvcc == NULL) {
@@ -445,9 +445,10 @@ free_skb:
  */
 static int br2684_regvcc(struct atm_vcc *atmvcc, void __user * arg)
 {
+        struct sk_buff_head queue;
         int err;
         struct br2684_vcc *brvcc;
-        struct sk_buff *skb;
+        struct sk_buff *skb, *tmp;
         struct sk_buff_head *rq;
         struct br2684_dev *brdev;
         struct net_device *net_dev;
@@ -505,29 +506,20 @@ static int br2684_regvcc(struct atm_vcc *atmvcc, void __user * arg)
         barrier();
         atmvcc->push = br2684_push;
 
+        __skb_queue_head_init(&queue);
         rq = &sk_atm(atmvcc)->sk_receive_queue;
 
         spin_lock_irqsave(&rq->lock, flags);
-        if (skb_queue_empty(rq)) {
-                skb = NULL;
-        } else {
-                /* NULL terminate the list.  */
-                rq->prev->next = NULL;
-                skb = rq->next;
-        }
-        rq->prev = rq->next = (struct sk_buff *)rq;
-        rq->qlen = 0;
+        skb_queue_splice_init(rq, &queue);
         spin_unlock_irqrestore(&rq->lock, flags);
 
-        while (skb) {
-                struct sk_buff *next = skb->next;
+        skb_queue_walk_safe(&queue, skb, tmp) {
+                struct net_device *dev = skb->dev;
 
-                skb->next = skb->prev = NULL;
-                br2684_push(atmvcc, skb);
-                skb->dev->stats.rx_bytes -= skb->len;
-                skb->dev->stats.rx_packets--;
+                dev->stats.rx_bytes -= skb->len;
+                dev->stats.rx_packets--;
 
-                skb = next;
+                br2684_push(atmvcc, skb);
         }
         __module_get(THIS_MODULE);
         return 0;
diff --git a/net/atm/clip.c b/net/atm/clip.c
index 3dc0a3a42a57..e65a3b1477f8 100644
--- a/net/atm/clip.c
+++ b/net/atm/clip.c
@@ -369,16 +369,16 @@ static int clip_start_xmit(struct sk_buff *skb, struct net_device *dev)
         unsigned long flags;
 
         pr_debug("clip_start_xmit (skb %p)\n", skb);
-        if (!skb->dst) {
-                printk(KERN_ERR "clip_start_xmit: skb->dst == NULL\n");
+        if (!skb_dst(skb)) {
+                printk(KERN_ERR "clip_start_xmit: skb_dst(skb) == NULL\n");
                 dev_kfree_skb(skb);
                 dev->stats.tx_dropped++;
                 return 0;
         }
-        if (!skb->dst->neighbour) {
+        if (!skb_dst(skb)->neighbour) {
 #if 0
-                skb->dst->neighbour = clip_find_neighbour(skb->dst, 1);
-                if (!skb->dst->neighbour) {
+                skb_dst(skb)->neighbour = clip_find_neighbour(skb_dst(skb), 1);
+                if (!skb_dst(skb)->neighbour) {
                         dev_kfree_skb(skb);     /* lost that one */
                         dev->stats.tx_dropped++;
                         return 0;
@@ -389,7 +389,7 @@ static int clip_start_xmit(struct sk_buff *skb, struct net_device *dev)
                 dev->stats.tx_dropped++;
                 return 0;
         }
-        entry = NEIGH2ENTRY(skb->dst->neighbour);
+        entry = NEIGH2ENTRY(skb_dst(skb)->neighbour);
         if (!entry->vccs) {
                 if (time_after(jiffies, entry->expires)) {
                         /* should be resolved */
@@ -406,7 +406,7 @@ static int clip_start_xmit(struct sk_buff *skb, struct net_device *dev)
         }
         pr_debug("neigh %p, vccs %p\n", entry, entry->vccs);
         ATM_SKB(skb)->vcc = vcc = entry->vccs->vcc;
-        pr_debug("using neighbour %p, vcc %p\n", skb->dst->neighbour, vcc);
+        pr_debug("using neighbour %p, vcc %p\n", skb_dst(skb)->neighbour, vcc);
         if (entry->vccs->encap) {
                 void *here;
 
@@ -445,9 +445,9 @@ static int clip_start_xmit(struct sk_buff *skb, struct net_device *dev)
 
 static int clip_mkip(struct atm_vcc *vcc, int timeout)
 {
+        struct sk_buff_head *rq, queue;
         struct clip_vcc *clip_vcc;
-        struct sk_buff *skb;
-        struct sk_buff_head *rq;
+        struct sk_buff *skb, *tmp;
         unsigned long flags;
 
         if (!vcc->push)
@@ -469,39 +469,28 @@ static int clip_mkip(struct atm_vcc *vcc, int timeout)
         vcc->push = clip_push;
         vcc->pop = clip_pop;
 
+        __skb_queue_head_init(&queue);
         rq = &sk_atm(vcc)->sk_receive_queue;
 
         spin_lock_irqsave(&rq->lock, flags);
-        if (skb_queue_empty(rq)) {
-                skb = NULL;
-        } else {
-                /* NULL terminate the list.  */
-                rq->prev->next = NULL;
-                skb = rq->next;
-        }
-        rq->prev = rq->next = (struct sk_buff *)rq;
-        rq->qlen = 0;
+        skb_queue_splice_init(rq, &queue);
         spin_unlock_irqrestore(&rq->lock, flags);
 
         /* re-process everything received between connection setup and MKIP */
-        while (skb) {
-                struct sk_buff *next = skb->next;
-
-                skb->next = skb->prev = NULL;
+        skb_queue_walk_safe(&queue, skb, tmp) {
                 if (!clip_devs) {
                         atm_return(vcc, skb->truesize);
                         kfree_skb(skb);
                 } else {
+                        struct net_device *dev = skb->dev;
                         unsigned int len = skb->len;
 
                         skb_get(skb);
                         clip_push(vcc, skb);
-                        skb->dev->stats.rx_packets--;
-                        skb->dev->stats.rx_bytes -= len;
+                        dev->stats.rx_packets--;
+                        dev->stats.rx_bytes -= len;
                         kfree_skb(skb);
                 }
-
-                skb = next;
         }
         return 0;
 }
@@ -568,6 +557,7 @@ static void clip_setup(struct net_device *dev)
         /* without any more elaborate queuing. 100 is a reasonable */
         /* compromise between decent burst-tolerance and protection */
         /* against memory hogs. */
+        dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
 }
 
 static int clip_create(int number)
diff --git a/net/atm/lec.c b/net/atm/lec.c
index 199b6bb79f42..ff2e594dca9b 100644
--- a/net/atm/lec.c
+++ b/net/atm/lec.c
@@ -34,7 +34,6 @@
 
 /* Proxy LEC knows about bridging */
 #if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
-#include <linux/if_bridge.h>
 #include "../bridge/br_private.h"
 
 static unsigned char bridge_ula_lec[] = { 0x01, 0x80, 0xc2, 0x00, 0x00 };
@@ -271,7 +270,8 @@ static int lec_start_xmit(struct sk_buff *skb, struct net_device *dev)
                 printk("%s:No lecd attached\n", dev->name);
                 dev->stats.tx_errors++;
                 netif_stop_queue(dev);
-                return -EUNATCH;
+                kfree_skb(skb);
+                return NETDEV_TX_OK;
         }
 
         pr_debug("skbuff head:%lx data:%lx tail:%lx end:%lx\n",
@@ -518,18 +518,14 @@ static int lec_atm_send(struct atm_vcc *vcc, struct sk_buff *skb)
         case l_should_bridge:
 #if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
                 {
-                        struct net_bridge_fdb_entry *f;
-
                         pr_debug("%s: bridge zeppelin asks about %pM\n",
                                  dev->name, mesg->content.proxy.mac_addr);
 
-                        if (br_fdb_get_hook == NULL || dev->br_port == NULL)
+                        if (br_fdb_test_addr_hook == NULL)
                                 break;
 
-                        f = br_fdb_get_hook(dev->br_port->br,
-                                            mesg->content.proxy.mac_addr);
-                        if (f != NULL && f->dst->dev != dev
-                            && f->dst->state == BR_STATE_FORWARDING) {
+                        if (br_fdb_test_addr_hook(dev,
+                                        mesg->content.proxy.mac_addr)) {
                                 /* hit from bridge table, send LE_ARP_RESPONSE */
                                 struct sk_buff *skb2;
                                 struct sock *sk;
@@ -540,10 +536,8 @@ static int lec_atm_send(struct atm_vcc *vcc, struct sk_buff *skb)
                                 skb2 =
                                     alloc_skb(sizeof(struct atmlec_msg),
                                               GFP_ATOMIC);
-                                if (skb2 == NULL) {
-                                        br_fdb_put_hook(f);
+                                if (skb2 == NULL)
                                         break;
-                                }
                                 skb2->len = sizeof(struct atmlec_msg);
                                 skb_copy_to_linear_data(skb2, mesg,
                                                         sizeof(*mesg));
@@ -552,8 +546,6 @@ static int lec_atm_send(struct atm_vcc *vcc, struct sk_buff *skb)
                                 skb_queue_tail(&sk->sk_receive_queue, skb2);
                                 sk->sk_data_ready(sk, skb2->len);
                         }
-                        if (f != NULL)
-                                br_fdb_put_hook(f);
                 }
 #endif /* defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE) */
                 break;
diff --git a/net/bluetooth/Kconfig b/net/bluetooth/Kconfig
index 7725da95a767..59fdb1d2e8ed 100644
--- a/net/bluetooth/Kconfig
+++ b/net/bluetooth/Kconfig
@@ -3,8 +3,9 @@
 #
 
 menuconfig BT
-        depends on NET && !S390
         tristate "Bluetooth subsystem support"
+        depends on NET && !S390
+        depends on RFKILL || !RFKILL
         help
           Bluetooth is low-cost, low-power, short-range wireless technology.
           It was designed as a replacement for cables and other short-range
diff --git a/net/bluetooth/cmtp/capi.c b/net/bluetooth/cmtp/capi.c
index 78958c0f9a40..97f8d68d574d 100644
--- a/net/bluetooth/cmtp/capi.c
+++ b/net/bluetooth/cmtp/capi.c
@@ -382,7 +382,7 @@ static void cmtp_reset_ctr(struct capi_ctr *ctrl)
 
         BT_DBG("ctrl %p", ctrl);
 
-        capi_ctr_reseted(ctrl);
+        capi_ctr_down(ctrl);
 
         atomic_inc(&session->terminate);
         cmtp_schedule(session);
diff --git a/net/bluetooth/hci_core.c b/net/bluetooth/hci_core.c
index cd061510b6bd..406ad07cdea1 100644
--- a/net/bluetooth/hci_core.c
+++ b/net/bluetooth/hci_core.c
@@ -39,6 +39,7 @@
 #include <linux/skbuff.h>
 #include <linux/interrupt.h>
 #include <linux/notifier.h>
+#include <linux/rfkill.h>
 #include <net/sock.h>
 
 #include <asm/system.h>
@@ -476,6 +477,11 @@ int hci_dev_open(__u16 dev)
 
         hci_req_lock(hdev);
 
+        if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) {
+                ret = -ERFKILL;
+                goto done;
+        }
+
         if (test_bit(HCI_UP, &hdev->flags)) {
                 ret = -EALREADY;
                 goto done;
@@ -813,6 +819,24 @@ int hci_get_dev_info(void __user *arg)
 
 /* ---- Interface to HCI drivers ---- */
 
+static int hci_rfkill_set_block(void *data, bool blocked)
+{
+        struct hci_dev *hdev = data;
+
+        BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked);
+
+        if (!blocked)
+                return 0;
+
+        hci_dev_do_close(hdev);
+
+        return 0;
+}
+
+static const struct rfkill_ops hci_rfkill_ops = {
+        .set_block = hci_rfkill_set_block,
+};
+
 /* Alloc HCI device */
 struct hci_dev *hci_alloc_dev(void)
 {
@@ -844,7 +868,8 @@ int hci_register_dev(struct hci_dev *hdev)
         struct list_head *head = &hci_dev_list, *p;
         int i, id = 0;
 
-        BT_DBG("%p name %s type %d owner %p", hdev, hdev->name, hdev->type, hdev->owner);
+        BT_DBG("%p name %s type %d owner %p", hdev, hdev->name,
+                                                hdev->type, hdev->owner);
 
         if (!hdev->open || !hdev->close || !hdev->destruct)
                 return -EINVAL;
@@ -900,6 +925,15 @@ int hci_register_dev(struct hci_dev *hdev)
 
         hci_register_sysfs(hdev);
 
+        hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev,
+                                RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops, hdev);
+        if (hdev->rfkill) {
+                if (rfkill_register(hdev->rfkill) < 0) {
+                        rfkill_destroy(hdev->rfkill);
+                        hdev->rfkill = NULL;
+                }
+        }
+
         hci_notify(hdev, HCI_DEV_REG);
 
         return id;
@@ -924,6 +958,11 @@ int hci_unregister_dev(struct hci_dev *hdev)
 
         hci_notify(hdev, HCI_DEV_UNREG);
 
+        if (hdev->rfkill) {
+                rfkill_unregister(hdev->rfkill);
+                rfkill_destroy(hdev->rfkill);
+        }
+
         hci_unregister_sysfs(hdev);
 
         __hci_dev_put(hdev);
diff --git a/net/bluetooth/l2cap.c b/net/bluetooth/l2cap.c
index ca4d3b40d5ce..bd0a4c1bced0 100644
--- a/net/bluetooth/l2cap.c
+++ b/net/bluetooth/l2cap.c
@@ -40,10 +40,10 @@
 #include <linux/skbuff.h>
 #include <linux/list.h>
 #include <linux/device.h>
+#include <linux/uaccess.h>
 #include <net/sock.h>
 
 #include <asm/system.h>
-#include <asm/uaccess.h>
 #include <asm/unaligned.h>
 
 #include <net/bluetooth/bluetooth.h>
@@ -52,7 +52,7 @@
 
 #define VERSION "2.13"
 
-static u32 l2cap_feat_mask = 0x0080;
+static u32 l2cap_feat_mask = L2CAP_FEAT_FIXED_CHAN;
 static u8 l2cap_fixed_chan[8] = { 0x02, };
 
 static const struct proto_ops l2cap_sock_ops;
@@ -134,7 +134,8 @@ static inline struct sock *l2cap_get_chan_by_scid(struct l2cap_chan_list *l, u16
         struct sock *s;
         read_lock(&l->lock);
         s = __l2cap_get_chan_by_scid(l, cid);
-        if (s) bh_lock_sock(s);
+        if (s)
+                bh_lock_sock(s);
         read_unlock(&l->lock);
         return s;
 }
@@ -154,17 +155,18 @@ static inline struct sock *l2cap_get_chan_by_ident(struct l2cap_chan_list *l, u8
         struct sock *s;
         read_lock(&l->lock);
         s = __l2cap_get_chan_by_ident(l, ident);
-        if (s) bh_lock_sock(s);
+        if (s)
+                bh_lock_sock(s);
         read_unlock(&l->lock);
         return s;
 }
 
 static u16 l2cap_alloc_cid(struct l2cap_chan_list *l)
 {
-        u16 cid = 0x0040;
+        u16 cid = L2CAP_CID_DYN_START;
 
-        for (; cid < 0xffff; cid++) {
-                if(!__l2cap_get_chan_by_scid(l, cid))
+        for (; cid < L2CAP_CID_DYN_END; cid++) {
+                if (!__l2cap_get_chan_by_scid(l, cid))
                         return cid;
         }
 
@@ -204,7 +206,8 @@ static void __l2cap_chan_add(struct l2cap_conn *conn, struct sock *sk, struct so
 {
         struct l2cap_chan_list *l = &conn->chan_list;
 
-        BT_DBG("conn %p, psm 0x%2.2x, dcid 0x%4.4x", conn, l2cap_pi(sk)->psm, l2cap_pi(sk)->dcid);
+        BT_DBG("conn %p, psm 0x%2.2x, dcid 0x%4.4x", conn,
+                        l2cap_pi(sk)->psm, l2cap_pi(sk)->dcid);
 
         conn->disc_reason = 0x13;
 
@@ -215,13 +218,13 @@ static void __l2cap_chan_add(struct l2cap_conn *conn, struct sock *sk, struct so
                 l2cap_pi(sk)->scid = l2cap_alloc_cid(l);
         } else if (sk->sk_type == SOCK_DGRAM) {
                 /* Connectionless socket */
-                l2cap_pi(sk)->scid = 0x0002;
-                l2cap_pi(sk)->dcid = 0x0002;
+                l2cap_pi(sk)->scid = L2CAP_CID_CONN_LESS;
+                l2cap_pi(sk)->dcid = L2CAP_CID_CONN_LESS;
                 l2cap_pi(sk)->omtu = L2CAP_DEFAULT_MTU;
         } else {
                 /* Raw socket can send/recv signalling messages only */
-                l2cap_pi(sk)->scid = 0x0001;
-                l2cap_pi(sk)->dcid = 0x0001;
+                l2cap_pi(sk)->scid = L2CAP_CID_SIGNALING;
+                l2cap_pi(sk)->dcid = L2CAP_CID_SIGNALING;
                 l2cap_pi(sk)->omtu = L2CAP_DEFAULT_MTU;
         }
 
@@ -272,7 +275,7 @@ static inline int l2cap_check_security(struct sock *sk)
                 if (l2cap_pi(sk)->sec_level == BT_SECURITY_HIGH)
                         auth_type = HCI_AT_NO_BONDING_MITM;
                 else
-                        auth_type = HCI_AT_NO_BONDING;
+                        auth_type = HCI_AT_NO_BONDING;
 
                 if (l2cap_pi(sk)->sec_level == BT_SECURITY_LOW)
                         l2cap_pi(sk)->sec_level = BT_SECURITY_SDP;
@@ -588,7 +591,8 @@ static inline struct sock *l2cap_get_sock_by_psm(int state, __le16 psm, bdaddr_t
         struct sock *s;
         read_lock(&l2cap_sk_list.lock);
         s = __l2cap_get_sock_by_psm(state, psm, src);
-        if (s) bh_lock_sock(s);
+        if (s)
+                bh_lock_sock(s);
         read_unlock(&l2cap_sk_list.lock);
         return s;
 }
@@ -808,7 +812,7 @@ static int l2cap_sock_bind(struct socket *sock, struct sockaddr *addr, int alen)
                 goto done;
         }
 
-        if (la.l2_psm && btohs(la.l2_psm) < 0x1001 &&
+        if (la.l2_psm && __le16_to_cpu(la.l2_psm) < 0x1001 &&
                                 !capable(CAP_NET_BIND_SERVICE)) {
                 err = -EACCES;
                 goto done;
@@ -825,7 +829,8 @@ static int l2cap_sock_bind(struct socket *sock, struct sockaddr *addr, int alen)
                 l2cap_pi(sk)->sport = la.l2_psm;
                 sk->sk_state = BT_BOUND;
 
-                if (btohs(la.l2_psm) == 0x0001 || btohs(la.l2_psm) == 0x0003)
+                if (__le16_to_cpu(la.l2_psm) == 0x0001 ||
+                                        __le16_to_cpu(la.l2_psm) == 0x0003)
                         l2cap_pi(sk)->sec_level = BT_SECURITY_SDP;
         }
 
@@ -844,12 +849,13 @@ static int l2cap_do_connect(struct sock *sk)
         struct hci_conn *hcon;
         struct hci_dev *hdev;
         __u8 auth_type;
-        int err = 0;
+        int err;
 
         BT_DBG("%s -> %s psm 0x%2.2x", batostr(src), batostr(dst),
                                                         l2cap_pi(sk)->psm);
 
-        if (!(hdev = hci_get_route(dst, src)))
+        hdev = hci_get_route(dst, src);
+        if (!hdev)
                 return -EHOSTUNREACH;
 
         hci_dev_lock_bh(hdev);
@@ -950,7 +956,7 @@ static int l2cap_sock_connect(struct socket *sock, struct sockaddr *addr, int al
                 goto done;
         }
 
-        switch(sk->sk_state) {
+        switch (sk->sk_state) {
         case BT_CONNECT:
         case BT_CONNECT2:
         case BT_CONFIG:
@@ -975,7 +981,8 @@ static int l2cap_sock_connect(struct socket *sock, struct sockaddr *addr, int al
         bacpy(&bt_sk(sk)->dst, &la.l2_bdaddr);
         l2cap_pi(sk)->psm = la.l2_psm;
 
-        if ((err = l2cap_do_connect(sk)))
+        err = l2cap_do_connect(sk);
+        if (err)
                 goto done;
 
 wait:
@@ -1009,9 +1016,9 @@ static int l2cap_sock_listen(struct socket *sock, int backlog)
                 write_lock_bh(&l2cap_sk_list.lock);
 
                 for (psm = 0x1001; psm < 0x1100; psm += 2)
-                        if (!__l2cap_get_sock_by_addr(htobs(psm), src)) {
-                                l2cap_pi(sk)->psm   = htobs(psm);
-                                l2cap_pi(sk)->sport = htobs(psm);
+                        if (!__l2cap_get_sock_by_addr(cpu_to_le16(psm), src)) {
+                                l2cap_pi(sk)->psm   = cpu_to_le16(psm);
+                                l2cap_pi(sk)->sport = cpu_to_le16(psm);
                                 err = 0;
                                 break;
                         }
@@ -1100,11 +1107,11 @@ static int l2cap_sock_getname(struct socket *sock, struct sockaddr *addr, int *l
         if (peer) {
                 la->l2_psm = l2cap_pi(sk)->psm;
                 bacpy(&la->l2_bdaddr, &bt_sk(sk)->dst);
-                la->l2_cid = htobs(l2cap_pi(sk)->dcid);
+                la->l2_cid = cpu_to_le16(l2cap_pi(sk)->dcid);
         } else {
                 la->l2_psm = l2cap_pi(sk)->sport;
                 bacpy(&la->l2_bdaddr, &bt_sk(sk)->src);
-                la->l2_cid = htobs(l2cap_pi(sk)->scid);
+                la->l2_cid = cpu_to_le16(l2cap_pi(sk)->scid);
         }
 
         return 0;
@@ -1114,7 +1121,7 @@ static inline int l2cap_do_send(struct sock *sk, struct msghdr *msg, int len)
 {
         struct l2cap_conn *conn = l2cap_pi(sk)->conn;
         struct sk_buff *skb, **frag;
-        int err, hlen, count, sent=0;
+        int err, hlen, count, sent = 0;
         struct l2cap_hdr *lh;
 
         BT_DBG("sk %p len %d", sk, len);
@@ -1167,8 +1174,8 @@ static inline int l2cap_do_send(struct sock *sk, struct msghdr *msg, int len)
 
                 frag = &(*frag)->next;
         }
-
-        if ((err = hci_send_acl(conn->hcon, skb, 0)) < 0)
+        err = hci_send_acl(conn->hcon, skb, 0);
+        if (err < 0)
                 goto fail;
 
         return sent;
@@ -1556,7 +1563,7 @@ static void l2cap_raw_recv(struct l2cap_conn *conn, struct sk_buff *skb)
 {
         struct l2cap_chan_list *l = &conn->chan_list;
         struct sk_buff *nskb;
-        struct sock * sk;
+        struct sock *sk;
 
         BT_DBG("conn %p", conn);
 
@@ -1568,8 +1575,8 @@ static void l2cap_raw_recv(struct l2cap_conn *conn, struct sk_buff *skb)
                 /* Don't send frame to the socket it came from */
                 if (skb->sk == sk)
                         continue;
-
-                if (!(nskb = skb_clone(skb, GFP_ATOMIC)))
+                nskb = skb_clone(skb, GFP_ATOMIC);
+                if (!nskb)
                         continue;
 
                 if (sock_queue_rcv_skb(sk, nskb))
@@ -1587,7 +1594,8 @@ static struct sk_buff *l2cap_build_cmd(struct l2cap_conn *conn,
         struct l2cap_hdr *lh;
         int len, count;
 
-        BT_DBG("conn %p, code 0x%2.2x, ident 0x%2.2x, len %d", conn, code, ident, dlen);
+        BT_DBG("conn %p, code 0x%2.2x, ident 0x%2.2x, len %d",
+                        conn, code, ident, dlen);
 
         len = L2CAP_HDR_SIZE + L2CAP_CMD_HDR_SIZE + dlen;
         count = min_t(unsigned int, conn->mtu, len);
@@ -1598,7 +1606,7 @@ static struct sk_buff *l2cap_build_cmd(struct l2cap_conn *conn,
 
         lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE);
         lh->len = cpu_to_le16(L2CAP_CMD_HDR_SIZE + dlen);
-        lh->cid = cpu_to_le16(0x0001);
+        lh->cid = cpu_to_le16(L2CAP_CID_SIGNALING);
 
         cmd = (struct l2cap_cmd_hdr *) skb_put(skb, L2CAP_CMD_HDR_SIZE);
         cmd->code  = code;
@@ -1739,8 +1747,8 @@ static int l2cap_parse_conf_req(struct sock *sk, void *data)
         while (len >= L2CAP_CONF_OPT_SIZE) {
                 len -= l2cap_get_conf_opt(&req, &type, &olen, &val);
 
-                hint  = type & 0x80;
-                type &= 0x7f;
+                hint  = type & L2CAP_CONF_HINT;
+                type &= L2CAP_CONF_MASK;
 
                 switch (type) {
                 case L2CAP_CONF_MTU:
@@ -1966,10 +1974,12 @@ static inline int l2cap_connect_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hd
         BT_DBG("dcid 0x%4.4x scid 0x%4.4x result 0x%2.2x status 0x%2.2x", dcid, scid, result, status);
 
         if (scid) {
-                if (!(sk = l2cap_get_chan_by_scid(&conn->chan_list, scid)))
+                sk = l2cap_get_chan_by_scid(&conn->chan_list, scid);
+                if (!sk)
                         return 0;
         } else {
-                if (!(sk = l2cap_get_chan_by_ident(&conn->chan_list, cmd->ident)))
+                sk = l2cap_get_chan_by_ident(&conn->chan_list, cmd->ident);
+                if (!sk)
                         return 0;
         }
 
@@ -2012,7 +2022,8 @@ static inline int l2cap_config_req(struct l2cap_conn *conn, struct l2cap_cmd_hdr
 
         BT_DBG("dcid 0x%4.4x flags 0x%2.2x", dcid, flags);
 
-        if (!(sk = l2cap_get_chan_by_scid(&conn->chan_list, dcid)))
+        sk = l2cap_get_chan_by_scid(&conn->chan_list, dcid);
+        if (!sk)
                 return -ENOENT;
 
         if (sk->sk_state == BT_DISCONN)
@@ -2079,9 +2090,11 @@ static inline int l2cap_config_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hdr
         flags  = __le16_to_cpu(rsp->flags);
         result = __le16_to_cpu(rsp->result);
 
-        BT_DBG("scid 0x%4.4x flags 0x%2.2x result 0x%2.2x", scid, flags, result);
+        BT_DBG("scid 0x%4.4x flags 0x%2.2x result 0x%2.2x",
+                        scid, flags, result);
 
-        if (!(sk = l2cap_get_chan_by_scid(&conn->chan_list, scid)))
+        sk = l2cap_get_chan_by_scid(&conn->chan_list, scid);
+        if (!sk)
                 return 0;
 
         switch (result) {
@@ -2142,7 +2155,8 @@ static inline int l2cap_disconnect_req(struct l2cap_conn *conn, struct l2cap_cmd
 
         BT_DBG("scid 0x%4.4x dcid 0x%4.4x", scid, dcid);
 
-        if (!(sk = l2cap_get_chan_by_scid(&conn->chan_list, dcid)))
+        sk = l2cap_get_chan_by_scid(&conn->chan_list, dcid);
+        if (!sk)
                 return 0;
 
         rsp.dcid = cpu_to_le16(l2cap_pi(sk)->scid);
@@ -2169,7 +2183,8 @@ static inline int l2cap_disconnect_rsp(struct l2cap_conn *conn, struct l2cap_cmd
 
         BT_DBG("dcid 0x%4.4x scid 0x%4.4x", dcid, scid);
 
-        if (!(sk = l2cap_get_chan_by_scid(&conn->chan_list, scid)))
+        sk = l2cap_get_chan_by_scid(&conn->chan_list, scid);
+        if (!sk)
                 return 0;
 
         l2cap_chan_del(sk, 0);
@@ -2230,7 +2245,7 @@ static inline int l2cap_information_rsp(struct l2cap_conn *conn, struct l2cap_cm
         if (type == L2CAP_IT_FEAT_MASK) {
                 conn->feat_mask = get_unaligned_le32(rsp->data);
 
-                if (conn->feat_mask & 0x0080) {
+                if (conn->feat_mask & L2CAP_FEAT_FIXED_CHAN) {
                         struct l2cap_info_req req;
                         req.type = cpu_to_le16(L2CAP_IT_FIXED_CHAN);
 
@@ -2403,7 +2418,8 @@ drop:
         kfree_skb(skb);
 
 done:
-        if (sk) bh_unlock_sock(sk);
+        if (sk)
+                bh_unlock_sock(sk);
         return 0;
 }
 
@@ -2420,11 +2436,11 @@ static void l2cap_recv_frame(struct l2cap_conn *conn, struct sk_buff *skb)
         BT_DBG("len %d, cid 0x%4.4x", len, cid);
 
         switch (cid) {
-        case 0x0001:
+        case L2CAP_CID_SIGNALING:
                 l2cap_sig_channel(conn, skb);
                 break;
 
-        case 0x0002:
+        case L2CAP_CID_CONN_LESS:
                 psm = get_unaligned((__le16 *) skb->data);
                 skb_pull(skb, 2);
                 l2cap_conless_channel(conn, psm, skb);
@@ -2650,7 +2666,8 @@ static int l2cap_recv_acldata(struct hci_conn *hcon, struct sk_buff *skb, u16 fl
                 }
 
                 /* Allocate skb for the complete frame (with header) */
-                if (!(conn->rx_skb = bt_skb_alloc(len, GFP_ATOMIC)))
+                conn->rx_skb = bt_skb_alloc(len, GFP_ATOMIC);
+                if (!conn->rx_skb)
                         goto drop;
 
                 skb_copy_from_linear_data(skb, skb_put(conn->rx_skb, skb->len),
@@ -2704,13 +2721,13 @@ static ssize_t l2cap_sysfs_show(struct class *dev, char *buf)
 
                 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, btohs(pi->psm), pi->scid, pi->dcid,
-                                pi->imtu, pi->omtu, pi->sec_level);
+                                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 str - buf;
 }
 
 static CLASS_ATTR(l2cap, S_IRUGO, l2cap_sysfs_show, NULL);
diff --git a/net/bluetooth/rfcomm/core.c b/net/bluetooth/rfcomm/core.c
index 374536e050aa..e50566ebf9f9 100644
--- a/net/bluetooth/rfcomm/core.c
+++ b/net/bluetooth/rfcomm/core.c
@@ -679,7 +679,7 @@ static struct rfcomm_session *rfcomm_session_create(bdaddr_t *src, bdaddr_t *dst
 
         bacpy(&addr.l2_bdaddr, dst);
         addr.l2_family = AF_BLUETOOTH;
-        addr.l2_psm    = htobs(RFCOMM_PSM);
+        addr.l2_psm    = cpu_to_le16(RFCOMM_PSM);
         addr.l2_cid    = 0;
         *err = kernel_connect(sock, (struct sockaddr *) &addr, sizeof(addr), O_NONBLOCK);
         if (*err == 0 || *err == -EINPROGRESS)
@@ -852,9 +852,9 @@ static int rfcomm_send_pn(struct rfcomm_session *s, int cr, struct rfcomm_dlc *d
         }
 
         if (cr && channel_mtu >= 0)
-                pn->mtu = htobs(channel_mtu);
+                pn->mtu = cpu_to_le16(channel_mtu);
         else
-                pn->mtu = htobs(d->mtu);
+                pn->mtu = cpu_to_le16(d->mtu);
 
         *ptr = __fcs(buf); ptr++;
 
@@ -1056,7 +1056,7 @@ static void rfcomm_make_uih(struct sk_buff *skb, u8 addr)
 
         if (len > 127) {
                 hdr = (void *) skb_push(skb, 4);
-                put_unaligned(htobs(__len16(len)), (__le16 *) &hdr->len);
+                put_unaligned(cpu_to_le16(__len16(len)), (__le16 *) &hdr->len);
         } else {
                 hdr = (void *) skb_push(skb, 3);
                 hdr->len = __len8(len);
@@ -1289,7 +1289,7 @@ static int rfcomm_apply_pn(struct rfcomm_dlc *d, int cr, struct rfcomm_pn *pn)
 
         d->priority = pn->priority;
 
-        d->mtu = btohs(pn->mtu);
+        d->mtu = __le16_to_cpu(pn->mtu);
 
         if (cr && d->mtu > s->mtu)
                 d->mtu = s->mtu;
@@ -1922,7 +1922,7 @@ static int rfcomm_add_listener(bdaddr_t *ba)
         /* Bind socket */
         bacpy(&addr.l2_bdaddr, ba);
         addr.l2_family = AF_BLUETOOTH;
-        addr.l2_psm    = htobs(RFCOMM_PSM);
+        addr.l2_psm    = cpu_to_le16(RFCOMM_PSM);
         addr.l2_cid    = 0;
         err = kernel_bind(sock, (struct sockaddr *) &addr, sizeof(addr));
         if (err < 0) {
diff --git a/net/bridge/br.c b/net/bridge/br.c
index 4d2c1f1cb524..9aac5213105a 100644
--- a/net/bridge/br.c
+++ b/net/bridge/br.c
@@ -65,8 +65,9 @@ static int __init br_init(void)
         brioctl_set(br_ioctl_deviceless_stub);
         br_handle_frame_hook = br_handle_frame;
 
-        br_fdb_get_hook = br_fdb_get;
-        br_fdb_put_hook = br_fdb_put;
+#if defined(CONFIG_ATM_LANE) || defined(CONFIG_ATM_LANE_MODULE)
+        br_fdb_test_addr_hook = br_fdb_test_addr;
+#endif
 
         return 0;
 err_out4:
@@ -95,8 +96,9 @@ static void __exit br_deinit(void)
         synchronize_net();
 
         br_netfilter_fini();
-        br_fdb_get_hook = NULL;
-        br_fdb_put_hook = NULL;
+#if defined(CONFIG_ATM_LANE) || defined(CONFIG_ATM_LANE_MODULE)
+        br_fdb_test_addr_hook = NULL;
+#endif
 
         br_handle_frame_hook = NULL;
         br_fdb_fini();
diff --git a/net/bridge/br_fdb.c b/net/bridge/br_fdb.c
index a48f5efdb6bf..57bf05c353bc 100644
--- a/net/bridge/br_fdb.c
+++ b/net/bridge/br_fdb.c
@@ -71,10 +71,17 @@ static inline int br_mac_hash(const unsigned char *mac)
         return jhash_1word(key, fdb_salt) & (BR_HASH_SIZE - 1);
 }
 
+static void fdb_rcu_free(struct rcu_head *head)
+{
+        struct net_bridge_fdb_entry *ent
+                = container_of(head, struct net_bridge_fdb_entry, rcu);
+        kmem_cache_free(br_fdb_cache, ent);
+}
+
 static inline void fdb_delete(struct net_bridge_fdb_entry *f)
 {
         hlist_del_rcu(&f->hlist);
-        br_fdb_put(f);
+        call_rcu(&f->rcu, fdb_rcu_free);
 }
 
 void br_fdb_changeaddr(struct net_bridge_port *p, const unsigned char *newaddr)
@@ -226,33 +233,26 @@ struct net_bridge_fdb_entry *__br_fdb_get(struct net_bridge *br,
         return NULL;
 }
 
-/* Interface used by ATM hook that keeps a ref count */
-struct net_bridge_fdb_entry *br_fdb_get(struct net_bridge *br,
-                                        unsigned char *addr)
+#if defined(CONFIG_ATM_LANE) || defined(CONFIG_ATM_LANE_MODULE)
+/* Interface used by ATM LANE hook to test
+ * if an addr is on some other bridge port */
+int br_fdb_test_addr(struct net_device *dev, unsigned char *addr)
 {
         struct net_bridge_fdb_entry *fdb;
+        int ret;
+
+        if (!dev->br_port)
+                return 0;
 
         rcu_read_lock();
-        fdb = __br_fdb_get(br, addr);
-        if (fdb && !atomic_inc_not_zero(&fdb->use_count))
-                fdb = NULL;
+        fdb = __br_fdb_get(dev->br_port->br, addr);
+        ret = fdb && fdb->dst->dev != dev &&
+                fdb->dst->state == BR_STATE_FORWARDING;
         rcu_read_unlock();
-        return fdb;
-}
-
-static void fdb_rcu_free(struct rcu_head *head)
-{
-        struct net_bridge_fdb_entry *ent
-                = container_of(head, struct net_bridge_fdb_entry, rcu);
-        kmem_cache_free(br_fdb_cache, ent);
-}
 
-/* Set entry up for deletion with RCU  */
-void br_fdb_put(struct net_bridge_fdb_entry *ent)
-{
-        if (atomic_dec_and_test(&ent->use_count))
-                call_rcu(&ent->rcu, fdb_rcu_free);
+        return ret;
 }
+#endif /* CONFIG_ATM_LANE */
 
 /*
  * Fill buffer with forwarding table records in
@@ -326,7 +326,6 @@ static struct net_bridge_fdb_entry *fdb_create(struct hlist_head *head,
         fdb = kmem_cache_alloc(br_fdb_cache, GFP_ATOMIC);
         if (fdb) {
                 memcpy(fdb->addr.addr, addr, ETH_ALEN);
-                atomic_set(&fdb->use_count, 1);
                 hlist_add_head_rcu(&fdb->hlist, head);
 
                 fdb->dst = source;
@@ -398,7 +397,7 @@ void br_fdb_update(struct net_bridge *br, struct net_bridge_port *source,
                 if (unlikely(fdb->is_local)) {
                         if (net_ratelimit())
                                 printk(KERN_WARNING "%s: received packet with "
-                                       " own address as source address\n",
+                                       "own address as source address\n",
                                        source->dev->name);
                 } else {
                         /* fastpath: update of existing entry */
diff --git a/net/bridge/br_netfilter.c b/net/bridge/br_netfilter.c
index e4a418fcb35b..d22f611e4004 100644
--- a/net/bridge/br_netfilter.c
+++ b/net/bridge/br_netfilter.c
@@ -228,6 +228,7 @@ int nf_bridge_copy_header(struct sk_buff *skb)
 static int br_nf_pre_routing_finish_ipv6(struct sk_buff *skb)
 {
         struct nf_bridge_info *nf_bridge = skb->nf_bridge;
+        struct rtable *rt;
 
         if (nf_bridge->mask & BRNF_PKT_TYPE) {
                 skb->pkt_type = PACKET_OTHERHOST;
@@ -235,12 +236,13 @@ static int br_nf_pre_routing_finish_ipv6(struct sk_buff *skb)
         }
         nf_bridge->mask ^= BRNF_NF_BRIDGE_PREROUTING;
 
-        skb->rtable = bridge_parent_rtable(nf_bridge->physindev);
-        if (!skb->rtable) {
+        rt = bridge_parent_rtable(nf_bridge->physindev);
+        if (!rt) {
                 kfree_skb(skb);
                 return 0;
         }
-        dst_hold(&skb->rtable->u.dst);
+        dst_hold(&rt->u.dst);
+        skb_dst_set(skb, &rt->u.dst);
 
         skb->dev = nf_bridge->physindev;
         nf_bridge_push_encap_header(skb);
@@ -320,7 +322,7 @@ static int br_nf_pre_routing_finish_bridge(struct sk_buff *skb)
 
         skb->dev = bridge_parent(skb->dev);
         if (skb->dev) {
-                struct dst_entry *dst = skb->dst;
+                struct dst_entry *dst = skb_dst(skb);
 
                 nf_bridge_pull_encap_header(skb);
 
@@ -338,6 +340,7 @@ static int br_nf_pre_routing_finish(struct sk_buff *skb)
         struct net_device *dev = skb->dev;
         struct iphdr *iph = ip_hdr(skb);
         struct nf_bridge_info *nf_bridge = skb->nf_bridge;
+        struct rtable *rt;
         int err;
 
         if (nf_bridge->mask & BRNF_PKT_TYPE) {
@@ -347,7 +350,6 @@ static int br_nf_pre_routing_finish(struct sk_buff *skb)
         nf_bridge->mask ^= BRNF_NF_BRIDGE_PREROUTING;
         if (dnat_took_place(skb)) {
                 if ((err = ip_route_input(skb, iph->daddr, iph->saddr, iph->tos, dev))) {
-                        struct rtable *rt;
                         struct flowi fl = {
                                 .nl_u = {
                                         .ip4_u = {
@@ -373,7 +375,7 @@ static int br_nf_pre_routing_finish(struct sk_buff *skb)
                                 /* - Bridged-and-DNAT'ed traffic doesn't
                                  *   require ip_forwarding. */
                                 if (((struct dst_entry *)rt)->dev == dev) {
-                                        skb->dst = (struct dst_entry *)rt;
+                                        skb_dst_set(skb, (struct dst_entry *)rt);
                                         goto bridged_dnat;
                                 }
                                 /* we are sure that forwarding is disabled, so printing
@@ -387,7 +389,7 @@ free_skb:
                         kfree_skb(skb);
                         return 0;
                 } else {
-                        if (skb->dst->dev == dev) {
+                        if (skb_dst(skb)->dev == dev) {
 bridged_dnat:
                                 /* Tell br_nf_local_out this is a
                                  * bridged frame */
@@ -404,12 +406,13 @@ bridged_dnat:
                         skb->pkt_type = PACKET_HOST;
                 }
         } else {
-                skb->rtable = bridge_parent_rtable(nf_bridge->physindev);
-                if (!skb->rtable) {
+                rt = bridge_parent_rtable(nf_bridge->physindev);
+                if (!rt) {
                         kfree_skb(skb);
                         return 0;
                 }
-                dst_hold(&skb->rtable->u.dst);
+                dst_hold(&rt->u.dst);
+                skb_dst_set(skb, &rt->u.dst);
         }
 
         skb->dev = nf_bridge->physindev;
@@ -628,10 +631,10 @@ static unsigned int br_nf_local_in(unsigned int hook, struct sk_buff *skb,
                                    const struct net_device *out,
                                    int (*okfn)(struct sk_buff *))
 {
-        if (skb->rtable && skb->rtable == bridge_parent_rtable(in)) {
-                dst_release(&skb->rtable->u.dst);
-                skb->rtable = NULL;
-        }
+        struct rtable *rt = skb_rtable(skb);
+
+        if (rt && rt == bridge_parent_rtable(in))
+                skb_dst_drop(skb);
 
         return NF_ACCEPT;
 }
@@ -846,7 +849,7 @@ static unsigned int br_nf_post_routing(unsigned int hook, struct sk_buff *skb,
                 return NF_ACCEPT;
 
 #ifdef CONFIG_NETFILTER_DEBUG
-        if (skb->dst == NULL) {
+        if (skb_dst(skb) == NULL) {
                 printk(KERN_INFO "br_netfilter post_routing: skb->dst == NULL\n");
                 goto print_error;
         }
diff --git a/net/bridge/br_private.h b/net/bridge/br_private.h
index b6c3b71974dc..d5b5537272b4 100644
--- a/net/bridge/br_private.h
+++ b/net/bridge/br_private.h
@@ -51,7 +51,6 @@ struct net_bridge_fdb_entry
         struct net_bridge_port          *dst;
 
         struct rcu_head                 rcu;
-        atomic_t                        use_count;
         unsigned long                   ageing_timer;
         mac_addr                        addr;
         unsigned char                   is_local;
@@ -154,9 +153,7 @@ extern void br_fdb_delete_by_port(struct net_bridge *br,
                                   const struct net_bridge_port *p, int do_all);
 extern struct net_bridge_fdb_entry *__br_fdb_get(struct net_bridge *br,
                                                  const unsigned char *addr);
-extern struct net_bridge_fdb_entry *br_fdb_get(struct net_bridge *br,
-                                               unsigned char *addr);
-extern void br_fdb_put(struct net_bridge_fdb_entry *ent);
+extern int br_fdb_test_addr(struct net_device *dev, unsigned char *addr);
 extern int br_fdb_fillbuf(struct net_bridge *br, void *buf,
                           unsigned long count, unsigned long off);
 extern int br_fdb_insert(struct net_bridge *br,
@@ -242,10 +239,9 @@ extern void br_stp_port_timer_init(struct net_bridge_port *p);
 extern unsigned long br_timer_value(const struct timer_list *timer);
 
 /* br.c */
-extern struct net_bridge_fdb_entry *(*br_fdb_get_hook)(struct net_bridge *br,
-                                                       unsigned char *addr);
-extern void (*br_fdb_put_hook)(struct net_bridge_fdb_entry *ent);
-
+#if defined(CONFIG_ATM_LANE) || defined(CONFIG_ATM_LANE_MODULE)
+extern int (*br_fdb_test_addr_hook)(struct net_device *dev, unsigned char *addr);
+#endif
 
 /* br_netlink.c */
 extern int br_netlink_init(void);
diff --git a/net/bridge/br_sysfs_br.c b/net/bridge/br_sysfs_br.c
index 603d89248e71..ee4820aa1843 100644
--- a/net/bridge/br_sysfs_br.c
+++ b/net/bridge/br_sysfs_br.c
@@ -172,7 +172,8 @@ static ssize_t store_stp_state(struct device *d,
         if (endp == buf)
                 return -EINVAL;
 
-        rtnl_lock();
+        if (!rtnl_trylock())
+                return restart_syscall();
         br_stp_set_enabled(br, val);
         rtnl_unlock();
 
diff --git a/net/bridge/br_sysfs_if.c b/net/bridge/br_sysfs_if.c
index 02b2d50cce4d..4a3cdf8f3813 100644
--- a/net/bridge/br_sysfs_if.c
+++ b/net/bridge/br_sysfs_if.c
@@ -189,7 +189,8 @@ static ssize_t brport_store(struct kobject * kobj,
 
         val = simple_strtoul(buf, &endp, 0);
         if (endp != buf) {
-                rtnl_lock();
+                if (!rtnl_trylock())
+                        return restart_syscall();
                 if (p->dev && p->br && brport_attr->store) {
                         spin_lock_bh(&p->br->lock);
                         ret = brport_attr->store(p, val);
diff --git a/net/bridge/netfilter/ebtables.c b/net/bridge/netfilter/ebtables.c
index 820252aee81f..37928d5f2840 100644
--- a/net/bridge/netfilter/ebtables.c
+++ b/net/bridge/netfilter/ebtables.c
@@ -142,6 +142,12 @@ static inline int ebt_basic_match(struct ebt_entry *e, struct ethhdr *h,
         return 0;
 }
 
+static inline __pure
+struct ebt_entry *ebt_next_entry(const struct ebt_entry *entry)
+{
+        return (void *)entry + entry->next_offset;
+}
+
 /* Do some firewalling */
 unsigned int ebt_do_table (unsigned int hook, struct sk_buff *skb,
    const struct net_device *in, const struct net_device *out,
@@ -164,7 +170,7 @@ unsigned int ebt_do_table (unsigned int hook, struct sk_buff *skb,
         mtpar.in      = tgpar.in  = in;
         mtpar.out     = tgpar.out = out;
         mtpar.hotdrop = &hotdrop;
-        tgpar.hooknum = hook;
+        mtpar.hooknum = tgpar.hooknum = hook;
 
         read_lock_bh(&table->lock);
         private = table->private;
@@ -249,8 +255,7 @@ letsreturn:
                 /* jump to a udc */
                 cs[sp].n = i + 1;
                 cs[sp].chaininfo = chaininfo;
-                cs[sp].e = (struct ebt_entry *)
-                   (((char *)point) + point->next_offset);
+                cs[sp].e = ebt_next_entry(point);
                 i = 0;
                 chaininfo = (struct ebt_entries *) (base + verdict);
 #ifdef CONFIG_NETFILTER_DEBUG
@@ -266,8 +271,7 @@ letsreturn:
                 sp++;
                 continue;
 letscontinue:
-                point = (struct ebt_entry *)
-                   (((char *)point) + point->next_offset);
+                point = ebt_next_entry(point);
                 i++;
         }
 
@@ -787,7 +791,7 @@ static int check_chainloops(struct ebt_entries *chain, struct ebt_cl_stack *cl_s
                         /* this can't be 0, so the loop test is correct */
                         cl_s[i].cs.n = pos + 1;
                         pos = 0;
-                        cl_s[i].cs.e = ((void *)e + e->next_offset);
+                        cl_s[i].cs.e = ebt_next_entry(e);
                         e = (struct ebt_entry *)(hlp2->data);
                         nentries = hlp2->nentries;
                         cl_s[i].from = chain_nr;
@@ -797,7 +801,7 @@ static int check_chainloops(struct ebt_entries *chain, struct ebt_cl_stack *cl_s
                         continue;
                 }
 letscontinue:
-                e = (void *)e + e->next_offset;
+                e = ebt_next_entry(e);
                 pos++;
         }
         return 0;
diff --git a/net/can/af_can.c b/net/can/af_can.c
index 10f0528c3bf5..e733725b11d4 100644
--- a/net/can/af_can.c
+++ b/net/can/af_can.c
@@ -903,6 +903,8 @@ static __exit void can_exit(void)
         }
         spin_unlock(&can_rcvlists_lock);
 
+        rcu_barrier(); /* Wait for completion of call_rcu()'s */
+
         kmem_cache_destroy(rcv_cache);
 }
 
diff --git a/net/core/datagram.c b/net/core/datagram.c
index b01a76abe1d2..58abee1f1df1 100644
--- a/net/core/datagram.c
+++ b/net/core/datagram.c
@@ -260,7 +260,9 @@ int skb_kill_datagram(struct sock *sk, struct sk_buff *skb, unsigned int flags)
                 spin_unlock_bh(&sk->sk_receive_queue.lock);
         }
 
-        skb_free_datagram(sk, skb);
+        kfree_skb(skb);
+        sk_mem_reclaim_partial(sk);
+
         return err;
 }
 
@@ -280,6 +282,7 @@ int skb_copy_datagram_iovec(const struct sk_buff *skb, int offset,
 {
         int start = skb_headlen(skb);
         int i, copy = start - offset;
+        struct sk_buff *frag_iter;
 
         /* Copy header. */
         if (copy > 0) {
@@ -320,28 +323,24 @@ int skb_copy_datagram_iovec(const struct sk_buff *skb, int offset,
                 start = end;
         }
 
-        if (skb_shinfo(skb)->frag_list) {
-                struct sk_buff *list = skb_shinfo(skb)->frag_list;
-
-                for (; list; list = list->next) {
-                        int end;
-
-                        WARN_ON(start > offset + len);
-
-                        end = start + list->len;
-                        if ((copy = end - offset) > 0) {
-                                if (copy > len)
-                                        copy = len;
-                                if (skb_copy_datagram_iovec(list,
-                                                            offset - start,
-                                                            to, copy))
-                                        goto fault;
-                                if ((len -= copy) == 0)
-                                        return 0;
-                                offset += copy;
-                        }
-                        start = end;
+        skb_walk_frags(skb, frag_iter) {
+                int end;
+
+                WARN_ON(start > offset + len);
+
+                end = start + frag_iter->len;
+                if ((copy = end - offset) > 0) {
+                        if (copy > len)
+                                copy = len;
+                        if (skb_copy_datagram_iovec(frag_iter,
+                                                    offset - start,
+                                                    to, copy))
+                                goto fault;
+                        if ((len -= copy) == 0)
+                                return 0;
+                        offset += copy;
                 }
+                start = end;
         }
         if (!len)
                 return 0;
@@ -351,30 +350,124 @@ fault:
 }
 
 /**
+ *      skb_copy_datagram_const_iovec - Copy a datagram to an iovec.
+ *      @skb: buffer to copy
+ *      @offset: offset in the buffer to start copying from
+ *      @to: io vector to copy to
+ *      @to_offset: offset in the io vector to start copying to
+ *      @len: amount of data to copy from buffer to iovec
+ *
+ *      Returns 0 or -EFAULT.
+ *      Note: the iovec is not modified during the copy.
+ */
+int skb_copy_datagram_const_iovec(const struct sk_buff *skb, int offset,
+                                  const struct iovec *to, int to_offset,
+                                  int len)
+{
+        int start = skb_headlen(skb);
+        int i, copy = start - offset;
+        struct sk_buff *frag_iter;
+
+        /* Copy header. */
+        if (copy > 0) {
+                if (copy > len)
+                        copy = len;
+                if (memcpy_toiovecend(to, skb->data + offset, to_offset, copy))
+                        goto fault;
+                if ((len -= copy) == 0)
+                        return 0;
+                offset += copy;
+                to_offset += copy;
+        }
+
+        /* Copy paged appendix. Hmm... why does this look so complicated? */
+        for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
+                int end;
+
+                WARN_ON(start > offset + len);
+
+                end = start + skb_shinfo(skb)->frags[i].size;
+                if ((copy = end - offset) > 0) {
+                        int err;
+                        u8  *vaddr;
+                        skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
+                        struct page *page = frag->page;
+
+                        if (copy > len)
+                                copy = len;
+                        vaddr = kmap(page);
+                        err = memcpy_toiovecend(to, vaddr + frag->page_offset +
+                                                offset - start, to_offset, copy);
+                        kunmap(page);
+                        if (err)
+                                goto fault;
+                        if (!(len -= copy))
+                                return 0;
+                        offset += copy;
+                        to_offset += copy;
+                }
+                start = end;
+        }
+
+        skb_walk_frags(skb, frag_iter) {
+                int end;
+
+                WARN_ON(start > offset + len);
+
+                end = start + frag_iter->len;
+                if ((copy = end - offset) > 0) {
+                        if (copy > len)
+                                copy = len;
+                        if (skb_copy_datagram_const_iovec(frag_iter,
+                                                          offset - start,
+                                                          to, to_offset,
+                                                          copy))
+                                goto fault;
+                        if ((len -= copy) == 0)
+                                return 0;
+                        offset += copy;
+                        to_offset += copy;
+                }
+                start = end;
+        }
+        if (!len)
+                return 0;
+
+fault:
+        return -EFAULT;
+}
+EXPORT_SYMBOL(skb_copy_datagram_const_iovec);
+
+/**
  *      skb_copy_datagram_from_iovec - Copy a datagram from an iovec.
  *      @skb: buffer to copy
  *      @offset: offset in the buffer to start copying to
  *      @from: io vector to copy to
+ *      @from_offset: offset in the io vector to start copying from
  *      @len: amount of data to copy to buffer from iovec
  *
  *      Returns 0 or -EFAULT.
- *      Note: the iovec is modified during the copy.
+ *      Note: the iovec is not modified during the copy.
  */
 int skb_copy_datagram_from_iovec(struct sk_buff *skb, int offset,
-                                 struct iovec *from, int len)
+                                 const struct iovec *from, int from_offset,
+                                 int len)
 {
         int start = skb_headlen(skb);
         int i, copy = start - offset;
+        struct sk_buff *frag_iter;
 
         /* Copy header. */
         if (copy > 0) {
                 if (copy > len)
                         copy = len;
-                if (memcpy_fromiovec(skb->data + offset, from, copy))
+                if (memcpy_fromiovecend(skb->data + offset, from, from_offset,
+                                        copy))
                         goto fault;
                 if ((len -= copy) == 0)
                         return 0;
                 offset += copy;
+                from_offset += copy;
         }
 
         /* Copy paged appendix. Hmm... why does this look so complicated? */
@@ -393,8 +486,9 @@ int skb_copy_datagram_from_iovec(struct sk_buff *skb, int offset,
                         if (copy > len)
                                 copy = len;
                         vaddr = kmap(page);
-                        err = memcpy_fromiovec(vaddr + frag->page_offset +
-                                               offset - start, from, copy);
+                        err = memcpy_fromiovecend(vaddr + frag->page_offset +
+                                                  offset - start,
+                                                  from, from_offset, copy);
                         kunmap(page);
                         if (err)
                                 goto fault;
@@ -402,32 +496,32 @@ int skb_copy_datagram_from_iovec(struct sk_buff *skb, int offset,
                         if (!(len -= copy))
                                 return 0;
                         offset += copy;
+                        from_offset += copy;
                 }
                 start = end;
         }
 
-        if (skb_shinfo(skb)->frag_list) {
-                struct sk_buff *list = skb_shinfo(skb)->frag_list;
-
-                for (; list; list = list->next) {
-                        int end;
-
-                        WARN_ON(start > offset + len);
-
-                        end = start + list->len;
-                        if ((copy = end - offset) > 0) {
-                                if (copy > len)
-                                        copy = len;
-                                if (skb_copy_datagram_from_iovec(list,
-                                                                 offset - start,
-                                                                 from, copy))
-                                        goto fault;
-                                if ((len -= copy) == 0)
-                                        return 0;
-                                offset += copy;
-                        }
-                        start = end;
+        skb_walk_frags(skb, frag_iter) {
+                int end;
+
+                WARN_ON(start > offset + len);
+
+                end = start + frag_iter->len;
+                if ((copy = end - offset) > 0) {
+                        if (copy > len)
+                                copy = len;
+                        if (skb_copy_datagram_from_iovec(frag_iter,
+                                                         offset - start,
+                                                         from,
+                                                         from_offset,
+                                                         copy))
+                                goto fault;
+                        if ((len -= copy) == 0)
+                                return 0;
+                        offset += copy;
+                        from_offset += copy;
                 }
+                start = end;
         }
         if (!len)
                 return 0;
@@ -442,8 +536,9 @@ static int skb_copy_and_csum_datagram(const struct sk_buff *skb, int offset,
                                       __wsum *csump)
 {
         int start = skb_headlen(skb);
-        int pos = 0;
         int i, copy = start - offset;
+        struct sk_buff *frag_iter;
+        int pos = 0;
 
         /* Copy header. */
         if (copy > 0) {
@@ -494,33 +589,29 @@ static int skb_copy_and_csum_datagram(const struct sk_buff *skb, int offset,
                 start = end;
         }
 
-        if (skb_shinfo(skb)->frag_list) {
-                struct sk_buff *list = skb_shinfo(skb)->frag_list;
-
-                for (; list; list=list->next) {
-                        int end;
-
-                        WARN_ON(start > offset + len);
-
-                        end = start + list->len;
-                        if ((copy = end - offset) > 0) {
-                                __wsum csum2 = 0;
-                                if (copy > len)
-                                        copy = len;
-                                if (skb_copy_and_csum_datagram(list,
-                                                               offset - start,
-                                                               to, copy,
-                                                               &csum2))
-                                        goto fault;
-                                *csump = csum_block_add(*csump, csum2, pos);
-                                if ((len -= copy) == 0)
-                                        return 0;
-                                offset += copy;
-                                to += copy;
-                                pos += copy;
-                        }
-                        start = end;
+        skb_walk_frags(skb, frag_iter) {
+                int end;
+
+                WARN_ON(start > offset + len);
+
+                end = start + frag_iter->len;
+                if ((copy = end - offset) > 0) {
+                        __wsum csum2 = 0;
+                        if (copy > len)
+                                copy = len;
+                        if (skb_copy_and_csum_datagram(frag_iter,
+                                                       offset - start,
+                                                       to, copy,
+                                                       &csum2))
+                                goto fault;
+                        *csump = csum_block_add(*csump, csum2, pos);
+                        if ((len -= copy) == 0)
+                                return 0;
+                        offset += copy;
+                        to += copy;
+                        pos += copy;
                 }
+                start = end;
         }
         if (!len)
                 return 0;
diff --git a/net/core/dev.c b/net/core/dev.c
index e2e9e4af3ace..576a61574a93 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -126,6 +126,7 @@
 #include <linux/in.h>
 #include <linux/jhash.h>
 #include <linux/random.h>
+#include <trace/events/napi.h>
 
 #include "net-sysfs.h"
 
@@ -268,7 +269,8 @@ static const unsigned short netdev_lock_type[] =
          ARPHRD_IRDA, ARPHRD_FCPP, ARPHRD_FCAL, ARPHRD_FCPL,
          ARPHRD_FCFABRIC, ARPHRD_IEEE802_TR, ARPHRD_IEEE80211,
          ARPHRD_IEEE80211_PRISM, ARPHRD_IEEE80211_RADIOTAP, ARPHRD_PHONET,
-         ARPHRD_PHONET_PIPE, ARPHRD_VOID, ARPHRD_NONE};
+         ARPHRD_PHONET_PIPE, ARPHRD_IEEE802154, ARPHRD_IEEE802154_PHY,
+         ARPHRD_VOID, ARPHRD_NONE};
 
 static const char *netdev_lock_name[] =
         {"_xmit_NETROM", "_xmit_ETHER", "_xmit_EETHER", "_xmit_AX25",
@@ -285,7 +287,8 @@ static const char *netdev_lock_name[] =
          "_xmit_IRDA", "_xmit_FCPP", "_xmit_FCAL", "_xmit_FCPL",
          "_xmit_FCFABRIC", "_xmit_IEEE802_TR", "_xmit_IEEE80211",
          "_xmit_IEEE80211_PRISM", "_xmit_IEEE80211_RADIOTAP", "_xmit_PHONET",
-         "_xmit_PHONET_PIPE", "_xmit_VOID", "_xmit_NONE"};
+         "_xmit_PHONET_PIPE", "_xmit_IEEE802154", "_xmit_IEEE802154_PHY",
+         "_xmit_VOID", "_xmit_NONE"};
 
 static struct lock_class_key netdev_xmit_lock_key[ARRAY_SIZE(netdev_lock_type)];
 static struct lock_class_key netdev_addr_lock_key[ARRAY_SIZE(netdev_lock_type)];
@@ -1047,7 +1050,7 @@ void dev_load(struct net *net, const char *name)
 int dev_open(struct net_device *dev)
 {
         const struct net_device_ops *ops = dev->netdev_ops;
-        int ret = 0;
+        int ret;
 
         ASSERT_RTNL();
 
@@ -1064,6 +1067,11 @@ int dev_open(struct net_device *dev)
         if (!netif_device_present(dev))
                 return -ENODEV;
 
+        ret = call_netdevice_notifiers(NETDEV_PRE_UP, dev);
+        ret = notifier_to_errno(ret);
+        if (ret)
+                return ret;
+
         /*
          *      Call device private open method
          */
@@ -1688,7 +1696,16 @@ int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev,
                                 goto gso;
                 }
 
+                /*
+                 * If device doesnt need skb->dst, release it right now while
+                 * its hot in this cpu cache
+                 */
+                if (dev->priv_flags & IFF_XMIT_DST_RELEASE)
+                        skb_dst_drop(skb);
+
                 rc = ops->ndo_start_xmit(skb, dev);
+                if (rc == 0)
+                        txq_trans_update(txq);
                 /*
                  * TODO: if skb_orphan() was called by
                  * dev->hard_start_xmit() (for example, the unmodified
@@ -1718,6 +1735,7 @@ gso:
                         skb->next = nskb;
                         return rc;
                 }
+                txq_trans_update(txq);
                 if (unlikely(netif_tx_queue_stopped(txq) && skb->next))
                         return NETDEV_TX_BUSY;
         } while (skb->next);
@@ -1735,8 +1753,12 @@ u16 skb_tx_hash(const struct net_device *dev, const struct sk_buff *skb)
 {
         u32 hash;
 
-        if (skb_rx_queue_recorded(skb))
-                return skb_get_rx_queue(skb) % dev->real_num_tx_queues;
+        if (skb_rx_queue_recorded(skb)) {
+                hash = skb_get_rx_queue(skb);
+                while (unlikely (hash >= dev->real_num_tx_queues))
+                        hash -= dev->real_num_tx_queues;
+                return hash;
+        }
 
         if (skb->sk && skb->sk->sk_hash)
                 hash = skb->sk->sk_hash;
@@ -1800,7 +1822,7 @@ int dev_queue_xmit(struct sk_buff *skb)
         if (netif_needs_gso(dev, skb))
                 goto gso;
 
-        if (skb_shinfo(skb)->frag_list &&
+        if (skb_has_frags(skb) &&
             !(dev->features & NETIF_F_FRAGLIST) &&
             __skb_linearize(skb))
                 goto out_kfree_skb;
@@ -2049,11 +2071,13 @@ static inline int deliver_skb(struct sk_buff *skb,
 }
 
 #if defined(CONFIG_BRIDGE) || defined (CONFIG_BRIDGE_MODULE)
-/* These hooks defined here for ATM */
-struct net_bridge;
-struct net_bridge_fdb_entry *(*br_fdb_get_hook)(struct net_bridge *br,
-                                                unsigned char *addr);
-void (*br_fdb_put_hook)(struct net_bridge_fdb_entry *ent) __read_mostly;
+
+#if defined(CONFIG_ATM_LANE) || defined(CONFIG_ATM_LANE_MODULE)
+/* This hook is defined here for ATM LANE */
+int (*br_fdb_test_addr_hook)(struct net_device *dev,
+                             unsigned char *addr) __read_mostly;
+EXPORT_SYMBOL(br_fdb_test_addr_hook);
+#endif
 
 /*
  * If bridge module is loaded call bridging hook.
@@ -2061,6 +2085,8 @@ void (*br_fdb_put_hook)(struct net_bridge_fdb_entry *ent) __read_mostly;
  */
 struct sk_buff *(*br_handle_frame_hook)(struct net_bridge_port *p,
                                         struct sk_buff *skb) __read_mostly;
+EXPORT_SYMBOL(br_handle_frame_hook);
+
 static inline struct sk_buff *handle_bridge(struct sk_buff *skb,
                                             struct packet_type **pt_prev, int *ret,
                                             struct net_device *orig_dev)
@@ -2374,26 +2400,6 @@ void napi_gro_flush(struct napi_struct *napi)
 }
 EXPORT_SYMBOL(napi_gro_flush);
 
-void *skb_gro_header(struct sk_buff *skb, unsigned int hlen)
-{
-        unsigned int offset = skb_gro_offset(skb);
-
-        hlen += offset;
-        if (hlen <= skb_headlen(skb))
-                return skb->data + offset;
-
-        if (unlikely(!skb_shinfo(skb)->nr_frags ||
-                     skb_shinfo(skb)->frags[0].size <=
-                     hlen - skb_headlen(skb) ||
-                     PageHighMem(skb_shinfo(skb)->frags[0].page)))
-                return pskb_may_pull(skb, hlen) ? skb->data + offset : NULL;
-
-        return page_address(skb_shinfo(skb)->frags[0].page) +
-               skb_shinfo(skb)->frags[0].page_offset +
-               offset - skb_headlen(skb);
-}
-EXPORT_SYMBOL(skb_gro_header);
-
 int dev_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
 {
         struct sk_buff **pp = NULL;
@@ -2407,7 +2413,7 @@ int dev_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
         if (!(skb->dev->features & NETIF_F_GRO))
                 goto normal;
 
-        if (skb_is_gso(skb) || skb_shinfo(skb)->frag_list)
+        if (skb_is_gso(skb) || skb_has_frags(skb))
                 goto normal;
 
         rcu_read_lock();
@@ -2456,10 +2462,25 @@ int dev_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
         ret = GRO_HELD;
 
 pull:
-        if (unlikely(!pskb_may_pull(skb, skb_gro_offset(skb)))) {
-                if (napi->gro_list == skb)
-                        napi->gro_list = skb->next;
-                ret = GRO_DROP;
+        if (skb_headlen(skb) < skb_gro_offset(skb)) {
+                int grow = skb_gro_offset(skb) - skb_headlen(skb);
+
+                BUG_ON(skb->end - skb->tail < grow);
+
+                memcpy(skb_tail_pointer(skb), NAPI_GRO_CB(skb)->frag0, grow);
+
+                skb->tail += grow;
+                skb->data_len -= grow;
+
+                skb_shinfo(skb)->frags[0].page_offset += grow;
+                skb_shinfo(skb)->frags[0].size -= grow;
+
+                if (unlikely(!skb_shinfo(skb)->frags[0].size)) {
+                        put_page(skb_shinfo(skb)->frags[0].page);
+                        memmove(skb_shinfo(skb)->frags,
+                                skb_shinfo(skb)->frags + 1,
+                                --skb_shinfo(skb)->nr_frags);
+                }
         }
 
 ok:
@@ -2509,6 +2530,22 @@ int napi_skb_finish(int ret, struct sk_buff *skb)
 }
 EXPORT_SYMBOL(napi_skb_finish);
 
+void skb_gro_reset_offset(struct sk_buff *skb)
+{
+        NAPI_GRO_CB(skb)->data_offset = 0;
+        NAPI_GRO_CB(skb)->frag0 = NULL;
+        NAPI_GRO_CB(skb)->frag0_len = 0;
+
+        if (skb->mac_header == skb->tail &&
+            !PageHighMem(skb_shinfo(skb)->frags[0].page)) {
+                NAPI_GRO_CB(skb)->frag0 =
+                        page_address(skb_shinfo(skb)->frags[0].page) +
+                        skb_shinfo(skb)->frags[0].page_offset;
+                NAPI_GRO_CB(skb)->frag0_len = skb_shinfo(skb)->frags[0].size;
+        }
+}
+EXPORT_SYMBOL(skb_gro_reset_offset);
+
 int napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
 {
         skb_gro_reset_offset(skb);
@@ -2526,16 +2563,10 @@ void napi_reuse_skb(struct napi_struct *napi, struct sk_buff *skb)
 }
 EXPORT_SYMBOL(napi_reuse_skb);
 
-struct sk_buff *napi_fraginfo_skb(struct napi_struct *napi,
-                                  struct napi_gro_fraginfo *info)
+struct sk_buff *napi_get_frags(struct napi_struct *napi)
 {
         struct net_device *dev = napi->dev;
         struct sk_buff *skb = napi->skb;
-        struct ethhdr *eth;
-        skb_frag_t *frag;
-        int i;
-
-        napi->skb = NULL;
 
         if (!skb) {
                 skb = netdev_alloc_skb(dev, GRO_MAX_HEAD + NET_IP_ALIGN);
@@ -2543,47 +2574,14 @@ struct sk_buff *napi_fraginfo_skb(struct napi_struct *napi,
                         goto out;
 
                 skb_reserve(skb, NET_IP_ALIGN);
-        }
 
-        BUG_ON(info->nr_frags > MAX_SKB_FRAGS);
-        frag = info->frags;
-
-        for (i = 0; i < info->nr_frags; i++) {
-                skb_fill_page_desc(skb, i, frag->page, frag->page_offset,
-                                   frag->size);
-                frag++;
-        }
-        skb_shinfo(skb)->nr_frags = info->nr_frags;
-
-        skb->data_len = info->len;
-        skb->len += info->len;
-        skb->truesize += info->len;
-
-        skb_reset_mac_header(skb);
-        skb_gro_reset_offset(skb);
-
-        eth = skb_gro_header(skb, sizeof(*eth));
-        if (!eth) {
-                napi_reuse_skb(napi, skb);
-                skb = NULL;
-                goto out;
+                napi->skb = skb;
         }
 
-        skb_gro_pull(skb, sizeof(*eth));
-
-        /*
-         * This works because the only protocols we care about don't require
-         * special handling.  We'll fix it up properly at the end.
-         */
-        skb->protocol = eth->h_proto;
-
-        skb->ip_summed = info->ip_summed;
-        skb->csum = info->csum;
-
 out:
         return skb;
 }
-EXPORT_SYMBOL(napi_fraginfo_skb);
+EXPORT_SYMBOL(napi_get_frags);
 
 int napi_frags_finish(struct napi_struct *napi, struct sk_buff *skb, int ret)
 {
@@ -2613,9 +2611,46 @@ int napi_frags_finish(struct napi_struct *napi, struct sk_buff *skb, int ret)
 }
 EXPORT_SYMBOL(napi_frags_finish);
 
-int napi_gro_frags(struct napi_struct *napi, struct napi_gro_fraginfo *info)
+struct sk_buff *napi_frags_skb(struct napi_struct *napi)
 {
-        struct sk_buff *skb = napi_fraginfo_skb(napi, info);
+        struct sk_buff *skb = napi->skb;
+        struct ethhdr *eth;
+        unsigned int hlen;
+        unsigned int off;
+
+        napi->skb = NULL;
+
+        skb_reset_mac_header(skb);
+        skb_gro_reset_offset(skb);
+
+        off = skb_gro_offset(skb);
+        hlen = off + sizeof(*eth);
+        eth = skb_gro_header_fast(skb, off);
+        if (skb_gro_header_hard(skb, hlen)) {
+                eth = skb_gro_header_slow(skb, hlen, off);
+                if (unlikely(!eth)) {
+                        napi_reuse_skb(napi, skb);
+                        skb = NULL;
+                        goto out;
+                }
+        }
+
+        skb_gro_pull(skb, sizeof(*eth));
+
+        /*
+         * This works because the only protocols we care about don't require
+         * special handling.  We'll fix it up properly at the end.
+         */
+        skb->protocol = eth->h_proto;
+
+out:
+        return skb;
+}
+EXPORT_SYMBOL(napi_frags_skb);
+
+int napi_gro_frags(struct napi_struct *napi)
+{
+        struct sk_buff *skb = napi_frags_skb(napi);
 
         if (!skb)
                 return NET_RX_DROP;
@@ -2719,7 +2754,7 @@ void netif_napi_del(struct napi_struct *napi)
         struct sk_buff *skb, *next;
 
         list_del_init(&napi->dev_list);
-        kfree_skb(napi->skb);
+        napi_free_frags(napi);
 
         for (skb = napi->gro_list; skb; skb = next) {
                 next = skb->next;
@@ -2773,8 +2808,10 @@ static void net_rx_action(struct softirq_action *h)
                  * accidently calling ->poll() when NAPI is not scheduled.
                  */
                 work = 0;
-                if (test_bit(NAPI_STATE_SCHED, &n->state))
+                if (test_bit(NAPI_STATE_SCHED, &n->state)) {
                         work = n->poll(n, weight);
+                        trace_napi_poll(n);
+                }
 
                 WARN_ON_ONCE(work > weight);
 
@@ -3444,6 +3481,319 @@ 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 list_head *list, int *delta,
+                         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) {
+                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);
+        if (delta)
+                (*delta)++;
+        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 list_head *list, int *delta,
+                         unsigned char *addr, int addr_len,
+                         unsigned char addr_type)
+{
+        struct netdev_hw_addr *ha;
+
+        list_for_each_entry(ha, 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);
+                        if (delta)
+                                (*delta)--;
+                        return 0;
+                }
+        }
+        return -ENOENT;
+}
+
+static int __hw_addr_add_multiple(struct list_head *to_list, int *to_delta,
+                                  struct list_head *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) {
+                type = addr_type ? addr_type : ha->type;
+                err = __hw_addr_add(to_list, to_delta, ha->addr,
+                                    addr_len, type);
+                if (err)
+                        goto unroll;
+        }
+        return 0;
+
+unroll:
+        list_for_each_entry(ha2, from_list, list) {
+                if (ha2 == ha)
+                        break;
+                type = addr_type ? addr_type : ha2->type;
+                __hw_addr_del(to_list, to_delta, ha2->addr,
+                              addr_len, type);
+        }
+        return err;
+}
+
+static void __hw_addr_del_multiple(struct list_head *to_list, int *to_delta,
+                                   struct list_head *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) {
+                type = addr_type ? addr_type : ha->type;
+                __hw_addr_del(to_list, to_delta, ha->addr,
+                              addr_len, addr_type);
+        }
+}
+
+static int __hw_addr_sync(struct list_head *to_list, int *to_delta,
+                          struct list_head *from_list, int *from_delta,
+                          int addr_len)
+{
+        int err = 0;
+        struct netdev_hw_addr *ha, *tmp;
+
+        list_for_each_entry_safe(ha, tmp, from_list, list) {
+                if (!ha->synced) {
+                        err = __hw_addr_add(to_list, to_delta, ha->addr,
+                                            addr_len, ha->type);
+                        if (err)
+                                break;
+                        ha->synced = true;
+                        ha->refcount++;
+                } else if (ha->refcount == 1) {
+                        __hw_addr_del(to_list, to_delta, ha->addr,
+                                      addr_len, ha->type);
+                        __hw_addr_del(from_list, from_delta, ha->addr,
+                                      addr_len, ha->type);
+                }
+        }
+        return err;
+}
+
+static void __hw_addr_unsync(struct list_head *to_list, int *to_delta,
+                             struct list_head *from_list, int *from_delta,
+                             int addr_len)
+{
+        struct netdev_hw_addr *ha, *tmp;
+
+        list_for_each_entry_safe(ha, tmp, from_list, list) {
+                if (ha->synced) {
+                        __hw_addr_del(to_list, to_delta, ha->addr,
+                                      addr_len, ha->type);
+                        ha->synced = false;
+                        __hw_addr_del(from_list, from_delta, ha->addr,
+                                      addr_len, ha->type);
+                }
+        }
+}
+
+
+static void __hw_addr_flush(struct list_head *list)
+{
+        struct netdev_hw_addr *ha, *tmp;
+
+        list_for_each_entry_safe(ha, tmp, list, list) {
+                list_del_rcu(&ha->list);
+                call_rcu(&ha->rcu_head, ha_rcu_free);
+        }
+}
+
+/* Device addresses handling functions */
+
+static void dev_addr_flush(struct net_device *dev)
+{
+        /* rtnl_mutex must be held here */
+
+        __hw_addr_flush(&dev->dev_addr_list);
+        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 */
+
+        INIT_LIST_HEAD(&dev->dev_addr_list);
+        memset(addr, 0, sizeof(addr));
+        err = __hw_addr_add(&dev->dev_addr_list, NULL, 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_addr_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_addr_list, NULL, 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_addr_list, struct netdev_hw_addr, list);
+        if (ha->addr == dev->dev_addr && ha->refcount == 1)
+                return -ENOENT;
+
+        err = __hw_addr_del(&dev->dev_addr_list, NULL, 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_addr_list, NULL,
+                                     &from_dev->dev_addr_list,
+                                     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_addr_list, NULL,
+                               &from_dev->dev_addr_list,
+                               to_dev->addr_len, addr_type);
+        call_netdevice_notifiers(NETDEV_CHANGEADDR, to_dev);
+        return 0;
+}
+EXPORT_SYMBOL(dev_addr_del_multiple);
+
+/* unicast and multicast addresses handling functions */
+
 int __dev_addr_delete(struct dev_addr_list **list, int *count,
                       void *addr, int alen, int glbl)
 {
@@ -3506,24 +3856,22 @@ int __dev_addr_add(struct dev_addr_list **list, int *count,
  *      dev_unicast_delete      - Release secondary unicast address.
  *      @dev: device
  *      @addr: address to delete
- *      @alen: length of @addr
  *
  *      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 alen)
+int dev_unicast_delete(struct net_device *dev, void *addr)
 {
         int err;
 
         ASSERT_RTNL();
 
-        netif_addr_lock_bh(dev);
-        err = __dev_addr_delete(&dev->uc_list, &dev->uc_count, addr, alen, 0);
+        err = __hw_addr_del(&dev->uc_list, &dev->uc_count, 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);
@@ -3532,24 +3880,22 @@ EXPORT_SYMBOL(dev_unicast_delete);
  *      dev_unicast_add         - add a secondary unicast address
  *      @dev: device
  *      @addr: address to add
- *      @alen: length of @addr
  *
  *      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 alen)
+int dev_unicast_add(struct net_device *dev, void *addr)
 {
         int err;
 
         ASSERT_RTNL();
 
-        netif_addr_lock_bh(dev);
-        err = __dev_addr_add(&dev->uc_list, &dev->uc_count, addr, alen, 0);
+        err = __hw_addr_add(&dev->uc_list, &dev->uc_count, 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);
@@ -3606,8 +3952,7 @@ void __dev_addr_unsync(struct dev_addr_list **to, int *to_count,
  *      @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.
+ *      addresses that have no users left.
  *
  *      This function is intended to be called from the dev->set_rx_mode
  *      function of layered software devices.
@@ -3616,12 +3961,15 @@ int dev_unicast_sync(struct net_device *to, struct net_device *from)
 {
         int err = 0;
 
-        netif_addr_lock_bh(to);
-        err = __dev_addr_sync(&to->uc_list, &to->uc_count,
-                              &from->uc_list, &from->uc_count);
+        ASSERT_RTNL();
+
+        if (to->addr_len != from->addr_len)
+                return -EINVAL;
+
+        err = __hw_addr_sync(&to->uc_list, &to->uc_count,
+                             &from->uc_list, &from->uc_count, to->addr_len);
         if (!err)
                 __dev_set_rx_mode(to);
-        netif_addr_unlock_bh(to);
         return err;
 }
 EXPORT_SYMBOL(dev_unicast_sync);
@@ -3637,18 +3985,33 @@ EXPORT_SYMBOL(dev_unicast_sync);
  */
 void dev_unicast_unsync(struct net_device *to, struct net_device *from)
 {
-        netif_addr_lock_bh(from);
-        netif_addr_lock(to);
+        ASSERT_RTNL();
 
-        __dev_addr_unsync(&to->uc_list, &to->uc_count,
-                          &from->uc_list, &from->uc_count);
-        __dev_set_rx_mode(to);
+        if (to->addr_len != from->addr_len)
+                return;
 
-        netif_addr_unlock(to);
-        netif_addr_unlock_bh(from);
+        __hw_addr_unsync(&to->uc_list, &to->uc_count,
+                         &from->uc_list, &from->uc_count, to->addr_len);
+        __dev_set_rx_mode(to);
 }
 EXPORT_SYMBOL(dev_unicast_unsync);
 
+static void dev_unicast_flush(struct net_device *dev)
+{
+        /* rtnl_mutex must be held here */
+
+        __hw_addr_flush(&dev->uc_list);
+        dev->uc_count = 0;
+}
+
+static void dev_unicast_init(struct net_device *dev)
+{
+        /* rtnl_mutex must be held here */
+
+        INIT_LIST_HEAD(&dev->uc_list);
+}
+
+
 static void __dev_addr_discard(struct dev_addr_list **list)
 {
         struct dev_addr_list *tmp;
@@ -3667,9 +4030,6 @@ static void dev_addr_discard(struct net_device *dev)
 {
         netif_addr_lock_bh(dev);
 
-        __dev_addr_discard(&dev->uc_list);
-        dev->uc_count = 0;
-
         __dev_addr_discard(&dev->mc_list);
         dev->mc_count = 0;
 
@@ -3853,7 +4213,7 @@ static int dev_ifsioc_locked(struct net *net, struct ifreq *ifr, unsigned int cm
 
         switch (cmd) {
                 case SIOCGIFFLAGS:      /* Get interface flags */
-                        ifr->ifr_flags = dev_get_flags(dev);
+                        ifr->ifr_flags = (short) dev_get_flags(dev);
                         return 0;
 
                 case SIOCGIFMETRIC:     /* Get the metric on the interface
@@ -4262,6 +4622,7 @@ static void rollback_registered(struct net_device *dev)
         /*
          *      Flush the unicast and multicast chains
          */
+        dev_unicast_flush(dev);
         dev_addr_discard(dev);
 
         if (dev->netdev_ops->ndo_uninit)
@@ -4333,39 +4694,6 @@ unsigned long netdev_fix_features(unsigned long features, const char *name)
 }
 EXPORT_SYMBOL(netdev_fix_features);
 
-/* Some devices need to (re-)set their netdev_ops inside
- * ->init() or similar.  If that happens, we have to setup
- * the compat pointers again.
- */
-void netdev_resync_ops(struct net_device *dev)
-{
-#ifdef CONFIG_COMPAT_NET_DEV_OPS
-        const struct net_device_ops *ops = dev->netdev_ops;
-
-        dev->init = ops->ndo_init;
-        dev->uninit = ops->ndo_uninit;
-        dev->open = ops->ndo_open;
-        dev->change_rx_flags = ops->ndo_change_rx_flags;
-        dev->set_rx_mode = ops->ndo_set_rx_mode;
-        dev->set_multicast_list = ops->ndo_set_multicast_list;
-        dev->set_mac_address = ops->ndo_set_mac_address;
-        dev->validate_addr = ops->ndo_validate_addr;
-        dev->do_ioctl = ops->ndo_do_ioctl;
-        dev->set_config = ops->ndo_set_config;
-        dev->change_mtu = ops->ndo_change_mtu;
-        dev->neigh_setup = ops->ndo_neigh_setup;
-        dev->tx_timeout = ops->ndo_tx_timeout;
-        dev->get_stats = ops->ndo_get_stats;
-        dev->vlan_rx_register = ops->ndo_vlan_rx_register;
-        dev->vlan_rx_add_vid = ops->ndo_vlan_rx_add_vid;
-        dev->vlan_rx_kill_vid = ops->ndo_vlan_rx_kill_vid;
-#ifdef CONFIG_NET_POLL_CONTROLLER
-        dev->poll_controller = ops->ndo_poll_controller;
-#endif
-#endif
-}
-EXPORT_SYMBOL(netdev_resync_ops);
-
 /**
  *      register_netdevice      - register a network device
  *      @dev: device to register
@@ -4405,23 +4733,6 @@ int register_netdevice(struct net_device *dev)
 
         dev->iflink = -1;
 
-#ifdef CONFIG_COMPAT_NET_DEV_OPS
-        /* Netdevice_ops API compatibility support.
-         * This is temporary until all network devices are converted.
-         */
-        if (dev->netdev_ops) {
-                netdev_resync_ops(dev);
-        } else {
-                char drivername[64];
-                pr_info("%s (%s): not using net_device_ops yet\n",
-                        dev->name, netdev_drivername(dev, drivername, 64));
-
-                /* This works only because net_device_ops and the
-                   compatibility structure are the same. */
-                dev->netdev_ops = (void *) &(dev->init);
-        }
-#endif
-
         /* Init, if this function is available */
         if (dev->netdev_ops->ndo_init) {
                 ret = dev->netdev_ops->ndo_init(dev);
@@ -4707,13 +5018,30 @@ void netdev_run_todo(void)
  *      the internal statistics structure is used.
  */
 const struct net_device_stats *dev_get_stats(struct net_device *dev)
- {
+{
         const struct net_device_ops *ops = dev->netdev_ops;
 
         if (ops->ndo_get_stats)
                 return ops->ndo_get_stats(dev);
-        else
-                return &dev->stats;
+        else {
+                unsigned long tx_bytes = 0, tx_packets = 0, tx_dropped = 0;
+                struct net_device_stats *stats = &dev->stats;
+                unsigned int i;
+                struct netdev_queue *txq;
+
+                for (i = 0; i < dev->num_tx_queues; i++) {
+                        txq = netdev_get_tx_queue(dev, i);
+                        tx_bytes   += txq->tx_bytes;
+                        tx_packets += txq->tx_packets;
+                        tx_dropped += txq->tx_dropped;
+                }
+                if (tx_bytes || tx_packets || tx_dropped) {
+                        stats->tx_bytes   = tx_bytes;
+                        stats->tx_packets = tx_packets;
+                        stats->tx_dropped = tx_dropped;
+                }
+                return stats;
+        }
 }
 EXPORT_SYMBOL(dev_get_stats);
 
@@ -4748,18 +5076,18 @@ struct net_device *alloc_netdev_mq(int sizeof_priv, const char *name,
         struct netdev_queue *tx;
         struct net_device *dev;
         size_t alloc_size;
-        void *p;
+        struct net_device *p;
 
         BUG_ON(strlen(name) >= sizeof(dev->name));
 
         alloc_size = sizeof(struct net_device);
         if (sizeof_priv) {
                 /* ensure 32-byte alignment of private area */
-                alloc_size = (alloc_size + NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST;
+                alloc_size = ALIGN(alloc_size, NETDEV_ALIGN);
                 alloc_size += sizeof_priv;
         }
         /* ensure 32-byte alignment of whole construct */
-        alloc_size += NETDEV_ALIGN_CONST;
+        alloc_size += NETDEV_ALIGN - 1;
 
         p = kzalloc(alloc_size, GFP_KERNEL);
         if (!p) {
@@ -4771,13 +5099,17 @@ struct net_device *alloc_netdev_mq(int sizeof_priv, const char *name,
         if (!tx) {
                 printk(KERN_ERR "alloc_netdev: Unable to allocate "
                        "tx qdiscs.\n");
-                kfree(p);
-                return NULL;
+                goto free_p;
         }
 
-        dev = (struct net_device *)
-                (((long)p + NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST);
+        dev = PTR_ALIGN(p, NETDEV_ALIGN);
         dev->padded = (char *)dev - (char *)p;
+
+        if (dev_addr_init(dev))
+                goto free_tx;
+
+        dev_unicast_init(dev);
+
         dev_net_set(dev, &init_net);
 
         dev->_tx = tx;
@@ -4789,9 +5121,17 @@ struct net_device *alloc_netdev_mq(int sizeof_priv, const char *name,
         netdev_init_queues(dev);
 
         INIT_LIST_HEAD(&dev->napi_list);
+        dev->priv_flags = IFF_XMIT_DST_RELEASE;
         setup(dev);
         strcpy(dev->name, name);
         return dev;
+
+free_tx:
+        kfree(tx);
+
+free_p:
+        kfree(p);
+        return NULL;
 }
 EXPORT_SYMBOL(alloc_netdev_mq);
 
@@ -4811,6 +5151,9 @@ void free_netdev(struct net_device *dev)
 
         kfree(dev->_tx);
 
+        /* Flush device addresses */
+        dev_addr_flush(dev);
+
         list_for_each_entry_safe(p, n, &dev->napi_list, dev_list)
                 netif_napi_del(p);
 
@@ -4970,6 +5313,7 @@ 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);
 
         netdev_unregister_kobject(dev);
@@ -5325,12 +5669,6 @@ EXPORT_SYMBOL(net_enable_timestamp);
 EXPORT_SYMBOL(net_disable_timestamp);
 EXPORT_SYMBOL(dev_get_flags);
 
-#if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
-EXPORT_SYMBOL(br_handle_frame_hook);
-EXPORT_SYMBOL(br_fdb_get_hook);
-EXPORT_SYMBOL(br_fdb_put_hook);
-#endif
-
 EXPORT_SYMBOL(dev_load);
 
 EXPORT_PER_CPU_SYMBOL(softnet_data);
diff --git a/net/core/drop_monitor.c b/net/core/drop_monitor.c
index 9fd0dc3cca99..9d66fa953ab7 100644
--- a/net/core/drop_monitor.c
+++ b/net/core/drop_monitor.c
@@ -22,8 +22,10 @@
 #include <linux/timer.h>
 #include <linux/bitops.h>
 #include <net/genetlink.h>
+#include <net/netevent.h>
 
-#include <trace/skb.h>
+#include <trace/events/skb.h>
+#include <trace/events/napi.h>
 
 #include <asm/unaligned.h>
 
@@ -38,7 +40,8 @@ static void send_dm_alert(struct work_struct *unused);
  * and the work handle that will send up
  * netlink alerts
  */
-struct sock *dm_sock;
+static int trace_state = TRACE_OFF;
+static spinlock_t trace_state_lock = SPIN_LOCK_UNLOCKED;
 
 struct per_cpu_dm_data {
         struct work_struct dm_alert_work;
@@ -47,11 +50,18 @@ struct per_cpu_dm_data {
         struct timer_list send_timer;
 };
 
+struct dm_hw_stat_delta {
+        struct net_device *dev;
+        struct list_head list;
+        struct rcu_head rcu;
+        unsigned long last_drop_val;
+};
+
 static struct genl_family net_drop_monitor_family = {
         .id             = GENL_ID_GENERATE,
         .hdrsize        = 0,
         .name           = "NET_DM",
-        .version        = 1,
+        .version        = 2,
         .maxattr        = NET_DM_CMD_MAX,
 };
 
@@ -59,19 +69,24 @@ static DEFINE_PER_CPU(struct per_cpu_dm_data, dm_cpu_data);
 
 static int dm_hit_limit = 64;
 static int dm_delay = 1;
-
+static unsigned long dm_hw_check_delta = 2*HZ;
+static LIST_HEAD(hw_stats_list);
 
 static void reset_per_cpu_data(struct per_cpu_dm_data *data)
 {
         size_t al;
         struct net_dm_alert_msg *msg;
+        struct nlattr *nla;
 
         al = sizeof(struct net_dm_alert_msg);
         al += dm_hit_limit * sizeof(struct net_dm_drop_point);
+        al += sizeof(struct nlattr);
+
         data->skb = genlmsg_new(al, GFP_KERNEL);
         genlmsg_put(data->skb, 0, 0, &net_drop_monitor_family,
                         0, NET_DM_CMD_ALERT);
-        msg = __nla_reserve_nohdr(data->skb, sizeof(struct net_dm_alert_msg));
+        nla = nla_reserve(data->skb, NLA_UNSPEC, sizeof(struct net_dm_alert_msg));
+        msg = nla_data(nla);
         memset(msg, 0, al);
         atomic_set(&data->dm_hit_count, dm_hit_limit);
 }
@@ -111,10 +126,11 @@ static void sched_send_work(unsigned long unused)
         schedule_work(&data->dm_alert_work);
 }
 
-static void trace_kfree_skb_hit(struct sk_buff *skb, void *location)
+static void trace_drop_common(struct sk_buff *skb, void *location)
 {
         struct net_dm_alert_msg *msg;
         struct nlmsghdr *nlh;
+        struct nlattr *nla;
         int i;
         struct per_cpu_dm_data *data = &__get_cpu_var(dm_cpu_data);
 
@@ -127,7 +143,8 @@ static void trace_kfree_skb_hit(struct sk_buff *skb, void *location)
         }
 
         nlh = (struct nlmsghdr *)data->skb->data;
-        msg = genlmsg_data(nlmsg_data(nlh));
+        nla = genlmsg_data(nlmsg_data(nlh));
+        msg = nla_data(nla);
         for (i = 0; i < msg->entries; i++) {
                 if (!memcmp(&location, msg->points[i].pc, sizeof(void *))) {
                         msg->points[i].count++;
@@ -139,6 +156,7 @@ static void trace_kfree_skb_hit(struct sk_buff *skb, void *location)
          * We need to create a new entry
          */
         __nla_reserve_nohdr(data->skb, sizeof(struct net_dm_drop_point));
+        nla->nla_len += NLA_ALIGN(sizeof(struct net_dm_drop_point));
         memcpy(msg->points[msg->entries].pc, &location, sizeof(void *));
         msg->points[msg->entries].count = 1;
         msg->entries++;
@@ -152,24 +170,80 @@ out:
         return;
 }
 
+static void trace_kfree_skb_hit(struct sk_buff *skb, void *location)
+{
+        trace_drop_common(skb, location);
+}
+
+static void trace_napi_poll_hit(struct napi_struct *napi)
+{
+        struct dm_hw_stat_delta *new_stat;
+
+        /*
+         * Ratelimit our check time to dm_hw_check_delta jiffies
+         */
+        if (!time_after(jiffies, napi->dev->last_rx + dm_hw_check_delta))
+                return;
+
+        rcu_read_lock();
+        list_for_each_entry_rcu(new_stat, &hw_stats_list, list) {
+                if ((new_stat->dev == napi->dev)  &&
+                    (napi->dev->stats.rx_dropped != new_stat->last_drop_val)) {
+                        trace_drop_common(NULL, NULL);
+                        new_stat->last_drop_val = napi->dev->stats.rx_dropped;
+                        break;
+                }
+        }
+        rcu_read_unlock();
+}
+
+
+static void free_dm_hw_stat(struct rcu_head *head)
+{
+        struct dm_hw_stat_delta *n;
+        n = container_of(head, struct dm_hw_stat_delta, rcu);
+        kfree(n);
+}
+
 static int set_all_monitor_traces(int state)
 {
         int rc = 0;
+        struct dm_hw_stat_delta *new_stat = NULL;
+        struct dm_hw_stat_delta *temp;
+
+        spin_lock(&trace_state_lock);
 
         switch (state) {
         case TRACE_ON:
                 rc |= register_trace_kfree_skb(trace_kfree_skb_hit);
+                rc |= register_trace_napi_poll(trace_napi_poll_hit);
                 break;
         case TRACE_OFF:
                 rc |= unregister_trace_kfree_skb(trace_kfree_skb_hit);
+                rc |= unregister_trace_napi_poll(trace_napi_poll_hit);
 
                 tracepoint_synchronize_unregister();
+
+                /*
+                 * Clean the device list
+                 */
+                list_for_each_entry_safe(new_stat, temp, &hw_stats_list, list) {
+                        if (new_stat->dev == NULL) {
+                                list_del_rcu(&new_stat->list);
+                                call_rcu(&new_stat->rcu, free_dm_hw_stat);
+                        }
+                }
                 break;
         default:
                 rc = 1;
                 break;
         }
 
+        if (!rc)
+                trace_state = state;
+
+        spin_unlock(&trace_state_lock);
+
         if (rc)
                 return -EINPROGRESS;
         return rc;
@@ -197,6 +271,44 @@ static int net_dm_cmd_trace(struct sk_buff *skb,
         return -ENOTSUPP;
 }
 
+static int dropmon_net_event(struct notifier_block *ev_block,
+                        unsigned long event, void *ptr)
+{
+        struct net_device *dev = ptr;
+        struct dm_hw_stat_delta *new_stat = NULL;
+        struct dm_hw_stat_delta *tmp;
+
+        switch (event) {
+        case NETDEV_REGISTER:
+                new_stat = kzalloc(sizeof(struct dm_hw_stat_delta), GFP_KERNEL);
+
+                if (!new_stat)
+                        goto out;
+
+                new_stat->dev = dev;
+                INIT_RCU_HEAD(&new_stat->rcu);
+                spin_lock(&trace_state_lock);
+                list_add_rcu(&new_stat->list, &hw_stats_list);
+                spin_unlock(&trace_state_lock);
+                break;
+        case NETDEV_UNREGISTER:
+                spin_lock(&trace_state_lock);
+                list_for_each_entry_safe(new_stat, tmp, &hw_stats_list, list) {
+                        if (new_stat->dev == dev) {
+                                new_stat->dev = NULL;
+                                if (trace_state == TRACE_OFF) {
+                                        list_del_rcu(&new_stat->list);
+                                        call_rcu(&new_stat->rcu, free_dm_hw_stat);
+                                        break;
+                                }
+                        }
+                }
+                spin_unlock(&trace_state_lock);
+                break;
+        }
+out:
+        return NOTIFY_DONE;
+}
 
 static struct genl_ops dropmon_ops[] = {
         {
@@ -213,6 +325,10 @@ static struct genl_ops dropmon_ops[] = {
         },
 };
 
+static struct notifier_block dropmon_net_notifier = {
+        .notifier_call = dropmon_net_event
+};
+
 static int __init init_net_drop_monitor(void)
 {
         int cpu;
@@ -236,12 +352,18 @@ static int __init init_net_drop_monitor(void)
                 ret = genl_register_ops(&net_drop_monitor_family,
                                         &dropmon_ops[i]);
                 if (ret) {
-                        printk(KERN_CRIT "failed to register operation %d\n",
+                        printk(KERN_CRIT "Failed to register operation %d\n",
                                 dropmon_ops[i].cmd);
                         goto out_unreg;
                 }
         }
 
+        rc = register_netdevice_notifier(&dropmon_net_notifier);
+        if (rc < 0) {
+                printk(KERN_CRIT "Failed to register netdevice notifier\n");
+                goto out_unreg;
+        }
+
         rc = 0;
 
         for_each_present_cpu(cpu) {
@@ -252,6 +374,7 @@ static int __init init_net_drop_monitor(void)
                 data->send_timer.data = cpu;
                 data->send_timer.function = sched_send_work;
         }
+
         goto out;
 
 out_unreg:
diff --git a/net/core/fib_rules.c b/net/core/fib_rules.c
index 98691e1466b8..bd309384f8b8 100644
--- a/net/core/fib_rules.c
+++ b/net/core/fib_rules.c
@@ -299,7 +299,7 @@ static int fib_nl_newrule(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
         } else if (rule->action == FR_ACT_GOTO)
                 goto errout_free;
 
-        err = ops->configure(rule, skb, nlh, frh, tb);
+        err = ops->configure(rule, skb, frh, tb);
         if (err < 0)
                 goto errout_free;
 
@@ -500,7 +500,7 @@ static int fib_nl_fill_rule(struct sk_buff *skb, struct fib_rule *rule,
         if (rule->target)
                 NLA_PUT_U32(skb, FRA_GOTO, rule->target);
 
-        if (ops->fill(rule, skb, nlh, frh) < 0)
+        if (ops->fill(rule, skb, frh) < 0)
                 goto nla_put_failure;
 
         return nlmsg_end(skb, nlh);
diff --git a/net/core/gen_estimator.c b/net/core/gen_estimator.c
index 6d62d4618cfc..78e5bfc454ae 100644
--- a/net/core/gen_estimator.c
+++ b/net/core/gen_estimator.c
@@ -128,12 +128,12 @@ static void est_timer(unsigned long arg)
                 npackets = e->bstats->packets;
                 brate = (nbytes - e->last_bytes)<<(7 - idx);
                 e->last_bytes = nbytes;
-                e->avbps += ((s64)(brate - e->avbps)) >> e->ewma_log;
+                e->avbps += (brate >> e->ewma_log) - (e->avbps >> e->ewma_log);
                 e->rate_est->bps = (e->avbps+0xF)>>5;
 
                 rate = (npackets - e->last_packets)<<(12 - idx);
                 e->last_packets = npackets;
-                e->avpps += ((long)rate - (long)e->avpps) >> e->ewma_log;
+                e->avpps += (rate >> e->ewma_log) - (e->avpps >> e->ewma_log);
                 e->rate_est->pps = (e->avpps+0x1FF)>>10;
 skip:
                 read_unlock(&est_lock);
diff --git a/net/core/iovec.c b/net/core/iovec.c
index 4c9c0121c9da..16ad45d4882b 100644
--- a/net/core/iovec.c
+++ b/net/core/iovec.c
@@ -98,6 +98,31 @@ int memcpy_toiovec(struct iovec *iov, unsigned char *kdata, int len)
 }
 
 /*
+ *      Copy kernel to iovec. Returns -EFAULT on error.
+ */
+
+int memcpy_toiovecend(const struct iovec *iov, unsigned char *kdata,
+                      int offset, int len)
+{
+        int copy;
+        for (; len > 0; ++iov) {
+                /* Skip over the finished iovecs */
+                if (unlikely(offset >= iov->iov_len)) {
+                        offset -= iov->iov_len;
+                        continue;
+                }
+                copy = min_t(unsigned int, iov->iov_len - offset, len);
+                if (copy_to_user(iov->iov_base + offset, kdata, copy))
+                        return -EFAULT;
+                offset = 0;
+                kdata += copy;
+                len -= copy;
+        }
+
+        return 0;
+}
+
+/*
  *      Copy iovec to kernel. Returns -EFAULT on error.
  *
  *      Note: this modifies the original iovec.
@@ -122,10 +147,11 @@ int memcpy_fromiovec(unsigned char *kdata, struct iovec *iov, int len)
 }
 
 /*
- *      For use with ip_build_xmit
+ *      Copy iovec from kernel. Returns -EFAULT on error.
  */
-int memcpy_fromiovecend(unsigned char *kdata, struct iovec *iov, int offset,
-                        int len)
+
+int memcpy_fromiovecend(unsigned char *kdata, const struct iovec *iov,
+                        int offset, int len)
 {
         /* Skip over the finished iovecs */
         while (offset >= iov->iov_len) {
@@ -236,3 +262,4 @@ EXPORT_SYMBOL(csum_partial_copy_fromiovecend);
 EXPORT_SYMBOL(memcpy_fromiovec);
 EXPORT_SYMBOL(memcpy_fromiovecend);
 EXPORT_SYMBOL(memcpy_toiovec);
+EXPORT_SYMBOL(memcpy_toiovecend);
diff --git a/net/core/neighbour.c b/net/core/neighbour.c
index a1cbce7fdae5..163b4f5b0365 100644
--- a/net/core/neighbour.c
+++ b/net/core/neighbour.c
@@ -771,6 +771,28 @@ static __inline__ int neigh_max_probes(struct neighbour *n)
                 p->ucast_probes + p->app_probes + p->mcast_probes);
 }
 
+static void neigh_invalidate(struct neighbour *neigh)
+{
+        struct sk_buff *skb;
+
+        NEIGH_CACHE_STAT_INC(neigh->tbl, res_failed);
+        NEIGH_PRINTK2("neigh %p is failed.\n", neigh);
+        neigh->updated = jiffies;
+
+        /* It is very thin place. report_unreachable is very complicated
+           routine. Particularly, it can hit the same neighbour entry!
+
+           So that, we try to be accurate and avoid dead loop. --ANK
+         */
+        while (neigh->nud_state == NUD_FAILED &&
+               (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) {
+                write_unlock(&neigh->lock);
+                neigh->ops->error_report(neigh, skb);
+                write_lock(&neigh->lock);
+        }
+        skb_queue_purge(&neigh->arp_queue);
+}
+
 /* Called when a timer expires for a neighbour entry. */
 
 static void neigh_timer_handler(unsigned long arg)
@@ -835,26 +857,9 @@ static void neigh_timer_handler(unsigned long arg)
 
         if ((neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) &&
             atomic_read(&neigh->probes) >= neigh_max_probes(neigh)) {
-                struct sk_buff *skb;
-
                 neigh->nud_state = NUD_FAILED;
-                neigh->updated = jiffies;
                 notify = 1;
-                NEIGH_CACHE_STAT_INC(neigh->tbl, res_failed);
-                NEIGH_PRINTK2("neigh %p is failed.\n", neigh);
-
-                /* It is very thin place. report_unreachable is very complicated
-                   routine. Particularly, it can hit the same neighbour entry!
-
-                   So that, we try to be accurate and avoid dead loop. --ANK
-                 */
-                while (neigh->nud_state == NUD_FAILED &&
-                       (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) {
-                        write_unlock(&neigh->lock);
-                        neigh->ops->error_report(neigh, skb);
-                        write_lock(&neigh->lock);
-                }
-                skb_queue_purge(&neigh->arp_queue);
+                neigh_invalidate(neigh);
         }
 
         if (neigh->nud_state & NUD_IN_TIMER) {
@@ -1001,6 +1006,11 @@ int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new,
                 neigh->nud_state = new;
                 err = 0;
                 notify = old & NUD_VALID;
+                if ((old & (NUD_INCOMPLETE | NUD_PROBE)) &&
+                    (new & NUD_FAILED)) {
+                        neigh_invalidate(neigh);
+                        notify = 1;
+                }
                 goto out;
         }
 
@@ -1088,8 +1098,8 @@ int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new,
                         struct neighbour *n1 = neigh;
                         write_unlock_bh(&neigh->lock);
                         /* On shaper/eql skb->dst->neighbour != neigh :( */
-                        if (skb->dst && skb->dst->neighbour)
-                                n1 = skb->dst->neighbour;
+                        if (skb_dst(skb) && skb_dst(skb)->neighbour)
+                                n1 = skb_dst(skb)->neighbour;
                         n1->output(skb);
                         write_lock_bh(&neigh->lock);
                 }
@@ -1182,7 +1192,7 @@ EXPORT_SYMBOL(neigh_compat_output);
 
 int neigh_resolve_output(struct sk_buff *skb)
 {
-        struct dst_entry *dst = skb->dst;
+        struct dst_entry *dst = skb_dst(skb);
         struct neighbour *neigh;
         int rc = 0;
 
@@ -1229,7 +1239,7 @@ EXPORT_SYMBOL(neigh_resolve_output);
 int neigh_connected_output(struct sk_buff *skb)
 {
         int err;
-        struct dst_entry *dst = skb->dst;
+        struct dst_entry *dst = skb_dst(skb);
         struct neighbour *neigh = dst->neighbour;
         struct net_device *dev = neigh->dev;
 
@@ -1298,8 +1308,7 @@ void pneigh_enqueue(struct neigh_table *tbl, struct neigh_parms *p,
                 if (time_before(tbl->proxy_timer.expires, sched_next))
                         sched_next = tbl->proxy_timer.expires;
         }
-        dst_release(skb->dst);
-        skb->dst = NULL;
+        skb_dst_drop(skb);
         dev_hold(skb->dev);
         __skb_queue_tail(&tbl->proxy_queue, skb);
         mod_timer(&tbl->proxy_timer, sched_next);
diff --git a/net/core/net-sysfs.c b/net/core/net-sysfs.c
index 2da59a0ac4ac..3994680c08b9 100644
--- a/net/core/net-sysfs.c
+++ b/net/core/net-sysfs.c
@@ -78,7 +78,7 @@ static ssize_t netdev_store(struct device *dev, struct device_attribute *attr,
                 goto err;
 
         if (!rtnl_trylock())
-                return -ERESTARTSYS;
+                return restart_syscall();
 
         if (dev_isalive(net)) {
                 if ((ret = (*set)(net, new)) == 0)
@@ -225,7 +225,8 @@ static ssize_t store_ifalias(struct device *dev, struct device_attribute *attr,
         if (len >  0 && buf[len - 1] == '\n')
                 --count;
 
-        rtnl_lock();
+        if (!rtnl_trylock())
+                return restart_syscall();
         ret = dev_set_alias(netdev, buf, count);
         rtnl_unlock();
 
@@ -238,7 +239,8 @@ static ssize_t show_ifalias(struct device *dev,
         const struct net_device *netdev = to_net_dev(dev);
         ssize_t ret = 0;
 
-        rtnl_lock();
+        if (!rtnl_trylock())
+                return restart_syscall();
         if (netdev->ifalias)
                 ret = sprintf(buf, "%s\n", netdev->ifalias);
         rtnl_unlock();
@@ -497,7 +499,6 @@ int netdev_register_kobject(struct net_device *net)
         dev->platform_data = net;
         dev->groups = groups;
 
-        BUILD_BUG_ON(BUS_ID_SIZE < IFNAMSIZ);
         dev_set_name(dev, "%s", net->name);
 
 #ifdef CONFIG_SYSFS
diff --git a/net/core/net-traces.c b/net/core/net-traces.c
index c8fb45665e4f..f1e982c508bb 100644
--- a/net/core/net-traces.c
+++ b/net/core/net-traces.c
@@ -19,11 +19,14 @@
 #include <linux/workqueue.h>
 #include <linux/netlink.h>
 #include <linux/net_dropmon.h>
-#include <trace/skb.h>
 
 #include <asm/unaligned.h>
 #include <asm/bitops.h>
 
+#define CREATE_TRACE_POINTS
+#include <trace/events/skb.h>
+#include <trace/events/napi.h>
 
-DEFINE_TRACE(kfree_skb);
 EXPORT_TRACEPOINT_SYMBOL_GPL(kfree_skb);
+
+EXPORT_TRACEPOINT_SYMBOL_GPL(napi_poll);
diff --git a/net/core/net_namespace.c b/net/core/net_namespace.c
index e3bebd36f053..b7292a2719dc 100644
--- a/net/core/net_namespace.c
+++ b/net/core/net_namespace.c
@@ -115,41 +115,34 @@ static void net_free(struct net *net)
         kmem_cache_free(net_cachep, net);
 }
 
-struct net *copy_net_ns(unsigned long flags, struct net *old_net)
+static struct net *net_create(void)
 {
-        struct net *new_net = NULL;
-        int err;
-
-        get_net(old_net);
-
-        if (!(flags & CLONE_NEWNET))
-                return old_net;
-
-        err = -ENOMEM;
-        new_net = net_alloc();
-        if (!new_net)
-                goto out_err;
+        struct net *net;
+        int rv;
 
+        net = net_alloc();
+        if (!net)
+                return ERR_PTR(-ENOMEM);
         mutex_lock(&net_mutex);
-        err = setup_net(new_net);
-        if (!err) {
+        rv = setup_net(net);
+        if (rv == 0) {
                 rtnl_lock();
-                list_add_tail(&new_net->list, &net_namespace_list);
+                list_add_tail(&net->list, &net_namespace_list);
                 rtnl_unlock();
         }
         mutex_unlock(&net_mutex);
+        if (rv < 0) {
+                net_free(net);
+                return ERR_PTR(rv);
+        }
+        return net;
+}
 
-        if (err)
-                goto out_free;
-out:
-        put_net(old_net);
-        return new_net;
-
-out_free:
-        net_free(new_net);
-out_err:
-        new_net = ERR_PTR(err);
-        goto out;
+struct net *copy_net_ns(unsigned long flags, struct net *old_net)
+{
+        if (!(flags & CLONE_NEWNET))
+                return get_net(old_net);
+        return net_create();
 }
 
 static void cleanup_net(struct work_struct *work)
@@ -203,9 +196,7 @@ struct net *copy_net_ns(unsigned long flags, struct net *old_net)
 static int __init net_ns_init(void)
 {
         struct net_generic *ng;
-        int err;
 
-        printk(KERN_INFO "net_namespace: %zd bytes\n", sizeof(struct net));
 #ifdef CONFIG_NET_NS
         net_cachep = kmem_cache_create("net_namespace", sizeof(struct net),
                                         SMP_CACHE_BYTES,
@@ -224,15 +215,14 @@ static int __init net_ns_init(void)
         rcu_assign_pointer(init_net.gen, ng);
 
         mutex_lock(&net_mutex);
-        err = setup_net(&init_net);
+        if (setup_net(&init_net))
+                panic("Could not setup the initial network namespace");
 
         rtnl_lock();
         list_add_tail(&init_net.list, &net_namespace_list);
         rtnl_unlock();
 
         mutex_unlock(&net_mutex);
-        if (err)
-                panic("Could not setup the initial network namespace");
 
         return 0;
 }
diff --git a/net/core/netpoll.c b/net/core/netpoll.c
index 64f51eec6576..9675f312830d 100644
--- a/net/core/netpoll.c
+++ b/net/core/netpoll.c
@@ -24,6 +24,7 @@
 #include <net/tcp.h>
 #include <net/udp.h>
 #include <asm/unaligned.h>
+#include <trace/events/napi.h>
 
 /*
  * We maintain a small pool of fully-sized skbs, to make sure the
@@ -137,6 +138,7 @@ static int poll_one_napi(struct netpoll_info *npinfo,
         set_bit(NAPI_STATE_NPSVC, &napi->state);
 
         work = napi->poll(napi, budget);
+        trace_napi_poll(napi);
 
         clear_bit(NAPI_STATE_NPSVC, &napi->state);
         atomic_dec(&trapped);
@@ -300,8 +302,11 @@ static void netpoll_send_skb(struct netpoll *np, struct sk_buff *skb)
                 for (tries = jiffies_to_usecs(1)/USEC_PER_POLL;
                      tries > 0; --tries) {
                         if (__netif_tx_trylock(txq)) {
-                                if (!netif_tx_queue_stopped(txq))
+                                if (!netif_tx_queue_stopped(txq)) {
                                         status = ops->ndo_start_xmit(skb, dev);
+                                        if (status == NETDEV_TX_OK)
+                                                txq_trans_update(txq);
+                                }
                                 __netif_tx_unlock(txq);
 
                                 if (status == NETDEV_TX_OK)
diff --git a/net/core/pktgen.c b/net/core/pktgen.c
index 0666a827bc62..19b8c20e98a4 100644
--- a/net/core/pktgen.c
+++ b/net/core/pktgen.c
@@ -3438,6 +3438,7 @@ static __inline__ void pktgen_xmit(struct pktgen_dev *pkt_dev)
               retry_now:
                 ret = (*xmit)(pkt_dev->skb, odev);
                 if (likely(ret == NETDEV_TX_OK)) {
+                        txq_trans_update(txq);
                         pkt_dev->last_ok = 1;
                         pkt_dev->sofar++;
                         pkt_dev->seq_num++;
@@ -3690,8 +3691,7 @@ out1:
 #ifdef CONFIG_XFRM
         free_SAs(pkt_dev);
 #endif
-        if (pkt_dev->flows)
-                vfree(pkt_dev->flows);
+        vfree(pkt_dev->flows);
         kfree(pkt_dev);
         return err;
 }
@@ -3790,8 +3790,7 @@ static int pktgen_remove_device(struct pktgen_thread *t,
 #ifdef CONFIG_XFRM
         free_SAs(pkt_dev);
 #endif
-        if (pkt_dev->flows)
-                vfree(pkt_dev->flows);
+        vfree(pkt_dev->flows);
         kfree(pkt_dev);
         return 0;
 }
diff --git a/net/core/skb_dma_map.c b/net/core/skb_dma_map.c
index 86234923a3b7..79687dfd6957 100644
--- a/net/core/skb_dma_map.c
+++ b/net/core/skb_dma_map.c
@@ -20,7 +20,7 @@ int skb_dma_map(struct device *dev, struct sk_buff *skb,
         if (dma_mapping_error(dev, map))
                 goto out_err;
 
-        sp->dma_maps[0] = map;
+        sp->dma_head = map;
         for (i = 0; i < sp->nr_frags; i++) {
                 skb_frag_t *fp = &sp->frags[i];
 
@@ -28,9 +28,8 @@ int skb_dma_map(struct device *dev, struct sk_buff *skb,
                                    fp->size, dir);
                 if (dma_mapping_error(dev, map))
                         goto unwind;
-                sp->dma_maps[i + 1] = map;
+                sp->dma_maps[i] = map;
         }
-        sp->num_dma_maps = i + 1;
 
         return 0;
 
@@ -38,10 +37,10 @@ unwind:
         while (--i >= 0) {
                 skb_frag_t *fp = &sp->frags[i];
 
-                dma_unmap_page(dev, sp->dma_maps[i + 1],
+                dma_unmap_page(dev, sp->dma_maps[i],
                                fp->size, dir);
         }
-        dma_unmap_single(dev, sp->dma_maps[0],
+        dma_unmap_single(dev, sp->dma_head,
                          skb_headlen(skb), dir);
 out_err:
         return -ENOMEM;
@@ -54,12 +53,12 @@ void skb_dma_unmap(struct device *dev, struct sk_buff *skb,
         struct skb_shared_info *sp = skb_shinfo(skb);
         int i;
 
-        dma_unmap_single(dev, sp->dma_maps[0],
+        dma_unmap_single(dev, sp->dma_head,
                          skb_headlen(skb), dir);
         for (i = 0; i < sp->nr_frags; i++) {
                 skb_frag_t *fp = &sp->frags[i];
 
-                dma_unmap_page(dev, sp->dma_maps[i + 1],
+                dma_unmap_page(dev, sp->dma_maps[i],
                                fp->size, dir);
         }
 }
diff --git a/net/core/skbuff.c b/net/core/skbuff.c
index e505b5392e1e..5c93435b0347 100644
--- a/net/core/skbuff.c
+++ b/net/core/skbuff.c
@@ -39,6 +39,7 @@
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
+#include <linux/kmemcheck.h>
 #include <linux/mm.h>
 #include <linux/interrupt.h>
 #include <linux/in.h>
@@ -65,7 +66,7 @@
 
 #include <asm/uaccess.h>
 #include <asm/system.h>
-#include <trace/skb.h>
+#include <trace/events/skb.h>
 
 #include "kmap_skb.h"
 
@@ -201,6 +202,8 @@ struct sk_buff *__alloc_skb(unsigned int size, gfp_t gfp_mask,
         skb->data = data;
         skb_reset_tail_pointer(skb);
         skb->end = skb->tail + size;
+        kmemcheck_annotate_bitfield(skb, flags1);
+        kmemcheck_annotate_bitfield(skb, flags2);
         /* make sure we initialize shinfo sequentially */
         shinfo = skb_shinfo(skb);
         atomic_set(&shinfo->dataref, 1);
@@ -210,13 +213,15 @@ struct sk_buff *__alloc_skb(unsigned int size, gfp_t gfp_mask,
         shinfo->gso_type = 0;
         shinfo->ip6_frag_id = 0;
         shinfo->tx_flags.flags = 0;
-        shinfo->frag_list = NULL;
+        skb_frag_list_init(skb);
         memset(&shinfo->hwtstamps, 0, sizeof(shinfo->hwtstamps));
 
         if (fclone) {
                 struct sk_buff *child = skb + 1;
                 atomic_t *fclone_ref = (atomic_t *) (child + 1);
 
+                kmemcheck_annotate_bitfield(child, flags1);
+                kmemcheck_annotate_bitfield(child, flags2);
                 skb->fclone = SKB_FCLONE_ORIG;
                 atomic_set(fclone_ref, 1);
 
@@ -323,7 +328,7 @@ static void skb_clone_fraglist(struct sk_buff *skb)
 {
         struct sk_buff *list;
 
-        for (list = skb_shinfo(skb)->frag_list; list; list = list->next)
+        skb_walk_frags(skb, list)
                 skb_get(list);
 }
 
@@ -338,7 +343,7 @@ static void skb_release_data(struct sk_buff *skb)
                                 put_page(skb_shinfo(skb)->frags[i].page);
                 }
 
-                if (skb_shinfo(skb)->frag_list)
+                if (skb_has_frags(skb))
                         skb_drop_fraglist(skb);
 
                 kfree(skb->head);
@@ -381,7 +386,7 @@ static void kfree_skbmem(struct sk_buff *skb)
 
 static void skb_release_head_state(struct sk_buff *skb)
 {
-        dst_release(skb->dst);
+        skb_dst_drop(skb);
 #ifdef CONFIG_XFRM
         secpath_put(skb->sp);
 #endif
@@ -503,7 +508,7 @@ int skb_recycle_check(struct sk_buff *skb, int skb_size)
         shinfo->gso_type = 0;
         shinfo->ip6_frag_id = 0;
         shinfo->tx_flags.flags = 0;
-        shinfo->frag_list = NULL;
+        skb_frag_list_init(skb);
         memset(&shinfo->hwtstamps, 0, sizeof(shinfo->hwtstamps));
 
         memset(skb, 0, offsetof(struct sk_buff, tail));
@@ -521,13 +526,12 @@ static void __copy_skb_header(struct sk_buff *new, const struct sk_buff *old)
         new->transport_header   = old->transport_header;
         new->network_header     = old->network_header;
         new->mac_header         = old->mac_header;
-        new->dst                = dst_clone(old->dst);
+        skb_dst_set(new, dst_clone(skb_dst(old)));
 #ifdef CONFIG_XFRM
         new->sp                 = secpath_get(old->sp);
 #endif
         memcpy(new->cb, old->cb, sizeof(old->cb));
-        new->csum_start         = old->csum_start;
-        new->csum_offset        = old->csum_offset;
+        new->csum               = old->csum;
         new->local_df           = old->local_df;
         new->pkt_type           = old->pkt_type;
         new->ip_summed          = old->ip_summed;
@@ -538,6 +542,7 @@ static void __copy_skb_header(struct sk_buff *new, const struct sk_buff *old)
 #endif
         new->protocol           = old->protocol;
         new->mark               = old->mark;
+        new->iif                = old->iif;
         __nf_copy(new, old);
 #if defined(CONFIG_NETFILTER_XT_TARGET_TRACE) || \
     defined(CONFIG_NETFILTER_XT_TARGET_TRACE_MODULE)
@@ -550,10 +555,17 @@ static void __copy_skb_header(struct sk_buff *new, const struct sk_buff *old)
 #endif
 #endif
         new->vlan_tci           = old->vlan_tci;
+#if defined(CONFIG_MAC80211) || defined(CONFIG_MAC80211_MODULE)
+        new->do_not_encrypt     = old->do_not_encrypt;
+#endif
 
         skb_copy_secmark(new, old);
 }
 
+/*
+ * You should not add any new code to this function.  Add it to
+ * __copy_skb_header above instead.
+ */
 static struct sk_buff *__skb_clone(struct sk_buff *n, struct sk_buff *skb)
 {
 #define C(x) n->x = skb->x
@@ -569,16 +581,11 @@ static struct sk_buff *__skb_clone(struct sk_buff *n, struct sk_buff *skb)
         n->cloned = 1;
         n->nohdr = 0;
         n->destructor = NULL;
-        C(iif);
         C(tail);
         C(end);
         C(head);
         C(data);
         C(truesize);
-#if defined(CONFIG_MAC80211) || defined(CONFIG_MAC80211_MODULE)
-        C(do_not_encrypt);
-        C(requeue);
-#endif
         atomic_set(&n->users, 1);
 
         atomic_inc(&(skb_shinfo(skb)->dataref));
@@ -633,6 +640,9 @@ struct sk_buff *skb_clone(struct sk_buff *skb, gfp_t gfp_mask)
                 n = kmem_cache_alloc(skbuff_head_cache, gfp_mask);
                 if (!n)
                         return NULL;
+
+                kmemcheck_annotate_bitfield(n, flags1);
+                kmemcheck_annotate_bitfield(n, flags2);
                 n->fclone = SKB_FCLONE_UNAVAILABLE;
         }
 
@@ -755,7 +765,7 @@ struct sk_buff *pskb_copy(struct sk_buff *skb, gfp_t gfp_mask)
                 skb_shinfo(n)->nr_frags = i;
         }
 
-        if (skb_shinfo(skb)->frag_list) {
+        if (skb_has_frags(skb)) {
                 skb_shinfo(n)->frag_list = skb_shinfo(skb)->frag_list;
                 skb_clone_fraglist(n);
         }
@@ -818,7 +828,7 @@ int pskb_expand_head(struct sk_buff *skb, int nhead, int ntail,
         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
                 get_page(skb_shinfo(skb)->frags[i].page);
 
-        if (skb_shinfo(skb)->frag_list)
+        if (skb_has_frags(skb))
                 skb_clone_fraglist(skb);
 
         skb_release_data(skb);
@@ -1090,7 +1100,7 @@ drop_pages:
                 for (; i < nfrags; i++)
                         put_page(skb_shinfo(skb)->frags[i].page);
 
-                if (skb_shinfo(skb)->frag_list)
+                if (skb_has_frags(skb))
                         skb_drop_fraglist(skb);
                 goto done;
         }
@@ -1185,7 +1195,7 @@ unsigned char *__pskb_pull_tail(struct sk_buff *skb, int delta)
         /* Optimization: no fragments, no reasons to preestimate
          * size of pulled pages. Superb.
          */
-        if (!skb_shinfo(skb)->frag_list)
+        if (!skb_has_frags(skb))
                 goto pull_pages;
 
         /* Estimate size of pulled pages. */
@@ -1282,8 +1292,9 @@ EXPORT_SYMBOL(__pskb_pull_tail);
 
 int skb_copy_bits(const struct sk_buff *skb, int offset, void *to, int len)
 {
-        int i, copy;
         int start = skb_headlen(skb);
+        struct sk_buff *frag_iter;
+        int i, copy;
 
         if (offset > (int)skb->len - len)
                 goto fault;
@@ -1325,28 +1336,23 @@ int skb_copy_bits(const struct sk_buff *skb, int offset, void *to, int len)
                 start = end;
         }
 
-        if (skb_shinfo(skb)->frag_list) {
-                struct sk_buff *list = skb_shinfo(skb)->frag_list;
+        skb_walk_frags(skb, frag_iter) {
+                int end;
 
-                for (; list; list = list->next) {
-                        int end;
-
-                        WARN_ON(start > offset + len);
-
-                        end = start + list->len;
-                        if ((copy = end - offset) > 0) {
-                                if (copy > len)
-                                        copy = len;
-                                if (skb_copy_bits(list, offset - start,
-                                                  to, copy))
-                                        goto fault;
-                                if ((len -= copy) == 0)
-                                        return 0;
-                                offset += copy;
-                                to     += copy;
-                        }
-                        start = end;
+                WARN_ON(start > offset + len);
+
+                end = start + frag_iter->len;
+                if ((copy = end - offset) > 0) {
+                        if (copy > len)
+                                copy = len;
+                        if (skb_copy_bits(frag_iter, offset - start, to, copy))
+                                goto fault;
+                        if ((len -= copy) == 0)
+                                return 0;
+                        offset += copy;
+                        to     += copy;
                 }
+                start = end;
         }
         if (!len)
                 return 0;
@@ -1531,6 +1537,7 @@ int skb_splice_bits(struct sk_buff *skb, unsigned int offset,
                 .ops = &sock_pipe_buf_ops,
                 .spd_release = sock_spd_release,
         };
+        struct sk_buff *frag_iter;
         struct sock *sk = skb->sk;
 
         /*
@@ -1545,13 +1552,11 @@ int skb_splice_bits(struct sk_buff *skb, unsigned int offset,
         /*
          * now see if we have a frag_list to map
          */
-        if (skb_shinfo(skb)->frag_list) {
-                struct sk_buff *list = skb_shinfo(skb)->frag_list;
-
-                for (; list && tlen; list = list->next) {
-                        if (__skb_splice_bits(list, &offset, &tlen, &spd, sk))
-                                break;
-                }
+        skb_walk_frags(skb, frag_iter) {
+                if (!tlen)
+                        break;
+                if (__skb_splice_bits(frag_iter, &offset, &tlen, &spd, sk))
+                        break;
         }
 
 done:
@@ -1590,8 +1595,9 @@ done:
 
 int skb_store_bits(struct sk_buff *skb, int offset, const void *from, int len)
 {
-        int i, copy;
         int start = skb_headlen(skb);
+        struct sk_buff *frag_iter;
+        int i, copy;
 
         if (offset > (int)skb->len - len)
                 goto fault;
@@ -1632,28 +1638,24 @@ int skb_store_bits(struct sk_buff *skb, int offset, const void *from, int len)
                 start = end;
         }
 
-        if (skb_shinfo(skb)->frag_list) {
-                struct sk_buff *list = skb_shinfo(skb)->frag_list;
+        skb_walk_frags(skb, frag_iter) {
+                int end;
 
-                for (; list; list = list->next) {
-                        int end;
-
-                        WARN_ON(start > offset + len);
-
-                        end = start + list->len;
-                        if ((copy = end - offset) > 0) {
-                                if (copy > len)
-                                        copy = len;
-                                if (skb_store_bits(list, offset - start,
-                                                   from, copy))
-                                        goto fault;
-                                if ((len -= copy) == 0)
-                                        return 0;
-                                offset += copy;
-                                from += copy;
-                        }
-                        start = end;
+                WARN_ON(start > offset + len);
+
+                end = start + frag_iter->len;
+                if ((copy = end - offset) > 0) {
+                        if (copy > len)
+                                copy = len;
+                        if (skb_store_bits(frag_iter, offset - start,
+                                           from, copy))
+                                goto fault;
+                        if ((len -= copy) == 0)
+                                return 0;
+                        offset += copy;
+                        from += copy;
                 }
+                start = end;
         }
         if (!len)
                 return 0;
@@ -1670,6 +1672,7 @@ __wsum skb_checksum(const struct sk_buff *skb, int offset,
 {
         int start = skb_headlen(skb);
         int i, copy = start - offset;
+        struct sk_buff *frag_iter;
         int pos = 0;
 
         /* Checksum header. */
@@ -1709,29 +1712,25 @@ __wsum skb_checksum(const struct sk_buff *skb, int offset,
                 start = end;
         }
 
-        if (skb_shinfo(skb)->frag_list) {
-                struct sk_buff *list = skb_shinfo(skb)->frag_list;
+        skb_walk_frags(skb, frag_iter) {
+                int end;
 
-                for (; list; list = list->next) {
-                        int end;
-
-                        WARN_ON(start > offset + len);
-
-                        end = start + list->len;
-                        if ((copy = end - offset) > 0) {
-                                __wsum csum2;
-                                if (copy > len)
-                                        copy = len;
-                                csum2 = skb_checksum(list, offset - start,
-                                                     copy, 0);
-                                csum = csum_block_add(csum, csum2, pos);
-                                if ((len -= copy) == 0)
-                                        return csum;
-                                offset += copy;
-                                pos    += copy;
-                        }
-                        start = end;
+                WARN_ON(start > offset + len);
+
+                end = start + frag_iter->len;
+                if ((copy = end - offset) > 0) {
+                        __wsum csum2;
+                        if (copy > len)
+                                copy = len;
+                        csum2 = skb_checksum(frag_iter, offset - start,
+                                             copy, 0);
+                        csum = csum_block_add(csum, csum2, pos);
+                        if ((len -= copy) == 0)
+                                return csum;
+                        offset += copy;
+                        pos    += copy;
                 }
+                start = end;
         }
         BUG_ON(len);
 
@@ -1746,6 +1745,7 @@ __wsum skb_copy_and_csum_bits(const struct sk_buff *skb, int offset,
 {
         int start = skb_headlen(skb);
         int i, copy = start - offset;
+        struct sk_buff *frag_iter;
         int pos = 0;
 
         /* Copy header. */
@@ -1790,31 +1790,27 @@ __wsum skb_copy_and_csum_bits(const struct sk_buff *skb, int offset,
                 start = end;
         }
 
-        if (skb_shinfo(skb)->frag_list) {
-                struct sk_buff *list = skb_shinfo(skb)->frag_list;
+        skb_walk_frags(skb, frag_iter) {
+                __wsum csum2;
+                int end;
 
-                for (; list; list = list->next) {
-                        __wsum csum2;
-                        int end;
-
-                        WARN_ON(start > offset + len);
-
-                        end = start + list->len;
-                        if ((copy = end - offset) > 0) {
-                                if (copy > len)
-                                        copy = len;
-                                csum2 = skb_copy_and_csum_bits(list,
-                                                               offset - start,
-                                                               to, copy, 0);
-                                csum = csum_block_add(csum, csum2, pos);
-                                if ((len -= copy) == 0)
-                                        return csum;
-                                offset += copy;
-                                to     += copy;
-                                pos    += copy;
-                        }
-                        start = end;
+                WARN_ON(start > offset + len);
+
+                end = start + frag_iter->len;
+                if ((copy = end - offset) > 0) {
+                        if (copy > len)
+                                copy = len;
+                        csum2 = skb_copy_and_csum_bits(frag_iter,
+                                                       offset - start,
+                                                       to, copy, 0);
+                        csum = csum_block_add(csum, csum2, pos);
+                        if ((len -= copy) == 0)
+                                return csum;
+                        offset += copy;
+                        to     += copy;
+                        pos    += copy;
                 }
+                start = end;
         }
         BUG_ON(len);
         return csum;
@@ -2324,8 +2320,7 @@ next_skb:
                 st->frag_data = NULL;
         }
 
-        if (st->root_skb == st->cur_skb &&
-            skb_shinfo(st->root_skb)->frag_list) {
+        if (st->root_skb == st->cur_skb && skb_has_frags(st->root_skb)) {
                 st->cur_skb = skb_shinfo(st->root_skb)->frag_list;
                 st->frag_idx = 0;
                 goto next_skb;
@@ -2636,7 +2631,7 @@ struct sk_buff *skb_segment(struct sk_buff *skb, int features)
                         } else
                                 skb_get(fskb2);
 
-                        BUG_ON(skb_shinfo(nskb)->frag_list);
+                        SKB_FRAG_ASSERT(nskb);
                         skb_shinfo(nskb)->frag_list = fskb2;
                 }
 
@@ -2661,30 +2656,40 @@ int skb_gro_receive(struct sk_buff **head, struct sk_buff *skb)
 {
         struct sk_buff *p = *head;
         struct sk_buff *nskb;
+        struct skb_shared_info *skbinfo = skb_shinfo(skb);
+        struct skb_shared_info *pinfo = skb_shinfo(p);
         unsigned int headroom;
         unsigned int len = skb_gro_len(skb);
+        unsigned int offset = skb_gro_offset(skb);
+        unsigned int headlen = skb_headlen(skb);
 
         if (p->len + len >= 65536)
                 return -E2BIG;
 
-        if (skb_shinfo(p)->frag_list)
+        if (pinfo->frag_list)
                 goto merge;
-        else if (skb_headlen(skb) <= skb_gro_offset(skb)) {
-                if (skb_shinfo(p)->nr_frags + skb_shinfo(skb)->nr_frags >
-                    MAX_SKB_FRAGS)
+        else if (headlen <= offset) {
+                skb_frag_t *frag;
+                skb_frag_t *frag2;
+                int i = skbinfo->nr_frags;
+                int nr_frags = pinfo->nr_frags + i;
+
+                offset -= headlen;
+
+                if (nr_frags > MAX_SKB_FRAGS)
                         return -E2BIG;
 
-                skb_shinfo(skb)->frags[0].page_offset +=
-                        skb_gro_offset(skb) - skb_headlen(skb);
-                skb_shinfo(skb)->frags[0].size -=
-                        skb_gro_offset(skb) - skb_headlen(skb);
+                pinfo->nr_frags = nr_frags;
+                skbinfo->nr_frags = 0;
 
-                memcpy(skb_shinfo(p)->frags + skb_shinfo(p)->nr_frags,
-                       skb_shinfo(skb)->frags,
-                       skb_shinfo(skb)->nr_frags * sizeof(skb_frag_t));
+                frag = pinfo->frags + nr_frags;
+                frag2 = skbinfo->frags + i;
+                do {
+                        *--frag = *--frag2;
+                } while (--i);
 
-                skb_shinfo(p)->nr_frags += skb_shinfo(skb)->nr_frags;
-                skb_shinfo(skb)->nr_frags = 0;
+                frag->page_offset += offset;
+                frag->size -= offset;
 
                 skb->truesize -= skb->data_len;
                 skb->len -= skb->data_len;
@@ -2715,7 +2720,7 @@ int skb_gro_receive(struct sk_buff **head, struct sk_buff *skb)
 
         *NAPI_GRO_CB(nskb) = *NAPI_GRO_CB(p);
         skb_shinfo(nskb)->frag_list = p;
-        skb_shinfo(nskb)->gso_size = skb_shinfo(p)->gso_size;
+        skb_shinfo(nskb)->gso_size = pinfo->gso_size;
         skb_header_release(p);
         nskb->prev = p;
 
@@ -2730,16 +2735,13 @@ int skb_gro_receive(struct sk_buff **head, struct sk_buff *skb)
         p = nskb;
 
 merge:
-        if (skb_gro_offset(skb) > skb_headlen(skb)) {
-                skb_shinfo(skb)->frags[0].page_offset +=
-                        skb_gro_offset(skb) - skb_headlen(skb);
-                skb_shinfo(skb)->frags[0].size -=
-                        skb_gro_offset(skb) - skb_headlen(skb);
-                skb_gro_reset_offset(skb);
-                skb_gro_pull(skb, skb_headlen(skb));
+        if (offset > headlen) {
+                skbinfo->frags[0].page_offset += offset - headlen;
+                skbinfo->frags[0].size -= offset - headlen;
+                offset = headlen;
         }
 
-        __skb_pull(skb, skb_gro_offset(skb));
+        __skb_pull(skb, offset);
 
         p->prev->next = skb;
         p->prev = skb;
@@ -2786,6 +2788,7 @@ __skb_to_sgvec(struct sk_buff *skb, struct scatterlist *sg, int offset, int len)
 {
         int start = skb_headlen(skb);
         int i, copy = start - offset;
+        struct sk_buff *frag_iter;
         int elt = 0;
 
         if (copy > 0) {
@@ -2819,26 +2822,22 @@ __skb_to_sgvec(struct sk_buff *skb, struct scatterlist *sg, int offset, int len)
                 start = end;
         }
 
-        if (skb_shinfo(skb)->frag_list) {
-                struct sk_buff *list = skb_shinfo(skb)->frag_list;
-
-                for (; list; list = list->next) {
-                        int end;
+        skb_walk_frags(skb, frag_iter) {
+                int end;
 
-                        WARN_ON(start > offset + len);
+                WARN_ON(start > offset + len);
 
-                        end = start + list->len;
-                        if ((copy = end - offset) > 0) {
-                                if (copy > len)
-                                        copy = len;
-                                elt += __skb_to_sgvec(list, sg+elt, offset - start,
-                                                      copy);
-                                if ((len -= copy) == 0)
-                                        return elt;
-                                offset += copy;
-                        }
-                        start = end;
+                end = start + frag_iter->len;
+                if ((copy = end - offset) > 0) {
+                        if (copy > len)
+                                copy = len;
+                        elt += __skb_to_sgvec(frag_iter, sg+elt, offset - start,
+                                              copy);
+                        if ((len -= copy) == 0)
+                                return elt;
+                        offset += copy;
                 }
+                start = end;
         }
         BUG_ON(len);
         return elt;
@@ -2886,7 +2885,7 @@ int skb_cow_data(struct sk_buff *skb, int tailbits, struct sk_buff **trailer)
                 return -ENOMEM;
 
         /* Easy case. Most of packets will go this way. */
-        if (!skb_shinfo(skb)->frag_list) {
+        if (!skb_has_frags(skb)) {
                 /* A little of trouble, not enough of space for trailer.
                  * This should not happen, when stack is tuned to generate
                  * good frames. OK, on miss we reallocate and reserve even more
@@ -2921,7 +2920,7 @@ int skb_cow_data(struct sk_buff *skb, int tailbits, struct sk_buff **trailer)
 
                 if (skb1->next == NULL && tailbits) {
                         if (skb_shinfo(skb1)->nr_frags ||
-                            skb_shinfo(skb1)->frag_list ||
+                            skb_has_frags(skb1) ||
                             skb_tailroom(skb1) < tailbits)
                                 ntail = tailbits + 128;
                 }
@@ -2930,7 +2929,7 @@ int skb_cow_data(struct sk_buff *skb, int tailbits, struct sk_buff **trailer)
                     skb_cloned(skb1) ||
                     ntail ||
                     skb_shinfo(skb1)->nr_frags ||
-                    skb_shinfo(skb1)->frag_list) {
+                    skb_has_frags(skb1)) {
                         struct sk_buff *skb2;
 
                         /* Fuck, we are miserable poor guys... */
@@ -3016,12 +3015,12 @@ EXPORT_SYMBOL_GPL(skb_tstamp_tx);
  */
 bool skb_partial_csum_set(struct sk_buff *skb, u16 start, u16 off)
 {
-        if (unlikely(start > skb->len - 2) ||
-            unlikely((int)start + off > skb->len - 2)) {
+        if (unlikely(start > skb_headlen(skb)) ||
+            unlikely((int)start + off > skb_headlen(skb) - 2)) {
                 if (net_ratelimit())
                         printk(KERN_WARNING
                                "bad partial csum: csum=%u/%u len=%u\n",
-                               start, off, skb->len);
+                               start, off, skb_headlen(skb));
                 return false;
         }
         skb->ip_summed = CHECKSUM_PARTIAL;
diff --git a/net/core/sock.c b/net/core/sock.c
index 7dbf3ffb35cc..b0ba569bc973 100644
--- a/net/core/sock.c
+++ b/net/core/sock.c
@@ -155,6 +155,7 @@ static const char *af_family_key_strings[AF_MAX+1] = {
   "sk_lock-27"       , "sk_lock-28"          , "sk_lock-AF_CAN"      ,
   "sk_lock-AF_TIPC"  , "sk_lock-AF_BLUETOOTH", "sk_lock-IUCV"        ,
   "sk_lock-AF_RXRPC" , "sk_lock-AF_ISDN"     , "sk_lock-AF_PHONET"   ,
+  "sk_lock-AF_IEEE802154",
   "sk_lock-AF_MAX"
 };
 static const char *af_family_slock_key_strings[AF_MAX+1] = {
@@ -170,6 +171,7 @@ static const char *af_family_slock_key_strings[AF_MAX+1] = {
   "slock-27"       , "slock-28"          , "slock-AF_CAN"      ,
   "slock-AF_TIPC"  , "slock-AF_BLUETOOTH", "slock-AF_IUCV"     ,
   "slock-AF_RXRPC" , "slock-AF_ISDN"     , "slock-AF_PHONET"   ,
+  "slock-AF_IEEE802154",
   "slock-AF_MAX"
 };
 static const char *af_family_clock_key_strings[AF_MAX+1] = {
@@ -185,6 +187,7 @@ static const char *af_family_clock_key_strings[AF_MAX+1] = {
   "clock-27"       , "clock-28"          , "clock-AF_CAN"      ,
   "clock-AF_TIPC"  , "clock-AF_BLUETOOTH", "clock-AF_IUCV"     ,
   "clock-AF_RXRPC" , "clock-AF_ISDN"     , "clock-AF_PHONET"   ,
+  "clock-AF_IEEE802154",
   "clock-AF_MAX"
 };
 
@@ -212,6 +215,7 @@ __u32 sysctl_rmem_default __read_mostly = SK_RMEM_MAX;
 
 /* Maximal space eaten by iovec or ancilliary data plus some space */
 int sysctl_optmem_max __read_mostly = sizeof(unsigned long)*(2*UIO_MAXIOV+512);
+EXPORT_SYMBOL(sysctl_optmem_max);
 
 static int sock_set_timeout(long *timeo_p, char __user *optval, int optlen)
 {
@@ -444,7 +448,7 @@ static inline void sock_valbool_flag(struct sock *sk, int bit, int valbool)
 int sock_setsockopt(struct socket *sock, int level, int optname,
                     char __user *optval, int optlen)
 {
-        struct sock *sk=sock->sk;
+        struct sock *sk = sock->sk;
         int val;
         int valbool;
         struct linger ling;
@@ -463,15 +467,15 @@ int sock_setsockopt(struct socket *sock, int level, int optname,
         if (get_user(val, (int __user *)optval))
                 return -EFAULT;
 
-        valbool = val?1:0;
+        valbool = val ? 1 : 0;
 
         lock_sock(sk);
 
-        switch(optname) {
+        switch (optname) {
         case SO_DEBUG:
-                if (val && !capable(CAP_NET_ADMIN)) {
+                if (val && !capable(CAP_NET_ADMIN))
                         ret = -EACCES;
-                } else
+                else
                         sock_valbool_flag(sk, SOCK_DBG, valbool);
                 break;
         case SO_REUSEADDR:
@@ -582,7 +586,7 @@ set_rcvbuf:
                         ret = -EINVAL;  /* 1003.1g */
                         break;
                 }
-                if (copy_from_user(&ling,optval,sizeof(ling))) {
+                if (copy_from_user(&ling, optval, sizeof(ling))) {
                         ret = -EFAULT;
                         break;
                 }
@@ -690,9 +694,8 @@ set_rcvbuf:
         case SO_MARK:
                 if (!capable(CAP_NET_ADMIN))
                         ret = -EPERM;
-                else {
+                else
                         sk->sk_mark = val;
-                }
                 break;
 
                 /* We implement the SO_SNDLOWAT etc to
@@ -704,6 +707,7 @@ set_rcvbuf:
         release_sock(sk);
         return ret;
 }
+EXPORT_SYMBOL(sock_setsockopt);
 
 
 int sock_getsockopt(struct socket *sock, int level, int optname,
@@ -727,7 +731,7 @@ int sock_getsockopt(struct socket *sock, int level, int optname,
 
         memset(&v, 0, sizeof(v));
 
-        switch(optname) {
+        switch (optname) {
         case SO_DEBUG:
                 v.val = sock_flag(sk, SOCK_DBG);
                 break;
@@ -762,7 +766,7 @@ int sock_getsockopt(struct socket *sock, int level, int optname,
 
         case SO_ERROR:
                 v.val = -sock_error(sk);
-                if (v.val==0)
+                if (v.val == 0)
                         v.val = xchg(&sk->sk_err_soft, 0);
                 break;
 
@@ -816,7 +820,7 @@ int sock_getsockopt(struct socket *sock, int level, int optname,
                 break;
 
         case SO_RCVTIMEO:
-                lv=sizeof(struct timeval);
+                lv = sizeof(struct timeval);
                 if (sk->sk_rcvtimeo == MAX_SCHEDULE_TIMEOUT) {
                         v.tm.tv_sec = 0;
                         v.tm.tv_usec = 0;
@@ -827,7 +831,7 @@ int sock_getsockopt(struct socket *sock, int level, int optname,
                 break;
 
         case SO_SNDTIMEO:
-                lv=sizeof(struct timeval);
+                lv = sizeof(struct timeval);
                 if (sk->sk_sndtimeo == MAX_SCHEDULE_TIMEOUT) {
                         v.tm.tv_sec = 0;
                         v.tm.tv_usec = 0;
@@ -842,7 +846,7 @@ int sock_getsockopt(struct socket *sock, int level, int optname,
                 break;
 
         case SO_SNDLOWAT:
-                v.val=1;
+                v.val = 1;
                 break;
 
         case SO_PASSCRED:
@@ -941,6 +945,8 @@ static struct sock *sk_prot_alloc(struct proto *prot, gfp_t priority,
                 sk = kmalloc(prot->obj_size, priority);
 
         if (sk != NULL) {
+                kmemcheck_annotate_bitfield(sk, flags);
+
                 if (security_sk_alloc(sk, family, priority))
                         goto out_free;
 
@@ -1002,8 +1008,9 @@ struct sock *sk_alloc(struct net *net, int family, gfp_t priority,
 
         return sk;
 }
+EXPORT_SYMBOL(sk_alloc);
 
-void sk_free(struct sock *sk)
+static void __sk_free(struct sock *sk)
 {
         struct sk_filter *filter;
 
@@ -1027,6 +1034,18 @@ void sk_free(struct sock *sk)
         sk_prot_free(sk->sk_prot_creator, sk);
 }
 
+void sk_free(struct sock *sk)
+{
+        /*
+         * We substract one from sk_wmem_alloc and can know if
+         * some packets are still in some tx queue.
+         * If not null, sock_wfree() will call __sk_free(sk) later
+         */
+        if (atomic_dec_and_test(&sk->sk_wmem_alloc))
+                __sk_free(sk);
+}
+EXPORT_SYMBOL(sk_free);
+
 /*
  * Last sock_put should drop referrence to sk->sk_net. It has already
  * been dropped in sk_change_net. Taking referrence to stopping namespace
@@ -1065,7 +1084,10 @@ struct sock *sk_clone(const struct sock *sk, const gfp_t priority)
                 newsk->sk_backlog.head  = newsk->sk_backlog.tail = NULL;
 
                 atomic_set(&newsk->sk_rmem_alloc, 0);
-                atomic_set(&newsk->sk_wmem_alloc, 0);
+                /*
+                 * sk_wmem_alloc set to one (see sk_free() and sock_wfree())
+                 */
+                atomic_set(&newsk->sk_wmem_alloc, 1);
                 atomic_set(&newsk->sk_omem_alloc, 0);
                 skb_queue_head_init(&newsk->sk_receive_queue);
                 skb_queue_head_init(&newsk->sk_write_queue);
@@ -1126,7 +1148,6 @@ struct sock *sk_clone(const struct sock *sk, const gfp_t priority)
 out:
         return newsk;
 }
-
 EXPORT_SYMBOL_GPL(sk_clone);
 
 void sk_setup_caps(struct sock *sk, struct dst_entry *dst)
@@ -1170,13 +1191,20 @@ void __init sk_init(void)
 void sock_wfree(struct sk_buff *skb)
 {
         struct sock *sk = skb->sk;
+        int res;
 
         /* In case it might be waiting for more memory. */
-        atomic_sub(skb->truesize, &sk->sk_wmem_alloc);
+        res = atomic_sub_return(skb->truesize, &sk->sk_wmem_alloc);
         if (!sock_flag(sk, SOCK_USE_WRITE_QUEUE))
                 sk->sk_write_space(sk);
-        sock_put(sk);
+        /*
+         * if sk_wmem_alloc reached 0, we are last user and should
+         * free this sock, as sk_free() call could not do it.
+         */
+        if (res == 0)
+                __sk_free(sk);
 }
+EXPORT_SYMBOL(sock_wfree);
 
 /*
  * Read buffer destructor automatically called from kfree_skb.
@@ -1188,6 +1216,7 @@ void sock_rfree(struct sk_buff *skb)
         atomic_sub(skb->truesize, &sk->sk_rmem_alloc);
         sk_mem_uncharge(skb->sk, skb->truesize);
 }
+EXPORT_SYMBOL(sock_rfree);
 
 
 int sock_i_uid(struct sock *sk)
@@ -1199,6 +1228,7 @@ int sock_i_uid(struct sock *sk)
         read_unlock(&sk->sk_callback_lock);
         return uid;
 }
+EXPORT_SYMBOL(sock_i_uid);
 
 unsigned long sock_i_ino(struct sock *sk)
 {
@@ -1209,6 +1239,7 @@ unsigned long sock_i_ino(struct sock *sk)
         read_unlock(&sk->sk_callback_lock);
         return ino;
 }
+EXPORT_SYMBOL(sock_i_ino);
 
 /*
  * Allocate a skb from the socket's send buffer.
@@ -1217,7 +1248,7 @@ struct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force,
                              gfp_t priority)
 {
         if (force || atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) {
-                struct sk_buff * skb = alloc_skb(size, priority);
+                struct sk_buff *skb = alloc_skb(size, priority);
                 if (skb) {
                         skb_set_owner_w(skb, sk);
                         return skb;
@@ -1225,6 +1256,7 @@ struct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force,
         }
         return NULL;
 }
+EXPORT_SYMBOL(sock_wmalloc);
 
 /*
  * Allocate a skb from the socket's receive buffer.
@@ -1261,6 +1293,7 @@ void *sock_kmalloc(struct sock *sk, int size, gfp_t priority)
         }
         return NULL;
 }
+EXPORT_SYMBOL(sock_kmalloc);
 
 /*
  * Free an option memory block.
@@ -1270,11 +1303,12 @@ void sock_kfree_s(struct sock *sk, void *mem, int size)
         kfree(mem);
         atomic_sub(size, &sk->sk_omem_alloc);
 }
+EXPORT_SYMBOL(sock_kfree_s);
 
 /* It is almost wait_for_tcp_memory minus release_sock/lock_sock.
    I think, these locks should be removed for datagram sockets.
  */
-static long sock_wait_for_wmem(struct sock * sk, long timeo)
+static long sock_wait_for_wmem(struct sock *sk, long timeo)
 {
         DEFINE_WAIT(wait);
 
@@ -1392,6 +1426,7 @@ struct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size,
 {
         return sock_alloc_send_pskb(sk, size, 0, noblock, errcode);
 }
+EXPORT_SYMBOL(sock_alloc_send_skb);
 
 static void __lock_sock(struct sock *sk)
 {
@@ -1460,7 +1495,6 @@ int sk_wait_data(struct sock *sk, long *timeo)
         finish_wait(sk->sk_sleep, &wait);
         return rc;
 }
-
 EXPORT_SYMBOL(sk_wait_data);
 
 /**
@@ -1541,7 +1575,6 @@ suppress_allocation:
         atomic_sub(amt, prot->memory_allocated);
         return 0;
 }
-
 EXPORT_SYMBOL(__sk_mem_schedule);
 
 /**
@@ -1560,7 +1593,6 @@ void __sk_mem_reclaim(struct sock *sk)
             (atomic_read(prot->memory_allocated) < prot->sysctl_mem[0]))
                 *prot->memory_pressure = 0;
 }
-
 EXPORT_SYMBOL(__sk_mem_reclaim);
 
 
@@ -1575,78 +1607,92 @@ int sock_no_bind(struct socket *sock, struct sockaddr *saddr, int len)
 {
         return -EOPNOTSUPP;
 }
+EXPORT_SYMBOL(sock_no_bind);
 
 int sock_no_connect(struct socket *sock, struct sockaddr *saddr,
                     int len, int flags)
 {
         return -EOPNOTSUPP;
 }
+EXPORT_SYMBOL(sock_no_connect);
 
 int sock_no_socketpair(struct socket *sock1, struct socket *sock2)
 {
         return -EOPNOTSUPP;
 }
+EXPORT_SYMBOL(sock_no_socketpair);
 
 int sock_no_accept(struct socket *sock, struct socket *newsock, int flags)
 {
         return -EOPNOTSUPP;
 }
+EXPORT_SYMBOL(sock_no_accept);
 
 int sock_no_getname(struct socket *sock, struct sockaddr *saddr,
                     int *len, int peer)
 {
         return -EOPNOTSUPP;
 }
+EXPORT_SYMBOL(sock_no_getname);
 
-unsigned int sock_no_poll(struct file * file, struct socket *sock, poll_table *pt)
+unsigned int sock_no_poll(struct file *file, struct socket *sock, poll_table *pt)
 {
         return 0;
 }
+EXPORT_SYMBOL(sock_no_poll);
 
 int sock_no_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 {
         return -EOPNOTSUPP;
 }
+EXPORT_SYMBOL(sock_no_ioctl);
 
 int sock_no_listen(struct socket *sock, int backlog)
 {
         return -EOPNOTSUPP;
 }
+EXPORT_SYMBOL(sock_no_listen);
 
 int sock_no_shutdown(struct socket *sock, int how)
 {
         return -EOPNOTSUPP;
 }
+EXPORT_SYMBOL(sock_no_shutdown);
 
 int sock_no_setsockopt(struct socket *sock, int level, int optname,
                     char __user *optval, int optlen)
 {
         return -EOPNOTSUPP;
 }
+EXPORT_SYMBOL(sock_no_setsockopt);
 
 int sock_no_getsockopt(struct socket *sock, int level, int optname,
                     char __user *optval, int __user *optlen)
 {
         return -EOPNOTSUPP;
 }
+EXPORT_SYMBOL(sock_no_getsockopt);
 
 int sock_no_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m,
                     size_t len)
 {
         return -EOPNOTSUPP;
 }
+EXPORT_SYMBOL(sock_no_sendmsg);
 
 int sock_no_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m,
                     size_t len, int flags)
 {
         return -EOPNOTSUPP;
 }
+EXPORT_SYMBOL(sock_no_recvmsg);
 
 int sock_no_mmap(struct file *file, struct socket *sock, struct vm_area_struct *vma)
 {
         /* Mirror missing mmap method error code */
         return -ENODEV;
 }
+EXPORT_SYMBOL(sock_no_mmap);
 
 ssize_t sock_no_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags)
 {
@@ -1660,6 +1706,7 @@ ssize_t sock_no_sendpage(struct socket *sock, struct page *page, int offset, siz
         kunmap(page);
         return res;
 }
+EXPORT_SYMBOL(sock_no_sendpage);
 
 /*
  *      Default Socket Callbacks
@@ -1723,6 +1770,7 @@ void sk_send_sigurg(struct sock *sk)
                 if (send_sigurg(&sk->sk_socket->file->f_owner))
                         sk_wake_async(sk, SOCK_WAKE_URG, POLL_PRI);
 }
+EXPORT_SYMBOL(sk_send_sigurg);
 
 void sk_reset_timer(struct sock *sk, struct timer_list* timer,
                     unsigned long expires)
@@ -1730,7 +1778,6 @@ void sk_reset_timer(struct sock *sk, struct timer_list* timer,
         if (!mod_timer(timer, expires))
                 sock_hold(sk);
 }
-
 EXPORT_SYMBOL(sk_reset_timer);
 
 void sk_stop_timer(struct sock *sk, struct timer_list* timer)
@@ -1738,7 +1785,6 @@ void sk_stop_timer(struct sock *sk, struct timer_list* timer)
         if (timer_pending(timer) && del_timer(timer))
                 __sock_put(sk);
 }
-
 EXPORT_SYMBOL(sk_stop_timer);
 
 void sock_init_data(struct socket *sock, struct sock *sk)
@@ -1795,8 +1841,10 @@ void sock_init_data(struct socket *sock, struct sock *sk)
         sk->sk_stamp = ktime_set(-1L, 0);
 
         atomic_set(&sk->sk_refcnt, 1);
+        atomic_set(&sk->sk_wmem_alloc, 1);
         atomic_set(&sk->sk_drops, 0);
 }
+EXPORT_SYMBOL(sock_init_data);
 
 void lock_sock_nested(struct sock *sk, int subclass)
 {
@@ -1812,7 +1860,6 @@ void lock_sock_nested(struct sock *sk, int subclass)
         mutex_acquire(&sk->sk_lock.dep_map, subclass, 0, _RET_IP_);
         local_bh_enable();
 }
-
 EXPORT_SYMBOL(lock_sock_nested);
 
 void release_sock(struct sock *sk)
@@ -1895,7 +1942,6 @@ int sock_common_getsockopt(struct socket *sock, int level, int optname,
 
         return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen);
 }
-
 EXPORT_SYMBOL(sock_common_getsockopt);
 
 #ifdef CONFIG_COMPAT
@@ -1925,7 +1971,6 @@ int sock_common_recvmsg(struct kiocb *iocb, struct socket *sock,
                 msg->msg_namelen = addr_len;
         return err;
 }
-
 EXPORT_SYMBOL(sock_common_recvmsg);
 
 /*
@@ -1938,7 +1983,6 @@ int sock_common_setsockopt(struct socket *sock, int level, int optname,
 
         return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen);
 }
-
 EXPORT_SYMBOL(sock_common_setsockopt);
 
 #ifdef CONFIG_COMPAT
@@ -1989,7 +2033,6 @@ void sk_common_release(struct sock *sk)
         sk_refcnt_debug_release(sk);
         sock_put(sk);
 }
-
 EXPORT_SYMBOL(sk_common_release);
 
 static DEFINE_RWLOCK(proto_list_lock);
@@ -2171,7 +2214,6 @@ out_free_sock_slab:
 out:
         return -ENOBUFS;
 }
-
 EXPORT_SYMBOL(proto_register);
 
 void proto_unregister(struct proto *prot)
@@ -2198,7 +2240,6 @@ void proto_unregister(struct proto *prot)
                 prot->twsk_prot->twsk_slab = NULL;
         }
 }
-
 EXPORT_SYMBOL(proto_unregister);
 
 #ifdef CONFIG_PROC_FS
@@ -2324,33 +2365,3 @@ static int __init proto_init(void)
 subsys_initcall(proto_init);
 
 #endif /* PROC_FS */
-
-EXPORT_SYMBOL(sk_alloc);
-EXPORT_SYMBOL(sk_free);
-EXPORT_SYMBOL(sk_send_sigurg);
-EXPORT_SYMBOL(sock_alloc_send_skb);
-EXPORT_SYMBOL(sock_init_data);
-EXPORT_SYMBOL(sock_kfree_s);
-EXPORT_SYMBOL(sock_kmalloc);
-EXPORT_SYMBOL(sock_no_accept);
-EXPORT_SYMBOL(sock_no_bind);
-EXPORT_SYMBOL(sock_no_connect);
-EXPORT_SYMBOL(sock_no_getname);
-EXPORT_SYMBOL(sock_no_getsockopt);
-EXPORT_SYMBOL(sock_no_ioctl);
-EXPORT_SYMBOL(sock_no_listen);
-EXPORT_SYMBOL(sock_no_mmap);
-EXPORT_SYMBOL(sock_no_poll);
-EXPORT_SYMBOL(sock_no_recvmsg);
-EXPORT_SYMBOL(sock_no_sendmsg);
-EXPORT_SYMBOL(sock_no_sendpage);
-EXPORT_SYMBOL(sock_no_setsockopt);
-EXPORT_SYMBOL(sock_no_shutdown);
-EXPORT_SYMBOL(sock_no_socketpair);
-EXPORT_SYMBOL(sock_rfree);
-EXPORT_SYMBOL(sock_setsockopt);
-EXPORT_SYMBOL(sock_wfree);
-EXPORT_SYMBOL(sock_wmalloc);
-EXPORT_SYMBOL(sock_i_uid);
-EXPORT_SYMBOL(sock_i_ino);
-EXPORT_SYMBOL(sysctl_optmem_max);
diff --git a/net/core/stream.c b/net/core/stream.c
index 8727cead64ad..a37debfeb1b2 100644
--- a/net/core/stream.c
+++ b/net/core/stream.c
@@ -33,7 +33,8 @@ void sk_stream_write_space(struct sock *sk)
                 clear_bit(SOCK_NOSPACE, &sock->flags);
 
                 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
-                        wake_up_interruptible(sk->sk_sleep);
+                        wake_up_interruptible_poll(sk->sk_sleep, POLLOUT |
+                                                POLLWRNORM | POLLWRBAND);
                 if (sock->fasync_list && !(sk->sk_shutdown & SEND_SHUTDOWN))
                         sock_wake_async(sock, SOCK_WAKE_SPACE, POLL_OUT);
         }
diff --git a/net/core/user_dma.c b/net/core/user_dma.c
index 164b090d5ac3..25d717ebc92e 100644
--- a/net/core/user_dma.c
+++ b/net/core/user_dma.c
@@ -51,6 +51,7 @@ int dma_skb_copy_datagram_iovec(struct dma_chan *chan,
 {
         int start = skb_headlen(skb);
         int i, copy = start - offset;
+        struct sk_buff *frag_iter;
         dma_cookie_t cookie = 0;
 
         /* Copy header. */
@@ -94,31 +95,28 @@ int dma_skb_copy_datagram_iovec(struct dma_chan *chan,
                 start = end;
         }
 
-        if (skb_shinfo(skb)->frag_list) {
-                struct sk_buff *list = skb_shinfo(skb)->frag_list;
-
-                for (; list; list = list->next) {
-                        int end;
-
-                        WARN_ON(start > offset + len);
-
-                        end = start + list->len;
-                        copy = end - offset;
-                        if (copy > 0) {
-                                if (copy > len)
-                                        copy = len;
-                                cookie = dma_skb_copy_datagram_iovec(chan, list,
-                                                offset - start, to, copy,
-                                                pinned_list);
-                                if (cookie < 0)
-                                        goto fault;
-                                len -= copy;
-                                if (len == 0)
-                                        goto end;
-                                offset += copy;
-                        }
-                        start = end;
+        skb_walk_frags(skb, frag_iter) {
+                int end;
+
+                WARN_ON(start > offset + len);
+
+                end = start + frag_iter->len;
+                copy = end - offset;
+                if (copy > 0) {
+                        if (copy > len)
+                                copy = len;
+                        cookie = dma_skb_copy_datagram_iovec(chan, frag_iter,
+                                                             offset - start,
+                                                             to, copy,
+                                                             pinned_list);
+                        if (cookie < 0)
+                                goto fault;
+                        len -= copy;
+                        if (len == 0)
+                                goto end;
+                        offset += copy;
                 }
+                start = end;
         }
 
 end:
diff --git a/net/dccp/ipv4.c b/net/dccp/ipv4.c
index d1dd95289b89..a0a36c9e6cce 100644
--- a/net/dccp/ipv4.c
+++ b/net/dccp/ipv4.c
@@ -452,7 +452,7 @@ static struct dst_entry* dccp_v4_route_skb(struct net *net, struct sock *sk,
                                            struct sk_buff *skb)
 {
         struct rtable *rt;
-        struct flowi fl = { .oif = skb->rtable->rt_iif,
+        struct flowi fl = { .oif = skb_rtable(skb)->rt_iif,
                             .nl_u = { .ip4_u =
                                       { .daddr = ip_hdr(skb)->saddr,
                                         .saddr = ip_hdr(skb)->daddr,
@@ -507,14 +507,14 @@ static void dccp_v4_ctl_send_reset(struct sock *sk, struct sk_buff *rxskb)
         const struct iphdr *rxiph;
         struct sk_buff *skb;
         struct dst_entry *dst;
-        struct net *net = dev_net(rxskb->dst->dev);
+        struct net *net = dev_net(skb_dst(rxskb)->dev);
         struct sock *ctl_sk = net->dccp.v4_ctl_sk;
 
         /* Never send a reset in response to a reset. */
         if (dccp_hdr(rxskb)->dccph_type == DCCP_PKT_RESET)
                 return;
 
-        if (rxskb->rtable->rt_type != RTN_LOCAL)
+        if (skb_rtable(rxskb)->rt_type != RTN_LOCAL)
                 return;
 
         dst = dccp_v4_route_skb(net, ctl_sk, rxskb);
@@ -528,7 +528,7 @@ static void dccp_v4_ctl_send_reset(struct sock *sk, struct sk_buff *rxskb)
         rxiph = ip_hdr(rxskb);
         dccp_hdr(skb)->dccph_checksum = dccp_v4_csum_finish(skb, rxiph->saddr,
                                                                  rxiph->daddr);
-        skb->dst = dst_clone(dst);
+        skb_dst_set(skb, dst_clone(dst));
 
         bh_lock_sock(ctl_sk);
         err = ip_build_and_send_pkt(skb, ctl_sk,
@@ -567,7 +567,7 @@ int dccp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
         struct dccp_skb_cb *dcb = DCCP_SKB_CB(skb);
 
         /* Never answer to DCCP_PKT_REQUESTs send to broadcast or multicast */
-        if (skb->rtable->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))
+        if (skb_rtable(skb)->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))
                 return 0;       /* discard, don't send a reset here */
 
         if (dccp_bad_service_code(sk, service)) {
diff --git a/net/dccp/ipv6.c b/net/dccp/ipv6.c
index b963f35c65f6..05ea7440d9e5 100644
--- a/net/dccp/ipv6.c
+++ b/net/dccp/ipv6.c
@@ -314,8 +314,9 @@ static void dccp_v6_ctl_send_reset(struct sock *sk, struct sk_buff *rxskb)
         struct ipv6hdr *rxip6h;
         struct sk_buff *skb;
         struct flowi fl;
-        struct net *net = dev_net(rxskb->dst->dev);
+        struct net *net = dev_net(skb_dst(rxskb)->dev);
         struct sock *ctl_sk = net->dccp.v6_ctl_sk;
+        struct dst_entry *dst;
 
         if (dccp_hdr(rxskb)->dccph_type == DCCP_PKT_RESET)
                 return;
@@ -342,8 +343,9 @@ static void dccp_v6_ctl_send_reset(struct sock *sk, struct sk_buff *rxskb)
         security_skb_classify_flow(rxskb, &fl);
 
         /* sk = NULL, but it is safe for now. RST socket required. */
-        if (!ip6_dst_lookup(ctl_sk, &skb->dst, &fl)) {
-                if (xfrm_lookup(net, &skb->dst, &fl, NULL, 0) >= 0) {
+        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);
                         DCCP_INC_STATS_BH(DCCP_MIB_OUTSEGS);
                         DCCP_INC_STATS_BH(DCCP_MIB_OUTRSTS);
diff --git a/net/dccp/output.c b/net/dccp/output.c
index 36bcc00654d3..c0e88c16d088 100644
--- a/net/dccp/output.c
+++ b/net/dccp/output.c
@@ -350,7 +350,7 @@ struct sk_buff *dccp_make_response(struct sock *sk, struct dst_entry *dst,
         /* Reserve space for headers. */
         skb_reserve(skb, sk->sk_prot->max_header);
 
-        skb->dst = dst_clone(dst);
+        skb_dst_set(skb, dst_clone(dst));
 
         dreq = dccp_rsk(req);
         if (inet_rsk(req)->acked)       /* increase ISS upon retransmission */
diff --git a/net/decnet/af_decnet.c b/net/decnet/af_decnet.c
index 9647d911f916..a5e3a593e472 100644
--- a/net/decnet/af_decnet.c
+++ b/net/decnet/af_decnet.c
@@ -1075,6 +1075,7 @@ static int dn_accept(struct socket *sock, struct socket *newsock, int flags)
         int err = 0;
         unsigned char type;
         long timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
+        struct dst_entry *dst;
 
         lock_sock(sk);
 
@@ -1102,8 +1103,9 @@ static int dn_accept(struct socket *sock, struct socket *newsock, int flags)
         }
         release_sock(sk);
 
-        dst_release(xchg(&newsk->sk_dst_cache, skb->dst));
-        skb->dst = NULL;
+        dst = skb_dst(skb);
+        dst_release(xchg(&newsk->sk_dst_cache, dst));
+        skb_dst_set(skb, NULL);
 
         DN_SK(newsk)->state        = DN_CR;
         DN_SK(newsk)->addrrem      = cb->src_port;
@@ -1250,14 +1252,8 @@ static int dn_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
                 if (skb) {
                         amount = skb->len;
                 } else {
-                        skb = sk->sk_receive_queue.next;
-                        for (;;) {
-                                if (skb ==
-                                    (struct sk_buff *)&sk->sk_receive_queue)
-                                        break;
+                        skb_queue_walk(&sk->sk_receive_queue, skb)
                                 amount += skb->len;
-                                skb = skb->next;
-                        }
                 }
                 release_sock(sk);
                 err = put_user(amount, (int __user *)arg);
@@ -1644,13 +1640,13 @@ static int __dn_getsockopt(struct socket *sock, int level,int optname, char __us
 
 static int dn_data_ready(struct sock *sk, struct sk_buff_head *q, int flags, int target)
 {
-        struct sk_buff *skb = q->next;
+        struct sk_buff *skb;
         int len = 0;
 
         if (flags & MSG_OOB)
                 return !skb_queue_empty(q) ? 1 : 0;
 
-        while(skb != (struct sk_buff *)q) {
+        skb_queue_walk(q, skb) {
                 struct dn_skb_cb *cb = DN_SKB_CB(skb);
                 len += skb->len;
 
@@ -1666,8 +1662,6 @@ static int dn_data_ready(struct sock *sk, struct sk_buff_head *q, int flags, int
                 /* minimum data length for read exceeded */
                 if (len >= target)
                         return 1;
-
-                skb = skb->next;
         }
 
         return 0;
@@ -1683,7 +1677,7 @@ static int dn_recvmsg(struct kiocb *iocb, struct socket *sock,
         size_t target = size > 1 ? 1 : 0;
         size_t copied = 0;
         int rv = 0;
-        struct sk_buff *skb, *nskb;
+        struct sk_buff *skb, *n;
         struct dn_skb_cb *cb = NULL;
         unsigned char eor = 0;
         long timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
@@ -1758,7 +1752,7 @@ static int dn_recvmsg(struct kiocb *iocb, struct socket *sock,
                 finish_wait(sk->sk_sleep, &wait);
         }
 
-        for(skb = queue->next; skb != (struct sk_buff *)queue; skb = nskb) {
+        skb_queue_walk_safe(queue, skb, n) {
                 unsigned int chunk = skb->len;
                 cb = DN_SKB_CB(skb);
 
@@ -1775,7 +1769,6 @@ static int dn_recvmsg(struct kiocb *iocb, struct socket *sock,
                         skb_pull(skb, chunk);
 
                 eor = cb->nsp_flags & 0x40;
-                nskb = skb->next;
 
                 if (skb->len == 0) {
                         skb_unlink(skb, queue);
diff --git a/net/decnet/dn_neigh.c b/net/decnet/dn_neigh.c
index 05b5aa05e50e..923786bd6d01 100644
--- a/net/decnet/dn_neigh.c
+++ b/net/decnet/dn_neigh.c
@@ -204,7 +204,7 @@ static void dn_short_error_report(struct neighbour *neigh, struct sk_buff *skb)
 
 static int dn_neigh_output_packet(struct sk_buff *skb)
 {
-        struct dst_entry *dst = skb->dst;
+        struct dst_entry *dst = skb_dst(skb);
         struct dn_route *rt = (struct dn_route *)dst;
         struct neighbour *neigh = dst->neighbour;
         struct net_device *dev = neigh->dev;
@@ -224,7 +224,7 @@ static int dn_neigh_output_packet(struct sk_buff *skb)
 
 static int dn_long_output(struct sk_buff *skb)
 {
-        struct dst_entry *dst = skb->dst;
+        struct dst_entry *dst = skb_dst(skb);
         struct neighbour *neigh = dst->neighbour;
         struct net_device *dev = neigh->dev;
         int headroom = dev->hard_header_len + sizeof(struct dn_long_packet) + 3;
@@ -270,7 +270,7 @@ static int dn_long_output(struct sk_buff *skb)
 
 static int dn_short_output(struct sk_buff *skb)
 {
-        struct dst_entry *dst = skb->dst;
+        struct dst_entry *dst = skb_dst(skb);
         struct neighbour *neigh = dst->neighbour;
         struct net_device *dev = neigh->dev;
         int headroom = dev->hard_header_len + sizeof(struct dn_short_packet) + 2;
@@ -313,7 +313,7 @@ static int dn_short_output(struct sk_buff *skb)
  */
 static int dn_phase3_output(struct sk_buff *skb)
 {
-        struct dst_entry *dst = skb->dst;
+        struct dst_entry *dst = skb_dst(skb);
         struct neighbour *neigh = dst->neighbour;
         struct net_device *dev = neigh->dev;
         int headroom = dev->hard_header_len + sizeof(struct dn_short_packet) + 2;
diff --git a/net/decnet/dn_nsp_in.c b/net/decnet/dn_nsp_in.c
index 5d8a2a56fd39..932408dca86d 100644
--- a/net/decnet/dn_nsp_in.c
+++ b/net/decnet/dn_nsp_in.c
@@ -578,6 +578,7 @@ out:
 static __inline__ int dn_queue_skb(struct sock *sk, struct sk_buff *skb, int sig, struct sk_buff_head *queue)
 {
         int err;
+        int skb_len;
 
         /* Cast skb->rcvbuf to unsigned... It's pointless, but reduces
            number of warnings when compiling with -W --ANK
@@ -592,22 +593,12 @@ static __inline__ int dn_queue_skb(struct sock *sk, struct sk_buff *skb, int sig
         if (err)
                 goto out;
 
+        skb_len = skb->len;
         skb_set_owner_r(skb, sk);
         skb_queue_tail(queue, skb);
 
-        /* This code only runs from BH or BH protected context.
-         * Therefore the plain read_lock is ok here. -DaveM
-         */
-        read_lock(&sk->sk_callback_lock);
-        if (!sock_flag(sk, SOCK_DEAD)) {
-                struct socket *sock = sk->sk_socket;
-                wake_up_interruptible(sk->sk_sleep);
-                if (sock && sock->fasync_list &&
-                    !test_bit(SOCK_ASYNC_WAITDATA, &sock->flags))
-                        __kill_fasync(sock->fasync_list, sig,
-                                    (sig == SIGURG) ? POLL_PRI : POLL_IN);
-        }
-        read_unlock(&sk->sk_callback_lock);
+        if (!sock_flag(sk, SOCK_DEAD))
+                sk->sk_data_ready(sk, skb_len);
 out:
         return err;
 }
diff --git a/net/decnet/dn_nsp_out.c b/net/decnet/dn_nsp_out.c
index 2013c25b7f5a..a65e929ce76c 100644
--- a/net/decnet/dn_nsp_out.c
+++ b/net/decnet/dn_nsp_out.c
@@ -85,7 +85,7 @@ static void dn_nsp_send(struct sk_buff *skb)
         dst = sk_dst_check(sk, 0);
         if (dst) {
 try_again:
-                skb->dst = dst;
+                skb_dst_set(skb, dst);
                 dst_output(skb);
                 return;
         }
@@ -382,7 +382,7 @@ int dn_nsp_check_xmit_queue(struct sock *sk, struct sk_buff *skb, struct sk_buff
 {
         struct dn_skb_cb *cb = DN_SKB_CB(skb);
         struct dn_scp *scp = DN_SK(sk);
-        struct sk_buff *skb2, *list, *ack = NULL;
+        struct sk_buff *skb2, *n, *ack = NULL;
         int wakeup = 0;
         int try_retrans = 0;
         unsigned long reftime = cb->stamp;
@@ -390,9 +390,7 @@ int dn_nsp_check_xmit_queue(struct sock *sk, struct sk_buff *skb, struct sk_buff
         unsigned short xmit_count;
         unsigned short segnum;
 
-        skb2 = q->next;
-        list = (struct sk_buff *)q;
-        while(list != skb2) {
+        skb_queue_walk_safe(q, skb2, n) {
                 struct dn_skb_cb *cb2 = DN_SKB_CB(skb2);
 
                 if (dn_before_or_equal(cb2->segnum, acknum))
@@ -400,8 +398,6 @@ int dn_nsp_check_xmit_queue(struct sock *sk, struct sk_buff *skb, struct sk_buff
 
                 /* printk(KERN_DEBUG "ack: %s %04x %04x\n", ack ? "ACK" : "SKIP", (int)cb2->segnum, (int)acknum); */
 
-                skb2 = skb2->next;
-
                 if (ack == NULL)
                         continue;
 
@@ -586,7 +582,7 @@ static __inline__ void dn_nsp_do_disc(struct sock *sk, unsigned char msgflg,
          * to be able to send disc packets out which have no socket
          * associations.
          */
-        skb->dst = dst_clone(dst);
+        skb_dst_set(skb, dst_clone(dst));
         dst_output(skb);
 }
 
@@ -615,7 +611,7 @@ void dn_nsp_return_disc(struct sk_buff *skb, unsigned char msgflg,
         int ddl = 0;
         gfp_t gfp = GFP_ATOMIC;
 
-        dn_nsp_do_disc(NULL, msgflg, reason, gfp, skb->dst, ddl,
+        dn_nsp_do_disc(NULL, msgflg, reason, gfp, skb_dst(skb), ddl,
                         NULL, cb->src_port, cb->dst_port);
 }
 
diff --git a/net/decnet/dn_route.c b/net/decnet/dn_route.c
index 0cc4394117df..1d6ca8a98dc6 100644
--- a/net/decnet/dn_route.c
+++ b/net/decnet/dn_route.c
@@ -678,7 +678,7 @@ out:
 
 static int dn_output(struct sk_buff *skb)
 {
-        struct dst_entry *dst = skb->dst;
+        struct dst_entry *dst = skb_dst(skb);
         struct dn_route *rt = (struct dn_route *)dst;
         struct net_device *dev = dst->dev;
         struct dn_skb_cb *cb = DN_SKB_CB(skb);
@@ -717,7 +717,7 @@ error:
 static int dn_forward(struct sk_buff *skb)
 {
         struct dn_skb_cb *cb = DN_SKB_CB(skb);
-        struct dst_entry *dst = skb->dst;
+        struct dst_entry *dst = skb_dst(skb);
         struct dn_dev *dn_db = dst->dev->dn_ptr;
         struct dn_route *rt;
         struct neighbour *neigh = dst->neighbour;
@@ -730,7 +730,7 @@ static int dn_forward(struct sk_buff *skb)
                 goto drop;
 
         /* Ensure that we have enough space for headers */
-        rt = (struct dn_route *)skb->dst;
+        rt = (struct dn_route *)skb_dst(skb);
         header_len = dn_db->use_long ? 21 : 6;
         if (skb_cow(skb, LL_RESERVED_SPACE(rt->u.dst.dev)+header_len))
                 goto drop;
@@ -1392,7 +1392,8 @@ make_route:
                 goto e_neighbour;
 
         hash = dn_hash(rt->fl.fld_src, rt->fl.fld_dst);
-        dn_insert_route(rt, hash, (struct dn_route **)&skb->dst);
+        dn_insert_route(rt, hash, &rt);
+        skb_dst_set(skb, &rt->u.dst);
 
 done:
         if (neigh)
@@ -1424,7 +1425,7 @@ static int dn_route_input(struct sk_buff *skb)
         struct dn_skb_cb *cb = DN_SKB_CB(skb);
         unsigned hash = dn_hash(cb->src, cb->dst);
 
-        if (skb->dst)
+        if (skb_dst(skb))
                 return 0;
 
         rcu_read_lock();
@@ -1437,7 +1438,7 @@ static int dn_route_input(struct sk_buff *skb)
                     (rt->fl.iif == cb->iif)) {
                         dst_use(&rt->u.dst, jiffies);
                         rcu_read_unlock();
-                        skb->dst = (struct dst_entry *)rt;
+                        skb_dst_set(skb, (struct dst_entry *)rt);
                         return 0;
                 }
         }
@@ -1449,7 +1450,7 @@ static int dn_route_input(struct sk_buff *skb)
 static int dn_rt_fill_info(struct sk_buff *skb, u32 pid, u32 seq,
                            int event, int nowait, unsigned int flags)
 {
-        struct dn_route *rt = (struct dn_route *)skb->dst;
+        struct dn_route *rt = (struct dn_route *)skb_dst(skb);
         struct rtmsg *r;
         struct nlmsghdr *nlh;
         unsigned char *b = skb_tail_pointer(skb);
@@ -1554,7 +1555,7 @@ static int dn_cache_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh, void
                 err = dn_route_input(skb);
                 local_bh_enable();
                 memset(cb, 0, sizeof(struct dn_skb_cb));
-                rt = (struct dn_route *)skb->dst;
+                rt = (struct dn_route *)skb_dst(skb);
                 if (!err && -rt->u.dst.error)
                         err = rt->u.dst.error;
         } else {
@@ -1570,7 +1571,7 @@ static int dn_cache_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh, void
         skb->dev = NULL;
         if (err)
                 goto out_free;
-        skb->dst = &rt->u.dst;
+        skb_dst_set(skb, &rt->u.dst);
         if (rtm->rtm_flags & RTM_F_NOTIFY)
                 rt->rt_flags |= RTCF_NOTIFY;
 
@@ -1622,15 +1623,15 @@ int dn_cache_dump(struct sk_buff *skb, struct netlink_callback *cb)
                         rt = rcu_dereference(rt->u.dst.dn_next), idx++) {
                         if (idx < s_idx)
                                 continue;
-                        skb->dst = dst_clone(&rt->u.dst);
+                        skb_dst_set(skb, dst_clone(&rt->u.dst));
                         if (dn_rt_fill_info(skb, NETLINK_CB(cb->skb).pid,
                                         cb->nlh->nlmsg_seq, RTM_NEWROUTE,
                                         1, NLM_F_MULTI) <= 0) {
-                                dst_release(xchg(&skb->dst, NULL));
+                                skb_dst_drop(skb);
                                 rcu_read_unlock_bh();
                                 goto done;
                         }
-                        dst_release(xchg(&skb->dst, NULL));
+                        skb_dst_drop(skb);
                 }
                 rcu_read_unlock_bh();
         }
diff --git a/net/decnet/dn_rules.c b/net/decnet/dn_rules.c
index 14fbca55e908..72495f25269f 100644
--- a/net/decnet/dn_rules.c
+++ b/net/decnet/dn_rules.c
@@ -115,7 +115,7 @@ static int dn_fib_rule_match(struct fib_rule *rule, struct flowi *fl, int flags)
 }
 
 static int dn_fib_rule_configure(struct fib_rule *rule, struct sk_buff *skb,
-                                 struct nlmsghdr *nlh, struct fib_rule_hdr *frh,
+                                 struct fib_rule_hdr *frh,
                                  struct nlattr **tb)
 {
         int err = -EINVAL;
@@ -192,7 +192,7 @@ unsigned dnet_addr_type(__le16 addr)
 }
 
 static int dn_fib_rule_fill(struct fib_rule *rule, struct sk_buff *skb,
-                            struct nlmsghdr *nlh, struct fib_rule_hdr *frh)
+                            struct fib_rule_hdr *frh)
 {
         struct dn_fib_rule *r = (struct dn_fib_rule *)rule;
 
diff --git a/net/dsa/slave.c b/net/dsa/slave.c
index ed131181215d..2175e6d5cc8d 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, ETH_ALEN);
+                err = dev_unicast_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, ETH_ALEN);
+                dev_unicast_delete(master, dev->dev_addr);
 out:
         return err;
 }
@@ -108,7 +108,7 @@ static int dsa_slave_close(struct net_device *dev)
                 dev_set_promiscuity(master, -1);
 
         if (compare_ether_addr(dev->dev_addr, master->dev_addr))
-                dev_unicast_delete(master, dev->dev_addr, ETH_ALEN);
+                dev_unicast_delete(master, dev->dev_addr);
 
         return 0;
 }
@@ -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, ETH_ALEN);
+                err = dev_unicast_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, ETH_ALEN);
+                dev_unicast_delete(master, dev->dev_addr);
 
 out:
         memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
diff --git a/net/econet/af_econet.c b/net/econet/af_econet.c
index 6f479fa522c3..8121bf0029e3 100644
--- a/net/econet/af_econet.c
+++ b/net/econet/af_econet.c
@@ -901,15 +901,10 @@ static void aun_tx_ack(unsigned long seq, int result)
         struct ec_cb *eb;
 
         spin_lock_irqsave(&aun_queue_lock, flags);
-        skb = skb_peek(&aun_queue);
-        while (skb && skb != (struct sk_buff *)&aun_queue)
-        {
-                struct sk_buff *newskb = skb->next;
+        skb_queue_walk(&aun_queue, skb) {
                 eb = (struct ec_cb *)&skb->cb;
                 if (eb->seq == seq)
                         goto foundit;
-
-                skb = newskb;
         }
         spin_unlock_irqrestore(&aun_queue_lock, flags);
         printk(KERN_DEBUG "AUN: unknown sequence %ld\n", seq);
@@ -982,23 +977,18 @@ static void aun_data_available(struct sock *sk, int slen)
 
 static void ab_cleanup(unsigned long h)
 {
-        struct sk_buff *skb;
+        struct sk_buff *skb, *n;
         unsigned long flags;
 
         spin_lock_irqsave(&aun_queue_lock, flags);
-        skb = skb_peek(&aun_queue);
-        while (skb && skb != (struct sk_buff *)&aun_queue)
-        {
-                struct sk_buff *newskb = skb->next;
+        skb_queue_walk_safe(&aun_queue, skb, n) {
                 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
-                if ((jiffies - eb->start) > eb->timeout)
-                {
+                if ((jiffies - eb->start) > eb->timeout) {
                         tx_result(skb->sk, eb->cookie,
                                   ECTYPE_TRANSMIT_NOT_PRESENT);
                         skb_unlink(skb, &aun_queue);
                         kfree_skb(skb);
                 }
-                skb = newskb;
         }
         spin_unlock_irqrestore(&aun_queue_lock, flags);
 
diff --git a/net/ethernet/eth.c b/net/ethernet/eth.c
index 280352aba403..5a883affecd3 100644
--- a/net/ethernet/eth.c
+++ b/net/ethernet/eth.c
@@ -337,11 +337,6 @@ const struct header_ops eth_header_ops ____cacheline_aligned = {
 void ether_setup(struct net_device *dev)
 {
         dev->header_ops         = &eth_header_ops;
-#ifdef CONFIG_COMPAT_NET_DEV_OPS
-        dev->change_mtu         = eth_change_mtu;
-        dev->set_mac_address    = eth_mac_addr;
-        dev->validate_addr      = eth_validate_addr;
-#endif
         dev->type               = ARPHRD_ETHER;
         dev->hard_header_len    = ETH_HLEN;
         dev->mtu                = ETH_DATA_LEN;
diff --git a/net/ieee802154/Kconfig b/net/ieee802154/Kconfig
new file mode 100644
index 000000000000..1c1de97d264a
--- /dev/null
+++ b/net/ieee802154/Kconfig
@@ -0,0 +1,12 @@
+config IEEE802154
+        tristate "IEEE Std 802.15.4 Low-Rate Wireless Personal Area Networks support (EXPERIMENTAL)"
+        depends on EXPERIMENTAL
+        ---help---
+          IEEE Std 802.15.4 defines a low data rate, low power and low
+          complexity short range wireless personal area networks. It was
+          designed to organise networks of sensors, switches, etc automation
+          devices. Maximum allowed data rate is 250 kb/s and typical personal
+          operating space around 10m.
+
+          Say Y here to compile LR-WPAN support into the kernel or say M to
+          compile it as modules.
diff --git a/net/ieee802154/Makefile b/net/ieee802154/Makefile
new file mode 100644
index 000000000000..f99338a26100
--- /dev/null
+++ b/net/ieee802154/Makefile
@@ -0,0 +1,5 @@
+obj-$(CONFIG_IEEE802154) +=     nl802154.o af_802154.o
+nl802154-y              := netlink.o nl_policy.o
+af_802154-y             := af_ieee802154.o raw.o dgram.o
+
+ccflags-y += -Wall -DDEBUG
diff --git a/net/ieee802154/af802154.h b/net/ieee802154/af802154.h
new file mode 100644
index 000000000000..b1ec52537522
--- /dev/null
+++ b/net/ieee802154/af802154.h
@@ -0,0 +1,36 @@
+/*
+ * Internal interfaces for ieee 802.15.4 address family.
+ *
+ * Copyright 2007, 2008, 2009 Siemens AG
+ *
+ * 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.
+ *
+ * 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.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Written by:
+ * Sergey Lapin <slapin@ossfans.org>
+ * Dmitry Eremin-Solenikov <dbaryshkov@gmail.com>
+ */
+
+#ifndef AF802154_H
+#define AF802154_H
+
+struct sk_buff;
+struct net_devce;
+extern struct proto ieee802154_raw_prot;
+extern struct proto ieee802154_dgram_prot;
+void ieee802154_raw_deliver(struct net_device *dev, struct sk_buff *skb);
+int ieee802154_dgram_deliver(struct net_device *dev, struct sk_buff *skb);
+struct net_device *ieee802154_get_dev(struct net *net,
+                struct ieee802154_addr *addr);
+
+#endif
diff --git a/net/ieee802154/af_ieee802154.c b/net/ieee802154/af_ieee802154.c
new file mode 100644
index 000000000000..882a927cefae
--- /dev/null
+++ b/net/ieee802154/af_ieee802154.c
@@ -0,0 +1,372 @@
+/*
+ * IEEE802154.4 socket interface
+ *
+ * Copyright 2007, 2008 Siemens AG
+ *
+ * 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.
+ *
+ * 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.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Written by:
+ * Sergey Lapin <slapin@ossfans.org>
+ * Maxim Gorbachyov <maxim.gorbachev@siemens.com>
+ */
+
+#include <linux/net.h>
+#include <linux/capability.h>
+#include <linux/module.h>
+#include <linux/if_arp.h>
+#include <linux/if.h>
+#include <linux/termios.h>      /* For TIOCOUTQ/INQ */
+#include <linux/list.h>
+#include <net/datalink.h>
+#include <net/psnap.h>
+#include <net/sock.h>
+#include <net/tcp_states.h>
+#include <net/route.h>
+
+#include <net/ieee802154/af_ieee802154.h>
+#include <net/ieee802154/netdevice.h>
+
+#include "af802154.h"
+
+#define DBG_DUMP(data, len) { \
+        int i; \
+        pr_debug("function: %s: data: len %d:\n", __func__, len); \
+        for (i = 0; i < len; i++) {\
+                pr_debug("%02x: %02x\n", i, (data)[i]); \
+        } \
+}
+
+/*
+ * Utility function for families
+ */
+struct net_device *ieee802154_get_dev(struct net *net,
+                struct ieee802154_addr *addr)
+{
+        struct net_device *dev = NULL;
+        struct net_device *tmp;
+        u16 pan_id, short_addr;
+
+        switch (addr->addr_type) {
+        case IEEE802154_ADDR_LONG:
+                rtnl_lock();
+                dev = dev_getbyhwaddr(net, ARPHRD_IEEE802154, addr->hwaddr);
+                if (dev)
+                        dev_hold(dev);
+                rtnl_unlock();
+                break;
+        case IEEE802154_ADDR_SHORT:
+                if (addr->pan_id == 0xffff ||
+                    addr->short_addr == IEEE802154_ADDR_UNDEF ||
+                    addr->short_addr == 0xffff)
+                        break;
+
+                rtnl_lock();
+
+                for_each_netdev(net, tmp) {
+                        if (tmp->type != ARPHRD_IEEE802154)
+                                continue;
+
+                        pan_id = ieee802154_mlme_ops(tmp)->get_pan_id(tmp);
+                        short_addr =
+                                ieee802154_mlme_ops(tmp)->get_short_addr(tmp);
+
+                        if (pan_id == addr->pan_id &&
+                            short_addr == addr->short_addr) {
+                                dev = tmp;
+                                dev_hold(dev);
+                                break;
+                        }
+                }
+
+                rtnl_unlock();
+                break;
+        default:
+                pr_warning("Unsupported ieee802154 address type: %d\n",
+                                addr->addr_type);
+                break;
+        }
+
+        return dev;
+}
+
+static int ieee802154_sock_release(struct socket *sock)
+{
+        struct sock *sk = sock->sk;
+
+        if (sk) {
+                sock->sk = NULL;
+                sk->sk_prot->close(sk, 0);
+        }
+        return 0;
+}
+static int ieee802154_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
+                struct msghdr *msg, size_t len)
+{
+        struct sock *sk = sock->sk;
+
+        return sk->sk_prot->sendmsg(iocb, sk, msg, len);
+}
+
+static int ieee802154_sock_bind(struct socket *sock, struct sockaddr *uaddr,
+                int addr_len)
+{
+        struct sock *sk = sock->sk;
+
+        if (sk->sk_prot->bind)
+                return sk->sk_prot->bind(sk, uaddr, addr_len);
+
+        return sock_no_bind(sock, uaddr, addr_len);
+}
+
+static int ieee802154_sock_connect(struct socket *sock, struct sockaddr *uaddr,
+                        int addr_len, int flags)
+{
+        struct sock *sk = sock->sk;
+
+        if (uaddr->sa_family == AF_UNSPEC)
+                return sk->sk_prot->disconnect(sk, flags);
+
+        return sk->sk_prot->connect(sk, uaddr, addr_len);
+}
+
+static int ieee802154_dev_ioctl(struct sock *sk, struct ifreq __user *arg,
+                unsigned int cmd)
+{
+        struct ifreq ifr;
+        int ret = -EINVAL;
+        struct net_device *dev;
+
+        if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
+                return -EFAULT;
+
+        ifr.ifr_name[IFNAMSIZ-1] = 0;
+
+        dev_load(sock_net(sk), ifr.ifr_name);
+        dev = dev_get_by_name(sock_net(sk), ifr.ifr_name);
+        if (dev->type == ARPHRD_IEEE802154 ||
+            dev->type == ARPHRD_IEEE802154_PHY)
+                ret = dev->netdev_ops->ndo_do_ioctl(dev, &ifr, cmd);
+
+        if (!ret && copy_to_user(arg, &ifr, sizeof(struct ifreq)))
+                ret = -EFAULT;
+        dev_put(dev);
+
+        return ret;
+}
+
+static int ieee802154_sock_ioctl(struct socket *sock, unsigned int cmd,
+                unsigned long arg)
+{
+        struct sock *sk = sock->sk;
+
+        switch (cmd) {
+        case SIOCGSTAMP:
+                return sock_get_timestamp(sk, (struct timeval __user *)arg);
+        case SIOCGSTAMPNS:
+                return sock_get_timestampns(sk, (struct timespec __user *)arg);
+        case SIOCGIFADDR:
+        case SIOCSIFADDR:
+                return ieee802154_dev_ioctl(sk, (struct ifreq __user *)arg,
+                                cmd);
+        default:
+                if (!sk->sk_prot->ioctl)
+                        return -ENOIOCTLCMD;
+                return sk->sk_prot->ioctl(sk, cmd, arg);
+        }
+}
+
+static const struct proto_ops ieee802154_raw_ops = {
+        .family            = PF_IEEE802154,
+        .owner             = THIS_MODULE,
+        .release           = ieee802154_sock_release,
+        .bind              = ieee802154_sock_bind,
+        .connect           = ieee802154_sock_connect,
+        .socketpair        = sock_no_socketpair,
+        .accept            = sock_no_accept,
+        .getname           = sock_no_getname,
+        .poll              = datagram_poll,
+        .ioctl             = ieee802154_sock_ioctl,
+        .listen            = sock_no_listen,
+        .shutdown          = sock_no_shutdown,
+        .setsockopt        = sock_common_setsockopt,
+        .getsockopt        = sock_common_getsockopt,
+        .sendmsg           = ieee802154_sock_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 const struct proto_ops ieee802154_dgram_ops = {
+        .family            = PF_IEEE802154,
+        .owner             = THIS_MODULE,
+        .release           = ieee802154_sock_release,
+        .bind              = ieee802154_sock_bind,
+        .connect           = ieee802154_sock_connect,
+        .socketpair        = sock_no_socketpair,
+        .accept            = sock_no_accept,
+        .getname           = sock_no_getname,
+        .poll              = datagram_poll,
+        .ioctl             = ieee802154_sock_ioctl,
+        .listen            = sock_no_listen,
+        .shutdown          = sock_no_shutdown,
+        .setsockopt        = sock_common_setsockopt,
+        .getsockopt        = sock_common_getsockopt,
+        .sendmsg           = ieee802154_sock_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
+};
+
+
+/*
+ * Create a socket. Initialise the socket, blank the addresses
+ * set the state.
+ */
+static int ieee802154_create(struct net *net, struct socket *sock,
+                int protocol)
+{
+        struct sock *sk;
+        int rc;
+        struct proto *proto;
+        const struct proto_ops *ops;
+
+        if (net != &init_net)
+                return -EAFNOSUPPORT;
+
+        switch (sock->type) {
+        case SOCK_RAW:
+                proto = &ieee802154_raw_prot;
+                ops = &ieee802154_raw_ops;
+                break;
+        case SOCK_DGRAM:
+                proto = &ieee802154_dgram_prot;
+                ops = &ieee802154_dgram_ops;
+                break;
+        default:
+                rc = -ESOCKTNOSUPPORT;
+                goto out;
+        }
+
+        rc = -ENOMEM;
+        sk = sk_alloc(net, PF_IEEE802154, GFP_KERNEL, proto);
+        if (!sk)
+                goto out;
+        rc = 0;
+
+        sock->ops = ops;
+
+        sock_init_data(sock, sk);
+        /* FIXME: sk->sk_destruct */
+        sk->sk_family = PF_IEEE802154;
+
+        /* Checksums on by default */
+        sock_set_flag(sk, SOCK_ZAPPED);
+
+        if (sk->sk_prot->hash)
+                sk->sk_prot->hash(sk);
+
+        if (sk->sk_prot->init) {
+                rc = sk->sk_prot->init(sk);
+                if (rc)
+                        sk_common_release(sk);
+        }
+out:
+        return rc;
+}
+
+static struct net_proto_family ieee802154_family_ops = {
+        .family         = PF_IEEE802154,
+        .create         = ieee802154_create,
+        .owner          = THIS_MODULE,
+};
+
+static int ieee802154_rcv(struct sk_buff *skb, struct net_device *dev,
+        struct packet_type *pt, struct net_device *orig_dev)
+{
+        DBG_DUMP(skb->data, skb->len);
+        if (!netif_running(dev))
+                return -ENODEV;
+        pr_debug("got frame, type %d, dev %p\n", dev->type, dev);
+
+        if (!net_eq(dev_net(dev), &init_net))
+                goto drop;
+
+        ieee802154_raw_deliver(dev, skb);
+
+        if (dev->type != ARPHRD_IEEE802154)
+                goto drop;
+
+        if (skb->pkt_type != PACKET_OTHERHOST)
+                return ieee802154_dgram_deliver(dev, skb);
+
+drop:
+        kfree_skb(skb);
+        return NET_RX_DROP;
+}
+
+
+static struct packet_type ieee802154_packet_type = {
+        .type = __constant_htons(ETH_P_IEEE802154),
+        .func = ieee802154_rcv,
+};
+
+static int __init af_ieee802154_init(void)
+{
+        int rc = -EINVAL;
+
+        rc = proto_register(&ieee802154_raw_prot, 1);
+        if (rc)
+                goto out;
+
+        rc = proto_register(&ieee802154_dgram_prot, 1);
+        if (rc)
+                goto err_dgram;
+
+        /* Tell SOCKET that we are alive */
+        rc = sock_register(&ieee802154_family_ops);
+        if (rc)
+                goto err_sock;
+        dev_add_pack(&ieee802154_packet_type);
+
+        rc = 0;
+        goto out;
+
+err_sock:
+        proto_unregister(&ieee802154_dgram_prot);
+err_dgram:
+        proto_unregister(&ieee802154_raw_prot);
+out:
+        return rc;
+}
+static void __exit af_ieee802154_remove(void)
+{
+        dev_remove_pack(&ieee802154_packet_type);
+        sock_unregister(PF_IEEE802154);
+        proto_unregister(&ieee802154_dgram_prot);
+        proto_unregister(&ieee802154_raw_prot);
+}
+
+module_init(af_ieee802154_init);
+module_exit(af_ieee802154_remove);
+
+MODULE_LICENSE("GPL");
+MODULE_ALIAS_NETPROTO(PF_IEEE802154);
diff --git a/net/ieee802154/dgram.c b/net/ieee802154/dgram.c
new file mode 100644
index 000000000000..1779677aed46
--- /dev/null
+++ b/net/ieee802154/dgram.c
@@ -0,0 +1,394 @@
+/*
+ * ZigBee socket interface
+ *
+ * Copyright 2007, 2008 Siemens AG
+ *
+ * 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.
+ *
+ * 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.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Written by:
+ * Sergey Lapin <slapin@ossfans.org>
+ * Dmitry Eremin-Solenikov <dbaryshkov@gmail.com>
+ */
+
+#include <linux/net.h>
+#include <linux/module.h>
+#include <linux/if_arp.h>
+#include <linux/list.h>
+#include <net/sock.h>
+#include <net/ieee802154/af_ieee802154.h>
+#include <net/ieee802154/mac_def.h>
+#include <net/ieee802154/netdevice.h>
+
+#include <asm/ioctls.h>
+
+#include "af802154.h"
+
+static HLIST_HEAD(dgram_head);
+static DEFINE_RWLOCK(dgram_lock);
+
+struct dgram_sock {
+        struct sock sk;
+
+        int bound;
+        struct ieee802154_addr src_addr;
+        struct ieee802154_addr dst_addr;
+};
+
+static inline struct dgram_sock *dgram_sk(const struct sock *sk)
+{
+        return container_of(sk, struct dgram_sock, sk);
+}
+
+
+static void dgram_hash(struct sock *sk)
+{
+        write_lock_bh(&dgram_lock);
+        sk_add_node(sk, &dgram_head);
+        sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
+        write_unlock_bh(&dgram_lock);
+}
+
+static void dgram_unhash(struct sock *sk)
+{
+        write_lock_bh(&dgram_lock);
+        if (sk_del_node_init(sk))
+                sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
+        write_unlock_bh(&dgram_lock);
+}
+
+static int dgram_init(struct sock *sk)
+{
+        struct dgram_sock *ro = dgram_sk(sk);
+
+        ro->dst_addr.addr_type = IEEE802154_ADDR_LONG;
+        ro->dst_addr.pan_id = 0xffff;
+        memset(&ro->dst_addr.hwaddr, 0xff, sizeof(ro->dst_addr.hwaddr));
+        return 0;
+}
+
+static void dgram_close(struct sock *sk, long timeout)
+{
+        sk_common_release(sk);
+}
+
+static int dgram_bind(struct sock *sk, struct sockaddr *uaddr, int len)
+{
+        struct sockaddr_ieee802154 *addr = (struct sockaddr_ieee802154 *)uaddr;
+        struct dgram_sock *ro = dgram_sk(sk);
+        int err = 0;
+        struct net_device *dev;
+
+        ro->bound = 0;
+
+        if (len < sizeof(*addr))
+                return -EINVAL;
+
+        if (addr->family != AF_IEEE802154)
+                return -EINVAL;
+
+        lock_sock(sk);
+
+        dev = ieee802154_get_dev(sock_net(sk), &addr->addr);
+        if (!dev) {
+                err = -ENODEV;
+                goto out;
+        }
+
+        if (dev->type != ARPHRD_IEEE802154) {
+                err = -ENODEV;
+                goto out_put;
+        }
+
+        memcpy(&ro->src_addr, &addr->addr, sizeof(struct ieee802154_addr));
+
+        ro->bound = 1;
+out_put:
+        dev_put(dev);
+out:
+        release_sock(sk);
+
+        return err;
+}
+
+static int dgram_ioctl(struct sock *sk, int cmd, unsigned long arg)
+{
+        switch (cmd) {
+        case SIOCOUTQ:
+        {
+                int amount = atomic_read(&sk->sk_wmem_alloc);
+                return put_user(amount, (int __user *)arg);
+        }
+
+        case SIOCINQ:
+        {
+                struct sk_buff *skb;
+                unsigned long amount;
+
+                amount = 0;
+                spin_lock_bh(&sk->sk_receive_queue.lock);
+                skb = skb_peek(&sk->sk_receive_queue);
+                if (skb != NULL) {
+                        /*
+                         * We will only return the amount
+                         * of this packet since that is all
+                         * that will be read.
+                         */
+                        /* FIXME: parse the header for more correct value */
+                        amount = skb->len - (3+8+8);
+                }
+                spin_unlock_bh(&sk->sk_receive_queue.lock);
+                return put_user(amount, (int __user *)arg);
+        }
+
+        }
+        return -ENOIOCTLCMD;
+}
+
+/* FIXME: autobind */
+static int dgram_connect(struct sock *sk, struct sockaddr *uaddr,
+                        int len)
+{
+        struct sockaddr_ieee802154 *addr = (struct sockaddr_ieee802154 *)uaddr;
+        struct dgram_sock *ro = dgram_sk(sk);
+        int err = 0;
+
+        if (len < sizeof(*addr))
+                return -EINVAL;
+
+        if (addr->family != AF_IEEE802154)
+                return -EINVAL;
+
+        lock_sock(sk);
+
+        if (!ro->bound) {
+                err = -ENETUNREACH;
+                goto out;
+        }
+
+        memcpy(&ro->dst_addr, &addr->addr, sizeof(struct ieee802154_addr));
+
+out:
+        release_sock(sk);
+        return err;
+}
+
+static int dgram_disconnect(struct sock *sk, int flags)
+{
+        struct dgram_sock *ro = dgram_sk(sk);
+
+        lock_sock(sk);
+
+        ro->dst_addr.addr_type = IEEE802154_ADDR_LONG;
+        memset(&ro->dst_addr.hwaddr, 0xff, sizeof(ro->dst_addr.hwaddr));
+
+        release_sock(sk);
+
+        return 0;
+}
+
+static int dgram_sendmsg(struct kiocb *iocb, struct sock *sk,
+                struct msghdr *msg, size_t size)
+{
+        struct net_device *dev;
+        unsigned mtu;
+        struct sk_buff *skb;
+        struct dgram_sock *ro = dgram_sk(sk);
+        int err;
+
+        if (msg->msg_flags & MSG_OOB) {
+                pr_debug("msg->msg_flags = 0x%x\n", msg->msg_flags);
+                return -EOPNOTSUPP;
+        }
+
+        if (!ro->bound)
+                dev = dev_getfirstbyhwtype(sock_net(sk), ARPHRD_IEEE802154);
+        else
+                dev = ieee802154_get_dev(sock_net(sk), &ro->src_addr);
+
+        if (!dev) {
+                pr_debug("no dev\n");
+                err = -ENXIO;
+                goto out;
+        }
+        mtu = dev->mtu;
+        pr_debug("name = %s, mtu = %u\n", dev->name, mtu);
+
+        skb = sock_alloc_send_skb(sk, LL_ALLOCATED_SPACE(dev) + size,
+                        msg->msg_flags & MSG_DONTWAIT,
+                        &err);
+        if (!skb)
+                goto out_dev;
+
+        skb_reserve(skb, LL_RESERVED_SPACE(dev));
+
+        skb_reset_network_header(skb);
+
+        mac_cb(skb)->flags = IEEE802154_FC_TYPE_DATA | MAC_CB_FLAG_ACKREQ;
+        mac_cb(skb)->seq = ieee802154_mlme_ops(dev)->get_dsn(dev);
+        err = dev_hard_header(skb, dev, ETH_P_IEEE802154, &ro->dst_addr,
+                        ro->bound ? &ro->src_addr : NULL, size);
+        if (err < 0)
+                goto out_skb;
+
+        skb_reset_mac_header(skb);
+
+        err = memcpy_fromiovec(skb_put(skb, size), msg->msg_iov, size);
+        if (err < 0)
+                goto out_skb;
+
+        if (size > mtu) {
+                pr_debug("size = %Zu, mtu = %u\n", size, mtu);
+                err = -EINVAL;
+                goto out_skb;
+        }
+
+        skb->dev = dev;
+        skb->sk  = sk;
+        skb->protocol = htons(ETH_P_IEEE802154);
+
+        dev_put(dev);
+
+        err = dev_queue_xmit(skb);
+        if (err > 0)
+                err = net_xmit_errno(err);
+
+        return err ?: size;
+
+out_skb:
+        kfree_skb(skb);
+out_dev:
+        dev_put(dev);
+out:
+        return err;
+}
+
+static int dgram_recvmsg(struct kiocb *iocb, struct sock *sk,
+                struct msghdr *msg, size_t len, int noblock, int flags,
+                int *addr_len)
+{
+        size_t copied = 0;
+        int err = -EOPNOTSUPP;
+        struct sk_buff *skb;
+
+        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;
+        }
+
+        /* FIXME: skip headers if necessary ?! */
+        err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
+        if (err)
+                goto done;
+
+        sock_recv_timestamp(msg, sk, skb);
+
+        if (flags & MSG_TRUNC)
+                copied = skb->len;
+done:
+        skb_free_datagram(sk, skb);
+out:
+        if (err)
+                return err;
+        return copied;
+}
+
+static int dgram_rcv_skb(struct sock *sk, struct sk_buff *skb)
+{
+        if (sock_queue_rcv_skb(sk, skb) < 0) {
+                atomic_inc(&sk->sk_drops);
+                kfree_skb(skb);
+                return NET_RX_DROP;
+        }
+
+        return NET_RX_SUCCESS;
+}
+
+static inline int ieee802154_match_sock(u8 *hw_addr, u16 pan_id,
+                u16 short_addr, struct dgram_sock *ro)
+{
+        if (!ro->bound)
+                return 1;
+
+        if (ro->src_addr.addr_type == IEEE802154_ADDR_LONG &&
+            !memcmp(ro->src_addr.hwaddr, hw_addr, IEEE802154_ADDR_LEN))
+                return 1;
+
+        if (ro->src_addr.addr_type == IEEE802154_ADDR_SHORT &&
+                     pan_id == ro->src_addr.pan_id &&
+                     short_addr == ro->src_addr.short_addr)
+                return 1;
+
+        return 0;
+}
+
+int ieee802154_dgram_deliver(struct net_device *dev, struct sk_buff *skb)
+{
+        struct sock *sk, *prev = NULL;
+        struct hlist_node *node;
+        int ret = NET_RX_SUCCESS;
+        u16 pan_id, short_addr;
+
+        /* Data frame processing */
+        BUG_ON(dev->type != ARPHRD_IEEE802154);
+
+        pan_id = ieee802154_mlme_ops(dev)->get_pan_id(dev);
+        short_addr = ieee802154_mlme_ops(dev)->get_short_addr(dev);
+
+        read_lock(&dgram_lock);
+        sk_for_each(sk, node, &dgram_head) {
+                if (ieee802154_match_sock(dev->dev_addr, pan_id, short_addr,
+                                        dgram_sk(sk))) {
+                        if (prev) {
+                                struct sk_buff *clone;
+                                clone = skb_clone(skb, GFP_ATOMIC);
+                                if (clone)
+                                        dgram_rcv_skb(prev, clone);
+                        }
+
+                        prev = sk;
+                }
+        }
+
+        if (prev)
+                dgram_rcv_skb(prev, skb);
+        else {
+                kfree_skb(skb);
+                ret = NET_RX_DROP;
+        }
+        read_unlock(&dgram_lock);
+
+        return ret;
+}
+
+struct proto ieee802154_dgram_prot = {
+        .name           = "IEEE-802.15.4-MAC",
+        .owner          = THIS_MODULE,
+        .obj_size       = sizeof(struct dgram_sock),
+        .init           = dgram_init,
+        .close          = dgram_close,
+        .bind           = dgram_bind,
+        .sendmsg        = dgram_sendmsg,
+        .recvmsg        = dgram_recvmsg,
+        .hash           = dgram_hash,
+        .unhash         = dgram_unhash,
+        .connect        = dgram_connect,
+        .disconnect     = dgram_disconnect,
+        .ioctl          = dgram_ioctl,
+};
+
diff --git a/net/ieee802154/netlink.c b/net/ieee802154/netlink.c
new file mode 100644
index 000000000000..105ad10876af
--- /dev/null
+++ b/net/ieee802154/netlink.c
@@ -0,0 +1,523 @@
+/*
+ * Netlink inteface for IEEE 802.15.4 stack
+ *
+ * Copyright 2007, 2008 Siemens AG
+ *
+ * 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.
+ *
+ * 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.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Written by:
+ * Sergey Lapin <slapin@ossfans.org>
+ * Dmitry Eremin-Solenikov <dbaryshkov@gmail.com>
+ */
+
+#include <linux/kernel.h>
+#include <linux/if_arp.h>
+#include <linux/netdevice.h>
+#include <net/netlink.h>
+#include <net/genetlink.h>
+#include <linux/nl802154.h>
+#include <net/ieee802154/af_ieee802154.h>
+#include <net/ieee802154/nl802154.h>
+#include <net/ieee802154/netdevice.h>
+
+static unsigned int ieee802154_seq_num;
+
+static struct genl_family ieee802154_coordinator_family = {
+        .id             = GENL_ID_GENERATE,
+        .hdrsize        = 0,
+        .name           = IEEE802154_NL_NAME,
+        .version        = 1,
+        .maxattr        = IEEE802154_ATTR_MAX,
+};
+
+static struct genl_multicast_group ieee802154_coord_mcgrp = {
+        .name           = IEEE802154_MCAST_COORD_NAME,
+};
+
+static struct genl_multicast_group ieee802154_beacon_mcgrp = {
+        .name           = IEEE802154_MCAST_BEACON_NAME,
+};
+
+/* Requests to userspace */
+static struct sk_buff *ieee802154_nl_create(int flags, u8 req)
+{
+        void *hdr;
+        struct sk_buff *msg = nlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC);
+
+        if (!msg)
+                return NULL;
+
+        hdr = genlmsg_put(msg, 0, ieee802154_seq_num++,
+                        &ieee802154_coordinator_family, flags, req);
+        if (!hdr) {
+                nlmsg_free(msg);
+                return NULL;
+        }
+
+        return msg;
+}
+
+static int ieee802154_nl_finish(struct sk_buff *msg)
+{
+        /* XXX: nlh is right at the start of msg */
+        void *hdr = genlmsg_data(NLMSG_DATA(msg->data));
+
+        if (!genlmsg_end(msg, hdr))
+                goto out;
+
+        return genlmsg_multicast(msg, 0, ieee802154_coord_mcgrp.id,
+                        GFP_ATOMIC);
+out:
+        nlmsg_free(msg);
+        return -ENOBUFS;
+}
+
+int ieee802154_nl_assoc_indic(struct net_device *dev,
+                struct ieee802154_addr *addr, u8 cap)
+{
+        struct sk_buff *msg;
+
+        pr_debug("%s\n", __func__);
+
+        if (addr->addr_type != IEEE802154_ADDR_LONG) {
+                pr_err("%s: received non-long source address!\n", __func__);
+                return -EINVAL;
+        }
+
+        msg = ieee802154_nl_create(0, IEEE802154_ASSOCIATE_INDIC);
+        if (!msg)
+                return -ENOBUFS;
+
+        NLA_PUT_STRING(msg, IEEE802154_ATTR_DEV_NAME, dev->name);
+        NLA_PUT_U32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex);
+        NLA_PUT(msg, IEEE802154_ATTR_HW_ADDR, IEEE802154_ADDR_LEN,
+                        dev->dev_addr);
+
+        NLA_PUT(msg, IEEE802154_ATTR_SRC_HW_ADDR, IEEE802154_ADDR_LEN,
+                        addr->hwaddr);
+
+        NLA_PUT_U8(msg, IEEE802154_ATTR_CAPABILITY, cap);
+
+        return ieee802154_nl_finish(msg);
+
+nla_put_failure:
+        nlmsg_free(msg);
+        return -ENOBUFS;
+}
+EXPORT_SYMBOL(ieee802154_nl_assoc_indic);
+
+int ieee802154_nl_assoc_confirm(struct net_device *dev, u16 short_addr,
+                u8 status)
+{
+        struct sk_buff *msg;
+
+        pr_debug("%s\n", __func__);
+
+        msg = ieee802154_nl_create(0, IEEE802154_ASSOCIATE_CONF);
+        if (!msg)
+                return -ENOBUFS;
+
+        NLA_PUT_STRING(msg, IEEE802154_ATTR_DEV_NAME, dev->name);
+        NLA_PUT_U32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex);
+        NLA_PUT(msg, IEEE802154_ATTR_HW_ADDR, IEEE802154_ADDR_LEN,
+                        dev->dev_addr);
+
+        NLA_PUT_U16(msg, IEEE802154_ATTR_SHORT_ADDR, short_addr);
+        NLA_PUT_U8(msg, IEEE802154_ATTR_STATUS, status);
+
+        return ieee802154_nl_finish(msg);
+
+nla_put_failure:
+        nlmsg_free(msg);
+        return -ENOBUFS;
+}
+EXPORT_SYMBOL(ieee802154_nl_assoc_confirm);
+
+int ieee802154_nl_disassoc_indic(struct net_device *dev,
+                struct ieee802154_addr *addr, u8 reason)
+{
+        struct sk_buff *msg;
+
+        pr_debug("%s\n", __func__);
+
+        msg = ieee802154_nl_create(0, IEEE802154_DISASSOCIATE_INDIC);
+        if (!msg)
+                return -ENOBUFS;
+
+        NLA_PUT_STRING(msg, IEEE802154_ATTR_DEV_NAME, dev->name);
+        NLA_PUT_U32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex);
+        NLA_PUT(msg, IEEE802154_ATTR_HW_ADDR, IEEE802154_ADDR_LEN,
+                        dev->dev_addr);
+
+        if (addr->addr_type == IEEE802154_ADDR_LONG)
+                NLA_PUT(msg, IEEE802154_ATTR_SRC_HW_ADDR, IEEE802154_ADDR_LEN,
+                                addr->hwaddr);
+        else
+                NLA_PUT_U16(msg, IEEE802154_ATTR_SRC_SHORT_ADDR,
+                                addr->short_addr);
+
+        NLA_PUT_U8(msg, IEEE802154_ATTR_REASON, reason);
+
+        return ieee802154_nl_finish(msg);
+
+nla_put_failure:
+        nlmsg_free(msg);
+        return -ENOBUFS;
+}
+EXPORT_SYMBOL(ieee802154_nl_disassoc_indic);
+
+int ieee802154_nl_disassoc_confirm(struct net_device *dev, u8 status)
+{
+        struct sk_buff *msg;
+
+        pr_debug("%s\n", __func__);
+
+        msg = ieee802154_nl_create(0, IEEE802154_DISASSOCIATE_CONF);
+        if (!msg)
+                return -ENOBUFS;
+
+        NLA_PUT_STRING(msg, IEEE802154_ATTR_DEV_NAME, dev->name);
+        NLA_PUT_U32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex);
+        NLA_PUT(msg, IEEE802154_ATTR_HW_ADDR, IEEE802154_ADDR_LEN,
+                        dev->dev_addr);
+
+        NLA_PUT_U8(msg, IEEE802154_ATTR_STATUS, status);
+
+        return ieee802154_nl_finish(msg);
+
+nla_put_failure:
+        nlmsg_free(msg);
+        return -ENOBUFS;
+}
+EXPORT_SYMBOL(ieee802154_nl_disassoc_confirm);
+
+int ieee802154_nl_beacon_indic(struct net_device *dev,
+                u16 panid, u16 coord_addr)
+{
+        struct sk_buff *msg;
+
+        pr_debug("%s\n", __func__);
+
+        msg = ieee802154_nl_create(0, IEEE802154_BEACON_NOTIFY_INDIC);
+        if (!msg)
+                return -ENOBUFS;
+
+        NLA_PUT_STRING(msg, IEEE802154_ATTR_DEV_NAME, dev->name);
+        NLA_PUT_U32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex);
+        NLA_PUT(msg, IEEE802154_ATTR_HW_ADDR, IEEE802154_ADDR_LEN,
+                        dev->dev_addr);
+        NLA_PUT_U16(msg, IEEE802154_ATTR_COORD_SHORT_ADDR, coord_addr);
+        NLA_PUT_U16(msg, IEEE802154_ATTR_COORD_PAN_ID, panid);
+
+        return ieee802154_nl_finish(msg);
+
+nla_put_failure:
+        nlmsg_free(msg);
+        return -ENOBUFS;
+}
+EXPORT_SYMBOL(ieee802154_nl_beacon_indic);
+
+int ieee802154_nl_scan_confirm(struct net_device *dev,
+                u8 status, u8 scan_type, u32 unscanned,
+                u8 *edl/* , struct list_head *pan_desc_list */)
+{
+        struct sk_buff *msg;
+
+        pr_debug("%s\n", __func__);
+
+        msg = ieee802154_nl_create(0, IEEE802154_SCAN_CONF);
+        if (!msg)
+                return -ENOBUFS;
+
+        NLA_PUT_STRING(msg, IEEE802154_ATTR_DEV_NAME, dev->name);
+        NLA_PUT_U32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex);
+        NLA_PUT(msg, IEEE802154_ATTR_HW_ADDR, IEEE802154_ADDR_LEN,
+                        dev->dev_addr);
+
+        NLA_PUT_U8(msg, IEEE802154_ATTR_STATUS, status);
+        NLA_PUT_U8(msg, IEEE802154_ATTR_SCAN_TYPE, scan_type);
+        NLA_PUT_U32(msg, IEEE802154_ATTR_CHANNELS, unscanned);
+
+        if (edl)
+                NLA_PUT(msg, IEEE802154_ATTR_ED_LIST, 27, edl);
+
+        return ieee802154_nl_finish(msg);
+
+nla_put_failure:
+        nlmsg_free(msg);
+        return -ENOBUFS;
+}
+EXPORT_SYMBOL(ieee802154_nl_scan_confirm);
+
+/* Requests from userspace */
+static struct net_device *ieee802154_nl_get_dev(struct genl_info *info)
+{
+        struct net_device *dev;
+
+        if (info->attrs[IEEE802154_ATTR_DEV_NAME]) {
+                char name[IFNAMSIZ + 1];
+                nla_strlcpy(name, info->attrs[IEEE802154_ATTR_DEV_NAME],
+                                sizeof(name));
+                dev = dev_get_by_name(&init_net, name);
+        } else if (info->attrs[IEEE802154_ATTR_DEV_INDEX])
+                dev = dev_get_by_index(&init_net,
+                                nla_get_u32(info->attrs[IEEE802154_ATTR_DEV_INDEX]));
+        else
+                return NULL;
+
+        if (dev->type != ARPHRD_IEEE802154) {
+                dev_put(dev);
+                return NULL;
+        }
+
+        return dev;
+}
+
+static int ieee802154_associate_req(struct sk_buff *skb,
+                struct genl_info *info)
+{
+        struct net_device *dev;
+        struct ieee802154_addr addr;
+        int ret = -EINVAL;
+
+        if (!info->attrs[IEEE802154_ATTR_CHANNEL] ||
+            !info->attrs[IEEE802154_ATTR_COORD_PAN_ID] ||
+            (!info->attrs[IEEE802154_ATTR_COORD_HW_ADDR] &&
+                !info->attrs[IEEE802154_ATTR_COORD_SHORT_ADDR]) ||
+            !info->attrs[IEEE802154_ATTR_CAPABILITY])
+                return -EINVAL;
+
+        dev = ieee802154_nl_get_dev(info);
+        if (!dev)
+                return -ENODEV;
+
+        if (info->attrs[IEEE802154_ATTR_COORD_HW_ADDR]) {
+                addr.addr_type = IEEE802154_ADDR_LONG;
+                nla_memcpy(addr.hwaddr,
+                                info->attrs[IEEE802154_ATTR_COORD_HW_ADDR],
+                                IEEE802154_ADDR_LEN);
+        } else {
+                addr.addr_type = IEEE802154_ADDR_SHORT;
+                addr.short_addr = nla_get_u16(
+                                info->attrs[IEEE802154_ATTR_COORD_SHORT_ADDR]);
+        }
+        addr.pan_id = nla_get_u16(info->attrs[IEEE802154_ATTR_COORD_PAN_ID]);
+
+        ret = ieee802154_mlme_ops(dev)->assoc_req(dev, &addr,
+                        nla_get_u8(info->attrs[IEEE802154_ATTR_CHANNEL]),
+                        nla_get_u8(info->attrs[IEEE802154_ATTR_CAPABILITY]));
+
+        dev_put(dev);
+        return ret;
+}
+
+static int ieee802154_associate_resp(struct sk_buff *skb,
+                struct genl_info *info)
+{
+        struct net_device *dev;
+        struct ieee802154_addr addr;
+        int ret = -EINVAL;
+
+        if (!info->attrs[IEEE802154_ATTR_STATUS] ||
+            !info->attrs[IEEE802154_ATTR_DEST_HW_ADDR] ||
+            !info->attrs[IEEE802154_ATTR_DEST_SHORT_ADDR])
+                return -EINVAL;
+
+        dev = ieee802154_nl_get_dev(info);
+        if (!dev)
+                return -ENODEV;
+
+        addr.addr_type = IEEE802154_ADDR_LONG;
+        nla_memcpy(addr.hwaddr, info->attrs[IEEE802154_ATTR_DEST_HW_ADDR],
+                        IEEE802154_ADDR_LEN);
+        addr.pan_id = ieee802154_mlme_ops(dev)->get_pan_id(dev);
+
+
+        ret = ieee802154_mlme_ops(dev)->assoc_resp(dev, &addr,
+                nla_get_u16(info->attrs[IEEE802154_ATTR_DEST_SHORT_ADDR]),
+                nla_get_u8(info->attrs[IEEE802154_ATTR_STATUS]));
+
+        dev_put(dev);
+        return ret;
+}
+
+static int ieee802154_disassociate_req(struct sk_buff *skb,
+                struct genl_info *info)
+{
+        struct net_device *dev;
+        struct ieee802154_addr addr;
+        int ret = -EINVAL;
+
+        if ((!info->attrs[IEEE802154_ATTR_DEST_HW_ADDR] &&
+                !info->attrs[IEEE802154_ATTR_DEST_SHORT_ADDR]) ||
+            !info->attrs[IEEE802154_ATTR_REASON])
+                return -EINVAL;
+
+        dev = ieee802154_nl_get_dev(info);
+        if (!dev)
+                return -ENODEV;
+
+        if (info->attrs[IEEE802154_ATTR_DEST_HW_ADDR]) {
+                addr.addr_type = IEEE802154_ADDR_LONG;
+                nla_memcpy(addr.hwaddr,
+                                info->attrs[IEEE802154_ATTR_DEST_HW_ADDR],
+                                IEEE802154_ADDR_LEN);
+        } else {
+                addr.addr_type = IEEE802154_ADDR_SHORT;
+                addr.short_addr = nla_get_u16(
+                                info->attrs[IEEE802154_ATTR_DEST_SHORT_ADDR]);
+        }
+        addr.pan_id = ieee802154_mlme_ops(dev)->get_pan_id(dev);
+
+        ret = ieee802154_mlme_ops(dev)->disassoc_req(dev, &addr,
+                        nla_get_u8(info->attrs[IEEE802154_ATTR_REASON]));
+
+        dev_put(dev);
+        return ret;
+}
+
+/*
+ * PANid, channel, beacon_order = 15, superframe_order = 15,
+ * PAN_coordinator, battery_life_extension = 0,
+ * coord_realignment = 0, security_enable = 0
+*/
+static int ieee802154_start_req(struct sk_buff *skb, struct genl_info *info)
+{
+        struct net_device *dev;
+        struct ieee802154_addr addr;
+
+        u8 channel, bcn_ord, sf_ord;
+        int pan_coord, blx, coord_realign;
+        int ret;
+
+        if (!info->attrs[IEEE802154_ATTR_COORD_PAN_ID] ||
+            !info->attrs[IEEE802154_ATTR_COORD_SHORT_ADDR] ||
+            !info->attrs[IEEE802154_ATTR_CHANNEL] ||
+            !info->attrs[IEEE802154_ATTR_BCN_ORD] ||
+            !info->attrs[IEEE802154_ATTR_SF_ORD] ||
+            !info->attrs[IEEE802154_ATTR_PAN_COORD] ||
+            !info->attrs[IEEE802154_ATTR_BAT_EXT] ||
+            !info->attrs[IEEE802154_ATTR_COORD_REALIGN]
+         )
+                return -EINVAL;
+
+        dev = ieee802154_nl_get_dev(info);
+        if (!dev)
+                return -ENODEV;
+
+        addr.addr_type = IEEE802154_ADDR_SHORT;
+        addr.short_addr = nla_get_u16(
+                        info->attrs[IEEE802154_ATTR_COORD_SHORT_ADDR]);
+        addr.pan_id = nla_get_u16(info->attrs[IEEE802154_ATTR_COORD_PAN_ID]);
+
+        channel = nla_get_u8(info->attrs[IEEE802154_ATTR_CHANNEL]);
+        bcn_ord = nla_get_u8(info->attrs[IEEE802154_ATTR_BCN_ORD]);
+        sf_ord = nla_get_u8(info->attrs[IEEE802154_ATTR_SF_ORD]);
+        pan_coord = nla_get_u8(info->attrs[IEEE802154_ATTR_PAN_COORD]);
+        blx = nla_get_u8(info->attrs[IEEE802154_ATTR_BAT_EXT]);
+        coord_realign = nla_get_u8(info->attrs[IEEE802154_ATTR_COORD_REALIGN]);
+
+        ret = ieee802154_mlme_ops(dev)->start_req(dev, &addr, channel,
+                bcn_ord, sf_ord, pan_coord, blx, coord_realign);
+
+        dev_put(dev);
+        return ret;
+}
+
+static int ieee802154_scan_req(struct sk_buff *skb, struct genl_info *info)
+{
+        struct net_device *dev;
+        int ret;
+        u8 type;
+        u32 channels;
+        u8 duration;
+
+        if (!info->attrs[IEEE802154_ATTR_SCAN_TYPE] ||
+            !info->attrs[IEEE802154_ATTR_CHANNELS] ||
+            !info->attrs[IEEE802154_ATTR_DURATION])
+                return -EINVAL;
+
+        dev = ieee802154_nl_get_dev(info);
+        if (!dev)
+                return -ENODEV;
+
+        type = nla_get_u8(info->attrs[IEEE802154_ATTR_SCAN_TYPE]);
+        channels = nla_get_u32(info->attrs[IEEE802154_ATTR_CHANNELS]);
+        duration = nla_get_u8(info->attrs[IEEE802154_ATTR_DURATION]);
+
+        ret = ieee802154_mlme_ops(dev)->scan_req(dev, type, channels,
+                        duration);
+
+        dev_put(dev);
+        return ret;
+}
+
+#define IEEE802154_OP(_cmd, _func)                      \
+        {                                               \
+                .cmd    = _cmd,                         \
+                .policy = ieee802154_policy,            \
+                .doit   = _func,                        \
+                .dumpit = NULL,                         \
+                .flags  = GENL_ADMIN_PERM,              \
+        }
+
+static struct genl_ops ieee802154_coordinator_ops[] = {
+        IEEE802154_OP(IEEE802154_ASSOCIATE_REQ, ieee802154_associate_req),
+        IEEE802154_OP(IEEE802154_ASSOCIATE_RESP, ieee802154_associate_resp),
+        IEEE802154_OP(IEEE802154_DISASSOCIATE_REQ, ieee802154_disassociate_req),
+        IEEE802154_OP(IEEE802154_SCAN_REQ, ieee802154_scan_req),
+        IEEE802154_OP(IEEE802154_START_REQ, ieee802154_start_req),
+};
+
+static int __init ieee802154_nl_init(void)
+{
+        int rc;
+        int i;
+
+        rc = genl_register_family(&ieee802154_coordinator_family);
+        if (rc)
+                goto fail;
+
+        rc = genl_register_mc_group(&ieee802154_coordinator_family,
+                        &ieee802154_coord_mcgrp);
+        if (rc)
+                goto fail;
+
+        rc = genl_register_mc_group(&ieee802154_coordinator_family,
+                        &ieee802154_beacon_mcgrp);
+        if (rc)
+                goto fail;
+
+
+        for (i = 0; i < ARRAY_SIZE(ieee802154_coordinator_ops); i++) {
+                rc = genl_register_ops(&ieee802154_coordinator_family,
+                                &ieee802154_coordinator_ops[i]);
+                if (rc)
+                        goto fail;
+        }
+
+        return 0;
+
+fail:
+        genl_unregister_family(&ieee802154_coordinator_family);
+        return rc;
+}
+module_init(ieee802154_nl_init);
+
+static void __exit ieee802154_nl_exit(void)
+{
+        genl_unregister_family(&ieee802154_coordinator_family);
+}
+module_exit(ieee802154_nl_exit);
+
diff --git a/net/ieee802154/nl_policy.c b/net/ieee802154/nl_policy.c
new file mode 100644
index 000000000000..c7d71d1adcac
--- /dev/null
+++ b/net/ieee802154/nl_policy.c
@@ -0,0 +1,52 @@
+/*
+ * nl802154.h
+ *
+ * Copyright (C) 2007, 2008 Siemens AG
+ *
+ * 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.
+ *
+ * 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.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <net/netlink.h>
+#include <linux/nl802154.h>
+
+#define NLA_HW_ADDR NLA_U64
+
+struct nla_policy ieee802154_policy[IEEE802154_ATTR_MAX + 1] = {
+        [IEEE802154_ATTR_DEV_NAME] = { .type = NLA_STRING, },
+        [IEEE802154_ATTR_DEV_INDEX] = { .type = NLA_U32, },
+
+        [IEEE802154_ATTR_STATUS] = { .type = NLA_U8, },
+        [IEEE802154_ATTR_SHORT_ADDR] = { .type = NLA_U16, },
+        [IEEE802154_ATTR_HW_ADDR] = { .type = NLA_HW_ADDR, },
+        [IEEE802154_ATTR_PAN_ID] = { .type = NLA_U16, },
+        [IEEE802154_ATTR_CHANNEL] = { .type = NLA_U8, },
+        [IEEE802154_ATTR_COORD_SHORT_ADDR] = { .type = NLA_U16, },
+        [IEEE802154_ATTR_COORD_HW_ADDR] = { .type = NLA_HW_ADDR, },
+        [IEEE802154_ATTR_COORD_PAN_ID] = { .type = NLA_U16, },
+        [IEEE802154_ATTR_SRC_SHORT_ADDR] = { .type = NLA_U16, },
+        [IEEE802154_ATTR_SRC_HW_ADDR] = { .type = NLA_HW_ADDR, },
+        [IEEE802154_ATTR_SRC_PAN_ID] = { .type = NLA_U16, },
+        [IEEE802154_ATTR_DEST_SHORT_ADDR] = { .type = NLA_U16, },
+        [IEEE802154_ATTR_DEST_HW_ADDR] = { .type = NLA_HW_ADDR, },
+        [IEEE802154_ATTR_DEST_PAN_ID] = { .type = NLA_U16, },
+
+        [IEEE802154_ATTR_CAPABILITY] = { .type = NLA_U8, },
+        [IEEE802154_ATTR_REASON] = { .type = NLA_U8, },
+        [IEEE802154_ATTR_SCAN_TYPE] = { .type = NLA_U8, },
+        [IEEE802154_ATTR_CHANNELS] = { .type = NLA_U32, },
+        [IEEE802154_ATTR_DURATION] = { .type = NLA_U8, },
+        [IEEE802154_ATTR_ED_LIST] = { .len = 27 },
+};
diff --git a/net/ieee802154/raw.c b/net/ieee802154/raw.c
new file mode 100644
index 000000000000..fca44d59f97e
--- /dev/null
+++ b/net/ieee802154/raw.c
@@ -0,0 +1,254 @@
+/*
+ * Raw IEEE 802.15.4 sockets
+ *
+ * Copyright 2007, 2008 Siemens AG
+ *
+ * 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.
+ *
+ * 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.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Written by:
+ * Sergey Lapin <slapin@ossfans.org>
+ * Dmitry Eremin-Solenikov <dbaryshkov@gmail.com>
+ */
+
+#include <linux/net.h>
+#include <linux/module.h>
+#include <linux/if_arp.h>
+#include <linux/list.h>
+#include <net/sock.h>
+#include <net/ieee802154/af_ieee802154.h>
+
+#include "af802154.h"
+
+static HLIST_HEAD(raw_head);
+static DEFINE_RWLOCK(raw_lock);
+
+static void raw_hash(struct sock *sk)
+{
+        write_lock_bh(&raw_lock);
+        sk_add_node(sk, &raw_head);
+        sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
+        write_unlock_bh(&raw_lock);
+}
+
+static void raw_unhash(struct sock *sk)
+{
+        write_lock_bh(&raw_lock);
+        if (sk_del_node_init(sk))
+                sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
+        write_unlock_bh(&raw_lock);
+}
+
+static void raw_close(struct sock *sk, long timeout)
+{
+        sk_common_release(sk);
+}
+
+static int raw_bind(struct sock *sk, struct sockaddr *uaddr, int len)
+{
+        struct sockaddr_ieee802154 *addr = (struct sockaddr_ieee802154 *)uaddr;
+        int err = 0;
+        struct net_device *dev = NULL;
+
+        if (len < sizeof(*addr))
+                return -EINVAL;
+
+        if (addr->family != AF_IEEE802154)
+                return -EINVAL;
+
+        lock_sock(sk);
+
+        dev = ieee802154_get_dev(sock_net(sk), &addr->addr);
+        if (!dev) {
+                err = -ENODEV;
+                goto out;
+        }
+
+        if (dev->type != ARPHRD_IEEE802154_PHY &&
+            dev->type != ARPHRD_IEEE802154) {
+                err = -ENODEV;
+                goto out_put;
+        }
+
+        sk->sk_bound_dev_if = dev->ifindex;
+        sk_dst_reset(sk);
+
+out_put:
+        dev_put(dev);
+out:
+        release_sock(sk);
+
+        return err;
+}
+
+static int raw_connect(struct sock *sk, struct sockaddr *uaddr,
+                        int addr_len)
+{
+        return -ENOTSUPP;
+}
+
+static int raw_disconnect(struct sock *sk, int flags)
+{
+        return 0;
+}
+
+static int raw_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
+                       size_t size)
+{
+        struct net_device *dev;
+        unsigned mtu;
+        struct sk_buff *skb;
+        int err;
+
+        if (msg->msg_flags & MSG_OOB) {
+                pr_debug("msg->msg_flags = 0x%x\n", msg->msg_flags);
+                return -EOPNOTSUPP;
+        }
+
+        lock_sock(sk);
+        if (!sk->sk_bound_dev_if)
+                dev = dev_getfirstbyhwtype(sock_net(sk), ARPHRD_IEEE802154);
+        else
+                dev = dev_get_by_index(sock_net(sk), sk->sk_bound_dev_if);
+        release_sock(sk);
+
+        if (!dev) {
+                pr_debug("no dev\n");
+                err = -ENXIO;
+                goto out;
+        }
+
+        mtu = dev->mtu;
+        pr_debug("name = %s, mtu = %u\n", dev->name, mtu);
+
+        if (size > mtu) {
+                pr_debug("size = %Zu, mtu = %u\n", size, mtu);
+                err = -EINVAL;
+                goto out_dev;
+        }
+
+        skb = sock_alloc_send_skb(sk, LL_ALLOCATED_SPACE(dev) + size,
+                        msg->msg_flags & MSG_DONTWAIT, &err);
+        if (!skb)
+                goto out_dev;
+
+        skb_reserve(skb, LL_RESERVED_SPACE(dev));
+
+        skb_reset_mac_header(skb);
+        skb_reset_network_header(skb);
+
+        err = memcpy_fromiovec(skb_put(skb, size), msg->msg_iov, size);
+        if (err < 0)
+                goto out_skb;
+
+        skb->dev = dev;
+        skb->sk  = sk;
+        skb->protocol = htons(ETH_P_IEEE802154);
+
+        dev_put(dev);
+
+        err = dev_queue_xmit(skb);
+        if (err > 0)
+                err = net_xmit_errno(err);
+
+        return err ?: size;
+
+out_skb:
+        kfree_skb(skb);
+out_dev:
+        dev_put(dev);
+out:
+        return err;
+}
+
+static int raw_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
+                       size_t len, int noblock, int flags, int *addr_len)
+{
+        size_t copied = 0;
+        int err = -EOPNOTSUPP;
+        struct sk_buff *skb;
+
+        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);
+
+        if (flags & MSG_TRUNC)
+                copied = skb->len;
+done:
+        skb_free_datagram(sk, skb);
+out:
+        if (err)
+                return err;
+        return copied;
+}
+
+static int raw_rcv_skb(struct sock *sk, struct sk_buff *skb)
+{
+        if (sock_queue_rcv_skb(sk, skb) < 0) {
+                atomic_inc(&sk->sk_drops);
+                kfree_skb(skb);
+                return NET_RX_DROP;
+        }
+
+        return NET_RX_SUCCESS;
+}
+
+
+void ieee802154_raw_deliver(struct net_device *dev, struct sk_buff *skb)
+{
+        struct sock *sk;
+        struct hlist_node *node;
+
+        read_lock(&raw_lock);
+        sk_for_each(sk, node, &raw_head) {
+                bh_lock_sock(sk);
+                if (!sk->sk_bound_dev_if ||
+                    sk->sk_bound_dev_if == dev->ifindex) {
+
+                        struct sk_buff *clone;
+
+                        clone = skb_clone(skb, GFP_ATOMIC);
+                        if (clone)
+                                raw_rcv_skb(sk, clone);
+                }
+                bh_unlock_sock(sk);
+        }
+        read_unlock(&raw_lock);
+}
+
+struct proto ieee802154_raw_prot = {
+        .name           = "IEEE-802.15.4-RAW",
+        .owner          = THIS_MODULE,
+        .obj_size       = sizeof(struct sock),
+        .close          = raw_close,
+        .bind           = raw_bind,
+        .sendmsg        = raw_sendmsg,
+        .recvmsg        = raw_recvmsg,
+        .hash           = raw_hash,
+        .unhash         = raw_unhash,
+        .connect        = raw_connect,
+        .disconnect     = raw_disconnect,
+};
+
diff --git a/net/ipv4/Kconfig b/net/ipv4/Kconfig
index 5b919f7b45db..70491d9035eb 100644
--- a/net/ipv4/Kconfig
+++ b/net/ipv4/Kconfig
@@ -273,29 +273,20 @@ config IP_PIMSM_V2
           you want to play with it.
 
 config ARPD
-        bool "IP: ARP daemon support (EXPERIMENTAL)"
-        depends on EXPERIMENTAL
+        bool "IP: ARP daemon support"
         ---help---
-          Normally, the kernel maintains an internal cache which maps IP
-          addresses to hardware addresses on the local network, so that
-          Ethernet/Token Ring/ etc. frames are sent to the proper address on
-          the physical networking layer. For small networks having a few
-          hundred directly connected hosts or less, keeping this address
-          resolution (ARP) cache inside the kernel works well. However,
-          maintaining an internal ARP cache does not work well for very large
-          switched networks, and will use a lot of kernel memory if TCP/IP
-          connections are made to many machines on the network.
-
-          If you say Y here, the kernel's internal ARP cache will never grow
-          to more than 256 entries (the oldest entries are expired in a LIFO
-          manner) and communication will be attempted with the user space ARP
-          daemon arpd. Arpd then answers the address resolution request either
-          from its own cache or by asking the net.
-
-          This code is experimental and also obsolete. If you want to use it,
-          you need to find a version of the daemon arpd on the net somewhere,
-          and you should also say Y to "Kernel/User network link driver",
-          below. If unsure, say N.
+          The kernel maintains an internal cache which maps IP addresses to
+          hardware addresses on the local network, so that Ethernet/Token Ring/
+          etc. frames are sent to the proper address on the physical networking
+          layer. Normally, kernel uses the ARP protocol to resolve these
+          mappings.
+
+          Saying Y here adds support to have an user space daemon to do this
+          resolution instead. This is useful for implementing an alternate
+          address resolution protocol (e.g. NHRP on mGRE tunnels) and also for
+          testing purposes.
+
+          If unsure, say N.
 
 config SYN_COOKIES
         bool "IP: TCP syncookie support (disabled per default)"
diff --git a/net/ipv4/af_inet.c b/net/ipv4/af_inet.c
index 7f03373b8c07..566ea6c4321d 100644
--- a/net/ipv4/af_inet.c
+++ b/net/ipv4/af_inet.c
@@ -116,7 +116,6 @@
 #include <linux/mroute.h>
 #endif
 
-extern void ip_mc_drop_socket(struct sock *sk);
 
 /* The inetsw table contains everything that inet_create needs to
  * build a new socket.
@@ -375,6 +374,7 @@ lookup_protocol:
         inet->uc_ttl    = -1;
         inet->mc_loop   = 1;
         inet->mc_ttl    = 1;
+        inet->mc_all    = 1;
         inet->mc_index  = 0;
         inet->mc_list   = NULL;
 
@@ -1003,8 +1003,6 @@ void inet_register_protosw(struct inet_protosw *p)
 out:
         spin_unlock_bh(&inetsw_lock);
 
-        synchronize_net();
-
         return;
 
 out_permanent:
@@ -1248,13 +1246,20 @@ static struct sk_buff **inet_gro_receive(struct sk_buff **head,
         struct sk_buff **pp = NULL;
         struct sk_buff *p;
         struct iphdr *iph;
+        unsigned int hlen;
+        unsigned int off;
+        unsigned int id;
         int flush = 1;
         int proto;
-        int id;
 
-        iph = skb_gro_header(skb, sizeof(*iph));
-        if (unlikely(!iph))
-                goto out;
+        off = skb_gro_offset(skb);
+        hlen = off + sizeof(*iph);
+        iph = skb_gro_header_fast(skb, off);
+        if (skb_gro_header_hard(skb, hlen)) {
+                iph = skb_gro_header_slow(skb, hlen, off);
+                if (unlikely(!iph))
+                        goto out;
+        }
 
         proto = iph->protocol & (MAX_INET_PROTOS - 1);
 
@@ -1269,9 +1274,9 @@ static struct sk_buff **inet_gro_receive(struct sk_buff **head,
         if (unlikely(ip_fast_csum((u8 *)iph, iph->ihl)))
                 goto out_unlock;
 
-        flush = ntohs(iph->tot_len) != skb_gro_len(skb) ||
-                iph->frag_off != htons(IP_DF);
-        id = ntohs(iph->id);
+        id = ntohl(*(u32 *)&iph->id);
+        flush = (u16)((ntohl(*(u32 *)iph) ^ skb_gro_len(skb)) | (id ^ IP_DF));
+        id >>= 16;
 
         for (p = *head; p; p = p->next) {
                 struct iphdr *iph2;
diff --git a/net/ipv4/arp.c b/net/ipv4/arp.c
index f11931c18381..8a3881e28aca 100644
--- a/net/ipv4/arp.c
+++ b/net/ipv4/arp.c
@@ -468,13 +468,13 @@ int arp_find(unsigned char *haddr, struct sk_buff *skb)
         __be32 paddr;
         struct neighbour *n;
 
-        if (!skb->dst) {
+        if (!skb_dst(skb)) {
                 printk(KERN_DEBUG "arp_find is called with dst==NULL\n");
                 kfree_skb(skb);
                 return 1;
         }
 
-        paddr = skb->rtable->rt_gateway;
+        paddr = skb_rtable(skb)->rt_gateway;
 
         if (arp_set_predefined(inet_addr_type(dev_net(dev), paddr), haddr, paddr, dev))
                 return 0;
@@ -817,7 +817,7 @@ static int arp_process(struct sk_buff *skb)
         if (arp->ar_op == htons(ARPOP_REQUEST) &&
             ip_route_input(skb, tip, sip, 0, dev) == 0) {
 
-                rt = skb->rtable;
+                rt = skb_rtable(skb);
                 addr_type = rt->rt_type;
 
                 if (addr_type == RTN_LOCAL) {
diff --git a/net/ipv4/devinet.c b/net/ipv4/devinet.c
index 126bb911880f..3863c3a4223f 100644
--- a/net/ipv4/devinet.c
+++ b/net/ipv4/devinet.c
@@ -1347,7 +1347,8 @@ static int devinet_sysctl_forward(ctl_table *ctl, int write,
                 struct net *net = ctl->extra2;
 
                 if (valp != &IPV4_DEVCONF_DFLT(net, FORWARDING)) {
-                        rtnl_lock();
+                        if (!rtnl_trylock())
+                                return restart_syscall();
                         if (valp == &IPV4_DEVCONF_ALL(net, FORWARDING)) {
                                 inet_forward_change(net);
                         } else if (*valp) {
diff --git a/net/ipv4/fib_frontend.c b/net/ipv4/fib_frontend.c
index cafcc49d0993..e2f950592566 100644
--- a/net/ipv4/fib_frontend.c
+++ b/net/ipv4/fib_frontend.c
@@ -40,7 +40,6 @@
 #include <net/route.h>
 #include <net/tcp.h>
 #include <net/sock.h>
-#include <net/icmp.h>
 #include <net/arp.h>
 #include <net/ip_fib.h>
 #include <net/rtnetlink.h>
diff --git a/net/ipv4/fib_hash.c b/net/ipv4/fib_hash.c
index ded8c44fb848..ecd39454235c 100644
--- a/net/ipv4/fib_hash.c
+++ b/net/ipv4/fib_hash.c
@@ -263,7 +263,6 @@ fn_hash_lookup(struct fib_table *tb, const struct flowi *flp, struct fib_result
 
                         err = fib_semantic_match(&f->fn_alias,
                                                  flp, res,
-                                                 f->fn_key, fz->fz_mask,
                                                  fz->fz_order);
                         if (err <= 0)
                                 goto out;
diff --git a/net/ipv4/fib_lookup.h b/net/ipv4/fib_lookup.h
index 2c1623d2768b..637b133973bd 100644
--- a/net/ipv4/fib_lookup.h
+++ b/net/ipv4/fib_lookup.h
@@ -22,8 +22,7 @@ struct fib_alias {
 /* Exported by fib_semantics.c */
 extern int fib_semantic_match(struct list_head *head,
                               const struct flowi *flp,
-                              struct fib_result *res, __be32 zone, __be32 mask,
-                                int prefixlen);
+                              struct fib_result *res, int prefixlen);
 extern void fib_release_info(struct fib_info *);
 extern struct fib_info *fib_create_info(struct fib_config *cfg);
 extern int fib_nh_match(struct fib_config *cfg, struct fib_info *fi);
diff --git a/net/ipv4/fib_rules.c b/net/ipv4/fib_rules.c
index 6080d7120821..92d9d97ec5e3 100644
--- a/net/ipv4/fib_rules.c
+++ b/net/ipv4/fib_rules.c
@@ -134,7 +134,7 @@ static const struct nla_policy fib4_rule_policy[FRA_MAX+1] = {
 };
 
 static int fib4_rule_configure(struct fib_rule *rule, struct sk_buff *skb,
-                               struct nlmsghdr *nlh, struct fib_rule_hdr *frh,
+                               struct fib_rule_hdr *frh,
                                struct nlattr **tb)
 {
         struct net *net = sock_net(skb->sk);
@@ -209,7 +209,7 @@ static int fib4_rule_compare(struct fib_rule *rule, struct fib_rule_hdr *frh,
 }
 
 static int fib4_rule_fill(struct fib_rule *rule, struct sk_buff *skb,
-                          struct nlmsghdr *nlh, struct fib_rule_hdr *frh)
+                          struct fib_rule_hdr *frh)
 {
         struct fib4_rule *rule4 = (struct fib4_rule *) rule;
 
diff --git a/net/ipv4/fib_semantics.c b/net/ipv4/fib_semantics.c
index f831df500907..9b096d6ff3f2 100644
--- a/net/ipv4/fib_semantics.c
+++ b/net/ipv4/fib_semantics.c
@@ -866,8 +866,7 @@ failure:
 
 /* Note! fib_semantic_match intentionally uses  RCU list functions. */
 int fib_semantic_match(struct list_head *head, const struct flowi *flp,
-                       struct fib_result *res, __be32 zone, __be32 mask,
-                        int prefixlen)
+                       struct fib_result *res, int prefixlen)
 {
         struct fib_alias *fa;
         int nh_sel = 0;
diff --git a/net/ipv4/fib_trie.c b/net/ipv4/fib_trie.c
index 33c7c85dfe40..d1a39b1277d6 100644
--- a/net/ipv4/fib_trie.c
+++ b/net/ipv4/fib_trie.c
@@ -123,6 +123,7 @@ struct tnode {
         union {
                 struct rcu_head rcu;
                 struct work_struct work;
+                struct tnode *tnode_free;
         };
         struct node *child[0];
 };
@@ -161,6 +162,8 @@ static void tnode_put_child_reorg(struct tnode *tn, int i, struct node *n,
 static struct node *resize(struct trie *t, struct tnode *tn);
 static struct tnode *inflate(struct trie *t, struct tnode *tn);
 static struct tnode *halve(struct trie *t, struct tnode *tn);
+/* tnodes to free after resize(); protected by RTNL */
+static struct tnode *tnode_free_head;
 
 static struct kmem_cache *fn_alias_kmem __read_mostly;
 static struct kmem_cache *trie_leaf_kmem __read_mostly;
@@ -385,6 +388,29 @@ static inline void tnode_free(struct tnode *tn)
                 call_rcu(&tn->rcu, __tnode_free_rcu);
 }
 
+static void tnode_free_safe(struct tnode *tn)
+{
+        BUG_ON(IS_LEAF(tn));
+
+        if (node_parent((struct node *) tn)) {
+                tn->tnode_free = tnode_free_head;
+                tnode_free_head = tn;
+        } else {
+                tnode_free(tn);
+        }
+}
+
+static void tnode_free_flush(void)
+{
+        struct tnode *tn;
+
+        while ((tn = tnode_free_head)) {
+                tnode_free_head = tn->tnode_free;
+                tn->tnode_free = NULL;
+                tnode_free(tn);
+        }
+}
+
 static struct leaf *leaf_new(void)
 {
         struct leaf *l = kmem_cache_alloc(trie_leaf_kmem, GFP_KERNEL);
@@ -495,7 +521,7 @@ static struct node *resize(struct trie *t, struct tnode *tn)
 
         /* No children */
         if (tn->empty_children == tnode_child_length(tn)) {
-                tnode_free(tn);
+                tnode_free_safe(tn);
                 return NULL;
         }
         /* One child */
@@ -509,7 +535,7 @@ static struct node *resize(struct trie *t, struct tnode *tn)
 
                         /* compress one level */
                         node_set_parent(n, NULL);
-                        tnode_free(tn);
+                        tnode_free_safe(tn);
                         return n;
                 }
         /*
@@ -670,7 +696,7 @@ static struct node *resize(struct trie *t, struct tnode *tn)
                         /* compress one level */
 
                         node_set_parent(n, NULL);
-                        tnode_free(tn);
+                        tnode_free_safe(tn);
                         return n;
                 }
 
@@ -756,7 +782,7 @@ static struct tnode *inflate(struct trie *t, struct tnode *tn)
                         put_child(t, tn, 2*i, inode->child[0]);
                         put_child(t, tn, 2*i+1, inode->child[1]);
 
-                        tnode_free(inode);
+                        tnode_free_safe(inode);
                         continue;
                 }
 
@@ -801,9 +827,9 @@ static struct tnode *inflate(struct trie *t, struct tnode *tn)
                 put_child(t, tn, 2*i, resize(t, left));
                 put_child(t, tn, 2*i+1, resize(t, right));
 
-                tnode_free(inode);
+                tnode_free_safe(inode);
         }
-        tnode_free(oldtnode);
+        tnode_free_safe(oldtnode);
         return tn;
 nomem:
         {
@@ -885,7 +911,7 @@ static struct tnode *halve(struct trie *t, struct tnode *tn)
                 put_child(t, newBinNode, 1, right);
                 put_child(t, tn, i/2, resize(t, newBinNode));
         }
-        tnode_free(oldtnode);
+        tnode_free_safe(oldtnode);
         return tn;
 nomem:
         {
@@ -989,7 +1015,6 @@ static struct node *trie_rebalance(struct trie *t, struct tnode *tn)
         t_key cindex, key;
         struct tnode *tp;
 
-        preempt_disable();
         key = tn->key;
 
         while (tn != NULL && (tp = node_parent((struct node *)tn)) != NULL) {
@@ -1001,16 +1026,18 @@ static struct node *trie_rebalance(struct trie *t, struct tnode *tn)
                                       (struct node *)tn, wasfull);
 
                 tp = node_parent((struct node *) tn);
+                tnode_free_flush();
                 if (!tp)
                         break;
                 tn = tp;
         }
 
         /* Handle last (top) tnode */
-        if (IS_TNODE(tn))
+        if (IS_TNODE(tn)) {
                 tn = (struct tnode *)resize(t, (struct tnode *)tn);
+                tnode_free_flush();
+        }
 
-        preempt_enable();
         return (struct node *)tn;
 }
 
@@ -1351,8 +1378,7 @@ static int check_leaf(struct trie *t, struct leaf *l,
                 if (l->key != (key & ntohl(mask)))
                         continue;
 
-                err = fib_semantic_match(&li->falh, flp, res,
-                                         htonl(l->key), mask, plen);
+                err = fib_semantic_match(&li->falh, flp, res, plen);
 
 #ifdef CONFIG_IP_FIB_TRIE_STATS
                 if (err <= 0)
diff --git a/net/ipv4/icmp.c b/net/ipv4/icmp.c
index 3f50807237e0..97c410e84388 100644
--- a/net/ipv4/icmp.c
+++ b/net/ipv4/icmp.c
@@ -356,7 +356,7 @@ static void icmp_push_reply(struct icmp_bxm *icmp_param,
 static void icmp_reply(struct icmp_bxm *icmp_param, struct sk_buff *skb)
 {
         struct ipcm_cookie ipc;
-        struct rtable *rt = skb->rtable;
+        struct rtable *rt = skb_rtable(skb);
         struct net *net = dev_net(rt->u.dst.dev);
         struct sock *sk;
         struct inet_sock *inet;
@@ -416,7 +416,7 @@ void icmp_send(struct sk_buff *skb_in, int type, int code, __be32 info)
         struct iphdr *iph;
         int room;
         struct icmp_bxm icmp_param;
-        struct rtable *rt = skb_in->rtable;
+        struct rtable *rt = skb_rtable(skb_in);
         struct ipcm_cookie ipc;
         __be32 saddr;
         u8  tos;
@@ -591,13 +591,13 @@ void icmp_send(struct sk_buff *skb_in, int type, int code, __be32 info)
                                 goto relookup_failed;
 
                         /* Ugh! */
-                        odst = skb_in->dst;
+                        odst = skb_dst(skb_in);
                         err = ip_route_input(skb_in, fl.fl4_dst, fl.fl4_src,
                                              RT_TOS(tos), rt2->u.dst.dev);
 
                         dst_release(&rt2->u.dst);
-                        rt2 = skb_in->rtable;
-                        skb_in->dst = odst;
+                        rt2 = skb_rtable(skb_in);
+                        skb_dst_set(skb_in, odst);
                 }
 
                 if (err)
@@ -659,7 +659,7 @@ static void icmp_unreach(struct sk_buff *skb)
         u32 info = 0;
         struct net *net;
 
-        net = dev_net(skb->dst->dev);
+        net = dev_net(skb_dst(skb)->dev);
 
         /*
          *      Incomplete header ?
@@ -822,7 +822,7 @@ static void icmp_echo(struct sk_buff *skb)
 {
         struct net *net;
 
-        net = dev_net(skb->dst->dev);
+        net = dev_net(skb_dst(skb)->dev);
         if (!net->ipv4.sysctl_icmp_echo_ignore_all) {
                 struct icmp_bxm icmp_param;
 
@@ -873,7 +873,7 @@ static void icmp_timestamp(struct sk_buff *skb)
 out:
         return;
 out_err:
-        ICMP_INC_STATS_BH(dev_net(skb->dst->dev), ICMP_MIB_INERRORS);
+        ICMP_INC_STATS_BH(dev_net(skb_dst(skb)->dev), ICMP_MIB_INERRORS);
         goto out;
 }
 
@@ -926,7 +926,7 @@ static void icmp_address(struct sk_buff *skb)
 
 static void icmp_address_reply(struct sk_buff *skb)
 {
-        struct rtable *rt = skb->rtable;
+        struct rtable *rt = skb_rtable(skb);
         struct net_device *dev = skb->dev;
         struct in_device *in_dev;
         struct in_ifaddr *ifa;
@@ -970,7 +970,7 @@ static void icmp_discard(struct sk_buff *skb)
 int icmp_rcv(struct sk_buff *skb)
 {
         struct icmphdr *icmph;
-        struct rtable *rt = skb->rtable;
+        struct rtable *rt = skb_rtable(skb);
         struct net *net = dev_net(rt->u.dst.dev);
 
         if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
diff --git a/net/ipv4/igmp.c b/net/ipv4/igmp.c
index 9eb6219af615..01b4284ed694 100644
--- a/net/ipv4/igmp.c
+++ b/net/ipv4/igmp.c
@@ -311,7 +311,7 @@ static struct sk_buff *igmpv3_newpack(struct net_device *dev, int size)
                 return NULL;
         }
 
-        skb->dst = &rt->u.dst;
+        skb_dst_set(skb, &rt->u.dst);
         skb->dev = dev;
 
         skb_reserve(skb, LL_RESERVED_SPACE(dev));
@@ -659,7 +659,7 @@ static int igmp_send_report(struct in_device *in_dev, struct ip_mc_list *pmc,
                 return -1;
         }
 
-        skb->dst = &rt->u.dst;
+        skb_dst_set(skb, &rt->u.dst);
 
         skb_reserve(skb, LL_RESERVED_SPACE(dev));
 
@@ -948,7 +948,7 @@ int igmp_rcv(struct sk_buff *skb)
         case IGMPV2_HOST_MEMBERSHIP_REPORT:
         case IGMPV3_HOST_MEMBERSHIP_REPORT:
                 /* Is it our report looped back? */
-                if (skb->rtable->fl.iif == 0)
+                if (skb_rtable(skb)->fl.iif == 0)
                         break;
                 /* don't rely on MC router hearing unicast reports */
                 if (skb->pkt_type == PACKET_MULTICAST ||
@@ -2196,7 +2196,7 @@ int ip_mc_sf_allow(struct sock *sk, __be32 loc_addr, __be32 rmt_addr, int dif)
                         break;
         }
         if (!pmc)
-                return 1;
+                return inet->mc_all;
         psl = pmc->sflist;
         if (!psl)
                 return pmc->sfmode == MCAST_EXCLUDE;
diff --git a/net/ipv4/inet_diag.c b/net/ipv4/inet_diag.c
index 588a7796e3e3..b0b273503e2a 100644
--- a/net/ipv4/inet_diag.c
+++ b/net/ipv4/inet_diag.c
@@ -198,8 +198,6 @@ static int inet_twsk_diag_fill(struct inet_timewait_sock *tw,
                 tmo = 0;
 
         r->idiag_family       = tw->tw_family;
-        r->idiag_state        = tw->tw_state;
-        r->idiag_timer        = 0;
         r->idiag_retrans      = 0;
         r->id.idiag_if        = tw->tw_bound_dev_if;
         r->id.idiag_cookie[0] = (u32)(unsigned long)tw;
diff --git a/net/ipv4/inet_timewait_sock.c b/net/ipv4/inet_timewait_sock.c
index 8554d0ea1719..61283f928825 100644
--- a/net/ipv4/inet_timewait_sock.c
+++ b/net/ipv4/inet_timewait_sock.c
@@ -9,6 +9,7 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/kmemcheck.h>
 #include <net/inet_hashtables.h>
 #include <net/inet_timewait_sock.h>
 #include <net/ip.h>
@@ -49,19 +50,22 @@ static void __inet_twsk_kill(struct inet_timewait_sock *tw,
         inet_twsk_put(tw);
 }
 
-void inet_twsk_put(struct inet_timewait_sock *tw)
+static noinline void inet_twsk_free(struct inet_timewait_sock *tw)
 {
-        if (atomic_dec_and_test(&tw->tw_refcnt)) {
-                struct module *owner = tw->tw_prot->owner;
-                twsk_destructor((struct sock *)tw);
+        struct module *owner = tw->tw_prot->owner;
+        twsk_destructor((struct sock *)tw);
 #ifdef SOCK_REFCNT_DEBUG
-                printk(KERN_DEBUG "%s timewait_sock %p released\n",
-                       tw->tw_prot->name, tw);
+        pr_debug("%s timewait_sock %p released\n", tw->tw_prot->name, tw);
 #endif
-                release_net(twsk_net(tw));
-                kmem_cache_free(tw->tw_prot->twsk_prot->twsk_slab, tw);
-                module_put(owner);
-        }
+        release_net(twsk_net(tw));
+        kmem_cache_free(tw->tw_prot->twsk_prot->twsk_slab, tw);
+        module_put(owner);
+}
+
+void inet_twsk_put(struct inet_timewait_sock *tw)
+{
+        if (atomic_dec_and_test(&tw->tw_refcnt))
+                inet_twsk_free(tw);
 }
 EXPORT_SYMBOL_GPL(inet_twsk_put);
 
@@ -117,6 +121,8 @@ struct inet_timewait_sock *inet_twsk_alloc(const struct sock *sk, const int stat
         if (tw != NULL) {
                 const struct inet_sock *inet = inet_sk(sk);
 
+                kmemcheck_annotate_bitfield(tw, flags);
+
                 /* Give us an identity. */
                 tw->tw_daddr        = inet->daddr;
                 tw->tw_rcv_saddr    = inet->rcv_saddr;
diff --git a/net/ipv4/ip_forward.c b/net/ipv4/ip_forward.c
index df3fe50bbf0d..a2991bc8e32e 100644
--- a/net/ipv4/ip_forward.c
+++ b/net/ipv4/ip_forward.c
@@ -42,7 +42,7 @@ static int ip_forward_finish(struct sk_buff *skb)
 {
         struct ip_options * opt = &(IPCB(skb)->opt);
 
-        IP_INC_STATS_BH(dev_net(skb->dst->dev), IPSTATS_MIB_OUTFORWDATAGRAMS);
+        IP_INC_STATS_BH(dev_net(skb_dst(skb)->dev), IPSTATS_MIB_OUTFORWDATAGRAMS);
 
         if (unlikely(opt->optlen))
                 ip_forward_options(skb);
@@ -81,7 +81,7 @@ int ip_forward(struct sk_buff *skb)
         if (!xfrm4_route_forward(skb))
                 goto drop;
 
-        rt = skb->rtable;
+        rt = skb_rtable(skb);
 
         if (opt->is_strictroute && rt->rt_dst != rt->rt_gateway)
                 goto sr_failed;
@@ -123,7 +123,7 @@ sr_failed:
 
 too_many_hops:
         /* Tell the sender its packet died... */
-        IP_INC_STATS_BH(dev_net(skb->dst->dev), IPSTATS_MIB_INHDRERRORS);
+        IP_INC_STATS_BH(dev_net(skb_dst(skb)->dev), IPSTATS_MIB_INHDRERRORS);
         icmp_send(skb, ICMP_TIME_EXCEEDED, ICMP_EXC_TTL, 0);
 drop:
         kfree_skb(skb);
diff --git a/net/ipv4/ip_fragment.c b/net/ipv4/ip_fragment.c
index 7985346653bd..575f9bd51ccd 100644
--- a/net/ipv4/ip_fragment.c
+++ b/net/ipv4/ip_fragment.c
@@ -507,7 +507,7 @@ static int ip_frag_reasm(struct ipq *qp, struct sk_buff *prev,
         /* If the first fragment is fragmented itself, we split
          * it to two chunks: the first with data and paged part
          * and the second, holding only fragments. */
-        if (skb_shinfo(head)->frag_list) {
+        if (skb_has_frags(head)) {
                 struct sk_buff *clone;
                 int i, plen = 0;
 
@@ -516,7 +516,7 @@ static int ip_frag_reasm(struct ipq *qp, struct sk_buff *prev,
                 clone->next = head->next;
                 head->next = clone;
                 skb_shinfo(clone)->frag_list = skb_shinfo(head)->frag_list;
-                skb_shinfo(head)->frag_list = NULL;
+                skb_frag_list_init(head);
                 for (i=0; i<skb_shinfo(head)->nr_frags; i++)
                         plen += skb_shinfo(head)->frags[i].size;
                 clone->len = clone->data_len = head->data_len - plen;
@@ -573,7 +573,7 @@ int ip_defrag(struct sk_buff *skb, u32 user)
         struct ipq *qp;
         struct net *net;
 
-        net = skb->dev ? dev_net(skb->dev) : dev_net(skb->dst->dev);
+        net = skb->dev ? dev_net(skb->dev) : dev_net(skb_dst(skb)->dev);
         IP_INC_STATS_BH(net, IPSTATS_MIB_REASMREQDS);
 
         /* Start by cleaning up the memory. */
diff --git a/net/ipv4/ip_gre.c b/net/ipv4/ip_gre.c
index e62510d5ea5a..44e2a3d2359a 100644
--- a/net/ipv4/ip_gre.c
+++ b/net/ipv4/ip_gre.c
@@ -602,7 +602,7 @@ static int ipgre_rcv(struct sk_buff *skb)
 #ifdef CONFIG_NET_IPGRE_BROADCAST
                 if (ipv4_is_multicast(iph->daddr)) {
                         /* Looped back packet, drop it! */
-                        if (skb->rtable->fl.iif == 0)
+                        if (skb_rtable(skb)->fl.iif == 0)
                                 goto drop;
                         stats->multicast++;
                         skb->pkt_type = PACKET_BROADCAST;
@@ -643,8 +643,7 @@ static int ipgre_rcv(struct sk_buff *skb)
                 stats->rx_packets++;
                 stats->rx_bytes += len;
                 skb->dev = tunnel->dev;
-                dst_release(skb->dst);
-                skb->dst = NULL;
+                skb_dst_drop(skb);
                 nf_reset(skb);
 
                 skb_reset_network_header(skb);
@@ -698,13 +697,13 @@ static int ipgre_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
         if ((dst = tiph->daddr) == 0) {
                 /* NBMA tunnel */
 
-                if (skb->dst == NULL) {
+                if (skb_dst(skb) == NULL) {
                         stats->tx_fifo_errors++;
                         goto tx_error;
                 }
 
                 if (skb->protocol == htons(ETH_P_IP)) {
-                        rt = skb->rtable;
+                        rt = skb_rtable(skb);
                         if ((dst = rt->rt_gateway) == 0)
                                 goto tx_error_icmp;
                 }
@@ -712,7 +711,7 @@ static int ipgre_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
                 else if (skb->protocol == htons(ETH_P_IPV6)) {
                         struct in6_addr *addr6;
                         int addr_type;
-                        struct neighbour *neigh = skb->dst->neighbour;
+                        struct neighbour *neigh = skb_dst(skb)->neighbour;
 
                         if (neigh == NULL)
                                 goto tx_error;
@@ -766,10 +765,10 @@ static int ipgre_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
         if (df)
                 mtu = dst_mtu(&rt->u.dst) - dev->hard_header_len - tunnel->hlen;
         else
-                mtu = skb->dst ? dst_mtu(skb->dst) : dev->mtu;
+                mtu = skb_dst(skb) ? dst_mtu(skb_dst(skb)) : dev->mtu;
 
-        if (skb->dst)
-                skb->dst->ops->update_pmtu(skb->dst, mtu);
+        if (skb_dst(skb))
+                skb_dst(skb)->ops->update_pmtu(skb_dst(skb), mtu);
 
         if (skb->protocol == htons(ETH_P_IP)) {
                 df |= (old_iph->frag_off&htons(IP_DF));
@@ -783,14 +782,14 @@ static int ipgre_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
         }
 #ifdef CONFIG_IPV6
         else if (skb->protocol == htons(ETH_P_IPV6)) {
-                struct rt6_info *rt6 = (struct rt6_info *)skb->dst;
+                struct rt6_info *rt6 = (struct rt6_info *)skb_dst(skb);
 
-                if (rt6 && mtu < dst_mtu(skb->dst) && mtu >= IPV6_MIN_MTU) {
+                if (rt6 && mtu < dst_mtu(skb_dst(skb)) && mtu >= IPV6_MIN_MTU) {
                         if ((tunnel->parms.iph.daddr &&
                              !ipv4_is_multicast(tunnel->parms.iph.daddr)) ||
                             rt6->rt6i_dst.plen == 128) {
                                 rt6->rt6i_flags |= RTF_MODIFIED;
-                                skb->dst->metrics[RTAX_MTU-1] = mtu;
+                                skb_dst(skb)->metrics[RTAX_MTU-1] = mtu;
                         }
                 }
 
@@ -837,8 +836,8 @@ static int ipgre_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
         memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
         IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED |
                               IPSKB_REROUTED);
-        dst_release(skb->dst);
-        skb->dst = &rt->u.dst;
+        skb_dst_drop(skb);
+        skb_dst_set(skb, &rt->u.dst);
 
         /*
          *      Push down and install the IPIP header.
@@ -1238,6 +1237,7 @@ static void ipgre_tunnel_setup(struct net_device *dev)
         dev->iflink             = 0;
         dev->addr_len           = 4;
         dev->features           |= NETIF_F_NETNS_LOCAL;
+        dev->priv_flags         &= ~IFF_XMIT_DST_RELEASE;
 }
 
 static int ipgre_tunnel_init(struct net_device *dev)
diff --git a/net/ipv4/ip_input.c b/net/ipv4/ip_input.c
index 1a58a6fa1dc0..490ce20faf38 100644
--- a/net/ipv4/ip_input.c
+++ b/net/ipv4/ip_input.c
@@ -329,7 +329,7 @@ static int ip_rcv_finish(struct sk_buff *skb)
          *      Initialise the virtual path cache for the packet. It describes
          *      how the packet travels inside Linux networking.
          */
-        if (skb->dst == NULL) {
+        if (skb_dst(skb) == NULL) {
                 int err = ip_route_input(skb, iph->daddr, iph->saddr, iph->tos,
                                          skb->dev);
                 if (unlikely(err)) {
@@ -344,9 +344,9 @@ static int ip_rcv_finish(struct sk_buff *skb)
         }
 
 #ifdef CONFIG_NET_CLS_ROUTE
-        if (unlikely(skb->dst->tclassid)) {
+        if (unlikely(skb_dst(skb)->tclassid)) {
                 struct ip_rt_acct *st = per_cpu_ptr(ip_rt_acct, smp_processor_id());
-                u32 idx = skb->dst->tclassid;
+                u32 idx = skb_dst(skb)->tclassid;
                 st[idx&0xFF].o_packets++;
                 st[idx&0xFF].o_bytes += skb->len;
                 st[(idx>>16)&0xFF].i_packets++;
@@ -357,11 +357,13 @@ static int ip_rcv_finish(struct sk_buff *skb)
         if (iph->ihl > 5 && ip_rcv_options(skb))
                 goto drop;
 
-        rt = skb->rtable;
-        if (rt->rt_type == RTN_MULTICAST)
-                IP_INC_STATS_BH(dev_net(rt->u.dst.dev), IPSTATS_MIB_INMCASTPKTS);
-        else if (rt->rt_type == RTN_BROADCAST)
-                IP_INC_STATS_BH(dev_net(rt->u.dst.dev), IPSTATS_MIB_INBCASTPKTS);
+        rt = skb_rtable(skb);
+        if (rt->rt_type == RTN_MULTICAST) {
+                IP_UPD_PO_STATS_BH(dev_net(rt->u.dst.dev), IPSTATS_MIB_INMCAST,
+                                skb->len);
+        } else if (rt->rt_type == RTN_BROADCAST)
+                IP_UPD_PO_STATS_BH(dev_net(rt->u.dst.dev), IPSTATS_MIB_INBCAST,
+                                skb->len);
 
         return dst_input(skb);
 
@@ -384,7 +386,8 @@ int ip_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt,
         if (skb->pkt_type == PACKET_OTHERHOST)
                 goto drop;
 
-        IP_INC_STATS_BH(dev_net(dev), IPSTATS_MIB_INRECEIVES);
+
+        IP_UPD_PO_STATS_BH(dev_net(dev), IPSTATS_MIB_IN, skb->len);
 
         if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL) {
                 IP_INC_STATS_BH(dev_net(dev), IPSTATS_MIB_INDISCARDS);
diff --git a/net/ipv4/ip_options.c b/net/ipv4/ip_options.c
index 2c88da6e7862..94bf105ef3c9 100644
--- a/net/ipv4/ip_options.c
+++ b/net/ipv4/ip_options.c
@@ -102,7 +102,7 @@ int ip_options_echo(struct ip_options * dopt, struct sk_buff * skb)
         sptr = skb_network_header(skb);
         dptr = dopt->__data;
 
-        daddr = skb->rtable->rt_spec_dst;
+        daddr = skb_rtable(skb)->rt_spec_dst;
 
         if (sopt->rr) {
                 optlen  = sptr[sopt->rr+1];
@@ -143,7 +143,7 @@ int ip_options_echo(struct ip_options * dopt, struct sk_buff * skb)
                                                 __be32 addr;
 
                                                 memcpy(&addr, sptr+soffset-1, 4);
-                                                if (inet_addr_type(dev_net(skb->dst->dev), addr) != RTN_LOCAL) {
+                                                if (inet_addr_type(dev_net(skb_dst(skb)->dev), addr) != RTN_LOCAL) {
                                                         dopt->ts_needtime = 1;
                                                         soffset += 8;
                                                 }
@@ -257,7 +257,7 @@ int ip_options_compile(struct net *net,
         struct rtable *rt = NULL;
 
         if (skb != NULL) {
-                rt = skb->rtable;
+                rt = skb_rtable(skb);
                 optptr = (unsigned char *)&(ip_hdr(skb)[1]);
         } else
                 optptr = opt->__data;
@@ -550,7 +550,7 @@ void ip_forward_options(struct sk_buff *skb)
 {
         struct   ip_options * opt       = &(IPCB(skb)->opt);
         unsigned char * optptr;
-        struct rtable *rt = skb->rtable;
+        struct rtable *rt = skb_rtable(skb);
         unsigned char *raw = skb_network_header(skb);
 
         if (opt->rr_needaddr) {
@@ -598,7 +598,7 @@ int ip_options_rcv_srr(struct sk_buff *skb)
         __be32 nexthop;
         struct iphdr *iph = ip_hdr(skb);
         unsigned char *optptr = skb_network_header(skb) + opt->srr;
-        struct rtable *rt = skb->rtable;
+        struct rtable *rt = skb_rtable(skb);
         struct rtable *rt2;
         int err;
 
@@ -623,13 +623,13 @@ int ip_options_rcv_srr(struct sk_buff *skb)
                 }
                 memcpy(&nexthop, &optptr[srrptr-1], 4);
 
-                rt = skb->rtable;
-                skb->rtable = NULL;
+                rt = skb_rtable(skb);
+                skb_dst_set(skb, NULL);
                 err = ip_route_input(skb, nexthop, iph->saddr, iph->tos, skb->dev);
-                rt2 = skb->rtable;
+                rt2 = skb_rtable(skb);
                 if (err || (rt2->rt_type != RTN_UNICAST && rt2->rt_type != RTN_LOCAL)) {
                         ip_rt_put(rt2);
-                        skb->rtable = rt;
+                        skb_dst_set(skb, &rt->u.dst);
                         return -EINVAL;
                 }
                 ip_rt_put(rt);
diff --git a/net/ipv4/ip_output.c b/net/ipv4/ip_output.c
index 3e7e910c7c0f..247026282669 100644
--- a/net/ipv4/ip_output.c
+++ b/net/ipv4/ip_output.c
@@ -95,7 +95,7 @@ int __ip_local_out(struct sk_buff *skb)
 
         iph->tot_len = htons(skb->len);
         ip_send_check(iph);
-        return nf_hook(PF_INET, NF_INET_LOCAL_OUT, skb, NULL, skb->dst->dev,
+        return nf_hook(PF_INET, NF_INET_LOCAL_OUT, skb, NULL, skb_dst(skb)->dev,
                        dst_output);
 }
 
@@ -118,7 +118,7 @@ static int ip_dev_loopback_xmit(struct sk_buff *newskb)
         __skb_pull(newskb, skb_network_offset(newskb));
         newskb->pkt_type = PACKET_LOOPBACK;
         newskb->ip_summed = CHECKSUM_UNNECESSARY;
-        WARN_ON(!newskb->dst);
+        WARN_ON(!skb_dst(newskb));
         netif_rx(newskb);
         return 0;
 }
@@ -140,7 +140,7 @@ int ip_build_and_send_pkt(struct sk_buff *skb, struct sock *sk,
                           __be32 saddr, __be32 daddr, struct ip_options *opt)
 {
         struct inet_sock *inet = inet_sk(sk);
-        struct rtable *rt = skb->rtable;
+        struct rtable *rt = skb_rtable(skb);
         struct iphdr *iph;
 
         /* Build the IP header. */
@@ -176,15 +176,15 @@ EXPORT_SYMBOL_GPL(ip_build_and_send_pkt);
 
 static inline int ip_finish_output2(struct sk_buff *skb)
 {
-        struct dst_entry *dst = skb->dst;
+        struct dst_entry *dst = skb_dst(skb);
         struct rtable *rt = (struct rtable *)dst;
         struct net_device *dev = dst->dev;
         unsigned int hh_len = LL_RESERVED_SPACE(dev);
 
-        if (rt->rt_type == RTN_MULTICAST)
-                IP_INC_STATS(dev_net(dev), IPSTATS_MIB_OUTMCASTPKTS);
-        else if (rt->rt_type == RTN_BROADCAST)
-                IP_INC_STATS(dev_net(dev), IPSTATS_MIB_OUTBCASTPKTS);
+        if (rt->rt_type == RTN_MULTICAST) {
+                IP_UPD_PO_STATS(dev_net(dev), IPSTATS_MIB_OUTMCAST, skb->len);
+        } else if (rt->rt_type == RTN_BROADCAST)
+                IP_UPD_PO_STATS(dev_net(dev), IPSTATS_MIB_OUTBCAST, skb->len);
 
         /* Be paranoid, rather than too clever. */
         if (unlikely(skb_headroom(skb) < hh_len && dev->header_ops)) {
@@ -217,14 +217,14 @@ static inline int ip_skb_dst_mtu(struct sk_buff *skb)
         struct inet_sock *inet = skb->sk ? inet_sk(skb->sk) : NULL;
 
         return (inet && inet->pmtudisc == IP_PMTUDISC_PROBE) ?
-               skb->dst->dev->mtu : dst_mtu(skb->dst);
+               skb_dst(skb)->dev->mtu : dst_mtu(skb_dst(skb));
 }
 
 static int ip_finish_output(struct sk_buff *skb)
 {
 #if defined(CONFIG_NETFILTER) && defined(CONFIG_XFRM)
         /* Policy lookup after SNAT yielded a new policy */
-        if (skb->dst->xfrm != NULL) {
+        if (skb_dst(skb)->xfrm != NULL) {
                 IPCB(skb)->flags |= IPSKB_REROUTED;
                 return dst_output(skb);
         }
@@ -238,13 +238,13 @@ static int ip_finish_output(struct sk_buff *skb)
 int ip_mc_output(struct sk_buff *skb)
 {
         struct sock *sk = skb->sk;
-        struct rtable *rt = skb->rtable;
+        struct rtable *rt = skb_rtable(skb);
         struct net_device *dev = rt->u.dst.dev;
 
         /*
          *      If the indicated interface is up and running, send the packet.
          */
-        IP_INC_STATS(dev_net(dev), IPSTATS_MIB_OUTREQUESTS);
+        IP_UPD_PO_STATS(dev_net(dev), IPSTATS_MIB_OUT, skb->len);
 
         skb->dev = dev;
         skb->protocol = htons(ETH_P_IP);
@@ -296,9 +296,9 @@ int ip_mc_output(struct sk_buff *skb)
 
 int ip_output(struct sk_buff *skb)
 {
-        struct net_device *dev = skb->dst->dev;
+        struct net_device *dev = skb_dst(skb)->dev;
 
-        IP_INC_STATS(dev_net(dev), IPSTATS_MIB_OUTREQUESTS);
+        IP_UPD_PO_STATS(dev_net(dev), IPSTATS_MIB_OUT, skb->len);
 
         skb->dev = dev;
         skb->protocol = htons(ETH_P_IP);
@@ -319,7 +319,7 @@ int ip_queue_xmit(struct sk_buff *skb, int ipfragok)
         /* Skip all of this if the packet is already routed,
          * f.e. by something like SCTP.
          */
-        rt = skb->rtable;
+        rt = skb_rtable(skb);
         if (rt != NULL)
                 goto packet_routed;
 
@@ -355,7 +355,7 @@ int ip_queue_xmit(struct sk_buff *skb, int ipfragok)
                 }
                 sk_setup_caps(sk, &rt->u.dst);
         }
-        skb->dst = dst_clone(&rt->u.dst);
+        skb_dst_set(skb, dst_clone(&rt->u.dst));
 
 packet_routed:
         if (opt && opt->is_strictroute && rt->rt_dst != rt->rt_gateway)
@@ -401,8 +401,8 @@ static void ip_copy_metadata(struct sk_buff *to, struct sk_buff *from)
         to->pkt_type = from->pkt_type;
         to->priority = from->priority;
         to->protocol = from->protocol;
-        dst_release(to->dst);
-        to->dst = dst_clone(from->dst);
+        skb_dst_drop(to);
+        skb_dst_set(to, dst_clone(skb_dst(from)));
         to->dev = from->dev;
         to->mark = from->mark;
 
@@ -440,7 +440,7 @@ int ip_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *))
         unsigned int mtu, hlen, left, len, ll_rs, pad;
         int offset;
         __be16 not_last_frag;
-        struct rtable *rt = skb->rtable;
+        struct rtable *rt = skb_rtable(skb);
         int err = 0;
 
         dev = rt->u.dst.dev;
@@ -474,7 +474,7 @@ int ip_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *))
          * LATER: this step can be merged to real generation of fragments,
          * we can switch to copy when see the first bad fragment.
          */
-        if (skb_shinfo(skb)->frag_list) {
+        if (skb_has_frags(skb)) {
                 struct sk_buff *frag;
                 int first_len = skb_pagelen(skb);
                 int truesizes = 0;
@@ -485,7 +485,7 @@ int ip_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *))
                     skb_cloned(skb))
                         goto slow_path;
 
-                for (frag = skb_shinfo(skb)->frag_list; frag; frag = frag->next) {
+                skb_walk_frags(skb, frag) {
                         /* Correct geometry. */
                         if (frag->len > mtu ||
                             ((frag->len & 7) && frag->next) ||
@@ -498,7 +498,6 @@ int ip_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *))
 
                         BUG_ON(frag->sk);
                         if (skb->sk) {
-                                sock_hold(skb->sk);
                                 frag->sk = skb->sk;
                                 frag->destructor = sock_wfree;
                                 truesizes += frag->truesize;
@@ -510,7 +509,7 @@ int ip_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *))
                 err = 0;
                 offset = 0;
                 frag = skb_shinfo(skb)->frag_list;
-                skb_shinfo(skb)->frag_list = NULL;
+                skb_frag_list_init(skb);
                 skb->data_len = first_len - skb_headlen(skb);
                 skb->truesize -= truesizes;
                 skb->len = first_len;
@@ -1294,7 +1293,7 @@ int ip_push_pending_frames(struct sock *sk)
          * on dst refcount
          */
         inet->cork.dst = NULL;
-        skb->dst = &rt->u.dst;
+        skb_dst_set(skb, &rt->u.dst);
 
         if (iph->protocol == IPPROTO_ICMP)
                 icmp_out_count(net, ((struct icmphdr *)
@@ -1362,7 +1361,7 @@ void ip_send_reply(struct sock *sk, struct sk_buff *skb, struct ip_reply_arg *ar
         } replyopts;
         struct ipcm_cookie ipc;
         __be32 daddr;
-        struct rtable *rt = skb->rtable;
+        struct rtable *rt = skb_rtable(skb);
 
         if (ip_options_echo(&replyopts.opt, skb))
                 return;
diff --git a/net/ipv4/ip_sockglue.c b/net/ipv4/ip_sockglue.c
index 43c05854d752..fc7993e9061f 100644
--- a/net/ipv4/ip_sockglue.c
+++ b/net/ipv4/ip_sockglue.c
@@ -57,7 +57,7 @@
 static void ip_cmsg_recv_pktinfo(struct msghdr *msg, struct sk_buff *skb)
 {
         struct in_pktinfo info;
-        struct rtable *rt = skb->rtable;
+        struct rtable *rt = skb_rtable(skb);
 
         info.ipi_addr.s_addr = ip_hdr(skb)->daddr;
         if (rt) {
@@ -157,38 +157,39 @@ void ip_cmsg_recv(struct msghdr *msg, struct sk_buff *skb)
         /* Ordered by supposed usage frequency */
         if (flags & 1)
                 ip_cmsg_recv_pktinfo(msg, skb);
-        if ((flags>>=1) == 0)
+        if ((flags >>= 1) == 0)
                 return;
 
         if (flags & 1)
                 ip_cmsg_recv_ttl(msg, skb);
-        if ((flags>>=1) == 0)
+        if ((flags >>= 1) == 0)
                 return;
 
         if (flags & 1)
                 ip_cmsg_recv_tos(msg, skb);
-        if ((flags>>=1) == 0)
+        if ((flags >>= 1) == 0)
                 return;
 
         if (flags & 1)
                 ip_cmsg_recv_opts(msg, skb);
-        if ((flags>>=1) == 0)
+        if ((flags >>= 1) == 0)
                 return;
 
         if (flags & 1)
                 ip_cmsg_recv_retopts(msg, skb);
-        if ((flags>>=1) == 0)
+        if ((flags >>= 1) == 0)
                 return;
 
         if (flags & 1)
                 ip_cmsg_recv_security(msg, skb);
 
-        if ((flags>>=1) == 0)
+        if ((flags >>= 1) == 0)
                 return;
         if (flags & 1)
                 ip_cmsg_recv_dstaddr(msg, skb);
 
 }
+EXPORT_SYMBOL(ip_cmsg_recv);
 
 int ip_cmsg_send(struct net *net, struct msghdr *msg, struct ipcm_cookie *ipc)
 {
@@ -203,7 +204,8 @@ int ip_cmsg_send(struct net *net, struct msghdr *msg, struct ipcm_cookie *ipc)
                 switch (cmsg->cmsg_type) {
                 case IP_RETOPTS:
                         err = cmsg->cmsg_len - CMSG_ALIGN(sizeof(struct cmsghdr));
-                        err = ip_options_get(net, &ipc->opt, CMSG_DATA(cmsg), err < 40 ? err : 40);
+                        err = ip_options_get(net, &ipc->opt, CMSG_DATA(cmsg),
+                                             err < 40 ? err : 40);
                         if (err)
                                 return err;
                         break;
@@ -238,7 +240,8 @@ int ip_cmsg_send(struct net *net, struct msghdr *msg, struct ipcm_cookie *ipc)
 struct ip_ra_chain *ip_ra_chain;
 DEFINE_RWLOCK(ip_ra_lock);
 
-int ip_ra_control(struct sock *sk, unsigned char on, void (*destructor)(struct sock *))
+int ip_ra_control(struct sock *sk, unsigned char on,
+                  void (*destructor)(struct sock *))
 {
         struct ip_ra_chain *ra, *new_ra, **rap;
 
@@ -248,7 +251,7 @@ int ip_ra_control(struct sock *sk, unsigned char on, void (*destructor)(struct s
         new_ra = on ? kmalloc(sizeof(*new_ra), GFP_KERNEL) : NULL;
 
         write_lock_bh(&ip_ra_lock);
-        for (rap = &ip_ra_chain; (ra=*rap) != NULL; rap = &ra->next) {
+        for (rap = &ip_ra_chain; (ra = *rap) != NULL; rap = &ra->next) {
                 if (ra->sk == sk) {
                         if (on) {
                                 write_unlock_bh(&ip_ra_lock);
@@ -416,7 +419,8 @@ int ip_recv_error(struct sock *sk, struct msghdr *msg, int len)
         /* 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) {
+        skb2 = skb_peek(&sk->sk_error_queue);
+        if (skb2 != NULL) {
                 sk->sk_err = SKB_EXT_ERR(skb2)->ee.ee_errno;
                 spin_unlock_bh(&sk->sk_error_queue.lock);
                 sk->sk_error_report(sk);
@@ -431,8 +435,8 @@ out:
 
 
 /*
- *      Socket option code for IP. This is the end of the line after any TCP,UDP etc options on
- *      an IP socket.
+ *      Socket option code for IP. This is the end of the line after any
+ *      TCP,UDP etc options on an IP socket.
  */
 
 static int do_ip_setsockopt(struct sock *sk, int level,
@@ -449,6 +453,7 @@ static int do_ip_setsockopt(struct sock *sk, int level,
                              (1<<IP_ROUTER_ALERT) | (1<<IP_FREEBIND) |
                              (1<<IP_PASSSEC) | (1<<IP_TRANSPARENT))) ||
             optname == IP_MULTICAST_TTL ||
+            optname == IP_MULTICAST_ALL ||
             optname == IP_MULTICAST_LOOP ||
             optname == IP_RECVORIGDSTADDR) {
                 if (optlen >= sizeof(int)) {
@@ -474,7 +479,7 @@ static int do_ip_setsockopt(struct sock *sk, int level,
         switch (optname) {
         case IP_OPTIONS:
         {
-                struct ip_options * opt = NULL;
+                struct ip_options *opt = NULL;
                 if (optlen > 40 || optlen < 0)
                         goto e_inval;
                 err = ip_options_get_from_user(sock_net(sk), &opt,
@@ -556,9 +561,9 @@ static int do_ip_setsockopt(struct sock *sk, int level,
                 }
                 break;
         case IP_TTL:
-                if (optlen<1)
+                if (optlen < 1)
                         goto e_inval;
-                if (val != -1 && (val < 1 || val>255))
+                if (val != -1 && (val < 0 || val > 255))
                         goto e_inval;
                 inet->uc_ttl = val;
                 break;
@@ -570,7 +575,7 @@ static int do_ip_setsockopt(struct sock *sk, int level,
                 inet->hdrincl = val ? 1 : 0;
                 break;
         case IP_MTU_DISCOVER:
-                if (val<0 || val>3)
+                if (val < 0 || val > 3)
                         goto e_inval;
                 inet->pmtudisc = val;
                 break;
@@ -582,7 +587,7 @@ static int do_ip_setsockopt(struct sock *sk, int level,
         case IP_MULTICAST_TTL:
                 if (sk->sk_type == SOCK_STREAM)
                         goto e_inval;
-                if (optlen<1)
+                if (optlen < 1)
                         goto e_inval;
                 if (val == -1)
                         val = 1;
@@ -591,7 +596,7 @@ static int do_ip_setsockopt(struct sock *sk, int level,
                 inet->mc_ttl = val;
                 break;
         case IP_MULTICAST_LOOP:
-                if (optlen<1)
+                if (optlen < 1)
                         goto e_inval;
                 inet->mc_loop = !!val;
                 break;
@@ -613,7 +618,8 @@ static int do_ip_setsockopt(struct sock *sk, int level,
                 } else {
                         memset(&mreq, 0, sizeof(mreq));
                         if (optlen >= sizeof(struct in_addr) &&
-                            copy_from_user(&mreq.imr_address, optval, sizeof(struct in_addr)))
+                            copy_from_user(&mreq.imr_address, optval,
+                                           sizeof(struct in_addr)))
                                 break;
                 }
 
@@ -677,7 +683,6 @@ static int do_ip_setsockopt(struct sock *sk, int level,
         }
         case IP_MSFILTER:
         {
-                extern int sysctl_igmp_max_msf;
                 struct ip_msfilter *msf;
 
                 if (optlen < IP_MSFILTER_SIZE(0))
@@ -831,7 +836,6 @@ static int do_ip_setsockopt(struct sock *sk, int level,
         }
         case MCAST_MSFILTER:
         {
-                extern int sysctl_igmp_max_msf;
                 struct sockaddr_in *psin;
                 struct ip_msfilter *msf = NULL;
                 struct group_filter *gsf = NULL;
@@ -849,9 +853,9 @@ static int do_ip_setsockopt(struct sock *sk, int level,
                         break;
                 }
                 err = -EFAULT;
-                if (copy_from_user(gsf, optval, optlen)) {
+                if (copy_from_user(gsf, optval, optlen))
                         goto mc_msf_out;
-                }
+
                 /* numsrc >= (4G-140)/128 overflow in 32 bits */
                 if (gsf->gf_numsrc >= 0x1ffffff ||
                     gsf->gf_numsrc > sysctl_igmp_max_msf) {
@@ -879,7 +883,7 @@ static int do_ip_setsockopt(struct sock *sk, int level,
                 msf->imsf_fmode = gsf->gf_fmode;
                 msf->imsf_numsrc = gsf->gf_numsrc;
                 err = -EADDRNOTAVAIL;
-                for (i=0; i<gsf->gf_numsrc; ++i) {
+                for (i = 0; i < gsf->gf_numsrc; ++i) {
                         psin = (struct sockaddr_in *)&gsf->gf_slist[i];
 
                         if (psin->sin_family != AF_INET)
@@ -890,17 +894,24 @@ static int do_ip_setsockopt(struct sock *sk, int level,
                 gsf = NULL;
 
                 err = ip_mc_msfilter(sk, msf, ifindex);
-        mc_msf_out:
+mc_msf_out:
                 kfree(msf);
                 kfree(gsf);
                 break;
         }
+        case IP_MULTICAST_ALL:
+                if (optlen < 1)
+                        goto e_inval;
+                if (val != 0 && val != 1)
+                        goto e_inval;
+                inet->mc_all = val;
+                break;
         case IP_ROUTER_ALERT:
                 err = ip_ra_control(sk, val ? 1 : 0, NULL);
                 break;
 
         case IP_FREEBIND:
-                if (optlen<1)
+                if (optlen < 1)
                         goto e_inval;
                 inet->freebind = !!val;
                 break;
@@ -957,6 +968,7 @@ int ip_setsockopt(struct sock *sk, int level,
 #endif
         return err;
 }
+EXPORT_SYMBOL(ip_setsockopt);
 
 #ifdef CONFIG_COMPAT
 int compat_ip_setsockopt(struct sock *sk, int level, int optname,
@@ -986,13 +998,12 @@ int compat_ip_setsockopt(struct sock *sk, int level, int optname,
 #endif
         return err;
 }
-
 EXPORT_SYMBOL(compat_ip_setsockopt);
 #endif
 
 /*
- *      Get the options. Note for future reference. The GET of IP options gets the
- *      _received_ ones. The set sets the _sent_ ones.
+ *      Get the options. Note for future reference. The GET of IP options gets
+ *      the _received_ ones. The set sets the _sent_ ones.
  */
 
 static int do_ip_getsockopt(struct sock *sk, int level, int optname,
@@ -1143,10 +1154,14 @@ static int do_ip_getsockopt(struct sock *sk, int level, int optname,
                         return -EFAULT;
                 }
                 err = ip_mc_gsfget(sk, &gsf,
-                                   (struct group_filter __user *)optval, optlen);
+                                   (struct group_filter __user *)optval,
+                                   optlen);
                 release_sock(sk);
                 return err;
         }
+        case IP_MULTICAST_ALL:
+                val = inet->mc_all;
+                break;
         case IP_PKTOPTIONS:
         {
                 struct msghdr msg;
@@ -1187,7 +1202,7 @@ static int do_ip_getsockopt(struct sock *sk, int level, int optname,
         }
         release_sock(sk);
 
-        if (len < sizeof(int) && len > 0 && val>=0 && val<=255) {
+        if (len < sizeof(int) && len > 0 && val >= 0 && val <= 255) {
                 unsigned char ucval = (unsigned char)val;
                 len = 1;
                 if (put_user(len, optlen))
@@ -1230,6 +1245,7 @@ int ip_getsockopt(struct sock *sk, int level,
 #endif
         return err;
 }
+EXPORT_SYMBOL(ip_getsockopt);
 
 #ifdef CONFIG_COMPAT
 int compat_ip_getsockopt(struct sock *sk, int level, int optname,
@@ -1262,11 +1278,5 @@ int compat_ip_getsockopt(struct sock *sk, int level, int optname,
 #endif
         return err;
 }
-
 EXPORT_SYMBOL(compat_ip_getsockopt);
 #endif
-
-EXPORT_SYMBOL(ip_cmsg_recv);
-
-EXPORT_SYMBOL(ip_getsockopt);
-EXPORT_SYMBOL(ip_setsockopt);
diff --git a/net/ipv4/ipconfig.c b/net/ipv4/ipconfig.c
index 88bf051d0cbb..f8d04c256454 100644
--- a/net/ipv4/ipconfig.c
+++ b/net/ipv4/ipconfig.c
@@ -160,6 +160,9 @@ static char user_dev_name[IFNAMSIZ] __initdata = { 0, };
 /* Protocols supported by available interfaces */
 static int ic_proto_have_if __initdata = 0;
 
+/* MTU for boot device */
+static int ic_dev_mtu __initdata = 0;
+
 #ifdef IPCONFIG_DYNAMIC
 static DEFINE_SPINLOCK(ic_recv_lock);
 static volatile int ic_got_reply __initdata = 0;    /* Proto(s) that replied */
@@ -286,7 +289,7 @@ set_sockaddr(struct sockaddr_in *sin, __be32 addr, __be16 port)
         sin->sin_port = port;
 }
 
-static int __init ic_dev_ioctl(unsigned int cmd, struct ifreq *arg)
+static int __init ic_devinet_ioctl(unsigned int cmd, struct ifreq *arg)
 {
         int res;
 
@@ -297,6 +300,17 @@ static int __init ic_dev_ioctl(unsigned int cmd, struct ifreq *arg)
         return res;
 }
 
+static int __init ic_dev_ioctl(unsigned int cmd, struct ifreq *arg)
+{
+        int res;
+
+        mm_segment_t oldfs = get_fs();
+        set_fs(get_ds());
+        res = dev_ioctl(&init_net, cmd, (struct ifreq __user *) arg);
+        set_fs(oldfs);
+        return res;
+}
+
 static int __init ic_route_ioctl(unsigned int cmd, struct rtentry *arg)
 {
         int res;
@@ -321,20 +335,31 @@ static int __init ic_setup_if(void)
         memset(&ir, 0, sizeof(ir));
         strcpy(ir.ifr_ifrn.ifrn_name, ic_dev->name);
         set_sockaddr(sin, ic_myaddr, 0);
-        if ((err = ic_dev_ioctl(SIOCSIFADDR, &ir)) < 0) {
+        if ((err = ic_devinet_ioctl(SIOCSIFADDR, &ir)) < 0) {
                 printk(KERN_ERR "IP-Config: Unable to set interface address (%d).\n", err);
                 return -1;
         }
         set_sockaddr(sin, ic_netmask, 0);
-        if ((err = ic_dev_ioctl(SIOCSIFNETMASK, &ir)) < 0) {
+        if ((err = ic_devinet_ioctl(SIOCSIFNETMASK, &ir)) < 0) {
                 printk(KERN_ERR "IP-Config: Unable to set interface netmask (%d).\n", err);
                 return -1;
         }
         set_sockaddr(sin, ic_myaddr | ~ic_netmask, 0);
-        if ((err = ic_dev_ioctl(SIOCSIFBRDADDR, &ir)) < 0) {
+        if ((err = ic_devinet_ioctl(SIOCSIFBRDADDR, &ir)) < 0) {
                 printk(KERN_ERR "IP-Config: Unable to set interface broadcast address (%d).\n", err);
                 return -1;
         }
+        /* Handle the case where we need non-standard MTU on the boot link (a network
+         * using jumbo frames, for instance).  If we can't set the mtu, don't error
+         * out, we'll try to muddle along.
+         */
+        if (ic_dev_mtu != 0) {
+                strcpy(ir.ifr_name, ic_dev->name);
+                ir.ifr_mtu = ic_dev_mtu;
+                if ((err = ic_dev_ioctl(SIOCSIFMTU, &ir)) < 0)
+                        printk(KERN_ERR "IP-Config: Unable to set interface mtu to %d (%d).\n",
+                                         ic_dev_mtu, err);
+        }
         return 0;
 }
 
@@ -623,6 +648,7 @@ ic_dhcp_init_options(u8 *options)
                         12,     /* Host name */
                         15,     /* Domain name */
                         17,     /* Boot path */
+                        26,     /* MTU */
                         40,     /* NIS domain name */
                 };
 
@@ -798,6 +824,7 @@ static void __init ic_do_bootp_ext(u8 *ext)
 {
        u8 servers;
        int i;
+        u16 mtu;
 
 #ifdef IPCONFIG_DEBUG
         u8 *c;
@@ -837,6 +864,10 @@ static void __init ic_do_bootp_ext(u8 *ext)
                         if (!root_server_path[0])
                                 ic_bootp_string(root_server_path, ext+1, *ext, sizeof(root_server_path));
                         break;
+                case 26:        /* Interface MTU */
+                        memcpy(&mtu, ext+1, sizeof(mtu));
+                        ic_dev_mtu = ntohs(mtu);
+                        break;
                 case 40:        /* NIS Domain name (_not_ DNS) */
                         ic_bootp_string(utsname()->domainname, ext+1, *ext, __NEW_UTS_LEN);
                         break;
@@ -1403,6 +1434,8 @@ static int __init ip_auto_config(void)
         printk(",\n     bootserver=%pI4", &ic_servaddr);
         printk(", rootserver=%pI4", &root_server_addr);
         printk(", rootpath=%s", root_server_path);
+        if (ic_dev_mtu)
+                printk(", mtu=%d", ic_dev_mtu);
         printk("\n");
 #endif /* !SILENT */
 
diff --git a/net/ipv4/ipip.c b/net/ipv4/ipip.c
index 9054139795af..93e2b787da20 100644
--- a/net/ipv4/ipip.c
+++ b/net/ipv4/ipip.c
@@ -370,8 +370,7 @@ static int ipip_rcv(struct sk_buff *skb)
                 tunnel->dev->stats.rx_packets++;
                 tunnel->dev->stats.rx_bytes += skb->len;
                 skb->dev = tunnel->dev;
-                dst_release(skb->dst);
-                skb->dst = NULL;
+                skb_dst_drop(skb);
                 nf_reset(skb);
                 ipip_ecn_decapsulate(iph, skb);
                 netif_rx(skb);
@@ -416,7 +415,7 @@ static int ipip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
 
         if (!dst) {
                 /* NBMA tunnel */
-                if ((rt = skb->rtable) == NULL) {
+                if ((rt = skb_rtable(skb)) == NULL) {
                         stats->tx_fifo_errors++;
                         goto tx_error;
                 }
@@ -447,15 +446,15 @@ static int ipip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
         if (tiph->frag_off)
                 mtu = dst_mtu(&rt->u.dst) - sizeof(struct iphdr);
         else
-                mtu = skb->dst ? dst_mtu(skb->dst) : dev->mtu;
+                mtu = skb_dst(skb) ? dst_mtu(skb_dst(skb)) : dev->mtu;
 
         if (mtu < 68) {
                 stats->collisions++;
                 ip_rt_put(rt);
                 goto tx_error;
         }
-        if (skb->dst)
-                skb->dst->ops->update_pmtu(skb->dst, mtu);
+        if (skb_dst(skb))
+                skb_dst(skb)->ops->update_pmtu(skb_dst(skb), mtu);
 
         df |= (old_iph->frag_off&htons(IP_DF));
 
@@ -502,8 +501,8 @@ static int ipip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
         memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
         IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED |
                               IPSKB_REROUTED);
-        dst_release(skb->dst);
-        skb->dst = &rt->u.dst;
+        skb_dst_drop(skb);
+        skb_dst_set(skb, &rt->u.dst);
 
         /*
          *      Push down and install the IPIP header.
@@ -713,6 +712,7 @@ static void ipip_tunnel_setup(struct net_device *dev)
         dev->iflink             = 0;
         dev->addr_len           = 4;
         dev->features           |= NETIF_F_NETNS_LOCAL;
+        dev->priv_flags         &= ~IFF_XMIT_DST_RELEASE;
 }
 
 static void ipip_tunnel_init(struct net_device *dev)
diff --git a/net/ipv4/ipmr.c b/net/ipv4/ipmr.c
index 13e9dd3012b3..9a8da5ed92b7 100644
--- a/net/ipv4/ipmr.c
+++ b/net/ipv4/ipmr.c
@@ -226,9 +226,10 @@ static void reg_vif_setup(struct net_device *dev)
         dev->flags              = IFF_NOARP;
         dev->netdev_ops         = &reg_vif_netdev_ops,
         dev->destructor         = free_netdev;
+        dev->features           |= NETIF_F_NETNS_LOCAL;
 }
 
-static struct net_device *ipmr_reg_vif(void)
+static struct net_device *ipmr_reg_vif(struct net *net)
 {
         struct net_device *dev;
         struct in_device *in_dev;
@@ -238,6 +239,8 @@ static struct net_device *ipmr_reg_vif(void)
         if (dev == NULL)
                 return NULL;
 
+        dev_net_set(dev, net);
+
         if (register_netdevice(dev)) {
                 free_netdev(dev);
                 return NULL;
@@ -448,7 +451,7 @@ static int vif_add(struct net *net, struct vifctl *vifc, int mrtsock)
                  */
                 if (net->ipv4.mroute_reg_vif_num >= 0)
                         return -EADDRINUSE;
-                dev = ipmr_reg_vif();
+                dev = ipmr_reg_vif(net);
                 if (!dev)
                         return -ENOBUFS;
                 err = dev_set_allmulti(dev, 1);
@@ -651,7 +654,7 @@ static int ipmr_cache_report(struct net *net,
         ip_hdr(skb)->protocol = 0;                      /* Flag to the kernel this is a route add */
         msg = (struct igmpmsg *)skb_network_header(skb);
         msg->im_vif = vifi;
-        skb->dst = dst_clone(pkt->dst);
+        skb_dst_set(skb, dst_clone(skb_dst(pkt)));
 
         /*
          *      Add our header
@@ -1031,16 +1034,6 @@ int ip_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, int
                 if (v != net->ipv4.mroute_do_pim) {
                         net->ipv4.mroute_do_pim = v;
                         net->ipv4.mroute_do_assert = v;
-#ifdef CONFIG_IP_PIMSM_V2
-                        if (net->ipv4.mroute_do_pim)
-                                ret = inet_add_protocol(&pim_protocol,
-                                                        IPPROTO_PIM);
-                        else
-                                ret = inet_del_protocol(&pim_protocol,
-                                                        IPPROTO_PIM);
-                        if (ret < 0)
-                                ret = -EAGAIN;
-#endif
                 }
                 rtnl_unlock();
                 return ret;
@@ -1201,7 +1194,7 @@ static void ip_encap(struct sk_buff *skb, __be32 saddr, __be32 daddr)
         iph->protocol   =       IPPROTO_IPIP;
         iph->ihl        =       5;
         iph->tot_len    =       htons(skb->len);
-        ip_select_ident(iph, skb->dst, NULL);
+        ip_select_ident(iph, skb_dst(skb), NULL);
         ip_send_check(iph);
 
         memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
@@ -1212,7 +1205,7 @@ static inline int ipmr_forward_finish(struct sk_buff *skb)
 {
         struct ip_options * opt = &(IPCB(skb)->opt);
 
-        IP_INC_STATS_BH(dev_net(skb->dst->dev), IPSTATS_MIB_OUTFORWDATAGRAMS);
+        IP_INC_STATS_BH(dev_net(skb_dst(skb)->dev), IPSTATS_MIB_OUTFORWDATAGRAMS);
 
         if (unlikely(opt->optlen))
                 ip_forward_options(skb);
@@ -1290,8 +1283,8 @@ static void ipmr_queue_xmit(struct sk_buff *skb, struct mfc_cache *c, int vifi)
         vif->pkt_out++;
         vif->bytes_out += skb->len;
 
-        dst_release(skb->dst);
-        skb->dst = &rt->u.dst;
+        skb_dst_drop(skb);
+        skb_dst_set(skb, &rt->u.dst);
         ip_decrease_ttl(ip_hdr(skb));
 
         /* FIXME: forward and output firewalls used to be called here.
@@ -1354,7 +1347,7 @@ static int ip_mr_forward(struct sk_buff *skb, struct mfc_cache *cache, int local
         if (net->ipv4.vif_table[vif].dev != skb->dev) {
                 int true_vifi;
 
-                if (skb->rtable->fl.iif == 0) {
+                if (skb_rtable(skb)->fl.iif == 0) {
                         /* It is our own packet, looped back.
                            Very complicated situation...
 
@@ -1430,7 +1423,7 @@ int ip_mr_input(struct sk_buff *skb)
 {
         struct mfc_cache *cache;
         struct net *net = dev_net(skb->dev);
-        int local = skb->rtable->rt_flags&RTCF_LOCAL;
+        int local = skb_rtable(skb)->rt_flags & RTCF_LOCAL;
 
         /* Packet is looped back after forward, it should not be
            forwarded second time, but still can be delivered locally.
@@ -1543,8 +1536,7 @@ static int __pim_rcv(struct sk_buff *skb, unsigned int pimlen)
         skb->protocol = htons(ETH_P_IP);
         skb->ip_summed = 0;
         skb->pkt_type = PACKET_HOST;
-        dst_release(skb->dst);
-        skb->dst = NULL;
+        skb_dst_drop(skb);
         reg_dev->stats.rx_bytes += skb->len;
         reg_dev->stats.rx_packets++;
         nf_reset(skb);
@@ -1646,7 +1638,7 @@ int ipmr_get_route(struct net *net,
 {
         int err;
         struct mfc_cache *cache;
-        struct rtable *rt = skb->rtable;
+        struct rtable *rt = skb_rtable(skb);
 
         read_lock(&mrt_lock);
         cache = ipmr_cache_find(net, rt->rt_src, rt->rt_dst);
@@ -1955,6 +1947,7 @@ static const struct file_operations ipmr_mfc_fops = {
 #ifdef CONFIG_IP_PIMSM_V2
 static struct net_protocol pim_protocol = {
         .handler        =       pim_rcv,
+        .netns_ok       =       1,
 };
 #endif
 
@@ -2041,8 +2034,19 @@ int __init ip_mr_init(void)
         err = register_netdevice_notifier(&ip_mr_notifier);
         if (err)
                 goto reg_notif_fail;
+#ifdef CONFIG_IP_PIMSM_V2
+        if (inet_add_protocol(&pim_protocol, IPPROTO_PIM) < 0) {
+                printk(KERN_ERR "ip_mr_init: can't add PIM protocol\n");
+                err = -EAGAIN;
+                goto add_proto_fail;
+        }
+#endif
         return 0;
 
+#ifdef CONFIG_IP_PIMSM_V2
+add_proto_fail:
+        unregister_netdevice_notifier(&ip_mr_notifier);
+#endif
 reg_notif_fail:
         del_timer(&ipmr_expire_timer);
         unregister_pernet_subsys(&ipmr_net_ops);
diff --git a/net/ipv4/netfilter.c b/net/ipv4/netfilter.c
index fdf6811c31a2..1725dc0ef688 100644
--- a/net/ipv4/netfilter.c
+++ b/net/ipv4/netfilter.c
@@ -12,7 +12,7 @@
 /* route_me_harder function, used by iptable_nat, iptable_mangle + ip_queue */
 int ip_route_me_harder(struct sk_buff *skb, unsigned addr_type)
 {
-        struct net *net = dev_net(skb->dst->dev);
+        struct net *net = dev_net(skb_dst(skb)->dev);
         const struct iphdr *iph = ip_hdr(skb);
         struct rtable *rt;
         struct flowi fl = {};
@@ -41,8 +41,8 @@ int ip_route_me_harder(struct sk_buff *skb, unsigned addr_type)
                         return -1;
 
                 /* Drop old route. */
-                dst_release(skb->dst);
-                skb->dst = &rt->u.dst;
+                skb_dst_drop(skb);
+                skb_dst_set(skb, &rt->u.dst);
         } else {
                 /* non-local src, find valid iif to satisfy
                  * rp-filter when calling ip_route_input. */
@@ -50,7 +50,7 @@ int ip_route_me_harder(struct sk_buff *skb, unsigned addr_type)
                 if (ip_route_output_key(net, &rt, &fl) != 0)
                         return -1;
 
-                odst = skb->dst;
+                odst = skb_dst(skb);
                 if (ip_route_input(skb, iph->daddr, iph->saddr,
                                    RT_TOS(iph->tos), rt->u.dst.dev) != 0) {
                         dst_release(&rt->u.dst);
@@ -60,18 +60,22 @@ int ip_route_me_harder(struct sk_buff *skb, unsigned addr_type)
                 dst_release(odst);
         }
 
-        if (skb->dst->error)
+        if (skb_dst(skb)->error)
                 return -1;
 
 #ifdef CONFIG_XFRM
         if (!(IPCB(skb)->flags & IPSKB_XFRM_TRANSFORMED) &&
-            xfrm_decode_session(skb, &fl, AF_INET) == 0)
-                if (xfrm_lookup(net, &skb->dst, &fl, skb->sk, 0))
+            xfrm_decode_session(skb, &fl, AF_INET) == 0) {
+                struct dst_entry *dst = skb_dst(skb);
+                skb_dst_set(skb, NULL);
+                if (xfrm_lookup(net, &dst, &fl, skb->sk, 0))
                         return -1;
+                skb_dst_set(skb, dst);
+        }
 #endif
 
         /* Change in oif may mean change in hh_len. */
-        hh_len = skb->dst->dev->hard_header_len;
+        hh_len = skb_dst(skb)->dev->hard_header_len;
         if (skb_headroom(skb) < hh_len &&
             pskb_expand_head(skb, hh_len - skb_headroom(skb), 0, GFP_ATOMIC))
                 return -1;
@@ -92,7 +96,7 @@ int ip_xfrm_me_harder(struct sk_buff *skb)
         if (xfrm_decode_session(skb, &fl, AF_INET) < 0)
                 return -1;
 
-        dst = skb->dst;
+        dst = skb_dst(skb);
         if (dst->xfrm)
                 dst = ((struct xfrm_dst *)dst)->route;
         dst_hold(dst);
@@ -100,11 +104,11 @@ int ip_xfrm_me_harder(struct sk_buff *skb)
         if (xfrm_lookup(dev_net(dst->dev), &dst, &fl, skb->sk, 0) < 0)
                 return -1;
 
-        dst_release(skb->dst);
-        skb->dst = dst;
+        skb_dst_drop(skb);
+        skb_dst_set(skb, dst);
 
         /* Change in oif may mean change in hh_len. */
-        hh_len = skb->dst->dev->hard_header_len;
+        hh_len = skb_dst(skb)->dev->hard_header_len;
         if (skb_headroom(skb) < hh_len &&
             pskb_expand_head(skb, hh_len - skb_headroom(skb), 0, GFP_ATOMIC))
                 return -1;
diff --git a/net/ipv4/netfilter/arp_tables.c b/net/ipv4/netfilter/arp_tables.c
index 831fe1879dc0..7505dff4ffdf 100644
--- a/net/ipv4/netfilter/arp_tables.c
+++ b/net/ipv4/netfilter/arp_tables.c
@@ -231,6 +231,12 @@ static inline struct arpt_entry *get_entry(void *base, unsigned int offset)
         return (struct arpt_entry *)(base + offset);
 }
 
+static inline __pure
+struct arpt_entry *arpt_next_entry(const struct arpt_entry *entry)
+{
+        return (void *)entry + entry->next_offset;
+}
+
 unsigned int arpt_do_table(struct sk_buff *skb,
                            unsigned int hook,
                            const struct net_device *in,
@@ -267,67 +273,64 @@ unsigned int arpt_do_table(struct sk_buff *skb,
 
         arp = arp_hdr(skb);
         do {
-                if (arp_packet_match(arp, skb->dev, indev, outdev, &e->arp)) {
-                        struct arpt_entry_target *t;
-                        int hdr_len;
-
-                        hdr_len = sizeof(*arp) + (2 * sizeof(struct in_addr)) +
-                                (2 * skb->dev->addr_len);
+                struct arpt_entry_target *t;
+                int hdr_len;
 
-                        ADD_COUNTER(e->counters, hdr_len, 1);
+                if (!arp_packet_match(arp, skb->dev, indev, outdev, &e->arp)) {
+                        e = arpt_next_entry(e);
+                        continue;
+                }
 
-                        t = arpt_get_target(e);
+                hdr_len = sizeof(*arp) + (2 * sizeof(struct in_addr)) +
+                        (2 * skb->dev->addr_len);
+                ADD_COUNTER(e->counters, hdr_len, 1);
 
-                        /* Standard target? */
-                        if (!t->u.kernel.target->target) {
-                                int v;
+                t = arpt_get_target(e);
 
-                                v = ((struct arpt_standard_target *)t)->verdict;
-                                if (v < 0) {
-                                        /* Pop from stack? */
-                                        if (v != ARPT_RETURN) {
-                                                verdict = (unsigned)(-v) - 1;
-                                                break;
-                                        }
-                                        e = back;
-                                        back = get_entry(table_base,
-                                                         back->comefrom);
-                                        continue;
-                                }
-                                if (table_base + v
-                                    != (void *)e + e->next_offset) {
-                                        /* Save old back ptr in next entry */
-                                        struct arpt_entry *next
-                                                = (void *)e + e->next_offset;
-                                        next->comefrom =
-                                                (void *)back - table_base;
-
-                                        /* set back pointer to next entry */
-                                        back = next;
-                                }
+                /* Standard target? */
+                if (!t->u.kernel.target->target) {
+                        int v;
 
-                                e = get_entry(table_base, v);
-                        } else {
-                                /* Targets which reenter must return
-                                 * abs. verdicts
-                                 */
-                                tgpar.target   = t->u.kernel.target;
-                                tgpar.targinfo = t->data;
-                                verdict = t->u.kernel.target->target(skb,
-                                                                     &tgpar);
-
-                                /* Target might have changed stuff. */
-                                arp = arp_hdr(skb);
-
-                                if (verdict == ARPT_CONTINUE)
-                                        e = (void *)e + e->next_offset;
-                                else
-                                        /* Verdict */
+                        v = ((struct arpt_standard_target *)t)->verdict;
+                        if (v < 0) {
+                                /* Pop from stack? */
+                                if (v != ARPT_RETURN) {
+                                        verdict = (unsigned)(-v) - 1;
                                         break;
+                                }
+                                e = back;
+                                back = get_entry(table_base, back->comefrom);
+                                continue;
                         }
-                } else {
-                        e = (void *)e + e->next_offset;
+                        if (table_base + v
+                            != arpt_next_entry(e)) {
+                                /* Save old back ptr in next entry */
+                                struct arpt_entry *next = arpt_next_entry(e);
+                                next->comefrom = (void *)back - table_base;
+
+                                /* set back pointer to next entry */
+                                back = next;
+                        }
+
+                        e = get_entry(table_base, v);
+                        continue;
                 }
+
+                /* Targets which reenter must return
+                 * abs. verdicts
+                 */
+                tgpar.target   = t->u.kernel.target;
+                tgpar.targinfo = t->data;
+                verdict = t->u.kernel.target->target(skb, &tgpar);
+
+                /* Target might have changed stuff. */
+                arp = arp_hdr(skb);
+
+                if (verdict == ARPT_CONTINUE)
+                        e = arpt_next_entry(e);
+                else
+                        /* Verdict */
+                        break;
         } while (!hotdrop);
         xt_info_rdunlock_bh();
 
diff --git a/net/ipv4/netfilter/ip_queue.c b/net/ipv4/netfilter/ip_queue.c
index 5f22c91c6e15..c156db215987 100644
--- a/net/ipv4/netfilter/ip_queue.c
+++ b/net/ipv4/netfilter/ip_queue.c
@@ -596,7 +596,7 @@ static int __init ip_queue_init(void)
 #ifdef CONFIG_SYSCTL
         ipq_sysctl_header = register_sysctl_paths(net_ipv4_ctl_path, ipq_table);
 #endif
-        status = nf_register_queue_handler(PF_INET, &nfqh);
+        status = nf_register_queue_handler(NFPROTO_IPV4, &nfqh);
         if (status < 0) {
                 printk(KERN_ERR "ip_queue: failed to register queue handler\n");
                 goto cleanup_sysctl;
diff --git a/net/ipv4/netfilter/ip_tables.c b/net/ipv4/netfilter/ip_tables.c
index 2ec8d7290c40..fdefae6b5dfc 100644
--- a/net/ipv4/netfilter/ip_tables.c
+++ b/net/ipv4/netfilter/ip_tables.c
@@ -238,8 +238,8 @@ static struct nf_loginfo trace_loginfo = {
 /* Mildly perf critical (only if packet tracing is on) */
 static inline int
 get_chainname_rulenum(struct ipt_entry *s, struct ipt_entry *e,
-                      char *hookname, char **chainname,
-                      char **comment, unsigned int *rulenum)
+                      const char *hookname, const char **chainname,
+                      const char **comment, unsigned int *rulenum)
 {
         struct ipt_standard_target *t = (void *)ipt_get_target(s);
 
@@ -257,8 +257,8 @@ get_chainname_rulenum(struct ipt_entry *s, struct ipt_entry *e,
                    && unconditional(&s->ip)) {
                         /* Tail of chains: STANDARD target (return/policy) */
                         *comment = *chainname == hookname
-                                ? (char *)comments[NF_IP_TRACE_COMMENT_POLICY]
-                                : (char *)comments[NF_IP_TRACE_COMMENT_RETURN];
+                                ? comments[NF_IP_TRACE_COMMENT_POLICY]
+                                : comments[NF_IP_TRACE_COMMENT_RETURN];
                 }
                 return 1;
         } else
@@ -277,14 +277,14 @@ static void trace_packet(struct sk_buff *skb,
 {
         void *table_base;
         const struct ipt_entry *root;
-        char *hookname, *chainname, *comment;
+        const char *hookname, *chainname, *comment;
         unsigned int rulenum = 0;
 
-        table_base = (void *)private->entries[smp_processor_id()];
+        table_base = private->entries[smp_processor_id()];
         root = get_entry(table_base, private->hook_entry[hook]);
 
-        hookname = chainname = (char *)hooknames[hook];
-        comment = (char *)comments[NF_IP_TRACE_COMMENT_RULE];
+        hookname = chainname = hooknames[hook];
+        comment = comments[NF_IP_TRACE_COMMENT_RULE];
 
         IPT_ENTRY_ITERATE(root,
                           private->size - private->hook_entry[hook],
@@ -297,6 +297,12 @@ static void trace_packet(struct sk_buff *skb,
 }
 #endif
 
+static inline __pure
+struct ipt_entry *ipt_next_entry(const struct ipt_entry *entry)
+{
+        return (void *)entry + entry->next_offset;
+}
+
 /* Returns one of the generic firewall policies, like NF_ACCEPT. */
 unsigned int
 ipt_do_table(struct sk_buff *skb,
@@ -305,6 +311,8 @@ ipt_do_table(struct sk_buff *skb,
              const struct net_device *out,
              struct xt_table *table)
 {
+#define tb_comefrom ((struct ipt_entry *)table_base)->comefrom
+
         static const char nulldevname[IFNAMSIZ] __attribute__((aligned(sizeof(long))));
         const struct iphdr *ip;
         u_int16_t datalen;
@@ -335,7 +343,7 @@ ipt_do_table(struct sk_buff *skb,
         mtpar.in      = tgpar.in  = in;
         mtpar.out     = tgpar.out = out;
         mtpar.family  = tgpar.family = NFPROTO_IPV4;
-        tgpar.hooknum = hook;
+        mtpar.hooknum = tgpar.hooknum = hook;
 
         IP_NF_ASSERT(table->valid_hooks & (1 << hook));
         xt_info_rdlock_bh();
@@ -348,92 +356,84 @@ ipt_do_table(struct sk_buff *skb,
         back = get_entry(table_base, private->underflow[hook]);
 
         do {
+                struct ipt_entry_target *t;
+
                 IP_NF_ASSERT(e);
                 IP_NF_ASSERT(back);
-                if (ip_packet_match(ip, indev, outdev,
-                    &e->ip, mtpar.fragoff)) {
-                        struct ipt_entry_target *t;
-
-                        if (IPT_MATCH_ITERATE(e, do_match, skb, &mtpar) != 0)
-                                goto no_match;
+                if (!ip_packet_match(ip, indev, outdev,
+                    &e->ip, mtpar.fragoff) ||
+                    IPT_MATCH_ITERATE(e, do_match, skb, &mtpar) != 0) {
+                        e = ipt_next_entry(e);
+                        continue;
+                }
 
-                        ADD_COUNTER(e->counters, ntohs(ip->tot_len), 1);
+                ADD_COUNTER(e->counters, ntohs(ip->tot_len), 1);
 
-                        t = ipt_get_target(e);
-                        IP_NF_ASSERT(t->u.kernel.target);
+                t = ipt_get_target(e);
+                IP_NF_ASSERT(t->u.kernel.target);
 
 #if defined(CONFIG_NETFILTER_XT_TARGET_TRACE) || \
     defined(CONFIG_NETFILTER_XT_TARGET_TRACE_MODULE)
-                        /* The packet is traced: log it */
-                        if (unlikely(skb->nf_trace))
-                                trace_packet(skb, hook, in, out,
-                                             table->name, private, e);
+                /* The packet is traced: log it */
+                if (unlikely(skb->nf_trace))
+                        trace_packet(skb, hook, in, out,
+                                     table->name, private, e);
 #endif
-                        /* Standard target? */
-                        if (!t->u.kernel.target->target) {
-                                int v;
-
-                                v = ((struct ipt_standard_target *)t)->verdict;
-                                if (v < 0) {
-                                        /* Pop from stack? */
-                                        if (v != IPT_RETURN) {
-                                                verdict = (unsigned)(-v) - 1;
-                                                break;
-                                        }
-                                        e = back;
-                                        back = get_entry(table_base,
-                                                         back->comefrom);
-                                        continue;
-                                }
-                                if (table_base + v != (void *)e + e->next_offset
-                                    && !(e->ip.flags & IPT_F_GOTO)) {
-                                        /* Save old back ptr in next entry */
-                                        struct ipt_entry *next
-                                                = (void *)e + e->next_offset;
-                                        next->comefrom
-                                                = (void *)back - table_base;
-                                        /* set back pointer to next entry */
-                                        back = next;
+                /* Standard target? */
+                if (!t->u.kernel.target->target) {
+                        int v;
+
+                        v = ((struct ipt_standard_target *)t)->verdict;
+                        if (v < 0) {
+                                /* Pop from stack? */
+                                if (v != IPT_RETURN) {
+                                        verdict = (unsigned)(-v) - 1;
+                                        break;
                                 }
+                                e = back;
+                                back = get_entry(table_base, back->comefrom);
+                                continue;
+                        }
+                        if (table_base + v != ipt_next_entry(e)
+                            && !(e->ip.flags & IPT_F_GOTO)) {
+                                /* Save old back ptr in next entry */
+                                struct ipt_entry *next = ipt_next_entry(e);
+                                next->comefrom = (void *)back - table_base;
+                                /* set back pointer to next entry */
+                                back = next;
+                        }
+
+                        e = get_entry(table_base, v);
+                        continue;
+                }
+
+                /* Targets which reenter must return
+                   abs. verdicts */
+                tgpar.target   = t->u.kernel.target;
+                tgpar.targinfo = t->data;
+
 
-                                e = get_entry(table_base, v);
-                        } else {
-                                /* Targets which reenter must return
-                                   abs. verdicts */
-                                tgpar.target   = t->u.kernel.target;
-                                tgpar.targinfo = t->data;
 #ifdef CONFIG_NETFILTER_DEBUG
-                                ((struct ipt_entry *)table_base)->comefrom
-                                        = 0xeeeeeeec;
+                tb_comefrom = 0xeeeeeeec;
 #endif
-                                verdict = t->u.kernel.target->target(skb,
-                                                                     &tgpar);
+                verdict = t->u.kernel.target->target(skb, &tgpar);
 #ifdef CONFIG_NETFILTER_DEBUG
-                                if (((struct ipt_entry *)table_base)->comefrom
-                                    != 0xeeeeeeec
-                                    && verdict == IPT_CONTINUE) {
-                                        printk("Target %s reentered!\n",
-                                               t->u.kernel.target->name);
-                                        verdict = NF_DROP;
-                                }
-                                ((struct ipt_entry *)table_base)->comefrom
-                                        = 0x57acc001;
+                if (tb_comefrom != 0xeeeeeeec && verdict == IPT_CONTINUE) {
+                        printk("Target %s reentered!\n",
+                               t->u.kernel.target->name);
+                        verdict = NF_DROP;
+                }
+                tb_comefrom = 0x57acc001;
 #endif
-                                /* Target might have changed stuff. */
-                                ip = ip_hdr(skb);
-                                datalen = skb->len - ip->ihl * 4;
-
-                                if (verdict == IPT_CONTINUE)
-                                        e = (void *)e + e->next_offset;
-                                else
-                                        /* Verdict */
-                                        break;
-                        }
-                } else {
+                /* Target might have changed stuff. */
+                ip = ip_hdr(skb);
+                datalen = skb->len - ip->ihl * 4;
 
-                no_match:
-                        e = (void *)e + e->next_offset;
-                }
+                if (verdict == IPT_CONTINUE)
+                        e = ipt_next_entry(e);
+                else
+                        /* Verdict */
+                        break;
         } while (!hotdrop);
         xt_info_rdunlock_bh();
 
@@ -444,6 +444,8 @@ ipt_do_table(struct sk_buff *skb,
                 return NF_DROP;
         else return verdict;
 #endif
+
+#undef tb_comefrom
 }
 
 /* Figures out from what hook each rule can be called: returns 0 if
@@ -2158,7 +2160,7 @@ static bool icmp_checkentry(const struct xt_mtchk_param *par)
 static struct xt_target ipt_standard_target __read_mostly = {
         .name           = IPT_STANDARD_TARGET,
         .targetsize     = sizeof(int),
-        .family         = AF_INET,
+        .family         = NFPROTO_IPV4,
 #ifdef CONFIG_COMPAT
         .compatsize     = sizeof(compat_int_t),
         .compat_from_user = compat_standard_from_user,
@@ -2170,7 +2172,7 @@ static struct xt_target ipt_error_target __read_mostly = {
         .name           = IPT_ERROR_TARGET,
         .target         = ipt_error,
         .targetsize     = IPT_FUNCTION_MAXNAMELEN,
-        .family         = AF_INET,
+        .family         = NFPROTO_IPV4,
 };
 
 static struct nf_sockopt_ops ipt_sockopts = {
@@ -2196,17 +2198,17 @@ static struct xt_match icmp_matchstruct __read_mostly = {
         .matchsize      = sizeof(struct ipt_icmp),
         .checkentry     = icmp_checkentry,
         .proto          = IPPROTO_ICMP,
-        .family         = AF_INET,
+        .family         = NFPROTO_IPV4,
 };
 
 static int __net_init ip_tables_net_init(struct net *net)
 {
-        return xt_proto_init(net, AF_INET);
+        return xt_proto_init(net, NFPROTO_IPV4);
 }
 
 static void __net_exit ip_tables_net_exit(struct net *net)
 {
-        xt_proto_fini(net, AF_INET);
+        xt_proto_fini(net, NFPROTO_IPV4);
 }
 
 static struct pernet_operations ip_tables_net_ops = {
diff --git a/net/ipv4/netfilter/ipt_MASQUERADE.c b/net/ipv4/netfilter/ipt_MASQUERADE.c
index f389f60cb105..dada0863946d 100644
--- a/net/ipv4/netfilter/ipt_MASQUERADE.c
+++ b/net/ipv4/netfilter/ipt_MASQUERADE.c
@@ -27,9 +27,6 @@ MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Netfilter Core Team <coreteam@netfilter.org>");
 MODULE_DESCRIPTION("Xtables: automatic-address SNAT");
 
-/* Lock protects masq region inside conntrack */
-static DEFINE_RWLOCK(masq_lock);
-
 /* FIXME: Multiple targets. --RR */
 static bool masquerade_tg_check(const struct xt_tgchk_param *par)
 {
@@ -72,16 +69,14 @@ masquerade_tg(struct sk_buff *skb, const struct xt_target_param *par)
                 return NF_ACCEPT;
 
         mr = par->targinfo;
-        rt = skb->rtable;
+        rt = skb_rtable(skb);
         newsrc = inet_select_addr(par->out, rt->rt_gateway, RT_SCOPE_UNIVERSE);
         if (!newsrc) {
                 printk("MASQUERADE: %s ate my IP address\n", par->out->name);
                 return NF_DROP;
         }
 
-        write_lock_bh(&masq_lock);
         nat->masq_index = par->out->ifindex;
-        write_unlock_bh(&masq_lock);
 
         /* Transfer from original range. */
         newrange = ((struct nf_nat_range)
@@ -97,16 +92,11 @@ static int
 device_cmp(struct nf_conn *i, void *ifindex)
 {
         const struct nf_conn_nat *nat = nfct_nat(i);
-        int ret;
 
         if (!nat)
                 return 0;
 
-        read_lock_bh(&masq_lock);
-        ret = (nat->masq_index == (int)(long)ifindex);
-        read_unlock_bh(&masq_lock);
-
-        return ret;
+        return nat->masq_index == (int)(long)ifindex;
 }
 
 static int masq_device_event(struct notifier_block *this,
diff --git a/net/ipv4/netfilter/ipt_REJECT.c b/net/ipv4/netfilter/ipt_REJECT.c
index 0b4b6e0ff2b9..c93ae44bff2a 100644
--- a/net/ipv4/netfilter/ipt_REJECT.c
+++ b/net/ipv4/netfilter/ipt_REJECT.c
@@ -108,17 +108,16 @@ static void send_reset(struct sk_buff *oldskb, int hook)
                 addr_type = RTN_LOCAL;
 
         /* ip_route_me_harder expects skb->dst to be set */
-        dst_hold(oldskb->dst);
-        nskb->dst = oldskb->dst;
+        skb_dst_set(nskb, dst_clone(skb_dst(oldskb)));
 
         if (ip_route_me_harder(nskb, addr_type))
                 goto free_nskb;
 
-        niph->ttl       = dst_metric(nskb->dst, RTAX_HOPLIMIT);
+        niph->ttl       = dst_metric(skb_dst(nskb), RTAX_HOPLIMIT);
         nskb->ip_summed = CHECKSUM_NONE;
 
         /* "Never happens" */
-        if (nskb->len > dst_mtu(nskb->dst))
+        if (nskb->len > dst_mtu(skb_dst(nskb)))
                 goto free_nskb;
 
         nf_ct_attach(nskb, oldskb);
diff --git a/net/ipv4/netfilter/nf_conntrack_proto_icmp.c b/net/ipv4/netfilter/nf_conntrack_proto_icmp.c
index 23b2c2ee869a..d71ba7677344 100644
--- a/net/ipv4/netfilter/nf_conntrack_proto_icmp.c
+++ b/net/ipv4/netfilter/nf_conntrack_proto_icmp.c
@@ -82,18 +82,10 @@ static int icmp_packet(struct nf_conn *ct,
                        u_int8_t pf,
                        unsigned int hooknum)
 {
-        /* Try to delete connection immediately after all replies:
-           won't actually vanish as we still have skb, and del_timer
-           means this will only run once even if count hits zero twice
-           (theoretically possible with SMP) */
-        if (CTINFO2DIR(ctinfo) == IP_CT_DIR_REPLY) {
-                if (atomic_dec_and_test(&ct->proto.icmp.count))
-                        nf_ct_kill_acct(ct, ctinfo, skb);
-        } else {
-                atomic_inc(&ct->proto.icmp.count);
-                nf_conntrack_event_cache(IPCT_PROTOINFO_VOLATILE, ct);
-                nf_ct_refresh_acct(ct, ctinfo, skb, nf_ct_icmp_timeout);
-        }
+        /* Do not immediately delete the connection after the first
+           successful reply to avoid excessive conntrackd traffic
+           and also to handle correctly ICMP echo reply duplicates. */
+        nf_ct_refresh_acct(ct, ctinfo, skb, nf_ct_icmp_timeout);
 
         return NF_ACCEPT;
 }
@@ -117,7 +109,6 @@ static bool icmp_new(struct nf_conn *ct, const struct sk_buff *skb,
                 nf_ct_dump_tuple_ip(&ct->tuplehash[0].tuple);
                 return false;
         }
-        atomic_set(&ct->proto.icmp.count, 0);
         return true;
 }
 
diff --git a/net/ipv4/netfilter/nf_nat_helper.c b/net/ipv4/netfilter/nf_nat_helper.c
index cf7a42bf9820..155c008626c8 100644
--- a/net/ipv4/netfilter/nf_nat_helper.c
+++ b/net/ipv4/netfilter/nf_nat_helper.c
@@ -140,7 +140,7 @@ nf_nat_mangle_tcp_packet(struct sk_buff *skb,
                          const char *rep_buffer,
                          unsigned int rep_len)
 {
-        struct rtable *rt = skb->rtable;
+        struct rtable *rt = skb_rtable(skb);
         struct iphdr *iph;
         struct tcphdr *tcph;
         int oldlen, datalen;
@@ -218,7 +218,7 @@ nf_nat_mangle_udp_packet(struct sk_buff *skb,
                          const char *rep_buffer,
                          unsigned int rep_len)
 {
-        struct rtable *rt = skb->rtable;
+        struct rtable *rt = skb_rtable(skb);
         struct iphdr *iph;
         struct udphdr *udph;
         int datalen, oldlen;
diff --git a/net/ipv4/netfilter/nf_nat_proto_sctp.c b/net/ipv4/netfilter/nf_nat_proto_sctp.c
index 65e470bc6123..3fc598eeeb1a 100644
--- a/net/ipv4/netfilter/nf_nat_proto_sctp.c
+++ b/net/ipv4/netfilter/nf_nat_proto_sctp.c
@@ -33,6 +33,7 @@ sctp_manip_pkt(struct sk_buff *skb,
                enum nf_nat_manip_type maniptype)
 {
         const struct iphdr *iph = (struct iphdr *)(skb->data + iphdroff);
+        struct sk_buff *frag;
         sctp_sctphdr_t *hdr;
         unsigned int hdroff = iphdroff + iph->ihl*4;
         __be32 oldip, newip;
@@ -57,8 +58,8 @@ sctp_manip_pkt(struct sk_buff *skb,
         }
 
         crc32 = sctp_start_cksum((u8 *)hdr, skb_headlen(skb) - hdroff);
-        for (skb = skb_shinfo(skb)->frag_list; skb; skb = skb->next)
-                crc32 = sctp_update_cksum((u8 *)skb->data, skb_headlen(skb),
+        skb_walk_frags(skb, frag)
+                crc32 = sctp_update_cksum((u8 *)frag->data, skb_headlen(frag),
                                           crc32);
         crc32 = sctp_end_cksum(crc32);
         hdr->checksum = crc32;
diff --git a/net/ipv4/netfilter/nf_nat_standalone.c b/net/ipv4/netfilter/nf_nat_standalone.c
index b7dd695691a0..5567bd0d0750 100644
--- a/net/ipv4/netfilter/nf_nat_standalone.c
+++ b/net/ipv4/netfilter/nf_nat_standalone.c
@@ -167,10 +167,9 @@ nf_nat_in(unsigned int hooknum,
 
         ret = nf_nat_fn(hooknum, skb, in, out, okfn);
         if (ret != NF_DROP && ret != NF_STOLEN &&
-            daddr != ip_hdr(skb)->daddr) {
-                dst_release(skb->dst);
-                skb->dst = NULL;
-        }
+            daddr != ip_hdr(skb)->daddr)
+                skb_dst_drop(skb);
+
         return ret;
 }
 
diff --git a/net/ipv4/proc.c b/net/ipv4/proc.c
index cf0cdeeb1db0..f25542c48b7d 100644
--- a/net/ipv4/proc.c
+++ b/net/ipv4/proc.c
@@ -90,14 +90,14 @@ static const struct file_operations sockstat_seq_fops = {
 
 /* snmp items */
 static const struct snmp_mib snmp4_ipstats_list[] = {
-        SNMP_MIB_ITEM("InReceives", IPSTATS_MIB_INRECEIVES),
+        SNMP_MIB_ITEM("InReceives", IPSTATS_MIB_INPKTS),
         SNMP_MIB_ITEM("InHdrErrors", IPSTATS_MIB_INHDRERRORS),
         SNMP_MIB_ITEM("InAddrErrors", IPSTATS_MIB_INADDRERRORS),
         SNMP_MIB_ITEM("ForwDatagrams", IPSTATS_MIB_OUTFORWDATAGRAMS),
         SNMP_MIB_ITEM("InUnknownProtos", IPSTATS_MIB_INUNKNOWNPROTOS),
         SNMP_MIB_ITEM("InDiscards", IPSTATS_MIB_INDISCARDS),
         SNMP_MIB_ITEM("InDelivers", IPSTATS_MIB_INDELIVERS),
-        SNMP_MIB_ITEM("OutRequests", IPSTATS_MIB_OUTREQUESTS),
+        SNMP_MIB_ITEM("OutRequests", IPSTATS_MIB_OUTPKTS),
         SNMP_MIB_ITEM("OutDiscards", IPSTATS_MIB_OUTDISCARDS),
         SNMP_MIB_ITEM("OutNoRoutes", IPSTATS_MIB_OUTNOROUTES),
         SNMP_MIB_ITEM("ReasmTimeout", IPSTATS_MIB_REASMTIMEOUT),
@@ -118,6 +118,12 @@ static const struct snmp_mib snmp4_ipextstats_list[] = {
         SNMP_MIB_ITEM("OutMcastPkts", IPSTATS_MIB_OUTMCASTPKTS),
         SNMP_MIB_ITEM("InBcastPkts", IPSTATS_MIB_INBCASTPKTS),
         SNMP_MIB_ITEM("OutBcastPkts", IPSTATS_MIB_OUTBCASTPKTS),
+        SNMP_MIB_ITEM("InOctets", IPSTATS_MIB_INOCTETS),
+        SNMP_MIB_ITEM("OutOctets", IPSTATS_MIB_OUTOCTETS),
+        SNMP_MIB_ITEM("InMcastOctets", IPSTATS_MIB_INMCASTOCTETS),
+        SNMP_MIB_ITEM("OutMcastOctets", IPSTATS_MIB_OUTMCASTOCTETS),
+        SNMP_MIB_ITEM("InBcastOctets", IPSTATS_MIB_INBCASTOCTETS),
+        SNMP_MIB_ITEM("OutBcastOctets", IPSTATS_MIB_OUTBCASTOCTETS),
         SNMP_MIB_SENTINEL
 };
 
diff --git a/net/ipv4/raw.c b/net/ipv4/raw.c
index f774651f0a47..3dc9171a272f 100644
--- a/net/ipv4/raw.c
+++ b/net/ipv4/raw.c
@@ -343,7 +343,7 @@ static int raw_send_hdrinc(struct sock *sk, void *from, size_t length,
 
         skb->priority = sk->sk_priority;
         skb->mark = sk->sk_mark;
-        skb->dst = dst_clone(&rt->u.dst);
+        skb_dst_set(skb, dst_clone(&rt->u.dst));
 
         skb_reset_network_header(skb);
         iph = ip_hdr(skb);
diff --git a/net/ipv4/route.c b/net/ipv4/route.c
index 28205e5bfa9b..cd76b3cb7092 100644
--- a/net/ipv4/route.c
+++ b/net/ipv4/route.c
@@ -131,8 +131,8 @@ static int ip_rt_min_advmss __read_mostly	= 256;
 static int ip_rt_secret_interval __read_mostly  = 10 * 60 * HZ;
 static int rt_chain_length_max __read_mostly    = 20;
 
-static void rt_worker_func(struct work_struct *work);
-static DECLARE_DELAYED_WORK(expires_work, rt_worker_func);
+static struct delayed_work expires_work;
+static unsigned long expires_ljiffies;
 
 /*
  *      Interface to generic destination cache.
@@ -787,9 +787,12 @@ static void rt_check_expire(void)
         struct rtable *rth, *aux, **rthp;
         unsigned long samples = 0;
         unsigned long sum = 0, sum2 = 0;
+        unsigned long delta;
         u64 mult;
 
-        mult = ((u64)ip_rt_gc_interval) << rt_hash_log;
+        delta = jiffies - expires_ljiffies;
+        expires_ljiffies = jiffies;
+        mult = ((u64)delta) << rt_hash_log;
         if (ip_rt_gc_timeout > 1)
                 do_div(mult, ip_rt_gc_timeout);
         goal = (unsigned int)mult;
@@ -1064,7 +1067,8 @@ work_done:
 out:    return 0;
 }
 
-static int rt_intern_hash(unsigned hash, struct rtable *rt, struct rtable **rp)
+static int rt_intern_hash(unsigned hash, struct rtable *rt,
+                          struct rtable **rp, struct sk_buff *skb)
 {
         struct rtable   *rth, **rthp;
         unsigned long   now;
@@ -1114,7 +1118,10 @@ restart:
                         spin_unlock_bh(rt_hash_lock_addr(hash));
 
                         rt_drop(rt);
-                        *rp = rth;
+                        if (rp)
+                                *rp = rth;
+                        else
+                                skb_dst_set(skb, &rth->u.dst);
                         return 0;
                 }
 
@@ -1210,7 +1217,10 @@ restart:
         rcu_assign_pointer(rt_hash_table[hash].chain, rt);
 
         spin_unlock_bh(rt_hash_lock_addr(hash));
-        *rp = rt;
+        if (rp)
+                *rp = rt;
+        else
+                skb_dst_set(skb, &rt->u.dst);
         return 0;
 }
 
@@ -1407,7 +1417,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))
+                                if (!rt_intern_hash(hash, rt, &rt, NULL))
                                         ip_rt_put(rt);
                                 goto do_next;
                         }
@@ -1473,7 +1483,7 @@ static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst)
 
 void ip_rt_send_redirect(struct sk_buff *skb)
 {
-        struct rtable *rt = skb->rtable;
+        struct rtable *rt = skb_rtable(skb);
         struct in_device *in_dev = in_dev_get(rt->u.dst.dev);
 
         if (!in_dev)
@@ -1521,7 +1531,7 @@ out:
 
 static int ip_error(struct sk_buff *skb)
 {
-        struct rtable *rt = skb->rtable;
+        struct rtable *rt = skb_rtable(skb);
         unsigned long now;
         int code;
 
@@ -1698,7 +1708,7 @@ static void ipv4_link_failure(struct sk_buff *skb)
 
         icmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0);
 
-        rt = skb->rtable;
+        rt = skb_rtable(skb);
         if (rt)
                 dst_set_expires(&rt->u.dst, 0);
 }
@@ -1858,7 +1868,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, &skb->rtable);
+        return rt_intern_hash(hash, rth, NULL, skb);
 
 e_nobufs:
         in_dev_put(in_dev);
@@ -2019,7 +2029,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, &skb->rtable);
+        return rt_intern_hash(hash, rth, NULL, skb);
 }
 
 /*
@@ -2175,7 +2185,7 @@ local_input:
         }
         rth->rt_type    = res.type;
         hash = rt_hash(daddr, saddr, fl.iif, rt_genid(net));
-        err = rt_intern_hash(hash, rth, &skb->rtable);
+        err = rt_intern_hash(hash, rth, NULL, skb);
         goto done;
 
 no_route:
@@ -2244,7 +2254,7 @@ int ip_route_input(struct sk_buff *skb, __be32 daddr, __be32 saddr,
                         dst_use(&rth->u.dst, jiffies);
                         RT_CACHE_STAT_INC(in_hit);
                         rcu_read_unlock();
-                        skb->rtable = rth;
+                        skb_dst_set(skb, &rth->u.dst);
                         return 0;
                 }
                 RT_CACHE_STAT_INC(in_hlist_search);
@@ -2420,7 +2430,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);
+                err = rt_intern_hash(hash, rth, rp, NULL);
         }
 
         return err;
@@ -2763,7 +2773,7 @@ static int rt_fill_info(struct net *net,
                         struct sk_buff *skb, u32 pid, u32 seq, int event,
                         int nowait, unsigned int flags)
 {
-        struct rtable *rt = skb->rtable;
+        struct rtable *rt = skb_rtable(skb);
         struct rtmsg *r;
         struct nlmsghdr *nlh;
         long expires;
@@ -2907,7 +2917,7 @@ static int inet_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void
                 err = ip_route_input(skb, dst, src, rtm->rtm_tos, dev);
                 local_bh_enable();
 
-                rt = skb->rtable;
+                rt = skb_rtable(skb);
                 if (err == 0 && rt->u.dst.error)
                         err = -rt->u.dst.error;
         } else {
@@ -2927,7 +2937,7 @@ static int inet_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void
         if (err)
                 goto errout_free;
 
-        skb->rtable = rt;
+        skb_dst_set(skb, &rt->u.dst);
         if (rtm->rtm_flags & RTM_F_NOTIFY)
                 rt->rt_flags |= RTCF_NOTIFY;
 
@@ -2968,15 +2978,15 @@ int ip_rt_dump(struct sk_buff *skb,  struct netlink_callback *cb)
                                 continue;
                         if (rt_is_expired(rt))
                                 continue;
-                        skb->dst = dst_clone(&rt->u.dst);
+                        skb_dst_set(skb, dst_clone(&rt->u.dst));
                         if (rt_fill_info(net, skb, NETLINK_CB(cb->skb).pid,
                                          cb->nlh->nlmsg_seq, RTM_NEWROUTE,
                                          1, NLM_F_MULTI) <= 0) {
-                                dst_release(xchg(&skb->dst, NULL));
+                                skb_dst_drop(skb);
                                 rcu_read_unlock_bh();
                                 goto done;
                         }
-                        dst_release(xchg(&skb->dst, NULL));
+                        skb_dst_drop(skb);
                 }
                 rcu_read_unlock_bh();
         }
@@ -3390,6 +3400,8 @@ int __init ip_rt_init(void)
         /* All the timers, started at system startup tend
            to synchronize. Perturb it a bit.
          */
+        INIT_DELAYED_WORK_DEFERRABLE(&expires_work, rt_worker_func);
+        expires_ljiffies = jiffies;
         schedule_delayed_work(&expires_work,
                 net_random() % ip_rt_gc_interval + ip_rt_gc_interval);
 
diff --git a/net/ipv4/syncookies.c b/net/ipv4/syncookies.c
index b35a950d2e06..cd2b97f1b6e1 100644
--- a/net/ipv4/syncookies.c
+++ b/net/ipv4/syncookies.c
@@ -161,13 +161,12 @@ static __u16 const msstab[] = {
  */
 __u32 cookie_v4_init_sequence(struct sock *sk, struct sk_buff *skb, __u16 *mssp)
 {
-        struct tcp_sock *tp = tcp_sk(sk);
         const struct iphdr *iph = ip_hdr(skb);
         const struct tcphdr *th = tcp_hdr(skb);
         int mssind;
         const __u16 mss = *mssp;
 
-        tp->last_synq_overflow = jiffies;
+        tcp_synq_overflow(sk);
 
         /* XXX sort msstab[] by probability?  Binary search? */
         for (mssind = 0; mss > msstab[mssind + 1]; mssind++)
@@ -268,7 +267,7 @@ struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb,
         if (!sysctl_tcp_syncookies || !th->ack)
                 goto out;
 
-        if (time_after(jiffies, tp->last_synq_overflow + TCP_TIMEOUT_INIT) ||
+        if (tcp_synq_no_recent_overflow(sk) ||
             (mss = cookie_check(skb, cookie)) == 0) {
                 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_SYNCOOKIESFAILED);
                 goto out;
diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
index 7a0f0b27bf1f..17b89c523f9d 100644
--- a/net/ipv4/tcp.c
+++ b/net/ipv4/tcp.c
@@ -439,12 +439,14 @@ int tcp_ioctl(struct sock *sk, int cmd, unsigned long arg)
                          !tp->urg_data ||
                          before(tp->urg_seq, tp->copied_seq) ||
                          !before(tp->urg_seq, tp->rcv_nxt)) {
+                        struct sk_buff *skb;
+
                         answ = tp->rcv_nxt - tp->copied_seq;
 
                         /* Subtract 1, if FIN is in queue. */
-                        if (answ && !skb_queue_empty(&sk->sk_receive_queue))
-                                answ -=
-                       tcp_hdr((struct sk_buff *)sk->sk_receive_queue.prev)->fin;
+                        skb = skb_peek_tail(&sk->sk_receive_queue);
+                        if (answ && skb)
+                                answ -= tcp_hdr(skb)->fin;
                 } else
                         answ = tp->urg_seq - tp->copied_seq;
                 release_sock(sk);
@@ -1382,11 +1384,7 @@ int tcp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
 
                 /* Next get a buffer. */
 
-                skb = skb_peek(&sk->sk_receive_queue);
-                do {
-                        if (!skb)
-                                break;
-
+                skb_queue_walk(&sk->sk_receive_queue, skb) {
                         /* Now that we have two receive queues this
                          * shouldn't happen.
                          */
@@ -1403,8 +1401,7 @@ int tcp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
                         if (tcp_hdr(skb)->fin)
                                 goto found_fin_ok;
                         WARN_ON(!(flags & MSG_PEEK));
-                        skb = skb->next;
-                } while (skb != (struct sk_buff *)&sk->sk_receive_queue);
+                }
 
                 /* Well, if we have backlog, try to process it now yet. */
 
@@ -2518,20 +2515,30 @@ struct sk_buff **tcp_gro_receive(struct sk_buff **head, struct sk_buff *skb)
         unsigned int thlen;
         unsigned int flags;
         unsigned int mss = 1;
+        unsigned int hlen;
+        unsigned int off;
         int flush = 1;
         int i;
 
-        th = skb_gro_header(skb, sizeof(*th));
-        if (unlikely(!th))
-                goto out;
+        off = skb_gro_offset(skb);
+        hlen = off + sizeof(*th);
+        th = skb_gro_header_fast(skb, off);
+        if (skb_gro_header_hard(skb, hlen)) {
+                th = skb_gro_header_slow(skb, hlen, off);
+                if (unlikely(!th))
+                        goto out;
+        }
 
         thlen = th->doff * 4;
         if (thlen < sizeof(*th))
                 goto out;
 
-        th = skb_gro_header(skb, thlen);
-        if (unlikely(!th))
-                goto out;
+        hlen = off + thlen;
+        if (skb_gro_header_hard(skb, hlen)) {
+                th = skb_gro_header_slow(skb, hlen, off);
+                if (unlikely(!th))
+                        goto out;
+        }
 
         skb_gro_pull(skb, thlen);
 
@@ -2544,7 +2551,7 @@ struct sk_buff **tcp_gro_receive(struct sk_buff **head, struct sk_buff *skb)
 
                 th2 = tcp_hdr(p);
 
-                if ((th->source ^ th2->source) | (th->dest ^ th2->dest)) {
+                if (*(u32 *)&th->source ^ *(u32 *)&th2->source) {
                         NAPI_GRO_CB(p)->same_flow = 0;
                         continue;
                 }
@@ -2559,14 +2566,14 @@ found:
         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) | (th->window ^ th2->window);
-        for (i = sizeof(*th); !flush && i < thlen; i += 4)
+        flush |= th->ack_seq ^ th2->ack_seq;
+        for (i = sizeof(*th); i < thlen; i += 4)
                 flush |= *(u32 *)((u8 *)th + i) ^
                          *(u32 *)((u8 *)th2 + i);
 
         mss = skb_shinfo(p)->gso_size;
 
-        flush |= (len > mss) | !len;
+        flush |= (len - 1) >= mss;
         flush |= (ntohl(th2->seq) + skb_gro_len(p)) ^ ntohl(th->seq);
 
         if (flush || skb_gro_receive(head, skb)) {
diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index eec3e6f9956c..2bdb0da237e6 100644
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -77,7 +77,7 @@ int sysctl_tcp_window_scaling __read_mostly = 1;
 int sysctl_tcp_sack __read_mostly = 1;
 int sysctl_tcp_fack __read_mostly = 1;
 int sysctl_tcp_reordering __read_mostly = TCP_FASTRETRANS_THRESH;
-int sysctl_tcp_ecn __read_mostly;
+int sysctl_tcp_ecn __read_mostly = 2;
 int sysctl_tcp_dsack __read_mostly = 1;
 int sysctl_tcp_app_win __read_mostly = 31;
 int sysctl_tcp_adv_win_scale __read_mostly = 2;
@@ -4426,7 +4426,7 @@ drop:
                 }
                 __skb_queue_head(&tp->out_of_order_queue, skb);
         } else {
-                struct sk_buff *skb1 = tp->out_of_order_queue.prev;
+                struct sk_buff *skb1 = skb_peek_tail(&tp->out_of_order_queue);
                 u32 seq = TCP_SKB_CB(skb)->seq;
                 u32 end_seq = TCP_SKB_CB(skb)->end_seq;
 
@@ -4443,15 +4443,18 @@ drop:
                 }
 
                 /* Find place to insert this segment. */
-                do {
+                while (1) {
                         if (!after(TCP_SKB_CB(skb1)->seq, seq))
                                 break;
-                } while ((skb1 = skb1->prev) !=
-                         (struct sk_buff *)&tp->out_of_order_queue);
+                        if (skb_queue_is_first(&tp->out_of_order_queue, skb1)) {
+                                skb1 = NULL;
+                                break;
+                        }
+                        skb1 = skb_queue_prev(&tp->out_of_order_queue, skb1);
+                }
 
                 /* Do skb overlap to previous one? */
-                if (skb1 != (struct sk_buff *)&tp->out_of_order_queue &&
-                    before(seq, TCP_SKB_CB(skb1)->end_seq)) {
+                if (skb1 && before(seq, TCP_SKB_CB(skb1)->end_seq)) {
                         if (!after(end_seq, TCP_SKB_CB(skb1)->end_seq)) {
                                 /* All the bits are present. Drop. */
                                 __kfree_skb(skb);
@@ -4463,15 +4466,26 @@ drop:
                                 tcp_dsack_set(sk, seq,
                                               TCP_SKB_CB(skb1)->end_seq);
                         } else {
-                                skb1 = skb1->prev;
+                                if (skb_queue_is_first(&tp->out_of_order_queue,
+                                                       skb1))
+                                        skb1 = NULL;
+                                else
+                                        skb1 = skb_queue_prev(
+                                                &tp->out_of_order_queue,
+                                                skb1);
                         }
                 }
-                __skb_queue_after(&tp->out_of_order_queue, skb1, skb);
+                if (!skb1)
+                        __skb_queue_head(&tp->out_of_order_queue, skb);
+                else
+                        __skb_queue_after(&tp->out_of_order_queue, skb1, skb);
 
                 /* And clean segments covered by new one as whole. */
-                while ((skb1 = skb->next) !=
-                       (struct sk_buff *)&tp->out_of_order_queue &&
-                       after(end_seq, TCP_SKB_CB(skb1)->seq)) {
+                while (!skb_queue_is_last(&tp->out_of_order_queue, skb)) {
+                        skb1 = skb_queue_next(&tp->out_of_order_queue, skb);
+
+                        if (!after(end_seq, TCP_SKB_CB(skb1)->seq))
+                                break;
                         if (before(end_seq, TCP_SKB_CB(skb1)->end_seq)) {
                                 tcp_dsack_extend(sk, TCP_SKB_CB(skb1)->seq,
                                                  end_seq);
@@ -4492,7 +4506,10 @@ add_sack:
 static struct sk_buff *tcp_collapse_one(struct sock *sk, struct sk_buff *skb,
                                         struct sk_buff_head *list)
 {
-        struct sk_buff *next = skb->next;
+        struct sk_buff *next = NULL;
+
+        if (!skb_queue_is_last(list, skb))
+                next = skb_queue_next(list, skb);
 
         __skb_unlink(skb, list);
         __kfree_skb(skb);
@@ -4503,6 +4520,9 @@ static struct sk_buff *tcp_collapse_one(struct sock *sk, struct sk_buff *skb,
 
 /* Collapse contiguous sequence of skbs head..tail with
  * sequence numbers start..end.
+ *
+ * If tail is NULL, this means until the end of the list.
+ *
  * Segments with FIN/SYN are not collapsed (only because this
  * simplifies code)
  */
@@ -4511,15 +4531,23 @@ tcp_collapse(struct sock *sk, struct sk_buff_head *list,
              struct sk_buff *head, struct sk_buff *tail,
              u32 start, u32 end)
 {
-        struct sk_buff *skb;
+        struct sk_buff *skb, *n;
+        bool end_of_skbs;
 
         /* First, check that queue is collapsible and find
          * the point where collapsing can be useful. */
-        for (skb = head; skb != tail;) {
+        skb = head;
+restart:
+        end_of_skbs = true;
+        skb_queue_walk_from_safe(list, skb, n) {
+                if (skb == tail)
+                        break;
                 /* No new bits? It is possible on ofo queue. */
                 if (!before(start, TCP_SKB_CB(skb)->end_seq)) {
                         skb = tcp_collapse_one(sk, skb, list);
-                        continue;
+                        if (!skb)
+                                break;
+                        goto restart;
                 }
 
                 /* The first skb to collapse is:
@@ -4529,16 +4557,24 @@ tcp_collapse(struct sock *sk, struct sk_buff_head *list,
                  */
                 if (!tcp_hdr(skb)->syn && !tcp_hdr(skb)->fin &&
                     (tcp_win_from_space(skb->truesize) > skb->len ||
-                     before(TCP_SKB_CB(skb)->seq, start) ||
-                     (skb->next != tail &&
-                      TCP_SKB_CB(skb)->end_seq != TCP_SKB_CB(skb->next)->seq)))
+                     before(TCP_SKB_CB(skb)->seq, start))) {
+                        end_of_skbs = false;
                         break;
+                }
+
+                if (!skb_queue_is_last(list, skb)) {
+                        struct sk_buff *next = skb_queue_next(list, skb);
+                        if (next != tail &&
+                            TCP_SKB_CB(skb)->end_seq != TCP_SKB_CB(next)->seq) {
+                                end_of_skbs = false;
+                                break;
+                        }
+                }
 
                 /* Decided to skip this, advance start seq. */
                 start = TCP_SKB_CB(skb)->end_seq;
-                skb = skb->next;
         }
-        if (skb == tail || tcp_hdr(skb)->syn || tcp_hdr(skb)->fin)
+        if (end_of_skbs || tcp_hdr(skb)->syn || tcp_hdr(skb)->fin)
                 return;
 
         while (before(start, end)) {
@@ -4583,7 +4619,8 @@ tcp_collapse(struct sock *sk, struct sk_buff_head *list,
                         }
                         if (!before(start, TCP_SKB_CB(skb)->end_seq)) {
                                 skb = tcp_collapse_one(sk, skb, list);
-                                if (skb == tail ||
+                                if (!skb ||
+                                    skb == tail ||
                                     tcp_hdr(skb)->syn ||
                                     tcp_hdr(skb)->fin)
                                         return;
@@ -4610,17 +4647,21 @@ static void tcp_collapse_ofo_queue(struct sock *sk)
         head = skb;
 
         for (;;) {
-                skb = skb->next;
+                struct sk_buff *next = NULL;
+
+                if (!skb_queue_is_last(&tp->out_of_order_queue, skb))
+                        next = skb_queue_next(&tp->out_of_order_queue, skb);
+                skb = next;
 
                 /* Segment is terminated when we see gap or when
                  * we are at the end of all the queue. */
-                if (skb == (struct sk_buff *)&tp->out_of_order_queue ||
+                if (!skb ||
                     after(TCP_SKB_CB(skb)->seq, end) ||
                     before(TCP_SKB_CB(skb)->end_seq, start)) {
                         tcp_collapse(sk, &tp->out_of_order_queue,
                                      head, skb, start, end);
                         head = skb;
-                        if (skb == (struct sk_buff *)&tp->out_of_order_queue)
+                        if (!skb)
                                 break;
                         /* Start new segment */
                         start = TCP_SKB_CB(skb)->seq;
@@ -4681,10 +4722,11 @@ static int tcp_prune_queue(struct sock *sk)
                 tp->rcv_ssthresh = min(tp->rcv_ssthresh, 4U * tp->advmss);
 
         tcp_collapse_ofo_queue(sk);
-        tcp_collapse(sk, &sk->sk_receive_queue,
-                     sk->sk_receive_queue.next,
-                     (struct sk_buff *)&sk->sk_receive_queue,
-                     tp->copied_seq, tp->rcv_nxt);
+        if (!skb_queue_empty(&sk->sk_receive_queue))
+                tcp_collapse(sk, &sk->sk_receive_queue,
+                             skb_peek(&sk->sk_receive_queue),
+                             NULL,
+                             tp->copied_seq, tp->rcv_nxt);
         sk_mem_reclaim(sk);
 
         if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf)
diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c
index 5d427f86b414..5a1ca2698c88 100644
--- a/net/ipv4/tcp_ipv4.c
+++ b/net/ipv4/tcp_ipv4.c
@@ -546,7 +546,7 @@ static void tcp_v4_send_reset(struct sock *sk, struct sk_buff *skb)
         if (th->rst)
                 return;
 
-        if (skb->rtable->rt_type != RTN_LOCAL)
+        if (skb_rtable(skb)->rt_type != RTN_LOCAL)
                 return;
 
         /* Swap the send and the receive. */
@@ -590,7 +590,7 @@ static void tcp_v4_send_reset(struct sock *sk, struct sk_buff *skb)
         arg.csumoffset = offsetof(struct tcphdr, check) / 2;
         arg.flags = (sk && inet_sk(sk)->transparent) ? IP_REPLY_ARG_NOSRCCHECK : 0;
 
-        net = dev_net(skb->dst->dev);
+        net = dev_net(skb_dst(skb)->dev);
         ip_send_reply(net->ipv4.tcp_sock, skb,
                       &arg, arg.iov[0].iov_len);
 
@@ -617,7 +617,7 @@ static void tcp_v4_send_ack(struct sk_buff *skb, u32 seq, u32 ack,
                         ];
         } rep;
         struct ip_reply_arg arg;
-        struct net *net = dev_net(skb->dst->dev);
+        struct net *net = dev_net(skb_dst(skb)->dev);
 
         memset(&rep.th, 0, sizeof(struct tcphdr));
         memset(&arg, 0, sizeof(arg));
@@ -1185,7 +1185,7 @@ int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
 #endif
 
         /* Never answer to SYNs send to broadcast or multicast */
-        if (skb->rtable->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))
+        if (skb_rtable(skb)->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))
                 goto drop;
 
         /* TW buckets are converted to open requests without
@@ -1593,7 +1593,7 @@ process:
 #endif
                 {
                         if (!tcp_prequeue(sk, skb))
-                        ret = tcp_v4_do_rcv(sk, skb);
+                                ret = tcp_v4_do_rcv(sk, skb);
                 }
         } else
                 sk_add_backlog(sk, skb);
@@ -2343,7 +2343,7 @@ void tcp4_proc_exit(void)
 
 struct sk_buff **tcp4_gro_receive(struct sk_buff **head, struct sk_buff *skb)
 {
-        struct iphdr *iph = ip_hdr(skb);
+        struct iphdr *iph = skb_gro_network_header(skb);
 
         switch (skb->ip_summed) {
         case CHECKSUM_COMPLETE:
diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index 59aec609cec6..416fc4c2e7eb 100644
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -288,7 +288,7 @@ static inline void TCP_ECN_send_syn(struct sock *sk, struct sk_buff *skb)
         struct tcp_sock *tp = tcp_sk(sk);
 
         tp->ecn_flags = 0;
-        if (sysctl_tcp_ecn) {
+        if (sysctl_tcp_ecn == 1) {
                 TCP_SKB_CB(skb)->flags |= TCPCB_FLAG_ECE | TCPCB_FLAG_CWR;
                 tp->ecn_flags = TCP_ECN_OK;
         }
@@ -2202,7 +2202,7 @@ struct sk_buff *tcp_make_synack(struct sock *sk, struct dst_entry *dst,
         /* Reserve space for headers. */
         skb_reserve(skb, MAX_TCP_HEADER);
 
-        skb->dst = dst_clone(dst);
+        skb_dst_set(skb, dst_clone(dst));
 
         mss = dst_metric(dst, RTAX_ADVMSS);
         if (tp->rx_opt.user_mss && tp->rx_opt.user_mss < mss)
diff --git a/net/ipv4/udp.c b/net/ipv4/udp.c
index 7a1d1ce22e66..8f4158d7c9a6 100644
--- a/net/ipv4/udp.c
+++ b/net/ipv4/udp.c
@@ -328,7 +328,7 @@ static inline struct sock *__udp4_lib_lookup_skb(struct sk_buff *skb,
         if (unlikely(sk = skb_steal_sock(skb)))
                 return sk;
         else
-                return __udp4_lib_lookup(dev_net(skb->dst->dev), iph->saddr, sport,
+                return __udp4_lib_lookup(dev_net(skb_dst(skb)->dev), iph->saddr, sport,
                                          iph->daddr, dport, inet_iif(skb),
                                          udptable);
 }
@@ -1237,7 +1237,7 @@ int __udp4_lib_rcv(struct sk_buff *skb, struct udp_table *udptable,
         struct sock *sk;
         struct udphdr *uh;
         unsigned short ulen;
-        struct rtable *rt = (struct rtable*)skb->dst;
+        struct rtable *rt = skb_rtable(skb);
         __be32 saddr, daddr;
         struct net *net = dev_net(skb->dev);
 
diff --git a/net/ipv4/xfrm4_input.c b/net/ipv4/xfrm4_input.c
index 4ec2162a437e..f9f922a0ba88 100644
--- a/net/ipv4/xfrm4_input.c
+++ b/net/ipv4/xfrm4_input.c
@@ -23,7 +23,7 @@ int xfrm4_extract_input(struct xfrm_state *x, struct sk_buff *skb)
 
 static inline int xfrm4_rcv_encap_finish(struct sk_buff *skb)
 {
-        if (skb->dst == NULL) {
+        if (skb_dst(skb) == NULL) {
                 const struct iphdr *iph = ip_hdr(skb);
 
                 if (ip_route_input(skb, iph->daddr, iph->saddr, iph->tos,
diff --git a/net/ipv4/xfrm4_mode_tunnel.c b/net/ipv4/xfrm4_mode_tunnel.c
index 7135279f3f84..3444f3b34eca 100644
--- a/net/ipv4/xfrm4_mode_tunnel.c
+++ b/net/ipv4/xfrm4_mode_tunnel.c
@@ -28,7 +28,7 @@ static inline void ipip_ecn_decapsulate(struct sk_buff *skb)
  */
 static int xfrm4_mode_tunnel_output(struct xfrm_state *x, struct sk_buff *skb)
 {
-        struct dst_entry *dst = skb->dst;
+        struct dst_entry *dst = skb_dst(skb);
         struct iphdr *top_iph;
         int flags;
 
@@ -41,7 +41,7 @@ static int xfrm4_mode_tunnel_output(struct xfrm_state *x, struct sk_buff *skb)
         top_iph->ihl = 5;
         top_iph->version = 4;
 
-        top_iph->protocol = xfrm_af2proto(skb->dst->ops->family);
+        top_iph->protocol = xfrm_af2proto(skb_dst(skb)->ops->family);
 
         /* DS disclosed */
         top_iph->tos = INET_ECN_encapsulate(XFRM_MODE_SKB_CB(skb)->tos,
diff --git a/net/ipv4/xfrm4_output.c b/net/ipv4/xfrm4_output.c
index 8c3180adddbf..c908bd99bcba 100644
--- a/net/ipv4/xfrm4_output.c
+++ b/net/ipv4/xfrm4_output.c
@@ -29,7 +29,7 @@ static int xfrm4_tunnel_check_size(struct sk_buff *skb)
         if (!(ip_hdr(skb)->frag_off & htons(IP_DF)) || skb->local_df)
                 goto out;
 
-        dst = skb->dst;
+        dst = skb_dst(skb);
         mtu = dst_mtu(dst);
         if (skb->len > mtu) {
                 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, htonl(mtu));
@@ -72,7 +72,7 @@ EXPORT_SYMBOL(xfrm4_prepare_output);
 static int xfrm4_output_finish(struct sk_buff *skb)
 {
 #ifdef CONFIG_NETFILTER
-        if (!skb->dst->xfrm) {
+        if (!skb_dst(skb)->xfrm) {
                 IPCB(skb)->flags |= IPSKB_REROUTED;
                 return dst_output(skb);
         }
@@ -87,6 +87,6 @@ static int xfrm4_output_finish(struct sk_buff *skb)
 int xfrm4_output(struct sk_buff *skb)
 {
         return NF_HOOK_COND(PF_INET, NF_INET_POST_ROUTING, skb,
-                            NULL, skb->dst->dev, xfrm4_output_finish,
+                            NULL, skb_dst(skb)->dev, xfrm4_output_finish,
                             !(IPCB(skb)->flags & IPSKB_REROUTED));
 }
diff --git a/net/ipv6/Kconfig b/net/ipv6/Kconfig
index ca8cb326d1d2..ead6c7a42f44 100644
--- a/net/ipv6/Kconfig
+++ b/net/ipv6/Kconfig
@@ -168,7 +168,7 @@ config IPV6_SIT
           into IPv4 packets. This is useful if you want to connect two IPv6
           networks over an IPv4-only path.
 
-          Saying M here will produce a module called sit.ko. If unsure, say Y.
+          Saying M here will produce a module called sit. If unsure, say Y.
 
 config IPV6_NDISC_NODETYPE
         bool
diff --git a/net/ipv6/addrconf.c b/net/ipv6/addrconf.c
index a8218bc1806a..8c1e86afbbf5 100644
--- a/net/ipv6/addrconf.c
+++ b/net/ipv6/addrconf.c
@@ -503,7 +503,7 @@ static int addrconf_fixup_forwarding(struct ctl_table *table, int *p, int old)
                 return 0;
 
         if (!rtnl_trylock())
-                return -ERESTARTSYS;
+                return restart_syscall();
 
         if (p == &net->ipv6.devconf_all->forwarding) {
                 __s32 newf = net->ipv6.devconf_all->forwarding;
@@ -591,7 +591,6 @@ ipv6_add_addr(struct inet6_dev *idev, const struct in6_addr *addr, int pfxlen,
 {
         struct inet6_ifaddr *ifa = NULL;
         struct rt6_info *rt;
-        struct net *net = dev_net(idev->dev);
         int hash;
         int err = 0;
         int addr_type = ipv6_addr_type(addr);
@@ -608,7 +607,7 @@ ipv6_add_addr(struct inet6_dev *idev, const struct in6_addr *addr, int pfxlen,
                 goto out2;
         }
 
-        if (idev->cnf.disable_ipv6 || net->ipv6.devconf_all->disable_ipv6) {
+        if (idev->cnf.disable_ipv6) {
                 err = -EACCES;
                 goto out2;
         }
@@ -1520,6 +1519,8 @@ static int addrconf_ifid_infiniband(u8 *eui, struct net_device *dev)
 
 int __ipv6_isatap_ifid(u8 *eui, __be32 addr)
 {
+        if (addr == 0)
+                return -1;
         eui[0] = (ipv4_is_zeronet(addr) || ipv4_is_private_10(addr) ||
                   ipv4_is_loopback(addr) || ipv4_is_linklocal_169(addr) ||
                   ipv4_is_private_172(addr) || ipv4_is_test_192(addr) ||
@@ -1750,6 +1751,7 @@ void addrconf_prefix_rcv(struct net_device *dev, u8 *opt, int len)
         __u32 prefered_lft;
         int addr_type;
         struct inet6_dev *in6_dev;
+        struct net *net = dev_net(dev);
 
         pinfo = (struct prefix_info *) opt;
 
@@ -1807,7 +1809,7 @@ void addrconf_prefix_rcv(struct net_device *dev, u8 *opt, int len)
                 if (addrconf_finite_timeout(rt_expires))
                         rt_expires *= HZ;
 
-                rt = rt6_lookup(dev_net(dev), &pinfo->prefix, NULL,
+                rt = rt6_lookup(net, &pinfo->prefix, NULL,
                                 dev->ifindex, 1);
 
                 if (rt && addrconf_is_prefix_route(rt)) {
@@ -1844,7 +1846,6 @@ void addrconf_prefix_rcv(struct net_device *dev, u8 *opt, int len)
                 struct inet6_ifaddr * ifp;
                 struct in6_addr addr;
                 int create = 0, update_lft = 0;
-                struct net *net = dev_net(dev);
 
                 if (pinfo->prefix_len == 64) {
                         memcpy(&addr, &pinfo->prefix, 8);
@@ -2765,7 +2766,7 @@ static void addrconf_dad_start(struct inet6_ifaddr *ifp, u32 flags)
                 spin_unlock_bh(&ifp->lock);
                 read_unlock_bh(&idev->lock);
                 /*
-                 * If the defice is not ready:
+                 * If the device is not ready:
                  * - keep it tentative if it is a permanent address.
                  * - otherwise, kill it.
                  */
@@ -3986,6 +3987,75 @@ static int addrconf_sysctl_forward_strategy(ctl_table *table,
         return addrconf_fixup_forwarding(table, valp, val);
 }
 
+static void dev_disable_change(struct inet6_dev *idev)
+{
+        if (!idev || !idev->dev)
+                return;
+
+        if (idev->cnf.disable_ipv6)
+                addrconf_notify(NULL, NETDEV_DOWN, idev->dev);
+        else
+                addrconf_notify(NULL, NETDEV_UP, idev->dev);
+}
+
+static void addrconf_disable_change(struct net *net, __s32 newf)
+{
+        struct net_device *dev;
+        struct inet6_dev *idev;
+
+        read_lock(&dev_base_lock);
+        for_each_netdev(net, dev) {
+                rcu_read_lock();
+                idev = __in6_dev_get(dev);
+                if (idev) {
+                        int changed = (!idev->cnf.disable_ipv6) ^ (!newf);
+                        idev->cnf.disable_ipv6 = newf;
+                        if (changed)
+                                dev_disable_change(idev);
+                }
+                rcu_read_unlock();
+        }
+        read_unlock(&dev_base_lock);
+}
+
+static int addrconf_disable_ipv6(struct ctl_table *table, int *p, int old)
+{
+        struct net *net;
+
+        net = (struct net *)table->extra2;
+
+        if (p == &net->ipv6.devconf_dflt->disable_ipv6)
+                return 0;
+
+        if (!rtnl_trylock())
+                return restart_syscall();
+
+        if (p == &net->ipv6.devconf_all->disable_ipv6) {
+                __s32 newf = net->ipv6.devconf_all->disable_ipv6;
+                net->ipv6.devconf_dflt->disable_ipv6 = newf;
+                addrconf_disable_change(net, newf);
+        } else if ((!*p) ^ (!old))
+                dev_disable_change((struct inet6_dev *)table->extra1);
+
+        rtnl_unlock();
+        return 0;
+}
+
+static
+int addrconf_sysctl_disable(ctl_table *ctl, int write, struct file * filp,
+                            void __user *buffer, size_t *lenp, loff_t *ppos)
+{
+        int *valp = ctl->data;
+        int val = *valp;
+        int ret;
+
+        ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
+
+        if (write)
+                ret = addrconf_disable_ipv6(ctl, valp, val);
+        return ret;
+}
+
 static struct addrconf_sysctl_table
 {
         struct ctl_table_header *sysctl_header;
@@ -4223,7 +4293,8 @@ static struct addrconf_sysctl_table
                         .data           =       &ipv6_devconf.disable_ipv6,
                         .maxlen         =       sizeof(int),
                         .mode           =       0644,
-                        .proc_handler   =       proc_dointvec,
+                        .proc_handler   =       addrconf_sysctl_disable,
+                        .strategy       =       sysctl_intvec,
                 },
                 {
                         .ctl_name       =       CTL_UNNUMBERED,
@@ -4344,6 +4415,10 @@ static int addrconf_init_net(struct net *net)
                 dflt = kmemdup(dflt, sizeof(ipv6_devconf_dflt), GFP_KERNEL);
                 if (dflt == NULL)
                         goto err_alloc_dflt;
+        } else {
+                /* these will be inherited by all namespaces */
+                dflt->autoconf = ipv6_defaults.autoconf;
+                dflt->disable_ipv6 = ipv6_defaults.disable_ipv6;
         }
 
         net->ipv6.devconf_all = all;
diff --git a/net/ipv6/af_inet6.c b/net/ipv6/af_inet6.c
index 61f55386a236..85b3d0036afd 100644
--- a/net/ipv6/af_inet6.c
+++ b/net/ipv6/af_inet6.c
@@ -72,9 +72,21 @@ MODULE_LICENSE("GPL");
 static struct list_head inetsw6[SOCK_MAX];
 static DEFINE_SPINLOCK(inetsw6_lock);
 
-static int disable_ipv6 = 0;
-module_param_named(disable, disable_ipv6, int, 0);
-MODULE_PARM_DESC(disable, "Disable IPv6 such that it is non-functional");
+struct ipv6_params ipv6_defaults = {
+        .disable_ipv6 = 0,
+        .autoconf = 1,
+};
+
+static int disable_ipv6_mod = 0;
+
+module_param_named(disable, disable_ipv6_mod, int, 0444);
+MODULE_PARM_DESC(disable, "Disable IPv6 module such that it is non-functional");
+
+module_param_named(disable_ipv6, ipv6_defaults.disable_ipv6, int, 0444);
+MODULE_PARM_DESC(disable_ipv6, "Disable IPv6 on all interfaces");
+
+module_param_named(autoconf, ipv6_defaults.autoconf, int, 0444);
+MODULE_PARM_DESC(autoconf, "Enable IPv6 address autoconfiguration on all interfaces");
 
 static __inline__ struct ipv6_pinfo *inet6_sk_generic(struct sock *sk)
 {
@@ -817,13 +829,20 @@ static struct sk_buff **ipv6_gro_receive(struct sk_buff **head,
         struct sk_buff *p;
         struct ipv6hdr *iph;
         unsigned int nlen;
+        unsigned int hlen;
+        unsigned int off;
         int flush = 1;
         int proto;
         __wsum csum;
 
-        iph = skb_gro_header(skb, sizeof(*iph));
-        if (unlikely(!iph))
-                goto out;
+        off = skb_gro_offset(skb);
+        hlen = off + sizeof(*iph);
+        iph = skb_gro_header_fast(skb, off);
+        if (skb_gro_header_hard(skb, hlen)) {
+                iph = skb_gro_header_slow(skb, hlen, off);
+                if (unlikely(!iph))
+                        goto out;
+        }
 
         skb_gro_pull(skb, sizeof(*iph));
         skb_set_transport_header(skb, skb_gro_offset(skb));
@@ -1031,7 +1050,7 @@ static int __init inet6_init(void)
         for(r = &inetsw6[0]; r < &inetsw6[SOCK_MAX]; ++r)
                 INIT_LIST_HEAD(r);
 
-        if (disable_ipv6) {
+        if (disable_ipv6_mod) {
                 printk(KERN_INFO
                        "IPv6: Loaded, but administratively disabled, "
                        "reboot required to enable\n");
@@ -1220,7 +1239,7 @@ module_init(inet6_init);
 
 static void __exit inet6_exit(void)
 {
-        if (disable_ipv6)
+        if (disable_ipv6_mod)
                 return;
 
         /* First of all disallow new sockets creation. */
diff --git a/net/ipv6/exthdrs.c b/net/ipv6/exthdrs.c
index 1c7f400a3cfe..4aae658e5501 100644
--- a/net/ipv6/exthdrs.c
+++ b/net/ipv6/exthdrs.c
@@ -277,7 +277,7 @@ static int ipv6_destopt_rcv(struct sk_buff *skb)
         if (!pskb_may_pull(skb, skb_transport_offset(skb) + 8) ||
             !pskb_may_pull(skb, (skb_transport_offset(skb) +
                                  ((skb_transport_header(skb)[1] + 1) << 3)))) {
-                IP6_INC_STATS_BH(dev_net(skb->dst->dev), ip6_dst_idev(skb->dst),
+                IP6_INC_STATS_BH(dev_net(skb_dst(skb)->dev), ip6_dst_idev(skb_dst(skb)),
                                  IPSTATS_MIB_INHDRERRORS);
                 kfree_skb(skb);
                 return -1;
@@ -288,7 +288,7 @@ static int ipv6_destopt_rcv(struct sk_buff *skb)
         dstbuf = opt->dst1;
 #endif
 
-        dst = dst_clone(skb->dst);
+        dst = dst_clone(skb_dst(skb));
         if (ip6_parse_tlv(tlvprocdestopt_lst, skb)) {
                 dst_release(dst);
                 skb->transport_header += (skb_transport_header(skb)[1] + 1) << 3;
@@ -333,7 +333,7 @@ static int ipv6_rthdr_rcv(struct sk_buff *skb)
         if (!pskb_may_pull(skb, skb_transport_offset(skb) + 8) ||
             !pskb_may_pull(skb, (skb_transport_offset(skb) +
                                  ((skb_transport_header(skb)[1] + 1) << 3)))) {
-                IP6_INC_STATS_BH(net, ip6_dst_idev(skb->dst),
+                IP6_INC_STATS_BH(net, ip6_dst_idev(skb_dst(skb)),
                                  IPSTATS_MIB_INHDRERRORS);
                 kfree_skb(skb);
                 return -1;
@@ -343,7 +343,7 @@ static int ipv6_rthdr_rcv(struct sk_buff *skb)
 
         if (ipv6_addr_is_multicast(&ipv6_hdr(skb)->daddr) ||
             skb->pkt_type != PACKET_HOST) {
-                IP6_INC_STATS_BH(net, ip6_dst_idev(skb->dst),
+                IP6_INC_STATS_BH(net, ip6_dst_idev(skb_dst(skb)),
                                  IPSTATS_MIB_INADDRERRORS);
                 kfree_skb(skb);
                 return -1;
@@ -358,7 +358,7 @@ looped_back:
                          * processed by own
                          */
                         if (!addr) {
-                                IP6_INC_STATS_BH(net, ip6_dst_idev(skb->dst),
+                                IP6_INC_STATS_BH(net, ip6_dst_idev(skb_dst(skb)),
                                                  IPSTATS_MIB_INADDRERRORS);
                                 kfree_skb(skb);
                                 return -1;
@@ -384,7 +384,7 @@ looped_back:
                         goto unknown_rh;
                 /* Silently discard invalid RTH type 2 */
                 if (hdr->hdrlen != 2 || hdr->segments_left != 1) {
-                        IP6_INC_STATS_BH(net, ip6_dst_idev(skb->dst),
+                        IP6_INC_STATS_BH(net, ip6_dst_idev(skb_dst(skb)),
                                          IPSTATS_MIB_INHDRERRORS);
                         kfree_skb(skb);
                         return -1;
@@ -403,7 +403,7 @@ looped_back:
         n = hdr->hdrlen >> 1;
 
         if (hdr->segments_left > n) {
-                IP6_INC_STATS_BH(net, ip6_dst_idev(skb->dst),
+                IP6_INC_STATS_BH(net, ip6_dst_idev(skb_dst(skb)),
                                  IPSTATS_MIB_INHDRERRORS);
                 icmpv6_param_prob(skb, ICMPV6_HDR_FIELD,
                                   ((&hdr->segments_left) -
@@ -417,7 +417,7 @@ looped_back:
         if (skb_cloned(skb)) {
                 /* the copy is a forwarded packet */
                 if (pskb_expand_head(skb, 0, 0, GFP_ATOMIC)) {
-                        IP6_INC_STATS_BH(net, ip6_dst_idev(skb->dst),
+                        IP6_INC_STATS_BH(net, ip6_dst_idev(skb_dst(skb)),
                                          IPSTATS_MIB_OUTDISCARDS);
                         kfree_skb(skb);
                         return -1;
@@ -440,13 +440,13 @@ looped_back:
                 if (xfrm6_input_addr(skb, (xfrm_address_t *)addr,
                                      (xfrm_address_t *)&ipv6_hdr(skb)->saddr,
                                      IPPROTO_ROUTING) < 0) {
-                        IP6_INC_STATS_BH(net, ip6_dst_idev(skb->dst),
+                        IP6_INC_STATS_BH(net, ip6_dst_idev(skb_dst(skb)),
                                          IPSTATS_MIB_INADDRERRORS);
                         kfree_skb(skb);
                         return -1;
                 }
-                if (!ipv6_chk_home_addr(dev_net(skb->dst->dev), addr)) {
-                        IP6_INC_STATS_BH(net, ip6_dst_idev(skb->dst),
+                if (!ipv6_chk_home_addr(dev_net(skb_dst(skb)->dev), addr)) {
+                        IP6_INC_STATS_BH(net, ip6_dst_idev(skb_dst(skb)),
                                          IPSTATS_MIB_INADDRERRORS);
                         kfree_skb(skb);
                         return -1;
@@ -458,7 +458,7 @@ looped_back:
         }
 
         if (ipv6_addr_is_multicast(addr)) {
-                IP6_INC_STATS_BH(net, ip6_dst_idev(skb->dst),
+                IP6_INC_STATS_BH(net, ip6_dst_idev(skb_dst(skb)),
                                  IPSTATS_MIB_INADDRERRORS);
                 kfree_skb(skb);
                 return -1;
@@ -468,17 +468,17 @@ looped_back:
         ipv6_addr_copy(addr, &ipv6_hdr(skb)->daddr);
         ipv6_addr_copy(&ipv6_hdr(skb)->daddr, &daddr);
 
-        dst_release(xchg(&skb->dst, NULL));
+        skb_dst_drop(skb);
         ip6_route_input(skb);
-        if (skb->dst->error) {
+        if (skb_dst(skb)->error) {
                 skb_push(skb, skb->data - skb_network_header(skb));
                 dst_input(skb);
                 return -1;
         }
 
-        if (skb->dst->dev->flags&IFF_LOOPBACK) {
+        if (skb_dst(skb)->dev->flags&IFF_LOOPBACK) {
                 if (ipv6_hdr(skb)->hop_limit <= 1) {
-                        IP6_INC_STATS_BH(net, ip6_dst_idev(skb->dst),
+                        IP6_INC_STATS_BH(net, ip6_dst_idev(skb_dst(skb)),
                                          IPSTATS_MIB_INHDRERRORS);
                         icmpv6_send(skb, ICMPV6_TIME_EXCEED, ICMPV6_EXC_HOPLIMIT,
                                     0, skb->dev);
@@ -494,7 +494,7 @@ looped_back:
         return -1;
 
 unknown_rh:
-        IP6_INC_STATS_BH(net, ip6_dst_idev(skb->dst), IPSTATS_MIB_INHDRERRORS);
+        IP6_INC_STATS_BH(net, ip6_dst_idev(skb_dst(skb)), IPSTATS_MIB_INHDRERRORS);
         icmpv6_param_prob(skb, ICMPV6_HDR_FIELD,
                           (&hdr->type) - skb_network_header(skb));
         return -1;
@@ -552,11 +552,11 @@ void ipv6_exthdrs_exit(void)
  **********************************/
 
 /*
- * Note: we cannot rely on skb->dst before we assign it in ip6_route_input().
+ * Note: we cannot rely on skb_dst(skb) before we assign it in ip6_route_input().
  */
 static inline struct inet6_dev *ipv6_skb_idev(struct sk_buff *skb)
 {
-        return skb->dst ? ip6_dst_idev(skb->dst) : __in6_dev_get(skb->dev);
+        return skb_dst(skb) ? ip6_dst_idev(skb_dst(skb)) : __in6_dev_get(skb->dev);
 }
 
 /* Router Alert as of RFC 2711 */
@@ -581,7 +581,7 @@ static int ipv6_hop_jumbo(struct sk_buff *skb, int optoff)
 {
         const unsigned char *nh = skb_network_header(skb);
         u32 pkt_len;
-        struct net *net = dev_net(skb->dst->dev);
+        struct net *net = dev_net(skb_dst(skb)->dev);
 
         if (nh[optoff + 1] != 4 || (optoff & 3) != 2) {
                 LIMIT_NETDEBUG(KERN_DEBUG "ipv6_hop_jumbo: wrong jumbo opt length/alignment %d\n",
diff --git a/net/ipv6/fib6_rules.c b/net/ipv6/fib6_rules.c
index f5de3f9dc692..00a7a5e4ac97 100644
--- a/net/ipv6/fib6_rules.c
+++ b/net/ipv6/fib6_rules.c
@@ -151,7 +151,7 @@ static const struct nla_policy fib6_rule_policy[FRA_MAX+1] = {
 };
 
 static int fib6_rule_configure(struct fib_rule *rule, struct sk_buff *skb,
-                               struct nlmsghdr *nlh, struct fib_rule_hdr *frh,
+                               struct fib_rule_hdr *frh,
                                struct nlattr **tb)
 {
         int err = -EINVAL;
@@ -211,7 +211,7 @@ static int fib6_rule_compare(struct fib_rule *rule, struct fib_rule_hdr *frh,
 }
 
 static int fib6_rule_fill(struct fib_rule *rule, struct sk_buff *skb,
-                          struct nlmsghdr *nlh, struct fib_rule_hdr *frh)
+                          struct fib_rule_hdr *frh)
 {
         struct fib6_rule *rule6 = (struct fib6_rule *) rule;
 
diff --git a/net/ipv6/inet6_connection_sock.c b/net/ipv6/inet6_connection_sock.c
index 3c3732d50c1a..cc4797dd8325 100644
--- a/net/ipv6/inet6_connection_sock.c
+++ b/net/ipv6/inet6_connection_sock.c
@@ -228,7 +228,7 @@ int inet6_csk_xmit(struct sk_buff *skb, int ipfragok)
                 __inet6_csk_dst_store(sk, dst, NULL, NULL);
         }
 
-        skb->dst = dst_clone(dst);
+        skb_dst_set(skb, dst_clone(dst));
 
         /* Restore final destination back after routing done */
         ipv6_addr_copy(&fl.fl6_dst, &np->daddr);
diff --git a/net/ipv6/ip6_input.c b/net/ipv6/ip6_input.c
index 8f04bd9da274..c3a07d75b5f5 100644
--- a/net/ipv6/ip6_input.c
+++ b/net/ipv6/ip6_input.c
@@ -48,7 +48,7 @@
 
 inline int ip6_rcv_finish( struct sk_buff *skb)
 {
-        if (skb->dst == NULL)
+        if (skb_dst(skb) == NULL)
                 ip6_route_input(skb);
 
         return dst_input(skb);
@@ -70,7 +70,7 @@ int ipv6_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt
 
         idev = __in6_dev_get(skb->dev);
 
-        IP6_INC_STATS_BH(net, idev, IPSTATS_MIB_INRECEIVES);
+        IP6_UPD_PO_STATS_BH(net, idev, IPSTATS_MIB_IN, skb->len);
 
         if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL ||
             !idev || unlikely(idev->cnf.disable_ipv6)) {
@@ -91,7 +91,7 @@ int ipv6_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt
          * arrived via the sending interface (ethX), because of the
          * nature of scoping architecture. --yoshfuji
          */
-        IP6CB(skb)->iif = skb->dst ? ip6_dst_idev(skb->dst)->dev->ifindex : dev->ifindex;
+        IP6CB(skb)->iif = skb_dst(skb) ? ip6_dst_idev(skb_dst(skb))->dev->ifindex : dev->ifindex;
 
         if (unlikely(!pskb_may_pull(skb, sizeof(*hdr))))
                 goto err;
@@ -161,7 +161,7 @@ static int ip6_input_finish(struct sk_buff *skb)
         int nexthdr, raw;
         u8 hash;
         struct inet6_dev *idev;
-        struct net *net = dev_net(skb->dst->dev);
+        struct net *net = dev_net(skb_dst(skb)->dev);
 
         /*
          *      Parse extension headers
@@ -169,7 +169,7 @@ static int ip6_input_finish(struct sk_buff *skb)
 
         rcu_read_lock();
 resubmit:
-        idev = ip6_dst_idev(skb->dst);
+        idev = ip6_dst_idev(skb_dst(skb));
         if (!pskb_pull(skb, skb_transport_offset(skb)))
                 goto discard;
         nhoff = IP6CB(skb)->nhoff;
@@ -242,8 +242,9 @@ int ip6_mc_input(struct sk_buff *skb)
         struct ipv6hdr *hdr;
         int deliver;
 
-        IP6_INC_STATS_BH(dev_net(skb->dst->dev),
-                         ip6_dst_idev(skb->dst), IPSTATS_MIB_INMCASTPKTS);
+        IP6_UPD_PO_STATS_BH(dev_net(skb_dst(skb)->dev),
+                         ip6_dst_idev(skb_dst(skb)), IPSTATS_MIB_INMCAST,
+                         skb->len);
 
         hdr = ipv6_hdr(skb);
         deliver = ipv6_chk_mcast_addr(skb->dev, &hdr->daddr, NULL);
diff --git a/net/ipv6/ip6_output.c b/net/ipv6/ip6_output.c
index 9fb49c3b518a..7c76e3d18215 100644
--- a/net/ipv6/ip6_output.c
+++ b/net/ipv6/ip6_output.c
@@ -78,7 +78,7 @@ int __ip6_local_out(struct sk_buff *skb)
                 len = 0;
         ipv6_hdr(skb)->payload_len = htons(len);
 
-        return nf_hook(PF_INET6, NF_INET_LOCAL_OUT, skb, NULL, skb->dst->dev,
+        return nf_hook(PF_INET6, NF_INET_LOCAL_OUT, skb, NULL, skb_dst(skb)->dev,
                        dst_output);
 }
 
@@ -96,7 +96,7 @@ EXPORT_SYMBOL_GPL(ip6_local_out);
 
 static int ip6_output_finish(struct sk_buff *skb)
 {
-        struct dst_entry *dst = skb->dst;
+        struct dst_entry *dst = skb_dst(skb);
 
         if (dst->hh)
                 return neigh_hh_output(dst->hh, skb);
@@ -117,7 +117,7 @@ static int ip6_dev_loopback_xmit(struct sk_buff *newskb)
         __skb_pull(newskb, skb_network_offset(newskb));
         newskb->pkt_type = PACKET_LOOPBACK;
         newskb->ip_summed = CHECKSUM_UNNECESSARY;
-        WARN_ON(!newskb->dst);
+        WARN_ON(!skb_dst(newskb));
 
         netif_rx(newskb);
         return 0;
@@ -126,7 +126,7 @@ static int ip6_dev_loopback_xmit(struct sk_buff *newskb)
 
 static int ip6_output2(struct sk_buff *skb)
 {
-        struct dst_entry *dst = skb->dst;
+        struct dst_entry *dst = skb_dst(skb);
         struct net_device *dev = dst->dev;
 
         skb->protocol = htons(ETH_P_IPV6);
@@ -134,7 +134,7 @@ static int ip6_output2(struct sk_buff *skb)
 
         if (ipv6_addr_is_multicast(&ipv6_hdr(skb)->daddr)) {
                 struct ipv6_pinfo* np = skb->sk ? inet6_sk(skb->sk) : NULL;
-                struct inet6_dev *idev = ip6_dst_idev(skb->dst);
+                struct inet6_dev *idev = ip6_dst_idev(skb_dst(skb));
 
                 if (!(dev->flags & IFF_LOOPBACK) && (!np || np->mc_loop) &&
                     ((mroute6_socket(dev_net(dev)) &&
@@ -159,7 +159,8 @@ static int ip6_output2(struct sk_buff *skb)
                         }
                 }
 
-                IP6_INC_STATS(dev_net(dev), idev, IPSTATS_MIB_OUTMCASTPKTS);
+                IP6_UPD_PO_STATS(dev_net(dev), idev, IPSTATS_MIB_OUTMCAST,
+                                skb->len);
         }
 
         return NF_HOOK(PF_INET6, NF_INET_POST_ROUTING, skb, NULL, skb->dev,
@@ -171,21 +172,21 @@ static inline int ip6_skb_dst_mtu(struct sk_buff *skb)
         struct ipv6_pinfo *np = skb->sk ? inet6_sk(skb->sk) : NULL;
 
         return (np && np->pmtudisc == IPV6_PMTUDISC_PROBE) ?
-               skb->dst->dev->mtu : dst_mtu(skb->dst);
+               skb_dst(skb)->dev->mtu : dst_mtu(skb_dst(skb));
 }
 
 int ip6_output(struct sk_buff *skb)
 {
-        struct inet6_dev *idev = ip6_dst_idev(skb->dst);
+        struct inet6_dev *idev = ip6_dst_idev(skb_dst(skb));
         if (unlikely(idev->cnf.disable_ipv6)) {
-                IP6_INC_STATS(dev_net(skb->dst->dev), idev,
+                IP6_INC_STATS(dev_net(skb_dst(skb)->dev), idev,
                               IPSTATS_MIB_OUTDISCARDS);
                 kfree_skb(skb);
                 return 0;
         }
 
         if ((skb->len > ip6_skb_dst_mtu(skb) && !skb_is_gso(skb)) ||
-                                dst_allfrag(skb->dst))
+                                dst_allfrag(skb_dst(skb)))
                 return ip6_fragment(skb, ip6_output2);
         else
                 return ip6_output2(skb);
@@ -201,7 +202,7 @@ int ip6_xmit(struct sock *sk, struct sk_buff *skb, struct flowi *fl,
         struct net *net = sock_net(sk);
         struct ipv6_pinfo *np = inet6_sk(sk);
         struct in6_addr *first_hop = &fl->fl6_dst;
-        struct dst_entry *dst = skb->dst;
+        struct dst_entry *dst = skb_dst(skb);
         struct ipv6hdr *hdr;
         u8  proto = fl->proto;
         int seg_len = skb->len;
@@ -221,7 +222,7 @@ int ip6_xmit(struct sock *sk, struct sk_buff *skb, struct flowi *fl,
                 if (skb_headroom(skb) < head_room) {
                         struct sk_buff *skb2 = skb_realloc_headroom(skb, head_room);
                         if (skb2 == NULL) {
-                                IP6_INC_STATS(net, ip6_dst_idev(skb->dst),
+                                IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
                                               IPSTATS_MIB_OUTDISCARDS);
                                 kfree_skb(skb);
                                 return -ENOBUFS;
@@ -275,8 +276,8 @@ int ip6_xmit(struct sock *sk, struct sk_buff *skb, struct flowi *fl,
 
         mtu = dst_mtu(dst);
         if ((skb->len <= mtu) || skb->local_df || skb_is_gso(skb)) {
-                IP6_INC_STATS(net, ip6_dst_idev(skb->dst),
-                              IPSTATS_MIB_OUTREQUESTS);
+                IP6_UPD_PO_STATS(net, ip6_dst_idev(skb_dst(skb)),
+                              IPSTATS_MIB_OUT, skb->len);
                 return NF_HOOK(PF_INET6, NF_INET_LOCAL_OUT, skb, NULL, dst->dev,
                                 dst_output);
         }
@@ -285,7 +286,7 @@ int ip6_xmit(struct sock *sk, struct sk_buff *skb, struct flowi *fl,
                 printk(KERN_DEBUG "IPv6: sending pkt_too_big to self\n");
         skb->dev = dst->dev;
         icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu, skb->dev);
-        IP6_INC_STATS(net, ip6_dst_idev(skb->dst), IPSTATS_MIB_FRAGFAILS);
+        IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)), IPSTATS_MIB_FRAGFAILS);
         kfree_skb(skb);
         return -EMSGSIZE;
 }
@@ -415,7 +416,7 @@ static inline int ip6_forward_finish(struct sk_buff *skb)
 
 int ip6_forward(struct sk_buff *skb)
 {
-        struct dst_entry *dst = skb->dst;
+        struct dst_entry *dst = skb_dst(skb);
         struct ipv6hdr *hdr = ipv6_hdr(skb);
         struct inet6_skb_parm *opt = IP6CB(skb);
         struct net *net = dev_net(dst->dev);
@@ -484,7 +485,7 @@ int ip6_forward(struct sk_buff *skb)
                 IP6_INC_STATS(net, ip6_dst_idev(dst), IPSTATS_MIB_INDISCARDS);
                 goto drop;
         }
-        dst = skb->dst;
+        dst = skb_dst(skb);
 
         /* IPv6 specs say nothing about it, but it is clear that we cannot
            send redirects to source routed frames.
@@ -565,8 +566,8 @@ static void ip6_copy_metadata(struct sk_buff *to, struct sk_buff *from)
         to->pkt_type = from->pkt_type;
         to->priority = from->priority;
         to->protocol = from->protocol;
-        dst_release(to->dst);
-        to->dst = dst_clone(from->dst);
+        skb_dst_drop(to);
+        skb_dst_set(to, dst_clone(skb_dst(from)));
         to->dev = from->dev;
         to->mark = from->mark;
 
@@ -623,7 +624,7 @@ int ip6_find_1stfragopt(struct sk_buff *skb, u8 **nexthdr)
 static int ip6_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *))
 {
         struct sk_buff *frag;
-        struct rt6_info *rt = (struct rt6_info*)skb->dst;
+        struct rt6_info *rt = (struct rt6_info*)skb_dst(skb);
         struct ipv6_pinfo *np = skb->sk ? inet6_sk(skb->sk) : NULL;
         struct ipv6hdr *tmp_hdr;
         struct frag_hdr *fh;
@@ -631,7 +632,7 @@ static int ip6_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *))
         __be32 frag_id = 0;
         int ptr, offset = 0, err=0;
         u8 *prevhdr, nexthdr = 0;
-        struct net *net = dev_net(skb->dst->dev);
+        struct net *net = dev_net(skb_dst(skb)->dev);
 
         hlen = ip6_find_1stfragopt(skb, &prevhdr);
         nexthdr = *prevhdr;
@@ -643,9 +644,9 @@ static int ip6_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *))
          * check should be redundant, but it's free.)
          */
         if (!skb->local_df) {
-                skb->dev = skb->dst->dev;
+                skb->dev = skb_dst(skb)->dev;
                 icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu, skb->dev);
-                IP6_INC_STATS(net, ip6_dst_idev(skb->dst),
+                IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
                               IPSTATS_MIB_FRAGFAILS);
                 kfree_skb(skb);
                 return -EMSGSIZE;
@@ -657,7 +658,7 @@ static int ip6_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *))
         }
         mtu -= hlen + sizeof(struct frag_hdr);
 
-        if (skb_shinfo(skb)->frag_list) {
+        if (skb_has_frags(skb)) {
                 int first_len = skb_pagelen(skb);
                 int truesizes = 0;
 
@@ -666,7 +667,7 @@ static int ip6_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *))
                     skb_cloned(skb))
                         goto slow_path;
 
-                for (frag = skb_shinfo(skb)->frag_list; frag; frag = frag->next) {
+                skb_walk_frags(skb, frag) {
                         /* Correct geometry. */
                         if (frag->len > mtu ||
                             ((frag->len & 7) && frag->next) ||
@@ -679,7 +680,6 @@ static int ip6_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *))
 
                         BUG_ON(frag->sk);
                         if (skb->sk) {
-                                sock_hold(skb->sk);
                                 frag->sk = skb->sk;
                                 frag->destructor = sock_wfree;
                                 truesizes += frag->truesize;
@@ -689,13 +689,13 @@ static int ip6_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *))
                 err = 0;
                 offset = 0;
                 frag = skb_shinfo(skb)->frag_list;
-                skb_shinfo(skb)->frag_list = NULL;
+                skb_frag_list_init(skb);
                 /* BUILD HEADER */
 
                 *prevhdr = NEXTHDR_FRAGMENT;
                 tmp_hdr = kmemdup(skb_network_header(skb), hlen, GFP_ATOMIC);
                 if (!tmp_hdr) {
-                        IP6_INC_STATS(net, ip6_dst_idev(skb->dst),
+                        IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
                                       IPSTATS_MIB_FRAGFAILS);
                         return -ENOMEM;
                 }
@@ -808,7 +808,7 @@ slow_path:
 
                 if ((frag = alloc_skb(len+hlen+sizeof(struct frag_hdr)+LL_ALLOCATED_SPACE(rt->u.dst.dev), GFP_ATOMIC)) == NULL) {
                         NETDEBUG(KERN_INFO "IPv6: frag: no memory for new fragment!\n");
-                        IP6_INC_STATS(net, ip6_dst_idev(skb->dst),
+                        IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
                                       IPSTATS_MIB_FRAGFAILS);
                         err = -ENOMEM;
                         goto fail;
@@ -872,16 +872,16 @@ slow_path:
                 if (err)
                         goto fail;
 
-                IP6_INC_STATS(net, ip6_dst_idev(skb->dst),
+                IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
                               IPSTATS_MIB_FRAGCREATES);
         }
-        IP6_INC_STATS(net, ip6_dst_idev(skb->dst),
+        IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
                       IPSTATS_MIB_FRAGOKS);
         kfree_skb(skb);
         return err;
 
 fail:
-        IP6_INC_STATS(net, ip6_dst_idev(skb->dst),
+        IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
                       IPSTATS_MIB_FRAGFAILS);
         kfree_skb(skb);
         return err;
@@ -1515,10 +1515,10 @@ int ip6_push_pending_frames(struct sock *sk)
         skb->priority = sk->sk_priority;
         skb->mark = sk->sk_mark;
 
-        skb->dst = dst_clone(&rt->u.dst);
-        IP6_INC_STATS(net, rt->rt6i_idev, IPSTATS_MIB_OUTREQUESTS);
+        skb_dst_set(skb, dst_clone(&rt->u.dst));
+        IP6_UPD_PO_STATS(net, rt->rt6i_idev, IPSTATS_MIB_OUT, skb->len);
         if (proto == IPPROTO_ICMPV6) {
-                struct inet6_dev *idev = ip6_dst_idev(skb->dst);
+                struct inet6_dev *idev = ip6_dst_idev(skb_dst(skb));
 
                 ICMP6MSGOUT_INC_STATS_BH(net, idev, icmp6_hdr(skb)->icmp6_type);
                 ICMP6_INC_STATS_BH(net, idev, ICMP6_MIB_OUTMSGS);
@@ -1544,8 +1544,8 @@ void ip6_flush_pending_frames(struct sock *sk)
         struct sk_buff *skb;
 
         while ((skb = __skb_dequeue_tail(&sk->sk_write_queue)) != NULL) {
-                if (skb->dst)
-                        IP6_INC_STATS(sock_net(sk), ip6_dst_idev(skb->dst),
+                if (skb_dst(skb))
+                        IP6_INC_STATS(sock_net(sk), ip6_dst_idev(skb_dst(skb)),
                                       IPSTATS_MIB_OUTDISCARDS);
                 kfree_skb(skb);
         }
diff --git a/net/ipv6/ip6_tunnel.c b/net/ipv6/ip6_tunnel.c
index d994c55a5b16..404d16a97d5c 100644
--- a/net/ipv6/ip6_tunnel.c
+++ b/net/ipv6/ip6_tunnel.c
@@ -532,8 +532,8 @@ ip4ip6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
         if (!skb2)
                 return 0;
 
-        dst_release(skb2->dst);
-        skb2->dst = NULL;
+        skb_dst_drop(skb2);
+
         skb_pull(skb2, offset);
         skb_reset_network_header(skb2);
         eiph = ip_hdr(skb2);
@@ -560,21 +560,21 @@ ip4ip6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
                         ip_rt_put(rt);
                         goto out;
                 }
-                skb2->dst = (struct dst_entry *)rt;
+                skb_dst_set(skb2, (struct dst_entry *)rt);
         } else {
                 ip_rt_put(rt);
                 if (ip_route_input(skb2, eiph->daddr, eiph->saddr, eiph->tos,
                                    skb2->dev) ||
-                    skb2->dst->dev->type != ARPHRD_TUNNEL)
+                    skb_dst(skb2)->dev->type != ARPHRD_TUNNEL)
                         goto out;
         }
 
         /* change mtu on this route */
         if (rel_type == ICMP_DEST_UNREACH && rel_code == ICMP_FRAG_NEEDED) {
-                if (rel_info > dst_mtu(skb2->dst))
+                if (rel_info > dst_mtu(skb_dst(skb2)))
                         goto out;
 
-                skb2->dst->ops->update_pmtu(skb2->dst, rel_info);
+                skb_dst(skb2)->ops->update_pmtu(skb_dst(skb2), rel_info);
         }
 
         icmp_send(skb2, rel_type, rel_code, htonl(rel_info));
@@ -606,8 +606,7 @@ ip6ip6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
                 if (!skb2)
                         return 0;
 
-                dst_release(skb2->dst);
-                skb2->dst = NULL;
+                skb_dst_drop(skb2);
                 skb_pull(skb2, offset);
                 skb_reset_network_header(skb2);
 
@@ -720,8 +719,7 @@ static int ip6_tnl_rcv(struct sk_buff *skb, __u16 protocol,
                 skb->pkt_type = PACKET_HOST;
                 memset(skb->cb, 0, sizeof(struct inet6_skb_parm));
                 skb->dev = t->dev;
-                dst_release(skb->dst);
-                skb->dst = NULL;
+                skb_dst_drop(skb);
                 nf_reset(skb);
 
                 dscp_ecn_decapsulate(t, ipv6h, skb);
@@ -885,8 +883,8 @@ static int ip6_tnl_xmit2(struct sk_buff *skb,
         }
         if (mtu < IPV6_MIN_MTU)
                 mtu = IPV6_MIN_MTU;
-        if (skb->dst)
-                skb->dst->ops->update_pmtu(skb->dst, mtu);
+        if (skb_dst(skb))
+                skb_dst(skb)->ops->update_pmtu(skb_dst(skb), mtu);
         if (skb->len > mtu) {
                 *pmtu = mtu;
                 err = -EMSGSIZE;
@@ -910,8 +908,8 @@ static int ip6_tnl_xmit2(struct sk_buff *skb,
                 kfree_skb(skb);
                 skb = new_skb;
         }
-        dst_release(skb->dst);
-        skb->dst = dst_clone(dst);
+        skb_dst_drop(skb);
+        skb_dst_set(skb, dst_clone(dst));
 
         skb->transport_header = skb->network_header;
 
@@ -1100,8 +1098,8 @@ static void ip6_tnl_link_config(struct ip6_tnl *t)
         struct ip6_tnl_parm *p = &t->parms;
         struct flowi *fl = &t->fl;
 
-        memcpy(&dev->dev_addr, &p->laddr, sizeof(struct in6_addr));
-        memcpy(&dev->broadcast, &p->raddr, sizeof(struct in6_addr));
+        memcpy(dev->dev_addr, &p->laddr, sizeof(struct in6_addr));
+        memcpy(dev->broadcast, &p->raddr, sizeof(struct in6_addr));
 
         /* Set up flowi template */
         ipv6_addr_copy(&fl->fl6_src, &p->laddr);
diff --git a/net/ipv6/ip6mr.c b/net/ipv6/ip6mr.c
index 228be551e9c1..c769f155c698 100644
--- a/net/ipv6/ip6mr.c
+++ b/net/ipv6/ip6mr.c
@@ -398,10 +398,9 @@ static int pim6_rcv(struct sk_buff *skb)
         skb->protocol = htons(ETH_P_IPV6);
         skb->ip_summed = 0;
         skb->pkt_type = PACKET_HOST;
-        dst_release(skb->dst);
+        skb_dst_drop(skb);
         reg_dev->stats.rx_bytes += skb->len;
         reg_dev->stats.rx_packets++;
-        skb->dst = NULL;
         nf_reset(skb);
         netif_rx(skb);
         dev_put(reg_dev);
@@ -442,6 +441,7 @@ static void reg_vif_setup(struct net_device *dev)
         dev->flags              = IFF_NOARP;
         dev->netdev_ops         = &reg_vif_netdev_ops;
         dev->destructor         = free_netdev;
+        dev->features           |= NETIF_F_NETNS_LOCAL;
 }
 
 static struct net_device *ip6mr_reg_vif(struct net *net)
@@ -849,7 +849,7 @@ static int ip6mr_cache_report(struct net *net, struct sk_buff *pkt, mifi_t mifi,
         ipv6_addr_copy(&msg->im6_src, &ipv6_hdr(pkt)->saddr);
         ipv6_addr_copy(&msg->im6_dst, &ipv6_hdr(pkt)->daddr);
 
-        skb->dst = dst_clone(pkt->dst);
+        skb_dst_set(skb, dst_clone(skb_dst(pkt)));
         skb->ip_summed = CHECKSUM_UNNECESSARY;
         }
 
@@ -1078,7 +1078,18 @@ int __init ip6_mr_init(void)
         err = register_netdevice_notifier(&ip6_mr_notifier);
         if (err)
                 goto reg_notif_fail;
+#ifdef CONFIG_IPV6_PIMSM_V2
+        if (inet6_add_protocol(&pim6_protocol, IPPROTO_PIM) < 0) {
+                printk(KERN_ERR "ip6_mr_init: can't add PIM protocol\n");
+                err = -EAGAIN;
+                goto add_proto_fail;
+        }
+#endif
         return 0;
+#ifdef CONFIG_IPV6_PIMSM_V2
+add_proto_fail:
+        unregister_netdevice_notifier(&ip6_mr_notifier);
+#endif
 reg_notif_fail:
         del_timer(&ipmr_expire_timer);
         unregister_pernet_subsys(&ip6mr_net_ops);
@@ -1364,14 +1375,6 @@ int ip6_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, int
                 if (v != net->ipv6.mroute_do_pim) {
                         net->ipv6.mroute_do_pim = v;
                         net->ipv6.mroute_do_assert = v;
-                        if (net->ipv6.mroute_do_pim)
-                                ret = inet6_add_protocol(&pim6_protocol,
-                                                         IPPROTO_PIM);
-                        else
-                                ret = inet6_del_protocol(&pim6_protocol,
-                                                         IPPROTO_PIM);
-                        if (ret < 0)
-                                ret = -EAGAIN;
                 }
                 rtnl_unlock();
                 return ret;
@@ -1487,7 +1490,7 @@ int ip6mr_ioctl(struct sock *sk, int cmd, void __user *arg)
 
 static inline int ip6mr_forward2_finish(struct sk_buff *skb)
 {
-        IP6_INC_STATS_BH(dev_net(skb->dst->dev), ip6_dst_idev(skb->dst),
+        IP6_INC_STATS_BH(dev_net(skb_dst(skb)->dev), ip6_dst_idev(skb_dst(skb)),
                          IPSTATS_MIB_OUTFORWDATAGRAMS);
         return dst_output(skb);
 }
@@ -1532,8 +1535,8 @@ static int ip6mr_forward2(struct sk_buff *skb, struct mfc6_cache *c, int vifi)
         if (!dst)
                 goto out_free;
 
-        dst_release(skb->dst);
-        skb->dst = dst;
+        skb_dst_drop(skb);
+        skb_dst_set(skb, dst);
 
         /*
          * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
@@ -1722,7 +1725,7 @@ int ip6mr_get_route(struct net *net,
 {
         int err;
         struct mfc6_cache *cache;
-        struct rt6_info *rt = (struct rt6_info *)skb->dst;
+        struct rt6_info *rt = (struct rt6_info *)skb_dst(skb);
 
         read_lock(&mrt_lock);
         cache = ip6mr_cache_find(net, &rt->rt6i_src.addr, &rt->rt6i_dst.addr);
diff --git a/net/ipv6/mcast.c b/net/ipv6/mcast.c
index a51fb33e6864..4b264ed40a8c 100644
--- a/net/ipv6/mcast.c
+++ b/net/ipv6/mcast.c
@@ -1448,8 +1448,10 @@ static void mld_sendpack(struct sk_buff *skb)
         struct net *net = dev_net(skb->dev);
         int err;
         struct flowi fl;
+        struct dst_entry *dst;
+
+        IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUT, skb->len);
 
-        IP6_INC_STATS(net, idev, IPSTATS_MIB_OUTREQUESTS);
         payload_len = (skb->tail - skb->network_header) - sizeof(*pip6);
         mldlen = skb->tail - skb->transport_header;
         pip6->payload_len = htons(payload_len);
@@ -1458,9 +1460,9 @@ static void mld_sendpack(struct sk_buff *skb)
                 IPPROTO_ICMPV6, csum_partial(skb_transport_header(skb),
                                              mldlen, 0));
 
-        skb->dst = icmp6_dst_alloc(skb->dev, NULL, &ipv6_hdr(skb)->daddr);
+        dst = icmp6_dst_alloc(skb->dev, NULL, &ipv6_hdr(skb)->daddr);
 
-        if (!skb->dst) {
+        if (!dst) {
                 err = -ENOMEM;
                 goto err_out;
         }
@@ -1469,17 +1471,20 @@ static void mld_sendpack(struct sk_buff *skb)
                          &ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr,
                          skb->dev->ifindex);
 
-        err = xfrm_lookup(net, &skb->dst, &fl, NULL, 0);
+        err = xfrm_lookup(net, &dst, &fl, NULL, 0);
+        skb_dst_set(skb, dst);
         if (err)
                 goto err_out;
 
+        payload_len = skb->len;
+
         err = NF_HOOK(PF_INET6, NF_INET_LOCAL_OUT, skb, NULL, skb->dev,
                       dst_output);
 out:
         if (!err) {
                 ICMP6MSGOUT_INC_STATS_BH(net, idev, ICMPV6_MLD2_REPORT);
                 ICMP6_INC_STATS_BH(net, idev, ICMP6_MIB_OUTMSGS);
-                IP6_INC_STATS_BH(net, idev, IPSTATS_MIB_OUTMCASTPKTS);
+                IP6_UPD_PO_STATS_BH(net, idev, IPSTATS_MIB_OUTMCAST, payload_len);
         } else
                 IP6_INC_STATS_BH(net, idev, IPSTATS_MIB_OUTDISCARDS);
 
@@ -1772,11 +1777,8 @@ static void igmp6_send(struct in6_addr *addr, struct net_device *dev, int type)
                      IPV6_TLV_ROUTERALERT, 2, 0, 0,
                      IPV6_TLV_PADN, 0 };
         struct flowi fl;
+        struct dst_entry *dst;
 
-        rcu_read_lock();
-        IP6_INC_STATS(net, __in6_dev_get(dev),
-                      IPSTATS_MIB_OUTREQUESTS);
-        rcu_read_unlock();
         if (type == ICMPV6_MGM_REDUCTION)
                 snd_addr = &in6addr_linklocal_allrouters;
         else
@@ -1786,6 +1788,11 @@ static void igmp6_send(struct in6_addr *addr, struct net_device *dev, int type)
         payload_len = len + sizeof(ra);
         full_len = sizeof(struct ipv6hdr) + payload_len;
 
+        rcu_read_lock();
+        IP6_UPD_PO_STATS(net, __in6_dev_get(dev),
+                      IPSTATS_MIB_OUT, full_len);
+        rcu_read_unlock();
+
         skb = sock_alloc_send_skb(sk, LL_ALLOCATED_SPACE(dev) + full_len, 1, &err);
 
         if (skb == NULL) {
@@ -1824,8 +1831,8 @@ static void igmp6_send(struct in6_addr *addr, struct net_device *dev, int type)
 
         idev = in6_dev_get(skb->dev);
 
-        skb->dst = icmp6_dst_alloc(skb->dev, NULL, &ipv6_hdr(skb)->daddr);
-        if (!skb->dst) {
+        dst = icmp6_dst_alloc(skb->dev, NULL, &ipv6_hdr(skb)->daddr);
+        if (!dst) {
                 err = -ENOMEM;
                 goto err_out;
         }
@@ -1834,17 +1841,18 @@ static void igmp6_send(struct in6_addr *addr, struct net_device *dev, int type)
                          &ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr,
                          skb->dev->ifindex);
 
-        err = xfrm_lookup(net, &skb->dst, &fl, NULL, 0);
+        err = xfrm_lookup(net, &dst, &fl, NULL, 0);
         if (err)
                 goto err_out;
 
+        skb_dst_set(skb, dst);
         err = NF_HOOK(PF_INET6, NF_INET_LOCAL_OUT, skb, NULL, skb->dev,
                       dst_output);
 out:
         if (!err) {
                 ICMP6MSGOUT_INC_STATS(net, idev, type);
                 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
-                IP6_INC_STATS(net, idev, IPSTATS_MIB_OUTMCASTPKTS);
+                IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUTMCAST, full_len);
         } else
                 IP6_INC_STATS(net, idev, IPSTATS_MIB_OUTDISCARDS);
 
diff --git a/net/ipv6/ndisc.c b/net/ipv6/ndisc.c
index 9f061d1adbc2..9eb68e92cc18 100644
--- a/net/ipv6/ndisc.c
+++ b/net/ipv6/ndisc.c
@@ -465,8 +465,8 @@ struct sk_buff *ndisc_build_skb(struct net_device *dev,
                                   1, &err);
         if (!skb) {
                 ND_PRINTK0(KERN_ERR
-                           "ICMPv6 ND: %s() failed to allocate an skb.\n",
-                           __func__);
+                           "ICMPv6 ND: %s() failed to allocate an skb, err=%d.\n",
+                           __func__, err);
                 return NULL;
         }
 
@@ -530,10 +530,10 @@ void ndisc_send_skb(struct sk_buff *skb,
                 return;
         }
 
-        skb->dst = dst;
+        skb_dst_set(skb, dst);
 
         idev = in6_dev_get(dst->dev);
-        IP6_INC_STATS(net, idev, IPSTATS_MIB_OUTREQUESTS);
+        IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUT, skb->len);
 
         err = NF_HOOK(PF_INET6, NF_INET_LOCAL_OUT, skb, NULL, dst->dev,
                       dst_output);
@@ -658,6 +658,7 @@ void ndisc_send_rs(struct net_device *dev, const struct in6_addr *saddr,
                      &icmp6h, NULL,
                      send_sllao ? ND_OPT_SOURCE_LL_ADDR : 0);
 }
+EXPORT_SYMBOL(ndisc_send_rs);
 
 
 static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb)
@@ -1561,8 +1562,8 @@ void ndisc_send_redirect(struct sk_buff *skb, struct neighbour *neigh,
                                    1, &err);
         if (buff == NULL) {
                 ND_PRINTK0(KERN_ERR
-                           "ICMPv6 Redirect: %s() failed to allocate an skb.\n",
-                           __func__);
+                           "ICMPv6 Redirect: %s() failed to allocate an skb, err=%d.\n",
+                           __func__, err);
                 goto release;
         }
 
@@ -1611,9 +1612,9 @@ void ndisc_send_redirect(struct sk_buff *skb, struct neighbour *neigh,
                                              len, IPPROTO_ICMPV6,
                                              csum_partial(icmph, len, 0));
 
-        buff->dst = dst;
+        skb_dst_set(buff, dst);
         idev = in6_dev_get(dst->dev);
-        IP6_INC_STATS(net, idev, IPSTATS_MIB_OUTREQUESTS);
+        IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUT, skb->len);
         err = NF_HOOK(PF_INET6, NF_INET_LOCAL_OUT, buff, NULL, dst->dev,
                       dst_output);
         if (!err) {
diff --git a/net/ipv6/netfilter.c b/net/ipv6/netfilter.c
index 834cea69fb53..d5ed92b14346 100644
--- a/net/ipv6/netfilter.c
+++ b/net/ipv6/netfilter.c
@@ -12,7 +12,7 @@
 
 int ip6_route_me_harder(struct sk_buff *skb)
 {
-        struct net *net = dev_net(skb->dst->dev);
+        struct net *net = dev_net(skb_dst(skb)->dev);
         struct ipv6hdr *iph = ipv6_hdr(skb);
         struct dst_entry *dst;
         struct flowi fl = {
@@ -28,9 +28,15 @@ int ip6_route_me_harder(struct sk_buff *skb)
 
 #ifdef CONFIG_XFRM
         if (!(IP6CB(skb)->flags & IP6SKB_XFRM_TRANSFORMED) &&
-            xfrm_decode_session(skb, &fl, AF_INET6) == 0)
-                if (xfrm_lookup(net, &skb->dst, &fl, skb->sk, 0))
+            xfrm_decode_session(skb, &fl, AF_INET6) == 0) {
+                struct dst_entry *dst2 = skb_dst(skb);
+
+                if (xfrm_lookup(net, &dst2, &fl, skb->sk, 0)) {
+                        skb_dst_set(skb, NULL);
                         return -1;
+                }
+                skb_dst_set(skb, dst2);
+        }
 #endif
 
         if (dst->error) {
@@ -41,9 +47,9 @@ int ip6_route_me_harder(struct sk_buff *skb)
         }
 
         /* Drop old route. */
-        dst_release(skb->dst);
+        skb_dst_drop(skb);
 
-        skb->dst = dst;
+        skb_dst_set(skb, dst);
         return 0;
 }
 EXPORT_SYMBOL(ip6_route_me_harder);
diff --git a/net/ipv6/netfilter/ip6_queue.c b/net/ipv6/netfilter/ip6_queue.c
index b693f841aeb4..1cf3f0c6a959 100644
--- a/net/ipv6/netfilter/ip6_queue.c
+++ b/net/ipv6/netfilter/ip6_queue.c
@@ -598,7 +598,7 @@ static int __init ip6_queue_init(void)
 #ifdef CONFIG_SYSCTL
         ipq_sysctl_header = register_sysctl_paths(net_ipv6_ctl_path, ipq_table);
 #endif
-        status = nf_register_queue_handler(PF_INET6, &nfqh);
+        status = nf_register_queue_handler(NFPROTO_IPV6, &nfqh);
         if (status < 0) {
                 printk(KERN_ERR "ip6_queue: failed to register queue handler\n");
                 goto cleanup_sysctl;
diff --git a/net/ipv6/netfilter/ip6_tables.c b/net/ipv6/netfilter/ip6_tables.c
index 219e165aea10..ced1f2c0cb65 100644
--- a/net/ipv6/netfilter/ip6_tables.c
+++ b/net/ipv6/netfilter/ip6_tables.c
@@ -270,8 +270,8 @@ static struct nf_loginfo trace_loginfo = {
 /* Mildly perf critical (only if packet tracing is on) */
 static inline int
 get_chainname_rulenum(struct ip6t_entry *s, struct ip6t_entry *e,
-                      char *hookname, char **chainname,
-                      char **comment, unsigned int *rulenum)
+                      const char *hookname, const char **chainname,
+                      const char **comment, unsigned int *rulenum)
 {
         struct ip6t_standard_target *t = (void *)ip6t_get_target(s);
 
@@ -289,8 +289,8 @@ get_chainname_rulenum(struct ip6t_entry *s, struct ip6t_entry *e,
                    && unconditional(&s->ipv6)) {
                         /* Tail of chains: STANDARD target (return/policy) */
                         *comment = *chainname == hookname
-                                ? (char *)comments[NF_IP6_TRACE_COMMENT_POLICY]
-                                : (char *)comments[NF_IP6_TRACE_COMMENT_RETURN];
+                                ? comments[NF_IP6_TRACE_COMMENT_POLICY]
+                                : comments[NF_IP6_TRACE_COMMENT_RETURN];
                 }
                 return 1;
         } else
@@ -309,14 +309,14 @@ static void trace_packet(struct sk_buff *skb,
 {
         void *table_base;
         const struct ip6t_entry *root;
-        char *hookname, *chainname, *comment;
+        const char *hookname, *chainname, *comment;
         unsigned int rulenum = 0;
 
-        table_base = (void *)private->entries[smp_processor_id()];
+        table_base = private->entries[smp_processor_id()];
         root = get_entry(table_base, private->hook_entry[hook]);
 
-        hookname = chainname = (char *)hooknames[hook];
-        comment = (char *)comments[NF_IP6_TRACE_COMMENT_RULE];
+        hookname = chainname = hooknames[hook];
+        comment = comments[NF_IP6_TRACE_COMMENT_RULE];
 
         IP6T_ENTRY_ITERATE(root,
                            private->size - private->hook_entry[hook],
@@ -329,6 +329,12 @@ static void trace_packet(struct sk_buff *skb,
 }
 #endif
 
+static inline __pure struct ip6t_entry *
+ip6t_next_entry(const struct ip6t_entry *entry)
+{
+        return (void *)entry + entry->next_offset;
+}
+
 /* Returns one of the generic firewall policies, like NF_ACCEPT. */
 unsigned int
 ip6t_do_table(struct sk_buff *skb,
@@ -337,6 +343,8 @@ ip6t_do_table(struct sk_buff *skb,
               const struct net_device *out,
               struct xt_table *table)
 {
+#define tb_comefrom ((struct ip6t_entry *)table_base)->comefrom
+
         static const char nulldevname[IFNAMSIZ] __attribute__((aligned(sizeof(long))));
         bool hotdrop = false;
         /* Initializing verdict to NF_DROP keeps gcc happy. */
@@ -361,7 +369,7 @@ ip6t_do_table(struct sk_buff *skb,
         mtpar.in      = tgpar.in  = in;
         mtpar.out     = tgpar.out = out;
         mtpar.family  = tgpar.family = NFPROTO_IPV6;
-        tgpar.hooknum = hook;
+        mtpar.hooknum = tgpar.hooknum = hook;
 
         IP_NF_ASSERT(table->valid_hooks & (1 << hook));
 
@@ -375,96 +383,86 @@ ip6t_do_table(struct sk_buff *skb,
         back = get_entry(table_base, private->underflow[hook]);
 
         do {
+                struct ip6t_entry_target *t;
+
                 IP_NF_ASSERT(e);
                 IP_NF_ASSERT(back);
-                if (ip6_packet_match(skb, indev, outdev, &e->ipv6,
-                        &mtpar.thoff, &mtpar.fragoff, &hotdrop)) {
-                        struct ip6t_entry_target *t;
-
-                        if (IP6T_MATCH_ITERATE(e, do_match, skb, &mtpar) != 0)
-                                goto no_match;
+                if (!ip6_packet_match(skb, indev, outdev, &e->ipv6,
+                    &mtpar.thoff, &mtpar.fragoff, &hotdrop) ||
+                    IP6T_MATCH_ITERATE(e, do_match, skb, &mtpar) != 0) {
+                        e = ip6t_next_entry(e);
+                        continue;
+                }
 
-                        ADD_COUNTER(e->counters,
-                                    ntohs(ipv6_hdr(skb)->payload_len) +
-                                    sizeof(struct ipv6hdr), 1);
+                ADD_COUNTER(e->counters,
+                            ntohs(ipv6_hdr(skb)->payload_len) +
+                            sizeof(struct ipv6hdr), 1);
 
-                        t = ip6t_get_target(e);
-                        IP_NF_ASSERT(t->u.kernel.target);
+                t = ip6t_get_target(e);
+                IP_NF_ASSERT(t->u.kernel.target);
 
 #if defined(CONFIG_NETFILTER_XT_TARGET_TRACE) || \
     defined(CONFIG_NETFILTER_XT_TARGET_TRACE_MODULE)
-                        /* The packet is traced: log it */
-                        if (unlikely(skb->nf_trace))
-                                trace_packet(skb, hook, in, out,
-                                             table->name, private, e);
+                /* The packet is traced: log it */
+                if (unlikely(skb->nf_trace))
+                        trace_packet(skb, hook, in, out,
+                                     table->name, private, e);
 #endif
-                        /* Standard target? */
-                        if (!t->u.kernel.target->target) {
-                                int v;
-
-                                v = ((struct ip6t_standard_target *)t)->verdict;
-                                if (v < 0) {
-                                        /* Pop from stack? */
-                                        if (v != IP6T_RETURN) {
-                                                verdict = (unsigned)(-v) - 1;
-                                                break;
-                                        }
-                                        e = back;
-                                        back = get_entry(table_base,
-                                                         back->comefrom);
-                                        continue;
-                                }
-                                if (table_base + v != (void *)e + e->next_offset
-                                    && !(e->ipv6.flags & IP6T_F_GOTO)) {
-                                        /* Save old back ptr in next entry */
-                                        struct ip6t_entry *next
-                                                = (void *)e + e->next_offset;
-                                        next->comefrom
-                                                = (void *)back - table_base;
-                                        /* set back pointer to next entry */
-                                        back = next;
+                /* Standard target? */
+                if (!t->u.kernel.target->target) {
+                        int v;
+
+                        v = ((struct ip6t_standard_target *)t)->verdict;
+                        if (v < 0) {
+                                /* Pop from stack? */
+                                if (v != IP6T_RETURN) {
+                                        verdict = (unsigned)(-v) - 1;
+                                        break;
                                 }
+                                e = back;
+                                back = get_entry(table_base, back->comefrom);
+                                continue;
+                        }
+                        if (table_base + v != ip6t_next_entry(e)
+                            && !(e->ipv6.flags & IP6T_F_GOTO)) {
+                                /* Save old back ptr in next entry */
+                                struct ip6t_entry *next = ip6t_next_entry(e);
+                                next->comefrom = (void *)back - table_base;
+                                /* set back pointer to next entry */
+                                back = next;
+                        }
 
-                                e = get_entry(table_base, v);
-                        } else {
-                                /* Targets which reenter must return
-                                   abs. verdicts */
-                                tgpar.target   = t->u.kernel.target;
-                                tgpar.targinfo = t->data;
+                        e = get_entry(table_base, v);
+                        continue;
+                }
 
-#ifdef CONFIG_NETFILTER_DEBUG
-                                ((struct ip6t_entry *)table_base)->comefrom
-                                        = 0xeeeeeeec;
-#endif
-                                verdict = t->u.kernel.target->target(skb,
-                                                                     &tgpar);
+                /* Targets which reenter must return
+                   abs. verdicts */
+                tgpar.target   = t->u.kernel.target;
+                tgpar.targinfo = t->data;
 
 #ifdef CONFIG_NETFILTER_DEBUG
-                                if (((struct ip6t_entry *)table_base)->comefrom
-                                    != 0xeeeeeeec
-                                    && verdict == IP6T_CONTINUE) {
-                                        printk("Target %s reentered!\n",
-                                               t->u.kernel.target->name);
-                                        verdict = NF_DROP;
-                                }
-                                ((struct ip6t_entry *)table_base)->comefrom
-                                        = 0x57acc001;
+                tb_comefrom = 0xeeeeeeec;
 #endif
-                                if (verdict == IP6T_CONTINUE)
-                                        e = (void *)e + e->next_offset;
-                                else
-                                        /* Verdict */
-                                        break;
-                        }
-                } else {
+                verdict = t->u.kernel.target->target(skb, &tgpar);
 
-                no_match:
-                        e = (void *)e + e->next_offset;
+#ifdef CONFIG_NETFILTER_DEBUG
+                if (tb_comefrom != 0xeeeeeeec && verdict == IP6T_CONTINUE) {
+                        printk("Target %s reentered!\n",
+                               t->u.kernel.target->name);
+                        verdict = NF_DROP;
                 }
+                tb_comefrom = 0x57acc001;
+#endif
+                if (verdict == IP6T_CONTINUE)
+                        e = ip6t_next_entry(e);
+                else
+                        /* Verdict */
+                        break;
         } while (!hotdrop);
 
 #ifdef CONFIG_NETFILTER_DEBUG
-        ((struct ip6t_entry *)table_base)->comefrom = NETFILTER_LINK_POISON;
+        tb_comefrom = NETFILTER_LINK_POISON;
 #endif
         xt_info_rdunlock_bh();
 
@@ -475,6 +473,8 @@ ip6t_do_table(struct sk_buff *skb,
                 return NF_DROP;
         else return verdict;
 #endif
+
+#undef tb_comefrom
 }
 
 /* Figures out from what hook each rule can be called: returns 0 if
@@ -2191,7 +2191,7 @@ static bool icmp6_checkentry(const struct xt_mtchk_param *par)
 static struct xt_target ip6t_standard_target __read_mostly = {
         .name           = IP6T_STANDARD_TARGET,
         .targetsize     = sizeof(int),
-        .family         = AF_INET6,
+        .family         = NFPROTO_IPV6,
 #ifdef CONFIG_COMPAT
         .compatsize     = sizeof(compat_int_t),
         .compat_from_user = compat_standard_from_user,
@@ -2203,7 +2203,7 @@ static struct xt_target ip6t_error_target __read_mostly = {
         .name           = IP6T_ERROR_TARGET,
         .target         = ip6t_error,
         .targetsize     = IP6T_FUNCTION_MAXNAMELEN,
-        .family         = AF_INET6,
+        .family         = NFPROTO_IPV6,
 };
 
 static struct nf_sockopt_ops ip6t_sockopts = {
@@ -2229,17 +2229,17 @@ static struct xt_match icmp6_matchstruct __read_mostly = {
         .matchsize      = sizeof(struct ip6t_icmp),
         .checkentry     = icmp6_checkentry,
         .proto          = IPPROTO_ICMPV6,
-        .family         = AF_INET6,
+        .family         = NFPROTO_IPV6,
 };
 
 static int __net_init ip6_tables_net_init(struct net *net)
 {
-        return xt_proto_init(net, AF_INET6);
+        return xt_proto_init(net, NFPROTO_IPV6);
 }
 
 static void __net_exit ip6_tables_net_exit(struct net *net)
 {
-        xt_proto_fini(net, AF_INET6);
+        xt_proto_fini(net, NFPROTO_IPV6);
 }
 
 static struct pernet_operations ip6_tables_net_ops = {
diff --git a/net/ipv6/netfilter/ip6t_REJECT.c b/net/ipv6/netfilter/ip6t_REJECT.c
index 5a2d0a41694a..5a7f00cd15ce 100644
--- a/net/ipv6/netfilter/ip6t_REJECT.c
+++ b/net/ipv6/netfilter/ip6t_REJECT.c
@@ -112,7 +112,7 @@ static void send_reset(struct net *net, struct sk_buff *oldskb)
                 return;
         }
 
-        nskb->dst = dst;
+        skb_dst_set(nskb, dst);
 
         skb_reserve(nskb, hh_len + dst->header_len);
 
diff --git a/net/ipv6/netfilter/nf_conntrack_proto_icmpv6.c b/net/ipv6/netfilter/nf_conntrack_proto_icmpv6.c
index 9903227bf37c..642dcb127bab 100644
--- a/net/ipv6/netfilter/nf_conntrack_proto_icmpv6.c
+++ b/net/ipv6/netfilter/nf_conntrack_proto_icmpv6.c
@@ -95,18 +95,10 @@ static int icmpv6_packet(struct nf_conn *ct,
                        u_int8_t pf,
                        unsigned int hooknum)
 {
-        /* Try to delete connection immediately after all replies:
-           won't actually vanish as we still have skb, and del_timer
-           means this will only run once even if count hits zero twice
-           (theoretically possible with SMP) */
-        if (CTINFO2DIR(ctinfo) == IP_CT_DIR_REPLY) {
-                if (atomic_dec_and_test(&ct->proto.icmp.count))
-                        nf_ct_kill_acct(ct, ctinfo, skb);
-        } else {
-                atomic_inc(&ct->proto.icmp.count);
-                nf_conntrack_event_cache(IPCT_PROTOINFO_VOLATILE, ct);
-                nf_ct_refresh_acct(ct, ctinfo, skb, nf_ct_icmpv6_timeout);
-        }
+        /* Do not immediately delete the connection after the first
+           successful reply to avoid excessive conntrackd traffic
+           and also to handle correctly ICMP echo reply duplicates. */
+        nf_ct_refresh_acct(ct, ctinfo, skb, nf_ct_icmpv6_timeout);
 
         return NF_ACCEPT;
 }
@@ -132,7 +124,6 @@ static bool icmpv6_new(struct nf_conn *ct, const struct sk_buff *skb,
                                       type + 128);
                 return false;
         }
-        atomic_set(&ct->proto.icmp.count, 0);
         return true;
 }
 
diff --git a/net/ipv6/netfilter/nf_conntrack_reasm.c b/net/ipv6/netfilter/nf_conntrack_reasm.c
index 058a5e4a60c3..f3aba255ad9f 100644
--- a/net/ipv6/netfilter/nf_conntrack_reasm.c
+++ b/net/ipv6/netfilter/nf_conntrack_reasm.c
@@ -409,7 +409,7 @@ nf_ct_frag6_reasm(struct nf_ct_frag6_queue *fq, struct net_device *dev)
         /* If the first fragment is fragmented itself, we split
          * it to two chunks: the first with data and paged part
          * and the second, holding only fragments. */
-        if (skb_shinfo(head)->frag_list) {
+        if (skb_has_frags(head)) {
                 struct sk_buff *clone;
                 int i, plen = 0;
 
@@ -420,7 +420,7 @@ nf_ct_frag6_reasm(struct nf_ct_frag6_queue *fq, struct net_device *dev)
                 clone->next = head->next;
                 head->next = clone;
                 skb_shinfo(clone)->frag_list = skb_shinfo(head)->frag_list;
-                skb_shinfo(head)->frag_list = NULL;
+                skb_frag_list_init(head);
                 for (i=0; i<skb_shinfo(head)->nr_frags; i++)
                         plen += skb_shinfo(head)->frags[i].size;
                 clone->len = clone->data_len = head->data_len - plen;
diff --git a/net/ipv6/proc.c b/net/ipv6/proc.c
index 97c17fdd6f75..590ddefb7ffc 100644
--- a/net/ipv6/proc.c
+++ b/net/ipv6/proc.c
@@ -61,7 +61,7 @@ static const struct file_operations sockstat6_seq_fops = {
 
 static struct snmp_mib snmp6_ipstats_list[] = {
 /* ipv6 mib according to RFC 2465 */
-        SNMP_MIB_ITEM("Ip6InReceives", IPSTATS_MIB_INRECEIVES),
+        SNMP_MIB_ITEM("Ip6InReceives", IPSTATS_MIB_INPKTS),
         SNMP_MIB_ITEM("Ip6InHdrErrors", IPSTATS_MIB_INHDRERRORS),
         SNMP_MIB_ITEM("Ip6InTooBigErrors", IPSTATS_MIB_INTOOBIGERRORS),
         SNMP_MIB_ITEM("Ip6InNoRoutes", IPSTATS_MIB_INNOROUTES),
@@ -71,7 +71,7 @@ static struct snmp_mib snmp6_ipstats_list[] = {
         SNMP_MIB_ITEM("Ip6InDiscards", IPSTATS_MIB_INDISCARDS),
         SNMP_MIB_ITEM("Ip6InDelivers", IPSTATS_MIB_INDELIVERS),
         SNMP_MIB_ITEM("Ip6OutForwDatagrams", IPSTATS_MIB_OUTFORWDATAGRAMS),
-        SNMP_MIB_ITEM("Ip6OutRequests", IPSTATS_MIB_OUTREQUESTS),
+        SNMP_MIB_ITEM("Ip6OutRequests", IPSTATS_MIB_OUTPKTS),
         SNMP_MIB_ITEM("Ip6OutDiscards", IPSTATS_MIB_OUTDISCARDS),
         SNMP_MIB_ITEM("Ip6OutNoRoutes", IPSTATS_MIB_OUTNOROUTES),
         SNMP_MIB_ITEM("Ip6ReasmTimeout", IPSTATS_MIB_REASMTIMEOUT),
@@ -83,6 +83,12 @@ static struct snmp_mib snmp6_ipstats_list[] = {
         SNMP_MIB_ITEM("Ip6FragCreates", IPSTATS_MIB_FRAGCREATES),
         SNMP_MIB_ITEM("Ip6InMcastPkts", IPSTATS_MIB_INMCASTPKTS),
         SNMP_MIB_ITEM("Ip6OutMcastPkts", IPSTATS_MIB_OUTMCASTPKTS),
+        SNMP_MIB_ITEM("Ip6InOctets", IPSTATS_MIB_INOCTETS),
+        SNMP_MIB_ITEM("Ip6OutOctets", IPSTATS_MIB_OUTOCTETS),
+        SNMP_MIB_ITEM("Ip6InMcastOctets", IPSTATS_MIB_INMCASTOCTETS),
+        SNMP_MIB_ITEM("Ip6OutMcastOctets", IPSTATS_MIB_OUTMCASTOCTETS),
+        SNMP_MIB_ITEM("Ip6InBcastOctets", IPSTATS_MIB_INBCASTOCTETS),
+        SNMP_MIB_ITEM("Ip6OutBcastOctets", IPSTATS_MIB_OUTBCASTOCTETS),
         SNMP_MIB_SENTINEL
 };
 
diff --git a/net/ipv6/raw.c b/net/ipv6/raw.c
index 61f6827e5906..36a090d87a3d 100644
--- a/net/ipv6/raw.c
+++ b/net/ipv6/raw.c
@@ -625,7 +625,7 @@ static int rawv6_send_hdrinc(struct sock *sk, void *from, int length,
 
         skb->priority = sk->sk_priority;
         skb->mark = sk->sk_mark;
-        skb->dst = dst_clone(&rt->u.dst);
+        skb_dst_set(skb, dst_clone(&rt->u.dst));
 
         skb_put(skb, length);
         skb_reset_network_header(skb);
@@ -638,7 +638,7 @@ static int rawv6_send_hdrinc(struct sock *sk, void *from, int length,
         if (err)
                 goto error_fault;
 
-        IP6_INC_STATS(sock_net(sk), rt->rt6i_idev, IPSTATS_MIB_OUTREQUESTS);
+        IP6_UPD_PO_STATS(sock_net(sk), rt->rt6i_idev, IPSTATS_MIB_OUT, skb->len);
         err = NF_HOOK(PF_INET6, NF_INET_LOCAL_OUT, skb, NULL, rt->u.dst.dev,
                       dst_output);
         if (err > 0)
diff --git a/net/ipv6/reassembly.c b/net/ipv6/reassembly.c
index e9ac7a12f595..2642a41a8535 100644
--- a/net/ipv6/reassembly.c
+++ b/net/ipv6/reassembly.c
@@ -267,7 +267,7 @@ static int ip6_frag_queue(struct frag_queue *fq, struct sk_buff *skb,
         struct sk_buff *prev, *next;
         struct net_device *dev;
         int offset, end;
-        struct net *net = dev_net(skb->dst->dev);
+        struct net *net = dev_net(skb_dst(skb)->dev);
 
         if (fq->q.last_in & INET_FRAG_COMPLETE)
                 goto err;
@@ -277,7 +277,7 @@ static int ip6_frag_queue(struct frag_queue *fq, struct sk_buff *skb,
                         ((u8 *)(fhdr + 1) - (u8 *)(ipv6_hdr(skb) + 1)));
 
         if ((unsigned int)end > IPV6_MAXPLEN) {
-                IP6_INC_STATS_BH(net, ip6_dst_idev(skb->dst),
+                IP6_INC_STATS_BH(net, ip6_dst_idev(skb_dst(skb)),
                                  IPSTATS_MIB_INHDRERRORS);
                 icmpv6_param_prob(skb, ICMPV6_HDR_FIELD,
                                   ((u8 *)&fhdr->frag_off -
@@ -310,7 +310,7 @@ static int ip6_frag_queue(struct frag_queue *fq, struct sk_buff *skb,
                         /* RFC2460 says always send parameter problem in
                          * this case. -DaveM
                          */
-                        IP6_INC_STATS_BH(net, ip6_dst_idev(skb->dst),
+                        IP6_INC_STATS_BH(net, ip6_dst_idev(skb_dst(skb)),
                                          IPSTATS_MIB_INHDRERRORS);
                         icmpv6_param_prob(skb, ICMPV6_HDR_FIELD,
                                           offsetof(struct ipv6hdr, payload_len));
@@ -434,7 +434,7 @@ static int ip6_frag_queue(struct frag_queue *fq, struct sk_buff *skb,
         return -1;
 
 err:
-        IP6_INC_STATS(net, ip6_dst_idev(skb->dst),
+        IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
                       IPSTATS_MIB_REASMFAILS);
         kfree_skb(skb);
         return -1;
@@ -494,7 +494,7 @@ static int ip6_frag_reasm(struct frag_queue *fq, struct sk_buff *prev,
         /* If the first fragment is fragmented itself, we split
          * it to two chunks: the first with data and paged part
          * and the second, holding only fragments. */
-        if (skb_shinfo(head)->frag_list) {
+        if (skb_has_frags(head)) {
                 struct sk_buff *clone;
                 int i, plen = 0;
 
@@ -503,7 +503,7 @@ static int ip6_frag_reasm(struct frag_queue *fq, struct sk_buff *prev,
                 clone->next = head->next;
                 head->next = clone;
                 skb_shinfo(clone)->frag_list = skb_shinfo(head)->frag_list;
-                skb_shinfo(head)->frag_list = NULL;
+                skb_frag_list_init(head);
                 for (i=0; i<skb_shinfo(head)->nr_frags; i++)
                         plen += skb_shinfo(head)->frags[i].size;
                 clone->len = clone->data_len = head->data_len - plen;
@@ -576,9 +576,9 @@ static int ipv6_frag_rcv(struct sk_buff *skb)
         struct frag_hdr *fhdr;
         struct frag_queue *fq;
         struct ipv6hdr *hdr = ipv6_hdr(skb);
-        struct net *net = dev_net(skb->dst->dev);
+        struct net *net = dev_net(skb_dst(skb)->dev);
 
-        IP6_INC_STATS_BH(net, ip6_dst_idev(skb->dst), IPSTATS_MIB_REASMREQDS);
+        IP6_INC_STATS_BH(net, ip6_dst_idev(skb_dst(skb)), IPSTATS_MIB_REASMREQDS);
 
         /* Jumbo payload inhibits frag. header */
         if (hdr->payload_len==0)
@@ -595,17 +595,17 @@ static int ipv6_frag_rcv(struct sk_buff *skb)
                 /* It is not a fragmented frame */
                 skb->transport_header += sizeof(struct frag_hdr);
                 IP6_INC_STATS_BH(net,
-                                 ip6_dst_idev(skb->dst), IPSTATS_MIB_REASMOKS);
+                                 ip6_dst_idev(skb_dst(skb)), IPSTATS_MIB_REASMOKS);
 
                 IP6CB(skb)->nhoff = (u8 *)fhdr - skb_network_header(skb);
                 return 1;
         }
 
         if (atomic_read(&net->ipv6.frags.mem) > net->ipv6.frags.high_thresh)
-                ip6_evictor(net, ip6_dst_idev(skb->dst));
+                ip6_evictor(net, ip6_dst_idev(skb_dst(skb)));
 
         if ((fq = fq_find(net, fhdr->identification, &hdr->saddr, &hdr->daddr,
-                          ip6_dst_idev(skb->dst))) != NULL) {
+                          ip6_dst_idev(skb_dst(skb)))) != NULL) {
                 int ret;
 
                 spin_lock(&fq->q.lock);
@@ -617,12 +617,12 @@ static int ipv6_frag_rcv(struct sk_buff *skb)
                 return ret;
         }
 
-        IP6_INC_STATS_BH(net, ip6_dst_idev(skb->dst), IPSTATS_MIB_REASMFAILS);
+        IP6_INC_STATS_BH(net, ip6_dst_idev(skb_dst(skb)), IPSTATS_MIB_REASMFAILS);
         kfree_skb(skb);
         return -1;
 
 fail_hdr:
-        IP6_INC_STATS(net, ip6_dst_idev(skb->dst), IPSTATS_MIB_INHDRERRORS);
+        IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)), IPSTATS_MIB_INHDRERRORS);
         icmpv6_param_prob(skb, ICMPV6_HDR_FIELD, skb_network_header_len(skb));
         return -1;
 }
diff --git a/net/ipv6/route.c b/net/ipv6/route.c
index 032a5ec391c5..658293ea05ba 100644
--- a/net/ipv6/route.c
+++ b/net/ipv6/route.c
@@ -800,7 +800,7 @@ void ip6_route_input(struct sk_buff *skb)
         if (rt6_need_strict(&iph->daddr) && skb->dev->type != ARPHRD_PIMREG)
                 flags |= RT6_LOOKUP_F_IFACE;
 
-        skb->dst = fib6_rule_lookup(net, &fl, flags, ip6_pol_route_input);
+        skb_dst_set(skb, fib6_rule_lookup(net, &fl, flags, ip6_pol_route_input));
 }
 
 static struct rt6_info *ip6_pol_route_output(struct net *net, struct fib6_table *table,
@@ -911,7 +911,7 @@ static void ip6_link_failure(struct sk_buff *skb)
 
         icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0, skb->dev);
 
-        rt = (struct rt6_info *) skb->dst;
+        rt = (struct rt6_info *) skb_dst(skb);
         if (rt) {
                 if (rt->rt6i_flags&RTF_CACHE) {
                         dst_set_expires(&rt->u.dst, 0);
@@ -1868,7 +1868,7 @@ int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg)
 static int ip6_pkt_drop(struct sk_buff *skb, int code, int ipstats_mib_noroutes)
 {
         int type;
-        struct dst_entry *dst = skb->dst;
+        struct dst_entry *dst = skb_dst(skb);
         switch (ipstats_mib_noroutes) {
         case IPSTATS_MIB_INNOROUTES:
                 type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
@@ -1895,7 +1895,7 @@ static int ip6_pkt_discard(struct sk_buff *skb)
 
 static int ip6_pkt_discard_out(struct sk_buff *skb)
 {
-        skb->dev = skb->dst->dev;
+        skb->dev = skb_dst(skb)->dev;
         return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
 }
 
@@ -1908,7 +1908,7 @@ static int ip6_pkt_prohibit(struct sk_buff *skb)
 
 static int ip6_pkt_prohibit_out(struct sk_buff *skb)
 {
-        skb->dev = skb->dst->dev;
+        skb->dev = skb_dst(skb)->dev;
         return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
 }
 
@@ -2366,7 +2366,7 @@ static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void
         skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
 
         rt = (struct rt6_info*) ip6_route_output(net, NULL, &fl);
-        skb->dst = &rt->u.dst;
+        skb_dst_set(skb, &rt->u.dst);
 
         err = rt6_fill_node(net, skb, rt, &fl.fl6_dst, &fl.fl6_src, iif,
                             RTM_NEWROUTE, NETLINK_CB(in_skb).pid,
diff --git a/net/ipv6/sit.c b/net/ipv6/sit.c
index 664ab82e03b2..68e52308e552 100644
--- a/net/ipv6/sit.c
+++ b/net/ipv6/sit.c
@@ -15,6 +15,7 @@
  * Roger Venning <r.venning@telstra.com>:       6to4 support
  * Nate Thompson <nate@thebog.net>:             6to4 support
  * Fred Templin <fred.l.templin@boeing.com>:    isatap support
+ * Sascha Hlusiak <mail@saschahlusiak.de>:      stateless autoconf for isatap
  */
 
 #include <linux/module.h>
@@ -80,7 +81,7 @@ struct sit_net {
 static DEFINE_RWLOCK(ipip6_lock);
 
 static struct ip_tunnel * ipip6_tunnel_lookup(struct net *net,
-                __be32 remote, __be32 local)
+                struct net_device *dev, __be32 remote, __be32 local)
 {
         unsigned h0 = HASH(remote);
         unsigned h1 = HASH(local);
@@ -89,18 +90,25 @@ static struct ip_tunnel * ipip6_tunnel_lookup(struct net *net,
 
         for (t = sitn->tunnels_r_l[h0^h1]; t; t = t->next) {
                 if (local == t->parms.iph.saddr &&
-                    remote == t->parms.iph.daddr && (t->dev->flags&IFF_UP))
+                    remote == t->parms.iph.daddr &&
+                    (!dev || !t->parms.link || dev->iflink == t->parms.link) &&
+                    (t->dev->flags & IFF_UP))
                         return t;
         }
         for (t = sitn->tunnels_r[h0]; t; t = t->next) {
-                if (remote == t->parms.iph.daddr && (t->dev->flags&IFF_UP))
+                if (remote == t->parms.iph.daddr &&
+                    (!dev || !t->parms.link || dev->iflink == t->parms.link) &&
+                    (t->dev->flags & IFF_UP))
                         return t;
         }
         for (t = sitn->tunnels_l[h1]; t; t = t->next) {
-                if (local == t->parms.iph.saddr && (t->dev->flags&IFF_UP))
+                if (local == t->parms.iph.saddr &&
+                    (!dev || !t->parms.link || dev->iflink == t->parms.link) &&
+                    (t->dev->flags & IFF_UP))
                         return t;
         }
-        if ((t = sitn->tunnels_wc[0]) != NULL && (t->dev->flags&IFF_UP))
+        t = sitn->tunnels_wc[0];
+        if ((t != NULL) && (t->dev->flags & IFF_UP))
                 return t;
         return NULL;
 }
@@ -165,8 +173,14 @@ static struct ip_tunnel * ipip6_tunnel_locate(struct net *net,
         struct sit_net *sitn = net_generic(net, sit_net_id);
 
         for (tp = __ipip6_bucket(sitn, parms); (t = *tp) != NULL; tp = &t->next) {
-                if (local == t->parms.iph.saddr && remote == t->parms.iph.daddr)
-                        return t;
+                if (local == t->parms.iph.saddr &&
+                    remote == t->parms.iph.daddr &&
+                    parms->link == t->parms.link) {
+                        if (create)
+                                return NULL;
+                        else
+                                return t;
+                }
         }
         if (!create)
                 goto failed;
@@ -209,6 +223,44 @@ failed:
         return NULL;
 }
 
+static void ipip6_tunnel_rs_timer(unsigned long data)
+{
+        struct ip_tunnel_prl_entry *p = (struct ip_tunnel_prl_entry *) data;
+        struct inet6_dev *ifp;
+        struct inet6_ifaddr *addr;
+
+        spin_lock(&p->lock);
+        ifp = __in6_dev_get(p->tunnel->dev);
+
+        read_lock_bh(&ifp->lock);
+        for (addr = ifp->addr_list; addr; addr = addr->if_next) {
+                struct in6_addr rtr;
+
+                if (!(ipv6_addr_type(&addr->addr) & IPV6_ADDR_LINKLOCAL))
+                        continue;
+
+                /* Send RS to guessed linklocal address of router
+                 *
+                 * Better: send to ff02::2 encapsuled in unicast directly
+                 * to router-v4 instead of guessing the v6 address.
+                 *
+                 * Cisco/Windows seem to not set the u/l bit correctly,
+                 * so we won't guess right.
+                 */
+                ipv6_addr_set(&rtr,  htonl(0xFE800000), 0, 0, 0);
+                if (!__ipv6_isatap_ifid(rtr.s6_addr + 8,
+                                        p->addr)) {
+                        ndisc_send_rs(p->tunnel->dev, &addr->addr, &rtr);
+                }
+        }
+        read_unlock_bh(&ifp->lock);
+
+        mod_timer(&p->rs_timer, jiffies + HZ * p->rs_delay);
+        spin_unlock(&p->lock);
+
+        return;
+}
+
 static struct ip_tunnel_prl_entry *
 __ipip6_tunnel_locate_prl(struct ip_tunnel *t, __be32 addr)
 {
@@ -267,6 +319,7 @@ static int ipip6_tunnel_get_prl(struct ip_tunnel *t,
                         continue;
                 kp[c].addr = prl->addr;
                 kp[c].flags = prl->flags;
+                kp[c].rs_delay = prl->rs_delay;
                 c++;
                 if (kprl.addr != htonl(INADDR_ANY))
                         break;
@@ -316,11 +369,23 @@ ipip6_tunnel_add_prl(struct ip_tunnel *t, struct ip_tunnel_prl *a, int chg)
         }
 
         p->next = t->prl;
+        p->tunnel = t;
         t->prl = p;
         t->prl_count++;
+
+        spin_lock_init(&p->lock);
+        setup_timer(&p->rs_timer, ipip6_tunnel_rs_timer, (unsigned long) p);
 update:
         p->addr = a->addr;
         p->flags = a->flags;
+        p->rs_delay = a->rs_delay;
+        if (p->rs_delay == 0)
+                p->rs_delay = IPTUNNEL_RS_DEFAULT_DELAY;
+        spin_lock(&p->lock);
+        del_timer(&p->rs_timer);
+        if (p->flags & PRL_DEFAULT)
+                mod_timer(&p->rs_timer, jiffies + 1);
+        spin_unlock(&p->lock);
 out:
         write_unlock(&ipip6_lock);
         return err;
@@ -339,6 +404,9 @@ ipip6_tunnel_del_prl(struct ip_tunnel *t, struct ip_tunnel_prl *a)
                         if ((*p)->addr == a->addr) {
                                 x = *p;
                                 *p = x->next;
+                                spin_lock(&x->lock);
+                                del_timer(&x->rs_timer);
+                                spin_unlock(&x->lock);
                                 kfree(x);
                                 t->prl_count--;
                                 goto out;
@@ -349,13 +417,16 @@ ipip6_tunnel_del_prl(struct ip_tunnel *t, struct ip_tunnel_prl *a)
                 while (t->prl) {
                         x = t->prl;
                         t->prl = t->prl->next;
+                        spin_lock(&x->lock);
+                        del_timer(&x->rs_timer);
+                        spin_unlock(&x->lock);
                         kfree(x);
                         t->prl_count--;
                 }
         }
 out:
         write_unlock(&ipip6_lock);
-        return 0;
+        return err;
 }
 
 static int
@@ -446,7 +517,10 @@ static int ipip6_err(struct sk_buff *skb, u32 info)
         err = -ENOENT;
 
         read_lock(&ipip6_lock);
-        t = ipip6_tunnel_lookup(dev_net(skb->dev), iph->daddr, iph->saddr);
+        t = ipip6_tunnel_lookup(dev_net(skb->dev),
+                                skb->dev,
+                                iph->daddr,
+                                iph->saddr);
         if (t == NULL || t->parms.iph.daddr == 0)
                 goto out;
 
@@ -481,8 +555,9 @@ static int ipip6_rcv(struct sk_buff *skb)
         iph = ip_hdr(skb);
 
         read_lock(&ipip6_lock);
-        if ((tunnel = ipip6_tunnel_lookup(dev_net(skb->dev),
-                                        iph->saddr, iph->daddr)) != NULL) {
+        tunnel = ipip6_tunnel_lookup(dev_net(skb->dev), skb->dev,
+                                     iph->saddr, iph->daddr);
+        if (tunnel != NULL) {
                 secpath_reset(skb);
                 skb->mac_header = skb->network_header;
                 skb_reset_network_header(skb);
@@ -500,8 +575,7 @@ static int ipip6_rcv(struct sk_buff *skb)
                 tunnel->dev->stats.rx_packets++;
                 tunnel->dev->stats.rx_bytes += skb->len;
                 skb->dev = tunnel->dev;
-                dst_release(skb->dst);
-                skb->dst = NULL;
+                skb_dst_drop(skb);
                 nf_reset(skb);
                 ipip6_ecn_decapsulate(iph, skb);
                 netif_rx(skb);
@@ -563,8 +637,8 @@ static int ipip6_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
         if (dev->priv_flags & IFF_ISATAP) {
                 struct neighbour *neigh = NULL;
 
-                if (skb->dst)
-                        neigh = skb->dst->neighbour;
+                if (skb_dst(skb))
+                        neigh = skb_dst(skb)->neighbour;
 
                 if (neigh == NULL) {
                         if (net_ratelimit())
@@ -588,8 +662,8 @@ static int ipip6_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
         if (!dst) {
                 struct neighbour *neigh = NULL;
 
-                if (skb->dst)
-                        neigh = skb->dst->neighbour;
+                if (skb_dst(skb))
+                        neigh = skb_dst(skb)->neighbour;
 
                 if (neigh == NULL) {
                         if (net_ratelimit())
@@ -639,7 +713,7 @@ static int ipip6_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
         if (tiph->frag_off)
                 mtu = dst_mtu(&rt->u.dst) - sizeof(struct iphdr);
         else
-                mtu = skb->dst ? dst_mtu(skb->dst) : dev->mtu;
+                mtu = skb_dst(skb) ? dst_mtu(skb_dst(skb)) : dev->mtu;
 
         if (mtu < 68) {
                 stats->collisions++;
@@ -648,8 +722,8 @@ static int ipip6_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
         }
         if (mtu < IPV6_MIN_MTU)
                 mtu = IPV6_MIN_MTU;
-        if (tunnel->parms.iph.daddr && skb->dst)
-                skb->dst->ops->update_pmtu(skb->dst, mtu);
+        if (tunnel->parms.iph.daddr && skb_dst(skb))
+                skb_dst(skb)->ops->update_pmtu(skb_dst(skb), mtu);
 
         if (skb->len > mtu) {
                 icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu, dev);
@@ -693,8 +767,8 @@ static int ipip6_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
         skb_reset_network_header(skb);
         memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
         IPCB(skb)->flags = 0;
-        dst_release(skb->dst);
-        skb->dst = &rt->u.dst;
+        skb_dst_drop(skb);
+        skb_dst_set(skb, &rt->u.dst);
 
         /*
          *      Push down and install the IPIP header.
diff --git a/net/ipv6/syncookies.c b/net/ipv6/syncookies.c
index 711175e0571f..8c2513982b61 100644
--- a/net/ipv6/syncookies.c
+++ b/net/ipv6/syncookies.c
@@ -131,7 +131,7 @@ __u32 cookie_v6_init_sequence(struct sock *sk, struct sk_buff *skb, __u16 *mssp)
         int mssind;
         const __u16 mss = *mssp;
 
-        tcp_sk(sk)->last_synq_overflow = jiffies;
+        tcp_synq_overflow(sk);
 
         for (mssind = 0; mss > msstab[mssind + 1]; mssind++)
                 ;
@@ -175,7 +175,7 @@ struct sock *cookie_v6_check(struct sock *sk, struct sk_buff *skb)
         if (!sysctl_tcp_syncookies || !th->ack)
                 goto out;
 
-        if (time_after(jiffies, tp->last_synq_overflow + TCP_TIMEOUT_INIT) ||
+        if (tcp_synq_no_recent_overflow(sk) ||
                 (mss = cookie_check(skb, cookie)) == 0) {
                 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_SYNCOOKIESFAILED);
                 goto out;
diff --git a/net/ipv6/tcp_ipv6.c b/net/ipv6/tcp_ipv6.c
index 4b5aa1854260..53b6a4192b16 100644
--- a/net/ipv6/tcp_ipv6.c
+++ b/net/ipv6/tcp_ipv6.c
@@ -941,9 +941,10 @@ static int tcp_v6_gso_send_check(struct sk_buff *skb)
         return 0;
 }
 
-struct sk_buff **tcp6_gro_receive(struct sk_buff **head, struct sk_buff *skb)
+static struct sk_buff **tcp6_gro_receive(struct sk_buff **head,
+                                         struct sk_buff *skb)
 {
-        struct ipv6hdr *iph = ipv6_hdr(skb);
+        struct ipv6hdr *iph = skb_gro_network_header(skb);
 
         switch (skb->ip_summed) {
         case CHECKSUM_COMPLETE:
@@ -961,9 +962,8 @@ struct sk_buff **tcp6_gro_receive(struct sk_buff **head, struct sk_buff *skb)
 
         return tcp_gro_receive(head, skb);
 }
-EXPORT_SYMBOL(tcp6_gro_receive);
 
-int tcp6_gro_complete(struct sk_buff *skb)
+static int tcp6_gro_complete(struct sk_buff *skb)
 {
         struct ipv6hdr *iph = ipv6_hdr(skb);
         struct tcphdr *th = tcp_hdr(skb);
@@ -974,7 +974,6 @@ int tcp6_gro_complete(struct sk_buff *skb)
 
         return tcp_gro_complete(skb);
 }
-EXPORT_SYMBOL(tcp6_gro_complete);
 
 static void tcp_v6_send_response(struct sk_buff *skb, u32 seq, u32 ack, u32 win,
                                  u32 ts, struct tcp_md5sig_key *key, int rst)
@@ -982,9 +981,10 @@ static void tcp_v6_send_response(struct sk_buff *skb, u32 seq, u32 ack, u32 win,
         struct tcphdr *th = tcp_hdr(skb), *t1;
         struct sk_buff *buff;
         struct flowi fl;
-        struct net *net = dev_net(skb->dst->dev);
+        struct net *net = dev_net(skb_dst(skb)->dev);
         struct sock *ctl_sk = net->ipv6.tcp_sk;
         unsigned int tot_len = sizeof(struct tcphdr);
+        struct dst_entry *dst;
         __be32 *topt;
 
         if (ts)
@@ -1053,8 +1053,9 @@ static void tcp_v6_send_response(struct sk_buff *skb, u32 seq, u32 ack, u32 win,
          * Underlying function will use this to retrieve the network
          * namespace
          */
-        if (!ip6_dst_lookup(ctl_sk, &buff->dst, &fl)) {
-                if (xfrm_lookup(net, &buff->dst, &fl, NULL, 0) >= 0) {
+        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);
                         TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
                         if (rst)
diff --git a/net/ipv6/udp.c b/net/ipv6/udp.c
index 8905712cfbb8..fc333d854728 100644
--- a/net/ipv6/udp.c
+++ b/net/ipv6/udp.c
@@ -177,10 +177,9 @@ static struct sock *__udp6_lib_lookup_skb(struct sk_buff *skb,
 
         if (unlikely(sk = skb_steal_sock(skb)))
                 return sk;
-        else
-                return __udp6_lib_lookup(dev_net(skb->dst->dev), &iph->saddr, sport,
-                                         &iph->daddr, dport, inet6_iif(skb),
-                                         udptable);
+        return __udp6_lib_lookup(dev_net(skb_dst(skb)->dev), &iph->saddr, sport,
+                                 &iph->daddr, dport, inet6_iif(skb),
+                                 udptable);
 }
 
 /*
diff --git a/net/ipv6/xfrm6_mode_tunnel.c b/net/ipv6/xfrm6_mode_tunnel.c
index e20529b4c825..3927832227b9 100644
--- a/net/ipv6/xfrm6_mode_tunnel.c
+++ b/net/ipv6/xfrm6_mode_tunnel.c
@@ -31,7 +31,7 @@ static inline void ipip6_ecn_decapsulate(struct sk_buff *skb)
  */
 static int xfrm6_mode_tunnel_output(struct xfrm_state *x, struct sk_buff *skb)
 {
-        struct dst_entry *dst = skb->dst;
+        struct dst_entry *dst = skb_dst(skb);
         struct ipv6hdr *top_iph;
         int dsfield;
 
@@ -45,7 +45,7 @@ static int xfrm6_mode_tunnel_output(struct xfrm_state *x, struct sk_buff *skb)
 
         memcpy(top_iph->flow_lbl, XFRM_MODE_SKB_CB(skb)->flow_lbl,
                sizeof(top_iph->flow_lbl));
-        top_iph->nexthdr = xfrm_af2proto(skb->dst->ops->family);
+        top_iph->nexthdr = xfrm_af2proto(skb_dst(skb)->ops->family);
 
         dsfield = XFRM_MODE_SKB_CB(skb)->tos;
         dsfield = INET_ECN_encapsulate(dsfield, dsfield);
diff --git a/net/ipv6/xfrm6_output.c b/net/ipv6/xfrm6_output.c
index 5ee5a031bc93..c4f4eef032a3 100644
--- a/net/ipv6/xfrm6_output.c
+++ b/net/ipv6/xfrm6_output.c
@@ -30,7 +30,7 @@ EXPORT_SYMBOL(xfrm6_find_1stfragopt);
 static int xfrm6_tunnel_check_size(struct sk_buff *skb)
 {
         int mtu, ret = 0;
-        struct dst_entry *dst = skb->dst;
+        struct dst_entry *dst = skb_dst(skb);
 
         mtu = dst_mtu(dst);
         if (mtu < IPV6_MIN_MTU)
@@ -90,6 +90,6 @@ static int xfrm6_output_finish(struct sk_buff *skb)
 
 int xfrm6_output(struct sk_buff *skb)
 {
-        return NF_HOOK(PF_INET6, NF_INET_POST_ROUTING, skb, NULL, skb->dst->dev,
+        return NF_HOOK(PF_INET6, NF_INET_POST_ROUTING, skb, NULL, skb_dst(skb)->dev,
                        xfrm6_output_finish);
 }
diff --git a/net/irda/irlap_frame.c b/net/irda/irlap_frame.c
index 2562ebc1b22c..7af2e74deda8 100644
--- a/net/irda/irlap_frame.c
+++ b/net/irda/irlap_frame.c
@@ -982,17 +982,12 @@ void irlap_resend_rejected_frames(struct irlap_cb *self, int command)
 {
         struct sk_buff *tx_skb;
         struct sk_buff *skb;
-        int count;
 
         IRDA_ASSERT(self != NULL, return;);
         IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
 
-        /* Initialize variables */
-        count = skb_queue_len(&self->wx_list);
-
         /*  Resend unacknowledged frame(s) */
-        skb = skb_peek(&self->wx_list);
-        while (skb != NULL) {
+        skb_queue_walk(&self->wx_list, skb) {
                 irlap_wait_min_turn_around(self, &self->qos_tx);
 
                 /* We copy the skb to be retransmitted since we will have to
@@ -1011,21 +1006,12 @@ void irlap_resend_rejected_frames(struct irlap_cb *self, int command)
                 /*
                  *  Set poll bit on the last frame retransmitted
                  */
-                if (count-- == 1)
+                if (skb_queue_is_last(&self->wx_list, skb))
                         tx_skb->data[1] |= PF_BIT; /* Set p/f bit */
                 else
                         tx_skb->data[1] &= ~PF_BIT; /* Clear p/f bit */
 
                 irlap_send_i_frame(self, tx_skb, command);
-
-                /*
-                 *  If our skb is the last buffer in the list, then
-                 *  we are finished, if not, move to the next sk-buffer
-                 */
-                if (skb == skb_peek_tail(&self->wx_list))
-                        skb = NULL;
-                else
-                        skb = skb->next;
         }
 #if 0 /* Not yet */
         /*
diff --git a/net/irda/irnetlink.c b/net/irda/irnetlink.c
index 2f05ec1037ab..8dd7ed7e7c1f 100644
--- a/net/irda/irnetlink.c
+++ b/net/irda/irnetlink.c
@@ -87,7 +87,7 @@ static int irda_nl_get_mode(struct sk_buff *skb, struct genl_info *info)
         if (!dev)
                 return -ENODEV;
 
-        msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
+        msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
         if (!msg) {
                 dev_put(dev);
                 return -ENOMEM;
@@ -148,21 +148,8 @@ static struct genl_ops irda_nl_ops[] = {
 
 int irda_nl_register(void)
 {
-        int err, i;
-
-        err = genl_register_family(&irda_nl_family);
-        if (err)
-                return err;
-
-        for (i = 0; i < ARRAY_SIZE(irda_nl_ops); i++) {
-                err = genl_register_ops(&irda_nl_family, &irda_nl_ops[i]);
-                if (err)
-                        goto err_out;
-        }
-        return 0;
- err_out:
-        genl_unregister_family(&irda_nl_family);
-        return err;
+        return genl_register_family_with_ops(&irda_nl_family,
+                irda_nl_ops, ARRAY_SIZE(irda_nl_ops));
 }
 
 void irda_nl_unregister(void)
diff --git a/net/iucv/af_iucv.c b/net/iucv/af_iucv.c
index b51c9187c347..656cbd195825 100644
--- a/net/iucv/af_iucv.c
+++ b/net/iucv/af_iucv.c
@@ -1,11 +1,12 @@
 /*
- *  linux/net/iucv/af_iucv.c
- *
  *  IUCV protocol stack for Linux on zSeries
  *
- *  Copyright 2006 IBM Corporation
+ *  Copyright IBM Corp. 2006, 2009
  *
  *  Author(s):  Jennifer Hunt <jenhunt@us.ibm.com>
+ *              Hendrik Brueckner <brueckner@linux.vnet.ibm.com>
+ *  PM functions:
+ *              Ursula Braun <ursula.braun@de.ibm.com>
  */
 
 #define KMSG_COMPONENT "af_iucv"
@@ -29,10 +30,7 @@
 #include <net/iucv/iucv.h>
 #include <net/iucv/af_iucv.h>
 
-#define CONFIG_IUCV_SOCK_DEBUG 1
-
-#define IPRMDATA 0x80
-#define VERSION "1.0"
+#define VERSION "1.1"
 
 static char iucv_userid[80];
 
@@ -44,6 +42,19 @@ static struct proto iucv_proto = {
         .obj_size       = sizeof(struct iucv_sock),
 };
 
+/* special AF_IUCV IPRM messages */
+static const u8 iprm_shutdown[8] =
+        {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
+
+#define TRGCLS_SIZE     (sizeof(((struct iucv_message *)0)->class))
+
+/* macros to set/get socket control buffer at correct offset */
+#define CB_TAG(skb)     ((skb)->cb)             /* iucv message tag */
+#define CB_TAG_LEN      (sizeof(((struct iucv_message *) 0)->tag))
+#define CB_TRGCLS(skb)  ((skb)->cb + CB_TAG_LEN) /* iucv msg target class */
+#define CB_TRGCLS_LEN   (TRGCLS_SIZE)
+
+
 static void iucv_sock_kill(struct sock *sk);
 static void iucv_sock_close(struct sock *sk);
 
@@ -54,6 +65,7 @@ static void iucv_callback_connack(struct iucv_path *, u8 ipuser[16]);
 static int iucv_callback_connreq(struct iucv_path *, u8 ipvmid[8],
                                  u8 ipuser[16]);
 static void iucv_callback_connrej(struct iucv_path *, u8 ipuser[16]);
+static void iucv_callback_shutdown(struct iucv_path *, u8 ipuser[16]);
 
 static struct iucv_sock_list iucv_sk_list = {
         .lock = __RW_LOCK_UNLOCKED(iucv_sk_list.lock),
@@ -65,7 +77,8 @@ static struct iucv_handler af_iucv_handler = {
         .path_complete    = iucv_callback_connack,
         .path_severed     = iucv_callback_connrej,
         .message_pending  = iucv_callback_rx,
-        .message_complete = iucv_callback_txdone
+        .message_complete = iucv_callback_txdone,
+        .path_quiesced    = iucv_callback_shutdown,
 };
 
 static inline void high_nmcpy(unsigned char *dst, char *src)
@@ -78,6 +91,153 @@ static inline void low_nmcpy(unsigned char *dst, char *src)
        memcpy(&dst[8], src, 8);
 }
 
+static int afiucv_pm_prepare(struct device *dev)
+{
+#ifdef CONFIG_PM_DEBUG
+        printk(KERN_WARNING "afiucv_pm_prepare\n");
+#endif
+        return 0;
+}
+
+static void afiucv_pm_complete(struct device *dev)
+{
+#ifdef CONFIG_PM_DEBUG
+        printk(KERN_WARNING "afiucv_pm_complete\n");
+#endif
+        return;
+}
+
+/**
+ * afiucv_pm_freeze() - Freeze PM callback
+ * @dev:        AFIUCV dummy device
+ *
+ * Sever all established IUCV communication pathes
+ */
+static int afiucv_pm_freeze(struct device *dev)
+{
+        struct iucv_sock *iucv;
+        struct sock *sk;
+        struct hlist_node *node;
+        int err = 0;
+
+#ifdef CONFIG_PM_DEBUG
+        printk(KERN_WARNING "afiucv_pm_freeze\n");
+#endif
+        read_lock(&iucv_sk_list.lock);
+        sk_for_each(sk, node, &iucv_sk_list.head) {
+                iucv = iucv_sk(sk);
+                skb_queue_purge(&iucv->send_skb_q);
+                skb_queue_purge(&iucv->backlog_skb_q);
+                switch (sk->sk_state) {
+                case IUCV_SEVERED:
+                case IUCV_DISCONN:
+                case IUCV_CLOSING:
+                case IUCV_CONNECTED:
+                        if (iucv->path) {
+                                err = iucv_path_sever(iucv->path, NULL);
+                                iucv_path_free(iucv->path);
+                                iucv->path = NULL;
+                        }
+                        break;
+                case IUCV_OPEN:
+                case IUCV_BOUND:
+                case IUCV_LISTEN:
+                case IUCV_CLOSED:
+                default:
+                        break;
+                }
+        }
+        read_unlock(&iucv_sk_list.lock);
+        return err;
+}
+
+/**
+ * afiucv_pm_restore_thaw() - Thaw and restore PM callback
+ * @dev:        AFIUCV dummy device
+ *
+ * socket clean up after freeze
+ */
+static int afiucv_pm_restore_thaw(struct device *dev)
+{
+        struct iucv_sock *iucv;
+        struct sock *sk;
+        struct hlist_node *node;
+
+#ifdef CONFIG_PM_DEBUG
+        printk(KERN_WARNING "afiucv_pm_restore_thaw\n");
+#endif
+        read_lock(&iucv_sk_list.lock);
+        sk_for_each(sk, node, &iucv_sk_list.head) {
+                iucv = iucv_sk(sk);
+                switch (sk->sk_state) {
+                case IUCV_CONNECTED:
+                        sk->sk_err = EPIPE;
+                        sk->sk_state = IUCV_DISCONN;
+                        sk->sk_state_change(sk);
+                        break;
+                case IUCV_DISCONN:
+                case IUCV_SEVERED:
+                case IUCV_CLOSING:
+                case IUCV_LISTEN:
+                case IUCV_BOUND:
+                case IUCV_OPEN:
+                default:
+                        break;
+                }
+        }
+        read_unlock(&iucv_sk_list.lock);
+        return 0;
+}
+
+static struct dev_pm_ops afiucv_pm_ops = {
+        .prepare = afiucv_pm_prepare,
+        .complete = afiucv_pm_complete,
+        .freeze = afiucv_pm_freeze,
+        .thaw = afiucv_pm_restore_thaw,
+        .restore = afiucv_pm_restore_thaw,
+};
+
+static struct device_driver af_iucv_driver = {
+        .owner = THIS_MODULE,
+        .name = "afiucv",
+        .bus  = &iucv_bus,
+        .pm   = &afiucv_pm_ops,
+};
+
+/* dummy device used as trigger for PM functions */
+static struct device *af_iucv_dev;
+
+/**
+ * iucv_msg_length() - Returns the length of an iucv message.
+ * @msg:        Pointer to struct iucv_message, MUST NOT be NULL
+ *
+ * The function returns the length of the specified iucv message @msg of data
+ * stored in a buffer and of data stored in the parameter list (PRMDATA).
+ *
+ * For IUCV_IPRMDATA, AF_IUCV uses the following convention to transport socket
+ * data:
+ *      PRMDATA[0..6]   socket data (max 7 bytes);
+ *      PRMDATA[7]      socket data length value (len is 0xff - PRMDATA[7])
+ *
+ * The socket data length is computed by substracting the socket data length
+ * value from 0xFF.
+ * If the socket data len is greater 7, then PRMDATA can be used for special
+ * notifications (see iucv_sock_shutdown); and further,
+ * if the socket data len is > 7, the function returns 8.
+ *
+ * Use this function to allocate socket buffers to store iucv message data.
+ */
+static inline size_t iucv_msg_length(struct iucv_message *msg)
+{
+        size_t datalen;
+
+        if (msg->flags & IUCV_IPRMDATA) {
+                datalen = 0xff - msg->rmmsg[7];
+                return (datalen < 8) ? datalen : 8;
+        }
+        return msg->length;
+}
+
 /* Timers */
 static void iucv_sock_timeout(unsigned long arg)
 {
@@ -225,6 +385,8 @@ static struct sock *iucv_sock_alloc(struct socket *sock, int proto, gfp_t prio)
         spin_lock_init(&iucv_sk(sk)->message_q.lock);
         skb_queue_head_init(&iucv_sk(sk)->backlog_skb_q);
         iucv_sk(sk)->send_tag = 0;
+        iucv_sk(sk)->flags = 0;
+        iucv_sk(sk)->msglimit = IUCV_QUEUELEN_DEFAULT;
         iucv_sk(sk)->path = NULL;
         memset(&iucv_sk(sk)->src_user_id , 0, 32);
 
@@ -248,11 +410,22 @@ static int iucv_sock_create(struct net *net, struct socket *sock, int protocol)
 {
         struct sock *sk;
 
-        if (sock->type != SOCK_STREAM)
-                return -ESOCKTNOSUPPORT;
+        if (protocol && protocol != PF_IUCV)
+                return -EPROTONOSUPPORT;
 
         sock->state = SS_UNCONNECTED;
-        sock->ops = &iucv_sock_ops;
+
+        switch (sock->type) {
+        case SOCK_STREAM:
+                sock->ops = &iucv_sock_ops;
+                break;
+        case SOCK_SEQPACKET:
+                /* currently, proto ops can handle both sk types */
+                sock->ops = &iucv_sock_ops;
+                break;
+        default:
+                return -ESOCKTNOSUPPORT;
+        }
 
         sk = iucv_sock_alloc(sock, protocol, GFP_KERNEL);
         if (!sk)
@@ -463,11 +636,9 @@ static int iucv_sock_connect(struct socket *sock, struct sockaddr *addr,
         if (sk->sk_state != IUCV_OPEN && sk->sk_state != IUCV_BOUND)
                 return -EBADFD;
 
-        if (sk->sk_type != SOCK_STREAM)
+        if (sk->sk_type != SOCK_STREAM && sk->sk_type != SOCK_SEQPACKET)
                 return -EINVAL;
 
-        iucv = iucv_sk(sk);
-
         if (sk->sk_state == IUCV_OPEN) {
                 err = iucv_sock_autobind(sk);
                 if (unlikely(err))
@@ -486,8 +657,8 @@ static int iucv_sock_connect(struct socket *sock, struct sockaddr *addr,
 
         iucv = iucv_sk(sk);
         /* Create path. */
-        iucv->path = iucv_path_alloc(IUCV_QUEUELEN_DEFAULT,
-                                     IPRMDATA, GFP_KERNEL);
+        iucv->path = iucv_path_alloc(iucv->msglimit,
+                                     IUCV_IPRMDATA, GFP_KERNEL);
         if (!iucv->path) {
                 err = -ENOMEM;
                 goto done;
@@ -521,8 +692,7 @@ static int iucv_sock_connect(struct socket *sock, struct sockaddr *addr,
         }
 
         if (sk->sk_state == IUCV_DISCONN) {
-                release_sock(sk);
-                return -ECONNREFUSED;
+                err = -ECONNREFUSED;
         }
 
         if (err) {
@@ -545,7 +715,10 @@ static int iucv_sock_listen(struct socket *sock, int backlog)
         lock_sock(sk);
 
         err = -EINVAL;
-        if (sk->sk_state != IUCV_BOUND || sock->type != SOCK_STREAM)
+        if (sk->sk_state != IUCV_BOUND)
+                goto done;
+
+        if (sock->type != SOCK_STREAM && sock->type != SOCK_SEQPACKET)
                 goto done;
 
         sk->sk_max_ack_backlog = backlog;
@@ -636,6 +809,30 @@ static int iucv_sock_getname(struct socket *sock, struct sockaddr *addr,
         return 0;
 }
 
+/**
+ * iucv_send_iprm() - Send socket data in parameter list of an iucv message.
+ * @path:       IUCV path
+ * @msg:        Pointer to a struct iucv_message
+ * @skb:        The socket data to send, skb->len MUST BE <= 7
+ *
+ * Send the socket data in the parameter list in the iucv message
+ * (IUCV_IPRMDATA). The socket data is stored at index 0 to 6 in the parameter
+ * list and the socket data len at index 7 (last byte).
+ * See also iucv_msg_length().
+ *
+ * Returns the error code from the iucv_message_send() call.
+ */
+static int iucv_send_iprm(struct iucv_path *path, struct iucv_message *msg,
+                          struct sk_buff *skb)
+{
+        u8 prmdata[8];
+
+        memcpy(prmdata, (void *) skb->data, skb->len);
+        prmdata[7] = 0xff - (u8) skb->len;
+        return iucv_message_send(path, msg, IUCV_IPRMDATA, 0,
+                                 (void *) prmdata, 8);
+}
+
 static int iucv_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
                              struct msghdr *msg, size_t len)
 {
@@ -643,6 +840,8 @@ static int iucv_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
         struct iucv_sock *iucv = iucv_sk(sk);
         struct sk_buff *skb;
         struct iucv_message txmsg;
+        struct cmsghdr *cmsg;
+        int cmsg_done;
         char user_id[9];
         char appl_id[9];
         int err;
@@ -654,6 +853,10 @@ static int iucv_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
         if (msg->msg_flags & MSG_OOB)
                 return -EOPNOTSUPP;
 
+        /* SOCK_SEQPACKET: we do not support segmented records */
+        if (sk->sk_type == SOCK_SEQPACKET && !(msg->msg_flags & MSG_EOR))
+                return -EOPNOTSUPP;
+
         lock_sock(sk);
 
         if (sk->sk_shutdown & SEND_SHUTDOWN) {
@@ -662,6 +865,52 @@ static int iucv_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
         }
 
         if (sk->sk_state == IUCV_CONNECTED) {
+                /* initialize defaults */
+                cmsg_done   = 0;        /* check for duplicate headers */
+                txmsg.class = 0;
+
+                /* iterate over control messages */
+                for (cmsg = CMSG_FIRSTHDR(msg); cmsg;
+                     cmsg = CMSG_NXTHDR(msg, cmsg)) {
+
+                        if (!CMSG_OK(msg, cmsg)) {
+                                err = -EINVAL;
+                                goto out;
+                        }
+
+                        if (cmsg->cmsg_level != SOL_IUCV)
+                                continue;
+
+                        if (cmsg->cmsg_type & cmsg_done) {
+                                err = -EINVAL;
+                                goto out;
+                        }
+                        cmsg_done |= cmsg->cmsg_type;
+
+                        switch (cmsg->cmsg_type) {
+                        case SCM_IUCV_TRGCLS:
+                                if (cmsg->cmsg_len != CMSG_LEN(TRGCLS_SIZE)) {
+                                        err = -EINVAL;
+                                        goto out;
+                                }
+
+                                /* set iucv message target class */
+                                memcpy(&txmsg.class,
+                                        (void *) CMSG_DATA(cmsg), TRGCLS_SIZE);
+
+                                break;
+
+                        default:
+                                err = -EINVAL;
+                                goto out;
+                                break;
+                        }
+                }
+
+                /* allocate one skb for each iucv message:
+                 * this is fine for SOCK_SEQPACKET (unless we want to support
+                 * segmented records using the MSG_EOR flag), but
+                 * for SOCK_STREAM we might want to improve it in future */
                 if (!(skb = sock_alloc_send_skb(sk, len,
                                                 msg->msg_flags & MSG_DONTWAIT,
                                                 &err)))
@@ -672,13 +921,33 @@ static int iucv_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
                         goto fail;
                 }
 
-                txmsg.class = 0;
-                memcpy(&txmsg.class, skb->data, skb->len >= 4 ? 4 : skb->len);
+                /* increment and save iucv message tag for msg_completion cbk */
                 txmsg.tag = iucv->send_tag++;
-                memcpy(skb->cb, &txmsg.tag, 4);
+                memcpy(CB_TAG(skb), &txmsg.tag, CB_TAG_LEN);
                 skb_queue_tail(&iucv->send_skb_q, skb);
-                err = iucv_message_send(iucv->path, &txmsg, 0, 0,
-                                        (void *) skb->data, skb->len);
+
+                if (((iucv->path->flags & IUCV_IPRMDATA) & iucv->flags)
+                    && skb->len <= 7) {
+                        err = iucv_send_iprm(iucv->path, &txmsg, skb);
+
+                        /* on success: there is no message_complete callback
+                         * for an IPRMDATA msg; remove skb from send queue */
+                        if (err == 0) {
+                                skb_unlink(skb, &iucv->send_skb_q);
+                                kfree_skb(skb);
+                        }
+
+                        /* this error should never happen since the
+                         * IUCV_IPRMDATA path flag is set... sever path */
+                        if (err == 0x15) {
+                                iucv_path_sever(iucv->path, NULL);
+                                skb_unlink(skb, &iucv->send_skb_q);
+                                err = -EPIPE;
+                                goto fail;
+                        }
+                } else
+                        err = iucv_message_send(iucv->path, &txmsg, 0, 0,
+                                                (void *) skb->data, skb->len);
                 if (err) {
                         if (err == 3) {
                                 user_id[8] = 0;
@@ -725,6 +994,10 @@ static int iucv_fragment_skb(struct sock *sk, struct sk_buff *skb, int len)
                 if (!nskb)
                         return -ENOMEM;
 
+                /* copy target class to control buffer of new skb */
+                memcpy(CB_TRGCLS(nskb), CB_TRGCLS(skb), CB_TRGCLS_LEN);
+
+                /* copy data fragment */
                 memcpy(nskb->data, skb->data + copied, size);
                 copied += size;
                 dataleft -= size;
@@ -744,19 +1017,33 @@ static void iucv_process_message(struct sock *sk, struct sk_buff *skb,
                                  struct iucv_message *msg)
 {
         int rc;
+        unsigned int len;
+
+        len = iucv_msg_length(msg);
+
+        /* store msg target class in the second 4 bytes of skb ctrl buffer */
+        /* Note: the first 4 bytes are reserved for msg tag */
+        memcpy(CB_TRGCLS(skb), &msg->class, CB_TRGCLS_LEN);
 
-        if (msg->flags & IPRMDATA) {
-                skb->data = NULL;
-                skb->len = 0;
+        /* check for special IPRM messages (e.g. iucv_sock_shutdown) */
+        if ((msg->flags & IUCV_IPRMDATA) && len > 7) {
+                if (memcmp(msg->rmmsg, iprm_shutdown, 8) == 0) {
+                        skb->data = NULL;
+                        skb->len = 0;
+                }
         } else {
-                rc = iucv_message_receive(path, msg, 0, skb->data,
-                                          msg->length, NULL);
+                rc = iucv_message_receive(path, msg, msg->flags & IUCV_IPRMDATA,
+                                          skb->data, len, NULL);
                 if (rc) {
                         kfree_skb(skb);
                         return;
                 }
-                if (skb->truesize >= sk->sk_rcvbuf / 4) {
-                        rc = iucv_fragment_skb(sk, skb, msg->length);
+                /* we need to fragment iucv messages for SOCK_STREAM only;
+                 * for SOCK_SEQPACKET, it is only relevant if we support
+                 * record segmentation using MSG_EOR (see also recvmsg()) */
+                if (sk->sk_type == SOCK_STREAM &&
+                    skb->truesize >= sk->sk_rcvbuf / 4) {
+                        rc = iucv_fragment_skb(sk, skb, len);
                         kfree_skb(skb);
                         skb = NULL;
                         if (rc) {
@@ -767,7 +1054,7 @@ static void iucv_process_message(struct sock *sk, struct sk_buff *skb,
                 } else {
                         skb_reset_transport_header(skb);
                         skb_reset_network_header(skb);
-                        skb->len = msg->length;
+                        skb->len = len;
                 }
         }
 
@@ -782,7 +1069,7 @@ static void iucv_process_message_q(struct sock *sk)
         struct sock_msg_q *p, *n;
 
         list_for_each_entry_safe(p, n, &iucv->message_q.list, list) {
-                skb = alloc_skb(p->msg.length, GFP_ATOMIC | GFP_DMA);
+                skb = alloc_skb(iucv_msg_length(&p->msg), GFP_ATOMIC | GFP_DMA);
                 if (!skb)
                         break;
                 iucv_process_message(sk, skb, p->path, &p->msg);
@@ -799,7 +1086,7 @@ static int iucv_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
         int noblock = flags & MSG_DONTWAIT;
         struct sock *sk = sock->sk;
         struct iucv_sock *iucv = iucv_sk(sk);
-        int target, copied = 0;
+        unsigned int copied, rlen;
         struct sk_buff *skb, *rskb, *cskb;
         int err = 0;
 
@@ -812,8 +1099,6 @@ static int iucv_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
         if (flags & (MSG_OOB))
                 return -EOPNOTSUPP;
 
-        target = sock_rcvlowat(sk, flags & MSG_WAITALL, len);
-
         /* receive/dequeue next skb:
          * the function understands MSG_PEEK and, thus, does not dequeue skb */
         skb = skb_recv_datagram(sk, flags, noblock, &err);
@@ -823,25 +1108,45 @@ static int iucv_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
                 return err;
         }
 
-        copied = min_t(unsigned int, skb->len, len);
+        rlen   = skb->len;              /* real length of skb */
+        copied = min_t(unsigned int, rlen, len);
 
         cskb = skb;
         if (memcpy_toiovec(msg->msg_iov, cskb->data, copied)) {
-                skb_queue_head(&sk->sk_receive_queue, skb);
-                if (copied == 0)
-                        return -EFAULT;
-                goto done;
+                if (!(flags & MSG_PEEK))
+                        skb_queue_head(&sk->sk_receive_queue, skb);
+                return -EFAULT;
+        }
+
+        /* SOCK_SEQPACKET: set MSG_TRUNC if recv buf size is too small */
+        if (sk->sk_type == SOCK_SEQPACKET) {
+                if (copied < rlen)
+                        msg->msg_flags |= MSG_TRUNC;
+                /* each iucv message contains a complete record */
+                msg->msg_flags |= MSG_EOR;
         }
 
-        len -= copied;
+        /* create control message to store iucv msg target class:
+         * get the trgcls from the control buffer of the skb due to
+         * fragmentation of original iucv message. */
+        err = put_cmsg(msg, SOL_IUCV, SCM_IUCV_TRGCLS,
+                        CB_TRGCLS_LEN, CB_TRGCLS(skb));
+        if (err) {
+                if (!(flags & MSG_PEEK))
+                        skb_queue_head(&sk->sk_receive_queue, skb);
+                return err;
+        }
 
         /* Mark read part of skb as used */
         if (!(flags & MSG_PEEK)) {
-                skb_pull(skb, copied);
 
-                if (skb->len) {
-                        skb_queue_head(&sk->sk_receive_queue, skb);
-                        goto done;
+                /* SOCK_STREAM: re-queue skb if it contains unreceived data */
+                if (sk->sk_type == SOCK_STREAM) {
+                        skb_pull(skb, copied);
+                        if (skb->len) {
+                                skb_queue_head(&sk->sk_receive_queue, skb);
+                                goto done;
+                        }
                 }
 
                 kfree_skb(skb);
@@ -866,7 +1171,11 @@ static int iucv_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
         }
 
 done:
-        return err ? : copied;
+        /* SOCK_SEQPACKET: return real length if MSG_TRUNC is set */
+        if (sk->sk_type == SOCK_SEQPACKET && (flags & MSG_TRUNC))
+                copied = rlen;
+
+        return copied;
 }
 
 static inline unsigned int iucv_accept_poll(struct sock *parent)
@@ -928,7 +1237,6 @@ static int iucv_sock_shutdown(struct socket *sock, int how)
         struct iucv_sock *iucv = iucv_sk(sk);
         struct iucv_message txmsg;
         int err = 0;
-        u8 prmmsg[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
 
         how++;
 
@@ -953,7 +1261,7 @@ static int iucv_sock_shutdown(struct socket *sock, int how)
                 txmsg.class = 0;
                 txmsg.tag = 0;
                 err = iucv_message_send(iucv->path, &txmsg, IUCV_IPRMDATA, 0,
-                                        (void *) prmmsg, 8);
+                                        (void *) iprm_shutdown, 8);
                 if (err) {
                         switch (err) {
                         case 1:
@@ -1007,6 +1315,98 @@ static int iucv_sock_release(struct socket *sock)
         return err;
 }
 
+/* getsockopt and setsockopt */
+static int iucv_sock_setsockopt(struct socket *sock, int level, int optname,
+                                char __user *optval, int optlen)
+{
+        struct sock *sk = sock->sk;
+        struct iucv_sock *iucv = iucv_sk(sk);
+        int val;
+        int rc;
+
+        if (level != SOL_IUCV)
+                return -ENOPROTOOPT;
+
+        if (optlen < sizeof(int))
+                return -EINVAL;
+
+        if (get_user(val, (int __user *) optval))
+                return -EFAULT;
+
+        rc = 0;
+
+        lock_sock(sk);
+        switch (optname) {
+        case SO_IPRMDATA_MSG:
+                if (val)
+                        iucv->flags |= IUCV_IPRMDATA;
+                else
+                        iucv->flags &= ~IUCV_IPRMDATA;
+                break;
+        case SO_MSGLIMIT:
+                switch (sk->sk_state) {
+                case IUCV_OPEN:
+                case IUCV_BOUND:
+                        if (val < 1 || val > (u16)(~0))
+                                rc = -EINVAL;
+                        else
+                                iucv->msglimit = val;
+                        break;
+                default:
+                        rc = -EINVAL;
+                        break;
+                }
+                break;
+        default:
+                rc = -ENOPROTOOPT;
+                break;
+        }
+        release_sock(sk);
+
+        return rc;
+}
+
+static int iucv_sock_getsockopt(struct socket *sock, int level, int optname,
+                                char __user *optval, int __user *optlen)
+{
+        struct sock *sk = sock->sk;
+        struct iucv_sock *iucv = iucv_sk(sk);
+        int val, len;
+
+        if (level != SOL_IUCV)
+                return -ENOPROTOOPT;
+
+        if (get_user(len, optlen))
+                return -EFAULT;
+
+        if (len < 0)
+                return -EINVAL;
+
+        len = min_t(unsigned int, len, sizeof(int));
+
+        switch (optname) {
+        case SO_IPRMDATA_MSG:
+                val = (iucv->flags & IUCV_IPRMDATA) ? 1 : 0;
+                break;
+        case SO_MSGLIMIT:
+                lock_sock(sk);
+                val = (iucv->path != NULL) ? iucv->path->msglim /* connected */
+                                           : iucv->msglimit;    /* default */
+                release_sock(sk);
+                break;
+        default:
+                return -ENOPROTOOPT;
+        }
+
+        if (put_user(len, optlen))
+                return -EFAULT;
+        if (copy_to_user(optval, &val, len))
+                return -EFAULT;
+
+        return 0;
+}
+
+
 /* Callback wrappers - called from iucv base support */
 static int iucv_callback_connreq(struct iucv_path *path,
                                  u8 ipvmid[8], u8 ipuser[16])
@@ -1060,7 +1460,7 @@ static int iucv_callback_connreq(struct iucv_path *path,
         }
 
         /* Create the new socket */
-        nsk = iucv_sock_alloc(NULL, SOCK_STREAM, GFP_ATOMIC);
+        nsk = iucv_sock_alloc(NULL, sk->sk_type, GFP_ATOMIC);
         if (!nsk) {
                 err = iucv_path_sever(path, user_data);
                 iucv_path_free(path);
@@ -1083,7 +1483,9 @@ static int iucv_callback_connreq(struct iucv_path *path,
         memcpy(nuser_data + 8, niucv->src_name, 8);
         ASCEBC(nuser_data + 8, 8);
 
-        path->msglim = IUCV_QUEUELEN_DEFAULT;
+        /* set message limit for path based on msglimit of accepting socket */
+        niucv->msglimit = iucv->msglimit;
+        path->msglim = iucv->msglimit;
         err = iucv_path_accept(path, &af_iucv_handler, nuser_data, nsk);
         if (err) {
                 err = iucv_path_sever(path, user_data);
@@ -1131,19 +1533,17 @@ static void iucv_callback_rx(struct iucv_path *path, struct iucv_message *msg)
                 goto save_message;
 
         len = atomic_read(&sk->sk_rmem_alloc);
-        len += msg->length + sizeof(struct sk_buff);
+        len += iucv_msg_length(msg) + sizeof(struct sk_buff);
         if (len > sk->sk_rcvbuf)
                 goto save_message;
 
-        skb = alloc_skb(msg->length, GFP_ATOMIC | GFP_DMA);
+        skb = alloc_skb(iucv_msg_length(msg), GFP_ATOMIC | GFP_DMA);
         if (!skb)
                 goto save_message;
 
         iucv_process_message(sk, skb, path, msg);
         goto out_unlock;
 
-        return;
-
 save_message:
         save_msg = kzalloc(sizeof(struct sock_msg_q), GFP_ATOMIC | GFP_DMA);
         if (!save_msg)
@@ -1170,7 +1570,7 @@ static void iucv_callback_txdone(struct iucv_path *path,
                 spin_lock_irqsave(&list->lock, flags);
 
                 while (list_skb != (struct sk_buff *)list) {
-                        if (!memcmp(&msg->tag, list_skb->cb, 4)) {
+                        if (!memcmp(&msg->tag, CB_TAG(list_skb), CB_TAG_LEN)) {
                                 this = list_skb;
                                 break;
                         }
@@ -1206,6 +1606,21 @@ static void iucv_callback_connrej(struct iucv_path *path, u8 ipuser[16])
         sk->sk_state_change(sk);
 }
 
+/* called if the other communication side shuts down its RECV direction;
+ * in turn, the callback sets SEND_SHUTDOWN to disable sending of data.
+ */
+static void iucv_callback_shutdown(struct iucv_path *path, u8 ipuser[16])
+{
+        struct sock *sk = path->private;
+
+        bh_lock_sock(sk);
+        if (sk->sk_state != IUCV_CLOSED) {
+                sk->sk_shutdown |= SEND_SHUTDOWN;
+                sk->sk_state_change(sk);
+        }
+        bh_unlock_sock(sk);
+}
+
 static struct proto_ops iucv_sock_ops = {
         .family         = PF_IUCV,
         .owner          = THIS_MODULE,
@@ -1222,8 +1637,8 @@ static struct proto_ops iucv_sock_ops = {
         .mmap           = sock_no_mmap,
         .socketpair     = sock_no_socketpair,
         .shutdown       = iucv_sock_shutdown,
-        .setsockopt     = sock_no_setsockopt,
-        .getsockopt     = sock_no_getsockopt
+        .setsockopt     = iucv_sock_setsockopt,
+        .getsockopt     = iucv_sock_getsockopt,
 };
 
 static struct net_proto_family iucv_sock_family_ops = {
@@ -1258,8 +1673,30 @@ static int __init afiucv_init(void)
         err = sock_register(&iucv_sock_family_ops);
         if (err)
                 goto out_proto;
+        /* establish dummy device */
+        err = driver_register(&af_iucv_driver);
+        if (err)
+                goto out_sock;
+        af_iucv_dev = kzalloc(sizeof(struct device), GFP_KERNEL);
+        if (!af_iucv_dev) {
+                err = -ENOMEM;
+                goto out_driver;
+        }
+        dev_set_name(af_iucv_dev, "af_iucv");
+        af_iucv_dev->bus = &iucv_bus;
+        af_iucv_dev->parent = iucv_root;
+        af_iucv_dev->release = (void (*)(struct device *))kfree;
+        af_iucv_dev->driver = &af_iucv_driver;
+        err = device_register(af_iucv_dev);
+        if (err)
+                goto out_driver;
+
         return 0;
 
+out_driver:
+        driver_unregister(&af_iucv_driver);
+out_sock:
+        sock_unregister(PF_IUCV);
 out_proto:
         proto_unregister(&iucv_proto);
 out_iucv:
@@ -1270,6 +1707,8 @@ out:
 
 static void __exit afiucv_exit(void)
 {
+        device_unregister(af_iucv_dev);
+        driver_unregister(&af_iucv_driver);
         sock_unregister(PF_IUCV);
         proto_unregister(&iucv_proto);
         iucv_unregister(&af_iucv_handler, 0);
diff --git a/net/iucv/iucv.c b/net/iucv/iucv.c
index a35240f61ec3..c833481d32e3 100644
--- a/net/iucv/iucv.c
+++ b/net/iucv/iucv.c
@@ -1,7 +1,8 @@
 /*
  * IUCV base infrastructure.
  *
- * Copyright 2001, 2006 IBM Deutschland Entwicklung GmbH, IBM Corporation
+ * Copyright IBM Corp. 2001, 2009
+ *
  * Author(s):
  *    Original source:
  *      Alan Altmark (Alan_Altmark@us.ibm.com)  Sept. 2000
@@ -10,6 +11,8 @@
  *      Fritz Elfert (elfert@de.ibm.com, felfert@millenux.com)
  *    Rewritten for af_iucv:
  *      Martin Schwidefsky <schwidefsky@de.ibm.com>
+ *    PM functions:
+ *      Ursula Braun (ursula.braun@de.ibm.com)
  *
  * Documentation used:
  *    The original source
@@ -45,6 +48,7 @@
 #include <linux/err.h>
 #include <linux/device.h>
 #include <linux/cpu.h>
+#include <linux/reboot.h>
 #include <net/iucv/iucv.h>
 #include <asm/atomic.h>
 #include <asm/ebcdic.h>
@@ -75,9 +79,24 @@ static int iucv_bus_match(struct device *dev, struct device_driver *drv)
         return 0;
 }
 
+static int iucv_pm_prepare(struct device *);
+static void iucv_pm_complete(struct device *);
+static int iucv_pm_freeze(struct device *);
+static int iucv_pm_thaw(struct device *);
+static int iucv_pm_restore(struct device *);
+
+static struct dev_pm_ops iucv_pm_ops = {
+        .prepare = iucv_pm_prepare,
+        .complete = iucv_pm_complete,
+        .freeze = iucv_pm_freeze,
+        .thaw = iucv_pm_thaw,
+        .restore = iucv_pm_restore,
+};
+
 struct bus_type iucv_bus = {
         .name = "iucv",
         .match = iucv_bus_match,
+        .pm = &iucv_pm_ops,
 };
 EXPORT_SYMBOL(iucv_bus);
 
@@ -147,6 +166,7 @@ enum iucv_command_codes {
         IUCV_RESUME = 14,
         IUCV_SEVER = 15,
         IUCV_SETMASK = 16,
+        IUCV_SETCONTROLMASK = 17,
 };
 
 /*
@@ -280,6 +300,7 @@ union iucv_param {
  * Anchor for per-cpu IUCV command parameter block.
  */
 static union iucv_param *iucv_param[NR_CPUS];
+static union iucv_param *iucv_param_irq[NR_CPUS];
 
 /**
  * iucv_call_b2f0
@@ -358,11 +379,23 @@ static void iucv_allow_cpu(void *data)
          *      0x10 - Flag to allow priority message completion interrupts
          *      0x08 - Flag to allow IUCV control interrupts
          */
-        parm = iucv_param[cpu];
+        parm = iucv_param_irq[cpu];
         memset(parm, 0, sizeof(union iucv_param));
         parm->set_mask.ipmask = 0xf8;
         iucv_call_b2f0(IUCV_SETMASK, parm);
 
+        /*
+         * Enable all iucv control interrupts.
+         * ipmask contains bits for the different interrupts
+         *      0x80 - Flag to allow pending connections interrupts
+         *      0x40 - Flag to allow connection complete interrupts
+         *      0x20 - Flag to allow connection severed interrupts
+         *      0x10 - Flag to allow connection quiesced interrupts
+         *      0x08 - Flag to allow connection resumed interrupts
+         */
+        memset(parm, 0, sizeof(union iucv_param));
+        parm->set_mask.ipmask = 0xf8;
+        iucv_call_b2f0(IUCV_SETCONTROLMASK, parm);
         /* Set indication that iucv interrupts are allowed for this cpu. */
         cpu_set(cpu, iucv_irq_cpumask);
 }
@@ -379,7 +412,7 @@ static void iucv_block_cpu(void *data)
         union iucv_param *parm;
 
         /* Disable all iucv interrupts. */
-        parm = iucv_param[cpu];
+        parm = iucv_param_irq[cpu];
         memset(parm, 0, sizeof(union iucv_param));
         iucv_call_b2f0(IUCV_SETMASK, parm);
 
@@ -388,6 +421,31 @@ static void iucv_block_cpu(void *data)
 }
 
 /**
+ * iucv_block_cpu_almost
+ * @data: unused
+ *
+ * Allow connection-severed interrupts only on this cpu.
+ */
+static void iucv_block_cpu_almost(void *data)
+{
+        int cpu = smp_processor_id();
+        union iucv_param *parm;
+
+        /* Allow iucv control interrupts only */
+        parm = iucv_param_irq[cpu];
+        memset(parm, 0, sizeof(union iucv_param));
+        parm->set_mask.ipmask = 0x08;
+        iucv_call_b2f0(IUCV_SETMASK, parm);
+        /* Allow iucv-severed interrupt only */
+        memset(parm, 0, sizeof(union iucv_param));
+        parm->set_mask.ipmask = 0x20;
+        iucv_call_b2f0(IUCV_SETCONTROLMASK, parm);
+
+        /* Clear indication that iucv interrupts are allowed for this cpu. */
+        cpu_clear(cpu, iucv_irq_cpumask);
+}
+
+/**
  * iucv_declare_cpu
  * @data: unused
  *
@@ -403,7 +461,7 @@ static void iucv_declare_cpu(void *data)
                 return;
 
         /* Declare interrupt buffer. */
-        parm = iucv_param[cpu];
+        parm = iucv_param_irq[cpu];
         memset(parm, 0, sizeof(union iucv_param));
         parm->db.ipbfadr1 = virt_to_phys(iucv_irq_data[cpu]);
         rc = iucv_call_b2f0(IUCV_DECLARE_BUFFER, parm);
@@ -460,7 +518,7 @@ static void iucv_retrieve_cpu(void *data)
         iucv_block_cpu(NULL);
 
         /* Retrieve interrupt buffer. */
-        parm = iucv_param[cpu];
+        parm = iucv_param_irq[cpu];
         iucv_call_b2f0(IUCV_RETRIEVE_BUFFER, parm);
 
         /* Clear indication that an iucv buffer exists for this cpu. */
@@ -574,11 +632,22 @@ static int __cpuinit iucv_cpu_notify(struct notifier_block *self,
                         iucv_irq_data[cpu] = NULL;
                         return NOTIFY_BAD;
                 }
+                iucv_param_irq[cpu] = kmalloc_node(sizeof(union iucv_param),
+                                        GFP_KERNEL|GFP_DMA, cpu_to_node(cpu));
+                if (!iucv_param_irq[cpu]) {
+                        kfree(iucv_param[cpu]);
+                        iucv_param[cpu] = NULL;
+                        kfree(iucv_irq_data[cpu]);
+                        iucv_irq_data[cpu] = NULL;
+                        return NOTIFY_BAD;
+                }
                 break;
         case CPU_UP_CANCELED:
         case CPU_UP_CANCELED_FROZEN:
         case CPU_DEAD:
         case CPU_DEAD_FROZEN:
+                kfree(iucv_param_irq[cpu]);
+                iucv_param_irq[cpu] = NULL;
                 kfree(iucv_param[cpu]);
                 iucv_param[cpu] = NULL;
                 kfree(iucv_irq_data[cpu]);
@@ -625,7 +694,7 @@ static int iucv_sever_pathid(u16 pathid, u8 userdata[16])
 {
         union iucv_param *parm;
 
-        parm = iucv_param[smp_processor_id()];
+        parm = iucv_param_irq[smp_processor_id()];
         memset(parm, 0, sizeof(union iucv_param));
         if (userdata)
                 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));
@@ -746,6 +815,28 @@ void iucv_unregister(struct iucv_handler *handler, int smp)
 }
 EXPORT_SYMBOL(iucv_unregister);
 
+static int iucv_reboot_event(struct notifier_block *this,
+                             unsigned long event, void *ptr)
+{
+        int i, rc;
+
+        get_online_cpus();
+        on_each_cpu(iucv_block_cpu, NULL, 1);
+        preempt_disable();
+        for (i = 0; i < iucv_max_pathid; i++) {
+                if (iucv_path_table[i])
+                        rc = iucv_sever_pathid(i, NULL);
+        }
+        preempt_enable();
+        put_online_cpus();
+        iucv_disable();
+        return NOTIFY_DONE;
+}
+
+static struct notifier_block iucv_reboot_notifier = {
+        .notifier_call = iucv_reboot_event,
+};
+
 /**
  * iucv_path_accept
  * @path: address of iucv path structure
@@ -765,6 +856,10 @@ int iucv_path_accept(struct iucv_path *path, struct iucv_handler *handler,
         int rc;
 
         local_bh_disable();
+        if (!cpu_isset(smp_processor_id(), iucv_buffer_cpumask)) {
+                rc = -EIO;
+                goto out;
+        }
         /* Prepare parameter block. */
         parm = iucv_param[smp_processor_id()];
         memset(parm, 0, sizeof(union iucv_param));
@@ -780,6 +875,7 @@ int iucv_path_accept(struct iucv_path *path, struct iucv_handler *handler,
                 path->msglim = parm->ctrl.ipmsglim;
                 path->flags = parm->ctrl.ipflags1;
         }
+out:
         local_bh_enable();
         return rc;
 }
@@ -809,6 +905,10 @@ int iucv_path_connect(struct iucv_path *path, struct iucv_handler *handler,
 
         spin_lock_bh(&iucv_table_lock);
         iucv_cleanup_queue();
+        if (!cpu_isset(smp_processor_id(), iucv_buffer_cpumask)) {
+                rc = -EIO;
+                goto out;
+        }
         parm = iucv_param[smp_processor_id()];
         memset(parm, 0, sizeof(union iucv_param));
         parm->ctrl.ipmsglim = path->msglim;
@@ -843,6 +943,7 @@ int iucv_path_connect(struct iucv_path *path, struct iucv_handler *handler,
                         rc = -EIO;
                 }
         }
+out:
         spin_unlock_bh(&iucv_table_lock);
         return rc;
 }
@@ -864,12 +965,17 @@ int iucv_path_quiesce(struct iucv_path *path, u8 userdata[16])
         int rc;
 
         local_bh_disable();
+        if (!cpu_isset(smp_processor_id(), iucv_buffer_cpumask)) {
+                rc = -EIO;
+                goto out;
+        }
         parm = iucv_param[smp_processor_id()];
         memset(parm, 0, sizeof(union iucv_param));
         if (userdata)
                 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));
         parm->ctrl.ippathid = path->pathid;
         rc = iucv_call_b2f0(IUCV_QUIESCE, parm);
+out:
         local_bh_enable();
         return rc;
 }
@@ -891,12 +997,17 @@ int iucv_path_resume(struct iucv_path *path, u8 userdata[16])
         int rc;
 
         local_bh_disable();
+        if (!cpu_isset(smp_processor_id(), iucv_buffer_cpumask)) {
+                rc = -EIO;
+                goto out;
+        }
         parm = iucv_param[smp_processor_id()];
         memset(parm, 0, sizeof(union iucv_param));
         if (userdata)
                 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));
         parm->ctrl.ippathid = path->pathid;
         rc = iucv_call_b2f0(IUCV_RESUME, parm);
+out:
         local_bh_enable();
         return rc;
 }
@@ -915,15 +1026,18 @@ int iucv_path_sever(struct iucv_path *path, u8 userdata[16])
         int rc;
 
         preempt_disable();
+        if (!cpu_isset(smp_processor_id(), iucv_buffer_cpumask)) {
+                rc = -EIO;
+                goto out;
+        }
         if (iucv_active_cpu != smp_processor_id())
                 spin_lock_bh(&iucv_table_lock);
         rc = iucv_sever_pathid(path->pathid, userdata);
-        if (!rc) {
-                iucv_path_table[path->pathid] = NULL;
-                list_del_init(&path->list);
-        }
+        iucv_path_table[path->pathid] = NULL;
+        list_del_init(&path->list);
         if (iucv_active_cpu != smp_processor_id())
                 spin_unlock_bh(&iucv_table_lock);
+out:
         preempt_enable();
         return rc;
 }
@@ -946,6 +1060,10 @@ int iucv_message_purge(struct iucv_path *path, struct iucv_message *msg,
         int rc;
 
         local_bh_disable();
+        if (!cpu_isset(smp_processor_id(), iucv_buffer_cpumask)) {
+                rc = -EIO;
+                goto out;
+        }
         parm = iucv_param[smp_processor_id()];
         memset(parm, 0, sizeof(union iucv_param));
         parm->purge.ippathid = path->pathid;
@@ -957,6 +1075,7 @@ int iucv_message_purge(struct iucv_path *path, struct iucv_message *msg,
                 msg->audit = (*(u32 *) &parm->purge.ipaudit) >> 8;
                 msg->tag = parm->purge.ipmsgtag;
         }
+out:
         local_bh_enable();
         return rc;
 }
@@ -1033,6 +1152,10 @@ int __iucv_message_receive(struct iucv_path *path, struct iucv_message *msg,
         if (msg->flags & IUCV_IPRMDATA)
                 return iucv_message_receive_iprmdata(path, msg, flags,
                                                      buffer, size, residual);
+        if (!cpu_isset(smp_processor_id(), iucv_buffer_cpumask)) {
+                rc = -EIO;
+                goto out;
+        }
         parm = iucv_param[smp_processor_id()];
         memset(parm, 0, sizeof(union iucv_param));
         parm->db.ipbfadr1 = (u32)(addr_t) buffer;
@@ -1048,6 +1171,7 @@ int __iucv_message_receive(struct iucv_path *path, struct iucv_message *msg,
                 if (residual)
                         *residual = parm->db.ipbfln1f;
         }
+out:
         return rc;
 }
 EXPORT_SYMBOL(__iucv_message_receive);
@@ -1101,6 +1225,10 @@ int iucv_message_reject(struct iucv_path *path, struct iucv_message *msg)
         int rc;
 
         local_bh_disable();
+        if (!cpu_isset(smp_processor_id(), iucv_buffer_cpumask)) {
+                rc = -EIO;
+                goto out;
+        }
         parm = iucv_param[smp_processor_id()];
         memset(parm, 0, sizeof(union iucv_param));
         parm->db.ippathid = path->pathid;
@@ -1108,6 +1236,7 @@ int iucv_message_reject(struct iucv_path *path, struct iucv_message *msg)
         parm->db.iptrgcls = msg->class;
         parm->db.ipflags1 = (IUCV_IPTRGCLS | IUCV_IPFGMID | IUCV_IPFGPID);
         rc = iucv_call_b2f0(IUCV_REJECT, parm);
+out:
         local_bh_enable();
         return rc;
 }
@@ -1135,6 +1264,10 @@ int iucv_message_reply(struct iucv_path *path, struct iucv_message *msg,
         int rc;
 
         local_bh_disable();
+        if (!cpu_isset(smp_processor_id(), iucv_buffer_cpumask)) {
+                rc = -EIO;
+                goto out;
+        }
         parm = iucv_param[smp_processor_id()];
         memset(parm, 0, sizeof(union iucv_param));
         if (flags & IUCV_IPRMDATA) {
@@ -1152,6 +1285,7 @@ int iucv_message_reply(struct iucv_path *path, struct iucv_message *msg,
                 parm->db.iptrgcls = msg->class;
         }
         rc = iucv_call_b2f0(IUCV_REPLY, parm);
+out:
         local_bh_enable();
         return rc;
 }
@@ -1180,6 +1314,10 @@ int __iucv_message_send(struct iucv_path *path, struct iucv_message *msg,
         union iucv_param *parm;
         int rc;
 
+        if (!cpu_isset(smp_processor_id(), iucv_buffer_cpumask)) {
+                rc = -EIO;
+                goto out;
+        }
         parm = iucv_param[smp_processor_id()];
         memset(parm, 0, sizeof(union iucv_param));
         if (flags & IUCV_IPRMDATA) {
@@ -1202,6 +1340,7 @@ int __iucv_message_send(struct iucv_path *path, struct iucv_message *msg,
         rc = iucv_call_b2f0(IUCV_SEND, parm);
         if (!rc)
                 msg->id = parm->db.ipmsgid;
+out:
         return rc;
 }
 EXPORT_SYMBOL(__iucv_message_send);
@@ -1262,6 +1401,10 @@ int iucv_message_send2way(struct iucv_path *path, struct iucv_message *msg,
         int rc;
 
         local_bh_disable();
+        if (!cpu_isset(smp_processor_id(), iucv_buffer_cpumask)) {
+                rc = -EIO;
+                goto out;
+        }
         parm = iucv_param[smp_processor_id()];
         memset(parm, 0, sizeof(union iucv_param));
         if (flags & IUCV_IPRMDATA) {
@@ -1287,6 +1430,7 @@ int iucv_message_send2way(struct iucv_path *path, struct iucv_message *msg,
         rc = iucv_call_b2f0(IUCV_SEND, parm);
         if (!rc)
                 msg->id = parm->db.ipmsgid;
+out:
         local_bh_enable();
         return rc;
 }
@@ -1378,6 +1522,8 @@ static void iucv_path_complete(struct iucv_irq_data *data)
         struct iucv_path_complete *ipc = (void *) data;
         struct iucv_path *path = iucv_path_table[ipc->ippathid];
 
+        if (path)
+                path->flags = ipc->ipflags1;
         if (path && path->handler && path->handler->path_complete)
                 path->handler->path_complete(path, ipc->ipuser);
 }
@@ -1413,7 +1559,7 @@ static void iucv_path_severed(struct iucv_irq_data *data)
         else {
                 iucv_sever_pathid(path->pathid, NULL);
                 iucv_path_table[path->pathid] = NULL;
-                list_del_init(&path->list);
+                list_del(&path->list);
                 iucv_path_free(path);
         }
 }
@@ -1675,6 +1821,130 @@ static void iucv_external_interrupt(u16 code)
         spin_unlock(&iucv_queue_lock);
 }
 
+static int iucv_pm_prepare(struct device *dev)
+{
+        int rc = 0;
+
+#ifdef CONFIG_PM_DEBUG
+        printk(KERN_INFO "iucv_pm_prepare\n");
+#endif
+        if (dev->driver && dev->driver->pm && dev->driver->pm->prepare)
+                rc = dev->driver->pm->prepare(dev);
+        return rc;
+}
+
+static void iucv_pm_complete(struct device *dev)
+{
+#ifdef CONFIG_PM_DEBUG
+        printk(KERN_INFO "iucv_pm_complete\n");
+#endif
+        if (dev->driver && dev->driver->pm && dev->driver->pm->complete)
+                dev->driver->pm->complete(dev);
+}
+
+/**
+ * iucv_path_table_empty() - determine if iucv path table is empty
+ *
+ * Returns 0 if there are still iucv pathes defined
+ *         1 if there are no iucv pathes defined
+ */
+int iucv_path_table_empty(void)
+{
+        int i;
+
+        for (i = 0; i < iucv_max_pathid; i++) {
+                if (iucv_path_table[i])
+                        return 0;
+        }
+        return 1;
+}
+
+/**
+ * iucv_pm_freeze() - Freeze PM callback
+ * @dev:        iucv-based device
+ *
+ * disable iucv interrupts
+ * invoke callback function of the iucv-based driver
+ * shut down iucv, if no iucv-pathes are established anymore
+ */
+static int iucv_pm_freeze(struct device *dev)
+{
+        int cpu;
+        int rc = 0;
+
+#ifdef CONFIG_PM_DEBUG
+        printk(KERN_WARNING "iucv_pm_freeze\n");
+#endif
+        for_each_cpu_mask_nr(cpu, iucv_irq_cpumask)
+                smp_call_function_single(cpu, iucv_block_cpu_almost, NULL, 1);
+        if (dev->driver && dev->driver->pm && dev->driver->pm->freeze)
+                rc = dev->driver->pm->freeze(dev);
+        if (iucv_path_table_empty())
+                iucv_disable();
+        return rc;
+}
+
+/**
+ * iucv_pm_thaw() - Thaw PM callback
+ * @dev:        iucv-based device
+ *
+ * make iucv ready for use again: allocate path table, declare interrupt buffers
+ *                                and enable iucv interrupts
+ * invoke callback function of the iucv-based driver
+ */
+static int iucv_pm_thaw(struct device *dev)
+{
+        int rc = 0;
+
+#ifdef CONFIG_PM_DEBUG
+        printk(KERN_WARNING "iucv_pm_thaw\n");
+#endif
+        if (!iucv_path_table) {
+                rc = iucv_enable();
+                if (rc)
+                        goto out;
+        }
+        if (cpus_empty(iucv_irq_cpumask)) {
+                if (iucv_nonsmp_handler)
+                        /* enable interrupts on one cpu */
+                        iucv_allow_cpu(NULL);
+                else
+                        /* enable interrupts on all cpus */
+                        iucv_setmask_mp();
+        }
+        if (dev->driver && dev->driver->pm && dev->driver->pm->thaw)
+                rc = dev->driver->pm->thaw(dev);
+out:
+        return rc;
+}
+
+/**
+ * iucv_pm_restore() - Restore PM callback
+ * @dev:        iucv-based device
+ *
+ * make iucv ready for use again: allocate path table, declare interrupt buffers
+ *                                and enable iucv interrupts
+ * invoke callback function of the iucv-based driver
+ */
+static int iucv_pm_restore(struct device *dev)
+{
+        int rc = 0;
+
+#ifdef CONFIG_PM_DEBUG
+        printk(KERN_WARNING "iucv_pm_restore %p\n", iucv_path_table);
+#endif
+        if (cpus_empty(iucv_irq_cpumask)) {
+                rc = iucv_query_maxconn();
+                rc = iucv_enable();
+                if (rc)
+                        goto out;
+        }
+        if (dev->driver && dev->driver->pm && dev->driver->pm->restore)
+                rc = dev->driver->pm->restore(dev);
+out:
+        return rc;
+}
+
 /**
  * iucv_init
  *
@@ -1717,23 +1987,37 @@ static int __init iucv_init(void)
                         rc = -ENOMEM;
                         goto out_free;
                 }
+                iucv_param_irq[cpu] = kmalloc_node(sizeof(union iucv_param),
+                                  GFP_KERNEL|GFP_DMA, cpu_to_node(cpu));
+                if (!iucv_param_irq[cpu]) {
+                        rc = -ENOMEM;
+                        goto out_free;
+                }
+
         }
         rc = register_hotcpu_notifier(&iucv_cpu_notifier);
         if (rc)
                 goto out_free;
+        rc = register_reboot_notifier(&iucv_reboot_notifier);
+        if (rc)
+                goto out_cpu;
         ASCEBC(iucv_error_no_listener, 16);
         ASCEBC(iucv_error_no_memory, 16);
         ASCEBC(iucv_error_pathid, 16);
         iucv_available = 1;
         rc = bus_register(&iucv_bus);
         if (rc)
-                goto out_cpu;
+                goto out_reboot;
         return 0;
 
+out_reboot:
+        unregister_reboot_notifier(&iucv_reboot_notifier);
 out_cpu:
         unregister_hotcpu_notifier(&iucv_cpu_notifier);
 out_free:
         for_each_possible_cpu(cpu) {
+                kfree(iucv_param_irq[cpu]);
+                iucv_param_irq[cpu] = NULL;
                 kfree(iucv_param[cpu]);
                 iucv_param[cpu] = NULL;
                 kfree(iucv_irq_data[cpu]);
@@ -1762,8 +2046,11 @@ static void __exit iucv_exit(void)
         list_for_each_entry_safe(p, n, &iucv_work_queue, list)
                 kfree(p);
         spin_unlock_irq(&iucv_queue_lock);
+        unregister_reboot_notifier(&iucv_reboot_notifier);
         unregister_hotcpu_notifier(&iucv_cpu_notifier);
         for_each_possible_cpu(cpu) {
+                kfree(iucv_param_irq[cpu]);
+                iucv_param_irq[cpu] = NULL;
                 kfree(iucv_param[cpu]);
                 iucv_param[cpu] = NULL;
                 kfree(iucv_irq_data[cpu]);
diff --git a/net/llc/af_llc.c b/net/llc/af_llc.c
index febae702685c..9208cf5f2bd5 100644
--- a/net/llc/af_llc.c
+++ b/net/llc/af_llc.c
@@ -935,7 +935,7 @@ static int llc_ui_getname(struct socket *sock, struct sockaddr *uaddr,
 
                 if (llc->dev) {
                         sllc.sllc_arphrd = llc->dev->type;
-                        memcpy(&sllc.sllc_mac, &llc->dev->dev_addr,
+                        memcpy(&sllc.sllc_mac, llc->dev->dev_addr,
                                IFHWADDRLEN);
                 }
         }
diff --git a/net/llc/llc_conn.c b/net/llc/llc_conn.c
index 3477624a4906..c6bab39b018e 100644
--- a/net/llc/llc_conn.c
+++ b/net/llc/llc_conn.c
@@ -79,10 +79,6 @@ int llc_conn_state_process(struct sock *sk, struct sk_buff *skb)
 
         if (unlikely(!ev->ind_prim && !ev->cfm_prim)) {
                 /* indicate or confirm not required */
-                /* XXX this is not very pretty, perhaps we should store
-                 * XXX indicate/confirm-needed state in the llc_conn_state_ev
-                 * XXX control block of the SKB instead? -DaveM
-                 */
                 if (!skb->next)
                         goto out_kfree_skb;
                 goto out_skb_put;
diff --git a/net/mac80211/Kconfig b/net/mac80211/Kconfig
index ecc3faf9f11a..ba2643a43c73 100644
--- a/net/mac80211/Kconfig
+++ b/net/mac80211/Kconfig
@@ -1,16 +1,35 @@
 config MAC80211
         tristate "Generic IEEE 802.11 Networking Stack (mac80211)"
+        depends on CFG80211
         select CRYPTO
         select CRYPTO_ECB
         select CRYPTO_ARC4
         select CRYPTO_AES
         select CRC32
         select WIRELESS_EXT
-        select CFG80211
         ---help---
           This option enables the hardware independent IEEE 802.11
           networking stack.
 
+comment "CFG80211 needs to be enabled for MAC80211"
+        depends on CFG80211=n
+
+config MAC80211_DEFAULT_PS
+        bool "enable powersave by default"
+        depends on MAC80211
+        default y
+        help
+          This option enables powersave mode by default.
+
+          If this causes your applications to misbehave you should fix your
+          applications instead -- they need to register their network
+          latency requirement, see Documentation/power/pm_qos_interface.txt.
+
+config MAC80211_DEFAULT_PS_VALUE
+        int
+        default 1 if MAC80211_DEFAULT_PS
+        default 0
+
 menu "Rate control algorithm selection"
         depends on MAC80211 != n
 
diff --git a/net/mac80211/agg-rx.c b/net/mac80211/agg-rx.c
index 07656d830bc4..bc064d7933ff 100644
--- a/net/mac80211/agg-rx.c
+++ b/net/mac80211/agg-rx.c
@@ -16,12 +16,12 @@
 #include <linux/ieee80211.h>
 #include <net/mac80211.h>
 #include "ieee80211_i.h"
+#include "driver-ops.h"
 
 void __ieee80211_stop_rx_ba_session(struct sta_info *sta, u16 tid,
                                     u16 initiator, u16 reason)
 {
         struct ieee80211_local *local = sta->local;
-        struct ieee80211_hw *hw = &local->hw;
         int i;
 
         /* check if TID is in operational state */
@@ -41,8 +41,8 @@ void __ieee80211_stop_rx_ba_session(struct sta_info *sta, u16 tid,
                sta->sta.addr, tid);
 #endif /* CONFIG_MAC80211_HT_DEBUG */
 
-        if (local->ops->ampdu_action(hw, IEEE80211_AMPDU_RX_STOP,
-                                     &sta->sta, tid, NULL))
+        if (drv_ampdu_action(local, IEEE80211_AMPDU_RX_STOP,
+                             &sta->sta, tid, NULL))
                 printk(KERN_DEBUG "HW problem - can not stop rx "
                                 "aggregation for tid %d\n", tid);
 
@@ -68,6 +68,7 @@ void __ieee80211_stop_rx_ba_session(struct sta_info *sta, u16 tid,
         spin_lock_bh(&sta->lock);
         /* free resources */
         kfree(sta->ampdu_mlme.tid_rx[tid]->reorder_buf);
+        kfree(sta->ampdu_mlme.tid_rx[tid]->reorder_time);
 
         if (!sta->ampdu_mlme.tid_rx[tid]->shutdown) {
                 kfree(sta->ampdu_mlme.tid_rx[tid]);
@@ -268,19 +269,23 @@ void ieee80211_process_addba_request(struct ieee80211_local *local,
         /* prepare reordering buffer */
         tid_agg_rx->reorder_buf =
                 kcalloc(buf_size, sizeof(struct sk_buff *), GFP_ATOMIC);
-        if (!tid_agg_rx->reorder_buf) {
+        tid_agg_rx->reorder_time =
+                kcalloc(buf_size, sizeof(unsigned long), GFP_ATOMIC);
+        if (!tid_agg_rx->reorder_buf || !tid_agg_rx->reorder_time) {
 #ifdef CONFIG_MAC80211_HT_DEBUG
                 if (net_ratelimit())
                         printk(KERN_ERR "can not allocate reordering buffer "
                                "to tid %d\n", tid);
 #endif
+                kfree(tid_agg_rx->reorder_buf);
+                kfree(tid_agg_rx->reorder_time);
                 kfree(sta->ampdu_mlme.tid_rx[tid]);
+                sta->ampdu_mlme.tid_rx[tid] = NULL;
                 goto end;
         }
 
-        if (local->ops->ampdu_action)
-                ret = local->ops->ampdu_action(hw, IEEE80211_AMPDU_RX_START,
-                                               &sta->sta, tid, &start_seq_num);
+        ret = drv_ampdu_action(local, IEEE80211_AMPDU_RX_START,
+                               &sta->sta, tid, &start_seq_num);
 #ifdef CONFIG_MAC80211_HT_DEBUG
         printk(KERN_DEBUG "Rx A-MPDU request on tid %d result %d\n", tid, ret);
 #endif /* CONFIG_MAC80211_HT_DEBUG */
diff --git a/net/mac80211/agg-tx.c b/net/mac80211/agg-tx.c
index 947aaaad35d2..9e5762ad307d 100644
--- a/net/mac80211/agg-tx.c
+++ b/net/mac80211/agg-tx.c
@@ -16,6 +16,7 @@
 #include <linux/ieee80211.h>
 #include <net/mac80211.h>
 #include "ieee80211_i.h"
+#include "driver-ops.h"
 #include "wme.h"
 
 /**
@@ -131,11 +132,14 @@ static int ___ieee80211_stop_tx_ba_session(struct sta_info *sta, u16 tid,
 
         state = &sta->ampdu_mlme.tid_state_tx[tid];
 
+        if (*state == HT_AGG_STATE_OPERATIONAL)
+                sta->ampdu_mlme.addba_req_num[tid] = 0;
+
         *state = HT_AGG_STATE_REQ_STOP_BA_MSK |
                 (initiator << HT_AGG_STATE_INITIATOR_SHIFT);
 
-        ret = local->ops->ampdu_action(&local->hw, IEEE80211_AMPDU_TX_STOP,
-                                       &sta->sta, tid, NULL);
+        ret = drv_ampdu_action(local, IEEE80211_AMPDU_TX_STOP,
+                               &sta->sta, tid, NULL);
 
         /* HW shall not deny going back to legacy */
         if (WARN_ON(ret)) {
@@ -306,8 +310,8 @@ int ieee80211_start_tx_ba_session(struct ieee80211_hw *hw, u8 *ra, u16 tid)
 
         start_seq_num = sta->tid_seq[tid];
 
-        ret = local->ops->ampdu_action(hw, IEEE80211_AMPDU_TX_START,
-                                       &sta->sta, tid, &start_seq_num);
+        ret = drv_ampdu_action(local, IEEE80211_AMPDU_TX_START,
+                               &sta->sta, tid, &start_seq_num);
 
         if (ret) {
 #ifdef CONFIG_MAC80211_HT_DEBUG
@@ -336,6 +340,7 @@ int ieee80211_start_tx_ba_session(struct ieee80211_hw *hw, u8 *ra, u16 tid)
                          sta->ampdu_mlme.tid_tx[tid]->dialog_token,
                          sta->ampdu_mlme.tid_tx[tid]->ssn,
                          0x40, 5000);
+        sta->ampdu_mlme.addba_req_num[tid]++;
         /* activate the timer for the recipient's addBA response */
         sta->ampdu_mlme.tid_tx[tid]->addba_resp_timer.expires =
                                 jiffies + ADDBA_RESP_INTERVAL;
@@ -418,8 +423,8 @@ static void ieee80211_agg_tx_operational(struct ieee80211_local *local,
         ieee80211_agg_splice_finish(local, sta, tid);
         spin_unlock(&local->ampdu_lock);
 
-        local->ops->ampdu_action(&local->hw, IEEE80211_AMPDU_TX_OPERATIONAL,
-                                 &sta->sta, tid, NULL);
+        drv_ampdu_action(local, IEEE80211_AMPDU_TX_OPERATIONAL,
+                         &sta->sta, tid, NULL);
 }
 
 void ieee80211_start_tx_ba_cb(struct ieee80211_hw *hw, u8 *ra, u16 tid)
@@ -605,7 +610,6 @@ void ieee80211_stop_tx_ba_cb(struct ieee80211_hw *hw, u8 *ra, u8 tid)
 
         *state = HT_AGG_STATE_IDLE;
         /* from now on packets are no longer put onto sta->pending */
-        sta->ampdu_mlme.addba_req_num[tid] = 0;
         kfree(sta->ampdu_mlme.tid_tx[tid]);
         sta->ampdu_mlme.tid_tx[tid] = NULL;
 
@@ -688,7 +692,6 @@ void ieee80211_process_addba_resp(struct ieee80211_local *local,
 
                 sta->ampdu_mlme.addba_req_num[tid] = 0;
         } else {
-                sta->ampdu_mlme.addba_req_num[tid]++;
                 ___ieee80211_stop_tx_ba_session(sta, tid, WLAN_BACK_INITIATOR);
         }
         spin_unlock_bh(&sta->lock);
diff --git a/net/mac80211/cfg.c b/net/mac80211/cfg.c
index e677b751d468..3f47276caeb8 100644
--- a/net/mac80211/cfg.c
+++ b/net/mac80211/cfg.c
@@ -13,6 +13,7 @@
 #include <linux/rcupdate.h>
 #include <net/cfg80211.h>
 #include "ieee80211_i.h"
+#include "driver-ops.h"
 #include "cfg.h"
 #include "rate.h"
 #include "mesh.h"
@@ -111,7 +112,7 @@ static int ieee80211_change_iface(struct wiphy *wiphy, int ifindex,
 }
 
 static int ieee80211_add_key(struct wiphy *wiphy, struct net_device *dev,
-                             u8 key_idx, u8 *mac_addr,
+                             u8 key_idx, const u8 *mac_addr,
                              struct key_params *params)
 {
         struct ieee80211_sub_if_data *sdata;
@@ -140,7 +141,8 @@ static int ieee80211_add_key(struct wiphy *wiphy, struct net_device *dev,
                 return -EINVAL;
         }
 
-        key = ieee80211_key_alloc(alg, key_idx, params->key_len, params->key);
+        key = ieee80211_key_alloc(alg, key_idx, params->key_len, params->key,
+                                  params->seq_len, params->seq);
         if (!key)
                 return -ENOMEM;
 
@@ -165,7 +167,7 @@ static int ieee80211_add_key(struct wiphy *wiphy, struct net_device *dev,
 }
 
 static int ieee80211_del_key(struct wiphy *wiphy, struct net_device *dev,
-                             u8 key_idx, u8 *mac_addr)
+                             u8 key_idx, const u8 *mac_addr)
 {
         struct ieee80211_sub_if_data *sdata;
         struct sta_info *sta;
@@ -207,7 +209,7 @@ static int ieee80211_del_key(struct wiphy *wiphy, struct net_device *dev,
 }
 
 static int ieee80211_get_key(struct wiphy *wiphy, struct net_device *dev,
-                             u8 key_idx, u8 *mac_addr, void *cookie,
+                             u8 key_idx, const u8 *mac_addr, void *cookie,
                              void (*callback)(void *cookie,
                                               struct key_params *params))
 {
@@ -245,12 +247,10 @@ static int ieee80211_get_key(struct wiphy *wiphy, struct net_device *dev,
                 iv32 = key->u.tkip.tx.iv32;
                 iv16 = key->u.tkip.tx.iv16;
 
-                if (key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE &&
-                    sdata->local->ops->get_tkip_seq)
-                        sdata->local->ops->get_tkip_seq(
-                                local_to_hw(sdata->local),
-                                key->conf.hw_key_idx,
-                                &iv32, &iv16);
+                if (key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE)
+                        drv_get_tkip_seq(sdata->local,
+                                         key->conf.hw_key_idx,
+                                         &iv32, &iv16);
 
                 seq[0] = iv16 & 0xff;
                 seq[1] = (iv16 >> 8) & 0xff;
@@ -451,18 +451,11 @@ static int ieee80211_config_beacon(struct ieee80211_sub_if_data *sdata,
          * This is a kludge. beacon interval should really be part
          * of the beacon information.
          */
-        if (params->interval && (sdata->local->hw.conf.beacon_int !=
-                                 params->interval)) {
-                sdata->local->hw.conf.beacon_int = params->interval;
-                err = ieee80211_hw_config(sdata->local,
-                                        IEEE80211_CONF_CHANGE_BEACON_INTERVAL);
-                if (err < 0)
-                        return err;
-                /*
-                 * We updated some parameter so if below bails out
-                 * it's not an error.
-                 */
-                err = 0;
+        if (params->interval &&
+            (sdata->vif.bss_conf.beacon_int != params->interval)) {
+                sdata->vif.bss_conf.beacon_int = params->interval;
+                ieee80211_bss_info_change_notify(sdata,
+                                                 BSS_CHANGED_BEACON_INT);
         }
 
         /* Need to have a beacon head if we don't have one yet */
@@ -528,8 +521,9 @@ static int ieee80211_config_beacon(struct ieee80211_sub_if_data *sdata,
 
         kfree(old);
 
-        return ieee80211_if_config(sdata, IEEE80211_IFCC_BEACON |
-                                          IEEE80211_IFCC_BEACON_ENABLED);
+        ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED |
+                                                BSS_CHANGED_BEACON);
+        return 0;
 }
 
 static int ieee80211_add_beacon(struct wiphy *wiphy, struct net_device *dev,
@@ -580,7 +574,8 @@ static int ieee80211_del_beacon(struct wiphy *wiphy, struct net_device *dev)
         synchronize_rcu();
         kfree(old);
 
-        return ieee80211_if_config(sdata, IEEE80211_IFCC_BEACON_ENABLED);
+        ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED);
+        return 0;
 }
 
 /* Layer 2 Update frame (802.2 Type 1 LLC XID Update response) */
@@ -635,34 +630,45 @@ static void sta_apply_parameters(struct ieee80211_local *local,
         int i, j;
         struct ieee80211_supported_band *sband;
         struct ieee80211_sub_if_data *sdata = sta->sdata;
+        u32 mask, set;
 
         sband = local->hw.wiphy->bands[local->oper_channel->band];
 
-        /*
-         * FIXME: updating the flags is racy when this function is
-         *        called from ieee80211_change_station(), this will
-         *        be resolved in a future patch.
-         */
+        spin_lock_bh(&sta->lock);
+        mask = params->sta_flags_mask;
+        set = params->sta_flags_set;
 
-        if (params->station_flags & STATION_FLAG_CHANGED) {
-                spin_lock_bh(&sta->lock);
+        if (mask & BIT(NL80211_STA_FLAG_AUTHORIZED)) {
                 sta->flags &= ~WLAN_STA_AUTHORIZED;
-                if (params->station_flags & STATION_FLAG_AUTHORIZED)
+                if (set & BIT(NL80211_STA_FLAG_AUTHORIZED))
                         sta->flags |= WLAN_STA_AUTHORIZED;
+        }
 
+        if (mask & BIT(NL80211_STA_FLAG_SHORT_PREAMBLE)) {
                 sta->flags &= ~WLAN_STA_SHORT_PREAMBLE;
-                if (params->station_flags & STATION_FLAG_SHORT_PREAMBLE)
+                if (set & BIT(NL80211_STA_FLAG_SHORT_PREAMBLE))
                         sta->flags |= WLAN_STA_SHORT_PREAMBLE;
+        }
 
+        if (mask & BIT(NL80211_STA_FLAG_WME)) {
                 sta->flags &= ~WLAN_STA_WME;
-                if (params->station_flags & STATION_FLAG_WME)
+                if (set & BIT(NL80211_STA_FLAG_WME))
                         sta->flags |= WLAN_STA_WME;
+        }
 
+        if (mask & BIT(NL80211_STA_FLAG_MFP)) {
                 sta->flags &= ~WLAN_STA_MFP;
-                if (params->station_flags & STATION_FLAG_MFP)
+                if (set & BIT(NL80211_STA_FLAG_MFP))
                         sta->flags |= WLAN_STA_MFP;
-                spin_unlock_bh(&sta->lock);
         }
+        spin_unlock_bh(&sta->lock);
+
+        /*
+         * cfg80211 validates this (1-2007) and allows setting the AID
+         * only when creating a new station entry
+         */
+        if (params->aid)
+                sta->sta.aid = params->aid;
 
         /*
          * FIXME: updating the following information is racy when this
@@ -671,12 +677,6 @@ static void sta_apply_parameters(struct ieee80211_local *local,
          *        maybe we should just reject attemps to change it.
          */
 
-        if (params->aid) {
-                sta->sta.aid = params->aid;
-                if (sta->sta.aid > IEEE80211_MAX_AID)
-                        sta->sta.aid = 0; /* XXX: should this be an error? */
-        }
-
         if (params->listen_interval >= 0)
                 sta->listen_interval = params->listen_interval;
 
@@ -1120,10 +1120,10 @@ static int ieee80211_set_txq_params(struct wiphy *wiphy,
         p.cw_max = params->cwmax;
         p.cw_min = params->cwmin;
         p.txop = params->txop;
-        if (local->ops->conf_tx(local_to_hw(local), params->queue, &p)) {
+        if (drv_conf_tx(local, params->queue, &p)) {
                 printk(KERN_DEBUG "%s: failed to set TX queue "
-                       "parameters for queue %d\n", local->mdev->name,
-                       params->queue);
+                       "parameters for queue %d\n",
+                       wiphy_name(local->hw.wiphy), params->queue);
                 return -EINVAL;
         }
 
@@ -1167,7 +1167,8 @@ static int ieee80211_scan(struct wiphy *wiphy,
 
         if (sdata->vif.type != NL80211_IFTYPE_STATION &&
             sdata->vif.type != NL80211_IFTYPE_ADHOC &&
-            sdata->vif.type != NL80211_IFTYPE_MESH_POINT)
+            sdata->vif.type != NL80211_IFTYPE_MESH_POINT &&
+            (sdata->vif.type != NL80211_IFTYPE_AP || sdata->u.ap.beacon))
                 return -EOPNOTSUPP;
 
         return ieee80211_request_scan(sdata, req);
@@ -1255,9 +1256,22 @@ static int ieee80211_assoc(struct wiphy *wiphy, struct net_device *dev,
                 sdata->u.mgd.flags |= IEEE80211_STA_AUTO_SSID_SEL;
 
         ret = ieee80211_sta_set_extra_ie(sdata, req->ie, req->ie_len);
-        if (ret)
+        if (ret && ret != -EALREADY)
                 return ret;
 
+        if (req->use_mfp) {
+                sdata->u.mgd.mfp = IEEE80211_MFP_REQUIRED;
+                sdata->u.mgd.flags |= IEEE80211_STA_MFP_ENABLED;
+        } else {
+                sdata->u.mgd.mfp = IEEE80211_MFP_DISABLED;
+                sdata->u.mgd.flags &= ~IEEE80211_STA_MFP_ENABLED;
+        }
+
+        if (req->control_port)
+                sdata->u.mgd.flags |= IEEE80211_STA_CONTROL_PORT;
+        else
+                sdata->u.mgd.flags &= ~IEEE80211_STA_CONTROL_PORT;
+
         sdata->u.mgd.flags |= IEEE80211_STA_EXT_SME;
         sdata->u.mgd.state = IEEE80211_STA_MLME_ASSOCIATE;
         ieee80211_sta_req_auth(sdata);
@@ -1267,25 +1281,106 @@ static int ieee80211_assoc(struct wiphy *wiphy, struct net_device *dev,
 static int ieee80211_deauth(struct wiphy *wiphy, struct net_device *dev,
                             struct cfg80211_deauth_request *req)
 {
-        struct ieee80211_sub_if_data *sdata;
-
-        sdata = IEEE80211_DEV_TO_SUB_IF(dev);
+        struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 
-        /* TODO: req->ie */
+        /* TODO: req->ie, req->peer_addr */
         return ieee80211_sta_deauthenticate(sdata, req->reason_code);
 }
 
 static int ieee80211_disassoc(struct wiphy *wiphy, struct net_device *dev,
                               struct cfg80211_disassoc_request *req)
 {
-        struct ieee80211_sub_if_data *sdata;
-
-        sdata = IEEE80211_DEV_TO_SUB_IF(dev);
+        struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 
-        /* TODO: req->ie */
+        /* TODO: req->ie, req->peer_addr */
         return ieee80211_sta_disassociate(sdata, req->reason_code);
 }
 
+static int ieee80211_join_ibss(struct wiphy *wiphy, struct net_device *dev,
+                               struct cfg80211_ibss_params *params)
+{
+        struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
+
+        return ieee80211_ibss_join(sdata, params);
+}
+
+static int ieee80211_leave_ibss(struct wiphy *wiphy, struct net_device *dev)
+{
+        struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
+
+        return ieee80211_ibss_leave(sdata);
+}
+
+static int ieee80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
+{
+        struct ieee80211_local *local = wiphy_priv(wiphy);
+        int err;
+
+        if (changed & WIPHY_PARAM_RTS_THRESHOLD) {
+                err = drv_set_rts_threshold(local, wiphy->rts_threshold);
+
+                if (err)
+                        return err;
+        }
+
+        if (changed & WIPHY_PARAM_RETRY_SHORT)
+                local->hw.conf.short_frame_max_tx_count = wiphy->retry_short;
+        if (changed & WIPHY_PARAM_RETRY_LONG)
+                local->hw.conf.long_frame_max_tx_count = wiphy->retry_long;
+        if (changed &
+            (WIPHY_PARAM_RETRY_SHORT | WIPHY_PARAM_RETRY_LONG))
+                ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_RETRY_LIMITS);
+
+        return 0;
+}
+
+static int ieee80211_set_tx_power(struct wiphy *wiphy,
+                                  enum tx_power_setting type, int dbm)
+{
+        struct ieee80211_local *local = wiphy_priv(wiphy);
+        struct ieee80211_channel *chan = local->hw.conf.channel;
+        u32 changes = 0;
+
+        switch (type) {
+        case TX_POWER_AUTOMATIC:
+                local->user_power_level = -1;
+                break;
+        case TX_POWER_LIMITED:
+                if (dbm < 0)
+                        return -EINVAL;
+                local->user_power_level = dbm;
+                break;
+        case TX_POWER_FIXED:
+                if (dbm < 0)
+                        return -EINVAL;
+                /* TODO: move to cfg80211 when it knows the channel */
+                if (dbm > chan->max_power)
+                        return -EINVAL;
+                local->user_power_level = dbm;
+                break;
+        }
+
+        ieee80211_hw_config(local, changes);
+
+        return 0;
+}
+
+static int ieee80211_get_tx_power(struct wiphy *wiphy, int *dbm)
+{
+        struct ieee80211_local *local = wiphy_priv(wiphy);
+
+        *dbm = local->hw.conf.power_level;
+
+        return 0;
+}
+
+static void ieee80211_rfkill_poll(struct wiphy *wiphy)
+{
+        struct ieee80211_local *local = wiphy_priv(wiphy);
+
+        drv_rfkill_poll(local);
+}
+
 struct cfg80211_ops mac80211_config_ops = {
         .add_virtual_intf = ieee80211_add_iface,
         .del_virtual_intf = ieee80211_del_iface,
@@ -1322,4 +1417,10 @@ struct cfg80211_ops mac80211_config_ops = {
         .assoc = ieee80211_assoc,
         .deauth = ieee80211_deauth,
         .disassoc = ieee80211_disassoc,
+        .join_ibss = ieee80211_join_ibss,
+        .leave_ibss = ieee80211_leave_ibss,
+        .set_wiphy_params = ieee80211_set_wiphy_params,
+        .set_tx_power = ieee80211_set_tx_power,
+        .get_tx_power = ieee80211_get_tx_power,
+        .rfkill_poll = ieee80211_rfkill_poll,
 };
diff --git a/net/mac80211/debugfs.c b/net/mac80211/debugfs.c
index 210b9b6fecd2..11c72311f35b 100644
--- a/net/mac80211/debugfs.c
+++ b/net/mac80211/debugfs.c
@@ -10,6 +10,7 @@
 #include <linux/debugfs.h>
 #include <linux/rtnetlink.h>
 #include "ieee80211_i.h"
+#include "driver-ops.h"
 #include "rate.h"
 #include "debugfs.h"
 
@@ -51,14 +52,6 @@ static const struct file_operations name## _ops = {			\
 
 DEBUGFS_READONLY_FILE(frequency, 20, "%d",
                       local->hw.conf.channel->center_freq);
-DEBUGFS_READONLY_FILE(rts_threshold, 20, "%d",
-                      local->rts_threshold);
-DEBUGFS_READONLY_FILE(fragmentation_threshold, 20, "%d",
-                      local->fragmentation_threshold);
-DEBUGFS_READONLY_FILE(short_retry_limit, 20, "%d",
-                      local->hw.conf.short_frame_max_tx_count);
-DEBUGFS_READONLY_FILE(long_retry_limit, 20, "%d",
-                      local->hw.conf.long_frame_max_tx_count);
 DEBUGFS_READONLY_FILE(total_ps_buffered, 20, "%d",
                       local->total_ps_buffered);
 DEBUGFS_READONLY_FILE(wep_iv, 20, "%#08x",
@@ -70,11 +63,10 @@ static ssize_t tsf_read(struct file *file, char __user *user_buf,
                              size_t count, loff_t *ppos)
 {
         struct ieee80211_local *local = file->private_data;
-        u64 tsf = 0;
+        u64 tsf;
         char buf[100];
 
-        if (local->ops->get_tsf)
-                tsf = local->ops->get_tsf(local_to_hw(local));
+        tsf = drv_get_tsf(local);
 
         snprintf(buf, sizeof(buf), "0x%016llx\n", (unsigned long long) tsf);
 
@@ -97,13 +89,13 @@ static ssize_t tsf_write(struct file *file,
 
         if (strncmp(buf, "reset", 5) == 0) {
                 if (local->ops->reset_tsf) {
-                        local->ops->reset_tsf(local_to_hw(local));
+                        drv_reset_tsf(local);
                         printk(KERN_INFO "%s: debugfs reset TSF\n", wiphy_name(local->hw.wiphy));
                 }
         } else {
                 tsf = simple_strtoul(buf, NULL, 0);
                 if (local->ops->set_tsf) {
-                        local->ops->set_tsf(local_to_hw(local), tsf);
+                        drv_set_tsf(local, tsf);
                         printk(KERN_INFO "%s: debugfs set TSF to %#018llx\n", wiphy_name(local->hw.wiphy), tsf);
                 }
         }
@@ -135,6 +127,42 @@ static const struct file_operations reset_ops = {
         .open = mac80211_open_file_generic,
 };
 
+static ssize_t noack_read(struct file *file, char __user *user_buf,
+                          size_t count, loff_t *ppos)
+{
+        struct ieee80211_local *local = file->private_data;
+        int res;
+        char buf[10];
+
+        res = scnprintf(buf, sizeof(buf), "%d\n", local->wifi_wme_noack_test);
+
+        return simple_read_from_buffer(user_buf, count, ppos, buf, res);
+}
+
+static ssize_t noack_write(struct file *file,
+                           const char __user *user_buf,
+                           size_t count, loff_t *ppos)
+{
+        struct ieee80211_local *local = file->private_data;
+        char buf[10];
+        size_t len;
+
+        len = min(count, sizeof(buf) - 1);
+        if (copy_from_user(buf, user_buf, len))
+                return -EFAULT;
+        buf[len] = '\0';
+
+        local->wifi_wme_noack_test = !!simple_strtoul(buf, NULL, 0);
+
+        return count;
+}
+
+static const struct file_operations noack_ops = {
+        .read = noack_read,
+        .write = noack_write,
+        .open = mac80211_open_file_generic
+};
+
 /* statistics stuff */
 
 #define DEBUGFS_STATS_FILE(name, buflen, fmt, value...)                 \
@@ -150,14 +178,12 @@ static ssize_t format_devstat_counter(struct ieee80211_local *local,
         char buf[20];
         int res;
 
-        if (!local->ops->get_stats)
-                return -EOPNOTSUPP;
-
         rtnl_lock();
-        res = local->ops->get_stats(local_to_hw(local), &stats);
+        res = drv_get_stats(local, &stats);
         rtnl_unlock();
-        if (!res)
-                res = printvalue(&stats, buf, sizeof(buf));
+        if (res)
+                return res;
+        res = printvalue(&stats, buf, sizeof(buf));
         return simple_read_from_buffer(userbuf, count, ppos, buf, res);
 }
 
@@ -269,14 +295,11 @@ void debugfs_hw_add(struct ieee80211_local *local)
         local->debugfs.keys = debugfs_create_dir("keys", phyd);
 
         DEBUGFS_ADD(frequency);
-        DEBUGFS_ADD(rts_threshold);
-        DEBUGFS_ADD(fragmentation_threshold);
-        DEBUGFS_ADD(short_retry_limit);
-        DEBUGFS_ADD(long_retry_limit);
         DEBUGFS_ADD(total_ps_buffered);
         DEBUGFS_ADD(wep_iv);
         DEBUGFS_ADD(tsf);
         DEBUGFS_ADD_MODE(reset, 0200);
+        DEBUGFS_ADD(noack);
 
         statsd = debugfs_create_dir("statistics", phyd);
         local->debugfs.statistics = statsd;
@@ -324,14 +347,11 @@ void debugfs_hw_add(struct ieee80211_local *local)
 void debugfs_hw_del(struct ieee80211_local *local)
 {
         DEBUGFS_DEL(frequency);
-        DEBUGFS_DEL(rts_threshold);
-        DEBUGFS_DEL(fragmentation_threshold);
-        DEBUGFS_DEL(short_retry_limit);
-        DEBUGFS_DEL(long_retry_limit);
         DEBUGFS_DEL(total_ps_buffered);
         DEBUGFS_DEL(wep_iv);
         DEBUGFS_DEL(tsf);
         DEBUGFS_DEL(reset);
+        DEBUGFS_DEL(noack);
 
         DEBUGFS_STATS_DEL(transmitted_fragment_count);
         DEBUGFS_STATS_DEL(multicast_transmitted_frame_count);
diff --git a/net/mac80211/driver-ops.h b/net/mac80211/driver-ops.h
new file mode 100644
index 000000000000..b13446afd48f
--- /dev/null
+++ b/net/mac80211/driver-ops.h
@@ -0,0 +1,191 @@
+#ifndef __MAC80211_DRIVER_OPS
+#define __MAC80211_DRIVER_OPS
+
+#include <net/mac80211.h>
+#include "ieee80211_i.h"
+
+static inline int drv_tx(struct ieee80211_local *local, struct sk_buff *skb)
+{
+        return local->ops->tx(&local->hw, skb);
+}
+
+static inline int drv_start(struct ieee80211_local *local)
+{
+        return local->ops->start(&local->hw);
+}
+
+static inline void drv_stop(struct ieee80211_local *local)
+{
+        local->ops->stop(&local->hw);
+}
+
+static inline int drv_add_interface(struct ieee80211_local *local,
+                                    struct ieee80211_if_init_conf *conf)
+{
+        return local->ops->add_interface(&local->hw, conf);
+}
+
+static inline void drv_remove_interface(struct ieee80211_local *local,
+                                        struct ieee80211_if_init_conf *conf)
+{
+        local->ops->remove_interface(&local->hw, conf);
+}
+
+static inline int drv_config(struct ieee80211_local *local, u32 changed)
+{
+        return local->ops->config(&local->hw, changed);
+}
+
+static inline void drv_bss_info_changed(struct ieee80211_local *local,
+                                        struct ieee80211_vif *vif,
+                                        struct ieee80211_bss_conf *info,
+                                        u32 changed)
+{
+        if (local->ops->bss_info_changed)
+                local->ops->bss_info_changed(&local->hw, vif, info, changed);
+}
+
+static inline void drv_configure_filter(struct ieee80211_local *local,
+                                        unsigned int changed_flags,
+                                        unsigned int *total_flags,
+                                        int mc_count,
+                                        struct dev_addr_list *mc_list)
+{
+        local->ops->configure_filter(&local->hw, changed_flags, total_flags,
+                                     mc_count, mc_list);
+}
+
+static inline int drv_set_tim(struct ieee80211_local *local,
+                              struct ieee80211_sta *sta, bool set)
+{
+        if (local->ops->set_tim)
+                return local->ops->set_tim(&local->hw, sta, set);
+        return 0;
+}
+
+static inline int drv_set_key(struct ieee80211_local *local,
+                              enum set_key_cmd cmd, struct ieee80211_vif *vif,
+                              struct ieee80211_sta *sta,
+                              struct ieee80211_key_conf *key)
+{
+        return local->ops->set_key(&local->hw, cmd, vif, sta, key);
+}
+
+static inline void drv_update_tkip_key(struct ieee80211_local *local,
+                                       struct ieee80211_key_conf *conf,
+                                       const u8 *address, u32 iv32,
+                                       u16 *phase1key)
+{
+        if (local->ops->update_tkip_key)
+                local->ops->update_tkip_key(&local->hw, conf, address,
+                                            iv32, phase1key);
+}
+
+static inline int drv_hw_scan(struct ieee80211_local *local,
+                              struct cfg80211_scan_request *req)
+{
+        return local->ops->hw_scan(&local->hw, req);
+}
+
+static inline void drv_sw_scan_start(struct ieee80211_local *local)
+{
+        if (local->ops->sw_scan_start)
+                local->ops->sw_scan_start(&local->hw);
+}
+
+static inline void drv_sw_scan_complete(struct ieee80211_local *local)
+{
+        if (local->ops->sw_scan_complete)
+                local->ops->sw_scan_complete(&local->hw);
+}
+
+static inline int drv_get_stats(struct ieee80211_local *local,
+                                struct ieee80211_low_level_stats *stats)
+{
+        if (!local->ops->get_stats)
+                return -EOPNOTSUPP;
+        return local->ops->get_stats(&local->hw, stats);
+}
+
+static inline void drv_get_tkip_seq(struct ieee80211_local *local,
+                                    u8 hw_key_idx, u32 *iv32, u16 *iv16)
+{
+        if (local->ops->get_tkip_seq)
+                local->ops->get_tkip_seq(&local->hw, hw_key_idx, iv32, iv16);
+}
+
+static inline int drv_set_rts_threshold(struct ieee80211_local *local,
+                                        u32 value)
+{
+        if (local->ops->set_rts_threshold)
+                return local->ops->set_rts_threshold(&local->hw, value);
+        return 0;
+}
+
+static inline void drv_sta_notify(struct ieee80211_local *local,
+                                  struct ieee80211_vif *vif,
+                                  enum sta_notify_cmd cmd,
+                                  struct ieee80211_sta *sta)
+{
+        if (local->ops->sta_notify)
+                local->ops->sta_notify(&local->hw, vif, cmd, sta);
+}
+
+static inline int drv_conf_tx(struct ieee80211_local *local, u16 queue,
+                              const struct ieee80211_tx_queue_params *params)
+{
+        if (local->ops->conf_tx)
+                return local->ops->conf_tx(&local->hw, queue, params);
+        return -EOPNOTSUPP;
+}
+
+static inline int drv_get_tx_stats(struct ieee80211_local *local,
+                                   struct ieee80211_tx_queue_stats *stats)
+{
+        return local->ops->get_tx_stats(&local->hw, stats);
+}
+
+static inline u64 drv_get_tsf(struct ieee80211_local *local)
+{
+        if (local->ops->get_tsf)
+                return local->ops->get_tsf(&local->hw);
+        return -1ULL;
+}
+
+static inline void drv_set_tsf(struct ieee80211_local *local, u64 tsf)
+{
+        if (local->ops->set_tsf)
+                local->ops->set_tsf(&local->hw, tsf);
+}
+
+static inline void drv_reset_tsf(struct ieee80211_local *local)
+{
+        if (local->ops->reset_tsf)
+                local->ops->reset_tsf(&local->hw);
+}
+
+static inline int drv_tx_last_beacon(struct ieee80211_local *local)
+{
+        if (local->ops->tx_last_beacon)
+                return local->ops->tx_last_beacon(&local->hw);
+        return 1;
+}
+
+static inline int drv_ampdu_action(struct ieee80211_local *local,
+                                   enum ieee80211_ampdu_mlme_action action,
+                                   struct ieee80211_sta *sta, u16 tid,
+                                   u16 *ssn)
+{
+        if (local->ops->ampdu_action)
+                return local->ops->ampdu_action(&local->hw, action,
+                                                sta, tid, ssn);
+        return -EOPNOTSUPP;
+}
+
+
+static inline void drv_rfkill_poll(struct ieee80211_local *local)
+{
+        if (local->ops->rfkill_poll)
+                local->ops->rfkill_poll(&local->hw);
+}
+#endif /* __MAC80211_DRIVER_OPS */
diff --git a/net/mac80211/event.c b/net/mac80211/event.c
index 0d95561c0ee0..f288d01a6344 100644
--- a/net/mac80211/event.c
+++ b/net/mac80211/event.c
@@ -12,12 +12,12 @@
 #include "ieee80211_i.h"
 
 /*
- * indicate a failed Michael MIC to userspace; the passed packet
- * (in the variable hdr) must be long enough to extract the TKIP
- * fields like TSC
+ * Indicate a failed Michael MIC to userspace. If the caller knows the TSC of
+ * the frame that generated the MIC failure (i.e., if it was provided by the
+ * driver or is still in the frame), it should provide that information.
  */
 void mac80211_ev_michael_mic_failure(struct ieee80211_sub_if_data *sdata, int keyidx,
-                                     struct ieee80211_hdr *hdr)
+                                     struct ieee80211_hdr *hdr, const u8 *tsc)
 {
         union iwreq_data wrqu;
         char *buf = kmalloc(128, GFP_ATOMIC);
@@ -34,8 +34,9 @@ void mac80211_ev_michael_mic_failure(struct ieee80211_sub_if_data *sdata, int ke
                 kfree(buf);
         }
 
-        /*
-         * TODO: re-add support for sending MIC failure indication
-         * with all info via nl80211
-         */
+        cfg80211_michael_mic_failure(sdata->dev, hdr->addr2,
+                                     (hdr->addr1[0] & 0x01) ?
+                                     NL80211_KEYTYPE_GROUP :
+                                     NL80211_KEYTYPE_PAIRWISE,
+                                     keyidx, tsc);
 }
diff --git a/net/mac80211/ht.c b/net/mac80211/ht.c
index 4e3c72f20de7..0891bfb06996 100644
--- a/net/mac80211/ht.c
+++ b/net/mac80211/ht.c
@@ -14,7 +14,6 @@
  */
 
 #include <linux/ieee80211.h>
-#include <net/wireless.h>
 #include <net/mac80211.h>
 #include "ieee80211_i.h"
 #include "rate.h"
@@ -83,89 +82,6 @@ void ieee80211_ht_cap_ie_to_sta_ht_cap(struct ieee80211_supported_band *sband,
                 ht_cap->mcs.rx_mask[32/8] |= 1;
 }
 
-/*
- * ieee80211_enable_ht should be called only after the operating band
- * has been determined as ht configuration depends on the hw's
- * HT abilities for a specific band.
- */
-u32 ieee80211_enable_ht(struct ieee80211_sub_if_data *sdata,
-                        struct ieee80211_ht_info *hti,
-                        u16 ap_ht_cap_flags)
-{
-        struct ieee80211_local *local = sdata->local;
-        struct ieee80211_supported_band *sband;
-        struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
-        struct ieee80211_bss_ht_conf ht;
-        struct sta_info *sta;
-        u32 changed = 0;
-        bool enable_ht = true, ht_changed;
-        enum nl80211_channel_type channel_type = NL80211_CHAN_NO_HT;
-
-        sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
-
-        memset(&ht, 0, sizeof(ht));
-
-        /* HT is not supported */
-        if (!sband->ht_cap.ht_supported)
-                enable_ht = false;
-
-        /* check that channel matches the right operating channel */
-        if (local->hw.conf.channel->center_freq !=
-            ieee80211_channel_to_frequency(hti->control_chan))
-                enable_ht = false;
-
-        if (enable_ht) {
-                channel_type = NL80211_CHAN_HT20;
-
-                if (!(ap_ht_cap_flags & IEEE80211_HT_CAP_40MHZ_INTOLERANT) &&
-                    (sband->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) &&
-                    (hti->ht_param & IEEE80211_HT_PARAM_CHAN_WIDTH_ANY)) {
-                        switch(hti->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
-                        case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
-                                channel_type = NL80211_CHAN_HT40PLUS;
-                                break;
-                        case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
-                                channel_type = NL80211_CHAN_HT40MINUS;
-                                break;
-                        }
-                }
-        }
-
-        ht_changed = conf_is_ht(&local->hw.conf) != enable_ht ||
-                     channel_type != local->hw.conf.channel_type;
-
-        local->oper_channel_type = channel_type;
-
-        if (ht_changed) {
-                /* channel_type change automatically detected */
-                ieee80211_hw_config(local, 0);
-
-                rcu_read_lock();
-
-                sta = sta_info_get(local, ifmgd->bssid);
-                if (sta)
-                        rate_control_rate_update(local, sband, sta,
-                                                 IEEE80211_RC_HT_CHANGED);
-
-                rcu_read_unlock();
-
-        }
-
-        /* disable HT */
-        if (!enable_ht)
-                return 0;
-
-        ht.operation_mode = le16_to_cpu(hti->operation_mode);
-
-        /* if bss configuration changed store the new one */
-        if (memcmp(&sdata->vif.bss_conf.ht, &ht, sizeof(ht))) {
-                changed |= BSS_CHANGED_HT;
-                sdata->vif.bss_conf.ht = ht;
-        }
-
-        return changed;
-}
-
 void ieee80211_sta_tear_down_BA_sessions(struct sta_info *sta)
 {
         int i;
diff --git a/net/mac80211/ibss.c b/net/mac80211/ibss.c
index 3201e1f96365..0b30277eb366 100644
--- a/net/mac80211/ibss.c
+++ b/net/mac80211/ibss.c
@@ -22,6 +22,7 @@
 #include <asm/unaligned.h>
 
 #include "ieee80211_i.h"
+#include "driver-ops.h"
 #include "rate.h"
 
 #define IEEE80211_SCAN_INTERVAL (2 * HZ)
@@ -59,74 +60,65 @@ static void ieee80211_rx_mgmt_auth_ibss(struct ieee80211_sub_if_data *sdata,
                                     sdata->u.ibss.bssid, 0);
 }
 
-static int __ieee80211_sta_join_ibss(struct ieee80211_sub_if_data *sdata,
-                                     const u8 *bssid, const int beacon_int,
-                                     const int freq,
-                                     const size_t supp_rates_len,
-                                     const u8 *supp_rates,
-                                     const u16 capability, u64 tsf)
+static void __ieee80211_sta_join_ibss(struct ieee80211_sub_if_data *sdata,
+                                      const u8 *bssid, const int beacon_int,
+                                      struct ieee80211_channel *chan,
+                                      const u32 basic_rates,
+                                      const u16 capability, u64 tsf)
 {
         struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
         struct ieee80211_local *local = sdata->local;
-        int res = 0, rates, i, j;
+        int rates, i;
         struct sk_buff *skb;
         struct ieee80211_mgmt *mgmt;
         u8 *pos;
         struct ieee80211_supported_band *sband;
-        union iwreq_data wrqu;
+        u32 bss_change;
+        u8 supp_rates[IEEE80211_MAX_SUPP_RATES];
 
-        if (local->ops->reset_tsf) {
-                /* Reset own TSF to allow time synchronization work. */
-                local->ops->reset_tsf(local_to_hw(local));
-        }
+        /* Reset own TSF to allow time synchronization work. */
+        drv_reset_tsf(local);
 
-        if ((ifibss->flags & IEEE80211_IBSS_PREV_BSSID_SET) &&
-           memcmp(ifibss->bssid, bssid, ETH_ALEN) == 0)
-                return res;
+        skb = ifibss->skb;
+        rcu_assign_pointer(ifibss->presp, NULL);
+        synchronize_rcu();
+        skb->data = skb->head;
+        skb->len = 0;
+        skb_reset_tail_pointer(skb);
+        skb_reserve(skb, sdata->local->hw.extra_tx_headroom);
 
-        skb = dev_alloc_skb(local->hw.extra_tx_headroom + 400);
-        if (!skb) {
-                printk(KERN_DEBUG "%s: failed to allocate buffer for probe "
-                       "response\n", sdata->dev->name);
-                return -ENOMEM;
-        }
-
-        if (!(ifibss->flags & IEEE80211_IBSS_PREV_BSSID_SET)) {
-                /* Remove possible STA entries from other IBSS networks. */
-                sta_info_flush_delayed(sdata);
-        }
+        if (memcmp(ifibss->bssid, bssid, ETH_ALEN))
+                sta_info_flush(sdata->local, sdata);
 
         memcpy(ifibss->bssid, bssid, ETH_ALEN);
-        res = ieee80211_if_config(sdata, IEEE80211_IFCC_BSSID);
-        if (res)
-                return res;
-
-        local->hw.conf.beacon_int = beacon_int >= 10 ? beacon_int : 10;
 
-        sdata->drop_unencrypted = capability &
-                WLAN_CAPABILITY_PRIVACY ? 1 : 0;
+        sdata->drop_unencrypted = capability & WLAN_CAPABILITY_PRIVACY ? 1 : 0;
 
-        res = ieee80211_set_freq(sdata, freq);
+        local->oper_channel = chan;
+        local->oper_channel_type = NL80211_CHAN_NO_HT;
+        ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL);
 
-        if (res)
-                return res;
+        sband = local->hw.wiphy->bands[chan->band];
 
-        sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
+        /* build supported rates array */
+        pos = supp_rates;
+        for (i = 0; i < sband->n_bitrates; i++) {
+                int rate = sband->bitrates[i].bitrate;
+                u8 basic = 0;
+                if (basic_rates & BIT(i))
+                        basic = 0x80;
+                *pos++ = basic | (u8) (rate / 5);
+        }
 
         /* Build IBSS probe response */
-
-        skb_reserve(skb, local->hw.extra_tx_headroom);
-
-        mgmt = (struct ieee80211_mgmt *)
-                skb_put(skb, 24 + sizeof(mgmt->u.beacon));
+        mgmt = (void *) skb_put(skb, 24 + sizeof(mgmt->u.beacon));
         memset(mgmt, 0, 24 + sizeof(mgmt->u.beacon));
         mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
                                           IEEE80211_STYPE_PROBE_RESP);
         memset(mgmt->da, 0xff, ETH_ALEN);
         memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
         memcpy(mgmt->bssid, ifibss->bssid, ETH_ALEN);
-        mgmt->u.beacon.beacon_int =
-                cpu_to_le16(local->hw.conf.beacon_int);
+        mgmt->u.beacon.beacon_int = cpu_to_le16(beacon_int);
         mgmt->u.beacon.timestamp = cpu_to_le64(tsf);
         mgmt->u.beacon.capab_info = cpu_to_le16(capability);
 
@@ -135,7 +127,7 @@ static int __ieee80211_sta_join_ibss(struct ieee80211_sub_if_data *sdata,
         *pos++ = ifibss->ssid_len;
         memcpy(pos, ifibss->ssid, ifibss->ssid_len);
 
-        rates = supp_rates_len;
+        rates = sband->n_bitrates;
         if (rates > 8)
                 rates = 8;
         pos = skb_put(skb, 2 + rates);
@@ -147,7 +139,7 @@ static int __ieee80211_sta_join_ibss(struct ieee80211_sub_if_data *sdata,
                 pos = skb_put(skb, 2 + 1);
                 *pos++ = WLAN_EID_DS_PARAMS;
                 *pos++ = 1;
-                *pos++ = ieee80211_frequency_to_channel(freq);
+                *pos++ = ieee80211_frequency_to_channel(chan->center_freq);
         }
 
         pos = skb_put(skb, 2 + 2);
@@ -157,51 +149,73 @@ static int __ieee80211_sta_join_ibss(struct ieee80211_sub_if_data *sdata,
         *pos++ = 0;
         *pos++ = 0;
 
-        if (supp_rates_len > 8) {
-                rates = supp_rates_len - 8;
+        if (sband->n_bitrates > 8) {
+                rates = sband->n_bitrates - 8;
                 pos = skb_put(skb, 2 + rates);
                 *pos++ = WLAN_EID_EXT_SUPP_RATES;
                 *pos++ = rates;
                 memcpy(pos, &supp_rates[8], rates);
         }
 
-        ifibss->probe_resp = skb;
+        if (ifibss->ie_len)
+                memcpy(skb_put(skb, ifibss->ie_len),
+                       ifibss->ie, ifibss->ie_len);
 
-        ieee80211_if_config(sdata, IEEE80211_IFCC_BEACON |
-                                   IEEE80211_IFCC_BEACON_ENABLED);
+        rcu_assign_pointer(ifibss->presp, skb);
 
+        sdata->vif.bss_conf.beacon_int = beacon_int;
+        bss_change = BSS_CHANGED_BEACON_INT;
+        bss_change |= ieee80211_reset_erp_info(sdata);
+        bss_change |= BSS_CHANGED_BSSID;
+        bss_change |= BSS_CHANGED_BEACON;
+        bss_change |= BSS_CHANGED_BEACON_ENABLED;
+        ieee80211_bss_info_change_notify(sdata, bss_change);
 
-        rates = 0;
-        for (i = 0; i < supp_rates_len; i++) {
-                int bitrate = (supp_rates[i] & 0x7f) * 5;
-                for (j = 0; j < sband->n_bitrates; j++)
-                        if (sband->bitrates[j].bitrate == bitrate)
-                                rates |= BIT(j);
-        }
+        ieee80211_sta_def_wmm_params(sdata, sband->n_bitrates, supp_rates);
 
-        ieee80211_sta_def_wmm_params(sdata, supp_rates_len, supp_rates);
-
-        ifibss->flags |= IEEE80211_IBSS_PREV_BSSID_SET;
         ifibss->state = IEEE80211_IBSS_MLME_JOINED;
-        mod_timer(&ifibss->timer, jiffies + IEEE80211_IBSS_MERGE_INTERVAL);
-
-        memset(&wrqu, 0, sizeof(wrqu));
-        memcpy(wrqu.ap_addr.sa_data, bssid, ETH_ALEN);
-        wireless_send_event(sdata->dev, SIOCGIWAP, &wrqu, NULL);
+        mod_timer(&ifibss->timer,
+                  round_jiffies(jiffies + IEEE80211_IBSS_MERGE_INTERVAL));
 
-        return res;
+        cfg80211_inform_bss_frame(local->hw.wiphy, local->hw.conf.channel,
+                                  mgmt, skb->len, 0, GFP_KERNEL);
+        cfg80211_ibss_joined(sdata->dev, ifibss->bssid, GFP_KERNEL);
 }
 
-static int ieee80211_sta_join_ibss(struct ieee80211_sub_if_data *sdata,
-                                   struct ieee80211_bss *bss)
+static void ieee80211_sta_join_ibss(struct ieee80211_sub_if_data *sdata,
+                                    struct ieee80211_bss *bss)
 {
-        return __ieee80211_sta_join_ibss(sdata,
-                                         bss->cbss.bssid,
-                                         bss->cbss.beacon_interval,
-                                         bss->cbss.channel->center_freq,
-                                         bss->supp_rates_len, bss->supp_rates,
-                                         bss->cbss.capability,
-                                         bss->cbss.tsf);
+        struct ieee80211_supported_band *sband;
+        u32 basic_rates;
+        int i, j;
+        u16 beacon_int = bss->cbss.beacon_interval;
+
+        if (beacon_int < 10)
+                beacon_int = 10;
+
+        sband = sdata->local->hw.wiphy->bands[bss->cbss.channel->band];
+
+        basic_rates = 0;
+
+        for (i = 0; i < bss->supp_rates_len; i++) {
+                int rate = (bss->supp_rates[i] & 0x7f) * 5;
+                bool is_basic = !!(bss->supp_rates[i] & 0x80);
+
+                for (j = 0; j < sband->n_bitrates; j++) {
+                        if (sband->bitrates[j].bitrate == rate) {
+                                if (is_basic)
+                                        basic_rates |= BIT(j);
+                                break;
+                        }
+                }
+        }
+
+        __ieee80211_sta_join_ibss(sdata, bss->cbss.bssid,
+                                  beacon_int,
+                                  bss->cbss.channel,
+                                  basic_rates,
+                                  bss->cbss.capability,
+                                  bss->cbss.tsf);
 }
 
 static void ieee80211_rx_bss_info(struct ieee80211_sub_if_data *sdata,
@@ -277,7 +291,7 @@ static void ieee80211_rx_bss_info(struct ieee80211_sub_if_data *sdata,
                 goto put_bss;
 
         /* we use a fixed BSSID */
-        if (sdata->u.ibss.flags & IEEE80211_IBSS_BSSID_SET)
+        if (sdata->u.ibss.bssid)
                 goto put_bss;
 
         /* not an IBSS */
@@ -322,12 +336,13 @@ static void ieee80211_rx_bss_info(struct ieee80211_sub_if_data *sdata,
                                 bitrates[rx_status->rate_idx].bitrate;
 
                 rx_timestamp = rx_status->mactime + (24 * 8 * 10 / rate);
-        } else if (local && local->ops && local->ops->get_tsf)
-                /* second best option: get current TSF */
-                rx_timestamp = local->ops->get_tsf(local_to_hw(local));
-        else
-                /* can't merge without knowing the TSF */
-                rx_timestamp = -1LLU;
+        } else {
+                /*
+                 * second best option: get current TSF
+                 * (will return -1 if not supported)
+                 */
+                rx_timestamp = drv_get_tsf(local);
+        }
 
 #ifdef CONFIG_MAC80211_IBSS_DEBUG
         printk(KERN_DEBUG "RX beacon SA=%pM BSSID="
@@ -369,13 +384,14 @@ struct sta_info *ieee80211_ibss_add_sta(struct ieee80211_sub_if_data *sdata,
         struct sta_info *sta;
         int band = local->hw.conf.channel->band;
 
-        /* TODO: Could consider removing the least recently used entry and
-         * allow new one to be added. */
+        /*
+         * XXX: Consider removing the least recently used entry and
+         *      allow new one to be added.
+         */
         if (local->num_sta >= IEEE80211_IBSS_MAX_STA_ENTRIES) {
-                if (net_ratelimit()) {
-                        printk(KERN_DEBUG "%s: No room for a new IBSS STA "
-                               "entry %pM\n", sdata->dev->name, addr);
-                }
+                if (net_ratelimit())
+                        printk(KERN_DEBUG "%s: No room for a new IBSS STA entry %pM\n",
+                               sdata->dev->name, addr);
                 return NULL;
         }
 
@@ -432,41 +448,33 @@ static void ieee80211_sta_merge_ibss(struct ieee80211_sub_if_data *sdata)
 {
         struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
 
-        mod_timer(&ifibss->timer, jiffies + IEEE80211_IBSS_MERGE_INTERVAL);
+        mod_timer(&ifibss->timer,
+                  round_jiffies(jiffies + IEEE80211_IBSS_MERGE_INTERVAL));
 
         ieee80211_sta_expire(sdata, IEEE80211_IBSS_INACTIVITY_LIMIT);
+
         if (ieee80211_sta_active_ibss(sdata))
                 return;
 
-        if ((ifibss->flags & IEEE80211_IBSS_BSSID_SET) &&
-            (!(ifibss->flags & IEEE80211_IBSS_AUTO_CHANNEL_SEL)))
+        if (ifibss->fixed_channel)
                 return;
 
         printk(KERN_DEBUG "%s: No active IBSS STAs - trying to scan for other "
                "IBSS networks with same SSID (merge)\n", sdata->dev->name);
 
-        /* XXX maybe racy? */
-        if (sdata->local->scan_req)
-                return;
-
-        memcpy(sdata->local->int_scan_req.ssids[0].ssid,
-               ifibss->ssid, IEEE80211_MAX_SSID_LEN);
-        sdata->local->int_scan_req.ssids[0].ssid_len = ifibss->ssid_len;
-        ieee80211_request_scan(sdata, &sdata->local->int_scan_req);
+        ieee80211_request_internal_scan(sdata, ifibss->ssid, ifibss->ssid_len);
 }
 
-static int ieee80211_sta_create_ibss(struct ieee80211_sub_if_data *sdata)
+static void ieee80211_sta_create_ibss(struct ieee80211_sub_if_data *sdata)
 {
         struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
         struct ieee80211_local *local = sdata->local;
         struct ieee80211_supported_band *sband;
-        u8 *pos;
         u8 bssid[ETH_ALEN];
-        u8 supp_rates[IEEE80211_MAX_SUPP_RATES];
         u16 capability;
         int i;
 
-        if (ifibss->flags & IEEE80211_IBSS_BSSID_SET) {
+        if (ifibss->fixed_bssid) {
                 memcpy(bssid, ifibss->bssid, ETH_ALEN);
         } else {
                 /* Generate random, not broadcast, locally administered BSSID. Mix in
@@ -482,10 +490,7 @@ static int ieee80211_sta_create_ibss(struct ieee80211_sub_if_data *sdata)
         printk(KERN_DEBUG "%s: Creating new IBSS network, BSSID %pM\n",
                sdata->dev->name, bssid);
 
-        sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
-
-        if (local->hw.conf.beacon_int == 0)
-                local->hw.conf.beacon_int = 100;
+        sband = local->hw.wiphy->bands[ifibss->channel->band];
 
         capability = WLAN_CAPABILITY_IBSS;
 
@@ -494,29 +499,20 @@ static int ieee80211_sta_create_ibss(struct ieee80211_sub_if_data *sdata)
         else
                 sdata->drop_unencrypted = 0;
 
-        pos = supp_rates;
-        for (i = 0; i < sband->n_bitrates; i++) {
-                int rate = sband->bitrates[i].bitrate;
-                *pos++ = (u8) (rate / 5);
-        }
-
-        return __ieee80211_sta_join_ibss(sdata,
-                                         bssid, local->hw.conf.beacon_int,
-                                         local->hw.conf.channel->center_freq,
-                                         sband->n_bitrates, supp_rates,
-                                         capability, 0);
+        __ieee80211_sta_join_ibss(sdata, bssid, sdata->vif.bss_conf.beacon_int,
+                                  ifibss->channel, 3, /* first two are basic */
+                                  capability, 0);
 }
 
-static int ieee80211_sta_find_ibss(struct ieee80211_sub_if_data *sdata)
+static void ieee80211_sta_find_ibss(struct ieee80211_sub_if_data *sdata)
 {
         struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
         struct ieee80211_local *local = sdata->local;
         struct ieee80211_bss *bss;
+        struct ieee80211_channel *chan = NULL;
         const u8 *bssid = NULL;
         int active_ibss;
-
-        if (ifibss->ssid_len == 0)
-                return -EINVAL;
+        u16 capability;
 
         active_ibss = ieee80211_sta_active_ibss(sdata);
 #ifdef CONFIG_MAC80211_IBSS_DEBUG
@@ -525,14 +521,23 @@ static int ieee80211_sta_find_ibss(struct ieee80211_sub_if_data *sdata)
 #endif /* CONFIG_MAC80211_IBSS_DEBUG */
 
         if (active_ibss)
-                return 0;
+                return;
 
-        if (ifibss->flags & IEEE80211_IBSS_BSSID_SET)
+        capability = WLAN_CAPABILITY_IBSS;
+        if (sdata->default_key)
+                capability |= WLAN_CAPABILITY_PRIVACY;
+
+        if (ifibss->fixed_bssid)
                 bssid = ifibss->bssid;
-        bss = (void *)cfg80211_get_bss(local->hw.wiphy, NULL, bssid,
+        if (ifibss->fixed_channel)
+                chan = ifibss->channel;
+        if (!is_zero_ether_addr(ifibss->bssid))
+                bssid = ifibss->bssid;
+        bss = (void *)cfg80211_get_bss(local->hw.wiphy, chan, bssid,
                                        ifibss->ssid, ifibss->ssid_len,
-                                       WLAN_CAPABILITY_IBSS,
-                                       WLAN_CAPABILITY_IBSS);
+                                       WLAN_CAPABILITY_IBSS |
+                                       WLAN_CAPABILITY_PRIVACY,
+                                       capability);
 
 #ifdef CONFIG_MAC80211_IBSS_DEBUG
         if (bss)
@@ -540,18 +545,14 @@ static int ieee80211_sta_find_ibss(struct ieee80211_sub_if_data *sdata)
                        "%pM\n", bss->cbss.bssid, ifibss->bssid);
 #endif /* CONFIG_MAC80211_IBSS_DEBUG */
 
-        if (bss &&
-            (!(ifibss->flags & IEEE80211_IBSS_PREV_BSSID_SET) ||
-             memcmp(ifibss->bssid, bss->cbss.bssid, ETH_ALEN))) {
-                int ret;
-
+        if (bss && memcmp(ifibss->bssid, bss->cbss.bssid, ETH_ALEN)) {
                 printk(KERN_DEBUG "%s: Selected IBSS BSSID %pM"
                        " based on configured SSID\n",
                        sdata->dev->name, bss->cbss.bssid);
 
-                ret = ieee80211_sta_join_ibss(sdata, bss);
+                ieee80211_sta_join_ibss(sdata, bss);
                 ieee80211_rx_bss_put(local, bss);
-                return ret;
+                return;
         } else if (bss)
                 ieee80211_rx_bss_put(local, bss);
 
@@ -562,29 +563,24 @@ static int ieee80211_sta_find_ibss(struct ieee80211_sub_if_data *sdata)
         /* Selected IBSS not found in current scan results - try to scan */
         if (ifibss->state == IEEE80211_IBSS_MLME_JOINED &&
             !ieee80211_sta_active_ibss(sdata)) {
-                mod_timer(&ifibss->timer, jiffies +
-                                          IEEE80211_IBSS_MERGE_INTERVAL);
-        } else if (time_after(jiffies, local->last_scan_completed +
+                mod_timer(&ifibss->timer,
+                          round_jiffies(jiffies + IEEE80211_IBSS_MERGE_INTERVAL));
+        } else if (time_after(jiffies, ifibss->last_scan_completed +
                                         IEEE80211_SCAN_INTERVAL)) {
                 printk(KERN_DEBUG "%s: Trigger new scan to find an IBSS to "
                        "join\n", sdata->dev->name);
 
-                /* XXX maybe racy? */
-                if (local->scan_req)
-                        return -EBUSY;
-
-                memcpy(local->int_scan_req.ssids[0].ssid,
-                       ifibss->ssid, IEEE80211_MAX_SSID_LEN);
-                local->int_scan_req.ssids[0].ssid_len = ifibss->ssid_len;
-                return ieee80211_request_scan(sdata, &local->int_scan_req);
+                ieee80211_request_internal_scan(sdata, ifibss->ssid,
+                                                ifibss->ssid_len);
         } else if (ifibss->state != IEEE80211_IBSS_MLME_JOINED) {
                 int interval = IEEE80211_SCAN_INTERVAL;
 
                 if (time_after(jiffies, ifibss->ibss_join_req +
                                IEEE80211_IBSS_JOIN_TIMEOUT)) {
-                        if (!(local->oper_channel->flags &
-                                                IEEE80211_CHAN_NO_IBSS))
-                                return ieee80211_sta_create_ibss(sdata);
+                        if (!(local->oper_channel->flags & IEEE80211_CHAN_NO_IBSS)) {
+                                ieee80211_sta_create_ibss(sdata);
+                                return;
+                        }
                         printk(KERN_DEBUG "%s: IBSS not allowed on"
                                " %d MHz\n", sdata->dev->name,
                                local->hw.conf.channel->center_freq);
@@ -595,11 +591,9 @@ static int ieee80211_sta_find_ibss(struct ieee80211_sub_if_data *sdata)
                 }
 
                 ifibss->state = IEEE80211_IBSS_MLME_SEARCH;
-                mod_timer(&ifibss->timer, jiffies + interval);
-                return 0;
+                mod_timer(&ifibss->timer,
+                          round_jiffies(jiffies + interval));
         }
-
-        return 0;
 }
 
 static void ieee80211_rx_mgmt_probe_req(struct ieee80211_sub_if_data *sdata,
@@ -614,13 +608,10 @@ static void ieee80211_rx_mgmt_probe_req(struct ieee80211_sub_if_data *sdata,
         u8 *pos, *end;
 
         if (ifibss->state != IEEE80211_IBSS_MLME_JOINED ||
-            len < 24 + 2 || !ifibss->probe_resp)
+            len < 24 + 2 || !ifibss->presp)
                 return;
 
-        if (local->ops->tx_last_beacon)
-                tx_last_beacon = local->ops->tx_last_beacon(local_to_hw(local));
-        else
-                tx_last_beacon = 1;
+        tx_last_beacon = drv_tx_last_beacon(local);
 
 #ifdef CONFIG_MAC80211_IBSS_DEBUG
         printk(KERN_DEBUG "%s: RX ProbeReq SA=%pM DA=%pM BSSID=%pM"
@@ -649,13 +640,13 @@ static void ieee80211_rx_mgmt_probe_req(struct ieee80211_sub_if_data *sdata,
         }
         if (pos[1] != 0 &&
             (pos[1] != ifibss->ssid_len ||
-             memcmp(pos + 2, ifibss->ssid, ifibss->ssid_len) != 0)) {
+             !memcmp(pos + 2, ifibss->ssid, ifibss->ssid_len))) {
                 /* Ignore ProbeReq for foreign SSID */
                 return;
         }
 
         /* Reply with ProbeResp */
-        skb = skb_copy(ifibss->probe_resp, GFP_KERNEL);
+        skb = skb_copy(ifibss->presp, GFP_KERNEL);
         if (!skb)
                 return;
 
@@ -746,6 +737,9 @@ static void ieee80211_ibss_work(struct work_struct *work)
         struct ieee80211_if_ibss *ifibss;
         struct sk_buff *skb;
 
+        if (WARN_ON(local->suspended))
+                return;
+
         if (!netif_running(sdata->dev))
                 return;
 
@@ -782,101 +776,63 @@ static void ieee80211_ibss_timer(unsigned long data)
         struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
         struct ieee80211_local *local = sdata->local;
 
+        if (local->quiescing) {
+                ifibss->timer_running = true;
+                return;
+        }
+
         set_bit(IEEE80211_IBSS_REQ_RUN, &ifibss->request);
         queue_work(local->hw.workqueue, &ifibss->work);
 }
 
-void ieee80211_ibss_setup_sdata(struct ieee80211_sub_if_data *sdata)
+#ifdef CONFIG_PM
+void ieee80211_ibss_quiesce(struct ieee80211_sub_if_data *sdata)
 {
         struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
 
-        INIT_WORK(&ifibss->work, ieee80211_ibss_work);
-        setup_timer(&ifibss->timer, ieee80211_ibss_timer,
-                    (unsigned long) sdata);
-        skb_queue_head_init(&ifibss->skb_queue);
-
-        ifibss->flags |= IEEE80211_IBSS_AUTO_BSSID_SEL |
-                        IEEE80211_IBSS_AUTO_CHANNEL_SEL;
+        cancel_work_sync(&ifibss->work);
+        if (del_timer_sync(&ifibss->timer))
+                ifibss->timer_running = true;
 }
 
-int ieee80211_ibss_commit(struct ieee80211_sub_if_data *sdata)
+void ieee80211_ibss_restart(struct ieee80211_sub_if_data *sdata)
 {
         struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
 
-        ifibss->flags &= ~IEEE80211_IBSS_PREV_BSSID_SET;
-
-        if (ifibss->ssid_len)
-                ifibss->flags |= IEEE80211_IBSS_SSID_SET;
-        else
-                ifibss->flags &= ~IEEE80211_IBSS_SSID_SET;
-
-        ifibss->ibss_join_req = jiffies;
-        ifibss->state = IEEE80211_IBSS_MLME_SEARCH;
-        set_bit(IEEE80211_IBSS_REQ_RUN, &ifibss->request);
-
-        return 0;
-}
-
-int ieee80211_ibss_set_ssid(struct ieee80211_sub_if_data *sdata, char *ssid, size_t len)
-{
-        struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
-
-        if (len > IEEE80211_MAX_SSID_LEN)
-                return -EINVAL;
-
-        if (ifibss->ssid_len != len || memcmp(ifibss->ssid, ssid, len) != 0) {
-                memset(ifibss->ssid, 0, sizeof(ifibss->ssid));
-                memcpy(ifibss->ssid, ssid, len);
-                ifibss->ssid_len = len;
+        if (ifibss->timer_running) {
+                add_timer(&ifibss->timer);
+                ifibss->timer_running = false;
         }
-
-        return ieee80211_ibss_commit(sdata);
-}
-
-int ieee80211_ibss_get_ssid(struct ieee80211_sub_if_data *sdata, char *ssid, size_t *len)
-{
-        struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
-
-        memcpy(ssid, ifibss->ssid, ifibss->ssid_len);
-        *len = ifibss->ssid_len;
-
-        return 0;
 }
+#endif
 
-int ieee80211_ibss_set_bssid(struct ieee80211_sub_if_data *sdata, u8 *bssid)
+void ieee80211_ibss_setup_sdata(struct ieee80211_sub_if_data *sdata)
 {
         struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
 
-        if (is_valid_ether_addr(bssid)) {
-                memcpy(ifibss->bssid, bssid, ETH_ALEN);
-                ifibss->flags |= IEEE80211_IBSS_BSSID_SET;
-        } else {
-                memset(ifibss->bssid, 0, ETH_ALEN);
-                ifibss->flags &= ~IEEE80211_IBSS_BSSID_SET;
-        }
-
-        if (netif_running(sdata->dev)) {
-                if (ieee80211_if_config(sdata, IEEE80211_IFCC_BSSID)) {
-                        printk(KERN_DEBUG "%s: Failed to config new BSSID to "
-                               "the low-level driver\n", sdata->dev->name);
-                }
-        }
-
-        return ieee80211_ibss_commit(sdata);
+        INIT_WORK(&ifibss->work, ieee80211_ibss_work);
+        setup_timer(&ifibss->timer, ieee80211_ibss_timer,
+                    (unsigned long) sdata);
+        skb_queue_head_init(&ifibss->skb_queue);
 }
 
 /* scan finished notification */
 void ieee80211_ibss_notify_scan_completed(struct ieee80211_local *local)
 {
-        struct ieee80211_sub_if_data *sdata = local->scan_sdata;
-        struct ieee80211_if_ibss *ifibss;
-
-        if (sdata && sdata->vif.type == NL80211_IFTYPE_ADHOC) {
-                ifibss = &sdata->u.ibss;
-                if ((!(ifibss->flags & IEEE80211_IBSS_PREV_BSSID_SET)) ||
-                    !ieee80211_sta_active_ibss(sdata))
-                        ieee80211_sta_find_ibss(sdata);
+        struct ieee80211_sub_if_data *sdata;
+
+        mutex_lock(&local->iflist_mtx);
+        list_for_each_entry(sdata, &local->interfaces, list) {
+                if (!netif_running(sdata->dev))
+                        continue;
+                if (sdata->vif.type != NL80211_IFTYPE_ADHOC)
+                        continue;
+                if (!sdata->u.ibss.ssid_len)
+                        continue;
+                sdata->u.ibss.last_scan_completed = jiffies;
+                ieee80211_sta_find_ibss(sdata);
         }
+        mutex_unlock(&local->iflist_mtx);
 }
 
 ieee80211_rx_result
@@ -906,3 +862,86 @@ ieee80211_ibss_rx_mgmt(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb,
 
         return RX_DROP_MONITOR;
 }
+
+int ieee80211_ibss_join(struct ieee80211_sub_if_data *sdata,
+                        struct cfg80211_ibss_params *params)
+{
+        struct sk_buff *skb;
+
+        if (params->bssid) {
+                memcpy(sdata->u.ibss.bssid, params->bssid, ETH_ALEN);
+                sdata->u.ibss.fixed_bssid = true;
+        } else
+                sdata->u.ibss.fixed_bssid = false;
+
+        sdata->vif.bss_conf.beacon_int = params->beacon_interval;
+
+        sdata->u.ibss.channel = params->channel;
+        sdata->u.ibss.fixed_channel = params->channel_fixed;
+
+        if (params->ie) {
+                sdata->u.ibss.ie = kmemdup(params->ie, params->ie_len,
+                                           GFP_KERNEL);
+                if (sdata->u.ibss.ie)
+                        sdata->u.ibss.ie_len = params->ie_len;
+        }
+
+        skb = dev_alloc_skb(sdata->local->hw.extra_tx_headroom +
+                            36 /* bitrates */ +
+                            34 /* SSID */ +
+                            3  /* DS params */ +
+                            4  /* IBSS params */ +
+                            params->ie_len);
+        if (!skb)
+                return -ENOMEM;
+
+        sdata->u.ibss.skb = skb;
+        sdata->u.ibss.state = IEEE80211_IBSS_MLME_SEARCH;
+        sdata->u.ibss.ibss_join_req = jiffies;
+
+        memcpy(sdata->u.ibss.ssid, params->ssid, IEEE80211_MAX_SSID_LEN);
+
+        /*
+         * The ssid_len setting below is used to see whether
+         * we are active, and we need all other settings
+         * before that may get visible.
+         */
+        mb();
+
+        sdata->u.ibss.ssid_len = params->ssid_len;
+
+        ieee80211_recalc_idle(sdata->local);
+
+        set_bit(IEEE80211_IBSS_REQ_RUN, &sdata->u.ibss.request);
+        queue_work(sdata->local->hw.workqueue, &sdata->u.ibss.work);
+
+        return 0;
+}
+
+int ieee80211_ibss_leave(struct ieee80211_sub_if_data *sdata)
+{
+        struct sk_buff *skb;
+
+        del_timer_sync(&sdata->u.ibss.timer);
+        clear_bit(IEEE80211_IBSS_REQ_RUN, &sdata->u.ibss.request);
+        cancel_work_sync(&sdata->u.ibss.work);
+        clear_bit(IEEE80211_IBSS_REQ_RUN, &sdata->u.ibss.request);
+
+        sta_info_flush(sdata->local, sdata);
+
+        /* remove beacon */
+        kfree(sdata->u.ibss.ie);
+        skb = sdata->u.ibss.presp;
+        rcu_assign_pointer(sdata->u.ibss.presp, NULL);
+        ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED);
+        synchronize_rcu();
+        kfree_skb(skb);
+
+        skb_queue_purge(&sdata->u.ibss.skb_queue);
+        memset(sdata->u.ibss.bssid, 0, ETH_ALEN);
+        sdata->u.ibss.ssid_len = 0;
+
+        ieee80211_recalc_idle(sdata->local);
+
+        return 0;
+}
diff --git a/net/mac80211/ieee80211_i.h b/net/mac80211/ieee80211_i.h
index e6ed78cb16b3..4dbc28964196 100644
--- a/net/mac80211/ieee80211_i.h
+++ b/net/mac80211/ieee80211_i.h
@@ -24,7 +24,6 @@
 #include <linux/spinlock.h>
 #include <linux/etherdevice.h>
 #include <net/cfg80211.h>
-#include <net/wireless.h>
 #include <net/iw_handler.h>
 #include <net/mac80211.h>
 #include "key.h"
@@ -236,7 +235,7 @@ struct mesh_preq_queue {
 #define IEEE80211_STA_ASSOCIATED        BIT(4)
 #define IEEE80211_STA_PROBEREQ_POLL     BIT(5)
 #define IEEE80211_STA_CREATE_IBSS       BIT(6)
-/* hole at 7, please re-use */
+#define IEEE80211_STA_CONTROL_PORT      BIT(7)
 #define IEEE80211_STA_WMM_ENABLED       BIT(8)
 /* hole at 9, please re-use */
 #define IEEE80211_STA_AUTO_SSID_SEL     BIT(10)
@@ -249,9 +248,8 @@ struct mesh_preq_queue {
 #define IEEE80211_STA_EXT_SME           BIT(17)
 /* flags for MLME request */
 #define IEEE80211_STA_REQ_SCAN 0
-#define IEEE80211_STA_REQ_DIRECT_PROBE 1
-#define IEEE80211_STA_REQ_AUTH 2
-#define IEEE80211_STA_REQ_RUN  3
+#define IEEE80211_STA_REQ_AUTH 1
+#define IEEE80211_STA_REQ_RUN  2
 
 /* bitfield of allowed auth algs */
 #define IEEE80211_AUTH_ALG_OPEN BIT(0)
@@ -295,6 +293,9 @@ struct ieee80211_if_managed {
         int auth_tries; /* retries for auth req */
         int assoc_tries; /* retries for assoc req */
 
+        unsigned long timers_running; /* used for quiesce/restart */
+        bool powersave; /* powersave requested for this iface */
+
         unsigned long request;
 
         unsigned long last_probe;
@@ -306,6 +307,8 @@ struct ieee80211_if_managed {
         int auth_alg; /* currently used IEEE 802.11 authentication algorithm */
         int auth_transaction;
 
+        u32 beacon_crc;
+
         enum {
                 IEEE80211_MFP_DISABLED,
                 IEEE80211_MFP_OPTIONAL,
@@ -319,14 +322,6 @@ struct ieee80211_if_managed {
         size_t sme_auth_ie_len;
 };
 
-enum ieee80211_ibss_flags {
-        IEEE80211_IBSS_AUTO_CHANNEL_SEL         = BIT(0),
-        IEEE80211_IBSS_AUTO_BSSID_SEL           = BIT(1),
-        IEEE80211_IBSS_BSSID_SET                = BIT(2),
-        IEEE80211_IBSS_PREV_BSSID_SET           = BIT(3),
-        IEEE80211_IBSS_SSID_SET                 = BIT(4),
-};
-
 enum ieee80211_ibss_request {
         IEEE80211_IBSS_REQ_RUN  = 0,
 };
@@ -337,17 +332,23 @@ struct ieee80211_if_ibss {
 
         struct sk_buff_head skb_queue;
 
-        u8 ssid[IEEE80211_MAX_SSID_LEN];
-        u8 ssid_len;
+        unsigned long request;
+        unsigned long last_scan_completed;
 
-        u32 flags;
+        bool timer_running;
 
-        u8 bssid[ETH_ALEN];
+        bool fixed_bssid;
+        bool fixed_channel;
 
-        unsigned long request;
+        u8 bssid[ETH_ALEN];
+        u8 ssid[IEEE80211_MAX_SSID_LEN];
+        u8 ssid_len, ie_len;
+        u8 *ie;
+        struct ieee80211_channel *channel;
 
         unsigned long ibss_join_req;
-        struct sk_buff *probe_resp; /* ProbeResp template for IBSS */
+        /* probe response/beacon for IBSS */
+        struct sk_buff *presp, *skb;
 
         enum {
                 IEEE80211_IBSS_MLME_SEARCH,
@@ -361,6 +362,8 @@ struct ieee80211_if_mesh {
         struct timer_list mesh_path_timer;
         struct sk_buff_head skb_queue;
 
+        unsigned long timers_running;
+
         bool housekeeping;
 
         u8 mesh_id[IEEE80211_MAX_MESH_ID_LEN];
@@ -430,6 +433,12 @@ struct ieee80211_sub_if_data {
 
         int drop_unencrypted;
 
+        /*
+         * keep track of whether the HT opmode (stored in
+         * vif.bss_info.ht_operation_mode) is valid.
+         */
+        bool ht_opmode_valid;
+
         /* Fragment table for host-based reassembly */
         struct ieee80211_fragment_entry fragments[IEEE80211_FRAGMENT_MAX];
         unsigned int fragment_next;
@@ -580,6 +589,7 @@ enum queue_stop_reason {
         IEEE80211_QUEUE_STOP_REASON_AGGREGATION,
         IEEE80211_QUEUE_STOP_REASON_SUSPEND,
         IEEE80211_QUEUE_STOP_REASON_PENDING,
+        IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
 };
 
 struct ieee80211_master_priv {
@@ -606,6 +616,21 @@ struct ieee80211_local {
         unsigned int filter_flags; /* FIF_* */
         struct iw_statistics wstats;
         bool tim_in_locked_section; /* see ieee80211_beacon_get() */
+
+        /*
+         * suspended is true if we finished all the suspend _and_ we have
+         * not yet come up from resume. This is to be used by mac80211
+         * to ensure driver sanity during suspend and mac80211's own
+         * sanity. It can eventually be used for WoW as well.
+         */
+        bool suspended;
+
+        /*
+         * quiescing is true during the suspend process _only_ to
+         * ease timer cancelling etc.
+         */
+        bool quiescing;
+
         int tx_headroom; /* required headroom for hardware/radiotap */
 
         /* Tasklet and skb queue to process calls from IRQ mode. All frames
@@ -626,8 +651,6 @@ struct ieee80211_local {
         spinlock_t sta_lock;
         unsigned long num_sta;
         struct list_head sta_list;
-        struct list_head sta_flush_list;
-        struct work_struct sta_flush_work;
         struct sta_info *sta_hash[STA_HASH_SIZE];
         struct timer_list sta_cleanup;
 
@@ -647,9 +670,6 @@ struct ieee80211_local {
 
         struct rate_control_ref *rate_ctrl;
 
-        int rts_threshold;
-        int fragmentation_threshold;
-
         struct crypto_blkcipher *wep_tx_tfm;
         struct crypto_blkcipher *wep_rx_tfm;
         u32 wep_iv;
@@ -666,15 +686,18 @@ struct ieee80211_local {
 
 
         /* Scanning and BSS list */
+        struct mutex scan_mtx;
         bool sw_scanning, hw_scanning;
         struct cfg80211_ssid scan_ssid;
         struct cfg80211_scan_request int_scan_req;
         struct cfg80211_scan_request *scan_req;
         struct ieee80211_channel *scan_channel;
+        const u8 *orig_ies;
+        int orig_ies_len;
         int scan_channel_idx;
+        int scan_ies_len;
 
         enum { SCAN_SET_CHANNEL, SCAN_SEND_PROBE } scan_state;
-        unsigned long last_scan_completed;
         struct delayed_work scan_work;
         struct ieee80211_sub_if_data *scan_sdata;
         enum nl80211_channel_type oper_channel_type;
@@ -736,28 +759,32 @@ struct ieee80211_local {
         int wifi_wme_noack_test;
         unsigned int wmm_acm; /* bit field of ACM bits (BIT(802.1D tag)) */
 
-        bool powersave;
         bool pspolling;
+        /*
+         * PS can only be enabled when we have exactly one managed
+         * interface (and monitors) in PS, this then points there.
+         */
+        struct ieee80211_sub_if_data *ps_sdata;
         struct work_struct dynamic_ps_enable_work;
         struct work_struct dynamic_ps_disable_work;
         struct timer_list dynamic_ps_timer;
+        struct notifier_block network_latency_notifier;
 
         int user_power_level; /* in dBm */
         int power_constr_level; /* in dBm */
 
+        struct work_struct restart_work;
+
 #ifdef CONFIG_MAC80211_DEBUGFS
         struct local_debugfsdentries {
                 struct dentry *rcdir;
                 struct dentry *rcname;
                 struct dentry *frequency;
-                struct dentry *rts_threshold;
-                struct dentry *fragmentation_threshold;
-                struct dentry *short_retry_limit;
-                struct dentry *long_retry_limit;
                 struct dentry *total_ps_buffered;
                 struct dentry *wep_iv;
                 struct dentry *tsf;
                 struct dentry *reset;
+                struct dentry *noack;
                 struct dentry *statistics;
                 struct local_debugfsdentries_statsdentries {
                         struct dentry *transmitted_fragment_count;
@@ -830,7 +857,7 @@ struct ieee802_11_elems {
         u8 *fh_params;
         u8 *ds_params;
         u8 *cf_params;
-        u8 *tim;
+        struct ieee80211_tim_ie *tim;
         u8 *ibss_params;
         u8 *challenge;
         u8 *wpa;
@@ -903,7 +930,6 @@ static inline int ieee80211_bssid_match(const u8 *raddr, const u8 *addr)
 
 
 int ieee80211_hw_config(struct ieee80211_local *local, u32 changed);
-int ieee80211_if_config(struct ieee80211_sub_if_data *sdata, u32 changed);
 void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx);
 void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata,
                                       u32 changed);
@@ -927,12 +953,16 @@ int ieee80211_sta_deauthenticate(struct ieee80211_sub_if_data *sdata, u16 reason
 int ieee80211_sta_disassociate(struct ieee80211_sub_if_data *sdata, u16 reason);
 void ieee80211_send_pspoll(struct ieee80211_local *local,
                            struct ieee80211_sub_if_data *sdata);
+void ieee80211_recalc_ps(struct ieee80211_local *local, s32 latency);
+int ieee80211_max_network_latency(struct notifier_block *nb,
+                                  unsigned long data, void *dummy);
+void ieee80211_sta_process_chanswitch(struct ieee80211_sub_if_data *sdata,
+                                      struct ieee80211_channel_sw_ie *sw_elem,
+                                      struct ieee80211_bss *bss);
+void ieee80211_sta_quiesce(struct ieee80211_sub_if_data *sdata);
+void ieee80211_sta_restart(struct ieee80211_sub_if_data *sdata);
 
 /* IBSS code */
-int ieee80211_ibss_commit(struct ieee80211_sub_if_data *sdata);
-int ieee80211_ibss_set_ssid(struct ieee80211_sub_if_data *sdata, char *ssid, size_t len);
-int ieee80211_ibss_get_ssid(struct ieee80211_sub_if_data *sdata, char *ssid, size_t *len);
-int ieee80211_ibss_set_bssid(struct ieee80211_sub_if_data *sdata, u8 *bssid);
 void ieee80211_ibss_notify_scan_completed(struct ieee80211_local *local);
 void ieee80211_ibss_setup_sdata(struct ieee80211_sub_if_data *sdata);
 ieee80211_rx_result
@@ -940,14 +970,22 @@ ieee80211_ibss_rx_mgmt(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb,
                        struct ieee80211_rx_status *rx_status);
 struct sta_info *ieee80211_ibss_add_sta(struct ieee80211_sub_if_data *sdata,
                                         u8 *bssid, u8 *addr, u32 supp_rates);
+int ieee80211_ibss_join(struct ieee80211_sub_if_data *sdata,
+                        struct cfg80211_ibss_params *params);
+int ieee80211_ibss_leave(struct ieee80211_sub_if_data *sdata);
+void ieee80211_ibss_quiesce(struct ieee80211_sub_if_data *sdata);
+void ieee80211_ibss_restart(struct ieee80211_sub_if_data *sdata);
 
 /* scan/BSS handling */
 void ieee80211_scan_work(struct work_struct *work);
+int ieee80211_request_internal_scan(struct ieee80211_sub_if_data *sdata,
+                                    const u8 *ssid, u8 ssid_len);
 int ieee80211_request_scan(struct ieee80211_sub_if_data *sdata,
                            struct cfg80211_scan_request *req);
 int ieee80211_scan_results(struct ieee80211_local *local,
                            struct iw_request_info *info,
                            char *buf, size_t len);
+void ieee80211_scan_cancel(struct ieee80211_local *local);
 ieee80211_rx_result
 ieee80211_scan_rx(struct ieee80211_sub_if_data *sdata,
                   struct sk_buff *skb,
@@ -956,9 +994,6 @@ int ieee80211_sta_set_extra_ie(struct ieee80211_sub_if_data *sdata,
                                const char *ie, size_t len);
 
 void ieee80211_mlme_notify_scan_completed(struct ieee80211_local *local);
-void ieee80211_scan_failed(struct ieee80211_local *local);
-int ieee80211_start_scan(struct ieee80211_sub_if_data *scan_sdata,
-                         struct cfg80211_scan_request *req);
 struct ieee80211_bss *
 ieee80211_bss_info_update(struct ieee80211_local *local,
                           struct ieee80211_rx_status *rx_status,
@@ -983,6 +1018,8 @@ int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata,
                              enum nl80211_iftype type);
 void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata);
 void ieee80211_remove_interfaces(struct ieee80211_local *local);
+u32 __ieee80211_recalc_idle(struct ieee80211_local *local);
+void ieee80211_recalc_idle(struct ieee80211_local *local);
 
 /* tx handling */
 void ieee80211_clear_tx_pending(struct ieee80211_local *local);
@@ -995,9 +1032,6 @@ int ieee80211_subif_start_xmit(struct sk_buff *skb, struct net_device *dev);
 void ieee80211_ht_cap_ie_to_sta_ht_cap(struct ieee80211_supported_band *sband,
                                        struct ieee80211_ht_cap *ht_cap_ie,
                                        struct ieee80211_sta_ht_cap *ht_cap);
-u32 ieee80211_enable_ht(struct ieee80211_sub_if_data *sdata,
-                        struct ieee80211_ht_info *hti,
-                        u16 ap_ht_cap_flags);
 void ieee80211_send_bar(struct ieee80211_sub_if_data *sdata, u8 *ra, u16 tid, u16 ssn);
 void ieee80211_send_delba(struct ieee80211_sub_if_data *sdata,
                           const u8 *da, u16 tid,
@@ -1027,24 +1061,23 @@ int __ieee80211_stop_tx_ba_session(struct sta_info *sta, u16 tid,
 void ieee80211_process_measurement_req(struct ieee80211_sub_if_data *sdata,
                                        struct ieee80211_mgmt *mgmt,
                                        size_t len);
-void ieee80211_chswitch_timer(unsigned long data);
-void ieee80211_chswitch_work(struct work_struct *work);
-void ieee80211_process_chanswitch(struct ieee80211_sub_if_data *sdata,
-                                  struct ieee80211_channel_sw_ie *sw_elem,
-                                  struct ieee80211_bss *bss);
-void ieee80211_handle_pwr_constr(struct ieee80211_sub_if_data *sdata,
-                                 u16 capab_info, u8 *pwr_constr_elem,
-                                 u8 pwr_constr_elem_len);
-
-/* Suspend/resume */
+
+/* Suspend/resume and hw reconfiguration */
+int ieee80211_reconfig(struct ieee80211_local *local);
+
 #ifdef CONFIG_PM
 int __ieee80211_suspend(struct ieee80211_hw *hw);
-int __ieee80211_resume(struct ieee80211_hw *hw);
+
+static inline int __ieee80211_resume(struct ieee80211_hw *hw)
+{
+        return ieee80211_reconfig(hw_to_local(hw));
+}
 #else
 static inline int __ieee80211_suspend(struct ieee80211_hw *hw)
 {
         return 0;
 }
+
 static inline int __ieee80211_resume(struct ieee80211_hw *hw)
 {
         return 0;
@@ -1053,19 +1086,20 @@ static inline int __ieee80211_resume(struct ieee80211_hw *hw)
 
 /* utility functions/constants */
 extern void *mac80211_wiphy_privid; /* for wiphy privid */
-extern const unsigned char rfc1042_header[6];
-extern const unsigned char bridge_tunnel_header[6];
 u8 *ieee80211_get_bssid(struct ieee80211_hdr *hdr, size_t len,
                         enum nl80211_iftype type);
 int ieee80211_frame_duration(struct ieee80211_local *local, size_t len,
                              int rate, int erp, int short_preamble);
 void mac80211_ev_michael_mic_failure(struct ieee80211_sub_if_data *sdata, int keyidx,
-                                     struct ieee80211_hdr *hdr);
+                                     struct ieee80211_hdr *hdr, const u8 *tsc);
 void ieee80211_set_wmm_default(struct ieee80211_sub_if_data *sdata);
 void ieee80211_tx_skb(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb,
                       int encrypt);
 void ieee802_11_parse_elems(u8 *start, size_t len,
                             struct ieee802_11_elems *elems);
+u32 ieee802_11_parse_elems_crc(u8 *start, size_t len,
+                               struct ieee802_11_elems *elems,
+                               u64 filter, u32 crc);
 int ieee80211_set_freq(struct ieee80211_sub_if_data *sdata, int freq);
 u32 ieee80211_mandatory_rates(struct ieee80211_local *local,
                               enum ieee80211_band band);
@@ -1088,14 +1122,20 @@ void ieee80211_wake_queue_by_reason(struct ieee80211_hw *hw, int queue,
                                     enum queue_stop_reason reason);
 void ieee80211_stop_queue_by_reason(struct ieee80211_hw *hw, int queue,
                                     enum queue_stop_reason reason);
+void ieee80211_add_pending_skb(struct ieee80211_local *local,
+                               struct sk_buff *skb);
+int ieee80211_add_pending_skbs(struct ieee80211_local *local,
+                               struct sk_buff_head *skbs);
 
 void ieee80211_send_auth(struct ieee80211_sub_if_data *sdata,
                          u16 transaction, u16 auth_alg,
                          u8 *extra, size_t extra_len,
                          const u8 *bssid, int encrypt);
+int ieee80211_build_preq_ies(struct ieee80211_local *local, u8 *buffer,
+                             const u8 *ie, size_t ie_len);
 void ieee80211_send_probe_req(struct ieee80211_sub_if_data *sdata, u8 *dst,
-                              u8 *ssid, size_t ssid_len,
-                              u8 *ie, size_t ie_len);
+                              const u8 *ssid, size_t ssid_len,
+                              const u8 *ie, size_t ie_len);
 
 void ieee80211_sta_def_wmm_params(struct ieee80211_sub_if_data *sdata,
                                   const size_t supp_rates_len,
diff --git a/net/mac80211/iface.c b/net/mac80211/iface.c
index 91e8e1bacaaa..b7c8a4484298 100644
--- a/net/mac80211/iface.c
+++ b/net/mac80211/iface.c
@@ -20,6 +20,7 @@
 #include "debugfs_netdev.h"
 #include "mesh.h"
 #include "led.h"
+#include "driver-ops.h"
 
 /**
  * DOC: Interface list locking
@@ -164,14 +165,12 @@ static int ieee80211_open(struct net_device *dev)
         }
 
         if (local->open_count == 0) {
-                res = 0;
-                if (local->ops->start)
-                        res = local->ops->start(local_to_hw(local));
+                res = drv_start(local);
                 if (res)
                         goto err_del_bss;
                 /* we're brought up, everything changes */
                 hw_reconf_flags = ~0;
-                ieee80211_led_radio(local, local->hw.conf.radio_enabled);
+                ieee80211_led_radio(local, true);
         }
 
         /*
@@ -199,8 +198,8 @@ static int ieee80211_open(struct net_device *dev)
          * Validate the MAC address for this device.
          */
         if (!is_valid_ether_addr(dev->dev_addr)) {
-                if (!local->open_count && local->ops->stop)
-                        local->ops->stop(local_to_hw(local));
+                if (!local->open_count)
+                        drv_stop(local);
                 return -EADDRNOTAVAIL;
         }
 
@@ -235,17 +234,13 @@ static int ieee80211_open(struct net_device *dev)
                 netif_addr_unlock_bh(local->mdev);
                 break;
         case NL80211_IFTYPE_STATION:
-        case NL80211_IFTYPE_ADHOC:
-                if (sdata->vif.type == NL80211_IFTYPE_STATION)
-                        sdata->u.mgd.flags &= ~IEEE80211_STA_PREV_BSSID_SET;
-                else
-                        sdata->u.ibss.flags &= ~IEEE80211_IBSS_PREV_BSSID_SET;
+                sdata->u.mgd.flags &= ~IEEE80211_STA_PREV_BSSID_SET;
                 /* fall through */
         default:
                 conf.vif = &sdata->vif;
                 conf.type = sdata->vif.type;
                 conf.mac_addr = dev->dev_addr;
-                res = local->ops->add_interface(local_to_hw(local), &conf);
+                res = drv_add_interface(local, &conf);
                 if (res)
                         goto err_stop;
 
@@ -306,6 +301,8 @@ static int ieee80211_open(struct net_device *dev)
         if (sdata->flags & IEEE80211_SDATA_PROMISC)
                 atomic_inc(&local->iff_promiscs);
 
+        hw_reconf_flags |= __ieee80211_recalc_idle(local);
+
         local->open_count++;
         if (hw_reconf_flags) {
                 ieee80211_hw_config(local, hw_reconf_flags);
@@ -317,6 +314,8 @@ static int ieee80211_open(struct net_device *dev)
                 ieee80211_set_wmm_default(sdata);
         }
 
+        ieee80211_recalc_ps(local, -1);
+
         /*
          * ieee80211_sta_work is disabled while network interface
          * is down. Therefore, some configuration changes may not
@@ -325,17 +324,15 @@ static int ieee80211_open(struct net_device *dev)
          */
         if (sdata->vif.type == NL80211_IFTYPE_STATION)
                 queue_work(local->hw.workqueue, &sdata->u.mgd.work);
-        else if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
-                queue_work(local->hw.workqueue, &sdata->u.ibss.work);
 
         netif_tx_start_all_queues(dev);
 
         return 0;
  err_del_interface:
-        local->ops->remove_interface(local_to_hw(local), &conf);
+        drv_remove_interface(local, &conf);
  err_stop:
-        if (!local->open_count && local->ops->stop)
-                local->ops->stop(local_to_hw(local));
+        if (!local->open_count)
+                drv_stop(local);
  err_del_bss:
         sdata->bss = NULL;
         if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
@@ -497,7 +494,6 @@ static int ieee80211_stop(struct net_device *dev)
                 /* fall through */
         case NL80211_IFTYPE_ADHOC:
                 if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
-                        memset(sdata->u.ibss.bssid, 0, ETH_ALEN);
                         del_timer_sync(&sdata->u.ibss.timer);
                         cancel_work_sync(&sdata->u.ibss.work);
                         synchronize_rcu();
@@ -549,19 +545,22 @@ static int ieee80211_stop(struct net_device *dev)
                 conf.mac_addr = dev->dev_addr;
                 /* disable all keys for as long as this netdev is down */
                 ieee80211_disable_keys(sdata);
-                local->ops->remove_interface(local_to_hw(local), &conf);
+                drv_remove_interface(local, &conf);
         }
 
         sdata->bss = NULL;
 
+        hw_reconf_flags |= __ieee80211_recalc_idle(local);
+
+        ieee80211_recalc_ps(local, -1);
+
         if (local->open_count == 0) {
                 if (netif_running(local->mdev))
                         dev_close(local->mdev);
 
-                if (local->ops->stop)
-                        local->ops->stop(local_to_hw(local));
+                drv_stop(local);
 
-                ieee80211_led_radio(local, 0);
+                ieee80211_led_radio(local, false);
 
                 flush_workqueue(local->hw.workqueue);
 
@@ -649,7 +648,8 @@ static void ieee80211_teardown_sdata(struct net_device *dev)
                         mesh_rmc_free(sdata);
                 break;
         case NL80211_IFTYPE_ADHOC:
-                kfree_skb(sdata->u.ibss.probe_resp);
+                if (WARN_ON(sdata->u.ibss.presp))
+                        kfree_skb(sdata->u.ibss.presp);
                 break;
         case NL80211_IFTYPE_STATION:
                 kfree(sdata->u.mgd.extra_ie);
@@ -896,3 +896,74 @@ void ieee80211_remove_interfaces(struct ieee80211_local *local)
                 unregister_netdevice(sdata->dev);
         }
 }
+
+static u32 ieee80211_idle_off(struct ieee80211_local *local,
+                              const char *reason)
+{
+        if (!(local->hw.conf.flags & IEEE80211_CONF_IDLE))
+                return 0;
+
+#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
+        printk(KERN_DEBUG "%s: device no longer idle - %s\n",
+               wiphy_name(local->hw.wiphy), reason);
+#endif
+
+        local->hw.conf.flags &= ~IEEE80211_CONF_IDLE;
+        return IEEE80211_CONF_CHANGE_IDLE;
+}
+
+static u32 ieee80211_idle_on(struct ieee80211_local *local)
+{
+        if (local->hw.conf.flags & IEEE80211_CONF_IDLE)
+                return 0;
+
+#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
+        printk(KERN_DEBUG "%s: device now idle\n",
+               wiphy_name(local->hw.wiphy));
+#endif
+
+        local->hw.conf.flags |= IEEE80211_CONF_IDLE;
+        return IEEE80211_CONF_CHANGE_IDLE;
+}
+
+u32 __ieee80211_recalc_idle(struct ieee80211_local *local)
+{
+        struct ieee80211_sub_if_data *sdata;
+        int count = 0;
+
+        if (local->hw_scanning || local->sw_scanning)
+                return ieee80211_idle_off(local, "scanning");
+
+        list_for_each_entry(sdata, &local->interfaces, list) {
+                if (!netif_running(sdata->dev))
+                        continue;
+                /* do not count disabled managed interfaces */
+                if (sdata->vif.type == NL80211_IFTYPE_STATION &&
+                    sdata->u.mgd.state == IEEE80211_STA_MLME_DISABLED)
+                        continue;
+                /* do not count unused IBSS interfaces */
+                if (sdata->vif.type == NL80211_IFTYPE_ADHOC &&
+                    !sdata->u.ibss.ssid_len)
+                        continue;
+                /* count everything else */
+                count++;
+        }
+
+        if (!count)
+                return ieee80211_idle_on(local);
+        else
+                return ieee80211_idle_off(local, "in use");
+
+        return 0;
+}
+
+void ieee80211_recalc_idle(struct ieee80211_local *local)
+{
+        u32 chg;
+
+        mutex_lock(&local->iflist_mtx);
+        chg = __ieee80211_recalc_idle(local);
+        mutex_unlock(&local->iflist_mtx);
+        if (chg)
+                ieee80211_hw_config(local, chg);
+}
diff --git a/net/mac80211/key.c b/net/mac80211/key.c
index 687acf23054d..ce267565e180 100644
--- a/net/mac80211/key.c
+++ b/net/mac80211/key.c
@@ -16,6 +16,7 @@
 #include <linux/rtnetlink.h>
 #include <net/mac80211.h>
 #include "ieee80211_i.h"
+#include "driver-ops.h"
 #include "debugfs_key.h"
 #include "aes_ccm.h"
 #include "aes_cmac.h"
@@ -136,8 +137,7 @@ static void ieee80211_key_enable_hw_accel(struct ieee80211_key *key)
                                      struct ieee80211_sub_if_data,
                                      u.ap);
 
-        ret = key->local->ops->set_key(local_to_hw(key->local), SET_KEY,
-                                       &sdata->vif, sta, &key->conf);
+        ret = drv_set_key(key->local, SET_KEY, &sdata->vif, sta, &key->conf);
 
         if (!ret) {
                 spin_lock(&todo_lock);
@@ -179,8 +179,8 @@ static void ieee80211_key_disable_hw_accel(struct ieee80211_key *key)
                                      struct ieee80211_sub_if_data,
                                      u.ap);
 
-        ret = key->local->ops->set_key(local_to_hw(key->local), DISABLE_KEY,
-                                       &sdata->vif, sta, &key->conf);
+        ret = drv_set_key(key->local, DISABLE_KEY, &sdata->vif,
+                          sta, &key->conf);
 
         if (ret)
                 printk(KERN_ERR "mac80211-%s: failed to remove key "
@@ -290,9 +290,11 @@ static void __ieee80211_key_replace(struct ieee80211_sub_if_data *sdata,
 struct ieee80211_key *ieee80211_key_alloc(enum ieee80211_key_alg alg,
                                           int idx,
                                           size_t key_len,
-                                          const u8 *key_data)
+                                          const u8 *key_data,
+                                          size_t seq_len, const u8 *seq)
 {
         struct ieee80211_key *key;
+        int i, j;
 
         BUG_ON(idx < 0 || idx >= NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS);
 
@@ -318,14 +320,31 @@ struct ieee80211_key *ieee80211_key_alloc(enum ieee80211_key_alg alg,
         case ALG_TKIP:
                 key->conf.iv_len = TKIP_IV_LEN;
                 key->conf.icv_len = TKIP_ICV_LEN;
+                if (seq) {
+                        for (i = 0; i < NUM_RX_DATA_QUEUES; i++) {
+                                key->u.tkip.rx[i].iv32 =
+                                        get_unaligned_le32(&seq[2]);
+                                key->u.tkip.rx[i].iv16 =
+                                        get_unaligned_le16(seq);
+                        }
+                }
                 break;
         case ALG_CCMP:
                 key->conf.iv_len = CCMP_HDR_LEN;
                 key->conf.icv_len = CCMP_MIC_LEN;
+                if (seq) {
+                        for (i = 0; i < NUM_RX_DATA_QUEUES; i++)
+                                for (j = 0; j < CCMP_PN_LEN; j++)
+                                        key->u.ccmp.rx_pn[i][j] =
+                                                seq[CCMP_PN_LEN - j - 1];
+                }
                 break;
         case ALG_AES_CMAC:
                 key->conf.iv_len = 0;
                 key->conf.icv_len = sizeof(struct ieee80211_mmie);
+                if (seq)
+                        for (j = 0; j < 6; j++)
+                                key->u.aes_cmac.rx_pn[j] = seq[6 - j - 1];
                 break;
         }
         memcpy(key->conf.key, key_data, key_len);
diff --git a/net/mac80211/key.h b/net/mac80211/key.h
index 215d3ef42a4f..9572e00f532c 100644
--- a/net/mac80211/key.h
+++ b/net/mac80211/key.h
@@ -144,7 +144,8 @@ struct ieee80211_key {
 struct ieee80211_key *ieee80211_key_alloc(enum ieee80211_key_alg alg,
                                           int idx,
                                           size_t key_len,
-                                          const u8 *key_data);
+                                          const u8 *key_data,
+                                          size_t seq_len, const u8 *seq);
 /*
  * Insert a key into data structures (sdata, sta if necessary)
  * to make it used, free old key.
diff --git a/net/mac80211/main.c b/net/mac80211/main.c
index 14134193cd17..092a017b237e 100644
--- a/net/mac80211/main.c
+++ b/net/mac80211/main.c
@@ -21,10 +21,12 @@
 #include <linux/wireless.h>
 #include <linux/rtnetlink.h>
 #include <linux/bitmap.h>
+#include <linux/pm_qos_params.h>
 #include <net/net_namespace.h>
 #include <net/cfg80211.h>
 
 #include "ieee80211_i.h"
+#include "driver-ops.h"
 #include "rate.h"
 #include "mesh.h"
 #include "wep.h"
@@ -80,10 +82,9 @@ void ieee80211_configure_filter(struct ieee80211_local *local)
         /* be a bit nasty */
         new_flags |= (1<<31);
 
-        local->ops->configure_filter(local_to_hw(local),
-                                     changed_flags, &new_flags,
-                                     local->mdev->mc_count,
-                                     local->mdev->mc_list);
+        drv_configure_filter(local, changed_flags, &new_flags,
+                             local->mdev->mc_count,
+                             local->mdev->mc_list);
 
         WARN_ON(new_flags & (1<<31));
 
@@ -151,93 +152,19 @@ static void ieee80211_master_set_multicast_list(struct net_device *dev)
         ieee80211_configure_filter(local);
 }
 
-/* everything else */
-
-int ieee80211_if_config(struct ieee80211_sub_if_data *sdata, u32 changed)
-{
-        struct ieee80211_local *local = sdata->local;
-        struct ieee80211_if_conf conf;
-
-        if (WARN_ON(!netif_running(sdata->dev)))
-                return 0;
-
-        memset(&conf, 0, sizeof(conf));
-
-        if (sdata->vif.type == NL80211_IFTYPE_STATION)
-                conf.bssid = sdata->u.mgd.bssid;
-        else if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
-                conf.bssid = sdata->u.ibss.bssid;
-        else if (sdata->vif.type == NL80211_IFTYPE_AP)
-                conf.bssid = sdata->dev->dev_addr;
-        else if (ieee80211_vif_is_mesh(&sdata->vif)) {
-                static const u8 zero[ETH_ALEN] = { 0 };
-                conf.bssid = zero;
-        } else {
-                WARN_ON(1);
-                return -EINVAL;
-        }
-
-        if (!local->ops->config_interface)
-                return 0;
-
-        switch (sdata->vif.type) {
-        case NL80211_IFTYPE_AP:
-        case NL80211_IFTYPE_ADHOC:
-        case NL80211_IFTYPE_MESH_POINT:
-                break;
-        default:
-                /* do not warn to simplify caller in scan.c */
-                changed &= ~IEEE80211_IFCC_BEACON_ENABLED;
-                if (WARN_ON(changed & IEEE80211_IFCC_BEACON))
-                        return -EINVAL;
-                changed &= ~IEEE80211_IFCC_BEACON;
-                break;
-        }
-
-        if (changed & IEEE80211_IFCC_BEACON_ENABLED) {
-                if (local->sw_scanning) {
-                        conf.enable_beacon = false;
-                } else {
-                        /*
-                         * Beacon should be enabled, but AP mode must
-                         * check whether there is a beacon configured.
-                         */
-                        switch (sdata->vif.type) {
-                        case NL80211_IFTYPE_AP:
-                                conf.enable_beacon =
-                                        !!rcu_dereference(sdata->u.ap.beacon);
-                                break;
-                        case NL80211_IFTYPE_ADHOC:
-                                conf.enable_beacon = !!sdata->u.ibss.probe_resp;
-                                break;
-                        case NL80211_IFTYPE_MESH_POINT:
-                                conf.enable_beacon = true;
-                                break;
-                        default:
-                                /* not reached */
-                                WARN_ON(1);
-                                break;
-                        }
-                }
-        }
-
-        conf.changed = changed;
-
-        return local->ops->config_interface(local_to_hw(local),
-                                            &sdata->vif, &conf);
-}
-
 int ieee80211_hw_config(struct ieee80211_local *local, u32 changed)
 {
-        struct ieee80211_channel *chan;
+        struct ieee80211_channel *chan, *scan_chan;
         int ret = 0;
         int power;
         enum nl80211_channel_type channel_type;
 
         might_sleep();
 
-        if (local->sw_scanning) {
-                chan = local->scan_channel;
+        scan_chan = local->scan_channel;
+
+        if (scan_chan) {
+                chan = scan_chan;
                 channel_type = NL80211_CHAN_NO_HT;
         } else {
                 chan = local->oper_channel;
@@ -251,7 +178,7 @@ int ieee80211_hw_config(struct ieee80211_local *local, u32 changed)
                 changed |= IEEE80211_CONF_CHANGE_CHANNEL;
         }
 
-        if (local->sw_scanning)
+        if (scan_chan)
                 power = chan->max_power;
         else
                 power = local->power_constr_level ?
@@ -267,7 +194,7 @@ int ieee80211_hw_config(struct ieee80211_local *local, u32 changed)
         }
 
         if (changed && local->open_count) {
-                ret = local->ops->config(local_to_hw(local), changed);
+                ret = drv_config(local, changed);
                 /*
                  * Goal:
                  * HW reconfiguration should never fail, the driver has told
@@ -292,18 +219,78 @@ void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata,
                                       u32 changed)
 {
         struct ieee80211_local *local = sdata->local;
+        static const u8 zero[ETH_ALEN] = { 0 };
 
-        if (WARN_ON(sdata->vif.type == NL80211_IFTYPE_AP_VLAN))
+        if (!changed)
                 return;
 
-        if (!changed)
+        if (sdata->vif.type == NL80211_IFTYPE_STATION) {
+                /*
+                 * While not associated, claim a BSSID of all-zeroes
+                 * so that drivers don't do any weird things with the
+                 * BSSID at that time.
+                 */
+                if (sdata->vif.bss_conf.assoc)
+                        sdata->vif.bss_conf.bssid = sdata->u.mgd.bssid;
+                else
+                        sdata->vif.bss_conf.bssid = zero;
+        } else if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
+                sdata->vif.bss_conf.bssid = sdata->u.ibss.bssid;
+        else if (sdata->vif.type == NL80211_IFTYPE_AP)
+                sdata->vif.bss_conf.bssid = sdata->dev->dev_addr;
+        else if (ieee80211_vif_is_mesh(&sdata->vif)) {
+                sdata->vif.bss_conf.bssid = zero;
+        } else {
+                WARN_ON(1);
                 return;
+        }
+
+        switch (sdata->vif.type) {
+        case NL80211_IFTYPE_AP:
+        case NL80211_IFTYPE_ADHOC:
+        case NL80211_IFTYPE_MESH_POINT:
+                break;
+        default:
+                /* do not warn to simplify caller in scan.c */
+                changed &= ~BSS_CHANGED_BEACON_ENABLED;
+                if (WARN_ON(changed & BSS_CHANGED_BEACON))
+                        return;
+                break;
+        }
+
+        if (changed & BSS_CHANGED_BEACON_ENABLED) {
+                if (local->sw_scanning) {
+                        sdata->vif.bss_conf.enable_beacon = false;
+                } else {
+                        /*
+                         * Beacon should be enabled, but AP mode must
+                         * check whether there is a beacon configured.
+                         */
+                        switch (sdata->vif.type) {
+                        case NL80211_IFTYPE_AP:
+                                sdata->vif.bss_conf.enable_beacon =
+                                        !!rcu_dereference(sdata->u.ap.beacon);
+                                break;
+                        case NL80211_IFTYPE_ADHOC:
+                                sdata->vif.bss_conf.enable_beacon =
+                                        !!rcu_dereference(sdata->u.ibss.presp);
+                                break;
+                        case NL80211_IFTYPE_MESH_POINT:
+                                sdata->vif.bss_conf.enable_beacon = true;
+                                break;
+                        default:
+                                /* not reached */
+                                WARN_ON(1);
+                                break;
+                        }
+                }
+        }
+
+        drv_bss_info_changed(local, &sdata->vif,
+                             &sdata->vif.bss_conf, changed);
 
-        if (local->ops->bss_info_changed)
-                local->ops->bss_info_changed(local_to_hw(local),
-                                             &sdata->vif,
-                                             &sdata->vif.bss_conf,
-                                             changed);
+        /* DEPRECATED */
+        local->hw.conf.beacon_int = sdata->vif.bss_conf.beacon_int;
 }
 
 u32 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata)
@@ -382,60 +369,12 @@ static void ieee80211_tasklet_handler(unsigned long data)
         }
 }
 
-/* Remove added headers (e.g., QoS control), encryption header/MIC, etc. to
- * make a prepared TX frame (one that has been given to hw) to look like brand
- * new IEEE 802.11 frame that is ready to go through TX processing again.
- */
-static void ieee80211_remove_tx_extra(struct ieee80211_local *local,
-                                      struct ieee80211_key *key,
-                                      struct sk_buff *skb)
-{
-        unsigned int hdrlen, iv_len, mic_len;
-        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
-
-        hdrlen = ieee80211_hdrlen(hdr->frame_control);
-
-        if (!key)
-                goto no_key;
-
-        switch (key->conf.alg) {
-        case ALG_WEP:
-                iv_len = WEP_IV_LEN;
-                mic_len = WEP_ICV_LEN;
-                break;
-        case ALG_TKIP:
-                iv_len = TKIP_IV_LEN;
-                mic_len = TKIP_ICV_LEN;
-                break;
-        case ALG_CCMP:
-                iv_len = CCMP_HDR_LEN;
-                mic_len = CCMP_MIC_LEN;
-                break;
-        default:
-                goto no_key;
-        }
-
-        if (skb->len >= hdrlen + mic_len &&
-            !(key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE))
-                skb_trim(skb, skb->len - mic_len);
-        if (skb->len >= hdrlen + iv_len) {
-                memmove(skb->data + iv_len, skb->data, hdrlen);
-                hdr = (struct ieee80211_hdr *)skb_pull(skb, iv_len);
-        }
-
-no_key:
-        if (ieee80211_is_data_qos(hdr->frame_control)) {
-                hdr->frame_control &= ~cpu_to_le16(IEEE80211_STYPE_QOS_DATA);
-                memmove(skb->data + IEEE80211_QOS_CTL_LEN, skb->data,
-                        hdrlen - IEEE80211_QOS_CTL_LEN);
-                skb_pull(skb, IEEE80211_QOS_CTL_LEN);
-        }
-}
-
 static void ieee80211_handle_filtered_frame(struct ieee80211_local *local,
                                             struct sta_info *sta,
                                             struct sk_buff *skb)
 {
+        struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
+
         sta->tx_filtered_count++;
 
         /*
@@ -477,16 +416,15 @@ static void ieee80211_handle_filtered_frame(struct ieee80211_local *local,
          */
         if (test_sta_flags(sta, WLAN_STA_PS) &&
             skb_queue_len(&sta->tx_filtered) < STA_MAX_TX_BUFFER) {
-                ieee80211_remove_tx_extra(local, sta->key, skb);
                 skb_queue_tail(&sta->tx_filtered, skb);
                 return;
         }
 
-        if (!test_sta_flags(sta, WLAN_STA_PS) && !skb->requeue) {
+        if (!test_sta_flags(sta, WLAN_STA_PS) &&
+            !(info->flags & IEEE80211_TX_INTFL_RETRIED)) {
                 /* Software retry the packet once */
-                skb->requeue = 1;
-                ieee80211_remove_tx_extra(local, sta->key, skb);
-                dev_queue_xmit(skb);
+                info->flags |= IEEE80211_TX_INTFL_RETRIED;
+                ieee80211_add_pending_skb(local, skb);
                 return;
         }
 
@@ -696,6 +634,28 @@ void ieee80211_tx_status(struct ieee80211_hw *hw, struct sk_buff *skb)
 }
 EXPORT_SYMBOL(ieee80211_tx_status);
 
+static void ieee80211_restart_work(struct work_struct *work)
+{
+        struct ieee80211_local *local =
+                container_of(work, struct ieee80211_local, restart_work);
+
+        rtnl_lock();
+        ieee80211_reconfig(local);
+        rtnl_unlock();
+}
+
+void ieee80211_restart_hw(struct ieee80211_hw *hw)
+{
+        struct ieee80211_local *local = hw_to_local(hw);
+
+        /* use this reason, __ieee80211_resume will unblock it */
+        ieee80211_stop_queues_by_reason(hw,
+                IEEE80211_QUEUE_STOP_REASON_SUSPEND);
+
+        schedule_work(&local->restart_work);
+}
+EXPORT_SYMBOL(ieee80211_restart_hw);
+
 struct ieee80211_hw *ieee80211_alloc_hw(size_t priv_data_len,
                                         const struct ieee80211_ops *ops)
 {
@@ -718,9 +678,7 @@ struct ieee80211_hw *ieee80211_alloc_hw(size_t priv_data_len,
          * +-------------------------+
          *
          */
-        priv_size = ((sizeof(struct ieee80211_local) +
-                      NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST) +
-                    priv_data_len;
+        priv_size = ALIGN(sizeof(*local), NETDEV_ALIGN) + priv_data_len;
 
         wiphy = wiphy_new(&mac80211_config_ops, priv_size);
 
@@ -728,17 +686,16 @@ struct ieee80211_hw *ieee80211_alloc_hw(size_t priv_data_len,
                 return NULL;
 
         wiphy->privid = mac80211_wiphy_privid;
-        wiphy->max_scan_ssids = 4;
+
         /* Yes, putting cfg80211_bss into ieee80211_bss is a hack */
         wiphy->bss_priv_size = sizeof(struct ieee80211_bss) -
                                sizeof(struct cfg80211_bss);
 
         local = wiphy_priv(wiphy);
+
         local->hw.wiphy = wiphy;
 
-        local->hw.priv = (char *)local +
-                         ((sizeof(struct ieee80211_local) +
-                           NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST);
+        local->hw.priv = (char *)local + ALIGN(sizeof(*local), NETDEV_ALIGN);
 
         BUG_ON(!ops->tx);
         BUG_ON(!ops->start);
@@ -752,15 +709,14 @@ struct ieee80211_hw *ieee80211_alloc_hw(size_t priv_data_len,
         /* set up some defaults */
         local->hw.queues = 1;
         local->hw.max_rates = 1;
-        local->rts_threshold = IEEE80211_MAX_RTS_THRESHOLD;
-        local->fragmentation_threshold = IEEE80211_MAX_FRAG_THRESHOLD;
-        local->hw.conf.long_frame_max_tx_count = 4;
-        local->hw.conf.short_frame_max_tx_count = 7;
+        local->hw.conf.long_frame_max_tx_count = wiphy->retry_long;
+        local->hw.conf.short_frame_max_tx_count = wiphy->retry_short;
         local->hw.conf.radio_enabled = true;
         local->user_power_level = -1;
 
         INIT_LIST_HEAD(&local->interfaces);
         mutex_init(&local->iflist_mtx);
+        mutex_init(&local->scan_mtx);
 
         spin_lock_init(&local->key_lock);
 
@@ -768,6 +724,8 @@ struct ieee80211_hw *ieee80211_alloc_hw(size_t priv_data_len,
 
         INIT_DELAYED_WORK(&local->scan_work, ieee80211_scan_work);
 
+        INIT_WORK(&local->restart_work, ieee80211_restart_work);
+
         INIT_WORK(&local->dynamic_ps_enable_work,
                   ieee80211_dynamic_ps_enable_work);
         INIT_WORK(&local->dynamic_ps_disable_work,
@@ -821,7 +779,17 @@ int ieee80211_register_hw(struct ieee80211_hw *hw)
         enum ieee80211_band band;
         struct net_device *mdev;
         struct ieee80211_master_priv *mpriv;
-        int channels, i, j;
+        int channels, i, j, max_bitrates;
+        bool supp_ht;
+        static const u32 cipher_suites[] = {
+                WLAN_CIPHER_SUITE_WEP40,
+                WLAN_CIPHER_SUITE_WEP104,
+                WLAN_CIPHER_SUITE_TKIP,
+                WLAN_CIPHER_SUITE_CCMP,
+
+                /* keep last -- depends on hw flags! */
+                WLAN_CIPHER_SUITE_AES_CMAC
+        };
 
         /*
          * generic code guarantees at least one band,
@@ -829,18 +797,25 @@ int ieee80211_register_hw(struct ieee80211_hw *hw)
          * that hw.conf.channel is assigned
          */
         channels = 0;
+        max_bitrates = 0;
+        supp_ht = false;
         for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
                 struct ieee80211_supported_band *sband;
 
                 sband = local->hw.wiphy->bands[band];
-                if (sband && !local->oper_channel) {
+                if (!sband)
+                        continue;
+                if (!local->oper_channel) {
                         /* init channel we're on */
                         local->hw.conf.channel =
-                        local->oper_channel =
-                        local->scan_channel = &sband->channels[0];
+                        local->oper_channel = &sband->channels[0];
+                        local->hw.conf.channel_type = NL80211_CHAN_NO_HT;
                 }
-                if (sband)
-                        channels += sband->n_channels;
+                channels += sband->n_channels;
+
+                if (max_bitrates < sband->n_bitrates)
+                        max_bitrates = sband->n_bitrates;
+                supp_ht = supp_ht || sband->ht_cap.ht_supported;
         }
 
         local->int_scan_req.n_channels = channels;
@@ -860,6 +835,37 @@ int ieee80211_register_hw(struct ieee80211_hw *hw)
         else if (local->hw.flags & IEEE80211_HW_SIGNAL_UNSPEC)
                 local->hw.wiphy->signal_type = CFG80211_SIGNAL_TYPE_UNSPEC;
 
+        /*
+         * Calculate scan IE length -- we need this to alloc
+         * memory and to subtract from the driver limit. It
+         * includes the (extended) supported rates and HT
+         * information -- SSID is the driver's responsibility.
+         */
+        local->scan_ies_len = 4 + max_bitrates; /* (ext) supp rates */
+        if (supp_ht)
+                local->scan_ies_len += 2 + sizeof(struct ieee80211_ht_cap);
+
+        if (!local->ops->hw_scan) {
+                /* For hw_scan, driver needs to set these up. */
+                local->hw.wiphy->max_scan_ssids = 4;
+                local->hw.wiphy->max_scan_ie_len = IEEE80211_MAX_DATA_LEN;
+        }
+
+        /*
+         * If the driver supports any scan IEs, then assume the
+         * limit includes the IEs mac80211 will add, otherwise
+         * leave it at zero and let the driver sort it out; we
+         * still pass our IEs to the driver but userspace will
+         * not be allowed to in that case.
+         */
+        if (local->hw.wiphy->max_scan_ie_len)
+                local->hw.wiphy->max_scan_ie_len -= local->scan_ies_len;
+
+        local->hw.wiphy->cipher_suites = cipher_suites;
+        local->hw.wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
+        if (!(local->hw.flags & IEEE80211_HW_MFP_CAPABLE))
+                local->hw.wiphy->n_cipher_suites--;
+
         result = wiphy_register(local->hw.wiphy);
         if (result < 0)
                 goto fail_wiphy_register;
@@ -898,9 +904,6 @@ int ieee80211_register_hw(struct ieee80211_hw *hw)
 
         debugfs_hw_add(local);
 
-        if (local->hw.conf.beacon_int < 10)
-                local->hw.conf.beacon_int = 100;
-
         if (local->hw.max_listen_interval == 0)
                 local->hw.max_listen_interval = 1;
 
@@ -965,25 +968,38 @@ int ieee80211_register_hw(struct ieee80211_hw *hw)
                 }
         }
 
+        local->network_latency_notifier.notifier_call =
+                ieee80211_max_network_latency;
+        result = pm_qos_add_notifier(PM_QOS_NETWORK_LATENCY,
+                                     &local->network_latency_notifier);
+
+        if (result) {
+                rtnl_lock();
+                goto fail_pm_qos;
+        }
+
         return 0;
 
-fail_rate:
+ fail_pm_qos:
+        ieee80211_led_exit(local);
+        ieee80211_remove_interfaces(local);
+ fail_rate:
         unregister_netdevice(local->mdev);
         local->mdev = NULL;
-fail_dev:
+ fail_dev:
         rtnl_unlock();
         ieee80211_wep_free(local);
-fail_wep:
+ fail_wep:
         sta_info_stop(local);
-fail_sta_info:
+ fail_sta_info:
         debugfs_hw_del(local);
         destroy_workqueue(local->hw.workqueue);
-fail_workqueue:
+ fail_workqueue:
         if (local->mdev)
                 free_netdev(local->mdev);
-fail_mdev_alloc:
+ fail_mdev_alloc:
         wiphy_unregister(local->hw.wiphy);
-fail_wiphy_register:
+ fail_wiphy_register:
         kfree(local->int_scan_req.channels);
         return result;
 }
@@ -996,6 +1012,9 @@ void ieee80211_unregister_hw(struct ieee80211_hw *hw)
         tasklet_kill(&local->tx_pending_tasklet);
         tasklet_kill(&local->tasklet);
 
+        pm_qos_remove_notifier(PM_QOS_NETWORK_LATENCY,
+                               &local->network_latency_notifier);
+
         rtnl_lock();
 
         /*
@@ -1038,6 +1057,7 @@ void ieee80211_free_hw(struct ieee80211_hw *hw)
         struct ieee80211_local *local = hw_to_local(hw);
 
         mutex_destroy(&local->iflist_mtx);
+        mutex_destroy(&local->scan_mtx);
 
         wiphy_free(local->hw.wiphy);
 }
diff --git a/net/mac80211/mesh.c b/net/mac80211/mesh.c
index 9a3e5de0410a..fc712e60705d 100644
--- a/net/mac80211/mesh.c
+++ b/net/mac80211/mesh.c
@@ -21,6 +21,9 @@
 #define CAPAB_OFFSET 17
 #define ACCEPT_PLINKS 0x80
 
+#define TMR_RUNNING_HK  0
+#define TMR_RUNNING_MP  1
+
 int mesh_allocated;
 static struct kmem_cache *rm_cache;
 
@@ -45,6 +48,12 @@ static void ieee80211_mesh_housekeeping_timer(unsigned long data)
         struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
 
         ifmsh->housekeeping = true;
+
+        if (local->quiescing) {
+                set_bit(TMR_RUNNING_HK, &ifmsh->timers_running);
+                return;
+        }
+
         queue_work(local->hw.workqueue, &ifmsh->work);
 }
 
@@ -343,6 +352,11 @@ static void ieee80211_mesh_path_timer(unsigned long data)
         struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
         struct ieee80211_local *local = sdata->local;
 
+        if (local->quiescing) {
+                set_bit(TMR_RUNNING_MP, &ifmsh->timers_running);
+                return;
+        }
+
         queue_work(local->hw.workqueue, &ifmsh->work);
 }
 
@@ -417,13 +431,39 @@ static void ieee80211_mesh_housekeeping(struct ieee80211_sub_if_data *sdata,
 
         free_plinks = mesh_plink_availables(sdata);
         if (free_plinks != sdata->u.mesh.accepting_plinks)
-                ieee80211_if_config(sdata, IEEE80211_IFCC_BEACON);
+                ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON);
 
         ifmsh->housekeeping = false;
         mod_timer(&ifmsh->housekeeping_timer,
                   round_jiffies(jiffies + IEEE80211_MESH_HOUSEKEEPING_INTERVAL));
 }
 
+#ifdef CONFIG_PM
+void ieee80211_mesh_quiesce(struct ieee80211_sub_if_data *sdata)
+{
+        struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
+
+        /* might restart the timer but that doesn't matter */
+        cancel_work_sync(&ifmsh->work);
+
+        /* use atomic bitops in case both timers fire at the same time */
+
+        if (del_timer_sync(&ifmsh->housekeeping_timer))
+                set_bit(TMR_RUNNING_HK, &ifmsh->timers_running);
+        if (del_timer_sync(&ifmsh->mesh_path_timer))
+                set_bit(TMR_RUNNING_MP, &ifmsh->timers_running);
+}
+
+void ieee80211_mesh_restart(struct ieee80211_sub_if_data *sdata)
+{
+        struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
+
+        if (test_and_clear_bit(TMR_RUNNING_HK, &ifmsh->timers_running))
+                add_timer(&ifmsh->housekeeping_timer);
+        if (test_and_clear_bit(TMR_RUNNING_MP, &ifmsh->timers_running))
+                add_timer(&ifmsh->mesh_path_timer);
+}
+#endif
 
 void ieee80211_start_mesh(struct ieee80211_sub_if_data *sdata)
 {
@@ -432,8 +472,8 @@ void ieee80211_start_mesh(struct ieee80211_sub_if_data *sdata)
 
         ifmsh->housekeeping = true;
         queue_work(local->hw.workqueue, &ifmsh->work);
-        ieee80211_if_config(sdata, IEEE80211_IFCC_BEACON |
-                                   IEEE80211_IFCC_BEACON_ENABLED);
+        ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON |
+                                                BSS_CHANGED_BEACON_ENABLED);
 }
 
 void ieee80211_stop_mesh(struct ieee80211_sub_if_data *sdata)
diff --git a/net/mac80211/mesh.h b/net/mac80211/mesh.h
index d891d7ddccd7..c7d72819cdd2 100644
--- a/net/mac80211/mesh.h
+++ b/net/mac80211/mesh.h
@@ -191,12 +191,8 @@ struct mesh_rmc {
 #define PLINK_CATEGORY          30
 #define MESH_PATH_SEL_CATEGORY  32
 
-/* Mesh Header Flags */
-#define IEEE80211S_FLAGS_AE     0x3
-
 /* Public interfaces */
 /* Various */
-int ieee80211_get_mesh_hdrlen(struct ieee80211s_hdr *meshhdr);
 int ieee80211_new_mesh_header(struct ieee80211s_hdr *meshhdr,
                 struct ieee80211_sub_if_data *sdata);
 int mesh_rmc_check(u8 *addr, struct ieee80211s_hdr *mesh_hdr,
@@ -267,6 +263,8 @@ void mesh_path_timer(unsigned long data);
 void mesh_path_flush_by_nexthop(struct sta_info *sta);
 void mesh_path_discard_frame(struct sk_buff *skb,
                 struct ieee80211_sub_if_data *sdata);
+void mesh_path_quiesce(struct ieee80211_sub_if_data *sdata);
+void mesh_path_restart(struct ieee80211_sub_if_data *sdata);
 
 #ifdef CONFIG_MAC80211_MESH
 extern int mesh_allocated;
@@ -294,10 +292,20 @@ static inline void mesh_path_activate(struct mesh_path *mpath)
 
 void ieee80211_mesh_notify_scan_completed(struct ieee80211_local *local);
 
+void ieee80211_mesh_quiesce(struct ieee80211_sub_if_data *sdata);
+void ieee80211_mesh_restart(struct ieee80211_sub_if_data *sdata);
+void mesh_plink_quiesce(struct sta_info *sta);
+void mesh_plink_restart(struct sta_info *sta);
 #else
 #define mesh_allocated  0
 static inline void
 ieee80211_mesh_notify_scan_completed(struct ieee80211_local *local) {}
+static inline void ieee80211_mesh_quiesce(struct ieee80211_sub_if_data *sdata)
+{}
+static inline void ieee80211_mesh_restart(struct ieee80211_sub_if_data *sdata)
+{}
+static inline void mesh_plink_quiesce(struct sta_info *sta) {}
+static inline void mesh_plink_restart(struct sta_info *sta) {}
 #endif
 
 #endif /* IEEE80211S_H */
diff --git a/net/mac80211/mesh_hwmp.c b/net/mac80211/mesh_hwmp.c
index 60b35accda91..003cb470ac84 100644
--- a/net/mac80211/mesh_hwmp.c
+++ b/net/mac80211/mesh_hwmp.c
@@ -836,8 +836,14 @@ void mesh_path_timer(unsigned long data)
         mpath = rcu_dereference(mpath);
         if (!mpath)
                 goto endmpathtimer;
-        spin_lock_bh(&mpath->state_lock);
         sdata = mpath->sdata;
+
+        if (sdata->local->quiescing) {
+                rcu_read_unlock();
+                return;
+        }
+
+        spin_lock_bh(&mpath->state_lock);
         if (mpath->flags & MESH_PATH_RESOLVED ||
                         (!(mpath->flags & MESH_PATH_RESOLVING)))
                 mpath->flags &= ~(MESH_PATH_RESOLVING | MESH_PATH_RESOLVED);
diff --git a/net/mac80211/mesh_plink.c b/net/mac80211/mesh_plink.c
index a8bbdeca013a..cb14253587f1 100644
--- a/net/mac80211/mesh_plink.c
+++ b/net/mac80211/mesh_plink.c
@@ -266,6 +266,11 @@ static void mesh_plink_timer(unsigned long data)
          */
         sta = (struct sta_info *) data;
 
+        if (sta->sdata->local->quiescing) {
+                sta->plink_timer_was_running = true;
+                return;
+        }
+
         spin_lock_bh(&sta->lock);
         if (sta->ignore_plink_timer) {
                 sta->ignore_plink_timer = false;
@@ -322,6 +327,22 @@ static void mesh_plink_timer(unsigned long data)
         }
 }
 
+#ifdef CONFIG_PM
+void mesh_plink_quiesce(struct sta_info *sta)
+{
+        if (del_timer_sync(&sta->plink_timer))
+                sta->plink_timer_was_running = true;
+}
+
+void mesh_plink_restart(struct sta_info *sta)
+{
+        if (sta->plink_timer_was_running) {
+                add_timer(&sta->plink_timer);
+                sta->plink_timer_was_running = false;
+        }
+}
+#endif
+
 static inline void mesh_plink_timer_set(struct sta_info *sta, int timeout)
 {
         sta->plink_timer.expires = jiffies + (HZ * timeout / 1000);
diff --git a/net/mac80211/mlme.c b/net/mac80211/mlme.c
index 132938b073dc..d779c57a8220 100644
--- a/net/mac80211/mlme.c
+++ b/net/mac80211/mlme.c
@@ -17,10 +17,13 @@
 #include <linux/if_arp.h>
 #include <linux/etherdevice.h>
 #include <linux/rtnetlink.h>
+#include <linux/pm_qos_params.h>
+#include <linux/crc32.h>
 #include <net/mac80211.h>
 #include <asm/unaligned.h>
 
 #include "ieee80211_i.h"
+#include "driver-ops.h"
 #include "rate.h"
 #include "led.h"
 
@@ -30,9 +33,13 @@
 #define IEEE80211_ASSOC_TIMEOUT (HZ / 5)
 #define IEEE80211_ASSOC_MAX_TRIES 3
 #define IEEE80211_MONITORING_INTERVAL (2 * HZ)
+#define IEEE80211_PROBE_WAIT (HZ / 5)
 #define IEEE80211_PROBE_IDLE_TIME (60 * HZ)
 #define IEEE80211_RETRY_AUTH_INTERVAL (1 * HZ)
 
+#define TMR_RUNNING_TIMER       0
+#define TMR_RUNNING_CHANSW      1
+
 /* utils */
 static int ecw2cw(int ecw)
 {
@@ -80,6 +87,92 @@ static int ieee80211_compatible_rates(struct ieee80211_bss *bss,
         return count;
 }
 
+/*
+ * ieee80211_enable_ht should be called only after the operating band
+ * has been determined as ht configuration depends on the hw's
+ * HT abilities for a specific band.
+ */
+static u32 ieee80211_enable_ht(struct ieee80211_sub_if_data *sdata,
+                               struct ieee80211_ht_info *hti,
+                               u16 ap_ht_cap_flags)
+{
+        struct ieee80211_local *local = sdata->local;
+        struct ieee80211_supported_band *sband;
+        struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
+        struct sta_info *sta;
+        u32 changed = 0;
+        u16 ht_opmode;
+        bool enable_ht = true, ht_changed;
+        enum nl80211_channel_type channel_type = NL80211_CHAN_NO_HT;
+
+        sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
+
+        /* HT is not supported */
+        if (!sband->ht_cap.ht_supported)
+                enable_ht = false;
+
+        /* check that channel matches the right operating channel */
+        if (local->hw.conf.channel->center_freq !=
+            ieee80211_channel_to_frequency(hti->control_chan))
+                enable_ht = false;
+
+        if (enable_ht) {
+                channel_type = NL80211_CHAN_HT20;
+
+                if (!(ap_ht_cap_flags & IEEE80211_HT_CAP_40MHZ_INTOLERANT) &&
+                    (sband->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) &&
+                    (hti->ht_param & IEEE80211_HT_PARAM_CHAN_WIDTH_ANY)) {
+                        switch(hti->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
+                        case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
+                                if (!(local->hw.conf.channel->flags &
+                                    IEEE80211_CHAN_NO_HT40PLUS))
+                                        channel_type = NL80211_CHAN_HT40PLUS;
+                                break;
+                        case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
+                                if (!(local->hw.conf.channel->flags &
+                                    IEEE80211_CHAN_NO_HT40MINUS))
+                                        channel_type = NL80211_CHAN_HT40MINUS;
+                                break;
+                        }
+                }
+        }
+
+        ht_changed = conf_is_ht(&local->hw.conf) != enable_ht ||
+                     channel_type != local->hw.conf.channel_type;
+
+        local->oper_channel_type = channel_type;
+
+        if (ht_changed) {
+                /* channel_type change automatically detected */
+                ieee80211_hw_config(local, 0);
+
+                rcu_read_lock();
+
+                sta = sta_info_get(local, ifmgd->bssid);
+                if (sta)
+                        rate_control_rate_update(local, sband, sta,
+                                                 IEEE80211_RC_HT_CHANGED);
+
+                rcu_read_unlock();
+        }
+
+        /* disable HT */
+        if (!enable_ht)
+                return 0;
+
+        ht_opmode = le16_to_cpu(hti->operation_mode);
+
+        /* if bss configuration changed store the new one */
+        if (!sdata->ht_opmode_valid ||
+            sdata->vif.bss_conf.ht_operation_mode != ht_opmode) {
+                changed |= BSS_CHANGED_HT;
+                sdata->vif.bss_conf.ht_operation_mode = ht_opmode;
+                sdata->ht_opmode_valid = true;
+        }
+
+        return changed;
+}
+
 /* frame sending functions */
 
 static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata)
@@ -263,13 +356,13 @@ static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata)
 
                 switch (ht_info->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
                 case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
-                        if (flags & IEEE80211_CHAN_NO_FAT_ABOVE) {
+                        if (flags & IEEE80211_CHAN_NO_HT40PLUS) {
                                 cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
                                 cap &= ~IEEE80211_HT_CAP_SGI_40;
                         }
                         break;
                 case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
-                        if (flags & IEEE80211_CHAN_NO_FAT_BELOW) {
+                        if (flags & IEEE80211_CHAN_NO_HT40MINUS) {
                                 cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
                                 cap &= ~IEEE80211_HT_CAP_SGI_40;
                         }
@@ -325,6 +418,10 @@ static void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata,
         /* u.deauth.reason_code == u.disassoc.reason_code */
         mgmt->u.deauth.reason_code = cpu_to_le16(reason);
 
+        if (stype == IEEE80211_STYPE_DEAUTH)
+                cfg80211_send_deauth(sdata->dev, (u8 *) mgmt, skb->len);
+        else
+                cfg80211_send_disassoc(sdata->dev, (u8 *) mgmt, skb->len);
         ieee80211_tx_skb(sdata, skb, ifmgd->flags & IEEE80211_STA_MFP_ENABLED);
 }
 
@@ -359,6 +456,277 @@ void ieee80211_send_pspoll(struct ieee80211_local *local,
         ieee80211_tx_skb(sdata, skb, 0);
 }
 
+void ieee80211_send_nullfunc(struct ieee80211_local *local,
+                             struct ieee80211_sub_if_data *sdata,
+                             int powersave)
+{
+        struct sk_buff *skb;
+        struct ieee80211_hdr *nullfunc;
+        __le16 fc;
+
+        if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
+                return;
+
+        skb = dev_alloc_skb(local->hw.extra_tx_headroom + 24);
+        if (!skb) {
+                printk(KERN_DEBUG "%s: failed to allocate buffer for nullfunc "
+                       "frame\n", sdata->dev->name);
+                return;
+        }
+        skb_reserve(skb, local->hw.extra_tx_headroom);
+
+        nullfunc = (struct ieee80211_hdr *) skb_put(skb, 24);
+        memset(nullfunc, 0, 24);
+        fc = cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_NULLFUNC |
+                         IEEE80211_FCTL_TODS);
+        if (powersave)
+                fc |= cpu_to_le16(IEEE80211_FCTL_PM);
+        nullfunc->frame_control = fc;
+        memcpy(nullfunc->addr1, sdata->u.mgd.bssid, ETH_ALEN);
+        memcpy(nullfunc->addr2, sdata->dev->dev_addr, ETH_ALEN);
+        memcpy(nullfunc->addr3, sdata->u.mgd.bssid, ETH_ALEN);
+
+        ieee80211_tx_skb(sdata, skb, 0);
+}
+
+/* spectrum management related things */
+static void ieee80211_chswitch_work(struct work_struct *work)
+{
+        struct ieee80211_sub_if_data *sdata =
+                container_of(work, struct ieee80211_sub_if_data, u.mgd.chswitch_work);
+        struct ieee80211_bss *bss;
+        struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
+
+        if (!netif_running(sdata->dev))
+                return;
+
+        bss = ieee80211_rx_bss_get(sdata->local, ifmgd->bssid,
+                                   sdata->local->hw.conf.channel->center_freq,
+                                   ifmgd->ssid, ifmgd->ssid_len);
+        if (!bss)
+                goto exit;
+
+        sdata->local->oper_channel = sdata->local->csa_channel;
+        /* XXX: shouldn't really modify cfg80211-owned data! */
+        if (!ieee80211_hw_config(sdata->local, IEEE80211_CONF_CHANGE_CHANNEL))
+                bss->cbss.channel = sdata->local->oper_channel;
+
+        ieee80211_rx_bss_put(sdata->local, bss);
+exit:
+        ifmgd->flags &= ~IEEE80211_STA_CSA_RECEIVED;
+        ieee80211_wake_queues_by_reason(&sdata->local->hw,
+                                        IEEE80211_QUEUE_STOP_REASON_CSA);
+}
+
+static void ieee80211_chswitch_timer(unsigned long data)
+{
+        struct ieee80211_sub_if_data *sdata =
+                (struct ieee80211_sub_if_data *) data;
+        struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
+
+        if (sdata->local->quiescing) {
+                set_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running);
+                return;
+        }
+
+        queue_work(sdata->local->hw.workqueue, &ifmgd->chswitch_work);
+}
+
+void ieee80211_sta_process_chanswitch(struct ieee80211_sub_if_data *sdata,
+                                      struct ieee80211_channel_sw_ie *sw_elem,
+                                      struct ieee80211_bss *bss)
+{
+        struct ieee80211_channel *new_ch;
+        struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
+        int new_freq = ieee80211_channel_to_frequency(sw_elem->new_ch_num);
+
+        if (ifmgd->state != IEEE80211_STA_MLME_ASSOCIATED)
+                return;
+
+        if (sdata->local->sw_scanning || sdata->local->hw_scanning)
+                return;
+
+        /* Disregard subsequent beacons if we are already running a timer
+           processing a CSA */
+
+        if (ifmgd->flags & IEEE80211_STA_CSA_RECEIVED)
+                return;
+
+        new_ch = ieee80211_get_channel(sdata->local->hw.wiphy, new_freq);
+        if (!new_ch || new_ch->flags & IEEE80211_CHAN_DISABLED)
+                return;
+
+        sdata->local->csa_channel = new_ch;
+
+        if (sw_elem->count <= 1) {
+                queue_work(sdata->local->hw.workqueue, &ifmgd->chswitch_work);
+        } else {
+                ieee80211_stop_queues_by_reason(&sdata->local->hw,
+                                        IEEE80211_QUEUE_STOP_REASON_CSA);
+                ifmgd->flags |= IEEE80211_STA_CSA_RECEIVED;
+                mod_timer(&ifmgd->chswitch_timer,
+                          jiffies +
+                          msecs_to_jiffies(sw_elem->count *
+                                           bss->cbss.beacon_interval));
+        }
+}
+
+static void ieee80211_handle_pwr_constr(struct ieee80211_sub_if_data *sdata,
+                                        u16 capab_info, u8 *pwr_constr_elem,
+                                        u8 pwr_constr_elem_len)
+{
+        struct ieee80211_conf *conf = &sdata->local->hw.conf;
+
+        if (!(capab_info & WLAN_CAPABILITY_SPECTRUM_MGMT))
+                return;
+
+        /* Power constraint IE length should be 1 octet */
+        if (pwr_constr_elem_len != 1)
+                return;
+
+        if ((*pwr_constr_elem <= conf->channel->max_power) &&
+            (*pwr_constr_elem != sdata->local->power_constr_level)) {
+                sdata->local->power_constr_level = *pwr_constr_elem;
+                ieee80211_hw_config(sdata->local, 0);
+        }
+}
+
+/* powersave */
+static void ieee80211_enable_ps(struct ieee80211_local *local,
+                                struct ieee80211_sub_if_data *sdata)
+{
+        struct ieee80211_conf *conf = &local->hw.conf;
+
+        /*
+         * If we are scanning right now then the parameters will
+         * take effect when scan finishes.
+         */
+        if (local->hw_scanning || local->sw_scanning)
+                return;
+
+        if (conf->dynamic_ps_timeout > 0 &&
+            !(local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS)) {
+                mod_timer(&local->dynamic_ps_timer, jiffies +
+                          msecs_to_jiffies(conf->dynamic_ps_timeout));
+        } else {
+                if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)
+                        ieee80211_send_nullfunc(local, sdata, 1);
+                conf->flags |= IEEE80211_CONF_PS;
+                ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
+        }
+}
+
+static void ieee80211_change_ps(struct ieee80211_local *local)
+{
+        struct ieee80211_conf *conf = &local->hw.conf;
+
+        if (local->ps_sdata) {
+                ieee80211_enable_ps(local, local->ps_sdata);
+        } else if (conf->flags & IEEE80211_CONF_PS) {
+                conf->flags &= ~IEEE80211_CONF_PS;
+                ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
+                del_timer_sync(&local->dynamic_ps_timer);
+                cancel_work_sync(&local->dynamic_ps_enable_work);
+        }
+}
+
+/* need to hold RTNL or interface lock */
+void ieee80211_recalc_ps(struct ieee80211_local *local, s32 latency)
+{
+        struct ieee80211_sub_if_data *sdata, *found = NULL;
+        int count = 0;
+
+        if (!(local->hw.flags & IEEE80211_HW_SUPPORTS_PS)) {
+                local->ps_sdata = NULL;
+                return;
+        }
+
+        list_for_each_entry(sdata, &local->interfaces, list) {
+                if (!netif_running(sdata->dev))
+                        continue;
+                if (sdata->vif.type != NL80211_IFTYPE_STATION)
+                        continue;
+                found = sdata;
+                count++;
+        }
+
+        if (count == 1 && found->u.mgd.powersave &&
+            (found->u.mgd.flags & IEEE80211_STA_ASSOCIATED) &&
+            !(found->u.mgd.flags & IEEE80211_STA_PROBEREQ_POLL)) {
+                s32 beaconint_us;
+
+                if (latency < 0)
+                        latency = pm_qos_requirement(PM_QOS_NETWORK_LATENCY);
+
+                beaconint_us = ieee80211_tu_to_usec(
+                                        found->vif.bss_conf.beacon_int);
+
+                if (beaconint_us > latency) {
+                        local->ps_sdata = NULL;
+                } else {
+                        u8 dtimper = found->vif.bss_conf.dtim_period;
+                        int maxslp = 1;
+
+                        if (dtimper > 1)
+                                maxslp = min_t(int, dtimper,
+                                                    latency / beaconint_us);
+
+                        local->hw.conf.max_sleep_period = maxslp;
+                        local->ps_sdata = found;
+                }
+        } else {
+                local->ps_sdata = NULL;
+        }
+
+        ieee80211_change_ps(local);
+}
+
+void ieee80211_dynamic_ps_disable_work(struct work_struct *work)
+{
+        struct ieee80211_local *local =
+                container_of(work, struct ieee80211_local,
+                             dynamic_ps_disable_work);
+
+        if (local->hw.conf.flags & IEEE80211_CONF_PS) {
+                local->hw.conf.flags &= ~IEEE80211_CONF_PS;
+                ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
+        }
+
+        ieee80211_wake_queues_by_reason(&local->hw,
+                                        IEEE80211_QUEUE_STOP_REASON_PS);
+}
+
+void ieee80211_dynamic_ps_enable_work(struct work_struct *work)
+{
+        struct ieee80211_local *local =
+                container_of(work, struct ieee80211_local,
+                             dynamic_ps_enable_work);
+        struct ieee80211_sub_if_data *sdata = local->ps_sdata;
+
+        /* can only happen when PS was just disabled anyway */
+        if (!sdata)
+                return;
+
+        if (local->hw.conf.flags & IEEE80211_CONF_PS)
+                return;
+
+        if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)
+                ieee80211_send_nullfunc(local, sdata, 1);
+
+        local->hw.conf.flags |= IEEE80211_CONF_PS;
+        ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
+}
+
+void ieee80211_dynamic_ps_timer(unsigned long data)
+{
+        struct ieee80211_local *local = (void *) data;
+
+        if (local->quiescing)
+                return;
+
+        queue_work(local->hw.workqueue, &local->dynamic_ps_enable_work);
+}
+
 /* MLME */
 static void ieee80211_sta_wmm_params(struct ieee80211_local *local,
                                      struct ieee80211_if_managed *ifmgd,
@@ -424,41 +792,16 @@ static void ieee80211_sta_wmm_params(struct ieee80211_local *local,
 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
                 printk(KERN_DEBUG "%s: WMM queue=%d aci=%d acm=%d aifs=%d "
                        "cWmin=%d cWmax=%d txop=%d\n",
-                       local->mdev->name, queue, aci, acm, params.aifs, params.cw_min,
-                       params.cw_max, params.txop);
+                       wiphy_name(local->hw.wiphy), queue, aci, acm,
+                       params.aifs, params.cw_min, params.cw_max, params.txop);
 #endif
-                if (local->ops->conf_tx &&
-                    local->ops->conf_tx(local_to_hw(local), queue, &params)) {
+                if (drv_conf_tx(local, queue, &params) && local->ops->conf_tx)
                         printk(KERN_DEBUG "%s: failed to set TX queue "
-                               "parameters for queue %d\n", local->mdev->name, queue);
-                }
+                               "parameters for queue %d\n",
+                               wiphy_name(local->hw.wiphy), queue);
         }
 }
 
-static bool ieee80211_check_tim(struct ieee802_11_elems *elems, u16 aid)
-{
-        u8 mask;
-        u8 index, indexn1, indexn2;
-        struct ieee80211_tim_ie *tim = (struct ieee80211_tim_ie *) elems->tim;
-
-        if (unlikely(!tim || elems->tim_len < 4))
-                return false;
-
-        aid &= 0x3fff;
-        index = aid / 8;
-        mask  = 1 << (aid & 7);
-
-        indexn1 = tim->bitmap_ctrl & 0xfe;
-        indexn2 = elems->tim_len + indexn1 - 4;
-
-        if (index < indexn1 || index > indexn2)
-                return false;
-
-        index -= indexn1;
-
-        return !!(tim->virtual_map[index] & mask);
-}
-
 static u32 ieee80211_handle_bss_capability(struct ieee80211_sub_if_data *sdata,
                                            u16 capab, bool erp_valid, u8 erp)
 {
@@ -610,6 +953,7 @@ static void ieee80211_set_associated(struct ieee80211_sub_if_data *sdata,
                 sdata->vif.bss_conf.timestamp = bss->cbss.tsf;
                 sdata->vif.bss_conf.dtim_period = bss->dtim_period;
 
+                bss_info_changed |= BSS_CHANGED_BEACON_INT;
                 bss_info_changed |= ieee80211_handle_bss_capability(sdata,
                         bss->cbss.capability, bss->has_erp_value, bss->erp_value);
 
@@ -632,20 +976,17 @@ static void ieee80211_set_associated(struct ieee80211_sub_if_data *sdata,
          * changed or not.
          */
         bss_info_changed |= BSS_CHANGED_BASIC_RATES;
+
+        /* And the BSSID changed - we're associated now */
+        bss_info_changed |= BSS_CHANGED_BSSID;
+
         ieee80211_bss_info_change_notify(sdata, bss_info_changed);
 
-        if (local->powersave) {
-                if (!(local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS) &&
-                    local->hw.conf.dynamic_ps_timeout > 0) {
-                        mod_timer(&local->dynamic_ps_timer, jiffies +
-                                  msecs_to_jiffies(
-                                        local->hw.conf.dynamic_ps_timeout));
-                } else {
-                        if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)
-                                ieee80211_send_nullfunc(local, sdata, 1);
-                        conf->flags |= IEEE80211_CONF_PS;
-                        ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
-                }
+        /* will be same as sdata */
+        if (local->ps_sdata) {
+                mutex_lock(&local->iflist_mtx);
+                ieee80211_recalc_ps(local, -1);
+                mutex_unlock(&local->iflist_mtx);
         }
 
         netif_tx_start_all_queues(sdata->dev);
@@ -664,7 +1005,8 @@ static void ieee80211_direct_probe(struct ieee80211_sub_if_data *sdata)
                 printk(KERN_DEBUG "%s: direct probe to AP %pM timed out\n",
                        sdata->dev->name, ifmgd->bssid);
                 ifmgd->state = IEEE80211_STA_MLME_DISABLED;
-                ieee80211_sta_send_apinfo(sdata);
+                ieee80211_recalc_idle(local);
+                cfg80211_send_auth_timeout(sdata->dev, ifmgd->bssid);
 
                 /*
                  * Most likely AP is not in the range so remove the
@@ -689,8 +1031,6 @@ static void ieee80211_direct_probe(struct ieee80211_sub_if_data *sdata)
 
         ifmgd->state = IEEE80211_STA_MLME_DIRECT_PROBE;
 
-        set_bit(IEEE80211_STA_REQ_DIRECT_PROBE, &ifmgd->request);
-
         /* Direct probe is sent to broadcast address as some APs
          * will not answer to direct packet in unassociated state.
          */
@@ -714,7 +1054,8 @@ static void ieee80211_authenticate(struct ieee80211_sub_if_data *sdata)
                        " timed out\n",
                        sdata->dev->name, ifmgd->bssid);
                 ifmgd->state = IEEE80211_STA_MLME_DISABLED;
-                ieee80211_sta_send_apinfo(sdata);
+                ieee80211_recalc_idle(local);
+                cfg80211_send_auth_timeout(sdata->dev, ifmgd->bssid);
                 ieee80211_rx_bss_remove(sdata, ifmgd->bssid,
                                 sdata->local->hw.conf.channel->center_freq,
                                 ifmgd->ssid, ifmgd->ssid_len);
@@ -817,9 +1158,16 @@ static void ieee80211_set_disassoc(struct ieee80211_sub_if_data *sdata,
 
         rcu_read_unlock();
 
+        ieee80211_set_wmm_default(sdata);
+
+        ieee80211_recalc_idle(local);
+
         /* channel(_type) changes are handled by ieee80211_hw_config */
         local->oper_channel_type = NL80211_CHAN_NO_HT;
 
+        /* on the next assoc, re-program HT parameters */
+        sdata->ht_opmode_valid = false;
+
         local->power_constr_level = 0;
 
         del_timer_sync(&local->dynamic_ps_timer);
@@ -831,6 +1179,9 @@ static void ieee80211_set_disassoc(struct ieee80211_sub_if_data *sdata,
         }
 
         ieee80211_hw_config(local, config_changed);
+
+        /* And the BSSID changed -- not very interesting here */
+        changed |= BSS_CHANGED_BSSID;
         ieee80211_bss_info_change_notify(sdata, changed);
 
         rcu_read_lock();
@@ -897,7 +1248,8 @@ static void ieee80211_associate(struct ieee80211_sub_if_data *sdata)
                        " timed out\n",
                        sdata->dev->name, ifmgd->bssid);
                 ifmgd->state = IEEE80211_STA_MLME_DISABLED;
-                ieee80211_sta_send_apinfo(sdata);
+                ieee80211_recalc_idle(local);
+                cfg80211_send_assoc_timeout(sdata->dev, ifmgd->bssid);
                 ieee80211_rx_bss_remove(sdata, ifmgd->bssid,
                                 sdata->local->hw.conf.channel->center_freq,
                                 ifmgd->ssid, ifmgd->ssid_len);
@@ -917,6 +1269,7 @@ static void ieee80211_associate(struct ieee80211_sub_if_data *sdata)
                 printk(KERN_DEBUG "%s: mismatch in privacy configuration and "
                        "mixed-cell disabled - abort association\n", sdata->dev->name);
                 ifmgd->state = IEEE80211_STA_MLME_DISABLED;
+                ieee80211_recalc_idle(local);
                 return;
         }
 
@@ -948,6 +1301,17 @@ void ieee80211_beacon_loss_work(struct work_struct *work)
                              u.mgd.beacon_loss_work);
         struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 
+        /*
+         * The driver has already reported this event and we have
+         * already sent a probe request. Maybe the AP died and the
+         * driver keeps reporting until we disassociate... We have
+         * to ignore that because otherwise we would continually
+         * reset the timer and never check whether we received a
+         * probe response!
+         */
+        if (ifmgd->flags & IEEE80211_STA_PROBEREQ_POLL)
+                return;
+
 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
         if (net_ratelimit()) {
                 printk(KERN_DEBUG "%s: driver reports beacon loss from AP %pM "
@@ -957,10 +1321,15 @@ void ieee80211_beacon_loss_work(struct work_struct *work)
 #endif
 
         ifmgd->flags |= IEEE80211_STA_PROBEREQ_POLL;
+
+        mutex_lock(&sdata->local->iflist_mtx);
+        ieee80211_recalc_ps(sdata->local, -1);
+        mutex_unlock(&sdata->local->iflist_mtx);
+
         ieee80211_send_probe_req(sdata, ifmgd->bssid, ifmgd->ssid,
                                  ifmgd->ssid_len, NULL, 0);
 
-        mod_timer(&ifmgd->timer, jiffies + IEEE80211_MONITORING_INTERVAL);
+        mod_timer(&ifmgd->timer, jiffies + IEEE80211_PROBE_WAIT);
 }
 
 void ieee80211_beacon_loss(struct ieee80211_vif *vif)
@@ -977,6 +1346,7 @@ static void ieee80211_associated(struct ieee80211_sub_if_data *sdata)
         struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
         struct ieee80211_local *local = sdata->local;
         struct sta_info *sta;
+        unsigned long last_rx;
         bool disassoc = false;
 
         /* TODO: start monitoring current AP signal quality and number of
@@ -993,17 +1363,21 @@ static void ieee80211_associated(struct ieee80211_sub_if_data *sdata)
                 printk(KERN_DEBUG "%s: No STA entry for own AP %pM\n",
                        sdata->dev->name, ifmgd->bssid);
                 disassoc = true;
-                goto unlock;
+                rcu_read_unlock();
+                goto out;
         }
 
+        last_rx = sta->last_rx;
+        rcu_read_unlock();
+
         if ((ifmgd->flags & IEEE80211_STA_PROBEREQ_POLL) &&
-            time_after(jiffies, sta->last_rx + IEEE80211_MONITORING_INTERVAL)) {
+            time_after(jiffies, last_rx + IEEE80211_PROBE_WAIT)) {
                 printk(KERN_DEBUG "%s: no probe response from AP %pM "
                        "- disassociating\n",
                        sdata->dev->name, ifmgd->bssid);
                 disassoc = true;
                 ifmgd->flags &= ~IEEE80211_STA_PROBEREQ_POLL;
-                goto unlock;
+                goto out;
         }
 
         /*
@@ -1022,27 +1396,31 @@ static void ieee80211_associated(struct ieee80211_sub_if_data *sdata)
                 }
 #endif
                 ifmgd->flags |= IEEE80211_STA_PROBEREQ_POLL;
+                mutex_lock(&local->iflist_mtx);
+                ieee80211_recalc_ps(local, -1);
+                mutex_unlock(&local->iflist_mtx);
                 ieee80211_send_probe_req(sdata, ifmgd->bssid, ifmgd->ssid,
                                          ifmgd->ssid_len, NULL, 0);
-                goto unlock;
-
+                mod_timer(&ifmgd->timer, jiffies + IEEE80211_PROBE_WAIT);
+                goto out;
         }
 
-        if (time_after(jiffies, sta->last_rx + IEEE80211_PROBE_IDLE_TIME)) {
+        if (time_after(jiffies, last_rx + IEEE80211_PROBE_IDLE_TIME)) {
                 ifmgd->flags |= IEEE80211_STA_PROBEREQ_POLL;
+                mutex_lock(&local->iflist_mtx);
+                ieee80211_recalc_ps(local, -1);
+                mutex_unlock(&local->iflist_mtx);
                 ieee80211_send_probe_req(sdata, ifmgd->bssid, ifmgd->ssid,
                                          ifmgd->ssid_len, NULL, 0);
         }
 
- unlock:
-        rcu_read_unlock();
-
-        if (disassoc)
+ out:
+        if (!disassoc)
+                mod_timer(&ifmgd->timer,
+                          jiffies + IEEE80211_MONITORING_INTERVAL);
+        else
                 ieee80211_set_disassoc(sdata, true, true,
                                         WLAN_REASON_PREV_AUTH_NOT_VALID);
-        else
-                mod_timer(&ifmgd->timer, jiffies +
-                                      IEEE80211_MONITORING_INTERVAL);
 }
 
 
@@ -1055,6 +1433,7 @@ static void ieee80211_auth_completed(struct ieee80211_sub_if_data *sdata)
         if (ifmgd->flags & IEEE80211_STA_EXT_SME) {
                 /* Wait for SME to request association */
                 ifmgd->state = IEEE80211_STA_MLME_DISABLED;
+                ieee80211_recalc_idle(sdata->local);
         } else
                 ieee80211_associate(sdata);
 }
@@ -1187,7 +1566,7 @@ static void ieee80211_rx_mgmt_deauth(struct ieee80211_sub_if_data *sdata,
 
         ieee80211_set_disassoc(sdata, true, false, 0);
         ifmgd->flags &= ~IEEE80211_STA_AUTHENTICATED;
-        cfg80211_send_rx_deauth(sdata->dev, (u8 *) mgmt, len);
+        cfg80211_send_deauth(sdata->dev, (u8 *) mgmt, len);
 }
 
 
@@ -1218,7 +1597,7 @@ static void ieee80211_rx_mgmt_disassoc(struct ieee80211_sub_if_data *sdata,
         }
 
         ieee80211_set_disassoc(sdata, false, false, reason_code);
-        cfg80211_send_rx_disassoc(sdata->dev, (u8 *) mgmt, len);
+        cfg80211_send_disassoc(sdata->dev, (u8 *) mgmt, len);
 }
 
 
@@ -1287,6 +1666,12 @@ static void ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data *sdata,
                  * association next time. This works around some broken APs
                  * which do not correctly reject reassociation requests. */
                 ifmgd->flags &= ~IEEE80211_STA_PREV_BSSID_SET;
+                cfg80211_send_rx_assoc(sdata->dev, (u8 *) mgmt, len);
+                if (ifmgd->flags & IEEE80211_STA_EXT_SME) {
+                        /* Wait for SME to decide what to do next */
+                        ifmgd->state = IEEE80211_STA_MLME_DISABLED;
+                        ieee80211_recalc_idle(local);
+                }
                 return;
         }
 
@@ -1340,8 +1725,9 @@ static void ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data *sdata,
          *        to between the sta_info_alloc() and sta_info_insert() above.
          */
 
-        set_sta_flags(sta, WLAN_STA_AUTH | WLAN_STA_ASSOC | WLAN_STA_ASSOC_AP |
-                           WLAN_STA_AUTHORIZED);
+        set_sta_flags(sta, WLAN_STA_AUTH | WLAN_STA_ASSOC | WLAN_STA_ASSOC_AP);
+        if (!(ifmgd->flags & IEEE80211_STA_CONTROL_PORT))
+                set_sta_flags(sta, WLAN_STA_AUTHORIZED);
 
         rates = 0;
         basic_rates = 0;
@@ -1421,6 +1807,8 @@ static void ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data *sdata,
         if (elems.wmm_param)
                 ieee80211_sta_wmm_params(local, ifmgd, elems.wmm_param,
                                          elems.wmm_param_len);
+        else
+                ieee80211_set_wmm_default(sdata);
 
         if (elems.ht_info_elem && elems.wmm_param &&
             (ifmgd->flags & IEEE80211_STA_WMM_ENABLED) &&
@@ -1476,7 +1864,7 @@ static void ieee80211_rx_bss_info(struct ieee80211_sub_if_data *sdata,
             (memcmp(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN) == 0)) {
                 struct ieee80211_channel_sw_ie *sw_elem =
                         (struct ieee80211_channel_sw_ie *)elems->ch_switch_elem;
-                ieee80211_process_chanswitch(sdata, sw_elem, bss);
+                ieee80211_sta_process_chanswitch(sdata, sw_elem, bss);
         }
 
         ieee80211_rx_bss_put(local, bss);
@@ -1507,57 +1895,98 @@ static void ieee80211_rx_mgmt_probe_resp(struct ieee80211_sub_if_data *sdata,
         ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems, false);
 
         /* direct probe may be part of the association flow */
-        if (test_and_clear_bit(IEEE80211_STA_REQ_DIRECT_PROBE,
-                               &ifmgd->request)) {
+        if (ifmgd->state == IEEE80211_STA_MLME_DIRECT_PROBE) {
                 printk(KERN_DEBUG "%s direct probe responded\n",
                        sdata->dev->name);
                 ieee80211_authenticate(sdata);
         }
 
-        if (ifmgd->flags & IEEE80211_STA_PROBEREQ_POLL)
+        if (ifmgd->flags & IEEE80211_STA_PROBEREQ_POLL) {
                 ifmgd->flags &= ~IEEE80211_STA_PROBEREQ_POLL;
+                mutex_lock(&sdata->local->iflist_mtx);
+                ieee80211_recalc_ps(sdata->local, -1);
+                mutex_unlock(&sdata->local->iflist_mtx);
+        }
 }
 
+/*
+ * This is the canonical list of information elements we care about,
+ * the filter code also gives us all changes to the Microsoft OUI
+ * (00:50:F2) vendor IE which is used for WMM which we need to track.
+ *
+ * We implement beacon filtering in software since that means we can
+ * avoid processing the frame here and in cfg80211, and userspace
+ * will not be able to tell whether the hardware supports it or not.
+ *
+ * XXX: This list needs to be dynamic -- userspace needs to be able to
+ *      add items it requires. It also needs to be able to tell us to
+ *      look out for other vendor IEs.
+ */
+static const u64 care_about_ies =
+        (1ULL << WLAN_EID_COUNTRY) |
+        (1ULL << WLAN_EID_ERP_INFO) |
+        (1ULL << WLAN_EID_CHANNEL_SWITCH) |
+        (1ULL << WLAN_EID_PWR_CONSTRAINT) |
+        (1ULL << WLAN_EID_HT_CAPABILITY) |
+        (1ULL << WLAN_EID_HT_INFORMATION);
+
 static void ieee80211_rx_mgmt_beacon(struct ieee80211_sub_if_data *sdata,
                                      struct ieee80211_mgmt *mgmt,
                                      size_t len,
                                      struct ieee80211_rx_status *rx_status)
 {
-        struct ieee80211_if_managed *ifmgd;
+        struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
         size_t baselen;
         struct ieee802_11_elems elems;
         struct ieee80211_local *local = sdata->local;
         u32 changed = 0;
-        bool erp_valid, directed_tim;
+        bool erp_valid, directed_tim = false;
         u8 erp_value = 0;
+        u32 ncrc;
 
         /* Process beacon from the current BSS */
         baselen = (u8 *) mgmt->u.beacon.variable - (u8 *) mgmt;
         if (baselen > len)
                 return;
 
-        ieee802_11_parse_elems(mgmt->u.beacon.variable, len - baselen, &elems);
-
-        ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems, true);
-
-        if (sdata->vif.type != NL80211_IFTYPE_STATION)
+        if (rx_status->freq != local->hw.conf.channel->center_freq)
                 return;
 
-        ifmgd = &sdata->u.mgd;
-
         if (!(ifmgd->flags & IEEE80211_STA_ASSOCIATED) ||
             memcmp(ifmgd->bssid, mgmt->bssid, ETH_ALEN) != 0)
                 return;
 
-        if (rx_status->freq != local->hw.conf.channel->center_freq)
-                return;
+        if (ifmgd->flags & IEEE80211_STA_PROBEREQ_POLL) {
+#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
+                if (net_ratelimit()) {
+                        printk(KERN_DEBUG "%s: cancelling probereq poll due "
+                               "to a received beacon\n", sdata->dev->name);
+                }
+#endif
+                ifmgd->flags &= ~IEEE80211_STA_PROBEREQ_POLL;
+                mutex_lock(&local->iflist_mtx);
+                ieee80211_recalc_ps(local, -1);
+                mutex_unlock(&local->iflist_mtx);
+        }
 
-        ieee80211_sta_wmm_params(local, ifmgd, elems.wmm_param,
-                                 elems.wmm_param_len);
+        ncrc = crc32_be(0, (void *)&mgmt->u.beacon.beacon_int, 4);
+        ncrc = ieee802_11_parse_elems_crc(mgmt->u.beacon.variable,
+                                          len - baselen, &elems,
+                                          care_about_ies, ncrc);
 
-        if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK) {
-                directed_tim = ieee80211_check_tim(&elems, ifmgd->aid);
+        if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)
+                directed_tim = ieee80211_check_tim(elems.tim, elems.tim_len,
+                                                   ifmgd->aid);
 
+        if (ncrc != ifmgd->beacon_crc) {
+                ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems,
+                                      true);
+
+                ieee80211_sta_wmm_params(local, ifmgd, elems.wmm_param,
+                                         elems.wmm_param_len);
+        }
+
+        if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK) {
                 if (directed_tim) {
                         if (local->hw.conf.dynamic_ps_timeout > 0) {
                                 local->hw.conf.flags &= ~IEEE80211_CONF_PS;
@@ -1580,6 +2009,10 @@ static void ieee80211_rx_mgmt_beacon(struct ieee80211_sub_if_data *sdata,
                 }
         }
 
+        if (ncrc == ifmgd->beacon_crc)
+                return;
+        ifmgd->beacon_crc = ncrc;
+
         if (elems.erp_info && elems.erp_info_len >= 1) {
                 erp_valid = true;
                 erp_value = elems.erp_info[0];
@@ -1714,6 +2147,11 @@ static void ieee80211_sta_timer(unsigned long data)
         struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
         struct ieee80211_local *local = sdata->local;
 
+        if (local->quiescing) {
+                set_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running);
+                return;
+        }
+
         set_bit(IEEE80211_STA_REQ_RUN, &ifmgd->request);
         queue_work(local->hw.workqueue, &ifmgd->work);
 }
@@ -1723,10 +2161,8 @@ static void ieee80211_sta_reset_auth(struct ieee80211_sub_if_data *sdata)
         struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
         struct ieee80211_local *local = sdata->local;
 
-        if (local->ops->reset_tsf) {
-                /* Reset own TSF to allow time synchronization work. */
-                local->ops->reset_tsf(local_to_hw(local));
-        }
+        /* Reset own TSF to allow time synchronization work. */
+        drv_reset_tsf(local);
 
         ifmgd->wmm_last_param_set = -1; /* allow any WMM update */
 
@@ -1814,25 +2250,18 @@ static int ieee80211_sta_config_auth(struct ieee80211_sub_if_data *sdata)
                 return 0;
         } else {
                 if (ifmgd->assoc_scan_tries < IEEE80211_ASSOC_SCANS_MAX_TRIES) {
+
                         ifmgd->assoc_scan_tries++;
-                        /* XXX maybe racy? */
-                        if (local->scan_req)
-                                return -1;
-                        memcpy(local->int_scan_req.ssids[0].ssid,
-                               ifmgd->ssid, IEEE80211_MAX_SSID_LEN);
-                        if (ifmgd->flags & IEEE80211_STA_AUTO_SSID_SEL)
-                                local->int_scan_req.ssids[0].ssid_len = 0;
-                        else
-                                local->int_scan_req.ssids[0].ssid_len = ifmgd->ssid_len;
 
-                        if (ieee80211_start_scan(sdata, &local->int_scan_req))
-                                ieee80211_scan_failed(local);
+                        ieee80211_request_internal_scan(sdata, ifmgd->ssid,
+                                                        ssid_len);
 
                         ifmgd->state = IEEE80211_STA_MLME_AUTHENTICATE;
                         set_bit(IEEE80211_STA_REQ_AUTH, &ifmgd->request);
                 } else {
                         ifmgd->assoc_scan_tries = 0;
                         ifmgd->state = IEEE80211_STA_MLME_DISABLED;
+                        ieee80211_recalc_idle(local);
                 }
         }
         return -1;
@@ -1855,6 +2284,17 @@ static void ieee80211_sta_work(struct work_struct *work)
 
         if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
                 return;
+
+        /*
+         * Nothing should have been stuffed into the workqueue during
+         * the suspend->resume cycle. If this WARN is seen then there
+         * is a bug with either the driver suspend or something in
+         * mac80211 stuffing into the workqueue which we haven't yet
+         * cleared during mac80211's suspend cycle.
+         */
+        if (WARN_ON(local->suspended))
+                return;
+
         ifmgd = &sdata->u.mgd;
 
         while ((skb = skb_dequeue(&ifmgd->skb_queue)))
@@ -1864,14 +2304,8 @@ static void ieee80211_sta_work(struct work_struct *work)
             ifmgd->state != IEEE80211_STA_MLME_AUTHENTICATE &&
             ifmgd->state != IEEE80211_STA_MLME_ASSOCIATE &&
             test_and_clear_bit(IEEE80211_STA_REQ_SCAN, &ifmgd->request)) {
-                /*
-                 * The call to ieee80211_start_scan can fail but ieee80211_request_scan
-                 * (which queued ieee80211_sta_work) did not return an error. Thus, call
-                 * ieee80211_scan_failed here if ieee80211_start_scan fails in order to
-                 * notify the scan requester.
-                 */
-                if (ieee80211_start_scan(sdata, local->scan_req))
-                        ieee80211_scan_failed(local);
+                queue_delayed_work(local->hw.workqueue, &local->scan_work,
+                                   round_jiffies_relative(0));
                 return;
         }
 
@@ -1882,6 +2316,8 @@ static void ieee80211_sta_work(struct work_struct *work)
         } else if (!test_and_clear_bit(IEEE80211_STA_REQ_RUN, &ifmgd->request))
                 return;
 
+        ieee80211_recalc_idle(local);
+
         switch (ifmgd->state) {
         case IEEE80211_STA_MLME_DISABLED:
                 break;
@@ -1926,10 +2362,43 @@ static void ieee80211_restart_sta_timer(struct ieee80211_sub_if_data *sdata)
         }
 }
 
+#ifdef CONFIG_PM
+void ieee80211_sta_quiesce(struct ieee80211_sub_if_data *sdata)
+{
+        struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
+
+        /*
+         * we need to use atomic bitops for the running bits
+         * only because both timers might fire at the same
+         * time -- the code here is properly synchronised.
+         */
+
+        cancel_work_sync(&ifmgd->work);
+        cancel_work_sync(&ifmgd->beacon_loss_work);
+        if (del_timer_sync(&ifmgd->timer))
+                set_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running);
+
+        cancel_work_sync(&ifmgd->chswitch_work);
+        if (del_timer_sync(&ifmgd->chswitch_timer))
+                set_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running);
+}
+
+void ieee80211_sta_restart(struct ieee80211_sub_if_data *sdata)
+{
+        struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
+
+        if (test_and_clear_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running))
+                add_timer(&ifmgd->timer);
+        if (test_and_clear_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running))
+                add_timer(&ifmgd->chswitch_timer);
+}
+#endif
+
 /* interface setup */
 void ieee80211_sta_setup_sdata(struct ieee80211_sub_if_data *sdata)
 {
         struct ieee80211_if_managed *ifmgd;
+        u32 hw_flags;
 
         ifmgd = &sdata->u.mgd;
         INIT_WORK(&ifmgd->work, ieee80211_sta_work);
@@ -1949,6 +2418,13 @@ void ieee80211_sta_setup_sdata(struct ieee80211_sub_if_data *sdata)
                 IEEE80211_STA_AUTO_CHANNEL_SEL;
         if (sdata->local->hw.queues >= 4)
                 ifmgd->flags |= IEEE80211_STA_WMM_ENABLED;
+
+        hw_flags = sdata->local->hw.flags;
+
+        if (hw_flags & IEEE80211_HW_SUPPORTS_PS) {
+                ifmgd->powersave = CONFIG_MAC80211_DEFAULT_PS_VALUE;
+                sdata->local->hw.conf.dynamic_ps_timeout = 500;
+        }
 }
 
 /* configuration hooks */
@@ -2032,13 +2508,6 @@ int ieee80211_sta_set_bssid(struct ieee80211_sub_if_data *sdata, u8 *bssid)
                 ifmgd->flags &= ~IEEE80211_STA_BSSID_SET;
         }
 
-        if (netif_running(sdata->dev)) {
-                if (ieee80211_if_config(sdata, IEEE80211_IFCC_BSSID)) {
-                        printk(KERN_DEBUG "%s: Failed to config new BSSID to "
-                               "the low-level driver\n", sdata->dev->name);
-                }
-        }
-
         return ieee80211_sta_commit(sdata);
 }
 
@@ -2047,6 +2516,13 @@ int ieee80211_sta_set_extra_ie(struct ieee80211_sub_if_data *sdata,
 {
         struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 
+        if (len == 0 && ifmgd->extra_ie_len == 0)
+                return -EALREADY;
+
+        if (len == ifmgd->extra_ie_len && ifmgd->extra_ie &&
+            memcmp(ifmgd->extra_ie, ie, len) == 0)
+                return -EALREADY;
+
         kfree(ifmgd->extra_ie);
         if (len == 0) {
                 ifmgd->extra_ie = NULL;
@@ -2068,9 +2544,6 @@ int ieee80211_sta_deauthenticate(struct ieee80211_sub_if_data *sdata, u16 reason
         printk(KERN_DEBUG "%s: deauthenticating by local choice (reason=%d)\n",
                sdata->dev->name, reason);
 
-        if (sdata->vif.type != NL80211_IFTYPE_STATION)
-                return -EINVAL;
-
         ieee80211_set_disassoc(sdata, true, true, reason);
         return 0;
 }
@@ -2082,9 +2555,6 @@ int ieee80211_sta_disassociate(struct ieee80211_sub_if_data *sdata, u16 reason)
         printk(KERN_DEBUG "%s: disassociating by local choice (reason=%d)\n",
                sdata->dev->name, reason);
 
-        if (sdata->vif.type != NL80211_IFTYPE_STATION)
-                return -EINVAL;
-
         if (!(ifmgd->flags & IEEE80211_STA_ASSOCIATED))
                 return -ENOLINK;
 
@@ -2104,75 +2574,17 @@ void ieee80211_mlme_notify_scan_completed(struct ieee80211_local *local)
         rcu_read_unlock();
 }
 
-void ieee80211_dynamic_ps_disable_work(struct work_struct *work)
+int ieee80211_max_network_latency(struct notifier_block *nb,
+                                  unsigned long data, void *dummy)
 {
+        s32 latency_usec = (s32) data;
         struct ieee80211_local *local =
-                container_of(work, struct ieee80211_local,
-                             dynamic_ps_disable_work);
-
-        if (local->hw.conf.flags & IEEE80211_CONF_PS) {
-                local->hw.conf.flags &= ~IEEE80211_CONF_PS;
-                ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
-        }
-
-        ieee80211_wake_queues_by_reason(&local->hw,
-                                        IEEE80211_QUEUE_STOP_REASON_PS);
-}
-
-void ieee80211_dynamic_ps_enable_work(struct work_struct *work)
-{
-        struct ieee80211_local *local =
-                container_of(work, struct ieee80211_local,
-                             dynamic_ps_enable_work);
-        /* XXX: using scan_sdata is completely broken! */
-        struct ieee80211_sub_if_data *sdata = local->scan_sdata;
-
-        if (local->hw.conf.flags & IEEE80211_CONF_PS)
-                return;
-
-        if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK && sdata)
-                ieee80211_send_nullfunc(local, sdata, 1);
-
-        local->hw.conf.flags |= IEEE80211_CONF_PS;
-        ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
-}
-
-void ieee80211_dynamic_ps_timer(unsigned long data)
-{
-        struct ieee80211_local *local = (void *) data;
-
-        queue_work(local->hw.workqueue, &local->dynamic_ps_enable_work);
-}
-
-void ieee80211_send_nullfunc(struct ieee80211_local *local,
-                             struct ieee80211_sub_if_data *sdata,
-                             int powersave)
-{
-        struct sk_buff *skb;
-        struct ieee80211_hdr *nullfunc;
-        __le16 fc;
+                container_of(nb, struct ieee80211_local,
+                             network_latency_notifier);
 
-        if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
-                return;
-
-        skb = dev_alloc_skb(local->hw.extra_tx_headroom + 24);
-        if (!skb) {
-                printk(KERN_DEBUG "%s: failed to allocate buffer for nullfunc "
-                       "frame\n", sdata->dev->name);
-                return;
-        }
-        skb_reserve(skb, local->hw.extra_tx_headroom);
+        mutex_lock(&local->iflist_mtx);
+        ieee80211_recalc_ps(local, latency_usec);
+        mutex_unlock(&local->iflist_mtx);
 
-        nullfunc = (struct ieee80211_hdr *) skb_put(skb, 24);
-        memset(nullfunc, 0, 24);
-        fc = cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_NULLFUNC |
-                         IEEE80211_FCTL_TODS);
-        if (powersave)
-                fc |= cpu_to_le16(IEEE80211_FCTL_PM);
-        nullfunc->frame_control = fc;
-        memcpy(nullfunc->addr1, sdata->u.mgd.bssid, ETH_ALEN);
-        memcpy(nullfunc->addr2, sdata->dev->dev_addr, ETH_ALEN);
-        memcpy(nullfunc->addr3, sdata->u.mgd.bssid, ETH_ALEN);
-
-        ieee80211_tx_skb(sdata, skb, 0);
+        return 0;
 }
diff --git a/net/mac80211/pm.c b/net/mac80211/pm.c
index 81985d27cbda..7a549f9deb96 100644
--- a/net/mac80211/pm.c
+++ b/net/mac80211/pm.c
@@ -2,6 +2,8 @@
 #include <net/rtnetlink.h>
 
 #include "ieee80211_i.h"
+#include "mesh.h"
+#include "driver-ops.h"
 #include "led.h"
 
 int __ieee80211_suspend(struct ieee80211_hw *hw)
@@ -12,11 +14,30 @@ int __ieee80211_suspend(struct ieee80211_hw *hw)
         struct sta_info *sta;
         unsigned long flags;
 
+        ieee80211_scan_cancel(local);
+
         ieee80211_stop_queues_by_reason(hw,
                         IEEE80211_QUEUE_STOP_REASON_SUSPEND);
 
+        /* flush out all packets */
+        synchronize_net();
+
+        local->quiescing = true;
+        /* make quiescing visible to timers everywhere */
+        mb();
+
         flush_workqueue(local->hw.workqueue);
 
+        /* Don't try to run timers while suspended. */
+        del_timer_sync(&local->sta_cleanup);
+
+         /*
+         * Note that this particular timer doesn't need to be
+         * restarted at resume.
+         */
+        cancel_work_sync(&local->dynamic_ps_enable_work);
+        del_timer_sync(&local->dynamic_ps_timer);
+
         /* disable keys */
         list_for_each_entry(sdata, &local->interfaces, list)
                 ieee80211_disable_keys(sdata);
@@ -34,157 +55,70 @@ int __ieee80211_suspend(struct ieee80211_hw *hw)
 
         rcu_read_unlock();
 
-        /* remove STAs */
-        if (local->ops->sta_notify) {
-                spin_lock_irqsave(&local->sta_lock, flags);
-                list_for_each_entry(sta, &local->sta_list, list) {
-                        if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
-                                sdata = container_of(sdata->bss,
-                                             struct ieee80211_sub_if_data,
-                                             u.ap);
-
-                        local->ops->sta_notify(hw, &sdata->vif,
-                                STA_NOTIFY_REMOVE, &sta->sta);
-                }
-                spin_unlock_irqrestore(&local->sta_lock, flags);
-        }
-
-        /* remove all interfaces */
-        list_for_each_entry(sdata, &local->interfaces, list) {
-                if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
-                    sdata->vif.type != NL80211_IFTYPE_MONITOR &&
-                    netif_running(sdata->dev)) {
-                        conf.vif = &sdata->vif;
-                        conf.type = sdata->vif.type;
-                        conf.mac_addr = sdata->dev->dev_addr;
-                        local->ops->remove_interface(hw, &conf);
-                }
-        }
-
         /* flush again, in case driver queued work */
         flush_workqueue(local->hw.workqueue);
 
-        /* stop hardware */
+        /* stop hardware - this must stop RX */
         if (local->open_count) {
                 ieee80211_led_radio(local, false);
-                local->ops->stop(hw);
-        }
-        return 0;
-}
-
-int __ieee80211_resume(struct ieee80211_hw *hw)
-{
-        struct ieee80211_local *local = hw_to_local(hw);
-        struct ieee80211_sub_if_data *sdata;
-        struct ieee80211_if_init_conf conf;
-        struct sta_info *sta;
-        unsigned long flags;
-        int res;
-
-        /* restart hardware */
-        if (local->open_count) {
-                res = local->ops->start(hw);
-
-                ieee80211_led_radio(local, hw->conf.radio_enabled);
+                drv_stop(local);
         }
 
-        /* add interfaces */
-        list_for_each_entry(sdata, &local->interfaces, list) {
-                if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
-                    sdata->vif.type != NL80211_IFTYPE_MONITOR &&
-                    netif_running(sdata->dev)) {
-                        conf.vif = &sdata->vif;
-                        conf.type = sdata->vif.type;
-                        conf.mac_addr = sdata->dev->dev_addr;
-                        res = local->ops->add_interface(hw, &conf);
-                }
-        }
-
-        /* add STAs back */
-        if (local->ops->sta_notify) {
-                spin_lock_irqsave(&local->sta_lock, flags);
-                list_for_each_entry(sta, &local->sta_list, list) {
+        /* remove STAs */
+        spin_lock_irqsave(&local->sta_lock, flags);
+        list_for_each_entry(sta, &local->sta_list, list) {
+                if (local->ops->sta_notify) {
+                        sdata = sta->sdata;
                         if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
                                 sdata = container_of(sdata->bss,
                                              struct ieee80211_sub_if_data,
                                              u.ap);
 
-                        local->ops->sta_notify(hw, &sdata->vif,
-                                STA_NOTIFY_ADD, &sta->sta);
+                        drv_sta_notify(local, &sdata->vif, STA_NOTIFY_REMOVE,
+                                       &sta->sta);
                 }
-                spin_unlock_irqrestore(&local->sta_lock, flags);
-        }
-
-        /* Clear Suspend state so that ADDBA requests can be processed */
-
-        rcu_read_lock();
 
-        if (hw->flags & IEEE80211_HW_AMPDU_AGGREGATION) {
-                list_for_each_entry_rcu(sta, &local->sta_list, list) {
-                        clear_sta_flags(sta, WLAN_STA_SUSPEND);
-                }
+                mesh_plink_quiesce(sta);
         }
+        spin_unlock_irqrestore(&local->sta_lock, flags);
 
-        rcu_read_unlock();
-
-        /* add back keys */
-        list_for_each_entry(sdata, &local->interfaces, list)
-                if (netif_running(sdata->dev))
-                        ieee80211_enable_keys(sdata);
-
-        /* setup RTS threshold */
-        if (local->ops->set_rts_threshold)
-                local->ops->set_rts_threshold(hw, local->rts_threshold);
-
-        /* reconfigure hardware */
-        ieee80211_hw_config(local, ~0);
-
-        netif_addr_lock_bh(local->mdev);
-        ieee80211_configure_filter(local);
-        netif_addr_unlock_bh(local->mdev);
-
-        /* Finally also reconfigure all the BSS information */
+        /* remove all interfaces */
         list_for_each_entry(sdata, &local->interfaces, list) {
-                u32 changed = ~0;
-                if (!netif_running(sdata->dev))
-                        continue;
-                switch (sdata->vif.type) {
+                switch(sdata->vif.type) {
                 case NL80211_IFTYPE_STATION:
-                        /* disable beacon change bits */
-                        changed &= ~IEEE80211_IFCC_BEACON;
-                        /* fall through */
+                        ieee80211_sta_quiesce(sdata);
+                        break;
                 case NL80211_IFTYPE_ADHOC:
-                case NL80211_IFTYPE_AP:
-                case NL80211_IFTYPE_MESH_POINT:
-                        /*
-                         * Driver's config_interface can fail if rfkill is
-                         * enabled. Accommodate this return code.
-                         * FIXME: When mac80211 has knowledge of rfkill
-                         * state the code below can change back to:
-                         *   WARN(ieee80211_if_config(sdata, changed));
-                         *   ieee80211_bss_info_change_notify(sdata, ~0);
-                         */
-                        if (ieee80211_if_config(sdata, changed))
-                                printk(KERN_DEBUG "%s: failed to configure interface during resume\n",
-                                       sdata->dev->name);
-                        else
-                                ieee80211_bss_info_change_notify(sdata, ~0);
+                        ieee80211_ibss_quiesce(sdata);
                         break;
-                case NL80211_IFTYPE_WDS:
+                case NL80211_IFTYPE_MESH_POINT:
+                        ieee80211_mesh_quiesce(sdata);
                         break;
                 case NL80211_IFTYPE_AP_VLAN:
                 case NL80211_IFTYPE_MONITOR:
-                        /* ignore virtual */
-                        break;
-                case NL80211_IFTYPE_UNSPECIFIED:
-                case __NL80211_IFTYPE_AFTER_LAST:
-                        WARN_ON(1);
+                        /* don't tell driver about this */
+                        continue;
+                default:
                         break;
                 }
+
+                if (!netif_running(sdata->dev))
+                        continue;
+
+                conf.vif = &sdata->vif;
+                conf.type = sdata->vif.type;
+                conf.mac_addr = sdata->dev->dev_addr;
+                drv_remove_interface(local, &conf);
         }
 
-        ieee80211_wake_queues_by_reason(hw,
-                        IEEE80211_QUEUE_STOP_REASON_SUSPEND);
+        local->suspended = true;
+        local->quiescing = false;
 
         return 0;
 }
+
+/*
+ * __ieee80211_resume() is a static inline which just calls
+ * ieee80211_reconfig(), which is also needed for hardware
+ * hang/firmware failure/etc. recovery.
+ */
diff --git a/net/mac80211/rc80211_minstrel.c b/net/mac80211/rc80211_minstrel.c
index d9233ec50610..b218b98fba7f 100644
--- a/net/mac80211/rc80211_minstrel.c
+++ b/net/mac80211/rc80211_minstrel.c
@@ -80,8 +80,7 @@ use_low_rate(struct sk_buff *skb)
         fc = le16_to_cpu(hdr->frame_control);
 
         return ((info->flags & IEEE80211_TX_CTL_NO_ACK) ||
-                (fc & IEEE80211_FCTL_FTYPE) != IEEE80211_FTYPE_DATA ||
-                is_multicast_ether_addr(hdr->addr1));
+                (fc & IEEE80211_FCTL_FTYPE) != IEEE80211_FTYPE_DATA);
 }
 
 
@@ -216,7 +215,7 @@ minstrel_get_next_sample(struct minstrel_sta_info *mi)
         unsigned int sample_ndx;
         sample_ndx = SAMPLE_TBL(mi, mi->sample_idx, mi->sample_column);
         mi->sample_idx++;
-        if (mi->sample_idx > (mi->n_rates - 2)) {
+        if ((int) mi->sample_idx > (mi->n_rates - 2)) {
                 mi->sample_idx = 0;
                 mi->sample_column++;
                 if (mi->sample_column >= SAMPLE_COLUMNS)
@@ -245,7 +244,10 @@ minstrel_get_rate(void *priv, struct ieee80211_sta *sta,
 
         if (!sta || !mi || use_low_rate(skb)) {
                 ar[0].idx = rate_lowest_index(sband, sta);
-                ar[0].count = mp->max_retry;
+                if (info->flags & IEEE80211_TX_CTL_NO_ACK)
+                        ar[0].count = 1;
+                else
+                        ar[0].count = mp->max_retry;
                 return;
         }
 
diff --git a/net/mac80211/rc80211_pid_algo.c b/net/mac80211/rc80211_pid_algo.c
index 8bef9a1262ff..a0bef767ceb5 100644
--- a/net/mac80211/rc80211_pid_algo.c
+++ b/net/mac80211/rc80211_pid_algo.c
@@ -289,13 +289,15 @@ rate_control_pid_get_rate(void *priv, struct ieee80211_sta *sta,
                 info->control.rates[0].count =
                         txrc->hw->conf.short_frame_max_tx_count;
 
-        /* Send management frames and broadcast/multicast data using lowest
-         * rate. */
+        /* Send management frames and NO_ACK data using lowest rate. */
         fc = le16_to_cpu(hdr->frame_control);
         if (!sta || !spinfo ||
             (fc & IEEE80211_FCTL_FTYPE) != IEEE80211_FTYPE_DATA ||
-            is_multicast_ether_addr(hdr->addr1)) {
+            info->flags & IEEE80211_TX_CTL_NO_ACK) {
                 info->control.rates[0].idx = rate_lowest_index(sband, sta);
+                if (info->flags & IEEE80211_TX_CTL_NO_ACK)
+                        info->control.rates[0].count = 1;
+
                 return;
         }
 
diff --git a/net/mac80211/rx.c b/net/mac80211/rx.c
index 9776f73c51ad..de5bba7f910a 100644
--- a/net/mac80211/rx.c
+++ b/net/mac80211/rx.c
@@ -19,6 +19,7 @@
 #include <net/ieee80211_radiotap.h>
 
 #include "ieee80211_i.h"
+#include "driver-ops.h"
 #include "led.h"
 #include "mesh.h"
 #include "wep.h"
@@ -629,15 +630,6 @@ ieee80211_rx_h_decrypt(struct ieee80211_rx_data *rx)
          * possible.
          */
 
-        if (!ieee80211_has_protected(hdr->frame_control)) {
-                if (!ieee80211_is_mgmt(hdr->frame_control) ||
-                    rx->sta == NULL || !test_sta_flags(rx->sta, WLAN_STA_MFP))
-                        return RX_CONTINUE;
-                mmie_keyidx = ieee80211_get_mmie_keyidx(rx->skb);
-                if (mmie_keyidx < 0)
-                        return RX_CONTINUE;
-        }
-
         /*
          * No point in finding a key and decrypting if the frame is neither
          * addressed to us nor a multicast frame.
@@ -648,8 +640,14 @@ ieee80211_rx_h_decrypt(struct ieee80211_rx_data *rx)
         if (rx->sta)
                 stakey = rcu_dereference(rx->sta->key);
 
+        if (!ieee80211_has_protected(hdr->frame_control))
+                mmie_keyidx = ieee80211_get_mmie_keyidx(rx->skb);
+
         if (!is_multicast_ether_addr(hdr->addr1) && stakey) {
                 rx->key = stakey;
+                /* Skip decryption if the frame is not protected. */
+                if (!ieee80211_has_protected(hdr->frame_control))
+                        return RX_CONTINUE;
         } else if (mmie_keyidx >= 0) {
                 /* Broadcast/multicast robust management frame / BIP */
                 if ((rx->status->flag & RX_FLAG_DECRYPTED) &&
@@ -660,6 +658,21 @@ ieee80211_rx_h_decrypt(struct ieee80211_rx_data *rx)
                     mmie_keyidx >= NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS)
                         return RX_DROP_MONITOR; /* unexpected BIP keyidx */
                 rx->key = rcu_dereference(rx->sdata->keys[mmie_keyidx]);
+        } else if (!ieee80211_has_protected(hdr->frame_control)) {
+                /*
+                 * The frame was not protected, so skip decryption. However, we
+                 * need to set rx->key if there is a key that could have been
+                 * used so that the frame may be dropped if encryption would
+                 * have been expected.
+                 */
+                struct ieee80211_key *key = NULL;
+                if (ieee80211_is_mgmt(hdr->frame_control) &&
+                    is_multicast_ether_addr(hdr->addr1) &&
+                    (key = rcu_dereference(rx->sdata->default_mgmt_key)))
+                        rx->key = key;
+                else if ((key = rcu_dereference(rx->sdata->default_key)))
+                        rx->key = key;
+                return RX_CONTINUE;
         } else {
                 /*
                  * The device doesn't give us the IV so we won't be
@@ -773,9 +786,7 @@ static void ap_sta_ps_start(struct sta_info *sta)
 
         atomic_inc(&sdata->bss->num_sta_ps);
         set_and_clear_sta_flags(sta, WLAN_STA_PS, WLAN_STA_PSPOLL);
-        if (local->ops->sta_notify)
-                local->ops->sta_notify(local_to_hw(local), &sdata->vif,
-                                        STA_NOTIFY_SLEEP, &sta->sta);
+        drv_sta_notify(local, &sdata->vif, STA_NOTIFY_SLEEP, &sta->sta);
 #ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
         printk(KERN_DEBUG "%s: STA %pM aid %d enters power save mode\n",
                sdata->dev->name, sta->sta.addr, sta->sta.aid);
@@ -786,15 +797,12 @@ static int ap_sta_ps_end(struct sta_info *sta)
 {
         struct ieee80211_sub_if_data *sdata = sta->sdata;
         struct ieee80211_local *local = sdata->local;
-        struct sk_buff *skb;
-        int sent = 0;
+        int sent, buffered;
 
         atomic_dec(&sdata->bss->num_sta_ps);
 
         clear_sta_flags(sta, WLAN_STA_PS | WLAN_STA_PSPOLL);
-        if (local->ops->sta_notify)
-                local->ops->sta_notify(local_to_hw(local), &sdata->vif,
-                                        STA_NOTIFY_AWAKE, &sta->sta);
+        drv_sta_notify(local, &sdata->vif, STA_NOTIFY_AWAKE, &sta->sta);
 
         if (!skb_queue_empty(&sta->ps_tx_buf))
                 sta_info_clear_tim_bit(sta);
@@ -805,22 +813,16 @@ static int ap_sta_ps_end(struct sta_info *sta)
 #endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */
 
         /* Send all buffered frames to the station */
-        while ((skb = skb_dequeue(&sta->tx_filtered)) != NULL) {
-                sent++;
-                skb->requeue = 1;
-                dev_queue_xmit(skb);
-        }
-        while ((skb = skb_dequeue(&sta->ps_tx_buf)) != NULL) {
-                local->total_ps_buffered--;
-                sent++;
+        sent = ieee80211_add_pending_skbs(local, &sta->tx_filtered);
+        buffered = ieee80211_add_pending_skbs(local, &sta->ps_tx_buf);
+        sent += buffered;
+        local->total_ps_buffered -= buffered;
+
 #ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
-                printk(KERN_DEBUG "%s: STA %pM aid %d send PS frame "
-                       "since STA not sleeping anymore\n", sdata->dev->name,
-                       sta->sta.addr, sta->sta.aid);
+        printk(KERN_DEBUG "%s: STA %pM aid %d sending %d filtered/%d PS frames "
+               "since STA not sleeping anymore\n", sdata->dev->name,
+               sta->sta.addr, sta->sta.aid, sent - buffered, buffered);
 #endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */
-                skb->requeue = 1;
-                dev_queue_xmit(skb);
-        }
 
         return sent;
 }
@@ -1212,109 +1214,38 @@ ieee80211_drop_unencrypted(struct ieee80211_rx_data *rx, __le16 fc)
         /* Drop unencrypted frames if key is set. */
         if (unlikely(!ieee80211_has_protected(fc) &&
                      !ieee80211_is_nullfunc(fc) &&
-                     (!ieee80211_is_mgmt(fc) ||
-                      (ieee80211_is_unicast_robust_mgmt_frame(rx->skb) &&
-                       rx->sta && test_sta_flags(rx->sta, WLAN_STA_MFP))) &&
-                     (rx->key || rx->sdata->drop_unencrypted)))
-                return -EACCES;
-        /* BIP does not use Protected field, so need to check MMIE */
-        if (unlikely(rx->sta && test_sta_flags(rx->sta, WLAN_STA_MFP) &&
-                     ieee80211_is_multicast_robust_mgmt_frame(rx->skb) &&
-                     ieee80211_get_mmie_keyidx(rx->skb) < 0 &&
+                     ieee80211_is_data(fc) &&
                      (rx->key || rx->sdata->drop_unencrypted)))
                 return -EACCES;
+        if (rx->sta && test_sta_flags(rx->sta, WLAN_STA_MFP)) {
+                if (unlikely(ieee80211_is_unicast_robust_mgmt_frame(rx->skb) &&
+                             rx->key))
+                        return -EACCES;
+                /* BIP does not use Protected field, so need to check MMIE */
+                if (unlikely(ieee80211_is_multicast_robust_mgmt_frame(rx->skb)
+                             && ieee80211_get_mmie_keyidx(rx->skb) < 0 &&
+                             rx->key))
+                        return -EACCES;
+                /*
+                 * When using MFP, Action frames are not allowed prior to
+                 * having configured keys.
+                 */
+                if (unlikely(ieee80211_is_action(fc) && !rx->key &&
+                             ieee80211_is_robust_mgmt_frame(
+                                     (struct ieee80211_hdr *) rx->skb->data)))
+                        return -EACCES;
+        }
 
         return 0;
 }
 
 static int
-ieee80211_data_to_8023(struct ieee80211_rx_data *rx)
+__ieee80211_data_to_8023(struct ieee80211_rx_data *rx)
 {
         struct net_device *dev = rx->dev;
-        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) rx->skb->data;
-        u16 hdrlen, ethertype;
-        u8 *payload;
-        u8 dst[ETH_ALEN];
-        u8 src[ETH_ALEN] __aligned(2);
-        struct sk_buff *skb = rx->skb;
         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 
-        if (unlikely(!ieee80211_is_data_present(hdr->frame_control)))
-                return -1;
-
-        hdrlen = ieee80211_hdrlen(hdr->frame_control);
-
-        /* convert IEEE 802.11 header + possible LLC headers into Ethernet
-         * header
-         * IEEE 802.11 address fields:
-         * ToDS FromDS Addr1 Addr2 Addr3 Addr4
-         *   0     0   DA    SA    BSSID n/a
-         *   0     1   DA    BSSID SA    n/a
-         *   1     0   BSSID SA    DA    n/a
-         *   1     1   RA    TA    DA    SA
-         */
-        memcpy(dst, ieee80211_get_DA(hdr), ETH_ALEN);
-        memcpy(src, ieee80211_get_SA(hdr), ETH_ALEN);
-
-        switch (hdr->frame_control &
-                cpu_to_le16(IEEE80211_FCTL_TODS | IEEE80211_FCTL_FROMDS)) {
-        case cpu_to_le16(IEEE80211_FCTL_TODS):
-                if (unlikely(sdata->vif.type != NL80211_IFTYPE_AP &&
-                             sdata->vif.type != NL80211_IFTYPE_AP_VLAN))
-                        return -1;
-                break;
-        case cpu_to_le16(IEEE80211_FCTL_TODS | IEEE80211_FCTL_FROMDS):
-                if (unlikely(sdata->vif.type != NL80211_IFTYPE_WDS &&
-                             sdata->vif.type != NL80211_IFTYPE_MESH_POINT))
-                        return -1;
-                if (ieee80211_vif_is_mesh(&sdata->vif)) {
-                        struct ieee80211s_hdr *meshdr = (struct ieee80211s_hdr *)
-                                (skb->data + hdrlen);
-                        hdrlen += ieee80211_get_mesh_hdrlen(meshdr);
-                        if (meshdr->flags & MESH_FLAGS_AE_A5_A6) {
-                                memcpy(dst, meshdr->eaddr1, ETH_ALEN);
-                                memcpy(src, meshdr->eaddr2, ETH_ALEN);
-                        }
-                }
-                break;
-        case cpu_to_le16(IEEE80211_FCTL_FROMDS):
-                if (sdata->vif.type != NL80211_IFTYPE_STATION ||
-                    (is_multicast_ether_addr(dst) &&
-                     !compare_ether_addr(src, dev->dev_addr)))
-                        return -1;
-                break;
-        case cpu_to_le16(0):
-                if (sdata->vif.type != NL80211_IFTYPE_ADHOC)
-                        return -1;
-                break;
-        }
-
-        if (unlikely(skb->len - hdrlen < 8))
-                return -1;
-
-        payload = skb->data + hdrlen;
-        ethertype = (payload[6] << 8) | payload[7];
-
-        if (likely((compare_ether_addr(payload, rfc1042_header) == 0 &&
-                    ethertype != ETH_P_AARP && ethertype != ETH_P_IPX) ||
-                   compare_ether_addr(payload, bridge_tunnel_header) == 0)) {
-                /* remove RFC1042 or Bridge-Tunnel encapsulation and
-                 * replace EtherType */
-                skb_pull(skb, hdrlen + 6);
-                memcpy(skb_push(skb, ETH_ALEN), src, ETH_ALEN);
-                memcpy(skb_push(skb, ETH_ALEN), dst, ETH_ALEN);
-        } else {
-                struct ethhdr *ehdr;
-                __be16 len;
-
-                skb_pull(skb, hdrlen);
-                len = htons(skb->len);
-                ehdr = (struct ethhdr *) skb_push(skb, sizeof(struct ethhdr));
-                memcpy(ehdr->h_dest, dst, ETH_ALEN);
-                memcpy(ehdr->h_source, src, ETH_ALEN);
-                ehdr->h_proto = len;
-        }
-        return 0;
+        return ieee80211_data_to_8023(rx->skb, dev->dev_addr, sdata->vif.type);
 }
 
 /*
@@ -1397,7 +1328,7 @@ ieee80211_deliver_skb(struct ieee80211_rx_data *rx)
                  * mac80211. That also explains the __skb_push()
                  * below.
                  */
-                align = (unsigned long)skb->data & 3;
+                align = ((unsigned long)(skb->data + sizeof(struct ethhdr))) & 3;
                 if (align) {
                         if (WARN_ON(skb_headroom(skb) < 3)) {
                                 dev_kfree_skb(skb);
@@ -1453,7 +1384,7 @@ ieee80211_rx_h_amsdu(struct ieee80211_rx_data *rx)
         if (!(rx->flags & IEEE80211_RX_AMSDU))
                 return RX_CONTINUE;
 
-        err = ieee80211_data_to_8023(rx);
+        err = __ieee80211_data_to_8023(rx);
         if (unlikely(err))
                 return RX_DROP_UNUSABLE;
 
@@ -1639,7 +1570,7 @@ ieee80211_rx_h_data(struct ieee80211_rx_data *rx)
         if (unlikely(!ieee80211_is_data_present(hdr->frame_control)))
                 return RX_DROP_MONITOR;
 
-        err = ieee80211_data_to_8023(rx);
+        err = __ieee80211_data_to_8023(rx);
         if (unlikely(err))
                 return RX_DROP_UNUSABLE;
 
@@ -1827,6 +1758,9 @@ ieee80211_rx_h_action(struct ieee80211_rx_data *rx)
                                    sizeof(mgmt->u.action.u.chan_switch)))
                                 return RX_DROP_MONITOR;
 
+                        if (sdata->vif.type != NL80211_IFTYPE_STATION)
+                                return RX_DROP_MONITOR;
+
                         if (memcmp(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN))
                                 return RX_DROP_MONITOR;
 
@@ -1837,7 +1771,7 @@ ieee80211_rx_h_action(struct ieee80211_rx_data *rx)
                         if (!bss)
                                 return RX_DROP_MONITOR;
 
-                        ieee80211_process_chanswitch(sdata,
+                        ieee80211_sta_process_chanswitch(sdata,
                                      &mgmt->u.action.u.chan_switch.sw_elem, bss);
                         ieee80211_rx_bss_put(local, bss);
                         break;
@@ -1932,7 +1866,7 @@ static void ieee80211_rx_michael_mic_report(struct net_device *dev,
             !ieee80211_is_auth(hdr->frame_control))
                 goto ignore;
 
-        mac80211_ev_michael_mic_failure(rx->sdata, keyidx, hdr);
+        mac80211_ev_michael_mic_failure(rx->sdata, keyidx, hdr, NULL);
  ignore:
         dev_kfree_skb(rx->skb);
         rx->skb = NULL;
@@ -2287,6 +2221,43 @@ static inline u16 seq_sub(u16 sq1, u16 sq2)
 }
 
 
+static void ieee80211_release_reorder_frame(struct ieee80211_hw *hw,
+                                            struct tid_ampdu_rx *tid_agg_rx,
+                                            int index)
+{
+        struct ieee80211_supported_band *sband;
+        struct ieee80211_rate *rate;
+        struct ieee80211_rx_status status;
+
+        if (!tid_agg_rx->reorder_buf[index])
+                goto no_frame;
+
+        /* release the reordered frames to stack */
+        memcpy(&status, tid_agg_rx->reorder_buf[index]->cb, sizeof(status));
+        sband = hw->wiphy->bands[status.band];
+        if (status.flag & RX_FLAG_HT)
+                rate = sband->bitrates; /* TODO: HT rates */
+        else
+                rate = &sband->bitrates[status.rate_idx];
+        __ieee80211_rx_handle_packet(hw, tid_agg_rx->reorder_buf[index],
+                                     &status, rate);
+        tid_agg_rx->stored_mpdu_num--;
+        tid_agg_rx->reorder_buf[index] = NULL;
+
+no_frame:
+        tid_agg_rx->head_seq_num = seq_inc(tid_agg_rx->head_seq_num);
+}
+
+
+/*
+ * Timeout (in jiffies) for skb's that are waiting in the RX reorder buffer. If
+ * the skb was added to the buffer longer than this time ago, the earlier
+ * frames that have not yet been received are assumed to be lost and the skb
+ * can be released for processing. This may also release other skb's from the
+ * reorder buffer if there are no additional gaps between the frames.
+ */
+#define HT_RX_REORDER_BUF_TIMEOUT (HZ / 10)
+
 /*
  * As it function blongs to Rx path it must be called with
  * the proper rcu_read_lock protection for its flow.
@@ -2298,12 +2269,8 @@ static u8 ieee80211_sta_manage_reorder_buf(struct ieee80211_hw *hw,
                                            u16 mpdu_seq_num,
                                            int bar_req)
 {
-        struct ieee80211_local *local = hw_to_local(hw);
-        struct ieee80211_rx_status status;
         u16 head_seq_num, buf_size;
         int index;
-        struct ieee80211_supported_band *sband;
-        struct ieee80211_rate *rate;
 
         buf_size = tid_agg_rx->buf_size;
         head_seq_num = tid_agg_rx->head_seq_num;
@@ -2328,28 +2295,8 @@ static u8 ieee80211_sta_manage_reorder_buf(struct ieee80211_hw *hw,
                         index = seq_sub(tid_agg_rx->head_seq_num,
                                 tid_agg_rx->ssn)
                                 % tid_agg_rx->buf_size;
-
-                        if (tid_agg_rx->reorder_buf[index]) {
-                                /* release the reordered frames to stack */
-                                memcpy(&status,
-                                        tid_agg_rx->reorder_buf[index]->cb,
-                                        sizeof(status));
-                                sband = local->hw.wiphy->bands[status.band];
-                                if (status.flag & RX_FLAG_HT) {
-                                        /* TODO: HT rates */
-                                        rate = sband->bitrates;
-                                } else {
-                                        rate = &sband->bitrates
-                                                [status.rate_idx];
-                                }
-                                __ieee80211_rx_handle_packet(hw,
-                                        tid_agg_rx->reorder_buf[index],
-                                        &status, rate);
-                                tid_agg_rx->stored_mpdu_num--;
-                                tid_agg_rx->reorder_buf[index] = NULL;
-                        }
-                        tid_agg_rx->head_seq_num =
-                                seq_inc(tid_agg_rx->head_seq_num);
+                        ieee80211_release_reorder_frame(hw, tid_agg_rx,
+                                                        index);
                 }
                 if (bar_req)
                         return 1;
@@ -2376,26 +2323,50 @@ static u8 ieee80211_sta_manage_reorder_buf(struct ieee80211_hw *hw,
 
         /* put the frame in the reordering buffer */
         tid_agg_rx->reorder_buf[index] = skb;
+        tid_agg_rx->reorder_time[index] = jiffies;
         memcpy(tid_agg_rx->reorder_buf[index]->cb, rxstatus,
                sizeof(*rxstatus));
         tid_agg_rx->stored_mpdu_num++;
         /* release the buffer until next missing frame */
         index = seq_sub(tid_agg_rx->head_seq_num, tid_agg_rx->ssn)
                                                 % tid_agg_rx->buf_size;
-        while (tid_agg_rx->reorder_buf[index]) {
-                /* release the reordered frame back to stack */
-                memcpy(&status, tid_agg_rx->reorder_buf[index]->cb,
-                        sizeof(status));
-                sband = local->hw.wiphy->bands[status.band];
-                if (status.flag & RX_FLAG_HT)
-                        rate = sband->bitrates; /* TODO: HT rates */
-                else
-                        rate = &sband->bitrates[status.rate_idx];
-                __ieee80211_rx_handle_packet(hw, tid_agg_rx->reorder_buf[index],
-                                             &status, rate);
-                tid_agg_rx->stored_mpdu_num--;
-                tid_agg_rx->reorder_buf[index] = NULL;
-                tid_agg_rx->head_seq_num = seq_inc(tid_agg_rx->head_seq_num);
+        if (!tid_agg_rx->reorder_buf[index] &&
+            tid_agg_rx->stored_mpdu_num > 1) {
+                /*
+                 * No buffers ready to be released, but check whether any
+                 * frames in the reorder buffer have timed out.
+                 */
+                int j;
+                int skipped = 1;
+                for (j = (index + 1) % tid_agg_rx->buf_size; j != index;
+                     j = (j + 1) % tid_agg_rx->buf_size) {
+                        if (tid_agg_rx->reorder_buf[j] == NULL) {
+                                skipped++;
+                                continue;
+                        }
+                        if (!time_after(jiffies, tid_agg_rx->reorder_time[j] +
+                                        HZ / 10))
+                                break;
+
+#ifdef CONFIG_MAC80211_HT_DEBUG
+                        if (net_ratelimit())
+                                printk(KERN_DEBUG "%s: release an RX reorder "
+                                       "frame due to timeout on earlier "
+                                       "frames\n",
+                                       wiphy_name(hw->wiphy));
+#endif
+                        ieee80211_release_reorder_frame(hw, tid_agg_rx, j);
+
+                        /*
+                         * Increment the head seq# also for the skipped slots.
+                         */
+                        tid_agg_rx->head_seq_num =
+                                (tid_agg_rx->head_seq_num + skipped) &
+                                SEQ_MASK;
+                        skipped = 0;
+                }
+        } else while (tid_agg_rx->reorder_buf[index]) {
+                ieee80211_release_reorder_frame(hw, tid_agg_rx, index);
                 index = seq_sub(tid_agg_rx->head_seq_num,
                         tid_agg_rx->ssn) % tid_agg_rx->buf_size;
         }
@@ -2517,6 +2488,18 @@ void __ieee80211_rx(struct ieee80211_hw *hw, struct sk_buff *skb,
                 return;
         }
 
+        /*
+         * In theory, the block ack reordering should happen after duplicate
+         * removal (ieee80211_rx_h_check(), which is an RX handler). As such,
+         * the call to ieee80211_rx_reorder_ampdu() should really be moved to
+         * happen as a new RX handler between ieee80211_rx_h_check and
+         * ieee80211_rx_h_decrypt. This cleanup may eventually happen, but for
+         * the time being, the call can be here since RX reorder buf processing
+         * will implicitly skip duplicates. We could, in theory at least,
+         * process frames that ieee80211_rx_h_passive_scan would drop (e.g.,
+         * frames from other than operational channel), but that should not
+         * happen in normal networks.
+         */
         if (!ieee80211_rx_reorder_ampdu(local, skb, status))
                 __ieee80211_rx_handle_packet(hw, skb, status, rate);
 
diff --git a/net/mac80211/scan.c b/net/mac80211/scan.c
index 3bf9839f5916..2a8d09ad17ff 100644
--- a/net/mac80211/scan.c
+++ b/net/mac80211/scan.c
@@ -21,6 +21,7 @@
 #include <net/iw_handler.h>
 
 #include "ieee80211_i.h"
+#include "driver-ops.h"
 #include "mesh.h"
 
 #define IEEE80211_PROBE_DELAY (HZ / 33)
@@ -202,18 +203,6 @@ ieee80211_scan_rx(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb,
         return RX_QUEUED;
 }
 
-void ieee80211_scan_failed(struct ieee80211_local *local)
-{
-        if (WARN_ON(!local->scan_req))
-                return;
-
-        /* notify cfg80211 about the failed scan */
-        if (local->scan_req != &local->int_scan_req)
-                cfg80211_scan_done(local->scan_req, true);
-
-        local->scan_req = NULL;
-}
-
 /*
  * inform AP that we will go to sleep so that it will buffer the frames
  * while we scan
@@ -253,7 +242,7 @@ static void ieee80211_scan_ps_disable(struct ieee80211_sub_if_data *sdata)
 {
         struct ieee80211_local *local = sdata->local;
 
-        if (!local->powersave)
+        if (!local->ps_sdata)
                 ieee80211_send_nullfunc(local, sdata, 0);
         else {
                 /*
@@ -274,51 +263,62 @@ static void ieee80211_scan_ps_disable(struct ieee80211_sub_if_data *sdata)
         }
 }
 
+static void ieee80211_restore_scan_ies(struct ieee80211_local *local)
+{
+        kfree(local->scan_req->ie);
+        local->scan_req->ie = local->orig_ies;
+        local->scan_req->ie_len = local->orig_ies_len;
+}
+
 void ieee80211_scan_completed(struct ieee80211_hw *hw, bool aborted)
 {
         struct ieee80211_local *local = hw_to_local(hw);
         struct ieee80211_sub_if_data *sdata;
+        bool was_hw_scan;
 
-        if (WARN_ON(!local->hw_scanning && !local->sw_scanning))
+        mutex_lock(&local->scan_mtx);
+
+        if (WARN_ON(!local->hw_scanning && !local->sw_scanning)) {
+                mutex_unlock(&local->scan_mtx);
                 return;
+        }
 
-        if (WARN_ON(!local->scan_req))
+        if (WARN_ON(!local->scan_req)) {
+                mutex_unlock(&local->scan_mtx);
                 return;
+        }
+
+        if (local->hw_scanning)
+                ieee80211_restore_scan_ies(local);
 
         if (local->scan_req != &local->int_scan_req)
                 cfg80211_scan_done(local->scan_req, aborted);
         local->scan_req = NULL;
 
-        local->last_scan_completed = jiffies;
+        was_hw_scan = local->hw_scanning;
+        local->hw_scanning = false;
+        local->sw_scanning = false;
+        local->scan_channel = NULL;
 
-        if (local->hw_scanning) {
-                local->hw_scanning = false;
-                /*
-                 * Somebody might have requested channel change during scan
-                 * that we won't have acted upon, try now. ieee80211_hw_config
-                 * will set the flag based on actual changes.
-                 */
-                ieee80211_hw_config(local, 0);
-                goto done;
-        }
+        /* we only have to protect scan_req and hw/sw scan */
+        mutex_unlock(&local->scan_mtx);
 
-        local->sw_scanning = false;
         ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL);
+        if (was_hw_scan)
+                goto done;
 
         netif_tx_lock_bh(local->mdev);
         netif_addr_lock(local->mdev);
         local->filter_flags &= ~FIF_BCN_PRBRESP_PROMISC;
-        local->ops->configure_filter(local_to_hw(local),
-                                     FIF_BCN_PRBRESP_PROMISC,
-                                     &local->filter_flags,
-                                     local->mdev->mc_count,
-                                     local->mdev->mc_list);
+        drv_configure_filter(local, FIF_BCN_PRBRESP_PROMISC,
+                             &local->filter_flags,
+                             local->mdev->mc_count,
+                             local->mdev->mc_list);
 
         netif_addr_unlock(local->mdev);
         netif_tx_unlock_bh(local->mdev);
 
-        if (local->ops->sw_scan_complete)
-                local->ops->sw_scan_complete(local_to_hw(local));
+        drv_sw_scan_complete(local);
 
         mutex_lock(&local->iflist_mtx);
         list_for_each_entry(sdata, &local->interfaces, list) {
@@ -338,18 +338,160 @@ void ieee80211_scan_completed(struct ieee80211_hw *hw, bool aborted)
                 if (sdata->vif.type == NL80211_IFTYPE_AP ||
                     sdata->vif.type == NL80211_IFTYPE_ADHOC ||
                     sdata->vif.type == NL80211_IFTYPE_MESH_POINT)
-                        ieee80211_if_config(sdata,
-                                            IEEE80211_IFCC_BEACON_ENABLED);
+                        ieee80211_bss_info_change_notify(
+                                sdata, BSS_CHANGED_BEACON_ENABLED);
         }
         mutex_unlock(&local->iflist_mtx);
 
  done:
+        ieee80211_recalc_idle(local);
         ieee80211_mlme_notify_scan_completed(local);
         ieee80211_ibss_notify_scan_completed(local);
         ieee80211_mesh_notify_scan_completed(local);
 }
 EXPORT_SYMBOL(ieee80211_scan_completed);
 
+static int ieee80211_start_sw_scan(struct ieee80211_local *local)
+{
+        struct ieee80211_sub_if_data *sdata;
+
+        /*
+         * Hardware/driver doesn't support hw_scan, so use software
+         * scanning instead. First send a nullfunc frame with power save
+         * bit on so that AP will buffer the frames for us while we are not
+         * listening, then send probe requests to each channel and wait for
+         * the responses. After all channels are scanned, tune back to the
+         * original channel and send a nullfunc frame with power save bit
+         * off to trigger the AP to send us all the buffered frames.
+         *
+         * Note that while local->sw_scanning is true everything else but
+         * nullfunc frames and probe requests will be dropped in
+         * ieee80211_tx_h_check_assoc().
+         */
+        drv_sw_scan_start(local);
+
+        mutex_lock(&local->iflist_mtx);
+        list_for_each_entry(sdata, &local->interfaces, list) {
+                if (!netif_running(sdata->dev))
+                        continue;
+
+                /* disable beaconing */
+                if (sdata->vif.type == NL80211_IFTYPE_AP ||
+                    sdata->vif.type == NL80211_IFTYPE_ADHOC ||
+                    sdata->vif.type == NL80211_IFTYPE_MESH_POINT)
+                        ieee80211_bss_info_change_notify(
+                                sdata, BSS_CHANGED_BEACON_ENABLED);
+
+                if (sdata->vif.type == NL80211_IFTYPE_STATION) {
+                        if (sdata->u.mgd.flags & IEEE80211_STA_ASSOCIATED) {
+                                netif_tx_stop_all_queues(sdata->dev);
+                                ieee80211_scan_ps_enable(sdata);
+                        }
+                } else
+                        netif_tx_stop_all_queues(sdata->dev);
+        }
+        mutex_unlock(&local->iflist_mtx);
+
+        local->scan_state = SCAN_SET_CHANNEL;
+        local->scan_channel_idx = 0;
+
+        netif_addr_lock_bh(local->mdev);
+        local->filter_flags |= FIF_BCN_PRBRESP_PROMISC;
+        drv_configure_filter(local, FIF_BCN_PRBRESP_PROMISC,
+                             &local->filter_flags,
+                             local->mdev->mc_count,
+                             local->mdev->mc_list);
+        netif_addr_unlock_bh(local->mdev);
+
+        /* TODO: start scan as soon as all nullfunc frames are ACKed */
+        queue_delayed_work(local->hw.workqueue, &local->scan_work,
+                           IEEE80211_CHANNEL_TIME);
+
+        return 0;
+}
+
+
+static int __ieee80211_start_scan(struct ieee80211_sub_if_data *sdata,
+                                  struct cfg80211_scan_request *req)
+{
+        struct ieee80211_local *local = sdata->local;
+        struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
+        int rc;
+
+        if (local->scan_req)
+                return -EBUSY;
+
+        if (local->ops->hw_scan) {
+                u8 *ies;
+                int ielen;
+
+                ies = kmalloc(2 + IEEE80211_MAX_SSID_LEN +
+                              local->scan_ies_len + req->ie_len, GFP_KERNEL);
+                if (!ies)
+                        return -ENOMEM;
+
+                ielen = ieee80211_build_preq_ies(local, ies,
+                                                 req->ie, req->ie_len);
+                local->orig_ies = req->ie;
+                local->orig_ies_len = req->ie_len;
+                req->ie = ies;
+                req->ie_len = ielen;
+        }
+
+        local->scan_req = req;
+        local->scan_sdata = sdata;
+
+        if (req != &local->int_scan_req &&
+            sdata->vif.type == NL80211_IFTYPE_STATION &&
+            (ifmgd->state == IEEE80211_STA_MLME_DIRECT_PROBE ||
+             ifmgd->state == IEEE80211_STA_MLME_AUTHENTICATE ||
+             ifmgd->state == IEEE80211_STA_MLME_ASSOCIATE)) {
+                /* actually wait for the assoc to finish/time out */
+                set_bit(IEEE80211_STA_REQ_SCAN, &ifmgd->request);
+                return 0;
+        }
+
+        if (local->ops->hw_scan)
+                local->hw_scanning = true;
+        else
+                local->sw_scanning = true;
+        /*
+         * Kicking off the scan need not be protected,
+         * only the scan variable stuff, since now
+         * local->scan_req is assigned and other callers
+         * will abort their scan attempts.
+         *
+         * This avoids getting a scan_mtx -> iflist_mtx
+         * dependency, so that the scan completed calls
+         * have more locking freedom.
+         */
+
+        ieee80211_recalc_idle(local);
+        mutex_unlock(&local->scan_mtx);
+
+        if (local->ops->hw_scan)
+                rc = drv_hw_scan(local, local->scan_req);
+        else
+                rc = ieee80211_start_sw_scan(local);
+
+        mutex_lock(&local->scan_mtx);
+
+        if (rc) {
+                if (local->ops->hw_scan) {
+                        local->hw_scanning = false;
+                        ieee80211_restore_scan_ies(local);
+                } else
+                        local->sw_scanning = false;
+
+                ieee80211_recalc_idle(local);
+
+                local->scan_req = NULL;
+                local->scan_sdata = NULL;
+        }
+
+        return rc;
+}
+
 void ieee80211_scan_work(struct work_struct *work)
 {
         struct ieee80211_local *local =
@@ -359,17 +501,41 @@ void ieee80211_scan_work(struct work_struct *work)
         int skip, i;
         unsigned long next_delay = 0;
 
+        mutex_lock(&local->scan_mtx);
+        if (!sdata || !local->scan_req) {
+                mutex_unlock(&local->scan_mtx);
+                return;
+        }
+
+        if (local->scan_req && !(local->sw_scanning || local->hw_scanning)) {
+                struct cfg80211_scan_request *req = local->scan_req;
+                int rc;
+
+                local->scan_req = NULL;
+
+                rc = __ieee80211_start_scan(sdata, req);
+                mutex_unlock(&local->scan_mtx);
+
+                if (rc)
+                        ieee80211_scan_completed(&local->hw, true);
+                return;
+        }
+
+        mutex_unlock(&local->scan_mtx);
+
         /*
          * Avoid re-scheduling when the sdata is going away.
          */
-        if (!netif_running(sdata->dev))
+        if (!netif_running(sdata->dev)) {
+                ieee80211_scan_completed(&local->hw, true);
                 return;
+        }
 
         switch (local->scan_state) {
         case SCAN_SET_CHANNEL:
                 /* if no more bands/channels left, complete scan */
                 if (local->scan_channel_idx >= local->scan_req->n_channels) {
-                        ieee80211_scan_completed(local_to_hw(local), false);
+                        ieee80211_scan_completed(&local->hw, false);
                         return;
                 }
                 skip = 0;
@@ -393,24 +559,39 @@ void ieee80211_scan_work(struct work_struct *work)
                 if (skip)
                         break;
 
-                next_delay = IEEE80211_PROBE_DELAY +
-                             usecs_to_jiffies(local->hw.channel_change_time);
+                /*
+                 * Probe delay is used to update the NAV, cf. 11.1.3.2.2
+                 * (which unfortunately doesn't say _why_ step a) is done,
+                 * but it waits for the probe delay or until a frame is
+                 * received - and the received frame would update the NAV).
+                 * For now, we do not support waiting until a frame is
+                 * received.
+                 *
+                 * In any case, it is not necessary for a passive scan.
+                 */
+                if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN ||
+                    !local->scan_req->n_ssids) {
+                        next_delay = IEEE80211_PASSIVE_CHANNEL_TIME;
+                        break;
+                }
+
+                next_delay = IEEE80211_PROBE_DELAY;
                 local->scan_state = SCAN_SEND_PROBE;
                 break;
         case SCAN_SEND_PROBE:
-                next_delay = IEEE80211_PASSIVE_CHANNEL_TIME;
-                local->scan_state = SCAN_SET_CHANNEL;
-
-                if (local->scan_channel->flags & IEEE80211_CHAN_PASSIVE_SCAN ||
-                    !local->scan_req->n_ssids)
-                        break;
                 for (i = 0; i < local->scan_req->n_ssids; i++)
                         ieee80211_send_probe_req(
                                 sdata, NULL,
                                 local->scan_req->ssids[i].ssid,
                                 local->scan_req->ssids[i].ssid_len,
                                 local->scan_req->ie, local->scan_req->ie_len);
+
+                /*
+                 * After sending probe requests, wait for probe responses
+                 * on the channel.
+                 */
                 next_delay = IEEE80211_CHANNEL_TIME;
+                local->scan_state = SCAN_SET_CHANNEL;
                 break;
         }
 
@@ -418,150 +599,53 @@ void ieee80211_scan_work(struct work_struct *work)
                            next_delay);
 }
 
-
-int ieee80211_start_scan(struct ieee80211_sub_if_data *scan_sdata,
-                         struct cfg80211_scan_request *req)
+int ieee80211_request_scan(struct ieee80211_sub_if_data *sdata,
+                           struct cfg80211_scan_request *req)
 {
-        struct ieee80211_local *local = scan_sdata->local;
-        struct ieee80211_sub_if_data *sdata;
-
-        if (!req)
-                return -EINVAL;
-
-        if (local->scan_req && local->scan_req != req)
-                return -EBUSY;
-
-        local->scan_req = req;
-
-        /* MLME-SCAN.request (page 118)  page 144 (11.1.3.1)
-         * BSSType: INFRASTRUCTURE, INDEPENDENT, ANY_BSS
-         * BSSID: MACAddress
-         * SSID
-         * ScanType: ACTIVE, PASSIVE
-         * ProbeDelay: delay (in microseconds) to be used prior to transmitting
-         *    a Probe frame during active scanning
-         * ChannelList
-         * MinChannelTime (>= ProbeDelay), in TU
-         * MaxChannelTime: (>= MinChannelTime), in TU
-         */
-
-         /* MLME-SCAN.confirm
-          * BSSDescriptionSet
-          * ResultCode: SUCCESS, INVALID_PARAMETERS
-         */
-
-        if (local->sw_scanning || local->hw_scanning) {
-                if (local->scan_sdata == scan_sdata)
-                        return 0;
-                return -EBUSY;
-        }
-
-        if (local->ops->hw_scan) {
-                int rc;
-
-                local->hw_scanning = true;
-                rc = local->ops->hw_scan(local_to_hw(local), req);
-                if (rc) {
-                        local->hw_scanning = false;
-                        return rc;
-                }
-                local->scan_sdata = scan_sdata;
-                return 0;
-        }
-
-        /*
-         * Hardware/driver doesn't support hw_scan, so use software
-         * scanning instead. First send a nullfunc frame with power save
-         * bit on so that AP will buffer the frames for us while we are not
-         * listening, then send probe requests to each channel and wait for
-         * the responses. After all channels are scanned, tune back to the
-         * original channel and send a nullfunc frame with power save bit
-         * off to trigger the AP to send us all the buffered frames.
-         *
-         * Note that while local->sw_scanning is true everything else but
-         * nullfunc frames and probe requests will be dropped in
-         * ieee80211_tx_h_check_assoc().
-         */
-        local->sw_scanning = true;
-        if (local->ops->sw_scan_start)
-                local->ops->sw_scan_start(local_to_hw(local));
+        int res;
 
-        mutex_lock(&local->iflist_mtx);
-        list_for_each_entry(sdata, &local->interfaces, list) {
-                if (!netif_running(sdata->dev))
-                        continue;
+        mutex_lock(&sdata->local->scan_mtx);
+        res = __ieee80211_start_scan(sdata, req);
+        mutex_unlock(&sdata->local->scan_mtx);
 
-                /* disable beaconing */
-                if (sdata->vif.type == NL80211_IFTYPE_AP ||
-                    sdata->vif.type == NL80211_IFTYPE_ADHOC ||
-                    sdata->vif.type == NL80211_IFTYPE_MESH_POINT)
-                        ieee80211_if_config(sdata,
-                                            IEEE80211_IFCC_BEACON_ENABLED);
+        return res;
+}
 
-                if (sdata->vif.type == NL80211_IFTYPE_STATION) {
-                        if (sdata->u.mgd.flags & IEEE80211_STA_ASSOCIATED) {
-                                netif_tx_stop_all_queues(sdata->dev);
-                                ieee80211_scan_ps_enable(sdata);
-                        }
-                } else
-                        netif_tx_stop_all_queues(sdata->dev);
-        }
-        mutex_unlock(&local->iflist_mtx);
+int ieee80211_request_internal_scan(struct ieee80211_sub_if_data *sdata,
+                                    const u8 *ssid, u8 ssid_len)
+{
+        struct ieee80211_local *local = sdata->local;
+        int ret = -EBUSY;
 
-        local->scan_state = SCAN_SET_CHANNEL;
-        local->scan_channel_idx = 0;
-        local->scan_sdata = scan_sdata;
-        local->scan_req = req;
+        mutex_lock(&local->scan_mtx);
 
-        netif_addr_lock_bh(local->mdev);
-        local->filter_flags |= FIF_BCN_PRBRESP_PROMISC;
-        local->ops->configure_filter(local_to_hw(local),
-                                     FIF_BCN_PRBRESP_PROMISC,
-                                     &local->filter_flags,
-                                     local->mdev->mc_count,
-                                     local->mdev->mc_list);
-        netif_addr_unlock_bh(local->mdev);
+        /* busy scanning */
+        if (local->scan_req)
+                goto unlock;
 
-        /* TODO: start scan as soon as all nullfunc frames are ACKed */
-        queue_delayed_work(local->hw.workqueue, &local->scan_work,
-                           IEEE80211_CHANNEL_TIME);
+        memcpy(local->int_scan_req.ssids[0].ssid, ssid, IEEE80211_MAX_SSID_LEN);
+        local->int_scan_req.ssids[0].ssid_len = ssid_len;
 
-        return 0;
+        ret = __ieee80211_start_scan(sdata, &sdata->local->int_scan_req);
+ unlock:
+        mutex_unlock(&local->scan_mtx);
+        return ret;
 }
 
-
-int ieee80211_request_scan(struct ieee80211_sub_if_data *sdata,
-                           struct cfg80211_scan_request *req)
+void ieee80211_scan_cancel(struct ieee80211_local *local)
 {
-        struct ieee80211_local *local = sdata->local;
-        struct ieee80211_if_managed *ifmgd;
-
-        if (!req)
-                return -EINVAL;
+        bool swscan;
 
-        if (local->scan_req && local->scan_req != req)
-                return -EBUSY;
-
-        local->scan_req = req;
-
-        if (sdata->vif.type != NL80211_IFTYPE_STATION)
-                return ieee80211_start_scan(sdata, req);
+        cancel_delayed_work_sync(&local->scan_work);
 
         /*
-         * STA has a state machine that might need to defer scanning
-         * while it's trying to associate/authenticate, therefore we
-         * queue it up to the state machine in that case.
+         * Only call this function when a scan can't be
+         * queued -- mostly at suspend under RTNL.
          */
+        mutex_lock(&local->scan_mtx);
+        swscan = local->sw_scanning;
+        mutex_unlock(&local->scan_mtx);
 
-        if (local->sw_scanning || local->hw_scanning) {
-                if (local->scan_sdata == sdata)
-                        return 0;
-                return -EBUSY;
-        }
-
-        ifmgd = &sdata->u.mgd;
-        set_bit(IEEE80211_STA_REQ_SCAN, &ifmgd->request);
-        queue_work(local->hw.workqueue, &ifmgd->work);
-
-        return 0;
+        if (swscan)
+                ieee80211_scan_completed(&local->hw, true);
 }
diff --git a/net/mac80211/spectmgmt.c b/net/mac80211/spectmgmt.c
index 5f7a2624ed74..68953033403d 100644
--- a/net/mac80211/spectmgmt.c
+++ b/net/mac80211/spectmgmt.c
@@ -15,7 +15,7 @@
  */
 
 #include <linux/ieee80211.h>
-#include <net/wireless.h>
+#include <net/cfg80211.h>
 #include <net/mac80211.h>
 #include "ieee80211_i.h"
 #include "sta_info.h"
@@ -84,104 +84,3 @@ void ieee80211_process_measurement_req(struct ieee80211_sub_if_data *sdata,
                         mgmt->sa, mgmt->bssid,
                         mgmt->u.action.u.measurement.dialog_token);
 }
-
-void ieee80211_chswitch_work(struct work_struct *work)
-{
-        struct ieee80211_sub_if_data *sdata =
-                container_of(work, struct ieee80211_sub_if_data, u.mgd.chswitch_work);
-        struct ieee80211_bss *bss;
-        struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
-
-        if (!netif_running(sdata->dev))
-                return;
-
-        bss = ieee80211_rx_bss_get(sdata->local, ifmgd->bssid,
-                                   sdata->local->hw.conf.channel->center_freq,
-                                   ifmgd->ssid, ifmgd->ssid_len);
-        if (!bss)
-                goto exit;
-
-        sdata->local->oper_channel = sdata->local->csa_channel;
-        /* XXX: shouldn't really modify cfg80211-owned data! */
-        if (!ieee80211_hw_config(sdata->local, IEEE80211_CONF_CHANGE_CHANNEL))
-                bss->cbss.channel = sdata->local->oper_channel;
-
-        ieee80211_rx_bss_put(sdata->local, bss);
-exit:
-        ifmgd->flags &= ~IEEE80211_STA_CSA_RECEIVED;
-        ieee80211_wake_queues_by_reason(&sdata->local->hw,
-                                        IEEE80211_QUEUE_STOP_REASON_CSA);
-}
-
-void ieee80211_chswitch_timer(unsigned long data)
-{
-        struct ieee80211_sub_if_data *sdata =
-                (struct ieee80211_sub_if_data *) data;
-        struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
-
-        queue_work(sdata->local->hw.workqueue, &ifmgd->chswitch_work);
-}
-
-void ieee80211_process_chanswitch(struct ieee80211_sub_if_data *sdata,
-                                  struct ieee80211_channel_sw_ie *sw_elem,
-                                  struct ieee80211_bss *bss)
-{
-        struct ieee80211_channel *new_ch;
-        struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
-        int new_freq = ieee80211_channel_to_frequency(sw_elem->new_ch_num);
-
-        /* FIXME: Handle ADHOC later */
-        if (sdata->vif.type != NL80211_IFTYPE_STATION)
-                return;
-
-        if (ifmgd->state != IEEE80211_STA_MLME_ASSOCIATED)
-                return;
-
-        if (sdata->local->sw_scanning || sdata->local->hw_scanning)
-                return;
-
-        /* Disregard subsequent beacons if we are already running a timer
-           processing a CSA */
-
-        if (ifmgd->flags & IEEE80211_STA_CSA_RECEIVED)
-                return;
-
-        new_ch = ieee80211_get_channel(sdata->local->hw.wiphy, new_freq);
-        if (!new_ch || new_ch->flags & IEEE80211_CHAN_DISABLED)
-                return;
-
-        sdata->local->csa_channel = new_ch;
-
-        if (sw_elem->count <= 1) {
-                queue_work(sdata->local->hw.workqueue, &ifmgd->chswitch_work);
-        } else {
-                ieee80211_stop_queues_by_reason(&sdata->local->hw,
-                                                IEEE80211_QUEUE_STOP_REASON_CSA);
-                ifmgd->flags |= IEEE80211_STA_CSA_RECEIVED;
-                mod_timer(&ifmgd->chswitch_timer,
-                          jiffies +
-                          msecs_to_jiffies(sw_elem->count *
-                                           bss->cbss.beacon_interval));
-        }
-}
-
-void ieee80211_handle_pwr_constr(struct ieee80211_sub_if_data *sdata,
-                                 u16 capab_info, u8 *pwr_constr_elem,
-                                 u8 pwr_constr_elem_len)
-{
-        struct ieee80211_conf *conf = &sdata->local->hw.conf;
-
-        if (!(capab_info & WLAN_CAPABILITY_SPECTRUM_MGMT))
-                return;
-
-        /* Power constraint IE length should be 1 octet */
-        if (pwr_constr_elem_len != 1)
-                return;
-
-        if ((*pwr_constr_elem <= conf->channel->max_power) &&
-            (*pwr_constr_elem != sdata->local->power_constr_level)) {
-                sdata->local->power_constr_level = *pwr_constr_elem;
-                ieee80211_hw_config(sdata->local, 0);
-        }
-}
-
diff --git a/net/mac80211/sta_info.c b/net/mac80211/sta_info.c
index c5f14e6bbde2..a360bceeba59 100644
--- a/net/mac80211/sta_info.c
+++ b/net/mac80211/sta_info.c
@@ -19,6 +19,7 @@
 
 #include <net/mac80211.h>
 #include "ieee80211_i.h"
+#include "driver-ops.h"
 #include "rate.h"
 #include "sta_info.h"
 #include "debugfs_sta.h"
@@ -43,6 +44,15 @@
  * When the insertion fails (sta_info_insert()) returns non-zero), the
  * structure will have been freed by sta_info_insert()!
  *
+ * sta entries are added by mac80211 when you establish a link with a
+ * peer. This means different things for the different type of interfaces
+ * we support. For a regular station this mean we add the AP sta when we
+ * receive an assocation response from the AP. For IBSS this occurs when
+ * we receive a probe response or a beacon from target IBSS network. For
+ * WDS we add the sta for the peer imediately upon device open. When using
+ * AP mode we add stations for each respective station upon request from
+ * userspace through nl80211.
+ *
  * Because there are debugfs entries for each station, and adding those
  * must be able to sleep, it is also possible to "pin" a station entry,
  * that means it can be removed from the hash table but not be freed.
@@ -292,6 +302,9 @@ struct sta_info *sta_info_alloc(struct ieee80211_sub_if_data *sdata,
         skb_queue_head_init(&sta->ps_tx_buf);
         skb_queue_head_init(&sta->tx_filtered);
 
+        for (i = 0; i < NUM_RX_DATA_QUEUES; i++)
+                sta->last_seq_ctrl[i] = cpu_to_le16(USHORT_MAX);
+
 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
         printk(KERN_DEBUG "%s: Allocated STA %pM\n",
                wiphy_name(local->hw.wiphy), sta->sta.addr);
@@ -346,8 +359,7 @@ int sta_info_insert(struct sta_info *sta)
                                              struct ieee80211_sub_if_data,
                                              u.ap);
 
-                local->ops->sta_notify(local_to_hw(local), &sdata->vif,
-                                       STA_NOTIFY_ADD, &sta->sta);
+                drv_sta_notify(local, &sdata->vif, STA_NOTIFY_ADD, &sta->sta);
         }
 
 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
@@ -405,8 +417,7 @@ static void __sta_info_set_tim_bit(struct ieee80211_if_ap *bss,
 
         if (sta->local->ops->set_tim) {
                 sta->local->tim_in_locked_section = true;
-                sta->local->ops->set_tim(local_to_hw(sta->local),
-                                         &sta->sta, true);
+                drv_set_tim(sta->local, &sta->sta, true);
                 sta->local->tim_in_locked_section = false;
         }
 }
@@ -431,8 +442,7 @@ static void __sta_info_clear_tim_bit(struct ieee80211_if_ap *bss,
 
         if (sta->local->ops->set_tim) {
                 sta->local->tim_in_locked_section = true;
-                sta->local->ops->set_tim(local_to_hw(sta->local),
-                                         &sta->sta, false);
+                drv_set_tim(sta->local, &sta->sta, false);
                 sta->local->tim_in_locked_section = false;
         }
 }
@@ -482,8 +492,8 @@ static void __sta_info_unlink(struct sta_info **sta)
                                              struct ieee80211_sub_if_data,
                                              u.ap);
 
-                local->ops->sta_notify(local_to_hw(local), &sdata->vif,
-                                       STA_NOTIFY_REMOVE, &(*sta)->sta);
+                drv_sta_notify(local, &sdata->vif, STA_NOTIFY_REMOVE,
+                               &(*sta)->sta);
         }
 
         if (ieee80211_vif_is_mesh(&sdata->vif)) {
@@ -543,9 +553,8 @@ void sta_info_unlink(struct sta_info **sta)
         spin_unlock_irqrestore(&local->sta_lock, flags);
 }
 
-static inline int sta_info_buffer_expired(struct ieee80211_local *local,
-                                          struct sta_info *sta,
-                                          struct sk_buff *skb)
+static int sta_info_buffer_expired(struct sta_info *sta,
+                                   struct sk_buff *skb)
 {
         struct ieee80211_tx_info *info;
         int timeout;
@@ -556,8 +565,9 @@ static inline int sta_info_buffer_expired(struct ieee80211_local *local,
         info = IEEE80211_SKB_CB(skb);
 
         /* Timeout: (2 * listen_interval * beacon_int * 1024 / 1000000) sec */
-        timeout = (sta->listen_interval * local->hw.conf.beacon_int * 32 /
-                   15625) * HZ;
+        timeout = (sta->listen_interval *
+                   sta->sdata->vif.bss_conf.beacon_int *
+                   32 / 15625) * HZ;
         if (timeout < STA_TX_BUFFER_EXPIRE)
                 timeout = STA_TX_BUFFER_EXPIRE;
         return time_after(jiffies, info->control.jiffies + timeout);
@@ -577,7 +587,7 @@ static void sta_info_cleanup_expire_buffered(struct ieee80211_local *local,
         for (;;) {
                 spin_lock_irqsave(&sta->ps_tx_buf.lock, flags);
                 skb = skb_peek(&sta->ps_tx_buf);
-                if (sta_info_buffer_expired(local, sta, skb))
+                if (sta_info_buffer_expired(sta, skb))
                         skb = __skb_dequeue(&sta->ps_tx_buf);
                 else
                         skb = NULL;
@@ -610,6 +620,9 @@ static void sta_info_cleanup(unsigned long data)
                 sta_info_cleanup_expire_buffered(local, sta);
         rcu_read_unlock();
 
+        if (local->quiescing)
+                return;
+
         local->sta_cleanup.expires =
                 round_jiffies(jiffies + STA_INFO_CLEANUP_INTERVAL);
         add_timer(&local->sta_cleanup);
@@ -686,41 +699,10 @@ static void sta_info_debugfs_add_work(struct work_struct *work)
 }
 #endif
 
-static void __ieee80211_run_pending_flush(struct ieee80211_local *local)
-{
-        struct sta_info *sta;
-        unsigned long flags;
-
-        ASSERT_RTNL();
-
-        spin_lock_irqsave(&local->sta_lock, flags);
-        while (!list_empty(&local->sta_flush_list)) {
-                sta = list_first_entry(&local->sta_flush_list,
-                                       struct sta_info, list);
-                list_del(&sta->list);
-                spin_unlock_irqrestore(&local->sta_lock, flags);
-                sta_info_destroy(sta);
-                spin_lock_irqsave(&local->sta_lock, flags);
-        }
-        spin_unlock_irqrestore(&local->sta_lock, flags);
-}
-
-static void ieee80211_sta_flush_work(struct work_struct *work)
-{
-        struct ieee80211_local *local =
-                container_of(work, struct ieee80211_local, sta_flush_work);
-
-        rtnl_lock();
-        __ieee80211_run_pending_flush(local);
-        rtnl_unlock();
-}
-
 void sta_info_init(struct ieee80211_local *local)
 {
         spin_lock_init(&local->sta_lock);
         INIT_LIST_HEAD(&local->sta_list);
-        INIT_LIST_HEAD(&local->sta_flush_list);
-        INIT_WORK(&local->sta_flush_work, ieee80211_sta_flush_work);
 
         setup_timer(&local->sta_cleanup, sta_info_cleanup,
                     (unsigned long)local);
@@ -741,7 +723,6 @@ int sta_info_start(struct ieee80211_local *local)
 void sta_info_stop(struct ieee80211_local *local)
 {
         del_timer(&local->sta_cleanup);
-        cancel_work_sync(&local->sta_flush_work);
 #ifdef CONFIG_MAC80211_DEBUGFS
         /*
          * Make sure the debugfs adding work isn't pending after this
@@ -752,10 +733,7 @@ void sta_info_stop(struct ieee80211_local *local)
         cancel_work_sync(&local->sta_debugfs_add);
 #endif
 
-        rtnl_lock();
         sta_info_flush(local, NULL);
-        __ieee80211_run_pending_flush(local);
-        rtnl_unlock();
 }
 
 /**
@@ -767,7 +745,7 @@ void sta_info_stop(struct ieee80211_local *local)
  * @sdata: matching rule for the net device (sta->dev) or %NULL to match all STAs
  */
 int sta_info_flush(struct ieee80211_local *local,
-                    struct ieee80211_sub_if_data *sdata)
+                   struct ieee80211_sub_if_data *sdata)
 {
         struct sta_info *sta, *tmp;
         LIST_HEAD(tmp_list);
@@ -775,7 +753,6 @@ int sta_info_flush(struct ieee80211_local *local,
         unsigned long flags;
 
         might_sleep();
-        ASSERT_RTNL();
 
         spin_lock_irqsave(&local->sta_lock, flags);
         list_for_each_entry_safe(sta, tmp, &local->sta_list, list) {
@@ -795,39 +772,6 @@ int sta_info_flush(struct ieee80211_local *local,
         return ret;
 }
 
-/**
- * sta_info_flush_delayed - flush matching STA entries from the STA table
- *
- * This function unlinks all stations for a given interface and queues
- * them for freeing. Note that the workqueue function scheduled here has
- * to run before any new keys can be added to the system to avoid set_key()
- * callback ordering issues.
- *
- * @sdata: the interface
- */
-void sta_info_flush_delayed(struct ieee80211_sub_if_data *sdata)
-{
-        struct ieee80211_local *local = sdata->local;
-        struct sta_info *sta, *tmp;
-        unsigned long flags;
-        bool work = false;
-
-        spin_lock_irqsave(&local->sta_lock, flags);
-        list_for_each_entry_safe(sta, tmp, &local->sta_list, list) {
-                if (sdata == sta->sdata) {
-                        __sta_info_unlink(&sta);
-                        if (sta) {
-                                list_add_tail(&sta->list,
-                                              &local->sta_flush_list);
-                                work = true;
-                        }
-                }
-        }
-        if (work)
-                schedule_work(&local->sta_flush_work);
-        spin_unlock_irqrestore(&local->sta_lock, flags);
-}
-
 void ieee80211_sta_expire(struct ieee80211_sub_if_data *sdata,
                           unsigned long exp_time)
 {
diff --git a/net/mac80211/sta_info.h b/net/mac80211/sta_info.h
index 5534d489f506..49a1a1f76511 100644
--- a/net/mac80211/sta_info.h
+++ b/net/mac80211/sta_info.h
@@ -88,6 +88,7 @@ struct tid_ampdu_tx {
  * struct tid_ampdu_rx - TID aggregation information (Rx).
  *
  * @reorder_buf: buffer to reorder incoming aggregated MPDUs
+ * @reorder_time: jiffies when skb was added
  * @session_timer: check if peer keeps Tx-ing on the TID (by timeout value)
  * @head_seq_num: head sequence number in reordering buffer.
  * @stored_mpdu_num: number of MPDUs in reordering buffer
@@ -99,6 +100,7 @@ struct tid_ampdu_tx {
  */
 struct tid_ampdu_rx {
         struct sk_buff **reorder_buf;
+        unsigned long *reorder_time;
         struct timer_list session_timer;
         u16 head_seq_num;
         u16 stored_mpdu_num;
@@ -214,6 +216,7 @@ struct sta_ampdu_mlme {
  * @plink_state: peer link state
  * @plink_timeout: timeout of peer link
  * @plink_timer: peer link watch timer
+ * @plink_timer_was_running: used by suspend/resume to restore timers
  * @debugfs: debug filesystem info
  * @sta: station information we share with the driver
  */
@@ -291,6 +294,7 @@ struct sta_info {
         __le16 reason;
         u8 plink_retries;
         bool ignore_plink_timer;
+        bool plink_timer_was_running;
         enum plink_state plink_state;
         u32 plink_timeout;
         struct timer_list plink_timer;
@@ -442,8 +446,7 @@ void sta_info_init(struct ieee80211_local *local);
 int sta_info_start(struct ieee80211_local *local);
 void sta_info_stop(struct ieee80211_local *local);
 int sta_info_flush(struct ieee80211_local *local,
-                    struct ieee80211_sub_if_data *sdata);
-void sta_info_flush_delayed(struct ieee80211_sub_if_data *sdata);
+                   struct ieee80211_sub_if_data *sdata);
 void ieee80211_sta_expire(struct ieee80211_sub_if_data *sdata,
                           unsigned long exp_time);
 
diff --git a/net/mac80211/tkip.c b/net/mac80211/tkip.c
index 38fa111d2dc6..964b7faa7f17 100644
--- a/net/mac80211/tkip.c
+++ b/net/mac80211/tkip.c
@@ -13,6 +13,7 @@
 #include <asm/unaligned.h>
 
 #include <net/mac80211.h>
+#include "driver-ops.h"
 #include "key.h"
 #include "tkip.h"
 #include "wep.h"
@@ -307,9 +308,8 @@ int ieee80211_tkip_decrypt_data(struct crypto_blkcipher *tfm,
                         if (is_multicast_ether_addr(ra))
                                 sta_addr = bcast;
 
-                        key->local->ops->update_tkip_key(
-                                local_to_hw(key->local), &key->conf,
-                                sta_addr, iv32, key->u.tkip.rx[queue].p1k);
+                        drv_update_tkip_key(key->local, &key->conf, sta_addr,
+                                            iv32, key->u.tkip.rx[queue].p1k);
                 }
         }
 
diff --git a/net/mac80211/tx.c b/net/mac80211/tx.c
index 63656266d567..d238a8939a09 100644
--- a/net/mac80211/tx.c
+++ b/net/mac80211/tx.c
@@ -25,6 +25,7 @@
 #include <asm/unaligned.h>
 
 #include "ieee80211_i.h"
+#include "driver-ops.h"
 #include "led.h"
 #include "mesh.h"
 #include "wep.h"
@@ -399,6 +400,7 @@ ieee80211_tx_h_unicast_ps_buf(struct ieee80211_tx_data *tx)
                         sta_info_set_tim_bit(sta);
 
                 info->control.jiffies = jiffies;
+                info->flags |= IEEE80211_TX_INTFL_NEED_TXPROCESSING;
                 skb_queue_tail(&sta->ps_tx_buf, tx->skb);
                 return TX_QUEUED;
         }
@@ -409,8 +411,24 @@ ieee80211_tx_h_unicast_ps_buf(struct ieee80211_tx_data *tx)
                        sta->sta.addr);
         }
 #endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */
-        clear_sta_flags(sta, WLAN_STA_PSPOLL);
+        if (test_and_clear_sta_flags(sta, WLAN_STA_PSPOLL)) {
+                /*
+                 * The sleeping station with pending data is now snoozing.
+                 * It queried us for its buffered frames and will go back
+                 * to deep sleep once it got everything.
+                 *
+                 * inform the driver, in case the hardware does powersave
+                 * frame filtering and keeps a station  blacklist on its own
+                 * (e.g: p54), so that frames can be delivered unimpeded.
+                 *
+                 * Note: It should be safe to disable the filter now.
+                 * As, it is really unlikely that we still have any pending
+                 * frame for this station in the hw's buffers/fifos left,
+                 * that is not rejected with a unsuccessful tx_status yet.
+                 */
 
+                info->flags |= IEEE80211_TX_CTL_CLEAR_PS_FILT;
+        }
         return TX_CONTINUE;
 }
 
@@ -429,7 +447,7 @@ ieee80211_tx_h_ps_buf(struct ieee80211_tx_data *tx)
 static ieee80211_tx_result debug_noinline
 ieee80211_tx_h_select_key(struct ieee80211_tx_data *tx)
 {
-        struct ieee80211_key *key;
+        struct ieee80211_key *key = NULL;
         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
 
@@ -500,7 +518,7 @@ ieee80211_tx_h_rate_ctrl(struct ieee80211_tx_data *tx)
         sband = tx->local->hw.wiphy->bands[tx->channel->band];
 
         len = min_t(int, tx->skb->len + FCS_LEN,
-                         tx->local->fragmentation_threshold);
+                         tx->local->hw.wiphy->frag_threshold);
 
         /* set up the tx rate control struct we give the RC algo */
         txrc.hw = local_to_hw(tx->local);
@@ -511,8 +529,7 @@ ieee80211_tx_h_rate_ctrl(struct ieee80211_tx_data *tx)
         txrc.max_rate_idx = tx->sdata->max_ratectrl_rateidx;
 
         /* set up RTS protection if desired */
-        if (tx->local->rts_threshold < IEEE80211_MAX_RTS_THRESHOLD &&
-            len > tx->local->rts_threshold) {
+        if (len > tx->local->hw.wiphy->rts_threshold) {
                 txrc.rts = rts = true;
         }
 
@@ -542,6 +559,10 @@ ieee80211_tx_h_rate_ctrl(struct ieee80211_tx_data *tx)
         if (unlikely(!info->control.rates[0].count))
                 info->control.rates[0].count = 1;
 
+        if (WARN_ON_ONCE((info->control.rates[0].count > 1) &&
+                         (info->flags & IEEE80211_TX_CTL_NO_ACK)))
+                info->control.rates[0].count = 1;
+
         if (is_multicast_ether_addr(hdr->addr1)) {
                 /*
                  * XXX: verify the rate is in the basic rateset
@@ -754,7 +775,7 @@ ieee80211_tx_h_fragment(struct ieee80211_tx_data *tx)
         struct sk_buff *skb = tx->skb;
         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
         struct ieee80211_hdr *hdr = (void *)skb->data;
-        int frag_threshold = tx->local->fragmentation_threshold;
+        int frag_threshold = tx->local->hw.wiphy->frag_threshold;
         int hdrlen;
         int fragnum;
 
@@ -852,6 +873,8 @@ ieee80211_tx_h_calculate_duration(struct ieee80211_tx_data *tx)
 
         do {
                 hdr = (void *) skb->data;
+                if (unlikely(ieee80211_is_pspoll(hdr->frame_control)))
+                        break; /* must not overwrite AID */
                 next_len = skb->next ? skb->next->len : 0;
                 group_addr = is_multicast_ether_addr(hdr->addr1);
 
@@ -885,9 +908,8 @@ ieee80211_tx_h_stats(struct ieee80211_tx_data *tx)
  * deal with packet injection down monitor interface
  * with Radiotap Header -- only called for monitor mode interface
  */
-static ieee80211_tx_result
-__ieee80211_parse_tx_radiotap(struct ieee80211_tx_data *tx,
-                              struct sk_buff *skb)
+static bool __ieee80211_parse_tx_radiotap(struct ieee80211_tx_data *tx,
+                                          struct sk_buff *skb)
 {
         /*
          * this is the moment to interpret and discard the radiotap header that
@@ -938,7 +960,7 @@ __ieee80211_parse_tx_radiotap(struct ieee80211_tx_data *tx,
                                  * on transmission
                                  */
                                 if (skb->len < (iterator.max_length + FCS_LEN))
-                                        return TX_DROP;
+                                        return false;
 
                                 skb_trim(skb, skb->len - FCS_LEN);
                         }
@@ -960,7 +982,7 @@ __ieee80211_parse_tx_radiotap(struct ieee80211_tx_data *tx,
         }
 
         if (ret != -ENOENT) /* ie, if we didn't simply run out of fields */
-                return TX_DROP;
+                return false;
 
         /*
          * remove the radiotap header
@@ -969,7 +991,7 @@ __ieee80211_parse_tx_radiotap(struct ieee80211_tx_data *tx,
          */
         skb_pull(skb, iterator.max_length);
 
-        return TX_CONTINUE;
+        return true;
 }
 
 /*
@@ -1003,7 +1025,7 @@ __ieee80211_tx_prepare(struct ieee80211_tx_data *tx,
         /* process and remove the injection radiotap header */
         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
         if (unlikely(info->flags & IEEE80211_TX_CTL_INJECTED)) {
-                if (__ieee80211_parse_tx_radiotap(tx, skb) == TX_DROP)
+                if (!__ieee80211_parse_tx_radiotap(tx, skb))
                         return TX_DROP;
 
                 /*
@@ -1067,12 +1089,15 @@ __ieee80211_tx_prepare(struct ieee80211_tx_data *tx,
                 info->flags |= IEEE80211_TX_CTL_NO_ACK;
         } else {
                 tx->flags |= IEEE80211_TX_UNICAST;
-                info->flags &= ~IEEE80211_TX_CTL_NO_ACK;
+                if (unlikely(local->wifi_wme_noack_test))
+                        info->flags |= IEEE80211_TX_CTL_NO_ACK;
+                else
+                        info->flags &= ~IEEE80211_TX_CTL_NO_ACK;
         }
 
         if (tx->flags & IEEE80211_TX_FRAGMENTED) {
                 if ((tx->flags & IEEE80211_TX_UNICAST) &&
-                    skb->len + FCS_LEN > local->fragmentation_threshold &&
+                    skb->len + FCS_LEN > local->hw.wiphy->frag_threshold &&
                     !(info->flags & IEEE80211_TX_CTL_AMPDU))
                         tx->flags |= IEEE80211_TX_FRAGMENTED;
                 else
@@ -1147,7 +1172,7 @@ static int __ieee80211_tx(struct ieee80211_local *local,
 
                 next = skb->next;
                 len = skb->len;
-                ret = local->ops->tx(local_to_hw(local), skb);
+                ret = drv_tx(local, skb);
                 if (WARN_ON(ret != NETDEV_TX_OK && skb->len != len)) {
                         dev_kfree_skb(skb);
                         ret = NETDEV_TX_OK;
@@ -1213,7 +1238,6 @@ static void ieee80211_tx(struct net_device *dev, struct sk_buff *skb,
                          bool txpending)
 {
         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
-        struct sta_info *sta;
         struct ieee80211_tx_data tx;
         ieee80211_tx_result res_prepare;
         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
@@ -1245,7 +1269,6 @@ static void ieee80211_tx(struct net_device *dev, struct sk_buff *skb,
                 return;
         }
 
-        sta = tx.sta;
         tx.channel = local->hw.conf.channel;
         info->band = tx.channel->band;
 
@@ -1392,7 +1415,8 @@ int ieee80211_master_start_xmit(struct sk_buff *skb, struct net_device *dev)
         }
 
         if ((local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK) &&
-            local->hw.conf.dynamic_ps_timeout > 0) {
+            local->hw.conf.dynamic_ps_timeout > 0 &&
+            !local->sw_scanning && !local->hw_scanning && local->ps_sdata) {
                 if (local->hw.conf.flags & IEEE80211_CONF_PS) {
                         ieee80211_stop_queues_by_reason(&local->hw,
                                         IEEE80211_QUEUE_STOP_REASON_PS);
@@ -1591,7 +1615,7 @@ int ieee80211_subif_start_xmit(struct sk_buff *skb,
 {
         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
         struct ieee80211_local *local = sdata->local;
-        int ret = 1, head_need;
+        int ret = NETDEV_TX_BUSY, head_need;
         u16 ethertype, hdrlen,  meshhdrlen = 0;
         __le16 fc;
         struct ieee80211_hdr hdr;
@@ -2086,18 +2110,18 @@ struct sk_buff *ieee80211_beacon_get(struct ieee80211_hw *hw,
         } else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
                 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
                 struct ieee80211_hdr *hdr;
+                struct sk_buff *presp = rcu_dereference(ifibss->presp);
 
-                if (!ifibss->probe_resp)
+                if (!presp)
                         goto out;
 
-                skb = skb_copy(ifibss->probe_resp, GFP_ATOMIC);
+                skb = skb_copy(presp, GFP_ATOMIC);
                 if (!skb)
                         goto out;
 
                 hdr = (struct ieee80211_hdr *) skb->data;
                 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
                                                  IEEE80211_STYPE_BEACON);
-
         } else if (ieee80211_vif_is_mesh(&sdata->vif)) {
                 struct ieee80211_mgmt *mgmt;
                 u8 *pos;
@@ -2117,7 +2141,7 @@ struct sk_buff *ieee80211_beacon_get(struct ieee80211_hw *hw,
                 memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
                 /* BSSID is left zeroed, wildcard value */
                 mgmt->u.beacon.beacon_int =
-                        cpu_to_le16(local->hw.conf.beacon_int);
+                        cpu_to_le16(sdata->vif.bss_conf.beacon_int);
                 mgmt->u.beacon.capab_info = 0x0; /* 0x0 for MPs */
 
                 pos = skb_put(skb, 2);
diff --git a/net/mac80211/util.c b/net/mac80211/util.c
index fdf432f14554..66ce96a69f31 100644
--- a/net/mac80211/util.c
+++ b/net/mac80211/util.c
@@ -20,27 +20,21 @@
 #include <linux/if_arp.h>
 #include <linux/wireless.h>
 #include <linux/bitmap.h>
+#include <linux/crc32.h>
 #include <net/net_namespace.h>
 #include <net/cfg80211.h>
 #include <net/rtnetlink.h>
 
 #include "ieee80211_i.h"
+#include "driver-ops.h"
 #include "rate.h"
 #include "mesh.h"
 #include "wme.h"
+#include "led.h"
 
 /* privid for wiphys to determine whether they belong to us or not */
 void *mac80211_wiphy_privid = &mac80211_wiphy_privid;
 
-/* See IEEE 802.1H for LLC/SNAP encapsulation/decapsulation */
-/* Ethernet-II snap header (RFC1042 for most EtherTypes) */
-const unsigned char rfc1042_header[] __aligned(2) =
-        { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00 };
-
-/* Bridge-Tunnel header (for EtherTypes ETH_P_AARP and ETH_P_IPX) */
-const unsigned char bridge_tunnel_header[] __aligned(2) =
-        { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0xf8 };
-
 struct ieee80211_hw *wiphy_to_ieee80211_hw(struct wiphy *wiphy)
 {
         struct ieee80211_local *local;
@@ -100,70 +94,6 @@ u8 *ieee80211_get_bssid(struct ieee80211_hdr *hdr, size_t len,
         return NULL;
 }
 
-unsigned int ieee80211_hdrlen(__le16 fc)
-{
-        unsigned int hdrlen = 24;
-
-        if (ieee80211_is_data(fc)) {
-                if (ieee80211_has_a4(fc))
-                        hdrlen = 30;
-                if (ieee80211_is_data_qos(fc))
-                        hdrlen += IEEE80211_QOS_CTL_LEN;
-                goto out;
-        }
-
-        if (ieee80211_is_ctl(fc)) {
-                /*
-                 * ACK and CTS are 10 bytes, all others 16. To see how
-                 * to get this condition consider
-                 *   subtype mask:   0b0000000011110000 (0x00F0)
-                 *   ACK subtype:    0b0000000011010000 (0x00D0)
-                 *   CTS subtype:    0b0000000011000000 (0x00C0)
-                 *   bits that matter:         ^^^      (0x00E0)
-                 *   value of those: 0b0000000011000000 (0x00C0)
-                 */
-                if ((fc & cpu_to_le16(0x00E0)) == cpu_to_le16(0x00C0))
-                        hdrlen = 10;
-                else
-                        hdrlen = 16;
-        }
-out:
-        return hdrlen;
-}
-EXPORT_SYMBOL(ieee80211_hdrlen);
-
-unsigned int ieee80211_get_hdrlen_from_skb(const struct sk_buff *skb)
-{
-        const struct ieee80211_hdr *hdr = (const struct ieee80211_hdr *)skb->data;
-        unsigned int hdrlen;
-
-        if (unlikely(skb->len < 10))
-                return 0;
-        hdrlen = ieee80211_hdrlen(hdr->frame_control);
-        if (unlikely(hdrlen > skb->len))
-                return 0;
-        return hdrlen;
-}
-EXPORT_SYMBOL(ieee80211_get_hdrlen_from_skb);
-
-int ieee80211_get_mesh_hdrlen(struct ieee80211s_hdr *meshhdr)
-{
-        int ae = meshhdr->flags & IEEE80211S_FLAGS_AE;
-        /* 7.1.3.5a.2 */
-        switch (ae) {
-        case 0:
-                return 6;
-        case 1:
-                return 12;
-        case 2:
-                return 18;
-        case 3:
-                return 24;
-        default:
-                return 6;
-        }
-}
-
 void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx)
 {
         struct sk_buff *skb = tx->skb;
@@ -411,6 +341,52 @@ void ieee80211_stop_queue(struct ieee80211_hw *hw, int queue)
 }
 EXPORT_SYMBOL(ieee80211_stop_queue);
 
+void ieee80211_add_pending_skb(struct ieee80211_local *local,
+                               struct sk_buff *skb)
+{
+        struct ieee80211_hw *hw = &local->hw;
+        unsigned long flags;
+        int queue = skb_get_queue_mapping(skb);
+
+        spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
+        __ieee80211_stop_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD);
+        __ieee80211_stop_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_PENDING);
+        skb_queue_tail(&local->pending[queue], skb);
+        __ieee80211_wake_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD);
+        spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
+}
+
+int ieee80211_add_pending_skbs(struct ieee80211_local *local,
+                               struct sk_buff_head *skbs)
+{
+        struct ieee80211_hw *hw = &local->hw;
+        struct sk_buff *skb;
+        unsigned long flags;
+        int queue, ret = 0, i;
+
+        spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
+        for (i = 0; i < hw->queues; i++)
+                __ieee80211_stop_queue(hw, i,
+                        IEEE80211_QUEUE_STOP_REASON_SKB_ADD);
+
+        while ((skb = skb_dequeue(skbs))) {
+                ret++;
+                queue = skb_get_queue_mapping(skb);
+                skb_queue_tail(&local->pending[queue], skb);
+        }
+
+        for (i = 0; i < hw->queues; i++) {
+                if (ret)
+                        __ieee80211_stop_queue(hw, i,
+                                IEEE80211_QUEUE_STOP_REASON_PENDING);
+                __ieee80211_wake_queue(hw, i,
+                        IEEE80211_QUEUE_STOP_REASON_SKB_ADD);
+        }
+        spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
+
+        return ret;
+}
+
 void ieee80211_stop_queues_by_reason(struct ieee80211_hw *hw,
                                     enum queue_stop_reason reason)
 {
@@ -536,8 +512,16 @@ EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_atomic);
 void ieee802_11_parse_elems(u8 *start, size_t len,
                             struct ieee802_11_elems *elems)
 {
+        ieee802_11_parse_elems_crc(start, len, elems, 0, 0);
+}
+
+u32 ieee802_11_parse_elems_crc(u8 *start, size_t len,
+                               struct ieee802_11_elems *elems,
+                               u64 filter, u32 crc)
+{
         size_t left = len;
         u8 *pos = start;
+        bool calc_crc = filter != 0;
 
         memset(elems, 0, sizeof(*elems));
         elems->ie_start = start;
@@ -551,7 +535,10 @@ void ieee802_11_parse_elems(u8 *start, size_t len,
                 left -= 2;
 
                 if (elen > left)
-                        return;
+                        break;
+
+                if (calc_crc && id < 64 && (filter & BIT(id)))
+                        crc = crc32_be(crc, pos - 2, elen + 2);
 
                 switch (id) {
                 case WLAN_EID_SSID:
@@ -575,8 +562,10 @@ void ieee802_11_parse_elems(u8 *start, size_t len,
                         elems->cf_params_len = elen;
                         break;
                 case WLAN_EID_TIM:
-                        elems->tim = pos;
-                        elems->tim_len = elen;
+                        if (elen >= sizeof(struct ieee80211_tim_ie)) {
+                                elems->tim = (void *)pos;
+                                elems->tim_len = elen;
+                        }
                         break;
                 case WLAN_EID_IBSS_PARAMS:
                         elems->ibss_params = pos;
@@ -586,15 +575,20 @@ void ieee802_11_parse_elems(u8 *start, size_t len,
                         elems->challenge = pos;
                         elems->challenge_len = elen;
                         break;
-                case WLAN_EID_WPA:
+                case WLAN_EID_VENDOR_SPECIFIC:
                         if (elen >= 4 && pos[0] == 0x00 && pos[1] == 0x50 &&
                             pos[2] == 0xf2) {
                                 /* Microsoft OUI (00:50:F2) */
+
+                                if (calc_crc)
+                                        crc = crc32_be(crc, pos - 2, elen + 2);
+
                                 if (pos[3] == 1) {
                                         /* OUI Type 1 - WPA IE */
                                         elems->wpa = pos;
                                         elems->wpa_len = elen;
                                 } else if (elen >= 5 && pos[3] == 2) {
+                                        /* OUI Type 2 - WMM IE */
                                         if (pos[4] == 0) {
                                                 elems->wmm_info = pos;
                                                 elems->wmm_info_len = elen;
@@ -679,32 +673,70 @@ void ieee802_11_parse_elems(u8 *start, size_t len,
                 left -= elen;
                 pos += elen;
         }
+
+        return crc;
 }
 
 void ieee80211_set_wmm_default(struct ieee80211_sub_if_data *sdata)
 {
         struct ieee80211_local *local = sdata->local;
         struct ieee80211_tx_queue_params qparam;
-        int i;
+        int queue;
+        bool use_11b;
+        int aCWmin, aCWmax;
 
         if (!local->ops->conf_tx)
                 return;
 
         memset(&qparam, 0, sizeof(qparam));
 
-        qparam.aifs = 2;
+        use_11b = (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ) &&
+                 !(sdata->flags & IEEE80211_SDATA_OPERATING_GMODE);
 
-        if (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ &&
-            !(sdata->flags & IEEE80211_SDATA_OPERATING_GMODE))
-                qparam.cw_min = 31;
-        else
-                qparam.cw_min = 15;
-
-        qparam.cw_max = 1023;
-        qparam.txop = 0;
+        for (queue = 0; queue < local_to_hw(local)->queues; queue++) {
+                /* Set defaults according to 802.11-2007 Table 7-37 */
+                aCWmax = 1023;
+                if (use_11b)
+                        aCWmin = 31;
+                else
+                        aCWmin = 15;
+
+                switch (queue) {
+                case 3: /* AC_BK */
+                        qparam.cw_max = aCWmax;
+                        qparam.cw_min = aCWmin;
+                        qparam.txop = 0;
+                        qparam.aifs = 7;
+                        break;
+                default: /* never happens but let's not leave undefined */
+                case 2: /* AC_BE */
+                        qparam.cw_max = aCWmax;
+                        qparam.cw_min = aCWmin;
+                        qparam.txop = 0;
+                        qparam.aifs = 3;
+                        break;
+                case 1: /* AC_VI */
+                        qparam.cw_max = aCWmin;
+                        qparam.cw_min = (aCWmin + 1) / 2 - 1;
+                        if (use_11b)
+                                qparam.txop = 6016/32;
+                        else
+                                qparam.txop = 3008/32;
+                        qparam.aifs = 2;
+                        break;
+                case 0: /* AC_VO */
+                        qparam.cw_max = (aCWmin + 1) / 2 - 1;
+                        qparam.cw_min = (aCWmin + 1) / 4 - 1;
+                        if (use_11b)
+                                qparam.txop = 3264/32;
+                        else
+                                qparam.txop = 1504/32;
+                        qparam.aifs = 2;
+                        break;
+                }
 
-        for (i = 0; i < local_to_hw(local)->queues; i++)
-                local->ops->conf_tx(local_to_hw(local), i, &qparam);
+                drv_conf_tx(local, queue, &qparam);
+        }
 }
 
 void ieee80211_sta_def_wmm_params(struct ieee80211_sub_if_data *sdata,
@@ -831,16 +863,73 @@ void ieee80211_send_auth(struct ieee80211_sub_if_data *sdata,
         ieee80211_tx_skb(sdata, skb, encrypt);
 }
 
+int ieee80211_build_preq_ies(struct ieee80211_local *local, u8 *buffer,
+                             const u8 *ie, size_t ie_len)
+{
+        struct ieee80211_supported_band *sband;
+        u8 *pos, *supp_rates_len, *esupp_rates_len = NULL;
+        int i;
+
+        sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
+
+        pos = buffer;
+
+        *pos++ = WLAN_EID_SUPP_RATES;
+        supp_rates_len = pos;
+        *pos++ = 0;
+
+        for (i = 0; i < sband->n_bitrates; i++) {
+                struct ieee80211_rate *rate = &sband->bitrates[i];
+
+                if (esupp_rates_len) {
+                        *esupp_rates_len += 1;
+                } else if (*supp_rates_len == 8) {
+                        *pos++ = WLAN_EID_EXT_SUPP_RATES;
+                        esupp_rates_len = pos;
+                        *pos++ = 1;
+                } else
+                        *supp_rates_len += 1;
+
+                *pos++ = rate->bitrate / 5;
+        }
+
+        if (sband->ht_cap.ht_supported) {
+                __le16 tmp = cpu_to_le16(sband->ht_cap.cap);
+
+                *pos++ = WLAN_EID_HT_CAPABILITY;
+                *pos++ = sizeof(struct ieee80211_ht_cap);
+                memset(pos, 0, sizeof(struct ieee80211_ht_cap));
+                memcpy(pos, &tmp, sizeof(u16));
+                pos += sizeof(u16);
+                /* TODO: needs a define here for << 2 */
+                *pos++ = sband->ht_cap.ampdu_factor |
+                         (sband->ht_cap.ampdu_density << 2);
+                memcpy(pos, &sband->ht_cap.mcs, sizeof(sband->ht_cap.mcs));
+                pos += sizeof(sband->ht_cap.mcs);
+                pos += 2 + 4 + 1; /* ext info, BF cap, antsel */
+        }
+
+        /*
+         * If adding more here, adjust code in main.c
+         * that calculates local->scan_ies_len.
+         */
+
+        if (ie) {
+                memcpy(pos, ie, ie_len);
+                pos += ie_len;
+        }
+
+        return pos - buffer;
+}
+
 void ieee80211_send_probe_req(struct ieee80211_sub_if_data *sdata, u8 *dst,
-                              u8 *ssid, size_t ssid_len,
-                              u8 *ie, size_t ie_len)
+                              const u8 *ssid, size_t ssid_len,
+                              const u8 *ie, size_t ie_len)
 {
         struct ieee80211_local *local = sdata->local;
-        struct ieee80211_supported_band *sband;
         struct sk_buff *skb;
         struct ieee80211_mgmt *mgmt;
-        u8 *pos, *supp_rates, *esupp_rates = NULL;
-        int i;
+        u8 *pos;
 
         skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*mgmt) + 200 +
                             ie_len);
@@ -867,31 +956,9 @@ void ieee80211_send_probe_req(struct ieee80211_sub_if_data *sdata, u8 *dst,
         *pos++ = WLAN_EID_SSID;
         *pos++ = ssid_len;
         memcpy(pos, ssid, ssid_len);
+        pos += ssid_len;
 
-        supp_rates = skb_put(skb, 2);
-        supp_rates[0] = WLAN_EID_SUPP_RATES;
-        supp_rates[1] = 0;
-        sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
-
-        for (i = 0; i < sband->n_bitrates; i++) {
-                struct ieee80211_rate *rate = &sband->bitrates[i];
-                if (esupp_rates) {
-                        pos = skb_put(skb, 1);
-                        esupp_rates[1]++;
-                } else if (supp_rates[1] == 8) {
-                        esupp_rates = skb_put(skb, 3);
-                        esupp_rates[0] = WLAN_EID_EXT_SUPP_RATES;
-                        esupp_rates[1] = 1;
-                        pos = &esupp_rates[2];
-                } else {
-                        pos = skb_put(skb, 1);
-                        supp_rates[1]++;
-                }
-                *pos = rate->bitrate / 5;
-        }
-
-        if (ie)
-                memcpy(skb_put(skb, ie_len), ie, ie_len);
+        skb_put(skb, ieee80211_build_preq_ies(local, pos, ie, ie_len));
 
         ieee80211_tx_skb(sdata, skb, 0);
 }
@@ -931,3 +998,151 @@ u32 ieee80211_sta_get_rates(struct ieee80211_local *local,
         }
         return supp_rates;
 }
+
+int ieee80211_reconfig(struct ieee80211_local *local)
+{
+        struct ieee80211_hw *hw = &local->hw;
+        struct ieee80211_sub_if_data *sdata;
+        struct ieee80211_if_init_conf conf;
+        struct sta_info *sta;
+        unsigned long flags;
+        int res;
+        bool from_suspend = local->suspended;
+
+        /*
+         * We're going to start the hardware, at that point
+         * we are no longer suspended and can RX frames.
+         */
+        local->suspended = false;
+
+        /* restart hardware */
+        if (local->open_count) {
+                res = drv_start(local);
+
+                ieee80211_led_radio(local, true);
+        }
+
+        /* add interfaces */
+        list_for_each_entry(sdata, &local->interfaces, list) {
+                if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
+                    sdata->vif.type != NL80211_IFTYPE_MONITOR &&
+                    netif_running(sdata->dev)) {
+                        conf.vif = &sdata->vif;
+                        conf.type = sdata->vif.type;
+                        conf.mac_addr = sdata->dev->dev_addr;
+                        res = drv_add_interface(local, &conf);
+                }
+        }
+
+        /* add STAs back */
+        if (local->ops->sta_notify) {
+                spin_lock_irqsave(&local->sta_lock, flags);
+                list_for_each_entry(sta, &local->sta_list, list) {
+                        sdata = sta->sdata;
+                        if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
+                                sdata = container_of(sdata->bss,
+                                             struct ieee80211_sub_if_data,
+                                             u.ap);
+
+                        drv_sta_notify(local, &sdata->vif, STA_NOTIFY_ADD,
+                                       &sta->sta);
+                }
+                spin_unlock_irqrestore(&local->sta_lock, flags);
+        }
+
+        /* Clear Suspend state so that ADDBA requests can be processed */
+
+        rcu_read_lock();
+
+        if (hw->flags & IEEE80211_HW_AMPDU_AGGREGATION) {
+                list_for_each_entry_rcu(sta, &local->sta_list, list) {
+                        clear_sta_flags(sta, WLAN_STA_SUSPEND);
+                }
+        }
+
+        rcu_read_unlock();
+
+        /* setup RTS threshold */
+        drv_set_rts_threshold(local, hw->wiphy->rts_threshold);
+
+        /* reconfigure hardware */
+        ieee80211_hw_config(local, ~0);
+
+        netif_addr_lock_bh(local->mdev);
+        ieee80211_configure_filter(local);
+        netif_addr_unlock_bh(local->mdev);
+
+        /* Finally also reconfigure all the BSS information */
+        list_for_each_entry(sdata, &local->interfaces, list) {
+                u32 changed = ~0;
+                if (!netif_running(sdata->dev))
+                        continue;
+                switch (sdata->vif.type) {
+                case NL80211_IFTYPE_STATION:
+                        /* disable beacon change bits */
+                        changed &= ~(BSS_CHANGED_BEACON |
+                                     BSS_CHANGED_BEACON_ENABLED);
+                        /* fall through */
+                case NL80211_IFTYPE_ADHOC:
+                case NL80211_IFTYPE_AP:
+                case NL80211_IFTYPE_MESH_POINT:
+                        ieee80211_bss_info_change_notify(sdata, changed);
+                        break;
+                case NL80211_IFTYPE_WDS:
+                        break;
+                case NL80211_IFTYPE_AP_VLAN:
+                case NL80211_IFTYPE_MONITOR:
+                        /* ignore virtual */
+                        break;
+                case NL80211_IFTYPE_UNSPECIFIED:
+                case __NL80211_IFTYPE_AFTER_LAST:
+                        WARN_ON(1);
+                        break;
+                }
+        }
+
+        /* add back keys */
+        list_for_each_entry(sdata, &local->interfaces, list)
+                if (netif_running(sdata->dev))
+                        ieee80211_enable_keys(sdata);
+
+        ieee80211_wake_queues_by_reason(hw,
+                        IEEE80211_QUEUE_STOP_REASON_SUSPEND);
+
+        /*
+         * If this is for hw restart things are still running.
+         * We may want to change that later, however.
+         */
+        if (!from_suspend)
+                return 0;
+
+#ifdef CONFIG_PM
+        local->suspended = false;
+
+        list_for_each_entry(sdata, &local->interfaces, list) {
+                switch(sdata->vif.type) {
+                case NL80211_IFTYPE_STATION:
+                        ieee80211_sta_restart(sdata);
+                        break;
+                case NL80211_IFTYPE_ADHOC:
+                        ieee80211_ibss_restart(sdata);
+                        break;
+                case NL80211_IFTYPE_MESH_POINT:
+                        ieee80211_mesh_restart(sdata);
+                        break;
+                default:
+                        break;
+                }
+        }
+
+        add_timer(&local->sta_cleanup);
+
+        spin_lock_irqsave(&local->sta_lock, flags);
+        list_for_each_entry(sta, &local->sta_list, list)
+                mesh_plink_restart(sta);
+        spin_unlock_irqrestore(&local->sta_lock, flags);
+#else
+        WARN_ON(1);
+#endif
+        return 0;
+}
diff --git a/net/mac80211/wext.c b/net/mac80211/wext.c
index 959aa8379ccf..d2d81b103341 100644
--- a/net/mac80211/wext.c
+++ b/net/mac80211/wext.c
@@ -27,100 +27,6 @@
 #include "aes_ccm.h"
 
 
-static int ieee80211_set_encryption(struct ieee80211_sub_if_data *sdata, u8 *sta_addr,
-                                    int idx, int alg, int remove,
-                                    int set_tx_key, const u8 *_key,
-                                    size_t key_len)
-{
-        struct ieee80211_local *local = sdata->local;
-        struct sta_info *sta;
-        struct ieee80211_key *key;
-        int err;
-
-        if (alg == ALG_AES_CMAC) {
-                if (idx < NUM_DEFAULT_KEYS ||
-                    idx >= NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS) {
-                        printk(KERN_DEBUG "%s: set_encrypt - invalid idx=%d "
-                               "(BIP)\n", sdata->dev->name, idx);
-                        return -EINVAL;
-                }
-        } else if (idx < 0 || idx >= NUM_DEFAULT_KEYS) {
-                printk(KERN_DEBUG "%s: set_encrypt - invalid idx=%d\n",
-                       sdata->dev->name, idx);
-                return -EINVAL;
-        }
-
-        if (remove) {
-                rcu_read_lock();
-
-                err = 0;
-
-                if (is_broadcast_ether_addr(sta_addr)) {
-                        key = sdata->keys[idx];
-                } else {
-                        sta = sta_info_get(local, sta_addr);
-                        if (!sta) {
-                                err = -ENOENT;
-                                goto out_unlock;
-                        }
-                        key = sta->key;
-                }
-
-                ieee80211_key_free(key);
-        } else {
-                key = ieee80211_key_alloc(alg, idx, key_len, _key);
-                if (!key)
-                        return -ENOMEM;
-
-                sta = NULL;
-                err = 0;
-
-                rcu_read_lock();
-
-                if (!is_broadcast_ether_addr(sta_addr)) {
-                        set_tx_key = 0;
-                        /*
-                         * According to the standard, the key index of a
-                         * pairwise key must be zero. However, some AP are
-                         * broken when it comes to WEP key indices, so we
-                         * work around this.
-                         */
-                        if (idx != 0 && alg != ALG_WEP) {
-                                ieee80211_key_free(key);
-                                err = -EINVAL;
-                                goto out_unlock;
-                        }
-
-                        sta = sta_info_get(local, sta_addr);
-                        if (!sta) {
-                                ieee80211_key_free(key);
-                                err = -ENOENT;
-                                goto out_unlock;
-                        }
-                }
-
-                if (alg == ALG_WEP &&
-                        key_len != LEN_WEP40 && key_len != LEN_WEP104) {
-                        ieee80211_key_free(key);
-                        err = -EINVAL;
-                        goto out_unlock;
-                }
-
-                ieee80211_key_link(key, sdata, sta);
-
-                if (set_tx_key || (!sta && !sdata->default_key && key))
-                        ieee80211_set_default_key(sdata, idx);
-                if (alg == ALG_AES_CMAC &&
-                    (set_tx_key || (!sta && !sdata->default_mgmt_key && key)))
-                        ieee80211_set_default_mgmt_key(sdata, idx);
-        }
-
- out_unlock:
-        rcu_read_unlock();
-
-        return err;
-}
-
 static int ieee80211_ioctl_siwgenie(struct net_device *dev,
                                     struct iw_request_info *info,
                                     struct iw_point *data, char *extra)
@@ -131,11 +37,13 @@ static int ieee80211_ioctl_siwgenie(struct net_device *dev,
 
         if (sdata->vif.type == NL80211_IFTYPE_STATION) {
                 int ret = ieee80211_sta_set_extra_ie(sdata, extra, data->length);
-                if (ret)
+                if (ret && ret != -EALREADY)
                         return ret;
                 sdata->u.mgd.flags &= ~IEEE80211_STA_AUTO_BSSID_SEL;
                 sdata->u.mgd.flags &= ~IEEE80211_STA_EXT_SME;
-                ieee80211_sta_req_auth(sdata);
+                sdata->u.mgd.flags &= ~IEEE80211_STA_CONTROL_PORT;
+                if (ret != -EALREADY)
+                        ieee80211_sta_req_auth(sdata);
                 return 0;
         }
 
@@ -149,17 +57,14 @@ static int ieee80211_ioctl_siwfreq(struct net_device *dev,
         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 
         if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
-                sdata->u.ibss.flags &= ~IEEE80211_IBSS_AUTO_CHANNEL_SEL;
+                return cfg80211_ibss_wext_siwfreq(dev, info, freq, extra);
         else if (sdata->vif.type == NL80211_IFTYPE_STATION)
                 sdata->u.mgd.flags &= ~IEEE80211_STA_AUTO_CHANNEL_SEL;
 
         /* freq->e == 0: freq->m = channel; otherwise freq = m * 10^e */
         if (freq->e == 0) {
                 if (freq->m < 0) {
-                        if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
-                                sdata->u.ibss.flags |=
-                                        IEEE80211_IBSS_AUTO_CHANNEL_SEL;
-                        else if (sdata->vif.type == NL80211_IFTYPE_STATION)
+                        if (sdata->vif.type == NL80211_IFTYPE_STATION)
                                 sdata->u.mgd.flags |=
                                         IEEE80211_STA_AUTO_CHANNEL_SEL;
                         return 0;
@@ -183,8 +88,12 @@ static int ieee80211_ioctl_giwfreq(struct net_device *dev,
                                    struct iw_freq *freq, char *extra)
 {
         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
+        struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 
-        freq->m = local->hw.conf.channel->center_freq;
+        if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
+                return cfg80211_ibss_wext_giwfreq(dev, info, freq, extra);
+
+        freq->m = local->oper_channel->center_freq;
         freq->e = 6;
 
         return 0;
@@ -195,15 +104,17 @@ static int ieee80211_ioctl_siwessid(struct net_device *dev,
                                     struct iw_request_info *info,
                                     struct iw_point *data, char *ssid)
 {
-        struct ieee80211_sub_if_data *sdata;
+        struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
         size_t len = data->length;
         int ret;
 
+        if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
+                return cfg80211_ibss_wext_siwessid(dev, info, data, ssid);
+
         /* iwconfig uses nul termination in SSID.. */
         if (len > 0 && ssid[len - 1] == '\0')
                 len--;
 
-        sdata = IEEE80211_DEV_TO_SUB_IF(dev);
         if (sdata->vif.type == NL80211_IFTYPE_STATION) {
                 if (data->flags)
                         sdata->u.mgd.flags &= ~IEEE80211_STA_AUTO_SSID_SEL;
@@ -215,10 +126,10 @@ static int ieee80211_ioctl_siwessid(struct net_device *dev,
                         return ret;
 
                 sdata->u.mgd.flags &= ~IEEE80211_STA_EXT_SME;
+                sdata->u.mgd.flags &= ~IEEE80211_STA_CONTROL_PORT;
                 ieee80211_sta_req_auth(sdata);
                 return 0;
-        } else if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
-                return ieee80211_ibss_set_ssid(sdata, ssid, len);
+        }
 
         return -EOPNOTSUPP;
 }
@@ -229,9 +140,13 @@ static int ieee80211_ioctl_giwessid(struct net_device *dev,
                                     struct iw_point *data, char *ssid)
 {
         size_t len;
-
         struct ieee80211_sub_if_data *sdata;
+
         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
+
+        if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
+                return cfg80211_ibss_wext_giwessid(dev, info, data, ssid);
+
         if (sdata->vif.type == NL80211_IFTYPE_STATION) {
                 int res = ieee80211_sta_get_ssid(sdata, ssid, &len);
                 if (res == 0) {
@@ -240,14 +155,6 @@ static int ieee80211_ioctl_giwessid(struct net_device *dev,
                 } else
                         data->flags = 0;
                 return res;
-        } else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
-                int res = ieee80211_ibss_get_ssid(sdata, ssid, &len);
-                if (res == 0) {
-                        data->length = len;
-                        data->flags = 1;
-                } else
-                        data->flags = 0;
-                return res;
         }
 
         return -EOPNOTSUPP;
@@ -258,9 +165,11 @@ static int ieee80211_ioctl_siwap(struct net_device *dev,
                                  struct iw_request_info *info,
                                  struct sockaddr *ap_addr, char *extra)
 {
-        struct ieee80211_sub_if_data *sdata;
+        struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
+
+        if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
+                return cfg80211_ibss_wext_siwap(dev, info, ap_addr, extra);
 
-        sdata = IEEE80211_DEV_TO_SUB_IF(dev);
         if (sdata->vif.type == NL80211_IFTYPE_STATION) {
                 int ret;
 
@@ -275,18 +184,9 @@ static int ieee80211_ioctl_siwap(struct net_device *dev,
                 if (ret)
                         return ret;
                 sdata->u.mgd.flags &= ~IEEE80211_STA_EXT_SME;
+                sdata->u.mgd.flags &= ~IEEE80211_STA_CONTROL_PORT;
                 ieee80211_sta_req_auth(sdata);
                 return 0;
-        } else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
-                if (is_zero_ether_addr((u8 *) &ap_addr->sa_data))
-                        sdata->u.ibss.flags |= IEEE80211_IBSS_AUTO_BSSID_SEL |
-                                               IEEE80211_IBSS_AUTO_CHANNEL_SEL;
-                else if (is_broadcast_ether_addr((u8 *) &ap_addr->sa_data))
-                        sdata->u.ibss.flags |= IEEE80211_IBSS_AUTO_BSSID_SEL;
-                else
-                        sdata->u.ibss.flags &= ~IEEE80211_IBSS_AUTO_BSSID_SEL;
-
-                return ieee80211_ibss_set_bssid(sdata, (u8 *) &ap_addr->sa_data);
         } else if (sdata->vif.type == NL80211_IFTYPE_WDS) {
                 /*
                  * If it is necessary to update the WDS peer address
@@ -312,9 +212,11 @@ static int ieee80211_ioctl_giwap(struct net_device *dev,
                                  struct iw_request_info *info,
                                  struct sockaddr *ap_addr, char *extra)
 {
-        struct ieee80211_sub_if_data *sdata;
+        struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
+
+        if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
+                return cfg80211_ibss_wext_giwap(dev, info, ap_addr, extra);
 
-        sdata = IEEE80211_DEV_TO_SUB_IF(dev);
         if (sdata->vif.type == NL80211_IFTYPE_STATION) {
                 if (sdata->u.mgd.state == IEEE80211_STA_MLME_ASSOCIATED) {
                         ap_addr->sa_family = ARPHRD_ETHER;
@@ -322,13 +224,6 @@ static int ieee80211_ioctl_giwap(struct net_device *dev,
                 } else
                         memset(&ap_addr->sa_data, 0, ETH_ALEN);
                 return 0;
-        } else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
-                if (sdata->u.ibss.state == IEEE80211_IBSS_MLME_JOINED) {
-                        ap_addr->sa_family = ARPHRD_ETHER;
-                        memcpy(&ap_addr->sa_data, sdata->u.ibss.bssid, ETH_ALEN);
-                } else
-                        memset(&ap_addr->sa_data, 0, ETH_ALEN);
-                return 0;
         } else if (sdata->vif.type == NL80211_IFTYPE_WDS) {
                 ap_addr->sa_family = ARPHRD_ETHER;
                 memcpy(&ap_addr->sa_data, sdata->u.wds.remote_addr, ETH_ALEN);
@@ -411,334 +306,6 @@ static int ieee80211_ioctl_giwrate(struct net_device *dev,
         return 0;
 }
 
-static int ieee80211_ioctl_siwtxpower(struct net_device *dev,
-                                      struct iw_request_info *info,
-                                      union iwreq_data *data, char *extra)
-{
-        struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
-        struct ieee80211_channel* chan = local->hw.conf.channel;
-        bool reconf = false;
-        u32 reconf_flags = 0;
-        int new_power_level;
-
-        if ((data->txpower.flags & IW_TXPOW_TYPE) != IW_TXPOW_DBM)
-                return -EINVAL;
-        if (data->txpower.flags & IW_TXPOW_RANGE)
-                return -EINVAL;
-        if (!chan)
-                return -EINVAL;
-
-        /* only change when not disabling */
-        if (!data->txpower.disabled) {
-                if (data->txpower.fixed) {
-                        if (data->txpower.value < 0)
-                                return -EINVAL;
-                        new_power_level = data->txpower.value;
-                        /*
-                         * Debatable, but we cannot do a fixed power
-                         * level above the regulatory constraint.
-                         * Use "iwconfig wlan0 txpower 15dBm" instead.
-                         */
-                        if (new_power_level > chan->max_power)
-                                return -EINVAL;
-                } else {
-                        /*
-                         * Automatic power level setting, max being the value
-                         * passed in from userland.
-                         */
-                        if (data->txpower.value < 0)
-                                new_power_level = -1;
-                        else
-                                new_power_level = data->txpower.value;
-                }
-
-                reconf = true;
-
-                /*
-                 * ieee80211_hw_config() will limit to the channel's
-                 * max power and possibly power constraint from AP.
-                 */
-                local->user_power_level = new_power_level;
-        }
-
-        if (local->hw.conf.radio_enabled != !(data->txpower.disabled)) {
-                local->hw.conf.radio_enabled = !(data->txpower.disabled);
-                reconf_flags |= IEEE80211_CONF_CHANGE_RADIO_ENABLED;
-                ieee80211_led_radio(local, local->hw.conf.radio_enabled);
-        }
-
-        if (reconf || reconf_flags)
-                ieee80211_hw_config(local, reconf_flags);
-
-        return 0;
-}
-
-static int ieee80211_ioctl_giwtxpower(struct net_device *dev,
-                                   struct iw_request_info *info,
-                                   union iwreq_data *data, char *extra)
-{
-        struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
-
-        data->txpower.fixed = 1;
-        data->txpower.disabled = !(local->hw.conf.radio_enabled);
-        data->txpower.value = local->hw.conf.power_level;
-        data->txpower.flags = IW_TXPOW_DBM;
-
-        return 0;
-}
-
-static int ieee80211_ioctl_siwrts(struct net_device *dev,
-                                  struct iw_request_info *info,
-                                  struct iw_param *rts, char *extra)
-{
-        struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
-
-        if (rts->disabled)
-                local->rts_threshold = IEEE80211_MAX_RTS_THRESHOLD;
-        else if (!rts->fixed)
-                /* if the rts value is not fixed, then take default */
-                local->rts_threshold = IEEE80211_MAX_RTS_THRESHOLD;
-        else if (rts->value < 0 || rts->value > IEEE80211_MAX_RTS_THRESHOLD)
-                return -EINVAL;
-        else
-                local->rts_threshold = rts->value;
-
-        /* If the wlan card performs RTS/CTS in hardware/firmware,
-         * configure it here */
-
-        if (local->ops->set_rts_threshold)
-                local->ops->set_rts_threshold(local_to_hw(local),
-                                             local->rts_threshold);
-
-        return 0;
-}
-
-static int ieee80211_ioctl_giwrts(struct net_device *dev,
-                                  struct iw_request_info *info,
-                                  struct iw_param *rts, char *extra)
-{
-        struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
-
-        rts->value = local->rts_threshold;
-        rts->disabled = (rts->value >= IEEE80211_MAX_RTS_THRESHOLD);
-        rts->fixed = 1;
-
-        return 0;
-}
-
-
-static int ieee80211_ioctl_siwfrag(struct net_device *dev,
-                                   struct iw_request_info *info,
-                                   struct iw_param *frag, char *extra)
-{
-        struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
-
-        if (frag->disabled)
-                local->fragmentation_threshold = IEEE80211_MAX_FRAG_THRESHOLD;
-        else if (!frag->fixed)
-                local->fragmentation_threshold = IEEE80211_MAX_FRAG_THRESHOLD;
-        else if (frag->value < 256 ||
-                 frag->value > IEEE80211_MAX_FRAG_THRESHOLD)
-                return -EINVAL;
-        else {
-                /* Fragment length must be even, so strip LSB. */
-                local->fragmentation_threshold = frag->value & ~0x1;
-        }
-
-        return 0;
-}
-
-static int ieee80211_ioctl_giwfrag(struct net_device *dev,
-                                   struct iw_request_info *info,
-                                   struct iw_param *frag, char *extra)
-{
-        struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
-
-        frag->value = local->fragmentation_threshold;
-        frag->disabled = (frag->value >= IEEE80211_MAX_FRAG_THRESHOLD);
-        frag->fixed = 1;
-
-        return 0;
-}
-
-
-static int ieee80211_ioctl_siwretry(struct net_device *dev,
-                                    struct iw_request_info *info,
-                                    struct iw_param *retry, char *extra)
-{
-        struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
-
-        if (retry->disabled ||
-            (retry->flags & IW_RETRY_TYPE) != IW_RETRY_LIMIT)
-                return -EINVAL;
-
-        if (retry->flags & IW_RETRY_MAX) {
-                local->hw.conf.long_frame_max_tx_count = retry->value;
-        } else if (retry->flags & IW_RETRY_MIN) {
-                local->hw.conf.short_frame_max_tx_count = retry->value;
-        } else {
-                local->hw.conf.long_frame_max_tx_count = retry->value;
-                local->hw.conf.short_frame_max_tx_count = retry->value;
-        }
-
-        ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_RETRY_LIMITS);
-
-        return 0;
-}
-
-
-static int ieee80211_ioctl_giwretry(struct net_device *dev,
-                                    struct iw_request_info *info,
-                                    struct iw_param *retry, char *extra)
-{
-        struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
-
-        retry->disabled = 0;
-        if (retry->flags == 0 || retry->flags & IW_RETRY_MIN) {
-                /* first return min value, iwconfig will ask max value
-                 * later if needed */
-                retry->flags |= IW_RETRY_LIMIT;
-                retry->value = local->hw.conf.short_frame_max_tx_count;
-                if (local->hw.conf.long_frame_max_tx_count !=
-                    local->hw.conf.short_frame_max_tx_count)
-                        retry->flags |= IW_RETRY_MIN;
-                return 0;
-        }
-        if (retry->flags & IW_RETRY_MAX) {
-                retry->flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
-                retry->value = local->hw.conf.long_frame_max_tx_count;
-        }
-
-        return 0;
-}
-
-static int ieee80211_ioctl_siwmlme(struct net_device *dev,
-                                   struct iw_request_info *info,
-                                   struct iw_point *data, char *extra)
-{
-        struct ieee80211_sub_if_data *sdata;
-        struct iw_mlme *mlme = (struct iw_mlme *) extra;
-
-        sdata = IEEE80211_DEV_TO_SUB_IF(dev);
-        if (!(sdata->vif.type == NL80211_IFTYPE_STATION))
-                return -EINVAL;
-
-        switch (mlme->cmd) {
-        case IW_MLME_DEAUTH:
-                /* TODO: mlme->addr.sa_data */
-                return ieee80211_sta_deauthenticate(sdata, mlme->reason_code);
-        case IW_MLME_DISASSOC:
-                /* TODO: mlme->addr.sa_data */
-                return ieee80211_sta_disassociate(sdata, mlme->reason_code);
-        default:
-                return -EOPNOTSUPP;
-        }
-}
-
-
-static int ieee80211_ioctl_siwencode(struct net_device *dev,
-                                     struct iw_request_info *info,
-                                     struct iw_point *erq, char *keybuf)
-{
-        struct ieee80211_sub_if_data *sdata;
-        int idx, i, alg = ALG_WEP;
-        u8 bcaddr[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
-        int remove = 0, ret;
-
-        sdata = IEEE80211_DEV_TO_SUB_IF(dev);
-
-        idx = erq->flags & IW_ENCODE_INDEX;
-        if (idx == 0) {
-                if (sdata->default_key)
-                        for (i = 0; i < NUM_DEFAULT_KEYS; i++) {
-                                if (sdata->default_key == sdata->keys[i]) {
-                                        idx = i;
-                                        break;
-                                }
-                        }
-        } else if (idx < 1 || idx > 4)
-                return -EINVAL;
-        else
-                idx--;
-
-        if (erq->flags & IW_ENCODE_DISABLED)
-                remove = 1;
-        else if (erq->length == 0) {
-                /* No key data - just set the default TX key index */
-                ieee80211_set_default_key(sdata, idx);
-                return 0;
-        }
-
-        ret = ieee80211_set_encryption(
-                sdata, bcaddr,
-                idx, alg, remove,
-                !sdata->default_key,
-                keybuf, erq->length);
-
-        if (!ret) {
-                if (remove)
-                        sdata->u.mgd.flags &= ~IEEE80211_STA_TKIP_WEP_USED;
-                else
-                        sdata->u.mgd.flags |= IEEE80211_STA_TKIP_WEP_USED;
-        }
-
-        return ret;
-}
-
-
-static int ieee80211_ioctl_giwencode(struct net_device *dev,
-                                     struct iw_request_info *info,
-                                     struct iw_point *erq, char *key)
-{
-        struct ieee80211_sub_if_data *sdata;
-        int idx, i;
-
-        sdata = IEEE80211_DEV_TO_SUB_IF(dev);
-
-        idx = erq->flags & IW_ENCODE_INDEX;
-        if (idx < 1 || idx > 4) {
-                idx = -1;
-                if (!sdata->default_key)
-                        idx = 0;
-                else for (i = 0; i < NUM_DEFAULT_KEYS; i++) {
-                        if (sdata->default_key == sdata->keys[i]) {
-                                idx = i;
-                                break;
-                        }
-                }
-                if (idx < 0)
-                        return -EINVAL;
-        } else
-                idx--;
-
-        erq->flags = idx + 1;
-
-        if (!sdata->keys[idx]) {
-                erq->length = 0;
-                erq->flags |= IW_ENCODE_DISABLED;
-                return 0;
-        }
-
-        memcpy(key, sdata->keys[idx]->conf.key,
-               min_t(int, erq->length, sdata->keys[idx]->conf.keylen));
-        erq->length = sdata->keys[idx]->conf.keylen;
-        erq->flags |= IW_ENCODE_ENABLED;
-
-        if (sdata->vif.type == NL80211_IFTYPE_STATION) {
-                switch (sdata->u.mgd.auth_alg) {
-                case WLAN_AUTH_OPEN:
-                case WLAN_AUTH_LEAP:
-                        erq->flags |= IW_ENCODE_OPEN;
-                        break;
-                case WLAN_AUTH_SHARED_KEY:
-                        erq->flags |= IW_ENCODE_RESTRICTED;
-                        break;
-                }
-        }
-
-        return 0;
-}
-
 static int ieee80211_ioctl_siwpower(struct net_device *dev,
                                     struct iw_request_info *info,
                                     struct iw_param *wrq,
@@ -747,7 +314,7 @@ static int ieee80211_ioctl_siwpower(struct net_device *dev,
         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
         struct ieee80211_conf *conf = &local->hw.conf;
-        int ret = 0, timeout = 0;
+        int timeout = 0;
         bool ps;
 
         if (!(local->hw.flags & IEEE80211_HW_SUPPORTS_PS))
@@ -779,42 +346,18 @@ static int ieee80211_ioctl_siwpower(struct net_device *dev,
                 timeout = wrq->value / 1000;
 
  set:
-        if (ps == local->powersave && timeout == conf->dynamic_ps_timeout)
-                return ret;
+        if (ps == sdata->u.mgd.powersave && timeout == conf->dynamic_ps_timeout)
+                return 0;
 
-        local->powersave = ps;
+        sdata->u.mgd.powersave = ps;
         conf->dynamic_ps_timeout = timeout;
 
         if (local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS)
-                ret = ieee80211_hw_config(local,
-                                          IEEE80211_CONF_CHANGE_DYNPS_TIMEOUT);
-
-        if (!(sdata->u.mgd.flags & IEEE80211_STA_ASSOCIATED))
-                return ret;
+                ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
 
-        if (conf->dynamic_ps_timeout > 0 &&
-            !(local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS)) {
-                mod_timer(&local->dynamic_ps_timer, jiffies +
-                          msecs_to_jiffies(conf->dynamic_ps_timeout));
-        } else {
-                if (local->powersave) {
-                        if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)
-                                ieee80211_send_nullfunc(local, sdata, 1);
-                        conf->flags |= IEEE80211_CONF_PS;
-                        ret = ieee80211_hw_config(local,
-                                        IEEE80211_CONF_CHANGE_PS);
-                } else {
-                        conf->flags &= ~IEEE80211_CONF_PS;
-                        ret = ieee80211_hw_config(local,
-                                        IEEE80211_CONF_CHANGE_PS);
-                        if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)
-                                ieee80211_send_nullfunc(local, sdata, 0);
-                        del_timer_sync(&local->dynamic_ps_timer);
-                        cancel_work_sync(&local->dynamic_ps_enable_work);
-                }
-        }
+        ieee80211_recalc_ps(local, -1);
 
-        return ret;
+        return 0;
 }
 
 static int ieee80211_ioctl_giwpower(struct net_device *dev,
@@ -822,9 +365,9 @@ static int ieee80211_ioctl_giwpower(struct net_device *dev,
                                     union iwreq_data *wrqu,
                                     char *extra)
 {
-        struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
+        struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 
-        wrqu->power.disabled = !local->powersave;
+        wrqu->power.disabled = !sdata->u.mgd.powersave;
 
         return 0;
 }
@@ -997,82 +540,6 @@ static int ieee80211_ioctl_giwauth(struct net_device *dev,
 }
 
 
-static int ieee80211_ioctl_siwencodeext(struct net_device *dev,
-                                        struct iw_request_info *info,
-                                        struct iw_point *erq, char *extra)
-{
-        struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
-        struct iw_encode_ext *ext = (struct iw_encode_ext *) extra;
-        int uninitialized_var(alg), idx, i, remove = 0;
-
-        switch (ext->alg) {
-        case IW_ENCODE_ALG_NONE:
-                remove = 1;
-                break;
-        case IW_ENCODE_ALG_WEP:
-                alg = ALG_WEP;
-                break;
-        case IW_ENCODE_ALG_TKIP:
-                alg = ALG_TKIP;
-                break;
-        case IW_ENCODE_ALG_CCMP:
-                alg = ALG_CCMP;
-                break;
-        case IW_ENCODE_ALG_AES_CMAC:
-                alg = ALG_AES_CMAC;
-                break;
-        default:
-                return -EOPNOTSUPP;
-        }
-
-        if (erq->flags & IW_ENCODE_DISABLED)
-                remove = 1;
-
-        idx = erq->flags & IW_ENCODE_INDEX;
-        if (alg == ALG_AES_CMAC) {
-                if (idx < NUM_DEFAULT_KEYS + 1 ||
-                    idx > NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS) {
-                        idx = -1;
-                        if (!sdata->default_mgmt_key)
-                                idx = 0;
-                        else for (i = NUM_DEFAULT_KEYS;
-                                  i < NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS;
-                                  i++) {
-                                if (sdata->default_mgmt_key == sdata->keys[i])
-                                {
-                                        idx = i;
-                                        break;
-                                }
-                        }
-                        if (idx < 0)
-                                return -EINVAL;
-                } else
-                        idx--;
-        } else {
-                if (idx < 1 || idx > 4) {
-                        idx = -1;
-                        if (!sdata->default_key)
-                                idx = 0;
-                        else for (i = 0; i < NUM_DEFAULT_KEYS; i++) {
-                                if (sdata->default_key == sdata->keys[i]) {
-                                        idx = i;
-                                        break;
-                                }
-                        }
-                        if (idx < 0)
-                                return -EINVAL;
-                } else
-                        idx--;
-        }
-
-        return ieee80211_set_encryption(sdata, ext->addr.sa_data, idx, alg,
-                                        remove,
-                                        ext->ext_flags &
-                                        IW_ENCODE_EXT_SET_TX_KEY,
-                                        ext->key, ext->key_len);
-}
-
-
 /* Structures to export the Wireless Handlers */
 
 static const iw_handler ieee80211_handler[] =
@@ -1099,7 +566,7 @@ static const iw_handler ieee80211_handler[] =
         (iw_handler) NULL,                              /* SIOCGIWTHRSPY */
         (iw_handler) ieee80211_ioctl_siwap,             /* SIOCSIWAP */
         (iw_handler) ieee80211_ioctl_giwap,             /* SIOCGIWAP */
-        (iw_handler) ieee80211_ioctl_siwmlme,           /* SIOCSIWMLME */
+        (iw_handler) cfg80211_wext_siwmlme,             /* SIOCSIWMLME */
         (iw_handler) NULL,                              /* SIOCGIWAPLIST */
         (iw_handler) cfg80211_wext_siwscan,             /* SIOCSIWSCAN */
         (iw_handler) cfg80211_wext_giwscan,             /* SIOCGIWSCAN */
@@ -1111,16 +578,16 @@ static const iw_handler ieee80211_handler[] =
         (iw_handler) NULL,                              /* -- hole -- */
         (iw_handler) ieee80211_ioctl_siwrate,           /* SIOCSIWRATE */
         (iw_handler) ieee80211_ioctl_giwrate,           /* SIOCGIWRATE */
-        (iw_handler) ieee80211_ioctl_siwrts,            /* SIOCSIWRTS */
-        (iw_handler) ieee80211_ioctl_giwrts,            /* SIOCGIWRTS */
-        (iw_handler) ieee80211_ioctl_siwfrag,           /* SIOCSIWFRAG */
-        (iw_handler) ieee80211_ioctl_giwfrag,           /* SIOCGIWFRAG */
-        (iw_handler) ieee80211_ioctl_siwtxpower,        /* SIOCSIWTXPOW */
-        (iw_handler) ieee80211_ioctl_giwtxpower,        /* SIOCGIWTXPOW */
-        (iw_handler) ieee80211_ioctl_siwretry,          /* SIOCSIWRETRY */
-        (iw_handler) ieee80211_ioctl_giwretry,          /* SIOCGIWRETRY */
-        (iw_handler) ieee80211_ioctl_siwencode,         /* SIOCSIWENCODE */
-        (iw_handler) ieee80211_ioctl_giwencode,         /* SIOCGIWENCODE */
+        (iw_handler) cfg80211_wext_siwrts,              /* SIOCSIWRTS */
+        (iw_handler) cfg80211_wext_giwrts,              /* SIOCGIWRTS */
+        (iw_handler) cfg80211_wext_siwfrag,             /* SIOCSIWFRAG */
+        (iw_handler) cfg80211_wext_giwfrag,             /* SIOCGIWFRAG */
+        (iw_handler) cfg80211_wext_siwtxpower,          /* SIOCSIWTXPOW */
+        (iw_handler) cfg80211_wext_giwtxpower,          /* SIOCGIWTXPOW */
+        (iw_handler) cfg80211_wext_siwretry,            /* SIOCSIWRETRY */
+        (iw_handler) cfg80211_wext_giwretry,            /* SIOCGIWRETRY */
+        (iw_handler) cfg80211_wext_siwencode,           /* SIOCSIWENCODE */
+        (iw_handler) cfg80211_wext_giwencode,           /* SIOCGIWENCODE */
         (iw_handler) ieee80211_ioctl_siwpower,          /* SIOCSIWPOWER */
         (iw_handler) ieee80211_ioctl_giwpower,          /* SIOCGIWPOWER */
         (iw_handler) NULL,                              /* -- hole -- */
@@ -1129,7 +596,7 @@ static const iw_handler ieee80211_handler[] =
         (iw_handler) NULL,                              /* SIOCGIWGENIE */
         (iw_handler) ieee80211_ioctl_siwauth,           /* SIOCSIWAUTH */
         (iw_handler) ieee80211_ioctl_giwauth,           /* SIOCGIWAUTH */
-        (iw_handler) ieee80211_ioctl_siwencodeext,      /* SIOCSIWENCODEEXT */
+        (iw_handler) cfg80211_wext_siwencodeext,        /* SIOCSIWENCODEEXT */
         (iw_handler) NULL,                              /* SIOCGIWENCODEEXT */
         (iw_handler) NULL,                              /* SIOCSIWPMKSA */
         (iw_handler) NULL,                              /* -- hole -- */
diff --git a/net/mac80211/wme.c b/net/mac80211/wme.c
index 0b8ad1f4ecdd..116a923b14d6 100644
--- a/net/mac80211/wme.c
+++ b/net/mac80211/wme.c
@@ -23,34 +23,6 @@
  */
 const int ieee802_1d_to_ac[8] = { 2, 3, 3, 2, 1, 1, 0, 0 };
 
-static const char llc_ip_hdr[8] = {0xAA, 0xAA, 0x3, 0, 0, 0, 0x08, 0};
-
-/* Given a data frame determine the 802.1p/1d tag to use.  */
-static unsigned int classify_1d(struct sk_buff *skb)
-{
-        unsigned int dscp;
-
-        /* skb->priority values from 256->263 are magic values to
-         * directly indicate a specific 802.1d priority.  This is used
-         * to allow 802.1d priority to be passed directly in from VLAN
-         * tags, etc.
-         */
-        if (skb->priority >= 256 && skb->priority <= 263)
-                return skb->priority - 256;
-
-        switch (skb->protocol) {
-        case htons(ETH_P_IP):
-                dscp = ip_hdr(skb)->tos & 0xfc;
-                break;
-
-        default:
-                return 0;
-        }
-
-        return dscp >> 5;
-}
-
-
 static int wme_downgrade_ac(struct sk_buff *skb)
 {
         switch (skb->priority) {
@@ -94,7 +66,7 @@ static u16 classify80211(struct ieee80211_local *local, struct sk_buff *skb)
 
         /* use the data classifier to determine what 802.1d tag the
          * data frame has */
-        skb->priority = classify_1d(skb);
+        skb->priority = cfg80211_classify8021d(skb);
 
         /* in case we are a client verify acm is not set for this ac */
         while (unlikely(local->wmm_acm & BIT(skb->priority))) {
@@ -129,11 +101,11 @@ u16 ieee80211_select_queue(struct net_device *dev, struct sk_buff *skb)
          * Now we know the 1d priority, fill in the QoS header if
          * there is one (and we haven't done this before).
          */
-        if (!skb->requeue && ieee80211_is_data_qos(hdr->frame_control)) {
+        if (ieee80211_is_data_qos(hdr->frame_control)) {
                 u8 *p = ieee80211_get_qos_ctl(hdr);
                 u8 ack_policy = 0;
                 tid = skb->priority & IEEE80211_QOS_CTL_TAG1D_MASK;
-                if (local->wifi_wme_noack_test)
+                if (unlikely(local->wifi_wme_noack_test))
                         ack_policy |= QOS_CONTROL_ACK_POLICY_NOACK <<
                                         QOS_CONTROL_ACK_POLICY_SHIFT;
                 /* qos header is 2 bytes, second reserved */
diff --git a/net/mac80211/wpa.c b/net/mac80211/wpa.c
index 4f8bfea278f2..dcfae8884b86 100644
--- a/net/mac80211/wpa.c
+++ b/net/mac80211/wpa.c
@@ -122,7 +122,7 @@ ieee80211_rx_h_michael_mic_verify(struct ieee80211_rx_data *rx)
                         return RX_DROP_UNUSABLE;
 
                 mac80211_ev_michael_mic_failure(rx->sdata, rx->key->conf.keyidx,
-                                                (void *) skb->data);
+                                                (void *) skb->data, NULL);
                 return RX_DROP_UNUSABLE;
         }
 
diff --git a/net/netfilter/Kconfig b/net/netfilter/Kconfig
index cb3ad741ebf8..634d14affc8d 100644
--- a/net/netfilter/Kconfig
+++ b/net/netfilter/Kconfig
@@ -327,7 +327,7 @@ config NETFILTER_XT_TARGET_CONNMARK
 
           If you want to compile it as a module, say M here and read
           <file:Documentation/kbuild/modules.txt>.  The module will be called
-          ipt_CONNMARK.ko.  If unsure, say `N'.
+          ipt_CONNMARK.  If unsure, say `N'.
 
 config NETFILTER_XT_TARGET_CONNSECMARK
         tristate '"CONNSECMARK" target support'
@@ -584,7 +584,7 @@ config NETFILTER_XT_MATCH_CONNMARK
 
           If you want to compile it as a module, say M here and read
           <file:Documentation/kbuild/modules.txt>.  The module will be called
-          ipt_connmark.ko.  If unsure, say `N'.
+          ipt_connmark.  If unsure, say `N'.
 
 config NETFILTER_XT_MATCH_CONNTRACK
         tristate '"conntrack" connection tracking match support'
@@ -917,6 +917,19 @@ config NETFILTER_XT_MATCH_U32
 
           Details and examples are in the kernel module source.
 
+config NETFILTER_XT_MATCH_OSF
+        tristate '"osf" Passive OS fingerprint match'
+        depends on NETFILTER_ADVANCED && NETFILTER_NETLINK
+        help
+          This option selects the Passive OS Fingerprinting match module
+          that allows to passively match the remote operating system by
+          analyzing incoming TCP SYN packets.
+
+          Rules and loading software can be downloaded from
+          http://www.ioremap.net/projects/osf
+
+          To compile it as a module, choose M here.  If unsure, say N.
+
 endif # NETFILTER_XTABLES
 
 endmenu
diff --git a/net/netfilter/Makefile b/net/netfilter/Makefile
index 6282060fbda9..49f62ee4e9ff 100644
--- a/net/netfilter/Makefile
+++ b/net/netfilter/Makefile
@@ -77,6 +77,7 @@ obj-$(CONFIG_NETFILTER_XT_MATCH_LIMIT) += xt_limit.o
 obj-$(CONFIG_NETFILTER_XT_MATCH_MAC) += xt_mac.o
 obj-$(CONFIG_NETFILTER_XT_MATCH_MARK) += xt_mark.o
 obj-$(CONFIG_NETFILTER_XT_MATCH_MULTIPORT) += xt_multiport.o
+obj-$(CONFIG_NETFILTER_XT_MATCH_OSF) += xt_osf.o
 obj-$(CONFIG_NETFILTER_XT_MATCH_OWNER) += xt_owner.o
 obj-$(CONFIG_NETFILTER_XT_MATCH_PHYSDEV) += xt_physdev.o
 obj-$(CONFIG_NETFILTER_XT_MATCH_PKTTYPE) += xt_pkttype.o
diff --git a/net/netfilter/ipvs/ip_vs_ctl.c b/net/netfilter/ipvs/ip_vs_ctl.c
index e01061f49cdc..7c1333c67ff3 100644
--- a/net/netfilter/ipvs/ip_vs_ctl.c
+++ b/net/netfilter/ipvs/ip_vs_ctl.c
@@ -3345,22 +3345,8 @@ static struct genl_ops ip_vs_genl_ops[] __read_mostly = {
 
 static int __init ip_vs_genl_register(void)
 {
-        int ret, i;
-
-        ret = genl_register_family(&ip_vs_genl_family);
-        if (ret)
-                return ret;
-
-        for (i = 0; i < ARRAY_SIZE(ip_vs_genl_ops); i++) {
-                ret = genl_register_ops(&ip_vs_genl_family, &ip_vs_genl_ops[i]);
-                if (ret)
-                        goto err_out;
-        }
-        return 0;
-
-err_out:
-        genl_unregister_family(&ip_vs_genl_family);
-        return ret;
+        return genl_register_family_with_ops(&ip_vs_genl_family,
+                ip_vs_genl_ops, ARRAY_SIZE(ip_vs_genl_ops));
 }
 
 static void ip_vs_genl_unregister(void)
diff --git a/net/netfilter/ipvs/ip_vs_xmit.c b/net/netfilter/ipvs/ip_vs_xmit.c
index 425ab144f15d..5874657af7f2 100644
--- a/net/netfilter/ipvs/ip_vs_xmit.c
+++ b/net/netfilter/ipvs/ip_vs_xmit.c
@@ -260,8 +260,8 @@ ip_vs_bypass_xmit(struct sk_buff *skb, struct ip_vs_conn *cp,
         ip_send_check(ip_hdr(skb));
 
         /* drop old route */
-        dst_release(skb->dst);
-        skb->dst = &rt->u.dst;
+        skb_dst_drop(skb);
+        skb_dst_set(skb, &rt->u.dst);
 
         /* Another hack: avoid icmp_send in ip_fragment */
         skb->local_df = 1;
@@ -324,8 +324,8 @@ ip_vs_bypass_xmit_v6(struct sk_buff *skb, struct ip_vs_conn *cp,
         }
 
         /* drop old route */
-        dst_release(skb->dst);
-        skb->dst = &rt->u.dst;
+        skb_dst_drop(skb);
+        skb_dst_set(skb, &rt->u.dst);
 
         /* Another hack: avoid icmp_send in ip_fragment */
         skb->local_df = 1;
@@ -388,8 +388,8 @@ ip_vs_nat_xmit(struct sk_buff *skb, struct ip_vs_conn *cp,
                 goto tx_error_put;
 
         /* drop old route */
-        dst_release(skb->dst);
-        skb->dst = &rt->u.dst;
+        skb_dst_drop(skb);
+        skb_dst_set(skb, &rt->u.dst);
 
         /* mangle the packet */
         if (pp->dnat_handler && !pp->dnat_handler(skb, pp, cp))
@@ -465,8 +465,8 @@ ip_vs_nat_xmit_v6(struct sk_buff *skb, struct ip_vs_conn *cp,
                 goto tx_error_put;
 
         /* drop old route */
-        dst_release(skb->dst);
-        skb->dst = &rt->u.dst;
+        skb_dst_drop(skb);
+        skb_dst_set(skb, &rt->u.dst);
 
         /* mangle the packet */
         if (pp->dnat_handler && !pp->dnat_handler(skb, pp, cp))
@@ -553,8 +553,8 @@ ip_vs_tunnel_xmit(struct sk_buff *skb, struct ip_vs_conn *cp,
                 IP_VS_DBG_RL("ip_vs_tunnel_xmit(): mtu less than 68\n");
                 goto tx_error;
         }
-        if (skb->dst)
-                skb->dst->ops->update_pmtu(skb->dst, mtu);
+        if (skb_dst(skb))
+                skb_dst(skb)->ops->update_pmtu(skb_dst(skb), mtu);
 
         df |= (old_iph->frag_off & htons(IP_DF));
 
@@ -596,8 +596,8 @@ ip_vs_tunnel_xmit(struct sk_buff *skb, struct ip_vs_conn *cp,
         memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
 
         /* drop old route */
-        dst_release(skb->dst);
-        skb->dst = &rt->u.dst;
+        skb_dst_drop(skb);
+        skb_dst_set(skb, &rt->u.dst);
 
         /*
          *      Push down and install the IPIP header.
@@ -665,8 +665,8 @@ ip_vs_tunnel_xmit_v6(struct sk_buff *skb, struct ip_vs_conn *cp,
                 IP_VS_DBG_RL("ip_vs_tunnel_xmit_v6(): mtu less than 1280\n");
                 goto tx_error;
         }
-        if (skb->dst)
-                skb->dst->ops->update_pmtu(skb->dst, mtu);
+        if (skb_dst(skb))
+                skb_dst(skb)->ops->update_pmtu(skb_dst(skb), mtu);
 
         if (mtu < ntohs(old_iph->payload_len) + sizeof(struct ipv6hdr)) {
                 icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu, skb->dev);
@@ -702,8 +702,8 @@ ip_vs_tunnel_xmit_v6(struct sk_buff *skb, struct ip_vs_conn *cp,
         memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
 
         /* drop old route */
-        dst_release(skb->dst);
-        skb->dst = &rt->u.dst;
+        skb_dst_drop(skb);
+        skb_dst_set(skb, &rt->u.dst);
 
         /*
          *      Push down and install the IPIP header.
@@ -775,8 +775,8 @@ ip_vs_dr_xmit(struct sk_buff *skb, struct ip_vs_conn *cp,
         ip_send_check(ip_hdr(skb));
 
         /* drop old route */
-        dst_release(skb->dst);
-        skb->dst = &rt->u.dst;
+        skb_dst_drop(skb);
+        skb_dst_set(skb, &rt->u.dst);
 
         /* Another hack: avoid icmp_send in ip_fragment */
         skb->local_df = 1;
@@ -828,8 +828,8 @@ ip_vs_dr_xmit_v6(struct sk_buff *skb, struct ip_vs_conn *cp,
         }
 
         /* drop old route */
-        dst_release(skb->dst);
-        skb->dst = &rt->u.dst;
+        skb_dst_drop(skb);
+        skb_dst_set(skb, &rt->u.dst);
 
         /* Another hack: avoid icmp_send in ip_fragment */
         skb->local_df = 1;
@@ -900,8 +900,8 @@ ip_vs_icmp_xmit(struct sk_buff *skb, struct ip_vs_conn *cp,
                 goto tx_error_put;
 
         /* drop the old route when skb is not shared */
-        dst_release(skb->dst);
-        skb->dst = &rt->u.dst;
+        skb_dst_drop(skb);
+        skb_dst_set(skb, &rt->u.dst);
 
         ip_vs_nat_icmp(skb, pp, cp, 0);
 
@@ -975,8 +975,8 @@ ip_vs_icmp_xmit_v6(struct sk_buff *skb, struct ip_vs_conn *cp,
                 goto tx_error_put;
 
         /* drop the old route when skb is not shared */
-        dst_release(skb->dst);
-        skb->dst = &rt->u.dst;
+        skb_dst_drop(skb);
+        skb_dst_set(skb, &rt->u.dst);
 
         ip_vs_nat_icmp_v6(skb, pp, cp, 0);
 
diff --git a/net/netfilter/nf_conntrack_acct.c b/net/netfilter/nf_conntrack_acct.c
index 9fe8982bd7c9..4a1d94aac20b 100644
--- a/net/netfilter/nf_conntrack_acct.c
+++ b/net/netfilter/nf_conntrack_acct.c
@@ -116,7 +116,7 @@ int nf_conntrack_acct_init(struct net *net)
         if (net_eq(net, &init_net)) {
 #ifdef CONFIG_NF_CT_ACCT
         printk(KERN_WARNING "CONFIG_NF_CT_ACCT is deprecated and will be removed soon. Please use\n");
-                printk(KERN_WARNING "nf_conntrack.acct=1 kernel paramater, acct=1 nf_conntrack module option or\n");
+                printk(KERN_WARNING "nf_conntrack.acct=1 kernel parameter, acct=1 nf_conntrack module option or\n");
                 printk(KERN_WARNING "sysctl net.netfilter.nf_conntrack_acct=1 to enable it.\n");
 #endif
 
diff --git a/net/netfilter/nf_conntrack_core.c b/net/netfilter/nf_conntrack_core.c
index 8020db6274b8..5f72b94b4918 100644
--- a/net/netfilter/nf_conntrack_core.c
+++ b/net/netfilter/nf_conntrack_core.c
@@ -39,6 +39,7 @@
 #include <net/netfilter/nf_conntrack_core.h>
 #include <net/netfilter/nf_conntrack_extend.h>
 #include <net/netfilter/nf_conntrack_acct.h>
+#include <net/netfilter/nf_conntrack_ecache.h>
 #include <net/netfilter/nf_nat.h>
 #include <net/netfilter/nf_nat_core.h>
 
@@ -182,10 +183,6 @@ destroy_conntrack(struct nf_conntrack *nfct)
         NF_CT_ASSERT(atomic_read(&nfct->use) == 0);
         NF_CT_ASSERT(!timer_pending(&ct->timeout));
 
-        if (!test_bit(IPS_DYING_BIT, &ct->status))
-                nf_conntrack_event(IPCT_DESTROY, ct);
-        set_bit(IPS_DYING_BIT, &ct->status);
-
         /* To make sure we don't get any weird locking issues here:
          * destroy_conntrack() MUST NOT be called with a write lock
          * to nf_conntrack_lock!!! -HW */
@@ -219,27 +216,70 @@ destroy_conntrack(struct nf_conntrack *nfct)
         nf_conntrack_free(ct);
 }
 
-static void death_by_timeout(unsigned long ul_conntrack)
+void nf_ct_delete_from_lists(struct nf_conn *ct)
 {
-        struct nf_conn *ct = (void *)ul_conntrack;
         struct net *net = nf_ct_net(ct);
-        struct nf_conn_help *help = nfct_help(ct);
-        struct nf_conntrack_helper *helper;
-
-        if (help) {
-                rcu_read_lock();
-                helper = rcu_dereference(help->helper);
-                if (helper && helper->destroy)
-                        helper->destroy(ct);
-                rcu_read_unlock();
-        }
 
+        nf_ct_helper_destroy(ct);
         spin_lock_bh(&nf_conntrack_lock);
         /* Inside lock so preempt is disabled on module removal path.
          * Otherwise we can get spurious warnings. */
         NF_CT_STAT_INC(net, delete_list);
         clean_from_lists(ct);
         spin_unlock_bh(&nf_conntrack_lock);
+}
+EXPORT_SYMBOL_GPL(nf_ct_delete_from_lists);
+
+static void death_by_event(unsigned long ul_conntrack)
+{
+        struct nf_conn *ct = (void *)ul_conntrack;
+        struct net *net = nf_ct_net(ct);
+
+        if (nf_conntrack_event(IPCT_DESTROY, ct) < 0) {
+                /* bad luck, let's retry again */
+                ct->timeout.expires = jiffies +
+                        (random32() % net->ct.sysctl_events_retry_timeout);
+                add_timer(&ct->timeout);
+                return;
+        }
+        /* we've got the event delivered, now it's dying */
+        set_bit(IPS_DYING_BIT, &ct->status);
+        spin_lock(&nf_conntrack_lock);
+        hlist_nulls_del(&ct->tuplehash[IP_CT_DIR_ORIGINAL].hnnode);
+        spin_unlock(&nf_conntrack_lock);
+        nf_ct_put(ct);
+}
+
+void nf_ct_insert_dying_list(struct nf_conn *ct)
+{
+        struct net *net = nf_ct_net(ct);
+
+        /* add this conntrack to the dying list */
+        spin_lock_bh(&nf_conntrack_lock);
+        hlist_nulls_add_head(&ct->tuplehash[IP_CT_DIR_ORIGINAL].hnnode,
+                             &net->ct.dying);
+        spin_unlock_bh(&nf_conntrack_lock);
+        /* set a new timer to retry event delivery */
+        setup_timer(&ct->timeout, death_by_event, (unsigned long)ct);
+        ct->timeout.expires = jiffies +
+                (random32() % net->ct.sysctl_events_retry_timeout);
+        add_timer(&ct->timeout);
+}
+EXPORT_SYMBOL_GPL(nf_ct_insert_dying_list);
+
+static void death_by_timeout(unsigned long ul_conntrack)
+{
+        struct nf_conn *ct = (void *)ul_conntrack;
+
+        if (!test_bit(IPS_DYING_BIT, &ct->status) &&
+            unlikely(nf_conntrack_event(IPCT_DESTROY, ct) < 0)) {
+                /* destroy event was not delivered */
+                nf_ct_delete_from_lists(ct);
+                nf_ct_insert_dying_list(ct);
+                return;
+        }
+        set_bit(IPS_DYING_BIT, &ct->status);
+        nf_ct_delete_from_lists(ct);
         nf_ct_put(ct);
 }
 
@@ -398,11 +438,7 @@ __nf_conntrack_confirm(struct sk_buff *skb)
         help = nfct_help(ct);
         if (help && help->helper)
                 nf_conntrack_event_cache(IPCT_HELPER, ct);
-#ifdef CONFIG_NF_NAT_NEEDED
-        if (test_bit(IPS_SRC_NAT_DONE_BIT, &ct->status) ||
-            test_bit(IPS_DST_NAT_DONE_BIT, &ct->status))
-                nf_conntrack_event_cache(IPCT_NATINFO, ct);
-#endif
+
         nf_conntrack_event_cache(master_ct(ct) ?
                                  IPCT_RELATED : IPCT_NEW, ct);
         return NF_ACCEPT;
@@ -523,6 +559,7 @@ struct nf_conn *nf_conntrack_alloc(struct net *net,
                 return ERR_PTR(-ENOMEM);
         }
 
+        spin_lock_init(&ct->lock);
         atomic_set(&ct->ct_general.use, 1);
         ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple = *orig;
         ct->tuplehash[IP_CT_DIR_REPLY].tuple = *repl;
@@ -580,6 +617,7 @@ init_conntrack(struct net *net,
         }
 
         nf_ct_acct_ext_add(ct, GFP_ATOMIC);
+        nf_ct_ecache_ext_add(ct, GFP_ATOMIC);
 
         spin_lock_bh(&nf_conntrack_lock);
         exp = nf_ct_find_expectation(net, tuple);
@@ -807,13 +845,9 @@ void __nf_ct_refresh_acct(struct nf_conn *ct,
                           unsigned long extra_jiffies,
                           int do_acct)
 {
-        int event = 0;
-
         NF_CT_ASSERT(ct->timeout.data == (unsigned long)ct);
         NF_CT_ASSERT(skb);
 
-        spin_lock_bh(&nf_conntrack_lock);
-
         /* Only update if this is not a fixed timeout */
         if (test_bit(IPS_FIXED_TIMEOUT_BIT, &ct->status))
                 goto acct;
@@ -821,19 +855,14 @@ void __nf_ct_refresh_acct(struct nf_conn *ct,
         /* If not in hash table, timer will not be active yet */
         if (!nf_ct_is_confirmed(ct)) {
                 ct->timeout.expires = extra_jiffies;
-                event = IPCT_REFRESH;
         } else {
                 unsigned long newtime = jiffies + extra_jiffies;
 
                 /* Only update the timeout if the new timeout is at least
                    HZ jiffies from the old timeout. Need del_timer for race
                    avoidance (may already be dying). */
-                if (newtime - ct->timeout.expires >= HZ
-                    && del_timer(&ct->timeout)) {
-                        ct->timeout.expires = newtime;
-                        add_timer(&ct->timeout);
-                        event = IPCT_REFRESH;
-                }
+                if (newtime - ct->timeout.expires >= HZ)
+                        mod_timer_pending(&ct->timeout, newtime);
         }
 
 acct:
@@ -842,17 +871,13 @@ acct:
 
                 acct = nf_conn_acct_find(ct);
                 if (acct) {
+                        spin_lock_bh(&ct->lock);
                         acct[CTINFO2DIR(ctinfo)].packets++;
                         acct[CTINFO2DIR(ctinfo)].bytes +=
                                 skb->len - skb_network_offset(skb);
+                        spin_unlock_bh(&ct->lock);
                 }
         }
-
-        spin_unlock_bh(&nf_conntrack_lock);
-
-        /* must be unlocked when calling event cache */
-        if (event)
-                nf_conntrack_event_cache(event, ct);
 }
 EXPORT_SYMBOL_GPL(__nf_ct_refresh_acct);
 
@@ -864,14 +889,14 @@ bool __nf_ct_kill_acct(struct nf_conn *ct,
         if (do_acct) {
                 struct nf_conn_counter *acct;
 
-                spin_lock_bh(&nf_conntrack_lock);
                 acct = nf_conn_acct_find(ct);
                 if (acct) {
+                        spin_lock_bh(&ct->lock);
                         acct[CTINFO2DIR(ctinfo)].packets++;
                         acct[CTINFO2DIR(ctinfo)].bytes +=
                                 skb->len - skb_network_offset(skb);
+                        spin_unlock_bh(&ct->lock);
                 }
-                spin_unlock_bh(&nf_conntrack_lock);
         }
 
         if (del_timer(&ct->timeout)) {
@@ -1001,15 +1026,22 @@ struct __nf_ct_flush_report {
         int report;
 };
 
-static int kill_all(struct nf_conn *i, void *data)
+static int kill_report(struct nf_conn *i, void *data)
 {
         struct __nf_ct_flush_report *fr = (struct __nf_ct_flush_report *)data;
 
-        /* get_next_corpse sets the dying bit for us */
-        nf_conntrack_event_report(IPCT_DESTROY,
-                                  i,
-                                  fr->pid,
-                                  fr->report);
+        /* If we fail to deliver the event, death_by_timeout() will retry */
+        if (nf_conntrack_event_report(IPCT_DESTROY, i,
+                                      fr->pid, fr->report) < 0)
+                return 1;
+
+        /* Avoid the delivery of the destroy event in death_by_timeout(). */
+        set_bit(IPS_DYING_BIT, &i->status);
+        return 1;
+}
+
+static int kill_all(struct nf_conn *i, void *data)
+{
         return 1;
 }
 
@@ -1023,15 +1055,30 @@ void nf_ct_free_hashtable(void *hash, int vmalloced, unsigned int size)
 }
 EXPORT_SYMBOL_GPL(nf_ct_free_hashtable);
 
-void nf_conntrack_flush(struct net *net, u32 pid, int report)
+void nf_conntrack_flush_report(struct net *net, u32 pid, int report)
 {
         struct __nf_ct_flush_report fr = {
                 .pid    = pid,
                 .report = report,
         };
-        nf_ct_iterate_cleanup(net, kill_all, &fr);
+        nf_ct_iterate_cleanup(net, kill_report, &fr);
+}
+EXPORT_SYMBOL_GPL(nf_conntrack_flush_report);
+
+static void nf_ct_release_dying_list(void)
+{
+        struct nf_conntrack_tuple_hash *h;
+        struct nf_conn *ct;
+        struct hlist_nulls_node *n;
+
+        spin_lock_bh(&nf_conntrack_lock);
+        hlist_nulls_for_each_entry(h, n, &init_net.ct.dying, hnnode) {
+                ct = nf_ct_tuplehash_to_ctrack(h);
+                /* never fails to remove them, no listeners at this point */
+                nf_ct_kill(ct);
+        }
+        spin_unlock_bh(&nf_conntrack_lock);
 }
-EXPORT_SYMBOL_GPL(nf_conntrack_flush);
 
 static void nf_conntrack_cleanup_init_net(void)
 {
@@ -1042,10 +1089,9 @@ static void nf_conntrack_cleanup_init_net(void)
 
 static void nf_conntrack_cleanup_net(struct net *net)
 {
-        nf_ct_event_cache_flush(net);
-        nf_conntrack_ecache_fini(net);
  i_see_dead_people:
-        nf_conntrack_flush(net, 0, 0);
+        nf_ct_iterate_cleanup(net, kill_all, NULL);
+        nf_ct_release_dying_list();
         if (atomic_read(&net->ct.count) != 0) {
                 schedule();
                 goto i_see_dead_people;
@@ -1056,6 +1102,7 @@ static void nf_conntrack_cleanup_net(struct net *net)
 
         nf_ct_free_hashtable(net->ct.hash, net->ct.hash_vmalloc,
                              nf_conntrack_htable_size);
+        nf_conntrack_ecache_fini(net);
         nf_conntrack_acct_fini(net);
         nf_conntrack_expect_fini(net);
         free_percpu(net->ct.stat);
@@ -1226,14 +1273,12 @@ static int nf_conntrack_init_net(struct net *net)
 
         atomic_set(&net->ct.count, 0);
         INIT_HLIST_NULLS_HEAD(&net->ct.unconfirmed, 0);
+        INIT_HLIST_NULLS_HEAD(&net->ct.dying, 0);
         net->ct.stat = alloc_percpu(struct ip_conntrack_stat);
         if (!net->ct.stat) {
                 ret = -ENOMEM;
                 goto err_stat;
         }
-        ret = nf_conntrack_ecache_init(net);
-        if (ret < 0)
-                goto err_ecache;
         net->ct.hash = nf_ct_alloc_hashtable(&nf_conntrack_htable_size,
                                              &net->ct.hash_vmalloc, 1);
         if (!net->ct.hash) {
@@ -1247,6 +1292,9 @@ static int nf_conntrack_init_net(struct net *net)
         ret = nf_conntrack_acct_init(net);
         if (ret < 0)
                 goto err_acct;
+        ret = nf_conntrack_ecache_init(net);
+        if (ret < 0)
+                goto err_ecache;
 
         /* Set up fake conntrack:
             - to never be deleted, not in any hashes */
@@ -1259,14 +1307,14 @@ static int nf_conntrack_init_net(struct net *net)
 
         return 0;
 
+err_ecache:
+        nf_conntrack_acct_fini(net);
 err_acct:
         nf_conntrack_expect_fini(net);
 err_expect:
         nf_ct_free_hashtable(net->ct.hash, net->ct.hash_vmalloc,
                              nf_conntrack_htable_size);
 err_hash:
-        nf_conntrack_ecache_fini(net);
-err_ecache:
         free_percpu(net->ct.stat);
 err_stat:
         return ret;
diff --git a/net/netfilter/nf_conntrack_ecache.c b/net/netfilter/nf_conntrack_ecache.c
index dee4190209cc..aee560b4768d 100644
--- a/net/netfilter/nf_conntrack_ecache.c
+++ b/net/netfilter/nf_conntrack_ecache.c
@@ -16,121 +16,245 @@
 #include <linux/stddef.h>
 #include <linux/err.h>
 #include <linux/percpu.h>
-#include <linux/notifier.h>
 #include <linux/kernel.h>
 #include <linux/netdevice.h>
 
 #include <net/netfilter/nf_conntrack.h>
 #include <net/netfilter/nf_conntrack_core.h>
+#include <net/netfilter/nf_conntrack_extend.h>
 
-ATOMIC_NOTIFIER_HEAD(nf_conntrack_chain);
-EXPORT_SYMBOL_GPL(nf_conntrack_chain);
+static DEFINE_MUTEX(nf_ct_ecache_mutex);
 
-ATOMIC_NOTIFIER_HEAD(nf_ct_expect_chain);
-EXPORT_SYMBOL_GPL(nf_ct_expect_chain);
+struct nf_ct_event_notifier *nf_conntrack_event_cb __read_mostly;
+EXPORT_SYMBOL_GPL(nf_conntrack_event_cb);
+
+struct nf_exp_event_notifier *nf_expect_event_cb __read_mostly;
+EXPORT_SYMBOL_GPL(nf_expect_event_cb);
 
 /* deliver cached events and clear cache entry - must be called with locally
  * disabled softirqs */
-static inline void
-__nf_ct_deliver_cached_events(struct nf_conntrack_ecache *ecache)
+void nf_ct_deliver_cached_events(struct nf_conn *ct)
 {
-        if (nf_ct_is_confirmed(ecache->ct) && !nf_ct_is_dying(ecache->ct)
-            && ecache->events) {
+        unsigned long events;
+        struct nf_ct_event_notifier *notify;
+        struct nf_conntrack_ecache *e;
+
+        rcu_read_lock();
+        notify = rcu_dereference(nf_conntrack_event_cb);
+        if (notify == NULL)
+                goto out_unlock;
+
+        e = nf_ct_ecache_find(ct);
+        if (e == NULL)
+                goto out_unlock;
+
+        events = xchg(&e->cache, 0);
+
+        if (nf_ct_is_confirmed(ct) && !nf_ct_is_dying(ct) && events) {
                 struct nf_ct_event item = {
-                        .ct     = ecache->ct,
+                        .ct     = ct,
                         .pid    = 0,
                         .report = 0
                 };
+                int ret;
+                /* We make a copy of the missed event cache without taking
+                 * the lock, thus we may send missed events twice. However,
+                 * this does not harm and it happens very rarely. */
+                unsigned long missed = e->missed;
 
-                atomic_notifier_call_chain(&nf_conntrack_chain,
-                                           ecache->events,
-                                           &item);
+                ret = notify->fcn(events | missed, &item);
+                if (unlikely(ret < 0 || missed)) {
+                        spin_lock_bh(&ct->lock);
+                        if (ret < 0)
+                                e->missed |= events;
+                        else
+                                e->missed &= ~missed;
+                        spin_unlock_bh(&ct->lock);
+                } 
         }
 
-        ecache->events = 0;
-        nf_ct_put(ecache->ct);
-        ecache->ct = NULL;
+out_unlock:
+        rcu_read_unlock();
 }
+EXPORT_SYMBOL_GPL(nf_ct_deliver_cached_events);
 
-/* Deliver all cached events for a particular conntrack. This is called
- * by code prior to async packet handling for freeing the skb */
-void nf_ct_deliver_cached_events(const struct nf_conn *ct)
+int nf_conntrack_register_notifier(struct nf_ct_event_notifier *new)
 {
-        struct net *net = nf_ct_net(ct);
-        struct nf_conntrack_ecache *ecache;
-
-        local_bh_disable();
-        ecache = per_cpu_ptr(net->ct.ecache, raw_smp_processor_id());
-        if (ecache->ct == ct)
-                __nf_ct_deliver_cached_events(ecache);
-        local_bh_enable();
+        int ret = 0;
+        struct nf_ct_event_notifier *notify;
+
+        mutex_lock(&nf_ct_ecache_mutex);
+        notify = rcu_dereference(nf_conntrack_event_cb);
+        if (notify != NULL) {
+                ret = -EBUSY;
+                goto out_unlock;
+        }
+        rcu_assign_pointer(nf_conntrack_event_cb, new);
+        mutex_unlock(&nf_ct_ecache_mutex);
+        return ret;
+
+out_unlock:
+        mutex_unlock(&nf_ct_ecache_mutex);
+        return ret;
 }
-EXPORT_SYMBOL_GPL(nf_ct_deliver_cached_events);
+EXPORT_SYMBOL_GPL(nf_conntrack_register_notifier);
 
-/* Deliver cached events for old pending events, if current conntrack != old */
-void __nf_ct_event_cache_init(struct nf_conn *ct)
+void nf_conntrack_unregister_notifier(struct nf_ct_event_notifier *new)
 {
-        struct net *net = nf_ct_net(ct);
-        struct nf_conntrack_ecache *ecache;
-
-        /* take care of delivering potentially old events */
-        ecache = per_cpu_ptr(net->ct.ecache, raw_smp_processor_id());
-        BUG_ON(ecache->ct == ct);
-        if (ecache->ct)
-                __nf_ct_deliver_cached_events(ecache);
-        /* initialize for this conntrack/packet */
-        ecache->ct = ct;
-        nf_conntrack_get(&ct->ct_general);
+        struct nf_ct_event_notifier *notify;
+
+        mutex_lock(&nf_ct_ecache_mutex);
+        notify = rcu_dereference(nf_conntrack_event_cb);
+        BUG_ON(notify != new);
+        rcu_assign_pointer(nf_conntrack_event_cb, NULL);
+        mutex_unlock(&nf_ct_ecache_mutex);
 }
-EXPORT_SYMBOL_GPL(__nf_ct_event_cache_init);
+EXPORT_SYMBOL_GPL(nf_conntrack_unregister_notifier);
 
-/* flush the event cache - touches other CPU's data and must not be called
- * while packets are still passing through the code */
-void nf_ct_event_cache_flush(struct net *net)
+int nf_ct_expect_register_notifier(struct nf_exp_event_notifier *new)
 {
-        struct nf_conntrack_ecache *ecache;
-        int cpu;
+        int ret = 0;
+        struct nf_exp_event_notifier *notify;
 
-        for_each_possible_cpu(cpu) {
-                ecache = per_cpu_ptr(net->ct.ecache, cpu);
-                if (ecache->ct)
-                        nf_ct_put(ecache->ct);
+        mutex_lock(&nf_ct_ecache_mutex);
+        notify = rcu_dereference(nf_expect_event_cb);
+        if (notify != NULL) {
+                ret = -EBUSY;
+                goto out_unlock;
         }
+        rcu_assign_pointer(nf_expect_event_cb, new);
+        mutex_unlock(&nf_ct_ecache_mutex);
+        return ret;
+
+out_unlock:
+        mutex_unlock(&nf_ct_ecache_mutex);
+        return ret;
 }
+EXPORT_SYMBOL_GPL(nf_ct_expect_register_notifier);
 
-int nf_conntrack_ecache_init(struct net *net)
+void nf_ct_expect_unregister_notifier(struct nf_exp_event_notifier *new)
 {
-        net->ct.ecache = alloc_percpu(struct nf_conntrack_ecache);
-        if (!net->ct.ecache)
-                return -ENOMEM;
-        return 0;
+        struct nf_exp_event_notifier *notify;
+
+        mutex_lock(&nf_ct_ecache_mutex);
+        notify = rcu_dereference(nf_expect_event_cb);
+        BUG_ON(notify != new);
+        rcu_assign_pointer(nf_expect_event_cb, NULL);
+        mutex_unlock(&nf_ct_ecache_mutex);
 }
+EXPORT_SYMBOL_GPL(nf_ct_expect_unregister_notifier);
 
-void nf_conntrack_ecache_fini(struct net *net)
+#define NF_CT_EVENTS_DEFAULT 1
+static int nf_ct_events __read_mostly = NF_CT_EVENTS_DEFAULT;
+static int nf_ct_events_retry_timeout __read_mostly = 15*HZ;
+
+#ifdef CONFIG_SYSCTL
+static struct ctl_table event_sysctl_table[] = {
+        {
+                .ctl_name       = CTL_UNNUMBERED,
+                .procname       = "nf_conntrack_events",
+                .data           = &init_net.ct.sysctl_events,
+                .maxlen         = sizeof(unsigned int),
+                .mode           = 0644,
+                .proc_handler   = proc_dointvec,
+        },
+        {
+                .ctl_name       = CTL_UNNUMBERED,
+                .procname       = "nf_conntrack_events_retry_timeout",
+                .data           = &init_net.ct.sysctl_events_retry_timeout,
+                .maxlen         = sizeof(unsigned int),
+                .mode           = 0644,
+                .proc_handler   = proc_dointvec_jiffies,
+        },
+        {}
+};
+#endif /* CONFIG_SYSCTL */
+
+static struct nf_ct_ext_type event_extend __read_mostly = {
+        .len    = sizeof(struct nf_conntrack_ecache),
+        .align  = __alignof__(struct nf_conntrack_ecache),
+        .id     = NF_CT_EXT_ECACHE,
+};
+
+#ifdef CONFIG_SYSCTL
+static int nf_conntrack_event_init_sysctl(struct net *net)
 {
-        free_percpu(net->ct.ecache);
+        struct ctl_table *table;
+
+        table = kmemdup(event_sysctl_table, sizeof(event_sysctl_table),
+                        GFP_KERNEL);
+        if (!table)
+                goto out;
+
+        table[0].data = &net->ct.sysctl_events;
+        table[1].data = &net->ct.sysctl_events_retry_timeout;
+
+        net->ct.event_sysctl_header =
+                register_net_sysctl_table(net,
+                                          nf_net_netfilter_sysctl_path, table);
+        if (!net->ct.event_sysctl_header) {
+                printk(KERN_ERR "nf_ct_event: can't register to sysctl.\n");
+                goto out_register;
+        }
+        return 0;
+
+out_register:
+        kfree(table);
+out:
+        return -ENOMEM;
 }
 
-int nf_conntrack_register_notifier(struct notifier_block *nb)
+static void nf_conntrack_event_fini_sysctl(struct net *net)
 {
-        return atomic_notifier_chain_register(&nf_conntrack_chain, nb);
+        struct ctl_table *table;
+
+        table = net->ct.event_sysctl_header->ctl_table_arg;
+        unregister_net_sysctl_table(net->ct.event_sysctl_header);
+        kfree(table);
+}
+#else
+static int nf_conntrack_event_init_sysctl(struct net *net)
+{
+        return 0;
 }
-EXPORT_SYMBOL_GPL(nf_conntrack_register_notifier);
 
-int nf_conntrack_unregister_notifier(struct notifier_block *nb)
+static void nf_conntrack_event_fini_sysctl(struct net *net)
 {
-        return atomic_notifier_chain_unregister(&nf_conntrack_chain, nb);
 }
-EXPORT_SYMBOL_GPL(nf_conntrack_unregister_notifier);
+#endif /* CONFIG_SYSCTL */
 
-int nf_ct_expect_register_notifier(struct notifier_block *nb)
+int nf_conntrack_ecache_init(struct net *net)
 {
-        return atomic_notifier_chain_register(&nf_ct_expect_chain, nb);
+        int ret;
+
+        net->ct.sysctl_events = nf_ct_events;
+        net->ct.sysctl_events_retry_timeout = nf_ct_events_retry_timeout;
+
+        if (net_eq(net, &init_net)) {
+                ret = nf_ct_extend_register(&event_extend);
+                if (ret < 0) {
+                        printk(KERN_ERR "nf_ct_event: Unable to register "
+                                        "event extension.\n");
+                        goto out_extend_register;
+                }
+        }
+
+        ret = nf_conntrack_event_init_sysctl(net);
+        if (ret < 0)
+                goto out_sysctl;
+
+        return 0;
+
+out_sysctl:
+        if (net_eq(net, &init_net))
+                nf_ct_extend_unregister(&event_extend);
+out_extend_register:
+        return ret;
 }
-EXPORT_SYMBOL_GPL(nf_ct_expect_register_notifier);
 
-int nf_ct_expect_unregister_notifier(struct notifier_block *nb)
+void nf_conntrack_ecache_fini(struct net *net)
 {
-        return atomic_notifier_chain_unregister(&nf_ct_expect_chain, nb);
+        nf_conntrack_event_fini_sysctl(net);
+        if (net_eq(net, &init_net))
+                nf_ct_extend_unregister(&event_extend);
 }
-EXPORT_SYMBOL_GPL(nf_ct_expect_unregister_notifier);
diff --git a/net/netfilter/nf_conntrack_ftp.c b/net/netfilter/nf_conntrack_ftp.c
index 00fecc385f9b..5509dd1f14cf 100644
--- a/net/netfilter/nf_conntrack_ftp.c
+++ b/net/netfilter/nf_conntrack_ftp.c
@@ -338,11 +338,9 @@ static void update_nl_seq(struct nf_conn *ct, u32 nl_seq,
 
         if (info->seq_aft_nl_num[dir] < NUM_SEQ_TO_REMEMBER) {
                 info->seq_aft_nl[dir][info->seq_aft_nl_num[dir]++] = nl_seq;
-                nf_conntrack_event_cache(IPCT_HELPINFO_VOLATILE, ct);
         } else if (oldest != NUM_SEQ_TO_REMEMBER &&
                    after(nl_seq, info->seq_aft_nl[dir][oldest])) {
                 info->seq_aft_nl[dir][oldest] = nl_seq;
-                nf_conntrack_event_cache(IPCT_HELPINFO_VOLATILE, ct);
         }
 }
 
diff --git a/net/netfilter/nf_conntrack_helper.c b/net/netfilter/nf_conntrack_helper.c
index 0fa5a422959f..65c2a7bc3afc 100644
--- a/net/netfilter/nf_conntrack_helper.c
+++ b/net/netfilter/nf_conntrack_helper.c
@@ -136,6 +136,20 @@ static inline int unhelp(struct nf_conntrack_tuple_hash *i,
         return 0;
 }
 
+void nf_ct_helper_destroy(struct nf_conn *ct)
+{
+        struct nf_conn_help *help = nfct_help(ct);
+        struct nf_conntrack_helper *helper;
+
+        if (help) {
+                rcu_read_lock();
+                helper = rcu_dereference(help->helper);
+                if (helper && helper->destroy)
+                        helper->destroy(ct);
+                rcu_read_unlock();
+        }
+}
+
 int nf_conntrack_helper_register(struct nf_conntrack_helper *me)
 {
         unsigned int h = helper_hash(&me->tuple);
diff --git a/net/netfilter/nf_conntrack_netbios_ns.c b/net/netfilter/nf_conntrack_netbios_ns.c
index 8a3875e36ec2..497b2224536f 100644
--- a/net/netfilter/nf_conntrack_netbios_ns.c
+++ b/net/netfilter/nf_conntrack_netbios_ns.c
@@ -48,7 +48,7 @@ static int help(struct sk_buff *skb, unsigned int protoff,
 {
         struct nf_conntrack_expect *exp;
         struct iphdr *iph = ip_hdr(skb);
-        struct rtable *rt = skb->rtable;
+        struct rtable *rt = skb_rtable(skb);
         struct in_device *in_dev;
         __be32 mask = 0;
 
diff --git a/net/netfilter/nf_conntrack_netlink.c b/net/netfilter/nf_conntrack_netlink.c
index c523f0b8cee5..49479d194570 100644
--- a/net/netfilter/nf_conntrack_netlink.c
+++ b/net/netfilter/nf_conntrack_netlink.c
@@ -27,7 +27,6 @@
 #include <linux/netlink.h>
 #include <linux/spinlock.h>
 #include <linux/interrupt.h>
-#include <linux/notifier.h>
 
 #include <linux/netfilter.h>
 #include <net/netlink.h>
@@ -144,7 +143,7 @@ nla_put_failure:
 }
 
 static inline int
-ctnetlink_dump_protoinfo(struct sk_buff *skb, const struct nf_conn *ct)
+ctnetlink_dump_protoinfo(struct sk_buff *skb, struct nf_conn *ct)
 {
         struct nf_conntrack_l4proto *l4proto;
         struct nlattr *nest_proto;
@@ -346,23 +345,21 @@ nla_put_failure:
         return -1;
 }
 
-#define tuple(ct, dir) (&(ct)->tuplehash[dir].tuple)
-
 static int
 ctnetlink_fill_info(struct sk_buff *skb, u32 pid, u32 seq,
-                    int event, int nowait,
-                    const struct nf_conn *ct)
+                    int event, struct nf_conn *ct)
 {
         struct nlmsghdr *nlh;
         struct nfgenmsg *nfmsg;
         struct nlattr *nest_parms;
-        unsigned char *b = skb_tail_pointer(skb);
+        unsigned int flags = pid ? NLM_F_MULTI : 0;
 
         event |= NFNL_SUBSYS_CTNETLINK << 8;
-        nlh    = NLMSG_PUT(skb, pid, seq, event, sizeof(struct nfgenmsg));
-        nfmsg  = NLMSG_DATA(nlh);
+        nlh = nlmsg_put(skb, pid, seq, event, sizeof(*nfmsg), flags);
+        if (nlh == NULL)
+                goto nlmsg_failure;
 
-        nlh->nlmsg_flags    = (nowait && pid) ? NLM_F_MULTI : 0;
+        nfmsg = nlmsg_data(nlh);
         nfmsg->nfgen_family = nf_ct_l3num(ct);
         nfmsg->version      = NFNETLINK_V0;
         nfmsg->res_id       = 0;
@@ -370,14 +367,14 @@ ctnetlink_fill_info(struct sk_buff *skb, u32 pid, u32 seq,
         nest_parms = nla_nest_start(skb, CTA_TUPLE_ORIG | NLA_F_NESTED);
         if (!nest_parms)
                 goto nla_put_failure;
-        if (ctnetlink_dump_tuples(skb, tuple(ct, IP_CT_DIR_ORIGINAL)) < 0)
+        if (ctnetlink_dump_tuples(skb, nf_ct_tuple(ct, IP_CT_DIR_ORIGINAL)) < 0)
                 goto nla_put_failure;
         nla_nest_end(skb, nest_parms);
 
         nest_parms = nla_nest_start(skb, CTA_TUPLE_REPLY | NLA_F_NESTED);
         if (!nest_parms)
                 goto nla_put_failure;
-        if (ctnetlink_dump_tuples(skb, tuple(ct, IP_CT_DIR_REPLY)) < 0)
+        if (ctnetlink_dump_tuples(skb, nf_ct_tuple(ct, IP_CT_DIR_REPLY)) < 0)
                 goto nla_put_failure;
         nla_nest_end(skb, nest_parms);
 
@@ -395,132 +392,109 @@ ctnetlink_fill_info(struct sk_buff *skb, u32 pid, u32 seq,
             ctnetlink_dump_nat_seq_adj(skb, ct) < 0)
                 goto nla_put_failure;
 
-        nlh->nlmsg_len = skb_tail_pointer(skb) - b;
+        nlmsg_end(skb, nlh);
         return skb->len;
 
 nlmsg_failure:
 nla_put_failure:
-        nlmsg_trim(skb, b);
+        nlmsg_cancel(skb, nlh);
         return -1;
 }
 
 #ifdef CONFIG_NF_CONNTRACK_EVENTS
-/*
- * The general structure of a ctnetlink event is
- *
- *  CTA_TUPLE_ORIG
- *    <l3/l4-proto-attributes>
- *  CTA_TUPLE_REPLY
- *    <l3/l4-proto-attributes>
- *  CTA_ID
- *  ...
- *  CTA_PROTOINFO
- *    <l4-proto-attributes>
- *  CTA_TUPLE_MASTER
- *    <l3/l4-proto-attributes>
- *
- * Therefore the formular is
- *
- *   size = sizeof(headers) + sizeof(generic_nlas) + 3 * sizeof(tuple_nlas)
- *              + sizeof(protoinfo_nlas)
- */
-static struct sk_buff *
-ctnetlink_alloc_skb(const struct nf_conntrack_tuple *tuple, gfp_t gfp)
+static inline size_t
+ctnetlink_proto_size(const struct nf_conn *ct)
 {
         struct nf_conntrack_l3proto *l3proto;
         struct nf_conntrack_l4proto *l4proto;
-        int len;
-
-#define NLA_TYPE_SIZE(type)             nla_total_size(sizeof(type))
-
-        /* proto independant part */
-        len = NLMSG_SPACE(sizeof(struct nfgenmsg))
-                + 3 * nla_total_size(0)         /* CTA_TUPLE_ORIG|REPL|MASTER */
-                + 3 * nla_total_size(0)         /* CTA_TUPLE_IP */
-                + 3 * nla_total_size(0)         /* CTA_TUPLE_PROTO */
-                + 3 * NLA_TYPE_SIZE(u_int8_t)   /* CTA_PROTO_NUM */
-                + NLA_TYPE_SIZE(u_int32_t)      /* CTA_ID */
-                + NLA_TYPE_SIZE(u_int32_t)      /* CTA_STATUS */
+        size_t len = 0;
+
+        rcu_read_lock();
+        l3proto = __nf_ct_l3proto_find(nf_ct_l3num(ct));
+        len += l3proto->nla_size;
+
+        l4proto = __nf_ct_l4proto_find(nf_ct_l3num(ct), nf_ct_protonum(ct));
+        len += l4proto->nla_size;
+        rcu_read_unlock();
+
+        return len;
+}
+
+static inline size_t
+ctnetlink_nlmsg_size(const struct nf_conn *ct)
+{
+        return NLMSG_ALIGN(sizeof(struct nfgenmsg))
+               + 3 * nla_total_size(0) /* CTA_TUPLE_ORIG|REPL|MASTER */
+               + 3 * nla_total_size(0) /* CTA_TUPLE_IP */
+               + 3 * nla_total_size(0) /* CTA_TUPLE_PROTO */
+               + 3 * nla_total_size(sizeof(u_int8_t)) /* CTA_PROTO_NUM */
+               + nla_total_size(sizeof(u_int32_t)) /* CTA_ID */
+               + nla_total_size(sizeof(u_int32_t)) /* CTA_STATUS */
 #ifdef CONFIG_NF_CT_ACCT
-                + 2 * nla_total_size(0)         /* CTA_COUNTERS_ORIG|REPL */
-                + 2 * NLA_TYPE_SIZE(uint64_t)   /* CTA_COUNTERS_PACKETS */
-                + 2 * NLA_TYPE_SIZE(uint64_t)   /* CTA_COUNTERS_BYTES */
+               + 2 * nla_total_size(0) /* CTA_COUNTERS_ORIG|REPL */
+               + 2 * nla_total_size(sizeof(uint64_t)) /* CTA_COUNTERS_PACKETS */
+               + 2 * nla_total_size(sizeof(uint64_t)) /* CTA_COUNTERS_BYTES */
 #endif
-                + NLA_TYPE_SIZE(u_int32_t)      /* CTA_TIMEOUT */
-                + nla_total_size(0)             /* CTA_PROTOINFO */
-                + nla_total_size(0)             /* CTA_HELP */
-                + nla_total_size(NF_CT_HELPER_NAME_LEN) /* CTA_HELP_NAME */
+               + nla_total_size(sizeof(u_int32_t)) /* CTA_TIMEOUT */
+               + nla_total_size(0) /* CTA_PROTOINFO */
+               + nla_total_size(0) /* CTA_HELP */
+               + nla_total_size(NF_CT_HELPER_NAME_LEN) /* CTA_HELP_NAME */
 #ifdef CONFIG_NF_CONNTRACK_SECMARK
-                + NLA_TYPE_SIZE(u_int32_t)      /* CTA_SECMARK */
+               + nla_total_size(sizeof(u_int32_t)) /* CTA_SECMARK */
 #endif
 #ifdef CONFIG_NF_NAT_NEEDED
-                + 2 * nla_total_size(0)         /* CTA_NAT_SEQ_ADJ_ORIG|REPL */
-                + 2 * NLA_TYPE_SIZE(u_int32_t)  /* CTA_NAT_SEQ_CORRECTION_POS */
-                + 2 * NLA_TYPE_SIZE(u_int32_t)  /* CTA_NAT_SEQ_CORRECTION_BEFORE */
-                + 2 * NLA_TYPE_SIZE(u_int32_t)  /* CTA_NAT_SEQ_CORRECTION_AFTER */
+               + 2 * nla_total_size(0) /* CTA_NAT_SEQ_ADJ_ORIG|REPL */
+               + 6 * nla_total_size(sizeof(u_int32_t)) /* CTA_NAT_SEQ_OFFSET */
 #endif
 #ifdef CONFIG_NF_CONNTRACK_MARK
-                + NLA_TYPE_SIZE(u_int32_t)      /* CTA_MARK */
+               + nla_total_size(sizeof(u_int32_t)) /* CTA_MARK */
 #endif
-                ;
-
-#undef NLA_TYPE_SIZE
-
-        rcu_read_lock();
-        l3proto = __nf_ct_l3proto_find(tuple->src.l3num);
-        len += l3proto->nla_size;
-
-        l4proto = __nf_ct_l4proto_find(tuple->src.l3num, tuple->dst.protonum);
-        len += l4proto->nla_size;
-        rcu_read_unlock();
-
-        return alloc_skb(len, gfp);
+               + ctnetlink_proto_size(ct)
+               ;
 }
 
-static int ctnetlink_conntrack_event(struct notifier_block *this,
-                                     unsigned long events, void *ptr)
+static int
+ctnetlink_conntrack_event(unsigned int events, struct nf_ct_event *item)
 {
         struct nlmsghdr *nlh;
         struct nfgenmsg *nfmsg;
         struct nlattr *nest_parms;
-        struct nf_ct_event *item = (struct nf_ct_event *)ptr;
         struct nf_conn *ct = item->ct;
         struct sk_buff *skb;
         unsigned int type;
-        sk_buff_data_t b;
         unsigned int flags = 0, group;
+        int err;
 
         /* ignore our fake conntrack entry */
         if (ct == &nf_conntrack_untracked)
-                return NOTIFY_DONE;
+                return 0;
 
-        if (events & IPCT_DESTROY) {
+        if (events & (1 << IPCT_DESTROY)) {
                 type = IPCTNL_MSG_CT_DELETE;
                 group = NFNLGRP_CONNTRACK_DESTROY;
-        } else  if (events & (IPCT_NEW | IPCT_RELATED)) {
+        } else  if (events & ((1 << IPCT_NEW) | (1 << IPCT_RELATED))) {
                 type = IPCTNL_MSG_CT_NEW;
                 flags = NLM_F_CREATE|NLM_F_EXCL;
                 group = NFNLGRP_CONNTRACK_NEW;
-        } else  if (events & (IPCT_STATUS | IPCT_PROTOINFO)) {
+        } else  if (events) {
                 type = IPCTNL_MSG_CT_NEW;
                 group = NFNLGRP_CONNTRACK_UPDATE;
         } else
-                return NOTIFY_DONE;
+                return 0;
 
         if (!item->report && !nfnetlink_has_listeners(group))
-                return NOTIFY_DONE;
+                return 0;
 
-        skb = ctnetlink_alloc_skb(tuple(ct, IP_CT_DIR_ORIGINAL), GFP_ATOMIC);
-        if (!skb)
+        skb = nlmsg_new(ctnetlink_nlmsg_size(ct), GFP_ATOMIC);
+        if (skb == NULL)
                 goto errout;
 
-        b = skb->tail;
-
         type |= NFNL_SUBSYS_CTNETLINK << 8;
-        nlh   = NLMSG_PUT(skb, item->pid, 0, type, sizeof(struct nfgenmsg));
-        nfmsg = NLMSG_DATA(nlh);
+        nlh = nlmsg_put(skb, item->pid, 0, type, sizeof(*nfmsg), flags);
+        if (nlh == NULL)
+                goto nlmsg_failure;
 
-        nlh->nlmsg_flags    = flags;
+        nfmsg = nlmsg_data(nlh);
         nfmsg->nfgen_family = nf_ct_l3num(ct);
         nfmsg->version  = NFNETLINK_V0;
         nfmsg->res_id   = 0;
@@ -529,14 +503,14 @@ static int ctnetlink_conntrack_event(struct notifier_block *this,
         nest_parms = nla_nest_start(skb, CTA_TUPLE_ORIG | NLA_F_NESTED);
         if (!nest_parms)
                 goto nla_put_failure;
-        if (ctnetlink_dump_tuples(skb, tuple(ct, IP_CT_DIR_ORIGINAL)) < 0)
+        if (ctnetlink_dump_tuples(skb, nf_ct_tuple(ct, IP_CT_DIR_ORIGINAL)) < 0)
                 goto nla_put_failure;
         nla_nest_end(skb, nest_parms);
 
         nest_parms = nla_nest_start(skb, CTA_TUPLE_REPLY | NLA_F_NESTED);
         if (!nest_parms)
                 goto nla_put_failure;
-        if (ctnetlink_dump_tuples(skb, tuple(ct, IP_CT_DIR_REPLY)) < 0)
+        if (ctnetlink_dump_tuples(skb, nf_ct_tuple(ct, IP_CT_DIR_REPLY)) < 0)
                 goto nla_put_failure;
         nla_nest_end(skb, nest_parms);
 
@@ -546,7 +520,7 @@ static int ctnetlink_conntrack_event(struct notifier_block *this,
         if (ctnetlink_dump_status(skb, ct) < 0)
                 goto nla_put_failure;
 
-        if (events & IPCT_DESTROY) {
+        if (events & (1 << IPCT_DESTROY)) {
                 if (ctnetlink_dump_counters(skb, ct, IP_CT_DIR_ORIGINAL) < 0 ||
                     ctnetlink_dump_counters(skb, ct, IP_CT_DIR_REPLY) < 0)
                         goto nla_put_failure;
@@ -554,47 +528,51 @@ static int ctnetlink_conntrack_event(struct notifier_block *this,
                 if (ctnetlink_dump_timeout(skb, ct) < 0)
                         goto nla_put_failure;
 
-                if (events & IPCT_PROTOINFO
+                if (events & (1 << IPCT_PROTOINFO)
                     && ctnetlink_dump_protoinfo(skb, ct) < 0)
                         goto nla_put_failure;
 
-                if ((events & IPCT_HELPER || nfct_help(ct))
+                if ((events & (1 << IPCT_HELPER) || nfct_help(ct))
                     && ctnetlink_dump_helpinfo(skb, ct) < 0)
                         goto nla_put_failure;
 
 #ifdef CONFIG_NF_CONNTRACK_SECMARK
-                if ((events & IPCT_SECMARK || ct->secmark)
+                if ((events & (1 << IPCT_SECMARK) || ct->secmark)
                     && ctnetlink_dump_secmark(skb, ct) < 0)
                         goto nla_put_failure;
 #endif
 
-                if (events & IPCT_RELATED &&
+                if (events & (1 << IPCT_RELATED) &&
                     ctnetlink_dump_master(skb, ct) < 0)
                         goto nla_put_failure;
 
-                if (events & IPCT_NATSEQADJ &&
+                if (events & (1 << IPCT_NATSEQADJ) &&
                     ctnetlink_dump_nat_seq_adj(skb, ct) < 0)
                         goto nla_put_failure;
         }
 
 #ifdef CONFIG_NF_CONNTRACK_MARK
-        if ((events & IPCT_MARK || ct->mark)
+        if ((events & (1 << IPCT_MARK) || ct->mark)
             && ctnetlink_dump_mark(skb, ct) < 0)
                 goto nla_put_failure;
 #endif
         rcu_read_unlock();
 
-        nlh->nlmsg_len = skb->tail - b;
-        nfnetlink_send(skb, item->pid, group, item->report);
-        return NOTIFY_DONE;
+        nlmsg_end(skb, nlh);
+        err = nfnetlink_send(skb, item->pid, group, item->report, GFP_ATOMIC);
+        if (err == -ENOBUFS || err == -EAGAIN)
+                return -ENOBUFS;
+
+        return 0;
 
 nla_put_failure:
         rcu_read_unlock();
+        nlmsg_cancel(skb, nlh);
 nlmsg_failure:
         kfree_skb(skb);
 errout:
         nfnetlink_set_err(0, group, -ENOBUFS);
-        return NOTIFY_DONE;
+        return 0;
 }
 #endif /* CONFIG_NF_CONNTRACK_EVENTS */
 
@@ -611,7 +589,7 @@ ctnetlink_dump_table(struct sk_buff *skb, struct netlink_callback *cb)
         struct nf_conn *ct, *last;
         struct nf_conntrack_tuple_hash *h;
         struct hlist_nulls_node *n;
-        struct nfgenmsg *nfmsg = NLMSG_DATA(cb->nlh);
+        struct nfgenmsg *nfmsg = nlmsg_data(cb->nlh);
         u_int8_t l3proto = nfmsg->nfgen_family;
 
         rcu_read_lock();
@@ -637,8 +615,7 @@ restart:
                         }
                         if (ctnetlink_fill_info(skb, NETLINK_CB(cb->skb).pid,
                                                 cb->nlh->nlmsg_seq,
-                                                IPCTNL_MSG_CT_NEW,
-                                                1, ct) < 0) {
+                                                IPCTNL_MSG_CT_NEW, ct) < 0) {
                                 cb->args[1] = (unsigned long)ct;
                                 goto out;
                         }
@@ -792,7 +769,7 @@ ctnetlink_del_conntrack(struct sock *ctnl, struct sk_buff *skb,
         struct nf_conntrack_tuple_hash *h;
         struct nf_conntrack_tuple tuple;
         struct nf_conn *ct;
-        struct nfgenmsg *nfmsg = NLMSG_DATA(nlh);
+        struct nfgenmsg *nfmsg = nlmsg_data(nlh);
         u_int8_t u3 = nfmsg->nfgen_family;
         int err = 0;
 
@@ -802,9 +779,9 @@ ctnetlink_del_conntrack(struct sock *ctnl, struct sk_buff *skb,
                 err = ctnetlink_parse_tuple(cda, &tuple, CTA_TUPLE_REPLY, u3);
         else {
                 /* Flush the whole table */
-                nf_conntrack_flush(&init_net, 
-                                   NETLINK_CB(skb).pid, 
-                                   nlmsg_report(nlh));
+                nf_conntrack_flush_report(&init_net,
+                                         NETLINK_CB(skb).pid,
+                                         nlmsg_report(nlh));
                 return 0;
         }
 
@@ -825,10 +802,15 @@ ctnetlink_del_conntrack(struct sock *ctnl, struct sk_buff *skb,
                 }
         }
 
-        nf_conntrack_event_report(IPCT_DESTROY,
-                                  ct,
-                                  NETLINK_CB(skb).pid,
-                                  nlmsg_report(nlh));
+        if (nf_conntrack_event_report(IPCT_DESTROY, ct,
+                                      NETLINK_CB(skb).pid,
+                                      nlmsg_report(nlh)) < 0) {
+                nf_ct_delete_from_lists(ct);
+                /* we failed to report the event, try later */
+                nf_ct_insert_dying_list(ct);
+                nf_ct_put(ct);
+                return 0;
+        }
 
         /* death_by_timeout would report the event again */
         set_bit(IPS_DYING_BIT, &ct->status);
@@ -847,7 +829,7 @@ ctnetlink_get_conntrack(struct sock *ctnl, struct sk_buff *skb,
         struct nf_conntrack_tuple tuple;
         struct nf_conn *ct;
         struct sk_buff *skb2 = NULL;
-        struct nfgenmsg *nfmsg = NLMSG_DATA(nlh);
+        struct nfgenmsg *nfmsg = nlmsg_data(nlh);
         u_int8_t u3 = nfmsg->nfgen_family;
         int err = 0;
 
@@ -872,15 +854,15 @@ ctnetlink_get_conntrack(struct sock *ctnl, struct sk_buff *skb,
         ct = nf_ct_tuplehash_to_ctrack(h);
 
         err = -ENOMEM;
-        skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
-        if (!skb2) {
+        skb2 = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
+        if (skb2 == NULL) {
                 nf_ct_put(ct);
                 return -ENOMEM;
         }
 
         rcu_read_lock();
         err = ctnetlink_fill_info(skb2, NETLINK_CB(skb).pid, nlh->nlmsg_seq,
-                                  IPCTNL_MSG_CT_NEW, 1, ct);
+                                  IPCTNL_MSG_CT_NEW, ct);
         rcu_read_unlock();
         nf_ct_put(ct);
         if (err <= 0)
@@ -1280,6 +1262,7 @@ ctnetlink_create_conntrack(struct nlattr *cda[],
         }
 
         nf_ct_acct_ext_add(ct, GFP_ATOMIC);
+        nf_ct_ecache_ext_add(ct, GFP_ATOMIC);
 
 #if defined(CONFIG_NF_CONNTRACK_MARK)
         if (cda[CTA_MARK])
@@ -1325,7 +1308,7 @@ ctnetlink_new_conntrack(struct sock *ctnl, struct sk_buff *skb,
 {
         struct nf_conntrack_tuple otuple, rtuple;
         struct nf_conntrack_tuple_hash *h = NULL;
-        struct nfgenmsg *nfmsg = NLMSG_DATA(nlh);
+        struct nfgenmsg *nfmsg = nlmsg_data(nlh);
         u_int8_t u3 = nfmsg->nfgen_family;
         int err = 0;
 
@@ -1367,13 +1350,13 @@ ctnetlink_new_conntrack(struct sock *ctnl, struct sk_buff *skb,
                         else
                                 events = IPCT_NEW;
 
-                        nf_conntrack_event_report(IPCT_STATUS |
-                                                  IPCT_HELPER |
-                                                  IPCT_PROTOINFO |
-                                                  IPCT_NATSEQADJ |
-                                                  IPCT_MARK | events,
-                                                  ct, NETLINK_CB(skb).pid,
-                                                  nlmsg_report(nlh));
+                        nf_conntrack_eventmask_report((1 << IPCT_STATUS) |
+                                                      (1 << IPCT_HELPER) |
+                                                      (1 << IPCT_PROTOINFO) |
+                                                      (1 << IPCT_NATSEQADJ) |
+                                                      (1 << IPCT_MARK) | events,
+                                                      ct, NETLINK_CB(skb).pid,
+                                                      nlmsg_report(nlh));
                         nf_ct_put(ct);
                 } else
                         spin_unlock_bh(&nf_conntrack_lock);
@@ -1392,13 +1375,13 @@ ctnetlink_new_conntrack(struct sock *ctnl, struct sk_buff *skb,
                 if (err == 0) {
                         nf_conntrack_get(&ct->ct_general);
                         spin_unlock_bh(&nf_conntrack_lock);
-                        nf_conntrack_event_report(IPCT_STATUS |
-                                                  IPCT_HELPER |
-                                                  IPCT_PROTOINFO |
-                                                  IPCT_NATSEQADJ |
-                                                  IPCT_MARK,
-                                                  ct, NETLINK_CB(skb).pid,
-                                                  nlmsg_report(nlh));
+                        nf_conntrack_eventmask_report((1 << IPCT_STATUS) |
+                                                      (1 << IPCT_HELPER) |
+                                                      (1 << IPCT_PROTOINFO) |
+                                                      (1 << IPCT_NATSEQADJ) |
+                                                      (1 << IPCT_MARK),
+                                                      ct, NETLINK_CB(skb).pid,
+                                                      nlmsg_report(nlh));
                         nf_ct_put(ct);
                 } else
                         spin_unlock_bh(&nf_conntrack_lock);
@@ -1503,19 +1486,18 @@ nla_put_failure:
 
 static int
 ctnetlink_exp_fill_info(struct sk_buff *skb, u32 pid, u32 seq,
-                    int event,
-                    int nowait,
-                    const struct nf_conntrack_expect *exp)
+                        int event, const struct nf_conntrack_expect *exp)
 {
         struct nlmsghdr *nlh;
         struct nfgenmsg *nfmsg;
-        unsigned char *b = skb_tail_pointer(skb);
+        unsigned int flags = pid ? NLM_F_MULTI : 0;
 
         event |= NFNL_SUBSYS_CTNETLINK_EXP << 8;
-        nlh    = NLMSG_PUT(skb, pid, seq, event, sizeof(struct nfgenmsg));
-        nfmsg  = NLMSG_DATA(nlh);
+        nlh = nlmsg_put(skb, pid, seq, event, sizeof(*nfmsg), flags);
+        if (nlh == NULL)
+                goto nlmsg_failure;
 
-        nlh->nlmsg_flags    = (nowait && pid) ? NLM_F_MULTI : 0;
+        nfmsg = nlmsg_data(nlh);
         nfmsg->nfgen_family = exp->tuple.src.l3num;
         nfmsg->version      = NFNETLINK_V0;
         nfmsg->res_id       = 0;
@@ -1523,49 +1505,46 @@ ctnetlink_exp_fill_info(struct sk_buff *skb, u32 pid, u32 seq,
         if (ctnetlink_exp_dump_expect(skb, exp) < 0)
                 goto nla_put_failure;
 
-        nlh->nlmsg_len = skb_tail_pointer(skb) - b;
+        nlmsg_end(skb, nlh);
         return skb->len;
 
 nlmsg_failure:
 nla_put_failure:
-        nlmsg_trim(skb, b);
+        nlmsg_cancel(skb, nlh);
         return -1;
 }
 
 #ifdef CONFIG_NF_CONNTRACK_EVENTS
-static int ctnetlink_expect_event(struct notifier_block *this,
-                                  unsigned long events, void *ptr)
+static int
+ctnetlink_expect_event(unsigned int events, struct nf_exp_event *item)
 {
         struct nlmsghdr *nlh;
         struct nfgenmsg *nfmsg;
-        struct nf_exp_event *item = (struct nf_exp_event *)ptr;
         struct nf_conntrack_expect *exp = item->exp;
         struct sk_buff *skb;
         unsigned int type;
-        sk_buff_data_t b;
         int flags = 0;
 
-        if (events & IPEXP_NEW) {
+        if (events & (1 << IPEXP_NEW)) {
                 type = IPCTNL_MSG_EXP_NEW;
                 flags = NLM_F_CREATE|NLM_F_EXCL;
         } else
-                return NOTIFY_DONE;
+                return 0;
 
         if (!item->report &&
             !nfnetlink_has_listeners(NFNLGRP_CONNTRACK_EXP_NEW))
-                return NOTIFY_DONE;
+                return 0;
 
-        skb = alloc_skb(NLMSG_GOODSIZE, GFP_ATOMIC);
-        if (!skb)
+        skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
+        if (skb == NULL)
                 goto errout;
 
-        b = skb->tail;
-
         type |= NFNL_SUBSYS_CTNETLINK_EXP << 8;
-        nlh   = NLMSG_PUT(skb, item->pid, 0, type, sizeof(struct nfgenmsg));
-        nfmsg = NLMSG_DATA(nlh);
+        nlh = nlmsg_put(skb, item->pid, 0, type, sizeof(*nfmsg), flags);
+        if (nlh == NULL)
+                goto nlmsg_failure;
 
-        nlh->nlmsg_flags    = flags;
+        nfmsg = nlmsg_data(nlh);
         nfmsg->nfgen_family = exp->tuple.src.l3num;
         nfmsg->version      = NFNETLINK_V0;
         nfmsg->res_id       = 0;
@@ -1575,17 +1554,19 @@ static int ctnetlink_expect_event(struct notifier_block *this,
                 goto nla_put_failure;
         rcu_read_unlock();
 
-        nlh->nlmsg_len = skb->tail - b;
-        nfnetlink_send(skb, item->pid, NFNLGRP_CONNTRACK_EXP_NEW, item->report);
-        return NOTIFY_DONE;
+        nlmsg_end(skb, nlh);
+        nfnetlink_send(skb, item->pid, NFNLGRP_CONNTRACK_EXP_NEW,
+                       item->report, GFP_ATOMIC);
+        return 0;
 
 nla_put_failure:
         rcu_read_unlock();
+        nlmsg_cancel(skb, nlh);
 nlmsg_failure:
         kfree_skb(skb);
 errout:
         nfnetlink_set_err(0, 0, -ENOBUFS);
-        return NOTIFY_DONE;
+        return 0;
 }
 #endif
 static int ctnetlink_exp_done(struct netlink_callback *cb)
@@ -1600,7 +1581,7 @@ ctnetlink_exp_dump_table(struct sk_buff *skb, struct netlink_callback *cb)
 {
         struct net *net = &init_net;
         struct nf_conntrack_expect *exp, *last;
-        struct nfgenmsg *nfmsg = NLMSG_DATA(cb->nlh);
+        struct nfgenmsg *nfmsg = nlmsg_data(cb->nlh);
         struct hlist_node *n;
         u_int8_t l3proto = nfmsg->nfgen_family;
 
@@ -1617,10 +1598,11 @@ restart:
                                         continue;
                                 cb->args[1] = 0;
                         }
-                        if (ctnetlink_exp_fill_info(skb, NETLINK_CB(cb->skb).pid,
+                        if (ctnetlink_exp_fill_info(skb,
+                                                    NETLINK_CB(cb->skb).pid,
                                                     cb->nlh->nlmsg_seq,
                                                     IPCTNL_MSG_EXP_NEW,
-                                                    1, exp) < 0) {
+                                                    exp) < 0) {
                                 if (!atomic_inc_not_zero(&exp->use))
                                         continue;
                                 cb->args[1] = (unsigned long)exp;
@@ -1652,7 +1634,7 @@ ctnetlink_get_expect(struct sock *ctnl, struct sk_buff *skb,
         struct nf_conntrack_tuple tuple;
         struct nf_conntrack_expect *exp;
         struct sk_buff *skb2;
-        struct nfgenmsg *nfmsg = NLMSG_DATA(nlh);
+        struct nfgenmsg *nfmsg = nlmsg_data(nlh);
         u_int8_t u3 = nfmsg->nfgen_family;
         int err = 0;
 
@@ -1683,14 +1665,13 @@ ctnetlink_get_expect(struct sock *ctnl, struct sk_buff *skb,
         }
 
         err = -ENOMEM;
-        skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
-        if (!skb2)
+        skb2 = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
+        if (skb2 == NULL)
                 goto out;
 
         rcu_read_lock();
         err = ctnetlink_exp_fill_info(skb2, NETLINK_CB(skb).pid,
-                                      nlh->nlmsg_seq, IPCTNL_MSG_EXP_NEW,
-                                      1, exp);
+                                      nlh->nlmsg_seq, IPCTNL_MSG_EXP_NEW, exp);
         rcu_read_unlock();
         if (err <= 0)
                 goto free;
@@ -1713,7 +1694,7 @@ ctnetlink_del_expect(struct sock *ctnl, struct sk_buff *skb,
         struct nf_conntrack_expect *exp;
         struct nf_conntrack_tuple tuple;
         struct nf_conntrack_helper *h;
-        struct nfgenmsg *nfmsg = NLMSG_DATA(nlh);
+        struct nfgenmsg *nfmsg = nlmsg_data(nlh);
         struct hlist_node *n, *next;
         u_int8_t u3 = nfmsg->nfgen_family;
         unsigned int i;
@@ -1854,7 +1835,7 @@ ctnetlink_new_expect(struct sock *ctnl, struct sk_buff *skb,
 {
         struct nf_conntrack_tuple tuple;
         struct nf_conntrack_expect *exp;
-        struct nfgenmsg *nfmsg = NLMSG_DATA(nlh);
+        struct nfgenmsg *nfmsg = nlmsg_data(nlh);
         u_int8_t u3 = nfmsg->nfgen_family;
         int err = 0;
 
@@ -1891,12 +1872,12 @@ ctnetlink_new_expect(struct sock *ctnl, struct sk_buff *skb,
 }
 
 #ifdef CONFIG_NF_CONNTRACK_EVENTS
-static struct notifier_block ctnl_notifier = {
-        .notifier_call  = ctnetlink_conntrack_event,
+static struct nf_ct_event_notifier ctnl_notifier = {
+        .fcn = ctnetlink_conntrack_event,
 };
 
-static struct notifier_block ctnl_notifier_exp = {
-        .notifier_call  = ctnetlink_expect_event,
+static struct nf_exp_event_notifier ctnl_notifier_exp = {
+        .fcn = ctnetlink_expect_event,
 };
 #endif
 
diff --git a/net/netfilter/nf_conntrack_proto_dccp.c b/net/netfilter/nf_conntrack_proto_dccp.c
index aee0d6bea309..1b816a2ea813 100644
--- a/net/netfilter/nf_conntrack_proto_dccp.c
+++ b/net/netfilter/nf_conntrack_proto_dccp.c
@@ -25,8 +25,6 @@
 #include <net/netfilter/nf_conntrack_ecache.h>
 #include <net/netfilter/nf_log.h>
 
-static DEFINE_RWLOCK(dccp_lock);
-
 /* Timeouts are based on values from RFC4340:
  *
  * - REQUEST:
@@ -492,7 +490,7 @@ static int dccp_packet(struct nf_conn *ct, const struct sk_buff *skb,
                 return NF_ACCEPT;
         }
 
-        write_lock_bh(&dccp_lock);
+        spin_lock_bh(&ct->lock);
 
         role = ct->proto.dccp.role[dir];
         old_state = ct->proto.dccp.state;
@@ -536,13 +534,13 @@ static int dccp_packet(struct nf_conn *ct, const struct sk_buff *skb,
                 ct->proto.dccp.last_dir = dir;
                 ct->proto.dccp.last_pkt = type;
 
-                write_unlock_bh(&dccp_lock);
+                spin_unlock_bh(&ct->lock);
                 if (LOG_INVALID(net, IPPROTO_DCCP))
                         nf_log_packet(pf, 0, skb, NULL, NULL, NULL,
                                       "nf_ct_dccp: invalid packet ignored ");
                 return NF_ACCEPT;
         case CT_DCCP_INVALID:
-                write_unlock_bh(&dccp_lock);
+                spin_unlock_bh(&ct->lock);
                 if (LOG_INVALID(net, IPPROTO_DCCP))
                         nf_log_packet(pf, 0, skb, NULL, NULL, NULL,
                                       "nf_ct_dccp: invalid state transition ");
@@ -552,7 +550,7 @@ static int dccp_packet(struct nf_conn *ct, const struct sk_buff *skb,
         ct->proto.dccp.last_dir = dir;
         ct->proto.dccp.last_pkt = type;
         ct->proto.dccp.state = new_state;
-        write_unlock_bh(&dccp_lock);
+        spin_unlock_bh(&ct->lock);
 
         if (new_state != old_state)
                 nf_conntrack_event_cache(IPCT_PROTOINFO, ct);
@@ -621,36 +619,39 @@ static int dccp_print_tuple(struct seq_file *s,
                           ntohs(tuple->dst.u.dccp.port));
 }
 
-static int dccp_print_conntrack(struct seq_file *s, const struct nf_conn *ct)
+static int dccp_print_conntrack(struct seq_file *s, struct nf_conn *ct)
 {
         return seq_printf(s, "%s ", dccp_state_names[ct->proto.dccp.state]);
 }
 
 #if defined(CONFIG_NF_CT_NETLINK) || defined(CONFIG_NF_CT_NETLINK_MODULE)
 static int dccp_to_nlattr(struct sk_buff *skb, struct nlattr *nla,
-                          const struct nf_conn *ct)
+                          struct nf_conn *ct)
 {
         struct nlattr *nest_parms;
 
-        read_lock_bh(&dccp_lock);
+        spin_lock_bh(&ct->lock);
         nest_parms = nla_nest_start(skb, CTA_PROTOINFO_DCCP | NLA_F_NESTED);
         if (!nest_parms)
                 goto nla_put_failure;
         NLA_PUT_U8(skb, CTA_PROTOINFO_DCCP_STATE, ct->proto.dccp.state);
         NLA_PUT_U8(skb, CTA_PROTOINFO_DCCP_ROLE,
                    ct->proto.dccp.role[IP_CT_DIR_ORIGINAL]);
+        NLA_PUT_BE64(skb, CTA_PROTOINFO_DCCP_HANDSHAKE_SEQ,
+                     cpu_to_be64(ct->proto.dccp.handshake_seq));
         nla_nest_end(skb, nest_parms);
-        read_unlock_bh(&dccp_lock);
+        spin_unlock_bh(&ct->lock);
         return 0;
 
 nla_put_failure:
-        read_unlock_bh(&dccp_lock);
+        spin_unlock_bh(&ct->lock);
         return -1;
 }
 
 static const struct nla_policy dccp_nla_policy[CTA_PROTOINFO_DCCP_MAX + 1] = {
         [CTA_PROTOINFO_DCCP_STATE]      = { .type = NLA_U8 },
         [CTA_PROTOINFO_DCCP_ROLE]       = { .type = NLA_U8 },
+        [CTA_PROTOINFO_DCCP_HANDSHAKE_SEQ] = { .type = NLA_U64 },
 };
 
 static int nlattr_to_dccp(struct nlattr *cda[], struct nf_conn *ct)
@@ -674,7 +675,7 @@ static int nlattr_to_dccp(struct nlattr *cda[], struct nf_conn *ct)
                 return -EINVAL;
         }
 
-        write_lock_bh(&dccp_lock);
+        spin_lock_bh(&ct->lock);
         ct->proto.dccp.state = nla_get_u8(tb[CTA_PROTOINFO_DCCP_STATE]);
         if (nla_get_u8(tb[CTA_PROTOINFO_DCCP_ROLE]) == CT_DCCP_ROLE_CLIENT) {
                 ct->proto.dccp.role[IP_CT_DIR_ORIGINAL] = CT_DCCP_ROLE_CLIENT;
@@ -683,7 +684,11 @@ static int nlattr_to_dccp(struct nlattr *cda[], struct nf_conn *ct)
                 ct->proto.dccp.role[IP_CT_DIR_ORIGINAL] = CT_DCCP_ROLE_SERVER;
                 ct->proto.dccp.role[IP_CT_DIR_REPLY] = CT_DCCP_ROLE_CLIENT;
         }
-        write_unlock_bh(&dccp_lock);
+        if (tb[CTA_PROTOINFO_DCCP_HANDSHAKE_SEQ]) {
+                ct->proto.dccp.handshake_seq =
+                be64_to_cpu(nla_get_be64(tb[CTA_PROTOINFO_DCCP_HANDSHAKE_SEQ]));
+        }
+        spin_unlock_bh(&ct->lock);
         return 0;
 }
 
diff --git a/net/netfilter/nf_conntrack_proto_gre.c b/net/netfilter/nf_conntrack_proto_gre.c
index 117b80112fcb..a54a0af0edba 100644
--- a/net/netfilter/nf_conntrack_proto_gre.c
+++ b/net/netfilter/nf_conntrack_proto_gre.c
@@ -176,7 +176,7 @@ static bool gre_invert_tuple(struct nf_conntrack_tuple *tuple,
 static bool gre_pkt_to_tuple(const struct sk_buff *skb, unsigned int dataoff,
                              struct nf_conntrack_tuple *tuple)
 {
-        struct net *net = dev_net(skb->dev ? skb->dev : skb->dst->dev);
+        struct net *net = dev_net(skb->dev ? skb->dev : skb_dst(skb)->dev);
         const struct gre_hdr_pptp *pgrehdr;
         struct gre_hdr_pptp _pgrehdr;
         __be16 srckey;
@@ -219,8 +219,7 @@ static int gre_print_tuple(struct seq_file *s,
 }
 
 /* print private data for conntrack */
-static int gre_print_conntrack(struct seq_file *s,
-                               const struct nf_conn *ct)
+static int gre_print_conntrack(struct seq_file *s, struct nf_conn *ct)
 {
         return seq_printf(s, "timeout=%u, stream_timeout=%u ",
                           (ct->proto.gre.timeout / HZ),
diff --git a/net/netfilter/nf_conntrack_proto_sctp.c b/net/netfilter/nf_conntrack_proto_sctp.c
index 101b4ad9e817..c10e6f36e31e 100644
--- a/net/netfilter/nf_conntrack_proto_sctp.c
+++ b/net/netfilter/nf_conntrack_proto_sctp.c
@@ -25,9 +25,6 @@
 #include <net/netfilter/nf_conntrack_l4proto.h>
 #include <net/netfilter/nf_conntrack_ecache.h>
 
-/* Protects ct->proto.sctp */
-static DEFINE_RWLOCK(sctp_lock);
-
 /* FIXME: Examine ipfilter's timeouts and conntrack transitions more
    closely.  They're more complex. --RR
 
@@ -164,13 +161,13 @@ static int sctp_print_tuple(struct seq_file *s,
 }
 
 /* Print out the private part of the conntrack. */
-static int sctp_print_conntrack(struct seq_file *s, const struct nf_conn *ct)
+static int sctp_print_conntrack(struct seq_file *s, struct nf_conn *ct)
 {
         enum sctp_conntrack state;
 
-        read_lock_bh(&sctp_lock);
+        spin_lock_bh(&ct->lock);
         state = ct->proto.sctp.state;
-        read_unlock_bh(&sctp_lock);
+        spin_unlock_bh(&ct->lock);
 
         return seq_printf(s, "%s ", sctp_conntrack_names[state]);
 }
@@ -318,7 +315,7 @@ static int sctp_packet(struct nf_conn *ct,
         }
 
         old_state = new_state = SCTP_CONNTRACK_NONE;
-        write_lock_bh(&sctp_lock);
+        spin_lock_bh(&ct->lock);
         for_each_sctp_chunk (skb, sch, _sch, offset, dataoff, count) {
                 /* Special cases of Verification tag check (Sec 8.5.1) */
                 if (sch->type == SCTP_CID_INIT) {
@@ -371,7 +368,7 @@ static int sctp_packet(struct nf_conn *ct,
                 if (old_state != new_state)
                         nf_conntrack_event_cache(IPCT_PROTOINFO, ct);
         }
-        write_unlock_bh(&sctp_lock);
+        spin_unlock_bh(&ct->lock);
 
         nf_ct_refresh_acct(ct, ctinfo, skb, sctp_timeouts[new_state]);
 
@@ -386,7 +383,7 @@ static int sctp_packet(struct nf_conn *ct,
         return NF_ACCEPT;
 
 out_unlock:
-        write_unlock_bh(&sctp_lock);
+        spin_unlock_bh(&ct->lock);
 out:
         return -NF_ACCEPT;
 }
@@ -469,11 +466,11 @@ static bool sctp_new(struct nf_conn *ct, const struct sk_buff *skb,
 #include <linux/netfilter/nfnetlink_conntrack.h>
 
 static int sctp_to_nlattr(struct sk_buff *skb, struct nlattr *nla,
-                          const struct nf_conn *ct)
+                          struct nf_conn *ct)
 {
         struct nlattr *nest_parms;
 
-        read_lock_bh(&sctp_lock);
+        spin_lock_bh(&ct->lock);
         nest_parms = nla_nest_start(skb, CTA_PROTOINFO_SCTP | NLA_F_NESTED);
         if (!nest_parms)
                 goto nla_put_failure;
@@ -488,14 +485,14 @@ static int sctp_to_nlattr(struct sk_buff *skb, struct nlattr *nla,
                      CTA_PROTOINFO_SCTP_VTAG_REPLY,
                      ct->proto.sctp.vtag[IP_CT_DIR_REPLY]);
 
-        read_unlock_bh(&sctp_lock);
+        spin_unlock_bh(&ct->lock);
 
         nla_nest_end(skb, nest_parms);
 
         return 0;
 
 nla_put_failure:
-        read_unlock_bh(&sctp_lock);
+        spin_unlock_bh(&ct->lock);
         return -1;
 }
 
@@ -527,13 +524,13 @@ static int nlattr_to_sctp(struct nlattr *cda[], struct nf_conn *ct)
             !tb[CTA_PROTOINFO_SCTP_VTAG_REPLY])
                 return -EINVAL;
 
-        write_lock_bh(&sctp_lock);
+        spin_lock_bh(&ct->lock);
         ct->proto.sctp.state = nla_get_u8(tb[CTA_PROTOINFO_SCTP_STATE]);
         ct->proto.sctp.vtag[IP_CT_DIR_ORIGINAL] =
                 nla_get_be32(tb[CTA_PROTOINFO_SCTP_VTAG_ORIGINAL]);
         ct->proto.sctp.vtag[IP_CT_DIR_REPLY] =
                 nla_get_be32(tb[CTA_PROTOINFO_SCTP_VTAG_REPLY]);
-        write_unlock_bh(&sctp_lock);
+        spin_unlock_bh(&ct->lock);
 
         return 0;
 }
diff --git a/net/netfilter/nf_conntrack_proto_tcp.c b/net/netfilter/nf_conntrack_proto_tcp.c
index 97a6e93d742e..33fc0a443f3d 100644
--- a/net/netfilter/nf_conntrack_proto_tcp.c
+++ b/net/netfilter/nf_conntrack_proto_tcp.c
@@ -29,9 +29,6 @@
 #include <net/netfilter/ipv4/nf_conntrack_ipv4.h>
 #include <net/netfilter/ipv6/nf_conntrack_ipv6.h>
 
-/* Protects ct->proto.tcp */
-static DEFINE_RWLOCK(tcp_lock);
-
 /* "Be conservative in what you do,
     be liberal in what you accept from others."
     If it's non-zero, we mark only out of window RST segments as INVALID. */
@@ -59,7 +56,7 @@ static const char *const tcp_conntrack_names[] = {
         "LAST_ACK",
         "TIME_WAIT",
         "CLOSE",
-        "LISTEN"
+        "SYN_SENT2",
 };
 
 #define SECS * HZ
@@ -82,6 +79,7 @@ static unsigned int tcp_timeouts[TCP_CONNTRACK_MAX] __read_mostly = {
         [TCP_CONNTRACK_LAST_ACK]        = 30 SECS,
         [TCP_CONNTRACK_TIME_WAIT]       = 2 MINS,
         [TCP_CONNTRACK_CLOSE]           = 10 SECS,
+        [TCP_CONNTRACK_SYN_SENT2]       = 2 MINS,
 };
 
 #define sNO TCP_CONNTRACK_NONE
@@ -93,7 +91,7 @@ static unsigned int tcp_timeouts[TCP_CONNTRACK_MAX] __read_mostly = {
 #define sLA TCP_CONNTRACK_LAST_ACK
 #define sTW TCP_CONNTRACK_TIME_WAIT
 #define sCL TCP_CONNTRACK_CLOSE
-#define sLI TCP_CONNTRACK_LISTEN
+#define sS2 TCP_CONNTRACK_SYN_SENT2
 #define sIV TCP_CONNTRACK_MAX
 #define sIG TCP_CONNTRACK_IGNORE
 
@@ -123,6 +121,7 @@ enum tcp_bit_set {
  *
  * NONE:        initial state
  * SYN_SENT:    SYN-only packet seen
+ * SYN_SENT2:   SYN-only packet seen from reply dir, simultaneous open
  * SYN_RECV:    SYN-ACK packet seen
  * ESTABLISHED: ACK packet seen
  * FIN_WAIT:    FIN packet seen
@@ -131,26 +130,24 @@ enum tcp_bit_set {
  * TIME_WAIT:   last ACK seen
  * CLOSE:       closed connection (RST)
  *
- * LISTEN state is not used.
- *
  * Packets marked as IGNORED (sIG):
  *      if they may be either invalid or valid
  *      and the receiver may send back a connection
  *      closing RST or a SYN/ACK.
  *
  * Packets marked as INVALID (sIV):
- *      if they are invalid
- *      or we do not support the request (simultaneous open)
+ *      if we regard them as truly invalid packets
  */
 static const u8 tcp_conntracks[2][6][TCP_CONNTRACK_MAX] = {
         {
 /* ORIGINAL */
-/*           sNO, sSS, sSR, sES, sFW, sCW, sLA, sTW, sCL, sLI   */
-/*syn*/    { sSS, sSS, sIG, sIG, sIG, sIG, sIG, sSS, sSS, sIV },
+/*           sNO, sSS, sSR, sES, sFW, sCW, sLA, sTW, sCL, sS2   */
+/*syn*/    { sSS, sSS, sIG, sIG, sIG, sIG, sIG, sSS, sSS, sS2 },
 /*
  *      sNO -> sSS      Initialize a new connection
  *      sSS -> sSS      Retransmitted SYN
- *      sSR -> sIG      Late retransmitted SYN?
+ *      sS2 -> sS2      Late retransmitted SYN
+ *      sSR -> sIG
  *      sES -> sIG      Error: SYNs in window outside the SYN_SENT state
  *                      are errors. Receiver will reply with RST
  *                      and close the connection.
@@ -161,22 +158,30 @@ static const u8 tcp_conntracks[2][6][TCP_CONNTRACK_MAX] = {
  *      sTW -> sSS      Reopened connection (RFC 1122).
  *      sCL -> sSS
  */
-/*           sNO, sSS, sSR, sES, sFW, sCW, sLA, sTW, sCL, sLI   */
-/*synack*/ { sIV, sIV, sIV, sIV, sIV, sIV, sIV, sIV, sIV, sIV },
+/*           sNO, sSS, sSR, sES, sFW, sCW, sLA, sTW, sCL, sS2   */
+/*synack*/ { sIV, sIV, sIG, sIG, sIG, sIG, sIG, sIG, sIG, sSR },
 /*
- * A SYN/ACK from the client is always invalid:
- *      - either it tries to set up a simultaneous open, which is
- *        not supported;
- *      - or the firewall has just been inserted between the two hosts
- *        during the session set-up. The SYN will be retransmitted
- *        by the true client (or it'll time out).
+ *      sNO -> sIV      Too late and no reason to do anything
+ *      sSS -> sIV      Client can't send SYN and then SYN/ACK
+ *      sS2 -> sSR      SYN/ACK sent to SYN2 in simultaneous open
+ *      sSR -> sIG
+ *      sES -> sIG      Error: SYNs in window outside the SYN_SENT state
+ *                      are errors. Receiver will reply with RST
+ *                      and close the connection.
+ *                      Or we are not in sync and hold a dead connection.
+ *      sFW -> sIG
+ *      sCW -> sIG
+ *      sLA -> sIG
+ *      sTW -> sIG
+ *      sCL -> sIG
  */
-/*           sNO, sSS, sSR, sES, sFW, sCW, sLA, sTW, sCL, sLI   */
+/*           sNO, sSS, sSR, sES, sFW, sCW, sLA, sTW, sCL, sS2   */
 /*fin*/    { sIV, sIV, sFW, sFW, sLA, sLA, sLA, sTW, sCL, sIV },
 /*
  *      sNO -> sIV      Too late and no reason to do anything...
  *      sSS -> sIV      Client migth not send FIN in this state:
  *                      we enforce waiting for a SYN/ACK reply first.
+ *      sS2 -> sIV
  *      sSR -> sFW      Close started.
  *      sES -> sFW
  *      sFW -> sLA      FIN seen in both directions, waiting for
@@ -187,11 +192,12 @@ static const u8 tcp_conntracks[2][6][TCP_CONNTRACK_MAX] = {
  *      sTW -> sTW
  *      sCL -> sCL
  */
-/*           sNO, sSS, sSR, sES, sFW, sCW, sLA, sTW, sCL, sLI   */
+/*           sNO, sSS, sSR, sES, sFW, sCW, sLA, sTW, sCL, sS2   */
 /*ack*/    { sES, sIV, sES, sES, sCW, sCW, sTW, sTW, sCL, sIV },
 /*
  *      sNO -> sES      Assumed.
  *      sSS -> sIV      ACK is invalid: we haven't seen a SYN/ACK yet.
+ *      sS2 -> sIV
  *      sSR -> sES      Established state is reached.
  *      sES -> sES      :-)
  *      sFW -> sCW      Normal close request answered by ACK.
@@ -200,29 +206,31 @@ static const u8 tcp_conntracks[2][6][TCP_CONNTRACK_MAX] = {
  *      sTW -> sTW      Retransmitted last ACK. Remain in the same state.
  *      sCL -> sCL
  */
-/*           sNO, sSS, sSR, sES, sFW, sCW, sLA, sTW, sCL, sLI   */
-/*rst*/    { sIV, sCL, sCL, sCL, sCL, sCL, sCL, sCL, sCL, sIV },
+/*           sNO, sSS, sSR, sES, sFW, sCW, sLA, sTW, sCL, sS2   */
+/*rst*/    { sIV, sCL, sCL, sCL, sCL, sCL, sCL, sCL, sCL, sCL },
 /*none*/   { sIV, sIV, sIV, sIV, sIV, sIV, sIV, sIV, sIV, sIV }
         },
         {
 /* REPLY */
-/*           sNO, sSS, sSR, sES, sFW, sCW, sLA, sTW, sCL, sLI   */
-/*syn*/    { sIV, sIV, sIV, sIV, sIV, sIV, sIV, sIV, sIV, sIV },
+/*           sNO, sSS, sSR, sES, sFW, sCW, sLA, sTW, sCL, sS2   */
+/*syn*/    { sIV, sS2, sIV, sIV, sIV, sIV, sIV, sIV, sIV, sS2 },
 /*
  *      sNO -> sIV      Never reached.
- *      sSS -> sIV      Simultaneous open, not supported
- *      sSR -> sIV      Simultaneous open, not supported.
- *      sES -> sIV      Server may not initiate a connection.
+ *      sSS -> sS2      Simultaneous open
+ *      sS2 -> sS2      Retransmitted simultaneous SYN
+ *      sSR -> sIV      Invalid SYN packets sent by the server
+ *      sES -> sIV
  *      sFW -> sIV
  *      sCW -> sIV
  *      sLA -> sIV
  *      sTW -> sIV      Reopened connection, but server may not do it.
  *      sCL -> sIV
  */
-/*           sNO, sSS, sSR, sES, sFW, sCW, sLA, sTW, sCL, sLI   */
-/*synack*/ { sIV, sSR, sSR, sIG, sIG, sIG, sIG, sIG, sIG, sIV },
+/*           sNO, sSS, sSR, sES, sFW, sCW, sLA, sTW, sCL, sS2   */
+/*synack*/ { sIV, sSR, sSR, sIG, sIG, sIG, sIG, sIG, sIG, sSR },
 /*
  *      sSS -> sSR      Standard open.
+ *      sS2 -> sSR      Simultaneous open
  *      sSR -> sSR      Retransmitted SYN/ACK.
  *      sES -> sIG      Late retransmitted SYN/ACK?
  *      sFW -> sIG      Might be SYN/ACK answering ignored SYN
@@ -231,10 +239,11 @@ static const u8 tcp_conntracks[2][6][TCP_CONNTRACK_MAX] = {
  *      sTW -> sIG
  *      sCL -> sIG
  */
-/*           sNO, sSS, sSR, sES, sFW, sCW, sLA, sTW, sCL, sLI   */
+/*           sNO, sSS, sSR, sES, sFW, sCW, sLA, sTW, sCL, sS2   */
 /*fin*/    { sIV, sIV, sFW, sFW, sLA, sLA, sLA, sTW, sCL, sIV },
 /*
  *      sSS -> sIV      Server might not send FIN in this state.
+ *      sS2 -> sIV
  *      sSR -> sFW      Close started.
  *      sES -> sFW
  *      sFW -> sLA      FIN seen in both directions.
@@ -243,10 +252,11 @@ static const u8 tcp_conntracks[2][6][TCP_CONNTRACK_MAX] = {
  *      sTW -> sTW
  *      sCL -> sCL
  */
-/*           sNO, sSS, sSR, sES, sFW, sCW, sLA, sTW, sCL, sLI   */
-/*ack*/    { sIV, sIG, sSR, sES, sCW, sCW, sTW, sTW, sCL, sIV },
+/*           sNO, sSS, sSR, sES, sFW, sCW, sLA, sTW, sCL, sS2   */
+/*ack*/    { sIV, sIG, sSR, sES, sCW, sCW, sTW, sTW, sCL, sIG },
 /*
  *      sSS -> sIG      Might be a half-open connection.
+ *      sS2 -> sIG
  *      sSR -> sSR      Might answer late resent SYN.
  *      sES -> sES      :-)
  *      sFW -> sCW      Normal close request answered by ACK.
@@ -255,8 +265,8 @@ static const u8 tcp_conntracks[2][6][TCP_CONNTRACK_MAX] = {
  *      sTW -> sTW      Retransmitted last ACK.
  *      sCL -> sCL
  */
-/*           sNO, sSS, sSR, sES, sFW, sCW, sLA, sTW, sCL, sLI   */
-/*rst*/    { sIV, sCL, sCL, sCL, sCL, sCL, sCL, sCL, sCL, sIV },
+/*           sNO, sSS, sSR, sES, sFW, sCW, sLA, sTW, sCL, sS2   */
+/*rst*/    { sIV, sCL, sCL, sCL, sCL, sCL, sCL, sCL, sCL, sCL },
 /*none*/   { sIV, sIV, sIV, sIV, sIV, sIV, sIV, sIV, sIV, sIV }
         }
 };
@@ -296,13 +306,13 @@ static int tcp_print_tuple(struct seq_file *s,
 }
 
 /* Print out the private part of the conntrack. */
-static int tcp_print_conntrack(struct seq_file *s, const struct nf_conn *ct)
+static int tcp_print_conntrack(struct seq_file *s, struct nf_conn *ct)
 {
         enum tcp_conntrack state;
 
-        read_lock_bh(&tcp_lock);
+        spin_lock_bh(&ct->lock);
         state = ct->proto.tcp.state;
-        read_unlock_bh(&tcp_lock);
+        spin_unlock_bh(&ct->lock);
 
         return seq_printf(s, "%s ", tcp_conntrack_names[state]);
 }
@@ -521,13 +531,14 @@ static bool tcp_in_window(const struct nf_conn *ct,
                  receiver->td_end, receiver->td_maxend, receiver->td_maxwin,
                  receiver->td_scale);
 
-        if (sender->td_end == 0) {
+        if (sender->td_maxwin == 0) {
                 /*
                  * Initialize sender data.
                  */
-                if (tcph->syn && tcph->ack) {
+                if (tcph->syn) {
                         /*
-                         * Outgoing SYN-ACK in reply to a SYN.
+                         * SYN-ACK in reply to a SYN
+                         * or SYN from reply direction in simultaneous open.
                          */
                         sender->td_end =
                         sender->td_maxend = end;
@@ -543,6 +554,9 @@ static bool tcp_in_window(const struct nf_conn *ct,
                               && receiver->flags & IP_CT_TCP_FLAG_WINDOW_SCALE))
                                 sender->td_scale =
                                 receiver->td_scale = 0;
+                        if (!tcph->ack)
+                                /* Simultaneous open */
+                                return true;
                 } else {
                         /*
                          * We are in the middle of a connection,
@@ -716,14 +730,14 @@ void nf_conntrack_tcp_update(const struct sk_buff *skb,
 
         end = segment_seq_plus_len(ntohl(tcph->seq), skb->len, dataoff, tcph);
 
-        write_lock_bh(&tcp_lock);
+        spin_lock_bh(&ct->lock);
         /*
          * We have to worry for the ack in the reply packet only...
          */
         if (after(end, ct->proto.tcp.seen[dir].td_end))
                 ct->proto.tcp.seen[dir].td_end = end;
         ct->proto.tcp.last_end = end;
-        write_unlock_bh(&tcp_lock);
+        spin_unlock_bh(&ct->lock);
         pr_debug("tcp_update: sender end=%u maxend=%u maxwin=%u scale=%i "
                  "receiver end=%u maxend=%u maxwin=%u scale=%i\n",
                  sender->td_end, sender->td_maxend, sender->td_maxwin,
@@ -832,7 +846,7 @@ static int tcp_packet(struct nf_conn *ct,
         th = skb_header_pointer(skb, dataoff, sizeof(_tcph), &_tcph);
         BUG_ON(th == NULL);
 
-        write_lock_bh(&tcp_lock);
+        spin_lock_bh(&ct->lock);
         old_state = ct->proto.tcp.state;
         dir = CTINFO2DIR(ctinfo);
         index = get_conntrack_index(th);
@@ -862,7 +876,7 @@ static int tcp_packet(struct nf_conn *ct,
                         && ct->proto.tcp.last_index == TCP_RST_SET)) {
                         /* Attempt to reopen a closed/aborted connection.
                          * Delete this connection and look up again. */
-                        write_unlock_bh(&tcp_lock);
+                        spin_unlock_bh(&ct->lock);
 
                         /* Only repeat if we can actually remove the timer.
                          * Destruction may already be in progress in process
@@ -898,7 +912,7 @@ static int tcp_packet(struct nf_conn *ct,
                          * that the client cannot but retransmit its SYN and
                          * thus initiate a clean new session.
                          */
-                        write_unlock_bh(&tcp_lock);
+                        spin_unlock_bh(&ct->lock);
                         if (LOG_INVALID(net, IPPROTO_TCP))
                                 nf_log_packet(pf, 0, skb, NULL, NULL, NULL,
                                           "nf_ct_tcp: killing out of sync session ");
@@ -911,7 +925,7 @@ static int tcp_packet(struct nf_conn *ct,
                 ct->proto.tcp.last_end =
                     segment_seq_plus_len(ntohl(th->seq), skb->len, dataoff, th);
 
-                write_unlock_bh(&tcp_lock);
+                spin_unlock_bh(&ct->lock);
                 if (LOG_INVALID(net, IPPROTO_TCP))
                         nf_log_packet(pf, 0, skb, NULL, NULL, NULL,
                                   "nf_ct_tcp: invalid packet ignored ");
@@ -920,7 +934,7 @@ static int tcp_packet(struct nf_conn *ct,
                 /* Invalid packet */
                 pr_debug("nf_ct_tcp: Invalid dir=%i index=%u ostate=%u\n",
                          dir, get_conntrack_index(th), old_state);
-                write_unlock_bh(&tcp_lock);
+                spin_unlock_bh(&ct->lock);
                 if (LOG_INVALID(net, IPPROTO_TCP))
                         nf_log_packet(pf, 0, skb, NULL, NULL, NULL,
                                   "nf_ct_tcp: invalid state ");
@@ -930,7 +944,7 @@ static int tcp_packet(struct nf_conn *ct,
                     && (ct->proto.tcp.seen[!dir].flags & IP_CT_TCP_FLAG_MAXACK_SET)
                     && before(ntohl(th->seq), ct->proto.tcp.seen[!dir].td_maxack)) {
                         /* Invalid RST  */
-                        write_unlock_bh(&tcp_lock);
+                        spin_unlock_bh(&ct->lock);
                         if (LOG_INVALID(net, IPPROTO_TCP))
                                 nf_log_packet(pf, 0, skb, NULL, NULL, NULL,
                                           "nf_ct_tcp: invalid RST ");
@@ -961,7 +975,7 @@ static int tcp_packet(struct nf_conn *ct,
 
         if (!tcp_in_window(ct, &ct->proto.tcp, dir, index,
                            skb, dataoff, th, pf)) {
-                write_unlock_bh(&tcp_lock);
+                spin_unlock_bh(&ct->lock);
                 return -NF_ACCEPT;
         }
      in_window:
@@ -990,9 +1004,8 @@ static int tcp_packet(struct nf_conn *ct,
                 timeout = nf_ct_tcp_timeout_unacknowledged;
         else
                 timeout = tcp_timeouts[new_state];
-        write_unlock_bh(&tcp_lock);
+        spin_unlock_bh(&ct->lock);
 
-        nf_conntrack_event_cache(IPCT_PROTOINFO_VOLATILE, ct);
         if (new_state != old_state)
                 nf_conntrack_event_cache(IPCT_PROTOINFO, ct);
 
@@ -1086,7 +1099,7 @@ static bool tcp_new(struct nf_conn *ct, const struct sk_buff *skb,
 
         ct->proto.tcp.seen[1].td_end = 0;
         ct->proto.tcp.seen[1].td_maxend = 0;
-        ct->proto.tcp.seen[1].td_maxwin = 1;
+        ct->proto.tcp.seen[1].td_maxwin = 0;
         ct->proto.tcp.seen[1].td_scale = 0;
 
         /* tcp_packet will set them */
@@ -1108,12 +1121,12 @@ static bool tcp_new(struct nf_conn *ct, const struct sk_buff *skb,
 #include <linux/netfilter/nfnetlink_conntrack.h>
 
 static int tcp_to_nlattr(struct sk_buff *skb, struct nlattr *nla,
-                         const struct nf_conn *ct)
+                         struct nf_conn *ct)
 {
         struct nlattr *nest_parms;
         struct nf_ct_tcp_flags tmp = {};
 
-        read_lock_bh(&tcp_lock);
+        spin_lock_bh(&ct->lock);
         nest_parms = nla_nest_start(skb, CTA_PROTOINFO_TCP | NLA_F_NESTED);
         if (!nest_parms)
                 goto nla_put_failure;
@@ -1133,14 +1146,14 @@ static int tcp_to_nlattr(struct sk_buff *skb, struct nlattr *nla,
         tmp.flags = ct->proto.tcp.seen[1].flags;
         NLA_PUT(skb, CTA_PROTOINFO_TCP_FLAGS_REPLY,
                 sizeof(struct nf_ct_tcp_flags), &tmp);
-        read_unlock_bh(&tcp_lock);
+        spin_unlock_bh(&ct->lock);
 
         nla_nest_end(skb, nest_parms);
 
         return 0;
 
 nla_put_failure:
-        read_unlock_bh(&tcp_lock);
+        spin_unlock_bh(&ct->lock);
         return -1;
 }
 
@@ -1171,7 +1184,7 @@ static int nlattr_to_tcp(struct nlattr *cda[], struct nf_conn *ct)
             nla_get_u8(tb[CTA_PROTOINFO_TCP_STATE]) >= TCP_CONNTRACK_MAX)
                 return -EINVAL;
 
-        write_lock_bh(&tcp_lock);
+        spin_lock_bh(&ct->lock);
         if (tb[CTA_PROTOINFO_TCP_STATE])
                 ct->proto.tcp.state = nla_get_u8(tb[CTA_PROTOINFO_TCP_STATE]);
 
@@ -1198,7 +1211,7 @@ static int nlattr_to_tcp(struct nlattr *cda[], struct nf_conn *ct)
                 ct->proto.tcp.seen[1].td_scale =
                         nla_get_u8(tb[CTA_PROTOINFO_TCP_WSCALE_REPLY]);
         }
-        write_unlock_bh(&tcp_lock);
+        spin_unlock_bh(&ct->lock);
 
         return 0;
 }
@@ -1328,6 +1341,13 @@ static struct ctl_table tcp_compat_sysctl_table[] = {
                 .proc_handler   = proc_dointvec_jiffies,
         },
         {
+                .procname       = "ip_conntrack_tcp_timeout_syn_sent2",
+                .data           = &tcp_timeouts[TCP_CONNTRACK_SYN_SENT2],
+                .maxlen         = sizeof(unsigned int),
+                .mode           = 0644,
+                .proc_handler   = proc_dointvec_jiffies,
+        },
+        {
                 .procname       = "ip_conntrack_tcp_timeout_syn_recv",
                 .data           = &tcp_timeouts[TCP_CONNTRACK_SYN_RECV],
                 .maxlen         = sizeof(unsigned int),
diff --git a/net/netfilter/nf_log.c b/net/netfilter/nf_log.c
index beb37311e1a5..2fefe147750a 100644
--- a/net/netfilter/nf_log.c
+++ b/net/netfilter/nf_log.c
@@ -248,14 +248,14 @@ static int nf_log_proc_dostring(ctl_table *table, int write, struct file *filp,
                 rcu_assign_pointer(nf_loggers[tindex], logger);
                 mutex_unlock(&nf_log_mutex);
         } else {
-                rcu_read_lock();
-                logger = rcu_dereference(nf_loggers[tindex]);
+                mutex_lock(&nf_log_mutex);
+                logger = nf_loggers[tindex];
                 if (!logger)
                         table->data = "NONE";
                 else
                         table->data = logger->name;
                 r = proc_dostring(table, write, filp, buffer, lenp, ppos);
-                rcu_read_unlock();
+                mutex_unlock(&nf_log_mutex);
         }
 
         return r;
diff --git a/net/netfilter/nf_queue.c b/net/netfilter/nf_queue.c
index 4f2310c93e01..3a6fd77f7761 100644
--- a/net/netfilter/nf_queue.c
+++ b/net/netfilter/nf_queue.c
@@ -204,10 +204,10 @@ int nf_queue(struct sk_buff *skb,
                                   queuenum);
 
         switch (pf) {
-        case AF_INET:
+        case NFPROTO_IPV4:
                 skb->protocol = htons(ETH_P_IP);
                 break;
-        case AF_INET6:
+        case NFPROTO_IPV6:
                 skb->protocol = htons(ETH_P_IPV6);
                 break;
         }
diff --git a/net/netfilter/nfnetlink.c b/net/netfilter/nfnetlink.c
index b8ab37ad7ed5..92761a988375 100644
--- a/net/netfilter/nfnetlink.c
+++ b/net/netfilter/nfnetlink.c
@@ -107,9 +107,10 @@ int nfnetlink_has_listeners(unsigned int group)
 }
 EXPORT_SYMBOL_GPL(nfnetlink_has_listeners);
 
-int nfnetlink_send(struct sk_buff *skb, u32 pid, unsigned group, int echo)
+int nfnetlink_send(struct sk_buff *skb, u32 pid,
+                   unsigned group, int echo, gfp_t flags)
 {
-        return nlmsg_notify(nfnl, skb, pid, group, echo, gfp_any());
+        return nlmsg_notify(nfnl, skb, pid, group, echo, flags);
 }
 EXPORT_SYMBOL_GPL(nfnetlink_send);
 
@@ -136,7 +137,7 @@ static int nfnetlink_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
                 return -EPERM;
 
         /* All the messages must at least contain nfgenmsg */
-        if (nlh->nlmsg_len < NLMSG_SPACE(sizeof(struct nfgenmsg)))
+        if (nlh->nlmsg_len < NLMSG_LENGTH(sizeof(struct nfgenmsg)))
                 return 0;
 
         type = nlh->nlmsg_type;
@@ -160,19 +161,14 @@ replay:
         {
                 int min_len = NLMSG_SPACE(sizeof(struct nfgenmsg));
                 u_int8_t cb_id = NFNL_MSG_TYPE(nlh->nlmsg_type);
-                u_int16_t attr_count = ss->cb[cb_id].attr_count;
-                struct nlattr *cda[attr_count+1];
-
-                if (likely(nlh->nlmsg_len >= min_len)) {
-                        struct nlattr *attr = (void *)nlh + NLMSG_ALIGN(min_len);
-                        int attrlen = nlh->nlmsg_len - NLMSG_ALIGN(min_len);
-
-                        err = nla_parse(cda, attr_count, attr, attrlen,
-                                        ss->cb[cb_id].policy);
-                        if (err < 0)
-                                return err;
-                } else
-                        return -EINVAL;
+                struct nlattr *cda[ss->cb[cb_id].attr_count + 1];
+                struct nlattr *attr = (void *)nlh + min_len;
+                int attrlen = nlh->nlmsg_len - min_len;
+
+                err = nla_parse(cda, ss->cb[cb_id].attr_count,
+                                attr, attrlen, ss->cb[cb_id].policy);
+                if (err < 0)
+                        return err;
 
                 err = nc->call(nfnl, skb, nlh, cda);
                 if (err == -EAGAIN)
diff --git a/net/netfilter/nfnetlink_queue.c b/net/netfilter/nfnetlink_queue.c
index 8c860112ce05..71daa0934b6c 100644
--- a/net/netfilter/nfnetlink_queue.c
+++ b/net/netfilter/nfnetlink_queue.c
@@ -1,6 +1,6 @@
 /*
  * This is a module which is used for queueing packets and communicating with
- * userspace via nfetlink.
+ * userspace via nfnetlink.
  *
  * (C) 2005 by Harald Welte <laforge@netfilter.org>
  * (C) 2007 by Patrick McHardy <kaber@trash.net>
@@ -932,6 +932,8 @@ static void __exit nfnetlink_queue_fini(void)
 #endif
         nfnetlink_subsys_unregister(&nfqnl_subsys);
         netlink_unregister_notifier(&nfqnl_rtnl_notifier);
+
+        rcu_barrier(); /* Wait for completion of call_rcu()'s */
 }
 
 MODULE_DESCRIPTION("netfilter packet queue handler");
diff --git a/net/netfilter/x_tables.c b/net/netfilter/x_tables.c
index 150e5cf62f85..025d1a0af78b 100644
--- a/net/netfilter/x_tables.c
+++ b/net/netfilter/x_tables.c
@@ -329,6 +329,32 @@ int xt_find_revision(u8 af, const char *name, u8 revision, int target,
 }
 EXPORT_SYMBOL_GPL(xt_find_revision);
 
+static char *textify_hooks(char *buf, size_t size, unsigned int mask)
+{
+        static const char *const names[] = {
+                "PREROUTING", "INPUT", "FORWARD",
+                "OUTPUT", "POSTROUTING", "BROUTING",
+        };
+        unsigned int i;
+        char *p = buf;
+        bool np = false;
+        int res;
+
+        *p = '\0';
+        for (i = 0; i < ARRAY_SIZE(names); ++i) {
+                if (!(mask & (1 << i)))
+                        continue;
+                res = snprintf(p, size, "%s%s", np ? "/" : "", names[i]);
+                if (res > 0) {
+                        size -= res;
+                        p += res;
+                }
+                np = true;
+        }
+
+        return buf;
+}
+
 int xt_check_match(struct xt_mtchk_param *par,
                    unsigned int size, u_int8_t proto, bool inv_proto)
 {
@@ -338,26 +364,30 @@ int xt_check_match(struct xt_mtchk_param *par,
                  * ebt_among is exempt from centralized matchsize checking
                  * because it uses a dynamic-size data set.
                  */
-                printk("%s_tables: %s match: invalid size %Zu != %u\n",
+                pr_err("%s_tables: %s match: invalid size %Zu != %u\n",
                        xt_prefix[par->family], par->match->name,
                        XT_ALIGN(par->match->matchsize), size);
                 return -EINVAL;
         }
         if (par->match->table != NULL &&
             strcmp(par->match->table, par->table) != 0) {
-                printk("%s_tables: %s match: only valid in %s table, not %s\n",
+                pr_err("%s_tables: %s match: only valid in %s table, not %s\n",
                        xt_prefix[par->family], par->match->name,
                        par->match->table, par->table);
                 return -EINVAL;
         }
         if (par->match->hooks && (par->hook_mask & ~par->match->hooks) != 0) {
-                printk("%s_tables: %s match: bad hook_mask %#x/%#x\n",
+                char used[64], allow[64];
+
+                pr_err("%s_tables: %s match: used from hooks %s, but only "
+                       "valid from %s\n",
                        xt_prefix[par->family], par->match->name,
-                       par->hook_mask, par->match->hooks);
+                       textify_hooks(used, sizeof(used), par->hook_mask),
+                       textify_hooks(allow, sizeof(allow), par->match->hooks));
                 return -EINVAL;
         }
         if (par->match->proto && (par->match->proto != proto || inv_proto)) {
-                printk("%s_tables: %s match: only valid for protocol %u\n",
+                pr_err("%s_tables: %s match: only valid for protocol %u\n",
                        xt_prefix[par->family], par->match->name,
                        par->match->proto);
                 return -EINVAL;
@@ -484,26 +514,30 @@ int xt_check_target(struct xt_tgchk_param *par,
                     unsigned int size, u_int8_t proto, bool inv_proto)
 {
         if (XT_ALIGN(par->target->targetsize) != size) {
-                printk("%s_tables: %s target: invalid size %Zu != %u\n",
+                pr_err("%s_tables: %s target: invalid size %Zu != %u\n",
                        xt_prefix[par->family], par->target->name,
                        XT_ALIGN(par->target->targetsize), size);
                 return -EINVAL;
         }
         if (par->target->table != NULL &&
             strcmp(par->target->table, par->table) != 0) {
-                printk("%s_tables: %s target: only valid in %s table, not %s\n",
+                pr_err("%s_tables: %s target: only valid in %s table, not %s\n",
                        xt_prefix[par->family], par->target->name,
                        par->target->table, par->table);
                 return -EINVAL;
         }
         if (par->target->hooks && (par->hook_mask & ~par->target->hooks) != 0) {
-                printk("%s_tables: %s target: bad hook_mask %#x/%#x\n",
+                char used[64], allow[64];
+
+                pr_err("%s_tables: %s target: used from hooks %s, but only "
+                       "usable from %s\n",
                        xt_prefix[par->family], par->target->name,
-                       par->hook_mask, par->target->hooks);
+                       textify_hooks(used, sizeof(used), par->hook_mask),
+                       textify_hooks(allow, sizeof(allow), par->target->hooks));
                 return -EINVAL;
         }
         if (par->target->proto && (par->target->proto != proto || inv_proto)) {
-                printk("%s_tables: %s target: only valid for protocol %u\n",
+                pr_err("%s_tables: %s target: only valid for protocol %u\n",
                        xt_prefix[par->family], par->target->name,
                        par->target->proto);
                 return -EINVAL;
diff --git a/net/netfilter/xt_NFQUEUE.c b/net/netfilter/xt_NFQUEUE.c
index f9977b3311f7..498b45101df7 100644
--- a/net/netfilter/xt_NFQUEUE.c
+++ b/net/netfilter/xt_NFQUEUE.c
@@ -11,6 +11,10 @@
 #include <linux/module.h>
 #include <linux/skbuff.h>
 
+#include <linux/ip.h>
+#include <linux/ipv6.h>
+#include <linux/jhash.h>
+
 #include <linux/netfilter.h>
 #include <linux/netfilter_arp.h>
 #include <linux/netfilter/x_tables.h>
@@ -23,6 +27,8 @@ MODULE_ALIAS("ipt_NFQUEUE");
 MODULE_ALIAS("ip6t_NFQUEUE");
 MODULE_ALIAS("arpt_NFQUEUE");
 
+static u32 jhash_initval __read_mostly;
+
 static unsigned int
 nfqueue_tg(struct sk_buff *skb, const struct xt_target_param *par)
 {
@@ -31,32 +37,105 @@ nfqueue_tg(struct sk_buff *skb, const struct xt_target_param *par)
         return NF_QUEUE_NR(tinfo->queuenum);
 }
 
+static u32 hash_v4(const struct sk_buff *skb)
+{
+        const struct iphdr *iph = ip_hdr(skb);
+        u32 ipaddr;
+
+        /* packets in either direction go into same queue */
+        ipaddr = iph->saddr ^ iph->daddr;
+
+        return jhash_2words(ipaddr, iph->protocol, jhash_initval);
+}
+
+static unsigned int
+nfqueue_tg4_v1(struct sk_buff *skb, const struct xt_target_param *par)
+{
+        const struct xt_NFQ_info_v1 *info = par->targinfo;
+        u32 queue = info->queuenum;
+
+        if (info->queues_total > 1)
+                queue = hash_v4(skb) % info->queues_total + queue;
+        return NF_QUEUE_NR(queue);
+}
+
+#if defined(CONFIG_IP6_NF_IPTABLES) || defined(CONFIG_IP6_NF_IPTABLES_MODULE)
+static u32 hash_v6(const struct sk_buff *skb)
+{
+        const struct ipv6hdr *ip6h = ipv6_hdr(skb);
+        u32 addr[4];
+
+        addr[0] = ip6h->saddr.s6_addr32[0] ^ ip6h->daddr.s6_addr32[0];
+        addr[1] = ip6h->saddr.s6_addr32[1] ^ ip6h->daddr.s6_addr32[1];
+        addr[2] = ip6h->saddr.s6_addr32[2] ^ ip6h->daddr.s6_addr32[2];
+        addr[3] = ip6h->saddr.s6_addr32[3] ^ ip6h->daddr.s6_addr32[3];
+
+        return jhash2(addr, ARRAY_SIZE(addr), jhash_initval);
+}
+
+static unsigned int
+nfqueue_tg6_v1(struct sk_buff *skb, const struct xt_target_param *par)
+{
+        const struct xt_NFQ_info_v1 *info = par->targinfo;
+        u32 queue = info->queuenum;
+
+        if (info->queues_total > 1)
+                queue = hash_v6(skb) % info->queues_total + queue;
+        return NF_QUEUE_NR(queue);
+}
+#endif
+
+static bool nfqueue_tg_v1_check(const struct xt_tgchk_param *par)
+{
+        const struct xt_NFQ_info_v1 *info = par->targinfo;
+        u32 maxid;
+
+        if (info->queues_total == 0) {
+                pr_err("NFQUEUE: number of total queues is 0\n");
+                return false;
+        }
+        maxid = info->queues_total - 1 + info->queuenum;
+        if (maxid > 0xffff) {
+                pr_err("NFQUEUE: number of queues (%u) out of range (got %u)\n",
+                       info->queues_total, maxid);
+                return false;
+        }
+        return true;
+}
+
 static struct xt_target nfqueue_tg_reg[] __read_mostly = {
         {
                 .name           = "NFQUEUE",
-                .family         = NFPROTO_IPV4,
+                .family         = NFPROTO_UNSPEC,
                 .target         = nfqueue_tg,
                 .targetsize     = sizeof(struct xt_NFQ_info),
                 .me             = THIS_MODULE,
         },
         {
                 .name           = "NFQUEUE",
-                .family         = NFPROTO_IPV6,
-                .target         = nfqueue_tg,
-                .targetsize     = sizeof(struct xt_NFQ_info),
+                .revision       = 1,
+                .family         = NFPROTO_IPV4,
+                .checkentry     = nfqueue_tg_v1_check,
+                .target         = nfqueue_tg4_v1,
+                .targetsize     = sizeof(struct xt_NFQ_info_v1),
                 .me             = THIS_MODULE,
         },
+#if defined(CONFIG_IP6_NF_IPTABLES) || defined(CONFIG_IP6_NF_IPTABLES_MODULE)
         {
                 .name           = "NFQUEUE",
-                .family         = NFPROTO_ARP,
-                .target         = nfqueue_tg,
-                .targetsize     = sizeof(struct xt_NFQ_info),
+                .revision       = 1,
+                .family         = NFPROTO_IPV6,
+                .checkentry     = nfqueue_tg_v1_check,
+                .target         = nfqueue_tg6_v1,
+                .targetsize     = sizeof(struct xt_NFQ_info_v1),
                 .me             = THIS_MODULE,
         },
+#endif
 };
 
 static int __init nfqueue_tg_init(void)
 {
+        get_random_bytes(&jhash_initval, sizeof(jhash_initval));
         return xt_register_targets(nfqueue_tg_reg, ARRAY_SIZE(nfqueue_tg_reg));
 }
 
diff --git a/net/netfilter/xt_TCPMSS.c b/net/netfilter/xt_TCPMSS.c
index 4f3b1f808795..eda64c1cb1e5 100644
--- a/net/netfilter/xt_TCPMSS.c
+++ b/net/netfilter/xt_TCPMSS.c
@@ -73,11 +73,11 @@ tcpmss_mangle_packet(struct sk_buff *skb,
         }
 
         if (info->mss == XT_TCPMSS_CLAMP_PMTU) {
-                if (dst_mtu(skb->dst) <= minlen) {
+                if (dst_mtu(skb_dst(skb)) <= minlen) {
                         if (net_ratelimit())
                                 printk(KERN_ERR "xt_TCPMSS: "
                                        "unknown or invalid path-MTU (%u)\n",
-                                       dst_mtu(skb->dst));
+                                       dst_mtu(skb_dst(skb)));
                         return -1;
                 }
                 if (in_mtu <= minlen) {
@@ -86,7 +86,7 @@ tcpmss_mangle_packet(struct sk_buff *skb,
                                        "invalid path-MTU (%u)\n", in_mtu);
                         return -1;
                 }
-                newmss = min(dst_mtu(skb->dst), in_mtu) - minlen;
+                newmss = min(dst_mtu(skb_dst(skb)), in_mtu) - minlen;
         } else
                 newmss = info->mss;
 
diff --git a/net/netfilter/xt_osf.c b/net/netfilter/xt_osf.c
new file mode 100644
index 000000000000..863e40977a4d
--- /dev/null
+++ b/net/netfilter/xt_osf.c
@@ -0,0 +1,428 @@
+/*
+ * Copyright (c) 2003+ Evgeniy Polyakov <zbr@ioremap.net>
+ *
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+
+#include <linux/if.h>
+#include <linux/inetdevice.h>
+#include <linux/ip.h>
+#include <linux/list.h>
+#include <linux/rculist.h>
+#include <linux/skbuff.h>
+#include <linux/slab.h>
+#include <linux/tcp.h>
+
+#include <net/ip.h>
+#include <net/tcp.h>
+
+#include <linux/netfilter/nfnetlink.h>
+#include <linux/netfilter/x_tables.h>
+#include <net/netfilter/nf_log.h>
+#include <linux/netfilter/xt_osf.h>
+
+struct xt_osf_finger {
+        struct rcu_head                 rcu_head;
+        struct list_head                finger_entry;
+        struct xt_osf_user_finger       finger;
+};
+
+enum osf_fmatch_states {
+        /* Packet does not match the fingerprint */
+        FMATCH_WRONG = 0,
+        /* Packet matches the fingerprint */
+        FMATCH_OK,
+        /* Options do not match the fingerprint, but header does */
+        FMATCH_OPT_WRONG,
+};
+
+/*
+ * Indexed by dont-fragment bit.
+ * It is the only constant value in the fingerprint.
+ */
+static struct list_head xt_osf_fingers[2];
+
+static const struct nla_policy xt_osf_policy[OSF_ATTR_MAX + 1] = {
+        [OSF_ATTR_FINGER]       = { .len = sizeof(struct xt_osf_user_finger) },
+};
+
+static void xt_osf_finger_free_rcu(struct rcu_head *rcu_head)
+{
+        struct xt_osf_finger *f = container_of(rcu_head, struct xt_osf_finger, rcu_head);
+
+        kfree(f);
+}
+
+static int xt_osf_add_callback(struct sock *ctnl, struct sk_buff *skb,
+                        struct nlmsghdr *nlh, struct nlattr *osf_attrs[])
+{
+        struct xt_osf_user_finger *f;
+        struct xt_osf_finger *kf = NULL, *sf;
+        int err = 0;
+
+        if (!osf_attrs[OSF_ATTR_FINGER])
+                return -EINVAL;
+
+        if (!(nlh->nlmsg_flags & NLM_F_CREATE))
+                return -EINVAL;
+
+        f = nla_data(osf_attrs[OSF_ATTR_FINGER]);
+
+        kf = kmalloc(sizeof(struct xt_osf_finger), GFP_KERNEL);
+        if (!kf)
+                return -ENOMEM;
+
+        memcpy(&kf->finger, f, sizeof(struct xt_osf_user_finger));
+
+        list_for_each_entry(sf, &xt_osf_fingers[!!f->df], finger_entry) {
+                if (memcmp(&sf->finger, f, sizeof(struct xt_osf_user_finger)))
+                        continue;
+
+                kfree(kf);
+                kf = NULL;
+
+                if (nlh->nlmsg_flags & NLM_F_EXCL)
+                        err = -EEXIST;
+                break;
+        }
+
+        /*
+         * We are protected by nfnl mutex.
+         */
+        if (kf)
+                list_add_tail_rcu(&kf->finger_entry, &xt_osf_fingers[!!f->df]);
+
+        return err;
+}
+
+static int xt_osf_remove_callback(struct sock *ctnl, struct sk_buff *skb,
+                        struct nlmsghdr *nlh, struct nlattr *osf_attrs[])
+{
+        struct xt_osf_user_finger *f;
+        struct xt_osf_finger *sf;
+        int err = ENOENT;
+
+        if (!osf_attrs[OSF_ATTR_FINGER])
+                return -EINVAL;
+
+        f = nla_data(osf_attrs[OSF_ATTR_FINGER]);
+
+        list_for_each_entry(sf, &xt_osf_fingers[!!f->df], finger_entry) {
+                if (memcmp(&sf->finger, f, sizeof(struct xt_osf_user_finger)))
+                        continue;
+
+                /*
+                 * We are protected by nfnl mutex.
+                 */
+                list_del_rcu(&sf->finger_entry);
+                call_rcu(&sf->rcu_head, xt_osf_finger_free_rcu);
+
+                err = 0;
+                break;
+        }
+
+        return err;
+}
+
+static const struct nfnl_callback xt_osf_nfnetlink_callbacks[OSF_MSG_MAX] = {
+        [OSF_MSG_ADD]   = {
+                .call           = xt_osf_add_callback,
+                .attr_count     = OSF_ATTR_MAX,
+                .policy         = xt_osf_policy,
+        },
+        [OSF_MSG_REMOVE]        = {
+                .call           = xt_osf_remove_callback,
+                .attr_count     = OSF_ATTR_MAX,
+                .policy         = xt_osf_policy,
+        },
+};
+
+static const struct nfnetlink_subsystem xt_osf_nfnetlink = {
+        .name                   = "osf",
+        .subsys_id              = NFNL_SUBSYS_OSF,
+        .cb_count               = OSF_MSG_MAX,
+        .cb                     = xt_osf_nfnetlink_callbacks,
+};
+
+static inline int xt_osf_ttl(const struct sk_buff *skb, const struct xt_osf_info *info,
+                            unsigned char f_ttl)
+{
+        const struct iphdr *ip = ip_hdr(skb);
+
+        if (info->flags & XT_OSF_TTL) {
+                if (info->ttl == XT_OSF_TTL_TRUE)
+                        return ip->ttl == f_ttl;
+                if (info->ttl == XT_OSF_TTL_NOCHECK)
+                        return 1;
+                else if (ip->ttl <= f_ttl)
+                        return 1;
+                else {
+                        struct in_device *in_dev = __in_dev_get_rcu(skb->dev);
+                        int ret = 0;
+
+                        for_ifa(in_dev) {
+                                if (inet_ifa_match(ip->saddr, ifa)) {
+                                        ret = (ip->ttl == f_ttl);
+                                        break;
+                                }
+                        }
+                        endfor_ifa(in_dev);
+
+                        return ret;
+                }
+        }
+
+        return ip->ttl == f_ttl;
+}
+
+static bool xt_osf_match_packet(const struct sk_buff *skb,
+                const struct xt_match_param *p)
+{
+        const struct xt_osf_info *info = p->matchinfo;
+        const struct iphdr *ip = ip_hdr(skb);
+        const struct tcphdr *tcp;
+        struct tcphdr _tcph;
+        int fmatch = FMATCH_WRONG, fcount = 0;
+        unsigned int optsize = 0, check_WSS = 0;
+        u16 window, totlen, mss = 0;
+        bool df;
+        const unsigned char *optp = NULL, *_optp = NULL;
+        unsigned char opts[MAX_IPOPTLEN];
+        const struct xt_osf_finger *kf;
+        const struct xt_osf_user_finger *f;
+
+        if (!info)
+                return false;
+
+        tcp = skb_header_pointer(skb, ip_hdrlen(skb), sizeof(struct tcphdr), &_tcph);
+        if (!tcp)
+                return false;
+
+        if (!tcp->syn)
+                return false;
+
+        totlen = ntohs(ip->tot_len);
+        df = ntohs(ip->frag_off) & IP_DF;
+        window = ntohs(tcp->window);
+
+        if (tcp->doff * 4 > sizeof(struct tcphdr)) {
+                optsize = tcp->doff * 4 - sizeof(struct tcphdr);
+
+                _optp = optp = skb_header_pointer(skb, ip_hdrlen(skb) +
+                                sizeof(struct tcphdr), optsize, opts);
+        }
+
+        rcu_read_lock();
+        list_for_each_entry_rcu(kf, &xt_osf_fingers[df], finger_entry) {
+                f = &kf->finger;
+
+                if (!(info->flags & XT_OSF_LOG) && strcmp(info->genre, f->genre))
+                        continue;
+
+                optp = _optp;
+                fmatch = FMATCH_WRONG;
+
+                if (totlen == f->ss && xt_osf_ttl(skb, info, f->ttl)) {
+                        int foptsize, optnum;
+
+                        /*
+                         * Should not happen if userspace parser was written correctly.
+                         */
+                        if (f->wss.wc >= OSF_WSS_MAX)
+                                continue;
+
+                        /* Check options */
+
+                        foptsize = 0;
+                        for (optnum = 0; optnum < f->opt_num; ++optnum)
+                                foptsize += f->opt[optnum].length;
+
+                        if (foptsize > MAX_IPOPTLEN ||
+                                optsize > MAX_IPOPTLEN ||
+                                optsize != foptsize)
+                                continue;
+
+                        check_WSS = f->wss.wc;
+
+                        for (optnum = 0; optnum < f->opt_num; ++optnum) {
+                                if (f->opt[optnum].kind == (*optp)) {
+                                        __u32 len = f->opt[optnum].length;
+                                        const __u8 *optend = optp + len;
+                                        int loop_cont = 0;
+
+                                        fmatch = FMATCH_OK;
+
+                                        switch (*optp) {
+                                        case OSFOPT_MSS:
+                                                mss = optp[3];
+                                                mss <<= 8;
+                                                mss |= optp[2];
+
+                                                mss = ntohs(mss);
+                                                break;
+                                        case OSFOPT_TS:
+                                                loop_cont = 1;
+                                                break;
+                                        }
+
+                                        optp = optend;
+                                } else
+                                        fmatch = FMATCH_OPT_WRONG;
+
+                                if (fmatch != FMATCH_OK)
+                                        break;
+                        }
+
+                        if (fmatch != FMATCH_OPT_WRONG) {
+                                fmatch = FMATCH_WRONG;
+
+                                switch (check_WSS) {
+                                case OSF_WSS_PLAIN:
+                                        if (f->wss.val == 0 || window == f->wss.val)
+                                                fmatch = FMATCH_OK;
+                                        break;
+                                case OSF_WSS_MSS:
+                                        /*
+                                         * Some smart modems decrease mangle MSS to 
+                                         * SMART_MSS_2, so we check standard, decreased
+                                         * and the one provided in the fingerprint MSS
+                                         * values.
+                                         */
+#define SMART_MSS_1     1460
+#define SMART_MSS_2     1448
+                                        if (window == f->wss.val * mss ||
+                                            window == f->wss.val * SMART_MSS_1 ||
+                                            window == f->wss.val * SMART_MSS_2)
+                                                fmatch = FMATCH_OK;
+                                        break;
+                                case OSF_WSS_MTU:
+                                        if (window == f->wss.val * (mss + 40) ||
+                                            window == f->wss.val * (SMART_MSS_1 + 40) ||
+                                            window == f->wss.val * (SMART_MSS_2 + 40))
+                                                fmatch = FMATCH_OK;
+                                        break;
+                                case OSF_WSS_MODULO:
+                                        if ((window % f->wss.val) == 0)
+                                                fmatch = FMATCH_OK;
+                                        break;
+                                }
+                        }
+
+                        if (fmatch != FMATCH_OK)
+                                continue;
+
+                        fcount++;
+
+                        if (info->flags & XT_OSF_LOG)
+                                nf_log_packet(p->hooknum, 0, skb, p->in, p->out, NULL,
+                                        "%s [%s:%s] : %pi4:%d -> %pi4:%d hops=%d\n",
+                                        f->genre, f->version, f->subtype,
+                                        &ip->saddr, ntohs(tcp->source),
+                                        &ip->daddr, ntohs(tcp->dest),
+                                        f->ttl - ip->ttl);
+
+                        if ((info->flags & XT_OSF_LOG) &&
+                            info->loglevel == XT_OSF_LOGLEVEL_FIRST)
+                                break;
+                }
+        }
+        rcu_read_unlock();
+
+        if (!fcount && (info->flags & XT_OSF_LOG))
+                nf_log_packet(p->hooknum, 0, skb, p->in, p->out, NULL,
+                        "Remote OS is not known: %pi4:%u -> %pi4:%u\n",
+                                &ip->saddr, ntohs(tcp->source),
+                                &ip->daddr, ntohs(tcp->dest));
+
+        if (fcount)
+                fmatch = FMATCH_OK;
+
+        return fmatch == FMATCH_OK;
+}
+
+static struct xt_match xt_osf_match = {
+        .name           = "osf",
+        .revision       = 0,
+        .family         = NFPROTO_IPV4,
+        .proto          = IPPROTO_TCP,
+        .hooks          = (1 << NF_INET_LOCAL_IN) |
+                                (1 << NF_INET_PRE_ROUTING) |
+                                (1 << NF_INET_FORWARD),
+        .match          = xt_osf_match_packet,
+        .matchsize      = sizeof(struct xt_osf_info),
+        .me             = THIS_MODULE,
+};
+
+static int __init xt_osf_init(void)
+{
+        int err = -EINVAL;
+        int i;
+
+        for (i=0; i<ARRAY_SIZE(xt_osf_fingers); ++i)
+                INIT_LIST_HEAD(&xt_osf_fingers[i]);
+
+        err = nfnetlink_subsys_register(&xt_osf_nfnetlink);
+        if (err < 0) {
+                printk(KERN_ERR "Failed (%d) to register OSF nsfnetlink helper.\n", err);
+                goto err_out_exit;
+        }
+
+        err = xt_register_match(&xt_osf_match);
+        if (err) {
+                printk(KERN_ERR "Failed (%d) to register OS fingerprint "
+                                "matching module.\n", err);
+                goto err_out_remove;
+        }
+
+        return 0;
+
+err_out_remove:
+        nfnetlink_subsys_unregister(&xt_osf_nfnetlink);
+err_out_exit:
+        return err;
+}
+
+static void __exit xt_osf_fini(void)
+{
+        struct xt_osf_finger *f;
+        int i;
+
+        nfnetlink_subsys_unregister(&xt_osf_nfnetlink);
+        xt_unregister_match(&xt_osf_match);
+
+        rcu_read_lock();
+        for (i=0; i<ARRAY_SIZE(xt_osf_fingers); ++i) {
+
+                list_for_each_entry_rcu(f, &xt_osf_fingers[i], finger_entry) {
+                        list_del_rcu(&f->finger_entry);
+                        call_rcu(&f->rcu_head, xt_osf_finger_free_rcu);
+                }
+        }
+        rcu_read_unlock();
+
+        rcu_barrier();
+}
+
+module_init(xt_osf_init);
+module_exit(xt_osf_fini);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Evgeniy Polyakov <zbr@ioremap.net>");
+MODULE_DESCRIPTION("Passive OS fingerprint matching.");
+MODULE_ALIAS_NFNL_SUBSYS(NFNL_SUBSYS_OSF);
diff --git a/net/netfilter/xt_policy.c b/net/netfilter/xt_policy.c
index 328bd20ddd25..4cbfebda8fa1 100644
--- a/net/netfilter/xt_policy.c
+++ b/net/netfilter/xt_policy.c
@@ -86,7 +86,7 @@ match_policy_out(const struct sk_buff *skb, const struct xt_policy_info *info,
                  unsigned short family)
 {
         const struct xt_policy_elem *e;
-        const struct dst_entry *dst = skb->dst;
+        const struct dst_entry *dst = skb_dst(skb);
         int strict = info->flags & XT_POLICY_MATCH_STRICT;
         int i, pos;
 
diff --git a/net/netfilter/xt_realm.c b/net/netfilter/xt_realm.c
index 67419287bc7e..484d1689bfde 100644
--- a/net/netfilter/xt_realm.c
+++ b/net/netfilter/xt_realm.c
@@ -25,7 +25,7 @@ static bool
 realm_mt(const struct sk_buff *skb, const struct xt_match_param *par)
 {
         const struct xt_realm_info *info = par->matchinfo;
-        const struct dst_entry *dst = skb->dst;
+        const struct dst_entry *dst = skb_dst(skb);
 
         return (info->id == (dst->tclassid & info->mask)) ^ info->invert;
 }
diff --git a/net/netfilter/xt_socket.c b/net/netfilter/xt_socket.c
index 1acc089be7e9..ebf00ad5b194 100644
--- a/net/netfilter/xt_socket.c
+++ b/net/netfilter/xt_socket.c
@@ -22,6 +22,8 @@
 #include <net/netfilter/nf_tproxy_core.h>
 #include <net/netfilter/ipv4/nf_defrag_ipv4.h>
 
+#include <linux/netfilter/xt_socket.h>
+
 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
 #define XT_SOCKET_HAVE_CONNTRACK 1
 #include <net/netfilter/nf_conntrack.h>
@@ -86,7 +88,8 @@ extract_icmp_fields(const struct sk_buff *skb,
 
 
 static bool
-socket_mt(const struct sk_buff *skb, const struct xt_match_param *par)
+socket_match(const struct sk_buff *skb, const struct xt_match_param *par,
+             const struct xt_socket_mtinfo1 *info)
 {
         const struct iphdr *iph = ip_hdr(skb);
         struct udphdr _hdr, *hp = NULL;
@@ -141,10 +144,24 @@ socket_mt(const struct sk_buff *skb, const struct xt_match_param *par)
         sk = nf_tproxy_get_sock_v4(dev_net(skb->dev), protocol,
                                    saddr, daddr, sport, dport, par->in, false);
         if (sk != NULL) {
-                bool wildcard = (sk->sk_state != TCP_TIME_WAIT && inet_sk(sk)->rcv_saddr == 0);
+                bool wildcard;
+                bool transparent = true;
+
+                /* Ignore sockets listening on INADDR_ANY */
+                wildcard = (sk->sk_state != TCP_TIME_WAIT &&
+                            inet_sk(sk)->rcv_saddr == 0);
+
+                /* Ignore non-transparent sockets,
+                   if XT_SOCKET_TRANSPARENT is used */
+                if (info && info->flags & XT_SOCKET_TRANSPARENT)
+                        transparent = ((sk->sk_state != TCP_TIME_WAIT &&
+                                        inet_sk(sk)->transparent) ||
+                                       (sk->sk_state == TCP_TIME_WAIT &&
+                                        inet_twsk(sk)->tw_transparent));
 
                 nf_tproxy_put_sock(sk);
-                if (wildcard)
+
+                if (wildcard || !transparent)
                         sk = NULL;
         }
 
@@ -157,23 +174,47 @@ socket_mt(const struct sk_buff *skb, const struct xt_match_param *par)
         return (sk != NULL);
 }
 
-static struct xt_match socket_mt_reg __read_mostly = {
-        .name           = "socket",
-        .family         = AF_INET,
-        .match          = socket_mt,
-        .hooks          = 1 << NF_INET_PRE_ROUTING,
-        .me             = THIS_MODULE,
+static bool
+socket_mt_v0(const struct sk_buff *skb, const struct xt_match_param *par)
+{
+        return socket_match(skb, par, NULL);
+}
+
+static bool
+socket_mt_v1(const struct sk_buff *skb, const struct xt_match_param *par)
+{
+        return socket_match(skb, par, par->matchinfo);
+}
+
+static struct xt_match socket_mt_reg[] __read_mostly = {
+        {
+                .name           = "socket",
+                .revision       = 0,
+                .family         = NFPROTO_IPV4,
+                .match          = socket_mt_v0,
+                .hooks          = 1 << NF_INET_PRE_ROUTING,
+                .me             = THIS_MODULE,
+        },
+        {
+                .name           = "socket",
+                .revision       = 1,
+                .family         = NFPROTO_IPV4,
+                .match          = socket_mt_v1,
+                .matchsize      = sizeof(struct xt_socket_mtinfo1),
+                .hooks          = 1 << NF_INET_PRE_ROUTING,
+                .me             = THIS_MODULE,
+        },
 };
 
 static int __init socket_mt_init(void)
 {
         nf_defrag_ipv4_enable();
-        return xt_register_match(&socket_mt_reg);
+        return xt_register_matches(socket_mt_reg, ARRAY_SIZE(socket_mt_reg));
 }
 
 static void __exit socket_mt_exit(void)
 {
-        xt_unregister_match(&socket_mt_reg);
+        xt_unregister_matches(socket_mt_reg, ARRAY_SIZE(socket_mt_reg));
 }
 
 module_init(socket_mt_init);
diff --git a/net/netlabel/netlabel_cipso_v4.c b/net/netlabel/netlabel_cipso_v4.c
index bf1ab1a6790d..e639298bc9c8 100644
--- a/net/netlabel/netlabel_cipso_v4.c
+++ b/net/netlabel/netlabel_cipso_v4.c
@@ -785,18 +785,6 @@ static struct genl_ops netlbl_cipsov4_ops[] = {
  */
 int __init netlbl_cipsov4_genl_init(void)
 {
-        int ret_val, i;
-
-        ret_val = genl_register_family(&netlbl_cipsov4_gnl_family);
-        if (ret_val != 0)
-                return ret_val;
-
-        for (i = 0; i < ARRAY_SIZE(netlbl_cipsov4_ops); i++) {
-                ret_val = genl_register_ops(&netlbl_cipsov4_gnl_family,
-                                &netlbl_cipsov4_ops[i]);
-                if (ret_val != 0)
-                        return ret_val;
-        }
-
-        return 0;
+        return genl_register_family_with_ops(&netlbl_cipsov4_gnl_family,
+                netlbl_cipsov4_ops, ARRAY_SIZE(netlbl_cipsov4_ops));
 }
diff --git a/net/netlabel/netlabel_mgmt.c b/net/netlabel/netlabel_mgmt.c
index 1821c5d50fb8..8203623e65ad 100644
--- a/net/netlabel/netlabel_mgmt.c
+++ b/net/netlabel/netlabel_mgmt.c
@@ -779,18 +779,6 @@ static struct genl_ops netlbl_mgmt_genl_ops[] = {
  */
 int __init netlbl_mgmt_genl_init(void)
 {
-        int ret_val, i;
-
-        ret_val = genl_register_family(&netlbl_mgmt_gnl_family);
-        if (ret_val != 0)
-                return ret_val;
-
-        for (i = 0; i < ARRAY_SIZE(netlbl_mgmt_genl_ops); i++) {
-                ret_val = genl_register_ops(&netlbl_mgmt_gnl_family,
-                                &netlbl_mgmt_genl_ops[i]);
-                if (ret_val != 0)
-                        return ret_val;
-        }
-
-        return 0;
+        return genl_register_family_with_ops(&netlbl_mgmt_gnl_family,
+                netlbl_mgmt_genl_ops, ARRAY_SIZE(netlbl_mgmt_genl_ops));
 }
diff --git a/net/netlabel/netlabel_unlabeled.c b/net/netlabel/netlabel_unlabeled.c
index f3c5c68c6848..fb357f010189 100644
--- a/net/netlabel/netlabel_unlabeled.c
+++ b/net/netlabel/netlabel_unlabeled.c
@@ -1478,20 +1478,8 @@ static struct genl_ops netlbl_unlabel_genl_ops[] = {
  */
 int __init netlbl_unlabel_genl_init(void)
 {
-        int ret_val, i;
-
-        ret_val = genl_register_family(&netlbl_unlabel_gnl_family);
-        if (ret_val != 0)
-                return ret_val;
-
-        for (i = 0; i < ARRAY_SIZE(netlbl_unlabel_genl_ops); i++) {
-                ret_val = genl_register_ops(&netlbl_unlabel_gnl_family,
-                                &netlbl_unlabel_genl_ops[i]);
-                if (ret_val != 0)
-                        return ret_val;
-        }
-
-        return 0;
+        return genl_register_family_with_ops(&netlbl_unlabel_gnl_family,
+                netlbl_unlabel_genl_ops, ARRAY_SIZE(netlbl_unlabel_genl_ops));
 }
 
 /*
diff --git a/net/netlink/genetlink.c b/net/netlink/genetlink.c
index 1d3dd30099df..eed4c6a8afc0 100644
--- a/net/netlink/genetlink.c
+++ b/net/netlink/genetlink.c
@@ -384,6 +384,52 @@ errout:
 }
 
 /**
+ * genl_register_family_with_ops - register a generic netlink family
+ * @family: generic netlink family
+ * @ops: operations to be registered
+ * @n_ops: number of elements to register
+ *
+ * Registers the specified family and operations from the specified table.
+ * Only one family may be registered with the same family name or identifier.
+ *
+ * The family id may equal GENL_ID_GENERATE causing an unique id to
+ * be automatically generated and assigned.
+ *
+ * Either a doit or dumpit callback must be specified for every registered
+ * operation or the function will fail. Only one operation structure per
+ * command identifier may be registered.
+ *
+ * See include/net/genetlink.h for more documenation on the operations
+ * structure.
+ *
+ * This is equivalent to calling genl_register_family() followed by
+ * genl_register_ops() for every operation entry in the table taking
+ * care to unregister the family on error path.
+ *
+ * Return 0 on success or a negative error code.
+ */
+int genl_register_family_with_ops(struct genl_family *family,
+        struct genl_ops *ops, size_t n_ops)
+{
+        int err, i;
+
+        err = genl_register_family(family);
+        if (err)
+                return err;
+
+        for (i = 0; i < n_ops; ++i, ++ops) {
+                err = genl_register_ops(family, ops);
+                if (err)
+                        goto err_out;
+        }
+        return 0;
+err_out:
+        genl_unregister_family(family);
+        return err;
+}
+EXPORT_SYMBOL(genl_register_family_with_ops);
+
+/**
  * genl_unregister_family - unregister generic netlink family
  * @family: generic netlink family
  *
diff --git a/net/packet/af_packet.c b/net/packet/af_packet.c
index f546e81acc45..4f76e5552d8e 100644
--- a/net/packet/af_packet.c
+++ b/net/packet/af_packet.c
@@ -39,6 +39,7 @@
  *                                      will simply extend the hardware address
  *                                      byte arrays at the end of sockaddr_ll
  *                                      and packet_mreq.
+ *              Johann Baudy    :       Added TX RING.
  *
  *              This program is free software; you can redistribute it and/or
  *              modify it under the terms of the GNU General Public License
@@ -157,7 +158,25 @@ struct packet_mreq_max
 };
 
 #ifdef CONFIG_PACKET_MMAP
-static int packet_set_ring(struct sock *sk, struct tpacket_req *req, int closing);
+static int packet_set_ring(struct sock *sk, struct tpacket_req *req,
+                int closing, int tx_ring);
+
+struct packet_ring_buffer {
+        char *                  *pg_vec;
+        unsigned int            head;
+        unsigned int            frames_per_block;
+        unsigned int            frame_size;
+        unsigned int            frame_max;
+
+        unsigned int            pg_vec_order;
+        unsigned int            pg_vec_pages;
+        unsigned int            pg_vec_len;
+
+        atomic_t                pending;
+};
+
+struct packet_sock;
+static int tpacket_snd(struct packet_sock *po, struct msghdr *msg);
 #endif
 
 static void packet_flush_mclist(struct sock *sk);
@@ -167,11 +186,8 @@ struct packet_sock {
         struct sock             sk;
         struct tpacket_stats    stats;
 #ifdef CONFIG_PACKET_MMAP
-        char *                  *pg_vec;
-        unsigned int            head;
-        unsigned int            frames_per_block;
-        unsigned int            frame_size;
-        unsigned int            frame_max;
+        struct packet_ring_buffer       rx_ring;
+        struct packet_ring_buffer       tx_ring;
         int                     copy_thresh;
 #endif
         struct packet_type      prot_hook;
@@ -185,12 +201,10 @@ struct packet_sock {
         struct packet_mclist    *mclist;
 #ifdef CONFIG_PACKET_MMAP
         atomic_t                mapped;
-        unsigned int            pg_vec_order;
-        unsigned int            pg_vec_pages;
-        unsigned int            pg_vec_len;
         enum tpacket_versions   tp_version;
         unsigned int            tp_hdrlen;
         unsigned int            tp_reserve;
+        unsigned int            tp_loss:1;
 #endif
 };
 
@@ -206,36 +220,33 @@ struct packet_skb_cb {
 
 #ifdef CONFIG_PACKET_MMAP
 
-static void *packet_lookup_frame(struct packet_sock *po, unsigned int position,
-                                 int status)
+static void __packet_set_status(struct packet_sock *po, void *frame, int status)
 {
-        unsigned int pg_vec_pos, frame_offset;
         union {
                 struct tpacket_hdr *h1;
                 struct tpacket2_hdr *h2;
                 void *raw;
         } h;
 
-        pg_vec_pos = position / po->frames_per_block;
-        frame_offset = position % po->frames_per_block;
-
-        h.raw = po->pg_vec[pg_vec_pos] + (frame_offset * po->frame_size);
+        h.raw = frame;
         switch (po->tp_version) {
         case TPACKET_V1:
-                if (status != (h.h1->tp_status ? TP_STATUS_USER :
-                                                TP_STATUS_KERNEL))
-                        return NULL;
+                h.h1->tp_status = status;
+                flush_dcache_page(virt_to_page(&h.h1->tp_status));
                 break;
         case TPACKET_V2:
-                if (status != (h.h2->tp_status ? TP_STATUS_USER :
-                                                TP_STATUS_KERNEL))
-                        return NULL;
+                h.h2->tp_status = status;
+                flush_dcache_page(virt_to_page(&h.h2->tp_status));
                 break;
+        default:
+                printk(KERN_ERR "TPACKET version not supported\n");
+                BUG();
         }
-        return h.raw;
+
+        smp_wmb();
 }
 
-static void __packet_set_status(struct packet_sock *po, void *frame, int status)
+static int __packet_get_status(struct packet_sock *po, void *frame)
 {
         union {
                 struct tpacket_hdr *h1;
@@ -243,16 +254,66 @@ static void __packet_set_status(struct packet_sock *po, void *frame, int status)
                 void *raw;
         } h;
 
+        smp_rmb();
+
         h.raw = frame;
         switch (po->tp_version) {
         case TPACKET_V1:
-                h.h1->tp_status = status;
-                break;
+                flush_dcache_page(virt_to_page(&h.h1->tp_status));
+                return h.h1->tp_status;
         case TPACKET_V2:
-                h.h2->tp_status = status;
-                break;
+                flush_dcache_page(virt_to_page(&h.h2->tp_status));
+                return h.h2->tp_status;
+        default:
+                printk(KERN_ERR "TPACKET version not supported\n");
+                BUG();
+                return 0;
         }
 }
+
+static void *packet_lookup_frame(struct packet_sock *po,
+                struct packet_ring_buffer *rb,
+                unsigned int position,
+                int status)
+{
+        unsigned int pg_vec_pos, frame_offset;
+        union {
+                struct tpacket_hdr *h1;
+                struct tpacket2_hdr *h2;
+                void *raw;
+        } h;
+
+        pg_vec_pos = position / rb->frames_per_block;
+        frame_offset = position % rb->frames_per_block;
+
+        h.raw = rb->pg_vec[pg_vec_pos] + (frame_offset * rb->frame_size);
+
+        if (status != __packet_get_status(po, h.raw))
+                return NULL;
+
+        return h.raw;
+}
+
+static inline void *packet_current_frame(struct packet_sock *po,
+                struct packet_ring_buffer *rb,
+                int status)
+{
+        return packet_lookup_frame(po, rb, rb->head, status);
+}
+
+static inline void *packet_previous_frame(struct packet_sock *po,
+                struct packet_ring_buffer *rb,
+                int status)
+{
+        unsigned int previous = rb->head ? rb->head - 1 : rb->frame_max;
+        return packet_lookup_frame(po, rb, previous, status);
+}
+
+static inline void packet_increment_head(struct packet_ring_buffer *buff)
+{
+        buff->head = buff->head != buff->frame_max ? buff->head+1 : 0;
+}
+
 #endif
 
 static inline struct packet_sock *pkt_sk(struct sock *sk)
@@ -311,8 +372,7 @@ static int packet_rcv_spkt(struct sk_buff *skb, struct net_device *dev,  struct
                 goto oom;
 
         /* drop any routing info */
-        dst_release(skb->dst);
-        skb->dst = NULL;
+        skb_dst_drop(skb);
 
         /* drop conntrack reference */
         nf_reset(skb);
@@ -560,8 +620,7 @@ static int packet_rcv(struct sk_buff *skb, struct net_device *dev, struct packet
 
         skb_set_owner_r(skb, sk);
         skb->dev = NULL;
-        dst_release(skb->dst);
-        skb->dst = NULL;
+        skb_dst_drop(skb);
 
         /* drop conntrack reference */
         nf_reset(skb);
@@ -648,7 +707,7 @@ static int tpacket_rcv(struct sk_buff *skb, struct net_device *dev, struct packe
                 macoff = netoff - maclen;
         }
 
-        if (macoff + snaplen > po->frame_size) {
+        if (macoff + snaplen > po->rx_ring.frame_size) {
                 if (po->copy_thresh &&
                     atomic_read(&sk->sk_rmem_alloc) + skb->truesize <
                     (unsigned)sk->sk_rcvbuf) {
@@ -661,16 +720,16 @@ static int tpacket_rcv(struct sk_buff *skb, struct net_device *dev, struct packe
                         if (copy_skb)
                                 skb_set_owner_r(copy_skb, sk);
                 }
-                snaplen = po->frame_size - macoff;
+                snaplen = po->rx_ring.frame_size - macoff;
                 if ((int)snaplen < 0)
                         snaplen = 0;
         }
 
         spin_lock(&sk->sk_receive_queue.lock);
-        h.raw = packet_lookup_frame(po, po->head, TP_STATUS_KERNEL);
+        h.raw = packet_current_frame(po, &po->rx_ring, TP_STATUS_KERNEL);
         if (!h.raw)
                 goto ring_is_full;
-        po->head = po->head != po->frame_max ? po->head+1 : 0;
+        packet_increment_head(&po->rx_ring);
         po->stats.tp_packets++;
         if (copy_skb) {
                 status |= TP_STATUS_COPY;
@@ -727,7 +786,6 @@ static int tpacket_rcv(struct sk_buff *skb, struct net_device *dev, struct packe
 
         __packet_set_status(po, h.raw, status);
         smp_mb();
-
         {
                 struct page *p_start, *p_end;
                 u8 *h_end = h.raw + macoff + snaplen - 1;
@@ -760,10 +818,249 @@ ring_is_full:
         goto drop_n_restore;
 }
 
-#endif
+static void tpacket_destruct_skb(struct sk_buff *skb)
+{
+        struct packet_sock *po = pkt_sk(skb->sk);
+        void * ph;
 
+        BUG_ON(skb == NULL);
 
-static int packet_sendmsg(struct kiocb *iocb, struct socket *sock,
+        if (likely(po->tx_ring.pg_vec)) {
+                ph = skb_shinfo(skb)->destructor_arg;
+                BUG_ON(__packet_get_status(po, ph) != TP_STATUS_SENDING);
+                BUG_ON(atomic_read(&po->tx_ring.pending) == 0);
+                atomic_dec(&po->tx_ring.pending);
+                __packet_set_status(po, ph, TP_STATUS_AVAILABLE);
+        }
+
+        sock_wfree(skb);
+}
+
+static int tpacket_fill_skb(struct packet_sock *po, struct sk_buff * skb,
+                void * frame, struct net_device *dev, int size_max,
+                __be16 proto, unsigned char * addr)
+{
+        union {
+                struct tpacket_hdr *h1;
+                struct tpacket2_hdr *h2;
+                void *raw;
+        } ph;
+        int to_write, offset, len, tp_len, nr_frags, len_max;
+        struct socket *sock = po->sk.sk_socket;
+        struct page *page;
+        void *data;
+        int err;
+
+        ph.raw = frame;
+
+        skb->protocol = proto;
+        skb->dev = dev;
+        skb->priority = po->sk.sk_priority;
+        skb_shinfo(skb)->destructor_arg = ph.raw;
+
+        switch (po->tp_version) {
+        case TPACKET_V2:
+                tp_len = ph.h2->tp_len;
+                break;
+        default:
+                tp_len = ph.h1->tp_len;
+                break;
+        }
+        if (unlikely(tp_len > size_max)) {
+                printk(KERN_ERR "packet size is too long (%d > %d)\n",
+                                tp_len, size_max);
+                return -EMSGSIZE;
+        }
+
+        skb_reserve(skb, LL_RESERVED_SPACE(dev));
+        skb_reset_network_header(skb);
+
+        data = ph.raw + po->tp_hdrlen - sizeof(struct sockaddr_ll);
+        to_write = tp_len;
+
+        if (sock->type == SOCK_DGRAM) {
+                err = dev_hard_header(skb, dev, ntohs(proto), addr,
+                                NULL, tp_len);
+                if (unlikely(err < 0))
+                        return -EINVAL;
+        } else if (dev->hard_header_len ) {
+                /* net device doesn't like empty head */
+                if (unlikely(tp_len <= dev->hard_header_len)) {
+                        printk(KERN_ERR "packet size is too short "
+                                        "(%d < %d)\n", tp_len,
+                                        dev->hard_header_len);
+                        return -EINVAL;
+                }
+
+                skb_push(skb, dev->hard_header_len);
+                err = skb_store_bits(skb, 0, data,
+                                dev->hard_header_len);
+                if (unlikely(err))
+                        return err;
+
+                data += dev->hard_header_len;
+                to_write -= dev->hard_header_len;
+        }
+
+        err = -EFAULT;
+        page = virt_to_page(data);
+        offset = offset_in_page(data);
+        len_max = PAGE_SIZE - offset;
+        len = ((to_write > len_max) ? len_max : to_write);
+
+        skb->data_len = to_write;
+        skb->len += to_write;
+        skb->truesize += to_write;
+        atomic_add(to_write, &po->sk.sk_wmem_alloc);
+
+        while (likely(to_write)) {
+                nr_frags = skb_shinfo(skb)->nr_frags;
+
+                if (unlikely(nr_frags >= MAX_SKB_FRAGS)) {
+                        printk(KERN_ERR "Packet exceed the number "
+                                        "of skb frags(%lu)\n",
+                                        MAX_SKB_FRAGS);
+                        return -EFAULT;
+                }
+
+                flush_dcache_page(page);
+                get_page(page);
+                skb_fill_page_desc(skb,
+                                nr_frags,
+                                page++, offset, len);
+                to_write -= len;
+                offset = 0;
+                len_max = PAGE_SIZE;
+                len = ((to_write > len_max) ? len_max : to_write);
+        }
+
+        return tp_len;
+}
+
+static int tpacket_snd(struct packet_sock *po, struct msghdr *msg)
+{
+        struct socket *sock;
+        struct sk_buff *skb;
+        struct net_device *dev;
+        __be16 proto;
+        int ifindex, err, reserve = 0;
+        void * ph;
+        struct sockaddr_ll *saddr=(struct sockaddr_ll *)msg->msg_name;
+        int tp_len, size_max;
+        unsigned char *addr;
+        int len_sum = 0;
+        int status = 0;
+
+        sock = po->sk.sk_socket;
+
+        mutex_lock(&po->pg_vec_lock);
+
+        err = -EBUSY;
+        if (saddr == NULL) {
+                ifindex = po->ifindex;
+                proto   = po->num;
+                addr    = NULL;
+        } else {
+                err = -EINVAL;
+                if (msg->msg_namelen < sizeof(struct sockaddr_ll))
+                        goto out;
+                if (msg->msg_namelen < (saddr->sll_halen
+                                        + offsetof(struct sockaddr_ll,
+                                                sll_addr)))
+                        goto out;
+                ifindex = saddr->sll_ifindex;
+                proto   = saddr->sll_protocol;
+                addr    = saddr->sll_addr;
+        }
+
+        dev = dev_get_by_index(sock_net(&po->sk), ifindex);
+        err = -ENXIO;
+        if (unlikely(dev == NULL))
+                goto out;
+
+        reserve = dev->hard_header_len;
+
+        err = -ENETDOWN;
+        if (unlikely(!(dev->flags & IFF_UP)))
+                goto out_put;
+
+        size_max = po->tx_ring.frame_size
+                - sizeof(struct skb_shared_info)
+                - po->tp_hdrlen
+                - LL_ALLOCATED_SPACE(dev)
+                - sizeof(struct sockaddr_ll);
+
+        if (size_max > dev->mtu + reserve)
+                size_max = dev->mtu + reserve;
+
+        do {
+                ph = packet_current_frame(po, &po->tx_ring,
+                                TP_STATUS_SEND_REQUEST);
+
+                if (unlikely(ph == NULL)) {
+                        schedule();
+                        continue;
+                }
+
+                status = TP_STATUS_SEND_REQUEST;
+                skb = sock_alloc_send_skb(&po->sk,
+                                LL_ALLOCATED_SPACE(dev)
+                                + sizeof(struct sockaddr_ll),
+                                0, &err);
+
+                if (unlikely(skb == NULL))
+                        goto out_status;
+
+                tp_len = tpacket_fill_skb(po, skb, ph, dev, size_max, proto,
+                                addr);
+
+                if (unlikely(tp_len < 0)) {
+                        if (po->tp_loss) {
+                                __packet_set_status(po, ph,
+                                                TP_STATUS_AVAILABLE);
+                                packet_increment_head(&po->tx_ring);
+                                kfree_skb(skb);
+                                continue;
+                        } else {
+                                status = TP_STATUS_WRONG_FORMAT;
+                                err = tp_len;
+                                goto out_status;
+                        }
+                }
+
+                skb->destructor = tpacket_destruct_skb;
+                __packet_set_status(po, ph, TP_STATUS_SENDING);
+                atomic_inc(&po->tx_ring.pending);
+
+                status = TP_STATUS_SEND_REQUEST;
+                err = dev_queue_xmit(skb);
+                if (unlikely(err > 0 && (err = net_xmit_errno(err)) != 0))
+                        goto out_xmit;
+                packet_increment_head(&po->tx_ring);
+                len_sum += tp_len;
+        }
+        while (likely((ph != NULL) || ((!(msg->msg_flags & MSG_DONTWAIT))
+                                        && (atomic_read(&po->tx_ring.pending))))
+              );
+
+        err = len_sum;
+        goto out_put;
+
+out_xmit:
+        skb->destructor = sock_wfree;
+        atomic_dec(&po->tx_ring.pending);
+out_status:
+        __packet_set_status(po, ph, status);
+        kfree_skb(skb);
+out_put:
+        dev_put(dev);
+out:
+        mutex_unlock(&po->pg_vec_lock);
+        return err;
+}
+#endif
+
+static int packet_snd(struct socket *sock,
                           struct msghdr *msg, size_t len)
 {
         struct sock *sk = sock->sk;
@@ -854,6 +1151,19 @@ out:
         return err;
 }
 
+static int packet_sendmsg(struct kiocb *iocb, struct socket *sock,
+                struct msghdr *msg, size_t len)
+{
+#ifdef CONFIG_PACKET_MMAP
+        struct sock *sk = sock->sk;
+        struct packet_sock *po = pkt_sk(sk);
+        if (po->tx_ring.pg_vec)
+                return tpacket_snd(po, msg);
+        else
+#endif
+                return packet_snd(sock, msg, len);
+}
+
 /*
  *      Close a PACKET socket. This is fairly simple. We immediately go
  *      to 'closed' state and remove our protocol entry in the device list.
@@ -864,6 +1174,9 @@ static int packet_release(struct socket *sock)
         struct sock *sk = sock->sk;
         struct packet_sock *po;
         struct net *net;
+#ifdef CONFIG_PACKET_MMAP
+        struct tpacket_req req;
+#endif
 
         if (!sk)
                 return 0;
@@ -893,11 +1206,13 @@ static int packet_release(struct socket *sock)
         packet_flush_mclist(sk);
 
 #ifdef CONFIG_PACKET_MMAP
-        if (po->pg_vec) {
-                struct tpacket_req req;
-                memset(&req, 0, sizeof(req));
-                packet_set_ring(sk, &req, 1);
-        }
+        memset(&req, 0, sizeof(req));
+
+        if (po->rx_ring.pg_vec)
+                packet_set_ring(sk, &req, 1, 0);
+
+        if (po->tx_ring.pg_vec)
+                packet_set_ring(sk, &req, 1, 1);
 #endif
 
         /*
@@ -1253,9 +1568,9 @@ static int packet_dev_mc(struct net_device *dev, struct packet_mclist *i,
         switch (i->type) {
         case PACKET_MR_MULTICAST:
                 if (what > 0)
-                        dev_mc_add(dev, i->addr, i->alen, 0);
+                        return dev_mc_add(dev, i->addr, i->alen, 0);
                 else
-                        dev_mc_delete(dev, i->addr, i->alen, 0);
+                        return dev_mc_delete(dev, i->addr, i->alen, 0);
                 break;
         case PACKET_MR_PROMISC:
                 return dev_set_promiscuity(dev, what);
@@ -1263,6 +1578,12 @@ static int packet_dev_mc(struct net_device *dev, struct packet_mclist *i,
         case PACKET_MR_ALLMULTI:
                 return dev_set_allmulti(dev, what);
                 break;
+        case PACKET_MR_UNICAST:
+                if (what > 0)
+                        return dev_unicast_add(dev, i->addr);
+                else
+                        return dev_unicast_delete(dev, i->addr);
+                break;
         default:;
         }
         return 0;
@@ -1391,7 +1712,7 @@ packet_setsockopt(struct socket *sock, int level, int optname, char __user *optv
         if (level != SOL_PACKET)
                 return -ENOPROTOOPT;
 
-        switch(optname) {
+        switch (optname) {
         case PACKET_ADD_MEMBERSHIP:
         case PACKET_DROP_MEMBERSHIP:
         {
@@ -1415,6 +1736,7 @@ packet_setsockopt(struct socket *sock, int level, int optname, char __user *optv
 
 #ifdef CONFIG_PACKET_MMAP
         case PACKET_RX_RING:
+        case PACKET_TX_RING:
         {
                 struct tpacket_req req;
 
@@ -1422,7 +1744,7 @@ packet_setsockopt(struct socket *sock, int level, int optname, char __user *optv
                         return -EINVAL;
                 if (copy_from_user(&req,optval,sizeof(req)))
                         return -EFAULT;
-                return packet_set_ring(sk, &req, 0);
+                return packet_set_ring(sk, &req, 0, optname == PACKET_TX_RING);
         }
         case PACKET_COPY_THRESH:
         {
@@ -1442,7 +1764,7 @@ packet_setsockopt(struct socket *sock, int level, int optname, char __user *optv
 
                 if (optlen != sizeof(val))
                         return -EINVAL;
-                if (po->pg_vec)
+                if (po->rx_ring.pg_vec || po->tx_ring.pg_vec)
                         return -EBUSY;
                 if (copy_from_user(&val, optval, sizeof(val)))
                         return -EFAULT;
@@ -1461,13 +1783,26 @@ packet_setsockopt(struct socket *sock, int level, int optname, char __user *optv
 
                 if (optlen != sizeof(val))
                         return -EINVAL;
-                if (po->pg_vec)
+                if (po->rx_ring.pg_vec || po->tx_ring.pg_vec)
                         return -EBUSY;
                 if (copy_from_user(&val, optval, sizeof(val)))
                         return -EFAULT;
                 po->tp_reserve = val;
                 return 0;
         }
+        case PACKET_LOSS:
+        {
+                unsigned int val;
+
+                if (optlen != sizeof(val))
+                        return -EINVAL;
+                if (po->rx_ring.pg_vec || po->tx_ring.pg_vec)
+                        return -EBUSY;
+                if (copy_from_user(&val, optval, sizeof(val)))
+                        return -EFAULT;
+                po->tp_loss = !!val;
+                return 0;
+        }
 #endif
         case PACKET_AUXDATA:
         {
@@ -1517,7 +1852,7 @@ static int packet_getsockopt(struct socket *sock, int level, int optname,
         if (len < 0)
                 return -EINVAL;
 
-        switch(optname) {
+        switch (optname) {
         case PACKET_STATISTICS:
                 if (len > sizeof(struct tpacket_stats))
                         len = sizeof(struct tpacket_stats);
@@ -1573,6 +1908,12 @@ static int packet_getsockopt(struct socket *sock, int level, int optname,
                 val = po->tp_reserve;
                 data = &val;
                 break;
+        case PACKET_LOSS:
+                if (len > sizeof(unsigned int))
+                        len = sizeof(unsigned int);
+                val = po->tp_loss;
+                data = &val;
+                break;
 #endif
         default:
                 return -ENOPROTOOPT;
@@ -1643,7 +1984,7 @@ static int packet_ioctl(struct socket *sock, unsigned int cmd,
 {
         struct sock *sk = sock->sk;
 
-        switch(cmd) {
+        switch (cmd) {
                 case SIOCOUTQ:
                 {
                         int amount = atomic_read(&sk->sk_wmem_alloc);
@@ -1705,13 +2046,17 @@ static unsigned int packet_poll(struct file * file, struct socket *sock,
         unsigned int mask = datagram_poll(file, sock, wait);
 
         spin_lock_bh(&sk->sk_receive_queue.lock);
-        if (po->pg_vec) {
-                unsigned last = po->head ? po->head-1 : po->frame_max;
-
-                if (packet_lookup_frame(po, last, TP_STATUS_USER))
+        if (po->rx_ring.pg_vec) {
+                if (!packet_previous_frame(po, &po->rx_ring, TP_STATUS_KERNEL))
                         mask |= POLLIN | POLLRDNORM;
         }
         spin_unlock_bh(&sk->sk_receive_queue.lock);
+        spin_lock_bh(&sk->sk_write_queue.lock);
+        if (po->tx_ring.pg_vec) {
+                if (packet_current_frame(po, &po->tx_ring, TP_STATUS_AVAILABLE))
+                        mask |= POLLOUT | POLLWRNORM;
+        }
+        spin_unlock_bh(&sk->sk_write_queue.lock);
         return mask;
 }
 
@@ -1788,21 +2133,33 @@ out_free_pgvec:
         goto out;
 }
 
-static int packet_set_ring(struct sock *sk, struct tpacket_req *req, int closing)
+static int packet_set_ring(struct sock *sk, struct tpacket_req *req,
+                int closing, int tx_ring)
 {
         char **pg_vec = NULL;
         struct packet_sock *po = pkt_sk(sk);
         int was_running, order = 0;
+        struct packet_ring_buffer *rb;
+        struct sk_buff_head *rb_queue;
         __be16 num;
-        int err = 0;
+        int err;
 
-        if (req->tp_block_nr) {
-                int i;
+        rb = tx_ring ? &po->tx_ring : &po->rx_ring;
+        rb_queue = tx_ring ? &sk->sk_write_queue : &sk->sk_receive_queue;
 
-                /* Sanity tests and some calculations */
+        err = -EBUSY;
+        if (!closing) {
+                if (atomic_read(&po->mapped))
+                        goto out;
+                if (atomic_read(&rb->pending))
+                        goto out;
+        }
 
-                if (unlikely(po->pg_vec))
-                        return -EBUSY;
+        if (req->tp_block_nr) {
+                /* Sanity tests and some calculations */
+                err = -EBUSY;
+                if (unlikely(rb->pg_vec))
+                        goto out;
 
                 switch (po->tp_version) {
                 case TPACKET_V1:
@@ -1813,42 +2170,35 @@ static int packet_set_ring(struct sock *sk, struct tpacket_req *req, int closing
                         break;
                 }
 
+                err = -EINVAL;
                 if (unlikely((int)req->tp_block_size <= 0))
-                        return -EINVAL;
+                        goto out;
                 if (unlikely(req->tp_block_size & (PAGE_SIZE - 1)))
-                        return -EINVAL;
+                        goto out;
                 if (unlikely(req->tp_frame_size < po->tp_hdrlen +
-                                                  po->tp_reserve))
-                        return -EINVAL;
+                                        po->tp_reserve))
+                        goto out;
                 if (unlikely(req->tp_frame_size & (TPACKET_ALIGNMENT - 1)))
-                        return -EINVAL;
+                        goto out;
 
-                po->frames_per_block = req->tp_block_size/req->tp_frame_size;
-                if (unlikely(po->frames_per_block <= 0))
-                        return -EINVAL;
-                if (unlikely((po->frames_per_block * req->tp_block_nr) !=
-                             req->tp_frame_nr))
-                        return -EINVAL;
+                rb->frames_per_block = req->tp_block_size/req->tp_frame_size;
+                if (unlikely(rb->frames_per_block <= 0))
+                        goto out;
+                if (unlikely((rb->frames_per_block * req->tp_block_nr) !=
+                                        req->tp_frame_nr))
+                        goto out;
 
                 err = -ENOMEM;
                 order = get_order(req->tp_block_size);
                 pg_vec = alloc_pg_vec(req, order);
                 if (unlikely(!pg_vec))
                         goto out;
-
-                for (i = 0; i < req->tp_block_nr; i++) {
-                        void *ptr = pg_vec[i];
-                        int k;
-
-                        for (k = 0; k < po->frames_per_block; k++) {
-                                __packet_set_status(po, ptr, TP_STATUS_KERNEL);
-                                ptr += req->tp_frame_size;
-                        }
-                }
-                /* Done */
-        } else {
+        }
+        /* Done */
+        else {
+                err = -EINVAL;
                 if (unlikely(req->tp_frame_nr))
-                        return -EINVAL;
+                        goto out;
         }
 
         lock_sock(sk);
@@ -1872,23 +2222,24 @@ static int packet_set_ring(struct sock *sk, struct tpacket_req *req, int closing
         if (closing || atomic_read(&po->mapped) == 0) {
                 err = 0;
 #define XC(a, b) ({ __typeof__ ((a)) __t; __t = (a); (a) = (b); __t; })
-
-                spin_lock_bh(&sk->sk_receive_queue.lock);
-                pg_vec = XC(po->pg_vec, pg_vec);
-                po->frame_max = (req->tp_frame_nr - 1);
-                po->head = 0;
-                po->frame_size = req->tp_frame_size;
-                spin_unlock_bh(&sk->sk_receive_queue.lock);
-
-                order = XC(po->pg_vec_order, order);
-                req->tp_block_nr = XC(po->pg_vec_len, req->tp_block_nr);
-
-                po->pg_vec_pages = req->tp_block_size/PAGE_SIZE;
-                po->prot_hook.func = po->pg_vec ? tpacket_rcv : packet_rcv;
-                skb_queue_purge(&sk->sk_receive_queue);
+                spin_lock_bh(&rb_queue->lock);
+                pg_vec = XC(rb->pg_vec, pg_vec);
+                rb->frame_max = (req->tp_frame_nr - 1);
+                rb->head = 0;
+                rb->frame_size = req->tp_frame_size;
+                spin_unlock_bh(&rb_queue->lock);
+
+                order = XC(rb->pg_vec_order, order);
+                req->tp_block_nr = XC(rb->pg_vec_len, req->tp_block_nr);
+
+                rb->pg_vec_pages = req->tp_block_size/PAGE_SIZE;
+                po->prot_hook.func = (po->rx_ring.pg_vec) ?
+                                                tpacket_rcv : packet_rcv;
+                skb_queue_purge(rb_queue);
 #undef XC
                 if (atomic_read(&po->mapped))
-                        printk(KERN_DEBUG "packet_mmap: vma is busy: %d\n", atomic_read(&po->mapped));
+                        printk(KERN_DEBUG "packet_mmap: vma is busy: %d\n",
+                                                atomic_read(&po->mapped));
         }
         mutex_unlock(&po->pg_vec_lock);
 
@@ -1909,11 +2260,13 @@ out:
         return err;
 }
 
-static int packet_mmap(struct file *file, struct socket *sock, struct vm_area_struct *vma)
+static int packet_mmap(struct file *file, struct socket *sock,
+                struct vm_area_struct *vma)
 {
         struct sock *sk = sock->sk;
         struct packet_sock *po = pkt_sk(sk);
-        unsigned long size;
+        unsigned long size, expected_size;
+        struct packet_ring_buffer *rb;
         unsigned long start;
         int err = -EINVAL;
         int i;
@@ -1921,26 +2274,43 @@ static int packet_mmap(struct file *file, struct socket *sock, struct vm_area_st
         if (vma->vm_pgoff)
                 return -EINVAL;
 
-        size = vma->vm_end - vma->vm_start;
-
         mutex_lock(&po->pg_vec_lock);
-        if (po->pg_vec == NULL)
+
+        expected_size = 0;
+        for (rb = &po->rx_ring; rb <= &po->tx_ring; rb++) {
+                if (rb->pg_vec) {
+                        expected_size += rb->pg_vec_len
+                                                * rb->pg_vec_pages
+                                                * PAGE_SIZE;
+                }
+        }
+
+        if (expected_size == 0)
                 goto out;
-        if (size != po->pg_vec_len*po->pg_vec_pages*PAGE_SIZE)
+
+        size = vma->vm_end - vma->vm_start;
+        if (size != expected_size)
                 goto out;
 
         start = vma->vm_start;
-        for (i = 0; i < po->pg_vec_len; i++) {
-                struct page *page = virt_to_page(po->pg_vec[i]);
-                int pg_num;
-
-                for (pg_num = 0; pg_num < po->pg_vec_pages; pg_num++, page++) {
-                        err = vm_insert_page(vma, start, page);
-                        if (unlikely(err))
-                                goto out;
-                        start += PAGE_SIZE;
+        for (rb = &po->rx_ring; rb <= &po->tx_ring; rb++) {
+                if (rb->pg_vec == NULL)
+                        continue;
+
+                for (i = 0; i < rb->pg_vec_len; i++) {
+                        struct page *page = virt_to_page(rb->pg_vec[i]);
+                        int pg_num;
+
+                        for (pg_num = 0; pg_num < rb->pg_vec_pages;
+                                        pg_num++,page++) {
+                                err = vm_insert_page(vma, start, page);
+                                if (unlikely(err))
+                                        goto out;
+                                start += PAGE_SIZE;
+                        }
                 }
         }
+
         atomic_inc(&po->mapped);
         vma->vm_ops = &packet_mmap_ops;
         err = 0;
diff --git a/net/phonet/pep-gprs.c b/net/phonet/pep-gprs.c
index 4aa888584d20..480839dfc560 100644
--- a/net/phonet/pep-gprs.c
+++ b/net/phonet/pep-gprs.c
@@ -115,10 +115,10 @@ static int gprs_recv(struct gprs_dev *gp, struct sk_buff *skb)
                 rskb->truesize += rskb->len;
 
                 /* Avoid nested fragments */
-                for (fs = skb_shinfo(skb)->frag_list; fs; fs = fs->next)
+                skb_walk_frags(skb, fs)
                         flen += fs->len;
                 skb->next = skb_shinfo(skb)->frag_list;
-                skb_shinfo(skb)->frag_list = NULL;
+                skb_frag_list_init(skb);
                 skb->len -= flen;
                 skb->data_len -= flen;
                 skb->truesize -= flen;
@@ -212,8 +212,9 @@ static int gprs_xmit(struct sk_buff *skb, struct net_device *dev)
                 dev->stats.tx_bytes += len;
         }
 
-        if (!pep_writeable(sk))
-                netif_stop_queue(dev);
+        netif_stop_queue(dev);
+        if (pep_writeable(sk))
+                netif_wake_queue(dev);
         return 0;
 }
 
diff --git a/net/phonet/pep.c b/net/phonet/pep.c
index 8ad2b5333881..eef833ea6d7b 100644
--- a/net/phonet/pep.c
+++ b/net/phonet/pep.c
@@ -940,10 +940,10 @@ int pep_write(struct sock *sk, struct sk_buff *skb)
         rskb->truesize += rskb->len;
 
         /* Avoid nested fragments */
-        for (fs = skb_shinfo(skb)->frag_list; fs; fs = fs->next)
+        skb_walk_frags(skb, fs)
                 flen += fs->len;
         skb->next = skb_shinfo(skb)->frag_list;
-        skb_shinfo(skb)->frag_list = NULL;
+        skb_frag_list_init(skb);
         skb->len -= flen;
         skb->data_len -= flen;
         skb->truesize -= flen;
diff --git a/net/rds/af_rds.c b/net/rds/af_rds.c
index 20cf16fc572f..b11e7e527864 100644
--- a/net/rds/af_rds.c
+++ b/net/rds/af_rds.c
@@ -35,7 +35,6 @@
 #include <linux/kernel.h>
 #include <linux/in.h>
 #include <linux/poll.h>
-#include <linux/version.h>
 #include <net/sock.h>
 
 #include "rds.h"
diff --git a/net/rds/connection.c b/net/rds/connection.c
index 273f064930a8..d14445c48304 100644
--- a/net/rds/connection.c
+++ b/net/rds/connection.c
@@ -148,14 +148,12 @@ static struct rds_connection *__rds_conn_create(__be32 laddr, __be32 faddr,
         if (conn)
                 goto out;
 
-        conn = kmem_cache_alloc(rds_conn_slab, gfp);
+        conn = kmem_cache_zalloc(rds_conn_slab, gfp);
         if (conn == NULL) {
                 conn = ERR_PTR(-ENOMEM);
                 goto out;
         }
 
-        memset(conn, 0, sizeof(*conn));
-
         INIT_HLIST_NODE(&conn->c_hash_node);
         conn->c_version = RDS_PROTOCOL_3_0;
         conn->c_laddr = laddr;
diff --git a/net/rds/ib.c b/net/rds/ib.c
index 4933b380985e..b9bcd32431e1 100644
--- a/net/rds/ib.c
+++ b/net/rds/ib.c
@@ -224,8 +224,8 @@ static int rds_ib_laddr_check(__be32 addr)
          * IB and iWARP capable NICs.
          */
         cm_id = rdma_create_id(NULL, NULL, RDMA_PS_TCP);
-        if (!cm_id)
-                return -EADDRNOTAVAIL;
+        if (IS_ERR(cm_id))
+                return PTR_ERR(cm_id);
 
         memset(&sin, 0, sizeof(sin));
         sin.sin_family = AF_INET;
diff --git a/net/rds/ib.h b/net/rds/ib.h
index 069206cae733..455ae73047fe 100644
--- a/net/rds/ib.h
+++ b/net/rds/ib.h
@@ -333,7 +333,7 @@ int rds_ib_xmit_rdma(struct rds_connection *conn, struct rds_rdma_op *op);
 void rds_ib_send_add_credits(struct rds_connection *conn, unsigned int credits);
 void rds_ib_advertise_credits(struct rds_connection *conn, unsigned int posted);
 int rds_ib_send_grab_credits(struct rds_ib_connection *ic, u32 wanted,
-                             u32 *adv_credits, int need_posted);
+                             u32 *adv_credits, int need_posted, int max_posted);
 
 /* ib_stats.c */
 DECLARE_PER_CPU(struct rds_ib_statistics, rds_ib_stats);
diff --git a/net/rds/ib_recv.c b/net/rds/ib_recv.c
index 36d931573ff4..5709bad28329 100644
--- a/net/rds/ib_recv.c
+++ b/net/rds/ib_recv.c
@@ -524,7 +524,7 @@ void rds_ib_attempt_ack(struct rds_ib_connection *ic)
         }
 
         /* Can we get a send credit? */
-        if (!rds_ib_send_grab_credits(ic, 1, &adv_credits, 0)) {
+        if (!rds_ib_send_grab_credits(ic, 1, &adv_credits, 0, RDS_MAX_ADV_CREDIT)) {
                 rds_ib_stats_inc(s_ib_tx_throttle);
                 clear_bit(IB_ACK_IN_FLIGHT, &ic->i_ack_flags);
                 return;
diff --git a/net/rds/ib_ring.c b/net/rds/ib_ring.c
index 99a6ccae964c..ff97e8eda858 100644
--- a/net/rds/ib_ring.c
+++ b/net/rds/ib_ring.c
@@ -137,7 +137,7 @@ int rds_ib_ring_empty(struct rds_ib_work_ring *ring)
 
 int rds_ib_ring_low(struct rds_ib_work_ring *ring)
 {
-        return __rds_ib_ring_used(ring) <= (ring->w_nr >> 2);
+        return __rds_ib_ring_used(ring) <= (ring->w_nr >> 1);
 }
 
 /*
diff --git a/net/rds/ib_send.c b/net/rds/ib_send.c
index cb6c52cb1c4c..23bf830db2d5 100644
--- a/net/rds/ib_send.c
+++ b/net/rds/ib_send.c
@@ -311,7 +311,7 @@ void rds_ib_send_cq_comp_handler(struct ib_cq *cq, void *context)
  * and using atomic_cmpxchg when updating the two counters.
  */
 int rds_ib_send_grab_credits(struct rds_ib_connection *ic,
-                             u32 wanted, u32 *adv_credits, int need_posted)
+                             u32 wanted, u32 *adv_credits, int need_posted, int max_posted)
 {
         unsigned int avail, posted, got = 0, advertise;
         long oldval, newval;
@@ -351,7 +351,7 @@ try_again:
          * available.
          */
         if (posted && (got || need_posted)) {
-                advertise = min_t(unsigned int, posted, RDS_MAX_ADV_CREDIT);
+                advertise = min_t(unsigned int, posted, max_posted);
                 newval -= IB_SET_POST_CREDITS(advertise);
         }
 
@@ -498,7 +498,7 @@ int rds_ib_xmit(struct rds_connection *conn, struct rds_message *rm,
 
         credit_alloc = work_alloc;
         if (ic->i_flowctl) {
-                credit_alloc = rds_ib_send_grab_credits(ic, work_alloc, &posted, 0);
+                credit_alloc = rds_ib_send_grab_credits(ic, work_alloc, &posted, 0, RDS_MAX_ADV_CREDIT);
                 adv_credits += posted;
                 if (credit_alloc < work_alloc) {
                         rds_ib_ring_unalloc(&ic->i_send_ring, work_alloc - credit_alloc);
@@ -506,7 +506,7 @@ int rds_ib_xmit(struct rds_connection *conn, struct rds_message *rm,
                         flow_controlled++;
                 }
                 if (work_alloc == 0) {
-                        rds_ib_ring_unalloc(&ic->i_send_ring, work_alloc);
+                        set_bit(RDS_LL_SEND_FULL, &conn->c_flags);
                         rds_ib_stats_inc(s_ib_tx_throttle);
                         ret = -ENOMEM;
                         goto out;
@@ -571,7 +571,7 @@ int rds_ib_xmit(struct rds_connection *conn, struct rds_message *rm,
                 /*
                  * Update adv_credits since we reset the ACK_REQUIRED bit.
                  */
-                rds_ib_send_grab_credits(ic, 0, &posted, 1);
+                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)
diff --git a/net/rds/info.c b/net/rds/info.c
index 1d885535214d..62aeef37aefe 100644
--- a/net/rds/info.c
+++ b/net/rds/info.c
@@ -188,10 +188,7 @@ int rds_info_getsockopt(struct socket *sock, int optname, char __user *optval,
                 ret = -ENOMEM;
                 goto out;
         }
-        down_read(&current->mm->mmap_sem);
-        ret = get_user_pages(current, current->mm, start, nr_pages, 1, 0,
-                             pages, NULL);
-        up_read(&current->mm->mmap_sem);
+        ret = get_user_pages_fast(start, nr_pages, 1, pages);
         if (ret != nr_pages) {
                 if (ret > 0)
                         nr_pages = ret;
diff --git a/net/rds/iw.c b/net/rds/iw.c
index b732efb5b634..d16e1cbc8e83 100644
--- a/net/rds/iw.c
+++ b/net/rds/iw.c
@@ -233,8 +233,8 @@ static int rds_iw_laddr_check(__be32 addr)
          * IB and iWARP capable NICs.
          */
         cm_id = rdma_create_id(NULL, NULL, RDMA_PS_TCP);
-        if (!cm_id)
-                return -EADDRNOTAVAIL;
+        if (IS_ERR(cm_id))
+                return PTR_ERR(cm_id);
 
         memset(&sin, 0, sizeof(sin));
         sin.sin_family = AF_INET;
diff --git a/net/rds/iw.h b/net/rds/iw.h
index b4fb27252895..0715dde323e7 100644
--- a/net/rds/iw.h
+++ b/net/rds/iw.h
@@ -361,7 +361,7 @@ int rds_iw_xmit_rdma(struct rds_connection *conn, struct rds_rdma_op *op);
 void rds_iw_send_add_credits(struct rds_connection *conn, unsigned int credits);
 void rds_iw_advertise_credits(struct rds_connection *conn, unsigned int posted);
 int rds_iw_send_grab_credits(struct rds_iw_connection *ic, u32 wanted,
-                             u32 *adv_credits, int need_posted);
+                             u32 *adv_credits, int need_posted, int max_posted);
 
 /* ib_stats.c */
 DECLARE_PER_CPU(struct rds_iw_statistics, rds_iw_stats);
diff --git a/net/rds/iw_recv.c b/net/rds/iw_recv.c
index fde470fa50d5..8683f5f66c4b 100644
--- a/net/rds/iw_recv.c
+++ b/net/rds/iw_recv.c
@@ -524,7 +524,7 @@ void rds_iw_attempt_ack(struct rds_iw_connection *ic)
         }
 
         /* Can we get a send credit? */
-        if (!rds_iw_send_grab_credits(ic, 1, &adv_credits, 0)) {
+        if (!rds_iw_send_grab_credits(ic, 1, &adv_credits, 0, RDS_MAX_ADV_CREDIT)) {
                 rds_iw_stats_inc(s_iw_tx_throttle);
                 clear_bit(IB_ACK_IN_FLIGHT, &ic->i_ack_flags);
                 return;
diff --git a/net/rds/iw_ring.c b/net/rds/iw_ring.c
index d422d4b5deef..da8e3b63f663 100644
--- a/net/rds/iw_ring.c
+++ b/net/rds/iw_ring.c
@@ -137,7 +137,7 @@ int rds_iw_ring_empty(struct rds_iw_work_ring *ring)
 
 int rds_iw_ring_low(struct rds_iw_work_ring *ring)
 {
-        return __rds_iw_ring_used(ring) <= (ring->w_nr >> 2);
+        return __rds_iw_ring_used(ring) <= (ring->w_nr >> 1);
 }
 
 
diff --git a/net/rds/iw_send.c b/net/rds/iw_send.c
index 22dd38ffd608..44a6a0551f28 100644
--- a/net/rds/iw_send.c
+++ b/net/rds/iw_send.c
@@ -347,7 +347,7 @@ void rds_iw_send_cq_comp_handler(struct ib_cq *cq, void *context)
  * and using atomic_cmpxchg when updating the two counters.
  */
 int rds_iw_send_grab_credits(struct rds_iw_connection *ic,
-                             u32 wanted, u32 *adv_credits, int need_posted)
+                             u32 wanted, u32 *adv_credits, int need_posted, int max_posted)
 {
         unsigned int avail, posted, got = 0, advertise;
         long oldval, newval;
@@ -387,7 +387,7 @@ try_again:
          * available.
          */
         if (posted && (got || need_posted)) {
-                advertise = min_t(unsigned int, posted, RDS_MAX_ADV_CREDIT);
+                advertise = min_t(unsigned int, posted, max_posted);
                 newval -= IB_SET_POST_CREDITS(advertise);
         }
 
@@ -541,7 +541,7 @@ int rds_iw_xmit(struct rds_connection *conn, struct rds_message *rm,
 
         credit_alloc = work_alloc;
         if (ic->i_flowctl) {
-                credit_alloc = rds_iw_send_grab_credits(ic, work_alloc, &posted, 0);
+                credit_alloc = rds_iw_send_grab_credits(ic, work_alloc, &posted, 0, RDS_MAX_ADV_CREDIT);
                 adv_credits += posted;
                 if (credit_alloc < work_alloc) {
                         rds_iw_ring_unalloc(&ic->i_send_ring, work_alloc - credit_alloc);
@@ -549,7 +549,7 @@ int rds_iw_xmit(struct rds_connection *conn, struct rds_message *rm,
                         flow_controlled++;
                 }
                 if (work_alloc == 0) {
-                        rds_iw_ring_unalloc(&ic->i_send_ring, work_alloc);
+                        set_bit(RDS_LL_SEND_FULL, &conn->c_flags);
                         rds_iw_stats_inc(s_iw_tx_throttle);
                         ret = -ENOMEM;
                         goto out;
@@ -614,7 +614,7 @@ int rds_iw_xmit(struct rds_connection *conn, struct rds_message *rm,
                 /*
                  * Update adv_credits since we reset the ACK_REQUIRED bit.
                  */
-                rds_iw_send_grab_credits(ic, 0, &posted, 1);
+                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)
diff --git a/net/rds/rdma.c b/net/rds/rdma.c
index eaeeb91e1119..8dc83d2caa58 100644
--- a/net/rds/rdma.c
+++ b/net/rds/rdma.c
@@ -150,12 +150,9 @@ static int rds_pin_pages(unsigned long user_addr, unsigned int nr_pages,
 {
         int ret;
 
-        down_read(&current->mm->mmap_sem);
-        ret = get_user_pages(current, current->mm, user_addr,
-                             nr_pages, write, 0, pages, NULL);
-        up_read(&current->mm->mmap_sem);
+        ret = get_user_pages_fast(user_addr, nr_pages, write, pages);
 
-        if (0 <= ret && (unsigned) ret < nr_pages) {
+        if (ret >= 0 && ret < nr_pages) {
                 while (ret--)
                         put_page(pages[ret]);
                 ret = -EFAULT;
diff --git a/net/rds/rdma_transport.c b/net/rds/rdma_transport.c
index 7b19024f9706..7d0f901c93d5 100644
--- a/net/rds/rdma_transport.c
+++ b/net/rds/rdma_transport.c
@@ -34,7 +34,7 @@
 
 #include "rdma_transport.h"
 
-static struct rdma_cm_id *rds_iw_listen_id;
+static struct rdma_cm_id *rds_rdma_listen_id;
 
 int rds_rdma_cm_event_handler(struct rdma_cm_id *cm_id,
                               struct rdma_cm_event *event)
@@ -161,7 +161,7 @@ static int __init rds_rdma_listen_init(void)
 
         rdsdebug("cm %p listening on port %u\n", cm_id, RDS_PORT);
 
-        rds_iw_listen_id = cm_id;
+        rds_rdma_listen_id = cm_id;
         cm_id = NULL;
 out:
         if (cm_id)
@@ -171,10 +171,10 @@ out:
 
 static void rds_rdma_listen_stop(void)
 {
-        if (rds_iw_listen_id) {
-                rdsdebug("cm %p\n", rds_iw_listen_id);
-                rdma_destroy_id(rds_iw_listen_id);
-                rds_iw_listen_id = NULL;
+        if (rds_rdma_listen_id) {
+                rdsdebug("cm %p\n", rds_rdma_listen_id);
+                rdma_destroy_id(rds_rdma_listen_id);
+                rds_rdma_listen_id = NULL;
         }
 }
 
diff --git a/net/rds/rds.h b/net/rds/rds.h
index 71794449ca4e..dbe111236783 100644
--- a/net/rds/rds.h
+++ b/net/rds/rds.h
@@ -132,7 +132,7 @@ struct rds_connection {
 #define RDS_FLAG_CONG_BITMAP    0x01
 #define RDS_FLAG_ACK_REQUIRED   0x02
 #define RDS_FLAG_RETRANSMITTED  0x04
-#define RDS_MAX_ADV_CREDIT      127
+#define RDS_MAX_ADV_CREDIT      255
 
 /*
  * Maximum space available for extension headers.
diff --git a/net/rds/send.c b/net/rds/send.c
index 104fe033203d..a4a7f428cd76 100644
--- a/net/rds/send.c
+++ b/net/rds/send.c
@@ -854,11 +854,6 @@ int rds_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
 
         rm->m_daddr = daddr;
 
-        /* Parse any control messages the user may have included. */
-        ret = rds_cmsg_send(rs, rm, msg, &allocated_mr);
-        if (ret)
-                goto out;
-
         /* rds_conn_create has a spinlock that runs with IRQ off.
          * Caching the conn in the socket helps a lot. */
         if (rs->rs_conn && rs->rs_conn->c_faddr == daddr)
@@ -874,6 +869,11 @@ int rds_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
                 rs->rs_conn = conn;
         }
 
+        /* Parse any control messages the user may have included. */
+        ret = rds_cmsg_send(rs, rm, msg, &allocated_mr);
+        if (ret)
+                goto out;
+
         if ((rm->m_rdma_cookie || rm->m_rdma_op)
          && conn->c_trans->xmit_rdma == NULL) {
                 if (printk_ratelimit())
diff --git a/net/rfkill/Kconfig b/net/rfkill/Kconfig
index 7f807b30cfbb..eaf765876458 100644
--- a/net/rfkill/Kconfig
+++ b/net/rfkill/Kconfig
@@ -10,22 +10,15 @@ menuconfig RFKILL
           To compile this driver as a module, choose M here: the
           module will be called rfkill.
 
-config RFKILL_INPUT
-        tristate "Input layer to RF switch connector"
-        depends on RFKILL && INPUT
-        help
-          Say Y here if you want kernel automatically toggle state
-          of RF switches on and off when user presses appropriate
-          button or a key on the keyboard. Without this module you
-          need a some kind of userspace application to control
-          state of the switches.
-
-          To compile this driver as a module, choose M here: the
-          module will be called rfkill-input.
-
 # LED trigger support
 config RFKILL_LEDS
         bool
-        depends on RFKILL && LEDS_TRIGGERS
+        depends on RFKILL
+        depends on LEDS_TRIGGERS = y || RFKILL = LEDS_TRIGGERS
         default y
 
+config RFKILL_INPUT
+        bool "RF switch input support" if EMBEDDED
+        depends on RFKILL
+        depends on INPUT = y || RFKILL = INPUT
+        default y if !EMBEDDED
diff --git a/net/rfkill/Makefile b/net/rfkill/Makefile
index b38c430be057..662105352691 100644
--- a/net/rfkill/Makefile
+++ b/net/rfkill/Makefile
@@ -2,5 +2,6 @@
 # Makefile for the RF switch subsystem.
 #
 
-obj-$(CONFIG_RFKILL)                    += rfkill.o
-obj-$(CONFIG_RFKILL_INPUT)              += rfkill-input.o
+rfkill-y                        += core.o
+rfkill-$(CONFIG_RFKILL_INPUT)   += input.o
+obj-$(CONFIG_RFKILL)            += rfkill.o
diff --git a/net/rfkill/core.c b/net/rfkill/core.c
new file mode 100644
index 000000000000..4e68ab439d5d
--- /dev/null
+++ b/net/rfkill/core.c
@@ -0,0 +1,1205 @@
+/*
+ * Copyright (C) 2006 - 2007 Ivo van Doorn
+ * Copyright (C) 2007 Dmitry Torokhov
+ * Copyright 2009 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 as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the
+ * Free Software Foundation, Inc.,
+ * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/workqueue.h>
+#include <linux/capability.h>
+#include <linux/list.h>
+#include <linux/mutex.h>
+#include <linux/rfkill.h>
+#include <linux/spinlock.h>
+#include <linux/miscdevice.h>
+#include <linux/wait.h>
+#include <linux/poll.h>
+#include <linux/fs.h>
+
+#include "rfkill.h"
+
+#define POLL_INTERVAL           (5 * HZ)
+
+#define RFKILL_BLOCK_HW         BIT(0)
+#define RFKILL_BLOCK_SW         BIT(1)
+#define RFKILL_BLOCK_SW_PREV    BIT(2)
+#define RFKILL_BLOCK_ANY        (RFKILL_BLOCK_HW |\
+                                 RFKILL_BLOCK_SW |\
+                                 RFKILL_BLOCK_SW_PREV)
+#define RFKILL_BLOCK_SW_SETCALL BIT(31)
+
+struct rfkill {
+        spinlock_t              lock;
+
+        const char              *name;
+        enum rfkill_type        type;
+
+        unsigned long           state;
+
+        u32                     idx;
+
+        bool                    registered;
+        bool                    suspended;
+        bool                    persistent;
+
+        const struct rfkill_ops *ops;
+        void                    *data;
+
+#ifdef CONFIG_RFKILL_LEDS
+        struct led_trigger      led_trigger;
+        const char              *ledtrigname;
+#endif
+
+        struct device           dev;
+        struct list_head        node;
+
+        struct delayed_work     poll_work;
+        struct work_struct      uevent_work;
+        struct work_struct      sync_work;
+};
+#define to_rfkill(d)    container_of(d, struct rfkill, dev)
+
+struct rfkill_int_event {
+        struct list_head        list;
+        struct rfkill_event     ev;
+};
+
+struct rfkill_data {
+        struct list_head        list;
+        struct list_head        events;
+        struct mutex            mtx;
+        wait_queue_head_t       read_wait;
+        bool                    input_handler;
+};
+
+
+MODULE_AUTHOR("Ivo van Doorn <IvDoorn@gmail.com>");
+MODULE_AUTHOR("Johannes Berg <johannes@sipsolutions.net>");
+MODULE_DESCRIPTION("RF switch support");
+MODULE_LICENSE("GPL");
+
+
+/*
+ * The locking here should be made much smarter, we currently have
+ * a bit of a stupid situation because drivers might want to register
+ * the rfkill struct under their own lock, and take this lock during
+ * rfkill method calls -- which will cause an AB-BA deadlock situation.
+ *
+ * To fix that, we need to rework this code here to be mostly lock-free
+ * and only use the mutex for list manipulations, not to protect the
+ * various other global variables. Then we can avoid holding the mutex
+ * around driver operations, and all is happy.
+ */
+static LIST_HEAD(rfkill_list);  /* list of registered rf switches */
+static DEFINE_MUTEX(rfkill_global_mutex);
+static LIST_HEAD(rfkill_fds);   /* list of open fds of /dev/rfkill */
+
+static unsigned int rfkill_default_state = 1;
+module_param_named(default_state, rfkill_default_state, uint, 0444);
+MODULE_PARM_DESC(default_state,
+                 "Default initial state for all radio types, 0 = radio off");
+
+static struct {
+        bool cur, sav;
+} rfkill_global_states[NUM_RFKILL_TYPES];
+
+static bool rfkill_epo_lock_active;
+
+
+#ifdef CONFIG_RFKILL_LEDS
+static void rfkill_led_trigger_event(struct rfkill *rfkill)
+{
+        struct led_trigger *trigger;
+
+        if (!rfkill->registered)
+                return;
+
+        trigger = &rfkill->led_trigger;
+
+        if (rfkill->state & RFKILL_BLOCK_ANY)
+                led_trigger_event(trigger, LED_OFF);
+        else
+                led_trigger_event(trigger, LED_FULL);
+}
+
+static void rfkill_led_trigger_activate(struct led_classdev *led)
+{
+        struct rfkill *rfkill;
+
+        rfkill = container_of(led->trigger, struct rfkill, led_trigger);
+
+        rfkill_led_trigger_event(rfkill);
+}
+
+const char *rfkill_get_led_trigger_name(struct rfkill *rfkill)
+{
+        return rfkill->led_trigger.name;
+}
+EXPORT_SYMBOL(rfkill_get_led_trigger_name);
+
+void rfkill_set_led_trigger_name(struct rfkill *rfkill, const char *name)
+{
+        BUG_ON(!rfkill);
+
+        rfkill->ledtrigname = name;
+}
+EXPORT_SYMBOL(rfkill_set_led_trigger_name);
+
+static int rfkill_led_trigger_register(struct rfkill *rfkill)
+{
+        rfkill->led_trigger.name = rfkill->ledtrigname
+                                        ? : dev_name(&rfkill->dev);
+        rfkill->led_trigger.activate = rfkill_led_trigger_activate;
+        return led_trigger_register(&rfkill->led_trigger);
+}
+
+static void rfkill_led_trigger_unregister(struct rfkill *rfkill)
+{
+        led_trigger_unregister(&rfkill->led_trigger);
+}
+#else
+static void rfkill_led_trigger_event(struct rfkill *rfkill)
+{
+}
+
+static inline int rfkill_led_trigger_register(struct rfkill *rfkill)
+{
+        return 0;
+}
+
+static inline void rfkill_led_trigger_unregister(struct rfkill *rfkill)
+{
+}
+#endif /* CONFIG_RFKILL_LEDS */
+
+static void rfkill_fill_event(struct rfkill_event *ev, struct rfkill *rfkill,
+                              enum rfkill_operation op)
+{
+        unsigned long flags;
+
+        ev->idx = rfkill->idx;
+        ev->type = rfkill->type;
+        ev->op = op;
+
+        spin_lock_irqsave(&rfkill->lock, flags);
+        ev->hard = !!(rfkill->state & RFKILL_BLOCK_HW);
+        ev->soft = !!(rfkill->state & (RFKILL_BLOCK_SW |
+                                        RFKILL_BLOCK_SW_PREV));
+        spin_unlock_irqrestore(&rfkill->lock, flags);
+}
+
+static void rfkill_send_events(struct rfkill *rfkill, enum rfkill_operation op)
+{
+        struct rfkill_data *data;
+        struct rfkill_int_event *ev;
+
+        list_for_each_entry(data, &rfkill_fds, list) {
+                ev = kzalloc(sizeof(*ev), GFP_KERNEL);
+                if (!ev)
+                        continue;
+                rfkill_fill_event(&ev->ev, rfkill, op);
+                mutex_lock(&data->mtx);
+                list_add_tail(&ev->list, &data->events);
+                mutex_unlock(&data->mtx);
+                wake_up_interruptible(&data->read_wait);
+        }
+}
+
+static void rfkill_event(struct rfkill *rfkill)
+{
+        if (!rfkill->registered || rfkill->suspended)
+                return;
+
+        kobject_uevent(&rfkill->dev.kobj, KOBJ_CHANGE);
+
+        /* also send event to /dev/rfkill */
+        rfkill_send_events(rfkill, RFKILL_OP_CHANGE);
+}
+
+static bool __rfkill_set_hw_state(struct rfkill *rfkill,
+                                  bool blocked, bool *change)
+{
+        unsigned long flags;
+        bool prev, any;
+
+        BUG_ON(!rfkill);
+
+        spin_lock_irqsave(&rfkill->lock, flags);
+        prev = !!(rfkill->state & RFKILL_BLOCK_HW);
+        if (blocked)
+                rfkill->state |= RFKILL_BLOCK_HW;
+        else
+                rfkill->state &= ~RFKILL_BLOCK_HW;
+        *change = prev != blocked;
+        any = rfkill->state & RFKILL_BLOCK_ANY;
+        spin_unlock_irqrestore(&rfkill->lock, flags);
+
+        rfkill_led_trigger_event(rfkill);
+
+        return any;
+}
+
+/**
+ * rfkill_set_block - wrapper for set_block method
+ *
+ * @rfkill: the rfkill struct to use
+ * @blocked: the new software state
+ *
+ * Calls the set_block method (when applicable) and handles notifications
+ * etc. as well.
+ */
+static void rfkill_set_block(struct rfkill *rfkill, bool blocked)
+{
+        unsigned long flags;
+        int err;
+
+        /*
+         * Some platforms (...!) generate input events which affect the
+         * _hard_ kill state -- whenever something tries to change the
+         * current software state query the hardware state too.
+         */
+        if (rfkill->ops->query)
+                rfkill->ops->query(rfkill, rfkill->data);
+
+        spin_lock_irqsave(&rfkill->lock, flags);
+        if (rfkill->state & RFKILL_BLOCK_SW)
+                rfkill->state |= RFKILL_BLOCK_SW_PREV;
+        else
+                rfkill->state &= ~RFKILL_BLOCK_SW_PREV;
+
+        if (blocked)
+                rfkill->state |= RFKILL_BLOCK_SW;
+        else
+                rfkill->state &= ~RFKILL_BLOCK_SW;
+
+        rfkill->state |= RFKILL_BLOCK_SW_SETCALL;
+        spin_unlock_irqrestore(&rfkill->lock, flags);
+
+        if (unlikely(rfkill->dev.power.power_state.event & PM_EVENT_SLEEP))
+                return;
+
+        err = rfkill->ops->set_block(rfkill->data, blocked);
+
+        spin_lock_irqsave(&rfkill->lock, flags);
+        if (err) {
+                /*
+                 * Failed -- reset status to _prev, this may be different
+                 * from what set set _PREV to earlier in this function
+                 * if rfkill_set_sw_state was invoked.
+                 */
+                if (rfkill->state & RFKILL_BLOCK_SW_PREV)
+                        rfkill->state |= RFKILL_BLOCK_SW;
+                else
+                        rfkill->state &= ~RFKILL_BLOCK_SW;
+        }
+        rfkill->state &= ~RFKILL_BLOCK_SW_SETCALL;
+        rfkill->state &= ~RFKILL_BLOCK_SW_PREV;
+        spin_unlock_irqrestore(&rfkill->lock, flags);
+
+        rfkill_led_trigger_event(rfkill);
+        rfkill_event(rfkill);
+}
+
+#ifdef CONFIG_RFKILL_INPUT
+static atomic_t rfkill_input_disabled = ATOMIC_INIT(0);
+
+/**
+ * __rfkill_switch_all - Toggle state of all switches of given type
+ * @type: type of interfaces to be affected
+ * @state: the new state
+ *
+ * This function sets the state of all switches of given type,
+ * unless a specific switch is claimed by userspace (in which case,
+ * that switch is left alone) or suspended.
+ *
+ * Caller must have acquired rfkill_global_mutex.
+ */
+static void __rfkill_switch_all(const enum rfkill_type type, bool blocked)
+{
+        struct rfkill *rfkill;
+
+        rfkill_global_states[type].cur = blocked;
+        list_for_each_entry(rfkill, &rfkill_list, node) {
+                if (rfkill->type != type)
+                        continue;
+
+                rfkill_set_block(rfkill, blocked);
+        }
+}
+
+/**
+ * rfkill_switch_all - Toggle state of all switches of given type
+ * @type: type of interfaces to be affected
+ * @state: the new state
+ *
+ * Acquires rfkill_global_mutex and calls __rfkill_switch_all(@type, @state).
+ * Please refer to __rfkill_switch_all() for details.
+ *
+ * Does nothing if the EPO lock is active.
+ */
+void rfkill_switch_all(enum rfkill_type type, bool blocked)
+{
+        if (atomic_read(&rfkill_input_disabled))
+                return;
+
+        mutex_lock(&rfkill_global_mutex);
+
+        if (!rfkill_epo_lock_active)
+                __rfkill_switch_all(type, blocked);
+
+        mutex_unlock(&rfkill_global_mutex);
+}
+
+/**
+ * rfkill_epo - emergency power off all transmitters
+ *
+ * This kicks all non-suspended rfkill devices to RFKILL_STATE_SOFT_BLOCKED,
+ * ignoring everything in its path but rfkill_global_mutex and rfkill->mutex.
+ *
+ * The global state before the EPO is saved and can be restored later
+ * using rfkill_restore_states().
+ */
+void rfkill_epo(void)
+{
+        struct rfkill *rfkill;
+        int i;
+
+        if (atomic_read(&rfkill_input_disabled))
+                return;
+
+        mutex_lock(&rfkill_global_mutex);
+
+        rfkill_epo_lock_active = true;
+        list_for_each_entry(rfkill, &rfkill_list, node)
+                rfkill_set_block(rfkill, true);
+
+        for (i = 0; i < NUM_RFKILL_TYPES; i++) {
+                rfkill_global_states[i].sav = rfkill_global_states[i].cur;
+                rfkill_global_states[i].cur = true;
+        }
+
+        mutex_unlock(&rfkill_global_mutex);
+}
+
+/**
+ * rfkill_restore_states - restore global states
+ *
+ * Restore (and sync switches to) the global state from the
+ * states in rfkill_default_states.  This can undo the effects of
+ * a call to rfkill_epo().
+ */
+void rfkill_restore_states(void)
+{
+        int i;
+
+        if (atomic_read(&rfkill_input_disabled))
+                return;
+
+        mutex_lock(&rfkill_global_mutex);
+
+        rfkill_epo_lock_active = false;
+        for (i = 0; i < NUM_RFKILL_TYPES; i++)
+                __rfkill_switch_all(i, rfkill_global_states[i].sav);
+        mutex_unlock(&rfkill_global_mutex);
+}
+
+/**
+ * rfkill_remove_epo_lock - unlock state changes
+ *
+ * Used by rfkill-input manually unlock state changes, when
+ * the EPO switch is deactivated.
+ */
+void rfkill_remove_epo_lock(void)
+{
+        if (atomic_read(&rfkill_input_disabled))
+                return;
+
+        mutex_lock(&rfkill_global_mutex);
+        rfkill_epo_lock_active = false;
+        mutex_unlock(&rfkill_global_mutex);
+}
+
+/**
+ * rfkill_is_epo_lock_active - returns true EPO is active
+ *
+ * Returns 0 (false) if there is NOT an active EPO contidion,
+ * and 1 (true) if there is an active EPO contition, which
+ * locks all radios in one of the BLOCKED states.
+ *
+ * Can be called in atomic context.
+ */
+bool rfkill_is_epo_lock_active(void)
+{
+        return rfkill_epo_lock_active;
+}
+
+/**
+ * rfkill_get_global_sw_state - returns global state for a type
+ * @type: the type to get the global state of
+ *
+ * Returns the current global state for a given wireless
+ * device type.
+ */
+bool rfkill_get_global_sw_state(const enum rfkill_type type)
+{
+        return rfkill_global_states[type].cur;
+}
+#endif
+
+
+bool rfkill_set_hw_state(struct rfkill *rfkill, bool blocked)
+{
+        bool ret, change;
+
+        ret = __rfkill_set_hw_state(rfkill, blocked, &change);
+
+        if (!rfkill->registered)
+                return ret;
+
+        if (change)
+                schedule_work(&rfkill->uevent_work);
+
+        return ret;
+}
+EXPORT_SYMBOL(rfkill_set_hw_state);
+
+static void __rfkill_set_sw_state(struct rfkill *rfkill, bool blocked)
+{
+        u32 bit = RFKILL_BLOCK_SW;
+
+        /* if in a ops->set_block right now, use other bit */
+        if (rfkill->state & RFKILL_BLOCK_SW_SETCALL)
+                bit = RFKILL_BLOCK_SW_PREV;
+
+        if (blocked)
+                rfkill->state |= bit;
+        else
+                rfkill->state &= ~bit;
+}
+
+bool rfkill_set_sw_state(struct rfkill *rfkill, bool blocked)
+{
+        unsigned long flags;
+        bool prev, hwblock;
+
+        BUG_ON(!rfkill);
+
+        spin_lock_irqsave(&rfkill->lock, flags);
+        prev = !!(rfkill->state & RFKILL_BLOCK_SW);
+        __rfkill_set_sw_state(rfkill, blocked);
+        hwblock = !!(rfkill->state & RFKILL_BLOCK_HW);
+        blocked = blocked || hwblock;
+        spin_unlock_irqrestore(&rfkill->lock, flags);
+
+        if (!rfkill->registered) {
+                rfkill->persistent = true;
+        } else {
+                if (prev != blocked && !hwblock)
+                        schedule_work(&rfkill->uevent_work);
+
+                rfkill_led_trigger_event(rfkill);
+        }
+
+        return blocked;
+}
+EXPORT_SYMBOL(rfkill_set_sw_state);
+
+void rfkill_set_states(struct rfkill *rfkill, bool sw, bool hw)
+{
+        unsigned long flags;
+        bool swprev, hwprev;
+
+        BUG_ON(!rfkill);
+
+        spin_lock_irqsave(&rfkill->lock, flags);
+
+        /*
+         * No need to care about prev/setblock ... this is for uevent only
+         * and that will get triggered by rfkill_set_block anyway.
+         */
+        swprev = !!(rfkill->state & RFKILL_BLOCK_SW);
+        hwprev = !!(rfkill->state & RFKILL_BLOCK_HW);
+        __rfkill_set_sw_state(rfkill, sw);
+
+        spin_unlock_irqrestore(&rfkill->lock, flags);
+
+        if (!rfkill->registered) {
+                rfkill->persistent = true;
+        } else {
+                if (swprev != sw || hwprev != hw)
+                        schedule_work(&rfkill->uevent_work);
+
+                rfkill_led_trigger_event(rfkill);
+        }
+}
+EXPORT_SYMBOL(rfkill_set_states);
+
+static ssize_t rfkill_name_show(struct device *dev,
+                                struct device_attribute *attr,
+                                char *buf)
+{
+        struct rfkill *rfkill = to_rfkill(dev);
+
+        return sprintf(buf, "%s\n", rfkill->name);
+}
+
+static const char *rfkill_get_type_str(enum rfkill_type type)
+{
+        switch (type) {
+        case RFKILL_TYPE_WLAN:
+                return "wlan";
+        case RFKILL_TYPE_BLUETOOTH:
+                return "bluetooth";
+        case RFKILL_TYPE_UWB:
+                return "ultrawideband";
+        case RFKILL_TYPE_WIMAX:
+                return "wimax";
+        case RFKILL_TYPE_WWAN:
+                return "wwan";
+        default:
+                BUG();
+        }
+
+        BUILD_BUG_ON(NUM_RFKILL_TYPES != RFKILL_TYPE_WWAN + 1);
+}
+
+static ssize_t rfkill_type_show(struct device *dev,
+                                struct device_attribute *attr,
+                                char *buf)
+{
+        struct rfkill *rfkill = to_rfkill(dev);
+
+        return sprintf(buf, "%s\n", rfkill_get_type_str(rfkill->type));
+}
+
+static ssize_t rfkill_idx_show(struct device *dev,
+                               struct device_attribute *attr,
+                               char *buf)
+{
+        struct rfkill *rfkill = to_rfkill(dev);
+
+        return sprintf(buf, "%d\n", rfkill->idx);
+}
+
+static u8 user_state_from_blocked(unsigned long state)
+{
+        if (state & RFKILL_BLOCK_HW)
+                return RFKILL_USER_STATE_HARD_BLOCKED;
+        if (state & RFKILL_BLOCK_SW)
+                return RFKILL_USER_STATE_SOFT_BLOCKED;
+
+        return RFKILL_USER_STATE_UNBLOCKED;
+}
+
+static ssize_t rfkill_state_show(struct device *dev,
+                                 struct device_attribute *attr,
+                                 char *buf)
+{
+        struct rfkill *rfkill = to_rfkill(dev);
+        unsigned long flags;
+        u32 state;
+
+        spin_lock_irqsave(&rfkill->lock, flags);
+        state = rfkill->state;
+        spin_unlock_irqrestore(&rfkill->lock, flags);
+
+        return sprintf(buf, "%d\n", user_state_from_blocked(state));
+}
+
+static ssize_t rfkill_state_store(struct device *dev,
+                                  struct device_attribute *attr,
+                                  const char *buf, size_t count)
+{
+        /*
+         * The intention was that userspace can only take control over
+         * a given device when/if rfkill-input doesn't control it due
+         * to user_claim. Since user_claim is currently unsupported,
+         * we never support changing the state from userspace -- this
+         * can be implemented again later.
+         */
+
+        return -EPERM;
+}
+
+static ssize_t rfkill_claim_show(struct device *dev,
+                                 struct device_attribute *attr,
+                                 char *buf)
+{
+        return sprintf(buf, "%d\n", 0);
+}
+
+static ssize_t rfkill_claim_store(struct device *dev,
+                                  struct device_attribute *attr,
+                                  const char *buf, size_t count)
+{
+        return -EOPNOTSUPP;
+}
+
+static struct device_attribute rfkill_dev_attrs[] = {
+        __ATTR(name, S_IRUGO, rfkill_name_show, NULL),
+        __ATTR(type, S_IRUGO, rfkill_type_show, NULL),
+        __ATTR(index, S_IRUGO, rfkill_idx_show, NULL),
+        __ATTR(state, S_IRUGO|S_IWUSR, rfkill_state_show, rfkill_state_store),
+        __ATTR(claim, S_IRUGO|S_IWUSR, rfkill_claim_show, rfkill_claim_store),
+        __ATTR_NULL
+};
+
+static void rfkill_release(struct device *dev)
+{
+        struct rfkill *rfkill = to_rfkill(dev);
+
+        kfree(rfkill);
+}
+
+static int rfkill_dev_uevent(struct device *dev, struct kobj_uevent_env *env)
+{
+        struct rfkill *rfkill = to_rfkill(dev);
+        unsigned long flags;
+        u32 state;
+        int error;
+
+        error = add_uevent_var(env, "RFKILL_NAME=%s", rfkill->name);
+        if (error)
+                return error;
+        error = add_uevent_var(env, "RFKILL_TYPE=%s",
+                               rfkill_get_type_str(rfkill->type));
+        if (error)
+                return error;
+        spin_lock_irqsave(&rfkill->lock, flags);
+        state = rfkill->state;
+        spin_unlock_irqrestore(&rfkill->lock, flags);
+        error = add_uevent_var(env, "RFKILL_STATE=%d",
+                               user_state_from_blocked(state));
+        return error;
+}
+
+void rfkill_pause_polling(struct rfkill *rfkill)
+{
+        BUG_ON(!rfkill);
+
+        if (!rfkill->ops->poll)
+                return;
+
+        cancel_delayed_work_sync(&rfkill->poll_work);
+}
+EXPORT_SYMBOL(rfkill_pause_polling);
+
+void rfkill_resume_polling(struct rfkill *rfkill)
+{
+        BUG_ON(!rfkill);
+
+        if (!rfkill->ops->poll)
+                return;
+
+        schedule_work(&rfkill->poll_work.work);
+}
+EXPORT_SYMBOL(rfkill_resume_polling);
+
+static int rfkill_suspend(struct device *dev, pm_message_t state)
+{
+        struct rfkill *rfkill = to_rfkill(dev);
+
+        rfkill_pause_polling(rfkill);
+
+        rfkill->suspended = true;
+
+        return 0;
+}
+
+static int rfkill_resume(struct device *dev)
+{
+        struct rfkill *rfkill = to_rfkill(dev);
+        bool cur;
+
+        cur = !!(rfkill->state & RFKILL_BLOCK_SW);
+        rfkill_set_block(rfkill, cur);
+
+        rfkill->suspended = false;
+
+        rfkill_resume_polling(rfkill);
+
+        return 0;
+}
+
+static struct class rfkill_class = {
+        .name           = "rfkill",
+        .dev_release    = rfkill_release,
+        .dev_attrs      = rfkill_dev_attrs,
+        .dev_uevent     = rfkill_dev_uevent,
+        .suspend        = rfkill_suspend,
+        .resume         = rfkill_resume,
+};
+
+bool rfkill_blocked(struct rfkill *rfkill)
+{
+        unsigned long flags;
+        u32 state;
+
+        spin_lock_irqsave(&rfkill->lock, flags);
+        state = rfkill->state;
+        spin_unlock_irqrestore(&rfkill->lock, flags);
+
+        return !!(state & RFKILL_BLOCK_ANY);
+}
+EXPORT_SYMBOL(rfkill_blocked);
+
+
+struct rfkill * __must_check rfkill_alloc(const char *name,
+                                          struct device *parent,
+                                          const enum rfkill_type type,
+                                          const struct rfkill_ops *ops,
+                                          void *ops_data)
+{
+        struct rfkill *rfkill;
+        struct device *dev;
+
+        if (WARN_ON(!ops))
+                return NULL;
+
+        if (WARN_ON(!ops->set_block))
+                return NULL;
+
+        if (WARN_ON(!name))
+                return NULL;
+
+        if (WARN_ON(type == RFKILL_TYPE_ALL || type >= NUM_RFKILL_TYPES))
+                return NULL;
+
+        rfkill = kzalloc(sizeof(*rfkill), GFP_KERNEL);
+        if (!rfkill)
+                return NULL;
+
+        spin_lock_init(&rfkill->lock);
+        INIT_LIST_HEAD(&rfkill->node);
+        rfkill->type = type;
+        rfkill->name = name;
+        rfkill->ops = ops;
+        rfkill->data = ops_data;
+
+        dev = &rfkill->dev;
+        dev->class = &rfkill_class;
+        dev->parent = parent;
+        device_initialize(dev);
+
+        return rfkill;
+}
+EXPORT_SYMBOL(rfkill_alloc);
+
+static void rfkill_poll(struct work_struct *work)
+{
+        struct rfkill *rfkill;
+
+        rfkill = container_of(work, struct rfkill, poll_work.work);
+
+        /*
+         * Poll hardware state -- driver will use one of the
+         * rfkill_set{,_hw,_sw}_state functions and use its
+         * return value to update the current status.
+         */
+        rfkill->ops->poll(rfkill, rfkill->data);
+
+        schedule_delayed_work(&rfkill->poll_work,
+                round_jiffies_relative(POLL_INTERVAL));
+}
+
+static void rfkill_uevent_work(struct work_struct *work)
+{
+        struct rfkill *rfkill;
+
+        rfkill = container_of(work, struct rfkill, uevent_work);
+
+        mutex_lock(&rfkill_global_mutex);
+        rfkill_event(rfkill);
+        mutex_unlock(&rfkill_global_mutex);
+}
+
+static void rfkill_sync_work(struct work_struct *work)
+{
+        struct rfkill *rfkill;
+        bool cur;
+
+        rfkill = container_of(work, struct rfkill, sync_work);
+
+        mutex_lock(&rfkill_global_mutex);
+        cur = rfkill_global_states[rfkill->type].cur;
+        rfkill_set_block(rfkill, cur);
+        mutex_unlock(&rfkill_global_mutex);
+}
+
+int __must_check rfkill_register(struct rfkill *rfkill)
+{
+        static unsigned long rfkill_no;
+        struct device *dev = &rfkill->dev;
+        int error;
+
+        BUG_ON(!rfkill);
+
+        mutex_lock(&rfkill_global_mutex);
+
+        if (rfkill->registered) {
+                error = -EALREADY;
+                goto unlock;
+        }
+
+        rfkill->idx = rfkill_no;
+        dev_set_name(dev, "rfkill%lu", rfkill_no);
+        rfkill_no++;
+
+        list_add_tail(&rfkill->node, &rfkill_list);
+
+        error = device_add(dev);
+        if (error)
+                goto remove;
+
+        error = rfkill_led_trigger_register(rfkill);
+        if (error)
+                goto devdel;
+
+        rfkill->registered = true;
+
+        INIT_DELAYED_WORK(&rfkill->poll_work, rfkill_poll);
+        INIT_WORK(&rfkill->uevent_work, rfkill_uevent_work);
+        INIT_WORK(&rfkill->sync_work, rfkill_sync_work);
+
+        if (rfkill->ops->poll)
+                schedule_delayed_work(&rfkill->poll_work,
+                        round_jiffies_relative(POLL_INTERVAL));
+
+        if (!rfkill->persistent || rfkill_epo_lock_active) {
+                schedule_work(&rfkill->sync_work);
+        } else {
+#ifdef CONFIG_RFKILL_INPUT
+                bool soft_blocked = !!(rfkill->state & RFKILL_BLOCK_SW);
+
+                if (!atomic_read(&rfkill_input_disabled))
+                        __rfkill_switch_all(rfkill->type, soft_blocked);
+#endif
+        }
+
+        rfkill_send_events(rfkill, RFKILL_OP_ADD);
+
+        mutex_unlock(&rfkill_global_mutex);
+        return 0;
+
+ devdel:
+        device_del(&rfkill->dev);
+ remove:
+        list_del_init(&rfkill->node);
+ unlock:
+        mutex_unlock(&rfkill_global_mutex);
+        return error;
+}
+EXPORT_SYMBOL(rfkill_register);
+
+void rfkill_unregister(struct rfkill *rfkill)
+{
+        BUG_ON(!rfkill);
+
+        if (rfkill->ops->poll)
+                cancel_delayed_work_sync(&rfkill->poll_work);
+
+        cancel_work_sync(&rfkill->uevent_work);
+        cancel_work_sync(&rfkill->sync_work);
+
+        rfkill->registered = false;
+
+        device_del(&rfkill->dev);
+
+        mutex_lock(&rfkill_global_mutex);
+        rfkill_send_events(rfkill, RFKILL_OP_DEL);
+        list_del_init(&rfkill->node);
+        mutex_unlock(&rfkill_global_mutex);
+
+        rfkill_led_trigger_unregister(rfkill);
+}
+EXPORT_SYMBOL(rfkill_unregister);
+
+void rfkill_destroy(struct rfkill *rfkill)
+{
+        if (rfkill)
+                put_device(&rfkill->dev);
+}
+EXPORT_SYMBOL(rfkill_destroy);
+
+static int rfkill_fop_open(struct inode *inode, struct file *file)
+{
+        struct rfkill_data *data;
+        struct rfkill *rfkill;
+        struct rfkill_int_event *ev, *tmp;
+
+        data = kzalloc(sizeof(*data), GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+
+        INIT_LIST_HEAD(&data->events);
+        mutex_init(&data->mtx);
+        init_waitqueue_head(&data->read_wait);
+
+        mutex_lock(&rfkill_global_mutex);
+        mutex_lock(&data->mtx);
+        /*
+         * start getting events from elsewhere but hold mtx to get
+         * startup events added first
+         */
+        list_add(&data->list, &rfkill_fds);
+
+        list_for_each_entry(rfkill, &rfkill_list, node) {
+                ev = kzalloc(sizeof(*ev), GFP_KERNEL);
+                if (!ev)
+                        goto free;
+                rfkill_fill_event(&ev->ev, rfkill, RFKILL_OP_ADD);
+                list_add_tail(&ev->list, &data->events);
+        }
+        mutex_unlock(&data->mtx);
+        mutex_unlock(&rfkill_global_mutex);
+
+        file->private_data = data;
+
+        return nonseekable_open(inode, file);
+
+ free:
+        mutex_unlock(&data->mtx);
+        mutex_unlock(&rfkill_global_mutex);
+        mutex_destroy(&data->mtx);
+        list_for_each_entry_safe(ev, tmp, &data->events, list)
+                kfree(ev);
+        kfree(data);
+        return -ENOMEM;
+}
+
+static unsigned int rfkill_fop_poll(struct file *file, poll_table *wait)
+{
+        struct rfkill_data *data = file->private_data;
+        unsigned int res = POLLOUT | POLLWRNORM;
+
+        poll_wait(file, &data->read_wait, wait);
+
+        mutex_lock(&data->mtx);
+        if (!list_empty(&data->events))
+                res = POLLIN | POLLRDNORM;
+        mutex_unlock(&data->mtx);
+
+        return res;
+}
+
+static bool rfkill_readable(struct rfkill_data *data)
+{
+        bool r;
+
+        mutex_lock(&data->mtx);
+        r = !list_empty(&data->events);
+        mutex_unlock(&data->mtx);
+
+        return r;
+}
+
+static ssize_t rfkill_fop_read(struct file *file, char __user *buf,
+                               size_t count, loff_t *pos)
+{
+        struct rfkill_data *data = file->private_data;
+        struct rfkill_int_event *ev;
+        unsigned long sz;
+        int ret;
+
+        mutex_lock(&data->mtx);
+
+        while (list_empty(&data->events)) {
+                if (file->f_flags & O_NONBLOCK) {
+                        ret = -EAGAIN;
+                        goto out;
+                }
+                mutex_unlock(&data->mtx);
+                ret = wait_event_interruptible(data->read_wait,
+                                               rfkill_readable(data));
+                mutex_lock(&data->mtx);
+
+                if (ret)
+                        goto out;
+        }
+
+        ev = list_first_entry(&data->events, struct rfkill_int_event,
+                                list);
+
+        sz = min_t(unsigned long, sizeof(ev->ev), count);
+        ret = sz;
+        if (copy_to_user(buf, &ev->ev, sz))
+                ret = -EFAULT;
+
+        list_del(&ev->list);
+        kfree(ev);
+ out:
+        mutex_unlock(&data->mtx);
+        return ret;
+}
+
+static ssize_t rfkill_fop_write(struct file *file, const char __user *buf,
+                                size_t count, loff_t *pos)
+{
+        struct rfkill *rfkill;
+        struct rfkill_event ev;
+
+        /* we don't need the 'hard' variable but accept it */
+        if (count < sizeof(ev) - 1)
+                return -EINVAL;
+
+        if (copy_from_user(&ev, buf, sizeof(ev) - 1))
+                return -EFAULT;
+
+        if (ev.op != RFKILL_OP_CHANGE && ev.op != RFKILL_OP_CHANGE_ALL)
+                return -EINVAL;
+
+        if (ev.type >= NUM_RFKILL_TYPES)
+                return -EINVAL;
+
+        mutex_lock(&rfkill_global_mutex);
+
+        if (ev.op == RFKILL_OP_CHANGE_ALL) {
+                if (ev.type == RFKILL_TYPE_ALL) {
+                        enum rfkill_type i;
+                        for (i = 0; i < NUM_RFKILL_TYPES; i++)
+                                rfkill_global_states[i].cur = ev.soft;
+                } else {
+                        rfkill_global_states[ev.type].cur = ev.soft;
+                }
+        }
+
+        list_for_each_entry(rfkill, &rfkill_list, node) {
+                if (rfkill->idx != ev.idx && ev.op != RFKILL_OP_CHANGE_ALL)
+                        continue;
+
+                if (rfkill->type != ev.type && ev.type != RFKILL_TYPE_ALL)
+                        continue;
+
+                rfkill_set_block(rfkill, ev.soft);
+        }
+        mutex_unlock(&rfkill_global_mutex);
+
+        return count;
+}
+
+static int rfkill_fop_release(struct inode *inode, struct file *file)
+{
+        struct rfkill_data *data = file->private_data;
+        struct rfkill_int_event *ev, *tmp;
+
+        mutex_lock(&rfkill_global_mutex);
+        list_del(&data->list);
+        mutex_unlock(&rfkill_global_mutex);
+
+        mutex_destroy(&data->mtx);
+        list_for_each_entry_safe(ev, tmp, &data->events, list)
+                kfree(ev);
+
+#ifdef CONFIG_RFKILL_INPUT
+        if (data->input_handler)
+                if (atomic_dec_return(&rfkill_input_disabled) == 0)
+                        printk(KERN_DEBUG "rfkill: input handler enabled\n");
+#endif
+
+        kfree(data);
+
+        return 0;
+}
+
+#ifdef CONFIG_RFKILL_INPUT
+static long rfkill_fop_ioctl(struct file *file, unsigned int cmd,
+                             unsigned long arg)
+{
+        struct rfkill_data *data = file->private_data;
+
+        if (_IOC_TYPE(cmd) != RFKILL_IOC_MAGIC)
+                return -ENOSYS;
+
+        if (_IOC_NR(cmd) != RFKILL_IOC_NOINPUT)
+                return -ENOSYS;
+
+        mutex_lock(&data->mtx);
+
+        if (!data->input_handler) {
+                if (atomic_inc_return(&rfkill_input_disabled) == 1)
+                        printk(KERN_DEBUG "rfkill: input handler disabled\n");
+                data->input_handler = true;
+        }
+
+        mutex_unlock(&data->mtx);
+
+        return 0;
+}
+#endif
+
+static const struct file_operations rfkill_fops = {
+        .open           = rfkill_fop_open,
+        .read           = rfkill_fop_read,
+        .write          = rfkill_fop_write,
+        .poll           = rfkill_fop_poll,
+        .release        = rfkill_fop_release,
+#ifdef CONFIG_RFKILL_INPUT
+        .unlocked_ioctl = rfkill_fop_ioctl,
+        .compat_ioctl   = rfkill_fop_ioctl,
+#endif
+};
+
+static struct miscdevice rfkill_miscdev = {
+        .name   = "rfkill",
+        .fops   = &rfkill_fops,
+        .minor  = MISC_DYNAMIC_MINOR,
+};
+
+static int __init rfkill_init(void)
+{
+        int error;
+        int i;
+
+        for (i = 0; i < NUM_RFKILL_TYPES; i++)
+                rfkill_global_states[i].cur = !rfkill_default_state;
+
+        error = class_register(&rfkill_class);
+        if (error)
+                goto out;
+
+        error = misc_register(&rfkill_miscdev);
+        if (error) {
+                class_unregister(&rfkill_class);
+                goto out;
+        }
+
+#ifdef CONFIG_RFKILL_INPUT
+        error = rfkill_handler_init();
+        if (error) {
+                misc_deregister(&rfkill_miscdev);
+                class_unregister(&rfkill_class);
+                goto out;
+        }
+#endif
+
+ out:
+        return error;
+}
+subsys_initcall(rfkill_init);
+
+static void __exit rfkill_exit(void)
+{
+#ifdef CONFIG_RFKILL_INPUT
+        rfkill_handler_exit();
+#endif
+        misc_deregister(&rfkill_miscdev);
+        class_unregister(&rfkill_class);
+}
+module_exit(rfkill_exit);
diff --git a/net/rfkill/input.c b/net/rfkill/input.c
new file mode 100644
index 000000000000..a7295ad5f9cb
--- /dev/null
+++ b/net/rfkill/input.c
@@ -0,0 +1,342 @@
+/*
+ * Input layer to RF Kill interface connector
+ *
+ * Copyright (c) 2007 Dmitry Torokhov
+ * Copyright 2009 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.
+ *
+ * If you ever run into a situation in which you have a SW_ type rfkill
+ * input device, then you can revive code that was removed in the patch
+ * "rfkill-input: remove unused code".
+ */
+
+#include <linux/input.h>
+#include <linux/slab.h>
+#include <linux/workqueue.h>
+#include <linux/init.h>
+#include <linux/rfkill.h>
+#include <linux/sched.h>
+
+#include "rfkill.h"
+
+enum rfkill_input_master_mode {
+        RFKILL_INPUT_MASTER_UNLOCK = 0,
+        RFKILL_INPUT_MASTER_RESTORE = 1,
+        RFKILL_INPUT_MASTER_UNBLOCKALL = 2,
+        NUM_RFKILL_INPUT_MASTER_MODES
+};
+
+/* Delay (in ms) between consecutive switch ops */
+#define RFKILL_OPS_DELAY 200
+
+static enum rfkill_input_master_mode rfkill_master_switch_mode =
+                                        RFKILL_INPUT_MASTER_UNBLOCKALL;
+module_param_named(master_switch_mode, rfkill_master_switch_mode, uint, 0);
+MODULE_PARM_DESC(master_switch_mode,
+        "SW_RFKILL_ALL ON should: 0=do nothing (only unlock); 1=restore; 2=unblock all");
+
+static spinlock_t rfkill_op_lock;
+static bool rfkill_op_pending;
+static unsigned long rfkill_sw_pending[BITS_TO_LONGS(NUM_RFKILL_TYPES)];
+static unsigned long rfkill_sw_state[BITS_TO_LONGS(NUM_RFKILL_TYPES)];
+
+enum rfkill_sched_op {
+        RFKILL_GLOBAL_OP_EPO = 0,
+        RFKILL_GLOBAL_OP_RESTORE,
+        RFKILL_GLOBAL_OP_UNLOCK,
+        RFKILL_GLOBAL_OP_UNBLOCK,
+};
+
+static enum rfkill_sched_op rfkill_master_switch_op;
+static enum rfkill_sched_op rfkill_op;
+
+static void __rfkill_handle_global_op(enum rfkill_sched_op op)
+{
+        unsigned int i;
+
+        switch (op) {
+        case RFKILL_GLOBAL_OP_EPO:
+                rfkill_epo();
+                break;
+        case RFKILL_GLOBAL_OP_RESTORE:
+                rfkill_restore_states();
+                break;
+        case RFKILL_GLOBAL_OP_UNLOCK:
+                rfkill_remove_epo_lock();
+                break;
+        case RFKILL_GLOBAL_OP_UNBLOCK:
+                rfkill_remove_epo_lock();
+                for (i = 0; i < NUM_RFKILL_TYPES; i++)
+                        rfkill_switch_all(i, false);
+                break;
+        default:
+                /* memory corruption or bug, fail safely */
+                rfkill_epo();
+                WARN(1, "Unknown requested operation %d! "
+                        "rfkill Emergency Power Off activated\n",
+                        op);
+        }
+}
+
+static void __rfkill_handle_normal_op(const enum rfkill_type type,
+                                      const bool complement)
+{
+        bool blocked;
+
+        blocked = rfkill_get_global_sw_state(type);
+        if (complement)
+                blocked = !blocked;
+
+        rfkill_switch_all(type, blocked);
+}
+
+static void rfkill_op_handler(struct work_struct *work)
+{
+        unsigned int i;
+        bool c;
+
+        spin_lock_irq(&rfkill_op_lock);
+        do {
+                if (rfkill_op_pending) {
+                        enum rfkill_sched_op op = rfkill_op;
+                        rfkill_op_pending = false;
+                        memset(rfkill_sw_pending, 0,
+                                sizeof(rfkill_sw_pending));
+                        spin_unlock_irq(&rfkill_op_lock);
+
+                        __rfkill_handle_global_op(op);
+
+                        spin_lock_irq(&rfkill_op_lock);
+
+                        /*
+                         * handle global ops first -- during unlocked period
+                         * we might have gotten a new global op.
+                         */
+                        if (rfkill_op_pending)
+                                continue;
+                }
+
+                if (rfkill_is_epo_lock_active())
+                        continue;
+
+                for (i = 0; i < NUM_RFKILL_TYPES; i++) {
+                        if (__test_and_clear_bit(i, rfkill_sw_pending)) {
+                                c = __test_and_clear_bit(i, rfkill_sw_state);
+                                spin_unlock_irq(&rfkill_op_lock);
+
+                                __rfkill_handle_normal_op(i, c);
+
+                                spin_lock_irq(&rfkill_op_lock);
+                        }
+                }
+        } while (rfkill_op_pending);
+        spin_unlock_irq(&rfkill_op_lock);
+}
+
+static DECLARE_DELAYED_WORK(rfkill_op_work, rfkill_op_handler);
+static unsigned long rfkill_last_scheduled;
+
+static unsigned long rfkill_ratelimit(const unsigned long last)
+{
+        const unsigned long delay = msecs_to_jiffies(RFKILL_OPS_DELAY);
+        return (time_after(jiffies, last + delay)) ? 0 : delay;
+}
+
+static void rfkill_schedule_ratelimited(void)
+{
+        if (delayed_work_pending(&rfkill_op_work))
+                return;
+        schedule_delayed_work(&rfkill_op_work,
+                              rfkill_ratelimit(rfkill_last_scheduled));
+        rfkill_last_scheduled = jiffies;
+}
+
+static void rfkill_schedule_global_op(enum rfkill_sched_op op)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&rfkill_op_lock, flags);
+        rfkill_op = op;
+        rfkill_op_pending = true;
+        if (op == RFKILL_GLOBAL_OP_EPO && !rfkill_is_epo_lock_active()) {
+                /* bypass the limiter for EPO */
+                cancel_delayed_work(&rfkill_op_work);
+                schedule_delayed_work(&rfkill_op_work, 0);
+                rfkill_last_scheduled = jiffies;
+        } else
+                rfkill_schedule_ratelimited();
+        spin_unlock_irqrestore(&rfkill_op_lock, flags);
+}
+
+static void rfkill_schedule_toggle(enum rfkill_type type)
+{
+        unsigned long flags;
+
+        if (rfkill_is_epo_lock_active())
+                return;
+
+        spin_lock_irqsave(&rfkill_op_lock, flags);
+        if (!rfkill_op_pending) {
+                __set_bit(type, rfkill_sw_pending);
+                __change_bit(type, rfkill_sw_state);
+                rfkill_schedule_ratelimited();
+        }
+        spin_unlock_irqrestore(&rfkill_op_lock, flags);
+}
+
+static void rfkill_schedule_evsw_rfkillall(int state)
+{
+        if (state)
+                rfkill_schedule_global_op(rfkill_master_switch_op);
+        else
+                rfkill_schedule_global_op(RFKILL_GLOBAL_OP_EPO);
+}
+
+static void rfkill_event(struct input_handle *handle, unsigned int type,
+                        unsigned int code, int data)
+{
+        if (type == EV_KEY && data == 1) {
+                switch (code) {
+                case KEY_WLAN:
+                        rfkill_schedule_toggle(RFKILL_TYPE_WLAN);
+                        break;
+                case KEY_BLUETOOTH:
+                        rfkill_schedule_toggle(RFKILL_TYPE_BLUETOOTH);
+                        break;
+                case KEY_UWB:
+                        rfkill_schedule_toggle(RFKILL_TYPE_UWB);
+                        break;
+                case KEY_WIMAX:
+                        rfkill_schedule_toggle(RFKILL_TYPE_WIMAX);
+                        break;
+                }
+        } else if (type == EV_SW && code == SW_RFKILL_ALL)
+                rfkill_schedule_evsw_rfkillall(data);
+}
+
+static int rfkill_connect(struct input_handler *handler, struct input_dev *dev,
+                          const struct input_device_id *id)
+{
+        struct input_handle *handle;
+        int error;
+
+        handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
+        if (!handle)
+                return -ENOMEM;
+
+        handle->dev = dev;
+        handle->handler = handler;
+        handle->name = "rfkill";
+
+        /* causes rfkill_start() to be called */
+        error = input_register_handle(handle);
+        if (error)
+                goto err_free_handle;
+
+        error = input_open_device(handle);
+        if (error)
+                goto err_unregister_handle;
+
+        return 0;
+
+ err_unregister_handle:
+        input_unregister_handle(handle);
+ err_free_handle:
+        kfree(handle);
+        return error;
+}
+
+static void rfkill_start(struct input_handle *handle)
+{
+        /*
+         * Take event_lock to guard against configuration changes, we
+         * should be able to deal with concurrency with rfkill_event()
+         * just fine (which event_lock will also avoid).
+         */
+        spin_lock_irq(&handle->dev->event_lock);
+
+        if (test_bit(EV_SW, handle->dev->evbit) &&
+            test_bit(SW_RFKILL_ALL, handle->dev->swbit))
+                rfkill_schedule_evsw_rfkillall(test_bit(SW_RFKILL_ALL,
+                                                        handle->dev->sw));
+
+        spin_unlock_irq(&handle->dev->event_lock);
+}
+
+static void rfkill_disconnect(struct input_handle *handle)
+{
+        input_close_device(handle);
+        input_unregister_handle(handle);
+        kfree(handle);
+}
+
+static const struct input_device_id rfkill_ids[] = {
+        {
+                .flags = INPUT_DEVICE_ID_MATCH_EVBIT | INPUT_DEVICE_ID_MATCH_KEYBIT,
+                .evbit = { BIT_MASK(EV_KEY) },
+                .keybit = { [BIT_WORD(KEY_WLAN)] = BIT_MASK(KEY_WLAN) },
+        },
+        {
+                .flags = INPUT_DEVICE_ID_MATCH_EVBIT | INPUT_DEVICE_ID_MATCH_KEYBIT,
+                .evbit = { BIT_MASK(EV_KEY) },
+                .keybit = { [BIT_WORD(KEY_BLUETOOTH)] = BIT_MASK(KEY_BLUETOOTH) },
+        },
+        {
+                .flags = INPUT_DEVICE_ID_MATCH_EVBIT | INPUT_DEVICE_ID_MATCH_KEYBIT,
+                .evbit = { BIT_MASK(EV_KEY) },
+                .keybit = { [BIT_WORD(KEY_UWB)] = BIT_MASK(KEY_UWB) },
+        },
+        {
+                .flags = INPUT_DEVICE_ID_MATCH_EVBIT | INPUT_DEVICE_ID_MATCH_KEYBIT,
+                .evbit = { BIT_MASK(EV_KEY) },
+                .keybit = { [BIT_WORD(KEY_WIMAX)] = BIT_MASK(KEY_WIMAX) },
+        },
+        {
+                .flags = INPUT_DEVICE_ID_MATCH_EVBIT | INPUT_DEVICE_ID_MATCH_SWBIT,
+                .evbit = { BIT(EV_SW) },
+                .swbit = { [BIT_WORD(SW_RFKILL_ALL)] = BIT_MASK(SW_RFKILL_ALL) },
+        },
+        { }
+};
+
+static struct input_handler rfkill_handler = {
+        .name = "rfkill",
+        .event = rfkill_event,
+        .connect = rfkill_connect,
+        .start = rfkill_start,
+        .disconnect = rfkill_disconnect,
+        .id_table = rfkill_ids,
+};
+
+int __init rfkill_handler_init(void)
+{
+        switch (rfkill_master_switch_mode) {
+        case RFKILL_INPUT_MASTER_UNBLOCKALL:
+                rfkill_master_switch_op = RFKILL_GLOBAL_OP_UNBLOCK;
+                break;
+        case RFKILL_INPUT_MASTER_RESTORE:
+                rfkill_master_switch_op = RFKILL_GLOBAL_OP_RESTORE;
+                break;
+        case RFKILL_INPUT_MASTER_UNLOCK:
+                rfkill_master_switch_op = RFKILL_GLOBAL_OP_UNLOCK;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        spin_lock_init(&rfkill_op_lock);
+
+        /* Avoid delay at first schedule */
+        rfkill_last_scheduled =
+                        jiffies - msecs_to_jiffies(RFKILL_OPS_DELAY) - 1;
+        return input_register_handler(&rfkill_handler);
+}
+
+void __exit rfkill_handler_exit(void)
+{
+        input_unregister_handler(&rfkill_handler);
+        cancel_delayed_work_sync(&rfkill_op_work);
+}
diff --git a/net/rfkill/rfkill-input.c b/net/rfkill/rfkill-input.c
deleted file mode 100644
index 84efde97c5a7..000000000000
--- a/net/rfkill/rfkill-input.c
+++ /dev/null
@@ -1,459 +0,0 @@
-/*
- * Input layer to RF Kill interface connector
- *
- * Copyright (c) 2007 Dmitry Torokhov
- */
-
-/*
- * 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/input.h>
-#include <linux/slab.h>
-#include <linux/workqueue.h>
-#include <linux/init.h>
-#include <linux/rfkill.h>
-#include <linux/sched.h>
-
-#include "rfkill-input.h"
-
-MODULE_AUTHOR("Dmitry Torokhov <dtor@mail.ru>");
-MODULE_DESCRIPTION("Input layer to RF switch connector");
-MODULE_LICENSE("GPL");
-
-enum rfkill_input_master_mode {
-        RFKILL_INPUT_MASTER_DONOTHING = 0,
-        RFKILL_INPUT_MASTER_RESTORE = 1,
-        RFKILL_INPUT_MASTER_UNBLOCKALL = 2,
-        RFKILL_INPUT_MASTER_MAX,        /* marker */
-};
-
-/* Delay (in ms) between consecutive switch ops */
-#define RFKILL_OPS_DELAY 200
-
-static enum rfkill_input_master_mode rfkill_master_switch_mode =
-                                        RFKILL_INPUT_MASTER_UNBLOCKALL;
-module_param_named(master_switch_mode, rfkill_master_switch_mode, uint, 0);
-MODULE_PARM_DESC(master_switch_mode,
-        "SW_RFKILL_ALL ON should: 0=do nothing; 1=restore; 2=unblock all");
-
-enum rfkill_global_sched_op {
-        RFKILL_GLOBAL_OP_EPO = 0,
-        RFKILL_GLOBAL_OP_RESTORE,
-        RFKILL_GLOBAL_OP_UNLOCK,
-        RFKILL_GLOBAL_OP_UNBLOCK,
-};
-
-/*
- * Currently, the code marked with RFKILL_NEED_SWSET is inactive.
- * If handling of EV_SW SW_WLAN/WWAN/BLUETOOTH/etc is needed in the
- * future, when such events are added, that code will be necessary.
- */
-
-struct rfkill_task {
-        struct delayed_work dwork;
-
-        /* ensures that task is serialized */
-        struct mutex mutex;
-
-        /* protects everything below */
-        spinlock_t lock;
-
-        /* pending regular switch operations (1=pending) */
-        unsigned long sw_pending[BITS_TO_LONGS(RFKILL_TYPE_MAX)];
-
-#ifdef RFKILL_NEED_SWSET
-        /* set operation pending (1=pending) */
-        unsigned long sw_setpending[BITS_TO_LONGS(RFKILL_TYPE_MAX)];
-
-        /* desired state for pending set operation (1=unblock) */
-        unsigned long sw_newstate[BITS_TO_LONGS(RFKILL_TYPE_MAX)];
-#endif
-
-        /* should the state be complemented (1=yes) */
-        unsigned long sw_togglestate[BITS_TO_LONGS(RFKILL_TYPE_MAX)];
-
-        bool global_op_pending;
-        enum rfkill_global_sched_op op;
-
-        /* last time it was scheduled */
-        unsigned long last_scheduled;
-};
-
-static void __rfkill_handle_global_op(enum rfkill_global_sched_op op)
-{
-        unsigned int i;
-
-        switch (op) {
-        case RFKILL_GLOBAL_OP_EPO:
-                rfkill_epo();
-                break;
-        case RFKILL_GLOBAL_OP_RESTORE:
-                rfkill_restore_states();
-                break;
-        case RFKILL_GLOBAL_OP_UNLOCK:
-                rfkill_remove_epo_lock();
-                break;
-        case RFKILL_GLOBAL_OP_UNBLOCK:
-                rfkill_remove_epo_lock();
-                for (i = 0; i < RFKILL_TYPE_MAX; i++)
-                        rfkill_switch_all(i, RFKILL_STATE_UNBLOCKED);
-                break;
-        default:
-                /* memory corruption or bug, fail safely */
-                rfkill_epo();
-                WARN(1, "Unknown requested operation %d! "
-                        "rfkill Emergency Power Off activated\n",
-                        op);
-        }
-}
-
-#ifdef RFKILL_NEED_SWSET
-static void __rfkill_handle_normal_op(const enum rfkill_type type,
-                        const bool sp, const bool s, const bool c)
-{
-        enum rfkill_state state;
-
-        if (sp)
-                state = (s) ? RFKILL_STATE_UNBLOCKED :
-                              RFKILL_STATE_SOFT_BLOCKED;
-        else
-                state = rfkill_get_global_state(type);
-
-        if (c)
-                state = rfkill_state_complement(state);
-
-        rfkill_switch_all(type, state);
-}
-#else
-static void __rfkill_handle_normal_op(const enum rfkill_type type,
-                        const bool c)
-{
-        enum rfkill_state state;
-
-        state = rfkill_get_global_state(type);
-        if (c)
-                state = rfkill_state_complement(state);
-
-        rfkill_switch_all(type, state);
-}
-#endif
-
-static void rfkill_task_handler(struct work_struct *work)
-{
-        struct rfkill_task *task = container_of(work,
-                                        struct rfkill_task, dwork.work);
-        bool doit = true;
-
-        mutex_lock(&task->mutex);
-
-        spin_lock_irq(&task->lock);
-        while (doit) {
-                if (task->global_op_pending) {
-                        enum rfkill_global_sched_op op = task->op;
-                        task->global_op_pending = false;
-                        memset(task->sw_pending, 0, sizeof(task->sw_pending));
-                        spin_unlock_irq(&task->lock);
-
-                        __rfkill_handle_global_op(op);
-
-                        /* make sure we do at least one pass with
-                         * !task->global_op_pending */
-                        spin_lock_irq(&task->lock);
-                        continue;
-                } else if (!rfkill_is_epo_lock_active()) {
-                        unsigned int i = 0;
-
-                        while (!task->global_op_pending &&
-                                                i < RFKILL_TYPE_MAX) {
-                                if (test_and_clear_bit(i, task->sw_pending)) {
-                                        bool c;
-#ifdef RFKILL_NEED_SWSET
-                                        bool sp, s;
-                                        sp = test_and_clear_bit(i,
-                                                        task->sw_setpending);
-                                        s = test_bit(i, task->sw_newstate);
-#endif
-                                        c = test_and_clear_bit(i,
-                                                        task->sw_togglestate);
-                                        spin_unlock_irq(&task->lock);
-
-#ifdef RFKILL_NEED_SWSET
-                                        __rfkill_handle_normal_op(i, sp, s, c);
-#else
-                                        __rfkill_handle_normal_op(i, c);
-#endif
-
-                                        spin_lock_irq(&task->lock);
-                                }
-                                i++;
-                        }
-                }
-                doit = task->global_op_pending;
-        }
-        spin_unlock_irq(&task->lock);
-
-        mutex_unlock(&task->mutex);
-}
-
-static struct rfkill_task rfkill_task = {
-        .dwork = __DELAYED_WORK_INITIALIZER(rfkill_task.dwork,
-                                rfkill_task_handler),
-        .mutex = __MUTEX_INITIALIZER(rfkill_task.mutex),
-        .lock = __SPIN_LOCK_UNLOCKED(rfkill_task.lock),
-};
-
-static unsigned long rfkill_ratelimit(const unsigned long last)
-{
-        const unsigned long delay = msecs_to_jiffies(RFKILL_OPS_DELAY);
-        return (time_after(jiffies, last + delay)) ? 0 : delay;
-}
-
-static void rfkill_schedule_ratelimited(void)
-{
-        if (!delayed_work_pending(&rfkill_task.dwork)) {
-                schedule_delayed_work(&rfkill_task.dwork,
-                                rfkill_ratelimit(rfkill_task.last_scheduled));
-                rfkill_task.last_scheduled = jiffies;
-        }
-}
-
-static void rfkill_schedule_global_op(enum rfkill_global_sched_op op)
-{
-        unsigned long flags;
-
-        spin_lock_irqsave(&rfkill_task.lock, flags);
-        rfkill_task.op = op;
-        rfkill_task.global_op_pending = true;
-        if (op == RFKILL_GLOBAL_OP_EPO && !rfkill_is_epo_lock_active()) {
-                /* bypass the limiter for EPO */
-                cancel_delayed_work(&rfkill_task.dwork);
-                schedule_delayed_work(&rfkill_task.dwork, 0);
-                rfkill_task.last_scheduled = jiffies;
-        } else
-                rfkill_schedule_ratelimited();
-        spin_unlock_irqrestore(&rfkill_task.lock, flags);
-}
-
-#ifdef RFKILL_NEED_SWSET
-/* Use this if you need to add EV_SW SW_WLAN/WWAN/BLUETOOTH/etc handling */
-
-static void rfkill_schedule_set(enum rfkill_type type,
-                                enum rfkill_state desired_state)
-{
-        unsigned long flags;
-
-        if (rfkill_is_epo_lock_active())
-                return;
-
-        spin_lock_irqsave(&rfkill_task.lock, flags);
-        if (!rfkill_task.global_op_pending) {
-                set_bit(type, rfkill_task.sw_pending);
-                set_bit(type, rfkill_task.sw_setpending);
-                clear_bit(type, rfkill_task.sw_togglestate);
-                if (desired_state)
-                        set_bit(type,  rfkill_task.sw_newstate);
-                else
-                        clear_bit(type, rfkill_task.sw_newstate);
-                rfkill_schedule_ratelimited();
-        }
-        spin_unlock_irqrestore(&rfkill_task.lock, flags);
-}
-#endif
-
-static void rfkill_schedule_toggle(enum rfkill_type type)
-{
-        unsigned long flags;
-
-        if (rfkill_is_epo_lock_active())
-                return;
-
-        spin_lock_irqsave(&rfkill_task.lock, flags);
-        if (!rfkill_task.global_op_pending) {
-                set_bit(type, rfkill_task.sw_pending);
-                change_bit(type, rfkill_task.sw_togglestate);
-                rfkill_schedule_ratelimited();
-        }
-        spin_unlock_irqrestore(&rfkill_task.lock, flags);
-}
-
-static void rfkill_schedule_evsw_rfkillall(int state)
-{
-        if (state) {
-                switch (rfkill_master_switch_mode) {
-                case RFKILL_INPUT_MASTER_UNBLOCKALL:
-                        rfkill_schedule_global_op(RFKILL_GLOBAL_OP_UNBLOCK);
-                        break;
-                case RFKILL_INPUT_MASTER_RESTORE:
-                        rfkill_schedule_global_op(RFKILL_GLOBAL_OP_RESTORE);
-                        break;
-                case RFKILL_INPUT_MASTER_DONOTHING:
-                        rfkill_schedule_global_op(RFKILL_GLOBAL_OP_UNLOCK);
-                        break;
-                default:
-                        /* memory corruption or driver bug! fail safely */
-                        rfkill_schedule_global_op(RFKILL_GLOBAL_OP_EPO);
-                        WARN(1, "Unknown rfkill_master_switch_mode (%d), "
-                                "driver bug or memory corruption detected!\n",
-                                rfkill_master_switch_mode);
-                        break;
-                }
-        } else
-                rfkill_schedule_global_op(RFKILL_GLOBAL_OP_EPO);
-}
-
-static void rfkill_event(struct input_handle *handle, unsigned int type,
-                        unsigned int code, int data)
-{
-        if (type == EV_KEY && data == 1) {
-                enum rfkill_type t;
-
-                switch (code) {
-                case KEY_WLAN:
-                        t = RFKILL_TYPE_WLAN;
-                        break;
-                case KEY_BLUETOOTH:
-                        t = RFKILL_TYPE_BLUETOOTH;
-                        break;
-                case KEY_UWB:
-                        t = RFKILL_TYPE_UWB;
-                        break;
-                case KEY_WIMAX:
-                        t = RFKILL_TYPE_WIMAX;
-                        break;
-                default:
-                        return;
-                }
-                rfkill_schedule_toggle(t);
-                return;
-        } else if (type == EV_SW) {
-                switch (code) {
-                case SW_RFKILL_ALL:
-                        rfkill_schedule_evsw_rfkillall(data);
-                        return;
-                default:
-                        return;
-                }
-        }
-}
-
-static int rfkill_connect(struct input_handler *handler, struct input_dev *dev,
-                          const struct input_device_id *id)
-{
-        struct input_handle *handle;
-        int error;
-
-        handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
-        if (!handle)
-                return -ENOMEM;
-
-        handle->dev = dev;
-        handle->handler = handler;
-        handle->name = "rfkill";
-
-        /* causes rfkill_start() to be called */
-        error = input_register_handle(handle);
-        if (error)
-                goto err_free_handle;
-
-        error = input_open_device(handle);
-        if (error)
-                goto err_unregister_handle;
-
-        return 0;
-
- err_unregister_handle:
-        input_unregister_handle(handle);
- err_free_handle:
-        kfree(handle);
-        return error;
-}
-
-static void rfkill_start(struct input_handle *handle)
-{
-        /* Take event_lock to guard against configuration changes, we
-         * should be able to deal with concurrency with rfkill_event()
-         * just fine (which event_lock will also avoid). */
-        spin_lock_irq(&handle->dev->event_lock);
-
-        if (test_bit(EV_SW, handle->dev->evbit)) {
-                if (test_bit(SW_RFKILL_ALL, handle->dev->swbit))
-                        rfkill_schedule_evsw_rfkillall(test_bit(SW_RFKILL_ALL,
-                                                        handle->dev->sw));
-                /* add resync for further EV_SW events here */
-        }
-
-        spin_unlock_irq(&handle->dev->event_lock);
-}
-
-static void rfkill_disconnect(struct input_handle *handle)
-{
-        input_close_device(handle);
-        input_unregister_handle(handle);
-        kfree(handle);
-}
-
-static const struct input_device_id rfkill_ids[] = {
-        {
-                .flags = INPUT_DEVICE_ID_MATCH_EVBIT | INPUT_DEVICE_ID_MATCH_KEYBIT,
-                .evbit = { BIT_MASK(EV_KEY) },
-                .keybit = { [BIT_WORD(KEY_WLAN)] = BIT_MASK(KEY_WLAN) },
-        },
-        {
-                .flags = INPUT_DEVICE_ID_MATCH_EVBIT | INPUT_DEVICE_ID_MATCH_KEYBIT,
-                .evbit = { BIT_MASK(EV_KEY) },
-                .keybit = { [BIT_WORD(KEY_BLUETOOTH)] = BIT_MASK(KEY_BLUETOOTH) },
-        },
-        {
-                .flags = INPUT_DEVICE_ID_MATCH_EVBIT | INPUT_DEVICE_ID_MATCH_KEYBIT,
-                .evbit = { BIT_MASK(EV_KEY) },
-                .keybit = { [BIT_WORD(KEY_UWB)] = BIT_MASK(KEY_UWB) },
-        },
-        {
-                .flags = INPUT_DEVICE_ID_MATCH_EVBIT | INPUT_DEVICE_ID_MATCH_KEYBIT,
-                .evbit = { BIT_MASK(EV_KEY) },
-                .keybit = { [BIT_WORD(KEY_WIMAX)] = BIT_MASK(KEY_WIMAX) },
-        },
-        {
-                .flags = INPUT_DEVICE_ID_MATCH_EVBIT | INPUT_DEVICE_ID_MATCH_SWBIT,
-                .evbit = { BIT(EV_SW) },
-                .swbit = { [BIT_WORD(SW_RFKILL_ALL)] = BIT_MASK(SW_RFKILL_ALL) },
-        },
-        { }
-};
-
-static struct input_handler rfkill_handler = {
-        .event =        rfkill_event,
-        .connect =      rfkill_connect,
-        .disconnect =   rfkill_disconnect,
-        .start =        rfkill_start,
-        .name =         "rfkill",
-        .id_table =     rfkill_ids,
-};
-
-static int __init rfkill_handler_init(void)
-{
-        if (rfkill_master_switch_mode >= RFKILL_INPUT_MASTER_MAX)
-                return -EINVAL;
-
-        /*
-         * The penalty to not doing this is a possible RFKILL_OPS_DELAY delay
-         * at the first use.  Acceptable, but if we can avoid it, why not?
-         */
-        rfkill_task.last_scheduled =
-                        jiffies - msecs_to_jiffies(RFKILL_OPS_DELAY) - 1;
-        return input_register_handler(&rfkill_handler);
-}
-
-static void __exit rfkill_handler_exit(void)
-{
-        input_unregister_handler(&rfkill_handler);
-        cancel_delayed_work_sync(&rfkill_task.dwork);
-        rfkill_remove_epo_lock();
-}
-
-module_init(rfkill_handler_init);
-module_exit(rfkill_handler_exit);
diff --git a/net/rfkill/rfkill.c b/net/rfkill/rfkill.c
deleted file mode 100644
index 3eaa39403c13..000000000000
--- a/net/rfkill/rfkill.c
+++ /dev/null
@@ -1,882 +0,0 @@
-/*
- * Copyright (C) 2006 - 2007 Ivo van Doorn
- * Copyright (C) 2007 Dmitry Torokhov
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the
- * Free Software Foundation, Inc.,
- * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
- */
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/workqueue.h>
-#include <linux/capability.h>
-#include <linux/list.h>
-#include <linux/mutex.h>
-#include <linux/rfkill.h>
-
-/* Get declaration of rfkill_switch_all() to shut up sparse. */
-#include "rfkill-input.h"
-
-
-MODULE_AUTHOR("Ivo van Doorn <IvDoorn@gmail.com>");
-MODULE_VERSION("1.0");
-MODULE_DESCRIPTION("RF switch support");
-MODULE_LICENSE("GPL");
-
-static LIST_HEAD(rfkill_list);  /* list of registered rf switches */
-static DEFINE_MUTEX(rfkill_global_mutex);
-
-static unsigned int rfkill_default_state = RFKILL_STATE_UNBLOCKED;
-module_param_named(default_state, rfkill_default_state, uint, 0444);
-MODULE_PARM_DESC(default_state,
-                 "Default initial state for all radio types, 0 = radio off");
-
-struct rfkill_gsw_state {
-        enum rfkill_state current_state;
-        enum rfkill_state default_state;
-};
-
-static struct rfkill_gsw_state rfkill_global_states[RFKILL_TYPE_MAX];
-static unsigned long rfkill_states_lockdflt[BITS_TO_LONGS(RFKILL_TYPE_MAX)];
-static bool rfkill_epo_lock_active;
-
-
-#ifdef CONFIG_RFKILL_LEDS
-static void rfkill_led_trigger(struct rfkill *rfkill,
-                               enum rfkill_state state)
-{
-        struct led_trigger *led = &rfkill->led_trigger;
-
-        if (!led->name)
-                return;
-        if (state != RFKILL_STATE_UNBLOCKED)
-                led_trigger_event(led, LED_OFF);
-        else
-                led_trigger_event(led, LED_FULL);
-}
-
-static void rfkill_led_trigger_activate(struct led_classdev *led)
-{
-        struct rfkill *rfkill = container_of(led->trigger,
-                        struct rfkill, led_trigger);
-
-        rfkill_led_trigger(rfkill, rfkill->state);
-}
-#endif /* CONFIG_RFKILL_LEDS */
-
-static void rfkill_uevent(struct rfkill *rfkill)
-{
-        kobject_uevent(&rfkill->dev.kobj, KOBJ_CHANGE);
-}
-
-static void update_rfkill_state(struct rfkill *rfkill)
-{
-        enum rfkill_state newstate, oldstate;
-
-        if (rfkill->get_state) {
-                mutex_lock(&rfkill->mutex);
-                if (!rfkill->get_state(rfkill->data, &newstate)) {
-                        oldstate = rfkill->state;
-                        rfkill->state = newstate;
-                        if (oldstate != newstate)
-                                rfkill_uevent(rfkill);
-                }
-                mutex_unlock(&rfkill->mutex);
-        }
-}
-
-/**
- * rfkill_toggle_radio - wrapper for toggle_radio hook
- * @rfkill: the rfkill struct to use
- * @force: calls toggle_radio even if cache says it is not needed,
- *      and also makes sure notifications of the state will be
- *      sent even if it didn't change
- * @state: the new state to call toggle_radio() with
- *
- * Calls rfkill->toggle_radio, enforcing the API for toggle_radio
- * calls and handling all the red tape such as issuing notifications
- * if the call is successful.
- *
- * Suspended devices are not touched at all, and -EAGAIN is returned.
- *
- * Note that the @force parameter cannot override a (possibly cached)
- * state of RFKILL_STATE_HARD_BLOCKED.  Any device making use of
- * RFKILL_STATE_HARD_BLOCKED implements either get_state() or
- * rfkill_force_state(), so the cache either is bypassed or valid.
- *
- * Note that we do call toggle_radio for RFKILL_STATE_SOFT_BLOCKED
- * even if the radio is in RFKILL_STATE_HARD_BLOCKED state, so as to
- * give the driver a hint that it should double-BLOCK the transmitter.
- *
- * Caller must have acquired rfkill->mutex.
- */
-static int rfkill_toggle_radio(struct rfkill *rfkill,
-                                enum rfkill_state state,
-                                int force)
-{
-        int retval = 0;
-        enum rfkill_state oldstate, newstate;
-
-        if (unlikely(rfkill->dev.power.power_state.event & PM_EVENT_SLEEP))
-                return -EBUSY;
-
-        oldstate = rfkill->state;
-
-        if (rfkill->get_state && !force &&
-            !rfkill->get_state(rfkill->data, &newstate))
-                rfkill->state = newstate;
-
-        switch (state) {
-        case RFKILL_STATE_HARD_BLOCKED:
-                /* typically happens when refreshing hardware state,
-                 * such as on resume */
-                state = RFKILL_STATE_SOFT_BLOCKED;
-                break;
-        case RFKILL_STATE_UNBLOCKED:
-                /* force can't override this, only rfkill_force_state() can */
-                if (rfkill->state == RFKILL_STATE_HARD_BLOCKED)
-                        return -EPERM;
-                break;
-        case RFKILL_STATE_SOFT_BLOCKED:
-                /* nothing to do, we want to give drivers the hint to double
-                 * BLOCK even a transmitter that is already in state
-                 * RFKILL_STATE_HARD_BLOCKED */
-                break;
-        default:
-                WARN(1, KERN_WARNING
-                        "rfkill: illegal state %d passed as parameter "
-                        "to rfkill_toggle_radio\n", state);
-                return -EINVAL;
-        }
-
-        if (force || state != rfkill->state) {
-                retval = rfkill->toggle_radio(rfkill->data, state);
-                /* never allow a HARD->SOFT downgrade! */
-                if (!retval && rfkill->state != RFKILL_STATE_HARD_BLOCKED)
-                        rfkill->state = state;
-        }
-
-        if (force || rfkill->state != oldstate)
-                rfkill_uevent(rfkill);
-
-        return retval;
-}
-
-/**
- * __rfkill_switch_all - Toggle state of all switches of given type
- * @type: type of interfaces to be affected
- * @state: the new state
- *
- * This function toggles the state of all switches of given type,
- * unless a specific switch is claimed by userspace (in which case,
- * that switch is left alone) or suspended.
- *
- * Caller must have acquired rfkill_global_mutex.
- */
-static void __rfkill_switch_all(const enum rfkill_type type,
-                                const enum rfkill_state state)
-{
-        struct rfkill *rfkill;
-
-        if (WARN((state >= RFKILL_STATE_MAX || type >= RFKILL_TYPE_MAX),
-                        KERN_WARNING
-                        "rfkill: illegal state %d or type %d "
-                        "passed as parameter to __rfkill_switch_all\n",
-                        state, type))
-                return;
-
-        rfkill_global_states[type].current_state = state;
-        list_for_each_entry(rfkill, &rfkill_list, node) {
-                if ((!rfkill->user_claim) && (rfkill->type == type)) {
-                        mutex_lock(&rfkill->mutex);
-                        rfkill_toggle_radio(rfkill, state, 0);
-                        mutex_unlock(&rfkill->mutex);
-                }
-        }
-}
-
-/**
- * rfkill_switch_all - Toggle state of all switches of given type
- * @type: type of interfaces to be affected
- * @state: the new state
- *
- * Acquires rfkill_global_mutex and calls __rfkill_switch_all(@type, @state).
- * Please refer to __rfkill_switch_all() for details.
- *
- * Does nothing if the EPO lock is active.
- */
-void rfkill_switch_all(enum rfkill_type type, enum rfkill_state state)
-{
-        mutex_lock(&rfkill_global_mutex);
-        if (!rfkill_epo_lock_active)
-                __rfkill_switch_all(type, state);
-        mutex_unlock(&rfkill_global_mutex);
-}
-EXPORT_SYMBOL(rfkill_switch_all);
-
-/**
- * rfkill_epo - emergency power off all transmitters
- *
- * This kicks all non-suspended rfkill devices to RFKILL_STATE_SOFT_BLOCKED,
- * ignoring everything in its path but rfkill_global_mutex and rfkill->mutex.
- *
- * The global state before the EPO is saved and can be restored later
- * using rfkill_restore_states().
- */
-void rfkill_epo(void)
-{
-        struct rfkill *rfkill;
-        int i;
-
-        mutex_lock(&rfkill_global_mutex);
-
-        rfkill_epo_lock_active = true;
-        list_for_each_entry(rfkill, &rfkill_list, node) {
-                mutex_lock(&rfkill->mutex);
-                rfkill_toggle_radio(rfkill, RFKILL_STATE_SOFT_BLOCKED, 1);
-                mutex_unlock(&rfkill->mutex);
-        }
-        for (i = 0; i < RFKILL_TYPE_MAX; i++) {
-                rfkill_global_states[i].default_state =
-                                rfkill_global_states[i].current_state;
-                rfkill_global_states[i].current_state =
-                                RFKILL_STATE_SOFT_BLOCKED;
-        }
-        mutex_unlock(&rfkill_global_mutex);
-}
-EXPORT_SYMBOL_GPL(rfkill_epo);
-
-/**
- * rfkill_restore_states - restore global states
- *
- * Restore (and sync switches to) the global state from the
- * states in rfkill_default_states.  This can undo the effects of
- * a call to rfkill_epo().
- */
-void rfkill_restore_states(void)
-{
-        int i;
-
-        mutex_lock(&rfkill_global_mutex);
-
-        rfkill_epo_lock_active = false;
-        for (i = 0; i < RFKILL_TYPE_MAX; i++)
-                __rfkill_switch_all(i, rfkill_global_states[i].default_state);
-        mutex_unlock(&rfkill_global_mutex);
-}
-EXPORT_SYMBOL_GPL(rfkill_restore_states);
-
-/**
- * rfkill_remove_epo_lock - unlock state changes
- *
- * Used by rfkill-input manually unlock state changes, when
- * the EPO switch is deactivated.
- */
-void rfkill_remove_epo_lock(void)
-{
-        mutex_lock(&rfkill_global_mutex);
-        rfkill_epo_lock_active = false;
-        mutex_unlock(&rfkill_global_mutex);
-}
-EXPORT_SYMBOL_GPL(rfkill_remove_epo_lock);
-
-/**
- * rfkill_is_epo_lock_active - returns true EPO is active
- *
- * Returns 0 (false) if there is NOT an active EPO contidion,
- * and 1 (true) if there is an active EPO contition, which
- * locks all radios in one of the BLOCKED states.
- *
- * Can be called in atomic context.
- */
-bool rfkill_is_epo_lock_active(void)
-{
-        return rfkill_epo_lock_active;
-}
-EXPORT_SYMBOL_GPL(rfkill_is_epo_lock_active);
-
-/**
- * rfkill_get_global_state - returns global state for a type
- * @type: the type to get the global state of
- *
- * Returns the current global state for a given wireless
- * device type.
- */
-enum rfkill_state rfkill_get_global_state(const enum rfkill_type type)
-{
-        return rfkill_global_states[type].current_state;
-}
-EXPORT_SYMBOL_GPL(rfkill_get_global_state);
-
-/**
- * rfkill_force_state - Force the internal rfkill radio state
- * @rfkill: pointer to the rfkill class to modify.
- * @state: the current radio state the class should be forced to.
- *
- * This function updates the internal state of the radio cached
- * by the rfkill class.  It should be used when the driver gets
- * a notification by the firmware/hardware of the current *real*
- * state of the radio rfkill switch.
- *
- * Devices which are subject to external changes on their rfkill
- * state (such as those caused by a hardware rfkill line) MUST
- * have their driver arrange to call rfkill_force_state() as soon
- * as possible after such a change.
- *
- * This function may not be called from an atomic context.
- */
-int rfkill_force_state(struct rfkill *rfkill, enum rfkill_state state)
-{
-        enum rfkill_state oldstate;
-
-        BUG_ON(!rfkill);
-        if (WARN((state >= RFKILL_STATE_MAX),
-                        KERN_WARNING
-                        "rfkill: illegal state %d passed as parameter "
-                        "to rfkill_force_state\n", state))
-                return -EINVAL;
-
-        mutex_lock(&rfkill->mutex);
-
-        oldstate = rfkill->state;
-        rfkill->state = state;
-
-        if (state != oldstate)
-                rfkill_uevent(rfkill);
-
-        mutex_unlock(&rfkill->mutex);
-
-        return 0;
-}
-EXPORT_SYMBOL(rfkill_force_state);
-
-static ssize_t rfkill_name_show(struct device *dev,
-                                struct device_attribute *attr,
-                                char *buf)
-{
-        struct rfkill *rfkill = to_rfkill(dev);
-
-        return sprintf(buf, "%s\n", rfkill->name);
-}
-
-static const char *rfkill_get_type_str(enum rfkill_type type)
-{
-        switch (type) {
-        case RFKILL_TYPE_WLAN:
-                return "wlan";
-        case RFKILL_TYPE_BLUETOOTH:
-                return "bluetooth";
-        case RFKILL_TYPE_UWB:
-                return "ultrawideband";
-        case RFKILL_TYPE_WIMAX:
-                return "wimax";
-        case RFKILL_TYPE_WWAN:
-                return "wwan";
-        default:
-                BUG();
-        }
-}
-
-static ssize_t rfkill_type_show(struct device *dev,
-                                struct device_attribute *attr,
-                                char *buf)
-{
-        struct rfkill *rfkill = to_rfkill(dev);
-
-        return sprintf(buf, "%s\n", rfkill_get_type_str(rfkill->type));
-}
-
-static ssize_t rfkill_state_show(struct device *dev,
-                                 struct device_attribute *attr,
-                                 char *buf)
-{
-        struct rfkill *rfkill = to_rfkill(dev);
-
-        update_rfkill_state(rfkill);
-        return sprintf(buf, "%d\n", rfkill->state);
-}
-
-static ssize_t rfkill_state_store(struct device *dev,
-                                  struct device_attribute *attr,
-                                  const char *buf, size_t count)
-{
-        struct rfkill *rfkill = to_rfkill(dev);
-        unsigned long state;
-        int error;
-
-        if (!capable(CAP_NET_ADMIN))
-                return -EPERM;
-
-        error = strict_strtoul(buf, 0, &state);
-        if (error)
-                return error;
-
-        /* RFKILL_STATE_HARD_BLOCKED is illegal here... */
-        if (state != RFKILL_STATE_UNBLOCKED &&
-            state != RFKILL_STATE_SOFT_BLOCKED)
-                return -EINVAL;
-
-        error = mutex_lock_killable(&rfkill->mutex);
-        if (error)
-                return error;
-
-        if (!rfkill_epo_lock_active)
-                error = rfkill_toggle_radio(rfkill, state, 0);
-        else
-                error = -EPERM;
-
-        mutex_unlock(&rfkill->mutex);
-
-        return error ? error : count;
-}
-
-static ssize_t rfkill_claim_show(struct device *dev,
-                                 struct device_attribute *attr,
-                                 char *buf)
-{
-        struct rfkill *rfkill = to_rfkill(dev);
-
-        return sprintf(buf, "%d\n", rfkill->user_claim);
-}
-
-static ssize_t rfkill_claim_store(struct device *dev,
-                                  struct device_attribute *attr,
-                                  const char *buf, size_t count)
-{
-        struct rfkill *rfkill = to_rfkill(dev);
-        unsigned long claim_tmp;
-        bool claim;
-        int error;
-
-        if (!capable(CAP_NET_ADMIN))
-                return -EPERM;
-
-        if (rfkill->user_claim_unsupported)
-                return -EOPNOTSUPP;
-
-        error = strict_strtoul(buf, 0, &claim_tmp);
-        if (error)
-                return error;
-        claim = !!claim_tmp;
-
-        /*
-         * Take the global lock to make sure the kernel is not in
-         * the middle of rfkill_switch_all
-         */
-        error = mutex_lock_killable(&rfkill_global_mutex);
-        if (error)
-                return error;
-
-        if (rfkill->user_claim != claim) {
-                if (!claim && !rfkill_epo_lock_active) {
-                        mutex_lock(&rfkill->mutex);
-                        rfkill_toggle_radio(rfkill,
-                                        rfkill_global_states[rfkill->type].current_state,
-                                        0);
-                        mutex_unlock(&rfkill->mutex);
-                }
-                rfkill->user_claim = claim;
-        }
-
-        mutex_unlock(&rfkill_global_mutex);
-
-        return error ? error : count;
-}
-
-static struct device_attribute rfkill_dev_attrs[] = {
-        __ATTR(name, S_IRUGO, rfkill_name_show, NULL),
-        __ATTR(type, S_IRUGO, rfkill_type_show, NULL),
-        __ATTR(state, S_IRUGO|S_IWUSR, rfkill_state_show, rfkill_state_store),
-        __ATTR(claim, S_IRUGO|S_IWUSR, rfkill_claim_show, rfkill_claim_store),
-        __ATTR_NULL
-};
-
-static void rfkill_release(struct device *dev)
-{
-        struct rfkill *rfkill = to_rfkill(dev);
-
-        kfree(rfkill);
-        module_put(THIS_MODULE);
-}
-
-#ifdef CONFIG_PM
-static int rfkill_suspend(struct device *dev, pm_message_t state)
-{
-        struct rfkill *rfkill = to_rfkill(dev);
-
-        /* mark class device as suspended */
-        if (dev->power.power_state.event != state.event)
-                dev->power.power_state = state;
-
-        /* store state for the resume handler */
-        rfkill->state_for_resume = rfkill->state;
-
-        return 0;
-}
-
-static int rfkill_resume(struct device *dev)
-{
-        struct rfkill *rfkill = to_rfkill(dev);
-        enum rfkill_state newstate;
-
-        if (dev->power.power_state.event != PM_EVENT_ON) {
-                mutex_lock(&rfkill->mutex);
-
-                dev->power.power_state.event = PM_EVENT_ON;
-
-                /*
-                 * rfkill->state could have been modified before we got
-                 * called, and won't be updated by rfkill_toggle_radio()
-                 * in force mode.  Sync it FIRST.
-                 */
-                if (rfkill->get_state &&
-                    !rfkill->get_state(rfkill->data, &newstate))
-                        rfkill->state = newstate;
-
-                /*
-                 * If we are under EPO, kick transmitter offline,
-                 * otherwise restore to pre-suspend state.
-                 *
-                 * Issue a notification in any case
-                 */
-                rfkill_toggle_radio(rfkill,
-                                rfkill_epo_lock_active ?
-                                        RFKILL_STATE_SOFT_BLOCKED :
-                                        rfkill->state_for_resume,
-                                1);
-
-                mutex_unlock(&rfkill->mutex);
-        }
-
-        return 0;
-}
-#else
-#define rfkill_suspend NULL
-#define rfkill_resume NULL
-#endif
-
-static int rfkill_dev_uevent(struct device *dev, struct kobj_uevent_env *env)
-{
-        struct rfkill *rfkill = to_rfkill(dev);
-        int error;
-
-        error = add_uevent_var(env, "RFKILL_NAME=%s", rfkill->name);
-        if (error)
-                return error;
-        error = add_uevent_var(env, "RFKILL_TYPE=%s",
-                                rfkill_get_type_str(rfkill->type));
-        if (error)
-                return error;
-        error = add_uevent_var(env, "RFKILL_STATE=%d", rfkill->state);
-        return error;
-}
-
-static struct class rfkill_class = {
-        .name           = "rfkill",
-        .dev_release    = rfkill_release,
-        .dev_attrs      = rfkill_dev_attrs,
-        .suspend        = rfkill_suspend,
-        .resume         = rfkill_resume,
-        .dev_uevent     = rfkill_dev_uevent,
-};
-
-static int rfkill_check_duplicity(const struct rfkill *rfkill)
-{
-        struct rfkill *p;
-        unsigned long seen[BITS_TO_LONGS(RFKILL_TYPE_MAX)];
-
-        memset(seen, 0, sizeof(seen));
-
-        list_for_each_entry(p, &rfkill_list, node) {
-                if (WARN((p == rfkill), KERN_WARNING
-                                "rfkill: illegal attempt to register "
-                                "an already registered rfkill struct\n"))
-                        return -EEXIST;
-                set_bit(p->type, seen);
-        }
-
-        /* 0: first switch of its kind */
-        return (test_bit(rfkill->type, seen)) ? 1 : 0;
-}
-
-static int rfkill_add_switch(struct rfkill *rfkill)
-{
-        int error;
-
-        mutex_lock(&rfkill_global_mutex);
-
-        error = rfkill_check_duplicity(rfkill);
-        if (error < 0)
-                goto unlock_out;
-
-        if (!error) {
-                /* lock default after first use */
-                set_bit(rfkill->type, rfkill_states_lockdflt);
-                rfkill_global_states[rfkill->type].current_state =
-                        rfkill_global_states[rfkill->type].default_state;
-        }
-
-        rfkill_toggle_radio(rfkill,
-                            rfkill_global_states[rfkill->type].current_state,
-                            0);
-
-        list_add_tail(&rfkill->node, &rfkill_list);
-
-        error = 0;
-unlock_out:
-        mutex_unlock(&rfkill_global_mutex);
-
-        return error;
-}
-
-static void rfkill_remove_switch(struct rfkill *rfkill)
-{
-        mutex_lock(&rfkill_global_mutex);
-        list_del_init(&rfkill->node);
-        mutex_unlock(&rfkill_global_mutex);
-
-        mutex_lock(&rfkill->mutex);
-        rfkill_toggle_radio(rfkill, RFKILL_STATE_SOFT_BLOCKED, 1);
-        mutex_unlock(&rfkill->mutex);
-}
-
-/**
- * rfkill_allocate - allocate memory for rfkill structure.
- * @parent: device that has rf switch on it
- * @type: type of the switch (RFKILL_TYPE_*)
- *
- * This function should be called by the network driver when it needs
- * rfkill structure.  Once the structure is allocated the driver should
- * finish its initialization by setting the name, private data, enable_radio
- * and disable_radio methods and then register it with rfkill_register().
- *
- * NOTE: If registration fails the structure shoudl be freed by calling
- * rfkill_free() otherwise rfkill_unregister() should be used.
- */
-struct rfkill * __must_check rfkill_allocate(struct device *parent,
-                                             enum rfkill_type type)
-{
-        struct rfkill *rfkill;
-        struct device *dev;
-
-        if (WARN((type >= RFKILL_TYPE_MAX),
-                        KERN_WARNING
-                        "rfkill: illegal type %d passed as parameter "
-                        "to rfkill_allocate\n", type))
-                return NULL;
-
-        rfkill = kzalloc(sizeof(struct rfkill), GFP_KERNEL);
-        if (!rfkill)
-                return NULL;
-
-        mutex_init(&rfkill->mutex);
-        INIT_LIST_HEAD(&rfkill->node);
-        rfkill->type = type;
-
-        dev = &rfkill->dev;
-        dev->class = &rfkill_class;
-        dev->parent = parent;
-        device_initialize(dev);
-
-        __module_get(THIS_MODULE);
-
-        return rfkill;
-}
-EXPORT_SYMBOL(rfkill_allocate);
-
-/**
- * rfkill_free - Mark rfkill structure for deletion
- * @rfkill: rfkill structure to be destroyed
- *
- * Decrements reference count of the rfkill structure so it is destroyed.
- * Note that rfkill_free() should _not_ be called after rfkill_unregister().
- */
-void rfkill_free(struct rfkill *rfkill)
-{
-        if (rfkill)
-                put_device(&rfkill->dev);
-}
-EXPORT_SYMBOL(rfkill_free);
-
-static void rfkill_led_trigger_register(struct rfkill *rfkill)
-{
-#ifdef CONFIG_RFKILL_LEDS
-        int error;
-
-        if (!rfkill->led_trigger.name)
-                rfkill->led_trigger.name = dev_name(&rfkill->dev);
-        if (!rfkill->led_trigger.activate)
-                rfkill->led_trigger.activate = rfkill_led_trigger_activate;
-        error = led_trigger_register(&rfkill->led_trigger);
-        if (error)
-                rfkill->led_trigger.name = NULL;
-#endif /* CONFIG_RFKILL_LEDS */
-}
-
-static void rfkill_led_trigger_unregister(struct rfkill *rfkill)
-{
-#ifdef CONFIG_RFKILL_LEDS
-        if (rfkill->led_trigger.name) {
-                led_trigger_unregister(&rfkill->led_trigger);
-                rfkill->led_trigger.name = NULL;
-        }
-#endif
-}
-
-/**
- * rfkill_register - Register a rfkill structure.
- * @rfkill: rfkill structure to be registered
- *
- * This function should be called by the network driver when the rfkill
- * structure needs to be registered. Immediately from registration the
- * switch driver should be able to service calls to toggle_radio.
- */
-int __must_check rfkill_register(struct rfkill *rfkill)
-{
-        static atomic_t rfkill_no = ATOMIC_INIT(0);
-        struct device *dev = &rfkill->dev;
-        int error;
-
-        if (WARN((!rfkill || !rfkill->toggle_radio ||
-                        rfkill->type >= RFKILL_TYPE_MAX ||
-                        rfkill->state >= RFKILL_STATE_MAX),
-                        KERN_WARNING
-                        "rfkill: attempt to register a "
-                        "badly initialized rfkill struct\n"))
-                return -EINVAL;
-
-        dev_set_name(dev, "rfkill%ld", (long)atomic_inc_return(&rfkill_no) - 1);
-
-        rfkill_led_trigger_register(rfkill);
-
-        error = rfkill_add_switch(rfkill);
-        if (error) {
-                rfkill_led_trigger_unregister(rfkill);
-                return error;
-        }
-
-        error = device_add(dev);
-        if (error) {
-                rfkill_remove_switch(rfkill);
-                rfkill_led_trigger_unregister(rfkill);
-                return error;
-        }
-
-        return 0;
-}
-EXPORT_SYMBOL(rfkill_register);
-
-/**
- * rfkill_unregister - Unregister a rfkill structure.
- * @rfkill: rfkill structure to be unregistered
- *
- * This function should be called by the network driver during device
- * teardown to destroy rfkill structure. Note that rfkill_free() should
- * _not_ be called after rfkill_unregister().
- */
-void rfkill_unregister(struct rfkill *rfkill)
-{
-        BUG_ON(!rfkill);
-        device_del(&rfkill->dev);
-        rfkill_remove_switch(rfkill);
-        rfkill_led_trigger_unregister(rfkill);
-        put_device(&rfkill->dev);
-}
-EXPORT_SYMBOL(rfkill_unregister);
-
-/**
- * rfkill_set_default - set initial value for a switch type
- * @type - the type of switch to set the default state of
- * @state - the new default state for that group of switches
- *
- * Sets the initial state rfkill should use for a given type.
- * The following initial states are allowed: RFKILL_STATE_SOFT_BLOCKED
- * and RFKILL_STATE_UNBLOCKED.
- *
- * This function is meant to be used by platform drivers for platforms
- * that can save switch state across power down/reboot.
- *
- * The default state for each switch type can be changed exactly once.
- * After a switch of that type is registered, the default state cannot
- * be changed anymore.  This guards against multiple drivers it the
- * same platform trying to set the initial switch default state, which
- * is not allowed.
- *
- * Returns -EPERM if the state has already been set once or is in use,
- * so drivers likely want to either ignore or at most printk(KERN_NOTICE)
- * if this function returns -EPERM.
- *
- * Returns 0 if the new default state was set, or an error if it
- * could not be set.
- */
-int rfkill_set_default(enum rfkill_type type, enum rfkill_state state)
-{
-        int error;
-
-        if (WARN((type >= RFKILL_TYPE_MAX ||
-                        (state != RFKILL_STATE_SOFT_BLOCKED &&
-                         state != RFKILL_STATE_UNBLOCKED)),
-                        KERN_WARNING
-                        "rfkill: illegal state %d or type %d passed as "
-                        "parameter to rfkill_set_default\n", state, type))
-                return -EINVAL;
-
-        mutex_lock(&rfkill_global_mutex);
-
-        if (!test_and_set_bit(type, rfkill_states_lockdflt)) {
-                rfkill_global_states[type].default_state = state;
-                rfkill_global_states[type].current_state = state;
-                error = 0;
-        } else
-                error = -EPERM;
-
-        mutex_unlock(&rfkill_global_mutex);
-        return error;
-}
-EXPORT_SYMBOL_GPL(rfkill_set_default);
-
-/*
- * Rfkill module initialization/deinitialization.
- */
-static int __init rfkill_init(void)
-{
-        int error;
-        int i;
-
-        /* RFKILL_STATE_HARD_BLOCKED is illegal here... */
-        if (rfkill_default_state != RFKILL_STATE_SOFT_BLOCKED &&
-            rfkill_default_state != RFKILL_STATE_UNBLOCKED)
-                return -EINVAL;
-
-        for (i = 0; i < RFKILL_TYPE_MAX; i++)
-                rfkill_global_states[i].default_state = rfkill_default_state;
-
-        error = class_register(&rfkill_class);
-        if (error) {
-                printk(KERN_ERR "rfkill: unable to register rfkill class\n");
-                return error;
-        }
-
-        return 0;
-}
-
-static void __exit rfkill_exit(void)
-{
-        class_unregister(&rfkill_class);
-}
-
-subsys_initcall(rfkill_init);
-module_exit(rfkill_exit);
diff --git a/net/rfkill/rfkill-input.h b/net/rfkill/rfkill.h
index fe8df6b5b935..d1117cb6e4de 100644
--- a/net/rfkill/rfkill-input.h
+++ b/net/rfkill/rfkill.h
@@ -1,5 +1,6 @@
 /*
  * Copyright (C) 2007 Ivo van Doorn
+ * Copyright 2009 Johannes Berg <johannes@sipsolutions.net>
  */
 
 /*
@@ -11,11 +12,16 @@
 #ifndef __RFKILL_INPUT_H
 #define __RFKILL_INPUT_H
 
-void rfkill_switch_all(enum rfkill_type type, enum rfkill_state state);
+/* core code */
+void rfkill_switch_all(const enum rfkill_type type, bool blocked);
 void rfkill_epo(void);
 void rfkill_restore_states(void);
 void rfkill_remove_epo_lock(void);
 bool rfkill_is_epo_lock_active(void);
-enum rfkill_state rfkill_get_global_state(const enum rfkill_type type);
+bool rfkill_get_global_sw_state(const enum rfkill_type type);
+
+/* input handler */
+int rfkill_handler_init(void);
+void rfkill_handler_exit(void);
 
 #endif /* __RFKILL_INPUT_H */
diff --git a/net/rose/rose_dev.c b/net/rose/rose_dev.c
index 7dcf2569613b..389d6e0d7740 100644
--- a/net/rose/rose_dev.c
+++ b/net/rose/rose_dev.c
@@ -137,7 +137,7 @@ static int rose_xmit(struct sk_buff *skb, struct net_device *dev)
 
         if (!netif_running(dev)) {
                 printk(KERN_ERR "ROSE: rose_xmit - called when iface is down\n");
-                return 1;
+                return NETDEV_TX_BUSY;
         }
         dev_kfree_skb(skb);
         stats->tx_errors++;
diff --git a/net/rxrpc/ar-connection.c b/net/rxrpc/ar-connection.c
index 67e38a056240..9f1ce841a0bb 100644
--- a/net/rxrpc/ar-connection.c
+++ b/net/rxrpc/ar-connection.c
@@ -444,6 +444,11 @@ int rxrpc_connect_call(struct rxrpc_sock *rx,
                         conn = list_entry(bundle->avail_conns.next,
                                           struct rxrpc_connection,
                                           bundle_link);
+                        if (conn->state >= RXRPC_CONN_REMOTELY_ABORTED) {
+                                list_del_init(&conn->bundle_link);
+                                bundle->num_conns--;
+                                continue;
+                        }
                         if (--conn->avail_calls == 0)
                                 list_move(&conn->bundle_link,
                                           &bundle->busy_conns);
@@ -461,6 +466,11 @@ int rxrpc_connect_call(struct rxrpc_sock *rx,
                         conn = list_entry(bundle->unused_conns.next,
                                           struct rxrpc_connection,
                                           bundle_link);
+                        if (conn->state >= RXRPC_CONN_REMOTELY_ABORTED) {
+                                list_del_init(&conn->bundle_link);
+                                bundle->num_conns--;
+                                continue;
+                        }
                         ASSERTCMP(conn->avail_calls, ==, RXRPC_MAXCALLS);
                         conn->avail_calls = RXRPC_MAXCALLS - 1;
                         ASSERT(conn->channels[0] == NULL &&
diff --git a/net/rxrpc/ar-connevent.c b/net/rxrpc/ar-connevent.c
index dc5cb1e19509..0505cdc4d6d4 100644
--- a/net/rxrpc/ar-connevent.c
+++ b/net/rxrpc/ar-connevent.c
@@ -150,11 +150,15 @@ static int rxrpc_process_event(struct rxrpc_connection *conn,
         u32 serial;
         int loop, ret;
 
-        if (conn->state >= RXRPC_CONN_REMOTELY_ABORTED)
+        if (conn->state >= RXRPC_CONN_REMOTELY_ABORTED) {
+                kleave(" = -ECONNABORTED [%u]", conn->state);
                 return -ECONNABORTED;
+        }
 
         serial = ntohl(sp->hdr.serial);
 
+        _enter("{%d},{%u,%%%u},", conn->debug_id, sp->hdr.type, serial);
+
         switch (sp->hdr.type) {
         case RXRPC_PACKET_TYPE_ABORT:
                 if (skb_copy_bits(skb, 0, &tmp, sizeof(tmp)) < 0)
@@ -199,6 +203,7 @@ static int rxrpc_process_event(struct rxrpc_connection *conn,
                 return 0;
 
         default:
+                _leave(" = -EPROTO [%u]", sp->hdr.type);
                 return -EPROTO;
         }
 }
diff --git a/net/sched/cls_cgroup.c b/net/sched/cls_cgroup.c
index e5becb92b3e7..e4877ca6727c 100644
--- a/net/sched/cls_cgroup.c
+++ b/net/sched/cls_cgroup.c
@@ -62,13 +62,7 @@ static u64 read_classid(struct cgroup *cgrp, struct cftype *cft)
 
 static int write_classid(struct cgroup *cgrp, struct cftype *cft, u64 value)
 {
-        if (!cgroup_lock_live_group(cgrp))
-                return -ENODEV;
-
         cgrp_cls_state(cgrp)->classid = (u32) value;
-
-        cgroup_unlock();
-
         return 0;
 }
 
diff --git a/net/sched/cls_flow.c b/net/sched/cls_flow.c
index 0ef4e3065bcd..9402a7fd3785 100644
--- a/net/sched/cls_flow.c
+++ b/net/sched/cls_flow.c
@@ -84,7 +84,7 @@ static u32 flow_get_dst(const struct sk_buff *skb)
         case htons(ETH_P_IPV6):
                 return ntohl(ipv6_hdr(skb)->daddr.s6_addr32[3]);
         default:
-                return addr_fold(skb->dst) ^ (__force u16)skb->protocol;
+                return addr_fold(skb_dst(skb)) ^ (__force u16)skb->protocol;
         }
 }
 
@@ -163,7 +163,7 @@ static u32 flow_get_proto_dst(const struct sk_buff *skb)
                 break;
         }
         default:
-                res = addr_fold(skb->dst) ^ (__force u16)skb->protocol;
+                res = addr_fold(skb_dst(skb)) ^ (__force u16)skb->protocol;
         }
 
         return res;
@@ -251,8 +251,8 @@ fallback:
 static u32 flow_get_rtclassid(const struct sk_buff *skb)
 {
 #ifdef CONFIG_NET_CLS_ROUTE
-        if (skb->dst)
-                return skb->dst->tclassid;
+        if (skb_dst(skb))
+                return skb_dst(skb)->tclassid;
 #endif
         return 0;
 }
diff --git a/net/sched/cls_route.c b/net/sched/cls_route.c
index bdf1f4172eef..dd872d5383ef 100644
--- a/net/sched/cls_route.c
+++ b/net/sched/cls_route.c
@@ -137,7 +137,7 @@ static int route4_classify(struct sk_buff *skb, struct tcf_proto *tp,
         u32 id, h;
         int iif, dont_cache = 0;
 
-        if ((dst = skb->dst) == NULL)
+        if ((dst = skb_dst(skb)) == NULL)
                 goto failure;
 
         id = dst->tclassid;
diff --git a/net/sched/em_meta.c b/net/sched/em_meta.c
index fad596bf32d7..266151ae85a3 100644
--- a/net/sched/em_meta.c
+++ b/net/sched/em_meta.c
@@ -246,11 +246,11 @@ META_COLLECTOR(int_tcindex)
 
 META_COLLECTOR(int_rtclassid)
 {
-        if (unlikely(skb->dst == NULL))
+        if (unlikely(skb_dst(skb) == NULL))
                 *err = -1;
         else
 #ifdef CONFIG_NET_CLS_ROUTE
-                dst->value = skb->dst->tclassid;
+                dst->value = skb_dst(skb)->tclassid;
 #else
                 dst->value = 0;
 #endif
@@ -258,10 +258,10 @@ META_COLLECTOR(int_rtclassid)
 
 META_COLLECTOR(int_rtiif)
 {
-        if (unlikely(skb->rtable == NULL))
+        if (unlikely(skb_rtable(skb) == NULL))
                 *err = -1;
         else
-                dst->value = skb->rtable->fl.iif;
+                dst->value = skb_rtable(skb)->fl.iif;
 }
 
 /**************************************************************************
diff --git a/net/sched/sch_api.c b/net/sched/sch_api.c
index 32009793307b..24d17ce9c294 100644
--- a/net/sched/sch_api.c
+++ b/net/sched/sch_api.c
@@ -484,7 +484,7 @@ void qdisc_watchdog_schedule(struct qdisc_watchdog *wd, psched_time_t expires)
 
         wd->qdisc->flags |= TCQ_F_THROTTLED;
         time = ktime_set(0, 0);
-        time = ktime_add_ns(time, PSCHED_US2NS(expires));
+        time = ktime_add_ns(time, PSCHED_TICKS2NS(expires));
         hrtimer_start(&wd->timer, time, HRTIMER_MODE_ABS);
 }
 EXPORT_SYMBOL(qdisc_watchdog_schedule);
@@ -1680,7 +1680,7 @@ static int psched_show(struct seq_file *seq, void *v)
 
         hrtimer_get_res(CLOCK_MONOTONIC, &ts);
         seq_printf(seq, "%08x %08x %08x %08x\n",
-                   (u32)NSEC_PER_USEC, (u32)PSCHED_US2NS(1),
+                   (u32)NSEC_PER_USEC, (u32)PSCHED_TICKS2NS(1),
                    1000000,
                    (u32)NSEC_PER_SEC/(u32)ktime_to_ns(timespec_to_ktime(ts)));
 
diff --git a/net/sched/sch_cbq.c b/net/sched/sch_cbq.c
index d728d8111732..23a167670fd5 100644
--- a/net/sched/sch_cbq.c
+++ b/net/sched/sch_cbq.c
@@ -509,7 +509,7 @@ static void cbq_ovl_delay(struct cbq_class *cl)
                         q->pmask |= (1<<TC_CBQ_MAXPRIO);
 
                         expires = ktime_set(0, 0);
-                        expires = ktime_add_ns(expires, PSCHED_US2NS(sched));
+                        expires = ktime_add_ns(expires, PSCHED_TICKS2NS(sched));
                         if (hrtimer_try_to_cancel(&q->delay_timer) &&
                             ktime_to_ns(ktime_sub(
                                         hrtimer_get_expires(&q->delay_timer),
@@ -620,7 +620,7 @@ static enum hrtimer_restart cbq_undelay(struct hrtimer *timer)
                 ktime_t time;
 
                 time = ktime_set(0, 0);
-                time = ktime_add_ns(time, PSCHED_US2NS(now + delay));
+                time = ktime_add_ns(time, PSCHED_TICKS2NS(now + delay));
                 hrtimer_start(&q->delay_timer, time, HRTIMER_MODE_ABS);
         }
 
diff --git a/net/sched/sch_generic.c b/net/sched/sch_generic.c
index 5f5efe4e6072..27d03816ec3e 100644
--- a/net/sched/sch_generic.c
+++ b/net/sched/sch_generic.c
@@ -196,6 +196,21 @@ void __qdisc_run(struct Qdisc *q)
         clear_bit(__QDISC_STATE_RUNNING, &q->state);
 }
 
+unsigned long dev_trans_start(struct net_device *dev)
+{
+        unsigned long val, res = dev->trans_start;
+        unsigned int i;
+
+        for (i = 0; i < dev->num_tx_queues; i++) {
+                val = netdev_get_tx_queue(dev, i)->trans_start;
+                if (val && time_after(val, res))
+                        res = val;
+        }
+        dev->trans_start = res;
+        return res;
+}
+EXPORT_SYMBOL(dev_trans_start);
+
 static void dev_watchdog(unsigned long arg)
 {
         struct net_device *dev = (struct net_device *)arg;
@@ -205,25 +220,30 @@ static void dev_watchdog(unsigned long arg)
                 if (netif_device_present(dev) &&
                     netif_running(dev) &&
                     netif_carrier_ok(dev)) {
-                        int some_queue_stopped = 0;
+                        int some_queue_timedout = 0;
                         unsigned int i;
+                        unsigned long trans_start;
 
                         for (i = 0; i < dev->num_tx_queues; i++) {
                                 struct netdev_queue *txq;
 
                                 txq = netdev_get_tx_queue(dev, i);
-                                if (netif_tx_queue_stopped(txq)) {
-                                        some_queue_stopped = 1;
+                                /*
+                                 * old device drivers set dev->trans_start
+                                 */
+                                trans_start = txq->trans_start ? : dev->trans_start;
+                                if (netif_tx_queue_stopped(txq) &&
+                                    time_after(jiffies, (trans_start +
+                                                         dev->watchdog_timeo))) {
+                                        some_queue_timedout = 1;
                                         break;
                                 }
                         }
 
-                        if (some_queue_stopped &&
-                            time_after(jiffies, (dev->trans_start +
-                                                 dev->watchdog_timeo))) {
+                        if (some_queue_timedout) {
                                 char drivername[64];
-                                WARN_ONCE(1, KERN_INFO "NETDEV WATCHDOG: %s (%s): transmit timed out\n",
-                                       dev->name, netdev_drivername(dev, drivername, 64));
+                                WARN_ONCE(1, KERN_INFO "NETDEV WATCHDOG: %s (%s): transmit queue %u timed out\n",
+                                       dev->name, netdev_drivername(dev, drivername, 64), i);
                                 dev->netdev_ops->ndo_tx_timeout(dev);
                         }
                         if (!mod_timer(&dev->watchdog_timer,
@@ -602,8 +622,10 @@ static void transition_one_qdisc(struct net_device *dev,
                 clear_bit(__QDISC_STATE_DEACTIVATED, &new_qdisc->state);
 
         rcu_assign_pointer(dev_queue->qdisc, new_qdisc);
-        if (need_watchdog_p && new_qdisc != &noqueue_qdisc)
+        if (need_watchdog_p && new_qdisc != &noqueue_qdisc) {
+                dev_queue->trans_start = 0;
                 *need_watchdog_p = 1;
+        }
 }
 
 void dev_activate(struct net_device *dev)
diff --git a/net/sched/sch_hfsc.c b/net/sched/sch_hfsc.c
index 5022f9c1f34b..362c2811b2df 100644
--- a/net/sched/sch_hfsc.c
+++ b/net/sched/sch_hfsc.c
@@ -372,7 +372,7 @@ cftree_update(struct hfsc_class *cl)
  *      ism: (psched_us/byte) << ISM_SHIFT
  *      dx: psched_us
  *
- * The clock source resolution with ktime is 1.024us.
+ * The clock source resolution with ktime and PSCHED_SHIFT 10 is 1.024us.
  *
  * sm and ism are scaled in order to keep effective digits.
  * SM_SHIFT and ISM_SHIFT are selected to keep at least 4 effective
@@ -383,9 +383,11 @@ cftree_update(struct hfsc_class *cl)
  *  bytes/1.024us 12.8e-3    128e-3     1280e-3    12800e-3   128000e-3
  *
  *  1.024us/byte  78.125     7.8125     0.78125    0.078125   0.0078125
+ *
+ * So, for PSCHED_SHIFT 10 we need: SM_SHIFT 20, ISM_SHIFT 18.
  */
-#define SM_SHIFT        20
-#define ISM_SHIFT       18
+#define SM_SHIFT        (30 - PSCHED_SHIFT)
+#define ISM_SHIFT       (8 + PSCHED_SHIFT)
 
 #define SM_MASK         ((1ULL << SM_SHIFT) - 1)
 #define ISM_MASK        ((1ULL << ISM_SHIFT) - 1)
diff --git a/net/sched/sch_sfq.c b/net/sched/sch_sfq.c
index 33133d27b539..8706920a6d45 100644
--- a/net/sched/sch_sfq.c
+++ b/net/sched/sch_sfq.c
@@ -149,7 +149,7 @@ static unsigned sfq_hash(struct sfq_sched_data *q, struct sk_buff *skb)
                 break;
         }
         default:
-                h = (unsigned long)skb->dst ^ skb->protocol;
+                h = (unsigned long)skb_dst(skb) ^ skb->protocol;
                 h2 = (unsigned long)skb->sk;
         }
 
diff --git a/net/sched/sch_teql.c b/net/sched/sch_teql.c
index 3b6418297231..9c002b6e0533 100644
--- a/net/sched/sch_teql.c
+++ b/net/sched/sch_teql.c
@@ -58,7 +58,6 @@ struct teql_master
         struct net_device *dev;
         struct Qdisc *slaves;
         struct list_head master_list;
-        struct net_device_stats stats;
 };
 
 struct teql_sched_data
@@ -223,7 +222,7 @@ __teql_resolve(struct sk_buff *skb, struct sk_buff *skb_res, struct net_device *
 {
         struct netdev_queue *dev_queue = netdev_get_tx_queue(dev, 0);
         struct teql_sched_data *q = qdisc_priv(dev_queue->qdisc);
-        struct neighbour *mn = skb->dst->neighbour;
+        struct neighbour *mn = skb_dst(skb)->neighbour;
         struct neighbour *n = q->ncache;
 
         if (mn->tbl == NULL)
@@ -263,8 +262,8 @@ static inline int teql_resolve(struct sk_buff *skb,
                 return -ENODEV;
 
         if (dev->header_ops == NULL ||
-            skb->dst == NULL ||
-            skb->dst->neighbour == NULL)
+            skb_dst(skb) == NULL ||
+            skb_dst(skb)->neighbour == NULL)
                 return 0;
         return __teql_resolve(skb, skb_res, dev);
 }
@@ -272,6 +271,7 @@ static inline int teql_resolve(struct sk_buff *skb,
 static int teql_master_xmit(struct sk_buff *skb, struct net_device *dev)
 {
         struct teql_master *master = netdev_priv(dev);
+        struct netdev_queue *txq = netdev_get_tx_queue(dev, 0);
         struct Qdisc *start, *q;
         int busy;
         int nores;
@@ -308,11 +308,12 @@ restart:
                                 if (!netif_tx_queue_stopped(slave_txq) &&
                                     !netif_tx_queue_frozen(slave_txq) &&
                                     slave_ops->ndo_start_xmit(skb, slave) == 0) {
+                                        txq_trans_update(slave_txq);
                                         __netif_tx_unlock(slave_txq);
                                         master->slaves = NEXT_SLAVE(q);
                                         netif_wake_queue(dev);
-                                        master->stats.tx_packets++;
-                                        master->stats.tx_bytes += length;
+                                        txq->tx_packets++;
+                                        txq->tx_bytes += length;
                                         return 0;
                                 }
                                 __netif_tx_unlock(slave_txq);
@@ -337,12 +338,12 @@ restart:
 
         if (busy) {
                 netif_stop_queue(dev);
-                return 1;
+                return NETDEV_TX_BUSY;
         }
-        master->stats.tx_errors++;
+        dev->stats.tx_errors++;
 
 drop:
-        master->stats.tx_dropped++;
+        txq->tx_dropped++;
         dev_kfree_skb(skb);
         return 0;
 }
@@ -395,12 +396,6 @@ static int teql_master_close(struct net_device *dev)
         return 0;
 }
 
-static struct net_device_stats *teql_master_stats(struct net_device *dev)
-{
-        struct teql_master *m = netdev_priv(dev);
-        return &m->stats;
-}
-
 static int teql_master_mtu(struct net_device *dev, int new_mtu)
 {
         struct teql_master *m = netdev_priv(dev);
@@ -425,7 +420,6 @@ static const struct net_device_ops teql_netdev_ops = {
         .ndo_open       = teql_master_open,
         .ndo_stop       = teql_master_close,
         .ndo_start_xmit = teql_master_xmit,
-        .ndo_get_stats  = teql_master_stats,
         .ndo_change_mtu = teql_master_mtu,
 };
 
diff --git a/net/sctp/associola.c b/net/sctp/associola.c
index f4b23043b610..525864bf4f07 100644
--- a/net/sctp/associola.c
+++ b/net/sctp/associola.c
@@ -293,7 +293,8 @@ static struct sctp_association *sctp_association_init(struct sctp_association *a
          * told otherwise.
          */
         asoc->peer.ipv4_address = 1;
-        asoc->peer.ipv6_address = 1;
+        if (asoc->base.sk->sk_family == PF_INET6)
+                asoc->peer.ipv6_address = 1;
         INIT_LIST_HEAD(&asoc->asocs);
 
         asoc->autoclose = sp->autoclose;
@@ -566,6 +567,21 @@ void sctp_assoc_rm_peer(struct sctp_association *asoc,
         if (asoc->init_last_sent_to == peer)
                 asoc->init_last_sent_to = NULL;
 
+        /* If we remove the transport an SHUTDOWN was last sent to, set it
+         * to NULL. Combined with the update of the retran path above, this
+         * will cause the next SHUTDOWN to be sent to the next available
+         * transport, maintaining the cycle.
+         */
+        if (asoc->shutdown_last_sent_to == peer)
+                asoc->shutdown_last_sent_to = NULL;
+
+        /* If we remove the transport an ASCONF was last sent to, set it to
+         * NULL.
+         */
+        if (asoc->addip_last_asconf &&
+            asoc->addip_last_asconf->transport == peer)
+                asoc->addip_last_asconf->transport = NULL;
+
         asoc->peer.transport_count--;
 
         sctp_transport_free(peer);
@@ -1268,49 +1284,21 @@ void sctp_assoc_update_retran_path(struct sctp_association *asoc)
                                  ntohs(t->ipaddr.v4.sin_port));
 }
 
-/* Choose the transport for sending a INIT packet.  */
-struct sctp_transport *sctp_assoc_choose_init_transport(
-        struct sctp_association *asoc)
-{
-        struct sctp_transport *t;
-
-        /* Use the retran path. If the last INIT was sent over the
-         * retran path, update the retran path and use it.
-         */
-        if (!asoc->init_last_sent_to) {
-                t = asoc->peer.active_path;
-        } else {
-                if (asoc->init_last_sent_to == asoc->peer.retran_path)
-                        sctp_assoc_update_retran_path(asoc);
-                t = asoc->peer.retran_path;
-        }
-
-        SCTP_DEBUG_PRINTK_IPADDR("sctp_assoc_update_retran_path:association"
-                                 " %p addr: ",
-                                 " port: %d\n",
-                                 asoc,
-                                 (&t->ipaddr),
-                                 ntohs(t->ipaddr.v4.sin_port));
-
-        return t;
-}
-
-/* Choose the transport for sending a SHUTDOWN packet.  */
-struct sctp_transport *sctp_assoc_choose_shutdown_transport(
-        struct sctp_association *asoc)
+/* Choose the transport for sending retransmit packet.  */
+struct sctp_transport *sctp_assoc_choose_alter_transport(
+        struct sctp_association *asoc, struct sctp_transport *last_sent_to)
 {
-        /* If this is the first time SHUTDOWN is sent, use the active path,
-         * else use the retran path. If the last SHUTDOWN was sent over the
+        /* If this is the first time packet is sent, use the active path,
+         * else use the retran path. If the last packet was sent over the
          * retran path, update the retran path and use it.
          */
-        if (!asoc->shutdown_last_sent_to)
+        if (!last_sent_to)
                 return asoc->peer.active_path;
         else {
-                if (asoc->shutdown_last_sent_to == asoc->peer.retran_path)
+                if (last_sent_to == asoc->peer.retran_path)
                         sctp_assoc_update_retran_path(asoc);
                 return asoc->peer.retran_path;
         }
-
 }
 
 /* Update the association's pmtu and frag_point by going through all the
@@ -1482,6 +1470,10 @@ int sctp_assoc_set_id(struct sctp_association *asoc, gfp_t gfp)
 {
         int assoc_id;
         int error = 0;
+
+        /* If the id is already assigned, keep it. */
+        if (asoc->assoc_id)
+                return error;
 retry:
         if (unlikely(!idr_pre_get(&sctp_assocs_id, gfp)))
                 return -ENOMEM;
diff --git a/net/sctp/input.c b/net/sctp/input.c
index d2e98803ffe3..c0c973e67add 100644
--- a/net/sctp/input.c
+++ b/net/sctp/input.c
@@ -81,13 +81,13 @@ static void sctp_add_backlog(struct sock *sk, struct sk_buff *skb);
 /* Calculate the SCTP checksum of an SCTP packet.  */
 static inline int sctp_rcv_checksum(struct sk_buff *skb)
 {
-        struct sk_buff *list = skb_shinfo(skb)->frag_list;
         struct sctphdr *sh = sctp_hdr(skb);
         __le32 cmp = sh->checksum;
+        struct sk_buff *list;
         __le32 val;
         __u32 tmp = sctp_start_cksum((__u8 *)sh, skb_headlen(skb));
 
-        for (; list; list = list->next)
+        skb_walk_frags(skb, list)
                 tmp = sctp_update_cksum((__u8 *)list->data, skb_headlen(list),
                                         tmp);
 
diff --git a/net/sctp/output.c b/net/sctp/output.c
index 7d08f522ec84..b76411444515 100644
--- a/net/sctp/output.c
+++ b/net/sctp/output.c
@@ -405,13 +405,14 @@ int sctp_packet_transmit(struct sctp_packet *packet)
                         sctp_assoc_sync_pmtu(asoc);
                 }
         }
-        nskb->dst = dst_clone(tp->dst);
-        if (!nskb->dst)
+        dst = dst_clone(tp->dst);
+        skb_dst_set(nskb, dst);
+        if (dst)
                 goto no_route;
-        dst = nskb->dst;
 
         /* Build the SCTP header.  */
         sh = (struct sctphdr *)skb_push(nskb, sizeof(struct sctphdr));
+        skb_reset_transport_header(nskb);
         sh->source = htons(packet->source_port);
         sh->dest   = htons(packet->destination_port);
 
@@ -527,15 +528,25 @@ int sctp_packet_transmit(struct sctp_packet *packet)
          * Note: Adler-32 is no longer applicable, as has been replaced
          * by CRC32-C as described in <draft-ietf-tsvwg-sctpcsum-02.txt>.
          */
-        if (!sctp_checksum_disable && !(dst->dev->features & NETIF_F_NO_CSUM)) {
+        if (!sctp_checksum_disable &&
+            !(dst->dev->features & (NETIF_F_NO_CSUM | NETIF_F_SCTP_CSUM))) {
                 __u32 crc32 = sctp_start_cksum((__u8 *)sh, cksum_buf_len);
 
                 /* 3) Put the resultant value into the checksum field in the
                  *    common header, and leave the rest of the bits unchanged.
                  */
                 sh->checksum = sctp_end_cksum(crc32);
-        } else
-                nskb->ip_summed = CHECKSUM_UNNECESSARY;
+        } else {
+                if (dst->dev->features & NETIF_F_SCTP_CSUM) {
+                        /* no need to seed psuedo checksum for SCTP */
+                        nskb->ip_summed = CHECKSUM_PARTIAL;
+                        nskb->csum_start = (skb_transport_header(nskb) -
+                                            nskb->head);
+                        nskb->csum_offset = offsetof(struct sctphdr, checksum);
+                } else {
+                        nskb->ip_summed = CHECKSUM_UNNECESSARY;
+                }
+        }
 
         /* IP layer ECN support
          * From RFC 2481
diff --git a/net/sctp/protocol.c b/net/sctp/protocol.c
index 8eb3e61cb701..79cbd47f4df7 100644
--- a/net/sctp/protocol.c
+++ b/net/sctp/protocol.c
@@ -393,7 +393,7 @@ static int sctp_v4_addr_valid(union sctp_addr *addr,
                 return 0;
 
         /* Is this a broadcast address? */
-        if (skb && skb->rtable->rt_flags & RTCF_BROADCAST)
+        if (skb && skb_rtable(skb)->rt_flags & RTCF_BROADCAST)
                 return 0;
 
         return 1;
@@ -572,7 +572,7 @@ static void sctp_v4_get_saddr(struct sctp_sock *sk,
 /* What interface did this skb arrive on? */
 static int sctp_v4_skb_iif(const struct sk_buff *skb)
 {
-        return skb->rtable->rt_iif;
+        return skb_rtable(skb)->rt_iif;
 }
 
 /* Was this packet marked by Explicit Congestion Notification? */
@@ -848,8 +848,8 @@ static inline int sctp_v4_xmit(struct sk_buff *skb,
 
         SCTP_DEBUG_PRINTK("%s: skb:%p, len:%d, src:%pI4, dst:%pI4\n",
                           __func__, skb, skb->len,
-                          &skb->rtable->rt_src,
-                          &skb->rtable->rt_dst);
+                          &skb_rtable(skb)->rt_src,
+                          &skb_rtable(skb)->rt_dst);
 
         inet->pmtudisc = transport->param_flags & SPP_PMTUD_ENABLE ?
                          IP_PMTUDISC_DO : IP_PMTUDISC_DONT;
@@ -1370,6 +1370,8 @@ SCTP_STATIC __exit void sctp_exit(void)
         sctp_proc_exit();
         cleanup_sctp_mibs();
 
+        rcu_barrier(); /* Wait for completion of call_rcu()'s */
+
         kmem_cache_destroy(sctp_chunk_cachep);
         kmem_cache_destroy(sctp_bucket_cachep);
 }
diff --git a/net/sctp/sm_make_chunk.c b/net/sctp/sm_make_chunk.c
index 6851ee94e974..61cc6075b0df 100644
--- a/net/sctp/sm_make_chunk.c
+++ b/net/sctp/sm_make_chunk.c
@@ -2864,19 +2864,19 @@ static __be16 sctp_process_asconf_param(struct sctp_association *asoc,
         switch (addr_param->v4.param_hdr.type) {
         case SCTP_PARAM_IPV6_ADDRESS:
                 if (!asoc->peer.ipv6_address)
-                        return SCTP_ERROR_INV_PARAM;
+                        return SCTP_ERROR_DNS_FAILED;
                 break;
         case SCTP_PARAM_IPV4_ADDRESS:
                 if (!asoc->peer.ipv4_address)
-                        return SCTP_ERROR_INV_PARAM;
+                        return SCTP_ERROR_DNS_FAILED;
                 break;
         default:
-                return SCTP_ERROR_INV_PARAM;
+                return SCTP_ERROR_DNS_FAILED;
         }
 
         af = sctp_get_af_specific(param_type2af(addr_param->v4.param_hdr.type));
         if (unlikely(!af))
-                return SCTP_ERROR_INV_PARAM;
+                return SCTP_ERROR_DNS_FAILED;
 
         af->from_addr_param(&addr, addr_param, htons(asoc->peer.port), 0);
 
@@ -2886,7 +2886,7 @@ static __be16 sctp_process_asconf_param(struct sctp_association *asoc,
          *  make sure we check for that)
          */
         if (!af->is_any(&addr) && !af->addr_valid(&addr, NULL, asconf->skb))
-                return SCTP_ERROR_INV_PARAM;
+                return SCTP_ERROR_DNS_FAILED;
 
         switch (asconf_param->param_hdr.type) {
         case SCTP_PARAM_ADD_IP:
@@ -2954,12 +2954,12 @@ static __be16 sctp_process_asconf_param(struct sctp_association *asoc,
 
                 peer = sctp_assoc_lookup_paddr(asoc, &addr);
                 if (!peer)
-                        return SCTP_ERROR_INV_PARAM;
+                        return SCTP_ERROR_DNS_FAILED;
 
                 sctp_assoc_set_primary(asoc, peer);
                 break;
         default:
-                return SCTP_ERROR_INV_PARAM;
+                return SCTP_ERROR_UNKNOWN_PARAM;
                 break;
         }
 
@@ -3273,7 +3273,7 @@ int sctp_process_asconf_ack(struct sctp_association *asoc,
                         retval = 1;
                         break;
 
-                case SCTP_ERROR_INV_PARAM:
+                case SCTP_ERROR_UNKNOWN_PARAM:
                         /* Disable sending this type of asconf parameter in
                          * future.
                          */
diff --git a/net/sctp/sm_sideeffect.c b/net/sctp/sm_sideeffect.c
index e2020eb2c8ca..86426aac1600 100644
--- a/net/sctp/sm_sideeffect.c
+++ b/net/sctp/sm_sideeffect.c
@@ -686,7 +686,8 @@ static void sctp_cmd_setup_t2(sctp_cmd_seq_t *cmds,
 {
         struct sctp_transport *t;
 
-        t = sctp_assoc_choose_shutdown_transport(asoc);
+        t = sctp_assoc_choose_alter_transport(asoc,
+                                              asoc->shutdown_last_sent_to);
         asoc->shutdown_last_sent_to = t;
         asoc->timeouts[SCTP_EVENT_TIMEOUT_T2_SHUTDOWN] = t->rto;
         chunk->transport = t;
@@ -777,7 +778,7 @@ static void sctp_cmd_setup_t4(sctp_cmd_seq_t *cmds,
 {
         struct sctp_transport *t;
 
-        t = asoc->peer.active_path;
+        t = sctp_assoc_choose_alter_transport(asoc, chunk->transport);
         asoc->timeouts[SCTP_EVENT_TIMEOUT_T4_RTO] = t->rto;
         chunk->transport = t;
 }
@@ -1379,7 +1380,8 @@ static int sctp_cmd_interpreter(sctp_event_t event_type,
 
                 case SCTP_CMD_INIT_CHOOSE_TRANSPORT:
                         chunk = cmd->obj.ptr;
-                        t = sctp_assoc_choose_init_transport(asoc);
+                        t = sctp_assoc_choose_alter_transport(asoc,
+                                                asoc->init_last_sent_to);
                         asoc->init_last_sent_to = t;
                         chunk->transport = t;
                         t->init_sent_count++;
diff --git a/net/sctp/sm_statefuns.c b/net/sctp/sm_statefuns.c
index 55a61aa69662..7288192f7df5 100644
--- a/net/sctp/sm_statefuns.c
+++ b/net/sctp/sm_statefuns.c
@@ -5432,9 +5432,13 @@ sctp_disposition_t sctp_sf_t2_timer_expire(const struct sctp_endpoint *ep,
         if (!reply)
                 goto nomem;
 
-        /* Do some failure management (Section 8.2). */
-        sctp_add_cmd_sf(commands, SCTP_CMD_STRIKE,
-                        SCTP_TRANSPORT(asoc->shutdown_last_sent_to));
+        /* Do some failure management (Section 8.2).
+         * If we remove the transport an SHUTDOWN was last sent to, don't
+         * do failure management.
+         */
+        if (asoc->shutdown_last_sent_to)
+                sctp_add_cmd_sf(commands, SCTP_CMD_STRIKE,
+                                SCTP_TRANSPORT(asoc->shutdown_last_sent_to));
 
         /* Set the transport for the SHUTDOWN/ACK chunk and the timeout for
          * the T2-shutdown timer.
@@ -5471,7 +5475,9 @@ sctp_disposition_t sctp_sf_t4_timer_expire(
          * detection on the appropriate destination address as defined in
          * RFC2960 [5] section 8.1 and 8.2.
          */
-        sctp_add_cmd_sf(commands, SCTP_CMD_STRIKE, SCTP_TRANSPORT(transport));
+        if (transport)
+                sctp_add_cmd_sf(commands, SCTP_CMD_STRIKE,
+                                SCTP_TRANSPORT(transport));
 
         /* Reconfig T4 timer and transport. */
         sctp_add_cmd_sf(commands, SCTP_CMD_SETUP_T4, SCTP_CHUNK(chunk));
diff --git a/net/sctp/sm_statetable.c b/net/sctp/sm_statetable.c
index 5c8186d88c61..6d9b3aafcc5d 100644
--- a/net/sctp/sm_statetable.c
+++ b/net/sctp/sm_statetable.c
@@ -698,7 +698,7 @@ chunk_event_table_unknown[SCTP_STATE_NUM_STATES] = {
         TYPE_SCTP_FUNC(sctp_sf_do_prm_asconf), \
         /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
         TYPE_SCTP_FUNC(sctp_sf_error_shutdown), \
-} /* TYPE_SCTP_PRIMITIVE_REQUESTHEARTBEAT */
+} /* TYPE_SCTP_PRIMITIVE_ASCONF */
 
 /* The primary index for this table is the primitive type.
  * The secondary index for this table is the state.
diff --git a/net/sctp/socket.c b/net/sctp/socket.c
index 5fb3a8c9792e..0f01e5d8a24f 100644
--- a/net/sctp/socket.c
+++ b/net/sctp/socket.c
@@ -1100,6 +1100,15 @@ static int __sctp_connect(struct sock* sk,
                 goto out_free;
         }
 
+        /* In case the user of sctp_connectx() wants an association
+         * id back, assign one now.
+         */
+        if (assoc_id) {
+                err = sctp_assoc_set_id(asoc, GFP_KERNEL);
+                if (err < 0)
+                        goto out_free;
+        }
+
         err = sctp_primitive_ASSOCIATE(asoc, NULL);
         if (err < 0) {
                 goto out_free;
@@ -1120,7 +1129,7 @@ static int __sctp_connect(struct sock* sk,
         timeo = sock_sndtimeo(sk, f_flags & O_NONBLOCK);
 
         err = sctp_wait_for_connect(asoc, &timeo);
-        if (!err && assoc_id)
+        if ((err == 0 || err == -EINPROGRESS) && assoc_id)
                 *assoc_id = asoc->assoc_id;
 
         /* Don't free association on exit. */
@@ -1264,6 +1273,34 @@ SCTP_STATIC int sctp_setsockopt_connectx(struct sock* sk,
                 return assoc_id;
 }
 
+/*
+ * New (hopefully final) interface for the API.  The option buffer is used
+ * both for the returned association id and the addresses.
+ */
+SCTP_STATIC int sctp_getsockopt_connectx3(struct sock* sk, int len,
+                                        char __user *optval,
+                                        int __user *optlen)
+{
+        sctp_assoc_t assoc_id = 0;
+        int err = 0;
+
+        if (len < sizeof(assoc_id))
+                return -EINVAL;
+
+        err = __sctp_setsockopt_connectx(sk,
+                        (struct sockaddr __user *)(optval + sizeof(assoc_id)),
+                        len - sizeof(assoc_id), &assoc_id);
+
+        if (err == 0 || err == -EINPROGRESS) {
+                if (copy_to_user(optval, &assoc_id, sizeof(assoc_id)))
+                        return -EFAULT;
+                if (put_user(sizeof(assoc_id), optlen))
+                        return -EFAULT;
+        }
+
+        return err;
+}
+
 /* API 3.1.4 close() - UDP Style Syntax
  * Applications use close() to perform graceful shutdown (as described in
  * Section 10.1 of [SCTP]) on ALL the associations currently represented
@@ -1844,7 +1881,7 @@ static int sctp_skb_pull(struct sk_buff *skb, int len)
         len -= skb_len;
         __skb_pull(skb, skb_len);
 
-        for (list = skb_shinfo(skb)->frag_list; list; list = list->next) {
+        skb_walk_frags(skb, list) {
                 rlen = sctp_skb_pull(list, len);
                 skb->len -= (len-rlen);
                 skb->data_len -= (len-rlen);
@@ -5578,6 +5615,9 @@ SCTP_STATIC int sctp_getsockopt(struct sock *sk, int level, int optname,
                 retval = sctp_getsockopt_local_addrs(sk, len, optval,
                                                      optlen);
                 break;
+        case SCTP_SOCKOPT_CONNECTX3:
+                retval = sctp_getsockopt_connectx3(sk, len, optval, optlen);
+                break;
         case SCTP_DEFAULT_SEND_PARAM:
                 retval = sctp_getsockopt_default_send_param(sk, len,
                                                             optval, optlen);
@@ -6620,7 +6660,7 @@ static void sctp_sock_rfree_frag(struct sk_buff *skb)
                 goto done;
 
         /* Don't forget the fragments. */
-        for (frag = skb_shinfo(skb)->frag_list; frag; frag = frag->next)
+        skb_walk_frags(skb, frag)
                 sctp_sock_rfree_frag(frag);
 
 done:
@@ -6635,7 +6675,7 @@ static void sctp_skb_set_owner_r_frag(struct sk_buff *skb, struct sock *sk)
                 goto done;
 
         /* Don't forget the fragments. */
-        for (frag = skb_shinfo(skb)->frag_list; frag; frag = frag->next)
+        skb_walk_frags(skb, frag)
                 sctp_skb_set_owner_r_frag(frag, sk);
 
 done:
diff --git a/net/sctp/sysctl.c b/net/sctp/sysctl.c
index f58e994e6852..63eabbc71298 100644
--- a/net/sctp/sysctl.c
+++ b/net/sctp/sysctl.c
@@ -49,8 +49,8 @@ static int zero = 0;
 static int one = 1;
 static int timer_max = 86400000; /* ms in one day */
 static int int_max = INT_MAX;
-static long sack_timer_min = 1;
-static long sack_timer_max = 500;
+static int sack_timer_min = 1;
+static int sack_timer_max = 500;
 
 extern int sysctl_sctp_mem[3];
 extern int sysctl_sctp_rmem[3];
@@ -223,7 +223,7 @@ static ctl_table sctp_table[] = {
                 .ctl_name       = NET_SCTP_SACK_TIMEOUT,
                 .procname       = "sack_timeout",
                 .data           = &sctp_sack_timeout,
-                .maxlen         = sizeof(long),
+                .maxlen         = sizeof(int),
                 .mode           = 0644,
                 .proc_handler   = proc_dointvec_minmax,
                 .strategy       = sysctl_intvec,
diff --git a/net/sctp/ulpevent.c b/net/sctp/ulpevent.c
index 5f186ca550d7..8b3560fd876d 100644
--- a/net/sctp/ulpevent.c
+++ b/net/sctp/ulpevent.c
@@ -976,9 +976,8 @@ static void sctp_ulpevent_receive_data(struct sctp_ulpevent *event,
          * In general, the skb passed from IP can have only 1 level of
          * fragments. But we allow multiple levels of fragments.
          */
-        for (frag = skb_shinfo(skb)->frag_list; frag; frag = frag->next) {
+        skb_walk_frags(skb, frag)
                 sctp_ulpevent_receive_data(sctp_skb2event(frag), asoc);
-        }
 }
 
 /* Do accounting for bytes just read by user and release the references to
@@ -1003,7 +1002,7 @@ static void sctp_ulpevent_release_data(struct sctp_ulpevent *event)
                 goto done;
 
         /* Don't forget the fragments. */
-        for (frag = skb_shinfo(skb)->frag_list; frag; frag = frag->next) {
+        skb_walk_frags(skb, frag) {
                 /* NOTE:  skb_shinfos are recursive. Although IP returns
                  * skb's with only 1 level of fragments, SCTP reassembly can
                  * increase the levels.
@@ -1026,7 +1025,7 @@ static void sctp_ulpevent_release_frag_data(struct sctp_ulpevent *event)
                 goto done;
 
         /* Don't forget the fragments. */
-        for (frag = skb_shinfo(skb)->frag_list; frag; frag = frag->next) {
+        skb_walk_frags(skb, frag) {
                 /* NOTE:  skb_shinfos are recursive. Although IP returns
                  * skb's with only 1 level of fragments, SCTP reassembly can
                  * increase the levels.
diff --git a/net/sunrpc/auth_gss/auth_gss.c b/net/sunrpc/auth_gss/auth_gss.c
index e630b38a6047..66d458fc6920 100644
--- a/net/sunrpc/auth_gss/auth_gss.c
+++ b/net/sunrpc/auth_gss/auth_gss.c
@@ -1548,6 +1548,7 @@ static void __exit exit_rpcsec_gss(void)
 {
         gss_svc_shutdown();
         rpcauth_unregister(&authgss_ops);
+        rcu_barrier(); /* Wait for completion of call_rcu()'s */
 }
 
 MODULE_LICENSE("GPL");
diff --git a/net/sunrpc/svc.c b/net/sunrpc/svc.c
index 6b90ce439c00..952f206ff307 100644
--- a/net/sunrpc/svc.c
+++ b/net/sunrpc/svc.c
@@ -125,7 +125,7 @@ svc_pool_map_choose_mode(void)
 {
         unsigned int node;
 
-        if (num_online_nodes() > 1) {
+        if (nr_online_nodes > 1) {
                 /*
                  * Actually have multiple NUMA nodes,
                  * so split pools on NUMA node boundaries
diff --git a/net/sunrpc/xprtsock.c b/net/sunrpc/xprtsock.c
index 8a721867b601..9111d11c09fd 100644
--- a/net/sunrpc/xprtsock.c
+++ b/net/sunrpc/xprtsock.c
@@ -928,7 +928,7 @@ static void xs_udp_data_ready(struct sock *sk, int len)
         UDPX_INC_STATS_BH(sk, UDP_MIB_INDATAGRAMS);
 
         /* Something worked... */
-        dst_confirm(skb->dst);
+        dst_confirm(skb_dst(skb));
 
         xprt_adjust_cwnd(task, copied);
         xprt_update_rtt(task);
diff --git a/net/tipc/eth_media.c b/net/tipc/eth_media.c
index f72ba774c246..524ba5696d4d 100644
--- a/net/tipc/eth_media.c
+++ b/net/tipc/eth_media.c
@@ -167,7 +167,7 @@ static int enable_bearer(struct tipc_bearer *tb_ptr)
         tb_ptr->mtu = dev->mtu;
         tb_ptr->blocked = 0;
         tb_ptr->addr.type = htonl(TIPC_MEDIA_TYPE_ETH);
-        memcpy(&tb_ptr->addr.dev_addr, &dev->dev_addr, ETH_ALEN);
+        memcpy(&tb_ptr->addr.dev_addr, dev->dev_addr, ETH_ALEN);
         return 0;
 }
 
diff --git a/net/tipc/netlink.c b/net/tipc/netlink.c
index c387217bb230..3c57005e44d1 100644
--- a/net/tipc/netlink.c
+++ b/net/tipc/netlink.c
@@ -68,7 +68,7 @@ static int handle_cmd(struct sk_buff *skb, struct genl_info *info)
         return 0;
 }
 
-static struct genl_family family = {
+static struct genl_family tipc_genl_family = {
         .id             = GENL_ID_GENERATE,
         .name           = TIPC_GENL_NAME,
         .version        = TIPC_GENL_VERSION,
@@ -76,39 +76,33 @@ static struct genl_family family = {
         .maxattr        = 0,
 };
 
-static struct genl_ops ops = {
+static struct genl_ops tipc_genl_ops = {
         .cmd            = TIPC_GENL_CMD,
         .doit           = handle_cmd,
 };
 
-static int family_registered = 0;
+static int tipc_genl_family_registered;
 
 int tipc_netlink_start(void)
 {
+        int res;
 
+        res = genl_register_family_with_ops(&tipc_genl_family,
+                &tipc_genl_ops, 1);
+        if (res) {
+                err("Failed to register netlink interface\n");
+                return res;
+        }
 
-        if (genl_register_family(&family))
-                goto err;
-
-        family_registered = 1;
-
-        if (genl_register_ops(&family, &ops))
-                goto err_unregister;
-
+        tipc_genl_family_registered = 1;
         return 0;
-
- err_unregister:
-        genl_unregister_family(&family);
-        family_registered = 0;
- err:
-        err("Failed to register netlink interface\n");
-        return -EFAULT;
 }
 
 void tipc_netlink_stop(void)
 {
-        if (family_registered) {
-                genl_unregister_family(&family);
-                family_registered = 0;
-        }
+        if (!tipc_genl_family_registered)
+                return;
+
+        genl_unregister_family(&tipc_genl_family);
+        tipc_genl_family_registered = 0;
 }
diff --git a/net/wimax/Kconfig b/net/wimax/Kconfig
index 1b46747a5f5a..e4d97ab476d5 100644
--- a/net/wimax/Kconfig
+++ b/net/wimax/Kconfig
@@ -1,23 +1,10 @@
 #
 # WiMAX LAN device configuration
 #
-# Note the ugly 'depends on' on WIMAX: that disallows RFKILL to be a
-# module if WIMAX is to be linked in. The WiMAX code is done in such a
-# way that it doesn't require and explicit dependency on RFKILL in
-# case an embedded system wants to rip it out.
-#
-# As well, enablement of the RFKILL code means we need the INPUT layer
-# support to inject events coming from hw rfkill switches. That
-# dependency could be killed if input.h provided appropriate means to
-# work when input is disabled.
-
-comment "WiMAX Wireless Broadband support requires CONFIG_INPUT enabled"
-        depends on INPUT = n && RFKILL != n
 
 menuconfig WIMAX
         tristate "WiMAX Wireless Broadband support"
-        depends on (y && RFKILL != m) || m
-        depends on (INPUT && RFKILL != n) || RFKILL = n
+        depends on RFKILL || !RFKILL
         help
 
           Select to configure support for devices that provide
diff --git a/net/wimax/Makefile b/net/wimax/Makefile
index 5b80b941c2c9..8f1510d0cc2b 100644
--- a/net/wimax/Makefile
+++ b/net/wimax/Makefile
@@ -6,6 +6,7 @@ wimax-y :=		\
         op-msg.o        \
         op-reset.o      \
         op-rfkill.o     \
+        op-state-get.o  \
         stack.o
 
 wimax-$(CONFIG_DEBUG_FS) += debugfs.o
diff --git a/net/wimax/debug-levels.h b/net/wimax/debug-levels.h
index 1c29123a3aa9..0975adba6b71 100644
--- a/net/wimax/debug-levels.h
+++ b/net/wimax/debug-levels.h
@@ -36,6 +36,7 @@ enum d_module {
         D_SUBMODULE_DECLARE(op_msg),
         D_SUBMODULE_DECLARE(op_reset),
         D_SUBMODULE_DECLARE(op_rfkill),
+        D_SUBMODULE_DECLARE(op_state_get),
         D_SUBMODULE_DECLARE(stack),
 };
 
diff --git a/net/wimax/debugfs.c b/net/wimax/debugfs.c
index 94d216a46407..6c9bedb7431e 100644
--- a/net/wimax/debugfs.c
+++ b/net/wimax/debugfs.c
@@ -61,6 +61,7 @@ int wimax_debugfs_add(struct wimax_dev *wimax_dev)
         __debugfs_register("wimax_dl_", op_msg, dentry);
         __debugfs_register("wimax_dl_", op_reset, dentry);
         __debugfs_register("wimax_dl_", op_rfkill, dentry);
+        __debugfs_register("wimax_dl_", op_state_get, dentry);
         __debugfs_register("wimax_dl_", stack, dentry);
         result = 0;
 out:
diff --git a/net/wimax/op-msg.c b/net/wimax/op-msg.c
index 9ad4d893a566..d631a17186bc 100644
--- a/net/wimax/op-msg.c
+++ b/net/wimax/op-msg.c
@@ -108,6 +108,12 @@
  * Don't use skb_push()/skb_pull()/skb_reserve() on the skb, as
  * wimax_msg_send() depends on skb->data being placed at the
  * beginning of the user message.
+ *
+ * Unlike other WiMAX stack calls, this call can be used way early,
+ * even before wimax_dev_add() is called, as long as the
+ * wimax_dev->net_dev pointer is set to point to a proper
+ * net_dev. This is so that drivers can use it early in case they need
+ * to send stuff around or communicate with user space.
  */
 struct sk_buff *wimax_msg_alloc(struct wimax_dev *wimax_dev,
                                 const char *pipe_name,
@@ -115,7 +121,7 @@ struct sk_buff *wimax_msg_alloc(struct wimax_dev *wimax_dev,
                                 gfp_t gfp_flags)
 {
         int result;
-        struct device *dev = wimax_dev->net_dev->dev.parent;
+        struct device *dev = wimax_dev_to_dev(wimax_dev);
         size_t msg_size;
         void *genl_msg;
         struct sk_buff *skb;
@@ -161,7 +167,6 @@ error_genlmsg_put:
 error_new:
         nlmsg_free(skb);
         return ERR_PTR(result);
-
 }
 EXPORT_SYMBOL_GPL(wimax_msg_alloc);
 
@@ -256,10 +261,16 @@ EXPORT_SYMBOL_GPL(wimax_msg_len);
  * Don't use skb_push()/skb_pull()/skb_reserve() on the skb, as
  * wimax_msg_send() depends on skb->data being placed at the
  * beginning of the user message.
+ *
+ * Unlike other WiMAX stack calls, this call can be used way early,
+ * even before wimax_dev_add() is called, as long as the
+ * wimax_dev->net_dev pointer is set to point to a proper
+ * net_dev. This is so that drivers can use it early in case they need
+ * to send stuff around or communicate with user space.
  */
 int wimax_msg_send(struct wimax_dev *wimax_dev, struct sk_buff *skb)
 {
-        struct device *dev = wimax_dev->net_dev->dev.parent;
+        struct device *dev = wimax_dev_to_dev(wimax_dev);
         void *msg = skb->data;
         size_t size = skb->len;
         might_sleep();
diff --git a/net/wimax/op-rfkill.c b/net/wimax/op-rfkill.c
index 2b75aee04217..70ef4df863b9 100644
--- a/net/wimax/op-rfkill.c
+++ b/net/wimax/op-rfkill.c
@@ -29,8 +29,8 @@
  * A non-polled generic rfkill device is embedded into the WiMAX
  * subsystem's representation of a device.
  *
- * FIXME: Need polled support? use a timer or add the implementation
- *     to the stack.
+ * FIXME: Need polled support? Let drivers provide a poll routine
+ *        and hand it to rfkill ops then?
  *
  * All device drivers have to do is after wimax_dev_init(), call
  * wimax_report_rfkill_hw() and wimax_report_rfkill_sw() to update
@@ -43,7 +43,7 @@
  *   wimax_rfkill()             Kernel calling wimax_rfkill()
  *     __wimax_rf_toggle_radio()
  *
- * wimax_rfkill_toggle_radio()  RF-Kill subsytem calling
+ * wimax_rfkill_set_radio_block()  RF-Kill subsytem calling
  *   __wimax_rf_toggle_radio()
  *
  * __wimax_rf_toggle_radio()
@@ -65,15 +65,11 @@
 #include <linux/wimax.h>
 #include <linux/security.h>
 #include <linux/rfkill.h>
-#include <linux/input.h>
 #include "wimax-internal.h"
 
 #define D_SUBMODULE op_rfkill
 #include "debug-levels.h"
 
-#if defined(CONFIG_RFKILL) || defined(CONFIG_RFKILL_MODULE)
-
-
 /**
  * wimax_report_rfkill_hw - Reports changes in the hardware RF switch
  *
@@ -99,7 +95,6 @@ void wimax_report_rfkill_hw(struct wimax_dev *wimax_dev,
         int result;
         struct device *dev = wimax_dev_to_dev(wimax_dev);
         enum wimax_st wimax_state;
-        enum rfkill_state rfkill_state;
 
         d_fnstart(3, dev, "(wimax_dev %p state %u)\n", wimax_dev, state);
         BUG_ON(state == WIMAX_RF_QUERY);
@@ -112,16 +107,16 @@ void wimax_report_rfkill_hw(struct wimax_dev *wimax_dev,
 
         if (state != wimax_dev->rf_hw) {
                 wimax_dev->rf_hw = state;
-                rfkill_state = state == WIMAX_RF_ON ?
-                        RFKILL_STATE_OFF : RFKILL_STATE_ON;
                 if (wimax_dev->rf_hw == WIMAX_RF_ON
                     && wimax_dev->rf_sw == WIMAX_RF_ON)
                         wimax_state = WIMAX_ST_READY;
                 else
                         wimax_state = WIMAX_ST_RADIO_OFF;
+
+                result = rfkill_set_hw_state(wimax_dev->rfkill,
+                                             state == WIMAX_RF_OFF);
+
                 __wimax_state_change(wimax_dev, wimax_state);
-                input_report_key(wimax_dev->rfkill_input, KEY_WIMAX,
-                                 rfkill_state);
         }
 error_not_ready:
         mutex_unlock(&wimax_dev->mutex);
@@ -174,6 +169,7 @@ void wimax_report_rfkill_sw(struct wimax_dev *wimax_dev,
                 else
                         wimax_state = WIMAX_ST_RADIO_OFF;
                 __wimax_state_change(wimax_dev, wimax_state);
+                rfkill_set_sw_state(wimax_dev->rfkill, state == WIMAX_RF_OFF);
         }
 error_not_ready:
         mutex_unlock(&wimax_dev->mutex);
@@ -249,36 +245,31 @@ out_no_change:
  *
  * NOTE: This call will block until the operation is completed.
  */
-static
-int wimax_rfkill_toggle_radio(void *data, enum rfkill_state state)
+static int wimax_rfkill_set_radio_block(void *data, bool blocked)
 {
         int result;
         struct wimax_dev *wimax_dev = data;
         struct device *dev = wimax_dev_to_dev(wimax_dev);
         enum wimax_rf_state rf_state;
 
-        d_fnstart(3, dev, "(wimax_dev %p state %u)\n", wimax_dev, state);
-        switch (state) {
-        case RFKILL_STATE_ON:
+        d_fnstart(3, dev, "(wimax_dev %p blocked %u)\n", wimax_dev, blocked);
+        rf_state = WIMAX_RF_ON;
+        if (blocked)
                 rf_state = WIMAX_RF_OFF;
-                break;
-        case RFKILL_STATE_OFF:
-                rf_state = WIMAX_RF_ON;
-                break;
-        default:
-                BUG();
-        }
         mutex_lock(&wimax_dev->mutex);
         if (wimax_dev->state <= __WIMAX_ST_QUIESCING)
-                result = 0;     /* just pretend it didn't happen */
+                result = 0;
         else
                 result = __wimax_rf_toggle_radio(wimax_dev, rf_state);
         mutex_unlock(&wimax_dev->mutex);
-        d_fnend(3, dev, "(wimax_dev %p state %u) = %d\n",
-                wimax_dev, state, result);
+        d_fnend(3, dev, "(wimax_dev %p blocked %u) = %d\n",
+                wimax_dev, blocked, result);
         return result;
 }
 
+static const struct rfkill_ops wimax_rfkill_ops = {
+        .set_block = wimax_rfkill_set_radio_block,
+};
 
 /**
  * wimax_rfkill - Set the software RF switch state for a WiMAX device
@@ -322,6 +313,7 @@ int wimax_rfkill(struct wimax_dev *wimax_dev, enum wimax_rf_state state)
                 result = __wimax_rf_toggle_radio(wimax_dev, state);
                 if (result < 0)
                         goto error;
+                rfkill_set_sw_state(wimax_dev->rfkill, state == WIMAX_RF_OFF);
                 break;
         case WIMAX_RF_QUERY:
                 break;
@@ -349,41 +341,20 @@ int wimax_rfkill_add(struct wimax_dev *wimax_dev)
 {
         int result;
         struct rfkill *rfkill;
-        struct input_dev *input_dev;
         struct device *dev = wimax_dev_to_dev(wimax_dev);
 
         d_fnstart(3, dev, "(wimax_dev %p)\n", wimax_dev);
         /* Initialize RF Kill */
         result = -ENOMEM;
-        rfkill = rfkill_allocate(dev, RFKILL_TYPE_WIMAX);
+        rfkill = rfkill_alloc(wimax_dev->name, dev, RFKILL_TYPE_WIMAX,
+                              &wimax_rfkill_ops, wimax_dev);
         if (rfkill == NULL)
                 goto error_rfkill_allocate;
+
+        d_printf(1, dev, "rfkill %p\n", rfkill);
+
         wimax_dev->rfkill = rfkill;
 
-        rfkill->name = wimax_dev->name;
-        rfkill->state = RFKILL_STATE_OFF;
-        rfkill->data = wimax_dev;
-        rfkill->toggle_radio = wimax_rfkill_toggle_radio;
-        rfkill->user_claim_unsupported = 1;
-
-        /* Initialize the input device for the hw key */
-        input_dev = input_allocate_device();
-        if (input_dev == NULL)
-                goto error_input_allocate;
-        wimax_dev->rfkill_input = input_dev;
-        d_printf(1, dev, "rfkill %p input %p\n", rfkill, input_dev);
-
-        input_dev->name = wimax_dev->name;
-        /* FIXME: get a real device bus ID and stuff? do we care? */
-        input_dev->id.bustype = BUS_HOST;
-        input_dev->id.vendor = 0xffff;
-        input_dev->evbit[0] = BIT(EV_KEY);
-        set_bit(KEY_WIMAX, input_dev->keybit);
-
-        /* Register both */
-        result = input_register_device(wimax_dev->rfkill_input);
-        if (result < 0)
-                goto error_input_register;
         result = rfkill_register(wimax_dev->rfkill);
         if (result < 0)
                 goto error_rfkill_register;
@@ -395,17 +366,8 @@ int wimax_rfkill_add(struct wimax_dev *wimax_dev)
         d_fnend(3, dev, "(wimax_dev %p) = 0\n", wimax_dev);
         return 0;
 
-        /* if rfkill_register() suceeds, can't use rfkill_free() any
-         * more, only rfkill_unregister() [it owns the refcount]; with
-         * the input device we have the same issue--hence the if. */
 error_rfkill_register:
-        input_unregister_device(wimax_dev->rfkill_input);
-        wimax_dev->rfkill_input = NULL;
-error_input_register:
-        if (wimax_dev->rfkill_input)
-                input_free_device(wimax_dev->rfkill_input);
-error_input_allocate:
-        rfkill_free(wimax_dev->rfkill);
+        rfkill_destroy(wimax_dev->rfkill);
 error_rfkill_allocate:
         d_fnend(3, dev, "(wimax_dev %p) = %d\n", wimax_dev, result);
         return result;
@@ -424,45 +386,12 @@ void wimax_rfkill_rm(struct wimax_dev *wimax_dev)
 {
         struct device *dev = wimax_dev_to_dev(wimax_dev);
         d_fnstart(3, dev, "(wimax_dev %p)\n", wimax_dev);
-        rfkill_unregister(wimax_dev->rfkill);   /* frees */
-        input_unregister_device(wimax_dev->rfkill_input);
+        rfkill_unregister(wimax_dev->rfkill);
+        rfkill_destroy(wimax_dev->rfkill);
         d_fnend(3, dev, "(wimax_dev %p)\n", wimax_dev);
 }
 
 
-#else /* #ifdef CONFIG_RFKILL */
-
-void wimax_report_rfkill_hw(struct wimax_dev *wimax_dev,
-                            enum wimax_rf_state state)
-{
-}
-EXPORT_SYMBOL_GPL(wimax_report_rfkill_hw);
-
-void wimax_report_rfkill_sw(struct wimax_dev *wimax_dev,
-                            enum wimax_rf_state state)
-{
-}
-EXPORT_SYMBOL_GPL(wimax_report_rfkill_sw);
-
-int wimax_rfkill(struct wimax_dev *wimax_dev,
-                 enum wimax_rf_state state)
-{
-        return WIMAX_RF_ON << 1 | WIMAX_RF_ON;
-}
-EXPORT_SYMBOL_GPL(wimax_rfkill);
-
-int wimax_rfkill_add(struct wimax_dev *wimax_dev)
-{
-        return 0;
-}
-
-void wimax_rfkill_rm(struct wimax_dev *wimax_dev)
-{
-}
-
-#endif /* #ifdef CONFIG_RFKILL */
-
-
 /*
  * Exporting to user space over generic netlink
  *
diff --git a/net/wimax/op-state-get.c b/net/wimax/op-state-get.c
new file mode 100644
index 000000000000..a76b8fcb056d
--- /dev/null
+++ b/net/wimax/op-state-get.c
@@ -0,0 +1,86 @@
+/*
+ * Linux WiMAX
+ * Implement and export a method for getting a WiMAX device current state
+ *
+ * Copyright (C) 2009 Paulius Zaleckas <paulius.zaleckas@teltonika.lt>
+ *
+ * Based on previous WiMAX core work by:
+ *  Copyright (C) 2008 Intel Corporation <linux-wimax@intel.com>
+ *  Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.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.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ */
+
+#include <net/wimax.h>
+#include <net/genetlink.h>
+#include <linux/wimax.h>
+#include <linux/security.h>
+#include "wimax-internal.h"
+
+#define D_SUBMODULE op_state_get
+#include "debug-levels.h"
+
+
+static const
+struct nla_policy wimax_gnl_state_get_policy[WIMAX_GNL_ATTR_MAX + 1] = {
+        [WIMAX_GNL_STGET_IFIDX] = {
+                .type = NLA_U32,
+        },
+};
+
+
+/*
+ * Exporting to user space over generic netlink
+ *
+ * Parse the state get command from user space, return a combination
+ * value that describe the current state.
+ *
+ * No attributes.
+ */
+static
+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;
+        if (info->attrs[WIMAX_GNL_STGET_IFIDX] == NULL) {
+                printk(KERN_ERR "WIMAX_GNL_OP_STATE_GET: can't find IFIDX "
+                        "attribute\n");
+                goto error_no_wimax_dev;
+        }
+        ifindex = nla_get_u32(info->attrs[WIMAX_GNL_STGET_IFIDX]);
+        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);
+error_no_wimax_dev:
+        d_fnend(3, NULL, "(skb %p info %p) = %d\n", skb, info, result);
+        return result;
+}
+
+
+struct genl_ops wimax_gnl_state_get = {
+        .cmd = WIMAX_GNL_OP_STATE_GET,
+        .flags = GENL_ADMIN_PERM,
+        .policy = wimax_gnl_state_get_policy,
+        .doit = wimax_gnl_doit_state_get,
+        .dumpit = NULL,
+};
diff --git a/net/wimax/stack.c b/net/wimax/stack.c
index 933e1422b09f..79fb7d7c640f 100644
--- a/net/wimax/stack.c
+++ b/net/wimax/stack.c
@@ -402,13 +402,15 @@ EXPORT_SYMBOL_GPL(wimax_dev_init);
 extern struct genl_ops
         wimax_gnl_msg_from_user,
         wimax_gnl_reset,
-        wimax_gnl_rfkill;
+        wimax_gnl_rfkill,
+        wimax_gnl_state_get;
 
 static
 struct genl_ops *wimax_gnl_ops[] = {
         &wimax_gnl_msg_from_user,
         &wimax_gnl_reset,
         &wimax_gnl_rfkill,
+        &wimax_gnl_state_get,
 };
 
 
@@ -533,6 +535,7 @@ struct d_level D_LEVEL[] = {
         D_SUBMODULE_DEFINE(op_msg),
         D_SUBMODULE_DEFINE(op_reset),
         D_SUBMODULE_DEFINE(op_rfkill),
+        D_SUBMODULE_DEFINE(op_state_get),
         D_SUBMODULE_DEFINE(stack),
 };
 size_t D_LEVEL_SIZE = ARRAY_SIZE(D_LEVEL);
diff --git a/net/wireless/Kconfig b/net/wireless/Kconfig
index 3c3bc9e579ed..4428dd5e911d 100644
--- a/net/wireless/Kconfig
+++ b/net/wireless/Kconfig
@@ -1,5 +1,6 @@
 config CFG80211
-        tristate "Improved wireless configuration API"
+        tristate "Improved wireless configuration API"
+        depends on RFKILL || !RFKILL
 
 config CFG80211_REG_DEBUG
         bool "cfg80211 regulatory debugging"
@@ -10,6 +11,14 @@ config CFG80211_REG_DEBUG
 
           If unsure, say N.
 
+config CFG80211_DEBUGFS
+        bool "cfg80211 DebugFS entries"
+        depends on CFG80211 && DEBUG_FS
+        ---help---
+          You can enable this if you want to debugfs entries for cfg80211.
+
+          If unsure, say N.
+
 config WIRELESS_OLD_REGULATORY
         bool "Old wireless static regulatory definitions"
         default n
diff --git a/net/wireless/Makefile b/net/wireless/Makefile
index 6d1e7b27b752..f78c4832a9ca 100644
--- a/net/wireless/Makefile
+++ b/net/wireless/Makefile
@@ -5,7 +5,8 @@ obj-$(CONFIG_LIB80211_CRYPT_WEP) += lib80211_crypt_wep.o
 obj-$(CONFIG_LIB80211_CRYPT_CCMP) += lib80211_crypt_ccmp.o
 obj-$(CONFIG_LIB80211_CRYPT_TKIP) += lib80211_crypt_tkip.o
 
-cfg80211-y += core.o sysfs.o radiotap.o util.o reg.o scan.o nl80211.o mlme.o
+cfg80211-y += core.o sysfs.o radiotap.o util.o reg.o scan.o nl80211.o mlme.o ibss.o
+cfg80211-$(CONFIG_CFG80211_DEBUGFS) += debugfs.o
 cfg80211-$(CONFIG_WIRELESS_EXT) += wext-compat.o
 
 ccflags-y += -D__CHECK_ENDIAN__
diff --git a/net/wireless/core.c b/net/wireless/core.c
index d1f556535f6d..d5850292b3df 100644
--- a/net/wireless/core.c
+++ b/net/wireless/core.c
@@ -1,7 +1,7 @@
 /*
  * This is the linux wireless configuration interface.
  *
- * Copyright 2006-2008          Johannes Berg <johannes@sipsolutions.net>
+ * Copyright 2006-2009          Johannes Berg <johannes@sipsolutions.net>
  */
 
 #include <linux/if.h>
@@ -12,12 +12,13 @@
 #include <linux/debugfs.h>
 #include <linux/notifier.h>
 #include <linux/device.h>
+#include <linux/rtnetlink.h>
 #include <net/genetlink.h>
 #include <net/cfg80211.h>
-#include <net/wireless.h>
 #include "nl80211.h"
 #include "core.h"
 #include "sysfs.h"
+#include "debugfs.h"
 
 /* name for sysfs, %d is appended */
 #define PHY_NAME "phy"
@@ -227,9 +228,44 @@ int cfg80211_dev_rename(struct cfg80211_registered_device *rdev,
         return 0;
 }
 
+static void cfg80211_rfkill_poll(struct rfkill *rfkill, void *data)
+{
+        struct cfg80211_registered_device *drv = data;
+
+        drv->ops->rfkill_poll(&drv->wiphy);
+}
+
+static int cfg80211_rfkill_set_block(void *data, bool blocked)
+{
+        struct cfg80211_registered_device *drv = data;
+        struct wireless_dev *wdev;
+
+        if (!blocked)
+                return 0;
+
+        rtnl_lock();
+        mutex_lock(&drv->devlist_mtx);
+
+        list_for_each_entry(wdev, &drv->netdev_list, list)
+                dev_close(wdev->netdev);
+
+        mutex_unlock(&drv->devlist_mtx);
+        rtnl_unlock();
+
+        return 0;
+}
+
+static void cfg80211_rfkill_sync_work(struct work_struct *work)
+{
+        struct cfg80211_registered_device *drv;
+
+        drv = container_of(work, struct cfg80211_registered_device, rfkill_sync);
+        cfg80211_rfkill_set_block(drv, rfkill_blocked(drv->rfkill));
+}
+
 /* exported functions */
 
-struct wiphy *wiphy_new(struct cfg80211_ops *ops, int sizeof_priv)
+struct wiphy *wiphy_new(const struct cfg80211_ops *ops, int sizeof_priv)
 {
         static int wiphy_counter;
 
@@ -274,6 +310,28 @@ struct wiphy *wiphy_new(struct cfg80211_ops *ops, int sizeof_priv)
         drv->wiphy.dev.class = &ieee80211_class;
         drv->wiphy.dev.platform_data = drv;
 
+        drv->rfkill_ops.set_block = cfg80211_rfkill_set_block;
+        drv->rfkill = rfkill_alloc(dev_name(&drv->wiphy.dev),
+                                   &drv->wiphy.dev, RFKILL_TYPE_WLAN,
+                                   &drv->rfkill_ops, drv);
+
+        if (!drv->rfkill) {
+                kfree(drv);
+                return NULL;
+        }
+
+        INIT_WORK(&drv->rfkill_sync, cfg80211_rfkill_sync_work);
+
+        /*
+         * Initialize wiphy parameters to IEEE 802.11 MIB default values.
+         * Fragmentation and RTS threshold are disabled by default with the
+         * special -1 value.
+         */
+        drv->wiphy.retry_short = 7;
+        drv->wiphy.retry_long = 4;
+        drv->wiphy.frag_threshold = (u32) -1;
+        drv->wiphy.rts_threshold = (u32) -1;
+
         return &drv->wiphy;
 }
 EXPORT_SYMBOL(wiphy_new);
@@ -337,17 +395,23 @@ int wiphy_register(struct wiphy *wiphy)
         /* check and set up bitrates */
         ieee80211_set_bitrate_flags(wiphy);
 
+        res = device_add(&drv->wiphy.dev);
+        if (res)
+                return res;
+
+        res = rfkill_register(drv->rfkill);
+        if (res)
+                goto out_rm_dev;
+
         mutex_lock(&cfg80211_mutex);
 
         /* set up regulatory info */
         wiphy_update_regulatory(wiphy, NL80211_REGDOM_SET_BY_CORE);
 
-        res = device_add(&drv->wiphy.dev);
-        if (res)
-                goto out_unlock;
-
         list_add(&drv->list, &cfg80211_drv_list);
 
+        mutex_unlock(&cfg80211_mutex);
+
         /* add to debugfs */
         drv->wiphy.debugfsdir =
                 debugfs_create_dir(wiphy_name(&drv->wiphy),
@@ -366,17 +430,41 @@ int wiphy_register(struct wiphy *wiphy)
                 nl80211_send_reg_change_event(&request);
         }
 
-        res = 0;
-out_unlock:
-        mutex_unlock(&cfg80211_mutex);
+        cfg80211_debugfs_drv_add(drv);
+
+        return 0;
+
+ out_rm_dev:
+        device_del(&drv->wiphy.dev);
         return res;
 }
 EXPORT_SYMBOL(wiphy_register);
 
+void wiphy_rfkill_start_polling(struct wiphy *wiphy)
+{
+        struct cfg80211_registered_device *drv = wiphy_to_dev(wiphy);
+
+        if (!drv->ops->rfkill_poll)
+                return;
+        drv->rfkill_ops.poll = cfg80211_rfkill_poll;
+        rfkill_resume_polling(drv->rfkill);
+}
+EXPORT_SYMBOL(wiphy_rfkill_start_polling);
+
+void wiphy_rfkill_stop_polling(struct wiphy *wiphy)
+{
+        struct cfg80211_registered_device *drv = wiphy_to_dev(wiphy);
+
+        rfkill_pause_polling(drv->rfkill);
+}
+EXPORT_SYMBOL(wiphy_rfkill_stop_polling);
+
 void wiphy_unregister(struct wiphy *wiphy)
 {
         struct cfg80211_registered_device *drv = wiphy_to_dev(wiphy);
 
+        rfkill_unregister(drv->rfkill);
+
         /* protect the device list */
         mutex_lock(&cfg80211_mutex);
 
@@ -396,6 +484,8 @@ void wiphy_unregister(struct wiphy *wiphy)
         /* unlock again before freeing */
         mutex_unlock(&drv->mtx);
 
+        cfg80211_debugfs_drv_del(drv);
+
         /* If this device got a regulatory hint tell core its
          * free to listen now to a new shiny device regulatory hint */
         reg_device_remove(wiphy);
@@ -411,6 +501,7 @@ EXPORT_SYMBOL(wiphy_unregister);
 void cfg80211_dev_free(struct cfg80211_registered_device *drv)
 {
         struct cfg80211_internal_bss *scan, *tmp;
+        rfkill_destroy(drv->rfkill);
         mutex_destroy(&drv->mtx);
         mutex_destroy(&drv->devlist_mtx);
         list_for_each_entry_safe(scan, tmp, &drv->bss_list, list)
@@ -424,6 +515,15 @@ void wiphy_free(struct wiphy *wiphy)
 }
 EXPORT_SYMBOL(wiphy_free);
 
+void wiphy_rfkill_set_hw_state(struct wiphy *wiphy, bool blocked)
+{
+        struct cfg80211_registered_device *drv = wiphy_to_dev(wiphy);
+
+        if (rfkill_set_hw_state(drv->rfkill, blocked))
+                schedule_work(&drv->rfkill_sync);
+}
+EXPORT_SYMBOL(wiphy_rfkill_set_hw_state);
+
 static int cfg80211_netdev_notifier_call(struct notifier_block * nb,
                                          unsigned long state,
                                          void *ndev)
@@ -432,7 +532,7 @@ static int cfg80211_netdev_notifier_call(struct notifier_block * nb,
         struct cfg80211_registered_device *rdev;
 
         if (!dev->ieee80211_ptr)
-                return 0;
+                return NOTIFY_DONE;
 
         rdev = wiphy_to_dev(dev->ieee80211_ptr->wiphy);
 
@@ -448,8 +548,28 @@ static int cfg80211_netdev_notifier_call(struct notifier_block * nb,
                                 "symlink to netdev!\n");
                 }
                 dev->ieee80211_ptr->netdev = dev;
+#ifdef CONFIG_WIRELESS_EXT
+                dev->ieee80211_ptr->wext.default_key = -1;
+                dev->ieee80211_ptr->wext.default_mgmt_key = -1;
+#endif
                 mutex_unlock(&rdev->devlist_mtx);
                 break;
+        case NETDEV_GOING_DOWN:
+                if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC)
+                        break;
+                if (!dev->ieee80211_ptr->ssid_len)
+                        break;
+                cfg80211_leave_ibss(rdev, dev, true);
+                break;
+        case NETDEV_UP:
+#ifdef CONFIG_WIRELESS_EXT
+                if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC)
+                        break;
+                if (!dev->ieee80211_ptr->wext.ibss.ssid_len)
+                        break;
+                cfg80211_join_ibss(rdev, dev, &dev->ieee80211_ptr->wext.ibss);
+                break;
+#endif
         case NETDEV_UNREGISTER:
                 mutex_lock(&rdev->devlist_mtx);
                 if (!list_empty(&dev->ieee80211_ptr->list)) {
@@ -458,9 +578,13 @@ static int cfg80211_netdev_notifier_call(struct notifier_block * nb,
                 }
                 mutex_unlock(&rdev->devlist_mtx);
                 break;
+        case NETDEV_PRE_UP:
+                if (rfkill_blocked(rdev->rfkill))
+                        return notifier_from_errno(-ERFKILL);
+                break;
         }
 
-        return 0;
+        return NOTIFY_DONE;
 }
 
 static struct notifier_block cfg80211_netdev_notifier = {
diff --git a/net/wireless/core.h b/net/wireless/core.h
index 0a592e4295f0..bfa340c7abb5 100644
--- a/net/wireless/core.h
+++ b/net/wireless/core.h
@@ -1,7 +1,7 @@
 /*
  * Wireless configuration interface internals.
  *
- * Copyright 2006, 2007 Johannes Berg <johannes@sipsolutions.net>
+ * Copyright 2006-2009  Johannes Berg <johannes@sipsolutions.net>
  */
 #ifndef __NET_WIRELESS_CORE_H
 #define __NET_WIRELESS_CORE_H
@@ -10,14 +10,15 @@
 #include <linux/netdevice.h>
 #include <linux/kref.h>
 #include <linux/rbtree.h>
-#include <linux/mutex.h>
+#include <linux/debugfs.h>
+#include <linux/rfkill.h>
+#include <linux/workqueue.h>
 #include <net/genetlink.h>
-#include <net/wireless.h>
 #include <net/cfg80211.h>
 #include "reg.h"
 
 struct cfg80211_registered_device {
-        struct cfg80211_ops *ops;
+        const struct cfg80211_ops *ops;
         struct list_head list;
         /* we hold this mutex during any call so that
          * we cannot do multiple calls at once, and also
@@ -25,6 +26,11 @@ struct cfg80211_registered_device {
          * any call is in progress */
         struct mutex mtx;
 
+        /* rfkill support */
+        struct rfkill_ops rfkill_ops;
+        struct rfkill *rfkill;
+        struct work_struct rfkill_sync;
+
         /* ISO / IEC 3166 alpha2 for which this device is receiving
          * country IEs on, this can help disregard country IEs from APs
          * on the same alpha2 quickly. The alpha2 may differ from
@@ -52,6 +58,17 @@ struct cfg80211_registered_device {
         struct cfg80211_scan_request *scan_req; /* protected by RTNL */
         unsigned long suspend_at;
 
+#ifdef CONFIG_CFG80211_DEBUGFS
+        /* Debugfs entries */
+        struct wiphy_debugfsdentries {
+                struct dentry *rts_threshold;
+                struct dentry *fragmentation_threshold;
+                struct dentry *short_retry_limit;
+                struct dentry *long_retry_limit;
+                struct dentry *ht40allow_map;
+        } debugfs;
+#endif
+
         /* must be last because of the way we do wiphy_priv(),
          * and it should at least be aligned to NETDEV_ALIGN */
         struct wiphy wiphy __attribute__((__aligned__(NETDEV_ALIGN)));
@@ -74,10 +91,7 @@ bool wiphy_idx_valid(int wiphy_idx)
 extern struct mutex cfg80211_mutex;
 extern struct list_head cfg80211_drv_list;
 
-static inline void assert_cfg80211_lock(void)
-{
-        WARN_ON(!mutex_is_locked(&cfg80211_mutex));
-}
+#define assert_cfg80211_lock() WARN_ON(!mutex_is_locked(&cfg80211_mutex))
 
 /*
  * You can use this to mark a wiphy_idx as not having an associated wiphy.
@@ -148,4 +162,16 @@ void cfg80211_bss_expire(struct cfg80211_registered_device *dev);
 void cfg80211_bss_age(struct cfg80211_registered_device *dev,
                       unsigned long age_secs);
 
+/* IBSS */
+int cfg80211_join_ibss(struct cfg80211_registered_device *rdev,
+                       struct net_device *dev,
+                       struct cfg80211_ibss_params *params);
+void cfg80211_clear_ibss(struct net_device *dev, bool nowext);
+int cfg80211_leave_ibss(struct cfg80211_registered_device *rdev,
+                        struct net_device *dev, bool nowext);
+
+/* internal helpers */
+int cfg80211_validate_key_settings(struct key_params *params, int key_idx,
+                                   const u8 *mac_addr);
+
 #endif /* __NET_WIRELESS_CORE_H */
diff --git a/net/wireless/debugfs.c b/net/wireless/debugfs.c
new file mode 100644
index 000000000000..679ddfcec1ee
--- /dev/null
+++ b/net/wireless/debugfs.c
@@ -0,0 +1,131 @@
+/*
+ * cfg80211 debugfs
+ *
+ * Copyright 2009       Luis R. Rodriguez <lrodriguez@atheros.com>
+ * Copyright 2007       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 "core.h"
+#include "debugfs.h"
+
+static int cfg80211_open_file_generic(struct inode *inode, struct file *file)
+{
+        file->private_data = inode->i_private;
+        return 0;
+}
+
+#define DEBUGFS_READONLY_FILE(name, buflen, fmt, value...)              \
+static ssize_t name## _read(struct file *file, char __user *userbuf,    \
+                            size_t count, loff_t *ppos)                 \
+{                                                                       \
+        struct wiphy *wiphy= file->private_data;                \
+        char buf[buflen];                                               \
+        int res;                                                        \
+                                                                        \
+        res = scnprintf(buf, buflen, fmt "\n", ##value);                \
+        return simple_read_from_buffer(userbuf, count, ppos, buf, res); \
+}                                                                       \
+                                                                        \
+static const struct file_operations name## _ops = {                     \
+        .read = name## _read,                                           \
+        .open = cfg80211_open_file_generic,                             \
+};
+
+DEBUGFS_READONLY_FILE(rts_threshold, 20, "%d",
+                      wiphy->rts_threshold)
+DEBUGFS_READONLY_FILE(fragmentation_threshold, 20, "%d",
+                      wiphy->frag_threshold);
+DEBUGFS_READONLY_FILE(short_retry_limit, 20, "%d",
+                      wiphy->retry_short)
+DEBUGFS_READONLY_FILE(long_retry_limit, 20, "%d",
+                      wiphy->retry_long);
+
+static int ht_print_chan(struct ieee80211_channel *chan,
+                         char *buf, int buf_size, int offset)
+{
+        if (WARN_ON(offset > buf_size))
+                return 0;
+
+        if (chan->flags & IEEE80211_CHAN_DISABLED)
+                return snprintf(buf + offset,
+                                buf_size - offset,
+                                "%d Disabled\n",
+                                chan->center_freq);
+
+        return snprintf(buf + offset,
+                        buf_size - offset,
+                        "%d HT40 %c%c\n",
+                        chan->center_freq,
+                        (chan->flags & IEEE80211_CHAN_NO_HT40MINUS) ? ' ' : '-',
+                        (chan->flags & IEEE80211_CHAN_NO_HT40PLUS)  ? ' ' : '+');
+}
+
+static ssize_t ht40allow_map_read(struct file *file,
+                                  char __user *user_buf,
+                                  size_t count, loff_t *ppos)
+{
+        struct wiphy *wiphy = file->private_data;
+        char *buf;
+        unsigned int offset = 0, buf_size = PAGE_SIZE, i, r;
+        enum ieee80211_band band;
+        struct ieee80211_supported_band *sband;
+
+        buf = kzalloc(buf_size, GFP_KERNEL);
+        if (!buf)
+                return -ENOMEM;
+
+        mutex_lock(&cfg80211_mutex);
+
+        for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
+                sband = wiphy->bands[band];
+                if (!sband)
+                        continue;
+                for (i = 0; i < sband->n_channels; i++)
+                        offset += ht_print_chan(&sband->channels[i],
+                                                buf, buf_size, offset);
+        }
+
+        mutex_unlock(&cfg80211_mutex);
+
+        r = simple_read_from_buffer(user_buf, count, ppos, buf, offset);
+
+        kfree(buf);
+
+        return r;
+}
+
+static const struct file_operations ht40allow_map_ops = {
+        .read = ht40allow_map_read,
+        .open = cfg80211_open_file_generic,
+};
+
+#define DEBUGFS_ADD(name)                                               \
+        drv->debugfs.name = debugfs_create_file(#name, S_IRUGO, phyd,   \
+                                                  &drv->wiphy, &name## _ops);
+#define DEBUGFS_DEL(name)                                               \
+        debugfs_remove(drv->debugfs.name);                              \
+        drv->debugfs.name = NULL;
+
+void cfg80211_debugfs_drv_add(struct cfg80211_registered_device *drv)
+{
+        struct dentry *phyd = drv->wiphy.debugfsdir;
+
+        DEBUGFS_ADD(rts_threshold);
+        DEBUGFS_ADD(fragmentation_threshold);
+        DEBUGFS_ADD(short_retry_limit);
+        DEBUGFS_ADD(long_retry_limit);
+        DEBUGFS_ADD(ht40allow_map);
+}
+
+void cfg80211_debugfs_drv_del(struct cfg80211_registered_device *drv)
+{
+        DEBUGFS_DEL(rts_threshold);
+        DEBUGFS_DEL(fragmentation_threshold);
+        DEBUGFS_DEL(short_retry_limit);
+        DEBUGFS_DEL(long_retry_limit);
+        DEBUGFS_DEL(ht40allow_map);
+}
diff --git a/net/wireless/debugfs.h b/net/wireless/debugfs.h
new file mode 100644
index 000000000000..c226983ae66b
--- /dev/null
+++ b/net/wireless/debugfs.h
@@ -0,0 +1,14 @@
+#ifndef __CFG80211_DEBUGFS_H
+#define __CFG80211_DEBUGFS_H
+
+#ifdef CONFIG_CFG80211_DEBUGFS
+void cfg80211_debugfs_drv_add(struct cfg80211_registered_device *drv);
+void cfg80211_debugfs_drv_del(struct cfg80211_registered_device *drv);
+#else
+static inline
+void cfg80211_debugfs_drv_add(struct cfg80211_registered_device *drv) {}
+static inline
+void cfg80211_debugfs_drv_del(struct cfg80211_registered_device *drv) {}
+#endif
+
+#endif /* __CFG80211_DEBUGFS_H */
diff --git a/net/wireless/ibss.c b/net/wireless/ibss.c
new file mode 100644
index 000000000000..a4a1c3498ff2
--- /dev/null
+++ b/net/wireless/ibss.c
@@ -0,0 +1,369 @@
+/*
+ * Some IBSS support code for cfg80211.
+ *
+ * Copyright 2009       Johannes Berg <johannes@sipsolutions.net>
+ */
+
+#include <linux/etherdevice.h>
+#include <linux/if_arp.h>
+#include <net/cfg80211.h>
+#include "nl80211.h"
+
+
+void cfg80211_ibss_joined(struct net_device *dev, const u8 *bssid, gfp_t gfp)
+{
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+        struct cfg80211_bss *bss;
+#ifdef CONFIG_WIRELESS_EXT
+        union iwreq_data wrqu;
+#endif
+
+        if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC))
+                return;
+
+        if (WARN_ON(!wdev->ssid_len))
+                return;
+
+        if (memcmp(bssid, wdev->bssid, ETH_ALEN) == 0)
+                return;
+
+        bss = cfg80211_get_bss(wdev->wiphy, NULL, bssid,
+                               wdev->ssid, wdev->ssid_len,
+                               WLAN_CAPABILITY_IBSS, WLAN_CAPABILITY_IBSS);
+
+        if (WARN_ON(!bss))
+                return;
+
+        if (wdev->current_bss) {
+                cfg80211_unhold_bss(wdev->current_bss);
+                cfg80211_put_bss(wdev->current_bss);
+        }
+
+        cfg80211_hold_bss(bss);
+        wdev->current_bss = bss;
+        memcpy(wdev->bssid, bssid, ETH_ALEN);
+
+        nl80211_send_ibss_bssid(wiphy_to_dev(wdev->wiphy), dev, bssid, gfp);
+#ifdef CONFIG_WIRELESS_EXT
+        memset(&wrqu, 0, sizeof(wrqu));
+        memcpy(wrqu.ap_addr.sa_data, bssid, ETH_ALEN);
+        wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL);
+#endif
+}
+EXPORT_SYMBOL(cfg80211_ibss_joined);
+
+int cfg80211_join_ibss(struct cfg80211_registered_device *rdev,
+                       struct net_device *dev,
+                       struct cfg80211_ibss_params *params)
+{
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+        int err;
+
+        if (wdev->ssid_len)
+                return -EALREADY;
+
+#ifdef CONFIG_WIRELESS_EXT
+        wdev->wext.ibss.channel = params->channel;
+#endif
+        err = rdev->ops->join_ibss(&rdev->wiphy, dev, params);
+
+        if (err)
+                return err;
+
+        memcpy(wdev->ssid, params->ssid, params->ssid_len);
+        wdev->ssid_len = params->ssid_len;
+
+        return 0;
+}
+
+void cfg80211_clear_ibss(struct net_device *dev, bool nowext)
+{
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+
+        if (wdev->current_bss) {
+                cfg80211_unhold_bss(wdev->current_bss);
+                cfg80211_put_bss(wdev->current_bss);
+        }
+
+        wdev->current_bss = NULL;
+        wdev->ssid_len = 0;
+        memset(wdev->bssid, 0, ETH_ALEN);
+#ifdef CONFIG_WIRELESS_EXT
+        if (!nowext)
+                wdev->wext.ibss.ssid_len = 0;
+#endif
+}
+
+int cfg80211_leave_ibss(struct cfg80211_registered_device *rdev,
+                        struct net_device *dev, bool nowext)
+{
+        int err;
+
+        err = rdev->ops->leave_ibss(&rdev->wiphy, dev);
+
+        if (err)
+                return err;
+
+        cfg80211_clear_ibss(dev, nowext);
+
+        return 0;
+}
+
+#ifdef CONFIG_WIRELESS_EXT
+static int cfg80211_ibss_wext_join(struct cfg80211_registered_device *rdev,
+                                   struct wireless_dev *wdev)
+{
+        enum ieee80211_band band;
+        int i;
+
+        if (!wdev->wext.ibss.beacon_interval)
+                wdev->wext.ibss.beacon_interval = 100;
+
+        /* try to find an IBSS channel if none requested ... */
+        if (!wdev->wext.ibss.channel) {
+                for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
+                        struct ieee80211_supported_band *sband;
+                        struct ieee80211_channel *chan;
+
+                        sband = rdev->wiphy.bands[band];
+                        if (!sband)
+                                continue;
+
+                        for (i = 0; i < sband->n_channels; i++) {
+                                chan = &sband->channels[i];
+                                if (chan->flags & IEEE80211_CHAN_NO_IBSS)
+                                        continue;
+                                if (chan->flags & IEEE80211_CHAN_DISABLED)
+                                        continue;
+                                wdev->wext.ibss.channel = chan;
+                                break;
+                        }
+
+                        if (wdev->wext.ibss.channel)
+                                break;
+                }
+
+                if (!wdev->wext.ibss.channel)
+                        return -EINVAL;
+        }
+
+        /* don't join -- SSID is not there */
+        if (!wdev->wext.ibss.ssid_len)
+                return 0;
+
+        if (!netif_running(wdev->netdev))
+                return 0;
+
+        return cfg80211_join_ibss(wiphy_to_dev(wdev->wiphy),
+                                  wdev->netdev, &wdev->wext.ibss);
+}
+
+int cfg80211_ibss_wext_siwfreq(struct net_device *dev,
+                               struct iw_request_info *info,
+                               struct iw_freq *freq, char *extra)
+{
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+        struct ieee80211_channel *chan;
+        int err;
+
+        /* call only for ibss! */
+        if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC))
+                return -EINVAL;
+
+        if (!wiphy_to_dev(wdev->wiphy)->ops->join_ibss)
+                return -EOPNOTSUPP;
+
+        chan = cfg80211_wext_freq(wdev->wiphy, freq);
+        if (chan && IS_ERR(chan))
+                return PTR_ERR(chan);
+
+        if (chan &&
+            (chan->flags & IEEE80211_CHAN_NO_IBSS ||
+             chan->flags & IEEE80211_CHAN_DISABLED))
+                return -EINVAL;
+
+        if (wdev->wext.ibss.channel == chan)
+                return 0;
+
+        if (wdev->ssid_len) {
+                err = cfg80211_leave_ibss(wiphy_to_dev(wdev->wiphy),
+                                          dev, true);
+                if (err)
+                        return err;
+        }
+
+        if (chan) {
+                wdev->wext.ibss.channel = chan;
+                wdev->wext.ibss.channel_fixed = true;
+        } else {
+                /* cfg80211_ibss_wext_join will pick one if needed */
+                wdev->wext.ibss.channel_fixed = false;
+        }
+
+        return cfg80211_ibss_wext_join(wiphy_to_dev(wdev->wiphy), wdev);
+}
+/* temporary symbol - mark GPL - in the future the handler won't be */
+EXPORT_SYMBOL_GPL(cfg80211_ibss_wext_siwfreq);
+
+int cfg80211_ibss_wext_giwfreq(struct net_device *dev,
+                               struct iw_request_info *info,
+                               struct iw_freq *freq, char *extra)
+{
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+        struct ieee80211_channel *chan = NULL;
+
+        /* call only for ibss! */
+        if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC))
+                return -EINVAL;
+
+        if (wdev->current_bss)
+                chan = wdev->current_bss->channel;
+        else if (wdev->wext.ibss.channel)
+                chan = wdev->wext.ibss.channel;
+
+        if (chan) {
+                freq->m = chan->center_freq;
+                freq->e = 6;
+                return 0;
+        }
+
+        /* no channel if not joining */
+        return -EINVAL;
+}
+/* temporary symbol - mark GPL - in the future the handler won't be */
+EXPORT_SYMBOL_GPL(cfg80211_ibss_wext_giwfreq);
+
+int cfg80211_ibss_wext_siwessid(struct net_device *dev,
+                                struct iw_request_info *info,
+                                struct iw_point *data, char *ssid)
+{
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+        size_t len = data->length;
+        int err;
+
+        /* call only for ibss! */
+        if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC))
+                return -EINVAL;
+
+        if (!wiphy_to_dev(wdev->wiphy)->ops->join_ibss)
+                return -EOPNOTSUPP;
+
+        if (wdev->ssid_len) {
+                err = cfg80211_leave_ibss(wiphy_to_dev(wdev->wiphy),
+                                          dev, true);
+                if (err)
+                        return err;
+        }
+
+        /* iwconfig uses nul termination in SSID.. */
+        if (len > 0 && ssid[len - 1] == '\0')
+                len--;
+
+        wdev->wext.ibss.ssid = wdev->ssid;
+        memcpy(wdev->wext.ibss.ssid, ssid, len);
+        wdev->wext.ibss.ssid_len = len;
+
+        return cfg80211_ibss_wext_join(wiphy_to_dev(wdev->wiphy), wdev);
+}
+/* temporary symbol - mark GPL - in the future the handler won't be */
+EXPORT_SYMBOL_GPL(cfg80211_ibss_wext_siwessid);
+
+int cfg80211_ibss_wext_giwessid(struct net_device *dev,
+                                struct iw_request_info *info,
+                                struct iw_point *data, char *ssid)
+{
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+
+        /* call only for ibss! */
+        if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC))
+                return -EINVAL;
+
+        data->flags = 0;
+
+        if (wdev->ssid_len) {
+                data->flags = 1;
+                data->length = wdev->ssid_len;
+                memcpy(ssid, wdev->ssid, data->length);
+        } else if (wdev->wext.ibss.ssid && wdev->wext.ibss.ssid_len) {
+                data->flags = 1;
+                data->length = wdev->wext.ibss.ssid_len;
+                memcpy(ssid, wdev->wext.ibss.ssid, data->length);
+        }
+
+        return 0;
+}
+/* temporary symbol - mark GPL - in the future the handler won't be */
+EXPORT_SYMBOL_GPL(cfg80211_ibss_wext_giwessid);
+
+int cfg80211_ibss_wext_siwap(struct net_device *dev,
+                             struct iw_request_info *info,
+                             struct sockaddr *ap_addr, char *extra)
+{
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+        u8 *bssid = ap_addr->sa_data;
+        int err;
+
+        /* call only for ibss! */
+        if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC))
+                return -EINVAL;
+
+        if (!wiphy_to_dev(wdev->wiphy)->ops->join_ibss)
+                return -EOPNOTSUPP;
+
+        if (ap_addr->sa_family != ARPHRD_ETHER)
+                return -EINVAL;
+
+        /* automatic mode */
+        if (is_zero_ether_addr(bssid) || is_broadcast_ether_addr(bssid))
+                bssid = NULL;
+
+        /* both automatic */
+        if (!bssid && !wdev->wext.ibss.bssid)
+                return 0;
+
+        /* fixed already - and no change */
+        if (wdev->wext.ibss.bssid && bssid &&
+            compare_ether_addr(bssid, wdev->wext.ibss.bssid) == 0)
+                return 0;
+
+        if (wdev->ssid_len) {
+                err = cfg80211_leave_ibss(wiphy_to_dev(wdev->wiphy),
+                                          dev, true);
+                if (err)
+                        return err;
+        }
+
+        if (bssid) {
+                memcpy(wdev->wext.bssid, bssid, ETH_ALEN);
+                wdev->wext.ibss.bssid = wdev->wext.bssid;
+        } else
+                wdev->wext.ibss.bssid = NULL;
+
+        return cfg80211_ibss_wext_join(wiphy_to_dev(wdev->wiphy), wdev);
+}
+/* temporary symbol - mark GPL - in the future the handler won't be */
+EXPORT_SYMBOL_GPL(cfg80211_ibss_wext_siwap);
+
+int cfg80211_ibss_wext_giwap(struct net_device *dev,
+                             struct iw_request_info *info,
+                             struct sockaddr *ap_addr, char *extra)
+{
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+
+        /* call only for ibss! */
+        if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC))
+                return -EINVAL;
+
+        ap_addr->sa_family = ARPHRD_ETHER;
+
+        if (wdev->wext.ibss.bssid) {
+                memcpy(ap_addr->sa_data, wdev->wext.ibss.bssid, ETH_ALEN);
+                return 0;
+        }
+
+        memcpy(ap_addr->sa_data, wdev->bssid, ETH_ALEN);
+        return 0;
+}
+/* temporary symbol - mark GPL - in the future the handler won't be */
+EXPORT_SYMBOL_GPL(cfg80211_ibss_wext_giwap);
+#endif
diff --git a/net/wireless/mlme.c b/net/wireless/mlme.c
index bec5721b6f99..42184361a109 100644
--- a/net/wireless/mlme.c
+++ b/net/wireless/mlme.c
@@ -28,19 +28,55 @@ void cfg80211_send_rx_assoc(struct net_device *dev, const u8 *buf, size_t len)
 }
 EXPORT_SYMBOL(cfg80211_send_rx_assoc);
 
-void cfg80211_send_rx_deauth(struct net_device *dev, const u8 *buf, size_t len)
+void cfg80211_send_deauth(struct net_device *dev, const u8 *buf, size_t len)
 {
         struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
-        nl80211_send_rx_deauth(rdev, dev, buf, len);
+        nl80211_send_deauth(rdev, dev, buf, len);
 }
-EXPORT_SYMBOL(cfg80211_send_rx_deauth);
+EXPORT_SYMBOL(cfg80211_send_deauth);
 
-void cfg80211_send_rx_disassoc(struct net_device *dev, const u8 *buf,
-                               size_t len)
+void cfg80211_send_disassoc(struct net_device *dev, const u8 *buf, size_t len)
 {
         struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
-        nl80211_send_rx_disassoc(rdev, dev, buf, len);
+        nl80211_send_disassoc(rdev, dev, buf, len);
 }
-EXPORT_SYMBOL(cfg80211_send_rx_disassoc);
+EXPORT_SYMBOL(cfg80211_send_disassoc);
+
+static void cfg80211_wext_disconnected(struct net_device *dev)
+{
+#ifdef CONFIG_WIRELESS_EXT
+        union iwreq_data wrqu;
+        memset(&wrqu, 0, sizeof(wrqu));
+        wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL);
+#endif
+}
+
+void cfg80211_send_auth_timeout(struct net_device *dev, const u8 *addr)
+{
+        struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
+        struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
+        nl80211_send_auth_timeout(rdev, dev, addr);
+        cfg80211_wext_disconnected(dev);
+}
+EXPORT_SYMBOL(cfg80211_send_auth_timeout);
+
+void cfg80211_send_assoc_timeout(struct net_device *dev, const u8 *addr)
+{
+        struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
+        struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
+        nl80211_send_assoc_timeout(rdev, dev, addr);
+        cfg80211_wext_disconnected(dev);
+}
+EXPORT_SYMBOL(cfg80211_send_assoc_timeout);
+
+void cfg80211_michael_mic_failure(struct net_device *dev, const u8 *addr,
+                                  enum nl80211_key_type key_type, int key_id,
+                                  const u8 *tsc)
+{
+        struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
+        struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
+        nl80211_michael_mic_failure(rdev, dev, addr, key_type, key_id, tsc);
+}
+EXPORT_SYMBOL(cfg80211_michael_mic_failure);
diff --git a/net/wireless/nl80211.c b/net/wireless/nl80211.c
index 2456e4ee445e..24168560ebae 100644
--- a/net/wireless/nl80211.c
+++ b/net/wireless/nl80211.c
@@ -1,7 +1,7 @@
 /*
  * This is the new netlink-based wireless configuration interface.
  *
- * Copyright 2006, 2007 Johannes Berg <johannes@sipsolutions.net>
+ * Copyright 2006-2009  Johannes Berg <johannes@sipsolutions.net>
  */
 
 #include <linux/if.h>
@@ -57,10 +57,14 @@ static int get_drv_dev_by_info_ifindex(struct nlattr **attrs,
 static struct nla_policy nl80211_policy[NL80211_ATTR_MAX+1] __read_mostly = {
         [NL80211_ATTR_WIPHY] = { .type = NLA_U32 },
         [NL80211_ATTR_WIPHY_NAME] = { .type = NLA_NUL_STRING,
-                                      .len = BUS_ID_SIZE-1 },
+                                      .len = 20-1 },
         [NL80211_ATTR_WIPHY_TXQ_PARAMS] = { .type = NLA_NESTED },
         [NL80211_ATTR_WIPHY_FREQ] = { .type = NLA_U32 },
         [NL80211_ATTR_WIPHY_CHANNEL_TYPE] = { .type = NLA_U32 },
+        [NL80211_ATTR_WIPHY_RETRY_SHORT] = { .type = NLA_U8 },
+        [NL80211_ATTR_WIPHY_RETRY_LONG] = { .type = NLA_U8 },
+        [NL80211_ATTR_WIPHY_FRAG_THRESHOLD] = { .type = NLA_U32 },
+        [NL80211_ATTR_WIPHY_RTS_THRESHOLD] = { .type = NLA_U32 },
 
         [NL80211_ATTR_IFTYPE] = { .type = NLA_U32 },
         [NL80211_ATTR_IFINDEX] = { .type = NLA_U32 },
@@ -73,6 +77,7 @@ static struct nla_policy nl80211_policy[NL80211_ATTR_MAX+1] __read_mostly = {
         [NL80211_ATTR_KEY_IDX] = { .type = NLA_U8 },
         [NL80211_ATTR_KEY_CIPHER] = { .type = NLA_U32 },
         [NL80211_ATTR_KEY_DEFAULT] = { .type = NLA_FLAG },
+        [NL80211_ATTR_KEY_SEQ] = { .type = NLA_BINARY, .len = 8 },
 
         [NL80211_ATTR_BEACON_INTERVAL] = { .type = NLA_U32 },
         [NL80211_ATTR_DTIM_PERIOD] = { .type = NLA_U32 },
@@ -116,8 +121,45 @@ static struct nla_policy nl80211_policy[NL80211_ATTR_MAX+1] __read_mostly = {
                                 .len = IEEE80211_MAX_SSID_LEN },
         [NL80211_ATTR_AUTH_TYPE] = { .type = NLA_U32 },
         [NL80211_ATTR_REASON_CODE] = { .type = NLA_U16 },
+        [NL80211_ATTR_FREQ_FIXED] = { .type = NLA_FLAG },
+        [NL80211_ATTR_TIMED_OUT] = { .type = NLA_FLAG },
+        [NL80211_ATTR_USE_MFP] = { .type = NLA_U32 },
+        [NL80211_ATTR_STA_FLAGS2] = {
+                .len = sizeof(struct nl80211_sta_flag_update),
+        },
+        [NL80211_ATTR_CONTROL_PORT] = { .type = NLA_FLAG },
 };
 
+/* IE validation */
+static bool is_valid_ie_attr(const struct nlattr *attr)
+{
+        const u8 *pos;
+        int len;
+
+        if (!attr)
+                return true;
+
+        pos = nla_data(attr);
+        len = nla_len(attr);
+
+        while (len) {
+                u8 elemlen;
+
+                if (len < 2)
+                        return false;
+                len -= 2;
+
+                elemlen = pos[1];
+                if (elemlen > len)
+                        return false;
+
+                len -= elemlen;
+                pos += 2 + elemlen;
+        }
+
+        return true;
+}
+
 /* message building helper */
 static inline void *nl80211hdr_put(struct sk_buff *skb, u32 pid, u32 seq,
                                    int flags, u8 cmd)
@@ -126,6 +168,30 @@ static inline void *nl80211hdr_put(struct sk_buff *skb, u32 pid, u32 seq,
         return genlmsg_put(skb, pid, seq, &nl80211_fam, flags, cmd);
 }
 
+static int nl80211_msg_put_channel(struct sk_buff *msg,
+                                   struct ieee80211_channel *chan)
+{
+        NLA_PUT_U32(msg, NL80211_FREQUENCY_ATTR_FREQ,
+                    chan->center_freq);
+
+        if (chan->flags & IEEE80211_CHAN_DISABLED)
+                NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_DISABLED);
+        if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN)
+                NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_PASSIVE_SCAN);
+        if (chan->flags & IEEE80211_CHAN_NO_IBSS)
+                NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_NO_IBSS);
+        if (chan->flags & IEEE80211_CHAN_RADAR)
+                NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_RADAR);
+
+        NLA_PUT_U32(msg, NL80211_FREQUENCY_ATTR_MAX_TX_POWER,
+                    DBM_TO_MBM(chan->max_power));
+
+        return 0;
+
+ nla_put_failure:
+        return -ENOBUFS;
+}
+
 /* netlink command implementations */
 
 static int nl80211_send_wiphy(struct sk_buff *msg, u32 pid, u32 seq, int flags,
@@ -149,8 +215,24 @@ static int nl80211_send_wiphy(struct sk_buff *msg, u32 pid, u32 seq, int flags,
 
         NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, dev->wiphy_idx);
         NLA_PUT_STRING(msg, NL80211_ATTR_WIPHY_NAME, wiphy_name(&dev->wiphy));
+
+        NLA_PUT_U8(msg, NL80211_ATTR_WIPHY_RETRY_SHORT,
+                   dev->wiphy.retry_short);
+        NLA_PUT_U8(msg, NL80211_ATTR_WIPHY_RETRY_LONG,
+                   dev->wiphy.retry_long);
+        NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_FRAG_THRESHOLD,
+                    dev->wiphy.frag_threshold);
+        NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_RTS_THRESHOLD,
+                    dev->wiphy.rts_threshold);
+
         NLA_PUT_U8(msg, NL80211_ATTR_MAX_NUM_SCAN_SSIDS,
                    dev->wiphy.max_scan_ssids);
+        NLA_PUT_U16(msg, NL80211_ATTR_MAX_SCAN_IE_LEN,
+                    dev->wiphy.max_scan_ie_len);
+
+        NLA_PUT(msg, NL80211_ATTR_CIPHER_SUITES,
+                sizeof(u32) * dev->wiphy.n_cipher_suites,
+                dev->wiphy.cipher_suites);
 
         nl_modes = nla_nest_start(msg, NL80211_ATTR_SUPPORTED_IFTYPES);
         if (!nl_modes)
@@ -202,20 +284,9 @@ static int nl80211_send_wiphy(struct sk_buff *msg, u32 pid, u32 seq, int flags,
                                 goto nla_put_failure;
 
                         chan = &dev->wiphy.bands[band]->channels[i];
-                        NLA_PUT_U32(msg, NL80211_FREQUENCY_ATTR_FREQ,
-                                    chan->center_freq);
-
-                        if (chan->flags & IEEE80211_CHAN_DISABLED)
-                                NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_DISABLED);
-                        if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN)
-                                NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_PASSIVE_SCAN);
-                        if (chan->flags & IEEE80211_CHAN_NO_IBSS)
-                                NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_NO_IBSS);
-                        if (chan->flags & IEEE80211_CHAN_RADAR)
-                                NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_RADAR);
 
-                        NLA_PUT_U32(msg, NL80211_FREQUENCY_ATTR_MAX_TX_POWER,
-                                    DBM_TO_MBM(chan->max_power));
+                        if (nl80211_msg_put_channel(msg, chan))
+                                goto nla_put_failure;
 
                         nla_nest_end(msg, nl_freq);
                 }
@@ -273,6 +344,7 @@ static int nl80211_send_wiphy(struct sk_buff *msg, u32 pid, u32 seq, int flags,
         CMD(assoc, ASSOCIATE);
         CMD(deauth, DEAUTHENTICATE);
         CMD(disassoc, DISASSOCIATE);
+        CMD(join_ibss, JOIN_IBSS);
 
 #undef CMD
         nla_nest_end(msg, nl_cmds);
@@ -317,7 +389,7 @@ static int nl80211_get_wiphy(struct sk_buff *skb, struct genl_info *info)
         if (IS_ERR(dev))
                 return PTR_ERR(dev);
 
-        msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
+        msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
         if (!msg)
                 goto out_err;
 
@@ -365,6 +437,9 @@ static int nl80211_set_wiphy(struct sk_buff *skb, struct genl_info *info)
         struct cfg80211_registered_device *rdev;
         int result = 0, rem_txq_params = 0;
         struct nlattr *nl_txq_params;
+        u32 changed;
+        u8 retry_short = 0, retry_long = 0;
+        u32 frag_threshold = 0, rts_threshold = 0;
 
         rtnl_lock();
 
@@ -418,7 +493,7 @@ static int nl80211_set_wiphy(struct sk_buff *skb, struct genl_info *info)
                 enum nl80211_channel_type channel_type = NL80211_CHAN_NO_HT;
                 struct ieee80211_channel *chan;
                 struct ieee80211_sta_ht_cap *ht_cap;
-                u32 freq, sec_freq;
+                u32 freq;
 
                 if (!rdev->ops->set_channel) {
                         result = -EOPNOTSUPP;
@@ -444,33 +519,28 @@ static int nl80211_set_wiphy(struct sk_buff *skb, struct genl_info *info)
                 if (!chan || chan->flags & IEEE80211_CHAN_DISABLED)
                         goto bad_res;
 
-                if (channel_type == NL80211_CHAN_HT40MINUS)
-                        sec_freq = freq - 20;
-                else if (channel_type == NL80211_CHAN_HT40PLUS)
-                        sec_freq = freq + 20;
-                else
-                        sec_freq = 0;
-
-                ht_cap = &rdev->wiphy.bands[chan->band]->ht_cap;
-
-                /* no HT capabilities */
-                if (channel_type != NL80211_CHAN_NO_HT &&
-                    !ht_cap->ht_supported)
+                if (channel_type == NL80211_CHAN_HT40MINUS &&
+                    (chan->flags & IEEE80211_CHAN_NO_HT40MINUS))
+                        goto bad_res;
+                else if (channel_type == NL80211_CHAN_HT40PLUS &&
+                         (chan->flags & IEEE80211_CHAN_NO_HT40PLUS))
                         goto bad_res;
 
-                if (sec_freq) {
-                        struct ieee80211_channel *schan;
+                /*
+                 * At this point we know if that if HT40 was requested
+                 * we are allowed to use it and the extension channel
+                 * exists.
+                 */
 
-                        /* no 40 MHz capabilities */
+                ht_cap = &rdev->wiphy.bands[chan->band]->ht_cap;
+
+                /* no HT capabilities or intolerant */
+                if (channel_type != NL80211_CHAN_NO_HT) {
+                        if (!ht_cap->ht_supported)
+                                goto bad_res;
                         if (!(ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) ||
                             (ht_cap->cap & IEEE80211_HT_CAP_40MHZ_INTOLERANT))
                                 goto bad_res;
-
-                        schan = ieee80211_get_channel(&rdev->wiphy, sec_freq);
-
-                        /* Secondary channel not allowed */
-                        if (!schan || schan->flags & IEEE80211_CHAN_DISABLED)
-                                goto bad_res;
                 }
 
                 result = rdev->ops->set_channel(&rdev->wiphy, chan,
@@ -479,6 +549,84 @@ static int nl80211_set_wiphy(struct sk_buff *skb, struct genl_info *info)
                         goto bad_res;
         }
 
+        changed = 0;
+
+        if (info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]) {
+                retry_short = nla_get_u8(
+                        info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]);
+                if (retry_short == 0) {
+                        result = -EINVAL;
+                        goto bad_res;
+                }
+                changed |= WIPHY_PARAM_RETRY_SHORT;
+        }
+
+        if (info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]) {
+                retry_long = nla_get_u8(
+                        info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]);
+                if (retry_long == 0) {
+                        result = -EINVAL;
+                        goto bad_res;
+                }
+                changed |= WIPHY_PARAM_RETRY_LONG;
+        }
+
+        if (info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]) {
+                frag_threshold = nla_get_u32(
+                        info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]);
+                if (frag_threshold < 256) {
+                        result = -EINVAL;
+                        goto bad_res;
+                }
+                if (frag_threshold != (u32) -1) {
+                        /*
+                         * Fragments (apart from the last one) are required to
+                         * have even length. Make the fragmentation code
+                         * simpler by stripping LSB should someone try to use
+                         * odd threshold value.
+                         */
+                        frag_threshold &= ~0x1;
+                }
+                changed |= WIPHY_PARAM_FRAG_THRESHOLD;
+        }
+
+        if (info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]) {
+                rts_threshold = nla_get_u32(
+                        info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]);
+                changed |= WIPHY_PARAM_RTS_THRESHOLD;
+        }
+
+        if (changed) {
+                u8 old_retry_short, old_retry_long;
+                u32 old_frag_threshold, old_rts_threshold;
+
+                if (!rdev->ops->set_wiphy_params) {
+                        result = -EOPNOTSUPP;
+                        goto bad_res;
+                }
+
+                old_retry_short = rdev->wiphy.retry_short;
+                old_retry_long = rdev->wiphy.retry_long;
+                old_frag_threshold = rdev->wiphy.frag_threshold;
+                old_rts_threshold = rdev->wiphy.rts_threshold;
+
+                if (changed & WIPHY_PARAM_RETRY_SHORT)
+                        rdev->wiphy.retry_short = retry_short;
+                if (changed & WIPHY_PARAM_RETRY_LONG)
+                        rdev->wiphy.retry_long = retry_long;
+                if (changed & WIPHY_PARAM_FRAG_THRESHOLD)
+                        rdev->wiphy.frag_threshold = frag_threshold;
+                if (changed & WIPHY_PARAM_RTS_THRESHOLD)
+                        rdev->wiphy.rts_threshold = rts_threshold;
+
+                result = rdev->ops->set_wiphy_params(&rdev->wiphy, changed);
+                if (result) {
+                        rdev->wiphy.retry_short = old_retry_short;
+                        rdev->wiphy.retry_long = old_retry_long;
+                        rdev->wiphy.frag_threshold = old_frag_threshold;
+                        rdev->wiphy.rts_threshold = old_rts_threshold;
+                }
+        }
 
  bad_res:
         mutex_unlock(&rdev->mtx);
@@ -489,6 +637,7 @@ static int nl80211_set_wiphy(struct sk_buff *skb, struct genl_info *info)
 
 
 static int nl80211_send_iface(struct sk_buff *msg, u32 pid, u32 seq, int flags,
+                              struct cfg80211_registered_device *rdev,
                               struct net_device *dev)
 {
         void *hdr;
@@ -498,6 +647,7 @@ static int nl80211_send_iface(struct sk_buff *msg, u32 pid, u32 seq, int flags,
                 return -1;
 
         NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
+        NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
         NLA_PUT_STRING(msg, NL80211_ATTR_IFNAME, dev->name);
         NLA_PUT_U32(msg, NL80211_ATTR_IFTYPE, dev->ieee80211_ptr->iftype);
         return genlmsg_end(msg, hdr);
@@ -532,7 +682,7 @@ static int nl80211_dump_interface(struct sk_buff *skb, struct netlink_callback *
                         }
                         if (nl80211_send_iface(skb, NETLINK_CB(cb->skb).pid,
                                                cb->nlh->nlmsg_seq, NLM_F_MULTI,
-                                               wdev->netdev) < 0) {
+                                               dev, wdev->netdev) < 0) {
                                 mutex_unlock(&dev->devlist_mtx);
                                 goto out;
                         }
@@ -562,11 +712,12 @@ static int nl80211_get_interface(struct sk_buff *skb, struct genl_info *info)
         if (err)
                 return err;
 
-        msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
+        msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
         if (!msg)
                 goto out_err;
 
-        if (nl80211_send_iface(msg, info->snd_pid, info->snd_seq, 0, netdev) < 0)
+        if (nl80211_send_iface(msg, info->snd_pid, info->snd_seq, 0,
+                               dev, netdev) < 0)
                 goto out_free;
 
         dev_put(netdev);
@@ -616,7 +767,7 @@ static int nl80211_set_interface(struct sk_buff *skb, struct genl_info *info)
         struct cfg80211_registered_device *drv;
         struct vif_params params;
         int err, ifindex;
-        enum nl80211_iftype type;
+        enum nl80211_iftype otype, ntype;
         struct net_device *dev;
         u32 _flags, *flags = NULL;
         bool change = false;
@@ -630,30 +781,27 @@ static int nl80211_set_interface(struct sk_buff *skb, struct genl_info *info)
                 goto unlock_rtnl;
 
         ifindex = dev->ifindex;
-        type = dev->ieee80211_ptr->iftype;
+        otype = ntype = dev->ieee80211_ptr->iftype;
         dev_put(dev);
 
         if (info->attrs[NL80211_ATTR_IFTYPE]) {
-                enum nl80211_iftype ntype;
-
                 ntype = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
-                if (type != ntype)
+                if (otype != ntype)
                         change = true;
-                type = ntype;
-                if (type > NL80211_IFTYPE_MAX) {
+                if (ntype > NL80211_IFTYPE_MAX) {
                         err = -EINVAL;
                         goto unlock;
                 }
         }
 
         if (!drv->ops->change_virtual_intf ||
-            !(drv->wiphy.interface_modes & (1 << type))) {
+            !(drv->wiphy.interface_modes & (1 << ntype))) {
                 err = -EOPNOTSUPP;
                 goto unlock;
         }
 
         if (info->attrs[NL80211_ATTR_MESH_ID]) {
-                if (type != NL80211_IFTYPE_MESH_POINT) {
+                if (ntype != NL80211_IFTYPE_MESH_POINT) {
                         err = -EINVAL;
                         goto unlock;
                 }
@@ -663,7 +811,7 @@ static int nl80211_set_interface(struct sk_buff *skb, struct genl_info *info)
         }
 
         if (info->attrs[NL80211_ATTR_MNTR_FLAGS]) {
-                if (type != NL80211_IFTYPE_MONITOR) {
+                if (ntype != NL80211_IFTYPE_MONITOR) {
                         err = -EINVAL;
                         goto unlock;
                 }
@@ -678,12 +826,17 @@ static int nl80211_set_interface(struct sk_buff *skb, struct genl_info *info)
 
         if (change)
                 err = drv->ops->change_virtual_intf(&drv->wiphy, ifindex,
-                                                    type, flags, &params);
+                                                    ntype, flags, &params);
         else
                 err = 0;
 
         dev = __dev_get_by_index(&init_net, ifindex);
-        WARN_ON(!dev || (!err && dev->ieee80211_ptr->iftype != type));
+        WARN_ON(!dev || (!err && dev->ieee80211_ptr->iftype != ntype));
+
+        if (dev && !err && (ntype != otype)) {
+                if (otype == NL80211_IFTYPE_ADHOC)
+                        cfg80211_clear_ibss(dev, false);
+        }
 
  unlock:
         cfg80211_put_dev(drv);
@@ -832,7 +985,7 @@ static int nl80211_get_key(struct sk_buff *skb, struct genl_info *info)
                 goto out;
         }
 
-        msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
+        msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
         if (!msg) {
                 err = -ENOMEM;
                 goto out;
@@ -920,6 +1073,14 @@ static int nl80211_set_key(struct sk_buff *skb, struct genl_info *info)
         }
 
         err = func(&drv->wiphy, dev, key_idx);
+#ifdef CONFIG_WIRELESS_EXT
+        if (!err) {
+                if (func == drv->ops->set_default_key)
+                        dev->ieee80211_ptr->wext.default_key = key_idx;
+                else
+                        dev->ieee80211_ptr->wext.default_mgmt_key = key_idx;
+        }
+#endif
 
  out:
         cfg80211_put_dev(drv);
@@ -934,7 +1095,7 @@ static int nl80211_set_key(struct sk_buff *skb, struct genl_info *info)
 static int nl80211_new_key(struct sk_buff *skb, struct genl_info *info)
 {
         struct cfg80211_registered_device *drv;
-        int err;
+        int err, i;
         struct net_device *dev;
         struct key_params params;
         u8 key_idx = 0;
@@ -950,6 +1111,11 @@ static int nl80211_new_key(struct sk_buff *skb, struct genl_info *info)
                 params.key_len = nla_len(info->attrs[NL80211_ATTR_KEY_DATA]);
         }
 
+        if (info->attrs[NL80211_ATTR_KEY_SEQ]) {
+                params.seq = nla_data(info->attrs[NL80211_ATTR_KEY_SEQ]);
+                params.seq_len = nla_len(info->attrs[NL80211_ATTR_KEY_SEQ]);
+        }
+
         if (info->attrs[NL80211_ATTR_KEY_IDX])
                 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
 
@@ -958,44 +1124,8 @@ static int nl80211_new_key(struct sk_buff *skb, struct genl_info *info)
         if (info->attrs[NL80211_ATTR_MAC])
                 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
 
-        if (key_idx > 5)
-                return -EINVAL;
-
-        /*
-         * Disallow pairwise keys with non-zero index unless it's WEP
-         * (because current deployments use pairwise WEP keys with
-         * non-zero indizes but 802.11i clearly specifies to use zero)
-         */
-        if (mac_addr && key_idx &&
-            params.cipher != WLAN_CIPHER_SUITE_WEP40 &&
-            params.cipher != WLAN_CIPHER_SUITE_WEP104)
-                return -EINVAL;
-
-        /* TODO: add definitions for the lengths to linux/ieee80211.h */
-        switch (params.cipher) {
-        case WLAN_CIPHER_SUITE_WEP40:
-                if (params.key_len != 5)
-                        return -EINVAL;
-                break;
-        case WLAN_CIPHER_SUITE_TKIP:
-                if (params.key_len != 32)
-                        return -EINVAL;
-                break;
-        case WLAN_CIPHER_SUITE_CCMP:
-                if (params.key_len != 16)
-                        return -EINVAL;
-                break;
-        case WLAN_CIPHER_SUITE_WEP104:
-                if (params.key_len != 13)
-                        return -EINVAL;
-                break;
-        case WLAN_CIPHER_SUITE_AES_CMAC:
-                if (params.key_len != 16)
-                        return -EINVAL;
-                break;
-        default:
+        if (cfg80211_validate_key_settings(&params, key_idx, mac_addr))
                 return -EINVAL;
-        }
 
         rtnl_lock();
 
@@ -1003,6 +1133,14 @@ static int nl80211_new_key(struct sk_buff *skb, struct genl_info *info)
         if (err)
                 goto unlock_rtnl;
 
+        for (i = 0; i < drv->wiphy.n_cipher_suites; i++)
+                if (params.cipher == drv->wiphy.cipher_suites[i])
+                        break;
+        if (i == drv->wiphy.n_cipher_suites) {
+                err = -EINVAL;
+                goto out;
+        }
+
         if (!drv->ops->add_key) {
                 err = -EOPNOTSUPP;
                 goto out;
@@ -1049,6 +1187,15 @@ static int nl80211_del_key(struct sk_buff *skb, struct genl_info *info)
 
         err = drv->ops->del_key(&drv->wiphy, dev, key_idx, mac_addr);
 
+#ifdef CONFIG_WIRELESS_EXT
+        if (!err) {
+                if (key_idx == dev->ieee80211_ptr->wext.default_key)
+                        dev->ieee80211_ptr->wext.default_key = -1;
+                else if (key_idx == dev->ieee80211_ptr->wext.default_mgmt_key)
+                        dev->ieee80211_ptr->wext.default_mgmt_key = -1;
+        }
+#endif
+
  out:
         cfg80211_put_dev(drv);
         dev_put(dev);
@@ -1069,6 +1216,9 @@ static int nl80211_addset_beacon(struct sk_buff *skb, struct genl_info *info)
         struct beacon_parameters params;
         int haveinfo = 0;
 
+        if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_BEACON_TAIL]))
+                return -EINVAL;
+
         rtnl_lock();
 
         err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
@@ -1186,15 +1336,36 @@ static const struct nla_policy sta_flags_policy[NL80211_STA_FLAG_MAX + 1] = {
         [NL80211_STA_FLAG_AUTHORIZED] = { .type = NLA_FLAG },
         [NL80211_STA_FLAG_SHORT_PREAMBLE] = { .type = NLA_FLAG },
         [NL80211_STA_FLAG_WME] = { .type = NLA_FLAG },
+        [NL80211_STA_FLAG_MFP] = { .type = NLA_FLAG },
 };
 
-static int parse_station_flags(struct nlattr *nla, u32 *staflags)
+static int parse_station_flags(struct genl_info *info,
+                               struct station_parameters *params)
 {
         struct nlattr *flags[NL80211_STA_FLAG_MAX + 1];
+        struct nlattr *nla;
         int flag;
 
-        *staflags = 0;
+        /*
+         * Try parsing the new attribute first so userspace
+         * can specify both for older kernels.
+         */
+        nla = info->attrs[NL80211_ATTR_STA_FLAGS2];
+        if (nla) {
+                struct nl80211_sta_flag_update *sta_flags;
+
+                sta_flags = nla_data(nla);
+                params->sta_flags_mask = sta_flags->mask;
+                params->sta_flags_set = sta_flags->set;
+                if ((params->sta_flags_mask |
+                     params->sta_flags_set) & BIT(__NL80211_STA_FLAG_INVALID))
+                        return -EINVAL;
+                return 0;
+        }
+
+        /* if present, parse the old attribute */
 
+        nla = info->attrs[NL80211_ATTR_STA_FLAGS];
         if (!nla)
                 return 0;
 
@@ -1202,11 +1373,12 @@ static int parse_station_flags(struct nlattr *nla, u32 *staflags)
                              nla, sta_flags_policy))
                 return -EINVAL;
 
-        *staflags = STATION_FLAG_CHANGED;
+        params->sta_flags_mask = (1 << __NL80211_STA_FLAG_AFTER_LAST) - 1;
+        params->sta_flags_mask &= ~1;
 
         for (flag = 1; flag <= NL80211_STA_FLAG_MAX; flag++)
                 if (flags[flag])
-                        *staflags |= (1<<flag);
+                        params->sta_flags_set |= (1<<flag);
 
         return 0;
 }
@@ -1424,7 +1596,7 @@ static int nl80211_get_station(struct sk_buff *skb, struct genl_info *info)
         if (err)
                 goto out;
 
-        msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
+        msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
         if (!msg)
                 goto out;
 
@@ -1502,8 +1674,7 @@ static int nl80211_set_station(struct sk_buff *skb, struct genl_info *info)
                 params.ht_capa =
                         nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
 
-        if (parse_station_flags(info->attrs[NL80211_ATTR_STA_FLAGS],
-                                &params.station_flags))
+        if (parse_station_flags(info, &params))
                 return -EINVAL;
 
         if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION])
@@ -1516,6 +1687,12 @@ static int nl80211_set_station(struct sk_buff *skb, struct genl_info *info)
         if (err)
                 goto out_rtnl;
 
+        if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
+            dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN) {
+                err = -EINVAL;
+                goto out;
+        }
+
         err = get_vlan(info->attrs[NL80211_ATTR_STA_VLAN], drv, &params.vlan);
         if (err)
                 goto out;
@@ -1567,13 +1744,16 @@ static int nl80211_new_station(struct sk_buff *skb, struct genl_info *info)
                 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
         params.listen_interval =
                 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
+
         params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
+        if (!params.aid || params.aid > IEEE80211_MAX_AID)
+                return -EINVAL;
+
         if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
                 params.ht_capa =
                         nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
 
-        if (parse_station_flags(info->attrs[NL80211_ATTR_STA_FLAGS],
-                                &params.station_flags))
+        if (parse_station_flags(info, &params))
                 return -EINVAL;
 
         rtnl_lock();
@@ -1582,6 +1762,12 @@ static int nl80211_new_station(struct sk_buff *skb, struct genl_info *info)
         if (err)
                 goto out_rtnl;
 
+        if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
+            dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN) {
+                err = -EINVAL;
+                goto out;
+        }
+
         err = get_vlan(info->attrs[NL80211_ATTR_STA_VLAN], drv, &params.vlan);
         if (err)
                 goto out;
@@ -1625,6 +1811,12 @@ static int nl80211_del_station(struct sk_buff *skb, struct genl_info *info)
         if (err)
                 goto out_rtnl;
 
+        if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
+            dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN) {
+                err = -EINVAL;
+                goto out;
+        }
+
         if (!drv->ops->del_station) {
                 err = -EOPNOTSUPP;
                 goto out;
@@ -1808,7 +2000,7 @@ static int nl80211_get_mpath(struct sk_buff *skb, struct genl_info *info)
         if (err)
                 goto out;
 
-        msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
+        msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
         if (!msg)
                 goto out;
 
@@ -2124,7 +2316,7 @@ static int nl80211_get_mesh_params(struct sk_buff *skb,
                 goto out;
 
         /* Draw up a netlink message to send back */
-        msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
+        msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
         if (!msg) {
                 err = -ENOBUFS;
                 goto out;
@@ -2302,7 +2494,7 @@ static int nl80211_get_reg(struct sk_buff *skb, struct genl_info *info)
         if (!cfg80211_regdomain)
                 goto out;
 
-        msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
+        msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
         if (!msg) {
                 err = -ENOBUFS;
                 goto out;
@@ -2385,18 +2577,24 @@ static int nl80211_set_reg(struct sk_buff *skb, struct genl_info *info)
                         rem_reg_rules) {
                 num_rules++;
                 if (num_rules > NL80211_MAX_SUPP_REG_RULES)
-                        goto bad_reg;
+                        return -EINVAL;
         }
 
-        if (!reg_is_valid_request(alpha2))
-                return -EINVAL;
+        mutex_lock(&cfg80211_mutex);
+
+        if (!reg_is_valid_request(alpha2)) {
+                r = -EINVAL;
+                goto bad_reg;
+        }
 
         size_of_regd = sizeof(struct ieee80211_regdomain) +
                 (num_rules * sizeof(struct ieee80211_reg_rule));
 
         rd = kzalloc(size_of_regd, GFP_KERNEL);
-        if (!rd)
-                return -ENOMEM;
+        if (!rd) {
+                r = -ENOMEM;
+                goto bad_reg;
+        }
 
         rd->n_reg_rules = num_rules;
         rd->alpha2[0] = alpha2[0];
@@ -2413,20 +2611,24 @@ static int nl80211_set_reg(struct sk_buff *skb, struct genl_info *info)
 
                 rule_idx++;
 
-                if (rule_idx > NL80211_MAX_SUPP_REG_RULES)
+                if (rule_idx > NL80211_MAX_SUPP_REG_RULES) {
+                        r = -EINVAL;
                         goto bad_reg;
+                }
         }
 
         BUG_ON(rule_idx != num_rules);
 
-        mutex_lock(&cfg80211_mutex);
         r = set_regdom(rd);
+
         mutex_unlock(&cfg80211_mutex);
+
         return r;
 
  bad_reg:
+        mutex_unlock(&cfg80211_mutex);
         kfree(rd);
-        return -EINVAL;
+        return r;
 }
 
 static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
@@ -2442,6 +2644,9 @@ static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
         enum ieee80211_band band;
         size_t ie_len;
 
+        if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
+                return -EINVAL;
+
         rtnl_lock();
 
         err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
@@ -2492,6 +2697,11 @@ static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
         else
                 ie_len = 0;
 
+        if (ie_len > wiphy->max_scan_ie_len) {
+                err = -EINVAL;
+                goto out;
+        }
+
         request = kzalloc(sizeof(*request)
                         + sizeof(*ssid) * n_ssids
                         + sizeof(channel) * n_channels
@@ -2554,7 +2764,8 @@ static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
 
         if (info->attrs[NL80211_ATTR_IE]) {
                 request->ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
-                memcpy(request->ie, nla_data(info->attrs[NL80211_ATTR_IE]),
+                memcpy((void *)request->ie,
+                       nla_data(info->attrs[NL80211_ATTR_IE]),
                        request->ie_len);
         }
 
@@ -2710,6 +2921,15 @@ static int nl80211_authenticate(struct sk_buff *skb, struct genl_info *info)
         struct wiphy *wiphy;
         int err;
 
+        if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
+                return -EINVAL;
+
+        if (!info->attrs[NL80211_ATTR_MAC])
+                return -EINVAL;
+
+        if (!info->attrs[NL80211_ATTR_AUTH_TYPE])
+                return -EINVAL;
+
         rtnl_lock();
 
         err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
@@ -2731,11 +2951,6 @@ static int nl80211_authenticate(struct sk_buff *skb, struct genl_info *info)
                 goto out;
         }
 
-        if (!info->attrs[NL80211_ATTR_MAC]) {
-                err = -EINVAL;
-                goto out;
-        }
-
         wiphy = &drv->wiphy;
         memset(&req, 0, sizeof(req));
 
@@ -2761,13 +2976,10 @@ static int nl80211_authenticate(struct sk_buff *skb, struct genl_info *info)
                 req.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
         }
 
-        if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
-                req.auth_type =
-                        nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
-                if (!nl80211_valid_auth_type(req.auth_type)) {
-                        err = -EINVAL;
-                        goto out;
-                }
+        req.auth_type = nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
+        if (!nl80211_valid_auth_type(req.auth_type)) {
+                err = -EINVAL;
+                goto out;
         }
 
         err = drv->ops->auth(&drv->wiphy, dev, &req);
@@ -2788,6 +3000,13 @@ static int nl80211_associate(struct sk_buff *skb, struct genl_info *info)
         struct wiphy *wiphy;
         int err;
 
+        if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
+                return -EINVAL;
+
+        if (!info->attrs[NL80211_ATTR_MAC] ||
+            !info->attrs[NL80211_ATTR_SSID])
+                return -EINVAL;
+
         rtnl_lock();
 
         err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
@@ -2809,12 +3028,6 @@ static int nl80211_associate(struct sk_buff *skb, struct genl_info *info)
                 goto out;
         }
 
-        if (!info->attrs[NL80211_ATTR_MAC] ||
-            !info->attrs[NL80211_ATTR_SSID]) {
-                err = -EINVAL;
-                goto out;
-        }
-
         wiphy = &drv->wiphy;
         memset(&req, 0, sizeof(req));
 
@@ -2838,6 +3051,19 @@ static int nl80211_associate(struct sk_buff *skb, struct genl_info *info)
                 req.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
         }
 
+        if (info->attrs[NL80211_ATTR_USE_MFP]) {
+                enum nl80211_mfp use_mfp =
+                        nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
+                if (use_mfp == NL80211_MFP_REQUIRED)
+                        req.use_mfp = true;
+                else if (use_mfp != NL80211_MFP_NO) {
+                        err = -EINVAL;
+                        goto out;
+                }
+        }
+
+        req.control_port = info->attrs[NL80211_ATTR_CONTROL_PORT];
+
         err = drv->ops->assoc(&drv->wiphy, dev, &req);
 
 out:
@@ -2856,6 +3082,15 @@ static int nl80211_deauthenticate(struct sk_buff *skb, struct genl_info *info)
         struct wiphy *wiphy;
         int err;
 
+        if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
+                return -EINVAL;
+
+        if (!info->attrs[NL80211_ATTR_MAC])
+                return -EINVAL;
+
+        if (!info->attrs[NL80211_ATTR_REASON_CODE])
+                return -EINVAL;
+
         rtnl_lock();
 
         err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
@@ -2877,24 +3112,16 @@ static int nl80211_deauthenticate(struct sk_buff *skb, struct genl_info *info)
                 goto out;
         }
 
-        if (!info->attrs[NL80211_ATTR_MAC]) {
-                err = -EINVAL;
-                goto out;
-        }
-
         wiphy = &drv->wiphy;
         memset(&req, 0, sizeof(req));
 
         req.peer_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
 
-        if (info->attrs[NL80211_ATTR_REASON_CODE]) {
-                req.reason_code =
-                        nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
-                if (req.reason_code == 0) {
-                        /* Reason Code 0 is reserved */
-                        err = -EINVAL;
-                        goto out;
-                }
+        req.reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
+        if (req.reason_code == 0) {
+                /* Reason Code 0 is reserved */
+                err = -EINVAL;
+                goto out;
         }
 
         if (info->attrs[NL80211_ATTR_IE]) {
@@ -2920,6 +3147,15 @@ static int nl80211_disassociate(struct sk_buff *skb, struct genl_info *info)
         struct wiphy *wiphy;
         int err;
 
+        if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
+                return -EINVAL;
+
+        if (!info->attrs[NL80211_ATTR_MAC])
+                return -EINVAL;
+
+        if (!info->attrs[NL80211_ATTR_REASON_CODE])
+                return -EINVAL;
+
         rtnl_lock();
 
         err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
@@ -2941,24 +3177,16 @@ static int nl80211_disassociate(struct sk_buff *skb, struct genl_info *info)
                 goto out;
         }
 
-        if (!info->attrs[NL80211_ATTR_MAC]) {
-                err = -EINVAL;
-                goto out;
-        }
-
         wiphy = &drv->wiphy;
         memset(&req, 0, sizeof(req));
 
         req.peer_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
 
-        if (info->attrs[NL80211_ATTR_REASON_CODE]) {
-                req.reason_code =
-                        nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
-                if (req.reason_code == 0) {
-                        /* Reason Code 0 is reserved */
-                        err = -EINVAL;
-                        goto out;
-                }
+        req.reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
+        if (req.reason_code == 0) {
+                /* Reason Code 0 is reserved */
+                err = -EINVAL;
+                goto out;
         }
 
         if (info->attrs[NL80211_ATTR_IE]) {
@@ -2976,6 +3204,124 @@ unlock_rtnl:
         return err;
 }
 
+static int nl80211_join_ibss(struct sk_buff *skb, struct genl_info *info)
+{
+        struct cfg80211_registered_device *drv;
+        struct net_device *dev;
+        struct cfg80211_ibss_params ibss;
+        struct wiphy *wiphy;
+        int err;
+
+        memset(&ibss, 0, sizeof(ibss));
+
+        if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
+                return -EINVAL;
+
+        if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
+            !info->attrs[NL80211_ATTR_SSID] ||
+            !nla_len(info->attrs[NL80211_ATTR_SSID]))
+                return -EINVAL;
+
+        ibss.beacon_interval = 100;
+
+        if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
+                ibss.beacon_interval =
+                        nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
+                if (ibss.beacon_interval < 1 || ibss.beacon_interval > 10000)
+                        return -EINVAL;
+        }
+
+        rtnl_lock();
+
+        err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
+        if (err)
+                goto unlock_rtnl;
+
+        if (!drv->ops->join_ibss) {
+                err = -EOPNOTSUPP;
+                goto out;
+        }
+
+        if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC) {
+                err = -EOPNOTSUPP;
+                goto out;
+        }
+
+        if (!netif_running(dev)) {
+                err = -ENETDOWN;
+                goto out;
+        }
+
+        wiphy = &drv->wiphy;
+
+        if (info->attrs[NL80211_ATTR_MAC])
+                ibss.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
+        ibss.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
+        ibss.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
+
+        if (info->attrs[NL80211_ATTR_IE]) {
+                ibss.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
+                ibss.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
+        }
+
+        ibss.channel = ieee80211_get_channel(wiphy,
+                nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
+        if (!ibss.channel ||
+            ibss.channel->flags & IEEE80211_CHAN_NO_IBSS ||
+            ibss.channel->flags & IEEE80211_CHAN_DISABLED) {
+                err = -EINVAL;
+                goto out;
+        }
+
+        ibss.channel_fixed = !!info->attrs[NL80211_ATTR_FREQ_FIXED];
+
+        err = cfg80211_join_ibss(drv, dev, &ibss);
+
+out:
+        cfg80211_put_dev(drv);
+        dev_put(dev);
+unlock_rtnl:
+        rtnl_unlock();
+        return err;
+}
+
+static int nl80211_leave_ibss(struct sk_buff *skb, struct genl_info *info)
+{
+        struct cfg80211_registered_device *drv;
+        struct net_device *dev;
+        int err;
+
+        rtnl_lock();
+
+        err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
+        if (err)
+                goto unlock_rtnl;
+
+        if (!drv->ops->leave_ibss) {
+                err = -EOPNOTSUPP;
+                goto out;
+        }
+
+        if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC) {
+                err = -EOPNOTSUPP;
+                goto out;
+        }
+
+        if (!netif_running(dev)) {
+                err = -ENETDOWN;
+                goto out;
+        }
+
+        err = cfg80211_leave_ibss(drv, dev, false);
+
+out:
+        cfg80211_put_dev(drv);
+        dev_put(dev);
+unlock_rtnl:
+        rtnl_unlock();
+        return err;
+}
+
 static struct genl_ops nl80211_ops[] = {
         {
                 .cmd = NL80211_CMD_GET_WIPHY,
@@ -3177,6 +3523,18 @@ static struct genl_ops nl80211_ops[] = {
                 .policy = nl80211_policy,
                 .flags = GENL_ADMIN_PERM,
         },
+        {
+                .cmd = NL80211_CMD_JOIN_IBSS,
+                .doit = nl80211_join_ibss,
+                .policy = nl80211_policy,
+                .flags = GENL_ADMIN_PERM,
+        },
+        {
+                .cmd = NL80211_CMD_LEAVE_IBSS,
+                .doit = nl80211_leave_ibss,
+                .policy = nl80211_policy,
+                .flags = GENL_ADMIN_PERM,
+        },
 };
 static struct genl_multicast_group nl80211_mlme_mcgrp = {
         .name = "mlme",
@@ -3199,7 +3557,7 @@ void nl80211_notify_dev_rename(struct cfg80211_registered_device *rdev)
 {
         struct sk_buff *msg;
 
-        msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
+        msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
         if (!msg)
                 return;
 
@@ -3211,11 +3569,43 @@ void nl80211_notify_dev_rename(struct cfg80211_registered_device *rdev)
         genlmsg_multicast(msg, 0, nl80211_config_mcgrp.id, GFP_KERNEL);
 }
 
+static int nl80211_add_scan_req(struct sk_buff *msg,
+                                struct cfg80211_registered_device *rdev)
+{
+        struct cfg80211_scan_request *req = rdev->scan_req;
+        struct nlattr *nest;
+        int i;
+
+        if (WARN_ON(!req))
+                return 0;
+
+        nest = nla_nest_start(msg, NL80211_ATTR_SCAN_SSIDS);
+        if (!nest)
+                goto nla_put_failure;
+        for (i = 0; i < req->n_ssids; i++)
+                NLA_PUT(msg, i, req->ssids[i].ssid_len, req->ssids[i].ssid);
+        nla_nest_end(msg, nest);
+
+        nest = nla_nest_start(msg, NL80211_ATTR_SCAN_FREQUENCIES);
+        if (!nest)
+                goto nla_put_failure;
+        for (i = 0; i < req->n_channels; i++)
+                NLA_PUT_U32(msg, i, req->channels[i]->center_freq);
+        nla_nest_end(msg, nest);
+
+        if (req->ie)
+                NLA_PUT(msg, NL80211_ATTR_IE, req->ie_len, req->ie);
+
+        return 0;
+ nla_put_failure:
+        return -ENOBUFS;
+}
+
 static int nl80211_send_scan_donemsg(struct sk_buff *msg,
-                                    struct cfg80211_registered_device *rdev,
-                                    struct net_device *netdev,
-                                    u32 pid, u32 seq, int flags,
-                                    u32 cmd)
+                                     struct cfg80211_registered_device *rdev,
+                                     struct net_device *netdev,
+                                     u32 pid, u32 seq, int flags,
+                                     u32 cmd)
 {
         void *hdr;
 
@@ -3226,7 +3616,8 @@ static int nl80211_send_scan_donemsg(struct sk_buff *msg,
         NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
         NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
 
-        /* XXX: we should probably bounce back the request? */
+        /* ignore errors and send incomplete event anyway */
+        nl80211_add_scan_req(msg, rdev);
 
         return genlmsg_end(msg, hdr);
 
@@ -3240,7 +3631,7 @@ void nl80211_send_scan_done(struct cfg80211_registered_device *rdev,
 {
         struct sk_buff *msg;
 
-        msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
+        msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
         if (!msg)
                 return;
 
@@ -3258,7 +3649,7 @@ void nl80211_send_scan_aborted(struct cfg80211_registered_device *rdev,
 {
         struct sk_buff *msg;
 
-        msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
+        msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
         if (!msg)
                 return;
 
@@ -3280,7 +3671,7 @@ void nl80211_send_reg_change_event(struct regulatory_request *request)
         struct sk_buff *msg;
         void *hdr;
 
-        msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
+        msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
         if (!msg)
                 return;
 
@@ -3334,7 +3725,7 @@ static void nl80211_send_mlme_event(struct cfg80211_registered_device *rdev,
         struct sk_buff *msg;
         void *hdr;
 
-        msg = nlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC);
+        msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
         if (!msg)
                 return;
 
@@ -3375,38 +3766,208 @@ void nl80211_send_rx_assoc(struct cfg80211_registered_device *rdev,
         nl80211_send_mlme_event(rdev, netdev, buf, len, NL80211_CMD_ASSOCIATE);
 }
 
-void nl80211_send_rx_deauth(struct cfg80211_registered_device *rdev,
-                            struct net_device *netdev, const u8 *buf,
-                            size_t len)
+void nl80211_send_deauth(struct cfg80211_registered_device *rdev,
+                         struct net_device *netdev, const u8 *buf, size_t len)
 {
         nl80211_send_mlme_event(rdev, netdev, buf, len,
                                 NL80211_CMD_DEAUTHENTICATE);
 }
 
-void nl80211_send_rx_disassoc(struct cfg80211_registered_device *rdev,
-                              struct net_device *netdev, const u8 *buf,
-                              size_t len)
+void nl80211_send_disassoc(struct cfg80211_registered_device *rdev,
+                           struct net_device *netdev, const u8 *buf,
+                           size_t len)
 {
         nl80211_send_mlme_event(rdev, netdev, buf, len,
                                 NL80211_CMD_DISASSOCIATE);
 }
 
+static void nl80211_send_mlme_timeout(struct cfg80211_registered_device *rdev,
+                                      struct net_device *netdev, int cmd,
+                                      const u8 *addr)
+{
+        struct sk_buff *msg;
+        void *hdr;
+
+        msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
+        if (!msg)
+                return;
+
+        hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
+        if (!hdr) {
+                nlmsg_free(msg);
+                return;
+        }
+
+        NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
+        NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
+        NLA_PUT_FLAG(msg, NL80211_ATTR_TIMED_OUT);
+        NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, addr);
+
+        if (genlmsg_end(msg, hdr) < 0) {
+                nlmsg_free(msg);
+                return;
+        }
+
+        genlmsg_multicast(msg, 0, nl80211_mlme_mcgrp.id, GFP_ATOMIC);
+        return;
+
+ nla_put_failure:
+        genlmsg_cancel(msg, hdr);
+        nlmsg_free(msg);
+}
+
+void nl80211_send_auth_timeout(struct cfg80211_registered_device *rdev,
+                               struct net_device *netdev, const u8 *addr)
+{
+        nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_AUTHENTICATE,
+                                  addr);
+}
+
+void nl80211_send_assoc_timeout(struct cfg80211_registered_device *rdev,
+                                struct net_device *netdev, const u8 *addr)
+{
+        nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_ASSOCIATE, addr);
+}
+
+void nl80211_send_ibss_bssid(struct cfg80211_registered_device *rdev,
+                             struct net_device *netdev, const u8 *bssid,
+                             gfp_t gfp)
+{
+        struct sk_buff *msg;
+        void *hdr;
+
+        msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
+        if (!msg)
+                return;
+
+        hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_JOIN_IBSS);
+        if (!hdr) {
+                nlmsg_free(msg);
+                return;
+        }
+
+        NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
+        NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
+        NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid);
+
+        if (genlmsg_end(msg, hdr) < 0) {
+                nlmsg_free(msg);
+                return;
+        }
+
+        genlmsg_multicast(msg, 0, nl80211_mlme_mcgrp.id, gfp);
+        return;
+
+ nla_put_failure:
+        genlmsg_cancel(msg, hdr);
+        nlmsg_free(msg);
+}
+
+void nl80211_michael_mic_failure(struct cfg80211_registered_device *rdev,
+                                 struct net_device *netdev, const u8 *addr,
+                                 enum nl80211_key_type key_type, int key_id,
+                                 const u8 *tsc)
+{
+        struct sk_buff *msg;
+        void *hdr;
+
+        msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
+        if (!msg)
+                return;
+
+        hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_MICHAEL_MIC_FAILURE);
+        if (!hdr) {
+                nlmsg_free(msg);
+                return;
+        }
+
+        NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
+        NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
+        if (addr)
+                NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, addr);
+        NLA_PUT_U32(msg, NL80211_ATTR_KEY_TYPE, key_type);
+        NLA_PUT_U8(msg, NL80211_ATTR_KEY_IDX, key_id);
+        if (tsc)
+                NLA_PUT(msg, NL80211_ATTR_KEY_SEQ, 6, tsc);
+
+        if (genlmsg_end(msg, hdr) < 0) {
+                nlmsg_free(msg);
+                return;
+        }
+
+        genlmsg_multicast(msg, 0, nl80211_mlme_mcgrp.id, GFP_ATOMIC);
+        return;
+
+ nla_put_failure:
+        genlmsg_cancel(msg, hdr);
+        nlmsg_free(msg);
+}
+
+void nl80211_send_beacon_hint_event(struct wiphy *wiphy,
+                                    struct ieee80211_channel *channel_before,
+                                    struct ieee80211_channel *channel_after)
+{
+        struct sk_buff *msg;
+        void *hdr;
+        struct nlattr *nl_freq;
+
+        msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
+        if (!msg)
+                return;
+
+        hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_BEACON_HINT);
+        if (!hdr) {
+                nlmsg_free(msg);
+                return;
+        }
+
+        /*
+         * Since we are applying the beacon hint to a wiphy we know its
+         * wiphy_idx is valid
+         */
+        NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy));
+
+        /* Before */
+        nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_BEFORE);
+        if (!nl_freq)
+                goto nla_put_failure;
+        if (nl80211_msg_put_channel(msg, channel_before))
+                goto nla_put_failure;
+        nla_nest_end(msg, nl_freq);
+
+        /* After */
+        nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_AFTER);
+        if (!nl_freq)
+                goto nla_put_failure;
+        if (nl80211_msg_put_channel(msg, channel_after))
+                goto nla_put_failure;
+        nla_nest_end(msg, nl_freq);
+
+        if (genlmsg_end(msg, hdr) < 0) {
+                nlmsg_free(msg);
+                return;
+        }
+
+        genlmsg_multicast(msg, 0, nl80211_regulatory_mcgrp.id, GFP_ATOMIC);
+
+        return;
+
+nla_put_failure:
+        genlmsg_cancel(msg, hdr);
+        nlmsg_free(msg);
+}
+
 /* initialisation/exit functions */
 
 int nl80211_init(void)
 {
-        int err, i;
+        int err;
 
-        err = genl_register_family(&nl80211_fam);
+        err = genl_register_family_with_ops(&nl80211_fam,
+                nl80211_ops, ARRAY_SIZE(nl80211_ops));
         if (err)
                 return err;
 
-        for (i = 0; i < ARRAY_SIZE(nl80211_ops); i++) {
-                err = genl_register_ops(&nl80211_fam, &nl80211_ops[i]);
-                if (err)
-                        goto err_out;
-        }
-
         err = genl_register_mc_group(&nl80211_fam, &nl80211_config_mcgrp);
         if (err)
                 goto err_out;
diff --git a/net/wireless/nl80211.h b/net/wireless/nl80211.h
index b77af4ab80be..5c12ad13499b 100644
--- a/net/wireless/nl80211.h
+++ b/net/wireless/nl80211.h
@@ -17,11 +17,31 @@ extern void nl80211_send_rx_auth(struct cfg80211_registered_device *rdev,
 extern void nl80211_send_rx_assoc(struct cfg80211_registered_device *rdev,
                                   struct net_device *netdev,
                                   const u8 *buf, size_t len);
-extern void nl80211_send_rx_deauth(struct cfg80211_registered_device *rdev,
-                                   struct net_device *netdev,
-                                   const u8 *buf, size_t len);
-extern void nl80211_send_rx_disassoc(struct cfg80211_registered_device *rdev,
-                                     struct net_device *netdev,
-                                     const u8 *buf, size_t len);
+extern void nl80211_send_deauth(struct cfg80211_registered_device *rdev,
+                                struct net_device *netdev,
+                                const u8 *buf, size_t len);
+extern void nl80211_send_disassoc(struct cfg80211_registered_device *rdev,
+                                  struct net_device *netdev,
+                                  const u8 *buf, size_t len);
+extern void nl80211_send_auth_timeout(struct cfg80211_registered_device *rdev,
+                                      struct net_device *netdev,
+                                      const u8 *addr);
+extern void nl80211_send_assoc_timeout(struct cfg80211_registered_device *rdev,
+                                       struct net_device *netdev,
+                                       const u8 *addr);
+extern void
+nl80211_michael_mic_failure(struct cfg80211_registered_device *rdev,
+                            struct net_device *netdev, const u8 *addr,
+                            enum nl80211_key_type key_type,
+                            int key_id, const u8 *tsc);
+
+extern void
+nl80211_send_beacon_hint_event(struct wiphy *wiphy,
+                               struct ieee80211_channel *channel_before,
+                               struct ieee80211_channel *channel_after);
+
+void nl80211_send_ibss_bssid(struct cfg80211_registered_device *rdev,
+                             struct net_device *netdev, const u8 *bssid,
+                             gfp_t gfp);
 
 #endif /* __NET_WIRELESS_NL80211_H */
diff --git a/net/wireless/reg.c b/net/wireless/reg.c
index 487cb627ddba..5e14371cda70 100644
--- a/net/wireless/reg.c
+++ b/net/wireless/reg.c
@@ -37,7 +37,6 @@
 #include <linux/random.h>
 #include <linux/nl80211.h>
 #include <linux/platform_device.h>
-#include <net/wireless.h>
 #include <net/cfg80211.h>
 #include "core.h"
 #include "reg.h"
@@ -49,12 +48,6 @@ static struct regulatory_request *last_request;
 /* To trigger userspace events */
 static struct platform_device *reg_pdev;
 
-/* Keep the ordering from large to small */
-static u32 supported_bandwidths[] = {
-        MHZ_TO_KHZ(40),
-        MHZ_TO_KHZ(20),
-};
-
 /*
  * Central wireless core regulatory domains, we only need two,
  * the current one and a world regulatory domain in case we have no
@@ -389,6 +382,8 @@ static int call_crda(const char *alpha2)
 /* Used by nl80211 before kmalloc'ing our regulatory domain */
 bool reg_is_valid_request(const char *alpha2)
 {
+        assert_cfg80211_lock();
+
         if (!last_request)
                 return false;
 
@@ -436,19 +431,20 @@ static bool is_valid_rd(const struct ieee80211_regdomain *rd)
         return true;
 }
 
-/* Returns value in KHz */
-static u32 freq_max_bandwidth(const struct ieee80211_freq_range *freq_range,
-        u32 freq)
+static bool reg_does_bw_fit(const struct ieee80211_freq_range *freq_range,
+                            u32 center_freq_khz,
+                            u32 bw_khz)
 {
-        unsigned int i;
-        for (i = 0; i < ARRAY_SIZE(supported_bandwidths); i++) {
-                u32 start_freq_khz = freq - supported_bandwidths[i]/2;
-                u32 end_freq_khz = freq + supported_bandwidths[i]/2;
-                if (start_freq_khz >= freq_range->start_freq_khz &&
-                        end_freq_khz <= freq_range->end_freq_khz)
-                        return supported_bandwidths[i];
-        }
-        return 0;
+        u32 start_freq_khz, end_freq_khz;
+
+        start_freq_khz = center_freq_khz - (bw_khz/2);
+        end_freq_khz = center_freq_khz + (bw_khz/2);
+
+        if (start_freq_khz >= freq_range->start_freq_khz &&
+            end_freq_khz <= freq_range->end_freq_khz)
+                return true;
+
+        return false;
 }
 
 /**
@@ -848,14 +844,17 @@ static u32 map_regdom_flags(u32 rd_flags)
 
 static int freq_reg_info_regd(struct wiphy *wiphy,
                               u32 center_freq,
-                              u32 *bandwidth,
+                              u32 desired_bw_khz,
                               const struct ieee80211_reg_rule **reg_rule,
                               const struct ieee80211_regdomain *custom_regd)
 {
         int i;
         bool band_rule_found = false;
         const struct ieee80211_regdomain *regd;
-        u32 max_bandwidth = 0;
+        bool bw_fits = false;
+
+        if (!desired_bw_khz)
+                desired_bw_khz = MHZ_TO_KHZ(20);
 
         regd = custom_regd ? custom_regd : cfg80211_regdomain;
 
@@ -888,38 +887,54 @@ static int freq_reg_info_regd(struct wiphy *wiphy,
                 if (!band_rule_found)
                         band_rule_found = freq_in_rule_band(fr, center_freq);
 
-                max_bandwidth = freq_max_bandwidth(fr, center_freq);
+                bw_fits = reg_does_bw_fit(fr,
+                                          center_freq,
+                                          desired_bw_khz);
 
-                if (max_bandwidth && *bandwidth <= max_bandwidth) {
+                if (band_rule_found && bw_fits) {
                         *reg_rule = rr;
-                        *bandwidth = max_bandwidth;
-                        break;
+                        return 0;
                 }
         }
 
         if (!band_rule_found)
                 return -ERANGE;
 
-        return !max_bandwidth;
+        return -EINVAL;
 }
 EXPORT_SYMBOL(freq_reg_info);
 
-int freq_reg_info(struct wiphy *wiphy, u32 center_freq, u32 *bandwidth,
-                         const struct ieee80211_reg_rule **reg_rule)
+int freq_reg_info(struct wiphy *wiphy,
+                  u32 center_freq,
+                  u32 desired_bw_khz,
+                  const struct ieee80211_reg_rule **reg_rule)
 {
         assert_cfg80211_lock();
-        return freq_reg_info_regd(wiphy, center_freq,
-                bandwidth, reg_rule, NULL);
+        return freq_reg_info_regd(wiphy,
+                                  center_freq,
+                                  desired_bw_khz,
+                                  reg_rule,
+                                  NULL);
 }
 
+/*
+ * Note that right now we assume the desired channel bandwidth
+ * is always 20 MHz for each individual channel (HT40 uses 20 MHz
+ * per channel, the primary and the extension channel). To support
+ * smaller custom bandwidths such as 5 MHz or 10 MHz we'll need a
+ * new ieee80211_channel.target_bw and re run the regulatory check
+ * on the wiphy with the target_bw specified. Then we can simply use
+ * that below for the desired_bw_khz below.
+ */
 static void handle_channel(struct wiphy *wiphy, enum ieee80211_band band,
                            unsigned int chan_idx)
 {
         int r;
-        u32 flags;
-        u32 max_bandwidth = 0;
+        u32 flags, bw_flags = 0;
+        u32 desired_bw_khz = MHZ_TO_KHZ(20);
         const struct ieee80211_reg_rule *reg_rule = NULL;
         const struct ieee80211_power_rule *power_rule = NULL;
+        const struct ieee80211_freq_range *freq_range = NULL;
         struct ieee80211_supported_band *sband;
         struct ieee80211_channel *chan;
         struct wiphy *request_wiphy = NULL;
@@ -934,8 +949,10 @@ static void handle_channel(struct wiphy *wiphy, enum ieee80211_band band,
 
         flags = chan->orig_flags;
 
-        r = freq_reg_info(wiphy, MHZ_TO_KHZ(chan->center_freq),
-                &max_bandwidth, &reg_rule);
+        r = freq_reg_info(wiphy,
+                          MHZ_TO_KHZ(chan->center_freq),
+                          desired_bw_khz,
+                          &reg_rule);
 
         if (r) {
                 /*
@@ -978,6 +995,10 @@ static void handle_channel(struct wiphy *wiphy, enum ieee80211_band band,
         }
 
         power_rule = &reg_rule->power_rule;
+        freq_range = &reg_rule->freq_range;
+
+        if (freq_range->max_bandwidth_khz < MHZ_TO_KHZ(40))
+                bw_flags = IEEE80211_CHAN_NO_HT40;
 
         if (last_request->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
             request_wiphy && request_wiphy == wiphy &&
@@ -988,19 +1009,19 @@ static void handle_channel(struct wiphy *wiphy, enum ieee80211_band band,
                  * settings
                  */
                 chan->flags = chan->orig_flags =
-                        map_regdom_flags(reg_rule->flags);
+                        map_regdom_flags(reg_rule->flags) | bw_flags;
                 chan->max_antenna_gain = chan->orig_mag =
                         (int) MBI_TO_DBI(power_rule->max_antenna_gain);
-                chan->max_bandwidth = KHZ_TO_MHZ(max_bandwidth);
+                chan->max_bandwidth = KHZ_TO_MHZ(desired_bw_khz);
                 chan->max_power = chan->orig_mpwr =
                         (int) MBM_TO_DBM(power_rule->max_eirp);
                 return;
         }
 
-        chan->flags = flags | map_regdom_flags(reg_rule->flags);
+        chan->flags = flags | bw_flags | map_regdom_flags(reg_rule->flags);
         chan->max_antenna_gain = min(chan->orig_mag,
                 (int) MBI_TO_DBI(power_rule->max_antenna_gain));
-        chan->max_bandwidth = KHZ_TO_MHZ(max_bandwidth);
+        chan->max_bandwidth = KHZ_TO_MHZ(desired_bw_khz);
         if (chan->orig_mpwr)
                 chan->max_power = min(chan->orig_mpwr,
                         (int) MBM_TO_DBM(power_rule->max_eirp));
@@ -1050,18 +1071,10 @@ static void handle_reg_beacon(struct wiphy *wiphy,
                               unsigned int chan_idx,
                               struct reg_beacon *reg_beacon)
 {
-#ifdef CONFIG_CFG80211_REG_DEBUG
-#define REG_DEBUG_BEACON_FLAG(desc) \
-        printk(KERN_DEBUG "cfg80211: Enabling " desc " on " \
-                "frequency: %d MHz (Ch %d) on %s\n", \
-                reg_beacon->chan.center_freq, \
-                ieee80211_frequency_to_channel(reg_beacon->chan.center_freq), \
-                wiphy_name(wiphy));
-#else
-#define REG_DEBUG_BEACON_FLAG(desc) do {} while (0)
-#endif
         struct ieee80211_supported_band *sband;
         struct ieee80211_channel *chan;
+        bool channel_changed = false;
+        struct ieee80211_channel chan_before;
 
         assert_cfg80211_lock();
 
@@ -1071,18 +1084,28 @@ static void handle_reg_beacon(struct wiphy *wiphy,
         if (likely(chan->center_freq != reg_beacon->chan.center_freq))
                 return;
 
-        if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN) {
+        if (chan->beacon_found)
+                return;
+
+        chan->beacon_found = true;
+
+        chan_before.center_freq = chan->center_freq;
+        chan_before.flags = chan->flags;
+
+        if ((chan->flags & IEEE80211_CHAN_PASSIVE_SCAN) &&
+            !(chan->orig_flags & IEEE80211_CHAN_PASSIVE_SCAN)) {
                 chan->flags &= ~IEEE80211_CHAN_PASSIVE_SCAN;
-                REG_DEBUG_BEACON_FLAG("active scanning");
+                channel_changed = true;
         }
 
-        if (chan->flags & IEEE80211_CHAN_NO_IBSS) {
+        if ((chan->flags & IEEE80211_CHAN_NO_IBSS) &&
+            !(chan->orig_flags & IEEE80211_CHAN_NO_IBSS)) {
                 chan->flags &= ~IEEE80211_CHAN_NO_IBSS;
-                REG_DEBUG_BEACON_FLAG("beaconing");
+                channel_changed = true;
         }
 
-        chan->beacon_found = true;
-#undef REG_DEBUG_BEACON_FLAG
+        if (channel_changed)
+                nl80211_send_beacon_hint_event(wiphy, &chan_before, chan);
 }
 
 /*
@@ -1155,6 +1178,93 @@ static void reg_process_beacons(struct wiphy *wiphy)
         wiphy_update_beacon_reg(wiphy);
 }
 
+static bool is_ht40_not_allowed(struct ieee80211_channel *chan)
+{
+        if (!chan)
+                return true;
+        if (chan->flags & IEEE80211_CHAN_DISABLED)
+                return true;
+        /* This would happen when regulatory rules disallow HT40 completely */
+        if (IEEE80211_CHAN_NO_HT40 == (chan->flags & (IEEE80211_CHAN_NO_HT40)))
+                return true;
+        return false;
+}
+
+static void reg_process_ht_flags_channel(struct wiphy *wiphy,
+                                         enum ieee80211_band band,
+                                         unsigned int chan_idx)
+{
+        struct ieee80211_supported_band *sband;
+        struct ieee80211_channel *channel;
+        struct ieee80211_channel *channel_before = NULL, *channel_after = NULL;
+        unsigned int i;
+
+        assert_cfg80211_lock();
+
+        sband = wiphy->bands[band];
+        BUG_ON(chan_idx >= sband->n_channels);
+        channel = &sband->channels[chan_idx];
+
+        if (is_ht40_not_allowed(channel)) {
+                channel->flags |= IEEE80211_CHAN_NO_HT40;
+                return;
+        }
+
+        /*
+         * We need to ensure the extension channels exist to
+         * be able to use HT40- or HT40+, this finds them (or not)
+         */
+        for (i = 0; i < sband->n_channels; i++) {
+                struct ieee80211_channel *c = &sband->channels[i];
+                if (c->center_freq == (channel->center_freq - 20))
+                        channel_before = c;
+                if (c->center_freq == (channel->center_freq + 20))
+                        channel_after = c;
+        }
+
+        /*
+         * Please note that this assumes target bandwidth is 20 MHz,
+         * if that ever changes we also need to change the below logic
+         * to include that as well.
+         */
+        if (is_ht40_not_allowed(channel_before))
+                channel->flags |= IEEE80211_CHAN_NO_HT40MINUS;
+        else
+                channel->flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
+
+        if (is_ht40_not_allowed(channel_after))
+                channel->flags |= IEEE80211_CHAN_NO_HT40PLUS;
+        else
+                channel->flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
+}
+
+static void reg_process_ht_flags_band(struct wiphy *wiphy,
+                                      enum ieee80211_band band)
+{
+        unsigned int i;
+        struct ieee80211_supported_band *sband;
+
+        BUG_ON(!wiphy->bands[band]);
+        sband = wiphy->bands[band];
+
+        for (i = 0; i < sband->n_channels; i++)
+                reg_process_ht_flags_channel(wiphy, band, i);
+}
+
+static void reg_process_ht_flags(struct wiphy *wiphy)
+{
+        enum ieee80211_band band;
+
+        if (!wiphy)
+                return;
+
+        for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
+                if (wiphy->bands[band])
+                        reg_process_ht_flags_band(wiphy, band);
+        }
+
+}
+
 void wiphy_update_regulatory(struct wiphy *wiphy,
                              enum nl80211_reg_initiator initiator)
 {
@@ -1168,6 +1278,7 @@ void wiphy_update_regulatory(struct wiphy *wiphy,
         }
 out:
         reg_process_beacons(wiphy);
+        reg_process_ht_flags(wiphy);
         if (wiphy->reg_notifier)
                 wiphy->reg_notifier(wiphy, last_request);
 }
@@ -1178,9 +1289,11 @@ static void handle_channel_custom(struct wiphy *wiphy,
                                   const struct ieee80211_regdomain *regd)
 {
         int r;
-        u32 max_bandwidth = 0;
+        u32 desired_bw_khz = MHZ_TO_KHZ(20);
+        u32 bw_flags = 0;
         const struct ieee80211_reg_rule *reg_rule = NULL;
         const struct ieee80211_power_rule *power_rule = NULL;
+        const struct ieee80211_freq_range *freq_range = NULL;
         struct ieee80211_supported_band *sband;
         struct ieee80211_channel *chan;
 
@@ -1190,8 +1303,11 @@ static void handle_channel_custom(struct wiphy *wiphy,
         BUG_ON(chan_idx >= sband->n_channels);
         chan = &sband->channels[chan_idx];
 
-        r = freq_reg_info_regd(wiphy, MHZ_TO_KHZ(chan->center_freq),
-                &max_bandwidth, &reg_rule, regd);
+        r = freq_reg_info_regd(wiphy,
+                               MHZ_TO_KHZ(chan->center_freq),
+                               desired_bw_khz,
+                               &reg_rule,
+                               regd);
 
         if (r) {
                 chan->flags = IEEE80211_CHAN_DISABLED;
@@ -1199,10 +1315,14 @@ static void handle_channel_custom(struct wiphy *wiphy,
         }
 
         power_rule = &reg_rule->power_rule;
+        freq_range = &reg_rule->freq_range;
+
+        if (freq_range->max_bandwidth_khz < MHZ_TO_KHZ(40))
+                bw_flags = IEEE80211_CHAN_NO_HT40;
 
-        chan->flags |= map_regdom_flags(reg_rule->flags);
+        chan->flags |= map_regdom_flags(reg_rule->flags) | bw_flags;
         chan->max_antenna_gain = (int) MBI_TO_DBI(power_rule->max_antenna_gain);
-        chan->max_bandwidth = KHZ_TO_MHZ(max_bandwidth);
+        chan->max_bandwidth = KHZ_TO_MHZ(desired_bw_khz);
         chan->max_power = (int) MBM_TO_DBM(power_rule->max_eirp);
 }
 
@@ -1224,13 +1344,22 @@ void wiphy_apply_custom_regulatory(struct wiphy *wiphy,
                                    const struct ieee80211_regdomain *regd)
 {
         enum ieee80211_band band;
+        unsigned int bands_set = 0;
 
         mutex_lock(&cfg80211_mutex);
         for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
-                if (wiphy->bands[band])
-                        handle_band_custom(wiphy, band, regd);
+                if (!wiphy->bands[band])
+                        continue;
+                handle_band_custom(wiphy, band, regd);
+                bands_set++;
         }
         mutex_unlock(&cfg80211_mutex);
+
+        /*
+         * no point in calling this if it won't have any effect
+         * on your device's supportd bands.
+         */
+        WARN_ON(!bands_set);
 }
 EXPORT_SYMBOL(wiphy_apply_custom_regulatory);
 
@@ -2000,7 +2129,12 @@ static int __set_regdom(const struct ieee80211_regdomain *rd)
                  * driver wanted to the wiphy to deal with conflicts
                  */
 
-                BUG_ON(request_wiphy->regd);
+                /*
+                 * Userspace could have sent two replies with only
+                 * one kernel request.
+                 */
+                if (request_wiphy->regd)
+                        return -EALREADY;
 
                 r = reg_copy_regd(&request_wiphy->regd, rd);
                 if (r)
@@ -2042,7 +2176,13 @@ static int __set_regdom(const struct ieee80211_regdomain *rd)
          * the country IE rd with what CRDA believes that country should have
          */
 
-        BUG_ON(!country_ie_regdomain);
+        /*
+         * Userspace could have sent two replies with only
+         * one kernel request. By the second reply we would have
+         * already processed and consumed the country_ie_regdomain.
+         */
+        if (!country_ie_regdomain)
+                return -EALREADY;
         BUG_ON(rd == country_ie_regdomain);
 
         /*
@@ -2119,14 +2259,14 @@ void reg_device_remove(struct wiphy *wiphy)
 
         assert_cfg80211_lock();
 
+        kfree(wiphy->regd);
+
         if (last_request)
                 request_wiphy = wiphy_idx_to_wiphy(last_request->wiphy_idx);
 
-        kfree(wiphy->regd);
-        if (!last_request || !request_wiphy)
-                return;
-        if (request_wiphy != wiphy)
+        if (!request_wiphy || request_wiphy != wiphy)
                 return;
+
         last_request->wiphy_idx = WIPHY_IDX_STALE;
         last_request->country_ie_env = ENVIRON_ANY;
 }
diff --git a/net/wireless/scan.c b/net/wireless/scan.c
index 1f260c40b6ca..e95b638b919f 100644
--- a/net/wireless/scan.c
+++ b/net/wireless/scan.c
@@ -29,13 +29,14 @@ void cfg80211_scan_done(struct cfg80211_scan_request *request, bool aborted)
                 goto out;
 
         WARN_ON(request != wiphy_to_dev(request->wiphy)->scan_req);
-        wiphy_to_dev(request->wiphy)->scan_req = NULL;
 
         if (aborted)
                 nl80211_send_scan_aborted(wiphy_to_dev(request->wiphy), dev);
         else
                 nl80211_send_scan_done(wiphy_to_dev(request->wiphy), dev);
 
+        wiphy_to_dev(request->wiphy)->scan_req = NULL;
+
 #ifdef CONFIG_WIRELESS_EXT
         if (!aborted) {
                 memset(&wrqu, 0, sizeof(wrqu));
@@ -377,18 +378,16 @@ cfg80211_bss_update(struct cfg80211_registered_device *dev,
                         size_t used = dev->wiphy.bss_priv_size + sizeof(*res);
                         size_t ielen = res->pub.len_information_elements;
 
-                        if (ksize(found) >= used + ielen) {
+                        if (!found->ies_allocated && ksize(found) >= used + ielen) {
                                 memcpy(found->pub.information_elements,
                                        res->pub.information_elements, ielen);
                                 found->pub.len_information_elements = ielen;
                         } else {
                                 u8 *ies = found->pub.information_elements;
 
-                                if (found->ies_allocated) {
-                                        if (ksize(ies) < ielen)
-                                                ies = krealloc(ies, ielen,
-                                                               GFP_ATOMIC);
-                                } else
+                                if (found->ies_allocated)
+                                        ies = krealloc(ies, ielen, GFP_ATOMIC);
+                                else
                                         ies = kmalloc(ielen, GFP_ATOMIC);
 
                                 if (ies) {
@@ -415,6 +414,55 @@ cfg80211_bss_update(struct cfg80211_registered_device *dev,
         return found;
 }
 
+struct cfg80211_bss*
+cfg80211_inform_bss(struct wiphy *wiphy,
+                    struct ieee80211_channel *channel,
+                    const u8 *bssid,
+                    u64 timestamp, u16 capability, u16 beacon_interval,
+                    const u8 *ie, size_t ielen,
+                    s32 signal, gfp_t gfp)
+{
+        struct cfg80211_internal_bss *res;
+        size_t privsz;
+
+        if (WARN_ON(!wiphy))
+                return NULL;
+
+        privsz = wiphy->bss_priv_size;
+
+        if (WARN_ON(wiphy->signal_type == NL80211_BSS_SIGNAL_UNSPEC &&
+                        (signal < 0 || signal > 100)))
+                return NULL;
+
+        res = kzalloc(sizeof(*res) + privsz + ielen, gfp);
+        if (!res)
+                return NULL;
+
+        memcpy(res->pub.bssid, bssid, ETH_ALEN);
+        res->pub.channel = channel;
+        res->pub.signal = signal;
+        res->pub.tsf = timestamp;
+        res->pub.beacon_interval = beacon_interval;
+        res->pub.capability = capability;
+        /* point to after the private area */
+        res->pub.information_elements = (u8 *)res + sizeof(*res) + privsz;
+        memcpy(res->pub.information_elements, ie, ielen);
+        res->pub.len_information_elements = ielen;
+
+        kref_init(&res->ref);
+
+        res = cfg80211_bss_update(wiphy_to_dev(wiphy), res, 0);
+        if (!res)
+                return NULL;
+
+        if (res->pub.capability & WLAN_CAPABILITY_ESS)
+                regulatory_hint_found_beacon(wiphy, channel, gfp);
+
+        /* cfg80211_bss_update gives us a referenced result */
+        return &res->pub;
+}
+EXPORT_SYMBOL(cfg80211_inform_bss);
+
 struct cfg80211_bss *
 cfg80211_inform_bss_frame(struct wiphy *wiphy,
                           struct ieee80211_channel *channel,
@@ -605,7 +653,7 @@ int cfg80211_wext_siwscan(struct net_device *dev,
         cfg80211_put_dev(rdev);
         return err;
 }
-EXPORT_SYMBOL(cfg80211_wext_siwscan);
+EXPORT_SYMBOL_GPL(cfg80211_wext_siwscan);
 
 static void ieee80211_scan_add_ies(struct iw_request_info *info,
                                    struct cfg80211_bss *bss,
@@ -914,5 +962,5 @@ int cfg80211_wext_giwscan(struct net_device *dev,
         cfg80211_put_dev(rdev);
         return res;
 }
-EXPORT_SYMBOL(cfg80211_wext_giwscan);
+EXPORT_SYMBOL_GPL(cfg80211_wext_giwscan);
 #endif
diff --git a/net/wireless/util.c b/net/wireless/util.c
index 487cdd9bcffc..25550692dda6 100644
--- a/net/wireless/util.c
+++ b/net/wireless/util.c
@@ -1,10 +1,12 @@
 /*
  * Wireless utility functions
  *
- * Copyright 2007       Johannes Berg <johannes@sipsolutions.net>
+ * Copyright 2007-2009  Johannes Berg <johannes@sipsolutions.net>
  */
-#include <net/wireless.h>
-#include <asm/bitops.h>
+#include <linux/bitops.h>
+#include <linux/etherdevice.h>
+#include <net/cfg80211.h>
+#include <net/ip.h>
 #include "core.h"
 
 struct ieee80211_rate *
@@ -138,3 +140,365 @@ void ieee80211_set_bitrate_flags(struct wiphy *wiphy)
                 if (wiphy->bands[band])
                         set_mandatory_flags_band(wiphy->bands[band], band);
 }
+
+int cfg80211_validate_key_settings(struct key_params *params, int key_idx,
+                                   const u8 *mac_addr)
+{
+        if (key_idx > 5)
+                return -EINVAL;
+
+        /*
+         * Disallow pairwise keys with non-zero index unless it's WEP
+         * (because current deployments use pairwise WEP keys with
+         * non-zero indizes but 802.11i clearly specifies to use zero)
+         */
+        if (mac_addr && key_idx &&
+            params->cipher != WLAN_CIPHER_SUITE_WEP40 &&
+            params->cipher != WLAN_CIPHER_SUITE_WEP104)
+                return -EINVAL;
+
+        switch (params->cipher) {
+        case WLAN_CIPHER_SUITE_WEP40:
+                if (params->key_len != WLAN_KEY_LEN_WEP40)
+                        return -EINVAL;
+                break;
+        case WLAN_CIPHER_SUITE_TKIP:
+                if (params->key_len != WLAN_KEY_LEN_TKIP)
+                        return -EINVAL;
+                break;
+        case WLAN_CIPHER_SUITE_CCMP:
+                if (params->key_len != WLAN_KEY_LEN_CCMP)
+                        return -EINVAL;
+                break;
+        case WLAN_CIPHER_SUITE_WEP104:
+                if (params->key_len != WLAN_KEY_LEN_WEP104)
+                        return -EINVAL;
+                break;
+        case WLAN_CIPHER_SUITE_AES_CMAC:
+                if (params->key_len != WLAN_KEY_LEN_AES_CMAC)
+                        return -EINVAL;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        if (params->seq) {
+                switch (params->cipher) {
+                case WLAN_CIPHER_SUITE_WEP40:
+                case WLAN_CIPHER_SUITE_WEP104:
+                        /* These ciphers do not use key sequence */
+                        return -EINVAL;
+                case WLAN_CIPHER_SUITE_TKIP:
+                case WLAN_CIPHER_SUITE_CCMP:
+                case WLAN_CIPHER_SUITE_AES_CMAC:
+                        if (params->seq_len != 6)
+                                return -EINVAL;
+                        break;
+                }
+        }
+
+        return 0;
+}
+
+/* See IEEE 802.1H for LLC/SNAP encapsulation/decapsulation */
+/* Ethernet-II snap header (RFC1042 for most EtherTypes) */
+const unsigned char rfc1042_header[] __aligned(2) =
+        { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00 };
+EXPORT_SYMBOL(rfc1042_header);
+
+/* Bridge-Tunnel header (for EtherTypes ETH_P_AARP and ETH_P_IPX) */
+const unsigned char bridge_tunnel_header[] __aligned(2) =
+        { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0xf8 };
+EXPORT_SYMBOL(bridge_tunnel_header);
+
+unsigned int ieee80211_hdrlen(__le16 fc)
+{
+        unsigned int hdrlen = 24;
+
+        if (ieee80211_is_data(fc)) {
+                if (ieee80211_has_a4(fc))
+                        hdrlen = 30;
+                if (ieee80211_is_data_qos(fc))
+                        hdrlen += IEEE80211_QOS_CTL_LEN;
+                goto out;
+        }
+
+        if (ieee80211_is_ctl(fc)) {
+                /*
+                 * ACK and CTS are 10 bytes, all others 16. To see how
+                 * to get this condition consider
+                 *   subtype mask:   0b0000000011110000 (0x00F0)
+                 *   ACK subtype:    0b0000000011010000 (0x00D0)
+                 *   CTS subtype:    0b0000000011000000 (0x00C0)
+                 *   bits that matter:         ^^^      (0x00E0)
+                 *   value of those: 0b0000000011000000 (0x00C0)
+                 */
+                if ((fc & cpu_to_le16(0x00E0)) == cpu_to_le16(0x00C0))
+                        hdrlen = 10;
+                else
+                        hdrlen = 16;
+        }
+out:
+        return hdrlen;
+}
+EXPORT_SYMBOL(ieee80211_hdrlen);
+
+unsigned int ieee80211_get_hdrlen_from_skb(const struct sk_buff *skb)
+{
+        const struct ieee80211_hdr *hdr =
+                        (const struct ieee80211_hdr *)skb->data;
+        unsigned int hdrlen;
+
+        if (unlikely(skb->len < 10))
+                return 0;
+        hdrlen = ieee80211_hdrlen(hdr->frame_control);
+        if (unlikely(hdrlen > skb->len))
+                return 0;
+        return hdrlen;
+}
+EXPORT_SYMBOL(ieee80211_get_hdrlen_from_skb);
+
+static int ieee80211_get_mesh_hdrlen(struct ieee80211s_hdr *meshhdr)
+{
+        int ae = meshhdr->flags & MESH_FLAGS_AE;
+        /* 7.1.3.5a.2 */
+        switch (ae) {
+        case 0:
+                return 6;
+        case 1:
+                return 12;
+        case 2:
+                return 18;
+        case 3:
+                return 24;
+        default:
+                return 6;
+        }
+}
+
+int ieee80211_data_to_8023(struct sk_buff *skb, u8 *addr,
+                           enum nl80211_iftype iftype)
+{
+        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
+        u16 hdrlen, ethertype;
+        u8 *payload;
+        u8 dst[ETH_ALEN];
+        u8 src[ETH_ALEN] __aligned(2);
+
+        if (unlikely(!ieee80211_is_data_present(hdr->frame_control)))
+                return -1;
+
+        hdrlen = ieee80211_hdrlen(hdr->frame_control);
+
+        /* convert IEEE 802.11 header + possible LLC headers into Ethernet
+         * header
+         * IEEE 802.11 address fields:
+         * ToDS FromDS Addr1 Addr2 Addr3 Addr4
+         *   0     0   DA    SA    BSSID n/a
+         *   0     1   DA    BSSID SA    n/a
+         *   1     0   BSSID SA    DA    n/a
+         *   1     1   RA    TA    DA    SA
+         */
+        memcpy(dst, ieee80211_get_DA(hdr), ETH_ALEN);
+        memcpy(src, ieee80211_get_SA(hdr), ETH_ALEN);
+
+        switch (hdr->frame_control &
+                cpu_to_le16(IEEE80211_FCTL_TODS | IEEE80211_FCTL_FROMDS)) {
+        case cpu_to_le16(IEEE80211_FCTL_TODS):
+                if (unlikely(iftype != NL80211_IFTYPE_AP &&
+                             iftype != NL80211_IFTYPE_AP_VLAN))
+                        return -1;
+                break;
+        case cpu_to_le16(IEEE80211_FCTL_TODS | IEEE80211_FCTL_FROMDS):
+                if (unlikely(iftype != NL80211_IFTYPE_WDS &&
+                             iftype != NL80211_IFTYPE_MESH_POINT))
+                        return -1;
+                if (iftype == NL80211_IFTYPE_MESH_POINT) {
+                        struct ieee80211s_hdr *meshdr =
+                                (struct ieee80211s_hdr *) (skb->data + hdrlen);
+                        hdrlen += ieee80211_get_mesh_hdrlen(meshdr);
+                        if (meshdr->flags & MESH_FLAGS_AE_A5_A6) {
+                                memcpy(dst, meshdr->eaddr1, ETH_ALEN);
+                                memcpy(src, meshdr->eaddr2, ETH_ALEN);
+                        }
+                }
+                break;
+        case cpu_to_le16(IEEE80211_FCTL_FROMDS):
+                if (iftype != NL80211_IFTYPE_STATION ||
+                    (is_multicast_ether_addr(dst) &&
+                     !compare_ether_addr(src, addr)))
+                        return -1;
+                break;
+        case cpu_to_le16(0):
+                if (iftype != NL80211_IFTYPE_ADHOC)
+                        return -1;
+                break;
+        }
+
+        if (unlikely(skb->len - hdrlen < 8))
+                return -1;
+
+        payload = skb->data + hdrlen;
+        ethertype = (payload[6] << 8) | payload[7];
+
+        if (likely((compare_ether_addr(payload, rfc1042_header) == 0 &&
+                    ethertype != ETH_P_AARP && ethertype != ETH_P_IPX) ||
+                   compare_ether_addr(payload, bridge_tunnel_header) == 0)) {
+                /* remove RFC1042 or Bridge-Tunnel encapsulation and
+                 * replace EtherType */
+                skb_pull(skb, hdrlen + 6);
+                memcpy(skb_push(skb, ETH_ALEN), src, ETH_ALEN);
+                memcpy(skb_push(skb, ETH_ALEN), dst, ETH_ALEN);
+        } else {
+                struct ethhdr *ehdr;
+                __be16 len;
+
+                skb_pull(skb, hdrlen);
+                len = htons(skb->len);
+                ehdr = (struct ethhdr *) skb_push(skb, sizeof(struct ethhdr));
+                memcpy(ehdr->h_dest, dst, ETH_ALEN);
+                memcpy(ehdr->h_source, src, ETH_ALEN);
+                ehdr->h_proto = len;
+        }
+        return 0;
+}
+EXPORT_SYMBOL(ieee80211_data_to_8023);
+
+int ieee80211_data_from_8023(struct sk_buff *skb, u8 *addr,
+                             enum nl80211_iftype iftype, u8 *bssid, bool qos)
+{
+        struct ieee80211_hdr hdr;
+        u16 hdrlen, ethertype;
+        __le16 fc;
+        const u8 *encaps_data;
+        int encaps_len, skip_header_bytes;
+        int nh_pos, h_pos;
+        int head_need;
+
+        if (unlikely(skb->len < ETH_HLEN))
+                return -EINVAL;
+
+        nh_pos = skb_network_header(skb) - skb->data;
+        h_pos = skb_transport_header(skb) - skb->data;
+
+        /* convert Ethernet header to proper 802.11 header (based on
+         * operation mode) */
+        ethertype = (skb->data[12] << 8) | skb->data[13];
+        fc = cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA);
+
+        switch (iftype) {
+        case NL80211_IFTYPE_AP:
+        case NL80211_IFTYPE_AP_VLAN:
+                fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS);
+                /* DA BSSID SA */
+                memcpy(hdr.addr1, skb->data, ETH_ALEN);
+                memcpy(hdr.addr2, addr, ETH_ALEN);
+                memcpy(hdr.addr3, skb->data + ETH_ALEN, ETH_ALEN);
+                hdrlen = 24;
+                break;
+        case NL80211_IFTYPE_STATION:
+                fc |= cpu_to_le16(IEEE80211_FCTL_TODS);
+                /* BSSID SA DA */
+                memcpy(hdr.addr1, bssid, ETH_ALEN);
+                memcpy(hdr.addr2, skb->data + ETH_ALEN, ETH_ALEN);
+                memcpy(hdr.addr3, skb->data, ETH_ALEN);
+                hdrlen = 24;
+                break;
+        case NL80211_IFTYPE_ADHOC:
+                /* DA SA BSSID */
+                memcpy(hdr.addr1, skb->data, ETH_ALEN);
+                memcpy(hdr.addr2, skb->data + ETH_ALEN, ETH_ALEN);
+                memcpy(hdr.addr3, bssid, ETH_ALEN);
+                hdrlen = 24;
+                break;
+        default:
+                return -EOPNOTSUPP;
+        }
+
+        if (qos) {
+                fc |= cpu_to_le16(IEEE80211_STYPE_QOS_DATA);
+                hdrlen += 2;
+        }
+
+        hdr.frame_control = fc;
+        hdr.duration_id = 0;
+        hdr.seq_ctrl = 0;
+
+        skip_header_bytes = ETH_HLEN;
+        if (ethertype == ETH_P_AARP || ethertype == ETH_P_IPX) {
+                encaps_data = bridge_tunnel_header;
+                encaps_len = sizeof(bridge_tunnel_header);
+                skip_header_bytes -= 2;
+        } else if (ethertype > 0x600) {
+                encaps_data = rfc1042_header;
+                encaps_len = sizeof(rfc1042_header);
+                skip_header_bytes -= 2;
+        } else {
+                encaps_data = NULL;
+                encaps_len = 0;
+        }
+
+        skb_pull(skb, skip_header_bytes);
+        nh_pos -= skip_header_bytes;
+        h_pos -= skip_header_bytes;
+
+        head_need = hdrlen + encaps_len - skb_headroom(skb);
+
+        if (head_need > 0 || skb_cloned(skb)) {
+                head_need = max(head_need, 0);
+                if (head_need)
+                        skb_orphan(skb);
+
+                if (pskb_expand_head(skb, head_need, 0, GFP_ATOMIC)) {
+                        printk(KERN_ERR "failed to reallocate Tx buffer\n");
+                        return -ENOMEM;
+                }
+                skb->truesize += head_need;
+        }
+
+        if (encaps_data) {
+                memcpy(skb_push(skb, encaps_len), encaps_data, encaps_len);
+                nh_pos += encaps_len;
+                h_pos += encaps_len;
+        }
+
+        memcpy(skb_push(skb, hdrlen), &hdr, hdrlen);
+
+        nh_pos += hdrlen;
+        h_pos += hdrlen;
+
+        /* Update skb pointers to various headers since this modified frame
+         * is going to go through Linux networking code that may potentially
+         * need things like pointer to IP header. */
+        skb_set_mac_header(skb, 0);
+        skb_set_network_header(skb, nh_pos);
+        skb_set_transport_header(skb, h_pos);
+
+        return 0;
+}
+EXPORT_SYMBOL(ieee80211_data_from_8023);
+
+/* Given a data frame determine the 802.1p/1d tag to use. */
+unsigned int cfg80211_classify8021d(struct sk_buff *skb)
+{
+        unsigned int dscp;
+
+        /* skb->priority values from 256->263 are magic values to
+         * directly indicate a specific 802.1d priority.  This is used
+         * to allow 802.1d priority to be passed directly in from VLAN
+         * tags, etc.
+         */
+        if (skb->priority >= 256 && skb->priority <= 263)
+                return skb->priority - 256;
+
+        switch (skb->protocol) {
+        case htons(ETH_P_IP):
+                dscp = ip_hdr(skb)->tos & 0xfc;
+                break;
+        default:
+                return 0;
+        }
+
+        return dscp >> 5;
+}
+EXPORT_SYMBOL(cfg80211_classify8021d);
diff --git a/net/wireless/wext-compat.c b/net/wireless/wext-compat.c
index 0fd1db6e95bb..d030c5315672 100644
--- a/net/wireless/wext-compat.c
+++ b/net/wireless/wext-compat.c
@@ -5,13 +5,14 @@
  * into cfg80211, when that happens all the exports here go away and
  * we directly assign the wireless handlers of wireless interfaces.
  *
- * Copyright 2008       Johannes Berg <johannes@sipsolutions.net>
+ * Copyright 2008-2009  Johannes Berg <johannes@sipsolutions.net>
  */
 
 #include <linux/wireless.h>
 #include <linux/nl80211.h>
+#include <linux/if_arp.h>
+#include <linux/etherdevice.h>
 #include <net/iw_handler.h>
-#include <net/wireless.h>
 #include <net/cfg80211.h>
 #include "core.h"
 
@@ -57,7 +58,7 @@ int cfg80211_wext_giwname(struct net_device *dev,
 
         return 0;
 }
-EXPORT_SYMBOL(cfg80211_wext_giwname);
+EXPORT_SYMBOL_GPL(cfg80211_wext_giwname);
 
 int cfg80211_wext_siwmode(struct net_device *dev, struct iw_request_info *info,
                           u32 *mode, char *extra)
@@ -108,7 +109,7 @@ int cfg80211_wext_siwmode(struct net_device *dev, struct iw_request_info *info,
 
         return ret;
 }
-EXPORT_SYMBOL(cfg80211_wext_siwmode);
+EXPORT_SYMBOL_GPL(cfg80211_wext_siwmode);
 
 int cfg80211_wext_giwmode(struct net_device *dev, struct iw_request_info *info,
                           u32 *mode, char *extra)
@@ -143,7 +144,7 @@ int cfg80211_wext_giwmode(struct net_device *dev, struct iw_request_info *info,
         }
         return 0;
 }
-EXPORT_SYMBOL(cfg80211_wext_giwmode);
+EXPORT_SYMBOL_GPL(cfg80211_wext_giwmode);
 
 
 int cfg80211_wext_giwrange(struct net_device *dev,
@@ -206,7 +207,6 @@ int cfg80211_wext_giwrange(struct net_device *dev,
         range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
                           IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
 
-
         for (band = 0; band < IEEE80211_NUM_BANDS; band ++) {
                 int i;
                 struct ieee80211_supported_band *sband;
@@ -240,4 +240,590 @@ int cfg80211_wext_giwrange(struct net_device *dev,
 
         return 0;
 }
-EXPORT_SYMBOL(cfg80211_wext_giwrange);
+EXPORT_SYMBOL_GPL(cfg80211_wext_giwrange);
+
+int cfg80211_wext_siwmlme(struct net_device *dev,
+                          struct iw_request_info *info,
+                          struct iw_point *data, char *extra)
+{
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+        struct iw_mlme *mlme = (struct iw_mlme *)extra;
+        struct cfg80211_registered_device *rdev;
+        union {
+                struct cfg80211_disassoc_request disassoc;
+                struct cfg80211_deauth_request deauth;
+        } cmd;
+
+        if (!wdev)
+                return -EOPNOTSUPP;
+
+        rdev = wiphy_to_dev(wdev->wiphy);
+
+        if (wdev->iftype != NL80211_IFTYPE_STATION)
+                return -EINVAL;
+
+        if (mlme->addr.sa_family != ARPHRD_ETHER)
+                return -EINVAL;
+
+        memset(&cmd, 0, sizeof(cmd));
+
+        switch (mlme->cmd) {
+        case IW_MLME_DEAUTH:
+                if (!rdev->ops->deauth)
+                        return -EOPNOTSUPP;
+                cmd.deauth.peer_addr = mlme->addr.sa_data;
+                cmd.deauth.reason_code = mlme->reason_code;
+                return rdev->ops->deauth(wdev->wiphy, dev, &cmd.deauth);
+        case IW_MLME_DISASSOC:
+                if (!rdev->ops->disassoc)
+                        return -EOPNOTSUPP;
+                cmd.disassoc.peer_addr = mlme->addr.sa_data;
+                cmd.disassoc.reason_code = mlme->reason_code;
+                return rdev->ops->disassoc(wdev->wiphy, dev, &cmd.disassoc);
+        default:
+                return -EOPNOTSUPP;
+        }
+}
+EXPORT_SYMBOL_GPL(cfg80211_wext_siwmlme);
+
+
+/**
+ * cfg80211_wext_freq - get wext frequency for non-"auto"
+ * @wiphy: the wiphy
+ * @freq: the wext freq encoding
+ *
+ * Returns a channel, %NULL for auto, or an ERR_PTR for errors!
+ */
+struct ieee80211_channel *cfg80211_wext_freq(struct wiphy *wiphy,
+                                             struct iw_freq *freq)
+{
+        struct ieee80211_channel *chan;
+        int f;
+
+        /*
+         * Parse frequency - return NULL for auto and
+         * -EINVAL for impossible things.
+         */
+        if (freq->e == 0) {
+                if (freq->m < 0)
+                        return NULL;
+                f = ieee80211_channel_to_frequency(freq->m);
+        } else {
+                int i, div = 1000000;
+                for (i = 0; i < freq->e; i++)
+                        div /= 10;
+                if (div <= 0)
+                        return ERR_PTR(-EINVAL);
+                f = freq->m / div;
+        }
+
+        /*
+         * Look up channel struct and return -EINVAL when
+         * it cannot be found.
+         */
+        chan = ieee80211_get_channel(wiphy, f);
+        if (!chan)
+                return ERR_PTR(-EINVAL);
+        return chan;
+}
+EXPORT_SYMBOL_GPL(cfg80211_wext_freq);
+
+int cfg80211_wext_siwrts(struct net_device *dev,
+                         struct iw_request_info *info,
+                         struct iw_param *rts, char *extra)
+{
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+        struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
+        u32 orts = wdev->wiphy->rts_threshold;
+        int err;
+
+        if (rts->disabled || !rts->fixed)
+                wdev->wiphy->rts_threshold = (u32) -1;
+        else if (rts->value < 0)
+                return -EINVAL;
+        else
+                wdev->wiphy->rts_threshold = rts->value;
+
+        err = rdev->ops->set_wiphy_params(wdev->wiphy,
+                                          WIPHY_PARAM_RTS_THRESHOLD);
+        if (err)
+                wdev->wiphy->rts_threshold = orts;
+
+        return err;
+}
+EXPORT_SYMBOL_GPL(cfg80211_wext_siwrts);
+
+int cfg80211_wext_giwrts(struct net_device *dev,
+                         struct iw_request_info *info,
+                         struct iw_param *rts, char *extra)
+{
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+
+        rts->value = wdev->wiphy->rts_threshold;
+        rts->disabled = rts->value == (u32) -1;
+        rts->fixed = 1;
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(cfg80211_wext_giwrts);
+
+int cfg80211_wext_siwfrag(struct net_device *dev,
+                          struct iw_request_info *info,
+                          struct iw_param *frag, char *extra)
+{
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+        struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
+        u32 ofrag = wdev->wiphy->frag_threshold;
+        int err;
+
+        if (frag->disabled || !frag->fixed)
+                wdev->wiphy->frag_threshold = (u32) -1;
+        else if (frag->value < 256)
+                return -EINVAL;
+        else {
+                /* Fragment length must be even, so strip LSB. */
+                wdev->wiphy->frag_threshold = frag->value & ~0x1;
+        }
+
+        err = rdev->ops->set_wiphy_params(wdev->wiphy,
+                                          WIPHY_PARAM_FRAG_THRESHOLD);
+        if (err)
+                wdev->wiphy->frag_threshold = ofrag;
+
+        return err;
+}
+EXPORT_SYMBOL_GPL(cfg80211_wext_siwfrag);
+
+int cfg80211_wext_giwfrag(struct net_device *dev,
+                          struct iw_request_info *info,
+                          struct iw_param *frag, char *extra)
+{
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+
+        frag->value = wdev->wiphy->frag_threshold;
+        frag->disabled = frag->value == (u32) -1;
+        frag->fixed = 1;
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(cfg80211_wext_giwfrag);
+
+int cfg80211_wext_siwretry(struct net_device *dev,
+                           struct iw_request_info *info,
+                           struct iw_param *retry, char *extra)
+{
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+        struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
+        u32 changed = 0;
+        u8 olong = wdev->wiphy->retry_long;
+        u8 oshort = wdev->wiphy->retry_short;
+        int err;
+
+        if (retry->disabled ||
+            (retry->flags & IW_RETRY_TYPE) != IW_RETRY_LIMIT)
+                return -EINVAL;
+
+        if (retry->flags & IW_RETRY_LONG) {
+                wdev->wiphy->retry_long = retry->value;
+                changed |= WIPHY_PARAM_RETRY_LONG;
+        } else if (retry->flags & IW_RETRY_SHORT) {
+                wdev->wiphy->retry_short = retry->value;
+                changed |= WIPHY_PARAM_RETRY_SHORT;
+        } else {
+                wdev->wiphy->retry_short = retry->value;
+                wdev->wiphy->retry_long = retry->value;
+                changed |= WIPHY_PARAM_RETRY_LONG;
+                changed |= WIPHY_PARAM_RETRY_SHORT;
+        }
+
+        if (!changed)
+                return 0;
+
+        err = rdev->ops->set_wiphy_params(wdev->wiphy, changed);
+        if (err) {
+                wdev->wiphy->retry_short = oshort;
+                wdev->wiphy->retry_long = olong;
+        }
+
+        return err;
+}
+EXPORT_SYMBOL_GPL(cfg80211_wext_siwretry);
+
+int cfg80211_wext_giwretry(struct net_device *dev,
+                           struct iw_request_info *info,
+                           struct iw_param *retry, char *extra)
+{
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+
+        retry->disabled = 0;
+
+        if (retry->flags == 0 || (retry->flags & IW_RETRY_SHORT)) {
+                /*
+                 * First return short value, iwconfig will ask long value
+                 * later if needed
+                 */
+                retry->flags |= IW_RETRY_LIMIT;
+                retry->value = wdev->wiphy->retry_short;
+                if (wdev->wiphy->retry_long != wdev->wiphy->retry_short)
+                        retry->flags |= IW_RETRY_LONG;
+
+                return 0;
+        }
+
+        if (retry->flags & IW_RETRY_LONG) {
+                retry->flags = IW_RETRY_LIMIT | IW_RETRY_LONG;
+                retry->value = wdev->wiphy->retry_long;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(cfg80211_wext_giwretry);
+
+static int cfg80211_set_encryption(struct cfg80211_registered_device *rdev,
+                                   struct net_device *dev, const u8 *addr,
+                                   bool remove, bool tx_key, int idx,
+                                   struct key_params *params)
+{
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+        int err;
+
+        if (params->cipher == WLAN_CIPHER_SUITE_AES_CMAC) {
+                if (!rdev->ops->set_default_mgmt_key)
+                        return -EOPNOTSUPP;
+
+                if (idx < 4 || idx > 5)
+                        return -EINVAL;
+        } else if (idx < 0 || idx > 3)
+                return -EINVAL;
+
+        if (remove) {
+                err = rdev->ops->del_key(&rdev->wiphy, dev, idx, addr);
+                if (!err) {
+                        if (idx == wdev->wext.default_key)
+                                wdev->wext.default_key = -1;
+                        else if (idx == wdev->wext.default_mgmt_key)
+                                wdev->wext.default_mgmt_key = -1;
+                }
+                /*
+                 * Applications using wireless extensions expect to be
+                 * able to delete keys that don't exist, so allow that.
+                 */
+                if (err == -ENOENT)
+                        return 0;
+
+                return err;
+        } else {
+                if (addr)
+                        tx_key = false;
+
+                if (cfg80211_validate_key_settings(params, idx, addr))
+                        return -EINVAL;
+
+                err = rdev->ops->add_key(&rdev->wiphy, dev, idx, addr, params);
+                if (err)
+                        return err;
+
+                if (tx_key || (!addr && wdev->wext.default_key == -1)) {
+                        err = rdev->ops->set_default_key(&rdev->wiphy,
+                                                         dev, idx);
+                        if (!err)
+                                wdev->wext.default_key = idx;
+                        return err;
+                }
+
+                if (params->cipher == WLAN_CIPHER_SUITE_AES_CMAC &&
+                    (tx_key || (!addr && wdev->wext.default_mgmt_key == -1))) {
+                        err = rdev->ops->set_default_mgmt_key(&rdev->wiphy,
+                                                              dev, idx);
+                        if (!err)
+                                wdev->wext.default_mgmt_key = idx;
+                        return err;
+                }
+
+                return 0;
+        }
+}
+
+int cfg80211_wext_siwencode(struct net_device *dev,
+                            struct iw_request_info *info,
+                            struct iw_point *erq, char *keybuf)
+{
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+        struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
+        int idx, err;
+        bool remove = false;
+        struct key_params params;
+
+        /* no use -- only MFP (set_default_mgmt_key) is optional */
+        if (!rdev->ops->del_key ||
+            !rdev->ops->add_key ||
+            !rdev->ops->set_default_key)
+                return -EOPNOTSUPP;
+
+        idx = erq->flags & IW_ENCODE_INDEX;
+        if (idx == 0) {
+                idx = wdev->wext.default_key;
+                if (idx < 0)
+                        idx = 0;
+        } else if (idx < 1 || idx > 4)
+                return -EINVAL;
+        else
+                idx--;
+
+        if (erq->flags & IW_ENCODE_DISABLED)
+                remove = true;
+        else if (erq->length == 0) {
+                /* No key data - just set the default TX key index */
+                err = rdev->ops->set_default_key(&rdev->wiphy, dev, idx);
+                if (!err)
+                        wdev->wext.default_key = idx;
+                return err;
+        }
+
+        memset(&params, 0, sizeof(params));
+        params.key = keybuf;
+        params.key_len = erq->length;
+        if (erq->length == 5)
+                params.cipher = WLAN_CIPHER_SUITE_WEP40;
+        else if (erq->length == 13)
+                params.cipher = WLAN_CIPHER_SUITE_WEP104;
+        else if (!remove)
+                return -EINVAL;
+
+        return cfg80211_set_encryption(rdev, dev, NULL, remove,
+                                       wdev->wext.default_key == -1,
+                                       idx, &params);
+}
+EXPORT_SYMBOL_GPL(cfg80211_wext_siwencode);
+
+int cfg80211_wext_siwencodeext(struct net_device *dev,
+                               struct iw_request_info *info,
+                               struct iw_point *erq, char *extra)
+{
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+        struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
+        struct iw_encode_ext *ext = (struct iw_encode_ext *) extra;
+        const u8 *addr;
+        int idx;
+        bool remove = false;
+        struct key_params params;
+        u32 cipher;
+
+        /* no use -- only MFP (set_default_mgmt_key) is optional */
+        if (!rdev->ops->del_key ||
+            !rdev->ops->add_key ||
+            !rdev->ops->set_default_key)
+                return -EOPNOTSUPP;
+
+        switch (ext->alg) {
+        case IW_ENCODE_ALG_NONE:
+                remove = true;
+                cipher = 0;
+                break;
+        case IW_ENCODE_ALG_WEP:
+                if (ext->key_len == 5)
+                        cipher = WLAN_CIPHER_SUITE_WEP40;
+                else if (ext->key_len == 13)
+                        cipher = WLAN_CIPHER_SUITE_WEP104;
+                else
+                        return -EINVAL;
+                break;
+        case IW_ENCODE_ALG_TKIP:
+                cipher = WLAN_CIPHER_SUITE_TKIP;
+                break;
+        case IW_ENCODE_ALG_CCMP:
+                cipher = WLAN_CIPHER_SUITE_CCMP;
+                break;
+        case IW_ENCODE_ALG_AES_CMAC:
+                cipher = WLAN_CIPHER_SUITE_AES_CMAC;
+                break;
+        default:
+                return -EOPNOTSUPP;
+        }
+
+        if (erq->flags & IW_ENCODE_DISABLED)
+                remove = true;
+
+        idx = erq->flags & IW_ENCODE_INDEX;
+        if (cipher == WLAN_CIPHER_SUITE_AES_CMAC) {
+                if (idx < 4 || idx > 5) {
+                        idx = wdev->wext.default_mgmt_key;
+                        if (idx < 0)
+                                return -EINVAL;
+                } else
+                        idx--;
+        } else {
+                if (idx < 1 || idx > 4) {
+                        idx = wdev->wext.default_key;
+                        if (idx < 0)
+                                return -EINVAL;
+                } else
+                        idx--;
+        }
+
+        addr = ext->addr.sa_data;
+        if (is_broadcast_ether_addr(addr))
+                addr = NULL;
+
+        memset(&params, 0, sizeof(params));
+        params.key = ext->key;
+        params.key_len = ext->key_len;
+        params.cipher = cipher;
+
+        if (ext->ext_flags & IW_ENCODE_EXT_RX_SEQ_VALID) {
+                params.seq = ext->rx_seq;
+                params.seq_len = 6;
+        }
+
+        return cfg80211_set_encryption(
+                        rdev, dev, addr, remove,
+                        ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY,
+                        idx, &params);
+}
+EXPORT_SYMBOL_GPL(cfg80211_wext_siwencodeext);
+
+struct giwencode_cookie {
+        size_t buflen;
+        char *keybuf;
+};
+
+static void giwencode_get_key_cb(void *cookie, struct key_params *params)
+{
+        struct giwencode_cookie *data = cookie;
+
+        if (!params->key) {
+                data->buflen = 0;
+                return;
+        }
+
+        data->buflen = min_t(size_t, data->buflen, params->key_len);
+        memcpy(data->keybuf, params->key, data->buflen);
+}
+
+int cfg80211_wext_giwencode(struct net_device *dev,
+                            struct iw_request_info *info,
+                            struct iw_point *erq, char *keybuf)
+{
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+        struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
+        int idx, err;
+        struct giwencode_cookie data = {
+                .keybuf = keybuf,
+                .buflen = erq->length,
+        };
+
+        if (!rdev->ops->get_key)
+                return -EOPNOTSUPP;
+
+        idx = erq->flags & IW_ENCODE_INDEX;
+        if (idx == 0) {
+                idx = wdev->wext.default_key;
+                if (idx < 0)
+                        idx = 0;
+        } else if (idx < 1 || idx > 4)
+                return -EINVAL;
+        else
+                idx--;
+
+        erq->flags = idx + 1;
+
+        err = rdev->ops->get_key(&rdev->wiphy, dev, idx, NULL, &data,
+                                 giwencode_get_key_cb);
+        if (!err) {
+                erq->length = data.buflen;
+                erq->flags |= IW_ENCODE_ENABLED;
+                return 0;
+        }
+
+        if (err == -ENOENT) {
+                erq->flags |= IW_ENCODE_DISABLED;
+                erq->length = 0;
+                return 0;
+        }
+
+        return err;
+}
+EXPORT_SYMBOL_GPL(cfg80211_wext_giwencode);
+
+int cfg80211_wext_siwtxpower(struct net_device *dev,
+                             struct iw_request_info *info,
+                             union iwreq_data *data, char *extra)
+{
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+        struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
+        enum tx_power_setting type;
+        int dbm = 0;
+
+        if ((data->txpower.flags & IW_TXPOW_TYPE) != IW_TXPOW_DBM)
+                return -EINVAL;
+        if (data->txpower.flags & IW_TXPOW_RANGE)
+                return -EINVAL;
+
+        if (!rdev->ops->set_tx_power)
+                return -EOPNOTSUPP;
+
+        /* only change when not disabling */
+        if (!data->txpower.disabled) {
+                rfkill_set_sw_state(rdev->rfkill, false);
+
+                if (data->txpower.fixed) {
+                        /*
+                         * wext doesn't support negative values, see
+                         * below where it's for automatic
+                         */
+                        if (data->txpower.value < 0)
+                                return -EINVAL;
+                        dbm = data->txpower.value;
+                        type = TX_POWER_FIXED;
+                        /* TODO: do regulatory check! */
+                } else {
+                        /*
+                         * Automatic power level setting, max being the value
+                         * passed in from userland.
+                         */
+                        if (data->txpower.value < 0) {
+                                type = TX_POWER_AUTOMATIC;
+                        } else {
+                                dbm = data->txpower.value;
+                                type = TX_POWER_LIMITED;
+                        }
+                }
+        } else {
+                rfkill_set_sw_state(rdev->rfkill, true);
+                schedule_work(&rdev->rfkill_sync);
+                return 0;
+        }
+
+        return rdev->ops->set_tx_power(wdev->wiphy, type, dbm);;
+}
+EXPORT_SYMBOL_GPL(cfg80211_wext_siwtxpower);
+
+int cfg80211_wext_giwtxpower(struct net_device *dev,
+                             struct iw_request_info *info,
+                             union iwreq_data *data, char *extra)
+{
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+        struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
+        int err, val;
+
+        if ((data->txpower.flags & IW_TXPOW_TYPE) != IW_TXPOW_DBM)
+                return -EINVAL;
+        if (data->txpower.flags & IW_TXPOW_RANGE)
+                return -EINVAL;
+
+        if (!rdev->ops->get_tx_power)
+                return -EOPNOTSUPP;
+
+        err = rdev->ops->get_tx_power(wdev->wiphy, &val);
+        if (err)
+                return err;
+
+        /* well... oh well */
+        data->txpower.fixed = 1;
+        data->txpower.disabled = rfkill_blocked(rdev->rfkill);
+        data->txpower.value = val;
+        data->txpower.flags = IW_TXPOW_DBM;
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(cfg80211_wext_giwtxpower);
diff --git a/net/wireless/wext.c b/net/wireless/wext.c
index 0e59f9ae9b81..252c2010c2e2 100644
--- a/net/wireless/wext.c
+++ b/net/wireless/wext.c
@@ -636,8 +636,10 @@ static void wireless_seq_printf_stats(struct seq_file *seq,
 /*
  * Print info for /proc/net/wireless (print all entries)
  */
-static int wireless_seq_show(struct seq_file *seq, void *v)
+static int wireless_dev_seq_show(struct seq_file *seq, void *v)
 {
+        might_sleep();
+
         if (v == SEQ_START_TOKEN)
                 seq_printf(seq, "Inter-| sta-|   Quality        |   Discarded "
                                 "packets               | Missed | WE\n"
@@ -649,14 +651,46 @@ static int wireless_seq_show(struct seq_file *seq, void *v)
         return 0;
 }
 
+static void *wireless_dev_seq_start(struct seq_file *seq, loff_t *pos)
+{
+        struct net *net = seq_file_net(seq);
+        loff_t off;
+        struct net_device *dev;
+
+        rtnl_lock();
+        if (!*pos)
+                return SEQ_START_TOKEN;
+
+        off = 1;
+        for_each_netdev(net, dev)
+                if (off++ == *pos)
+                        return dev;
+        return NULL;
+}
+
+static void *wireless_dev_seq_next(struct seq_file *seq, void *v, loff_t *pos)
+{
+        struct net *net = seq_file_net(seq);
+
+        ++*pos;
+
+        return v == SEQ_START_TOKEN ?
+                first_net_device(net) : next_net_device(v);
+}
+
+static void wireless_dev_seq_stop(struct seq_file *seq, void *v)
+{
+        rtnl_unlock();
+}
+
 static const struct seq_operations wireless_seq_ops = {
-        .start = dev_seq_start,
-        .next  = dev_seq_next,
-        .stop  = dev_seq_stop,
-        .show  = wireless_seq_show,
+        .start = wireless_dev_seq_start,
+        .next  = wireless_dev_seq_next,
+        .stop  = wireless_dev_seq_stop,
+        .show  = wireless_dev_seq_show,
 };
 
-static int wireless_seq_open(struct inode *inode, struct file *file)
+static int seq_open_wireless(struct inode *inode, struct file *file)
 {
         return seq_open_net(inode, file, &wireless_seq_ops,
                             sizeof(struct seq_net_private));
@@ -664,7 +698,7 @@ static int wireless_seq_open(struct inode *inode, struct file *file)
 
 static const struct file_operations wireless_seq_fops = {
         .owner   = THIS_MODULE,
-        .open    = wireless_seq_open,
+        .open    = seq_open_wireless,
         .read    = seq_read,
         .llseek  = seq_lseek,
         .release = seq_release_net,
diff --git a/net/xfrm/xfrm_algo.c b/net/xfrm/xfrm_algo.c
index 96036cf2216d..d31ccb487730 100644
--- a/net/xfrm/xfrm_algo.c
+++ b/net/xfrm/xfrm_algo.c
@@ -696,8 +696,9 @@ int skb_icv_walk(const struct sk_buff *skb, struct hash_desc *desc,
 {
         int start = skb_headlen(skb);
         int i, copy = start - offset;
-        int err;
+        struct sk_buff *frag_iter;
         struct scatterlist sg;
+        int err;
 
         /* Checksum header. */
         if (copy > 0) {
@@ -742,28 +743,24 @@ int skb_icv_walk(const struct sk_buff *skb, struct hash_desc *desc,
                 start = end;
         }
 
-        if (skb_shinfo(skb)->frag_list) {
-                struct sk_buff *list = skb_shinfo(skb)->frag_list;
-
-                for (; list; list = list->next) {
-                        int end;
-
-                        WARN_ON(start > offset + len);
-
-                        end = start + list->len;
-                        if ((copy = end - offset) > 0) {
-                                if (copy > len)
-                                        copy = len;
-                                err = skb_icv_walk(list, desc, offset-start,
-                                                   copy, icv_update);
-                                if (unlikely(err))
-                                        return err;
-                                if ((len -= copy) == 0)
-                                        return 0;
-                                offset += copy;
-                        }
-                        start = end;
+        skb_walk_frags(skb, frag_iter) {
+                int end;
+
+                WARN_ON(start > offset + len);
+
+                end = start + frag_iter->len;
+                if ((copy = end - offset) > 0) {
+                        if (copy > len)
+                                copy = len;
+                        err = skb_icv_walk(frag_iter, desc, offset-start,
+                                           copy, icv_update);
+                        if (unlikely(err))
+                                return err;
+                        if ((len -= copy) == 0)
+                                return 0;
+                        offset += copy;
                 }
+                start = end;
         }
         BUG_ON(len);
         return 0;
diff --git a/net/xfrm/xfrm_input.c b/net/xfrm/xfrm_input.c
index b4a13178fb40..e0009c17d809 100644
--- a/net/xfrm/xfrm_input.c
+++ b/net/xfrm/xfrm_input.c
@@ -251,8 +251,7 @@ resume:
         nf_reset(skb);
 
         if (decaps) {
-                dst_release(skb->dst);
-                skb->dst = NULL;
+                skb_dst_drop(skb);
                 netif_rx(skb);
                 return 0;
         } else {
diff --git a/net/xfrm/xfrm_output.c b/net/xfrm/xfrm_output.c
index c235597ba8dd..b9fe13138c07 100644
--- a/net/xfrm/xfrm_output.c
+++ b/net/xfrm/xfrm_output.c
@@ -22,7 +22,7 @@ static int xfrm_output2(struct sk_buff *skb);
 
 static int xfrm_state_check_space(struct xfrm_state *x, struct sk_buff *skb)
 {
-        struct dst_entry *dst = skb->dst;
+        struct dst_entry *dst = skb_dst(skb);
         int nhead = dst->header_len + LL_RESERVED_SPACE(dst->dev)
                 - skb_headroom(skb);
         int ntail = dst->dev->needed_tailroom - skb_tailroom(skb);
@@ -39,7 +39,7 @@ static int xfrm_state_check_space(struct xfrm_state *x, struct sk_buff *skb)
 
 static int xfrm_output_one(struct sk_buff *skb, int err)
 {
-        struct dst_entry *dst = skb->dst;
+        struct dst_entry *dst = skb_dst(skb);
         struct xfrm_state *x = dst->xfrm;
         struct net *net = xs_net(x);
 
@@ -94,12 +94,13 @@ resume:
                         goto error_nolock;
                 }
 
-                if (!(skb->dst = dst_pop(dst))) {
+                dst = dst_pop(dst);
+                if (!dst) {
                         XFRM_INC_STATS(net, LINUX_MIB_XFRMOUTERROR);
                         err = -EHOSTUNREACH;
                         goto error_nolock;
                 }
-                dst = skb->dst;
+                skb_dst_set(skb, dst);
                 x = dst->xfrm;
         } while (x && !(x->outer_mode->flags & XFRM_MODE_FLAG_TUNNEL));
 
@@ -119,16 +120,16 @@ int xfrm_output_resume(struct sk_buff *skb, int err)
         while (likely((err = xfrm_output_one(skb, err)) == 0)) {
                 nf_reset(skb);
 
-                err = skb->dst->ops->local_out(skb);
+                err = skb_dst(skb)->ops->local_out(skb);
                 if (unlikely(err != 1))
                         goto out;
 
-                if (!skb->dst->xfrm)
+                if (!skb_dst(skb)->xfrm)
                         return dst_output(skb);
 
-                err = nf_hook(skb->dst->ops->family,
+                err = nf_hook(skb_dst(skb)->ops->family,
                               NF_INET_POST_ROUTING, skb,
-                              NULL, skb->dst->dev, xfrm_output2);
+                              NULL, skb_dst(skb)->dev, xfrm_output2);
                 if (unlikely(err != 1))
                         goto out;
         }
@@ -179,7 +180,7 @@ static int xfrm_output_gso(struct sk_buff *skb)
 
 int xfrm_output(struct sk_buff *skb)
 {
-        struct net *net = dev_net(skb->dst->dev);
+        struct net *net = dev_net(skb_dst(skb)->dev);
         int err;
 
         if (skb_is_gso(skb))
@@ -202,7 +203,7 @@ int xfrm_inner_extract_output(struct xfrm_state *x, struct sk_buff *skb)
         struct xfrm_mode *inner_mode;
         if (x->sel.family == AF_UNSPEC)
                 inner_mode = xfrm_ip2inner_mode(x,
-                                xfrm_af2proto(skb->dst->ops->family));
+                                xfrm_af2proto(skb_dst(skb)->ops->family));
         else
                 inner_mode = x->inner_mode;
 
diff --git a/net/xfrm/xfrm_policy.c b/net/xfrm/xfrm_policy.c
index 9c068ab3a834..cb81ca35b0d6 100644
--- a/net/xfrm/xfrm_policy.c
+++ b/net/xfrm/xfrm_policy.c
@@ -2027,6 +2027,8 @@ int __xfrm_route_forward(struct sk_buff *skb, unsigned short family)
 {
         struct net *net = dev_net(skb->dev);
         struct flowi fl;
+        struct dst_entry *dst;
+        int res;
 
         if (xfrm_decode_session(skb, &fl, family) < 0) {
                 /* XXX: we should have something like FWDHDRERROR here. */
@@ -2034,7 +2036,11 @@ int __xfrm_route_forward(struct sk_buff *skb, unsigned short family)
                 return 0;
         }
 
-        return xfrm_lookup(net, &skb->dst, &fl, NULL, 0) == 0;
+        dst = skb_dst(skb);
+
+        res = xfrm_lookup(net, &dst, &fl, NULL, 0) == 0;
+        skb_dst_set(skb, dst);
+        return res;
 }
 EXPORT_SYMBOL(__xfrm_route_forward);