Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/cooloney...
[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 = create_proc_entry("eps", S_IRUGO, proc_net_sctp);
260         if (!p)
261                 return -ENOMEM;
262
263         p->proc_fops = &sctp_eps_seq_fops;
264
265         return 0;
266 }
267
268 /* Cleanup the proc fs entry for 'eps' object. */
269 void sctp_eps_proc_exit(void)
270 {
271         remove_proc_entry("eps", proc_net_sctp);
272 }
273
274
275 static void * sctp_assocs_seq_start(struct seq_file *seq, loff_t *pos)
276 {
277         if (*pos >= sctp_assoc_hashsize)
278                 return NULL;
279
280         if (*pos < 0)
281                 *pos = 0;
282
283         if (*pos == 0)
284                 seq_printf(seq, " ASSOC     SOCK   STY SST ST HBKT ASSOC-ID TX_QUEUE RX_QUEUE UID INODE LPORT "
285                                 "RPORT LADDRS <-> RADDRS\n");
286
287         return (void *)pos;
288 }
289
290 static void sctp_assocs_seq_stop(struct seq_file *seq, void *v)
291 {
292         return;
293 }
294
295
296 static void * sctp_assocs_seq_next(struct seq_file *seq, void *v, loff_t *pos)
297 {
298         if (++*pos >= sctp_assoc_hashsize)
299                 return NULL;
300
301         return pos;
302 }
303
304 /* Display sctp associations (/proc/net/sctp/assocs). */
305 static int sctp_assocs_seq_show(struct seq_file *seq, void *v)
306 {
307         struct sctp_hashbucket *head;
308         struct sctp_ep_common *epb;
309         struct sctp_association *assoc;
310         struct sock *sk;
311         struct hlist_node *node;
312         int    hash = *(loff_t *)v;
313
314         if (hash >= sctp_assoc_hashsize)
315                 return -ENOMEM;
316
317         head = &sctp_assoc_hashtable[hash];
318         sctp_local_bh_disable();
319         read_lock(&head->lock);
320         sctp_for_each_hentry(epb, node, &head->chain) {
321                 assoc = sctp_assoc(epb);
322                 sk = epb->sk;
323                 seq_printf(seq,
324                            "%8p %8p %-3d %-3d %-2d %-4d %4d %8d %8d %7d %5lu %-5d %5d ",
325                            assoc, sk, sctp_sk(sk)->type, sk->sk_state,
326                            assoc->state, hash, assoc->assoc_id,
327                            assoc->sndbuf_used,
328                            atomic_read(&assoc->rmem_alloc),
329                            sock_i_uid(sk), sock_i_ino(sk),
330                            epb->bind_addr.port,
331                            assoc->peer.port);
332
333                 seq_printf(seq, " ");
334                 sctp_seq_dump_local_addrs(seq, epb);
335                 seq_printf(seq, "<-> ");
336                 sctp_seq_dump_remote_addrs(seq, assoc);
337                 seq_printf(seq, "\n");
338         }
339         read_unlock(&head->lock);
340         sctp_local_bh_enable();
341
342         return 0;
343 }
344
345 static const struct seq_operations sctp_assoc_ops = {
346         .start = sctp_assocs_seq_start,
347         .next  = sctp_assocs_seq_next,
348         .stop  = sctp_assocs_seq_stop,
349         .show  = sctp_assocs_seq_show,
350 };
351
352 /* Initialize the seq file operations for 'assocs' object. */
353 static int sctp_assocs_seq_open(struct inode *inode, struct file *file)
354 {
355         return seq_open(file, &sctp_assoc_ops);
356 }
357
358 static const struct file_operations sctp_assocs_seq_fops = {
359         .open    = sctp_assocs_seq_open,
360         .read    = seq_read,
361         .llseek  = seq_lseek,
362         .release = seq_release,
363 };
364
365 /* Set up the proc fs entry for 'assocs' object. */
366 int __init sctp_assocs_proc_init(void)
367 {
368         struct proc_dir_entry *p;
369
370         p = create_proc_entry("assocs", S_IRUGO, proc_net_sctp);
371         if (!p)
372                 return -ENOMEM;
373
374         p->proc_fops = &sctp_assocs_seq_fops;
375
376         return 0;
377 }
378
379 /* Cleanup the proc fs entry for 'assocs' object. */
380 void sctp_assocs_proc_exit(void)
381 {
382         remove_proc_entry("assocs", proc_net_sctp);
383 }