1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2019 Isilon Systems, LLC. 5 * Copyright (c) 2005-2014 Sandvine Incorporated. All rights reserved. 6 * Copyright (c) 2000 Darrell Anderson 7 * All rights reserved. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 28 * SUCH DAMAGE. 29 */ 30 31 #include <sys/cdefs.h> 32 __FBSDID("$FreeBSD$"); 33 34 #include "opt_ddb.h" 35 #include "opt_inet.h" 36 37 #include <sys/param.h> 38 #include <sys/systm.h> 39 #include <sys/endian.h> 40 #include <sys/errno.h> 41 #include <sys/socket.h> 42 #include <sys/sysctl.h> 43 44 #ifdef DDB 45 #include <ddb/ddb.h> 46 #include <ddb/db_lex.h> 47 #endif 48 49 #include <net/ethernet.h> 50 #include <net/if.h> 51 #include <net/if_arp.h> 52 #include <net/if_dl.h> 53 #include <net/if_types.h> 54 #include <net/if_var.h> 55 56 #include <netinet/in.h> 57 #include <netinet/in_systm.h> 58 #include <netinet/in_var.h> 59 #include <netinet/ip.h> 60 #include <netinet/ip_var.h> 61 #include <netinet/ip_options.h> 62 #include <netinet/udp.h> 63 #include <netinet/udp_var.h> 64 65 #include <machine/in_cksum.h> 66 #include <machine/pcb.h> 67 68 #include <net/debugnet.h> 69 #define DEBUGNET_INTERNAL 70 #include <net/debugnet_int.h> 71 72 FEATURE(debugnet, "Debugnet support"); 73 74 SYSCTL_NODE(_net, OID_AUTO, debugnet, CTLFLAG_RD, NULL, 75 "debugnet parameters"); 76 77 unsigned debugnet_debug; 78 SYSCTL_UINT(_net_debugnet, OID_AUTO, debug, CTLFLAG_RWTUN, 79 &debugnet_debug, 0, 80 "Debug message verbosity (0: off; 1: on; 2: verbose)"); 81 82 int debugnet_npolls = 2000; 83 SYSCTL_INT(_net_debugnet, OID_AUTO, npolls, CTLFLAG_RWTUN, 84 &debugnet_npolls, 0, 85 "Number of times to poll before assuming packet loss (0.5ms per poll)"); 86 int debugnet_nretries = 10; 87 SYSCTL_INT(_net_debugnet, OID_AUTO, nretries, CTLFLAG_RWTUN, 88 &debugnet_nretries, 0, 89 "Number of retransmit attempts before giving up"); 90 91 static bool g_debugnet_pcb_inuse; 92 static struct debugnet_pcb g_dnet_pcb; 93 94 /* 95 * Simple accessors for opaque PCB. 96 */ 97 const unsigned char * 98 debugnet_get_gw_mac(const struct debugnet_pcb *pcb) 99 { 100 MPASS(g_debugnet_pcb_inuse && pcb == &g_dnet_pcb && 101 pcb->dp_state >= DN_STATE_HAVE_GW_MAC); 102 return (pcb->dp_gw_mac.octet); 103 } 104 105 /* 106 * Start of network primitives, beginning with output primitives. 107 */ 108 109 /* 110 * Handles creation of the ethernet header, then places outgoing packets into 111 * the tx buffer for the NIC 112 * 113 * Parameters: 114 * m The mbuf containing the packet to be sent (will be freed by 115 * this function or the NIC driver) 116 * ifp The interface to send on 117 * dst The destination ethernet address (source address will be looked 118 * up using ifp) 119 * etype The ETHERTYPE_* value for the protocol that is being sent 120 * 121 * Returns: 122 * int see errno.h, 0 for success 123 */ 124 int 125 debugnet_ether_output(struct mbuf *m, struct ifnet *ifp, struct ether_addr dst, 126 u_short etype) 127 { 128 struct ether_header *eh; 129 130 if (((ifp->if_flags & (IFF_MONITOR | IFF_UP)) != IFF_UP) || 131 (ifp->if_drv_flags & IFF_DRV_RUNNING) != IFF_DRV_RUNNING) { 132 if_printf(ifp, "%s: interface isn't up\n", __func__); 133 m_freem(m); 134 return (ENETDOWN); 135 } 136 137 /* Fill in the ethernet header. */ 138 M_PREPEND(m, ETHER_HDR_LEN, M_NOWAIT); 139 if (m == NULL) { 140 printf("%s: out of mbufs\n", __func__); 141 return (ENOBUFS); 142 } 143 eh = mtod(m, struct ether_header *); 144 memcpy(eh->ether_shost, IF_LLADDR(ifp), ETHER_ADDR_LEN); 145 memcpy(eh->ether_dhost, dst.octet, ETHER_ADDR_LEN); 146 eh->ether_type = htons(etype); 147 return (ifp->if_debugnet_methods->dn_transmit(ifp, m)); 148 } 149 150 /* 151 * Unreliable transmission of an mbuf chain to the debugnet server 152 * Note: can't handle fragmentation; fails if the packet is larger than 153 * ifp->if_mtu after adding the UDP/IP headers 154 * 155 * Parameters: 156 * pcb The debugnet context block 157 * m mbuf chain 158 * 159 * Returns: 160 * int see errno.h, 0 for success 161 */ 162 static int 163 debugnet_udp_output(struct debugnet_pcb *pcb, struct mbuf *m) 164 { 165 struct udphdr *udp; 166 167 MPASS(pcb->dp_state >= DN_STATE_HAVE_GW_MAC); 168 169 M_PREPEND(m, sizeof(*udp), M_NOWAIT); 170 if (m == NULL) { 171 printf("%s: out of mbufs\n", __func__); 172 return (ENOBUFS); 173 } 174 175 udp = mtod(m, void *); 176 udp->uh_ulen = htons(m->m_pkthdr.len); 177 /* Use this src port so that the server can connect() the socket */ 178 udp->uh_sport = htons(pcb->dp_client_ack_port); 179 udp->uh_dport = htons(pcb->dp_server_port); 180 /* Computed later (protocol-dependent). */ 181 udp->uh_sum = 0; 182 183 return (debugnet_ip_output(pcb, m)); 184 } 185 186 /* 187 * Dummy free function for debugnet clusters. 188 */ 189 static void 190 debugnet_mbuf_free(struct mbuf *m __unused) 191 { 192 } 193 194 /* 195 * Construct and reliably send a debugnet packet. May fail from a resource 196 * shortage or extreme number of unacknowledged retransmissions. Wait for 197 * an acknowledgement before returning. Splits packets into chunks small 198 * enough to be sent without fragmentation (looks up the interface MTU) 199 * 200 * Parameters: 201 * type debugnet packet type (HERALD, FINISHED, ...) 202 * data data 203 * datalen data size (bytes) 204 * auxdata optional auxiliary information 205 * 206 * Returns: 207 * int see errno.h, 0 for success 208 */ 209 int 210 debugnet_send(struct debugnet_pcb *pcb, uint32_t type, const void *data, 211 uint32_t datalen, const struct debugnet_proto_aux *auxdata) 212 { 213 struct debugnet_msg_hdr *dn_msg_hdr; 214 struct mbuf *m, *m2; 215 uint64_t want_acks; 216 uint32_t i, pktlen, sent_so_far; 217 int retries, polls, error; 218 219 want_acks = 0; 220 pcb->dp_rcvd_acks = 0; 221 retries = 0; 222 223 retransmit: 224 /* Chunks can be too big to fit in packets. */ 225 for (i = sent_so_far = 0; sent_so_far < datalen || 226 (i == 0 && datalen == 0); i++) { 227 pktlen = datalen - sent_so_far; 228 229 /* Bound: the interface MTU (assume no IP options). */ 230 pktlen = min(pktlen, pcb->dp_ifp->if_mtu - 231 sizeof(struct udpiphdr) - sizeof(struct debugnet_msg_hdr)); 232 233 /* 234 * Check if it is retransmitting and this has been ACKed 235 * already. 236 */ 237 if ((pcb->dp_rcvd_acks & (1 << i)) != 0) { 238 sent_so_far += pktlen; 239 continue; 240 } 241 242 /* 243 * Get and fill a header mbuf, then chain data as an extended 244 * mbuf. 245 */ 246 m = m_gethdr(M_NOWAIT, MT_DATA); 247 if (m == NULL) { 248 printf("%s: Out of mbufs\n", __func__); 249 return (ENOBUFS); 250 } 251 m->m_len = sizeof(struct debugnet_msg_hdr); 252 m->m_pkthdr.len = sizeof(struct debugnet_msg_hdr); 253 MH_ALIGN(m, sizeof(struct debugnet_msg_hdr)); 254 dn_msg_hdr = mtod(m, struct debugnet_msg_hdr *); 255 dn_msg_hdr->mh_seqno = htonl(pcb->dp_seqno + i); 256 dn_msg_hdr->mh_type = htonl(type); 257 dn_msg_hdr->mh_len = htonl(pktlen); 258 259 if (auxdata != NULL) { 260 dn_msg_hdr->mh_offset = 261 htobe64(auxdata->dp_offset_start + sent_so_far); 262 dn_msg_hdr->mh_aux2 = htobe32(auxdata->dp_aux2); 263 } else { 264 dn_msg_hdr->mh_offset = htobe64(sent_so_far); 265 dn_msg_hdr->mh_aux2 = 0; 266 } 267 268 if (pktlen != 0) { 269 m2 = m_get(M_NOWAIT, MT_DATA); 270 if (m2 == NULL) { 271 m_freem(m); 272 printf("%s: Out of mbufs\n", __func__); 273 return (ENOBUFS); 274 } 275 MEXTADD(m2, __DECONST(char *, data) + sent_so_far, 276 pktlen, debugnet_mbuf_free, NULL, NULL, 0, 277 EXT_DISPOSABLE); 278 m2->m_len = pktlen; 279 280 m_cat(m, m2); 281 m->m_pkthdr.len += pktlen; 282 } 283 error = debugnet_udp_output(pcb, m); 284 if (error != 0) 285 return (error); 286 287 /* Note that we're waiting for this packet in the bitfield. */ 288 want_acks |= (1 << i); 289 sent_so_far += pktlen; 290 } 291 if (i >= DEBUGNET_MAX_IN_FLIGHT) 292 printf("Warning: Sent more than %d packets (%d). " 293 "Acknowledgements will fail unless the size of " 294 "rcvd_acks/want_acks is increased.\n", 295 DEBUGNET_MAX_IN_FLIGHT, i); 296 297 /* 298 * Wait for acks. A *real* window would speed things up considerably. 299 */ 300 polls = 0; 301 while (pcb->dp_rcvd_acks != want_acks) { 302 if (polls++ > debugnet_npolls) { 303 if (retries++ > debugnet_nretries) 304 return (ETIMEDOUT); 305 printf(". "); 306 goto retransmit; 307 } 308 debugnet_network_poll(pcb->dp_ifp); 309 DELAY(500); 310 } 311 pcb->dp_seqno += i; 312 return (0); 313 } 314 315 /* 316 * Network input primitives. 317 */ 318 319 static void 320 debugnet_handle_ack(struct debugnet_pcb *pcb, struct mbuf **mb, uint16_t sport) 321 { 322 const struct debugnet_ack *dn_ack; 323 struct mbuf *m; 324 uint32_t rcv_ackno; 325 326 m = *mb; 327 328 if (m->m_pkthdr.len < sizeof(*dn_ack)) { 329 DNETDEBUG("ignoring small ACK packet\n"); 330 return; 331 } 332 /* Get Ack. */ 333 if (m->m_len < sizeof(*dn_ack)) { 334 m = m_pullup(m, sizeof(*dn_ack)); 335 *mb = m; 336 if (m == NULL) { 337 DNETDEBUG("m_pullup failed\n"); 338 return; 339 } 340 } 341 dn_ack = mtod(m, const void *); 342 343 /* Debugnet processing. */ 344 /* 345 * Packet is meant for us. Extract the ack sequence number and the 346 * port number if necessary. 347 */ 348 rcv_ackno = ntohl(dn_ack->da_seqno); 349 if (pcb->dp_state < DN_STATE_GOT_HERALD_PORT) { 350 pcb->dp_server_port = sport; 351 pcb->dp_state = DN_STATE_GOT_HERALD_PORT; 352 } 353 if (rcv_ackno >= pcb->dp_seqno + DEBUGNET_MAX_IN_FLIGHT) 354 printf("%s: ACK %u too far in future!\n", __func__, rcv_ackno); 355 else if (rcv_ackno >= pcb->dp_seqno) { 356 /* We're interested in this ack. Record it. */ 357 pcb->dp_rcvd_acks |= 1 << (rcv_ackno - pcb->dp_seqno); 358 } 359 } 360 361 void 362 debugnet_handle_udp(struct debugnet_pcb *pcb, struct mbuf **mb) 363 { 364 const struct udphdr *udp; 365 struct mbuf *m; 366 uint16_t sport; 367 368 /* UDP processing. */ 369 370 m = *mb; 371 if (m->m_pkthdr.len < sizeof(*udp)) { 372 DNETDEBUG("ignoring small UDP packet\n"); 373 return; 374 } 375 376 /* Get UDP headers. */ 377 if (m->m_len < sizeof(*udp)) { 378 m = m_pullup(m, sizeof(*udp)); 379 *mb = m; 380 if (m == NULL) { 381 DNETDEBUG("m_pullup failed\n"); 382 return; 383 } 384 } 385 udp = mtod(m, const void *); 386 387 /* For now, the only UDP packets we expect to receive are acks. */ 388 if (ntohs(udp->uh_dport) != pcb->dp_client_ack_port) { 389 DNETDEBUG("not on the expected ACK port.\n"); 390 return; 391 } 392 sport = ntohs(udp->uh_sport); 393 394 m_adj(m, sizeof(*udp)); 395 debugnet_handle_ack(pcb, mb, sport); 396 } 397 398 /* 399 * Handler for incoming packets directly from the network adapter 400 * Identifies the packet type (IP or ARP) and passes it along to one of the 401 * helper functions debugnet_handle_ip or debugnet_handle_arp. 402 * 403 * It needs to partially replicate the behaviour of ether_input() and 404 * ether_demux(). 405 * 406 * Parameters: 407 * ifp the interface the packet came from 408 * m an mbuf containing the packet received 409 */ 410 static void 411 debugnet_pkt_in(struct ifnet *ifp, struct mbuf *m) 412 { 413 struct ifreq ifr; 414 struct ether_header *eh; 415 u_short etype; 416 417 /* Ethernet processing. */ 418 if ((m->m_flags & M_PKTHDR) == 0) { 419 DNETDEBUG_IF(ifp, "discard frame without packet header\n"); 420 goto done; 421 } 422 if (m->m_len < ETHER_HDR_LEN) { 423 DNETDEBUG_IF(ifp, 424 "discard frame without leading eth header (len %u pktlen %u)\n", 425 m->m_len, m->m_pkthdr.len); 426 goto done; 427 } 428 if ((m->m_flags & M_HASFCS) != 0) { 429 m_adj(m, -ETHER_CRC_LEN); 430 m->m_flags &= ~M_HASFCS; 431 } 432 eh = mtod(m, struct ether_header *); 433 etype = ntohs(eh->ether_type); 434 if ((m->m_flags & M_VLANTAG) != 0 || etype == ETHERTYPE_VLAN) { 435 DNETDEBUG_IF(ifp, "ignoring vlan packets\n"); 436 goto done; 437 } 438 if (if_gethwaddr(ifp, &ifr) != 0) { 439 DNETDEBUG_IF(ifp, "failed to get hw addr for interface\n"); 440 goto done; 441 } 442 if (memcmp(ifr.ifr_addr.sa_data, eh->ether_dhost, 443 ETHER_ADDR_LEN) != 0 && 444 (etype != ETHERTYPE_ARP || !ETHER_IS_BROADCAST(eh->ether_dhost))) { 445 DNETDEBUG_IF(ifp, 446 "discard frame with incorrect destination addr\n"); 447 goto done; 448 } 449 450 MPASS(g_debugnet_pcb_inuse); 451 452 /* Done ethernet processing. Strip off the ethernet header. */ 453 m_adj(m, ETHER_HDR_LEN); 454 switch (etype) { 455 case ETHERTYPE_ARP: 456 debugnet_handle_arp(&g_dnet_pcb, &m); 457 break; 458 case ETHERTYPE_IP: 459 debugnet_handle_ip(&g_dnet_pcb, &m); 460 break; 461 default: 462 DNETDEBUG_IF(ifp, "dropping unknown ethertype %hu\n", etype); 463 break; 464 } 465 done: 466 if (m != NULL) 467 m_freem(m); 468 } 469 470 /* 471 * Network polling primitive. 472 * 473 * Instead of assuming that most of the network stack is sane, we just poll the 474 * driver directly for packets. 475 */ 476 void 477 debugnet_network_poll(struct ifnet *ifp) 478 { 479 ifp->if_debugnet_methods->dn_poll(ifp, 1000); 480 } 481 482 /* 483 * Start of consumer API surface. 484 */ 485 void 486 debugnet_free(struct debugnet_pcb *pcb) 487 { 488 struct ifnet *ifp; 489 490 MPASS(g_debugnet_pcb_inuse); 491 MPASS(pcb == &g_dnet_pcb); 492 493 ifp = pcb->dp_ifp; 494 if (ifp != NULL) { 495 if (pcb->dp_drv_input != NULL) 496 ifp->if_input = pcb->dp_drv_input; 497 if (pcb->dp_event_started) 498 ifp->if_debugnet_methods->dn_event(ifp, DEBUGNET_END); 499 } 500 debugnet_mbuf_finish(); 501 502 g_debugnet_pcb_inuse = false; 503 memset(&g_dnet_pcb, 0xfd, sizeof(g_dnet_pcb)); 504 } 505 506 int 507 debugnet_connect(const struct debugnet_conn_params *dcp, 508 struct debugnet_pcb **pcb_out) 509 { 510 struct debugnet_pcb *pcb; 511 struct ifnet *ifp; 512 int error; 513 514 if (g_debugnet_pcb_inuse) { 515 printf("%s: Only one connection at a time.\n", __func__); 516 return (EBUSY); 517 } 518 519 pcb = &g_dnet_pcb; 520 *pcb = (struct debugnet_pcb) { 521 .dp_state = DN_STATE_INIT, 522 .dp_client = dcp->dc_client, 523 .dp_server = dcp->dc_server, 524 .dp_gateway = dcp->dc_gateway, 525 .dp_server_port = dcp->dc_herald_port, /* Initially */ 526 .dp_client_ack_port = dcp->dc_client_ack_port, 527 .dp_seqno = 1, 528 .dp_ifp = dcp->dc_ifp, 529 }; 530 531 /* Switch to the debugnet mbuf zones. */ 532 debugnet_mbuf_start(); 533 534 /* At least one needed parameter is missing; infer it. */ 535 if (pcb->dp_client == INADDR_ANY || pcb->dp_gateway == INADDR_ANY || 536 pcb->dp_ifp == NULL) { 537 struct sockaddr_in dest_sin, *gw_sin, *local_sin; 538 struct rtentry *dest_rt; 539 struct ifnet *rt_ifp; 540 541 memset(&dest_sin, 0, sizeof(dest_sin)); 542 dest_sin = (struct sockaddr_in) { 543 .sin_len = sizeof(dest_sin), 544 .sin_family = AF_INET, 545 .sin_addr.s_addr = pcb->dp_server, 546 }; 547 548 CURVNET_SET(vnet0); 549 dest_rt = rtalloc1((struct sockaddr *)&dest_sin, 0, 550 RTF_RNH_LOCKED); 551 CURVNET_RESTORE(); 552 553 if (dest_rt == NULL) { 554 db_printf("%s: Could not get route for that server.\n", 555 __func__); 556 error = ENOENT; 557 goto cleanup; 558 } 559 560 if (dest_rt->rt_gateway->sa_family == AF_INET) 561 gw_sin = (struct sockaddr_in *)dest_rt->rt_gateway; 562 else { 563 if (dest_rt->rt_gateway->sa_family == AF_LINK) 564 DNETDEBUG("Destination address is on link.\n"); 565 gw_sin = NULL; 566 } 567 568 MPASS(dest_rt->rt_ifa->ifa_addr->sa_family == AF_INET); 569 local_sin = (struct sockaddr_in *)dest_rt->rt_ifa->ifa_addr; 570 571 rt_ifp = dest_rt->rt_ifp; 572 573 if (pcb->dp_client == INADDR_ANY) 574 pcb->dp_client = local_sin->sin_addr.s_addr; 575 if (pcb->dp_gateway == INADDR_ANY && gw_sin != NULL) 576 pcb->dp_gateway = gw_sin->sin_addr.s_addr; 577 if (pcb->dp_ifp == NULL) 578 pcb->dp_ifp = rt_ifp; 579 580 RTFREE_LOCKED(dest_rt); 581 } 582 583 ifp = pcb->dp_ifp; 584 585 if (debugnet_debug > 0) { 586 char serbuf[INET_ADDRSTRLEN], clibuf[INET_ADDRSTRLEN], 587 gwbuf[INET_ADDRSTRLEN]; 588 inet_ntop(AF_INET, &pcb->dp_server, serbuf, sizeof(serbuf)); 589 inet_ntop(AF_INET, &pcb->dp_client, clibuf, sizeof(clibuf)); 590 if (pcb->dp_gateway != INADDR_ANY) 591 inet_ntop(AF_INET, &pcb->dp_gateway, gwbuf, sizeof(gwbuf)); 592 DNETDEBUG("Connecting to %s:%d%s%s from %s:%d on %s\n", 593 serbuf, pcb->dp_server_port, 594 (pcb->dp_gateway == INADDR_ANY) ? "" : " via ", 595 (pcb->dp_gateway == INADDR_ANY) ? "" : gwbuf, 596 clibuf, pcb->dp_client_ack_port, if_name(ifp)); 597 } 598 599 /* Validate iface is online and supported. */ 600 if (!DEBUGNET_SUPPORTED_NIC(ifp)) { 601 printf("%s: interface '%s' does not support debugnet\n", 602 __func__, if_name(ifp)); 603 error = ENODEV; 604 goto cleanup; 605 } 606 if ((if_getflags(ifp) & IFF_UP) == 0) { 607 printf("%s: interface '%s' link is down\n", __func__, 608 if_name(ifp)); 609 error = ENXIO; 610 goto cleanup; 611 } 612 613 ifp->if_debugnet_methods->dn_event(ifp, DEBUGNET_START); 614 pcb->dp_event_started = true; 615 616 /* 617 * We maintain the invariant that g_debugnet_pcb_inuse is always true 618 * while the debugnet ifp's if_input is overridden with 619 * debugnet_pkt_in. 620 */ 621 g_debugnet_pcb_inuse = true; 622 623 /* Make the card use *our* receive callback. */ 624 pcb->dp_drv_input = ifp->if_input; 625 ifp->if_input = debugnet_pkt_in; 626 627 printf("%s: searching for %s MAC...\n", __func__, 628 (dcp->dc_gateway == INADDR_ANY) ? "server" : "gateway"); 629 630 error = debugnet_arp_gw(pcb); 631 if (error != 0) { 632 printf("%s: failed to locate MAC address\n", __func__); 633 goto cleanup; 634 } 635 MPASS(pcb->dp_state == DN_STATE_HAVE_GW_MAC); 636 637 error = debugnet_send(pcb, DEBUGNET_HERALD, dcp->dc_herald_data, 638 dcp->dc_herald_datalen, NULL); 639 if (error != 0) { 640 printf("%s: failed to herald debugnet server\n", __func__); 641 goto cleanup; 642 } 643 644 *pcb_out = pcb; 645 return (0); 646 647 cleanup: 648 debugnet_free(pcb); 649 return (error); 650 } 651 652 /* 653 * Pre-allocated dump-time mbuf tracking. 654 * 655 * We just track the high water mark we've ever seen and allocate appropriately 656 * for that iface/mtu combo. 657 */ 658 static struct { 659 int nmbuf; 660 int ncl; 661 int clsize; 662 } dn_hwm; 663 static struct mtx dn_hwm_lk; 664 MTX_SYSINIT(debugnet_hwm_lock, &dn_hwm_lk, "Debugnet HWM lock", MTX_DEF); 665 666 static void 667 dn_maybe_reinit_mbufs(int nmbuf, int ncl, int clsize) 668 { 669 bool any; 670 671 any = false; 672 mtx_lock(&dn_hwm_lk); 673 674 if (nmbuf > dn_hwm.nmbuf) { 675 any = true; 676 dn_hwm.nmbuf = nmbuf; 677 } else 678 nmbuf = dn_hwm.nmbuf; 679 680 if (ncl > dn_hwm.ncl) { 681 any = true; 682 dn_hwm.ncl = ncl; 683 } else 684 ncl = dn_hwm.ncl; 685 686 if (clsize > dn_hwm.clsize) { 687 any = true; 688 dn_hwm.clsize = clsize; 689 } else 690 clsize = dn_hwm.clsize; 691 692 mtx_unlock(&dn_hwm_lk); 693 694 if (any) 695 debugnet_mbuf_reinit(nmbuf, ncl, clsize); 696 } 697 698 void 699 debugnet_any_ifnet_update(struct ifnet *ifp) 700 { 701 int clsize, nmbuf, ncl, nrxr; 702 703 if (!DEBUGNET_SUPPORTED_NIC(ifp)) 704 return; 705 706 ifp->if_debugnet_methods->dn_init(ifp, &nrxr, &ncl, &clsize); 707 KASSERT(nrxr > 0, ("invalid receive ring count %d", nrxr)); 708 709 /* 710 * We need two headers per message on the transmit side. Multiply by 711 * four to give us some breathing room. 712 */ 713 nmbuf = ncl * (4 + nrxr); 714 ncl *= nrxr; 715 716 dn_maybe_reinit_mbufs(nmbuf, ncl, clsize); 717 } 718 719 /* 720 * Unfortunately, the ifnet_arrival_event eventhandler hook is mostly useless 721 * for us because drivers tend to if_attach before invoking DEBUGNET_SET(). 722 * 723 * On the other hand, hooking DEBUGNET_SET() itself may still be too early, 724 * because the driver is still in attach. Since we cannot use down interfaces, 725 * maybe hooking ifnet_event:IFNET_EVENT_UP is sufficient? ... Nope, at least 726 * with vtnet and dhcpclient that event just never occurs. 727 * 728 * So that's how I've landed on the lower level ifnet_link_event. 729 */ 730 731 static void 732 dn_ifnet_event(void *arg __unused, struct ifnet *ifp, int link_state) 733 { 734 if (link_state == LINK_STATE_UP) 735 debugnet_any_ifnet_update(ifp); 736 } 737 738 static eventhandler_tag dn_attach_cookie; 739 static void 740 dn_evh_init(void *ctx __unused) 741 { 742 dn_attach_cookie = EVENTHANDLER_REGISTER(ifnet_link_event, 743 dn_ifnet_event, NULL, EVENTHANDLER_PRI_ANY); 744 } 745 SYSINIT(dn_evh_init, SI_SUB_EVENTHANDLER + 1, SI_ORDER_ANY, dn_evh_init, NULL); 746 747 /* 748 * DDB parsing helpers for debugnet(4) consumers. 749 */ 750 #ifdef DDB 751 struct my_inet_opt { 752 bool has_opt; 753 const char *printname; 754 in_addr_t *result; 755 }; 756 757 static int 758 dn_parse_optarg_ipv4(struct my_inet_opt *opt) 759 { 760 in_addr_t tmp; 761 unsigned octet; 762 int t; 763 764 tmp = 0; 765 for (octet = 0; octet < 4; octet++) { 766 t = db_read_token_flags(DRT_WSPACE | DRT_DECIMAL); 767 if (t != tNUMBER) { 768 db_printf("%s:%s: octet %u expected number; found %d\n", 769 __func__, opt->printname, octet, t); 770 return (EINVAL); 771 } 772 /* 773 * db_lex lexes '-' distinctly from the number itself, but 774 * let's document that invariant. 775 */ 776 MPASS(db_tok_number >= 0); 777 778 if (db_tok_number > UINT8_MAX) { 779 db_printf("%s:%s: octet %u out of range: %jd\n", __func__, 780 opt->printname, octet, (intmax_t)db_tok_number); 781 return (EDOM); 782 } 783 784 /* Constructed host-endian and converted to network later. */ 785 tmp = (tmp << 8) | db_tok_number; 786 787 if (octet < 3) { 788 t = db_read_token_flags(DRT_WSPACE); 789 if (t != tDOT) { 790 db_printf("%s:%s: octet %u expected '.'; found" 791 " %d\n", __func__, opt->printname, octet, 792 t); 793 return (EINVAL); 794 } 795 } 796 } 797 798 *opt->result = htonl(tmp); 799 opt->has_opt = true; 800 return (0); 801 } 802 803 int 804 debugnet_parse_ddb_cmd(const char *cmd, struct debugnet_ddb_config *result) 805 { 806 struct ifnet *ifp; 807 int t, error; 808 bool want_ifp; 809 char ch; 810 811 struct my_inet_opt opt_client = { 812 .printname = "client", 813 .result = &result->dd_client, 814 }, 815 opt_server = { 816 .printname = "server", 817 .result = &result->dd_server, 818 }, 819 opt_gateway = { 820 .printname = "gateway", 821 .result = &result->dd_gateway, 822 }, 823 *cur_inet_opt; 824 825 ifp = NULL; 826 memset(result, 0, sizeof(*result)); 827 828 /* 829 * command [space] [-] [opt] [[space] [optarg]] ... 830 * 831 * db_command has already lexed 'command' for us. 832 */ 833 t = db_read_token_flags(DRT_WSPACE); 834 if (t == tWSPACE) 835 t = db_read_token_flags(DRT_WSPACE); 836 837 while (t != tEOL) { 838 if (t != tMINUS) { 839 db_printf("%s: Bad syntax; expected '-', got %d\n", 840 cmd, t); 841 goto usage; 842 } 843 844 t = db_read_token_flags(DRT_WSPACE); 845 if (t != tIDENT) { 846 db_printf("%s: Bad syntax; expected tIDENT, got %d\n", 847 cmd, t); 848 goto usage; 849 } 850 851 if (strlen(db_tok_string) > 1) { 852 db_printf("%s: Bad syntax; expected single option " 853 "flag, got '%s'\n", cmd, db_tok_string); 854 goto usage; 855 } 856 857 want_ifp = false; 858 cur_inet_opt = NULL; 859 switch ((ch = db_tok_string[0])) { 860 default: 861 DNETDEBUG("Unexpected: '%c'\n", ch); 862 /* FALLTHROUGH */ 863 case 'h': 864 goto usage; 865 case 'c': 866 cur_inet_opt = &opt_client; 867 break; 868 case 'g': 869 cur_inet_opt = &opt_gateway; 870 break; 871 case 's': 872 cur_inet_opt = &opt_server; 873 break; 874 case 'i': 875 want_ifp = true; 876 break; 877 } 878 879 t = db_read_token_flags(DRT_WSPACE); 880 if (t != tWSPACE) { 881 db_printf("%s: Bad syntax; expected space after " 882 "flag %c, got %d\n", cmd, ch, t); 883 goto usage; 884 } 885 886 if (want_ifp) { 887 t = db_read_token_flags(DRT_WSPACE); 888 if (t != tIDENT) { 889 db_printf("%s: Expected interface but got %d\n", 890 cmd, t); 891 goto usage; 892 } 893 894 CURVNET_SET(vnet0); 895 /* 896 * We *don't* take a ref here because the only current 897 * consumer, db_netdump_cmd, does not need it. It 898 * (somewhat redundantly) extracts the if_name(), 899 * re-lookups the ifp, and takes its own reference. 900 */ 901 ifp = ifunit(db_tok_string); 902 CURVNET_RESTORE(); 903 if (ifp == NULL) { 904 db_printf("Could not locate interface %s\n", 905 db_tok_string); 906 goto cleanup; 907 } 908 } else { 909 MPASS(cur_inet_opt != NULL); 910 /* Assume IPv4 for now. */ 911 error = dn_parse_optarg_ipv4(cur_inet_opt); 912 if (error != 0) 913 goto cleanup; 914 } 915 916 /* Skip (mandatory) whitespace after option, if not EOL. */ 917 t = db_read_token_flags(DRT_WSPACE); 918 if (t == tEOL) 919 break; 920 if (t != tWSPACE) { 921 db_printf("%s: Bad syntax; expected space after " 922 "flag %c option; got %d\n", cmd, ch, t); 923 goto usage; 924 } 925 t = db_read_token_flags(DRT_WSPACE); 926 } 927 928 if (!opt_server.has_opt) { 929 db_printf("%s: need a destination server address\n", cmd); 930 goto usage; 931 } 932 933 result->dd_has_client = opt_client.has_opt; 934 result->dd_has_gateway = opt_gateway.has_opt; 935 result->dd_ifp = ifp; 936 937 /* We parsed the full line to tEOL already, or bailed with an error. */ 938 return (0); 939 940 usage: 941 db_printf("Usage: %s -s <server> [-g <gateway> -c <localip> " 942 "-i <interface>]\n", cmd); 943 error = EINVAL; 944 /* FALLTHROUGH */ 945 cleanup: 946 db_skip_to_eol(); 947 return (error); 948 } 949 #endif /* DDB */ 950