xref: /freebsd/sys/netinet/netdump/netdump_client.c (revision 7029da5c36f2d3cf6bb6c81bf551229f416399e8)
1e5054602SMark Johnston /*-
2e5054602SMark Johnston  * Copyright (c) 2005-2014 Sandvine Incorporated. All rights reserved.
3e5054602SMark Johnston  * Copyright (c) 2000 Darrell Anderson
4e5054602SMark Johnston  * All rights reserved.
5e5054602SMark Johnston  *
6e5054602SMark Johnston  * Redistribution and use in source and binary forms, with or without
7e5054602SMark Johnston  * modification, are permitted provided that the following conditions
8e5054602SMark Johnston  * are met:
9e5054602SMark Johnston  * 1. Redistributions of source code must retain the above copyright
10e5054602SMark Johnston  *    notice, this list of conditions and the following disclaimer.
11e5054602SMark Johnston  * 2. Redistributions in binary form must reproduce the above copyright
12e5054602SMark Johnston  *    notice, this list of conditions and the following disclaimer in the
13e5054602SMark Johnston  *    documentation and/or other materials provided with the distribution.
14e5054602SMark Johnston  *
15e5054602SMark Johnston  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16e5054602SMark Johnston  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17e5054602SMark Johnston  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18e5054602SMark Johnston  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19e5054602SMark Johnston  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20e5054602SMark Johnston  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21e5054602SMark Johnston  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22e5054602SMark Johnston  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23e5054602SMark Johnston  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24e5054602SMark Johnston  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25e5054602SMark Johnston  * SUCH DAMAGE.
26e5054602SMark Johnston  */
27e5054602SMark Johnston 
28e5054602SMark Johnston /*
29e5054602SMark Johnston  * netdump_client.c
30e5054602SMark Johnston  * FreeBSD subsystem supporting netdump network dumps.
31e5054602SMark Johnston  * A dedicated server must be running to accept client dumps.
32e5054602SMark Johnston  */
33e5054602SMark Johnston 
34e5054602SMark Johnston #include <sys/cdefs.h>
35e5054602SMark Johnston __FBSDID("$FreeBSD$");
36e5054602SMark Johnston 
378270d35eSConrad Meyer #include "opt_ddb.h"
388270d35eSConrad Meyer 
39e5054602SMark Johnston #include <sys/param.h>
40e5054602SMark Johnston #include <sys/conf.h>
41e5054602SMark Johnston #include <sys/disk.h>
42e5054602SMark Johnston #include <sys/endian.h>
4304e0c883SConrad Meyer #include <sys/eventhandler.h>
44b35822d9SMark Johnston #include <sys/jail.h>
45e5054602SMark Johnston #include <sys/kernel.h>
46e5054602SMark Johnston #include <sys/kerneldump.h>
47e5054602SMark Johnston #include <sys/mbuf.h>
48e5054602SMark Johnston #include <sys/module.h>
49e5054602SMark Johnston #include <sys/priv.h>
50e5054602SMark Johnston #include <sys/proc.h>
51e5054602SMark Johnston #include <sys/protosw.h>
52e5054602SMark Johnston #include <sys/socket.h>
53e5054602SMark Johnston #include <sys/sysctl.h>
547790c8c1SConrad Meyer #include <sys/syslog.h>
55e5054602SMark Johnston #include <sys/systm.h>
56e5054602SMark Johnston 
578270d35eSConrad Meyer #ifdef DDB
588270d35eSConrad Meyer #include <ddb/ddb.h>
598270d35eSConrad Meyer #include <ddb/db_lex.h>
608270d35eSConrad Meyer #endif
618270d35eSConrad Meyer 
62e5054602SMark Johnston #include <net/ethernet.h>
63e5054602SMark Johnston #include <net/if.h>
64e5054602SMark Johnston #include <net/if_arp.h>
65e5054602SMark Johnston #include <net/if_dl.h>
66e5054602SMark Johnston #include <net/if_types.h>
67e5054602SMark Johnston #include <net/if_var.h>
687790c8c1SConrad Meyer #include <net/debugnet.h>
69e5054602SMark Johnston 
70e5054602SMark Johnston #include <netinet/in.h>
71e5054602SMark Johnston #include <netinet/in_systm.h>
72e5054602SMark Johnston #include <netinet/in_var.h>
73e5054602SMark Johnston #include <netinet/ip.h>
74e5054602SMark Johnston #include <netinet/ip_var.h>
75e5054602SMark Johnston #include <netinet/ip_options.h>
76e5054602SMark Johnston #include <netinet/udp.h>
77e5054602SMark Johnston #include <netinet/udp_var.h>
78e5054602SMark Johnston #include <netinet/netdump/netdump.h>
79e5054602SMark Johnston 
80e5054602SMark Johnston #include <machine/in_cksum.h>
81e5054602SMark Johnston #include <machine/pcb.h>
82e5054602SMark Johnston 
83e5054602SMark Johnston #define	NETDDEBUGV(f, ...) do {						\
84e5054602SMark Johnston 	if (nd_debug > 1)						\
85e5054602SMark Johnston 		printf(("%s: " f), __func__, ## __VA_ARGS__);		\
86e5054602SMark Johnston } while (0)
87e5054602SMark Johnston 
886b6e2954SConrad Meyer static int	 netdump_configure(struct diocskerneldump_arg *,
896b6e2954SConrad Meyer 		    struct thread *);
90e5054602SMark Johnston static int	 netdump_dumper(void *priv __unused, void *virtual,
91e5054602SMark Johnston 		    vm_offset_t physical __unused, off_t offset, size_t length);
9264e7d18fSConrad Meyer static bool	 netdump_enabled(void);
9364e7d18fSConrad Meyer static int	 netdump_enabled_sysctl(SYSCTL_HANDLER_ARGS);
94e5054602SMark Johnston static int	 netdump_ioctl(struct cdev *dev __unused, u_long cmd,
95e5054602SMark Johnston 		    caddr_t addr, int flags __unused, struct thread *td);
96e5054602SMark Johnston static int	 netdump_modevent(module_t mod, int type, void *priv);
97e5054602SMark Johnston static int	 netdump_start(struct dumperinfo *di);
9864e7d18fSConrad Meyer static void	 netdump_unconfigure(void);
99e5054602SMark Johnston 
100e5054602SMark Johnston /* Must be at least as big as the chunks dumpsys() gives us. */
101e5054602SMark Johnston static unsigned char nd_buf[MAXDUMPPGS * PAGE_SIZE];
1027790c8c1SConrad Meyer static int dump_failed;
103e5054602SMark Johnston 
104e5054602SMark Johnston /* Configuration parameters. */
1056144b50fSConrad Meyer static struct {
1066144b50fSConrad Meyer 	char		 ndc_iface[IFNAMSIZ];
1076144b50fSConrad Meyer 	union kd_ip	 ndc_server;
1086144b50fSConrad Meyer 	union kd_ip	 ndc_client;
1096144b50fSConrad Meyer 	union kd_ip	 ndc_gateway;
1106144b50fSConrad Meyer 	uint8_t		 ndc_af;
1118726929dSMark Johnston 	/* Runtime State */
1127790c8c1SConrad Meyer 	struct debugnet_pcb *nd_pcb;
1138726929dSMark Johnston 	off_t		 nd_tx_off;
1148726929dSMark Johnston 	size_t		 nd_buf_len;
1156144b50fSConrad Meyer } nd_conf;
1166144b50fSConrad Meyer #define	nd_server	nd_conf.ndc_server.in4
1176144b50fSConrad Meyer #define	nd_client	nd_conf.ndc_client.in4
1186144b50fSConrad Meyer #define	nd_gateway	nd_conf.ndc_gateway.in4
119e5054602SMark Johnston 
120e5054602SMark Johnston /* General dynamic settings. */
12164e7d18fSConrad Meyer static struct sx nd_conf_lk;
12264e7d18fSConrad Meyer SX_SYSINIT(nd_conf, &nd_conf_lk, "netdump configuration lock");
12364e7d18fSConrad Meyer #define NETDUMP_WLOCK()			sx_xlock(&nd_conf_lk)
12464e7d18fSConrad Meyer #define NETDUMP_WUNLOCK()		sx_xunlock(&nd_conf_lk)
12564e7d18fSConrad Meyer #define NETDUMP_RLOCK()			sx_slock(&nd_conf_lk)
12664e7d18fSConrad Meyer #define NETDUMP_RUNLOCK()		sx_sunlock(&nd_conf_lk)
12764e7d18fSConrad Meyer #define NETDUMP_ASSERT_WLOCKED()	sx_assert(&nd_conf_lk, SA_XLOCKED)
12864e7d18fSConrad Meyer #define NETDUMP_ASSERT_LOCKED()		sx_assert(&nd_conf_lk, SA_LOCKED)
129e5054602SMark Johnston static struct ifnet *nd_ifp;
13064e7d18fSConrad Meyer static eventhandler_tag nd_detach_cookie;
131e5054602SMark Johnston 
132e5054602SMark Johnston FEATURE(netdump, "Netdump client support");
133e5054602SMark Johnston 
134*7029da5cSPawel Biernacki static SYSCTL_NODE(_net, OID_AUTO, netdump, CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
135e5054602SMark Johnston     "netdump parameters");
136e5054602SMark Johnston 
137e5054602SMark Johnston static int nd_debug;
138e5054602SMark Johnston SYSCTL_INT(_net_netdump, OID_AUTO, debug, CTLFLAG_RWTUN,
139e5054602SMark Johnston     &nd_debug, 0,
140e5054602SMark Johnston     "Debug message verbosity");
141*7029da5cSPawel Biernacki SYSCTL_PROC(_net_netdump, OID_AUTO, enabled,
142*7029da5cSPawel Biernacki     CTLFLAG_RD | CTLTYPE_INT | CTLFLAG_MPSAFE, NULL, 0,
143*7029da5cSPawel Biernacki     netdump_enabled_sysctl, "I",
144*7029da5cSPawel Biernacki     "netdump configuration status");
145e5054602SMark Johnston static char nd_path[MAXPATHLEN];
146e5054602SMark Johnston SYSCTL_STRING(_net_netdump, OID_AUTO, path, CTLFLAG_RW,
147e5054602SMark Johnston     nd_path, sizeof(nd_path),
148e5054602SMark Johnston     "Server path for output files");
1497790c8c1SConrad Meyer /*
1507790c8c1SConrad Meyer  * The following three variables were moved to debugnet(4), but these knobs
1517790c8c1SConrad Meyer  * were retained as aliases.
1527790c8c1SConrad Meyer  */
153da7d7778SMark Johnston SYSCTL_INT(_net_netdump, OID_AUTO, polls, CTLFLAG_RWTUN,
1547790c8c1SConrad Meyer     &debugnet_npolls, 0,
155da7d7778SMark Johnston     "Number of times to poll before assuming packet loss (0.5ms per poll)");
156da7d7778SMark Johnston SYSCTL_INT(_net_netdump, OID_AUTO, retries, CTLFLAG_RWTUN,
1577790c8c1SConrad Meyer     &debugnet_nretries, 0,
158da7d7778SMark Johnston     "Number of retransmit attempts before giving up");
159da7d7778SMark Johnston SYSCTL_INT(_net_netdump, OID_AUTO, arp_retries, CTLFLAG_RWTUN,
1607790c8c1SConrad Meyer     &debugnet_arp_nretries, 0,
161da7d7778SMark Johnston     "Number of ARP attempts before giving up");
162e5054602SMark Johnston 
163fde2cf65SConrad Meyer static bool nd_is_enabled;
16464e7d18fSConrad Meyer static bool
16564e7d18fSConrad Meyer netdump_enabled(void)
16664e7d18fSConrad Meyer {
16764e7d18fSConrad Meyer 
16864e7d18fSConrad Meyer 	NETDUMP_ASSERT_LOCKED();
169fde2cf65SConrad Meyer 	return (nd_is_enabled);
170fde2cf65SConrad Meyer }
171fde2cf65SConrad Meyer 
172fde2cf65SConrad Meyer static void
173fde2cf65SConrad Meyer netdump_set_enabled(bool status)
174fde2cf65SConrad Meyer {
175fde2cf65SConrad Meyer 
176fde2cf65SConrad Meyer 	NETDUMP_ASSERT_LOCKED();
177fde2cf65SConrad Meyer 	nd_is_enabled = status;
17864e7d18fSConrad Meyer }
17964e7d18fSConrad Meyer 
18064e7d18fSConrad Meyer static int
18164e7d18fSConrad Meyer netdump_enabled_sysctl(SYSCTL_HANDLER_ARGS)
18264e7d18fSConrad Meyer {
18364e7d18fSConrad Meyer 	int en, error;
18464e7d18fSConrad Meyer 
18564e7d18fSConrad Meyer 	NETDUMP_RLOCK();
18664e7d18fSConrad Meyer 	en = netdump_enabled();
18764e7d18fSConrad Meyer 	NETDUMP_RUNLOCK();
18864e7d18fSConrad Meyer 
18964e7d18fSConrad Meyer 	error = SYSCTL_OUT(req, &en, sizeof(en));
19064e7d18fSConrad Meyer 	if (error != 0 || req->newptr == NULL)
19164e7d18fSConrad Meyer 		return (error);
19264e7d18fSConrad Meyer 	return (EPERM);
19364e7d18fSConrad Meyer }
19464e7d18fSConrad Meyer 
195e5054602SMark Johnston /*-
196e5054602SMark Johnston  * Dumping specific primitives.
197e5054602SMark Johnston  */
198e5054602SMark Johnston 
199e5054602SMark Johnston /*
200ccdc9866SMark Johnston  * Flush any buffered vmcore data.
201ccdc9866SMark Johnston  */
202ccdc9866SMark Johnston static int
203ccdc9866SMark Johnston netdump_flush_buf(void)
204ccdc9866SMark Johnston {
205ccdc9866SMark Johnston 	int error;
206ccdc9866SMark Johnston 
207ccdc9866SMark Johnston 	error = 0;
208ccdc9866SMark Johnston 	if (nd_conf.nd_buf_len != 0) {
2097790c8c1SConrad Meyer 		struct debugnet_proto_aux auxdata = {
2107790c8c1SConrad Meyer 			.dp_offset_start = nd_conf.nd_tx_off,
2117790c8c1SConrad Meyer 		};
2127790c8c1SConrad Meyer 		error = debugnet_send(nd_conf.nd_pcb, DEBUGNET_DATA, nd_buf,
2137790c8c1SConrad Meyer 		    nd_conf.nd_buf_len, &auxdata);
214ccdc9866SMark Johnston 		if (error == 0)
215ccdc9866SMark Johnston 			nd_conf.nd_buf_len = 0;
216ccdc9866SMark Johnston 	}
217ccdc9866SMark Johnston 	return (error);
218ccdc9866SMark Johnston }
219ccdc9866SMark Johnston 
220ccdc9866SMark Johnston /*
221e5054602SMark Johnston  * Callback from dumpsys() to dump a chunk of memory.
222e5054602SMark Johnston  * Copies it out to our static buffer then sends it across the network.
223e5054602SMark Johnston  * Detects the initial KDH and makes sure it is given a special packet type.
224e5054602SMark Johnston  *
225e5054602SMark Johnston  * Parameters:
226e5054602SMark Johnston  *	priv	 Unused. Optional private pointer.
227e5054602SMark Johnston  *	virtual  Virtual address (where to read the data from)
228e5054602SMark Johnston  *	physical Unused. Physical memory address.
229e5054602SMark Johnston  *	offset	 Offset from start of core file
230e5054602SMark Johnston  *	length	 Data length
231e5054602SMark Johnston  *
232e5054602SMark Johnston  * Return value:
233e5054602SMark Johnston  *	0 on success
234e5054602SMark Johnston  *	errno on error
235e5054602SMark Johnston  */
236e5054602SMark Johnston static int
237e5054602SMark Johnston netdump_dumper(void *priv __unused, void *virtual,
238e5054602SMark Johnston     vm_offset_t physical __unused, off_t offset, size_t length)
239e5054602SMark Johnston {
240e5054602SMark Johnston 	int error;
241e5054602SMark Johnston 
242e5054602SMark Johnston 	NETDDEBUGV("netdump_dumper(NULL, %p, NULL, %ju, %zu)\n",
243e5054602SMark Johnston 	    virtual, (uintmax_t)offset, length);
244e5054602SMark Johnston 
245e5054602SMark Johnston 	if (virtual == NULL) {
246ccdc9866SMark Johnston 		error = netdump_flush_buf();
247ccdc9866SMark Johnston 		if (error != 0)
2488726929dSMark Johnston 			dump_failed = 1;
2498726929dSMark Johnston 
250e5054602SMark Johnston 		if (dump_failed != 0)
251e5054602SMark Johnston 			printf("failed to dump the kernel core\n");
2527790c8c1SConrad Meyer 		else if (
2537790c8c1SConrad Meyer 		    debugnet_sendempty(nd_conf.nd_pcb, DEBUGNET_FINISHED) != 0)
254e5054602SMark Johnston 			printf("failed to close the transaction\n");
255e5054602SMark Johnston 		else
256e5054602SMark Johnston 			printf("\nnetdump finished.\n");
2577790c8c1SConrad Meyer 		debugnet_free(nd_conf.nd_pcb);
2587790c8c1SConrad Meyer 		nd_conf.nd_pcb = NULL;
259e5054602SMark Johnston 		return (0);
260e5054602SMark Johnston 	}
261e5054602SMark Johnston 	if (length > sizeof(nd_buf))
262e5054602SMark Johnston 		return (ENOSPC);
263e5054602SMark Johnston 
2648726929dSMark Johnston 	if (nd_conf.nd_buf_len + length > sizeof(nd_buf) ||
2658726929dSMark Johnston 	    (nd_conf.nd_buf_len != 0 && nd_conf.nd_tx_off +
2668726929dSMark Johnston 	    nd_conf.nd_buf_len != offset)) {
267ccdc9866SMark Johnston 		error = netdump_flush_buf();
268e5054602SMark Johnston 		if (error != 0) {
269e5054602SMark Johnston 			dump_failed = 1;
270e5054602SMark Johnston 			return (error);
271e5054602SMark Johnston 		}
2728726929dSMark Johnston 		nd_conf.nd_tx_off = offset;
2738726929dSMark Johnston 	}
2748726929dSMark Johnston 
2758726929dSMark Johnston 	memmove(nd_buf + nd_conf.nd_buf_len, virtual, length);
2768726929dSMark Johnston 	nd_conf.nd_buf_len += length;
2778726929dSMark Johnston 
278e5054602SMark Johnston 	return (0);
279e5054602SMark Johnston }
280e5054602SMark Johnston 
281e5054602SMark Johnston /*
2825aa0576bSEd Maste  * Perform any initialization needed prior to transmitting the kernel core.
283e5054602SMark Johnston  */
284e5054602SMark Johnston static int
285e5054602SMark Johnston netdump_start(struct dumperinfo *di)
286e5054602SMark Johnston {
2877790c8c1SConrad Meyer 	struct debugnet_conn_params dcp;
2887790c8c1SConrad Meyer 	struct debugnet_pcb *pcb;
289e5054602SMark Johnston 	char buf[INET_ADDRSTRLEN];
290e5054602SMark Johnston 	int error;
291e5054602SMark Johnston 
292e5054602SMark Johnston 	error = 0;
293e5054602SMark Johnston 
294e5054602SMark Johnston 	/* Check if the dumping is allowed to continue. */
29564e7d18fSConrad Meyer 	if (!netdump_enabled())
296e5054602SMark Johnston 		return (EINVAL);
297e5054602SMark Johnston 
298879e0604SMateusz Guzik 	if (!KERNEL_PANICKED()) {
299e5054602SMark Johnston 		printf(
300e5054602SMark Johnston 		    "netdump_start: netdump may only be used after a panic\n");
301e5054602SMark Johnston 		return (EINVAL);
302e5054602SMark Johnston 	}
303e5054602SMark Johnston 
3047790c8c1SConrad Meyer 	memset(&dcp, 0, sizeof(dcp));
3057790c8c1SConrad Meyer 
306e5054602SMark Johnston 	if (nd_server.s_addr == INADDR_ANY) {
307e5054602SMark Johnston 		printf("netdump_start: can't netdump; no server IP given\n");
308e5054602SMark Johnston 		return (EINVAL);
309e5054602SMark Johnston 	}
310e5054602SMark Johnston 
311e5054602SMark Johnston 	/* We start dumping at offset 0. */
312e5054602SMark Johnston 	di->dumpoff = 0;
313e5054602SMark Johnston 
3147790c8c1SConrad Meyer 	dcp.dc_ifp = nd_ifp;
315e5054602SMark Johnston 
3167790c8c1SConrad Meyer 	dcp.dc_client = nd_client.s_addr;
3177790c8c1SConrad Meyer 	dcp.dc_server = nd_server.s_addr;
3187790c8c1SConrad Meyer 	dcp.dc_gateway = nd_gateway.s_addr;
319e5054602SMark Johnston 
3207790c8c1SConrad Meyer 	dcp.dc_herald_port = NETDUMP_PORT;
321e9c69625SConrad Meyer 	dcp.dc_client_port = NETDUMP_ACKPORT;
322e5054602SMark Johnston 
3237790c8c1SConrad Meyer 	dcp.dc_herald_data = nd_path;
3247790c8c1SConrad Meyer 	dcp.dc_herald_datalen = (nd_path[0] == 0) ? 0 : strlen(nd_path) + 1;
325e5054602SMark Johnston 
3267790c8c1SConrad Meyer 	error = debugnet_connect(&dcp, &pcb);
3277790c8c1SConrad Meyer 	if (error != 0) {
328e5054602SMark Johnston 		printf("failed to contact netdump server\n");
3297790c8c1SConrad Meyer 		/* Squash debugnet to something the dumper code understands. */
3307790c8c1SConrad Meyer 		return (EINVAL);
331e5054602SMark Johnston 	}
332e5054602SMark Johnston 
3337790c8c1SConrad Meyer 	printf("netdumping to %s (%6D)\n", inet_ntoa_r(nd_server, buf),
3347790c8c1SConrad Meyer 	    debugnet_get_gw_mac(pcb), ":");
3357790c8c1SConrad Meyer 	nd_conf.nd_pcb = pcb;
3367790c8c1SConrad Meyer 	return (0);
337e5054602SMark Johnston }
338e5054602SMark Johnston 
339e5054602SMark Johnston static int
340e5054602SMark Johnston netdump_write_headers(struct dumperinfo *di, struct kerneldumpheader *kdh,
341e5054602SMark Johnston     void *key, uint32_t keysize)
342e5054602SMark Johnston {
343e5054602SMark Johnston 	int error;
344e5054602SMark Johnston 
345ccdc9866SMark Johnston 	error = netdump_flush_buf();
346ccdc9866SMark Johnston 	if (error != 0)
347ccdc9866SMark Johnston 		return (error);
348e5054602SMark Johnston 	memcpy(nd_buf, kdh, sizeof(*kdh));
3497790c8c1SConrad Meyer 	error = debugnet_send(nd_conf.nd_pcb, NETDUMP_KDH, nd_buf,
3507790c8c1SConrad Meyer 	    sizeof(*kdh), NULL);
351e5054602SMark Johnston 	if (error == 0 && keysize > 0) {
352e5054602SMark Johnston 		if (keysize > sizeof(nd_buf))
353e5054602SMark Johnston 			return (EINVAL);
354e5054602SMark Johnston 		memcpy(nd_buf, key, keysize);
3557790c8c1SConrad Meyer 		error = debugnet_send(nd_conf.nd_pcb, NETDUMP_EKCD_KEY, nd_buf,
3567790c8c1SConrad Meyer 		    keysize, NULL);
357e5054602SMark Johnston 	}
358e5054602SMark Johnston 	return (error);
359e5054602SMark Johnston }
360e5054602SMark Johnston 
361e5054602SMark Johnston /*-
362e5054602SMark Johnston  * KLD specific code.
363e5054602SMark Johnston  */
364e5054602SMark Johnston 
365e5054602SMark Johnston static struct cdevsw netdump_cdevsw = {
366e5054602SMark Johnston 	.d_version =	D_VERSION,
367e5054602SMark Johnston 	.d_ioctl =	netdump_ioctl,
368e5054602SMark Johnston 	.d_name =	"netdump",
369e5054602SMark Johnston };
370e5054602SMark Johnston 
371e5054602SMark Johnston static struct cdev *netdump_cdev;
372e5054602SMark Johnston 
37364e7d18fSConrad Meyer static void
37464e7d18fSConrad Meyer netdump_unconfigure(void)
37564e7d18fSConrad Meyer {
37664e7d18fSConrad Meyer 	struct diocskerneldump_arg kda;
37764e7d18fSConrad Meyer 
37864e7d18fSConrad Meyer 	NETDUMP_ASSERT_WLOCKED();
379fde2cf65SConrad Meyer 	KASSERT(netdump_enabled(), ("%s: not enabled", __func__));
38064e7d18fSConrad Meyer 
38164e7d18fSConrad Meyer 	bzero(&kda, sizeof(kda));
38264e7d18fSConrad Meyer 	kda.kda_index = KDA_REMOVE_DEV;
38364e7d18fSConrad Meyer 	(void)dumper_remove(nd_conf.ndc_iface, &kda);
38464e7d18fSConrad Meyer 
385fde2cf65SConrad Meyer 	if (nd_ifp != NULL)
38664e7d18fSConrad Meyer 		if_rele(nd_ifp);
38764e7d18fSConrad Meyer 	nd_ifp = NULL;
388fde2cf65SConrad Meyer 	netdump_set_enabled(false);
38964e7d18fSConrad Meyer 
3907790c8c1SConrad Meyer 	log(LOG_WARNING, "netdump: Lost configured interface %s\n",
3917790c8c1SConrad Meyer 	    nd_conf.ndc_iface);
3927790c8c1SConrad Meyer 
39364e7d18fSConrad Meyer 	bzero(&nd_conf, sizeof(nd_conf));
39464e7d18fSConrad Meyer }
39564e7d18fSConrad Meyer 
39664e7d18fSConrad Meyer static void
39764e7d18fSConrad Meyer netdump_ifdetach(void *arg __unused, struct ifnet *ifp)
39864e7d18fSConrad Meyer {
39964e7d18fSConrad Meyer 
40064e7d18fSConrad Meyer 	NETDUMP_WLOCK();
40164e7d18fSConrad Meyer 	if (ifp == nd_ifp)
40264e7d18fSConrad Meyer 		netdump_unconfigure();
40364e7d18fSConrad Meyer 	NETDUMP_WUNLOCK();
40464e7d18fSConrad Meyer }
40564e7d18fSConrad Meyer 
4068270d35eSConrad Meyer /*
4078270d35eSConrad Meyer  * td of NULL is a sentinel value that indicates a kernel caller (ddb(4) or
4088270d35eSConrad Meyer  * modload-based tunable parameters).
4098270d35eSConrad Meyer  */
410e5054602SMark Johnston static int
4116b6e2954SConrad Meyer netdump_configure(struct diocskerneldump_arg *conf, struct thread *td)
412e5054602SMark Johnston {
413e5054602SMark Johnston 	struct ifnet *ifp;
414e5054602SMark Johnston 
41564e7d18fSConrad Meyer 	NETDUMP_ASSERT_WLOCKED();
41664e7d18fSConrad Meyer 
417fde2cf65SConrad Meyer 	if (conf->kda_iface[0] != 0) {
4184ad8cb68SMichael Tuexen 		if (td != NULL && !IS_DEFAULT_VNET(TD_TO_VNET(td)))
419b35822d9SMark Johnston 			return (EINVAL);
4204ad8cb68SMichael Tuexen 		CURVNET_SET(vnet0);
42164e7d18fSConrad Meyer 		ifp = ifunit_ref(conf->kda_iface);
422b35822d9SMark Johnston 		CURVNET_RESTORE();
423fde2cf65SConrad Meyer 	} else
424fde2cf65SConrad Meyer 		ifp = NULL;
425e5054602SMark Johnston 
426fde2cf65SConrad Meyer 	if (nd_ifp != NULL)
42764e7d18fSConrad Meyer 		if_rele(nd_ifp);
428e5054602SMark Johnston 	nd_ifp = ifp;
429fde2cf65SConrad Meyer 	netdump_set_enabled(true);
4306144b50fSConrad Meyer 
4316144b50fSConrad Meyer #define COPY_SIZED(elm) do {	\
4326144b50fSConrad Meyer 	_Static_assert(sizeof(nd_conf.ndc_ ## elm) ==			\
4336144b50fSConrad Meyer 	    sizeof(conf->kda_ ## elm), "elm " __XSTRING(elm) " mismatch"); \
4346144b50fSConrad Meyer 	memcpy(&nd_conf.ndc_ ## elm, &conf->kda_ ## elm,		\
4356144b50fSConrad Meyer 	    sizeof(nd_conf.ndc_ ## elm));				\
4366144b50fSConrad Meyer } while (0)
4376144b50fSConrad Meyer 	COPY_SIZED(iface);
4386144b50fSConrad Meyer 	COPY_SIZED(server);
4396144b50fSConrad Meyer 	COPY_SIZED(client);
4406144b50fSConrad Meyer 	COPY_SIZED(gateway);
4416144b50fSConrad Meyer 	COPY_SIZED(af);
4426144b50fSConrad Meyer #undef COPY_SIZED
44364e7d18fSConrad Meyer 
444e5054602SMark Johnston 	return (0);
445e5054602SMark Johnston }
446e5054602SMark Johnston 
447e5054602SMark Johnston /*
448e5054602SMark Johnston  * ioctl(2) handler for the netdump device. This is currently only used to
449e5054602SMark Johnston  * register netdump as a dump device.
450e5054602SMark Johnston  *
451e5054602SMark Johnston  * Parameters:
452e5054602SMark Johnston  *     dev, Unused.
453e5054602SMark Johnston  *     cmd, The ioctl to be handled.
454e5054602SMark Johnston  *     addr, The parameter for the ioctl.
455e5054602SMark Johnston  *     flags, Unused.
456e5054602SMark Johnston  *     td, The thread invoking this ioctl.
457e5054602SMark Johnston  *
458e5054602SMark Johnston  * Returns:
459e5054602SMark Johnston  *     0 on success, and an errno value on failure.
460e5054602SMark Johnston  */
461e5054602SMark Johnston static int
462e5054602SMark Johnston netdump_ioctl(struct cdev *dev __unused, u_long cmd, caddr_t addr,
463e5054602SMark Johnston     int flags __unused, struct thread *td)
464e5054602SMark Johnston {
4656b6e2954SConrad Meyer 	struct diocskerneldump_arg kda_copy, *conf;
466e5054602SMark Johnston 	struct dumperinfo dumper;
467e5054602SMark Johnston 	uint8_t *encryptedkey;
468e5054602SMark Johnston 	int error;
469a9f7f192SConrad Meyer #ifdef COMPAT_FREEBSD11
470e5054602SMark Johnston 	u_int u;
471a9f7f192SConrad Meyer #endif
4726b6e2954SConrad Meyer #ifdef COMPAT_FREEBSD12
4736b6e2954SConrad Meyer 	struct diocskerneldump_arg_freebsd12 *kda12;
4746b6e2954SConrad Meyer 	struct netdump_conf_freebsd12 *conf12;
4756b6e2954SConrad Meyer #endif
476e5054602SMark Johnston 
4776b6e2954SConrad Meyer 	conf = NULL;
478e5054602SMark Johnston 	error = 0;
47964e7d18fSConrad Meyer 	NETDUMP_WLOCK();
48064e7d18fSConrad Meyer 
481e5054602SMark Johnston 	switch (cmd) {
48260ade167SConrad Meyer #ifdef COMPAT_FREEBSD11
48360ade167SConrad Meyer 	case DIOCSKERNELDUMP_FREEBSD11:
4846b6e2954SConrad Meyer 		gone_in(13, "11.x ABI compatibility");
485e5054602SMark Johnston 		u = *(u_int *)addr;
486e5054602SMark Johnston 		if (u != 0) {
487e5054602SMark Johnston 			error = ENXIO;
488e5054602SMark Johnston 			break;
489e5054602SMark Johnston 		}
49064e7d18fSConrad Meyer 		if (netdump_enabled())
49164e7d18fSConrad Meyer 			netdump_unconfigure();
49260ade167SConrad Meyer 		break;
49360ade167SConrad Meyer #endif
4946b6e2954SConrad Meyer #ifdef COMPAT_FREEBSD12
4956b6e2954SConrad Meyer 		/*
4966b6e2954SConrad Meyer 		 * Used by dumpon(8) in 12.x for clearing previous
4976b6e2954SConrad Meyer 		 * configuration -- then NETDUMPSCONF_FREEBSD12 is used to
4986b6e2954SConrad Meyer 		 * actually configure netdump.
4996b6e2954SConrad Meyer 		 */
5006b6e2954SConrad Meyer 	case DIOCSKERNELDUMP_FREEBSD12:
5016b6e2954SConrad Meyer 		gone_in(14, "12.x ABI compatibility");
5026b6e2954SConrad Meyer 
5036b6e2954SConrad Meyer 		kda12 = (void *)addr;
5046b6e2954SConrad Meyer 		if (kda12->kda12_enable) {
50560ade167SConrad Meyer 			error = ENXIO;
50660ade167SConrad Meyer 			break;
50760ade167SConrad Meyer 		}
50864e7d18fSConrad Meyer 		if (netdump_enabled())
50964e7d18fSConrad Meyer 			netdump_unconfigure();
510e5054602SMark Johnston 		break;
5116b6e2954SConrad Meyer 
5126b6e2954SConrad Meyer 	case NETDUMPGCONF_FREEBSD12:
5136b6e2954SConrad Meyer 		gone_in(14, "FreeBSD 12.x ABI compat");
5146b6e2954SConrad Meyer 		conf12 = (void *)addr;
5156b6e2954SConrad Meyer 
51664e7d18fSConrad Meyer 		if (!netdump_enabled()) {
517e5054602SMark Johnston 			error = ENXIO;
518e5054602SMark Johnston 			break;
519e5054602SMark Johnston 		}
5206144b50fSConrad Meyer 		if (nd_conf.ndc_af != AF_INET) {
5216b6e2954SConrad Meyer 			error = EOPNOTSUPP;
522e5054602SMark Johnston 			break;
5236b6e2954SConrad Meyer 		}
524e5054602SMark Johnston 
525fde2cf65SConrad Meyer 		if (nd_ifp != NULL)
5266b6e2954SConrad Meyer 			strlcpy(conf12->ndc12_iface, nd_ifp->if_xname,
5276b6e2954SConrad Meyer 			    sizeof(conf12->ndc12_iface));
5286b6e2954SConrad Meyer 		memcpy(&conf12->ndc12_server, &nd_server,
5296b6e2954SConrad Meyer 		    sizeof(conf12->ndc12_server));
5306b6e2954SConrad Meyer 		memcpy(&conf12->ndc12_client, &nd_client,
5316b6e2954SConrad Meyer 		    sizeof(conf12->ndc12_client));
5326b6e2954SConrad Meyer 		memcpy(&conf12->ndc12_gateway, &nd_gateway,
5336b6e2954SConrad Meyer 		    sizeof(conf12->ndc12_gateway));
5346b6e2954SConrad Meyer 		break;
5356b6e2954SConrad Meyer #endif
5366b6e2954SConrad Meyer 	case DIOCGKERNELDUMP:
5376b6e2954SConrad Meyer 		conf = (void *)addr;
5386b6e2954SConrad Meyer 		/*
5396b6e2954SConrad Meyer 		 * For now, index is ignored; netdump doesn't support multiple
5406b6e2954SConrad Meyer 		 * configurations (yet).
5416b6e2954SConrad Meyer 		 */
54264e7d18fSConrad Meyer 		if (!netdump_enabled()) {
5436b6e2954SConrad Meyer 			error = ENXIO;
5446b6e2954SConrad Meyer 			conf = NULL;
5456b6e2954SConrad Meyer 			break;
5466b6e2954SConrad Meyer 		}
5476b6e2954SConrad Meyer 
548fde2cf65SConrad Meyer 		if (nd_ifp != NULL)
5496b6e2954SConrad Meyer 			strlcpy(conf->kda_iface, nd_ifp->if_xname,
5506b6e2954SConrad Meyer 			    sizeof(conf->kda_iface));
5516b6e2954SConrad Meyer 		memcpy(&conf->kda_server, &nd_server, sizeof(nd_server));
5526b6e2954SConrad Meyer 		memcpy(&conf->kda_client, &nd_client, sizeof(nd_client));
5536b6e2954SConrad Meyer 		memcpy(&conf->kda_gateway, &nd_gateway, sizeof(nd_gateway));
5546144b50fSConrad Meyer 		conf->kda_af = nd_conf.ndc_af;
5556b6e2954SConrad Meyer 		conf = NULL;
5566b6e2954SConrad Meyer 		break;
5576b6e2954SConrad Meyer 
5586b6e2954SConrad Meyer #ifdef COMPAT_FREEBSD12
5596b6e2954SConrad Meyer 	case NETDUMPSCONF_FREEBSD12:
5606b6e2954SConrad Meyer 		gone_in(14, "FreeBSD 12.x ABI compat");
5616b6e2954SConrad Meyer 
5626b6e2954SConrad Meyer 		conf12 = (struct netdump_conf_freebsd12 *)addr;
5636b6e2954SConrad Meyer 
5646b6e2954SConrad Meyer 		_Static_assert(offsetof(struct diocskerneldump_arg, kda_server)
5656b6e2954SConrad Meyer 		    == offsetof(struct netdump_conf_freebsd12, ndc12_server),
5666b6e2954SConrad Meyer 		    "simplifying assumption");
5676b6e2954SConrad Meyer 
5686b6e2954SConrad Meyer 		memset(&kda_copy, 0, sizeof(kda_copy));
5696b6e2954SConrad Meyer 		memcpy(&kda_copy, conf12,
5706b6e2954SConrad Meyer 		    offsetof(struct diocskerneldump_arg, kda_server));
5716b6e2954SConrad Meyer 
5726b6e2954SConrad Meyer 		/* 12.x ABI could only configure IPv4 (INET) netdump. */
5736b6e2954SConrad Meyer 		kda_copy.kda_af = AF_INET;
5746b6e2954SConrad Meyer 		memcpy(&kda_copy.kda_server.in4, &conf12->ndc12_server,
5756b6e2954SConrad Meyer 		    sizeof(struct in_addr));
5766b6e2954SConrad Meyer 		memcpy(&kda_copy.kda_client.in4, &conf12->ndc12_client,
5776b6e2954SConrad Meyer 		    sizeof(struct in_addr));
5786b6e2954SConrad Meyer 		memcpy(&kda_copy.kda_gateway.in4, &conf12->ndc12_gateway,
5796b6e2954SConrad Meyer 		    sizeof(struct in_addr));
5806b6e2954SConrad Meyer 
5816b6e2954SConrad Meyer 		kda_copy.kda_index =
5826b6e2954SConrad Meyer 		    (conf12->ndc12_kda.kda12_enable ? 0 : KDA_REMOVE_ALL);
5836b6e2954SConrad Meyer 
5846b6e2954SConrad Meyer 		conf = &kda_copy;
5856b6e2954SConrad Meyer 		explicit_bzero(conf12, sizeof(*conf12));
5866b6e2954SConrad Meyer 		/* FALLTHROUGH */
5876b6e2954SConrad Meyer #endif
5886b6e2954SConrad Meyer 	case DIOCSKERNELDUMP:
5896b6e2954SConrad Meyer 		encryptedkey = NULL;
5906b6e2954SConrad Meyer 		if (cmd == DIOCSKERNELDUMP) {
5916b6e2954SConrad Meyer 			conf = (void *)addr;
5926b6e2954SConrad Meyer 			memcpy(&kda_copy, conf, sizeof(kda_copy));
5936b6e2954SConrad Meyer 		}
5946b6e2954SConrad Meyer 		/* Netdump only supports IP4 at this time. */
5956b6e2954SConrad Meyer 		if (conf->kda_af != AF_INET) {
5966b6e2954SConrad Meyer 			error = EPROTONOSUPPORT;
5976b6e2954SConrad Meyer 			break;
5986b6e2954SConrad Meyer 		}
5996b6e2954SConrad Meyer 
6006b6e2954SConrad Meyer 		conf->kda_iface[sizeof(conf->kda_iface) - 1] = '\0';
6016b6e2954SConrad Meyer 		if (conf->kda_index == KDA_REMOVE ||
6026b6e2954SConrad Meyer 		    conf->kda_index == KDA_REMOVE_DEV ||
6036b6e2954SConrad Meyer 		    conf->kda_index == KDA_REMOVE_ALL) {
60464e7d18fSConrad Meyer 			if (netdump_enabled())
60564e7d18fSConrad Meyer 				netdump_unconfigure();
60664e7d18fSConrad Meyer 			if (conf->kda_index == KDA_REMOVE_ALL)
60764e7d18fSConrad Meyer 				error = dumper_remove(NULL, conf);
608e5054602SMark Johnston 			break;
609e5054602SMark Johnston 		}
610e5054602SMark Johnston 
611b35822d9SMark Johnston 		error = netdump_configure(conf, td);
612e5054602SMark Johnston 		if (error != 0)
613e5054602SMark Johnston 			break;
614e5054602SMark Johnston 
6156b6e2954SConrad Meyer 		if (conf->kda_encryption != KERNELDUMP_ENC_NONE) {
6166b6e2954SConrad Meyer 			if (conf->kda_encryptedkeysize <= 0 ||
6176b6e2954SConrad Meyer 			    conf->kda_encryptedkeysize >
6186b6e2954SConrad Meyer 			    KERNELDUMP_ENCKEY_MAX_SIZE) {
6196b6e2954SConrad Meyer 				error = EINVAL;
6206b6e2954SConrad Meyer 				break;
6216b6e2954SConrad Meyer 			}
6226b6e2954SConrad Meyer 			encryptedkey = malloc(conf->kda_encryptedkeysize,
6236b6e2954SConrad Meyer 			    M_TEMP, M_WAITOK);
6246b6e2954SConrad Meyer 			error = copyin(conf->kda_encryptedkey, encryptedkey,
6256b6e2954SConrad Meyer 			    conf->kda_encryptedkeysize);
626e5054602SMark Johnston 			if (error != 0) {
627e5054602SMark Johnston 				free(encryptedkey, M_TEMP);
6286b6e2954SConrad Meyer 				break;
629e5054602SMark Johnston 			}
6306b6e2954SConrad Meyer 
6316b6e2954SConrad Meyer 			conf->kda_encryptedkey = encryptedkey;
632e5054602SMark Johnston 		}
633e5054602SMark Johnston 
6349f78e2b8SMark Johnston 		memset(&dumper, 0, sizeof(dumper));
635e5054602SMark Johnston 		dumper.dumper_start = netdump_start;
636e5054602SMark Johnston 		dumper.dumper_hdr = netdump_write_headers;
637e5054602SMark Johnston 		dumper.dumper = netdump_dumper;
638e5054602SMark Johnston 		dumper.priv = NULL;
639e5054602SMark Johnston 		dumper.blocksize = NETDUMP_DATASIZE;
640e5054602SMark Johnston 		dumper.maxiosize = MAXDUMPPGS * PAGE_SIZE;
641e5054602SMark Johnston 		dumper.mediaoffset = 0;
642e5054602SMark Johnston 		dumper.mediasize = 0;
643e5054602SMark Johnston 
6446b6e2954SConrad Meyer 		error = dumper_insert(&dumper, conf->kda_iface, conf);
645e5054602SMark Johnston 		if (encryptedkey != NULL) {
6466b6e2954SConrad Meyer 			explicit_bzero(encryptedkey,
6476b6e2954SConrad Meyer 			    conf->kda_encryptedkeysize);
648e5054602SMark Johnston 			free(encryptedkey, M_TEMP);
649e5054602SMark Johnston 		}
65064e7d18fSConrad Meyer 		if (error != 0)
65164e7d18fSConrad Meyer 			netdump_unconfigure();
652e5054602SMark Johnston 		break;
653e5054602SMark Johnston 	default:
6546b6e2954SConrad Meyer 		error = ENOTTY;
655e5054602SMark Johnston 		break;
656e5054602SMark Johnston 	}
6576b6e2954SConrad Meyer 	explicit_bzero(&kda_copy, sizeof(kda_copy));
6586b6e2954SConrad Meyer 	if (conf != NULL)
6596b6e2954SConrad Meyer 		explicit_bzero(conf, sizeof(*conf));
66064e7d18fSConrad Meyer 	NETDUMP_WUNLOCK();
661e5054602SMark Johnston 	return (error);
662e5054602SMark Johnston }
663e5054602SMark Johnston 
664e5054602SMark Johnston /*
665e5054602SMark Johnston  * Called upon system init or kld load.  Initializes the netdump parameters to
666e5054602SMark Johnston  * sane defaults (locates the first available NIC and uses the first IPv4 IP on
667e5054602SMark Johnston  * that card as the client IP).  Leaves the server IP unconfigured.
668e5054602SMark Johnston  *
669e5054602SMark Johnston  * Parameters:
670e5054602SMark Johnston  *	mod, Unused.
671e5054602SMark Johnston  *	what, The module event type.
672e5054602SMark Johnston  *	priv, Unused.
673e5054602SMark Johnston  *
674e5054602SMark Johnston  * Returns:
675e5054602SMark Johnston  *	int, An errno value if an error occured, 0 otherwise.
676e5054602SMark Johnston  */
677e5054602SMark Johnston static int
678e5054602SMark Johnston netdump_modevent(module_t mod __unused, int what, void *priv __unused)
679e5054602SMark Johnston {
6806b6e2954SConrad Meyer 	struct diocskerneldump_arg conf;
681e5054602SMark Johnston 	char *arg;
682e5054602SMark Johnston 	int error;
683e5054602SMark Johnston 
684e5054602SMark Johnston 	error = 0;
685e5054602SMark Johnston 	switch (what) {
686e5054602SMark Johnston 	case MOD_LOAD:
687e5054602SMark Johnston 		error = make_dev_p(MAKEDEV_WAITOK, &netdump_cdev,
688e5054602SMark Johnston 		    &netdump_cdevsw, 0, UID_ROOT, GID_WHEEL, 0600, "netdump");
689e5054602SMark Johnston 		if (error != 0)
690e5054602SMark Johnston 			return (error);
691e5054602SMark Johnston 
69264e7d18fSConrad Meyer 		nd_detach_cookie = EVENTHANDLER_REGISTER(ifnet_departure_event,
69364e7d18fSConrad Meyer 		    netdump_ifdetach, NULL, EVENTHANDLER_PRI_ANY);
69464e7d18fSConrad Meyer 
695e5054602SMark Johnston 		if ((arg = kern_getenv("net.dump.iface")) != NULL) {
6966b6e2954SConrad Meyer 			strlcpy(conf.kda_iface, arg, sizeof(conf.kda_iface));
697e5054602SMark Johnston 			freeenv(arg);
698e5054602SMark Johnston 
699e5054602SMark Johnston 			if ((arg = kern_getenv("net.dump.server")) != NULL) {
7006b6e2954SConrad Meyer 				inet_aton(arg, &conf.kda_server.in4);
701e5054602SMark Johnston 				freeenv(arg);
702e5054602SMark Johnston 			}
703e5054602SMark Johnston 			if ((arg = kern_getenv("net.dump.client")) != NULL) {
704070e7bf9SConrad Meyer 				inet_aton(arg, &conf.kda_client.in4);
705e5054602SMark Johnston 				freeenv(arg);
706e5054602SMark Johnston 			}
707e5054602SMark Johnston 			if ((arg = kern_getenv("net.dump.gateway")) != NULL) {
708070e7bf9SConrad Meyer 				inet_aton(arg, &conf.kda_gateway.in4);
709e5054602SMark Johnston 				freeenv(arg);
710e5054602SMark Johnston 			}
7116b6e2954SConrad Meyer 			conf.kda_af = AF_INET;
712e5054602SMark Johnston 
713e5054602SMark Johnston 			/* Ignore errors; we print a message to the console. */
71464e7d18fSConrad Meyer 			NETDUMP_WLOCK();
7158270d35eSConrad Meyer 			(void)netdump_configure(&conf, NULL);
71664e7d18fSConrad Meyer 			NETDUMP_WUNLOCK();
717e5054602SMark Johnston 		}
718e5054602SMark Johnston 		break;
719e5054602SMark Johnston 	case MOD_UNLOAD:
72064e7d18fSConrad Meyer 		NETDUMP_WLOCK();
72164e7d18fSConrad Meyer 		if (netdump_enabled()) {
722e5054602SMark Johnston 			printf("netdump: disabling dump device for unload\n");
72364e7d18fSConrad Meyer 			netdump_unconfigure();
724e5054602SMark Johnston 		}
72564e7d18fSConrad Meyer 		NETDUMP_WUNLOCK();
7266b6e2954SConrad Meyer 		destroy_dev(netdump_cdev);
72764e7d18fSConrad Meyer 		EVENTHANDLER_DEREGISTER(ifnet_departure_event,
72864e7d18fSConrad Meyer 		    nd_detach_cookie);
729e5054602SMark Johnston 		break;
730e5054602SMark Johnston 	default:
731e5054602SMark Johnston 		error = EOPNOTSUPP;
732e5054602SMark Johnston 		break;
733e5054602SMark Johnston 	}
734e5054602SMark Johnston 	return (error);
735e5054602SMark Johnston }
736e5054602SMark Johnston 
737e5054602SMark Johnston static moduledata_t netdump_mod = {
738e5054602SMark Johnston 	"netdump",
739e5054602SMark Johnston 	netdump_modevent,
740e5054602SMark Johnston 	NULL,
741e5054602SMark Johnston };
742e5054602SMark Johnston 
743e5054602SMark Johnston MODULE_VERSION(netdump, 1);
744e5054602SMark Johnston DECLARE_MODULE(netdump, netdump_mod, SI_SUB_PSEUDO, SI_ORDER_ANY);
7458270d35eSConrad Meyer 
7468270d35eSConrad Meyer #ifdef DDB
7478270d35eSConrad Meyer /*
7488270d35eSConrad Meyer  * Usage: netdump -s <server> [-g <gateway] -c <localip> -i <interface>
7498270d35eSConrad Meyer  *
7508270d35eSConrad Meyer  * Order is not significant.
7518270d35eSConrad Meyer  *
7528270d35eSConrad Meyer  * Currently, this command does not support configuring encryption or
7538270d35eSConrad Meyer  * compression.
7548270d35eSConrad Meyer  */
7558270d35eSConrad Meyer DB_FUNC(netdump, db_netdump_cmd, db_cmd_table, CS_OWN, NULL)
7568270d35eSConrad Meyer {
7578270d35eSConrad Meyer 	static struct diocskerneldump_arg conf;
7588270d35eSConrad Meyer 	static char blockbuf[NETDUMP_DATASIZE];
7598270d35eSConrad Meyer 	static union {
7608270d35eSConrad Meyer 		struct dumperinfo di;
7618270d35eSConrad Meyer 		/* For valid di_devname. */
7628270d35eSConrad Meyer 		char di_buf[sizeof(struct dumperinfo) + 1];
7638270d35eSConrad Meyer 	} u;
7648270d35eSConrad Meyer 
7658270d35eSConrad Meyer 	struct debugnet_ddb_config params;
7668270d35eSConrad Meyer 	int error;
7678270d35eSConrad Meyer 
7688270d35eSConrad Meyer 	error = debugnet_parse_ddb_cmd("netdump", &params);
7698270d35eSConrad Meyer 	if (error != 0) {
7708270d35eSConrad Meyer 		db_printf("Error configuring netdump: %d\n", error);
7718270d35eSConrad Meyer 		return;
7728270d35eSConrad Meyer 	}
7738270d35eSConrad Meyer 
7748270d35eSConrad Meyer 	/* Translate to a netdump dumper config. */
7758270d35eSConrad Meyer 	memset(&conf, 0, sizeof(conf));
776fde2cf65SConrad Meyer 
777fde2cf65SConrad Meyer 	if (params.dd_ifp != NULL)
778fde2cf65SConrad Meyer 		strlcpy(conf.kda_iface, if_name(params.dd_ifp),
779fde2cf65SConrad Meyer 		    sizeof(conf.kda_iface));
7808270d35eSConrad Meyer 
7818270d35eSConrad Meyer 	conf.kda_af = AF_INET;
7828270d35eSConrad Meyer 	conf.kda_server.in4 = (struct in_addr) { params.dd_server };
783fde2cf65SConrad Meyer 	if (params.dd_has_client)
7848270d35eSConrad Meyer 		conf.kda_client.in4 = (struct in_addr) { params.dd_client };
785fde2cf65SConrad Meyer 	else
786fde2cf65SConrad Meyer 		conf.kda_client.in4 = (struct in_addr) { INADDR_ANY };
7878270d35eSConrad Meyer 	if (params.dd_has_gateway)
7888270d35eSConrad Meyer 		conf.kda_gateway.in4 = (struct in_addr) { params.dd_gateway };
7898270d35eSConrad Meyer 	else
7908270d35eSConrad Meyer 		conf.kda_gateway.in4 = (struct in_addr) { INADDR_ANY };
7918270d35eSConrad Meyer 
7928270d35eSConrad Meyer 	/* Set the global netdump config to these options. */
7938270d35eSConrad Meyer 	error = netdump_configure(&conf, NULL);
7948270d35eSConrad Meyer 	if (error != 0) {
7958270d35eSConrad Meyer 		db_printf("Error enabling netdump: %d\n", error);
7968270d35eSConrad Meyer 		return;
7978270d35eSConrad Meyer 	}
7988270d35eSConrad Meyer 
7998270d35eSConrad Meyer 	/* Fake the generic dump configuration list entry to avoid malloc. */
8008270d35eSConrad Meyer 	memset(&u.di_buf, 0, sizeof(u.di_buf));
8018270d35eSConrad Meyer 	u.di.dumper_start = netdump_start;
8028270d35eSConrad Meyer 	u.di.dumper_hdr = netdump_write_headers;
8038270d35eSConrad Meyer 	u.di.dumper = netdump_dumper;
8048270d35eSConrad Meyer 	u.di.priv = NULL;
8058270d35eSConrad Meyer 	u.di.blocksize = NETDUMP_DATASIZE;
8068270d35eSConrad Meyer 	u.di.maxiosize = MAXDUMPPGS * PAGE_SIZE;
8078270d35eSConrad Meyer 	u.di.mediaoffset = 0;
8088270d35eSConrad Meyer 	u.di.mediasize = 0;
8098270d35eSConrad Meyer 	u.di.blockbuf = blockbuf;
8108270d35eSConrad Meyer 
8118270d35eSConrad Meyer 	dumper_ddb_insert(&u.di);
8128270d35eSConrad Meyer 
8138270d35eSConrad Meyer 	error = doadump(false);
8148270d35eSConrad Meyer 
8158270d35eSConrad Meyer 	dumper_ddb_remove(&u.di);
8168270d35eSConrad Meyer 	if (error != 0)
8178270d35eSConrad Meyer 		db_printf("Cannot dump: %d\n", error);
8188270d35eSConrad Meyer }
8198270d35eSConrad Meyer #endif /* DDB */
820