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