1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #pragma ident "%Z%%M% %I% %E% SMI" 28 29 #include <sys/types.h> 30 #include <sys/stream.h> 31 #include <sys/mdb_modapi.h> 32 #include <sys/socket.h> 33 #include <sys/list.h> 34 #include <sys/strsun.h> 35 36 #include <mdb/mdb_stdlib.h> 37 38 #include <netinet/in.h> 39 #include <netinet/ip6.h> 40 #include <netinet/sctp.h> 41 42 #include <inet/common.h> 43 #include <inet/ip.h> 44 #include <inet/ip6.h> 45 #include <inet/ipclassifier.h> 46 47 #include <sctp/sctp_impl.h> 48 #include <sctp/sctp_addr.h> 49 50 #define MDB_SCTP_SHOW_FLAGS 0x1 51 #define MDB_SCTP_DUMP_ADDRS 0x2 52 #define MDB_SCTP_SHOW_HASH 0x4 53 #define MDB_SCTP_SHOW_OUT 0x8 54 #define MDB_SCTP_SHOW_IN 0x10 55 #define MDB_SCTP_SHOW_MISC 0x20 56 #define MDB_SCTP_SHOW_RTT 0x40 57 #define MDB_SCTP_SHOW_STATS 0x80 58 #define MDB_SCTP_SHOW_FLOW 0x100 59 #define MDB_SCTP_SHOW_HDR 0x200 60 #define MDB_SCTP_SHOW_PMTUD 0x400 61 #define MDB_SCTP_SHOW_RXT 0x800 62 #define MDB_SCTP_SHOW_CONN 0x1000 63 #define MDB_SCTP_SHOW_CLOSE 0x2000 64 #define MDB_SCTP_SHOW_EXT 0x4000 65 66 #define MDB_SCTP_SHOW_ALL 0xffffffff 67 68 uint_t sctp_conn_hash_size; 69 static GElf_Sym sctp_list_sym; 70 static list_t sctp_list; 71 72 /* 73 * Both the ill and ipif global arrays are small, so we just read 74 * in the whole arrays. 75 */ 76 static sctp_ill_hash_t local_g_ills[SCTP_ILL_HASH]; 77 static sctp_ipif_hash_t local_g_ipifs[SCTP_IPIF_HASH]; 78 79 /* 80 * Copy from usr/src/uts/common/os/list.c. Should we have a generic 81 * mdb list walker? 82 */ 83 #define list_object(a, node) ((void *)(((char *)node) - (a)->list_offset)) 84 85 static char * 86 sctp_faddr_state(int state) 87 { 88 char *statestr; 89 90 switch (state) { 91 case SCTP_FADDRS_UNREACH: 92 statestr = "Unreachable"; 93 break; 94 case SCTP_FADDRS_DOWN: 95 statestr = "Down"; 96 break; 97 case SCTP_FADDRS_ALIVE: 98 statestr = "Alive"; 99 break; 100 case SCTP_FADDRS_UNCONFIRMED: 101 statestr = "Unconfirmed"; 102 break; 103 default: 104 statestr = "Unknown"; 105 break; 106 } 107 return (statestr); 108 } 109 110 /* ARGSUSED */ 111 static int 112 sctp_faddr(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 113 { 114 sctp_faddr_t fa[1]; 115 char *statestr; 116 117 if (!(flags & DCMD_ADDRSPEC)) 118 return (DCMD_USAGE); 119 120 if (mdb_vread(fa, sizeof (*fa), addr) == -1) { 121 mdb_warn("cannot read fadder at %p", addr); 122 return (DCMD_ERR); 123 } 124 125 statestr = sctp_faddr_state(fa->state); 126 mdb_printf("%<u>%p\t%<b>%N%</b>\t%s%</u>\n", addr, &fa->faddr, 127 statestr); 128 mdb_printf("next\t\t%?p\tsaddr\t%N\n", fa->next, &fa->saddr); 129 mdb_printf("rto\t\t%?d\tsrtt\t\t%?d\n", fa->rto, fa->srtt); 130 mdb_printf("rttvar\t\t%?d\trtt_updates\t%?u\n", fa->rttvar, 131 fa->rtt_updates); 132 mdb_printf("strikes\t\t%?d\tmax_retr\t%?d\n", fa->strikes, 133 fa->max_retr); 134 mdb_printf("hb_expiry\t%?ld\thb_interval\t%?u\n", fa->hb_expiry, 135 fa->hb_interval); 136 mdb_printf("pmss\t\t%?u\tcwnd\t\t%?u\n", fa->sfa_pmss, fa->cwnd); 137 mdb_printf("ssthresh\t%?u\tsuna\t\t%?u\n", fa->ssthresh, fa->suna); 138 mdb_printf("pba\t\t%?u\tacked\t\t%?u\n", fa->pba, fa->acked); 139 mdb_printf("lastactive\t%?ld\thb_secret\t%?#lx\n", fa->lastactive, 140 fa->hb_secret); 141 mdb_printf("timer_mp\t%?p\tire\t\t%?p\n", fa->timer_mp, fa->ire); 142 mdb_printf("hb_pending\t%?d\ttimer_running\t%?d\n" 143 "df\t\t%?d\tpmtu_discovered\t%?d\n" 144 "isv4\t\t%?d\tretransmissions\t%?u\n", 145 fa->hb_pending, fa->timer_running, fa->df, fa->pmtu_discovered, 146 fa->isv4, fa->T3expire); 147 148 return (DCMD_OK); 149 } 150 151 static void 152 print_set(sctp_set_t *sp) 153 { 154 mdb_printf("\tbegin\t%<b>%?x%</b>\t\tend\t%<b>%?x%</b>\n", 155 sp->begin, sp->end); 156 mdb_printf("\tnext\t%?p\tprev\t%?p\n", sp->next, sp->prev); 157 } 158 159 /* ARGSUSED */ 160 static int 161 sctp_set(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 162 { 163 sctp_set_t sp[1]; 164 165 if (!(flags & DCMD_ADDRSPEC)) 166 return (DCMD_USAGE); 167 168 if (mdb_vread(sp, sizeof (*sp), addr) == -1) 169 return (DCMD_ERR); 170 171 print_set(sp); 172 173 return (DCMD_OK); 174 } 175 176 static void 177 dump_sack_info(uintptr_t addr) 178 { 179 sctp_set_t sp[1]; 180 181 while (addr != 0) { 182 if (mdb_vread(sp, sizeof (*sp), addr) == -1) { 183 mdb_warn("failed to read sctp_set at %p", addr); 184 return; 185 } 186 187 addr = (uintptr_t)sp->next; 188 print_set(sp); 189 } 190 } 191 192 static int 193 dump_msghdr(mblk_t *meta) 194 { 195 sctp_msg_hdr_t smh; 196 197 if (mdb_vread(&smh, sizeof (smh), (uintptr_t)meta->b_rptr) == -1) 198 return (-1); 199 200 mdb_printf("%<u>msg_hdr_t at \t%?p\tsentto\t%?p%</u>\n", 201 meta->b_rptr, SCTP_CHUNK_DEST(meta)); 202 mdb_printf("\tttl\t%?ld\ttob\t%?ld\n", smh.smh_ttl, smh.smh_tob); 203 mdb_printf("\tsid\t%?u\tssn\t%?u\n", smh.smh_sid, smh.smh_ssn); 204 mdb_printf("\tppid\t%?u\tflags\t%?s\n", smh.smh_ppid, 205 smh.smh_flags & MSG_UNORDERED ? "unordered" : " "); 206 mdb_printf("\tcontext\t%?u\tmsglen\t%?d\n", smh.smh_context, 207 smh.smh_msglen); 208 209 return (0); 210 } 211 212 static int 213 dump_datahdr(mblk_t *mp) 214 { 215 sctp_data_hdr_t sdc; 216 uint16_t sdh_int16; 217 uint32_t sdh_int32; 218 219 if (mdb_vread(&sdc, sizeof (sdc), (uintptr_t)mp->b_rptr) == -1) 220 return (-1); 221 222 mdb_printf("%<u>data_chunk_t \t%?p\tsentto\t%?p%</u>\n", 223 mp->b_rptr, SCTP_CHUNK_DEST(mp)); 224 mdb_printf("\tsent\t%?d\t", SCTP_CHUNK_ISSENT(mp)?1:0); 225 mdb_printf("retrans\t%?d\n", SCTP_CHUNK_WANT_REXMIT(mp)?1:0); 226 mdb_printf("\tacked\t%?d\t", SCTP_CHUNK_ISACKED(mp)?1:0); 227 mdb_printf("sackcnt\t%?u\n", SCTP_CHUNK_SACKCNT(mp)); 228 229 mdb_nhconvert(&sdh_int16, &sdc.sdh_len, sizeof (sdc.sdh_len)); 230 mdb_printf("\tlen\t%?d\t", sdh_int16); 231 mdb_printf("BBIT=%d", SCTP_DATA_GET_BBIT(&sdc) == 0 ? 0 : 1); 232 mdb_printf("EBIT=%d", SCTP_DATA_GET_EBIT(&sdc) == 0 ? 0 : 1); 233 234 mdb_nhconvert(&sdh_int32, &sdc.sdh_tsn, sizeof (sdc.sdh_tsn)); 235 mdb_nhconvert(&sdh_int16, &sdc.sdh_sid, sizeof (sdc.sdh_sid)); 236 mdb_printf("\ttsn\t%?x\tsid\t%?hu\n", sdh_int32, sdh_int16); 237 238 mdb_nhconvert(&sdh_int16, &sdc.sdh_ssn, sizeof (sdc.sdh_ssn)); 239 mdb_nhconvert(&sdh_int32, &sdc.sdh_payload_id, 240 sizeof (sdc.sdh_payload_id)); 241 mdb_printf("\tssn\t%?hu\tppid\t%?d\n", sdh_int16, sdh_int32); 242 243 return (0); 244 } 245 246 static int 247 sctp_sent_list(mblk_t *addr) 248 { 249 mblk_t meta, mp; 250 251 if (!addr) 252 return (0); 253 254 if (mdb_vread(&meta, sizeof (meta), (uintptr_t)addr) == -1) 255 return (-1); 256 257 for (;;) { 258 dump_msghdr(&meta); 259 260 if (meta.b_cont == NULL) { 261 mdb_printf("No data chunks with message header!\n"); 262 return (-1); 263 } 264 if (mdb_vread(&mp, sizeof (mp), 265 (uintptr_t)meta.b_cont) == -1) { 266 return (-1); 267 } 268 for (;;) { 269 dump_datahdr(&mp); 270 if (!mp.b_next) 271 break; 272 273 if (mdb_vread(&mp, sizeof (mp), 274 (uintptr_t)(mp.b_next)) == -1) 275 return (-1); 276 } 277 if (meta.b_next == NULL) 278 break; 279 if (mdb_vread(&meta, sizeof (meta), 280 (uintptr_t)meta.b_next) == -1) 281 return (-1); 282 } 283 284 return (0); 285 } 286 287 static int 288 sctp_unsent_list(mblk_t *addr) 289 { 290 mblk_t meta; 291 292 if (!addr) 293 return (0); 294 295 if (mdb_vread(&meta, sizeof (meta), (uintptr_t)addr) == -1) 296 return (-1); 297 298 for (;;) { 299 dump_msghdr(&meta); 300 301 if (meta.b_next == NULL) 302 break; 303 304 if (mdb_vread(&meta, sizeof (meta), 305 (uintptr_t)meta.b_next) == -1) 306 return (-1); 307 } 308 309 return (0); 310 } 311 312 /* ARGSUSED */ 313 static int 314 sctp_xmit_list(uintptr_t addr, uint_t flags, int ac, const mdb_arg_t *av) 315 { 316 sctp_t sctp; 317 318 if (!(flags & DCMD_ADDRSPEC)) 319 return (DCMD_USAGE); 320 321 if (mdb_vread(&sctp, sizeof (sctp), addr) == -1) 322 return (DCMD_ERR); 323 324 mdb_printf("%<b>Chunkified TX list%</b>\n"); 325 if (sctp_sent_list(sctp.sctp_xmit_head) < 0) 326 return (DCMD_ERR); 327 328 mdb_printf("%<b>Unchunkified TX list%</b>\n"); 329 if (sctp_unsent_list(sctp.sctp_xmit_unsent) < 0) 330 return (DCMD_ERR); 331 332 return (DCMD_OK); 333 } 334 335 /* ARGSUSED */ 336 static int 337 sctp_mdata_chunk(uintptr_t addr, uint_t flags, int ac, const mdb_arg_t *av) 338 { 339 sctp_data_hdr_t dc; 340 mblk_t mp; 341 342 if (!(flags & DCMD_ADDRSPEC)) 343 return (DCMD_USAGE); 344 345 if (mdb_vread(&mp, sizeof (mp), addr) == -1) 346 return (DCMD_ERR); 347 348 if (mdb_vread(&dc, sizeof (dc), (uintptr_t)mp.b_rptr) == -1) 349 return (DCMD_ERR); 350 351 mdb_printf("%<b>%-?p%</b>tsn\t%?x\tsid\t%?hu\n", addr, 352 dc.sdh_tsn, dc.sdh_sid); 353 mdb_printf("%-?sssn\t%?hu\tppid\t%?x\n", "", dc.sdh_ssn, 354 dc.sdh_payload_id); 355 356 return (DCMD_OK); 357 } 358 359 /* ARGSUSED */ 360 static int 361 sctp_istr_msgs(uintptr_t addr, uint_t flags, int ac, const mdb_arg_t *av) 362 { 363 mblk_t istrmp; 364 mblk_t dmp; 365 sctp_data_hdr_t dp; 366 uintptr_t daddr; 367 uintptr_t chaddr; 368 boolean_t bbit; 369 boolean_t ebit; 370 371 if (!(flags & DCMD_ADDRSPEC)) 372 return (DCMD_USAGE); 373 374 do { 375 if (mdb_vread(&istrmp, sizeof (istrmp), addr) == -1) 376 return (DCMD_ERR); 377 378 mdb_printf("\tistr mblk at %p: next: %?p\n" 379 "\t\tprev: %?p\tcont: %?p\n", addr, istrmp.b_next, 380 istrmp.b_prev, istrmp.b_cont); 381 daddr = (uintptr_t)&istrmp; 382 do { 383 if (mdb_vread(&dmp, sizeof (dmp), daddr) == -1) 384 break; 385 chaddr = (uintptr_t)dmp.b_rptr; 386 if (mdb_vread(&dp, sizeof (dp), chaddr) == -1) 387 break; 388 389 bbit = (SCTP_DATA_GET_BBIT(&dp) != 0); 390 ebit = (SCTP_DATA_GET_EBIT(&dp) != 0); 391 392 mdb_printf("\t\t\ttsn: %x bbit: %d ebit: %d\n", 393 dp.sdh_tsn, bbit, ebit); 394 395 396 daddr = (uintptr_t)dmp.b_cont; 397 } while (daddr != NULL); 398 399 addr = (uintptr_t)istrmp.b_next; 400 } while (addr != NULL); 401 402 return (DCMD_OK); 403 } 404 405 /* ARGSUSED */ 406 static int 407 sctp_reass_list(uintptr_t addr, uint_t flags, int ac, const mdb_arg_t *av) 408 { 409 sctp_reass_t srp; 410 mblk_t srpmp; 411 sctp_data_hdr_t dp; 412 mblk_t dmp; 413 uintptr_t daddr; 414 uintptr_t chaddr; 415 boolean_t bbit, ebit; 416 417 if (!(flags & DCMD_ADDRSPEC)) 418 return (DCMD_USAGE); 419 420 do { 421 if (mdb_vread(&srpmp, sizeof (srpmp), addr) == -1) 422 return (DCMD_ERR); 423 424 if (mdb_vread(&srp, sizeof (srp), 425 (uintptr_t)srpmp.b_datap->db_base) == -1) 426 return (DCMD_ERR); 427 428 mdb_printf("\treassembly mblk at %p: next: %?p\n" 429 "\t\tprev: %?p\tcont: %?p\n", addr, srpmp.b_next, 430 srpmp.b_prev, srpmp.b_cont); 431 mdb_printf("\t\tssn: %hu\tneeded: %hu\tgot: %hu\ttail: %?p\n" 432 "\t\tpartial_delivered: %s\n", srp.ssn, srp.needed, 433 srp.got, srp.tail, srp.partial_delivered ? "TRUE" : 434 "FALSE"); 435 436 /* display the contents of this ssn's reassemby list */ 437 daddr = DB_TYPE(&srpmp) == M_CTL ? (uintptr_t)srpmp.b_cont : 438 (uintptr_t)&srpmp; 439 do { 440 if (mdb_vread(&dmp, sizeof (dmp), daddr) == -1) 441 break; 442 chaddr = (uintptr_t)dmp.b_rptr; 443 if (mdb_vread(&dp, sizeof (dp), chaddr) == -1) 444 break; 445 446 bbit = (SCTP_DATA_GET_BBIT(&dp) != 0); 447 ebit = (SCTP_DATA_GET_EBIT(&dp) != 0); 448 449 mdb_printf("\t\t\ttsn: %x bbit: %d ebit: %d\n", 450 dp.sdh_tsn, bbit, ebit); 451 452 daddr = (uintptr_t)dmp.b_cont; 453 } while (daddr != NULL); 454 455 addr = (uintptr_t)srpmp.b_next; 456 } while (addr != NULL); 457 458 return (DCMD_OK); 459 } 460 461 /* ARGSUSED */ 462 static int 463 sctp_uo_reass_list(uintptr_t addr, uint_t flags, int ac, const mdb_arg_t *av) 464 { 465 sctp_data_hdr_t dp; 466 mblk_t dmp; 467 uintptr_t chaddr; 468 boolean_t bbit; 469 boolean_t ebit; 470 boolean_t ubit; 471 472 if (!(flags & DCMD_ADDRSPEC)) 473 return (DCMD_USAGE); 474 475 do { 476 if (mdb_vread(&dmp, sizeof (dmp), addr) == -1) 477 return (DCMD_ERR); 478 479 mdb_printf("\treassembly mblk at %p: next: %?p\n" 480 "\t\tprev: %?p\n", addr, dmp.b_next, dmp.b_prev); 481 482 chaddr = (uintptr_t)dmp.b_rptr; 483 if (mdb_vread(&dp, sizeof (dp), chaddr) == -1) 484 break; 485 486 bbit = (SCTP_DATA_GET_BBIT(&dp) != 0); 487 ebit = (SCTP_DATA_GET_EBIT(&dp) != 0); 488 ubit = (SCTP_DATA_GET_UBIT(&dp) != 0); 489 490 mdb_printf("\t\t\tsid: %hu ssn: %hu tsn: %x " 491 "flags: %x (U=%d B=%d E=%d)\n", dp.sdh_sid, dp.sdh_ssn, 492 dp.sdh_tsn, dp.sdh_flags, ubit, bbit, ebit); 493 494 addr = (uintptr_t)dmp.b_next; 495 } while (addr != NULL); 496 497 return (DCMD_OK); 498 } 499 500 static int 501 sctp_instr(uintptr_t addr, uint_t flags, int ac, const mdb_arg_t *av) 502 { 503 sctp_instr_t sip; 504 505 if (!(flags & DCMD_ADDRSPEC)) 506 return (DCMD_USAGE); 507 508 if (mdb_vread(&sip, sizeof (sip), addr) == -1) 509 return (DCMD_ERR); 510 511 mdb_printf("%<b>%-?p%</b>\n\tmsglist\t%?p\tnmsgs\t%?d\n" 512 "\tnextseq\t%?d\treass\t%?p\n", addr, sip.istr_msgs, 513 sip.istr_nmsgs, sip.nextseq, sip.istr_reass); 514 mdb_set_dot(addr + sizeof (sip)); 515 516 return (sctp_reass_list((uintptr_t)sip.istr_reass, flags, ac, av)); 517 } 518 519 static const char * 520 state2str(sctp_t *sctp) 521 { 522 switch (sctp->sctp_state) { 523 case SCTPS_IDLE: return ("SCTPS_IDLE"); 524 case SCTPS_BOUND: return ("SCTPS_BOUND"); 525 case SCTPS_LISTEN: return ("SCTPS_LISTEN"); 526 case SCTPS_COOKIE_WAIT: return ("SCTPS_COOKIE_WAIT"); 527 case SCTPS_COOKIE_ECHOED: return ("SCTPS_COOKIE_ECHOED"); 528 case SCTPS_ESTABLISHED: return ("SCTPS_ESTABLISHED"); 529 case SCTPS_SHUTDOWN_PENDING: return ("SCTPS_SHUTDOWN_PENDING"); 530 case SCTPS_SHUTDOWN_SENT: return ("SCTPS_SHUTDOWN_SENT"); 531 case SCTPS_SHUTDOWN_RECEIVED: return ("SCTPS_SHUTDOWN_RECEIVED"); 532 case SCTPS_SHUTDOWN_ACK_SENT: return ("SCTPS_SHUTDOWN_ACK_SENT"); 533 default: return ("UNKNOWN STATE"); 534 } 535 } 536 537 static void 538 show_sctp_flags(sctp_t *sctp) 539 { 540 mdb_printf("\tunderstands_asconf\t%d\n", 541 sctp->sctp_understands_asconf); 542 mdb_printf("\tdebug\t\t\t%d\n", sctp->sctp_debug); 543 mdb_printf("\tdontroute\t\t%d\n", sctp->sctp_dontroute); 544 mdb_printf("\tbroadcast\t\t%d\n", sctp->sctp_broadcast); 545 546 mdb_printf("\tuseloopback\t\t%d\n", sctp->sctp_useloopback); 547 mdb_printf("\tcchunk_pend\t\t%d\n", sctp->sctp_cchunk_pend); 548 mdb_printf("\tdgram_errind\t\t%d\n", sctp->sctp_dgram_errind); 549 mdb_printf("\treuseaddr\t\t%d\n", sctp->sctp_reuseaddr); 550 551 mdb_printf("\tlinger\t\t\t%d\n", sctp->sctp_linger); 552 if (sctp->sctp_lingering) 553 return; 554 mdb_printf("\tlingering\t\t%d\n", sctp->sctp_lingering); 555 mdb_printf("\tloopback\t\t%d\n", sctp->sctp_loopback); 556 mdb_printf("\tforce_sack\t\t%d\n", sctp->sctp_force_sack); 557 558 mdb_printf("\tack_timer_runing\t%d\n", sctp->sctp_ack_timer_running); 559 mdb_printf("\trecvdstaddr\t\t%d\n", sctp->sctp_recvdstaddr); 560 mdb_printf("\thwcksum\t\t\t%d\n", sctp->sctp_hwcksum); 561 mdb_printf("\tunderstands_addip\t%d\n", sctp->sctp_understands_addip); 562 563 mdb_printf("\tbound_to_all\t\t%d\n", sctp->sctp_bound_to_all); 564 mdb_printf("\tcansleep\t\t%d\n", sctp->sctp_cansleep); 565 mdb_printf("\tdetached\t\t%d\n", sctp->sctp_detached); 566 mdb_printf("\tsend_adaption\t\t%d\n", sctp->sctp_send_adaption); 567 568 mdb_printf("\trecv_adaption\t\t%d\n", sctp->sctp_recv_adaption); 569 mdb_printf("\tndelay\t\t\t%d\n", sctp->sctp_ndelay); 570 mdb_printf("\tcondemned\t\t%d\n", sctp->sctp_condemned); 571 mdb_printf("\tchk_fast_rexmit\t\t%d\n", sctp->sctp_chk_fast_rexmit); 572 573 mdb_printf("\tprsctp_aware\t\t%d\n", sctp->sctp_prsctp_aware); 574 mdb_printf("\tlinklocal\t\t%d\n", sctp->sctp_linklocal); 575 mdb_printf("\tmac_exempt\t\t%d\n", sctp->sctp_mac_exempt); 576 mdb_printf("\trexmitting\t\t%d\n", sctp->sctp_rexmitting); 577 578 mdb_printf("\trecvsndrcvinfo\t\t%d\n", sctp->sctp_recvsndrcvinfo); 579 mdb_printf("\trecvassocevnt\t\t%d\n", sctp->sctp_recvassocevnt); 580 mdb_printf("\trecvpathevnt\t\t%d\n", sctp->sctp_recvpathevnt); 581 mdb_printf("\trecvsendfailevnt\t%d\n", sctp->sctp_recvsendfailevnt); 582 583 mdb_printf("\trecvpeerevnt\t\t%d\n", sctp->sctp_recvpeererr); 584 mdb_printf("\trecvchutdownevnt\t%d\n", sctp->sctp_recvshutdownevnt); 585 mdb_printf("\trecvcpdnevnt\t\t%d\n", sctp->sctp_recvpdevnt); 586 mdb_printf("\trecvcalevnt\t\t%d\n\n", sctp->sctp_recvalevnt); 587 } 588 589 /* 590 * Given a sctp_saddr_ipif_t, print out its address. This assumes 591 * that addr contains the sctp_addr_ipif_t structure already and this 592 * function does not need to read it in. 593 */ 594 /* ARGSUSED */ 595 static int 596 print_saddr(uintptr_t ptr, const void *addr, void *cbdata) 597 { 598 sctp_saddr_ipif_t *saddr = (sctp_saddr_ipif_t *)addr; 599 sctp_ipif_t ipif; 600 char *statestr; 601 602 /* Read in the sctp_ipif object */ 603 if (mdb_vread(&ipif, sizeof (ipif), (uintptr_t)saddr->saddr_ipifp) == 604 -1) { 605 mdb_warn("cannot read ipif at %p", saddr->saddr_ipifp); 606 return (WALK_ERR); 607 } 608 609 switch (ipif.sctp_ipif_state) { 610 case SCTP_IPIFS_CONDEMNED: 611 statestr = "Condemned"; 612 break; 613 case SCTP_IPIFS_INVALID: 614 statestr = "Invalid"; 615 break; 616 case SCTP_IPIFS_DOWN: 617 statestr = "Down"; 618 break; 619 case SCTP_IPIFS_UP: 620 statestr = "Up"; 621 break; 622 default: 623 statestr = "Unknown"; 624 break; 625 } 626 mdb_printf("\t%p\t%N% (%s", saddr->saddr_ipifp, &ipif.sctp_ipif_saddr, 627 statestr); 628 if (saddr->saddr_ipif_dontsrc == 1) 629 mdb_printf("/Dontsrc"); 630 if (saddr->saddr_ipif_unconfirmed == 1) 631 mdb_printf("/Unconfirmed"); 632 if (saddr->saddr_ipif_delete_pending == 1) 633 mdb_printf("/DeletePending"); 634 mdb_printf(")\n"); 635 mdb_printf("\t\t\tMTU %d id %d zoneid %d IPIF flags %x\n", 636 ipif.sctp_ipif_mtu, ipif.sctp_ipif_id, 637 ipif.sctp_ipif_zoneid, ipif.sctp_ipif_flags); 638 return (WALK_NEXT); 639 } 640 641 /* 642 * Given a sctp_faddr_t, print out its address. This assumes that 643 * addr contains the sctp_faddr_t structure already and this function 644 * does not need to read it in. 645 */ 646 static int 647 print_faddr(uintptr_t ptr, const void *addr, void *cbdata) 648 { 649 char *statestr; 650 sctp_faddr_t *faddr = (sctp_faddr_t *)addr; 651 int *i = cbdata; 652 653 statestr = sctp_faddr_state(faddr->state); 654 655 mdb_printf("\t%d:\t%N\t%?p (%s)\n", (*i)++, &faddr->faddr, ptr, 656 statestr); 657 return (WALK_NEXT); 658 } 659 660 int 661 sctp(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 662 { 663 sctp_t sctp; 664 conn_t connp; 665 int i; 666 uint_t opts = 0; 667 uint_t paddr = 0; 668 in_port_t lport, fport; 669 670 if (!(flags & DCMD_ADDRSPEC)) 671 return (DCMD_USAGE); 672 673 if (mdb_vread(&sctp, sizeof (sctp), addr) == -1) { 674 mdb_warn("failed to read sctp_t at: %p\n", addr); 675 return (DCMD_ERR); 676 } 677 if (mdb_vread(&connp, sizeof (connp), 678 (uintptr_t)sctp.sctp_connp) == -1) { 679 mdb_warn("failed to read conn_t at: %p\n", sctp.sctp_connp); 680 return (DCMD_ERR); 681 } 682 683 if (mdb_getopts(argc, argv, 684 'a', MDB_OPT_SETBITS, MDB_SCTP_SHOW_ALL, &opts, 685 'f', MDB_OPT_SETBITS, MDB_SCTP_SHOW_FLAGS, &opts, 686 'h', MDB_OPT_SETBITS, MDB_SCTP_SHOW_HASH, &opts, 687 'o', MDB_OPT_SETBITS, MDB_SCTP_SHOW_OUT, &opts, 688 'i', MDB_OPT_SETBITS, MDB_SCTP_SHOW_IN, &opts, 689 'm', MDB_OPT_SETBITS, MDB_SCTP_SHOW_MISC, &opts, 690 'r', MDB_OPT_SETBITS, MDB_SCTP_SHOW_RTT, &opts, 691 'S', MDB_OPT_SETBITS, MDB_SCTP_SHOW_STATS, &opts, 692 'F', MDB_OPT_SETBITS, MDB_SCTP_SHOW_FLOW, &opts, 693 'H', MDB_OPT_SETBITS, MDB_SCTP_SHOW_HDR, &opts, 694 'p', MDB_OPT_SETBITS, MDB_SCTP_SHOW_PMTUD, &opts, 695 'R', MDB_OPT_SETBITS, MDB_SCTP_SHOW_RXT, &opts, 696 'C', MDB_OPT_SETBITS, MDB_SCTP_SHOW_CONN, &opts, 697 'c', MDB_OPT_SETBITS, MDB_SCTP_SHOW_CLOSE, &opts, 698 'e', MDB_OPT_SETBITS, MDB_SCTP_SHOW_EXT, &opts, 699 'P', MDB_OPT_SETBITS, 1, &paddr, 700 'd', MDB_OPT_SETBITS, MDB_SCTP_DUMP_ADDRS, &opts) != argc) { 701 return (DCMD_USAGE); 702 } 703 704 /* non-verbose faddrs, suitable for pipelines to sctp_faddr */ 705 if (paddr != 0) { 706 sctp_faddr_t faddr, *fp; 707 for (fp = sctp.sctp_faddrs; fp != NULL; fp = faddr.next) { 708 if (mdb_vread(&faddr, sizeof (faddr), (uintptr_t)fp) 709 == -1) { 710 mdb_warn("failed to read faddr at %p", 711 fp); 712 return (DCMD_ERR); 713 } 714 mdb_printf("%p\n", fp); 715 } 716 return (DCMD_OK); 717 } 718 719 mdb_nhconvert(&lport, &sctp.sctp_lport, sizeof (lport)); 720 mdb_nhconvert(&fport, &sctp.sctp_fport, sizeof (fport)); 721 mdb_printf("%<u>%p% %22s S=%-6hu D=%-6hu% ZONE=%d%</u>", addr, 722 state2str(&sctp), lport, fport, connp.conn_zoneid); 723 724 if (sctp.sctp_faddrs) { 725 sctp_faddr_t faddr; 726 if (mdb_vread(&faddr, sizeof (faddr), 727 (uintptr_t)sctp.sctp_faddrs) != -1) 728 mdb_printf("%<u> %N%</u>", &faddr.faddr); 729 } 730 mdb_printf("\n"); 731 732 if (opts & MDB_SCTP_DUMP_ADDRS) { 733 mdb_printf("%<b>Local and Peer Addresses%</b>\n"); 734 735 /* Display source addresses */ 736 mdb_printf("nsaddrs\t\t%?d\n", sctp.sctp_nsaddrs); 737 (void) mdb_pwalk("sctp_walk_saddr", print_saddr, NULL, addr); 738 739 /* Display peer addresses */ 740 mdb_printf("nfaddrs\t\t%?d\n", sctp.sctp_nfaddrs); 741 i = 1; 742 (void) mdb_pwalk("sctp_walk_faddr", print_faddr, &i, addr); 743 744 mdb_printf("lastfaddr\t%?p\tprimary\t\t%?p\n", 745 sctp.sctp_lastfaddr, sctp.sctp_primary); 746 mdb_printf("current\t\t%?p\tlastdata\t%?p\n", 747 sctp.sctp_current, sctp.sctp_lastdata); 748 } 749 750 if (opts & MDB_SCTP_SHOW_OUT) { 751 mdb_printf("%<b>Outbound Data%</b>\n"); 752 mdb_printf("xmit_head\t%?p\txmit_tail\t%?p\n", 753 sctp.sctp_xmit_head, sctp.sctp_xmit_tail); 754 mdb_printf("xmit_unsent\t%?p\txmit_unsent_tail%?p\n", 755 sctp.sctp_xmit_unsent, sctp.sctp_xmit_unsent_tail); 756 mdb_printf("xmit_unacked\t%?p\n", sctp.sctp_xmit_unacked); 757 mdb_printf("unacked\t\t%?u\tunsent\t\t%?ld\n", 758 sctp.sctp_unacked, sctp.sctp_unsent); 759 mdb_printf("ltsn\t\t%?x\tlastack_rxd\t%?x\n", 760 sctp.sctp_ltsn, sctp.sctp_lastack_rxd); 761 mdb_printf("recovery_tsn\t%?x\tadv_pap\t\t%?x\n", 762 sctp.sctp_recovery_tsn, sctp.sctp_adv_pap); 763 mdb_printf("num_ostr\t%?hu\tostrcntrs\t%?p\n", 764 sctp.sctp_num_ostr, sctp.sctp_ostrcntrs); 765 766 mdb_printf("%<b>Default Send Parameters%</b>\n"); 767 mdb_printf("def_stream\t%?u\tdef_flags\t%?x\n", 768 sctp.sctp_def_stream, sctp.sctp_def_flags); 769 mdb_printf("def_ppid\t%?x\tdef_context\t%?x\n", 770 sctp.sctp_def_ppid, sctp.sctp_def_context); 771 mdb_printf("def_timetolive\t%?u\n", 772 sctp.sctp_def_timetolive); 773 } 774 775 if (opts & MDB_SCTP_SHOW_IN) { 776 mdb_printf("%<b>Inbound Data%</b>\n"); 777 mdb_printf("sack_info\t%?p\tsack_gaps\t%?d\n", 778 sctp.sctp_sack_info, sctp.sctp_sack_gaps); 779 dump_sack_info((uintptr_t)sctp.sctp_sack_info); 780 mdb_printf("ftsn\t\t%?x\tlastacked\t%?x\n", 781 sctp.sctp_ftsn, sctp.sctp_lastacked); 782 mdb_printf("istr_nmsgs\t%?d\tsack_toggle\t%?d\n", 783 sctp.sctp_istr_nmsgs, sctp.sctp_sack_toggle); 784 mdb_printf("ack_mp\t\t%?p\n", sctp.sctp_ack_mp); 785 mdb_printf("num_istr\t%?hu\tinstr\t\t%?p\n", 786 sctp.sctp_num_istr, sctp.sctp_instr); 787 mdb_printf("unord_reass\t%?p\n", sctp.sctp_uo_frags); 788 } 789 790 if (opts & MDB_SCTP_SHOW_RTT) { 791 mdb_printf("%<b>RTT Tracking%</b>\n"); 792 mdb_printf("rtt_tsn\t\t%?x\tout_time\t%?ld\n", 793 sctp.sctp_rtt_tsn, sctp.sctp_out_time); 794 } 795 796 if (opts & MDB_SCTP_SHOW_FLOW) { 797 mdb_printf("%<b>Flow Control%</b>\n"); 798 mdb_printf("txmit_hiwater\t%?d\n" 799 "xmit_lowater\t%?d\tfrwnd\t\t%?u\n" 800 "rwnd\t\t%?u\tinitial rwnd\t%?u\n" 801 "rxqueued\t%?u\tcwnd_max\t%?u\n", sctp.sctp_xmit_hiwater, 802 sctp.sctp_xmit_lowater, sctp.sctp_frwnd, 803 sctp.sctp_rwnd, sctp.sctp_irwnd, sctp.sctp_rxqueued, 804 sctp.sctp_cwnd_max); 805 } 806 807 if (opts & MDB_SCTP_SHOW_HDR) { 808 mdb_printf("%<b>Composite Headers%</b>\n"); 809 mdb_printf("iphc\t\t%?p\tiphc6\t\t%?p\n" 810 "iphc_len\t%?d\tiphc6_len\t%?d\n" 811 "hdr_len\t\t%?d\thdr6_len\t%?d\n" 812 "ipha\t\t%?p\tip6h\t\t%?p\n" 813 "ip_hdr_len\t%?d\tip_hdr6_len\t%?d\n" 814 "sctph\t\t%?p\tsctph6\t\t%?p\n" 815 "lvtag\t\t%?x\tfvtag\t\t%?x\n", sctp.sctp_iphc, 816 sctp.sctp_iphc6, sctp.sctp_iphc_len, 817 sctp.sctp_iphc6_len, sctp.sctp_hdr_len, 818 sctp.sctp_hdr6_len, sctp.sctp_ipha, sctp.sctp_ip6h, 819 sctp.sctp_ip_hdr_len, sctp.sctp_ip_hdr6_len, 820 sctp.sctp_sctph, sctp.sctp_sctph6, sctp.sctp_lvtag, 821 sctp.sctp_fvtag); 822 } 823 824 if (opts & MDB_SCTP_SHOW_PMTUD) { 825 mdb_printf("%<b>PMTUd%</b>\n"); 826 mdb_printf("last_mtu_probe\t%?ld\tmtu_probe_intvl\t%?ld\n" 827 "mss\t\t%?u\n", 828 sctp.sctp_last_mtu_probe, sctp.sctp_mtu_probe_intvl, 829 sctp.sctp_mss); 830 } 831 832 if (opts & MDB_SCTP_SHOW_RXT) { 833 mdb_printf("%<b>Retransmit Info%</b>\n"); 834 mdb_printf("cookie_mp\t%?p\tstrikes\t\t%?d\n" 835 "max_init_rxt\t%?d\tpa_max_rxt\t%?d\n" 836 "pp_max_rxt\t%?d\trto_max\t\t%?u\n" 837 "rto_min\t\t%?u\trto_initial\t%?u\n" 838 "init_rto_max\t%?u\n" 839 "rxt_nxttsn\t%?u\trxt_maxtsn\t%?u\n", sctp.sctp_cookie_mp, 840 sctp.sctp_strikes, sctp.sctp_max_init_rxt, 841 sctp.sctp_pa_max_rxt, sctp.sctp_pp_max_rxt, 842 sctp.sctp_rto_max, sctp.sctp_rto_min, 843 sctp.sctp_rto_initial, sctp.sctp_init_rto_max, 844 sctp.sctp_rxt_nxttsn, sctp.sctp_rxt_maxtsn); 845 } 846 847 if (opts & MDB_SCTP_SHOW_CONN) { 848 mdb_printf("%<b>Connection State%</b>\n"); 849 mdb_printf("last_secret_update%?ld\n", 850 sctp.sctp_last_secret_update); 851 852 mdb_printf("secret\t\t"); 853 for (i = 0; i < SCTP_SECRET_LEN; i++) { 854 if (i % 2 == 0) 855 mdb_printf("0x%02x", sctp.sctp_secret[i]); 856 else 857 mdb_printf("%02x ", sctp.sctp_secret[i]); 858 } 859 mdb_printf("\n"); 860 mdb_printf("old_secret\t"); 861 for (i = 0; i < SCTP_SECRET_LEN; i++) { 862 if (i % 2 == 0) 863 mdb_printf("0x%02x", sctp.sctp_old_secret[i]); 864 else 865 mdb_printf("%02x ", sctp.sctp_old_secret[i]); 866 } 867 mdb_printf("\n"); 868 } 869 870 if (opts & MDB_SCTP_SHOW_STATS) { 871 mdb_printf("%<b>Stats Counters%</b>\n"); 872 mdb_printf("opkts\t\t%?llu\tobchunks\t%?llu\n" 873 "odchunks\t%?llu\toudchunks\t%?llu\n" 874 "rxtchunks\t%?llu\tT1expire\t%?lu\n" 875 "T2expire\t%?lu\tT3expire\t%?lu\n" 876 "msgcount\t%?llu\tprsctpdrop\t%?llu\n" 877 "AssocStartTime\t%?lu\n", 878 sctp.sctp_opkts, sctp.sctp_obchunks, 879 sctp.sctp_odchunks, sctp.sctp_oudchunks, 880 sctp.sctp_rxtchunks, sctp.sctp_T1expire, 881 sctp.sctp_T2expire, sctp.sctp_T3expire, 882 sctp.sctp_msgcount, sctp.sctp_prsctpdrop, 883 sctp.sctp_assoc_start_time); 884 mdb_printf("ipkts\t\t%?llu\tibchunks\t%?llu\n" 885 "idchunks\t%?llu\tiudchunks\t%?llu\n" 886 "fragdmsgs\t%?llu\treassmsgs\t%?llu\n", 887 sctp.sctp_ipkts, sctp.sctp_ibchunks, 888 sctp.sctp_idchunks, sctp.sctp_iudchunks, 889 sctp.sctp_fragdmsgs, sctp.sctp_reassmsgs); 890 } 891 892 if (opts & MDB_SCTP_SHOW_HASH) { 893 mdb_printf("%<b>Hash Tables%</b>\n"); 894 mdb_printf("conn_hash_next\t%?p\t", sctp.sctp_conn_hash_next); 895 mdb_printf("conn_hash_prev\t%?p\n", sctp.sctp_conn_hash_prev); 896 mdb_printf("[ conn_hash bucket\t%?d ]\n", 897 SCTP_CONN_HASH(sctp.sctp_ports)); 898 899 mdb_printf("listen_hash_next%?p\t", 900 sctp.sctp_listen_hash_next); 901 mdb_printf("listen_hash_prev%?p\n", 902 sctp.sctp_listen_hash_prev); 903 mdb_nhconvert(&lport, &sctp.sctp_lport, sizeof (lport)); 904 mdb_printf("[ listen_hash bucket\t%?d ]\n", 905 SCTP_LISTEN_HASH(lport)); 906 907 mdb_printf("conn_tfp\t%?p\t", sctp.sctp_conn_tfp); 908 mdb_printf("listen_tfp\t%?p\n", sctp.sctp_listen_tfp); 909 910 mdb_printf("bind_hash\t%?p\tptpbhn\t\t%?p\n", 911 sctp.sctp_bind_hash, sctp.sctp_ptpbhn); 912 mdb_printf("bind_lockp\t%?p\n", 913 sctp.sctp_bind_lockp); 914 mdb_printf("[ bind_hash bucket\t%?d ]\n", 915 SCTP_BIND_HASH(lport)); 916 } 917 918 if (opts & MDB_SCTP_SHOW_CLOSE) { 919 mdb_printf("%<b>Cleanup / Close%</b>\n"); 920 mdb_printf("shutdown_faddr\t%?p\tclient_errno\t%?d\n" 921 "lingertime\t%?d\trefcnt\t\t%?hu\n", 922 sctp.sctp_shutdown_faddr, sctp.sctp_client_errno, 923 sctp.sctp_lingertime, sctp.sctp_refcnt); 924 } 925 926 if (opts & MDB_SCTP_SHOW_MISC) { 927 mdb_printf("%<b>Miscellaneous%</b>\n"); 928 mdb_printf("bound_if\t%?u\theartbeat_mp\t%?p\n" 929 "family\t\t%?u\tipversion\t%?hu\n" 930 "hb_interval\t%?u\tautoclose\t%?d\n" 931 "active\t\t%?ld\ttx_adaption_code%?x\n" 932 "rx_adaption_code%?x\ttimer_mp\t%?p\n", 933 sctp.sctp_bound_if, sctp.sctp_heartbeat_mp, 934 sctp.sctp_family, sctp.sctp_ipversion, 935 sctp.sctp_hb_interval, sctp.sctp_autoclose, 936 sctp.sctp_active, sctp.sctp_tx_adaption_code, 937 sctp.sctp_rx_adaption_code, sctp.sctp_timer_mp); 938 } 939 940 if (opts & MDB_SCTP_SHOW_EXT) { 941 mdb_printf("%<b>Extensions and Reliable Ctl Chunks%</b>\n"); 942 mdb_printf("cxmit_list\t%?p\tlcsn\t\t%?x\n" 943 "fcsn\t\t%?x\n", sctp.sctp_cxmit_list, sctp.sctp_lcsn, 944 sctp.sctp_fcsn); 945 } 946 947 if (opts & MDB_SCTP_SHOW_FLAGS) { 948 mdb_printf("%<b>Flags%</b>\n"); 949 show_sctp_flags(&sctp); 950 } 951 952 return (DCMD_OK); 953 } 954 955 typedef struct fanout_walk_data { 956 int index; 957 int size; 958 uintptr_t sctp; 959 sctp_tf_t *fanout; 960 uintptr_t (*getnext)(sctp_t *); 961 } fanout_walk_data_t; 962 963 typedef struct fanout_init { 964 const char *symname; 965 int (*getsize)(); 966 uintptr_t (*getnext)(sctp_t *); 967 } fanout_init_t; 968 969 static uintptr_t 970 listen_next(sctp_t *sctp) 971 { 972 return ((uintptr_t)sctp->sctp_listen_hash_next); 973 } 974 975 static int 976 listen_size(void) 977 { 978 return (SCTP_LISTEN_FANOUT_SIZE); 979 } 980 981 static uintptr_t 982 conn_next(sctp_t *sctp) 983 { 984 return ((uintptr_t)sctp->sctp_conn_hash_next); 985 } 986 987 static int 988 conn_size(void) 989 { 990 GElf_Sym sym; 991 int size; 992 993 if (mdb_lookup_by_name("sctp_conn_hash_size", &sym) == -1) { 994 mdb_warn("can't read 'sctp_conn_hash_size'"); 995 return (1); 996 } 997 if (mdb_vread(&size, sizeof (size), sym.st_value) == -1) { 998 mdb_warn("can't dereference 'sctp_conn_hash_size'"); 999 return (1); 1000 } 1001 return (size); 1002 } 1003 1004 static uintptr_t 1005 bind_next(sctp_t *sctp) 1006 { 1007 return ((uintptr_t)sctp->sctp_bind_hash); 1008 } 1009 1010 static int 1011 bind_size(void) 1012 { 1013 return (SCTP_BIND_FANOUT_SIZE); 1014 } 1015 1016 static intptr_t 1017 find_next_hash_item(fanout_walk_data_t *fw) 1018 { 1019 sctp_tf_t tf; 1020 sctp_t sctp; 1021 1022 /* first try to continue down the hash chain */ 1023 if (fw->sctp != NULL) { 1024 /* try to get next in hash chain */ 1025 if (mdb_vread(&sctp, sizeof (sctp), fw->sctp) == -1) { 1026 mdb_warn("failed to read sctp at %p", fw->sctp); 1027 return (NULL); 1028 } 1029 fw->sctp = fw->getnext(&sctp); 1030 if (fw->sctp != NULL) 1031 return (fw->sctp); 1032 else 1033 /* end of chain; go to next bucket */ 1034 fw->index++; 1035 } 1036 1037 /* find a new hash chain, traversing the buckets */ 1038 for (; fw->index < fw->size; fw->index++) { 1039 /* read the current hash line for an sctp */ 1040 if (mdb_vread(&tf, sizeof (tf), 1041 (uintptr_t)(fw->fanout + fw->index)) == -1) { 1042 mdb_warn("failed to read tf at %p", 1043 fw->fanout + fw->index); 1044 return (NULL); 1045 } 1046 if (tf.tf_sctp != NULL) { 1047 /* start of a new chain */ 1048 fw->sctp = (uintptr_t)tf.tf_sctp; 1049 return (fw->sctp); 1050 } 1051 } 1052 return (NULL); 1053 } 1054 1055 static int 1056 fanout_walk_init(mdb_walk_state_t *wsp) 1057 { 1058 GElf_Sym sym; 1059 fanout_walk_data_t *lw; 1060 fanout_init_t *fi = wsp->walk_arg; 1061 1062 if (mdb_lookup_by_name(fi->symname, &sym) == -1) { 1063 mdb_warn("failed to read '%s'", fi->symname); 1064 return (WALK_ERR); 1065 } 1066 1067 lw = mdb_alloc(sizeof (*lw), UM_SLEEP); 1068 lw->index = 0; 1069 lw->size = fi->getsize(); 1070 lw->sctp = NULL; 1071 lw->fanout = (sctp_tf_t *)(uintptr_t)sym.st_value; 1072 lw->getnext = fi->getnext; 1073 1074 if ((wsp->walk_addr = find_next_hash_item(lw)) == NULL) { 1075 return (WALK_DONE); 1076 } 1077 wsp->walk_data = lw; 1078 return (WALK_NEXT); 1079 } 1080 1081 static int 1082 fanout_walk_step(mdb_walk_state_t *wsp) 1083 { 1084 fanout_walk_data_t *fw = wsp->walk_data; 1085 uintptr_t addr = wsp->walk_addr; 1086 sctp_t sctp; 1087 int status; 1088 1089 if (mdb_vread(&sctp, sizeof (sctp), addr) == -1) { 1090 mdb_warn("failed to read sctp at %p", addr); 1091 return (WALK_DONE); 1092 } 1093 1094 status = wsp->walk_callback(addr, &sctp, wsp->walk_cbdata); 1095 if (status != WALK_NEXT) 1096 return (status); 1097 1098 if ((wsp->walk_addr = find_next_hash_item(fw)) == NULL) 1099 return (WALK_DONE); 1100 1101 return (WALK_NEXT); 1102 } 1103 1104 static void 1105 fanout_walk_fini(mdb_walk_state_t *wsp) 1106 { 1107 fanout_walk_data_t *fw = wsp->walk_data; 1108 1109 mdb_free(fw, sizeof (*fw)); 1110 } 1111 1112 static int 1113 sctp_walk_init(mdb_walk_state_t *wsp) 1114 { 1115 wsp->walk_addr = (uintptr_t)list_object(&sctp_list, 1116 sctp_list.list_head.list_next); 1117 return (WALK_NEXT); 1118 } 1119 1120 static int 1121 sctp_walk_step(mdb_walk_state_t *wsp) 1122 { 1123 uintptr_t psctp = wsp->walk_addr; 1124 sctp_t sctp; 1125 int status; 1126 1127 if (mdb_vread(&sctp, sizeof (sctp), psctp) == -1) { 1128 mdb_warn("failed to read sctp at %p", psctp); 1129 return (WALK_ERR); 1130 } 1131 status = wsp->walk_callback(psctp, &sctp, wsp->walk_cbdata); 1132 if (status != WALK_NEXT) 1133 return (status); 1134 1135 if ((psctp = (uintptr_t)sctp.sctp_list.list_next) == 1136 sctp_list_sym.st_value + OFFSETOF(list_t, list_head)) { 1137 return (WALK_DONE); 1138 } else { 1139 wsp->walk_addr = (uintptr_t)list_object(&sctp_list, psctp); 1140 return (WALK_NEXT); 1141 } 1142 } 1143 1144 static int 1145 sctp_walk_faddr_init(mdb_walk_state_t *wsp) 1146 { 1147 sctp_t sctp; 1148 1149 if (wsp->walk_addr == NULL) 1150 return (WALK_ERR); 1151 1152 if (mdb_vread(&sctp, sizeof (sctp), wsp->walk_addr) == -1) { 1153 mdb_warn("failed to read sctp at %p", wsp->walk_addr); 1154 return (WALK_ERR); 1155 } 1156 if ((wsp->walk_addr = (uintptr_t)sctp.sctp_faddrs) != NULL) 1157 return (WALK_NEXT); 1158 else 1159 return (WALK_DONE); 1160 } 1161 1162 static int 1163 sctp_walk_faddr_step(mdb_walk_state_t *wsp) 1164 { 1165 uintptr_t faddr_ptr = wsp->walk_addr; 1166 sctp_faddr_t sctp_faddr; 1167 int status; 1168 1169 if (mdb_vread(&sctp_faddr, sizeof (sctp_faddr_t), faddr_ptr) == -1) { 1170 mdb_warn("failed to read sctp_faddr_t at %p", faddr_ptr); 1171 return (WALK_ERR); 1172 } 1173 status = wsp->walk_callback(faddr_ptr, &sctp_faddr, wsp->walk_cbdata); 1174 if (status != WALK_NEXT) 1175 return (status); 1176 if ((faddr_ptr = (uintptr_t)sctp_faddr.next) == NULL) { 1177 return (WALK_DONE); 1178 } else { 1179 wsp->walk_addr = faddr_ptr; 1180 return (WALK_NEXT); 1181 } 1182 } 1183 1184 /* 1185 * Helper structure for sctp_walk_saddr. It stores the sctp_t being walked, 1186 * the current index to the sctp_saddrs[], and the current count of the 1187 * sctp_saddr_ipif_t list. 1188 */ 1189 typedef struct { 1190 sctp_t sctp; 1191 int hash_index; 1192 int cur_cnt; 1193 } saddr_walk_t; 1194 1195 static int 1196 sctp_walk_saddr_init(mdb_walk_state_t *wsp) 1197 { 1198 sctp_t *sctp; 1199 int i; 1200 saddr_walk_t *swalker; 1201 1202 if (wsp->walk_addr == NULL) 1203 return (WALK_ERR); 1204 1205 swalker = mdb_alloc(sizeof (saddr_walk_t), UM_SLEEP); 1206 sctp = &swalker->sctp; 1207 if (mdb_vread(sctp, sizeof (sctp_t), wsp->walk_addr) == -1) { 1208 mdb_warn("failed to read sctp at %p", wsp->walk_addr); 1209 mdb_free(swalker, sizeof (saddr_walk_t)); 1210 return (WALK_ERR); 1211 } 1212 1213 /* Find the first source address. */ 1214 for (i = 0; i < SCTP_IPIF_HASH; i++) { 1215 if (sctp->sctp_saddrs[i].ipif_count > 0) { 1216 list_t *addr_list; 1217 1218 addr_list = &sctp->sctp_saddrs[i].sctp_ipif_list; 1219 wsp->walk_addr = (uintptr_t)list_object(addr_list, 1220 addr_list->list_head.list_next); 1221 1222 /* Recode the current info */ 1223 swalker->hash_index = i; 1224 swalker->cur_cnt = 1; 1225 wsp->walk_data = swalker; 1226 1227 return (WALK_NEXT); 1228 } 1229 } 1230 return (WALK_DONE); 1231 } 1232 1233 static int 1234 sctp_walk_saddr_step(mdb_walk_state_t *wsp) 1235 { 1236 uintptr_t saddr_ptr = wsp->walk_addr; 1237 sctp_saddr_ipif_t saddr; 1238 saddr_walk_t *swalker; 1239 sctp_t *sctp; 1240 int status; 1241 int i, j; 1242 1243 if (mdb_vread(&saddr, sizeof (sctp_saddr_ipif_t), saddr_ptr) == -1) { 1244 mdb_warn("failed to read sctp_saddr_ipif_t at %p", saddr_ptr); 1245 return (WALK_ERR); 1246 } 1247 status = wsp->walk_callback(saddr_ptr, &saddr, wsp->walk_cbdata); 1248 if (status != WALK_NEXT) 1249 return (status); 1250 1251 swalker = (saddr_walk_t *)wsp->walk_data; 1252 sctp = &swalker->sctp; 1253 i = swalker->hash_index; 1254 j = swalker->cur_cnt; 1255 1256 /* 1257 * If there is still a source address in the current list, return it. 1258 * Otherwise, go to the next list in the sctp_saddrs[]. 1259 */ 1260 if (j++ < sctp->sctp_saddrs[i].ipif_count) { 1261 wsp->walk_addr = (uintptr_t)saddr.saddr_ipif.list_next; 1262 swalker->cur_cnt = j; 1263 return (WALK_NEXT); 1264 } else { 1265 list_t *lst; 1266 1267 for (i = i + 1; i < SCTP_IPIF_HASH; i++) { 1268 if (sctp->sctp_saddrs[i].ipif_count > 0) { 1269 lst = &sctp->sctp_saddrs[i].sctp_ipif_list; 1270 wsp->walk_addr = (uintptr_t)list_object( 1271 lst, lst->list_head.list_next); 1272 swalker->hash_index = i; 1273 swalker->cur_cnt = 1; 1274 return (WALK_NEXT); 1275 } 1276 } 1277 } 1278 return (WALK_DONE); 1279 } 1280 1281 static void 1282 sctp_walk_saddr_fini(mdb_walk_state_t *wsp) 1283 { 1284 saddr_walk_t *swalker = (saddr_walk_t *)wsp->walk_data; 1285 1286 mdb_free(swalker, sizeof (saddr_walk_t)); 1287 } 1288 1289 static int 1290 sctp_walk_ill_init(mdb_walk_state_t *wsp) 1291 { 1292 intptr_t i; 1293 1294 /* Find the first ill. */ 1295 for (i = 0; i < SCTP_ILL_HASH; i++) { 1296 if (local_g_ills[i].ill_count > 0) { 1297 wsp->walk_addr = (uintptr_t)list_object( 1298 &local_g_ills[i].sctp_ill_list, 1299 local_g_ills[i].sctp_ill_list.list_head.list_next); 1300 wsp->walk_data = (void *)i; 1301 wsp->walk_arg = (void *)1; 1302 return (WALK_NEXT); 1303 } 1304 } 1305 return (WALK_DONE); 1306 } 1307 1308 static int 1309 sctp_walk_ill_step(mdb_walk_state_t *wsp) 1310 { 1311 uintptr_t ill_ptr = wsp->walk_addr; 1312 sctp_ill_t ill; 1313 int status; 1314 intptr_t i, j; 1315 1316 if (mdb_vread(&ill, sizeof (sctp_ill_t), ill_ptr) == -1) { 1317 mdb_warn("failed to read sctp_ill_t at %p", ill_ptr); 1318 return (WALK_ERR); 1319 } 1320 status = wsp->walk_callback(ill_ptr, &ill, wsp->walk_cbdata); 1321 if (status != WALK_NEXT) 1322 return (status); 1323 1324 i = (intptr_t)wsp->walk_data; 1325 j = (intptr_t)wsp->walk_arg; 1326 1327 /* 1328 * If there is still an ill in the current list, return it. 1329 * Otherwise, go to the next list and find another one. 1330 */ 1331 if (j++ < local_g_ills[i].ill_count) { 1332 wsp->walk_addr = (uintptr_t)ill.sctp_ills.list_next; 1333 wsp->walk_data = (void *)i; 1334 wsp->walk_arg = (void *)j; 1335 return (WALK_NEXT); 1336 } else { 1337 list_t *ill_list; 1338 1339 for (i = i + 1; i < SCTP_ILL_HASH; i++) { 1340 if (local_g_ills[i].ill_count > 0) { 1341 ill_list = &local_g_ills[i].sctp_ill_list; 1342 wsp->walk_addr = (uintptr_t)list_object( 1343 ill_list, ill_list->list_head.list_next); 1344 1345 /* Record the current position. */ 1346 wsp->walk_data = (void *)i; 1347 wsp->walk_arg = (void *)1; 1348 return (WALK_NEXT); 1349 } 1350 } 1351 } 1352 return (WALK_DONE); 1353 } 1354 1355 static int 1356 sctp_walk_ipif_init(mdb_walk_state_t *wsp) 1357 { 1358 intptr_t i; 1359 list_t *ipif_list; 1360 1361 for (i = 0; i < SCTP_IPIF_HASH; i++) { 1362 if (local_g_ipifs[i].ipif_count > 0) { 1363 ipif_list = &local_g_ipifs[i].sctp_ipif_list; 1364 1365 wsp->walk_addr = (uintptr_t)list_object(ipif_list, 1366 ipif_list->list_head.list_next); 1367 wsp->walk_data = (void *)i; 1368 wsp->walk_arg = (void *)1; 1369 return (WALK_NEXT); 1370 } 1371 } 1372 return (WALK_DONE); 1373 } 1374 1375 static int 1376 sctp_walk_ipif_step(mdb_walk_state_t *wsp) 1377 { 1378 uintptr_t ipif_ptr = wsp->walk_addr; 1379 sctp_ipif_t ipif; 1380 int status; 1381 intptr_t i, j; 1382 1383 if (mdb_vread(&ipif, sizeof (sctp_ipif_t), ipif_ptr) == -1) { 1384 mdb_warn("failed to read sctp_ipif_t at %p", ipif_ptr); 1385 return (WALK_ERR); 1386 } 1387 status = wsp->walk_callback(ipif_ptr, &ipif, wsp->walk_cbdata); 1388 if (status != WALK_NEXT) 1389 return (status); 1390 1391 i = (intptr_t)wsp->walk_data; 1392 j = (intptr_t)wsp->walk_arg; 1393 1394 /* 1395 * If there is still an ipif in the current list, return it. 1396 * Otherwise, go to the next list and find another one. 1397 */ 1398 if (j++ < local_g_ipifs[i].ipif_count) { 1399 wsp->walk_addr = (uintptr_t)ipif.sctp_ipifs.list_next; 1400 wsp->walk_data = (void *)i; 1401 wsp->walk_arg = (void *)j; 1402 return (WALK_NEXT); 1403 } else { 1404 list_t *ipif_list; 1405 1406 for (i = i + 1; i < SCTP_IPIF_HASH; i++) { 1407 if (local_g_ipifs[i].ipif_count > 0) { 1408 ipif_list = &local_g_ipifs[i].sctp_ipif_list; 1409 wsp->walk_addr = (uintptr_t)list_object( 1410 ipif_list, ipif_list->list_head.list_next); 1411 1412 /* Record the current position */ 1413 wsp->walk_data = (void *)i; 1414 wsp->walk_arg = (void *)1; 1415 return (WALK_NEXT); 1416 } 1417 } 1418 } 1419 return (WALK_DONE); 1420 } 1421 1422 static void 1423 sctp_help(void) 1424 { 1425 mdb_printf("Print information for a given SCTP sctp_t\n\n"); 1426 mdb_printf("Options:\n"); 1427 mdb_printf("\t-a\t All the information\n"); 1428 mdb_printf("\t-f\t Flags\n"); 1429 mdb_printf("\t-h\t Hash Tables\n"); 1430 mdb_printf("\t-o\t Outbound Data\n"); 1431 mdb_printf("\t-i\t Inbound Data\n"); 1432 mdb_printf("\t-m\t Miscellaneous Information\n"); 1433 mdb_printf("\t-r\t RTT Tracking\n"); 1434 mdb_printf("\t-S\t Stats Counters\n"); 1435 mdb_printf("\t-F\t Flow Control\n"); 1436 mdb_printf("\t-H\t Composite Headers\n"); 1437 mdb_printf("\t-p\t PMTUD\n"); 1438 mdb_printf("\t-R\t Retransmit Information\n"); 1439 mdb_printf("\t-C\t Connection State\n"); 1440 mdb_printf("\t-c\t Cleanup / Close\n"); 1441 mdb_printf("\t-e\t Extensions and Reliable Control Chunks\n"); 1442 mdb_printf("\t-d\t Local and Peer addresses\n"); 1443 mdb_printf("\t-P\t Peer addresses\n"); 1444 } 1445 static const mdb_dcmd_t dcmds[] = { 1446 { "sctp", ":[-afhoimrSFHpRCcedP]", 1447 "display sctp control structure", sctp, sctp_help }, 1448 { "sctp_set", ":", "display a SCTP set", sctp_set }, 1449 { "sctp_faddr", ":", "display a faddr", sctp_faddr }, 1450 { "sctp_istr_msgs", ":", "display msg list on an instream", 1451 sctp_istr_msgs }, 1452 { "sctp_mdata_chunk", ":", "display a data chunk in an mblk", 1453 sctp_mdata_chunk }, 1454 { "sctp_xmit_list", ":", "display sctp xmit lists", sctp_xmit_list }, 1455 { "sctp_instr", ":", "display instr", sctp_instr }, 1456 { "sctp_reass_list", ":", "display reass list", sctp_reass_list }, 1457 { "sctp_uo_reass_list", ":", "display un-ordered reass list", 1458 sctp_uo_reass_list }, 1459 { NULL } 1460 }; 1461 1462 static const fanout_init_t listen_fanout_init = { 1463 "sctp_listen_fanout", listen_size, listen_next 1464 }; 1465 1466 static const fanout_init_t conn_fanout_init = { 1467 "sctp_conn_fanout", conn_size, conn_next 1468 }; 1469 1470 static const fanout_init_t bind_fanout_init = { 1471 "sctp_bind_fanout", bind_size, bind_next 1472 }; 1473 1474 static const mdb_walker_t walkers[] = { 1475 { "sctps", "walk the full chain of sctps", 1476 sctp_walk_init, sctp_walk_step, NULL }, 1477 { "sctp_listen_fanout", "walk the sctp listen fanout", 1478 fanout_walk_init, fanout_walk_step, fanout_walk_fini, 1479 (void *)&listen_fanout_init }, 1480 { "sctp_conn_fanout", "walk the sctp conn fanout", 1481 fanout_walk_init, fanout_walk_step, fanout_walk_fini, 1482 (void *)&conn_fanout_init }, 1483 { "sctp_bind_fanout", "walk the sctp bind fanout", 1484 fanout_walk_init, fanout_walk_step, fanout_walk_fini, 1485 (void *)&bind_fanout_init }, 1486 { "sctp_walk_faddr", "walk the peer address list of a given sctp_t", 1487 sctp_walk_faddr_init, sctp_walk_faddr_step, NULL }, 1488 { "sctp_walk_saddr", "walk the local address list of a given sctp_t", 1489 sctp_walk_saddr_init, sctp_walk_saddr_step, sctp_walk_saddr_fini }, 1490 { "sctp_walk_ill", "walk the sctp_g_ills list", 1491 sctp_walk_ill_init, sctp_walk_ill_step, NULL }, 1492 { "sctp_walk_ipif", "walk the sctp_g_ipif list", 1493 sctp_walk_ipif_init, sctp_walk_ipif_step, NULL }, 1494 { NULL } 1495 }; 1496 1497 static const mdb_modinfo_t modinfo = { MDB_API_VERSION, dcmds, walkers }; 1498 1499 const mdb_modinfo_t * 1500 _mdb_init(void) 1501 { 1502 GElf_Sym sym; 1503 GElf_Sym ills_sym; 1504 GElf_Sym ipifs_sym; 1505 1506 if (mdb_lookup_by_name("sctp_g_list", &sctp_list_sym) == -1) { 1507 mdb_warn("failed to find 'sctp_g_list'"); 1508 return (NULL); 1509 } 1510 if (mdb_vread(&sctp_list, sizeof (list_t), 1511 (uintptr_t)sctp_list_sym.st_value) == -1) { 1512 mdb_warn("failed to read 'sctp_g_list'"); 1513 return (NULL); 1514 } 1515 if (mdb_lookup_by_name("sctp_conn_hash_size", &sym) != -1) { 1516 if (mdb_vread(&sctp_conn_hash_size, 1517 sizeof (sctp_conn_hash_size), sym.st_value) == -1) { 1518 mdb_warn("failed to read 'sctp_conn_hash_size'"); 1519 return (NULL); 1520 } 1521 } 1522 if (mdb_lookup_by_name("sctp_g_ills", &ills_sym) == -1) { 1523 mdb_warn("failed to find 'sctp_g_ills'"); 1524 return (NULL); 1525 } 1526 if (mdb_vread(&local_g_ills, sizeof (local_g_ills), 1527 (uintptr_t)ills_sym.st_value) == -1) { 1528 mdb_warn("failed to read 'sctp_g_ills'"); 1529 return (NULL); 1530 } 1531 if (mdb_lookup_by_name("sctp_g_ipifs", &ipifs_sym) == -1) { 1532 mdb_warn("failed to find 'sctp_g_ipifs'"); 1533 return (NULL); 1534 } 1535 if (mdb_vread(&local_g_ipifs, sizeof (local_g_ipifs), 1536 (uintptr_t)ipifs_sym.st_value) == -1) { 1537 mdb_warn("failed to read 'sctp_g_ipifs'"); 1538 return (NULL); 1539 } 1540 1541 return (&modinfo); 1542 } 1543