10094 i_mdi_client_free() doesn't need to check for a NULL cdip
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 (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved. 23 * Copyright (c) 2014 Nexenta Systems Inc. All rights reserved. 24 */ 25 26 /* 27 * Multipath driver interface (MDI) implementation; see mdi_impldefs.h for a 28 * more detailed discussion of the overall mpxio architecture. 29 * 30 * Default locking order: 31 * 32 * _NOTE(LOCK_ORDER(mdi_mutex, mdi_vhci:vh_phci_mutex); 33 * _NOTE(LOCK_ORDER(mdi_mutex, mdi_vhci:vh_client_mutex); 34 * _NOTE(LOCK_ORDER(mdi_vhci:vh_phci_mutex, mdi_phci::ph_mutex); 35 * _NOTE(LOCK_ORDER(mdi_vhci:vh_client_mutex, mdi_client::ct_mutex); 36 * _NOTE(LOCK_ORDER(mdi_phci::ph_mutex mdi_pathinfo::pi_mutex)) 37 * _NOTE(LOCK_ORDER(mdi_phci::ph_mutex mdi_client::ct_mutex)) 38 * _NOTE(LOCK_ORDER(mdi_client::ct_mutex mdi_pathinfo::pi_mutex)) 39 */ 40 41 #include <sys/note.h> 42 #include <sys/types.h> 43 #include <sys/varargs.h> 44 #include <sys/param.h> 45 #include <sys/errno.h> 46 #include <sys/uio.h> 47 #include <sys/buf.h> 48 #include <sys/modctl.h> 49 #include <sys/open.h> 50 #include <sys/kmem.h> 51 #include <sys/poll.h> 52 #include <sys/conf.h> 53 #include <sys/bootconf.h> 54 #include <sys/cmn_err.h> 55 #include <sys/stat.h> 56 #include <sys/ddi.h> 57 #include <sys/sunddi.h> 58 #include <sys/ddipropdefs.h> 59 #include <sys/sunndi.h> 60 #include <sys/ndi_impldefs.h> 61 #include <sys/promif.h> 62 #include <sys/sunmdi.h> 63 #include <sys/mdi_impldefs.h> 64 #include <sys/taskq.h> 65 #include <sys/epm.h> 66 #include <sys/sunpm.h> 67 #include <sys/modhash.h> 68 #include <sys/disp.h> 69 #include <sys/autoconf.h> 70 #include <sys/sysmacros.h> 71 72 #ifdef DEBUG 73 #include <sys/debug.h> 74 int mdi_debug = 1; 75 int mdi_debug_logonly = 0; 76 #define MDI_DEBUG(dbglevel, pargs) if (mdi_debug >= (dbglevel)) i_mdi_log pargs 77 #define MDI_WARN CE_WARN, __func__ 78 #define MDI_NOTE CE_NOTE, __func__ 79 #define MDI_CONT CE_CONT, __func__ 80 static void i_mdi_log(int, const char *, dev_info_t *, const char *, ...); 81 #else /* !DEBUG */ 82 #define MDI_DEBUG(dbglevel, pargs) 83 #endif /* DEBUG */ 84 int mdi_debug_consoleonly = 0; 85 int mdi_delay = 3; 86 87 extern pri_t minclsyspri; 88 extern int modrootloaded; 89 90 /* 91 * Global mutex: 92 * Protects vHCI list and structure members. 93 */ 94 kmutex_t mdi_mutex; 95 96 /* 97 * Registered vHCI class driver lists 98 */ 99 int mdi_vhci_count; 100 mdi_vhci_t *mdi_vhci_head; 101 mdi_vhci_t *mdi_vhci_tail; 102 103 /* 104 * Client Hash Table size 105 */ 106 static int mdi_client_table_size = CLIENT_HASH_TABLE_SIZE; 107 108 /* 109 * taskq interface definitions 110 */ 111 #define MDI_TASKQ_N_THREADS 8 112 #define MDI_TASKQ_PRI minclsyspri 113 #define MDI_TASKQ_MINALLOC (4*mdi_taskq_n_threads) 114 #define MDI_TASKQ_MAXALLOC (500*mdi_taskq_n_threads) 115 116 taskq_t *mdi_taskq; 117 static uint_t mdi_taskq_n_threads = MDI_TASKQ_N_THREADS; 118 119 #define TICKS_PER_SECOND (drv_usectohz(1000000)) 120 121 /* 122 * The data should be "quiet" for this interval (in seconds) before the 123 * vhci cached data is flushed to the disk. 124 */ 125 static int mdi_vhcache_flush_delay = 10; 126 127 /* number of seconds the vhcache flush daemon will sleep idle before exiting */ 128 static int mdi_vhcache_flush_daemon_idle_time = 60; 129 130 /* 131 * MDI falls back to discovery of all paths when a bus_config_one fails. 132 * The following parameters can be used to tune this operation. 133 * 134 * mdi_path_discovery_boot 135 * Number of times path discovery will be attempted during early boot. 136 * Probably there is no reason to ever set this value to greater than one. 137 * 138 * mdi_path_discovery_postboot 139 * Number of times path discovery will be attempted after early boot. 140 * Set it to a minimum of two to allow for discovery of iscsi paths which 141 * may happen very late during booting. 142 * 143 * mdi_path_discovery_interval 144 * Minimum number of seconds MDI will wait between successive discovery 145 * of all paths. Set it to -1 to disable discovery of all paths. 146 */ 147 static int mdi_path_discovery_boot = 1; 148 static int mdi_path_discovery_postboot = 2; 149 static int mdi_path_discovery_interval = 10; 150 151 /* 152 * number of seconds the asynchronous configuration thread will sleep idle 153 * before exiting. 154 */ 155 static int mdi_async_config_idle_time = 600; 156 157 static int mdi_bus_config_cache_hash_size = 256; 158 159 /* turns off multithreaded configuration for certain operations */ 160 static int mdi_mtc_off = 0; 161 162 /* 163 * The "path" to a pathinfo node is identical to the /devices path to a 164 * devinfo node had the device been enumerated under a pHCI instead of 165 * a vHCI. This pathinfo "path" is associated with a 'path_instance'. 166 * This association persists across create/delete of the pathinfo nodes, 167 * but not across reboot. 168 */ 169 static uint_t mdi_pathmap_instance = 1; /* 0 -> any path */ 170 static int mdi_pathmap_hash_size = 256; 171 static kmutex_t mdi_pathmap_mutex; 172 static mod_hash_t *mdi_pathmap_bypath; /* "path"->instance */ 173 static mod_hash_t *mdi_pathmap_byinstance; /* instance->"path" */ 174 static mod_hash_t *mdi_pathmap_sbyinstance; /* inst->shortpath */ 175 176 /* 177 * MDI component property name/value string definitions 178 */ 179 const char *mdi_component_prop = "mpxio-component"; 180 const char *mdi_component_prop_vhci = "vhci"; 181 const char *mdi_component_prop_phci = "phci"; 182 const char *mdi_component_prop_client = "client"; 183 184 /* 185 * MDI client global unique identifier property name 186 */ 187 const char *mdi_client_guid_prop = "client-guid"; 188 189 /* 190 * MDI client load balancing property name/value string definitions 191 */ 192 const char *mdi_load_balance = "load-balance"; 193 const char *mdi_load_balance_none = "none"; 194 const char *mdi_load_balance_rr = "round-robin"; 195 const char *mdi_load_balance_lba = "logical-block"; 196 197 /* 198 * Obsolete vHCI class definition; to be removed after Leadville update 199 */ 200 const char *mdi_vhci_class_scsi = MDI_HCI_CLASS_SCSI; 201 202 static char vhci_greeting[] = 203 "\tThere already exists one vHCI driver for class %s\n" 204 "\tOnly one vHCI driver for each class is allowed\n"; 205 206 /* 207 * Static function prototypes 208 */ 209 static int i_mdi_phci_offline(dev_info_t *, uint_t); 210 static int i_mdi_client_offline(dev_info_t *, uint_t); 211 static int i_mdi_phci_pre_detach(dev_info_t *, ddi_detach_cmd_t); 212 static void i_mdi_phci_post_detach(dev_info_t *, 213 ddi_detach_cmd_t, int); 214 static int i_mdi_client_pre_detach(dev_info_t *, 215 ddi_detach_cmd_t); 216 static void i_mdi_client_post_detach(dev_info_t *, 217 ddi_detach_cmd_t, int); 218 static void i_mdi_pm_hold_pip(mdi_pathinfo_t *); 219 static void i_mdi_pm_rele_pip(mdi_pathinfo_t *); 220 static int i_mdi_lba_lb(mdi_client_t *ct, 221 mdi_pathinfo_t **ret_pip, struct buf *buf); 222 static void i_mdi_pm_hold_client(mdi_client_t *, int); 223 static void i_mdi_pm_rele_client(mdi_client_t *, int); 224 static void i_mdi_pm_reset_client(mdi_client_t *); 225 static int i_mdi_power_all_phci(mdi_client_t *); 226 static void i_mdi_log_sysevent(dev_info_t *, char *, char *); 227 228 229 /* 230 * Internal mdi_pathinfo node functions 231 */ 232 static void i_mdi_pi_kstat_destroy(mdi_pathinfo_t *); 233 234 static mdi_vhci_t *i_mdi_vhci_class2vhci(char *); 235 static mdi_vhci_t *i_devi_get_vhci(dev_info_t *); 236 static mdi_phci_t *i_devi_get_phci(dev_info_t *); 237 static void i_mdi_phci_lock(mdi_phci_t *, mdi_pathinfo_t *); 238 static void i_mdi_phci_unlock(mdi_phci_t *); 239 static mdi_pathinfo_t *i_mdi_pi_alloc(mdi_phci_t *, char *, mdi_client_t *); 240 static void i_mdi_phci_add_path(mdi_phci_t *, mdi_pathinfo_t *); 241 static void i_mdi_client_add_path(mdi_client_t *, mdi_pathinfo_t *); 242 static void i_mdi_pi_free(mdi_phci_t *ph, mdi_pathinfo_t *, 243 mdi_client_t *); 244 static void i_mdi_phci_remove_path(mdi_phci_t *, mdi_pathinfo_t *); 245 static void i_mdi_client_remove_path(mdi_client_t *, 246 mdi_pathinfo_t *); 247 248 static int i_mdi_pi_state_change(mdi_pathinfo_t *, 249 mdi_pathinfo_state_t, int); 250 static int i_mdi_pi_offline(mdi_pathinfo_t *, int); 251 static dev_info_t *i_mdi_devinfo_create(mdi_vhci_t *, char *, char *, 252 char **, int); 253 static dev_info_t *i_mdi_devinfo_find(mdi_vhci_t *, char *, char *); 254 static int i_mdi_devinfo_remove(dev_info_t *, dev_info_t *, int); 255 static int i_mdi_is_child_present(dev_info_t *, dev_info_t *); 256 static mdi_client_t *i_mdi_client_alloc(mdi_vhci_t *, char *, char *); 257 static void i_mdi_client_enlist_table(mdi_vhci_t *, mdi_client_t *); 258 static void i_mdi_client_delist_table(mdi_vhci_t *, mdi_client_t *); 259 static mdi_client_t *i_mdi_client_find(mdi_vhci_t *, char *, char *); 260 static void i_mdi_client_update_state(mdi_client_t *); 261 static int i_mdi_client_compute_state(mdi_client_t *, 262 mdi_phci_t *); 263 static void i_mdi_client_lock(mdi_client_t *, mdi_pathinfo_t *); 264 static void i_mdi_client_unlock(mdi_client_t *); 265 static int i_mdi_client_free(mdi_vhci_t *, mdi_client_t *); 266 static mdi_client_t *i_devi_get_client(dev_info_t *); 267 /* 268 * NOTE: this will be removed once the NWS files are changed to use the new 269 * mdi_{enable,disable}_path interfaces 270 */ 271 static int i_mdi_pi_enable_disable(dev_info_t *, dev_info_t *, 272 int, int); 273 static mdi_pathinfo_t *i_mdi_enable_disable_path(mdi_pathinfo_t *pip, 274 mdi_vhci_t *vh, int flags, int op); 275 /* 276 * Failover related function prototypes 277 */ 278 static int i_mdi_failover(void *); 279 280 /* 281 * misc internal functions 282 */ 283 static int i_mdi_get_hash_key(char *); 284 static int i_map_nvlist_error_to_mdi(int); 285 static void i_mdi_report_path_state(mdi_client_t *, 286 mdi_pathinfo_t *); 287 288 static void setup_vhci_cache(mdi_vhci_t *); 289 static int destroy_vhci_cache(mdi_vhci_t *); 290 static int stop_vhcache_async_threads(mdi_vhci_config_t *); 291 static boolean_t stop_vhcache_flush_thread(void *, int); 292 static void free_string_array(char **, int); 293 static void free_vhcache_phci(mdi_vhcache_phci_t *); 294 static void free_vhcache_pathinfo(mdi_vhcache_pathinfo_t *); 295 static void free_vhcache_client(mdi_vhcache_client_t *); 296 static int mainnvl_to_vhcache(mdi_vhci_cache_t *, nvlist_t *); 297 static nvlist_t *vhcache_to_mainnvl(mdi_vhci_cache_t *); 298 static void vhcache_phci_add(mdi_vhci_config_t *, mdi_phci_t *); 299 static void vhcache_phci_remove(mdi_vhci_config_t *, mdi_phci_t *); 300 static void vhcache_pi_add(mdi_vhci_config_t *, 301 struct mdi_pathinfo *); 302 static void vhcache_pi_remove(mdi_vhci_config_t *, 303 struct mdi_pathinfo *); 304 static void free_phclient_path_list(mdi_phys_path_t *); 305 static void sort_vhcache_paths(mdi_vhcache_client_t *); 306 static int flush_vhcache(mdi_vhci_config_t *, int); 307 static void vhcache_dirty(mdi_vhci_config_t *); 308 static void free_async_client_config(mdi_async_client_config_t *); 309 static void single_threaded_vhconfig_enter(mdi_vhci_config_t *); 310 static void single_threaded_vhconfig_exit(mdi_vhci_config_t *); 311 static nvlist_t *read_on_disk_vhci_cache(char *); 312 extern int fread_nvlist(char *, nvlist_t **); 313 extern int fwrite_nvlist(char *, nvlist_t *); 314 315 /* called once when first vhci registers with mdi */ 316 static void 317 i_mdi_init() 318 { 319 static int initialized = 0; 320 321 if (initialized) 322 return; 323 initialized = 1; 324 325 mutex_init(&mdi_mutex, NULL, MUTEX_DEFAULT, NULL); 326 327 /* Create our taskq resources */ 328 mdi_taskq = taskq_create("mdi_taskq", mdi_taskq_n_threads, 329 MDI_TASKQ_PRI, MDI_TASKQ_MINALLOC, MDI_TASKQ_MAXALLOC, 330 TASKQ_PREPOPULATE | TASKQ_CPR_SAFE); 331 ASSERT(mdi_taskq != NULL); /* taskq_create never fails */ 332 333 /* Allocate ['path_instance' <-> "path"] maps */ 334 mutex_init(&mdi_pathmap_mutex, NULL, MUTEX_DRIVER, NULL); 335 mdi_pathmap_bypath = mod_hash_create_strhash( 336 "mdi_pathmap_bypath", mdi_pathmap_hash_size, 337 mod_hash_null_valdtor); 338 mdi_pathmap_byinstance = mod_hash_create_idhash( 339 "mdi_pathmap_byinstance", mdi_pathmap_hash_size, 340 mod_hash_null_valdtor); 341 mdi_pathmap_sbyinstance = mod_hash_create_idhash( 342 "mdi_pathmap_sbyinstance", mdi_pathmap_hash_size, 343 mod_hash_null_valdtor); 344 } 345 346 /* 347 * mdi_get_component_type(): 348 * Return mpxio component type 349 * Return Values: 350 * MDI_COMPONENT_NONE 351 * MDI_COMPONENT_VHCI 352 * MDI_COMPONENT_PHCI 353 * MDI_COMPONENT_CLIENT 354 * XXX This doesn't work under multi-level MPxIO and should be 355 * removed when clients migrate mdi_component_is_*() interfaces. 356 */ 357 int 358 mdi_get_component_type(dev_info_t *dip) 359 { 360 return (DEVI(dip)->devi_mdi_component); 361 } 362 363 /* 364 * mdi_vhci_register(): 365 * Register a vHCI module with the mpxio framework 366 * mdi_vhci_register() is called by vHCI drivers to register the 367 * 'class_driver' vHCI driver and its MDI entrypoints with the 368 * mpxio framework. The vHCI driver must call this interface as 369 * part of its attach(9e) handler. 370 * Competing threads may try to attach mdi_vhci_register() as 371 * the vHCI drivers are loaded and attached as a result of pHCI 372 * driver instance registration (mdi_phci_register()) with the 373 * framework. 374 * Return Values: 375 * MDI_SUCCESS 376 * MDI_FAILURE 377 */ 378 /*ARGSUSED*/ 379 int 380 mdi_vhci_register(char *class, dev_info_t *vdip, mdi_vhci_ops_t *vops, 381 int flags) 382 { 383 mdi_vhci_t *vh = NULL; 384 385 /* Registrant can't be older */ 386 ASSERT(vops->vo_revision <= MDI_VHCI_OPS_REV); 387 388 #ifdef DEBUG 389 /* 390 * IB nexus driver is loaded only when IB hardware is present. 391 * In order to be able to do this there is a need to drive the loading 392 * and attaching of the IB nexus driver (especially when an IB hardware 393 * is dynamically plugged in) when an IB HCA driver (PHCI) 394 * is being attached. Unfortunately this gets into the limitations 395 * of devfs as there seems to be no clean way to drive configuration 396 * of a subtree from another subtree of a devfs. Hence, do not ASSERT 397 * for IB. 398 */ 399 if (strcmp(class, MDI_HCI_CLASS_IB) != 0) 400 ASSERT(DEVI_BUSY_OWNED(ddi_get_parent(vdip))); 401 #endif 402 403 i_mdi_init(); 404 405 mutex_enter(&mdi_mutex); 406 /* 407 * Scan for already registered vhci 408 */ 409 for (vh = mdi_vhci_head; vh != NULL; vh = vh->vh_next) { 410 if (strcmp(vh->vh_class, class) == 0) { 411 /* 412 * vHCI has already been created. Check for valid 413 * vHCI ops registration. We only support one vHCI 414 * module per class 415 */ 416 if (vh->vh_ops != NULL) { 417 mutex_exit(&mdi_mutex); 418 cmn_err(CE_NOTE, vhci_greeting, class); 419 return (MDI_FAILURE); 420 } 421 break; 422 } 423 } 424 425 /* 426 * if not yet created, create the vHCI component 427 */ 428 if (vh == NULL) { 429 struct client_hash *hash = NULL; 430 char *load_balance; 431 432 /* 433 * Allocate and initialize the mdi extensions 434 */ 435 vh = kmem_zalloc(sizeof (mdi_vhci_t), KM_SLEEP); 436 hash = kmem_zalloc(mdi_client_table_size * sizeof (*hash), 437 KM_SLEEP); 438 vh->vh_client_table = hash; 439 vh->vh_class = kmem_zalloc(strlen(class) + 1, KM_SLEEP); 440 (void) strcpy(vh->vh_class, class); 441 vh->vh_lb = LOAD_BALANCE_RR; 442 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, vdip, 443 0, LOAD_BALANCE_PROP, &load_balance) == DDI_SUCCESS) { 444 if (strcmp(load_balance, LOAD_BALANCE_PROP_NONE) == 0) { 445 vh->vh_lb = LOAD_BALANCE_NONE; 446 } else if (strcmp(load_balance, LOAD_BALANCE_PROP_LBA) 447 == 0) { 448 vh->vh_lb = LOAD_BALANCE_LBA; 449 } 450 ddi_prop_free(load_balance); 451 } 452 453 mutex_init(&vh->vh_phci_mutex, NULL, MUTEX_DEFAULT, NULL); 454 mutex_init(&vh->vh_client_mutex, NULL, MUTEX_DEFAULT, NULL); 455 456 /* 457 * Store the vHCI ops vectors 458 */ 459 vh->vh_dip = vdip; 460 vh->vh_ops = vops; 461 462 setup_vhci_cache(vh); 463 464 if (mdi_vhci_head == NULL) { 465 mdi_vhci_head = vh; 466 } 467 if (mdi_vhci_tail) { 468 mdi_vhci_tail->vh_next = vh; 469 } 470 mdi_vhci_tail = vh; 471 mdi_vhci_count++; 472 } 473 474 /* 475 * Claim the devfs node as a vhci component 476 */ 477 DEVI(vdip)->devi_mdi_component |= MDI_COMPONENT_VHCI; 478 479 /* 480 * Initialize our back reference from dev_info node 481 */ 482 DEVI(vdip)->devi_mdi_xhci = (caddr_t)vh; 483 mutex_exit(&mdi_mutex); 484 return (MDI_SUCCESS); 485 } 486 487 /* 488 * mdi_vhci_unregister(): 489 * Unregister a vHCI module from mpxio framework 490 * mdi_vhci_unregister() is called from the detach(9E) entrypoint 491 * of a vhci to unregister it from the framework. 492 * Return Values: 493 * MDI_SUCCESS 494 * MDI_FAILURE 495 */ 496 /*ARGSUSED*/ 497 int 498 mdi_vhci_unregister(dev_info_t *vdip, int flags) 499 { 500 mdi_vhci_t *found, *vh, *prev = NULL; 501 502 ASSERT(DEVI_BUSY_OWNED(ddi_get_parent(vdip))); 503 504 /* 505 * Check for invalid VHCI 506 */ 507 if ((vh = i_devi_get_vhci(vdip)) == NULL) 508 return (MDI_FAILURE); 509 510 /* 511 * Scan the list of registered vHCIs for a match 512 */ 513 mutex_enter(&mdi_mutex); 514 for (found = mdi_vhci_head; found != NULL; found = found->vh_next) { 515 if (found == vh) 516 break; 517 prev = found; 518 } 519 520 if (found == NULL) { 521 mutex_exit(&mdi_mutex); 522 return (MDI_FAILURE); 523 } 524 525 /* 526 * Check the vHCI, pHCI and client count. All the pHCIs and clients 527 * should have been unregistered, before a vHCI can be 528 * unregistered. 529 */ 530 MDI_VHCI_PHCI_LOCK(vh); 531 if (vh->vh_refcnt || vh->vh_phci_count || vh->vh_client_count) { 532 MDI_VHCI_PHCI_UNLOCK(vh); 533 mutex_exit(&mdi_mutex); 534 return (MDI_FAILURE); 535 } 536 MDI_VHCI_PHCI_UNLOCK(vh); 537 538 if (destroy_vhci_cache(vh) != MDI_SUCCESS) { 539 mutex_exit(&mdi_mutex); 540 return (MDI_FAILURE); 541 } 542 543 /* 544 * Remove the vHCI from the global list 545 */ 546 if (vh == mdi_vhci_head) { 547 mdi_vhci_head = vh->vh_next; 548 } else { 549 prev->vh_next = vh->vh_next; 550 } 551 if (vh == mdi_vhci_tail) { 552 mdi_vhci_tail = prev; 553 } 554 mdi_vhci_count--; 555 mutex_exit(&mdi_mutex); 556 557 vh->vh_ops = NULL; 558 DEVI(vdip)->devi_mdi_component &= ~MDI_COMPONENT_VHCI; 559 DEVI(vdip)->devi_mdi_xhci = NULL; 560 kmem_free(vh->vh_class, strlen(vh->vh_class)+1); 561 kmem_free(vh->vh_client_table, 562 mdi_client_table_size * sizeof (struct client_hash)); 563 mutex_destroy(&vh->vh_phci_mutex); 564 mutex_destroy(&vh->vh_client_mutex); 565 566 kmem_free(vh, sizeof (mdi_vhci_t)); 567 return (MDI_SUCCESS); 568 } 569 570 /* 571 * i_mdi_vhci_class2vhci(): 572 * Look for a matching vHCI module given a vHCI class name 573 * Return Values: 574 * Handle to a vHCI component 575 * NULL 576 */ 577 static mdi_vhci_t * 578 i_mdi_vhci_class2vhci(char *class) 579 { 580 mdi_vhci_t *vh = NULL; 581 582 ASSERT(!MUTEX_HELD(&mdi_mutex)); 583 584 mutex_enter(&mdi_mutex); 585 for (vh = mdi_vhci_head; vh != NULL; vh = vh->vh_next) { 586 if (strcmp(vh->vh_class, class) == 0) { 587 break; 588 } 589 } 590 mutex_exit(&mdi_mutex); 591 return (vh); 592 } 593 594 /* 595 * i_devi_get_vhci(): 596 * Utility function to get the handle to a vHCI component 597 * Return Values: 598 * Handle to a vHCI component 599 * NULL 600 */ 601 mdi_vhci_t * 602 i_devi_get_vhci(dev_info_t *vdip) 603 { 604 mdi_vhci_t *vh = NULL; 605 if (MDI_VHCI(vdip)) { 606 vh = (mdi_vhci_t *)DEVI(vdip)->devi_mdi_xhci; 607 } 608 return (vh); 609 } 610 611 /* 612 * mdi_phci_register(): 613 * Register a pHCI module with mpxio framework 614 * mdi_phci_register() is called by pHCI drivers to register with 615 * the mpxio framework and a specific 'class_driver' vHCI. The 616 * pHCI driver must call this interface as part of its attach(9e) 617 * handler. 618 * Return Values: 619 * MDI_SUCCESS 620 * MDI_FAILURE 621 */ 622 /*ARGSUSED*/ 623 int 624 mdi_phci_register(char *class, dev_info_t *pdip, int flags) 625 { 626 mdi_phci_t *ph; 627 mdi_vhci_t *vh; 628 char *data; 629 630 /* 631 * Some subsystems, like fcp, perform pHCI registration from a 632 * different thread than the one doing the pHCI attach(9E) - the 633 * driver attach code is waiting for this other thread to complete. 634 * This means we can only ASSERT DEVI_BUSY_CHANGING of parent 635 * (indicating that some thread has done an ndi_devi_enter of parent) 636 * not DEVI_BUSY_OWNED (which would indicate that we did the enter). 637 */ 638 ASSERT(DEVI_BUSY_CHANGING(ddi_get_parent(pdip))); 639 640 /* 641 * Check for mpxio-disable property. Enable mpxio if the property is 642 * missing or not set to "yes". 643 * If the property is set to "yes" then emit a brief message. 644 */ 645 if ((ddi_prop_lookup_string(DDI_DEV_T_ANY, pdip, 0, "mpxio-disable", 646 &data) == DDI_SUCCESS)) { 647 if (strcmp(data, "yes") == 0) { 648 MDI_DEBUG(1, (MDI_CONT, pdip, 649 "?multipath capabilities disabled via %s.conf.", 650 ddi_driver_name(pdip))); 651 ddi_prop_free(data); 652 return (MDI_FAILURE); 653 } 654 ddi_prop_free(data); 655 } 656 657 /* 658 * Search for a matching vHCI 659 */ 660 vh = (mdi_vhci_t *)i_mdi_vhci_class2vhci(class); 661 if (vh == NULL) { 662 return (MDI_FAILURE); 663 } 664 665 ph = kmem_zalloc(sizeof (mdi_phci_t), KM_SLEEP); 666 mutex_init(&ph->ph_mutex, NULL, MUTEX_DEFAULT, NULL); 667 ph->ph_dip = pdip; 668 ph->ph_vhci = vh; 669 ph->ph_next = NULL; 670 ph->ph_unstable = 0; 671 ph->ph_vprivate = 0; 672 cv_init(&ph->ph_unstable_cv, NULL, CV_DRIVER, NULL); 673 674 MDI_PHCI_LOCK(ph); 675 MDI_PHCI_SET_POWER_UP(ph); 676 MDI_PHCI_UNLOCK(ph); 677 DEVI(pdip)->devi_mdi_component |= MDI_COMPONENT_PHCI; 678 DEVI(pdip)->devi_mdi_xhci = (caddr_t)ph; 679 680 vhcache_phci_add(vh->vh_config, ph); 681 682 MDI_VHCI_PHCI_LOCK(vh); 683 if (vh->vh_phci_head == NULL) { 684 vh->vh_phci_head = ph; 685 } 686 if (vh->vh_phci_tail) { 687 vh->vh_phci_tail->ph_next = ph; 688 } 689 vh->vh_phci_tail = ph; 690 vh->vh_phci_count++; 691 MDI_VHCI_PHCI_UNLOCK(vh); 692 693 i_mdi_log_sysevent(pdip, class, ESC_DDI_INITIATOR_REGISTER); 694 return (MDI_SUCCESS); 695 } 696 697 /* 698 * mdi_phci_unregister(): 699 * Unregister a pHCI module from mpxio framework 700 * mdi_phci_unregister() is called by the pHCI drivers from their 701 * detach(9E) handler to unregister their instances from the 702 * framework. 703 * Return Values: 704 * MDI_SUCCESS 705 * MDI_FAILURE 706 */ 707 /*ARGSUSED*/ 708 int 709 mdi_phci_unregister(dev_info_t *pdip, int flags) 710 { 711 mdi_vhci_t *vh; 712 mdi_phci_t *ph; 713 mdi_phci_t *tmp; 714 mdi_phci_t *prev = NULL; 715 mdi_pathinfo_t *pip; 716 717 ASSERT(DEVI_BUSY_CHANGING(ddi_get_parent(pdip))); 718 719 ph = i_devi_get_phci(pdip); 720 if (ph == NULL) { 721 MDI_DEBUG(1, (MDI_WARN, pdip, "!not a valid pHCI")); 722 return (MDI_FAILURE); 723 } 724 725 vh = ph->ph_vhci; 726 ASSERT(vh != NULL); 727 if (vh == NULL) { 728 MDI_DEBUG(1, (MDI_WARN, pdip, "!not a valid vHCI")); 729 return (MDI_FAILURE); 730 } 731 732 MDI_VHCI_PHCI_LOCK(vh); 733 tmp = vh->vh_phci_head; 734 while (tmp) { 735 if (tmp == ph) { 736 break; 737 } 738 prev = tmp; 739 tmp = tmp->ph_next; 740 } 741 742 if (ph == vh->vh_phci_head) { 743 vh->vh_phci_head = ph->ph_next; 744 } else { 745 prev->ph_next = ph->ph_next; 746 } 747 748 if (ph == vh->vh_phci_tail) { 749 vh->vh_phci_tail = prev; 750 } 751 752 vh->vh_phci_count--; 753 MDI_VHCI_PHCI_UNLOCK(vh); 754 755 /* Walk remaining pathinfo nodes and disassociate them from pHCI */ 756 MDI_PHCI_LOCK(ph); 757 for (pip = (mdi_pathinfo_t *)ph->ph_path_head; pip; 758 pip = (mdi_pathinfo_t *)MDI_PI(pip)->pi_phci_link) 759 MDI_PI(pip)->pi_phci = NULL; 760 MDI_PHCI_UNLOCK(ph); 761 762 i_mdi_log_sysevent(pdip, ph->ph_vhci->vh_class, 763 ESC_DDI_INITIATOR_UNREGISTER); 764 vhcache_phci_remove(vh->vh_config, ph); 765 cv_destroy(&ph->ph_unstable_cv); 766 mutex_destroy(&ph->ph_mutex); 767 kmem_free(ph, sizeof (mdi_phci_t)); 768 DEVI(pdip)->devi_mdi_component &= ~MDI_COMPONENT_PHCI; 769 DEVI(pdip)->devi_mdi_xhci = NULL; 770 return (MDI_SUCCESS); 771 } 772 773 /* 774 * i_devi_get_phci(): 775 * Utility function to return the phci extensions. 776 */ 777 static mdi_phci_t * 778 i_devi_get_phci(dev_info_t *pdip) 779 { 780 mdi_phci_t *ph = NULL; 781 782 if (MDI_PHCI(pdip)) { 783 ph = (mdi_phci_t *)DEVI(pdip)->devi_mdi_xhci; 784 } 785 return (ph); 786 } 787 788 /* 789 * Single thread mdi entry into devinfo node for modifying its children. 790 * If necessary we perform an ndi_devi_enter of the vHCI before doing 791 * an ndi_devi_enter of 'dip'. We maintain circular in two parts: one 792 * for the vHCI and one for the pHCI. 793 */ 794 void 795 mdi_devi_enter(dev_info_t *phci_dip, int *circular) 796 { 797 dev_info_t *vdip; 798 int vcircular, pcircular; 799 800 /* Verify calling context */ 801 ASSERT(MDI_PHCI(phci_dip)); 802 vdip = mdi_devi_get_vdip(phci_dip); 803 ASSERT(vdip); /* A pHCI always has a vHCI */ 804 805 /* 806 * If pHCI is detaching then the framework has already entered the 807 * vHCI on a threads that went down the code path leading to 808 * detach_node(). This framework enter of the vHCI during pHCI 809 * detach is done to avoid deadlock with vHCI power management 810 * operations which enter the vHCI and the enter down the path 811 * to the pHCI. If pHCI is detaching then we piggyback this calls 812 * enter of the vHCI on frameworks vHCI enter that has already 813 * occurred - this is OK because we know that the framework thread 814 * doing detach is waiting for our completion. 815 * 816 * We should DEVI_IS_DETACHING under an enter of the parent to avoid 817 * race with detach - but we can't do that because the framework has 818 * already entered the parent, so we have some complexity instead. 819 */ 820 for (;;) { 821 if (ndi_devi_tryenter(vdip, &vcircular)) { 822 ASSERT(vcircular != -1); 823 if (DEVI_IS_DETACHING(phci_dip)) { 824 ndi_devi_exit(vdip, vcircular); 825 vcircular = -1; 826 } 827 break; 828 } else if (DEVI_IS_DETACHING(phci_dip)) { 829 vcircular = -1; 830 break; 831 } else if (servicing_interrupt()) { 832 /* 833 * Don't delay an interrupt (and ensure adaptive 834 * mutex inversion support). 835 */ 836 ndi_devi_enter(vdip, &vcircular); 837 break; 838 } else { 839 delay_random(mdi_delay); 840 } 841 } 842 843 ndi_devi_enter(phci_dip, &pcircular); 844 *circular = (vcircular << 16) | (pcircular & 0xFFFF); 845 } 846 847 /* 848 * Attempt to mdi_devi_enter. 849 */ 850 int 851 mdi_devi_tryenter(dev_info_t *phci_dip, int *circular) 852 { 853 dev_info_t *vdip; 854 int vcircular, pcircular; 855 856 /* Verify calling context */ 857 ASSERT(MDI_PHCI(phci_dip)); 858 vdip = mdi_devi_get_vdip(phci_dip); 859 ASSERT(vdip); /* A pHCI always has a vHCI */ 860 861 if (ndi_devi_tryenter(vdip, &vcircular)) { 862 if (ndi_devi_tryenter(phci_dip, &pcircular)) { 863 *circular = (vcircular << 16) | (pcircular & 0xFFFF); 864 return (1); /* locked */ 865 } 866 ndi_devi_exit(vdip, vcircular); 867 } 868 return (0); /* busy */ 869 } 870 871 /* 872 * Release mdi_devi_enter or successful mdi_devi_tryenter. 873 */ 874 void 875 mdi_devi_exit(dev_info_t *phci_dip, int circular) 876 { 877 dev_info_t *vdip; 878 int vcircular, pcircular; 879 880 /* Verify calling context */ 881 ASSERT(MDI_PHCI(phci_dip)); 882 vdip = mdi_devi_get_vdip(phci_dip); 883 ASSERT(vdip); /* A pHCI always has a vHCI */ 884 885 /* extract two circular recursion values from single int */ 886 pcircular = (short)(circular & 0xFFFF); 887 vcircular = (short)((circular >> 16) & 0xFFFF); 888 889 ndi_devi_exit(phci_dip, pcircular); 890 if (vcircular != -1) 891 ndi_devi_exit(vdip, vcircular); 892 } 893 894 /* 895 * The functions mdi_devi_exit_phci() and mdi_devi_enter_phci() are used 896 * around a pHCI drivers calls to mdi_pi_online/offline, after holding 897 * the pathinfo node via mdi_hold_path/mdi_rele_path, to avoid deadlock 898 * with vHCI power management code during path online/offline. Each 899 * mdi_devi_exit_phci must have a matching mdi_devi_enter_phci, and both must 900 * occur within the scope of an active mdi_devi_enter that establishes the 901 * circular value. 902 */ 903 void 904 mdi_devi_exit_phci(dev_info_t *phci_dip, int circular) 905 { 906 int pcircular; 907 908 /* Verify calling context */ 909 ASSERT(MDI_PHCI(phci_dip)); 910 911 /* Keep hold on pHCI until we reenter in mdi_devi_enter_phci */ 912 ndi_hold_devi(phci_dip); 913 914 pcircular = (short)(circular & 0xFFFF); 915 ndi_devi_exit(phci_dip, pcircular); 916 } 917 918 void 919 mdi_devi_enter_phci(dev_info_t *phci_dip, int *circular) 920 { 921 int pcircular; 922 923 /* Verify calling context */ 924 ASSERT(MDI_PHCI(phci_dip)); 925 926 ndi_devi_enter(phci_dip, &pcircular); 927 928 /* Drop hold from mdi_devi_exit_phci. */ 929 ndi_rele_devi(phci_dip); 930 931 /* verify matching mdi_devi_exit_phci/mdi_devi_enter_phci use */ 932 ASSERT(pcircular == ((short)(*circular & 0xFFFF))); 933 } 934 935 /* 936 * mdi_devi_get_vdip(): 937 * given a pHCI dip return vHCI dip 938 */ 939 dev_info_t * 940 mdi_devi_get_vdip(dev_info_t *pdip) 941 { 942 mdi_phci_t *ph; 943 944 ph = i_devi_get_phci(pdip); 945 if (ph && ph->ph_vhci) 946 return (ph->ph_vhci->vh_dip); 947 return (NULL); 948 } 949 950 /* 951 * mdi_devi_pdip_entered(): 952 * Return 1 if we are vHCI and have done an ndi_devi_enter 953 * of a pHCI 954 */ 955 int 956 mdi_devi_pdip_entered(dev_info_t *vdip) 957 { 958 mdi_vhci_t *vh; 959 mdi_phci_t *ph; 960 961 vh = i_devi_get_vhci(vdip); 962 if (vh == NULL) 963 return (0); 964 965 MDI_VHCI_PHCI_LOCK(vh); 966 ph = vh->vh_phci_head; 967 while (ph) { 968 if (ph->ph_dip && DEVI_BUSY_OWNED(ph->ph_dip)) { 969 MDI_VHCI_PHCI_UNLOCK(vh); 970 return (1); 971 } 972 ph = ph->ph_next; 973 } 974 MDI_VHCI_PHCI_UNLOCK(vh); 975 return (0); 976 } 977 978 /* 979 * mdi_phci_path2devinfo(): 980 * Utility function to search for a valid phci device given 981 * the devfs pathname. 982 */ 983 dev_info_t * 984 mdi_phci_path2devinfo(dev_info_t *vdip, caddr_t pathname) 985 { 986 char *temp_pathname; 987 mdi_vhci_t *vh; 988 mdi_phci_t *ph; 989 dev_info_t *pdip = NULL; 990 991 vh = i_devi_get_vhci(vdip); 992 ASSERT(vh != NULL); 993 994 if (vh == NULL) { 995 /* 996 * Invalid vHCI component, return failure 997 */ 998 return (NULL); 999 } 1000 1001 temp_pathname = kmem_zalloc(MAXPATHLEN, KM_SLEEP); 1002 MDI_VHCI_PHCI_LOCK(vh); 1003 ph = vh->vh_phci_head; 1004 while (ph != NULL) { 1005 pdip = ph->ph_dip; 1006 ASSERT(pdip != NULL); 1007 *temp_pathname = '\0'; 1008 (void) ddi_pathname(pdip, temp_pathname); 1009 if (strcmp(temp_pathname, pathname) == 0) { 1010 break; 1011 } 1012 ph = ph->ph_next; 1013 } 1014 if (ph == NULL) { 1015 pdip = NULL; 1016 } 1017 MDI_VHCI_PHCI_UNLOCK(vh); 1018 kmem_free(temp_pathname, MAXPATHLEN); 1019 return (pdip); 1020 } 1021 1022 /* 1023 * mdi_phci_get_path_count(): 1024 * get number of path information nodes associated with a given 1025 * pHCI device. 1026 */ 1027 int 1028 mdi_phci_get_path_count(dev_info_t *pdip) 1029 { 1030 mdi_phci_t *ph; 1031 int count = 0; 1032 1033 ph = i_devi_get_phci(pdip); 1034 if (ph != NULL) { 1035 count = ph->ph_path_count; 1036 } 1037 return (count); 1038 } 1039 1040 /* 1041 * i_mdi_phci_lock(): 1042 * Lock a pHCI device 1043 * Return Values: 1044 * None 1045 * Note: 1046 * The default locking order is: 1047 * _NOTE(LOCK_ORDER(mdi_phci::ph_mutex mdi_pathinfo::pi_mutex)) 1048 * But there are number of situations where locks need to be 1049 * grabbed in reverse order. This routine implements try and lock 1050 * mechanism depending on the requested parameter option. 1051 */ 1052 static void 1053 i_mdi_phci_lock(mdi_phci_t *ph, mdi_pathinfo_t *pip) 1054 { 1055 if (pip) { 1056 /* Reverse locking is requested. */ 1057 while (MDI_PHCI_TRYLOCK(ph) == 0) { 1058 if (servicing_interrupt()) { 1059 MDI_PI_HOLD(pip); 1060 MDI_PI_UNLOCK(pip); 1061 MDI_PHCI_LOCK(ph); 1062 MDI_PI_LOCK(pip); 1063 MDI_PI_RELE(pip); 1064 break; 1065 } else { 1066 /* 1067 * tryenter failed. Try to grab again 1068 * after a small delay 1069 */ 1070 MDI_PI_HOLD(pip); 1071 MDI_PI_UNLOCK(pip); 1072 delay_random(mdi_delay); 1073 MDI_PI_LOCK(pip); 1074 MDI_PI_RELE(pip); 1075 } 1076 } 1077 } else { 1078 MDI_PHCI_LOCK(ph); 1079 } 1080 } 1081 1082 /* 1083 * i_mdi_phci_unlock(): 1084 * Unlock the pHCI component 1085 */ 1086 static void 1087 i_mdi_phci_unlock(mdi_phci_t *ph) 1088 { 1089 MDI_PHCI_UNLOCK(ph); 1090 } 1091 1092 /* 1093 * i_mdi_devinfo_create(): 1094 * create client device's devinfo node 1095 * Return Values: 1096 * dev_info 1097 * NULL 1098 * Notes: 1099 */ 1100 static dev_info_t * 1101 i_mdi_devinfo_create(mdi_vhci_t *vh, char *name, char *guid, 1102 char **compatible, int ncompatible) 1103 { 1104 dev_info_t *cdip = NULL; 1105 1106 ASSERT(MDI_VHCI_CLIENT_LOCKED(vh)); 1107 1108 /* Verify for duplicate entry */ 1109 cdip = i_mdi_devinfo_find(vh, name, guid); 1110 ASSERT(cdip == NULL); 1111 if (cdip) { 1112 cmn_err(CE_WARN, 1113 "i_mdi_devinfo_create: client %s@%s already exists", 1114 name ? name : "", guid ? guid : ""); 1115 } 1116 1117 ndi_devi_alloc_sleep(vh->vh_dip, name, DEVI_SID_NODEID, &cdip); 1118 if (cdip == NULL) 1119 goto fail; 1120 1121 /* 1122 * Create component type and Global unique identifier 1123 * properties 1124 */ 1125 if (ndi_prop_update_string(DDI_DEV_T_NONE, cdip, 1126 MDI_CLIENT_GUID_PROP, guid) != DDI_PROP_SUCCESS) { 1127 goto fail; 1128 } 1129 1130 /* Decorate the node with compatible property */ 1131 if (compatible && 1132 (ndi_prop_update_string_array(DDI_DEV_T_NONE, cdip, 1133 "compatible", compatible, ncompatible) != DDI_PROP_SUCCESS)) { 1134 goto fail; 1135 } 1136 1137 return (cdip); 1138 1139 fail: 1140 if (cdip) { 1141 (void) ndi_prop_remove_all(cdip); 1142 (void) ndi_devi_free(cdip); 1143 } 1144 return (NULL); 1145 } 1146 1147 /* 1148 * i_mdi_devinfo_find(): 1149 * Find a matching devinfo node for given client node name 1150 * and its guid. 1151 * Return Values: 1152 * Handle to a dev_info node or NULL 1153 */ 1154 static dev_info_t * 1155 i_mdi_devinfo_find(mdi_vhci_t *vh, caddr_t name, char *guid) 1156 { 1157 char *data; 1158 dev_info_t *cdip = NULL; 1159 dev_info_t *ndip = NULL; 1160 int circular; 1161 1162 ndi_devi_enter(vh->vh_dip, &circular); 1163 ndip = (dev_info_t *)DEVI(vh->vh_dip)->devi_child; 1164 while ((cdip = ndip) != NULL) { 1165 ndip = (dev_info_t *)DEVI(cdip)->devi_sibling; 1166 1167 if (strcmp(DEVI(cdip)->devi_node_name, name)) { 1168 continue; 1169 } 1170 1171 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, cdip, 1172 DDI_PROP_DONTPASS, MDI_CLIENT_GUID_PROP, 1173 &data) != DDI_PROP_SUCCESS) { 1174 continue; 1175 } 1176 1177 if (strcmp(data, guid) != 0) { 1178 ddi_prop_free(data); 1179 continue; 1180 } 1181 ddi_prop_free(data); 1182 break; 1183 } 1184 ndi_devi_exit(vh->vh_dip, circular); 1185 return (cdip); 1186 } 1187 1188 /* 1189 * i_mdi_devinfo_remove(): 1190 * Remove a client device node 1191 */ 1192 static int 1193 i_mdi_devinfo_remove(dev_info_t *vdip, dev_info_t *cdip, int flags) 1194 { 1195 int rv = MDI_SUCCESS; 1196 1197 if (i_mdi_is_child_present(vdip, cdip) == MDI_SUCCESS || 1198 (flags & MDI_CLIENT_FLAGS_DEV_NOT_SUPPORTED)) { 1199 rv = ndi_devi_offline(cdip, NDI_DEVFS_CLEAN | NDI_DEVI_REMOVE); 1200 if (rv != NDI_SUCCESS) { 1201 MDI_DEBUG(1, (MDI_NOTE, cdip, 1202 "!failed: cdip %p", (void *)cdip)); 1203 } 1204 /* 1205 * Convert to MDI error code 1206 */ 1207 switch (rv) { 1208 case NDI_SUCCESS: 1209 rv = MDI_SUCCESS; 1210 break; 1211 case NDI_BUSY: 1212 rv = MDI_BUSY; 1213 break; 1214 default: 1215 rv = MDI_FAILURE; 1216 break; 1217 } 1218 } 1219 return (rv); 1220 } 1221 1222 /* 1223 * i_devi_get_client() 1224 * Utility function to get mpxio component extensions 1225 */ 1226 static mdi_client_t * 1227 i_devi_get_client(dev_info_t *cdip) 1228 { 1229 mdi_client_t *ct = NULL; 1230 1231 if (MDI_CLIENT(cdip)) { 1232 ct = (mdi_client_t *)DEVI(cdip)->devi_mdi_client; 1233 } 1234 return (ct); 1235 } 1236 1237 /* 1238 * i_mdi_is_child_present(): 1239 * Search for the presence of client device dev_info node 1240 */ 1241 static int 1242 i_mdi_is_child_present(dev_info_t *vdip, dev_info_t *cdip) 1243 { 1244 int rv = MDI_FAILURE; 1245 struct dev_info *dip; 1246 int circular; 1247 1248 ndi_devi_enter(vdip, &circular); 1249 dip = DEVI(vdip)->devi_child; 1250 while (dip) { 1251 if (dip == DEVI(cdip)) { 1252 rv = MDI_SUCCESS; 1253 break; 1254 } 1255 dip = dip->devi_sibling; 1256 } 1257 ndi_devi_exit(vdip, circular); 1258 return (rv); 1259 } 1260 1261 1262 /* 1263 * i_mdi_client_lock(): 1264 * Grab client component lock 1265 * Return Values: 1266 * None 1267 * Note: 1268 * The default locking order is: 1269 * _NOTE(LOCK_ORDER(mdi_client::ct_mutex mdi_pathinfo::pi_mutex)) 1270 * But there are number of situations where locks need to be 1271 * grabbed in reverse order. This routine implements try and lock 1272 * mechanism depending on the requested parameter option. 1273 */ 1274 static void 1275 i_mdi_client_lock(mdi_client_t *ct, mdi_pathinfo_t *pip) 1276 { 1277 if (pip) { 1278 /* 1279 * Reverse locking is requested. 1280 */ 1281 while (MDI_CLIENT_TRYLOCK(ct) == 0) { 1282 if (servicing_interrupt()) { 1283 MDI_PI_HOLD(pip); 1284 MDI_PI_UNLOCK(pip); 1285 MDI_CLIENT_LOCK(ct); 1286 MDI_PI_LOCK(pip); 1287 MDI_PI_RELE(pip); 1288 break; 1289 } else { 1290 /* 1291 * tryenter failed. Try to grab again 1292 * after a small delay 1293 */ 1294 MDI_PI_HOLD(pip); 1295 MDI_PI_UNLOCK(pip); 1296 delay_random(mdi_delay); 1297 MDI_PI_LOCK(pip); 1298 MDI_PI_RELE(pip); 1299 } 1300 } 1301 } else { 1302 MDI_CLIENT_LOCK(ct); 1303 } 1304 } 1305 1306 /* 1307 * i_mdi_client_unlock(): 1308 * Unlock a client component 1309 */ 1310 static void 1311 i_mdi_client_unlock(mdi_client_t *ct) 1312 { 1313 MDI_CLIENT_UNLOCK(ct); 1314 } 1315 1316 /* 1317 * i_mdi_client_alloc(): 1318 * Allocate and initialize a client structure. Caller should 1319 * hold the vhci client lock. 1320 * Return Values: 1321 * Handle to a client component 1322 */ 1323 /*ARGSUSED*/ 1324 static mdi_client_t * 1325 i_mdi_client_alloc(mdi_vhci_t *vh, char *name, char *lguid) 1326 { 1327 mdi_client_t *ct; 1328 1329 ASSERT(MDI_VHCI_CLIENT_LOCKED(vh)); 1330 1331 /* 1332 * Allocate and initialize a component structure. 1333 */ 1334 ct = kmem_zalloc(sizeof (*ct), KM_SLEEP); 1335 mutex_init(&ct->ct_mutex, NULL, MUTEX_DEFAULT, NULL); 1336 ct->ct_hnext = NULL; 1337 ct->ct_hprev = NULL; 1338 ct->ct_dip = NULL; 1339 ct->ct_vhci = vh; 1340 ct->ct_drvname = kmem_alloc(strlen(name) + 1, KM_SLEEP); 1341 (void) strcpy(ct->ct_drvname, name); 1342 ct->ct_guid = kmem_alloc(strlen(lguid) + 1, KM_SLEEP); 1343 (void) strcpy(ct->ct_guid, lguid); 1344 ct->ct_cprivate = NULL; 1345 ct->ct_vprivate = NULL; 1346 ct->ct_flags = 0; 1347 ct->ct_state = MDI_CLIENT_STATE_FAILED; 1348 MDI_CLIENT_LOCK(ct); 1349 MDI_CLIENT_SET_OFFLINE(ct); 1350 MDI_CLIENT_SET_DETACH(ct); 1351 MDI_CLIENT_SET_POWER_UP(ct); 1352 MDI_CLIENT_UNLOCK(ct); 1353 ct->ct_failover_flags = 0; 1354 ct->ct_failover_status = 0; 1355 cv_init(&ct->ct_failover_cv, NULL, CV_DRIVER, NULL); 1356 ct->ct_unstable = 0; 1357 cv_init(&ct->ct_unstable_cv, NULL, CV_DRIVER, NULL); 1358 cv_init(&ct->ct_powerchange_cv, NULL, CV_DRIVER, NULL); 1359 ct->ct_lb = vh->vh_lb; 1360 ct->ct_lb_args = kmem_zalloc(sizeof (client_lb_args_t), KM_SLEEP); 1361 ct->ct_lb_args->region_size = LOAD_BALANCE_DEFAULT_REGION_SIZE; 1362 ct->ct_path_count = 0; 1363 ct->ct_path_head = NULL; 1364 ct->ct_path_tail = NULL; 1365 ct->ct_path_last = NULL; 1366 1367 /* 1368 * Add this client component to our client hash queue 1369 */ 1370 i_mdi_client_enlist_table(vh, ct); 1371 return (ct); 1372 } 1373 1374 /* 1375 * i_mdi_client_enlist_table(): 1376 * Attach the client device to the client hash table. Caller 1377 * should hold the vhci client lock. 1378 */ 1379 static void 1380 i_mdi_client_enlist_table(mdi_vhci_t *vh, mdi_client_t *ct) 1381 { 1382 int index; 1383 struct client_hash *head; 1384 1385 ASSERT(MDI_VHCI_CLIENT_LOCKED(vh)); 1386 1387 index = i_mdi_get_hash_key(ct->ct_guid); 1388 head = &vh->vh_client_table[index]; 1389 ct->ct_hnext = (mdi_client_t *)head->ct_hash_head; 1390 head->ct_hash_head = ct; 1391 head->ct_hash_count++; 1392 vh->vh_client_count++; 1393 } 1394 1395 /* 1396 * i_mdi_client_delist_table(): 1397 * Attach the client device to the client hash table. 1398 * Caller should hold the vhci client lock. 1399 */ 1400 static void 1401 i_mdi_client_delist_table(mdi_vhci_t *vh, mdi_client_t *ct) 1402 { 1403 int index; 1404 char *guid; 1405 struct client_hash *head; 1406 mdi_client_t *next; 1407 mdi_client_t *last; 1408 1409 ASSERT(MDI_VHCI_CLIENT_LOCKED(vh)); 1410 1411 guid = ct->ct_guid; 1412 index = i_mdi_get_hash_key(guid); 1413 head = &vh->vh_client_table[index]; 1414 1415 last = NULL; 1416 next = (mdi_client_t *)head->ct_hash_head; 1417 while (next != NULL) { 1418 if (next == ct) { 1419 break; 1420 } 1421 last = next; 1422 next = next->ct_hnext; 1423 } 1424 1425 if (next) { 1426 head->ct_hash_count--; 1427 if (last == NULL) { 1428 head->ct_hash_head = ct->ct_hnext; 1429 } else { 1430 last->ct_hnext = ct->ct_hnext; 1431 } 1432 ct->ct_hnext = NULL; 1433 vh->vh_client_count--; 1434 } 1435 } 1436 1437 1438 /* 1439 * i_mdi_client_free(): 1440 * Free a client component 1441 */ 1442 static int 1443 i_mdi_client_free(mdi_vhci_t *vh, mdi_client_t *ct) 1444 { 1445 int rv = MDI_SUCCESS; 1446 int flags = ct->ct_flags; 1447 dev_info_t *cdip; 1448 dev_info_t *vdip; 1449 1450 ASSERT(MDI_VHCI_CLIENT_LOCKED(vh)); 1451 1452 vdip = vh->vh_dip; 1453 cdip = ct->ct_dip; 1454 1455 (void) ndi_prop_remove(DDI_DEV_T_NONE, cdip, MDI_CLIENT_GUID_PROP); 1456 DEVI(cdip)->devi_mdi_component &= ~MDI_COMPONENT_CLIENT; 1457 DEVI(cdip)->devi_mdi_client = NULL; 1458 1459 /* 1460 * Clear out back ref. to dev_info_t node 1461 */ 1462 ct->ct_dip = NULL; 1463 1464 /* 1465 * Remove this client from our hash queue 1466 */ 1467 i_mdi_client_delist_table(vh, ct); 1468 1469 /* 1470 * Uninitialize and free the component 1471 */ 1472 kmem_free(ct->ct_drvname, strlen(ct->ct_drvname) + 1); 1473 kmem_free(ct->ct_guid, strlen(ct->ct_guid) + 1); 1474 kmem_free(ct->ct_lb_args, sizeof (client_lb_args_t)); 1475 cv_destroy(&ct->ct_failover_cv); 1476 cv_destroy(&ct->ct_unstable_cv); 1477 cv_destroy(&ct->ct_powerchange_cv); 1478 mutex_destroy(&ct->ct_mutex); 1479 kmem_free(ct, sizeof (*ct)); 1480 1481 if (cdip != NULL) { 1482 MDI_VHCI_CLIENT_UNLOCK(vh); 1483 (void) i_mdi_devinfo_remove(vdip, cdip, flags); 1484 MDI_VHCI_CLIENT_LOCK(vh); 1485 } 1486 return (rv); 1487 } 1488 1489 /* 1490 * i_mdi_client_find(): 1491 * Find the client structure corresponding to a given guid 1492 * Caller should hold the vhci client lock. 1493 */ 1494 static mdi_client_t * 1495 i_mdi_client_find(mdi_vhci_t *vh, char *cname, char *guid) 1496 { 1497 int index; 1498 struct client_hash *head; 1499 mdi_client_t *ct; 1500 1501 ASSERT(MDI_VHCI_CLIENT_LOCKED(vh)); 1502 1503 index = i_mdi_get_hash_key(guid); 1504 head = &vh->vh_client_table[index]; 1505 1506 ct = head->ct_hash_head; 1507 while (ct != NULL) { 1508 if (strcmp(ct->ct_guid, guid) == 0 && 1509 (cname == NULL || strcmp(ct->ct_drvname, cname) == 0)) { 1510 break; 1511 } 1512 ct = ct->ct_hnext; 1513 } 1514 return (ct); 1515 } 1516 1517 /* 1518 * i_mdi_client_update_state(): 1519 * Compute and update client device state 1520 * Notes: 1521 * A client device can be in any of three possible states: 1522 * 1523 * MDI_CLIENT_STATE_OPTIMAL - Client in optimal state with more 1524 * one online/standby paths. Can tolerate failures. 1525 * MDI_CLIENT_STATE_DEGRADED - Client device in degraded state with 1526 * no alternate paths available as standby. A failure on the online 1527 * would result in loss of access to device data. 1528 * MDI_CLIENT_STATE_FAILED - Client device in failed state with 1529 * no paths available to access the device. 1530 */ 1531 static void 1532 i_mdi_client_update_state(mdi_client_t *ct) 1533 { 1534 int state; 1535 1536 ASSERT(MDI_CLIENT_LOCKED(ct)); 1537 state = i_mdi_client_compute_state(ct, NULL); 1538 MDI_CLIENT_SET_STATE(ct, state); 1539 } 1540 1541 /* 1542 * i_mdi_client_compute_state(): 1543 * Compute client device state 1544 * 1545 * mdi_phci_t * Pointer to pHCI structure which should 1546 * while computing the new value. Used by 1547 * i_mdi_phci_offline() to find the new 1548 * client state after DR of a pHCI. 1549 */ 1550 static int 1551 i_mdi_client_compute_state(mdi_client_t *ct, mdi_phci_t *ph) 1552 { 1553 int state; 1554 int online_count = 0; 1555 int standby_count = 0; 1556 mdi_pathinfo_t *pip, *next; 1557 1558 ASSERT(MDI_CLIENT_LOCKED(ct)); 1559 pip = ct->ct_path_head; 1560 while (pip != NULL) { 1561 MDI_PI_LOCK(pip); 1562 next = (mdi_pathinfo_t *)MDI_PI(pip)->pi_client_link; 1563 if (MDI_PI(pip)->pi_phci == ph) { 1564 MDI_PI_UNLOCK(pip); 1565 pip = next; 1566 continue; 1567 } 1568 1569 if ((MDI_PI(pip)->pi_state & MDI_PATHINFO_STATE_MASK) 1570 == MDI_PATHINFO_STATE_ONLINE) 1571 online_count++; 1572 else if ((MDI_PI(pip)->pi_state & MDI_PATHINFO_STATE_MASK) 1573 == MDI_PATHINFO_STATE_STANDBY) 1574 standby_count++; 1575 MDI_PI_UNLOCK(pip); 1576 pip = next; 1577 } 1578 1579 if (online_count == 0) { 1580 if (standby_count == 0) { 1581 state = MDI_CLIENT_STATE_FAILED; 1582 MDI_DEBUG(2, (MDI_NOTE, ct->ct_dip, 1583 "client state failed: ct = %p", (void *)ct)); 1584 } else if (standby_count == 1) { 1585 state = MDI_CLIENT_STATE_DEGRADED; 1586 } else { 1587 state = MDI_CLIENT_STATE_OPTIMAL; 1588 } 1589 } else if (online_count == 1) { 1590 if (standby_count == 0) { 1591 state = MDI_CLIENT_STATE_DEGRADED; 1592 } else { 1593 state = MDI_CLIENT_STATE_OPTIMAL; 1594 } 1595 } else { 1596 state = MDI_CLIENT_STATE_OPTIMAL; 1597 } 1598 return (state); 1599 } 1600 1601 /* 1602 * i_mdi_client2devinfo(): 1603 * Utility function 1604 */ 1605 dev_info_t * 1606 i_mdi_client2devinfo(mdi_client_t *ct) 1607 { 1608 return (ct->ct_dip); 1609 } 1610 1611 /* 1612 * mdi_client_path2_devinfo(): 1613 * Given the parent devinfo and child devfs pathname, search for 1614 * a valid devfs node handle. 1615 */ 1616 dev_info_t * 1617 mdi_client_path2devinfo(dev_info_t *vdip, char *pathname) 1618 { 1619 dev_info_t *cdip = NULL; 1620 dev_info_t *ndip = NULL; 1621 char *temp_pathname; 1622 int circular; 1623 1624 /* 1625 * Allocate temp buffer 1626 */ 1627 temp_pathname = kmem_zalloc(MAXPATHLEN, KM_SLEEP); 1628 1629 /* 1630 * Lock parent against changes 1631 */ 1632 ndi_devi_enter(vdip, &circular); 1633 ndip = (dev_info_t *)DEVI(vdip)->devi_child; 1634 while ((cdip = ndip) != NULL) { 1635 ndip = (dev_info_t *)DEVI(cdip)->devi_sibling; 1636 1637 *temp_pathname = '\0'; 1638 (void) ddi_pathname(cdip, temp_pathname); 1639 if (strcmp(temp_pathname, pathname) == 0) { 1640 break; 1641 } 1642 } 1643 /* 1644 * Release devinfo lock 1645 */ 1646 ndi_devi_exit(vdip, circular); 1647 1648 /* 1649 * Free the temp buffer 1650 */ 1651 kmem_free(temp_pathname, MAXPATHLEN); 1652 return (cdip); 1653 } 1654 1655 /* 1656 * mdi_client_get_path_count(): 1657 * Utility function to get number of path information nodes 1658 * associated with a given client device. 1659 */ 1660 int 1661 mdi_client_get_path_count(dev_info_t *cdip) 1662 { 1663 mdi_client_t *ct; 1664 int count = 0; 1665 1666 ct = i_devi_get_client(cdip); 1667 if (ct != NULL) { 1668 count = ct->ct_path_count; 1669 } 1670 return (count); 1671 } 1672 1673 1674 /* 1675 * i_mdi_get_hash_key(): 1676 * Create a hash using strings as keys 1677 * 1678 */ 1679 static int 1680 i_mdi_get_hash_key(char *str) 1681 { 1682 uint32_t g, hash = 0; 1683 char *p; 1684 1685 for (p = str; *p != '\0'; p++) { 1686 g = *p; 1687 hash += g; 1688 } 1689 return (hash % (CLIENT_HASH_TABLE_SIZE - 1)); 1690 } 1691 1692 /* 1693 * mdi_get_lb_policy(): 1694 * Get current load balancing policy for a given client device 1695 */ 1696 client_lb_t 1697 mdi_get_lb_policy(dev_info_t *cdip) 1698 { 1699 client_lb_t lb = LOAD_BALANCE_NONE; 1700 mdi_client_t *ct; 1701 1702 ct = i_devi_get_client(cdip); 1703 if (ct != NULL) { 1704 lb = ct->ct_lb; 1705 } 1706 return (lb); 1707 } 1708 1709 /* 1710 * mdi_set_lb_region_size(): 1711 * Set current region size for the load-balance 1712 */ 1713 int 1714 mdi_set_lb_region_size(dev_info_t *cdip, int region_size) 1715 { 1716 mdi_client_t *ct; 1717 int rv = MDI_FAILURE; 1718 1719 ct = i_devi_get_client(cdip); 1720 if (ct != NULL && ct->ct_lb_args != NULL) { 1721 ct->ct_lb_args->region_size = region_size; 1722 rv = MDI_SUCCESS; 1723 } 1724 return (rv); 1725 } 1726 1727 /* 1728 * mdi_Set_lb_policy(): 1729 * Set current load balancing policy for a given client device 1730 */ 1731 int 1732 mdi_set_lb_policy(dev_info_t *cdip, client_lb_t lb) 1733 { 1734 mdi_client_t *ct; 1735 int rv = MDI_FAILURE; 1736 1737 ct = i_devi_get_client(cdip); 1738 if (ct != NULL) { 1739 ct->ct_lb = lb; 1740 rv = MDI_SUCCESS; 1741 } 1742 return (rv); 1743 } 1744 1745 /* 1746 * mdi_failover(): 1747 * failover function called by the vHCI drivers to initiate 1748 * a failover operation. This is typically due to non-availability 1749 * of online paths to route I/O requests. Failover can be 1750 * triggered through user application also. 1751 * 1752 * The vHCI driver calls mdi_failover() to initiate a failover 1753 * operation. mdi_failover() calls back into the vHCI driver's 1754 * vo_failover() entry point to perform the actual failover 1755 * operation. The reason for requiring the vHCI driver to 1756 * initiate failover by calling mdi_failover(), instead of directly 1757 * executing vo_failover() itself, is to ensure that the mdi 1758 * framework can keep track of the client state properly. 1759 * Additionally, mdi_failover() provides as a convenience the 1760 * option of performing the failover operation synchronously or 1761 * asynchronously 1762 * 1763 * Upon successful completion of the failover operation, the 1764 * paths that were previously ONLINE will be in the STANDBY state, 1765 * and the newly activated paths will be in the ONLINE state. 1766 * 1767 * The flags modifier determines whether the activation is done 1768 * synchronously: MDI_FAILOVER_SYNC 1769 * Return Values: 1770 * MDI_SUCCESS 1771 * MDI_FAILURE 1772 * MDI_BUSY 1773 */ 1774 /*ARGSUSED*/ 1775 int 1776 mdi_failover(dev_info_t *vdip, dev_info_t *cdip, int flags) 1777 { 1778 int rv; 1779 mdi_client_t *ct; 1780 1781 ct = i_devi_get_client(cdip); 1782 ASSERT(ct != NULL); 1783 if (ct == NULL) { 1784 /* cdip is not a valid client device. Nothing more to do. */ 1785 return (MDI_FAILURE); 1786 } 1787 1788 MDI_CLIENT_LOCK(ct); 1789 1790 if (MDI_CLIENT_IS_PATH_FREE_IN_PROGRESS(ct)) { 1791 /* A path to the client is being freed */ 1792 MDI_CLIENT_UNLOCK(ct); 1793 return (MDI_BUSY); 1794 } 1795 1796 1797 if (MDI_CLIENT_IS_FAILED(ct)) { 1798 /* 1799 * Client is in failed state. Nothing more to do. 1800 */ 1801 MDI_CLIENT_UNLOCK(ct); 1802 return (MDI_FAILURE); 1803 } 1804 1805 if (MDI_CLIENT_IS_FAILOVER_IN_PROGRESS(ct)) { 1806 /* 1807 * Failover is already in progress; return BUSY 1808 */ 1809 MDI_CLIENT_UNLOCK(ct); 1810 return (MDI_BUSY); 1811 } 1812 /* 1813 * Make sure that mdi_pathinfo node state changes are processed. 1814 * We do not allow failovers to progress while client path state 1815 * changes are in progress 1816 */ 1817 if (ct->ct_unstable) { 1818 if (flags == MDI_FAILOVER_ASYNC) { 1819 MDI_CLIENT_UNLOCK(ct); 1820 return (MDI_BUSY); 1821 } else { 1822 while (ct->ct_unstable) 1823 cv_wait(&ct->ct_unstable_cv, &ct->ct_mutex); 1824 } 1825 } 1826 1827 /* 1828 * Client device is in stable state. Before proceeding, perform sanity 1829 * checks again. 1830 */ 1831 if ((MDI_CLIENT_IS_DETACHED(ct)) || (MDI_CLIENT_IS_FAILED(ct)) || 1832 (!i_ddi_devi_attached(cdip))) { 1833 /* 1834 * Client is in failed state. Nothing more to do. 1835 */ 1836 MDI_CLIENT_UNLOCK(ct); 1837 return (MDI_FAILURE); 1838 } 1839 1840 /* 1841 * Set the client state as failover in progress. 1842 */ 1843 MDI_CLIENT_SET_FAILOVER_IN_PROGRESS(ct); 1844 ct->ct_failover_flags = flags; 1845 MDI_CLIENT_UNLOCK(ct); 1846 1847 if (flags == MDI_FAILOVER_ASYNC) { 1848 /* 1849 * Submit the initiate failover request via CPR safe 1850 * taskq threads. 1851 */ 1852 (void) taskq_dispatch(mdi_taskq, (task_func_t *)i_mdi_failover, 1853 ct, KM_SLEEP); 1854 return (MDI_ACCEPT); 1855 } else { 1856 /* 1857 * Synchronous failover mode. Typically invoked from the user 1858 * land. 1859 */ 1860 rv = i_mdi_failover(ct); 1861 } 1862 return (rv); 1863 } 1864 1865 /* 1866 * i_mdi_failover(): 1867 * internal failover function. Invokes vHCI drivers failover 1868 * callback function and process the failover status 1869 * Return Values: 1870 * None 1871 * 1872 * Note: A client device in failover state can not be detached or freed. 1873 */ 1874 static int 1875 i_mdi_failover(void *arg) 1876 { 1877 int rv = MDI_SUCCESS; 1878 mdi_client_t *ct = (mdi_client_t *)arg; 1879 mdi_vhci_t *vh = ct->ct_vhci; 1880 1881 ASSERT(!MDI_CLIENT_LOCKED(ct)); 1882 1883 if (vh->vh_ops->vo_failover != NULL) { 1884 /* 1885 * Call vHCI drivers callback routine 1886 */ 1887 rv = (*vh->vh_ops->vo_failover)(vh->vh_dip, ct->ct_dip, 1888 ct->ct_failover_flags); 1889 } 1890 1891 MDI_CLIENT_LOCK(ct); 1892 MDI_CLIENT_CLEAR_FAILOVER_IN_PROGRESS(ct); 1893 1894 /* 1895 * Save the failover return status 1896 */ 1897 ct->ct_failover_status = rv; 1898 1899 /* 1900 * As a result of failover, client status would have been changed. 1901 * Update the client state and wake up anyone waiting on this client 1902 * device. 1903 */ 1904 i_mdi_client_update_state(ct); 1905 1906 cv_broadcast(&ct->ct_failover_cv); 1907 MDI_CLIENT_UNLOCK(ct); 1908 return (rv); 1909 } 1910 1911 /* 1912 * Load balancing is logical block. 1913 * IOs within the range described by region_size 1914 * would go on the same path. This would improve the 1915 * performance by cache-hit on some of the RAID devices. 1916 * Search only for online paths(At some point we 1917 * may want to balance across target ports). 1918 * If no paths are found then default to round-robin. 1919 */ 1920 static int 1921 i_mdi_lba_lb(mdi_client_t *ct, mdi_pathinfo_t **ret_pip, struct buf *bp) 1922 { 1923 int path_index = -1; 1924 int online_path_count = 0; 1925 int online_nonpref_path_count = 0; 1926 int region_size = ct->ct_lb_args->region_size; 1927 mdi_pathinfo_t *pip; 1928 mdi_pathinfo_t *next; 1929 int preferred, path_cnt; 1930 1931 pip = ct->ct_path_head; 1932 while (pip) { 1933 MDI_PI_LOCK(pip); 1934 if (MDI_PI(pip)->pi_state == 1935 MDI_PATHINFO_STATE_ONLINE && MDI_PI(pip)->pi_preferred) { 1936 online_path_count++; 1937 } else if (MDI_PI(pip)->pi_state == 1938 MDI_PATHINFO_STATE_ONLINE && !MDI_PI(pip)->pi_preferred) { 1939 online_nonpref_path_count++; 1940 } 1941 next = (mdi_pathinfo_t *) 1942 MDI_PI(pip)->pi_client_link; 1943 MDI_PI_UNLOCK(pip); 1944 pip = next; 1945 } 1946 /* if found any online/preferred then use this type */ 1947 if (online_path_count > 0) { 1948 path_cnt = online_path_count; 1949 preferred = 1; 1950 } else if (online_nonpref_path_count > 0) { 1951 path_cnt = online_nonpref_path_count; 1952 preferred = 0; 1953 } else { 1954 path_cnt = 0; 1955 } 1956 if (path_cnt) { 1957 path_index = (bp->b_blkno >> region_size) % path_cnt; 1958 pip = ct->ct_path_head; 1959 while (pip && path_index != -1) { 1960 MDI_PI_LOCK(pip); 1961 if (path_index == 0 && 1962 (MDI_PI(pip)->pi_state == 1963 MDI_PATHINFO_STATE_ONLINE) && 1964 MDI_PI(pip)->pi_preferred == preferred) { 1965 MDI_PI_HOLD(pip); 1966 MDI_PI_UNLOCK(pip); 1967 *ret_pip = pip; 1968 return (MDI_SUCCESS); 1969 } 1970 path_index --; 1971 next = (mdi_pathinfo_t *) 1972 MDI_PI(pip)->pi_client_link; 1973 MDI_PI_UNLOCK(pip); 1974 pip = next; 1975 } 1976 MDI_DEBUG(4, (MDI_NOTE, ct->ct_dip, 1977 "lba %llx: path %s %p", 1978 bp->b_lblkno, mdi_pi_spathname(pip), (void *)pip)); 1979 } 1980 return (MDI_FAILURE); 1981 } 1982 1983 /* 1984 * mdi_select_path(): 1985 * select a path to access a client device. 1986 * 1987 * mdi_select_path() function is called by the vHCI drivers to 1988 * select a path to route the I/O request to. The caller passes 1989 * the block I/O data transfer structure ("buf") as one of the 1990 * parameters. The mpxio framework uses the buf structure 1991 * contents to maintain per path statistics (total I/O size / 1992 * count pending). If more than one online paths are available to 1993 * select, the framework automatically selects a suitable path 1994 * for routing I/O request. If a failover operation is active for 1995 * this client device the call shall be failed with MDI_BUSY error 1996 * code. 1997 * 1998 * By default this function returns a suitable path in online 1999 * state based on the current load balancing policy. Currently 2000 * we support LOAD_BALANCE_NONE (Previously selected online path 2001 * will continue to be used till the path is usable) and 2002 * LOAD_BALANCE_RR (Online paths will be selected in a round 2003 * robin fashion), LOAD_BALANCE_LB(Online paths will be selected 2004 * based on the logical block). The load balancing 2005 * through vHCI drivers configuration file (driver.conf). 2006 * 2007 * vHCI drivers may override this default behavior by specifying 2008 * appropriate flags. The meaning of the thrid argument depends 2009 * on the flags specified. If MDI_SELECT_PATH_INSTANCE is set 2010 * then the argument is the "path instance" of the path to select. 2011 * If MDI_SELECT_PATH_INSTANCE is not set then the argument is 2012 * "start_pip". A non NULL "start_pip" is the starting point to 2013 * walk and find the next appropriate path. The following values 2014 * are currently defined: MDI_SELECT_ONLINE_PATH (to select an 2015 * ONLINE path) and/or MDI_SELECT_STANDBY_PATH (to select an 2016 * STANDBY path). 2017 * 2018 * The non-standard behavior is used by the scsi_vhci driver, 2019 * whenever it has to use a STANDBY/FAULTED path. Eg. during 2020 * attach of client devices (to avoid an unnecessary failover 2021 * when the STANDBY path comes up first), during failover 2022 * (to activate a STANDBY path as ONLINE). 2023 * 2024 * The selected path is returned in a a mdi_hold_path() state 2025 * (pi_ref_cnt). Caller should release the hold by calling 2026 * mdi_rele_path(). 2027 * 2028 * Return Values: 2029 * MDI_SUCCESS - Completed successfully 2030 * MDI_BUSY - Client device is busy failing over 2031 * MDI_NOPATH - Client device is online, but no valid path are 2032 * available to access this client device 2033 * MDI_FAILURE - Invalid client device or state 2034 * MDI_DEVI_ONLINING 2035 * - Client device (struct dev_info state) is in 2036 * onlining state. 2037 */ 2038 2039 /*ARGSUSED*/ 2040 int 2041 mdi_select_path(dev_info_t *cdip, struct buf *bp, int flags, 2042 void *arg, mdi_pathinfo_t **ret_pip) 2043 { 2044 mdi_client_t *ct; 2045 mdi_pathinfo_t *pip; 2046 mdi_pathinfo_t *next; 2047 mdi_pathinfo_t *head; 2048 mdi_pathinfo_t *start; 2049 client_lb_t lbp; /* load balancing policy */ 2050 int sb = 1; /* standard behavior */ 2051 int preferred = 1; /* preferred path */ 2052 int cond, cont = 1; 2053 int retry = 0; 2054 mdi_pathinfo_t *start_pip; /* request starting pathinfo */ 2055 int path_instance; /* request specific path instance */ 2056 2057 /* determine type of arg based on flags */ 2058 if (flags & MDI_SELECT_PATH_INSTANCE) { 2059 path_instance = (int)(intptr_t)arg; 2060 start_pip = NULL; 2061 } else { 2062 path_instance = 0; 2063 start_pip = (mdi_pathinfo_t *)arg; 2064 } 2065 2066 if (flags != 0) { 2067 /* 2068 * disable default behavior 2069 */ 2070 sb = 0; 2071 } 2072 2073 *ret_pip = NULL; 2074 ct = i_devi_get_client(cdip); 2075 if (ct == NULL) { 2076 /* mdi extensions are NULL, Nothing more to do */ 2077 return (MDI_FAILURE); 2078 } 2079 2080 MDI_CLIENT_LOCK(ct); 2081 2082 if (sb) { 2083 if (MDI_CLIENT_IS_FAILED(ct)) { 2084 /* 2085 * Client is not ready to accept any I/O requests. 2086 * Fail this request. 2087 */ 2088 MDI_DEBUG(2, (MDI_NOTE, cdip, 2089 "client state offline ct = %p", (void *)ct)); 2090 MDI_CLIENT_UNLOCK(ct); 2091 return (MDI_FAILURE); 2092 } 2093 2094 if (MDI_CLIENT_IS_FAILOVER_IN_PROGRESS(ct)) { 2095 /* 2096 * Check for Failover is in progress. If so tell the 2097 * caller that this device is busy. 2098 */ 2099 MDI_DEBUG(2, (MDI_NOTE, cdip, 2100 "client failover in progress ct = %p", 2101 (void *)ct)); 2102 MDI_CLIENT_UNLOCK(ct); 2103 return (MDI_BUSY); 2104 } 2105 2106 /* 2107 * Check to see whether the client device is attached. 2108 * If not so, let the vHCI driver manually select a path 2109 * (standby) and let the probe/attach process to continue. 2110 */ 2111 if (MDI_CLIENT_IS_DETACHED(ct) || !i_ddi_devi_attached(cdip)) { 2112 MDI_DEBUG(4, (MDI_NOTE, cdip, 2113 "devi is onlining ct = %p", (void *)ct)); 2114 MDI_CLIENT_UNLOCK(ct); 2115 return (MDI_DEVI_ONLINING); 2116 } 2117 } 2118 2119 /* 2120 * Cache in the client list head. If head of the list is NULL 2121 * return MDI_NOPATH 2122 */ 2123 head = ct->ct_path_head; 2124 if (head == NULL) { 2125 MDI_CLIENT_UNLOCK(ct); 2126 return (MDI_NOPATH); 2127 } 2128 2129 /* Caller is specifying a specific pathinfo path by path_instance */ 2130 if (path_instance) { 2131 /* search for pathinfo with correct path_instance */ 2132 for (pip = head; 2133 pip && (mdi_pi_get_path_instance(pip) != path_instance); 2134 pip = (mdi_pathinfo_t *)MDI_PI(pip)->pi_client_link) 2135 ; 2136 2137 /* If path can't be selected then MDI_NOPATH is returned. */ 2138 if (pip == NULL) { 2139 MDI_CLIENT_UNLOCK(ct); 2140 return (MDI_NOPATH); 2141 } 2142 2143 /* 2144 * Verify state of path. When asked to select a specific 2145 * path_instance, we select the requested path in any 2146 * state (ONLINE, OFFLINE, STANDBY, FAULT) other than INIT. 2147 * We don't however select paths where the pHCI has detached. 2148 * NOTE: last pathinfo node of an opened client device may 2149 * exist in an OFFLINE state after the pHCI associated with 2150 * that path has detached (but pi_phci will be NULL if that 2151 * has occurred). 2152 */ 2153 MDI_PI_LOCK(pip); 2154 if ((MDI_PI(pip)->pi_state == MDI_PATHINFO_STATE_INIT) || 2155 (MDI_PI(pip)->pi_phci == NULL)) { 2156 MDI_PI_UNLOCK(pip); 2157 MDI_CLIENT_UNLOCK(ct); 2158 return (MDI_FAILURE); 2159 } 2160 2161 /* Return MDI_BUSY if we have a transient condition */ 2162 if (MDI_PI_IS_TRANSIENT(pip)) { 2163 MDI_PI_UNLOCK(pip); 2164 MDI_CLIENT_UNLOCK(ct); 2165 return (MDI_BUSY); 2166 } 2167 2168 /* 2169 * Return the path in hold state. Caller should release the 2170 * lock by calling mdi_rele_path() 2171 */ 2172 MDI_PI_HOLD(pip); 2173 MDI_PI_UNLOCK(pip); 2174 *ret_pip = pip; 2175 MDI_CLIENT_UNLOCK(ct); 2176 return (MDI_SUCCESS); 2177 } 2178 2179 /* 2180 * for non default behavior, bypass current 2181 * load balancing policy and always use LOAD_BALANCE_RR 2182 * except that the start point will be adjusted based 2183 * on the provided start_pip 2184 */ 2185 lbp = sb ? ct->ct_lb : LOAD_BALANCE_RR; 2186 2187 switch (lbp) { 2188 case LOAD_BALANCE_NONE: 2189 /* 2190 * Load balancing is None or Alternate path mode 2191 * Start looking for a online mdi_pathinfo node starting from 2192 * last known selected path 2193 */ 2194 preferred = 1; 2195 pip = (mdi_pathinfo_t *)ct->ct_path_last; 2196 if (pip == NULL) { 2197 pip = head; 2198 } 2199 start = pip; 2200 do { 2201 MDI_PI_LOCK(pip); 2202 /* 2203 * No need to explicitly check if the path is disabled. 2204 * Since we are checking for state == ONLINE and the 2205 * same variable is used for DISABLE/ENABLE information. 2206 */ 2207 if ((MDI_PI(pip)->pi_state == 2208 MDI_PATHINFO_STATE_ONLINE) && 2209 preferred == MDI_PI(pip)->pi_preferred) { 2210 /* 2211 * Return the path in hold state. Caller should 2212 * release the lock by calling mdi_rele_path() 2213 */ 2214 MDI_PI_HOLD(pip); 2215 MDI_PI_UNLOCK(pip); 2216 ct->ct_path_last = pip; 2217 *ret_pip = pip; 2218 MDI_CLIENT_UNLOCK(ct); 2219 return (MDI_SUCCESS); 2220 } 2221 2222 /* 2223 * Path is busy. 2224 */ 2225 if (MDI_PI_IS_DRV_DISABLE_TRANSIENT(pip) || 2226 MDI_PI_IS_TRANSIENT(pip)) 2227 retry = 1; 2228 /* 2229 * Keep looking for a next available online path 2230 */ 2231 next = (mdi_pathinfo_t *)MDI_PI(pip)->pi_client_link; 2232 if (next == NULL) { 2233 next = head; 2234 } 2235 MDI_PI_UNLOCK(pip); 2236 pip = next; 2237 if (start == pip && preferred) { 2238 preferred = 0; 2239 } else if (start == pip && !preferred) { 2240 cont = 0; 2241 } 2242 } while (cont); 2243 break; 2244 2245 case LOAD_BALANCE_LBA: 2246 /* 2247 * Make sure we are looking 2248 * for an online path. Otherwise, if it is for a STANDBY 2249 * path request, it will go through and fetch an ONLINE 2250 * path which is not desirable. 2251 */ 2252 if ((ct->ct_lb_args != NULL) && 2253 (ct->ct_lb_args->region_size) && bp && 2254 (sb || (flags == MDI_SELECT_ONLINE_PATH))) { 2255 if (i_mdi_lba_lb(ct, ret_pip, bp) 2256 == MDI_SUCCESS) { 2257 MDI_CLIENT_UNLOCK(ct); 2258 return (MDI_SUCCESS); 2259 } 2260 } 2261 /* FALLTHROUGH */ 2262 case LOAD_BALANCE_RR: 2263 /* 2264 * Load balancing is Round Robin. Start looking for a online 2265 * mdi_pathinfo node starting from last known selected path 2266 * as the start point. If override flags are specified, 2267 * process accordingly. 2268 * If the search is already in effect(start_pip not null), 2269 * then lets just use the same path preference to continue the 2270 * traversal. 2271 */ 2272 2273 if (start_pip != NULL) { 2274 preferred = MDI_PI(start_pip)->pi_preferred; 2275 } else { 2276 preferred = 1; 2277 } 2278 2279 start = sb ? (mdi_pathinfo_t *)ct->ct_path_last : start_pip; 2280 if (start == NULL) { 2281 pip = head; 2282 } else { 2283 pip = (mdi_pathinfo_t *)MDI_PI(start)->pi_client_link; 2284 if (pip == NULL) { 2285 if ( flags & MDI_SELECT_NO_PREFERRED) { 2286 /* 2287 * Return since we hit the end of list 2288 */ 2289 MDI_CLIENT_UNLOCK(ct); 2290 return (MDI_NOPATH); 2291 } 2292 2293 if (!sb) { 2294 if (preferred == 0) { 2295 /* 2296 * Looks like we have completed 2297 * the traversal as preferred 2298 * value is 0. Time to bail out. 2299 */ 2300 *ret_pip = NULL; 2301 MDI_CLIENT_UNLOCK(ct); 2302 return (MDI_NOPATH); 2303 } else { 2304 /* 2305 * Looks like we reached the 2306 * end of the list. Lets enable 2307 * traversal of non preferred 2308 * paths. 2309 */ 2310 preferred = 0; 2311 } 2312 } 2313 pip = head; 2314 } 2315 } 2316 start = pip; 2317 do { 2318 MDI_PI_LOCK(pip); 2319 if (sb) { 2320 cond = ((MDI_PI(pip)->pi_state == 2321 MDI_PATHINFO_STATE_ONLINE && 2322 MDI_PI(pip)->pi_preferred == 2323 preferred) ? 1 : 0); 2324 } else { 2325 if (flags == MDI_SELECT_ONLINE_PATH) { 2326 cond = ((MDI_PI(pip)->pi_state == 2327 MDI_PATHINFO_STATE_ONLINE && 2328 MDI_PI(pip)->pi_preferred == 2329 preferred) ? 1 : 0); 2330 } else if (flags == MDI_SELECT_STANDBY_PATH) { 2331 cond = ((MDI_PI(pip)->pi_state == 2332 MDI_PATHINFO_STATE_STANDBY && 2333 MDI_PI(pip)->pi_preferred == 2334 preferred) ? 1 : 0); 2335 } else if (flags == (MDI_SELECT_ONLINE_PATH | 2336 MDI_SELECT_STANDBY_PATH)) { 2337 cond = (((MDI_PI(pip)->pi_state == 2338 MDI_PATHINFO_STATE_ONLINE || 2339 (MDI_PI(pip)->pi_state == 2340 MDI_PATHINFO_STATE_STANDBY)) && 2341 MDI_PI(pip)->pi_preferred == 2342 preferred) ? 1 : 0); 2343 } else if (flags == 2344 (MDI_SELECT_STANDBY_PATH | 2345 MDI_SELECT_ONLINE_PATH | 2346 MDI_SELECT_USER_DISABLE_PATH)) { 2347 cond = (((MDI_PI(pip)->pi_state == 2348 MDI_PATHINFO_STATE_ONLINE || 2349 (MDI_PI(pip)->pi_state == 2350 MDI_PATHINFO_STATE_STANDBY) || 2351 (MDI_PI(pip)->pi_state == 2352 (MDI_PATHINFO_STATE_ONLINE| 2353 MDI_PATHINFO_STATE_USER_DISABLE)) || 2354 (MDI_PI(pip)->pi_state == 2355 (MDI_PATHINFO_STATE_STANDBY | 2356 MDI_PATHINFO_STATE_USER_DISABLE)))&& 2357 MDI_PI(pip)->pi_preferred == 2358 preferred) ? 1 : 0); 2359 } else if (flags == 2360 (MDI_SELECT_STANDBY_PATH | 2361 MDI_SELECT_ONLINE_PATH | 2362 MDI_SELECT_NO_PREFERRED)) { 2363 cond = (((MDI_PI(pip)->pi_state == 2364 MDI_PATHINFO_STATE_ONLINE) || 2365 (MDI_PI(pip)->pi_state == 2366 MDI_PATHINFO_STATE_STANDBY)) 2367 ? 1 : 0); 2368 } else { 2369 cond = 0; 2370 } 2371 } 2372 /* 2373 * No need to explicitly check if the path is disabled. 2374 * Since we are checking for state == ONLINE and the 2375 * same variable is used for DISABLE/ENABLE information. 2376 */ 2377 if (cond) { 2378 /* 2379 * Return the path in hold state. Caller should 2380 * release the lock by calling mdi_rele_path() 2381 */ 2382 MDI_PI_HOLD(pip); 2383 MDI_PI_UNLOCK(pip); 2384 if (sb) 2385 ct->ct_path_last = pip; 2386 *ret_pip = pip; 2387 MDI_CLIENT_UNLOCK(ct); 2388 return (MDI_SUCCESS); 2389 } 2390 /* 2391 * Path is busy. 2392 */ 2393 if (MDI_PI_IS_DRV_DISABLE_TRANSIENT(pip) || 2394 MDI_PI_IS_TRANSIENT(pip)) 2395 retry = 1; 2396 2397 /* 2398 * Keep looking for a next available online path 2399 */ 2400 do_again: 2401 next = (mdi_pathinfo_t *)MDI_PI(pip)->pi_client_link; 2402 if (next == NULL) { 2403 if ( flags & MDI_SELECT_NO_PREFERRED) { 2404 /* 2405 * Bail out since we hit the end of list 2406 */ 2407 MDI_PI_UNLOCK(pip); 2408 break; 2409 } 2410 2411 if (!sb) { 2412 if (preferred == 1) { 2413 /* 2414 * Looks like we reached the 2415 * end of the list. Lets enable 2416 * traversal of non preferred 2417 * paths. 2418 */ 2419 preferred = 0; 2420 next = head; 2421 } else { 2422 /* 2423 * We have done both the passes 2424 * Preferred as well as for 2425 * Non-preferred. Bail out now. 2426 */ 2427 cont = 0; 2428 } 2429 } else { 2430 /* 2431 * Standard behavior case. 2432 */ 2433 next = head; 2434 } 2435 } 2436 MDI_PI_UNLOCK(pip); 2437 if (cont == 0) { 2438 break; 2439 } 2440 pip = next; 2441 2442 if (!sb) { 2443 /* 2444 * We need to handle the selection of 2445 * non-preferred path in the following 2446 * case: 2447 * 2448 * +------+ +------+ +------+ +-----+ 2449 * | A : 1| - | B : 1| - | C : 0| - |NULL | 2450 * +------+ +------+ +------+ +-----+ 2451 * 2452 * If we start the search with B, we need to 2453 * skip beyond B to pick C which is non - 2454 * preferred in the second pass. The following 2455 * test, if true, will allow us to skip over 2456 * the 'start'(B in the example) to select 2457 * other non preferred elements. 2458 */ 2459 if ((start_pip != NULL) && (start_pip == pip) && 2460 (MDI_PI(start_pip)->pi_preferred 2461 != preferred)) { 2462 /* 2463 * try again after going past the start 2464 * pip 2465 */ 2466 MDI_PI_LOCK(pip); 2467 goto do_again; 2468 } 2469 } else { 2470 /* 2471 * Standard behavior case 2472 */ 2473 if (start == pip && preferred) { 2474 /* look for nonpreferred paths */ 2475 preferred = 0; 2476 } else if (start == pip && !preferred) { 2477 /* 2478 * Exit condition 2479 */ 2480 cont = 0; 2481 } 2482 } 2483 } while (cont); 2484 break; 2485 } 2486 2487 MDI_CLIENT_UNLOCK(ct); 2488 if (retry == 1) { 2489 return (MDI_BUSY); 2490 } else { 2491 return (MDI_NOPATH); 2492 } 2493 } 2494 2495 /* 2496 * For a client, return the next available path to any phci 2497 * 2498 * Note: 2499 * Caller should hold the branch's devinfo node to get a consistent 2500 * snap shot of the mdi_pathinfo nodes. 2501 * 2502 * Please note that even the list is stable the mdi_pathinfo 2503 * node state and properties are volatile. The caller should lock 2504 * and unlock the nodes by calling mdi_pi_lock() and 2505 * mdi_pi_unlock() functions to get a stable properties. 2506 * 2507 * If there is a need to use the nodes beyond the hold of the 2508 * devinfo node period (For ex. I/O), then mdi_pathinfo node 2509 * need to be held against unexpected removal by calling 2510 * mdi_hold_path() and should be released by calling 2511 * mdi_rele_path() on completion. 2512 */ 2513 mdi_pathinfo_t * 2514 mdi_get_next_phci_path(dev_info_t *ct_dip, mdi_pathinfo_t *pip) 2515 { 2516 mdi_client_t *ct; 2517 2518 if (!MDI_CLIENT(ct_dip)) 2519 return (NULL); 2520 2521 /* 2522 * Walk through client link 2523 */ 2524 ct = (mdi_client_t *)DEVI(ct_dip)->devi_mdi_client; 2525 ASSERT(ct != NULL); 2526 2527 if (pip == NULL) 2528 return ((mdi_pathinfo_t *)ct->ct_path_head); 2529 2530 return ((mdi_pathinfo_t *)MDI_PI(pip)->pi_client_link); 2531 } 2532 2533 /* 2534 * For a phci, return the next available path to any client 2535 * Note: ditto mdi_get_next_phci_path() 2536 */ 2537 mdi_pathinfo_t * 2538 mdi_get_next_client_path(dev_info_t *ph_dip, mdi_pathinfo_t *pip) 2539 { 2540 mdi_phci_t *ph; 2541 2542 if (!MDI_PHCI(ph_dip)) 2543 return (NULL); 2544 2545 /* 2546 * Walk through pHCI link 2547 */ 2548 ph = (mdi_phci_t *)DEVI(ph_dip)->devi_mdi_xhci; 2549 ASSERT(ph != NULL); 2550 2551 if (pip == NULL) 2552 return ((mdi_pathinfo_t *)ph->ph_path_head); 2553 2554 return ((mdi_pathinfo_t *)MDI_PI(pip)->pi_phci_link); 2555 } 2556 2557 /* 2558 * mdi_hold_path(): 2559 * Hold the mdi_pathinfo node against unwanted unexpected free. 2560 * Return Values: 2561 * None 2562 */ 2563 void 2564 mdi_hold_path(mdi_pathinfo_t *pip) 2565 { 2566 if (pip) { 2567 MDI_PI_LOCK(pip); 2568 MDI_PI_HOLD(pip); 2569 MDI_PI_UNLOCK(pip); 2570 } 2571 } 2572 2573 2574 /* 2575 * mdi_rele_path(): 2576 * Release the mdi_pathinfo node which was selected 2577 * through mdi_select_path() mechanism or manually held by 2578 * calling mdi_hold_path(). 2579 * Return Values: 2580 * None 2581 */ 2582 void 2583 mdi_rele_path(mdi_pathinfo_t *pip) 2584 { 2585 if (pip) { 2586 MDI_PI_LOCK(pip); 2587 MDI_PI_RELE(pip); 2588 if (MDI_PI(pip)->pi_ref_cnt == 0) { 2589 cv_broadcast(&MDI_PI(pip)->pi_ref_cv); 2590 } 2591 MDI_PI_UNLOCK(pip); 2592 } 2593 } 2594 2595 /* 2596 * mdi_pi_lock(): 2597 * Lock the mdi_pathinfo node. 2598 * Note: 2599 * The caller should release the lock by calling mdi_pi_unlock() 2600 */ 2601 void 2602 mdi_pi_lock(mdi_pathinfo_t *pip) 2603 { 2604 ASSERT(pip != NULL); 2605 if (pip) { 2606 MDI_PI_LOCK(pip); 2607 } 2608 } 2609 2610 2611 /* 2612 * mdi_pi_unlock(): 2613 * Unlock the mdi_pathinfo node. 2614 * Note: 2615 * The mdi_pathinfo node should have been locked with mdi_pi_lock() 2616 */ 2617 void 2618 mdi_pi_unlock(mdi_pathinfo_t *pip) 2619 { 2620 ASSERT(pip != NULL); 2621 if (pip) { 2622 MDI_PI_UNLOCK(pip); 2623 } 2624 } 2625 2626 /* 2627 * mdi_pi_find(): 2628 * Search the list of mdi_pathinfo nodes attached to the 2629 * pHCI/Client device node whose path address matches "paddr". 2630 * Returns a pointer to the mdi_pathinfo node if a matching node is 2631 * found. 2632 * Return Values: 2633 * mdi_pathinfo node handle 2634 * NULL 2635 * Notes: 2636 * Caller need not hold any locks to call this function. 2637 */ 2638 mdi_pathinfo_t * 2639 mdi_pi_find(dev_info_t *pdip, char *caddr, char *paddr) 2640 { 2641 mdi_phci_t *ph; 2642 mdi_vhci_t *vh; 2643 mdi_client_t *ct; 2644 mdi_pathinfo_t *pip = NULL; 2645 2646 MDI_DEBUG(2, (MDI_NOTE, pdip, 2647 "caddr@%s paddr@%s", caddr ? caddr : "", paddr ? paddr : "")); 2648 if ((pdip == NULL) || (paddr == NULL)) { 2649 return (NULL); 2650 } 2651 ph = i_devi_get_phci(pdip); 2652 if (ph == NULL) { 2653 /* 2654 * Invalid pHCI device, Nothing more to do. 2655 */ 2656 MDI_DEBUG(2, (MDI_WARN, pdip, "invalid phci")); 2657 return (NULL); 2658 } 2659 2660 vh = ph->ph_vhci; 2661 if (vh == NULL) { 2662 /* 2663 * Invalid vHCI device, Nothing more to do. 2664 */ 2665 MDI_DEBUG(2, (MDI_WARN, pdip, "invalid vhci")); 2666 return (NULL); 2667 } 2668 2669 /* 2670 * Look for pathinfo node identified by paddr. 2671 */ 2672 if (caddr == NULL) { 2673 /* 2674 * Find a mdi_pathinfo node under pHCI list for a matching 2675 * unit address. 2676 */ 2677 MDI_PHCI_LOCK(ph); 2678 if (MDI_PHCI_IS_OFFLINE(ph)) { 2679 MDI_DEBUG(2, (MDI_WARN, pdip, 2680 "offline phci %p", (void *)ph)); 2681 MDI_PHCI_UNLOCK(ph); 2682 return (NULL); 2683 } 2684 pip = (mdi_pathinfo_t *)ph->ph_path_head; 2685 2686 while (pip != NULL) { 2687 if (strcmp(MDI_PI(pip)->pi_addr, paddr) == 0) { 2688 break; 2689 } 2690 pip = (mdi_pathinfo_t *)MDI_PI(pip)->pi_phci_link; 2691 } 2692 MDI_PHCI_UNLOCK(ph); 2693 MDI_DEBUG(2, (MDI_NOTE, pdip, 2694 "found %s %p", mdi_pi_spathname(pip), (void *)pip)); 2695 return (pip); 2696 } 2697 2698 /* 2699 * XXX - Is the rest of the code in this function really necessary? 2700 * The consumers of mdi_pi_find() can search for the desired pathinfo 2701 * node by calling mdi_pi_find(pdip, NULL, paddr). Irrespective of 2702 * whether the search is based on the pathinfo nodes attached to 2703 * the pHCI or the client node, the result will be the same. 2704 */ 2705 2706 /* 2707 * Find the client device corresponding to 'caddr' 2708 */ 2709 MDI_VHCI_CLIENT_LOCK(vh); 2710 2711 /* 2712 * XXX - Passing NULL to the following function works as long as the 2713 * the client addresses (caddr) are unique per vhci basis. 2714 */ 2715 ct = i_mdi_client_find(vh, NULL, caddr); 2716 if (ct == NULL) { 2717 /* 2718 * Client not found, Obviously mdi_pathinfo node has not been 2719 * created yet. 2720 */ 2721 MDI_VHCI_CLIENT_UNLOCK(vh); 2722 MDI_DEBUG(2, (MDI_NOTE, pdip, 2723 "client not found for caddr @%s", caddr ? caddr : "")); 2724 return (NULL); 2725 } 2726 2727 /* 2728 * Hold the client lock and look for a mdi_pathinfo node with matching 2729 * pHCI and paddr 2730 */ 2731 MDI_CLIENT_LOCK(ct); 2732 2733 /* 2734 * Release the global mutex as it is no more needed. Note: We always 2735 * respect the locking order while acquiring. 2736 */ 2737 MDI_VHCI_CLIENT_UNLOCK(vh); 2738 2739 pip = (mdi_pathinfo_t *)ct->ct_path_head; 2740 while (pip != NULL) { 2741 /* 2742 * Compare the unit address 2743 */ 2744 if ((MDI_PI(pip)->pi_phci == ph) && 2745 strcmp(MDI_PI(pip)->pi_addr, paddr) == 0) { 2746 break; 2747 } 2748 pip = (mdi_pathinfo_t *)MDI_PI(pip)->pi_client_link; 2749 } 2750 MDI_CLIENT_UNLOCK(ct); 2751 MDI_DEBUG(2, (MDI_NOTE, pdip, 2752 "found: %s %p", mdi_pi_spathname(pip), (void *)pip)); 2753 return (pip); 2754 } 2755 2756 /* 2757 * mdi_pi_alloc(): 2758 * Allocate and initialize a new instance of a mdi_pathinfo node. 2759 * The mdi_pathinfo node returned by this function identifies a 2760 * unique device path is capable of having properties attached 2761 * and passed to mdi_pi_online() to fully attach and online the 2762 * path and client device node. 2763 * The mdi_pathinfo node returned by this function must be 2764 * destroyed using mdi_pi_free() if the path is no longer 2765 * operational or if the caller fails to attach a client device 2766 * node when calling mdi_pi_online(). The framework will not free 2767 * the resources allocated. 2768 * This function can be called from both interrupt and kernel 2769 * contexts. DDI_NOSLEEP flag should be used while calling 2770 * from interrupt contexts. 2771 * Return Values: 2772 * MDI_SUCCESS 2773 * MDI_FAILURE 2774 * MDI_NOMEM 2775 */ 2776 /*ARGSUSED*/ 2777 int 2778 mdi_pi_alloc_compatible(dev_info_t *pdip, char *cname, char *caddr, char *paddr, 2779 char **compatible, int ncompatible, int flags, mdi_pathinfo_t **ret_pip) 2780 { 2781 mdi_vhci_t *vh; 2782 mdi_phci_t *ph; 2783 mdi_client_t *ct; 2784 mdi_pathinfo_t *pip = NULL; 2785 dev_info_t *cdip; 2786 int rv = MDI_NOMEM; 2787 int path_allocated = 0; 2788 2789 MDI_DEBUG(2, (MDI_NOTE, pdip, 2790 "cname %s: caddr@%s paddr@%s", 2791 cname ? cname : "", caddr ? caddr : "", paddr ? paddr : "")); 2792 2793 if (pdip == NULL || cname == NULL || caddr == NULL || paddr == NULL || 2794 ret_pip == NULL) { 2795 /* Nothing more to do */ 2796 return (MDI_FAILURE); 2797 } 2798 2799 *ret_pip = NULL; 2800 2801 /* No allocations on detaching pHCI */ 2802 if (DEVI_IS_DETACHING(pdip)) { 2803 /* Invalid pHCI device, return failure */ 2804 MDI_DEBUG(1, (MDI_WARN, pdip, 2805 "!detaching pHCI=%p", (void *)pdip)); 2806 return (MDI_FAILURE); 2807 } 2808 2809 ph = i_devi_get_phci(pdip); 2810 ASSERT(ph != NULL); 2811 if (ph == NULL) { 2812 /* Invalid pHCI device, return failure */ 2813 MDI_DEBUG(1, (MDI_WARN, pdip, 2814 "!invalid pHCI=%p", (void *)pdip)); 2815 return (MDI_FAILURE); 2816 } 2817 2818 MDI_PHCI_LOCK(ph); 2819 vh = ph->ph_vhci; 2820 if (vh == NULL) { 2821 /* Invalid vHCI device, return failure */ 2822 MDI_DEBUG(1, (MDI_WARN, pdip, 2823 "!invalid vHCI=%p", (void *)pdip)); 2824 MDI_PHCI_UNLOCK(ph); 2825 return (MDI_FAILURE); 2826 } 2827 2828 if (MDI_PHCI_IS_READY(ph) == 0) { 2829 /* 2830 * Do not allow new node creation when pHCI is in 2831 * offline/suspended states 2832 */ 2833 MDI_DEBUG(1, (MDI_WARN, pdip, 2834 "pHCI=%p is not ready", (void *)ph)); 2835 MDI_PHCI_UNLOCK(ph); 2836 return (MDI_BUSY); 2837 } 2838 MDI_PHCI_UNSTABLE(ph); 2839 MDI_PHCI_UNLOCK(ph); 2840 2841 /* look for a matching client, create one if not found */ 2842 MDI_VHCI_CLIENT_LOCK(vh); 2843 ct = i_mdi_client_find(vh, cname, caddr); 2844 if (ct == NULL) { 2845 ct = i_mdi_client_alloc(vh, cname, caddr); 2846 ASSERT(ct != NULL); 2847 } 2848 2849 if (ct->ct_dip == NULL) { 2850 /* 2851 * Allocate a devinfo node 2852 */ 2853 ct->ct_dip = i_mdi_devinfo_create(vh, cname, caddr, 2854 compatible, ncompatible); 2855 if (ct->ct_dip == NULL) { 2856 (void) i_mdi_client_free(vh, ct); 2857 goto fail; 2858 } 2859 } 2860 cdip = ct->ct_dip; 2861 2862 DEVI(cdip)->devi_mdi_component |= MDI_COMPONENT_CLIENT; 2863 DEVI(cdip)->devi_mdi_client = (caddr_t)ct; 2864 2865 MDI_CLIENT_LOCK(ct); 2866 pip = (mdi_pathinfo_t *)ct->ct_path_head; 2867 while (pip != NULL) { 2868 /* 2869 * Compare the unit address 2870 */ 2871 if ((MDI_PI(pip)->pi_phci == ph) && 2872 strcmp(MDI_PI(pip)->pi_addr, paddr) == 0) { 2873 break; 2874 } 2875 pip = (mdi_pathinfo_t *)MDI_PI(pip)->pi_client_link; 2876 } 2877 MDI_CLIENT_UNLOCK(ct); 2878 2879 if (pip == NULL) { 2880 /* 2881 * This is a new path for this client device. Allocate and 2882 * initialize a new pathinfo node 2883 */ 2884 pip = i_mdi_pi_alloc(ph, paddr, ct); 2885 ASSERT(pip != NULL); 2886 path_allocated = 1; 2887 } 2888 rv = MDI_SUCCESS; 2889 2890 fail: 2891 /* 2892 * Release the global mutex. 2893 */ 2894 MDI_VHCI_CLIENT_UNLOCK(vh); 2895 2896 /* 2897 * Mark the pHCI as stable 2898 */ 2899 MDI_PHCI_LOCK(ph); 2900 MDI_PHCI_STABLE(ph); 2901 MDI_PHCI_UNLOCK(ph); 2902 *ret_pip = pip; 2903 2904 MDI_DEBUG(2, (MDI_NOTE, pdip, 2905 "alloc %s %p", mdi_pi_spathname(pip), (void *)pip)); 2906 2907 if (path_allocated) 2908 vhcache_pi_add(vh->vh_config, MDI_PI(pip)); 2909 2910 return (rv); 2911 } 2912 2913 /*ARGSUSED*/ 2914 int 2915 mdi_pi_alloc(dev_info_t *pdip, char *cname, char *caddr, char *paddr, 2916 int flags, mdi_pathinfo_t **ret_pip) 2917 { 2918 return (mdi_pi_alloc_compatible(pdip, cname, caddr, paddr, NULL, 0, 2919 flags, ret_pip)); 2920 } 2921 2922 /* 2923 * i_mdi_pi_alloc(): 2924 * Allocate a mdi_pathinfo node and add to the pHCI path list 2925 * Return Values: 2926 * mdi_pathinfo 2927 */ 2928 /*ARGSUSED*/ 2929 static mdi_pathinfo_t * 2930 i_mdi_pi_alloc(mdi_phci_t *ph, char *paddr, mdi_client_t *ct) 2931 { 2932 mdi_pathinfo_t *pip; 2933 int ct_circular; 2934 int ph_circular; 2935 static char path[MAXPATHLEN]; /* mdi_pathmap_mutex protects */ 2936 char *path_persistent; 2937 int path_instance; 2938 mod_hash_val_t hv; 2939 2940 ASSERT(MDI_VHCI_CLIENT_LOCKED(ph->ph_vhci)); 2941 2942 pip = kmem_zalloc(sizeof (struct mdi_pathinfo), KM_SLEEP); 2943 mutex_init(&MDI_PI(pip)->pi_mutex, NULL, MUTEX_DEFAULT, NULL); 2944 MDI_PI(pip)->pi_state = MDI_PATHINFO_STATE_INIT | 2945 MDI_PATHINFO_STATE_TRANSIENT; 2946 2947 if (MDI_PHCI_IS_USER_DISABLED(ph)) 2948 MDI_PI_SET_USER_DISABLE(pip); 2949 2950 if (MDI_PHCI_IS_DRV_DISABLED_TRANSIENT(ph)) 2951 MDI_PI_SET_DRV_DISABLE_TRANS(pip); 2952 2953 if (MDI_PHCI_IS_DRV_DISABLED(ph)) 2954 MDI_PI_SET_DRV_DISABLE(pip); 2955 2956 MDI_PI(pip)->pi_old_state = MDI_PATHINFO_STATE_INIT; 2957 cv_init(&MDI_PI(pip)->pi_state_cv, NULL, CV_DEFAULT, NULL); 2958 MDI_PI(pip)->pi_client = ct; 2959 MDI_PI(pip)->pi_phci = ph; 2960 MDI_PI(pip)->pi_addr = kmem_alloc(strlen(paddr) + 1, KM_SLEEP); 2961 (void) strcpy(MDI_PI(pip)->pi_addr, paddr); 2962 2963 /* 2964 * We form the "path" to the pathinfo node, and see if we have 2965 * already allocated a 'path_instance' for that "path". If so, 2966 * we use the already allocated 'path_instance'. If not, we 2967 * allocate a new 'path_instance' and associate it with a copy of 2968 * the "path" string (which is never freed). The association 2969 * between a 'path_instance' this "path" string persists until 2970 * reboot. 2971 */ 2972 mutex_enter(&mdi_pathmap_mutex); 2973 (void) ddi_pathname(ph->ph_dip, path); 2974 (void) sprintf(path + strlen(path), "/%s@%s", 2975 mdi_pi_get_node_name(pip), mdi_pi_get_addr(pip)); 2976 if (mod_hash_find(mdi_pathmap_bypath, (mod_hash_key_t)path, &hv) == 0) { 2977 path_instance = (uint_t)(intptr_t)hv; 2978 } else { 2979 /* allocate a new 'path_instance' and persistent "path" */ 2980 path_instance = mdi_pathmap_instance++; 2981 path_persistent = i_ddi_strdup(path, KM_SLEEP); 2982 (void) mod_hash_insert(mdi_pathmap_bypath, 2983 (mod_hash_key_t)path_persistent, 2984 (mod_hash_val_t)(intptr_t)path_instance); 2985 (void) mod_hash_insert(mdi_pathmap_byinstance, 2986 (mod_hash_key_t)(intptr_t)path_instance, 2987 (mod_hash_val_t)path_persistent); 2988 2989 /* create shortpath name */ 2990 (void) snprintf(path, sizeof(path), "%s%d/%s@%s", 2991 ddi_driver_name(ph->ph_dip), ddi_get_instance(ph->ph_dip), 2992 mdi_pi_get_node_name(pip), mdi_pi_get_addr(pip)); 2993 path_persistent = i_ddi_strdup(path, KM_SLEEP); 2994 (void) mod_hash_insert(mdi_pathmap_sbyinstance, 2995 (mod_hash_key_t)(intptr_t)path_instance, 2996 (mod_hash_val_t)path_persistent); 2997 } 2998 mutex_exit(&mdi_pathmap_mutex); 2999 MDI_PI(pip)->pi_path_instance = path_instance; 3000 3001 (void) nvlist_alloc(&MDI_PI(pip)->pi_prop, NV_UNIQUE_NAME, KM_SLEEP); 3002 ASSERT(MDI_PI(pip)->pi_prop != NULL); 3003 MDI_PI(pip)->pi_pprivate = NULL; 3004 MDI_PI(pip)->pi_cprivate = NULL; 3005 MDI_PI(pip)->pi_vprivate = NULL; 3006 MDI_PI(pip)->pi_client_link = NULL; 3007 MDI_PI(pip)->pi_phci_link = NULL; 3008 MDI_PI(pip)->pi_ref_cnt = 0; 3009 MDI_PI(pip)->pi_kstats = NULL; 3010 MDI_PI(pip)->pi_preferred = 1; 3011 cv_init(&MDI_PI(pip)->pi_ref_cv, NULL, CV_DEFAULT, NULL); 3012 3013 /* 3014 * Lock both dev_info nodes against changes in parallel. 3015 * 3016 * The ndi_devi_enter(Client), is atypical since the client is a leaf. 3017 * This atypical operation is done to synchronize pathinfo nodes 3018 * during devinfo snapshot (see di_register_pip) by 'pretending' that 3019 * the pathinfo nodes are children of the Client. 3020 */ 3021 ndi_devi_enter(ct->ct_dip, &ct_circular); 3022 ndi_devi_enter(ph->ph_dip, &ph_circular); 3023 3024 i_mdi_phci_add_path(ph, pip); 3025 i_mdi_client_add_path(ct, pip); 3026 3027 ndi_devi_exit(ph->ph_dip, ph_circular); 3028 ndi_devi_exit(ct->ct_dip, ct_circular); 3029 3030 return (pip); 3031 } 3032 3033 /* 3034 * mdi_pi_pathname_by_instance(): 3035 * Lookup of "path" by 'path_instance'. Return "path". 3036 * NOTE: returned "path" remains valid forever (until reboot). 3037 */ 3038 char * 3039 mdi_pi_pathname_by_instance(int path_instance) 3040 { 3041 char *path; 3042 mod_hash_val_t hv; 3043 3044 /* mdi_pathmap lookup of "path" by 'path_instance' */ 3045 mutex_enter(&mdi_pathmap_mutex); 3046 if (mod_hash_find(mdi_pathmap_byinstance, 3047 (mod_hash_key_t)(intptr_t)path_instance, &hv) == 0) 3048 path = (char *)hv; 3049 else 3050 path = NULL; 3051 mutex_exit(&mdi_pathmap_mutex); 3052 return (path); 3053 } 3054 3055 /* 3056 * mdi_pi_spathname_by_instance(): 3057 * Lookup of "shortpath" by 'path_instance'. Return "shortpath". 3058 * NOTE: returned "shortpath" remains valid forever (until reboot). 3059 */ 3060 char * 3061 mdi_pi_spathname_by_instance(int path_instance) 3062 { 3063 char *path; 3064 mod_hash_val_t hv; 3065 3066 /* mdi_pathmap lookup of "path" by 'path_instance' */ 3067 mutex_enter(&mdi_pathmap_mutex); 3068 if (mod_hash_find(mdi_pathmap_sbyinstance, 3069 (mod_hash_key_t)(intptr_t)path_instance, &hv) == 0) 3070 path = (char *)hv; 3071 else 3072 path = NULL; 3073 mutex_exit(&mdi_pathmap_mutex); 3074 return (path); 3075 } 3076 3077 3078 /* 3079 * i_mdi_phci_add_path(): 3080 * Add a mdi_pathinfo node to pHCI list. 3081 * Notes: 3082 * Caller should per-pHCI mutex 3083 */ 3084 static void 3085 i_mdi_phci_add_path(mdi_phci_t *ph, mdi_pathinfo_t *pip) 3086 { 3087 ASSERT(DEVI_BUSY_OWNED(ph->ph_dip)); 3088 3089 MDI_PHCI_LOCK(ph); 3090 if (ph->ph_path_head == NULL) { 3091 ph->ph_path_head = pip; 3092 } else { 3093 MDI_PI(ph->ph_path_tail)->pi_phci_link = MDI_PI(pip); 3094 } 3095 ph->ph_path_tail = pip; 3096 ph->ph_path_count++; 3097 MDI_PHCI_UNLOCK(ph); 3098 } 3099 3100 /* 3101 * i_mdi_client_add_path(): 3102 * Add mdi_pathinfo node to client list 3103 */ 3104 static void 3105 i_mdi_client_add_path(mdi_client_t *ct, mdi_pathinfo_t *pip) 3106 { 3107 ASSERT(DEVI_BUSY_OWNED(ct->ct_dip)); 3108 3109 MDI_CLIENT_LOCK(ct); 3110 if (ct->ct_path_head == NULL) { 3111 ct->ct_path_head = pip; 3112 } else { 3113 MDI_PI(ct->ct_path_tail)->pi_client_link = MDI_PI(pip); 3114 } 3115 ct->ct_path_tail = pip; 3116 ct->ct_path_count++; 3117 MDI_CLIENT_UNLOCK(ct); 3118 } 3119 3120 /* 3121 * mdi_pi_free(): 3122 * Free the mdi_pathinfo node and also client device node if this 3123 * is the last path to the device 3124 * Return Values: 3125 * MDI_SUCCESS 3126 * MDI_FAILURE 3127 * MDI_BUSY 3128 */ 3129 /*ARGSUSED*/ 3130 int 3131 mdi_pi_free(mdi_pathinfo_t *pip, int flags) 3132 { 3133 int rv; 3134 mdi_vhci_t *vh; 3135 mdi_phci_t *ph; 3136 mdi_client_t *ct; 3137 int (*f)(); 3138 int client_held = 0; 3139 3140 MDI_PI_LOCK(pip); 3141 ph = MDI_PI(pip)->pi_phci; 3142 ASSERT(ph != NULL); 3143 if (ph == NULL) { 3144 /* 3145 * Invalid pHCI device, return failure 3146 */ 3147 MDI_DEBUG(1, (MDI_WARN, NULL, 3148 "!invalid pHCI: pip %s %p", 3149 mdi_pi_spathname(pip), (void *)pip)); 3150 MDI_PI_UNLOCK(pip); 3151 return (MDI_FAILURE); 3152 } 3153 3154 vh = ph->ph_vhci; 3155 ASSERT(vh != NULL); 3156 if (vh == NULL) { 3157 /* Invalid pHCI device, return failure */ 3158 MDI_DEBUG(1, (MDI_WARN, ph->ph_dip, 3159 "!invalid vHCI: pip %s %p", 3160 mdi_pi_spathname(pip), (void *)pip)); 3161 MDI_PI_UNLOCK(pip); 3162 return (MDI_FAILURE); 3163 } 3164 3165 ct = MDI_PI(pip)->pi_client; 3166 ASSERT(ct != NULL); 3167 if (ct == NULL) { 3168 /* 3169 * Invalid Client device, return failure 3170 */ 3171 MDI_DEBUG(1, (MDI_WARN, ph->ph_dip, 3172 "!invalid client: pip %s %p", 3173 mdi_pi_spathname(pip), (void *)pip)); 3174 MDI_PI_UNLOCK(pip); 3175 return (MDI_FAILURE); 3176 } 3177 3178 /* 3179 * Check to see for busy condition. A mdi_pathinfo can only be freed 3180 * if the node state is either offline or init and the reference count 3181 * is zero. 3182 */ 3183 if (!(MDI_PI_IS_OFFLINE(pip) || MDI_PI_IS_INIT(pip) || 3184 MDI_PI_IS_INITING(pip))) { 3185 /* 3186 * Node is busy 3187 */ 3188 MDI_DEBUG(1, (MDI_WARN, ct->ct_dip, 3189 "!busy: pip %s %p", mdi_pi_spathname(pip), (void *)pip)); 3190 MDI_PI_UNLOCK(pip); 3191 return (MDI_BUSY); 3192 } 3193 3194 while (MDI_PI(pip)->pi_ref_cnt != 0) { 3195 /* 3196 * Give a chance for pending I/Os to complete. 3197 */ 3198 MDI_DEBUG(1, (MDI_NOTE, ct->ct_dip, 3199 "!%d cmds still pending on path: %s %p", 3200 MDI_PI(pip)->pi_ref_cnt, 3201 mdi_pi_spathname(pip), (void *)pip)); 3202 if (cv_reltimedwait(&MDI_PI(pip)->pi_ref_cv, 3203 &MDI_PI(pip)->pi_mutex, drv_usectohz(60 * 1000000), 3204 TR_CLOCK_TICK) == -1) { 3205 /* 3206 * The timeout time reached without ref_cnt being zero 3207 * being signaled. 3208 */ 3209 MDI_DEBUG(1, (MDI_NOTE, ct->ct_dip, 3210 "!Timeout reached on path %s %p without the cond", 3211 mdi_pi_spathname(pip), (void *)pip)); 3212 MDI_DEBUG(1, (MDI_NOTE, ct->ct_dip, 3213 "!%d cmds still pending on path %s %p", 3214 MDI_PI(pip)->pi_ref_cnt, 3215 mdi_pi_spathname(pip), (void *)pip)); 3216 MDI_PI_UNLOCK(pip); 3217 return (MDI_BUSY); 3218 } 3219 } 3220 if (MDI_PI(pip)->pi_pm_held) { 3221 client_held = 1; 3222 } 3223 MDI_PI_UNLOCK(pip); 3224 3225 vhcache_pi_remove(vh->vh_config, MDI_PI(pip)); 3226 3227 MDI_CLIENT_LOCK(ct); 3228 3229 /* Prevent further failovers till MDI_VHCI_CLIENT_LOCK is held */ 3230 MDI_CLIENT_SET_PATH_FREE_IN_PROGRESS(ct); 3231 3232 /* 3233 * Wait till failover is complete before removing this node. 3234 */ 3235 while (MDI_CLIENT_IS_FAILOVER_IN_PROGRESS(ct)) 3236 cv_wait(&ct->ct_failover_cv, &ct->ct_mutex); 3237 3238 MDI_CLIENT_UNLOCK(ct); 3239 MDI_VHCI_CLIENT_LOCK(vh); 3240 MDI_CLIENT_LOCK(ct); 3241 MDI_CLIENT_CLEAR_PATH_FREE_IN_PROGRESS(ct); 3242 3243 if (!MDI_PI_IS_INITING(pip)) { 3244 f = vh->vh_ops->vo_pi_uninit; 3245 if (f != NULL) { 3246 rv = (*f)(vh->vh_dip, pip, 0); 3247 } 3248 } else 3249 rv = MDI_SUCCESS; 3250 3251 /* 3252 * If vo_pi_uninit() completed successfully. 3253 */ 3254 if (rv == MDI_SUCCESS) { 3255 if (client_held) { 3256 MDI_DEBUG(4, (MDI_NOTE, ct->ct_dip, 3257 "i_mdi_pm_rele_client\n")); 3258 i_mdi_pm_rele_client(ct, 1); 3259 } 3260 i_mdi_pi_free(ph, pip, ct); 3261 if (ct->ct_path_count == 0) { 3262 /* 3263 * Client lost its last path. 3264 * Clean up the client device 3265 */ 3266 MDI_CLIENT_UNLOCK(ct); 3267 (void) i_mdi_client_free(ct->ct_vhci, ct); 3268 MDI_VHCI_CLIENT_UNLOCK(vh); 3269 return (rv); 3270 } 3271 } 3272 MDI_CLIENT_UNLOCK(ct); 3273 MDI_VHCI_CLIENT_UNLOCK(vh); 3274 3275 if (rv == MDI_FAILURE) 3276 vhcache_pi_add(vh->vh_config, MDI_PI(pip)); 3277 3278 return (rv); 3279 } 3280 3281 /* 3282 * i_mdi_pi_free(): 3283 * Free the mdi_pathinfo node 3284 */ 3285 static void 3286 i_mdi_pi_free(mdi_phci_t *ph, mdi_pathinfo_t *pip, mdi_client_t *ct) 3287 { 3288 int ct_circular; 3289 int ph_circular; 3290 3291 ASSERT(MDI_CLIENT_LOCKED(ct)); 3292 3293 /* 3294 * remove any per-path kstats 3295 */ 3296 i_mdi_pi_kstat_destroy(pip); 3297 3298 /* See comments in i_mdi_pi_alloc() */ 3299 ndi_devi_enter(ct->ct_dip, &ct_circular); 3300 ndi_devi_enter(ph->ph_dip, &ph_circular); 3301 3302 i_mdi_client_remove_path(ct, pip); 3303 i_mdi_phci_remove_path(ph, pip); 3304 3305 ndi_devi_exit(ph->ph_dip, ph_circular); 3306 ndi_devi_exit(ct->ct_dip, ct_circular); 3307 3308 mutex_destroy(&MDI_PI(pip)->pi_mutex); 3309 cv_destroy(&MDI_PI(pip)->pi_state_cv); 3310 cv_destroy(&MDI_PI(pip)->pi_ref_cv); 3311 if (MDI_PI(pip)->pi_addr) { 3312 kmem_free(MDI_PI(pip)->pi_addr, 3313 strlen(MDI_PI(pip)->pi_addr) + 1); 3314 MDI_PI(pip)->pi_addr = NULL; 3315 } 3316 3317 if (MDI_PI(pip)->pi_prop) { 3318 (void) nvlist_free(MDI_PI(pip)->pi_prop); 3319 MDI_PI(pip)->pi_prop = NULL; 3320 } 3321 kmem_free(pip, sizeof (struct mdi_pathinfo)); 3322 } 3323 3324 3325 /* 3326 * i_mdi_phci_remove_path(): 3327 * Remove a mdi_pathinfo node from pHCI list. 3328 * Notes: 3329 * Caller should hold per-pHCI mutex 3330 */ 3331 static void 3332 i_mdi_phci_remove_path(mdi_phci_t *ph, mdi_pathinfo_t *pip) 3333 { 3334 mdi_pathinfo_t *prev = NULL; 3335 mdi_pathinfo_t *path = NULL; 3336 3337 ASSERT(DEVI_BUSY_OWNED(ph->ph_dip)); 3338 3339 MDI_PHCI_LOCK(ph); 3340 path = ph->ph_path_head; 3341 while (path != NULL) { 3342 if (path == pip) { 3343 break; 3344 } 3345 prev = path; 3346 path = (mdi_pathinfo_t *)MDI_PI(path)->pi_phci_link; 3347 } 3348 3349 if (path) { 3350 ph->ph_path_count--; 3351 if (prev) { 3352 MDI_PI(prev)->pi_phci_link = MDI_PI(path)->pi_phci_link; 3353 } else { 3354 ph->ph_path_head = 3355 (mdi_pathinfo_t *)MDI_PI(path)->pi_phci_link; 3356 } 3357 if (ph->ph_path_tail == path) { 3358 ph->ph_path_tail = prev; 3359 } 3360 } 3361 3362 /* 3363 * Clear the pHCI link 3364 */ 3365 MDI_PI(pip)->pi_phci_link = NULL; 3366 MDI_PI(pip)->pi_phci = NULL; 3367 MDI_PHCI_UNLOCK(ph); 3368 } 3369 3370 /* 3371 * i_mdi_client_remove_path(): 3372 * Remove a mdi_pathinfo node from client path list. 3373 */ 3374 static void 3375 i_mdi_client_remove_path(mdi_client_t *ct, mdi_pathinfo_t *pip) 3376 { 3377 mdi_pathinfo_t *prev = NULL; 3378 mdi_pathinfo_t *path; 3379 3380 ASSERT(DEVI_BUSY_OWNED(ct->ct_dip)); 3381 3382 ASSERT(MDI_CLIENT_LOCKED(ct)); 3383 path = ct->ct_path_head; 3384 while (path != NULL) { 3385 if (path == pip) { 3386 break; 3387 } 3388 prev = path; 3389 path = (mdi_pathinfo_t *)MDI_PI(path)->pi_client_link; 3390 } 3391 3392 if (path) { 3393 ct->ct_path_count--; 3394 if (prev) { 3395 MDI_PI(prev)->pi_client_link = 3396 MDI_PI(path)->pi_client_link; 3397 } else { 3398 ct->ct_path_head = 3399 (mdi_pathinfo_t *)MDI_PI(path)->pi_client_link; 3400 } 3401 if (ct->ct_path_tail == path) { 3402 ct->ct_path_tail = prev; 3403 } 3404 if (ct->ct_path_last == path) { 3405 ct->ct_path_last = ct->ct_path_head; 3406 } 3407 } 3408 MDI_PI(pip)->pi_client_link = NULL; 3409 MDI_PI(pip)->pi_client = NULL; 3410 } 3411 3412 /* 3413 * i_mdi_pi_state_change(): 3414 * online a mdi_pathinfo node 3415 * 3416 * Return Values: 3417 * MDI_SUCCESS 3418 * MDI_FAILURE 3419 */ 3420 /*ARGSUSED*/ 3421 static int 3422 i_mdi_pi_state_change(mdi_pathinfo_t *pip, mdi_pathinfo_state_t state, int flag) 3423 { 3424 int rv = MDI_SUCCESS; 3425 mdi_vhci_t *vh; 3426 mdi_phci_t *ph; 3427 mdi_client_t *ct; 3428 int (*f)(); 3429 dev_info_t *cdip; 3430 3431 MDI_PI_LOCK(pip); 3432 3433 ph = MDI_PI(pip)->pi_phci; 3434 ASSERT(ph); 3435 if (ph == NULL) { 3436 /* 3437 * Invalid pHCI device, fail the request 3438 */ 3439 MDI_PI_UNLOCK(pip); 3440 MDI_DEBUG(1, (MDI_WARN, NULL, 3441 "!invalid phci: pip %s %p", 3442 mdi_pi_spathname(pip), (void *)pip)); 3443 return (MDI_FAILURE); 3444 } 3445 3446 vh = ph->ph_vhci; 3447 ASSERT(vh); 3448 if (vh == NULL) { 3449 /* 3450 * Invalid vHCI device, fail the request 3451 */ 3452 MDI_PI_UNLOCK(pip); 3453 MDI_DEBUG(1, (MDI_WARN, ph->ph_dip, 3454 "!invalid vhci: pip %s %p", 3455 mdi_pi_spathname(pip), (void *)pip)); 3456 return (MDI_FAILURE); 3457 } 3458 3459 ct = MDI_PI(pip)->pi_client; 3460 ASSERT(ct != NULL); 3461 if (ct == NULL) { 3462 /* 3463 * Invalid client device, fail the request 3464 */ 3465 MDI_PI_UNLOCK(pip); 3466 MDI_DEBUG(1, (MDI_WARN, ph->ph_dip, 3467 "!invalid client: pip %s %p", 3468 mdi_pi_spathname(pip), (void *)pip)); 3469 return (MDI_FAILURE); 3470 } 3471 3472 /* 3473 * If this path has not been initialized yet, Callback vHCI driver's 3474 * pathinfo node initialize entry point 3475 */ 3476 3477 if (MDI_PI_IS_INITING(pip)) { 3478 MDI_PI_UNLOCK(pip); 3479 f = vh->vh_ops->vo_pi_init; 3480 if (f != NULL) { 3481 rv = (*f)(vh->vh_dip, pip, 0); 3482 if (rv != MDI_SUCCESS) { 3483 MDI_DEBUG(1, (MDI_WARN, ct->ct_dip, 3484 "!vo_pi_init failed: vHCI %p, pip %s %p", 3485 (void *)vh, mdi_pi_spathname(pip), 3486 (void *)pip)); 3487 return (MDI_FAILURE); 3488 } 3489 } 3490 MDI_PI_LOCK(pip); 3491 MDI_PI_CLEAR_TRANSIENT(pip); 3492 } 3493 3494 /* 3495 * Do not allow state transition when pHCI is in offline/suspended 3496 * states 3497 */ 3498 i_mdi_phci_lock(ph, pip); 3499 if (MDI_PHCI_IS_READY(ph) == 0) { 3500 MDI_DEBUG(1, (MDI_WARN, ct->ct_dip, 3501 "!pHCI not ready, pHCI=%p", (void *)ph)); 3502 MDI_PI_UNLOCK(pip); 3503 i_mdi_phci_unlock(ph); 3504 return (MDI_BUSY); 3505 } 3506 MDI_PHCI_UNSTABLE(ph); 3507 i_mdi_phci_unlock(ph); 3508 3509 /* 3510 * Check if mdi_pathinfo state is in transient state. 3511 * If yes, offlining is in progress and wait till transient state is 3512 * cleared. 3513 */ 3514 if (MDI_PI_IS_TRANSIENT(pip)) { 3515 while (MDI_PI_IS_TRANSIENT(pip)) { 3516 cv_wait(&MDI_PI(pip)->pi_state_cv, 3517 &MDI_PI(pip)->pi_mutex); 3518 } 3519 } 3520 3521 /* 3522 * Grab the client lock in reverse order sequence and release the 3523 * mdi_pathinfo mutex. 3524 */ 3525 i_mdi_client_lock(ct, pip); 3526 MDI_PI_UNLOCK(pip); 3527 3528 /* 3529 * Wait till failover state is cleared 3530 */ 3531 while (MDI_CLIENT_IS_FAILOVER_IN_PROGRESS(ct)) 3532 cv_wait(&ct->ct_failover_cv, &ct->ct_mutex); 3533 3534 /* 3535 * Mark the mdi_pathinfo node state as transient 3536 */ 3537 MDI_PI_LOCK(pip); 3538 switch (state) { 3539 case MDI_PATHINFO_STATE_ONLINE: 3540 MDI_PI_SET_ONLINING(pip); 3541 break; 3542 3543 case MDI_PATHINFO_STATE_STANDBY: 3544 MDI_PI_SET_STANDBYING(pip); 3545 break; 3546 3547 case MDI_PATHINFO_STATE_FAULT: 3548 /* 3549 * Mark the pathinfo state as FAULTED 3550 */ 3551 MDI_PI_SET_FAULTING(pip); 3552 MDI_PI_ERRSTAT(pip, MDI_PI_HARDERR); 3553 break; 3554 3555 case MDI_PATHINFO_STATE_OFFLINE: 3556 /* 3557 * ndi_devi_offline() cannot hold pip or ct locks. 3558 */ 3559 MDI_PI_UNLOCK(pip); 3560 3561 /* 3562 * If this is a user initiated path online->offline operation 3563 * who's success would transition a client from DEGRADED to 3564 * FAILED then only proceed if we can offline the client first. 3565 */ 3566 cdip = ct->ct_dip; 3567 if ((flag & NDI_USER_REQ) && 3568 MDI_PI_IS_ONLINE(pip) && 3569 (MDI_CLIENT_STATE(ct) == MDI_CLIENT_STATE_DEGRADED)) { 3570 i_mdi_client_unlock(ct); 3571 rv = ndi_devi_offline(cdip, NDI_DEVFS_CLEAN); 3572 if (rv != NDI_SUCCESS) { 3573 /* 3574 * Convert to MDI error code 3575 */ 3576 switch (rv) { 3577 case NDI_BUSY: 3578 rv = MDI_BUSY; 3579 break; 3580 default: 3581 rv = MDI_FAILURE; 3582 break; 3583 } 3584 goto state_change_exit; 3585 } else { 3586 i_mdi_client_lock(ct, NULL); 3587 } 3588 } 3589 /* 3590 * Mark the mdi_pathinfo node state as transient 3591 */ 3592 MDI_PI_LOCK(pip); 3593 MDI_PI_SET_OFFLINING(pip); 3594 break; 3595 } 3596 MDI_PI_UNLOCK(pip); 3597 MDI_CLIENT_UNSTABLE(ct); 3598 i_mdi_client_unlock(ct); 3599 3600 f = vh->vh_ops->vo_pi_state_change; 3601 if (f != NULL) 3602 rv = (*f)(vh->vh_dip, pip, state, 0, flag); 3603 3604 MDI_CLIENT_LOCK(ct); 3605 MDI_PI_LOCK(pip); 3606 if (rv == MDI_NOT_SUPPORTED) { 3607 MDI_CLIENT_SET_DEV_NOT_SUPPORTED(ct); 3608 } 3609 if (rv != MDI_SUCCESS) { 3610 MDI_DEBUG(2, (MDI_WARN, ct->ct_dip, 3611 "vo_pi_state_change failed: rv %x", rv)); 3612 } 3613 if (MDI_PI_IS_TRANSIENT(pip)) { 3614 if (rv == MDI_SUCCESS) { 3615 MDI_PI_CLEAR_TRANSIENT(pip); 3616 } else { 3617 MDI_PI(pip)->pi_state = MDI_PI_OLD_STATE(pip); 3618 } 3619 } 3620 3621 /* 3622 * Wake anyone waiting for this mdi_pathinfo node 3623 */ 3624 cv_broadcast(&MDI_PI(pip)->pi_state_cv); 3625 MDI_PI_UNLOCK(pip); 3626 3627 /* 3628 * Mark the client device as stable 3629 */ 3630 MDI_CLIENT_STABLE(ct); 3631 if (rv == MDI_SUCCESS) { 3632 if (ct->ct_unstable == 0) { 3633 cdip = ct->ct_dip; 3634 3635 /* 3636 * Onlining the mdi_pathinfo node will impact the 3637 * client state Update the client and dev_info node 3638 * state accordingly 3639 */ 3640 rv = NDI_SUCCESS; 3641 i_mdi_client_update_state(ct); 3642 switch (MDI_CLIENT_STATE(ct)) { 3643 case MDI_CLIENT_STATE_OPTIMAL: 3644 case MDI_CLIENT_STATE_DEGRADED: 3645 if (cdip && !i_ddi_devi_attached(cdip) && 3646 ((state == MDI_PATHINFO_STATE_ONLINE) || 3647 (state == MDI_PATHINFO_STATE_STANDBY))) { 3648 3649 /* 3650 * Must do ndi_devi_online() through 3651 * hotplug thread for deferred 3652 * attach mechanism to work 3653 */ 3654 MDI_CLIENT_UNLOCK(ct); 3655 rv = ndi_devi_online(cdip, 0); 3656 MDI_CLIENT_LOCK(ct); 3657 if ((rv != NDI_SUCCESS) && 3658 (MDI_CLIENT_STATE(ct) == 3659 MDI_CLIENT_STATE_DEGRADED)) { 3660 MDI_DEBUG(1, (MDI_WARN, cdip, 3661 "!ndi_devi_online failed " 3662 "error %x", rv)); 3663 } 3664 rv = NDI_SUCCESS; 3665 } 3666 break; 3667 3668 case MDI_CLIENT_STATE_FAILED: 3669 /* 3670 * This is the last path case for 3671 * non-user initiated events. 3672 */ 3673 if (((flag & NDI_USER_REQ) == 0) && 3674 cdip && (i_ddi_node_state(cdip) >= 3675 DS_INITIALIZED)) { 3676 MDI_CLIENT_UNLOCK(ct); 3677 rv = ndi_devi_offline(cdip, 3678 NDI_DEVFS_CLEAN); 3679 MDI_CLIENT_LOCK(ct); 3680 3681 if (rv != NDI_SUCCESS) { 3682 /* 3683 * ndi_devi_offline failed. 3684 * Reset client flags to 3685 * online as the path could not 3686 * be offlined. 3687 */ 3688 MDI_DEBUG(1, (MDI_WARN, cdip, 3689 "!ndi_devi_offline failed: " 3690 "error %x", rv)); 3691 MDI_CLIENT_SET_ONLINE(ct); 3692 } 3693 } 3694 break; 3695 } 3696 /* 3697 * Convert to MDI error code 3698 */ 3699 switch (rv) { 3700 case NDI_SUCCESS: 3701 MDI_CLIENT_SET_REPORT_DEV_NEEDED(ct); 3702 i_mdi_report_path_state(ct, pip); 3703 rv = MDI_SUCCESS; 3704 break; 3705 case NDI_BUSY: 3706 rv = MDI_BUSY; 3707 break; 3708 default: 3709 rv = MDI_FAILURE; 3710 break; 3711 } 3712 } 3713 } 3714 MDI_CLIENT_UNLOCK(ct); 3715 3716 state_change_exit: 3717 /* 3718 * Mark the pHCI as stable again. 3719 */ 3720 MDI_PHCI_LOCK(ph); 3721 MDI_PHCI_STABLE(ph); 3722 MDI_PHCI_UNLOCK(ph); 3723 return (rv); 3724 } 3725 3726 /* 3727 * mdi_pi_online(): 3728 * Place the path_info node in the online state. The path is 3729 * now available to be selected by mdi_select_path() for 3730 * transporting I/O requests to client devices. 3731 * Return Values: 3732 * MDI_SUCCESS 3733 * MDI_FAILURE 3734 */ 3735 int 3736 mdi_pi_online(mdi_pathinfo_t *pip, int flags) 3737 { 3738 mdi_client_t *ct = MDI_PI(pip)->pi_client; 3739 int client_held = 0; 3740 int rv; 3741 3742 ASSERT(ct != NULL); 3743 rv = i_mdi_pi_state_change(pip, MDI_PATHINFO_STATE_ONLINE, flags); 3744 if (rv != MDI_SUCCESS) 3745 return (rv); 3746 3747 MDI_PI_LOCK(pip); 3748 if (MDI_PI(pip)->pi_pm_held == 0) { 3749 MDI_DEBUG(4, (MDI_NOTE, ct->ct_dip, 3750 "i_mdi_pm_hold_pip %p", (void *)pip)); 3751 i_mdi_pm_hold_pip(pip); 3752 client_held = 1; 3753 } 3754 MDI_PI_UNLOCK(pip); 3755 3756 if (client_held) { 3757 MDI_CLIENT_LOCK(ct); 3758 if (ct->ct_power_cnt == 0) { 3759 rv = i_mdi_power_all_phci(ct); 3760 } 3761 3762 MDI_DEBUG(4, (MDI_NOTE, ct->ct_dip, 3763 "i_mdi_pm_hold_client %p", (void *)ct)); 3764 i_mdi_pm_hold_client(ct, 1); 3765 MDI_CLIENT_UNLOCK(ct); 3766 } 3767 3768 return (rv); 3769 } 3770 3771 /* 3772 * mdi_pi_standby(): 3773 * Place the mdi_pathinfo node in standby state 3774 * 3775 * Return Values: 3776 * MDI_SUCCESS 3777 * MDI_FAILURE 3778 */ 3779 int 3780 mdi_pi_standby(mdi_pathinfo_t *pip, int flags) 3781 { 3782 return (i_mdi_pi_state_change(pip, MDI_PATHINFO_STATE_STANDBY, flags)); 3783 } 3784 3785 /* 3786 * mdi_pi_fault(): 3787 * Place the mdi_pathinfo node in fault'ed state 3788 * Return Values: 3789 * MDI_SUCCESS 3790 * MDI_FAILURE 3791 */ 3792 int 3793 mdi_pi_fault(mdi_pathinfo_t *pip, int flags) 3794 { 3795 return (i_mdi_pi_state_change(pip, MDI_PATHINFO_STATE_FAULT, flags)); 3796 } 3797 3798 /* 3799 * mdi_pi_offline(): 3800 * Offline a mdi_pathinfo node. 3801 * Return Values: 3802 * MDI_SUCCESS 3803 * MDI_FAILURE 3804 */ 3805 int 3806 mdi_pi_offline(mdi_pathinfo_t *pip, int flags) 3807 { 3808 int ret, client_held = 0; 3809 mdi_client_t *ct; 3810 3811 /* 3812 * Original code overloaded NDI_DEVI_REMOVE to this interface, and 3813 * used it to mean "user initiated operation" (i.e. devctl). Callers 3814 * should now just use NDI_USER_REQ. 3815 */ 3816 if (flags & NDI_DEVI_REMOVE) { 3817 flags &= ~NDI_DEVI_REMOVE; 3818 flags |= NDI_USER_REQ; 3819 } 3820 3821 ret = i_mdi_pi_state_change(pip, MDI_PATHINFO_STATE_OFFLINE, flags); 3822 3823 if (ret == MDI_SUCCESS) { 3824 MDI_PI_LOCK(pip); 3825 if (MDI_PI(pip)->pi_pm_held) { 3826 client_held = 1; 3827 } 3828 MDI_PI_UNLOCK(pip); 3829 3830 if (client_held) { 3831 ct = MDI_PI(pip)->pi_client; 3832 MDI_CLIENT_LOCK(ct); 3833 MDI_DEBUG(4, (MDI_NOTE, ct->ct_dip, 3834 "i_mdi_pm_rele_client\n")); 3835 i_mdi_pm_rele_client(ct, 1); 3836 MDI_CLIENT_UNLOCK(ct); 3837 } 3838 } 3839 3840 return (ret); 3841 } 3842 3843 /* 3844 * i_mdi_pi_offline(): 3845 * Offline a mdi_pathinfo node and call the vHCI driver's callback 3846 */ 3847 static int 3848 i_mdi_pi_offline(mdi_pathinfo_t *pip, int flags) 3849 { 3850 dev_info_t *vdip = NULL; 3851 mdi_vhci_t *vh = NULL; 3852 mdi_client_t *ct = NULL; 3853 int (*f)(); 3854 int rv; 3855 3856 MDI_PI_LOCK(pip); 3857 ct = MDI_PI(pip)->pi_client; 3858 ASSERT(ct != NULL); 3859 3860 while (MDI_PI(pip)->pi_ref_cnt != 0) { 3861 /* 3862 * Give a chance for pending I/Os to complete. 3863 */ 3864 MDI_DEBUG(1, (MDI_NOTE, ct->ct_dip, 3865 "!%d cmds still pending on path %s %p", 3866 MDI_PI(pip)->pi_ref_cnt, mdi_pi_spathname(pip), 3867 (void *)pip)); 3868 if (cv_reltimedwait(&MDI_PI(pip)->pi_ref_cv, 3869 &MDI_PI(pip)->pi_mutex, drv_usectohz(60 * 1000000), 3870 TR_CLOCK_TICK) == -1) { 3871 /* 3872 * The timeout time reached without ref_cnt being zero 3873 * being signaled. 3874 */ 3875 MDI_DEBUG(1, (MDI_NOTE, ct->ct_dip, 3876 "!Timeout reached on path %s %p without the cond", 3877 mdi_pi_spathname(pip), (void *)pip)); 3878 MDI_DEBUG(1, (MDI_NOTE, ct->ct_dip, 3879 "!%d cmds still pending on path %s %p", 3880 MDI_PI(pip)->pi_ref_cnt, 3881 mdi_pi_spathname(pip), (void *)pip)); 3882 } 3883 } 3884 vh = ct->ct_vhci; 3885 vdip = vh->vh_dip; 3886 3887 /* 3888 * Notify vHCI that has registered this event 3889 */ 3890 ASSERT(vh->vh_ops); 3891 f = vh->vh_ops->vo_pi_state_change; 3892 3893 if (f != NULL) { 3894 MDI_PI_UNLOCK(pip); 3895 if ((rv = (*f)(vdip, pip, MDI_PATHINFO_STATE_OFFLINE, 0, 3896 flags)) != MDI_SUCCESS) { 3897 MDI_DEBUG(1, (MDI_WARN, ct->ct_dip, 3898 "!vo_path_offline failed: vdip %s%d %p: path %s %p", 3899 ddi_driver_name(vdip), ddi_get_instance(vdip), 3900 (void *)vdip, mdi_pi_spathname(pip), (void *)pip)); 3901 } 3902 MDI_PI_LOCK(pip); 3903 } 3904 3905 /* 3906 * Set the mdi_pathinfo node state and clear the transient condition 3907 */ 3908 MDI_PI_SET_OFFLINE(pip); 3909 cv_broadcast(&MDI_PI(pip)->pi_state_cv); 3910 MDI_PI_UNLOCK(pip); 3911 3912 MDI_CLIENT_LOCK(ct); 3913 if (rv == MDI_SUCCESS) { 3914 if (ct->ct_unstable == 0) { 3915 dev_info_t *cdip = ct->ct_dip; 3916 3917 /* 3918 * Onlining the mdi_pathinfo node will impact the 3919 * client state Update the client and dev_info node 3920 * state accordingly 3921 */ 3922 i_mdi_client_update_state(ct); 3923 rv = NDI_SUCCESS; 3924 if (MDI_CLIENT_STATE(ct) == MDI_CLIENT_STATE_FAILED) { 3925 if (cdip && 3926 (i_ddi_node_state(cdip) >= 3927 DS_INITIALIZED)) { 3928 MDI_CLIENT_UNLOCK(ct); 3929 rv = ndi_devi_offline(cdip, 3930 NDI_DEVFS_CLEAN); 3931 MDI_CLIENT_LOCK(ct); 3932 if (rv != NDI_SUCCESS) { 3933 /* 3934 * ndi_devi_offline failed. 3935 * Reset client flags to 3936 * online. 3937 */ 3938 MDI_DEBUG(4, (MDI_WARN, cdip, 3939 "ndi_devi_offline failed: " 3940 "error %x", rv)); 3941 MDI_CLIENT_SET_ONLINE(ct); 3942 } 3943 } 3944 } 3945 /* 3946 * Convert to MDI error code 3947 */ 3948 switch (rv) { 3949 case NDI_SUCCESS: 3950 rv = MDI_SUCCESS; 3951 break; 3952 case NDI_BUSY: 3953 rv = MDI_BUSY; 3954 break; 3955 default: 3956 rv = MDI_FAILURE; 3957 break; 3958 } 3959 } 3960 MDI_CLIENT_SET_REPORT_DEV_NEEDED(ct); 3961 i_mdi_report_path_state(ct, pip); 3962 } 3963 3964 MDI_CLIENT_UNLOCK(ct); 3965 3966 /* 3967 * Change in the mdi_pathinfo node state will impact the client state 3968 */ 3969 MDI_DEBUG(2, (MDI_NOTE, ct->ct_dip, 3970 "ct = %p pip = %p", (void *)ct, (void *)pip)); 3971 return (rv); 3972 } 3973 3974 /* 3975 * i_mdi_pi_online(): 3976 * Online a mdi_pathinfo node and call the vHCI driver's callback 3977 */ 3978 static int 3979 i_mdi_pi_online(mdi_pathinfo_t *pip, int flags) 3980 { 3981 mdi_vhci_t *vh = NULL; 3982 mdi_client_t *ct = NULL; 3983 mdi_phci_t *ph; 3984 int (*f)(); 3985 int rv; 3986 3987 MDI_PI_LOCK(pip); 3988 ph = MDI_PI(pip)->pi_phci; 3989 vh = ph->ph_vhci; 3990 ct = MDI_PI(pip)->pi_client; 3991 MDI_PI_SET_ONLINING(pip) 3992 MDI_PI_UNLOCK(pip); 3993 f = vh->vh_ops->vo_pi_state_change; 3994 if (f != NULL) 3995 rv = (*f)(vh->vh_dip, pip, MDI_PATHINFO_STATE_ONLINE, 0, 3996 flags); 3997 MDI_CLIENT_LOCK(ct); 3998 MDI_PI_LOCK(pip); 3999 cv_broadcast(&MDI_PI(pip)->pi_state_cv); 4000 MDI_PI_UNLOCK(pip); 4001 if (rv == MDI_SUCCESS) { 4002 dev_info_t *cdip = ct->ct_dip; 4003 4004 rv = MDI_SUCCESS; 4005 i_mdi_client_update_state(ct); 4006 if (MDI_CLIENT_STATE(ct) == MDI_CLIENT_STATE_OPTIMAL || 4007 MDI_CLIENT_STATE(ct) == MDI_CLIENT_STATE_DEGRADED) { 4008 if (cdip && !i_ddi_devi_attached(cdip)) { 4009 MDI_CLIENT_UNLOCK(ct); 4010 rv = ndi_devi_online(cdip, 0); 4011 MDI_CLIENT_LOCK(ct); 4012 if ((rv != NDI_SUCCESS) && 4013 (MDI_CLIENT_STATE(ct) == 4014 MDI_CLIENT_STATE_DEGRADED)) { 4015 MDI_CLIENT_SET_OFFLINE(ct); 4016 } 4017 if (rv != NDI_SUCCESS) { 4018 /* Reset the path state */ 4019 MDI_PI_LOCK(pip); 4020 MDI_PI(pip)->pi_state = 4021 MDI_PI_OLD_STATE(pip); 4022 MDI_PI_UNLOCK(pip); 4023 } 4024 } 4025 } 4026 switch (rv) { 4027 case NDI_SUCCESS: 4028 MDI_CLIENT_SET_REPORT_DEV_NEEDED(ct); 4029 i_mdi_report_path_state(ct, pip); 4030 rv = MDI_SUCCESS; 4031 break; 4032 case NDI_BUSY: 4033 rv = MDI_BUSY; 4034 break; 4035 default: 4036 rv = MDI_FAILURE; 4037 break; 4038 } 4039 } else { 4040 /* Reset the path state */ 4041 MDI_PI_LOCK(pip); 4042 MDI_PI(pip)->pi_state = MDI_PI_OLD_STATE(pip); 4043 MDI_PI_UNLOCK(pip); 4044 } 4045 MDI_CLIENT_UNLOCK(ct); 4046 return (rv); 4047 } 4048 4049 /* 4050 * mdi_pi_get_node_name(): 4051 * Get the name associated with a mdi_pathinfo node. 4052 * Since pathinfo nodes are not directly named, we 4053 * return the node_name of the client. 4054 * 4055 * Return Values: 4056 * char * 4057 */ 4058 char * 4059 mdi_pi_get_node_name(mdi_pathinfo_t *pip) 4060 { 4061 mdi_client_t *ct; 4062 4063 if (pip == NULL) 4064 return (NULL); 4065 ct = MDI_PI(pip)->pi_client; 4066 if ((ct == NULL) || (ct->ct_dip == NULL)) 4067 return (NULL); 4068 return (ddi_node_name(ct->ct_dip)); 4069 } 4070 4071 /* 4072 * mdi_pi_get_addr(): 4073 * Get the unit address associated with a mdi_pathinfo node 4074 * 4075 * Return Values: 4076 * char * 4077 */ 4078 char * 4079 mdi_pi_get_addr(mdi_pathinfo_t *pip) 4080 { 4081 if (pip == NULL) 4082 return (NULL); 4083 4084 return (MDI_PI(pip)->pi_addr); 4085 } 4086 4087 /* 4088 * mdi_pi_get_path_instance(): 4089 * Get the 'path_instance' of a mdi_pathinfo node 4090 * 4091 * Return Values: 4092 * path_instance 4093 */ 4094 int 4095 mdi_pi_get_path_instance(mdi_pathinfo_t *pip) 4096 { 4097 if (pip == NULL) 4098 return (0); 4099 4100 return (MDI_PI(pip)->pi_path_instance); 4101 } 4102 4103 /* 4104 * mdi_pi_pathname(): 4105 * Return pointer to path to pathinfo node. 4106 */ 4107 char * 4108 mdi_pi_pathname(mdi_pathinfo_t *pip) 4109 { 4110 if (pip == NULL) 4111 return (NULL); 4112 return (mdi_pi_pathname_by_instance(mdi_pi_get_path_instance(pip))); 4113 } 4114 4115 /* 4116 * mdi_pi_spathname(): 4117 * Return pointer to shortpath to pathinfo node. Used for debug 4118 * messages, so return "" instead of NULL when unknown. 4119 */ 4120 char * 4121 mdi_pi_spathname(mdi_pathinfo_t *pip) 4122 { 4123 char *spath = ""; 4124 4125 if (pip) { 4126 spath = mdi_pi_spathname_by_instance( 4127 mdi_pi_get_path_instance(pip)); 4128 if (spath == NULL) 4129 spath = ""; 4130 } 4131 return (spath); 4132 } 4133 4134 char * 4135 mdi_pi_pathname_obp(mdi_pathinfo_t *pip, char *path) 4136 { 4137 char *obp_path = NULL; 4138 if ((pip == NULL) || (path == NULL)) 4139 return (NULL); 4140 4141 if (mdi_prop_lookup_string(pip, "obp-path", &obp_path) == MDI_SUCCESS) { 4142 (void) strcpy(path, obp_path); 4143 (void) mdi_prop_free(obp_path); 4144 } else { 4145 path = NULL; 4146 } 4147 return (path); 4148 } 4149 4150 int 4151 mdi_pi_pathname_obp_set(mdi_pathinfo_t *pip, char *component) 4152 { 4153 dev_info_t *pdip; 4154 char *obp_path = NULL; 4155 int rc = MDI_FAILURE; 4156 4157 if (pip == NULL) 4158 return (MDI_FAILURE); 4159 4160 pdip = mdi_pi_get_phci(pip); 4161 if (pdip == NULL) 4162 return (MDI_FAILURE); 4163 4164 obp_path = kmem_zalloc(MAXPATHLEN, KM_SLEEP); 4165 4166 if (ddi_pathname_obp(pdip, obp_path) == NULL) { 4167 (void) ddi_pathname(pdip, obp_path); 4168 } 4169 4170 if (component) { 4171 (void) strncat(obp_path, "/", MAXPATHLEN); 4172 (void) strncat(obp_path, component, MAXPATHLEN); 4173 } 4174 rc = mdi_prop_update_string(pip, "obp-path", obp_path); 4175 4176 if (obp_path) 4177 kmem_free(obp_path, MAXPATHLEN); 4178 return (rc); 4179 } 4180 4181 /* 4182 * mdi_pi_get_client(): 4183 * Get the client devinfo associated with a mdi_pathinfo node 4184 * 4185 * Return Values: 4186 * Handle to client device dev_info node 4187 */ 4188 dev_info_t * 4189 mdi_pi_get_client(mdi_pathinfo_t *pip) 4190 { 4191 dev_info_t *dip = NULL; 4192 if (pip) { 4193 dip = MDI_PI(pip)->pi_client->ct_dip; 4194 } 4195 return (dip); 4196 } 4197 4198 /* 4199 * mdi_pi_get_phci(): 4200 * Get the pHCI devinfo associated with the mdi_pathinfo node 4201 * Return Values: 4202 * Handle to dev_info node 4203 */ 4204 dev_info_t * 4205 mdi_pi_get_phci(mdi_pathinfo_t *pip) 4206 { 4207 dev_info_t *dip = NULL; 4208 mdi_phci_t *ph; 4209 4210 if (pip) { 4211 ph = MDI_PI(pip)->pi_phci; 4212 if (ph) 4213 dip = ph->ph_dip; 4214 } 4215 return (dip); 4216 } 4217 4218 /* 4219 * mdi_pi_get_client_private(): 4220 * Get the client private information associated with the 4221 * mdi_pathinfo node 4222 */ 4223 void * 4224 mdi_pi_get_client_private(mdi_pathinfo_t *pip) 4225 { 4226 void *cprivate = NULL; 4227 if (pip) { 4228 cprivate = MDI_PI(pip)->pi_cprivate; 4229 } 4230 return (cprivate); 4231 } 4232 4233 /* 4234 * mdi_pi_set_client_private(): 4235 * Set the client private information in the mdi_pathinfo node 4236 */ 4237 void 4238 mdi_pi_set_client_private(mdi_pathinfo_t *pip, void *priv) 4239 { 4240 if (pip) { 4241 MDI_PI(pip)->pi_cprivate = priv; 4242 } 4243 } 4244 4245 /* 4246 * mdi_pi_get_phci_private(): 4247 * Get the pHCI private information associated with the 4248 * mdi_pathinfo node 4249 */ 4250 caddr_t 4251 mdi_pi_get_phci_private(mdi_pathinfo_t *pip) 4252 { 4253 caddr_t pprivate = NULL; 4254 4255 if (pip) { 4256 pprivate = MDI_PI(pip)->pi_pprivate; 4257 } 4258 return (pprivate); 4259 } 4260 4261 /* 4262 * mdi_pi_set_phci_private(): 4263 * Set the pHCI private information in the mdi_pathinfo node 4264 */ 4265 void 4266 mdi_pi_set_phci_private(mdi_pathinfo_t *pip, caddr_t priv) 4267 { 4268 if (pip) { 4269 MDI_PI(pip)->pi_pprivate = priv; 4270 } 4271 } 4272 4273 /* 4274 * mdi_pi_get_state(): 4275 * Get the mdi_pathinfo node state. Transient states are internal 4276 * and not provided to the users 4277 */ 4278 mdi_pathinfo_state_t 4279 mdi_pi_get_state(mdi_pathinfo_t *pip) 4280 { 4281 mdi_pathinfo_state_t state = MDI_PATHINFO_STATE_INIT; 4282 4283 if (pip) { 4284 if (MDI_PI_IS_TRANSIENT(pip)) { 4285 /* 4286 * mdi_pathinfo is in state transition. Return the 4287 * last good state. 4288 */ 4289 state = MDI_PI_OLD_STATE(pip); 4290 } else { 4291 state = MDI_PI_STATE(pip); 4292 } 4293 } 4294 return (state); 4295 } 4296 4297 /* 4298 * mdi_pi_get_flags(): 4299 * Get the mdi_pathinfo node flags. 4300 */ 4301 uint_t 4302 mdi_pi_get_flags(mdi_pathinfo_t *pip) 4303 { 4304 return (pip ? MDI_PI(pip)->pi_flags : 0); 4305 } 4306 4307 /* 4308 * Note that the following function needs to be the new interface for 4309 * mdi_pi_get_state when mpxio gets integrated to ON. 4310 */ 4311 int 4312 mdi_pi_get_state2(mdi_pathinfo_t *pip, mdi_pathinfo_state_t *state, 4313 uint32_t *ext_state) 4314 { 4315 *state = MDI_PATHINFO_STATE_INIT; 4316 4317 if (pip) { 4318 if (MDI_PI_IS_TRANSIENT(pip)) { 4319 /* 4320 * mdi_pathinfo is in state transition. Return the 4321 * last good state. 4322 */ 4323 *state = MDI_PI_OLD_STATE(pip); 4324 *ext_state = MDI_PI_OLD_EXT_STATE(pip); 4325 } else { 4326 *state = MDI_PI_STATE(pip); 4327 *ext_state = MDI_PI_EXT_STATE(pip); 4328 } 4329 } 4330 return (MDI_SUCCESS); 4331 } 4332 4333 /* 4334 * mdi_pi_get_preferred: 4335 * Get the preferred path flag 4336 */ 4337 int 4338 mdi_pi_get_preferred(mdi_pathinfo_t *pip) 4339 { 4340 if (pip) { 4341 return (MDI_PI(pip)->pi_preferred); 4342 } 4343 return (0); 4344 } 4345 4346 /* 4347 * mdi_pi_set_preferred: 4348 * Set the preferred path flag 4349 */ 4350 void 4351 mdi_pi_set_preferred(mdi_pathinfo_t *pip, int preferred) 4352 { 4353 if (pip) { 4354 MDI_PI(pip)->pi_preferred = preferred; 4355 } 4356 } 4357 4358 /* 4359 * mdi_pi_set_state(): 4360 * Set the mdi_pathinfo node state 4361 */ 4362 void 4363 mdi_pi_set_state(mdi_pathinfo_t *pip, mdi_pathinfo_state_t state) 4364 { 4365 uint32_t ext_state; 4366 4367 if (pip) { 4368 ext_state = MDI_PI(pip)->pi_state & MDI_PATHINFO_EXT_STATE_MASK; 4369 MDI_PI(pip)->pi_state = state; 4370 MDI_PI(pip)->pi_state |= ext_state; 4371 4372 /* Path has changed state, invalidate DINFOCACHE snap shot. */ 4373 i_ddi_di_cache_invalidate(); 4374 } 4375 } 4376 4377 /* 4378 * Property functions: 4379 */ 4380 int 4381 i_map_nvlist_error_to_mdi(int val) 4382 { 4383 int rv; 4384 4385 switch (val) { 4386 case 0: 4387 rv = DDI_PROP_SUCCESS; 4388 break; 4389 case EINVAL: 4390 case ENOTSUP: 4391 rv = DDI_PROP_INVAL_ARG; 4392 break; 4393 case ENOMEM: 4394 rv = DDI_PROP_NO_MEMORY; 4395 break; 4396 default: 4397 rv = DDI_PROP_NOT_FOUND; 4398 break; 4399 } 4400 return (rv); 4401 } 4402 4403 /* 4404 * mdi_pi_get_next_prop(): 4405 * Property walk function. The caller should hold mdi_pi_lock() 4406 * and release by calling mdi_pi_unlock() at the end of walk to 4407 * get a consistent value. 4408 */ 4409 nvpair_t * 4410 mdi_pi_get_next_prop(mdi_pathinfo_t *pip, nvpair_t *prev) 4411 { 4412 if ((pip == NULL) || (MDI_PI(pip)->pi_prop == NULL)) { 4413 return (NULL); 4414 } 4415 ASSERT(MDI_PI_LOCKED(pip)); 4416 return (nvlist_next_nvpair(MDI_PI(pip)->pi_prop, prev)); 4417 } 4418 4419 /* 4420 * mdi_prop_remove(): 4421 * Remove the named property from the named list. 4422 */ 4423 int 4424 mdi_prop_remove(mdi_pathinfo_t *pip, char *name) 4425 { 4426 if (pip == NULL) { 4427 return (DDI_PROP_NOT_FOUND); 4428 } 4429 ASSERT(!MDI_PI_LOCKED(pip)); 4430 MDI_PI_LOCK(pip); 4431 if (MDI_PI(pip)->pi_prop == NULL) { 4432 MDI_PI_UNLOCK(pip); 4433 return (DDI_PROP_NOT_FOUND); 4434 } 4435 if (name) { 4436 (void) nvlist_remove_all(MDI_PI(pip)->pi_prop, name); 4437 } else { 4438 char nvp_name[MAXNAMELEN]; 4439 nvpair_t *nvp; 4440 nvp = nvlist_next_nvpair(MDI_PI(pip)->pi_prop, NULL); 4441 while (nvp) { 4442 nvpair_t *next; 4443 next = nvlist_next_nvpair(MDI_PI(pip)->pi_prop, nvp); 4444 (void) snprintf(nvp_name, sizeof(nvp_name), "%s", 4445 nvpair_name(nvp)); 4446 (void) nvlist_remove_all(MDI_PI(pip)->pi_prop, 4447 nvp_name); 4448 nvp = next; 4449 } 4450 } 4451 MDI_PI_UNLOCK(pip); 4452 return (DDI_PROP_SUCCESS); 4453 } 4454 4455 /* 4456 * mdi_prop_size(): 4457 * Get buffer size needed to pack the property data. 4458 * Caller should hold the mdi_pathinfo_t lock to get a consistent 4459 * buffer size. 4460 */ 4461 int 4462 mdi_prop_size(mdi_pathinfo_t *pip, size_t *buflenp) 4463 { 4464 int rv; 4465 size_t bufsize; 4466 4467 *buflenp = 0; 4468 if ((pip == NULL) || (MDI_PI(pip)->pi_prop == NULL)) { 4469 return (DDI_PROP_NOT_FOUND); 4470 } 4471 ASSERT(MDI_PI_LOCKED(pip)); 4472 rv = nvlist_size(MDI_PI(pip)->pi_prop, 4473 &bufsize, NV_ENCODE_NATIVE); 4474 *buflenp = bufsize; 4475 return (i_map_nvlist_error_to_mdi(rv)); 4476 } 4477 4478 /* 4479 * mdi_prop_pack(): 4480 * pack the property list. The caller should hold the 4481 * mdi_pathinfo_t node to get a consistent data 4482 */ 4483 int 4484 mdi_prop_pack(mdi_pathinfo_t *pip, char **bufp, uint_t buflen) 4485 { 4486 int rv; 4487 size_t bufsize; 4488 4489 if ((pip == NULL) || MDI_PI(pip)->pi_prop == NULL) { 4490 return (DDI_PROP_NOT_FOUND); 4491 } 4492 4493 ASSERT(MDI_PI_LOCKED(pip)); 4494 4495 bufsize = buflen; 4496 rv = nvlist_pack(MDI_PI(pip)->pi_prop, bufp, (size_t *)&bufsize, 4497 NV_ENCODE_NATIVE, KM_SLEEP); 4498 4499 return (i_map_nvlist_error_to_mdi(rv)); 4500 } 4501 4502 /* 4503 * mdi_prop_update_byte(): 4504 * Create/Update a byte property 4505 */ 4506 int 4507 mdi_prop_update_byte(mdi_pathinfo_t *pip, char *name, uchar_t data) 4508 { 4509 int rv; 4510 4511 if (pip == NULL) { 4512 return (DDI_PROP_INVAL_ARG); 4513 } 4514 ASSERT(!MDI_PI_LOCKED(pip)); 4515 MDI_PI_LOCK(pip); 4516 if (MDI_PI(pip)->pi_prop == NULL) { 4517 MDI_PI_UNLOCK(pip); 4518 return (DDI_PROP_NOT_FOUND); 4519 } 4520 rv = nvlist_add_byte(MDI_PI(pip)->pi_prop, name, data); 4521 MDI_PI_UNLOCK(pip); 4522 return (i_map_nvlist_error_to_mdi(rv)); 4523 } 4524 4525 /* 4526 * mdi_prop_update_byte_array(): 4527 * Create/Update a byte array property 4528 */ 4529 int 4530 mdi_prop_update_byte_array(mdi_pathinfo_t *pip, char *name, uchar_t *data, 4531 uint_t nelements) 4532 { 4533 int rv; 4534 4535 if (pip == NULL) { 4536 return (DDI_PROP_INVAL_ARG); 4537 } 4538 ASSERT(!MDI_PI_LOCKED(pip)); 4539 MDI_PI_LOCK(pip); 4540 if (MDI_PI(pip)->pi_prop == NULL) { 4541 MDI_PI_UNLOCK(pip); 4542 return (DDI_PROP_NOT_FOUND); 4543 } 4544 rv = nvlist_add_byte_array(MDI_PI(pip)->pi_prop, name, data, nelements); 4545 MDI_PI_UNLOCK(pip); 4546 return (i_map_nvlist_error_to_mdi(rv)); 4547 } 4548 4549 /* 4550 * mdi_prop_update_int(): 4551 * Create/Update a 32 bit integer property 4552 */ 4553 int 4554 mdi_prop_update_int(mdi_pathinfo_t *pip, char *name, int data) 4555 { 4556 int rv; 4557 4558 if (pip == NULL) { 4559 return (DDI_PROP_INVAL_ARG); 4560 } 4561 ASSERT(!MDI_PI_LOCKED(pip)); 4562 MDI_PI_LOCK(pip); 4563 if (MDI_PI(pip)->pi_prop == NULL) { 4564 MDI_PI_UNLOCK(pip); 4565 return (DDI_PROP_NOT_FOUND); 4566 } 4567 rv = nvlist_add_int32(MDI_PI(pip)->pi_prop, name, (int32_t)data); 4568 MDI_PI_UNLOCK(pip); 4569 return (i_map_nvlist_error_to_mdi(rv)); 4570 } 4571 4572 /* 4573 * mdi_prop_update_int64(): 4574 * Create/Update a 64 bit integer property 4575 */ 4576 int 4577 mdi_prop_update_int64(mdi_pathinfo_t *pip, char *name, int64_t data) 4578 { 4579 int rv; 4580 4581 if (pip == NULL) { 4582 return (DDI_PROP_INVAL_ARG); 4583 } 4584 ASSERT(!MDI_PI_LOCKED(pip)); 4585 MDI_PI_LOCK(pip); 4586 if (MDI_PI(pip)->pi_prop == NULL) { 4587 MDI_PI_UNLOCK(pip); 4588 return (DDI_PROP_NOT_FOUND); 4589 } 4590 rv = nvlist_add_int64(MDI_PI(pip)->pi_prop, name, data); 4591 MDI_PI_UNLOCK(pip); 4592 return (i_map_nvlist_error_to_mdi(rv)); 4593 } 4594 4595 /* 4596 * mdi_prop_update_int_array(): 4597 * Create/Update a int array property 4598 */ 4599 int 4600 mdi_prop_update_int_array(mdi_pathinfo_t *pip, char *name, int *data, 4601 uint_t nelements) 4602 { 4603 int rv; 4604 4605 if (pip == NULL) { 4606 return (DDI_PROP_INVAL_ARG); 4607 } 4608 ASSERT(!MDI_PI_LOCKED(pip)); 4609 MDI_PI_LOCK(pip); 4610 if (MDI_PI(pip)->pi_prop == NULL) { 4611 MDI_PI_UNLOCK(pip); 4612 return (DDI_PROP_NOT_FOUND); 4613 } 4614 rv = nvlist_add_int32_array(MDI_PI(pip)->pi_prop, name, (int32_t *)data, 4615 nelements); 4616 MDI_PI_UNLOCK(pip); 4617 return (i_map_nvlist_error_to_mdi(rv)); 4618 } 4619 4620 /* 4621 * mdi_prop_update_string(): 4622 * Create/Update a string property 4623 */ 4624 int 4625 mdi_prop_update_string(mdi_pathinfo_t *pip, char *name, char *data) 4626 { 4627 int rv; 4628 4629 if (pip == NULL) { 4630 return (DDI_PROP_INVAL_ARG); 4631 } 4632 ASSERT(!MDI_PI_LOCKED(pip)); 4633 MDI_PI_LOCK(pip); 4634 if (MDI_PI(pip)->pi_prop == NULL) { 4635 MDI_PI_UNLOCK(pip); 4636 return (DDI_PROP_NOT_FOUND); 4637 } 4638 rv = nvlist_add_string(MDI_PI(pip)->pi_prop, name, data); 4639 MDI_PI_UNLOCK(pip); 4640 return (i_map_nvlist_error_to_mdi(rv)); 4641 } 4642 4643 /* 4644 * mdi_prop_update_string_array(): 4645 * Create/Update a string array property 4646 */ 4647 int 4648 mdi_prop_update_string_array(mdi_pathinfo_t *pip, char *name, char **data, 4649 uint_t nelements) 4650 { 4651 int rv; 4652 4653 if (pip == NULL) { 4654 return (DDI_PROP_INVAL_ARG); 4655 } 4656 ASSERT(!MDI_PI_LOCKED(pip)); 4657 MDI_PI_LOCK(pip); 4658 if (MDI_PI(pip)->pi_prop == NULL) { 4659 MDI_PI_UNLOCK(pip); 4660 return (DDI_PROP_NOT_FOUND); 4661 } 4662 rv = nvlist_add_string_array(MDI_PI(pip)->pi_prop, name, data, 4663 nelements); 4664 MDI_PI_UNLOCK(pip); 4665 return (i_map_nvlist_error_to_mdi(rv)); 4666 } 4667 4668 /* 4669 * mdi_prop_lookup_byte(): 4670 * Look for byte property identified by name. The data returned 4671 * is the actual property and valid as long as mdi_pathinfo_t node 4672 * is alive. 4673 */ 4674 int 4675 mdi_prop_lookup_byte(mdi_pathinfo_t *pip, char *name, uchar_t *data) 4676 { 4677 int rv; 4678 4679 if ((pip == NULL) || (MDI_PI(pip)->pi_prop == NULL)) { 4680 return (DDI_PROP_NOT_FOUND); 4681 } 4682 rv = nvlist_lookup_byte(MDI_PI(pip)->pi_prop, name, data); 4683 return (i_map_nvlist_error_to_mdi(rv)); 4684 } 4685 4686 4687 /* 4688 * mdi_prop_lookup_byte_array(): 4689 * Look for byte array property identified by name. The data 4690 * returned is the actual property and valid as long as 4691 * mdi_pathinfo_t node is alive. 4692 */ 4693 int 4694 mdi_prop_lookup_byte_array(mdi_pathinfo_t *pip, char *name, uchar_t **data, 4695 uint_t *nelements) 4696 { 4697 int rv; 4698 4699 if ((pip == NULL) || (MDI_PI(pip)->pi_prop == NULL)) { 4700 return (DDI_PROP_NOT_FOUND); 4701 } 4702 rv = nvlist_lookup_byte_array(MDI_PI(pip)->pi_prop, name, data, 4703 nelements); 4704 return (i_map_nvlist_error_to_mdi(rv)); 4705 } 4706 4707 /* 4708 * mdi_prop_lookup_int(): 4709 * Look for int property identified by name. The data returned 4710 * is the actual property and valid as long as mdi_pathinfo_t 4711 * node is alive. 4712 */ 4713 int 4714 mdi_prop_lookup_int(mdi_pathinfo_t *pip, char *name, int *data) 4715 { 4716 int rv; 4717 4718 if ((pip == NULL) || (MDI_PI(pip)->pi_prop == NULL)) { 4719 return (DDI_PROP_NOT_FOUND); 4720 } 4721 rv = nvlist_lookup_int32(MDI_PI(pip)->pi_prop, name, (int32_t *)data); 4722 return (i_map_nvlist_error_to_mdi(rv)); 4723 } 4724 4725 /* 4726 * mdi_prop_lookup_int64(): 4727 * Look for int64 property identified by name. The data returned 4728 * is the actual property and valid as long as mdi_pathinfo_t node 4729 * is alive. 4730 */ 4731 int 4732 mdi_prop_lookup_int64(mdi_pathinfo_t *pip, char *name, int64_t *data) 4733 { 4734 int rv; 4735 if ((pip == NULL) || (MDI_PI(pip)->pi_prop == NULL)) { 4736 return (DDI_PROP_NOT_FOUND); 4737 } 4738 rv = nvlist_lookup_int64(MDI_PI(pip)->pi_prop, name, data); 4739 return (i_map_nvlist_error_to_mdi(rv)); 4740 } 4741 4742 /* 4743 * mdi_prop_lookup_int_array(): 4744 * Look for int array property identified by name. The data 4745 * returned is the actual property and valid as long as 4746 * mdi_pathinfo_t node is alive. 4747 */ 4748 int 4749 mdi_prop_lookup_int_array(mdi_pathinfo_t *pip, char *name, int **data, 4750 uint_t *nelements) 4751 { 4752 int rv; 4753 4754 if ((pip == NULL) || (MDI_PI(pip)->pi_prop == NULL)) { 4755 return (DDI_PROP_NOT_FOUND); 4756 } 4757 rv = nvlist_lookup_int32_array(MDI_PI(pip)->pi_prop, name, 4758 (int32_t **)data, nelements); 4759 return (i_map_nvlist_error_to_mdi(rv)); 4760 } 4761 4762 /* 4763 * mdi_prop_lookup_string(): 4764 * Look for string property identified by name. The data 4765 * returned is the actual property and valid as long as 4766 * mdi_pathinfo_t node is alive. 4767 */ 4768 int 4769 mdi_prop_lookup_string(mdi_pathinfo_t *pip, char *name, char **data) 4770 { 4771 int rv; 4772 4773 if ((pip == NULL) || (MDI_PI(pip)->pi_prop == NULL)) { 4774 return (DDI_PROP_NOT_FOUND); 4775 } 4776 rv = nvlist_lookup_string(MDI_PI(pip)->pi_prop, name, data); 4777 return (i_map_nvlist_error_to_mdi(rv)); 4778 } 4779 4780 /* 4781 * mdi_prop_lookup_string_array(): 4782 * Look for string array property identified by name. The data 4783 * returned is the actual property and valid as long as 4784 * mdi_pathinfo_t node is alive. 4785 */ 4786 int 4787 mdi_prop_lookup_string_array(mdi_pathinfo_t *pip, char *name, char ***data, 4788 uint_t *nelements) 4789 { 4790 int rv; 4791 4792 if ((pip == NULL) || (MDI_PI(pip)->pi_prop == NULL)) { 4793 return (DDI_PROP_NOT_FOUND); 4794 } 4795 rv = nvlist_lookup_string_array(MDI_PI(pip)->pi_prop, name, data, 4796 nelements); 4797 return (i_map_nvlist_error_to_mdi(rv)); 4798 } 4799 4800 /* 4801 * mdi_prop_free(): 4802 * Symmetrical function to ddi_prop_free(). nvlist_lookup_xx() 4803 * functions return the pointer to actual property data and not a 4804 * copy of it. So the data returned is valid as long as 4805 * mdi_pathinfo_t node is valid. 4806 */ 4807 /*ARGSUSED*/ 4808 int 4809 mdi_prop_free(void *data) 4810 { 4811 return (DDI_PROP_SUCCESS); 4812 } 4813 4814 /*ARGSUSED*/ 4815 static void 4816 i_mdi_report_path_state(mdi_client_t *ct, mdi_pathinfo_t *pip) 4817 { 4818 char *ct_path; 4819 char *ct_status; 4820 char *status; 4821 dev_info_t *cdip = ct->ct_dip; 4822 char lb_buf[64]; 4823 int report_lb_c = 0, report_lb_p = 0; 4824 4825 ASSERT(MDI_CLIENT_LOCKED(ct)); 4826 if ((cdip == NULL) || (ddi_get_instance(cdip) == -1) || 4827 (MDI_CLIENT_IS_REPORT_DEV_NEEDED(ct) == 0)) { 4828 return; 4829 } 4830 if (MDI_CLIENT_STATE(ct) == MDI_CLIENT_STATE_OPTIMAL) { 4831 ct_status = "optimal"; 4832 report_lb_c = 1; 4833 } else if (MDI_CLIENT_STATE(ct) == MDI_CLIENT_STATE_DEGRADED) { 4834 ct_status = "degraded"; 4835 } else if (MDI_CLIENT_STATE(ct) == MDI_CLIENT_STATE_FAILED) { 4836 ct_status = "failed"; 4837 } else { 4838 ct_status = "unknown"; 4839 } 4840 4841 lb_buf[0] = 0; /* not interested in load balancing config */ 4842 4843 if (MDI_PI_FLAGS_IS_DEVICE_REMOVED(pip)) { 4844 status = "removed"; 4845 } else if (MDI_PI_IS_OFFLINE(pip)) { 4846 status = "offline"; 4847 } else if (MDI_PI_IS_ONLINE(pip)) { 4848 status = "online"; 4849 report_lb_p = 1; 4850 } else if (MDI_PI_IS_STANDBY(pip)) { 4851 status = "standby"; 4852 } else if (MDI_PI_IS_FAULT(pip)) { 4853 status = "faulted"; 4854 } else { 4855 status = "unknown"; 4856 } 4857 4858 if (cdip) { 4859 ct_path = kmem_alloc(MAXPATHLEN, KM_SLEEP); 4860 4861 /* 4862 * NOTE: Keeping "multipath status: %s" and 4863 * "Load balancing: %s" format unchanged in case someone 4864 * scrubs /var/adm/messages looking for these messages. 4865 */ 4866 if (report_lb_c && report_lb_p) { 4867 if (ct->ct_lb == LOAD_BALANCE_LBA) { 4868 (void) snprintf(lb_buf, sizeof (lb_buf), 4869 "%s, region-size: %d", mdi_load_balance_lba, 4870 ct->ct_lb_args->region_size); 4871 } else if (ct->ct_lb == LOAD_BALANCE_NONE) { 4872 (void) snprintf(lb_buf, sizeof (lb_buf), 4873 "%s", mdi_load_balance_none); 4874 } else { 4875 (void) snprintf(lb_buf, sizeof (lb_buf), "%s", 4876 mdi_load_balance_rr); 4877 } 4878 4879 cmn_err(mdi_debug_consoleonly ? CE_NOTE : CE_CONT, 4880 "?%s (%s%d) multipath status: %s: " 4881 "path %d %s is %s: Load balancing: %s\n", 4882 ddi_pathname(cdip, ct_path), ddi_driver_name(cdip), 4883 ddi_get_instance(cdip), ct_status, 4884 mdi_pi_get_path_instance(pip), 4885 mdi_pi_spathname(pip), status, lb_buf); 4886 } else { 4887 cmn_err(mdi_debug_consoleonly ? CE_NOTE : CE_CONT, 4888 "?%s (%s%d) multipath status: %s: " 4889 "path %d %s is %s\n", 4890 ddi_pathname(cdip, ct_path), ddi_driver_name(cdip), 4891 ddi_get_instance(cdip), ct_status, 4892 mdi_pi_get_path_instance(pip), 4893 mdi_pi_spathname(pip), status); 4894 } 4895 4896 kmem_free(ct_path, MAXPATHLEN); 4897 MDI_CLIENT_CLEAR_REPORT_DEV_NEEDED(ct); 4898 } 4899 } 4900 4901 #ifdef DEBUG 4902 /* 4903 * i_mdi_log(): 4904 * Utility function for error message management 4905 * 4906 * NOTE: Implementation takes care of trailing \n for cmn_err, 4907 * MDI_DEBUG should not terminate fmt strings with \n. 4908 * 4909 * NOTE: If the level is >= 2, and there is no leading !?^ 4910 * then a leading ! is implied (but can be overriden via 4911 * mdi_debug_consoleonly). If you are using kmdb on the console, 4912 * consider setting mdi_debug_consoleonly to 1 as an aid. 4913 */ 4914 /*PRINTFLIKE4*/ 4915 static void 4916 i_mdi_log(int level, const char *func, dev_info_t *dip, const char *fmt, ...) 4917 { 4918 char name[MAXNAMELEN]; 4919 char buf[512]; 4920 char *bp; 4921 va_list ap; 4922 int log_only = 0; 4923 int boot_only = 0; 4924 int console_only = 0; 4925 4926 if (dip) { 4927 (void) snprintf(name, sizeof(name), "%s%d: ", 4928 ddi_driver_name(dip), ddi_get_instance(dip)); 4929 } else { 4930 name[0] = 0; 4931 } 4932 4933 va_start(ap, fmt); 4934 (void) vsnprintf(buf, sizeof(buf), fmt, ap); 4935 va_end(ap); 4936 4937 switch (buf[0]) { 4938 case '!': 4939 bp = &buf[1]; 4940 log_only = 1; 4941 break; 4942 case '?': 4943 bp = &buf[1]; 4944 boot_only = 1; 4945 break; 4946 case '^': 4947 bp = &buf[1]; 4948 console_only = 1; 4949 break; 4950 default: 4951 if (level >= 2) 4952 log_only = 1; /* ! implied */ 4953 bp = buf; 4954 break; 4955 } 4956 if (mdi_debug_logonly) { 4957 log_only = 1; 4958 boot_only = 0; 4959 console_only = 0; 4960 } 4961 if (mdi_debug_consoleonly) { 4962 log_only = 0; 4963 boot_only = 0; 4964 console_only = 1; 4965 level = CE_NOTE; 4966 goto console; 4967 } 4968 4969 switch (level) { 4970 case CE_NOTE: 4971 level = CE_CONT; 4972 /* FALLTHROUGH */ 4973 case CE_CONT: 4974 if (boot_only) { 4975 cmn_err(level, "?mdi: %s%s: %s\n", name, func, bp); 4976 } else if (console_only) { 4977 cmn_err(level, "^mdi: %s%s: %s\n", name, func, bp); 4978 } else if (log_only) { 4979 cmn_err(level, "!mdi: %s%s: %s\n", name, func, bp); 4980 } else { 4981 cmn_err(level, "mdi: %s%s: %s\n", name, func, bp); 4982 } 4983 break; 4984 4985 case CE_WARN: 4986 case CE_PANIC: 4987 console: 4988 if (boot_only) { 4989 cmn_err(level, "?mdi: %s%s: %s", name, func, bp); 4990 } else if (console_only) { 4991 cmn_err(level, "^mdi: %s%s: %s", name, func, bp); 4992 } else if (log_only) { 4993 cmn_err(level, "!mdi: %s%s: %s", name, func, bp); 4994 } else { 4995 cmn_err(level, "mdi: %s%s: %s", name, func, bp); 4996 } 4997 break; 4998 default: 4999 cmn_err(level, "mdi: %s%s", name, bp); 5000 break; 5001 } 5002 } 5003 #endif /* DEBUG */ 5004 5005 void 5006 i_mdi_client_online(dev_info_t *ct_dip) 5007 { 5008 mdi_client_t *ct; 5009 5010 /* 5011 * Client online notification. Mark client state as online 5012 * restore our binding with dev_info node 5013 */ 5014 ct = i_devi_get_client(ct_dip); 5015 ASSERT(ct != NULL); 5016 MDI_CLIENT_LOCK(ct); 5017 MDI_CLIENT_SET_ONLINE(ct); 5018 /* catch for any memory leaks */ 5019 ASSERT((ct->ct_dip == NULL) || (ct->ct_dip == ct_dip)); 5020 ct->ct_dip = ct_dip; 5021 5022 if (ct->ct_power_cnt == 0) 5023 (void) i_mdi_power_all_phci(ct); 5024 5025 MDI_DEBUG(4, (MDI_NOTE, ct_dip, 5026 "i_mdi_pm_hold_client %p", (void *)ct)); 5027 i_mdi_pm_hold_client(ct, 1); 5028 5029 MDI_CLIENT_UNLOCK(ct); 5030 } 5031 5032 void 5033 i_mdi_phci_online(dev_info_t *ph_dip) 5034 { 5035 mdi_phci_t *ph; 5036 5037 /* pHCI online notification. Mark state accordingly */ 5038 ph = i_devi_get_phci(ph_dip); 5039 ASSERT(ph != NULL); 5040 MDI_PHCI_LOCK(ph); 5041 MDI_PHCI_SET_ONLINE(ph); 5042 MDI_PHCI_UNLOCK(ph); 5043 } 5044 5045 /* 5046 * mdi_devi_online(): 5047 * Online notification from NDI framework on pHCI/client 5048 * device online. 5049 * Return Values: 5050 * NDI_SUCCESS 5051 * MDI_FAILURE 5052 */ 5053 /*ARGSUSED*/ 5054 int 5055 mdi_devi_online(dev_info_t *dip, uint_t flags) 5056 { 5057 if (MDI_PHCI(dip)) { 5058 i_mdi_phci_online(dip); 5059 } 5060 5061 if (MDI_CLIENT(dip)) { 5062 i_mdi_client_online(dip); 5063 } 5064 return (NDI_SUCCESS); 5065 } 5066 5067 /* 5068 * mdi_devi_offline(): 5069 * Offline notification from NDI framework on pHCI/Client device 5070 * offline. 5071 * 5072 * Return Values: 5073 * NDI_SUCCESS 5074 * NDI_FAILURE 5075 */ 5076 /*ARGSUSED*/ 5077 int 5078 mdi_devi_offline(dev_info_t *dip, uint_t flags) 5079 { 5080 int rv = NDI_SUCCESS; 5081 5082 if (MDI_CLIENT(dip)) { 5083 rv = i_mdi_client_offline(dip, flags); 5084 if (rv != NDI_SUCCESS) 5085 return (rv); 5086 } 5087 5088 if (MDI_PHCI(dip)) { 5089 rv = i_mdi_phci_offline(dip, flags); 5090 5091 if ((rv != NDI_SUCCESS) && MDI_CLIENT(dip)) { 5092 /* set client back online */ 5093 i_mdi_client_online(dip); 5094 } 5095 } 5096 5097 return (rv); 5098 } 5099 5100 /*ARGSUSED*/ 5101 static int 5102 i_mdi_phci_offline(dev_info_t *dip, uint_t flags) 5103 { 5104 int rv = NDI_SUCCESS; 5105 mdi_phci_t *ph; 5106 mdi_client_t *ct; 5107 mdi_pathinfo_t *pip; 5108 mdi_pathinfo_t *next; 5109 mdi_pathinfo_t *failed_pip = NULL; 5110 dev_info_t *cdip; 5111 5112 /* 5113 * pHCI component offline notification 5114 * Make sure that this pHCI instance is free to be offlined. 5115 * If it is OK to proceed, Offline and remove all the child 5116 * mdi_pathinfo nodes. This process automatically offlines 5117 * corresponding client devices, for which this pHCI provides 5118 * critical services. 5119 */ 5120 ph = i_devi_get_phci(dip); 5121 MDI_DEBUG(2, (MDI_NOTE, dip, 5122 "called %p %p", (void *)dip, (void *)ph)); 5123 if (ph == NULL) { 5124 return (rv); 5125 } 5126 5127 MDI_PHCI_LOCK(ph); 5128 5129 if (MDI_PHCI_IS_OFFLINE(ph)) { 5130 MDI_DEBUG(1, (MDI_WARN, dip, 5131 "!pHCI already offlined: %p", (void *)dip)); 5132 MDI_PHCI_UNLOCK(ph); 5133 return (NDI_SUCCESS); 5134 } 5135 5136 /* 5137 * Check to see if the pHCI can be offlined 5138 */ 5139 if (ph->ph_unstable) { 5140 MDI_DEBUG(1, (MDI_WARN, dip, 5141 "!One or more target devices are in transient state. " 5142 "This device can not be removed at this moment. " 5143 "Please try again later.")); 5144 MDI_PHCI_UNLOCK(ph); 5145 return (NDI_BUSY); 5146 } 5147 5148 pip = ph->ph_path_head; 5149 while (pip != NULL) { 5150 MDI_PI_LOCK(pip); 5151 next = (mdi_pathinfo_t *)MDI_PI(pip)->pi_phci_link; 5152 5153 /* 5154 * The mdi_pathinfo state is OK. Check the client state. 5155 * If failover in progress fail the pHCI from offlining 5156 */ 5157 ct = MDI_PI(pip)->pi_client; 5158 i_mdi_client_lock(ct, pip); 5159 if ((MDI_CLIENT_IS_FAILOVER_IN_PROGRESS(ct)) || 5160 (ct->ct_unstable)) { 5161 /* 5162 * Failover is in progress, Fail the DR 5163 */ 5164 MDI_DEBUG(1, (MDI_WARN, dip, 5165 "!pHCI device is busy. " 5166 "This device can not be removed at this moment. " 5167 "Please try again later.")); 5168 MDI_PI_UNLOCK(pip); 5169 i_mdi_client_unlock(ct); 5170 MDI_PHCI_UNLOCK(ph); 5171 return (NDI_BUSY); 5172 } 5173 MDI_PI_UNLOCK(pip); 5174 5175 /* 5176 * Check to see of we are removing the last path of this 5177 * client device... 5178 */ 5179 cdip = ct->ct_dip; 5180 if (cdip && (i_ddi_node_state(cdip) >= DS_INITIALIZED) && 5181 (i_mdi_client_compute_state(ct, ph) == 5182 MDI_CLIENT_STATE_FAILED)) { 5183 i_mdi_client_unlock(ct); 5184 MDI_PHCI_UNLOCK(ph); 5185 if (ndi_devi_offline(cdip, 5186 NDI_DEVFS_CLEAN) != NDI_SUCCESS) { 5187 /* 5188 * ndi_devi_offline() failed. 5189 * This pHCI provides the critical path 5190 * to one or more client devices. 5191 * Return busy. 5192 */ 5193 MDI_PHCI_LOCK(ph); 5194 MDI_DEBUG(1, (MDI_WARN, dip, 5195 "!pHCI device is busy. " 5196 "This device can not be removed at this " 5197 "moment. Please try again later.")); 5198 failed_pip = pip; 5199 break; 5200 } else { 5201 MDI_PHCI_LOCK(ph); 5202 pip = next; 5203 } 5204 } else { 5205 i_mdi_client_unlock(ct); 5206 pip = next; 5207 } 5208 } 5209 5210 if (failed_pip) { 5211 pip = ph->ph_path_head; 5212 while (pip != failed_pip) { 5213 MDI_PI_LOCK(pip); 5214 next = (mdi_pathinfo_t *)MDI_PI(pip)->pi_phci_link; 5215 ct = MDI_PI(pip)->pi_client; 5216 i_mdi_client_lock(ct, pip); 5217 cdip = ct->ct_dip; 5218 switch (MDI_CLIENT_STATE(ct)) { 5219 case MDI_CLIENT_STATE_OPTIMAL: 5220 case MDI_CLIENT_STATE_DEGRADED: 5221 if (cdip) { 5222 MDI_PI_UNLOCK(pip); 5223 i_mdi_client_unlock(ct); 5224 MDI_PHCI_UNLOCK(ph); 5225 (void) ndi_devi_online(cdip, 0); 5226 MDI_PHCI_LOCK(ph); 5227 pip = next; 5228 continue; 5229 } 5230 break; 5231 5232 case MDI_CLIENT_STATE_FAILED: 5233 if (cdip) { 5234 MDI_PI_UNLOCK(pip); 5235 i_mdi_client_unlock(ct); 5236 MDI_PHCI_UNLOCK(ph); 5237 (void) ndi_devi_offline(cdip, 5238 NDI_DEVFS_CLEAN); 5239 MDI_PHCI_LOCK(ph); 5240 pip = next; 5241 continue; 5242 } 5243 break; 5244 } 5245 MDI_PI_UNLOCK(pip); 5246 i_mdi_client_unlock(ct); 5247 pip = next; 5248 } 5249 MDI_PHCI_UNLOCK(ph); 5250 return (NDI_BUSY); 5251 } 5252 5253 /* 5254 * Mark the pHCI as offline 5255 */ 5256 MDI_PHCI_SET_OFFLINE(ph); 5257 5258 /* 5259 * Mark the child mdi_pathinfo nodes as transient 5260 */ 5261 pip = ph->ph_path_head; 5262 while (pip != NULL) { 5263 MDI_PI_LOCK(pip); 5264 next = (mdi_pathinfo_t *)MDI_PI(pip)->pi_phci_link; 5265 MDI_PI_SET_OFFLINING(pip); 5266 MDI_PI_UNLOCK(pip); 5267 pip = next; 5268 } 5269 MDI_PHCI_UNLOCK(ph); 5270 /* 5271 * Give a chance for any pending commands to execute 5272 */ 5273 delay_random(mdi_delay); 5274 MDI_PHCI_LOCK(ph); 5275 pip = ph->ph_path_head; 5276 while (pip != NULL) { 5277 next = (mdi_pathinfo_t *)MDI_PI(pip)->pi_phci_link; 5278 (void) i_mdi_pi_offline(pip, flags); 5279 MDI_PI_LOCK(pip); 5280 ct = MDI_PI(pip)->pi_client; 5281 if (!MDI_PI_IS_OFFLINE(pip)) { 5282 MDI_DEBUG(1, (MDI_WARN, dip, 5283 "!pHCI device is busy. " 5284 "This device can not be removed at this moment. " 5285 "Please try again later.")); 5286 MDI_PI_UNLOCK(pip); 5287 MDI_PHCI_SET_ONLINE(ph); 5288 MDI_PHCI_UNLOCK(ph); 5289 return (NDI_BUSY); 5290 } 5291 MDI_PI_UNLOCK(pip); 5292 pip = next; 5293 } 5294 MDI_PHCI_UNLOCK(ph); 5295 5296 return (rv); 5297 } 5298 5299 void 5300 mdi_phci_mark_retiring(dev_info_t *dip, char **cons_array) 5301 { 5302 mdi_phci_t *ph; 5303 mdi_client_t *ct; 5304 mdi_pathinfo_t *pip; 5305 mdi_pathinfo_t *next; 5306 dev_info_t *cdip; 5307 5308 if (!MDI_PHCI(dip)) 5309 return; 5310 5311 ph = i_devi_get_phci(dip); 5312 if (ph == NULL) { 5313 return; 5314 } 5315 5316 MDI_PHCI_LOCK(ph); 5317 5318 if (MDI_PHCI_IS_OFFLINE(ph)) { 5319 /* has no last path */ 5320 MDI_PHCI_UNLOCK(ph); 5321 return; 5322 } 5323 5324 pip = ph->ph_path_head; 5325 while (pip != NULL) { 5326 MDI_PI_LOCK(pip); 5327 next = (mdi_pathinfo_t *)MDI_PI(pip)->pi_phci_link; 5328 5329 ct = MDI_PI(pip)->pi_client; 5330 i_mdi_client_lock(ct, pip); 5331 MDI_PI_UNLOCK(pip); 5332 5333 cdip = ct->ct_dip; 5334 if (cdip && (i_ddi_node_state(cdip) >= DS_INITIALIZED) && 5335 (i_mdi_client_compute_state(ct, ph) == 5336 MDI_CLIENT_STATE_FAILED)) { 5337 /* Last path. Mark client dip as retiring */ 5338 i_mdi_client_unlock(ct); 5339 MDI_PHCI_UNLOCK(ph); 5340 (void) e_ddi_mark_retiring(cdip, cons_array); 5341 MDI_PHCI_LOCK(ph); 5342 pip = next; 5343 } else { 5344 i_mdi_client_unlock(ct); 5345 pip = next; 5346 } 5347 } 5348 5349 MDI_PHCI_UNLOCK(ph); 5350 5351 return; 5352 } 5353 5354 void 5355 mdi_phci_retire_notify(dev_info_t *dip, int *constraint) 5356 { 5357 mdi_phci_t *ph; 5358 mdi_client_t *ct; 5359 mdi_pathinfo_t *pip; 5360 mdi_pathinfo_t *next; 5361 dev_info_t *cdip; 5362 5363 if (!MDI_PHCI(dip)) 5364 return; 5365 5366 ph = i_devi_get_phci(dip); 5367 if (ph == NULL) 5368 return; 5369 5370 MDI_PHCI_LOCK(ph); 5371 5372 if (MDI_PHCI_IS_OFFLINE(ph)) { 5373 MDI_PHCI_UNLOCK(ph); 5374 /* not last path */ 5375 return; 5376 } 5377 5378 if (ph->ph_unstable) { 5379 MDI_PHCI_UNLOCK(ph); 5380 /* can't check for constraints */ 5381 *constraint = 0; 5382 return; 5383 } 5384 5385 pip = ph->ph_path_head; 5386 while (pip != NULL) { 5387 MDI_PI_LOCK(pip); 5388 next = (mdi_pathinfo_t *)MDI_PI(pip)->pi_phci_link; 5389 5390 /* 5391 * The mdi_pathinfo state is OK. Check the client state. 5392 * If failover in progress fail the pHCI from offlining 5393 */ 5394 ct = MDI_PI(pip)->pi_client; 5395 i_mdi_client_lock(ct, pip); 5396 if ((MDI_CLIENT_IS_FAILOVER_IN_PROGRESS(ct)) || 5397 (ct->ct_unstable)) { 5398 /* 5399 * Failover is in progress, can't check for constraints 5400 */ 5401 MDI_PI_UNLOCK(pip); 5402 i_mdi_client_unlock(ct); 5403 MDI_PHCI_UNLOCK(ph); 5404 *constraint = 0; 5405 return; 5406 } 5407 MDI_PI_UNLOCK(pip); 5408 5409 /* 5410 * Check to see of we are retiring the last path of this 5411 * client device... 5412 */ 5413 cdip = ct->ct_dip; 5414 if (cdip && (i_ddi_node_state(cdip) >= DS_INITIALIZED) && 5415 (i_mdi_client_compute_state(ct, ph) == 5416 MDI_CLIENT_STATE_FAILED)) { 5417 i_mdi_client_unlock(ct); 5418 MDI_PHCI_UNLOCK(ph); 5419 (void) e_ddi_retire_notify(cdip, constraint); 5420 MDI_PHCI_LOCK(ph); 5421 pip = next; 5422 } else { 5423 i_mdi_client_unlock(ct); 5424 pip = next; 5425 } 5426 } 5427 5428 MDI_PHCI_UNLOCK(ph); 5429 5430 return; 5431 } 5432 5433 /* 5434 * offline the path(s) hanging off the pHCI. If the 5435 * last path to any client, check that constraints 5436 * have been applied. 5437 * 5438 * If constraint is 0, we aren't going to retire the 5439 * pHCI. However we still need to go through the paths 5440 * calling e_ddi_retire_finalize() to clear their 5441 * contract barriers. 5442 */ 5443 void 5444 mdi_phci_retire_finalize(dev_info_t *dip, int phci_only, void *constraint) 5445 { 5446 mdi_phci_t *ph; 5447 mdi_client_t *ct; 5448 mdi_pathinfo_t *pip; 5449 mdi_pathinfo_t *next; 5450 dev_info_t *cdip; 5451 int unstable = 0; 5452 int tmp_constraint; 5453 5454 if (!MDI_PHCI(dip)) 5455 return; 5456 5457 ph = i_devi_get_phci(dip); 5458 if (ph == NULL) { 5459 /* no last path and no pips */ 5460 return; 5461 } 5462 5463 MDI_PHCI_LOCK(ph); 5464 5465 if (MDI_PHCI_IS_OFFLINE(ph)) { 5466 MDI_PHCI_UNLOCK(ph); 5467 /* no last path and no pips */ 5468 return; 5469 } 5470 5471 /* 5472 * Check to see if the pHCI can be offlined 5473 */ 5474 if (ph->ph_unstable) { 5475 unstable = 1; 5476 } 5477 5478 pip = ph->ph_path_head; 5479 while (pip != NULL) { 5480 MDI_PI_LOCK(pip); 5481 next = (mdi_pathinfo_t *)MDI_PI(pip)->pi_phci_link; 5482 5483 /* 5484 * if failover in progress fail the pHCI from offlining 5485 */ 5486 ct = MDI_PI(pip)->pi_client; 5487 i_mdi_client_lock(ct, pip); 5488 if ((MDI_CLIENT_IS_FAILOVER_IN_PROGRESS(ct)) || 5489 (ct->ct_unstable)) { 5490 unstable = 1; 5491 } 5492 MDI_PI_UNLOCK(pip); 5493 5494 /* 5495 * Check to see of we are removing the last path of this 5496 * client device... 5497 */ 5498 cdip = ct->ct_dip; 5499 if (!phci_only && cdip && 5500 (i_ddi_node_state(cdip) >= DS_INITIALIZED) && 5501 (i_mdi_client_compute_state(ct, ph) == 5502 MDI_CLIENT_STATE_FAILED)) { 5503 i_mdi_client_unlock(ct); 5504 MDI_PHCI_UNLOCK(ph); 5505 /* 5506 * This is the last path to this client. 5507 * 5508 * Constraint will only be set to 1 if this client can 5509 * be retired (as already determined by 5510 * mdi_phci_retire_notify). However we don't actually 5511 * need to retire the client (we just retire the last 5512 * path - MPXIO will then fail all I/Os to the client). 5513 * But we still need to call e_ddi_retire_finalize so 5514 * the contract barriers can be cleared. Therefore we 5515 * temporarily set constraint = 0 so that the client 5516 * dip is not retired. 5517 */ 5518 tmp_constraint = 0; 5519 (void) e_ddi_retire_finalize(cdip, &tmp_constraint); 5520 MDI_PHCI_LOCK(ph); 5521 pip = next; 5522 } else { 5523 i_mdi_client_unlock(ct); 5524 pip = next; 5525 } 5526 } 5527 5528 if (!phci_only && *((int *)constraint) == 0) { 5529 MDI_PHCI_UNLOCK(ph); 5530 return; 5531 } 5532 5533 /* 5534 * Cannot offline pip(s) 5535 */ 5536 if (unstable) { 5537 cmn_err(CE_WARN, "%s%d: mdi_phci_retire_finalize: " 5538 "pHCI in transient state, cannot retire", 5539 ddi_driver_name(dip), ddi_get_instance(dip)); 5540 MDI_PHCI_UNLOCK(ph); 5541 return; 5542 } 5543 5544 /* 5545 * Mark the pHCI as offline 5546 */ 5547 MDI_PHCI_SET_OFFLINE(ph); 5548 5549 /* 5550 * Mark the child mdi_pathinfo nodes as transient 5551 */ 5552 pip = ph->ph_path_head; 5553 while (pip != NULL) { 5554 MDI_PI_LOCK(pip); 5555 next = (mdi_pathinfo_t *)MDI_PI(pip)->pi_phci_link; 5556 MDI_PI_SET_OFFLINING(pip); 5557 MDI_PI_UNLOCK(pip); 5558 pip = next; 5559 } 5560 MDI_PHCI_UNLOCK(ph); 5561 /* 5562 * Give a chance for any pending commands to execute 5563 */ 5564 delay_random(mdi_delay); 5565 MDI_PHCI_LOCK(ph); 5566 pip = ph->ph_path_head; 5567 while (pip != NULL) { 5568 next = (mdi_pathinfo_t *)MDI_PI(pip)->pi_phci_link; 5569 (void) i_mdi_pi_offline(pip, 0); 5570 MDI_PI_LOCK(pip); 5571 ct = MDI_PI(pip)->pi_client; 5572 if (!MDI_PI_IS_OFFLINE(pip)) { 5573 cmn_err(CE_WARN, "mdi_phci_retire_finalize: " 5574 "path %d %s busy, cannot offline", 5575 mdi_pi_get_path_instance(pip), 5576 mdi_pi_spathname(pip)); 5577 MDI_PI_UNLOCK(pip); 5578 MDI_PHCI_SET_ONLINE(ph); 5579 MDI_PHCI_UNLOCK(ph); 5580 return; 5581 } 5582 MDI_PI_UNLOCK(pip); 5583 pip = next; 5584 } 5585 MDI_PHCI_UNLOCK(ph); 5586 5587 return; 5588 } 5589 5590 void 5591 mdi_phci_unretire(dev_info_t *dip) 5592 { 5593 mdi_phci_t *ph; 5594 mdi_pathinfo_t *pip; 5595 mdi_pathinfo_t *next; 5596 5597 ASSERT(MDI_PHCI(dip)); 5598 5599 /* 5600 * Online the phci 5601 */ 5602 i_mdi_phci_online(dip); 5603 5604 ph = i_devi_get_phci(dip); 5605 MDI_PHCI_LOCK(ph); 5606 pip = ph->ph_path_head; 5607 while (pip != NULL) { 5608 MDI_PI_LOCK(pip); 5609 next = (mdi_pathinfo_t *)MDI_PI(pip)->pi_phci_link; 5610 MDI_PI_UNLOCK(pip); 5611 (void) i_mdi_pi_online(pip, 0); 5612 pip = next; 5613 } 5614 MDI_PHCI_UNLOCK(ph); 5615 } 5616 5617 /*ARGSUSED*/ 5618 static int 5619 i_mdi_client_offline(dev_info_t *dip, uint_t flags) 5620 { 5621 int rv = NDI_SUCCESS; 5622 mdi_client_t *ct; 5623 5624 /* 5625 * Client component to go offline. Make sure that we are 5626 * not in failing over state and update client state 5627 * accordingly 5628 */ 5629 ct = i_devi_get_client(dip); 5630 MDI_DEBUG(2, (MDI_NOTE, dip, 5631 "called %p %p", (void *)dip, (void *)ct)); 5632 if (ct != NULL) { 5633 MDI_CLIENT_LOCK(ct); 5634 if (ct->ct_unstable) { 5635 /* 5636 * One or more paths are in transient state, 5637 * Dont allow offline of a client device 5638 */ 5639 MDI_DEBUG(1, (MDI_WARN, dip, 5640 "!One or more paths to " 5641 "this device are in transient state. " 5642 "This device can not be removed at this moment. " 5643 "Please try again later.")); 5644 MDI_CLIENT_UNLOCK(ct); 5645 return (NDI_BUSY); 5646 } 5647 if (MDI_CLIENT_IS_FAILOVER_IN_PROGRESS(ct)) { 5648 /* 5649 * Failover is in progress, Dont allow DR of 5650 * a client device 5651 */ 5652 MDI_DEBUG(1, (MDI_WARN, dip, 5653 "!Client device is Busy. " 5654 "This device can not be removed at this moment. " 5655 "Please try again later.")); 5656 MDI_CLIENT_UNLOCK(ct); 5657 return (NDI_BUSY); 5658 } 5659 MDI_CLIENT_SET_OFFLINE(ct); 5660 5661 /* 5662 * Unbind our relationship with the dev_info node 5663 */ 5664 if (flags & NDI_DEVI_REMOVE) { 5665 ct->ct_dip = NULL; 5666 } 5667 MDI_CLIENT_UNLOCK(ct); 5668 } 5669 return (rv); 5670 } 5671 5672 /* 5673 * mdi_pre_attach(): 5674 * Pre attach() notification handler 5675 */ 5676 /*ARGSUSED*/ 5677 int 5678 mdi_pre_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) 5679 { 5680 /* don't support old DDI_PM_RESUME */ 5681 if ((DEVI(dip)->devi_mdi_component != MDI_COMPONENT_NONE) && 5682 (cmd == DDI_PM_RESUME)) 5683 return (DDI_FAILURE); 5684 5685 return (DDI_SUCCESS); 5686 } 5687 5688 /* 5689 * mdi_post_attach(): 5690 * Post attach() notification handler 5691 */ 5692 /*ARGSUSED*/ 5693 void 5694 mdi_post_attach(dev_info_t *dip, ddi_attach_cmd_t cmd, int error) 5695 { 5696 mdi_phci_t *ph; 5697 mdi_client_t *ct; 5698 mdi_vhci_t *vh; 5699 5700 if (MDI_PHCI(dip)) { 5701 ph = i_devi_get_phci(dip); 5702 ASSERT(ph != NULL); 5703 5704 MDI_PHCI_LOCK(ph); 5705 switch (cmd) { 5706 case DDI_ATTACH: 5707 MDI_DEBUG(2, (MDI_NOTE, dip, 5708 "phci post_attach called %p", (void *)ph)); 5709 if (error == DDI_SUCCESS) { 5710 MDI_PHCI_SET_ATTACH(ph); 5711 } else { 5712 MDI_DEBUG(1, (MDI_NOTE, dip, 5713 "!pHCI post_attach failed: error %d", 5714 error)); 5715 MDI_PHCI_SET_DETACH(ph); 5716 } 5717 break; 5718 5719 case DDI_RESUME: 5720 MDI_DEBUG(2, (MDI_NOTE, dip, 5721 "pHCI post_resume: called %p", (void *)ph)); 5722 if (error == DDI_SUCCESS) { 5723 MDI_PHCI_SET_RESUME(ph); 5724 } else { 5725 MDI_DEBUG(1, (MDI_NOTE, dip, 5726 "!pHCI post_resume failed: error %d", 5727 error)); 5728 MDI_PHCI_SET_SUSPEND(ph); 5729 } 5730 break; 5731 } 5732 MDI_PHCI_UNLOCK(ph); 5733 } 5734 5735 if (MDI_CLIENT(dip)) { 5736 ct = i_devi_get_client(dip); 5737 ASSERT(ct != NULL); 5738 5739 MDI_CLIENT_LOCK(ct); 5740 switch (cmd) { 5741 case DDI_ATTACH: 5742 MDI_DEBUG(2, (MDI_NOTE, dip, 5743 "client post_attach called %p", (void *)ct)); 5744 if (error != DDI_SUCCESS) { 5745 MDI_DEBUG(1, (MDI_NOTE, dip, 5746 "!client post_attach failed: error %d", 5747 error)); 5748 MDI_CLIENT_SET_DETACH(ct); 5749 MDI_DEBUG(4, (MDI_WARN, dip, 5750 "i_mdi_pm_reset_client")); 5751 i_mdi_pm_reset_client(ct); 5752 break; 5753 } 5754 5755 /* 5756 * Client device has successfully attached, inform 5757 * the vhci. 5758 */ 5759 vh = ct->ct_vhci; 5760 if (vh->vh_ops->vo_client_attached) 5761 (*vh->vh_ops->vo_client_attached)(dip); 5762 5763 MDI_CLIENT_SET_ATTACH(ct); 5764 break; 5765 5766 case DDI_RESUME: 5767 MDI_DEBUG(2, (MDI_NOTE, dip, 5768 "client post_attach: called %p", (void *)ct)); 5769 if (error == DDI_SUCCESS) { 5770 MDI_CLIENT_SET_RESUME(ct); 5771 } else { 5772 MDI_DEBUG(1, (MDI_NOTE, dip, 5773 "!client post_resume failed: error %d", 5774 error)); 5775 MDI_CLIENT_SET_SUSPEND(ct); 5776 } 5777 break; 5778 } 5779 MDI_CLIENT_UNLOCK(ct); 5780 } 5781 } 5782 5783 /* 5784 * mdi_pre_detach(): 5785 * Pre detach notification handler 5786 */ 5787 /*ARGSUSED*/ 5788 int 5789 mdi_pre_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 5790 { 5791 int rv = DDI_SUCCESS; 5792 5793 if (MDI_CLIENT(dip)) { 5794 (void) i_mdi_client_pre_detach(dip, cmd); 5795 } 5796 5797 if (MDI_PHCI(dip)) { 5798 rv = i_mdi_phci_pre_detach(dip, cmd); 5799 } 5800 5801 return (rv); 5802 } 5803 5804 /*ARGSUSED*/ 5805 static int 5806 i_mdi_phci_pre_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 5807 { 5808 int rv = DDI_SUCCESS; 5809 mdi_phci_t *ph; 5810 mdi_client_t *ct; 5811 mdi_pathinfo_t *pip; 5812 mdi_pathinfo_t *failed_pip = NULL; 5813 mdi_pathinfo_t *next; 5814 5815 ph = i_devi_get_phci(dip); 5816 if (ph == NULL) { 5817 return (rv); 5818 } 5819 5820 MDI_PHCI_LOCK(ph); 5821 switch (cmd) { 5822 case DDI_DETACH: 5823 MDI_DEBUG(2, (MDI_NOTE, dip, 5824 "pHCI pre_detach: called %p", (void *)ph)); 5825 if (!MDI_PHCI_IS_OFFLINE(ph)) { 5826 /* 5827 * mdi_pathinfo nodes are still attached to 5828 * this pHCI. Fail the detach for this pHCI. 5829 */ 5830 MDI_DEBUG(2, (MDI_WARN, dip, 5831 "pHCI pre_detach: paths are still attached %p", 5832 (void *)ph)); 5833 rv = DDI_FAILURE; 5834 break; 5835 } 5836 MDI_PHCI_SET_DETACH(ph); 5837 break; 5838 5839 case DDI_SUSPEND: 5840 /* 5841 * pHCI is getting suspended. Since mpxio client 5842 * devices may not be suspended at this point, to avoid 5843 * a potential stack overflow, it is important to suspend 5844 * client devices before pHCI can be suspended. 5845 */ 5846 5847 MDI_DEBUG(2, (MDI_NOTE, dip, 5848 "pHCI pre_suspend: called %p", (void *)ph)); 5849 /* 5850 * Suspend all the client devices accessible through this pHCI 5851 */ 5852 pip = ph->ph_path_head; 5853 while (pip != NULL && rv == DDI_SUCCESS) { 5854 dev_info_t *cdip; 5855 MDI_PI_LOCK(pip); 5856 next = 5857 (mdi_pathinfo_t *)MDI_PI(pip)->pi_phci_link; 5858 ct = MDI_PI(pip)->pi_client; 5859 i_mdi_client_lock(ct, pip); 5860 cdip = ct->ct_dip; 5861 MDI_PI_UNLOCK(pip); 5862 if ((MDI_CLIENT_IS_DETACHED(ct) == 0) && 5863 MDI_CLIENT_IS_SUSPENDED(ct) == 0) { 5864 i_mdi_client_unlock(ct); 5865 if ((rv = devi_detach(cdip, DDI_SUSPEND)) != 5866 DDI_SUCCESS) { 5867 /* 5868 * Suspend of one of the client 5869 * device has failed. 5870 */ 5871 MDI_DEBUG(1, (MDI_WARN, dip, 5872 "!suspend of device (%s%d) failed.", 5873 ddi_driver_name(cdip), 5874 ddi_get_instance(cdip))); 5875 failed_pip = pip; 5876 break; 5877 } 5878 } else { 5879 i_mdi_client_unlock(ct); 5880 } 5881 pip = next; 5882 } 5883 5884 if (rv == DDI_SUCCESS) { 5885 /* 5886 * Suspend of client devices is complete. Proceed 5887 * with pHCI suspend. 5888 */ 5889 MDI_PHCI_SET_SUSPEND(ph); 5890 } else { 5891 /* 5892 * Revert back all the suspended client device states 5893 * to converse. 5894 */ 5895 pip = ph->ph_path_head; 5896 while (pip != failed_pip) { 5897 dev_info_t *cdip; 5898 MDI_PI_LOCK(pip); 5899 next = 5900 (mdi_pathinfo_t *)MDI_PI(pip)->pi_phci_link; 5901 ct = MDI_PI(pip)->pi_client; 5902 i_mdi_client_lock(ct, pip); 5903 cdip = ct->ct_dip; 5904 MDI_PI_UNLOCK(pip); 5905 if (MDI_CLIENT_IS_SUSPENDED(ct)) { 5906 i_mdi_client_unlock(ct); 5907 (void) devi_attach(cdip, DDI_RESUME); 5908 } else { 5909 i_mdi_client_unlock(ct); 5910 } 5911 pip = next; 5912 } 5913 } 5914 break; 5915 5916 default: 5917 rv = DDI_FAILURE; 5918 break; 5919 } 5920 MDI_PHCI_UNLOCK(ph); 5921 return (rv); 5922 } 5923 5924 /*ARGSUSED*/ 5925 static int 5926 i_mdi_client_pre_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 5927 { 5928 int rv = DDI_SUCCESS; 5929 mdi_client_t *ct; 5930 5931 ct = i_devi_get_client(dip); 5932 if (ct == NULL) { 5933 return (rv); 5934 } 5935 5936 MDI_CLIENT_LOCK(ct); 5937 switch (cmd) { 5938 case DDI_DETACH: 5939 MDI_DEBUG(2, (MDI_NOTE, dip, 5940 "client pre_detach: called %p", 5941 (void *)ct)); 5942 MDI_CLIENT_SET_DETACH(ct); 5943 break; 5944 5945 case DDI_SUSPEND: 5946 MDI_DEBUG(2, (MDI_NOTE, dip, 5947 "client pre_suspend: called %p", 5948 (void *)ct)); 5949 MDI_CLIENT_SET_SUSPEND(ct); 5950 break; 5951 5952 default: 5953 rv = DDI_FAILURE; 5954 break; 5955 } 5956 MDI_CLIENT_UNLOCK(ct); 5957 return (rv); 5958 } 5959 5960 /* 5961 * mdi_post_detach(): 5962 * Post detach notification handler 5963 */ 5964 /*ARGSUSED*/ 5965 void 5966 mdi_post_detach(dev_info_t *dip, ddi_detach_cmd_t cmd, int error) 5967 { 5968 /* 5969 * Detach/Suspend of mpxio component failed. Update our state 5970 * too 5971 */ 5972 if (MDI_PHCI(dip)) 5973 i_mdi_phci_post_detach(dip, cmd, error); 5974 5975 if (MDI_CLIENT(dip)) 5976 i_mdi_client_post_detach(dip, cmd, error); 5977 } 5978 5979 /*ARGSUSED*/ 5980 static void 5981 i_mdi_phci_post_detach(dev_info_t *dip, ddi_detach_cmd_t cmd, int error) 5982 { 5983 mdi_phci_t *ph; 5984 5985 /* 5986 * Detach/Suspend of phci component failed. Update our state 5987 * too 5988 */ 5989 ph = i_devi_get_phci(dip); 5990 if (ph == NULL) { 5991 return; 5992 } 5993 5994 MDI_PHCI_LOCK(ph); 5995 /* 5996 * Detach of pHCI failed. Restore back converse 5997 * state 5998 */ 5999 switch (cmd) { 6000 case DDI_DETACH: 6001 MDI_DEBUG(2, (MDI_NOTE, dip, 6002 "pHCI post_detach: called %p", 6003 (void *)ph)); 6004 if (error != DDI_SUCCESS) 6005 MDI_PHCI_SET_ATTACH(ph); 6006 break; 6007 6008 case DDI_SUSPEND: 6009 MDI_DEBUG(2, (MDI_NOTE, dip, 6010 "pHCI post_suspend: called %p", 6011 (void *)ph)); 6012 if (error != DDI_SUCCESS) 6013 MDI_PHCI_SET_RESUME(ph); 6014 break; 6015 } 6016 MDI_PHCI_UNLOCK(ph); 6017 } 6018 6019 /*ARGSUSED*/ 6020 static void 6021 i_mdi_client_post_detach(dev_info_t *dip, ddi_detach_cmd_t cmd, int error) 6022 { 6023 mdi_client_t *ct; 6024 6025 ct = i_devi_get_client(dip); 6026 if (ct == NULL) { 6027 return; 6028 } 6029 MDI_CLIENT_LOCK(ct); 6030 /* 6031 * Detach of Client failed. Restore back converse 6032 * state 6033 */ 6034 switch (cmd) { 6035 case DDI_DETACH: 6036 MDI_DEBUG(2, (MDI_NOTE, dip, 6037 "client post_detach: called %p", (void *)ct)); 6038 if (DEVI_IS_ATTACHING(dip)) { 6039 MDI_DEBUG(4, (MDI_NOTE, dip, 6040 "i_mdi_pm_rele_client\n")); 6041 i_mdi_pm_rele_client(ct, ct->ct_path_count); 6042 } else { 6043 MDI_DEBUG(4, (MDI_NOTE, dip, 6044 "i_mdi_pm_reset_client\n")); 6045 i_mdi_pm_reset_client(ct); 6046 } 6047 if (error != DDI_SUCCESS) 6048 MDI_CLIENT_SET_ATTACH(ct); 6049 break; 6050 6051 case DDI_SUSPEND: 6052 MDI_DEBUG(2, (MDI_NOTE, dip, 6053 "called %p", (void *)ct)); 6054 if (error != DDI_SUCCESS) 6055 MDI_CLIENT_SET_RESUME(ct); 6056 break; 6057 } 6058 MDI_CLIENT_UNLOCK(ct); 6059 } 6060 6061 int 6062 mdi_pi_kstat_exists(mdi_pathinfo_t *pip) 6063 { 6064 return (MDI_PI(pip)->pi_kstats ? 1 : 0); 6065 } 6066 6067 /* 6068 * create and install per-path (client - pHCI) statistics 6069 * I/O stats supported: nread, nwritten, reads, and writes 6070 * Error stats - hard errors, soft errors, & transport errors 6071 */ 6072 int 6073 mdi_pi_kstat_create(mdi_pathinfo_t *pip, char *ksname) 6074 { 6075 kstat_t *kiosp, *kerrsp; 6076 struct pi_errs *nsp; 6077 struct mdi_pi_kstats *mdi_statp; 6078 6079 if (MDI_PI(pip)->pi_kstats != NULL) 6080 return (MDI_SUCCESS); 6081 6082 if ((kiosp = kstat_create("mdi", 0, ksname, "iopath", 6083 KSTAT_TYPE_IO, 1, KSTAT_FLAG_PERSISTENT)) == NULL) { 6084 return (MDI_FAILURE); 6085 } 6086 6087 (void) strcat(ksname, ",err"); 6088 kerrsp = kstat_create("mdi", 0, ksname, "iopath_errors", 6089 KSTAT_TYPE_NAMED, 6090 sizeof (struct pi_errs) / sizeof (kstat_named_t), 0); 6091 if (kerrsp == NULL) { 6092 kstat_delete(kiosp); 6093 return (MDI_FAILURE); 6094 } 6095 6096 nsp = (struct pi_errs *)kerrsp->ks_data; 6097 kstat_named_init(&nsp->pi_softerrs, "Soft Errors", KSTAT_DATA_UINT32); 6098 kstat_named_init(&nsp->pi_harderrs, "Hard Errors", KSTAT_DATA_UINT32); 6099 kstat_named_init(&nsp->pi_transerrs, "Transport Errors", 6100 KSTAT_DATA_UINT32); 6101 kstat_named_init(&nsp->pi_icnt_busy, "Interconnect Busy", 6102 KSTAT_DATA_UINT32); 6103 kstat_named_init(&nsp->pi_icnt_errors, "Interconnect Errors", 6104 KSTAT_DATA_UINT32); 6105 kstat_named_init(&nsp->pi_phci_rsrc, "pHCI No Resources", 6106 KSTAT_DATA_UINT32); 6107 kstat_named_init(&nsp->pi_phci_localerr, "pHCI Local Errors", 6108 KSTAT_DATA_UINT32); 6109 kstat_named_init(&nsp->pi_phci_invstate, "pHCI Invalid State", 6110 KSTAT_DATA_UINT32); 6111 kstat_named_init(&nsp->pi_failedfrom, "Failed From", 6112 KSTAT_DATA_UINT32); 6113 kstat_named_init(&nsp->pi_failedto, "Failed To", KSTAT_DATA_UINT32); 6114 6115 mdi_statp = kmem_alloc(sizeof (*mdi_statp), KM_SLEEP); 6116 mdi_statp->pi_kstat_ref = 1; 6117 mdi_statp->pi_kstat_iostats = kiosp; 6118 mdi_statp->pi_kstat_errstats = kerrsp; 6119 kstat_install(kiosp); 6120 kstat_install(kerrsp); 6121 MDI_PI(pip)->pi_kstats = mdi_statp; 6122 return (MDI_SUCCESS); 6123 } 6124 6125 /* 6126 * destroy per-path properties 6127 */ 6128 static void 6129 i_mdi_pi_kstat_destroy(mdi_pathinfo_t *pip) 6130 { 6131 6132 struct mdi_pi_kstats *mdi_statp; 6133 6134 if (MDI_PI(pip)->pi_kstats == NULL) 6135 return; 6136 if ((mdi_statp = MDI_PI(pip)->pi_kstats) == NULL) 6137 return; 6138 6139 MDI_PI(pip)->pi_kstats = NULL; 6140 6141 /* 6142 * the kstat may be shared between multiple pathinfo nodes 6143 * decrement this pathinfo's usage, removing the kstats 6144 * themselves when the last pathinfo reference is removed. 6145 */ 6146 ASSERT(mdi_statp->pi_kstat_ref > 0); 6147 if (--mdi_statp->pi_kstat_ref != 0) 6148 return; 6149 6150 kstat_delete(mdi_statp->pi_kstat_iostats); 6151 kstat_delete(mdi_statp->pi_kstat_errstats); 6152 kmem_free(mdi_statp, sizeof (*mdi_statp)); 6153 } 6154 6155 /* 6156 * update I/O paths KSTATS 6157 */ 6158 void 6159 mdi_pi_kstat_iosupdate(mdi_pathinfo_t *pip, struct buf *bp) 6160 { 6161 kstat_t *iostatp; 6162 size_t xfer_cnt; 6163 6164 ASSERT(pip != NULL); 6165 6166 /* 6167 * I/O can be driven across a path prior to having path 6168 * statistics available, i.e. probe(9e). 6169 */ 6170 if (bp != NULL && MDI_PI(pip)->pi_kstats != NULL) { 6171 iostatp = MDI_PI(pip)->pi_kstats->pi_kstat_iostats; 6172 xfer_cnt = bp->b_bcount - bp->b_resid; 6173 if (bp->b_flags & B_READ) { 6174 KSTAT_IO_PTR(iostatp)->reads++; 6175 KSTAT_IO_PTR(iostatp)->nread += xfer_cnt; 6176 } else { 6177 KSTAT_IO_PTR(iostatp)->writes++; 6178 KSTAT_IO_PTR(iostatp)->nwritten += xfer_cnt; 6179 } 6180 } 6181 } 6182 6183 /* 6184 * Enable the path(specific client/target/initiator) 6185 * Enabling a path means that MPxIO may select the enabled path for routing 6186 * future I/O requests, subject to other path state constraints. 6187 */ 6188 int 6189 mdi_pi_enable_path(mdi_pathinfo_t *pip, int flags) 6190 { 6191 mdi_phci_t *ph; 6192 6193 ph = MDI_PI(pip)->pi_phci; 6194 if (ph == NULL) { 6195 MDI_DEBUG(1, (MDI_NOTE, mdi_pi_get_phci(pip), 6196 "!failed: path %s %p: NULL ph", 6197 mdi_pi_spathname(pip), (void *)pip)); 6198 return (MDI_FAILURE); 6199 } 6200 6201 (void) i_mdi_enable_disable_path(pip, ph->ph_vhci, flags, 6202 MDI_ENABLE_OP); 6203 MDI_DEBUG(5, (MDI_NOTE, ph->ph_dip, 6204 "!returning success pip = %p. ph = %p", 6205 (void *)pip, (void *)ph)); 6206 return (MDI_SUCCESS); 6207 6208 } 6209 6210 /* 6211 * Disable the path (specific client/target/initiator) 6212 * Disabling a path means that MPxIO will not select the disabled path for 6213 * routing any new I/O requests. 6214 */ 6215 int 6216 mdi_pi_disable_path(mdi_pathinfo_t *pip, int flags) 6217 { 6218 mdi_phci_t *ph; 6219 6220 ph = MDI_PI(pip)->pi_phci; 6221 if (ph == NULL) { 6222 MDI_DEBUG(1, (MDI_NOTE, mdi_pi_get_phci(pip), 6223 "!failed: path %s %p: NULL ph", 6224 mdi_pi_spathname(pip), (void *)pip)); 6225 return (MDI_FAILURE); 6226 } 6227 6228 (void) i_mdi_enable_disable_path(pip, 6229 ph->ph_vhci, flags, MDI_DISABLE_OP); 6230 MDI_DEBUG(5, (MDI_NOTE, ph->ph_dip, 6231 "!returning success pip = %p. ph = %p", 6232 (void *)pip, (void *)ph)); 6233 return (MDI_SUCCESS); 6234 } 6235 6236 /* 6237 * disable the path to a particular pHCI (pHCI specified in the phci_path 6238 * argument) for a particular client (specified in the client_path argument). 6239 * Disabling a path means that MPxIO will not select the disabled path for 6240 * routing any new I/O requests. 6241 * NOTE: this will be removed once the NWS files are changed to use the new 6242 * mdi_{enable,disable}_path interfaces 6243 */ 6244 int 6245 mdi_pi_disable(dev_info_t *cdip, dev_info_t *pdip, int flags) 6246 { 6247 return (i_mdi_pi_enable_disable(cdip, pdip, flags, MDI_DISABLE_OP)); 6248 } 6249 6250 /* 6251 * Enable the path to a particular pHCI (pHCI specified in the phci_path 6252 * argument) for a particular client (specified in the client_path argument). 6253 * Enabling a path means that MPxIO may select the enabled path for routing 6254 * future I/O requests, subject to other path state constraints. 6255 * NOTE: this will be removed once the NWS files are changed to use the new 6256 * mdi_{enable,disable}_path interfaces 6257 */ 6258 6259 int 6260 mdi_pi_enable(dev_info_t *cdip, dev_info_t *pdip, int flags) 6261 { 6262 return (i_mdi_pi_enable_disable(cdip, pdip, flags, MDI_ENABLE_OP)); 6263 } 6264 6265 /* 6266 * Common routine for doing enable/disable. 6267 */ 6268 static mdi_pathinfo_t * 6269 i_mdi_enable_disable_path(mdi_pathinfo_t *pip, mdi_vhci_t *vh, int flags, 6270 int op) 6271 { 6272 int sync_flag = 0; 6273 int rv; 6274 mdi_pathinfo_t *next; 6275 int (*f)() = NULL; 6276 6277 /* 6278 * Check to make sure the path is not already in the 6279 * requested state. If it is just return the next path 6280 * as we have nothing to do here. 6281 */ 6282 if ((MDI_PI_IS_DISABLE(pip) && op == MDI_DISABLE_OP) || 6283 (!MDI_PI_IS_DISABLE(pip) && op == MDI_ENABLE_OP)) { 6284 MDI_PI_LOCK(pip); 6285 next = (mdi_pathinfo_t *)MDI_PI(pip)->pi_phci_link; 6286 MDI_PI_UNLOCK(pip); 6287 return (next); 6288 } 6289 6290 f = vh->vh_ops->vo_pi_state_change; 6291 6292 sync_flag = (flags << 8) & 0xf00; 6293 6294 /* 6295 * Do a callback into the mdi consumer to let it 6296 * know that path is about to get enabled/disabled. 6297 */ 6298 if (f != NULL) { 6299 rv = (*f)(vh->vh_dip, pip, 0, 6300 MDI_PI_EXT_STATE(pip), 6301 MDI_EXT_STATE_CHANGE | sync_flag | 6302 op | MDI_BEFORE_STATE_CHANGE); 6303 if (rv != MDI_SUCCESS) { 6304 MDI_DEBUG(2, (MDI_WARN, vh->vh_dip, 6305 "vo_pi_state_change: failed rv = %x", rv)); 6306 } 6307 } 6308 MDI_PI_LOCK(pip); 6309 next = (mdi_pathinfo_t *)MDI_PI(pip)->pi_phci_link; 6310 6311 switch (flags) { 6312 case USER_DISABLE: 6313 if (op == MDI_DISABLE_OP) { 6314 MDI_PI_SET_USER_DISABLE(pip); 6315 } else { 6316 MDI_PI_SET_USER_ENABLE(pip); 6317 } 6318 break; 6319 case DRIVER_DISABLE: 6320 if (op == MDI_DISABLE_OP) { 6321 MDI_PI_SET_DRV_DISABLE(pip); 6322 } else { 6323 MDI_PI_SET_DRV_ENABLE(pip); 6324 } 6325 break; 6326 case DRIVER_DISABLE_TRANSIENT: 6327 if (op == MDI_DISABLE_OP && rv == MDI_SUCCESS) { 6328 MDI_PI_SET_DRV_DISABLE_TRANS(pip); 6329 } else { 6330 MDI_PI_SET_DRV_ENABLE_TRANS(pip); 6331 } 6332 break; 6333 } 6334 MDI_PI_UNLOCK(pip); 6335 /* 6336 * Do a callback into the mdi consumer to let it 6337 * know that path is now enabled/disabled. 6338 */ 6339 if (f != NULL) { 6340 rv = (*f)(vh->vh_dip, pip, 0, 6341 MDI_PI_EXT_STATE(pip), 6342 MDI_EXT_STATE_CHANGE | sync_flag | 6343 op | MDI_AFTER_STATE_CHANGE); 6344 if (rv != MDI_SUCCESS) { 6345 MDI_DEBUG(2, (MDI_WARN, vh->vh_dip, 6346 "vo_pi_state_change failed: rv = %x", rv)); 6347 } 6348 } 6349 return (next); 6350 } 6351 6352 /* 6353 * Common routine for doing enable/disable. 6354 * NOTE: this will be removed once the NWS files are changed to use the new 6355 * mdi_{enable,disable}_path has been putback 6356 */ 6357 int 6358 i_mdi_pi_enable_disable(dev_info_t *cdip, dev_info_t *pdip, int flags, int op) 6359 { 6360 6361 mdi_phci_t *ph; 6362 mdi_vhci_t *vh = NULL; 6363 mdi_client_t *ct; 6364 mdi_pathinfo_t *next, *pip; 6365 int found_it; 6366 6367 ph = i_devi_get_phci(pdip); 6368 MDI_DEBUG(5, (MDI_NOTE, cdip ? cdip : pdip, 6369 "!op = %d pdip = %p cdip = %p", op, (void *)pdip, 6370 (void *)cdip)); 6371 if (ph == NULL) { 6372 MDI_DEBUG(1, (MDI_NOTE, cdip ? cdip : pdip, 6373 "!failed: operation %d: NULL ph", op)); 6374 return (MDI_FAILURE); 6375 } 6376 6377 if ((op != MDI_ENABLE_OP) && (op != MDI_DISABLE_OP)) { 6378 MDI_DEBUG(1, (MDI_NOTE, cdip ? cdip : pdip, 6379 "!failed: invalid operation %d", op)); 6380 return (MDI_FAILURE); 6381 } 6382 6383 vh = ph->ph_vhci; 6384 6385 if (cdip == NULL) { 6386 /* 6387 * Need to mark the Phci as enabled/disabled. 6388 */ 6389 MDI_DEBUG(4, (MDI_NOTE, cdip ? cdip : pdip, 6390 "op %d for the phci", op)); 6391 MDI_PHCI_LOCK(ph); 6392 switch (flags) { 6393 case USER_DISABLE: 6394 if (op == MDI_DISABLE_OP) { 6395 MDI_PHCI_SET_USER_DISABLE(ph); 6396 } else { 6397 MDI_PHCI_SET_USER_ENABLE(ph); 6398 } 6399 break; 6400 case DRIVER_DISABLE: 6401 if (op == MDI_DISABLE_OP) { 6402 MDI_PHCI_SET_DRV_DISABLE(ph); 6403 } else { 6404 MDI_PHCI_SET_DRV_ENABLE(ph); 6405 } 6406 break; 6407 case DRIVER_DISABLE_TRANSIENT: 6408 if (op == MDI_DISABLE_OP) { 6409 MDI_PHCI_SET_DRV_DISABLE_TRANSIENT(ph); 6410 } else { 6411 MDI_PHCI_SET_DRV_ENABLE_TRANSIENT(ph); 6412 } 6413 break; 6414 default: 6415 MDI_PHCI_UNLOCK(ph); 6416 MDI_DEBUG(1, (MDI_NOTE, cdip ? cdip : pdip, 6417 "!invalid flag argument= %d", flags)); 6418 } 6419 6420 /* 6421 * Phci has been disabled. Now try to enable/disable 6422 * path info's to each client. 6423 */ 6424 pip = ph->ph_path_head; 6425 while (pip != NULL) { 6426 pip = i_mdi_enable_disable_path(pip, vh, flags, op); 6427 } 6428 MDI_PHCI_UNLOCK(ph); 6429 } else { 6430 6431 /* 6432 * Disable a specific client. 6433 */ 6434 ct = i_devi_get_client(cdip); 6435 if (ct == NULL) { 6436 MDI_DEBUG(1, (MDI_NOTE, cdip ? cdip : pdip, 6437 "!failed: operation = %d: NULL ct", op)); 6438 return (MDI_FAILURE); 6439 } 6440 6441 MDI_CLIENT_LOCK(ct); 6442 pip = ct->ct_path_head; 6443 found_it = 0; 6444 while (pip != NULL) { 6445 MDI_PI_LOCK(pip); 6446 next = (mdi_pathinfo_t *)MDI_PI(pip)->pi_client_link; 6447 if (MDI_PI(pip)->pi_phci == ph) { 6448 MDI_PI_UNLOCK(pip); 6449 found_it = 1; 6450 break; 6451 } 6452 MDI_PI_UNLOCK(pip); 6453 pip = next; 6454 } 6455 6456 6457 MDI_CLIENT_UNLOCK(ct); 6458 if (found_it == 0) { 6459 MDI_DEBUG(1, (MDI_NOTE, cdip ? cdip : pdip, 6460 "!failed. Could not find corresponding pip\n")); 6461 return (MDI_FAILURE); 6462 } 6463 6464 (void) i_mdi_enable_disable_path(pip, vh, flags, op); 6465 } 6466 6467 MDI_DEBUG(5, (MDI_NOTE, cdip ? cdip : pdip, 6468 "!op %d returning success pdip = %p cdip = %p", 6469 op, (void *)pdip, (void *)cdip)); 6470 return (MDI_SUCCESS); 6471 } 6472 6473 /* 6474 * Ensure phci powered up 6475 */ 6476 static void 6477 i_mdi_pm_hold_pip(mdi_pathinfo_t *pip) 6478 { 6479 dev_info_t *ph_dip; 6480 6481 ASSERT(pip != NULL); 6482 ASSERT(MDI_PI_LOCKED(pip)); 6483 6484 if (MDI_PI(pip)->pi_pm_held) { 6485 return; 6486 } 6487 6488 ph_dip = mdi_pi_get_phci(pip); 6489 MDI_DEBUG(4, (MDI_NOTE, ph_dip, 6490 "%s %p", mdi_pi_spathname(pip), (void *)pip)); 6491 if (ph_dip == NULL) { 6492 return; 6493 } 6494 6495 MDI_PI_UNLOCK(pip); 6496 MDI_DEBUG(4, (MDI_NOTE, ph_dip, "kidsupcnt was %d", 6497 DEVI(ph_dip)->devi_pm_kidsupcnt)); 6498 pm_hold_power(ph_dip); 6499 MDI_DEBUG(4, (MDI_NOTE, ph_dip, "kidsupcnt is %d", 6500 DEVI(ph_dip)->devi_pm_kidsupcnt)); 6501 MDI_PI_LOCK(pip); 6502 6503 /* If PM_GET_PM_INFO is NULL the pm_hold_power above was a noop */ 6504 if (DEVI(ph_dip)->devi_pm_info) 6505 MDI_PI(pip)->pi_pm_held = 1; 6506 } 6507 6508 /* 6509 * Allow phci powered down 6510 */ 6511 static void 6512 i_mdi_pm_rele_pip(mdi_pathinfo_t *pip) 6513 { 6514 dev_info_t *ph_dip = NULL; 6515 6516 ASSERT(pip != NULL); 6517 ASSERT(MDI_PI_LOCKED(pip)); 6518 6519 if (MDI_PI(pip)->pi_pm_held == 0) { 6520 return; 6521 } 6522 6523 ph_dip = mdi_pi_get_phci(pip); 6524 ASSERT(ph_dip != NULL); 6525 6526 MDI_DEBUG(4, (MDI_NOTE, ph_dip, 6527 "%s %p", mdi_pi_spathname(pip), (void *)pip)); 6528 6529 MDI_PI_UNLOCK(pip); 6530 MDI_DEBUG(4, (MDI_NOTE, ph_dip, 6531 "kidsupcnt was %d", DEVI(ph_dip)->devi_pm_kidsupcnt)); 6532 pm_rele_power(ph_dip); 6533 MDI_DEBUG(4, (MDI_NOTE, ph_dip, 6534 "kidsupcnt is %d", DEVI(ph_dip)->devi_pm_kidsupcnt)); 6535 MDI_PI_LOCK(pip); 6536 6537 MDI_PI(pip)->pi_pm_held = 0; 6538 } 6539 6540 static void 6541 i_mdi_pm_hold_client(mdi_client_t *ct, int incr) 6542 { 6543 ASSERT(MDI_CLIENT_LOCKED(ct)); 6544 6545 ct->ct_power_cnt += incr; 6546 MDI_DEBUG(4, (MDI_NOTE, ct->ct_dip, 6547 "%p ct_power_cnt = %d incr = %d", 6548 (void *)ct, ct->ct_power_cnt, incr)); 6549 ASSERT(ct->ct_power_cnt >= 0); 6550 } 6551 6552 static void 6553 i_mdi_rele_all_phci(mdi_client_t *ct) 6554 { 6555 mdi_pathinfo_t *pip; 6556 6557 ASSERT(MDI_CLIENT_LOCKED(ct)); 6558 pip = (mdi_pathinfo_t *)ct->ct_path_head; 6559 while (pip != NULL) { 6560 mdi_hold_path(pip); 6561 MDI_PI_LOCK(pip); 6562 i_mdi_pm_rele_pip(pip); 6563 MDI_PI_UNLOCK(pip); 6564 mdi_rele_path(pip); 6565 pip = (mdi_pathinfo_t *)MDI_PI(pip)->pi_client_link; 6566 } 6567 } 6568 6569 static void 6570 i_mdi_pm_rele_client(mdi_client_t *ct, int decr) 6571 { 6572 ASSERT(MDI_CLIENT_LOCKED(ct)); 6573 6574 if (i_ddi_devi_attached(ct->ct_dip)) { 6575 ct->ct_power_cnt -= decr; 6576 MDI_DEBUG(4, (MDI_NOTE, ct->ct_dip, 6577 "%p ct_power_cnt = %d decr = %d", 6578 (void *)ct, ct->ct_power_cnt, decr)); 6579 } 6580 6581 ASSERT(ct->ct_power_cnt >= 0); 6582 if (ct->ct_power_cnt == 0) { 6583 i_mdi_rele_all_phci(ct); 6584 return; 6585 } 6586 } 6587 6588 static void 6589 i_mdi_pm_reset_client(mdi_client_t *ct) 6590 { 6591 MDI_DEBUG(4, (MDI_NOTE, ct->ct_dip, 6592 "%p ct_power_cnt = %d", (void *)ct, ct->ct_power_cnt)); 6593 ASSERT(MDI_CLIENT_LOCKED(ct)); 6594 ct->ct_power_cnt = 0; 6595 i_mdi_rele_all_phci(ct); 6596 ct->ct_powercnt_config = 0; 6597 ct->ct_powercnt_unconfig = 0; 6598 ct->ct_powercnt_reset = 1; 6599 } 6600 6601 static int 6602 i_mdi_power_one_phci(mdi_pathinfo_t *pip) 6603 { 6604 int ret; 6605 dev_info_t *ph_dip; 6606 6607 MDI_PI_LOCK(pip); 6608 i_mdi_pm_hold_pip(pip); 6609 6610 ph_dip = mdi_pi_get_phci(pip); 6611 MDI_PI_UNLOCK(pip); 6612 6613 /* bring all components of phci to full power */ 6614 MDI_DEBUG(4, (MDI_NOTE, ph_dip, 6615 "pm_powerup for %s%d %p", ddi_driver_name(ph_dip), 6616 ddi_get_instance(ph_dip), (void *)pip)); 6617 6618 ret = pm_powerup(ph_dip); 6619 6620 if (ret == DDI_FAILURE) { 6621 MDI_DEBUG(4, (MDI_NOTE, ph_dip, 6622 "pm_powerup FAILED for %s%d %p", 6623 ddi_driver_name(ph_dip), ddi_get_instance(ph_dip), 6624 (void *)pip)); 6625 6626 MDI_PI_LOCK(pip); 6627 i_mdi_pm_rele_pip(pip); 6628 MDI_PI_UNLOCK(pip); 6629 return (MDI_FAILURE); 6630 } 6631 6632 return (MDI_SUCCESS); 6633 } 6634 6635 static int 6636 i_mdi_power_all_phci(mdi_client_t *ct) 6637 { 6638 mdi_pathinfo_t *pip; 6639 int succeeded = 0; 6640 6641 ASSERT(MDI_CLIENT_LOCKED(ct)); 6642 pip = (mdi_pathinfo_t *)ct->ct_path_head; 6643 while (pip != NULL) { 6644 /* 6645 * Don't power if MDI_PATHINFO_STATE_FAULT 6646 * or MDI_PATHINFO_STATE_OFFLINE. 6647 */ 6648 if (MDI_PI_IS_INIT(pip) || 6649 MDI_PI_IS_ONLINE(pip) || MDI_PI_IS_STANDBY(pip)) { 6650 mdi_hold_path(pip); 6651 MDI_CLIENT_UNLOCK(ct); 6652 if (i_mdi_power_one_phci(pip) == MDI_SUCCESS) 6653 succeeded = 1; 6654 6655 ASSERT(ct == MDI_PI(pip)->pi_client); 6656 MDI_CLIENT_LOCK(ct); 6657 mdi_rele_path(pip); 6658 } 6659 pip = (mdi_pathinfo_t *)MDI_PI(pip)->pi_client_link; 6660 } 6661 6662 return (succeeded ? MDI_SUCCESS : MDI_FAILURE); 6663 } 6664 6665 /* 6666 * mdi_bus_power(): 6667 * 1. Place the phci(s) into powered up state so that 6668 * client can do power management 6669 * 2. Ensure phci powered up as client power managing 6670 * Return Values: 6671 * MDI_SUCCESS 6672 * MDI_FAILURE 6673 */ 6674 int 6675 mdi_bus_power(dev_info_t *parent, void *impl_arg, pm_bus_power_op_t op, 6676 void *arg, void *result) 6677 { 6678 int ret = MDI_SUCCESS; 6679 pm_bp_child_pwrchg_t *bpc; 6680 mdi_client_t *ct; 6681 dev_info_t *cdip; 6682 pm_bp_has_changed_t *bphc; 6683 6684 /* 6685 * BUS_POWER_NOINVOL not supported 6686 */ 6687 if (op == BUS_POWER_NOINVOL) 6688 return (MDI_FAILURE); 6689 6690 /* 6691 * ignore other OPs. 6692 * return quickly to save cou cycles on the ct processing 6693 */ 6694 switch (op) { 6695 case BUS_POWER_PRE_NOTIFICATION: 6696 case BUS_POWER_POST_NOTIFICATION: 6697 bpc = (pm_bp_child_pwrchg_t *)arg; 6698 cdip = bpc->bpc_dip; 6699 break; 6700 case BUS_POWER_HAS_CHANGED: 6701 bphc = (pm_bp_has_changed_t *)arg; 6702 cdip = bphc->bphc_dip; 6703 break; 6704 default: 6705 return (pm_busop_bus_power(parent, impl_arg, op, arg, result)); 6706 } 6707 6708 ASSERT(MDI_CLIENT(cdip)); 6709 6710 ct = i_devi_get_client(cdip); 6711 if (ct == NULL) 6712 return (MDI_FAILURE); 6713 6714 /* 6715 * wait till the mdi_pathinfo node state change are processed 6716 */ 6717 MDI_CLIENT_LOCK(ct); 6718 switch (op) { 6719 case BUS_POWER_PRE_NOTIFICATION: 6720 MDI_DEBUG(4, (MDI_NOTE, bpc->bpc_dip, 6721 "BUS_POWER_PRE_NOTIFICATION:" 6722 "%s@%s, olevel=%d, nlevel=%d, comp=%d", 6723 ddi_node_name(bpc->bpc_dip), PM_ADDR(bpc->bpc_dip), 6724 bpc->bpc_olevel, bpc->bpc_nlevel, bpc->bpc_comp)); 6725 6726 /* serialize power level change per client */ 6727 while (MDI_CLIENT_IS_POWER_TRANSITION(ct)) 6728 cv_wait(&ct->ct_powerchange_cv, &ct->ct_mutex); 6729 6730 MDI_CLIENT_SET_POWER_TRANSITION(ct); 6731 6732 if (ct->ct_power_cnt == 0) { 6733 ret = i_mdi_power_all_phci(ct); 6734 } 6735 6736 /* 6737 * if new_level > 0: 6738 * - hold phci(s) 6739 * - power up phci(s) if not already 6740 * ignore power down 6741 */ 6742 if (bpc->bpc_nlevel > 0) { 6743 if (!DEVI_IS_ATTACHING(ct->ct_dip)) { 6744 MDI_DEBUG(4, (MDI_NOTE, bpc->bpc_dip, 6745 "i_mdi_pm_hold_client\n")); 6746 i_mdi_pm_hold_client(ct, ct->ct_path_count); 6747 } 6748 } 6749 break; 6750 case BUS_POWER_POST_NOTIFICATION: 6751 MDI_DEBUG(4, (MDI_NOTE, bpc->bpc_dip, 6752 "BUS_POWER_POST_NOTIFICATION:" 6753 "%s@%s, olevel=%d, nlevel=%d, comp=%d result=%d", 6754 ddi_node_name(bpc->bpc_dip), PM_ADDR(bpc->bpc_dip), 6755 bpc->bpc_olevel, bpc->bpc_nlevel, bpc->bpc_comp, 6756 *(int *)result)); 6757 6758 if (*(int *)result == DDI_SUCCESS) { 6759 if (bpc->bpc_nlevel > 0) { 6760 MDI_CLIENT_SET_POWER_UP(ct); 6761 } else { 6762 MDI_CLIENT_SET_POWER_DOWN(ct); 6763 } 6764 } 6765 6766 /* release the hold we did in pre-notification */ 6767 if (bpc->bpc_nlevel > 0 && (*(int *)result != DDI_SUCCESS) && 6768 !DEVI_IS_ATTACHING(ct->ct_dip)) { 6769 MDI_DEBUG(4, (MDI_NOTE, bpc->bpc_dip, 6770 "i_mdi_pm_rele_client\n")); 6771 i_mdi_pm_rele_client(ct, ct->ct_path_count); 6772 } 6773 6774 if (bpc->bpc_nlevel == 0 && (*(int *)result == DDI_SUCCESS)) { 6775 /* another thread might started attaching */ 6776 if (DEVI_IS_ATTACHING(ct->ct_dip)) { 6777 MDI_DEBUG(4, (MDI_NOTE, bpc->bpc_dip, 6778 "i_mdi_pm_rele_client\n")); 6779 i_mdi_pm_rele_client(ct, ct->ct_path_count); 6780 /* detaching has been taken care in pm_post_unconfig */ 6781 } else if (!DEVI_IS_DETACHING(ct->ct_dip)) { 6782 MDI_DEBUG(4, (MDI_NOTE, bpc->bpc_dip, 6783 "i_mdi_pm_reset_client\n")); 6784 i_mdi_pm_reset_client(ct); 6785 } 6786 } 6787 6788 MDI_CLIENT_CLEAR_POWER_TRANSITION(ct); 6789 cv_broadcast(&ct->ct_powerchange_cv); 6790 6791 break; 6792 6793 /* need to do more */ 6794 case BUS_POWER_HAS_CHANGED: 6795 MDI_DEBUG(4, (MDI_NOTE, bphc->bphc_dip, 6796 "BUS_POWER_HAS_CHANGED:" 6797 "%s@%s, olevel=%d, nlevel=%d, comp=%d", 6798 ddi_node_name(bphc->bphc_dip), PM_ADDR(bphc->bphc_dip), 6799 bphc->bphc_olevel, bphc->bphc_nlevel, bphc->bphc_comp)); 6800 6801 if (bphc->bphc_nlevel > 0 && 6802 bphc->bphc_nlevel > bphc->bphc_olevel) { 6803 if (ct->ct_power_cnt == 0) { 6804 ret = i_mdi_power_all_phci(ct); 6805 } 6806 MDI_DEBUG(4, (MDI_NOTE, bphc->bphc_dip, 6807 "i_mdi_pm_hold_client\n")); 6808 i_mdi_pm_hold_client(ct, ct->ct_path_count); 6809 } 6810 6811 if (bphc->bphc_nlevel == 0 && bphc->bphc_olevel != -1) { 6812 MDI_DEBUG(4, (MDI_NOTE, bphc->bphc_dip, 6813 "i_mdi_pm_rele_client\n")); 6814 i_mdi_pm_rele_client(ct, ct->ct_path_count); 6815 } 6816 break; 6817 } 6818 6819 MDI_CLIENT_UNLOCK(ct); 6820 return (ret); 6821 } 6822 6823 static int 6824 i_mdi_pm_pre_config_one(dev_info_t *child) 6825 { 6826 int ret = MDI_SUCCESS; 6827 mdi_client_t *ct; 6828 6829 ct = i_devi_get_client(child); 6830 if (ct == NULL) 6831 return (MDI_FAILURE); 6832 6833 MDI_CLIENT_LOCK(ct); 6834 while (MDI_CLIENT_IS_POWER_TRANSITION(ct)) 6835 cv_wait(&ct->ct_powerchange_cv, &ct->ct_mutex); 6836 6837 if (!MDI_CLIENT_IS_FAILED(ct)) { 6838 MDI_CLIENT_UNLOCK(ct); 6839 MDI_DEBUG(4, (MDI_NOTE, child, "already configured\n")); 6840 return (MDI_SUCCESS); 6841 } 6842 6843 if (ct->ct_powercnt_config) { 6844 MDI_CLIENT_UNLOCK(ct); 6845 MDI_DEBUG(4, (MDI_NOTE, child, "already held\n")); 6846 return (MDI_SUCCESS); 6847 } 6848 6849 if (ct->ct_power_cnt == 0) { 6850 ret = i_mdi_power_all_phci(ct); 6851 } 6852 MDI_DEBUG(4, (MDI_NOTE, child, "i_mdi_pm_hold_client\n")); 6853 i_mdi_pm_hold_client(ct, ct->ct_path_count); 6854 ct->ct_powercnt_config = 1; 6855 ct->ct_powercnt_reset = 0; 6856 MDI_CLIENT_UNLOCK(ct); 6857 return (ret); 6858 } 6859 6860 static int 6861 i_mdi_pm_pre_config(dev_info_t *vdip, dev_info_t *child) 6862 { 6863 int ret = MDI_SUCCESS; 6864 dev_info_t *cdip; 6865 int circ; 6866 6867 ASSERT(MDI_VHCI(vdip)); 6868 6869 /* ndi_devi_config_one */ 6870 if (child) { 6871 ASSERT(DEVI_BUSY_OWNED(vdip)); 6872 return (i_mdi_pm_pre_config_one(child)); 6873 } 6874 6875 /* devi_config_common */ 6876 ndi_devi_enter(vdip, &circ); 6877 cdip = ddi_get_child(vdip); 6878 while (cdip) { 6879 dev_info_t *next = ddi_get_next_sibling(cdip); 6880 6881 ret = i_mdi_pm_pre_config_one(cdip); 6882 if (ret != MDI_SUCCESS) 6883 break; 6884 cdip = next; 6885 } 6886 ndi_devi_exit(vdip, circ); 6887 return (ret); 6888 } 6889 6890 static int 6891 i_mdi_pm_pre_unconfig_one(dev_info_t *child, int *held, int flags) 6892 { 6893 int ret = MDI_SUCCESS; 6894 mdi_client_t *ct; 6895 6896 ct = i_devi_get_client(child); 6897 if (ct == NULL) 6898 return (MDI_FAILURE); 6899 6900 MDI_CLIENT_LOCK(ct); 6901 while (MDI_CLIENT_IS_POWER_TRANSITION(ct)) 6902 cv_wait(&ct->ct_powerchange_cv, &ct->ct_mutex); 6903 6904 if (!i_ddi_devi_attached(child)) { 6905 MDI_DEBUG(4, (MDI_NOTE, child, "node detached already\n")); 6906 MDI_CLIENT_UNLOCK(ct); 6907 return (MDI_SUCCESS); 6908 } 6909 6910 if (MDI_CLIENT_IS_POWERED_DOWN(ct) && 6911 (flags & NDI_AUTODETACH)) { 6912 MDI_DEBUG(4, (MDI_NOTE, child, "auto-modunload\n")); 6913 MDI_CLIENT_UNLOCK(ct); 6914 return (MDI_FAILURE); 6915 } 6916 6917 if (ct->ct_powercnt_unconfig) { 6918 MDI_DEBUG(4, (MDI_NOTE, child, "ct_powercnt_held\n")); 6919 MDI_CLIENT_UNLOCK(ct); 6920 *held = 1; 6921 return (MDI_SUCCESS); 6922 } 6923 6924 if (ct->ct_power_cnt == 0) { 6925 ret = i_mdi_power_all_phci(ct); 6926 } 6927 MDI_DEBUG(4, (MDI_NOTE, child, "i_mdi_pm_hold_client\n")); 6928 i_mdi_pm_hold_client(ct, ct->ct_path_count); 6929 ct->ct_powercnt_unconfig = 1; 6930 ct->ct_powercnt_reset = 0; 6931 MDI_CLIENT_UNLOCK(ct); 6932 if (ret == MDI_SUCCESS) 6933 *held = 1; 6934 return (ret); 6935 } 6936 6937 static int 6938 i_mdi_pm_pre_unconfig(dev_info_t *vdip, dev_info_t *child, int *held, 6939 int flags) 6940 { 6941 int ret = MDI_SUCCESS; 6942 dev_info_t *cdip; 6943 int circ; 6944 6945 ASSERT(MDI_VHCI(vdip)); 6946 *held = 0; 6947 6948 /* ndi_devi_unconfig_one */ 6949 if (child) { 6950 ASSERT(DEVI_BUSY_OWNED(vdip)); 6951 return (i_mdi_pm_pre_unconfig_one(child, held, flags)); 6952 } 6953 6954 /* devi_unconfig_common */ 6955 ndi_devi_enter(vdip, &circ); 6956 cdip = ddi_get_child(vdip); 6957 while (cdip) { 6958 dev_info_t *next = ddi_get_next_sibling(cdip); 6959 6960 ret = i_mdi_pm_pre_unconfig_one(cdip, held, flags); 6961 cdip = next; 6962 } 6963 ndi_devi_exit(vdip, circ); 6964 6965 if (*held) 6966 ret = MDI_SUCCESS; 6967 6968 return (ret); 6969 } 6970 6971 static void 6972 i_mdi_pm_post_config_one(dev_info_t *child) 6973 { 6974 mdi_client_t *ct; 6975 6976 ct = i_devi_get_client(child); 6977 if (ct == NULL) 6978 return; 6979 6980 MDI_CLIENT_LOCK(ct); 6981 while (MDI_CLIENT_IS_POWER_TRANSITION(ct)) 6982 cv_wait(&ct->ct_powerchange_cv, &ct->ct_mutex); 6983 6984 if (ct->ct_powercnt_reset || !ct->ct_powercnt_config) { 6985 MDI_DEBUG(4, (MDI_NOTE, child, "not configured\n")); 6986 MDI_CLIENT_UNLOCK(ct); 6987 return; 6988 } 6989 6990 /* client has not been updated */ 6991 if (MDI_CLIENT_IS_FAILED(ct)) { 6992 MDI_DEBUG(4, (MDI_NOTE, child, "client failed\n")); 6993 MDI_CLIENT_UNLOCK(ct); 6994 return; 6995 } 6996 6997 /* another thread might have powered it down or detached it */ 6998 if ((MDI_CLIENT_IS_POWERED_DOWN(ct) && 6999 !DEVI_IS_ATTACHING(child)) || 7000 (!i_ddi_devi_attached(child) && 7001 !DEVI_IS_ATTACHING(child))) { 7002 MDI_DEBUG(4, (MDI_NOTE, child, "i_mdi_pm_reset_client\n")); 7003 i_mdi_pm_reset_client(ct); 7004 } else { 7005 mdi_pathinfo_t *pip, *next; 7006 int valid_path_count = 0; 7007 7008 MDI_DEBUG(4, (MDI_NOTE, child, "i_mdi_pm_rele_client\n")); 7009 pip = ct->ct_path_head; 7010 while (pip != NULL) { 7011 MDI_PI_LOCK(pip); 7012 next = (mdi_pathinfo_t *)MDI_PI(pip)->pi_client_link; 7013 if (MDI_PI_IS_ONLINE(pip) || MDI_PI_IS_STANDBY(pip)) 7014 valid_path_count ++; 7015 MDI_PI_UNLOCK(pip); 7016 pip = next; 7017 } 7018 i_mdi_pm_rele_client(ct, valid_path_count); 7019 } 7020 ct->ct_powercnt_config = 0; 7021 MDI_CLIENT_UNLOCK(ct); 7022 } 7023 7024 static void 7025 i_mdi_pm_post_config(dev_info_t *vdip, dev_info_t *child) 7026 { 7027 int circ; 7028 dev_info_t *cdip; 7029 7030 ASSERT(MDI_VHCI(vdip)); 7031 7032 /* ndi_devi_config_one */ 7033 if (child) { 7034 ASSERT(DEVI_BUSY_OWNED(vdip)); 7035 i_mdi_pm_post_config_one(child); 7036 return; 7037 } 7038 7039 /* devi_config_common */ 7040 ndi_devi_enter(vdip, &circ); 7041 cdip = ddi_get_child(vdip); 7042 while (cdip) { 7043 dev_info_t *next = ddi_get_next_sibling(cdip); 7044 7045 i_mdi_pm_post_config_one(cdip); 7046 cdip = next; 7047 } 7048 ndi_devi_exit(vdip, circ); 7049 } 7050 7051 static void 7052 i_mdi_pm_post_unconfig_one(dev_info_t *child) 7053 { 7054 mdi_client_t *ct; 7055 7056 ct = i_devi_get_client(child); 7057 if (ct == NULL) 7058 return; 7059 7060 MDI_CLIENT_LOCK(ct); 7061 while (MDI_CLIENT_IS_POWER_TRANSITION(ct)) 7062 cv_wait(&ct->ct_powerchange_cv, &ct->ct_mutex); 7063 7064 if (!ct->ct_powercnt_unconfig || ct->ct_powercnt_reset) { 7065 MDI_DEBUG(4, (MDI_NOTE, child, "not held\n")); 7066 MDI_CLIENT_UNLOCK(ct); 7067 return; 7068 } 7069 7070 /* failure detaching or another thread just attached it */ 7071 if ((MDI_CLIENT_IS_POWERED_DOWN(ct) && 7072 i_ddi_devi_attached(child)) || 7073 (!i_ddi_devi_attached(child) && 7074 !DEVI_IS_ATTACHING(child))) { 7075 MDI_DEBUG(4, (MDI_NOTE, child, "i_mdi_pm_reset_client\n")); 7076 i_mdi_pm_reset_client(ct); 7077 } else { 7078 mdi_pathinfo_t *pip, *next; 7079 int valid_path_count = 0; 7080 7081 MDI_DEBUG(4, (MDI_NOTE, child, "i_mdi_pm_rele_client\n")); 7082 pip = ct->ct_path_head; 7083 while (pip != NULL) { 7084 MDI_PI_LOCK(pip); 7085 next = (mdi_pathinfo_t *)MDI_PI(pip)->pi_client_link; 7086 if (MDI_PI_IS_ONLINE(pip) || MDI_PI_IS_STANDBY(pip)) 7087 valid_path_count ++; 7088 MDI_PI_UNLOCK(pip); 7089 pip = next; 7090 } 7091 i_mdi_pm_rele_client(ct, valid_path_count); 7092 ct->ct_powercnt_unconfig = 0; 7093 } 7094 7095 MDI_CLIENT_UNLOCK(ct); 7096 } 7097 7098 static void 7099 i_mdi_pm_post_unconfig(dev_info_t *vdip, dev_info_t *child, int held) 7100 { 7101 int circ; 7102 dev_info_t *cdip; 7103 7104 ASSERT(MDI_VHCI(vdip)); 7105 7106 if (!held) { 7107 MDI_DEBUG(4, (MDI_NOTE, vdip, "held = %d", held)); 7108 return; 7109 } 7110 7111 if (child) { 7112 ASSERT(DEVI_BUSY_OWNED(vdip)); 7113 i_mdi_pm_post_unconfig_one(child); 7114 return; 7115 } 7116 7117 ndi_devi_enter(vdip, &circ); 7118 cdip = ddi_get_child(vdip); 7119 while (cdip) { 7120 dev_info_t *next = ddi_get_next_sibling(cdip); 7121 7122 i_mdi_pm_post_unconfig_one(cdip); 7123 cdip = next; 7124 } 7125 ndi_devi_exit(vdip, circ); 7126 } 7127 7128 int 7129 mdi_power(dev_info_t *vdip, mdi_pm_op_t op, void *args, char *devnm, int flags) 7130 { 7131 int circ, ret = MDI_SUCCESS; 7132 dev_info_t *client_dip = NULL; 7133 mdi_client_t *ct; 7134 7135 /* 7136 * Handling ndi_devi_config_one and ndi_devi_unconfig_one. 7137 * Power up pHCI for the named client device. 7138 * Note: Before the client is enumerated under vhci by phci, 7139 * client_dip can be NULL. Then proceed to power up all the 7140 * pHCIs. 7141 */ 7142 if (devnm != NULL) { 7143 ndi_devi_enter(vdip, &circ); 7144 client_dip = ndi_devi_findchild(vdip, devnm); 7145 } 7146 7147 MDI_DEBUG(4, (MDI_NOTE, vdip, 7148 "op = %d %s %p", op, devnm ? devnm : "", (void *)client_dip)); 7149 7150 switch (op) { 7151 case MDI_PM_PRE_CONFIG: 7152 ret = i_mdi_pm_pre_config(vdip, client_dip); 7153 break; 7154 7155 case MDI_PM_PRE_UNCONFIG: 7156 ret = i_mdi_pm_pre_unconfig(vdip, client_dip, (int *)args, 7157 flags); 7158 break; 7159 7160 case MDI_PM_POST_CONFIG: 7161 i_mdi_pm_post_config(vdip, client_dip); 7162 break; 7163 7164 case MDI_PM_POST_UNCONFIG: 7165 i_mdi_pm_post_unconfig(vdip, client_dip, *(int *)args); 7166 break; 7167 7168 case MDI_PM_HOLD_POWER: 7169 case MDI_PM_RELE_POWER: 7170 ASSERT(args); 7171 7172 client_dip = (dev_info_t *)args; 7173 ASSERT(MDI_CLIENT(client_dip)); 7174 7175 ct = i_devi_get_client(client_dip); 7176 MDI_CLIENT_LOCK(ct); 7177 7178 if (op == MDI_PM_HOLD_POWER) { 7179 if (ct->ct_power_cnt == 0) { 7180 (void) i_mdi_power_all_phci(ct); 7181 MDI_DEBUG(4, (MDI_NOTE, client_dip, 7182 "i_mdi_pm_hold_client\n")); 7183 i_mdi_pm_hold_client(ct, ct->ct_path_count); 7184 } 7185 } else { 7186 if (DEVI_IS_ATTACHING(client_dip)) { 7187 MDI_DEBUG(4, (MDI_NOTE, client_dip, 7188 "i_mdi_pm_rele_client\n")); 7189 i_mdi_pm_rele_client(ct, ct->ct_path_count); 7190 } else { 7191 MDI_DEBUG(4, (MDI_NOTE, client_dip, 7192 "i_mdi_pm_reset_client\n")); 7193 i_mdi_pm_reset_client(ct); 7194 } 7195 } 7196 7197 MDI_CLIENT_UNLOCK(ct); 7198 break; 7199 7200 default: 7201 break; 7202 } 7203 7204 if (devnm) 7205 ndi_devi_exit(vdip, circ); 7206 7207 return (ret); 7208 } 7209 7210 int 7211 mdi_component_is_vhci(dev_info_t *dip, const char **mdi_class) 7212 { 7213 mdi_vhci_t *vhci; 7214 7215 if (!MDI_VHCI(dip)) 7216 return (MDI_FAILURE); 7217 7218 if (mdi_class) { 7219 vhci = DEVI(dip)->devi_mdi_xhci; 7220 ASSERT(vhci); 7221 *mdi_class = vhci->vh_class; 7222 } 7223 7224 return (MDI_SUCCESS); 7225 } 7226 7227 int 7228 mdi_component_is_phci(dev_info_t *dip, const char **mdi_class) 7229 { 7230 mdi_phci_t *phci; 7231 7232 if (!MDI_PHCI(dip)) 7233 return (MDI_FAILURE); 7234 7235 if (mdi_class) { 7236 phci = DEVI(dip)->devi_mdi_xhci; 7237 ASSERT(phci); 7238 *mdi_class = phci->ph_vhci->vh_class; 7239 } 7240 7241 return (MDI_SUCCESS); 7242 } 7243 7244 int 7245 mdi_component_is_client(dev_info_t *dip, const char **mdi_class) 7246 { 7247 mdi_client_t *client; 7248 7249 if (!MDI_CLIENT(dip)) 7250 return (MDI_FAILURE); 7251 7252 if (mdi_class) { 7253 client = DEVI(dip)->devi_mdi_client; 7254 ASSERT(client); 7255 *mdi_class = client->ct_vhci->vh_class; 7256 } 7257 7258 return (MDI_SUCCESS); 7259 } 7260 7261 void * 7262 mdi_client_get_vhci_private(dev_info_t *dip) 7263 { 7264 ASSERT(mdi_component_is_client(dip, NULL) == MDI_SUCCESS); 7265 if (mdi_component_is_client(dip, NULL) == MDI_SUCCESS) { 7266 mdi_client_t *ct; 7267 ct = i_devi_get_client(dip); 7268 return (ct->ct_vprivate); 7269 } 7270 return (NULL); 7271 } 7272 7273 void 7274 mdi_client_set_vhci_private(dev_info_t *dip, void *data) 7275 { 7276 ASSERT(mdi_component_is_client(dip, NULL) == MDI_SUCCESS); 7277 if (mdi_component_is_client(dip, NULL) == MDI_SUCCESS) { 7278 mdi_client_t *ct; 7279 ct = i_devi_get_client(dip); 7280 ct->ct_vprivate = data; 7281 } 7282 } 7283 /* 7284 * mdi_pi_get_vhci_private(): 7285 * Get the vhci private information associated with the 7286 * mdi_pathinfo node 7287 */ 7288 void * 7289 mdi_pi_get_vhci_private(mdi_pathinfo_t *pip) 7290 { 7291 caddr_t vprivate = NULL; 7292 if (pip) { 7293 vprivate = MDI_PI(pip)->pi_vprivate; 7294 } 7295 return (vprivate); 7296 } 7297 7298 /* 7299 * mdi_pi_set_vhci_private(): 7300 * Set the vhci private information in the mdi_pathinfo node 7301 */ 7302 void 7303 mdi_pi_set_vhci_private(mdi_pathinfo_t *pip, void *priv) 7304 { 7305 if (pip) { 7306 MDI_PI(pip)->pi_vprivate = priv; 7307 } 7308 } 7309 7310 /* 7311 * mdi_phci_get_vhci_private(): 7312 * Get the vhci private information associated with the 7313 * mdi_phci node 7314 */ 7315 void * 7316 mdi_phci_get_vhci_private(dev_info_t *dip) 7317 { 7318 ASSERT(mdi_component_is_phci(dip, NULL) == MDI_SUCCESS); 7319 if (mdi_component_is_phci(dip, NULL) == MDI_SUCCESS) { 7320 mdi_phci_t *ph; 7321 ph = i_devi_get_phci(dip); 7322 return (ph->ph_vprivate); 7323 } 7324 return (NULL); 7325 } 7326 7327 /* 7328 * mdi_phci_set_vhci_private(): 7329 * Set the vhci private information in the mdi_phci node 7330 */ 7331 void 7332 mdi_phci_set_vhci_private(dev_info_t *dip, void *priv) 7333 { 7334 ASSERT(mdi_component_is_phci(dip, NULL) == MDI_SUCCESS); 7335 if (mdi_component_is_phci(dip, NULL) == MDI_SUCCESS) { 7336 mdi_phci_t *ph; 7337 ph = i_devi_get_phci(dip); 7338 ph->ph_vprivate = priv; 7339 } 7340 } 7341 7342 int 7343 mdi_pi_ishidden(mdi_pathinfo_t *pip) 7344 { 7345 return (MDI_PI_FLAGS_IS_HIDDEN(pip)); 7346 } 7347 7348 int 7349 mdi_pi_device_isremoved(mdi_pathinfo_t *pip) 7350 { 7351 return (MDI_PI_FLAGS_IS_DEVICE_REMOVED(pip)); 7352 } 7353 7354 /* Return 1 if all client paths are device_removed */ 7355 static int 7356 i_mdi_client_all_devices_removed(mdi_client_t *ct) 7357 { 7358 mdi_pathinfo_t *pip; 7359 int all_devices_removed = 1; 7360 7361 MDI_CLIENT_LOCK(ct); 7362 for (pip = ct->ct_path_head; pip; 7363 pip = (mdi_pathinfo_t *)MDI_PI(pip)->pi_client_link) { 7364 if (!mdi_pi_device_isremoved(pip)) { 7365 all_devices_removed = 0; 7366 break; 7367 } 7368 } 7369 MDI_CLIENT_UNLOCK(ct); 7370 return (all_devices_removed); 7371 } 7372 7373 /* 7374 * When processing path hotunplug, represent device removal. 7375 */ 7376 int 7377 mdi_pi_device_remove(mdi_pathinfo_t *pip) 7378 { 7379 mdi_client_t *ct; 7380 7381 MDI_PI_LOCK(pip); 7382 if (mdi_pi_device_isremoved(pip)) { 7383 MDI_PI_UNLOCK(pip); 7384 return (0); 7385 } 7386 MDI_PI_FLAGS_SET_DEVICE_REMOVED(pip); 7387 MDI_PI_FLAGS_SET_HIDDEN(pip); 7388 MDI_PI_UNLOCK(pip); 7389 7390 /* 7391 * If all paths associated with the client are now DEVICE_REMOVED, 7392 * reflect DEVICE_REMOVED in the client. 7393 */ 7394 ct = MDI_PI(pip)->pi_client; 7395 if (ct && ct->ct_dip && i_mdi_client_all_devices_removed(ct)) 7396 (void) ndi_devi_device_remove(ct->ct_dip); 7397 else 7398 i_ddi_di_cache_invalidate(); 7399 7400 return (1); 7401 } 7402 7403 /* 7404 * When processing hotplug, if a path marked mdi_pi_device_isremoved() 7405 * is now accessible then this interfaces is used to represent device insertion. 7406 */ 7407 int 7408 mdi_pi_device_insert(mdi_pathinfo_t *pip) 7409 { 7410 MDI_PI_LOCK(pip); 7411 if (!mdi_pi_device_isremoved(pip)) { 7412 MDI_PI_UNLOCK(pip); 7413 return (0); 7414 } 7415 MDI_PI_FLAGS_CLR_DEVICE_REMOVED(pip); 7416 MDI_PI_FLAGS_CLR_HIDDEN(pip); 7417 MDI_PI_UNLOCK(pip); 7418 7419 i_ddi_di_cache_invalidate(); 7420 7421 return (1); 7422 } 7423 7424 /* 7425 * List of vhci class names: 7426 * A vhci class name must be in this list only if the corresponding vhci 7427 * driver intends to use the mdi provided bus config implementation 7428 * (i.e., mdi_vhci_bus_config()). 7429 */ 7430 static char *vhci_class_list[] = { MDI_HCI_CLASS_SCSI, MDI_HCI_CLASS_IB }; 7431 #define N_VHCI_CLASSES (sizeof (vhci_class_list) / sizeof (char *)) 7432 7433 /* 7434 * During boot time, the on-disk vhci cache for every vhci class is read 7435 * in the form of an nvlist and stored here. 7436 */ 7437 static nvlist_t *vhcache_nvl[N_VHCI_CLASSES]; 7438 7439 /* nvpair names in vhci cache nvlist */ 7440 #define MDI_VHCI_CACHE_VERSION 1 7441 #define MDI_NVPNAME_VERSION "version" 7442 #define MDI_NVPNAME_PHCIS "phcis" 7443 #define MDI_NVPNAME_CTADDRMAP "clientaddrmap" 7444 7445 /* 7446 * Given vhci class name, return its on-disk vhci cache filename. 7447 * Memory for the returned filename which includes the full path is allocated 7448 * by this function. 7449 */ 7450 static char * 7451 vhclass2vhcache_filename(char *vhclass) 7452 { 7453 char *filename; 7454 int len; 7455 static char *fmt = "/etc/devices/mdi_%s_cache"; 7456 7457 /* 7458 * fmt contains the on-disk vhci cache file name format; 7459 * for scsi_vhci the filename is "/etc/devices/mdi_scsi_vhci_cache". 7460 */ 7461 7462 /* the -1 below is to account for "%s" in the format string */ 7463 len = strlen(fmt) + strlen(vhclass) - 1; 7464 filename = kmem_alloc(len, KM_SLEEP); 7465 (void) snprintf(filename, len, fmt, vhclass); 7466 ASSERT(len == (strlen(filename) + 1)); 7467 return (filename); 7468 } 7469 7470 /* 7471 * initialize the vhci cache related data structures and read the on-disk 7472 * vhci cached data into memory. 7473 */ 7474 static void 7475 setup_vhci_cache(mdi_vhci_t *vh) 7476 { 7477 mdi_vhci_config_t *vhc; 7478 mdi_vhci_cache_t *vhcache; 7479 int i; 7480 nvlist_t *nvl = NULL; 7481 7482 vhc = kmem_zalloc(sizeof (mdi_vhci_config_t), KM_SLEEP); 7483 vh->vh_config = vhc; 7484 vhcache = &vhc->vhc_vhcache; 7485 7486 vhc->vhc_vhcache_filename = vhclass2vhcache_filename(vh->vh_class); 7487 7488 mutex_init(&vhc->vhc_lock, NULL, MUTEX_DEFAULT, NULL); 7489 cv_init(&vhc->vhc_cv, NULL, CV_DRIVER, NULL); 7490 7491 rw_init(&vhcache->vhcache_lock, NULL, RW_DRIVER, NULL); 7492 7493 /* 7494 * Create string hash; same as mod_hash_create_strhash() except that 7495 * we use NULL key destructor. 7496 */ 7497 vhcache->vhcache_client_hash = mod_hash_create_extended(vh->vh_class, 7498 mdi_bus_config_cache_hash_size, 7499 mod_hash_null_keydtor, mod_hash_null_valdtor, 7500 mod_hash_bystr, NULL, mod_hash_strkey_cmp, KM_SLEEP); 7501 7502 /* 7503 * The on-disk vhci cache is read during booting prior to the 7504 * lights-out period by mdi_read_devices_files(). 7505 */ 7506 for (i = 0; i < N_VHCI_CLASSES; i++) { 7507 if (strcmp(vhci_class_list[i], vh->vh_class) == 0) { 7508 nvl = vhcache_nvl[i]; 7509 vhcache_nvl[i] = NULL; 7510 break; 7511 } 7512 } 7513 7514 /* 7515 * this is to cover the case of some one manually causing unloading 7516 * (or detaching) and reloading (or attaching) of a vhci driver. 7517 */ 7518 if (nvl == NULL && modrootloaded) 7519 nvl = read_on_disk_vhci_cache(vh->vh_class); 7520 7521 if (nvl != NULL) { 7522 rw_enter(&vhcache->vhcache_lock, RW_WRITER); 7523 if (mainnvl_to_vhcache(vhcache, nvl) == MDI_SUCCESS) 7524 vhcache->vhcache_flags |= MDI_VHCI_CACHE_SETUP_DONE; 7525 else { 7526 cmn_err(CE_WARN, 7527 "%s: data file corrupted, will recreate", 7528 vhc->vhc_vhcache_filename); 7529 } 7530 rw_exit(&vhcache->vhcache_lock); 7531 nvlist_free(nvl); 7532 } 7533 7534 vhc->vhc_cbid = callb_add(stop_vhcache_flush_thread, vhc, 7535 CB_CL_UADMIN_PRE_VFS, "mdi_vhcache_flush"); 7536 7537 vhc->vhc_path_discovery_boot = mdi_path_discovery_boot; 7538 vhc->vhc_path_discovery_postboot = mdi_path_discovery_postboot; 7539 } 7540 7541 /* 7542 * free all vhci cache related resources 7543 */ 7544 static int 7545 destroy_vhci_cache(mdi_vhci_t *vh) 7546 { 7547 mdi_vhci_config_t *vhc = vh->vh_config; 7548 mdi_vhci_cache_t *vhcache = &vhc->vhc_vhcache; 7549 mdi_vhcache_phci_t *cphci, *cphci_next; 7550 mdi_vhcache_client_t *cct, *cct_next; 7551 mdi_vhcache_pathinfo_t *cpi, *cpi_next; 7552 7553 if (stop_vhcache_async_threads(vhc) != MDI_SUCCESS) 7554 return (MDI_FAILURE); 7555 7556 kmem_free(vhc->vhc_vhcache_filename, 7557 strlen(vhc->vhc_vhcache_filename) + 1); 7558 7559 mod_hash_destroy_strhash(vhcache->vhcache_client_hash); 7560 7561 for (cphci = vhcache->vhcache_phci_head; cphci != NULL; 7562 cphci = cphci_next) { 7563 cphci_next = cphci->cphci_next; 7564 free_vhcache_phci(cphci); 7565 } 7566 7567 for (cct = vhcache->vhcache_client_head; cct != NULL; cct = cct_next) { 7568 cct_next = cct->cct_next; 7569 for (cpi = cct->cct_cpi_head; cpi != NULL; cpi = cpi_next) { 7570 cpi_next = cpi->cpi_next; 7571 free_vhcache_pathinfo(cpi); 7572 } 7573 free_vhcache_client(cct); 7574 } 7575 7576 rw_destroy(&vhcache->vhcache_lock); 7577 7578 mutex_destroy(&vhc->vhc_lock); 7579 cv_destroy(&vhc->vhc_cv); 7580 kmem_free(vhc, sizeof (mdi_vhci_config_t)); 7581 return (MDI_SUCCESS); 7582 } 7583 7584 /* 7585 * Stop all vhci cache related async threads and free their resources. 7586 */ 7587 static int 7588 stop_vhcache_async_threads(mdi_vhci_config_t *vhc) 7589 { 7590 mdi_async_client_config_t *acc, *acc_next; 7591 7592 mutex_enter(&vhc->vhc_lock); 7593 vhc->vhc_flags |= MDI_VHC_EXIT; 7594 ASSERT(vhc->vhc_acc_thrcount >= 0); 7595 cv_broadcast(&vhc->vhc_cv); 7596 7597 while ((vhc->vhc_flags & MDI_VHC_VHCACHE_FLUSH_THREAD) || 7598 vhc->vhc_acc_thrcount != 0) { 7599 mutex_exit(&vhc->vhc_lock); 7600 delay_random(mdi_delay); 7601 mutex_enter(&vhc->vhc_lock); 7602 } 7603 7604 vhc->vhc_flags &= ~MDI_VHC_EXIT; 7605 7606 for (acc = vhc->vhc_acc_list_head; acc != NULL; acc = acc_next) { 7607 acc_next = acc->acc_next; 7608 free_async_client_config(acc); 7609 } 7610 vhc->vhc_acc_list_head = NULL; 7611 vhc->vhc_acc_list_tail = NULL; 7612 vhc->vhc_acc_count = 0; 7613 7614 if (vhc->vhc_flags & MDI_VHC_VHCACHE_DIRTY) { 7615 vhc->vhc_flags &= ~MDI_VHC_VHCACHE_DIRTY; 7616 mutex_exit(&vhc->vhc_lock); 7617 if (flush_vhcache(vhc, 0) != MDI_SUCCESS) { 7618 vhcache_dirty(vhc); 7619 return (MDI_FAILURE); 7620 } 7621 } else 7622 mutex_exit(&vhc->vhc_lock); 7623 7624 if (callb_delete(vhc->vhc_cbid) != 0) 7625 return (MDI_FAILURE); 7626 7627 return (MDI_SUCCESS); 7628 } 7629 7630 /* 7631 * Stop vhci cache flush thread 7632 */ 7633 /* ARGSUSED */ 7634 static boolean_t 7635 stop_vhcache_flush_thread(void *arg, int code) 7636 { 7637 mdi_vhci_config_t *vhc = (mdi_vhci_config_t *)arg; 7638 7639 mutex_enter(&vhc->vhc_lock); 7640 vhc->vhc_flags |= MDI_VHC_EXIT; 7641 cv_broadcast(&vhc->vhc_cv); 7642 7643 while (vhc->vhc_flags & MDI_VHC_VHCACHE_FLUSH_THREAD) { 7644 mutex_exit(&vhc->vhc_lock); 7645 delay_random(mdi_delay); 7646 mutex_enter(&vhc->vhc_lock); 7647 } 7648 7649 if (vhc->vhc_flags & MDI_VHC_VHCACHE_DIRTY) { 7650 vhc->vhc_flags &= ~MDI_VHC_VHCACHE_DIRTY; 7651 mutex_exit(&vhc->vhc_lock); 7652 (void) flush_vhcache(vhc, 1); 7653 } else 7654 mutex_exit(&vhc->vhc_lock); 7655 7656 return (B_TRUE); 7657 } 7658 7659 /* 7660 * Enqueue the vhcache phci (cphci) at the tail of the list 7661 */ 7662 static void 7663 enqueue_vhcache_phci(mdi_vhci_cache_t *vhcache, mdi_vhcache_phci_t *cphci) 7664 { 7665 cphci->cphci_next = NULL; 7666 if (vhcache->vhcache_phci_head == NULL) 7667 vhcache->vhcache_phci_head = cphci; 7668 else 7669 vhcache->vhcache_phci_tail->cphci_next = cphci; 7670 vhcache->vhcache_phci_tail = cphci; 7671 } 7672 7673 /* 7674 * Enqueue the vhcache pathinfo (cpi) at the tail of the list 7675 */ 7676 static void 7677 enqueue_tail_vhcache_pathinfo(mdi_vhcache_client_t *cct, 7678 mdi_vhcache_pathinfo_t *cpi) 7679 { 7680 cpi->cpi_next = NULL; 7681 if (cct->cct_cpi_head == NULL) 7682 cct->cct_cpi_head = cpi; 7683 else 7684 cct->cct_cpi_tail->cpi_next = cpi; 7685 cct->cct_cpi_tail = cpi; 7686 } 7687 7688 /* 7689 * Enqueue the vhcache pathinfo (cpi) at the correct location in the 7690 * ordered list. All cpis which do not have MDI_CPI_HINT_PATH_DOES_NOT_EXIST 7691 * flag set come at the beginning of the list. All cpis which have this 7692 * flag set come at the end of the list. 7693 */ 7694 static void 7695 enqueue_vhcache_pathinfo(mdi_vhcache_client_t *cct, 7696 mdi_vhcache_pathinfo_t *newcpi) 7697 { 7698 mdi_vhcache_pathinfo_t *cpi, *prev_cpi; 7699 7700 if (cct->cct_cpi_head == NULL || 7701 (newcpi->cpi_flags & MDI_CPI_HINT_PATH_DOES_NOT_EXIST)) 7702 enqueue_tail_vhcache_pathinfo(cct, newcpi); 7703 else { 7704 for (cpi = cct->cct_cpi_head, prev_cpi = NULL; cpi != NULL && 7705 !(cpi->cpi_flags & MDI_CPI_HINT_PATH_DOES_NOT_EXIST); 7706 prev_cpi = cpi, cpi = cpi->cpi_next) 7707 ; 7708 7709 if (prev_cpi == NULL) 7710 cct->cct_cpi_head = newcpi; 7711 else 7712 prev_cpi->cpi_next = newcpi; 7713 7714 newcpi->cpi_next = cpi; 7715 7716 if (cpi == NULL) 7717 cct->cct_cpi_tail = newcpi; 7718 } 7719 } 7720 7721 /* 7722 * Enqueue the vhcache client (cct) at the tail of the list 7723 */ 7724 static void 7725 enqueue_vhcache_client(mdi_vhci_cache_t *vhcache, 7726 mdi_vhcache_client_t *cct) 7727 { 7728 cct->cct_next = NULL; 7729 if (vhcache->vhcache_client_head == NULL) 7730 vhcache->vhcache_client_head = cct; 7731 else 7732 vhcache->vhcache_client_tail->cct_next = cct; 7733 vhcache->vhcache_client_tail = cct; 7734 } 7735 7736 static void 7737 free_string_array(char **str, int nelem) 7738 { 7739 int i; 7740 7741 if (str) { 7742 for (i = 0; i < nelem; i++) { 7743 if (str[i]) 7744 kmem_free(str[i], strlen(str[i]) + 1); 7745 } 7746 kmem_free(str, sizeof (char *) * nelem); 7747 } 7748 } 7749 7750 static void 7751 free_vhcache_phci(mdi_vhcache_phci_t *cphci) 7752 { 7753 kmem_free(cphci->cphci_path, strlen(cphci->cphci_path) + 1); 7754 kmem_free(cphci, sizeof (*cphci)); 7755 } 7756 7757 static void 7758 free_vhcache_pathinfo(mdi_vhcache_pathinfo_t *cpi) 7759 { 7760 kmem_free(cpi->cpi_addr, strlen(cpi->cpi_addr) + 1); 7761 kmem_free(cpi, sizeof (*cpi)); 7762 } 7763 7764 static void 7765 free_vhcache_client(mdi_vhcache_client_t *cct) 7766 { 7767 kmem_free(cct->cct_name_addr, strlen(cct->cct_name_addr) + 1); 7768 kmem_free(cct, sizeof (*cct)); 7769 } 7770 7771 static char * 7772 vhcache_mknameaddr(char *ct_name, char *ct_addr, int *ret_len) 7773 { 7774 char *name_addr; 7775 int len; 7776 7777 len = strlen(ct_name) + strlen(ct_addr) + 2; 7778 name_addr = kmem_alloc(len, KM_SLEEP); 7779 (void) snprintf(name_addr, len, "%s@%s", ct_name, ct_addr); 7780 7781 if (ret_len) 7782 *ret_len = len; 7783 return (name_addr); 7784 } 7785 7786 /* 7787 * Copy the contents of paddrnvl to vhci cache. 7788 * paddrnvl nvlist contains path information for a vhci client. 7789 * See the comment in mainnvl_to_vhcache() for the format of this nvlist. 7790 */ 7791 static void 7792 paddrnvl_to_vhcache(nvlist_t *nvl, mdi_vhcache_phci_t *cphci_list[], 7793 mdi_vhcache_client_t *cct) 7794 { 7795 nvpair_t *nvp = NULL; 7796 mdi_vhcache_pathinfo_t *cpi; 7797 uint_t nelem; 7798 uint32_t *val; 7799 7800 while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) { 7801 ASSERT(nvpair_type(nvp) == DATA_TYPE_UINT32_ARRAY); 7802 cpi = kmem_zalloc(sizeof (*cpi), KM_SLEEP); 7803 cpi->cpi_addr = i_ddi_strdup(nvpair_name(nvp), KM_SLEEP); 7804 (void) nvpair_value_uint32_array(nvp, &val, &nelem); 7805 ASSERT(nelem == 2); 7806 cpi->cpi_cphci = cphci_list[val[0]]; 7807 cpi->cpi_flags = val[1]; 7808 enqueue_tail_vhcache_pathinfo(cct, cpi); 7809 } 7810 } 7811 7812 /* 7813 * Copy the contents of caddrmapnvl to vhci cache. 7814 * caddrmapnvl nvlist contains vhci client address to phci client address 7815 * mappings. See the comment in mainnvl_to_vhcache() for the format of 7816 * this nvlist. 7817 */ 7818 static void 7819 caddrmapnvl_to_vhcache(mdi_vhci_cache_t *vhcache, nvlist_t *nvl, 7820 mdi_vhcache_phci_t *cphci_list[]) 7821 { 7822 nvpair_t *nvp = NULL; 7823 nvlist_t *paddrnvl; 7824 mdi_vhcache_client_t *cct; 7825 7826 while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) { 7827 ASSERT(nvpair_type(nvp) == DATA_TYPE_NVLIST); 7828 cct = kmem_zalloc(sizeof (*cct), KM_SLEEP); 7829 cct->cct_name_addr = i_ddi_strdup(nvpair_name(nvp), KM_SLEEP); 7830 (void) nvpair_value_nvlist(nvp, &paddrnvl); 7831 paddrnvl_to_vhcache(paddrnvl, cphci_list, cct); 7832 /* the client must contain at least one path */ 7833 ASSERT(cct->cct_cpi_head != NULL); 7834 7835 enqueue_vhcache_client(vhcache, cct); 7836 (void) mod_hash_insert(vhcache->vhcache_client_hash, 7837 (mod_hash_key_t)cct->cct_name_addr, (mod_hash_val_t)cct); 7838 } 7839 } 7840 7841 /* 7842 * Copy the contents of the main nvlist to vhci cache. 7843 * 7844 * VHCI busconfig cached data is stored in the form of a nvlist on the disk. 7845 * The nvlist contains the mappings between the vhci client addresses and 7846 * their corresponding phci client addresses. 7847 * 7848 * The structure of the nvlist is as follows: 7849 * 7850 * Main nvlist: 7851 * NAME TYPE DATA 7852 * version int32 version number 7853 * phcis string array array of phci paths 7854 * clientaddrmap nvlist_t c2paddrs_nvl (see below) 7855 * 7856 * structure of c2paddrs_nvl: 7857 * NAME TYPE DATA 7858 * caddr1 nvlist_t paddrs_nvl1 7859 * caddr2 nvlist_t paddrs_nvl2 7860 * ... 7861 * where caddr1, caddr2, ... are vhci client name and addresses in the 7862 * form of "<clientname>@<clientaddress>". 7863 * (for example: "ssd@2000002037cd9f72"); 7864 * paddrs_nvl1, paddrs_nvl2, .. are nvlists that contain path information. 7865 * 7866 * structure of paddrs_nvl: 7867 * NAME TYPE DATA 7868 * pi_addr1 uint32_array (phci-id, cpi_flags) 7869 * pi_addr2 uint32_array (phci-id, cpi_flags) 7870 * ... 7871 * where pi_addr1, pi_addr2, ... are bus specific addresses of pathinfo nodes 7872 * (so called pi_addrs, for example: "w2100002037cd9f72,0"); 7873 * phci-ids are integers that identify pHCIs to which the 7874 * the bus specific address belongs to. These integers are used as an index 7875 * into to the phcis string array in the main nvlist to get the pHCI path. 7876 */ 7877 static int 7878 mainnvl_to_vhcache(mdi_vhci_cache_t *vhcache, nvlist_t *nvl) 7879 { 7880 char **phcis, **phci_namep; 7881 uint_t nphcis; 7882 mdi_vhcache_phci_t *cphci, **cphci_list; 7883 nvlist_t *caddrmapnvl; 7884 int32_t ver; 7885 int i; 7886 size_t cphci_list_size; 7887 7888 ASSERT(RW_WRITE_HELD(&vhcache->vhcache_lock)); 7889 7890 if (nvlist_lookup_int32(nvl, MDI_NVPNAME_VERSION, &ver) != 0 || 7891 ver != MDI_VHCI_CACHE_VERSION) 7892 return (MDI_FAILURE); 7893 7894 if (nvlist_lookup_string_array(nvl, MDI_NVPNAME_PHCIS, &phcis, 7895 &nphcis) != 0) 7896 return (MDI_SUCCESS); 7897 7898 ASSERT(nphcis > 0); 7899 7900 cphci_list_size = sizeof (mdi_vhcache_phci_t *) * nphcis; 7901 cphci_list = kmem_alloc(cphci_list_size, KM_SLEEP); 7902 for (i = 0, phci_namep = phcis; i < nphcis; i++, phci_namep++) { 7903 cphci = kmem_zalloc(sizeof (mdi_vhcache_phci_t), KM_SLEEP); 7904 cphci->cphci_path = i_ddi_strdup(*phci_namep, KM_SLEEP); 7905 enqueue_vhcache_phci(vhcache, cphci); 7906 cphci_list[i] = cphci; 7907 } 7908 7909 ASSERT(vhcache->vhcache_phci_head != NULL); 7910 7911 if (nvlist_lookup_nvlist(nvl, MDI_NVPNAME_CTADDRMAP, &caddrmapnvl) == 0) 7912 caddrmapnvl_to_vhcache(vhcache, caddrmapnvl, cphci_list); 7913 7914 kmem_free(cphci_list, cphci_list_size); 7915 return (MDI_SUCCESS); 7916 } 7917 7918 /* 7919 * Build paddrnvl for the specified client using the information in the 7920 * vhci cache and add it to the caddrmapnnvl. 7921 * Returns 0 on success, errno on failure. 7922 */ 7923 static int 7924 vhcache_to_paddrnvl(mdi_vhci_cache_t *vhcache, mdi_vhcache_client_t *cct, 7925 nvlist_t *caddrmapnvl) 7926 { 7927 mdi_vhcache_pathinfo_t *cpi; 7928 nvlist_t *nvl; 7929 int err; 7930 uint32_t val[2]; 7931 7932 ASSERT(RW_LOCK_HELD(&vhcache->vhcache_lock)); 7933 7934 if ((err = nvlist_alloc(&nvl, 0, KM_SLEEP)) != 0) 7935 return (err); 7936 7937 for (cpi = cct->cct_cpi_head; cpi != NULL; cpi = cpi->cpi_next) { 7938 val[0] = cpi->cpi_cphci->cphci_id; 7939 val[1] = cpi->cpi_flags; 7940 if ((err = nvlist_add_uint32_array(nvl, cpi->cpi_addr, val, 2)) 7941 != 0) 7942 goto out; 7943 } 7944 7945 err = nvlist_add_nvlist(caddrmapnvl, cct->cct_name_addr, nvl); 7946 out: 7947 nvlist_free(nvl); 7948 return (err); 7949 } 7950 7951 /* 7952 * Build caddrmapnvl using the information in the vhci cache 7953 * and add it to the mainnvl. 7954 * Returns 0 on success, errno on failure. 7955 */ 7956 static int 7957 vhcache_to_caddrmapnvl(mdi_vhci_cache_t *vhcache, nvlist_t *mainnvl) 7958 { 7959 mdi_vhcache_client_t *cct; 7960 nvlist_t *nvl; 7961 int err; 7962 7963 ASSERT(RW_LOCK_HELD(&vhcache->vhcache_lock)); 7964 7965 if ((err = nvlist_alloc(&nvl, NV_UNIQUE_NAME, KM_SLEEP)) != 0) 7966 return (err); 7967 7968 for (cct = vhcache->vhcache_client_head; cct != NULL; 7969 cct = cct->cct_next) { 7970 if ((err = vhcache_to_paddrnvl(vhcache, cct, nvl)) != 0) 7971 goto out; 7972 } 7973 7974 err = nvlist_add_nvlist(mainnvl, MDI_NVPNAME_CTADDRMAP, nvl); 7975 out: 7976 nvlist_free(nvl); 7977 return (err); 7978 } 7979 7980 /* 7981 * Build nvlist using the information in the vhci cache. 7982 * See the comment in mainnvl_to_vhcache() for the format of the nvlist. 7983 * Returns nvl on success, NULL on failure. 7984 */ 7985 static nvlist_t * 7986 vhcache_to_mainnvl(mdi_vhci_cache_t *vhcache) 7987 { 7988 mdi_vhcache_phci_t *cphci; 7989 uint_t phci_count; 7990 char **phcis; 7991 nvlist_t *nvl; 7992 int err, i; 7993 7994 if ((err = nvlist_alloc(&nvl, NV_UNIQUE_NAME, KM_SLEEP)) != 0) { 7995 nvl = NULL; 7996 goto out; 7997 } 7998 7999 if ((err = nvlist_add_int32(nvl, MDI_NVPNAME_VERSION, 8000 MDI_VHCI_CACHE_VERSION)) != 0) 8001 goto out; 8002 8003 rw_enter(&vhcache->vhcache_lock, RW_READER); 8004 if (vhcache->vhcache_phci_head == NULL) { 8005 rw_exit(&vhcache->vhcache_lock); 8006 return (nvl); 8007 } 8008 8009 phci_count = 0; 8010 for (cphci = vhcache->vhcache_phci_head; cphci != NULL; 8011 cphci = cphci->cphci_next) 8012 cphci->cphci_id = phci_count++; 8013 8014 /* build phci pathname list */ 8015 phcis = kmem_alloc(sizeof (char *) * phci_count, KM_SLEEP); 8016 for (cphci = vhcache->vhcache_phci_head, i = 0; cphci != NULL; 8017 cphci = cphci->cphci_next, i++) 8018 phcis[i] = i_ddi_strdup(cphci->cphci_path, KM_SLEEP); 8019 8020 err = nvlist_add_string_array(nvl, MDI_NVPNAME_PHCIS, phcis, 8021 phci_count); 8022 free_string_array(phcis, phci_count); 8023 8024 if (err == 0 && 8025 (err = vhcache_to_caddrmapnvl(vhcache, nvl)) == 0) { 8026 rw_exit(&vhcache->vhcache_lock); 8027 return (nvl); 8028 } 8029 8030 rw_exit(&vhcache->vhcache_lock); 8031 out: 8032 nvlist_free(nvl); 8033 return (NULL); 8034 } 8035 8036 /* 8037 * Lookup vhcache phci structure for the specified phci path. 8038 */ 8039 static mdi_vhcache_phci_t * 8040 lookup_vhcache_phci_by_name(mdi_vhci_cache_t *vhcache, char *phci_path) 8041 { 8042 mdi_vhcache_phci_t *cphci; 8043 8044 ASSERT(RW_LOCK_HELD(&vhcache->vhcache_lock)); 8045 8046 for (cphci = vhcache->vhcache_phci_head; cphci != NULL; 8047 cphci = cphci->cphci_next) { 8048 if (strcmp(cphci->cphci_path, phci_path) == 0) 8049 return (cphci); 8050 } 8051 8052 return (NULL); 8053 } 8054 8055 /* 8056 * Lookup vhcache phci structure for the specified phci. 8057 */ 8058 static mdi_vhcache_phci_t * 8059 lookup_vhcache_phci_by_addr(mdi_vhci_cache_t *vhcache, mdi_phci_t *ph) 8060 { 8061 mdi_vhcache_phci_t *cphci; 8062 8063 ASSERT(RW_LOCK_HELD(&vhcache->vhcache_lock)); 8064 8065 for (cphci = vhcache->vhcache_phci_head; cphci != NULL; 8066 cphci = cphci->cphci_next) { 8067 if (cphci->cphci_phci == ph) 8068 return (cphci); 8069 } 8070 8071 return (NULL); 8072 } 8073 8074 /* 8075 * Add the specified phci to the vhci cache if not already present. 8076 */ 8077 static void 8078 vhcache_phci_add(mdi_vhci_config_t *vhc, mdi_phci_t *ph) 8079 { 8080 mdi_vhci_cache_t *vhcache = &vhc->vhc_vhcache; 8081 mdi_vhcache_phci_t *cphci; 8082 char *pathname; 8083 int cache_updated; 8084 8085 rw_enter(&vhcache->vhcache_lock, RW_WRITER); 8086 8087 pathname = kmem_alloc(MAXPATHLEN, KM_SLEEP); 8088 (void) ddi_pathname(ph->ph_dip, pathname); 8089 if ((cphci = lookup_vhcache_phci_by_name(vhcache, pathname)) 8090 != NULL) { 8091 cphci->cphci_phci = ph; 8092 cache_updated = 0; 8093 } else { 8094 cphci = kmem_zalloc(sizeof (*cphci), KM_SLEEP); 8095 cphci->cphci_path = i_ddi_strdup(pathname, KM_SLEEP); 8096 cphci->cphci_phci = ph; 8097 enqueue_vhcache_phci(vhcache, cphci); 8098 cache_updated = 1; 8099 } 8100 8101 rw_exit(&vhcache->vhcache_lock); 8102 8103 /* 8104 * Since a new phci has been added, reset 8105 * vhc_path_discovery_cutoff_time to allow for discovery of paths 8106 * during next vhcache_discover_paths(). 8107 */ 8108 mutex_enter(&vhc->vhc_lock); 8109 vhc->vhc_path_discovery_cutoff_time = 0; 8110 mutex_exit(&vhc->vhc_lock); 8111 8112 kmem_free(pathname, MAXPATHLEN); 8113 if (cache_updated) 8114 vhcache_dirty(vhc); 8115 } 8116 8117 /* 8118 * Remove the reference to the specified phci from the vhci cache. 8119 */ 8120 static void 8121 vhcache_phci_remove(mdi_vhci_config_t *vhc, mdi_phci_t *ph) 8122 { 8123 mdi_vhci_cache_t *vhcache = &vhc->vhc_vhcache; 8124 mdi_vhcache_phci_t *cphci; 8125 8126 rw_enter(&vhcache->vhcache_lock, RW_WRITER); 8127 if ((cphci = lookup_vhcache_phci_by_addr(vhcache, ph)) != NULL) { 8128 /* do not remove the actual mdi_vhcache_phci structure */ 8129 cphci->cphci_phci = NULL; 8130 } 8131 rw_exit(&vhcache->vhcache_lock); 8132 } 8133 8134 static void 8135 init_vhcache_lookup_token(mdi_vhcache_lookup_token_t *dst, 8136 mdi_vhcache_lookup_token_t *src) 8137 { 8138 if (src == NULL) { 8139 dst->lt_cct = NULL; 8140 dst->lt_cct_lookup_time = 0; 8141 } else { 8142 dst->lt_cct = src->lt_cct; 8143 dst->lt_cct_lookup_time = src->lt_cct_lookup_time; 8144 } 8145 } 8146 8147 /* 8148 * Look up vhcache client for the specified client. 8149 */ 8150 static mdi_vhcache_client_t * 8151 lookup_vhcache_client(mdi_vhci_cache_t *vhcache, char *ct_name, char *ct_addr, 8152 mdi_vhcache_lookup_token_t *token) 8153 { 8154 mod_hash_val_t hv; 8155 char *name_addr; 8156 int len; 8157 8158 ASSERT(RW_LOCK_HELD(&vhcache->vhcache_lock)); 8159 8160 /* 8161 * If no vhcache clean occurred since the last lookup, we can 8162 * simply return the cct from the last lookup operation. 8163 * It works because ccts are never freed except during the vhcache 8164 * cleanup operation. 8165 */ 8166 if (token != NULL && 8167 vhcache->vhcache_clean_time < token->lt_cct_lookup_time) 8168 return (token->lt_cct); 8169 8170 name_addr = vhcache_mknameaddr(ct_name, ct_addr, &len); 8171 if (mod_hash_find(vhcache->vhcache_client_hash, 8172 (mod_hash_key_t)name_addr, &hv) == 0) { 8173 if (token) { 8174 token->lt_cct = (mdi_vhcache_client_t *)hv; 8175 token->lt_cct_lookup_time = ddi_get_lbolt64(); 8176 } 8177 } else { 8178 if (token) { 8179 token->lt_cct = NULL; 8180 token->lt_cct_lookup_time = 0; 8181 } 8182 hv = NULL; 8183 } 8184 kmem_free(name_addr, len); 8185 return ((mdi_vhcache_client_t *)hv); 8186 } 8187 8188 /* 8189 * Add the specified path to the vhci cache if not already present. 8190 * Also add the vhcache client for the client corresponding to this path 8191 * if it doesn't already exist. 8192 */ 8193 static void 8194 vhcache_pi_add(mdi_vhci_config_t *vhc, struct mdi_pathinfo *pip) 8195 { 8196 mdi_vhci_cache_t *vhcache = &vhc->vhc_vhcache; 8197 mdi_vhcache_client_t *cct; 8198 mdi_vhcache_pathinfo_t *cpi; 8199 mdi_phci_t *ph = pip->pi_phci; 8200 mdi_client_t *ct = pip->pi_client; 8201 int cache_updated = 0; 8202 8203 rw_enter(&vhcache->vhcache_lock, RW_WRITER); 8204 8205 /* if vhcache client for this pip doesn't already exist, add it */ 8206 if ((cct = lookup_vhcache_client(vhcache, ct->ct_drvname, ct->ct_guid, 8207 NULL)) == NULL) { 8208 cct = kmem_zalloc(sizeof (*cct), KM_SLEEP); 8209 cct->cct_name_addr = vhcache_mknameaddr(ct->ct_drvname, 8210 ct->ct_guid, NULL); 8211 enqueue_vhcache_client(vhcache, cct); 8212 (void) mod_hash_insert(vhcache->vhcache_client_hash, 8213 (mod_hash_key_t)cct->cct_name_addr, (mod_hash_val_t)cct); 8214 cache_updated = 1; 8215 } 8216 8217 for (cpi = cct->cct_cpi_head; cpi != NULL; cpi = cpi->cpi_next) { 8218 if (cpi->cpi_cphci->cphci_phci == ph && 8219 strcmp(cpi->cpi_addr, pip->pi_addr) == 0) { 8220 cpi->cpi_pip = pip; 8221 if (cpi->cpi_flags & MDI_CPI_HINT_PATH_DOES_NOT_EXIST) { 8222 cpi->cpi_flags &= 8223 ~MDI_CPI_HINT_PATH_DOES_NOT_EXIST; 8224 sort_vhcache_paths(cct); 8225 cache_updated = 1; 8226 } 8227 break; 8228 } 8229 } 8230 8231 if (cpi == NULL) { 8232 cpi = kmem_zalloc(sizeof (*cpi), KM_SLEEP); 8233 cpi->cpi_addr = i_ddi_strdup(pip->pi_addr, KM_SLEEP); 8234 cpi->cpi_cphci = lookup_vhcache_phci_by_addr(vhcache, ph); 8235 ASSERT(cpi->cpi_cphci != NULL); 8236 cpi->cpi_pip = pip; 8237 enqueue_vhcache_pathinfo(cct, cpi); 8238 cache_updated = 1; 8239 } 8240 8241 rw_exit(&vhcache->vhcache_lock); 8242 8243 if (cache_updated) 8244 vhcache_dirty(vhc); 8245 } 8246 8247 /* 8248 * Remove the reference to the specified path from the vhci cache. 8249 */ 8250 static void 8251 vhcache_pi_remove(mdi_vhci_config_t *vhc, struct mdi_pathinfo *pip) 8252 { 8253 mdi_vhci_cache_t *vhcache = &vhc->vhc_vhcache; 8254 mdi_client_t *ct = pip->pi_client; 8255 mdi_vhcache_client_t *cct; 8256 mdi_vhcache_pathinfo_t *cpi; 8257 8258 rw_enter(&vhcache->vhcache_lock, RW_WRITER); 8259 if ((cct = lookup_vhcache_client(vhcache, ct->ct_drvname, ct->ct_guid, 8260 NULL)) != NULL) { 8261 for (cpi = cct->cct_cpi_head; cpi != NULL; 8262 cpi = cpi->cpi_next) { 8263 if (cpi->cpi_pip == pip) { 8264 cpi->cpi_pip = NULL; 8265 break; 8266 } 8267 } 8268 } 8269 rw_exit(&vhcache->vhcache_lock); 8270 } 8271 8272 /* 8273 * Flush the vhci cache to disk. 8274 * Returns MDI_SUCCESS on success, MDI_FAILURE on failure. 8275 */ 8276 static int 8277 flush_vhcache(mdi_vhci_config_t *vhc, int force_flag) 8278 { 8279 nvlist_t *nvl; 8280 int err; 8281 int rv; 8282 8283 /* 8284 * It is possible that the system may shutdown before 8285 * i_ddi_io_initialized (during stmsboot for example). To allow for 8286 * flushing the cache in this case do not check for 8287 * i_ddi_io_initialized when force flag is set. 8288 */ 8289 if (force_flag == 0 && !i_ddi_io_initialized()) 8290 return (MDI_FAILURE); 8291 8292 if ((nvl = vhcache_to_mainnvl(&vhc->vhc_vhcache)) != NULL) { 8293 err = fwrite_nvlist(vhc->vhc_vhcache_filename, nvl); 8294 nvlist_free(nvl); 8295 } else 8296 err = EFAULT; 8297 8298 rv = MDI_SUCCESS; 8299 mutex_enter(&vhc->vhc_lock); 8300 if (err != 0) { 8301 if (err == EROFS) { 8302 vhc->vhc_flags |= MDI_VHC_READONLY_FS; 8303 vhc->vhc_flags &= ~(MDI_VHC_VHCACHE_FLUSH_ERROR | 8304 MDI_VHC_VHCACHE_DIRTY); 8305 } else { 8306 if (!(vhc->vhc_flags & MDI_VHC_VHCACHE_FLUSH_ERROR)) { 8307 cmn_err(CE_CONT, "%s: update failed\n", 8308 vhc->vhc_vhcache_filename); 8309 vhc->vhc_flags |= MDI_VHC_VHCACHE_FLUSH_ERROR; 8310 } 8311 rv = MDI_FAILURE; 8312 } 8313 } else if (vhc->vhc_flags & MDI_VHC_VHCACHE_FLUSH_ERROR) { 8314 cmn_err(CE_CONT, 8315 "%s: update now ok\n", vhc->vhc_vhcache_filename); 8316 vhc->vhc_flags &= ~MDI_VHC_VHCACHE_FLUSH_ERROR; 8317 } 8318 mutex_exit(&vhc->vhc_lock); 8319 8320 return (rv); 8321 } 8322 8323 /* 8324 * Call flush_vhcache() to flush the vhci cache at the scheduled time. 8325 * Exits itself if left idle for the idle timeout period. 8326 */ 8327 static void 8328 vhcache_flush_thread(void *arg) 8329 { 8330 mdi_vhci_config_t *vhc = (mdi_vhci_config_t *)arg; 8331 clock_t idle_time, quit_at_ticks; 8332 callb_cpr_t cprinfo; 8333 8334 /* number of seconds to sleep idle before exiting */ 8335 idle_time = mdi_vhcache_flush_daemon_idle_time * TICKS_PER_SECOND; 8336 8337 CALLB_CPR_INIT(&cprinfo, &vhc->vhc_lock, callb_generic_cpr, 8338 "mdi_vhcache_flush"); 8339 mutex_enter(&vhc->vhc_lock); 8340 for (; ; ) { 8341 while (!(vhc->vhc_flags & MDI_VHC_EXIT) && 8342 (vhc->vhc_flags & MDI_VHC_VHCACHE_DIRTY)) { 8343 if (ddi_get_lbolt() < vhc->vhc_flush_at_ticks) { 8344 CALLB_CPR_SAFE_BEGIN(&cprinfo); 8345 (void) cv_timedwait(&vhc->vhc_cv, 8346 &vhc->vhc_lock, vhc->vhc_flush_at_ticks); 8347 CALLB_CPR_SAFE_END(&cprinfo, &vhc->vhc_lock); 8348 } else { 8349 vhc->vhc_flags &= ~MDI_VHC_VHCACHE_DIRTY; 8350 mutex_exit(&vhc->vhc_lock); 8351 8352 if (flush_vhcache(vhc, 0) != MDI_SUCCESS) 8353 vhcache_dirty(vhc); 8354 8355 mutex_enter(&vhc->vhc_lock); 8356 } 8357 } 8358 8359 quit_at_ticks = ddi_get_lbolt() + idle_time; 8360 8361 while (!(vhc->vhc_flags & MDI_VHC_EXIT) && 8362 !(vhc->vhc_flags & MDI_VHC_VHCACHE_DIRTY) && 8363 ddi_get_lbolt() < quit_at_ticks) { 8364 CALLB_CPR_SAFE_BEGIN(&cprinfo); 8365 (void) cv_timedwait(&vhc->vhc_cv, &vhc->vhc_lock, 8366 quit_at_ticks); 8367 CALLB_CPR_SAFE_END(&cprinfo, &vhc->vhc_lock); 8368 } 8369 8370 if ((vhc->vhc_flags & MDI_VHC_EXIT) || 8371 !(vhc->vhc_flags & MDI_VHC_VHCACHE_DIRTY)) 8372 goto out; 8373 } 8374 8375 out: 8376 vhc->vhc_flags &= ~MDI_VHC_VHCACHE_FLUSH_THREAD; 8377 /* CALLB_CPR_EXIT releases the vhc->vhc_lock */ 8378 CALLB_CPR_EXIT(&cprinfo); 8379 } 8380 8381 /* 8382 * Make vhci cache dirty and schedule flushing by vhcache flush thread. 8383 */ 8384 static void 8385 vhcache_dirty(mdi_vhci_config_t *vhc) 8386 { 8387 mdi_vhci_cache_t *vhcache = &vhc->vhc_vhcache; 8388 int create_thread; 8389 8390 rw_enter(&vhcache->vhcache_lock, RW_READER); 8391 /* do not flush cache until the cache is fully built */ 8392 if (!(vhcache->vhcache_flags & MDI_VHCI_CACHE_SETUP_DONE)) { 8393 rw_exit(&vhcache->vhcache_lock); 8394 return; 8395 } 8396 rw_exit(&vhcache->vhcache_lock); 8397 8398 mutex_enter(&vhc->vhc_lock); 8399 if (vhc->vhc_flags & MDI_VHC_READONLY_FS) { 8400 mutex_exit(&vhc->vhc_lock); 8401 return; 8402 } 8403 8404 vhc->vhc_flags |= MDI_VHC_VHCACHE_DIRTY; 8405 vhc->vhc_flush_at_ticks = ddi_get_lbolt() + 8406 mdi_vhcache_flush_delay * TICKS_PER_SECOND; 8407 if (vhc->vhc_flags & MDI_VHC_VHCACHE_FLUSH_THREAD) { 8408 cv_broadcast(&vhc->vhc_cv); 8409 create_thread = 0; 8410 } else { 8411 vhc->vhc_flags |= MDI_VHC_VHCACHE_FLUSH_THREAD; 8412 create_thread = 1; 8413 } 8414 mutex_exit(&vhc->vhc_lock); 8415 8416 if (create_thread) 8417 (void) thread_create(NULL, 0, vhcache_flush_thread, vhc, 8418 0, &p0, TS_RUN, minclsyspri); 8419 } 8420 8421 /* 8422 * phci bus config structure - one for for each phci bus config operation that 8423 * we initiate on behalf of a vhci. 8424 */ 8425 typedef struct mdi_phci_bus_config_s { 8426 char *phbc_phci_path; 8427 struct mdi_vhci_bus_config_s *phbc_vhbusconfig; /* vhci bus config */ 8428 struct mdi_phci_bus_config_s *phbc_next; 8429 } mdi_phci_bus_config_t; 8430 8431 /* vhci bus config structure - one for each vhci bus config operation */ 8432 typedef struct mdi_vhci_bus_config_s { 8433 ddi_bus_config_op_t vhbc_op; /* bus config op */ 8434 major_t vhbc_op_major; /* bus config op major */ 8435 uint_t vhbc_op_flags; /* bus config op flags */ 8436 kmutex_t vhbc_lock; 8437 kcondvar_t vhbc_cv; 8438 int vhbc_thr_count; 8439 } mdi_vhci_bus_config_t; 8440 8441 /* 8442 * bus config the specified phci 8443 */ 8444 static void 8445 bus_config_phci(void *arg) 8446 { 8447 mdi_phci_bus_config_t *phbc = (mdi_phci_bus_config_t *)arg; 8448 mdi_vhci_bus_config_t *vhbc = phbc->phbc_vhbusconfig; 8449 dev_info_t *ph_dip; 8450 8451 /* 8452 * first configure all path components upto phci and then configure 8453 * the phci children. 8454 */ 8455 if ((ph_dip = e_ddi_hold_devi_by_path(phbc->phbc_phci_path, 0)) 8456 != NULL) { 8457 if (vhbc->vhbc_op == BUS_CONFIG_DRIVER || 8458 vhbc->vhbc_op == BUS_UNCONFIG_DRIVER) { 8459 (void) ndi_devi_config_driver(ph_dip, 8460 vhbc->vhbc_op_flags, 8461 vhbc->vhbc_op_major); 8462 } else 8463 (void) ndi_devi_config(ph_dip, 8464 vhbc->vhbc_op_flags); 8465 8466 /* release the hold that e_ddi_hold_devi_by_path() placed */ 8467 ndi_rele_devi(ph_dip); 8468 } 8469 8470 kmem_free(phbc->phbc_phci_path, strlen(phbc->phbc_phci_path) + 1); 8471 kmem_free(phbc, sizeof (*phbc)); 8472 8473 mutex_enter(&vhbc->vhbc_lock); 8474 vhbc->vhbc_thr_count--; 8475 if (vhbc->vhbc_thr_count == 0) 8476 cv_broadcast(&vhbc->vhbc_cv); 8477 mutex_exit(&vhbc->vhbc_lock); 8478 } 8479 8480 /* 8481 * Bus config all phcis associated with the vhci in parallel. 8482 * op must be BUS_CONFIG_DRIVER or BUS_CONFIG_ALL. 8483 */ 8484 static void 8485 bus_config_all_phcis(mdi_vhci_cache_t *vhcache, uint_t flags, 8486 ddi_bus_config_op_t op, major_t maj) 8487 { 8488 mdi_phci_bus_config_t *phbc_head = NULL, *phbc, *phbc_next; 8489 mdi_vhci_bus_config_t *vhbc; 8490 mdi_vhcache_phci_t *cphci; 8491 8492 rw_enter(&vhcache->vhcache_lock, RW_READER); 8493 if (vhcache->vhcache_phci_head == NULL) { 8494 rw_exit(&vhcache->vhcache_lock); 8495 return; 8496 } 8497 8498 vhbc = kmem_zalloc(sizeof (*vhbc), KM_SLEEP); 8499 8500 for (cphci = vhcache->vhcache_phci_head; cphci != NULL; 8501 cphci = cphci->cphci_next) { 8502 /* skip phcis that haven't attached before root is available */ 8503 if (!modrootloaded && (cphci->cphci_phci == NULL)) 8504 continue; 8505 phbc = kmem_zalloc(sizeof (*phbc), KM_SLEEP); 8506 phbc->phbc_phci_path = i_ddi_strdup(cphci->cphci_path, 8507 KM_SLEEP); 8508 phbc->phbc_vhbusconfig = vhbc; 8509 phbc->phbc_next = phbc_head; 8510 phbc_head = phbc; 8511 vhbc->vhbc_thr_count++; 8512 } 8513 rw_exit(&vhcache->vhcache_lock); 8514 8515 vhbc->vhbc_op = op; 8516 vhbc->vhbc_op_major = maj; 8517 vhbc->vhbc_op_flags = NDI_NO_EVENT | 8518 (flags & (NDI_CONFIG_REPROBE | NDI_DRV_CONF_REPROBE)); 8519 mutex_init(&vhbc->vhbc_lock, NULL, MUTEX_DEFAULT, NULL); 8520 cv_init(&vhbc->vhbc_cv, NULL, CV_DRIVER, NULL); 8521 8522 /* now create threads to initiate bus config on all phcis in parallel */ 8523 for (phbc = phbc_head; phbc != NULL; phbc = phbc_next) { 8524 phbc_next = phbc->phbc_next; 8525 if (mdi_mtc_off) 8526 bus_config_phci((void *)phbc); 8527 else 8528 (void) thread_create(NULL, 0, bus_config_phci, phbc, 8529 0, &p0, TS_RUN, minclsyspri); 8530 } 8531 8532 mutex_enter(&vhbc->vhbc_lock); 8533 /* wait until all threads exit */ 8534 while (vhbc->vhbc_thr_count > 0) 8535 cv_wait(&vhbc->vhbc_cv, &vhbc->vhbc_lock); 8536 mutex_exit(&vhbc->vhbc_lock); 8537 8538 mutex_destroy(&vhbc->vhbc_lock); 8539 cv_destroy(&vhbc->vhbc_cv); 8540 kmem_free(vhbc, sizeof (*vhbc)); 8541 } 8542 8543 /* 8544 * Single threaded version of bus_config_all_phcis() 8545 */ 8546 static void 8547 st_bus_config_all_phcis(mdi_vhci_config_t *vhc, uint_t flags, 8548 ddi_bus_config_op_t op, major_t maj) 8549 { 8550 mdi_vhci_cache_t *vhcache = &vhc->vhc_vhcache; 8551 8552 single_threaded_vhconfig_enter(vhc); 8553 bus_config_all_phcis(vhcache, flags, op, maj); 8554 single_threaded_vhconfig_exit(vhc); 8555 } 8556 8557 /* 8558 * Perform BUS_CONFIG_ONE on the specified child of the phci. 8559 * The path includes the child component in addition to the phci path. 8560 */ 8561 static int 8562 bus_config_one_phci_child(char *path) 8563 { 8564 dev_info_t *ph_dip, *child; 8565 char *devnm; 8566 int rv = MDI_FAILURE; 8567 8568 /* extract the child component of the phci */ 8569 devnm = strrchr(path, '/'); 8570 *devnm++ = '\0'; 8571 8572 /* 8573 * first configure all path components upto phci and then 8574 * configure the phci child. 8575 */ 8576 if ((ph_dip = e_ddi_hold_devi_by_path(path, 0)) != NULL) { 8577 if (ndi_devi_config_one(ph_dip, devnm, &child, NDI_NO_EVENT) == 8578 NDI_SUCCESS) { 8579 /* 8580 * release the hold that ndi_devi_config_one() placed 8581 */ 8582 ndi_rele_devi(child); 8583 rv = MDI_SUCCESS; 8584 } 8585 8586 /* release the hold that e_ddi_hold_devi_by_path() placed */ 8587 ndi_rele_devi(ph_dip); 8588 } 8589 8590 devnm--; 8591 *devnm = '/'; 8592 return (rv); 8593 } 8594 8595 /* 8596 * Build a list of phci client paths for the specified vhci client. 8597 * The list includes only those phci client paths which aren't configured yet. 8598 */ 8599 static mdi_phys_path_t * 8600 build_phclient_path_list(mdi_vhcache_client_t *cct, char *ct_name) 8601 { 8602 mdi_vhcache_pathinfo_t *cpi; 8603 mdi_phys_path_t *pp_head = NULL, *pp_tail = NULL, *pp; 8604 int config_path, len; 8605 8606 for (cpi = cct->cct_cpi_head; cpi != NULL; cpi = cpi->cpi_next) { 8607 /* 8608 * include only those paths that aren't configured. 8609 */ 8610 config_path = 0; 8611 if (cpi->cpi_pip == NULL) 8612 config_path = 1; 8613 else { 8614 MDI_PI_LOCK(cpi->cpi_pip); 8615 if (MDI_PI_IS_INIT(cpi->cpi_pip)) 8616 config_path = 1; 8617 MDI_PI_UNLOCK(cpi->cpi_pip); 8618 } 8619 8620 if (config_path) { 8621 pp = kmem_alloc(sizeof (*pp), KM_SLEEP); 8622 len = strlen(cpi->cpi_cphci->cphci_path) + 8623 strlen(ct_name) + strlen(cpi->cpi_addr) + 3; 8624 pp->phys_path = kmem_alloc(len, KM_SLEEP); 8625 (void) snprintf(pp->phys_path, len, "%s/%s@%s", 8626 cpi->cpi_cphci->cphci_path, ct_name, 8627 cpi->cpi_addr); 8628 pp->phys_path_next = NULL; 8629 8630 if (pp_head == NULL) 8631 pp_head = pp; 8632 else 8633 pp_tail->phys_path_next = pp; 8634 pp_tail = pp; 8635 } 8636 } 8637 8638 return (pp_head); 8639 } 8640 8641 /* 8642 * Free the memory allocated for phci client path list. 8643 */ 8644 static void 8645 free_phclient_path_list(mdi_phys_path_t *pp_head) 8646 { 8647 mdi_phys_path_t *pp, *pp_next; 8648 8649 for (pp = pp_head; pp != NULL; pp = pp_next) { 8650 pp_next = pp->phys_path_next; 8651 kmem_free(pp->phys_path, strlen(pp->phys_path) + 1); 8652 kmem_free(pp, sizeof (*pp)); 8653 } 8654 } 8655 8656 /* 8657 * Allocated async client structure and initialize with the specified values. 8658 */ 8659 static mdi_async_client_config_t * 8660 alloc_async_client_config(char *ct_name, char *ct_addr, 8661 mdi_phys_path_t *pp_head, mdi_vhcache_lookup_token_t *tok) 8662 { 8663 mdi_async_client_config_t *acc; 8664 8665 acc = kmem_alloc(sizeof (*acc), KM_SLEEP); 8666 acc->acc_ct_name = i_ddi_strdup(ct_name, KM_SLEEP); 8667 acc->acc_ct_addr = i_ddi_strdup(ct_addr, KM_SLEEP); 8668 acc->acc_phclient_path_list_head = pp_head; 8669 init_vhcache_lookup_token(&acc->acc_token, tok); 8670 acc->acc_next = NULL; 8671 return (acc); 8672 } 8673 8674 /* 8675 * Free the memory allocated for the async client structure and their members. 8676 */ 8677 static void 8678 free_async_client_config(mdi_async_client_config_t *acc) 8679 { 8680 if (acc->acc_phclient_path_list_head) 8681 free_phclient_path_list(acc->acc_phclient_path_list_head); 8682 kmem_free(acc->acc_ct_name, strlen(acc->acc_ct_name) + 1); 8683 kmem_free(acc->acc_ct_addr, strlen(acc->acc_ct_addr) + 1); 8684 kmem_free(acc, sizeof (*acc)); 8685 } 8686 8687 /* 8688 * Sort vhcache pathinfos (cpis) of the specified client. 8689 * All cpis which do not have MDI_CPI_HINT_PATH_DOES_NOT_EXIST 8690 * flag set come at the beginning of the list. All cpis which have this 8691 * flag set come at the end of the list. 8692 */ 8693 static void 8694 sort_vhcache_paths(mdi_vhcache_client_t *cct) 8695 { 8696 mdi_vhcache_pathinfo_t *cpi, *cpi_next, *cpi_head; 8697 8698 cpi_head = cct->cct_cpi_head; 8699 cct->cct_cpi_head = cct->cct_cpi_tail = NULL; 8700 for (cpi = cpi_head; cpi != NULL; cpi = cpi_next) { 8701 cpi_next = cpi->cpi_next; 8702 enqueue_vhcache_pathinfo(cct, cpi); 8703 } 8704 } 8705 8706 /* 8707 * Verify whether MDI_CPI_HINT_PATH_DOES_NOT_EXIST flag setting is correct for 8708 * every vhcache pathinfo of the specified client. If not adjust the flag 8709 * setting appropriately. 8710 * 8711 * Note that MDI_CPI_HINT_PATH_DOES_NOT_EXIST flag is persisted in the 8712 * on-disk vhci cache. So every time this flag is updated the cache must be 8713 * flushed. 8714 */ 8715 static void 8716 adjust_sort_vhcache_paths(mdi_vhci_config_t *vhc, char *ct_name, char *ct_addr, 8717 mdi_vhcache_lookup_token_t *tok) 8718 { 8719 mdi_vhci_cache_t *vhcache = &vhc->vhc_vhcache; 8720 mdi_vhcache_client_t *cct; 8721 mdi_vhcache_pathinfo_t *cpi; 8722 8723 rw_enter(&vhcache->vhcache_lock, RW_READER); 8724 if ((cct = lookup_vhcache_client(vhcache, ct_name, ct_addr, tok)) 8725 == NULL) { 8726 rw_exit(&vhcache->vhcache_lock); 8727 return; 8728 } 8729 8730 /* 8731 * to avoid unnecessary on-disk cache updates, first check if an 8732 * update is really needed. If no update is needed simply return. 8733 */ 8734 for (cpi = cct->cct_cpi_head; cpi != NULL; cpi = cpi->cpi_next) { 8735 if ((cpi->cpi_pip != NULL && 8736 (cpi->cpi_flags & MDI_CPI_HINT_PATH_DOES_NOT_EXIST)) || 8737 (cpi->cpi_pip == NULL && 8738 !(cpi->cpi_flags & MDI_CPI_HINT_PATH_DOES_NOT_EXIST))) { 8739 break; 8740 } 8741 } 8742 if (cpi == NULL) { 8743 rw_exit(&vhcache->vhcache_lock); 8744 return; 8745 } 8746 8747 if (rw_tryupgrade(&vhcache->vhcache_lock) == 0) { 8748 rw_exit(&vhcache->vhcache_lock); 8749 rw_enter(&vhcache->vhcache_lock, RW_WRITER); 8750 if ((cct = lookup_vhcache_client(vhcache, ct_name, ct_addr, 8751 tok)) == NULL) { 8752 rw_exit(&vhcache->vhcache_lock); 8753 return; 8754 } 8755 } 8756 8757 for (cpi = cct->cct_cpi_head; cpi != NULL; cpi = cpi->cpi_next) { 8758 if (cpi->cpi_pip != NULL) 8759 cpi->cpi_flags &= ~MDI_CPI_HINT_PATH_DOES_NOT_EXIST; 8760 else 8761 cpi->cpi_flags |= MDI_CPI_HINT_PATH_DOES_NOT_EXIST; 8762 } 8763 sort_vhcache_paths(cct); 8764 8765 rw_exit(&vhcache->vhcache_lock); 8766 vhcache_dirty(vhc); 8767 } 8768 8769 /* 8770 * Configure all specified paths of the client. 8771 */ 8772 static void 8773 config_client_paths_sync(mdi_vhci_config_t *vhc, char *ct_name, char *ct_addr, 8774 mdi_phys_path_t *pp_head, mdi_vhcache_lookup_token_t *tok) 8775 { 8776 mdi_phys_path_t *pp; 8777 8778 for (pp = pp_head; pp != NULL; pp = pp->phys_path_next) 8779 (void) bus_config_one_phci_child(pp->phys_path); 8780 adjust_sort_vhcache_paths(vhc, ct_name, ct_addr, tok); 8781 } 8782 8783 /* 8784 * Dequeue elements from vhci async client config list and bus configure 8785 * their corresponding phci clients. 8786 */ 8787 static void 8788 config_client_paths_thread(void *arg) 8789 { 8790 mdi_vhci_config_t *vhc = (mdi_vhci_config_t *)arg; 8791 mdi_async_client_config_t *acc; 8792 clock_t quit_at_ticks; 8793 clock_t idle_time = mdi_async_config_idle_time * TICKS_PER_SECOND; 8794 callb_cpr_t cprinfo; 8795 8796 CALLB_CPR_INIT(&cprinfo, &vhc->vhc_lock, callb_generic_cpr, 8797 "mdi_config_client_paths"); 8798 8799 for (; ; ) { 8800 quit_at_ticks = ddi_get_lbolt() + idle_time; 8801 8802 mutex_enter(&vhc->vhc_lock); 8803 while (!(vhc->vhc_flags & MDI_VHC_EXIT) && 8804 vhc->vhc_acc_list_head == NULL && 8805 ddi_get_lbolt() < quit_at_ticks) { 8806 CALLB_CPR_SAFE_BEGIN(&cprinfo); 8807 (void) cv_timedwait(&vhc->vhc_cv, &vhc->vhc_lock, 8808 quit_at_ticks); 8809 CALLB_CPR_SAFE_END(&cprinfo, &vhc->vhc_lock); 8810 } 8811 8812 if ((vhc->vhc_flags & MDI_VHC_EXIT) || 8813 vhc->vhc_acc_list_head == NULL) 8814 goto out; 8815 8816 acc = vhc->vhc_acc_list_head; 8817 vhc->vhc_acc_list_head = acc->acc_next; 8818 if (vhc->vhc_acc_list_head == NULL) 8819 vhc->vhc_acc_list_tail = NULL; 8820 vhc->vhc_acc_count--; 8821 mutex_exit(&vhc->vhc_lock); 8822 8823 config_client_paths_sync(vhc, acc->acc_ct_name, 8824 acc->acc_ct_addr, acc->acc_phclient_path_list_head, 8825 &acc->acc_token); 8826 8827 free_async_client_config(acc); 8828 } 8829 8830 out: 8831 vhc->vhc_acc_thrcount--; 8832 /* CALLB_CPR_EXIT releases the vhc->vhc_lock */ 8833 CALLB_CPR_EXIT(&cprinfo); 8834 } 8835 8836 /* 8837 * Arrange for all the phci client paths (pp_head) for the specified client 8838 * to be bus configured asynchronously by a thread. 8839 */ 8840 static void 8841 config_client_paths_async(mdi_vhci_config_t *vhc, char *ct_name, char *ct_addr, 8842 mdi_phys_path_t *pp_head, mdi_vhcache_lookup_token_t *tok) 8843 { 8844 mdi_async_client_config_t *acc, *newacc; 8845 int create_thread; 8846 8847 if (pp_head == NULL) 8848 return; 8849 8850 if (mdi_mtc_off) { 8851 config_client_paths_sync(vhc, ct_name, ct_addr, pp_head, tok); 8852 free_phclient_path_list(pp_head); 8853 return; 8854 } 8855 8856 newacc = alloc_async_client_config(ct_name, ct_addr, pp_head, tok); 8857 ASSERT(newacc); 8858 8859 mutex_enter(&vhc->vhc_lock); 8860 for (acc = vhc->vhc_acc_list_head; acc != NULL; acc = acc->acc_next) { 8861 if (strcmp(ct_name, acc->acc_ct_name) == 0 && 8862 strcmp(ct_addr, acc->acc_ct_addr) == 0) { 8863 free_async_client_config(newacc); 8864 mutex_exit(&vhc->vhc_lock); 8865 return; 8866 } 8867 } 8868 8869 if (vhc->vhc_acc_list_head == NULL) 8870 vhc->vhc_acc_list_head = newacc; 8871 else 8872 vhc->vhc_acc_list_tail->acc_next = newacc; 8873 vhc->vhc_acc_list_tail = newacc; 8874 vhc->vhc_acc_count++; 8875 if (vhc->vhc_acc_count <= vhc->vhc_acc_thrcount) { 8876 cv_broadcast(&vhc->vhc_cv); 8877 create_thread = 0; 8878 } else { 8879 vhc->vhc_acc_thrcount++; 8880 create_thread = 1; 8881 } 8882 mutex_exit(&vhc->vhc_lock); 8883 8884 if (create_thread) 8885 (void) thread_create(NULL, 0, config_client_paths_thread, vhc, 8886 0, &p0, TS_RUN, minclsyspri); 8887 } 8888 8889 /* 8890 * Return number of online paths for the specified client. 8891 */ 8892 static int 8893 nonline_paths(mdi_vhcache_client_t *cct) 8894 { 8895 mdi_vhcache_pathinfo_t *cpi; 8896 int online_count = 0; 8897 8898 for (cpi = cct->cct_cpi_head; cpi != NULL; cpi = cpi->cpi_next) { 8899 if (cpi->cpi_pip != NULL) { 8900 MDI_PI_LOCK(cpi->cpi_pip); 8901 if (cpi->cpi_pip->pi_state == MDI_PATHINFO_STATE_ONLINE) 8902 online_count++; 8903 MDI_PI_UNLOCK(cpi->cpi_pip); 8904 } 8905 } 8906 8907 return (online_count); 8908 } 8909 8910 /* 8911 * Bus configure all paths for the specified vhci client. 8912 * If at least one path for the client is already online, the remaining paths 8913 * will be configured asynchronously. Otherwise, it synchronously configures 8914 * the paths until at least one path is online and then rest of the paths 8915 * will be configured asynchronously. 8916 */ 8917 static void 8918 config_client_paths(mdi_vhci_config_t *vhc, char *ct_name, char *ct_addr) 8919 { 8920 mdi_vhci_cache_t *vhcache = &vhc->vhc_vhcache; 8921 mdi_phys_path_t *pp_head, *pp; 8922 mdi_vhcache_client_t *cct; 8923 mdi_vhcache_lookup_token_t tok; 8924 8925 ASSERT(RW_LOCK_HELD(&vhcache->vhcache_lock)); 8926 8927 init_vhcache_lookup_token(&tok, NULL); 8928 8929 if (ct_name == NULL || ct_addr == NULL || 8930 (cct = lookup_vhcache_client(vhcache, ct_name, ct_addr, &tok)) 8931 == NULL || 8932 (pp_head = build_phclient_path_list(cct, ct_name)) == NULL) { 8933 rw_exit(&vhcache->vhcache_lock); 8934 return; 8935 } 8936 8937 /* if at least one path is online, configure the rest asynchronously */ 8938 if (nonline_paths(cct) > 0) { 8939 rw_exit(&vhcache->vhcache_lock); 8940 config_client_paths_async(vhc, ct_name, ct_addr, pp_head, &tok); 8941 return; 8942 } 8943 8944 rw_exit(&vhcache->vhcache_lock); 8945 8946 for (pp = pp_head; pp != NULL; pp = pp->phys_path_next) { 8947 if (bus_config_one_phci_child(pp->phys_path) == MDI_SUCCESS) { 8948 rw_enter(&vhcache->vhcache_lock, RW_READER); 8949 8950 if ((cct = lookup_vhcache_client(vhcache, ct_name, 8951 ct_addr, &tok)) == NULL) { 8952 rw_exit(&vhcache->vhcache_lock); 8953 goto out; 8954 } 8955 8956 if (nonline_paths(cct) > 0 && 8957 pp->phys_path_next != NULL) { 8958 rw_exit(&vhcache->vhcache_lock); 8959 config_client_paths_async(vhc, ct_name, ct_addr, 8960 pp->phys_path_next, &tok); 8961 pp->phys_path_next = NULL; 8962 goto out; 8963 } 8964 8965 rw_exit(&vhcache->vhcache_lock); 8966 } 8967 } 8968 8969 adjust_sort_vhcache_paths(vhc, ct_name, ct_addr, &tok); 8970 out: 8971 free_phclient_path_list(pp_head); 8972 } 8973 8974 static void 8975 single_threaded_vhconfig_enter(mdi_vhci_config_t *vhc) 8976 { 8977 mutex_enter(&vhc->vhc_lock); 8978 while (vhc->vhc_flags & MDI_VHC_SINGLE_THREADED) 8979 cv_wait(&vhc->vhc_cv, &vhc->vhc_lock); 8980 vhc->vhc_flags |= MDI_VHC_SINGLE_THREADED; 8981 mutex_exit(&vhc->vhc_lock); 8982 } 8983 8984 static void 8985 single_threaded_vhconfig_exit(mdi_vhci_config_t *vhc) 8986 { 8987 mutex_enter(&vhc->vhc_lock); 8988 vhc->vhc_flags &= ~MDI_VHC_SINGLE_THREADED; 8989 cv_broadcast(&vhc->vhc_cv); 8990 mutex_exit(&vhc->vhc_lock); 8991 } 8992 8993 typedef struct mdi_phci_driver_info { 8994 char *phdriver_name; /* name of the phci driver */ 8995 8996 /* set to non zero if the phci driver supports root device */ 8997 int phdriver_root_support; 8998 } mdi_phci_driver_info_t; 8999 9000 /* 9001 * vhci class and root support capability of a phci driver can be 9002 * specified using ddi-vhci-class and ddi-no-root-support properties in the 9003 * phci driver.conf file. The built-in tables below contain this information 9004 * for those phci drivers whose driver.conf files don't yet contain this info. 9005 * 9006 * All phci drivers expect iscsi have root device support. 9007 */ 9008 static mdi_phci_driver_info_t scsi_phci_driver_list[] = { 9009 { "fp", 1 }, 9010 { "iscsi", 0 }, 9011 { "ibsrp", 1 } 9012 }; 9013 9014 static mdi_phci_driver_info_t ib_phci_driver_list[] = { "tavor", 1 }; 9015 9016 static void * 9017 mdi_realloc(void *old_ptr, size_t old_size, size_t new_size) 9018 { 9019 void *new_ptr; 9020 9021 new_ptr = kmem_zalloc(new_size, KM_SLEEP); 9022 if (old_ptr) { 9023 bcopy(old_ptr, new_ptr, MIN(old_size, new_size)); 9024 kmem_free(old_ptr, old_size); 9025 } 9026 return (new_ptr); 9027 } 9028 9029 static void 9030 add_to_phci_list(char ***driver_list, int **root_support_list, 9031 int *cur_elements, int *max_elements, char *driver_name, int root_support) 9032 { 9033 ASSERT(*cur_elements <= *max_elements); 9034 if (*cur_elements == *max_elements) { 9035 *max_elements += 10; 9036 *driver_list = mdi_realloc(*driver_list, 9037 sizeof (char *) * (*cur_elements), 9038 sizeof (char *) * (*max_elements)); 9039 *root_support_list = mdi_realloc(*root_support_list, 9040 sizeof (int) * (*cur_elements), 9041 sizeof (int) * (*max_elements)); 9042 } 9043 (*driver_list)[*cur_elements] = i_ddi_strdup(driver_name, KM_SLEEP); 9044 (*root_support_list)[*cur_elements] = root_support; 9045 (*cur_elements)++; 9046 } 9047 9048 static void 9049 get_phci_driver_list(char *vhci_class, char ***driver_list, 9050 int **root_support_list, int *cur_elements, int *max_elements) 9051 { 9052 mdi_phci_driver_info_t *st_driver_list, *p; 9053 int st_ndrivers, root_support, i, j, driver_conf_count; 9054 major_t m; 9055 struct devnames *dnp; 9056 ddi_prop_t *propp; 9057 9058 *driver_list = NULL; 9059 *root_support_list = NULL; 9060 *cur_elements = 0; 9061 *max_elements = 0; 9062 9063 /* add the phci drivers derived from the phci driver.conf files */ 9064 for (m = 0; m < devcnt; m++) { 9065 dnp = &devnamesp[m]; 9066 9067 if (dnp->dn_flags & DN_PHCI_DRIVER) { 9068 LOCK_DEV_OPS(&dnp->dn_lock); 9069 if (dnp->dn_global_prop_ptr != NULL && 9070 (propp = i_ddi_prop_search(DDI_DEV_T_ANY, 9071 DDI_VHCI_CLASS, DDI_PROP_TYPE_STRING, 9072 &dnp->dn_global_prop_ptr->prop_list)) != NULL && 9073 strcmp(propp->prop_val, vhci_class) == 0) { 9074 9075 root_support = (i_ddi_prop_search(DDI_DEV_T_ANY, 9076 DDI_NO_ROOT_SUPPORT, DDI_PROP_TYPE_INT, 9077 &dnp->dn_global_prop_ptr->prop_list) 9078 == NULL) ? 1 : 0; 9079 9080 add_to_phci_list(driver_list, root_support_list, 9081 cur_elements, max_elements, dnp->dn_name, 9082 root_support); 9083 9084 UNLOCK_DEV_OPS(&dnp->dn_lock); 9085 } else 9086 UNLOCK_DEV_OPS(&dnp->dn_lock); 9087 } 9088 } 9089 9090 driver_conf_count = *cur_elements; 9091 9092 /* add the phci drivers specified in the built-in tables */ 9093 if (strcmp(vhci_class, MDI_HCI_CLASS_SCSI) == 0) { 9094 st_driver_list = scsi_phci_driver_list; 9095 st_ndrivers = sizeof (scsi_phci_driver_list) / 9096 sizeof (mdi_phci_driver_info_t); 9097 } else if (strcmp(vhci_class, MDI_HCI_CLASS_IB) == 0) { 9098 st_driver_list = ib_phci_driver_list; 9099 st_ndrivers = sizeof (ib_phci_driver_list) / 9100 sizeof (mdi_phci_driver_info_t); 9101 } else { 9102 st_driver_list = NULL; 9103 st_ndrivers = 0; 9104 } 9105 9106 for (i = 0, p = st_driver_list; i < st_ndrivers; i++, p++) { 9107 /* add this phci driver if not already added before */ 9108 for (j = 0; j < driver_conf_count; j++) { 9109 if (strcmp((*driver_list)[j], p->phdriver_name) == 0) 9110 break; 9111 } 9112 if (j == driver_conf_count) { 9113 add_to_phci_list(driver_list, root_support_list, 9114 cur_elements, max_elements, p->phdriver_name, 9115 p->phdriver_root_support); 9116 } 9117 } 9118 } 9119 9120 /* 9121 * Attach the phci driver instances associated with the specified vhci class. 9122 * If root is mounted attach all phci driver instances. 9123 * If root is not mounted, attach the instances of only those phci 9124 * drivers that have the root support. 9125 */ 9126 static void 9127 attach_phci_drivers(char *vhci_class) 9128 { 9129 char **driver_list, **p; 9130 int *root_support_list; 9131 int cur_elements, max_elements, i; 9132 major_t m; 9133 9134 get_phci_driver_list(vhci_class, &driver_list, &root_support_list, 9135 &cur_elements, &max_elements); 9136 9137 for (i = 0; i < cur_elements; i++) { 9138 if (modrootloaded || root_support_list[i]) { 9139 m = ddi_name_to_major(driver_list[i]); 9140 if (m != DDI_MAJOR_T_NONE && 9141 ddi_hold_installed_driver(m)) 9142 ddi_rele_driver(m); 9143 } 9144 } 9145 9146 if (driver_list) { 9147 for (i = 0, p = driver_list; i < cur_elements; i++, p++) 9148 kmem_free(*p, strlen(*p) + 1); 9149 kmem_free(driver_list, sizeof (char *) * max_elements); 9150 kmem_free(root_support_list, sizeof (int) * max_elements); 9151 } 9152 } 9153 9154 /* 9155 * Build vhci cache: 9156 * 9157 * Attach phci driver instances and then drive BUS_CONFIG_ALL on 9158 * the phci driver instances. During this process the cache gets built. 9159 * 9160 * Cache is built fully if the root is mounted. 9161 * If the root is not mounted, phci drivers that do not have root support 9162 * are not attached. As a result the cache is built partially. The entries 9163 * in the cache reflect only those phci drivers that have root support. 9164 */ 9165 static int 9166 build_vhci_cache(mdi_vhci_t *vh) 9167 { 9168 mdi_vhci_config_t *vhc = vh->vh_config; 9169 mdi_vhci_cache_t *vhcache = &vhc->vhc_vhcache; 9170 9171 single_threaded_vhconfig_enter(vhc); 9172 9173 rw_enter(&vhcache->vhcache_lock, RW_READER); 9174 if (vhcache->vhcache_flags & MDI_VHCI_CACHE_SETUP_DONE) { 9175 rw_exit(&vhcache->vhcache_lock); 9176 single_threaded_vhconfig_exit(vhc); 9177 return (0); 9178 } 9179 rw_exit(&vhcache->vhcache_lock); 9180 9181 attach_phci_drivers(vh->vh_class); 9182 bus_config_all_phcis(vhcache, NDI_DRV_CONF_REPROBE | NDI_NO_EVENT, 9183 BUS_CONFIG_ALL, DDI_MAJOR_T_NONE); 9184 9185 rw_enter(&vhcache->vhcache_lock, RW_WRITER); 9186 vhcache->vhcache_flags |= MDI_VHCI_CACHE_SETUP_DONE; 9187 rw_exit(&vhcache->vhcache_lock); 9188 9189 single_threaded_vhconfig_exit(vhc); 9190 vhcache_dirty(vhc); 9191 return (1); 9192 } 9193 9194 /* 9195 * Determine if discovery of paths is needed. 9196 */ 9197 static int 9198 vhcache_do_discovery(mdi_vhci_config_t *vhc) 9199 { 9200 int rv = 1; 9201 9202 mutex_enter(&vhc->vhc_lock); 9203 if (i_ddi_io_initialized() == 0) { 9204 if (vhc->vhc_path_discovery_boot > 0) { 9205 vhc->vhc_path_discovery_boot--; 9206 goto out; 9207 } 9208 } else { 9209 if (vhc->vhc_path_discovery_postboot > 0) { 9210 vhc->vhc_path_discovery_postboot--; 9211 goto out; 9212 } 9213 } 9214 9215 /* 9216 * Do full path discovery at most once per mdi_path_discovery_interval. 9217 * This is to avoid a series of full path discoveries when opening 9218 * stale /dev/[r]dsk links. 9219 */ 9220 if (mdi_path_discovery_interval != -1 && 9221 ddi_get_lbolt64() >= vhc->vhc_path_discovery_cutoff_time) 9222 goto out; 9223 9224 rv = 0; 9225 out: 9226 mutex_exit(&vhc->vhc_lock); 9227 return (rv); 9228 } 9229 9230 /* 9231 * Discover all paths: 9232 * 9233 * Attach phci driver instances and then drive BUS_CONFIG_ALL on all the phci 9234 * driver instances. During this process all paths will be discovered. 9235 */ 9236 static int 9237 vhcache_discover_paths(mdi_vhci_t *vh) 9238 { 9239 mdi_vhci_config_t *vhc = vh->vh_config; 9240 mdi_vhci_cache_t *vhcache = &vhc->vhc_vhcache; 9241 int rv = 0; 9242 9243 single_threaded_vhconfig_enter(vhc); 9244 9245 if (vhcache_do_discovery(vhc)) { 9246 attach_phci_drivers(vh->vh_class); 9247 bus_config_all_phcis(vhcache, NDI_DRV_CONF_REPROBE | 9248 NDI_NO_EVENT, BUS_CONFIG_ALL, DDI_MAJOR_T_NONE); 9249 9250 mutex_enter(&vhc->vhc_lock); 9251 vhc->vhc_path_discovery_cutoff_time = ddi_get_lbolt64() + 9252 mdi_path_discovery_interval * TICKS_PER_SECOND; 9253 mutex_exit(&vhc->vhc_lock); 9254 rv = 1; 9255 } 9256 9257 single_threaded_vhconfig_exit(vhc); 9258 return (rv); 9259 } 9260 9261 /* 9262 * Generic vhci bus config implementation: 9263 * 9264 * Parameters 9265 * vdip vhci dip 9266 * flags bus config flags 9267 * op bus config operation 9268 * The remaining parameters are bus config operation specific 9269 * 9270 * for BUS_CONFIG_ONE 9271 * arg pointer to name@addr 9272 * child upon successful return from this function, *child will be 9273 * set to the configured and held devinfo child node of vdip. 9274 * ct_addr pointer to client address (i.e. GUID) 9275 * 9276 * for BUS_CONFIG_DRIVER 9277 * arg major number of the driver 9278 * child and ct_addr parameters are ignored 9279 * 9280 * for BUS_CONFIG_ALL 9281 * arg, child, and ct_addr parameters are ignored 9282 * 9283 * Note that for the rest of the bus config operations, this function simply 9284 * calls the framework provided default bus config routine. 9285 */ 9286 int 9287 mdi_vhci_bus_config(dev_info_t *vdip, uint_t flags, ddi_bus_config_op_t op, 9288 void *arg, dev_info_t **child, char *ct_addr) 9289 { 9290 mdi_vhci_t *vh = i_devi_get_vhci(vdip); 9291 mdi_vhci_config_t *vhc = vh->vh_config; 9292 mdi_vhci_cache_t *vhcache = &vhc->vhc_vhcache; 9293 int rv = 0; 9294 int params_valid = 0; 9295 char *cp; 9296 9297 /* 9298 * To bus config vhcis we relay operation, possibly using another 9299 * thread, to phcis. The phci driver then interacts with MDI to cause 9300 * vhci child nodes to be enumerated under the vhci node. Adding a 9301 * vhci child requires an ndi_devi_enter of the vhci. Since another 9302 * thread may be adding the child, to avoid deadlock we can't wait 9303 * for the relayed operations to complete if we have already entered 9304 * the vhci node. 9305 */ 9306 if (DEVI_BUSY_OWNED(vdip)) { 9307 MDI_DEBUG(2, (MDI_NOTE, vdip, 9308 "vhci dip is busy owned %p", (void *)vdip)); 9309 goto default_bus_config; 9310 } 9311 9312 rw_enter(&vhcache->vhcache_lock, RW_READER); 9313 if (!(vhcache->vhcache_flags & MDI_VHCI_CACHE_SETUP_DONE)) { 9314 rw_exit(&vhcache->vhcache_lock); 9315 rv = build_vhci_cache(vh); 9316 rw_enter(&vhcache->vhcache_lock, RW_READER); 9317 } 9318 9319 switch (op) { 9320 case BUS_CONFIG_ONE: 9321 if (arg != NULL && ct_addr != NULL) { 9322 /* extract node name */ 9323 cp = (char *)arg; 9324 while (*cp != '\0' && *cp != '@') 9325 cp++; 9326 if (*cp == '@') { 9327 params_valid = 1; 9328 *cp = '\0'; 9329 config_client_paths(vhc, (char *)arg, ct_addr); 9330 /* config_client_paths() releases cache_lock */ 9331 *cp = '@'; 9332 break; 9333 } 9334 } 9335 9336 rw_exit(&vhcache->vhcache_lock); 9337 break; 9338 9339 case BUS_CONFIG_DRIVER: 9340 rw_exit(&vhcache->vhcache_lock); 9341 if (rv == 0) 9342 st_bus_config_all_phcis(vhc, flags, op, 9343 (major_t)(uintptr_t)arg); 9344 break; 9345 9346 case BUS_CONFIG_ALL: 9347 rw_exit(&vhcache->vhcache_lock); 9348 if (rv == 0) 9349 st_bus_config_all_phcis(vhc, flags, op, -1); 9350 break; 9351 9352 default: 9353 rw_exit(&vhcache->vhcache_lock); 9354 break; 9355 } 9356 9357 9358 default_bus_config: 9359 /* 9360 * All requested child nodes are enumerated under the vhci. 9361 * Now configure them. 9362 */ 9363 if (ndi_busop_bus_config(vdip, flags, op, arg, child, 0) == 9364 NDI_SUCCESS) { 9365 return (MDI_SUCCESS); 9366 } else if (op == BUS_CONFIG_ONE && rv == 0 && params_valid) { 9367 /* discover all paths and try configuring again */ 9368 if (vhcache_discover_paths(vh) && 9369 ndi_busop_bus_config(vdip, flags, op, arg, child, 0) == 9370 NDI_SUCCESS) 9371 return (MDI_SUCCESS); 9372 } 9373 9374 return (MDI_FAILURE); 9375 } 9376 9377 /* 9378 * Read the on-disk vhci cache into an nvlist for the specified vhci class. 9379 */ 9380 static nvlist_t * 9381 read_on_disk_vhci_cache(char *vhci_class) 9382 { 9383 nvlist_t *nvl; 9384 int err; 9385 char *filename; 9386 9387 filename = vhclass2vhcache_filename(vhci_class); 9388 9389 if ((err = fread_nvlist(filename, &nvl)) == 0) { 9390 kmem_free(filename, strlen(filename) + 1); 9391 return (nvl); 9392 } else if (err == EIO) 9393 cmn_err(CE_WARN, "%s: I/O error, will recreate", filename); 9394 else if (err == EINVAL) 9395 cmn_err(CE_WARN, 9396 "%s: data file corrupted, will recreate", filename); 9397 9398 kmem_free(filename, strlen(filename) + 1); 9399 return (NULL); 9400 } 9401 9402 /* 9403 * Read on-disk vhci cache into nvlists for all vhci classes. 9404 * Called during booting by i_ddi_read_devices_files(). 9405 */ 9406 void 9407 mdi_read_devices_files(void) 9408 { 9409 int i; 9410 9411 for (i = 0; i < N_VHCI_CLASSES; i++) 9412 vhcache_nvl[i] = read_on_disk_vhci_cache(vhci_class_list[i]); 9413 } 9414 9415 /* 9416 * Remove all stale entries from vhci cache. 9417 */ 9418 static void 9419 clean_vhcache(mdi_vhci_config_t *vhc) 9420 { 9421 mdi_vhci_cache_t *vhcache = &vhc->vhc_vhcache; 9422 mdi_vhcache_phci_t *phci, *nxt_phci; 9423 mdi_vhcache_client_t *client, *nxt_client; 9424 mdi_vhcache_pathinfo_t *path, *nxt_path; 9425 9426 rw_enter(&vhcache->vhcache_lock, RW_WRITER); 9427 9428 client = vhcache->vhcache_client_head; 9429 vhcache->vhcache_client_head = vhcache->vhcache_client_tail = NULL; 9430 for ( ; client != NULL; client = nxt_client) { 9431 nxt_client = client->cct_next; 9432 9433 path = client->cct_cpi_head; 9434 client->cct_cpi_head = client->cct_cpi_tail = NULL; 9435 for ( ; path != NULL; path = nxt_path) { 9436 nxt_path = path->cpi_next; 9437 if ((path->cpi_cphci->cphci_phci != NULL) && 9438 (path->cpi_pip != NULL)) { 9439 enqueue_tail_vhcache_pathinfo(client, path); 9440 } else if (path->cpi_pip != NULL) { 9441 /* Not valid to have a path without a phci. */ 9442 free_vhcache_pathinfo(path); 9443 } 9444 } 9445 9446 if (client->cct_cpi_head != NULL) 9447 enqueue_vhcache_client(vhcache, client); 9448 else { 9449 (void) mod_hash_destroy(vhcache->vhcache_client_hash, 9450 (mod_hash_key_t)client->cct_name_addr); 9451 free_vhcache_client(client); 9452 } 9453 } 9454 9455 phci = vhcache->vhcache_phci_head; 9456 vhcache->vhcache_phci_head = vhcache->vhcache_phci_tail = NULL; 9457 for ( ; phci != NULL; phci = nxt_phci) { 9458 9459 nxt_phci = phci->cphci_next; 9460 if (phci->cphci_phci != NULL) 9461 enqueue_vhcache_phci(vhcache, phci); 9462 else 9463 free_vhcache_phci(phci); 9464 } 9465 9466 vhcache->vhcache_clean_time = ddi_get_lbolt64(); 9467 rw_exit(&vhcache->vhcache_lock); 9468 vhcache_dirty(vhc); 9469 } 9470 9471 /* 9472 * Remove all stale entries from vhci cache. 9473 * Called by i_ddi_clean_devices_files() during the execution of devfsadm -C 9474 */ 9475 void 9476 mdi_clean_vhcache(void) 9477 { 9478 mdi_vhci_t *vh; 9479 9480 mutex_enter(&mdi_mutex); 9481 for (vh = mdi_vhci_head; vh != NULL; vh = vh->vh_next) { 9482 vh->vh_refcnt++; 9483 mutex_exit(&mdi_mutex); 9484 clean_vhcache(vh->vh_config); 9485 mutex_enter(&mdi_mutex); 9486 vh->vh_refcnt--; 9487 } 9488 mutex_exit(&mdi_mutex); 9489 } 9490 9491 /* 9492 * mdi_vhci_walk_clients(): 9493 * Walker routine to traverse client dev_info nodes 9494 * ddi_walk_devs(ddi_get_child(vdip), f, arg) returns the entire tree 9495 * below the client, including nexus devices, which we dont want. 9496 * So we just traverse the immediate siblings, starting from 1st client. 9497 */ 9498 void 9499 mdi_vhci_walk_clients(dev_info_t *vdip, 9500 int (*f)(dev_info_t *, void *), void *arg) 9501 { 9502 mdi_vhci_t *vh = i_devi_get_vhci(vdip); 9503 dev_info_t *cdip; 9504 mdi_client_t *ct; 9505 9506 MDI_VHCI_CLIENT_LOCK(vh); 9507 cdip = ddi_get_child(vdip); 9508 while (cdip) { 9509 ct = i_devi_get_client(cdip); 9510 MDI_CLIENT_LOCK(ct); 9511 9512 if (((*f)(cdip, arg)) == DDI_WALK_CONTINUE) 9513 cdip = ddi_get_next_sibling(cdip); 9514 else 9515 cdip = NULL; 9516 9517 MDI_CLIENT_UNLOCK(ct); 9518 } 9519 MDI_VHCI_CLIENT_UNLOCK(vh); 9520 } 9521 9522 /* 9523 * mdi_vhci_walk_phcis(): 9524 * Walker routine to traverse phci dev_info nodes 9525 */ 9526 void 9527 mdi_vhci_walk_phcis(dev_info_t *vdip, 9528 int (*f)(dev_info_t *, void *), void *arg) 9529 { 9530 mdi_vhci_t *vh = i_devi_get_vhci(vdip); 9531 mdi_phci_t *ph, *next; 9532 9533 MDI_VHCI_PHCI_LOCK(vh); 9534 ph = vh->vh_phci_head; 9535 while (ph) { 9536 MDI_PHCI_LOCK(ph); 9537 9538 if (((*f)(ph->ph_dip, arg)) == DDI_WALK_CONTINUE) 9539 next = ph->ph_next; 9540 else 9541 next = NULL; 9542 9543 MDI_PHCI_UNLOCK(ph); 9544 ph = next; 9545 } 9546 MDI_VHCI_PHCI_UNLOCK(vh); 9547 } 9548 9549 9550 /* 9551 * mdi_walk_vhcis(): 9552 * Walker routine to traverse vhci dev_info nodes 9553 */ 9554 void 9555 mdi_walk_vhcis(int (*f)(dev_info_t *, void *), void *arg) 9556 { 9557 mdi_vhci_t *vh = NULL; 9558 9559 mutex_enter(&mdi_mutex); 9560 /* 9561 * Scan for already registered vhci 9562 */ 9563 for (vh = mdi_vhci_head; vh != NULL; vh = vh->vh_next) { 9564 vh->vh_refcnt++; 9565 mutex_exit(&mdi_mutex); 9566 if (((*f)(vh->vh_dip, arg)) != DDI_WALK_CONTINUE) { 9567 mutex_enter(&mdi_mutex); 9568 vh->vh_refcnt--; 9569 break; 9570 } else { 9571 mutex_enter(&mdi_mutex); 9572 vh->vh_refcnt--; 9573 } 9574 } 9575 9576 mutex_exit(&mdi_mutex); 9577 } 9578 9579 /* 9580 * i_mdi_log_sysevent(): 9581 * Logs events for pickup by syseventd 9582 */ 9583 static void 9584 i_mdi_log_sysevent(dev_info_t *dip, char *ph_vh_class, char *subclass) 9585 { 9586 char *path_name; 9587 nvlist_t *attr_list; 9588 9589 if (nvlist_alloc(&attr_list, NV_UNIQUE_NAME_TYPE, 9590 KM_SLEEP) != DDI_SUCCESS) { 9591 goto alloc_failed; 9592 } 9593 9594 path_name = kmem_zalloc(MAXPATHLEN, KM_SLEEP); 9595 (void) ddi_pathname(dip, path_name); 9596 9597 if (nvlist_add_string(attr_list, DDI_DRIVER_NAME, 9598 ddi_driver_name(dip)) != DDI_SUCCESS) { 9599 goto error; 9600 } 9601 9602 if (nvlist_add_int32(attr_list, DDI_DRIVER_MAJOR, 9603 (int32_t)ddi_driver_major(dip)) != DDI_SUCCESS) { 9604 goto error; 9605 } 9606 9607 if (nvlist_add_int32(attr_list, DDI_INSTANCE, 9608 (int32_t)ddi_get_instance(dip)) != DDI_SUCCESS) { 9609 goto error; 9610 } 9611 9612 if (nvlist_add_string(attr_list, DDI_PATHNAME, 9613 path_name) != DDI_SUCCESS) { 9614 goto error; 9615 } 9616 9617 if (nvlist_add_string(attr_list, DDI_CLASS, 9618 ph_vh_class) != DDI_SUCCESS) { 9619 goto error; 9620 } 9621 9622 (void) ddi_log_sysevent(dip, DDI_VENDOR_SUNW, EC_DDI, subclass, 9623 attr_list, NULL, DDI_SLEEP); 9624 9625 error: 9626 kmem_free(path_name, MAXPATHLEN); 9627 nvlist_free(attr_list); 9628 return; 9629 9630 alloc_failed: 9631 MDI_DEBUG(1, (MDI_WARN, dip, "!unable to send sysevent")); 9632 } 9633 9634 char ** 9635 mdi_get_phci_driver_list(char *vhci_class, int *ndrivers) 9636 { 9637 char **driver_list, **ret_driver_list = NULL; 9638 int *root_support_list; 9639 int cur_elements, max_elements; 9640 9641 get_phci_driver_list(vhci_class, &driver_list, &root_support_list, 9642 &cur_elements, &max_elements); 9643 9644 9645 if (driver_list) { 9646 kmem_free(root_support_list, sizeof (int) * max_elements); 9647 ret_driver_list = mdi_realloc(driver_list, sizeof (char *) 9648 * max_elements, sizeof (char *) * cur_elements); 9649 } 9650 *ndrivers = cur_elements; 9651 9652 return (ret_driver_list); 9653 9654 } 9655 9656 void 9657 mdi_free_phci_driver_list(char **driver_list, int ndrivers) 9658 { 9659 char **p; 9660 int i; 9661 9662 if (driver_list) { 9663 for (i = 0, p = driver_list; i < ndrivers; i++, p++) 9664 kmem_free(*p, strlen(*p) + 1); 9665 kmem_free(driver_list, sizeof (char *) * ndrivers); 9666 } 9667 } 9668 9669 /* 9670 * mdi_is_dev_supported(): 9671 * function called by pHCI bus config operation to determine if a 9672 * device should be represented as a child of the vHCI or the 9673 * pHCI. This decision is made by the vHCI, using cinfo idenity 9674 * information passed by the pHCI - specifics of the cinfo 9675 * representation are by agreement between the pHCI and vHCI. 9676 * Return Values: 9677 * MDI_SUCCESS 9678 * MDI_FAILURE 9679 */ 9680 int 9681 mdi_is_dev_supported(char *class, dev_info_t *pdip, void *cinfo) 9682 { 9683 mdi_vhci_t *vh; 9684 9685 ASSERT(class && pdip); 9686 9687 /* 9688 * For dev_supported, mdi_phci_register() must have established pdip as 9689 * a pHCI. 9690 * 9691 * NOTE: mdi_phci_register() does "mpxio-disable" processing, and 9692 * MDI_PHCI(pdip) will return false if mpxio is disabled. 9693 */ 9694 if (!MDI_PHCI(pdip)) 9695 return (MDI_FAILURE); 9696 9697 /* Return MDI_FAILURE if vHCI does not support asking the question. */ 9698 vh = (mdi_vhci_t *)i_mdi_vhci_class2vhci(class); 9699 if ((vh == NULL) || (vh->vh_ops->vo_is_dev_supported == NULL)) { 9700 return (MDI_FAILURE); 9701 } 9702 9703 /* Return vHCI answer */ 9704 return (vh->vh_ops->vo_is_dev_supported(vh->vh_dip, pdip, cinfo)); 9705 } 9706 9707 int 9708 mdi_dc_return_dev_state(mdi_pathinfo_t *pip, struct devctl_iocdata *dcp) 9709 { 9710 uint_t devstate = 0; 9711 dev_info_t *cdip; 9712 9713 if ((pip == NULL) || (dcp == NULL)) 9714 return (MDI_FAILURE); 9715 9716 cdip = mdi_pi_get_client(pip); 9717 9718 switch (mdi_pi_get_state(pip)) { 9719 case MDI_PATHINFO_STATE_INIT: 9720 devstate = DEVICE_DOWN; 9721 break; 9722 case MDI_PATHINFO_STATE_ONLINE: 9723 devstate = DEVICE_ONLINE; 9724 if ((cdip) && (devi_stillreferenced(cdip) == DEVI_REFERENCED)) 9725 devstate |= DEVICE_BUSY; 9726 break; 9727 case MDI_PATHINFO_STATE_STANDBY: 9728 devstate = DEVICE_ONLINE; 9729 break; 9730 case MDI_PATHINFO_STATE_FAULT: 9731 devstate = DEVICE_DOWN; 9732 break; 9733 case MDI_PATHINFO_STATE_OFFLINE: 9734 devstate = DEVICE_OFFLINE; 9735 break; 9736 default: 9737 ASSERT(MDI_PI(pip)->pi_state); 9738 } 9739 9740 if (copyout(&devstate, dcp->cpyout_buf, sizeof (uint_t)) != 0) 9741 return (MDI_FAILURE); 9742 9743 return (MDI_SUCCESS); 9744 } --- EOF ---