ipv{4,6}/udp{,lite}: simplify proc registration

Remove a couple indirections to make the code look like most other
protocols.

Signed-off-by: Christoph Hellwig <hch@lst.de>

diff --git a/include/net/udp.h b/include/net/udp.h
index 0676b272f6ac8bf91d07f18b7f75e39481a47eaa..093cd323f66a915ee37bcc94676a9014bd0d3fa9 100644 (file)
--- a/include/net/udp.h
+++ b/include/net/udp.h
@@ -408,31 +408,27 @@ do {                                                                      \
 #define __UDPX_INC_STATS(sk, field) __UDP_INC_STATS(sock_net(sk), field, 0)
 #endif
 
-/* /proc */
-int udp_seq_open(struct inode *inode, struct file *file);
-
+#ifdef CONFIG_PROC_FS
 struct udp_seq_afinfo {
-       char                            *name;
        sa_family_t                     family;
        struct udp_table                *udp_table;
-       const struct file_operations    *seq_fops;
-       struct seq_operations           seq_ops;
 };
 
 struct udp_iter_state {
        struct seq_net_private  p;
-       sa_family_t             family;
        int                     bucket;
-       struct udp_table        *udp_table;
 };
 
-#ifdef CONFIG_PROC_FS
-int udp_proc_register(struct net *net, struct udp_seq_afinfo *afinfo);
-void udp_proc_unregister(struct net *net, struct udp_seq_afinfo *afinfo);
+void *udp_seq_start(struct seq_file *seq, loff_t *pos);
+void *udp_seq_next(struct seq_file *seq, void *v, loff_t *pos);
+void udp_seq_stop(struct seq_file *seq, void *v);
+
+extern const struct file_operations udp_afinfo_seq_fops;
+extern const struct file_operations udp6_afinfo_seq_fops;
 
 int udp4_proc_init(void);
 void udp4_proc_exit(void);
-#endif
+#endif /* CONFIG_PROC_FS */
 
 int udpv4_offload_init(void);
 

diff --git a/net/ipv4/udp.c b/net/ipv4/udp.c
index b61a770884fa81a92fb503adb08299677a322498..51559a8c6e57bbf4e92a4c0e0c22a04b7b1f6b81 100644 (file)
--- a/net/ipv4/udp.c
+++ b/net/ipv4/udp.c
@@ -2582,12 +2582,13 @@ EXPORT_SYMBOL(udp_prot);
 static struct sock *udp_get_first(struct seq_file *seq, int start)
 {
        struct sock *sk;
+       struct udp_seq_afinfo *afinfo = PDE_DATA(file_inode(seq->file));
        struct udp_iter_state *state = seq->private;
        struct net *net = seq_file_net(seq);
 
-       for (state->bucket = start; state->bucket <= state->udp_table->mask;
+       for (state->bucket = start; state->bucket <= afinfo->udp_table->mask;
             ++state->bucket) {
-               struct udp_hslot *hslot = &state->udp_table->hash[state->bucket];
+               struct udp_hslot *hslot = &afinfo->udp_table->hash[state->bucket];
 
                if (hlist_empty(&hslot->head))
                        continue;
@@ -2596,7 +2597,7 @@ static struct sock *udp_get_first(struct seq_file *seq, int start)
                sk_for_each(sk, &hslot->head) {
                        if (!net_eq(sock_net(sk), net))
                                continue;
-                       if (sk->sk_family == state->family)
+                       if (sk->sk_family == afinfo->family)
                                goto found;
                }
                spin_unlock_bh(&hslot->lock);
@@ -2608,16 +2609,17 @@ found:
 
 static struct sock *udp_get_next(struct seq_file *seq, struct sock *sk)
 {
+       struct udp_seq_afinfo *afinfo = PDE_DATA(file_inode(seq->file));
        struct udp_iter_state *state = seq->private;
        struct net *net = seq_file_net(seq);
 
        do {
                sk = sk_next(sk);
-       } while (sk && (!net_eq(sock_net(sk), net) || sk->sk_family != state->family));
+       } while (sk && (!net_eq(sock_net(sk), net) || sk->sk_family != afinfo->family));
 
        if (!sk) {
-               if (state->bucket <= state->udp_table->mask)
-                       spin_unlock_bh(&state->udp_table->hash[state->bucket].lock);
+               if (state->bucket <= afinfo->udp_table->mask)
+                       spin_unlock_bh(&afinfo->udp_table->hash[state->bucket].lock);
                return udp_get_first(seq, state->bucket + 1);
        }
        return sk;
@@ -2633,15 +2635,16 @@ static struct sock *udp_get_idx(struct seq_file *seq, loff_t pos)
        return pos ? NULL : sk;
 }
 
-static void *udp_seq_start(struct seq_file *seq, loff_t *pos)
+void *udp_seq_start(struct seq_file *seq, loff_t *pos)
 {
        struct udp_iter_state *state = seq->private;
        state->bucket = MAX_UDP_PORTS;
 
        return *pos ? udp_get_idx(seq, *pos-1) : SEQ_START_TOKEN;
 }
+EXPORT_SYMBOL(udp_seq_start);
 
-static void *udp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
+void *udp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 {
        struct sock *sk;
 
@@ -2653,56 +2656,17 @@ static void *udp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
        ++*pos;
        return sk;
 }
+EXPORT_SYMBOL(udp_seq_next);
 
-static void udp_seq_stop(struct seq_file *seq, void *v)
+void udp_seq_stop(struct seq_file *seq, void *v)
 {
+       struct udp_seq_afinfo *afinfo = PDE_DATA(file_inode(seq->file));
        struct udp_iter_state *state = seq->private;
 
-       if (state->bucket <= state->udp_table->mask)
-               spin_unlock_bh(&state->udp_table->hash[state->bucket].lock);
+       if (state->bucket <= afinfo->udp_table->mask)
+               spin_unlock_bh(&afinfo->udp_table->hash[state->bucket].lock);
 }
-
-int udp_seq_open(struct inode *inode, struct file *file)
-{
-       struct udp_seq_afinfo *afinfo = PDE_DATA(inode);
-       struct udp_iter_state *s;
-       int err;
-
-       err = seq_open_net(inode, file, &afinfo->seq_ops,
-                          sizeof(struct udp_iter_state));
-       if (err < 0)
-               return err;
-
-       s = ((struct seq_file *)file->private_data)->private;
-       s->family               = afinfo->family;
-       s->udp_table            = afinfo->udp_table;
-       return err;
-}
-EXPORT_SYMBOL(udp_seq_open);
-
-/* ------------------------------------------------------------------------ */
-int udp_proc_register(struct net *net, struct udp_seq_afinfo *afinfo)
-{
-       struct proc_dir_entry *p;
-       int rc = 0;
-
-       afinfo->seq_ops.start           = udp_seq_start;
-       afinfo->seq_ops.next            = udp_seq_next;
-       afinfo->seq_ops.stop            = udp_seq_stop;
-
-       p = proc_create_data(afinfo->name, 0444, net->proc_net,
-                            afinfo->seq_fops, afinfo);
-       if (!p)
-               rc = -ENOMEM;
-       return rc;
-}
-EXPORT_SYMBOL(udp_proc_register);
-
-void udp_proc_unregister(struct net *net, struct udp_seq_afinfo *afinfo)
-{
-       remove_proc_entry(afinfo->name, net->proc_net);
-}
-EXPORT_SYMBOL(udp_proc_unregister);
+EXPORT_SYMBOL(udp_seq_stop);
 
 /* ------------------------------------------------------------------------ */
 static void udp4_format_sock(struct sock *sp, struct seq_file *f,
@@ -2742,32 +2706,43 @@ int udp4_seq_show(struct seq_file *seq, void *v)
        return 0;
 }
 
-static const struct file_operations udp_afinfo_seq_fops = {
+static const struct seq_operations udp_seq_ops = {
+       .start          = udp_seq_start,
+       .next           = udp_seq_next,
+       .stop           = udp_seq_stop,
+       .show           = udp4_seq_show,
+};
+
+static int udp_seq_open(struct inode *inode, struct file *file)
+{
+       return seq_open_net(inode, file, &udp_seq_ops,
+                       sizeof(struct udp_iter_state));
+}
+
+const struct file_operations udp_afinfo_seq_fops = {
        .open     = udp_seq_open,
        .read     = seq_read,
        .llseek   = seq_lseek,
        .release  = seq_release_net
 };
+EXPORT_SYMBOL(udp_afinfo_seq_fops);
 
-/* ------------------------------------------------------------------------ */
 static struct udp_seq_afinfo udp4_seq_afinfo = {
-       .name           = "udp",
        .family         = AF_INET,
        .udp_table      = &udp_table,
-       .seq_fops       = &udp_afinfo_seq_fops,
-       .seq_ops        = {
-               .show           = udp4_seq_show,
-       },
 };
 
 static int __net_init udp4_proc_init_net(struct net *net)
 {
-       return udp_proc_register(net, &udp4_seq_afinfo);
+       if (!proc_create_data("udp", 0444, net->proc_net, &udp_afinfo_seq_fops,
+                       &udp4_seq_afinfo))
+               return -ENOMEM;
+       return 0;
 }
 
 static void __net_exit udp4_proc_exit_net(struct net *net)
 {
-       udp_proc_unregister(net, &udp4_seq_afinfo);
+       remove_proc_entry("udp", net->proc_net);
 }
 
 static struct pernet_operations udp4_net_ops = {

diff --git a/net/ipv4/udplite.c b/net/ipv4/udplite.c
index f96614e9b9a5d866e6ed01f7624f097c408a84ce..4a6e67bfbe0dbcc10cfe5c73f12c2e1b503ce106 100644 (file)
--- a/net/ipv4/udplite.c
+++ b/net/ipv4/udplite.c
@@ -14,6 +14,7 @@
 #define pr_fmt(fmt) "UDPLite: " fmt
 
 #include <linux/export.h>
+#include <linux/proc_fs.h>
 #include "udp_impl.h"
 
 struct udp_table       udplite_table __read_mostly;
@@ -73,32 +74,22 @@ static struct inet_protosw udplite4_protosw = {
 };
 
 #ifdef CONFIG_PROC_FS
-
-static const struct file_operations udplite_afinfo_seq_fops = {
-       .open     = udp_seq_open,
-       .read     = seq_read,
-       .llseek   = seq_lseek,
-       .release  = seq_release_net
-};
-
 static struct udp_seq_afinfo udplite4_seq_afinfo = {
-       .name           = "udplite",
        .family         = AF_INET,
        .udp_table      = &udplite_table,
-       .seq_fops       = &udplite_afinfo_seq_fops,
-       .seq_ops        = {
-               .show           = udp4_seq_show,
-       },
 };
 
 static int __net_init udplite4_proc_init_net(struct net *net)
 {
-       return udp_proc_register(net, &udplite4_seq_afinfo);
+       if (!proc_create_data("udplite", 0444, net->proc_net,
+                       &udp_afinfo_seq_fops, &udplite4_seq_afinfo))
+               return -ENOMEM;
+       return 0;
 }
 
 static void __net_exit udplite4_proc_exit_net(struct net *net)
 {
-       udp_proc_unregister(net, &udplite4_seq_afinfo);
+       remove_proc_entry("udplite", net->proc_net);
 }
 
 static struct pernet_operations udplite4_net_ops = {

diff --git a/net/ipv6/udp.c b/net/ipv6/udp.c
index ea0730028e5d6fb386094590ab5c45233835de7b..29adddeac3e5be8fec022311fef001e354df6f3c 100644 (file)
--- a/net/ipv6/udp.c
+++ b/net/ipv6/udp.c
@@ -1480,31 +1480,43 @@ int udp6_seq_show(struct seq_file *seq, void *v)
        return 0;
 }
 
-static const struct file_operations udp6_afinfo_seq_fops = {
-       .open     = udp_seq_open,
+static const struct seq_operations udp6_seq_ops = {
+       .start          = udp_seq_start,
+       .next           = udp_seq_next,
+       .stop           = udp_seq_stop,
+       .show           = udp6_seq_show,
+};
+
+static int udp6_seq_open(struct inode *inode, struct file *file)
+{
+       return seq_open_net(inode, file, &udp6_seq_ops,
+                       sizeof(struct udp_iter_state));
+}
+
+const struct file_operations udp6_afinfo_seq_fops = {
+       .open     = udp6_seq_open,
        .read     = seq_read,
        .llseek   = seq_lseek,
        .release  = seq_release_net
 };
+EXPORT_SYMBOL(udp6_afinfo_seq_fops);
 
 static struct udp_seq_afinfo udp6_seq_afinfo = {
-       .name           = "udp6",
        .family         = AF_INET6,
        .udp_table      = &udp_table,
-       .seq_fops       = &udp6_afinfo_seq_fops,
-       .seq_ops        = {
-               .show           = udp6_seq_show,
-       },
 };
 
 int __net_init udp6_proc_init(struct net *net)
 {
-       return udp_proc_register(net, &udp6_seq_afinfo);
+       if (!proc_create_data("udp6", 0444, net->proc_net,
+                       &udp6_afinfo_seq_fops, &udp6_seq_afinfo))
+               return -ENOMEM;
+       return 0;
 }
 
 void udp6_proc_exit(struct net *net)
 {
-       udp_proc_unregister(net, &udp6_seq_afinfo);
+       remove_proc_entry("udp6", net->proc_net);
 }
 #endif /* CONFIG_PROC_FS */
 

diff --git a/net/ipv6/udplite.c b/net/ipv6/udplite.c
index 14ae32bb1f3da2bcc4ac1ba51042482cae1132ca..a119e57196b5276fefb3f4328525543ba4bb2f36 100644 (file)
--- a/net/ipv6/udplite.c
+++ b/net/ipv6/udplite.c
@@ -12,6 +12,7 @@
  *             2 of the License, or (at your option) any later version.
  */
 #include <linux/export.h>
+#include <linux/proc_fs.h>
 #include "udp_impl.h"
 
 static int udplitev6_rcv(struct sk_buff *skb)
@@ -92,32 +93,22 @@ void udplitev6_exit(void)
 }
 
 #ifdef CONFIG_PROC_FS
-
-static const struct file_operations udplite6_afinfo_seq_fops = {
-       .open     = udp_seq_open,
-       .read     = seq_read,
-       .llseek   = seq_lseek,
-       .release  = seq_release_net
-};
-
 static struct udp_seq_afinfo udplite6_seq_afinfo = {
-       .name           = "udplite6",
        .family         = AF_INET6,
        .udp_table      = &udplite_table,
-       .seq_fops       = &udplite6_afinfo_seq_fops,
-       .seq_ops        = {
-               .show           = udp6_seq_show,
-       },
 };
 
 static int __net_init udplite6_proc_init_net(struct net *net)
 {
-       return udp_proc_register(net, &udplite6_seq_afinfo);
+       if (!proc_create_data("udplite6", 0444, net->proc_net,
+                       &udp6_afinfo_seq_fops, &udplite6_seq_afinfo))
+               return -ENOMEM;
+       return 0;
 }
 
 static void __net_exit udplite6_proc_exit_net(struct net *net)
 {
-       udp_proc_unregister(net, &udplite6_seq_afinfo);
+       remove_proc_entry("udplite6", net->proc_net);
 }
 
 static struct pernet_operations udplite6_net_ops = {