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 /* 23 * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #pragma ident "%Z%%M% %I% %E% SMI" 28 29 /* 30 * A CPR derivative specifically for sbd 31 */ 32 33 #include <sys/types.h> 34 #include <sys/systm.h> 35 #include <sys/machparam.h> 36 #include <sys/machsystm.h> 37 #include <sys/ddi.h> 38 #define SUNDDI_IMPL 39 #include <sys/sunddi.h> 40 #include <sys/sunndi.h> 41 #include <sys/devctl.h> 42 #include <sys/time.h> 43 #include <sys/kmem.h> 44 #include <nfs/lm.h> 45 #include <sys/ddi_impldefs.h> 46 #include <sys/ndi_impldefs.h> 47 #include <sys/obpdefs.h> 48 #include <sys/cmn_err.h> 49 #include <sys/debug.h> 50 #include <sys/errno.h> 51 #include <sys/callb.h> 52 #include <sys/clock.h> 53 #include <sys/x_call.h> 54 #include <sys/cpuvar.h> 55 #include <sys/epm.h> 56 #include <sys/vfs.h> 57 58 #ifdef DEBUG 59 #include <sys/note.h> 60 #endif 61 62 #include <sys/promif.h> 63 #include <sys/conf.h> 64 #include <sys/cyclic.h> 65 66 #include <sys/sbd_ioctl.h> 67 #include <sys/sbd.h> 68 #include <sys/sbdp_priv.h> 69 #include <sys/cpu_sgnblk_defs.h> 70 71 static char * 72 sbdp_get_err_buf(sbd_error_t *ep) 73 { 74 return (ep->e_rsc); 75 } 76 77 extern void e_ddi_enter_driver_list(struct devnames *dnp, int *listcnt); 78 extern void e_ddi_exit_driver_list(struct devnames *dnp, int listcnt); 79 extern int is_pseudo_device(dev_info_t *dip); 80 81 extern kmutex_t cpu_lock; 82 83 static int sbdp_is_real_device(dev_info_t *dip); 84 #ifdef DEBUG 85 static int sbdp_bypass_device(char *dname); 86 #endif 87 static int sbdp_check_dip(dev_info_t *dip, void *arg, uint_t ref); 88 89 static int sbdp_resolve_devname(dev_info_t *dip, char *buffer, 90 char *alias); 91 92 int sbdp_test_suspend(sbdp_handle_t *hp); 93 94 #define SR_STATE(srh) ((srh)->sr_suspend_state) 95 #define SR_SET_STATE(srh, state) (SR_STATE((srh)) = (state)) 96 #define SR_FAILED_DIP(srh) ((srh)->sr_failed_dip) 97 98 #define SR_FLAG_WATCHDOG 0x1 99 #define SR_CHECK_FLAG(srh, flag) ((srh)->sr_flags & (flag)) 100 #define SR_SET_FLAG(srh, flag) ((srh)->sr_flags |= (flag)) 101 #define SR_CLEAR_FLAG(srh, flag) ((srh)->sr_flags &= ~(flag)) 102 103 #ifdef DEBUG 104 /* 105 * Just for testing. List of drivers to bypass when performing a suspend. 106 */ 107 static char *sbdp_bypass_list[] = { 108 /* "sgsbbc", this is an example when needed */ 109 "" 110 }; 111 #endif 112 113 #define SKIP_SYNC /* bypass sync ops in sbdp_suspend */ 114 115 /* 116 * sbdp_skip_user_threads is used to control if user threads should 117 * be suspended. If sbdp_skip_user_threads is true, the rest of the 118 * flags are not used; if it is false, sbdp_check_user_stop_result 119 * will be used to control whether or not we need to check suspend 120 * result, and sbdp_allow_blocked_threads will be used to control 121 * whether or not we allow suspend to continue if there are blocked 122 * threads. We allow all combinations of sbdp_check_user_stop_result 123 * and sbdp_allow_block_threads, even though it might not make much 124 * sense to not allow block threads when we don't even check stop 125 * result. 126 */ 127 static int sbdp_skip_user_threads = 0; /* default to FALSE */ 128 static int sbdp_check_user_stop_result = 1; /* default to TRUE */ 129 static int sbdp_allow_blocked_threads = 1; /* default to TRUE */ 130 131 132 static void 133 sbdp_stop_intr(void) 134 { 135 kpreempt_disable(); 136 cyclic_suspend(); 137 } 138 139 static void 140 sbdp_enable_intr(void) 141 { 142 cyclic_resume(); 143 kpreempt_enable(); 144 } 145 146 sbdp_sr_handle_t * 147 sbdp_get_sr_handle(void) 148 { 149 sbdp_sr_handle_t *srh; 150 srh = kmem_zalloc(sizeof (sbdp_sr_handle_t), KM_SLEEP); 151 152 return (srh); 153 } 154 155 void 156 sbdp_release_sr_handle(sbdp_sr_handle_t *srh) 157 { 158 ASSERT(SR_FAILED_DIP(srh) == NULL); 159 kmem_free((caddr_t)srh, sizeof (sbdp_sr_handle_t)); 160 } 161 162 static int 163 sbdp_is_real_device(dev_info_t *dip) 164 { 165 struct regspec *regbuf = NULL; 166 int length = 0; 167 int rc; 168 169 if (ddi_get_driver(dip) == NULL) 170 return (0); 171 172 if (DEVI(dip)->devi_pm_flags & (PMC_NEEDS_SR|PMC_PARENTAL_SR)) 173 return (1); 174 if (DEVI(dip)->devi_pm_flags & PMC_NO_SR) 175 return (0); 176 177 /* 178 * now the general case 179 */ 180 rc = ddi_getlongprop(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, "reg", 181 (caddr_t)®buf, &length); 182 ASSERT(rc != DDI_PROP_NO_MEMORY); 183 if (rc != DDI_PROP_SUCCESS) { 184 return (0); 185 } else { 186 if ((length > 0) && (regbuf != NULL)) 187 kmem_free(regbuf, length); 188 return (1); 189 } 190 } 191 192 #ifdef DEBUG 193 static int 194 sbdp_bypass_device(char *dname) 195 { 196 int i; 197 char **lname; 198 /* check the bypass list */ 199 for (i = 0, lname = &sbdp_bypass_list[i]; **lname != '\0'; lname++) { 200 SBDP_DBG_QR("Checking %s\n", *lname); 201 if (strcmp(dname, sbdp_bypass_list[i++]) == 0) 202 return (1); 203 } 204 return (0); 205 } 206 #endif 207 208 static int 209 sbdp_resolve_devname(dev_info_t *dip, char *buffer, char *alias) 210 { 211 major_t devmajor; 212 char *aka, *name; 213 214 *buffer = *alias = 0; 215 216 if (dip == NULL) 217 return (-1); 218 219 if ((name = ddi_get_name(dip)) == NULL) 220 name = "<null name>"; 221 222 aka = name; 223 224 if ((devmajor = ddi_name_to_major(aka)) != -1) 225 aka = ddi_major_to_name(devmajor); 226 227 (void) strcpy(buffer, name); 228 229 if (strcmp(name, aka)) 230 (void) strcpy(alias, aka); 231 else 232 *alias = 0; 233 234 return (0); 235 } 236 237 typedef struct sbdp_ref { 238 int *refcount; 239 sbd_error_t *sep; 240 } sbdp_ref_t; 241 242 static int 243 sbdp_check_dip(dev_info_t *dip, void *arg, uint_t ref) 244 { 245 char *dname; 246 sbdp_ref_t *sbrp = (sbdp_ref_t *)arg; 247 248 if (dip == NULL) 249 return (DDI_WALK_CONTINUE); 250 251 ASSERT(sbrp->sep != NULL); 252 ASSERT(sbrp->refcount != NULL); 253 254 if (!sbdp_is_real_device(dip)) 255 return (DDI_WALK_CONTINUE); 256 257 dname = ddi_binding_name(dip); 258 259 if ((strcmp(dname, "pciclass,060940") == 0) || (strcmp(dname, 260 "pciclass,060980") == 0)) { 261 (void) ddi_pathname(dip, sbdp_get_err_buf(sbrp->sep)); 262 sbdp_set_err(sbrp->sep, ESBD_BUSY, NULL); 263 (*sbrp->refcount)++; 264 return (DDI_WALK_TERMINATE); 265 } 266 267 #ifdef DEBUG 268 if (sbdp_bypass_device(dname)) 269 return (DDI_WALK_CONTINUE); 270 #endif 271 272 if (ref) { 273 (*sbrp->refcount)++; 274 SBDP_DBG_QR("\n%s (major# %d) is referenced\n", 275 dname, ddi_name_to_major(dname)); 276 (void) ddi_pathname(dip, sbdp_get_err_buf(sbrp->sep)); 277 sbdp_set_err(sbrp->sep, ESBD_BUSY, NULL); 278 return (DDI_WALK_TERMINATE); 279 } 280 return (DDI_WALK_CONTINUE); 281 } 282 283 void 284 sbdp_check_devices(dev_info_t *dip, int *refcount, sbd_error_t *sep) 285 { 286 sbdp_ref_t sbr; 287 288 sbr.refcount = refcount; 289 sbr.sep = sep; 290 291 ASSERT(e_ddi_branch_held(dip)); 292 293 (void) e_ddi_branch_referenced(dip, sbdp_check_dip, &sbr); 294 } 295 296 /* 297 * Starting from the root node suspend all devices in the device tree. 298 * Assumes that all devices have already been marked busy. 299 */ 300 static int 301 sbdp_suspend_devices_(dev_info_t *dip, sbdp_sr_handle_t *srh) 302 { 303 major_t major; 304 char *dname; 305 306 for (; dip != NULL; dip = ddi_get_next_sibling(dip)) { 307 char d_name[40], d_alias[40], *d_info; 308 309 if (sbdp_suspend_devices_(ddi_get_child(dip), srh)) { 310 return (ENXIO); 311 } 312 313 if (!sbdp_is_real_device(dip)) 314 continue; 315 316 major = (major_t)-1; 317 if ((dname = DEVI(dip)->devi_binding_name) != NULL) 318 major = ddi_name_to_major(dname); 319 320 #ifdef DEBUG 321 if (sbdp_bypass_device(dname)) { 322 SBDP_DBG_QR("bypassed suspend of %s (major# %d)\n", 323 dname, major); 324 continue; 325 } 326 #endif 327 328 if ((d_info = ddi_get_name_addr(dip)) == NULL) 329 d_info = "<null>"; 330 331 d_name[0] = 0; 332 if (sbdp_resolve_devname(dip, d_name, d_alias) == 0) { 333 if (d_alias[0] != 0) { 334 SBDP_DBG_QR("\tsuspending %s@%s (aka %s)\n", 335 d_name, d_info, d_alias); 336 } else { 337 SBDP_DBG_QR("\tsuspending %s@%s\n", 338 d_name, d_info); 339 } 340 } else { 341 SBDP_DBG_QR("\tsuspending %s@%s\n", dname, d_info); 342 } 343 344 if (devi_detach(dip, DDI_SUSPEND) != DDI_SUCCESS) { 345 (void) sprintf(sbdp_get_err_buf(&srh->sep), 346 "%d", major); 347 348 sbdp_set_err(&srh->sep, ESGT_SUSPEND, NULL); 349 ndi_hold_devi(dip); 350 SR_FAILED_DIP(srh) = dip; 351 return (DDI_FAILURE); 352 } 353 } 354 355 return (DDI_SUCCESS); 356 } 357 358 /*ARGSUSED*/ 359 static int 360 sbdp_suspend_devices_enter(dev_info_t *dip, void *arg) 361 { 362 struct dev_info *devi = DEVI(dip); 363 ndi_devi_enter(dip, &devi->devi_circular); 364 return (DDI_WALK_CONTINUE); 365 } 366 367 /*ARGSUSED*/ 368 static int 369 sbdp_suspend_devices_exit(dev_info_t *dip, void *arg) 370 { 371 struct dev_info *devi = DEVI(dip); 372 ndi_devi_exit(dip, devi->devi_circular); 373 return (DDI_WALK_CONTINUE); 374 } 375 376 /* 377 * Before suspending devices first mark all device nodes busy. This 378 * avoids a deadlock situation when another thread holds a device busy 379 * and accesses an already suspended device. 380 */ 381 static int 382 sbdp_suspend_devices(dev_info_t *dip, sbdp_sr_handle_t *srh) 383 { 384 int rv; 385 386 /* assumes dip is ddi_root_node so no ndi_devi_enter required */ 387 ASSERT(dip == ddi_root_node()); 388 ddi_walk_devs(dip, sbdp_suspend_devices_enter, NULL); 389 rv = sbdp_suspend_devices_(dip, srh); 390 ddi_walk_devs(dip, sbdp_suspend_devices_exit, NULL); 391 return (rv); 392 } 393 394 static void 395 sbdp_resume_devices(dev_info_t *start, sbdp_sr_handle_t *srh) 396 { 397 int circ; 398 dev_info_t *dip, *next, *last = NULL; 399 char *bn; 400 sbd_error_t *sep; 401 402 sep = &srh->sep; 403 404 /* attach in reverse device tree order */ 405 while (last != start) { 406 dip = start; 407 next = ddi_get_next_sibling(dip); 408 while (next != last && dip != SR_FAILED_DIP(srh)) { 409 dip = next; 410 next = ddi_get_next_sibling(dip); 411 } 412 if (dip == SR_FAILED_DIP(srh)) { 413 /* Release hold acquired in sbdp_suspend_devices() */ 414 ndi_rele_devi(dip); 415 SR_FAILED_DIP(srh) = NULL; 416 } else if (sbdp_is_real_device(dip) && 417 SR_FAILED_DIP(srh) == NULL) { 418 419 if (DEVI(dip)->devi_binding_name != NULL) { 420 bn = ddi_binding_name(dip); 421 } 422 #ifdef DEBUG 423 if (!sbdp_bypass_device(bn)) { 424 #else 425 { 426 #endif 427 char d_name[40], d_alias[40], *d_info; 428 429 d_name[0] = 0; 430 d_info = ddi_get_name_addr(dip); 431 if (d_info == NULL) 432 d_info = "<null>"; 433 434 if (!sbdp_resolve_devname(dip, d_name, 435 d_alias)) { 436 if (d_alias[0] != 0) { 437 SBDP_DBG_QR("\tresuming " 438 "%s@%s (aka %s)\n", 439 d_name, d_info, 440 d_alias); 441 } else { 442 SBDP_DBG_QR("\tresuming " 443 "%s@%s\n", 444 d_name, d_info); 445 } 446 } else { 447 SBDP_DBG_QR("\tresuming %s@%s\n", 448 bn, d_info); 449 } 450 451 if (devi_attach(dip, DDI_RESUME) != 452 DDI_SUCCESS) { 453 /* 454 * Print a console warning, 455 * set an errno of ESGT_RESUME, 456 * and save the driver major 457 * number in the e_str. 458 */ 459 460 (void) sprintf(sbdp_get_err_buf(sep), 461 "%s@%s", 462 d_name[0] ? d_name : bn, d_info); 463 SBDP_DBG_QR("\tFAILED to resume " 464 "%s\n", sbdp_get_err_buf(sep)); 465 sbdp_set_err(sep, 466 ESGT_RESUME, NULL); 467 } 468 } 469 } 470 ndi_devi_enter(dip, &circ); 471 sbdp_resume_devices(ddi_get_child(dip), srh); 472 ndi_devi_exit(dip, circ); 473 last = dip; 474 } 475 } 476 477 /* 478 * True if thread is virtually stopped. Similar to CPR_VSTOPPED 479 * but from DR point of view. These user threads are waiting in 480 * the kernel. Once they return from kernel, they will process 481 * the stop signal and stop. 482 */ 483 #define SBDP_VSTOPPED(t) \ 484 ((t)->t_state == TS_SLEEP && \ 485 (t)->t_wchan != NULL && \ 486 (t)->t_astflag && \ 487 ((t)->t_proc_flag & TP_CHKPT)) 488 489 490 static int 491 sbdp_stop_user_threads(sbdp_sr_handle_t *srh) 492 { 493 int count; 494 char cache_psargs[PSARGSZ]; 495 kthread_id_t cache_tp; 496 uint_t cache_t_state; 497 int bailout; 498 sbd_error_t *sep; 499 kthread_id_t tp; 500 501 extern void add_one_utstop(); 502 extern void utstop_timedwait(clock_t); 503 extern void utstop_init(void); 504 505 #define SBDP_UTSTOP_RETRY 4 506 #define SBDP_UTSTOP_WAIT hz 507 508 if (sbdp_skip_user_threads) 509 return (DDI_SUCCESS); 510 511 sep = &srh->sep; 512 ASSERT(sep); 513 514 utstop_init(); 515 516 /* we need to try a few times to get past fork, etc. */ 517 for (count = 0; count < SBDP_UTSTOP_RETRY; count++) { 518 /* walk the entire threadlist */ 519 mutex_enter(&pidlock); 520 for (tp = curthread->t_next; tp != curthread; tp = tp->t_next) { 521 proc_t *p = ttoproc(tp); 522 523 /* handle kernel threads separately */ 524 if (p->p_as == &kas || p->p_stat == SZOMB) 525 continue; 526 527 mutex_enter(&p->p_lock); 528 thread_lock(tp); 529 530 if (tp->t_state == TS_STOPPED) { 531 /* add another reason to stop this thread */ 532 tp->t_schedflag &= ~TS_RESUME; 533 } else { 534 tp->t_proc_flag |= TP_CHKPT; 535 536 thread_unlock(tp); 537 mutex_exit(&p->p_lock); 538 add_one_utstop(); 539 mutex_enter(&p->p_lock); 540 thread_lock(tp); 541 542 aston(tp); 543 544 if (tp->t_state == TS_SLEEP && 545 (tp->t_flag & T_WAKEABLE)) { 546 setrun_locked(tp); 547 } 548 549 } 550 551 /* grab thread if needed */ 552 if (tp->t_state == TS_ONPROC && tp->t_cpu != CPU) 553 poke_cpu(tp->t_cpu->cpu_id); 554 555 556 thread_unlock(tp); 557 mutex_exit(&p->p_lock); 558 } 559 mutex_exit(&pidlock); 560 561 562 /* let everything catch up */ 563 utstop_timedwait(count * count * SBDP_UTSTOP_WAIT); 564 565 566 /* now, walk the threadlist again to see if we are done */ 567 mutex_enter(&pidlock); 568 for (tp = curthread->t_next, bailout = 0; 569 tp != curthread; tp = tp->t_next) { 570 proc_t *p = ttoproc(tp); 571 572 /* handle kernel threads separately */ 573 if (p->p_as == &kas || p->p_stat == SZOMB) 574 continue; 575 576 /* 577 * If this thread didn't stop, and we don't allow 578 * unstopped blocked threads, bail. 579 */ 580 thread_lock(tp); 581 if (!CPR_ISTOPPED(tp) && 582 !(sbdp_allow_blocked_threads && 583 SBDP_VSTOPPED(tp))) { 584 585 /* nope, cache the details for later */ 586 bcopy(p->p_user.u_psargs, cache_psargs, 587 sizeof (cache_psargs)); 588 cache_tp = tp; 589 cache_t_state = tp->t_state; 590 bailout = 1; 591 } 592 thread_unlock(tp); 593 } 594 mutex_exit(&pidlock); 595 596 /* were all the threads stopped? */ 597 if (!bailout) 598 break; 599 } 600 601 /* were we unable to stop all threads after a few tries? */ 602 if (bailout) { 603 cmn_err(CE_NOTE, "process: %s id: %p state: %x\n", 604 cache_psargs, cache_tp, cache_t_state); 605 606 (void) sprintf(sbdp_get_err_buf(sep), "%s", cache_psargs); 607 sbdp_set_err(sep, ESGT_UTHREAD, NULL); 608 return (ESRCH); 609 } 610 611 return (DDI_SUCCESS); 612 } 613 614 static void 615 sbdp_start_user_threads(void) 616 { 617 kthread_id_t tp; 618 619 mutex_enter(&pidlock); 620 621 /* walk all threads and release them */ 622 for (tp = curthread->t_next; tp != curthread; tp = tp->t_next) { 623 proc_t *p = ttoproc(tp); 624 625 /* skip kernel threads */ 626 if (ttoproc(tp)->p_as == &kas) 627 continue; 628 629 mutex_enter(&p->p_lock); 630 tp->t_proc_flag &= ~TP_CHKPT; 631 mutex_exit(&p->p_lock); 632 633 thread_lock(tp); 634 if (CPR_ISTOPPED(tp)) { 635 /* back on the runq */ 636 tp->t_schedflag |= TS_RESUME; 637 setrun_locked(tp); 638 } 639 thread_unlock(tp); 640 } 641 642 mutex_exit(&pidlock); 643 } 644 645 static void 646 sbdp_signal_user(int sig) 647 { 648 struct proc *p; 649 650 mutex_enter(&pidlock); 651 652 for (p = practive; p != NULL; p = p->p_next) { 653 /* only user threads */ 654 if (p->p_exec == NULL || p->p_stat == SZOMB || 655 p == proc_init || p == ttoproc(curthread)) 656 continue; 657 658 mutex_enter(&p->p_lock); 659 sigtoproc(p, NULL, sig); 660 mutex_exit(&p->p_lock); 661 } 662 663 mutex_exit(&pidlock); 664 665 /* add a bit of delay */ 666 delay(hz); 667 } 668 669 static uint_t saved_watchdog_seconds; 670 671 void 672 sbdp_resume(sbdp_sr_handle_t *srh) 673 { 674 /* 675 * update the signature block 676 */ 677 CPU_SIGNATURE(OS_SIG, SIGST_RESUME_INPROGRESS, SIGSUBST_NULL, 678 CPU->cpu_id); 679 680 switch (SR_STATE(srh)) { 681 case SBDP_SRSTATE_FULL: 682 683 ASSERT(MUTEX_HELD(&cpu_lock)); 684 685 /* 686 * Prevent false alarm in tod_validate() due to tod 687 * value change between suspend and resume 688 */ 689 mutex_enter(&tod_lock); 690 tod_fault_reset(); 691 mutex_exit(&tod_lock); 692 693 sbdp_enable_intr(); /* enable intr & clock */ 694 695 /* 696 * release all the other cpus 697 * using start_cpus() vice sbdp_release_cpus() 698 */ 699 start_cpus(); 700 mutex_exit(&cpu_lock); 701 702 /* 703 * If we suspended hw watchdog at suspend, 704 * re-enable it now. 705 */ 706 if (SR_CHECK_FLAG(srh, SR_FLAG_WATCHDOG)) { 707 mutex_enter(&tod_lock); 708 tod_ops.tod_set_watchdog_timer( 709 saved_watchdog_seconds); 710 mutex_exit(&tod_lock); 711 } 712 713 /* FALLTHROUGH */ 714 715 case SBDP_SRSTATE_DRIVER: 716 /* 717 * resume devices: root node doesn't have to 718 * be held in any way. 719 */ 720 sbdp_resume_devices(ddi_root_node(), srh); 721 722 /* 723 * resume the lock manager 724 */ 725 lm_cprresume(); 726 727 /* FALLTHROUGH */ 728 729 case SBDP_SRSTATE_USER: 730 /* 731 * finally, resume user threads 732 */ 733 if (!sbdp_skip_user_threads) { 734 SBDP_DBG_QR("DR: resuming user threads...\n"); 735 sbdp_start_user_threads(); 736 } 737 /* FALLTHROUGH */ 738 739 case SBDP_SRSTATE_BEGIN: 740 default: 741 /* 742 * let those who care know that we've just resumed 743 */ 744 SBDP_DBG_QR("sending SIGTHAW...\n"); 745 sbdp_signal_user(SIGTHAW); 746 break; 747 } 748 749 /* 750 * update the signature block 751 */ 752 CPU_SIGNATURE(OS_SIG, SIGST_RUN, SIGSUBST_NULL, CPU->cpu_id); 753 754 SBDP_DBG_QR("DR: resume COMPLETED\n"); 755 } 756 757 int 758 sbdp_suspend(sbdp_sr_handle_t *srh) 759 { 760 int force; 761 int rc = DDI_SUCCESS; 762 763 force = (srh && (srh->sr_flags & SBDP_IOCTL_FLAG_FORCE)); 764 765 /* 766 * if no force flag, check for unsafe drivers 767 */ 768 if (force) { 769 SBDP_DBG_QR("\nsbdp_suspend invoked with force flag"); 770 } 771 772 /* 773 * update the signature block 774 */ 775 CPU_SIGNATURE(OS_SIG, SIGST_QUIESCE_INPROGRESS, SIGSUBST_NULL, 776 CPU->cpu_id); 777 778 /* 779 * first, stop all user threads 780 */ 781 SBDP_DBG_QR("SBDP: suspending user threads...\n"); 782 SR_SET_STATE(srh, SBDP_SRSTATE_USER); 783 if (((rc = sbdp_stop_user_threads(srh)) != DDI_SUCCESS) && 784 sbdp_check_user_stop_result) { 785 sbdp_resume(srh); 786 return (rc); 787 } 788 789 #ifndef SKIP_SYNC 790 /* 791 * This sync swap out all user pages 792 */ 793 vfs_sync(SYNC_ALL); 794 #endif 795 796 /* 797 * special treatment for lock manager 798 */ 799 lm_cprsuspend(); 800 801 #ifndef SKIP_SYNC 802 /* 803 * sync the file system in case we never make it back 804 */ 805 sync(); 806 807 #endif 808 /* 809 * now suspend drivers 810 */ 811 SBDP_DBG_QR("SBDP: suspending drivers...\n"); 812 SR_SET_STATE(srh, SBDP_SRSTATE_DRIVER); 813 814 /* 815 * Root node doesn't have to be held in any way. 816 */ 817 if ((rc = sbdp_suspend_devices(ddi_root_node(), srh)) != DDI_SUCCESS) { 818 sbdp_resume(srh); 819 return (rc); 820 } 821 822 /* 823 * finally, grab all cpus 824 */ 825 SR_SET_STATE(srh, SBDP_SRSTATE_FULL); 826 827 /* 828 * if watchdog was activated, disable it 829 */ 830 if (watchdog_activated) { 831 mutex_enter(&tod_lock); 832 saved_watchdog_seconds = tod_ops.tod_clear_watchdog_timer(); 833 mutex_exit(&tod_lock); 834 SR_SET_FLAG(srh, SR_FLAG_WATCHDOG); 835 } else { 836 SR_CLEAR_FLAG(srh, SR_FLAG_WATCHDOG); 837 } 838 839 mutex_enter(&cpu_lock); 840 pause_cpus(NULL); 841 sbdp_stop_intr(); 842 843 /* 844 * update the signature block 845 */ 846 CPU_SIGNATURE(OS_SIG, SIGST_QUIESCED, SIGSUBST_NULL, CPU->cpu_id); 847 848 return (rc); 849 } 850 851 /*ARGSUSED*/ 852 int 853 sbdp_test_suspend(sbdp_handle_t *hp) 854 { 855 sbdp_sr_handle_t *srh; 856 int err; 857 858 SBDP_DBG_QR("%s...\n", "sbdp_test_suspend"); 859 860 srh = sbdp_get_sr_handle(); 861 862 srh->sr_flags = hp->h_flags; 863 864 if ((err = sbdp_suspend(srh)) == DDI_SUCCESS) { 865 sbdp_resume(srh); 866 } else { 867 SBDP_DBG_MISC("sbdp_suspend() failed, err = 0x%x\n", err); 868 } 869 sbdp_release_sr_handle(srh); 870 871 return (0); 872 } 873 874 #ifdef DEBUG 875 int 876 sbdp_passthru_test_quiesce(sbdp_handle_t *hp, void *arg) 877 { 878 _NOTE(ARGUNUSED(arg)) 879 880 return (sbdp_test_suspend(hp)); 881 } 882 #endif 883