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