net: Convert uses of typedef ctl_table to struct ctl_table

tjh.dev / kernel

fork atom

Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git

kernel os linux

fork atom

net: Convert uses of typedef ctl_table to struct ctl_table

Reduce the uses of this unnecessary typedef.

Done via perl script:

$ git grep --name-only -w ctl_table net | \
xargs perl -p -i -e '\
sub trim { my ($local) = @_; $local =~ s/(^\s+|\s+$)//g; return $local; } \
s/\b(?<!struct\s)ctl_table\b(\s*\*\s*|\s+\w+)/"struct ctl_table " . trim($1)/ge'

Reflow the modified lines that now exceed 80 columns.

Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

authored by

Joe Perches and committed by

David S. Miller 12 years ago fe2c6338 194f4a6d

+86 -85

32 changed files

expand all collapse all

net

ax25

sysctl_net_ax25.c

bridge

br_netfilter.c

core

neighbour.c

sysctl_net_core.c

decnet

dn_dev.c

sysctl_net_decnet.c

ipv4

devinet.c

netfilter

nf_conntrack_l3proto_ipv4.c

route.c

sysctl_net_ipv4.c

ipv6

addrconf.c

icmp.c

route.c

sysctl_net_ipv6.c

irda

irsysctl.c

netfilter

ipvs

ip_vs_ctl.c

ip_vs_lblc.c

ip_vs_lblcr.c

nf_conntrack_standalone.c

nf_log.c

netrom

sysctl_net_netrom.c

phonet

sysctl.c

rds

ib_sysctl.c

iw_sysctl.c

sysctl.c

rose

sysctl_net_rose.c

sctp

sysctl.c

sunrpc

sysctl.c

xprtrdma

svc_rdma.c

transport.c

xprtsock.c

unix

sysctl_net_unix.c

+1 -1

net/ax25/sysctl_net_ax25.c

reviewed

··· 29 29 static int min_ds_timeout[1], max_ds_timeout[] = {65535000}; 30 30 #endif 31 31 32 32 - static const ctl_table ax25_param_table[] = { 32 32 + static const struct ctl_table ax25_param_table[] = { 33 33 { 34 34 .procname = "ip_default_mode", 35 35 .maxlen = sizeof(int),

+2 -2

net/bridge/br_netfilter.c

reviewed

··· 992 992 993 993 #ifdef CONFIG_SYSCTL 994 994 static 995 995 - int brnf_sysctl_call_tables(ctl_table * ctl, int write, 995 995 + int brnf_sysctl_call_tables(struct ctl_table *ctl, int write, 996 996 void __user * buffer, size_t * lenp, loff_t * ppos) 997 997 { 998 998 int ret; ··· 1004 1004 return ret; 1005 1005 } 1006 1006 1007 1007 - static ctl_table brnf_table[] = { 1007 1007 + static struct ctl_table brnf_table[] = { 1008 1008 { 1009 1009 .procname = "bridge-nf-call-arptables", 1010 1010 .data = &brnf_call_arptables,

+3 -3

net/core/neighbour.c

reviewed

··· 2765 2765 static int zero; 2766 2766 static int unres_qlen_max = INT_MAX / SKB_TRUESIZE(ETH_FRAME_LEN); 2767 2767 2768 2768 - static int proc_unres_qlen(ctl_table *ctl, int write, void __user *buffer, 2769 2769 - size_t *lenp, loff_t *ppos) 2768 2768 + static int proc_unres_qlen(struct ctl_table *ctl, int write, 2769 2769 + void __user *buffer, size_t *lenp, loff_t *ppos) 2770 2770 { 2771 2771 int size, ret; 2772 2772 - ctl_table tmp = *ctl; 2772 2772 + struct ctl_table tmp = *ctl; 2773 2773 2774 2774 tmp.extra1 = &zero; 2775 2775 tmp.extra2 = &unres_qlen_max;

+4 -4

net/core/sysctl_net_core.c

reviewed

··· 24 24 static int one = 1; 25 25 26 26 #ifdef CONFIG_RPS 27 27 - static int rps_sock_flow_sysctl(ctl_table *table, int write, 27 27 + static int rps_sock_flow_sysctl(struct ctl_table *table, int write, 28 28 void __user *buffer, size_t *lenp, loff_t *ppos) 29 29 { 30 30 unsigned int orig_size, size; 31 31 int ret, i; 32 32 - ctl_table tmp = { 32 32 + struct ctl_table tmp = { 33 33 .data = &size, 34 34 .maxlen = sizeof(size), 35 35 .mode = table->mode ··· 91 91 #ifdef CONFIG_NET_FLOW_LIMIT 92 92 static DEFINE_MUTEX(flow_limit_update_mutex); 93 93 94 94 - static int flow_limit_cpu_sysctl(ctl_table *table, int write, 94 94 + static int flow_limit_cpu_sysctl(struct ctl_table *table, int write, 95 95 void __user *buffer, size_t *lenp, 96 96 loff_t *ppos) 97 97 { ··· 156 156 return ret; 157 157 } 158 158 159 159 - static int flow_limit_table_len_sysctl(ctl_table *table, int write, 159 159 + static int flow_limit_table_len_sysctl(struct ctl_table *table, int write, 160 160 void __user *buffer, size_t *lenp, 161 161 loff_t *ppos) 162 162 {

+3 -3

net/decnet/dn_dev.c

reviewed

··· 158 158 static int min_priority[1]; 159 159 static int max_priority[] = { 127 }; /* From DECnet spec */ 160 160 161 161 - static int dn_forwarding_proc(ctl_table *, int, 161 161 + static int dn_forwarding_proc(struct ctl_table *, int, 162 162 void __user *, size_t *, loff_t *); 163 163 static struct dn_dev_sysctl_table { 164 164 struct ctl_table_header *sysctl_header; 165 165 - ctl_table dn_dev_vars[5]; 165 165 + struct ctl_table dn_dev_vars[5]; 166 166 } dn_dev_sysctl = { 167 167 NULL, 168 168 { ··· 242 242 } 243 243 } 244 244 245 245 - static int dn_forwarding_proc(ctl_table *table, int write, 245 245 + static int dn_forwarding_proc(struct ctl_table *table, int write, 246 246 void __user *buffer, 247 247 size_t *lenp, loff_t *ppos) 248 248 {

+3 -3

net/decnet/sysctl_net_decnet.c

reviewed

··· 132 132 return 0; 133 133 } 134 134 135 135 - static int dn_node_address_handler(ctl_table *table, int write, 135 135 + static int dn_node_address_handler(struct ctl_table *table, int write, 136 136 void __user *buffer, 137 137 size_t *lenp, loff_t *ppos) 138 138 { ··· 183 183 return 0; 184 184 } 185 185 186 186 - static int dn_def_dev_handler(ctl_table *table, int write, 186 186 + static int dn_def_dev_handler(struct ctl_table *table, int write, 187 187 void __user *buffer, 188 188 size_t *lenp, loff_t *ppos) 189 189 { ··· 246 246 return 0; 247 247 } 248 248 249 249 - static ctl_table dn_table[] = { 249 249 + static struct ctl_table dn_table[] = { 250 250 { 251 251 .procname = "node_address", 252 252 .maxlen = 7,

+3 -3

net/ipv4/devinet.c

reviewed

··· 1942 1942 } 1943 1943 } 1944 1944 1945 1945 - static int devinet_conf_proc(ctl_table *ctl, int write, 1945 1945 + static int devinet_conf_proc(struct ctl_table *ctl, int write, 1946 1946 void __user *buffer, 1947 1947 size_t *lenp, loff_t *ppos) 1948 1948 { ··· 1985 1985 return ret; 1986 1986 } 1987 1987 1988 1988 - static int devinet_sysctl_forward(ctl_table *ctl, int write, 1988 1988 + static int devinet_sysctl_forward(struct ctl_table *ctl, int write, 1989 1989 void __user *buffer, 1990 1990 size_t *lenp, loff_t *ppos) 1991 1991 { ··· 2028 2028 return ret; 2029 2029 } 2030 2030 2031 2031 - static int ipv4_doint_and_flush(ctl_table *ctl, int write, 2031 2031 + static int ipv4_doint_and_flush(struct ctl_table *ctl, int write, 2032 2032 void __user *buffer, 2033 2033 size_t *lenp, loff_t *ppos) 2034 2034 {

+1 -1

net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c

reviewed

··· 223 223 static int log_invalid_proto_min = 0; 224 224 static int log_invalid_proto_max = 255; 225 225 226 226 - static ctl_table ip_ct_sysctl_table[] = { 226 226 + static struct ctl_table ip_ct_sysctl_table[] = { 227 227 { 228 228 .procname = "ip_conntrack_max", 229 229 .maxlen = sizeof(int),

+2 -2

net/ipv4/route.c

reviewed

··· 2448 2448 static int ip_rt_gc_min_interval __read_mostly = HZ / 2; 2449 2449 static int ip_rt_gc_elasticity __read_mostly = 8; 2450 2450 2451 2451 - static int ipv4_sysctl_rtcache_flush(ctl_table *__ctl, int write, 2451 2451 + static int ipv4_sysctl_rtcache_flush(struct ctl_table *__ctl, int write, 2452 2452 void __user *buffer, 2453 2453 size_t *lenp, loff_t *ppos) 2454 2454 { ··· 2463 2463 return -EINVAL; 2464 2464 } 2465 2465 2466 2466 - static ctl_table ipv4_route_table[] = { 2466 2466 + static struct ctl_table ipv4_route_table[] = { 2467 2467 { 2468 2468 .procname = "gc_thresh", 2469 2469 .data = &ipv4_dst_ops.gc_thresh,

+16 -15

net/ipv4/sysctl_net_ipv4.c

reviewed

··· 49 49 } 50 50 51 51 /* Validate changes from /proc interface. */ 52 52 - static int ipv4_local_port_range(ctl_table *table, int write, 52 52 + static int ipv4_local_port_range(struct ctl_table *table, int write, 53 53 void __user *buffer, 54 54 size_t *lenp, loff_t *ppos) 55 55 { 56 56 int ret; 57 57 int range[2]; 58 58 - ctl_table tmp = { 58 58 + struct ctl_table tmp = { 59 59 .data = &range, 60 60 .maxlen = sizeof(range), 61 61 .mode = table->mode, ··· 100 100 } 101 101 102 102 /* Validate changes from /proc interface. */ 103 103 - static int ipv4_ping_group_range(ctl_table *table, int write, 103 103 + static int ipv4_ping_group_range(struct ctl_table *table, int write, 104 104 void __user *buffer, 105 105 size_t *lenp, loff_t *ppos) 106 106 { ··· 108 108 int ret; 109 109 gid_t urange[2]; 110 110 kgid_t low, high; 111 111 - ctl_table tmp = { 111 111 + struct ctl_table tmp = { 112 112 .data = &urange, 113 113 .maxlen = sizeof(urange), 114 114 .mode = table->mode, ··· 135 135 return ret; 136 136 } 137 137 138 138 - static int proc_tcp_congestion_control(ctl_table *ctl, int write, 138 138 + static int proc_tcp_congestion_control(struct ctl_table *ctl, int write, 139 139 void __user *buffer, size_t *lenp, loff_t *ppos) 140 140 { 141 141 char val[TCP_CA_NAME_MAX]; 142 142 - ctl_table tbl = { 142 142 + struct ctl_table tbl = { 143 143 .data = val, 144 144 .maxlen = TCP_CA_NAME_MAX, 145 145 }; ··· 153 153 return ret; 154 154 } 155 155 156 156 - static int proc_tcp_available_congestion_control(ctl_table *ctl, 156 156 + static int proc_tcp_available_congestion_control(struct ctl_table *ctl, 157 157 int write, 158 158 void __user *buffer, size_t *lenp, 159 159 loff_t *ppos) 160 160 { 161 161 - ctl_table tbl = { .maxlen = TCP_CA_BUF_MAX, }; 161 161 + struct ctl_table tbl = { .maxlen = TCP_CA_BUF_MAX, }; 162 162 int ret; 163 163 164 164 tbl.data = kmalloc(tbl.maxlen, GFP_USER); ··· 170 170 return ret; 171 171 } 172 172 173 173 - static int proc_allowed_congestion_control(ctl_table *ctl, 173 173 + static int proc_allowed_congestion_control(struct ctl_table *ctl, 174 174 int write, 175 175 void __user *buffer, size_t *lenp, 176 176 loff_t *ppos) 177 177 { 178 178 - ctl_table tbl = { .maxlen = TCP_CA_BUF_MAX }; 178 178 + struct ctl_table tbl = { .maxlen = TCP_CA_BUF_MAX }; 179 179 int ret; 180 180 181 181 tbl.data = kmalloc(tbl.maxlen, GFP_USER); ··· 190 190 return ret; 191 191 } 192 192 193 193 - static int ipv4_tcp_mem(ctl_table *ctl, int write, 193 193 + static int ipv4_tcp_mem(struct ctl_table *ctl, int write, 194 194 void __user *buffer, size_t *lenp, 195 195 loff_t *ppos) 196 196 { ··· 201 201 struct mem_cgroup *memcg; 202 202 #endif 203 203 204 204 - ctl_table tmp = { 204 204 + struct ctl_table tmp = { 205 205 .data = &vec, 206 206 .maxlen = sizeof(vec), 207 207 .mode = ctl->mode, ··· 233 233 return 0; 234 234 } 235 235 236 236 - static int proc_tcp_fastopen_key(ctl_table *ctl, int write, void __user *buffer, 237 237 - size_t *lenp, loff_t *ppos) 236 236 + static int proc_tcp_fastopen_key(struct ctl_table *ctl, int write, 237 237 + void __user *buffer, size_t *lenp, 238 238 + loff_t *ppos) 238 239 { 239 239 - ctl_table tbl = { .maxlen = (TCP_FASTOPEN_KEY_LENGTH * 2 + 10) }; 240 240 + struct ctl_table tbl = { .maxlen = (TCP_FASTOPEN_KEY_LENGTH * 2 + 10) }; 240 241 struct tcp_fastopen_context *ctxt; 241 242 int ret; 242 243 u32 user_key[4]; /* 16 bytes, matching TCP_FASTOPEN_KEY_LENGTH */

+5 -5

net/ipv6/addrconf.c

reviewed

··· 4620 4620 #ifdef CONFIG_SYSCTL 4621 4621 4622 4622 static 4623 4623 - int addrconf_sysctl_forward(ctl_table *ctl, int write, 4623 4623 + int addrconf_sysctl_forward(struct ctl_table *ctl, int write, 4624 4624 void __user *buffer, size_t *lenp, loff_t *ppos) 4625 4625 { 4626 4626 int *valp = ctl->data; 4627 4627 int val = *valp; 4628 4628 loff_t pos = *ppos; 4629 4629 - ctl_table lctl; 4629 4629 + struct ctl_table lctl; 4630 4630 int ret; 4631 4631 4632 4632 /* ··· 4705 4705 } 4706 4706 4707 4707 static 4708 4708 - int addrconf_sysctl_disable(ctl_table *ctl, int write, 4708 4708 + int addrconf_sysctl_disable(struct ctl_table *ctl, int write, 4709 4709 void __user *buffer, size_t *lenp, loff_t *ppos) 4710 4710 { 4711 4711 int *valp = ctl->data; 4712 4712 int val = *valp; 4713 4713 loff_t pos = *ppos; 4714 4714 - ctl_table lctl; 4714 4714 + struct ctl_table lctl; 4715 4715 int ret; 4716 4716 4717 4717 /* ··· 4733 4733 static struct addrconf_sysctl_table 4734 4734 { 4735 4735 struct ctl_table_header *sysctl_header; 4736 4736 - ctl_table addrconf_vars[DEVCONF_MAX+1]; 4736 4736 + struct ctl_table addrconf_vars[DEVCONF_MAX+1]; 4737 4737 } addrconf_sysctl __read_mostly = { 4738 4738 .sysctl_header = NULL, 4739 4739 .addrconf_vars = {

+1 -1

net/ipv6/icmp.c

reviewed

··· 976 976 EXPORT_SYMBOL(icmpv6_err_convert); 977 977 978 978 #ifdef CONFIG_SYSCTL 979 979 - ctl_table ipv6_icmp_table_template[] = { 979 979 + struct ctl_table ipv6_icmp_table_template[] = { 980 980 { 981 981 .procname = "ratelimit", 982 982 .data = &init_net.ipv6.sysctl.icmpv6_time,

+2 -2

net/ipv6/route.c

reviewed

··· 2790 2790 #ifdef CONFIG_SYSCTL 2791 2791 2792 2792 static 2793 2793 - int ipv6_sysctl_rtcache_flush(ctl_table *ctl, int write, 2793 2793 + int ipv6_sysctl_rtcache_flush(struct ctl_table *ctl, int write, 2794 2794 void __user *buffer, size_t *lenp, loff_t *ppos) 2795 2795 { 2796 2796 struct net *net; ··· 2805 2805 return 0; 2806 2806 } 2807 2807 2808 2808 - ctl_table ipv6_route_table_template[] = { 2808 2808 + struct ctl_table ipv6_route_table_template[] = { 2809 2809 { 2810 2810 .procname = "flush", 2811 2811 .data = &init_net.ipv6.sysctl.flush_delay,

+2 -2

net/ipv6/sysctl_net_ipv6.c

reviewed

··· 16 16 #include <net/addrconf.h> 17 17 #include <net/inet_frag.h> 18 18 19 19 - static ctl_table ipv6_table_template[] = { 19 19 + static struct ctl_table ipv6_table_template[] = { 20 20 { 21 21 .procname = "bindv6only", 22 22 .data = &init_net.ipv6.sysctl.bindv6only, ··· 27 27 { } 28 28 }; 29 29 30 30 - static ctl_table ipv6_rotable[] = { 30 30 + static struct ctl_table ipv6_rotable[] = { 31 31 { 32 32 .procname = "mld_max_msf", 33 33 .data = &sysctl_mld_max_msf,

+3 -3

net/irda/irsysctl.c

reviewed

··· 73 73 /* For other sysctl, I've no idea of the range. Maybe Dag could help 74 74 * us on that - Jean II */ 75 75 76 76 - static int do_devname(ctl_table *table, int write, 76 76 + static int do_devname(struct ctl_table *table, int write, 77 77 void __user *buffer, size_t *lenp, loff_t *ppos) 78 78 { 79 79 int ret; ··· 90 90 } 91 91 92 92 93 93 - static int do_discovery(ctl_table *table, int write, 93 93 + static int do_discovery(struct ctl_table *table, int write, 94 94 void __user *buffer, size_t *lenp, loff_t *ppos) 95 95 { 96 96 int ret; ··· 111 111 } 112 112 113 113 /* One file */ 114 114 - static ctl_table irda_table[] = { 114 114 + static struct ctl_table irda_table[] = { 115 115 { 116 116 .procname = "discovery", 117 117 .data = &sysctl_discovery,

+4 -4

net/netfilter/ipvs/ip_vs_ctl.c

reviewed

··· 1575 1575 static int three = 3; 1576 1576 1577 1577 static int 1578 1578 - proc_do_defense_mode(ctl_table *table, int write, 1578 1578 + proc_do_defense_mode(struct ctl_table *table, int write, 1579 1579 void __user *buffer, size_t *lenp, loff_t *ppos) 1580 1580 { 1581 1581 struct net *net = current->nsproxy->net_ns; ··· 1596 1596 } 1597 1597 1598 1598 static int 1599 1599 - proc_do_sync_threshold(ctl_table *table, int write, 1599 1599 + proc_do_sync_threshold(struct ctl_table *table, int write, 1600 1600 void __user *buffer, size_t *lenp, loff_t *ppos) 1601 1601 { 1602 1602 int *valp = table->data; ··· 1616 1616 } 1617 1617 1618 1618 static int 1619 1619 - proc_do_sync_mode(ctl_table *table, int write, 1619 1619 + proc_do_sync_mode(struct ctl_table *table, int write, 1620 1620 void __user *buffer, size_t *lenp, loff_t *ppos) 1621 1621 { 1622 1622 int *valp = table->data; ··· 1634 1634 } 1635 1635 1636 1636 static int 1637 1637 - proc_do_sync_ports(ctl_table *table, int write, 1637 1637 + proc_do_sync_ports(struct ctl_table *table, int write, 1638 1638 void __user *buffer, size_t *lenp, loff_t *ppos) 1639 1639 { 1640 1640 int *valp = table->data;

+1 -1

net/netfilter/ipvs/ip_vs_lblc.c

reviewed

··· 118 118 * IPVS LBLC sysctl table 119 119 */ 120 120 #ifdef CONFIG_SYSCTL 121 121 - static ctl_table vs_vars_table[] = { 121 121 + static struct ctl_table vs_vars_table[] = { 122 122 { 123 123 .procname = "lblc_expiration", 124 124 .data = NULL,

+1 -1

net/netfilter/ipvs/ip_vs_lblcr.c

reviewed

··· 299 299 * IPVS LBLCR sysctl table 300 300 */ 301 301 302 302 - static ctl_table vs_vars_table[] = { 302 302 + static struct ctl_table vs_vars_table[] = { 303 303 { 304 304 .procname = "lblcr_expiration", 305 305 .data = NULL,

+2 -2

net/netfilter/nf_conntrack_standalone.c

reviewed

··· 408 408 409 409 static struct ctl_table_header *nf_ct_netfilter_header; 410 410 411 411 - static ctl_table nf_ct_sysctl_table[] = { 411 411 + static struct ctl_table nf_ct_sysctl_table[] = { 412 412 { 413 413 .procname = "nf_conntrack_max", 414 414 .data = &nf_conntrack_max, ··· 458 458 459 459 #define NET_NF_CONNTRACK_MAX 2089 460 460 461 461 - static ctl_table nf_ct_netfilter_table[] = { 461 461 + static struct ctl_table nf_ct_netfilter_table[] = { 462 462 { 463 463 .procname = "nf_conntrack_max", 464 464 .data = &nf_conntrack_max,

+1 -1

net/netfilter/nf_log.c

reviewed

··· 245 245 static char nf_log_sysctl_fnames[NFPROTO_NUMPROTO-NFPROTO_UNSPEC][3]; 246 246 static struct ctl_table nf_log_sysctl_table[NFPROTO_NUMPROTO+1]; 247 247 248 248 - static int nf_log_proc_dostring(ctl_table *table, int write, 248 248 + static int nf_log_proc_dostring(struct ctl_table *table, int write, 249 249 void __user *buffer, size_t *lenp, loff_t *ppos) 250 250 { 251 251 const struct nf_logger *logger;

+1 -1

net/netrom/sysctl_net_netrom.c

reviewed

··· 34 34 35 35 static struct ctl_table_header *nr_table_header; 36 36 37 37 - static ctl_table nr_table[] = { 37 37 + static struct ctl_table nr_table[] = { 38 38 { 39 39 .procname = "default_path_quality", 40 40 .data = &sysctl_netrom_default_path_quality,

+2 -2

net/phonet/sysctl.c

reviewed

··· 61 61 } while (read_seqretry(&local_port_range_lock, seq)); 62 62 } 63 63 64 64 - static int proc_local_port_range(ctl_table *table, int write, 64 64 + static int proc_local_port_range(struct ctl_table *table, int write, 65 65 void __user *buffer, 66 66 size_t *lenp, loff_t *ppos) 67 67 { 68 68 int ret; 69 69 int range[2] = {local_port_range[0], local_port_range[1]}; 70 70 - ctl_table tmp = { 70 70 + struct ctl_table tmp = { 71 71 .data = &range, 72 72 .maxlen = sizeof(range), 73 73 .mode = table->mode,

+1 -1

net/rds/ib_sysctl.c

reviewed

··· 61 61 */ 62 62 unsigned int rds_ib_sysctl_flow_control = 0; 63 63 64 64 - static ctl_table rds_ib_sysctl_table[] = { 64 64 + static struct ctl_table rds_ib_sysctl_table[] = { 65 65 { 66 66 .procname = "max_send_wr", 67 67 .data = &rds_ib_sysctl_max_send_wr,

+1 -1

net/rds/iw_sysctl.c

reviewed

··· 55 55 56 56 unsigned int rds_iw_sysctl_flow_control = 1; 57 57 58 58 - static ctl_table rds_iw_sysctl_table[] = { 58 58 + static struct ctl_table rds_iw_sysctl_table[] = { 59 59 { 60 60 .procname = "max_send_wr", 61 61 .data = &rds_iw_sysctl_max_send_wr,

+1 -1

net/rds/sysctl.c

reviewed

··· 49 49 50 50 unsigned int rds_sysctl_ping_enable = 1; 51 51 52 52 - static ctl_table rds_sysctl_rds_table[] = { 52 52 + static struct ctl_table rds_sysctl_rds_table[] = { 53 53 { 54 54 .procname = "reconnect_min_delay_ms", 55 55 .data = &rds_sysctl_reconnect_min_jiffies,

+1 -1

net/rose/sysctl_net_rose.c

reviewed

··· 24 24 25 25 static struct ctl_table_header *rose_table_header; 26 26 27 27 - static ctl_table rose_table[] = { 27 27 + static struct ctl_table rose_table[] = { 28 28 { 29 29 .procname = "restart_request_timeout", 30 30 .data = &sysctl_rose_restart_request_timeout,

+5 -5

net/sctp/sysctl.c

reviewed

··· 62 62 extern int sysctl_sctp_rmem[3]; 63 63 extern int sysctl_sctp_wmem[3]; 64 64 65 65 - static int proc_sctp_do_hmac_alg(ctl_table *ctl, 65 65 + static int proc_sctp_do_hmac_alg(struct ctl_table *ctl, 66 66 int write, 67 67 void __user *buffer, size_t *lenp, 68 68 69 69 loff_t *ppos); 70 70 - static ctl_table sctp_table[] = { 70 70 + static struct ctl_table sctp_table[] = { 71 71 { 72 72 .procname = "sctp_mem", 73 73 .data = &sysctl_sctp_mem, ··· 93 93 { /* sentinel */ } 94 94 }; 95 95 96 96 - static ctl_table sctp_net_table[] = { 96 96 + static struct ctl_table sctp_net_table[] = { 97 97 { 98 98 .procname = "rto_initial", 99 99 .data = &init_net.sctp.rto_initial, ··· 300 300 { /* sentinel */ } 301 301 }; 302 302 303 303 - static int proc_sctp_do_hmac_alg(ctl_table *ctl, 303 303 + static int proc_sctp_do_hmac_alg(struct ctl_table *ctl, 304 304 int write, 305 305 void __user *buffer, size_t *lenp, 306 306 loff_t *ppos) 307 307 { 308 308 struct net *net = current->nsproxy->net_ns; 309 309 char tmp[8]; 310 310 - ctl_table tbl; 310 310 + struct ctl_table tbl; 311 311 int ret; 312 312 int changed = 0; 313 313 char *none = "none";

+5 -5

net/sunrpc/sysctl.c

reviewed

··· 40 40 #ifdef RPC_DEBUG 41 41 42 42 static struct ctl_table_header *sunrpc_table_header; 43 43 - static ctl_table sunrpc_table[]; 43 43 + static struct ctl_table sunrpc_table[]; 44 44 45 45 void 46 46 rpc_register_sysctl(void) ··· 58 58 } 59 59 } 60 60 61 61 - static int proc_do_xprt(ctl_table *table, int write, 61 61 + static int proc_do_xprt(struct ctl_table *table, int write, 62 62 void __user *buffer, size_t *lenp, loff_t *ppos) 63 63 { 64 64 char tmpbuf[256]; ··· 73 73 } 74 74 75 75 static int 76 76 - proc_dodebug(ctl_table *table, int write, 76 76 + proc_dodebug(struct ctl_table *table, int write, 77 77 void __user *buffer, size_t *lenp, loff_t *ppos) 78 78 { 79 79 char tmpbuf[20], c, *s; ··· 135 135 } 136 136 137 137 138 138 - static ctl_table debug_table[] = { 138 138 + static struct ctl_table debug_table[] = { 139 139 { 140 140 .procname = "rpc_debug", 141 141 .data = &rpc_debug, ··· 173 173 { } 174 174 }; 175 175 176 176 - static ctl_table sunrpc_table[] = { 176 176 + static struct ctl_table sunrpc_table[] = { 177 177 { 178 178 .procname = "sunrpc", 179 179 .mode = 0555,

+4 -4

net/sunrpc/xprtrdma/svc_rdma.c

reviewed

··· 84 84 * resets the associated statistic to zero. Any read returns it's 85 85 * current value. 86 86 */ 87 87 - static int read_reset_stat(ctl_table *table, int write, 87 87 + static int read_reset_stat(struct ctl_table *table, int write, 88 88 void __user *buffer, size_t *lenp, 89 89 loff_t *ppos) 90 90 { ··· 119 119 } 120 120 121 121 static struct ctl_table_header *svcrdma_table_header; 122 122 - static ctl_table svcrdma_parm_table[] = { 122 122 + static struct ctl_table svcrdma_parm_table[] = { 123 123 { 124 124 .procname = "max_requests", 125 125 .data = &svcrdma_max_requests, ··· 214 214 { }, 215 215 }; 216 216 217 217 - static ctl_table svcrdma_table[] = { 217 217 + static struct ctl_table svcrdma_table[] = { 218 218 { 219 219 .procname = "svc_rdma", 220 220 .mode = 0555, ··· 223 223 { }, 224 224 }; 225 225 226 226 - static ctl_table svcrdma_root_table[] = { 226 226 + static struct ctl_table svcrdma_root_table[] = { 227 227 { 228 228 .procname = "sunrpc", 229 229 .mode = 0555,

+2 -2

net/sunrpc/xprtrdma/transport.c

reviewed

··· 86 86 87 87 static struct ctl_table_header *sunrpc_table_header; 88 88 89 89 - static ctl_table xr_tunables_table[] = { 89 89 + static struct ctl_table xr_tunables_table[] = { 90 90 { 91 91 .procname = "rdma_slot_table_entries", 92 92 .data = &xprt_rdma_slot_table_entries, ··· 138 138 { }, 139 139 }; 140 140 141 141 - static ctl_table sunrpc_table[] = { 141 141 + static struct ctl_table sunrpc_table[] = { 142 142 { 143 143 .procname = "sunrpc", 144 144 .mode = 0555,

+2 -2

net/sunrpc/xprtsock.c

reviewed

··· 87 87 * FIXME: changing the UDP slot table size should also resize the UDP 88 88 * socket buffers for existing UDP transports 89 89 */ 90 90 - static ctl_table xs_tunables_table[] = { 90 90 + static struct ctl_table xs_tunables_table[] = { 91 91 { 92 92 .procname = "udp_slot_table_entries", 93 93 .data = &xprt_udp_slot_table_entries, ··· 143 143 { }, 144 144 }; 145 145 146 146 - static ctl_table sunrpc_table[] = { 146 146 + static struct ctl_table sunrpc_table[] = { 147 147 { 148 148 .procname = "sunrpc", 149 149 .mode = 0555,

+1 -1

net/unix/sysctl_net_unix.c

reviewed

··· 15 15 16 16 #include <net/af_unix.h> 17 17 18 18 - static ctl_table unix_table[] = { 18 18 + static struct ctl_table unix_table[] = { 19 19 { 20 20 .procname = "max_dgram_qlen", 21 21 .data = &init_net.unx.sysctl_max_dgram_qlen,