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 2008 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #include <sys/types.h> 27 #include <sys/ksynch.h> 28 #include <sys/cmn_err.h> 29 #include <sys/errno.h> 30 #include <sys/kmem.h> 31 #include <sys/cred.h> 32 #include <sys/buf.h> 33 #include <sys/ddi.h> 34 #include <sys/nsc_thread.h> 35 36 37 #include "sd_bcache.h" 38 #include "sd_trace.h" 39 #include "sd_io.h" 40 #include "sd_bio.h" 41 #include "sd_ft.h" 42 #include "sd_misc.h" 43 #include "sd_pcu.h" 44 45 /* 46 * PCU (aka UPS) handling - 47 */ 48 #define bitmap_next cc_dirty_link 49 #define bitmap_tail cc_dirty_next 50 51 #define anon_next cc_dirty_link 52 #define anon_tail cc_dirty_next 53 #define anon_data cc_data 54 55 struct bitmap { 56 _sd_cctl_t *bmps; 57 int bmaps_per_block; 58 int inuse; /* In use in the _last_ block */ 59 }; 60 61 #define SDBC_PCU_MAXSWAPIL 3 /* Watch for 5 fields in ioctl arg. */ 62 63 struct swapfiles { 64 int nswpf; /* Number of filenames */ 65 int colsize; /* In cache blocks */ 66 char *names[SDBC_PCU_MAXSWAPIL]; 67 }; 68 69 static void _sdbc_pcu_cleanup(struct swapfiles *); 70 71 /* 72 * Forward declare functions containing 64-bit argument types to enforce 73 * type-checking. 74 */ 75 static int add_bitmap_entry(struct bitmap *bmp, _sd_bitmap_t bits, int any_fail, 76 nsc_off_t fba_num); 77 static int flush_bitmap_list(struct bitmap *bmp, dev_t dev, nsc_off_t *blkno); 78 static int flush_centry_list(_sd_cd_info_t *cdi, _sd_cctl_t *dirty, dev_t dev, 79 nsc_off_t *blkno, int failed, struct bitmap *bmaps); 80 static int flush_hdr(_sd_cctl_t *hdr, dev_t dev, nsc_off_t blkno); 81 static int flush_anon_list(_sd_cctl_t *anon_list, dev_t dev, nsc_off_t *blkno); 82 static void sdbc_anon_copy(caddr_t src, nsc_size_t len, _sd_cctl_t *dest, 83 nsc_off_t dest_off); 84 static void sdbc_anon_get(_sd_cctl_t *src, nsc_off_t src_off, caddr_t dest, 85 nsc_size_t len); 86 static _sd_cctl_t *sdbc_get_anon_list(nsc_size_t bytes); 87 88 static int got_hint; /* did we capture hint at power_lost */ 89 static unsigned int wrthru_hint; /* saved hint at power_lost */ 90 static int saw_power_lost; 91 92 char _sdbc_shutdown_in_progress; 93 static struct swapfiles swfs; 94 95 /* 96 * sdbc_get_anon_list - allocate a set of anonymous cache block 97 * entries that can pretend to be a single blocks of data holding 98 * a virtual character array holding "bytes" entries. 99 * 100 * returns - the cache block heading the chain. 101 */ 102 static _sd_cctl_t * 103 sdbc_get_anon_list(nsc_size_t bytes) 104 { 105 _sd_cctl_t *list, *prev; 106 nsc_size_t i, blks; 107 108 prev = NULL; 109 blks = (bytes + CACHE_BLOCK_SIZE - 1) / CACHE_BLOCK_SIZE; 110 for (i = 0; i < blks; i++) { 111 112 list = sdbc_centry_alloc_blks(_CD_NOHASH, 0, 1, 0); 113 bzero(list->cc_data, CACHE_BLOCK_SIZE); 114 list->anon_next = prev; 115 prev = list; 116 }; 117 118 return (list); 119 } 120 121 /* 122 * sdbc_anon_get - gets "len" bytes of data virtual character array represented 123 * by "src" begining at index "dest_off" and copy to buffer "dest". 124 * 125 * dest - pointer to our virtual array (chain of cache blocks). 126 * dest_off - first location to copy data to. 127 * src - pointer to data to copy 128 * len - the number of bytes of data to copy 129 * 130 */ 131 static void 132 sdbc_anon_get(_sd_cctl_t *src, nsc_off_t src_off, caddr_t dest, nsc_size_t len) 133 { 134 nsc_size_t i; 135 nsc_size_t nlen; 136 nsc_off_t blk_start, blk_end; 137 138 if (len == 0) 139 return; 140 141 blk_start = src_off / CACHE_BLOCK_SIZE; 142 blk_end = (src_off + len) / CACHE_BLOCK_SIZE; 143 144 for (i = 0; i < blk_start; i++) { 145 src = src->anon_next; 146 src_off -= CACHE_BLOCK_SIZE; 147 } 148 149 nlen = min(len, CACHE_BLOCK_SIZE - src_off); 150 bcopy(&src->anon_data[src_off], dest, (size_t)nlen); 151 152 for (i = 1; i < blk_end - blk_start; i++) { 153 bcopy(src->anon_data, &dest[nlen], (size_t)CACHE_BLOCK_SIZE); 154 nlen += CACHE_BLOCK_SIZE; 155 src = src->anon_next; 156 } 157 if (nlen != len) { 158 bcopy(src->anon_data, &dest[nlen], (size_t)(len - nlen)); 159 } 160 } 161 162 /* 163 * sdbc_anon_copy - copies "len" bytes of data from "src" to the 164 * virtual character array represented by "dest" begining at index 165 * "dest_off". 166 * 167 * src - pointer to data to copy 168 * len - the number of bytes of data to copy 169 * dest - pointer to our virtual array (chain of cache blocks). 170 * dest_off - first location to copy data to. 171 * 172 */ 173 static void 174 sdbc_anon_copy(caddr_t src, nsc_size_t len, _sd_cctl_t *dest, 175 nsc_off_t dest_off) 176 { 177 nsc_size_t i; 178 nsc_size_t nlen; 179 nsc_off_t blk_start, blk_end; 180 181 if (len == 0) 182 return; 183 184 blk_start = dest_off / CACHE_BLOCK_SIZE; 185 blk_end = (dest_off + len) / CACHE_BLOCK_SIZE; 186 187 for (i = 0; i < blk_start; i++) { 188 dest = dest->anon_next; 189 dest_off -= CACHE_BLOCK_SIZE; 190 } 191 192 nlen = min(len, CACHE_BLOCK_SIZE - dest_off); 193 bcopy(src, &dest->anon_data[dest_off], (size_t)nlen); 194 195 for (i = 1; i < blk_end - blk_start; i++) { 196 bcopy(&src[nlen], dest->anon_data, (size_t)CACHE_BLOCK_SIZE); 197 nlen += CACHE_BLOCK_SIZE; 198 dest = dest->anon_next; 199 } 200 if (nlen != len) { 201 bcopy(&src[nlen], dest->anon_data, (size_t)(len - nlen)); 202 } 203 } 204 205 /* 206 * flush_anon_list - flush a chain of anonymous cache blocks 207 * to the state file. Anonymous chains of cache blocks represent 208 * virtual arrays for the state flushing code and can contain 209 * various types of data. 210 * 211 * anon_list - chain of cache blocks to flush. 212 * 213 * dev - the state file device 214 * 215 * blkno - on input the cache block number to begin writing at. 216 * On exit the next cache block number following the data 217 * just written. 218 * 219 * returns - 0 on success, error number on failure. 220 */ 221 static int 222 flush_anon_list(_sd_cctl_t *anon_list, 223 dev_t dev, 224 nsc_off_t *blkno) 225 { 226 struct buf *bp; 227 int rc; 228 _sd_cctl_t *prev; 229 nsc_size_t bcnt; 230 231 if (anon_list == NULL) 232 return (0); 233 234 bcnt = 0; 235 do { 236 bp = sd_alloc_iob(dev, BLK_TO_FBA_NUM(*blkno), 237 BLK_TO_FBA_NUM(1), 0); 238 sd_add_fba(bp, &anon_list->cc_addr, 0, BLK_FBAS); 239 rc = sd_start_io(bp, NULL, NULL, 0); 240 (*blkno)++; 241 242 /* 243 * A failure here is death. This is harsh but not sure 244 * what else to do 245 */ 246 247 if (rc != NSC_DONE) 248 return (rc); 249 bcnt++; 250 251 prev = anon_list; 252 anon_list = anon_list->anon_next; 253 _sd_centry_release(prev); 254 255 } while (anon_list); 256 257 cmn_err(CE_CONT, "sdbc(flush_anon_list) %" NSC_SZFMT "\n", bcnt); 258 return (0); 259 260 } 261 262 /* 263 * start_bitmap_list - allocate an anonymous cache block entry 264 * to anchor a chain of cache blocks representing a virtual 265 * array of bitmap entries. 266 * 267 * returns - the cache block heading the chain. 268 */ 269 static void 270 start_bitmap_list(struct bitmap *bmp, int bpb) 271 { 272 _sd_cctl_t *list; 273 274 list = sdbc_centry_alloc_blks(_CD_NOHASH, 0, 1, 0); 275 bzero(list->cc_data, CACHE_BLOCK_SIZE); 276 list->bitmap_next = NULL; 277 list->bitmap_tail = list; 278 279 bmp->bmps = list; 280 bmp->inuse = 0; 281 bmp->bmaps_per_block = bpb; 282 } 283 284 /* 285 * add_bitmap_entry - Add a bitmap entry to the chain of bitmap 286 * entries we are creating for cd's entry in the state file. 287 * 288 * Bitmaps are stored in a chain of anonymous cache blocks. Each 289 * cache block can hold bmaps_per_block in it. As each block is 290 * filled a new block is added to the tail of the chain. 291 * 292 * list - the chain of cache blocks containing the bitmaps. 293 * bits - the bitmap entry to add. 294 * any_fail - flag saying whether the data corresponding to this 295 * bitmap entry had previously failed going to disk. 296 * fba_num - FBA number corresponding to the entry. 297 * 298 * returns - 0 on success, error number on failure. 299 */ 300 static int 301 add_bitmap_entry(struct bitmap *bmp, 302 _sd_bitmap_t bits, int any_fail, nsc_off_t fba_num) 303 { 304 sdbc_pwf_bitmap_t *bmap; 305 _sd_cctl_t *list = bmp->bmps; 306 int i; 307 308 bmap = (sdbc_pwf_bitmap_t *)list->bitmap_tail->cc_data; 309 if (bmp->inuse == bmp->bmaps_per_block) { 310 _sd_cctl_t *nlist; 311 312 nlist = sdbc_centry_alloc_blks(_CD_NOHASH, 0, 1, 0); 313 bzero(nlist->cc_data, CACHE_BLOCK_SIZE); 314 nlist->bitmap_next = NULL; 315 nlist->bitmap_tail = NULL; 316 list->bitmap_tail->bitmap_next = nlist; 317 list->bitmap_tail = nlist; 318 bmp->inuse = 0; 319 } 320 i = bmp->inuse++; 321 bmap->bitmaps[i].fba_num = fba_num; 322 bmap->bitmaps[i].dirty = bits; 323 bmap->bitmaps[i].errs = (char)any_fail; 324 325 return (0); 326 } 327 328 /* 329 * flush_bitmap_list - flush a chain of anonymous cache blocks 330 * containing the dirty/valid bitmaps for a set of cache blocks. 331 * 332 * b_list - the chain of bitmap data. 333 * dev - the state file device. 334 * blkno - on input the cache block number to begin writing at. 335 * On exit the next cache block number following the data 336 * just written. 337 * 338 * returns - 0 on success, error number on failure. 339 */ 340 static int 341 flush_bitmap_list(struct bitmap *bmp, dev_t dev, nsc_off_t *blkno) 342 { 343 _sd_cctl_t *b_list; 344 struct buf *bp; 345 int rc; 346 _sd_cctl_t *prev; 347 int bcnt = 0; /* P3 temp */ 348 349 if ((b_list = bmp->bmps) == NULL) 350 return (0); 351 352 do { 353 bp = sd_alloc_iob(dev, BLK_TO_FBA_NUM(*blkno), 354 BLK_TO_FBA_NUM(1), 0); 355 sd_add_fba(bp, &b_list->cc_addr, 0, BLK_FBAS); 356 rc = sd_start_io(bp, NULL, NULL, 0); 357 (*blkno)++; 358 359 /* 360 * A failure here is death. This is harsh but not sure 361 * what else to do 362 */ 363 364 if (rc != NSC_DONE) 365 return (rc); 366 bcnt++; 367 368 prev = b_list; 369 b_list = b_list->bitmap_next; 370 _sd_centry_release(prev); 371 372 } while (b_list); 373 cmn_err(CE_CONT, "sdbc(flush_bitmap_list) %d\n", bcnt); /* P3 */ 374 375 return (0); 376 377 } 378 379 /* 380 * flush_centry_list - flush a chain of cache blocks for the 381 * cache descriptor described by "cdi" to the state file. 382 * In addition the bitmaps describing the validity and dirty 383 * state of each entry are captured to the bitmap chain. 384 * 385 * cdi - pointer to description of the cd we are writing. 386 * dirty - chain of dirty cache blocks to flush (linked 387 * by dirty_next (sequential) and dirty_link (disjoint). 388 * 389 * dev - the state file device. 390 * 391 * blkno - on input the cache block number to begin writing at. 392 * On exit the next cache block number following the data 393 * just written. 394 * 395 * failed - a flag noting whether these blocks had already 396 * been attempted to write to their true destination and 397 * failed. (i.e. is the chain from fail_head). 398 * 399 * bmaps - a chain of anonymous cache blocks containing all 400 * the dirty/valid bitmaps for the cache blocks we write. 401 * 402 * returns - 0 on success, error number on failure. 403 */ 404 static int 405 flush_centry_list(_sd_cd_info_t *cdi, 406 _sd_cctl_t *dirty, 407 dev_t dev, 408 nsc_off_t *blkno, 409 int failed, 410 struct bitmap *bmaps) 411 { 412 _sd_cctl_t *cc_ent; 413 nsc_size_t count; /* count of cache blocks in a sequential chain */ 414 struct buf *bp; 415 int rc; 416 int bcnt = 0; 417 418 if (dirty == NULL) 419 return (0); 420 421 mutex_enter(&cdi->cd_lock); 422 423 do { 424 /* 425 * each cache block is written to the disk regardless of its 426 * valid/dirty masks. 427 */ 428 count = 0; 429 cc_ent = dirty; 430 do { 431 count++; 432 cc_ent = cc_ent->cc_dirty_next; 433 } while (cc_ent); 434 435 bp = sd_alloc_iob(dev, BLK_TO_FBA_NUM(*blkno), 436 BLK_TO_FBA_NUM(count), 0); 437 438 cc_ent = dirty; 439 do { 440 sd_add_fba(bp, &cc_ent->cc_addr, 0, BLK_FBAS); 441 rc = add_bitmap_entry(bmaps, 442 cc_ent->cc_dirty | cc_ent->cc_toflush, failed, 443 BLK_TO_FBA_NUM(CENTRY_BLK(cc_ent))); 444 if (rc) 445 return (rc); 446 cc_ent = cc_ent->cc_dirty_next; 447 } while (cc_ent); 448 449 *blkno += count; 450 rc = sd_start_io(bp, NULL, NULL, 0); 451 452 /* 453 * A failure here is death. This is harsh but not sure 454 * what else to do 455 */ 456 457 if (rc != NSC_DONE) 458 return (rc); 459 bcnt += count; 460 461 dirty = dirty->cc_dirty_link; 462 } while (dirty); 463 cmn_err(CE_CONT, "sdbc(flush_centry_list) %d\n", bcnt); /* P3 */ 464 465 mutex_exit(&cdi->cd_lock); 466 return (0); 467 } 468 469 /* 470 * flush_hdr - Flush the state file header to the disk partition 471 * "dev" at FBA "blkno". Return the result of the i/o operation. 472 * hdr - a cache block containing the header. 473 * dev - the state file device. 474 * blkno - cache block position to write the header. 475 * 476 * returns - 0 on success, error number on failure. 477 */ 478 static int 479 flush_hdr(_sd_cctl_t *hdr, dev_t dev, nsc_off_t blkno) 480 { 481 struct buf *bp; 482 int rc; 483 484 bp = sd_alloc_iob(dev, BLK_TO_FBA_NUM(blkno), BLK_TO_FBA_NUM(1), 0); 485 sd_add_fba(bp, &hdr->cc_addr, 0, BLK_FBAS); 486 rc = sd_start_io(bp, NULL, NULL, 0); 487 _sd_centry_release(hdr); 488 return (rc); 489 490 } 491 492 /* 493 * _sdbc_power_flush - flushd the state of sdbc to the state "file" 494 * on the system disk. All dirty blocks (in progress, unscheduled, 495 * failed) are written along with the bitmap for each block. The 496 * data is written using normal sdbc i/o via anonymous cache blocks. 497 * This is done to simplify the job here (and to limit memory 498 * requests) at the expense of making the recovery programs more 499 * complex. Since recovery is done at user level this seems to be 500 * a good trade off. 501 * 502 * Returns: 0 on success, error number on failure. 503 */ 504 static int 505 _sdbc_power_flush(void) 506 { 507 _sd_cctl_t *name_pool; 508 int string_size; 509 510 sdbc_pwf_hdr_t *hdr; 511 _sd_cctl_t *hdrblk; 512 513 struct bitmap bmap; 514 515 _sd_cd_info_t *cdi; 516 int open_files; 517 _sd_cctl_t *file_pool; 518 sdbc_pwf_desc_t current; 519 520 nsc_fd_t *state_fd; 521 dev_t state_rdev; 522 int devmaj, devmin; 523 nsc_off_t blkno; 524 long len; 525 long total_len; 526 int pending; 527 int rc = 0; 528 529 /* 530 * Force wrthru just in case SLM software didn't really send us a 531 * warning. (Also makes for easier testing) 532 */ 533 (void) _sd_set_node_hint(NSC_FORCED_WRTHRU); 534 /* disable all (dangerous) cache entry points */ 535 536 cmn_err(CE_CONT, "sdbc(sdbc_power_flush) hint set..\n"); /* P3 */ 537 538 _sdbc_shutdown_in_progress = 1; 539 540 #if 0 541 if (sdbc_io && (rc = nsc_unregister_io(sdbc_io, NSC_PCATCH)) != 0) { 542 /* 543 * this is bad, in theory we could just busy-out all our 544 * interfaces and continue. 545 */ 546 cmn_err(CE_WARN, 547 "sdbc(_sdbc_power_flush) couldn't unregister i/o %d", rc); 548 return (rc); 549 } 550 551 sdbc_io = NULL; 552 #endif 553 554 /* wait for all i/o to finish/timeout ? */ 555 556 if ((pending = _sdbc_wait_pending()) != 0) 557 cmn_err(CE_NOTE, "sdbc(_sdbc_power_flush) %d I/Os were" 558 " pending at power shutdown", pending); 559 560 cmn_err(CE_CONT, "sdbc(sdbc_power_flush) over pending\n"); /* P3 */ 561 562 /* prevent any further async flushing */ 563 564 _sdbc_flush_deconfigure(); 565 566 /* 567 * At this point no higher level clients should be able to get thru. 568 * Failover i/o from the other node is our only other concern as 569 * far as disturbing the state of sdbc. 570 */ 571 572 /* figure out the names for the string pool */ 573 574 string_size = 0; 575 open_files = 0; 576 cdi = _sd_cache_files; 577 do { 578 579 if (cdi->cd_info == NULL) 580 continue; 581 if (cdi->cd_info->sh_alloc == 0) 582 continue; 583 open_files++; 584 string_size += strlen(cdi->cd_info->sh_filename) + 1; 585 } while (++cdi != &_sd_cache_files[sdbc_max_devs]); 586 587 if (open_files == 0) { 588 return (0); 589 } 590 591 hdrblk = sdbc_centry_alloc_blks(_CD_NOHASH, 0, 1, 0); 592 bzero(hdrblk->cc_data, CACHE_BLOCK_SIZE); 593 hdr = (sdbc_pwf_hdr_t *)hdrblk->cc_data; 594 hdr->magic = SDBC_PWF_MAGIC; 595 hdr->alignment = CACHE_BLOCK_SIZE; 596 hdr->cd_count = open_files; 597 /* XXX bmap_size is redundant */ 598 hdr->bmap_size = CACHE_BLOCK_SIZE / sizeof (sdbc_pwf_bitmap_t); 599 600 name_pool = sdbc_get_anon_list(string_size); 601 file_pool = sdbc_get_anon_list(sizeof (sdbc_pwf_desc_t) * open_files); 602 603 open_files = 0; 604 cdi = _sd_cache_files; 605 total_len = 0; 606 do { 607 608 if (cdi->cd_info == NULL) 609 continue; 610 if (cdi->cd_info->sh_alloc == 0) 611 continue; 612 613 len = strlen(cdi->cd_info->sh_filename) + 1; 614 615 /* copy the name to string pool */ 616 sdbc_anon_copy(cdi->cd_info->sh_filename, 617 len, name_pool, total_len); 618 619 bzero(¤t, sizeof (current)); 620 current.name = total_len; 621 sdbc_anon_copy((caddr_t)¤t, sizeof (current), file_pool, 622 open_files * sizeof (sdbc_pwf_desc_t)); 623 624 open_files++; 625 total_len += len; 626 627 } while (++cdi != &_sd_cache_files[sdbc_max_devs]); 628 629 /* flush dirty data */ 630 631 if (swfs.nswpf == 0 || swfs.names[0] == NULL) { 632 cmn_err(CE_WARN, "sdbc(_sdbc_power_flush): State file" 633 " is not configured"); 634 rc = ENODEV; 635 goto cleanup; 636 } 637 638 if (!(state_fd = 639 nsc_open(swfs.names[0], NSC_DEVICE, NULL, NULL, &rc)) || 640 !nsc_getval(state_fd, "DevMaj", (int *)&devmaj) || 641 !nsc_getval(state_fd, "DevMin", (int *)&devmin)) { 642 if (state_fd) { 643 (void) nsc_close(state_fd); 644 } 645 /* 646 * We are hosed big time. We can't get device to write the 647 * state file opened. 648 */ 649 cmn_err(CE_WARN, "sdbc(_sdbc_power_flush): Couldn't " 650 "open %s for saved state file", swfs.names[0]); 651 rc = EIO; 652 goto cleanup; 653 } 654 655 state_rdev = makedevice(devmaj, devmin); 656 657 blkno = 1; 658 659 hdr->string_pool = blkno; 660 rc = flush_anon_list(name_pool, state_rdev, &blkno); 661 662 hdr->descriptor_pool = blkno; 663 rc = flush_anon_list(file_pool, state_rdev, &blkno); 664 665 /* 666 * iterate across all devices, flushing the data and collecting bitmaps 667 */ 668 669 open_files = 0; 670 for (cdi = _sd_cache_files; 671 cdi != &_sd_cache_files[sdbc_max_devs]; cdi++) { 672 nsc_off_t blk2; 673 nsc_off_t fp_off; 674 675 if (cdi->cd_info == NULL) 676 continue; 677 if (cdi->cd_info->sh_alloc == 0) 678 continue; 679 680 /* retrieve the file description so we can update it */ 681 fp_off = (open_files++) * sizeof (sdbc_pwf_desc_t); 682 sdbc_anon_get(file_pool, fp_off, 683 (caddr_t)¤t, sizeof (current)); 684 685 current.blocks = blkno; 686 687 if (cdi->cd_io_head) { 688 /* 689 * Need to wait for this to timeout? 690 * Seems like worst case we just write the data twice 691 * so we should be ok. 692 */ 693 /*EMPTY*/ 694 ; 695 } 696 697 start_bitmap_list(&bmap, hdr->bmap_size); 698 699 /* Flush the enqueued dirty data blocks */ 700 701 (void) flush_centry_list(cdi, cdi->cd_dirty_head, state_rdev, 702 &blkno, 0, &bmap); 703 cdi->cd_dirty_head = NULL; 704 cdi->cd_dirty_tail = NULL; 705 706 /* Flush the failed dirty data blocks */ 707 708 (void) flush_centry_list(cdi, cdi->cd_fail_head, state_rdev, 709 &blkno, 1, &bmap); 710 cdi->cd_fail_head = NULL; 711 712 /* 713 * Flush the in progress dirty data blocks. These really should 714 * really be null by now. Worst case we write the data again 715 * on recovery as we know the dirty masks won't change since 716 * flusher is stopped. 717 */ 718 719 (void) flush_centry_list(cdi, cdi->cd_io_head, state_rdev, 720 &blkno, 0, &bmap); 721 cdi->cd_io_head = NULL; 722 cdi->cd_io_tail = NULL; 723 724 current.bitmaps = blkno; 725 current.nblocks = blkno - current.blocks; 726 727 (void) flush_bitmap_list(&bmap, state_rdev, &blkno); 728 729 /* update the current cd's file description */ 730 sdbc_anon_copy((caddr_t)¤t, sizeof (current), file_pool, 731 fp_off); 732 733 blk2 = hdr->descriptor_pool; 734 rc = flush_anon_list(file_pool, state_rdev, &blk2); 735 } 736 737 #if !defined(_SunOS_5_6) 738 hdr->dump_time = ddi_get_time(); 739 #else 740 hdr->dump_time = hrestime.tv_sec; 741 #endif 742 /* write the header at front and back */ 743 (void) flush_hdr(hdrblk, state_rdev, blkno); 744 (void) flush_hdr(hdrblk, state_rdev, 0L); 745 746 /* P3 */ 747 cmn_err(CE_CONT, "sdbc(sdbc_power_flush) %" NSC_SZFMT " total\n", 748 blkno); 749 750 cleanup: 751 ; 752 return (rc); 753 754 } 755 756 /* 757 * _sdbc_power_lost - System is running on UPS power we have "rideout" 758 * minutes of power left prior to shutdown. Get into a state where we 759 * will be ready should we need to shutdown. 760 * 761 * ARGUMENTS: 762 * rideout - minutes of power left prior to shutdown. 763 */ 764 void 765 _sdbc_power_lost(int rideout) 766 { 767 cmn_err(CE_WARN, "sdbc(_sdbc_power_lost) battery time " 768 "remaining %d minute(s)", rideout); 769 770 got_hint = 1; 771 if (_sd_get_node_hint(&wrthru_hint)) 772 got_hint = 0; 773 774 cmn_err(CE_WARN, "sdbc(_sdbc_power_lost) got hint %d " 775 "hint 0x%x", got_hint, wrthru_hint); 776 777 (void) _sd_set_node_hint(NSC_FORCED_WRTHRU); 778 saw_power_lost = 1; 779 } 780 781 /* 782 * _sdbc_power_ok - System is back running on mains power after 783 * seeing a power fail. Return to normal power up operation. 784 * 785 */ 786 void 787 _sdbc_power_ok(void) 788 { 789 cmn_err(CE_WARN, "sdbc(_sdbc_power_ok) power ok"); 790 if (saw_power_lost && got_hint) { 791 /* 792 * In theory we have a race here between _sdbc_power_lost 793 * and here. However it is expected that power ioctls that 794 * cause these to be generated are sequential in nature 795 * so there is no race. 796 */ 797 saw_power_lost = 0; 798 if (wrthru_hint & _SD_WRTHRU_MASK) 799 (void) _sd_set_node_hint(wrthru_hint & _SD_WRTHRU_MASK); 800 else 801 (void) _sd_clear_node_hint(_SD_WRTHRU_MASK); 802 } 803 } 804 805 /* 806 * _sdbc_power_down - System is running on UPS power and we must stop 807 * operation as the machine is now going down. Schedule a shutdown 808 * thread. 809 * 810 * When we return all cache activity will be blocked. 811 */ 812 void 813 _sdbc_power_down(void) 814 { 815 cmn_err(CE_WARN, "sdbc(_sdbc_power_down) powering down..."); 816 (void) _sdbc_power_flush(); 817 } 818 819 /* 820 * Configure safe store from the general cache configuration ioctl. 821 */ 822 int 823 _sdbc_pcu_config(int namec, char **namev) 824 { 825 int i; 826 827 if (swfs.nswpf != 0) { 828 /* 829 * This should not happen because cache protects itself 830 * from double configuration in sd_conf.c. 831 */ 832 cmn_err(CE_CONT, "sdbc(_sdbc_pcu_config) double " 833 "configuration of Safe Store\n"); 834 return (EINVAL); 835 } 836 swfs.colsize = 32; /* No way to configure in the general ioctl */ 837 838 for (i = 0; i < namec; i++) { 839 if ((swfs.names[i] = kmem_alloc(strlen(namev[i])+1, 840 KM_NOSLEEP)) == NULL) { 841 _sdbc_pcu_cleanup(&swfs); 842 return (ENOMEM); 843 } 844 swfs.nswpf++; 845 (void) strcpy(swfs.names[i], namev[i]); 846 } 847 848 return (0); 849 } 850 851 /* 852 */ 853 void 854 _sdbc_pcu_unload() 855 { 856 _sdbc_pcu_cleanup(&swfs); 857 } 858 859 /* 860 * Destructor for struct swapfiles. 861 */ 862 static void 863 _sdbc_pcu_cleanup(struct swapfiles *swp) 864 { 865 int i; 866 char *s; 867 868 for (i = 0; i < swp->nswpf; i++) { 869 if ((s = swp->names[i]) != NULL) 870 kmem_free(s, strlen(s)+1); 871 swp->names[i] = NULL; 872 } 873 swp->nswpf = 0; 874 } 875