Merge branches 'release', 'button-sysfs', 'misc', 'mismatch', 'randconfig' and 'toshi...
[linux-2.6] / 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 = proc_create("snmp", S_IRUGO, proc_net_sctp, &sctp_snmp_seq_fops);
112         if (!p)
113                 return -ENOMEM;
114
115         return 0;
116 }
117
118 /* Cleanup the proc fs entry for 'snmp' object. */
119 void sctp_snmp_proc_exit(void)
120 {
121         remove_proc_entry("snmp", proc_net_sctp);
122 }
123
124 /* Dump local addresses of an association/endpoint. */
125 static void sctp_seq_dump_local_addrs(struct seq_file *seq, struct sctp_ep_common *epb)
126 {
127         struct list_head *pos;
128         struct sctp_association *asoc;
129         struct sctp_sockaddr_entry *laddr;
130         struct sctp_transport *peer;
131         union sctp_addr *addr, *primary = NULL;
132         struct sctp_af *af;
133
134         if (epb->type == SCTP_EP_TYPE_ASSOCIATION) {
135             asoc = sctp_assoc(epb);
136             peer = asoc->peer.primary_path;
137             primary = &peer->saddr;
138         }
139
140         list_for_each(pos, &epb->bind_addr.address_list) {
141                 laddr = list_entry(pos, struct sctp_sockaddr_entry, list);
142                 addr = &laddr->a;
143                 af = sctp_get_af_specific(addr->sa.sa_family);
144                 if (primary && af->cmp_addr(addr, primary)) {
145                         seq_printf(seq, "*");
146                 }
147                 af->seq_dump_addr(seq, addr);
148         }
149 }
150
151 /* Dump remote addresses of an association. */
152 static void sctp_seq_dump_remote_addrs(struct seq_file *seq, struct sctp_association *assoc)
153 {
154         struct list_head *pos;
155         struct sctp_transport *transport;
156         union sctp_addr *addr, *primary;
157         struct sctp_af *af;
158
159         primary = &assoc->peer.primary_addr;
160         list_for_each(pos, &assoc->peer.transport_addr_list) {
161                 transport = list_entry(pos, struct sctp_transport, transports);
162                 addr = &transport->ipaddr;
163                 af = sctp_get_af_specific(addr->sa.sa_family);
164                 if (af->cmp_addr(addr, primary)) {
165                         seq_printf(seq, "*");
166                 }
167                 af->seq_dump_addr(seq, addr);
168         }
169 }
170
171 static void * sctp_eps_seq_start(struct seq_file *seq, loff_t *pos)
172 {
173         if (*pos >= sctp_ep_hashsize)
174                 return NULL;
175
176         if (*pos < 0)
177                 *pos = 0;
178
179         if (*pos == 0)
180                 seq_printf(seq, " ENDPT     SOCK   STY SST HBKT LPORT   UID INODE LADDRS\n");
181
182         return (void *)pos;
183 }
184
185 static void sctp_eps_seq_stop(struct seq_file *seq, void *v)
186 {
187         return;
188 }
189
190
191 static void * sctp_eps_seq_next(struct seq_file *seq, void *v, loff_t *pos)
192 {
193         if (++*pos >= sctp_ep_hashsize)
194                 return NULL;
195
196         return pos;
197 }
198
199
200 /* Display sctp endpoints (/proc/net/sctp/eps). */
201 static int sctp_eps_seq_show(struct seq_file *seq, void *v)
202 {
203         struct sctp_hashbucket *head;
204         struct sctp_ep_common *epb;
205         struct sctp_endpoint *ep;
206         struct sock *sk;
207         struct hlist_node *node;
208         int    hash = *(loff_t *)v;
209
210         if (hash >= sctp_ep_hashsize)
211                 return -ENOMEM;
212
213         head = &sctp_ep_hashtable[hash];
214         sctp_local_bh_disable();
215         read_lock(&head->lock);
216         sctp_for_each_hentry(epb, node, &head->chain) {
217                 ep = sctp_ep(epb);
218                 sk = epb->sk;
219                 seq_printf(seq, "%8p %8p %-3d %-3d %-4d %-5d %5d %5lu ", ep, sk,
220                            sctp_sk(sk)->type, sk->sk_state, hash,
221                            epb->bind_addr.port,
222                            sock_i_uid(sk), sock_i_ino(sk));
223
224                 sctp_seq_dump_local_addrs(seq, epb);
225                 seq_printf(seq, "\n");
226         }
227         read_unlock(&head->lock);
228         sctp_local_bh_enable();
229
230         return 0;
231 }
232
233 static const struct seq_operations sctp_eps_ops = {
234         .start = sctp_eps_seq_start,
235         .next  = sctp_eps_seq_next,
236         .stop  = sctp_eps_seq_stop,
237         .show  = sctp_eps_seq_show,
238 };
239
240
241 /* Initialize the seq file operations for 'eps' object. */
242 static int sctp_eps_seq_open(struct inode *inode, struct file *file)
243 {
244         return seq_open(file, &sctp_eps_ops);
245 }
246
247 static const struct file_operations sctp_eps_seq_fops = {
248         .open    = sctp_eps_seq_open,
249         .read    = seq_read,
250         .llseek  = seq_lseek,
251         .release = seq_release,
252 };
253
254 /* Set up the proc fs entry for 'eps' object. */
255 int __init sctp_eps_proc_init(void)
256 {
257         struct proc_dir_entry *p;
258
259         p = proc_create("eps", S_IRUGO, proc_net_sctp, &sctp_eps_seq_fops);
260         if (!p)
261                 return -ENOMEM;
262
263         return 0;
264 }
265
266 /* Cleanup the proc fs entry for 'eps' object. */
267 void sctp_eps_proc_exit(void)
268 {
269         remove_proc_entry("eps", proc_net_sctp);
270 }
271
272
273 static void * sctp_assocs_seq_start(struct seq_file *seq, loff_t *pos)
274 {
275         if (*pos >= sctp_assoc_hashsize)
276                 return NULL;
277
278         if (*pos < 0)
279                 *pos = 0;
280
281         if (*pos == 0)
282                 seq_printf(seq, " ASSOC     SOCK   STY SST ST HBKT ASSOC-ID TX_QUEUE RX_QUEUE UID INODE LPORT "
283                                 "RPORT LADDRS <-> RADDRS\n");
284
285         return (void *)pos;
286 }
287
288 static void sctp_assocs_seq_stop(struct seq_file *seq, void *v)
289 {
290         return;
291 }
292
293
294 static void * sctp_assocs_seq_next(struct seq_file *seq, void *v, loff_t *pos)
295 {
296         if (++*pos >= sctp_assoc_hashsize)
297                 return NULL;
298
299         return pos;
300 }
301
302 /* Display sctp associations (/proc/net/sctp/assocs). */
303 static int sctp_assocs_seq_show(struct seq_file *seq, void *v)
304 {
305         struct sctp_hashbucket *head;
306         struct sctp_ep_common *epb;
307         struct sctp_association *assoc;
308         struct sock *sk;
309         struct hlist_node *node;
310         int    hash = *(loff_t *)v;
311
312         if (hash >= sctp_assoc_hashsize)
313                 return -ENOMEM;
314
315         head = &sctp_assoc_hashtable[hash];
316         sctp_local_bh_disable();
317         read_lock(&head->lock);
318         sctp_for_each_hentry(epb, node, &head->chain) {
319                 assoc = sctp_assoc(epb);
320                 sk = epb->sk;
321                 seq_printf(seq,
322                            "%8p %8p %-3d %-3d %-2d %-4d %4d %8d %8d %7d %5lu %-5d %5d ",
323                            assoc, sk, sctp_sk(sk)->type, sk->sk_state,
324                            assoc->state, hash, assoc->assoc_id,
325                            assoc->sndbuf_used,
326                            atomic_read(&assoc->rmem_alloc),
327                            sock_i_uid(sk), sock_i_ino(sk),
328                            epb->bind_addr.port,
329                            assoc->peer.port);
330
331                 seq_printf(seq, " ");
332                 sctp_seq_dump_local_addrs(seq, epb);
333                 seq_printf(seq, "<-> ");
334                 sctp_seq_dump_remote_addrs(seq, assoc);
335                 seq_printf(seq, "\n");
336         }
337         read_unlock(&head->lock);
338         sctp_local_bh_enable();
339
340         return 0;
341 }
342
343 static const struct seq_operations sctp_assoc_ops = {
344         .start = sctp_assocs_seq_start,
345         .next  = sctp_assocs_seq_next,
346         .stop  = sctp_assocs_seq_stop,
347         .show  = sctp_assocs_seq_show,
348 };
349
350 /* Initialize the seq file operations for 'assocs' object. */
351 static int sctp_assocs_seq_open(struct inode *inode, struct file *file)
352 {
353         return seq_open(file, &sctp_assoc_ops);
354 }
355
356 static const struct file_operations sctp_assocs_seq_fops = {
357         .open    = sctp_assocs_seq_open,
358         .read    = seq_read,
359         .llseek  = seq_lseek,
360         .release = seq_release,
361 };
362
363 /* Set up the proc fs entry for 'assocs' object. */
364 int __init sctp_assocs_proc_init(void)
365 {
366         struct proc_dir_entry *p;
367
368         p = proc_create("assocs", S_IRUGO, proc_net_sctp,
369                         &sctp_assocs_seq_fops);
370         if (!p)
371                 return -ENOMEM;
372
373         return 0;
374 }
375
376 /* Cleanup the proc fs entry for 'assocs' object. */
377 void sctp_assocs_proc_exit(void)
378 {
379         remove_proc_entry("assocs", proc_net_sctp);
380 }