summaryrefslogtreecommitdiffstats
path: root/net
diff options
context:
space:
mode:
authorChristoph Hellwig <hch@lst.de>2018-04-10 13:42:55 -0400
committerChristoph Hellwig <hch@lst.de>2018-05-16 01:24:30 -0400
commitc3506372277779fccbffee2475400fcd689d5738 (patch)
treed45d820f96a84a1223fa84c6ad4b7d84a81399aa /net
parenta2dcdee3748b664bf011b4b12de64e945dd4c8c2 (diff)
proc: introduce proc_create_net{,_data}
Variants of proc_create{,_data} that directly take a struct seq_operations and deal with network namespaces in ->open and ->release. All callers of proc_create + seq_open_net converted over, and seq_{open,release}_net are removed entirely. Signed-off-by: Christoph Hellwig <hch@lst.de>
Diffstat (limited to 'net')
-rw-r--r--net/8021q/vlanproc.c18
-rw-r--r--net/atm/clip.c17
-rw-r--r--net/core/net-procfs.c49
-rw-r--r--net/core/sock.c16
-rw-r--r--net/decnet/dn_neigh.c18
-rw-r--r--net/ipv4/arp.c17
-rw-r--r--net/ipv4/fib_trie.c32
-rw-r--r--net/ipv4/igmp.c33
-rw-r--r--net/ipv4/ipmr.c32
-rw-r--r--net/ipv4/ping.c16
-rw-r--r--net/ipv4/raw.c17
-rw-r--r--net/ipv4/tcp_ipv4.c17
-rw-r--r--net/ipv4/udp.c21
-rw-r--r--net/ipv4/udplite.c4
-rw-r--r--net/ipv6/addrconf.c16
-rw-r--r--net/ipv6/anycast.c16
-rw-r--r--net/ipv6/ip6_fib.c18
-rw-r--r--net/ipv6/ip6_flowlabel.c17
-rw-r--r--net/ipv6/ip6mr.c32
-rw-r--r--net/ipv6/mcast.c34
-rw-r--r--net/ipv6/ping.c16
-rw-r--r--net/ipv6/raw.c17
-rw-r--r--net/ipv6/route.c11
-rw-r--r--net/ipv6/tcp_ipv6.c17
-rw-r--r--net/ipv6/udp.c21
-rw-r--r--net/ipv6/udplite.c5
-rw-r--r--net/kcm/kcmproc.c16
-rw-r--r--net/key/af_key.c16
-rw-r--r--net/l2tp/l2tp_ppp.c22
-rw-r--r--net/netfilter/ipvs/ip_vs_app.c16
-rw-r--r--net/netfilter/ipvs/ip_vs_conn.c35
-rw-r--r--net/netfilter/ipvs/ip_vs_ctl.c16
-rw-r--r--net/netfilter/nf_conntrack_expect.c17
-rw-r--r--net/netfilter/nf_conntrack_standalone.c33
-rw-r--r--net/netfilter/nf_log.c19
-rw-r--r--net/netfilter/nf_synproxy_core.c17
-rw-r--r--net/netfilter/nfnetlink_log.c18
-rw-r--r--net/netfilter/nfnetlink_queue.c18
-rw-r--r--net/netfilter/x_tables.c18
-rw-r--r--net/netlink/af_netlink.c18
-rw-r--r--net/packet/af_packet.c17
-rw-r--r--net/phonet/pn_dev.c6
-rw-r--r--net/phonet/socket.c30
-rw-r--r--net/rxrpc/ar-internal.h4
-rw-r--r--net/rxrpc/net_ns.c7
-rw-r--r--net/rxrpc/proc.c31
-rw-r--r--net/sctp/proc.c54
-rw-r--r--net/unix/af_unix.c17
-rw-r--r--net/wireless/wext-proc.c17
49 files changed, 134 insertions, 855 deletions
diff --git a/net/8021q/vlanproc.c b/net/8021q/vlanproc.c
index d3e3f0f2ec1c..d36e8c4b7f56 100644
--- a/net/8021q/vlanproc.c
+++ b/net/8021q/vlanproc.c
@@ -73,19 +73,6 @@ static const struct seq_operations vlan_seq_ops = {
73 .show = vlan_seq_show, 73 .show = vlan_seq_show,
74}; 74};
75 75
76static int vlan_seq_open(struct inode *inode, struct file *file)
77{
78 return seq_open_net(inode, file, &vlan_seq_ops,
79 sizeof(struct seq_net_private));
80}
81
82static const struct file_operations vlan_fops = {
83 .open = vlan_seq_open,
84 .read = seq_read,
85 .llseek = seq_lseek,
86 .release = seq_release_net,
87};
88
89/* 76/*
90 * Proc filesystem directory entries. 77 * Proc filesystem directory entries.
91 */ 78 */
@@ -132,8 +119,9 @@ int __net_init vlan_proc_init(struct net *net)
132 if (!vn->proc_vlan_dir) 119 if (!vn->proc_vlan_dir)
133 goto err; 120 goto err;
134 121
135 vn->proc_vlan_conf = proc_create(name_conf, S_IFREG | 0600, 122 vn->proc_vlan_conf = proc_create_net(name_conf, S_IFREG | 0600,
136 vn->proc_vlan_dir, &vlan_fops); 123 vn->proc_vlan_dir, &vlan_seq_ops,
124 sizeof(struct seq_net_private));
137 if (!vn->proc_vlan_conf) 125 if (!vn->proc_vlan_conf)
138 goto err; 126 goto err;
139 return 0; 127 return 0;
diff --git a/net/atm/clip.c b/net/atm/clip.c
index f07dbc632222..66caa48a27c2 100644
--- a/net/atm/clip.c
+++ b/net/atm/clip.c
@@ -863,20 +863,6 @@ static const struct seq_operations arp_seq_ops = {
863 .stop = neigh_seq_stop, 863 .stop = neigh_seq_stop,
864 .show = clip_seq_show, 864 .show = clip_seq_show,
865}; 865};
866
867static int arp_seq_open(struct inode *inode, struct file *file)
868{
869 return seq_open_net(inode, file, &arp_seq_ops,
870 sizeof(struct clip_seq_state));
871}
872
873static const struct file_operations arp_seq_fops = {
874 .open = arp_seq_open,
875 .read = seq_read,
876 .llseek = seq_lseek,
877 .release = seq_release_net,
878 .owner = THIS_MODULE
879};
880#endif 866#endif
881 867
882static void atm_clip_exit_noproc(void); 868static void atm_clip_exit_noproc(void);
@@ -893,7 +879,8 @@ static int __init atm_clip_init(void)
893 { 879 {
894 struct proc_dir_entry *p; 880 struct proc_dir_entry *p;
895 881
896 p = proc_create("arp", 0444, atm_proc_root, &arp_seq_fops); 882 p = proc_create_net("arp", 0444, atm_proc_root, &arp_seq_ops,
883 sizeof(struct clip_seq_state));
897 if (!p) { 884 if (!p) {
898 pr_err("Unable to initialize /proc/net/atm/arp\n"); 885 pr_err("Unable to initialize /proc/net/atm/arp\n");
899 atm_clip_exit_noproc(); 886 atm_clip_exit_noproc();
diff --git a/net/core/net-procfs.c b/net/core/net-procfs.c
index c4e8ebe55e26..63881f72ef71 100644
--- a/net/core/net-procfs.c
+++ b/net/core/net-procfs.c
@@ -175,19 +175,6 @@ static const struct seq_operations dev_seq_ops = {
175 .show = dev_seq_show, 175 .show = dev_seq_show,
176}; 176};
177 177
178static int dev_seq_open(struct inode *inode, struct file *file)
179{
180 return seq_open_net(inode, file, &dev_seq_ops,
181 sizeof(struct seq_net_private));
182}
183
184static const struct file_operations dev_seq_fops = {
185 .open = dev_seq_open,
186 .read = seq_read,
187 .llseek = seq_lseek,
188 .release = seq_release_net,
189};
190
191static const struct seq_operations softnet_seq_ops = { 178static const struct seq_operations softnet_seq_ops = {
192 .start = softnet_seq_start, 179 .start = softnet_seq_start,
193 .next = softnet_seq_next, 180 .next = softnet_seq_next,
@@ -285,30 +272,18 @@ static const struct seq_operations ptype_seq_ops = {
285 .show = ptype_seq_show, 272 .show = ptype_seq_show,
286}; 273};
287 274
288static int ptype_seq_open(struct inode *inode, struct file *file)
289{
290 return seq_open_net(inode, file, &ptype_seq_ops,
291 sizeof(struct seq_net_private));
292}
293
294static const struct file_operations ptype_seq_fops = {
295 .open = ptype_seq_open,
296 .read = seq_read,
297 .llseek = seq_lseek,
298 .release = seq_release_net,
299};
300
301
302static int __net_init dev_proc_net_init(struct net *net) 275static int __net_init dev_proc_net_init(struct net *net)
303{ 276{
304 int rc = -ENOMEM; 277 int rc = -ENOMEM;
305 278
306 if (!proc_create("dev", 0444, net->proc_net, &dev_seq_fops)) 279 if (!proc_create_net("dev", 0444, net->proc_net, &dev_seq_ops,
280 sizeof(struct seq_net_private)))
307 goto out; 281 goto out;
308 if (!proc_create_seq("softnet_stat", 0444, net->proc_net, 282 if (!proc_create_seq("softnet_stat", 0444, net->proc_net,
309 &softnet_seq_ops)) 283 &softnet_seq_ops))
310 goto out_dev; 284 goto out_dev;
311 if (!proc_create("ptype", 0444, net->proc_net, &ptype_seq_fops)) 285 if (!proc_create_net("ptype", 0444, net->proc_net, &ptype_seq_ops,
286 sizeof(struct seq_net_private)))
312 goto out_softnet; 287 goto out_softnet;
313 288
314 if (wext_proc_init(net)) 289 if (wext_proc_init(net))
@@ -365,22 +340,10 @@ static const struct seq_operations dev_mc_seq_ops = {
365 .show = dev_mc_seq_show, 340 .show = dev_mc_seq_show,
366}; 341};
367 342
368static int dev_mc_seq_open(struct inode *inode, struct file *file)
369{
370 return seq_open_net(inode, file, &dev_mc_seq_ops,
371 sizeof(struct seq_net_private));
372}
373
374static const struct file_operations dev_mc_seq_fops = {
375 .open = dev_mc_seq_open,
376 .read = seq_read,
377 .llseek = seq_lseek,
378 .release = seq_release_net,
379};
380
381static int __net_init dev_mc_net_init(struct net *net) 343static int __net_init dev_mc_net_init(struct net *net)
382{ 344{
383 if (!proc_create("dev_mcast", 0, net->proc_net, &dev_mc_seq_fops)) 345 if (!proc_create_net("dev_mcast", 0, net->proc_net, &dev_mc_seq_ops,
346 sizeof(struct seq_net_private)))
384 return -ENOMEM; 347 return -ENOMEM;
385 return 0; 348 return 0;
386} 349}
diff --git a/net/core/sock.c b/net/core/sock.c
index 6444525f610c..835a22f94bc5 100644
--- a/net/core/sock.c
+++ b/net/core/sock.c
@@ -3439,22 +3439,10 @@ static const struct seq_operations proto_seq_ops = {
3439 .show = proto_seq_show, 3439 .show = proto_seq_show,
3440}; 3440};
3441 3441
3442static int proto_seq_open(struct inode *inode, struct file *file)
3443{
3444 return seq_open_net(inode, file, &proto_seq_ops,
3445 sizeof(struct seq_net_private));
3446}
3447
3448static const struct file_operations proto_seq_fops = {
3449 .open = proto_seq_open,
3450 .read = seq_read,
3451 .llseek = seq_lseek,
3452 .release = seq_release_net,
3453};
3454
3455static __net_init int proto_init_net(struct net *net) 3442static __net_init int proto_init_net(struct net *net)
3456{ 3443{
3457 if (!proc_create("protocols", 0444, net->proc_net, &proto_seq_fops)) 3444 if (!proc_create_net("protocols", 0444, net->proc_net, &proto_seq_ops,
3445 sizeof(struct seq_net_private)))
3458 return -ENOMEM; 3446 return -ENOMEM;
3459 3447
3460 return 0; 3448 return 0;
diff --git a/net/decnet/dn_neigh.c b/net/decnet/dn_neigh.c
index 13156165afa3..94b306f6d551 100644
--- a/net/decnet/dn_neigh.c
+++ b/net/decnet/dn_neigh.c
@@ -589,27 +589,13 @@ static const struct seq_operations dn_neigh_seq_ops = {
589 .stop = neigh_seq_stop, 589 .stop = neigh_seq_stop,
590 .show = dn_neigh_seq_show, 590 .show = dn_neigh_seq_show,
591}; 591};
592
593static int dn_neigh_seq_open(struct inode *inode, struct file *file)
594{
595 return seq_open_net(inode, file, &dn_neigh_seq_ops,
596 sizeof(struct neigh_seq_state));
597}
598
599static const struct file_operations dn_neigh_seq_fops = {
600 .open = dn_neigh_seq_open,
601 .read = seq_read,
602 .llseek = seq_lseek,
603 .release = seq_release_net,
604};
605
606#endif 592#endif
607 593
608void __init dn_neigh_init(void) 594void __init dn_neigh_init(void)
609{ 595{
610 neigh_table_init(NEIGH_DN_TABLE, &dn_neigh_table); 596 neigh_table_init(NEIGH_DN_TABLE, &dn_neigh_table);
611 proc_create("decnet_neigh", 0444, init_net.proc_net, 597 proc_create_net("decnet_neigh", 0444, init_net.proc_net,
612 &dn_neigh_seq_fops); 598 &dn_neigh_seq_ops, sizeof(struct neigh_seq_state));
613} 599}
614 600
615void __exit dn_neigh_cleanup(void) 601void __exit dn_neigh_cleanup(void)
diff --git a/net/ipv4/arp.c b/net/ipv4/arp.c
index bf6c2d4d4fdc..e90c89ef8c08 100644
--- a/net/ipv4/arp.c
+++ b/net/ipv4/arp.c
@@ -1418,23 +1418,12 @@ static const struct seq_operations arp_seq_ops = {
1418 .show = arp_seq_show, 1418 .show = arp_seq_show,
1419}; 1419};
1420 1420
1421static int arp_seq_open(struct inode *inode, struct file *file) 1421/* ------------------------------------------------------------------------ */
1422{
1423 return seq_open_net(inode, file, &arp_seq_ops,
1424 sizeof(struct neigh_seq_state));
1425}
1426
1427static const struct file_operations arp_seq_fops = {
1428 .open = arp_seq_open,
1429 .read = seq_read,
1430 .llseek = seq_lseek,
1431 .release = seq_release_net,
1432};
1433
1434 1422
1435static int __net_init arp_net_init(struct net *net) 1423static int __net_init arp_net_init(struct net *net)
1436{ 1424{
1437 if (!proc_create("arp", 0444, net->proc_net, &arp_seq_fops)) 1425 if (!proc_create_net("arp", 0444, net->proc_net, &arp_seq_ops,
1426 sizeof(struct neigh_seq_state)))
1438 return -ENOMEM; 1427 return -ENOMEM;
1439 return 0; 1428 return 0;
1440} 1429}
diff --git a/net/ipv4/fib_trie.c b/net/ipv4/fib_trie.c
index 3dcffd3ce98c..3293f04b941d 100644
--- a/net/ipv4/fib_trie.c
+++ b/net/ipv4/fib_trie.c
@@ -2533,19 +2533,6 @@ static const struct seq_operations fib_trie_seq_ops = {
2533 .show = fib_trie_seq_show, 2533 .show = fib_trie_seq_show,
2534}; 2534};
2535 2535
2536static int fib_trie_seq_open(struct inode *inode, struct file *file)
2537{
2538 return seq_open_net(inode, file, &fib_trie_seq_ops,
2539 sizeof(struct fib_trie_iter));
2540}
2541
2542static const struct file_operations fib_trie_fops = {
2543 .open = fib_trie_seq_open,
2544 .read = seq_read,
2545 .llseek = seq_lseek,
2546 .release = seq_release_net,
2547};
2548
2549struct fib_route_iter { 2536struct fib_route_iter {
2550 struct seq_net_private p; 2537 struct seq_net_private p;
2551 struct fib_table *main_tb; 2538 struct fib_table *main_tb;
@@ -2726,29 +2713,18 @@ static const struct seq_operations fib_route_seq_ops = {
2726 .show = fib_route_seq_show, 2713 .show = fib_route_seq_show,
2727}; 2714};
2728 2715
2729static int fib_route_seq_open(struct inode *inode, struct file *file)
2730{
2731 return seq_open_net(inode, file, &fib_route_seq_ops,
2732 sizeof(struct fib_route_iter));
2733}
2734
2735static const struct file_operations fib_route_fops = {
2736 .open = fib_route_seq_open,
2737 .read = seq_read,
2738 .llseek = seq_lseek,
2739 .release = seq_release_net,
2740};
2741
2742int __net_init fib_proc_init(struct net *net) 2716int __net_init fib_proc_init(struct net *net)
2743{ 2717{
2744 if (!proc_create("fib_trie", 0444, net->proc_net, &fib_trie_fops)) 2718 if (!proc_create_net("fib_trie", 0444, net->proc_net, &fib_trie_seq_ops,
2719 sizeof(struct fib_trie_iter)))
2745 goto out1; 2720 goto out1;
2746 2721
2747 if (!proc_create("fib_triestat", 0444, net->proc_net, 2722 if (!proc_create("fib_triestat", 0444, net->proc_net,
2748 &fib_triestat_fops)) 2723 &fib_triestat_fops))
2749 goto out2; 2724 goto out2;
2750 2725
2751 if (!proc_create("route", 0444, net->proc_net, &fib_route_fops)) 2726 if (!proc_create_net("route", 0444, net->proc_net, &fib_route_seq_ops,
2727 sizeof(struct fib_route_iter)))
2752 goto out3; 2728 goto out3;
2753 2729
2754 return 0; 2730 return 0;
diff --git a/net/ipv4/igmp.c b/net/ipv4/igmp.c
index b26a81a7de42..85b617b655bc 100644
--- a/net/ipv4/igmp.c
+++ b/net/ipv4/igmp.c
@@ -2829,19 +2829,6 @@ static const struct seq_operations igmp_mc_seq_ops = {
2829 .show = igmp_mc_seq_show, 2829 .show = igmp_mc_seq_show,
2830}; 2830};
2831 2831
2832static int igmp_mc_seq_open(struct inode *inode, struct file *file)
2833{
2834 return seq_open_net(inode, file, &igmp_mc_seq_ops,
2835 sizeof(struct igmp_mc_iter_state));
2836}
2837
2838static const struct file_operations igmp_mc_seq_fops = {
2839 .open = igmp_mc_seq_open,
2840 .read = seq_read,
2841 .llseek = seq_lseek,
2842 .release = seq_release_net,
2843};
2844
2845struct igmp_mcf_iter_state { 2832struct igmp_mcf_iter_state {
2846 struct seq_net_private p; 2833 struct seq_net_private p;
2847 struct net_device *dev; 2834 struct net_device *dev;
@@ -2975,29 +2962,17 @@ static const struct seq_operations igmp_mcf_seq_ops = {
2975 .show = igmp_mcf_seq_show, 2962 .show = igmp_mcf_seq_show,
2976}; 2963};
2977 2964
2978static int igmp_mcf_seq_open(struct inode *inode, struct file *file)
2979{
2980 return seq_open_net(inode, file, &igmp_mcf_seq_ops,
2981 sizeof(struct igmp_mcf_iter_state));
2982}
2983
2984static const struct file_operations igmp_mcf_seq_fops = {
2985 .open = igmp_mcf_seq_open,
2986 .read = seq_read,
2987 .llseek = seq_lseek,
2988 .release = seq_release_net,
2989};
2990
2991static int __net_init igmp_net_init(struct net *net) 2965static int __net_init igmp_net_init(struct net *net)
2992{ 2966{
2993 struct proc_dir_entry *pde; 2967 struct proc_dir_entry *pde;
2994 int err; 2968 int err;
2995 2969
2996 pde = proc_create("igmp", 0444, net->proc_net, &igmp_mc_seq_fops); 2970 pde = proc_create_net("igmp", 0444, net->proc_net, &igmp_mc_seq_ops,
2971 sizeof(struct igmp_mc_iter_state));
2997 if (!pde) 2972 if (!pde)
2998 goto out_igmp; 2973 goto out_igmp;
2999 pde = proc_create("mcfilter", 0444, net->proc_net, 2974 pde = proc_create_net("mcfilter", 0444, net->proc_net,
3000 &igmp_mcf_seq_fops); 2975 &igmp_mcf_seq_ops, sizeof(struct igmp_mcf_iter_state));
3001 if (!pde) 2976 if (!pde)
3002 goto out_mcfilter; 2977 goto out_mcfilter;
3003 err = inet_ctl_sock_create(&net->ipv4.mc_autojoin_sk, AF_INET, 2978 err = inet_ctl_sock_create(&net->ipv4.mc_autojoin_sk, AF_INET,
diff --git a/net/ipv4/ipmr.c b/net/ipv4/ipmr.c
index 2fb4de3f7f66..37c4f885ff7b 100644
--- a/net/ipv4/ipmr.c
+++ b/net/ipv4/ipmr.c
@@ -2828,19 +2828,6 @@ static const struct seq_operations ipmr_vif_seq_ops = {
2828 .show = ipmr_vif_seq_show, 2828 .show = ipmr_vif_seq_show,
2829}; 2829};
2830 2830
2831static int ipmr_vif_open(struct inode *inode, struct file *file)
2832{
2833 return seq_open_net(inode, file, &ipmr_vif_seq_ops,
2834 sizeof(struct mr_vif_iter));
2835}
2836
2837static const struct file_operations ipmr_vif_fops = {
2838 .open = ipmr_vif_open,
2839 .read = seq_read,
2840 .llseek = seq_lseek,
2841 .release = seq_release_net,
2842};
2843
2844static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos) 2831static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
2845{ 2832{
2846 struct net *net = seq_file_net(seq); 2833 struct net *net = seq_file_net(seq);
@@ -2900,19 +2887,6 @@ static const struct seq_operations ipmr_mfc_seq_ops = {
2900 .stop = mr_mfc_seq_stop, 2887 .stop = mr_mfc_seq_stop,
2901 .show = ipmr_mfc_seq_show, 2888 .show = ipmr_mfc_seq_show,
2902}; 2889};
2903
2904static int ipmr_mfc_open(struct inode *inode, struct file *file)
2905{
2906 return seq_open_net(inode, file, &ipmr_mfc_seq_ops,
2907 sizeof(struct mr_mfc_iter));
2908}
2909
2910static const struct file_operations ipmr_mfc_fops = {
2911 .open = ipmr_mfc_open,
2912 .read = seq_read,
2913 .llseek = seq_lseek,
2914 .release = seq_release_net,
2915};
2916#endif 2890#endif
2917 2891
2918#ifdef CONFIG_IP_PIMSM_V2 2892#ifdef CONFIG_IP_PIMSM_V2
@@ -2977,9 +2951,11 @@ static int __net_init ipmr_net_init(struct net *net)
2977 2951
2978#ifdef CONFIG_PROC_FS 2952#ifdef CONFIG_PROC_FS
2979 err = -ENOMEM; 2953 err = -ENOMEM;
2980 if (!proc_create("ip_mr_vif", 0, net->proc_net, &ipmr_vif_fops)) 2954 if (!proc_create_net("ip_mr_vif", 0, net->proc_net, &ipmr_vif_seq_ops,
2955 sizeof(struct mr_vif_iter)))
2981 goto proc_vif_fail; 2956 goto proc_vif_fail;
2982 if (!proc_create("ip_mr_cache", 0, net->proc_net, &ipmr_mfc_fops)) 2957 if (!proc_create_net("ip_mr_cache", 0, net->proc_net, &ipmr_mfc_seq_ops,
2958 sizeof(struct mr_mfc_iter)))
2983 goto proc_cache_fail; 2959 goto proc_cache_fail;
2984#endif 2960#endif
2985 return 0; 2961 return 0;
diff --git a/net/ipv4/ping.c b/net/ipv4/ping.c
index 4d21c24dba78..2ed64bca54e3 100644
--- a/net/ipv4/ping.c
+++ b/net/ipv4/ping.c
@@ -1157,22 +1157,10 @@ static const struct seq_operations ping_v4_seq_ops = {
1157 .stop = ping_seq_stop, 1157 .stop = ping_seq_stop,
1158}; 1158};
1159 1159
1160static int ping_v4_seq_open(struct inode *inode, struct file *file)
1161{
1162 return seq_open_net(inode, file, &ping_v4_seq_ops,
1163 sizeof(struct ping_iter_state));
1164}
1165
1166const struct file_operations ping_v4_seq_fops = {
1167 .open = ping_v4_seq_open,
1168 .read = seq_read,
1169 .llseek = seq_lseek,
1170 .release = seq_release_net,
1171};
1172
1173static int __net_init ping_v4_proc_init_net(struct net *net) 1160static int __net_init ping_v4_proc_init_net(struct net *net)
1174{ 1161{
1175 if (!proc_create("icmp", 0444, net->proc_net, &ping_v4_seq_fops)) 1162 if (!proc_create_net("icmp", 0444, net->proc_net, &ping_v4_seq_ops,
1163 sizeof(struct ping_iter_state)))
1176 return -ENOMEM; 1164 return -ENOMEM;
1177 return 0; 1165 return 0;
1178} 1166}
diff --git a/net/ipv4/raw.c b/net/ipv4/raw.c
index ae57962b31e3..abb3c9490c55 100644
--- a/net/ipv4/raw.c
+++ b/net/ipv4/raw.c
@@ -1112,23 +1112,10 @@ static const struct seq_operations raw_seq_ops = {
1112 .show = raw_seq_show, 1112 .show = raw_seq_show,
1113}; 1113};
1114 1114
1115static int raw_v4_seq_open(struct inode *inode, struct file *file)
1116{
1117 return seq_open_net(inode, file, &raw_seq_ops,
1118 sizeof(struct raw_iter_state));
1119}
1120
1121static const struct file_operations raw_seq_fops = {
1122 .open = raw_v4_seq_open,
1123 .read = seq_read,
1124 .llseek = seq_lseek,
1125 .release = seq_release_net,
1126};
1127
1128static __net_init int raw_init_net(struct net *net) 1115static __net_init int raw_init_net(struct net *net)
1129{ 1116{
1130 if (!proc_create_data("raw", 0444, net->proc_net, &raw_seq_fops, 1117 if (!proc_create_net_data("raw", 0444, net->proc_net, &raw_seq_ops,
1131 &raw_v4_hashinfo)) 1118 sizeof(struct raw_iter_state), &raw_v4_hashinfo))
1132 return -ENOMEM; 1119 return -ENOMEM;
1133 1120
1134 return 0; 1121 return 0;
diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c
index 645f259d0972..2c970626b398 100644
--- a/net/ipv4/tcp_ipv4.c
+++ b/net/ipv4/tcp_ipv4.c
@@ -2350,27 +2350,14 @@ static const struct seq_operations tcp4_seq_ops = {
2350 .stop = tcp_seq_stop, 2350 .stop = tcp_seq_stop,
2351}; 2351};
2352 2352
2353static int tcp_seq_open(struct inode *inode, struct file *file)
2354{
2355 return seq_open_net(inode, file, &tcp4_seq_ops,
2356 sizeof(struct tcp_iter_state));
2357}
2358
2359static const struct file_operations tcp_afinfo_seq_fops = {
2360 .open = tcp_seq_open,
2361 .read = seq_read,
2362 .llseek = seq_lseek,
2363 .release = seq_release_net
2364};
2365
2366static struct tcp_seq_afinfo tcp4_seq_afinfo = { 2353static struct tcp_seq_afinfo tcp4_seq_afinfo = {
2367 .family = AF_INET, 2354 .family = AF_INET,
2368}; 2355};
2369 2356
2370static int __net_init tcp4_proc_init_net(struct net *net) 2357static int __net_init tcp4_proc_init_net(struct net *net)
2371{ 2358{
2372 if (!proc_create_data("tcp", 0444, net->proc_net, 2359 if (!proc_create_net_data("tcp", 0444, net->proc_net, &tcp4_seq_ops,
2373 &tcp_afinfo_seq_fops, &tcp4_seq_afinfo)) 2360 sizeof(struct tcp_iter_state), &tcp4_seq_afinfo))
2374 return -ENOMEM; 2361 return -ENOMEM;
2375 return 0; 2362 return 0;
2376} 2363}
diff --git a/net/ipv4/udp.c b/net/ipv4/udp.c
index 51559a8c6e57..051a43ff3fb8 100644
--- a/net/ipv4/udp.c
+++ b/net/ipv4/udp.c
@@ -2706,26 +2706,13 @@ int udp4_seq_show(struct seq_file *seq, void *v)
2706 return 0; 2706 return 0;
2707} 2707}
2708 2708
2709static const struct seq_operations udp_seq_ops = { 2709const struct seq_operations udp_seq_ops = {
2710 .start = udp_seq_start, 2710 .start = udp_seq_start,
2711 .next = udp_seq_next, 2711 .next = udp_seq_next,
2712 .stop = udp_seq_stop, 2712 .stop = udp_seq_stop,
2713 .show = udp4_seq_show, 2713 .show = udp4_seq_show,
2714}; 2714};
2715 2715EXPORT_SYMBOL(udp_seq_ops);
2716static int udp_seq_open(struct inode *inode, struct file *file)
2717{
2718 return seq_open_net(inode, file, &udp_seq_ops,
2719 sizeof(struct udp_iter_state));
2720}
2721
2722const struct file_operations udp_afinfo_seq_fops = {
2723 .open = udp_seq_open,
2724 .read = seq_read,
2725 .llseek = seq_lseek,
2726 .release = seq_release_net
2727};
2728EXPORT_SYMBOL(udp_afinfo_seq_fops);
2729 2716
2730static struct udp_seq_afinfo udp4_seq_afinfo = { 2717static struct udp_seq_afinfo udp4_seq_afinfo = {
2731 .family = AF_INET, 2718 .family = AF_INET,
@@ -2734,8 +2721,8 @@ static struct udp_seq_afinfo udp4_seq_afinfo = {
2734 2721
2735static int __net_init udp4_proc_init_net(struct net *net) 2722static int __net_init udp4_proc_init_net(struct net *net)
2736{ 2723{
2737 if (!proc_create_data("udp", 0444, net->proc_net, &udp_afinfo_seq_fops, 2724 if (!proc_create_net_data("udp", 0444, net->proc_net, &udp_seq_ops,
2738 &udp4_seq_afinfo)) 2725 sizeof(struct udp_iter_state), &udp4_seq_afinfo))
2739 return -ENOMEM; 2726 return -ENOMEM;
2740 return 0; 2727 return 0;
2741} 2728}
diff --git a/net/ipv4/udplite.c b/net/ipv4/udplite.c
index 4a6e67bfbe0d..8545457752fb 100644
--- a/net/ipv4/udplite.c
+++ b/net/ipv4/udplite.c
@@ -81,8 +81,8 @@ static struct udp_seq_afinfo udplite4_seq_afinfo = {
81 81
82static int __net_init udplite4_proc_init_net(struct net *net) 82static int __net_init udplite4_proc_init_net(struct net *net)
83{ 83{
84 if (!proc_create_data("udplite", 0444, net->proc_net, 84 if (!proc_create_net_data("udplite", 0444, net->proc_net, &udp_seq_ops,
85 &udp_afinfo_seq_fops, &udplite4_seq_afinfo)) 85 sizeof(struct udp_iter_state), &udplite4_seq_afinfo))
86 return -ENOMEM; 86 return -ENOMEM;
87 return 0; 87 return 0;
88} 88}
diff --git a/net/ipv6/addrconf.c b/net/ipv6/addrconf.c
index 78cef00c9596..1b5ea3379d9b 100644
--- a/net/ipv6/addrconf.c
+++ b/net/ipv6/addrconf.c
@@ -4254,22 +4254,10 @@ static const struct seq_operations if6_seq_ops = {
4254 .stop = if6_seq_stop, 4254 .stop = if6_seq_stop,
4255}; 4255};
4256 4256
4257static int if6_seq_open(struct inode *inode, struct file *file)
4258{
4259 return seq_open_net(inode, file, &if6_seq_ops,
4260 sizeof(struct if6_iter_state));
4261}
4262
4263static const struct file_operations if6_fops = {
4264 .open = if6_seq_open,
4265 .read = seq_read,
4266 .llseek = seq_lseek,
4267 .release = seq_release_net,
4268};
4269
4270static int __net_init if6_proc_net_init(struct net *net) 4257static int __net_init if6_proc_net_init(struct net *net)
4271{ 4258{
4272 if (!proc_create("if_inet6", 0444, net->proc_net, &if6_fops)) 4259 if (!proc_create_net("if_inet6", 0444, net->proc_net, &if6_seq_ops,
4260 sizeof(struct if6_iter_state)))
4273 return -ENOMEM; 4261 return -ENOMEM;
4274 return 0; 4262 return 0;
4275} 4263}
diff --git a/net/ipv6/anycast.c b/net/ipv6/anycast.c
index bbcabbba9bd8..ebeaf47d5c8d 100644
--- a/net/ipv6/anycast.c
+++ b/net/ipv6/anycast.c
@@ -529,22 +529,10 @@ static const struct seq_operations ac6_seq_ops = {
529 .show = ac6_seq_show, 529 .show = ac6_seq_show,
530}; 530};
531 531
532static int ac6_seq_open(struct inode *inode, struct file *file)
533{
534 return seq_open_net(inode, file, &ac6_seq_ops,
535 sizeof(struct ac6_iter_state));
536}
537
538static const struct file_operations ac6_seq_fops = {
539 .open = ac6_seq_open,
540 .read = seq_read,
541 .llseek = seq_lseek,
542 .release = seq_release_net,
543};
544
545int __net_init ac6_proc_init(struct net *net) 532int __net_init ac6_proc_init(struct net *net)
546{ 533{
547 if (!proc_create("anycast6", 0444, net->proc_net, &ac6_seq_fops)) 534 if (!proc_create_net("anycast6", 0444, net->proc_net, &ac6_seq_ops,
535 sizeof(struct ac6_iter_state)))
548 return -ENOMEM; 536 return -ENOMEM;
549 537
550 return 0; 538 return 0;
diff --git a/net/ipv6/ip6_fib.c b/net/ipv6/ip6_fib.c
index deab2db6692e..01372dd74e38 100644
--- a/net/ipv6/ip6_fib.c
+++ b/net/ipv6/ip6_fib.c
@@ -2209,15 +2209,6 @@ void fib6_gc_cleanup(void)
2209} 2209}
2210 2210
2211#ifdef CONFIG_PROC_FS 2211#ifdef CONFIG_PROC_FS
2212
2213struct ipv6_route_iter {
2214 struct seq_net_private p;
2215 struct fib6_walker w;
2216 loff_t skip;
2217 struct fib6_table *tbl;
2218 int sernum;
2219};
2220
2221static int ipv6_route_seq_show(struct seq_file *seq, void *v) 2212static int ipv6_route_seq_show(struct seq_file *seq, void *v)
2222{ 2213{
2223 struct rt6_info *rt = v; 2214 struct rt6_info *rt = v;
@@ -2383,17 +2374,10 @@ static void ipv6_route_seq_stop(struct seq_file *seq, void *v)
2383 rcu_read_unlock_bh(); 2374 rcu_read_unlock_bh();
2384} 2375}
2385 2376
2386static const struct seq_operations ipv6_route_seq_ops = { 2377const struct seq_operations ipv6_route_seq_ops = {
2387 .start = ipv6_route_seq_start, 2378 .start = ipv6_route_seq_start,
2388 .next = ipv6_route_seq_next, 2379 .next = ipv6_route_seq_next,
2389 .stop = ipv6_route_seq_stop, 2380 .stop = ipv6_route_seq_stop,
2390 .show = ipv6_route_seq_show 2381 .show = ipv6_route_seq_show
2391}; 2382};
2392
2393int ipv6_route_open(struct inode *inode, struct file *file)
2394{
2395 return seq_open_net(inode, file, &ipv6_route_seq_ops,
2396 sizeof(struct ipv6_route_iter));
2397}
2398
2399#endif /* CONFIG_PROC_FS */ 2383#endif /* CONFIG_PROC_FS */
diff --git a/net/ipv6/ip6_flowlabel.c b/net/ipv6/ip6_flowlabel.c
index 2fbd9bed764a..3eee7637bdfe 100644
--- a/net/ipv6/ip6_flowlabel.c
+++ b/net/ipv6/ip6_flowlabel.c
@@ -812,23 +812,10 @@ static const struct seq_operations ip6fl_seq_ops = {
812 .show = ip6fl_seq_show, 812 .show = ip6fl_seq_show,
813}; 813};
814 814
815static int ip6fl_seq_open(struct inode *inode, struct file *file)
816{
817 return seq_open_net(inode, file, &ip6fl_seq_ops,
818 sizeof(struct ip6fl_iter_state));
819}
820
821static const struct file_operations ip6fl_seq_fops = {
822 .open = ip6fl_seq_open,
823 .read = seq_read,
824 .llseek = seq_lseek,
825 .release = seq_release_net,
826};
827
828static int __net_init ip6_flowlabel_proc_init(struct net *net) 815static int __net_init ip6_flowlabel_proc_init(struct net *net)
829{ 816{
830 if (!proc_create("ip6_flowlabel", 0444, net->proc_net, 817 if (!proc_create_net("ip6_flowlabel", 0444, net->proc_net,
831 &ip6fl_seq_fops)) 818 &ip6fl_seq_ops, sizeof(struct ip6fl_iter_state)))
832 return -ENOMEM; 819 return -ENOMEM;
833 return 0; 820 return 0;
834} 821}
diff --git a/net/ipv6/ip6mr.c b/net/ipv6/ip6mr.c
index 298fd8b6ed17..4a15529d33eb 100644
--- a/net/ipv6/ip6mr.c
+++ b/net/ipv6/ip6mr.c
@@ -439,19 +439,6 @@ static const struct seq_operations ip6mr_vif_seq_ops = {
439 .show = ip6mr_vif_seq_show, 439 .show = ip6mr_vif_seq_show,
440}; 440};
441 441
442static int ip6mr_vif_open(struct inode *inode, struct file *file)
443{
444 return seq_open_net(inode, file, &ip6mr_vif_seq_ops,
445 sizeof(struct mr_vif_iter));
446}
447
448static const struct file_operations ip6mr_vif_fops = {
449 .open = ip6mr_vif_open,
450 .read = seq_read,
451 .llseek = seq_lseek,
452 .release = seq_release_net,
453};
454
455static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos) 442static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
456{ 443{
457 struct net *net = seq_file_net(seq); 444 struct net *net = seq_file_net(seq);
@@ -512,19 +499,6 @@ static const struct seq_operations ipmr_mfc_seq_ops = {
512 .stop = mr_mfc_seq_stop, 499 .stop = mr_mfc_seq_stop,
513 .show = ipmr_mfc_seq_show, 500 .show = ipmr_mfc_seq_show,
514}; 501};
515
516static int ipmr_mfc_open(struct inode *inode, struct file *file)
517{
518 return seq_open_net(inode, file, &ipmr_mfc_seq_ops,
519 sizeof(struct mr_mfc_iter));
520}
521
522static const struct file_operations ip6mr_mfc_fops = {
523 .open = ipmr_mfc_open,
524 .read = seq_read,
525 .llseek = seq_lseek,
526 .release = seq_release_net,
527};
528#endif 502#endif
529 503
530#ifdef CONFIG_IPV6_PIMSM_V2 504#ifdef CONFIG_IPV6_PIMSM_V2
@@ -1316,9 +1290,11 @@ static int __net_init ip6mr_net_init(struct net *net)
1316 1290
1317#ifdef CONFIG_PROC_FS 1291#ifdef CONFIG_PROC_FS
1318 err = -ENOMEM; 1292 err = -ENOMEM;
1319 if (!proc_create("ip6_mr_vif", 0, net->proc_net, &ip6mr_vif_fops)) 1293 if (!proc_create_net("ip6_mr_vif", 0, net->proc_net, &ip6mr_vif_seq_ops,
1294 sizeof(struct mr_vif_iter)))
1320 goto proc_vif_fail; 1295 goto proc_vif_fail;
1321 if (!proc_create("ip6_mr_cache", 0, net->proc_net, &ip6mr_mfc_fops)) 1296 if (!proc_create_net("ip6_mr_cache", 0, net->proc_net, &ipmr_mfc_seq_ops,
1297 sizeof(struct mr_mfc_iter)))
1322 goto proc_cache_fail; 1298 goto proc_cache_fail;
1323#endif 1299#endif
1324 1300
diff --git a/net/ipv6/mcast.c b/net/ipv6/mcast.c
index 793159d77d8a..975021df7c1c 100644
--- a/net/ipv6/mcast.c
+++ b/net/ipv6/mcast.c
@@ -2749,19 +2749,6 @@ static const struct seq_operations igmp6_mc_seq_ops = {
2749 .show = igmp6_mc_seq_show, 2749 .show = igmp6_mc_seq_show,
2750}; 2750};
2751 2751
2752static int igmp6_mc_seq_open(struct inode *inode, struct file *file)
2753{
2754 return seq_open_net(inode, file, &igmp6_mc_seq_ops,
2755 sizeof(struct igmp6_mc_iter_state));
2756}
2757
2758static const struct file_operations igmp6_mc_seq_fops = {
2759 .open = igmp6_mc_seq_open,
2760 .read = seq_read,
2761 .llseek = seq_lseek,
2762 .release = seq_release_net,
2763};
2764
2765struct igmp6_mcf_iter_state { 2752struct igmp6_mcf_iter_state {
2766 struct seq_net_private p; 2753 struct seq_net_private p;
2767 struct net_device *dev; 2754 struct net_device *dev;
@@ -2903,28 +2890,17 @@ static const struct seq_operations igmp6_mcf_seq_ops = {
2903 .show = igmp6_mcf_seq_show, 2890 .show = igmp6_mcf_seq_show,
2904}; 2891};
2905 2892
2906static int igmp6_mcf_seq_open(struct inode *inode, struct file *file)
2907{
2908 return seq_open_net(inode, file, &igmp6_mcf_seq_ops,
2909 sizeof(struct igmp6_mcf_iter_state));
2910}
2911
2912static const struct file_operations igmp6_mcf_seq_fops = {
2913 .open = igmp6_mcf_seq_open,
2914 .read = seq_read,
2915 .llseek = seq_lseek,
2916 .release = seq_release_net,
2917};
2918
2919static int __net_init igmp6_proc_init(struct net *net) 2893static int __net_init igmp6_proc_init(struct net *net)
2920{ 2894{
2921 int err; 2895 int err;
2922 2896
2923 err = -ENOMEM; 2897 err = -ENOMEM;
2924 if (!proc_create("igmp6", 0444, net->proc_net, &igmp6_mc_seq_fops)) 2898 if (!proc_create_net("igmp6", 0444, net->proc_net, &igmp6_mc_seq_ops,
2899 sizeof(struct igmp6_mc_iter_state)))
2925 goto out; 2900 goto out;
2926 if (!proc_create("mcfilter6", 0444, net->proc_net, 2901 if (!proc_create_net("mcfilter6", 0444, net->proc_net,
2927 &igmp6_mcf_seq_fops)) 2902 &igmp6_mcf_seq_ops,
2903 sizeof(struct igmp6_mcf_iter_state)))
2928 goto out_proc_net_igmp6; 2904 goto out_proc_net_igmp6;
2929 2905
2930 err = 0; 2906 err = 0;
diff --git a/net/ipv6/ping.c b/net/ipv6/ping.c
index 45d5c8e0f2bf..96f56bf49a30 100644
--- a/net/ipv6/ping.c
+++ b/net/ipv6/ping.c
@@ -223,22 +223,10 @@ static const struct seq_operations ping_v6_seq_ops = {
223 .stop = ping_seq_stop, 223 .stop = ping_seq_stop,
224}; 224};
225 225
226static int ping_v6_seq_open(struct inode *inode, struct file *file)
227{
228 return seq_open_net(inode, file, &ping_v6_seq_ops,
229 sizeof(struct ping_iter_state));
230}
231
232const struct file_operations ping_v6_seq_fops = {
233 .open = ping_v6_seq_open,
234 .read = seq_read,
235 .llseek = seq_lseek,
236 .release = seq_release_net,
237};
238
239static int __net_init ping_v6_proc_init_net(struct net *net) 226static int __net_init ping_v6_proc_init_net(struct net *net)
240{ 227{
241 if (!proc_create("icmp6", 0444, net->proc_net, &ping_v6_seq_fops)) 228 if (!proc_create_net("icmp6", 0444, net->proc_net, &ping_v6_seq_ops,
229 sizeof(struct ping_iter_state)))
242 return -ENOMEM; 230 return -ENOMEM;
243 return 0; 231 return 0;
244} 232}
diff --git a/net/ipv6/raw.c b/net/ipv6/raw.c
index dade69bf61e6..afc307c89d1a 100644
--- a/net/ipv6/raw.c
+++ b/net/ipv6/raw.c
@@ -1304,23 +1304,10 @@ static const struct seq_operations raw6_seq_ops = {
1304 .show = raw6_seq_show, 1304 .show = raw6_seq_show,
1305}; 1305};
1306 1306
1307static int raw6_seq_open(struct inode *inode, struct file *file)
1308{
1309 return seq_open_net(inode, file, &raw6_seq_ops,
1310 sizeof(struct raw_iter_state));
1311}
1312
1313static const struct file_operations raw6_seq_fops = {
1314 .open = raw6_seq_open,
1315 .read = seq_read,
1316 .llseek = seq_lseek,
1317 .release = seq_release_net,
1318};
1319
1320static int __net_init raw6_init_net(struct net *net) 1307static int __net_init raw6_init_net(struct net *net)
1321{ 1308{
1322 if (!proc_create_data("raw6", 0444, net->proc_net, &raw6_seq_fops, 1309 if (!proc_create_net_data("raw6", 0444, net->proc_net, &raw6_seq_ops,
1323 &raw_v6_hashinfo)) 1310 sizeof(struct raw_iter_state), &raw_v6_hashinfo))
1324 return -ENOMEM; 1311 return -ENOMEM;
1325 1312
1326 return 0; 1313 return 0;
diff --git a/net/ipv6/route.c b/net/ipv6/route.c
index f4d61736c41a..527b9b644f5a 100644
--- a/net/ipv6/route.c
+++ b/net/ipv6/route.c
@@ -4862,14 +4862,6 @@ static int ip6_route_dev_notify(struct notifier_block *this,
4862 */ 4862 */
4863 4863
4864#ifdef CONFIG_PROC_FS 4864#ifdef CONFIG_PROC_FS
4865
4866static const struct file_operations ipv6_route_proc_fops = {
4867 .open = ipv6_route_open,
4868 .read = seq_read,
4869 .llseek = seq_lseek,
4870 .release = seq_release_net,
4871};
4872
4873static int rt6_stats_seq_show(struct seq_file *seq, void *v) 4865static int rt6_stats_seq_show(struct seq_file *seq, void *v)
4874{ 4866{
4875 struct net *net = (struct net *)seq->private; 4867 struct net *net = (struct net *)seq->private;
@@ -5100,7 +5092,8 @@ static void __net_exit ip6_route_net_exit(struct net *net)
5100static int __net_init ip6_route_net_init_late(struct net *net) 5092static int __net_init ip6_route_net_init_late(struct net *net)
5101{ 5093{
5102#ifdef CONFIG_PROC_FS 5094#ifdef CONFIG_PROC_FS
5103 proc_create("ipv6_route", 0, net->proc_net, &ipv6_route_proc_fops); 5095 proc_create_net("ipv6_route", 0, net->proc_net, &ipv6_route_seq_ops,
5096 sizeof(struct ipv6_route_iter));
5104 proc_create("rt6_stats", 0444, net->proc_net, &rt6_stats_seq_fops); 5097 proc_create("rt6_stats", 0444, net->proc_net, &rt6_stats_seq_fops);
5105#endif 5098#endif
5106 return 0; 5099 return 0;
diff --git a/net/ipv6/tcp_ipv6.c b/net/ipv6/tcp_ipv6.c
index c0329bb1692f..d2ce66b23430 100644
--- a/net/ipv6/tcp_ipv6.c
+++ b/net/ipv6/tcp_ipv6.c
@@ -1916,27 +1916,14 @@ static const struct seq_operations tcp6_seq_ops = {
1916 .stop = tcp_seq_stop, 1916 .stop = tcp_seq_stop,
1917}; 1917};
1918 1918
1919static int tcp6_seq_open(struct inode *inode, struct file *file)
1920{
1921 return seq_open_net(inode, file, &tcp6_seq_ops,
1922 sizeof(struct tcp_iter_state));
1923}
1924
1925static const struct file_operations tcp6_afinfo_seq_fops = {
1926 .open = tcp6_seq_open,
1927 .read = seq_read,
1928 .llseek = seq_lseek,
1929 .release = seq_release_net
1930};
1931
1932static struct tcp_seq_afinfo tcp6_seq_afinfo = { 1919static struct tcp_seq_afinfo tcp6_seq_afinfo = {
1933 .family = AF_INET6, 1920 .family = AF_INET6,
1934}; 1921};
1935 1922
1936int __net_init tcp6_proc_init(struct net *net) 1923int __net_init tcp6_proc_init(struct net *net)
1937{ 1924{
1938 if (!proc_create_data("tcp6", 0444, net->proc_net, 1925 if (!proc_create_net_data("tcp6", 0444, net->proc_net, &tcp6_seq_ops,
1939 &tcp6_afinfo_seq_fops, &tcp6_seq_afinfo)) 1926 sizeof(struct tcp_iter_state), &tcp6_seq_afinfo))
1940 return -ENOMEM; 1927 return -ENOMEM;
1941 return 0; 1928 return 0;
1942} 1929}
diff --git a/net/ipv6/udp.c b/net/ipv6/udp.c
index 29adddeac3e5..00e2112da26d 100644
--- a/net/ipv6/udp.c
+++ b/net/ipv6/udp.c
@@ -1480,26 +1480,13 @@ int udp6_seq_show(struct seq_file *seq, void *v)
1480 return 0; 1480 return 0;
1481} 1481}
1482 1482
1483static const struct seq_operations udp6_seq_ops = { 1483const struct seq_operations udp6_seq_ops = {
1484 .start = udp_seq_start, 1484 .start = udp_seq_start,
1485 .next = udp_seq_next, 1485 .next = udp_seq_next,
1486 .stop = udp_seq_stop, 1486 .stop = udp_seq_stop,
1487 .show = udp6_seq_show, 1487 .show = udp6_seq_show,
1488}; 1488};
1489 1489EXPORT_SYMBOL(udp6_seq_ops);
1490static int udp6_seq_open(struct inode *inode, struct file *file)
1491{
1492 return seq_open_net(inode, file, &udp6_seq_ops,
1493 sizeof(struct udp_iter_state));
1494}
1495
1496const struct file_operations udp6_afinfo_seq_fops = {
1497 .open = udp6_seq_open,
1498 .read = seq_read,
1499 .llseek = seq_lseek,
1500 .release = seq_release_net
1501};
1502EXPORT_SYMBOL(udp6_afinfo_seq_fops);
1503 1490
1504static struct udp_seq_afinfo udp6_seq_afinfo = { 1491static struct udp_seq_afinfo udp6_seq_afinfo = {
1505 .family = AF_INET6, 1492 .family = AF_INET6,
@@ -1508,8 +1495,8 @@ static struct udp_seq_afinfo udp6_seq_afinfo = {
1508 1495
1509int __net_init udp6_proc_init(struct net *net) 1496int __net_init udp6_proc_init(struct net *net)
1510{ 1497{
1511 if (!proc_create_data("udp6", 0444, net->proc_net, 1498 if (!proc_create_net_data("udp6", 0444, net->proc_net, &udp6_seq_ops,
1512 &udp6_afinfo_seq_fops, &udp6_seq_afinfo)) 1499 sizeof(struct udp_iter_state), &udp6_seq_afinfo))
1513 return -ENOMEM; 1500 return -ENOMEM;
1514 return 0; 1501 return 0;
1515} 1502}
diff --git a/net/ipv6/udplite.c b/net/ipv6/udplite.c
index a119e57196b5..5000ad6878e6 100644
--- a/net/ipv6/udplite.c
+++ b/net/ipv6/udplite.c
@@ -100,8 +100,9 @@ static struct udp_seq_afinfo udplite6_seq_afinfo = {
100 100
101static int __net_init udplite6_proc_init_net(struct net *net) 101static int __net_init udplite6_proc_init_net(struct net *net)
102{ 102{
103 if (!proc_create_data("udplite6", 0444, net->proc_net, 103 if (!proc_create_net_data("udplite6", 0444, net->proc_net,
104 &udp6_afinfo_seq_fops, &udplite6_seq_afinfo)) 104 &udp6_seq_ops, sizeof(struct udp_iter_state),
105 &udplite6_seq_afinfo))
105 return -ENOMEM; 106 return -ENOMEM;
106 return 0; 107 return 0;
107} 108}
diff --git a/net/kcm/kcmproc.c b/net/kcm/kcmproc.c
index 6d0667e62baf..6283ed2f43b2 100644
--- a/net/kcm/kcmproc.c
+++ b/net/kcm/kcmproc.c
@@ -239,19 +239,6 @@ static const struct seq_operations kcm_seq_ops = {
239 .stop = kcm_seq_stop, 239 .stop = kcm_seq_stop,
240}; 240};
241 241
242static int kcm_seq_open(struct inode *inode, struct file *file)
243{
244 return seq_open_net(inode, file, &kcm_seq_ops,
245 sizeof(struct kcm_proc_mux_state));
246}
247
248static const struct file_operations kcm_seq_fops = {
249 .open = kcm_seq_open,
250 .read = seq_read,
251 .llseek = seq_lseek,
252 .release = seq_release_net,
253};
254
255static int kcm_stats_seq_show(struct seq_file *seq, void *v) 242static int kcm_stats_seq_show(struct seq_file *seq, void *v)
256{ 243{
257 struct kcm_psock_stats psock_stats; 244 struct kcm_psock_stats psock_stats;
@@ -376,7 +363,8 @@ static int kcm_proc_init_net(struct net *net)
376 &kcm_stats_seq_fops)) 363 &kcm_stats_seq_fops))
377 goto out_kcm_stats; 364 goto out_kcm_stats;
378 365
379 if (!proc_create("kcm", 0444, net->proc_net, &kcm_seq_fops)) 366 if (!proc_create_net("kcm", 0444, net->proc_net, &kcm_seq_ops,
367 sizeof(struct kcm_proc_mux_state)))
380 goto out_kcm; 368 goto out_kcm;
381 369
382 return 0; 370 return 0;
diff --git a/net/key/af_key.c b/net/key/af_key.c
index e62e52e8f141..5e1d2946ffbf 100644
--- a/net/key/af_key.c
+++ b/net/key/af_key.c
@@ -3812,24 +3812,12 @@ static const struct seq_operations pfkey_seq_ops = {
3812 .show = pfkey_seq_show, 3812 .show = pfkey_seq_show,
3813}; 3813};
3814 3814
3815static int pfkey_seq_open(struct inode *inode, struct file *file)
3816{
3817 return seq_open_net(inode, file, &pfkey_seq_ops,
3818 sizeof(struct seq_net_private));
3819}
3820
3821static const struct file_operations pfkey_proc_ops = {
3822 .open = pfkey_seq_open,
3823 .read = seq_read,
3824 .llseek = seq_lseek,
3825 .release = seq_release_net,
3826};
3827
3828static int __net_init pfkey_init_proc(struct net *net) 3815static int __net_init pfkey_init_proc(struct net *net)
3829{ 3816{
3830 struct proc_dir_entry *e; 3817 struct proc_dir_entry *e;
3831 3818
3832 e = proc_create("pfkey", 0, net->proc_net, &pfkey_proc_ops); 3819 e = proc_create_net("pfkey", 0, net->proc_net, &pfkey_seq_ops,
3820 sizeof(struct seq_net_private));
3833 if (e == NULL) 3821 if (e == NULL)
3834 return -ENOMEM; 3822 return -ENOMEM;
3835 3823
diff --git a/net/l2tp/l2tp_ppp.c b/net/l2tp/l2tp_ppp.c
index 1fd9e145076a..830469766c1f 100644
--- a/net/l2tp/l2tp_ppp.c
+++ b/net/l2tp/l2tp_ppp.c
@@ -1742,24 +1742,6 @@ static const struct seq_operations pppol2tp_seq_ops = {
1742 .stop = pppol2tp_seq_stop, 1742 .stop = pppol2tp_seq_stop,
1743 .show = pppol2tp_seq_show, 1743 .show = pppol2tp_seq_show,
1744}; 1744};
1745
1746/* Called when our /proc file is opened. We allocate data for use when
1747 * iterating our tunnel / session contexts and store it in the private
1748 * data of the seq_file.
1749 */
1750static int pppol2tp_proc_open(struct inode *inode, struct file *file)
1751{
1752 return seq_open_net(inode, file, &pppol2tp_seq_ops,
1753 sizeof(struct pppol2tp_seq_data));
1754}
1755
1756static const struct file_operations pppol2tp_proc_fops = {
1757 .open = pppol2tp_proc_open,
1758 .read = seq_read,
1759 .llseek = seq_lseek,
1760 .release = seq_release_net,
1761};
1762
1763#endif /* CONFIG_PROC_FS */ 1745#endif /* CONFIG_PROC_FS */
1764 1746
1765/***************************************************************************** 1747/*****************************************************************************
@@ -1771,8 +1753,8 @@ static __net_init int pppol2tp_init_net(struct net *net)
1771 struct proc_dir_entry *pde; 1753 struct proc_dir_entry *pde;
1772 int err = 0; 1754 int err = 0;
1773 1755
1774 pde = proc_create("pppol2tp", 0444, net->proc_net, 1756 pde = proc_create_net("pppol2tp", 0444, net->proc_net,
1775 &pppol2tp_proc_fops); 1757 &pppol2tp_seq_ops, sizeof(struct pppol2tp_seq_data));
1776 if (!pde) { 1758 if (!pde) {
1777 err = -ENOMEM; 1759 err = -ENOMEM;
1778 goto out; 1760 goto out;
diff --git a/net/netfilter/ipvs/ip_vs_app.c b/net/netfilter/ipvs/ip_vs_app.c
index 1c98c907bc63..c3db074fc1f7 100644
--- a/net/netfilter/ipvs/ip_vs_app.c
+++ b/net/netfilter/ipvs/ip_vs_app.c
@@ -587,25 +587,13 @@ static const struct seq_operations ip_vs_app_seq_ops = {
587 .stop = ip_vs_app_seq_stop, 587 .stop = ip_vs_app_seq_stop,
588 .show = ip_vs_app_seq_show, 588 .show = ip_vs_app_seq_show,
589}; 589};
590
591static int ip_vs_app_open(struct inode *inode, struct file *file)
592{
593 return seq_open_net(inode, file, &ip_vs_app_seq_ops,
594 sizeof(struct seq_net_private));
595}
596
597static const struct file_operations ip_vs_app_fops = {
598 .open = ip_vs_app_open,
599 .read = seq_read,
600 .llseek = seq_lseek,
601 .release = seq_release_net,
602};
603#endif 590#endif
604 591
605int __net_init ip_vs_app_net_init(struct netns_ipvs *ipvs) 592int __net_init ip_vs_app_net_init(struct netns_ipvs *ipvs)
606{ 593{
607 INIT_LIST_HEAD(&ipvs->app_list); 594 INIT_LIST_HEAD(&ipvs->app_list);
608 proc_create("ip_vs_app", 0, ipvs->net->proc_net, &ip_vs_app_fops); 595 proc_create_net("ip_vs_app", 0, ipvs->net->proc_net, &ip_vs_app_seq_ops,
596 sizeof(struct seq_net_private));
609 return 0; 597 return 0;
610} 598}
611 599
diff --git a/net/netfilter/ipvs/ip_vs_conn.c b/net/netfilter/ipvs/ip_vs_conn.c
index 370abbf6f421..2dde148f97b5 100644
--- a/net/netfilter/ipvs/ip_vs_conn.c
+++ b/net/netfilter/ipvs/ip_vs_conn.c
@@ -1136,19 +1136,6 @@ static const struct seq_operations ip_vs_conn_seq_ops = {
1136 .show = ip_vs_conn_seq_show, 1136 .show = ip_vs_conn_seq_show,
1137}; 1137};
1138 1138
1139static int ip_vs_conn_open(struct inode *inode, struct file *file)
1140{
1141 return seq_open_net(inode, file, &ip_vs_conn_seq_ops,
1142 sizeof(struct ip_vs_iter_state));
1143}
1144
1145static const struct file_operations ip_vs_conn_fops = {
1146 .open = ip_vs_conn_open,
1147 .read = seq_read,
1148 .llseek = seq_lseek,
1149 .release = seq_release_net,
1150};
1151
1152static const char *ip_vs_origin_name(unsigned int flags) 1139static const char *ip_vs_origin_name(unsigned int flags)
1153{ 1140{
1154 if (flags & IP_VS_CONN_F_SYNC) 1141 if (flags & IP_VS_CONN_F_SYNC)
@@ -1212,20 +1199,6 @@ static const struct seq_operations ip_vs_conn_sync_seq_ops = {
1212 .stop = ip_vs_conn_seq_stop, 1199 .stop = ip_vs_conn_seq_stop,
1213 .show = ip_vs_conn_sync_seq_show, 1200 .show = ip_vs_conn_sync_seq_show,
1214}; 1201};
1215
1216static int ip_vs_conn_sync_open(struct inode *inode, struct file *file)
1217{
1218 return seq_open_net(inode, file, &ip_vs_conn_sync_seq_ops,
1219 sizeof(struct ip_vs_iter_state));
1220}
1221
1222static const struct file_operations ip_vs_conn_sync_fops = {
1223 .open = ip_vs_conn_sync_open,
1224 .read = seq_read,
1225 .llseek = seq_lseek,
1226 .release = seq_release_net,
1227};
1228
1229#endif 1202#endif
1230 1203
1231 1204
@@ -1385,9 +1358,11 @@ int __net_init ip_vs_conn_net_init(struct netns_ipvs *ipvs)
1385{ 1358{
1386 atomic_set(&ipvs->conn_count, 0); 1359 atomic_set(&ipvs->conn_count, 0);
1387 1360
1388 proc_create("ip_vs_conn", 0, ipvs->net->proc_net, &ip_vs_conn_fops); 1361 proc_create_net("ip_vs_conn", 0, ipvs->net->proc_net,
1389 proc_create("ip_vs_conn_sync", 0, ipvs->net->proc_net, 1362 &ip_vs_conn_seq_ops, sizeof(struct ip_vs_iter_state));
1390 &ip_vs_conn_sync_fops); 1363 proc_create_net("ip_vs_conn_sync", 0, ipvs->net->proc_net,
1364 &ip_vs_conn_sync_seq_ops,
1365 sizeof(struct ip_vs_iter_state));
1391 return 0; 1366 return 0;
1392} 1367}
1393 1368
diff --git a/net/netfilter/ipvs/ip_vs_ctl.c b/net/netfilter/ipvs/ip_vs_ctl.c
index f36098887ad0..6221016e554a 100644
--- a/net/netfilter/ipvs/ip_vs_ctl.c
+++ b/net/netfilter/ipvs/ip_vs_ctl.c
@@ -2109,19 +2109,6 @@ static const struct seq_operations ip_vs_info_seq_ops = {
2109 .show = ip_vs_info_seq_show, 2109 .show = ip_vs_info_seq_show,
2110}; 2110};
2111 2111
2112static int ip_vs_info_open(struct inode *inode, struct file *file)
2113{
2114 return seq_open_net(inode, file, &ip_vs_info_seq_ops,
2115 sizeof(struct ip_vs_iter));
2116}
2117
2118static const struct file_operations ip_vs_info_fops = {
2119 .open = ip_vs_info_open,
2120 .read = seq_read,
2121 .llseek = seq_lseek,
2122 .release = seq_release_net,
2123};
2124
2125static int ip_vs_stats_show(struct seq_file *seq, void *v) 2112static int ip_vs_stats_show(struct seq_file *seq, void *v)
2126{ 2113{
2127 struct net *net = seq_file_single_net(seq); 2114 struct net *net = seq_file_single_net(seq);
@@ -4030,7 +4017,8 @@ int __net_init ip_vs_control_net_init(struct netns_ipvs *ipvs)
4030 4017
4031 spin_lock_init(&ipvs->tot_stats.lock); 4018 spin_lock_init(&ipvs->tot_stats.lock);
4032 4019
4033 proc_create("ip_vs", 0, ipvs->net->proc_net, &ip_vs_info_fops); 4020 proc_create_net("ip_vs", 0, ipvs->net->proc_net, &ip_vs_info_seq_ops,
4021 sizeof(struct ip_vs_iter));
4034 proc_create("ip_vs_stats", 0, ipvs->net->proc_net, &ip_vs_stats_fops); 4022 proc_create("ip_vs_stats", 0, ipvs->net->proc_net, &ip_vs_stats_fops);
4035 proc_create("ip_vs_stats_percpu", 0, ipvs->net->proc_net, 4023 proc_create("ip_vs_stats_percpu", 0, ipvs->net->proc_net,
4036 &ip_vs_stats_percpu_fops); 4024 &ip_vs_stats_percpu_fops);
diff --git a/net/netfilter/nf_conntrack_expect.c b/net/netfilter/nf_conntrack_expect.c
index 4b2b3d53acfc..853b23206bb7 100644
--- a/net/netfilter/nf_conntrack_expect.c
+++ b/net/netfilter/nf_conntrack_expect.c
@@ -644,19 +644,6 @@ static const struct seq_operations exp_seq_ops = {
644 .stop = exp_seq_stop, 644 .stop = exp_seq_stop,
645 .show = exp_seq_show 645 .show = exp_seq_show
646}; 646};
647
648static int exp_open(struct inode *inode, struct file *file)
649{
650 return seq_open_net(inode, file, &exp_seq_ops,
651 sizeof(struct ct_expect_iter_state));
652}
653
654static const struct file_operations exp_file_ops = {
655 .open = exp_open,
656 .read = seq_read,
657 .llseek = seq_lseek,
658 .release = seq_release_net,
659};
660#endif /* CONFIG_NF_CONNTRACK_PROCFS */ 647#endif /* CONFIG_NF_CONNTRACK_PROCFS */
661 648
662static int exp_proc_init(struct net *net) 649static int exp_proc_init(struct net *net)
@@ -666,8 +653,8 @@ static int exp_proc_init(struct net *net)
666 kuid_t root_uid; 653 kuid_t root_uid;
667 kgid_t root_gid; 654 kgid_t root_gid;
668 655
669 proc = proc_create("nf_conntrack_expect", 0440, net->proc_net, 656 proc = proc_create_net("nf_conntrack_expect", 0440, net->proc_net,
670 &exp_file_ops); 657 &exp_seq_ops, sizeof(struct ct_expect_iter_state));
671 if (!proc) 658 if (!proc)
672 return -ENOMEM; 659 return -ENOMEM;
673 660
diff --git a/net/netfilter/nf_conntrack_standalone.c b/net/netfilter/nf_conntrack_standalone.c
index 037fec54c850..b642c0b2495c 100644
--- a/net/netfilter/nf_conntrack_standalone.c
+++ b/net/netfilter/nf_conntrack_standalone.c
@@ -375,19 +375,6 @@ static const struct seq_operations ct_seq_ops = {
375 .show = ct_seq_show 375 .show = ct_seq_show
376}; 376};
377 377
378static int ct_open(struct inode *inode, struct file *file)
379{
380 return seq_open_net(inode, file, &ct_seq_ops,
381 sizeof(struct ct_iter_state));
382}
383
384static const struct file_operations ct_file_ops = {
385 .open = ct_open,
386 .read = seq_read,
387 .llseek = seq_lseek,
388 .release = seq_release_net,
389};
390
391static void *ct_cpu_seq_start(struct seq_file *seq, loff_t *pos) 378static void *ct_cpu_seq_start(struct seq_file *seq, loff_t *pos)
392{ 379{
393 struct net *net = seq_file_net(seq); 380 struct net *net = seq_file_net(seq);
@@ -467,26 +454,14 @@ static const struct seq_operations ct_cpu_seq_ops = {
467 .show = ct_cpu_seq_show, 454 .show = ct_cpu_seq_show,
468}; 455};
469 456
470static int ct_cpu_seq_open(struct inode *inode, struct file *file)
471{
472 return seq_open_net(inode, file, &ct_cpu_seq_ops,
473 sizeof(struct seq_net_private));
474}
475
476static const struct file_operations ct_cpu_seq_fops = {
477 .open = ct_cpu_seq_open,
478 .read = seq_read,
479 .llseek = seq_lseek,
480 .release = seq_release_net,
481};
482
483static int nf_conntrack_standalone_init_proc(struct net *net) 457static int nf_conntrack_standalone_init_proc(struct net *net)
484{ 458{
485 struct proc_dir_entry *pde; 459 struct proc_dir_entry *pde;
486 kuid_t root_uid; 460 kuid_t root_uid;
487 kgid_t root_gid; 461 kgid_t root_gid;
488 462
489 pde = proc_create("nf_conntrack", 0440, net->proc_net, &ct_file_ops); 463 pde = proc_create_net("nf_conntrack", 0440, net->proc_net, &ct_seq_ops,
464 sizeof(struct ct_iter_state));
490 if (!pde) 465 if (!pde)
491 goto out_nf_conntrack; 466 goto out_nf_conntrack;
492 467
@@ -495,8 +470,8 @@ static int nf_conntrack_standalone_init_proc(struct net *net)
495 if (uid_valid(root_uid) && gid_valid(root_gid)) 470 if (uid_valid(root_uid) && gid_valid(root_gid))
496 proc_set_user(pde, root_uid, root_gid); 471 proc_set_user(pde, root_uid, root_gid);
497 472
498 pde = proc_create("nf_conntrack", 0444, net->proc_net_stat, 473 pde = proc_create_net("nf_conntrack", 0444, net->proc_net_stat,
499 &ct_cpu_seq_fops); 474 &ct_cpu_seq_ops, sizeof(struct seq_net_private));
500 if (!pde) 475 if (!pde)
501 goto out_stat_nf_conntrack; 476 goto out_stat_nf_conntrack;
502 return 0; 477 return 0;
diff --git a/net/netfilter/nf_log.c b/net/netfilter/nf_log.c
index 6d0357817cda..426457047578 100644
--- a/net/netfilter/nf_log.c
+++ b/net/netfilter/nf_log.c
@@ -394,21 +394,6 @@ static const struct seq_operations nflog_seq_ops = {
394 .stop = seq_stop, 394 .stop = seq_stop,
395 .show = seq_show, 395 .show = seq_show,
396}; 396};
397
398static int nflog_open(struct inode *inode, struct file *file)
399{
400 return seq_open_net(inode, file, &nflog_seq_ops,
401 sizeof(struct seq_net_private));
402}
403
404static const struct file_operations nflog_file_ops = {
405 .open = nflog_open,
406 .read = seq_read,
407 .llseek = seq_lseek,
408 .release = seq_release_net,
409};
410
411
412#endif /* PROC_FS */ 397#endif /* PROC_FS */
413 398
414#ifdef CONFIG_SYSCTL 399#ifdef CONFIG_SYSCTL
@@ -549,8 +534,8 @@ static int __net_init nf_log_net_init(struct net *net)
549 int ret = -ENOMEM; 534 int ret = -ENOMEM;
550 535
551#ifdef CONFIG_PROC_FS 536#ifdef CONFIG_PROC_FS
552 if (!proc_create("nf_log", 0444, 537 if (!proc_create_net("nf_log", 0444, net->nf.proc_netfilter,
553 net->nf.proc_netfilter, &nflog_file_ops)) 538 &nflog_seq_ops, sizeof(struct seq_net_private)))
554 return ret; 539 return ret;
555#endif 540#endif
556 ret = netfilter_log_sysctl_init(net); 541 ret = netfilter_log_sysctl_init(net);
diff --git a/net/netfilter/nf_synproxy_core.c b/net/netfilter/nf_synproxy_core.c
index 6039b350abbe..8ff4d22f10b2 100644
--- a/net/netfilter/nf_synproxy_core.c
+++ b/net/netfilter/nf_synproxy_core.c
@@ -310,23 +310,10 @@ static const struct seq_operations synproxy_cpu_seq_ops = {
310 .show = synproxy_cpu_seq_show, 310 .show = synproxy_cpu_seq_show,
311}; 311};
312 312
313static int synproxy_cpu_seq_open(struct inode *inode, struct file *file)
314{
315 return seq_open_net(inode, file, &synproxy_cpu_seq_ops,
316 sizeof(struct seq_net_private));
317}
318
319static const struct file_operations synproxy_cpu_seq_fops = {
320 .open = synproxy_cpu_seq_open,
321 .read = seq_read,
322 .llseek = seq_lseek,
323 .release = seq_release_net,
324};
325
326static int __net_init synproxy_proc_init(struct net *net) 313static int __net_init synproxy_proc_init(struct net *net)
327{ 314{
328 if (!proc_create("synproxy", 0444, net->proc_net_stat, 315 if (!proc_create_net("synproxy", 0444, net->proc_net_stat,
329 &synproxy_cpu_seq_fops)) 316 &synproxy_cpu_seq_ops, sizeof(struct seq_net_private)))
330 return -ENOMEM; 317 return -ENOMEM;
331 return 0; 318 return 0;
332} 319}
diff --git a/net/netfilter/nfnetlink_log.c b/net/netfilter/nfnetlink_log.c
index 7b46aa4c478d..c14822b9729f 100644
--- a/net/netfilter/nfnetlink_log.c
+++ b/net/netfilter/nfnetlink_log.c
@@ -1046,20 +1046,6 @@ static const struct seq_operations nful_seq_ops = {
1046 .stop = seq_stop, 1046 .stop = seq_stop,
1047 .show = seq_show, 1047 .show = seq_show,
1048}; 1048};
1049
1050static int nful_open(struct inode *inode, struct file *file)
1051{
1052 return seq_open_net(inode, file, &nful_seq_ops,
1053 sizeof(struct iter_state));
1054}
1055
1056static const struct file_operations nful_file_ops = {
1057 .open = nful_open,
1058 .read = seq_read,
1059 .llseek = seq_lseek,
1060 .release = seq_release_net,
1061};
1062
1063#endif /* PROC_FS */ 1049#endif /* PROC_FS */
1064 1050
1065static int __net_init nfnl_log_net_init(struct net *net) 1051static int __net_init nfnl_log_net_init(struct net *net)
@@ -1077,8 +1063,8 @@ static int __net_init nfnl_log_net_init(struct net *net)
1077 spin_lock_init(&log->instances_lock); 1063 spin_lock_init(&log->instances_lock);
1078 1064
1079#ifdef CONFIG_PROC_FS 1065#ifdef CONFIG_PROC_FS
1080 proc = proc_create("nfnetlink_log", 0440, 1066 proc = proc_create_net("nfnetlink_log", 0440, net->nf.proc_netfilter,
1081 net->nf.proc_netfilter, &nful_file_ops); 1067 &nful_seq_ops, sizeof(struct iter_state));
1082 if (!proc) 1068 if (!proc)
1083 return -ENOMEM; 1069 return -ENOMEM;
1084 1070
diff --git a/net/netfilter/nfnetlink_queue.c b/net/netfilter/nfnetlink_queue.c
index 74a04638ef03..494a9ab35cb6 100644
--- a/net/netfilter/nfnetlink_queue.c
+++ b/net/netfilter/nfnetlink_queue.c
@@ -1469,20 +1469,6 @@ static const struct seq_operations nfqnl_seq_ops = {
1469 .stop = seq_stop, 1469 .stop = seq_stop,
1470 .show = seq_show, 1470 .show = seq_show,
1471}; 1471};
1472
1473static int nfqnl_open(struct inode *inode, struct file *file)
1474{
1475 return seq_open_net(inode, file, &nfqnl_seq_ops,
1476 sizeof(struct iter_state));
1477}
1478
1479static const struct file_operations nfqnl_file_ops = {
1480 .open = nfqnl_open,
1481 .read = seq_read,
1482 .llseek = seq_lseek,
1483 .release = seq_release_net,
1484};
1485
1486#endif /* PROC_FS */ 1472#endif /* PROC_FS */
1487 1473
1488static int __net_init nfnl_queue_net_init(struct net *net) 1474static int __net_init nfnl_queue_net_init(struct net *net)
@@ -1496,8 +1482,8 @@ static int __net_init nfnl_queue_net_init(struct net *net)
1496 spin_lock_init(&q->instances_lock); 1482 spin_lock_init(&q->instances_lock);
1497 1483
1498#ifdef CONFIG_PROC_FS 1484#ifdef CONFIG_PROC_FS
1499 if (!proc_create("nfnetlink_queue", 0440, 1485 if (!proc_create_net("nfnetlink_queue", 0440, net->nf.proc_netfilter,
1500 net->nf.proc_netfilter, &nfqnl_file_ops)) 1486 &nfqnl_seq_ops, sizeof(struct iter_state)))
1501 return -ENOMEM; 1487 return -ENOMEM;
1502#endif 1488#endif
1503 nf_register_queue_handler(net, &nfqh); 1489 nf_register_queue_handler(net, &nfqh);
diff --git a/net/netfilter/x_tables.c b/net/netfilter/x_tables.c
index 3704101af27f..344dd01a5027 100644
--- a/net/netfilter/x_tables.c
+++ b/net/netfilter/x_tables.c
@@ -1529,19 +1529,6 @@ static const struct seq_operations xt_table_seq_ops = {
1529 .show = xt_table_seq_show, 1529 .show = xt_table_seq_show,
1530}; 1530};
1531 1531
1532static int xt_table_open(struct inode *inode, struct file *file)
1533{
1534 return seq_open_net(inode, file, &xt_table_seq_ops,
1535 sizeof(struct seq_net_private));
1536}
1537
1538static const struct file_operations xt_table_ops = {
1539 .open = xt_table_open,
1540 .read = seq_read,
1541 .llseek = seq_lseek,
1542 .release = seq_release_net,
1543};
1544
1545/* 1532/*
1546 * Traverse state for ip{,6}_{tables,matches} for helping crossing 1533 * Traverse state for ip{,6}_{tables,matches} for helping crossing
1547 * the multi-AF mutexes. 1534 * the multi-AF mutexes.
@@ -1790,8 +1777,9 @@ int xt_proto_init(struct net *net, u_int8_t af)
1790 1777
1791 strlcpy(buf, xt_prefix[af], sizeof(buf)); 1778 strlcpy(buf, xt_prefix[af], sizeof(buf));
1792 strlcat(buf, FORMAT_TABLES, sizeof(buf)); 1779 strlcat(buf, FORMAT_TABLES, sizeof(buf));
1793 proc = proc_create_data(buf, 0440, net->proc_net, &xt_table_ops, 1780 proc = proc_create_net_data(buf, 0440, net->proc_net, &xt_table_seq_ops,
1794 (void *)(unsigned long)af); 1781 sizeof(struct seq_net_private),
1782 (void *)(unsigned long)af);
1795 if (!proc) 1783 if (!proc)
1796 goto out; 1784 goto out;
1797 if (uid_valid(root_uid) && gid_valid(root_gid)) 1785 if (uid_valid(root_uid) && gid_valid(root_gid))
diff --git a/net/netlink/af_netlink.c b/net/netlink/af_netlink.c
index 2e2dd88fc79f..393573a99a5a 100644
--- a/net/netlink/af_netlink.c
+++ b/net/netlink/af_netlink.c
@@ -2635,21 +2635,6 @@ static const struct seq_operations netlink_seq_ops = {
2635 .stop = netlink_seq_stop, 2635 .stop = netlink_seq_stop,
2636 .show = netlink_seq_show, 2636 .show = netlink_seq_show,
2637}; 2637};
2638
2639
2640static int netlink_seq_open(struct inode *inode, struct file *file)
2641{
2642 return seq_open_net(inode, file, &netlink_seq_ops,
2643 sizeof(struct nl_seq_iter));
2644}
2645
2646static const struct file_operations netlink_seq_fops = {
2647 .open = netlink_seq_open,
2648 .read = seq_read,
2649 .llseek = seq_lseek,
2650 .release = seq_release_net,
2651};
2652
2653#endif 2638#endif
2654 2639
2655int netlink_register_notifier(struct notifier_block *nb) 2640int netlink_register_notifier(struct notifier_block *nb)
@@ -2694,7 +2679,8 @@ static const struct net_proto_family netlink_family_ops = {
2694static int __net_init netlink_net_init(struct net *net) 2679static int __net_init netlink_net_init(struct net *net)
2695{ 2680{
2696#ifdef CONFIG_PROC_FS 2681#ifdef CONFIG_PROC_FS
2697 if (!proc_create("netlink", 0, net->proc_net, &netlink_seq_fops)) 2682 if (!proc_create_net("netlink", 0, net->proc_net, &netlink_seq_ops,
2683 sizeof(struct nl_seq_iter)))
2698 return -ENOMEM; 2684 return -ENOMEM;
2699#endif 2685#endif
2700 return 0; 2686 return 0;
diff --git a/net/packet/af_packet.c b/net/packet/af_packet.c
index 01f3515cada0..833e65252f1f 100644
--- a/net/packet/af_packet.c
+++ b/net/packet/af_packet.c
@@ -4554,20 +4554,6 @@ static const struct seq_operations packet_seq_ops = {
4554 .stop = packet_seq_stop, 4554 .stop = packet_seq_stop,
4555 .show = packet_seq_show, 4555 .show = packet_seq_show,
4556}; 4556};
4557
4558static int packet_seq_open(struct inode *inode, struct file *file)
4559{
4560 return seq_open_net(inode, file, &packet_seq_ops,
4561 sizeof(struct seq_net_private));
4562}
4563
4564static const struct file_operations packet_seq_fops = {
4565 .open = packet_seq_open,
4566 .read = seq_read,
4567 .llseek = seq_lseek,
4568 .release = seq_release_net,
4569};
4570
4571#endif 4557#endif
4572 4558
4573static int __net_init packet_net_init(struct net *net) 4559static int __net_init packet_net_init(struct net *net)
@@ -4575,7 +4561,8 @@ static int __net_init packet_net_init(struct net *net)
4575 mutex_init(&net->packet.sklist_lock); 4561 mutex_init(&net->packet.sklist_lock);
4576 INIT_HLIST_HEAD(&net->packet.sklist); 4562 INIT_HLIST_HEAD(&net->packet.sklist);
4577 4563
4578 if (!proc_create("packet", 0, net->proc_net, &packet_seq_fops)) 4564 if (!proc_create_net("packet", 0, net->proc_net, &packet_seq_ops,
4565 sizeof(struct seq_net_private)))
4579 return -ENOMEM; 4566 return -ENOMEM;
4580 4567
4581 return 0; 4568 return 0;
diff --git a/net/phonet/pn_dev.c b/net/phonet/pn_dev.c
index 77787512fc32..6cb4f602ab71 100644
--- a/net/phonet/pn_dev.c
+++ b/net/phonet/pn_dev.c
@@ -320,7 +320,8 @@ static int __net_init phonet_init_net(struct net *net)
320{ 320{
321 struct phonet_net *pnn = phonet_pernet(net); 321 struct phonet_net *pnn = phonet_pernet(net);
322 322
323 if (!proc_create("phonet", 0, net->proc_net, &pn_sock_seq_fops)) 323 if (!proc_create_net("phonet", 0, net->proc_net, &pn_sock_seq_ops,
324 sizeof(struct seq_net_private)))
324 return -ENOMEM; 325 return -ENOMEM;
325 326
326 INIT_LIST_HEAD(&pnn->pndevs.list); 327 INIT_LIST_HEAD(&pnn->pndevs.list);
@@ -351,7 +352,8 @@ int __init phonet_device_init(void)
351 if (err) 352 if (err)
352 return err; 353 return err;
353 354
354 proc_create("pnresource", 0, init_net.proc_net, &pn_res_seq_fops); 355 proc_create_net("pnresource", 0, init_net.proc_net, &pn_res_seq_ops,
356 sizeof(struct seq_net_private));
355 register_netdevice_notifier(&phonet_device_notifier); 357 register_netdevice_notifier(&phonet_device_notifier);
356 err = phonet_netlink_register(); 358 err = phonet_netlink_register();
357 if (err) 359 if (err)
diff --git a/net/phonet/socket.c b/net/phonet/socket.c
index f9b40e6a18a5..30187990257f 100644
--- a/net/phonet/socket.c
+++ b/net/phonet/socket.c
@@ -620,25 +620,12 @@ static int pn_sock_seq_show(struct seq_file *seq, void *v)
620 return 0; 620 return 0;
621} 621}
622 622
623static const struct seq_operations pn_sock_seq_ops = { 623const struct seq_operations pn_sock_seq_ops = {
624 .start = pn_sock_seq_start, 624 .start = pn_sock_seq_start,
625 .next = pn_sock_seq_next, 625 .next = pn_sock_seq_next,
626 .stop = pn_sock_seq_stop, 626 .stop = pn_sock_seq_stop,
627 .show = pn_sock_seq_show, 627 .show = pn_sock_seq_show,
628}; 628};
629
630static int pn_sock_open(struct inode *inode, struct file *file)
631{
632 return seq_open_net(inode, file, &pn_sock_seq_ops,
633 sizeof(struct seq_net_private));
634}
635
636const struct file_operations pn_sock_seq_fops = {
637 .open = pn_sock_open,
638 .read = seq_read,
639 .llseek = seq_lseek,
640 .release = seq_release_net,
641};
642#endif 629#endif
643 630
644static struct { 631static struct {
@@ -802,23 +789,10 @@ static int pn_res_seq_show(struct seq_file *seq, void *v)
802 return 0; 789 return 0;
803} 790}
804 791
805static const struct seq_operations pn_res_seq_ops = { 792const struct seq_operations pn_res_seq_ops = {
806 .start = pn_res_seq_start, 793 .start = pn_res_seq_start,
807 .next = pn_res_seq_next, 794 .next = pn_res_seq_next,
808 .stop = pn_res_seq_stop, 795 .stop = pn_res_seq_stop,
809 .show = pn_res_seq_show, 796 .show = pn_res_seq_show,
810}; 797};
811
812static int pn_res_open(struct inode *inode, struct file *file)
813{
814 return seq_open_net(inode, file, &pn_res_seq_ops,
815 sizeof(struct seq_net_private));
816}
817
818const struct file_operations pn_res_seq_fops = {
819 .open = pn_res_open,
820 .read = seq_read,
821 .llseek = seq_lseek,
822 .release = seq_release_net,
823};
824#endif 798#endif
diff --git a/net/rxrpc/ar-internal.h b/net/rxrpc/ar-internal.h
index 19975d2ca9a2..29923ec2189c 100644
--- a/net/rxrpc/ar-internal.h
+++ b/net/rxrpc/ar-internal.h
@@ -1051,8 +1051,8 @@ void __rxrpc_queue_peer_error(struct rxrpc_peer *);
1051/* 1051/*
1052 * proc.c 1052 * proc.c
1053 */ 1053 */
1054extern const struct file_operations rxrpc_call_seq_fops; 1054extern const struct seq_operations rxrpc_call_seq_ops;
1055extern const struct file_operations rxrpc_connection_seq_fops; 1055extern const struct seq_operations rxrpc_connection_seq_ops;
1056 1056
1057/* 1057/*
1058 * recvmsg.c 1058 * recvmsg.c
diff --git a/net/rxrpc/net_ns.c b/net/rxrpc/net_ns.c
index c7a023fb22d0..5d6a773db973 100644
--- a/net/rxrpc/net_ns.c
+++ b/net/rxrpc/net_ns.c
@@ -97,8 +97,11 @@ static __net_init int rxrpc_init_net(struct net *net)
97 if (!rxnet->proc_net) 97 if (!rxnet->proc_net)
98 goto err_proc; 98 goto err_proc;
99 99
100 proc_create("calls", 0444, rxnet->proc_net, &rxrpc_call_seq_fops); 100 proc_create_net("calls", 0444, rxnet->proc_net, &rxrpc_call_seq_ops,
101 proc_create("conns", 0444, rxnet->proc_net, &rxrpc_connection_seq_fops); 101 sizeof(struct seq_net_private));
102 proc_create_net("conns", 0444, rxnet->proc_net,
103 &rxrpc_connection_seq_ops,
104 sizeof(struct seq_net_private));
102 return 0; 105 return 0;
103 106
104err_proc: 107err_proc:
diff --git a/net/rxrpc/proc.c b/net/rxrpc/proc.c
index 7e45db058823..d9fca8c4bcdc 100644
--- a/net/rxrpc/proc.c
+++ b/net/rxrpc/proc.c
@@ -115,26 +115,13 @@ static int rxrpc_call_seq_show(struct seq_file *seq, void *v)
115 return 0; 115 return 0;
116} 116}
117 117
118static const struct seq_operations rxrpc_call_seq_ops = { 118const struct seq_operations rxrpc_call_seq_ops = {
119 .start = rxrpc_call_seq_start, 119 .start = rxrpc_call_seq_start,
120 .next = rxrpc_call_seq_next, 120 .next = rxrpc_call_seq_next,
121 .stop = rxrpc_call_seq_stop, 121 .stop = rxrpc_call_seq_stop,
122 .show = rxrpc_call_seq_show, 122 .show = rxrpc_call_seq_show,
123}; 123};
124 124
125static int rxrpc_call_seq_open(struct inode *inode, struct file *file)
126{
127 return seq_open_net(inode, file, &rxrpc_call_seq_ops,
128 sizeof(struct seq_net_private));
129}
130
131const struct file_operations rxrpc_call_seq_fops = {
132 .open = rxrpc_call_seq_open,
133 .read = seq_read,
134 .llseek = seq_lseek,
135 .release = seq_release,
136};
137
138/* 125/*
139 * generate a list of extant virtual connections in /proc/net/rxrpc_conns 126 * generate a list of extant virtual connections in /proc/net/rxrpc_conns
140 */ 127 */
@@ -207,23 +194,9 @@ print:
207 return 0; 194 return 0;
208} 195}
209 196
210static const struct seq_operations rxrpc_connection_seq_ops = { 197const struct seq_operations rxrpc_connection_seq_ops = {
211 .start = rxrpc_connection_seq_start, 198 .start = rxrpc_connection_seq_start,
212 .next = rxrpc_connection_seq_next, 199 .next = rxrpc_connection_seq_next,
213 .stop = rxrpc_connection_seq_stop, 200 .stop = rxrpc_connection_seq_stop,
214 .show = rxrpc_connection_seq_show, 201 .show = rxrpc_connection_seq_show,
215}; 202};
216
217
218static int rxrpc_connection_seq_open(struct inode *inode, struct file *file)
219{
220 return seq_open_net(inode, file, &rxrpc_connection_seq_ops,
221 sizeof(struct seq_net_private));
222}
223
224const struct file_operations rxrpc_connection_seq_fops = {
225 .open = rxrpc_connection_seq_open,
226 .read = seq_read,
227 .llseek = seq_lseek,
228 .release = seq_release,
229};
diff --git a/net/sctp/proc.c b/net/sctp/proc.c
index 1d9ccc6dab2b..009c185b71eb 100644
--- a/net/sctp/proc.c
+++ b/net/sctp/proc.c
@@ -225,21 +225,6 @@ static const struct seq_operations sctp_eps_ops = {
225 .show = sctp_eps_seq_show, 225 .show = sctp_eps_seq_show,
226}; 226};
227 227
228
229/* Initialize the seq file operations for 'eps' object. */
230static int sctp_eps_seq_open(struct inode *inode, struct file *file)
231{
232 return seq_open_net(inode, file, &sctp_eps_ops,
233 sizeof(struct seq_net_private));
234}
235
236static const struct file_operations sctp_eps_seq_fops = {
237 .open = sctp_eps_seq_open,
238 .read = seq_read,
239 .llseek = seq_lseek,
240 .release = seq_release_net,
241};
242
243struct sctp_ht_iter { 228struct sctp_ht_iter {
244 struct seq_net_private p; 229 struct seq_net_private p;
245 struct rhashtable_iter hti; 230 struct rhashtable_iter hti;
@@ -338,20 +323,6 @@ static const struct seq_operations sctp_assoc_ops = {
338 .show = sctp_assocs_seq_show, 323 .show = sctp_assocs_seq_show,
339}; 324};
340 325
341/* Initialize the seq file operations for 'assocs' object. */
342static int sctp_assocs_seq_open(struct inode *inode, struct file *file)
343{
344 return seq_open_net(inode, file, &sctp_assoc_ops,
345 sizeof(struct sctp_ht_iter));
346}
347
348static const struct file_operations sctp_assocs_seq_fops = {
349 .open = sctp_assocs_seq_open,
350 .read = seq_read,
351 .llseek = seq_lseek,
352 .release = seq_release_net,
353};
354
355static int sctp_remaddr_seq_show(struct seq_file *seq, void *v) 326static int sctp_remaddr_seq_show(struct seq_file *seq, void *v)
356{ 327{
357 struct sctp_association *assoc; 328 struct sctp_association *assoc;
@@ -431,19 +402,6 @@ static const struct seq_operations sctp_remaddr_ops = {
431 .show = sctp_remaddr_seq_show, 402 .show = sctp_remaddr_seq_show,
432}; 403};
433 404
434static int sctp_remaddr_seq_open(struct inode *inode, struct file *file)
435{
436 return seq_open_net(inode, file, &sctp_remaddr_ops,
437 sizeof(struct sctp_ht_iter));
438}
439
440static const struct file_operations sctp_remaddr_seq_fops = {
441 .open = sctp_remaddr_seq_open,
442 .read = seq_read,
443 .llseek = seq_lseek,
444 .release = seq_release_net,
445};
446
447/* Set up the proc fs entry for the SCTP protocol. */ 405/* Set up the proc fs entry for the SCTP protocol. */
448int __net_init sctp_proc_init(struct net *net) 406int __net_init sctp_proc_init(struct net *net)
449{ 407{
@@ -453,14 +411,14 @@ int __net_init sctp_proc_init(struct net *net)
453 if (!proc_create("snmp", 0444, net->sctp.proc_net_sctp, 411 if (!proc_create("snmp", 0444, net->sctp.proc_net_sctp,
454 &sctp_snmp_seq_fops)) 412 &sctp_snmp_seq_fops))
455 goto cleanup; 413 goto cleanup;
456 if (!proc_create("eps", 0444, net->sctp.proc_net_sctp, 414 if (!proc_create_net("eps", 0444, net->sctp.proc_net_sctp,
457 &sctp_eps_seq_fops)) 415 &sctp_eps_ops, sizeof(struct seq_net_private)))
458 goto cleanup; 416 goto cleanup;
459 if (!proc_create("assocs", 0444, net->sctp.proc_net_sctp, 417 if (!proc_create_net("assocs", 0444, net->sctp.proc_net_sctp,
460 &sctp_assocs_seq_fops)) 418 &sctp_assoc_ops, sizeof(struct sctp_ht_iter)))
461 goto cleanup; 419 goto cleanup;
462 if (!proc_create("remaddr", 0444, net->sctp.proc_net_sctp, 420 if (!proc_create_net("remaddr", 0444, net->sctp.proc_net_sctp,
463 &sctp_remaddr_seq_fops)) 421 &sctp_remaddr_ops, sizeof(struct sctp_ht_iter)))
464 goto cleanup; 422 goto cleanup;
465 return 0; 423 return 0;
466 424
diff --git a/net/unix/af_unix.c b/net/unix/af_unix.c
index 68bb70a62afe..e5473c03d667 100644
--- a/net/unix/af_unix.c
+++ b/net/unix/af_unix.c
@@ -2852,20 +2852,6 @@ static const struct seq_operations unix_seq_ops = {
2852 .stop = unix_seq_stop, 2852 .stop = unix_seq_stop,
2853 .show = unix_seq_show, 2853 .show = unix_seq_show,
2854}; 2854};
2855
2856static int unix_seq_open(struct inode *inode, struct file *file)
2857{
2858 return seq_open_net(inode, file, &unix_seq_ops,
2859 sizeof(struct seq_net_private));
2860}
2861
2862static const struct file_operations unix_seq_fops = {
2863 .open = unix_seq_open,
2864 .read = seq_read,
2865 .llseek = seq_lseek,
2866 .release = seq_release_net,
2867};
2868
2869#endif 2855#endif
2870 2856
2871static const struct net_proto_family unix_family_ops = { 2857static const struct net_proto_family unix_family_ops = {
@@ -2884,7 +2870,8 @@ static int __net_init unix_net_init(struct net *net)
2884 goto out; 2870 goto out;
2885 2871
2886#ifdef CONFIG_PROC_FS 2872#ifdef CONFIG_PROC_FS
2887 if (!proc_create("unix", 0, net->proc_net, &unix_seq_fops)) { 2873 if (!proc_create_net("unix", 0, net->proc_net, &unix_seq_ops,
2874 sizeof(struct seq_net_private))) {
2888 unix_sysctl_unregister(net); 2875 unix_sysctl_unregister(net);
2889 goto out; 2876 goto out;
2890 } 2877 }
diff --git a/net/wireless/wext-proc.c b/net/wireless/wext-proc.c
index b4c464594a5e..cadcf8613af2 100644
--- a/net/wireless/wext-proc.c
+++ b/net/wireless/wext-proc.c
@@ -126,24 +126,11 @@ static const struct seq_operations wireless_seq_ops = {
126 .show = wireless_dev_seq_show, 126 .show = wireless_dev_seq_show,
127}; 127};
128 128
129static int seq_open_wireless(struct inode *inode, struct file *file)
130{
131 return seq_open_net(inode, file, &wireless_seq_ops,
132 sizeof(struct seq_net_private));
133}
134
135static const struct file_operations wireless_seq_fops = {
136 .open = seq_open_wireless,
137 .read = seq_read,
138 .llseek = seq_lseek,
139 .release = seq_release_net,
140};
141
142int __net_init wext_proc_init(struct net *net) 129int __net_init wext_proc_init(struct net *net)
143{ 130{
144 /* Create /proc/net/wireless entry */ 131 /* Create /proc/net/wireless entry */
145 if (!proc_create("wireless", 0444, net->proc_net, 132 if (!proc_create_net("wireless", 0444, net->proc_net,
146 &wireless_seq_fops)) 133 &wireless_seq_ops, sizeof(struct seq_net_private)))
147 return -ENOMEM; 134 return -ENOMEM;
148 135
149 return 0; 136 return 0;
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-21 22:44:13 -0500