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 } 386