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