dect
/
linux-2.6
Archived
13
0
Fork 0
Code Releases Activity

net: Convert all sysctl registrations to register_net_sysctl 

This results in code with less boiler plate that is a bit easier
to read.

Additionally stops us from using compatibility code in the sysctl
core, hastening the day when the compatibility code can be removed.

Signed-off-by: Eric W. Biederman <ebiederm@xmission.com>
Acked-by: Pavel Emelyanov <xemul@parallels.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
Eric W. Biederman 2012-04-19 13:44:49 +00:00 committed by David S. Miller
parent f99e8f715a
commit ec8f23ce0f
36 changed files with 44 additions and 171 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
drivers/infiniband/core/ucma.c
View File

@ -66,12 +66,6 @@ static ctl_table ucma_ctl_table[] = {
{ }
};
static struct ctl_path ucma_ctl_path[] = {
{ .procname = "net" },
{ .procname = "rdma_ucm" },
{ }
};
struct ucma_file {
struct mutex mut;
struct file *filp;
@ -1392,7 +1386,7 @@ static int __init ucma_init(void)
goto err1;
}
ucma_ctl_table_hdr = register_net_sysctl_table(&init_net, ucma_ctl_path, ucma_ctl_table);
ucma_ctl_table_hdr = register_net_sysctl(&init_net, "net/rdma_ucm", ucma_ctl_table);
if (!ucma_ctl_table_hdr) {
printk(KERN_ERR "rdma_ucm: couldn't register sysctl paths\n");
ret = -ENOMEM;

8
net/802/tr.c
View File

@ -643,12 +643,6 @@ static struct ctl_table tr_table[] = {
},
{ },
};
static __initdata struct ctl_path tr_path[] = {
{ .procname = "net", },
{ .procname = "token-ring", },
{ }
};
#endif
/*
@ -662,7 +656,7 @@ static int __init rif_init(void)
setup_timer(&rif_timer, rif_check_expire, 0);
add_timer(&rif_timer);
#ifdef CONFIG_SYSCTL
register_net_sysctl_table(&init_net, tr_path, tr_table);
register_net_sysctl(&init_net, "net/token-ring", tr_table);
#endif
proc_net_fops_create(&init_net, "tr_rif", S_IRUGO, &rif_seq_fops);
return 0;

8
net/appletalk/sysctl_net_atalk.c
View File

@ -42,17 +42,11 @@ static struct ctl_table atalk_table[] = {
{ },
};
static struct ctl_path atalk_path[] = {
{ .procname = "net", },
{ .procname = "appletalk", },
{ }
};
static struct ctl_table_header *atalk_table_header;
void atalk_register_sysctl(void)
{
atalk_table_header = register_net_sysctl_table(&init_net, atalk_path, atalk_table);
atalk_table_header = register_net_sysctl(&init_net, "net/appletalk", atalk_table);
}
void atalk_unregister_sysctl(void)

8
net/bridge/br_netfilter.c
View File

@ -1008,12 +1008,6 @@ static ctl_table brnf_table[] = {
},
{ }
};
static struct ctl_path brnf_path[] = {
{ .procname = "net", },
{ .procname = "bridge", },
{ }
};
#endif
int __init br_netfilter_init(void)
@ -1030,7 +1024,7 @@ int __init br_netfilter_init(void)
return ret;
}
#ifdef CONFIG_SYSCTL
brnf_sysctl_header = register_net_sysctl_table(&init_net, brnf_path, brnf_table);
brnf_sysctl_header = register_net_sysctl(&init_net, "net/bridge", brnf_table);
if (brnf_sysctl_header == NULL) {
printk(KERN_WARNING
"br_netfilter: can't register to sysctl.\n");

3
net/core/sysctl_net_core.c
View File

@ -224,8 +224,7 @@ static __net_init int sysctl_core_net_init(struct net *net)
tbl[0].data = &net->core.sysctl_somaxconn;
}
net->core.sysctl_hdr = register_net_sysctl_table(net,
net_core_path, tbl);
net->core.sysctl_hdr = register_net_sysctl(net, "net/core", tbl);
if (net->core.sysctl_hdr == NULL)
goto err_reg;

9
net/dccp/sysctl.c
View File

@ -98,18 +98,11 @@ static struct ctl_table dccp_default_table[] = {
{ }
};
static struct ctl_path dccp_path[] = {
{ .procname = "net", },
{ .procname = "dccp", },
{ .procname = "default", },
{ }
};
static struct ctl_table_header *dccp_table_header;
int __init dccp_sysctl_init(void)
{
dccp_table_header = register_net_sysctl_table(&init_net, dccp_path,
dccp_table_header = register_net_sysctl(&init_net, "net/dccp/default",
dccp_default_table);
return dccp_table_header != NULL ? 0 : -ENOMEM;

2
net/ipv4/ip_fragment.c
View File

@ -782,7 +782,7 @@ static int __net_init ip4_frags_ns_ctl_register(struct net *net)
table[2].data = &net->ipv4.frags.timeout;
}
hdr = register_net_sysctl_table(net, net_ipv4_ctl_path, table);
hdr = register_net_sysctl(net, "net/ipv4", table);
if (hdr == NULL)
goto err_reg;

2
net/ipv4/netfilter/ip_queue.c
View File

@ -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_net_sysctl_table(&init_net, net_ipv4_ctl_path, ipq_table);
ipq_sysctl_header = register_net_sysctl(&init_net, "net/ipv4", ipq_table);
#endif
status = nf_register_queue_handler(NFPROTO_IPV4, &nfqh);
if (status < 0) {

10
net/ipv4/route.c
View File

@ -3354,13 +3354,6 @@ static struct ctl_table ipv4_route_flush_table[] = {
{ },
};
static __net_initdata struct ctl_path ipv4_route_path[] = {
{ .procname = "net", },
{ .procname = "ipv4", },
{ .procname = "route", },
{ },
};
static __net_init int sysctl_route_net_init(struct net *net)
{
struct ctl_table *tbl;
@ -3373,8 +3366,7 @@ static __net_init int sysctl_route_net_init(struct net *net)
}
tbl[0].extra1 = net;
net->ipv4.route_hdr =
register_net_sysctl_table(net, ipv4_route_path, tbl);
net->ipv4.route_hdr = register_net_sysctl(net, "net/ipv4/route", tbl);
if (net->ipv4.route_hdr == NULL)
goto err_reg;
return 0;

5
net/ipv4/sysctl_net_ipv4.c
View File

@ -815,8 +815,7 @@ static __net_init int ipv4_sysctl_init_net(struct net *net)
tcp_init_mem(net);
net->ipv4.ipv4_hdr = register_net_sysctl_table(net,
net_ipv4_ctl_path, table);
net->ipv4.ipv4_hdr = register_net_sysctl(net, "net/ipv4", table);
if (net->ipv4.ipv4_hdr == NULL)
goto err_reg;
@ -857,7 +856,7 @@ static __init int sysctl_ipv4_init(void)
if (!i->procname)
return -EINVAL;
hdr = register_net_sysctl_table(&init_net, net_ipv4_ctl_path, ipv4_table);
hdr = register_net_sysctl(&init_net, "net/ipv4", ipv4_table);
if (hdr == NULL)
return -ENOMEM;

4
net/ipv4/xfrm4_policy.c
View File

@ -298,8 +298,8 @@ void __init xfrm4_init(int rt_max_size)
xfrm4_state_init();
xfrm4_policy_init();
#ifdef CONFIG_SYSCTL
sysctl_hdr = register_net_sysctl_table(&init_net, net_ipv4_ctl_path,
xfrm4_policy_table);
sysctl_hdr = register_net_sysctl(&init_net, "net/ipv4",
xfrm4_policy_table);
#endif
}

2
net/ipv6/netfilter/ip6_queue.c
View File

@ -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_net_sysctl_table(&init_net, net_ipv6_ctl_path, ipq_table);
ipq_sysctl_header = register_net_sysctl(&init_net, "net/ipv6", ipq_table);
#endif
status = nf_register_queue_handler(NFPROTO_IPV6, &nfqh);
if (status < 0) {

4
net/ipv6/netfilter/nf_conntrack_reasm.c
View File

@ -626,8 +626,8 @@ int nf_ct_frag6_init(void)
inet_frags_init(&nf_frags);
#ifdef CONFIG_SYSCTL
nf_ct_frag6_sysctl_header = register_net_sysctl_table(&init_net, nf_net_netfilter_sysctl_path,
nf_ct_frag6_sysctl_table);
nf_ct_frag6_sysctl_header = register_net_sysctl(&init_net, "net/netfilter",
nf_ct_frag6_sysctl_table);
if (!nf_ct_frag6_sysctl_header) {
inet_frags_fini(&nf_frags);
return -ENOMEM;

2
net/ipv6/reassembly.c
View File

@ -646,7 +646,7 @@ static int __net_init ip6_frags_ns_sysctl_register(struct net *net)
table[2].data = &net->ipv6.frags.timeout;
}
hdr = register_net_sysctl_table(net, net_ipv6_ctl_path, table);
hdr = register_net_sysctl(net, "net/ipv6", table);
if (hdr == NULL)
goto err_reg;

4
net/ipv6/xfrm6_policy.c
View File

@ -334,8 +334,8 @@ int __init xfrm6_init(void)
goto out_policy;
#ifdef CONFIG_SYSCTL
sysctl_hdr = register_net_sysctl_table(&init_net, net_ipv6_ctl_path,
xfrm6_policy_table);
sysctl_hdr = register_net_sysctl(&init_net, "net/ipv6",
xfrm6_policy_table);
#endif
out:
return ret;

8
net/ipx/sysctl_net_ipx.c
View File

@ -28,17 +28,11 @@ static struct ctl_table ipx_table[] = {
{ },
};
static struct ctl_path ipx_path[] = {
{ .procname = "net", },
{ .procname = "ipx", },
{ }
};
static struct ctl_table_header *ipx_table_header;
void ipx_register_sysctl(void)
{
ipx_table_header = register_net_sysctl_table(&init_net, ipx_path, ipx_table);
ipx_table_header = register_net_sysctl(&init_net, "net/ipx", ipx_table);
}
void ipx_unregister_sysctl(void)

8
net/irda/irsysctl.c
View File

@ -235,12 +235,6 @@ static ctl_table irda_table[] = {
{ }
};
static struct ctl_path irda_path[] = {
{ .procname = "net", },
{ .procname = "irda", },
{ }
};
static struct ctl_table_header *irda_table_header;
/*
@ -251,7 +245,7 @@ static struct ctl_table_header *irda_table_header;
*/
int __init irda_sysctl_register(void)
{
irda_table_header = register_net_sysctl_table(&init_net, irda_path, irda_table);
irda_table_header = register_net_sysctl(&init_net, "net/irda", irda_table);
if (!irda_table_header)
return -ENOMEM;

3
net/netfilter/ipvs/ip_vs_ctl.c
View File

@ -3672,8 +3672,7 @@ int __net_init ip_vs_control_net_init_sysctl(struct net *net)
tbl[idx++].data = &ipvs->sysctl_nat_icmp_send;
ipvs->sysctl_hdr = register_net_sysctl_table(net, net_vs_ctl_path,
tbl);
ipvs->sysctl_hdr = register_net_sysctl(net, "net/ipv4/vs", tbl);
if (ipvs->sysctl_hdr == NULL) {
if (!net_eq(net, &init_net))
kfree(tbl);

3
net/netfilter/ipvs/ip_vs_lblc.c
View File

@ -563,8 +563,7 @@ static int __net_init __ip_vs_lblc_init(struct net *net)
ipvs->lblc_ctl_table[0].data = &ipvs->sysctl_lblc_expiration;
ipvs->lblc_ctl_header =
register_net_sysctl_table(net, net_vs_ctl_path,
ipvs->lblc_ctl_table);
register_net_sysctl(net, "net/ipv4/vs", ipvs->lblc_ctl_table);
if (!ipvs->lblc_ctl_header) {
if (!net_eq(net, &init_net))
kfree(ipvs->lblc_ctl_table);

3
net/netfilter/ipvs/ip_vs_lblcr.c
View File

@ -757,8 +757,7 @@ static int __net_init __ip_vs_lblcr_init(struct net *net)
ipvs->lblcr_ctl_table[0].data = &ipvs->sysctl_lblcr_expiration;
ipvs->lblcr_ctl_header =
register_net_sysctl_table(net, net_vs_ctl_path,
ipvs->lblcr_ctl_table);
register_net_sysctl(net, "net/ipv4/vs", ipvs->lblcr_ctl_table);
if (!ipvs->lblcr_ctl_header) {
if (!net_eq(net, &init_net))
kfree(ipvs->lblcr_ctl_table);

4
net/netfilter/nf_conntrack_acct.c
View File

@ -69,8 +69,8 @@ static int nf_conntrack_acct_init_sysctl(struct net *net)
table[0].data = &net->ct.sysctl_acct;
net->ct.acct_sysctl_header = register_net_sysctl_table(net,
nf_net_netfilter_sysctl_path, table);
net->ct.acct_sysctl_header = register_net_sysctl(net, "net/netfilter",
table);
if (!net->ct.acct_sysctl_header) {
printk(KERN_ERR "nf_conntrack_acct: can't register to sysctl.\n");
goto out_register;

3
net/netfilter/nf_conntrack_ecache.c
View File

@ -199,8 +199,7 @@ static int nf_conntrack_event_init_sysctl(struct net *net)
table[1].data = &net->ct.sysctl_events_retry_timeout;
net->ct.event_sysctl_header =
register_net_sysctl_table(net,
nf_net_netfilter_sysctl_path, table);
register_net_sysctl(net, "net/netfilter", table);
if (!net->ct.event_sysctl_header) {
printk(KERN_ERR "nf_ct_event: can't register to sysctl.\n");
goto out_register;

4
net/netfilter/nf_conntrack_proto_dccp.c
View File

@ -910,8 +910,8 @@ static __net_init int dccp_net_init(struct net *net)
dn->sysctl_table[6].data = &dn->dccp_timeout[CT_DCCP_TIMEWAIT];
dn->sysctl_table[7].data = &dn->dccp_loose;
dn->sysctl_header = register_net_sysctl_table(net,
nf_net_netfilter_sysctl_path, dn->sysctl_table);
dn->sysctl_header = register_net_sysctl(net, "net/netfilter",
dn->sysctl_table);
if (!dn->sysctl_header) {
kfree(dn->sysctl_table);
return -ENOMEM;

10
net/netfilter/nf_conntrack_standalone.c
View File

@ -468,18 +468,13 @@ static ctl_table nf_ct_netfilter_table[] = {
{ }
};
static struct ctl_path nf_ct_path[] = {
{ .procname = "net", },
{ }
};
static int nf_conntrack_standalone_init_sysctl(struct net *net)
{
struct ctl_table *table;
if (net_eq(net, &init_net)) {
nf_ct_netfilter_header =
register_net_sysctl_table(&init_net, nf_ct_path, nf_ct_netfilter_table);
register_net_sysctl(&init_net, "net", nf_ct_netfilter_table);
if (!nf_ct_netfilter_header)
goto out;
}
@ -494,8 +489,7 @@ static int nf_conntrack_standalone_init_sysctl(struct net *net)
table[3].data = &net->ct.sysctl_checksum;
table[4].data = &net->ct.sysctl_log_invalid;
net->ct.sysctl_header = register_net_sysctl_table(net,
nf_net_netfilter_sysctl_path, table);
net->ct.sysctl_header = register_net_sysctl(net, "net/netfilter", table);
if (!net->ct.sysctl_header)
goto out_unregister_netfilter;

4
net/netfilter/nf_conntrack_timestamp.c
View File

@ -51,8 +51,8 @@ static int nf_conntrack_tstamp_init_sysctl(struct net *net)
table[0].data = &net->ct.sysctl_tstamp;
net->ct.tstamp_sysctl_header = register_net_sysctl_table(net,
nf_net_netfilter_sysctl_path, table);
net->ct.tstamp_sysctl_header = register_net_sysctl(net, "net/netfilter",
table);
if (!net->ct.tstamp_sysctl_header) {
printk(KERN_ERR "nf_ct_tstamp: can't register to sysctl.\n");
goto out_register;

9
net/netfilter/nf_log.c
View File

@ -214,13 +214,6 @@ static const struct file_operations nflog_file_ops = {
#endif /* PROC_FS */
#ifdef CONFIG_SYSCTL
static struct ctl_path nf_log_sysctl_path[] = {
{ .procname = "net", },
{ .procname = "netfilter", },
{ .procname = "nf_log", },
{ }
};
static char nf_log_sysctl_fnames[NFPROTO_NUMPROTO-NFPROTO_UNSPEC][3];
static struct ctl_table nf_log_sysctl_table[NFPROTO_NUMPROTO+1];
static struct ctl_table_header *nf_log_dir_header;
@ -283,7 +276,7 @@ static __init int netfilter_log_sysctl_init(void)
nf_log_sysctl_table[i].extra1 = (void *)(unsigned long) i;
}
nf_log_dir_header = register_net_sysctl_table(&init_net, nf_log_sysctl_path,
nf_log_dir_header = register_net_sysctl(&init_net, "net/netfilter/nf_log",
nf_log_sysctl_table);
if (!nf_log_dir_header)
return -ENOMEM;

8
net/netrom/sysctl_net_netrom.c
View File

@ -146,15 +146,9 @@ static ctl_table nr_table[] = {
{ }
};
static struct ctl_path nr_path[] = {
{ .procname = "net", },
{ .procname = "netrom", },
{ }
};
void __init nr_register_sysctl(void)
{
nr_table_header = register_net_sysctl_table(&init_net, nr_path, nr_table);
nr_table_header = register_net_sysctl(&init_net, "net/netrom", nr_table);
}
void nr_unregister_sysctl(void)

8
net/phonet/sysctl.c
View File

@ -98,15 +98,9 @@ static struct ctl_table phonet_table[] = {
{ }
};
static struct ctl_path phonet_ctl_path[] = {
{ .procname = "net", },
{ .procname = "phonet", },
{ },
};
int __init phonet_sysctl_init(void)
{
phonet_table_hrd = register_net_sysctl_table(&init_net, phonet_ctl_path, phonet_table);
phonet_table_hrd = register_net_sysctl(&init_net, "net/phonet", phonet_table);
return phonet_table_hrd == NULL ? -ENOMEM : 0;
}

9
net/rds/ib_sysctl.c
View File

@ -106,13 +106,6 @@ static ctl_table rds_ib_sysctl_table[] = {
{ }
};
static struct ctl_path rds_ib_sysctl_path[] = {
{ .procname = "net", },
{ .procname = "rds", },
{ .procname = "ib", },
{ }
};
void rds_ib_sysctl_exit(void)
{
if (rds_ib_sysctl_hdr)
@ -121,7 +114,7 @@ void rds_ib_sysctl_exit(void)
int rds_ib_sysctl_init(void)
{
rds_ib_sysctl_hdr = register_net_sysctl_table(&init_net, rds_ib_sysctl_path, rds_ib_sysctl_table);
rds_ib_sysctl_hdr = register_net_sysctl(&init_net, "net/rds/ib", rds_ib_sysctl_table);
if (!rds_ib_sysctl_hdr)
return -ENOMEM;
return 0;

9
net/rds/iw_sysctl.c
View File

@ -109,13 +109,6 @@ static ctl_table rds_iw_sysctl_table[] = {
{ }
};
static struct ctl_path rds_iw_sysctl_path[] = {
{ .procname = "net", },
{ .procname = "rds", },
{ .procname = "iw", },
{ }
};
void rds_iw_sysctl_exit(void)
{
if (rds_iw_sysctl_hdr)
@ -124,7 +117,7 @@ void rds_iw_sysctl_exit(void)
int rds_iw_sysctl_init(void)
{
rds_iw_sysctl_hdr = register_net_sysctl_table(&init_net, rds_iw_sysctl_path, rds_iw_sysctl_table);
rds_iw_sysctl_hdr = register_net_sysctl(&init_net, "net/rds/iw", rds_iw_sysctl_table);
if (!rds_iw_sysctl_hdr)
return -ENOMEM;
return 0;

9
net/rds/sysctl.c
View File

@ -92,13 +92,6 @@ static ctl_table rds_sysctl_rds_table[] = {
{ }
};
static struct ctl_path rds_sysctl_path[] = {
{ .procname = "net", },
{ .procname = "rds", },
{ }
};
void rds_sysctl_exit(void)
{
if (rds_sysctl_reg_table)
@ -110,7 +103,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_net_sysctl_table(&init_net, rds_sysctl_path, rds_sysctl_rds_table);
rds_sysctl_reg_table = register_net_sysctl(&init_net,"net/rds", rds_sysctl_rds_table);
if (!rds_sysctl_reg_table)
return -ENOMEM;
return 0;

8
net/rose/sysctl_net_rose.c
View File

@ -118,15 +118,9 @@ static ctl_table rose_table[] = {
{ }
};
static struct ctl_path rose_path[] = {
{ .procname = "net", },
{ .procname = "rose", },
{ }
};
void __init rose_register_sysctl(void)
{
rose_table_header = register_net_sysctl_table(&init_net, rose_path, rose_table);
rose_table_header = register_net_sysctl(&init_net, "net/rose", rose_table);
}
void rose_unregister_sysctl(void)

8
net/sctp/sysctl.c
View File

@ -275,18 +275,12 @@ static ctl_table sctp_table[] = {
{ /* sentinel */ }
};
static struct ctl_path sctp_path[] = {
{ .procname = "net", },
{ .procname = "sctp", },
{ }
};
static struct ctl_table_header * sctp_sysctl_header;
/* Sysctl registration. */
void sctp_sysctl_register(void)
{
sctp_sysctl_header = register_net_sysctl_table(&init_net, sctp_path, sctp_table);
sctp_sysctl_header = register_net_sysctl(&init_net, "net/sctp", sctp_table);
}
/* Sysctl deregistration. */

8
net/unix/sysctl_net_unix.c
View File

@ -26,12 +26,6 @@ static ctl_table unix_table[] = {
{ }
};
static struct ctl_path unix_path[] = {
{ .procname = "net", },
{ .procname = "unix", },
{ },
};
int __net_init unix_sysctl_register(struct net *net)
{
struct ctl_table *table;
@ -41,7 +35,7 @@ int __net_init unix_sysctl_register(struct net *net)
goto err_alloc;
table[0].data = &net->unx.sysctl_max_dgram_qlen;
net->unx.ctl = register_net_sysctl_table(net, unix_path, table);
net->unx.ctl = register_net_sysctl(net, "net/unix", table);
if (net->unx.ctl == NULL)
goto err_reg;

8
net/x25/sysctl_net_x25.c
View File

@ -73,15 +73,9 @@ static struct ctl_table x25_table[] = {
{ 0, },
};
static struct ctl_path x25_path[] = {
{ .procname = "net", },
{ .procname = "x25", },
{ }
};
void __init x25_register_sysctl(void)
{
x25_table_header = register_net_sysctl_table(&init_net, x25_path, x25_table);
x25_table_header = register_net_sysctl(&init_net, "net/x25", x25_table);
}
void x25_unregister_sysctl(void)

2
net/xfrm/xfrm_sysctl.c
View File

@ -54,7 +54,7 @@ int __net_init xfrm_sysctl_init(struct net *net)
table[2].data = &net->xfrm.sysctl_larval_drop;
table[3].data = &net->xfrm.sysctl_acq_expires;
net->xfrm.sysctl_hdr = register_net_sysctl_table(net, net_core_path, table);
net->xfrm.sysctl_hdr = register_net_sysctl(net, "net/core", table);
if (!net->xfrm.sysctl_hdr)
goto out_register;
return 0;