30 files changed, 58 insertions, 56 deletions

diff --git a/net/802/tr.c b/net/802/tr.c
index e65f0b8de0c4..103e0201b0ab 100644
--- a/net/802/tr.c
+++ b/net/802/tr.c
@@ -662,7 +662,7 @@ static int __init rif_init(void)
         setup_timer(&rif_timer, rif_check_expire, 0);
         add_timer(&rif_timer);
 #ifdef CONFIG_SYSCTL
-        register_sysctl_paths(tr_path, tr_table);
+        register_net_sysctl_table(&init_net, tr_path, tr_table);
 #endif
         proc_net_fops_create(&init_net, "tr_rif", S_IRUGO, &rif_seq_fops);
         return 0;
diff --git a/net/appletalk/sysctl_net_atalk.c b/net/appletalk/sysctl_net_atalk.c
index 04e9c0da7aa9..5edce8f70cb7 100644
--- a/net/appletalk/sysctl_net_atalk.c
+++ b/net/appletalk/sysctl_net_atalk.c
@@ -52,10 +52,10 @@ static struct ctl_table_header *atalk_table_header;
 
 void atalk_register_sysctl(void)
 {
-        atalk_table_header = register_sysctl_paths(atalk_path, atalk_table);
+        atalk_table_header = register_net_sysctl_table(&init_net, atalk_path, atalk_table);
 }
 
 void atalk_unregister_sysctl(void)
 {
-        unregister_sysctl_table(atalk_table_header);
+        unregister_net_sysctl_table(atalk_table_header);
 }
diff --git a/net/ax25/sysctl_net_ax25.c b/net/ax25/sysctl_net_ax25.c
index ebe0ef3f1d83..7ba381b6f074 100644
--- a/net/ax25/sysctl_net_ax25.c
+++ b/net/ax25/sysctl_net_ax25.c
@@ -196,13 +196,13 @@ void ax25_register_sysctl(void)
         }
         spin_unlock_bh(&ax25_dev_lock);
 
-        ax25_table_header = register_sysctl_paths(ax25_path, ax25_table);
+        ax25_table_header = register_net_sysctl_table(&init_net, ax25_path, ax25_table);
 }
 
 void ax25_unregister_sysctl(void)
 {
         ctl_table *p;
-        unregister_sysctl_table(ax25_table_header);
+        unregister_net_sysctl_table(ax25_table_header);
 
         for (p = ax25_table; p->procname; p++)
                 kfree(p->child);
diff --git a/net/bridge/br_netfilter.c b/net/bridge/br_netfilter.c
index dec4f3817133..4f4c4a619f68 100644
--- a/net/bridge/br_netfilter.c
+++ b/net/bridge/br_netfilter.c
@@ -1030,7 +1030,7 @@ int __init br_netfilter_init(void)
                 return ret;
         }
 #ifdef CONFIG_SYSCTL
-        brnf_sysctl_header = register_sysctl_paths(brnf_path, brnf_table);
+        brnf_sysctl_header = register_net_sysctl_table(&init_net, brnf_path, brnf_table);
         if (brnf_sysctl_header == NULL) {
                 printk(KERN_WARNING
                        "br_netfilter: can't register to sysctl.\n");
@@ -1047,7 +1047,7 @@ void br_netfilter_fini(void)
 {
         nf_unregister_hooks(br_nf_ops, ARRAY_SIZE(br_nf_ops));
 #ifdef CONFIG_SYSCTL
-        unregister_sysctl_table(brnf_sysctl_header);
+        unregister_net_sysctl_table(brnf_sysctl_header);
 #endif
         dst_entries_destroy(&fake_dst_ops);
 }
diff --git a/net/core/neighbour.c b/net/core/neighbour.c
index 434eed8c6185..0c2df3d3cfbf 100644
--- a/net/core/neighbour.c
+++ b/net/core/neighbour.c
@@ -3017,7 +3017,7 @@ void neigh_sysctl_unregister(struct neigh_parms *p)
         if (p->sysctl_table) {
                 struct neigh_sysctl_table *t = p->sysctl_table;
                 p->sysctl_table = NULL;
-                unregister_sysctl_table(t->sysctl_header);
+                unregister_net_sysctl_table(t->sysctl_header);
                 kfree(t->dev_name);
                 kfree(t);
         }
diff --git a/net/core/sysctl_net_core.c b/net/core/sysctl_net_core.c
index 8f67633b484e..7d3772e0d150 100644
--- a/net/core/sysctl_net_core.c
+++ b/net/core/sysctl_net_core.c
@@ -257,7 +257,7 @@ static __init int sysctl_core_init(void)
 {
         static struct ctl_table empty[1];
 
-        kmemleak_not_leak(register_sysctl_paths(net_core_path, empty));
+        kmemleak_not_leak(register_net_sysctl_table(&init_net, net_core_path, empty));
         register_net_sysctl(&init_net, "net/core", net_core_table);
         return register_pernet_subsys(&sysctl_core_ops);
 }
diff --git a/net/dccp/sysctl.c b/net/dccp/sysctl.c
index 42348824ee31..329e1390c26d 100644
--- a/net/dccp/sysctl.c
+++ b/net/dccp/sysctl.c
@@ -109,7 +109,7 @@ static struct ctl_table_header *dccp_table_header;
 
 int __init dccp_sysctl_init(void)
 {
-        dccp_table_header = register_sysctl_paths(dccp_path,
+        dccp_table_header = register_net_sysctl_table(&init_net, dccp_path,
                         dccp_default_table);
 
         return dccp_table_header != NULL ? 0 : -ENOMEM;
@@ -118,7 +118,7 @@ int __init dccp_sysctl_init(void)
 void dccp_sysctl_exit(void)
 {
         if (dccp_table_header != NULL) {
-                unregister_sysctl_table(dccp_table_header);
+                unregister_net_sysctl_table(dccp_table_header);
                 dccp_table_header = NULL;
         }
 }
diff --git a/net/decnet/dn_dev.c b/net/decnet/dn_dev.c
index a4aecb09d12a..ce8a18471845 100644
--- a/net/decnet/dn_dev.c
+++ b/net/decnet/dn_dev.c
@@ -236,7 +236,7 @@ static void dn_dev_sysctl_register(struct net_device *dev, struct dn_dev_parms *
 
         t->dn_dev_vars[0].extra1 = (void *)dev;
 
-        t->sysctl_header = register_sysctl_paths(dn_ctl_path, t->dn_dev_vars);
+        t->sysctl_header = register_net_sysctl_table(&init_net, dn_ctl_path, t->dn_dev_vars);
         if (t->sysctl_header == NULL)
                 kfree(t);
         else
@@ -248,7 +248,7 @@ static void dn_dev_sysctl_unregister(struct dn_dev_parms *parms)
         if (parms->sysctl) {
                 struct dn_dev_sysctl_table *t = parms->sysctl;
                 parms->sysctl = NULL;
-                unregister_sysctl_table(t->sysctl_header);
+                unregister_net_sysctl_table(t->sysctl_header);
                 kfree(t);
         }
 }
diff --git a/net/decnet/sysctl_net_decnet.c b/net/decnet/sysctl_net_decnet.c
index 02e75d11cfbb..4380b8edea72 100644
--- a/net/decnet/sysctl_net_decnet.c
+++ b/net/decnet/sysctl_net_decnet.c
@@ -359,12 +359,12 @@ static struct ctl_path dn_path[] = {
 
 void dn_register_sysctl(void)
 {
-        dn_table_header = register_sysctl_paths(dn_path, dn_table);
+        dn_table_header = register_net_sysctl_table(&init_net, dn_path, dn_table);
 }
 
 void dn_unregister_sysctl(void)
 {
-        unregister_sysctl_table(dn_table_header);
+        unregister_net_sysctl_table(dn_table_header);
 }
 
 #else  /* CONFIG_SYSCTL */
diff --git a/net/ipv4/netfilter/ip_queue.c b/net/ipv4/netfilter/ip_queue.c
index 94d45e1f8882..766485d7d099 100644
--- a/net/ipv4/netfilter/ip_queue.c
+++ b/net/ipv4/netfilter/ip_queue.c
@@ -586,7 +586,7 @@ static int __init ip_queue_init(void)
 #endif
         register_netdevice_notifier(&ipq_dev_notifier);
 #ifdef CONFIG_SYSCTL
-        ipq_sysctl_header = register_sysctl_paths(net_ipv4_ctl_path, ipq_table);
+        ipq_sysctl_header = register_net_sysctl_table(&init_net, net_ipv4_ctl_path, ipq_table);
 #endif
         status = nf_register_queue_handler(NFPROTO_IPV4, &nfqh);
         if (status < 0) {
@@ -597,7 +597,7 @@ static int __init ip_queue_init(void)
 
 cleanup_sysctl:
 #ifdef CONFIG_SYSCTL
-        unregister_sysctl_table(ipq_sysctl_header);
+        unregister_net_sysctl_table(ipq_sysctl_header);
 #endif
         unregister_netdevice_notifier(&ipq_dev_notifier);
         proc_net_remove(&init_net, IPQ_PROC_FS_NAME);
@@ -618,7 +618,7 @@ static void __exit ip_queue_fini(void)
         ipq_flush(NULL, 0);
 
 #ifdef CONFIG_SYSCTL
-        unregister_sysctl_table(ipq_sysctl_header);
+        unregister_net_sysctl_table(ipq_sysctl_header);
 #endif
         unregister_netdevice_notifier(&ipq_dev_notifier);
         proc_net_remove(&init_net, IPQ_PROC_FS_NAME);
diff --git a/net/ipv4/route.c b/net/ipv4/route.c
index a1c115d750e9..86866a4b537f 100644
--- a/net/ipv4/route.c
+++ b/net/ipv4/route.c
@@ -3515,6 +3515,6 @@ int __init ip_rt_init(void)
  */
 void __init ip_static_sysctl_init(void)
 {
-        kmemleak_not_leak(register_sysctl_paths(ipv4_path, ipv4_skeleton));
+        kmemleak_not_leak(register_net_sysctl_table(&init_net, ipv4_path, ipv4_skeleton));
 }
 #endif
diff --git a/net/ipv4/sysctl_net_ipv4.c b/net/ipv4/sysctl_net_ipv4.c
index 34a628625d9c..e7a6fa3d70bb 100644
--- a/net/ipv4/sysctl_net_ipv4.c
+++ b/net/ipv4/sysctl_net_ipv4.c
@@ -857,12 +857,12 @@ static __init int sysctl_ipv4_init(void)
         if (!i->procname)
                 return -EINVAL;
 
-        hdr = register_sysctl_paths(net_ipv4_ctl_path, ipv4_table);
+        hdr = register_net_sysctl_table(&init_net, net_ipv4_ctl_path, ipv4_table);
         if (hdr == NULL)
                 return -ENOMEM;
 
         if (register_pernet_subsys(&ipv4_sysctl_ops)) {
-                unregister_sysctl_table(hdr);
+                unregister_net_sysctl_table(hdr);
                 return -ENOMEM;
         }
 
diff --git a/net/ipv6/netfilter/ip6_queue.c b/net/ipv6/netfilter/ip6_queue.c
index a34c9e4c792c..6785f5044acf 100644
--- a/net/ipv6/netfilter/ip6_queue.c
+++ b/net/ipv6/netfilter/ip6_queue.c
@@ -588,7 +588,7 @@ static int __init ip6_queue_init(void)
 #endif
         register_netdevice_notifier(&ipq_dev_notifier);
 #ifdef CONFIG_SYSCTL
-        ipq_sysctl_header = register_sysctl_paths(net_ipv6_ctl_path, ipq_table);
+        ipq_sysctl_header = register_net_sysctl_table(&init_net, net_ipv6_ctl_path, ipq_table);
 #endif
         status = nf_register_queue_handler(NFPROTO_IPV6, &nfqh);
         if (status < 0) {
@@ -599,7 +599,7 @@ static int __init ip6_queue_init(void)
 
 cleanup_sysctl:
 #ifdef CONFIG_SYSCTL
-        unregister_sysctl_table(ipq_sysctl_header);
+        unregister_net_sysctl_table(ipq_sysctl_header);
 #endif
         unregister_netdevice_notifier(&ipq_dev_notifier);
         proc_net_remove(&init_net, IPQ_PROC_FS_NAME);
@@ -621,7 +621,7 @@ static void __exit ip6_queue_fini(void)
         ipq_flush(NULL, 0);
 
 #ifdef CONFIG_SYSCTL
-        unregister_sysctl_table(ipq_sysctl_header);
+        unregister_net_sysctl_table(ipq_sysctl_header);
 #endif
         unregister_netdevice_notifier(&ipq_dev_notifier);
         proc_net_remove(&init_net, IPQ_PROC_FS_NAME);
diff --git a/net/ipv6/netfilter/nf_conntrack_reasm.c b/net/ipv6/netfilter/nf_conntrack_reasm.c
index 38f00b0298d3..754814462950 100644
--- a/net/ipv6/netfilter/nf_conntrack_reasm.c
+++ b/net/ipv6/netfilter/nf_conntrack_reasm.c
@@ -626,7 +626,7 @@ int nf_ct_frag6_init(void)
         inet_frags_init(&nf_frags);
 
 #ifdef CONFIG_SYSCTL
-        nf_ct_frag6_sysctl_header = register_sysctl_paths(nf_net_netfilter_sysctl_path,
+        nf_ct_frag6_sysctl_header = register_net_sysctl_table(&init_net, nf_net_netfilter_sysctl_path,
                                                           nf_ct_frag6_sysctl_table);
         if (!nf_ct_frag6_sysctl_header) {
                 inet_frags_fini(&nf_frags);
@@ -640,7 +640,7 @@ int nf_ct_frag6_init(void)
 void nf_ct_frag6_cleanup(void)
 {
 #ifdef CONFIG_SYSCTL
-        unregister_sysctl_table(nf_ct_frag6_sysctl_header);
+        unregister_net_sysctl_table(nf_ct_frag6_sysctl_header);
         nf_ct_frag6_sysctl_header = NULL;
 #endif
         inet_frags_fini(&nf_frags);
diff --git a/net/ipv6/sysctl_net_ipv6.c b/net/ipv6/sysctl_net_ipv6.c
index 06f21e5ad361..99279c8aaf29 100644
--- a/net/ipv6/sysctl_net_ipv6.c
+++ b/net/ipv6/sysctl_net_ipv6.c
@@ -165,7 +165,7 @@ static struct ctl_table_header *ip6_base;
 
 int ipv6_static_sysctl_register(void)
 {
-        ip6_base = register_sysctl_paths(net_ipv6_ctl_path, ipv6_static_skeleton);
+        ip6_base = register_net_sysctl_table(&init_net, net_ipv6_ctl_path, ipv6_static_skeleton);
         if (ip6_base == NULL)
                 return -ENOMEM;
         return 0;
diff --git a/net/ipx/sysctl_net_ipx.c b/net/ipx/sysctl_net_ipx.c
index bd6dca00fb85..035880709e84 100644
--- a/net/ipx/sysctl_net_ipx.c
+++ b/net/ipx/sysctl_net_ipx.c
@@ -8,6 +8,7 @@
 
 #include <linux/mm.h>
 #include <linux/sysctl.h>
+#include <net/net_namespace.h>
 
 #ifndef CONFIG_SYSCTL
 #error This file should not be compiled without CONFIG_SYSCTL defined
@@ -37,10 +38,10 @@ static struct ctl_table_header *ipx_table_header;
 
 void ipx_register_sysctl(void)
 {
-        ipx_table_header = register_sysctl_paths(ipx_path, ipx_table);
+        ipx_table_header = register_net_sysctl_table(&init_net, ipx_path, ipx_table);
 }
 
 void ipx_unregister_sysctl(void)
 {
-        unregister_sysctl_table(ipx_table_header);
+        unregister_net_sysctl_table(ipx_table_header);
 }
diff --git a/net/irda/irsysctl.c b/net/irda/irsysctl.c
index 2615ffc8e785..20ced38fc371 100644
--- a/net/irda/irsysctl.c
+++ b/net/irda/irsysctl.c
@@ -251,7 +251,7 @@ static struct ctl_table_header *irda_table_header;
  */
 int __init irda_sysctl_register(void)
 {
-        irda_table_header = register_sysctl_paths(irda_path, irda_table);
+        irda_table_header = register_net_sysctl_table(&init_net, irda_path, irda_table);
         if (!irda_table_header)
                 return -ENOMEM;
 
@@ -266,7 +266,7 @@ int __init irda_sysctl_register(void)
  */
 void irda_sysctl_unregister(void)
 {
-        unregister_sysctl_table(irda_table_header);
+        unregister_net_sysctl_table(irda_table_header);
 }
 
 
diff --git a/net/llc/sysctl_net_llc.c b/net/llc/sysctl_net_llc.c
index e2ebe3586263..9a6a65f2104b 100644
--- a/net/llc/sysctl_net_llc.c
+++ b/net/llc/sysctl_net_llc.c
@@ -7,6 +7,7 @@
 #include <linux/mm.h>
 #include <linux/init.h>
 #include <linux/sysctl.h>
+#include <net/net_namespace.h>
 #include <net/llc.h>
 
 #ifndef CONFIG_SYSCTL
@@ -89,7 +90,7 @@ static struct ctl_table_header *llc_table_header;
 
 int __init llc_sysctl_init(void)
 {
-        llc_table_header = register_sysctl_paths(llc_path, llc_table);
+        llc_table_header = register_net_sysctl_table(&init_net, llc_path, llc_table);
 
         return llc_table_header ? 0 : -ENOMEM;
 }
@@ -97,7 +98,7 @@ int __init llc_sysctl_init(void)
 void llc_sysctl_exit(void)
 {
         if (llc_table_header) {
-                unregister_sysctl_table(llc_table_header);
+                unregister_net_sysctl_table(llc_table_header);
                 llc_table_header = NULL;
         }
 }
diff --git a/net/netfilter/nf_conntrack_proto.c b/net/netfilter/nf_conntrack_proto.c
index be3da2c8cdc5..bbc753fd4fe0 100644
--- a/net/netfilter/nf_conntrack_proto.c
+++ b/net/netfilter/nf_conntrack_proto.c
@@ -40,7 +40,7 @@ nf_ct_register_sysctl(struct ctl_table_header **header, struct ctl_path *path,
                       struct ctl_table *table, unsigned int *users)
 {
         if (*header == NULL) {
-                *header = register_sysctl_paths(path, table);
+                *header = register_net_sysctl_table(&init_net, path, table);
                 if (*header == NULL)
                         return -ENOMEM;
         }
@@ -56,7 +56,7 @@ nf_ct_unregister_sysctl(struct ctl_table_header **header,
         if (users != NULL && --*users > 0)
                 return;
 
-        unregister_sysctl_table(*header);
+        unregister_net_sysctl_table(*header);
         *header = NULL;
 }
 #endif
diff --git a/net/netfilter/nf_conntrack_standalone.c b/net/netfilter/nf_conntrack_standalone.c
index 885f5ab9bc28..0c3888de0f55 100644
--- a/net/netfilter/nf_conntrack_standalone.c
+++ b/net/netfilter/nf_conntrack_standalone.c
@@ -479,7 +479,7 @@ static int nf_conntrack_standalone_init_sysctl(struct net *net)
 
         if (net_eq(net, &init_net)) {
                 nf_ct_netfilter_header =
-                       register_sysctl_paths(nf_ct_path, nf_ct_netfilter_table);
+                       register_net_sysctl_table(&init_net, nf_ct_path, nf_ct_netfilter_table);
                 if (!nf_ct_netfilter_header)
                         goto out;
         }
@@ -505,7 +505,7 @@ out_unregister_netfilter:
         kfree(table);
 out_kmemdup:
         if (net_eq(net, &init_net))
-                unregister_sysctl_table(nf_ct_netfilter_header);
+                unregister_net_sysctl_table(nf_ct_netfilter_header);
 out:
         printk(KERN_ERR "nf_conntrack: can't register to sysctl.\n");
         return -ENOMEM;
@@ -516,7 +516,7 @@ static void nf_conntrack_standalone_fini_sysctl(struct net *net)
         struct ctl_table *table;
 
         if (net_eq(net, &init_net))
-                unregister_sysctl_table(nf_ct_netfilter_header);
+                unregister_net_sysctl_table(nf_ct_netfilter_header);
         table = net->ct.sysctl_header->ctl_table_arg;
         unregister_net_sysctl_table(net->ct.sysctl_header);
         kfree(table);
diff --git a/net/netfilter/nf_log.c b/net/netfilter/nf_log.c
index 957374a234d4..04fca48d901a 100644
--- a/net/netfilter/nf_log.c
+++ b/net/netfilter/nf_log.c
@@ -283,7 +283,7 @@ static __init int netfilter_log_sysctl_init(void)
                 nf_log_sysctl_table[i].extra1 = (void *)(unsigned long) i;
         }
 
-        nf_log_dir_header = register_sysctl_paths(nf_log_sysctl_path,
+        nf_log_dir_header = register_net_sysctl_table(&init_net, nf_log_sysctl_path,
                                        nf_log_sysctl_table);
         if (!nf_log_dir_header)
                 return -ENOMEM;
diff --git a/net/netrom/sysctl_net_netrom.c b/net/netrom/sysctl_net_netrom.c
index 1e0fa9e57aac..4ed149e265bf 100644
--- a/net/netrom/sysctl_net_netrom.c
+++ b/net/netrom/sysctl_net_netrom.c
@@ -154,10 +154,10 @@ static struct ctl_path nr_path[] = {
 
 void __init nr_register_sysctl(void)
 {
-        nr_table_header = register_sysctl_paths(nr_path, nr_table);
+        nr_table_header = register_net_sysctl_table(&init_net, nr_path, nr_table);
 }
 
 void nr_unregister_sysctl(void)
 {
-        unregister_sysctl_table(nr_table_header);
+        unregister_net_sysctl_table(nr_table_header);
 }
diff --git a/net/phonet/sysctl.c b/net/phonet/sysctl.c
index 8bed7675b3f4..aa55db5f383b 100644
--- a/net/phonet/sysctl.c
+++ b/net/phonet/sysctl.c
@@ -106,11 +106,11 @@ static struct ctl_path phonet_ctl_path[] = {
 
 int __init phonet_sysctl_init(void)
 {
-        phonet_table_hrd = register_sysctl_paths(phonet_ctl_path, phonet_table);
+        phonet_table_hrd = register_net_sysctl_table(&init_net, phonet_ctl_path, phonet_table);
         return phonet_table_hrd == NULL ? -ENOMEM : 0;
 }
 
 void phonet_sysctl_exit(void)
 {
-        unregister_sysctl_table(phonet_table_hrd);
+        unregister_net_sysctl_table(phonet_table_hrd);
 }
diff --git a/net/rds/ib_sysctl.c b/net/rds/ib_sysctl.c
index 1253b006efdb..0fef3e15777b 100644
--- a/net/rds/ib_sysctl.c
+++ b/net/rds/ib_sysctl.c
@@ -116,12 +116,12 @@ static struct ctl_path rds_ib_sysctl_path[] = {
 void rds_ib_sysctl_exit(void)
 {
         if (rds_ib_sysctl_hdr)
-                unregister_sysctl_table(rds_ib_sysctl_hdr);
+                unregister_net_sysctl_table(rds_ib_sysctl_hdr);
 }
 
 int rds_ib_sysctl_init(void)
 {
-        rds_ib_sysctl_hdr = register_sysctl_paths(rds_ib_sysctl_path, rds_ib_sysctl_table);
+        rds_ib_sysctl_hdr = register_net_sysctl_table(&init_net, rds_ib_sysctl_path, rds_ib_sysctl_table);
         if (!rds_ib_sysctl_hdr)
                 return -ENOMEM;
         return 0;
diff --git a/net/rds/iw_sysctl.c b/net/rds/iw_sysctl.c
index e2e47176e729..bcfe36dc55a7 100644
--- a/net/rds/iw_sysctl.c
+++ b/net/rds/iw_sysctl.c
@@ -119,12 +119,12 @@ static struct ctl_path rds_iw_sysctl_path[] = {
 void rds_iw_sysctl_exit(void)
 {
         if (rds_iw_sysctl_hdr)
-                unregister_sysctl_table(rds_iw_sysctl_hdr);
+                unregister_net_sysctl_table(rds_iw_sysctl_hdr);
 }
 
 int rds_iw_sysctl_init(void)
 {
-        rds_iw_sysctl_hdr = register_sysctl_paths(rds_iw_sysctl_path, rds_iw_sysctl_table);
+        rds_iw_sysctl_hdr = register_net_sysctl_table(&init_net, rds_iw_sysctl_path, rds_iw_sysctl_table);
         if (!rds_iw_sysctl_hdr)
                 return -ENOMEM;
         return 0;
diff --git a/net/rds/sysctl.c b/net/rds/sysctl.c
index 25ad0c77a26c..30354b8cd584 100644
--- a/net/rds/sysctl.c
+++ b/net/rds/sysctl.c
@@ -102,7 +102,7 @@ static struct ctl_path rds_sysctl_path[] = {
 void rds_sysctl_exit(void)
 {
         if (rds_sysctl_reg_table)
-                unregister_sysctl_table(rds_sysctl_reg_table);
+                unregister_net_sysctl_table(rds_sysctl_reg_table);
 }
 
 int rds_sysctl_init(void)
@@ -110,7 +110,7 @@ int rds_sysctl_init(void)
         rds_sysctl_reconnect_min = msecs_to_jiffies(1);
         rds_sysctl_reconnect_min_jiffies = rds_sysctl_reconnect_min;
 
-        rds_sysctl_reg_table = register_sysctl_paths(rds_sysctl_path, rds_sysctl_rds_table);
+        rds_sysctl_reg_table = register_net_sysctl_table(&init_net, rds_sysctl_path, rds_sysctl_rds_table);
         if (!rds_sysctl_reg_table)
                 return -ENOMEM;
         return 0;
diff --git a/net/rose/sysctl_net_rose.c b/net/rose/sysctl_net_rose.c
index df6d9dac2186..02b73979535b 100644
--- a/net/rose/sysctl_net_rose.c
+++ b/net/rose/sysctl_net_rose.c
@@ -126,10 +126,10 @@ static struct ctl_path rose_path[] = {
 
 void __init rose_register_sysctl(void)
 {
-        rose_table_header = register_sysctl_paths(rose_path, rose_table);
+        rose_table_header = register_net_sysctl_table(&init_net, rose_path, rose_table);
 }
 
 void rose_unregister_sysctl(void)
 {
-        unregister_sysctl_table(rose_table_header);
+        unregister_net_sysctl_table(rose_table_header);
 }
diff --git a/net/sctp/sysctl.c b/net/sctp/sysctl.c
index 60ffbd067ff7..1e385b452047 100644
--- a/net/sctp/sysctl.c
+++ b/net/sctp/sysctl.c
@@ -286,11 +286,11 @@ static struct ctl_table_header * sctp_sysctl_header;
 /* Sysctl registration.  */
 void sctp_sysctl_register(void)
 {
-        sctp_sysctl_header = register_sysctl_paths(sctp_path, sctp_table);
+        sctp_sysctl_header = register_net_sysctl_table(&init_net, sctp_path, sctp_table);
 }
 
 /* Sysctl deregistration.  */
 void sctp_sysctl_unregister(void)
 {
-        unregister_sysctl_table(sctp_sysctl_header);
+        unregister_net_sysctl_table(sctp_sysctl_header);
 }
diff --git a/net/unix/sysctl_net_unix.c b/net/unix/sysctl_net_unix.c
index 397cffebb3b6..4f6979c06f84 100644
--- a/net/unix/sysctl_net_unix.c
+++ b/net/unix/sysctl_net_unix.c
@@ -58,6 +58,6 @@ void unix_sysctl_unregister(struct net *net)
         struct ctl_table *table;
 
         table = net->unx.ctl->ctl_table_arg;
-        unregister_sysctl_table(net->unx.ctl);
+        unregister_net_sysctl_table(net->unx.ctl);
         kfree(table);
 }
diff --git a/net/x25/sysctl_net_x25.c b/net/x25/sysctl_net_x25.c
index d2efd29f434e..08337cb488d4 100644
--- a/net/x25/sysctl_net_x25.c
+++ b/net/x25/sysctl_net_x25.c
@@ -81,10 +81,10 @@ static struct ctl_path x25_path[] = {
 
 void __init x25_register_sysctl(void)
 {
-        x25_table_header = register_sysctl_paths(x25_path, x25_table);
+        x25_table_header = register_net_sysctl_table(&init_net, x25_path, x25_table);
 }
 
 void x25_unregister_sysctl(void)
 {
-        unregister_sysctl_table(x25_table_header);
+        unregister_net_sysctl_table(x25_table_header);
 }