1 /*-
2  * Copyright (c) 2005-2014 Sandvine Incorporated. All rights reserved.
3  * Copyright (c) 2000 Darrell Anderson
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25  * SUCH DAMAGE.
26  */
27 
28 /*
29  * netdump_client.c
30  * FreeBSD subsystem supporting netdump network dumps.
31  * A dedicated server must be running to accept client dumps.
32  */
33 
34 #include <sys/cdefs.h>
35 #include "opt_ddb.h"
36 
37 #include <sys/param.h>
38 #include <sys/conf.h>
39 #include <sys/disk.h>
40 #include <sys/endian.h>
41 #include <sys/eventhandler.h>
42 #include <sys/jail.h>
43 #include <sys/kernel.h>
44 #include <sys/kerneldump.h>
45 #include <sys/mbuf.h>
46 #include <sys/module.h>
47 #include <sys/priv.h>
48 #include <sys/proc.h>
49 #include <sys/protosw.h>
50 #include <sys/socket.h>
51 #include <sys/sysctl.h>
52 #include <sys/syslog.h>
53 #include <sys/systm.h>
54 
55 #ifdef DDB
56 #include <ddb/ddb.h>
57 #include <ddb/db_lex.h>
58 #endif
59 
60 #include <net/ethernet.h>
61 #include <net/if.h>
62 #include <net/if_arp.h>
63 #include <net/if_dl.h>
64 #include <net/if_types.h>
65 #include <net/if_var.h>
66 #include <net/if_private.h>
67 #include <net/debugnet.h>
68 
69 #include <netinet/in.h>
70 #include <netinet/in_systm.h>
71 #include <netinet/in_var.h>
72 #include <netinet/ip.h>
73 #include <netinet/ip_var.h>
74 #include <netinet/ip_options.h>
75 #include <netinet/udp.h>
76 #include <netinet/udp_var.h>
77 #include <netinet/netdump/netdump.h>
78 
79 #include <machine/in_cksum.h>
80 #include <machine/pcb.h>
81 
82 #define	NETDDEBUGV(f, ...) do {						\
83 	if (nd_debug > 1)						\
84 		printf(("%s: " f), __func__, ## __VA_ARGS__);		\
85 } while (0)
86 
87 static void	 netdump_cleanup(void);
88 static int	 netdump_configure(struct diocskerneldump_arg *,
89 		    struct thread *);
90 static int	 netdump_dumper(void *priv __unused, void *virtual,
91 		    off_t offset, size_t length);
92 static bool	 netdump_enabled(void);
93 static int	 netdump_enabled_sysctl(SYSCTL_HANDLER_ARGS);
94 static int	 netdump_ioctl(struct cdev *dev __unused, u_long cmd,
95 		    caddr_t addr, int flags __unused, struct thread *td);
96 static int	 netdump_modevent(module_t mod, int type, void *priv);
97 static int	 netdump_start(struct dumperinfo *di, void *key,
98 		    uint32_t keysize);
99 static void	 netdump_unconfigure(void);
100 
101 /* Must be at least as big as the chunks dumpsys() gives us. */
102 static unsigned char nd_buf[MAXDUMPPGS * PAGE_SIZE];
103 static int dump_failed;
104 
105 /* Configuration parameters. */
106 static struct {
107 	char		 ndc_iface[IFNAMSIZ];
108 	union kd_ip	 ndc_server;
109 	union kd_ip	 ndc_client;
110 	union kd_ip	 ndc_gateway;
111 	uint8_t		 ndc_af;
112 	/* Runtime State */
113 	struct debugnet_pcb *nd_pcb;
114 	off_t		 nd_tx_off;
115 	size_t		 nd_buf_len;
116 } nd_conf;
117 #define	nd_server	nd_conf.ndc_server.in4
118 #define	nd_client	nd_conf.ndc_client.in4
119 #define	nd_gateway	nd_conf.ndc_gateway.in4
120 
121 /* General dynamic settings. */
122 static struct sx nd_conf_lk;
123 SX_SYSINIT(nd_conf, &nd_conf_lk, "netdump configuration lock");
124 #define NETDUMP_WLOCK()			sx_xlock(&nd_conf_lk)
125 #define NETDUMP_WUNLOCK()		sx_xunlock(&nd_conf_lk)
126 #define NETDUMP_RLOCK()			sx_slock(&nd_conf_lk)
127 #define NETDUMP_RUNLOCK()		sx_sunlock(&nd_conf_lk)
128 #define NETDUMP_ASSERT_WLOCKED()	sx_assert(&nd_conf_lk, SA_XLOCKED)
129 #define NETDUMP_ASSERT_LOCKED()		sx_assert(&nd_conf_lk, SA_LOCKED)
130 static struct ifnet *nd_ifp;
131 static eventhandler_tag nd_detach_cookie;
132 
133 FEATURE(netdump, "Netdump client support");
134 
135 static SYSCTL_NODE(_net, OID_AUTO, netdump, CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
136     "netdump parameters");
137 
138 static int nd_debug;
139 SYSCTL_INT(_net_netdump, OID_AUTO, debug, CTLFLAG_RWTUN,
140     &nd_debug, 0,
141     "Debug message verbosity");
142 SYSCTL_PROC(_net_netdump, OID_AUTO, enabled,
143     CTLFLAG_RD | CTLTYPE_INT | CTLFLAG_MPSAFE, NULL, 0,
144     netdump_enabled_sysctl, "I",
145     "netdump configuration status");
146 static char nd_path[MAXPATHLEN];
147 SYSCTL_STRING(_net_netdump, OID_AUTO, path, CTLFLAG_RW,
148     nd_path, sizeof(nd_path),
149     "Server path for output files");
150 /*
151  * The following three variables were moved to debugnet(4), but these knobs
152  * were retained as aliases.
153  */
154 SYSCTL_INT(_net_netdump, OID_AUTO, polls, CTLFLAG_RWTUN,
155     &debugnet_npolls, 0,
156     "Number of times to poll before assuming packet loss (0.5ms per poll)");
157 SYSCTL_INT(_net_netdump, OID_AUTO, retries, CTLFLAG_RWTUN,
158     &debugnet_nretries, 0,
159     "Number of retransmit attempts before giving up");
160 SYSCTL_INT(_net_netdump, OID_AUTO, arp_retries, CTLFLAG_RWTUN,
161     &debugnet_arp_nretries, 0,
162     "Number of ARP attempts before giving up");
163 
164 static bool nd_is_enabled;
165 static bool
166 netdump_enabled(void)
167 {
168 
169 	NETDUMP_ASSERT_LOCKED();
170 	return (nd_is_enabled);
171 }
172 
173 static void
174 netdump_set_enabled(bool status)
175 {
176 
177 	NETDUMP_ASSERT_LOCKED();
178 	nd_is_enabled = status;
179 }
180 
181 static int
182 netdump_enabled_sysctl(SYSCTL_HANDLER_ARGS)
183 {
184 	int en, error;
185 
186 	NETDUMP_RLOCK();
187 	en = netdump_enabled();
188 	NETDUMP_RUNLOCK();
189 
190 	error = SYSCTL_OUT(req, &en, sizeof(en));
191 	if (error != 0 || req->newptr == NULL)
192 		return (error);
193 	return (EPERM);
194 }
195 
196 /*-
197  * Dumping specific primitives.
198  */
199 
200 /*
201  * Flush any buffered vmcore data.
202  */
203 static int
204 netdump_flush_buf(void)
205 {
206 	int error;
207 
208 	error = 0;
209 	if (nd_conf.nd_buf_len != 0) {
210 		struct debugnet_proto_aux auxdata = {
211 			.dp_offset_start = nd_conf.nd_tx_off,
212 		};
213 		error = debugnet_send(nd_conf.nd_pcb, DEBUGNET_DATA, nd_buf,
214 		    nd_conf.nd_buf_len, &auxdata);
215 		if (error == 0)
216 			nd_conf.nd_buf_len = 0;
217 	}
218 	return (error);
219 }
220 
221 /*
222  * Callback from dumpsys() to dump a chunk of memory.
223  * Copies it out to our static buffer then sends it across the network.
224  * Detects the initial KDH and makes sure it is given a special packet type.
225  *
226  * Parameters:
227  *	priv	 Unused. Optional private pointer.
228  *	virtual  Virtual address (where to read the data from)
229  *	offset	 Offset from start of core file
230  *	length	 Data length
231  *
232  * Return value:
233  *	0 on success
234  *	errno on error
235  */
236 static int
237 netdump_dumper(void *priv __unused, void *virtual, off_t offset, size_t length)
238 {
239 	int error;
240 
241 	NETDDEBUGV("netdump_dumper(NULL, %p, NULL, %ju, %zu)\n",
242 	    virtual, (uintmax_t)offset, length);
243 
244 	if (virtual == NULL) {
245 		error = netdump_flush_buf();
246 		if (error != 0)
247 			dump_failed = 1;
248 
249 		if (dump_failed != 0)
250 			printf("failed to dump the kernel core\n");
251 		else if (
252 		    debugnet_sendempty(nd_conf.nd_pcb, DEBUGNET_FINISHED) != 0)
253 			printf("failed to close the transaction\n");
254 		else
255 			printf("\nnetdump finished.\n");
256 		netdump_cleanup();
257 		return (0);
258 	}
259 	if (length > sizeof(nd_buf)) {
260 		netdump_cleanup();
261 		return (ENOSPC);
262 	}
263 
264 	if (nd_conf.nd_buf_len + length > sizeof(nd_buf) ||
265 	    (nd_conf.nd_buf_len != 0 && nd_conf.nd_tx_off +
266 	    nd_conf.nd_buf_len != offset)) {
267 		error = netdump_flush_buf();
268 		if (error != 0) {
269 			dump_failed = 1;
270 			netdump_cleanup();
271 			return (error);
272 		}
273 		nd_conf.nd_tx_off = offset;
274 	}
275 
276 	memmove(nd_buf + nd_conf.nd_buf_len, virtual, length);
277 	nd_conf.nd_buf_len += length;
278 
279 	return (0);
280 }
281 
282 /*
283  * Perform any initialization needed prior to transmitting the kernel core.
284  */
285 static int
286 netdump_start(struct dumperinfo *di, void *key, uint32_t keysize)
287 {
288 	struct debugnet_conn_params dcp;
289 	struct debugnet_pcb *pcb;
290 	char buf[INET_ADDRSTRLEN];
291 	int error;
292 
293 	error = 0;
294 
295 	/* Check if the dumping is allowed to continue. */
296 	if (!netdump_enabled())
297 		return (EINVAL);
298 
299 	if (!KERNEL_PANICKED()) {
300 		printf(
301 		    "netdump_start: netdump may only be used after a panic\n");
302 		return (EINVAL);
303 	}
304 
305 	memset(&dcp, 0, sizeof(dcp));
306 
307 	if (nd_server.s_addr == INADDR_ANY) {
308 		printf("netdump_start: can't netdump; no server IP given\n");
309 		return (EINVAL);
310 	}
311 
312 	/* We start dumping at offset 0. */
313 	di->dumpoff = 0;
314 
315 	dcp.dc_ifp = nd_ifp;
316 
317 	dcp.dc_client = nd_client.s_addr;
318 	dcp.dc_server = nd_server.s_addr;
319 	dcp.dc_gateway = nd_gateway.s_addr;
320 
321 	dcp.dc_herald_port = NETDUMP_PORT;
322 	dcp.dc_client_port = NETDUMP_ACKPORT;
323 
324 	dcp.dc_herald_data = nd_path;
325 	dcp.dc_herald_datalen = (nd_path[0] == 0) ? 0 : strlen(nd_path) + 1;
326 
327 	error = debugnet_connect(&dcp, &pcb);
328 	if (error != 0) {
329 		printf("failed to contact netdump server\n");
330 		/* Squash debugnet to something the dumper code understands. */
331 		return (EINVAL);
332 	}
333 
334 	printf("netdumping to %s (%6D)\n", inet_ntoa_r(nd_server, buf),
335 	    debugnet_get_gw_mac(pcb), ":");
336 	nd_conf.nd_pcb = pcb;
337 
338 	/* Send the key before the dump so a partial dump is still usable. */
339 	if (keysize > 0) {
340 		if (keysize > sizeof(nd_buf)) {
341 			printf("crypto key is too large (%u)\n", keysize);
342 			error = EINVAL;
343 			goto out;
344 		}
345 		memcpy(nd_buf, key, keysize);
346 		error = debugnet_send(pcb, NETDUMP_EKCD_KEY, nd_buf, keysize,
347 		    NULL);
348 		if (error != 0) {
349 			printf("error %d sending crypto key\n", error);
350 			goto out;
351 		}
352 	}
353 
354 out:
355 	if (error != 0) {
356 		/* As above, squash errors. */
357 		error = EINVAL;
358 		netdump_cleanup();
359 	}
360 	return (error);
361 }
362 
363 static int
364 netdump_write_headers(struct dumperinfo *di, struct kerneldumpheader *kdh)
365 {
366 	int error;
367 
368 	error = netdump_flush_buf();
369 	if (error != 0)
370 		goto out;
371 	memcpy(nd_buf, kdh, sizeof(*kdh));
372 	error = debugnet_send(nd_conf.nd_pcb, NETDUMP_KDH, nd_buf,
373 	    sizeof(*kdh), NULL);
374 out:
375 	if (error != 0)
376 		netdump_cleanup();
377 	return (error);
378 }
379 
380 /*
381  * Cleanup routine for a possibly failed netdump.
382  */
383 static void
384 netdump_cleanup(void)
385 {
386 	if (nd_conf.nd_pcb != NULL) {
387 		debugnet_free(nd_conf.nd_pcb);
388 		nd_conf.nd_pcb = NULL;
389 	}
390 }
391 
392 /*-
393  * KLD specific code.
394  */
395 
396 static struct cdevsw netdump_cdevsw = {
397 	.d_version =	D_VERSION,
398 	.d_ioctl =	netdump_ioctl,
399 	.d_name =	"netdump",
400 };
401 
402 static struct cdev *netdump_cdev;
403 
404 static void
405 netdump_unconfigure(void)
406 {
407 	struct diocskerneldump_arg kda;
408 
409 	NETDUMP_ASSERT_WLOCKED();
410 	KASSERT(netdump_enabled(), ("%s: not enabled", __func__));
411 
412 	bzero(&kda, sizeof(kda));
413 	kda.kda_index = KDA_REMOVE_DEV;
414 	(void)dumper_remove(nd_conf.ndc_iface, &kda);
415 
416 	if (nd_ifp != NULL)
417 		if_rele(nd_ifp);
418 	nd_ifp = NULL;
419 	netdump_set_enabled(false);
420 
421 	log(LOG_WARNING, "netdump: Lost configured interface %s\n",
422 	    nd_conf.ndc_iface);
423 
424 	bzero(&nd_conf, sizeof(nd_conf));
425 }
426 
427 static void
428 netdump_ifdetach(void *arg __unused, struct ifnet *ifp)
429 {
430 
431 	NETDUMP_WLOCK();
432 	if (ifp == nd_ifp)
433 		netdump_unconfigure();
434 	NETDUMP_WUNLOCK();
435 }
436 
437 /*
438  * td of NULL is a sentinel value that indicates a kernel caller (ddb(4) or
439  * modload-based tunable parameters).
440  */
441 static int
442 netdump_configure(struct diocskerneldump_arg *conf, struct thread *td)
443 {
444 	struct ifnet *ifp;
445 
446 	NETDUMP_ASSERT_WLOCKED();
447 
448 	if (conf->kda_iface[0] != 0) {
449 		if (td != NULL && !IS_DEFAULT_VNET(TD_TO_VNET(td)))
450 			return (EINVAL);
451 		CURVNET_SET(vnet0);
452 		ifp = ifunit_ref(conf->kda_iface);
453 		CURVNET_RESTORE();
454 		if (ifp == NULL)
455 			return (ENODEV);
456 		if (!DEBUGNET_SUPPORTED_NIC(ifp)) {
457 			if_rele(ifp);
458 			return (ENODEV);
459 		}
460 	} else
461 		ifp = NULL;
462 
463 	if (nd_ifp != NULL)
464 		if_rele(nd_ifp);
465 	nd_ifp = ifp;
466 	netdump_set_enabled(true);
467 
468 #define COPY_SIZED(elm) do {	\
469 	_Static_assert(sizeof(nd_conf.ndc_ ## elm) ==			\
470 	    sizeof(conf->kda_ ## elm), "elm " __XSTRING(elm) " mismatch"); \
471 	memcpy(&nd_conf.ndc_ ## elm, &conf->kda_ ## elm,		\
472 	    sizeof(nd_conf.ndc_ ## elm));				\
473 } while (0)
474 	COPY_SIZED(iface);
475 	COPY_SIZED(server);
476 	COPY_SIZED(client);
477 	COPY_SIZED(gateway);
478 	COPY_SIZED(af);
479 #undef COPY_SIZED
480 
481 	return (0);
482 }
483 
484 /*
485  * ioctl(2) handler for the netdump device. This is currently only used to
486  * register netdump as a dump device.
487  *
488  * Parameters:
489  *     dev, Unused.
490  *     cmd, The ioctl to be handled.
491  *     addr, The parameter for the ioctl.
492  *     flags, Unused.
493  *     td, The thread invoking this ioctl.
494  *
495  * Returns:
496  *     0 on success, and an errno value on failure.
497  */
498 static int
499 netdump_ioctl(struct cdev *dev __unused, u_long cmd, caddr_t addr,
500     int flags __unused, struct thread *td)
501 {
502 	struct diocskerneldump_arg *conf;
503 	struct dumperinfo dumper;
504 	uint8_t *encryptedkey;
505 	int error;
506 
507 	conf = NULL;
508 	error = 0;
509 	NETDUMP_WLOCK();
510 
511 	switch (cmd) {
512 	case DIOCGKERNELDUMP:
513 		conf = (void *)addr;
514 		/*
515 		 * For now, index is ignored; netdump doesn't support multiple
516 		 * configurations (yet).
517 		 */
518 		if (!netdump_enabled()) {
519 			error = ENXIO;
520 			conf = NULL;
521 			break;
522 		}
523 
524 		if (nd_ifp != NULL)
525 			strlcpy(conf->kda_iface, nd_ifp->if_xname,
526 			    sizeof(conf->kda_iface));
527 		memcpy(&conf->kda_server, &nd_server, sizeof(nd_server));
528 		memcpy(&conf->kda_client, &nd_client, sizeof(nd_client));
529 		memcpy(&conf->kda_gateway, &nd_gateway, sizeof(nd_gateway));
530 		conf->kda_af = nd_conf.ndc_af;
531 		conf = NULL;
532 		break;
533 	case DIOCSKERNELDUMP:
534 		encryptedkey = NULL;
535 		conf = (void *)addr;
536 
537 		/* Netdump only supports IP4 at this time. */
538 		if (conf->kda_af != AF_INET) {
539 			error = EPROTONOSUPPORT;
540 			break;
541 		}
542 
543 		conf->kda_iface[sizeof(conf->kda_iface) - 1] = '\0';
544 		if (conf->kda_index == KDA_REMOVE ||
545 		    conf->kda_index == KDA_REMOVE_DEV ||
546 		    conf->kda_index == KDA_REMOVE_ALL) {
547 			if (netdump_enabled())
548 				netdump_unconfigure();
549 			if (conf->kda_index == KDA_REMOVE_ALL)
550 				error = dumper_remove(NULL, conf);
551 			break;
552 		}
553 
554 		error = netdump_configure(conf, td);
555 		if (error != 0)
556 			break;
557 
558 		if (conf->kda_encryption != KERNELDUMP_ENC_NONE) {
559 			if (conf->kda_encryptedkeysize <= 0 ||
560 			    conf->kda_encryptedkeysize >
561 			    KERNELDUMP_ENCKEY_MAX_SIZE) {
562 				error = EINVAL;
563 				break;
564 			}
565 			encryptedkey = malloc(conf->kda_encryptedkeysize,
566 			    M_TEMP, M_WAITOK);
567 			error = copyin(conf->kda_encryptedkey, encryptedkey,
568 			    conf->kda_encryptedkeysize);
569 			if (error != 0) {
570 				free(encryptedkey, M_TEMP);
571 				break;
572 			}
573 
574 			conf->kda_encryptedkey = encryptedkey;
575 		}
576 
577 		memset(&dumper, 0, sizeof(dumper));
578 		dumper.dumper_start = netdump_start;
579 		dumper.dumper_hdr = netdump_write_headers;
580 		dumper.dumper = netdump_dumper;
581 		dumper.priv = NULL;
582 		dumper.blocksize = NETDUMP_DATASIZE;
583 		dumper.maxiosize = MAXDUMPPGS * PAGE_SIZE;
584 		dumper.mediaoffset = 0;
585 		dumper.mediasize = 0;
586 
587 		error = dumper_insert(&dumper, conf->kda_iface, conf);
588 		zfree(encryptedkey, M_TEMP);
589 		if (error != 0)
590 			netdump_unconfigure();
591 		break;
592 	default:
593 		error = ENOTTY;
594 		break;
595 	}
596 	if (conf != NULL)
597 		explicit_bzero(conf, sizeof(*conf));
598 	NETDUMP_WUNLOCK();
599 	return (error);
600 }
601 
602 /*
603  * Called upon system init or kld load.  Initializes the netdump parameters to
604  * sane defaults (locates the first available NIC and uses the first IPv4 IP on
605  * that card as the client IP).  Leaves the server IP unconfigured.
606  *
607  * Parameters:
608  *	mod, Unused.
609  *	what, The module event type.
610  *	priv, Unused.
611  *
612  * Returns:
613  *	int, An errno value if an error occurred, 0 otherwise.
614  */
615 static int
616 netdump_modevent(module_t mod __unused, int what, void *priv __unused)
617 {
618 	struct diocskerneldump_arg conf;
619 	char *arg;
620 	int error;
621 
622 	error = 0;
623 	switch (what) {
624 	case MOD_LOAD:
625 		error = make_dev_p(MAKEDEV_WAITOK, &netdump_cdev,
626 		    &netdump_cdevsw, 0, UID_ROOT, GID_WHEEL, 0600, "netdump");
627 		if (error != 0)
628 			return (error);
629 
630 		nd_detach_cookie = EVENTHANDLER_REGISTER(ifnet_departure_event,
631 		    netdump_ifdetach, NULL, EVENTHANDLER_PRI_ANY);
632 
633 		if ((arg = kern_getenv("net.dump.iface")) != NULL) {
634 			strlcpy(conf.kda_iface, arg, sizeof(conf.kda_iface));
635 			freeenv(arg);
636 
637 			if ((arg = kern_getenv("net.dump.server")) != NULL) {
638 				inet_aton(arg, &conf.kda_server.in4);
639 				freeenv(arg);
640 			}
641 			if ((arg = kern_getenv("net.dump.client")) != NULL) {
642 				inet_aton(arg, &conf.kda_client.in4);
643 				freeenv(arg);
644 			}
645 			if ((arg = kern_getenv("net.dump.gateway")) != NULL) {
646 				inet_aton(arg, &conf.kda_gateway.in4);
647 				freeenv(arg);
648 			}
649 			conf.kda_af = AF_INET;
650 
651 			/* Ignore errors; we print a message to the console. */
652 			NETDUMP_WLOCK();
653 			(void)netdump_configure(&conf, NULL);
654 			NETDUMP_WUNLOCK();
655 		}
656 		break;
657 	case MOD_UNLOAD:
658 		NETDUMP_WLOCK();
659 		if (netdump_enabled()) {
660 			printf("netdump: disabling dump device for unload\n");
661 			netdump_unconfigure();
662 		}
663 		NETDUMP_WUNLOCK();
664 		destroy_dev(netdump_cdev);
665 		EVENTHANDLER_DEREGISTER(ifnet_departure_event,
666 		    nd_detach_cookie);
667 		break;
668 	default:
669 		error = EOPNOTSUPP;
670 		break;
671 	}
672 	return (error);
673 }
674 
675 static moduledata_t netdump_mod = {
676 	"netdump",
677 	netdump_modevent,
678 	NULL,
679 };
680 
681 MODULE_VERSION(netdump, 1);
682 DECLARE_MODULE(netdump, netdump_mod, SI_SUB_PSEUDO, SI_ORDER_ANY);
683 
684 #ifdef DDB
685 /*
686  * Usage: netdump -s <server> [-g <gateway] -c <localip> -i <interface>
687  *
688  * Order is not significant.
689  *
690  * Currently, this command does not support configuring encryption or
691  * compression.
692  */
693 DB_COMMAND_FLAGS(netdump, db_netdump_cmd, CS_OWN)
694 {
695 	static struct diocskerneldump_arg conf;
696 	static char blockbuf[NETDUMP_DATASIZE];
697 	static union {
698 		struct dumperinfo di;
699 		/* For valid di_devname. */
700 		char di_buf[sizeof(struct dumperinfo) + 1];
701 	} u;
702 
703 	struct debugnet_ddb_config params;
704 	int error;
705 
706 	error = debugnet_parse_ddb_cmd("netdump", &params);
707 	if (error != 0) {
708 		db_printf("Error configuring netdump: %d\n", error);
709 		return;
710 	}
711 
712 	/* Translate to a netdump dumper config. */
713 	memset(&conf, 0, sizeof(conf));
714 
715 	if (params.dd_ifp != NULL)
716 		strlcpy(conf.kda_iface, if_name(params.dd_ifp),
717 		    sizeof(conf.kda_iface));
718 
719 	conf.kda_af = AF_INET;
720 	conf.kda_server.in4 = (struct in_addr) { params.dd_server };
721 	if (params.dd_has_client)
722 		conf.kda_client.in4 = (struct in_addr) { params.dd_client };
723 	else
724 		conf.kda_client.in4 = (struct in_addr) { INADDR_ANY };
725 	if (params.dd_has_gateway)
726 		conf.kda_gateway.in4 = (struct in_addr) { params.dd_gateway };
727 	else
728 		conf.kda_gateway.in4 = (struct in_addr) { INADDR_ANY };
729 
730 	/* Set the global netdump config to these options. */
731 	error = netdump_configure(&conf, NULL);
732 	if (error != 0) {
733 		db_printf("Error enabling netdump: %d\n", error);
734 		return;
735 	}
736 
737 	/* Fake the generic dump configuration list entry to avoid malloc. */
738 	memset(&u.di_buf, 0, sizeof(u.di_buf));
739 	u.di.dumper_start = netdump_start;
740 	u.di.dumper_hdr = netdump_write_headers;
741 	u.di.dumper = netdump_dumper;
742 	u.di.priv = NULL;
743 	u.di.blocksize = NETDUMP_DATASIZE;
744 	u.di.maxiosize = MAXDUMPPGS * PAGE_SIZE;
745 	u.di.mediaoffset = 0;
746 	u.di.mediasize = 0;
747 	u.di.blockbuf = blockbuf;
748 
749 	dumper_ddb_insert(&u.di);
750 
751 	error = doadump(false);
752 
753 	dumper_ddb_remove(&u.di);
754 	if (error != 0)
755 		db_printf("Cannot dump: %d\n", error);
756 }
757 #endif /* DDB */
758