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