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 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #define _SCM_ 27 28 #include <sys/types.h> 29 #include <sys/ksynch.h> 30 #include <sys/cmn_err.h> 31 #include <sys/modctl.h> 32 #include <sys/conf.h> 33 #include <sys/errno.h> 34 #include <sys/file.h> 35 #include <sys/kmem.h> 36 #include <sys/cred.h> 37 #include <sys/ddi.h> 38 #include <sys/nsc_thread.h> 39 40 #include "sd_bcache.h" 41 #include "sd_misc.h" 42 #include "sd_trace.h" 43 #include "sd_ft.h" 44 #include "sd_io.h" 45 #include "sd_bio.h" 46 #include "sd_pcu.h" 47 #include "sd_tdaemon.h" 48 #include "sdbc_ioctl.h" 49 #include <sys/ncall/ncall.h> 50 #include <sys/nsctl/nsctl.h> 51 #include <sys/nsctl/nsvers.h> 52 53 #include <sys/sdt.h> /* dtrace is S10 or later */ 54 55 #include <sys/unistat/spcs_s.h> 56 #include <sys/unistat/spcs_s_k.h> 57 #include <sys/unistat/spcs_errors.h> 58 static dev_info_t *dev_dip; 59 dev_info_t *sdbc_get_dip(); 60 61 62 /* 63 * A global variable to set the threshold for large writes to 64 * be in write through mode when NVRAM is present. This should 65 * solve the NVRAM bandwidth problem. 66 */ 67 68 int sdbc_wrthru_len; 69 nsc_size_t sdbc_max_fbas = _SD_MAX_FBAS; 70 int sdbc_max_devs = 0; 71 72 krwlock_t sdbc_queue_lock; 73 74 static int _sd_debug_level = 0; 75 76 static kmutex_t _sd_block_lk; 77 78 #define REGISTER_SVC(X, Y) (ncall_register_svc(X, Y)) 79 #define UNREGISTER_SVC(X) (ncall_unregister_svc(X)) 80 81 const int sdbc_major_rev = ISS_VERSION_MAJ; 82 const int sdbc_minor_rev = ISS_VERSION_MIN; 83 const int sdbc_micro_rev = ISS_VERSION_MIC; 84 const int sdbc_baseline_rev = ISS_VERSION_NUM; 85 static char sdbc_version[16]; 86 87 static int _sdbc_attached = 0; 88 89 static int _sdbc_print(dev_t dev, char *s); 90 static int sdbcunload(void); 91 static int sdbcload(void); 92 static int sdbcopen(dev_t *devp, int flag, int otyp, cred_t *crp); 93 static int sdbcclose(dev_t dev, int flag, int otyp, cred_t *crp); 94 static int sdbcioctl(dev_t dev, int cmd, void *arg, int mode, cred_t *crp, 95 int *rvp); 96 static int _sdbc_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **); 97 static int _sdbc_probe(dev_info_t *dip); 98 static int _sdbc_attach(dev_info_t *, ddi_attach_cmd_t); 99 static int _sdbc_detach(dev_info_t *, ddi_detach_cmd_t); 100 static int _sdbc_reset(dev_info_t *, ddi_reset_cmd_t); 101 102 #ifdef sun 103 /* 104 * Solaris specific driver module interface code. 105 */ 106 107 #ifdef USES_SOFT_STATE 108 struct sdbc_state { 109 dev_info_t *dip; /* everyone would need a devinfo */ 110 }; 111 112 static void *sdbc_statep; /* for soft state routines */ 113 #endif /* USES_SOFT_STATE */ 114 115 static struct cb_ops sdbc_cb_ops = { 116 sdbcopen, /* open */ 117 sdbcclose, /* close */ 118 nodev, /* not a block driver, strategy not an entry point */ 119 _sdbc_print, /* no print routine */ 120 nodev, /* no dump routine */ 121 nodev, /* read */ 122 nodev, /* write */ 123 (int (*) ()) sdbcioctl, /* ioctl */ 124 nodev, /* no devmap routine */ 125 nodev, /* no mmap routine */ 126 nodev, /* no segmap routine */ 127 nochpoll, /* no chpoll routine */ 128 ddi_prop_op, 129 0, /* not a STREAMS driver, no cb_str routine */ 130 D_NEW | D_MP, /* safe for multi-thread/multi-processor */ 131 }; 132 133 134 static struct dev_ops sdbc_ops = { 135 DEVO_REV, /* Driver build version */ 136 0, /* device reference count */ 137 _sdbc_getinfo, 138 nulldev, 139 _sdbc_probe, 140 _sdbc_attach, 141 _sdbc_detach, 142 _sdbc_reset, 143 &sdbc_cb_ops, 144 (struct bus_ops *)NULL 145 }; 146 147 static struct modldrv sdbc_ldrv = { 148 &mod_driverops, 149 "nws:Storage Cache:" ISS_VERSION_STR, 150 &sdbc_ops 151 }; 152 153 static struct modlinkage sdbc_modlinkage = { 154 MODREV_1, 155 &sdbc_ldrv, 156 NULL 157 }; 158 159 /* 160 * dynmem interface 161 */ 162 static int mutex_and_condvar_flag; 163 164 /* 165 * Solaris module load time code 166 */ 167 int 168 _init(void) 169 { 170 171 int err; 172 173 mutex_and_condvar_flag = 0; 174 175 #ifdef USES_SOFT_STATE 176 ddi_soft_state_init(&sdbc_statep, sizeof (struct sdbc_state), 177 MAX_INSTANCES); 178 #endif /* USES_SOFT_STATE */ 179 180 /* 181 * It is "load" time, call the unixware equivalent. 182 */ 183 err = sdbcload(); 184 if (!err) 185 err = mod_install(&sdbc_modlinkage); 186 187 if (err) { 188 (void) sdbcunload(); 189 #ifdef USES_SOFT_STATE 190 ddi_soft_state_fini(&sdbc_statep); 191 #endif /* USES_SOFT_STATE */ 192 } 193 194 if (!err) { 195 mutex_and_condvar_flag = 1; 196 mutex_init(&dynmem_processing_dm.thread_dm_lock, "dynmem", 197 MUTEX_DRIVER, NULL); 198 cv_init(&dynmem_processing_dm.thread_dm_cv, "dynmem", 199 CV_DRIVER, NULL); 200 } 201 202 return (err); 203 204 } 205 /* 206 * Solaris module unload time code 207 */ 208 209 int 210 _fini(void) 211 { 212 int err; 213 214 if (_sd_cache_initialized) { 215 return (EBUSY); 216 } else if (_sd_ioset && 217 (_sd_ioset->set_nlive || _sd_ioset->set_nthread)) { 218 cmn_err(CE_WARN, "!sdbc:_fini() %d threads still " 219 "active; %d threads in set\n", _sd_ioset->set_nlive, 220 _sd_ioset->set_nthread); 221 return (EBUSY); 222 } 223 if ((err = mod_remove(&sdbc_modlinkage)) == 0) { 224 DTRACE_PROBE2(_sdbc_fini_mod_remove_succeeded, 225 int, err, 226 struct modlinkage *, &sdbc_modlinkage); 227 err = sdbcunload(); 228 #ifdef USES_SOFT_STATE 229 ddi_soft_state_fini(&sdbc_statep); 230 #endif /* USES_SOFT_STATE */ 231 232 if (mutex_and_condvar_flag) { 233 cv_destroy(&dynmem_processing_dm.thread_dm_cv); 234 mutex_destroy(&dynmem_processing_dm.thread_dm_lock); 235 mutex_and_condvar_flag = 0; 236 } 237 } 238 239 return (err); 240 } 241 242 /* 243 * Solaris module info code 244 */ 245 int 246 _info(struct modinfo *modinfop) 247 { 248 return (mod_info(&sdbc_modlinkage, modinfop)); 249 } 250 251 /*ARGSUSED*/ 252 static int 253 _sdbc_probe(dev_info_t *dip) 254 { 255 return (DDI_PROBE_SUCCESS); 256 } 257 258 /* 259 * Attach an instance of the device. This happens before an open 260 * can succeed. 261 */ 262 static int 263 _sdbc_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) 264 { 265 _dm_process_vars_t local_dm_process_vars; 266 struct buf bp; 267 268 if (cmd != DDI_ATTACH) 269 return (DDI_FAILURE); 270 271 /* 272 * Get the threshold value for setting large writes in 273 * write through mode(when NVRAM is present) 274 */ 275 276 sdbc_wrthru_len = ddi_prop_get_int(DDI_DEV_T_ANY, dip, 277 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "sdbc_wrthru_thresh", 64); 278 279 /* Get sdbc_max_fbas from sdbc.conf */ 280 sdbc_max_fbas = ddi_prop_get_int(DDI_DEV_T_ANY, dip, 281 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "sdbc_max_fbas", 282 _SD_MAX_FBAS); 283 284 bp.b_bcount = (size_t)FBA_SIZE(sdbc_max_fbas); 285 minphys(&bp); /* clamps value to maxphys */ 286 287 sdbc_max_fbas = FBA_NUM(bp.b_bcount); 288 289 if (sdbc_max_fbas > _SD_MAX_FBAS) { 290 cmn_err(CE_WARN, 291 "!_sdbc_attach: sdbc_max_fbas set to %d", _SD_MAX_FBAS); 292 sdbc_max_fbas = _SD_MAX_FBAS; 293 } 294 295 /* 296 * -get the maximum list length for multipage dynmem 297 * -time between aging 298 * -number of agings before dealloc 299 * -what to report D0=shutdown, D1=thread variables 300 */ 301 dynmem_processing_dm.max_dyn_list = MAX_DYN_LIST_DEFAULT; 302 dynmem_processing_dm.monitor_dynmem_process = 303 MONITOR_DYNMEM_PROCESS_DEFAULT; 304 dynmem_processing_dm.cache_aging_ct1 = CACHE_AGING_CT_DEFAULT; 305 dynmem_processing_dm.cache_aging_ct2 = CACHE_AGING_CT_DEFAULT; 306 dynmem_processing_dm.cache_aging_ct3 = CACHE_AGING_CT_DEFAULT; 307 dynmem_processing_dm.cache_aging_sec1 = CACHE_AGING_SEC1_DEFAULT; 308 dynmem_processing_dm.cache_aging_sec2 = CACHE_AGING_SEC2_DEFAULT; 309 dynmem_processing_dm.cache_aging_sec3 = CACHE_AGING_SEC3_DEFAULT; 310 dynmem_processing_dm.cache_aging_pcnt1 = CACHE_AGING_PCNT1_DEFAULT; 311 dynmem_processing_dm.cache_aging_pcnt2 = CACHE_AGING_PCNT2_DEFAULT; 312 dynmem_processing_dm.max_holds_pcnt = MAX_HOLDS_PCNT_DEFAULT; 313 dynmem_processing_dm.process_directive = PROCESS_DIRECTIVE_DEFAULT; 314 315 local_dm_process_vars.max_dyn_list = ddi_prop_get_int(DDI_DEV_T_ANY, 316 dip, DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "sdbc_max_dyn_list", 317 MAX_DYN_LIST_DEFAULT); 318 319 local_dm_process_vars.monitor_dynmem_process = 320 ddi_prop_get_int(DDI_DEV_T_ANY, dip, 321 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "sdbc_monitor_dynmem", 322 MONITOR_DYNMEM_PROCESS_DEFAULT); 323 324 local_dm_process_vars.cache_aging_ct1 = ddi_prop_get_int(DDI_DEV_T_ANY, 325 dip, DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "sdbc_cache_aging_ct1", 326 CACHE_AGING_CT_DEFAULT); 327 328 local_dm_process_vars.cache_aging_ct2 = ddi_prop_get_int(DDI_DEV_T_ANY, 329 dip, DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "sdbc_cache_aging_ct2", 330 CACHE_AGING_CT_DEFAULT); 331 332 local_dm_process_vars.cache_aging_ct3 = ddi_prop_get_int(DDI_DEV_T_ANY, 333 dip, DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "sdbc_cache_aging_ct3", 334 CACHE_AGING_CT_DEFAULT); 335 336 local_dm_process_vars.cache_aging_sec1 = ddi_prop_get_int(DDI_DEV_T_ANY, 337 dip, DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "sdbc_cache_aging_sec1", 338 CACHE_AGING_SEC1_DEFAULT); 339 340 local_dm_process_vars.cache_aging_sec2 = ddi_prop_get_int(DDI_DEV_T_ANY, 341 dip, DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "sdbc_cache_aging_sec2", 342 CACHE_AGING_SEC2_DEFAULT); 343 344 local_dm_process_vars.cache_aging_sec3 = ddi_prop_get_int(DDI_DEV_T_ANY, 345 dip, DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "sdbc_cache_aging_sec3", 346 CACHE_AGING_SEC3_DEFAULT); 347 348 local_dm_process_vars.cache_aging_pcnt1 = 349 ddi_prop_get_int(DDI_DEV_T_ANY, dip, 350 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "sdbc_cache_aging_pcnt1", 351 CACHE_AGING_PCNT1_DEFAULT); 352 353 local_dm_process_vars.cache_aging_pcnt2 = 354 ddi_prop_get_int(DDI_DEV_T_ANY, dip, 355 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "sdbc_cache_aging_pcnt2", 356 CACHE_AGING_PCNT2_DEFAULT); 357 358 local_dm_process_vars.process_directive = 359 ddi_prop_get_int(DDI_DEV_T_ANY, dip, 360 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "sdbc_process_directive", 361 PROCESS_DIRECTIVE_DEFAULT); 362 363 local_dm_process_vars.max_holds_pcnt = ddi_prop_get_int(DDI_DEV_T_ANY, 364 dip, DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "sdbc_max_holds_pcnt", 365 MAX_HOLDS_PCNT_DEFAULT); 366 367 (void) sdbc_edit_xfer_process_vars_dm(&local_dm_process_vars); 368 369 #define MINOR_NAME "c,sdbc" /* character device */ 370 #define MINOR_NUMBER 0 371 #ifdef MINOR_NAME 372 if (ddi_create_minor_node(dip, MINOR_NAME, S_IFCHR, 373 MINOR_NUMBER, DDI_PSEUDO, 0) != DDI_SUCCESS) { 374 /* free anything we allocated here */ 375 return (DDI_FAILURE); 376 } 377 #endif /* MINOR_NAME */ 378 379 /* Announce presence of the device */ 380 ddi_report_dev(dip); 381 dev_dip = dip; 382 /* mark the device as attached, opens may proceed */ 383 _sdbc_attached = 1; 384 385 rw_init(&sdbc_queue_lock, NULL, RW_DRIVER, NULL); 386 387 return (DDI_SUCCESS); 388 } 389 390 /*ARGSUSED*/ 391 static int 392 _sdbc_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 393 { 394 if (cmd == DDI_DETACH) { 395 /* 396 * Check first if the cache is still in use 397 * and if it is, prevent the detach. 398 */ 399 if (_sd_cache_initialized) 400 return (EBUSY); 401 402 _sdbc_attached = 0; 403 404 rw_destroy(&sdbc_queue_lock); 405 dev_dip = NULL; 406 407 return (DDI_SUCCESS); 408 } else 409 return (DDI_FAILURE); 410 } 411 412 /*ARGSUSED*/ 413 static int 414 _sdbc_reset(dev_info_t *dip, ddi_reset_cmd_t cmd) 415 { 416 return (DDI_SUCCESS); 417 } 418 419 /*ARGSUSED*/ 420 static int 421 _sdbc_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result) 422 { 423 dev_t dev; 424 #ifdef USES_SOFT_STATE 425 struct sdbc_state *xsp; 426 int instance; 427 #endif /* USES_SOFT_STATE */ 428 int rc; 429 430 switch (cmd) { 431 case DDI_INFO_DEVT2INSTANCE: 432 dev = (dev_t)arg; 433 /* The "instance" number is the minor number */ 434 *result = (void *)(unsigned long)getminor(dev); 435 rc = DDI_SUCCESS; 436 break; 437 438 case DDI_INFO_DEVT2DEVINFO: 439 dev = (dev_t)arg; 440 #ifdef USES_SOFT_STATE 441 /* the instance number is the minor number */ 442 instance = getminor(dev); 443 xsp = ddi_get_soft_state(sdbc_statep, instance); 444 if (xsp == NULL) 445 return (DDI_FAILURE); 446 *result = (void *) xsp->dip; 447 #else 448 *result = (void *) NULL; 449 #endif /* USES_SOFT_STATE */ 450 rc = DDI_SUCCESS; 451 break; 452 453 default: 454 rc = DDI_FAILURE; 455 break; 456 } 457 return (rc); 458 } 459 460 /*ARGSUSED*/ 461 int 462 _sdbc_print(dev_t dev, char *s) 463 { 464 cmn_err(CE_WARN, "!sdbc(_sdbc_print) %s", s); 465 return (0); 466 } 467 #else 468 MOD_DRV_WRAPPER(sdbc, sdbcload, sdbcunload, NULL, "Storage Device Block Cache"); 469 #endif /* sun */ 470 471 static int sdbc_inited; 472 473 static int 474 sdbcinit(void) 475 { 476 int rc; 477 478 sdbc_inited = 0; 479 480 (void) strncpy(sdbc_version, _VERSION_, sizeof (sdbc_version)); 481 482 mutex_init(&_sd_cache_lock, NULL, MUTEX_DRIVER, NULL); 483 mutex_init(&_sdbc_config_lock, NULL, MUTEX_DRIVER, NULL); 484 485 #ifdef m88k 486 REGISTER_SVC(SD_DUAL_WRITE, r_sd_ifs_write); 487 REGISTER_SVC(SD_DUAL_READ, r_sd_ifs_read); 488 REGISTER_SVC(SD_SET_CD, r_sd_set_cd); 489 REGISTER_SVC(SD_GETSIZE, r_sd_getsize); 490 REGISTER_SVC(SD_DUAL_OPEN, r_sd_ifs_open); 491 REGISTER_SVC(SD_REMOTE_FLUSH, r_sd_remote_flush); 492 REGISTER_SVC(SD_SGREMOTE_FLUSH, r_sd_sgremote_flush); 493 REGISTER_SVC(SD_DISK_IO, r_sd_disk_io); 494 REGISTER_SVC(SD_GET_BMAP, r_rem_get_bmap); 495 496 if ((rc = hpf_register_module("SDBC", _sd_hpf_stats)) != 0) 497 return (rc); 498 #endif 499 REGISTER_SVC(SD_ENABLE, r_sd_ifs_cache_enable); 500 REGISTER_SVC(SD_DISABLE, r_sd_ifs_cache_disable); 501 REGISTER_SVC(SD_CD_DISCARD, r_cd_discard); 502 503 cv_init(&_sd_flush_cv, NULL, CV_DRIVER, NULL); 504 505 mutex_init(&_sd_block_lk, NULL, MUTEX_DRIVER, NULL); 506 507 sdbc_max_devs = nsc_max_devices(); 508 509 /* 510 * Initialize the bitmap array that would be useful in determining 511 * if the mask is not fragmented, instead of determinig this 512 * at run time. Also initialize a lookup array for each mask, with 513 * the starting position, the length, and the mask subset 514 */ 515 _sd_init_contig_bmap(); 516 _sd_init_lookup_map(); 517 518 if ((rc = _sdbc_iobuf_load()) != 0) 519 return (rc); 520 if ((rc = _sdbc_handles_load()) != 0) 521 return (rc); 522 if ((rc = _sdbc_tr_load()) != 0) 523 return (rc); 524 if ((rc = _sdbc_ft_load()) != 0) 525 return (rc); 526 if ((rc = _sdbc_tdaemon_load()) != 0) 527 return (rc); 528 if ((rc = _sdbc_hash_load()) != 0) 529 return (rc); 530 #ifdef DEBUG 531 _sdbc_ioj_load(); 532 #endif 533 sdbc_inited = 1; 534 535 return (0); 536 } 537 538 static int 539 sdbcunload(void) 540 { 541 if (_sd_cache_initialized) { 542 cmn_err(CE_WARN, 543 "!sdbc(sdbcunload) cannot unload module - cache in use!"); 544 return (EEXIST); 545 } 546 #ifdef m88k 547 UNREGISTER_SVC(SD_DUAL_WRITE); 548 UNREGISTER_SVC(SD_DUAL_READ); 549 UNREGISTER_SVC(SD_SET_CD); 550 UNREGISTER_SVC(SD_GETSIZE); 551 UNREGISTER_SVC(SD_DUAL_OPEN); 552 UNREGISTER_SVC(SD_REMOTE_FLUSH); 553 UNREGISTER_SVC(SD_SGREMOTE_FLUSH); 554 UNREGISTER_SVC(SD_DISK_IO); 555 UNREGISTER_SVC(SD_GET_BMAP); 556 557 (void) hpf_unregister_module("SDBC"); 558 #endif 559 UNREGISTER_SVC(SD_ENABLE); 560 UNREGISTER_SVC(SD_DISABLE); 561 UNREGISTER_SVC(SD_CD_DISCARD); 562 563 cv_destroy(&_sd_flush_cv); 564 mutex_destroy(&_sd_block_lk); 565 566 _sdbc_hash_unload(); 567 _sdbc_ft_unload(); 568 _sdbc_tr_unload(); 569 _sdbc_tdaemon_unload(); 570 _sdbc_handles_unload(); 571 _sdbc_iobuf_unload(); 572 #ifdef DEBUG 573 _sdbc_ioj_unload(); 574 #endif 575 576 mutex_destroy(&_sd_cache_lock); 577 mutex_destroy(&_sdbc_config_lock); 578 579 /* 580 * Normally we would unregister memory at deconfig time. 581 * However when chasing things like memory leaks it is 582 * useful to defer until unload time. 583 */ 584 if (_sdbc_memtype_deconfigure_delayed) 585 _sdbc_memtype_deconfigure(); 586 587 return (0); 588 } 589 590 591 static int 592 sdbcload(void) 593 { 594 int err; 595 596 if ((err = sdbcinit()) != 0) { 597 (void) sdbcunload(); 598 return (err); 599 } 600 return (0); 601 } 602 603 604 /* ARGSUSED */ 605 606 static int 607 sdbcopen(dev_t *devp, int flag, int otyp, cred_t *crp) 608 { 609 int nd = nsc_node_id(); 610 611 /* 612 * If we were statically linked in then returning an error out 613 * of sdbcinit won't prevent someone from coming thru here. 614 * We must prevent them from getting any further. 615 */ 616 if (!sdbc_inited) 617 return (EINVAL); 618 619 if (nd < nsc_min_nodeid) { 620 cmn_err(CE_WARN, 621 "!sdbc(sdbcopen) open failed, systemid (%d) must be >= %d", 622 nd, nsc_min_nodeid); 623 return (EINVAL); 624 } 625 if (!_sdbc_attached) 626 return (ENXIO); 627 628 return (0); 629 } 630 631 632 /* ARGSUSED */ 633 634 static int 635 sdbcclose(dev_t dev, int flag, int otyp, cred_t *crp) 636 { 637 return (0); 638 } 639 640 #ifdef _MULTI_DATAMODEL 641 static int 642 convert_ioctl_args(int cmd, void *arg, int mode, _sdbc_ioctl_t *args) 643 /* 644 * convert_ioctl-args - Do a case by case conversion of a ILP32 ioctl 645 * structure to an LP64 structure. 646 * The main concern here is whether to sign-extend or not. The rule 647 * is that pointers are not sign extended, the rest are obvious. 648 * Since most everything is sign-extended the definition of 649 * _sdbc_ioctl32_t uses signed fields. 650 * 651 */ 652 { 653 _sdbc_ioctl32_t args32; 654 655 if (ddi_copyin(arg, &args32, sizeof (_sdbc_ioctl32_t), mode)) 656 return (EFAULT); 657 658 bzero((void *) args, sizeof (_sdbc_ioctl_t)); 659 660 switch (cmd) { 661 662 case SDBC_UNUSED_1: 663 case SDBC_UNUSED_2: 664 case SDBC_UNUSED_3: 665 args->sdbc_ustatus = (spcs_s_info_t)args32.sdbc_ustatus; 666 cmn_err(CE_WARN, 667 "!sdbc(convert_ioctl_args) obsolete sdbc ioctl used"); 668 return (EINVAL); 669 670 case SDBC_ADUMP: 671 args->arg0 = args32.arg0; /* cd */ 672 args->arg1 = (uint32_t)args32.arg1; /* &tt */ 673 args->arg2 = (uint32_t)args32.arg2; /* NULL (buf) */ 674 args->arg3 = args32.arg3; /* size of buf */ 675 args->arg4 = args32.arg4; /* flag */ 676 args->sdbc_ustatus = (spcs_s_info_t)args32.sdbc_ustatus; 677 break; 678 679 case SDBC_TEST_INIT: 680 args->arg0 = (uint32_t)args32.arg0; /* fname (char *) */ 681 args->arg1 = args32.arg1; /* index */ 682 args->arg2 = args32.arg2; /* len */ 683 args->arg3 = args32.arg3; /* track size */ 684 args->arg4 = args32.arg4; /* flag */ 685 break; 686 687 case SDBC_TEST_START: 688 args->arg0 = args32.arg0; /* num */ 689 args->arg1 = args32.arg1; /* type */ 690 args->arg2 = args32.arg2; /* loops */ 691 args->arg3 = args32.arg3; /* from */ 692 args->arg4 = args32.arg4; /* seed */ 693 break; 694 695 case SDBC_TEST_END: 696 break; 697 698 case SDBC_ENABLE: 699 case SDBC_VERSION: 700 args->arg0 = (uint32_t)args32.arg0; /* pointer */ 701 args->sdbc_ustatus = (spcs_s_info_t)args32.sdbc_ustatus; 702 break; 703 704 case SDBC_DISABLE: 705 args->sdbc_ustatus = (spcs_s_info_t)args32.sdbc_ustatus; 706 break; 707 708 case SDBC_GET_CLUSTER_SIZE: 709 args->arg0 = (uint32_t)args32.arg0; /* (int * ) */ 710 args->sdbc_ustatus = (spcs_s_info_t)args32.sdbc_ustatus; 711 break; 712 713 /* get the gl_file data */ 714 case SDBC_GET_CLUSTER_DATA: 715 /* pointer to array[2*cluster_size] */ 716 args->arg0 = (uint32_t)args32.arg0; 717 args->sdbc_ustatus = (spcs_s_info_t)args32.sdbc_ustatus; 718 break; 719 720 /* get the size of the global info pages for each board */ 721 case SDBC_GET_GLMUL_SIZES: 722 args->arg0 = (uint32_t)args32.arg0; /* int[CACHE_MEM_PAD] * */ 723 args->sdbc_ustatus = (spcs_s_info_t)args32.sdbc_ustatus; 724 break; 725 726 /* get the global info about write blocks */ 727 case SDBC_GET_GLMUL_INFO: 728 /* pointer to array[2*(sum of GLMUL_SIZES)] */ 729 args->arg0 = (uint32_t)args32.arg0; 730 args->sdbc_ustatus = (spcs_s_info_t)args32.sdbc_ustatus; 731 break; 732 733 case SDBC_SET_CD_HINT: 734 args->arg0 = args32.arg0; /* cd */ 735 args->arg1 = args32.arg1; /* hint */ 736 args->arg2 = args32.arg2; /* flag */ 737 args->sdbc_ustatus = (spcs_s_info_t)args32.sdbc_ustatus; 738 break; 739 740 case SDBC_GET_CD_HINT: 741 args->arg0 = args32.arg0; 742 args->sdbc_ustatus = (spcs_s_info_t)args32.sdbc_ustatus; 743 break; 744 745 case SDBC_SET_NODE_HINT: 746 args->arg0 = args32.arg0; /* hint */ 747 args->arg1 = args32.arg1; /* flag */ 748 args->sdbc_ustatus = (spcs_s_info_t)args32.sdbc_ustatus; 749 break; 750 751 case SDBC_GET_NODE_HINT: 752 args->sdbc_ustatus = (spcs_s_info_t)args32.sdbc_ustatus; 753 break; 754 755 case SDBC_STATS: 756 args->arg0 = (uint32_t)args32.arg0; /* (_sd_stats_t *) */ 757 args->sdbc_ustatus = (spcs_s_info_t)args32.sdbc_ustatus; 758 break; 759 760 case SDBC_ZAP_STATS: 761 args->sdbc_ustatus = (spcs_s_info_t)args32.sdbc_ustatus; 762 break; 763 764 case SDBC_GET_CD_BLK: 765 args->arg0 = args32.arg0; /* cd */ 766 args->arg1 = (uint32_t)args32.arg1; /* blk */ 767 args->arg2 = (uint32_t)args32.arg2; /* (addr[5] *) */ 768 break; 769 770 case SDBC_GET_CONFIG: 771 args->arg0 = (uint32_t)args32.arg0; /* (_sdbc_config_t *) */ 772 args->sdbc_ustatus = (spcs_s_info_t)args32.sdbc_ustatus; 773 break; 774 775 case SDBC_SET_CONFIG: 776 args->arg0 = (uint32_t)args32.arg0; /* (_sdbc_config_t *) */ 777 args->sdbc_ustatus = (spcs_s_info_t)args32.sdbc_ustatus; 778 break; 779 780 case SDBC_MAXFILES: 781 args->arg0 = (uint32_t)args32.arg0; /* (int * ) */ 782 args->sdbc_ustatus = (spcs_s_info_t)args32.sdbc_ustatus; 783 break; 784 785 #ifdef DEBUG 786 /* toggle flusher flag for testing */ 787 case SDBC_TOGGLE_FLUSH: 788 args->sdbc_ustatus = (spcs_s_info_t)args32.sdbc_ustatus; 789 break; 790 791 case SDBC_INJ_IOERR: /* cd, errnum */ 792 args->arg0 = args32.arg0; /* cd */ 793 args->arg1 = args32.arg1; /* i/o error number */ 794 args->arg2 = args32.arg2; /* countdown to issuing error */ 795 break; 796 797 /* clear injected i/o errors */ 798 case SDBC_CLR_IOERR: /* cd */ 799 args->arg0 = args32.arg0; /* cd */ 800 break; 801 #endif /* DEBUG */ 802 default: 803 return (EINVAL); 804 } 805 806 return (0); 807 } 808 #endif /* _MULTI_DATAMODEL */ 809 810 static int 811 sdbc_get_cd_blk(_sdbc_ioctl_t *args, int mode) 812 { 813 814 _sd_cctl_t *cc_ent; 815 caddr_t data; 816 char *taddr; 817 intptr_t addr[5]; 818 #ifdef _MULTI_DATAMODEL 819 uint32_t addr_32[5]; 820 #endif /* _MULTI_DATAMODEL */ 821 char *lookup_file = NULL; 822 int rc; 823 sdbc_info_t info; 824 nsc_off_t fba_pos; /* disk block number */ 825 826 if (_sd_cache_initialized == 0) { 827 return (EINVAL); 828 } 829 830 /* copyin the block number */ 831 if (ddi_copyin((void *)args->arg1, &fba_pos, sizeof (nsc_off_t), 832 mode)) { 833 return (EFAULT); 834 } 835 836 #ifdef _MULTI_DATAMODEL 837 if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) { 838 if (ddi_copyin((void *)args->arg2, addr_32, sizeof (addr_32), 839 mode)) { 840 return (EFAULT); 841 } 842 addr[0] = addr_32[0]; /* (sdbc_info_t *) */ 843 addr[1] = addr_32[1]; /* (char *) cdata */ 844 addr[2] = addr_32[2]; /* ( int * ) cblk_size */ 845 addr[3] = addr_32[3]; /* ( char * ) filename */ 846 addr[4] = addr_32[4]; /* ( char *) wdata */ 847 } else { 848 if (ddi_copyin((void *)args->arg2, addr, sizeof (addr), mode)) { 849 return (EFAULT); 850 } 851 } 852 #else /* _MULTI_DATAMODEL */ 853 if (ddi_copyin((void *)args->arg2, addr, sizeof (addr), mode)) { 854 return (EFAULT); 855 } 856 #endif /* _MULTI_DATAMODEL */ 857 858 (void) copyout(&CACHE_BLOCK_SIZE, (void *)addr[2], sizeof (int)); 859 860 if (_sd_get_cd_blk((int)args->arg0, FBA_TO_BLK_NUM(fba_pos), 861 &cc_ent, &data, &lookup_file)) { 862 if (lookup_file != NULL) 863 (void) copyout(lookup_file, (void *)addr[3], 864 NSC_MAXPATH); 865 return (ENOENT); 866 } 867 rc = 0; 868 taddr = NULL; 869 870 info.ci_write = cc_ent->cc_write ? 1 : 0; 871 info.ci_dirty = cc_ent->cc_dirty; 872 info.ci_valid = cc_ent->cc_valid; 873 info.ci_cd = CENTRY_CD(cc_ent); 874 info.ci_dblk = BLK_TO_FBA_NUM(CENTRY_BLK(cc_ent)); 875 (void) copyout(lookup_file, (void *)addr[3], NSC_MAXPATH); 876 (void) copyout(&info, (void *)addr[0], sizeof (sdbc_info_t)); 877 878 (void) copyout(data, (void *)addr[1], CACHE_BLOCK_SIZE); 879 880 /* get the write data if any */ 881 if (cc_ent->cc_write) { 882 883 if (sdbc_safestore) { 884 cmn_err(CE_WARN, 885 "!sdbc(sdbc_get_cd_blk) cc_write 0x%p sc-res 0x%p", 886 (void *)cc_ent->cc_write, 887 (void *)cc_ent->cc_write->sc_res); 888 889 if ((taddr = kmem_alloc(CACHE_BLOCK_SIZE, 890 KM_NOSLEEP)) == NULL) { 891 cmn_err(CE_WARN, 892 "!sdbc(sdbc_get_cd_blk) kmem_alloc failed." 893 " cannot get write data"); 894 info.ci_write = NULL; 895 rc = EFAULT; 896 } else if (SSOP_READ_CBLOCK(sdbc_safestore, 897 cc_ent->cc_write->sc_res, taddr, 898 CACHE_BLOCK_SIZE, 0) == SS_ERR) { 899 900 cmn_err(CE_WARN, "sdbc(sdbc_get_cd_blk) " 901 "!safestore read failed"); 902 rc = EFAULT; 903 904 } else if (copyout(taddr, (void *)addr[4], 905 CACHE_BLOCK_SIZE)) { 906 cmn_err(CE_WARN, 907 "!sdbc(sdbc_get_cd_blk) copyout failed." 908 " cannot get write data"); 909 rc = EFAULT; 910 } 911 } 912 913 } 914 915 if (taddr) 916 kmem_free(taddr, CACHE_BLOCK_SIZE); 917 918 return (rc); 919 } 920 921 /* ARGSUSED */ 922 static int 923 sdbcioctl(dev_t dev, int cmd, void *arg, int mode, cred_t *crp, int *rvp) 924 { 925 int rc = 0; 926 _sdbc_ioctl_t args; 927 int convert_32 = 0; 928 spcs_s_info_t kstatus; 929 930 *rvp = 0; 931 932 #ifdef _MULTI_DATAMODEL 933 if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) { 934 int rc; 935 convert_32 = 1; 936 if ((rc = convert_ioctl_args(cmd, arg, mode, &args)) != 0) 937 return (rc); 938 } else { 939 if (ddi_copyin(arg, &args, sizeof (_sdbc_ioctl_t), mode)) { 940 return (EFAULT); 941 } 942 } 943 #else /* _MULTI_DATAMODEL */ 944 if (ddi_copyin(arg, &args, sizeof (_sdbc_ioctl_t), mode)) { 945 return (EFAULT); 946 } 947 #endif /* _MULTI_DATAMODEL */ 948 949 kstatus = spcs_s_kcreate(); 950 if (!kstatus) 951 return (ENOMEM); 952 953 switch (cmd) { 954 955 case SDBC_UNUSED_1: 956 case SDBC_UNUSED_2: 957 case SDBC_UNUSED_3: 958 959 return (spcs_s_ocopyoutf(&kstatus, args.sdbc_ustatus, 960 SDBC_EOBSOLETE)); 961 962 case SDBC_ADUMP: 963 rc = _sd_adump(&args, rvp); 964 break; 965 966 case SDBC_TEST_INIT: 967 rc = _sd_test_init(&args); 968 break; 969 970 case SDBC_TEST_START: 971 rc = _sd_test_start(&args, rvp); 972 break; 973 974 case SDBC_TEST_END: 975 rc = _sd_test_end(); 976 break; 977 978 case SDBC_ENABLE: 979 mutex_enter(&_sdbc_config_lock); 980 rc = _sdbc_configure((_sd_cache_param_t *)args.arg0, 981 NULL, kstatus); 982 if (rc && rc != EALREADY && rc != SDBC_ENONETMEM) { 983 (void) _sdbc_deconfigure(kstatus); 984 mutex_exit(&_sdbc_config_lock); 985 return (spcs_s_ocopyoutf 986 (&kstatus, args.sdbc_ustatus, rc)); 987 } 988 mutex_exit(&_sdbc_config_lock); 989 return (spcs_s_ocopyoutf(&kstatus, args.sdbc_ustatus, rc)); 990 991 case SDBC_DISABLE: 992 mutex_enter(&_sdbc_config_lock); 993 if (_sd_cache_initialized == 0) { 994 995 mutex_exit(&_sdbc_config_lock); 996 return (spcs_s_ocopyoutf(&kstatus, args.sdbc_ustatus, 997 SDBC_EDISABLE)); 998 } 999 rc = _sdbc_deconfigure(kstatus); 1000 mutex_exit(&_sdbc_config_lock); 1001 return (spcs_s_ocopyoutf(&kstatus, args.sdbc_ustatus, rc)); 1002 1003 case SDBC_GET_CLUSTER_SIZE: 1004 if (_sd_cache_initialized == 0) { 1005 1006 return (spcs_s_ocopyoutf(&kstatus, args.sdbc_ustatus, 1007 SDBC_ECLUSTER_SIZE)); 1008 } 1009 1010 rc = sd_get_file_info_size((void *)args.arg0); 1011 break; 1012 1013 /* get the gl_file data */ 1014 case SDBC_GET_CLUSTER_DATA: 1015 if (_sd_cache_initialized == 0) { 1016 1017 return (spcs_s_ocopyoutf(&kstatus, args.sdbc_ustatus, 1018 SDBC_ECLUSTER_DATA)); 1019 } 1020 rc = sd_get_file_info_data((void *)args.arg0); 1021 break; 1022 1023 /* get the size of the global info pages for each board */ 1024 case SDBC_GET_GLMUL_SIZES: 1025 if (_sd_cache_initialized == 0) { 1026 return (spcs_s_ocopyoutf(&kstatus, args.sdbc_ustatus, 1027 SDBC_EGLMUL_SIZE)); 1028 } 1029 rc = sd_get_glmul_sizes((void *)args.arg0); 1030 break; 1031 1032 /* get the global info about write blocks */ 1033 case SDBC_GET_GLMUL_INFO: 1034 if (_sd_cache_initialized == 0) { 1035 1036 return (spcs_s_ocopyoutf(&kstatus, args.sdbc_ustatus, 1037 SDBC_EGLMUL_INFO)); 1038 1039 } 1040 rc = sd_get_glmul_info((void *)args.arg0); 1041 break; 1042 1043 case SDBC_SET_CD_HINT: 1044 if (_sd_cache_initialized == 0) 1045 return (spcs_s_ocopyoutf(&kstatus, 1046 args.sdbc_ustatus, EINVAL)); 1047 rc = ((args.arg2) ? 1048 _sd_set_hint((int)args.arg0, (uint_t)args.arg1) : 1049 _sd_clear_hint((int)args.arg0, (uint_t)args.arg1)); 1050 return (spcs_s_ocopyoutf(&kstatus, args.sdbc_ustatus, rc)); 1051 1052 case SDBC_GET_CD_HINT: 1053 { 1054 uint_t hint; 1055 1056 if (_sd_cache_initialized == 0) 1057 return (spcs_s_ocopyoutf(&kstatus, 1058 args.sdbc_ustatus, EINVAL)); 1059 if ((rc = _sd_get_cd_hint((int)args.arg0, &hint)) == 0) 1060 *rvp = hint; 1061 return (spcs_s_ocopyoutf(&kstatus, args.sdbc_ustatus, 1062 rc)); 1063 } 1064 1065 case SDBC_SET_NODE_HINT: 1066 rc = ((args.arg1) ? _sd_set_node_hint((uint_t)args.arg0) : 1067 _sd_clear_node_hint((uint_t)args.arg0)); 1068 if (rc) 1069 return (spcs_s_ocopyoutf(&kstatus, args.sdbc_ustatus, 1070 rc)); 1071 /* FALLTHRU */ 1072 case SDBC_GET_NODE_HINT: 1073 { 1074 uint_t hint; 1075 if ((rc = _sd_get_node_hint(&hint)) == 0) 1076 *rvp = hint; 1077 return (spcs_s_ocopyoutf(&kstatus, args.sdbc_ustatus, 1078 rc)); 1079 } 1080 1081 case SDBC_STATS: 1082 rc = _sd_get_stats((void *)args.arg0, convert_32); 1083 return (spcs_s_ocopyoutf(&kstatus, args.sdbc_ustatus, rc)); 1084 1085 case SDBC_ZAP_STATS: 1086 _sd_zap_stats(); 1087 return (spcs_s_ocopyoutf(&kstatus, args.sdbc_ustatus, 0)); 1088 1089 case SDBC_GET_CD_BLK: 1090 if (_sd_cache_initialized == 0) 1091 return (spcs_s_ocopyoutf(&kstatus, 1092 args.sdbc_ustatus, EINVAL)); 1093 rc = sdbc_get_cd_blk(&args, mode); 1094 break; 1095 1096 case SDBC_GET_CONFIG: 1097 { 1098 _sdbc_config_t sdbc_config_info; 1099 1100 if (ddi_copyin((void *)args.arg0, 1101 &sdbc_config_info, 1102 sizeof (_sdbc_config_t), 1103 mode)) { 1104 spcs_s_kfree(kstatus); 1105 return (EFAULT); 1106 } 1107 rc = _sdbc_get_config(&sdbc_config_info); 1108 (void) ddi_copyout(&sdbc_config_info, 1109 (void *)args.arg0, 1110 sizeof (_sdbc_config_t), 1111 mode); 1112 return (spcs_s_ocopyoutf(&kstatus, args.sdbc_ustatus, rc)); 1113 } 1114 1115 case SDBC_SET_CONFIG: 1116 { 1117 _sdbc_config_t mgmt_config_info; 1118 1119 if (ddi_copyin((void *)args.arg0, 1120 &mgmt_config_info, 1121 sizeof (_sdbc_config_t), 1122 mode)) { 1123 spcs_s_kfree(kstatus); 1124 return (EFAULT); 1125 } 1126 1127 rc = _sdbc_configure(NULL, &mgmt_config_info, kstatus); 1128 if (rc && rc != EALREADY) { 1129 (void) _sdbc_deconfigure(kstatus); 1130 return (spcs_s_ocopyoutf 1131 (&kstatus, args.sdbc_ustatus, rc)); 1132 } 1133 1134 return (spcs_s_ocopyoutf(&kstatus, args.sdbc_ustatus, rc)); 1135 } 1136 1137 case SDBC_MAXFILES: 1138 if (copyout(&sdbc_max_devs, (void *)args.arg0, 1139 sizeof (sdbc_max_devs))) 1140 rc = EFAULT; 1141 else 1142 rc = 0; 1143 1144 break; 1145 1146 case SDBC_VERSION: 1147 { 1148 cache_version_t cache_version; 1149 1150 cache_version.major = sdbc_major_rev; 1151 cache_version.minor = sdbc_minor_rev; 1152 cache_version.micro = sdbc_micro_rev; 1153 cache_version.baseline = sdbc_baseline_rev; 1154 1155 if (ddi_copyout(&cache_version, (void *)args.arg0, 1156 sizeof (cache_version_t), mode)) { 1157 rc = EFAULT; 1158 break; 1159 } 1160 1161 break; 1162 } 1163 1164 1165 #ifdef DEBUG 1166 /* toggle flusher flag for testing */ 1167 case SDBC_TOGGLE_FLUSH: 1168 _sdbc_flush_flag ^= 1; 1169 *rvp = _sdbc_flush_flag; 1170 rc = 0; 1171 1172 return (spcs_s_ocopyoutf(&kstatus, args.sdbc_ustatus, 1173 SDBC_ETOGGLE_FLUSH, _sdbc_flush_flag ? "on" : "off")); 1174 1175 1176 /* inject i/o errors */ 1177 case SDBC_INJ_IOERR: /* cd, errnum */ 1178 if (_sd_cache_initialized == 0) 1179 return (spcs_s_ocopyoutf(&kstatus, 1180 args.sdbc_ustatus, EINVAL)); 1181 rc = _sdbc_inject_ioerr(args.arg0, args.arg1, args.arg2); 1182 break; 1183 1184 /* clear injected i/o errors */ 1185 case SDBC_CLR_IOERR: /* cd */ 1186 if (_sd_cache_initialized == 0) 1187 return (spcs_s_ocopyoutf(&kstatus, 1188 args.sdbc_ustatus, EINVAL)); 1189 rc = _sdbc_clear_ioerr(args.arg0); 1190 break; 1191 1192 #endif /* DEBUG */ 1193 default: 1194 _sd_print(3, "!SDBC unknown ioctl: 0x%x unsupported", cmd); 1195 rc = EINVAL; 1196 break; 1197 } 1198 1199 spcs_s_kfree(kstatus); 1200 return (rc); 1201 } 1202 1203 1204 /* 1205 * _sd_timed_block - sleep waiting for ticks time delay. 1206 * ticks - # of ticks to sleep 1207 * cvp - pointer to the cv we wait on while we delay. 1208 * 1209 * NO spin locks can be held at entry! 1210 * 1211 */ 1212 void 1213 _sd_timed_block(clock_t ticks, kcondvar_t *cvp) 1214 { 1215 mutex_enter(&_sd_block_lk); 1216 (void) cv_reltimedwait(cvp, &_sd_block_lk, ticks, TR_CLOCK_TICK); 1217 mutex_exit(&_sd_block_lk); 1218 } 1219 1220 1221 /* 1222 * _sd_unblock - awake a sleeper waiting on cv pointed to by cvp. 1223 * 1224 * NO spin locks can be held at entry as we may sleep. 1225 * 1226 */ 1227 void 1228 _sd_unblock(kcondvar_t *cvp) 1229 { 1230 1231 mutex_enter(&_sd_block_lk); 1232 cv_broadcast(cvp); 1233 mutex_exit(&_sd_block_lk); 1234 } 1235 1236 /* ARGSUSED */ 1237 void 1238 _sd_data_log(int num, _sd_cctl_t *centry, nsc_off_t st, nsc_size_t len) 1239 { 1240 #if defined(_SD_FBA_DATA_LOG) 1241 nsc_size_t i; 1242 nsc_off_t blk; 1243 1244 blk = BLK_TO_FBA_NUM(CENTRY_BLK(centry)); 1245 for (i = st; i < (st + len); i++) 1246 SDTRACE(num, CENTRY_CD(centry), 1, blk + i, 1247 *(int *)(centry->cc_data + FBA_SIZE(i)), 1248 *(int *)(centry->cc_data + FBA_SIZE(i) + 4)); 1249 #endif /* _SD_FBA_DATA_LOG */ 1250 } 1251 1252 /* ARGSUSED */ 1253 void 1254 _sd_data_log_chain(int num, _sd_cctl_t *centry, nsc_off_t fba_pos, 1255 nsc_size_t fba_len) 1256 { 1257 #if defined(_SD_FBA_DATA_LOG) 1258 sdbc_cblk_fba_t st_cblk_len; /* FBA len of starting cache block */ 1259 sdbc_cblk_fba_t end_cblk_len; /* FBA len of ending cache block */ 1260 sdbc_cblk_fba_t st_cblk_off; /* FBA offset into starting cblock */ 1261 1262 while (CENTRY_BLK(centry) != FBA_TO_BLK_NUM(fba_pos)) 1263 centry = centry->cc_chain; 1264 1265 st_cblk_off = BLK_FBA_OFF(fba_pos); 1266 st_cblk_len = BLK_FBAS - st_cblk_off; 1267 if (st_cblk_len >= fba_len) { 1268 end_cblk_len = 0; 1269 st_cblk_len = fba_len; 1270 } else { 1271 end_cblk_len = BLK_FBA_OFF(fba_pos + fba_len); 1272 } 1273 1274 DATA_LOG(num, centry, st_cblk_off, st_cblk_len); 1275 1276 fba_len -= st_cblk_len; 1277 centry = centry->cc_chain; 1278 1279 while (fba_len > end_cblk_len) { 1280 DATA_LOG(num, centry, 0, BLK_FBAS); 1281 fba_len -= BLK_FBAS; 1282 centry = centry->cc_chain; 1283 } 1284 if (end_cblk_len) DATA_LOG(num, centry, 0, end_cblk_len); 1285 #endif /* _SD_FBA_DATA_LOG */ 1286 } 1287 1288 1289 void 1290 _sd_zap_stats(void) 1291 { 1292 int i; 1293 1294 if (_sd_cache_stats == NULL) 1295 return; 1296 1297 _sd_cache_stats->st_rdhits = 0; 1298 _sd_cache_stats->st_rdmiss = 0; 1299 _sd_cache_stats->st_wrhits = 0; 1300 _sd_cache_stats->st_wrmiss = 0; 1301 _sd_lru_q.sq_noreq_stat = 0; 1302 _sd_lru_q.sq_req_stat = 0; 1303 1304 for (i = 0; i < sdbc_max_devs; i++) { 1305 _sd_cache_stats->st_shared[i].sh_cache_read = 0; 1306 _sd_cache_stats->st_shared[i].sh_cache_write = 0; 1307 _sd_cache_stats->st_shared[i].sh_disk_read = 0; 1308 _sd_cache_stats->st_shared[i].sh_disk_write = 0; 1309 } 1310 } 1311 1312 1313 /* 1314 * Return the cache sizes used by the Sense Subsystem Status CCW 1315 */ 1316 int 1317 _sd_cache_sizes(int *asize, int *wsize) 1318 { 1319 int psize; 1320 1321 *asize = 0; 1322 *wsize = 0; 1323 1324 /* 1325 * add in the total cache size and the 1326 * non-volatile (battery-backed) cache size. 1327 */ 1328 if (_sd_net_config.sn_configured) { 1329 psize = _sd_net_config.sn_psize; 1330 *asize += (_sd_net_config.sn_cpages * psize); 1331 *wsize += (safestore_config.ssc_wsize); 1332 } 1333 1334 return (0); 1335 } 1336 1337 1338 /*PRINTFLIKE2*/ 1339 void 1340 _sd_print(int level, char *fmt, ...) 1341 { 1342 va_list adx; 1343 if (level <= _sd_debug_level) { 1344 va_start(adx, fmt); 1345 vcmn_err(CE_NOTE, fmt, adx); 1346 va_end(adx); 1347 1348 } 1349 } 1350 1351 1352 int 1353 _sd_get_cd_blk(int cd, nsc_off_t cblk, _sd_cctl_t **cc, caddr_t *data, 1354 char **filename) 1355 { 1356 _sd_cctl_t *cc_ent; 1357 1358 if (FILE_OPENED(cd) != 0) { 1359 *filename = _sd_cache_files[cd].cd_info->sh_filename; 1360 if (cc_ent = (_sd_cctl_t *) 1361 _sd_hash_search(cd, cblk, _sd_htable)) { 1362 *cc = cc_ent; 1363 *data = (caddr_t)cc_ent->cc_data; 1364 return (0); 1365 } 1366 } 1367 return (-1); 1368 } 1369 1370 /* 1371 * central dyn mem processing vars edit rtn. 1372 * input a local copy and xfer to global 1373 * 1374 * sec0,sec1,sec2 1375 * range check 1 to 255 (arbitrary but in any case must be <= 2000 due to 1376 * 32bit signed int limits in later calc) 1377 * aging_ct 1378 * range check 1 to 255 (only 8 bits reserved for aging ctr) 1379 * 1380 */ 1381 int 1382 sdbc_edit_xfer_process_vars_dm(_dm_process_vars_t *process_vars) 1383 { 1384 if (process_vars->max_dyn_list > 0) 1385 dynmem_processing_dm.max_dyn_list = process_vars->max_dyn_list; 1386 1387 /* no edit on monitor_dynmem_process */ 1388 dynmem_processing_dm.monitor_dynmem_process = 1389 process_vars->monitor_dynmem_process; 1390 /* no edit on process_directive */ 1391 dynmem_processing_dm.process_directive = 1392 process_vars->process_directive; 1393 1394 if (process_vars->cache_aging_ct1 > 0 && 1395 process_vars->cache_aging_ct1 <= CACHE_AGING_CT_MAX) 1396 dynmem_processing_dm.cache_aging_ct1 = 1397 process_vars->cache_aging_ct1; 1398 if (process_vars->cache_aging_ct2 > 0 && 1399 process_vars->cache_aging_ct2 <= CACHE_AGING_CT_MAX) 1400 dynmem_processing_dm.cache_aging_ct2 = 1401 process_vars->cache_aging_ct2; 1402 if (process_vars->cache_aging_ct3 > 0 && 1403 process_vars->cache_aging_ct3 <= CACHE_AGING_CT_MAX) 1404 dynmem_processing_dm.cache_aging_ct3 = 1405 process_vars->cache_aging_ct3; 1406 if (process_vars->cache_aging_sec1 > 0 && 1407 process_vars->cache_aging_sec1 <= CACHE_AGING_SEC1_MAX) 1408 dynmem_processing_dm.cache_aging_sec1 = 1409 process_vars->cache_aging_sec1; 1410 if (process_vars->cache_aging_sec2 > 0 && 1411 process_vars->cache_aging_sec2 <= CACHE_AGING_SEC2_MAX) 1412 dynmem_processing_dm.cache_aging_sec2 = 1413 process_vars->cache_aging_sec2; 1414 if (process_vars->cache_aging_sec3 > 0 && 1415 process_vars->cache_aging_sec3 <= CACHE_AGING_SEC3_MAX) 1416 dynmem_processing_dm.cache_aging_sec3 = 1417 process_vars->cache_aging_sec3; 1418 if (process_vars->cache_aging_pcnt1 >= 0 && 1419 process_vars->cache_aging_pcnt1 <= CACHE_AGING_PCNT1_MAX) 1420 dynmem_processing_dm.cache_aging_pcnt1 = 1421 process_vars->cache_aging_pcnt1; 1422 if (process_vars->cache_aging_pcnt2 >= 0 && 1423 process_vars->cache_aging_pcnt2 <= CACHE_AGING_PCNT2_MAX) 1424 dynmem_processing_dm.cache_aging_pcnt2 = 1425 process_vars->cache_aging_pcnt2; 1426 if (process_vars->max_holds_pcnt >= 0 && 1427 process_vars->max_holds_pcnt <= MAX_HOLDS_PCNT_MAX) 1428 dynmem_processing_dm.max_holds_pcnt = 1429 process_vars->max_holds_pcnt; 1430 return (0); 1431 } 1432 1433 dev_info_t * 1434 sdbc_get_dip() 1435 { 1436 return (dev_dip); 1437 } 1438