sys/netinet/netdump/netdump_client.c

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