[SCTP]: Use snmp_fold_field instead of a homebrew analogue.
[sfrench/cifs-2.6.git] / net / sctp / proc.c
1 /* SCTP kernel implementation
2  * Copyright (c) 2003 International Business Machines, Corp.
3  *
4  * This file is part of the SCTP kernel implementation
5  *
6  * This SCTP implementation is free software;
7  * you can redistribute it and/or modify it under the terms of
8  * the GNU General Public License as published by
9  * the Free Software Foundation; either version 2, or (at your option)
10  * any later version.
11  *
12  * This SCTP implementation is distributed in the hope that it
13  * will be useful, but WITHOUT ANY WARRANTY; without even the implied
14  *                 ************************
15  * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
16  * See the GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with GNU CC; see the file COPYING.  If not, write to
20  * the Free Software Foundation, 59 Temple Place - Suite 330,
21  * Boston, MA 02111-1307, USA.
22  *
23  * Please send any bug reports or fixes you make to the
24  * email address(es):
25  *    lksctp developers <lksctp-developers@lists.sourceforge.net>
26  *
27  * Or submit a bug report through the following website:
28  *    http://www.sf.net/projects/lksctp
29  *
30  * Written or modified by:
31  *    Sridhar Samudrala <sri@us.ibm.com>
32  *
33  * Any bugs reported given to us we will try to fix... any fixes shared will
34  * be incorporated into the next SCTP release.
35  */
36
37 #include <linux/types.h>
38 #include <linux/seq_file.h>
39 #include <linux/init.h>
40 #include <net/sctp/sctp.h>
41 #include <net/ip.h> /* for snmp_fold_field */
42
43 static struct snmp_mib sctp_snmp_list[] = {
44         SNMP_MIB_ITEM("SctpCurrEstab", SCTP_MIB_CURRESTAB),
45         SNMP_MIB_ITEM("SctpActiveEstabs", SCTP_MIB_ACTIVEESTABS),
46         SNMP_MIB_ITEM("SctpPassiveEstabs", SCTP_MIB_PASSIVEESTABS),
47         SNMP_MIB_ITEM("SctpAborteds", SCTP_MIB_ABORTEDS),
48         SNMP_MIB_ITEM("SctpShutdowns", SCTP_MIB_SHUTDOWNS),
49         SNMP_MIB_ITEM("SctpOutOfBlues", SCTP_MIB_OUTOFBLUES),
50         SNMP_MIB_ITEM("SctpChecksumErrors", SCTP_MIB_CHECKSUMERRORS),
51         SNMP_MIB_ITEM("SctpOutCtrlChunks", SCTP_MIB_OUTCTRLCHUNKS),
52         SNMP_MIB_ITEM("SctpOutOrderChunks", SCTP_MIB_OUTORDERCHUNKS),
53         SNMP_MIB_ITEM("SctpOutUnorderChunks", SCTP_MIB_OUTUNORDERCHUNKS),
54         SNMP_MIB_ITEM("SctpInCtrlChunks", SCTP_MIB_INCTRLCHUNKS),
55         SNMP_MIB_ITEM("SctpInOrderChunks", SCTP_MIB_INORDERCHUNKS),
56         SNMP_MIB_ITEM("SctpInUnorderChunks", SCTP_MIB_INUNORDERCHUNKS),
57         SNMP_MIB_ITEM("SctpFragUsrMsgs", SCTP_MIB_FRAGUSRMSGS),
58         SNMP_MIB_ITEM("SctpReasmUsrMsgs", SCTP_MIB_REASMUSRMSGS),
59         SNMP_MIB_ITEM("SctpOutSCTPPacks", SCTP_MIB_OUTSCTPPACKS),
60         SNMP_MIB_ITEM("SctpInSCTPPacks", SCTP_MIB_INSCTPPACKS),
61         SNMP_MIB_ITEM("SctpT1InitExpireds", SCTP_MIB_T1_INIT_EXPIREDS),
62         SNMP_MIB_ITEM("SctpT1CookieExpireds", SCTP_MIB_T1_COOKIE_EXPIREDS),
63         SNMP_MIB_ITEM("SctpT2ShutdownExpireds", SCTP_MIB_T2_SHUTDOWN_EXPIREDS),
64         SNMP_MIB_ITEM("SctpT3RtxExpireds", SCTP_MIB_T3_RTX_EXPIREDS),
65         SNMP_MIB_ITEM("SctpT4RtoExpireds", SCTP_MIB_T4_RTO_EXPIREDS),
66         SNMP_MIB_ITEM("SctpT5ShutdownGuardExpireds", SCTP_MIB_T5_SHUTDOWN_GUARD_EXPIREDS),
67         SNMP_MIB_ITEM("SctpDelaySackExpireds", SCTP_MIB_DELAY_SACK_EXPIREDS),
68         SNMP_MIB_ITEM("SctpAutocloseExpireds", SCTP_MIB_AUTOCLOSE_EXPIREDS),
69         SNMP_MIB_ITEM("SctpT3Retransmits", SCTP_MIB_T3_RETRANSMITS),
70         SNMP_MIB_ITEM("SctpPmtudRetransmits", SCTP_MIB_PMTUD_RETRANSMITS),
71         SNMP_MIB_ITEM("SctpFastRetransmits", SCTP_MIB_FAST_RETRANSMITS),
72         SNMP_MIB_ITEM("SctpInPktSoftirq", SCTP_MIB_IN_PKT_SOFTIRQ),
73         SNMP_MIB_ITEM("SctpInPktBacklog", SCTP_MIB_IN_PKT_BACKLOG),
74         SNMP_MIB_ITEM("SctpInPktDiscards", SCTP_MIB_IN_PKT_DISCARDS),
75         SNMP_MIB_ITEM("SctpInDataChunkDiscards", SCTP_MIB_IN_DATA_CHUNK_DISCARDS),
76         SNMP_MIB_SENTINEL
77 };
78
79 /* Display sctp snmp mib statistics(/proc/net/sctp/snmp). */
80 static int sctp_snmp_seq_show(struct seq_file *seq, void *v)
81 {
82         int i;
83
84         for (i = 0; sctp_snmp_list[i].name != NULL; i++)
85                 seq_printf(seq, "%-32s\t%ld\n", sctp_snmp_list[i].name,
86                            snmp_fold_field((void **)sctp_statistics,
87                                       sctp_snmp_list[i].entry));
88
89         return 0;
90 }
91
92 /* Initialize the seq file operations for 'snmp' object. */
93 static int sctp_snmp_seq_open(struct inode *inode, struct file *file)
94 {
95         return single_open(file, sctp_snmp_seq_show, NULL);
96 }
97
98 static const struct file_operations sctp_snmp_seq_fops = {
99         .owner   = THIS_MODULE,
100         .open    = sctp_snmp_seq_open,
101         .read    = seq_read,
102         .llseek  = seq_lseek,
103         .release = single_release,
104 };
105
106 /* Set up the proc fs entry for 'snmp' object. */
107 int __init sctp_snmp_proc_init(void)
108 {
109         struct proc_dir_entry *p;
110
111         p = create_proc_entry("snmp", S_IRUGO, proc_net_sctp);
112         if (!p)
113                 return -ENOMEM;
114
115         p->proc_fops = &sctp_snmp_seq_fops;
116
117         return 0;
118 }
119
120 /* Cleanup the proc fs entry for 'snmp' object. */
121 void sctp_snmp_proc_exit(void)
122 {
123         remove_proc_entry("snmp", proc_net_sctp);
124 }
125
126 /* Dump local addresses of an association/endpoint. */
127 static void sctp_seq_dump_local_addrs(struct seq_file *seq, struct sctp_ep_common *epb)
128 {
129         struct list_head *pos;
130         struct sctp_association *asoc;
131         struct sctp_sockaddr_entry *laddr;
132         struct sctp_transport *peer;
133         union sctp_addr *addr, *primary = NULL;
134         struct sctp_af *af;
135
136         if (epb->type == SCTP_EP_TYPE_ASSOCIATION) {
137             asoc = sctp_assoc(epb);
138             peer = asoc->peer.primary_path;
139             primary = &peer->saddr;
140         }
141
142         list_for_each(pos, &epb->bind_addr.address_list) {
143                 laddr = list_entry(pos, struct sctp_sockaddr_entry, list);
144                 addr = &laddr->a;
145                 af = sctp_get_af_specific(addr->sa.sa_family);
146                 if (primary && af->cmp_addr(addr, primary)) {
147                         seq_printf(seq, "*");
148                 }
149                 af->seq_dump_addr(seq, addr);
150         }
151 }
152
153 /* Dump remote addresses of an association. */
154 static void sctp_seq_dump_remote_addrs(struct seq_file *seq, struct sctp_association *assoc)
155 {
156         struct list_head *pos;
157         struct sctp_transport *transport;
158         union sctp_addr *addr, *primary;
159         struct sctp_af *af;
160
161         primary = &assoc->peer.primary_addr;
162         list_for_each(pos, &assoc->peer.transport_addr_list) {
163                 transport = list_entry(pos, struct sctp_transport, transports);
164                 addr = &transport->ipaddr;
165                 af = sctp_get_af_specific(addr->sa.sa_family);
166                 if (af->cmp_addr(addr, primary)) {
167                         seq_printf(seq, "*");
168                 }
169                 af->seq_dump_addr(seq, addr);
170         }
171 }
172
173 static void * sctp_eps_seq_start(struct seq_file *seq, loff_t *pos)
174 {
175         if (*pos >= sctp_ep_hashsize)
176                 return NULL;
177
178         if (*pos < 0)
179                 *pos = 0;
180
181         if (*pos == 0)
182                 seq_printf(seq, " ENDPT     SOCK   STY SST HBKT LPORT   UID INODE LADDRS\n");
183
184         return (void *)pos;
185 }
186
187 static void sctp_eps_seq_stop(struct seq_file *seq, void *v)
188 {
189         return;
190 }
191
192
193 static void * sctp_eps_seq_next(struct seq_file *seq, void *v, loff_t *pos)
194 {
195         if (++*pos >= sctp_ep_hashsize)
196                 return NULL;
197
198         return pos;
199 }
200
201
202 /* Display sctp endpoints (/proc/net/sctp/eps). */
203 static int sctp_eps_seq_show(struct seq_file *seq, void *v)
204 {
205         struct sctp_hashbucket *head;
206         struct sctp_ep_common *epb;
207         struct sctp_endpoint *ep;
208         struct sock *sk;
209         struct hlist_node *node;
210         int    hash = *(loff_t *)v;
211
212         if (hash >= sctp_ep_hashsize)
213                 return -ENOMEM;
214
215         head = &sctp_ep_hashtable[hash];
216         sctp_local_bh_disable();
217         read_lock(&head->lock);
218         sctp_for_each_hentry(epb, node, &head->chain) {
219                 ep = sctp_ep(epb);
220                 sk = epb->sk;
221                 seq_printf(seq, "%8p %8p %-3d %-3d %-4d %-5d %5d %5lu ", ep, sk,
222                            sctp_sk(sk)->type, sk->sk_state, hash,
223                            epb->bind_addr.port,
224                            sock_i_uid(sk), sock_i_ino(sk));
225
226                 sctp_seq_dump_local_addrs(seq, epb);
227                 seq_printf(seq, "\n");
228         }
229         read_unlock(&head->lock);
230         sctp_local_bh_enable();
231
232         return 0;
233 }
234
235 static const struct seq_operations sctp_eps_ops = {
236         .start = sctp_eps_seq_start,
237         .next  = sctp_eps_seq_next,
238         .stop  = sctp_eps_seq_stop,
239         .show  = sctp_eps_seq_show,
240 };
241
242
243 /* Initialize the seq file operations for 'eps' object. */
244 static int sctp_eps_seq_open(struct inode *inode, struct file *file)
245 {
246         return seq_open(file, &sctp_eps_ops);
247 }
248
249 static const struct file_operations sctp_eps_seq_fops = {
250         .open    = sctp_eps_seq_open,
251         .read    = seq_read,
252         .llseek  = seq_lseek,
253         .release = seq_release,
254 };
255
256 /* Set up the proc fs entry for 'eps' object. */
257 int __init sctp_eps_proc_init(void)
258 {
259         struct proc_dir_entry *p;
260
261         p = create_proc_entry("eps", S_IRUGO, proc_net_sctp);
262         if (!p)
263                 return -ENOMEM;
264
265         p->proc_fops = &sctp_eps_seq_fops;
266
267         return 0;
268 }
269
270 /* Cleanup the proc fs entry for 'eps' object. */
271 void sctp_eps_proc_exit(void)
272 {
273         remove_proc_entry("eps", proc_net_sctp);
274 }
275
276
277 static void * sctp_assocs_seq_start(struct seq_file *seq, loff_t *pos)
278 {
279         if (*pos >= sctp_assoc_hashsize)
280                 return NULL;
281
282         if (*pos < 0)
283                 *pos = 0;
284
285         if (*pos == 0)
286                 seq_printf(seq, " ASSOC     SOCK   STY SST ST HBKT ASSOC-ID TX_QUEUE RX_QUEUE UID INODE LPORT "
287                                 "RPORT LADDRS <-> RADDRS\n");
288
289         return (void *)pos;
290 }
291
292 static void sctp_assocs_seq_stop(struct seq_file *seq, void *v)
293 {
294         return;
295 }
296
297
298 static void * sctp_assocs_seq_next(struct seq_file *seq, void *v, loff_t *pos)
299 {
300         if (++*pos >= sctp_assoc_hashsize)
301                 return NULL;
302
303         return pos;
304 }
305
306 /* Display sctp associations (/proc/net/sctp/assocs). */
307 static int sctp_assocs_seq_show(struct seq_file *seq, void *v)
308 {
309         struct sctp_hashbucket *head;
310         struct sctp_ep_common *epb;
311         struct sctp_association *assoc;
312         struct sock *sk;
313         struct hlist_node *node;
314         int    hash = *(loff_t *)v;
315
316         if (hash >= sctp_assoc_hashsize)
317                 return -ENOMEM;
318
319         head = &sctp_assoc_hashtable[hash];
320         sctp_local_bh_disable();
321         read_lock(&head->lock);
322         sctp_for_each_hentry(epb, node, &head->chain) {
323                 assoc = sctp_assoc(epb);
324                 sk = epb->sk;
325                 seq_printf(seq,
326                            "%8p %8p %-3d %-3d %-2d %-4d %4d %8d %8d %7d %5lu %-5d %5d ",
327                            assoc, sk, sctp_sk(sk)->type, sk->sk_state,
328                            assoc->state, hash, assoc->assoc_id,
329                            assoc->sndbuf_used,
330                            atomic_read(&assoc->rmem_alloc),
331                            sock_i_uid(sk), sock_i_ino(sk),
332                            epb->bind_addr.port,
333                            assoc->peer.port);
334
335                 seq_printf(seq, " ");
336                 sctp_seq_dump_local_addrs(seq, epb);
337                 seq_printf(seq, "<-> ");
338                 sctp_seq_dump_remote_addrs(seq, assoc);
339                 seq_printf(seq, "\n");
340         }
341         read_unlock(&head->lock);
342         sctp_local_bh_enable();
343
344         return 0;
345 }
346
347 static const struct seq_operations sctp_assoc_ops = {
348         .start = sctp_assocs_seq_start,
349         .next  = sctp_assocs_seq_next,
350         .stop  = sctp_assocs_seq_stop,
351         .show  = sctp_assocs_seq_show,
352 };
353
354 /* Initialize the seq file operations for 'assocs' object. */
355 static int sctp_assocs_seq_open(struct inode *inode, struct file *file)
356 {
357         return seq_open(file, &sctp_assoc_ops);
358 }
359
360 static const struct file_operations sctp_assocs_seq_fops = {
361         .open    = sctp_assocs_seq_open,
362         .read    = seq_read,
363         .llseek  = seq_lseek,
364         .release = seq_release,
365 };
366
367 /* Set up the proc fs entry for 'assocs' object. */
368 int __init sctp_assocs_proc_init(void)
369 {
370         struct proc_dir_entry *p;
371
372         p = create_proc_entry("assocs", S_IRUGO, proc_net_sctp);
373         if (!p)
374                 return -ENOMEM;
375
376         p->proc_fops = &sctp_assocs_seq_fops;
377
378         return 0;
379 }
380
381 /* Cleanup the proc fs entry for 'assocs' object. */
382 void sctp_assocs_proc_exit(void)
383 {
384         remove_proc_entry("assocs", proc_net_sctp);
385 }