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 }
381
|
This page was automatically generated by the
LXR engine.
|