net/x25/x25_proc.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  X.25 Packet Layer release 002
0004  *
0005  *  This is ALPHA test software. This code may break your machine,
0006  *  randomly fail to work with new releases, misbehave and/or generally
0007  *  screw up. It might even work.
0008  *
0009  *  This code REQUIRES 2.4 with seq_file support
0010  *
0011  *  History
0012  *  2002/10/06  Arnaldo Carvalho de Melo  seq_file support
0013  */
0014
0015 #include <linux/init.h>
0016 #include <linux/proc_fs.h>
0017 #include <linux/seq_file.h>
0018 #include <linux/export.h>
0019 #include <net/net_namespace.h>
0020 #include <net/sock.h>
0021 #include <net/x25.h>
0022
0023 #ifdef CONFIG_PROC_FS
0024
0025 static void *x25_seq_route_start(struct seq_file *seq, loff_t *pos)
0026     __acquires(x25_route_list_lock)
0027 {
0028     read_lock_bh(&x25_route_list_lock);
0029     return seq_list_start_head(&x25_route_list, *pos);
0030 }
0031
0032 static void *x25_seq_route_next(struct seq_file *seq, void *v, loff_t *pos)
0033 {
0034     return seq_list_next(v, &x25_route_list, pos);
0035 }
0036
0037 static void x25_seq_route_stop(struct seq_file *seq, void *v)
0038     __releases(x25_route_list_lock)
0039 {
0040     read_unlock_bh(&x25_route_list_lock);
0041 }
0042
0043 static int x25_seq_route_show(struct seq_file *seq, void *v)
0044 {
0045     struct x25_route *rt = list_entry(v, struct x25_route, node);
0046
0047     if (v == &x25_route_list) {
0048         seq_puts(seq, "Address          Digits  Device\n");
0049         goto out;
0050     }
0051
0052     rt = v;
0053     seq_printf(seq, "%-15s  %-6d  %-5s\n",
0054            rt->address.x25_addr, rt->sigdigits,
0055            rt->dev ? rt->dev->name : "???");
0056 out:
0057     return 0;
0058 }
0059
0060 static void *x25_seq_socket_start(struct seq_file *seq, loff_t *pos)
0061     __acquires(x25_list_lock)
0062 {
0063     read_lock_bh(&x25_list_lock);
0064     return seq_hlist_start_head(&x25_list, *pos);
0065 }
0066
0067 static void *x25_seq_socket_next(struct seq_file *seq, void *v, loff_t *pos)
0068 {
0069     return seq_hlist_next(v, &x25_list, pos);
0070 }
0071
0072 static void x25_seq_socket_stop(struct seq_file *seq, void *v)
0073     __releases(x25_list_lock)
0074 {
0075     read_unlock_bh(&x25_list_lock);
0076 }
0077
0078 static int x25_seq_socket_show(struct seq_file *seq, void *v)
0079 {
0080     struct sock *s;
0081     struct x25_sock *x25;
0082     const char *devname;
0083
0084     if (v == SEQ_START_TOKEN) {
0085         seq_printf(seq, "dest_addr  src_addr   dev   lci st vs vr "
0086                 "va   t  t2 t21 t22 t23 Snd-Q Rcv-Q inode\n");
0087         goto out;
0088     }
0089
0090     s = sk_entry(v);
0091     x25 = x25_sk(s);
0092
0093     if (!x25->neighbour || !x25->neighbour->dev)
0094         devname = "???";
0095     else
0096         devname = x25->neighbour->dev->name;
0097
0098     seq_printf(seq, "%-10s %-10s %-5s %3.3X  %d  %d  %d  %d %3lu %3lu "
0099             "%3lu %3lu %3lu %5d %5d %ld\n",
0100            !x25->dest_addr.x25_addr[0] ? "*" : x25->dest_addr.x25_addr,
0101            !x25->source_addr.x25_addr[0] ? "*" : x25->source_addr.x25_addr,
0102            devname, x25->lci & 0x0FFF, x25->state, x25->vs, x25->vr,
0103            x25->va, x25_display_timer(s) / HZ, x25->t2  / HZ,
0104            x25->t21 / HZ, x25->t22 / HZ, x25->t23 / HZ,
0105            sk_wmem_alloc_get(s),
0106            sk_rmem_alloc_get(s),
0107            s->sk_socket ? SOCK_INODE(s->sk_socket)->i_ino : 0L);
0108 out:
0109     return 0;
0110 }
0111
0112 static void *x25_seq_forward_start(struct seq_file *seq, loff_t *pos)
0113     __acquires(x25_forward_list_lock)
0114 {
0115     read_lock_bh(&x25_forward_list_lock);
0116     return seq_list_start_head(&x25_forward_list, *pos);
0117 }
0118
0119 static void *x25_seq_forward_next(struct seq_file *seq, void *v, loff_t *pos)
0120 {
0121     return seq_list_next(v, &x25_forward_list, pos);
0122 }
0123
0124 static void x25_seq_forward_stop(struct seq_file *seq, void *v)
0125     __releases(x25_forward_list_lock)
0126 {
0127     read_unlock_bh(&x25_forward_list_lock);
0128 }
0129
0130 static int x25_seq_forward_show(struct seq_file *seq, void *v)
0131 {
0132     struct x25_forward *f = list_entry(v, struct x25_forward, node);
0133
0134     if (v == &x25_forward_list) {
0135         seq_printf(seq, "lci dev1       dev2\n");
0136         goto out;
0137     }
0138
0139     f = v;
0140
0141     seq_printf(seq, "%d %-10s %-10s\n",
0142             f->lci, f->dev1->name, f->dev2->name);
0143 out:
0144     return 0;
0145 }
0146
0147 static const struct seq_operations x25_seq_route_ops = {
0148     .start  = x25_seq_route_start,
0149     .next   = x25_seq_route_next,
0150     .stop   = x25_seq_route_stop,
0151     .show   = x25_seq_route_show,
0152 };
0153
0154 static const struct seq_operations x25_seq_socket_ops = {
0155     .start  = x25_seq_socket_start,
0156     .next   = x25_seq_socket_next,
0157     .stop   = x25_seq_socket_stop,
0158     .show   = x25_seq_socket_show,
0159 };
0160
0161 static const struct seq_operations x25_seq_forward_ops = {
0162     .start  = x25_seq_forward_start,
0163     .next   = x25_seq_forward_next,
0164     .stop   = x25_seq_forward_stop,
0165     .show   = x25_seq_forward_show,
0166 };
0167
0168 int __init x25_proc_init(void)
0169 {
0170     if (!proc_mkdir("x25", init_net.proc_net))
0171         return -ENOMEM;
0172
0173     if (!proc_create_seq("x25/route", 0444, init_net.proc_net,
0174              &x25_seq_route_ops))
0175         goto out;
0176
0177     if (!proc_create_seq("x25/socket", 0444, init_net.proc_net,
0178              &x25_seq_socket_ops))
0179         goto out;
0180
0181     if (!proc_create_seq("x25/forward", 0444, init_net.proc_net,
0182              &x25_seq_forward_ops))
0183         goto out;
0184     return 0;
0185
0186 out:
0187     remove_proc_subtree("x25", init_net.proc_net);
0188     return -ENOMEM;
0189 }
0190
0191 void __exit x25_proc_exit(void)
0192 {
0193     remove_proc_subtree("x25", init_net.proc_net);
0194 }
0195
0196 #else /* CONFIG_PROC_FS */
0197
0198 int __init x25_proc_init(void)
0199 {
0200     return 0;
0201 }
0202
0203 void __exit x25_proc_exit(void)
0204 {
0205 }
0206 #endif /* CONFIG_PROC_FS */