Merge branch 'master' into upstream

199 files changed, 764 insertions, 539 deletions

diff --git a/net/802/fc.c b/net/802/fc.c
index d64e6a502958..675d9ba8e591 100644
--- a/net/802/fc.c
+++ b/net/802/fc.c
@@ -14,7 +14,6 @@
 #include <asm/system.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/socket.h>
diff --git a/net/802/fddi.c b/net/802/fddi.c
index 0b98fe2fa2f6..ace6386384bc 100644
--- a/net/802/fddi.c
+++ b/net/802/fddi.c
@@ -30,7 +30,6 @@
 #include <asm/system.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/socket.h>
diff --git a/net/802/hippi.c b/net/802/hippi.c
index be0da59323b3..578f2a3d692d 100644
--- a/net/802/hippi.c
+++ b/net/802/hippi.c
@@ -23,7 +23,6 @@
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/socket.h>
diff --git a/net/appletalk/sysctl_net_atalk.c b/net/appletalk/sysctl_net_atalk.c
index 40b0af7437a2..7df1778e221a 100644
--- a/net/appletalk/sysctl_net_atalk.c
+++ b/net/appletalk/sysctl_net_atalk.c
@@ -73,7 +73,7 @@ static struct ctl_table_header *atalk_table_header;
 
 void atalk_register_sysctl(void)
 {
-        atalk_table_header = register_sysctl_table(atalk_root_table, 1);
+        atalk_table_header = register_sysctl_table(atalk_root_table);
 }
 
 void atalk_unregister_sysctl(void)
diff --git a/net/atm/addr.c b/net/atm/addr.c
index 3060fd0ba4b9..6afa77d63bb5 100644
--- a/net/atm/addr.c
+++ b/net/atm/addr.c
@@ -4,7 +4,6 @@
 
 #include <linux/atm.h>
 #include <linux/atmdev.h>
-#include <linux/sched.h>
 #include <asm/uaccess.h>
 
 #include "signaling.h"
diff --git a/net/atm/lec.c b/net/atm/lec.c
index 986945527691..3d804d61f656 100644
--- a/net/atm/lec.c
+++ b/net/atm/lec.c
@@ -1437,7 +1437,6 @@ static void lane2_associate_ind(struct net_device *dev, u8 *mac_addr,
  */
 
 #include <linux/types.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <asm/param.h>
 #include <asm/atomic.h>
diff --git a/net/atm/raw.c b/net/atm/raw.c
index 4df7cdd72aa1..1378f61c5c31 100644
--- a/net/atm/raw.c
+++ b/net/atm/raw.c
@@ -4,7 +4,6 @@
 
 
 #include <linux/module.h>
-#include <linux/sched.h>
 #include <linux/atmdev.h>
 #include <linux/capability.h>
 #include <linux/kernel.h>
diff --git a/net/ax25/ax25_addr.c b/net/ax25/ax25_addr.c
index 419e7188d5a7..7e7964dd987b 100644
--- a/net/ax25/ax25_addr.c
+++ b/net/ax25/ax25_addr.c
@@ -12,7 +12,6 @@
 #include <linux/in.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/net/ax25/ax25_dev.c b/net/ax25/ax25_dev.c
index b787678220ff..528c874d9828 100644
--- a/net/ax25/ax25_dev.c
+++ b/net/ax25/ax25_dev.c
@@ -11,7 +11,6 @@
 #include <linux/socket.h>
 #include <linux/in.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/net/ax25/ax25_ds_in.c b/net/ax25/ax25_ds_in.c
index edcaa897027c..e37d217a986a 100644
--- a/net/ax25/ax25_ds_in.c
+++ b/net/ax25/ax25_ds_in.c
@@ -12,7 +12,6 @@
 #include <linux/socket.h>
 #include <linux/in.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/net/ax25/ax25_ds_subr.c b/net/ax25/ax25_ds_subr.c
index 4d22d4430ec8..9569dd3fa466 100644
--- a/net/ax25/ax25_ds_subr.c
+++ b/net/ax25/ax25_ds_subr.c
@@ -12,7 +12,6 @@
 #include <linux/socket.h>
 #include <linux/in.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/net/ax25/ax25_iface.c b/net/ax25/ax25_iface.c
index aff3e652c2d1..16be0c14780a 100644
--- a/net/ax25/ax25_iface.c
+++ b/net/ax25/ax25_iface.c
@@ -12,7 +12,6 @@
 #include <linux/in.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
-#include <linux/sched.h>
 #include <linux/spinlock.h>
 #include <linux/timer.h>
 #include <linux/string.h>
diff --git a/net/ax25/ax25_in.c b/net/ax25/ax25_in.c
index e9d94291581e..4a6b26becadc 100644
--- a/net/ax25/ax25_in.c
+++ b/net/ax25/ax25_in.c
@@ -14,7 +14,6 @@
 #include <linux/socket.h>
 #include <linux/in.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/net/ax25/ax25_ip.c b/net/ax25/ax25_ip.c
index 8d62d8681615..7f818bbcd1c5 100644
--- a/net/ax25/ax25_ip.c
+++ b/net/ax25/ax25_ip.c
@@ -12,7 +12,6 @@
 #include <linux/in.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/net/ax25/ax25_out.c b/net/ax25/ax25_out.c
index f84047d1e8ce..223835092b7a 100644
--- a/net/ax25/ax25_out.c
+++ b/net/ax25/ax25_out.c
@@ -14,7 +14,6 @@
 #include <linux/in.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/net/ax25/ax25_std_in.c b/net/ax25/ax25_std_in.c
index f6ed283e9de8..a8eef88d8652 100644
--- a/net/ax25/ax25_std_in.c
+++ b/net/ax25/ax25_std_in.c
@@ -19,7 +19,6 @@
 #include <linux/socket.h>
 #include <linux/in.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/net/ax25/ax25_std_subr.c b/net/ax25/ax25_std_subr.c
index 2b3c801ae486..277f81bb979a 100644
--- a/net/ax25/ax25_std_subr.c
+++ b/net/ax25/ax25_std_subr.c
@@ -11,7 +11,6 @@
 #include <linux/socket.h>
 #include <linux/in.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/net/ax25/ax25_std_timer.c b/net/ax25/ax25_std_timer.c
index e3528b1a7802..f2f6918ac9bb 100644
--- a/net/ax25/ax25_std_timer.c
+++ b/net/ax25/ax25_std_timer.c
@@ -14,7 +14,6 @@
 #include <linux/socket.h>
 #include <linux/in.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/net/ax25/ax25_subr.c b/net/ax25/ax25_subr.c
index 85c58c49b4d0..b6c577e3c914 100644
--- a/net/ax25/ax25_subr.c
+++ b/net/ax25/ax25_subr.c
@@ -14,7 +14,6 @@
 #include <linux/socket.h>
 #include <linux/in.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/net/ax25/ax25_uid.c b/net/ax25/ax25_uid.c
index 59a41b1e61f5..75c76647b2cb 100644
--- a/net/ax25/ax25_uid.c
+++ b/net/ax25/ax25_uid.c
@@ -13,7 +13,6 @@
 #include <linux/socket.h>
 #include <linux/in.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/net/ax25/sysctl_net_ax25.c b/net/ax25/sysctl_net_ax25.c
index d23a27f25d2f..443a83676638 100644
--- a/net/ax25/sysctl_net_ax25.c
+++ b/net/ax25/sysctl_net_ax25.c
@@ -245,7 +245,7 @@ void ax25_register_sysctl(void)
 
         ax25_dir_table[0].child = ax25_table;
 
-        ax25_table_header = register_sysctl_table(ax25_root_table, 1);
+        ax25_table_header = register_sysctl_table(ax25_root_table);
 }
 
 void ax25_unregister_sysctl(void)
diff --git a/net/bluetooth/bnep/sock.c b/net/bluetooth/bnep/sock.c
index 6d7311cee1b4..10292e776046 100644
--- a/net/bluetooth/bnep/sock.c
+++ b/net/bluetooth/bnep/sock.c
@@ -34,7 +34,6 @@
 #include <linux/capability.h>
 #include <linux/errno.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/poll.h>
 #include <linux/fcntl.h>
diff --git a/net/bluetooth/cmtp/sock.c b/net/bluetooth/cmtp/sock.c
index 0c5ccd95517f..19be7861e51e 100644
--- a/net/bluetooth/cmtp/sock.c
+++ b/net/bluetooth/cmtp/sock.c
@@ -26,7 +26,6 @@
 #include <linux/capability.h>
 #include <linux/errno.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/poll.h>
 #include <linux/fcntl.h>
diff --git a/net/bluetooth/hci_conn.c b/net/bluetooth/hci_conn.c
index 67ee0bd80f5f..f3403fdb59f8 100644
--- a/net/bluetooth/hci_conn.c
+++ b/net/bluetooth/hci_conn.c
@@ -29,7 +29,6 @@
 #include <linux/types.h>
 #include <linux/errno.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/poll.h>
 #include <linux/fcntl.h>
diff --git a/net/bluetooth/hci_event.c b/net/bluetooth/hci_event.c
index 00d845e3d307..936d3fc479cd 100644
--- a/net/bluetooth/hci_event.c
+++ b/net/bluetooth/hci_event.c
@@ -29,7 +29,6 @@
 #include <linux/types.h>
 #include <linux/errno.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/poll.h>
 #include <linux/fcntl.h>
diff --git a/net/bluetooth/hci_sock.c b/net/bluetooth/hci_sock.c
index dc3ecb19a5cd..f928d2b2a17d 100644
--- a/net/bluetooth/hci_sock.c
+++ b/net/bluetooth/hci_sock.c
@@ -30,7 +30,6 @@
 #include <linux/capability.h>
 #include <linux/errno.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/poll.h>
 #include <linux/fcntl.h>
diff --git a/net/bluetooth/hidp/sock.c b/net/bluetooth/hidp/sock.c
index 33bda40aceb8..8b8a6c1dbd99 100644
--- a/net/bluetooth/hidp/sock.c
+++ b/net/bluetooth/hidp/sock.c
@@ -26,7 +26,6 @@
 #include <linux/capability.h>
 #include <linux/errno.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/poll.h>
 #include <linux/fcntl.h>
diff --git a/net/bridge/br_if.c b/net/bridge/br_if.c
index f35c1a378d0f..aff6a779c9c8 100644
--- a/net/bridge/br_if.c
+++ b/net/bridge/br_if.c
@@ -108,6 +108,7 @@ static void port_carrier_check(struct work_struct *work)
                 spin_unlock_bh(&br->lock);
         }
 done:
+        dev_put(dev);
         rtnl_unlock();
 }
 
@@ -161,7 +162,8 @@ static void del_nbp(struct net_bridge_port *p)
 
         dev_set_promiscuity(dev, -1);
 
-        cancel_delayed_work(&p->carrier_check);
+        if (cancel_delayed_work(&p->carrier_check))
+                dev_put(dev);
 
         spin_lock_bh(&br->lock);
         br_stp_disable_port(p);
@@ -444,7 +446,9 @@ int br_add_if(struct net_bridge *br, struct net_device *dev)
         spin_lock_bh(&br->lock);
         br_stp_recalculate_bridge_id(br);
         br_features_recompute(br);
-        schedule_delayed_work(&p->carrier_check, BR_PORT_DEBOUNCE);
+        if (schedule_delayed_work(&p->carrier_check, BR_PORT_DEBOUNCE))
+                dev_hold(dev);
+
         spin_unlock_bh(&br->lock);
 
         dev_set_mtu(br->dev, br_min_mtu(br));
diff --git a/net/bridge/br_netfilter.c b/net/bridge/br_netfilter.c
index a0744e653f09..7712d76f06ba 100644
--- a/net/bridge/br_netfilter.c
+++ b/net/bridge/br_netfilter.c
@@ -957,7 +957,7 @@ int __init br_netfilter_init(void)
         if (ret < 0)
                 return ret;
 #ifdef CONFIG_SYSCTL
-        brnf_sysctl_header = register_sysctl_table(brnf_net_table, 0);
+        brnf_sysctl_header = register_sysctl_table(brnf_net_table);
         if (brnf_sysctl_header == NULL) {
                 printk(KERN_WARNING
                        "br_netfilter: can't register to sysctl.\n");
diff --git a/net/bridge/br_notify.c b/net/bridge/br_notify.c
index 8cd3e4229070..3311c4e30829 100644
--- a/net/bridge/br_notify.c
+++ b/net/bridge/br_notify.c
@@ -56,7 +56,9 @@ static int br_device_event(struct notifier_block *unused, unsigned long event, v
 
         case NETDEV_CHANGE:
                 if (br->dev->flags & IFF_UP)
-                        schedule_delayed_work(&p->carrier_check, BR_PORT_DEBOUNCE);
+                        if (schedule_delayed_work(&p->carrier_check,
+                                                BR_PORT_DEBOUNCE))
+                                dev_hold(dev);
                 break;
 
         case NETDEV_FEAT_CHANGE:
diff --git a/net/bridge/netfilter/ebtables.c b/net/bridge/netfilter/ebtables.c
index 5818d70b8e8d..34c49799f9b3 100644
--- a/net/bridge/netfilter/ebtables.c
+++ b/net/bridge/netfilter/ebtables.c
@@ -16,7 +16,6 @@
  */
 
 /* used for print_string */
-#include <linux/sched.h>
 #include <linux/tty.h>
 
 #include <linux/kmod.h>
diff --git a/net/compat.c b/net/compat.c
index 9c970749a3b0..1f32866d09b7 100644
--- a/net/compat.c
+++ b/net/compat.c
@@ -13,7 +13,6 @@
 
 #include <linux/kernel.h>
 #include <linux/fs.h>
-#include <linux/sched.h>
 #include <linux/types.h>
 #include <linux/file.h>
 #include <linux/icmpv6.h>
diff --git a/net/core/dev_mcast.c b/net/core/dev_mcast.c
index c4e754e86e96..56b310c0c860 100644
--- a/net/core/dev_mcast.c
+++ b/net/core/dev_mcast.c
@@ -27,7 +27,6 @@
 #include <linux/bitops.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/socket.h>
diff --git a/net/core/dst.c b/net/core/dst.c
index 61dd9d3951f1..764bccb3d992 100644
--- a/net/core/dst.c
+++ b/net/core/dst.c
@@ -12,7 +12,6 @@
 #include <linux/mm.h>
 #include <linux/module.h>
 #include <linux/netdevice.h>
-#include <linux/sched.h>
 #include <linux/skbuff.h>
 #include <linux/string.h>
 #include <linux/types.h>
diff --git a/net/core/filter.c b/net/core/filter.c
index 8123a31d919d..8d185a089c53 100644
--- a/net/core/filter.c
+++ b/net/core/filter.c
@@ -18,7 +18,6 @@
 
 #include <linux/module.h>
 #include <linux/types.h>
-#include <linux/sched.h>
 #include <linux/mm.h>
 #include <linux/fcntl.h>
 #include <linux/socket.h>
diff --git a/net/core/iovec.c b/net/core/iovec.c
index 4fb1cb9b79b9..755c37fdaee7 100644
--- a/net/core/iovec.c
+++ b/net/core/iovec.c
@@ -18,7 +18,6 @@
 
 #include <linux/errno.h>
 #include <linux/module.h>
-#include <linux/sched.h>
 #include <linux/kernel.h>
 #include <linux/mm.h>
 #include <linux/slab.h>
diff --git a/net/core/neighbour.c b/net/core/neighbour.c
index 512eed91785d..3183142c6044 100644
--- a/net/core/neighbour.c
+++ b/net/core/neighbour.c
@@ -19,7 +19,6 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/socket.h>
-#include <linux/sched.h>
 #include <linux/netdevice.h>
 #include <linux/proc_fs.h>
 #ifdef CONFIG_SYSCTL
@@ -2708,7 +2707,7 @@ int neigh_sysctl_register(struct net_device *dev, struct neigh_parms *p,
         t->neigh_proto_dir[0].child    = t->neigh_neigh_dir;
         t->neigh_root_dir[0].child     = t->neigh_proto_dir;
 
-        t->sysctl_header = register_sysctl_table(t->neigh_root_dir, 0);
+        t->sysctl_header = register_sysctl_table(t->neigh_root_dir);
         if (!t->sysctl_header) {
                 err = -ENOBUFS;
                 goto free_procname;
diff --git a/net/core/rtnetlink.c b/net/core/rtnetlink.c
index ee5a787271f6..6055074c4b81 100644
--- a/net/core/rtnetlink.c
+++ b/net/core/rtnetlink.c
@@ -21,7 +21,6 @@
 #include <linux/types.h>
 #include <linux/socket.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/net/core/skbuff.c b/net/core/skbuff.c
index 3d5646869022..f89ff151cfab 100644
--- a/net/core/skbuff.c
+++ b/net/core/skbuff.c
@@ -41,7 +41,6 @@
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/mm.h>
 #include <linux/interrupt.h>
 #include <linux/in.h>
diff --git a/net/dccp/sysctl.c b/net/dccp/sysctl.c
index fdcfca3e9208..1260aabac5e1 100644
--- a/net/dccp/sysctl.c
+++ b/net/dccp/sysctl.c
@@ -127,7 +127,7 @@ static struct ctl_table_header *dccp_table_header;
 
 int __init dccp_sysctl_init(void)
 {
-        dccp_table_header = register_sysctl_table(dccp_root_table, 1);
+        dccp_table_header = register_sysctl_table(dccp_root_table);
 
         return dccp_table_header != NULL ? 0 : -ENOMEM;
 }
diff --git a/net/decnet/dn_dev.c b/net/decnet/dn_dev.c
index 2b2c7fe45a71..060d725e2942 100644
--- a/net/decnet/dn_dev.c
+++ b/net/decnet/dn_dev.c
@@ -261,7 +261,6 @@ static void dn_dev_sysctl_register(struct net_device *dev, struct dn_dev_parms *
         for(i = 0; i < ARRAY_SIZE(t->dn_dev_vars) - 1; i++) {
                 long offset = (long)t->dn_dev_vars[i].data;
                 t->dn_dev_vars[i].data = ((char *)parms) + offset;
-                t->dn_dev_vars[i].de = NULL;
         }
 
         if (dev) {
@@ -273,16 +272,12 @@ static void dn_dev_sysctl_register(struct net_device *dev, struct dn_dev_parms *
         }
 
         t->dn_dev_dev[0].child = t->dn_dev_vars;
-        t->dn_dev_dev[0].de = NULL;
         t->dn_dev_conf_dir[0].child = t->dn_dev_dev;
-        t->dn_dev_conf_dir[0].de = NULL;
         t->dn_dev_proto_dir[0].child = t->dn_dev_conf_dir;
-        t->dn_dev_proto_dir[0].de = NULL;
         t->dn_dev_root_dir[0].child = t->dn_dev_proto_dir;
-        t->dn_dev_root_dir[0].de = NULL;
         t->dn_dev_vars[0].extra1 = (void *)dev;
 
-        t->sysctl_header = register_sysctl_table(t->dn_dev_root_dir, 0);
+        t->sysctl_header = register_sysctl_table(t->dn_dev_root_dir);
         if (t->sysctl_header == NULL)
                 kfree(t);
         else
diff --git a/net/decnet/dn_nsp_in.c b/net/decnet/dn_nsp_in.c
index 0f244e81a377..9d20904f6f52 100644
--- a/net/decnet/dn_nsp_in.c
+++ b/net/decnet/dn_nsp_in.c
@@ -50,7 +50,6 @@
 #include <linux/socket.h>
 #include <linux/in.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/net/decnet/dn_nsp_out.c b/net/decnet/dn_nsp_out.c
index 23d5ca88dfa3..2d2cda82c7db 100644
--- a/net/decnet/dn_nsp_out.c
+++ b/net/decnet/dn_nsp_out.c
@@ -43,7 +43,6 @@
 #include <linux/socket.h>
 #include <linux/in.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/net/decnet/sysctl_net_decnet.c b/net/decnet/sysctl_net_decnet.c
index a6c067b593ab..52e40d7eb22d 100644
--- a/net/decnet/sysctl_net_decnet.c
+++ b/net/decnet/sysctl_net_decnet.c
@@ -491,7 +491,7 @@ static ctl_table dn_root_table[] = {
 
 void dn_register_sysctl(void)
 {
-        dn_table_header = register_sysctl_table(dn_root_table, 1);
+        dn_table_header = register_sysctl_table(dn_root_table);
 }
 
 void dn_unregister_sysctl(void)
diff --git a/net/econet/af_econet.c b/net/econet/af_econet.c
index f2ce41434290..bc12e36263f0 100644
--- a/net/econet/af_econet.c
+++ b/net/econet/af_econet.c
@@ -13,7 +13,6 @@
 
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/socket.h>
diff --git a/net/ethernet/eth.c b/net/ethernet/eth.c
index 766a0b59c0d3..7391f55904d1 100644
--- a/net/ethernet/eth.c
+++ b/net/ethernet/eth.c
@@ -40,7 +40,6 @@
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/socket.h>
diff --git a/net/ipv4/arp.c b/net/ipv4/arp.c
index 0ffd2d2920c3..1a3488a83f49 100644
--- a/net/ipv4/arp.c
+++ b/net/ipv4/arp.c
@@ -78,7 +78,6 @@
 #include <linux/types.h>
 #include <linux/string.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/capability.h>
 #include <linux/socket.h>
 #include <linux/sockios.h>
diff --git a/net/ipv4/devinet.c b/net/ipv4/devinet.c
index ba5e7f4cd127..8a0ec10a13a7 100644
--- a/net/ipv4/devinet.c
+++ b/net/ipv4/devinet.c
@@ -35,7 +35,6 @@
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/socket.h>
@@ -1577,7 +1576,6 @@ static void devinet_sysctl_register(struct in_device *in_dev,
                 return;
         for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
                 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
-                t->devinet_vars[i].de = NULL;
         }
 
         if (dev) {
@@ -1599,15 +1597,11 @@ static void devinet_sysctl_register(struct in_device *in_dev,
 
         t->devinet_dev[0].procname    = dev_name;
         t->devinet_dev[0].child       = t->devinet_vars;
-        t->devinet_dev[0].de          = NULL;
         t->devinet_conf_dir[0].child  = t->devinet_dev;
-        t->devinet_conf_dir[0].de     = NULL;
         t->devinet_proto_dir[0].child = t->devinet_conf_dir;
-        t->devinet_proto_dir[0].de    = NULL;
         t->devinet_root_dir[0].child  = t->devinet_proto_dir;
-        t->devinet_root_dir[0].de     = NULL;
 
-        t->sysctl_header = register_sysctl_table(t->devinet_root_dir, 0);
+        t->sysctl_header = register_sysctl_table(t->devinet_root_dir);
         if (!t->sysctl_header)
             goto free_procname;
 
@@ -1641,7 +1635,7 @@ void __init devinet_init(void)
         rtnetlink_links[PF_INET] = inet_rtnetlink_table;
 #ifdef CONFIG_SYSCTL
         devinet_sysctl.sysctl_header =
-                register_sysctl_table(devinet_sysctl.devinet_root_dir, 0);
+                register_sysctl_table(devinet_sysctl.devinet_root_dir);
         devinet_sysctl_register(NULL, &ipv4_devconf_dflt);
 #endif
 }
diff --git a/net/ipv4/fib_frontend.c b/net/ipv4/fib_frontend.c
index 64f31e63db7f..1fba6439fc57 100644
--- a/net/ipv4/fib_frontend.c
+++ b/net/ipv4/fib_frontend.c
@@ -22,7 +22,6 @@
 #include <linux/capability.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/mm.h>
 #include <linux/string.h>
 #include <linux/socket.h>
diff --git a/net/ipv4/fib_hash.c b/net/ipv4/fib_hash.c
index b21bb28d1fd0..a4949f957ab5 100644
--- a/net/ipv4/fib_hash.c
+++ b/net/ipv4/fib_hash.c
@@ -20,7 +20,6 @@
 #include <linux/bitops.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/mm.h>
 #include <linux/string.h>
 #include <linux/socket.h>
diff --git a/net/ipv4/fib_trie.c b/net/ipv4/fib_trie.c
index c33dca073801..72b3036bbc09 100644
--- a/net/ipv4/fib_trie.c
+++ b/net/ipv4/fib_trie.c
@@ -57,7 +57,6 @@
 #include <asm/bitops.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/mm.h>
 #include <linux/string.h>
 #include <linux/socket.h>
diff --git a/net/ipv4/inetpeer.c b/net/ipv4/inetpeer.c
index 711eb6d0285a..db3ef96bdfd9 100644
--- a/net/ipv4/inetpeer.c
+++ b/net/ipv4/inetpeer.c
@@ -14,7 +14,6 @@
 #include <linux/interrupt.h>
 #include <linux/spinlock.h>
 #include <linux/random.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/time.h>
 #include <linux/kernel.h>
diff --git a/net/ipv4/ip_forward.c b/net/ipv4/ip_forward.c
index c3ea0cd2e584..369e721c4bab 100644
--- a/net/ipv4/ip_forward.c
+++ b/net/ipv4/ip_forward.c
@@ -23,7 +23,6 @@
 
 #include <linux/types.h>
 #include <linux/mm.h>
-#include <linux/sched.h>
 #include <linux/skbuff.h>
 #include <linux/ip.h>
 #include <linux/icmp.h>
diff --git a/net/ipv4/ip_gre.c b/net/ipv4/ip_gre.c
index f12c0d6623a0..9151da642318 100644
--- a/net/ipv4/ip_gre.c
+++ b/net/ipv4/ip_gre.c
@@ -13,7 +13,6 @@
 #include <linux/capability.h>
 #include <linux/module.h>
 #include <linux/types.h>
-#include <linux/sched.h>
 #include <linux/kernel.h>
 #include <asm/uaccess.h>
 #include <linux/skbuff.h>
diff --git a/net/ipv4/ip_output.c b/net/ipv4/ip_output.c
index bb0bb8f07c54..d096332f6c6d 100644
--- a/net/ipv4/ip_output.c
+++ b/net/ipv4/ip_output.c
@@ -49,7 +49,6 @@
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/mm.h>
 #include <linux/string.h>
 #include <linux/errno.h>
diff --git a/net/ipv4/ip_sockglue.c b/net/ipv4/ip_sockglue.c
index e120686c3cb8..23048d9f3584 100644
--- a/net/ipv4/ip_sockglue.c
+++ b/net/ipv4/ip_sockglue.c
@@ -20,7 +20,6 @@
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/mm.h>
-#include <linux/sched.h>
 #include <linux/skbuff.h>
 #include <linux/ip.h>
 #include <linux/icmp.h>
diff --git a/net/ipv4/ipip.c b/net/ipv4/ipip.c
index 475bcd1e4181..3ec5ce0f5498 100644
--- a/net/ipv4/ipip.c
+++ b/net/ipv4/ipip.c
@@ -96,7 +96,6 @@
 #include <linux/capability.h>
 #include <linux/module.h>
 #include <linux/types.h>
-#include <linux/sched.h>
 #include <linux/kernel.h>
 #include <asm/uaccess.h>
 #include <linux/skbuff.h>
@@ -871,7 +870,7 @@ static int __init ipip_init(void)
 
         printk(banner);
 
-        if (xfrm4_tunnel_register(&ipip_handler)) {
+        if (xfrm4_tunnel_register(&ipip_handler, AF_INET)) {
                 printk(KERN_INFO "ipip init: can't register tunnel\n");
                 return -EAGAIN;
         }
@@ -893,7 +892,7 @@ static int __init ipip_init(void)
  err2:
         free_netdev(ipip_fb_tunnel_dev);
  err1:
-        xfrm4_tunnel_deregister(&ipip_handler);
+        xfrm4_tunnel_deregister(&ipip_handler, AF_INET);
         goto out;
 }
 
@@ -913,7 +912,7 @@ static void __exit ipip_destroy_tunnels(void)
 
 static void __exit ipip_fini(void)
 {
-        if (xfrm4_tunnel_deregister(&ipip_handler))
+        if (xfrm4_tunnel_deregister(&ipip_handler, AF_INET))
                 printk(KERN_INFO "ipip close: can't deregister tunnel\n");
 
         rtnl_lock();
diff --git a/net/ipv4/ipmr.c b/net/ipv4/ipmr.c
index e6d11abd7841..601e3df69258 100644
--- a/net/ipv4/ipmr.c
+++ b/net/ipv4/ipmr.c
@@ -31,7 +31,6 @@
 #include <asm/system.h>
 #include <asm/uaccess.h>
 #include <linux/types.h>
-#include <linux/sched.h>
 #include <linux/capability.h>
 #include <linux/errno.h>
 #include <linux/timer.h>
diff --git a/net/ipv4/ipvs/ip_vs_ctl.c b/net/ipv4/ipvs/ip_vs_ctl.c
index 8b08d9cdcbc8..b3050a6817e7 100644
--- a/net/ipv4/ipvs/ip_vs_ctl.c
+++ b/net/ipv4/ipvs/ip_vs_ctl.c
@@ -2359,7 +2359,7 @@ int ip_vs_control_init(void)
         proc_net_fops_create("ip_vs", 0, &ip_vs_info_fops);
         proc_net_fops_create("ip_vs_stats",0, &ip_vs_stats_fops);
 
-        sysctl_header = register_sysctl_table(vs_root_table, 0);
+        sysctl_header = register_sysctl_table(vs_root_table);
 
         /* Initialize ip_vs_svc_table, ip_vs_svc_fwm_table, ip_vs_rtable */
         for(idx = 0; idx < IP_VS_SVC_TAB_SIZE; idx++)  {
diff --git a/net/ipv4/ipvs/ip_vs_lblc.c b/net/ipv4/ipvs/ip_vs_lblc.c
index 76fd1fb91878..c801273cb881 100644
--- a/net/ipv4/ipvs/ip_vs_lblc.c
+++ b/net/ipv4/ipvs/ip_vs_lblc.c
@@ -583,7 +583,7 @@ static struct ip_vs_scheduler ip_vs_lblc_scheduler =
 static int __init ip_vs_lblc_init(void)
 {
         INIT_LIST_HEAD(&ip_vs_lblc_scheduler.n_list);
-        sysctl_header = register_sysctl_table(lblc_root_table, 0);
+        sysctl_header = register_sysctl_table(lblc_root_table);
         return register_ip_vs_scheduler(&ip_vs_lblc_scheduler);
 }
 
diff --git a/net/ipv4/ipvs/ip_vs_lblcr.c b/net/ipv4/ipvs/ip_vs_lblcr.c
index bf1e7f272b84..23f9b9e73c85 100644
--- a/net/ipv4/ipvs/ip_vs_lblcr.c
+++ b/net/ipv4/ipvs/ip_vs_lblcr.c
@@ -841,7 +841,7 @@ static struct ip_vs_scheduler ip_vs_lblcr_scheduler =
 static int __init ip_vs_lblcr_init(void)
 {
         INIT_LIST_HEAD(&ip_vs_lblcr_scheduler.n_list);
-        sysctl_header = register_sysctl_table(lblcr_root_table, 0);
+        sysctl_header = register_sysctl_table(lblcr_root_table);
 #ifdef CONFIG_IP_VS_LBLCR_DEBUG
         proc_net_create("ip_vs_lblcr", 0, ip_vs_lblcr_getinfo);
 #endif
diff --git a/net/ipv4/ipvs/ip_vs_sched.c b/net/ipv4/ipvs/ip_vs_sched.c
index 8bc42b76223d..1602304abbf9 100644
--- a/net/ipv4/ipvs/ip_vs_sched.c
+++ b/net/ipv4/ipvs/ip_vs_sched.c
@@ -20,7 +20,6 @@
  */
 
 #include <linux/module.h>
-#include <linux/sched.h>
 #include <linux/spinlock.h>
 #include <linux/interrupt.h>
 #include <asm/string.h>
diff --git a/net/ipv4/multipath_drr.c b/net/ipv4/multipath_drr.c
index cb8fce467349..574c735836fc 100644
--- a/net/ipv4/multipath_drr.c
+++ b/net/ipv4/multipath_drr.c
@@ -15,7 +15,6 @@
 #include <asm/system.h>
 #include <asm/uaccess.h>
 #include <linux/types.h>
-#include <linux/sched.h>
 #include <linux/errno.h>
 #include <linux/timer.h>
 #include <linux/mm.h>
diff --git a/net/ipv4/multipath_random.c b/net/ipv4/multipath_random.c
index 047e861f06bd..57f481498fbb 100644
--- a/net/ipv4/multipath_random.c
+++ b/net/ipv4/multipath_random.c
@@ -15,7 +15,6 @@
 #include <asm/system.h>
 #include <asm/uaccess.h>
 #include <linux/types.h>
-#include <linux/sched.h>
 #include <linux/errno.h>
 #include <linux/timer.h>
 #include <linux/mm.h>
diff --git a/net/ipv4/multipath_rr.c b/net/ipv4/multipath_rr.c
index 896246d8040e..0ad22524f450 100644
--- a/net/ipv4/multipath_rr.c
+++ b/net/ipv4/multipath_rr.c
@@ -15,7 +15,6 @@
 #include <asm/system.h>
 #include <asm/uaccess.h>
 #include <linux/types.h>
-#include <linux/sched.h>
 #include <linux/errno.h>
 #include <linux/timer.h>
 #include <linux/mm.h>
diff --git a/net/ipv4/multipath_wrandom.c b/net/ipv4/multipath_wrandom.c
index 7e22f15d13df..2bdbb92b450a 100644
--- a/net/ipv4/multipath_wrandom.c
+++ b/net/ipv4/multipath_wrandom.c
@@ -15,7 +15,6 @@
 #include <asm/system.h>
 #include <asm/uaccess.h>
 #include <linux/types.h>
-#include <linux/sched.h>
 #include <linux/errno.h>
 #include <linux/timer.h>
 #include <linux/mm.h>
diff --git a/net/ipv4/netfilter/ip_conntrack_proto_generic.c b/net/ipv4/netfilter/ip_conntrack_proto_generic.c
index 36f2b5e5d80a..88af82e98658 100644
--- a/net/ipv4/netfilter/ip_conntrack_proto_generic.c
+++ b/net/ipv4/netfilter/ip_conntrack_proto_generic.c
@@ -7,7 +7,6 @@
  */
 
 #include <linux/types.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/netfilter.h>
 #include <linux/netfilter_ipv4/ip_conntrack_protocol.h>
diff --git a/net/ipv4/netfilter/ip_conntrack_proto_icmp.c b/net/ipv4/netfilter/ip_conntrack_proto_icmp.c
index ec71abead00c..ad70c81a21e0 100644
--- a/net/ipv4/netfilter/ip_conntrack_proto_icmp.c
+++ b/net/ipv4/netfilter/ip_conntrack_proto_icmp.c
@@ -7,7 +7,6 @@
  */
 
 #include <linux/types.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/netfilter.h>
 #include <linux/in.h>
diff --git a/net/ipv4/netfilter/ip_conntrack_proto_sctp.c b/net/ipv4/netfilter/ip_conntrack_proto_sctp.c
index 9d5b917f49cd..e6942992b2f6 100644
--- a/net/ipv4/netfilter/ip_conntrack_proto_sctp.c
+++ b/net/ipv4/netfilter/ip_conntrack_proto_sctp.c
@@ -14,7 +14,6 @@
  */
 
 #include <linux/types.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/interrupt.h>
 #include <linux/netfilter.h>
@@ -623,7 +622,7 @@ static int __init ip_conntrack_proto_sctp_init(void)
         }
 
 #ifdef CONFIG_SYSCTL
-        ip_ct_sysctl_header = register_sysctl_table(ip_ct_net_table, 0);
+        ip_ct_sysctl_header = register_sysctl_table(ip_ct_net_table);
         if (ip_ct_sysctl_header == NULL) {
                 ret = -ENOMEM;
                 printk("ip_conntrack_proto_sctp: can't register to sysctl.\n");
diff --git a/net/ipv4/netfilter/ip_conntrack_proto_tcp.c b/net/ipv4/netfilter/ip_conntrack_proto_tcp.c
index fa35b49fe2fa..170d625fad67 100644
--- a/net/ipv4/netfilter/ip_conntrack_proto_tcp.c
+++ b/net/ipv4/netfilter/ip_conntrack_proto_tcp.c
@@ -20,7 +20,6 @@
  */
 
 #include <linux/types.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/netfilter.h>
 #include <linux/module.h>
diff --git a/net/ipv4/netfilter/ip_conntrack_proto_udp.c b/net/ipv4/netfilter/ip_conntrack_proto_udp.c
index a99a7c75e5b5..14c30c646c7f 100644
--- a/net/ipv4/netfilter/ip_conntrack_proto_udp.c
+++ b/net/ipv4/netfilter/ip_conntrack_proto_udp.c
@@ -7,7 +7,6 @@
  */
 
 #include <linux/types.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/netfilter.h>
 #include <linux/in.h>
diff --git a/net/ipv4/netfilter/ip_conntrack_standalone.c b/net/ipv4/netfilter/ip_conntrack_standalone.c
index c7c1ec61b0f5..56b2f7546d1e 100644
--- a/net/ipv4/netfilter/ip_conntrack_standalone.c
+++ b/net/ipv4/netfilter/ip_conntrack_standalone.c
@@ -848,7 +848,7 @@ static int __init ip_conntrack_standalone_init(void)
                 goto cleanup_proc_stat;
         }
 #ifdef CONFIG_SYSCTL
-        ip_ct_sysctl_header = register_sysctl_table(ip_ct_net_table, 0);
+        ip_ct_sysctl_header = register_sysctl_table(ip_ct_net_table);
         if (ip_ct_sysctl_header == NULL) {
                 printk("ip_conntrack: can't register to sysctl.\n");
                 ret = -ENOMEM;
diff --git a/net/ipv4/netfilter/ip_queue.c b/net/ipv4/netfilter/ip_queue.c
index 68bf19f3b01c..a14798a850d7 100644
--- a/net/ipv4/netfilter/ip_queue.c
+++ b/net/ipv4/netfilter/ip_queue.c
@@ -693,7 +693,7 @@ static int __init ip_queue_init(void)
         }
 
         register_netdevice_notifier(&ipq_dev_notifier);
-        ipq_sysctl_header = register_sysctl_table(ipq_root_table, 0);
+        ipq_sysctl_header = register_sysctl_table(ipq_root_table);
 
         status = nf_register_queue_handler(PF_INET, &nfqh);
         if (status < 0) {
diff --git a/net/ipv4/netfilter/ipt_REJECT.c b/net/ipv4/netfilter/ipt_REJECT.c
index a9eb3635fff2..80f739e21824 100644
--- a/net/ipv4/netfilter/ipt_REJECT.c
+++ b/net/ipv4/netfilter/ipt_REJECT.c
@@ -80,6 +80,10 @@ static void send_reset(struct sk_buff *oldskb, int hook)
         nskb->mark = 0;
         skb_init_secmark(nskb);
 
+        skb_shinfo(nskb)->gso_size = 0;
+        skb_shinfo(nskb)->gso_segs = 0;
+        skb_shinfo(nskb)->gso_type = 0;
+
         tcph = (struct tcphdr *)((u_int32_t*)nskb->nh.iph + nskb->nh.iph->ihl);
 
         /* Swap source and dest */
diff --git a/net/ipv4/netfilter/nf_conntrack_proto_icmp.c b/net/ipv4/netfilter/nf_conntrack_proto_icmp.c
index e5aa4d849b00..88cfa6aacfc1 100644
--- a/net/ipv4/netfilter/nf_conntrack_proto_icmp.c
+++ b/net/ipv4/netfilter/nf_conntrack_proto_icmp.c
@@ -12,7 +12,6 @@
  */
 
 #include <linux/types.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/netfilter.h>
 #include <linux/in.h>
diff --git a/net/ipv4/protocol.c b/net/ipv4/protocol.c
index 6cd6340de8bd..da70fef82c93 100644
--- a/net/ipv4/protocol.c
+++ b/net/ipv4/protocol.c
@@ -30,7 +30,6 @@
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/socket.h>
 #include <linux/in.h>
diff --git a/net/ipv4/route.c b/net/ipv4/route.c
index 9b5e56481d53..37e0d4d5cf94 100644
--- a/net/ipv4/route.c
+++ b/net/ipv4/route.c
@@ -70,7 +70,6 @@
 #include <linux/bitops.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/mm.h>
 #include <linux/bootmem.h>
 #include <linux/string.h>
diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index cebe9aa918a3..dc151139b5af 100644
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -481,7 +481,7 @@ static int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it,
                 /* RFC1323: The window in SYN & SYN/ACK segments
                  * is never scaled.
                  */
-                th->window      = htons(tp->rcv_wnd);
+                th->window      = htons(min(tp->rcv_wnd, 65535U));
         } else {
                 th->window      = htons(tcp_select_window(sk));
         }
@@ -2160,7 +2160,7 @@ struct sk_buff * tcp_make_synack(struct sock *sk, struct dst_entry *dst,
         }
 
         /* RFC1323: The window in SYN & SYN/ACK segments is never scaled. */
-        th->window = htons(req->rcv_wnd);
+        th->window = htons(min(req->rcv_wnd, 65535U));
 
         TCP_SKB_CB(skb)->when = tcp_time_stamp;
         tcp_syn_build_options((__be32 *)(th + 1), dst_metric(dst, RTAX_ADVMSS), ireq->tstamp_ok,
diff --git a/net/ipv4/tunnel4.c b/net/ipv4/tunnel4.c
index 8d30c48f090e..a794a8ca8b4f 100644
--- a/net/ipv4/tunnel4.c
+++ b/net/ipv4/tunnel4.c
@@ -14,9 +14,10 @@
 #include <net/xfrm.h>
 
 static struct xfrm_tunnel *tunnel4_handlers;
+static struct xfrm_tunnel *tunnel64_handlers;
 static DEFINE_MUTEX(tunnel4_mutex);
 
-int xfrm4_tunnel_register(struct xfrm_tunnel *handler)
+int xfrm4_tunnel_register(struct xfrm_tunnel *handler, unsigned short family)
 {
         struct xfrm_tunnel **pprev;
         int ret = -EEXIST;
@@ -24,7 +25,8 @@ int xfrm4_tunnel_register(struct xfrm_tunnel *handler)
 
         mutex_lock(&tunnel4_mutex);
 
-        for (pprev = &tunnel4_handlers; *pprev; pprev = &(*pprev)->next) {
+        for (pprev = (family == AF_INET) ? &tunnel4_handlers : &tunnel64_handlers;
+             *pprev; pprev = &(*pprev)->next) {
                 if ((*pprev)->priority > priority)
                         break;
                 if ((*pprev)->priority == priority)
@@ -44,14 +46,15 @@ err:
 
 EXPORT_SYMBOL(xfrm4_tunnel_register);
 
-int xfrm4_tunnel_deregister(struct xfrm_tunnel *handler)
+int xfrm4_tunnel_deregister(struct xfrm_tunnel *handler, unsigned short family)
 {
         struct xfrm_tunnel **pprev;
         int ret = -ENOENT;
 
         mutex_lock(&tunnel4_mutex);
 
-        for (pprev = &tunnel4_handlers; *pprev; pprev = &(*pprev)->next) {
+        for (pprev = (family == AF_INET) ? &tunnel4_handlers : &tunnel64_handlers;
+             *pprev; pprev = &(*pprev)->next) {
                 if (*pprev == handler) {
                         *pprev = handler->next;
                         ret = 0;
@@ -86,6 +89,26 @@ drop:
         return 0;
 }
 
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
+static int tunnel64_rcv(struct sk_buff *skb)
+{
+        struct xfrm_tunnel *handler;
+
+        if (!pskb_may_pull(skb, sizeof(struct iphdr)))
+                goto drop;
+
+        for (handler = tunnel64_handlers; handler; handler = handler->next)
+                if (!handler->handler(skb))
+                        return 0;
+
+        icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
+
+drop:
+        kfree_skb(skb);
+        return 0;
+}
+#endif
+
 static void tunnel4_err(struct sk_buff *skb, u32 info)
 {
         struct xfrm_tunnel *handler;
@@ -101,17 +124,36 @@ static struct net_protocol tunnel4_protocol = {
         .no_policy      =       1,
 };
 
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
+static struct net_protocol tunnel64_protocol = {
+        .handler        =       tunnel64_rcv,
+        .err_handler    =       tunnel4_err,
+        .no_policy      =       1,
+};
+#endif
+
 static int __init tunnel4_init(void)
 {
         if (inet_add_protocol(&tunnel4_protocol, IPPROTO_IPIP)) {
                 printk(KERN_ERR "tunnel4 init: can't add protocol\n");
                 return -EAGAIN;
         }
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
+        if (inet_add_protocol(&tunnel64_protocol, IPPROTO_IPV6)) {
+                printk(KERN_ERR "tunnel64 init: can't add protocol\n");
+                inet_del_protocol(&tunnel4_protocol, IPPROTO_IPIP);
+                return -EAGAIN;
+        }
+#endif
         return 0;
 }
 
 static void __exit tunnel4_fini(void)
 {
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
+        if (inet_del_protocol(&tunnel64_protocol, IPPROTO_IPV6))
+                printk(KERN_ERR "tunnel64 close: can't remove protocol\n");
+#endif
         if (inet_del_protocol(&tunnel4_protocol, IPPROTO_IPIP))
                 printk(KERN_ERR "tunnel4 close: can't remove protocol\n");
 }
diff --git a/net/ipv4/xfrm4_input.c b/net/ipv4/xfrm4_input.c
index 289146bdb8b0..78e80deb7e89 100644
--- a/net/ipv4/xfrm4_input.c
+++ b/net/ipv4/xfrm4_input.c
@@ -27,6 +27,7 @@ static int xfrm4_parse_spi(struct sk_buff *skb, u8 nexthdr, __be32 *spi, __be32
 {
         switch (nexthdr) {
         case IPPROTO_IPIP:
+        case IPPROTO_IPV6:
                 *spi = skb->nh.iph->saddr;
                 *seq = 0;
                 return 0;
@@ -70,7 +71,8 @@ int xfrm4_rcv_encap(struct sk_buff *skb, __u16 encap_type)
                 if (xfrm_nr == XFRM_MAX_DEPTH)
                         goto drop;
 
-                x = xfrm_state_lookup((xfrm_address_t *)&iph->daddr, spi, iph->protocol, AF_INET);
+                x = xfrm_state_lookup((xfrm_address_t *)&iph->daddr, spi,
+                                iph->protocol != IPPROTO_IPV6 ? iph->protocol : IPPROTO_IPIP, AF_INET);
                 if (x == NULL)
                         goto drop;
 
diff --git a/net/ipv4/xfrm4_mode_tunnel.c b/net/ipv4/xfrm4_mode_tunnel.c
index e54c5494c88f..e1cab33fdad1 100644
--- a/net/ipv4/xfrm4_mode_tunnel.c
+++ b/net/ipv4/xfrm4_mode_tunnel.c
@@ -95,6 +95,7 @@ static int xfrm4_tunnel_input(struct xfrm_state *x, struct sk_buff *skb)
 
         switch(iph->protocol){
                 case IPPROTO_IPIP:
+                        break;
 #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
                 case IPPROTO_IPV6:
                         break;
diff --git a/net/ipv4/xfrm4_tunnel.c b/net/ipv4/xfrm4_tunnel.c
index 1be6762b2d47..3eef06454da9 100644
--- a/net/ipv4/xfrm4_tunnel.c
+++ b/net/ipv4/xfrm4_tunnel.c
@@ -64,24 +64,45 @@ static struct xfrm_tunnel xfrm_tunnel_handler = {
         .priority       =       2,
 };
 
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
+static struct xfrm_tunnel xfrm64_tunnel_handler = {
+        .handler        =       xfrm4_rcv,
+        .err_handler    =       xfrm_tunnel_err,
+        .priority       =       2,
+};
+#endif
+
 static int __init ipip_init(void)
 {
         if (xfrm_register_type(&ipip_type, AF_INET) < 0) {
                 printk(KERN_INFO "ipip init: can't add xfrm type\n");
                 return -EAGAIN;
         }
-        if (xfrm4_tunnel_register(&xfrm_tunnel_handler)) {
-                printk(KERN_INFO "ipip init: can't add xfrm handler\n");
+
+        if (xfrm4_tunnel_register(&xfrm_tunnel_handler, AF_INET)) {
+                printk(KERN_INFO "ipip init: can't add xfrm handler for AF_INET\n");
+                xfrm_unregister_type(&ipip_type, AF_INET);
+                return -EAGAIN;
+        }
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
+        if (xfrm4_tunnel_register(&xfrm64_tunnel_handler, AF_INET6)) {
+                printk(KERN_INFO "ipip init: can't add xfrm handler for AF_INET6\n");
+                xfrm4_tunnel_deregister(&xfrm_tunnel_handler, AF_INET);
                 xfrm_unregister_type(&ipip_type, AF_INET);
                 return -EAGAIN;
         }
+#endif
         return 0;
 }
 
 static void __exit ipip_fini(void)
 {
-        if (xfrm4_tunnel_deregister(&xfrm_tunnel_handler))
-                printk(KERN_INFO "ipip close: can't remove xfrm handler\n");
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
+        if (xfrm4_tunnel_deregister(&xfrm64_tunnel_handler, AF_INET6))
+                printk(KERN_INFO "ipip close: can't remove xfrm handler for AF_INET6\n");
+#endif
+        if (xfrm4_tunnel_deregister(&xfrm_tunnel_handler, AF_INET))
+                printk(KERN_INFO "ipip close: can't remove xfrm handler for AF_INET\n");
         if (xfrm_unregister_type(&ipip_type, AF_INET) < 0)
                 printk(KERN_INFO "ipip close: can't remove xfrm type\n");
 }
diff --git a/net/ipv6/Kconfig b/net/ipv6/Kconfig
index deb4101a2a81..79682efb14be 100644
--- a/net/ipv6/Kconfig
+++ b/net/ipv6/Kconfig
@@ -156,6 +156,7 @@ config INET6_XFRM_MODE_ROUTEOPTIMIZATION
 config IPV6_SIT
         tristate "IPv6: IPv6-in-IPv4 tunnel (SIT driver)"
         depends on IPV6
+        select INET_TUNNEL
         default y
         ---help---
           Tunneling means encapsulating data of one protocol type within
diff --git a/net/ipv6/addrconf.c b/net/ipv6/addrconf.c
index ea0755b09033..569a37d698f7 100644
--- a/net/ipv6/addrconf.c
+++ b/net/ipv6/addrconf.c
@@ -44,7 +44,6 @@
 #include <linux/types.h>
 #include <linux/socket.h>
 #include <linux/sockios.h>
-#include <linux/sched.h>
 #include <linux/net.h>
 #include <linux/in6.h>
 #include <linux/netdevice.h>
@@ -3999,7 +3998,6 @@ static void addrconf_sysctl_register(struct inet6_dev *idev, struct ipv6_devconf
                 return;
         for (i=0; t->addrconf_vars[i].data; i++) {
                 t->addrconf_vars[i].data += (char*)p - (char*)&ipv6_devconf;
-                t->addrconf_vars[i].de = NULL;
                 t->addrconf_vars[i].extra1 = idev; /* embedded; no ref */
         }
         if (dev) {
@@ -4022,15 +4020,11 @@ static void addrconf_sysctl_register(struct inet6_dev *idev, struct ipv6_devconf
         t->addrconf_dev[0].procname = dev_name;
 
         t->addrconf_dev[0].child = t->addrconf_vars;
-        t->addrconf_dev[0].de = NULL;
         t->addrconf_conf_dir[0].child = t->addrconf_dev;
-        t->addrconf_conf_dir[0].de = NULL;
         t->addrconf_proto_dir[0].child = t->addrconf_conf_dir;
-        t->addrconf_proto_dir[0].de = NULL;
         t->addrconf_root_dir[0].child = t->addrconf_proto_dir;
-        t->addrconf_root_dir[0].de = NULL;
 
-        t->sysctl_header = register_sysctl_table(t->addrconf_root_dir, 0);
+        t->sysctl_header = register_sysctl_table(t->addrconf_root_dir);
         if (t->sysctl_header == NULL)
                 goto free_procname;
         else
@@ -4115,7 +4109,7 @@ int __init addrconf_init(void)
         rtnetlink_links[PF_INET6] = inet6_rtnetlink_table;
 #ifdef CONFIG_SYSCTL
         addrconf_sysctl.sysctl_header =
-                register_sysctl_table(addrconf_sysctl.addrconf_root_dir, 0);
+                register_sysctl_table(addrconf_sysctl.addrconf_root_dir);
         addrconf_sysctl_register(NULL, &ipv6_devconf_dflt);
 #endif
 
diff --git a/net/ipv6/af_inet6.c b/net/ipv6/af_inet6.c
index a006d242be76..3585d8fa7f02 100644
--- a/net/ipv6/af_inet6.c
+++ b/net/ipv6/af_inet6.c
@@ -28,7 +28,6 @@
 #include <linux/socket.h>
 #include <linux/in.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/net/ipv6/anycast.c b/net/ipv6/anycast.c
index 6fb2e9d716c0..e5ef5979ade4 100644
--- a/net/ipv6/anycast.c
+++ b/net/ipv6/anycast.c
@@ -21,7 +21,6 @@
 #include <linux/string.h>
 #include <linux/socket.h>
 #include <linux/sockios.h>
-#include <linux/sched.h>
 #include <linux/net.h>
 #include <linux/in6.h>
 #include <linux/netdevice.h>
diff --git a/net/ipv6/datagram.c b/net/ipv6/datagram.c
index 5f54dec3e205..3b4e8dcf4c86 100644
--- a/net/ipv6/datagram.c
+++ b/net/ipv6/datagram.c
@@ -17,7 +17,6 @@
 #include <linux/errno.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/interrupt.h>
 #include <linux/socket.h>
 #include <linux/sockios.h>
diff --git a/net/ipv6/exthdrs.c b/net/ipv6/exthdrs.c
index 08313efc48c8..28e0c6568272 100644
--- a/net/ipv6/exthdrs.c
+++ b/net/ipv6/exthdrs.c
@@ -27,7 +27,6 @@
 #include <linux/types.h>
 #include <linux/socket.h>
 #include <linux/sockios.h>
-#include <linux/sched.h>
 #include <linux/net.h>
 #include <linux/netdevice.h>
 #include <linux/in6.h>
diff --git a/net/ipv6/icmp.c b/net/ipv6/icmp.c
index 9377fea02682..edfe98bf64c3 100644
--- a/net/ipv6/icmp.c
+++ b/net/ipv6/icmp.c
@@ -37,7 +37,6 @@
 #include <linux/socket.h>
 #include <linux/in.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/sockios.h>
 #include <linux/net.h>
 #include <linux/skbuff.h>
diff --git a/net/ipv6/inet6_hashtables.c b/net/ipv6/inet6_hashtables.c
index 30b16da739c2..ae6b0e7eb488 100644
--- a/net/ipv6/inet6_hashtables.c
+++ b/net/ipv6/inet6_hashtables.c
@@ -172,7 +172,7 @@ static int __inet6_check_established(struct inet_timewait_death_row *death_row,
         const struct in6_addr *saddr = &np->daddr;
         const int dif = sk->sk_bound_dev_if;
         const __portpair ports = INET_COMBINED_PORTS(inet->dport, lport);
-        const unsigned int hash = inet6_ehashfn(daddr, inet->num, saddr,
+        const unsigned int hash = inet6_ehashfn(daddr, lport, saddr,
                                                 inet->dport);
         struct inet_ehash_bucket *head = inet_ehash_bucket(hinfo, hash);
         struct sock *sk2;
diff --git a/net/ipv6/ip6_input.c b/net/ipv6/ip6_input.c
index 4fdded0e545a..11bfc7c43182 100644
--- a/net/ipv6/ip6_input.c
+++ b/net/ipv6/ip6_input.c
@@ -25,7 +25,6 @@
 #include <linux/types.h>
 #include <linux/socket.h>
 #include <linux/sockios.h>
-#include <linux/sched.h>
 #include <linux/net.h>
 #include <linux/netdevice.h>
 #include <linux/in6.h>
diff --git a/net/ipv6/ip6_tunnel.c b/net/ipv6/ip6_tunnel.c
index 367b74832986..662edb826899 100644
--- a/net/ipv6/ip6_tunnel.c
+++ b/net/ipv6/ip6_tunnel.c
@@ -1128,7 +1128,7 @@ static int __init ip6_tunnel_init(void)
 {
         int  err;
 
-        if (xfrm6_tunnel_register(&ip6ip6_handler)) {
+        if (xfrm6_tunnel_register(&ip6ip6_handler, AF_INET6)) {
                 printk(KERN_ERR "ip6ip6 init: can't register tunnel\n");
                 return -EAGAIN;
         }
@@ -1147,7 +1147,7 @@ static int __init ip6_tunnel_init(void)
         }
         return 0;
 fail:
-        xfrm6_tunnel_deregister(&ip6ip6_handler);
+        xfrm6_tunnel_deregister(&ip6ip6_handler, AF_INET6);
         return err;
 }
 
@@ -1171,7 +1171,7 @@ static void __exit ip6ip6_destroy_tunnels(void)
 
 static void __exit ip6_tunnel_cleanup(void)
 {
-        if (xfrm6_tunnel_deregister(&ip6ip6_handler))
+        if (xfrm6_tunnel_deregister(&ip6ip6_handler, AF_INET6))
                 printk(KERN_INFO "ip6ip6 close: can't deregister tunnel\n");
 
         rtnl_lock();
diff --git a/net/ipv6/ipv6_sockglue.c b/net/ipv6/ipv6_sockglue.c
index 3f1e779ea5c5..286c86735aed 100644
--- a/net/ipv6/ipv6_sockglue.c
+++ b/net/ipv6/ipv6_sockglue.c
@@ -31,7 +31,6 @@
 #include <linux/types.h>
 #include <linux/socket.h>
 #include <linux/sockios.h>
-#include <linux/sched.h>
 #include <linux/net.h>
 #include <linux/in6.h>
 #include <linux/netdevice.h>
diff --git a/net/ipv6/netfilter/ip6_queue.c b/net/ipv6/netfilter/ip6_queue.c
index 58847d3b61e5..fdb30a5916e5 100644
--- a/net/ipv6/netfilter/ip6_queue.c
+++ b/net/ipv6/netfilter/ip6_queue.c
@@ -683,7 +683,7 @@ static int __init ip6_queue_init(void)
         }
 
         register_netdevice_notifier(&ipq_dev_notifier);
-        ipq_sysctl_header = register_sysctl_table(ipq_root_table, 0);
+        ipq_sysctl_header = register_sysctl_table(ipq_root_table);
 
         status = nf_register_queue_handler(PF_INET6, &nfqh);
         if (status < 0) {
diff --git a/net/ipv6/netfilter/nf_conntrack_proto_icmpv6.c b/net/ipv6/netfilter/nf_conntrack_proto_icmpv6.c
index 19bdb7cb8ff3..21f19cc719f3 100644
--- a/net/ipv6/netfilter/nf_conntrack_proto_icmpv6.c
+++ b/net/ipv6/netfilter/nf_conntrack_proto_icmpv6.c
@@ -17,7 +17,6 @@
  */
 
 #include <linux/types.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/module.h>
 #include <linux/netfilter.h>
diff --git a/net/ipv6/proc.c b/net/ipv6/proc.c
index c82257dd04b6..fa3fb509f187 100644
--- a/net/ipv6/proc.c
+++ b/net/ipv6/proc.c
@@ -17,7 +17,6 @@
  *              as published by the Free Software Foundation; either version
  *              2 of the License, or (at your option) any later version.
  */
-#include <linux/sched.h>
 #include <linux/socket.h>
 #include <linux/net.h>
 #include <linux/ipv6.h>
diff --git a/net/ipv6/protocol.c b/net/ipv6/protocol.c
index ad0410c99675..ef43bd57baed 100644
--- a/net/ipv6/protocol.c
+++ b/net/ipv6/protocol.c
@@ -27,7 +27,6 @@
 #include <linux/types.h>
 #include <linux/socket.h>
 #include <linux/sockios.h>
-#include <linux/sched.h>
 #include <linux/net.h>
 #include <linux/in6.h>
 #include <linux/netdevice.h>
diff --git a/net/ipv6/raw.c b/net/ipv6/raw.c
index 1f8f6275a7e4..306d5d83c068 100644
--- a/net/ipv6/raw.c
+++ b/net/ipv6/raw.c
@@ -24,7 +24,6 @@
 #include <linux/types.h>
 #include <linux/socket.h>
 #include <linux/sockios.h>
-#include <linux/sched.h>
 #include <linux/net.h>
 #include <linux/in6.h>
 #include <linux/netdevice.h>
diff --git a/net/ipv6/sit.c b/net/ipv6/sit.c
index 4d3cf301e1fc..08d6ed3396e4 100644
--- a/net/ipv6/sit.c
+++ b/net/ipv6/sit.c
@@ -24,7 +24,6 @@
 #include <linux/types.h>
 #include <linux/socket.h>
 #include <linux/sockios.h>
-#include <linux/sched.h>
 #include <linux/net.h>
 #include <linux/in6.h>
 #include <linux/netdevice.h>
@@ -216,7 +215,7 @@ static void ipip6_tunnel_uninit(struct net_device *dev)
 }
 
 
-static void ipip6_err(struct sk_buff *skb, u32 info)
+static int ipip6_err(struct sk_buff *skb, u32 info)
 {
 #ifndef I_WISH_WORLD_WERE_PERFECT
 
@@ -228,21 +227,22 @@ static void ipip6_err(struct sk_buff *skb, u32 info)
         int type = skb->h.icmph->type;
         int code = skb->h.icmph->code;
         struct ip_tunnel *t;
+        int err;
 
         switch (type) {
         default:
         case ICMP_PARAMETERPROB:
-                return;
+                return 0;
 
         case ICMP_DEST_UNREACH:
                 switch (code) {
                 case ICMP_SR_FAILED:
                 case ICMP_PORT_UNREACH:
                         /* Impossible event. */
-                        return;
+                        return 0;
                 case ICMP_FRAG_NEEDED:
                         /* Soft state for pmtu is maintained by IP core. */
-                        return;
+                        return 0;
                 default:
                         /* All others are translated to HOST_UNREACH.
                            rfc2003 contains "deep thoughts" about NET_UNREACH,
@@ -253,14 +253,18 @@ static void ipip6_err(struct sk_buff *skb, u32 info)
                 break;
         case ICMP_TIME_EXCEEDED:
                 if (code != ICMP_EXC_TTL)
-                        return;
+                        return 0;
                 break;
         }
 
+        err = -ENOENT;
+
         read_lock(&ipip6_lock);
         t = ipip6_tunnel_lookup(iph->daddr, iph->saddr);
         if (t == NULL || t->parms.iph.daddr == 0)
                 goto out;
+
+        err = 0;
         if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
                 goto out;
 
@@ -271,7 +275,7 @@ static void ipip6_err(struct sk_buff *skb, u32 info)
         t->err_time = jiffies;
 out:
         read_unlock(&ipip6_lock);
-        return;
+        return err;
 #else
         struct iphdr *iph = (struct iphdr*)dp;
         int hlen = iph->ihl<<2;
@@ -332,7 +336,7 @@ out:
         /* Prepare fake skb to feed it to icmpv6_send */
         skb2 = skb_clone(skb, GFP_ATOMIC);
         if (skb2 == NULL)
-                return;
+                return 0;
         dst_release(skb2->dst);
         skb2->dst = NULL;
         skb_pull(skb2, skb->data - (u8*)iph6);
@@ -355,7 +359,7 @@ out:
                 }
         }
         kfree_skb(skb2);
-        return;
+        return 0;
 #endif
 }
 
@@ -791,9 +795,10 @@ static int __init ipip6_fb_tunnel_init(struct net_device *dev)
         return 0;
 }
 
-static struct net_protocol sit_protocol = {
+static struct xfrm_tunnel sit_handler = {
         .handler        =       ipip6_rcv,
         .err_handler    =       ipip6_err,
+        .priority       =       1,
 };
 
 static void __exit sit_destroy_tunnels(void)
@@ -812,7 +817,7 @@ static void __exit sit_destroy_tunnels(void)
 
 static void __exit sit_cleanup(void)
 {
-        inet_del_protocol(&sit_protocol, IPPROTO_IPV6);
+        xfrm4_tunnel_deregister(&sit_handler, AF_INET6);
 
         rtnl_lock();
         sit_destroy_tunnels();
@@ -826,7 +831,7 @@ static int __init sit_init(void)
 
         printk(KERN_INFO "IPv6 over IPv4 tunneling driver\n");
 
-        if (inet_add_protocol(&sit_protocol, IPPROTO_IPV6) < 0) {
+        if (xfrm4_tunnel_register(&sit_handler, AF_INET6) < 0) {
                 printk(KERN_INFO "sit init: Can't add protocol\n");
                 return -EAGAIN;
         }
@@ -848,7 +853,7 @@ static int __init sit_init(void)
  err2:
         free_netdev(ipip6_fb_tunnel_dev);
  err1:
-        inet_del_protocol(&sit_protocol, IPPROTO_IPV6);
+        xfrm4_tunnel_deregister(&sit_handler, AF_INET6);
         goto out;
 }
 
diff --git a/net/ipv6/sysctl_net_ipv6.c b/net/ipv6/sysctl_net_ipv6.c
index 25e8e7783fee..3fb44277207b 100644
--- a/net/ipv6/sysctl_net_ipv6.c
+++ b/net/ipv6/sysctl_net_ipv6.c
@@ -107,7 +107,7 @@ static ctl_table ipv6_root_table[] = {
 
 void ipv6_sysctl_register(void)
 {
-        ipv6_sysctl_header = register_sysctl_table(ipv6_root_table, 0);
+        ipv6_sysctl_header = register_sysctl_table(ipv6_root_table);
 }
 
 void ipv6_sysctl_unregister(void)
diff --git a/net/ipv6/tunnel6.c b/net/ipv6/tunnel6.c
index 918d07dd1219..23e2809878ae 100644
--- a/net/ipv6/tunnel6.c
+++ b/net/ipv6/tunnel6.c
@@ -30,9 +30,10 @@
 #include <net/xfrm.h>
 
 static struct xfrm6_tunnel *tunnel6_handlers;
+static struct xfrm6_tunnel *tunnel46_handlers;
 static DEFINE_MUTEX(tunnel6_mutex);
 
-int xfrm6_tunnel_register(struct xfrm6_tunnel *handler)
+int xfrm6_tunnel_register(struct xfrm6_tunnel *handler, unsigned short family)
 {
         struct xfrm6_tunnel **pprev;
         int ret = -EEXIST;
@@ -40,7 +41,8 @@ int xfrm6_tunnel_register(struct xfrm6_tunnel *handler)
 
         mutex_lock(&tunnel6_mutex);
 
-        for (pprev = &tunnel6_handlers; *pprev; pprev = &(*pprev)->next) {
+        for (pprev = (family == AF_INET6) ? &tunnel6_handlers : &tunnel46_handlers;
+             *pprev; pprev = &(*pprev)->next) {
                 if ((*pprev)->priority > priority)
                         break;
                 if ((*pprev)->priority == priority)
@@ -60,14 +62,15 @@ err:
 
 EXPORT_SYMBOL(xfrm6_tunnel_register);
 
-int xfrm6_tunnel_deregister(struct xfrm6_tunnel *handler)
+int xfrm6_tunnel_deregister(struct xfrm6_tunnel *handler, unsigned short family)
 {
         struct xfrm6_tunnel **pprev;
         int ret = -ENOENT;
 
         mutex_lock(&tunnel6_mutex);
 
-        for (pprev = &tunnel6_handlers; *pprev; pprev = &(*pprev)->next) {
+        for (pprev = (family == AF_INET6) ? &tunnel6_handlers : &tunnel46_handlers;
+             *pprev; pprev = &(*pprev)->next) {
                 if (*pprev == handler) {
                         *pprev = handler->next;
                         ret = 0;
@@ -103,6 +106,25 @@ drop:
         return 0;
 }
 
+static int tunnel46_rcv(struct sk_buff **pskb)
+{
+        struct sk_buff *skb = *pskb;
+        struct xfrm6_tunnel *handler;
+
+        if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
+                goto drop;
+
+        for (handler = tunnel46_handlers; handler; handler = handler->next)
+                if (!handler->handler(skb))
+                        return 0;
+
+        icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_PORT_UNREACH, 0, skb->dev);
+
+drop:
+        kfree_skb(skb);
+        return 0;
+}
+
 static void tunnel6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
                         int type, int code, int offset, __be32 info)
 {
@@ -119,17 +141,30 @@ static struct inet6_protocol tunnel6_protocol = {
         .flags          = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
 };
 
+static struct inet6_protocol tunnel46_protocol = {
+        .handler        = tunnel46_rcv,
+        .err_handler    = tunnel6_err,
+        .flags          = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
+};
+
 static int __init tunnel6_init(void)
 {
         if (inet6_add_protocol(&tunnel6_protocol, IPPROTO_IPV6)) {
                 printk(KERN_ERR "tunnel6 init(): can't add protocol\n");
                 return -EAGAIN;
         }
+        if (inet6_add_protocol(&tunnel46_protocol, IPPROTO_IPIP)) {
+                printk(KERN_ERR "tunnel6 init(): can't add protocol\n");
+                inet6_del_protocol(&tunnel6_protocol, IPPROTO_IPV6);
+                return -EAGAIN;
+        }
         return 0;
 }
 
 static void __exit tunnel6_fini(void)
 {
+        if (inet6_del_protocol(&tunnel46_protocol, IPPROTO_IPIP))
+                printk(KERN_ERR "tunnel6 close: can't remove protocol\n");
         if (inet6_del_protocol(&tunnel6_protocol, IPPROTO_IPV6))
                 printk(KERN_ERR "tunnel6 close: can't remove protocol\n");
 }
diff --git a/net/ipv6/udp.c b/net/ipv6/udp.c
index ccf2f4d196be..0ad471909881 100644
--- a/net/ipv6/udp.c
+++ b/net/ipv6/udp.c
@@ -27,7 +27,6 @@
 #include <linux/types.h>
 #include <linux/socket.h>
 #include <linux/sockios.h>
-#include <linux/sched.h>
 #include <linux/net.h>
 #include <linux/in6.h>
 #include <linux/netdevice.h>
diff --git a/net/ipv6/xfrm6_input.c b/net/ipv6/xfrm6_input.c
index 25250147bdc3..31f651f95096 100644
--- a/net/ipv6/xfrm6_input.c
+++ b/net/ipv6/xfrm6_input.c
@@ -40,7 +40,8 @@ int xfrm6_rcv_spi(struct sk_buff *skb, __be32 spi)
                 if (xfrm_nr == XFRM_MAX_DEPTH)
                         goto drop;
 
-                x = xfrm_state_lookup((xfrm_address_t *)&iph->daddr, spi, nexthdr, AF_INET6);
+                x = xfrm_state_lookup((xfrm_address_t *)&iph->daddr, spi,
+                                nexthdr != IPPROTO_IPIP ? nexthdr : IPPROTO_IPV6, AF_INET6);
                 if (x == NULL)
                         goto drop;
                 spin_lock(&x->lock);
diff --git a/net/ipv6/xfrm6_tunnel.c b/net/ipv6/xfrm6_tunnel.c
index fb0228772f01..ee4b84a33ff4 100644
--- a/net/ipv6/xfrm6_tunnel.c
+++ b/net/ipv6/xfrm6_tunnel.c
@@ -339,17 +339,29 @@ static struct xfrm6_tunnel xfrm6_tunnel_handler = {
         .priority       = 2,
 };
 
+static struct xfrm6_tunnel xfrm46_tunnel_handler = {
+        .handler        = xfrm6_tunnel_rcv,
+        .err_handler    = xfrm6_tunnel_err,
+        .priority       = 2,
+};
+
 static int __init xfrm6_tunnel_init(void)
 {
         if (xfrm_register_type(&xfrm6_tunnel_type, AF_INET6) < 0)
                 return -EAGAIN;
 
-        if (xfrm6_tunnel_register(&xfrm6_tunnel_handler)) {
+        if (xfrm6_tunnel_register(&xfrm6_tunnel_handler, AF_INET6)) {
+                xfrm_unregister_type(&xfrm6_tunnel_type, AF_INET6);
+                return -EAGAIN;
+        }
+        if (xfrm6_tunnel_register(&xfrm46_tunnel_handler, AF_INET)) {
+                xfrm6_tunnel_deregister(&xfrm6_tunnel_handler, AF_INET6);
                 xfrm_unregister_type(&xfrm6_tunnel_type, AF_INET6);
                 return -EAGAIN;
         }
         if (xfrm6_tunnel_spi_init() < 0) {
-                xfrm6_tunnel_deregister(&xfrm6_tunnel_handler);
+                xfrm6_tunnel_deregister(&xfrm46_tunnel_handler, AF_INET);
+                xfrm6_tunnel_deregister(&xfrm6_tunnel_handler, AF_INET6);
                 xfrm_unregister_type(&xfrm6_tunnel_type, AF_INET6);
                 return -EAGAIN;
         }
@@ -359,7 +371,8 @@ static int __init xfrm6_tunnel_init(void)
 static void __exit xfrm6_tunnel_fini(void)
 {
         xfrm6_tunnel_spi_fini();
-        xfrm6_tunnel_deregister(&xfrm6_tunnel_handler);
+        xfrm6_tunnel_deregister(&xfrm46_tunnel_handler, AF_INET);
+        xfrm6_tunnel_deregister(&xfrm6_tunnel_handler, AF_INET6);
         xfrm_unregister_type(&xfrm6_tunnel_type, AF_INET6);
 }
 
diff --git a/net/ipx/sysctl_net_ipx.c b/net/ipx/sysctl_net_ipx.c
index 85ae35fa1e0e..0cf526450536 100644
--- a/net/ipx/sysctl_net_ipx.c
+++ b/net/ipx/sysctl_net_ipx.c
@@ -52,7 +52,7 @@ static struct ctl_table_header *ipx_table_header;
 
 void ipx_register_sysctl(void)
 {
-        ipx_table_header = register_sysctl_table(ipx_root_table, 1);
+        ipx_table_header = register_sysctl_table(ipx_root_table);
 }
 
 void ipx_unregister_sysctl(void)
diff --git a/net/irda/ircomm/ircomm_core.c b/net/irda/ircomm/ircomm_core.c
index ec40715dcdda..4749f8f55391 100644
--- a/net/irda/ircomm/ircomm_core.c
+++ b/net/irda/ircomm/ircomm_core.c
@@ -30,7 +30,6 @@
  ********************************************************************/
 
 #include <linux/module.h>
-#include <linux/sched.h>
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
 #include <linux/init.h>
diff --git a/net/irda/ircomm/ircomm_event.c b/net/irda/ircomm/ircomm_event.c
index 23d0468794e2..8ba4e59ece16 100644
--- a/net/irda/ircomm/ircomm_event.c
+++ b/net/irda/ircomm/ircomm_event.c
@@ -28,7 +28,6 @@
  *
  ********************************************************************/
 
-#include <linux/sched.h>
 #include <linux/proc_fs.h>
 #include <linux/init.h>
 
diff --git a/net/irda/ircomm/ircomm_lmp.c b/net/irda/ircomm/ircomm_lmp.c
index 22bd75299104..55860ee4e39e 100644
--- a/net/irda/ircomm/ircomm_lmp.c
+++ b/net/irda/ircomm/ircomm_lmp.c
@@ -30,7 +30,6 @@
  *
  ********************************************************************/
 
-#include <linux/sched.h>
 #include <linux/init.h>
 
 #include <net/irda/irda.h>
diff --git a/net/irda/ircomm/ircomm_param.c b/net/irda/ircomm/ircomm_param.c
index fbac13e95b28..01d7c9c7b3b4 100644
--- a/net/irda/ircomm/ircomm_param.c
+++ b/net/irda/ircomm/ircomm_param.c
@@ -28,7 +28,6 @@
  *
  ********************************************************************/
 
-#include <linux/sched.h>
 #include <linux/workqueue.h>
 #include <linux/interrupt.h>
 
diff --git a/net/irda/ircomm/ircomm_ttp.c b/net/irda/ircomm/ircomm_ttp.c
index bb06ebaadd16..712eafd0cc76 100644
--- a/net/irda/ircomm/ircomm_ttp.c
+++ b/net/irda/ircomm/ircomm_ttp.c
@@ -29,7 +29,6 @@
  *
  ********************************************************************/
 
-#include <linux/sched.h>
 #include <linux/init.h>
 
 #include <net/irda/irda.h>
diff --git a/net/irda/ircomm/ircomm_tty_attach.c b/net/irda/ircomm/ircomm_tty_attach.c
index 8d7ba93e4e09..824309dabfe9 100644
--- a/net/irda/ircomm/ircomm_tty_attach.c
+++ b/net/irda/ircomm/ircomm_tty_attach.c
@@ -29,7 +29,6 @@
  *
  ********************************************************************/
 
-#include <linux/sched.h>
 #include <linux/init.h>
 
 #include <net/irda/irda.h>
diff --git a/net/irda/ircomm/ircomm_tty_ioctl.c b/net/irda/ircomm/ircomm_tty_ioctl.c
index a5174e6e7ad3..6030947b6d93 100644
--- a/net/irda/ircomm/ircomm_tty_ioctl.c
+++ b/net/irda/ircomm/ircomm_tty_ioctl.c
@@ -30,7 +30,6 @@
 
 #include <linux/init.h>
 #include <linux/fs.h>
-#include <linux/sched.h>
 #include <linux/termios.h>
 #include <linux/tty.h>
 #include <linux/serial.h>
diff --git a/net/irda/irsysctl.c b/net/irda/irsysctl.c
index bb53ba0be585..2e968e7d8fea 100644
--- a/net/irda/irsysctl.c
+++ b/net/irda/irsysctl.c
@@ -274,7 +274,7 @@ static struct ctl_table_header *irda_table_header;
  */
 int __init irda_sysctl_register(void)
 {
-        irda_table_header = register_sysctl_table(irda_root_table, 0);
+        irda_table_header = register_sysctl_table(irda_root_table);
         if (!irda_table_header)
                 return -ENOMEM;
 
diff --git a/net/lapb/lapb_in.c b/net/lapb/lapb_in.c
index b0f8713f66ca..6762e7c751eb 100644
--- a/net/lapb/lapb_in.c
+++ b/net/lapb/lapb_in.c
@@ -20,7 +20,6 @@
 #include <linux/socket.h>
 #include <linux/in.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/net/lapb/lapb_out.c b/net/lapb/lapb_out.c
index 981beb5e5187..339cc5f2684f 100644
--- a/net/lapb/lapb_out.c
+++ b/net/lapb/lapb_out.c
@@ -19,7 +19,6 @@
 #include <linux/socket.h>
 #include <linux/in.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/net/lapb/lapb_subr.c b/net/lapb/lapb_subr.c
index b8739cf9156d..b827f47ac133 100644
--- a/net/lapb/lapb_subr.c
+++ b/net/lapb/lapb_subr.c
@@ -18,7 +18,6 @@
 #include <linux/socket.h>
 #include <linux/in.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/net/llc/sysctl_net_llc.c b/net/llc/sysctl_net_llc.c
index d047a3e15714..46992d036017 100644
--- a/net/llc/sysctl_net_llc.c
+++ b/net/llc/sysctl_net_llc.c
@@ -116,7 +116,7 @@ static struct ctl_table_header *llc_table_header;
 
 int __init llc_sysctl_init(void)
 {
-        llc_table_header = register_sysctl_table(llc_root_table, 1);
+        llc_table_header = register_sysctl_table(llc_root_table);
 
         return llc_table_header ? 0 : -ENOMEM;
 }
diff --git a/net/netfilter/nf_conntrack_proto_generic.c b/net/netfilter/nf_conntrack_proto_generic.c
index 69902531c236..7c069939695a 100644
--- a/net/netfilter/nf_conntrack_proto_generic.c
+++ b/net/netfilter/nf_conntrack_proto_generic.c
@@ -12,7 +12,7 @@
  */
 
 #include <linux/types.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/timer.h>
 #include <linux/netfilter.h>
 #include <net/netfilter/nf_conntrack_l4proto.h>
diff --git a/net/netfilter/nf_conntrack_proto_sctp.c b/net/netfilter/nf_conntrack_proto_sctp.c
index 0133afa2c7ef..3c80558716a0 100644
--- a/net/netfilter/nf_conntrack_proto_sctp.c
+++ b/net/netfilter/nf_conntrack_proto_sctp.c
@@ -19,7 +19,6 @@
  */
 
 #include <linux/types.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/netfilter.h>
 #include <linux/module.h>
diff --git a/net/netfilter/nf_conntrack_proto_tcp.c b/net/netfilter/nf_conntrack_proto_tcp.c
index aff65aad3c66..069b85ca51cd 100644
--- a/net/netfilter/nf_conntrack_proto_tcp.c
+++ b/net/netfilter/nf_conntrack_proto_tcp.c
@@ -25,7 +25,6 @@
  */
 
 #include <linux/types.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/netfilter.h>
 #include <linux/module.h>
diff --git a/net/netfilter/nf_conntrack_proto_udp.c b/net/netfilter/nf_conntrack_proto_udp.c
index e49cd25998c4..d0a1cee7ee52 100644
--- a/net/netfilter/nf_conntrack_proto_udp.c
+++ b/net/netfilter/nf_conntrack_proto_udp.c
@@ -12,7 +12,6 @@
  */
 
 #include <linux/types.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/module.h>
 #include <linux/netfilter.h>
diff --git a/net/netfilter/nf_conntrack_standalone.c b/net/netfilter/nf_conntrack_standalone.c
index a0bba481d70d..b8586360e519 100644
--- a/net/netfilter/nf_conntrack_standalone.c
+++ b/net/netfilter/nf_conntrack_standalone.c
@@ -445,7 +445,7 @@ static int __init nf_conntrack_standalone_init(void)
         proc_stat->owner = THIS_MODULE;
 #endif
 #ifdef CONFIG_SYSCTL
-        nf_ct_sysctl_header = register_sysctl_table(nf_ct_net_table, 0);
+        nf_ct_sysctl_header = register_sysctl_table(nf_ct_net_table);
         if (nf_ct_sysctl_header == NULL) {
                 printk("nf_conntrack: can't register to sysctl.\n");
                 ret = -ENOMEM;
diff --git a/net/netfilter/nf_sysctl.c b/net/netfilter/nf_sysctl.c
index 06ddddb2911f..ee34589e48a4 100644
--- a/net/netfilter/nf_sysctl.c
+++ b/net/netfilter/nf_sysctl.c
@@ -56,7 +56,7 @@ nf_register_sysctl_table(struct ctl_table *path, struct ctl_table *table)
         path = path_dup(path, table);
         if (path == NULL)
                 return NULL;
-        header = register_sysctl_table(path, 0);
+        header = register_sysctl_table(path);
         if (header == NULL)
                 path_free(path, table);
         return header;
diff --git a/net/netfilter/nfnetlink.c b/net/netfilter/nfnetlink.c
index f42bb1366007..11d504d0ac72 100644
--- a/net/netfilter/nfnetlink.c
+++ b/net/netfilter/nfnetlink.c
@@ -19,7 +19,6 @@
 #include <linux/socket.h>
 #include <linux/kernel.h>
 #include <linux/major.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/net/netrom/nr_dev.c b/net/netrom/nr_dev.c
index 4700d5225b78..9a97ed6e6910 100644
--- a/net/netrom/nr_dev.c
+++ b/net/netrom/nr_dev.c
@@ -9,7 +9,6 @@
 #include <linux/module.h>
 #include <linux/proc_fs.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/interrupt.h>
 #include <linux/fs.h>
 #include <linux/types.h>
diff --git a/net/netrom/nr_in.c b/net/netrom/nr_in.c
index a7d88b5ad756..5560acbaaa95 100644
--- a/net/netrom/nr_in.c
+++ b/net/netrom/nr_in.c
@@ -12,7 +12,6 @@
 #include <linux/socket.h>
 #include <linux/in.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/net/netrom/nr_out.c b/net/netrom/nr_out.c
index 7939ded9c98c..0cbfb611465b 100644
--- a/net/netrom/nr_out.c
+++ b/net/netrom/nr_out.c
@@ -12,7 +12,6 @@
 #include <linux/socket.h>
 #include <linux/in.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/net/netrom/nr_route.c b/net/netrom/nr_route.c
index c2fbac9c69ce..8e6bd4e9d82c 100644
--- a/net/netrom/nr_route.c
+++ b/net/netrom/nr_route.c
@@ -13,7 +13,6 @@
 #include <linux/socket.h>
 #include <linux/in.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/net/netrom/nr_subr.c b/net/netrom/nr_subr.c
index cfab5721a608..07b694d18870 100644
--- a/net/netrom/nr_subr.c
+++ b/net/netrom/nr_subr.c
@@ -11,7 +11,6 @@
 #include <linux/socket.h>
 #include <linux/in.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/net/netrom/sysctl_net_netrom.c b/net/netrom/sysctl_net_netrom.c
index e4b27d7aae79..2ea68da01fb8 100644
--- a/net/netrom/sysctl_net_netrom.c
+++ b/net/netrom/sysctl_net_netrom.c
@@ -192,7 +192,7 @@ static ctl_table nr_root_table[] = {
 
 void __init nr_register_sysctl(void)
 {
-        nr_table_header = register_sysctl_table(nr_root_table, 1);
+        nr_table_header = register_sysctl_table(nr_root_table);
 }
 
 void nr_unregister_sysctl(void)
diff --git a/net/packet/af_packet.c b/net/packet/af_packet.c
index 15ff7b15e211..bf2699074774 100644
--- a/net/packet/af_packet.c
+++ b/net/packet/af_packet.c
@@ -50,7 +50,6 @@
  */
 
 #include <linux/types.h>
-#include <linux/sched.h>
 #include <linux/mm.h>
 #include <linux/capability.h>
 #include <linux/fcntl.h>
diff --git a/net/rose/rose_dev.c b/net/rose/rose_dev.c
index 50824d345fa6..8d88795dc663 100644
--- a/net/rose/rose_dev.c
+++ b/net/rose/rose_dev.c
@@ -9,7 +9,6 @@
 #include <linux/module.h>
 #include <linux/proc_fs.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/interrupt.h>
 #include <linux/fs.h>
 #include <linux/types.h>
diff --git a/net/rose/rose_in.c b/net/rose/rose_in.c
index 8348d33f1efe..4ee0879d3540 100644
--- a/net/rose/rose_in.c
+++ b/net/rose/rose_in.c
@@ -16,7 +16,6 @@
 #include <linux/socket.h>
 #include <linux/in.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/net/rose/rose_out.c b/net/rose/rose_out.c
index 2965ffc83b9b..69820f93414b 100644
--- a/net/rose/rose_out.c
+++ b/net/rose/rose_out.c
@@ -11,7 +11,6 @@
 #include <linux/socket.h>
 #include <linux/in.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/net/rose/rose_route.c b/net/rose/rose_route.c
index 1ddf7f5fa6db..a1233e1b1ab6 100644
--- a/net/rose/rose_route.c
+++ b/net/rose/rose_route.c
@@ -12,7 +12,6 @@
 #include <linux/socket.h>
 #include <linux/in.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/net/rose/rose_subr.c b/net/rose/rose_subr.c
index 36a77944622b..b05108f382da 100644
--- a/net/rose/rose_subr.c
+++ b/net/rose/rose_subr.c
@@ -11,7 +11,6 @@
 #include <linux/socket.h>
 #include <linux/in.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/net/rose/sysctl_net_rose.c b/net/rose/sysctl_net_rose.c
index 27a452bc5b8d..455b0555a669 100644
--- a/net/rose/sysctl_net_rose.c
+++ b/net/rose/sysctl_net_rose.c
@@ -160,7 +160,7 @@ static ctl_table rose_root_table[] = {
 
 void __init rose_register_sysctl(void)
 {
-        rose_table_header = register_sysctl_table(rose_root_table, 1);
+        rose_table_header = register_sysctl_table(rose_root_table);
 }
 
 void rose_unregister_sysctl(void)
diff --git a/net/rxrpc/sysctl.c b/net/rxrpc/sysctl.c
index 0755ae028e43..884290754af7 100644
--- a/net/rxrpc/sysctl.c
+++ b/net/rxrpc/sysctl.c
@@ -97,7 +97,7 @@ static ctl_table rxrpc_dir_sysctl_table[] = {
 int rxrpc_sysctl_init(void)
 {
 #ifdef CONFIG_SYSCTL
-        rxrpc_sysctl = register_sysctl_table(rxrpc_dir_sysctl_table, 0);
+        rxrpc_sysctl = register_sysctl_table(rxrpc_dir_sysctl_table);
         if (!rxrpc_sysctl)
                 return -ENOMEM;
 #endif /* CONFIG_SYSCTL */
diff --git a/net/rxrpc/transport.c b/net/rxrpc/transport.c
index ff5f4f333086..8e57be2df936 100644
--- a/net/rxrpc/transport.c
+++ b/net/rxrpc/transport.c
@@ -9,7 +9,6 @@
  * 2 of the License, or (at your option) any later version.
  */
 
-#include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/module.h>
 #include <rxrpc/transport.h>
diff --git a/net/sched/act_api.c b/net/sched/act_api.c
index dd0868dfbd90..cb21617a5670 100644
--- a/net/sched/act_api.c
+++ b/net/sched/act_api.c
@@ -16,7 +16,6 @@
 #include <linux/bitops.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/socket.h>
diff --git a/net/sched/act_gact.c b/net/sched/act_gact.c
index 60095d86fd8f..87d0faf32867 100644
--- a/net/sched/act_gact.c
+++ b/net/sched/act_gact.c
@@ -15,7 +15,6 @@
 #include <linux/bitops.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/socket.h>
diff --git a/net/sched/act_ipt.c b/net/sched/act_ipt.c
index 0fdabfa9f4bf..47f0b1324239 100644
--- a/net/sched/act_ipt.c
+++ b/net/sched/act_ipt.c
@@ -16,7 +16,6 @@
 #include <asm/bitops.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/socket.h>
diff --git a/net/sched/act_mirred.c b/net/sched/act_mirred.c
index 483897271f15..68f26cb278f9 100644
--- a/net/sched/act_mirred.c
+++ b/net/sched/act_mirred.c
@@ -17,7 +17,6 @@
 #include <asm/bitops.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/socket.h>
diff --git a/net/sched/act_pedit.c b/net/sched/act_pedit.c
index 53aa96cd579b..3d6a2fcc9ce4 100644
--- a/net/sched/act_pedit.c
+++ b/net/sched/act_pedit.c
@@ -14,7 +14,6 @@
 #include <asm/bitops.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/socket.h>
diff --git a/net/sched/act_police.c b/net/sched/act_police.c
index 6ffe35da22b1..10a5a5c36f76 100644
--- a/net/sched/act_police.c
+++ b/net/sched/act_police.c
@@ -16,7 +16,6 @@
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/socket.h>
diff --git a/net/sched/cls_api.c b/net/sched/cls_api.c
index f41f4ee0587a..5c6ffdb77d2d 100644
--- a/net/sched/cls_api.c
+++ b/net/sched/cls_api.c
@@ -20,7 +20,6 @@
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/socket.h>
diff --git a/net/sched/cls_basic.c b/net/sched/cls_basic.c
index ea13c2c5b061..fad08e521c24 100644
--- a/net/sched/cls_basic.c
+++ b/net/sched/cls_basic.c
@@ -12,7 +12,6 @@
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/errno.h>
diff --git a/net/sched/cls_fw.c b/net/sched/cls_fw.c
index 2ce3ce5c66eb..5dbb9d451f73 100644
--- a/net/sched/cls_fw.c
+++ b/net/sched/cls_fw.c
@@ -24,7 +24,6 @@
 #include <linux/bitops.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/socket.h>
diff --git a/net/sched/cls_route.c b/net/sched/cls_route.c
index d3aea730d4c8..e85df07d8ce7 100644
--- a/net/sched/cls_route.c
+++ b/net/sched/cls_route.c
@@ -15,7 +15,6 @@
 #include <linux/bitops.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/socket.h>
diff --git a/net/sched/cls_rsvp.c b/net/sched/cls_rsvp.c
index ad2613790d85..1d4a1fb17608 100644
--- a/net/sched/cls_rsvp.c
+++ b/net/sched/cls_rsvp.c
@@ -15,7 +15,6 @@
 #include <linux/bitops.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/socket.h>
diff --git a/net/sched/cls_rsvp6.c b/net/sched/cls_rsvp6.c
index fde51f7848eb..a2979d89798f 100644
--- a/net/sched/cls_rsvp6.c
+++ b/net/sched/cls_rsvp6.c
@@ -15,7 +15,6 @@
 #include <linux/bitops.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/socket.h>
diff --git a/net/sched/cls_u32.c b/net/sched/cls_u32.c
index a232671cfa4e..0bcb16928d25 100644
--- a/net/sched/cls_u32.c
+++ b/net/sched/cls_u32.c
@@ -36,7 +36,6 @@
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/socket.h>
diff --git a/net/sched/em_nbyte.c b/net/sched/em_nbyte.c
index 42103b2bdc51..b4b36efce292 100644
--- a/net/sched/em_nbyte.c
+++ b/net/sched/em_nbyte.c
@@ -12,7 +12,6 @@
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/skbuff.h>
 #include <linux/tc_ematch/tc_em_nbyte.h>
diff --git a/net/sched/em_text.c b/net/sched/em_text.c
index 8ad894b58fce..e8f46169449d 100644
--- a/net/sched/em_text.c
+++ b/net/sched/em_text.c
@@ -12,7 +12,6 @@
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/skbuff.h>
 #include <linux/textsearch.h>
diff --git a/net/sched/ematch.c b/net/sched/ematch.c
index d3ad36b36129..959c306c5714 100644
--- a/net/sched/ematch.c
+++ b/net/sched/ematch.c
@@ -84,7 +84,6 @@
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/mm.h>
 #include <linux/errno.h>
 #include <linux/interrupt.h>
diff --git a/net/sched/sch_api.c b/net/sched/sch_api.c
index 4158127bc202..ecc988af4a9a 100644
--- a/net/sched/sch_api.c
+++ b/net/sched/sch_api.c
@@ -18,7 +18,6 @@
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/socket.h>
diff --git a/net/sched/sch_cbq.c b/net/sched/sch_cbq.c
index 48830cac1014..76c92e710a33 100644
--- a/net/sched/sch_cbq.c
+++ b/net/sched/sch_cbq.c
@@ -16,7 +16,6 @@
 #include <linux/bitops.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/socket.h>
diff --git a/net/sched/sch_hfsc.c b/net/sched/sch_hfsc.c
index 135087d4213a..396deb71480f 100644
--- a/net/sched/sch_hfsc.c
+++ b/net/sched/sch_hfsc.c
@@ -71,8 +71,6 @@
 #include <asm/system.h>
 #include <asm/div64.h>
 
-#define HFSC_DEBUG 1
-
 /*
  * kernel internal service curve representation:
  *   coordinates are given by 64 bit unsigned integers.
@@ -211,17 +209,6 @@ do {									\
 } while (0)
 #endif
 
-#if HFSC_DEBUG
-#define ASSERT(cond)                                                    \
-do {                                                                    \
-        if (unlikely(!(cond)))                                          \
-                printk("assertion %s failed at %s:%i (%s)\n",           \
-                       #cond, __FILE__, __LINE__, __FUNCTION__);        \
-} while (0)
-#else
-#define ASSERT(cond)
-#endif /* HFSC_DEBUG */
-
 #define HT_INFINITY     0xffffffffffffffffULL   /* infinite time value */
 
 
@@ -1492,7 +1479,7 @@ hfsc_schedule_watchdog(struct Qdisc *sch, u64 cur_time)
                 if (next_time == 0 || next_time > q->root.cl_cfmin)
                         next_time = q->root.cl_cfmin;
         }
-        ASSERT(next_time != 0);
+        WARN_ON(next_time == 0);
         delay = next_time - cur_time;
         delay = PSCHED_US2JIFFIE(delay);
 
diff --git a/net/sched/sch_htb.c b/net/sched/sch_htb.c
index 1f098d862f92..97cbb9aec946 100644
--- a/net/sched/sch_htb.c
+++ b/net/sched/sch_htb.c
@@ -33,7 +33,6 @@
 #include <linux/bitops.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/socket.h>
diff --git a/net/sched/sch_prio.c b/net/sched/sch_prio.c
index 9f957ca5073b..de889f23f22a 100644
--- a/net/sched/sch_prio.c
+++ b/net/sched/sch_prio.c
@@ -17,7 +17,6 @@
 #include <linux/bitops.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/socket.h>
diff --git a/net/sched/sch_teql.c b/net/sched/sch_teql.c
index 6a66037abac9..587123c61af9 100644
--- a/net/sched/sch_teql.c
+++ b/net/sched/sch_teql.c
@@ -14,7 +14,6 @@
 #include <linux/bitops.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/socket.h>
diff --git a/net/sctp/associola.c b/net/sctp/associola.c
index fca6f75b0a0d..fa82b73c965b 100644
--- a/net/sctp/associola.c
+++ b/net/sctp/associola.c
@@ -52,7 +52,6 @@
 #include <linux/fcntl.h>
 #include <linux/poll.h>
 #include <linux/init.h>
-#include <linux/sched.h>
 
 #include <linux/slab.h>
 #include <linux/in.h>
diff --git a/net/sctp/bind_addr.c b/net/sctp/bind_addr.c
index 80294cbc0de6..fdb287a9e2e2 100644
--- a/net/sctp/bind_addr.c
+++ b/net/sctp/bind_addr.c
@@ -43,7 +43,6 @@
  */
 
 #include <linux/types.h>
-#include <linux/sched.h>
 #include <linux/in.h>
 #include <net/sock.h>
 #include <net/ipv6.h>
diff --git a/net/sctp/endpointola.c b/net/sctp/endpointola.c
index 286a8dbb63b7..1404a9e2e78f 100644
--- a/net/sctp/endpointola.c
+++ b/net/sctp/endpointola.c
@@ -50,7 +50,6 @@
  */
 
 #include <linux/types.h>
-#include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/in.h>
 #include <linux/random.h>       /* get_random_bytes() */
diff --git a/net/sctp/ipv6.c b/net/sctp/ipv6.c
index 01b27fb5dfc5..63fe1093b616 100644
--- a/net/sctp/ipv6.c
+++ b/net/sctp/ipv6.c
@@ -53,7 +53,6 @@
 #include <linux/socket.h>
 #include <linux/sockios.h>
 #include <linux/net.h>
-#include <linux/sched.h>
 #include <linux/in.h>
 #include <linux/in6.h>
 #include <linux/netdevice.h>
diff --git a/net/sctp/sysctl.c b/net/sctp/sysctl.c
index 633cd178654b..e2c679baf912 100644
--- a/net/sctp/sysctl.c
+++ b/net/sctp/sysctl.c
@@ -254,7 +254,7 @@ static struct ctl_table_header * sctp_sysctl_header;
 /* Sysctl registration.  */
 void sctp_sysctl_register(void)
 {
-        sctp_sysctl_header = register_sysctl_table(sctp_root_table, 0);
+        sctp_sysctl_header = register_sysctl_table(sctp_root_table);
 }
 
 /* Sysctl deregistration.  */
diff --git a/net/sunrpc/auth.c b/net/sunrpc/auth.c
index 76f7eac4082d..9527f2bb1744 100644
--- a/net/sunrpc/auth.c
+++ b/net/sunrpc/auth.c
@@ -181,7 +181,7 @@ rpcauth_gc_credcache(struct rpc_auth *auth, struct hlist_head *free)
         struct rpc_cred *cred;
         int             i;
 
-        dprintk("RPC: gc'ing RPC credentials for auth %p\n", auth);
+        dprintk("RPC:       gc'ing RPC credentials for auth %p\n", auth);
         for (i = 0; i < RPC_CREDCACHE_NR; i++) {
                 hlist_for_each_safe(pos, next, &cache->hashtable[i]) {
                         cred = hlist_entry(pos, struct rpc_cred, cr_hash);
@@ -267,7 +267,7 @@ rpcauth_lookupcred(struct rpc_auth *auth, int flags)
         };
         struct rpc_cred *ret;
 
-        dprintk("RPC:     looking up %s cred\n",
+        dprintk("RPC:       looking up %s cred\n",
                 auth->au_ops->au_name);
         get_group_info(acred.group_info);
         ret = auth->au_ops->lookup_cred(auth, &acred, flags);
@@ -287,7 +287,7 @@ rpcauth_bindcred(struct rpc_task *task)
         struct rpc_cred *ret;
         int flags = 0;
 
-        dprintk("RPC: %4d looking up %s cred\n",
+        dprintk("RPC: %5u looking up %s cred\n",
                 task->tk_pid, task->tk_auth->au_ops->au_name);
         get_group_info(acred.group_info);
         if (task->tk_flags & RPC_TASK_ROOTCREDS)
@@ -304,8 +304,9 @@ rpcauth_bindcred(struct rpc_task *task)
 void
 rpcauth_holdcred(struct rpc_task *task)
 {
-        dprintk("RPC: %4d holding %s cred %p\n",
-                task->tk_pid, task->tk_auth->au_ops->au_name, task->tk_msg.rpc_cred);
+        dprintk("RPC: %5u holding %s cred %p\n",
+                task->tk_pid, task->tk_auth->au_ops->au_name,
+                task->tk_msg.rpc_cred);
         if (task->tk_msg.rpc_cred)
                 get_rpccred(task->tk_msg.rpc_cred);
 }
@@ -324,7 +325,7 @@ rpcauth_unbindcred(struct rpc_task *task)
 {
         struct rpc_cred *cred = task->tk_msg.rpc_cred;
 
-        dprintk("RPC: %4d releasing %s cred %p\n",
+        dprintk("RPC: %5u releasing %s cred %p\n",
                 task->tk_pid, task->tk_auth->au_ops->au_name, cred);
 
         put_rpccred(cred);
@@ -336,7 +337,7 @@ rpcauth_marshcred(struct rpc_task *task, __be32 *p)
 {
         struct rpc_cred *cred = task->tk_msg.rpc_cred;
 
-        dprintk("RPC: %4d marshaling %s cred %p\n",
+        dprintk("RPC: %5u marshaling %s cred %p\n",
                 task->tk_pid, task->tk_auth->au_ops->au_name, cred);
 
         return cred->cr_ops->crmarshal(task, p);
@@ -347,7 +348,7 @@ rpcauth_checkverf(struct rpc_task *task, __be32 *p)
 {
         struct rpc_cred *cred = task->tk_msg.rpc_cred;
 
-        dprintk("RPC: %4d validating %s cred %p\n",
+        dprintk("RPC: %5u validating %s cred %p\n",
                 task->tk_pid, task->tk_auth->au_ops->au_name, cred);
 
         return cred->cr_ops->crvalidate(task, p);
@@ -359,7 +360,7 @@ rpcauth_wrap_req(struct rpc_task *task, kxdrproc_t encode, void *rqstp,
 {
         struct rpc_cred *cred = task->tk_msg.rpc_cred;
 
-        dprintk("RPC: %4d using %s cred %p to wrap rpc data\n",
+        dprintk("RPC: %5u using %s cred %p to wrap rpc data\n",
                         task->tk_pid, cred->cr_ops->cr_name, cred);
         if (cred->cr_ops->crwrap_req)
                 return cred->cr_ops->crwrap_req(task, encode, rqstp, data, obj);
@@ -373,7 +374,7 @@ rpcauth_unwrap_resp(struct rpc_task *task, kxdrproc_t decode, void *rqstp,
 {
         struct rpc_cred *cred = task->tk_msg.rpc_cred;
 
-        dprintk("RPC: %4d using %s cred %p to unwrap rpc data\n",
+        dprintk("RPC: %5u using %s cred %p to unwrap rpc data\n",
                         task->tk_pid, cred->cr_ops->cr_name, cred);
         if (cred->cr_ops->crunwrap_resp)
                 return cred->cr_ops->crunwrap_resp(task, decode, rqstp,
@@ -388,7 +389,7 @@ rpcauth_refreshcred(struct rpc_task *task)
         struct rpc_cred *cred = task->tk_msg.rpc_cred;
         int err;
 
-        dprintk("RPC: %4d refreshing %s cred %p\n",
+        dprintk("RPC: %5u refreshing %s cred %p\n",
                 task->tk_pid, task->tk_auth->au_ops->au_name, cred);
 
         err = cred->cr_ops->crrefresh(task);
@@ -400,7 +401,7 @@ rpcauth_refreshcred(struct rpc_task *task)
 void
 rpcauth_invalcred(struct rpc_task *task)
 {
-        dprintk("RPC: %4d invalidating %s cred %p\n",
+        dprintk("RPC: %5u invalidating %s cred %p\n",
                 task->tk_pid, task->tk_auth->au_ops->au_name, task->tk_msg.rpc_cred);
         spin_lock(&rpc_credcache_lock);
         if (task->tk_msg.rpc_cred)
diff --git a/net/sunrpc/auth_gss/auth_gss.c b/net/sunrpc/auth_gss/auth_gss.c
index 718fb94ad0f7..4e4ccc5b6fea 100644
--- a/net/sunrpc/auth_gss/auth_gss.c
+++ b/net/sunrpc/auth_gss/auth_gss.c
@@ -241,7 +241,7 @@ gss_fill_context(const void *p, const void *end, struct gss_cl_ctx *ctx, struct
         }
         return q;
 err:
-        dprintk("RPC:      gss_fill_context returning %ld\n", -PTR_ERR(p));
+        dprintk("RPC:       gss_fill_context returning %ld\n", -PTR_ERR(p));
         return p;
 }
 
@@ -276,10 +276,10 @@ __gss_find_upcall(struct gss_auth *gss_auth, uid_t uid)
                 if (pos->uid != uid)
                         continue;
                 atomic_inc(&pos->count);
-                dprintk("RPC:      gss_find_upcall found msg %p\n", pos);
+                dprintk("RPC:       gss_find_upcall found msg %p\n", pos);
                 return pos;
         }
-        dprintk("RPC:      gss_find_upcall found nothing\n");
+        dprintk("RPC:       gss_find_upcall found nothing\n");
         return NULL;
 }
 
@@ -393,7 +393,8 @@ gss_refresh_upcall(struct rpc_task *task)
         struct gss_upcall_msg *gss_msg;
         int err = 0;
 
-        dprintk("RPC: %4u gss_refresh_upcall for uid %u\n", task->tk_pid, cred->cr_uid);
+        dprintk("RPC: %5u gss_refresh_upcall for uid %u\n", task->tk_pid,
+                                                                cred->cr_uid);
         gss_msg = gss_setup_upcall(task->tk_client, gss_auth, cred);
         if (IS_ERR(gss_msg)) {
                 err = PTR_ERR(gss_msg);
@@ -413,8 +414,8 @@ gss_refresh_upcall(struct rpc_task *task)
         spin_unlock(&gss_auth->lock);
         gss_release_msg(gss_msg);
 out:
-        dprintk("RPC: %4u gss_refresh_upcall for uid %u result %d\n", task->tk_pid,
-                        cred->cr_uid, err);
+        dprintk("RPC: %5u gss_refresh_upcall for uid %u result %d\n",
+                        task->tk_pid, cred->cr_uid, err);
         return err;
 }
 
@@ -426,7 +427,7 @@ gss_create_upcall(struct gss_auth *gss_auth, struct gss_cred *gss_cred)
         DEFINE_WAIT(wait);
         int err = 0;
 
-        dprintk("RPC: gss_upcall for uid %u\n", cred->cr_uid);
+        dprintk("RPC:       gss_upcall for uid %u\n", cred->cr_uid);
         gss_msg = gss_setup_upcall(gss_auth->client, gss_auth, cred);
         if (IS_ERR(gss_msg)) {
                 err = PTR_ERR(gss_msg);
@@ -454,7 +455,8 @@ out_intr:
         finish_wait(&gss_msg->waitqueue, &wait);
         gss_release_msg(gss_msg);
 out:
-        dprintk("RPC: gss_create_upcall for uid %u result %d\n", cred->cr_uid, err);
+        dprintk("RPC:       gss_create_upcall for uid %u result %d\n",
+                        cred->cr_uid, err);
         return err;
 }
 
@@ -546,14 +548,14 @@ gss_pipe_downcall(struct file *filp, const char __user *src, size_t mlen)
         }
         gss_put_ctx(ctx);
         kfree(buf);
-        dprintk("RPC:      gss_pipe_downcall returning length %Zu\n", mlen);
+        dprintk("RPC:       gss_pipe_downcall returning length %Zu\n", mlen);
         return mlen;
 err_put_ctx:
         gss_put_ctx(ctx);
 err:
         kfree(buf);
 out:
-        dprintk("RPC:      gss_pipe_downcall returning %d\n", err);
+        dprintk("RPC:       gss_pipe_downcall returning %d\n", err);
         return err;
 }
 
@@ -591,7 +593,7 @@ gss_pipe_destroy_msg(struct rpc_pipe_msg *msg)
         static unsigned long ratelimit;
 
         if (msg->errno < 0) {
-                dprintk("RPC:      gss_pipe_destroy_msg releasing msg %p\n",
+                dprintk("RPC:       gss_pipe_destroy_msg releasing msg %p\n",
                                 gss_msg);
                 atomic_inc(&gss_msg->count);
                 gss_unhash_msg(gss_msg);
@@ -618,7 +620,7 @@ gss_create(struct rpc_clnt *clnt, rpc_authflavor_t flavor)
         struct rpc_auth * auth;
         int err = -ENOMEM; /* XXX? */
 
-        dprintk("RPC:      creating GSS authenticator for client %p\n",clnt);
+        dprintk("RPC:       creating GSS authenticator for client %p\n", clnt);
 
         if (!try_module_get(THIS_MODULE))
                 return ERR_PTR(err);
@@ -670,8 +672,8 @@ gss_destroy(struct rpc_auth *auth)
 {
         struct gss_auth *gss_auth;
 
-        dprintk("RPC:      destroying GSS authenticator %p flavor %d\n",
-                auth, auth->au_flavor);
+        dprintk("RPC:       destroying GSS authenticator %p flavor %d\n",
+                        auth, auth->au_flavor);
 
         gss_auth = container_of(auth, struct gss_auth, rpc_auth);
         rpc_unlink(gss_auth->dentry);
@@ -689,7 +691,7 @@ gss_destroy(struct rpc_auth *auth)
 static void
 gss_destroy_ctx(struct gss_cl_ctx *ctx)
 {
-        dprintk("RPC:      gss_destroy_ctx\n");
+        dprintk("RPC:       gss_destroy_ctx\n");
 
         if (ctx->gc_gss_ctx)
                 gss_delete_sec_context(&ctx->gc_gss_ctx);
@@ -703,7 +705,7 @@ gss_destroy_cred(struct rpc_cred *rc)
 {
         struct gss_cred *cred = container_of(rc, struct gss_cred, gc_base);
 
-        dprintk("RPC:      gss_destroy_cred \n");
+        dprintk("RPC:       gss_destroy_cred \n");
 
         if (cred->gc_ctx)
                 gss_put_ctx(cred->gc_ctx);
@@ -726,7 +728,7 @@ gss_create_cred(struct rpc_auth *auth, struct auth_cred *acred, int flags)
         struct gss_cred *cred = NULL;
         int err = -ENOMEM;
 
-        dprintk("RPC:      gss_create_cred for uid %d, flavor %d\n",
+        dprintk("RPC:       gss_create_cred for uid %d, flavor %d\n",
                 acred->uid, auth->au_flavor);
 
         if (!(cred = kzalloc(sizeof(*cred), GFP_KERNEL)))
@@ -745,7 +747,7 @@ gss_create_cred(struct rpc_auth *auth, struct auth_cred *acred, int flags)
         return &cred->gc_base;
 
 out_err:
-        dprintk("RPC:      gss_create_cred failed with error %d\n", err);
+        dprintk("RPC:       gss_create_cred failed with error %d\n", err);
         return ERR_PTR(err);
 }
 
@@ -799,7 +801,7 @@ gss_marshal(struct rpc_task *task, __be32 *p)
         struct kvec     iov;
         struct xdr_buf  verf_buf;
 
-        dprintk("RPC: %4u gss_marshal\n", task->tk_pid);
+        dprintk("RPC: %5u gss_marshal\n", task->tk_pid);
 
         *p++ = htonl(RPC_AUTH_GSS);
         cred_len = p++;
@@ -865,7 +867,7 @@ gss_validate(struct rpc_task *task, __be32 *p)
         u32             flav,len;
         u32             maj_stat;
 
-        dprintk("RPC: %4u gss_validate\n", task->tk_pid);
+        dprintk("RPC: %5u gss_validate\n", task->tk_pid);
 
         flav = ntohl(*p++);
         if ((len = ntohl(*p++)) > RPC_MAX_AUTH_SIZE)
@@ -888,12 +890,12 @@ gss_validate(struct rpc_task *task, __be32 *p)
          * calculate the length of the verifier: */
         task->tk_auth->au_verfsize = XDR_QUADLEN(len) + 2;
         gss_put_ctx(ctx);
-        dprintk("RPC: %4u GSS gss_validate: gss_verify_mic succeeded.\n",
+        dprintk("RPC: %5u gss_validate: gss_verify_mic succeeded.\n",
                         task->tk_pid);
         return p + XDR_QUADLEN(len);
 out_bad:
         gss_put_ctx(ctx);
-        dprintk("RPC: %4u gss_validate failed.\n", task->tk_pid);
+        dprintk("RPC: %5u gss_validate failed.\n", task->tk_pid);
         return NULL;
 }
 
@@ -1063,7 +1065,7 @@ gss_wrap_req(struct rpc_task *task,
         struct gss_cl_ctx *ctx = gss_cred_get_ctx(cred);
         int             status = -EIO;
 
-        dprintk("RPC: %4u gss_wrap_req\n", task->tk_pid);
+        dprintk("RPC: %5u gss_wrap_req\n", task->tk_pid);
         if (ctx->gc_proc != RPC_GSS_PROC_DATA) {
                 /* The spec seems a little ambiguous here, but I think that not
                  * wrapping context destruction requests makes the most sense.
@@ -1086,7 +1088,7 @@ gss_wrap_req(struct rpc_task *task,
         }
 out:
         gss_put_ctx(ctx);
-        dprintk("RPC: %4u gss_wrap_req returning %d\n", task->tk_pid, status);
+        dprintk("RPC: %5u gss_wrap_req returning %d\n", task->tk_pid, status);
         return status;
 }
 
@@ -1192,7 +1194,7 @@ out_decode:
         status = decode(rqstp, p, obj);
 out:
         gss_put_ctx(ctx);
-        dprintk("RPC: %4u gss_unwrap_resp returning %d\n", task->tk_pid,
+        dprintk("RPC: %5u gss_unwrap_resp returning %d\n", task->tk_pid,
                         status);
         return status;
 }
diff --git a/net/sunrpc/auth_gss/gss_krb5_crypto.c b/net/sunrpc/auth_gss/gss_krb5_crypto.c
index 0a9948de0992..f441aa0b26dc 100644
--- a/net/sunrpc/auth_gss/gss_krb5_crypto.c
+++ b/net/sunrpc/auth_gss/gss_krb5_crypto.c
@@ -66,8 +66,8 @@ krb5_encrypt(
                 goto out;
 
         if (crypto_blkcipher_ivsize(tfm) > 16) {
-                dprintk("RPC:      gss_k5encrypt: tfm iv size to large %d\n",
-                         crypto_blkcipher_ivsize(tfm));
+                dprintk("RPC:       gss_k5encrypt: tfm iv size to large %d\n",
+                         crypto_blkcipher_ivsize(tfm));
                 goto out;
         }
 
@@ -79,7 +79,7 @@ krb5_encrypt(
 
         ret = crypto_blkcipher_encrypt_iv(&desc, sg, sg, length);
 out:
-        dprintk("RPC:      krb5_encrypt returns %d\n",ret);
+        dprintk("RPC:       krb5_encrypt returns %d\n", ret);
         return ret;
 }
 
@@ -102,7 +102,7 @@ krb5_decrypt(
                 goto out;
 
         if (crypto_blkcipher_ivsize(tfm) > 16) {
-                dprintk("RPC:      gss_k5decrypt: tfm iv size to large %d\n",
+                dprintk("RPC:       gss_k5decrypt: tfm iv size to large %d\n",
                         crypto_blkcipher_ivsize(tfm));
                 goto out;
         }
@@ -114,7 +114,7 @@ krb5_decrypt(
 
         ret = crypto_blkcipher_decrypt_iv(&desc, sg, sg, length);
 out:
-        dprintk("RPC:      gss_k5decrypt returns %d\n",ret);
+        dprintk("RPC:       gss_k5decrypt returns %d\n",ret);
         return ret;
 }
 
diff --git a/net/sunrpc/auth_gss/gss_krb5_mech.c b/net/sunrpc/auth_gss/gss_krb5_mech.c
index 05d4bee86fc0..7b1943217053 100644
--- a/net/sunrpc/auth_gss/gss_krb5_mech.c
+++ b/net/sunrpc/auth_gss/gss_krb5_mech.c
@@ -175,7 +175,8 @@ gss_import_sec_context_kerberos(const void *p,
         }
 
         ctx_id->internal_ctx_id = ctx;
-        dprintk("RPC:      Successfully imported new context.\n");
+
+        dprintk("RPC:       Successfully imported new context.\n");
         return 0;
 
 out_err_free_key2:
diff --git a/net/sunrpc/auth_gss/gss_krb5_seal.c b/net/sunrpc/auth_gss/gss_krb5_seal.c
index d0bb5064f8c5..a0d9faa59cb5 100644
--- a/net/sunrpc/auth_gss/gss_krb5_seal.c
+++ b/net/sunrpc/auth_gss/gss_krb5_seal.c
@@ -83,7 +83,7 @@ gss_get_mic_kerberos(struct gss_ctx *gss_ctx, struct xdr_buf *text,
         s32                     now;
         u32                     seq_send;
 
-        dprintk("RPC:     gss_krb5_seal\n");
+        dprintk("RPC:       gss_krb5_seal\n");
 
         now = get_seconds();
 
diff --git a/net/sunrpc/auth_gss/gss_krb5_seqnum.c b/net/sunrpc/auth_gss/gss_krb5_seqnum.c
index 3e315a68efaa..43f3421f1e6a 100644
--- a/net/sunrpc/auth_gss/gss_krb5_seqnum.c
+++ b/net/sunrpc/auth_gss/gss_krb5_seqnum.c
@@ -70,7 +70,7 @@ krb5_get_seq_num(struct crypto_blkcipher *key,
         s32 code;
         unsigned char plain[8];
 
-        dprintk("RPC:      krb5_get_seq_num:\n");
+        dprintk("RPC:       krb5_get_seq_num:\n");
 
         if ((code = krb5_decrypt(key, cksum, buf, plain, 8)))
                 return code;
diff --git a/net/sunrpc/auth_gss/gss_krb5_unseal.c b/net/sunrpc/auth_gss/gss_krb5_unseal.c
index 87f8977ccece..e30a993466bc 100644
--- a/net/sunrpc/auth_gss/gss_krb5_unseal.c
+++ b/net/sunrpc/auth_gss/gss_krb5_unseal.c
@@ -86,7 +86,7 @@ gss_verify_mic_kerberos(struct gss_ctx *gss_ctx,
         unsigned char           *ptr = (unsigned char *)read_token->data;
         int                     bodysize;
 
-        dprintk("RPC:      krb5_read_token\n");
+        dprintk("RPC:       krb5_read_token\n");
 
         if (g_verify_token_header(&ctx->mech_used, &bodysize, &ptr,
                                         read_token->len))
diff --git a/net/sunrpc/auth_gss/gss_krb5_wrap.c b/net/sunrpc/auth_gss/gss_krb5_wrap.c
index fe25b3d898dc..42b3220bed39 100644
--- a/net/sunrpc/auth_gss/gss_krb5_wrap.c
+++ b/net/sunrpc/auth_gss/gss_krb5_wrap.c
@@ -129,7 +129,7 @@ gss_wrap_kerberos(struct gss_ctx *ctx, int offset,
         struct page             **tmp_pages;
         u32                     seq_send;
 
-        dprintk("RPC:     gss_wrap_kerberos\n");
+        dprintk("RPC:       gss_wrap_kerberos\n");
 
         now = get_seconds();
 
@@ -215,7 +215,7 @@ gss_unwrap_kerberos(struct gss_ctx *ctx, int offset, struct xdr_buf *buf)
         int                     data_len;
         int                     blocksize;
 
-        dprintk("RPC:      gss_unwrap_kerberos\n");
+        dprintk("RPC:       gss_unwrap_kerberos\n");
 
         ptr = (u8 *)buf->head[0].iov_base + offset;
         if (g_verify_token_header(&kctx->mech_used, &bodysize, &ptr,
diff --git a/net/sunrpc/auth_gss/gss_mech_switch.c b/net/sunrpc/auth_gss/gss_mech_switch.c
index 3423890e4a30..26872517ccf3 100644
--- a/net/sunrpc/auth_gss/gss_mech_switch.c
+++ b/net/sunrpc/auth_gss/gss_mech_switch.c
@@ -113,7 +113,7 @@ gss_mech_register(struct gss_api_mech *gm)
         spin_lock(&registered_mechs_lock);
         list_add(&gm->gm_list, &registered_mechs);
         spin_unlock(&registered_mechs_lock);
-        dprintk("RPC:      registered gss mechanism %s\n", gm->gm_name);
+        dprintk("RPC:       registered gss mechanism %s\n", gm->gm_name);
         return 0;
 }
 
@@ -125,7 +125,7 @@ gss_mech_unregister(struct gss_api_mech *gm)
         spin_lock(&registered_mechs_lock);
         list_del(&gm->gm_list);
         spin_unlock(&registered_mechs_lock);
-        dprintk("RPC:      unregistered gss mechanism %s\n", gm->gm_name);
+        dprintk("RPC:       unregistered gss mechanism %s\n", gm->gm_name);
         gss_mech_free(gm);
 }
 
@@ -298,7 +298,7 @@ gss_unwrap(struct gss_ctx	*ctx_id,
 u32
 gss_delete_sec_context(struct gss_ctx   **context_handle)
 {
-        dprintk("RPC:      gss_delete_sec_context deleting %p\n",
+        dprintk("RPC:       gss_delete_sec_context deleting %p\n",
                         *context_handle);
 
         if (!*context_handle)
diff --git a/net/sunrpc/auth_gss/gss_spkm3_mech.c b/net/sunrpc/auth_gss/gss_spkm3_mech.c
index 8ef3f1c19435..7e15aa68ae64 100644
--- a/net/sunrpc/auth_gss/gss_spkm3_mech.c
+++ b/net/sunrpc/auth_gss/gss_spkm3_mech.c
@@ -97,7 +97,8 @@ gss_import_sec_context_spkm3(const void *p, size_t len,
         if (IS_ERR(p))
                 goto out_err_free_ctx;
         if (version != 1) {
-                dprintk("RPC: unknown spkm3 token format: obsolete nfs-utils?\n");
+                dprintk("RPC:       unknown spkm3 token format: "
+                                "obsolete nfs-utils?\n");
                 goto out_err_free_ctx;
         }
 
@@ -138,7 +139,7 @@ gss_import_sec_context_spkm3(const void *p, size_t len,
 
         ctx_id->internal_ctx_id = ctx;
 
-        dprintk("Successfully imported new spkm context.\n");
+        dprintk("RPC:       Successfully imported new spkm context.\n");
         return 0;
 
 out_err_free_intg_key:
@@ -183,7 +184,7 @@ gss_verify_mic_spkm3(struct gss_ctx		*ctx,
 
         maj_stat = spkm3_read_token(sctx, checksum, signbuf, SPKM_MIC_TOK);
 
-        dprintk("RPC: gss_verify_mic_spkm3 returning %d\n", maj_stat);
+        dprintk("RPC:       gss_verify_mic_spkm3 returning %d\n", maj_stat);
         return maj_stat;
 }
 
@@ -197,7 +198,7 @@ gss_get_mic_spkm3(struct gss_ctx	*ctx,
 
         err = spkm3_make_token(sctx, message_buffer,
                                 message_token, SPKM_MIC_TOK);
-        dprintk("RPC: gss_get_mic_spkm3 returning %d\n", err);
+        dprintk("RPC:       gss_get_mic_spkm3 returning %d\n", err);
         return err;
 }
 
diff --git a/net/sunrpc/auth_gss/gss_spkm3_seal.c b/net/sunrpc/auth_gss/gss_spkm3_seal.c
index b179d58c6249..104cbf4f769f 100644
--- a/net/sunrpc/auth_gss/gss_spkm3_seal.c
+++ b/net/sunrpc/auth_gss/gss_spkm3_seal.c
@@ -75,20 +75,21 @@ spkm3_make_token(struct spkm3_ctx *ctx,
         now = jiffies;
 
         if (ctx->ctx_id.len != 16) {
-                dprintk("RPC: spkm3_make_token BAD ctx_id.len %d\n",
+                dprintk("RPC:       spkm3_make_token BAD ctx_id.len %d\n",
                                 ctx->ctx_id.len);
                 goto out_err;
         }
 
         if (!g_OID_equal(&ctx->intg_alg, &hmac_md5_oid)) {
-                dprintk("RPC: gss_spkm3_seal: unsupported I-ALG algorithm."
-                                "only support hmac-md5 I-ALG.\n");
+                dprintk("RPC:       gss_spkm3_seal: unsupported I-ALG "
+                                "algorithm.  only support hmac-md5 I-ALG.\n");
                 goto out_err;
         } else
                 checksum_type = CKSUMTYPE_HMAC_MD5;
 
         if (!g_OID_equal(&ctx->conf_alg, &cast5_cbc_oid)) {
-                dprintk("RPC: gss_spkm3_seal: unsupported C-ALG algorithm\n");
+                dprintk("RPC:       gss_spkm3_seal: unsupported C-ALG "
+                                "algorithm\n");
                 goto out_err;
         }
 
@@ -113,7 +114,8 @@ spkm3_make_token(struct spkm3_ctx *ctx,
 
                 spkm3_make_mic_token(&ptr, tokenlen, &mic_hdr, &md5cksum, md5elen, md5zbit);
         } else if (toktype == SPKM_WRAP_TOK) { /* Not Supported */
-                dprintk("RPC: gss_spkm3_seal: SPKM_WRAP_TOK not supported\n");
+                dprintk("RPC:       gss_spkm3_seal: SPKM_WRAP_TOK "
+                                "not supported\n");
                 goto out_err;
         }
 
@@ -153,7 +155,7 @@ make_spkm3_checksum(s32 cksumtype, struct xdr_netobj *key, char *header,
                         cksumname = "md5";
                         break;
                 default:
-                        dprintk("RPC:      spkm3_make_checksum:"
+                        dprintk("RPC:       spkm3_make_checksum:"
                                         " unsupported checksum %d", cksumtype);
                         return GSS_S_FAILURE;
         }
diff --git a/net/sunrpc/auth_gss/gss_spkm3_token.c b/net/sunrpc/auth_gss/gss_spkm3_token.c
index 8400b621971e..6cdd241ad267 100644
--- a/net/sunrpc/auth_gss/gss_spkm3_token.c
+++ b/net/sunrpc/auth_gss/gss_spkm3_token.c
@@ -209,7 +209,7 @@ spkm3_verify_mic_token(unsigned char **tokp, int *mic_hdrlen, unsigned char **ck
 
         /* spkm3 innercontext token preamble */
         if ((ptr[0] != 0xa4) || (ptr[2] != 0x30)) {
-                dprintk("RPC: BAD SPKM ictoken preamble\n");
+                dprintk("RPC:       BAD SPKM ictoken preamble\n");
                 goto out;
         }
 
@@ -217,25 +217,25 @@ spkm3_verify_mic_token(unsigned char **tokp, int *mic_hdrlen, unsigned char **ck
 
         /* token type */
         if ((ptr[4] != 0x02) || (ptr[5] != 0x02)) {
-                dprintk("RPC: BAD asn1 SPKM3 token type\n");
+                dprintk("RPC:       BAD asn1 SPKM3 token type\n");
                 goto out;
         }
 
         /* only support SPKM_MIC_TOK */
         if((ptr[6] != 0x01) || (ptr[7] != 0x01)) {
-                dprintk("RPC: ERROR unsupported SPKM3 token \n");
+                dprintk("RPC:       ERROR unsupported SPKM3 token \n");
                 goto out;
         }
 
         /* contextid */
         if (ptr[8] != 0x03) {
-                dprintk("RPC: BAD SPKM3 asn1 context-id type\n");
+                dprintk("RPC:       BAD SPKM3 asn1 context-id type\n");
                 goto out;
         }
 
         ctxelen = ptr[9];
         if (ctxelen > 17) {  /* length includes asn1 zbit octet */
-                dprintk("RPC: BAD SPKM3 contextid len %d\n", ctxelen);
+                dprintk("RPC:       BAD SPKM3 contextid len %d\n", ctxelen);
                 goto out;
         }
 
@@ -251,7 +251,9 @@ spkm3_verify_mic_token(unsigned char **tokp, int *mic_hdrlen, unsigned char **ck
         */
 
         if (*mic_hdrlen != 6 + ctxelen) {
-                dprintk("RPC: BAD SPKM_ MIC_TOK header len %d: we only support default int-alg (should be absent) and do not support snd-seq\n", *mic_hdrlen);
+                dprintk("RPC:       BAD SPKM_ MIC_TOK header len %d: we only "
+                                "support default int-alg (should be absent) "
+                                "and do not support snd-seq\n", *mic_hdrlen);
                 goto out;
         }
         /* checksum */
diff --git a/net/sunrpc/auth_gss/gss_spkm3_unseal.c b/net/sunrpc/auth_gss/gss_spkm3_unseal.c
index 35a1b34c4a1d..cc21ee860bb6 100644
--- a/net/sunrpc/auth_gss/gss_spkm3_unseal.c
+++ b/net/sunrpc/auth_gss/gss_spkm3_unseal.c
@@ -72,7 +72,7 @@ spkm3_read_token(struct spkm3_ctx *ctx,
         /* decode the token */
 
         if (toktype != SPKM_MIC_TOK) {
-                dprintk("RPC: BAD SPKM3 token type: %d\n", toktype);
+                dprintk("RPC:       BAD SPKM3 token type: %d\n", toktype);
                 goto out;
         }
 
@@ -80,7 +80,7 @@ spkm3_read_token(struct spkm3_ctx *ctx,
                 goto out;
 
         if (*cksum++ != 0x03) {
-                dprintk("RPC: spkm3_read_token BAD checksum type\n");
+                dprintk("RPC:       spkm3_read_token BAD checksum type\n");
                 goto out;
         }
         md5elen = *cksum++;
@@ -97,7 +97,8 @@ spkm3_read_token(struct spkm3_ctx *ctx,
          */
         ret = GSS_S_DEFECTIVE_TOKEN;
         if (!g_OID_equal(&ctx->intg_alg, &hmac_md5_oid)) {
-                dprintk("RPC: gss_spkm3_seal: unsupported I-ALG algorithm\n");
+                dprintk("RPC:       gss_spkm3_seal: unsupported I-ALG "
+                                "algorithm\n");
                 goto out;
         }
 
@@ -113,7 +114,7 @@ spkm3_read_token(struct spkm3_ctx *ctx,
         ret = GSS_S_BAD_SIG;
         code = memcmp(md5cksum.data, wire_cksum.data, wire_cksum.len);
         if (code) {
-                dprintk("RPC: bad MIC checksum\n");
+                dprintk("RPC:       bad MIC checksum\n");
                 goto out;
         }
 
diff --git a/net/sunrpc/auth_gss/svcauth_gss.c b/net/sunrpc/auth_gss/svcauth_gss.c
index 8fde38ecaf21..db298b501c81 100644
--- a/net/sunrpc/auth_gss/svcauth_gss.c
+++ b/net/sunrpc/auth_gss/svcauth_gss.c
@@ -669,14 +669,14 @@ gss_verify_header(struct svc_rqst *rqstp, struct rsc *rsci,
         }
 
         if (gc->gc_seq > MAXSEQ) {
-                dprintk("RPC:      svcauth_gss: discarding request with large sequence number %d\n",
-                                gc->gc_seq);
+                dprintk("RPC:       svcauth_gss: discarding request with "
+                                "large sequence number %d\n", gc->gc_seq);
                 *authp = rpcsec_gsserr_ctxproblem;
                 return SVC_DENIED;
         }
         if (!gss_check_seq_num(rsci, gc->gc_seq)) {
-                dprintk("RPC:      svcauth_gss: discarding request with old sequence number %d\n",
-                                gc->gc_seq);
+                dprintk("RPC:       svcauth_gss: discarding request with "
+                                "old sequence number %d\n", gc->gc_seq);
                 return SVC_DROP;
         }
         return SVC_OK;
@@ -958,7 +958,8 @@ svcauth_gss_accept(struct svc_rqst *rqstp, __be32 *authp)
         __be32          *reject_stat = resv->iov_base + resv->iov_len;
         int             ret;
 
-        dprintk("RPC:      svcauth_gss: argv->iov_len = %zd\n",argv->iov_len);
+        dprintk("RPC:       svcauth_gss: argv->iov_len = %zd\n",
+                        argv->iov_len);
 
         *authp = rpc_autherr_badcred;
         if (!svcdata)
diff --git a/net/sunrpc/auth_null.c b/net/sunrpc/auth_null.c
index 3be257dc32b2..3df9fccab2f8 100644
--- a/net/sunrpc/auth_null.c
+++ b/net/sunrpc/auth_null.c
@@ -10,7 +10,6 @@
 #include <linux/module.h>
 #include <linux/utsname.h>
 #include <linux/sunrpc/clnt.h>
-#include <linux/sched.h>
 
 #ifdef RPC_DEBUG
 # define RPCDBG_FACILITY        RPCDBG_AUTH
diff --git a/net/sunrpc/auth_unix.c b/net/sunrpc/auth_unix.c
index f7f990c9afe2..4e7733aee36e 100644
--- a/net/sunrpc/auth_unix.c
+++ b/net/sunrpc/auth_unix.c
@@ -39,7 +39,8 @@ static struct rpc_credops	unix_credops;
 static struct rpc_auth *
 unx_create(struct rpc_clnt *clnt, rpc_authflavor_t flavor)
 {
-        dprintk("RPC: creating UNIX authenticator for client %p\n", clnt);
+        dprintk("RPC:       creating UNIX authenticator for client %p\n",
+                        clnt);
         if (atomic_inc_return(&unix_auth.au_count) == 0)
                 unix_cred_cache.nextgc = jiffies + (unix_cred_cache.expire >> 1);
         return &unix_auth;
@@ -48,7 +49,7 @@ unx_create(struct rpc_clnt *clnt, rpc_authflavor_t flavor)
 static void
 unx_destroy(struct rpc_auth *auth)
 {
-        dprintk("RPC: destroying UNIX authenticator %p\n", auth);
+        dprintk("RPC:       destroying UNIX authenticator %p\n", auth);
         rpcauth_free_credcache(auth);
 }
 
@@ -67,8 +68,8 @@ unx_create_cred(struct rpc_auth *auth, struct auth_cred *acred, int flags)
         struct unx_cred *cred;
         int             i;
 
-        dprintk("RPC:      allocating UNIX cred for uid %d gid %d\n",
-                                acred->uid, acred->gid);
+        dprintk("RPC:       allocating UNIX cred for uid %d gid %d\n",
+                        acred->uid, acred->gid);
 
         if (!(cred = kmalloc(sizeof(*cred), GFP_KERNEL)))
                 return ERR_PTR(-ENOMEM);
diff --git a/net/sunrpc/cache.c b/net/sunrpc/cache.c
index 8612044b9189..f02f24ae9468 100644
--- a/net/sunrpc/cache.c
+++ b/net/sunrpc/cache.c
@@ -215,7 +215,8 @@ int cache_check(struct cache_detail *detail,
                 if (rv == -EAGAIN)
                         rv = -ENOENT;
         } else if (rv == -EAGAIN || age > refresh_age/2) {
-                dprintk("Want update, refage=%ld, age=%ld\n", refresh_age, age);
+                dprintk("RPC:       Want update, refage=%ld, age=%ld\n",
+                                refresh_age, age);
                 if (!test_and_set_bit(CACHE_PENDING, &h->flags)) {
                         switch (cache_make_upcall(detail, h)) {
                         case -EINVAL:
diff --git a/net/sunrpc/clnt.c b/net/sunrpc/clnt.c
index c95a61736d1c..6d7221fe990a 100644
--- a/net/sunrpc/clnt.c
+++ b/net/sunrpc/clnt.c
@@ -42,6 +42,10 @@
 # define RPCDBG_FACILITY        RPCDBG_CALL
 #endif
 
+#define dprint_status(t)                                        \
+        dprintk("RPC: %5u %s (status %d)\n", t->tk_pid,         \
+                        __FUNCTION__, t->tk_status)
+
 static DECLARE_WAIT_QUEUE_HEAD(destroy_wait);
 
 
@@ -106,8 +110,8 @@ static struct rpc_clnt * rpc_new_client(struct rpc_xprt *xprt, char *servname, s
         int err;
         int len;
 
-        dprintk("RPC: creating %s client for %s (xprt %p)\n",
-                program->name, servname, xprt);
+        dprintk("RPC:       creating %s client for %s (xprt %p)\n",
+                        program->name, servname, xprt);
 
         err = -EINVAL;
         if (!xprt)
@@ -220,7 +224,7 @@ struct rpc_clnt *rpc_create(struct rpc_create_args *args)
                 xprt->resvport = 0;
 
         dprintk("RPC:       creating %s client for %s (xprt %p)\n",
-                args->program->name, args->servername, xprt);
+                        args->program->name, args->servername, xprt);
 
         clnt = rpc_new_client(xprt, args->servername, args->program,
                                 args->version, args->authflavor);
@@ -245,6 +249,8 @@ struct rpc_clnt *rpc_create(struct rpc_create_args *args)
                 clnt->cl_autobind = 1;
         if (args->flags & RPC_CLNT_CREATE_ONESHOT)
                 clnt->cl_oneshot = 1;
+        if (args->flags & RPC_CLNT_CREATE_DISCRTRY)
+                clnt->cl_discrtry = 1;
 
         return clnt;
 }
@@ -288,7 +294,7 @@ out_no_path:
 out_no_stats:
         kfree(new);
 out_no_clnt:
-        dprintk("RPC: %s returned error %d\n", __FUNCTION__, err);
+        dprintk("RPC:       %s: returned error %d\n", __FUNCTION__, err);
         return ERR_PTR(err);
 }
 
@@ -301,7 +307,7 @@ out_no_clnt:
 int
 rpc_shutdown_client(struct rpc_clnt *clnt)
 {
-        dprintk("RPC: shutting down %s client for %s, tasks=%d\n",
+        dprintk("RPC:       shutting down %s client for %s, tasks=%d\n",
                         clnt->cl_protname, clnt->cl_server,
                         atomic_read(&clnt->cl_users));
 
@@ -336,7 +342,7 @@ rpc_destroy_client(struct rpc_clnt *clnt)
                 return 1;
         BUG_ON(atomic_read(&clnt->cl_users) != 0);
 
-        dprintk("RPC: destroying %s client for %s\n",
+        dprintk("RPC:       destroying %s client for %s\n",
                         clnt->cl_protname, clnt->cl_server);
         if (clnt->cl_auth) {
                 rpcauth_destroy(clnt->cl_auth);
@@ -366,8 +372,8 @@ out_free:
 void
 rpc_release_client(struct rpc_clnt *clnt)
 {
-        dprintk("RPC:      rpc_release_client(%p, %d)\n",
-                                clnt, atomic_read(&clnt->cl_users));
+        dprintk("RPC:       rpc_release_client(%p, %d)\n",
+                        clnt, atomic_read(&clnt->cl_users));
 
         if (!atomic_dec_and_test(&clnt->cl_users))
                 return;
@@ -486,17 +492,13 @@ int rpc_call_sync(struct rpc_clnt *clnt, struct rpc_message *msg, int flags)
         /* Mask signals on RPC calls _and_ GSS_AUTH upcalls */
         rpc_task_sigmask(task, &oldset);
 
-        rpc_call_setup(task, msg, 0);
-
         /* Set up the call info struct and execute the task */
+        rpc_call_setup(task, msg, 0);
+        if (task->tk_status == 0) {
+                atomic_inc(&task->tk_count);
+                rpc_execute(task);
+        }
         status = task->tk_status;
-        if (status != 0)
-                goto out;
-        atomic_inc(&task->tk_count);
-        status = rpc_execute(task);
-        if (status == 0)
-                status = task->tk_status;
-out:
         rpc_put_task(task);
         rpc_restore_sigmask(&oldset);
         return status;
@@ -658,9 +660,10 @@ call_start(struct rpc_task *task)
 {
         struct rpc_clnt *clnt = task->tk_client;
 
-        dprintk("RPC: %4d call_start %s%d proc %d (%s)\n", task->tk_pid,
-                clnt->cl_protname, clnt->cl_vers, task->tk_msg.rpc_proc->p_proc,
-                (RPC_IS_ASYNC(task) ? "async" : "sync"));
+        dprintk("RPC: %5u call_start %s%d proc %d (%s)\n", task->tk_pid,
+                        clnt->cl_protname, clnt->cl_vers,
+                        task->tk_msg.rpc_proc->p_proc,
+                        (RPC_IS_ASYNC(task) ? "async" : "sync"));
 
         /* Increment call count */
         task->tk_msg.rpc_proc->p_count++;
@@ -674,7 +677,7 @@ call_start(struct rpc_task *task)
 static void
 call_reserve(struct rpc_task *task)
 {
-        dprintk("RPC: %4d call_reserve\n", task->tk_pid);
+        dprint_status(task);
 
         if (!rpcauth_uptodatecred(task)) {
                 task->tk_action = call_refresh;
@@ -694,8 +697,7 @@ call_reserveresult(struct rpc_task *task)
 {
         int status = task->tk_status;
 
-        dprintk("RPC: %4d call_reserveresult (status %d)\n",
-                                task->tk_pid, task->tk_status);
+        dprint_status(task);
 
         /*
          * After a call to xprt_reserve(), we must have either
@@ -749,8 +751,8 @@ call_allocate(struct rpc_task *task)
         struct rpc_xprt *xprt = task->tk_xprt;
         unsigned int    bufsiz;
 
-        dprintk("RPC: %4d call_allocate (status %d)\n",
-                                task->tk_pid, task->tk_status);
+        dprint_status(task);
+
         task->tk_action = call_bind;
         if (req->rq_buffer)
                 return;
@@ -761,7 +763,8 @@ call_allocate(struct rpc_task *task)
 
         if (xprt->ops->buf_alloc(task, bufsiz << 1) != NULL)
                 return;
-        printk(KERN_INFO "RPC: buffer allocation failed for task %p\n", task);
+
+        dprintk("RPC: %5u rpc_buffer allocation failed\n", task->tk_pid);
 
         if (RPC_IS_ASYNC(task) || !signalled()) {
                 xprt_release(task);
@@ -798,8 +801,7 @@ call_encode(struct rpc_task *task)
         kxdrproc_t      encode;
         __be32          *p;
 
-        dprintk("RPC: %4d call_encode (status %d)\n",
-                                task->tk_pid, task->tk_status);
+        dprint_status(task);
 
         /* Default buffer setup */
         bufsiz = req->rq_bufsize >> 1;
@@ -845,8 +847,7 @@ call_bind(struct rpc_task *task)
 {
         struct rpc_xprt *xprt = task->tk_xprt;
 
-        dprintk("RPC: %4d call_bind (status %d)\n",
-                                task->tk_pid, task->tk_status);
+        dprint_status(task);
 
         task->tk_action = call_connect;
         if (!xprt_bound(xprt)) {
@@ -865,8 +866,7 @@ call_bind_status(struct rpc_task *task)
         int status = -EACCES;
 
         if (task->tk_status >= 0) {
-                dprintk("RPC: %4d call_bind_status (status %d)\n",
-                                        task->tk_pid, task->tk_status);
+                dprint_status(task);
                 task->tk_status = 0;
                 task->tk_action = call_connect;
                 return;
@@ -874,24 +874,24 @@ call_bind_status(struct rpc_task *task)
 
         switch (task->tk_status) {
         case -EACCES:
-                dprintk("RPC: %4d remote rpcbind: RPC program/version unavailable\n",
-                                task->tk_pid);
+                dprintk("RPC: %5u remote rpcbind: RPC program/version "
+                                "unavailable\n", task->tk_pid);
                 rpc_delay(task, 3*HZ);
                 goto retry_timeout;
         case -ETIMEDOUT:
-                dprintk("RPC: %4d rpcbind request timed out\n",
+                dprintk("RPC: %5u rpcbind request timed out\n",
                                 task->tk_pid);
                 goto retry_timeout;
         case -EPFNOSUPPORT:
-                dprintk("RPC: %4d remote rpcbind service unavailable\n",
+                dprintk("RPC: %5u remote rpcbind service unavailable\n",
                                 task->tk_pid);
                 break;
         case -EPROTONOSUPPORT:
-                dprintk("RPC: %4d remote rpcbind version 2 unavailable\n",
+                dprintk("RPC: %5u remote rpcbind version 2 unavailable\n",
                                 task->tk_pid);
                 break;
         default:
-                dprintk("RPC: %4d unrecognized rpcbind error (%d)\n",
+                dprintk("RPC: %5u unrecognized rpcbind error (%d)\n",
                                 task->tk_pid, -task->tk_status);
                 status = -EIO;
         }
@@ -911,7 +911,7 @@ call_connect(struct rpc_task *task)
 {
         struct rpc_xprt *xprt = task->tk_xprt;
 
-        dprintk("RPC: %4d call_connect xprt %p %s connected\n",
+        dprintk("RPC: %5u call_connect xprt %p %s connected\n",
                         task->tk_pid, xprt,
                         (xprt_connected(xprt) ? "is" : "is not"));
 
@@ -933,8 +933,7 @@ call_connect_status(struct rpc_task *task)
         struct rpc_clnt *clnt = task->tk_client;
         int status = task->tk_status;
 
-        dprintk("RPC: %5u call_connect_status (status %d)\n",
-                                task->tk_pid, task->tk_status);
+        dprint_status(task);
 
         task->tk_status = 0;
         if (status >= 0) {
@@ -966,8 +965,7 @@ call_connect_status(struct rpc_task *task)
 static void
 call_transmit(struct rpc_task *task)
 {
-        dprintk("RPC: %4d call_transmit (status %d)\n",
-                                task->tk_pid, task->tk_status);
+        dprint_status(task);
 
         task->tk_action = call_status;
         if (task->tk_status < 0)
@@ -1028,8 +1026,7 @@ call_status(struct rpc_task *task)
         if (req->rq_received > 0 && !req->rq_bytes_sent)
                 task->tk_status = req->rq_received;
 
-        dprintk("RPC: %4d call_status (status %d)\n",
-                                task->tk_pid, task->tk_status);
+        dprint_status(task);
 
         status = task->tk_status;
         if (status >= 0) {
@@ -1080,11 +1077,11 @@ call_timeout(struct rpc_task *task)
         struct rpc_clnt *clnt = task->tk_client;
 
         if (xprt_adjust_timeout(task->tk_rqstp) == 0) {
-                dprintk("RPC: %4d call_timeout (minor)\n", task->tk_pid);
+                dprintk("RPC: %5u call_timeout (minor)\n", task->tk_pid);
                 goto retry;
         }
 
-        dprintk("RPC: %4d call_timeout (major)\n", task->tk_pid);
+        dprintk("RPC: %5u call_timeout (major)\n", task->tk_pid);
         task->tk_timeouts++;
 
         if (RPC_IS_SOFT(task)) {
@@ -1118,8 +1115,8 @@ call_decode(struct rpc_task *task)
         kxdrproc_t      decode = task->tk_msg.rpc_proc->p_decode;
         __be32          *p;
 
-        dprintk("RPC: %4d call_decode (status %d)\n",
-                                task->tk_pid, task->tk_status);
+        dprintk("RPC: %5u call_decode (status %d)\n",
+                        task->tk_pid, task->tk_status);
 
         if (task->tk_flags & RPC_CALL_MAJORSEEN) {
                 printk(KERN_NOTICE "%s: server %s OK\n",
@@ -1133,8 +1130,8 @@ call_decode(struct rpc_task *task)
                         clnt->cl_stats->rpcretrans++;
                         goto out_retry;
                 }
-                dprintk("%s: too small RPC reply size (%d bytes)\n",
-                        clnt->cl_protname, task->tk_status);
+                dprintk("RPC:       %s: too small RPC reply size (%d bytes)\n",
+                                clnt->cl_protname, task->tk_status);
                 task->tk_action = call_timeout;
                 goto out_retry;
         }
@@ -1166,8 +1163,8 @@ call_decode(struct rpc_task *task)
                                                       task->tk_msg.rpc_resp);
                 unlock_kernel();
         }
-        dprintk("RPC: %4d call_decode result %d\n", task->tk_pid,
-                                        task->tk_status);
+        dprintk("RPC: %5u call_decode result %d\n", task->tk_pid,
+                        task->tk_status);
         return;
 out_retry:
         req->rq_received = req->rq_private_buf.len = 0;
@@ -1180,7 +1177,7 @@ out_retry:
 static void
 call_refresh(struct rpc_task *task)
 {
-        dprintk("RPC: %4d call_refresh\n", task->tk_pid);
+        dprint_status(task);
 
         xprt_release(task);     /* Must do to obtain new XID */
         task->tk_action = call_refreshresult;
@@ -1196,8 +1193,8 @@ static void
 call_refreshresult(struct rpc_task *task)
 {
         int status = task->tk_status;
-        dprintk("RPC: %4d call_refreshresult (status %d)\n",
-                                task->tk_pid, task->tk_status);
+
+        dprint_status(task);
 
         task->tk_status = 0;
         task->tk_action = call_reserve;
@@ -1275,11 +1272,15 @@ call_verify(struct rpc_task *task)
                         case RPC_AUTH_ERROR:
                                 break;
                         case RPC_MISMATCH:
-                                dprintk("%s: RPC call version mismatch!\n", __FUNCTION__);
+                                dprintk("RPC: %5u %s: RPC call version "
+                                                "mismatch!\n",
+                                                task->tk_pid, __FUNCTION__);
                                 error = -EPROTONOSUPPORT;
                                 goto out_err;
                         default:
-                                dprintk("%s: RPC call rejected, unknown error: %x\n", __FUNCTION__, n);
+                                dprintk("RPC: %5u %s: RPC call rejected, "
+                                                "unknown error: %x\n",
+                                                task->tk_pid, __FUNCTION__, n);
                                 goto out_eio;
                 }
                 if (--len < 0)
@@ -1292,8 +1293,8 @@ call_verify(struct rpc_task *task)
                         if (!task->tk_cred_retry)
                                 break;
                         task->tk_cred_retry--;
-                        dprintk("RPC: %4d call_verify: retry stale creds\n",
-                                                        task->tk_pid);
+                        dprintk("RPC: %5u %s: retry stale creds\n",
+                                        task->tk_pid, __FUNCTION__);
                         rpcauth_invalcred(task);
                         task->tk_action = call_refresh;
                         goto out_retry;
@@ -1303,8 +1304,8 @@ call_verify(struct rpc_task *task)
                         if (!task->tk_garb_retry)
                                 break;
                         task->tk_garb_retry--;
-                        dprintk("RPC: %4d call_verify: retry garbled creds\n",
-                                                        task->tk_pid);
+                        dprintk("RPC: %5u %s: retry garbled creds\n",
+                                        task->tk_pid, __FUNCTION__);
                         task->tk_action = call_bind;
                         goto out_retry;
                 case RPC_AUTH_TOOWEAK:
@@ -1315,8 +1316,8 @@ call_verify(struct rpc_task *task)
                         printk(KERN_WARNING "call_verify: unknown auth error: %x\n", n);
                         error = -EIO;
                 }
-                dprintk("RPC: %4d call_verify: call rejected %d\n",
-                                                task->tk_pid, n);
+                dprintk("RPC: %5u %s: call rejected %d\n",
+                                task->tk_pid, __FUNCTION__, n);
                 goto out_err;
         }
         if (!(p = rpcauth_checkverf(task, p))) {
@@ -1330,20 +1331,24 @@ call_verify(struct rpc_task *task)
         case RPC_SUCCESS:
                 return p;
         case RPC_PROG_UNAVAIL:
-                dprintk("RPC: call_verify: program %u is unsupported by server %s\n",
+                dprintk("RPC: %5u %s: program %u is unsupported by server %s\n",
+                                task->tk_pid, __FUNCTION__,
                                 (unsigned int)task->tk_client->cl_prog,
                                 task->tk_client->cl_server);
                 error = -EPFNOSUPPORT;
                 goto out_err;
         case RPC_PROG_MISMATCH:
-                dprintk("RPC: call_verify: program %u, version %u unsupported by server %s\n",
+                dprintk("RPC: %5u %s: program %u, version %u unsupported by "
+                                "server %s\n", task->tk_pid, __FUNCTION__,
                                 (unsigned int)task->tk_client->cl_prog,
                                 (unsigned int)task->tk_client->cl_vers,
                                 task->tk_client->cl_server);
                 error = -EPROTONOSUPPORT;
                 goto out_err;
         case RPC_PROC_UNAVAIL:
-                dprintk("RPC: call_verify: proc %p unsupported by program %u, version %u on server %s\n",
+                dprintk("RPC: %5u %s: proc %p unsupported by program %u, "
+                                "version %u on server %s\n",
+                                task->tk_pid, __FUNCTION__,
                                 task->tk_msg.rpc_proc,
                                 task->tk_client->cl_prog,
                                 task->tk_client->cl_vers,
@@ -1351,7 +1356,8 @@ call_verify(struct rpc_task *task)
                 error = -EOPNOTSUPP;
                 goto out_err;
         case RPC_GARBAGE_ARGS:
-                dprintk("RPC: %4d %s: server saw garbage\n", task->tk_pid, __FUNCTION__);
+                dprintk("RPC: %5u %s: server saw garbage\n",
+                                task->tk_pid, __FUNCTION__);
                 break;                  /* retry */
         default:
                 printk(KERN_WARNING "call_verify: server accept status: %x\n", n);
@@ -1362,7 +1368,8 @@ out_garbage:
         task->tk_client->cl_stats->rpcgarbage++;
         if (task->tk_garb_retry) {
                 task->tk_garb_retry--;
-                dprintk("RPC %s: retrying %4d\n", __FUNCTION__, task->tk_pid);
+                dprintk("RPC: %5u %s: retrying\n",
+                                task->tk_pid, __FUNCTION__);
                 task->tk_action = call_bind;
 out_retry:
                 return ERR_PTR(-EAGAIN);
diff --git a/net/sunrpc/pmap_clnt.c b/net/sunrpc/pmap_clnt.c
index f4e1357bc186..d9f765344589 100644
--- a/net/sunrpc/pmap_clnt.c
+++ b/net/sunrpc/pmap_clnt.c
@@ -62,7 +62,10 @@ static inline void pmap_map_free(struct portmap_args *map)
 
 static void pmap_map_release(void *data)
 {
-        pmap_map_free(data);
+        struct portmap_args *map = data;
+
+        xprt_put(map->pm_xprt);
+        pmap_map_free(map);
 }
 
 static const struct rpc_call_ops pmap_getport_ops = {
@@ -94,7 +97,7 @@ void rpc_getport(struct rpc_task *task)
         struct rpc_task *child;
         int status;
 
-        dprintk("RPC: %4d rpc_getport(%s, %u, %u, %d)\n",
+        dprintk("RPC: %5u rpc_getport(%s, %u, %u, %d)\n",
                         task->tk_pid, clnt->cl_server,
                         clnt->cl_prog, clnt->cl_vers, xprt->prot);
 
@@ -133,7 +136,7 @@ void rpc_getport(struct rpc_task *task)
         status = -EIO;
         child = rpc_run_task(pmap_clnt, RPC_TASK_ASYNC, &pmap_getport_ops, map);
         if (IS_ERR(child))
-                goto bailout;
+                goto bailout_nofree;
         rpc_put_task(child);
 
         task->tk_xprt->stat.bind_count++;
@@ -175,7 +178,7 @@ int rpc_getport_external(struct sockaddr_in *sin, __u32 prog, __u32 vers, int pr
         char            hostname[32];
         int             status;
 
-        dprintk("RPC:      rpc_getport_external(%u.%u.%u.%u, %u, %u, %d)\n",
+        dprintk("RPC:       rpc_getport_external(%u.%u.%u.%u, %u, %u, %d)\n",
                         NIPQUAD(sin->sin_addr.s_addr), prog, vers, prot);
 
         sprintf(hostname, "%u.%u.%u.%u", NIPQUAD(sin->sin_addr.s_addr));
@@ -218,11 +221,10 @@ static void pmap_getport_done(struct rpc_task *child, void *data)
                 status = 0;
         }
 
-        dprintk("RPC: %4d pmap_getport_done(status %d, port %u)\n",
+        dprintk("RPC: %5u pmap_getport_done(status %d, port %u)\n",
                         child->tk_pid, status, map->pm_port);
 
         pmap_wake_portmap_waiters(xprt, status);
-        xprt_put(xprt);
 }
 
 /**
@@ -255,13 +257,14 @@ int rpc_register(u32 prog, u32 vers, int prot, unsigned short port, int *okay)
         struct rpc_clnt         *pmap_clnt;
         int error = 0;
 
-        dprintk("RPC: registering (%u, %u, %d, %u) with portmapper.\n",
+        dprintk("RPC:       registering (%u, %u, %d, %u) with portmapper.\n",
                         prog, vers, prot, port);
 
         pmap_clnt = pmap_create("localhost", &sin, IPPROTO_UDP, 1);
         if (IS_ERR(pmap_clnt)) {
                 error = PTR_ERR(pmap_clnt);
-                dprintk("RPC: couldn't create pmap client. Error = %d\n", error);
+                dprintk("RPC:       couldn't create pmap client. Error = %d\n",
+                                error);
                 return error;
         }
 
@@ -272,7 +275,7 @@ int rpc_register(u32 prog, u32 vers, int prot, unsigned short port, int *okay)
                         "RPC: failed to contact portmap (errno %d).\n",
                         error);
         }
-        dprintk("RPC: registration status %d/%d\n", error, *okay);
+        dprintk("RPC:       registration status %d/%d\n", error, *okay);
 
         /* Client deleted automatically because cl_oneshot == 1 */
         return error;
@@ -303,8 +306,9 @@ static struct rpc_clnt *pmap_create(char *hostname, struct sockaddr_in *srvaddr,
  */
 static int xdr_encode_mapping(struct rpc_rqst *req, __be32 *p, struct portmap_args *map)
 {
-        dprintk("RPC: xdr_encode_mapping(%u, %u, %u, %u)\n",
-                map->pm_prog, map->pm_vers, map->pm_prot, map->pm_port);
+        dprintk("RPC:       xdr_encode_mapping(%u, %u, %u, %u)\n",
+                        map->pm_prog, map->pm_vers,
+                        map->pm_prot, map->pm_port);
         *p++ = htonl(map->pm_prog);
         *p++ = htonl(map->pm_vers);
         *p++ = htonl(map->pm_prot);
diff --git a/net/sunrpc/rpc_pipe.c b/net/sunrpc/rpc_pipe.c
index e1fad77a2257..9b9ea5045569 100644
--- a/net/sunrpc/rpc_pipe.c
+++ b/net/sunrpc/rpc_pipe.c
@@ -589,7 +589,7 @@ __rpc_mkdir(struct inode *dir, struct dentry *dentry)
 {
         struct inode *inode;
 
-        inode = rpc_get_inode(dir->i_sb, S_IFDIR | S_IRUSR | S_IXUSR);
+        inode = rpc_get_inode(dir->i_sb, S_IFDIR | S_IRUGO | S_IXUGO);
         if (!inode)
                 goto out_err;
         inode->i_ino = iunique(dir->i_sb, 100);
diff --git a/net/sunrpc/sched.c b/net/sunrpc/sched.c
index 54a6b92525ea..6d87320074b1 100644
--- a/net/sunrpc/sched.c
+++ b/net/sunrpc/sched.c
@@ -74,7 +74,7 @@ static DEFINE_SPINLOCK(rpc_sched_lock);
 static inline void
 __rpc_disable_timer(struct rpc_task *task)
 {
-        dprintk("RPC: %4d disabling timer\n", task->tk_pid);
+        dprintk("RPC: %5u disabling timer\n", task->tk_pid);
         task->tk_timeout_fn = NULL;
         task->tk_timeout = 0;
 }
@@ -93,7 +93,7 @@ static void rpc_run_timer(struct rpc_task *task)
         callback = task->tk_timeout_fn;
         task->tk_timeout_fn = NULL;
         if (callback && RPC_IS_QUEUED(task)) {
-                dprintk("RPC: %4d running timer\n", task->tk_pid);
+                dprintk("RPC: %5u running timer\n", task->tk_pid);
                 callback(task);
         }
         smp_mb__before_clear_bit();
@@ -110,7 +110,7 @@ __rpc_add_timer(struct rpc_task *task, rpc_action timer)
         if (!task->tk_timeout)
                 return;
 
-        dprintk("RPC: %4d setting alarm for %lu ms\n",
+        dprintk("RPC: %5u setting alarm for %lu ms\n",
                         task->tk_pid, task->tk_timeout * 1000 / HZ);
 
         if (timer)
@@ -132,7 +132,7 @@ rpc_delete_timer(struct rpc_task *task)
                 return;
         if (test_and_clear_bit(RPC_TASK_HAS_TIMER, &task->tk_runstate)) {
                 del_singleshot_timer_sync(&task->tk_timer);
-                dprintk("RPC: %4d deleting timer\n", task->tk_pid);
+                dprintk("RPC: %5u deleting timer\n", task->tk_pid);
         }
 }
 
@@ -179,8 +179,8 @@ static void __rpc_add_wait_queue(struct rpc_wait_queue *queue, struct rpc_task *
         queue->qlen++;
         rpc_set_queued(task);
 
-        dprintk("RPC: %4d added to queue %p \"%s\"\n",
-                                task->tk_pid, queue, rpc_qname(queue));
+        dprintk("RPC: %5u added to queue %p \"%s\"\n",
+                        task->tk_pid, queue, rpc_qname(queue));
 }
 
 /*
@@ -212,8 +212,8 @@ static void __rpc_remove_wait_queue(struct rpc_task *task)
         else
                 list_del(&task->u.tk_wait.list);
         queue->qlen--;
-        dprintk("RPC: %4d removed from queue %p \"%s\"\n",
-                                task->tk_pid, queue, rpc_qname(queue));
+        dprintk("RPC: %5u removed from queue %p \"%s\"\n",
+                        task->tk_pid, queue, rpc_qname(queue));
 }
 
 static inline void rpc_set_waitqueue_priority(struct rpc_wait_queue *queue, int priority)
@@ -344,8 +344,8 @@ static void rpc_make_runnable(struct rpc_task *task)
 static void __rpc_sleep_on(struct rpc_wait_queue *q, struct rpc_task *task,
                         rpc_action action, rpc_action timer)
 {
-        dprintk("RPC: %4d sleep_on(queue \"%s\" time %ld)\n", task->tk_pid,
-                                rpc_qname(q), jiffies);
+        dprintk("RPC: %5u sleep_on(queue \"%s\" time %lu)\n",
+                        task->tk_pid, rpc_qname(q), jiffies);
 
         if (!RPC_IS_ASYNC(task) && !RPC_IS_ACTIVATED(task)) {
                 printk(KERN_ERR "RPC: Inactive synchronous task put to sleep!\n");
@@ -381,7 +381,8 @@ void rpc_sleep_on(struct rpc_wait_queue *q, struct rpc_task *task,
  */
 static void __rpc_do_wake_up_task(struct rpc_task *task)
 {
-        dprintk("RPC: %4d __rpc_wake_up_task (now %ld)\n", task->tk_pid, jiffies);
+        dprintk("RPC: %5u __rpc_wake_up_task (now %lu)\n",
+                        task->tk_pid, jiffies);
 
 #ifdef RPC_DEBUG
         BUG_ON(task->tk_magic != RPC_TASK_MAGIC_ID);
@@ -397,7 +398,7 @@ static void __rpc_do_wake_up_task(struct rpc_task *task)
 
         rpc_make_runnable(task);
 
-        dprintk("RPC:      __rpc_wake_up_task done\n");
+        dprintk("RPC:       __rpc_wake_up_task done\n");
 }
 
 /*
@@ -418,7 +419,7 @@ static void __rpc_wake_up_task(struct rpc_task *task)
 static void
 __rpc_default_timer(struct rpc_task *task)
 {
-        dprintk("RPC: %d timeout (default timer)\n", task->tk_pid);
+        dprintk("RPC: %5u timeout (default timer)\n", task->tk_pid);
         task->tk_status = -ETIMEDOUT;
         rpc_wake_up_task(task);
 }
@@ -502,7 +503,8 @@ struct rpc_task * rpc_wake_up_next(struct rpc_wait_queue *queue)
 {
         struct rpc_task *task = NULL;
 
-        dprintk("RPC:      wake_up_next(%p \"%s\")\n", queue, rpc_qname(queue));
+        dprintk("RPC:       wake_up_next(%p \"%s\")\n",
+                        queue, rpc_qname(queue));
         rcu_read_lock_bh();
         spin_lock(&queue->lock);
         if (RPC_IS_PRIORITY(queue))
@@ -625,12 +627,12 @@ void rpc_release_calldata(const struct rpc_call_ops *ops, void *calldata)
 /*
  * This is the RPC `scheduler' (or rather, the finite state machine).
  */
-static int __rpc_execute(struct rpc_task *task)
+static void __rpc_execute(struct rpc_task *task)
 {
         int             status = 0;
 
-        dprintk("RPC: %4d rpc_execute flgs %x\n",
-                                task->tk_pid, task->tk_flags);
+        dprintk("RPC: %5u __rpc_execute flags=0x%x\n",
+                        task->tk_pid, task->tk_flags);
 
         BUG_ON(RPC_IS_QUEUED(task));
 
@@ -679,14 +681,14 @@ static int __rpc_execute(struct rpc_task *task)
                 if (RPC_IS_ASYNC(task)) {
                         /* Careful! we may have raced... */
                         if (RPC_IS_QUEUED(task))
-                                return 0;
+                                return;
                         if (rpc_test_and_set_running(task))
-                                return 0;
+                                return;
                         continue;
                 }
 
                 /* sync task: sleep here */
-                dprintk("RPC: %4d sync task going to sleep\n", task->tk_pid);
+                dprintk("RPC: %5u sync task going to sleep\n", task->tk_pid);
                 /* Note: Caller should be using rpc_clnt_sigmask() */
                 status = out_of_line_wait_on_bit(&task->tk_runstate,
                                 RPC_TASK_QUEUED, rpc_wait_bit_interruptible,
@@ -698,19 +700,19 @@ static int __rpc_execute(struct rpc_task *task)
                          * clean up after sleeping on some queue, we don't
                          * break the loop here, but go around once more.
                          */
-                        dprintk("RPC: %4d got signal\n", task->tk_pid);
+                        dprintk("RPC: %5u got signal\n", task->tk_pid);
                         task->tk_flags |= RPC_TASK_KILLED;
                         rpc_exit(task, -ERESTARTSYS);
                         rpc_wake_up_task(task);
                 }
                 rpc_set_running(task);
-                dprintk("RPC: %4d sync task resuming\n", task->tk_pid);
+                dprintk("RPC: %5u sync task resuming\n", task->tk_pid);
         }
 
-        dprintk("RPC: %4d, return %d, status %d\n", task->tk_pid, status, task->tk_status);
+        dprintk("RPC: %5u return %d, status %d\n", task->tk_pid, status,
+                        task->tk_status);
         /* Release all resources associated with the task */
         rpc_release_task(task);
-        return status;
 }
 
 /*
@@ -722,12 +724,11 @@ static int __rpc_execute(struct rpc_task *task)
  *       released. In particular note that tk_release() will have
  *       been called, so your task memory may have been freed.
  */
-int
-rpc_execute(struct rpc_task *task)
+void rpc_execute(struct rpc_task *task)
 {
         rpc_set_active(task);
         rpc_set_running(task);
-        return __rpc_execute(task);
+        __rpc_execute(task);
 }
 
 static void rpc_async_schedule(struct work_struct *work)
@@ -826,7 +827,7 @@ void rpc_init_task(struct rpc_task *task, struct rpc_clnt *clnt, int flags, cons
         /* starting timestamp */
         task->tk_start = jiffies;
 
-        dprintk("RPC: %4d new task procpid %d\n", task->tk_pid,
+        dprintk("RPC:       new task initialized, procpid %u\n",
                                 current->pid);
 }
 
@@ -839,7 +840,7 @@ rpc_alloc_task(void)
 static void rpc_free_task(struct rcu_head *rcu)
 {
         struct rpc_task *task = container_of(rcu, struct rpc_task, u.tk_rcu);
-        dprintk("RPC: %4d freeing task\n", task->tk_pid);
+        dprintk("RPC: %5u freeing task\n", task->tk_pid);
         mempool_free(task, rpc_task_mempool);
 }
 
@@ -858,7 +859,7 @@ struct rpc_task *rpc_new_task(struct rpc_clnt *clnt, int flags, const struct rpc
 
         rpc_init_task(task, clnt, flags, tk_ops, calldata);
 
-        dprintk("RPC: %4d allocated task\n", task->tk_pid);
+        dprintk("RPC:       allocated task %p\n", task);
         task->tk_flags |= RPC_TASK_DYNAMIC;
 out:
         return task;
@@ -902,7 +903,7 @@ static void rpc_release_task(struct rpc_task *task)
 #ifdef RPC_DEBUG
         BUG_ON(task->tk_magic != RPC_TASK_MAGIC_ID);
 #endif
-        dprintk("RPC: %4d release task\n", task->tk_pid);
+        dprintk("RPC: %5u release task\n", task->tk_pid);
 
         /* Remove from global task list */
         spin_lock(&rpc_sched_lock);
@@ -955,7 +956,7 @@ void rpc_killall_tasks(struct rpc_clnt *clnt)
         struct rpc_task *rovr;
         struct list_head *le;
 
-        dprintk("RPC:      killing all tasks for client %p\n", clnt);
+        dprintk("RPC:       killing all tasks for client %p\n", clnt);
 
         /*
          * Spin lock all_tasks to prevent changes...
@@ -984,7 +985,8 @@ static void rpciod_killall(void)
                 rpc_killall_tasks(NULL);
                 flush_workqueue(rpciod_workqueue);
                 if (!list_empty(&all_tasks)) {
-                        dprintk("rpciod_killall: waiting for tasks to exit\n");
+                        dprintk("RPC:       rpciod_killall: waiting for tasks "
+                                        "to exit\n");
                         yield();
                 }
         }
@@ -1004,7 +1006,7 @@ rpciod_up(void)
         int error = 0;
 
         mutex_lock(&rpciod_mutex);
-        dprintk("rpciod_up: users %d\n", rpciod_users);
+        dprintk("RPC:       rpciod_up: users %u\n", rpciod_users);
         rpciod_users++;
         if (rpciod_workqueue)
                 goto out;
@@ -1012,7 +1014,7 @@ rpciod_up(void)
          * If there's no pid, we should be the first user.
          */
         if (rpciod_users > 1)
-                printk(KERN_WARNING "rpciod_up: no workqueue, %d users??\n", rpciod_users);
+                printk(KERN_WARNING "rpciod_up: no workqueue, %u users??\n", rpciod_users);
         /*
          * Create the rpciod thread and wait for it to start.
          */
@@ -1034,7 +1036,7 @@ void
 rpciod_down(void)
 {
         mutex_lock(&rpciod_mutex);
-        dprintk("rpciod_down sema %d\n", rpciod_users);
+        dprintk("RPC:       rpciod_down sema %u\n", rpciod_users);
         if (rpciod_users) {
                 if (--rpciod_users)
                         goto out;
@@ -1042,7 +1044,7 @@ rpciod_down(void)
                 printk(KERN_WARNING "rpciod_down: no users??\n");
 
         if (!rpciod_workqueue) {
-                dprintk("rpciod_down: Nothing to do!\n");
+                dprintk("RPC:       rpciod_down: Nothing to do!\n");
                 goto out;
         }
         rpciod_killall();
@@ -1072,7 +1074,7 @@ void rpc_show_tasks(void)
                 if (RPC_IS_QUEUED(t))
                         rpc_waitq = rpc_qname(t->u.tk_wait.rpc_waitq);
 
-                printk("%05d %04d %04x %06d %8p %6d %8p %08ld %8s %8p %8p\n",
+                printk("%5u %04d %04x %6d %8p %6d %8p %8ld %8s %8p %8p\n",
                         t->tk_pid,
                         (t->tk_msg.rpc_proc ? t->tk_msg.rpc_proc->p_proc : -1),
                         t->tk_flags, t->tk_status,
diff --git a/net/sunrpc/stats.c b/net/sunrpc/stats.c
index 044d9484bb8c..74ba7d443dfc 100644
--- a/net/sunrpc/stats.c
+++ b/net/sunrpc/stats.c
@@ -16,7 +16,6 @@
 
 #include <linux/init.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
 #include <linux/sunrpc/clnt.h>
@@ -226,7 +225,7 @@ 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);
+        dprintk("RPC:       registering /proc/net/rpc/%s\n", name);
 
         ent = create_proc_entry(name, 0, proc_net_rpc);
         if (ent) {
@@ -263,7 +262,7 @@ svc_proc_unregister(const char *name)
 void
 rpc_proc_init(void)
 {
-        dprintk("RPC: registering /proc/net/rpc\n");
+        dprintk("RPC:       registering /proc/net/rpc\n");
         if (!proc_net_rpc) {
                 struct proc_dir_entry *ent;
                 ent = proc_mkdir("rpc", proc_net);
@@ -277,7 +276,7 @@ rpc_proc_init(void)
 void
 rpc_proc_exit(void)
 {
-        dprintk("RPC: unregistering /proc/net/rpc\n");
+        dprintk("RPC:       unregistering /proc/net/rpc\n");
         if (proc_net_rpc) {
                 proc_net_rpc = NULL;
                 remove_proc_entry("net/rpc", NULL);
diff --git a/net/sunrpc/sunrpc_syms.c b/net/sunrpc/sunrpc_syms.c
index d85fddeb6388..43ecf62f12ef 100644
--- a/net/sunrpc/sunrpc_syms.c
+++ b/net/sunrpc/sunrpc_syms.c
@@ -9,7 +9,6 @@
 #include <linux/module.h>
 
 #include <linux/types.h>
-#include <linux/sched.h>
 #include <linux/uio.h>
 #include <linux/unistd.h>
 #include <linux/init.h>
@@ -137,7 +136,7 @@ EXPORT_SYMBOL(nlm_debug);
 
 extern int register_rpc_pipefs(void);
 extern void unregister_rpc_pipefs(void);
-extern struct cache_detail ip_map_cache;
+extern struct cache_detail ip_map_cache, unix_gid_cache;
 extern int init_socket_xprt(void);
 extern void cleanup_socket_xprt(void);
 
@@ -157,6 +156,7 @@ init_sunrpc(void)
         rpc_proc_init();
 #endif
         cache_register(&ip_map_cache);
+        cache_register(&unix_gid_cache);
         init_socket_xprt();
 out:
         return err;
@@ -170,6 +170,8 @@ cleanup_sunrpc(void)
         rpc_destroy_mempool();
         if (cache_unregister(&ip_map_cache))
                 printk(KERN_ERR "sunrpc: failed to unregister ip_map cache\n");
+        if (cache_unregister(&unix_gid_cache))
+              printk(KERN_ERR "sunrpc: failed to unregister unix_gid cache\n");
 #ifdef RPC_DEBUG
         rpc_unregister_sysctl();
 #endif
diff --git a/net/sunrpc/svc.c b/net/sunrpc/svc.c
index b00511d39b65..4ab137403e1a 100644
--- a/net/sunrpc/svc.c
+++ b/net/sunrpc/svc.c
@@ -317,7 +317,7 @@ __svc_create(struct svc_program *prog, unsigned int bufsize, int npools,
         for (i = 0; i < serv->sv_nrpools; i++) {
                 struct svc_pool *pool = &serv->sv_pools[i];
 
-                dprintk("initialising pool %u for %s\n",
+                dprintk("svc: initialising pool %u for %s\n",
                                 i, serv->sv_name);
 
                 pool->sp_id = i;
@@ -368,7 +368,7 @@ svc_destroy(struct svc_serv *serv)
 {
         struct svc_sock *svsk;
 
-        dprintk("RPC: svc_destroy(%s, %d)\n",
+        dprintk("svc: svc_destroy(%s, %d)\n",
                                 serv->sv_program->pg_name,
                                 serv->sv_nrthreads);
 
@@ -654,7 +654,7 @@ svc_register(struct svc_serv *serv, int proto, unsigned short port)
                         if (progp->pg_vers[i] == NULL)
                                 continue;
 
-                        dprintk("RPC: svc_register(%s, %s, %d, %d)%s\n",
+                        dprintk("svc: svc_register(%s, %s, %d, %d)%s\n",
                                         progp->pg_name,
                                         proto == IPPROTO_UDP?  "udp" : "tcp",
                                         port,
diff --git a/net/sunrpc/svcauth.c b/net/sunrpc/svcauth.c
index 811a24c83262..f5c3808bf85a 100644
--- a/net/sunrpc/svcauth.c
+++ b/net/sunrpc/svcauth.c
@@ -10,7 +10,6 @@
  */
 
 #include <linux/types.h>
-#include <linux/sched.h>
 #include <linux/module.h>
 #include <linux/sunrpc/types.h>
 #include <linux/sunrpc/xdr.h>
diff --git a/net/sunrpc/svcauth_unix.c b/net/sunrpc/svcauth_unix.c
index 4b775dbf580d..9bae4090254c 100644
--- a/net/sunrpc/svcauth_unix.c
+++ b/net/sunrpc/svcauth_unix.c
@@ -418,6 +418,214 @@ svcauth_unix_info_release(void *info)
         cache_put(&ipm->h, &ip_map_cache);
 }
 
+/****************************************************************************
+ * auth.unix.gid cache
+ * simple cache to map a UID to a list of GIDs
+ * because AUTH_UNIX aka AUTH_SYS has a max of 16
+ */
+#define GID_HASHBITS    8
+#define GID_HASHMAX     (1<<GID_HASHBITS)
+#define GID_HASHMASK    (GID_HASHMAX - 1)
+
+struct unix_gid {
+        struct cache_head       h;
+        uid_t                   uid;
+        struct group_info       *gi;
+};
+static struct cache_head        *gid_table[GID_HASHMAX];
+
+static void unix_gid_put(struct kref *kref)
+{
+        struct cache_head *item = container_of(kref, struct cache_head, ref);
+        struct unix_gid *ug = container_of(item, struct unix_gid, h);
+        if (test_bit(CACHE_VALID, &item->flags) &&
+            !test_bit(CACHE_NEGATIVE, &item->flags))
+                put_group_info(ug->gi);
+        kfree(ug);
+}
+
+static int unix_gid_match(struct cache_head *corig, struct cache_head *cnew)
+{
+        struct unix_gid *orig = container_of(corig, struct unix_gid, h);
+        struct unix_gid *new = container_of(cnew, struct unix_gid, h);
+        return orig->uid == new->uid;
+}
+static void unix_gid_init(struct cache_head *cnew, struct cache_head *citem)
+{
+        struct unix_gid *new = container_of(cnew, struct unix_gid, h);
+        struct unix_gid *item = container_of(citem, struct unix_gid, h);
+        new->uid = item->uid;
+}
+static void unix_gid_update(struct cache_head *cnew, struct cache_head *citem)
+{
+        struct unix_gid *new = container_of(cnew, struct unix_gid, h);
+        struct unix_gid *item = container_of(citem, struct unix_gid, h);
+
+        get_group_info(item->gi);
+        new->gi = item->gi;
+}
+static struct cache_head *unix_gid_alloc(void)
+{
+        struct unix_gid *g = kmalloc(sizeof(*g), GFP_KERNEL);
+        if (g)
+                return &g->h;
+        else
+                return NULL;
+}
+
+static void unix_gid_request(struct cache_detail *cd,
+                             struct cache_head *h,
+                             char **bpp, int *blen)
+{
+        char tuid[20];
+        struct unix_gid *ug = container_of(h, struct unix_gid, h);
+
+        snprintf(tuid, 20, "%u", ug->uid);
+        qword_add(bpp, blen, tuid);
+        (*bpp)[-1] = '\n';
+}
+
+static struct unix_gid *unix_gid_lookup(uid_t uid);
+extern struct cache_detail unix_gid_cache;
+
+static int unix_gid_parse(struct cache_detail *cd,
+                        char *mesg, int mlen)
+{
+        /* uid expiry Ngid gid0 gid1 ... gidN-1 */
+        int uid;
+        int gids;
+        int rv;
+        int i;
+        int err;
+        time_t expiry;
+        struct unix_gid ug, *ugp;
+
+        if (mlen <= 0 || mesg[mlen-1] != '\n')
+                return -EINVAL;
+        mesg[mlen-1] = 0;
+
+        rv = get_int(&mesg, &uid);
+        if (rv)
+                return -EINVAL;
+        ug.uid = uid;
+
+        expiry = get_expiry(&mesg);
+        if (expiry == 0)
+                return -EINVAL;
+
+        rv = get_int(&mesg, &gids);
+        if (rv || gids < 0 || gids > 8192)
+                return -EINVAL;
+
+        ug.gi = groups_alloc(gids);
+        if (!ug.gi)
+                return -ENOMEM;
+
+        for (i = 0 ; i < gids ; i++) {
+                int gid;
+                rv = get_int(&mesg, &gid);
+                err = -EINVAL;
+                if (rv)
+                        goto out;
+                GROUP_AT(ug.gi, i) = gid;
+        }
+
+        ugp = unix_gid_lookup(uid);
+        if (ugp) {
+                struct cache_head *ch;
+                ug.h.flags = 0;
+                ug.h.expiry_time = expiry;
+                ch = sunrpc_cache_update(&unix_gid_cache,
+                                         &ug.h, &ugp->h,
+                                         hash_long(uid, GID_HASHBITS));
+                if (!ch)
+                        err = -ENOMEM;
+                else {
+                        err = 0;
+                        cache_put(ch, &unix_gid_cache);
+                }
+        } else
+                err = -ENOMEM;
+ out:
+        if (ug.gi)
+                put_group_info(ug.gi);
+        return err;
+}
+
+static int unix_gid_show(struct seq_file *m,
+                         struct cache_detail *cd,
+                         struct cache_head *h)
+{
+        struct unix_gid *ug;
+        int i;
+        int glen;
+
+        if (h == NULL) {
+                seq_puts(m, "#uid cnt: gids...\n");
+                return 0;
+        }
+        ug = container_of(h, struct unix_gid, h);
+        if (test_bit(CACHE_VALID, &h->flags) &&
+            !test_bit(CACHE_NEGATIVE, &h->flags))
+                glen = ug->gi->ngroups;
+        else
+                glen = 0;
+
+        seq_printf(m, "%d %d:", ug->uid, glen);
+        for (i = 0; i < glen; i++)
+                seq_printf(m, " %d", GROUP_AT(ug->gi, i));
+        seq_printf(m, "\n");
+        return 0;
+}
+
+struct cache_detail unix_gid_cache = {
+        .owner          = THIS_MODULE,
+        .hash_size      = GID_HASHMAX,
+        .hash_table     = gid_table,
+        .name           = "auth.unix.gid",
+        .cache_put      = unix_gid_put,
+        .cache_request  = unix_gid_request,
+        .cache_parse    = unix_gid_parse,
+        .cache_show     = unix_gid_show,
+        .match          = unix_gid_match,
+        .init           = unix_gid_init,
+        .update         = unix_gid_update,
+        .alloc          = unix_gid_alloc,
+};
+
+static struct unix_gid *unix_gid_lookup(uid_t uid)
+{
+        struct unix_gid ug;
+        struct cache_head *ch;
+
+        ug.uid = uid;
+        ch = sunrpc_cache_lookup(&unix_gid_cache, &ug.h,
+                                 hash_long(uid, GID_HASHBITS));
+        if (ch)
+                return container_of(ch, struct unix_gid, h);
+        else
+                return NULL;
+}
+
+static int unix_gid_find(uid_t uid, struct group_info **gip,
+                         struct svc_rqst *rqstp)
+{
+        struct unix_gid *ug = unix_gid_lookup(uid);
+        if (!ug)
+                return -EAGAIN;
+        switch (cache_check(&unix_gid_cache, &ug->h, &rqstp->rq_chandle)) {
+        case -ENOENT:
+                *gip = NULL;
+                return 0;
+        case 0:
+                *gip = ug->gi;
+                get_group_info(*gip);
+                return 0;
+        default:
+                return -EAGAIN;
+        }
+}
+
 static int
 svcauth_unix_set_client(struct svc_rqst *rqstp)
 {
@@ -543,12 +751,19 @@ svcauth_unix_accept(struct svc_rqst *rqstp, __be32 *authp)
         slen = svc_getnl(argv);                 /* gids length */
         if (slen > 16 || (len -= (slen + 2)*4) < 0)
                 goto badcred;
-        cred->cr_group_info = groups_alloc(slen);
-        if (cred->cr_group_info == NULL)
+        if (unix_gid_find(cred->cr_uid, &cred->cr_group_info, rqstp)
+            == -EAGAIN)
                 return SVC_DROP;
-        for (i = 0; i < slen; i++)
-                GROUP_AT(cred->cr_group_info, i) = svc_getnl(argv);
-
+        if (cred->cr_group_info == NULL) {
+                cred->cr_group_info = groups_alloc(slen);
+                if (cred->cr_group_info == NULL)
+                        return SVC_DROP;
+                for (i = 0; i < slen; i++)
+                        GROUP_AT(cred->cr_group_info, i) = svc_getnl(argv);
+        } else {
+                for (i = 0; i < slen ; i++)
+                        svc_getnl(argv);
+        }
         if (svc_getu32(argv) != htonl(RPC_AUTH_NULL) || svc_getu32(argv) != 0) {
                 *authp = rpc_autherr_badverf;
                 return SVC_DENIED;
diff --git a/net/sunrpc/sysctl.c b/net/sunrpc/sysctl.c
index 47d8df2b5eb2..738db32a287d 100644
--- a/net/sunrpc/sysctl.c
+++ b/net/sunrpc/sysctl.c
@@ -35,14 +35,8 @@ static ctl_table		sunrpc_table[];
 void
 rpc_register_sysctl(void)
 {
-        if (!sunrpc_table_header) {
-                sunrpc_table_header = register_sysctl_table(sunrpc_table, 1);
-#ifdef CONFIG_PROC_FS
-                if (sunrpc_table[0].de)
-                        sunrpc_table[0].de->owner = THIS_MODULE;
-#endif
-        }
-
+        if (!sunrpc_table_header)
+                sunrpc_table_header = register_sysctl_table(sunrpc_table);
 }
 
 void
diff --git a/net/sunrpc/xprt.c b/net/sunrpc/xprt.c
index e7c71a1ea3d4..ee6ffa01dfb1 100644
--- a/net/sunrpc/xprt.c
+++ b/net/sunrpc/xprt.c
@@ -108,7 +108,7 @@ int xprt_reserve_xprt(struct rpc_task *task)
         return 1;
 
 out_sleep:
-        dprintk("RPC: %4d failed to lock transport %p\n",
+        dprintk("RPC: %5u failed to lock transport %p\n",
                         task->tk_pid, xprt);
         task->tk_timeout = 0;
         task->tk_status = -EAGAIN;
@@ -158,7 +158,7 @@ int xprt_reserve_xprt_cong(struct rpc_task *task)
         }
         xprt_clear_locked(xprt);
 out_sleep:
-        dprintk("RPC: %4d failed to lock transport %p\n", task->tk_pid, xprt);
+        dprintk("RPC: %5u failed to lock transport %p\n", task->tk_pid, xprt);
         task->tk_timeout = 0;
         task->tk_status = -EAGAIN;
         if (req && req->rq_ntrans)
@@ -281,7 +281,7 @@ __xprt_get_cong(struct rpc_xprt *xprt, struct rpc_task *task)
 
         if (req->rq_cong)
                 return 1;
-        dprintk("RPC: %4d xprt_cwnd_limited cong = %ld cwnd = %ld\n",
+        dprintk("RPC: %5u xprt_cwnd_limited cong = %lu cwnd = %lu\n",
                         task->tk_pid, xprt->cong, xprt->cwnd);
         if (RPCXPRT_CONGESTED(xprt))
                 return 0;
@@ -340,7 +340,7 @@ void xprt_adjust_cwnd(struct rpc_task *task, int result)
                 if (cwnd < RPC_CWNDSCALE)
                         cwnd = RPC_CWNDSCALE;
         }
-        dprintk("RPC:      cong %ld, cwnd was %ld, now %ld\n",
+        dprintk("RPC:       cong %ld, cwnd was %ld, now %ld\n",
                         xprt->cong, xprt->cwnd, cwnd);
         xprt->cwnd = cwnd;
         __xprt_put_cong(xprt, req);
@@ -387,8 +387,8 @@ void xprt_write_space(struct rpc_xprt *xprt)
 
         spin_lock_bh(&xprt->transport_lock);
         if (xprt->snd_task) {
-                dprintk("RPC:      write space: waking waiting task on xprt %p\n",
-                                xprt);
+                dprintk("RPC:       write space: waking waiting task on "
+                                "xprt %p\n", xprt);
                 rpc_wake_up_task(xprt->snd_task);
         }
         spin_unlock_bh(&xprt->transport_lock);
@@ -494,7 +494,7 @@ static void xprt_autoclose(struct work_struct *work)
  */
 void xprt_disconnect(struct rpc_xprt *xprt)
 {
-        dprintk("RPC:      disconnected transport %p\n", xprt);
+        dprintk("RPC:       disconnected transport %p\n", xprt);
         spin_lock_bh(&xprt->transport_lock);
         xprt_clear_connected(xprt);
         xprt_wake_pending_tasks(xprt, -ENOTCONN);
@@ -530,7 +530,7 @@ void xprt_connect(struct rpc_task *task)
 {
         struct rpc_xprt *xprt = task->tk_xprt;
 
-        dprintk("RPC: %4d xprt_connect xprt %p %s connected\n", task->tk_pid,
+        dprintk("RPC: %5u xprt_connect xprt %p %s connected\n", task->tk_pid,
                         xprt, (xprt_connected(xprt) ? "is" : "is not"));
 
         if (!xprt_bound(xprt)) {
@@ -560,7 +560,7 @@ static void xprt_connect_status(struct rpc_task *task)
         if (task->tk_status >= 0) {
                 xprt->stat.connect_count++;
                 xprt->stat.connect_time += (long)jiffies - xprt->stat.connect_start;
-                dprintk("RPC: %4d xprt_connect_status: connection established\n",
+                dprintk("RPC: %5u xprt_connect_status: connection established\n",
                                 task->tk_pid);
                 return;
         }
@@ -568,20 +568,22 @@ static void xprt_connect_status(struct rpc_task *task)
         switch (task->tk_status) {
         case -ECONNREFUSED:
         case -ECONNRESET:
-                dprintk("RPC: %4d xprt_connect_status: server %s refused connection\n",
-                                task->tk_pid, task->tk_client->cl_server);
+                dprintk("RPC: %5u xprt_connect_status: server %s refused "
+                                "connection\n", task->tk_pid,
+                                task->tk_client->cl_server);
                 break;
         case -ENOTCONN:
-                dprintk("RPC: %4d xprt_connect_status: connection broken\n",
+                dprintk("RPC: %5u xprt_connect_status: connection broken\n",
                                 task->tk_pid);
                 break;
         case -ETIMEDOUT:
-                dprintk("RPC: %4d xprt_connect_status: connect attempt timed out\n",
-                                task->tk_pid);
+                dprintk("RPC: %5u xprt_connect_status: connect attempt timed "
+                                "out\n", task->tk_pid);
                 break;
         default:
-                dprintk("RPC: %4d xprt_connect_status: error %d connecting to server %s\n",
-                                task->tk_pid, -task->tk_status, task->tk_client->cl_server);
+                dprintk("RPC: %5u xprt_connect_status: error %d connecting to "
+                                "server %s\n", task->tk_pid, -task->tk_status,
+                                task->tk_client->cl_server);
                 xprt_release_write(xprt, task);
                 task->tk_status = -EIO;
         }
@@ -602,6 +604,9 @@ struct rpc_rqst *xprt_lookup_rqst(struct rpc_xprt *xprt, __be32 xid)
                 if (entry->rq_xid == xid)
                         return entry;
         }
+
+        dprintk("RPC:       xprt_lookup_rqst did not find xid %08x\n",
+                        ntohl(xid));
         xprt->stat.bad_xids++;
         return NULL;
 }
@@ -654,7 +659,7 @@ static void xprt_timer(struct rpc_task *task)
         struct rpc_rqst *req = task->tk_rqstp;
         struct rpc_xprt *xprt = req->rq_xprt;
 
-        dprintk("RPC: %4d xprt_timer\n", task->tk_pid);
+        dprintk("RPC: %5u xprt_timer\n", task->tk_pid);
 
         spin_lock(&xprt->transport_lock);
         if (!req->rq_received) {
@@ -678,7 +683,7 @@ int xprt_prepare_transmit(struct rpc_task *task)
         struct rpc_xprt *xprt = req->rq_xprt;
         int err = 0;
 
-        dprintk("RPC: %4d xprt_prepare_transmit\n", task->tk_pid);
+        dprintk("RPC: %5u xprt_prepare_transmit\n", task->tk_pid);
 
         spin_lock_bh(&xprt->transport_lock);
         if (req->rq_received && !req->rq_bytes_sent) {
@@ -716,7 +721,7 @@ void xprt_transmit(struct rpc_task *task)
         struct rpc_xprt *xprt = req->rq_xprt;
         int status;
 
-        dprintk("RPC: %4d xprt_transmit(%u)\n", task->tk_pid, req->rq_slen);
+        dprintk("RPC: %5u xprt_transmit(%u)\n", task->tk_pid, req->rq_slen);
 
         if (!req->rq_received) {
                 if (list_empty(&req->rq_list)) {
@@ -730,13 +735,23 @@ void xprt_transmit(struct rpc_task *task)
                         xprt_reset_majortimeo(req);
                         /* Turn off autodisconnect */
                         del_singleshot_timer_sync(&xprt->timer);
+                } else {
+                        /* If all request bytes have been sent,
+                         * then we must be retransmitting this one */
+                        if (!req->rq_bytes_sent) {
+                                if (task->tk_client->cl_discrtry) {
+                                        xprt_disconnect(xprt);
+                                        task->tk_status = -ENOTCONN;
+                                        return;
+                                }
+                        }
                 }
         } else if (!req->rq_bytes_sent)
                 return;
 
         status = xprt->ops->send_request(task);
         if (status == 0) {
-                dprintk("RPC: %4d xmit complete\n", task->tk_pid);
+                dprintk("RPC: %5u xmit complete\n", task->tk_pid);
                 spin_lock_bh(&xprt->transport_lock);
 
                 xprt->ops->set_retrans_timeout(task);
@@ -777,7 +792,7 @@ static inline void do_xprt_reserve(struct rpc_task *task)
                 xprt_request_init(task, xprt);
                 return;
         }
-        dprintk("RPC:      waiting for request slot\n");
+        dprintk("RPC:       waiting for request slot\n");
         task->tk_status = -EAGAIN;
         task->tk_timeout = 0;
         rpc_sleep_on(&xprt->backlog, task, NULL, NULL);
@@ -822,7 +837,7 @@ static void xprt_request_init(struct rpc_task *task, struct rpc_xprt *xprt)
         req->rq_xid     = xprt_alloc_xid(xprt);
         req->rq_release_snd_buf = NULL;
         xprt_reset_majortimeo(req);
-        dprintk("RPC: %4d reserved req %p xid %08x\n", task->tk_pid,
+        dprintk("RPC: %5u reserved req %p xid %08x\n", task->tk_pid,
                         req, ntohl(req->rq_xid));
 }
 
@@ -856,7 +871,7 @@ void xprt_release(struct rpc_task *task)
                 req->rq_release_snd_buf(req);
         memset(req, 0, sizeof(*req));   /* mark unused */
 
-        dprintk("RPC: %4d release request %p\n", task->tk_pid, req);
+        dprintk("RPC: %5u release request %p\n", task->tk_pid, req);
 
         spin_lock(&xprt->reserve_lock);
         list_add(&req->rq_list, &xprt->free);
@@ -906,7 +921,7 @@ struct rpc_xprt *xprt_create_transport(int proto, struct sockaddr *ap, size_t si
                 return ERR_PTR(-EIO);
         }
         if (IS_ERR(xprt)) {
-                dprintk("RPC:      xprt_create_transport: failed, %ld\n",
+                dprintk("RPC:       xprt_create_transport: failed, %ld\n",
                                 -PTR_ERR(xprt));
                 return xprt;
         }
@@ -936,7 +951,7 @@ struct rpc_xprt *xprt_create_transport(int proto, struct sockaddr *ap, size_t si
 
         xprt_init_xid(xprt);
 
-        dprintk("RPC:      created transport %p with %u slots\n", xprt,
+        dprintk("RPC:       created transport %p with %u slots\n", xprt,
                         xprt->max_reqs);
 
         return xprt;
@@ -951,7 +966,7 @@ static void xprt_destroy(struct kref *kref)
 {
         struct rpc_xprt *xprt = container_of(kref, struct rpc_xprt, kref);
 
-        dprintk("RPC:      destroying transport %p\n", xprt);
+        dprintk("RPC:       destroying transport %p\n", xprt);
         xprt->shutdown = 1;
         del_timer_sync(&xprt->timer);
 
diff --git a/net/sunrpc/xprtsock.c b/net/sunrpc/xprtsock.c
index 49cabffd7fdb..a5a32029e728 100644
--- a/net/sunrpc/xprtsock.c
+++ b/net/sunrpc/xprtsock.c
@@ -18,7 +18,6 @@
 #include <linux/types.h>
 #include <linux/slab.h>
 #include <linux/capability.h>
-#include <linux/sched.h>
 #include <linux/pagemap.h>
 #include <linux/errno.h>
 #include <linux/socket.h>
@@ -192,7 +191,7 @@ static void xs_pktdump(char *msg, u32 *packet, unsigned int count)
         u8 *buf = (u8 *) packet;
         int j;
 
-        dprintk("RPC:      %s\n", msg);
+        dprintk("RPC:       %s\n", msg);
         for (j = 0; j < count && j < 128; j += 4) {
                 if (!(j & 31)) {
                         if (j)
@@ -418,7 +417,7 @@ static void xs_nospace(struct rpc_task *task)
         struct rpc_xprt *xprt = req->rq_xprt;
         struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
 
-        dprintk("RPC: %4d xmit incomplete (%u left of %u)\n",
+        dprintk("RPC: %5u xmit incomplete (%u left of %u)\n",
                         task->tk_pid, req->rq_slen - req->rq_bytes_sent,
                         req->rq_slen);
 
@@ -467,7 +466,7 @@ static int xs_udp_send_request(struct rpc_task *task)
                               xprt->addrlen, xdr,
                               req->rq_bytes_sent);
 
-        dprintk("RPC:      xs_udp_send_request(%u) = %d\n",
+        dprintk("RPC:       xs_udp_send_request(%u) = %d\n",
                         xdr->len - req->rq_bytes_sent, status);
 
         if (likely(status >= (int) req->rq_slen))
@@ -488,7 +487,7 @@ static int xs_udp_send_request(struct rpc_task *task)
                 xs_nospace(task);
                 break;
         default:
-                dprintk("RPC:      sendmsg returned unrecognized error %d\n",
+                dprintk("RPC:       sendmsg returned unrecognized error %d\n",
                         -status);
                 break;
         }
@@ -539,7 +538,7 @@ static int xs_tcp_send_request(struct rpc_task *task)
                 status = xs_sendpages(transport->sock,
                                         NULL, 0, xdr, req->rq_bytes_sent);
 
-                dprintk("RPC:      xs_tcp_send_request(%u) = %d\n",
+                dprintk("RPC:       xs_tcp_send_request(%u) = %d\n",
                                 xdr->len - req->rq_bytes_sent, status);
 
                 if (unlikely(status < 0))
@@ -570,7 +569,7 @@ static int xs_tcp_send_request(struct rpc_task *task)
                 status = -ENOTCONN;
                 break;
         default:
-                dprintk("RPC:      sendmsg returned unrecognized error %d\n",
+                dprintk("RPC:       sendmsg returned unrecognized error %d\n",
                         -status);
                 xprt_disconnect(xprt);
                 break;
@@ -622,7 +621,7 @@ static void xs_close(struct rpc_xprt *xprt)
         if (!sk)
                 goto clear_close_wait;
 
-        dprintk("RPC:      xs_close xprt %p\n", xprt);
+        dprintk("RPC:       xs_close xprt %p\n", xprt);
 
         write_lock_bh(&sk->sk_callback_lock);
         transport->inet = NULL;
@@ -652,7 +651,7 @@ static void xs_destroy(struct rpc_xprt *xprt)
 {
         struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
 
-        dprintk("RPC:      xs_destroy xprt %p\n", xprt);
+        dprintk("RPC:       xs_destroy xprt %p\n", xprt);
 
         cancel_delayed_work(&transport->connect_worker);
         flush_scheduled_work();
@@ -686,7 +685,7 @@ static void xs_udp_data_ready(struct sock *sk, int len)
         __be32 *xp;
 
         read_lock(&sk->sk_callback_lock);
-        dprintk("RPC:      xs_udp_data_ready...\n");
+        dprintk("RPC:       xs_udp_data_ready...\n");
         if (!(xprt = xprt_from_sock(sk)))
                 goto out;
 
@@ -698,7 +697,7 @@ static void xs_udp_data_ready(struct sock *sk, int len)
 
         repsize = skb->len - sizeof(struct udphdr);
         if (repsize < 4) {
-                dprintk("RPC:      impossible RPC reply size %d!\n", repsize);
+                dprintk("RPC:       impossible RPC reply size %d!\n", repsize);
                 goto dropit;
         }
 
@@ -762,11 +761,11 @@ static inline void xs_tcp_read_fraghdr(struct rpc_xprt *xprt, struct xdr_skb_rea
 
         /* Sanity check of the record length */
         if (unlikely(transport->tcp_reclen < 4)) {
-                dprintk("RPC:      invalid TCP record fragment length\n");
+                dprintk("RPC:       invalid TCP record fragment length\n");
                 xprt_disconnect(xprt);
                 return;
         }
-        dprintk("RPC:      reading TCP record fragment of length %d\n",
+        dprintk("RPC:       reading TCP record fragment of length %d\n",
                         transport->tcp_reclen);
 }
 
@@ -789,7 +788,7 @@ static inline void xs_tcp_read_xid(struct sock_xprt *transport, struct xdr_skb_r
         char *p;
 
         len = sizeof(transport->tcp_xid) - transport->tcp_offset;
-        dprintk("RPC:      reading XID (%Zu bytes)\n", len);
+        dprintk("RPC:       reading XID (%Zu bytes)\n", len);
         p = ((char *) &transport->tcp_xid) + transport->tcp_offset;
         used = xdr_skb_read_bits(desc, p, len);
         transport->tcp_offset += used;
@@ -798,7 +797,7 @@ static inline void xs_tcp_read_xid(struct sock_xprt *transport, struct xdr_skb_r
         transport->tcp_flags &= ~TCP_RCV_COPY_XID;
         transport->tcp_flags |= TCP_RCV_COPY_DATA;
         transport->tcp_copied = 4;
-        dprintk("RPC:      reading reply for XID %08x\n",
+        dprintk("RPC:       reading reply for XID %08x\n",
                         ntohl(transport->tcp_xid));
         xs_tcp_check_fraghdr(transport);
 }
@@ -816,7 +815,7 @@ static inline void xs_tcp_read_request(struct rpc_xprt *xprt, struct xdr_skb_rea
         req = xprt_lookup_rqst(xprt, transport->tcp_xid);
         if (!req) {
                 transport->tcp_flags &= ~TCP_RCV_COPY_DATA;
-                dprintk("RPC:      XID %08x request not found!\n",
+                dprintk("RPC:       XID %08x request not found!\n",
                                 ntohl(transport->tcp_xid));
                 spin_unlock(&xprt->transport_lock);
                 return;
@@ -853,19 +852,20 @@ static inline void xs_tcp_read_request(struct rpc_xprt *xprt, struct xdr_skb_rea
                  * be discarded.
                  */
                 transport->tcp_flags &= ~TCP_RCV_COPY_DATA;
-                dprintk("RPC:      XID %08x truncated request\n",
+                dprintk("RPC:       XID %08x truncated request\n",
                                 ntohl(transport->tcp_xid));
-                dprintk("RPC:      xprt = %p, tcp_copied = %lu, tcp_offset = %u, tcp_reclen = %u\n",
-                                xprt, transport->tcp_copied, transport->tcp_offset,
-                                        transport->tcp_reclen);
+                dprintk("RPC:       xprt = %p, tcp_copied = %lu, "
+                                "tcp_offset = %u, tcp_reclen = %u\n",
+                                xprt, transport->tcp_copied,
+                                transport->tcp_offset, transport->tcp_reclen);
                 goto out;
         }
 
-        dprintk("RPC:      XID %08x read %Zd bytes\n",
+        dprintk("RPC:       XID %08x read %Zd bytes\n",
                         ntohl(transport->tcp_xid), r);
-        dprintk("RPC:      xprt = %p, tcp_copied = %lu, tcp_offset = %u, tcp_reclen = %u\n",
-                        xprt, transport->tcp_copied, transport->tcp_offset,
-                                transport->tcp_reclen);
+        dprintk("RPC:       xprt = %p, tcp_copied = %lu, tcp_offset = %u, "
+                        "tcp_reclen = %u\n", xprt, transport->tcp_copied,
+                        transport->tcp_offset, transport->tcp_reclen);
 
         if (transport->tcp_copied == req->rq_private_buf.buflen)
                 transport->tcp_flags &= ~TCP_RCV_COPY_DATA;
@@ -891,7 +891,7 @@ static inline void xs_tcp_read_discard(struct sock_xprt *transport, struct xdr_s
         desc->count -= len;
         desc->offset += len;
         transport->tcp_offset += len;
-        dprintk("RPC:      discarded %Zu bytes\n", len);
+        dprintk("RPC:       discarded %Zu bytes\n", len);
         xs_tcp_check_fraghdr(transport);
 }
 
@@ -905,7 +905,7 @@ static int xs_tcp_data_recv(read_descriptor_t *rd_desc, struct sk_buff *skb, uns
                 .count  = len,
         };
 
-        dprintk("RPC:      xs_tcp_data_recv started\n");
+        dprintk("RPC:       xs_tcp_data_recv started\n");
         do {
                 /* Read in a new fragment marker if necessary */
                 /* Can we ever really expect to get completely empty fragments? */
@@ -926,7 +926,7 @@ static int xs_tcp_data_recv(read_descriptor_t *rd_desc, struct sk_buff *skb, uns
                 /* Skip over any trailing bytes on short reads */
                 xs_tcp_read_discard(transport, &desc);
         } while (desc.count);
-        dprintk("RPC:      xs_tcp_data_recv done\n");
+        dprintk("RPC:       xs_tcp_data_recv done\n");
         return len - desc.count;
 }
 
@@ -941,8 +941,9 @@ static void xs_tcp_data_ready(struct sock *sk, int bytes)
         struct rpc_xprt *xprt;
         read_descriptor_t rd_desc;
 
+        dprintk("RPC:       xs_tcp_data_ready...\n");
+
         read_lock(&sk->sk_callback_lock);
-        dprintk("RPC:      xs_tcp_data_ready...\n");
         if (!(xprt = xprt_from_sock(sk)))
                 goto out;
         if (xprt->shutdown)
@@ -968,11 +969,11 @@ static void xs_tcp_state_change(struct sock *sk)
         read_lock(&sk->sk_callback_lock);
         if (!(xprt = xprt_from_sock(sk)))
                 goto out;
-        dprintk("RPC:      xs_tcp_state_change client %p...\n", xprt);
-        dprintk("RPC:      state %x conn %d dead %d zapped %d\n",
-                                sk->sk_state, xprt_connected(xprt),
-                                sock_flag(sk, SOCK_DEAD),
-                                sock_flag(sk, SOCK_ZAPPED));
+        dprintk("RPC:       xs_tcp_state_change client %p...\n", xprt);
+        dprintk("RPC:       state %x conn %d dead %d zapped %d\n",
+                        sk->sk_state, xprt_connected(xprt),
+                        sock_flag(sk, SOCK_DEAD),
+                        sock_flag(sk, SOCK_ZAPPED));
 
         switch (sk->sk_state) {
         case TCP_ESTABLISHED:
@@ -1140,7 +1141,7 @@ static void xs_set_port(struct rpc_xprt *xprt, unsigned short port)
 {
         struct sockaddr_in *sap = (struct sockaddr_in *) &xprt->addr;
 
-        dprintk("RPC:      setting port for xprt %p to %u\n", xprt, port);
+        dprintk("RPC:       setting port for xprt %p to %u\n", xprt, port);
 
         sap->sin_port = htons(port);
 }
@@ -1159,7 +1160,7 @@ static int xs_bindresvport(struct sock_xprt *transport, struct socket *sock)
                                                 sizeof(myaddr));
                 if (err == 0) {
                         transport->port = port;
-                        dprintk("RPC:      xs_bindresvport bound to port %u\n",
+                        dprintk("RPC:       xs_bindresvport bound to port %u\n",
                                         port);
                         return 0;
                 }
@@ -1169,7 +1170,7 @@ static int xs_bindresvport(struct sock_xprt *transport, struct socket *sock)
                         port--;
         } while (err == -EADDRINUSE && port != transport->port);
 
-        dprintk("RPC:      can't bind to reserved port (%d).\n", -err);
+        dprintk("RPC:       can't bind to reserved port (%d).\n", -err);
         return err;
 }
 
@@ -1223,7 +1224,7 @@ static void xs_udp_connect_worker(struct work_struct *work)
         xs_close(xprt);
 
         if ((err = sock_create_kern(PF_INET, SOCK_DGRAM, IPPROTO_UDP, &sock)) < 0) {
-                dprintk("RPC:      can't create UDP transport socket (%d).\n", -err);
+                dprintk("RPC:       can't create UDP transport socket (%d).\n", -err);
                 goto out;
         }
         xs_reclassify_socket(sock);
@@ -1233,7 +1234,7 @@ static void xs_udp_connect_worker(struct work_struct *work)
                 goto out;
         }
 
-        dprintk("RPC:      worker connecting xprt %p to address: %s\n",
+        dprintk("RPC:       worker connecting xprt %p to address: %s\n",
                         xprt, xprt->address_strings[RPC_DISPLAY_ALL]);
 
         if (!transport->inet) {
@@ -1275,7 +1276,7 @@ static void xs_tcp_reuse_connection(struct rpc_xprt *xprt)
         struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
         struct sockaddr any;
 
-        dprintk("RPC:      disconnecting xprt %p to reuse port\n", xprt);
+        dprintk("RPC:       disconnecting xprt %p to reuse port\n", xprt);
 
         /*
          * Disconnect the transport socket by doing a connect operation
@@ -1285,7 +1286,7 @@ static void xs_tcp_reuse_connection(struct rpc_xprt *xprt)
         any.sa_family = AF_UNSPEC;
         result = kernel_connect(transport->sock, &any, sizeof(any), 0);
         if (result)
-                dprintk("RPC:      AF_UNSPEC connect return code %d\n",
+                dprintk("RPC:       AF_UNSPEC connect return code %d\n",
                                 result);
 }
 
@@ -1309,7 +1310,8 @@ static void xs_tcp_connect_worker(struct work_struct *work)
         if (!sock) {
                 /* start from scratch */
                 if ((err = sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, &sock)) < 0) {
-                        dprintk("RPC:      can't create TCP transport socket (%d).\n", -err);
+                        dprintk("RPC:       can't create TCP transport "
+                                        "socket (%d).\n", -err);
                         goto out;
                 }
                 xs_reclassify_socket(sock);
@@ -1322,7 +1324,7 @@ static void xs_tcp_connect_worker(struct work_struct *work)
                 /* "close" the socket, preserving the local port */
                 xs_tcp_reuse_connection(xprt);
 
-        dprintk("RPC:      worker connecting xprt %p to address: %s\n",
+        dprintk("RPC:       worker connecting xprt %p to address: %s\n",
                         xprt, xprt->address_strings[RPC_DISPLAY_ALL]);
 
         if (!transport->inet) {
@@ -1359,8 +1361,9 @@ static void xs_tcp_connect_worker(struct work_struct *work)
         xprt->stat.connect_start = jiffies;
         status = kernel_connect(sock, (struct sockaddr *) &xprt->addr,
                         xprt->addrlen, O_NONBLOCK);
-        dprintk("RPC: %p  connect status %d connected %d sock state %d\n",
-                        xprt, -status, xprt_connected(xprt), sock->sk->sk_state);
+        dprintk("RPC:       %p connect status %d connected %d sock state %d\n",
+                        xprt, -status, xprt_connected(xprt),
+                        sock->sk->sk_state);
         if (status < 0) {
                 switch (status) {
                         case -EINPROGRESS:
@@ -1404,7 +1407,8 @@ static void xs_connect(struct rpc_task *task)
                 return;
 
         if (transport->sock != NULL) {
-                dprintk("RPC:      xs_connect delayed xprt %p for %lu seconds\n",
+                dprintk("RPC:       xs_connect delayed xprt %p for %lu "
+                                "seconds\n",
                                 xprt, xprt->reestablish_timeout / HZ);
                 schedule_delayed_work(&transport->connect_worker,
                                         xprt->reestablish_timeout);
@@ -1412,7 +1416,7 @@ static void xs_connect(struct rpc_task *task)
                 if (xprt->reestablish_timeout > XS_TCP_MAX_REEST_TO)
                         xprt->reestablish_timeout = XS_TCP_MAX_REEST_TO;
         } else {
-                dprintk("RPC:      xs_connect scheduled xprt %p\n", xprt);
+                dprintk("RPC:       xs_connect scheduled xprt %p\n", xprt);
                 schedule_delayed_work(&transport->connect_worker, 0);
 
                 /* flush_scheduled_work can sleep... */
@@ -1507,13 +1511,14 @@ static struct rpc_xprt *xs_setup_xprt(struct sockaddr *addr, size_t addrlen, uns
         struct sock_xprt *new;
 
         if (addrlen > sizeof(xprt->addr)) {
-                dprintk("RPC:      xs_setup_xprt: address too large\n");
+                dprintk("RPC:       xs_setup_xprt: address too large\n");
                 return ERR_PTR(-EBADF);
         }
 
         new = kzalloc(sizeof(*new), GFP_KERNEL);
         if (new == NULL) {
-                dprintk("RPC:      xs_setup_xprt: couldn't allocate rpc_xprt\n");
+                dprintk("RPC:       xs_setup_xprt: couldn't allocate "
+                                "rpc_xprt\n");
                 return ERR_PTR(-ENOMEM);
         }
         xprt = &new->xprt;
@@ -1522,7 +1527,8 @@ static struct rpc_xprt *xs_setup_xprt(struct sockaddr *addr, size_t addrlen, uns
         xprt->slot = kcalloc(xprt->max_reqs, sizeof(struct rpc_rqst), GFP_KERNEL);
         if (xprt->slot == NULL) {
                 kfree(xprt);
-                dprintk("RPC:      xs_setup_xprt: couldn't allocate slot table\n");
+                dprintk("RPC:       xs_setup_xprt: couldn't allocate slot "
+                                "table\n");
                 return ERR_PTR(-ENOMEM);
         }
 
@@ -1572,7 +1578,7 @@ struct rpc_xprt *xs_setup_udp(struct sockaddr *addr, size_t addrlen, struct rpc_
                 xprt_set_timeout(&xprt->timeout, 5, 5 * HZ);
 
         xs_format_peer_addresses(xprt);
-        dprintk("RPC:      set up transport to address %s\n",
+        dprintk("RPC:       set up transport to address %s\n",
                         xprt->address_strings[RPC_DISPLAY_ALL]);
 
         return xprt;
@@ -1616,7 +1622,7 @@ struct rpc_xprt *xs_setup_tcp(struct sockaddr *addr, size_t addrlen, struct rpc_
                 xprt_set_timeout(&xprt->timeout, 2, 60 * HZ);
 
         xs_format_peer_addresses(xprt);
-        dprintk("RPC:      set up transport to address %s\n",
+        dprintk("RPC:       set up transport to address %s\n",
                         xprt->address_strings[RPC_DISPLAY_ALL]);
 
         return xprt;
@@ -1629,13 +1635,8 @@ struct rpc_xprt *xs_setup_tcp(struct sockaddr *addr, size_t addrlen, struct rpc_
 int init_socket_xprt(void)
 {
 #ifdef RPC_DEBUG
-        if (!sunrpc_table_header) {
-                sunrpc_table_header = register_sysctl_table(sunrpc_table, 1);
-#ifdef CONFIG_PROC_FS
-                if (sunrpc_table[0].de)
-                        sunrpc_table[0].de->owner = THIS_MODULE;
-#endif
-        }
+        if (!sunrpc_table_header)
+                sunrpc_table_header = register_sysctl_table(sunrpc_table);
 #endif
 
         return 0;
diff --git a/net/unix/garbage.c b/net/unix/garbage.c
index f8bcf5d114d9..f20b7ea7c555 100644
--- a/net/unix/garbage.c
+++ b/net/unix/garbage.c
@@ -65,7 +65,6 @@
  */
 
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/socket.h>
 #include <linux/un.h>
diff --git a/net/unix/sysctl_net_unix.c b/net/unix/sysctl_net_unix.c
index 690ffa5d5bfb..eb0bd57ebada 100644
--- a/net/unix/sysctl_net_unix.c
+++ b/net/unix/sysctl_net_unix.c
@@ -50,7 +50,7 @@ static struct ctl_table_header * unix_sysctl_header;
 
 void unix_sysctl_register(void)
 {
-        unix_sysctl_header = register_sysctl_table(unix_root_table, 0);
+        unix_sysctl_header = register_sysctl_table(unix_root_table);
 }
 
 void unix_sysctl_unregister(void)
diff --git a/net/x25/sysctl_net_x25.c b/net/x25/sysctl_net_x25.c
index 5f631061c229..a59b77f18234 100644
--- a/net/x25/sysctl_net_x25.c
+++ b/net/x25/sysctl_net_x25.c
@@ -106,7 +106,7 @@ static struct ctl_table x25_root_table[] = {
 
 void __init x25_register_sysctl(void)
 {
-        x25_table_header = register_sysctl_table(x25_root_table, 1);
+        x25_table_header = register_sysctl_table(x25_root_table);
 }
 
 void x25_unregister_sysctl(void)
diff --git a/net/xfrm/xfrm_policy.c b/net/xfrm/xfrm_policy.c
index c394b413f651..946b715db5ec 100644
--- a/net/xfrm/xfrm_policy.c
+++ b/net/xfrm/xfrm_policy.c
@@ -1550,7 +1550,7 @@ xfrm_state_ok(struct xfrm_tmpl *tmpl, struct xfrm_state *x,
               unsigned short family)
 {
         if (xfrm_state_kern(x))
-                return tmpl->optional && !xfrm_state_addr_cmp(tmpl, x, family);
+                return tmpl->optional && !xfrm_state_addr_cmp(tmpl, x, tmpl->encap_family);
         return  x->id.proto == tmpl->id.proto &&
                 (x->id.spi == tmpl->id.spi || !tmpl->id.spi) &&
                 (x->props.reqid == tmpl->reqid || !tmpl->reqid) &&