Merge branch 'master' of /pub/scm/linux/kernel/git/torvalds/linux-2.6

82 files changed, 508 insertions, 346 deletions

diff --git a/net/8021q/vlanproc.c b/net/8021q/vlanproc.c
index daad0064e2c2..08b54b593d56 100644
--- a/net/8021q/vlanproc.c
+++ b/net/8021q/vlanproc.c
@@ -176,12 +176,11 @@ int vlan_proc_add_dev(struct net_device *vlandev)
         struct vlan_dev_info *dev_info = vlan_dev_info(vlandev);
         struct vlan_net *vn = net_generic(dev_net(vlandev), vlan_net_id);
 
-        dev_info->dent = proc_create(vlandev->name, S_IFREG|S_IRUSR|S_IWUSR,
-                                     vn->proc_vlan_dir, &vlandev_fops);
+        dev_info->dent =
+                proc_create_data(vlandev->name, S_IFREG|S_IRUSR|S_IWUSR,
+                                 vn->proc_vlan_dir, &vlandev_fops, vlandev);
         if (!dev_info->dent)
                 return -ENOBUFS;
-
-        dev_info->dent->data = vlandev;
         return 0;
 }
 
diff --git a/net/atm/proc.c b/net/atm/proc.c
index 5c9f3d148135..49487b313f22 100644
--- a/net/atm/proc.c
+++ b/net/atm/proc.c
@@ -417,12 +417,10 @@ int atm_proc_dev_register(struct atm_dev *dev)
                 goto err_out;
         sprintf(dev->proc_name,"%s:%d",dev->type, dev->number);
 
-        dev->proc_entry = proc_create(dev->proc_name, 0, atm_proc_root,
-                                      &proc_atm_dev_ops);
+        dev->proc_entry = proc_create_data(dev->proc_name, 0, atm_proc_root,
+                                           &proc_atm_dev_ops, dev);
         if (!dev->proc_entry)
                 goto err_free_name;
-        dev->proc_entry->data = dev;
-        dev->proc_entry->owner = THIS_MODULE;
         return 0;
 err_free_name:
         kfree(dev->proc_name);
diff --git a/net/bluetooth/bnep/core.c b/net/bluetooth/bnep/core.c
index 347e935faaf0..f85d94643aaf 100644
--- a/net/bluetooth/bnep/core.c
+++ b/net/bluetooth/bnep/core.c
@@ -135,7 +135,7 @@ static int bnep_ctrl_set_netfilter(struct bnep_session *s, __be16 *data, int len
         if (len < 2)
                 return -EILSEQ;
 
-        n = ntohs(get_unaligned(data));
+        n = get_unaligned_be16(data);
         data++; len -= 2;
 
         if (len < n)
@@ -150,8 +150,8 @@ static int bnep_ctrl_set_netfilter(struct bnep_session *s, __be16 *data, int len
                 int i;
 
                 for (i = 0; i < n; i++) {
-                        f[i].start = ntohs(get_unaligned(data++));
-                        f[i].end   = ntohs(get_unaligned(data++));
+                        f[i].start = get_unaligned_be16(data++);
+                        f[i].end   = get_unaligned_be16(data++);
 
                         BT_DBG("proto filter start %d end %d",
                                 f[i].start, f[i].end);
@@ -180,7 +180,7 @@ static int bnep_ctrl_set_mcfilter(struct bnep_session *s, u8 *data, int len)
         if (len < 2)
                 return -EILSEQ;
 
-        n = ntohs(get_unaligned((__be16 *) data));
+        n = get_unaligned_be16(data);
         data += 2; len -= 2;
 
         if (len < n)
diff --git a/net/bluetooth/hci_event.c b/net/bluetooth/hci_event.c
index 46df2e403df8..6aef8f24e581 100644
--- a/net/bluetooth/hci_event.c
+++ b/net/bluetooth/hci_event.c
@@ -129,8 +129,7 @@ static void hci_cc_write_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
 
         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
         if (conn) {
-                __le16 policy = get_unaligned((__le16 *) (sent + 2));
-                conn->link_policy = __le16_to_cpu(policy);
+                conn->link_policy = get_unaligned_le16(sent + 2);
         }
 
         hci_dev_unlock(hdev);
@@ -313,7 +312,7 @@ static void hci_cc_write_voice_setting(struct hci_dev *hdev, struct sk_buff *skb
                 return;
 
         if (!status) {
-                __u16 setting = __le16_to_cpu(get_unaligned((__le16 *) sent));
+                __u16 setting = get_unaligned_le16(sent);
 
                 if (hdev->voice_setting != setting) {
                         hdev->voice_setting = setting;
@@ -1152,8 +1151,8 @@ static inline void hci_num_comp_pkts_evt(struct hci_dev *hdev, struct sk_buff *s
                 struct hci_conn *conn;
                 __u16  handle, count;
 
-                handle = __le16_to_cpu(get_unaligned(ptr++));
-                count  = __le16_to_cpu(get_unaligned(ptr++));
+                handle = get_unaligned_le16(ptr++);
+                count  = get_unaligned_le16(ptr++);
 
                 conn = hci_conn_hash_lookup_handle(hdev, handle);
                 if (conn) {
diff --git a/net/bluetooth/hci_sock.c b/net/bluetooth/hci_sock.c
index 1d36c093523b..747fabd735d2 100644
--- a/net/bluetooth/hci_sock.c
+++ b/net/bluetooth/hci_sock.c
@@ -440,7 +440,7 @@ static int hci_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
         skb->dev = (void *) hdev;
 
         if (bt_cb(skb)->pkt_type == HCI_COMMAND_PKT) {
-                u16 opcode = __le16_to_cpu(get_unaligned((__le16 *) skb->data));
+                u16 opcode = get_unaligned_le16(skb->data);
                 u16 ogf = hci_opcode_ogf(opcode);
                 u16 ocf = hci_opcode_ocf(opcode);
 
diff --git a/net/bluetooth/l2cap.c b/net/bluetooth/l2cap.c
index a4849f2c1d81..6e180d255505 100644
--- a/net/bluetooth/l2cap.c
+++ b/net/bluetooth/l2cap.c
@@ -1827,7 +1827,7 @@ static inline int l2cap_information_rsp(struct l2cap_conn *conn, struct l2cap_cm
         del_timer(&conn->info_timer);
 
         if (type == L2CAP_IT_FEAT_MASK)
-                conn->feat_mask = __le32_to_cpu(get_unaligned((__le32 *) rsp->data));
+                conn->feat_mask = get_unaligned_le32(rsp->data);
 
         l2cap_conn_start(conn);
 
diff --git a/net/bridge/br.c b/net/bridge/br.c
index a90182873120..8f3c58e5f7a5 100644
--- a/net/bridge/br.c
+++ b/net/bridge/br.c
@@ -76,7 +76,6 @@ static void __exit br_deinit(void)
         rcu_assign_pointer(br_stp_sap->rcv_func, NULL);
 
         br_netlink_fini();
-        br_netfilter_fini();
         unregister_netdevice_notifier(&br_device_notifier);
         brioctl_set(NULL);
 
@@ -84,6 +83,7 @@ static void __exit br_deinit(void)
 
         synchronize_net();
 
+        br_netfilter_fini();
         llc_sap_put(br_stp_sap);
         br_fdb_get_hook = NULL;
         br_fdb_put_hook = NULL;
diff --git a/net/bridge/br_fdb.c b/net/bridge/br_fdb.c
index 9326c377822e..72c5976a5ce3 100644
--- a/net/bridge/br_fdb.c
+++ b/net/bridge/br_fdb.c
@@ -285,7 +285,11 @@ int br_fdb_fillbuf(struct net_bridge *br, void *buf,
 
                         /* convert from internal format to API */
                         memcpy(fe->mac_addr, f->addr.addr, ETH_ALEN);
+
+                        /* due to ABI compat need to split into hi/lo */
                         fe->port_no = f->dst->port_no;
+                        fe->port_hi = f->dst->port_no >> 8;
+
                         fe->is_local = f->is_local;
                         if (!f->is_static)
                                 fe->ageing_timer_value = jiffies_to_clock_t(jiffies - f->ageing_timer);
diff --git a/net/bridge/br_if.c b/net/bridge/br_if.c
index 298e0f463c56..77a981a1ee52 100644
--- a/net/bridge/br_if.c
+++ b/net/bridge/br_if.c
@@ -411,9 +411,12 @@ err2:
         br_fdb_delete_by_port(br, p, 1);
 err1:
         kobject_del(&p->kobj);
-        return err;
+        goto put_back;
 err0:
         kobject_put(&p->kobj);
+
+put_back:
+        dev_put(dev);
         return err;
 }
 
diff --git a/net/bridge/br_stp_bpdu.c b/net/bridge/br_stp_bpdu.c
index 8deab645ef75..ddeb6e5d45d6 100644
--- a/net/bridge/br_stp_bpdu.c
+++ b/net/bridge/br_stp_bpdu.c
@@ -58,12 +58,12 @@ static inline void br_set_ticks(unsigned char *dest, int j)
 {
         unsigned long ticks = (STP_HZ * j)/ HZ;
 
-        put_unaligned(htons(ticks), (__be16 *)dest);
+        put_unaligned_be16(ticks, dest);
 }
 
 static inline int br_get_ticks(const unsigned char *src)
 {
-        unsigned long ticks = ntohs(get_unaligned((__be16 *)src));
+        unsigned long ticks = get_unaligned_be16(src);
 
         return DIV_ROUND_UP(ticks * HZ, STP_HZ);
 }
diff --git a/net/can/bcm.c b/net/can/bcm.c
index 74fd2d33aff4..d9a3a9d13bed 100644
--- a/net/can/bcm.c
+++ b/net/can/bcm.c
@@ -412,12 +412,6 @@ static void bcm_rx_changed(struct bcm_op *op, struct can_frame *data)
         bcm_send_to_user(op, &head, data, 1);
 }
 
-/* TODO: move to linux/hrtimer.h */
-static inline int hrtimer_callback_running(struct hrtimer *timer)
-{
-        return timer->state & HRTIMER_STATE_CALLBACK;
-}
-
 /*
  * bcm_rx_update_and_send - process a detected relevant receive content change
  *                          1. update the last received data
diff --git a/net/compat.c b/net/compat.c
index 01bf95d0832e..c823f6f290cb 100644
--- a/net/compat.c
+++ b/net/compat.c
@@ -548,6 +548,9 @@ struct compat_group_filter {
                 __attribute__ ((aligned(4)));
 } __attribute__ ((packed));
 
+#define __COMPAT_GF0_SIZE (sizeof(struct compat_group_filter) - \
+                        sizeof(struct __kernel_sockaddr_storage))
+
 
 int compat_mc_setsockopt(struct sock *sock, int level, int optname,
         char __user *optval, int optlen,
@@ -582,7 +585,7 @@ int compat_mc_setsockopt(struct sock *sock, int level, int optname,
         case MCAST_UNBLOCK_SOURCE:
         {
                 struct compat_group_source_req __user *gsr32 = (void *)optval;
-                struct group_source_req *kgsr = compat_alloc_user_space(
+                struct group_source_req __user *kgsr = compat_alloc_user_space(
                         sizeof(struct group_source_req));
                 u32 interface;
 
@@ -603,10 +606,10 @@ int compat_mc_setsockopt(struct sock *sock, int level, int optname,
         case MCAST_MSFILTER:
         {
                 struct compat_group_filter __user *gf32 = (void *)optval;
-                struct group_filter *kgf;
+                struct group_filter __user *kgf;
                 u32 interface, fmode, numsrc;
 
-                if (!access_ok(VERIFY_READ, gf32, sizeof(*gf32)) ||
+                if (!access_ok(VERIFY_READ, gf32, __COMPAT_GF0_SIZE) ||
                     __get_user(interface, &gf32->gf_interface) ||
                     __get_user(fmode, &gf32->gf_fmode) ||
                     __get_user(numsrc, &gf32->gf_numsrc))
@@ -622,7 +625,7 @@ int compat_mc_setsockopt(struct sock *sock, int level, int optname,
                     __put_user(numsrc, &kgf->gf_numsrc) ||
                     copy_in_user(&kgf->gf_group, &gf32->gf_group,
                                 sizeof(kgf->gf_group)) ||
-                    (numsrc && copy_in_user(&kgf->gf_slist, &gf32->gf_slist,
+                    (numsrc && copy_in_user(kgf->gf_slist, gf32->gf_slist,
                                 numsrc * sizeof(kgf->gf_slist[0]))))
                         return -EFAULT;
                 koptval = (char __user *)kgf;
@@ -637,6 +640,85 @@ int compat_mc_setsockopt(struct sock *sock, int level, int optname,
 
 EXPORT_SYMBOL(compat_mc_setsockopt);
 
+int compat_mc_getsockopt(struct sock *sock, int level, int optname,
+        char __user *optval, int __user *optlen,
+        int (*getsockopt)(struct sock *,int,int,char __user *,int __user *))
+{
+        struct compat_group_filter __user *gf32 = (void *)optval;
+        struct group_filter __user *kgf;
+        int __user      *koptlen;
+        u32 interface, fmode, numsrc;
+        int klen, ulen, err;
+
+        if (optname != MCAST_MSFILTER)
+                return getsockopt(sock, level, optname, optval, optlen);
+
+        koptlen = compat_alloc_user_space(sizeof(*koptlen));
+        if (!access_ok(VERIFY_READ, optlen, sizeof(*optlen)) ||
+            __get_user(ulen, optlen))
+                return -EFAULT;
+
+        /* adjust len for pad */
+        klen = ulen + sizeof(*kgf) - sizeof(*gf32);
+
+        if (klen < GROUP_FILTER_SIZE(0))
+                return -EINVAL;
+
+        if (!access_ok(VERIFY_WRITE, koptlen, sizeof(*koptlen)) ||
+            __put_user(klen, koptlen))
+                return -EFAULT;
+
+        /* have to allow space for previous compat_alloc_user_space, too */
+        kgf = compat_alloc_user_space(klen+sizeof(*optlen));
+
+        if (!access_ok(VERIFY_READ, gf32, __COMPAT_GF0_SIZE) ||
+            __get_user(interface, &gf32->gf_interface) ||
+            __get_user(fmode, &gf32->gf_fmode) ||
+            __get_user(numsrc, &gf32->gf_numsrc) ||
+            __put_user(interface, &kgf->gf_interface) ||
+            __put_user(fmode, &kgf->gf_fmode) ||
+            __put_user(numsrc, &kgf->gf_numsrc) ||
+            copy_in_user(&kgf->gf_group,&gf32->gf_group,sizeof(kgf->gf_group)))
+                return -EFAULT;
+
+        err = getsockopt(sock, level, optname, (char __user *)kgf, koptlen);
+        if (err)
+                return err;
+
+        if (!access_ok(VERIFY_READ, koptlen, sizeof(*koptlen)) ||
+            __get_user(klen, koptlen))
+                return -EFAULT;
+
+        ulen = klen - (sizeof(*kgf)-sizeof(*gf32));
+
+        if (!access_ok(VERIFY_WRITE, optlen, sizeof(*optlen)) ||
+            __put_user(ulen, optlen))
+                return -EFAULT;
+
+        if (!access_ok(VERIFY_READ, kgf, klen) ||
+            !access_ok(VERIFY_WRITE, gf32, ulen) ||
+            __get_user(interface, &kgf->gf_interface) ||
+            __get_user(fmode, &kgf->gf_fmode) ||
+            __get_user(numsrc, &kgf->gf_numsrc) ||
+            __put_user(interface, &gf32->gf_interface) ||
+            __put_user(fmode, &gf32->gf_fmode) ||
+            __put_user(numsrc, &gf32->gf_numsrc))
+                return -EFAULT;
+        if (numsrc) {
+                int copylen;
+
+                klen -= GROUP_FILTER_SIZE(0);
+                copylen = numsrc * sizeof(gf32->gf_slist[0]);
+                if (copylen > klen)
+                        copylen = klen;
+                if (copy_in_user(gf32->gf_slist, kgf->gf_slist, copylen))
+                        return -EFAULT;
+        }
+        return err;
+}
+
+EXPORT_SYMBOL(compat_mc_getsockopt);
+
 
 /* Argument list sizes for compat_sys_socketcall */
 #define AL(x) ((x) * sizeof(u32))
diff --git a/net/core/dev.c b/net/core/dev.c
index e1df1ab3e04a..d334446a8eaf 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -162,7 +162,7 @@ struct net_dma {
         struct dma_client client;
         spinlock_t lock;
         cpumask_t channel_mask;
-        struct dma_chan *channels[NR_CPUS];
+        struct dma_chan **channels;
 };
 
 static enum dma_state_client
@@ -1524,7 +1524,7 @@ static int dev_gso_segment(struct sk_buff *skb)
         if (!segs)
                 return 0;
 
-        if (unlikely(IS_ERR(segs)))
+        if (IS_ERR(segs))
                 return PTR_ERR(segs);
 
         skb->next = segs;
@@ -2444,7 +2444,7 @@ static struct netif_rx_stats *softnet_get_online(loff_t *pos)
 {
         struct netif_rx_stats *rc = NULL;
 
-        while (*pos < NR_CPUS)
+        while (*pos < nr_cpu_ids)
                 if (cpu_online(*pos)) {
                         rc = &per_cpu(netdev_rx_stat, *pos);
                         break;
@@ -3776,6 +3776,7 @@ int register_netdevice(struct net_device *dev)
                 }
         }
 
+        netdev_initialize_kobject(dev);
         ret = netdev_register_kobject(dev);
         if (ret)
                 goto err_uninit;
@@ -4208,7 +4209,8 @@ int dev_change_net_namespace(struct net_device *dev, struct net *net, const char
         }
 
         /* Fixup kobjects */
-        err = device_rename(&dev->dev, dev->name);
+        netdev_unregister_kobject(dev);
+        err = netdev_register_kobject(dev);
         WARN_ON(err);
 
         /* Add the device back in the hashes */
@@ -4324,7 +4326,7 @@ netdev_dma_event(struct dma_client *client, struct dma_chan *chan,
         spin_lock(&net_dma->lock);
         switch (state) {
         case DMA_RESOURCE_AVAILABLE:
-                for (i = 0; i < NR_CPUS; i++)
+                for (i = 0; i < nr_cpu_ids; i++)
                         if (net_dma->channels[i] == chan) {
                                 found = 1;
                                 break;
@@ -4339,7 +4341,7 @@ netdev_dma_event(struct dma_client *client, struct dma_chan *chan,
                 }
                 break;
         case DMA_RESOURCE_REMOVED:
-                for (i = 0; i < NR_CPUS; i++)
+                for (i = 0; i < nr_cpu_ids; i++)
                         if (net_dma->channels[i] == chan) {
                                 found = 1;
                                 pos = i;
@@ -4366,6 +4368,13 @@ netdev_dma_event(struct dma_client *client, struct dma_chan *chan,
  */
 static int __init netdev_dma_register(void)
 {
+        net_dma.channels = kzalloc(nr_cpu_ids * sizeof(struct net_dma),
+                                                                GFP_KERNEL);
+        if (unlikely(!net_dma.channels)) {
+                printk(KERN_NOTICE
+                                "netdev_dma: no memory for net_dma.channels\n");
+                return -ENOMEM;
+        }
         spin_lock_init(&net_dma.lock);
         dma_cap_set(DMA_MEMCPY, net_dma.client.cap_mask);
         dma_async_client_register(&net_dma.client);
diff --git a/net/core/filter.c b/net/core/filter.c
index f5f3cf603064..4f8369729a4e 100644
--- a/net/core/filter.c
+++ b/net/core/filter.c
@@ -213,7 +213,7 @@ unsigned int sk_run_filter(struct sk_buff *skb, struct sock_filter *filter, int
 load_w:
                         ptr = load_pointer(skb, k, 4, &tmp);
                         if (ptr != NULL) {
-                                A = ntohl(get_unaligned((__be32 *)ptr));
+                                A = get_unaligned_be32(ptr);
                                 continue;
                         }
                         break;
@@ -222,7 +222,7 @@ load_w:
 load_h:
                         ptr = load_pointer(skb, k, 2, &tmp);
                         if (ptr != NULL) {
-                                A = ntohs(get_unaligned((__be16 *)ptr));
+                                A = get_unaligned_be16(ptr);
                                 continue;
                         }
                         break;
diff --git a/net/core/neighbour.c b/net/core/neighbour.c
index 75075c303c44..5d9d7130bd6e 100644
--- a/net/core/neighbour.c
+++ b/net/core/neighbour.c
@@ -1430,11 +1430,10 @@ void neigh_table_init_no_netlink(struct neigh_table *tbl)
                 panic("cannot create neighbour cache statistics");
 
 #ifdef CONFIG_PROC_FS
-        tbl->pde = proc_create(tbl->id, 0, init_net.proc_net_stat,
-                               &neigh_stat_seq_fops);
+        tbl->pde = proc_create_data(tbl->id, 0, init_net.proc_net_stat,
+                                    &neigh_stat_seq_fops, tbl);
         if (!tbl->pde)
                 panic("cannot create neighbour proc dir entry");
-        tbl->pde->data = tbl;
 #endif
 
         tbl->hash_mask = 1;
diff --git a/net/core/net-sysfs.c b/net/core/net-sysfs.c
index 4e7b847347f7..90e2177af081 100644
--- a/net/core/net-sysfs.c
+++ b/net/core/net-sysfs.c
@@ -449,7 +449,6 @@ int netdev_register_kobject(struct net_device *net)
         struct device *dev = &(net->dev);
         struct attribute_group **groups = net->sysfs_groups;
 
-        device_initialize(dev);
         dev->class = &net_class;
         dev->platform_data = net;
         dev->groups = groups;
@@ -470,6 +469,12 @@ int netdev_register_kobject(struct net_device *net)
         return device_add(dev);
 }
 
+void netdev_initialize_kobject(struct net_device *net)
+{
+        struct device *device = &(net->dev);
+        device_initialize(device);
+}
+
 int netdev_kobject_init(void)
 {
         return class_register(&net_class);
diff --git a/net/core/net-sysfs.h b/net/core/net-sysfs.h
index f5f108db3924..14e7524260b3 100644
--- a/net/core/net-sysfs.h
+++ b/net/core/net-sysfs.h
@@ -4,5 +4,5 @@
 int netdev_kobject_init(void);
 int netdev_register_kobject(struct net_device *);
 void netdev_unregister_kobject(struct net_device *);
-
+void netdev_initialize_kobject(struct net_device *);
 #endif
diff --git a/net/core/pktgen.c b/net/core/pktgen.c
index a803b442234c..8dca21110493 100644
--- a/net/core/pktgen.c
+++ b/net/core/pktgen.c
@@ -3570,15 +3570,14 @@ static int pktgen_add_device(struct pktgen_thread *t, const char *ifname)
         if (err)
                 goto out1;
 
-        pkt_dev->entry = proc_create(ifname, 0600,
-                                     pg_proc_dir, &pktgen_if_fops);
+        pkt_dev->entry = proc_create_data(ifname, 0600, pg_proc_dir,
+                                          &pktgen_if_fops, pkt_dev);
         if (!pkt_dev->entry) {
                 printk(KERN_ERR "pktgen: cannot create %s/%s procfs entry.\n",
                        PG_PROC_DIR, ifname);
                 err = -EINVAL;
                 goto out2;
         }
-        pkt_dev->entry->data = pkt_dev;
 #ifdef CONFIG_XFRM
         pkt_dev->ipsmode = XFRM_MODE_TRANSPORT;
         pkt_dev->ipsproto = IPPROTO_ESP;
@@ -3628,7 +3627,8 @@ static int __init pktgen_create_thread(int cpu)
         kthread_bind(p, cpu);
         t->tsk = p;
 
-        pe = proc_create(t->tsk->comm, 0600, pg_proc_dir, &pktgen_thread_fops);
+        pe = proc_create_data(t->tsk->comm, 0600, pg_proc_dir,
+                              &pktgen_thread_fops, t);
         if (!pe) {
                 printk(KERN_ERR "pktgen: cannot create %s/%s procfs entry.\n",
                        PG_PROC_DIR, t->tsk->comm);
@@ -3638,8 +3638,6 @@ static int __init pktgen_create_thread(int cpu)
                 return -EINVAL;
         }
 
-        pe->data = t;
-
         wake_up_process(p);
 
         return 0;
@@ -3716,8 +3714,6 @@ static int __init pg_init(void)
                 return -EINVAL;
         }
 
-        pe->data = NULL;
-
         /* Register us to receive netdevice events */
         register_netdevice_notifier(&pktgen_notifier_block);
 
diff --git a/net/core/sock.c b/net/core/sock.c
index 5dbb81bc9673..fa76f04fa9c6 100644
--- a/net/core/sock.c
+++ b/net/core/sock.c
@@ -228,11 +228,12 @@ static int sock_set_timeout(long *timeo_p, char __user *optval, int optlen)
                 static int warned __read_mostly;
 
                 *timeo_p = 0;
-                if (warned < 10 && net_ratelimit())
+                if (warned < 10 && net_ratelimit()) {
                         warned++;
                         printk(KERN_INFO "sock_set_timeout: `%s' (pid %d) "
                                "tries to set negative timeout\n",
                                 current->comm, task_pid_nr(current));
+                }
                 return 0;
         }
         *timeo_p = MAX_SCHEDULE_TIMEOUT;
diff --git a/net/dccp/ccids/ccid2.c b/net/dccp/ccids/ccid2.c
index b5b52ebb2693..8e9580874216 100644
--- a/net/dccp/ccids/ccid2.c
+++ b/net/dccp/ccids/ccid2.c
@@ -716,7 +716,7 @@ static int ccid2_hc_tx_init(struct ccid *ccid, struct sock *sk)
          * packets for new connections, following the rules from [RFC3390]".
          * We need to convert the bytes of RFC3390 into the packets of RFC 4341.
          */
-        hctx->ccid2hctx_cwnd = min(4U, max(2U, 4380U / dp->dccps_mss_cache));
+        hctx->ccid2hctx_cwnd = clamp(4380U / dp->dccps_mss_cache, 2U, 4U);
 
         /* Make sure that Ack Ratio is enabled and within bounds. */
         max_ratio = DIV_ROUND_UP(hctx->ccid2hctx_cwnd, 2);
diff --git a/net/dccp/ccids/ccid3.c b/net/dccp/ccids/ccid3.c
index e76f460af0ea..cd61dea2eea1 100644
--- a/net/dccp/ccids/ccid3.c
+++ b/net/dccp/ccids/ccid3.c
@@ -88,8 +88,8 @@ static void ccid3_hc_tx_set_state(struct sock *sk,
 static inline u64 rfc3390_initial_rate(struct sock *sk)
 {
         const struct ccid3_hc_tx_sock *hctx = ccid3_hc_tx_sk(sk);
-        const __u32 w_init = min_t(__u32, 4 * hctx->ccid3hctx_s,
-                                   max_t(__u32, 2 * hctx->ccid3hctx_s, 4380));
+        const __u32 w_init = clamp_t(__u32, 4380U,
+                        2 * hctx->ccid3hctx_s, 4 * hctx->ccid3hctx_s);
 
         return scaled_div(w_init << 6, hctx->ccid3hctx_rtt);
 }
diff --git a/net/ipv4/af_inet.c b/net/ipv4/af_inet.c
index f2b5270efdaa..24eca23c2db3 100644
--- a/net/ipv4/af_inet.c
+++ b/net/ipv4/af_inet.c
@@ -1234,7 +1234,7 @@ static struct sk_buff *inet_gso_segment(struct sk_buff *skb, int features)
                 segs = ops->gso_segment(skb, features);
         rcu_read_unlock();
 
-        if (!segs || unlikely(IS_ERR(segs)))
+        if (!segs || IS_ERR(segs))
                 goto out;
 
         skb = segs;
diff --git a/net/ipv4/cipso_ipv4.c b/net/ipv4/cipso_ipv4.c
index 4637ded3dba8..05afb576d935 100644
--- a/net/ipv4/cipso_ipv4.c
+++ b/net/ipv4/cipso_ipv4.c
@@ -983,7 +983,7 @@ static int cipso_v4_map_cat_enum_valid(const struct cipso_v4_doi *doi_def,
                 return -EFAULT;
 
         for (iter = 0; iter < enumcat_len; iter += 2) {
-                cat = ntohs(get_unaligned((__be16 *)&enumcat[iter]));
+                cat = get_unaligned_be16(&enumcat[iter]);
                 if (cat <= cat_prev)
                         return -EFAULT;
                 cat_prev = cat;
@@ -1052,7 +1052,7 @@ static int cipso_v4_map_cat_enum_ntoh(const struct cipso_v4_doi *doi_def,
 
         for (iter = 0; iter < net_cat_len; iter += 2) {
                 ret_val = netlbl_secattr_catmap_setbit(secattr->attr.mls.cat,
-                                ntohs(get_unaligned((__be16 *)&net_cat[iter])),
+                                get_unaligned_be16(&net_cat[iter]),
                                 GFP_ATOMIC);
                 if (ret_val != 0)
                         return ret_val;
@@ -1086,10 +1086,9 @@ static int cipso_v4_map_cat_rng_valid(const struct cipso_v4_doi *doi_def,
                 return -EFAULT;
 
         for (iter = 0; iter < rngcat_len; iter += 4) {
-                cat_high = ntohs(get_unaligned((__be16 *)&rngcat[iter]));
+                cat_high = get_unaligned_be16(&rngcat[iter]);
                 if ((iter + 4) <= rngcat_len)
-                        cat_low = ntohs(
-                                get_unaligned((__be16 *)&rngcat[iter + 2]));
+                        cat_low = get_unaligned_be16(&rngcat[iter + 2]);
                 else
                         cat_low = 0;
 
@@ -1188,10 +1187,9 @@ static int cipso_v4_map_cat_rng_ntoh(const struct cipso_v4_doi *doi_def,
         u16 cat_high;
 
         for (net_iter = 0; net_iter < net_cat_len; net_iter += 4) {
-                cat_high = ntohs(get_unaligned((__be16 *)&net_cat[net_iter]));
+                cat_high = get_unaligned_be16(&net_cat[net_iter]);
                 if ((net_iter + 4) <= net_cat_len)
-                        cat_low = ntohs(
-                              get_unaligned((__be16 *)&net_cat[net_iter + 2]));
+                        cat_low = get_unaligned_be16(&net_cat[net_iter + 2]);
                 else
                         cat_low = 0;
 
@@ -1562,7 +1560,7 @@ int cipso_v4_validate(unsigned char **option)
         }
 
         rcu_read_lock();
-        doi_def = cipso_v4_doi_search(ntohl(get_unaligned((__be32 *)&opt[2])));
+        doi_def = cipso_v4_doi_search(get_unaligned_be32(&opt[2]));
         if (doi_def == NULL) {
                 err_offset = 2;
                 goto validate_return_locked;
@@ -1843,7 +1841,7 @@ static int cipso_v4_getattr(const unsigned char *cipso,
         if (cipso_v4_cache_check(cipso, cipso[1], secattr) == 0)
                 return 0;
 
-        doi = ntohl(get_unaligned((__be32 *)&cipso[2]));
+        doi = get_unaligned_be32(&cipso[2]);
         rcu_read_lock();
         doi_def = cipso_v4_doi_search(doi);
         if (doi_def == NULL)
diff --git a/net/ipv4/icmp.c b/net/ipv4/icmp.c
index c67d00e8c600..87397351ddac 100644
--- a/net/ipv4/icmp.c
+++ b/net/ipv4/icmp.c
@@ -691,7 +691,8 @@ static void icmp_unreach(struct sk_buff *skb)
                                                NIPQUAD(iph->daddr));
                         } else {
                                 info = ip_rt_frag_needed(net, iph,
-                                                     ntohs(icmph->un.frag.mtu));
+                                                         ntohs(icmph->un.frag.mtu),
+                                                         skb->dev);
                                 if (!info)
                                         goto out;
                         }
diff --git a/net/ipv4/ip_output.c b/net/ipv4/ip_output.c
index 08349267ceb4..e527628f56cf 100644
--- a/net/ipv4/ip_output.c
+++ b/net/ipv4/ip_output.c
@@ -753,23 +753,15 @@ static inline int ip_ufo_append_data(struct sock *sk,
                 skb->ip_summed = CHECKSUM_PARTIAL;
                 skb->csum = 0;
                 sk->sk_sndmsg_off = 0;
-        }
 
-        err = skb_append_datato_frags(sk,skb, getfrag, from,
-                               (length - transhdrlen));
-        if (!err) {
-                /* specify the length of each IP datagram fragment*/
+                /* specify the length of each IP datagram fragment */
                 skb_shinfo(skb)->gso_size = mtu - fragheaderlen;
                 skb_shinfo(skb)->gso_type = SKB_GSO_UDP;
                 __skb_queue_tail(&sk->sk_write_queue, skb);
-
-                return 0;
         }
-        /* There is not enough support do UFO ,
-         * so follow normal path
-         */
-        kfree_skb(skb);
-        return err;
+
+        return skb_append_datato_frags(sk, skb, getfrag, from,
+                                       (length - transhdrlen));
 }
 
 /*
@@ -863,9 +855,9 @@ int ip_append_data(struct sock *sk,
                 csummode = CHECKSUM_PARTIAL;
 
         inet->cork.length += length;
-        if (((length > mtu) && (sk->sk_protocol == IPPROTO_UDP)) &&
-                        (rt->u.dst.dev->features & NETIF_F_UFO)) {
-
+        if (((length> mtu) || !skb_queue_empty(&sk->sk_write_queue)) &&
+            (sk->sk_protocol == IPPROTO_UDP) &&
+            (rt->u.dst.dev->features & NETIF_F_UFO)) {
                 err = ip_ufo_append_data(sk, getfrag, from, length, hh_len,
                                          fragheaderlen, transhdrlen, mtu,
                                          flags);
diff --git a/net/ipv4/ip_sockglue.c b/net/ipv4/ip_sockglue.c
index 4d8d95404f45..e0514e82308e 100644
--- a/net/ipv4/ip_sockglue.c
+++ b/net/ipv4/ip_sockglue.c
@@ -1186,7 +1186,14 @@ int ip_getsockopt(struct sock *sk, int level,
 int compat_ip_getsockopt(struct sock *sk, int level, int optname,
                          char __user *optval, int __user *optlen)
 {
-        int err = do_ip_getsockopt(sk, level, optname, optval, optlen);
+        int err;
+
+        if (optname == MCAST_MSFILTER)
+                return compat_mc_getsockopt(sk, level, optname, optval, optlen,
+                        ip_getsockopt);
+
+        err = do_ip_getsockopt(sk, level, optname, optval, optlen);
+
 #ifdef CONFIG_NETFILTER
         /* we need to exclude all possible ENOPROTOOPTs except default case */
         if (err == -ENOPROTOOPT && optname != IP_PKTOPTIONS &&
diff --git a/net/ipv4/ipconfig.c b/net/ipv4/ipconfig.c
index 0f42d1c1f690..89dee4346f60 100644
--- a/net/ipv4/ipconfig.c
+++ b/net/ipv4/ipconfig.c
@@ -412,12 +412,12 @@ static struct packet_type rarp_packet_type __initdata = {
         .func = ic_rarp_recv,
 };
 
-static inline void ic_rarp_init(void)
+static inline void __init ic_rarp_init(void)
 {
         dev_add_pack(&rarp_packet_type);
 }
 
-static inline void ic_rarp_cleanup(void)
+static inline void __init ic_rarp_cleanup(void)
 {
         dev_remove_pack(&rarp_packet_type);
 }
@@ -682,7 +682,7 @@ static void __init ic_bootp_init_ext(u8 *e)
 /*
  *  Initialize the DHCP/BOOTP mechanism.
  */
-static inline void ic_bootp_init(void)
+static inline void __init ic_bootp_init(void)
 {
         int i;
 
@@ -696,7 +696,7 @@ static inline void ic_bootp_init(void)
 /*
  *  DHCP/BOOTP cleanup.
  */
-static inline void ic_bootp_cleanup(void)
+static inline void __init ic_bootp_cleanup(void)
 {
         dev_remove_pack(&bootp_packet_type);
 }
diff --git a/net/ipv4/ipvs/ip_vs_proto.c b/net/ipv4/ipvs/ip_vs_proto.c
index dde28a250d92..4b1c16cbb16b 100644
--- a/net/ipv4/ipvs/ip_vs_proto.c
+++ b/net/ipv4/ipvs/ip_vs_proto.c
@@ -148,7 +148,7 @@ const char * ip_vs_state_name(__u16 proto, int state)
         struct ip_vs_protocol *pp = ip_vs_proto_get(proto);
 
         if (pp == NULL || pp->state_name == NULL)
-                return "ERR!";
+                return (IPPROTO_IP == proto) ? "NONE" : "ERR!";
         return pp->state_name(state);
 }
 
diff --git a/net/ipv4/ipvs/ip_vs_proto_ah.c b/net/ipv4/ipvs/ip_vs_proto_ah.c
index a842676e1c69..4bf835e1d86d 100644
--- a/net/ipv4/ipvs/ip_vs_proto_ah.c
+++ b/net/ipv4/ipvs/ip_vs_proto_ah.c
@@ -160,6 +160,7 @@ static void ah_exit(struct ip_vs_protocol *pp)
 struct ip_vs_protocol ip_vs_protocol_ah = {
         .name =                 "AH",
         .protocol =             IPPROTO_AH,
+        .num_states =           1,
         .dont_defrag =          1,
         .init =                 ah_init,
         .exit =                 ah_exit,
diff --git a/net/ipv4/ipvs/ip_vs_proto_esp.c b/net/ipv4/ipvs/ip_vs_proto_esp.c
index aef0d3ee8e44..db6a6b7b1a0b 100644
--- a/net/ipv4/ipvs/ip_vs_proto_esp.c
+++ b/net/ipv4/ipvs/ip_vs_proto_esp.c
@@ -159,6 +159,7 @@ static void esp_exit(struct ip_vs_protocol *pp)
 struct ip_vs_protocol ip_vs_protocol_esp = {
         .name =                 "ESP",
         .protocol =             IPPROTO_ESP,
+        .num_states =           1,
         .dont_defrag =          1,
         .init =                 esp_init,
         .exit =                 esp_exit,
diff --git a/net/ipv4/ipvs/ip_vs_proto_tcp.c b/net/ipv4/ipvs/ip_vs_proto_tcp.c
index 620e40ff79a9..b83dc14b0a4d 100644
--- a/net/ipv4/ipvs/ip_vs_proto_tcp.c
+++ b/net/ipv4/ipvs/ip_vs_proto_tcp.c
@@ -594,6 +594,7 @@ static void ip_vs_tcp_exit(struct ip_vs_protocol *pp)
 struct ip_vs_protocol ip_vs_protocol_tcp = {
         .name =                 "TCP",
         .protocol =             IPPROTO_TCP,
+        .num_states =           IP_VS_TCP_S_LAST,
         .dont_defrag =          0,
         .appcnt =               ATOMIC_INIT(0),
         .init =                 ip_vs_tcp_init,
diff --git a/net/ipv4/ipvs/ip_vs_proto_udp.c b/net/ipv4/ipvs/ip_vs_proto_udp.c
index 1caa2908373f..75771cb3cd6f 100644
--- a/net/ipv4/ipvs/ip_vs_proto_udp.c
+++ b/net/ipv4/ipvs/ip_vs_proto_udp.c
@@ -409,6 +409,7 @@ static void udp_exit(struct ip_vs_protocol *pp)
 struct ip_vs_protocol ip_vs_protocol_udp = {
         .name =                 "UDP",
         .protocol =             IPPROTO_UDP,
+        .num_states =           IP_VS_UDP_S_LAST,
         .dont_defrag =          0,
         .init =                 udp_init,
         .exit =                 udp_exit,
diff --git a/net/ipv4/ipvs/ip_vs_sync.c b/net/ipv4/ipvs/ip_vs_sync.c
index 69c56663cc9a..eff54efe0351 100644
--- a/net/ipv4/ipvs/ip_vs_sync.c
+++ b/net/ipv4/ipvs/ip_vs_sync.c
@@ -288,11 +288,16 @@ static void ip_vs_process_message(const char *buffer, const size_t buflen)
         char *p;
         int i;
 
+        if (buflen < sizeof(struct ip_vs_sync_mesg)) {
+                IP_VS_ERR_RL("sync message header too short\n");
+                return;
+        }
+
         /* Convert size back to host byte order */
         m->size = ntohs(m->size);
 
         if (buflen != m->size) {
-                IP_VS_ERR("bogus message\n");
+                IP_VS_ERR_RL("bogus sync message size\n");
                 return;
         }
 
@@ -307,9 +312,48 @@ static void ip_vs_process_message(const char *buffer, const size_t buflen)
         for (i=0; i<m->nr_conns; i++) {
                 unsigned flags, state;
 
-                s = (struct ip_vs_sync_conn *)p;
+                if (p + SIMPLE_CONN_SIZE > buffer+buflen) {
+                        IP_VS_ERR_RL("bogus conn in sync message\n");
+                        return;
+                }
+                s = (struct ip_vs_sync_conn *) p;
                 flags = ntohs(s->flags) | IP_VS_CONN_F_SYNC;
+                flags &= ~IP_VS_CONN_F_HASHED;
+                if (flags & IP_VS_CONN_F_SEQ_MASK) {
+                        opt = (struct ip_vs_sync_conn_options *)&s[1];
+                        p += FULL_CONN_SIZE;
+                        if (p > buffer+buflen) {
+                                IP_VS_ERR_RL("bogus conn options in sync message\n");
+                                return;
+                        }
+                } else {
+                        opt = NULL;
+                        p += SIMPLE_CONN_SIZE;
+                }
+
                 state = ntohs(s->state);
+                if (!(flags & IP_VS_CONN_F_TEMPLATE)) {
+                        pp = ip_vs_proto_get(s->protocol);
+                        if (!pp) {
+                                IP_VS_ERR_RL("Unsupported protocol %u in sync msg\n",
+                                        s->protocol);
+                                continue;
+                        }
+                        if (state >= pp->num_states) {
+                                IP_VS_DBG(2, "Invalid %s state %u in sync msg\n",
+                                        pp->name, state);
+                                continue;
+                        }
+                } else {
+                        /* protocol in templates is not used for state/timeout */
+                        pp = NULL;
+                        if (state > 0) {
+                                IP_VS_DBG(2, "Invalid template state %u in sync msg\n",
+                                        state);
+                                state = 0;
+                        }
+                }
+
                 if (!(flags & IP_VS_CONN_F_TEMPLATE))
                         cp = ip_vs_conn_in_get(s->protocol,
                                                s->caddr, s->cport,
@@ -345,14 +389,9 @@ static void ip_vs_process_message(const char *buffer, const size_t buflen)
                                 IP_VS_ERR("ip_vs_conn_new failed\n");
                                 return;
                         }
-                        cp->state = state;
                 } else if (!cp->dest) {
                         dest = ip_vs_try_bind_dest(cp);
-                        if (!dest) {
-                                /* it is an unbound entry created by
-                                 * synchronization */
-                                cp->flags = flags | IP_VS_CONN_F_HASHED;
-                        } else
+                        if (dest)
                                 atomic_dec(&dest->refcnt);
                 } else if ((cp->dest) && (cp->protocol == IPPROTO_TCP) &&
                            (cp->state != state)) {
@@ -371,23 +410,22 @@ static void ip_vs_process_message(const char *buffer, const size_t buflen)
                         }
                 }
 
-                if (flags & IP_VS_CONN_F_SEQ_MASK) {
-                        opt = (struct ip_vs_sync_conn_options *)&s[1];
+                if (opt)
                         memcpy(&cp->in_seq, opt, sizeof(*opt));
-                        p += FULL_CONN_SIZE;
-                } else
-                        p += SIMPLE_CONN_SIZE;
-
                 atomic_set(&cp->in_pkts, sysctl_ip_vs_sync_threshold[0]);
                 cp->state = state;
-                pp = ip_vs_proto_get(s->protocol);
-                cp->timeout = pp->timeout_table[cp->state];
+                cp->old_state = cp->state;
+                /*
+                 * We can not recover the right timeout for templates
+                 * in all cases, we can not find the right fwmark
+                 * virtual service. If needed, we can do it for
+                 * non-fwmark persistent services.
+                 */
+                if (!(flags & IP_VS_CONN_F_TEMPLATE) && pp->timeout_table)
+                        cp->timeout = pp->timeout_table[state];
+                else
+                        cp->timeout = (3*60*HZ);
                 ip_vs_conn_put(cp);
-
-                if (p > buffer+buflen) {
-                        IP_VS_ERR("bogus message\n");
-                        return;
-                }
         }
 }
 
diff --git a/net/ipv4/netfilter/ip_queue.c b/net/ipv4/netfilter/ip_queue.c
index 719be29f7506..26a37cedcf2e 100644
--- a/net/ipv4/netfilter/ip_queue.c
+++ b/net/ipv4/netfilter/ip_queue.c
@@ -296,9 +296,8 @@ ipq_mangle_ipv4(ipq_verdict_msg_t *v, struct nf_queue_entry *e)
                 if (v->data_len > 0xFFFF)
                         return -EINVAL;
                 if (diff > skb_tailroom(e->skb)) {
-                        nskb = skb_copy_expand(e->skb, 0,
-                                               diff - skb_tailroom(e->skb),
-                                               GFP_ATOMIC);
+                        nskb = skb_copy_expand(e->skb, skb_headroom(e->skb),
+                                               diff, GFP_ATOMIC);
                         if (!nskb) {
                                 printk(KERN_WARNING "ip_queue: error "
                                       "in mangle, dropping packet\n");
diff --git a/net/ipv4/netfilter/ipt_CLUSTERIP.c b/net/ipv4/netfilter/ipt_CLUSTERIP.c
index 22d8e7cd9197..1819ad7ab910 100644
--- a/net/ipv4/netfilter/ipt_CLUSTERIP.c
+++ b/net/ipv4/netfilter/ipt_CLUSTERIP.c
@@ -169,14 +169,14 @@ clusterip_config_init(const struct ipt_clusterip_tgt_info *i, __be32 ip,
 
                 /* create proc dir entry */
                 sprintf(buffer, "%u.%u.%u.%u", NIPQUAD(ip));
-                c->pde = proc_create(buffer, S_IWUSR|S_IRUSR,
-                                     clusterip_procdir, &clusterip_proc_fops);
+                c->pde = proc_create_data(buffer, S_IWUSR|S_IRUSR,
+                                          clusterip_procdir,
+                                          &clusterip_proc_fops, c);
                 if (!c->pde) {
                         kfree(c);
                         return NULL;
                 }
         }
-        c->pde->data = c;
 #endif
 
         write_lock_bh(&clusterip_lock);
diff --git a/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c b/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c
index cacb9cb27dab..5a955c440364 100644
--- a/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c
+++ b/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c
@@ -303,7 +303,7 @@ getorigdst(struct sock *sk, int optval, void __user *user, int *len)
         const struct nf_conntrack_tuple_hash *h;
         struct nf_conntrack_tuple tuple;
 
-        NF_CT_TUPLE_U_BLANK(&tuple);
+        memset(&tuple, 0, sizeof(tuple));
         tuple.src.u3.ip = inet->rcv_saddr;
         tuple.src.u.tcp.port = inet->sport;
         tuple.dst.u3.ip = inet->daddr;
diff --git a/net/ipv4/route.c b/net/ipv4/route.c
index ce25a13f3430..5e3685c5c407 100644
--- a/net/ipv4/route.c
+++ b/net/ipv4/route.c
@@ -1430,11 +1430,13 @@ static inline unsigned short guess_mtu(unsigned short old_mtu)
 }
 
 unsigned short ip_rt_frag_needed(struct net *net, struct iphdr *iph,
-                                 unsigned short new_mtu)
+                                 unsigned short new_mtu,
+                                 struct net_device *dev)
 {
-        int i;
+        int i, k;
         unsigned short old_mtu = ntohs(iph->tot_len);
         struct rtable *rth;
+        int  ikeys[2] = { dev->ifindex, 0 };
         __be32  skeys[2] = { iph->saddr, 0, };
         __be32  daddr = iph->daddr;
         unsigned short est_mtu = 0;
@@ -1442,22 +1444,26 @@ unsigned short ip_rt_frag_needed(struct net *net, struct iphdr *iph,
         if (ipv4_config.no_pmtu_disc)
                 return 0;
 
-        for (i = 0; i < 2; i++) {
-                unsigned hash = rt_hash(daddr, skeys[i], 0);
+        for (k = 0; k < 2; k++) {
+                for (i = 0; i < 2; i++) {
+                        unsigned hash = rt_hash(daddr, skeys[i], ikeys[k]);
 
-                rcu_read_lock();
-                for (rth = rcu_dereference(rt_hash_table[hash].chain); rth;
-                     rth = rcu_dereference(rth->u.dst.rt_next)) {
-                        if (rth->fl.fl4_dst == daddr &&
-                            rth->fl.fl4_src == skeys[i] &&
-                            rth->rt_dst  == daddr &&
-                            rth->rt_src  == iph->saddr &&
-                            rth->fl.iif == 0 &&
-                            !(dst_metric_locked(&rth->u.dst, RTAX_MTU)) &&
-                            net_eq(dev_net(rth->u.dst.dev), net) &&
-                            rth->rt_genid == atomic_read(&rt_genid)) {
+                        rcu_read_lock();
+                        for (rth = rcu_dereference(rt_hash_table[hash].chain); rth;
+                             rth = rcu_dereference(rth->u.dst.rt_next)) {
                                 unsigned short mtu = new_mtu;
 
+                                if (rth->fl.fl4_dst != daddr ||
+                                    rth->fl.fl4_src != skeys[i] ||
+                                    rth->rt_dst != daddr ||
+                                    rth->rt_src != iph->saddr ||
+                                    rth->fl.oif != ikeys[k] ||
+                                    rth->fl.iif != 0 ||
+                                    dst_metric_locked(&rth->u.dst, RTAX_MTU) ||
+                                    !net_eq(dev_net(rth->u.dst.dev), net) ||
+                                    rth->rt_genid != atomic_read(&rt_genid))
+                                        continue;
+
                                 if (new_mtu < 68 || new_mtu >= old_mtu) {
 
                                         /* BSD 4.2 compatibility hack :-( */
@@ -1483,8 +1489,8 @@ unsigned short ip_rt_frag_needed(struct net *net, struct iphdr *iph,
                                         est_mtu = mtu;
                                 }
                         }
+                        rcu_read_unlock();
                 }
-                rcu_read_unlock();
         }
         return est_mtu ? : new_mtu;
 }
diff --git a/net/ipv4/tcp_cong.c b/net/ipv4/tcp_cong.c
index 3a6be23d222f..6a250828b767 100644
--- a/net/ipv4/tcp_cong.c
+++ b/net/ipv4/tcp_cong.c
@@ -285,14 +285,12 @@ int tcp_is_cwnd_limited(const struct sock *sk, u32 in_flight)
         if (in_flight >= tp->snd_cwnd)
                 return 1;
 
-        if (!sk_can_gso(sk))
-                return 0;
-
         left = tp->snd_cwnd - in_flight;
-        if (sysctl_tcp_tso_win_divisor)
-                return left * sysctl_tcp_tso_win_divisor < tp->snd_cwnd;
-        else
-                return left <= tcp_max_burst(tp);
+        if (sk_can_gso(sk) &&
+            left * sysctl_tcp_tso_win_divisor < tp->snd_cwnd &&
+            left * tp->mss_cache < sk->sk_gso_max_size)
+                return 1;
+        return left <= tcp_max_burst(tp);
 }
 EXPORT_SYMBOL_GPL(tcp_is_cwnd_limited);
 
diff --git a/net/ipv4/tcp_cubic.c b/net/ipv4/tcp_cubic.c
index eb5b9854c8c7..4a1221e5e8ee 100644
--- a/net/ipv4/tcp_cubic.c
+++ b/net/ipv4/tcp_cubic.c
@@ -15,8 +15,8 @@
 
 #include <linux/mm.h>
 #include <linux/module.h>
+#include <linux/math64.h>
 #include <net/tcp.h>
-#include <asm/div64.h>
 
 #define BICTCP_BETA_SCALE    1024       /* Scale factor beta calculation
                                          * max_cwnd = snd_cwnd * beta
@@ -128,7 +128,7 @@ static u32 cubic_root(u64 a)
          * x    = ( 2 * x  +  a / x  ) / 3
          *  k+1          k         k
          */
-        x = (2 * x + (u32)div64_64(a, (u64)x * (u64)(x - 1)));
+        x = (2 * x + (u32)div64_u64(a, (u64)x * (u64)(x - 1)));
         x = ((x * 341) >> 10);
         return x;
 }
diff --git a/net/ipv4/tcp_hybla.c b/net/ipv4/tcp_hybla.c
index 44618b675916..bfcbd148a89d 100644
--- a/net/ipv4/tcp_hybla.c
+++ b/net/ipv4/tcp_hybla.c
@@ -101,8 +101,10 @@ static void hybla_cong_avoid(struct sock *sk, u32 ack, u32 in_flight)
         if (!tcp_is_cwnd_limited(sk, in_flight))
                 return;
 
-        if (!ca->hybla_en)
-                return tcp_reno_cong_avoid(sk, ack, in_flight);
+        if (!ca->hybla_en) {
+                tcp_reno_cong_avoid(sk, ack, in_flight);
+                return;
+        }
 
         if (ca->rho == 0)
                 hybla_recalc_param(sk);
diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index 0298f80681f2..eda4f4a233f3 100644
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -1172,8 +1172,8 @@ static int tcp_check_dsack(struct tcp_sock *tp, struct sk_buff *ack_skb,
                            struct tcp_sack_block_wire *sp, int num_sacks,
                            u32 prior_snd_una)
 {
-        u32 start_seq_0 = ntohl(get_unaligned(&sp[0].start_seq));
-        u32 end_seq_0 = ntohl(get_unaligned(&sp[0].end_seq));
+        u32 start_seq_0 = get_unaligned_be32(&sp[0].start_seq);
+        u32 end_seq_0 = get_unaligned_be32(&sp[0].end_seq);
         int dup_sack = 0;
 
         if (before(start_seq_0, TCP_SKB_CB(ack_skb)->ack_seq)) {
@@ -1181,8 +1181,8 @@ static int tcp_check_dsack(struct tcp_sock *tp, struct sk_buff *ack_skb,
                 tcp_dsack_seen(tp);
                 NET_INC_STATS_BH(LINUX_MIB_TCPDSACKRECV);
         } else if (num_sacks > 1) {
-                u32 end_seq_1 = ntohl(get_unaligned(&sp[1].end_seq));
-                u32 start_seq_1 = ntohl(get_unaligned(&sp[1].start_seq));
+                u32 end_seq_1 = get_unaligned_be32(&sp[1].end_seq);
+                u32 start_seq_1 = get_unaligned_be32(&sp[1].start_seq);
 
                 if (!after(end_seq_0, end_seq_1) &&
                     !before(start_seq_0, start_seq_1)) {
@@ -1453,8 +1453,8 @@ tcp_sacktag_write_queue(struct sock *sk, struct sk_buff *ack_skb,
         for (i = 0; i < num_sacks; i++) {
                 int dup_sack = !i && found_dup_sack;
 
-                sp[used_sacks].start_seq = ntohl(get_unaligned(&sp_wire[i].start_seq));
-                sp[used_sacks].end_seq = ntohl(get_unaligned(&sp_wire[i].end_seq));
+                sp[used_sacks].start_seq = get_unaligned_be32(&sp_wire[i].start_seq);
+                sp[used_sacks].end_seq = get_unaligned_be32(&sp_wire[i].end_seq);
 
                 if (!tcp_is_sackblock_valid(tp, dup_sack,
                                             sp[used_sacks].start_seq,
@@ -3340,7 +3340,7 @@ void tcp_parse_options(struct sk_buff *skb, struct tcp_options_received *opt_rx,
                         switch (opcode) {
                         case TCPOPT_MSS:
                                 if (opsize == TCPOLEN_MSS && th->syn && !estab) {
-                                        u16 in_mss = ntohs(get_unaligned((__be16 *)ptr));
+                                        u16 in_mss = get_unaligned_be16(ptr);
                                         if (in_mss) {
                                                 if (opt_rx->user_mss &&
                                                     opt_rx->user_mss < in_mss)
@@ -3369,8 +3369,8 @@ void tcp_parse_options(struct sk_buff *skb, struct tcp_options_received *opt_rx,
                                     ((estab && opt_rx->tstamp_ok) ||
                                      (!estab && sysctl_tcp_timestamps))) {
                                         opt_rx->saw_tstamp = 1;
-                                        opt_rx->rcv_tsval = ntohl(get_unaligned((__be32 *)ptr));
-                                        opt_rx->rcv_tsecr = ntohl(get_unaligned((__be32 *)(ptr+4)));
+                                        opt_rx->rcv_tsval = get_unaligned_be32(ptr);
+                                        opt_rx->rcv_tsecr = get_unaligned_be32(ptr + 4);
                                 }
                                 break;
                         case TCPOPT_SACK_PERM:
diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c
index 0e9bc120707d..cd601a866c2f 100644
--- a/net/ipv4/tcp_ipv4.c
+++ b/net/ipv4/tcp_ipv4.c
@@ -2214,9 +2214,6 @@ static int tcp_seq_open(struct inode *inode, struct file *file)
         struct tcp_iter_state *s;
         int err;
 
-        if (unlikely(afinfo == NULL))
-                return -EINVAL;
-
         err = seq_open_net(inode, file, &afinfo->seq_ops,
                           sizeof(struct tcp_iter_state));
         if (err < 0)
@@ -2241,10 +2238,9 @@ int tcp_proc_register(struct net *net, struct tcp_seq_afinfo *afinfo)
         afinfo->seq_ops.next            = tcp_seq_next;
         afinfo->seq_ops.stop            = tcp_seq_stop;
 
-        p = proc_net_fops_create(net, afinfo->name, S_IRUGO, &afinfo->seq_fops);
-        if (p)
-                p->data = afinfo;
-        else
+        p = proc_create_data(afinfo->name, S_IRUGO, net->proc_net,
+                             &afinfo->seq_fops, afinfo);
+        if (!p)
                 rc = -ENOMEM;
         return rc;
 }
diff --git a/net/ipv4/tcp_vegas.c b/net/ipv4/tcp_vegas.c
index be24d6ee34bd..14504dada116 100644
--- a/net/ipv4/tcp_vegas.c
+++ b/net/ipv4/tcp_vegas.c
@@ -167,8 +167,10 @@ static void tcp_vegas_cong_avoid(struct sock *sk, u32 ack, u32 in_flight)
         struct tcp_sock *tp = tcp_sk(sk);
         struct vegas *vegas = inet_csk_ca(sk);
 
-        if (!vegas->doing_vegas_now)
-                return tcp_reno_cong_avoid(sk, ack, in_flight);
+        if (!vegas->doing_vegas_now) {
+                tcp_reno_cong_avoid(sk, ack, in_flight);
+                return;
+        }
 
         /* The key players are v_beg_snd_una and v_beg_snd_nxt.
          *
@@ -229,7 +231,8 @@ static void tcp_vegas_cong_avoid(struct sock *sk, u32 ack, u32 in_flight)
                          */
                         tcp_reno_cong_avoid(sk, ack, in_flight);
                 } else {
-                        u32 rtt, target_cwnd, diff;
+                        u32 rtt, diff;
+                        u64 target_cwnd;
 
                         /* We have enough RTT samples, so, using the Vegas
                          * algorithm, we determine if we should increase or
@@ -252,8 +255,9 @@ static void tcp_vegas_cong_avoid(struct sock *sk, u32 ack, u32 in_flight)
                          * We keep it as a fixed point number with
                          * V_PARAM_SHIFT bits to the right of the binary point.
                          */
-                        target_cwnd = ((old_wnd * vegas->baseRTT)
-                                       << V_PARAM_SHIFT) / rtt;
+                        target_cwnd = ((u64)old_wnd * vegas->baseRTT);
+                        target_cwnd <<= V_PARAM_SHIFT;
+                        do_div(target_cwnd, rtt);
 
                         /* Calculate the difference between the window we had,
                          * and the window we would like to have. This quantity
@@ -279,7 +283,7 @@ static void tcp_vegas_cong_avoid(struct sock *sk, u32 ack, u32 in_flight)
                                  * utilization.
                                  */
                                 tp->snd_cwnd = min(tp->snd_cwnd,
-                                                   (target_cwnd >>
+                                                   ((u32)target_cwnd >>
                                                     V_PARAM_SHIFT)+1);
 
                         } else if (tp->snd_cwnd <= tp->snd_ssthresh) {
diff --git a/net/ipv4/tcp_veno.c b/net/ipv4/tcp_veno.c
index d16689e98516..d08b2e855c22 100644
--- a/net/ipv4/tcp_veno.c
+++ b/net/ipv4/tcp_veno.c
@@ -119,8 +119,10 @@ static void tcp_veno_cong_avoid(struct sock *sk, u32 ack, u32 in_flight)
         struct tcp_sock *tp = tcp_sk(sk);
         struct veno *veno = inet_csk_ca(sk);
 
-        if (!veno->doing_veno_now)
-                return tcp_reno_cong_avoid(sk, ack, in_flight);
+        if (!veno->doing_veno_now) {
+                tcp_reno_cong_avoid(sk, ack, in_flight);
+                return;
+        }
 
         /* limited by applications */
         if (!tcp_is_cwnd_limited(sk, in_flight))
@@ -133,7 +135,8 @@ static void tcp_veno_cong_avoid(struct sock *sk, u32 ack, u32 in_flight)
                  */
                 tcp_reno_cong_avoid(sk, ack, in_flight);
         } else {
-                u32 rtt, target_cwnd;
+                u64 target_cwnd;
+                u32 rtt;
 
                 /* We have enough rtt samples, so, using the Veno
                  * algorithm, we determine the state of the network.
@@ -141,8 +144,9 @@ static void tcp_veno_cong_avoid(struct sock *sk, u32 ack, u32 in_flight)
 
                 rtt = veno->minrtt;
 
-                target_cwnd = ((tp->snd_cwnd * veno->basertt)
-                               << V_PARAM_SHIFT) / rtt;
+                target_cwnd = (tp->snd_cwnd * veno->basertt);
+                target_cwnd <<= V_PARAM_SHIFT;
+                do_div(target_cwnd, rtt);
 
                 veno->diff = (tp->snd_cwnd << V_PARAM_SHIFT) - target_cwnd;
 
diff --git a/net/ipv4/udp.c b/net/ipv4/udp.c
index 1f535e315188..db1cb7c96d63 100644
--- a/net/ipv4/udp.c
+++ b/net/ipv4/udp.c
@@ -1605,10 +1605,9 @@ int udp_proc_register(struct net *net, struct udp_seq_afinfo *afinfo)
         afinfo->seq_ops.next            = udp_seq_next;
         afinfo->seq_ops.stop            = udp_seq_stop;
 
-        p = proc_net_fops_create(net, afinfo->name, S_IRUGO, &afinfo->seq_fops);
-        if (p)
-                p->data = afinfo;
-        else
+        p = proc_create_data(afinfo->name, S_IRUGO, net->proc_net,
+                             &afinfo->seq_fops, afinfo);
+        if (!p)
                 rc = -ENOMEM;
         return rc;
 }
diff --git a/net/ipv6/ipv6_sockglue.c b/net/ipv6/ipv6_sockglue.c
index db6fdc1498aa..56d55fecf8ec 100644
--- a/net/ipv6/ipv6_sockglue.c
+++ b/net/ipv6/ipv6_sockglue.c
@@ -1127,6 +1127,10 @@ int compat_ipv6_getsockopt(struct sock *sk, int level, int optname,
         if (level != SOL_IPV6)
                 return -ENOPROTOOPT;
 
+        if (optname == MCAST_MSFILTER)
+                return compat_mc_getsockopt(sk, level, optname, optval, optlen,
+                        ipv6_getsockopt);
+
         err = do_ipv6_getsockopt(sk, level, optname, optval, optlen);
 #ifdef CONFIG_NETFILTER
         /* we need to exclude all possible ENOPROTOOPTs except default case */
diff --git a/net/ipv6/netfilter/ip6_queue.c b/net/ipv6/netfilter/ip6_queue.c
index 92a36c9e5402..2eff3ae8977d 100644
--- a/net/ipv6/netfilter/ip6_queue.c
+++ b/net/ipv6/netfilter/ip6_queue.c
@@ -298,9 +298,8 @@ ipq_mangle_ipv6(ipq_verdict_msg_t *v, struct nf_queue_entry *e)
                 if (v->data_len > 0xFFFF)
                         return -EINVAL;
                 if (diff > skb_tailroom(e->skb)) {
-                        nskb = skb_copy_expand(e->skb, 0,
-                                               diff - skb_tailroom(e->skb),
-                                               GFP_ATOMIC);
+                        nskb = skb_copy_expand(e->skb, skb_headroom(e->skb),
+                                               diff, GFP_ATOMIC);
                         if (!nskb) {
                                 printk(KERN_WARNING "ip6_queue: OOM "
                                       "in mangle, dropping packet\n");
diff --git a/net/ipv6/proc.c b/net/ipv6/proc.c
index ca8b82f96fe5..df0736a4cafa 100644
--- a/net/ipv6/proc.c
+++ b/net/ipv6/proc.c
@@ -247,13 +247,11 @@ int snmp6_register_dev(struct inet6_dev *idev)
         if (!proc_net_devsnmp6)
                 return -ENOENT;
 
-        p = proc_create(idev->dev->name, S_IRUGO,
-                        proc_net_devsnmp6, &snmp6_seq_fops);
+        p = proc_create_data(idev->dev->name, S_IRUGO,
+                             proc_net_devsnmp6, &snmp6_seq_fops, idev);
         if (!p)
                 return -ENOMEM;
 
-        p->data = idev;
-
         idev->stats.proc_dir_entry = p;
         return 0;
 }
diff --git a/net/ipv6/reassembly.c b/net/ipv6/reassembly.c
index 7b247e3a16fe..798cabc7535b 100644
--- a/net/ipv6/reassembly.c
+++ b/net/ipv6/reassembly.c
@@ -197,6 +197,7 @@ static void ip6_frag_expire(unsigned long data)
 {
         struct frag_queue *fq;
         struct net_device *dev = NULL;
+        struct net *net;
 
         fq = container_of((struct inet_frag_queue *)data, struct frag_queue, q);
 
@@ -207,7 +208,8 @@ static void ip6_frag_expire(unsigned long data)
 
         fq_kill(fq);
 
-        dev = dev_get_by_index(&init_net, fq->iif);
+        net = container_of(fq->q.net, struct net, ipv6.frags);
+        dev = dev_get_by_index(net, fq->iif);
         if (!dev)
                 goto out;
 
diff --git a/net/irda/ircomm/ircomm_tty.c b/net/irda/ircomm/ircomm_tty.c
index d2620410cb0a..76c3057d0179 100644
--- a/net/irda/ircomm/ircomm_tty.c
+++ b/net/irda/ircomm/ircomm_tty.c
@@ -555,10 +555,8 @@ static void ircomm_tty_close(struct tty_struct *tty, struct file *filp)
 
         ircomm_tty_shutdown(self);
 
-        if (tty->driver->flush_buffer)
-                tty->driver->flush_buffer(tty);
-        if (tty->ldisc.flush_buffer)
-                tty->ldisc.flush_buffer(tty);
+        tty_driver_flush_buffer(tty);
+        tty_ldisc_flush(tty);
 
         tty->closing = 0;
         self->tty = NULL;
diff --git a/net/irda/iriap.c b/net/irda/iriap.c
index 9e15c82960fe..4a105dc32dcd 100644
--- a/net/irda/iriap.c
+++ b/net/irda/iriap.c
@@ -451,12 +451,14 @@ static void iriap_getvaluebyclass_confirm(struct iriap_cb *self,
         n = 2;
 
         /* Get length, MSB first */
-        len = be16_to_cpu(get_unaligned((__be16 *)(fp+n))); n += 2;
+        len = get_unaligned_be16(fp + n);
+        n += 2;
 
         IRDA_DEBUG(4, "%s(), len=%d\n", __func__, len);
 
         /* Get object ID, MSB first */
-        obj_id = be16_to_cpu(get_unaligned((__be16 *)(fp+n))); n += 2;
+        obj_id = get_unaligned_be16(fp + n);
+        n += 2;
 
         type = fp[n++];
         IRDA_DEBUG(4, "%s(), Value type = %d\n", __func__, type);
@@ -506,7 +508,7 @@ static void iriap_getvaluebyclass_confirm(struct iriap_cb *self,
                 value = irias_new_string_value(fp+n);
                 break;
         case IAS_OCT_SEQ:
-                value_len = be16_to_cpu(get_unaligned((__be16 *)(fp+n)));
+                value_len = get_unaligned_be16(fp + n);
                 n += 2;
 
                 /* Will truncate to IAS_MAX_OCTET_STRING bytes */
diff --git a/net/irda/irnet/irnet_irda.c b/net/irda/irnet/irnet_irda.c
index a4f1439ffdd8..75497e55927d 100644
--- a/net/irda/irnet/irnet_irda.c
+++ b/net/irda/irnet/irnet_irda.c
@@ -9,6 +9,7 @@
  */
 
 #include "irnet_irda.h"         /* Private header */
+#include <linux/seq_file.h>
 
 /*
  * PPP disconnect work: we need to make sure we're in
@@ -1717,34 +1718,23 @@ irnet_expiry_indication(discinfo_t *	expiry,
  */
 
 #ifdef CONFIG_PROC_FS
-/*------------------------------------------------------------------*/
-/*
- * Function irnet_proc_read (buf, start, offset, len, unused)
- *
- *    Give some info to the /proc file system
- */
 static int
-irnet_proc_read(char *  buf,
-                char ** start,
-                off_t   offset,
-                int     len)
+irnet_proc_show(struct seq_file *m, void *v)
 {
   irnet_socket *        self;
   char *                state;
   int                   i = 0;
 
-  len = 0;
-
   /* Get the IrNET server information... */
-  len += sprintf(buf+len, "IrNET server - ");
-  len += sprintf(buf+len, "IrDA state: %s, ",
+  seq_printf(m, "IrNET server - ");
+  seq_printf(m, "IrDA state: %s, ",
                  (irnet_server.running ? "running" : "dead"));
-  len += sprintf(buf+len, "stsap_sel: %02x, ", irnet_server.s.stsap_sel);
-  len += sprintf(buf+len, "dtsap_sel: %02x\n", irnet_server.s.dtsap_sel);
+  seq_printf(m, "stsap_sel: %02x, ", irnet_server.s.stsap_sel);
+  seq_printf(m, "dtsap_sel: %02x\n", irnet_server.s.dtsap_sel);
 
   /* Do we need to continue ? */
   if(!irnet_server.running)
-    return len;
+    return 0;
 
   /* Protect access to the instance list */
   spin_lock_bh(&irnet_server.spinlock);
@@ -1754,23 +1744,23 @@ irnet_proc_read(char *	buf,
   while(self != NULL)
     {
       /* Start printing info about the socket. */
-      len += sprintf(buf+len, "\nIrNET socket %d - ", i++);
+      seq_printf(m, "\nIrNET socket %d - ", i++);
 
       /* First, get the requested configuration */
-      len += sprintf(buf+len, "Requested IrDA name: \"%s\", ", self->rname);
-      len += sprintf(buf+len, "daddr: %08x, ", self->rdaddr);
-      len += sprintf(buf+len, "saddr: %08x\n", self->rsaddr);
+      seq_printf(m, "Requested IrDA name: \"%s\", ", self->rname);
+      seq_printf(m, "daddr: %08x, ", self->rdaddr);
+      seq_printf(m, "saddr: %08x\n", self->rsaddr);
 
       /* Second, get all the PPP info */
-      len += sprintf(buf+len, " PPP state: %s",
+      seq_printf(m, "   PPP state: %s",
                  (self->ppp_open ? "registered" : "unregistered"));
       if(self->ppp_open)
         {
-          len += sprintf(buf+len, ", unit: ppp%d",
+          seq_printf(m, ", unit: ppp%d",
                          ppp_unit_number(&self->chan));
-          len += sprintf(buf+len, ", channel: %d",
+          seq_printf(m, ", channel: %d",
                          ppp_channel_index(&self->chan));
-          len += sprintf(buf+len, ", mru: %d",
+          seq_printf(m, ", mru: %d",
                          self->mru);
           /* Maybe add self->flags ? Later... */
         }
@@ -1789,10 +1779,10 @@ irnet_proc_read(char *	buf,
               state = "weird";
             else
               state = "idle";
-      len += sprintf(buf+len, "\n       IrDA state: %s, ", state);
-      len += sprintf(buf+len, "daddr: %08x, ", self->daddr);
-      len += sprintf(buf+len, "stsap_sel: %02x, ", self->stsap_sel);
-      len += sprintf(buf+len, "dtsap_sel: %02x\n", self->dtsap_sel);
+      seq_printf(m, "\n IrDA state: %s, ", state);
+      seq_printf(m, "daddr: %08x, ", self->daddr);
+      seq_printf(m, "stsap_sel: %02x, ", self->stsap_sel);
+      seq_printf(m, "dtsap_sel: %02x\n", self->dtsap_sel);
 
       /* Next socket, please... */
       self = (irnet_socket *) hashbin_get_next(irnet_server.list);
@@ -1801,8 +1791,21 @@ irnet_proc_read(char *	buf,
   /* Spin lock end */
   spin_unlock_bh(&irnet_server.spinlock);
 
-  return len;
+  return 0;
 }
+
+static int irnet_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, irnet_proc_show, NULL);
+}
+
+static const struct file_operations irnet_proc_fops = {
+        .owner          = THIS_MODULE,
+        .open           = irnet_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
 #endif /* PROC_FS */
 
 
@@ -1841,7 +1844,7 @@ irda_irnet_init(void)
 
 #ifdef CONFIG_PROC_FS
   /* Add a /proc file for irnet infos */
-  create_proc_info_entry("irnet", 0, proc_irda, irnet_proc_read);
+  proc_create("irnet", 0, proc_irda, &irnet_proc_fops);
 #endif /* CONFIG_PROC_FS */
 
   /* Setup the IrNET server */
diff --git a/net/irda/irnet/irnet_irda.h b/net/irda/irnet/irnet_irda.h
index 0ba92d0d5204..3e408952a3f1 100644
--- a/net/irda/irnet/irnet_irda.h
+++ b/net/irda/irnet/irnet_irda.h
@@ -159,14 +159,6 @@ static void
                                 DISCOVERY_MODE,
                                 void *);
 #endif
-/* -------------------------- PROC ENTRY -------------------------- */
-#ifdef CONFIG_PROC_FS
-static int
-        irnet_proc_read(char *,
-                        char **,
-                        off_t,
-                        int);
-#endif /* CONFIG_PROC_FS */
 
 /**************************** VARIABLES ****************************/
 
diff --git a/net/key/af_key.c b/net/key/af_key.c
index 2403a31fe0f6..9e7236ff6bcc 100644
--- a/net/key/af_key.c
+++ b/net/key/af_key.c
@@ -1498,7 +1498,8 @@ static int pfkey_add(struct sock *sk, struct sk_buff *skb, struct sadb_msg *hdr,
                 err = xfrm_state_update(x);
 
         xfrm_audit_state_add(x, err ? 0 : 1,
-                             audit_get_loginuid(current), 0);
+                             audit_get_loginuid(current),
+                             audit_get_sessionid(current), 0);
 
         if (err < 0) {
                 x->km.state = XFRM_STATE_DEAD;
@@ -1552,7 +1553,8 @@ static int pfkey_delete(struct sock *sk, struct sk_buff *skb, struct sadb_msg *h
         km_state_notify(x, &c);
 out:
         xfrm_audit_state_delete(x, err ? 0 : 1,
-                               audit_get_loginuid(current), 0);
+                                audit_get_loginuid(current),
+                                audit_get_sessionid(current), 0);
         xfrm_state_put(x);
 
         return err;
@@ -1728,6 +1730,7 @@ static int pfkey_flush(struct sock *sk, struct sk_buff *skb, struct sadb_msg *hd
                 return -EINVAL;
 
         audit_info.loginuid = audit_get_loginuid(current);
+        audit_info.sessionid = audit_get_sessionid(current);
         audit_info.secid = 0;
         err = xfrm_state_flush(proto, &audit_info);
         if (err)
@@ -2324,7 +2327,8 @@ static int pfkey_spdadd(struct sock *sk, struct sk_buff *skb, struct sadb_msg *h
                                  hdr->sadb_msg_type != SADB_X_SPDUPDATE);
 
         xfrm_audit_policy_add(xp, err ? 0 : 1,
-                             audit_get_loginuid(current), 0);
+                              audit_get_loginuid(current),
+                              audit_get_sessionid(current), 0);
 
         if (err)
                 goto out;
@@ -2406,7 +2410,8 @@ static int pfkey_spddelete(struct sock *sk, struct sk_buff *skb, struct sadb_msg
                 return -ENOENT;
 
         xfrm_audit_policy_delete(xp, err ? 0 : 1,
-                                audit_get_loginuid(current), 0);
+                                 audit_get_loginuid(current),
+                                 audit_get_sessionid(current), 0);
 
         if (err)
                 goto out;
@@ -2667,7 +2672,8 @@ static int pfkey_spdget(struct sock *sk, struct sk_buff *skb, struct sadb_msg *h
 
         if (delete) {
                 xfrm_audit_policy_delete(xp, err ? 0 : 1,
-                                audit_get_loginuid(current), 0);
+                                audit_get_loginuid(current),
+                                audit_get_sessionid(current), 0);
 
                 if (err)
                         goto out;
@@ -2767,6 +2773,7 @@ static int pfkey_spdflush(struct sock *sk, struct sk_buff *skb, struct sadb_msg
         int err;
 
         audit_info.loginuid = audit_get_loginuid(current);
+        audit_info.sessionid = audit_get_sessionid(current);
         audit_info.secid = 0;
         err = xfrm_policy_flush(XFRM_POLICY_TYPE_MAIN, &audit_info);
         if (err)
diff --git a/net/mac80211/ieee80211_i.h b/net/mac80211/ieee80211_i.h
index 8e53ce7ed444..c7314bf4bec2 100644
--- a/net/mac80211/ieee80211_i.h
+++ b/net/mac80211/ieee80211_i.h
@@ -354,7 +354,7 @@ struct ieee80211_if_sta {
         int preq_queue_len;
         struct mesh_stats mshstats;
         struct mesh_config mshcfg;
-        u8 mesh_seqnum[3];
+        u32 mesh_seqnum;
         bool accepting_plinks;
 #endif
         u16 aid;
diff --git a/net/mac80211/main.c b/net/mac80211/main.c
index e9a978979d38..9ad4e3631b6b 100644
--- a/net/mac80211/main.c
+++ b/net/mac80211/main.c
@@ -255,22 +255,8 @@ static int ieee80211_open(struct net_device *dev)
 
         switch (sdata->vif.type) {
         case IEEE80211_IF_TYPE_WDS:
-                if (is_zero_ether_addr(sdata->u.wds.remote_addr))
+                if (!is_valid_ether_addr(sdata->u.wds.remote_addr))
                         return -ENOLINK;
-
-                /* Create STA entry for the WDS peer */
-                sta = sta_info_alloc(sdata, sdata->u.wds.remote_addr,
-                                     GFP_KERNEL);
-                if (!sta)
-                        return -ENOMEM;
-
-                sta->flags |= WLAN_STA_AUTHORIZED;
-
-                res = sta_info_insert(sta);
-                if (res) {
-                        /* STA has been freed */
-                        return res;
-                }
                 break;
         case IEEE80211_IF_TYPE_VLAN:
                 if (!sdata->u.vlan.ap)
@@ -337,10 +323,8 @@ static int ieee80211_open(struct net_device *dev)
                 conf.type = sdata->vif.type;
                 conf.mac_addr = dev->dev_addr;
                 res = local->ops->add_interface(local_to_hw(local), &conf);
-                if (res && !local->open_count && local->ops->stop)
-                        local->ops->stop(local_to_hw(local));
                 if (res)
-                        return res;
+                        goto err_stop;
 
                 ieee80211_if_config(dev);
                 ieee80211_reset_erp_info(dev);
@@ -353,9 +337,29 @@ static int ieee80211_open(struct net_device *dev)
                         netif_carrier_on(dev);
         }
 
+        if (sdata->vif.type == IEEE80211_IF_TYPE_WDS) {
+                /* Create STA entry for the WDS peer */
+                sta = sta_info_alloc(sdata, sdata->u.wds.remote_addr,
+                                     GFP_KERNEL);
+                if (!sta) {
+                        res = -ENOMEM;
+                        goto err_del_interface;
+                }
+
+                sta->flags |= WLAN_STA_AUTHORIZED;
+
+                res = sta_info_insert(sta);
+                if (res) {
+                        /* STA has been freed */
+                        goto err_del_interface;
+                }
+        }
+
         if (local->open_count == 0) {
                 res = dev_open(local->mdev);
                 WARN_ON(res);
+                if (res)
+                        goto err_del_interface;
                 tasklet_enable(&local->tx_pending_tasklet);
                 tasklet_enable(&local->tasklet);
         }
@@ -390,6 +394,12 @@ static int ieee80211_open(struct net_device *dev)
         netif_start_queue(dev);
 
         return 0;
+ err_del_interface:
+        local->ops->remove_interface(local_to_hw(local), &conf);
+ err_stop:
+        if (!local->open_count && local->ops->stop)
+                local->ops->stop(local_to_hw(local));
+        return res;
 }
 
 static int ieee80211_stop(struct net_device *dev)
@@ -975,6 +985,7 @@ static int __ieee80211_if_config(struct net_device *dev,
                 conf.ssid_len = sdata->u.sta.ssid_len;
         } else if (ieee80211_vif_is_mesh(&sdata->vif)) {
                 conf.beacon = beacon;
+                conf.beacon_control = control;
                 ieee80211_start_mesh(dev);
         } else if (sdata->vif.type == IEEE80211_IF_TYPE_AP) {
                 conf.ssid = sdata->u.ap.ssid;
diff --git a/net/mac80211/mesh.c b/net/mac80211/mesh.c
index 594a3356a508..f76bc26ae4d2 100644
--- a/net/mac80211/mesh.c
+++ b/net/mac80211/mesh.c
@@ -8,6 +8,7 @@
  * published by the Free Software Foundation.
  */
 
+#include <asm/unaligned.h>
 #include "ieee80211_i.h"
 #include "mesh.h"
 
@@ -167,8 +168,8 @@ int mesh_rmc_check(u8 *sa, struct ieee80211s_hdr *mesh_hdr,
         struct rmc_entry *p, *n;
 
         /* Don't care about endianness since only match matters */
-        memcpy(&seqnum, mesh_hdr->seqnum, sizeof(mesh_hdr->seqnum));
-        idx = mesh_hdr->seqnum[0] & rmc->idx_mask;
+        memcpy(&seqnum, &mesh_hdr->seqnum, sizeof(mesh_hdr->seqnum));
+        idx = le32_to_cpu(mesh_hdr->seqnum) & rmc->idx_mask;
         list_for_each_entry_safe(p, n, &rmc->bucket[idx].list, list) {
                 ++entries;
                 if (time_after(jiffies, p->exp_time) ||
@@ -393,16 +394,8 @@ int ieee80211_new_mesh_header(struct ieee80211s_hdr *meshhdr,
 {
         meshhdr->flags = 0;
         meshhdr->ttl = sdata->u.sta.mshcfg.dot11MeshTTL;
-
-        meshhdr->seqnum[0] = sdata->u.sta.mesh_seqnum[0]++;
-        meshhdr->seqnum[1] = sdata->u.sta.mesh_seqnum[1];
-        meshhdr->seqnum[2] = sdata->u.sta.mesh_seqnum[2];
-
-        if (sdata->u.sta.mesh_seqnum[0] == 0) {
-                sdata->u.sta.mesh_seqnum[1]++;
-                if (sdata->u.sta.mesh_seqnum[1] == 0)
-                        sdata->u.sta.mesh_seqnum[2]++;
-        }
+        put_unaligned(cpu_to_le32(sdata->u.sta.mesh_seqnum), &meshhdr->seqnum);
+        sdata->u.sta.mesh_seqnum++;
 
         return 5;
 }
diff --git a/net/mac80211/mesh.h b/net/mac80211/mesh.h
index 9ee3affab346..2e161f6d8288 100644
--- a/net/mac80211/mesh.h
+++ b/net/mac80211/mesh.h
@@ -140,7 +140,7 @@ struct rmc_entry {
 
 struct mesh_rmc {
         struct rmc_entry bucket[RMC_BUCKETS];
-        u8 idx_mask;
+        u32 idx_mask;
 };
 
 
diff --git a/net/mac80211/tkip.c b/net/mac80211/tkip.c
index dddbfd60f351..09093da24af6 100644
--- a/net/mac80211/tkip.c
+++ b/net/mac80211/tkip.c
@@ -230,10 +230,8 @@ void ieee80211_get_tkip_key(struct ieee80211_key_conf *keyconf,
 
         iv16 = data[hdr_len] << 8;
         iv16 += data[hdr_len + 2];
-        iv32 = data[hdr_len + 4] +
-                (data[hdr_len + 5] >> 8) +
-                (data[hdr_len + 6] >> 16) +
-                (data[hdr_len + 7] >> 24);
+        iv32 = data[hdr_len + 4] | (data[hdr_len + 5] << 8) |
+               (data[hdr_len + 6] << 16) | (data[hdr_len + 7] << 24);
 
 #ifdef CONFIG_TKIP_DEBUG
         printk(KERN_DEBUG "TKIP encrypt: iv16 = 0x%04x, iv32 = 0x%08x\n",
diff --git a/net/netfilter/nf_conntrack_core.c b/net/netfilter/nf_conntrack_core.c
index 4eac65c74ed0..c4b1799da5d7 100644
--- a/net/netfilter/nf_conntrack_core.c
+++ b/net/netfilter/nf_conntrack_core.c
@@ -104,7 +104,7 @@ nf_ct_get_tuple(const struct sk_buff *skb,
                 const struct nf_conntrack_l3proto *l3proto,
                 const struct nf_conntrack_l4proto *l4proto)
 {
-        NF_CT_TUPLE_U_BLANK(tuple);
+        memset(tuple, 0, sizeof(*tuple));
 
         tuple->src.l3num = l3num;
         if (l3proto->pkt_to_tuple(skb, nhoff, tuple) == 0)
@@ -151,7 +151,7 @@ nf_ct_invert_tuple(struct nf_conntrack_tuple *inverse,
                    const struct nf_conntrack_l3proto *l3proto,
                    const struct nf_conntrack_l4proto *l4proto)
 {
-        NF_CT_TUPLE_U_BLANK(inverse);
+        memset(inverse, 0, sizeof(*inverse));
 
         inverse->src.l3num = orig->src.l3num;
         if (l3proto->invert_tuple(inverse, orig) == 0)
diff --git a/net/netfilter/nf_conntrack_standalone.c b/net/netfilter/nf_conntrack_standalone.c
index b59871f6bdda..46ea542d0df9 100644
--- a/net/netfilter/nf_conntrack_standalone.c
+++ b/net/netfilter/nf_conntrack_standalone.c
@@ -296,11 +296,11 @@ static int nf_conntrack_standalone_init_proc(void)
         pde = proc_net_fops_create(&init_net, "nf_conntrack", 0440, &ct_file_ops);
         if (!pde)
                 goto out_nf_conntrack;
-        pde = create_proc_entry("nf_conntrack", S_IRUGO, init_net.proc_net_stat);
+
+        pde = proc_create("nf_conntrack", S_IRUGO, init_net.proc_net_stat,
+                          &ct_cpu_seq_fops);
         if (!pde)
                 goto out_stat_nf_conntrack;
-        pde->proc_fops = &ct_cpu_seq_fops;
-        pde->owner = THIS_MODULE;
         return 0;
 
 out_stat_nf_conntrack:
diff --git a/net/netfilter/nf_queue.c b/net/netfilter/nf_queue.c
index bbd26893c0c4..582ec3efc8a5 100644
--- a/net/netfilter/nf_queue.c
+++ b/net/netfilter/nf_queue.c
@@ -214,7 +214,7 @@ int nf_queue(struct sk_buff *skb,
 
         segs = skb_gso_segment(skb, 0);
         kfree_skb(skb);
-        if (unlikely(IS_ERR(segs)))
+        if (IS_ERR(segs))
                 return 1;
 
         do {
diff --git a/net/netfilter/nfnetlink_queue.c b/net/netfilter/nfnetlink_queue.c
index 2c9fe5c12894..3447025ce068 100644
--- a/net/netfilter/nfnetlink_queue.c
+++ b/net/netfilter/nfnetlink_queue.c
@@ -454,9 +454,8 @@ nfqnl_mangle(void *data, int data_len, struct nf_queue_entry *e)
                 if (data_len > 0xFFFF)
                         return -EINVAL;
                 if (diff > skb_tailroom(e->skb)) {
-                        nskb = skb_copy_expand(e->skb, 0,
-                                               diff - skb_tailroom(e->skb),
-                                               GFP_ATOMIC);
+                        nskb = skb_copy_expand(e->skb, skb_headroom(e->skb),
+                                               diff, GFP_ATOMIC);
                         if (!nskb) {
                                 printk(KERN_WARNING "nf_queue: OOM "
                                       "in mangle, dropping packet\n");
diff --git a/net/netfilter/x_tables.c b/net/netfilter/x_tables.c
index f52f7f810ac4..5d75cd86ebb3 100644
--- a/net/netfilter/x_tables.c
+++ b/net/netfilter/x_tables.c
@@ -787,7 +787,7 @@ static const struct file_operations xt_table_ops = {
         .open    = xt_table_open,
         .read    = seq_read,
         .llseek  = seq_lseek,
-        .release = seq_release,
+        .release = seq_release_net,
 };
 
 static void *xt_match_seq_start(struct seq_file *seq, loff_t *pos)
@@ -936,25 +936,24 @@ int xt_proto_init(struct net *net, int af)
 #ifdef CONFIG_PROC_FS
         strlcpy(buf, xt_prefix[af], sizeof(buf));
         strlcat(buf, FORMAT_TABLES, sizeof(buf));
-        proc = proc_net_fops_create(net, buf, 0440, &xt_table_ops);
+        proc = proc_create_data(buf, 0440, net->proc_net, &xt_table_ops,
+                                (void *)(unsigned long)af);
         if (!proc)
                 goto out;
-        proc->data = (void *)(unsigned long)af;
-
 
         strlcpy(buf, xt_prefix[af], sizeof(buf));
         strlcat(buf, FORMAT_MATCHES, sizeof(buf));
-        proc = proc_net_fops_create(net, buf, 0440, &xt_match_ops);
+        proc = proc_create_data(buf, 0440, net->proc_net, &xt_match_ops,
+                                (void *)(unsigned long)af);
         if (!proc)
                 goto out_remove_tables;
-        proc->data = (void *)(unsigned long)af;
 
         strlcpy(buf, xt_prefix[af], sizeof(buf));
         strlcat(buf, FORMAT_TARGETS, sizeof(buf));
-        proc = proc_net_fops_create(net, buf, 0440, &xt_target_ops);
+        proc = proc_create_data(buf, 0440, net->proc_net, &xt_target_ops,
+                                (void *)(unsigned long)af);
         if (!proc)
                 goto out_remove_matches;
-        proc->data = (void *)(unsigned long)af;
 #endif
 
         return 0;
diff --git a/net/netfilter/xt_TCPOPTSTRIP.c b/net/netfilter/xt_TCPOPTSTRIP.c
index 3b2aa56833b9..9685b6fcbc81 100644
--- a/net/netfilter/xt_TCPOPTSTRIP.c
+++ b/net/netfilter/xt_TCPOPTSTRIP.c
@@ -90,7 +90,7 @@ tcpoptstrip_tg6(struct sk_buff *skb, const struct net_device *in,
                 const struct xt_target *target, const void *targinfo)
 {
         struct ipv6hdr *ipv6h = ipv6_hdr(skb);
-        unsigned int tcphoff;
+        int tcphoff;
         u_int8_t nexthdr;
 
         nexthdr = ipv6h->nexthdr;
diff --git a/net/netfilter/xt_connbytes.c b/net/netfilter/xt_connbytes.c
index b15e7e2fa143..d7e8983cd37f 100644
--- a/net/netfilter/xt_connbytes.c
+++ b/net/netfilter/xt_connbytes.c
@@ -4,12 +4,11 @@
 #include <linux/module.h>
 #include <linux/bitops.h>
 #include <linux/skbuff.h>
+#include <linux/math64.h>
 #include <linux/netfilter/x_tables.h>
 #include <linux/netfilter/xt_connbytes.h>
 #include <net/netfilter/nf_conntrack.h>
 
-#include <asm/div64.h>
-
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Harald Welte <laforge@netfilter.org>");
 MODULE_DESCRIPTION("Xtables: Number of packets/bytes per connection matching");
@@ -82,7 +81,7 @@ connbytes_mt(const struct sk_buff *skb, const struct net_device *in,
                         break;
                 }
                 if (pkts != 0)
-                        what = div64_64(bytes, pkts);
+                        what = div64_u64(bytes, pkts);
                 break;
         }
 
diff --git a/net/netfilter/xt_hashlimit.c b/net/netfilter/xt_hashlimit.c
index 40d344b21453..6809af542a2c 100644
--- a/net/netfilter/xt_hashlimit.c
+++ b/net/netfilter/xt_hashlimit.c
@@ -237,15 +237,15 @@ static int htable_create_v0(struct xt_hashlimit_info *minfo, int family)
         hinfo->family = family;
         hinfo->rnd_initialized = 0;
         spin_lock_init(&hinfo->lock);
-        hinfo->pde = proc_create(minfo->name, 0,
+        hinfo->pde =
+                proc_create_data(minfo->name, 0,
                                  family == AF_INET ? hashlimit_procdir4 :
                                                      hashlimit_procdir6,
-                                 &dl_file_ops);
+                                 &dl_file_ops, hinfo);
         if (!hinfo->pde) {
                 vfree(hinfo);
                 return -1;
         }
-        hinfo->pde->data = hinfo;
 
         setup_timer(&hinfo->timer, htable_gc, (unsigned long )hinfo);
         hinfo->timer.expires = jiffies + msecs_to_jiffies(hinfo->cfg.gc_interval);
@@ -301,15 +301,15 @@ static int htable_create(struct xt_hashlimit_mtinfo1 *minfo,
         hinfo->rnd_initialized = 0;
         spin_lock_init(&hinfo->lock);
 
-        hinfo->pde = proc_create(minfo->name, 0,
+        hinfo->pde =
+                proc_create_data(minfo->name, 0,
                                  family == AF_INET ? hashlimit_procdir4 :
                                                      hashlimit_procdir6,
-                                 &dl_file_ops);
+                                 &dl_file_ops, hinfo);
         if (hinfo->pde == NULL) {
                 vfree(hinfo);
                 return -1;
         }
-        hinfo->pde->data = hinfo;
 
         setup_timer(&hinfo->timer, htable_gc, (unsigned long)hinfo);
         hinfo->timer.expires = jiffies + msecs_to_jiffies(hinfo->cfg.gc_interval);
diff --git a/net/netlabel/netlabel_unlabeled.c b/net/netlabel/netlabel_unlabeled.c
index d282ad1570a7..0099da5b2591 100644
--- a/net/netlabel/netlabel_unlabeled.c
+++ b/net/netlabel/netlabel_unlabeled.c
@@ -1780,6 +1780,7 @@ int __init netlbl_unlabel_defconf(void)
          * messages so don't worry to much about these values. */
         security_task_getsecid(current, &audit_info.secid);
         audit_info.loginuid = 0;
+        audit_info.sessionid = 0;
 
         entry = kzalloc(sizeof(*entry), GFP_KERNEL);
         if (entry == NULL)
diff --git a/net/netlabel/netlabel_user.c b/net/netlabel/netlabel_user.c
index b17d4203806e..68706b4e3bf8 100644
--- a/net/netlabel/netlabel_user.c
+++ b/net/netlabel/netlabel_user.c
@@ -107,7 +107,9 @@ struct audit_buffer *netlbl_audit_start_common(int type,
         if (audit_buf == NULL)
                 return NULL;
 
-        audit_log_format(audit_buf, "netlabel: auid=%u", audit_info->loginuid);
+        audit_log_format(audit_buf, "netlabel: auid=%u ses=%u",
+                         audit_info->loginuid,
+                         audit_info->sessionid);
 
         if (audit_info->secid != 0 &&
             security_secid_to_secctx(audit_info->secid,
diff --git a/net/netlabel/netlabel_user.h b/net/netlabel/netlabel_user.h
index 6d7f4ab46c2b..6caef8b20611 100644
--- a/net/netlabel/netlabel_user.h
+++ b/net/netlabel/netlabel_user.h
@@ -51,6 +51,7 @@ static inline void netlbl_netlink_auditinfo(struct sk_buff *skb,
 {
         audit_info->secid = NETLINK_CB(skb).sid;
         audit_info->loginuid = NETLINK_CB(skb).loginuid;
+        audit_info->sessionid = NETLINK_CB(skb).sessionid;
 }
 
 /* NetLabel NETLINK I/O functions */
diff --git a/net/netlink/af_netlink.c b/net/netlink/af_netlink.c
index 46f3e44bb83a..9b97f8006c9c 100644
--- a/net/netlink/af_netlink.c
+++ b/net/netlink/af_netlink.c
@@ -1248,6 +1248,7 @@ static int netlink_sendmsg(struct kiocb *kiocb, struct socket *sock,
         NETLINK_CB(skb).pid     = nlk->pid;
         NETLINK_CB(skb).dst_group = dst_group;
         NETLINK_CB(skb).loginuid = audit_get_loginuid(current);
+        NETLINK_CB(skb).sessionid = audit_get_sessionid(current);
         security_task_getsecid(current, &(NETLINK_CB(skb).sid));
         memcpy(NETLINK_CREDS(skb), &siocb->scm->creds, sizeof(struct ucred));
 
diff --git a/net/rose/rose_route.c b/net/rose/rose_route.c
index 5053a53ba24f..bd593871c81e 100644
--- a/net/rose/rose_route.c
+++ b/net/rose/rose_route.c
@@ -1066,12 +1066,12 @@ out:
 #ifdef CONFIG_PROC_FS
 
 static void *rose_node_start(struct seq_file *seq, loff_t *pos)
-        __acquires(rose_neigh_list_lock)
+        __acquires(rose_node_list_lock)
 {
         struct rose_node *rose_node;
         int i = 1;
 
-        spin_lock_bh(&rose_neigh_list_lock);
+        spin_lock_bh(&rose_node_list_lock);
         if (*pos == 0)
                 return SEQ_START_TOKEN;
 
@@ -1090,9 +1090,9 @@ static void *rose_node_next(struct seq_file *seq, void *v, loff_t *pos)
 }
 
 static void rose_node_stop(struct seq_file *seq, void *v)
-        __releases(rose_neigh_list_lock)
+        __releases(rose_node_list_lock)
 {
-        spin_unlock_bh(&rose_neigh_list_lock);
+        spin_unlock_bh(&rose_node_list_lock);
 }
 
 static int rose_node_show(struct seq_file *seq, void *v)
diff --git a/net/rxrpc/ar-transport.c b/net/rxrpc/ar-transport.c
index bb282a6a19f0..64069c8769a5 100644
--- a/net/rxrpc/ar-transport.c
+++ b/net/rxrpc/ar-transport.c
@@ -184,12 +184,13 @@ void rxrpc_put_transport(struct rxrpc_transport *trans)
         ASSERTCMP(atomic_read(&trans->usage), >, 0);
 
         trans->put_time = get_seconds();
-        if (unlikely(atomic_dec_and_test(&trans->usage)))
+        if (unlikely(atomic_dec_and_test(&trans->usage))) {
                 _debug("zombie");
                 /* let the reaper determine the timeout to avoid a race with
                  * overextending the timeout if the reaper is running at the
                  * same time */
                 rxrpc_queue_delayed_work(&rxrpc_transport_reap, 0);
+        }
         _leave("");
 }
 
diff --git a/net/sched/sch_generic.c b/net/sched/sch_generic.c
index b741618e4d54..d355e5e47fe3 100644
--- a/net/sched/sch_generic.c
+++ b/net/sched/sch_generic.c
@@ -219,6 +219,7 @@ static void dev_watchdog(unsigned long arg)
                                 printk(KERN_INFO "NETDEV WATCHDOG: %s: transmit timed out\n",
                                        dev->name);
                                 dev->tx_timeout(dev);
+                                WARN_ON_ONCE(1);
                         }
                         if (!mod_timer(&dev->watchdog_timer, round_jiffies(jiffies + dev->watchdog_timeo)))
                                 dev_hold(dev);
diff --git a/net/sched/sch_sfq.c b/net/sched/sch_sfq.c
index a20e2ef7704b..f0463d757a98 100644
--- a/net/sched/sch_sfq.c
+++ b/net/sched/sch_sfq.c
@@ -521,7 +521,8 @@ static void sfq_destroy(struct Qdisc *sch)
         struct sfq_sched_data *q = qdisc_priv(sch);
 
         tcf_destroy_chain(q->filter_list);
-        del_timer(&q->perturb_timer);
+        q->perturb_period = 0;
+        del_timer_sync(&q->perturb_timer);
 }
 
 static int sfq_dump(struct Qdisc *sch, struct sk_buff *skb)
diff --git a/net/sunrpc/cache.c b/net/sunrpc/cache.c
index d75530ff2a6d..c9966713282a 100644
--- a/net/sunrpc/cache.c
+++ b/net/sunrpc/cache.c
@@ -316,31 +316,28 @@ static int create_cache_proc_entries(struct cache_detail *cd)
         cd->proc_ent->owner = cd->owner;
         cd->channel_ent = cd->content_ent = NULL;
 
-        p = proc_create("flush", S_IFREG|S_IRUSR|S_IWUSR,
-                        cd->proc_ent, &cache_flush_operations);
+        p = proc_create_data("flush", S_IFREG|S_IRUSR|S_IWUSR,
+                             cd->proc_ent, &cache_flush_operations, cd);
         cd->flush_ent = p;
         if (p == NULL)
                 goto out_nomem;
         p->owner = cd->owner;
-        p->data = cd;
 
         if (cd->cache_request || cd->cache_parse) {
-                p = proc_create("channel", S_IFREG|S_IRUSR|S_IWUSR,
-                                cd->proc_ent, &cache_file_operations);
+                p = proc_create_data("channel", S_IFREG|S_IRUSR|S_IWUSR,
+                                     cd->proc_ent, &cache_file_operations, cd);
                 cd->channel_ent = p;
                 if (p == NULL)
                         goto out_nomem;
                 p->owner = cd->owner;
-                p->data = cd;
         }
         if (cd->cache_show) {
-                p = proc_create("content", S_IFREG|S_IRUSR|S_IWUSR,
-                                cd->proc_ent, &content_file_operations);
+                p = proc_create_data("content", S_IFREG|S_IRUSR|S_IWUSR,
+                                cd->proc_ent, &content_file_operations, cd);
                 cd->content_ent = p;
                 if (p == NULL)
                         goto out_nomem;
                 p->owner = cd->owner;
-                p->data = cd;
         }
         return 0;
 out_nomem:
diff --git a/net/sunrpc/stats.c b/net/sunrpc/stats.c
index c6061a4346c8..50b049c6598a 100644
--- a/net/sunrpc/stats.c
+++ b/net/sunrpc/stats.c
@@ -224,16 +224,10 @@ EXPORT_SYMBOL_GPL(rpc_print_iostats);
 static inline struct proc_dir_entry *
 do_register(const char *name, void *data, const struct file_operations *fops)
 {
-        struct proc_dir_entry *ent;
-
         rpc_proc_init();
         dprintk("RPC:       registering /proc/net/rpc/%s\n", name);
 
-        ent = proc_create(name, 0, proc_net_rpc, fops);
-        if (ent) {
-                ent->data = data;
-        }
-        return ent;
+        return proc_create_data(name, 0, proc_net_rpc, fops, data);
 }
 
 struct proc_dir_entry *
diff --git a/net/sysctl_net.c b/net/sysctl_net.c
index 665e856675a4..b4f0525f91af 100644
--- a/net/sysctl_net.c
+++ b/net/sysctl_net.c
@@ -82,6 +82,6 @@ EXPORT_SYMBOL_GPL(register_net_sysctl_table);
 
 void unregister_net_sysctl_table(struct ctl_table_header *header)
 {
-        return unregister_sysctl_table(header);
+        unregister_sysctl_table(header);
 }
 EXPORT_SYMBOL_GPL(unregister_net_sysctl_table);
diff --git a/net/xfrm/xfrm_output.c b/net/xfrm/xfrm_output.c
index 2519129c6d21..09cd9c0c2d80 100644
--- a/net/xfrm/xfrm_output.c
+++ b/net/xfrm/xfrm_output.c
@@ -150,7 +150,7 @@ static int xfrm_output_gso(struct sk_buff *skb)
 
         segs = skb_gso_segment(skb, 0);
         kfree_skb(skb);
-        if (unlikely(IS_ERR(segs)))
+        if (IS_ERR(segs))
                 return PTR_ERR(segs);
 
         do {
diff --git a/net/xfrm/xfrm_policy.c b/net/xfrm/xfrm_policy.c
index e0c0390613c0..cae9fd815543 100644
--- a/net/xfrm/xfrm_policy.c
+++ b/net/xfrm/xfrm_policy.c
@@ -762,6 +762,7 @@ xfrm_policy_flush_secctx_check(u8 type, struct xfrm_audit *audit_info)
                         if (err) {
                                 xfrm_audit_policy_delete(pol, 0,
                                                          audit_info->loginuid,
+                                                         audit_info->sessionid,
                                                          audit_info->secid);
                                 return err;
                         }
@@ -777,6 +778,7 @@ xfrm_policy_flush_secctx_check(u8 type, struct xfrm_audit *audit_info)
                                 if (err) {
                                         xfrm_audit_policy_delete(pol, 0,
                                                         audit_info->loginuid,
+                                                        audit_info->sessionid,
                                                         audit_info->secid);
                                         return err;
                                 }
@@ -819,6 +821,7 @@ int xfrm_policy_flush(u8 type, struct xfrm_audit *audit_info)
                         write_unlock_bh(&xfrm_policy_lock);
 
                         xfrm_audit_policy_delete(pol, 1, audit_info->loginuid,
+                                                 audit_info->sessionid,
                                                  audit_info->secid);
 
                         xfrm_policy_kill(pol);
@@ -841,6 +844,7 @@ int xfrm_policy_flush(u8 type, struct xfrm_audit *audit_info)
 
                                 xfrm_audit_policy_delete(pol, 1,
                                                          audit_info->loginuid,
+                                                         audit_info->sessionid,
                                                          audit_info->secid);
                                 xfrm_policy_kill(pol);
                                 killed++;
@@ -2472,14 +2476,14 @@ static void xfrm_audit_common_policyinfo(struct xfrm_policy *xp,
 }
 
 void xfrm_audit_policy_add(struct xfrm_policy *xp, int result,
-                           u32 auid, u32 secid)
+                           uid_t auid, u32 sessionid, u32 secid)
 {
         struct audit_buffer *audit_buf;
 
         audit_buf = xfrm_audit_start("SPD-add");
         if (audit_buf == NULL)
                 return;
-        xfrm_audit_helper_usrinfo(auid, secid, audit_buf);
+        xfrm_audit_helper_usrinfo(auid, sessionid, secid, audit_buf);
         audit_log_format(audit_buf, " res=%u", result);
         xfrm_audit_common_policyinfo(xp, audit_buf);
         audit_log_end(audit_buf);
@@ -2487,14 +2491,14 @@ void xfrm_audit_policy_add(struct xfrm_policy *xp, int result,
 EXPORT_SYMBOL_GPL(xfrm_audit_policy_add);
 
 void xfrm_audit_policy_delete(struct xfrm_policy *xp, int result,
-                              u32 auid, u32 secid)
+                              uid_t auid, u32 sessionid, u32 secid)
 {
         struct audit_buffer *audit_buf;
 
         audit_buf = xfrm_audit_start("SPD-delete");
         if (audit_buf == NULL)
                 return;
-        xfrm_audit_helper_usrinfo(auid, secid, audit_buf);
+        xfrm_audit_helper_usrinfo(auid, sessionid, secid, audit_buf);
         audit_log_format(audit_buf, " res=%u", result);
         xfrm_audit_common_policyinfo(xp, audit_buf);
         audit_log_end(audit_buf);
diff --git a/net/xfrm/xfrm_state.c b/net/xfrm/xfrm_state.c
index fac27ce770d5..72fddafd891a 100644
--- a/net/xfrm/xfrm_state.c
+++ b/net/xfrm/xfrm_state.c
@@ -496,7 +496,8 @@ expired:
                 km_state_expired(x, 1, 0);
 
         xfrm_audit_state_delete(x, err ? 0 : 1,
-                                audit_get_loginuid(current), 0);
+                                audit_get_loginuid(current),
+                                audit_get_sessionid(current), 0);
 
 out:
         spin_unlock(&x->lock);
@@ -603,6 +604,7 @@ xfrm_state_flush_secctx_check(u8 proto, struct xfrm_audit *audit_info)
                            (err = security_xfrm_state_delete(x)) != 0) {
                                 xfrm_audit_state_delete(x, 0,
                                                         audit_info->loginuid,
+                                                        audit_info->sessionid,
                                                         audit_info->secid);
                                 return err;
                         }
@@ -641,6 +643,7 @@ restart:
                                 err = xfrm_state_delete(x);
                                 xfrm_audit_state_delete(x, err ? 0 : 1,
                                                         audit_info->loginuid,
+                                                        audit_info->sessionid,
                                                         audit_info->secid);
                                 xfrm_state_put(x);
 
@@ -2123,14 +2126,14 @@ static void xfrm_audit_helper_pktinfo(struct sk_buff *skb, u16 family,
 }
 
 void xfrm_audit_state_add(struct xfrm_state *x, int result,
-                          u32 auid, u32 secid)
+                          uid_t auid, u32 sessionid, u32 secid)
 {
         struct audit_buffer *audit_buf;
 
         audit_buf = xfrm_audit_start("SAD-add");
         if (audit_buf == NULL)
                 return;
-        xfrm_audit_helper_usrinfo(auid, secid, audit_buf);
+        xfrm_audit_helper_usrinfo(auid, sessionid, secid, audit_buf);
         xfrm_audit_helper_sainfo(x, audit_buf);
         audit_log_format(audit_buf, " res=%u", result);
         audit_log_end(audit_buf);
@@ -2138,14 +2141,14 @@ void xfrm_audit_state_add(struct xfrm_state *x, int result,
 EXPORT_SYMBOL_GPL(xfrm_audit_state_add);
 
 void xfrm_audit_state_delete(struct xfrm_state *x, int result,
-                             u32 auid, u32 secid)
+                             uid_t auid, u32 sessionid, u32 secid)
 {
         struct audit_buffer *audit_buf;
 
         audit_buf = xfrm_audit_start("SAD-delete");
         if (audit_buf == NULL)
                 return;
-        xfrm_audit_helper_usrinfo(auid, secid, audit_buf);
+        xfrm_audit_helper_usrinfo(auid, sessionid, secid, audit_buf);
         xfrm_audit_helper_sainfo(x, audit_buf);
         audit_log_format(audit_buf, " res=%u", result);
         audit_log_end(audit_buf);
diff --git a/net/xfrm/xfrm_user.c b/net/xfrm/xfrm_user.c
index 22a30ae582a2..a1b0fbe3ea35 100644
--- a/net/xfrm/xfrm_user.c
+++ b/net/xfrm/xfrm_user.c
@@ -407,6 +407,9 @@ static int xfrm_add_sa(struct sk_buff *skb, struct nlmsghdr *nlh,
         struct xfrm_state *x;
         int err;
         struct km_event c;
+        uid_t loginuid = NETLINK_CB(skb).loginuid;
+        u32 sessionid = NETLINK_CB(skb).sessionid;
+        u32 sid = NETLINK_CB(skb).sid;
 
         err = verify_newsa_info(p, attrs);
         if (err)
@@ -422,8 +425,7 @@ static int xfrm_add_sa(struct sk_buff *skb, struct nlmsghdr *nlh,
         else
                 err = xfrm_state_update(x);
 
-        xfrm_audit_state_add(x, err ? 0 : 1, NETLINK_CB(skb).loginuid,
-                             NETLINK_CB(skb).sid);
+        xfrm_audit_state_add(x, err ? 0 : 1, loginuid, sessionid, sid);
 
         if (err < 0) {
                 x->km.state = XFRM_STATE_DEAD;
@@ -478,6 +480,9 @@ static int xfrm_del_sa(struct sk_buff *skb, struct nlmsghdr *nlh,
         int err = -ESRCH;
         struct km_event c;
         struct xfrm_usersa_id *p = nlmsg_data(nlh);
+        uid_t loginuid = NETLINK_CB(skb).loginuid;
+        u32 sessionid = NETLINK_CB(skb).sessionid;
+        u32 sid = NETLINK_CB(skb).sid;
 
         x = xfrm_user_state_lookup(p, attrs, &err);
         if (x == NULL)
@@ -502,8 +507,7 @@ static int xfrm_del_sa(struct sk_buff *skb, struct nlmsghdr *nlh,
         km_state_notify(x, &c);
 
 out:
-        xfrm_audit_state_delete(x, err ? 0 : 1, NETLINK_CB(skb).loginuid,
-                                NETLINK_CB(skb).sid);
+        xfrm_audit_state_delete(x, err ? 0 : 1, loginuid, sessionid, sid);
         xfrm_state_put(x);
         return err;
 }
@@ -1123,6 +1127,9 @@ static int xfrm_add_policy(struct sk_buff *skb, struct nlmsghdr *nlh,
         struct km_event c;
         int err;
         int excl;
+        uid_t loginuid = NETLINK_CB(skb).loginuid;
+        u32 sessionid = NETLINK_CB(skb).sessionid;
+        u32 sid = NETLINK_CB(skb).sid;
 
         err = verify_newpolicy_info(p);
         if (err)
@@ -1141,8 +1148,7 @@ static int xfrm_add_policy(struct sk_buff *skb, struct nlmsghdr *nlh,
          * a type XFRM_MSG_UPDPOLICY - JHS */
         excl = nlh->nlmsg_type == XFRM_MSG_NEWPOLICY;
         err = xfrm_policy_insert(p->dir, xp, excl);
-        xfrm_audit_policy_add(xp, err ? 0 : 1, NETLINK_CB(skb).loginuid,
-                              NETLINK_CB(skb).sid);
+        xfrm_audit_policy_add(xp, err ? 0 : 1, loginuid, sessionid, sid);
 
         if (err) {
                 security_xfrm_policy_free(xp->security);
@@ -1371,9 +1377,12 @@ static int xfrm_get_policy(struct sk_buff *skb, struct nlmsghdr *nlh,
                                             NETLINK_CB(skb).pid);
                 }
         } else {
-                xfrm_audit_policy_delete(xp, err ? 0 : 1,
-                                         NETLINK_CB(skb).loginuid,
-                                         NETLINK_CB(skb).sid);
+                uid_t loginuid = NETLINK_CB(skb).loginuid;
+                u32 sessionid = NETLINK_CB(skb).sessionid;
+                u32 sid = NETLINK_CB(skb).sid;
+
+                xfrm_audit_policy_delete(xp, err ? 0 : 1, loginuid, sessionid,
+                                         sid);
 
                 if (err != 0)
                         goto out;
@@ -1399,6 +1408,7 @@ static int xfrm_flush_sa(struct sk_buff *skb, struct nlmsghdr *nlh,
         int err;
 
         audit_info.loginuid = NETLINK_CB(skb).loginuid;
+        audit_info.sessionid = NETLINK_CB(skb).sessionid;
         audit_info.secid = NETLINK_CB(skb).sid;
         err = xfrm_state_flush(p->proto, &audit_info);
         if (err)
@@ -1546,6 +1556,7 @@ static int xfrm_flush_policy(struct sk_buff *skb, struct nlmsghdr *nlh,
                 return err;
 
         audit_info.loginuid = NETLINK_CB(skb).loginuid;
+        audit_info.sessionid = NETLINK_CB(skb).sessionid;
         audit_info.secid = NETLINK_CB(skb).sid;
         err = xfrm_policy_flush(type, &audit_info);
         if (err)
@@ -1604,9 +1615,11 @@ static int xfrm_add_pol_expire(struct sk_buff *skb, struct nlmsghdr *nlh,
         read_unlock(&xp->lock);
         err = 0;
         if (up->hard) {
+                uid_t loginuid = NETLINK_CB(skb).loginuid;
+                uid_t sessionid = NETLINK_CB(skb).sessionid;
+                u32 sid = NETLINK_CB(skb).sid;
                 xfrm_policy_delete(xp, p->dir);
-                xfrm_audit_policy_delete(xp, 1, NETLINK_CB(skb).loginuid,
-                                         NETLINK_CB(skb).sid);
+                xfrm_audit_policy_delete(xp, 1, loginuid, sessionid, sid);
 
         } else {
                 // reset the timers here?
@@ -1640,9 +1653,11 @@ static int xfrm_add_sa_expire(struct sk_buff *skb, struct nlmsghdr *nlh,
         km_state_expired(x, ue->hard, current->pid);
 
         if (ue->hard) {
+                uid_t loginuid = NETLINK_CB(skb).loginuid;
+                uid_t sessionid = NETLINK_CB(skb).sessionid;
+                u32 sid = NETLINK_CB(skb).sid;
                 __xfrm_state_delete(x);
-                xfrm_audit_state_delete(x, 1, NETLINK_CB(skb).loginuid,
-                                        NETLINK_CB(skb).sid);
+                xfrm_audit_state_delete(x, 1, loginuid, sessionid, sid);
         }
         err = 0;
 out: