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 }