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", ¶ms); 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