1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2007 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #pragma ident "%Z%%M% %I% %E% SMI" 27 28 /* 29 * sun4v application watchdog driver 30 */ 31 32 #include <sys/types.h> 33 #include <sys/file.h> 34 #include <sys/errno.h> 35 #include <sys/open.h> 36 #include <sys/callb.h> 37 #include <sys/cred.h> 38 #include <sys/cyclic.h> 39 #include <sys/uio.h> 40 #include <sys/stat.h> 41 #include <sys/ksynch.h> 42 #include <sys/modctl.h> 43 #include <sys/conf.h> 44 #include <sys/devops.h> 45 #include <sys/debug.h> 46 #include <sys/cmn_err.h> 47 #include <sys/ddi.h> 48 #include <sys/reboot.h> 49 #include <sys/sunddi.h> 50 #include <sys/signal.h> 51 #include <sys/ntwdt.h> 52 #include <sys/note.h> 53 54 /* 55 * tunables 56 */ 57 int ntwdt_disable_timeout_action = 0; 58 59 #ifdef DEBUG 60 61 int ntwdt_debug = 0; /* ntwdt debug flag, dbg all for now. */ 62 63 /* 64 * Flags to set in ntwdt_debug. 65 */ 66 #define NTWDT_DBG_ENTRY 0x00000001 /* drv entry points */ 67 #define NTWDT_DBG_IOCTL 0x00000002 /* ioctl's */ 68 #define NTWDT_DBG_NTWDT 0x00000004 /* other ntwdt debug */ 69 70 #define NTWDT_DBG(flag, msg) \ 71 { if ((ntwdt_debug) & (flag)) (void) printf msg; } 72 #else /* DEBUG */ 73 #define NTWDT_DBG(flag, msg) 74 #endif /* DEBUG */ 75 76 #define NTWDT_MINOR_NODE "awdt" 77 #define getstate(minor) \ 78 ((ntwdt_state_t *)ddi_get_soft_state(ntwdt_statep, (minor))) 79 80 /* 81 * The ntwdt cyclic interval in nanosecond unit as cyclic subsystem supports 82 * nanosecond resolution. 83 */ 84 #define NTWDT_CYCLIC_INTERVAL NANOSEC /* 1 seconds */ 85 86 /* 87 * The ntwdt decrement interval in 1 second resolution. 88 */ 89 #define NTWDT_DECREMENT_INTERVAL 1 /* 1 second */ 90 91 /* 92 * ntwdt_watchdog_flags and macros to set/clear one bit in it. 93 */ 94 #define NTWDT_FLAG_SKIP_CYCLIC 0x1 /* skip next cyclic */ 95 96 #define NTWDT_MAX_TIMEOUT (3 * 60 * 60) /* 3 hours */ 97 98 #define WDT_MIN_COREAPI_MAJOR 1 99 #define WDT_MIN_COREAPI_MINOR 1 100 101 /* 102 * Application watchdog state. 103 */ 104 typedef struct ntwdt_runstate { 105 kmutex_t ntwdt_runstate_mutex; 106 ddi_iblock_cookie_t ntwdt_runstate_mtx_cookie; 107 int ntwdt_watchdog_enabled; /* wdog enabled ? */ 108 int ntwdt_reset_enabled; /* reset enabled ? */ 109 int ntwdt_timer_running; /* wdog running ? */ 110 int ntwdt_watchdog_expired; /* wdog expired ? */ 111 uint32_t ntwdt_time_remaining; /* expiration timer */ 112 uint32_t ntwdt_watchdog_timeout; /* timeout in seconds */ 113 hrtime_t ntwdt_cyclic_interval; /* cyclic interval */ 114 cyc_handler_t ntwdt_cycl_hdlr; 115 cyc_time_t ntwdt_cycl_time; 116 uint32_t ntwdt_watchdog_flags; 117 } ntwdt_runstate_t; 118 119 /* 120 * softstate of NTWDT 121 */ 122 typedef struct { 123 kmutex_t ntwdt_mutex; 124 dev_info_t *ntwdt_dip; /* dip */ 125 int ntwdt_open_flag; /* file open ? */ 126 ntwdt_runstate_t *ntwdt_run_state; /* wdog state */ 127 cyclic_id_t ntwdt_cycl_id; 128 } ntwdt_state_t; 129 130 static void *ntwdt_statep; /* softstate */ 131 static dev_info_t *ntwdt_dip; 132 133 static ddi_softintr_t ntwdt_cyclic_softint_id; 134 135 static int ntwdt_info(dev_info_t *, ddi_info_cmd_t, void *, void **); 136 static int ntwdt_attach(dev_info_t *, ddi_attach_cmd_t); 137 static int ntwdt_detach(dev_info_t *, ddi_detach_cmd_t); 138 static int ntwdt_open(dev_t *, int, int, cred_t *); 139 static int ntwdt_close(dev_t, int, int, cred_t *); 140 static int ntwdt_ioctl(dev_t, int, intptr_t, int, cred_t *, int *); 141 142 static int ntwdt_chk_watchdog_support(); 143 static void ntwdt_arm_watchdog(ntwdt_runstate_t *ntwdt_state); 144 static void ntwdt_cyclic_pat(void); 145 static uint_t ntwdt_cyclic_softint(caddr_t arg); 146 static void ntwdt_start_timer(ntwdt_state_t *ntwdt_ptr); 147 static void ntwdt_stop_timer_lock(void *arg); 148 static void ntwdt_stop_timer(void *arg); 149 static void ntwdt_enforce_timeout(); 150 151 static struct cb_ops ntwdt_cb_ops = { 152 ntwdt_open, /* cb_open */ 153 ntwdt_close, /* cb_close */ 154 nodev, /* cb_strategy */ 155 nodev, /* cb_print */ 156 nodev, /* cb_dump */ 157 nodev, /* cb_read */ 158 nodev, /* cb_write */ 159 ntwdt_ioctl, /* cb_ioctl */ 160 nodev, /* cb_devmap */ 161 nodev, /* cb_mmap */ 162 nodev, /* cb_segmap */ 163 nochpoll, /* cb_chpoll */ 164 ddi_prop_op, /* cb_prop_op */ 165 NULL, /* cb_str */ 166 D_NEW | D_MP /* cb_flag */ 167 }; 168 169 static struct dev_ops ntwdt_dev_ops = { 170 DEVO_REV, /* devo_rev */ 171 0, /* devo_refcnt */ 172 ntwdt_info, /* devo_info */ 173 nulldev, /* devo_identify */ 174 nulldev, /* devo_probe */ 175 ntwdt_attach, /* devo_attach */ 176 ntwdt_detach, /* devo_detach */ 177 nodev, /* devo_reset */ 178 &ntwdt_cb_ops, /* devo_cb_ops */ 179 NULL, /* devo_bus_ops */ 180 nulldev /* devo_power */ 181 }; 182 183 static struct modldrv modldrv = { 184 &mod_driverops, 185 "Application Watchdog Driver 1.1", 186 &ntwdt_dev_ops 187 }; 188 189 static struct modlinkage modlinkage = { 190 MODREV_1, 191 (void *)&modldrv, 192 NULL 193 }; 194 195 int 196 _init(void) 197 { 198 int error = 0; 199 200 NTWDT_DBG(NTWDT_DBG_ENTRY, ("_init")); 201 202 /* Initialize the soft state structures */ 203 if ((error = ddi_soft_state_init(&ntwdt_statep, 204 sizeof (ntwdt_state_t), 1)) != 0) { 205 return (error); 206 } 207 208 /* Install the loadable module */ 209 if ((error = mod_install(&modlinkage)) != 0) { 210 ddi_soft_state_fini(&ntwdt_statep); 211 } 212 return (error); 213 } 214 215 int 216 _info(struct modinfo *modinfop) 217 { 218 NTWDT_DBG(NTWDT_DBG_ENTRY, ("_info")); 219 220 return (mod_info(&modlinkage, modinfop)); 221 } 222 223 int 224 _fini(void) 225 { 226 int retval; 227 228 NTWDT_DBG(NTWDT_DBG_ENTRY, ("_fini")); 229 230 if ((retval = mod_remove(&modlinkage)) == 0) { 231 ddi_soft_state_fini(&ntwdt_statep); 232 } 233 234 return (retval); 235 } 236 237 static int 238 ntwdt_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) 239 { 240 int instance; 241 ntwdt_state_t *ntwdt_ptr = NULL; /* pointer to ntwdt_runstatep */ 242 ntwdt_runstate_t *ntwdt_runstatep = NULL; 243 cyc_handler_t *hdlr = NULL; 244 245 switch (cmd) { 246 case DDI_ATTACH: 247 break; 248 249 case DDI_RESUME: 250 return (DDI_SUCCESS); 251 252 default: 253 return (DDI_FAILURE); 254 } 255 256 if (ntwdt_chk_watchdog_support() != 0) { 257 return (DDI_FAILURE); 258 } 259 260 instance = ddi_get_instance(dip); 261 ASSERT(instance == 0); 262 263 if (ddi_soft_state_zalloc(ntwdt_statep, instance) != DDI_SUCCESS) { 264 return (DDI_FAILURE); 265 } 266 ntwdt_ptr = ddi_get_soft_state(ntwdt_statep, instance); 267 ASSERT(ntwdt_ptr != NULL); 268 269 ntwdt_dip = dip; 270 271 ntwdt_ptr->ntwdt_dip = dip; 272 ntwdt_ptr->ntwdt_cycl_id = CYCLIC_NONE; 273 mutex_init(&ntwdt_ptr->ntwdt_mutex, NULL, 274 MUTEX_DRIVER, NULL); 275 276 /* 277 * Initialize the watchdog structure 278 */ 279 ntwdt_ptr->ntwdt_run_state = 280 kmem_zalloc(sizeof (ntwdt_runstate_t), KM_SLEEP); 281 ntwdt_runstatep = ntwdt_ptr->ntwdt_run_state; 282 283 if (ddi_get_soft_iblock_cookie(dip, DDI_SOFTINT_LOW, 284 &ntwdt_runstatep->ntwdt_runstate_mtx_cookie) != DDI_SUCCESS) { 285 cmn_err(CE_WARN, "init of iblock cookie failed " 286 "for ntwdt_runstate_mutex"); 287 goto err1; 288 } else { 289 mutex_init(&ntwdt_runstatep->ntwdt_runstate_mutex, 290 NULL, 291 MUTEX_DRIVER, 292 (void *)ntwdt_runstatep->ntwdt_runstate_mtx_cookie); 293 } 294 295 /* Cyclic fires once per second: */ 296 ntwdt_runstatep->ntwdt_cyclic_interval = NTWDT_CYCLIC_INTERVAL; 297 298 /* init the Cyclic that drives the NTWDT */ 299 hdlr = &ntwdt_runstatep->ntwdt_cycl_hdlr; 300 hdlr->cyh_level = CY_LOCK_LEVEL; 301 hdlr->cyh_func = (cyc_func_t)ntwdt_cyclic_pat; 302 hdlr->cyh_arg = NULL; 303 304 /* Softint that will be triggered by Cyclic that drives NTWDT */ 305 if (ddi_add_softintr(dip, DDI_SOFTINT_LOW, &ntwdt_cyclic_softint_id, 306 NULL, NULL, ntwdt_cyclic_softint, (caddr_t)ntwdt_ptr) 307 != DDI_SUCCESS) { 308 cmn_err(CE_WARN, "failed to add cyclic softintr"); 309 goto err2; 310 } 311 312 /* 313 * Create Minor Node as last activity. This prevents 314 * application from accessing our implementation until it 315 * is initialized. 316 */ 317 if (ddi_create_minor_node(dip, NTWDT_MINOR_NODE, S_IFCHR, 0, 318 DDI_PSEUDO, NULL) == DDI_FAILURE) { 319 cmn_err(CE_WARN, "failed to create Minor Node: %s", 320 NTWDT_MINOR_NODE); 321 goto err3; 322 } 323 324 /* Display our driver info in the banner */ 325 ddi_report_dev(dip); 326 327 return (DDI_SUCCESS); 328 329 err3: 330 ddi_remove_softintr(ntwdt_cyclic_softint_id); 331 err2: 332 mutex_destroy(&ntwdt_runstatep->ntwdt_runstate_mutex); 333 err1: 334 /* clean up the driver stuff here */ 335 kmem_free(ntwdt_runstatep, sizeof (ntwdt_runstate_t)); 336 ntwdt_ptr->ntwdt_run_state = NULL; 337 mutex_destroy(&ntwdt_ptr->ntwdt_mutex); 338 ddi_soft_state_free(ntwdt_statep, instance); 339 ntwdt_dip = NULL; 340 341 return (DDI_FAILURE); 342 } 343 344 /*ARGSUSED*/ 345 static int 346 ntwdt_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result) 347 { 348 dev_t dev; 349 int instance; 350 int error = DDI_SUCCESS; 351 352 switch (infocmd) { 353 case DDI_INFO_DEVT2DEVINFO: 354 dev = (dev_t)arg; 355 if (getminor(dev) == 0) { 356 *result = (void *)ntwdt_dip; 357 } else { 358 error = DDI_FAILURE; 359 } 360 break; 361 362 case DDI_INFO_DEVT2INSTANCE: 363 dev = (dev_t)arg; 364 instance = getminor(dev); 365 *result = (void *)(uintptr_t)instance; 366 break; 367 368 default: 369 error = DDI_FAILURE; 370 371 } 372 373 return (error); 374 } 375 376 /*ARGSUSED*/ 377 static int 378 ntwdt_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 379 { 380 int instance = ddi_get_instance(dip); 381 ntwdt_state_t *ntwdt_ptr = NULL; 382 383 ntwdt_ptr = ddi_get_soft_state(ntwdt_statep, instance); 384 if (ntwdt_ptr == NULL) { 385 return (DDI_FAILURE); 386 } 387 388 switch (cmd) { 389 case DDI_SUSPEND: 390 return (DDI_SUCCESS); 391 392 case DDI_DETACH: 393 /* 394 * release resources in opposite (LIFO) order as 395 * were allocated in attach. 396 */ 397 ddi_remove_minor_node(dip, NULL); 398 ntwdt_stop_timer_lock((void *)ntwdt_ptr); 399 ddi_remove_softintr(ntwdt_cyclic_softint_id); 400 401 mutex_destroy( 402 &ntwdt_ptr->ntwdt_run_state->ntwdt_runstate_mutex); 403 kmem_free(ntwdt_ptr->ntwdt_run_state, 404 sizeof (ntwdt_runstate_t)); 405 ntwdt_ptr->ntwdt_run_state = NULL; 406 407 mutex_destroy(&ntwdt_ptr->ntwdt_mutex); 408 409 ddi_soft_state_free(ntwdt_statep, instance); 410 411 ntwdt_dip = NULL; 412 return (DDI_SUCCESS); 413 414 default: 415 return (DDI_FAILURE); 416 } 417 } 418 419 /*ARGSUSED*/ 420 static int 421 ntwdt_open(dev_t *devp, int flag, int otyp, cred_t *credp) 422 { 423 int instance = getminor(*devp); 424 int retval = 0; 425 ntwdt_state_t *ntwdt_ptr = getstate(instance); 426 427 if (ntwdt_ptr == NULL) { 428 return (ENXIO); 429 } 430 431 /* 432 * ensure caller is a priviledged process. 433 */ 434 if (drv_priv(credp) != 0) { 435 return (EPERM); 436 } 437 438 mutex_enter(&ntwdt_ptr->ntwdt_mutex); 439 if (ntwdt_ptr->ntwdt_open_flag) { 440 retval = EAGAIN; 441 } else { 442 ntwdt_ptr->ntwdt_open_flag = 1; 443 } 444 mutex_exit(&ntwdt_ptr->ntwdt_mutex); 445 446 return (retval); 447 } 448 449 /*ARGSUSED*/ 450 static int 451 ntwdt_close(dev_t dev, int flag, int otyp, cred_t *credp) 452 { 453 int instance = getminor(dev); 454 ntwdt_state_t *ntwdt_ptr = getstate(instance); 455 456 if (ntwdt_ptr == NULL) { 457 return (ENXIO); 458 } 459 460 mutex_enter(&ntwdt_ptr->ntwdt_mutex); 461 ntwdt_ptr->ntwdt_open_flag = 0; 462 mutex_exit(&ntwdt_ptr->ntwdt_mutex); 463 464 return (0); 465 } 466 467 /*ARGSUSED*/ 468 static int 469 ntwdt_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp, 470 int *rvalp) 471 { 472 int instance = getminor(dev); 473 int retval = 0; 474 ntwdt_state_t *ntwdt_ptr = NULL; 475 ntwdt_runstate_t *ntwdt_state; 476 lom_dogstate_t lom_dogstate; 477 lom_dogctl_t lom_dogctl; 478 uint32_t lom_dogtime; 479 480 if ((ntwdt_ptr = getstate(instance)) == NULL) { 481 return (ENXIO); 482 } 483 484 ntwdt_state = ntwdt_ptr->ntwdt_run_state; 485 486 switch (cmd) { 487 case LOMIOCDOGSTATE: 488 mutex_enter(&ntwdt_state->ntwdt_runstate_mutex); 489 lom_dogstate.reset_enable = ntwdt_state->ntwdt_reset_enabled; 490 lom_dogstate.dog_enable = ntwdt_state->ntwdt_watchdog_enabled; 491 lom_dogstate.dog_timeout = ntwdt_state->ntwdt_watchdog_timeout; 492 mutex_exit(&ntwdt_state->ntwdt_runstate_mutex); 493 494 if (ddi_copyout((caddr_t)&lom_dogstate, (caddr_t)arg, 495 sizeof (lom_dogstate_t), mode) != 0) { 496 retval = EFAULT; 497 } 498 break; 499 500 case LOMIOCDOGCTL: 501 if (ddi_copyin((caddr_t)arg, (caddr_t)&lom_dogctl, 502 sizeof (lom_dogctl_t), mode) != 0) { 503 retval = EFAULT; 504 break; 505 } 506 507 NTWDT_DBG(NTWDT_DBG_IOCTL, ("reset_enable: %d, and dog_enable: " 508 "%d, watchdog_timeout %d", lom_dogctl.reset_enable, 509 lom_dogctl.dog_enable, 510 ntwdt_state->ntwdt_watchdog_timeout)); 511 /* 512 * ignore request to enable reset while disabling watchdog. 513 */ 514 if (!lom_dogctl.dog_enable && lom_dogctl.reset_enable) { 515 NTWDT_DBG(NTWDT_DBG_IOCTL, ("invalid combination of " 516 "reset_enable: %d, and dog_enable: %d", 517 lom_dogctl.reset_enable, 518 lom_dogctl.dog_enable)); 519 retval = EINVAL; 520 break; 521 } 522 523 mutex_enter(&ntwdt_state->ntwdt_runstate_mutex); 524 525 if (ntwdt_state->ntwdt_watchdog_timeout == 0) { 526 /* 527 * the LOMIOCDOGTIME has never been used to setup 528 * a valid timeout. 529 */ 530 NTWDT_DBG(NTWDT_DBG_IOCTL, ("timeout has not been set" 531 "watchdog_timeout: %d", 532 ntwdt_state->ntwdt_watchdog_timeout)); 533 retval = EINVAL; 534 goto end; 535 } 536 537 /* 538 * Store the user specified state in the softstate. 539 */ 540 ntwdt_state->ntwdt_reset_enabled = lom_dogctl.reset_enable; 541 ntwdt_state->ntwdt_watchdog_enabled = lom_dogctl.dog_enable; 542 543 if (ntwdt_state->ntwdt_watchdog_enabled != 0) { 544 /* 545 * The user wants to enable the watchdog. 546 * Arm the watchdog and start the cyclic. 547 */ 548 ntwdt_arm_watchdog(ntwdt_state); 549 550 if (ntwdt_state->ntwdt_timer_running == 0) { 551 ntwdt_start_timer(ntwdt_ptr); 552 } 553 554 NTWDT_DBG(NTWDT_DBG_IOCTL, ("AWDT is enabled")); 555 } else { 556 /* 557 * The user wants to disable the watchdog. 558 */ 559 if (ntwdt_state->ntwdt_timer_running != 0) { 560 ntwdt_stop_timer(ntwdt_ptr); 561 } 562 NTWDT_DBG(NTWDT_DBG_IOCTL, ("AWDT is disabled")); 563 } 564 565 mutex_exit(&ntwdt_state->ntwdt_runstate_mutex); 566 break; 567 568 case LOMIOCDOGTIME: 569 if (ddi_copyin((caddr_t)arg, (caddr_t)&lom_dogtime, 570 sizeof (uint32_t), mode) != 0) { 571 retval = EFAULT; 572 break; 573 } 574 575 NTWDT_DBG(NTWDT_DBG_IOCTL, ("user set timeout: %d", 576 lom_dogtime)); 577 578 /* 579 * Ensure specified timeout is valid. 580 */ 581 if ((lom_dogtime == 0) || 582 (lom_dogtime > (uint32_t)NTWDT_MAX_TIMEOUT)) { 583 retval = EINVAL; 584 NTWDT_DBG(NTWDT_DBG_IOCTL, ("user set invalid " 585 "timeout: %d", (int)TICK_TO_MSEC(lom_dogtime))); 586 break; 587 } 588 589 mutex_enter(&ntwdt_state->ntwdt_runstate_mutex); 590 591 ntwdt_state->ntwdt_watchdog_timeout = lom_dogtime; 592 593 /* 594 * If awdt is currently running, re-arm it with the 595 * newly-specified timeout value. 596 */ 597 if (ntwdt_state->ntwdt_timer_running != 0) { 598 ntwdt_arm_watchdog(ntwdt_state); 599 } 600 mutex_exit(&ntwdt_state->ntwdt_runstate_mutex); 601 break; 602 603 case LOMIOCDOGPAT: 604 /* 605 * Allow user to pat the watchdog timer. 606 */ 607 NTWDT_DBG(NTWDT_DBG_IOCTL, ("DOGPAT is invoked")); 608 mutex_enter(&ntwdt_state->ntwdt_runstate_mutex); 609 610 /* 611 * If awdt is not enabled or underlying cyclic is not 612 * running, exit. 613 */ 614 if (!(ntwdt_state->ntwdt_watchdog_enabled && 615 ntwdt_state->ntwdt_timer_running)) { 616 NTWDT_DBG(NTWDT_DBG_IOCTL, ("PAT: AWDT not enabled")); 617 goto end; 618 } 619 620 if (ntwdt_state->ntwdt_watchdog_expired == 0) { 621 /* 622 * re-arm the awdt. 623 */ 624 ntwdt_arm_watchdog(ntwdt_state); 625 NTWDT_DBG(NTWDT_DBG_IOCTL, ("AWDT patted, " 626 "remainning seconds: %d", 627 ntwdt_state->ntwdt_time_remaining)); 628 } 629 630 mutex_exit(&ntwdt_state->ntwdt_runstate_mutex); 631 break; 632 633 default: 634 retval = EINVAL; 635 break; 636 } 637 return (retval); 638 end: 639 mutex_exit(&ntwdt_state->ntwdt_runstate_mutex); 640 return (retval); 641 } 642 643 static void 644 ntwdt_cyclic_pat(void) 645 { 646 ddi_trigger_softintr(ntwdt_cyclic_softint_id); 647 } 648 649 static uint_t 650 ntwdt_cyclic_softint(caddr_t arg) 651 { 652 /*LINTED E_BAD_PTR_CAST_ALIGN*/ 653 ntwdt_state_t *ntwdt_ptr = (ntwdt_state_t *)arg; 654 ntwdt_runstate_t *ntwdt_state; 655 656 ntwdt_state = ntwdt_ptr->ntwdt_run_state; 657 658 mutex_enter(&ntwdt_state->ntwdt_runstate_mutex); 659 660 if ((ntwdt_state->ntwdt_watchdog_flags & NTWDT_FLAG_SKIP_CYCLIC) != 0) { 661 ntwdt_state->ntwdt_watchdog_flags &= ~NTWDT_FLAG_SKIP_CYCLIC; 662 goto end; 663 } 664 665 if ((ntwdt_state->ntwdt_timer_running == 0) || 666 (ntwdt_ptr->ntwdt_cycl_id == CYCLIC_NONE) || 667 (ntwdt_state->ntwdt_watchdog_enabled == 0)) { 668 goto end; 669 } 670 671 NTWDT_DBG(NTWDT_DBG_IOCTL, ("cyclic_softint: %d" 672 "lbolt64: %d\n", ntwdt_state->ntwdt_watchdog_timeout, 673 (int)TICK_TO_MSEC(lbolt64))); 674 675 /* 676 * Decrement the virtual watchdog timer and check if it has expired. 677 */ 678 ntwdt_state->ntwdt_time_remaining -= NTWDT_DECREMENT_INTERVAL; 679 680 if (ntwdt_state->ntwdt_time_remaining == 0) { 681 cmn_err(CE_WARN, "application-watchdog expired"); 682 ntwdt_state->ntwdt_watchdog_expired = 1; 683 684 if (ntwdt_state->ntwdt_reset_enabled != 0) { 685 /* 686 * The user wants to reset the system. 687 */ 688 mutex_exit(&ntwdt_state->ntwdt_runstate_mutex); 689 690 NTWDT_DBG(NTWDT_DBG_NTWDT, ("recovery being done")); 691 ntwdt_enforce_timeout(); 692 } else { 693 NTWDT_DBG(NTWDT_DBG_NTWDT, ("no recovery being done")); 694 ntwdt_state->ntwdt_watchdog_enabled = 0; 695 } 696 697 /* 698 * Schedule Callout to stop the cyclic. 699 */ 700 (void) timeout(ntwdt_stop_timer_lock, ntwdt_ptr, 0); 701 } else { 702 _NOTE(EMPTY) 703 NTWDT_DBG(NTWDT_DBG_NTWDT, ("time remaining in AWDT: %d secs", 704 (int)TICK_TO_MSEC(ntwdt_state->ntwdt_time_remaining))); 705 } 706 707 end: 708 mutex_exit(&ntwdt_state->ntwdt_runstate_mutex); 709 return (DDI_INTR_CLAIMED); 710 } 711 712 static void 713 ntwdt_arm_watchdog(ntwdt_runstate_t *ntwdt_state) 714 { 715 ntwdt_state->ntwdt_time_remaining = ntwdt_state->ntwdt_watchdog_timeout; 716 717 if (ntwdt_state->ntwdt_timer_running != 0) { 718 ntwdt_state->ntwdt_watchdog_flags |= NTWDT_FLAG_SKIP_CYCLIC; 719 } else { 720 ntwdt_state->ntwdt_watchdog_flags &= ~NTWDT_FLAG_SKIP_CYCLIC; 721 } 722 } 723 724 static void 725 ntwdt_start_timer(ntwdt_state_t *ntwdt_ptr) 726 { 727 ntwdt_runstate_t *ntwdt_state = ntwdt_ptr->ntwdt_run_state; 728 cyc_handler_t *hdlr = &ntwdt_state->ntwdt_cycl_hdlr; 729 cyc_time_t *when = &ntwdt_state->ntwdt_cycl_time; 730 731 /* 732 * Init the cyclic. 733 */ 734 when->cyt_interval = ntwdt_state->ntwdt_cyclic_interval; 735 when->cyt_when = gethrtime() + when->cyt_interval; 736 737 ntwdt_state->ntwdt_watchdog_expired = 0; 738 ntwdt_state->ntwdt_timer_running = 1; 739 740 mutex_enter(&cpu_lock); 741 if (ntwdt_ptr->ntwdt_cycl_id == CYCLIC_NONE) { 742 ntwdt_ptr->ntwdt_cycl_id = cyclic_add(hdlr, when); 743 } 744 mutex_exit(&cpu_lock); 745 746 NTWDT_DBG(NTWDT_DBG_NTWDT, ("cyclic-driven timer is started")); 747 } 748 749 static void 750 ntwdt_stop_timer(void *arg) 751 { 752 ntwdt_state_t *ntwdt_ptr = (ntwdt_state_t *)arg; 753 ntwdt_runstate_t *ntwdt_state = ntwdt_ptr->ntwdt_run_state; 754 755 mutex_enter(&cpu_lock); 756 if (ntwdt_ptr->ntwdt_cycl_id != CYCLIC_NONE) { 757 cyclic_remove(ntwdt_ptr->ntwdt_cycl_id); 758 } 759 mutex_exit(&cpu_lock); 760 761 ntwdt_state->ntwdt_watchdog_flags = 0; 762 ntwdt_state->ntwdt_timer_running = 0; 763 ntwdt_ptr->ntwdt_cycl_id = CYCLIC_NONE; 764 765 NTWDT_DBG(NTWDT_DBG_NTWDT, ("cyclic-driven timer is stopped")); 766 } 767 768 /* 769 * This is a wrapper function for ntwdt_stop_timer as some callers 770 * will already have the appropriate mutex locked, and others not. 771 */ 772 static void 773 ntwdt_stop_timer_lock(void *arg) 774 { 775 ntwdt_state_t *ntwdt_ptr = (ntwdt_state_t *)arg; 776 777 mutex_enter(&ntwdt_ptr->ntwdt_run_state->ntwdt_runstate_mutex); 778 ntwdt_stop_timer(arg); 779 mutex_exit(&ntwdt_ptr->ntwdt_run_state->ntwdt_runstate_mutex); 780 } 781 782 static void 783 ntwdt_enforce_timeout() 784 { 785 if (ntwdt_disable_timeout_action != 0) { 786 cmn_err(CE_NOTE, "Appication watchdog timer expired, " 787 "taking no action"); 788 return; 789 } 790 791 NTWDT_DBG(NTWDT_DBG_NTWDT, ("dump cores and rebooting ...")); 792 793 (void) kadmin(A_DUMP, AD_BOOT, NULL, kcred); 794 cmn_err(CE_PANIC, "kadmin(A_DUMP, AD_BOOT) failed"); 795 _NOTE(NOTREACHED); 796 } 797 798 static int 799 ntwdt_chk_watchdog_support() 800 { 801 int retval = 0; 802 803 if ((boothowto & RB_DEBUG) != 0) { 804 cmn_err(CE_WARN, "kernel debugger was booted; " 805 "application watchdog is not available."); 806 retval = ENOTSUP; 807 } 808 return (retval); 809 } 810