Merge branch 'hch.procfs' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs

Pull procfs updates from Al Viro:
 "Christoph's proc_create_... cleanups series"

* 'hch.procfs' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs: (44 commits)
  xfs, proc: hide unused xfs procfs helpers
  isdn/gigaset: add back gigaset_procinfo assignment
  proc: update SIZEOF_PDE_INLINE_NAME for the new pde fields
  tty: replace ->proc_fops with ->proc_show
  ide: replace ->proc_fops with ->proc_show
  ide: remove ide_driver_proc_write
  isdn: replace ->proc_fops with ->proc_show
  atm: switch to proc_create_seq_private
  atm: simplify procfs code
  bluetooth: switch to proc_create_seq_data
  netfilter/x_tables: switch to proc_create_seq_private
  netfilter/xt_hashlimit: switch to proc_create_{seq,single}_data
  neigh: switch to proc_create_seq_data
  hostap: switch to proc_create_{seq,single}_data
  bonding: switch to proc_create_seq_data
  rtc/proc: switch to proc_create_single_data
  drbd: switch to proc_create_single
  resource: switch to proc_create_seq_data
  staging/rtl8192u: simplify procfs code
  jfs: simplify procfs code
  ...

79 files changed, 408 insertions, 2131 deletions

diff --git a/net/8021q/vlanproc.c b/net/8021q/vlanproc.c
index a627a5db2125..d36e8c4b7f56 100644
--- a/net/8021q/vlanproc.c
+++ b/net/8021q/vlanproc.c
@@ -73,35 +73,6 @@ static const struct seq_operations vlan_seq_ops = {
         .show = vlan_seq_show,
 };
 
-static int vlan_seq_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &vlan_seq_ops,
-                        sizeof(struct seq_net_private));
-}
-
-static const struct file_operations vlan_fops = {
-        .open    = vlan_seq_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release_net,
-};
-
-/*
- *      /proc/net/vlan/<device> file and inode operations
- */
-
-static int vlandev_seq_open(struct inode *inode, struct file *file)
-{
-        return single_open(file, vlandev_seq_show, PDE_DATA(inode));
-}
-
-static const struct file_operations vlandev_fops = {
-        .open    = vlandev_seq_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = single_release,
-};
-
 /*
  * Proc filesystem directory entries.
  */
@@ -148,8 +119,9 @@ int __net_init vlan_proc_init(struct net *net)
         if (!vn->proc_vlan_dir)
                 goto err;
 
-        vn->proc_vlan_conf = proc_create(name_conf, S_IFREG | 0600,
-                                         vn->proc_vlan_dir, &vlan_fops);
+        vn->proc_vlan_conf = proc_create_net(name_conf, S_IFREG | 0600,
+                        vn->proc_vlan_dir, &vlan_seq_ops,
+                        sizeof(struct seq_net_private));
         if (!vn->proc_vlan_conf)
                 goto err;
         return 0;
@@ -171,9 +143,8 @@ int vlan_proc_add_dev(struct net_device *vlandev)
 
         if (!strcmp(vlandev->name, name_conf))
                 return -EINVAL;
-        vlan->dent =
-                proc_create_data(vlandev->name, S_IFREG | 0600,
-                                 vn->proc_vlan_dir, &vlandev_fops, vlandev);
+        vlan->dent = proc_create_single_data(vlandev->name, S_IFREG | 0600,
+                        vn->proc_vlan_dir, vlandev_seq_show, vlandev);
         if (!vlan->dent)
                 return -ENOBUFS;
         return 0;
diff --git a/net/appletalk/aarp.c b/net/appletalk/aarp.c
index d4c1021e74e1..49a16cee2aae 100644
--- a/net/appletalk/aarp.c
+++ b/net/appletalk/aarp.c
@@ -907,11 +907,6 @@ void aarp_device_down(struct net_device *dev)
 }
 
 #ifdef CONFIG_PROC_FS
-struct aarp_iter_state {
-        int bucket;
-        struct aarp_entry **table;
-};
-
 /*
  * Get the aarp entry that is in the chain described
  * by the iterator.
@@ -1033,25 +1028,12 @@ static int aarp_seq_show(struct seq_file *seq, void *v)
         return 0;
 }
 
-static const struct seq_operations aarp_seq_ops = {
+const struct seq_operations aarp_seq_ops = {
         .start  = aarp_seq_start,
         .next   = aarp_seq_next,
         .stop   = aarp_seq_stop,
         .show   = aarp_seq_show,
 };
-
-static int aarp_seq_open(struct inode *inode, struct file *file)
-{
-        return seq_open_private(file, &aarp_seq_ops,
-                        sizeof(struct aarp_iter_state));
-}
-
-const struct file_operations atalk_seq_arp_fops = {
-        .open           = aarp_seq_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = seq_release_private,
-};
 #endif
 
 /* General module cleanup. Called from cleanup_module() in ddp.c. */
diff --git a/net/appletalk/atalk_proc.c b/net/appletalk/atalk_proc.c
index 7214aea14cb3..8006295f8bd7 100644
--- a/net/appletalk/atalk_proc.c
+++ b/net/appletalk/atalk_proc.c
@@ -210,42 +210,6 @@ static const struct seq_operations atalk_seq_socket_ops = {
         .show   = atalk_seq_socket_show,
 };
 
-static int atalk_seq_interface_open(struct inode *inode, struct file *file)
-{
-        return seq_open(file, &atalk_seq_interface_ops);
-}
-
-static int atalk_seq_route_open(struct inode *inode, struct file *file)
-{
-        return seq_open(file, &atalk_seq_route_ops);
-}
-
-static int atalk_seq_socket_open(struct inode *inode, struct file *file)
-{
-        return seq_open(file, &atalk_seq_socket_ops);
-}
-
-static const struct file_operations atalk_seq_interface_fops = {
-        .open           = atalk_seq_interface_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = seq_release,
-};
-
-static const struct file_operations atalk_seq_route_fops = {
-        .open           = atalk_seq_route_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = seq_release,
-};
-
-static const struct file_operations atalk_seq_socket_fops = {
-        .open           = atalk_seq_socket_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = seq_release,
-};
-
 static struct proc_dir_entry *atalk_proc_dir;
 
 int __init atalk_proc_init(void)
@@ -257,22 +221,23 @@ int __init atalk_proc_init(void)
         if (!atalk_proc_dir)
                 goto out;
 
-        p = proc_create("interface", 0444, atalk_proc_dir,
-                        &atalk_seq_interface_fops);
+        p = proc_create_seq("interface", 0444, atalk_proc_dir,
+                        &atalk_seq_interface_ops);
         if (!p)
                 goto out_interface;
 
-        p = proc_create("route", 0444, atalk_proc_dir,
-                        &atalk_seq_route_fops);
+        p = proc_create_seq("route", 0444, atalk_proc_dir,
+                        &atalk_seq_route_ops);
         if (!p)
                 goto out_route;
 
-        p = proc_create("socket", 0444, atalk_proc_dir,
-                        &atalk_seq_socket_fops);
+        p = proc_create_seq("socket", 0444, atalk_proc_dir,
+                        &atalk_seq_socket_ops);
         if (!p)
                 goto out_socket;
 
-        p = proc_create("arp", 0444, atalk_proc_dir, &atalk_seq_arp_fops);
+        p = proc_create_seq_private("arp", 0444, atalk_proc_dir, &aarp_seq_ops,
+                        sizeof(struct aarp_iter_state), NULL);
         if (!p)
                 goto out_arp;
 
diff --git a/net/atm/br2684.c b/net/atm/br2684.c
index fd94bea36ee8..36b3adacc0dd 100644
--- a/net/atm/br2684.c
+++ b/net/atm/br2684.c
@@ -818,18 +818,6 @@ static const struct seq_operations br2684_seq_ops = {
         .show = br2684_seq_show,
 };
 
-static int br2684_proc_open(struct inode *inode, struct file *file)
-{
-        return seq_open(file, &br2684_seq_ops);
-}
-
-static const struct file_operations br2684_proc_ops = {
-        .open = br2684_proc_open,
-        .read = seq_read,
-        .llseek = seq_lseek,
-        .release = seq_release,
-};
-
 extern struct proc_dir_entry *atm_proc_root;    /* from proc.c */
 #endif /* CONFIG_PROC_FS */
 
@@ -837,7 +825,7 @@ static int __init br2684_init(void)
 {
 #ifdef CONFIG_PROC_FS
         struct proc_dir_entry *p;
-        p = proc_create("br2684", 0, atm_proc_root, &br2684_proc_ops);
+        p = proc_create_seq("br2684", 0, atm_proc_root, &br2684_seq_ops);
         if (p == NULL)
                 return -ENOMEM;
 #endif
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 = {
         .stop   = neigh_seq_stop,
         .show   = clip_seq_show,
 };
-
-static int arp_seq_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &arp_seq_ops,
-                            sizeof(struct clip_seq_state));
-}
-
-static const struct file_operations arp_seq_fops = {
-        .open           = arp_seq_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = seq_release_net,
-        .owner          = THIS_MODULE
-};
 #endif
 
 static void atm_clip_exit_noproc(void);
@@ -893,7 +879,8 @@ static int __init atm_clip_init(void)
         {
                 struct proc_dir_entry *p;
 
-                p = proc_create("arp", 0444, atm_proc_root, &arp_seq_fops);
+                p = proc_create_net("arp", 0444, atm_proc_root, &arp_seq_ops,
+                                sizeof(struct clip_seq_state));
                 if (!p) {
                         pr_err("Unable to initialize /proc/net/atm/arp\n");
                         atm_clip_exit_noproc();
diff --git a/net/atm/lec.c b/net/atm/lec.c
index 3138a869b5c0..5a95fcf6f9b6 100644
--- a/net/atm/lec.c
+++ b/net/atm/lec.c
@@ -990,18 +990,6 @@ static const struct seq_operations lec_seq_ops = {
         .stop = lec_seq_stop,
         .show = lec_seq_show,
 };
-
-static int lec_seq_open(struct inode *inode, struct file *file)
-{
-        return seq_open_private(file, &lec_seq_ops, sizeof(struct lec_state));
-}
-
-static const struct file_operations lec_seq_fops = {
-        .open = lec_seq_open,
-        .read = seq_read,
-        .llseek = seq_lseek,
-        .release = seq_release_private,
-};
 #endif
 
 static int lane_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
@@ -1047,7 +1035,8 @@ static int __init lane_module_init(void)
 #ifdef CONFIG_PROC_FS
         struct proc_dir_entry *p;
 
-        p = proc_create("lec", 0444, atm_proc_root, &lec_seq_fops);
+        p = proc_create_seq_private("lec", 0444, atm_proc_root, &lec_seq_ops,
+                        sizeof(struct lec_state), NULL);
         if (!p) {
                 pr_err("Unable to initialize /proc/net/atm/lec\n");
                 return -ENOMEM;
diff --git a/net/atm/proc.c b/net/atm/proc.c
index 55410c00c7e2..0b0495a41bbe 100644
--- a/net/atm/proc.c
+++ b/net/atm/proc.c
@@ -68,7 +68,6 @@ static void atm_dev_info(struct seq_file *seq, const struct atm_dev *dev)
 struct vcc_state {
         int bucket;
         struct sock *sk;
-        int family;
 };
 
 static inline int compare_family(struct sock *sk, int family)
@@ -106,23 +105,13 @@ out:
         return (l < 0);
 }
 
-static inline void *vcc_walk(struct vcc_state *state, loff_t l)
+static inline void *vcc_walk(struct seq_file *seq, loff_t l)
 {
-        return __vcc_walk(&state->sk, state->family, &state->bucket, l) ?
-               state : NULL;
-}
-
-static int __vcc_seq_open(struct inode *inode, struct file *file,
-        int family, const struct seq_operations *ops)
-{
-        struct vcc_state *state;
-
-        state = __seq_open_private(file, ops, sizeof(*state));
-        if (state == NULL)
-                return -ENOMEM;
+        struct vcc_state *state = seq->private;
+        int family = (uintptr_t)(PDE_DATA(file_inode(seq->file)));
 
-        state->family = family;
-        return 0;
+        return __vcc_walk(&state->sk, family, &state->bucket, l) ?
+               state : NULL;
 }
 
 static void *vcc_seq_start(struct seq_file *seq, loff_t *pos)
@@ -133,7 +122,7 @@ static void *vcc_seq_start(struct seq_file *seq, loff_t *pos)
 
         read_lock(&vcc_sklist_lock);
         state->sk = SEQ_START_TOKEN;
-        return left ? vcc_walk(state, left) : SEQ_START_TOKEN;
+        return left ? vcc_walk(seq, left) : SEQ_START_TOKEN;
 }
 
 static void vcc_seq_stop(struct seq_file *seq, void *v)
@@ -144,9 +133,7 @@ static void vcc_seq_stop(struct seq_file *seq, void *v)
 
 static void *vcc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 {
-        struct vcc_state *state = seq->private;
-
-        v = vcc_walk(state, 1);
+        v = vcc_walk(seq, 1);
         *pos += !!PTR_ERR(v);
         return v;
 }
@@ -257,18 +244,6 @@ static const struct seq_operations atm_dev_seq_ops = {
         .show   = atm_dev_seq_show,
 };
 
-static int atm_dev_seq_open(struct inode *inode, struct file *file)
-{
-        return seq_open(file, &atm_dev_seq_ops);
-}
-
-static const struct file_operations devices_seq_fops = {
-        .open           = atm_dev_seq_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = seq_release,
-};
-
 static int pvc_seq_show(struct seq_file *seq, void *v)
 {
         static char atm_pvc_banner[] =
@@ -292,18 +267,6 @@ static const struct seq_operations pvc_seq_ops = {
         .show   = pvc_seq_show,
 };
 
-static int pvc_seq_open(struct inode *inode, struct file *file)
-{
-        return __vcc_seq_open(inode, file, PF_ATMPVC, &pvc_seq_ops);
-}
-
-static const struct file_operations pvc_seq_fops = {
-        .open           = pvc_seq_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = seq_release_private,
-};
-
 static int vcc_seq_show(struct seq_file *seq, void *v)
 {
         if (v == SEQ_START_TOKEN) {
@@ -326,18 +289,6 @@ static const struct seq_operations vcc_seq_ops = {
         .show   = vcc_seq_show,
 };
 
-static int vcc_seq_open(struct inode *inode, struct file *file)
-{
-        return __vcc_seq_open(inode, file, 0, &vcc_seq_ops);
-}
-
-static const struct file_operations vcc_seq_fops = {
-        .open           = vcc_seq_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = seq_release_private,
-};
-
 static int svc_seq_show(struct seq_file *seq, void *v)
 {
         static const char atm_svc_banner[] =
@@ -361,18 +312,6 @@ static const struct seq_operations svc_seq_ops = {
         .show   = svc_seq_show,
 };
 
-static int svc_seq_open(struct inode *inode, struct file *file)
-{
-        return __vcc_seq_open(inode, file, PF_ATMSVC, &svc_seq_ops);
-}
-
-static const struct file_operations svc_seq_fops = {
-        .open           = svc_seq_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = seq_release_private,
-};
-
 static ssize_t proc_dev_atm_read(struct file *file, char __user *buf,
                                  size_t count, loff_t *pos)
 {
@@ -440,58 +379,22 @@ void atm_proc_dev_deregister(struct atm_dev *dev)
         kfree(dev->proc_name);
 }
 
-static struct atm_proc_entry {
-        char *name;
-        const struct file_operations *proc_fops;
-        struct proc_dir_entry *dirent;
-} atm_proc_ents[] = {
-        { .name = "devices",    .proc_fops = &devices_seq_fops },
-        { .name = "pvc",        .proc_fops = &pvc_seq_fops },
-        { .name = "svc",        .proc_fops = &svc_seq_fops },
-        { .name = "vc",         .proc_fops = &vcc_seq_fops },
-        { .name = NULL,         .proc_fops = NULL }
-};
-
-static void atm_proc_dirs_remove(void)
-{
-        static struct atm_proc_entry *e;
-
-        for (e = atm_proc_ents; e->name; e++) {
-                if (e->dirent)
-                        remove_proc_entry(e->name, atm_proc_root);
-        }
-        remove_proc_entry("atm", init_net.proc_net);
-}
-
 int __init atm_proc_init(void)
 {
-        static struct atm_proc_entry *e;
-        int ret;
-
         atm_proc_root = proc_net_mkdir(&init_net, "atm", init_net.proc_net);
         if (!atm_proc_root)
-                goto err_out;
-        for (e = atm_proc_ents; e->name; e++) {
-                struct proc_dir_entry *dirent;
-
-                dirent = proc_create(e->name, 0444,
-                                     atm_proc_root, e->proc_fops);
-                if (!dirent)
-                        goto err_out_remove;
-                e->dirent = dirent;
-        }
-        ret = 0;
-out:
-        return ret;
-
-err_out_remove:
-        atm_proc_dirs_remove();
-err_out:
-        ret = -ENOMEM;
-        goto out;
+                return -ENOMEM;
+        proc_create_seq("devices", 0444, atm_proc_root, &atm_dev_seq_ops);
+        proc_create_seq_private("pvc", 0444, atm_proc_root, &pvc_seq_ops,
+                        sizeof(struct vcc_state), (void *)(uintptr_t)PF_ATMPVC);
+        proc_create_seq_private("svc", 0444, atm_proc_root, &svc_seq_ops,
+                        sizeof(struct vcc_state), (void *)(uintptr_t)PF_ATMSVC);
+        proc_create_seq_private("vc", 0444, atm_proc_root, &vcc_seq_ops,
+                        sizeof(struct vcc_state), NULL);
+        return 0;
 }
 
 void atm_proc_exit(void)
 {
-        atm_proc_dirs_remove();
+        remove_proc_subtree("atm", init_net.proc_net);
 }
diff --git a/net/ax25/af_ax25.c b/net/ax25/af_ax25.c
index 2b41366fcad2..c603d33d5410 100644
--- a/net/ax25/af_ax25.c
+++ b/net/ax25/af_ax25.c
@@ -1924,19 +1924,6 @@ static const struct seq_operations ax25_info_seqops = {
         .stop = ax25_info_stop,
         .show = ax25_info_show,
 };
-
-static int ax25_info_open(struct inode *inode, struct file *file)
-{
-        return seq_open(file, &ax25_info_seqops);
-}
-
-static const struct file_operations ax25_info_fops = {
-        .open = ax25_info_open,
-        .read = seq_read,
-        .llseek = seq_lseek,
-        .release = seq_release,
-};
-
 #endif
 
 static const struct net_proto_family ax25_family_ops = {
@@ -1989,10 +1976,10 @@ static int __init ax25_init(void)
         dev_add_pack(&ax25_packet_type);
         register_netdevice_notifier(&ax25_dev_notifier);
 
-        proc_create("ax25_route", 0444, init_net.proc_net,
-                    &ax25_route_fops);
-        proc_create("ax25", 0444, init_net.proc_net, &ax25_info_fops);
-        proc_create("ax25_calls", 0444, init_net.proc_net, &ax25_uid_fops);
+        proc_create_seq("ax25_route", 0444, init_net.proc_net, &ax25_rt_seqops);
+        proc_create_seq("ax25", 0444, init_net.proc_net, &ax25_info_seqops);
+        proc_create_seq("ax25_calls", 0444, init_net.proc_net,
+                        &ax25_uid_seqops);
 out:
         return rc;
 }
diff --git a/net/ax25/ax25_route.c b/net/ax25/ax25_route.c
index 525558972fd9..a0eff323af12 100644
--- a/net/ax25/ax25_route.c
+++ b/net/ax25/ax25_route.c
@@ -323,25 +323,12 @@ static int ax25_rt_seq_show(struct seq_file *seq, void *v)
         return 0;
 }
 
-static const struct seq_operations ax25_rt_seqops = {
+const struct seq_operations ax25_rt_seqops = {
         .start = ax25_rt_seq_start,
         .next = ax25_rt_seq_next,
         .stop = ax25_rt_seq_stop,
         .show = ax25_rt_seq_show,
 };
-
-static int ax25_rt_info_open(struct inode *inode, struct file *file)
-{
-        return seq_open(file, &ax25_rt_seqops);
-}
-
-const struct file_operations ax25_route_fops = {
-        .open = ax25_rt_info_open,
-        .read = seq_read,
-        .llseek = seq_lseek,
-        .release = seq_release,
-};
-
 #endif
 
 /*
diff --git a/net/ax25/ax25_uid.c b/net/ax25/ax25_uid.c
index 4ebe91ba317a..99d02e390e43 100644
--- a/net/ax25/ax25_uid.c
+++ b/net/ax25/ax25_uid.c
@@ -181,25 +181,12 @@ static int ax25_uid_seq_show(struct seq_file *seq, void *v)
         return 0;
 }
 
-static const struct seq_operations ax25_uid_seqops = {
+const struct seq_operations ax25_uid_seqops = {
         .start = ax25_uid_seq_start,
         .next = ax25_uid_seq_next,
         .stop = ax25_uid_seq_stop,
         .show = ax25_uid_seq_show,
 };
-
-static int ax25_uid_info_open(struct inode *inode, struct file *file)
-{
-        return seq_open(file, &ax25_uid_seqops);
-}
-
-const struct file_operations ax25_uid_fops = {
-        .open = ax25_uid_info_open,
-        .read = seq_read,
-        .llseek = seq_lseek,
-        .release = seq_release,
-};
-
 #endif
 
 /*
diff --git a/net/bluetooth/af_bluetooth.c b/net/bluetooth/af_bluetooth.c
index 84d92a077834..3264e1873219 100644
--- a/net/bluetooth/af_bluetooth.c
+++ b/net/bluetooth/af_bluetooth.c
@@ -605,15 +605,10 @@ int bt_sock_wait_ready(struct sock *sk, unsigned long flags)
 EXPORT_SYMBOL(bt_sock_wait_ready);
 
 #ifdef CONFIG_PROC_FS
-struct bt_seq_state {
-        struct bt_sock_list *l;
-};
-
 static void *bt_seq_start(struct seq_file *seq, loff_t *pos)
         __acquires(seq->private->l->lock)
 {
-        struct bt_seq_state *s = seq->private;
-        struct bt_sock_list *l = s->l;
+        struct bt_sock_list *l = PDE_DATA(file_inode(seq->file));
 
         read_lock(&l->lock);
         return seq_hlist_start_head(&l->head, *pos);
@@ -621,8 +616,7 @@ static void *bt_seq_start(struct seq_file *seq, loff_t *pos)
 
 static void *bt_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 {
-        struct bt_seq_state *s = seq->private;
-        struct bt_sock_list *l = s->l;
+        struct bt_sock_list *l = PDE_DATA(file_inode(seq->file));
 
         return seq_hlist_next(v, &l->head, pos);
 }
@@ -630,16 +624,14 @@ static void *bt_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 static void bt_seq_stop(struct seq_file *seq, void *v)
         __releases(seq->private->l->lock)
 {
-        struct bt_seq_state *s = seq->private;
-        struct bt_sock_list *l = s->l;
+        struct bt_sock_list *l = PDE_DATA(file_inode(seq->file));
 
         read_unlock(&l->lock);
 }
 
 static int bt_seq_show(struct seq_file *seq, void *v)
 {
-        struct bt_seq_state *s = seq->private;
-        struct bt_sock_list *l = s->l;
+        struct bt_sock_list *l = PDE_DATA(file_inode(seq->file));
 
         if (v == SEQ_START_TOKEN) {
                 seq_puts(seq ,"sk               RefCnt Rmem   Wmem   User   Inode  Parent");
@@ -681,35 +673,13 @@ static const struct seq_operations bt_seq_ops = {
         .show  = bt_seq_show,
 };
 
-static int bt_seq_open(struct inode *inode, struct file *file)
-{
-        struct bt_sock_list *sk_list;
-        struct bt_seq_state *s;
-
-        sk_list = PDE_DATA(inode);
-        s = __seq_open_private(file, &bt_seq_ops,
-                               sizeof(struct bt_seq_state));
-        if (!s)
-                return -ENOMEM;
-
-        s->l = sk_list;
-        return 0;
-}
-
-static const struct file_operations bt_fops = {
-        .open = bt_seq_open,
-        .read = seq_read,
-        .llseek = seq_lseek,
-        .release = seq_release_private
-};
-
 int bt_procfs_init(struct net *net, const char *name,
                    struct bt_sock_list *sk_list,
                    int (* seq_show)(struct seq_file *, void *))
 {
         sk_list->custom_seq_show = seq_show;
 
-        if (!proc_create_data(name, 0, net->proc_net, &bt_fops, sk_list))
+        if (!proc_create_seq_data(name, 0, net->proc_net, &bt_seq_ops, sk_list))
                 return -ENOMEM;
         return 0;
 }
diff --git a/net/bluetooth/cmtp/capi.c b/net/bluetooth/cmtp/capi.c
index 426a92f02db4..eb41556002e3 100644
--- a/net/bluetooth/cmtp/capi.c
+++ b/net/bluetooth/cmtp/capi.c
@@ -521,18 +521,6 @@ static int cmtp_proc_show(struct seq_file *m, void *v)
         return 0;
 }
 
-static int cmtp_proc_open(struct inode *inode, struct file *file)
-{
-        return single_open(file, cmtp_proc_show, PDE_DATA(inode));
-}
-
-static const struct file_operations cmtp_proc_fops = {
-        .open           = cmtp_proc_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = single_release,
-};
-
 int cmtp_attach_device(struct cmtp_session *session)
 {
         unsigned char buf[4];
@@ -571,7 +559,7 @@ int cmtp_attach_device(struct cmtp_session *session)
         session->ctrl.send_message  = cmtp_send_message;
 
         session->ctrl.procinfo      = cmtp_procinfo;
-        session->ctrl.proc_fops = &cmtp_proc_fops;
+        session->ctrl.proc_show     = cmtp_proc_show;
 
         if (attach_capi_ctr(&session->ctrl) < 0) {
                 BT_ERR("Can't attach new controller");
diff --git a/net/can/bcm.c b/net/can/bcm.c
index ac5e5e34fee3..6ad89f49b341 100644
--- a/net/can/bcm.c
+++ b/net/can/bcm.c
@@ -239,18 +239,6 @@ static int bcm_proc_show(struct seq_file *m, void *v)
         seq_putc(m, '\n');
         return 0;
 }
-
-static int bcm_proc_open(struct inode *inode, struct file *file)
-{
-        return single_open_net(inode, file, bcm_proc_show);
-}
-
-static const struct file_operations bcm_proc_fops = {
-        .open           = bcm_proc_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = single_release,
-};
 #endif /* CONFIG_PROC_FS */
 
 /*
@@ -1606,9 +1594,9 @@ static int bcm_connect(struct socket *sock, struct sockaddr *uaddr, int len,
         if (net->can.bcmproc_dir) {
                 /* unique socket address as filename */
                 sprintf(bo->procname, "%lu", sock_i_ino(sk));
-                bo->bcm_proc_read = proc_create_data(bo->procname, 0644,
+                bo->bcm_proc_read = proc_create_net_single(bo->procname, 0644,
                                                      net->can.bcmproc_dir,
-                                                     &bcm_proc_fops, sk);
+                                                     bcm_proc_show, sk);
                 if (!bo->bcm_proc_read) {
                         ret = -ENOMEM;
                         goto fail;
diff --git a/net/can/proc.c b/net/can/proc.c
index fdf704e9bb8c..70fea17bb04c 100644
--- a/net/can/proc.c
+++ b/net/can/proc.c
@@ -270,18 +270,6 @@ static int can_stats_proc_show(struct seq_file *m, void *v)
         return 0;
 }
 
-static int can_stats_proc_open(struct inode *inode, struct file *file)
-{
-        return single_open_net(inode, file, can_stats_proc_show);
-}
-
-static const struct file_operations can_stats_proc_fops = {
-        .open           = can_stats_proc_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = single_release,
-};
-
 static int can_reset_stats_proc_show(struct seq_file *m, void *v)
 {
         struct net *net = m->private;
@@ -303,36 +291,12 @@ static int can_reset_stats_proc_show(struct seq_file *m, void *v)
         return 0;
 }
 
-static int can_reset_stats_proc_open(struct inode *inode, struct file *file)
-{
-        return single_open_net(inode, file, can_reset_stats_proc_show);
-}
-
-static const struct file_operations can_reset_stats_proc_fops = {
-        .open           = can_reset_stats_proc_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = single_release,
-};
-
 static int can_version_proc_show(struct seq_file *m, void *v)
 {
         seq_printf(m, "%s\n", CAN_VERSION_STRING);
         return 0;
 }
 
-static int can_version_proc_open(struct inode *inode, struct file *file)
-{
-        return single_open_net(inode, file, can_version_proc_show);
-}
-
-static const struct file_operations can_version_proc_fops = {
-        .open           = can_version_proc_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = single_release,
-};
-
 static inline void can_rcvlist_proc_show_one(struct seq_file *m, int idx,
                                              struct net_device *dev,
                                              struct can_dev_rcv_lists *d)
@@ -373,18 +337,6 @@ static int can_rcvlist_proc_show(struct seq_file *m, void *v)
         return 0;
 }
 
-static int can_rcvlist_proc_open(struct inode *inode, struct file *file)
-{
-        return single_open_net(inode, file, can_rcvlist_proc_show);
-}
-
-static const struct file_operations can_rcvlist_proc_fops = {
-        .open           = can_rcvlist_proc_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = single_release,
-};
-
 static inline void can_rcvlist_proc_show_array(struct seq_file *m,
                                                struct net_device *dev,
                                                struct hlist_head *rcv_array,
@@ -440,19 +392,6 @@ static int can_rcvlist_sff_proc_show(struct seq_file *m, void *v)
         return 0;
 }
 
-static int can_rcvlist_sff_proc_open(struct inode *inode, struct file *file)
-{
-        return single_open_net(inode, file, can_rcvlist_sff_proc_show);
-}
-
-static const struct file_operations can_rcvlist_sff_proc_fops = {
-        .open           = can_rcvlist_sff_proc_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = single_release,
-};
-
-
 static int can_rcvlist_eff_proc_show(struct seq_file *m, void *v)
 {
         struct net_device *dev;
@@ -483,18 +422,6 @@ static int can_rcvlist_eff_proc_show(struct seq_file *m, void *v)
         return 0;
 }
 
-static int can_rcvlist_eff_proc_open(struct inode *inode, struct file *file)
-{
-        return single_open_net(inode, file, can_rcvlist_eff_proc_show);
-}
-
-static const struct file_operations can_rcvlist_eff_proc_fops = {
-        .open           = can_rcvlist_eff_proc_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = single_release,
-};
-
 /*
  * can_init_proc - create main CAN proc directory and procfs entries
  */
@@ -510,37 +437,29 @@ void can_init_proc(struct net *net)
         }
 
         /* own procfs entries from the AF_CAN core */
-        net->can.pde_version     = proc_create(CAN_PROC_VERSION, 0644,
-                                               net->can.proc_dir,
-                                               &can_version_proc_fops);
-        net->can.pde_stats       = proc_create(CAN_PROC_STATS, 0644,
-                                               net->can.proc_dir,
-                                               &can_stats_proc_fops);
-        net->can.pde_reset_stats = proc_create(CAN_PROC_RESET_STATS, 0644,
-                                               net->can.proc_dir,
-                                               &can_reset_stats_proc_fops);
-        net->can.pde_rcvlist_err = proc_create_data(CAN_PROC_RCVLIST_ERR, 0644,
-                                                    net->can.proc_dir,
-                                                    &can_rcvlist_proc_fops,
-                                                    (void *)RX_ERR);
-        net->can.pde_rcvlist_all = proc_create_data(CAN_PROC_RCVLIST_ALL, 0644,
-                                                    net->can.proc_dir,
-                                                    &can_rcvlist_proc_fops,
-                                                    (void *)RX_ALL);
-        net->can.pde_rcvlist_fil = proc_create_data(CAN_PROC_RCVLIST_FIL, 0644,
-                                                    net->can.proc_dir,
-                                                    &can_rcvlist_proc_fops,
-                                                    (void *)RX_FIL);
-        net->can.pde_rcvlist_inv = proc_create_data(CAN_PROC_RCVLIST_INV, 0644,
-                                                    net->can.proc_dir,
-                                                    &can_rcvlist_proc_fops,
-                                                    (void *)RX_INV);
-        net->can.pde_rcvlist_eff = proc_create(CAN_PROC_RCVLIST_EFF, 0644,
-                                               net->can.proc_dir,
-                                               &can_rcvlist_eff_proc_fops);
-        net->can.pde_rcvlist_sff = proc_create(CAN_PROC_RCVLIST_SFF, 0644,
-                                               net->can.proc_dir,
-                                               &can_rcvlist_sff_proc_fops);
+        net->can.pde_version = proc_create_net_single(CAN_PROC_VERSION, 0644,
+                        net->can.proc_dir, can_version_proc_show, NULL);
+        net->can.pde_stats = proc_create_net_single(CAN_PROC_STATS, 0644,
+                        net->can.proc_dir, can_stats_proc_show, NULL);
+        net->can.pde_reset_stats = proc_create_net_single(CAN_PROC_RESET_STATS,
+                        0644, net->can.proc_dir, can_reset_stats_proc_show,
+                        NULL);
+        net->can.pde_rcvlist_err = proc_create_net_single(CAN_PROC_RCVLIST_ERR,
+                        0644, net->can.proc_dir, can_rcvlist_proc_show,
+                        (void *)RX_ERR);
+        net->can.pde_rcvlist_all = proc_create_net_single(CAN_PROC_RCVLIST_ALL,
+                        0644, net->can.proc_dir, can_rcvlist_proc_show,
+                        (void *)RX_ALL);
+        net->can.pde_rcvlist_fil = proc_create_net_single(CAN_PROC_RCVLIST_FIL,
+                        0644, net->can.proc_dir, can_rcvlist_proc_show,
+                        (void *)RX_FIL);
+        net->can.pde_rcvlist_inv = proc_create_net_single(CAN_PROC_RCVLIST_INV,
+                        0644, net->can.proc_dir, can_rcvlist_proc_show,
+                        (void *)RX_INV);
+        net->can.pde_rcvlist_eff = proc_create_net_single(CAN_PROC_RCVLIST_EFF,
+                        0644, net->can.proc_dir, can_rcvlist_eff_proc_show, NULL);
+        net->can.pde_rcvlist_sff = proc_create_net_single(CAN_PROC_RCVLIST_SFF,
+                        0644, net->can.proc_dir, can_rcvlist_sff_proc_show, NULL);
 }
 
 /*
diff --git a/net/core/neighbour.c b/net/core/neighbour.c
index ce519861be59..1fb43bff417d 100644
--- a/net/core/neighbour.c
+++ b/net/core/neighbour.c
@@ -59,7 +59,7 @@ static int pneigh_ifdown_and_unlock(struct neigh_table *tbl,
                                     struct net_device *dev);
 
 #ifdef CONFIG_PROC_FS
-static const struct file_operations neigh_stat_seq_fops;
+static const struct seq_operations neigh_stat_seq_ops;
 #endif
 
 /*
@@ -1558,8 +1558,8 @@ void neigh_table_init(int index, struct neigh_table *tbl)
                 panic("cannot create neighbour cache statistics");
 
 #ifdef CONFIG_PROC_FS
-        if (!proc_create_data(tbl->id, 0, init_net.proc_net_stat,
-                              &neigh_stat_seq_fops, tbl))
+        if (!proc_create_seq_data(tbl->id, 0, init_net.proc_net_stat,
+                              &neigh_stat_seq_ops, tbl))
                 panic("cannot create neighbour proc dir entry");
 #endif
 
@@ -2786,7 +2786,7 @@ EXPORT_SYMBOL(neigh_seq_stop);
 
 static void *neigh_stat_seq_start(struct seq_file *seq, loff_t *pos)
 {
-        struct neigh_table *tbl = seq->private;
+        struct neigh_table *tbl = PDE_DATA(file_inode(seq->file));
         int cpu;
 
         if (*pos == 0)
@@ -2803,7 +2803,7 @@ static void *neigh_stat_seq_start(struct seq_file *seq, loff_t *pos)
 
 static void *neigh_stat_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 {
-        struct neigh_table *tbl = seq->private;
+        struct neigh_table *tbl = PDE_DATA(file_inode(seq->file));
         int cpu;
 
         for (cpu = *pos; cpu < nr_cpu_ids; ++cpu) {
@@ -2822,7 +2822,7 @@ static void neigh_stat_seq_stop(struct seq_file *seq, void *v)
 
 static int neigh_stat_seq_show(struct seq_file *seq, void *v)
 {
-        struct neigh_table *tbl = seq->private;
+        struct neigh_table *tbl = PDE_DATA(file_inode(seq->file));
         struct neigh_statistics *st = v;
 
         if (v == SEQ_START_TOKEN) {
@@ -2861,25 +2861,6 @@ static const struct seq_operations neigh_stat_seq_ops = {
         .stop   = neigh_stat_seq_stop,
         .show   = neigh_stat_seq_show,
 };
-
-static int neigh_stat_seq_open(struct inode *inode, struct file *file)
-{
-        int ret = seq_open(file, &neigh_stat_seq_ops);
-
-        if (!ret) {
-                struct seq_file *sf = file->private_data;
-                sf->private = PDE_DATA(inode);
-        }
-        return ret;
-};
-
-static const struct file_operations neigh_stat_seq_fops = {
-        .open    = neigh_stat_seq_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release,
-};
-
 #endif /* CONFIG_PROC_FS */
 
 static inline size_t neigh_nlmsg_size(void)
diff --git a/net/core/net-procfs.c b/net/core/net-procfs.c
index 9737302907b1..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 = {
         .show  = dev_seq_show,
 };
 
-static int dev_seq_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &dev_seq_ops,
-                            sizeof(struct seq_net_private));
-}
-
-static const struct file_operations dev_seq_fops = {
-        .open    = dev_seq_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release_net,
-};
-
 static const struct seq_operations softnet_seq_ops = {
         .start = softnet_seq_start,
         .next  = softnet_seq_next,
@@ -195,18 +182,6 @@ static const struct seq_operations softnet_seq_ops = {
         .show  = softnet_seq_show,
 };
 
-static int softnet_seq_open(struct inode *inode, struct file *file)
-{
-        return seq_open(file, &softnet_seq_ops);
-}
-
-static const struct file_operations softnet_seq_fops = {
-        .open    = softnet_seq_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release,
-};
-
 static void *ptype_get_idx(loff_t pos)
 {
         struct packet_type *pt = NULL;
@@ -297,30 +272,18 @@ static const struct seq_operations ptype_seq_ops = {
         .show  = ptype_seq_show,
 };
 
-static int ptype_seq_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &ptype_seq_ops,
-                        sizeof(struct seq_net_private));
-}
-
-static const struct file_operations ptype_seq_fops = {
-        .open    = ptype_seq_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release_net,
-};
-
-
 static int __net_init dev_proc_net_init(struct net *net)
 {
         int rc = -ENOMEM;
 
-        if (!proc_create("dev", 0444, net->proc_net, &dev_seq_fops))
+        if (!proc_create_net("dev", 0444, net->proc_net, &dev_seq_ops,
+                        sizeof(struct seq_net_private)))
                 goto out;
-        if (!proc_create("softnet_stat", 0444, net->proc_net,
-                         &softnet_seq_fops))
+        if (!proc_create_seq("softnet_stat", 0444, net->proc_net,
+                         &softnet_seq_ops))
                 goto out_dev;
-        if (!proc_create("ptype", 0444, net->proc_net, &ptype_seq_fops))
+        if (!proc_create_net("ptype", 0444, net->proc_net, &ptype_seq_ops,
+                        sizeof(struct seq_net_private)))
                 goto out_softnet;
 
         if (wext_proc_init(net))
@@ -377,22 +340,10 @@ static const struct seq_operations dev_mc_seq_ops = {
         .show  = dev_mc_seq_show,
 };
 
-static int dev_mc_seq_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &dev_mc_seq_ops,
-                            sizeof(struct seq_net_private));
-}
-
-static const struct file_operations dev_mc_seq_fops = {
-        .open    = dev_mc_seq_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release_net,
-};
-
 static int __net_init dev_mc_net_init(struct net *net)
 {
-        if (!proc_create("dev_mcast", 0, net->proc_net, &dev_mc_seq_fops))
+        if (!proc_create_net("dev_mcast", 0, net->proc_net, &dev_mc_seq_ops,
+                        sizeof(struct seq_net_private)))
                 return -ENOMEM;
         return 0;
 }
diff --git a/net/core/sock.c b/net/core/sock.c
index 3b6d02854e57..815770333d91 100644
--- a/net/core/sock.c
+++ b/net/core/sock.c
@@ -3439,22 +3439,10 @@ static const struct seq_operations proto_seq_ops = {
         .show   = proto_seq_show,
 };
 
-static int proto_seq_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &proto_seq_ops,
-                            sizeof(struct seq_net_private));
-}
-
-static const struct file_operations proto_seq_fops = {
-        .open           = proto_seq_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = seq_release_net,
-};
-
 static __net_init int proto_init_net(struct net *net)
 {
-        if (!proc_create("protocols", 0444, net->proc_net, &proto_seq_fops))
+        if (!proc_create_net("protocols", 0444, net->proc_net, &proto_seq_ops,
+                        sizeof(struct seq_net_private)))
                 return -ENOMEM;
 
         return 0;
diff --git a/net/decnet/af_decnet.c b/net/decnet/af_decnet.c
index 32751602767f..7d6ff983ba2c 100644
--- a/net/decnet/af_decnet.c
+++ b/net/decnet/af_decnet.c
@@ -2314,19 +2314,6 @@ static const struct seq_operations dn_socket_seq_ops = {
         .stop   = dn_socket_seq_stop,
         .show   = dn_socket_seq_show,
 };
-
-static int dn_socket_seq_open(struct inode *inode, struct file *file)
-{
-        return seq_open_private(file, &dn_socket_seq_ops,
-                        sizeof(struct dn_iter_state));
-}
-
-static const struct file_operations dn_socket_seq_fops = {
-        .open           = dn_socket_seq_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = seq_release_private,
-};
 #endif
 
 static const struct net_proto_family    dn_family_ops = {
@@ -2383,7 +2370,9 @@ static int __init decnet_init(void)
         dev_add_pack(&dn_dix_packet_type);
         register_netdevice_notifier(&dn_dev_notifier);
 
-        proc_create("decnet", 0444, init_net.proc_net, &dn_socket_seq_fops);
+        proc_create_seq_private("decnet", 0444, init_net.proc_net,
+                        &dn_socket_seq_ops, sizeof(struct dn_iter_state),
+                        NULL);
         dn_register_sysctl();
 out:
         return rc;
diff --git a/net/decnet/dn_dev.c b/net/decnet/dn_dev.c
index c03b046478c3..bfd43e8f2c06 100644
--- a/net/decnet/dn_dev.c
+++ b/net/decnet/dn_dev.c
@@ -1382,19 +1382,6 @@ static const struct seq_operations dn_dev_seq_ops = {
         .stop   = dn_dev_seq_stop,
         .show   = dn_dev_seq_show,
 };
-
-static int dn_dev_seq_open(struct inode *inode, struct file *file)
-{
-        return seq_open(file, &dn_dev_seq_ops);
-}
-
-static const struct file_operations dn_dev_seq_fops = {
-        .open    = dn_dev_seq_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release,
-};
-
 #endif /* CONFIG_PROC_FS */
 
 static int addr[2];
@@ -1424,7 +1411,7 @@ void __init dn_dev_init(void)
         rtnl_register_module(THIS_MODULE, PF_DECnet, RTM_GETADDR,
                              NULL, dn_nl_dump_ifaddr, 0);
 
-        proc_create("decnet_dev", 0444, init_net.proc_net, &dn_dev_seq_fops);
+        proc_create_seq("decnet_dev", 0444, init_net.proc_net, &dn_dev_seq_ops);
 
 #ifdef CONFIG_SYSCTL
         {
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 = {
         .stop  = neigh_seq_stop,
         .show  = dn_neigh_seq_show,
 };
-
-static int dn_neigh_seq_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &dn_neigh_seq_ops,
-                            sizeof(struct neigh_seq_state));
-}
-
-static const struct file_operations dn_neigh_seq_fops = {
-        .open           = dn_neigh_seq_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = seq_release_net,
-};
-
 #endif
 
 void __init dn_neigh_init(void)
 {
         neigh_table_init(NEIGH_DN_TABLE, &dn_neigh_table);
-        proc_create("decnet_neigh", 0444, init_net.proc_net,
-                    &dn_neigh_seq_fops);
+        proc_create_net("decnet_neigh", 0444, init_net.proc_net,
+                        &dn_neigh_seq_ops, sizeof(struct neigh_seq_state));
 }
 
 void __exit dn_neigh_cleanup(void)
diff --git a/net/decnet/dn_route.c b/net/decnet/dn_route.c
index eca0cc6b761f..e74765024d88 100644
--- a/net/decnet/dn_route.c
+++ b/net/decnet/dn_route.c
@@ -1852,20 +1852,6 @@ static const struct seq_operations dn_rt_cache_seq_ops = {
         .stop   = dn_rt_cache_seq_stop,
         .show   = dn_rt_cache_seq_show,
 };
-
-static int dn_rt_cache_seq_open(struct inode *inode, struct file *file)
-{
-        return seq_open_private(file, &dn_rt_cache_seq_ops,
-                        sizeof(struct dn_rt_cache_iter_state));
-}
-
-static const struct file_operations dn_rt_cache_seq_fops = {
-        .open    = dn_rt_cache_seq_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release_private,
-};
-
 #endif /* CONFIG_PROC_FS */
 
 void __init dn_route_init(void)
@@ -1918,8 +1904,9 @@ void __init dn_route_init(void)
 
         dn_dst_ops.gc_thresh = (dn_rt_hash_mask + 1);
 
-        proc_create("decnet_cache", 0444, init_net.proc_net,
-                    &dn_rt_cache_seq_fops);
+        proc_create_seq_private("decnet_cache", 0444, init_net.proc_net,
+                        &dn_rt_cache_seq_ops,
+                        sizeof(struct dn_rt_cache_iter_state), NULL);
 
 #ifdef CONFIG_DECNET_ROUTER
         rtnl_register_module(THIS_MODULE, PF_DECnet, RTM_GETROUTE,
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 = {
         .show   = arp_seq_show,
 };
 
-static int arp_seq_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &arp_seq_ops,
-                            sizeof(struct neigh_seq_state));
-}
-
-static const struct file_operations arp_seq_fops = {
-        .open           = arp_seq_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = seq_release_net,
-};
-
+/* ------------------------------------------------------------------------ */
 
 static int __net_init arp_net_init(struct net *net)
 {
-        if (!proc_create("arp", 0444, net->proc_net, &arp_seq_fops))
+        if (!proc_create_net("arp", 0444, net->proc_net, &arp_seq_ops,
+                        sizeof(struct neigh_seq_state)))
                 return -ENOMEM;
         return 0;
 }
diff --git a/net/ipv4/fib_trie.c b/net/ipv4/fib_trie.c
index 3dcffd3ce98c..99c23a0cb8ca 100644
--- a/net/ipv4/fib_trie.c
+++ b/net/ipv4/fib_trie.c
@@ -2348,18 +2348,6 @@ static int fib_triestat_seq_show(struct seq_file *seq, void *v)
         return 0;
 }
 
-static int fib_triestat_seq_open(struct inode *inode, struct file *file)
-{
-        return single_open_net(inode, file, fib_triestat_seq_show);
-}
-
-static const struct file_operations fib_triestat_fops = {
-        .open   = fib_triestat_seq_open,
-        .read   = seq_read,
-        .llseek = seq_lseek,
-        .release = single_release_net,
-};
-
 static struct key_vector *fib_trie_get_idx(struct seq_file *seq, loff_t pos)
 {
         struct fib_trie_iter *iter = seq->private;
@@ -2533,19 +2521,6 @@ static const struct seq_operations fib_trie_seq_ops = {
         .show   = fib_trie_seq_show,
 };
 
-static int fib_trie_seq_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &fib_trie_seq_ops,
-                            sizeof(struct fib_trie_iter));
-}
-
-static const struct file_operations fib_trie_fops = {
-        .open   = fib_trie_seq_open,
-        .read   = seq_read,
-        .llseek = seq_lseek,
-        .release = seq_release_net,
-};
-
 struct fib_route_iter {
         struct seq_net_private p;
         struct fib_table *main_tb;
@@ -2726,29 +2701,18 @@ static const struct seq_operations fib_route_seq_ops = {
         .show   = fib_route_seq_show,
 };
 
-static int fib_route_seq_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &fib_route_seq_ops,
-                            sizeof(struct fib_route_iter));
-}
-
-static const struct file_operations fib_route_fops = {
-        .open   = fib_route_seq_open,
-        .read   = seq_read,
-        .llseek = seq_lseek,
-        .release = seq_release_net,
-};
-
 int __net_init fib_proc_init(struct net *net)
 {
-        if (!proc_create("fib_trie", 0444, net->proc_net, &fib_trie_fops))
+        if (!proc_create_net("fib_trie", 0444, net->proc_net, &fib_trie_seq_ops,
+                        sizeof(struct fib_trie_iter)))
                 goto out1;
 
-        if (!proc_create("fib_triestat", 0444, net->proc_net,
-                         &fib_triestat_fops))
+        if (!proc_create_net_single("fib_triestat", 0444, net->proc_net,
+                        fib_triestat_seq_show, NULL))
                 goto out2;
 
-        if (!proc_create("route", 0444, net->proc_net, &fib_route_fops))
+        if (!proc_create_net("route", 0444, net->proc_net, &fib_route_seq_ops,
+                        sizeof(struct fib_route_iter)))
                 goto out3;
 
         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 = {
         .show   =       igmp_mc_seq_show,
 };
 
-static int igmp_mc_seq_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &igmp_mc_seq_ops,
-                        sizeof(struct igmp_mc_iter_state));
-}
-
-static const struct file_operations igmp_mc_seq_fops = {
-        .open           =       igmp_mc_seq_open,
-        .read           =       seq_read,
-        .llseek         =       seq_lseek,
-        .release        =       seq_release_net,
-};
-
 struct igmp_mcf_iter_state {
         struct seq_net_private p;
         struct net_device *dev;
@@ -2975,29 +2962,17 @@ static const struct seq_operations igmp_mcf_seq_ops = {
         .show   =       igmp_mcf_seq_show,
 };
 
-static int igmp_mcf_seq_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &igmp_mcf_seq_ops,
-                        sizeof(struct igmp_mcf_iter_state));
-}
-
-static const struct file_operations igmp_mcf_seq_fops = {
-        .open           =       igmp_mcf_seq_open,
-        .read           =       seq_read,
-        .llseek         =       seq_lseek,
-        .release        =       seq_release_net,
-};
-
 static int __net_init igmp_net_init(struct net *net)
 {
         struct proc_dir_entry *pde;
         int err;
 
-        pde = proc_create("igmp", 0444, net->proc_net, &igmp_mc_seq_fops);
+        pde = proc_create_net("igmp", 0444, net->proc_net, &igmp_mc_seq_ops,
+                        sizeof(struct igmp_mc_iter_state));
         if (!pde)
                 goto out_igmp;
-        pde = proc_create("mcfilter", 0444, net->proc_net,
-                          &igmp_mcf_seq_fops);
+        pde = proc_create_net("mcfilter", 0444, net->proc_net,
+                        &igmp_mcf_seq_ops, sizeof(struct igmp_mcf_iter_state));
         if (!pde)
                 goto out_mcfilter;
         err = inet_ctl_sock_create(&net->ipv4.mc_autojoin_sk, AF_INET,
diff --git a/net/ipv4/ipconfig.c b/net/ipv4/ipconfig.c
index 43f620feb1c4..bbcbcc113d19 100644
--- a/net/ipv4/ipconfig.c
+++ b/net/ipv4/ipconfig.c
@@ -1282,18 +1282,6 @@ static int pnp_seq_show(struct seq_file *seq, void *v)
                            &ic_servaddr);
         return 0;
 }
-
-static int pnp_seq_open(struct inode *indoe, struct file *file)
-{
-        return single_open(file, pnp_seq_show, NULL);
-}
-
-static const struct file_operations pnp_seq_fops = {
-        .open           = pnp_seq_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = single_release,
-};
 #endif /* CONFIG_PROC_FS */
 
 /*
@@ -1369,7 +1357,7 @@ static int __init ip_auto_config(void)
         unsigned int i;
 
 #ifdef CONFIG_PROC_FS
-        proc_create("pnp", 0444, init_net.proc_net, &pnp_seq_fops);
+        proc_create_single("pnp", 0444, init_net.proc_net, pnp_seq_show);
 #endif /* CONFIG_PROC_FS */
 
         if (!ic_enable)
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 = {
         .show  = ipmr_vif_seq_show,
 };
 
-static int ipmr_vif_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &ipmr_vif_seq_ops,
-                            sizeof(struct mr_vif_iter));
-}
-
-static const struct file_operations ipmr_vif_fops = {
-        .open    = ipmr_vif_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release_net,
-};
-
 static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
 {
         struct net *net = seq_file_net(seq);
@@ -2900,19 +2887,6 @@ static const struct seq_operations ipmr_mfc_seq_ops = {
         .stop  = mr_mfc_seq_stop,
         .show  = ipmr_mfc_seq_show,
 };
-
-static int ipmr_mfc_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &ipmr_mfc_seq_ops,
-                            sizeof(struct mr_mfc_iter));
-}
-
-static const struct file_operations ipmr_mfc_fops = {
-        .open    = ipmr_mfc_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release_net,
-};
 #endif
 
 #ifdef CONFIG_IP_PIMSM_V2
@@ -2977,9 +2951,11 @@ static int __net_init ipmr_net_init(struct net *net)
 
 #ifdef CONFIG_PROC_FS
         err = -ENOMEM;
-        if (!proc_create("ip_mr_vif", 0, net->proc_net, &ipmr_vif_fops))
+        if (!proc_create_net("ip_mr_vif", 0, net->proc_net, &ipmr_vif_seq_ops,
+                        sizeof(struct mr_vif_iter)))
                 goto proc_vif_fail;
-        if (!proc_create("ip_mr_cache", 0, net->proc_net, &ipmr_mfc_fops))
+        if (!proc_create_net("ip_mr_cache", 0, net->proc_net, &ipmr_mfc_seq_ops,
+                        sizeof(struct mr_mfc_iter)))
                 goto proc_cache_fail;
 #endif
         return 0;
diff --git a/net/ipv4/ping.c b/net/ipv4/ping.c
index 56a010622f70..2ed64bca54e3 100644
--- a/net/ipv4/ping.c
+++ b/net/ipv4/ping.c
@@ -1150,58 +1150,24 @@ static int ping_v4_seq_show(struct seq_file *seq, void *v)
         return 0;
 }
 
-static int ping_seq_open(struct inode *inode, struct file *file)
-{
-        struct ping_seq_afinfo *afinfo = PDE_DATA(inode);
-        return seq_open_net(inode, file, &afinfo->seq_ops,
-                           sizeof(struct ping_iter_state));
-}
-
-const struct file_operations ping_seq_fops = {
-        .open           = ping_seq_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = seq_release_net,
-};
-EXPORT_SYMBOL_GPL(ping_seq_fops);
-
-static struct ping_seq_afinfo ping_v4_seq_afinfo = {
-        .name           = "icmp",
-        .family         = AF_INET,
-        .seq_fops       = &ping_seq_fops,
-        .seq_ops        = {
-                .start          = ping_v4_seq_start,
-                .show           = ping_v4_seq_show,
-                .next           = ping_seq_next,
-                .stop           = ping_seq_stop,
-        },
+static const struct seq_operations ping_v4_seq_ops = {
+        .start          = ping_v4_seq_start,
+        .show           = ping_v4_seq_show,
+        .next           = ping_seq_next,
+        .stop           = ping_seq_stop,
 };
 
-int ping_proc_register(struct net *net, struct ping_seq_afinfo *afinfo)
+static int __net_init ping_v4_proc_init_net(struct net *net)
 {
-        struct proc_dir_entry *p;
-        p = proc_create_data(afinfo->name, 0444, net->proc_net,
-                             afinfo->seq_fops, afinfo);
-        if (!p)
+        if (!proc_create_net("icmp", 0444, net->proc_net, &ping_v4_seq_ops,
+                        sizeof(struct ping_iter_state)))
                 return -ENOMEM;
         return 0;
 }
-EXPORT_SYMBOL_GPL(ping_proc_register);
-
-void ping_proc_unregister(struct net *net, struct ping_seq_afinfo *afinfo)
-{
-        remove_proc_entry(afinfo->name, net->proc_net);
-}
-EXPORT_SYMBOL_GPL(ping_proc_unregister);
-
-static int __net_init ping_v4_proc_init_net(struct net *net)
-{
-        return ping_proc_register(net, &ping_v4_seq_afinfo);
-}
 
 static void __net_exit ping_v4_proc_exit_net(struct net *net)
 {
-        ping_proc_unregister(net, &ping_v4_seq_afinfo);
+        remove_proc_entry("icmp", net->proc_net);
 }
 
 static struct pernet_operations ping_v4_net_ops = {
diff --git a/net/ipv4/proc.c b/net/ipv4/proc.c
index a058de677e94..573e43c8ed87 100644
--- a/net/ipv4/proc.c
+++ b/net/ipv4/proc.c
@@ -77,18 +77,6 @@ static int sockstat_seq_show(struct seq_file *seq, void *v)
         return 0;
 }
 
-static int sockstat_seq_open(struct inode *inode, struct file *file)
-{
-        return single_open_net(inode, file, sockstat_seq_show);
-}
-
-static const struct file_operations sockstat_seq_fops = {
-        .open    = sockstat_seq_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = single_release_net,
-};
-
 /* snmp items */
 static const struct snmp_mib snmp4_ipstats_list[] = {
         SNMP_MIB_ITEM("InReceives", IPSTATS_MIB_INPKTS),
@@ -460,20 +448,6 @@ static int snmp_seq_show(struct seq_file *seq, void *v)
         return 0;
 }
 
-static int snmp_seq_open(struct inode *inode, struct file *file)
-{
-        return single_open_net(inode, file, snmp_seq_show);
-}
-
-static const struct file_operations snmp_seq_fops = {
-        .open    = snmp_seq_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = single_release_net,
-};
-
-
-
 /*
  *      Output /proc/net/netstat
  */
@@ -507,26 +481,16 @@ static int netstat_seq_show(struct seq_file *seq, void *v)
         return 0;
 }
 
-static int netstat_seq_open(struct inode *inode, struct file *file)
-{
-        return single_open_net(inode, file, netstat_seq_show);
-}
-
-static const struct file_operations netstat_seq_fops = {
-        .open    = netstat_seq_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = single_release_net,
-};
-
 static __net_init int ip_proc_init_net(struct net *net)
 {
-        if (!proc_create("sockstat", 0444, net->proc_net,
-                         &sockstat_seq_fops))
+        if (!proc_create_net_single("sockstat", 0444, net->proc_net,
+                        sockstat_seq_show, NULL))
                 goto out_sockstat;
-        if (!proc_create("netstat", 0444, net->proc_net, &netstat_seq_fops))
+        if (!proc_create_net_single("netstat", 0444, net->proc_net,
+                        netstat_seq_show, NULL))
                 goto out_netstat;
-        if (!proc_create("snmp", 0444, net->proc_net, &snmp_seq_fops))
+        if (!proc_create_net_single("snmp", 0444, net->proc_net, snmp_seq_show,
+                        NULL))
                 goto out_snmp;
 
         return 0;
diff --git a/net/ipv4/raw.c b/net/ipv4/raw.c
index 1b4d3355624a..abb3c9490c55 100644
--- a/net/ipv4/raw.c
+++ b/net/ipv4/raw.c
@@ -1003,11 +1003,12 @@ struct proto raw_prot = {
 static struct sock *raw_get_first(struct seq_file *seq)
 {
         struct sock *sk;
+        struct raw_hashinfo *h = PDE_DATA(file_inode(seq->file));
         struct raw_iter_state *state = raw_seq_private(seq);
 
         for (state->bucket = 0; state->bucket < RAW_HTABLE_SIZE;
                         ++state->bucket) {
-                sk_for_each(sk, &state->h->ht[state->bucket])
+                sk_for_each(sk, &h->ht[state->bucket])
                         if (sock_net(sk) == seq_file_net(seq))
                                 goto found;
         }
@@ -1018,6 +1019,7 @@ found:
 
 static struct sock *raw_get_next(struct seq_file *seq, struct sock *sk)
 {
+        struct raw_hashinfo *h = PDE_DATA(file_inode(seq->file));
         struct raw_iter_state *state = raw_seq_private(seq);
 
         do {
@@ -1027,7 +1029,7 @@ try_again:
         } while (sk && sock_net(sk) != seq_file_net(seq));
 
         if (!sk && ++state->bucket < RAW_HTABLE_SIZE) {
-                sk = sk_head(&state->h->ht[state->bucket]);
+                sk = sk_head(&h->ht[state->bucket]);
                 goto try_again;
         }
         return sk;
@@ -1045,9 +1047,9 @@ static struct sock *raw_get_idx(struct seq_file *seq, loff_t pos)
 
 void *raw_seq_start(struct seq_file *seq, loff_t *pos)
 {
-        struct raw_iter_state *state = raw_seq_private(seq);
+        struct raw_hashinfo *h = PDE_DATA(file_inode(seq->file));
 
-        read_lock(&state->h->lock);
+        read_lock(&h->lock);
         return *pos ? raw_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
 }
 EXPORT_SYMBOL_GPL(raw_seq_start);
@@ -1067,9 +1069,9 @@ EXPORT_SYMBOL_GPL(raw_seq_next);
 
 void raw_seq_stop(struct seq_file *seq, void *v)
 {
-        struct raw_iter_state *state = raw_seq_private(seq);
+        struct raw_hashinfo *h = PDE_DATA(file_inode(seq->file));
 
-        read_unlock(&state->h->lock);
+        read_unlock(&h->lock);
 }
 EXPORT_SYMBOL_GPL(raw_seq_stop);
 
@@ -1110,37 +1112,10 @@ static const struct seq_operations raw_seq_ops = {
         .show  = raw_seq_show,
 };
 
-int raw_seq_open(struct inode *ino, struct file *file,
-                 struct raw_hashinfo *h, const struct seq_operations *ops)
-{
-        int err;
-        struct raw_iter_state *i;
-
-        err = seq_open_net(ino, file, ops, sizeof(struct raw_iter_state));
-        if (err < 0)
-                return err;
-
-        i = raw_seq_private((struct seq_file *)file->private_data);
-        i->h = h;
-        return 0;
-}
-EXPORT_SYMBOL_GPL(raw_seq_open);
-
-static int raw_v4_seq_open(struct inode *inode, struct file *file)
-{
-        return raw_seq_open(inode, file, &raw_v4_hashinfo, &raw_seq_ops);
-}
-
-static const struct file_operations raw_seq_fops = {
-        .open    = raw_v4_seq_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release_net,
-};
-
 static __net_init int raw_init_net(struct net *net)
 {
-        if (!proc_create("raw", 0444, net->proc_net, &raw_seq_fops))
+        if (!proc_create_net_data("raw", 0444, net->proc_net, &raw_seq_ops,
+                        sizeof(struct raw_iter_state), &raw_v4_hashinfo))
                 return -ENOMEM;
 
         return 0;
diff --git a/net/ipv4/route.c b/net/ipv4/route.c
index 2cfa1b518f8d..75fb8864be67 100644
--- a/net/ipv4/route.c
+++ b/net/ipv4/route.c
@@ -360,18 +360,6 @@ static int rt_acct_proc_show(struct seq_file *m, void *v)
         kfree(dst);
         return 0;
 }
-
-static int rt_acct_proc_open(struct inode *inode, struct file *file)
-{
-        return single_open(file, rt_acct_proc_show, NULL);
-}
-
-static const struct file_operations rt_acct_proc_fops = {
-        .open           = rt_acct_proc_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = single_release,
-};
 #endif
 
 static int __net_init ip_rt_do_proc_init(struct net *net)
@@ -389,7 +377,8 @@ static int __net_init ip_rt_do_proc_init(struct net *net)
                 goto err2;
 
 #ifdef CONFIG_IP_ROUTE_CLASSID
-        pde = proc_create("rt_acct", 0, net->proc_net, &rt_acct_proc_fops);
+        pde = proc_create_single("rt_acct", 0, net->proc_net,
+                        rt_acct_proc_show);
         if (!pde)
                 goto err3;
 #endif
diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c
index f70586b50838..2c970626b398 100644
--- a/net/ipv4/tcp_ipv4.c
+++ b/net/ipv4/tcp_ipv4.c
@@ -1961,6 +1961,7 @@ EXPORT_SYMBOL(tcp_v4_destroy_sock);
  */
 static void *listening_get_next(struct seq_file *seq, void *cur)
 {
+        struct tcp_seq_afinfo *afinfo = PDE_DATA(file_inode(seq->file));
         struct tcp_iter_state *st = seq->private;
         struct net *net = seq_file_net(seq);
         struct inet_listen_hashbucket *ilb;
@@ -1983,7 +1984,7 @@ get_sk:
         sk_for_each_from(sk) {
                 if (!net_eq(sock_net(sk), net))
                         continue;
-                if (sk->sk_family == st->family)
+                if (sk->sk_family == afinfo->family)
                         return sk;
         }
         spin_unlock(&ilb->lock);
@@ -2020,6 +2021,7 @@ static inline bool empty_bucket(const struct tcp_iter_state *st)
  */
 static void *established_get_first(struct seq_file *seq)
 {
+        struct tcp_seq_afinfo *afinfo = PDE_DATA(file_inode(seq->file));
         struct tcp_iter_state *st = seq->private;
         struct net *net = seq_file_net(seq);
         void *rc = NULL;
@@ -2036,7 +2038,7 @@ static void *established_get_first(struct seq_file *seq)
 
                 spin_lock_bh(lock);
                 sk_nulls_for_each(sk, node, &tcp_hashinfo.ehash[st->bucket].chain) {
-                        if (sk->sk_family != st->family ||
+                        if (sk->sk_family != afinfo->family ||
                             !net_eq(sock_net(sk), net)) {
                                 continue;
                         }
@@ -2051,6 +2053,7 @@ out:
 
 static void *established_get_next(struct seq_file *seq, void *cur)
 {
+        struct tcp_seq_afinfo *afinfo = PDE_DATA(file_inode(seq->file));
         struct sock *sk = cur;
         struct hlist_nulls_node *node;
         struct tcp_iter_state *st = seq->private;
@@ -2062,7 +2065,8 @@ static void *established_get_next(struct seq_file *seq, void *cur)
         sk = sk_nulls_next(sk);
 
         sk_nulls_for_each_from(sk, node) {
-                if (sk->sk_family == st->family && net_eq(sock_net(sk), net))
+                if (sk->sk_family == afinfo->family &&
+                    net_eq(sock_net(sk), net))
                         return sk;
         }
 
@@ -2135,7 +2139,7 @@ static void *tcp_seek_last_pos(struct seq_file *seq)
         return rc;
 }
 
-static void *tcp_seq_start(struct seq_file *seq, loff_t *pos)
+void *tcp_seq_start(struct seq_file *seq, loff_t *pos)
 {
         struct tcp_iter_state *st = seq->private;
         void *rc;
@@ -2156,8 +2160,9 @@ out:
         st->last_pos = *pos;
         return rc;
 }
+EXPORT_SYMBOL(tcp_seq_start);
 
-static void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
+void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 {
         struct tcp_iter_state *st = seq->private;
         void *rc = NULL;
@@ -2186,8 +2191,9 @@ out:
         st->last_pos = *pos;
         return rc;
 }
+EXPORT_SYMBOL(tcp_seq_next);
 
-static void tcp_seq_stop(struct seq_file *seq, void *v)
+void tcp_seq_stop(struct seq_file *seq, void *v)
 {
         struct tcp_iter_state *st = seq->private;
 
@@ -2202,47 +2208,7 @@ static void tcp_seq_stop(struct seq_file *seq, void *v)
                 break;
         }
 }
-
-int tcp_seq_open(struct inode *inode, struct file *file)
-{
-        struct tcp_seq_afinfo *afinfo = PDE_DATA(inode);
-        struct tcp_iter_state *s;
-        int err;
-
-        err = seq_open_net(inode, file, &afinfo->seq_ops,
-                          sizeof(struct tcp_iter_state));
-        if (err < 0)
-                return err;
-
-        s = ((struct seq_file *)file->private_data)->private;
-        s->family               = afinfo->family;
-        s->last_pos             = 0;
-        return 0;
-}
-EXPORT_SYMBOL(tcp_seq_open);
-
-int tcp_proc_register(struct net *net, struct tcp_seq_afinfo *afinfo)
-{
-        int rc = 0;
-        struct proc_dir_entry *p;
-
-        afinfo->seq_ops.start           = tcp_seq_start;
-        afinfo->seq_ops.next            = tcp_seq_next;
-        afinfo->seq_ops.stop            = tcp_seq_stop;
-
-        p = proc_create_data(afinfo->name, 0444, net->proc_net,
-                             afinfo->seq_fops, afinfo);
-        if (!p)
-                rc = -ENOMEM;
-        return rc;
-}
-EXPORT_SYMBOL(tcp_proc_register);
-
-void tcp_proc_unregister(struct net *net, struct tcp_seq_afinfo *afinfo)
-{
-        remove_proc_entry(afinfo->name, net->proc_net);
-}
-EXPORT_SYMBOL(tcp_proc_unregister);
+EXPORT_SYMBOL(tcp_seq_stop);
 
 static void get_openreq4(const struct request_sock *req,
                          struct seq_file *f, int i)
@@ -2377,30 +2343,28 @@ out:
         return 0;
 }
 
-static const struct file_operations tcp_afinfo_seq_fops = {
-        .open    = tcp_seq_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release_net
+static const struct seq_operations tcp4_seq_ops = {
+        .show           = tcp4_seq_show,
+        .start          = tcp_seq_start,
+        .next           = tcp_seq_next,
+        .stop           = tcp_seq_stop,
 };
 
 static struct tcp_seq_afinfo tcp4_seq_afinfo = {
-        .name           = "tcp",
         .family         = AF_INET,
-        .seq_fops       = &tcp_afinfo_seq_fops,
-        .seq_ops        = {
-                .show           = tcp4_seq_show,
-        },
 };
 
 static int __net_init tcp4_proc_init_net(struct net *net)
 {
-        return tcp_proc_register(net, &tcp4_seq_afinfo);
+        if (!proc_create_net_data("tcp", 0444, net->proc_net, &tcp4_seq_ops,
+                        sizeof(struct tcp_iter_state), &tcp4_seq_afinfo))
+                return -ENOMEM;
+        return 0;
 }
 
 static void __net_exit tcp4_proc_exit_net(struct net *net)
 {
-        tcp_proc_unregister(net, &tcp4_seq_afinfo);
+        remove_proc_entry("tcp", net->proc_net);
 }
 
 static struct pernet_operations tcp4_net_ops = {
diff --git a/net/ipv4/udp.c b/net/ipv4/udp.c
index b61a770884fa..051a43ff3fb8 100644
--- 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,30 @@ int udp4_seq_show(struct seq_file *seq, void *v)
         return 0;
 }
 
-static const struct file_operations udp_afinfo_seq_fops = {
-        .open     = udp_seq_open,
-        .read     = seq_read,
-        .llseek   = seq_lseek,
-        .release  = seq_release_net
+const struct seq_operations udp_seq_ops = {
+        .start          = udp_seq_start,
+        .next           = udp_seq_next,
+        .stop           = udp_seq_stop,
+        .show           = udp4_seq_show,
 };
+EXPORT_SYMBOL(udp_seq_ops);
 
-/* ------------------------------------------------------------------------ */
 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_net_data("udp", 0444, net->proc_net, &udp_seq_ops,
+                        sizeof(struct udp_iter_state), &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 f96614e9b9a5..8545457752fb 100644
--- 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_net_data("udplite", 0444, net->proc_net, &udp_seq_ops,
+                        sizeof(struct udp_iter_state), &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/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 = {
         .stop   = if6_seq_stop,
 };
 
-static int if6_seq_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &if6_seq_ops,
-                            sizeof(struct if6_iter_state));
-}
-
-static const struct file_operations if6_fops = {
-        .open           = if6_seq_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = seq_release_net,
-};
-
 static int __net_init if6_proc_net_init(struct net *net)
 {
-        if (!proc_create("if_inet6", 0444, net->proc_net, &if6_fops))
+        if (!proc_create_net("if_inet6", 0444, net->proc_net, &if6_seq_ops,
+                        sizeof(struct if6_iter_state)))
                 return -ENOMEM;
         return 0;
 }
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 = {
         .show   =       ac6_seq_show,
 };
 
-static int ac6_seq_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &ac6_seq_ops,
-                            sizeof(struct ac6_iter_state));
-}
-
-static const struct file_operations ac6_seq_fops = {
-        .open           =       ac6_seq_open,
-        .read           =       seq_read,
-        .llseek         =       seq_lseek,
-        .release        =       seq_release_net,
-};
-
 int __net_init ac6_proc_init(struct net *net)
 {
-        if (!proc_create("anycast6", 0444, net->proc_net, &ac6_seq_fops))
+        if (!proc_create_net("anycast6", 0444, net->proc_net, &ac6_seq_ops,
+                        sizeof(struct ac6_iter_state)))
                 return -ENOMEM;
 
         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)
 }
 
 #ifdef CONFIG_PROC_FS
-
-struct ipv6_route_iter {
-        struct seq_net_private p;
-        struct fib6_walker w;
-        loff_t skip;
-        struct fib6_table *tbl;
-        int sernum;
-};
-
 static int ipv6_route_seq_show(struct seq_file *seq, void *v)
 {
         struct rt6_info *rt = v;
@@ -2383,17 +2374,10 @@ static void ipv6_route_seq_stop(struct seq_file *seq, void *v)
         rcu_read_unlock_bh();
 }
 
-static const struct seq_operations ipv6_route_seq_ops = {
+const struct seq_operations ipv6_route_seq_ops = {
         .start  = ipv6_route_seq_start,
         .next   = ipv6_route_seq_next,
         .stop   = ipv6_route_seq_stop,
         .show   = ipv6_route_seq_show
 };
-
-int ipv6_route_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &ipv6_route_seq_ops,
-                            sizeof(struct ipv6_route_iter));
-}
-
 #endif /* CONFIG_PROC_FS */
diff --git a/net/ipv6/ip6_flowlabel.c b/net/ipv6/ip6_flowlabel.c
index c05c4e82a7ca..3eee7637bdfe 100644
--- a/net/ipv6/ip6_flowlabel.c
+++ b/net/ipv6/ip6_flowlabel.c
@@ -754,6 +754,10 @@ static struct ip6_flowlabel *ip6fl_get_idx(struct seq_file *seq, loff_t pos)
 static void *ip6fl_seq_start(struct seq_file *seq, loff_t *pos)
         __acquires(RCU)
 {
+        struct ip6fl_iter_state *state = ip6fl_seq_private(seq);
+
+        state->pid_ns = proc_pid_ns(file_inode(seq->file));
+
         rcu_read_lock_bh();
         return *pos ? ip6fl_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
 }
@@ -808,44 +812,10 @@ static const struct seq_operations ip6fl_seq_ops = {
         .show   =       ip6fl_seq_show,
 };
 
-static int ip6fl_seq_open(struct inode *inode, struct file *file)
-{
-        struct seq_file *seq;
-        struct ip6fl_iter_state *state;
-        int err;
-
-        err = seq_open_net(inode, file, &ip6fl_seq_ops,
-                           sizeof(struct ip6fl_iter_state));
-
-        if (!err) {
-                seq = file->private_data;
-                state = ip6fl_seq_private(seq);
-                rcu_read_lock();
-                state->pid_ns = get_pid_ns(task_active_pid_ns(current));
-                rcu_read_unlock();
-        }
-        return err;
-}
-
-static int ip6fl_seq_release(struct inode *inode, struct file *file)
-{
-        struct seq_file *seq = file->private_data;
-        struct ip6fl_iter_state *state = ip6fl_seq_private(seq);
-        put_pid_ns(state->pid_ns);
-        return seq_release_net(inode, file);
-}
-
-static const struct file_operations ip6fl_seq_fops = {
-        .open           =       ip6fl_seq_open,
-        .read           =       seq_read,
-        .llseek         =       seq_lseek,
-        .release        =       ip6fl_seq_release,
-};
-
 static int __net_init ip6_flowlabel_proc_init(struct net *net)
 {
-        if (!proc_create("ip6_flowlabel", 0444, net->proc_net,
-                         &ip6fl_seq_fops))
+        if (!proc_create_net("ip6_flowlabel", 0444, net->proc_net,
+                        &ip6fl_seq_ops, sizeof(struct ip6fl_iter_state)))
                 return -ENOMEM;
         return 0;
 }
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 = {
         .show  = ip6mr_vif_seq_show,
 };
 
-static int ip6mr_vif_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &ip6mr_vif_seq_ops,
-                            sizeof(struct mr_vif_iter));
-}
-
-static const struct file_operations ip6mr_vif_fops = {
-        .open    = ip6mr_vif_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release_net,
-};
-
 static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
 {
         struct net *net = seq_file_net(seq);
@@ -512,19 +499,6 @@ static const struct seq_operations ipmr_mfc_seq_ops = {
         .stop  = mr_mfc_seq_stop,
         .show  = ipmr_mfc_seq_show,
 };
-
-static int ipmr_mfc_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &ipmr_mfc_seq_ops,
-                            sizeof(struct mr_mfc_iter));
-}
-
-static const struct file_operations ip6mr_mfc_fops = {
-        .open    = ipmr_mfc_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release_net,
-};
 #endif
 
 #ifdef CONFIG_IPV6_PIMSM_V2
@@ -1316,9 +1290,11 @@ static int __net_init ip6mr_net_init(struct net *net)
 
 #ifdef CONFIG_PROC_FS
         err = -ENOMEM;
-        if (!proc_create("ip6_mr_vif", 0, net->proc_net, &ip6mr_vif_fops))
+        if (!proc_create_net("ip6_mr_vif", 0, net->proc_net, &ip6mr_vif_seq_ops,
+                        sizeof(struct mr_vif_iter)))
                 goto proc_vif_fail;
-        if (!proc_create("ip6_mr_cache", 0, net->proc_net, &ip6mr_mfc_fops))
+        if (!proc_create_net("ip6_mr_cache", 0, net->proc_net, &ipmr_mfc_seq_ops,
+                        sizeof(struct mr_mfc_iter)))
                 goto proc_cache_fail;
 #endif
 
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 = {
         .show   =       igmp6_mc_seq_show,
 };
 
-static int igmp6_mc_seq_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &igmp6_mc_seq_ops,
-                            sizeof(struct igmp6_mc_iter_state));
-}
-
-static const struct file_operations igmp6_mc_seq_fops = {
-        .open           =       igmp6_mc_seq_open,
-        .read           =       seq_read,
-        .llseek         =       seq_lseek,
-        .release        =       seq_release_net,
-};
-
 struct igmp6_mcf_iter_state {
         struct seq_net_private p;
         struct net_device *dev;
@@ -2903,28 +2890,17 @@ static const struct seq_operations igmp6_mcf_seq_ops = {
         .show   =       igmp6_mcf_seq_show,
 };
 
-static int igmp6_mcf_seq_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &igmp6_mcf_seq_ops,
-                            sizeof(struct igmp6_mcf_iter_state));
-}
-
-static const struct file_operations igmp6_mcf_seq_fops = {
-        .open           =       igmp6_mcf_seq_open,
-        .read           =       seq_read,
-        .llseek         =       seq_lseek,
-        .release        =       seq_release_net,
-};
-
 static int __net_init igmp6_proc_init(struct net *net)
 {
         int err;
 
         err = -ENOMEM;
-        if (!proc_create("igmp6", 0444, net->proc_net, &igmp6_mc_seq_fops))
+        if (!proc_create_net("igmp6", 0444, net->proc_net, &igmp6_mc_seq_ops,
+                        sizeof(struct igmp6_mc_iter_state)))
                 goto out;
-        if (!proc_create("mcfilter6", 0444, net->proc_net,
-                         &igmp6_mcf_seq_fops))
+        if (!proc_create_net("mcfilter6", 0444, net->proc_net,
+                        &igmp6_mcf_seq_ops,
+                        sizeof(struct igmp6_mcf_iter_state)))
                 goto out_proc_net_igmp6;
 
         err = 0;
diff --git a/net/ipv6/ping.c b/net/ipv6/ping.c
index 746eeae7f581..96f56bf49a30 100644
--- a/net/ipv6/ping.c
+++ b/net/ipv6/ping.c
@@ -24,6 +24,7 @@
 #include <net/protocol.h>
 #include <net/udp.h>
 #include <net/transp_v6.h>
+#include <linux/proc_fs.h>
 #include <net/ping.h>
 
 /* Compatibility glue so we can support IPv6 when it's compiled as a module */
@@ -215,26 +216,24 @@ static int ping_v6_seq_show(struct seq_file *seq, void *v)
         return 0;
 }
 
-static struct ping_seq_afinfo ping_v6_seq_afinfo = {
-        .name           = "icmp6",
-        .family         = AF_INET6,
-        .seq_fops       = &ping_seq_fops,
-        .seq_ops        = {
-                .start          = ping_v6_seq_start,
-                .show           = ping_v6_seq_show,
-                .next           = ping_seq_next,
-                .stop           = ping_seq_stop,
-        },
+static const struct seq_operations ping_v6_seq_ops = {
+        .start          = ping_v6_seq_start,
+        .show           = ping_v6_seq_show,
+        .next           = ping_seq_next,
+        .stop           = ping_seq_stop,
 };
 
 static int __net_init ping_v6_proc_init_net(struct net *net)
 {
-        return ping_proc_register(net, &ping_v6_seq_afinfo);
+        if (!proc_create_net("icmp6", 0444, net->proc_net, &ping_v6_seq_ops,
+                        sizeof(struct ping_iter_state)))
+                return -ENOMEM;
+        return 0;
 }
 
 static void __net_init ping_v6_proc_exit_net(struct net *net)
 {
-        return ping_proc_unregister(net, &ping_v6_seq_afinfo);
+        remove_proc_entry("icmp6", net->proc_net);
 }
 
 static struct pernet_operations ping_v6_net_ops = {
diff --git a/net/ipv6/proc.c b/net/ipv6/proc.c
index a85f7e0b14b1..2356b4af7309 100644
--- a/net/ipv6/proc.c
+++ b/net/ipv6/proc.c
@@ -53,18 +53,6 @@ static int sockstat6_seq_show(struct seq_file *seq, void *v)
         return 0;
 }
 
-static int sockstat6_seq_open(struct inode *inode, struct file *file)
-{
-        return single_open_net(inode, file, sockstat6_seq_show);
-}
-
-static const struct file_operations sockstat6_seq_fops = {
-        .open    = sockstat6_seq_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = single_release_net,
-};
-
 static const struct snmp_mib snmp6_ipstats_list[] = {
 /* ipv6 mib according to RFC 2465 */
         SNMP_MIB_ITEM("Ip6InReceives", IPSTATS_MIB_INPKTS),
@@ -242,18 +230,6 @@ static int snmp6_seq_show(struct seq_file *seq, void *v)
         return 0;
 }
 
-static int snmp6_seq_open(struct inode *inode, struct file *file)
-{
-        return single_open_net(inode, file, snmp6_seq_show);
-}
-
-static const struct file_operations snmp6_seq_fops = {
-        .open    = snmp6_seq_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = single_release_net,
-};
-
 static int snmp6_dev_seq_show(struct seq_file *seq, void *v)
 {
         struct inet6_dev *idev = (struct inet6_dev *)seq->private;
@@ -267,18 +243,6 @@ static int snmp6_dev_seq_show(struct seq_file *seq, void *v)
         return 0;
 }
 
-static int snmp6_dev_seq_open(struct inode *inode, struct file *file)
-{
-        return single_open(file, snmp6_dev_seq_show, PDE_DATA(inode));
-}
-
-static const struct file_operations snmp6_dev_seq_fops = {
-        .open    = snmp6_dev_seq_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = single_release,
-};
-
 int snmp6_register_dev(struct inet6_dev *idev)
 {
         struct proc_dir_entry *p;
@@ -291,9 +255,8 @@ int snmp6_register_dev(struct inet6_dev *idev)
         if (!net->mib.proc_net_devsnmp6)
                 return -ENOENT;
 
-        p = proc_create_data(idev->dev->name, 0444,
-                             net->mib.proc_net_devsnmp6,
-                             &snmp6_dev_seq_fops, idev);
+        p = proc_create_single_data(idev->dev->name, 0444,
+                        net->mib.proc_net_devsnmp6, snmp6_dev_seq_show, idev);
         if (!p)
                 return -ENOMEM;
 
@@ -315,11 +278,12 @@ int snmp6_unregister_dev(struct inet6_dev *idev)
 
 static int __net_init ipv6_proc_init_net(struct net *net)
 {
-        if (!proc_create("sockstat6", 0444, net->proc_net,
-                         &sockstat6_seq_fops))
+        if (!proc_create_net_single("sockstat6", 0444, net->proc_net,
+                        sockstat6_seq_show, NULL))
                 return -ENOMEM;
 
-        if (!proc_create("snmp6", 0444, net->proc_net, &snmp6_seq_fops))
+        if (!proc_create_net_single("snmp6", 0444, net->proc_net,
+                        snmp6_seq_show, NULL))
                 goto proc_snmp6_fail;
 
         net->mib.proc_net_devsnmp6 = proc_mkdir("dev_snmp6", net->proc_net);
diff --git a/net/ipv6/raw.c b/net/ipv6/raw.c
index 5eb9b08947ed..afc307c89d1a 100644
--- a/net/ipv6/raw.c
+++ b/net/ipv6/raw.c
@@ -1304,21 +1304,10 @@ static const struct seq_operations raw6_seq_ops = {
         .show =         raw6_seq_show,
 };
 
-static int raw6_seq_open(struct inode *inode, struct file *file)
-{
-        return raw_seq_open(inode, file, &raw_v6_hashinfo, &raw6_seq_ops);
-}
-
-static const struct file_operations raw6_seq_fops = {
-        .open =         raw6_seq_open,
-        .read =         seq_read,
-        .llseek =       seq_lseek,
-        .release =      seq_release_net,
-};
-
 static int __net_init raw6_init_net(struct net *net)
 {
-        if (!proc_create("raw6", 0444, net->proc_net, &raw6_seq_fops))
+        if (!proc_create_net_data("raw6", 0444, net->proc_net, &raw6_seq_ops,
+                        sizeof(struct raw_iter_state), &raw_v6_hashinfo))
                 return -ENOMEM;
 
         return 0;
diff --git a/net/ipv6/route.c b/net/ipv6/route.c
index f4d61736c41a..a6598762d2c1 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,
  */
 
 #ifdef CONFIG_PROC_FS
-
-static const struct file_operations ipv6_route_proc_fops = {
-        .open           = ipv6_route_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = seq_release_net,
-};
-
 static int rt6_stats_seq_show(struct seq_file *seq, void *v)
 {
         struct net *net = (struct net *)seq->private;
@@ -4884,18 +4876,6 @@ static int rt6_stats_seq_show(struct seq_file *seq, void *v)
 
         return 0;
 }
-
-static int rt6_stats_seq_open(struct inode *inode, struct file *file)
-{
-        return single_open_net(inode, file, rt6_stats_seq_show);
-}
-
-static const struct file_operations rt6_stats_seq_fops = {
-        .open    = rt6_stats_seq_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = single_release_net,
-};
 #endif  /* CONFIG_PROC_FS */
 
 #ifdef CONFIG_SYSCTL
@@ -5100,8 +5080,10 @@ static void __net_exit ip6_route_net_exit(struct net *net)
 static int __net_init ip6_route_net_init_late(struct net *net)
 {
 #ifdef CONFIG_PROC_FS
-        proc_create("ipv6_route", 0, net->proc_net, &ipv6_route_proc_fops);
-        proc_create("rt6_stats", 0444, net->proc_net, &rt6_stats_seq_fops);
+        proc_create_net("ipv6_route", 0, net->proc_net, &ipv6_route_seq_ops,
+                        sizeof(struct ipv6_route_iter));
+        proc_create_net_single("rt6_stats", 0444, net->proc_net,
+                        rt6_stats_seq_show, NULL);
 #endif
         return 0;
 }
diff --git a/net/ipv6/tcp_ipv6.c b/net/ipv6/tcp_ipv6.c
index 6d664d83cd16..d2ce66b23430 100644
--- a/net/ipv6/tcp_ipv6.c
+++ b/net/ipv6/tcp_ipv6.c
@@ -1909,30 +1909,28 @@ out:
         return 0;
 }
 
-static const struct file_operations tcp6_afinfo_seq_fops = {
-        .open    = tcp_seq_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release_net
+static const struct seq_operations tcp6_seq_ops = {
+        .show           = tcp6_seq_show,
+        .start          = tcp_seq_start,
+        .next           = tcp_seq_next,
+        .stop           = tcp_seq_stop,
 };
 
 static struct tcp_seq_afinfo tcp6_seq_afinfo = {
-        .name           = "tcp6",
         .family         = AF_INET6,
-        .seq_fops       = &tcp6_afinfo_seq_fops,
-        .seq_ops        = {
-                .show           = tcp6_seq_show,
-        },
 };
 
 int __net_init tcp6_proc_init(struct net *net)
 {
-        return tcp_proc_register(net, &tcp6_seq_afinfo);
+        if (!proc_create_net_data("tcp6", 0444, net->proc_net, &tcp6_seq_ops,
+                        sizeof(struct tcp_iter_state), &tcp6_seq_afinfo))
+                return -ENOMEM;
+        return 0;
 }
 
 void tcp6_proc_exit(struct net *net)
 {
-        tcp_proc_unregister(net, &tcp6_seq_afinfo);
+        remove_proc_entry("tcp6", net->proc_net);
 }
 #endif
 
diff --git a/net/ipv6/udp.c b/net/ipv6/udp.c
index ea0730028e5d..00e2112da26d 100644
--- a/net/ipv6/udp.c
+++ b/net/ipv6/udp.c
@@ -1480,31 +1480,30 @@ 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,
-        .read     = seq_read,
-        .llseek   = seq_lseek,
-        .release  = seq_release_net
+const struct seq_operations udp6_seq_ops = {
+        .start          = udp_seq_start,
+        .next           = udp_seq_next,
+        .stop           = udp_seq_stop,
+        .show           = udp6_seq_show,
 };
+EXPORT_SYMBOL(udp6_seq_ops);
 
 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_net_data("udp6", 0444, net->proc_net, &udp6_seq_ops,
+                        sizeof(struct udp_iter_state), &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 14ae32bb1f3d..5000ad6878e6 100644
--- 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,23 @@ 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_net_data("udplite6", 0444, net->proc_net,
+                        &udp6_seq_ops, sizeof(struct udp_iter_state),
+                        &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 = {
diff --git a/net/kcm/kcmproc.c b/net/kcm/kcmproc.c
index 1fac92543094..370da2f80e3c 100644
--- a/net/kcm/kcmproc.c
+++ b/net/kcm/kcmproc.c
@@ -15,12 +15,6 @@
 #include <net/tcp.h>
 
 #ifdef CONFIG_PROC_FS
-struct kcm_seq_muxinfo {
-        char                            *name;
-        const struct file_operations    *seq_fops;
-        const struct seq_operations     seq_ops;
-};
-
 static struct kcm_mux *kcm_get_first(struct seq_file *seq)
 {
         struct net *net = seq_file_net(seq);
@@ -86,14 +80,6 @@ struct kcm_proc_mux_state {
         int idx;
 };
 
-static int kcm_seq_open(struct inode *inode, struct file *file)
-{
-        struct kcm_seq_muxinfo *muxinfo = PDE_DATA(inode);
-
-        return seq_open_net(inode, file, &muxinfo->seq_ops,
-                           sizeof(struct kcm_proc_mux_state));
-}
-
 static void kcm_format_mux_header(struct seq_file *seq)
 {
         struct net *net = seq_file_net(seq);
@@ -246,44 +232,13 @@ static int kcm_seq_show(struct seq_file *seq, void *v)
         return 0;
 }
 
-static const struct file_operations kcm_seq_fops = {
-        .open           = kcm_seq_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = seq_release_net,
+static const struct seq_operations kcm_seq_ops = {
+        .show   = kcm_seq_show,
+        .start  = kcm_seq_start,
+        .next   = kcm_seq_next,
+        .stop   = kcm_seq_stop,
 };
 
-static struct kcm_seq_muxinfo kcm_seq_muxinfo = {
-        .name           = "kcm",
-        .seq_fops       = &kcm_seq_fops,
-        .seq_ops        = {
-                .show   = kcm_seq_show,
-                .start  = kcm_seq_start,
-                .next   = kcm_seq_next,
-                .stop   = kcm_seq_stop,
-        }
-};
-
-static int kcm_proc_register(struct net *net, struct kcm_seq_muxinfo *muxinfo)
-{
-        struct proc_dir_entry *p;
-        int rc = 0;
-
-        p = proc_create_data(muxinfo->name, 0444, net->proc_net,
-                             muxinfo->seq_fops, muxinfo);
-        if (!p)
-                rc = -ENOMEM;
-        return rc;
-}
-EXPORT_SYMBOL(kcm_proc_register);
-
-static void kcm_proc_unregister(struct net *net,
-                                struct kcm_seq_muxinfo *muxinfo)
-{
-        remove_proc_entry(muxinfo->name, net->proc_net);
-}
-EXPORT_SYMBOL(kcm_proc_unregister);
-
 static int kcm_stats_seq_show(struct seq_file *seq, void *v)
 {
         struct kcm_psock_stats psock_stats;
@@ -390,30 +345,14 @@ static int kcm_stats_seq_show(struct seq_file *seq, void *v)
         return 0;
 }
 
-static int kcm_stats_seq_open(struct inode *inode, struct file *file)
-{
-        return single_open_net(inode, file, kcm_stats_seq_show);
-}
-
-static const struct file_operations kcm_stats_seq_fops = {
-        .open    = kcm_stats_seq_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = single_release_net,
-};
-
 static int kcm_proc_init_net(struct net *net)
 {
-        int err;
-
-        if (!proc_create("kcm_stats", 0444, net->proc_net,
-                         &kcm_stats_seq_fops)) {
-                err = -ENOMEM;
+        if (!proc_create_net_single("kcm_stats", 0444, net->proc_net,
+                         kcm_stats_seq_show, NULL))
                 goto out_kcm_stats;
-        }
 
-        err = kcm_proc_register(net, &kcm_seq_muxinfo);
-        if (err)
+        if (!proc_create_net("kcm", 0444, net->proc_net, &kcm_seq_ops,
+                        sizeof(struct kcm_proc_mux_state)))
                 goto out_kcm;
 
         return 0;
@@ -421,12 +360,12 @@ static int kcm_proc_init_net(struct net *net)
 out_kcm:
         remove_proc_entry("kcm_stats", net->proc_net);
 out_kcm_stats:
-        return err;
+        return -ENOMEM;
 }
 
 static void kcm_proc_exit_net(struct net *net)
 {
-        kcm_proc_unregister(net, &kcm_seq_muxinfo);
+        remove_proc_entry("kcm", net->proc_net);
         remove_proc_entry("kcm_stats", net->proc_net);
 }
 
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 = {
         .show   = pfkey_seq_show,
 };
 
-static int pfkey_seq_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &pfkey_seq_ops,
-                            sizeof(struct seq_net_private));
-}
-
-static const struct file_operations pfkey_proc_ops = {
-        .open    = pfkey_seq_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release_net,
-};
-
 static int __net_init pfkey_init_proc(struct net *net)
 {
         struct proc_dir_entry *e;
 
-        e = proc_create("pfkey", 0, net->proc_net, &pfkey_proc_ops);
+        e = proc_create_net("pfkey", 0, net->proc_net, &pfkey_seq_ops,
+                        sizeof(struct seq_net_private));
         if (e == NULL)
                 return -ENOMEM;
 
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 = {
         .stop           = pppol2tp_seq_stop,
         .show           = pppol2tp_seq_show,
 };
-
-/* Called when our /proc file is opened. We allocate data for use when
- * iterating our tunnel / session contexts and store it in the private
- * data of the seq_file.
- */
-static int pppol2tp_proc_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &pppol2tp_seq_ops,
-                            sizeof(struct pppol2tp_seq_data));
-}
-
-static const struct file_operations pppol2tp_proc_fops = {
-        .open           = pppol2tp_proc_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = seq_release_net,
-};
-
 #endif /* CONFIG_PROC_FS */
 
 /*****************************************************************************
@@ -1771,8 +1753,8 @@ static __net_init int pppol2tp_init_net(struct net *net)
         struct proc_dir_entry *pde;
         int err = 0;
 
-        pde = proc_create("pppol2tp", 0444, net->proc_net,
-                          &pppol2tp_proc_fops);
+        pde = proc_create_net("pppol2tp", 0444, net->proc_net,
+                        &pppol2tp_seq_ops, sizeof(struct pppol2tp_seq_data));
         if (!pde) {
                 err = -ENOMEM;
                 goto out;
diff --git a/net/llc/llc_proc.c b/net/llc/llc_proc.c
index 62ea0aed94b4..f3a36c16a5e7 100644
--- a/net/llc/llc_proc.c
+++ b/net/llc/llc_proc.c
@@ -214,30 +214,6 @@ static const struct seq_operations llc_seq_core_ops = {
         .show   = llc_seq_core_show,
 };
 
-static int llc_seq_socket_open(struct inode *inode, struct file *file)
-{
-        return seq_open(file, &llc_seq_socket_ops);
-}
-
-static int llc_seq_core_open(struct inode *inode, struct file *file)
-{
-        return seq_open(file, &llc_seq_core_ops);
-}
-
-static const struct file_operations llc_seq_socket_fops = {
-        .open           = llc_seq_socket_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = seq_release,
-};
-
-static const struct file_operations llc_seq_core_fops = {
-        .open           = llc_seq_core_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = seq_release,
-};
-
 static struct proc_dir_entry *llc_proc_dir;
 
 int __init llc_proc_init(void)
@@ -249,11 +225,11 @@ int __init llc_proc_init(void)
         if (!llc_proc_dir)
                 goto out;
 
-        p = proc_create("socket", 0444, llc_proc_dir, &llc_seq_socket_fops);
+        p = proc_create_seq("socket", 0444, llc_proc_dir, &llc_seq_socket_ops);
         if (!p)
                 goto out_socket;
 
-        p = proc_create("core", 0444, llc_proc_dir, &llc_seq_core_fops);
+        p = proc_create_seq("core", 0444, llc_proc_dir, &llc_seq_core_ops);
         if (!p)
                 goto out_core;
 
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 = {
         .stop  = ip_vs_app_seq_stop,
         .show  = ip_vs_app_seq_show,
 };
-
-static int ip_vs_app_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &ip_vs_app_seq_ops,
-                            sizeof(struct seq_net_private));
-}
-
-static const struct file_operations ip_vs_app_fops = {
-        .open    = ip_vs_app_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release_net,
-};
 #endif
 
 int __net_init ip_vs_app_net_init(struct netns_ipvs *ipvs)
 {
         INIT_LIST_HEAD(&ipvs->app_list);
-        proc_create("ip_vs_app", 0, ipvs->net->proc_net, &ip_vs_app_fops);
+        proc_create_net("ip_vs_app", 0, ipvs->net->proc_net, &ip_vs_app_seq_ops,
+                        sizeof(struct seq_net_private));
         return 0;
 }
 
diff --git a/net/netfilter/ipvs/ip_vs_conn.c b/net/netfilter/ipvs/ip_vs_conn.c
index 75de46576f51..61c3a389da89 100644
--- a/net/netfilter/ipvs/ip_vs_conn.c
+++ b/net/netfilter/ipvs/ip_vs_conn.c
@@ -1131,19 +1131,6 @@ static const struct seq_operations ip_vs_conn_seq_ops = {
         .show  = ip_vs_conn_seq_show,
 };
 
-static int ip_vs_conn_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &ip_vs_conn_seq_ops,
-                            sizeof(struct ip_vs_iter_state));
-}
-
-static const struct file_operations ip_vs_conn_fops = {
-        .open    = ip_vs_conn_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release_net,
-};
-
 static const char *ip_vs_origin_name(unsigned int flags)
 {
         if (flags & IP_VS_CONN_F_SYNC)
@@ -1207,20 +1194,6 @@ static const struct seq_operations ip_vs_conn_sync_seq_ops = {
         .stop  = ip_vs_conn_seq_stop,
         .show  = ip_vs_conn_sync_seq_show,
 };
-
-static int ip_vs_conn_sync_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &ip_vs_conn_sync_seq_ops,
-                            sizeof(struct ip_vs_iter_state));
-}
-
-static const struct file_operations ip_vs_conn_sync_fops = {
-        .open    = ip_vs_conn_sync_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release_net,
-};
-
 #endif
 
 
@@ -1380,9 +1353,11 @@ int __net_init ip_vs_conn_net_init(struct netns_ipvs *ipvs)
 {
         atomic_set(&ipvs->conn_count, 0);
 
-        proc_create("ip_vs_conn", 0, ipvs->net->proc_net, &ip_vs_conn_fops);
-        proc_create("ip_vs_conn_sync", 0, ipvs->net->proc_net,
-                    &ip_vs_conn_sync_fops);
+        proc_create_net("ip_vs_conn", 0, ipvs->net->proc_net,
+                        &ip_vs_conn_seq_ops, sizeof(struct ip_vs_iter_state));
+        proc_create_net("ip_vs_conn_sync", 0, ipvs->net->proc_net,
+                        &ip_vs_conn_sync_seq_ops,
+                        sizeof(struct ip_vs_iter_state));
         return 0;
 }
 
diff --git a/net/netfilter/ipvs/ip_vs_ctl.c b/net/netfilter/ipvs/ip_vs_ctl.c
index 3ecca0616d8c..141b1509c948 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 = {
         .show  = ip_vs_info_seq_show,
 };
 
-static int ip_vs_info_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &ip_vs_info_seq_ops,
-                        sizeof(struct ip_vs_iter));
-}
-
-static const struct file_operations ip_vs_info_fops = {
-        .open    = ip_vs_info_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release_net,
-};
-
 static int ip_vs_stats_show(struct seq_file *seq, void *v)
 {
         struct net *net = seq_file_single_net(seq);
@@ -2154,18 +2141,6 @@ static int ip_vs_stats_show(struct seq_file *seq, void *v)
         return 0;
 }
 
-static int ip_vs_stats_seq_open(struct inode *inode, struct file *file)
-{
-        return single_open_net(inode, file, ip_vs_stats_show);
-}
-
-static const struct file_operations ip_vs_stats_fops = {
-        .open = ip_vs_stats_seq_open,
-        .read = seq_read,
-        .llseek = seq_lseek,
-        .release = single_release_net,
-};
-
 static int ip_vs_stats_percpu_show(struct seq_file *seq, void *v)
 {
         struct net *net = seq_file_single_net(seq);
@@ -2221,18 +2196,6 @@ static int ip_vs_stats_percpu_show(struct seq_file *seq, void *v)
 
         return 0;
 }
-
-static int ip_vs_stats_percpu_seq_open(struct inode *inode, struct file *file)
-{
-        return single_open_net(inode, file, ip_vs_stats_percpu_show);
-}
-
-static const struct file_operations ip_vs_stats_percpu_fops = {
-        .open = ip_vs_stats_percpu_seq_open,
-        .read = seq_read,
-        .llseek = seq_lseek,
-        .release = single_release_net,
-};
 #endif
 
 /*
@@ -4039,10 +4002,12 @@ int __net_init ip_vs_control_net_init(struct netns_ipvs *ipvs)
 
         spin_lock_init(&ipvs->tot_stats.lock);
 
-        proc_create("ip_vs", 0, ipvs->net->proc_net, &ip_vs_info_fops);
-        proc_create("ip_vs_stats", 0, ipvs->net->proc_net, &ip_vs_stats_fops);
-        proc_create("ip_vs_stats_percpu", 0, ipvs->net->proc_net,
-                    &ip_vs_stats_percpu_fops);
+        proc_create_net("ip_vs", 0, ipvs->net->proc_net, &ip_vs_info_seq_ops,
+                        sizeof(struct ip_vs_iter));
+        proc_create_net_single("ip_vs_stats", 0, ipvs->net->proc_net,
+                        ip_vs_stats_show, NULL);
+        proc_create_net_single("ip_vs_stats_percpu", 0, ipvs->net->proc_net,
+                        ip_vs_stats_percpu_show, NULL);
 
         if (ip_vs_control_net_init_sysctl(ipvs))
                 goto err;
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 = {
         .stop = exp_seq_stop,
         .show = exp_seq_show
 };
-
-static int exp_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &exp_seq_ops,
-                        sizeof(struct ct_expect_iter_state));
-}
-
-static const struct file_operations exp_file_ops = {
-        .open    = exp_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release_net,
-};
 #endif /* CONFIG_NF_CONNTRACK_PROCFS */
 
 static int exp_proc_init(struct net *net)
@@ -666,8 +653,8 @@ static int exp_proc_init(struct net *net)
         kuid_t root_uid;
         kgid_t root_gid;
 
-        proc = proc_create("nf_conntrack_expect", 0440, net->proc_net,
-                           &exp_file_ops);
+        proc = proc_create_net("nf_conntrack_expect", 0440, net->proc_net,
+                        &exp_seq_ops, sizeof(struct ct_expect_iter_state));
         if (!proc)
                 return -ENOMEM;
 
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 = {
         .show  = ct_seq_show
 };
 
-static int ct_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &ct_seq_ops,
-                        sizeof(struct ct_iter_state));
-}
-
-static const struct file_operations ct_file_ops = {
-        .open    = ct_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release_net,
-};
-
 static void *ct_cpu_seq_start(struct seq_file *seq, loff_t *pos)
 {
         struct net *net = seq_file_net(seq);
@@ -467,26 +454,14 @@ static const struct seq_operations ct_cpu_seq_ops = {
         .show   = ct_cpu_seq_show,
 };
 
-static int ct_cpu_seq_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &ct_cpu_seq_ops,
-                            sizeof(struct seq_net_private));
-}
-
-static const struct file_operations ct_cpu_seq_fops = {
-        .open    = ct_cpu_seq_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release_net,
-};
-
 static int nf_conntrack_standalone_init_proc(struct net *net)
 {
         struct proc_dir_entry *pde;
         kuid_t root_uid;
         kgid_t root_gid;
 
-        pde = proc_create("nf_conntrack", 0440, net->proc_net, &ct_file_ops);
+        pde = proc_create_net("nf_conntrack", 0440, net->proc_net, &ct_seq_ops,
+                        sizeof(struct ct_iter_state));
         if (!pde)
                 goto out_nf_conntrack;
 
@@ -495,8 +470,8 @@ static int nf_conntrack_standalone_init_proc(struct net *net)
         if (uid_valid(root_uid) && gid_valid(root_gid))
                 proc_set_user(pde, root_uid, root_gid);
 
-        pde = proc_create("nf_conntrack", 0444, net->proc_net_stat,
-                          &ct_cpu_seq_fops);
+        pde = proc_create_net("nf_conntrack", 0444, net->proc_net_stat,
+                        &ct_cpu_seq_ops, sizeof(struct seq_net_private));
         if (!pde)
                 goto out_stat_nf_conntrack;
         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 = {
         .stop   = seq_stop,
         .show   = seq_show,
 };
-
-static int nflog_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &nflog_seq_ops,
-                            sizeof(struct seq_net_private));
-}
-
-static const struct file_operations nflog_file_ops = {
-        .open    = nflog_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release_net,
-};
-
-
 #endif /* PROC_FS */
 
 #ifdef CONFIG_SYSCTL
@@ -549,8 +534,8 @@ static int __net_init nf_log_net_init(struct net *net)
         int ret = -ENOMEM;
 
 #ifdef CONFIG_PROC_FS
-        if (!proc_create("nf_log", 0444,
-                         net->nf.proc_netfilter, &nflog_file_ops))
+        if (!proc_create_net("nf_log", 0444, net->nf.proc_netfilter,
+                        &nflog_seq_ops, sizeof(struct seq_net_private)))
                 return ret;
 #endif
         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 = {
         .show           = synproxy_cpu_seq_show,
 };
 
-static int synproxy_cpu_seq_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &synproxy_cpu_seq_ops,
-                            sizeof(struct seq_net_private));
-}
-
-static const struct file_operations synproxy_cpu_seq_fops = {
-        .open           = synproxy_cpu_seq_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = seq_release_net,
-};
-
 static int __net_init synproxy_proc_init(struct net *net)
 {
-        if (!proc_create("synproxy", 0444, net->proc_net_stat,
-                         &synproxy_cpu_seq_fops))
+        if (!proc_create_net("synproxy", 0444, net->proc_net_stat,
+                        &synproxy_cpu_seq_ops, sizeof(struct seq_net_private)))
                 return -ENOMEM;
         return 0;
 }
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 = {
         .stop   = seq_stop,
         .show   = seq_show,
 };
-
-static int nful_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &nful_seq_ops,
-                            sizeof(struct iter_state));
-}
-
-static const struct file_operations nful_file_ops = {
-        .open    = nful_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release_net,
-};
-
 #endif /* PROC_FS */
 
 static 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)
         spin_lock_init(&log->instances_lock);
 
 #ifdef CONFIG_PROC_FS
-        proc = proc_create("nfnetlink_log", 0440,
-                           net->nf.proc_netfilter, &nful_file_ops);
+        proc = proc_create_net("nfnetlink_log", 0440, net->nf.proc_netfilter,
+                        &nful_seq_ops, sizeof(struct iter_state));
         if (!proc)
                 return -ENOMEM;
 
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 = {
         .stop   = seq_stop,
         .show   = seq_show,
 };
-
-static int nfqnl_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &nfqnl_seq_ops,
-                        sizeof(struct iter_state));
-}
-
-static const struct file_operations nfqnl_file_ops = {
-        .open    = nfqnl_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release_net,
-};
-
 #endif /* PROC_FS */
 
 static 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)
         spin_lock_init(&q->instances_lock);
 
 #ifdef CONFIG_PROC_FS
-        if (!proc_create("nfnetlink_queue", 0440,
-                         net->nf.proc_netfilter, &nfqnl_file_ops))
+        if (!proc_create_net("nfnetlink_queue", 0440, net->nf.proc_netfilter,
+                        &nfqnl_seq_ops, sizeof(struct iter_state)))
                 return -ENOMEM;
 #endif
         nf_register_queue_handler(net, &nfqh);
diff --git a/net/netfilter/x_tables.c b/net/netfilter/x_tables.c
index cb7cb300c3bc..55cb4d197184 100644
--- a/net/netfilter/x_tables.c
+++ b/net/netfilter/x_tables.c
@@ -1495,15 +1495,10 @@ void *xt_unregister_table(struct xt_table *table)
 EXPORT_SYMBOL_GPL(xt_unregister_table);
 
 #ifdef CONFIG_PROC_FS
-struct xt_names_priv {
-        struct seq_net_private p;
-        u_int8_t af;
-};
 static void *xt_table_seq_start(struct seq_file *seq, loff_t *pos)
 {
-        struct xt_names_priv *priv = seq->private;
         struct net *net = seq_file_net(seq);
-        u_int8_t af = priv->af;
+        u_int8_t af = (unsigned long)PDE_DATA(file_inode(seq->file));
 
         mutex_lock(&xt[af].mutex);
         return seq_list_start(&net->xt.tables[af], *pos);
@@ -1511,17 +1506,15 @@ static void *xt_table_seq_start(struct seq_file *seq, loff_t *pos)
 
 static void *xt_table_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 {
-        struct xt_names_priv *priv = seq->private;
         struct net *net = seq_file_net(seq);
-        u_int8_t af = priv->af;
+        u_int8_t af = (unsigned long)PDE_DATA(file_inode(seq->file));
 
         return seq_list_next(v, &net->xt.tables[af], pos);
 }
 
 static void xt_table_seq_stop(struct seq_file *seq, void *v)
 {
-        struct xt_names_priv *priv = seq->private;
-        u_int8_t af = priv->af;
+        u_int8_t af = (unsigned long)PDE_DATA(file_inode(seq->file));
 
         mutex_unlock(&xt[af].mutex);
 }
@@ -1542,34 +1535,13 @@ static const struct seq_operations xt_table_seq_ops = {
         .show   = xt_table_seq_show,
 };
 
-static int xt_table_open(struct inode *inode, struct file *file)
-{
-        int ret;
-        struct xt_names_priv *priv;
-
-        ret = seq_open_net(inode, file, &xt_table_seq_ops,
-                           sizeof(struct xt_names_priv));
-        if (!ret) {
-                priv = ((struct seq_file *)file->private_data)->private;
-                priv->af = (unsigned long)PDE_DATA(inode);
-        }
-        return ret;
-}
-
-static const struct file_operations xt_table_ops = {
-        .open    = xt_table_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release_net,
-};
-
 /*
  * Traverse state for ip{,6}_{tables,matches} for helping crossing
  * the multi-AF mutexes.
  */
 struct nf_mttg_trav {
         struct list_head *head, *curr;
-        uint8_t class, nfproto;
+        uint8_t class;
 };
 
 enum {
@@ -1586,6 +1558,7 @@ static void *xt_mttg_seq_next(struct seq_file *seq, void *v, loff_t *ppos,
                 [MTTG_TRAV_NFP_UNSPEC] = MTTG_TRAV_NFP_SPEC,
                 [MTTG_TRAV_NFP_SPEC]   = MTTG_TRAV_DONE,
         };
+        uint8_t nfproto = (unsigned long)PDE_DATA(file_inode(seq->file));
         struct nf_mttg_trav *trav = seq->private;
 
         switch (trav->class) {
@@ -1600,9 +1573,9 @@ static void *xt_mttg_seq_next(struct seq_file *seq, void *v, loff_t *ppos,
                 if (trav->curr != trav->head)
                         break;
                 mutex_unlock(&xt[NFPROTO_UNSPEC].mutex);
-                mutex_lock(&xt[trav->nfproto].mutex);
+                mutex_lock(&xt[nfproto].mutex);
                 trav->head = trav->curr = is_target ?
-                        &xt[trav->nfproto].target : &xt[trav->nfproto].match;
+                        &xt[nfproto].target : &xt[nfproto].match;
                 trav->class = next_class[trav->class];
                 break;
         case MTTG_TRAV_NFP_SPEC:
@@ -1634,6 +1607,7 @@ static void *xt_mttg_seq_start(struct seq_file *seq, loff_t *pos,
 
 static void xt_mttg_seq_stop(struct seq_file *seq, void *v)
 {
+        uint8_t nfproto = (unsigned long)PDE_DATA(file_inode(seq->file));
         struct nf_mttg_trav *trav = seq->private;
 
         switch (trav->class) {
@@ -1641,7 +1615,7 @@ static void xt_mttg_seq_stop(struct seq_file *seq, void *v)
                 mutex_unlock(&xt[NFPROTO_UNSPEC].mutex);
                 break;
         case MTTG_TRAV_NFP_SPEC:
-                mutex_unlock(&xt[trav->nfproto].mutex);
+                mutex_unlock(&xt[nfproto].mutex);
                 break;
         }
 }
@@ -1680,24 +1654,6 @@ static const struct seq_operations xt_match_seq_ops = {
         .show   = xt_match_seq_show,
 };
 
-static int xt_match_open(struct inode *inode, struct file *file)
-{
-        struct nf_mttg_trav *trav;
-        trav = __seq_open_private(file, &xt_match_seq_ops, sizeof(*trav));
-        if (!trav)
-                return -ENOMEM;
-
-        trav->nfproto = (unsigned long)PDE_DATA(inode);
-        return 0;
-}
-
-static const struct file_operations xt_match_ops = {
-        .open    = xt_match_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release_private,
-};
-
 static void *xt_target_seq_start(struct seq_file *seq, loff_t *pos)
 {
         return xt_mttg_seq_start(seq, pos, true);
@@ -1732,24 +1688,6 @@ static const struct seq_operations xt_target_seq_ops = {
         .show   = xt_target_seq_show,
 };
 
-static int xt_target_open(struct inode *inode, struct file *file)
-{
-        struct nf_mttg_trav *trav;
-        trav = __seq_open_private(file, &xt_target_seq_ops, sizeof(*trav));
-        if (!trav)
-                return -ENOMEM;
-
-        trav->nfproto = (unsigned long)PDE_DATA(inode);
-        return 0;
-}
-
-static const struct file_operations xt_target_ops = {
-        .open    = xt_target_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release_private,
-};
-
 #define FORMAT_TABLES   "_tables_names"
 #define FORMAT_MATCHES  "_tables_matches"
 #define FORMAT_TARGETS  "_tables_targets"
@@ -1813,8 +1751,9 @@ int xt_proto_init(struct net *net, u_int8_t af)
 
         strlcpy(buf, xt_prefix[af], sizeof(buf));
         strlcat(buf, FORMAT_TABLES, sizeof(buf));
-        proc = proc_create_data(buf, 0440, net->proc_net, &xt_table_ops,
-                                (void *)(unsigned long)af);
+        proc = proc_create_net_data(buf, 0440, net->proc_net, &xt_table_seq_ops,
+                        sizeof(struct seq_net_private),
+                        (void *)(unsigned long)af);
         if (!proc)
                 goto out;
         if (uid_valid(root_uid) && gid_valid(root_gid))
@@ -1822,8 +1761,9 @@ int xt_proto_init(struct net *net, u_int8_t af)
 
         strlcpy(buf, xt_prefix[af], sizeof(buf));
         strlcat(buf, FORMAT_MATCHES, sizeof(buf));
-        proc = proc_create_data(buf, 0440, net->proc_net, &xt_match_ops,
-                                (void *)(unsigned long)af);
+        proc = proc_create_seq_private(buf, 0440, net->proc_net,
+                        &xt_match_seq_ops, sizeof(struct nf_mttg_trav),
+                        (void *)(unsigned long)af);
         if (!proc)
                 goto out_remove_tables;
         if (uid_valid(root_uid) && gid_valid(root_gid))
@@ -1831,8 +1771,9 @@ int xt_proto_init(struct net *net, u_int8_t af)
 
         strlcpy(buf, xt_prefix[af], sizeof(buf));
         strlcat(buf, FORMAT_TARGETS, sizeof(buf));
-        proc = proc_create_data(buf, 0440, net->proc_net, &xt_target_ops,
-                                (void *)(unsigned long)af);
+        proc = proc_create_seq_private(buf, 0440, net->proc_net,
+                         &xt_target_seq_ops, sizeof(struct nf_mttg_trav),
+                         (void *)(unsigned long)af);
         if (!proc)
                 goto out_remove_matches;
         if (uid_valid(root_uid) && gid_valid(root_gid))
diff --git a/net/netfilter/xt_hashlimit.c b/net/netfilter/xt_hashlimit.c
index 0cd73567e7ff..9b16402f29af 100644
--- a/net/netfilter/xt_hashlimit.c
+++ b/net/netfilter/xt_hashlimit.c
@@ -57,9 +57,9 @@ static inline struct hashlimit_net *hashlimit_pernet(struct net *net)
 }
 
 /* need to declare this at the top */
-static const struct file_operations dl_file_ops_v2;
-static const struct file_operations dl_file_ops_v1;
-static const struct file_operations dl_file_ops;
+static const struct seq_operations dl_seq_ops_v2;
+static const struct seq_operations dl_seq_ops_v1;
+static const struct seq_operations dl_seq_ops;
 
 /* hash table crap */
 struct dsthash_dst {
@@ -272,7 +272,7 @@ static int htable_create(struct net *net, struct hashlimit_cfg3 *cfg,
 {
         struct hashlimit_net *hashlimit_net = hashlimit_pernet(net);
         struct xt_hashlimit_htable *hinfo;
-        const struct file_operations *fops;
+        const struct seq_operations *ops;
         unsigned int size, i;
         int ret;
 
@@ -321,19 +321,19 @@ static int htable_create(struct net *net, struct hashlimit_cfg3 *cfg,
 
         switch (revision) {
         case 1:
-                fops = &dl_file_ops_v1;
+                ops = &dl_seq_ops_v1;
                 break;
         case 2:
-                fops = &dl_file_ops_v2;
+                ops = &dl_seq_ops_v2;
                 break;
         default:
-                fops = &dl_file_ops;
+                ops = &dl_seq_ops;
         }
 
-        hinfo->pde = proc_create_data(name, 0,
+        hinfo->pde = proc_create_seq_data(name, 0,
                 (family == NFPROTO_IPV4) ?
                 hashlimit_net->ipt_hashlimit : hashlimit_net->ip6t_hashlimit,
-                fops, hinfo);
+                ops, hinfo);
         if (hinfo->pde == NULL) {
                 kfree(hinfo->name);
                 vfree(hinfo);
@@ -1057,7 +1057,7 @@ static struct xt_match hashlimit_mt_reg[] __read_mostly = {
 static void *dl_seq_start(struct seq_file *s, loff_t *pos)
         __acquires(htable->lock)
 {
-        struct xt_hashlimit_htable *htable = s->private;
+        struct xt_hashlimit_htable *htable = PDE_DATA(file_inode(s->private));
         unsigned int *bucket;
 
         spin_lock_bh(&htable->lock);
@@ -1074,7 +1074,7 @@ static void *dl_seq_start(struct seq_file *s, loff_t *pos)
 
 static void *dl_seq_next(struct seq_file *s, void *v, loff_t *pos)
 {
-        struct xt_hashlimit_htable *htable = s->private;
+        struct xt_hashlimit_htable *htable = PDE_DATA(file_inode(s->private));
         unsigned int *bucket = v;
 
         *pos = ++(*bucket);
@@ -1088,7 +1088,7 @@ static void *dl_seq_next(struct seq_file *s, void *v, loff_t *pos)
 static void dl_seq_stop(struct seq_file *s, void *v)
         __releases(htable->lock)
 {
-        struct xt_hashlimit_htable *htable = s->private;
+        struct xt_hashlimit_htable *htable = PDE_DATA(file_inode(s->private));
         unsigned int *bucket = v;
 
         if (!IS_ERR(bucket))
@@ -1130,7 +1130,7 @@ static void dl_seq_print(struct dsthash_ent *ent, u_int8_t family,
 static int dl_seq_real_show_v2(struct dsthash_ent *ent, u_int8_t family,
                                struct seq_file *s)
 {
-        const struct xt_hashlimit_htable *ht = s->private;
+        struct xt_hashlimit_htable *ht = PDE_DATA(file_inode(s->private));
 
         spin_lock(&ent->lock);
         /* recalculate to show accurate numbers */
@@ -1145,7 +1145,7 @@ static int dl_seq_real_show_v2(struct dsthash_ent *ent, u_int8_t family,
 static int dl_seq_real_show_v1(struct dsthash_ent *ent, u_int8_t family,
                                struct seq_file *s)
 {
-        const struct xt_hashlimit_htable *ht = s->private;
+        struct xt_hashlimit_htable *ht = PDE_DATA(file_inode(s->private));
 
         spin_lock(&ent->lock);
         /* recalculate to show accurate numbers */
@@ -1160,7 +1160,7 @@ static int dl_seq_real_show_v1(struct dsthash_ent *ent, u_int8_t family,
 static int dl_seq_real_show(struct dsthash_ent *ent, u_int8_t family,
                             struct seq_file *s)
 {
-        const struct xt_hashlimit_htable *ht = s->private;
+        struct xt_hashlimit_htable *ht = PDE_DATA(file_inode(s->private));
 
         spin_lock(&ent->lock);
         /* recalculate to show accurate numbers */
@@ -1174,7 +1174,7 @@ static int dl_seq_real_show(struct dsthash_ent *ent, u_int8_t family,
 
 static int dl_seq_show_v2(struct seq_file *s, void *v)
 {
-        struct xt_hashlimit_htable *htable = s->private;
+        struct xt_hashlimit_htable *htable = PDE_DATA(file_inode(s->private));
         unsigned int *bucket = (unsigned int *)v;
         struct dsthash_ent *ent;
 
@@ -1188,7 +1188,7 @@ static int dl_seq_show_v2(struct seq_file *s, void *v)
 
 static int dl_seq_show_v1(struct seq_file *s, void *v)
 {
-        struct xt_hashlimit_htable *htable = s->private;
+        struct xt_hashlimit_htable *htable = PDE_DATA(file_inode(s->private));
         unsigned int *bucket = v;
         struct dsthash_ent *ent;
 
@@ -1202,7 +1202,7 @@ static int dl_seq_show_v1(struct seq_file *s, void *v)
 
 static int dl_seq_show(struct seq_file *s, void *v)
 {
-        struct xt_hashlimit_htable *htable = s->private;
+        struct xt_hashlimit_htable *htable = PDE_DATA(file_inode(s->private));
         unsigned int *bucket = v;
         struct dsthash_ent *ent;
 
@@ -1235,62 +1235,6 @@ static const struct seq_operations dl_seq_ops = {
         .show  = dl_seq_show
 };
 
-static int dl_proc_open_v2(struct inode *inode, struct file *file)
-{
-        int ret = seq_open(file, &dl_seq_ops_v2);
-
-        if (!ret) {
-                struct seq_file *sf = file->private_data;
-
-                sf->private = PDE_DATA(inode);
-        }
-        return ret;
-}
-
-static int dl_proc_open_v1(struct inode *inode, struct file *file)
-{
-        int ret = seq_open(file, &dl_seq_ops_v1);
-
-        if (!ret) {
-                struct seq_file *sf = file->private_data;
-                sf->private = PDE_DATA(inode);
-        }
-        return ret;
-}
-
-static int dl_proc_open(struct inode *inode, struct file *file)
-{
-        int ret = seq_open(file, &dl_seq_ops);
-
-        if (!ret) {
-                struct seq_file *sf = file->private_data;
-
-                sf->private = PDE_DATA(inode);
-        }
-        return ret;
-}
-
-static const struct file_operations dl_file_ops_v2 = {
-        .open    = dl_proc_open_v2,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release
-};
-
-static const struct file_operations dl_file_ops_v1 = {
-        .open    = dl_proc_open_v1,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release
-};
-
-static const struct file_operations dl_file_ops = {
-        .open    = dl_proc_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release
-};
-
 static int __net_init hashlimit_proc_net_init(struct net *net)
 {
         struct hashlimit_net *hashlimit_net = hashlimit_pernet(net);
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 = {
         .stop   = netlink_seq_stop,
         .show   = netlink_seq_show,
 };
-
-
-static int netlink_seq_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &netlink_seq_ops,
-                                sizeof(struct nl_seq_iter));
-}
-
-static const struct file_operations netlink_seq_fops = {
-        .open           = netlink_seq_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = seq_release_net,
-};
-
 #endif
 
 int netlink_register_notifier(struct notifier_block *nb)
@@ -2694,7 +2679,8 @@ static const struct net_proto_family netlink_family_ops = {
 static int __net_init netlink_net_init(struct net *net)
 {
 #ifdef CONFIG_PROC_FS
-        if (!proc_create("netlink", 0, net->proc_net, &netlink_seq_fops))
+        if (!proc_create_net("netlink", 0, net->proc_net, &netlink_seq_ops,
+                        sizeof(struct nl_seq_iter)))
                 return -ENOMEM;
 #endif
         return 0;
diff --git a/net/netrom/af_netrom.c b/net/netrom/af_netrom.c
index 4221d98a314b..c2888c78d4c1 100644
--- a/net/netrom/af_netrom.c
+++ b/net/netrom/af_netrom.c
@@ -1338,18 +1338,6 @@ static const struct seq_operations nr_info_seqops = {
         .stop = nr_info_stop,
         .show = nr_info_show,
 };
-
-static int nr_info_open(struct inode *inode, struct file *file)
-{
-        return seq_open(file, &nr_info_seqops);
-}
-
-static const struct file_operations nr_info_fops = {
-        .open = nr_info_open,
-        .read = seq_read,
-        .llseek = seq_lseek,
-        .release = seq_release,
-};
 #endif  /* CONFIG_PROC_FS */
 
 static const struct net_proto_family nr_family_ops = {
@@ -1450,9 +1438,9 @@ static int __init nr_proto_init(void)
 
         nr_loopback_init();
 
-        proc_create("nr", 0444, init_net.proc_net, &nr_info_fops);
-        proc_create("nr_neigh", 0444, init_net.proc_net, &nr_neigh_fops);
-        proc_create("nr_nodes", 0444, init_net.proc_net, &nr_nodes_fops);
+        proc_create_seq("nr", 0444, init_net.proc_net, &nr_info_seqops);
+        proc_create_seq("nr_neigh", 0444, init_net.proc_net, &nr_neigh_seqops);
+        proc_create_seq("nr_nodes", 0444, init_net.proc_net, &nr_node_seqops);
 out:
         return rc;
 fail:
diff --git a/net/netrom/nr_route.c b/net/netrom/nr_route.c
index b5a7dcb30991..6485f593e2f0 100644
--- a/net/netrom/nr_route.c
+++ b/net/netrom/nr_route.c
@@ -888,25 +888,13 @@ static int nr_node_show(struct seq_file *seq, void *v)
         return 0;
 }
 
-static const struct seq_operations nr_node_seqops = {
+const struct seq_operations nr_node_seqops = {
         .start = nr_node_start,
         .next = nr_node_next,
         .stop = nr_node_stop,
         .show = nr_node_show,
 };
 
-static int nr_node_info_open(struct inode *inode, struct file *file)
-{
-        return seq_open(file, &nr_node_seqops);
-}
-
-const struct file_operations nr_nodes_fops = {
-        .open = nr_node_info_open,
-        .read = seq_read,
-        .llseek = seq_lseek,
-        .release = seq_release,
-};
-
 static void *nr_neigh_start(struct seq_file *seq, loff_t *pos)
 {
         spin_lock_bh(&nr_neigh_list_lock);
@@ -954,25 +942,12 @@ static int nr_neigh_show(struct seq_file *seq, void *v)
         return 0;
 }
 
-static const struct seq_operations nr_neigh_seqops = {
+const struct seq_operations nr_neigh_seqops = {
         .start = nr_neigh_start,
         .next = nr_neigh_next,
         .stop = nr_neigh_stop,
         .show = nr_neigh_show,
 };
-
-static int nr_neigh_info_open(struct inode *inode, struct file *file)
-{
-        return seq_open(file, &nr_neigh_seqops);
-}
-
-const struct file_operations nr_neigh_fops = {
-        .open = nr_neigh_info_open,
-        .read = seq_read,
-        .llseek = seq_lseek,
-        .release = seq_release,
-};
-
 #endif
 
 /*
diff --git a/net/packet/af_packet.c b/net/packet/af_packet.c
index acb7b86574cd..f9cdd27a7f6f 100644
--- a/net/packet/af_packet.c
+++ b/net/packet/af_packet.c
@@ -4556,20 +4556,6 @@ static const struct seq_operations packet_seq_ops = {
         .stop   = packet_seq_stop,
         .show   = packet_seq_show,
 };
-
-static int packet_seq_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &packet_seq_ops,
-                            sizeof(struct seq_net_private));
-}
-
-static const struct file_operations packet_seq_fops = {
-        .open           = packet_seq_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = seq_release_net,
-};
-
 #endif
 
 static int __net_init packet_net_init(struct net *net)
@@ -4577,7 +4563,8 @@ static int __net_init packet_net_init(struct net *net)
         mutex_init(&net->packet.sklist_lock);
         INIT_HLIST_HEAD(&net->packet.sklist);
 
-        if (!proc_create("packet", 0, net->proc_net, &packet_seq_fops))
+        if (!proc_create_net("packet", 0, net->proc_net, &packet_seq_ops,
+                        sizeof(struct seq_net_private)))
                 return -ENOMEM;
 
         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)
 {
         struct phonet_net *pnn = phonet_pernet(net);
 
-        if (!proc_create("phonet", 0, net->proc_net, &pn_sock_seq_fops))
+        if (!proc_create_net("phonet", 0, net->proc_net, &pn_sock_seq_ops,
+                        sizeof(struct seq_net_private)))
                 return -ENOMEM;
 
         INIT_LIST_HEAD(&pnn->pndevs.list);
@@ -351,7 +352,8 @@ int __init phonet_device_init(void)
         if (err)
                 return err;
 
-        proc_create("pnresource", 0, init_net.proc_net, &pn_res_seq_fops);
+        proc_create_net("pnresource", 0, init_net.proc_net, &pn_res_seq_ops,
+                        sizeof(struct seq_net_private));
         register_netdevice_notifier(&phonet_device_notifier);
         err = phonet_netlink_register();
         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)
         return 0;
 }
 
-static const struct seq_operations pn_sock_seq_ops = {
+const struct seq_operations pn_sock_seq_ops = {
         .start = pn_sock_seq_start,
         .next = pn_sock_seq_next,
         .stop = pn_sock_seq_stop,
         .show = pn_sock_seq_show,
 };
-
-static int pn_sock_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &pn_sock_seq_ops,
-                                sizeof(struct seq_net_private));
-}
-
-const struct file_operations pn_sock_seq_fops = {
-        .open = pn_sock_open,
-        .read = seq_read,
-        .llseek = seq_lseek,
-        .release = seq_release_net,
-};
 #endif
 
 static struct  {
@@ -802,23 +789,10 @@ static int pn_res_seq_show(struct seq_file *seq, void *v)
         return 0;
 }
 
-static const struct seq_operations pn_res_seq_ops = {
+const struct seq_operations pn_res_seq_ops = {
         .start = pn_res_seq_start,
         .next = pn_res_seq_next,
         .stop = pn_res_seq_stop,
         .show = pn_res_seq_show,
 };
-
-static int pn_res_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &pn_res_seq_ops,
-                                sizeof(struct seq_net_private));
-}
-
-const struct file_operations pn_res_seq_fops = {
-        .open = pn_res_open,
-        .read = seq_read,
-        .llseek = seq_lseek,
-        .release = seq_release_net,
-};
 #endif
diff --git a/net/rose/af_rose.c b/net/rose/af_rose.c
index 9ff5e0a76593..22a7f2b413ac 100644
--- a/net/rose/af_rose.c
+++ b/net/rose/af_rose.c
@@ -1453,18 +1453,6 @@ static const struct seq_operations rose_info_seqops = {
         .stop = rose_info_stop,
         .show = rose_info_show,
 };
-
-static int rose_info_open(struct inode *inode, struct file *file)
-{
-        return seq_open(file, &rose_info_seqops);
-}
-
-static const struct file_operations rose_info_fops = {
-        .open = rose_info_open,
-        .read = seq_read,
-        .llseek = seq_lseek,
-        .release = seq_release,
-};
 #endif  /* CONFIG_PROC_FS */
 
 static const struct net_proto_family rose_family_ops = {
@@ -1567,13 +1555,13 @@ static int __init rose_proto_init(void)
 
         rose_add_loopback_neigh();
 
-        proc_create("rose", 0444, init_net.proc_net, &rose_info_fops);
-        proc_create("rose_neigh", 0444, init_net.proc_net,
-                    &rose_neigh_fops);
-        proc_create("rose_nodes", 0444, init_net.proc_net,
-                    &rose_nodes_fops);
-        proc_create("rose_routes", 0444, init_net.proc_net,
-                    &rose_routes_fops);
+        proc_create_seq("rose", 0444, init_net.proc_net, &rose_info_seqops);
+        proc_create_seq("rose_neigh", 0444, init_net.proc_net,
+                    &rose_neigh_seqops);
+        proc_create_seq("rose_nodes", 0444, init_net.proc_net,
+                    &rose_node_seqops);
+        proc_create_seq("rose_routes", 0444, init_net.proc_net,
+                    &rose_route_seqops);
 out:
         return rc;
 fail:
diff --git a/net/rose/rose_route.c b/net/rose/rose_route.c
index 178619ddab68..77e9f85a2c92 100644
--- a/net/rose/rose_route.c
+++ b/net/rose/rose_route.c
@@ -1143,25 +1143,13 @@ static int rose_node_show(struct seq_file *seq, void *v)
         return 0;
 }
 
-static const struct seq_operations rose_node_seqops = {
+const struct seq_operations rose_node_seqops = {
         .start = rose_node_start,
         .next = rose_node_next,
         .stop = rose_node_stop,
         .show = rose_node_show,
 };
 
-static int rose_nodes_open(struct inode *inode, struct file *file)
-{
-        return seq_open(file, &rose_node_seqops);
-}
-
-const struct file_operations rose_nodes_fops = {
-        .open = rose_nodes_open,
-        .read = seq_read,
-        .llseek = seq_lseek,
-        .release = seq_release,
-};
-
 static void *rose_neigh_start(struct seq_file *seq, loff_t *pos)
         __acquires(rose_neigh_list_lock)
 {
@@ -1226,26 +1214,13 @@ static int rose_neigh_show(struct seq_file *seq, void *v)
 }
 
 
-static const struct seq_operations rose_neigh_seqops = {
+const struct seq_operations rose_neigh_seqops = {
         .start = rose_neigh_start,
         .next = rose_neigh_next,
         .stop = rose_neigh_stop,
         .show = rose_neigh_show,
 };
 
-static int rose_neigh_open(struct inode *inode, struct file *file)
-{
-        return seq_open(file, &rose_neigh_seqops);
-}
-
-const struct file_operations rose_neigh_fops = {
-        .open = rose_neigh_open,
-        .read = seq_read,
-        .llseek = seq_lseek,
-        .release = seq_release,
-};
-
-
 static void *rose_route_start(struct seq_file *seq, loff_t *pos)
         __acquires(rose_route_list_lock)
 {
@@ -1311,25 +1286,12 @@ static int rose_route_show(struct seq_file *seq, void *v)
         return 0;
 }
 
-static const struct seq_operations rose_route_seqops = {
+struct seq_operations rose_route_seqops = {
         .start = rose_route_start,
         .next = rose_route_next,
         .stop = rose_route_stop,
         .show = rose_route_show,
 };
-
-static int rose_route_open(struct inode *inode, struct file *file)
-{
-        return seq_open(file, &rose_route_seqops);
-}
-
-const struct file_operations rose_routes_fops = {
-        .open = rose_route_open,
-        .read = seq_read,
-        .llseek = seq_lseek,
-        .release = seq_release,
-};
-
 #endif /* CONFIG_PROC_FS */
 
 /*
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 *);
 /*
  * proc.c
  */
-extern const struct file_operations rxrpc_call_seq_fops;
-extern const struct file_operations rxrpc_connection_seq_fops;
+extern const struct seq_operations rxrpc_call_seq_ops;
+extern const struct seq_operations rxrpc_connection_seq_ops;
 
 /*
  * 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)
         if (!rxnet->proc_net)
                 goto err_proc;
 
-        proc_create("calls", 0444, rxnet->proc_net, &rxrpc_call_seq_fops);
-        proc_create("conns", 0444, rxnet->proc_net, &rxrpc_connection_seq_fops);
+        proc_create_net("calls", 0444, rxnet->proc_net, &rxrpc_call_seq_ops,
+                        sizeof(struct seq_net_private));
+        proc_create_net("conns", 0444, rxnet->proc_net,
+                        &rxrpc_connection_seq_ops,
+                        sizeof(struct seq_net_private));
         return 0;
 
 err_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)
         return 0;
 }
 
-static const struct seq_operations rxrpc_call_seq_ops = {
+const struct seq_operations rxrpc_call_seq_ops = {
         .start  = rxrpc_call_seq_start,
         .next   = rxrpc_call_seq_next,
         .stop   = rxrpc_call_seq_stop,
         .show   = rxrpc_call_seq_show,
 };
 
-static int rxrpc_call_seq_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &rxrpc_call_seq_ops,
-                            sizeof(struct seq_net_private));
-}
-
-const struct file_operations rxrpc_call_seq_fops = {
-        .open           = rxrpc_call_seq_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = seq_release,
-};
-
 /*
  * generate a list of extant virtual connections in /proc/net/rxrpc_conns
  */
@@ -207,23 +194,9 @@ print:
         return 0;
 }
 
-static const struct seq_operations rxrpc_connection_seq_ops = {
+const struct seq_operations rxrpc_connection_seq_ops = {
         .start  = rxrpc_connection_seq_start,
         .next   = rxrpc_connection_seq_next,
         .stop   = rxrpc_connection_seq_stop,
         .show   = rxrpc_connection_seq_show,
 };
-
-
-static int rxrpc_connection_seq_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &rxrpc_connection_seq_ops,
-                            sizeof(struct seq_net_private));
-}
-
-const struct file_operations rxrpc_connection_seq_fops = {
-        .open           = rxrpc_connection_seq_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = seq_release,
-};
diff --git a/net/sched/sch_api.c b/net/sched/sch_api.c
index 106dae7e4818..54eca685420f 100644
--- a/net/sched/sch_api.c
+++ b/net/sched/sch_api.c
@@ -2092,23 +2092,11 @@ static int psched_show(struct seq_file *seq, void *v)
         return 0;
 }
 
-static int psched_open(struct inode *inode, struct file *file)
-{
-        return single_open(file, psched_show, NULL);
-}
-
-static const struct file_operations psched_fops = {
-        .open = psched_open,
-        .read  = seq_read,
-        .llseek = seq_lseek,
-        .release = single_release,
-};
-
 static int __net_init psched_net_init(struct net *net)
 {
         struct proc_dir_entry *e;
 
-        e = proc_create("psched", 0, net->proc_net, &psched_fops);
+        e = proc_create_single("psched", 0, net->proc_net, psched_show);
         if (e == NULL)
                 return -ENOMEM;
 
diff --git a/net/sctp/objcnt.c b/net/sctp/objcnt.c
index fd2684ad94c8..a6179b26b80c 100644
--- a/net/sctp/objcnt.c
+++ b/net/sctp/objcnt.c
@@ -108,25 +108,13 @@ static const struct seq_operations sctp_objcnt_seq_ops = {
         .show  = sctp_objcnt_seq_show,
 };
 
-static int sctp_objcnt_seq_open(struct inode *inode, struct file *file)
-{
-        return seq_open(file, &sctp_objcnt_seq_ops);
-}
-
-static const struct file_operations sctp_objcnt_ops = {
-        .open    = sctp_objcnt_seq_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release,
-};
-
 /* Initialize the objcount in the proc filesystem.  */
 void sctp_dbg_objcnt_init(struct net *net)
 {
         struct proc_dir_entry *ent;
 
-        ent = proc_create("sctp_dbg_objcnt", 0,
-                          net->sctp.proc_net_sctp, &sctp_objcnt_ops);
+        ent = proc_create_seq("sctp_dbg_objcnt", 0,
+                          net->sctp.proc_net_sctp, &sctp_objcnt_seq_ops);
         if (!ent)
                 pr_warn("sctp_dbg_objcnt: Unable to create /proc entry.\n");
 }
diff --git a/net/sctp/proc.c b/net/sctp/proc.c
index 1d9ccc6dab2b..ef5c9a82d4e8 100644
--- a/net/sctp/proc.c
+++ b/net/sctp/proc.c
@@ -88,19 +88,6 @@ static int sctp_snmp_seq_show(struct seq_file *seq, void *v)
         return 0;
 }
 
-/* Initialize the seq file operations for 'snmp' object. */
-static int sctp_snmp_seq_open(struct inode *inode, struct file *file)
-{
-        return single_open_net(inode, file, sctp_snmp_seq_show);
-}
-
-static const struct file_operations sctp_snmp_seq_fops = {
-        .open    = sctp_snmp_seq_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = single_release_net,
-};
-
 /* Dump local addresses of an association/endpoint. */
 static void sctp_seq_dump_local_addrs(struct seq_file *seq, struct sctp_ep_common *epb)
 {
@@ -225,21 +212,6 @@ static const struct seq_operations sctp_eps_ops = {
         .show  = sctp_eps_seq_show,
 };
 
-
-/* Initialize the seq file operations for 'eps' object. */
-static int sctp_eps_seq_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &sctp_eps_ops,
-                            sizeof(struct seq_net_private));
-}
-
-static const struct file_operations sctp_eps_seq_fops = {
-        .open    = sctp_eps_seq_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release_net,
-};
-
 struct sctp_ht_iter {
         struct seq_net_private p;
         struct rhashtable_iter hti;
@@ -338,20 +310,6 @@ static const struct seq_operations sctp_assoc_ops = {
         .show  = sctp_assocs_seq_show,
 };
 
-/* Initialize the seq file operations for 'assocs' object. */
-static int sctp_assocs_seq_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &sctp_assoc_ops,
-                            sizeof(struct sctp_ht_iter));
-}
-
-static const struct file_operations sctp_assocs_seq_fops = {
-        .open    = sctp_assocs_seq_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release_net,
-};
-
 static int sctp_remaddr_seq_show(struct seq_file *seq, void *v)
 {
         struct sctp_association *assoc;
@@ -431,36 +389,23 @@ static const struct seq_operations sctp_remaddr_ops = {
         .show  = sctp_remaddr_seq_show,
 };
 
-static int sctp_remaddr_seq_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &sctp_remaddr_ops,
-                            sizeof(struct sctp_ht_iter));
-}
-
-static const struct file_operations sctp_remaddr_seq_fops = {
-        .open = sctp_remaddr_seq_open,
-        .read = seq_read,
-        .llseek = seq_lseek,
-        .release = seq_release_net,
-};
-
 /* Set up the proc fs entry for the SCTP protocol. */
 int __net_init sctp_proc_init(struct net *net)
 {
         net->sctp.proc_net_sctp = proc_net_mkdir(net, "sctp", net->proc_net);
         if (!net->sctp.proc_net_sctp)
                 return -ENOMEM;
-        if (!proc_create("snmp", 0444, net->sctp.proc_net_sctp,
-                         &sctp_snmp_seq_fops))
+        if (!proc_create_net_single("snmp", 0444, net->sctp.proc_net_sctp,
+                         sctp_snmp_seq_show, NULL))
                 goto cleanup;
-        if (!proc_create("eps", 0444, net->sctp.proc_net_sctp,
-                         &sctp_eps_seq_fops))
+        if (!proc_create_net("eps", 0444, net->sctp.proc_net_sctp,
+                        &sctp_eps_ops, sizeof(struct seq_net_private)))
                 goto cleanup;
-        if (!proc_create("assocs", 0444, net->sctp.proc_net_sctp,
-                         &sctp_assocs_seq_fops))
+        if (!proc_create_net("assocs", 0444, net->sctp.proc_net_sctp,
+                        &sctp_assoc_ops, sizeof(struct sctp_ht_iter)))
                 goto cleanup;
-        if (!proc_create("remaddr", 0444, net->sctp.proc_net_sctp,
-                         &sctp_remaddr_seq_fops))
+        if (!proc_create_net("remaddr", 0444, net->sctp.proc_net_sctp,
+                        &sctp_remaddr_ops, sizeof(struct sctp_ht_iter)))
                 goto cleanup;
         return 0;
 
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 = {
         .stop   = unix_seq_stop,
         .show   = unix_seq_show,
 };
-
-static int unix_seq_open(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &unix_seq_ops,
-                            sizeof(struct seq_net_private));
-}
-
-static const struct file_operations unix_seq_fops = {
-        .open           = unix_seq_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = seq_release_net,
-};
-
 #endif
 
 static const struct net_proto_family unix_family_ops = {
@@ -2884,7 +2870,8 @@ static int __net_init unix_net_init(struct net *net)
                 goto out;
 
 #ifdef CONFIG_PROC_FS
-        if (!proc_create("unix", 0, net->proc_net, &unix_seq_fops)) {
+        if (!proc_create_net("unix", 0, net->proc_net, &unix_seq_ops,
+                        sizeof(struct seq_net_private))) {
                 unix_sysctl_unregister(net);
                 goto out;
         }
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 = {
         .show  = wireless_dev_seq_show,
 };
 
-static int seq_open_wireless(struct inode *inode, struct file *file)
-{
-        return seq_open_net(inode, file, &wireless_seq_ops,
-                            sizeof(struct seq_net_private));
-}
-
-static const struct file_operations wireless_seq_fops = {
-        .open    = seq_open_wireless,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = seq_release_net,
-};
-
 int __net_init wext_proc_init(struct net *net)
 {
         /* Create /proc/net/wireless entry */
-        if (!proc_create("wireless", 0444, net->proc_net,
-                         &wireless_seq_fops))
+        if (!proc_create_net("wireless", 0444, net->proc_net,
+                        &wireless_seq_ops, sizeof(struct seq_net_private)))
                 return -ENOMEM;
 
         return 0;
diff --git a/net/x25/x25_proc.c b/net/x25/x25_proc.c
index 64b415e93f6a..da52c9dc256c 100644
--- a/net/x25/x25_proc.c
+++ b/net/x25/x25_proc.c
@@ -171,57 +171,21 @@ static const struct seq_operations x25_seq_forward_ops = {
         .show   = x25_seq_forward_show,
 };
 
-static int x25_seq_socket_open(struct inode *inode, struct file *file)
-{
-        return seq_open(file, &x25_seq_socket_ops);
-}
-
-static int x25_seq_route_open(struct inode *inode, struct file *file)
-{
-        return seq_open(file, &x25_seq_route_ops);
-}
-
-static int x25_seq_forward_open(struct inode *inode, struct file *file)
-{
-        return seq_open(file, &x25_seq_forward_ops);
-}
-
-static const struct file_operations x25_seq_socket_fops = {
-        .open           = x25_seq_socket_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = seq_release,
-};
-
-static const struct file_operations x25_seq_route_fops = {
-        .open           = x25_seq_route_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = seq_release,
-};
-
-static const struct file_operations x25_seq_forward_fops = {
-        .open           = x25_seq_forward_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = seq_release,
-};
-
 int __init x25_proc_init(void)
 {
         if (!proc_mkdir("x25", init_net.proc_net))
                 return -ENOMEM;
 
-        if (!proc_create("x25/route", 0444, init_net.proc_net,
-                         &x25_seq_route_fops))
+        if (!proc_create_seq("x25/route", 0444, init_net.proc_net,
+                         &x25_seq_route_ops))
                 goto out;
 
-        if (!proc_create("x25/socket", 0444, init_net.proc_net,
-                         &x25_seq_socket_fops))
+        if (!proc_create_seq("x25/socket", 0444, init_net.proc_net,
+                         &x25_seq_socket_ops))
                 goto out;
 
-        if (!proc_create("x25/forward", 0444, init_net.proc_net,
-                         &x25_seq_forward_fops))
+        if (!proc_create_seq("x25/forward", 0444, init_net.proc_net,
+                         &x25_seq_forward_ops))
                 goto out;
         return 0;
 
diff --git a/net/xfrm/xfrm_proc.c b/net/xfrm/xfrm_proc.c
index ed06903cd84d..178318d2e120 100644
--- a/net/xfrm/xfrm_proc.c
+++ b/net/xfrm/xfrm_proc.c
@@ -65,22 +65,10 @@ static int xfrm_statistics_seq_show(struct seq_file *seq, void *v)
         return 0;
 }
 
-static int xfrm_statistics_seq_open(struct inode *inode, struct file *file)
-{
-        return single_open_net(inode, file, xfrm_statistics_seq_show);
-}
-
-static const struct file_operations xfrm_statistics_seq_fops = {
-        .open    = xfrm_statistics_seq_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = single_release_net,
-};
-
 int __net_init xfrm_proc_init(struct net *net)
 {
-        if (!proc_create("xfrm_stat", 0444, net->proc_net,
-                         &xfrm_statistics_seq_fops))
+        if (!proc_create_net_single("xfrm_stat", 0444, net->proc_net,
+                         xfrm_statistics_seq_show, NULL))
                 return -ENOMEM;
         return 0;
 }