1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright (c) 1994, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Copyright 2014 Garrett D'Amore <garrett@damore.org>
25 * Copyright (c) 2016 by Delphix. All rights reserved.
26 * Copyright 2022 RackTop Systems, Inc.
27 * Copyright 2023 Oxide Computer Company
28 */
29
30 #include <sys/note.h>
31
32 /*
33 * Generic SCSI Host Bus Adapter interface implementation
34 */
35 #include <sys/scsi/scsi.h>
36 #include <sys/scsi/generic/sas.h>
37 #include <sys/file.h>
38 #include <sys/disp.h> /* for minclsyspri */
39 #include <sys/ddi_impldefs.h>
40 #include <sys/ndi_impldefs.h>
41 #include <sys/sunndi.h>
42 #include <sys/ddi.h>
43 #include <sys/sunmdi.h>
44 #include <sys/mdi_impldefs.h>
45 #include <sys/callb.h>
46 #include <sys/epm.h>
47 #include <sys/damap.h>
48 #include <sys/time.h>
49 #include <sys/sunldi.h>
50 #include <sys/fm/protocol.h>
51
52 extern struct scsi_pkt *scsi_init_cache_pkt(struct scsi_address *,
53 struct scsi_pkt *, struct buf *, int, int, int, int,
54 int (*)(caddr_t), caddr_t);
55 extern void scsi_free_cache_pkt(struct scsi_address *, struct scsi_pkt *);
56 extern void scsi_cache_dmafree(struct scsi_address *, struct scsi_pkt *);
57 extern void scsi_sync_cache_pkt(struct scsi_address *, struct scsi_pkt *);
58 extern int modrootloaded;
59
60 /*
61 * Round up all allocations so that we can guarantee
62 * long-long alignment. This is the same alignment
63 * provided by kmem_alloc().
64 */
65 #define ROUNDUP(x) (((x) + 0x07) & ~0x07)
66
67 /* Magic number to track correct allocations in wrappers */
68 #define PKT_WRAPPER_MAGIC 0xa110ced /* alloced correctly */
69
70 kmutex_t scsi_flag_nointr_mutex;
71 kcondvar_t scsi_flag_nointr_cv;
72 kmutex_t scsi_log_mutex;
73
74 /* asynchronous probe barrier deletion data structures */
75 static kmutex_t scsi_hba_barrier_mutex;
76 static kcondvar_t scsi_hba_barrier_cv;
77 static struct scsi_hba_barrier {
78 struct scsi_hba_barrier *barrier_next;
79 clock_t barrier_endtime;
80 dev_info_t *barrier_probe;
81 } *scsi_hba_barrier_list;
82 static int scsi_hba_devi_is_barrier(dev_info_t *probe);
83 static void scsi_hba_barrier_tran_tgt_free(dev_info_t *probe);
84 static void scsi_hba_barrier_add(dev_info_t *probe, int seconds);
85 static int scsi_hba_remove_node(dev_info_t *child);
86 static void scsi_hba_barrier_daemon(void *arg);
87
88 /* LUN-change ASC/ASCQ processing data structures (stage1 and stage2) */
89 static kmutex_t scsi_lunchg1_mutex;
90 static kcondvar_t scsi_lunchg1_cv;
91 static struct scsi_pkt *scsi_lunchg1_list;
92 static void scsi_lunchg1_daemon(void *arg);
93 static kmutex_t scsi_lunchg2_mutex;
94 static kcondvar_t scsi_lunchg2_cv;
95 static struct scsi_lunchg2 {
96 struct scsi_lunchg2 *lunchg2_next;
97 char *lunchg2_path;
98 } *scsi_lunchg2_list;
99 static void scsi_lunchg2_daemon(void *arg);
100
101 static int scsi_findchild(dev_info_t *self, char *name, char *addr,
102 int init, dev_info_t **dchildp, mdi_pathinfo_t **pchildp, int *ppi);
103
104 /* return value defines for scsi_findchild */
105 #define CHILD_TYPE_NONE 0
106 #define CHILD_TYPE_DEVINFO 1
107 #define CHILD_TYPE_PATHINFO 2
108
109 /*
110 * Enumeration code path currently being followed. SE_BUSCONFIG results in
111 * DEVI_SID_NODEID, and SE_HP (hotplug) results in DEVI_SID_HP_NODEID.
112 *
113 * Since hotplug enumeration is based on information obtained from hardware
114 * (tgtmap/report_lun) the type/severity of enumeration error messages is
115 * sometimes based SE_HP (indirectly via ndi_dev_is_hotplug_node()). By
116 * convention, these messages are all produced by scsi_enumeration_failed().
117 */
118 typedef enum { SE_BUSCONFIG = 0, SE_HP = 1 } scsi_enum_t;
119
120 /* compatible properties of driver to use during probe/enumeration operations */
121 static char *compatible_probe = "scsa,probe";
122 static char *compatible_nodev = "scsa,nodev";
123 static char *scsi_probe_ascii[] = SCSIPROBE_ASCII;
124
125 /* number of LUNs we attempt to get on the first SCMD_REPORT_LUNS command */
126 int scsi_lunrpt_default_max = 256;
127 int scsi_lunrpt_timeout = 3; /* seconds */
128
129 /*
130 * Only enumerate one lun if reportluns fails on a SCSI_VERSION_3 device
131 * (tunable based on calling context).
132 */
133 int scsi_lunrpt_failed_do1lun = (1 << SE_HP);
134
135 /* 'scsi-binding-set' value for legacy enumerated 'spi' transports */
136 char *scsi_binding_set_spi = "spi";
137
138 /* enable NDI_DEVI_DEBUG for bus_[un]config operations */
139 int scsi_hba_bus_config_debug = 0;
140
141 /* DEBUG: enable NDI_DEVI_REMOVE for bus_unconfig of dynamic node */
142 int scsi_hba_bus_unconfig_remove = 0;
143
144 /* number of probe serilization messages */
145 int scsi_hba_wait_msg = 5;
146
147 /*
148 * Establish the timeout used to cache (in the probe node) the fact that the
149 * device does not exist. This replaces the target specific probe cache.
150 */
151 int scsi_hba_barrier_timeout = (60); /* seconds */
152
153 #ifdef DEBUG
154 int scsi_hba_bus_config_failure_msg = 0;
155 int scsi_hba_bus_config_failure_dbg = 0;
156 int scsi_hba_bus_config_success_msg = 0;
157 int scsi_hba_bus_config_success_dbg = 0;
158 #endif /* DEBUG */
159
160 /*
161 * Structure for scsi_hba_iportmap_* implementation/wrap.
162 */
163 typedef struct impl_scsi_iportmap {
164 dev_info_t *iportmap_hba_dip;
165 damap_t *iportmap_dam;
166 int iportmap_create_window;
167 uint64_t iportmap_create_time; /* clock64_t */
168 int iportmap_create_csync_usec;
169 int iportmap_settle_usec;
170 int iportmap_sync_cnt;
171 } impl_scsi_iportmap_t;
172
173 /*
174 * Structure for scsi_hba_tgtmap_* implementation/wrap.
175 *
176 * Every call to scsi_hba_tgtmap_set_begin will increment tgtmap_reports,
177 * and a call to scsi_hba_tgtmap_set_end will reset tgtmap_reports to zero.
178 * If, in scsi_hba_tgtmap_set_begin, we detect a tgtmap_reports value of
179 * scsi_hba_tgtmap_reports_max we produce a message to indicate that
180 * the caller is never completing an observation (i.e. we are not making
181 * any forward progress). If this message occurs, it indicates that the
182 * solaris hotplug ramifications at the target and lun level are no longer
183 * tracking.
184 *
185 * NOTE: LUNMAPSIZE OK for now, but should be dynamic in reportlun code.
186 */
187 typedef struct impl_scsi_tgtmap {
188 scsi_hba_tran_t *tgtmap_tran;
189 int tgtmap_reports; /* _begin, no _end */
190 int tgtmap_noisy;
191 scsi_tgt_activate_cb_t tgtmap_activate_cb;
192 scsi_tgt_deactivate_cb_t tgtmap_deactivate_cb;
193 void *tgtmap_mappriv;
194 damap_t *tgtmap_dam[SCSI_TGT_NTYPES];
195 int tgtmap_create_window;
196 uint64_t tgtmap_create_time; /* clock64_t */
197 int tgtmap_create_csync_usec;
198 int tgtmap_settle_usec;
199 int tgtmap_sync_cnt;
200 } impl_scsi_tgtmap_t;
201 #define LUNMAPSIZE 256 /* 256 LUNs/target */
202
203 /* Produce warning if number of begins without an end exceed this value */
204 int scsi_hba_tgtmap_reports_max = 256;
205
206 static int scsi_tgtmap_sync(scsi_hba_tgtmap_t *, int);
207
208 /* Default settle_usec damap_sync factor */
209 int scsi_hba_map_settle_f = 10;
210
211
212 /* Prototype for static dev_ops devo_*() functions */
213 static int scsi_hba_info(
214 dev_info_t *self,
215 ddi_info_cmd_t infocmd,
216 void *arg,
217 void **result);
218
219 /* Prototypes for static bus_ops bus_*() functions */
220 static int scsi_hba_bus_ctl(
221 dev_info_t *self,
222 dev_info_t *child,
223 ddi_ctl_enum_t op,
224 void *arg,
225 void *result);
226
227 static int scsi_hba_map_fault(
228 dev_info_t *self,
229 dev_info_t *child,
230 struct hat *hat,
231 struct seg *seg,
232 caddr_t addr,
233 struct devpage *dp,
234 pfn_t pfn,
235 uint_t prot,
236 uint_t lock);
237
238 static int scsi_hba_get_eventcookie(
239 dev_info_t *self,
240 dev_info_t *child,
241 char *name,
242 ddi_eventcookie_t *eventp);
243
244 static int scsi_hba_add_eventcall(
245 dev_info_t *self,
246 dev_info_t *child,
247 ddi_eventcookie_t event,
248 void (*callback)(
249 dev_info_t *dip,
250 ddi_eventcookie_t event,
251 void *arg,
252 void *bus_impldata),
253 void *arg,
254 ddi_callback_id_t *cb_id);
255
256 static int scsi_hba_remove_eventcall(
257 dev_info_t *self,
258 ddi_callback_id_t id);
259
260 static int scsi_hba_post_event(
261 dev_info_t *self,
262 dev_info_t *child,
263 ddi_eventcookie_t event,
264 void *bus_impldata);
265
266 static int scsi_hba_bus_config(
267 dev_info_t *self,
268 uint_t flags,
269 ddi_bus_config_op_t op,
270 void *arg,
271 dev_info_t **childp);
272
273 static int scsi_hba_bus_unconfig(
274 dev_info_t *self,
275 uint_t flags,
276 ddi_bus_config_op_t op,
277 void *arg);
278
279 static int scsi_hba_fm_init_child(
280 dev_info_t *self,
281 dev_info_t *child,
282 int cap,
283 ddi_iblock_cookie_t *ibc);
284
285 static int scsi_hba_bus_power(
286 dev_info_t *self,
287 void *impl_arg,
288 pm_bus_power_op_t op,
289 void *arg,
290 void *result);
291
292 /* bus_ops vector for SCSI HBA's. */
293 static struct bus_ops scsi_hba_busops = {
294 BUSO_REV,
295 nullbusmap, /* bus_map */
296 NULL, /* bus_get_intrspec */
297 NULL, /* bus_add_intrspec */
298 NULL, /* bus_remove_intrspec */
299 scsi_hba_map_fault, /* bus_map_fault */
300 NULL, /* bus_dma_map */
301 ddi_dma_allochdl, /* bus_dma_allochdl */
302 ddi_dma_freehdl, /* bus_dma_freehdl */
303 ddi_dma_bindhdl, /* bus_dma_bindhdl */
304 ddi_dma_unbindhdl, /* bus_unbindhdl */
305 ddi_dma_flush, /* bus_dma_flush */
306 ddi_dma_win, /* bus_dma_win */
307 ddi_dma_mctl, /* bus_dma_ctl */
308 scsi_hba_bus_ctl, /* bus_ctl */
309 ddi_bus_prop_op, /* bus_prop_op */
310 scsi_hba_get_eventcookie, /* bus_get_eventcookie */
311 scsi_hba_add_eventcall, /* bus_add_eventcall */
312 scsi_hba_remove_eventcall, /* bus_remove_eventcall */
313 scsi_hba_post_event, /* bus_post_event */
314 NULL, /* bus_intr_ctl */
315 scsi_hba_bus_config, /* bus_config */
316 scsi_hba_bus_unconfig, /* bus_unconfig */
317 scsi_hba_fm_init_child, /* bus_fm_init */
318 NULL, /* bus_fm_fini */
319 NULL, /* bus_fm_access_enter */
320 NULL, /* bus_fm_access_exit */
321 scsi_hba_bus_power /* bus_power */
322 };
323
324 /* cb_ops for hotplug :devctl and :scsi support */
325 static struct cb_ops scsi_hba_cbops = {
326 scsi_hba_open,
327 scsi_hba_close,
328 nodev, /* strategy */
329 nodev, /* print */
330 nodev, /* dump */
331 nodev, /* read */
332 nodev, /* write */
333 scsi_hba_ioctl, /* ioctl */
334 nodev, /* devmap */
335 nodev, /* mmap */
336 nodev, /* segmap */
337 nochpoll, /* poll */
338 ddi_prop_op, /* prop_op */
339 NULL, /* stream */
340 D_NEW|D_MP|D_HOTPLUG, /* cb_flag */
341 CB_REV, /* rev */
342 nodev, /* int (*cb_aread)() */
343 nodev /* int (*cb_awrite)() */
344 };
345
346 /* Prototypes for static scsi_hba.c/SCSA private lunmap interfaces */
347 static int scsi_lunmap_create(
348 dev_info_t *self,
349 impl_scsi_tgtmap_t *tgtmap,
350 char *tgt_addr);
351 static void scsi_lunmap_destroy(
352 dev_info_t *self,
353 impl_scsi_tgtmap_t *tgtmap,
354 char *tgt_addr);
355 static void scsi_lunmap_set_begin(
356 dev_info_t *self,
357 damap_t *lundam);
358 static int scsi_lunmap_set_add(
359 dev_info_t *self,
360 damap_t *lundam,
361 char *taddr,
362 scsi_lun64_t lun_num,
363 int lun_sfunc);
364 static void scsi_lunmap_set_end(
365 dev_info_t *self,
366 damap_t *lundam);
367
368 /* Prototypes for static misc. scsi_hba.c private bus_config interfaces */
369 static int scsi_hba_bus_config_iports(dev_info_t *self, uint_t flags,
370 ddi_bus_config_op_t op, void *arg, dev_info_t **childp);
371 static int scsi_hba_bus_config_spi(dev_info_t *self, uint_t flags,
372 ddi_bus_config_op_t op, void *arg, dev_info_t **childp);
373 static dev_info_t *scsi_hba_bus_config_port(dev_info_t *self,
374 char *nameaddr, scsi_enum_t se);
375
376 #ifdef sparc
377 static int scsi_hba_bus_config_prom_node(dev_info_t *self, uint_t flags,
378 void *arg, dev_info_t **childp);
379 #endif /* sparc */
380
381
382 /*
383 * SCSI_HBA_LOG is used for all messages. A logging level is specified when
384 * generating a message. Some levels correspond directly to cmn_err levels,
385 * some are associated with increasing levels diagnostic/debug output (LOG1-4),
386 * and others are associated with specific levels of interface (LOGMAP).
387 * For _LOG() messages, a __func__ prefix will identify the function origin
388 * of the message. For _LOG_NF messages, there is no function prefix or
389 * self/child context. Filtering of messages is provided based on logging
390 * level, but messages with cmn_err logging level and messages generated
391 * generated with _LOG_NF() are never filtered.
392 *
393 * For debugging, more complete information can be displayed with each message
394 * (full device path and pointer values) by adjusting scsi_hba_log_info.
395 */
396 /* logging levels */
397 #define SCSI_HBA_LOGCONT CE_CONT
398 #define SCSI_HBA_LOGNOTE CE_NOTE
399 #define SCSI_HBA_LOGWARN CE_WARN
400 #define SCSI_HBA_LOGPANIC CE_PANIC
401 #define SCSI_HBA_LOGIGNORE CE_IGNORE
402 #define SCSI_HBA_LOG_CE_MASK 0x0000000F /* no filter for these levels */
403 #define SCSI_HBA_LOG1 0x00000010 /* DIAG1 level enable */
404 #define SCSI_HBA_LOG2 0x00000020 /* DIAG2 level enable */
405 #define SCSI_HBA_LOG3 0x00000040 /* DIAG3 level enable */
406 #define SCSI_HBA_LOG4 0x00000080 /* DIAG4 level enable */
407 #define SCSI_HBA_LOGMAPPHY 0x00000100 /* MAPPHY level enable */
408 #define SCSI_HBA_LOGMAPIPT 0x00000200 /* MAPIPT level enable */
409 #define SCSI_HBA_LOGMAPTGT 0x00000400 /* MAPTGT level enable */
410 #define SCSI_HBA_LOGMAPLUN 0x00000800 /* MAPLUN level enable */
411 #define SCSI_HBA_LOGMAPCFG 0x00001000 /* MAPCFG level enable */
412 #define SCSI_HBA_LOGMAPUNCFG 0x00002000 /* MAPUNCFG level enable */
413 #define SCSI_HBA_LOGTRACE 0x00010000 /* TRACE enable */
414 #if (CE_CONT | CE_NOTE | CE_WARN | CE_PANIC | CE_IGNORE) > SCSI_HBA_LOG_CE_MASK
415 Error, problem with CE_ definitions
416 #endif
417
418 /*
419 * Tunable log message augmentation and filters: filters do not apply to
420 * SCSI_HBA_LOG_CE_MASK level messages or LOG_NF() messages.
421 *
422 * An example set of /etc/system tunings to simplify debug a SCSA pHCI HBA
423 * driver called "pmcs", including "scsi_vhci" operation, by capturing
424 * log information in the system log might be:
425 *
426 * echo "set scsi:scsi_hba_log_filter_level=0x3ff0" >> /etc/system
427 * echo "set scsi:scsi_hba_log_filter_phci=\"pmcs\"" >> /etc/system
428 * echo "set scsi:scsi_hba_log_filter_vhci=\"scsi_vhci\"" >> /etc/system
429 *
430 * To capture information on just HBA-SCSAv3 *map operation, use
431 * echo "set scsi:scsi_hba_log_filter_level=0x3f10" >> /etc/system
432 *
433 * For debugging an HBA driver, you may also want to set:
434 *
435 * echo "set scsi:scsi_hba_log_align=1" >> /etc/system
436 * echo "set scsi:scsi_hba_log_mt_disable=0x6" >> /etc/system
437 * echo "set mtc_off=1" >> /etc/system
438 * echo "set mdi_mtc_off=1" >> /etc/system
439 * echo "set scsi:scsi_hba_log_fcif=0" >> /etc/system
440 */
441 int scsi_hba_log_filter_level =
442 SCSI_HBA_LOG1 |
443 0;
444 char *scsi_hba_log_filter_phci = "\0\0\0\0\0\0\0\0\0\0\0\0";
445 char *scsi_hba_log_filter_vhci = "\0\0\0\0\0\0\0\0\0\0\0\0";
446 int scsi_hba_log_align = 0; /* NOTE: will not cause truncation */
447 int scsi_hba_log_fcif = '!'; /* "^!?" first char in format */
448 /* NOTE: iff level > SCSI_HBA_LOG1 */
449 /* '\0'0x00 -> console and system log */
450 /* '^' 0x5e -> console_only */
451 /* '!' 0x21 -> system log only */
452 /* '?' 0x2F -> See cmn_err(9F) */
453 int scsi_hba_log_info = /* augmentation: extra info output */
454 (0 << 0) | /* 0x0001: process information */
455 (0 << 1) | /* 0x0002: full /devices path */
456 (0 << 2); /* 0x0004: devinfo pointer */
457
458 int scsi_hba_log_mt_disable =
459 /* SCSI_ENUMERATION_MT_LUN_DISABLE | (ie 0x02) */
460 /* SCSI_ENUMERATION_MT_TARGET_DISABLE | (ie 0x04) */
461 0;
462
463 /* static data for HBA logging subsystem */
464 static kmutex_t scsi_hba_log_mutex;
465 static char scsi_hba_log_i[512];
466 static char scsi_hba_log_buf[512];
467 static char scsi_hba_fmt[512];
468
469 /* Macros to use in scsi_hba.c source code below */
470 #define SCSI_HBA_LOG(x) scsi_hba_log x
471 #define _LOG(level) SCSI_HBA_LOG##level, __func__
472 #define _MAP(map) SCSI_HBA_LOGMAP##map, __func__
473 #define _LOG_NF(level) SCSI_HBA_LOG##level, NULL, NULL, NULL
474 #define _LOG_TRACE _LOG(TRACE)
475 #define _LOGLUN _MAP(LUN)
476 #define _LOGTGT _MAP(TGT)
477 #define _LOGIPT _MAP(IPT)
478 #define _LOGPHY _MAP(PHY)
479 #define _LOGCFG _MAP(CFG)
480 #define _LOGUNCFG _MAP(UNCFG)
481
482 /*PRINTFLIKE5*/
483 static void
scsi_hba_log(int level,const char * func,dev_info_t * self,dev_info_t * child,const char * fmt,...)484 scsi_hba_log(int level, const char *func, dev_info_t *self, dev_info_t *child,
485 const char *fmt, ...)
486 {
487 va_list ap;
488 int clevel;
489 int align;
490 char *info;
491 char *f;
492 char *ua;
493
494 /* derive self from child's parent */
495 if ((self == NULL) && child)
496 self = ddi_get_parent(child);
497
498 /* no filtering of SCSI_HBA_LOG_CE_MASK or LOG_NF messages */
499 if (((level & SCSI_HBA_LOG_CE_MASK) != level) && (func != NULL)) {
500 /* scsi_hba_log_filter_level: filter on level as bitmask */
501 if ((level & scsi_hba_log_filter_level) == 0)
502 return;
503
504 /* scsi_hba_log_filter_phci/vhci: on name of driver */
505 if (*scsi_hba_log_filter_phci &&
506 ((self == NULL) ||
507 (ddi_driver_name(self) == NULL) ||
508 strcmp(ddi_driver_name(self), scsi_hba_log_filter_phci))) {
509 /* does not match pHCI, check vHCI */
510 if (*scsi_hba_log_filter_vhci &&
511 ((self == NULL) ||
512 (ddi_driver_name(self) == NULL) ||
513 strcmp(ddi_driver_name(self),
514 scsi_hba_log_filter_vhci))) {
515 /* does not match vHCI */
516 return;
517 }
518 }
519
520
521 /* passed filters, determine align */
522 align = scsi_hba_log_align;
523
524 /* shorten func for filtered output */
525 if (strncmp(func, "scsi_hba_", 9) == 0)
526 func += 9;
527 if (strncmp(func, "scsi_", 5) == 0)
528 func += 5;
529 } else {
530 /* don't align output that is never filtered */
531 align = 0;
532 }
533
534 /* determine the cmn_err form from the level */
535 clevel = ((level & SCSI_HBA_LOG_CE_MASK) == level) ? level : CE_CONT;
536
537 /* protect common buffers used to format output */
538 mutex_enter(&scsi_hba_log_mutex);
539
540 /* skip special first characters, we add them back below */
541 f = (char *)fmt;
542 if (*f && strchr("^!?", *f))
543 f++;
544 va_start(ap, fmt);
545 (void) vsprintf(scsi_hba_log_buf, f, ap);
546 va_end(ap);
547
548 /* augment message with 'information' */
549 info = scsi_hba_log_i;
550 *info = '\0';
551 if ((scsi_hba_log_info & 0x0001) && curproc != NULL &&
552 PTOU(curproc)->u_comm[0] != '\0') {
553 (void) sprintf(info, "%s[%d]%p ",
554 PTOU(curproc)->u_comm, curproc->p_pid, (void *)curthread);
555 info += strlen(info);
556 }
557 if (self) {
558 if ((scsi_hba_log_info & 0x0004) && (child || self)) {
559 (void) sprintf(info, "%p ",
560 (void *)(child ? child : self));
561 info += strlen(info);
562 }
563 if (scsi_hba_log_info & 0x0002) {
564 (void) ddi_pathname(child ? child : self, info);
565 (void) strcat(info, " ");
566 info += strlen(info);
567 }
568
569 /* always provide 'default' information about self &child */
570 (void) sprintf(info, "%s%d ", ddi_driver_name(self),
571 ddi_get_instance(self));
572 info += strlen(info);
573 if (child) {
574 ua = ddi_get_name_addr(child);
575 (void) sprintf(info, "%s@%s ",
576 ddi_node_name(child), (ua && *ua) ? ua : "");
577 info += strlen(info);
578 }
579 }
580
581 /* turn off alignment if truncation would occur */
582 if (align && ((strlen(func) > 18) || (strlen(scsi_hba_log_i) > 36)))
583 align = 0;
584
585 /* adjust for aligned output */
586 if (align) {
587 if (func == NULL)
588 func = "";
589 /* remove trailing blank with align output */
590 if ((info != scsi_hba_log_i) && (*(info -1) == '\b'))
591 *(info - 1) = '\0';
592 }
593
594 /* special "first character in format" must be in format itself */
595 f = scsi_hba_fmt;
596 if (fmt[0] && strchr("^!?", fmt[0]))
597 *f++ = fmt[0];
598 else if (scsi_hba_log_fcif && (level > SCSI_HBA_LOG1))
599 *f++ = (char)scsi_hba_log_fcif; /* add global fcif */
600 if (align)
601 (void) sprintf(f, "%s", "%-18.18s: %36.36s: %s%s");
602 else
603 (void) sprintf(f, "%s", func ? "%s: %s%s%s" : "%s%s%s");
604
605 if (func)
606 cmn_err(clevel, scsi_hba_fmt, func, scsi_hba_log_i,
607 scsi_hba_log_buf, clevel == CE_CONT ? "\n" : "");
608 else
609 cmn_err(clevel, scsi_hba_fmt, scsi_hba_log_i,
610 scsi_hba_log_buf, clevel == CE_CONT ? "\n" : "");
611 mutex_exit(&scsi_hba_log_mutex);
612 }
613
614 int scsi_enumeration_failed_panic = 0;
615 int scsi_enumeration_failed_hotplug = 1;
616
617 static void
scsi_enumeration_failed(dev_info_t * child,scsi_enum_t se,char * arg,char * when)618 scsi_enumeration_failed(dev_info_t *child, scsi_enum_t se,
619 char *arg, char *when)
620 {
621 /* If 'se' is -1 the 'se' value comes from child. */
622 if (se == -1) {
623 ASSERT(child);
624 se = ndi_dev_is_hotplug_node(child) ? SE_HP : SE_BUSCONFIG;
625 }
626
627 if (scsi_enumeration_failed_panic) {
628 /* set scsi_enumeration_failed_panic to debug */
629 SCSI_HBA_LOG((_LOG(PANIC), NULL, child,
630 "%s%senumeration failed during %s",
631 arg ? arg : "", arg ? " " : "", when));
632 } else if (scsi_enumeration_failed_hotplug && (se == SE_HP)) {
633 /* set scsi_enumeration_failed_hotplug for console messages */
634 SCSI_HBA_LOG((_LOG(WARN), NULL, child,
635 "%s%senumeration failed during %s",
636 arg ? arg : "", arg ? " " : "", when));
637 } else {
638 /* default */
639 SCSI_HBA_LOG((_LOG(2), NULL, child,
640 "%s%senumeration failed during %s",
641 arg ? arg : "", arg ? " " : "", when));
642 }
643 }
644
645 /*
646 * scsi_hba version of [nm]di_devi_enter/[nm]di_devi_exit that detects if HBA
647 * is a PHCI, and chooses mdi/ndi locking implementation.
648 */
649 static void
scsi_hba_devi_enter(dev_info_t * self,boolean_t * enteredvp)650 scsi_hba_devi_enter(dev_info_t *self, boolean_t *enteredvp)
651 {
652 if (MDI_PHCI(self))
653 mdi_devi_enter(self, enteredvp);
654 else
655 ndi_devi_enter(self);
656 }
657
658 static int
scsi_hba_devi_tryenter(dev_info_t * self,boolean_t * enteredvp)659 scsi_hba_devi_tryenter(dev_info_t *self, boolean_t *enteredvp)
660 {
661 if (MDI_PHCI(self))
662 return (mdi_devi_tryenter(self, enteredvp));
663 else
664 return (ndi_devi_tryenter(self));
665 }
666
667 static void
scsi_hba_devi_exit(dev_info_t * self,boolean_t enteredv)668 scsi_hba_devi_exit(dev_info_t *self, boolean_t enteredv)
669 {
670 if (MDI_PHCI(self))
671 mdi_devi_exit(self, enteredv);
672 else
673 ndi_devi_exit(self);
674 }
675
676 static void
scsi_hba_devi_enter_phci(dev_info_t * self)677 scsi_hba_devi_enter_phci(dev_info_t *self)
678 {
679 if (MDI_PHCI(self))
680 mdi_devi_enter_phci(self);
681 }
682
683 static void
scsi_hba_devi_exit_phci(dev_info_t * self)684 scsi_hba_devi_exit_phci(dev_info_t *self)
685 {
686 if (MDI_PHCI(self))
687 mdi_devi_exit_phci(self);
688 }
689
690 static int
scsi_hba_dev_is_sid(dev_info_t * child)691 scsi_hba_dev_is_sid(dev_info_t *child)
692 {
693 /*
694 * Use ndi_dev_is_persistent_node instead of ddi_dev_is_sid to avoid
695 * any possible locking issues in mixed nexus devctl code (like usb).
696 */
697 return (ndi_dev_is_persistent_node(child));
698 }
699
700 /*
701 * Called from _init() when loading "scsi" module
702 */
703 void
scsi_initialize_hba_interface()704 scsi_initialize_hba_interface()
705 {
706 SCSI_HBA_LOG((_LOG_TRACE, NULL, NULL, __func__));
707
708 /* We need "scsiprobe" and "scsinodev" as an alias or a driver. */
709 if (ddi_name_to_major(compatible_probe) == DDI_MAJOR_T_NONE) {
710 SCSI_HBA_LOG((_LOG_NF(WARN), "failed to resolve '%s' "
711 "driver alias, defaulting to 'nulldriver'",
712 compatible_probe));
713
714 /* If no "nulldriver" driver nothing will work... */
715 compatible_probe = "nulldriver";
716 if (ddi_name_to_major(compatible_probe) == DDI_MAJOR_T_NONE)
717 SCSI_HBA_LOG((_LOG_NF(WARN), "no probe '%s' driver, "
718 "system misconfigured", compatible_probe));
719 }
720 if (ddi_name_to_major(compatible_nodev) == DDI_MAJOR_T_NONE) {
721 SCSI_HBA_LOG((_LOG_NF(WARN), "failed to resolve '%s' "
722 "driver alias, defaulting to 'nulldriver'",
723 compatible_nodev));
724
725 /* If no "nulldriver" driver nothing will work... */
726 compatible_nodev = "nulldriver";
727 if (ddi_name_to_major(compatible_nodev) == DDI_MAJOR_T_NONE)
728 SCSI_HBA_LOG((_LOG_NF(WARN), "no nodev '%s' driver, "
729 "system misconfigured", compatible_nodev));
730 }
731
732 /*
733 * Verify our special node name "probe" will not be used in other ways.
734 * Don't expect things to work if they are.
735 */
736 if (ddi_major_to_name(ddi_name_to_major("probe")))
737 SCSI_HBA_LOG((_LOG_NF(WARN),
738 "driver already using special node name 'probe'"));
739
740 mutex_init(&scsi_log_mutex, NULL, MUTEX_DRIVER, NULL);
741 mutex_init(&scsi_flag_nointr_mutex, NULL, MUTEX_DRIVER, NULL);
742 cv_init(&scsi_flag_nointr_cv, NULL, CV_DRIVER, NULL);
743 mutex_init(&scsi_hba_log_mutex, NULL, MUTEX_DRIVER, NULL);
744
745 /* initialize the asynchronous barrier deletion daemon */
746 mutex_init(&scsi_hba_barrier_mutex, NULL, MUTEX_DRIVER, NULL);
747 cv_init(&scsi_hba_barrier_cv, NULL, CV_DRIVER, NULL);
748 (void) thread_create(NULL, 0,
749 (void (*)())scsi_hba_barrier_daemon, NULL,
750 0, &p0, TS_RUN, minclsyspri);
751
752 /* initialize lun change ASC/ASCQ processing daemon (stage1 & stage2) */
753 mutex_init(&scsi_lunchg1_mutex, NULL, MUTEX_DRIVER, NULL);
754 cv_init(&scsi_lunchg1_cv, NULL, CV_DRIVER, NULL);
755 (void) thread_create(NULL, 0,
756 (void (*)())scsi_lunchg1_daemon, NULL,
757 0, &p0, TS_RUN, minclsyspri);
758 mutex_init(&scsi_lunchg2_mutex, NULL, MUTEX_DRIVER, NULL);
759 cv_init(&scsi_lunchg2_cv, NULL, CV_DRIVER, NULL);
760 (void) thread_create(NULL, 0,
761 (void (*)())scsi_lunchg2_daemon, NULL,
762 0, &p0, TS_RUN, minclsyspri);
763 }
764
765 int
scsi_hba_pkt_constructor(void * buf,void * arg,int kmflag)766 scsi_hba_pkt_constructor(void *buf, void *arg, int kmflag)
767 {
768 struct scsi_pkt_cache_wrapper *pktw;
769 struct scsi_pkt *pkt;
770 scsi_hba_tran_t *tran = (scsi_hba_tran_t *)arg;
771 int pkt_len;
772 char *ptr;
773
774 /*
775 * allocate a chunk of memory for the following:
776 * scsi_pkt
777 * pcw_* fields
778 * pkt_ha_private
779 * pkt_cdbp, if needed
780 * (pkt_private always null)
781 * pkt_scbp, if needed
782 */
783 pkt_len = tran->tran_hba_len + sizeof (struct scsi_pkt_cache_wrapper);
784 if (tran->tran_hba_flags & SCSI_HBA_TRAN_CDB)
785 pkt_len += DEFAULT_CDBLEN;
786 if (tran->tran_hba_flags & SCSI_HBA_TRAN_SCB)
787 pkt_len += DEFAULT_SCBLEN;
788 bzero(buf, pkt_len);
789
790 ptr = buf;
791 pktw = buf;
792 ptr += sizeof (struct scsi_pkt_cache_wrapper);
793 pkt = &(pktw->pcw_pkt);
794 pkt->pkt_ha_private = (opaque_t)ptr;
795
796 pktw->pcw_magic = PKT_WRAPPER_MAGIC; /* alloced correctly */
797 /*
798 * keep track of the granularity at the time this handle was
799 * allocated
800 */
801 pktw->pcw_granular = tran->tran_dma_attr.dma_attr_granular;
802
803 if (ddi_dma_alloc_handle(tran->tran_hba_dip, &tran->tran_dma_attr,
804 kmflag == KM_SLEEP ? SLEEP_FUNC: NULL_FUNC, NULL,
805 &pkt->pkt_handle) != DDI_SUCCESS) {
806
807 return (-1);
808 }
809 ptr += tran->tran_hba_len;
810 if (tran->tran_hba_flags & SCSI_HBA_TRAN_CDB) {
811 pkt->pkt_cdbp = (opaque_t)ptr;
812 ptr += DEFAULT_CDBLEN;
813 }
814 pkt->pkt_private = NULL;
815 if (tran->tran_hba_flags & SCSI_HBA_TRAN_SCB)
816 pkt->pkt_scbp = (opaque_t)ptr;
817 if (tran->tran_pkt_constructor)
818 return ((*tran->tran_pkt_constructor)(pkt, arg, kmflag));
819 else
820 return (0);
821 }
822
823 #define P_TO_TRAN(pkt) ((pkt)->pkt_address.a_hba_tran)
824
825 void
scsi_hba_pkt_destructor(void * buf,void * arg)826 scsi_hba_pkt_destructor(void *buf, void *arg)
827 {
828 struct scsi_pkt_cache_wrapper *pktw = buf;
829 struct scsi_pkt *pkt = &(pktw->pcw_pkt);
830 scsi_hba_tran_t *tran = (scsi_hba_tran_t *)arg;
831
832 ASSERT(pktw->pcw_magic == PKT_WRAPPER_MAGIC);
833 ASSERT((pktw->pcw_flags & PCW_BOUND) == 0);
834 if (tran->tran_pkt_destructor)
835 (*tran->tran_pkt_destructor)(pkt, arg);
836
837 /* make sure nobody messed with our pointers */
838 ASSERT(pkt->pkt_ha_private == (opaque_t)((char *)pkt +
839 sizeof (struct scsi_pkt_cache_wrapper)));
840 ASSERT(((tran->tran_hba_flags & SCSI_HBA_TRAN_SCB) == 0) ||
841 (pkt->pkt_scbp == (opaque_t)((char *)pkt +
842 tran->tran_hba_len +
843 (((tran->tran_hba_flags & SCSI_HBA_TRAN_CDB) == 0) ?
844 0 : DEFAULT_CDBLEN) +
845 DEFAULT_PRIVLEN + sizeof (struct scsi_pkt_cache_wrapper))));
846 ASSERT(((tran->tran_hba_flags & SCSI_HBA_TRAN_CDB) == 0) ||
847 (pkt->pkt_cdbp == (opaque_t)((char *)pkt +
848 tran->tran_hba_len +
849 sizeof (struct scsi_pkt_cache_wrapper))));
850 ASSERT(pkt->pkt_handle);
851 ddi_dma_free_handle(&pkt->pkt_handle);
852 pkt->pkt_handle = NULL;
853 pkt->pkt_numcookies = 0;
854 pktw->pcw_total_xfer = 0;
855 pktw->pcw_totalwin = 0;
856 pktw->pcw_curwin = 0;
857 }
858
859 /*
860 * Called by an HBA from _init() to plumb in common SCSA bus_ops and
861 * cb_ops for the HBA's :devctl and :scsi minor nodes.
862 */
863 int
scsi_hba_init(struct modlinkage * modlp)864 scsi_hba_init(struct modlinkage *modlp)
865 {
866 struct dev_ops *hba_dev_ops;
867
868 SCSI_HBA_LOG((_LOG_TRACE, NULL, NULL, __func__));
869
870 /*
871 * Get a pointer to the dev_ops structure of the HBA and plumb our
872 * bus_ops vector into the HBA's dev_ops structure.
873 */
874 hba_dev_ops = ((struct modldrv *)(modlp->ml_linkage[0]))->drv_dev_ops;
875 ASSERT(hba_dev_ops->devo_bus_ops == NULL);
876 hba_dev_ops->devo_bus_ops = &scsi_hba_busops;
877
878 /*
879 * Plumb our cb_ops vector into the HBA's dev_ops structure to
880 * provide getinfo and hotplugging ioctl support if the HBA driver
881 * does not already provide this support.
882 */
883 if (hba_dev_ops->devo_cb_ops == NULL) {
884 hba_dev_ops->devo_cb_ops = &scsi_hba_cbops;
885 }
886 if (hba_dev_ops->devo_cb_ops->cb_open == scsi_hba_open) {
887 ASSERT(hba_dev_ops->devo_cb_ops->cb_close == scsi_hba_close);
888 hba_dev_ops->devo_getinfo = scsi_hba_info;
889 }
890 return (0);
891 }
892
893 /*
894 * Called by an HBA attach(9E) to allocate a scsi_hba_tran(9S) structure. An
895 * HBA driver will then initialize the structure and then call
896 * scsi_hba_attach_setup(9F).
897 */
898 /*ARGSUSED*/
899 scsi_hba_tran_t *
scsi_hba_tran_alloc(dev_info_t * self,int flags)900 scsi_hba_tran_alloc(
901 dev_info_t *self,
902 int flags)
903 {
904 scsi_hba_tran_t *tran;
905
906 SCSI_HBA_LOG((_LOG_TRACE, self, NULL, __func__));
907
908 /* allocate SCSA flavors for self */
909 ndi_flavorv_alloc(self, SCSA_NFLAVORS);
910
911 tran = kmem_zalloc(sizeof (scsi_hba_tran_t),
912 (flags & SCSI_HBA_CANSLEEP) ? KM_SLEEP : KM_NOSLEEP);
913
914 if (tran) {
915 tran->tran_interconnect_type = INTERCONNECT_PARALLEL;
916
917 /*
918 * HBA driver called scsi_hba_tran_alloc(), so tran structure
919 * is proper size and unused/newer fields are zero.
920 *
921 * NOTE: We use SCSA_HBA_SCSA_TA as an obtuse form of
922 * versioning to detect old HBA drivers that do not use
923 * scsi_hba_tran_alloc, and would present garbage data
924 * (instead of valid/zero data) for newer tran fields.
925 */
926 tran->tran_hba_flags |= SCSI_HBA_SCSA_TA;
927 }
928
929 return (tran);
930 }
931
932 /*
933 * Called by an HBA to free a scsi_hba_tran structure
934 */
935 void
scsi_hba_tran_free(scsi_hba_tran_t * tran)936 scsi_hba_tran_free(
937 scsi_hba_tran_t *tran)
938 {
939 SCSI_HBA_LOG((_LOG_TRACE, tran->tran_hba_dip, NULL, __func__));
940
941 kmem_free(tran, sizeof (scsi_hba_tran_t));
942 }
943
944 int
scsi_tran_ext_alloc(scsi_hba_tran_t * tran,size_t length,int flags)945 scsi_tran_ext_alloc(
946 scsi_hba_tran_t *tran,
947 size_t length,
948 int flags)
949 {
950 void *tran_ext;
951 int ret = DDI_FAILURE;
952
953 tran_ext = kmem_zalloc(length,
954 (flags & SCSI_HBA_CANSLEEP) ? KM_SLEEP : KM_NOSLEEP);
955 if (tran_ext != NULL) {
956 tran->tran_extension = tran_ext;
957 ret = DDI_SUCCESS;
958 }
959 return (ret);
960 }
961
962 void
scsi_tran_ext_free(scsi_hba_tran_t * tran,size_t length)963 scsi_tran_ext_free(
964 scsi_hba_tran_t *tran,
965 size_t length)
966 {
967 if (tran->tran_extension != NULL) {
968 kmem_free(tran->tran_extension, length);
969 tran->tran_extension = NULL;
970 }
971 }
972
973 /*
974 * Common nexus teardown code: used by both scsi_hba_detach() on SCSA HBA node
975 * and iport_postdetach_tran_scsi_device() on a SCSA HBA iport node (and for
976 * failure cleanup). Undo scsa_nexus_setup in reverse order.
977 *
978 * NOTE: Since we are in the Solaris IO framework, we can depend on
979 * undocumented cleanup operations performed by other parts of the framework:
980 * like detach_node() calling ddi_prop_remove_all() and
981 * ddi_remove_minor_node(,NULL).
982 */
983 static void
scsa_nexus_teardown(dev_info_t * self,scsi_hba_tran_t * tran)984 scsa_nexus_teardown(dev_info_t *self, scsi_hba_tran_t *tran)
985 {
986 /* Teardown FMA. */
987 if (tran->tran_hba_flags & SCSI_HBA_SCSA_FM) {
988 ddi_fm_fini(self);
989 tran->tran_hba_flags &= ~SCSI_HBA_SCSA_FM;
990 }
991 }
992
993 /*
994 * Common nexus setup code: used by both scsi_hba_attach_setup() on SCSA HBA
995 * node and iport_preattach_tran_scsi_device() on a SCSA HBA iport node.
996 *
997 * This code makes no assumptions about tran use by scsi_device children.
998 */
999 static int
scsa_nexus_setup(dev_info_t * self,scsi_hba_tran_t * tran)1000 scsa_nexus_setup(dev_info_t *self, scsi_hba_tran_t *tran)
1001 {
1002 int capable;
1003 int scsa_minor;
1004
1005 /*
1006 * NOTE: SCSA maintains an 'fm-capable' domain, in tran_fm_capable,
1007 * that is not dependent (limited by) the capabilities of its parents.
1008 * For example a devinfo node in a branch that is not
1009 * DDI_FM_EREPORT_CAPABLE may report as capable, via tran_fm_capable,
1010 * to its scsi_device children.
1011 *
1012 * Get 'fm-capable' property from driver.conf, if present. If not
1013 * present, default to the scsi_fm_capable global (which has
1014 * DDI_FM_EREPORT_CAPABLE set by default).
1015 */
1016 if (tran->tran_fm_capable == DDI_FM_NOT_CAPABLE)
1017 tran->tran_fm_capable = ddi_prop_get_int(DDI_DEV_T_ANY, self,
1018 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
1019 "fm-capable", scsi_fm_capable);
1020
1021 /*
1022 * If an HBA is *not* doing its own fma support by calling
1023 * ddi_fm_init() prior to scsi_hba_attach_setup(), we provide a minimal
1024 * common SCSA implementation so that scsi_device children can generate
1025 * ereports via scsi_fm_ereport_post(). We use ddi_fm_capable() to
1026 * detect an HBA calling ddi_fm_init() prior to scsi_hba_attach_setup().
1027 */
1028 if (tran->tran_fm_capable &&
1029 (ddi_fm_capable(self) == DDI_FM_NOT_CAPABLE)) {
1030 /*
1031 * We are capable of something, pass our capabilities up the
1032 * tree, but use a local variable so our parent can't limit
1033 * our capabilities (we don't want our parent to clear
1034 * DDI_FM_EREPORT_CAPABLE).
1035 *
1036 * NOTE: iblock cookies are not important because scsi HBAs
1037 * always interrupt below LOCK_LEVEL.
1038 */
1039 capable = tran->tran_fm_capable;
1040 ddi_fm_init(self, &capable, NULL);
1041
1042 /*
1043 * Set SCSI_HBA_SCSA_FM bit to mark us as using the common
1044 * minimal SCSA fm implementation - we called ddi_fm_init(),
1045 * so we are responsible for calling ddi_fm_fini() in
1046 * scsi_hba_detach().
1047 *
1048 * NOTE: if ddi_fm_init fails to establish handle, SKIP cleanup.
1049 */
1050 if (DEVI(self)->devi_fmhdl)
1051 tran->tran_hba_flags |= SCSI_HBA_SCSA_FM;
1052 }
1053
1054 /* If SCSA responsible for for minor nodes, create :devctl minor. */
1055 scsa_minor = (ddi_get_driver(self)->devo_cb_ops->cb_open ==
1056 scsi_hba_open) ? 1 : 0;
1057 if (scsa_minor && ((ddi_create_minor_node(self, "devctl", S_IFCHR,
1058 INST2DEVCTL(ddi_get_instance(self)), DDI_NT_SCSI_NEXUS, 0) !=
1059 DDI_SUCCESS))) {
1060 SCSI_HBA_LOG((_LOG(WARN), self, NULL,
1061 "can't create :devctl minor node"));
1062 goto fail;
1063 }
1064
1065 return (DDI_SUCCESS);
1066
1067 fail: scsa_nexus_teardown(self, tran);
1068 return (DDI_FAILURE);
1069 }
1070
1071 /*
1072 * Common tran teardown code: used by iport_postdetach_tran_scsi_device() on a
1073 * SCSA HBA iport node and (possibly) by scsi_hba_detach() on SCSA HBA node
1074 * (and for failure cleanup). Undo scsa_tran_setup in reverse order.
1075 *
1076 * NOTE: Since we are in the Solaris IO framework, we can depend on
1077 * undocumented cleanup operations performed by other parts of the framework:
1078 * like detach_node() calling ddi_prop_remove_all() and
1079 * ddi_remove_minor_node(,NULL).
1080 */
1081 static void
scsa_tran_teardown(dev_info_t * self,scsi_hba_tran_t * tran)1082 scsa_tran_teardown(dev_info_t *self, scsi_hba_tran_t *tran)
1083 {
1084 tran->tran_iport_dip = NULL;
1085
1086 /* Teardown pHCI registration */
1087 if (tran->tran_hba_flags & SCSI_HBA_SCSA_PHCI) {
1088 (void) mdi_phci_unregister(self, 0);
1089 tran->tran_hba_flags &= ~SCSI_HBA_SCSA_PHCI;
1090 }
1091 }
1092
1093 /*
1094 * Common tran setup code: used by iport_preattach_tran_scsi_device() on a
1095 * SCSA HBA iport node and (possibly) by scsi_hba_attach_setup() on SCSA HBA
1096 * node.
1097 */
1098 static int
scsa_tran_setup(dev_info_t * self,scsi_hba_tran_t * tran)1099 scsa_tran_setup(dev_info_t *self, scsi_hba_tran_t *tran)
1100 {
1101 int scsa_minor;
1102 int id;
1103 char *scsi_binding_set;
1104 static const char *interconnect[] = INTERCONNECT_TYPE_ASCII;
1105
1106 SCSI_HBA_LOG((_LOG_TRACE, self, NULL, __func__));
1107
1108 /* If SCSA responsible for for minor nodes, create ":scsi" */
1109 scsa_minor = (ddi_get_driver(self)->devo_cb_ops->cb_open ==
1110 scsi_hba_open) ? 1 : 0;
1111 if (scsa_minor && (ddi_create_minor_node(self, "scsi", S_IFCHR,
1112 INST2SCSI(ddi_get_instance(self)),
1113 DDI_NT_SCSI_ATTACHMENT_POINT, 0) != DDI_SUCCESS)) {
1114 SCSI_HBA_LOG((_LOG(WARN), self, NULL,
1115 "can't create :scsi minor node"));
1116 goto fail;
1117 }
1118
1119 /*
1120 * If the property does not already exist on self then see if we can
1121 * pull it from further up the tree and define it on self. If the
1122 * property does not exist above (including options.conf) then use the
1123 * default value specified (global variable). We pull things down from
1124 * above for faster "DDI_PROP_NOTPROM | DDI_PROP_DONTPASS" runtime
1125 * access.
1126 *
1127 * Future: Should we avoid creating properties when value == global?
1128 */
1129 #define CONFIG_INT_PROP(s, p, dv) { \
1130 if ((ddi_prop_exists(DDI_DEV_T_ANY, s, \
1131 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, p) == 0) && \
1132 (ndi_prop_update_int(DDI_DEV_T_NONE, s, p, \
1133 ddi_prop_get_int(DDI_DEV_T_ANY, ddi_get_parent(s), \
1134 DDI_PROP_NOTPROM, p, dv)) != DDI_PROP_SUCCESS)) \
1135 SCSI_HBA_LOG((_LOG(WARN), NULL, s, \
1136 "can't create property '%s'", p)); \
1137 }
1138
1139 /* Decorate with scsi configuration properties */
1140 CONFIG_INT_PROP(self, "scsi-enumeration", scsi_enumeration);
1141 CONFIG_INT_PROP(self, "scsi-options", scsi_options);
1142 CONFIG_INT_PROP(self, "scsi-reset-delay", scsi_reset_delay);
1143 CONFIG_INT_PROP(self, "scsi-watchdog-tick", scsi_watchdog_tick);
1144 CONFIG_INT_PROP(self, "scsi-selection-timeout", scsi_selection_timeout);
1145 CONFIG_INT_PROP(self, "scsi-tag-age-limit", scsi_tag_age_limit);
1146
1147 /*
1148 * Pull down the scsi-initiator-id from further up the tree, or as
1149 * defined by OBP. Place on node for faster access. NOTE: there is
1150 * some confusion about what the name of the property should be.
1151 */
1152 id = ddi_prop_get_int(DDI_DEV_T_ANY, self, 0, "initiator-id", -1);
1153 if (id == -1)
1154 id = ddi_prop_get_int(DDI_DEV_T_ANY, self, 0,
1155 "scsi-initiator-id", -1);
1156 if (id != -1)
1157 CONFIG_INT_PROP(self, "scsi-initiator-id", id);
1158
1159 /*
1160 * If we are responsible for tran allocation, establish
1161 * 'initiator-interconnect-type'.
1162 */
1163 if ((tran->tran_hba_flags & SCSI_HBA_SCSA_TA) &&
1164 (tran->tran_interconnect_type > 0) &&
1165 (tran->tran_interconnect_type < INTERCONNECT_MAX)) {
1166 if (ndi_prop_update_string(DDI_DEV_T_NONE, self,
1167 "initiator-interconnect-type",
1168 (char *)interconnect[tran->tran_interconnect_type])
1169 != DDI_PROP_SUCCESS) {
1170 SCSI_HBA_LOG((_LOG(WARN), self, NULL,
1171 "failed to establish "
1172 "'initiator-interconnect-type'"));
1173 goto fail;
1174 }
1175 }
1176
1177 /*
1178 * The 'scsi-binding-set' property can be defined in driver.conf
1179 * files of legacy drivers on an as-needed basis. If 'scsi-binding-set'
1180 * is not driver.conf defined, and the HBA is not implementing its own
1181 * private bus_config, we define scsi-binding-set to the default
1182 * 'spi' legacy value.
1183 *
1184 * NOTE: This default 'spi' value will be deleted if an HBA driver
1185 * ends up using the scsi_hba_tgtmap_create() enumeration services.
1186 *
1187 * NOTE: If we were ever to decide to derive 'scsi-binding-set' from
1188 * the IEEE-1275 'device_type' property then this is where that code
1189 * should go - there is not enough consistency in 'device_type' to do
1190 * this correctly at this point in time.
1191 */
1192 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, self,
1193 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "scsi-binding-set",
1194 &scsi_binding_set) == DDI_PROP_SUCCESS) {
1195 SCSI_HBA_LOG((_LOG(2), NULL, self,
1196 "external 'scsi-binding-set' \"%s\"", scsi_binding_set));
1197 ddi_prop_free(scsi_binding_set);
1198 } else if (scsi_binding_set_spi &&
1199 ((tran->tran_bus_config == NULL) ||
1200 (tran->tran_bus_config == scsi_hba_bus_config_spi))) {
1201 if (ndi_prop_update_string(DDI_DEV_T_NONE, self,
1202 "scsi-binding-set", scsi_binding_set_spi) !=
1203 DDI_PROP_SUCCESS) {
1204 SCSI_HBA_LOG((_LOG(WARN), self, NULL,
1205 "failed to establish 'scsi_binding_set' default"));
1206 goto fail;
1207 }
1208 SCSI_HBA_LOG((_LOG(2), NULL, self,
1209 "default 'scsi-binding-set' \"%s\"", scsi_binding_set_spi));
1210 } else
1211 SCSI_HBA_LOG((_LOG(2), NULL, self,
1212 "no 'scsi-binding-set'"));
1213
1214 /*
1215 * If SCSI_HBA_TRAN_PHCI is set, take care of pHCI registration of the
1216 * initiator.
1217 */
1218 if ((tran->tran_hba_flags & SCSI_HBA_TRAN_PHCI) &&
1219 (mdi_phci_register(MDI_HCI_CLASS_SCSI, self, 0) == MDI_SUCCESS))
1220 tran->tran_hba_flags |= SCSI_HBA_SCSA_PHCI;
1221
1222 /* NOTE: tran_hba_dip is for DMA operation at the HBA node level */
1223 tran->tran_iport_dip = self; /* for iport association */
1224 return (DDI_SUCCESS);
1225
1226 fail: scsa_tran_teardown(self, tran);
1227 return (DDI_FAILURE);
1228 }
1229
1230 /*
1231 * Called by a SCSA HBA driver to attach an instance of the driver to
1232 * SCSA HBA node enumerated by PCI.
1233 */
1234 int
scsi_hba_attach_setup(dev_info_t * self,ddi_dma_attr_t * hba_dma_attr,scsi_hba_tran_t * tran,int flags)1235 scsi_hba_attach_setup(
1236 dev_info_t *self,
1237 ddi_dma_attr_t *hba_dma_attr,
1238 scsi_hba_tran_t *tran,
1239 int flags)
1240 {
1241 int len;
1242 char cache_name[96];
1243
1244 SCSI_HBA_LOG((_LOG_TRACE, self, NULL, __func__));
1245
1246 /*
1247 * Verify that we are a driver so other code does not need to
1248 * check for NULL ddi_get_driver() result.
1249 */
1250 if (ddi_get_driver(self) == NULL)
1251 return (DDI_FAILURE);
1252
1253 /*
1254 * Verify that we are called on a SCSA HBA node (function enumerated
1255 * by PCI), not on an iport node.
1256 */
1257 ASSERT(scsi_hba_iport_unit_address(self) == NULL);
1258 if (scsi_hba_iport_unit_address(self))
1259 return (DDI_FAILURE); /* self can't be an iport */
1260
1261 /* Caller must provide the tran. */
1262 ASSERT(tran);
1263 if (tran == NULL)
1264 return (DDI_FAILURE);
1265
1266 /*
1267 * Verify correct scsi_hba_tran_t form:
1268 *
1269 * o Both or none of tran_get_name/tran_get_addr.
1270 * NOTE: Older SCSA HBA drivers for SCSI transports with addressing
1271 * that did not fit the SPI "struct scsi_address" model were required
1272 * to implement tran_get_name and tran_get_addr. This is no longer
1273 * true - modern transport drivers should now use common SCSA
1274 * enumeration services. The SCSA enumeration code will represent
1275 * the unit-address using well-known address properties
1276 * (SCSI_ADDR_PROP_TARGET_PORT, SCSI_ADDR_PROP_LUN64) during
1277 * devinfo/pathinfo node creation. The HBA driver can obtain values
1278 * using scsi_device_prop_lookup_*() from its tran_tgt_init(9E).
1279 *
1280 */
1281 if ((tran->tran_get_name == NULL) ^ (tran->tran_get_bus_addr == NULL)) {
1282 SCSI_HBA_LOG((_LOG(WARN), self, NULL,
1283 "should support both or neither: "
1284 "tran_get_name, tran_get_bus_addr"));
1285 return (DDI_FAILURE);
1286 }
1287
1288 /*
1289 * Establish the devinfo context of this tran structure, preserving
1290 * knowledge of how the tran was allocated.
1291 */
1292 tran->tran_hba_dip = self; /* for DMA */
1293 tran->tran_hba_flags = (flags & ~SCSI_HBA_SCSA_TA) |
1294 (tran->tran_hba_flags & SCSI_HBA_SCSA_TA);
1295
1296 /* Establish flavor of transport (and ddi_get_driver_private()) */
1297 ndi_flavorv_set(self, SCSA_FLAVOR_SCSI_DEVICE, tran);
1298
1299 /*
1300 * Note: We only need dma_attr_minxfer and dma_attr_burstsizes
1301 * from the DMA attributes. scsi_hba_attach(9f) only guarantees
1302 * that these two fields are initialized properly. If this
1303 * changes, be sure to revisit the implementation of
1304 * scsi_hba_attach(9F).
1305 */
1306 (void) memcpy(&tran->tran_dma_attr, hba_dma_attr,
1307 sizeof (ddi_dma_attr_t));
1308
1309 /* Create tran_setup_pkt(9E) kmem_cache. */
1310 if (tran->tran_setup_pkt) {
1311 ASSERT(tran->tran_init_pkt == NULL);
1312 ASSERT(tran->tran_destroy_pkt == NULL);
1313 if (tran->tran_init_pkt || tran->tran_destroy_pkt)
1314 goto fail;
1315
1316 tran->tran_init_pkt = scsi_init_cache_pkt;
1317 tran->tran_destroy_pkt = scsi_free_cache_pkt;
1318 tran->tran_sync_pkt = scsi_sync_cache_pkt;
1319 tran->tran_dmafree = scsi_cache_dmafree;
1320
1321 len = sizeof (struct scsi_pkt_cache_wrapper);
1322 len += ROUNDUP(tran->tran_hba_len);
1323 if (tran->tran_hba_flags & SCSI_HBA_TRAN_CDB)
1324 len += ROUNDUP(DEFAULT_CDBLEN);
1325 if (tran->tran_hba_flags & SCSI_HBA_TRAN_SCB)
1326 len += ROUNDUP(DEFAULT_SCBLEN);
1327
1328 (void) snprintf(cache_name, sizeof (cache_name),
1329 "pkt_cache_%s_%d", ddi_driver_name(self),
1330 ddi_get_instance(self));
1331
1332 tran->tran_pkt_cache_ptr = kmem_cache_create(
1333 cache_name, len, 8, scsi_hba_pkt_constructor,
1334 scsi_hba_pkt_destructor, NULL, tran, NULL, 0);
1335 }
1336
1337 /* Perform node setup independent of initiator role */
1338 if (scsa_nexus_setup(self, tran) != DDI_SUCCESS)
1339 goto fail;
1340
1341 /*
1342 * The SCSI_HBA_HBA flag is passed to scsi_hba_attach_setup when the
1343 * HBA driver knows that *all* children of the SCSA HBA node will be
1344 * 'iports'. If the SCSA HBA node can have iport children and also
1345 * function as an initiator for xxx_device children then it should
1346 * not specify SCSI_HBA_HBA in its scsi_hba_attach_setup call. An
1347 * HBA driver that does not manage iports should not set SCSA_HBA_HBA.
1348 */
1349 if (tran->tran_hba_flags & SCSI_HBA_HBA) {
1350 /*
1351 * Set the 'ddi-config-driver-node' property on the nexus
1352 * node that notify attach_driver_nodes() to configure all
1353 * immediate children so that nodes which bind to the
1354 * same driver as parent are able to be added into per-driver
1355 * list.
1356 */
1357 if (ndi_prop_create_boolean(DDI_DEV_T_NONE,
1358 self, "ddi-config-driver-node") != DDI_PROP_SUCCESS)
1359 goto fail;
1360 } else {
1361 if (scsa_tran_setup(self, tran) != DDI_SUCCESS)
1362 goto fail;
1363 }
1364
1365 return (DDI_SUCCESS);
1366
1367 fail: (void) scsi_hba_detach(self);
1368 return (DDI_FAILURE);
1369 }
1370
1371 /*
1372 * Called by an HBA to detach an instance of the driver. This may be called
1373 * for SCSA HBA nodes and for SCSA iport nodes.
1374 */
1375 int
scsi_hba_detach(dev_info_t * self)1376 scsi_hba_detach(dev_info_t *self)
1377 {
1378 scsi_hba_tran_t *tran;
1379
1380 ASSERT(scsi_hba_iport_unit_address(self) == NULL);
1381 if (scsi_hba_iport_unit_address(self))
1382 return (DDI_FAILURE); /* self can't be an iport */
1383
1384 /* Check all error return conditions upfront */
1385 tran = ndi_flavorv_get(self, SCSA_FLAVOR_SCSI_DEVICE);
1386 ASSERT(tran);
1387 if (tran == NULL)
1388 return (DDI_FAILURE);
1389
1390 ASSERT(tran->tran_open_flag == 0);
1391 if (tran->tran_open_flag)
1392 return (DDI_FAILURE);
1393
1394 if (!(tran->tran_hba_flags & SCSI_HBA_HBA))
1395 scsa_tran_teardown(self, tran);
1396 scsa_nexus_teardown(self, tran);
1397
1398 /* Teardown tran_setup_pkt(9E) kmem_cache. */
1399 if (tran->tran_pkt_cache_ptr) {
1400 kmem_cache_destroy(tran->tran_pkt_cache_ptr);
1401 tran->tran_pkt_cache_ptr = NULL;
1402 }
1403
1404 (void) memset(&tran->tran_dma_attr, 0, sizeof (ddi_dma_attr_t));
1405
1406 /* Teardown flavor of transport (and ddi_get_driver_private()) */
1407 ndi_flavorv_set(self, SCSA_FLAVOR_SCSI_DEVICE, NULL);
1408
1409 tran->tran_hba_dip = NULL;
1410
1411 return (DDI_SUCCESS);
1412 }
1413
1414
1415 /*
1416 * Called by an HBA from _fini()
1417 */
1418 void
scsi_hba_fini(struct modlinkage * modlp)1419 scsi_hba_fini(struct modlinkage *modlp)
1420 {
1421 struct dev_ops *hba_dev_ops;
1422
1423 SCSI_HBA_LOG((_LOG_TRACE, NULL, NULL, __func__));
1424
1425 /* Get the devops structure of this module and clear bus_ops vector. */
1426 hba_dev_ops = ((struct modldrv *)(modlp->ml_linkage[0]))->drv_dev_ops;
1427
1428 if (hba_dev_ops->devo_cb_ops == &scsi_hba_cbops)
1429 hba_dev_ops->devo_cb_ops = NULL;
1430
1431 if (hba_dev_ops->devo_getinfo == scsi_hba_info)
1432 hba_dev_ops->devo_getinfo = NULL;
1433
1434 hba_dev_ops->devo_bus_ops = (struct bus_ops *)NULL;
1435 }
1436
1437 /*
1438 * SAS specific functions
1439 */
1440 smp_hba_tran_t *
smp_hba_tran_alloc(dev_info_t * self)1441 smp_hba_tran_alloc(dev_info_t *self)
1442 {
1443 /* allocate SCSA flavors for self */
1444 ndi_flavorv_alloc(self, SCSA_NFLAVORS);
1445 return (kmem_zalloc(sizeof (smp_hba_tran_t), KM_SLEEP));
1446 }
1447
1448 void
smp_hba_tran_free(smp_hba_tran_t * tran)1449 smp_hba_tran_free(smp_hba_tran_t *tran)
1450 {
1451 kmem_free(tran, sizeof (smp_hba_tran_t));
1452 }
1453
1454 int
smp_hba_attach_setup(dev_info_t * self,smp_hba_tran_t * tran)1455 smp_hba_attach_setup(
1456 dev_info_t *self,
1457 smp_hba_tran_t *tran)
1458 {
1459 ASSERT(scsi_hba_iport_unit_address(self) == NULL);
1460 if (scsi_hba_iport_unit_address(self))
1461 return (DDI_FAILURE); /* self can't be an iport */
1462
1463 /*
1464 * The owner of the this devinfo_t was responsible
1465 * for informing the framework already about
1466 * additional flavors.
1467 */
1468 ndi_flavorv_set(self, SCSA_FLAVOR_SMP, tran);
1469 return (DDI_SUCCESS);
1470 }
1471
1472 int
smp_hba_detach(dev_info_t * self)1473 smp_hba_detach(dev_info_t *self)
1474 {
1475 ASSERT(scsi_hba_iport_unit_address(self) == NULL);
1476 if (scsi_hba_iport_unit_address(self))
1477 return (DDI_FAILURE); /* self can't be an iport */
1478
1479 ndi_flavorv_set(self, SCSA_FLAVOR_SMP, NULL);
1480 return (DDI_SUCCESS);
1481 }
1482
1483 /*
1484 * SMP child flavored functions
1485 */
1486 static int
smp_busctl_ua(dev_info_t * child,char * addr,int maxlen)1487 smp_busctl_ua(dev_info_t *child, char *addr, int maxlen)
1488 {
1489 char *tport;
1490 char *wwn;
1491
1492 /* limit ndi_devi_findchild_by_callback to expected flavor */
1493 if (ndi_flavor_get(child) != SCSA_FLAVOR_SMP)
1494 return (DDI_FAILURE);
1495
1496 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, child,
1497 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
1498 SCSI_ADDR_PROP_TARGET_PORT, &tport) == DDI_SUCCESS) {
1499 (void) snprintf(addr, maxlen, "%s", tport);
1500 ddi_prop_free(tport);
1501 return (DDI_SUCCESS);
1502 }
1503
1504 /*
1505 * NOTE: the following code should be deleted when mpt is changed to
1506 * use SCSI_ADDR_PROP_TARGET_PORT instead of SMP_WWN.
1507 */
1508 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, child,
1509 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
1510 SMP_WWN, &wwn) == DDI_SUCCESS) {
1511 (void) snprintf(addr, maxlen, "w%s", wwn);
1512 ddi_prop_free(wwn);
1513 return (DDI_SUCCESS);
1514 }
1515 return (DDI_FAILURE);
1516 }
1517
1518 static int
smp_busctl_reportdev(dev_info_t * child)1519 smp_busctl_reportdev(dev_info_t *child)
1520 {
1521 dev_info_t *self = ddi_get_parent(child);
1522 char *tport;
1523 char *wwn;
1524
1525 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, child,
1526 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
1527 SCSI_ADDR_PROP_TARGET_PORT, &tport) == DDI_SUCCESS) {
1528 SCSI_HBA_LOG((_LOG_NF(CONT), "?%s%d at %s%d: target-port %s",
1529 ddi_driver_name(child), ddi_get_instance(child),
1530 ddi_driver_name(self), ddi_get_instance(self), tport));
1531 ddi_prop_free(tport);
1532 return (DDI_SUCCESS);
1533 }
1534
1535 /*
1536 * NOTE: the following code should be deleted when mpt is changed to
1537 * use SCSI_ADDR_PROP_TARGET_PORT instead of SMP_WWN.
1538 */
1539 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, child,
1540 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
1541 SMP_WWN, &wwn) == DDI_SUCCESS) {
1542 SCSI_HBA_LOG((_LOG_NF(CONT), "?%s%d at %s%d: wwn %s",
1543 ddi_driver_name(child), ddi_get_instance(child),
1544 ddi_driver_name(self), ddi_get_instance(self), wwn));
1545 ddi_prop_free(wwn);
1546 return (DDI_SUCCESS);
1547 }
1548 return (DDI_FAILURE);
1549 }
1550
1551 static int
smp_busctl_initchild(dev_info_t * child)1552 smp_busctl_initchild(dev_info_t *child)
1553 {
1554 dev_info_t *self = ddi_get_parent(child);
1555 smp_hba_tran_t *tran;
1556 dev_info_t *dup;
1557 char addr[SCSI_MAXNAMELEN];
1558 struct smp_device *smp_sd;
1559 uint64_t wwn;
1560
1561 tran = ndi_flavorv_get(self, SCSA_FLAVOR_SMP);
1562 ASSERT(tran);
1563 if (tran == NULL)
1564 return (DDI_FAILURE);
1565
1566 if (smp_busctl_ua(child, addr, sizeof (addr)) != DDI_SUCCESS)
1567 return (DDI_NOT_WELL_FORMED);
1568 if (scsi_wwnstr_to_wwn(addr, &wwn))
1569 return (DDI_NOT_WELL_FORMED);
1570
1571 /* Prevent duplicate nodes. */
1572 dup = ndi_devi_findchild_by_callback(self, ddi_node_name(child), addr,
1573 smp_busctl_ua);
1574 if (dup) {
1575 ASSERT(ndi_flavor_get(dup) == SCSA_FLAVOR_SMP);
1576 if (ndi_flavor_get(dup) != SCSA_FLAVOR_SMP) {
1577 SCSI_HBA_LOG((_LOG(1), NULL, child,
1578 "init failed: %s@%s: not SMP flavored",
1579 ddi_node_name(child), addr));
1580 return (DDI_FAILURE);
1581 }
1582 if (dup != child) {
1583 SCSI_HBA_LOG((_LOG(4), NULL, child,
1584 "init failed: %s@%s: detected duplicate %p",
1585 ddi_node_name(child), addr, (void *)dup));
1586 return (DDI_FAILURE);
1587 }
1588 }
1589
1590
1591 /* set the node @addr string */
1592 ddi_set_name_addr(child, addr);
1593
1594 /* Allocate and initialize smp_device. */
1595 smp_sd = kmem_zalloc(sizeof (struct smp_device), KM_SLEEP);
1596 smp_sd->smp_sd_dev = child;
1597 smp_sd->smp_sd_address.smp_a_hba_tran = tran;
1598 bcopy(&wwn, smp_sd->smp_sd_address.smp_a_wwn, SAS_WWN_BYTE_SIZE);
1599
1600 ddi_set_driver_private(child, smp_sd);
1601
1602 if (tran->smp_tran_init && ((*tran->smp_tran_init)(self, child,
1603 tran, smp_sd) != DDI_SUCCESS)) {
1604 kmem_free(smp_sd, sizeof (struct smp_device));
1605 scsi_enumeration_failed(child, -1, NULL, "smp_tran_init");
1606 ddi_set_driver_private(child, NULL);
1607 ddi_set_name_addr(child, NULL);
1608 return (DDI_FAILURE);
1609 }
1610
1611 return (DDI_SUCCESS);
1612 }
1613
1614 /*ARGSUSED*/
1615 static int
smp_busctl_uninitchild(dev_info_t * child)1616 smp_busctl_uninitchild(dev_info_t *child)
1617 {
1618 dev_info_t *self = ddi_get_parent(child);
1619 struct smp_device *smp_sd = ddi_get_driver_private(child);
1620 smp_hba_tran_t *tran;
1621
1622 tran = ndi_flavorv_get(self, SCSA_FLAVOR_SMP);
1623 ASSERT(smp_sd && tran);
1624 if ((smp_sd == NULL) || (tran == NULL))
1625 return (DDI_FAILURE);
1626
1627 if (tran->smp_tran_free)
1628 (*tran->smp_tran_free) (self, child, tran, smp_sd);
1629
1630 kmem_free(smp_sd, sizeof (*smp_sd));
1631 ddi_set_driver_private(child, NULL);
1632 ddi_set_name_addr(child, NULL);
1633 return (DDI_SUCCESS);
1634 }
1635
1636 /* Find an "smp" child at the specified address. */
1637 static dev_info_t *
smp_findchild(dev_info_t * self,char * addr)1638 smp_findchild(dev_info_t *self, char *addr)
1639 {
1640 dev_info_t *child;
1641
1642 /* Search "smp" devinfo child at specified address. */
1643 ASSERT(self && DEVI_BUSY_OWNED(self) && addr);
1644 for (child = ddi_get_child(self); child;
1645 child = ddi_get_next_sibling(child)) {
1646 /* skip non-"smp" nodes */
1647 if (ndi_flavor_get(child) != SCSA_FLAVOR_SMP)
1648 continue;
1649
1650 /* Attempt initchild to establish unit-address */
1651 if (i_ddi_node_state(child) < DS_INITIALIZED)
1652 (void) ddi_initchild(self, child);
1653
1654 /* Verify state and non-NULL unit-address. */
1655 if ((i_ddi_node_state(child) < DS_INITIALIZED) ||
1656 (ddi_get_name_addr(child) == NULL))
1657 continue;
1658
1659 /* Return "smp" child if unit-address matches. */
1660 if (strcmp(ddi_get_name_addr(child), addr) == 0)
1661 return (child);
1662 }
1663 return (NULL);
1664 }
1665
1666 /*
1667 * Search for "smp" child of self at the specified address. If found, online
1668 * and return with a hold. Unlike general SCSI configuration, we can assume
1669 * the the device is actually there when we are called (i.e., device is
1670 * created by hotplug, not by bus_config).
1671 */
1672 int
smp_hba_bus_config(dev_info_t * self,char * addr,dev_info_t ** childp)1673 smp_hba_bus_config(dev_info_t *self, char *addr, dev_info_t **childp)
1674 {
1675 dev_info_t *child;
1676 boolean_t enteredv;
1677
1678 ASSERT(self && addr && childp);
1679 *childp = NULL;
1680
1681 /* Search for "smp" child. */
1682 scsi_hba_devi_enter(self, &enteredv);
1683 if ((child = smp_findchild(self, addr)) == NULL) {
1684 scsi_hba_devi_exit(self, enteredv);
1685 return (NDI_FAILURE);
1686 }
1687
1688 /* Attempt online. */
1689 if (ndi_devi_online(child, 0) != NDI_SUCCESS) {
1690 scsi_hba_devi_exit(self, enteredv);
1691 return (NDI_FAILURE);
1692 }
1693
1694 /* On success, return with active hold. */
1695 ndi_hold_devi(child);
1696 scsi_hba_devi_exit(self, enteredv);
1697 *childp = child;
1698 return (NDI_SUCCESS);
1699 }
1700
1701
1702
1703 /* Create "smp" child devinfo node at specified unit-address. */
1704 int
smp_hba_bus_config_taddr(dev_info_t * self,char * addr)1705 smp_hba_bus_config_taddr(dev_info_t *self, char *addr)
1706 {
1707 dev_info_t *child;
1708 boolean_t enteredv;
1709
1710 /*
1711 * NOTE: If we ever uses a generic node name (.vs. a driver name)
1712 * or define a 'compatible' property, this code will need to use
1713 * a 'probe' node (ala scsi_device support) to obtain identity
1714 * information from the device.
1715 */
1716
1717 /* Search for "smp" child. */
1718 scsi_hba_devi_enter(self, &enteredv);
1719 child = smp_findchild(self, addr);
1720 if (child) {
1721 /* Child exists, note if this was a new reinsert. */
1722 if (ndi_devi_device_insert(child))
1723 SCSI_HBA_LOG((_LOGCFG, self, NULL,
1724 "devinfo smp@%s device_reinsert", addr));
1725
1726 scsi_hba_devi_exit(self, enteredv);
1727 return (NDI_SUCCESS);
1728 }
1729
1730 /* Allocate "smp" child devinfo node and establish flavor of child. */
1731 ndi_devi_alloc_sleep(self, "smp", DEVI_SID_HP_NODEID, &child);
1732 ASSERT(child);
1733 ndi_flavor_set(child, SCSA_FLAVOR_SMP);
1734
1735 /* Add unit-address property to child. */
1736 if (ndi_prop_update_string(DDI_DEV_T_NONE, child,
1737 SCSI_ADDR_PROP_TARGET_PORT, addr) != DDI_PROP_SUCCESS) {
1738 (void) ndi_devi_free(child);
1739 scsi_hba_devi_exit(self, enteredv);
1740 return (NDI_FAILURE);
1741 }
1742
1743 /* Attempt to online the new "smp" node. */
1744 (void) ndi_devi_online(child, 0);
1745
1746 scsi_hba_devi_exit(self, enteredv);
1747 return (NDI_SUCCESS);
1748 }
1749
1750 /*
1751 * Wrapper to scsi_ua_get which takes a devinfo argument instead of a
1752 * scsi_device structure.
1753 */
1754 static int
scsi_busctl_ua(dev_info_t * child,char * addr,int maxlen)1755 scsi_busctl_ua(dev_info_t *child, char *addr, int maxlen)
1756 {
1757 struct scsi_device *sd;
1758
1759 /* limit ndi_devi_findchild_by_callback to expected flavor */
1760 if (ndi_flavor_get(child) != SCSA_FLAVOR_SCSI_DEVICE)
1761 return (DDI_FAILURE);
1762
1763 /* nodes are named by tran_get_name or default "tgt,lun" */
1764 sd = ddi_get_driver_private(child);
1765 if (sd && (scsi_ua_get(sd, addr, maxlen) == 1))
1766 return (DDI_SUCCESS);
1767
1768 return (DDI_FAILURE);
1769 }
1770
1771 static int
scsi_busctl_reportdev(dev_info_t * child)1772 scsi_busctl_reportdev(dev_info_t *child)
1773 {
1774 dev_info_t *self = ddi_get_parent(child);
1775 struct scsi_device *sd = ddi_get_driver_private(child);
1776 scsi_hba_tran_t *tran;
1777 char ua[SCSI_MAXNAMELEN];
1778 char ra[SCSI_MAXNAMELEN];
1779
1780 SCSI_HBA_LOG((_LOG_TRACE, NULL, child, __func__));
1781
1782 tran = ndi_flavorv_get(self, SCSA_FLAVOR_SCSI_DEVICE);
1783 ASSERT(tran && sd);
1784 if ((tran == NULL) || (sd == NULL))
1785 return (DDI_FAILURE);
1786
1787 /* get the unit_address and bus_addr information */
1788 if ((scsi_ua_get(sd, ua, sizeof (ua)) == 0) ||
1789 (scsi_ua_get_reportdev(sd, ra, sizeof (ra)) == 0)) {
1790 SCSI_HBA_LOG((_LOG(WARN), NULL, child, "REPORTDEV failure"));
1791 return (DDI_FAILURE);
1792 }
1793
1794 if (tran->tran_get_name == NULL)
1795 SCSI_HBA_LOG((_LOG_NF(CONT), "?%s%d at %s%d: %s",
1796 ddi_driver_name(child), ddi_get_instance(child),
1797 ddi_driver_name(self), ddi_get_instance(self), ra));
1798 else if (*ra)
1799 SCSI_HBA_LOG((_LOG_NF(CONT),
1800 "?%s%d at %s%d: unit-address %s: %s",
1801 ddi_driver_name(child), ddi_get_instance(child),
1802 ddi_driver_name(self), ddi_get_instance(self), ua, ra));
1803 else
1804 SCSI_HBA_LOG((_LOG_NF(CONT),
1805 "?%s%d at %s%d: unit-address %s",
1806 ddi_driver_name(child), ddi_get_instance(child),
1807 ddi_driver_name(self), ddi_get_instance(self), ua));
1808
1809 return (DDI_SUCCESS);
1810 }
1811
1812
1813 /*
1814 * scsi_busctl_initchild is called to initialize the SCSA transport for
1815 * communication with a particular child scsi target device. Successful
1816 * initialization requires properties on the node which describe the address
1817 * of the target device. If the address of the target device can't be
1818 * determined from properties then DDI_NOT_WELL_FORMED is returned. Nodes that
1819 * are DDI_NOT_WELL_FORMED are considered an implementation artifact and
1820 * are hidden from devinfo snapshots by calling ndi_devi_set_hidden().
1821 * The child may be one of the following types of devinfo nodes:
1822 *
1823 * OBP node:
1824 * OBP does not enumerate target devices attached a SCSI bus. These
1825 * template/stub/wild-card nodes are a legacy artifact for support of old
1826 * driver loading methods. Since they have no properties,
1827 * DDI_NOT_WELL_FORMED will be returned.
1828 *
1829 * SID node:
1830 * The node may be either a:
1831 * o probe/barrier SID node
1832 * o a dynamic SID target node
1833 *
1834 * driver.conf node: The situation for this nexus is different than most.
1835 * Typically a driver.conf node definition is used to either define a
1836 * new child devinfo node or to further decorate (via merge) a SID
1837 * child with properties. In our case we use the nodes for *both*
1838 * purposes.
1839 *
1840 * In both the SID node and driver.conf node cases we must form the nodes
1841 * "@addr" from the well-known scsi(9P) device unit-address properties on
1842 * the node.
1843 *
1844 * For HBA drivers that implement the deprecated tran_get_name interface,
1845 * "@addr" construction involves having that driver interpret properties via
1846 * scsi_busctl_ua -> scsi_ua_get -> tran_get_name: there is no
1847 * requirement for the property names to be well-known.
1848 *
1849 * NOTE: We don't currently support "merge". When this support is added a
1850 * specific property, like "unit-address", should *always* identify a
1851 * driver.conf node that needs to be merged into a specific SID node. When
1852 * enumeration is enabled, a .conf node without the "unit-address" property
1853 * should be ignored. The best way to establish the "unit-address" property
1854 * would be to have the system assign parent= and unit-address= from an
1855 * instance=# driver.conf entry (by using the instance tree).
1856 */
1857 static int
scsi_busctl_initchild(dev_info_t * child)1858 scsi_busctl_initchild(dev_info_t *child)
1859 {
1860 dev_info_t *self = ddi_get_parent(child);
1861 dev_info_t *dup;
1862 scsi_hba_tran_t *tran;
1863 struct scsi_device *sd;
1864 scsi_hba_tran_t *tran_clone;
1865 char *class;
1866 int tgt;
1867 int lun;
1868 int sfunc;
1869 int err = DDI_FAILURE;
1870 char addr[SCSI_MAXNAMELEN];
1871
1872 ASSERT(DEVI_BUSY_OWNED(self));
1873 SCSI_HBA_LOG((_LOG(4), NULL, child, "init begin"));
1874
1875 /*
1876 * For a driver like fp with multiple upper-layer-protocols
1877 * it is possible for scsi_hba_init in _init to plumb SCSA
1878 * and have the load of fcp (which does scsi_hba_attach_setup)
1879 * to fail. In this case we may get here with a NULL hba.
1880 */
1881 tran = ndi_flavorv_get(self, SCSA_FLAVOR_SCSI_DEVICE);
1882 if (tran == NULL)
1883 return (DDI_NOT_WELL_FORMED);
1884
1885 /*
1886 * OBP may create template/stub/wild-card nodes for legacy driver
1887 * loading methods. These nodes have no properties, so we lack the
1888 * addressing properties to initchild them. Hide the node and return
1889 * DDI_NOT_WELL_FORMED.
1890 *
1891 * Future: define/use a ndi_devi_has_properties(dip) type interface.
1892 *
1893 * NOTE: It would be nice if we could delete these ill formed nodes by
1894 * implementing a DDI_NOT_WELL_FORMED_DELETE return code. This can't
1895 * be done until leadville debug code removes its dependencies
1896 * on the devinfo still being present after a failed ndi_devi_online.
1897 */
1898 if ((DEVI(child)->devi_hw_prop_ptr == NULL) &&
1899 (DEVI(child)->devi_drv_prop_ptr == NULL) &&
1900 (DEVI(child)->devi_sys_prop_ptr == NULL)) {
1901 SCSI_HBA_LOG((_LOG(4), NULL, child,
1902 "init failed: no properties"));
1903 ndi_devi_set_hidden(child);
1904 return (DDI_NOT_WELL_FORMED);
1905 }
1906
1907 /* get legacy SPI addressing properties */
1908 if ((tgt = ddi_prop_get_int(DDI_DEV_T_ANY, child,
1909 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
1910 SCSI_ADDR_PROP_TARGET, -1)) == -1) {
1911 tgt = 0;
1912 /*
1913 * A driver.conf node for merging always has a target= property,
1914 * even if it is just a dummy that does not contain the real
1915 * target address. However drivers that register devids may
1916 * create stub driver.conf nodes without a target= property so
1917 * that pathological devid resolution works. Hide the stub
1918 * node and return DDI_NOT_WELL_FORMED.
1919 */
1920 if (!scsi_hba_dev_is_sid(child)) {
1921 SCSI_HBA_LOG((_LOG(4), NULL, child,
1922 "init failed: stub .conf node"));
1923 ndi_devi_set_hidden(child);
1924 return (DDI_NOT_WELL_FORMED);
1925 }
1926 }
1927 lun = ddi_prop_get_int(DDI_DEV_T_ANY, child,
1928 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, SCSI_ADDR_PROP_LUN, 0);
1929 sfunc = ddi_prop_get_int(DDI_DEV_T_ANY, child,
1930 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, SCSI_ADDR_PROP_SFUNC, -1);
1931
1932 /*
1933 * The scsi_address structure may not specify all the addressing
1934 * information. For an old HBA that doesn't support tran_get_name
1935 * (most pre-SCSI-3 HBAs) the scsi_address structure is still used,
1936 * so the target property must exist and the LUN must be < 256.
1937 */
1938 if ((tran->tran_get_name == NULL) &&
1939 ((tgt >= USHRT_MAX) || (lun >= 256))) {
1940 SCSI_HBA_LOG((_LOG(1), NULL, child,
1941 "init failed: illegal/missing properties"));
1942 ndi_devi_set_hidden(child);
1943 return (DDI_NOT_WELL_FORMED);
1944 }
1945
1946 /*
1947 * We need to initialize a fair amount of our environment to invoke
1948 * tran_get_name (via scsi_busctl_ua and scsi_ua_get) to
1949 * produce the "@addr" name from addressing properties. Allocate and
1950 * initialize scsi device structure.
1951 */
1952 sd = kmem_zalloc(sizeof (struct scsi_device), KM_SLEEP);
1953 mutex_init(&sd->sd_mutex, NULL, MUTEX_DRIVER, NULL);
1954 sd->sd_dev = child;
1955 sd->sd_pathinfo = NULL;
1956 sd->sd_uninit_prevent = 0;
1957 ddi_set_driver_private(child, sd);
1958
1959 if (tran->tran_hba_flags & SCSI_HBA_ADDR_COMPLEX) {
1960 /*
1961 * For a SCSI_HBA_ADDR_COMPLEX transport we store a pointer to
1962 * scsi_device in the scsi_address structure. This allows an
1963 * HBA driver to find its per-scsi_device private data
1964 * (accessible to the HBA given just the scsi_address by using
1965 * scsi_address_device(9F)/scsi_device_hba_private_get(9F)).
1966 */
1967 sd->sd_address.a.a_sd = sd;
1968 tran_clone = NULL;
1969 } else {
1970 /*
1971 * Initialize the scsi_address so that a SCSI-2 target driver
1972 * talking to a SCSI-2 device on a SCSI-3 bus (spi) continues
1973 * to work. We skew the secondary function value so that we
1974 * can tell from the address structure if we are processing
1975 * a secondary function request.
1976 */
1977 sd->sd_address.a_target = (ushort_t)tgt;
1978 sd->sd_address.a_lun = (uchar_t)lun;
1979 if (sfunc == -1)
1980 sd->sd_address.a_sublun = (uchar_t)0;
1981 else
1982 sd->sd_address.a_sublun = (uchar_t)sfunc + 1;
1983
1984 /*
1985 * NOTE: Don't limit LUNs to scsi_options value because a
1986 * scsi_device discovered via SPI dynamic enumeration might
1987 * still support SCMD_REPORT_LUNS.
1988 */
1989
1990 /*
1991 * Deprecated: Use SCSI_HBA_ADDR_COMPLEX:
1992 * Clone transport structure if requested. Cloning allows
1993 * an HBA to maintain target-specific information if
1994 * necessary, such as target addressing information that
1995 * does not adhere to the scsi_address structure format.
1996 */
1997 if (tran->tran_hba_flags & SCSI_HBA_TRAN_CLONE) {
1998 tran_clone = kmem_alloc(
1999 sizeof (scsi_hba_tran_t), KM_SLEEP);
2000 bcopy((caddr_t)tran,
2001 (caddr_t)tran_clone, sizeof (scsi_hba_tran_t));
2002 tran = tran_clone;
2003 tran->tran_sd = sd;
2004 } else {
2005 tran_clone = NULL;
2006 ASSERT(tran->tran_sd == NULL);
2007 }
2008 }
2009
2010 /* establish scsi_address pointer to the HBA's tran structure */
2011 sd->sd_address.a_hba_tran = tran;
2012
2013 /*
2014 * This is a grotty hack that allows direct-access (non-scsa) drivers
2015 * (like chs, ata, and mlx which all make cmdk children) to put its
2016 * own vector in the 'a_hba_tran' field. When all the drivers that do
2017 * this are fixed, please remove this hack.
2018 *
2019 * NOTE: This hack is also shows up in the DEVP_TO_TRAN implementation
2020 * in scsi_confsubr.c.
2021 */
2022 sd->sd_tran_safe = tran;
2023
2024 /*
2025 * If the class property is not already established, set it to "scsi".
2026 * This is done so that parent= driver.conf nodes have class.
2027 */
2028 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, child,
2029 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "class",
2030 &class) == DDI_PROP_SUCCESS) {
2031 ddi_prop_free(class);
2032 } else if (ndi_prop_update_string(DDI_DEV_T_NONE, child,
2033 "class", "scsi") != DDI_PROP_SUCCESS) {
2034 SCSI_HBA_LOG((_LOG(2), NULL, child, "init failed: class"));
2035 ndi_devi_set_hidden(child);
2036 err = DDI_NOT_WELL_FORMED;
2037 goto failure;
2038 }
2039
2040 /* Establish the @addr name of the child. */
2041 *addr = '\0';
2042 if (scsi_busctl_ua(child, addr, sizeof (addr)) != DDI_SUCCESS) {
2043 /*
2044 * Some driver.conf files add bogus target properties (relative
2045 * to their nexus representation of target) to their stub
2046 * nodes, causing the check above to not filter them.
2047 */
2048 SCSI_HBA_LOG((_LOG(3), NULL, child,
2049 "init failed: scsi_busctl_ua call"));
2050 ndi_devi_set_hidden(child);
2051 err = DDI_NOT_WELL_FORMED;
2052 goto failure;
2053 }
2054 if (*addr == '\0') {
2055 SCSI_HBA_LOG((_LOG(2), NULL, child, "init failed: ua"));
2056 ndi_devi_set_hidden(child);
2057 err = DDI_NOT_WELL_FORMED;
2058 goto failure;
2059 }
2060
2061 /* Prevent duplicate nodes. */
2062 dup = ndi_devi_findchild_by_callback(self, ddi_node_name(child), addr,
2063 scsi_busctl_ua);
2064 if (dup) {
2065 ASSERT(ndi_flavor_get(dup) == SCSA_FLAVOR_SCSI_DEVICE);
2066 if (ndi_flavor_get(dup) != SCSA_FLAVOR_SCSI_DEVICE) {
2067 SCSI_HBA_LOG((_LOG(1), NULL, child,
2068 "init failed: %s@%s: not SCSI_DEVICE flavored",
2069 ddi_node_name(child), addr));
2070 goto failure;
2071 }
2072 if (dup != child) {
2073 SCSI_HBA_LOG((_LOG(4), NULL, child,
2074 "init failed: %s@%s: detected duplicate %p",
2075 ddi_node_name(child), addr, (void *)dup));
2076 goto failure;
2077 }
2078 }
2079
2080 /* set the node @addr string */
2081 ddi_set_name_addr(child, addr);
2082
2083 /* call HBA's target init entry point if it exists */
2084 if (tran->tran_tgt_init != NULL) {
2085 SCSI_HBA_LOG((_LOG(4), NULL, child, "init tran_tgt_init"));
2086 sd->sd_tran_tgt_free_done = 0;
2087 if ((*tran->tran_tgt_init)
2088 (self, child, tran, sd) != DDI_SUCCESS) {
2089 scsi_enumeration_failed(child, -1, NULL,
2090 "tran_tgt_init");
2091 goto failure;
2092 }
2093 }
2094
2095 SCSI_HBA_LOG((_LOG(3), NULL, child, "init successful"));
2096 return (DDI_SUCCESS);
2097
2098 failure:
2099 if (tran_clone)
2100 kmem_free(tran_clone, sizeof (scsi_hba_tran_t));
2101 mutex_destroy(&sd->sd_mutex);
2102 kmem_free(sd, sizeof (*sd));
2103 ddi_set_driver_private(child, NULL);
2104 ddi_set_name_addr(child, NULL);
2105
2106 return (err); /* remove the node */
2107 }
2108
2109 static int
scsi_busctl_uninitchild(dev_info_t * child)2110 scsi_busctl_uninitchild(dev_info_t *child)
2111 {
2112 dev_info_t *self = ddi_get_parent(child);
2113 struct scsi_device *sd = ddi_get_driver_private(child);
2114 scsi_hba_tran_t *tran;
2115 scsi_hba_tran_t *tran_clone;
2116
2117 ASSERT(DEVI_BUSY_OWNED(self));
2118
2119 tran = ndi_flavorv_get(self, SCSA_FLAVOR_SCSI_DEVICE);
2120 ASSERT(tran && sd);
2121 if ((tran == NULL) || (sd == NULL))
2122 return (DDI_FAILURE);
2123
2124 /*
2125 * We use sd_uninit_prevent to avoid uninitializing barrier/probe
2126 * nodes that are still in use. Since barrier/probe nodes are not
2127 * attached we can't prevent their state demotion via ndi_hold_devi.
2128 */
2129 if (sd->sd_uninit_prevent) {
2130 SCSI_HBA_LOG((_LOG(2), NULL, child, "uninit prevented"));
2131 return (DDI_FAILURE);
2132 }
2133
2134 /*
2135 * Don't uninitialize a client node if it still has paths.
2136 */
2137 if (MDI_CLIENT(child) && mdi_client_get_path_count(child)) {
2138 SCSI_HBA_LOG((_LOG(2), NULL, child,
2139 "uninit prevented, client has paths"));
2140 return (DDI_FAILURE);
2141 }
2142
2143 SCSI_HBA_LOG((_LOG(3), NULL, child, "uninit begin"));
2144
2145 if (tran->tran_hba_flags & SCSI_HBA_TRAN_CLONE) {
2146 tran_clone = sd->sd_address.a_hba_tran;
2147
2148 /* ... grotty hack, involving sd_tran_safe, continued. */
2149 if (tran_clone != sd->sd_tran_safe) {
2150 tran_clone = sd->sd_tran_safe;
2151 #ifdef DEBUG
2152 /*
2153 * Complain so things get fixed and hack can, at
2154 * some point in time, be removed.
2155 */
2156 SCSI_HBA_LOG((_LOG(WARN), self, NULL,
2157 "'%s' is corrupting a_hba_tran", sd->sd_dev ?
2158 ddi_driver_name(sd->sd_dev) : "unknown_driver"));
2159 #endif /* DEBUG */
2160 }
2161
2162 ASSERT(tran_clone->tran_hba_flags & SCSI_HBA_TRAN_CLONE);
2163 ASSERT(tran_clone->tran_sd == sd);
2164 tran = tran_clone;
2165 } else {
2166 tran_clone = NULL;
2167 ASSERT(tran->tran_sd == NULL);
2168 }
2169
2170 /*
2171 * To simplify host adapter drivers we guarantee that multiple
2172 * tran_tgt_init(9E) calls of the same unit address are never
2173 * active at the same time. This requires that we always call
2174 * tran_tgt_free on probe/barrier nodes directly prior to
2175 * uninitchild.
2176 *
2177 * NOTE: To correctly support SCSI_HBA_TRAN_CLONE, we must use
2178 * the (possibly cloned) hba_tran pointer from the scsi_device
2179 * instead of hba_tran.
2180 */
2181 if (tran->tran_tgt_free) {
2182 if (!sd->sd_tran_tgt_free_done) {
2183 SCSI_HBA_LOG((_LOG(4), NULL, child,
2184 "uninit tran_tgt_free"));
2185 (*tran->tran_tgt_free) (self, child, tran, sd);
2186 sd->sd_tran_tgt_free_done = 1;
2187 } else {
2188 SCSI_HBA_LOG((_LOG(4), NULL, child,
2189 "uninit tran_tgt_free already done"));
2190 }
2191 }
2192
2193 /*
2194 * If a inquiry data is still allocated (by scsi_probe()) we
2195 * free the allocation here. This keeps scsi_inq valid for the
2196 * same duration as the corresponding inquiry properties. It
2197 * also allows a tran_tgt_init() implementation that establishes
2198 * sd_inq to deal with deallocation in its tran_tgt_free
2199 * (setting sd_inq back to NULL) without upsetting the
2200 * framework. Moving the inquiry free here also allows setting
2201 * of sd_uninit_prevent to preserve the data for lun0 based
2202 * scsi_get_device_type_scsi_options() calls.
2203 */
2204 if (sd->sd_inq) {
2205 kmem_free(sd->sd_inq, SUN_INQSIZE);
2206 sd->sd_inq = (struct scsi_inquiry *)NULL;
2207 }
2208
2209 mutex_destroy(&sd->sd_mutex);
2210 if (tran_clone)
2211 kmem_free(tran_clone, sizeof (scsi_hba_tran_t));
2212 kmem_free(sd, sizeof (*sd));
2213
2214 ddi_set_driver_private(child, NULL);
2215 SCSI_HBA_LOG((_LOG(3), NULL, child, "uninit complete"));
2216 ddi_set_name_addr(child, NULL);
2217 return (DDI_SUCCESS);
2218 }
2219
2220 static int
iport_busctl_ua(dev_info_t * child,char * addr,int maxlen)2221 iport_busctl_ua(dev_info_t *child, char *addr, int maxlen)
2222 {
2223 char *iport_ua;
2224
2225 /* limit ndi_devi_findchild_by_callback to expected flavor */
2226 if (ndi_flavor_get(child) != SCSA_FLAVOR_IPORT)
2227 return (DDI_FAILURE);
2228
2229 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, child,
2230 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
2231 SCSI_ADDR_PROP_IPORTUA, &iport_ua) != DDI_SUCCESS) {
2232 return (DDI_FAILURE);
2233 }
2234
2235 (void) snprintf(addr, maxlen, "%s", iport_ua);
2236 ddi_prop_free(iport_ua);
2237 return (DDI_SUCCESS);
2238 }
2239
2240 static int
iport_busctl_reportdev(dev_info_t * child)2241 iport_busctl_reportdev(dev_info_t *child)
2242 {
2243 dev_info_t *self = ddi_get_parent(child);
2244 char *iport_ua;
2245 char *initiator_port = NULL;
2246
2247 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, child,
2248 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
2249 SCSI_ADDR_PROP_IPORTUA, &iport_ua) != DDI_SUCCESS)
2250 return (DDI_FAILURE);
2251
2252 (void) ddi_prop_lookup_string(DDI_DEV_T_ANY, child,
2253 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
2254 SCSI_ADDR_PROP_INITIATOR_PORT, &initiator_port);
2255
2256 if (initiator_port) {
2257 SCSI_HBA_LOG((_LOG_NF(CONT),
2258 "?%s%d at %s%d: %s %s %s %s",
2259 ddi_driver_name(child), ddi_get_instance(child),
2260 ddi_driver_name(self), ddi_get_instance(self),
2261 SCSI_ADDR_PROP_INITIATOR_PORT, initiator_port,
2262 SCSI_ADDR_PROP_IPORTUA, iport_ua));
2263 ddi_prop_free(initiator_port);
2264 } else {
2265 SCSI_HBA_LOG((_LOG_NF(CONT), "?%s%d at %s%d: %s %s",
2266 ddi_driver_name(child), ddi_get_instance(child),
2267 ddi_driver_name(self), ddi_get_instance(self),
2268 SCSI_ADDR_PROP_IPORTUA, iport_ua));
2269 }
2270 ddi_prop_free(iport_ua);
2271 return (DDI_SUCCESS);
2272 }
2273
2274 /* initchild SCSA iport 'child' node */
2275 static int
iport_busctl_initchild(dev_info_t * child)2276 iport_busctl_initchild(dev_info_t *child)
2277 {
2278 dev_info_t *self = ddi_get_parent(child);
2279 dev_info_t *dup = NULL;
2280 char addr[SCSI_MAXNAMELEN];
2281
2282 if (iport_busctl_ua(child, addr, sizeof (addr)) != DDI_SUCCESS)
2283 return (DDI_NOT_WELL_FORMED);
2284
2285 /* Prevent duplicate nodes. */
2286 dup = ndi_devi_findchild_by_callback(self, ddi_node_name(child), addr,
2287 iport_busctl_ua);
2288 if (dup) {
2289 ASSERT(ndi_flavor_get(dup) == SCSA_FLAVOR_IPORT);
2290 if (ndi_flavor_get(dup) != SCSA_FLAVOR_IPORT) {
2291 SCSI_HBA_LOG((_LOG(1), NULL, child,
2292 "init failed: %s@%s: not IPORT flavored",
2293 ddi_node_name(child), addr));
2294 return (DDI_FAILURE);
2295 }
2296 if (dup != child) {
2297 SCSI_HBA_LOG((_LOG(4), NULL, child,
2298 "init failed: %s@%s: detected duplicate %p",
2299 ddi_node_name(child), addr, (void *)dup));
2300 return (DDI_FAILURE);
2301 }
2302 }
2303
2304 /* set the node @addr string */
2305 ddi_set_name_addr(child, addr);
2306
2307 return (DDI_SUCCESS);
2308 }
2309
2310 /* uninitchild SCSA iport 'child' node */
2311 static int
iport_busctl_uninitchild(dev_info_t * child)2312 iport_busctl_uninitchild(dev_info_t *child)
2313 {
2314 ddi_set_name_addr(child, NULL);
2315 return (DDI_SUCCESS);
2316 }
2317
2318 /* Uninitialize scsi_device flavor of transport on SCSA iport 'child' node. */
2319 static void
iport_postdetach_tran_scsi_device(dev_info_t * child)2320 iport_postdetach_tran_scsi_device(dev_info_t *child)
2321 {
2322 scsi_hba_tran_t *tran;
2323
2324 tran = ndi_flavorv_get(child, SCSA_FLAVOR_SCSI_DEVICE);
2325 if (tran == NULL)
2326 return;
2327
2328 scsa_tran_teardown(child, tran);
2329 scsa_nexus_teardown(child, tran);
2330
2331 ndi_flavorv_set(child, SCSA_FLAVOR_SCSI_DEVICE, NULL);
2332 scsi_hba_tran_free(tran);
2333 }
2334
2335 /* Initialize scsi_device flavor of transport on SCSA iport 'child' node. */
2336 static void
iport_preattach_tran_scsi_device(dev_info_t * child)2337 iport_preattach_tran_scsi_device(dev_info_t *child)
2338 {
2339 dev_info_t *hba = ddi_get_parent(child);
2340 scsi_hba_tran_t *htran;
2341 scsi_hba_tran_t *tran;
2342
2343 /* parent HBA node scsi_device tran is required */
2344 htran = ndi_flavorv_get(hba, SCSA_FLAVOR_SCSI_DEVICE);
2345 ASSERT(htran);
2346
2347 /* Allocate iport child's scsi_device transport vector */
2348 tran = scsi_hba_tran_alloc(child, SCSI_HBA_CANSLEEP);
2349 ASSERT(tran);
2350
2351 /* Structure-copy scsi_device transport of HBA to iport. */
2352 *tran = *htran;
2353
2354 /*
2355 * Reset scsi_device transport fields not shared with the
2356 * parent, and not established below.
2357 */
2358 tran->tran_open_flag = 0;
2359 tran->tran_hba_private = NULL;
2360
2361 /* Establish the devinfo context of this tran structure. */
2362 tran->tran_iport_dip = child;
2363
2364 /* Clear SCSI_HBA_SCSA flags (except TA) */
2365 tran->tran_hba_flags &=
2366 ~(SCSI_HBA_SCSA_FM | SCSI_HBA_SCSA_PHCI); /* clear parent state */
2367 tran->tran_hba_flags |= SCSI_HBA_SCSA_TA; /* always TA */
2368 tran->tran_hba_flags &= ~SCSI_HBA_HBA; /* never HBA */
2369
2370 /* Establish flavor of transport (and ddi_get_driver_private()) */
2371 ndi_flavorv_set(child, SCSA_FLAVOR_SCSI_DEVICE, tran);
2372
2373 /* Setup iport node */
2374 if ((scsa_nexus_setup(child, tran) != DDI_SUCCESS) ||
2375 (scsa_tran_setup(child, tran) != DDI_SUCCESS))
2376 iport_postdetach_tran_scsi_device(child);
2377 }
2378
2379 /* Uninitialize smp_device flavor of transport on SCSA iport 'child' node. */
2380 static void
iport_postdetach_tran_smp_device(dev_info_t * child)2381 iport_postdetach_tran_smp_device(dev_info_t *child)
2382 {
2383 smp_hba_tran_t *tran;
2384
2385 tran = ndi_flavorv_get(child, SCSA_FLAVOR_SMP);
2386 if (tran == NULL)
2387 return;
2388
2389 ndi_flavorv_set(child, SCSA_FLAVOR_SMP, NULL);
2390 smp_hba_tran_free(tran);
2391 }
2392
2393 /* Initialize smp_device flavor of transport on SCSA iport 'child' node. */
2394 static void
iport_preattach_tran_smp_device(dev_info_t * child)2395 iport_preattach_tran_smp_device(dev_info_t *child)
2396 {
2397 dev_info_t *hba = ddi_get_parent(child);
2398 smp_hba_tran_t *htran;
2399 smp_hba_tran_t *tran;
2400
2401 /* parent HBA node smp_device tran is optional */
2402 htran = ndi_flavorv_get(hba, SCSA_FLAVOR_SMP);
2403 if (htran == NULL) {
2404 ndi_flavorv_set(child, SCSA_FLAVOR_SMP, NULL);
2405 return;
2406 }
2407
2408 /* Allocate iport child's smp_device transport vector */
2409 tran = smp_hba_tran_alloc(child);
2410
2411 /* Structure-copy smp_device transport of HBA to iport. */
2412 *tran = *htran;
2413
2414 /* Establish flavor of transport */
2415 ndi_flavorv_set(child, SCSA_FLAVOR_SMP, tran);
2416 }
2417
2418 /*
2419 * Generic bus_ctl operations for SCSI HBA's,
2420 * hiding the busctl interface from the HBA.
2421 */
2422 /*ARGSUSED*/
2423 static int
scsi_hba_bus_ctl(dev_info_t * self,dev_info_t * child,ddi_ctl_enum_t op,void * arg,void * result)2424 scsi_hba_bus_ctl(
2425 dev_info_t *self,
2426 dev_info_t *child,
2427 ddi_ctl_enum_t op,
2428 void *arg,
2429 void *result)
2430 {
2431 int child_flavor = 0;
2432 int val;
2433 ddi_dma_attr_t *attr;
2434 scsi_hba_tran_t *tran;
2435 struct attachspec *as;
2436 struct detachspec *ds;
2437
2438 /* For some ops, child is 'arg'. */
2439 if ((op == DDI_CTLOPS_INITCHILD) || (op == DDI_CTLOPS_UNINITCHILD))
2440 child = (dev_info_t *)arg;
2441
2442 /* Determine the flavor of the child: scsi, smp, iport */
2443 child_flavor = ndi_flavor_get(child);
2444
2445 switch (op) {
2446 case DDI_CTLOPS_INITCHILD:
2447 switch (child_flavor) {
2448 case SCSA_FLAVOR_SCSI_DEVICE:
2449 return (scsi_busctl_initchild(child));
2450 case SCSA_FLAVOR_SMP:
2451 return (smp_busctl_initchild(child));
2452 case SCSA_FLAVOR_IPORT:
2453 return (iport_busctl_initchild(child));
2454 default:
2455 return (DDI_FAILURE);
2456 }
2457 /* NOTREACHED */
2458
2459 case DDI_CTLOPS_UNINITCHILD:
2460 switch (child_flavor) {
2461 case SCSA_FLAVOR_SCSI_DEVICE:
2462 return (scsi_busctl_uninitchild(child));
2463 case SCSA_FLAVOR_SMP:
2464 return (smp_busctl_uninitchild(child));
2465 case SCSA_FLAVOR_IPORT:
2466 return (iport_busctl_uninitchild(child));
2467 default:
2468 return (DDI_FAILURE);
2469 }
2470 /* NOTREACHED */
2471
2472 case DDI_CTLOPS_REPORTDEV:
2473 switch (child_flavor) {
2474 case SCSA_FLAVOR_SCSI_DEVICE:
2475 return (scsi_busctl_reportdev(child));
2476 case SCSA_FLAVOR_SMP:
2477 return (smp_busctl_reportdev(child));
2478 case SCSA_FLAVOR_IPORT:
2479 return (iport_busctl_reportdev(child));
2480 default:
2481 return (DDI_FAILURE);
2482 }
2483 /* NOTREACHED */
2484
2485 case DDI_CTLOPS_ATTACH:
2486 as = (struct attachspec *)arg;
2487
2488 if (child_flavor != SCSA_FLAVOR_IPORT)
2489 return (DDI_SUCCESS);
2490
2491 /* iport processing */
2492 if (as->when == DDI_PRE) {
2493 /* setup pre attach(9E) */
2494 iport_preattach_tran_scsi_device(child);
2495 iport_preattach_tran_smp_device(child);
2496 } else if ((as->when == DDI_POST) &&
2497 (as->result != DDI_SUCCESS)) {
2498 /* cleanup if attach(9E) failed */
2499 iport_postdetach_tran_scsi_device(child);
2500 iport_postdetach_tran_smp_device(child);
2501 }
2502 return (DDI_SUCCESS);
2503
2504 case DDI_CTLOPS_DETACH:
2505 ds = (struct detachspec *)arg;
2506
2507 if (child_flavor != SCSA_FLAVOR_IPORT)
2508 return (DDI_SUCCESS);
2509
2510 /* iport processing */
2511 if ((ds->when == DDI_POST) &&
2512 (ds->result == DDI_SUCCESS)) {
2513 /* cleanup if detach(9E) was successful */
2514 iport_postdetach_tran_scsi_device(child);
2515 iport_postdetach_tran_smp_device(child);
2516 }
2517 return (DDI_SUCCESS);
2518
2519 case DDI_CTLOPS_IOMIN:
2520 tran = ddi_get_driver_private(self);
2521 ASSERT(tran);
2522 if (tran == NULL)
2523 return (DDI_FAILURE);
2524
2525 /*
2526 * The 'arg' value of nonzero indicates 'streaming'
2527 * mode. If in streaming mode, pick the largest
2528 * of our burstsizes available and say that that
2529 * is our minimum value (modulo what minxfer is).
2530 */
2531 attr = &tran->tran_dma_attr;
2532 val = *((int *)result);
2533 val = maxbit(val, attr->dma_attr_minxfer);
2534 *((int *)result) = maxbit(val, ((intptr_t)arg ?
2535 (1<<ddi_ffs(attr->dma_attr_burstsizes)-1) :
2536 (1<<(ddi_fls(attr->dma_attr_burstsizes)-1))));
2537
2538 return (ddi_ctlops(self, child, op, arg, result));
2539
2540 case DDI_CTLOPS_SIDDEV:
2541 return (ndi_dev_is_persistent_node(child) ?
2542 DDI_SUCCESS : DDI_FAILURE);
2543
2544 case DDI_CTLOPS_POWER:
2545 return (DDI_SUCCESS);
2546
2547 /*
2548 * These ops correspond to functions that "shouldn't" be called
2549 * by a SCSI target driver. So we whine when we're called.
2550 */
2551 case DDI_CTLOPS_DMAPMAPC:
2552 case DDI_CTLOPS_REPORTINT:
2553 case DDI_CTLOPS_REGSIZE:
2554 case DDI_CTLOPS_NREGS:
2555 case DDI_CTLOPS_SLAVEONLY:
2556 case DDI_CTLOPS_AFFINITY:
2557 case DDI_CTLOPS_POKE:
2558 case DDI_CTLOPS_PEEK:
2559 SCSI_HBA_LOG((_LOG(WARN), self, NULL, "invalid op (%d)", op));
2560 return (DDI_FAILURE);
2561
2562 /* Everything else we pass up */
2563 case DDI_CTLOPS_PTOB:
2564 case DDI_CTLOPS_BTOP:
2565 case DDI_CTLOPS_BTOPR:
2566 case DDI_CTLOPS_DVMAPAGESIZE:
2567 default:
2568 return (ddi_ctlops(self, child, op, arg, result));
2569 }
2570 /* NOTREACHED */
2571 }
2572
2573 /*
2574 * Private wrapper for scsi_pkt's allocated via scsi_hba_pkt_alloc()
2575 */
2576 struct scsi_pkt_wrapper {
2577 struct scsi_pkt scsi_pkt;
2578 int pkt_wrapper_magic;
2579 int pkt_wrapper_len;
2580 };
2581
2582 #if !defined(lint)
2583 _NOTE(SCHEME_PROTECTS_DATA("unique per thread", scsi_pkt_wrapper))
2584 _NOTE(SCHEME_PROTECTS_DATA("Unshared Data", dev_ops))
2585 #endif
2586
2587 /*
2588 * Called by an HBA to allocate a scsi_pkt
2589 */
2590 /*ARGSUSED*/
2591 struct scsi_pkt *
scsi_hba_pkt_alloc(dev_info_t * self,struct scsi_address * ap,int cmdlen,int statuslen,int tgtlen,int hbalen,int (* callback)(caddr_t arg),caddr_t arg)2592 scsi_hba_pkt_alloc(
2593 dev_info_t *self,
2594 struct scsi_address *ap,
2595 int cmdlen,
2596 int statuslen,
2597 int tgtlen,
2598 int hbalen,
2599 int (*callback)(caddr_t arg),
2600 caddr_t arg)
2601 {
2602 struct scsi_pkt *pkt;
2603 struct scsi_pkt_wrapper *hba_pkt;
2604 caddr_t p;
2605 int acmdlen, astatuslen, atgtlen, ahbalen;
2606 int pktlen;
2607
2608 /* Sanity check */
2609 if (callback != SLEEP_FUNC && callback != NULL_FUNC)
2610 SCSI_HBA_LOG((_LOG(WARN), self, NULL,
2611 "callback must be SLEEP_FUNC or NULL_FUNC"));
2612
2613 /*
2614 * Round up so everything gets allocated on long-word boundaries
2615 */
2616 acmdlen = ROUNDUP(cmdlen);
2617 astatuslen = ROUNDUP(statuslen);
2618 atgtlen = ROUNDUP(tgtlen);
2619 ahbalen = ROUNDUP(hbalen);
2620 pktlen = sizeof (struct scsi_pkt_wrapper) +
2621 acmdlen + astatuslen + atgtlen + ahbalen;
2622
2623 hba_pkt = kmem_zalloc(pktlen,
2624 (callback == SLEEP_FUNC) ? KM_SLEEP : KM_NOSLEEP);
2625 if (hba_pkt == NULL) {
2626 ASSERT(callback == NULL_FUNC);
2627 return (NULL);
2628 }
2629
2630 /*
2631 * Set up our private info on this pkt
2632 */
2633 hba_pkt->pkt_wrapper_len = pktlen;
2634 hba_pkt->pkt_wrapper_magic = PKT_WRAPPER_MAGIC; /* alloced correctly */
2635 pkt = &hba_pkt->scsi_pkt;
2636
2637 /*
2638 * Set up pointers to private data areas, cdb, and status.
2639 */
2640 p = (caddr_t)(hba_pkt + 1);
2641 if (hbalen > 0) {
2642 pkt->pkt_ha_private = (opaque_t)p;
2643 p += ahbalen;
2644 }
2645 if (tgtlen > 0) {
2646 pkt->pkt_private = (opaque_t)p;
2647 p += atgtlen;
2648 }
2649 if (statuslen > 0) {
2650 pkt->pkt_scbp = (uchar_t *)p;
2651 p += astatuslen;
2652 }
2653 if (cmdlen > 0) {
2654 pkt->pkt_cdbp = (uchar_t *)p;
2655 }
2656
2657 /*
2658 * Initialize the pkt's scsi_address
2659 */
2660 pkt->pkt_address = *ap;
2661
2662 /*
2663 * NB: It may not be safe for drivers, esp target drivers, to depend
2664 * on the following fields being set until all the scsi_pkt
2665 * allocation violations discussed in scsi_pkt.h are all resolved.
2666 */
2667 pkt->pkt_cdblen = cmdlen;
2668 pkt->pkt_tgtlen = tgtlen;
2669 pkt->pkt_scblen = statuslen;
2670
2671 return (pkt);
2672 }
2673
2674 /*
2675 * Called by an HBA to free a scsi_pkt
2676 */
2677 /*ARGSUSED*/
2678 void
scsi_hba_pkt_free(struct scsi_address * ap,struct scsi_pkt * pkt)2679 scsi_hba_pkt_free(
2680 struct scsi_address *ap,
2681 struct scsi_pkt *pkt)
2682 {
2683 kmem_free(pkt, ((struct scsi_pkt_wrapper *)pkt)->pkt_wrapper_len);
2684 }
2685
2686 /*
2687 * Return 1 if the scsi_pkt used a proper allocator.
2688 *
2689 * The DDI does not allow a driver to allocate it's own scsi_pkt(9S), a
2690 * driver should not have *any* compiled in dependencies on "sizeof (struct
2691 * scsi_pkt)". While this has been the case for many years, a number of
2692 * drivers have still not been fixed. This function can be used to detect
2693 * improperly allocated scsi_pkt structures, and produce messages identifying
2694 * drivers that need to be fixed.
2695 *
2696 * While drivers in violation are being fixed, this function can also
2697 * be used by the framework to detect packets that violated allocation
2698 * rules.
2699 *
2700 * NB: It is possible, but very unlikely, for this code to return a false
2701 * positive (finding correct magic, but for wrong reasons). Careful
2702 * consideration is needed for callers using this interface to condition
2703 * access to newer scsi_pkt fields (those after pkt_reason).
2704 *
2705 * NB: As an aid to minimizing the amount of work involved in 'fixing' legacy
2706 * drivers that violate scsi_*(9S) allocation rules, private
2707 * scsi_pkt_size()/scsi_size_clean() functions are available (see their
2708 * implementation for details).
2709 *
2710 * *** Non-legacy use of scsi_pkt_size() is discouraged. ***
2711 *
2712 * NB: When supporting broken HBA drivers is not longer a concern, this
2713 * code should be removed.
2714 */
2715 int
scsi_pkt_allocated_correctly(struct scsi_pkt * pkt)2716 scsi_pkt_allocated_correctly(struct scsi_pkt *pkt)
2717 {
2718 struct scsi_pkt_wrapper *hba_pkt = (struct scsi_pkt_wrapper *)pkt;
2719 int magic;
2720 major_t major;
2721 #ifdef DEBUG
2722 int *pspwm, *pspcwm;
2723
2724 /*
2725 * We are getting scsi packets from two 'correct' wrapper schemes,
2726 * make sure we are looking at the same place in both to detect
2727 * proper allocation.
2728 */
2729 pspwm = &((struct scsi_pkt_wrapper *)0)->pkt_wrapper_magic;
2730 pspcwm = &((struct scsi_pkt_cache_wrapper *)0)->pcw_magic;
2731 ASSERT(pspwm == pspcwm);
2732 #endif /* DEBUG */
2733
2734
2735 /*
2736 * Check to see if driver is scsi_size_clean(), assume it
2737 * is using the scsi_pkt_size() interface everywhere it needs to
2738 * if the driver indicates it is scsi_size_clean().
2739 */
2740 major = ddi_driver_major(P_TO_TRAN(pkt)->tran_hba_dip);
2741 if (devnamesp[major].dn_flags & DN_SCSI_SIZE_CLEAN)
2742 return (1); /* ok */
2743
2744 /*
2745 * Special case crossing a page boundary. If the scsi_pkt was not
2746 * allocated correctly, then across a page boundary we have a
2747 * fault hazard.
2748 */
2749 if ((((uintptr_t)(&hba_pkt->scsi_pkt)) & MMU_PAGEMASK) ==
2750 (((uintptr_t)(&hba_pkt->pkt_wrapper_magic)) & MMU_PAGEMASK)) {
2751 /* fastpath, no cross-page hazard */
2752 magic = hba_pkt->pkt_wrapper_magic;
2753 } else {
2754 /* add protection for cross-page hazard */
2755 if (ddi_peek32((dev_info_t *)NULL,
2756 &hba_pkt->pkt_wrapper_magic, &magic) == DDI_FAILURE) {
2757 return (0); /* violation */
2758 }
2759 }
2760
2761 /* properly allocated packet always has correct magic */
2762 return ((magic == PKT_WRAPPER_MAGIC) ? 1 : 0);
2763 }
2764
2765 /*
2766 * Private interfaces to simplify conversion of legacy drivers so they don't
2767 * depend on scsi_*(9S) size. Instead of using these private interface, HBA
2768 * drivers should use DDI sanctioned allocation methods:
2769 *
2770 * scsi_pkt Use scsi_hba_pkt_alloc(9F), or implement
2771 * tran_setup_pkt(9E).
2772 *
2773 * scsi_device You are doing something strange/special, a scsi_device
2774 * structure should only be allocated by scsi_hba.c
2775 * initchild code or scsi_vhci.c code.
2776 *
2777 * scsi_hba_tran Use scsi_hba_tran_alloc(9F).
2778 */
2779 size_t
scsi_pkt_size()2780 scsi_pkt_size()
2781 {
2782 return (sizeof (struct scsi_pkt));
2783 }
2784
2785 size_t
scsi_hba_tran_size()2786 scsi_hba_tran_size()
2787 {
2788 return (sizeof (scsi_hba_tran_t));
2789 }
2790
2791 size_t
scsi_device_size()2792 scsi_device_size()
2793 {
2794 return (sizeof (struct scsi_device));
2795 }
2796
2797 /*
2798 * Legacy compliance to scsi_pkt(9S) allocation rules through use of
2799 * scsi_pkt_size() is detected by the 'scsi-size-clean' driver.conf property
2800 * or an HBA driver calling to scsi_size_clean() from attach(9E). A driver
2801 * developer should only indicate that a legacy driver is clean after using
2802 * SCSI_SIZE_CLEAN_VERIFY to ensure compliance (see scsi_pkt.h).
2803 */
2804 void
scsi_size_clean(dev_info_t * self)2805 scsi_size_clean(dev_info_t *self)
2806 {
2807 major_t major;
2808 struct devnames *dnp;
2809
2810 ASSERT(self);
2811 major = ddi_driver_major(self);
2812 ASSERT(major < devcnt);
2813 if (major >= devcnt) {
2814 SCSI_HBA_LOG((_LOG(WARN), self, NULL,
2815 "scsi_pkt_size: bogus major: %d", major));
2816 return;
2817 }
2818
2819 /* Set DN_SCSI_SIZE_CLEAN flag in dn_flags. */
2820 dnp = &devnamesp[major];
2821 if ((dnp->dn_flags & DN_SCSI_SIZE_CLEAN) == 0) {
2822 LOCK_DEV_OPS(&dnp->dn_lock);
2823 dnp->dn_flags |= DN_SCSI_SIZE_CLEAN;
2824 UNLOCK_DEV_OPS(&dnp->dn_lock);
2825 }
2826 }
2827
2828
2829 /*
2830 * Called by an HBA to map strings to capability indices
2831 */
2832 int
scsi_hba_lookup_capstr(char * capstr)2833 scsi_hba_lookup_capstr(
2834 char *capstr)
2835 {
2836 /*
2837 * Capability strings: only add entries to mask the legacy
2838 * '_' vs. '-' misery. All new capabilities should use '-',
2839 * and be captured be added to SCSI_CAP_ASCII.
2840 */
2841 static struct cap_strings {
2842 char *cap_string;
2843 int cap_index;
2844 } cap_strings[] = {
2845 { "dma_max", SCSI_CAP_DMA_MAX },
2846 { "msg_out", SCSI_CAP_MSG_OUT },
2847 { "wide_xfer", SCSI_CAP_WIDE_XFER },
2848 { NULL, 0 }
2849 };
2850 static char *cap_ascii[] = SCSI_CAP_ASCII;
2851 char **cap;
2852 int i;
2853 struct cap_strings *cp;
2854
2855 for (cap = cap_ascii, i = 0; *cap != NULL; cap++, i++)
2856 if (strcmp(*cap, capstr) == 0)
2857 return (i);
2858
2859 for (cp = cap_strings; cp->cap_string != NULL; cp++)
2860 if (strcmp(cp->cap_string, capstr) == 0)
2861 return (cp->cap_index);
2862
2863 return (-1);
2864 }
2865
2866 /*
2867 * Called by an HBA to determine if the system is in 'panic' state.
2868 */
2869 int
scsi_hba_in_panic()2870 scsi_hba_in_panic()
2871 {
2872 return (panicstr != NULL);
2873 }
2874
2875 /*
2876 * If a SCSI target driver attempts to mmap memory,
2877 * the buck stops here.
2878 */
2879 /*ARGSUSED*/
2880 static int
scsi_hba_map_fault(dev_info_t * self,dev_info_t * child,struct hat * hat,struct seg * seg,caddr_t addr,struct devpage * dp,pfn_t pfn,uint_t prot,uint_t lock)2881 scsi_hba_map_fault(
2882 dev_info_t *self,
2883 dev_info_t *child,
2884 struct hat *hat,
2885 struct seg *seg,
2886 caddr_t addr,
2887 struct devpage *dp,
2888 pfn_t pfn,
2889 uint_t prot,
2890 uint_t lock)
2891 {
2892 return (DDI_FAILURE);
2893 }
2894
2895 static int
scsi_hba_get_eventcookie(dev_info_t * self,dev_info_t * child,char * name,ddi_eventcookie_t * eventp)2896 scsi_hba_get_eventcookie(
2897 dev_info_t *self,
2898 dev_info_t *child,
2899 char *name,
2900 ddi_eventcookie_t *eventp)
2901 {
2902 scsi_hba_tran_t *tran;
2903
2904 tran = ddi_get_driver_private(self);
2905 if (tran->tran_get_eventcookie &&
2906 ((*tran->tran_get_eventcookie)(self,
2907 child, name, eventp) == DDI_SUCCESS)) {
2908 return (DDI_SUCCESS);
2909 }
2910
2911 return (ndi_busop_get_eventcookie(self, child, name, eventp));
2912 }
2913
2914 static int
scsi_hba_add_eventcall(dev_info_t * self,dev_info_t * child,ddi_eventcookie_t event,void (* callback)(dev_info_t * self,ddi_eventcookie_t event,void * arg,void * bus_impldata),void * arg,ddi_callback_id_t * cb_id)2915 scsi_hba_add_eventcall(
2916 dev_info_t *self,
2917 dev_info_t *child,
2918 ddi_eventcookie_t event,
2919 void (*callback)(
2920 dev_info_t *self,
2921 ddi_eventcookie_t event,
2922 void *arg,
2923 void *bus_impldata),
2924 void *arg,
2925 ddi_callback_id_t *cb_id)
2926 {
2927 scsi_hba_tran_t *tran;
2928
2929 tran = ddi_get_driver_private(self);
2930 if (tran->tran_add_eventcall &&
2931 ((*tran->tran_add_eventcall)(self, child,
2932 event, callback, arg, cb_id) == DDI_SUCCESS)) {
2933 return (DDI_SUCCESS);
2934 }
2935
2936 return (DDI_FAILURE);
2937 }
2938
2939 static int
scsi_hba_remove_eventcall(dev_info_t * self,ddi_callback_id_t cb_id)2940 scsi_hba_remove_eventcall(dev_info_t *self, ddi_callback_id_t cb_id)
2941 {
2942 scsi_hba_tran_t *tran;
2943 ASSERT(cb_id);
2944
2945 tran = ddi_get_driver_private(self);
2946 if (tran->tran_remove_eventcall &&
2947 ((*tran->tran_remove_eventcall)(
2948 self, cb_id) == DDI_SUCCESS)) {
2949 return (DDI_SUCCESS);
2950 }
2951
2952 return (DDI_FAILURE);
2953 }
2954
2955 static int
scsi_hba_post_event(dev_info_t * self,dev_info_t * child,ddi_eventcookie_t event,void * bus_impldata)2956 scsi_hba_post_event(
2957 dev_info_t *self,
2958 dev_info_t *child,
2959 ddi_eventcookie_t event,
2960 void *bus_impldata)
2961 {
2962 scsi_hba_tran_t *tran;
2963
2964 tran = ddi_get_driver_private(self);
2965 if (tran->tran_post_event &&
2966 ((*tran->tran_post_event)(self,
2967 child, event, bus_impldata) == DDI_SUCCESS)) {
2968 return (DDI_SUCCESS);
2969 }
2970
2971 return (DDI_FAILURE);
2972 }
2973
2974 /*
2975 * Default getinfo(9e) for scsi_hba
2976 */
2977 /* ARGSUSED */
2978 static int
scsi_hba_info(dev_info_t * self,ddi_info_cmd_t infocmd,void * arg,void ** result)2979 scsi_hba_info(dev_info_t *self, ddi_info_cmd_t infocmd, void *arg,
2980 void **result)
2981 {
2982 int error = DDI_SUCCESS;
2983
2984 switch (infocmd) {
2985 case DDI_INFO_DEVT2INSTANCE:
2986 *result = (void *)(intptr_t)(MINOR2INST(getminor((dev_t)arg)));
2987 break;
2988 default:
2989 error = DDI_FAILURE;
2990 }
2991 return (error);
2992 }
2993
2994 /*
2995 * Default open and close routine for scsi_hba
2996 */
2997 /* ARGSUSED */
2998 int
scsi_hba_open(dev_t * devp,int flags,int otyp,cred_t * credp)2999 scsi_hba_open(dev_t *devp, int flags, int otyp, cred_t *credp)
3000 {
3001 dev_info_t *self;
3002 scsi_hba_tran_t *tran;
3003 int rv = 0;
3004
3005 if (otyp != OTYP_CHR)
3006 return (EINVAL);
3007
3008 if ((self = e_ddi_hold_devi_by_dev(*devp, 0)) == NULL)
3009 return (ENXIO);
3010
3011 tran = ddi_get_driver_private(self);
3012 if (tran == NULL) {
3013 ddi_release_devi(self);
3014 return (ENXIO);
3015 }
3016
3017 /*
3018 * tran_open_flag bit field:
3019 * 0: closed
3020 * 1: shared open by minor at bit position
3021 * 1 at 31st bit: exclusive open
3022 */
3023 mutex_enter(&(tran->tran_open_lock));
3024 if (flags & FEXCL) {
3025 if (tran->tran_open_flag != 0) {
3026 rv = EBUSY; /* already open */
3027 } else {
3028 tran->tran_open_flag = TRAN_OPEN_EXCL;
3029 }
3030 } else {
3031 if (tran->tran_open_flag == TRAN_OPEN_EXCL) {
3032 rv = EBUSY; /* already excl. open */
3033 } else {
3034 int minor = getminor(*devp) & TRAN_MINOR_MASK;
3035 tran->tran_open_flag |= (1 << minor);
3036 /*
3037 * Ensure that the last framework reserved minor
3038 * is unused. Otherwise, the exclusive open
3039 * mechanism may break.
3040 */
3041 ASSERT(minor != 31);
3042 }
3043 }
3044 mutex_exit(&(tran->tran_open_lock));
3045
3046 ddi_release_devi(self);
3047 return (rv);
3048 }
3049
3050 /* ARGSUSED */
3051 int
scsi_hba_close(dev_t dev,int flag,int otyp,cred_t * credp)3052 scsi_hba_close(dev_t dev, int flag, int otyp, cred_t *credp)
3053 {
3054 dev_info_t *self;
3055 scsi_hba_tran_t *tran;
3056
3057 if (otyp != OTYP_CHR)
3058 return (EINVAL);
3059
3060 if ((self = e_ddi_hold_devi_by_dev(dev, 0)) == NULL)
3061 return (ENXIO);
3062
3063 tran = ddi_get_driver_private(self);
3064 if (tran == NULL) {
3065 ddi_release_devi(self);
3066 return (ENXIO);
3067 }
3068
3069 mutex_enter(&(tran->tran_open_lock));
3070 if (tran->tran_open_flag == TRAN_OPEN_EXCL) {
3071 tran->tran_open_flag = 0;
3072 } else {
3073 int minor = getminor(dev) & TRAN_MINOR_MASK;
3074 tran->tran_open_flag &= ~(1 << minor);
3075 }
3076 mutex_exit(&(tran->tran_open_lock));
3077
3078 ddi_release_devi(self);
3079 return (0);
3080 }
3081
3082 /*
3083 * standard ioctl commands for SCSI hotplugging
3084 */
3085 /* ARGSUSED */
3086 int
scsi_hba_ioctl(dev_t dev,int cmd,intptr_t arg,int mode,cred_t * credp,int * rvalp)3087 scsi_hba_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
3088 int *rvalp)
3089 {
3090 dev_info_t *self;
3091 struct devctl_iocdata *dcp = NULL;
3092 dev_info_t *child = NULL;
3093 mdi_pathinfo_t *path = NULL;
3094 struct scsi_device *sd;
3095 scsi_hba_tran_t *tran;
3096 uint_t bus_state;
3097 int rv = 0;
3098 boolean_t enteredv;
3099 char *name;
3100 char *addr;
3101
3102 self = e_ddi_hold_devi_by_dev(dev, 0);
3103 if (self == NULL) {
3104 rv = ENXIO;
3105 goto out;
3106 }
3107
3108 tran = ddi_get_driver_private(self);
3109 if (tran == NULL) {
3110 rv = ENXIO;
3111 goto out;
3112 }
3113
3114 /* Ioctls for which the generic implementation suffices. */
3115 switch (cmd) {
3116 case DEVCTL_BUS_GETSTATE:
3117 rv = ndi_devctl_ioctl(self, cmd, arg, mode, 0);
3118 goto out;
3119 }
3120
3121 /* read devctl ioctl data */
3122 if (ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS) {
3123 rv = EFAULT;
3124 goto out;
3125 }
3126
3127 /* Ioctls that require child identification */
3128 switch (cmd) {
3129 case DEVCTL_DEVICE_GETSTATE:
3130 case DEVCTL_DEVICE_ONLINE:
3131 case DEVCTL_DEVICE_OFFLINE:
3132 case DEVCTL_DEVICE_REMOVE:
3133 case DEVCTL_DEVICE_RESET:
3134 name = ndi_dc_getname(dcp);
3135 addr = ndi_dc_getaddr(dcp);
3136 if ((name == NULL) || (addr == NULL)) {
3137 rv = EINVAL;
3138 goto out;
3139 }
3140
3141 /*
3142 * Find child with name@addr - might find a devinfo
3143 * child (child), a pathinfo child (path), or nothing.
3144 */
3145 scsi_hba_devi_enter(self, &enteredv);
3146
3147 (void) scsi_findchild(self, name, addr, 1, &child, &path, NULL);
3148 if (path) {
3149 /* Found a pathinfo */
3150 ASSERT(path && (child == NULL));
3151 mdi_hold_path(path);
3152 scsi_hba_devi_exit_phci(self);
3153 sd = NULL;
3154 } else if (child) {
3155 /* Found a devinfo */
3156 ASSERT(child && (path == NULL));
3157
3158 /* verify scsi_device of child */
3159 if (ndi_flavor_get(child) == SCSA_FLAVOR_SCSI_DEVICE)
3160 sd = ddi_get_driver_private(child);
3161 else
3162 sd = NULL;
3163 } else {
3164 ASSERT((path == NULL) && (child == NULL));
3165 scsi_hba_devi_exit(self, enteredv);
3166 rv = ENXIO; /* found nothing */
3167 goto out;
3168 }
3169 break;
3170
3171 case DEVCTL_BUS_RESETALL: /* ioctl that operate on any child */
3172 /*
3173 * Find a child's scsi_address so we can invoke tran_reset.
3174 *
3175 * Future: If no child exists, we could fake a child. This will
3176 * be a enhancement for the future - for now, we fall back to
3177 * BUS_RESET.
3178 */
3179 scsi_hba_devi_enter(self, &enteredv);
3180 child = ddi_get_child(self);
3181 sd = NULL;
3182 while (child) {
3183 /* verify scsi_device of child */
3184 if (ndi_flavor_get(child) == SCSA_FLAVOR_SCSI_DEVICE)
3185 sd = ddi_get_driver_private(child);
3186 if (sd != NULL) {
3187 /*
3188 * NOTE: node has a scsi_device structure, so
3189 * it must be initialized.
3190 */
3191 ndi_hold_devi(child);
3192 break;
3193 }
3194 child = ddi_get_next_sibling(child);
3195 }
3196 if (child == NULL)
3197 scsi_hba_devi_exit(self, enteredv);
3198 break;
3199 }
3200
3201 switch (cmd) {
3202 case DEVCTL_DEVICE_GETSTATE:
3203 if (path) {
3204 if (mdi_dc_return_dev_state(path, dcp) != MDI_SUCCESS)
3205 rv = EFAULT;
3206 } else if (child) {
3207 if (ndi_dc_return_dev_state(child, dcp) != NDI_SUCCESS)
3208 rv = EFAULT;
3209 } else {
3210 rv = ENXIO;
3211 }
3212 break;
3213
3214 case DEVCTL_DEVICE_RESET:
3215 if (sd == NULL) {
3216 rv = ENOTTY;
3217 break;
3218 }
3219 if (tran->tran_reset == NULL) {
3220 rv = ENOTSUP;
3221 break;
3222 }
3223
3224 /* Start with the small stick */
3225 if (scsi_reset(&sd->sd_address, RESET_LUN) == 1)
3226 break; /* LUN reset worked */
3227 if (scsi_reset(&sd->sd_address, RESET_TARGET) != 1)
3228 rv = EIO; /* Target reset failed */
3229 break;
3230
3231 case DEVCTL_BUS_QUIESCE:
3232 if ((ndi_get_bus_state(self, &bus_state) == NDI_SUCCESS) &&
3233 (bus_state == BUS_QUIESCED))
3234 rv = EALREADY;
3235 else if (tran->tran_quiesce == NULL)
3236 rv = ENOTSUP; /* man ioctl(2) says ENOTTY */
3237 else if (tran->tran_quiesce(self) != 0)
3238 rv = EIO;
3239 else if (ndi_set_bus_state(self, BUS_QUIESCED) != NDI_SUCCESS)
3240 rv = EIO;
3241 break;
3242
3243 case DEVCTL_BUS_UNQUIESCE:
3244 if ((ndi_get_bus_state(self, &bus_state) == NDI_SUCCESS) &&
3245 (bus_state == BUS_ACTIVE))
3246 rv = EALREADY;
3247 else if (tran->tran_unquiesce == NULL)
3248 rv = ENOTSUP; /* man ioctl(2) says ENOTTY */
3249 else if (tran->tran_unquiesce(self) != 0)
3250 rv = EIO;
3251 else if (ndi_set_bus_state(self, BUS_ACTIVE) != NDI_SUCCESS)
3252 rv = EIO;
3253 break;
3254
3255 case DEVCTL_BUS_RESET:
3256 if (tran->tran_bus_reset == NULL)
3257 rv = ENOTSUP; /* man ioctl(2) says ENOTTY */
3258 else if (tran->tran_bus_reset(self, RESET_BUS) != 1)
3259 rv = EIO;
3260 break;
3261
3262 case DEVCTL_BUS_RESETALL:
3263 if ((sd != NULL) &&
3264 (scsi_reset(&sd->sd_address, RESET_ALL) == 1)) {
3265 break; /* reset all worked */
3266 }
3267 if (tran->tran_bus_reset == NULL) {
3268 rv = ENOTSUP; /* man ioctl(2) says ENOTTY */
3269 break;
3270 }
3271 if (tran->tran_bus_reset(self, RESET_BUS) != 1)
3272 rv = EIO; /* bus reset failed */
3273 break;
3274
3275 case DEVCTL_BUS_CONFIGURE:
3276 if (ndi_devi_config(self, NDI_DEVFS_CLEAN | NDI_DEVI_PERSIST |
3277 NDI_CONFIG_REPROBE) != NDI_SUCCESS) {
3278 rv = EIO;
3279 }
3280 break;
3281
3282 case DEVCTL_BUS_UNCONFIGURE:
3283 if (ndi_devi_unconfig(self,
3284 NDI_DEVFS_CLEAN | NDI_DEVI_REMOVE) != NDI_SUCCESS) {
3285 rv = EBUSY;
3286 }
3287 break;
3288
3289 case DEVCTL_DEVICE_ONLINE:
3290 ASSERT(child || path);
3291 if (path) {
3292 if (mdi_pi_online(path, NDI_USER_REQ) != MDI_SUCCESS)
3293 rv = EIO;
3294 } else {
3295 if (ndi_devi_online(child, 0) != NDI_SUCCESS)
3296 rv = EIO;
3297 }
3298 break;
3299
3300 case DEVCTL_DEVICE_OFFLINE:
3301 ASSERT(child || path);
3302 if (sd != NULL)
3303 (void) scsi_clear_task_set(&sd->sd_address);
3304 if (path) {
3305 if (mdi_pi_offline(path, NDI_USER_REQ) != MDI_SUCCESS)
3306 rv = EIO;
3307 } else {
3308 if (ndi_devi_offline(child,
3309 NDI_DEVFS_CLEAN) != NDI_SUCCESS)
3310 rv = EIO;
3311 }
3312 break;
3313
3314 case DEVCTL_DEVICE_REMOVE:
3315 ASSERT(child || path);
3316 if (sd != NULL)
3317 (void) scsi_clear_task_set(&sd->sd_address);
3318 if (path) {
3319 /* NOTE: don't pass NDI_DEVI_REMOVE to mdi_pi_offline */
3320 if (mdi_pi_offline(path, NDI_USER_REQ) == MDI_SUCCESS) {
3321 scsi_hba_devi_enter_phci(self);
3322 mdi_rele_path(path);
3323
3324 /* ... here is the DEVICE_REMOVE part. */
3325 (void) mdi_pi_free(path, 0);
3326 path = NULL;
3327 } else {
3328 rv = EIO;
3329 }
3330 } else {
3331 if (ndi_devi_offline(child,
3332 NDI_DEVFS_CLEAN | NDI_DEVI_REMOVE) != NDI_SUCCESS)
3333 rv = EIO;
3334 }
3335 break;
3336
3337 default:
3338 ASSERT(dcp != NULL);
3339 rv = ENOTTY;
3340 break;
3341 }
3342
3343 /* all done -- clean up and return */
3344 out:
3345 /* release hold on what we found */
3346 if (path) {
3347 scsi_hba_devi_enter_phci(self);
3348 mdi_rele_path(path);
3349 }
3350 if (path || child)
3351 scsi_hba_devi_exit(self, enteredv);
3352
3353 if (dcp)
3354 ndi_dc_freehdl(dcp);
3355
3356 if (self)
3357 ddi_release_devi(self);
3358
3359 *rvalp = rv;
3360
3361 return (rv);
3362 }
3363
3364 /*ARGSUSED*/
3365 static int
scsi_hba_fm_init_child(dev_info_t * self,dev_info_t * child,int cap,ddi_iblock_cookie_t * ibc)3366 scsi_hba_fm_init_child(dev_info_t *self, dev_info_t *child, int cap,
3367 ddi_iblock_cookie_t *ibc)
3368 {
3369 scsi_hba_tran_t *tran = ddi_get_driver_private(self);
3370
3371 return (tran ? tran->tran_fm_capable : scsi_fm_capable);
3372 }
3373
3374 static int
scsi_hba_bus_power(dev_info_t * self,void * impl_arg,pm_bus_power_op_t op,void * arg,void * result)3375 scsi_hba_bus_power(dev_info_t *self, void *impl_arg, pm_bus_power_op_t op,
3376 void *arg, void *result)
3377 {
3378 scsi_hba_tran_t *tran;
3379
3380 tran = ddi_get_driver_private(self);
3381 if (tran && tran->tran_bus_power) {
3382 return (tran->tran_bus_power(self, impl_arg,
3383 op, arg, result));
3384 }
3385
3386 return (pm_busop_bus_power(self, impl_arg, op, arg, result));
3387 }
3388
3389 /*
3390 * Return the lun64 value from a address string: "addr,lun[,sfunc]". Either
3391 * the lun is after the first ',' or the entire address string is the lun.
3392 * Return SCSI_LUN64_ILLEGAL if the format is incorrect. A lun64 is at most
3393 * 16 hex digits long.
3394 *
3395 * If the address string specified has incorrect syntax (busconfig one of
3396 * bogus /devices path) then scsi_addr_to_lun64 can return SCSI_LUN64_ILLEGAL.
3397 */
3398 static scsi_lun64_t
scsi_addr_to_lun64(char * addr)3399 scsi_addr_to_lun64(char *addr)
3400 {
3401 scsi_lun64_t lun64;
3402 char *s;
3403 int i;
3404
3405 if (addr) {
3406 s = strchr(addr, ','); /* "addr,lun" */
3407 if (s)
3408 s++; /* skip ',', at lun */
3409 else
3410 s = addr; /* "lun" */
3411
3412 for (lun64 = 0, i = 0; *s && (i < 16); s++, i++) {
3413 if (*s >= '0' && *s <= '9')
3414 lun64 = (lun64 << 4) + (*s - '0');
3415 else if (*s >= 'A' && *s <= 'F')
3416 lun64 = (lun64 << 4) + 10 + (*s - 'A');
3417 else if (*s >= 'a' && *s <= 'f')
3418 lun64 = (lun64 << 4) + 10 + (*s - 'a');
3419 else
3420 break;
3421 }
3422 if (*s && (*s != ',')) /* [,sfunc] is OK */
3423 lun64 = SCSI_LUN64_ILLEGAL;
3424 } else
3425 lun64 = SCSI_LUN64_ILLEGAL;
3426
3427 if (lun64 == SCSI_LUN64_ILLEGAL)
3428 SCSI_HBA_LOG((_LOG(2), NULL, NULL,
3429 "addr_to_lun64 %s lun %" PRIlun64,
3430 addr ? addr : "NULL", lun64));
3431 return (lun64);
3432 }
3433
3434 /*
3435 * Return the sfunc value from a address string: "addr,lun[,sfunc]". Either the
3436 * sfunc is after the second ',' or the entire address string is the sfunc.
3437 * Return -1 if there is only one ',' in the address string or the string is
3438 * invalid. An sfunc is at most two hex digits long.
3439 */
3440 static int
scsi_addr_to_sfunc(char * addr)3441 scsi_addr_to_sfunc(char *addr)
3442 {
3443 int sfunc;
3444 char *s;
3445 int i;
3446
3447 if (addr) {
3448 s = strchr(addr, ','); /* "addr,lun" */
3449 if (s) {
3450 s++; /* skip ',', at lun */
3451 s = strchr(s, ','); /* "lun,sfunc" */
3452 if (s == NULL)
3453 return (-1); /* no ",sfunc" */
3454 s++; /* skip ',', at sfunc */
3455 } else
3456 s = addr; /* "sfunc" */
3457
3458 for (sfunc = 0, i = 0; *s && (i < 2); s++, i++) {
3459 if (*s >= '0' && *s <= '9')
3460 sfunc = (sfunc << 4) + (*s - '0');
3461 else if (*s >= 'A' && *s <= 'F')
3462 sfunc = (sfunc << 4) + 10 + (*s - 'A');
3463 else if (*s >= 'a' && *s <= 'f')
3464 sfunc = (sfunc << 4) + 10 + (*s - 'a');
3465 else
3466 break;
3467 }
3468 if (*s)
3469 sfunc = -1; /* illegal */
3470 } else
3471 sfunc = -1;
3472 return (sfunc);
3473 }
3474
3475 /*
3476 * Convert scsi ascii string data to NULL terminated (semi) legal IEEE 1275
3477 * "compatible" (name) property form.
3478 *
3479 * For ASCII INQUIRY data, a one-way conversion algorithm is needed to take
3480 * SCSI_ASCII (20h - 7Eh) to a 1275-like compatible form. The 1275 spec allows
3481 * letters, digits, one ",", and ". _ + -", all limited by a maximum 31
3482 * character length. Since ", ." are used as separators in the compatible
3483 * string itself, they are converted to "_". All SCSI_ASCII characters that
3484 * are illegal in 1275, as well as any illegal SCSI_ASCII characters
3485 * encountered, are converted to "_". To reduce length, trailing blanks are
3486 * trimmed from SCSI_ASCII fields prior to conversion.
3487 *
3488 * Example: SCSI_ASCII "ST32550W SUN2.1G" -> "ST32550W_SUN2_1G"
3489 *
3490 * NOTE: the 1275 string form is always less than or equal to the scsi form.
3491 */
3492 static char *
string_scsi_to_1275(char * s_1275,char * s_scsi,int len)3493 string_scsi_to_1275(char *s_1275, char *s_scsi, int len)
3494 {
3495 (void) strncpy(s_1275, s_scsi, len);
3496 s_1275[len--] = '\0';
3497
3498 while (len >= 0) {
3499 if (s_1275[len] == ' ')
3500 s_1275[len--] = '\0'; /* trim trailing " " */
3501 else
3502 break;
3503 }
3504
3505 while (len >= 0) {
3506 if (((s_1275[len] >= 'a') && (s_1275[len] <= 'z')) ||
3507 ((s_1275[len] >= 'A') && (s_1275[len] <= 'Z')) ||
3508 ((s_1275[len] >= '0') && (s_1275[len] <= '9')) ||
3509 (s_1275[len] == '_') ||
3510 (s_1275[len] == '+') ||
3511 (s_1275[len] == '-'))
3512 len--; /* legal 1275 */
3513 else
3514 s_1275[len--] = '_'; /* illegal SCSI_ASCII | 1275 */
3515 }
3516
3517 return (s_1275);
3518 }
3519
3520 /*
3521 * Given the inquiry data, binding_set, and dtype_node for a scsi device,
3522 * return the nodename and compatible property for the device. The "compatible"
3523 * concept comes from IEEE-1275. The compatible information is returned is in
3524 * the correct form for direct use defining the "compatible" string array
3525 * property. Internally, "compatible" is also used to determine the nodename
3526 * to return.
3527 *
3528 * This function is provided as a separate entry point for use by drivers that
3529 * currently issue their own non-SCSA inquiry command and perform their own
3530 * node creation based their own private compiled in tables. Converting these
3531 * drivers to use this interface provides a quick easy way of obtaining
3532 * consistency as well as the flexibility associated with the 1275 techniques.
3533 *
3534 * The dtype_node is passed as a separate argument (instead of having the
3535 * implementation use inq_dtype). It indicates that information about
3536 * a secondary function embedded service should be produced.
3537 *
3538 * Callers must always use scsi_hba_nodename_compatible_free, even if
3539 * *nodenamep is null, to free the nodename and compatible information
3540 * when done.
3541 *
3542 * If a nodename can't be determined then **compatiblep will point to a
3543 * diagnostic string containing all the compatible forms.
3544 *
3545 * NOTE: some compatible strings may violate the 31 character restriction
3546 * imposed by IEEE-1275. This is not a problem because Solaris does not care
3547 * about this 31 character limit.
3548 *
3549 * Each compatible form belongs to a form-group. The form-groups currently
3550 * defined are generic ("scsiclass"), binding-set ("scsa.b"), and failover
3551 * ("scsa.f").
3552 *
3553 * The following compatible forms, in high to low precedence
3554 * order, are defined for SCSI target device nodes.
3555 *
3556 * scsiclass,DDEEFFF.vVVVVVVVV.pPPPPPPPPPPPPPPPP.rRRRR (1 *1&2)
3557 * scsiclass,DDEE.vVVVVVVVV.pPPPPPPPPPPPPPPPP.rRRRR (2 *1)
3558 * scsiclass,DDFFF.vVVVVVVVV.pPPPPPPPPPPPPPPPP.rRRRR (3 *2)
3559 * scsiclass,DD.vVVVVVVVV.pPPPPPPPPPPPPPPPP.rRRRR (4)
3560 * scsiclass,DDEEFFF.vVVVVVVVV.pPPPPPPPPPPPPPPPP (5 *1&2)
3561 * scsiclass,DDEE.vVVVVVVVV.pPPPPPPPPPPPPPPPP (6 *1)
3562 * scsiclass,DDFFF.vVVVVVVVV.pPPPPPPPPPPPPPPPP (7 *2)
3563 * scsiclass,DD.vVVVVVVVV.pPPPPPPPPPPPPPPPP (8)
3564 * scsa,DD.bBBBBBBBB (8.5 *3)
3565 * scsiclass,DDEEFFF (9 *1&2)
3566 * scsiclass,DDEE (10 *1)
3567 * scsiclass,DDFFF (11 *2)
3568 * scsiclass,DD (12)
3569 * scsa.fFFF (12.5 *4)
3570 * scsiclass (13)
3571 *
3572 * *1 only produced on a secondary function node
3573 * *2 only produced when generic form-group flags exist.
3574 * *3 only produced when binding-set form-group legacy support is needed
3575 * *4 only produced when failover form-group flags exist.
3576 *
3577 * where:
3578 *
3579 * v is the letter 'v'. Denotest the
3580 * beginning of VVVVVVVV.
3581 *
3582 * VVVVVVVV Translated scsi_vendor.
3583 *
3584 * p is the letter 'p'. Denotes the
3585 * beginning of PPPPPPPPPPPPPPPP.
3586 *
3587 * PPPPPPPPPPPPPPPP Translated scsi_product.
3588 *
3589 * r is the letter 'r'. Denotes the
3590 * beginning of RRRR.
3591 *
3592 * RRRR Translated scsi_revision.
3593 *
3594 * DD is a two digit ASCII hexadecimal
3595 * number. The value of the two digits is
3596 * based one the SCSI "Peripheral device
3597 * type" command set associated with the
3598 * node. On a primary node this is the
3599 * scsi_dtype of the primary command set,
3600 * on a secondary node this is the
3601 * scsi_dtype associated with the secondary
3602 * function embedded command set.
3603 *
3604 * EE Same encoding used for DD. This form is
3605 * only generated on secondary function
3606 * nodes. The DD secondary function is embedded
3607 * in an EE device.
3608 *
3609 * FFF Concatenation, in alphabetical order,
3610 * of the flag characters within a form-group.
3611 * For a given form-group, the following
3612 * flags are defined.
3613 *
3614 * scsiclass: (generic form-group):
3615 * R Removable_Media: Used when
3616 * inq_rmb is set.
3617 * S SAF-TE device: Used when
3618 * inquiry information indicates
3619 * SAF-TE devices.
3620 *
3621 * scsa.f: (failover form-group):
3622 * E Explicit Target_Port_Group: Used
3623 * when inq_tpgse is set and 'G' is
3624 * alse present.
3625 * G GUID: Used when a GUID can be
3626 * generated for the device.
3627 * I Implicit Target_Port_Group: Used
3628 * when inq_tpgs is set and 'G' is
3629 * also present.
3630 *
3631 * Forms using FFF are only be generated
3632 * if there are applicable flag
3633 * characters.
3634 *
3635 * b is the letter 'b'. Denotes the
3636 * beginning of BBBBBBBB.
3637 *
3638 * BBBBBBBB Binding-set. Operating System Specific:
3639 * scsi-binding-set property of HBA.
3640 */
3641 #define NCOMPAT (1 + (13 + 2) + 1)
3642 #define COMPAT_LONGEST (strlen( \
3643 "scsiclass,DDEEFFF.vVVVVVVVV.pPPPPPPPPPPPPPPPP.rRRRR" + 1))
3644
3645 /*
3646 * Private version with extra device 'identity' arguments to allow code
3647 * to determine GUID FFF support.
3648 */
3649 static void
scsi_hba_ident_nodename_compatible_get(struct scsi_inquiry * inq,uchar_t * inq80,size_t inq80len,uchar_t * inq83,size_t inq83len,char * binding_set,int dtype_node,char * compat0,char ** nodenamep,char ** drivernamep,char *** compatiblep,int * ncompatiblep)3650 scsi_hba_ident_nodename_compatible_get(struct scsi_inquiry *inq,
3651 uchar_t *inq80, size_t inq80len, uchar_t *inq83, size_t inq83len,
3652 char *binding_set, int dtype_node, char *compat0,
3653 char **nodenamep, char **drivernamep,
3654 char ***compatiblep, int *ncompatiblep)
3655 {
3656 char vid[sizeof (inq->inq_vid) + 1 ];
3657 char pid[sizeof (inq->inq_pid) + 1];
3658 char rev[sizeof (inq->inq_revision) + 1];
3659 char gf[sizeof ("RS\0")];
3660 char ff[sizeof ("EGI\0")];
3661 int dtype_device;
3662 int ncompat; /* number of compatible */
3663 char **compatp; /* compatible ptrs */
3664 int i;
3665 char *nname; /* nodename */
3666 char *dname; /* driver name */
3667 char **csp;
3668 char *p;
3669 int tlen;
3670 int len;
3671 major_t major;
3672 ddi_devid_t devid;
3673 char *guid;
3674 uchar_t *iqd = (uchar_t *)inq;
3675
3676 /*
3677 * Nodename_aliases: This table was originally designed to be
3678 * implemented via a new nodename_aliases file - a peer to the
3679 * driver_aliases that selects a nodename based on compatible
3680 * forms in much the same say driver_aliases is used to select
3681 * driver bindings from compatible forms. Each compatible form
3682 * is an 'alias'. Until a more general need for a
3683 * nodename_aliases file exists, which may never occur, the
3684 * scsi mappings are described here via a compiled in table.
3685 *
3686 * This table contains nodename mappings for self-identifying
3687 * scsi devices enumerated by the Solaris kernel. For a given
3688 * device, the highest precedence "compatible" form with a
3689 * mapping is used to select the nodename for the device. This
3690 * will typically be a generic nodename, however in some legacy
3691 * compatibility cases a driver nodename mapping may be selected.
3692 *
3693 * Because of possible breakage associated with switching SCSI
3694 * target devices from driver nodenames to generic nodenames,
3695 * we are currently unable to support generic nodenames for all
3696 * SCSI devices (binding-sets). Although /devices paths are
3697 * defined as unstable, avoiding possible breakage is
3698 * important. Some of the newer SCSI transports (USB) already
3699 * use generic nodenames. All new SCSI transports and target
3700 * devices should use generic nodenames. At times this decision
3701 * may be architecture dependent (sparc .vs. intel) based on when
3702 * a transport was supported on a particular architecture.
3703 *
3704 * We provide a base set of generic nodename mappings based on
3705 * scsiclass dtype and higher-precedence driver nodename
3706 * mappings based on scsa "binding-set" to cover legacy
3707 * issues. The binding-set is typically associated with
3708 * "scsi-binding-set" property value of the HBA. The legacy
3709 * mappings are provided independent of whether the driver they
3710 * refer to is installed. This allows a correctly named node
3711 * be created at discovery time, and binding to occur when/if
3712 * an add_drv of the legacy driver occurs.
3713 *
3714 * We also have mappings for legacy SUN hardware that
3715 * misidentifies itself (enclosure services which identify
3716 * themselves as processors). All future hardware should use
3717 * the correct dtype.
3718 *
3719 * As SCSI HBAs are modified to use the SCSA interfaces for
3720 * self-identifying SCSI target devices (PSARC/2004/116) the
3721 * nodename_aliases table (PSARC/2004/420) should be augmented
3722 * with legacy mappings in order to maintain compatibility with
3723 * existing /devices paths, especially for devices that house
3724 * an OS. Failure to do this may cause upgrade problems.
3725 * Additions for new target devices or transports should not
3726 * add scsa binding-set compatible mappings.
3727 */
3728 static struct nodename_aliases {
3729 char *na_nodename; /* nodename */
3730 char *na_alias; /* compatible form match */
3731 } na[] = {
3732 /* # mapping to generic nodenames based on scsi dtype */
3733 {"disk", "scsiclass,00"},
3734 {"tape", "scsiclass,01"},
3735 {"printer", "scsiclass,02"},
3736 {"processor", "scsiclass,03"},
3737 {"worm", "scsiclass,04"},
3738 {"cdrom", "scsiclass,05"},
3739 {"scanner", "scsiclass,06"},
3740 {"optical-disk", "scsiclass,07"},
3741 {"medium-changer", "scsiclass,08"},
3742 {"obsolete", "scsiclass,09"},
3743 {"prepress-a", "scsiclass,0a"},
3744 {"prepress-b", "scsiclass,0b"},
3745 {"array-controller", "scsiclass,0c"},
3746 {"enclosure", "scsiclass,0d"},
3747 {"disk", "scsiclass,0e"},
3748 {"card-reader", "scsiclass,0f"},
3749 {"bridge", "scsiclass,10"},
3750 {"object-store", "scsiclass,11"},
3751 {"reserved", "scsiclass,12"},
3752 {"reserved", "scsiclass,13"},
3753 {"reserved", "scsiclass,14"},
3754 {"reserved", "scsiclass,15"},
3755 {"reserved", "scsiclass,16"},
3756 {"reserved", "scsiclass,17"},
3757 {"reserved", "scsiclass,18"},
3758 {"reserved", "scsiclass,19"},
3759 {"reserved", "scsiclass,1a"},
3760 {"reserved", "scsiclass,1b"},
3761 {"reserved", "scsiclass,1c"},
3762 {"reserved", "scsiclass,1d"},
3763 {"well-known-lun", "scsiclass,1e"},
3764 {"unknown", "scsiclass,1f"},
3765
3766 #ifdef sparc
3767 /* # legacy mapping to driver nodenames for fcp binding-set */
3768 {"ssd", "scsa,00.bfcp"},
3769 {"st", "scsa,01.bfcp"},
3770 {"sgen", "scsa,08.bfcp"},
3771 {"ses", "scsa,0d.bfcp"},
3772
3773 /* # legacy mapping to driver nodenames for vhci binding-set */
3774 {"ssd", "scsa,00.bvhci"},
3775 {"st", "scsa,01.bvhci"},
3776 {"sgen", "scsa,08.bvhci"},
3777 {"ses", "scsa,0d.bvhci"},
3778 #else /* sparc */
3779 /* # for x86 fcp and vhci use generic nodenames */
3780 #endif /* sparc */
3781
3782 /* # legacy mapping to driver nodenames for spi binding-set */
3783 {"sd", "scsa,00.bspi"},
3784 {"sd", "scsa,05.bspi"},
3785 {"sd", "scsa,07.bspi"},
3786 {"st", "scsa,01.bspi"},
3787 {"ses", "scsa,0d.bspi"},
3788
3789 /* # SUN misidentified spi hardware */
3790 {"ses", "scsiclass,03.vSUN.pD2"},
3791 {"ses", "scsiclass,03.vSYMBIOS.pD1000"},
3792
3793 /* # legacy mapping to driver nodenames for atapi binding-set */
3794 {"sd", "scsa,00.batapi"},
3795 {"sd", "scsa,05.batapi"},
3796 {"sd", "scsa,07.batapi"},
3797 {"st", "scsa,01.batapi"},
3798 {"unknown", "scsa,0d.batapi"},
3799
3800 /* # legacy mapping to generic nodenames for usb binding-set */
3801 {"disk", "scsa,05.busb"},
3802 {"disk", "scsa,07.busb"},
3803 {"changer", "scsa,08.busb"},
3804 {"comm", "scsa,09.busb"},
3805 {"array_ctlr", "scsa,0c.busb"},
3806 {"esi", "scsa,0d.busb"},
3807
3808 /*
3809 * mapping nodenames for mpt based on scsi dtype
3810 * for being compatible with the original node names
3811 * under mpt controller
3812 */
3813 {"sd", "scsa,00.bmpt"},
3814 {"sd", "scsa,05.bmpt"},
3815 {"sd", "scsa,07.bmpt"},
3816 {"st", "scsa,01.bmpt"},
3817 {"ses", "scsa,0d.bmpt"},
3818 {"sgen", "scsa,08.bmpt"},
3819 {NULL, NULL}
3820 };
3821 struct nodename_aliases *nap;
3822
3823 /* NOTE: drivernamep can be NULL */
3824 ASSERT(nodenamep && compatiblep && ncompatiblep &&
3825 (binding_set == NULL || (strlen(binding_set) <= 8)));
3826 if ((nodenamep == NULL) || (compatiblep == NULL) ||
3827 (ncompatiblep == NULL))
3828 return;
3829
3830 /*
3831 * In order to reduce runtime we allocate one block of memory that
3832 * contains both the NULL terminated array of pointers to compatible
3833 * forms and the individual compatible strings. This block is
3834 * somewhat larger than needed, but is short lived - it only exists
3835 * until the caller can transfer the information into the "compatible"
3836 * string array property and call scsi_hba_nodename_compatible_free.
3837 */
3838 tlen = NCOMPAT * COMPAT_LONGEST;
3839 compatp = kmem_alloc((NCOMPAT * sizeof (char *)) + tlen, KM_SLEEP);
3840
3841 /* convert inquiry data from SCSI ASCII to 1275 string */
3842 (void) string_scsi_to_1275(vid, inq->inq_vid,
3843 sizeof (inq->inq_vid));
3844 (void) string_scsi_to_1275(pid, inq->inq_pid,
3845 sizeof (inq->inq_pid));
3846 (void) string_scsi_to_1275(rev, inq->inq_revision,
3847 sizeof (inq->inq_revision));
3848 ASSERT((strlen(vid) <= sizeof (inq->inq_vid)) &&
3849 (strlen(pid) <= sizeof (inq->inq_pid)) &&
3850 (strlen(rev) <= sizeof (inq->inq_revision)));
3851
3852 /*
3853 * Form flags in ***ALPHABETICAL*** order within form-group:
3854 *
3855 * NOTE: When adding a new flag to an existing form-group, careful
3856 * consideration must be given to not breaking existing bindings
3857 * based on that form-group.
3858 */
3859
3860 /*
3861 * generic form-group flags
3862 * R removable:
3863 * Set when inq_rmb is set and for well known scsi dtypes. For a
3864 * bus where the entire device is removable (like USB), we expect
3865 * the HBA to intercept the inquiry data and set inq_rmb.
3866 * Since OBP does not distinguish removable media in its generic
3867 * name selection we avoid setting the 'R' flag if the root is not
3868 * yet mounted.
3869 * S SAF-TE device
3870 * Set when the device type is SAT-TE.
3871 */
3872 i = 0;
3873 dtype_device = inq->inq_dtype & DTYPE_MASK;
3874 if (modrootloaded && (inq->inq_rmb ||
3875 (dtype_device == DTYPE_WORM) ||
3876 (dtype_device == DTYPE_RODIRECT) ||
3877 (dtype_device == DTYPE_OPTICAL)))
3878 gf[i++] = 'R'; /* removable */
3879 gf[i] = '\0';
3880
3881 if (modrootloaded &&
3882 (dtype_device == DTYPE_PROCESSOR) &&
3883 (strncmp((char *)&iqd[44], "SAF-TE", 4) == 0))
3884 gf[i++] = 'S';
3885 gf[i] = '\0';
3886
3887 /*
3888 * failover form-group flags
3889 * E Explicit Target_Port_Group_Supported:
3890 * Set for a device that has a GUID if inq_tpgse also set.
3891 * G GUID:
3892 * Set when we have identity information, can determine a devid
3893 * from the identity information, and can generate a guid from
3894 * that devid.
3895 * I Implicit Target_Port_Group_Supported:
3896 * Set for a device that has a GUID if inq_tpgs also set.
3897 */
3898 i = 0;
3899 if ((inq80 || inq83) &&
3900 (ddi_devid_scsi_encode(DEVID_SCSI_ENCODE_VERSION_LATEST, NULL,
3901 (uchar_t *)inq, sizeof (*inq), inq80, inq80len, inq83, inq83len,
3902 &devid) == DDI_SUCCESS)) {
3903 guid = ddi_devid_to_guid(devid);
3904 ddi_devid_free(devid);
3905 } else
3906 guid = NULL;
3907 if (guid && (inq->inq_tpgs & TPGS_FAILOVER_EXPLICIT))
3908 ff[i++] = 'E'; /* EXPLICIT TPGS */
3909 if (guid)
3910 ff[i++] = 'G'; /* GUID */
3911 if (guid && (inq->inq_tpgs & TPGS_FAILOVER_IMPLICIT))
3912 ff[i++] = 'I'; /* IMPLICIT TPGS */
3913 ff[i] = '\0';
3914 if (guid)
3915 ddi_devid_free_guid(guid);
3916
3917 /*
3918 * Construct all applicable compatible forms. See comment at the
3919 * head of the function for a description of the compatible forms.
3920 */
3921 csp = compatp;
3922 p = (char *)(compatp + NCOMPAT);
3923
3924 /* ( 0) driver (optional, not documented in scsi(5)) */
3925 if (compat0) {
3926 *csp++ = p;
3927 (void) snprintf(p, tlen, "%s", compat0);
3928 len = strlen(p) + 1;
3929 p += len;
3930 tlen -= len;
3931 }
3932
3933 /* ( 1) scsiclass,DDEEFFF.vV.pP.rR */
3934 if ((dtype_device != dtype_node) && *gf && *vid && *pid && *rev) {
3935 *csp++ = p;
3936 (void) snprintf(p, tlen, "scsiclass,%02x%02x%s.v%s.p%s.r%s",
3937 dtype_node, dtype_device, gf, vid, pid, rev);
3938 len = strlen(p) + 1;
3939 p += len;
3940 tlen -= len;
3941 }
3942
3943 /* ( 2) scsiclass,DDEE.vV.pP.rR */
3944 if ((dtype_device != dtype_node) && *vid && *pid && *rev) {
3945 *csp++ = p;
3946 (void) snprintf(p, tlen, "scsiclass,%02x%02x.v%s.p%s.r%s",
3947 dtype_node, dtype_device, vid, pid, rev);
3948 len = strlen(p) + 1;
3949 p += len;
3950 tlen -= len;
3951 }
3952
3953 /* ( 3) scsiclass,DDFFF.vV.pP.rR */
3954 if (*gf && *vid && *pid && *rev) {
3955 *csp++ = p;
3956 (void) snprintf(p, tlen, "scsiclass,%02x%s.v%s.p%s.r%s",
3957 dtype_node, gf, vid, pid, rev);
3958 len = strlen(p) + 1;
3959 p += len;
3960 tlen -= len;
3961 }
3962
3963 /* ( 4) scsiclass,DD.vV.pP.rR */
3964 if (*vid && *pid && *rev) {
3965 *csp++ = p;
3966 (void) snprintf(p, tlen, "scsiclass,%02x.v%s.p%s.r%s",
3967 dtype_node, vid, pid, rev);
3968 len = strlen(p) + 1;
3969 p += len;
3970 tlen -= len;
3971 }
3972
3973 /* ( 5) scsiclass,DDEEFFF.vV.pP */
3974 if ((dtype_device != dtype_node) && *gf && *vid && *pid) {
3975 *csp++ = p;
3976 (void) snprintf(p, tlen, "scsiclass,%02x%02x%s.v%s.p%s",
3977 dtype_node, dtype_device, gf, vid, pid);
3978 len = strlen(p) + 1;
3979 p += len;
3980 tlen -= len;
3981 }
3982
3983 /* ( 6) scsiclass,DDEE.vV.pP */
3984 if ((dtype_device != dtype_node) && *vid && *pid) {
3985 *csp++ = p;
3986 (void) snprintf(p, tlen, "scsiclass,%02x%02x.v%s.p%s",
3987 dtype_node, dtype_device, vid, pid);
3988 len = strlen(p) + 1;
3989 p += len;
3990 tlen -= len;
3991 }
3992
3993 /* ( 7) scsiclass,DDFFF.vV.pP */
3994 if (*gf && *vid && *pid) {
3995 *csp++ = p;
3996 (void) snprintf(p, tlen, "scsiclass,%02x%s.v%s.p%s",
3997 dtype_node, gf, vid, pid);
3998 len = strlen(p) + 1;
3999 p += len;
4000 tlen -= len;
4001 }
4002
4003 /* ( 8) scsiclass,DD.vV.pP */
4004 if (*vid && *pid) {
4005 *csp++ = p;
4006 (void) snprintf(p, tlen, "scsiclass,%02x.v%s.p%s",
4007 dtype_node, vid, pid);
4008 len = strlen(p) + 1;
4009 p += len;
4010 tlen -= len;
4011 }
4012
4013 /* (8.5) scsa,DD.bB (not documented in scsi(5)) */
4014 if (binding_set) {
4015 *csp++ = p;
4016 (void) snprintf(p, tlen, "scsa,%02x.b%s",
4017 dtype_node, binding_set);
4018 len = strlen(p) + 1;
4019 p += len;
4020 tlen -= len;
4021 }
4022
4023 /* ( 9) scsiclass,DDEEFFF */
4024 if ((dtype_device != dtype_node) && *gf) {
4025 *csp++ = p;
4026 (void) snprintf(p, tlen, "scsiclass,%02x%02x%s",
4027 dtype_node, dtype_device, gf);
4028 len = strlen(p) + 1;
4029 p += len;
4030 tlen -= len;
4031 }
4032
4033 /* (10) scsiclass,DDEE */
4034 if (dtype_device != dtype_node) {
4035 *csp++ = p;
4036 (void) snprintf(p, tlen, "scsiclass,%02x%02x",
4037 dtype_node, dtype_device);
4038 len = strlen(p) + 1;
4039 p += len;
4040 tlen -= len;
4041 }
4042
4043 /* (11) scsiclass,DDFFF */
4044 if (*gf) {
4045 *csp++ = p;
4046 (void) snprintf(p, tlen, "scsiclass,%02x%s",
4047 dtype_node, gf);
4048 len = strlen(p) + 1;
4049 p += len;
4050 tlen -= len;
4051 }
4052
4053 /* (12) scsiclass,DD */
4054 *csp++ = p;
4055 (void) snprintf(p, tlen, "scsiclass,%02x", dtype_node);
4056 len = strlen(p) + 1;
4057 p += len;
4058 tlen -= len;
4059
4060 /* (12.5) scsa.fFFF */
4061 if (*ff) {
4062 *csp++ = p;
4063 (void) snprintf(p, tlen, "scsa.f%s", ff);
4064 len = strlen(p) + 1;
4065 p += len;
4066 tlen -= len;
4067 }
4068
4069 /* (13) scsiclass */
4070 *csp++ = p;
4071 (void) snprintf(p, tlen, "scsiclass");
4072 len = strlen(p) + 1;
4073 p += len;
4074 tlen -= len;
4075 ASSERT(tlen >= 0);
4076
4077 *csp = NULL; /* NULL terminate array of pointers */
4078 ncompat = csp - compatp;
4079
4080 /*
4081 * When determining a nodename, a nodename_aliases specified
4082 * mapping has precedence over using a driver_aliases specified
4083 * driver binding as a nodename.
4084 *
4085 * See if any of the compatible forms have a nodename_aliases
4086 * specified nodename. These mappings are described by
4087 * nodename_aliases entries like:
4088 *
4089 * disk "scsiclass,00"
4090 * enclosure "scsiclass,03.vSYMBIOS.pD1000"
4091 * ssd "scsa,00.bfcp"
4092 *
4093 * All nodename_aliases mappings should idealy be to generic
4094 * names, however a higher precedence legacy mapping to a
4095 * driver name may exist. The highest precedence mapping
4096 * provides the nodename, so legacy driver nodename mappings
4097 * (if they exist) take precedence over generic nodename
4098 * mappings.
4099 */
4100 for (nname = NULL, csp = compatp; (nname == NULL) && *csp; csp++) {
4101 for (nap = na; nap->na_nodename; nap++) {
4102 if (strcmp(*csp, nap->na_alias) == 0) {
4103 nname = nap->na_nodename;
4104 break;
4105 }
4106 }
4107 }
4108
4109 /*
4110 * Determine the driver name based on compatible (which may
4111 * have the passed in compat0 as the first item). The driver_aliases
4112 * file has entries like
4113 *
4114 * sd "scsiclass,00"
4115 *
4116 * that map compatible forms to specific drivers. These entries are
4117 * established by add_drv/update_drv. We use the most specific
4118 * driver binding as the nodename. This matches the eventual
4119 * ddi_driver_compatible_major() binding that will be
4120 * established by bind_node()
4121 */
4122 for (dname = NULL, csp = compatp; *csp; csp++) {
4123 major = ddi_name_to_major(*csp);
4124 if ((major == DDI_MAJOR_T_NONE) ||
4125 (devnamesp[major].dn_flags & DN_DRIVER_REMOVED))
4126 continue;
4127 if (dname = ddi_major_to_name(major))
4128 break;
4129 }
4130
4131 /*
4132 * If no nodename_aliases mapping exists then use the
4133 * driver_aliases specified driver binding as a nodename.
4134 */
4135 if (nname == NULL)
4136 nname = dname;
4137
4138 /* return results */
4139 if (nname) {
4140 *nodenamep = kmem_alloc(strlen(nname) + 1, KM_SLEEP);
4141 (void) strcpy(*nodenamep, nname);
4142 } else {
4143 *nodenamep = NULL;
4144
4145 /*
4146 * If no nodename could be determined return a special
4147 * 'compatible' to be used for a diagnostic message. This
4148 * compatible contains all compatible forms concatenated
4149 * into a single string pointed to by the first element.
4150 */
4151 for (csp = compatp; *(csp + 1); csp++)
4152 *((*csp) + strlen(*csp)) = ' ';
4153 *(compatp + 1) = NULL;
4154 ncompat = 1;
4155
4156 }
4157 if (drivernamep) {
4158 if (dname) {
4159 *drivernamep = kmem_alloc(strlen(dname) + 1, KM_SLEEP);
4160 (void) strcpy(*drivernamep, dname);
4161 } else
4162 *drivernamep = NULL;
4163 }
4164 *compatiblep = compatp;
4165 *ncompatiblep = ncompat;
4166 }
4167
4168 /*
4169 * Free allocations associated with scsi_hba_ident_nodename_compatible_get.
4170 */
4171 static void
scsi_hba_ident_nodename_compatible_free(char * nodename,char * drivername,char ** compatible)4172 scsi_hba_ident_nodename_compatible_free(char *nodename, char *drivername,
4173 char **compatible)
4174 {
4175 if (nodename)
4176 kmem_free(nodename, strlen(nodename) + 1);
4177 if (drivername)
4178 kmem_free(drivername, strlen(drivername) + 1);
4179 if (compatible)
4180 kmem_free(compatible, (NCOMPAT * sizeof (char *)) +
4181 (NCOMPAT * COMPAT_LONGEST));
4182 }
4183
4184 void
scsi_hba_nodename_compatible_get(struct scsi_inquiry * inq,char * binding_set,int dtype_node,char * compat0,char ** nodenamep,char *** compatiblep,int * ncompatiblep)4185 scsi_hba_nodename_compatible_get(struct scsi_inquiry *inq,
4186 char *binding_set, int dtype_node, char *compat0,
4187 char **nodenamep, char ***compatiblep, int *ncompatiblep)
4188 {
4189 scsi_hba_ident_nodename_compatible_get(inq,
4190 NULL, 0, NULL, 0, binding_set, dtype_node, compat0, nodenamep,
4191 NULL, compatiblep, ncompatiblep);
4192 }
4193
4194 void
scsi_hba_nodename_compatible_free(char * nodename,char ** compatible)4195 scsi_hba_nodename_compatible_free(char *nodename, char **compatible)
4196 {
4197 scsi_hba_ident_nodename_compatible_free(nodename, NULL, compatible);
4198 }
4199
4200 /* return the unit_address associated with a scsi_device */
4201 char *
scsi_device_unit_address(struct scsi_device * sd)4202 scsi_device_unit_address(struct scsi_device *sd)
4203 {
4204 mdi_pathinfo_t *pip;
4205
4206 ASSERT(sd && sd->sd_dev);
4207 if ((sd == NULL) || (sd->sd_dev == NULL))
4208 return (NULL);
4209
4210 pip = (mdi_pathinfo_t *)sd->sd_pathinfo;
4211 if (pip)
4212 return (mdi_pi_get_addr(pip));
4213 else
4214 return (ddi_get_name_addr(sd->sd_dev));
4215 }
4216
4217 /* scsi_device property interfaces */
4218 #define _TYPE_DEFINED(flags) \
4219 (((flags & SCSI_DEVICE_PROP_TYPE_MSK) == SCSI_DEVICE_PROP_PATH) || \
4220 ((flags & SCSI_DEVICE_PROP_TYPE_MSK) == SCSI_DEVICE_PROP_DEVICE))
4221
4222 #define _DEVICE_PIP(sd, flags) \
4223 ((((flags & SCSI_DEVICE_PROP_TYPE_MSK) == SCSI_DEVICE_PROP_PATH) && \
4224 sd->sd_pathinfo) ? (mdi_pathinfo_t *)sd->sd_pathinfo : NULL)
4225
4226 int
scsi_device_prop_get_int(struct scsi_device * sd,uint_t flags,char * name,int defval)4227 scsi_device_prop_get_int(struct scsi_device *sd, uint_t flags,
4228 char *name, int defval)
4229 {
4230 mdi_pathinfo_t *pip;
4231 int v = defval;
4232 int data;
4233 int rv;
4234
4235 ASSERT(sd && name && sd->sd_dev && _TYPE_DEFINED(flags));
4236 if ((sd == NULL) || (name == NULL) || (sd->sd_dev == NULL) ||
4237 !_TYPE_DEFINED(flags))
4238 return (v);
4239
4240 pip = _DEVICE_PIP(sd, flags);
4241 if (pip) {
4242 rv = mdi_prop_lookup_int(pip, name, &data);
4243 if (rv == DDI_PROP_SUCCESS)
4244 v = data;
4245 } else
4246 v = ddi_prop_get_int(DDI_DEV_T_ANY, sd->sd_dev,
4247 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, name, v);
4248 return (v);
4249 }
4250
4251
4252 int64_t
scsi_device_prop_get_int64(struct scsi_device * sd,uint_t flags,char * name,int64_t defval)4253 scsi_device_prop_get_int64(struct scsi_device *sd, uint_t flags,
4254 char *name, int64_t defval)
4255 {
4256 mdi_pathinfo_t *pip;
4257 int64_t v = defval;
4258 int64_t data;
4259 int rv;
4260
4261 ASSERT(sd && name && sd->sd_dev && _TYPE_DEFINED(flags));
4262 if ((sd == NULL) || (name == NULL) || (sd->sd_dev == NULL) ||
4263 !_TYPE_DEFINED(flags))
4264 return (v);
4265
4266 pip = _DEVICE_PIP(sd, flags);
4267 if (pip) {
4268 rv = mdi_prop_lookup_int64(pip, name, &data);
4269 if (rv == DDI_PROP_SUCCESS)
4270 v = data;
4271 } else
4272 v = ddi_prop_get_int64(DDI_DEV_T_ANY, sd->sd_dev,
4273 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, name, v);
4274 return (v);
4275 }
4276
4277 int
scsi_device_prop_lookup_byte_array(struct scsi_device * sd,uint_t flags,char * name,uchar_t ** data,uint_t * nelements)4278 scsi_device_prop_lookup_byte_array(struct scsi_device *sd, uint_t flags,
4279 char *name, uchar_t **data, uint_t *nelements)
4280 {
4281 mdi_pathinfo_t *pip;
4282 int rv;
4283
4284 ASSERT(sd && name && sd->sd_dev && _TYPE_DEFINED(flags));
4285 if ((sd == NULL) || (name == NULL) || (sd->sd_dev == NULL) ||
4286 !_TYPE_DEFINED(flags))
4287 return (DDI_PROP_INVAL_ARG);
4288
4289 pip = _DEVICE_PIP(sd, flags);
4290 if (pip)
4291 rv = mdi_prop_lookup_byte_array(pip, name, data, nelements);
4292 else
4293 rv = ddi_prop_lookup_byte_array(DDI_DEV_T_ANY, sd->sd_dev,
4294 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
4295 name, data, nelements);
4296 return (rv);
4297 }
4298
4299 int
scsi_device_prop_lookup_int_array(struct scsi_device * sd,uint_t flags,char * name,int ** data,uint_t * nelements)4300 scsi_device_prop_lookup_int_array(struct scsi_device *sd, uint_t flags,
4301 char *name, int **data, uint_t *nelements)
4302 {
4303 mdi_pathinfo_t *pip;
4304 int rv;
4305
4306 ASSERT(sd && name && sd->sd_dev && _TYPE_DEFINED(flags));
4307 if ((sd == NULL) || (name == NULL) || (sd->sd_dev == NULL) ||
4308 !_TYPE_DEFINED(flags))
4309 return (DDI_PROP_INVAL_ARG);
4310
4311 pip = _DEVICE_PIP(sd, flags);
4312 if (pip)
4313 rv = mdi_prop_lookup_int_array(pip, name, data, nelements);
4314 else
4315 rv = ddi_prop_lookup_int_array(DDI_DEV_T_ANY, sd->sd_dev,
4316 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
4317 name, data, nelements);
4318 return (rv);
4319 }
4320
4321
4322 int
scsi_device_prop_lookup_string(struct scsi_device * sd,uint_t flags,char * name,char ** data)4323 scsi_device_prop_lookup_string(struct scsi_device *sd, uint_t flags,
4324 char *name, char **data)
4325 {
4326 mdi_pathinfo_t *pip;
4327 int rv;
4328
4329 ASSERT(sd && name && sd->sd_dev && _TYPE_DEFINED(flags));
4330 if ((sd == NULL) || (name == NULL) || (sd->sd_dev == NULL) ||
4331 !_TYPE_DEFINED(flags))
4332 return (DDI_PROP_INVAL_ARG);
4333
4334 pip = _DEVICE_PIP(sd, flags);
4335 if (pip)
4336 rv = mdi_prop_lookup_string(pip, name, data);
4337 else
4338 rv = ddi_prop_lookup_string(DDI_DEV_T_ANY, sd->sd_dev,
4339 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
4340 name, data);
4341 return (rv);
4342 }
4343
4344 int
scsi_device_prop_lookup_string_array(struct scsi_device * sd,uint_t flags,char * name,char *** data,uint_t * nelements)4345 scsi_device_prop_lookup_string_array(struct scsi_device *sd, uint_t flags,
4346 char *name, char ***data, uint_t *nelements)
4347 {
4348 mdi_pathinfo_t *pip;
4349 int rv;
4350
4351 ASSERT(sd && name && sd->sd_dev && _TYPE_DEFINED(flags));
4352 if ((sd == NULL) || (name == NULL) || (sd->sd_dev == NULL) ||
4353 !_TYPE_DEFINED(flags))
4354 return (DDI_PROP_INVAL_ARG);
4355
4356 pip = _DEVICE_PIP(sd, flags);
4357 if (pip)
4358 rv = mdi_prop_lookup_string_array(pip, name, data, nelements);
4359 else
4360 rv = ddi_prop_lookup_string_array(DDI_DEV_T_ANY, sd->sd_dev,
4361 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
4362 name, data, nelements);
4363 return (rv);
4364 }
4365
4366 int
scsi_device_prop_update_byte_array(struct scsi_device * sd,uint_t flags,char * name,uchar_t * data,uint_t nelements)4367 scsi_device_prop_update_byte_array(struct scsi_device *sd, uint_t flags,
4368 char *name, uchar_t *data, uint_t nelements)
4369 {
4370 mdi_pathinfo_t *pip;
4371 int rv;
4372
4373 ASSERT(sd && name && sd->sd_dev && _TYPE_DEFINED(flags));
4374 if ((sd == NULL) || (name == NULL) || (sd->sd_dev == NULL) ||
4375 !_TYPE_DEFINED(flags))
4376 return (DDI_PROP_INVAL_ARG);
4377
4378 pip = _DEVICE_PIP(sd, flags);
4379 if (pip)
4380 rv = mdi_prop_update_byte_array(pip, name, data, nelements);
4381 else
4382 rv = ndi_prop_update_byte_array(DDI_DEV_T_NONE, sd->sd_dev,
4383 name, data, nelements);
4384 return (rv);
4385 }
4386
4387 int
scsi_device_prop_update_int(struct scsi_device * sd,uint_t flags,char * name,int data)4388 scsi_device_prop_update_int(struct scsi_device *sd, uint_t flags,
4389 char *name, int data)
4390 {
4391 mdi_pathinfo_t *pip;
4392 int rv;
4393
4394 ASSERT(sd && name && sd->sd_dev && _TYPE_DEFINED(flags));
4395 if ((sd == NULL) || (name == NULL) || (sd->sd_dev == NULL) ||
4396 !_TYPE_DEFINED(flags))
4397 return (DDI_PROP_INVAL_ARG);
4398
4399 pip = _DEVICE_PIP(sd, flags);
4400 if (pip)
4401 rv = mdi_prop_update_int(pip, name, data);
4402 else
4403 rv = ndi_prop_update_int(DDI_DEV_T_NONE, sd->sd_dev,
4404 name, data);
4405 return (rv);
4406 }
4407
4408 int
scsi_device_prop_update_int64(struct scsi_device * sd,uint_t flags,char * name,int64_t data)4409 scsi_device_prop_update_int64(struct scsi_device *sd, uint_t flags,
4410 char *name, int64_t data)
4411 {
4412 mdi_pathinfo_t *pip;
4413 int rv;
4414
4415 ASSERT(sd && name && sd->sd_dev && _TYPE_DEFINED(flags));
4416 if ((sd == NULL) || (name == NULL) || (sd->sd_dev == NULL) ||
4417 !_TYPE_DEFINED(flags))
4418 return (DDI_PROP_INVAL_ARG);
4419
4420 pip = _DEVICE_PIP(sd, flags);
4421 if (pip)
4422 rv = mdi_prop_update_int64(pip, name, data);
4423 else
4424 rv = ndi_prop_update_int64(DDI_DEV_T_NONE, sd->sd_dev,
4425 name, data);
4426 return (rv);
4427 }
4428
4429 int
scsi_device_prop_update_int_array(struct scsi_device * sd,uint_t flags,char * name,int * data,uint_t nelements)4430 scsi_device_prop_update_int_array(struct scsi_device *sd, uint_t flags,
4431 char *name, int *data, uint_t nelements)
4432 {
4433 mdi_pathinfo_t *pip;
4434 int rv;
4435
4436 ASSERT(sd && name && sd->sd_dev && _TYPE_DEFINED(flags));
4437 if ((sd == NULL) || (name == NULL) || (sd->sd_dev == NULL) ||
4438 !_TYPE_DEFINED(flags))
4439 return (DDI_PROP_INVAL_ARG);
4440
4441 pip = _DEVICE_PIP(sd, flags);
4442 if (pip)
4443 rv = mdi_prop_update_int_array(pip, name, data, nelements);
4444 else
4445 rv = ndi_prop_update_int_array(DDI_DEV_T_NONE, sd->sd_dev,
4446 name, data, nelements);
4447 return (rv);
4448 }
4449
4450 int
scsi_device_prop_update_string(struct scsi_device * sd,uint_t flags,char * name,char * data)4451 scsi_device_prop_update_string(struct scsi_device *sd, uint_t flags,
4452 char *name, char *data)
4453 {
4454 mdi_pathinfo_t *pip;
4455 int rv;
4456
4457 ASSERT(sd && name && sd->sd_dev && _TYPE_DEFINED(flags));
4458 if ((sd == NULL) || (name == NULL) || (sd->sd_dev == NULL) ||
4459 !_TYPE_DEFINED(flags))
4460 return (DDI_PROP_INVAL_ARG);
4461
4462 pip = _DEVICE_PIP(sd, flags);
4463 if (pip)
4464 rv = mdi_prop_update_string(pip, name, data);
4465 else
4466 rv = ndi_prop_update_string(DDI_DEV_T_NONE, sd->sd_dev,
4467 name, data);
4468 return (rv);
4469 }
4470
4471 int
scsi_device_prop_update_string_array(struct scsi_device * sd,uint_t flags,char * name,char ** data,uint_t nelements)4472 scsi_device_prop_update_string_array(struct scsi_device *sd, uint_t flags,
4473 char *name, char **data, uint_t nelements)
4474 {
4475 mdi_pathinfo_t *pip;
4476 int rv;
4477
4478 ASSERT(sd && name && sd->sd_dev && _TYPE_DEFINED(flags));
4479 if ((sd == NULL) || (name == NULL) || (sd->sd_dev == NULL) ||
4480 !_TYPE_DEFINED(flags))
4481 return (DDI_PROP_INVAL_ARG);
4482
4483 pip = _DEVICE_PIP(sd, flags);
4484 if (pip)
4485 rv = mdi_prop_update_string_array(pip, name, data, nelements);
4486 else
4487 rv = ndi_prop_update_string_array(DDI_DEV_T_NONE, sd->sd_dev,
4488 name, data, nelements);
4489 return (rv);
4490 }
4491
4492 int
scsi_device_prop_remove(struct scsi_device * sd,uint_t flags,char * name)4493 scsi_device_prop_remove(struct scsi_device *sd, uint_t flags, char *name)
4494 {
4495 mdi_pathinfo_t *pip;
4496 int rv;
4497
4498 ASSERT(sd && name && sd->sd_dev && _TYPE_DEFINED(flags));
4499 if ((sd == NULL) || (name == NULL) || (sd->sd_dev == NULL) ||
4500 !_TYPE_DEFINED(flags))
4501 return (DDI_PROP_INVAL_ARG);
4502
4503 pip = _DEVICE_PIP(sd, flags);
4504 if (pip)
4505 rv = mdi_prop_remove(pip, name);
4506 else
4507 rv = ndi_prop_remove(DDI_DEV_T_NONE, sd->sd_dev, name);
4508 return (rv);
4509 }
4510
4511 void
scsi_device_prop_free(struct scsi_device * sd,uint_t flags,void * data)4512 scsi_device_prop_free(struct scsi_device *sd, uint_t flags, void *data)
4513 {
4514 mdi_pathinfo_t *pip;
4515
4516 ASSERT(sd && data && sd->sd_dev && _TYPE_DEFINED(flags));
4517 if ((sd == NULL) || (data == NULL) || (sd->sd_dev == NULL) ||
4518 !_TYPE_DEFINED(flags))
4519 return;
4520
4521 pip = _DEVICE_PIP(sd, flags);
4522 if (pip)
4523 (void) mdi_prop_free(data);
4524 else
4525 ddi_prop_free(data);
4526 }
4527
4528 /* SMP device property interfaces */
4529 int
smp_device_prop_get_int(struct smp_device * smp_sd,char * name,int defval)4530 smp_device_prop_get_int(struct smp_device *smp_sd, char *name, int defval)
4531 {
4532 int v = defval;
4533
4534 ASSERT(smp_sd && name && smp_sd->smp_sd_dev);
4535 if ((smp_sd == NULL) || (name == NULL) || (smp_sd->smp_sd_dev == NULL))
4536 return (v);
4537
4538 v = ddi_prop_get_int(DDI_DEV_T_ANY, smp_sd->smp_sd_dev,
4539 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, name, v);
4540 return (v);
4541 }
4542
4543
4544 int64_t
smp_device_prop_get_int64(struct smp_device * smp_sd,char * name,int64_t defval)4545 smp_device_prop_get_int64(struct smp_device *smp_sd, char *name, int64_t defval)
4546 {
4547 int64_t v = defval;
4548
4549 ASSERT(smp_sd && name && smp_sd->smp_sd_dev);
4550 if ((smp_sd == NULL) || (name == NULL) || (smp_sd->smp_sd_dev == NULL))
4551 return (v);
4552
4553 v = ddi_prop_get_int64(DDI_DEV_T_ANY, smp_sd->smp_sd_dev,
4554 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, name, v);
4555 return (v);
4556 }
4557
4558 int
smp_device_prop_lookup_byte_array(struct smp_device * smp_sd,char * name,uchar_t ** data,uint_t * nelements)4559 smp_device_prop_lookup_byte_array(struct smp_device *smp_sd, char *name,
4560 uchar_t **data, uint_t *nelements)
4561 {
4562 int rv;
4563
4564 ASSERT(smp_sd && name && smp_sd->smp_sd_dev);
4565 if ((smp_sd == NULL) || (name == NULL) || (smp_sd->smp_sd_dev == NULL))
4566 return (DDI_PROP_INVAL_ARG);
4567
4568 rv = ddi_prop_lookup_byte_array(DDI_DEV_T_ANY, smp_sd->smp_sd_dev,
4569 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
4570 name, data, nelements);
4571 return (rv);
4572 }
4573
4574 int
smp_device_prop_lookup_int_array(struct smp_device * smp_sd,char * name,int ** data,uint_t * nelements)4575 smp_device_prop_lookup_int_array(struct smp_device *smp_sd, char *name,
4576 int **data, uint_t *nelements)
4577 {
4578 int rv;
4579
4580 ASSERT(smp_sd && name && smp_sd->smp_sd_dev);
4581 if ((smp_sd == NULL) || (name == NULL) || (smp_sd->smp_sd_dev == NULL))
4582 return (DDI_PROP_INVAL_ARG);
4583
4584 rv = ddi_prop_lookup_int_array(DDI_DEV_T_ANY, smp_sd->smp_sd_dev,
4585 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
4586 name, data, nelements);
4587 return (rv);
4588 }
4589
4590
4591 int
smp_device_prop_lookup_string(struct smp_device * smp_sd,char * name,char ** data)4592 smp_device_prop_lookup_string(struct smp_device *smp_sd, char *name,
4593 char **data)
4594 {
4595 int rv;
4596
4597 ASSERT(smp_sd && name && smp_sd->smp_sd_dev);
4598 if ((smp_sd == NULL) || (name == NULL) || (smp_sd->smp_sd_dev == NULL))
4599 return (DDI_PROP_INVAL_ARG);
4600
4601 rv = ddi_prop_lookup_string(DDI_DEV_T_ANY, smp_sd->smp_sd_dev,
4602 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
4603 name, data);
4604 return (rv);
4605 }
4606
4607 int
smp_device_prop_lookup_string_array(struct smp_device * smp_sd,char * name,char *** data,uint_t * nelements)4608 smp_device_prop_lookup_string_array(struct smp_device *smp_sd, char *name,
4609 char ***data, uint_t *nelements)
4610 {
4611 int rv;
4612
4613 ASSERT(smp_sd && name && smp_sd->smp_sd_dev);
4614 if ((smp_sd == NULL) || (name == NULL) || (smp_sd->smp_sd_dev == NULL))
4615 return (DDI_PROP_INVAL_ARG);
4616
4617 rv = ddi_prop_lookup_string_array(DDI_DEV_T_ANY, smp_sd->smp_sd_dev,
4618 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
4619 name, data, nelements);
4620 return (rv);
4621 }
4622
4623 int
smp_device_prop_update_byte_array(struct smp_device * smp_sd,char * name,uchar_t * data,uint_t nelements)4624 smp_device_prop_update_byte_array(struct smp_device *smp_sd, char *name,
4625 uchar_t *data, uint_t nelements)
4626 {
4627 int rv;
4628
4629 ASSERT(smp_sd && name && smp_sd->smp_sd_dev);
4630 if ((smp_sd == NULL) || (name == NULL) || (smp_sd->smp_sd_dev == NULL))
4631 return (DDI_PROP_INVAL_ARG);
4632
4633 rv = ndi_prop_update_byte_array(DDI_DEV_T_NONE, smp_sd->smp_sd_dev,
4634 name, data, nelements);
4635 return (rv);
4636 }
4637
4638 int
smp_device_prop_update_int(struct smp_device * smp_sd,char * name,int data)4639 smp_device_prop_update_int(struct smp_device *smp_sd, char *name, int data)
4640 {
4641 int rv;
4642
4643 ASSERT(smp_sd && name && smp_sd->smp_sd_dev);
4644 if ((smp_sd == NULL) || (name == NULL) || (smp_sd->smp_sd_dev == NULL))
4645 return (DDI_PROP_INVAL_ARG);
4646
4647 rv = ndi_prop_update_int(DDI_DEV_T_NONE, smp_sd->smp_sd_dev,
4648 name, data);
4649 return (rv);
4650 }
4651
4652 int
smp_device_prop_update_int64(struct smp_device * smp_sd,char * name,int64_t data)4653 smp_device_prop_update_int64(struct smp_device *smp_sd, char *name,
4654 int64_t data)
4655 {
4656 int rv;
4657
4658 ASSERT(smp_sd && name && smp_sd->smp_sd_dev);
4659 if ((smp_sd == NULL) || (name == NULL) || (smp_sd->smp_sd_dev == NULL))
4660 return (DDI_PROP_INVAL_ARG);
4661
4662 rv = ndi_prop_update_int64(DDI_DEV_T_NONE, smp_sd->smp_sd_dev,
4663 name, data);
4664 return (rv);
4665 }
4666
4667 int
smp_device_prop_update_int_array(struct smp_device * smp_sd,char * name,int * data,uint_t nelements)4668 smp_device_prop_update_int_array(struct smp_device *smp_sd, char *name,
4669 int *data, uint_t nelements)
4670 {
4671 int rv;
4672
4673 ASSERT(smp_sd && name && smp_sd->smp_sd_dev);
4674 if ((smp_sd == NULL) || (name == NULL) || (smp_sd->smp_sd_dev == NULL))
4675 return (DDI_PROP_INVAL_ARG);
4676
4677 rv = ndi_prop_update_int_array(DDI_DEV_T_NONE, smp_sd->smp_sd_dev,
4678 name, data, nelements);
4679 return (rv);
4680 }
4681
4682 int
smp_device_prop_update_string(struct smp_device * smp_sd,char * name,char * data)4683 smp_device_prop_update_string(struct smp_device *smp_sd, char *name, char *data)
4684 {
4685 int rv;
4686
4687 ASSERT(smp_sd && name && smp_sd->smp_sd_dev);
4688 if ((smp_sd == NULL) || (name == NULL) || (smp_sd->smp_sd_dev == NULL))
4689 return (DDI_PROP_INVAL_ARG);
4690
4691 rv = ndi_prop_update_string(DDI_DEV_T_NONE, smp_sd->smp_sd_dev,
4692 name, data);
4693 return (rv);
4694 }
4695
4696 int
smp_device_prop_update_string_array(struct smp_device * smp_sd,char * name,char ** data,uint_t nelements)4697 smp_device_prop_update_string_array(struct smp_device *smp_sd, char *name,
4698 char **data, uint_t nelements)
4699 {
4700 int rv;
4701
4702 ASSERT(smp_sd && name && smp_sd->smp_sd_dev);
4703 if ((smp_sd == NULL) || (name == NULL) || (smp_sd->smp_sd_dev == NULL))
4704 return (DDI_PROP_INVAL_ARG);
4705
4706 rv = ndi_prop_update_string_array(DDI_DEV_T_NONE, smp_sd->smp_sd_dev,
4707 name, data, nelements);
4708 return (rv);
4709 }
4710
4711 int
smp_device_prop_remove(struct smp_device * smp_sd,char * name)4712 smp_device_prop_remove(struct smp_device *smp_sd, char *name)
4713 {
4714 int rv;
4715
4716 ASSERT(smp_sd && name && smp_sd->smp_sd_dev);
4717 if ((smp_sd == NULL) || (name == NULL) || (smp_sd->smp_sd_dev == NULL))
4718 return (DDI_PROP_INVAL_ARG);
4719
4720 rv = ndi_prop_remove(DDI_DEV_T_NONE, smp_sd->smp_sd_dev, name);
4721 return (rv);
4722 }
4723
4724 void
smp_device_prop_free(struct smp_device * smp_sd,void * data)4725 smp_device_prop_free(struct smp_device *smp_sd, void *data)
4726 {
4727 ASSERT(smp_sd && data && smp_sd->smp_sd_dev);
4728 if ((smp_sd == NULL) || (data == NULL) || (smp_sd->smp_sd_dev == NULL))
4729 return;
4730
4731 ddi_prop_free(data);
4732 }
4733
4734 /*
4735 * scsi_hba_ua_set: given "unit-address" string, set properties.
4736 *
4737 * Function to set the properties on a devinfo or pathinfo node from
4738 * the "unit-address" part of a "name@unit-address" /devices path 'name'
4739 * string.
4740 *
4741 * This function works in conjunction with scsi_ua_get()/scsi_hba_ua_get()
4742 * (and possibly with an HBA driver's tran_tgt_init() implementation).
4743 */
4744 static int
scsi_hba_ua_set(char * ua,dev_info_t * dchild,mdi_pathinfo_t * pchild)4745 scsi_hba_ua_set(char *ua, dev_info_t *dchild, mdi_pathinfo_t *pchild)
4746 {
4747 char *p;
4748 int tgt;
4749 char *tgt_port_end;
4750 char *tgt_port;
4751 int tgt_port_len;
4752 int sfunc;
4753 scsi_lun64_t lun64;
4754
4755 /* Caller must choose to decorate devinfo *or* pathinfo */
4756 ASSERT((dchild != NULL) ^ (pchild != NULL));
4757 if (dchild && pchild)
4758 return (0);
4759
4760 /*
4761 * generic implementation based on "tgt,lun[,sfunc]" address form.
4762 * parse hex "tgt" part of "tgt,lun[,sfunc]"
4763 */
4764 p = ua;
4765 tgt_port_end = NULL;
4766 for (tgt = 0; *p && *p != ','; p++) {
4767 if (*p >= '0' && *p <= '9')
4768 tgt = (tgt << 4) + (*p - '0');
4769 else if (*p >= 'a' && *p <= 'f')
4770 tgt = (tgt << 4) + 10 + (*p - 'a');
4771 else
4772 tgt = -1; /* non-numeric */
4773
4774 /*
4775 * if non-numeric or our of range set tgt to -1 and
4776 * skip forward
4777 */
4778 if (tgt < 0) {
4779 tgt = -1;
4780 for (; *p && *p != ','; p++)
4781 ;
4782 break;
4783 }
4784 }
4785 tgt_port_end = p;
4786
4787 /* parse hex ",lun" part of "tgt,lun[,sfunc]" */
4788 if (*p)
4789 p++;
4790 for (lun64 = 0; *p && *p != ','; p++) {
4791 if (*p >= '0' && *p <= '9')
4792 lun64 = (lun64 << 4) + (*p - '0');
4793 else if (*p >= 'a' && *p <= 'f')
4794 lun64 = (lun64 << 4) + 10 + (*p - 'a');
4795 else
4796 return (0);
4797 }
4798
4799 /* parse hex ",sfunc" part of "tgt,lun[,sfunc]" */
4800 if (*p) {
4801 p++;
4802 for (sfunc = 0; *p; p++) {
4803 if (*p >= '0' && *p <= '9')
4804 sfunc = (sfunc << 4) + (*p - '0');
4805 else if (*p >= 'a' && *p <= 'f')
4806 sfunc = (sfunc << 4) + 10 + (*p - 'a');
4807 else
4808 return (0);
4809 }
4810 } else
4811 sfunc = -1;
4812
4813 if (dchild) {
4814 /*
4815 * Decorate a devinfo node with unit address properties.
4816 * This adds the the addressing properties needed to
4817 * DDI_CTLOPS_UNINITCHILD the devinfo node (i.e. perform
4818 * the reverse operation - form unit address from properties).
4819 */
4820 if ((tgt != -1) && (ndi_prop_update_int(DDI_DEV_T_NONE, dchild,
4821 SCSI_ADDR_PROP_TARGET, tgt) != DDI_PROP_SUCCESS))
4822 return (0);
4823
4824 if (tgt_port_end) {
4825 tgt_port_len = tgt_port_end - ua + 1;
4826 tgt_port = kmem_alloc(tgt_port_len, KM_SLEEP);
4827 (void) strlcpy(tgt_port, ua, tgt_port_len);
4828 if (ndi_prop_update_string(DDI_DEV_T_NONE, dchild,
4829 SCSI_ADDR_PROP_TARGET_PORT, tgt_port) !=
4830 DDI_PROP_SUCCESS) {
4831 kmem_free(tgt_port, tgt_port_len);
4832 return (0);
4833 }
4834 kmem_free(tgt_port, tgt_port_len);
4835 }
4836
4837 /* Set the appropriate lun properties. */
4838 if (lun64 < SCSI_32LUNS_PER_TARGET) {
4839 if (ndi_prop_update_int(DDI_DEV_T_NONE, dchild,
4840 SCSI_ADDR_PROP_LUN, (int)lun64) != DDI_PROP_SUCCESS)
4841 return (0);
4842 }
4843 if (ndi_prop_update_int64(DDI_DEV_T_NONE, dchild,
4844 SCSI_ADDR_PROP_LUN64, lun64) != DDI_PROP_SUCCESS)
4845 return (0);
4846
4847 /* Set the sfunc property */
4848 if ((sfunc != -1) &&
4849 (ndi_prop_update_int(DDI_DEV_T_NONE, dchild,
4850 SCSI_ADDR_PROP_SFUNC, (int)sfunc) != DDI_PROP_SUCCESS))
4851 return (0);
4852 } else if (pchild) {
4853 /*
4854 * Decorate a pathinfo node with unit address properties.
4855 */
4856 if ((tgt != -1) && (mdi_prop_update_int(pchild,
4857 SCSI_ADDR_PROP_TARGET, tgt) != DDI_PROP_SUCCESS))
4858 return (0);
4859
4860 if (tgt_port_end) {
4861 tgt_port_len = tgt_port_end - ua + 1;
4862 tgt_port = kmem_alloc(tgt_port_len, KM_SLEEP);
4863 (void) strlcpy(tgt_port, ua, tgt_port_len);
4864 if (mdi_prop_update_string(pchild,
4865 SCSI_ADDR_PROP_TARGET_PORT, tgt_port) !=
4866 DDI_PROP_SUCCESS) {
4867 kmem_free(tgt_port, tgt_port_len);
4868 return (0);
4869 }
4870 kmem_free(tgt_port, tgt_port_len);
4871 }
4872
4873 /* Set the appropriate lun properties */
4874 if (lun64 < SCSI_32LUNS_PER_TARGET) {
4875 if (mdi_prop_update_int(pchild, SCSI_ADDR_PROP_LUN,
4876 (int)lun64) != DDI_PROP_SUCCESS)
4877 return (0);
4878 }
4879
4880 if (mdi_prop_update_int64(pchild, SCSI_ADDR_PROP_LUN64,
4881 lun64) != DDI_PROP_SUCCESS)
4882 return (0);
4883
4884 /* Set the sfunc property */
4885 if ((sfunc != -1) &&
4886 (mdi_prop_update_int(pchild,
4887 SCSI_ADDR_PROP_SFUNC, (int)sfunc) != DDI_PROP_SUCCESS))
4888 return (0);
4889 }
4890 return (1);
4891 }
4892
4893 /*
4894 * Private ndi_devi_find/mdi_pi_find implementation - find the child
4895 * dev_info/path_info of self whose phci name matches "name@caddr".
4896 * We have our own implementation because we need to search with both
4897 * forms of sibling lists (dev_info and path_info) and we need to be able
4898 * to search with a NULL name in order to find siblings already associated
4899 * with a given unit-address (same @addr). NOTE: NULL name search will never
4900 * return probe node.
4901 *
4902 * If pchildp is NULL and we find a pathinfo child, we return the client
4903 * devinfo node in *dchildp.
4904 *
4905 * The init flag argument should be clear when called from places where
4906 * recursion could occur (like scsi_busctl_initchild) and when the caller
4907 * has already performed a search for name@addr with init set (performance).
4908 *
4909 * Future: Integrate ndi_devi_findchild_by_callback into scsi_findchild.
4910 */
4911 static int
scsi_findchild(dev_info_t * self,char * name,char * addr,int init,dev_info_t ** dchildp,mdi_pathinfo_t ** pchildp,int * ppi)4912 scsi_findchild(dev_info_t *self, char *name, char *addr, int init,
4913 dev_info_t **dchildp, mdi_pathinfo_t **pchildp, int *ppi)
4914 {
4915 dev_info_t *dchild; /* devinfo child */
4916 mdi_pathinfo_t *pchild; /* pathinfo child */
4917 int found = CHILD_TYPE_NONE;
4918 char *daddr;
4919
4920 ASSERT(self && DEVI_BUSY_OWNED(self));
4921 ASSERT(addr && dchildp);
4922 if ((self == NULL) || (addr == NULL) || (dchildp == NULL))
4923 return (CHILD_TYPE_NONE);
4924
4925 *dchildp = NULL;
4926 if (pchildp)
4927 *pchildp = NULL;
4928 if (ppi)
4929 *ppi = 0;
4930
4931 /* Walk devinfo child list to find a match */
4932 for (dchild = ddi_get_child(self); dchild;
4933 dchild = ddi_get_next_sibling(dchild)) {
4934 if (i_ddi_node_state(dchild) < DS_INITIALIZED)
4935 continue;
4936
4937 daddr = ddi_get_name_addr(dchild);
4938 if (daddr && (strcmp(addr, daddr) == 0) &&
4939 ((name == NULL) ||
4940 (strcmp(name, DEVI(dchild)->devi_node_name) == 0))) {
4941 /*
4942 * If we are asked to find "anything" at a given
4943 * unit-address (name == NULL), we don't realy want
4944 * to find the 'probe' node. The existance of
4945 * a probe node on a 'name == NULL' search should
4946 * fail. This will trigger slow-path code where
4947 * we explicity look for, and synchronize against,
4948 * a node named "probe" at the unit-address.
4949 */
4950 if ((name == NULL) &&
4951 scsi_hba_devi_is_barrier(dchild)) {
4952 SCSI_HBA_LOG((_LOG(4), NULL, dchild,
4953 "%s@%s 'probe' devinfo found, skip",
4954 name ? name : "", addr));
4955 continue;
4956 }
4957
4958 /* We have found a match. */
4959 found |= CHILD_TYPE_DEVINFO;
4960 SCSI_HBA_LOG((_LOG(4), NULL, dchild,
4961 "%s@%s devinfo found", name ? name : "", addr));
4962 *dchildp = dchild; /* devinfo found */
4963 break;
4964 }
4965 }
4966
4967 /*
4968 * Walk pathinfo child list to find a match.
4969 *
4970 * NOTE: Unlike devinfo nodes, pathinfo nodes have a string searchable
4971 * unit-address from creation - so there is no need for an 'init'
4972 * search block of code for pathinfo nodes below.
4973 */
4974 pchild = mdi_pi_find(self, NULL, addr);
4975 if (pchild) {
4976 /*
4977 * NOTE: If name specified and we match a pathinfo unit
4978 * address, we don't check the client node name.
4979 */
4980 if (ppi)
4981 *ppi = mdi_pi_get_path_instance(pchild);
4982 found |= CHILD_TYPE_PATHINFO;
4983
4984 if (pchildp) {
4985 SCSI_HBA_LOG((_LOG(4), self, NULL,
4986 "%s pathinfo found", mdi_pi_spathname(pchild)));
4987 *pchildp = pchild; /* pathinfo found */
4988 } else if (*dchildp == NULL) {
4989 /*
4990 * Did not find a devinfo node, found a pathinfo node,
4991 * but caller did not ask us to return a pathinfo node:
4992 * we return the 'client' devinfo node instead (but
4993 * with CHILD_TYPE_PATHINFO 'found' return value).
4994 */
4995 dchild = mdi_pi_get_client(pchild);
4996 SCSI_HBA_LOG((_LOG(4), NULL, dchild,
4997 "%s pathinfo found, client switch",
4998 mdi_pi_spathname(pchild)));
4999
5000 /*
5001 * A pathinfo node always has a 'client' devinfo node,
5002 * but we need to ensure that the 'client' is
5003 * initialized and has a scsi_device structure too.
5004 */
5005 ASSERT(dchild);
5006 if (i_ddi_node_state(dchild) < DS_INITIALIZED) {
5007 SCSI_HBA_LOG((_LOG(4), NULL, dchild,
5008 "%s found client, initchild",
5009 mdi_pi_spathname(pchild)));
5010 (void) ddi_initchild(ddi_get_parent(dchild),
5011 dchild);
5012 }
5013 if (i_ddi_node_state(dchild) >= DS_INITIALIZED) {
5014 /* client found and initialized */
5015 *dchildp = dchild;
5016 } else {
5017 SCSI_HBA_LOG((_LOG(4), NULL, dchild,
5018 "%s found client, but failed initchild",
5019 mdi_pi_spathname(pchild)));
5020 }
5021 }
5022 }
5023
5024 /* Try devinfo again with initchild of uninitialized nodes */
5025 if ((found == CHILD_TYPE_NONE) && init) {
5026 for (dchild = ddi_get_child(self); dchild;
5027 dchild = ddi_get_next_sibling(dchild)) {
5028 /* skip if checked above */
5029 if (i_ddi_node_state(dchild) >= DS_INITIALIZED)
5030 continue;
5031 /* attempt initchild to establish unit-address */
5032 (void) ddi_initchild(self, dchild);
5033 if (i_ddi_node_state(dchild) < DS_INITIALIZED)
5034 continue;
5035 daddr = ddi_get_name_addr(dchild);
5036 if (daddr &&
5037 ((name == NULL) || (strcmp(name,
5038 DEVI(dchild)->devi_node_name) == 0)) &&
5039 (strcmp(addr, daddr) == 0)) {
5040 found |= CHILD_TYPE_DEVINFO;
5041 SCSI_HBA_LOG((_LOG(4), NULL, dchild,
5042 "%s@%s devinfo found post initchild",
5043 name ? name : "", addr));
5044 *dchildp = dchild; /* devinfo found */
5045 break; /* node found */
5046 }
5047 }
5048 }
5049
5050 /*
5051 * We should never find devinfo and pathinfo at the same
5052 * unit-address.
5053 */
5054 ASSERT(found != (CHILD_TYPE_DEVINFO | CHILD_TYPE_PATHINFO));
5055 if (found == (CHILD_TYPE_DEVINFO | CHILD_TYPE_PATHINFO)) {
5056 found = CHILD_TYPE_NONE;
5057 *dchildp = NULL;
5058 *pchildp = NULL;
5059 }
5060 return (found);
5061 }
5062
5063 /*
5064 * Given information about a child device (contained on probe node) construct
5065 * and return a pointer to the dynamic SID devinfo node associated with the
5066 * device. In the creation of this SID node a compatible property for the
5067 * device is formed and used to establish a nodename (via
5068 * /etc/nodename_aliases) and to bind a driver (via /etc/driver_aliases).
5069 *
5070 * If this routine is called then we got a response from a device and
5071 * obtained the inquiry data from the device. Some inquiry results indicate
5072 * that the specific LUN we addressed does not exist, and we don't want to
5073 * bind a standard target driver to the node we create. Even though the
5074 * specific LUN is not usable, the framework may still want to bind a
5075 * target driver to the device for internal communication with the device -
5076 * an example would be issuing a report_lun to enumerate other LUNs under a
5077 * DPQ_NEVER LUN0. Another example would be wanting to known that the
5078 * DPQ_NEVER LUN0 device exists in BUS_CONFIG_ONE for non-existent LUN
5079 * caching optimizations. To support this we let the caller specify a
5080 * compatible property (or driver). If LUN0 inquiry data indicates that the
5081 * LUN does not exist then we establish compat0 as the highest precedence(0)
5082 * compatible form. If used, this compat0 driver will never be called on to
5083 * issue external commands to the device.
5084 *
5085 * If no driver binds to the device using driver_alias we establish the driver
5086 * passed in as the node name.
5087 */
5088
5089 extern int e_devid_cache_pathinfo(mdi_pathinfo_t *, ddi_devid_t);
5090
5091 static int
scsi_device_createchild(dev_info_t * self,char * addr,scsi_enum_t se,struct scsi_device * sdprobe,dev_info_t ** dchildp,mdi_pathinfo_t ** pchildp)5092 scsi_device_createchild(dev_info_t *self, char *addr, scsi_enum_t se,
5093 struct scsi_device *sdprobe, dev_info_t **dchildp, mdi_pathinfo_t **pchildp)
5094 {
5095 scsi_lun64_t lun64;
5096 int dtype;
5097 int dpq;
5098 int dpq_vu;
5099 int dtype_node;
5100 int lunexists;
5101 char *compat0;
5102 char *nname;
5103 char **compat = NULL;
5104 int ncompat;
5105 dev_info_t *dchild = NULL;
5106 mdi_pathinfo_t *pchild = NULL;
5107 dev_info_t *probe = sdprobe->sd_dev;
5108 struct scsi_inquiry *inq = sdprobe->sd_inq;
5109 uchar_t *inq80 = NULL;
5110 uchar_t *inq83 = NULL;
5111 uint_t inq80len, inq83len;
5112 char *binding_set = NULL;
5113 char *dname = NULL;
5114 ddi_devid_t devid;
5115 int have_devid = 0;
5116 ddi_devid_t cdevid;
5117 int have_cdevid = 0;
5118 char *devid_str;
5119 char *guid = NULL;
5120
5121 ASSERT(self && addr && *addr && DEVI_BUSY_OWNED(self));
5122 ASSERT(dchildp && pchildp);
5123
5124 /*
5125 * Determine the lun and whether the lun exists. We may need to create
5126 * a node for LUN0 (with compat0 driver binding) even if the lun does
5127 * not exist - so we can run report_lun to find additional LUNs.
5128 */
5129 lun64 = scsi_addr_to_lun64(addr);
5130 dtype = inq->inq_dtype & DTYPE_MASK; /* device */
5131 dpq = inq->inq_dtype & DPQ_MASK;
5132 dpq_vu = inq->inq_dtype & DPQ_VUNIQ ? 1 : 0;
5133
5134 dtype_node = scsi_addr_to_sfunc(addr); /* secondary function */
5135 if (dtype_node == -1)
5136 dtype_node = dtype; /* node for device */
5137
5138 lunexists = (dtype != dtype_node) || /* override */
5139 ((dpq_vu == 0) && (dpq == DPQ_POSSIBLE)) || /* ANSII */
5140 (dpq_vu && (lun64 == 0)); /* VU LUN0 */
5141 if (dtype == DTYPE_UNKNOWN)
5142 lunexists = 0;
5143
5144 SCSI_HBA_LOG((_LOG(4), self, NULL,
5145 "@%s dtype %x %x dpq_vu %d dpq %x: %d",
5146 addr, dtype, dtype_node, dpq_vu, dpq, lunexists));
5147
5148 /* A non-existent LUN0 uses compatible_nodev. */
5149 if (lunexists) {
5150 compat0 = NULL; /* compat0 not needed */
5151 } else if (lun64 == 0) {
5152 compat0 = compatible_nodev;
5153 SCSI_HBA_LOG((_LOG(2), self, NULL,
5154 "@%s lun 0 with compat0 %s", addr, compat0));
5155 } else
5156 goto out; /* no node created */
5157
5158 /* Obtain identity information from probe node. */
5159 if (ddi_prop_lookup_byte_array(DDI_DEV_T_ANY, probe,
5160 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "inquiry-page-80",
5161 &inq80, &inq80len) != DDI_PROP_SUCCESS)
5162 inq80 = NULL;
5163 if (ddi_prop_lookup_byte_array(DDI_DEV_T_ANY, probe,
5164 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "inquiry-page-83",
5165 &inq83, &inq83len) != DDI_PROP_SUCCESS)
5166 inq83 = NULL;
5167
5168 /* Get "scsi-binding-set" property (if there is one). */
5169 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, self,
5170 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
5171 "scsi-binding-set", &binding_set) == DDI_PROP_SUCCESS)
5172 SCSI_HBA_LOG((_LOG(2), NULL, probe,
5173 "binding_set '%s'", binding_set));
5174
5175 /* determine the node name and compatible information */
5176 scsi_hba_ident_nodename_compatible_get(inq,
5177 inq80, inq80len, inq83, inq83len, binding_set, dtype_node,
5178 compat0, &nname, &dname, &compat, &ncompat);
5179
5180 if (nname == NULL) {
5181 /*
5182 * We will not be able to create a node because we could not
5183 * determine a node name. Print out a NODRIVER level warning
5184 * message with the compatible forms for the device. Note that
5185 * there may be a driver.conf node that attaches to the device,
5186 * which is why we only produce this warning message for debug
5187 * kernels.
5188 */
5189 SCSI_HBA_LOG((_LOG(1), NULL, self,
5190 "no node_name for device @%s:\n compatible: %s",
5191 addr, *compat));
5192 goto out;
5193 }
5194
5195 /*
5196 * FUTURE: some day we may want an accurate "compatible" on the probe
5197 * node so that vhci_is_dev_supported() in scsi_vhci could, at
5198 * least in part, determine/configure based on "compatible".
5199 *
5200 * if (ndi_prop_update_string_array(DDI_DEV_T_NONE, probe,
5201 * "compatible", compat, ncompat) != DDI_PROP_SUCCESS) {
5202 * SCSI_HBA_LOG((_LOG(3), self, NULL,
5203 * "%s@%s failed probe compatible decoration",
5204 * nname, addr));
5205 * goto out;
5206 * }
5207 */
5208
5209 /* Encode devid from identity information. */
5210 if (ddi_devid_scsi_encode(DEVID_SCSI_ENCODE_VERSION_LATEST, dname,
5211 (uchar_t *)inq, sizeof (*inq), inq80, inq80len, inq83, inq83len,
5212 &devid) == DDI_SUCCESS) {
5213 have_devid = 1;
5214
5215 /* Attempt to form guid from devid. */
5216 guid = ddi_devid_to_guid(devid);
5217
5218 /* Produce string devid for debug. */
5219 devid_str = ddi_devid_str_encode(devid, NULL);
5220 SCSI_HBA_LOG((_LOG(3), self, probe, "devid '%s' guid '%s'",
5221 devid_str ? devid_str : "NULL", guid ? guid : "NULL"));
5222 ddi_devid_str_free(devid_str);
5223 }
5224
5225
5226 /*
5227 * Determine if the device should be enumerated as under the vHCI
5228 * (client node) or under the pHCI. By convention scsi_vhci expects
5229 * the "cinfo" argument identity information to be represented as a
5230 * devinfo node with the needed information (i.e. the pHCI probe node).
5231 */
5232 if ((guid == NULL) ||
5233 (mdi_is_dev_supported(MDI_HCI_CLASS_SCSI, self, sdprobe) !=
5234 MDI_SUCCESS)) {
5235 SCSI_HBA_LOG((_LOG(3), self, probe, "==> devinfo"));
5236
5237 /*
5238 * Enumerate under pHCI:
5239 *
5240 * Create dynamic SID dchild node. No attempt is made to
5241 * transfer information (except the addressing and identity
5242 * information) from the probe node to the dynamic node since
5243 * there may be HBA specific side effects that the framework
5244 * does not known how to transfer.
5245 */
5246 ndi_devi_alloc_sleep(self, nname,
5247 (se == SE_HP) ? DEVI_SID_HP_NODEID : DEVI_SID_NODEID,
5248 &dchild);
5249 ASSERT(dchild);
5250 ndi_flavor_set(dchild, SCSA_FLAVOR_SCSI_DEVICE);
5251
5252 /*
5253 * Decorate new node with addressing properties (via
5254 * scsi_hba_ua_set()), compatible, identity information, and
5255 * class.
5256 */
5257 if ((scsi_hba_ua_set(addr, dchild, NULL) == 0) ||
5258 (ndi_prop_update_string_array(DDI_DEV_T_NONE, dchild,
5259 "compatible", compat, ncompat) != DDI_PROP_SUCCESS) ||
5260 (inq80 && (ndi_prop_update_byte_array(DDI_DEV_T_NONE,
5261 dchild, "inquiry-page-80", inq80, inq80len) !=
5262 DDI_PROP_SUCCESS)) ||
5263 (inq83 && (ndi_prop_update_byte_array(DDI_DEV_T_NONE,
5264 dchild, "inquiry-page-83", inq83, inq83len) !=
5265 DDI_PROP_SUCCESS)) ||
5266 (ndi_prop_update_string(DDI_DEV_T_NONE, dchild,
5267 "class", "scsi") != DDI_PROP_SUCCESS)) {
5268 SCSI_HBA_LOG((_LOG(2), self, NULL,
5269 "devinfo @%s failed decoration", addr));
5270 (void) scsi_hba_remove_node(dchild);
5271 dchild = NULL;
5272 goto out;
5273 }
5274
5275 /* Bind the driver */
5276 if (ndi_devi_bind_driver(dchild, 0) != NDI_SUCCESS) {
5277 /* need to bind in order to register a devid */
5278 SCSI_HBA_LOG((_LOGCFG, NULL, dchild,
5279 "devinfo @%s created, no driver-> "
5280 "no devid_register", addr));
5281 goto out;
5282 }
5283
5284 /* Register devid */
5285 if (have_devid) {
5286 if (ddi_devid_register(dchild, devid) == DDI_FAILURE)
5287 SCSI_HBA_LOG((_LOG(1), NULL, dchild,
5288 "devinfo @%s created, "
5289 "devid register failed", addr));
5290 else
5291 SCSI_HBA_LOG((_LOG(2), NULL, dchild,
5292 "devinfo @%s created with devid", addr));
5293 } else
5294 SCSI_HBA_LOG((_LOG(2), NULL, dchild,
5295 "devinfo @%s created, no devid", addr));
5296 } else {
5297 /*
5298 * Enumerate under vHCI:
5299 *
5300 * Create a pathinfo pchild node.
5301 */
5302 SCSI_HBA_LOG((_LOG(3), self, probe, "==>pathinfo"));
5303
5304 if (mdi_pi_alloc_compatible(self, nname, guid, addr, compat,
5305 ncompat, 0, &pchild) != MDI_SUCCESS) {
5306 SCSI_HBA_LOG((_LOG(2), self, probe,
5307 "pathinfo alloc failed"));
5308 goto out;
5309 }
5310
5311 ASSERT(pchild);
5312 dchild = mdi_pi_get_client(pchild);
5313 ASSERT(dchild);
5314 ndi_flavor_set(dchild, SCSA_FLAVOR_SCSI_DEVICE);
5315
5316 /*
5317 * Decorate new node with addressing properties via
5318 * scsi_hba_ua_set().
5319 */
5320 if (scsi_hba_ua_set(addr, NULL, pchild) == 0) {
5321 SCSI_HBA_LOG((_LOG(1), self, NULL,
5322 "pathinfo %s decoration failed",
5323 mdi_pi_spathname(pchild)));
5324 (void) mdi_pi_free(pchild, 0);
5325 pchild = NULL;
5326 goto out;
5327 }
5328
5329 /* Bind the driver */
5330 if (ndi_devi_bind_driver(dchild, 0) != NDI_SUCCESS) {
5331 /* need to bind in order to register a devid */
5332 SCSI_HBA_LOG((_LOGCFG, self, NULL,
5333 "pathinfo %s created, no client driver-> "
5334 "no devid_register", mdi_pi_spathname(pchild)));
5335 goto out;
5336 }
5337
5338 /* Watch out for inconsistancies in devids. */
5339 if (ddi_devid_get(dchild, &cdevid) == DDI_SUCCESS)
5340 have_cdevid = 1;
5341
5342 if (have_devid && !have_cdevid) {
5343 /* Client does not yet have devid, register ours. */
5344 if (ddi_devid_register(dchild, devid) == DDI_FAILURE)
5345 SCSI_HBA_LOG((_LOG(1), self, NULL,
5346 "pathinfo %s created, "
5347 "devid register failed",
5348 mdi_pi_spathname(pchild)));
5349 else
5350 SCSI_HBA_LOG((_LOG(2), self, NULL,
5351 "pathinfo %s created with devid",
5352 mdi_pi_spathname(pchild)));
5353 } else if (have_devid && have_cdevid) {
5354 /*
5355 * We have devid and client already has devid:
5356 * they must be the same.
5357 */
5358 if (ddi_devid_compare(cdevid, devid) != 0) {
5359 SCSI_HBA_LOG((_LOG(WARN), NULL, dchild,
5360 "mismatched devid on path %s",
5361 mdi_pi_spathname(pchild)));
5362 }
5363 } else if (!have_devid && have_cdevid) {
5364 /*
5365 * Client already has a devid, but we don't:
5366 * we should not have missing devids.
5367 */
5368 SCSI_HBA_LOG((_LOG(WARN), NULL, dchild,
5369 "missing devid on path %s",
5370 mdi_pi_spathname(pchild)));
5371 } else if (!have_cdevid && !have_devid) {
5372 /* devid not supported */
5373 SCSI_HBA_LOG((_LOG(2), self, NULL,
5374 "pathinfo %s created, no devid",
5375 mdi_pi_spathname(pchild)));
5376 }
5377
5378 /*
5379 * The above has registered devid for the device under
5380 * the client node. Now register it under the full pHCI
5381 * path to the device. We'll get an entry equivalent to
5382 * booting with mpxio disabled. This is needed for
5383 * telemetry during enumeration.
5384 */
5385 if (e_devid_cache_pathinfo(pchild, devid) == DDI_SUCCESS) {
5386 SCSI_HBA_LOG((_LOG(2), NULL, dchild,
5387 "pathinfo @%s created with devid", addr));
5388 } else {
5389 SCSI_HBA_LOG((_LOG(1), NULL, dchild,
5390 "pathinfo @%s devid cache failed", addr));
5391 }
5392 }
5393
5394 /* free the node name and compatible information */
5395 out: if (have_devid)
5396 ddi_devid_free(devid);
5397 if (have_cdevid)
5398 ddi_devid_free(cdevid);
5399 if (guid)
5400 ddi_devid_free_guid(guid);
5401 if (compat)
5402 scsi_hba_ident_nodename_compatible_free(nname, dname, compat);
5403 if (inq80)
5404 ddi_prop_free(inq80);
5405 if (inq83)
5406 ddi_prop_free(inq83);
5407 if (binding_set)
5408 ddi_prop_free(binding_set);
5409
5410 /* return child_type results */
5411 if (pchild) {
5412 *dchildp = NULL;
5413 *pchildp = pchild;
5414 return (CHILD_TYPE_PATHINFO);
5415 } else if (dchild) {
5416 *dchildp = dchild;
5417 *pchildp = NULL;
5418 return (CHILD_TYPE_DEVINFO);
5419 }
5420
5421 return (CHILD_TYPE_NONE);
5422 }
5423
5424 /*
5425 * Call scsi_device_createchild and then initchild the new node.
5426 */
5427 static dev_info_t *
scsi_device_configchild(dev_info_t * self,char * addr,scsi_enum_t se,struct scsi_device * sdprobe,int * ppi)5428 scsi_device_configchild(dev_info_t *self, char *addr, scsi_enum_t se,
5429 struct scsi_device *sdprobe, int *ppi)
5430 {
5431 int child_type;
5432 dev_info_t *dchild;
5433 mdi_pathinfo_t *pchild;
5434 dev_info_t *child;
5435 int rval;
5436
5437 ASSERT(self && addr && *addr && DEVI_BUSY_OWNED(self));
5438 if (ppi)
5439 *ppi = 0;
5440
5441 child_type = scsi_device_createchild(self, addr, se, sdprobe,
5442 &dchild, &pchild);
5443
5444 /*
5445 * Prevent multiple initialized (tran_tgt_init) nodes associated with
5446 * the same @addr at the same time by calling tran_tgt_free() on the
5447 * probe node prior to promotion of the 'real' node. After the call
5448 * to scsi_hba_barrier_tran_tgt_free(), the HBA no longer has any
5449 * probe node context.
5450 */
5451 scsi_hba_barrier_tran_tgt_free(sdprobe->sd_dev);
5452
5453 switch (child_type) {
5454 case CHILD_TYPE_NONE:
5455 child = NULL;
5456 break;
5457
5458 case CHILD_TYPE_PATHINFO:
5459 /*
5460 * Online pathinfo: Hold the path and exit the pHCI while
5461 * calling mdi_pi_online() to avoid deadlock with power
5462 * management of pHCI.
5463 */
5464 ASSERT(MDI_PHCI(self));
5465 mdi_hold_path(pchild);
5466 scsi_hba_devi_exit_phci(self);
5467
5468 rval = mdi_pi_online(pchild, 0);
5469
5470 scsi_hba_devi_enter_phci(self);
5471 mdi_rele_path(pchild);
5472
5473 if (rval != MDI_SUCCESS) {
5474 /* pathinfo form of "failed during tran_tgt_init" */
5475 scsi_enumeration_failed(NULL, se,
5476 mdi_pi_spathname(pchild), "path online");
5477 (void) mdi_pi_free(pchild, 0);
5478 return (NULL);
5479 }
5480
5481 /*
5482 * Return the path_instance of the pathinfo node.
5483 *
5484 * NOTE: We assume that sd_inq is not path-specific.
5485 */
5486 if (ppi)
5487 *ppi = mdi_pi_get_path_instance(pchild);
5488
5489
5490 /*
5491 * Fallthrough into CHILD_TYPE_DEVINFO code to promote
5492 * the 'client' devinfo node as a dchild.
5493 */
5494 dchild = mdi_pi_get_client(pchild);
5495 SCSI_HBA_LOG((_LOG(4), NULL, dchild,
5496 "pathinfo online successful"));
5497 /* FALLTHROUGH */
5498
5499 case CHILD_TYPE_DEVINFO:
5500 /*
5501 * For now, we ndi_devi_online() the child because some other
5502 * parts of the IO framework, like degenerate devid code,
5503 * depend on bus_config driving nodes to DS_ATTACHED. At some
5504 * point in the future, to keep things light-weight, we would
5505 * like to change the ndi_devi_online call below to be
5506 *
5507 * if (ddi_initchild(self, dchild) != DDI_SUCCESS)
5508 *
5509 * This would promote the node so that framework code could
5510 * find the child with an @addr search, but does not incur
5511 * attach(9E) overhead for BUS_CONFIG_ALL cases where the
5512 * framework is not interested in attach of the node.
5513 *
5514 * NOTE: If the addr specified has incorrect syntax (busconfig
5515 * one of bogus /devices path) then call below can fail.
5516 */
5517 if (ndi_devi_online(dchild, 0) != NDI_SUCCESS) {
5518 SCSI_HBA_LOG((_LOG(2), NULL, dchild,
5519 "devinfo online failed"));
5520
5521 /* failed online does not remove the node */
5522 (void) scsi_hba_remove_node(dchild);
5523 return (NULL);
5524 }
5525 SCSI_HBA_LOG((_LOG(4), NULL, dchild,
5526 "devinfo initchild successful"));
5527 child = dchild;
5528 break;
5529 }
5530 return (child);
5531 }
5532
5533 void
scsi_hba_pkt_comp(struct scsi_pkt * pkt)5534 scsi_hba_pkt_comp(struct scsi_pkt *pkt)
5535 {
5536 scsi_hba_tran_t *tran;
5537 uint8_t *sensep;
5538
5539 ASSERT(pkt);
5540
5541 /*
5542 * Catch second call on the same packet before doing anything else.
5543 */
5544 if (pkt->pkt_flags & FLAG_PKT_COMP_CALLED) {
5545 cmn_err(
5546 #ifdef DEBUG
5547 CE_PANIC,
5548 #else
5549 CE_WARN,
5550 #endif
5551 "%s duplicate scsi_hba_pkt_comp(9F) on same scsi_pkt(9S)",
5552 mod_containing_pc(caller()));
5553 }
5554
5555 pkt->pkt_flags |= FLAG_PKT_COMP_CALLED;
5556
5557 if (pkt->pkt_comp == NULL)
5558 return;
5559
5560 /*
5561 * For HBA drivers that implement tran_setup_pkt(9E), if we are
5562 * completing a 'consistent' mode DMA operation then we must
5563 * perform dma_sync prior to calling pkt_comp to ensure that
5564 * the target driver sees the correct data in memory.
5565 */
5566 ASSERT((pkt->pkt_flags & FLAG_NOINTR) == 0);
5567 if (((pkt->pkt_dma_flags & DDI_DMA_CONSISTENT) &&
5568 (pkt->pkt_dma_flags & DDI_DMA_READ)) &&
5569 ((P_TO_TRAN(pkt)->tran_setup_pkt) != NULL)) {
5570 scsi_sync_pkt(pkt);
5571 }
5572
5573 /*
5574 * If the HBA driver is using SCSAv3 scsi_hba_tgtmap_create enumeration
5575 * then we detect the special ASC/ASCQ completion codes that indicate
5576 * that the lun configuration of a target has changed. Since we need to
5577 * be determine scsi_device given scsi_address enbedded in
5578 * scsi_pkt (via scsi_address_device(9F)), we also require use of
5579 * SCSI_HBA_ADDR_COMPLEX.
5580 */
5581 tran = pkt->pkt_address.a_hba_tran;
5582 ASSERT(tran);
5583 if ((tran->tran_tgtmap == NULL) ||
5584 !(tran->tran_hba_flags & SCSI_HBA_ADDR_COMPLEX))
5585 goto comp; /* not using tgtmap */
5586
5587 /*
5588 * Check for lun-change notification and queue the scsi_pkt for
5589 * lunchg1 processing. The 'pkt_comp' call to the target driver
5590 * is part of lunchg1 processing.
5591 */
5592 if ((pkt->pkt_reason == CMD_CMPLT) &&
5593 (((*pkt->pkt_scbp) & STATUS_MASK) == STATUS_CHECK) &&
5594 (pkt->pkt_state & STATE_ARQ_DONE)) {
5595 sensep = (uint8_t *)&(((struct scsi_arq_status *)(uintptr_t)
5596 (pkt->pkt_scbp))->sts_sensedata);
5597 if (((scsi_sense_key(sensep) == KEY_UNIT_ATTENTION) &&
5598 (scsi_sense_asc(sensep) == 0x3f) &&
5599 (scsi_sense_ascq(sensep) == 0x0e)) ||
5600
5601 ((scsi_sense_key(sensep) == KEY_UNIT_ATTENTION) &&
5602 (scsi_sense_asc(sensep) == 0x25) &&
5603 (scsi_sense_ascq(sensep) == 0x00))) {
5604 /*
5605 * The host adaptor is done with the packet, we use
5606 * pkt_stmp stage-temporary to link the packet for
5607 * lunchg1 processing.
5608 *
5609 * NOTE: pkt_ha_private is not available since its use
5610 * extends to tran_teardown_pkt.
5611 */
5612 mutex_enter(&scsi_lunchg1_mutex);
5613 pkt->pkt_stmp = scsi_lunchg1_list;
5614 scsi_lunchg1_list = pkt;
5615 if (pkt->pkt_stmp == NULL)
5616 cv_signal(&scsi_lunchg1_cv);
5617 mutex_exit(&scsi_lunchg1_mutex);
5618 return;
5619 }
5620 }
5621
5622 comp: (*pkt->pkt_comp)(pkt);
5623 }
5624
5625 /*
5626 * return 1 if the specified node is a barrier/probe node
5627 */
5628 static int
scsi_hba_devi_is_barrier(dev_info_t * probe)5629 scsi_hba_devi_is_barrier(dev_info_t *probe)
5630 {
5631 if (probe && (strcmp(ddi_node_name(probe), "probe") == 0))
5632 return (1);
5633 return (0);
5634 }
5635
5636 /*
5637 * A host adapter driver is easier to write if we prevent multiple initialized
5638 * (tran_tgt_init) scsi_device structures to the same unit-address at the same
5639 * time. We prevent this from occurring all the time during the barrier/probe
5640 * node to real child hand-off by calling scsi_hba_barrier_tran_tgt_free
5641 * on the probe node prior to ddi_inichild of the 'real' node. As part of
5642 * this early tran_tgt_free implementation, we must also call this function
5643 * as we put a probe node on the scsi_hba_barrier_list.
5644 */
5645 static void
scsi_hba_barrier_tran_tgt_free(dev_info_t * probe)5646 scsi_hba_barrier_tran_tgt_free(dev_info_t *probe)
5647 {
5648 struct scsi_device *sdprobe;
5649 dev_info_t *self;
5650 scsi_hba_tran_t *tran;
5651
5652 ASSERT(probe && scsi_hba_devi_is_barrier(probe));
5653
5654 /* Return if we never called tran_tgt_init(9E). */
5655 if (i_ddi_node_state(probe) < DS_INITIALIZED)
5656 return;
5657
5658 sdprobe = ddi_get_driver_private(probe);
5659 self = ddi_get_parent(probe);
5660 ASSERT(sdprobe && self);
5661 tran = ddi_get_driver_private(self);
5662 ASSERT(tran);
5663
5664 if (tran->tran_tgt_free) {
5665 /*
5666 * To correctly support TRAN_CLONE, we need to use the same
5667 * cloned scsi_hba_tran(9S) structure for both tran_tgt_init(9E)
5668 * and tran_tgt_free(9E).
5669 */
5670 if (tran->tran_hba_flags & SCSI_HBA_TRAN_CLONE)
5671 tran = sdprobe->sd_address.a_hba_tran;
5672
5673 if (!sdprobe->sd_tran_tgt_free_done) {
5674 SCSI_HBA_LOG((_LOG(4), NULL, probe,
5675 "tran_tgt_free EARLY"));
5676 (*tran->tran_tgt_free) (self, probe, tran, sdprobe);
5677 sdprobe->sd_tran_tgt_free_done = 1;
5678 } else {
5679 SCSI_HBA_LOG((_LOG(4), NULL, probe,
5680 "tran_tgt_free EARLY already done"));
5681 }
5682 }
5683 }
5684
5685 /*
5686 * Add an entry to the list of barrier nodes to be asynchronously deleted by
5687 * the scsi_hba_barrier_daemon after the specified timeout. Nodes on
5688 * the barrier list are used to implement the bus_config probe cache
5689 * of non-existent devices. The nodes are at DS_INITIALIZED, so their
5690 * @addr is established for searching. Since devi_ref of a DS_INITIALIZED
5691 * node will *not* prevent demotion, demotion is prevented by setting
5692 * sd_uninit_prevent. Devinfo snapshots attempt to attach probe cache
5693 * nodes, and on failure attempt to demote the node (without the participation
5694 * of bus_unconfig) to DS_BOUND - this demotion is prevented via
5695 * sd_uninit_prevent causing any attempted DDI_CTLOPS_UNINITCHILD to fail.
5696 * Probe nodes are bound to nulldriver. The list is sorted by
5697 * expiration time.
5698 *
5699 * NOTE: If we drove a probe node to DS_ATTACHED, we could use ndi_hold_devi()
5700 * to prevent demotion (instead of sd_uninit_prevent).
5701 */
5702 static void
scsi_hba_barrier_add(dev_info_t * probe,int seconds)5703 scsi_hba_barrier_add(dev_info_t *probe, int seconds)
5704 {
5705 struct scsi_hba_barrier *nb;
5706 struct scsi_hba_barrier *b;
5707 struct scsi_hba_barrier **bp;
5708 clock_t endtime;
5709
5710 ASSERT(scsi_hba_devi_is_barrier(probe));
5711
5712 /* HBA is no longer responsible for nodes on the barrier list. */
5713 scsi_hba_barrier_tran_tgt_free(probe);
5714 nb = kmem_alloc(sizeof (struct scsi_hba_barrier), KM_SLEEP);
5715 mutex_enter(&scsi_hba_barrier_mutex);
5716 endtime = ddi_get_lbolt() + drv_usectohz(seconds * MICROSEC);
5717 for (bp = &scsi_hba_barrier_list; (b = *bp) != NULL;
5718 bp = &b->barrier_next)
5719 if (b->barrier_endtime > endtime)
5720 break;
5721 nb->barrier_next = *bp;
5722 nb->barrier_endtime = endtime;
5723 nb->barrier_probe = probe;
5724 *bp = nb;
5725 if (bp == &scsi_hba_barrier_list)
5726 cv_signal(&scsi_hba_barrier_cv);
5727 mutex_exit(&scsi_hba_barrier_mutex);
5728 }
5729
5730 /*
5731 * Attempt to remove devinfo node node, return 1 if removed. We
5732 * don't try to remove barrier nodes that have sd_uninit_prevent set
5733 * (even though they should fail device_uninitchild).
5734 */
5735 static int
scsi_hba_remove_node(dev_info_t * child)5736 scsi_hba_remove_node(dev_info_t *child)
5737 {
5738 dev_info_t *self = ddi_get_parent(child);
5739 struct scsi_device *sd;
5740 boolean_t enteredv;
5741 int remove = 1;
5742 int ret = 0;
5743 char na[SCSI_MAXNAMELEN];
5744
5745 scsi_hba_devi_enter(self, &enteredv);
5746
5747 /* Honor sd_uninit_prevent on barrier nodes */
5748 if (scsi_hba_devi_is_barrier(child)) {
5749 sd = ddi_get_driver_private(child);
5750 if (sd && sd->sd_uninit_prevent)
5751 remove = 0;
5752 }
5753
5754 if (remove) {
5755 (void) ddi_deviname(child, na);
5756 if (ddi_remove_child(child, 0) != DDI_SUCCESS) {
5757 SCSI_HBA_LOG((_LOG(2), NULL, child,
5758 "remove_node failed"));
5759 } else {
5760 child = NULL; /* child is gone */
5761 SCSI_HBA_LOG((_LOG(4), self, NULL,
5762 "remove_node removed %s", *na ? &na[1] : na));
5763 ret = 1;
5764 }
5765 } else {
5766 SCSI_HBA_LOG((_LOG(4), NULL, child, "remove_node prevented"));
5767 }
5768 scsi_hba_devi_exit(self, enteredv);
5769 return (ret);
5770 }
5771
5772 /*
5773 * The asynchronous barrier deletion daemon. Waits for a barrier timeout
5774 * to expire, then deletes the barrier (removes it as a child).
5775 */
5776 /*ARGSUSED*/
5777 static void
scsi_hba_barrier_daemon(void * arg)5778 scsi_hba_barrier_daemon(void *arg)
5779 {
5780 struct scsi_hba_barrier *b;
5781 dev_info_t *probe;
5782 callb_cpr_t cprinfo;
5783 boolean_t enteredv;
5784 dev_info_t *self;
5785
5786 CALLB_CPR_INIT(&cprinfo, &scsi_hba_barrier_mutex,
5787 callb_generic_cpr, "scsi_hba_barrier_daemon");
5788 again: mutex_enter(&scsi_hba_barrier_mutex);
5789 for (;;) {
5790 b = scsi_hba_barrier_list;
5791 if (b == NULL) {
5792 /* all barriers expired, wait for barrier_add */
5793 CALLB_CPR_SAFE_BEGIN(&cprinfo);
5794 (void) cv_wait(&scsi_hba_barrier_cv,
5795 &scsi_hba_barrier_mutex);
5796 CALLB_CPR_SAFE_END(&cprinfo, &scsi_hba_barrier_mutex);
5797 } else {
5798 if (ddi_get_lbolt() >= b->barrier_endtime) {
5799 /*
5800 * Drop and retry if ordering issue. Do this
5801 * before calling scsi_hba_remove_node() and
5802 * deadlocking.
5803 */
5804 probe = b->barrier_probe;
5805 self = ddi_get_parent(probe);
5806 if (scsi_hba_devi_tryenter(self,
5807 &enteredv) == 0) {
5808 delay: mutex_exit(&scsi_hba_barrier_mutex);
5809 delay_random(5);
5810 goto again;
5811 }
5812
5813 /* process expired barrier */
5814 if (!scsi_hba_remove_node(probe)) {
5815 /* remove failed, delay and retry */
5816 SCSI_HBA_LOG((_LOG(4), NULL, probe,
5817 "delay expire"));
5818 scsi_hba_devi_exit(self, enteredv);
5819 goto delay;
5820 }
5821 scsi_hba_barrier_list = b->barrier_next;
5822 kmem_free(b, sizeof (struct scsi_hba_barrier));
5823 scsi_hba_devi_exit(self, enteredv);
5824 } else {
5825 /* establish timeout for next barrier expire */
5826 (void) cv_timedwait(&scsi_hba_barrier_cv,
5827 &scsi_hba_barrier_mutex,
5828 b->barrier_endtime);
5829 }
5830 }
5831 }
5832 }
5833
5834 /*
5835 * Remove all barriers associated with the specified HBA. This is called
5836 * from from the bus_unconfig implementation to remove probe nodes associated
5837 * with the specified HBA (self) so that probe nodes that have not expired
5838 * will not prevent DR of the HBA.
5839 */
5840 static void
scsi_hba_barrier_purge(dev_info_t * self)5841 scsi_hba_barrier_purge(dev_info_t *self)
5842 {
5843 struct scsi_hba_barrier **bp;
5844 struct scsi_hba_barrier *b;
5845
5846 mutex_enter(&scsi_hba_barrier_mutex);
5847 for (bp = &scsi_hba_barrier_list; (b = *bp) != NULL; ) {
5848 if (ddi_get_parent(b->barrier_probe) == self) {
5849 if (scsi_hba_remove_node(b->barrier_probe)) {
5850 *bp = b->barrier_next;
5851 kmem_free(b, sizeof (struct scsi_hba_barrier));
5852 } else {
5853 SCSI_HBA_LOG((_LOG(4), NULL, b->barrier_probe,
5854 "skip purge"));
5855 }
5856 } else
5857 bp = &b->barrier_next;
5858 }
5859
5860 mutex_exit(&scsi_hba_barrier_mutex);
5861 }
5862
5863 /*
5864 * LUN-change processing daemons: processing occurs in two stages:
5865 *
5866 * Stage 1: Daemon waits for a lunchg1 queued scsi_pkt, dequeues the pkt,
5867 * forms the path, completes the scsi_pkt (pkt_comp), and
5868 * queues the path for stage 2 processing. The use of stage 1
5869 * avoids issues related to memory allocation in interrupt context
5870 * (scsi_hba_pkt_comp()). We delay the pkt_comp completion until
5871 * after lunchg1 processing forms the path for stage 2 - this is
5872 * done to prevent the target driver from detaching until the
5873 * path formation is complete (driver with outstanding commands
5874 * should not detach).
5875 *
5876 * Stage 2: Daemon waits for a lunchg2 queued request, dequeues the
5877 * request, and opens the path using ldi_open_by_name(). The
5878 * path opened uses a special "@taddr,*" unit address that will
5879 * trigger lun enumeration in scsi_hba_bus_configone(). We
5880 * trigger lun enumeration in stage 2 to avoid problems when
5881 * initial ASC/ASCQ trigger occurs during discovery.
5882 */
5883 /*ARGSUSED*/
5884 static void
scsi_lunchg1_daemon(void * arg)5885 scsi_lunchg1_daemon(void *arg)
5886 {
5887 callb_cpr_t cprinfo;
5888 struct scsi_pkt *pkt;
5889 scsi_hba_tran_t *tran;
5890 dev_info_t *self;
5891 struct scsi_device *sd;
5892 char *ua, *p;
5893 char taddr[SCSI_MAXNAMELEN];
5894 char path[MAXPATHLEN];
5895 struct scsi_lunchg2 *lunchg2;
5896
5897 CALLB_CPR_INIT(&cprinfo, &scsi_lunchg1_mutex,
5898 callb_generic_cpr, "scsi_lunchg1_daemon");
5899 mutex_enter(&scsi_lunchg1_mutex);
5900 for (;;) {
5901 pkt = scsi_lunchg1_list;
5902 if (pkt == NULL) {
5903 /* All lunchg1 processing requests serviced, wait. */
5904 CALLB_CPR_SAFE_BEGIN(&cprinfo);
5905 (void) cv_wait(&scsi_lunchg1_cv,
5906 &scsi_lunchg1_mutex);
5907 CALLB_CPR_SAFE_END(&cprinfo, &scsi_lunchg1_mutex);
5908 continue;
5909 }
5910
5911 /* Unlink and perform lunchg1 processing on pkt. */
5912 scsi_lunchg1_list = pkt->pkt_stmp;
5913
5914 /* Determine initiator port (self) from the pkt_address. */
5915 tran = pkt->pkt_address.a_hba_tran;
5916 ASSERT(tran && tran->tran_tgtmap && tran->tran_iport_dip);
5917 self = tran->tran_iport_dip;
5918
5919 /*
5920 * Determine scsi_devie from pkt_address (depends on
5921 * SCSI_HBA_ADDR_COMPLEX).
5922 */
5923 sd = scsi_address_device(&(pkt->pkt_address));
5924 ASSERT(sd);
5925 if (sd == NULL) {
5926 (*pkt->pkt_comp)(pkt);
5927 continue;
5928 }
5929
5930 /* Determine unit-address from scsi_device. */
5931 ua = scsi_device_unit_address(sd);
5932
5933 /* Extract taddr from the unit-address. */
5934 for (p = taddr; (*ua != ',') && (*ua != '\0'); )
5935 *p++ = *ua++;
5936 *p = '\0'; /* NULL terminate taddr */
5937
5938 /*
5939 * Form path using special "@taddr,*" notation to trigger
5940 * lun enumeration.
5941 */
5942 (void) ddi_pathname(self, path);
5943 (void) strlcat(path, "/luns@", sizeof (path));
5944 (void) strlcat(path, taddr, sizeof (path));
5945 (void) strlcat(path, ",*", sizeof (path));
5946
5947 /*
5948 * Now that we have the path, complete the pkt that
5949 * triggered lunchg1 processing.
5950 */
5951 (*pkt->pkt_comp)(pkt);
5952
5953 /* Allocate element for stage2 processing queue. */
5954 lunchg2 = kmem_alloc(sizeof (*lunchg2), KM_SLEEP);
5955 lunchg2->lunchg2_path = strdup(path);
5956
5957 /* Queue and dispatch to stage 2. */
5958 SCSI_HBA_LOG((_LOG(2), self, NULL,
5959 "lunchg stage1: queue %s", lunchg2->lunchg2_path));
5960 mutex_enter(&scsi_lunchg2_mutex);
5961 lunchg2->lunchg2_next = scsi_lunchg2_list;
5962 scsi_lunchg2_list = lunchg2;
5963 if (lunchg2->lunchg2_next == NULL)
5964 cv_signal(&scsi_lunchg2_cv);
5965 mutex_exit(&scsi_lunchg2_mutex);
5966 }
5967 }
5968
5969 /*ARGSUSED*/
5970 static void
scsi_lunchg2_daemon(void * arg)5971 scsi_lunchg2_daemon(void *arg)
5972 {
5973 callb_cpr_t cprinfo;
5974 struct scsi_lunchg2 *lunchg2;
5975 ldi_ident_t li;
5976 ldi_handle_t lh;
5977
5978 CALLB_CPR_INIT(&cprinfo, &scsi_lunchg2_mutex,
5979 callb_generic_cpr, "scsi_lunchg2_daemon");
5980
5981 li = ldi_ident_from_anon();
5982 mutex_enter(&scsi_lunchg2_mutex);
5983 for (;;) {
5984 lunchg2 = scsi_lunchg2_list;
5985 if (lunchg2 == NULL) {
5986 /* All lunchg2 processing requests serviced, wait. */
5987 CALLB_CPR_SAFE_BEGIN(&cprinfo);
5988 (void) cv_wait(&scsi_lunchg2_cv,
5989 &scsi_lunchg2_mutex);
5990 CALLB_CPR_SAFE_END(&cprinfo, &scsi_lunchg2_mutex);
5991 continue;
5992 }
5993
5994 /* Unlink and perform lunchg2 processing on pkt. */
5995 scsi_lunchg2_list = lunchg2->lunchg2_next;
5996
5997 /*
5998 * Open and close the path to trigger lun enumeration. We
5999 * don't expect the open to succeed, but we do expect code in
6000 * scsi_hba_bus_configone() to trigger lun enumeration.
6001 */
6002 SCSI_HBA_LOG((_LOG(2), NULL, NULL,
6003 "lunchg stage2: open %s", lunchg2->lunchg2_path));
6004 if (ldi_open_by_name(lunchg2->lunchg2_path,
6005 FREAD, kcred, &lh, li) == 0)
6006 (void) ldi_close(lh, FREAD, kcred);
6007
6008 /* Free path and linked element. */
6009 strfree(lunchg2->lunchg2_path);
6010 kmem_free(lunchg2, sizeof (*lunchg2));
6011 }
6012 }
6013
6014 /*
6015 * Enumerate a child at the specified @addr. If a device exists @addr then
6016 * ensure that we have the appropriately named devinfo node for it. Name is
6017 * NULL in the bus_config_all case. This routine has no knowledge of the
6018 * format of an @addr string or associated addressing properties.
6019 *
6020 * The caller must guarantee that there is an open scsi_hba_devi_enter on the
6021 * parent. We return the scsi_device structure for the child device. This
6022 * scsi_device structure is valid until the caller scsi_hba_devi_exit the
6023 * parent. The caller can add do ndi_hold_devi of the child prior to the
6024 * scsi_hba_devi_exit to extend the validity of the child.
6025 *
6026 * In some cases the returned scsi_device structure may be used to drive
6027 * additional SCMD_REPORT_LUNS operations by bus_config_all callers.
6028 *
6029 * The first operation performed is to see if there is a dynamic SID nodes
6030 * already attached at the specified "name@addr". This is the fastpath
6031 * case for resolving a reference to a node that has already been created.
6032 * All other references are serialized for a given @addr prior to probing
6033 * to determine the type of device, if any, at the specified @addr.
6034 * If no device is present then NDI_FAILURE is returned. The fact that a
6035 * device does not exist may be determined via the barrier/probe cache,
6036 * minimizing the probes of non-existent devices.
6037 *
6038 * When there is a device present the dynamic SID node is created based on
6039 * the device found. If a driver.conf node exists for the same @addr it
6040 * will either merge into the dynamic SID node (if the SID node bound to
6041 * that driver), or exist independently. To prevent the actions of one driver
6042 * causing side effects in another, code prevents multiple SID nodes from
6043 * binding to the same "@addr" at the same time. There is autodetach code
6044 * to allow one device to be replaced with another at the same @addr for
6045 * slot addressed SCSI bus implementations (SPI). For compatibility with
6046 * legacy driver.conf behavior, the code does not prevent multiple driver.conf
6047 * nodes from attaching to the same @addr at the same time.
6048 *
6049 * This routine may have the side effect of creating nodes for devices other
6050 * than the one being sought. It is possible that there is a different type of
6051 * target device at that target/lun address than we were asking for. In that
6052 * It is the caller's responsibility to determine whether the device we found,
6053 * if any, at the specified address, is the one it really wanted.
6054 */
6055 static struct scsi_device *
scsi_device_config(dev_info_t * self,char * name,char * addr,scsi_enum_t se,boolean_t * enteredvp,int * ppi)6056 scsi_device_config(dev_info_t *self, char *name, char *addr, scsi_enum_t se,
6057 boolean_t *enteredvp, int *ppi)
6058 {
6059 dev_info_t *child = NULL;
6060 dev_info_t *probe = NULL;
6061 struct scsi_device *sdchild;
6062 struct scsi_device *sdprobe;
6063 dev_info_t *dsearch;
6064 mdi_pathinfo_t *psearch;
6065 major_t major;
6066 int sp;
6067 int pi = 0;
6068 int wait_msg = scsi_hba_wait_msg;
6069 int chg;
6070
6071 ASSERT(self && addr && DEVI_BUSY_OWNED(self));
6072
6073 SCSI_HBA_LOG((_LOG(4), self, NULL, "%s@%s wanted",
6074 name ? name : "", addr));
6075
6076 /* playing with "probe" node name is dangerous */
6077 if (name && (strcmp(name, "probe") == 0))
6078 return (NULL);
6079
6080 /*
6081 * NOTE: use 'goto done;' or 'goto fail;'. There should only be one
6082 * 'return' statement from here to the end of the function - the one
6083 * on the last line of the function.
6084 */
6085
6086 /*
6087 * Fastpath: search to see if we are requesting a named SID node that
6088 * already exists (we already created) - probe node does not count.
6089 * scsi_findchild() does not hold the returned devinfo node, but
6090 * this is OK since the caller has a scsi_hba_devi_enter on the
6091 * attached parent HBA (self). The caller is responsible for attaching
6092 * and placing a hold on the child (directly via ndi_hold_devi or
6093 * indirectly via ndi_busop_bus_config) before doing an
6094 * scsi_hba_devi_exit on the parent.
6095 *
6096 * NOTE: This fastpath prevents detecting a driver binding change
6097 * (autodetach) if the same nodename is used for old and new binding.
6098 */
6099 /* first call is with init set */
6100 (void) scsi_findchild(self, name, addr, 1, &dsearch, NULL, &pi);
6101 if (dsearch && scsi_hba_dev_is_sid(dsearch) &&
6102 !scsi_hba_devi_is_barrier(dsearch)) {
6103 SCSI_HBA_LOG((_LOG(4), NULL, dsearch,
6104 "%s@%s devinfo fastpath", name ? name : "", addr));
6105 child = dsearch;
6106 goto done;
6107 }
6108
6109 /*
6110 * Create a barrier devinfo node used to "probe" the device with. We
6111 * need to drive this node to DS_INITIALIZED so that the
6112 * DDI_CTLOPS_INITCHILD has occurred, bringing the SCSA transport to
6113 * a state useable state for issuing our "probe" commands. We establish
6114 * this barrier node with a node name of "probe" and compatible
6115 * property of "scsiprobe". The compatible property must be associated
6116 * in /etc/driver_aliases with a scsi target driver available in the
6117 * root file system (sd).
6118 *
6119 * The "probe" that we perform on the barrier node, after it is
6120 * DS_INITIALIZED, is used to find the information needed to create a
6121 * dynamic devinfo (SID) node. This "probe" is separate from the
6122 * probe(9E) call associated with the transition of a node from
6123 * DS_INITIALIZED to DS_PROBED. The probe(9E) call that eventually
6124 * occurs against the created SID node should find ddi_dev_is_sid and
6125 * just return DDI_PROBE_DONTCARE.
6126 *
6127 * Trying to avoid the use of a barrier node is not a good idea
6128 * because we may have an HBA driver that uses generic bus_config
6129 * (this code) but implements its own DDI_CTLOPS_INITCHILD with side
6130 * effects that we can't duplicate (such as the ATA nexus driver).
6131 *
6132 * The probe/barrier node plays an integral part of the locking scheme.
6133 * The objective is to single thread probes of the same device (same
6134 * @addr) while allowing parallelism for probes of different devices
6135 * with the same parent. At this point we are serialized on our self.
6136 * For parallelism we will need to release our self. Prior to release
6137 * we construct a barrier for probes of the same device to serialize
6138 * against. The "probe@addr" node acts as this barrier. An entering
6139 * thread must wait until the probe node does not exist - it can then
6140 * create and link the probe node - dropping the HBA (self) lock after
6141 * the node is linked and visible (after ddi_initchild). A side effect
6142 * of this is that transports should not "go over the wire" (i.e. do
6143 * things that incur significant delays) until after tran_target_init.
6144 * This means that the first "over the wire" operation should occur
6145 * at tran_target_probe time - when things are running in parallel
6146 * again.
6147 *
6148 * If the probe node exists then another probe with the same @addr is
6149 * in progress, we must wait until there is no probe in progress
6150 * before proceeding, and when we proceed we must continue to hold the
6151 * HBA (self) until we have linked a new probe node as a barrier.
6152 *
6153 * When a device is found to *not* exist, its probe/barrier node may be
6154 * marked with DEVICE_REMOVED with node deletion scheduled for some
6155 * future time (seconds). This asynchronous deletion allows the
6156 * framework to detect repeated requests to the same non-existent
6157 * device and avoid overhead associated with contacting a non-existent
6158 * device again and again.
6159 */
6160 for (;;) {
6161 /*
6162 * Search for probe node - they should only exist as devinfo
6163 * nodes.
6164 */
6165 (void) scsi_findchild(self, "probe", addr,
6166 0, &probe, &psearch, NULL);
6167 if (probe == NULL) {
6168 if (psearch)
6169 SCSI_HBA_LOG((_LOG(2), self,
6170 mdi_pi_get_client(psearch),
6171 "???? @%s 'probe' search found "
6172 "pathinfo: %p", addr, (void *)psearch));
6173 break;
6174 }
6175
6176 /*
6177 * The barrier node may cache the non-existence of a device
6178 * by leaving the barrier node in place (with
6179 * DEVI_DEVICE_REMOVED flag set ) for some amount of time after
6180 * the failure of a probe. This flag is used to fail
6181 * additional probes until the barrier probe node is deleted,
6182 * which will occur from a timeout some time after a failed
6183 * probe. The failed probe will use DEVI_SET_DEVICE_REMOVED
6184 * and schedule probe node deletion from a timeout. The callers
6185 * scsi_hba_devi_exit on the way out of the first failure will
6186 * do the cv_broadcast associated with the cv_wait below - this
6187 * handles threads that wait prior to DEVI_DEVICE_REMOVED being
6188 * set.
6189 */
6190 if (DEVI_IS_DEVICE_REMOVED(probe)) {
6191 SCSI_HBA_LOG((_LOG(3), NULL, probe,
6192 "detected probe DEVICE_REMOVED"));
6193 probe = NULL; /* deletion already scheduled */
6194 goto fail;
6195 }
6196
6197 /*
6198 * Drop the lock on the HBA (self) and wait until the probe in
6199 * progress has completed. A changes in the sibling list from
6200 * removing the probe node will cause cv_wait to return
6201 * (scsi_hba_devi_exit does the cv_broadcast).
6202 */
6203 if (wait_msg) {
6204 wait_msg--;
6205 SCSI_HBA_LOG((_LOG(2), NULL, probe,
6206 "exists, probe already in progress: %s", wait_msg ?
6207 "waiting..." : "last msg, but still waiting..."));
6208 }
6209
6210 /*
6211 * NOTE: we could avoid rare case of one second delay by
6212 * implementing scsi_hba_devi_exit_and_wait based on
6213 * ndi/mdi_devi_exit_and_wait (and consider switching devcfg.c
6214 * code to use these ndi/mdi interfaces too).
6215 */
6216 scsi_hba_devi_exit(self, *enteredvp);
6217 mutex_enter(&DEVI(self)->devi_lock);
6218 (void) cv_timedwait(&DEVI(self)->devi_cv,
6219 &DEVI(self)->devi_lock,
6220 ddi_get_lbolt() + drv_usectohz(MICROSEC));
6221 mutex_exit(&DEVI(self)->devi_lock);
6222 scsi_hba_devi_enter(self, enteredvp);
6223 }
6224 ASSERT(probe == NULL);
6225
6226 /*
6227 * Search to see if we are requesting a SID node that already exists.
6228 * We hold the HBA (self) and there is not another probe in progress at
6229 * the same @addr. scsi_findchild() does not hold the returned
6230 * devinfo node but this is OK since we hold the HBA (self).
6231 */
6232 if (name) {
6233 (void) scsi_findchild(self, name, addr, 1, &dsearch, NULL, &pi);
6234 if (dsearch && scsi_hba_dev_is_sid(dsearch)) {
6235 SCSI_HBA_LOG((_LOG(4), NULL, dsearch,
6236 "%s@%s probe devinfo fastpath",
6237 name ? name : "", addr));
6238 child = dsearch;
6239 goto done;
6240 }
6241 }
6242
6243 /*
6244 * We are looking for a SID node that does not exist or a driver.conf
6245 * node.
6246 *
6247 * To avoid probe side effects, before we probe the device at the
6248 * specified address we need to check to see if there is already an
6249 * initialized child "@addr".
6250 *
6251 * o If we find an initialized SID child and name is NULL or matches
6252 * the name or the name of the attached driver then we return the
6253 * existing node.
6254 *
6255 * o If we find a non-matching SID node, we will attempt to autodetach
6256 * and remove the node in preference to our new node.
6257 *
6258 * o If SID node found does not match and can't be autodetached, we
6259 * fail: we only allow one SID node at an address.
6260 *
6261 * NOTE: This code depends on SID nodes showing up prior to
6262 * driver.conf nodes in the sibling list.
6263 */
6264 for (;;) {
6265 /* first NULL name call is with init set */
6266 (void) scsi_findchild(self, NULL, addr, 1, &dsearch, NULL, &pi);
6267 if (dsearch == NULL)
6268 break;
6269 ASSERT(!scsi_hba_devi_is_barrier(dsearch));
6270
6271 /*
6272 * To detect changes in driver binding that should attempt
6273 * autodetach we determine the major number of the driver
6274 * that should currently be associated with the device based
6275 * on the compatible property.
6276 */
6277 major = DDI_MAJOR_T_NONE;
6278 if (scsi_hba_dev_is_sid(dsearch))
6279 major = ddi_compatible_driver_major(dsearch, NULL);
6280 if ((major == DDI_MAJOR_T_NONE) && (name == NULL))
6281 major = ddi_driver_major(dsearch);
6282
6283 if ((scsi_hba_dev_is_sid(dsearch) ||
6284 (i_ddi_node_state(dsearch) >= DS_INITIALIZED)) &&
6285 ((name == NULL) ||
6286 (strcmp(ddi_node_name(dsearch), name) == 0) ||
6287 (strcmp(ddi_driver_name(dsearch), name) == 0)) &&
6288 (major == ddi_driver_major(dsearch))) {
6289 SCSI_HBA_LOG((_LOG(3), NULL, dsearch,
6290 "already attached @addr"));
6291 child = dsearch;
6292 goto done;
6293 }
6294
6295 if (!scsi_hba_dev_is_sid(dsearch))
6296 break; /* driver.conf node */
6297
6298 /*
6299 * Implement autodetach of SID node for situations like a
6300 * previously "scsinodev" LUN0 coming into existence (or a
6301 * disk/tape on an SPI transport at same addr but never both
6302 * powered on at the same time). Try to autodetach the existing
6303 * SID node @addr. If that works, search again - otherwise fail.
6304 */
6305 SCSI_HBA_LOG((_LOG(2), NULL, dsearch,
6306 "looking for %s@%s: SID @addr exists, autodetach",
6307 name ? name : "", addr));
6308 if (!scsi_hba_remove_node(dsearch)) {
6309 SCSI_HBA_LOG((_LOG(2), NULL, dsearch,
6310 "autodetach @%s failed: fail %s@%s",
6311 addr, name ? name : "", addr));
6312 goto fail;
6313 }
6314 SCSI_HBA_LOG((_LOG(2), self, NULL, "autodetach @%s OK", addr));
6315 }
6316
6317 /*
6318 * We will be creating a new SID node, allocate probe node
6319 * used to find out information about the device located @addr.
6320 * The probe node also acts as a barrier against additional
6321 * configuration at the same address, and in the case of non-existent
6322 * devices it will (for some amount of time) avoid re-learning that
6323 * the device does not exist on every reference. Once the probe
6324 * node is DS_LINKED we can drop the HBA (self).
6325 *
6326 * The probe node is allocated as a hidden node so that it does not
6327 * show up in devinfo snapshots.
6328 */
6329 ndi_devi_alloc_sleep(self, "probe",
6330 (se == SE_HP) ? DEVI_SID_HP_HIDDEN_NODEID : DEVI_SID_HIDDEN_NODEID,
6331 &probe);
6332 ASSERT(probe);
6333 ndi_flavor_set(probe, SCSA_FLAVOR_SCSI_DEVICE);
6334
6335 /*
6336 * Decorate the probe node with the property representation of @addr
6337 * unit-address string prior to initchild so that initchild can
6338 * construct the name of the node from properties and tran_tgt_init
6339 * implementation can determine what LUN is being referenced.
6340 *
6341 * If the addr specified has incorrect syntax (busconfig one of bogus
6342 * /devices path) then scsi_hba_ua_set can fail. If the address
6343 * is not understood by the SCSA HBA driver then this operation will
6344 * work, but tran_tgt_init may still fail (for example the HBA
6345 * driver may not support secondary functions).
6346 */
6347 if (scsi_hba_ua_set(addr, probe, NULL) == 0) {
6348 SCSI_HBA_LOG((_LOG(2), NULL, probe,
6349 "@%s failed scsi_hba_ua_set", addr));
6350 goto fail;
6351 }
6352
6353 /*
6354 * Set the class property to "scsi". This is sufficient to distinguish
6355 * the node for HBAs that have multiple classes of children (like uata
6356 * - which has "dada" class for ATA children and "scsi" class for
6357 * ATAPI children) and may not use our scsi_busctl_initchild()
6358 * implementation. We also add a "compatible" property of "scsiprobe"
6359 * to select the probe driver.
6360 */
6361 if ((ndi_prop_update_string(DDI_DEV_T_NONE, probe,
6362 "class", "scsi") != DDI_PROP_SUCCESS) ||
6363 (ndi_prop_update_string_array(DDI_DEV_T_NONE, probe,
6364 "compatible", &compatible_probe, 1) != DDI_PROP_SUCCESS)) {
6365 SCSI_HBA_LOG((_LOG(1), NULL, probe,
6366 "@%s failed node decoration", addr));
6367 goto fail;
6368 }
6369
6370 /*
6371 * Promote probe node to DS_INITIALIZED so that transport can be used
6372 * for scsi_probe. After this the node is linked and visible as a
6373 * barrier for serialization of other @addr operations.
6374 *
6375 * NOTE: If we attached the probe node, we could get rid of
6376 * uninit_prevent.
6377 */
6378 if (ddi_initchild(self, probe) != DDI_SUCCESS) {
6379 SCSI_HBA_LOG((_LOG(2), NULL, probe,
6380 "@%s failed initchild", addr));
6381
6382 /* probe node will be removed in fail exit path */
6383 goto fail;
6384 }
6385
6386 /* get the scsi_device structure of the probe node */
6387 sdprobe = ddi_get_driver_private(probe);
6388 ASSERT(sdprobe);
6389
6390 /*
6391 * Do scsi_probe. The probe node is linked and visible as a barrier.
6392 * We prevent uninitialization of the probe node and drop our HBA (self)
6393 * while we run scsi_probe() of this "@addr". This allows the framework
6394 * to support multiple scsi_probes for different devices attached to
6395 * the same HBA (self) in parallel. We prevent node demotion of the
6396 * probe node from DS_INITIALIZED by setting sd_uninit_prevent. The
6397 * probe node can not be successfully demoted below DS_INITIALIZED
6398 * (scsi_busctl_uninitchild will fail) until we zero sd_uninit_prevent
6399 * as we are freeing the node via scsi_hba_remove_node(probe).
6400 */
6401 sdprobe->sd_uninit_prevent++;
6402 scsi_hba_devi_exit(self, *enteredvp);
6403 sp = scsi_probe(sdprobe, SLEEP_FUNC);
6404
6405 /* Introduce a small delay here to increase parallelism. */
6406 delay_random(5);
6407
6408 if (sp == SCSIPROBE_EXISTS) {
6409 /*
6410 * For a device that exists, while still running in parallel,
6411 * also get identity information from device. This is done
6412 * separate from scsi_probe/tran_tgt_probe/scsi_hba_probe
6413 * since the probe code path may still be used for HBAs
6414 * that don't use common bus_config services (we don't want
6415 * to expose that code path to a behavior change). This
6416 * operation is called 'identity' to avoid confusion with
6417 * deprecated identify(9E).
6418 *
6419 * Future: We may eventually want to allow HBA customization via
6420 * scsi_identity/tran_tgt_identity/scsi_device_identity, but for
6421 * now we just scsi_device_identity.
6422 *
6423 * The identity operation will establish additional properties
6424 * on the probe node related to device identity:
6425 *
6426 * "inquiry-page-80" byte array of SCSI page 80
6427 * "inquiry-page-83" byte array of SCSI page 83
6428 *
6429 * These properties will be used to generate a devid
6430 * (ddi_devid_scsi_encode) and guid - and to register
6431 * (ddi_devid_register) a devid for the device.
6432 *
6433 * If identify fails (non-zero return), the we had allocation
6434 * problems or the device returned inconsistent results then
6435 * we pretend that device does not exist.
6436 */
6437 if (scsi_device_identity(sdprobe, SLEEP_FUNC)) {
6438 scsi_enumeration_failed(probe, -1, NULL, "identify");
6439 sp = SCSIPROBE_FAILURE;
6440 }
6441
6442 /*
6443 * Future: Is there anything more we can do here to help avoid
6444 * serialization on iport parent during scsi_device attach(9E)?
6445 */
6446 }
6447 scsi_hba_devi_enter(self, enteredvp);
6448 sdprobe->sd_uninit_prevent--;
6449
6450 if (sp != SCSIPROBE_EXISTS) {
6451 scsi_enumeration_failed(probe, -1, NULL, "probe");
6452
6453 if ((se != SE_HP) && scsi_hba_barrier_timeout) {
6454 /*
6455 * Target does not exist. Mark the barrier probe node
6456 * as DEVICE_REMOVED and schedule an asynchronous
6457 * deletion of the node in scsi_hba_barrier_timeout
6458 * seconds. We keep our hold on the probe node
6459 * until we are ready perform the asynchronous node
6460 * deletion.
6461 */
6462 SCSI_HBA_LOG((_LOG(3), NULL, probe,
6463 "set probe DEVICE_REMOVED"));
6464 mutex_enter(&DEVI(probe)->devi_lock);
6465 DEVI_SET_DEVICE_REMOVED(probe);
6466 mutex_exit(&DEVI(probe)->devi_lock);
6467
6468 scsi_hba_barrier_add(probe, scsi_hba_barrier_timeout);
6469 probe = NULL;
6470 }
6471 goto fail;
6472 }
6473
6474 /* Create the child node from the inquiry data in the probe node. */
6475 if ((child = scsi_device_configchild(self, addr, se, sdprobe,
6476 &pi)) == NULL) {
6477 /*
6478 * This may fail because there was no driver binding identified
6479 * via driver_alias. We may still have a conf node.
6480 */
6481 if (name) {
6482 (void) scsi_findchild(self, name, addr,
6483 0, &child, NULL, &pi);
6484 if (child)
6485 SCSI_HBA_LOG((_LOG(2), NULL, child,
6486 "using driver.conf driver binding"));
6487 }
6488 if (child == NULL) {
6489 SCSI_HBA_LOG((_LOG(2), NULL, probe,
6490 "device not configured"));
6491 goto fail;
6492 }
6493 }
6494
6495 /*
6496 * Transfer the inquiry data from the probe node to the child
6497 * SID node to avoid an extra scsi_probe. Callers depend on
6498 * established inquiry data for the returned scsi_device.
6499 */
6500 sdchild = ddi_get_driver_private(child);
6501 if (sdchild && (sdchild->sd_inq == NULL)) {
6502 sdchild->sd_inq = sdprobe->sd_inq;
6503 sdprobe->sd_inq = NULL;
6504 }
6505
6506 /*
6507 * If we are doing a bus_configone and the node we created has the
6508 * wrong node and driver name then switch the return result to a
6509 * driver.conf node with the correct name - if such a node exists.
6510 */
6511 if (name && (strcmp(ddi_node_name(child), name) != 0) &&
6512 (strcmp(ddi_driver_name(child), name) != 0)) {
6513 (void) scsi_findchild(self, name, addr,
6514 0, &dsearch, NULL, &pi);
6515 if (dsearch == NULL) {
6516 SCSI_HBA_LOG((_LOG(2), NULL, child,
6517 "wrong device configured %s@%s", name, addr));
6518 /*
6519 * We can't remove when modrootloaded == 0 in case
6520 * boot-device a uses generic name and
6521 * scsi_hba_nodename_compatible_get() returned a
6522 * legacy binding-set driver oriented name.
6523 */
6524 if (modrootloaded) {
6525 (void) scsi_hba_remove_node(child);
6526 child = NULL;
6527 goto fail;
6528 }
6529 } else {
6530 SCSI_HBA_LOG((_LOG(2), NULL, dsearch,
6531 "device configured, but switching to driver.conf"));
6532 child = dsearch;
6533 }
6534 }
6535
6536 /* get the scsi_device structure from the node */
6537 SCSI_HBA_LOG((_LOG(3), NULL, child, "device configured"));
6538
6539 if (child) {
6540 done: ASSERT(child);
6541 sdchild = ddi_get_driver_private(child);
6542 ASSERT(sdchild);
6543
6544 /*
6545 * We may have ended up here after promotion of a previously
6546 * demoted node, where demotion deleted sd_inq data in
6547 * scsi_busctl_uninitchild. We redo the scsi_probe() to
6548 * reestablish sd_inq. We also want to redo the scsi_probe
6549 * for devices are currently device_isremove in order to
6550 * detect new device_insert.
6551 */
6552 if ((sdchild->sd_inq == NULL) ||
6553 ((pi == 0) && ndi_devi_device_isremoved(child))) {
6554
6555 /* hotplug_node can only be revived via hotplug. */
6556 if ((se == SE_HP) || !ndi_dev_is_hotplug_node(child)) {
6557 SCSI_HBA_LOG((_LOG(3), NULL, child,
6558 "scsi_probe() demoted devinfo"));
6559
6560 sp = scsi_probe(sdchild, SLEEP_FUNC);
6561
6562 if (sp == SCSIPROBE_EXISTS) {
6563 ASSERT(sdchild->sd_inq);
6564
6565 /*
6566 * Devinfo child exists and we are
6567 * talking to the device, report
6568 * reinsert and note if this was a
6569 * new reinsert.
6570 */
6571 chg = ndi_devi_device_insert(child);
6572 SCSI_HBA_LOG((_LOGCFG, NULL, child,
6573 "devinfo %s@%s device_reinsert%s",
6574 name ? name : "", addr,
6575 chg ? "" : "ed already"));
6576 } else {
6577 scsi_enumeration_failed(child, se,
6578 NULL, "reprobe");
6579
6580 chg = ndi_devi_device_remove(child);
6581 SCSI_HBA_LOG((_LOG(2), NULL, child,
6582 "%s device_remove%s",
6583 (sp > (sizeof (scsi_probe_ascii) /
6584 sizeof (scsi_probe_ascii[0]))) ?
6585 "UNKNOWN" : scsi_probe_ascii[sp],
6586 chg ? "" : "ed already"));
6587
6588 child = NULL;
6589 sdchild = NULL;
6590 }
6591 } else {
6592 SCSI_HBA_LOG((_LOG(2), NULL, child,
6593 "no reprobe"));
6594
6595 child = NULL;
6596 sdchild = NULL;
6597 }
6598 }
6599 } else {
6600 fail: ASSERT(child == NULL);
6601 sdchild = NULL;
6602 }
6603 if (probe) {
6604 /*
6605 * Clean up probe node, destroying node if uninit_prevent
6606 * it is going to zero. Destroying the probe node (deleting
6607 * from the sibling list) will wake up any people waiting on
6608 * the probe node barrier.
6609 */
6610 SCSI_HBA_LOG((_LOG(4), NULL, probe, "remove probe"));
6611 if (!scsi_hba_remove_node(probe)) {
6612 /*
6613 * Probe node removal should not fail, but if it
6614 * does we hand that responsibility over to the
6615 * async barrier deletion thread - other references
6616 * to the same unit-address can hang until the
6617 * probe node delete completes.
6618 */
6619 SCSI_HBA_LOG((_LOG(4), NULL, probe,
6620 "remove probe failed, go async"));
6621 scsi_hba_barrier_add(probe, 1);
6622 }
6623 probe = NULL;
6624 }
6625
6626 /*
6627 * If we successfully resolved via a pathinfo node, we need to find
6628 * the pathinfo node and ensure that it is online (if possible). This
6629 * is done for the case where the device was open when
6630 * scsi_device_unconfig occurred, so mdi_pi_free did not occur. If the
6631 * device has now been reinserted, we want the path back online.
6632 * NOTE: This needs to occur after destruction of the probe node to
6633 * avoid ASSERT related to two nodes at the same unit-address.
6634 */
6635 if (sdchild && pi && (probe == NULL)) {
6636 ASSERT(MDI_PHCI(self));
6637
6638 (void) scsi_findchild(self, NULL, addr,
6639 0, &dsearch, &psearch, NULL);
6640 ASSERT((psearch == NULL) ||
6641 (mdi_pi_get_client(psearch) == child));
6642
6643 if (psearch && mdi_pi_device_isremoved(psearch)) {
6644 /*
6645 * Verify that we can talk to the device, and if
6646 * so note if this is a new device_insert.
6647 *
6648 * NOTE: We depend on mdi_path_select(), when given
6649 * a specific path_instance, to select that path
6650 * even if the path is offline.
6651 *
6652 * NOTE: A Client node is not ndi_dev_is_hotplug_node().
6653 */
6654 if (se == SE_HP) {
6655 SCSI_HBA_LOG((_LOG(3), NULL, child,
6656 "%s scsi_probe() demoted pathinfo",
6657 mdi_pi_spathname(psearch)));
6658
6659 sp = scsi_hba_probe_pi(sdchild, SLEEP_FUNC, pi);
6660
6661 if (sp == SCSIPROBE_EXISTS) {
6662 /*
6663 * Pathinfo child exists and we are
6664 * talking to the device, report
6665 * reinsert and note if this
6666 * was a new reinsert.
6667 */
6668 chg = mdi_pi_device_insert(psearch);
6669 SCSI_HBA_LOG((_LOGCFG, self, NULL,
6670 "pathinfo %s device_reinsert%s",
6671 mdi_pi_spathname(psearch),
6672 chg ? "" : "ed already"));
6673
6674 if (chg)
6675 (void) mdi_pi_online(psearch,
6676 0);
6677
6678 /*
6679 * Report client reinsert and note if
6680 * this was a new reinsert.
6681 */
6682 chg = ndi_devi_device_insert(child);
6683 SCSI_HBA_LOG((_LOGCFG, NULL, child,
6684 "client devinfo %s@%s "
6685 "device_reinsert%s",
6686 name ? name : "", addr,
6687 chg ? "" : "ed already"));
6688 } else {
6689 scsi_enumeration_failed(child, se,
6690 mdi_pi_spathname(psearch),
6691 "reprobe");
6692 child = NULL;
6693 sdchild = NULL;
6694 }
6695
6696 } else {
6697 SCSI_HBA_LOG((_LOG(2), NULL, child,
6698 "%s no reprobe",
6699 mdi_pi_spathname(psearch)));
6700
6701 child = NULL;
6702 sdchild = NULL;
6703 }
6704 }
6705 }
6706
6707 /* If asked for path_instance, return it. */
6708 if (ppi)
6709 *ppi = pi;
6710
6711 return (sdchild);
6712 }
6713
6714 static void
scsi_device_unconfig(dev_info_t * self,char * addr)6715 scsi_device_unconfig(dev_info_t *self, char *addr)
6716 {
6717 dev_info_t *child = NULL;
6718 mdi_pathinfo_t *path = NULL;
6719 char *spathname;
6720 int rval;
6721
6722 ASSERT(self && addr && DEVI_BUSY_OWNED(self));
6723
6724 /*
6725 * We have a catch-22. We may have a demoted node that we need to find
6726 * and offline/remove. To find the node if it isn't demoted, we
6727 * use scsi_findchild. If it's demoted, we then use
6728 * ndi_devi_findchild_by_callback.
6729 */
6730 (void) scsi_findchild(self, NULL, addr, 0, &child, &path, NULL);
6731
6732 if ((child == NULL) && (path == NULL)) {
6733 child = ndi_devi_findchild_by_callback(self, NULL, addr,
6734 scsi_busctl_ua);
6735 if (child) {
6736 SCSI_HBA_LOG((_LOGUNCFG, self, NULL,
6737 "devinfo @%s found by callback",
6738 addr));
6739 ASSERT(ndi_flavor_get(child) ==
6740 SCSA_FLAVOR_SCSI_DEVICE);
6741 if (ndi_flavor_get(child) != SCSA_FLAVOR_SCSI_DEVICE) {
6742 SCSI_HBA_LOG((_LOGUNCFG, self, NULL,
6743 "devinfo @%s not SCSI_DEVICE flavored",
6744 addr));
6745 child = NULL;
6746 }
6747 }
6748 }
6749
6750 if (child) {
6751 ASSERT(child && (path == NULL));
6752
6753 /* Don't unconfig probe nodes. */
6754 if (scsi_hba_devi_is_barrier(child)) {
6755 SCSI_HBA_LOG((_LOGUNCFG, self, NULL,
6756 "devinfo @%s is_barrier, skip",
6757 addr));
6758 return;
6759 }
6760
6761 /* Attempt to offline/remove the devinfo node */
6762 if (ndi_devi_offline(child,
6763 NDI_DEVFS_CLEAN | NDI_DEVI_REMOVE) == DDI_SUCCESS) {
6764 SCSI_HBA_LOG((_LOGUNCFG, self, NULL,
6765 "devinfo @%s offlined and removed",
6766 addr));
6767 } else if (ndi_devi_device_remove(child)) {
6768 /* Offline/remove failed, note new device_remove */
6769 SCSI_HBA_LOG((_LOGUNCFG, self, NULL,
6770 "devinfo @%s offline failed, device_remove",
6771 addr));
6772 }
6773 } else if (path) {
6774 ASSERT(path && (child == NULL));
6775
6776 /*
6777 * Attempt to offline/remove the pathinfo node.
6778 *
6779 * NOTE: mdi_pi_offline of last path will fail if the
6780 * device is open (i.e. the client can't be offlined).
6781 *
6782 * NOTE: For mdi there is no REMOVE flag for mdi_pi_offline().
6783 * When mdi_pi_offline returns MDI_SUCCESS, we are responsible
6784 * for remove via mdi_pi_free().
6785 */
6786 mdi_hold_path(path);
6787 spathname = mdi_pi_spathname(path); /* valid after free */
6788 scsi_hba_devi_exit_phci(self);
6789 rval = mdi_pi_offline(path, 0);
6790 scsi_hba_devi_enter_phci(self);
6791
6792 /* Note new device_remove */
6793 if (mdi_pi_device_remove(path))
6794 SCSI_HBA_LOG((_LOGUNCFG, self, NULL,
6795 "pathinfo %s note device_remove", spathname));
6796
6797 mdi_rele_path(path);
6798 if (rval == MDI_SUCCESS) {
6799 (void) mdi_pi_free(path, 0);
6800 SCSI_HBA_LOG((_LOGUNCFG, self, NULL,
6801 "pathinfo %s offlined, then freed", spathname));
6802 }
6803 } else {
6804 ASSERT((path == NULL) && (child == NULL));
6805
6806 SCSI_HBA_LOG((_LOGUNCFG, self, NULL, "@%s not found", addr));
6807 }
6808 }
6809
6810 /*
6811 * configure the device at the specified "@addr" address.
6812 */
6813 static struct scsi_device *
scsi_hba_bus_configone_addr(dev_info_t * self,char * addr,scsi_enum_t se)6814 scsi_hba_bus_configone_addr(dev_info_t *self, char *addr, scsi_enum_t se)
6815 {
6816 boolean_t enteredv;
6817 struct scsi_device *sd;
6818
6819 scsi_hba_devi_enter(self, &enteredv);
6820 sd = scsi_device_config(self, NULL, addr, se, &enteredv, NULL);
6821 scsi_hba_devi_exit(self, enteredv);
6822 return (sd);
6823 }
6824
6825 /*
6826 * unconfigure the device at the specified "@addr" address.
6827 */
6828 static void
scsi_hba_bus_unconfigone_addr(dev_info_t * self,char * addr)6829 scsi_hba_bus_unconfigone_addr(dev_info_t *self, char *addr)
6830 {
6831 boolean_t enteredv;
6832
6833 scsi_hba_devi_enter(self, &enteredv);
6834 (void) scsi_device_unconfig(self, addr);
6835 scsi_hba_devi_exit(self, enteredv);
6836 }
6837
6838 /*
6839 * The bus_config_all operations are multi-threaded for performance. A
6840 * separate thread per target and per LUN is used. The config handle is used
6841 * to coordinate all the threads at a given level and the config thread data
6842 * contains the required information for a specific thread to identify what it
6843 * is processing and the handle under which this is being processed.
6844 */
6845
6846 /* multi-threaded config handle */
6847 struct scsi_hba_mte_h {
6848 dev_info_t *h_self; /* initiator port */
6849 int h_thr_count;
6850 kmutex_t h_lock;
6851 kcondvar_t h_cv;
6852 };
6853
6854 /* target of 'self' config thread data */
6855 struct scsi_hba_mte_td {
6856 struct scsi_hba_mte_h *td_h;
6857 char *td_taddr; /* target port */
6858 int td_mt;
6859 scsi_enum_t td_se;
6860 };
6861
6862 /* Invoke callback on a vector of taddrs from multiple threads */
6863 static void
scsi_hba_thread_taddrs(dev_info_t * self,char ** taddrs,int mt,scsi_enum_t se,void (* callback)(void * arg))6864 scsi_hba_thread_taddrs(dev_info_t *self, char **taddrs, int mt,
6865 scsi_enum_t se, void (*callback)(void *arg))
6866 {
6867 struct scsi_hba_mte_h *h; /* HBA header */
6868 struct scsi_hba_mte_td *td; /* target data */
6869 char **taddr;
6870
6871 /* allocate and initialize the handle */
6872 h = kmem_zalloc(sizeof (*h), KM_SLEEP);
6873 mutex_init(&h->h_lock, NULL, MUTEX_DEFAULT, NULL);
6874 cv_init(&h->h_cv, NULL, CV_DEFAULT, NULL);
6875 h->h_self = self;
6876
6877 /* loop over all the targets */
6878 for (taddr = taddrs; *taddr; taddr++) {
6879 /* allocate a thread data structure for target */
6880 td = kmem_alloc(sizeof (*td), KM_SLEEP);
6881 td->td_h = h;
6882 td->td_taddr = *taddr;
6883 td->td_mt = mt;
6884 td->td_se = se;
6885
6886 /* process the target */
6887 mutex_enter(&h->h_lock);
6888 h->h_thr_count++;
6889 mutex_exit(&h->h_lock);
6890
6891 if (mt & SCSI_ENUMERATION_MT_TARGET_DISABLE)
6892 callback((void *)td);
6893 else
6894 (void) thread_create(NULL, 0, callback, (void *)td,
6895 0, &p0, TS_RUN, minclsyspri);
6896 }
6897
6898 /* wait for all the target threads to complete */
6899 mutex_enter(&h->h_lock);
6900 while (h->h_thr_count > 0)
6901 cv_wait(&h->h_cv, &h->h_lock);
6902 mutex_exit(&h->h_lock);
6903
6904 /* free the handle */
6905 cv_destroy(&h->h_cv);
6906 mutex_destroy(&h->h_lock);
6907 kmem_free(h, sizeof (*h));
6908 }
6909
6910
6911 /* lun/secondary function of lun0 config thread data */
6912 struct scsi_hba_mte_ld {
6913 struct scsi_hba_mte_h *ld_h;
6914 char *ld_taddr; /* target port */
6915 scsi_lun64_t ld_lun64; /* lun */
6916 int ld_sfunc; /* secondary function */
6917 scsi_enum_t ld_se;
6918 };
6919
6920 /*
6921 * Enumerate the LUNs and secondary functions of the specified target. The
6922 * target portion of the "@addr" is already represented as a string in the
6923 * thread data, we add a ",lun" representation to this and perform a
6924 * bus_configone byte of enumeration on that "@addr".
6925 */
6926 static void
scsi_hba_enum_lsf_of_tgt_thr(void * arg)6927 scsi_hba_enum_lsf_of_tgt_thr(void *arg)
6928 {
6929 struct scsi_hba_mte_ld *ld = (struct scsi_hba_mte_ld *)arg;
6930 struct scsi_hba_mte_h *h = ld->ld_h;
6931 dev_info_t *self = h->h_self;
6932 char addr[SCSI_MAXNAMELEN];
6933
6934 /* make string form of "@taddr,lun[,sfunc]" and see if it exists */
6935 if (ld->ld_sfunc == -1)
6936 (void) snprintf(addr, sizeof (addr),
6937 "%s,%" PRIx64, ld->ld_taddr, ld->ld_lun64);
6938 else
6939 (void) snprintf(addr, sizeof (addr),
6940 "%s,%" PRIx64 ",%x",
6941 ld->ld_taddr, ld->ld_lun64, ld->ld_sfunc);
6942
6943 /* configure device at that unit-address address */
6944 (void) scsi_hba_bus_configone_addr(self, addr, ld->ld_se);
6945
6946 /* signal completion of this LUN thread to the target */
6947 mutex_enter(&h->h_lock);
6948 if (--h->h_thr_count == 0)
6949 cv_broadcast(&h->h_cv);
6950 mutex_exit(&h->h_lock);
6951
6952 /* free config thread data */
6953 kmem_free(ld, sizeof (*ld));
6954 }
6955
6956 /* Format of SCSI REPORT_LUNS report */
6957 typedef struct scsi_lunrpt {
6958 uchar_t lunrpt_len_msb; /* # LUNs being reported */
6959 uchar_t lunrpt_len_mmsb;
6960 uchar_t lunrpt_len_mlsb;
6961 uchar_t lunrpt_len_lsb;
6962 uchar_t lunrpt_reserved[4];
6963 scsi_lun_t lunrpt_luns[1]; /* LUNs, variable size */
6964 } scsi_lunrpt_t;
6965
6966 /*
6967 * scsi_device_reportluns()
6968 *
6969 * Callers of this routine should ensure that the 'sd0' scsi_device structure
6970 * and 'pi' path_instance specified are associated with a responding LUN0.
6971 * This should not be called for SCSI-1 devices.
6972 *
6973 * To get a LUN report, we must allocate a buffer. To know how big to make the
6974 * buffer, we must know the number of LUNs. To know the number of LUNs, we must
6975 * get a LUN report. We first issue a SCMD_REPORT_LUNS command using a
6976 * reasonably sized buffer that's big enough to report all LUNs for most
6977 * typical devices. If it turns out that we needed a bigger buffer, we attempt
6978 * to allocate a buffer of sufficient size, and reissue the command. If the
6979 * first command succeeds, but the second fails, we return whatever we were
6980 * able to get the first time. We return enough information for the caller to
6981 * tell whether they got all the LUNs or only a subset.
6982 *
6983 * If successful, we allocate an array of scsi_lun_t to hold the results. The
6984 * caller must kmem_free(*lunarrayp, *sizep) when finished with it. Upon
6985 * successful return return value is NDI_SUCCESS and:
6986 *
6987 * *lunarrayp points to the allocated array,
6988 * *nlunsp is the number of valid LUN entries in the array,
6989 * *tlunsp is the total number of LUNs in the target,
6990 * *sizep is the size of the lunarrayp array, which must be freed.
6991 *
6992 * If the *nlunsp is less than *tlunsp, then we were only able to retrieve a
6993 * subset of the total set of LUNs in the target.
6994 */
6995 static int
scsi_device_reportluns(struct scsi_device * sd0,char * taddr,int pi,scsi_lun_t ** lunarrayp,uint32_t * nlunsp,uint32_t * tlunsp,size_t * sizep)6996 scsi_device_reportluns(struct scsi_device *sd0, char *taddr, int pi,
6997 scsi_lun_t **lunarrayp, uint32_t *nlunsp, uint32_t *tlunsp, size_t *sizep)
6998 {
6999 struct buf *lunrpt_bp;
7000 struct scsi_pkt *lunrpt_pkt;
7001 scsi_lunrpt_t *lunrpt;
7002 uint32_t bsize;
7003 uint32_t tluns, nluns;
7004 int default_maxluns = scsi_lunrpt_default_max;
7005 dev_info_t *child;
7006
7007 ASSERT(sd0 && lunarrayp && nlunsp && tlunsp && sizep);
7008
7009 /*
7010 * NOTE: child should only be used in SCSI_HBA_LOG context since with
7011 * vHCI enumeration it may be the vHCI 'client' devinfo child instead
7012 * of a child of the 'self' pHCI we are enumerating.
7013 */
7014 child = sd0->sd_dev;
7015
7016 /* first try, look for up to scsi_lunrpt_default_max LUNs */
7017 nluns = default_maxluns;
7018
7019 again: bsize = sizeof (struct scsi_lunrpt) +
7020 ((nluns - 1) * sizeof (struct scsi_lun));
7021
7022 lunrpt_bp = scsi_alloc_consistent_buf(&sd0->sd_address,
7023 (struct buf *)NULL, bsize, B_READ, SLEEP_FUNC, NULL);
7024 if (lunrpt_bp == NULL) {
7025 SCSI_HBA_LOG((_LOG(1), NULL, child, "failed alloc"));
7026 return (NDI_NOMEM);
7027 }
7028
7029 lunrpt_pkt = scsi_init_pkt(&sd0->sd_address,
7030 (struct scsi_pkt *)NULL, lunrpt_bp, CDB_GROUP5,
7031 sizeof (struct scsi_arq_status), 0, PKT_CONSISTENT,
7032 SLEEP_FUNC, NULL);
7033 if (lunrpt_pkt == NULL) {
7034 SCSI_HBA_LOG((_LOG(1), NULL, child, "failed init"));
7035 scsi_free_consistent_buf(lunrpt_bp);
7036 return (NDI_NOMEM);
7037 }
7038
7039 (void) scsi_setup_cdb((union scsi_cdb *)lunrpt_pkt->pkt_cdbp,
7040 SCMD_REPORT_LUNS, 0, bsize, 0);
7041
7042 lunrpt_pkt->pkt_time = scsi_lunrpt_timeout;
7043
7044 /*
7045 * When sd0 is a vHCI scsi device, we need reportlun to be issued
7046 * against a specific LUN0 path_instance that we are enumerating.
7047 */
7048 lunrpt_pkt->pkt_path_instance = pi;
7049 lunrpt_pkt->pkt_flags |= FLAG_PKT_PATH_INSTANCE;
7050
7051 /*
7052 * NOTE: scsi_poll may not allow HBA specific recovery from TRAN_BUSY.
7053 */
7054 if (scsi_poll(lunrpt_pkt) < 0) {
7055 SCSI_HBA_LOG((_LOG(2), NULL, child, "reportlun not supported"));
7056 scsi_destroy_pkt(lunrpt_pkt);
7057 scsi_free_consistent_buf(lunrpt_bp);
7058 return (NDI_FAILURE);
7059 }
7060
7061 scsi_destroy_pkt(lunrpt_pkt);
7062
7063 lunrpt = (scsi_lunrpt_t *)lunrpt_bp->b_un.b_addr;
7064
7065 /* Compute the total number of LUNs in the target */
7066 tluns = (((uint_t)lunrpt->lunrpt_len_msb << 24) |
7067 ((uint_t)lunrpt->lunrpt_len_mmsb << 16) |
7068 ((uint_t)lunrpt->lunrpt_len_mlsb << 8) |
7069 ((uint_t)lunrpt->lunrpt_len_lsb)) >> 3;
7070
7071 if (tluns == 0) {
7072 /* Illegal response -- this target is broken */
7073 SCSI_HBA_LOG((_LOG(1), NULL, child, "illegal tluns of zero"));
7074 scsi_free_consistent_buf(lunrpt_bp);
7075 return (DDI_NOT_WELL_FORMED);
7076 }
7077
7078 if (tluns > nluns) {
7079 /* have more than we allocated space for */
7080 if (nluns == default_maxluns) {
7081 /* first time around, reallocate larger */
7082 scsi_free_consistent_buf(lunrpt_bp);
7083 nluns = tluns;
7084 goto again;
7085 }
7086
7087 /* uh oh, we got a different tluns the second time! */
7088 SCSI_HBA_LOG((_LOG(1), NULL, child,
7089 "tluns changed from %d to %d", nluns, tluns));
7090 } else
7091 nluns = tluns;
7092
7093 /*
7094 * Now we have:
7095 * lunrpt_bp is the buffer we're using;
7096 * tluns is the total number of LUNs the target says it has;
7097 * nluns is the number of LUNs we were able to get into the buffer.
7098 *
7099 * Copy the data out of scarce iopb memory into regular kmem.
7100 * The caller must kmem_free(*lunarrayp, *sizep) when finished with it.
7101 */
7102 *lunarrayp = (scsi_lun_t *)kmem_alloc(
7103 nluns * sizeof (scsi_lun_t), KM_SLEEP);
7104 if (*lunarrayp == NULL) {
7105 SCSI_HBA_LOG((_LOG(1), NULL, child, "NULL lunarray"));
7106 scsi_free_consistent_buf(lunrpt_bp);
7107 return (NDI_NOMEM);
7108 }
7109
7110 *sizep = nluns * sizeof (scsi_lun_t);
7111 *nlunsp = nluns;
7112 *tlunsp = tluns;
7113 bcopy((void *)&lunrpt->lunrpt_luns, (void *)*lunarrayp, *sizep);
7114 scsi_free_consistent_buf(lunrpt_bp);
7115 SCSI_HBA_LOG((_LOG(3), NULL, child,
7116 "@%s,0 path %d: %d/%d luns", taddr, pi, nluns, tluns));
7117 return (NDI_SUCCESS);
7118 }
7119
7120 /*
7121 * Enumerate all the LUNs and secondary functions of the specified 'taddr'
7122 * target port as accessed via 'self' pHCI. Note that sd0 may be associated
7123 * with a child of the vHCI instead of 'self' - in this case the 'pi'
7124 * path_instance is used to ensure that the SCMD_REPORT_LUNS command is issued
7125 * through the 'self' pHCI path.
7126 *
7127 * We multi-thread across all the LUNs and secondary functions and enumerate
7128 * them. Which LUNs exist is based on SCMD_REPORT_LUNS data.
7129 *
7130 * The scsi_device we are called with should be for LUN0 and has been probed.
7131 *
7132 * This function is structured so that an HBA that has a different target
7133 * addressing structure can still use this function to enumerate the its
7134 * LUNs if it uses "taddr,lun" for its LUN space.
7135 *
7136 * We make assumptions about other LUNs associated with the target:
7137 *
7138 * For SCSI-2 and SCSI-3 target we will issue the SCSI report_luns
7139 * command. If this fails or we have a SCSI-1 then the number of
7140 * LUNs is determined based on SCSI_OPTIONS_NLUNS. For a SCSI-1
7141 * target we never probe above LUN 8, even if SCSI_OPTIONS_NLUNS
7142 * indicates we should.
7143 *
7144 * HBA drivers wanting a different set of assumptions should implement their
7145 * own LUN enumeration code.
7146 */
7147 static int
scsi_hba_enum_lsf_of_t(struct scsi_device * sd0,dev_info_t * self,char * taddr,int pi,int mt,scsi_enum_t se)7148 scsi_hba_enum_lsf_of_t(struct scsi_device *sd0,
7149 dev_info_t *self, char *taddr, int pi, int mt, scsi_enum_t se)
7150 {
7151 dev_info_t *child;
7152 scsi_hba_tran_t *tran;
7153 impl_scsi_tgtmap_t *tgtmap;
7154 damap_id_t tgtid;
7155 damap_t *tgtdam;
7156 damap_t *lundam = NULL;
7157 struct scsi_hba_mte_h *h;
7158 struct scsi_hba_mte_ld *ld;
7159 int aver;
7160 scsi_lun_t *lunp = NULL;
7161 int lun;
7162 uint32_t nluns;
7163 uint32_t tluns;
7164 size_t size;
7165 scsi_lun64_t lun64;
7166 int maxluns;
7167
7168 /*
7169 * If LUN0 failed then we have no other LUNs.
7170 *
7171 * NOTE: We need sd_inq to be valid to check ansi version. Since
7172 * scsi_unprobe is now a noop (sd_inq freeded in
7173 * scsi_busctl_uninitchild) sd_inq remains valid even if a target
7174 * driver detach(9E) occurs, resulting in a scsi_unprobe call
7175 * (sd_uninit_prevent keeps sd_inq valid by failing any
7176 * device_uninitchild attempts).
7177 */
7178 ASSERT(sd0 && sd0->sd_uninit_prevent && sd0->sd_dev && sd0->sd_inq);
7179 if ((sd0 == NULL) || (sd0->sd_dev == NULL) || (sd0->sd_inq == NULL)) {
7180 SCSI_HBA_LOG((_LOG(1), NULL, sd0 ? sd0->sd_dev : NULL,
7181 "not setup correctly:%s%s%s",
7182 (sd0 == NULL) ? " device" : "",
7183 (sd0 && (sd0->sd_dev == NULL)) ? " dip" : "",
7184 (sd0 && (sd0->sd_inq == NULL)) ? " inq" : ""));
7185 return (DDI_FAILURE);
7186 }
7187
7188 /*
7189 * NOTE: child should only be used in SCSI_HBA_LOG context since with
7190 * vHCI enumeration it may be the vHCI 'client' devinfo child instead
7191 * of a child of the 'self' pHCI we are enumerating.
7192 */
7193 child = sd0->sd_dev;
7194
7195 /* Determine if we are reporting lun observations into lunmap. */
7196 tran = ndi_flavorv_get(self, SCSA_FLAVOR_SCSI_DEVICE);
7197 tgtmap = (impl_scsi_tgtmap_t *)tran->tran_tgtmap;
7198 if (tgtmap) {
7199 tgtdam = tgtmap->tgtmap_dam[SCSI_TGT_SCSI_DEVICE];
7200 tgtid = damap_lookup(tgtdam, taddr);
7201 if (tgtid != NODAM) {
7202 lundam = damap_id_priv_get(tgtdam, tgtid);
7203 damap_id_rele(tgtdam, tgtid);
7204 ASSERT(lundam);
7205 }
7206 }
7207
7208 if (lundam) {
7209 /* If using lunmap, start the observation */
7210 scsi_lunmap_set_begin(self, lundam);
7211 } else {
7212 /* allocate and initialize the LUN handle */
7213 h = kmem_zalloc(sizeof (*h), KM_SLEEP);
7214 mutex_init(&h->h_lock, NULL, MUTEX_DEFAULT, NULL);
7215 cv_init(&h->h_cv, NULL, CV_DEFAULT, NULL);
7216 h->h_self = self;
7217 }
7218
7219 /* See if SCMD_REPORT_LUNS works for SCSI-2 and beyond */
7220 aver = sd0->sd_inq->inq_ansi;
7221 if ((aver >= SCSI_VERSION_2) && (scsi_device_reportluns(sd0,
7222 taddr, pi, &lunp, &nluns, &tluns, &size) == NDI_SUCCESS)) {
7223
7224 ASSERT(lunp && (size > 0) && (nluns > 0) && (tluns > 0));
7225
7226 /* loop over the reported LUNs */
7227 SCSI_HBA_LOG((_LOG(2), NULL, child,
7228 "@%s,0 path %d: enumerating %d reported lun%s", taddr, pi,
7229 nluns, nluns > 1 ? "s" : ""));
7230
7231 for (lun = 0; lun < nluns; lun++) {
7232 lun64 = scsi_lun_to_lun64(lunp[lun]);
7233
7234 if (lundam) {
7235 if (scsi_lunmap_set_add(self, lundam,
7236 taddr, lun64, -1) != DDI_SUCCESS) {
7237 SCSI_HBA_LOG((_LOG_NF(WARN),
7238 "@%s,%" PRIx64 " failed to create",
7239 taddr, lun64));
7240 }
7241 } else {
7242 if (lun64 == 0)
7243 continue;
7244
7245 /* allocate a thread data structure for LUN */
7246 ld = kmem_alloc(sizeof (*ld), KM_SLEEP);
7247 ld->ld_h = h;
7248 ld->ld_taddr = taddr;
7249 ld->ld_lun64 = lun64;
7250 ld->ld_sfunc = -1;
7251 ld->ld_se = se;
7252
7253 /* process the LUN */
7254 mutex_enter(&h->h_lock);
7255 h->h_thr_count++;
7256 mutex_exit(&h->h_lock);
7257
7258 if (mt & SCSI_ENUMERATION_MT_LUN_DISABLE)
7259 scsi_hba_enum_lsf_of_tgt_thr(
7260 (void *)ld);
7261 else
7262 (void) thread_create(NULL, 0,
7263 scsi_hba_enum_lsf_of_tgt_thr,
7264 (void *)ld, 0, &p0, TS_RUN,
7265 minclsyspri);
7266 }
7267 }
7268
7269 /* free the LUN array allocated by scsi_device_reportluns */
7270 kmem_free(lunp, size);
7271 } else {
7272 /* Determine the number of LUNs to enumerate. */
7273 maxluns = scsi_get_scsi_maxluns(sd0);
7274
7275 /* Couldn't get SCMD_REPORT_LUNS data */
7276 if (aver >= SCSI_VERSION_3) {
7277 scsi_enumeration_failed(child, se, taddr, "report_lun");
7278
7279 /*
7280 * Based on calling context tunable, only enumerate one
7281 * lun (lun0) if scsi_device_reportluns() fails on a
7282 * SCSI_VERSION_3 or greater device.
7283 */
7284 if (scsi_lunrpt_failed_do1lun & (1 << se))
7285 maxluns = 1;
7286 }
7287
7288 /* loop over possible LUNs, skipping LUN0 */
7289 if (maxluns > 1)
7290 SCSI_HBA_LOG((_LOG(2), NULL, child,
7291 "@%s,0 path %d: enumerating luns 1-%d", taddr, pi,
7292 maxluns - 1));
7293 else
7294 SCSI_HBA_LOG((_LOG(2), NULL, child,
7295 "@%s,0 path %d: enumerating just lun0", taddr, pi));
7296
7297 for (lun64 = 0; lun64 < maxluns; lun64++) {
7298 if (lundam) {
7299 if (scsi_lunmap_set_add(self, lundam,
7300 taddr, lun64, -1) != DDI_SUCCESS) {
7301 SCSI_HBA_LOG((_LOG_NF(WARN),
7302 "@%s,%" PRIx64 " failed to create",
7303 taddr, lun64));
7304 }
7305 } else {
7306 if (lun64 == 0)
7307 continue;
7308
7309 /* allocate a thread data structure for LUN */
7310 ld = kmem_alloc(sizeof (*ld), KM_SLEEP);
7311 ld->ld_h = h;
7312 ld->ld_taddr = taddr;
7313 ld->ld_lun64 = lun64;
7314 ld->ld_sfunc = -1;
7315 ld->ld_se = se;
7316
7317 /* process the LUN */
7318 mutex_enter(&h->h_lock);
7319 h->h_thr_count++;
7320 mutex_exit(&h->h_lock);
7321 if (mt & SCSI_ENUMERATION_MT_LUN_DISABLE)
7322 scsi_hba_enum_lsf_of_tgt_thr(
7323 (void *)ld);
7324 else
7325 (void) thread_create(NULL, 0,
7326 scsi_hba_enum_lsf_of_tgt_thr,
7327 (void *)ld, 0, &p0, TS_RUN,
7328 minclsyspri);
7329 }
7330 }
7331 }
7332
7333 /*
7334 * If we have an embedded service as a secondary function on LUN0 and
7335 * the primary LUN0 function is different than the secondary function
7336 * then enumerate the secondary function. The sfunc value is the dtype
7337 * associated with the embedded service.
7338 *
7339 * inq_encserv: enclosure service and our dtype is not DTYPE_ESI
7340 * or DTYPE_UNKNOWN then create a separate DTYPE_ESI node for
7341 * enclosure service access.
7342 */
7343 ASSERT(sd0->sd_inq);
7344 if (sd0->sd_inq->inq_encserv &&
7345 ((sd0->sd_inq->inq_dtype & DTYPE_MASK) != DTYPE_UNKNOWN) &&
7346 ((sd0->sd_inq->inq_dtype & DTYPE_MASK) != DTYPE_ESI) &&
7347 ((sd0->sd_inq->inq_ansi >= SCSI_VERSION_3))) {
7348 if (lundam) {
7349 if (scsi_lunmap_set_add(self, lundam,
7350 taddr, 0, DTYPE_ESI) != DDI_SUCCESS) {
7351 SCSI_HBA_LOG((_LOG_NF(WARN),
7352 "@%s,0,%x failed to create",
7353 taddr, DTYPE_ESI));
7354 }
7355 } else {
7356 /* allocate a thread data structure for sfunc */
7357 ld = kmem_alloc(sizeof (*ld), KM_SLEEP);
7358 ld->ld_h = h;
7359 ld->ld_taddr = taddr;
7360 ld->ld_lun64 = 0;
7361 ld->ld_sfunc = DTYPE_ESI;
7362 ld->ld_se = se;
7363
7364 /* process the LUN */
7365 mutex_enter(&h->h_lock);
7366 h->h_thr_count++;
7367 mutex_exit(&h->h_lock);
7368 if (mt & SCSI_ENUMERATION_MT_LUN_DISABLE)
7369 scsi_hba_enum_lsf_of_tgt_thr((void *)ld);
7370 else
7371 (void) thread_create(NULL, 0,
7372 scsi_hba_enum_lsf_of_tgt_thr, (void *)ld,
7373 0, &p0, TS_RUN, minclsyspri);
7374 }
7375 }
7376
7377 /*
7378 * Future: Add secondary function support for:
7379 * inq_mchngr (DTYPE_CHANGER)
7380 * inq_sccs (DTYPE_ARRAY_CTRL)
7381 */
7382
7383 if (lundam) {
7384 /* If using lunmap, end the observation */
7385 scsi_lunmap_set_end(self, lundam);
7386 } else {
7387 /* wait for all the LUN threads of this target to complete */
7388 mutex_enter(&h->h_lock);
7389 while (h->h_thr_count > 0)
7390 cv_wait(&h->h_cv, &h->h_lock);
7391 mutex_exit(&h->h_lock);
7392
7393 /* free the target handle */
7394 cv_destroy(&h->h_cv);
7395 mutex_destroy(&h->h_lock);
7396 kmem_free(h, sizeof (*h));
7397 }
7398
7399 return (DDI_SUCCESS);
7400 }
7401
7402 /*
7403 * Enumerate LUN0 and all other LUNs and secondary functions associated with
7404 * the specified target address.
7405 *
7406 * Return NDI_SUCCESS if we might have created a new node.
7407 * Return NDI_FAILURE if we definitely did not create a new node.
7408 */
7409 static int
scsi_hba_bus_config_taddr(dev_info_t * self,char * taddr,int mt,scsi_enum_t se)7410 scsi_hba_bus_config_taddr(dev_info_t *self, char *taddr, int mt, scsi_enum_t se)
7411 {
7412 char addr[SCSI_MAXNAMELEN];
7413 struct scsi_device *sd;
7414 boolean_t enteredv;
7415 int ret;
7416 int pi;
7417
7418 /* See if LUN0 of the specified target exists. */
7419 (void) snprintf(addr, sizeof (addr), "%s,0", taddr);
7420
7421 scsi_hba_devi_enter(self, &enteredv);
7422 sd = scsi_device_config(self, NULL, addr, se, &enteredv, &pi);
7423
7424 if (sd) {
7425 /*
7426 * LUN0 exists, enumerate all the other LUNs.
7427 *
7428 * With vHCI enumeration, when 'self' is a pHCI the sd
7429 * scsi_device may be associated with the vHCI 'client'.
7430 * In this case 'pi' is the path_instance needed to
7431 * continue enumeration communication LUN0 via 'self'
7432 * pHCI and specific 'taddr' target address.
7433 *
7434 * We prevent the removal of LUN0 until we are done with
7435 * prevent/allow because we must exit the parent for
7436 * multi-threaded scsi_hba_enum_lsf_of_t().
7437 *
7438 * NOTE: scsi_unprobe is a noop, sd->sd_inq is valid until
7439 * device_uninitchild - so sd_uninit_prevent keeps sd_inq valid
7440 * by failing any device_uninitchild attempts.
7441 */
7442 ret = NDI_SUCCESS;
7443 sd->sd_uninit_prevent++;
7444 scsi_hba_devi_exit(self, enteredv);
7445
7446 (void) scsi_hba_enum_lsf_of_t(sd, self, taddr, pi, mt, se);
7447
7448 scsi_hba_devi_enter(self, &enteredv);
7449 sd->sd_uninit_prevent--;
7450 } else
7451 ret = NDI_FAILURE;
7452 scsi_hba_devi_exit(self, enteredv);
7453 return (ret);
7454 }
7455
7456 /* Config callout from scsi_hba_thread_taddrs */
7457 static void
scsi_hba_taddr_config_thr(void * arg)7458 scsi_hba_taddr_config_thr(void *arg)
7459 {
7460 struct scsi_hba_mte_td *td = (struct scsi_hba_mte_td *)arg;
7461 struct scsi_hba_mte_h *h = td->td_h;
7462
7463 (void) scsi_hba_bus_config_taddr(h->h_self, td->td_taddr,
7464 td->td_mt, td->td_se);
7465
7466 /* signal completion of this target thread to the HBA */
7467 mutex_enter(&h->h_lock);
7468 if (--h->h_thr_count == 0)
7469 cv_broadcast(&h->h_cv);
7470 mutex_exit(&h->h_lock);
7471
7472 /* free config thread data */
7473 kmem_free(td, sizeof (*td));
7474 }
7475
7476 /*
7477 * Enumerate all the children of the specified SCSI parallel interface (spi).
7478 * An HBA associated with a non-parallel scsi bus should be using another bus
7479 * level enumeration implementation (possibly their own) and calling
7480 * scsi_hba_bus_config_taddr to do enumeration of devices associated with a
7481 * particular target address.
7482 *
7483 * On an spi bus the targets are sequentially enumerated based on the
7484 * width of the bus. We also take care to try to skip the HBAs own initiator
7485 * id. See scsi_hba_enum_lsf_of_t() for LUN and secondary function enumeration.
7486 *
7487 * Return NDI_SUCCESS if we might have created a new node.
7488 * Return NDI_FAILURE if we definitely did not create a new node.
7489 *
7490 * Note: At some point we may want to expose this interface in transport.h
7491 * if we find an hba that implements bus_config but still uses spi-like target
7492 * addresses.
7493 */
7494 static int
scsi_hba_bus_configall_spi(dev_info_t * self,int mt)7495 scsi_hba_bus_configall_spi(dev_info_t *self, int mt)
7496 {
7497 int options;
7498 int ntargets;
7499 int id;
7500 int tgt;
7501 char **taddrs;
7502 char **taddr;
7503 char *tbuf;
7504
7505 /*
7506 * Find the number of targets supported on the bus. Look at the per
7507 * bus scsi-options property on the HBA node and check its
7508 * SCSI_OPTIONS_WIDE setting.
7509 */
7510 options = ddi_prop_get_int(DDI_DEV_T_ANY, self,
7511 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "scsi-options", -1);
7512 if ((options != -1) && ((options & SCSI_OPTIONS_WIDE) == 0))
7513 ntargets = NTARGETS; /* 8 */
7514 else
7515 ntargets = NTARGETS_WIDE; /* 16 */
7516
7517 /*
7518 * Find the initiator-id for the HBA so we can skip that. We get the
7519 * cached value on the HBA node, established in scsi_hba_attach_setup.
7520 * If we were unable to determine the id then we rely on the HBA to
7521 * fail gracefully when asked to enumerate itself.
7522 */
7523 id = ddi_prop_get_int(DDI_DEV_T_ANY, self,
7524 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "scsi-initiator-id", -1);
7525 if (id > ntargets) {
7526 SCSI_HBA_LOG((_LOG(1), self, NULL,
7527 "'scsi-initiator-id' bogus for %d target bus: %d",
7528 ntargets, id));
7529 id = -1;
7530 }
7531 SCSI_HBA_LOG((_LOG(2), self, NULL,
7532 "enumerating targets 0-%d skip %d", ntargets, id));
7533
7534 /* form vector of target addresses */
7535 taddrs = kmem_zalloc(sizeof (char *) * (ntargets + 1), KM_SLEEP);
7536 for (tgt = 0, taddr = taddrs; tgt < ntargets; tgt++) {
7537 /* skip initiator */
7538 if (tgt == id)
7539 continue;
7540
7541 /* convert to string and enumerate the target address */
7542 tbuf = kmem_alloc(((tgt/16) + 1) + 1, KM_SLEEP);
7543 (void) sprintf(tbuf, "%x", tgt);
7544 ASSERT(strlen(tbuf) == ((tgt/16) + 1));
7545 *taddr++ = tbuf;
7546 }
7547
7548 /* null terminate vector of target addresses */
7549 *taddr = NULL;
7550
7551 /* configure vector of target addresses */
7552 scsi_hba_thread_taddrs(self, taddrs, mt, SE_BUSCONFIG,
7553 scsi_hba_taddr_config_thr);
7554
7555 /* free vector of target addresses */
7556 for (taddr = taddrs; *taddr; taddr++)
7557 kmem_free(*taddr, strlen(*taddr) + 1);
7558 kmem_free(taddrs, sizeof (char *) * (ntargets + 1));
7559 return (NDI_SUCCESS);
7560 }
7561
7562 /*
7563 * Transport independent bus_configone BUS_CONFIG_ONE implementation. Takes
7564 * same arguments, minus op, as scsi_hba_bus_config(), tran_bus_config(),
7565 * and scsi_hba_bus_config_spi().
7566 */
7567 int
scsi_hba_bus_configone(dev_info_t * self,uint_t flags,char * arg,dev_info_t ** childp)7568 scsi_hba_bus_configone(dev_info_t *self, uint_t flags, char *arg,
7569 dev_info_t **childp)
7570 {
7571 int ret;
7572 boolean_t enteredv;
7573 char *name, *addr;
7574 char *lcp;
7575 char sc1, sc2;
7576 char nameaddr[SCSI_MAXNAMELEN];
7577 extern int i_ndi_make_spec_children(dev_info_t *, uint_t);
7578 struct scsi_device *sd0, *sd;
7579 scsi_lun64_t lun64;
7580 int mt;
7581
7582 /* parse_name modifies arg1, we must duplicate "name@addr" */
7583 (void) strcpy(nameaddr, arg);
7584 i_ddi_parse_name(nameaddr, &name, &addr, NULL);
7585
7586 /* verify the form of the node - we need an @addr */
7587 if ((name == NULL) || (addr == NULL) ||
7588 (*name == '\0') || (*addr == '\0')) {
7589 /*
7590 * OBP may create ill formed template/stub/wild-card
7591 * nodes (no @addr) for legacy driver loading methods -
7592 * ignore them.
7593 */
7594 SCSI_HBA_LOG((_LOG(2), self, NULL, "%s ill formed", arg));
7595 return (NDI_FAILURE);
7596 }
7597
7598 /*
7599 * Check to see if this is a non-scsi flavor configuration operation.
7600 */
7601 if (strcmp(name, "smp") == 0) {
7602 /*
7603 * Configure the child, and if we're successful return with
7604 * active hold.
7605 */
7606 return (smp_hba_bus_config(self, addr, childp));
7607 }
7608
7609 /*
7610 * The framework does not ensure the creation of driver.conf
7611 * nodes prior to calling a nexus bus_config. For legacy
7612 * support of driver.conf file nodes we want to create our
7613 * driver.conf file children now so that we can detect if we
7614 * are being asked to bus_configone one of these nodes.
7615 *
7616 * Needing driver.conf file nodes prior to bus config is unique
7617 * to scsi_enumeration mixed mode (legacy driver.conf and
7618 * dynamic SID node) support. There is no general need for the
7619 * framework to make driver.conf children prior to bus_config.
7620 *
7621 * We enter our HBA (self) prior to scsi_device_config, and
7622 * pass it our enteredv. The scsi_device_config may exit the
7623 * HBA around scsi_probe() operations to allow for parallelism.
7624 * This is done after the probe node "@addr" is available as a
7625 * barrier to prevent parallel probes of the same device. The
7626 * probe node is also configured in a way that it can't be
7627 * removed by the framework until we are done with it.
7628 *
7629 * NOTE: The framework is currently preventing many parallel
7630 * sibling operations (such as attaches), so the parallelism
7631 * we are providing is of marginal use until that is improved.
7632 * The most logical way to solve this would be to have separate
7633 * target and lun nodes. This would be a large change in the
7634 * format of /devices paths and is not being pursued at this
7635 * time. The need for parallelism will become more of an issue
7636 * with top-down attach for mpxio/vhci and for iSCSI support.
7637 * We may want to eventually want a dual mode implementation,
7638 * where the HBA determines if we should construct separate
7639 * target and lun devinfo nodes.
7640 */
7641 scsi_hba_devi_enter(self, &enteredv);
7642 SCSI_HBA_LOG((_LOG(4), self, NULL, "%s@%s config_one", name, addr));
7643 (void) i_ndi_make_spec_children(self, flags);
7644
7645 /*
7646 * For bus_configone, we make sure that we can find LUN0
7647 * first. This allows the delayed probe/barrier deletion for a
7648 * non-existent LUN0 (if enabled in scsi_device_config) to
7649 * cover all LUNs on the target. This is done to minimize the
7650 * number of independent target selection timeouts that occur
7651 * when a target with many LUNs is no longer accessible
7652 * (powered off). This removes the need for target driver
7653 * probe cache implementations.
7654 *
7655 * This optimization may not be desirable in a pure bridge
7656 * environment where targets on the other side of the bridge
7657 * show up as LUNs to the host. If we ever need to support
7658 * such a configuration then we should consider implementing a
7659 * SCSI_OPTIONS_ILUN0 bit.
7660 *
7661 * NOTE: we are *not* applying any target limitation filtering
7662 * to bus_configone, which means that we are relying on the
7663 * HBA tran_tgt_init entry point invoked by scsi_busctl_initchild
7664 * to fail.
7665 */
7666 sd0 = (struct scsi_device *)-1;
7667 lcp = strchr(addr, ','); /* "addr,lun[,sfunc]" */
7668 if (lcp) {
7669 /*
7670 * With "tgt,lun[,sfunc]" addressing, multiple addressing levels
7671 * have been compressed into single devinfo node unit-address.
7672 * This presents a mismatch - there is no bus_config to discover
7673 * LUNs below a specific target, the only choice is to
7674 * BUS_CONFIG_ALL the HBA. To support BUS_CONFIG_ALL_LUNS below
7675 * a specific target, a bus_configone with lun address of "*"
7676 * triggers lun discovery below a target.
7677 */
7678 if (*(lcp + 1) == '*') {
7679 mt = ddi_prop_get_int(DDI_DEV_T_ANY, self,
7680 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
7681 "scsi-enumeration", scsi_enumeration);
7682 mt |= scsi_hba_log_mt_disable;
7683
7684 SCSI_HBA_LOG((_LOG(2), self, NULL,
7685 "%s@%s lun enumeration triggered", name, addr));
7686 *lcp = '\0'; /* turn ',' into '\0' */
7687 scsi_hba_devi_exit(self, enteredv);
7688 (void) scsi_hba_bus_config_taddr(self, addr,
7689 mt, SE_BUSCONFIG);
7690 return (NDI_FAILURE);
7691 }
7692
7693 /* convert hex lun number from ascii */
7694 lun64 = scsi_addr_to_lun64(lcp + 1);
7695
7696 if ((lun64 != 0) && (lun64 != SCSI_LUN64_ILLEGAL)) {
7697 /*
7698 * configure ",0" lun first, saving off
7699 * original lun characters.
7700 */
7701 sc1 = *(lcp + 1);
7702 sc2 = *(lcp + 2);
7703 *(lcp + 1) = '0';
7704 *(lcp + 2) = '\0';
7705 sd0 = scsi_device_config(self,
7706 NULL, addr, SE_BUSCONFIG, &enteredv, NULL);
7707
7708 /* restore original lun */
7709 *(lcp + 1) = sc1;
7710 *(lcp + 2) = sc2;
7711
7712 /*
7713 * Apply maxlun filtering.
7714 *
7715 * Future: We still have the kludged
7716 * scsi_check_ss2_LUN_limit() filtering off
7717 * scsi_probe() to catch bogus driver.conf
7718 * entries.
7719 */
7720 if (sd0 && (lun64 < SCSI_32LUNS_PER_TARGET) &&
7721 (lun64 >= scsi_get_scsi_maxluns(sd0))) {
7722 sd0 = NULL;
7723 SCSI_HBA_LOG((_LOG(4), self, NULL,
7724 "%s@%s filtered", name, addr));
7725 } else
7726 SCSI_HBA_LOG((_LOG(4), self, NULL,
7727 "%s@%s lun 0 %s", name, addr,
7728 sd0 ? "worked" : "failed"));
7729 }
7730 }
7731
7732 /*
7733 * configure the requested device if LUN0 exists or we were
7734 * unable to determine the lun format to determine if LUN0
7735 * exists.
7736 */
7737 if (sd0) {
7738 sd = scsi_device_config(self,
7739 name, addr, SE_BUSCONFIG, &enteredv, NULL);
7740 } else {
7741 sd = NULL;
7742 SCSI_HBA_LOG((_LOG(2), self, NULL,
7743 "%s@%s no lun 0 or filtered lun", name, addr));
7744 }
7745
7746 /*
7747 * We know what we found, to reduce overhead we finish BUS_CONFIG_ONE
7748 * processing without calling back to the frameworks
7749 * ndi_busop_bus_config (unless we goto framework below).
7750 *
7751 * If the reference is to a driver name and we created a generic name
7752 * (bound to that driver) we will still succeed. This is important
7753 * for correctly resolving old drivername references to device that now
7754 * uses a generic names across the transition to generic naming. This
7755 * is effectively an internal implementation of the NDI_DRIVERNAME flag.
7756 *
7757 * We also need to special case the resolve_pathname OBP boot-device
7758 * case (modrootloaded == 0) where reference is to a generic name but
7759 * we created a legacy driver name node by returning just returning
7760 * the node created.
7761 */
7762 if (sd && sd->sd_dev &&
7763 ((strcmp(ddi_node_name(sd->sd_dev), name) == 0) ||
7764 (strcmp(ddi_driver_name(sd->sd_dev), name) == 0) ||
7765 (modrootloaded == 0)) &&
7766 (ndi_devi_online(sd->sd_dev,
7767 flags & NDI_NO_EVENT) == NDI_SUCCESS)) {
7768
7769 /* device attached, return devinfo node with hold */
7770 ret = NDI_SUCCESS;
7771 *childp = sd->sd_dev;
7772 ndi_hold_devi(sd->sd_dev);
7773 } else {
7774 /*
7775 * In the process of failing we may have added nodes to the HBA
7776 * (self), clearing DEVI_MADE_CHILDREN. To reduce the overhead
7777 * associated with the frameworks reaction to this we clear the
7778 * flag here.
7779 */
7780 mutex_enter(&DEVI(self)->devi_lock);
7781 DEVI(self)->devi_flags &= ~DEVI_MADE_CHILDREN;
7782 mutex_exit(&DEVI(self)->devi_lock);
7783 ret = NDI_FAILURE;
7784
7785 /*
7786 * The framework may still be able to succeed with
7787 * with its GENERIC_PROP code.
7788 */
7789 scsi_hba_devi_exit(self, enteredv);
7790 if (flags & NDI_DRV_CONF_REPROBE)
7791 flags |= NDI_CONFIG_REPROBE;
7792 flags |= NDI_MDI_FALLBACK; /* devinfo&pathinfo children */
7793 return (ndi_busop_bus_config(self, flags, BUS_CONFIG_ONE,
7794 (void *)arg, childp, 0));
7795 }
7796
7797 scsi_hba_devi_exit(self, enteredv);
7798 return (ret);
7799 }
7800
7801 /*
7802 * Perform SCSI Parallel Interconnect bus_config
7803 */
7804 static int
scsi_hba_bus_config_spi(dev_info_t * self,uint_t flags,ddi_bus_config_op_t op,void * arg,dev_info_t ** childp)7805 scsi_hba_bus_config_spi(dev_info_t *self, uint_t flags,
7806 ddi_bus_config_op_t op, void *arg, dev_info_t **childp)
7807 {
7808 int ret;
7809 int mt;
7810
7811 /*
7812 * Enumerate scsi target devices: See if we are doing generic dynamic
7813 * enumeration: if driver.conf has not specified the 'scsi-enumeration'
7814 * knob then use the global scsi_enumeration knob.
7815 */
7816 mt = ddi_prop_get_int(DDI_DEV_T_ANY, self,
7817 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
7818 "scsi-enumeration", scsi_enumeration);
7819 mt |= scsi_hba_log_mt_disable;
7820
7821 if ((mt & SCSI_ENUMERATION_ENABLE) == 0) {
7822 /*
7823 * Static driver.conf file enumeration:
7824 *
7825 * Force reprobe for BUS_CONFIG_ONE or when manually
7826 * reconfiguring via devfsadm(8) to emulate deferred attach.
7827 * Reprobe only discovers driver.conf enumerated nodes, more
7828 * dynamic implementations probably require their own
7829 * bus_config.
7830 */
7831 if ((op == BUS_CONFIG_ONE) || (flags & NDI_DRV_CONF_REPROBE))
7832 flags |= NDI_CONFIG_REPROBE;
7833 flags |= NDI_MDI_FALLBACK; /* devinfo&pathinfo children */
7834 return (ndi_busop_bus_config(self, flags, op, arg, childp, 0));
7835 }
7836
7837 if (scsi_hba_bus_config_debug)
7838 flags |= NDI_DEVI_DEBUG;
7839
7840 /*
7841 * Generic spi dynamic bus config enumeration to discover and enumerate
7842 * the target device nodes we are looking for.
7843 */
7844 switch (op) {
7845 case BUS_CONFIG_ONE: /* enumerate the named child */
7846 ret = scsi_hba_bus_configone(self, flags, (char *)arg, childp);
7847 break;
7848
7849 case BUS_CONFIG_ALL: /* enumerate all children on the bus */
7850 case BUS_CONFIG_DRIVER: /* enumerate all children that bind to driver */
7851 SCSI_HBA_LOG((_LOG(3), self, NULL,
7852 "BUS_CONFIG_%s mt %x",
7853 (op == BUS_CONFIG_ALL) ? "ALL" : "DRIVER", mt));
7854
7855 /*
7856 * Enumerate targets on SCSI parallel interconnect and let the
7857 * framework finish the operation (attach the nodes).
7858 */
7859 if ((ret = scsi_hba_bus_configall_spi(self, mt)) == NDI_SUCCESS)
7860 ret = ndi_busop_bus_config(self, flags, op,
7861 arg, childp, 0);
7862 break;
7863
7864 default:
7865 ret = NDI_FAILURE;
7866 break;
7867 }
7868 return (ret);
7869 }
7870
7871 /*
7872 * Perform SCSI Parallel Interconnect bus_unconfig
7873 */
7874 static int
scsi_hba_bus_unconfig_spi(dev_info_t * self,uint_t flags,ddi_bus_config_op_t op,void * arg)7875 scsi_hba_bus_unconfig_spi(dev_info_t *self, uint_t flags,
7876 ddi_bus_config_op_t op, void *arg)
7877 {
7878 int mt;
7879 int ret;
7880 boolean_t enteredv;
7881
7882 /*
7883 * See if we are doing generic dynamic enumeration: if driver.conf has
7884 * not specified the 'scsi-enumeration' knob then use the global
7885 * scsi_enumeration knob.
7886 */
7887 mt = ddi_prop_get_int(DDI_DEV_T_ANY, self,
7888 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
7889 "scsi-enumeration", scsi_enumeration);
7890 mt |= scsi_hba_log_mt_disable;
7891
7892 if ((mt & SCSI_ENUMERATION_ENABLE) == 0)
7893 return (ndi_busop_bus_unconfig(self, flags, op, arg));
7894
7895 if (scsi_hba_bus_config_debug)
7896 flags |= NDI_DEVI_DEBUG;
7897
7898 scsi_hba_devi_enter(self, &enteredv);
7899 switch (op) {
7900 case BUS_UNCONFIG_ONE:
7901 SCSI_HBA_LOG((_LOG(3), self, NULL,
7902 "unconfig one: %s", (char *)arg));
7903 ret = NDI_SUCCESS;
7904 break;
7905
7906 case BUS_UNCONFIG_ALL:
7907 case BUS_UNCONFIG_DRIVER:
7908 ret = NDI_SUCCESS;
7909 break;
7910
7911 default:
7912 ret = NDI_FAILURE;
7913 break;
7914 }
7915
7916 /* Perform the generic default bus unconfig */
7917 if (ret == NDI_SUCCESS)
7918 ret = ndi_busop_bus_unconfig(self, flags, op, arg);
7919
7920 scsi_hba_devi_exit(self, enteredv);
7921
7922 return (ret);
7923 }
7924
7925 static int
scsi_hba_bus_config_tgtmap(dev_info_t * self,uint_t flags,ddi_bus_config_op_t op,void * arg,dev_info_t ** childp)7926 scsi_hba_bus_config_tgtmap(dev_info_t *self, uint_t flags,
7927 ddi_bus_config_op_t op, void *arg, dev_info_t **childp)
7928 {
7929 scsi_hba_tran_t *tran;
7930 impl_scsi_tgtmap_t *tgtmap;
7931 uint64_t tsa = 0; /* clock64_t */
7932 int maxdev;
7933 int sync_usec;
7934 int synced;
7935 int ret = NDI_FAILURE;
7936
7937 if ((op != BUS_CONFIG_ONE) && (op != BUS_CONFIG_ALL) &&
7938 (op != BUS_CONFIG_DRIVER))
7939 goto out;
7940
7941 tran = ndi_flavorv_get(self, SCSA_FLAVOR_SCSI_DEVICE);
7942 tgtmap = (impl_scsi_tgtmap_t *)tran->tran_tgtmap;
7943 ASSERT(tgtmap);
7944
7945 /*
7946 * MPXIO is never a sure thing (and we have mixed children), so
7947 * set NDI_NDI_FALLBACK so that ndi_busop_bus_config will
7948 * search for both devinfo and pathinfo children.
7949 *
7950 * Future: Remove NDI_MDI_FALLBACK since devcfg.c now looks for
7951 * devinfo/pathinfo children in parallel (instead of old way of
7952 * looking for one form of child and then doing "fallback" to
7953 * look for other form of child).
7954 */
7955 flags |= NDI_MDI_FALLBACK; /* devinfo&pathinfo children */
7956
7957 /*
7958 * If bus_config occurred within the map create-to-hotplug_sync window,
7959 * we need the framework to wait for children that are physicaly
7960 * present at map create time to show up (via tgtmap hotplug config).
7961 *
7962 * The duration of this window is specified by the HBA driver at
7963 * scsi_hba_tgtmap_create(9F) time (during attach(9E)). Its
7964 * 'csync_usec' value is selected based on how long it takes the HBA
7965 * driver to get from map creation to initial observation for something
7966 * already plugged in. Estimate high, a low estimate can result in
7967 * devices not showing up correctly on first reference. The call to
7968 * ndi_busop_bus_config needs a timeout value large enough so that
7969 * the map sync call further down is not a noop (i.e. done against
7970 * an empty map when something is infact plugged in). With
7971 * BUS_CONFIG_ONE, the call to ndi_busop_bus_config will return as
7972 * soon as the desired device is enumerated via hotplug - so we are
7973 * not committed to waiting the entire time.
7974 *
7975 * We are typically outside the window, so timeout is 0.
7976 */
7977 sync_usec = tgtmap->tgtmap_create_csync_usec;
7978 if (tgtmap->tgtmap_create_window) {
7979 tsa = ddi_get_lbolt64() - tgtmap->tgtmap_create_time;
7980 if (tsa < drv_usectohz(sync_usec)) {
7981 tsa = drv_usectohz(sync_usec) - tsa;
7982 ret = ndi_busop_bus_config(self,
7983 flags, op, arg, childp, (clock_t)tsa);
7984 } else
7985 tsa = 0; /* passed window */
7986
7987 /* First one out closes the window. */
7988 tgtmap->tgtmap_create_window = 0;
7989 } else if (op == BUS_CONFIG_ONE)
7990 ret = ndi_busop_bus_config(self, flags, op, arg, childp, 0);
7991
7992 /* Return if doing a BUS_CONFIG_ONE and we found what we want. */
7993 if ((op == BUS_CONFIG_ONE) && (ret == NDI_SUCCESS))
7994 goto out; /* performance path */
7995
7996 /*
7997 * We sync if we were in the window, on the first bus_config_one, and
7998 * every bus_config_all (or bus_config_driver).
7999 */
8000 if (tsa || (tgtmap->tgtmap_sync_cnt == 0) ||
8001 (op != BUS_CONFIG_ONE)) {
8002 /*
8003 * Sync current observations in the map and look again. We
8004 * place an upper bound on the amount of time we will wait for
8005 * sync to complete to avoid a bad device causing this
8006 * busconfig operation to hang.
8007 *
8008 * We are typically stable, so damap_sync returns immediately.
8009 *
8010 * Max time to wait for sync is settle_usec per possible device.
8011 */
8012 tgtmap->tgtmap_sync_cnt++;
8013 maxdev = damap_size(tgtmap->tgtmap_dam[SCSI_TGT_SCSI_DEVICE]);
8014 maxdev = (maxdev > scsi_hba_map_settle_f) ? maxdev :
8015 scsi_hba_map_settle_f;
8016 sync_usec = maxdev * tgtmap->tgtmap_settle_usec;
8017 synced = scsi_tgtmap_sync((scsi_hba_tgtmap_t *)tgtmap,
8018 sync_usec);
8019 if (!synced)
8020 SCSI_HBA_LOG((_LOGCFG, self, NULL,
8021 "tgtmap_sync timeout"));
8022 } else
8023 synced = -1;
8024
8025 if (op == BUS_CONFIG_ONE)
8026 ret = scsi_hba_bus_configone(self, flags, arg, childp);
8027 else
8028 ret = ndi_busop_bus_config(self, flags, op, arg, childp, 0);
8029
8030 out:
8031 #ifdef DEBUG
8032 if (ret != NDI_SUCCESS) {
8033 if (scsi_hba_bus_config_failure_msg ||
8034 scsi_hba_bus_config_failure_dbg) {
8035 scsi_hba_bus_config_failure_msg--;
8036 printf("%s%d: bus_config_tgtmap %p failure on %s: "
8037 "%d %d\n",
8038 ddi_driver_name(self), ddi_get_instance(self),
8039 (void *)tgtmap,
8040 (op == BUS_CONFIG_ONE) ? (char *)arg : "ALL",
8041 (int)tsa, synced);
8042 }
8043 if (scsi_hba_bus_config_failure_dbg) {
8044 scsi_hba_bus_config_failure_dbg--;
8045 debug_enter("config_tgtmap failure");
8046 }
8047 } else if (scsi_hba_bus_config_success_msg ||
8048 scsi_hba_bus_config_success_dbg) {
8049 scsi_hba_bus_config_success_msg--;
8050 printf("%s%d: bus_config_tgtmap %p success on %s: %d %d\n",
8051 ddi_driver_name(self), ddi_get_instance(self),
8052 (void *)tgtmap,
8053 (op == BUS_CONFIG_ONE) ? (char *)arg : "ALL",
8054 (int)tsa, synced);
8055 if (scsi_hba_bus_config_success_dbg) {
8056 scsi_hba_bus_config_success_dbg--;
8057 debug_enter("config_tgtmap success");
8058 }
8059 }
8060 #endif /* DEBUG */
8061 return (ret);
8062 }
8063
8064 static int
scsi_hba_bus_unconfig_tgtmap(dev_info_t * self,uint_t flags,ddi_bus_config_op_t op,void * arg)8065 scsi_hba_bus_unconfig_tgtmap(dev_info_t *self, uint_t flags,
8066 ddi_bus_config_op_t op, void *arg)
8067 {
8068 int ret = NDI_FAILURE;
8069
8070 switch (op) {
8071 case BUS_UNCONFIG_ONE:
8072 case BUS_UNCONFIG_DRIVER:
8073 case BUS_UNCONFIG_ALL:
8074 ret = NDI_SUCCESS;
8075 break;
8076 default:
8077 break;
8078 }
8079
8080 if (ret == NDI_SUCCESS) {
8081 flags &= ~NDI_DEVI_REMOVE;
8082 ret = ndi_busop_bus_unconfig(self, flags, op, arg);
8083 }
8084 return (ret);
8085 }
8086
8087 static int
scsi_hba_bus_config_iportmap(dev_info_t * self,uint_t flags,ddi_bus_config_op_t op,void * arg,dev_info_t ** childp)8088 scsi_hba_bus_config_iportmap(dev_info_t *self, uint_t flags,
8089 ddi_bus_config_op_t op, void *arg, dev_info_t **childp)
8090 {
8091 scsi_hba_tran_t *tran;
8092 impl_scsi_iportmap_t *iportmap;
8093 dev_info_t *child;
8094 boolean_t enteredv;
8095 uint64_t tsa = 0; /* clock64_t */
8096 int sync_usec;
8097 int synced;
8098 int ret = NDI_FAILURE;
8099
8100 if ((op != BUS_CONFIG_ONE) && (op != BUS_CONFIG_ALL) &&
8101 (op != BUS_CONFIG_DRIVER))
8102 goto out;
8103
8104 tran = ndi_flavorv_get(self, SCSA_FLAVOR_SCSI_DEVICE);
8105 iportmap = (impl_scsi_iportmap_t *)tran->tran_iportmap;
8106 ASSERT(iportmap);
8107
8108 /*
8109 * MPXIO is never a sure thing (and we have mixed children), so
8110 * set NDI_NDI_FALLBACK so that ndi_busop_bus_config will
8111 * search for both devinfo and pathinfo children.
8112 *
8113 * Future: Remove NDI_MDI_FALLBACK since devcfg.c now looks for
8114 * devinfo/pathinfo children in parallel (instead of old way of
8115 * looking for one form of child and then doing "fallback" to
8116 * look for other form of child).
8117 */
8118 flags |= NDI_MDI_FALLBACK; /* devinfo&pathinfo children */
8119
8120 /*
8121 * If bus_config occurred within the map create-to-hotplug_sync window,
8122 * we need the framework to wait for children that are physicaly
8123 * present at map create time to show up (via iportmap hotplug config).
8124 *
8125 * The duration of this window is specified by the HBA driver at
8126 * scsi_hba_iportmap_create(9F) time (during attach(9E)). Its
8127 * 'csync_usec' value is selected based on how long it takes the HBA
8128 * driver to get from map creation to initial observation for something
8129 * already plugged in. Estimate high, a low estimate can result in
8130 * devices not showing up correctly on first reference. The call to
8131 * ndi_busop_bus_config needs a timeout value large enough so that
8132 * the map sync call further down is not a noop (i.e. done against
8133 * an empty map when something is infact plugged in). With
8134 * BUS_CONFIG_ONE, the call to ndi_busop_bus_config will return as
8135 * soon as the desired device is enumerated via hotplug - so we are
8136 * not committed to waiting the entire time.
8137 *
8138 * We are typically outside the window, so timeout is 0.
8139 */
8140 sync_usec = iportmap->iportmap_create_csync_usec;
8141 if (iportmap->iportmap_create_window) {
8142 tsa = ddi_get_lbolt64() - iportmap->iportmap_create_time;
8143 if (tsa < drv_usectohz(sync_usec)) {
8144 tsa = drv_usectohz(sync_usec) - tsa;
8145 ret = ndi_busop_bus_config(self,
8146 flags, op, arg, childp, (clock_t)tsa);
8147 } else
8148 tsa = 0; /* passed window */
8149
8150 /* First one out closes the window. */
8151 iportmap->iportmap_create_window = 0;
8152 } else if (op == BUS_CONFIG_ONE)
8153 ret = ndi_busop_bus_config(self, flags, op, arg, childp, 0);
8154
8155 /* Return if doing a BUS_CONFIG_ONE and we found what we want. */
8156 if ((op == BUS_CONFIG_ONE) && (ret == NDI_SUCCESS))
8157 goto out; /* performance path */
8158
8159 /*
8160 * We sync if we were in the window, on the first bus_config_one, and
8161 * every bus_config_all (or bus_config_driver).
8162 */
8163 if (tsa || (iportmap->iportmap_sync_cnt == 0) ||
8164 (op != BUS_CONFIG_ONE)) {
8165 /*
8166 * Sync current observations in the map and look again. We
8167 * place an upper bound on the amount of time we will wait for
8168 * sync to complete to avoid a bad device causing this
8169 * busconfig operation to hang.
8170 *
8171 * We are typically stable, so damap_sync returns immediately.
8172 *
8173 * Max time to wait for sync is settle_usec times settle factor.
8174 */
8175 iportmap->iportmap_sync_cnt++;
8176 synced = damap_sync(iportmap->iportmap_dam, sync_usec);
8177 if (!synced)
8178 SCSI_HBA_LOG((_LOGCFG, self, NULL,
8179 "iportmap_sync timeout"));
8180 } else
8181 synced = -1;
8182
8183 if (op == BUS_CONFIG_ONE) {
8184 /* create the iport node child */
8185 scsi_hba_devi_enter(self, &enteredv);
8186 if ((child = scsi_hba_bus_config_port(self, (char *)arg,
8187 SE_BUSCONFIG)) != NULL) {
8188 if (childp) {
8189 ndi_hold_devi(child);
8190 *childp = child;
8191 }
8192 ret = NDI_SUCCESS;
8193 }
8194 scsi_hba_devi_exit(self, enteredv);
8195 } else
8196 ret = ndi_busop_bus_config(self, flags, op, arg, childp, 0);
8197
8198 out:
8199 #ifdef DEBUG
8200 if (ret != NDI_SUCCESS) {
8201 if (scsi_hba_bus_config_failure_msg ||
8202 scsi_hba_bus_config_failure_dbg) {
8203 scsi_hba_bus_config_failure_msg--;
8204 printf("%s%d: bus_config_iportmap %p failure on %s: "
8205 "%d %d\n",
8206 ddi_driver_name(self), ddi_get_instance(self),
8207 (void *)iportmap,
8208 (op == BUS_CONFIG_ONE) ? (char *)arg : "ALL",
8209 (int)tsa, synced);
8210 }
8211 if (scsi_hba_bus_config_failure_dbg) {
8212 scsi_hba_bus_config_failure_dbg--;
8213 debug_enter("config_iportmap failure");
8214 }
8215 } else if (scsi_hba_bus_config_success_msg ||
8216 scsi_hba_bus_config_success_dbg) {
8217 scsi_hba_bus_config_success_msg--;
8218 printf("%s%d: bus_config_iportmap %p success on %s: %d %d\n",
8219 ddi_driver_name(self), ddi_get_instance(self),
8220 (void *)iportmap,
8221 (op == BUS_CONFIG_ONE) ? (char *)arg : "ALL",
8222 (int)tsa, synced);
8223 if (scsi_hba_bus_config_success_dbg) {
8224 scsi_hba_bus_config_success_dbg--;
8225 debug_enter("config_iportmap success");
8226 }
8227 }
8228 #endif /* DEBUG */
8229 return (ret);
8230 }
8231
8232 static int
scsi_hba_bus_unconfig_iportmap(dev_info_t * self,uint_t flags,ddi_bus_config_op_t op,void * arg)8233 scsi_hba_bus_unconfig_iportmap(dev_info_t *self, uint_t flags,
8234 ddi_bus_config_op_t op, void *arg)
8235 {
8236 flags &= ~NDI_DEVI_REMOVE;
8237 return (ndi_busop_bus_unconfig(self, flags, op, arg));
8238 }
8239
8240 /*
8241 * SCSI HBA bus config enumeration entry point. Called via the bus_ops
8242 * bus_config entry point for all SCSA HBA drivers.
8243 *
8244 * o If an HBA implements its own bus_config via tran_bus_config then we
8245 * invoke it. An HBA that implements its own tran_bus_config entry point
8246 * may still call back into common SCSA code bus_config code for:
8247 *
8248 * o SPI bus_config (scsi_hba_bus_spi)
8249 * o LUN and secondary function enumeration (scsi_hba_enum_lsf_of_t()).
8250 * o configuration of a specific device (scsi_device_config).
8251 * o determining 1275 SCSI nodename and compatible property
8252 * (scsi_hba_nodename_compatible_get/_free).
8253 *
8254 * o Otherwise we implement a SCSI parallel interface (spi) bus config.
8255 *
8256 * Return NDI_SUCCESS if we might have created a new node.
8257 * Return NDI_FAILURE if we definitely did not create a new node.
8258 */
8259 static int
scsi_hba_bus_config(dev_info_t * self,uint_t flags,ddi_bus_config_op_t op,void * arg,dev_info_t ** childp)8260 scsi_hba_bus_config(dev_info_t *self, uint_t flags,
8261 ddi_bus_config_op_t op, void *arg, dev_info_t **childp)
8262 {
8263 scsi_hba_tran_t *tran;
8264 int ret;
8265
8266 /* make sure that we will not disappear */
8267 ASSERT(DEVI(self)->devi_ref);
8268
8269 tran = ndi_flavorv_get(self, SCSA_FLAVOR_SCSI_DEVICE);
8270 if (tran == NULL) {
8271 /* NULL tran driver.conf config (used by cmdk). */
8272 if ((op == BUS_CONFIG_ONE) || (flags & NDI_DRV_CONF_REPROBE))
8273 flags |= NDI_CONFIG_REPROBE;
8274 return (ndi_busop_bus_config(self, flags, op, arg, childp, 0));
8275 }
8276
8277 /* Check if self is HBA-only node. */
8278 if (tran->tran_hba_flags & SCSI_HBA_HBA) {
8279 /* The bus_config request is to configure iports below HBA. */
8280
8281 #ifdef sparc
8282 /*
8283 * Sparc's 'boot-device' OBP property value lacks an /iport@X/
8284 * component. Prior to the mount of root, we drive a disk@
8285 * BUS_CONFIG_ONE operatino down a level to resolve an
8286 * OBP 'boot-device' path.
8287 *
8288 * Future: Add (modrootloaded == 0) below, and insure that
8289 * all attempts bus_conf of 'bo_name' (in OBP form) occur
8290 * prior to 'modrootloaded = 1;' assignment in vfs_mountroot.
8291 */
8292 if ((op == BUS_CONFIG_ONE) &&
8293 (strncmp((char *)arg, "disk@", strlen("disk@")) == 0)) {
8294 return (scsi_hba_bus_config_prom_node(self,
8295 flags, arg, childp));
8296 }
8297 #endif /* sparc */
8298
8299 if (tran->tran_iportmap) {
8300 /* config based on scsi_hba_iportmap API */
8301 ret = scsi_hba_bus_config_iportmap(self,
8302 flags, op, arg, childp);
8303 } else {
8304 /* config based on 'iport_register' API */
8305 ret = scsi_hba_bus_config_iports(self,
8306 flags, op, arg, childp);
8307 }
8308 return (ret);
8309 }
8310
8311 /* Check to see how the iport/HBA does target/lun bus config. */
8312 if (tran->tran_bus_config) {
8313 /* HBA config based on Sun-private/legacy tran_bus_config */
8314 ret = tran->tran_bus_config(self, flags, op, arg, childp);
8315 } else if (tran->tran_tgtmap) {
8316 /* SCSAv3 config based on scsi_hba_tgtmap_*() API */
8317 ret = scsi_hba_bus_config_tgtmap(self, flags, op, arg, childp);
8318 } else {
8319 /* SCSA config based on SCSI Parallel Interconnect */
8320 ret = scsi_hba_bus_config_spi(self, flags, op, arg, childp);
8321 }
8322 return (ret);
8323 }
8324
8325 /*
8326 * Called via the bus_ops bus_unconfig entry point for SCSI HBA drivers.
8327 */
8328 static int
scsi_hba_bus_unconfig(dev_info_t * self,uint_t flags,ddi_bus_config_op_t op,void * arg)8329 scsi_hba_bus_unconfig(dev_info_t *self, uint_t flags,
8330 ddi_bus_config_op_t op, void *arg)
8331 {
8332 boolean_t enteredv;
8333 scsi_hba_tran_t *tran;
8334 int ret;
8335
8336 tran = ddi_get_driver_private(self);
8337 if (tran == NULL) {
8338 /* NULL tran driver.conf unconfig (used by cmdk). */
8339 return (ndi_busop_bus_unconfig(self, flags, op, arg));
8340 }
8341
8342 /*
8343 * Purge barrier/probe node children. We do this prior to
8344 * tran_bus_unconfig in case the unconfig implementation calls back
8345 * into the common code at a different enumeration level, such a
8346 * scsi_device_config, which still creates barrier/probe nodes.
8347 */
8348 scsi_hba_devi_enter(self, &enteredv);
8349 scsi_hba_barrier_purge(self);
8350 scsi_hba_devi_exit(self, enteredv);
8351
8352 /* DEBUG: for testing, allow bus_unconfig do drive removal. */
8353 if (scsi_hba_bus_unconfig_remove)
8354 flags |= NDI_DEVI_REMOVE;
8355
8356 /* Check if self is HBA-only node. */
8357 if (tran->tran_hba_flags & SCSI_HBA_HBA) {
8358 /* The bus_config request is to unconfigure iports below HBA. */
8359 if (tran->tran_iportmap) {
8360 /* SCSAv3 unconfig based on scsi_hba_iportmap API */
8361 ret = scsi_hba_bus_unconfig_iportmap(self,
8362 flags, op, arg);
8363 } else if (tran->tran_bus_unconfig) {
8364 /* HBA unconfig based on Sun-private/legacy API */
8365 ret = tran->tran_bus_unconfig(self, flags, op, arg);
8366 } else {
8367 /* Standard framework unconfig. */
8368 ret = ndi_busop_bus_unconfig(self, flags, op, arg);
8369 }
8370 return (ret);
8371 }
8372
8373 /* Check to see how the iport/HBA does target/lun bus unconfig. */
8374 if (tran->tran_bus_unconfig) {
8375 /* HBA unconfig based on Sun-private/legacy tran_bus_unconfig */
8376 ret = tran->tran_bus_unconfig(self, flags, op, arg);
8377 } else if (tran->tran_tgtmap) {
8378 /* SCSAv3 unconfig based on scsi_hba_tgtmap_*() API */
8379 ret = scsi_hba_bus_unconfig_tgtmap(self, flags, op, arg);
8380 } else {
8381 /* SCSA unconfig based on SCSI Parallel Interconnect */
8382 ret = scsi_hba_bus_unconfig_spi(self, flags, op, arg);
8383 }
8384 return (ret);
8385 }
8386
8387 static int
scsi_tgtmap_scsi_config(void * arg,damap_t * mapp,damap_id_t tgtid)8388 scsi_tgtmap_scsi_config(void *arg, damap_t *mapp, damap_id_t tgtid)
8389 {
8390 scsi_hba_tran_t *tran = (scsi_hba_tran_t *)arg;
8391 dev_info_t *self = tran->tran_iport_dip;
8392 impl_scsi_tgtmap_t *tgtmap;
8393 char *tgtaddr;
8394 int cfg_status, mt;
8395
8396 tgtmap = (impl_scsi_tgtmap_t *)tran->tran_tgtmap;
8397 tgtaddr = damap_id2addr(mapp, tgtid);
8398
8399 if (scsi_lunmap_create(self, tgtmap, tgtaddr) != DDI_SUCCESS) {
8400 SCSI_HBA_LOG((_LOG_NF(WARN),
8401 "failed to create lunmap for %s", tgtaddr));
8402 }
8403
8404 mt = ddi_prop_get_int(DDI_DEV_T_ANY, self,
8405 DDI_PROP_NOTPROM | DDI_PROP_DONTPASS, "scsi-enumeration",
8406 scsi_enumeration);
8407 mt |= scsi_hba_log_mt_disable;
8408
8409 cfg_status = scsi_hba_bus_config_taddr(self, tgtaddr, mt, SE_HP);
8410 if (cfg_status != NDI_SUCCESS) {
8411 SCSI_HBA_LOG((_LOGCFG, self, NULL, "%s @%s config status %d",
8412 damap_name(mapp), tgtaddr, cfg_status));
8413 scsi_lunmap_destroy(self, tgtmap, tgtaddr);
8414 return (DAM_FAILURE);
8415 }
8416
8417 return (DAM_SUCCESS);
8418 }
8419
8420
8421 static int
scsi_tgtmap_scsi_unconfig(void * arg,damap_t * mapp,damap_id_t tgtid)8422 scsi_tgtmap_scsi_unconfig(void *arg, damap_t *mapp, damap_id_t tgtid)
8423 {
8424 scsi_hba_tran_t *tran = (scsi_hba_tran_t *)arg;
8425 dev_info_t *self = tran->tran_iport_dip;
8426 impl_scsi_tgtmap_t *tgtmap;
8427 char *tgt_addr;
8428
8429 tgtmap = (impl_scsi_tgtmap_t *)tran->tran_tgtmap;
8430 tgt_addr = damap_id2addr(mapp, tgtid);
8431
8432 SCSI_HBA_LOG((_LOGUNCFG, self, NULL, "%s @%s", damap_name(mapp),
8433 tgt_addr));
8434 scsi_lunmap_destroy(self, tgtmap, tgt_addr);
8435 return (DAM_SUCCESS);
8436 }
8437
8438 static int
scsi_tgtmap_smp_config(void * arg,damap_t * mapp,damap_id_t tgtid)8439 scsi_tgtmap_smp_config(void *arg, damap_t *mapp, damap_id_t tgtid)
8440 {
8441 scsi_hba_tran_t *tran = (scsi_hba_tran_t *)arg;
8442 dev_info_t *self = tran->tran_iport_dip;
8443 char *addr;
8444
8445 addr = damap_id2addr(mapp, tgtid);
8446 SCSI_HBA_LOG((_LOGCFG, self, NULL, "%s @%s", damap_name(mapp), addr));
8447
8448 return ((smp_hba_bus_config_taddr(self, addr) == NDI_SUCCESS) ?
8449 DAM_SUCCESS : DAM_FAILURE);
8450 }
8451
8452 static int
scsi_tgtmap_smp_unconfig(void * arg,damap_t * mapp,damap_id_t tgtid)8453 scsi_tgtmap_smp_unconfig(void *arg, damap_t *mapp, damap_id_t tgtid)
8454 {
8455 scsi_hba_tran_t *tran = (scsi_hba_tran_t *)arg;
8456 dev_info_t *self = tran->tran_iport_dip;
8457 char *addr;
8458 dev_info_t *child;
8459 char nameaddr[SCSI_MAXNAMELEN];
8460 boolean_t enteredv;
8461
8462 addr = damap_id2addr(mapp, tgtid);
8463 SCSI_HBA_LOG((_LOGUNCFG, self, NULL, "%s @%s", damap_name(mapp), addr));
8464
8465 (void) snprintf(nameaddr, sizeof (nameaddr), "smp@%s", addr);
8466 scsi_hba_devi_enter(self, &enteredv);
8467 if ((child = ndi_devi_findchild(self, nameaddr)) == NULL) {
8468 scsi_hba_devi_exit(self, enteredv);
8469 return (DAM_SUCCESS);
8470 }
8471
8472 if (ndi_devi_offline(child,
8473 NDI_DEVFS_CLEAN | NDI_DEVI_REMOVE) == DDI_SUCCESS) {
8474 SCSI_HBA_LOG((_LOGUNCFG, self, NULL,
8475 "devinfo smp@%s offlined and removed", addr));
8476 } else if (ndi_devi_device_remove(child)) {
8477 /* Offline/remove failed, note new device_remove */
8478 SCSI_HBA_LOG((_LOGUNCFG, self, NULL,
8479 "devinfo smp@%s offline failed, device_remove",
8480 addr));
8481 }
8482 scsi_hba_devi_exit(self, enteredv);
8483 return (DAM_SUCCESS);
8484 }
8485
8486 /* ARGSUSED1 */
8487 static void
scsi_tgtmap_smp_activate(void * map_priv,char * tgt_addr,int addrid,void ** tgt_privp)8488 scsi_tgtmap_smp_activate(void *map_priv, char *tgt_addr, int addrid,
8489 void **tgt_privp)
8490 {
8491 impl_scsi_tgtmap_t *tgtmap = (impl_scsi_tgtmap_t *)map_priv;
8492 dev_info_t *self = tgtmap->tgtmap_tran->tran_iport_dip;
8493
8494 if (tgtmap->tgtmap_activate_cb) {
8495 SCSI_HBA_LOG((_LOGTGT, self, NULL, "%s @%s activated",
8496 damap_name(tgtmap->tgtmap_dam[SCSI_TGT_SMP_DEVICE]),
8497 tgt_addr));
8498
8499 (*tgtmap->tgtmap_activate_cb)(tgtmap->tgtmap_mappriv,
8500 tgt_addr, SCSI_TGT_SMP_DEVICE, tgt_privp);
8501 }
8502 }
8503
8504 /* ARGSUSED1 */
8505 static void
scsi_tgtmap_smp_deactivate(void * map_priv,char * tgt_addr,int addrid,void * tgt_privp,damap_deact_rsn_t damap_rsn)8506 scsi_tgtmap_smp_deactivate(void *map_priv, char *tgt_addr, int addrid,
8507 void *tgt_privp, damap_deact_rsn_t damap_rsn)
8508 {
8509 impl_scsi_tgtmap_t *tgtmap = (impl_scsi_tgtmap_t *)map_priv;
8510 dev_info_t *self = tgtmap->tgtmap_tran->tran_iport_dip;
8511 boolean_t tgtmap_rereport;
8512 scsi_tgtmap_deact_rsn_t tgtmap_rsn;
8513
8514 if (tgtmap->tgtmap_deactivate_cb) {
8515 SCSI_HBA_LOG((_LOGTGT, self, NULL, "%s @%s deactivated %d",
8516 damap_name(tgtmap->tgtmap_dam[SCSI_TGT_SMP_DEVICE]),
8517 tgt_addr, damap_rsn));
8518
8519 if (damap_rsn == DAMAP_DEACT_RSN_GONE)
8520 tgtmap_rsn = SCSI_TGT_DEACT_RSN_GONE;
8521 else if (damap_rsn == DAMAP_DEACT_RSN_CFG_FAIL)
8522 tgtmap_rsn = SCSI_TGT_DEACT_RSN_CFG_FAIL;
8523 else if (damap_rsn == DAMAP_DEACT_RSN_UNSTBL)
8524 tgtmap_rsn = SCSI_TGT_DEACT_RSN_UNSTBL;
8525 else {
8526 SCSI_HBA_LOG((_LOG(WARN), self, NULL,
8527 "%s @%s deactivated with unknown rsn",
8528 damap_name(tgtmap->tgtmap_dam[SCSI_TGT_SMP_DEVICE]),
8529 tgt_addr));
8530 return;
8531 }
8532
8533 tgtmap_rereport = (*tgtmap->tgtmap_deactivate_cb)
8534 (tgtmap->tgtmap_mappriv, tgt_addr,
8535 SCSI_TGT_SMP_DEVICE, tgt_privp, tgtmap_rsn);
8536
8537 if ((tgtmap_rsn == SCSI_TGT_DEACT_RSN_CFG_FAIL) &&
8538 (tgtmap_rereport == B_FALSE)) {
8539 SCSI_HBA_LOG((_LOG(WARN), NULL, self,
8540 "%s enumeration failed, no more retries until "
8541 "config change occurs", tgt_addr));
8542 }
8543 }
8544 }
8545
8546 /* ARGSUSED1 */
8547 static void
scsi_tgtmap_scsi_activate(void * map_priv,char * tgt_addr,int addrid,void ** tgt_privp)8548 scsi_tgtmap_scsi_activate(void *map_priv, char *tgt_addr, int addrid,
8549 void **tgt_privp)
8550 {
8551 impl_scsi_tgtmap_t *tgtmap = (impl_scsi_tgtmap_t *)map_priv;
8552 dev_info_t *self = tgtmap->tgtmap_tran->tran_iport_dip;
8553
8554 if (tgtmap->tgtmap_activate_cb) {
8555 SCSI_HBA_LOG((_LOGTGT, self, NULL, "%s @%s activated",
8556 damap_name(tgtmap->tgtmap_dam[SCSI_TGT_SCSI_DEVICE]),
8557 tgt_addr));
8558
8559 (*tgtmap->tgtmap_activate_cb)(tgtmap->tgtmap_mappriv,
8560 tgt_addr, SCSI_TGT_SCSI_DEVICE, tgt_privp);
8561 }
8562 }
8563
8564 /* ARGSUSED1 */
8565 static void
scsi_tgtmap_scsi_deactivate(void * map_priv,char * tgt_addr,int addrid,void * tgt_privp,damap_deact_rsn_t damap_rsn)8566 scsi_tgtmap_scsi_deactivate(void *map_priv, char *tgt_addr, int addrid,
8567 void *tgt_privp, damap_deact_rsn_t damap_rsn)
8568 {
8569 impl_scsi_tgtmap_t *tgtmap = (impl_scsi_tgtmap_t *)map_priv;
8570 dev_info_t *self = tgtmap->tgtmap_tran->tran_iport_dip;
8571 boolean_t tgtmap_rereport;
8572 scsi_tgtmap_deact_rsn_t tgtmap_rsn;
8573
8574 if (tgtmap->tgtmap_deactivate_cb) {
8575 SCSI_HBA_LOG((_LOGTGT, self, NULL, "%s @%s deactivated %d",
8576 damap_name(tgtmap->tgtmap_dam[SCSI_TGT_SCSI_DEVICE]),
8577 tgt_addr, damap_rsn));
8578
8579 if (damap_rsn == DAMAP_DEACT_RSN_GONE)
8580 tgtmap_rsn = SCSI_TGT_DEACT_RSN_GONE;
8581 else if (damap_rsn == DAMAP_DEACT_RSN_CFG_FAIL)
8582 tgtmap_rsn = SCSI_TGT_DEACT_RSN_CFG_FAIL;
8583 else if (damap_rsn == DAMAP_DEACT_RSN_UNSTBL)
8584 tgtmap_rsn = SCSI_TGT_DEACT_RSN_UNSTBL;
8585 else {
8586 SCSI_HBA_LOG((_LOG(WARN), self, NULL,
8587 "%s @%s deactivated with unknown rsn", damap_name(
8588 tgtmap->tgtmap_dam[SCSI_TGT_SCSI_DEVICE]),
8589 tgt_addr));
8590 return;
8591 }
8592
8593 tgtmap_rereport = (*tgtmap->tgtmap_deactivate_cb)
8594 (tgtmap->tgtmap_mappriv, tgt_addr,
8595 SCSI_TGT_SCSI_DEVICE, tgt_privp, tgtmap_rsn);
8596
8597 if ((tgtmap_rsn == SCSI_TGT_DEACT_RSN_CFG_FAIL) &&
8598 (tgtmap_rereport == B_FALSE)) {
8599 SCSI_HBA_LOG((_LOG(WARN), NULL, self,
8600 "%s enumeration failed, no more retries until "
8601 "config change occurs", tgt_addr));
8602 }
8603 }
8604 }
8605
8606
8607 int
scsi_hba_tgtmap_create(dev_info_t * self,scsi_tgtmap_mode_t mode,int csync_usec,int settle_usec,void * tgtmap_priv,scsi_tgt_activate_cb_t activate_cb,scsi_tgt_deactivate_cb_t deactivate_cb,scsi_hba_tgtmap_t ** handle)8608 scsi_hba_tgtmap_create(dev_info_t *self, scsi_tgtmap_mode_t mode,
8609 int csync_usec, int settle_usec, void *tgtmap_priv,
8610 scsi_tgt_activate_cb_t activate_cb, scsi_tgt_deactivate_cb_t deactivate_cb,
8611 scsi_hba_tgtmap_t **handle)
8612 {
8613 scsi_hba_tran_t *tran;
8614 damap_t *mapp;
8615 char context[64];
8616 impl_scsi_tgtmap_t *tgtmap;
8617 damap_rptmode_t rpt_style;
8618 char *scsi_binding_set;
8619 int optflags;
8620
8621 if (self == NULL || csync_usec == 0 ||
8622 settle_usec == 0 || handle == NULL)
8623 return (DDI_FAILURE);
8624
8625 *handle = NULL;
8626
8627 if (scsi_hba_iport_unit_address(self) == NULL)
8628 return (DDI_FAILURE);
8629
8630 switch (mode) {
8631 case SCSI_TM_FULLSET:
8632 rpt_style = DAMAP_REPORT_FULLSET;
8633 break;
8634 case SCSI_TM_PERADDR:
8635 rpt_style = DAMAP_REPORT_PERADDR;
8636 break;
8637 default:
8638 return (DDI_FAILURE);
8639 }
8640
8641 tran = (scsi_hba_tran_t *)ddi_get_driver_private(self);
8642 ASSERT(tran);
8643 if (tran == NULL)
8644 return (DDI_FAILURE);
8645
8646 tgtmap = kmem_zalloc(sizeof (*tgtmap), KM_SLEEP);
8647 tgtmap->tgtmap_tran = tran;
8648 tgtmap->tgtmap_activate_cb = activate_cb;
8649 tgtmap->tgtmap_deactivate_cb = deactivate_cb;
8650 tgtmap->tgtmap_mappriv = tgtmap_priv;
8651
8652 tgtmap->tgtmap_create_window = 1; /* start with window */
8653 tgtmap->tgtmap_create_time = ddi_get_lbolt64();
8654 tgtmap->tgtmap_create_csync_usec = csync_usec;
8655 tgtmap->tgtmap_settle_usec = settle_usec;
8656 tgtmap->tgtmap_sync_cnt = 0;
8657
8658 optflags = (ddi_prop_get_int(DDI_DEV_T_ANY, self,
8659 DDI_PROP_NOTPROM | DDI_PROP_DONTPASS, "scsi-enumeration",
8660 scsi_enumeration) & SCSI_ENUMERATION_MT_TARGET_DISABLE) ?
8661 DAMAP_SERIALCONFIG : DAMAP_MTCONFIG;
8662
8663 (void) snprintf(context, sizeof (context), "%s%d.tgtmap.scsi",
8664 ddi_driver_name(self), ddi_get_instance(self));
8665 SCSI_HBA_LOG((_LOGTGT, self, NULL, "%s", context));
8666 if (damap_create(context, rpt_style, optflags, settle_usec,
8667 tgtmap, scsi_tgtmap_scsi_activate, scsi_tgtmap_scsi_deactivate,
8668 tran, scsi_tgtmap_scsi_config, scsi_tgtmap_scsi_unconfig,
8669 &mapp) != DAM_SUCCESS) {
8670 kmem_free(tgtmap, sizeof (*tgtmap));
8671 return (DDI_FAILURE);
8672 }
8673 tgtmap->tgtmap_dam[SCSI_TGT_SCSI_DEVICE] = mapp;
8674
8675 (void) snprintf(context, sizeof (context), "%s%d.tgtmap.smp",
8676 ddi_driver_name(self), ddi_get_instance(self));
8677 SCSI_HBA_LOG((_LOGTGT, self, NULL, "%s", context));
8678 if (damap_create(context, rpt_style, optflags,
8679 settle_usec, tgtmap, scsi_tgtmap_smp_activate,
8680 scsi_tgtmap_smp_deactivate,
8681 tran, scsi_tgtmap_smp_config, scsi_tgtmap_smp_unconfig,
8682 &mapp) != DAM_SUCCESS) {
8683 damap_destroy(tgtmap->tgtmap_dam[SCSI_TGT_SCSI_DEVICE]);
8684 kmem_free(tgtmap, sizeof (*tgtmap));
8685 return (DDI_FAILURE);
8686 }
8687 tgtmap->tgtmap_dam[SCSI_TGT_SMP_DEVICE] = mapp;
8688
8689 tran->tran_tgtmap = (scsi_hba_tgtmap_t *)tgtmap;
8690 *handle = (scsi_hba_tgtmap_t *)tgtmap;
8691
8692 /*
8693 * We have now set tran_tgtmap, marking the tran as using tgtmap
8694 * enumeration services. To prevent the generation of legacy spi
8695 * 'binding-set' compatible forms, remove the 'scsi-binding-set'
8696 * property.
8697 */
8698 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, self,
8699 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "scsi-binding-set",
8700 &scsi_binding_set) == DDI_PROP_SUCCESS) {
8701 if (strcmp(scsi_binding_set, scsi_binding_set_spi) == 0)
8702 (void) ndi_prop_remove(DDI_DEV_T_NONE, self,
8703 "scsi-binding-set");
8704 ddi_prop_free(scsi_binding_set);
8705 }
8706 return (DDI_SUCCESS);
8707 }
8708
8709 void
scsi_hba_tgtmap_destroy(scsi_hba_tgtmap_t * handle)8710 scsi_hba_tgtmap_destroy(scsi_hba_tgtmap_t *handle)
8711 {
8712 impl_scsi_tgtmap_t *tgtmap = (impl_scsi_tgtmap_t *)handle;
8713 dev_info_t *self = tgtmap->tgtmap_tran->tran_iport_dip;
8714 int i;
8715
8716 for (i = 0; i < SCSI_TGT_NTYPES; i++) {
8717 if (tgtmap->tgtmap_dam[i]) {
8718 SCSI_HBA_LOG((_LOGTGT, self, NULL,
8719 "%s", damap_name(tgtmap->tgtmap_dam[i])));
8720 damap_destroy(tgtmap->tgtmap_dam[i]);
8721 }
8722 }
8723 kmem_free(tgtmap, sizeof (*tgtmap));
8724 }
8725
8726 /* return 1 if all maps ended up syned */
8727 static int
scsi_tgtmap_sync(scsi_hba_tgtmap_t * handle,int sync_usec)8728 scsi_tgtmap_sync(scsi_hba_tgtmap_t *handle, int sync_usec)
8729 {
8730 impl_scsi_tgtmap_t *tgtmap = (impl_scsi_tgtmap_t *)handle;
8731 dev_info_t *self = tgtmap->tgtmap_tran->tran_iport_dip;
8732 int all_synced = 1;
8733 int synced;
8734 int i;
8735
8736 for (i = 0; i < SCSI_TGT_NTYPES; i++) {
8737 if (tgtmap->tgtmap_dam[i]) {
8738 SCSI_HBA_LOG((_LOGTGT, self, NULL, "%s sync begin",
8739 damap_name(tgtmap->tgtmap_dam[i])));
8740 synced = damap_sync(tgtmap->tgtmap_dam[i], sync_usec);
8741 all_synced &= synced;
8742 SCSI_HBA_LOG((_LOGTGT, self, NULL, "%s sync end %d",
8743 damap_name(tgtmap->tgtmap_dam[i]), synced));
8744
8745 }
8746 }
8747 return (all_synced);
8748 }
8749
8750 /* return 1 if all maps ended up empty */
8751 static int
scsi_tgtmap_is_empty(scsi_hba_tgtmap_t * handle)8752 scsi_tgtmap_is_empty(scsi_hba_tgtmap_t *handle)
8753 {
8754 impl_scsi_tgtmap_t *tgtmap = (impl_scsi_tgtmap_t *)handle;
8755 dev_info_t *self = tgtmap->tgtmap_tran->tran_iport_dip;
8756 int all_empty = 1;
8757 int empty;
8758 int i;
8759
8760 for (i = 0; i < SCSI_TGT_NTYPES; i++) {
8761 if (tgtmap->tgtmap_dam[i]) {
8762 empty = damap_is_empty(tgtmap->tgtmap_dam[i]);
8763 all_empty &= empty;
8764 SCSI_HBA_LOG((_LOGTGT, self, NULL, "%s is_empty %d",
8765 damap_name(tgtmap->tgtmap_dam[i]), empty));
8766 }
8767 }
8768
8769 return (all_empty);
8770 }
8771
8772 static int
scsi_tgtmap_beginf(scsi_hba_tgtmap_t * handle,boolean_t do_begin)8773 scsi_tgtmap_beginf(scsi_hba_tgtmap_t *handle, boolean_t do_begin)
8774 {
8775 impl_scsi_tgtmap_t *tgtmap = (impl_scsi_tgtmap_t *)handle;
8776 dev_info_t *self = tgtmap->tgtmap_tran->tran_iport_dip;
8777 char *context;
8778 int rv = DAM_SUCCESS;
8779 int i;
8780
8781 for (i = 0; i < SCSI_TGT_NTYPES; i++) {
8782 if (tgtmap->tgtmap_dam[i] == NULL) {
8783 continue;
8784 }
8785
8786 context = damap_name(tgtmap->tgtmap_dam[i]);
8787 if (do_begin == B_TRUE) {
8788 if (i == SCSI_TGT_SCSI_DEVICE) {
8789 /*
8790 * In scsi_device context, so we have the
8791 * 'context' string, diagnose the case where
8792 * the tgtmap caller is failing to make
8793 * forward progress, i.e. the caller is never
8794 * completing an observation by calling
8795 * scsi_hbg_tgtmap_set_end. If this occurs,
8796 * the solaris target/lun state may be out
8797 * of sync with hardware.
8798 */
8799 if (tgtmap->tgtmap_reports++ >=
8800 scsi_hba_tgtmap_reports_max) {
8801 tgtmap->tgtmap_noisy++;
8802 if (tgtmap->tgtmap_noisy == 1) {
8803 SCSI_HBA_LOG((_LOG(WARN),
8804 self, NULL,
8805 "%s: failing tgtmap begin",
8806 context));
8807 }
8808 }
8809 }
8810
8811 rv = damap_addrset_begin(tgtmap->tgtmap_dam[i]);
8812 } else {
8813 rv = damap_addrset_flush(tgtmap->tgtmap_dam[i]);
8814 }
8815
8816 if (rv != DAM_SUCCESS) {
8817 SCSI_HBA_LOG((_LOGTGT, self, NULL, "%s FAIL", context));
8818 } else {
8819 SCSI_HBA_LOG((_LOGTGT, self, NULL, "%s", context));
8820 }
8821 }
8822
8823 return ((rv == DAM_SUCCESS) ? DDI_SUCCESS : DDI_FAILURE);
8824 }
8825
8826
8827 int
scsi_hba_tgtmap_set_begin(scsi_hba_tgtmap_t * handle)8828 scsi_hba_tgtmap_set_begin(scsi_hba_tgtmap_t *handle)
8829 {
8830 return (scsi_tgtmap_beginf(handle, B_TRUE));
8831 }
8832
8833 int
scsi_hba_tgtmap_set_flush(scsi_hba_tgtmap_t * handle)8834 scsi_hba_tgtmap_set_flush(scsi_hba_tgtmap_t *handle)
8835 {
8836 return (scsi_tgtmap_beginf(handle, B_FALSE));
8837 }
8838
8839 int
scsi_hba_tgtmap_set_add(scsi_hba_tgtmap_t * handle,scsi_tgtmap_tgt_type_t tgt_type,char * tgt_addr,void * tgt_priv)8840 scsi_hba_tgtmap_set_add(scsi_hba_tgtmap_t *handle,
8841 scsi_tgtmap_tgt_type_t tgt_type, char *tgt_addr, void *tgt_priv)
8842 {
8843 impl_scsi_tgtmap_t *tgtmap = (impl_scsi_tgtmap_t *)handle;
8844 dev_info_t *self = tgtmap->tgtmap_tran->tran_iport_dip;
8845
8846 if (tgt_type >= SCSI_TGT_NTYPES || !tgtmap->tgtmap_dam[tgt_type])
8847 return (DDI_FAILURE);
8848
8849 SCSI_HBA_LOG((_LOGTGT, self, NULL,
8850 "%s @%s", damap_name(tgtmap->tgtmap_dam[tgt_type]), tgt_addr));
8851
8852 return ((damap_addrset_add(tgtmap->tgtmap_dam[tgt_type], tgt_addr,
8853 NULL, NULL, tgt_priv) == DAM_SUCCESS) ? DDI_SUCCESS : DDI_FAILURE);
8854 }
8855
8856 /*ARGSUSED*/
8857 int
scsi_hba_tgtmap_set_end(scsi_hba_tgtmap_t * handle,uint_t flags)8858 scsi_hba_tgtmap_set_end(scsi_hba_tgtmap_t *handle, uint_t flags)
8859 {
8860 impl_scsi_tgtmap_t *tgtmap = (impl_scsi_tgtmap_t *)handle;
8861 dev_info_t *self = tgtmap->tgtmap_tran->tran_iport_dip;
8862 char *context;
8863 int rv = DDI_SUCCESS;
8864 int i;
8865
8866 tgtmap->tgtmap_reports = tgtmap->tgtmap_noisy = 0;
8867
8868 for (i = 0; i < SCSI_TGT_NTYPES; i++) {
8869 if (tgtmap->tgtmap_dam[i] == NULL)
8870 continue;
8871 context = damap_name(tgtmap->tgtmap_dam[i]);
8872 if (damap_addrset_end(
8873 tgtmap->tgtmap_dam[i], 0) != DAM_SUCCESS) {
8874 SCSI_HBA_LOG((_LOGTGT, self, NULL, "%s FAIL", context));
8875 rv = DDI_FAILURE;
8876 continue;
8877 }
8878
8879 SCSI_HBA_LOG((_LOGTGT, self, NULL, "%s", context));
8880 }
8881 return (rv);
8882 }
8883
8884 int
scsi_hba_tgtmap_tgt_add(scsi_hba_tgtmap_t * handle,scsi_tgtmap_tgt_type_t tgt_type,char * tgt_addr,void * tgt_priv)8885 scsi_hba_tgtmap_tgt_add(scsi_hba_tgtmap_t *handle,
8886 scsi_tgtmap_tgt_type_t tgt_type, char *tgt_addr, void *tgt_priv)
8887 {
8888 impl_scsi_tgtmap_t *tgtmap = (impl_scsi_tgtmap_t *)handle;
8889 dev_info_t *self = tgtmap->tgtmap_tran->tran_iport_dip;
8890
8891 if (tgt_type >= SCSI_TGT_NTYPES || !tgtmap->tgtmap_dam[tgt_type])
8892 return (DDI_FAILURE);
8893
8894 SCSI_HBA_LOG((_LOGTGT, self, NULL,
8895 "%s @%s", damap_name(tgtmap->tgtmap_dam[tgt_type]), tgt_addr));
8896
8897 return ((damap_addr_add(tgtmap->tgtmap_dam[tgt_type], tgt_addr, NULL,
8898 NULL, tgt_priv) == DAM_SUCCESS) ? DDI_SUCCESS : DDI_FAILURE);
8899 }
8900
8901 int
scsi_hba_tgtmap_tgt_remove(scsi_hba_tgtmap_t * handle,scsi_tgtmap_tgt_type_t tgt_type,char * tgt_addr)8902 scsi_hba_tgtmap_tgt_remove(scsi_hba_tgtmap_t *handle,
8903 scsi_tgtmap_tgt_type_t tgt_type, char *tgt_addr)
8904 {
8905 impl_scsi_tgtmap_t *tgtmap = (impl_scsi_tgtmap_t *)handle;
8906 dev_info_t *self = tgtmap->tgtmap_tran->tran_iport_dip;
8907
8908 if (tgt_type >= SCSI_TGT_NTYPES || !tgtmap->tgtmap_dam[tgt_type])
8909 return (DDI_FAILURE);
8910
8911 SCSI_HBA_LOG((_LOGTGT, self, NULL,
8912 "%s @%s", damap_name(tgtmap->tgtmap_dam[tgt_type]), tgt_addr));
8913
8914 return ((damap_addr_del(tgtmap->tgtmap_dam[tgt_type],
8915 tgt_addr) == DAM_SUCCESS) ? DDI_SUCCESS : DDI_FAILURE);
8916 }
8917
8918 void
scsi_hba_tgtmap_scan_luns(scsi_hba_tgtmap_t * handle,char * tgt_addr)8919 scsi_hba_tgtmap_scan_luns(scsi_hba_tgtmap_t *handle, char *tgt_addr)
8920 {
8921 impl_scsi_tgtmap_t *tgtmap = (impl_scsi_tgtmap_t *)handle;
8922 dev_info_t *self = tgtmap->tgtmap_tran->tran_iport_dip;
8923 struct scsi_lunchg2 *lunchg2;
8924 struct scsi_lunchg2 *p;
8925 char path[MAXPATHLEN];
8926
8927 (void) ddi_pathname(self, path);
8928 (void) strlcat(path, "/luns@", sizeof (path));
8929 (void) strlcat(path, tgt_addr, sizeof (path));
8930 (void) strlcat(path, ",*", sizeof (path));
8931
8932 mutex_enter(&scsi_lunchg2_mutex);
8933
8934 /* if we're already scheduled to do this, don't submit another one */
8935 for (p = scsi_lunchg2_list; p != NULL; p = p->lunchg2_next) {
8936 if (strcmp(path, p->lunchg2_path) == 0) {
8937 mutex_exit(&scsi_lunchg2_mutex);
8938 return;
8939 }
8940 }
8941
8942 lunchg2 = kmem_alloc(sizeof (*lunchg2), KM_SLEEP);
8943 lunchg2->lunchg2_path = strdup(path);
8944 lunchg2->lunchg2_next = scsi_lunchg2_list;
8945 scsi_lunchg2_list = lunchg2;
8946 if (lunchg2->lunchg2_next == NULL)
8947 cv_signal(&scsi_lunchg2_cv);
8948 mutex_exit(&scsi_lunchg2_mutex);
8949 }
8950
8951 int
scsi_hba_tgtmap_lookup(scsi_hba_tgtmap_t * handle,char * tgt_addr,scsi_tgtmap_tgt_type_t * r_type)8952 scsi_hba_tgtmap_lookup(scsi_hba_tgtmap_t *handle,
8953 char *tgt_addr, scsi_tgtmap_tgt_type_t *r_type)
8954 {
8955 impl_scsi_tgtmap_t *tgtmap = (impl_scsi_tgtmap_t *)handle;
8956 dev_info_t *self = tgtmap->tgtmap_tran->tran_iport_dip;
8957 damap_id_t tgtid;
8958 int i;
8959
8960 for (i = 0; i < SCSI_TGT_NTYPES; i++) {
8961 tgtid = damap_lookup(tgtmap->tgtmap_dam[i], tgt_addr);
8962 if (tgtid != NODAM) {
8963 *r_type = i;
8964 SCSI_HBA_LOG((_LOG(3), self, NULL,
8965 "%s @%s found: type %d",
8966 damap_name(tgtmap->tgtmap_dam[i]), tgt_addr, i));
8967 damap_id_rele(tgtmap->tgtmap_dam[i], tgtid);
8968 return (DDI_SUCCESS);
8969 }
8970 }
8971
8972 SCSI_HBA_LOG((_LOG(3), self, NULL,
8973 "%s%d.tgtmap @%s not found",
8974 ddi_driver_name(self), ddi_get_instance(self), tgt_addr));
8975 return (DDI_FAILURE);
8976 }
8977
8978 /*
8979 * Return the unit-address of an 'iport' node, or NULL for non-iport node.
8980 */
8981 char *
scsi_hba_iport_unit_address(dev_info_t * self)8982 scsi_hba_iport_unit_address(dev_info_t *self)
8983 {
8984 /*
8985 * NOTE: Since 'self' could be a SCSA iport node or a SCSA HBA node,
8986 * we can't use SCSA flavors: the flavor of a SCSA HBA node is not
8987 * established/owned by SCSA, it is established by the nexus that
8988 * created the SCSA HBA node (PCI) as a child.
8989 *
8990 * NOTE: If we want to support a node_name other than "iport" for
8991 * an iport node then we can add support for a "scsa-iport-node-name"
8992 * property on the SCSA HBA node. A SCSA HBA driver would set this
8993 * property on the SCSA HBA node prior to using the iport API.
8994 */
8995 if (strcmp(ddi_node_name(self), "iport") == 0)
8996 return (ddi_get_name_addr(self));
8997 else
8998 return (NULL);
8999 }
9000
9001 /*
9002 * Define a SCSI initiator port (bus/channel) for an HBA card that needs to
9003 * support multiple SCSI ports, but only has a single HBA devinfo node. This
9004 * function should be called from the HBA's attach(9E) implementation (when
9005 * processing the HBA devinfo node attach) after the number of SCSI ports on
9006 * the card is known or when the HBA driver DR handler detects a new port.
9007 * The function returns 0 on failure and 1 on success.
9008 *
9009 * The implementation will add the port value into the "scsi-iports" property
9010 * value maintained on the HBA node as. These properties are used by the generic
9011 * scsi bus_config implementation to dynamicaly enumerate the specified iport
9012 * children. The enumeration code will, on demand, create the appropriate
9013 * iport children with a SCSI_ADDR_PROP_IPORTUA unit address. This node will
9014 * bind to the same driver as the HBA node itself. This means that an HBA
9015 * driver that uses iports should expect probe(9E), attach(9E), and detach(9E)
9016 * calls on the iport children of the HBA. If configuration for all ports was
9017 * already done during HBA node attach, the driver should just return
9018 * DDI_SUCCESS when confronted with an iport node.
9019 *
9020 * A maximum of 32 iport ports are supported per HBA devinfo node.
9021 *
9022 * A NULL "port" can be used to indicate that the framework should enumerate
9023 * target children on the HBA node itself, in addition to enumerating target
9024 * children on any iport nodes declared. There are two reasons that an HBA may
9025 * wish to have target children enumerated on both the HBA node and iport
9026 * node(s):
9027 *
9028 * o If, in the past, HBA hardware had only a single physical port but now
9029 * supports multiple physical ports, the updated driver that supports
9030 * multiple physical ports may want to avoid /devices path upgrade issues
9031 * by enumerating the first physical port under the HBA instead of as a
9032 * iport.
9033 *
9034 * o Some hardware RAID HBA controllers (mlx, chs, etc) support multiple
9035 * SCSI physical ports configured so that various physical devices on
9036 * the physical ports are amalgamated into virtual devices on a virtual
9037 * port. Amalgamated physical devices no longer appear to the host OS
9038 * on the physical ports, but other non-amalgamated devices may still be
9039 * visible on the physical ports. These drivers use a model where the
9040 * physical ports are iport nodes and the HBA node is the virtual port to
9041 * the configured virtual devices.
9042 */
9043 int
scsi_hba_iport_register(dev_info_t * self,char * port)9044 scsi_hba_iport_register(dev_info_t *self, char *port)
9045 {
9046 unsigned int ports = 0;
9047 int rval, i;
9048 char **iports, **newiports;
9049
9050 ASSERT(self);
9051 if (self == NULL)
9052 return (DDI_FAILURE);
9053
9054 rval = ddi_prop_lookup_string_array(DDI_DEV_T_ANY, self,
9055 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "scsi-iports", &iports,
9056 &ports);
9057
9058 if (ports >= SCSI_HBA_MAX_IPORTS) {
9059 ddi_prop_free(iports);
9060 return (DDI_FAILURE);
9061 }
9062
9063 if (rval == DDI_PROP_SUCCESS) {
9064 for (i = 0; i < ports; i++) {
9065 if (strcmp(port, iports[i]) == 0) {
9066 /* iport already registered */
9067 ddi_prop_free(iports);
9068 return (DDI_SUCCESS);
9069 }
9070 }
9071 }
9072
9073 newiports = kmem_alloc((sizeof (char *) * (ports + 1)), KM_SLEEP);
9074
9075 for (i = 0; i < ports; i++) {
9076 newiports[i] = strdup(iports[i]);
9077 }
9078 newiports[ports] = strdup(port);
9079 ports++;
9080
9081 if (ddi_prop_update_string_array(DDI_DEV_T_NONE, self,
9082 "scsi-iports", newiports, ports) != DDI_PROP_SUCCESS) {
9083 SCSI_HBA_LOG((_LOG(WARN), self, NULL,
9084 "failed to establish %s %s",
9085 SCSI_ADDR_PROP_IPORTUA, port));
9086 rval = DDI_FAILURE;
9087 } else {
9088 rval = DDI_SUCCESS;
9089 }
9090
9091 /* If there is iport exist, free property */
9092 if (ports > 1)
9093 ddi_prop_free(iports);
9094 for (i = 0; i < ports; i++) {
9095 strfree(newiports[i]);
9096 }
9097 kmem_free(newiports, (sizeof (char *)) * ports);
9098
9099 return (rval);
9100 }
9101
9102 /*
9103 * Check if the HBA has any scsi_hba_iport_register()ed children.
9104 */
9105 int
scsi_hba_iport_exist(dev_info_t * self)9106 scsi_hba_iport_exist(dev_info_t *self)
9107 {
9108 unsigned int ports = 0;
9109 char **iports;
9110 int rval;
9111
9112 rval = ddi_prop_lookup_string_array(DDI_DEV_T_ANY, self,
9113 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "scsi-iports", &iports,
9114 &ports);
9115
9116 if (rval != DDI_PROP_SUCCESS)
9117 return (0);
9118
9119 /* If there is now at least 1 iport, then iports is valid */
9120 if (ports > 0) {
9121 rval = 1;
9122 } else
9123 rval = 0;
9124 ddi_prop_free(iports);
9125
9126 return (rval);
9127 }
9128
9129 dev_info_t *
scsi_hba_iport_find(dev_info_t * self,char * portnm)9130 scsi_hba_iport_find(dev_info_t *self, char *portnm)
9131 {
9132 char *addr = NULL;
9133 char **iports;
9134 unsigned int num_iports = 0;
9135 int rval = DDI_FAILURE;
9136 int i = 0;
9137 dev_info_t *child = NULL;
9138
9139 /* check to see if this is an HBA that defined scsi iports */
9140 rval = ddi_prop_lookup_string_array(DDI_DEV_T_ANY, self,
9141 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "scsi-iports", &iports,
9142 &num_iports);
9143
9144 if (rval != DDI_SUCCESS) {
9145 return (NULL);
9146 }
9147 ASSERT(num_iports > 0);
9148
9149 /* check to see if this port was registered */
9150 for (i = 0; i < num_iports; i++) {
9151 if (strcmp(iports[i], portnm) == 0)
9152 break;
9153 }
9154
9155 if (i == num_iports) {
9156 child = NULL;
9157 goto out;
9158 }
9159
9160 addr = kmem_zalloc(SCSI_MAXNAMELEN, KM_SLEEP);
9161 (void) snprintf(addr, SCSI_MAXNAMELEN, "iport@%s", portnm);
9162 rval = ndi_devi_config_one(self, addr, &child, NDI_NO_EVENT);
9163 kmem_free(addr, SCSI_MAXNAMELEN);
9164
9165 if (rval != DDI_SUCCESS) {
9166 child = NULL;
9167 }
9168 out:
9169 ddi_prop_free(iports);
9170 return (child);
9171 }
9172
9173 /*
9174 * Search/create the specified iport node
9175 */
9176 static dev_info_t *
scsi_hba_bus_config_port(dev_info_t * self,char * nameaddr,scsi_enum_t se)9177 scsi_hba_bus_config_port(dev_info_t *self, char *nameaddr, scsi_enum_t se)
9178 {
9179 dev_info_t *child; /* iport child of HBA node */
9180 scsi_hba_tran_t *tran;
9181 char *addr;
9182 char *compat;
9183
9184 /*
9185 * See if the iport node already exists.
9186 */
9187 addr = nameaddr + strlen("iport@");
9188 if (child = ndi_devi_findchild(self, nameaddr)) {
9189 if (ndi_devi_device_isremoved(child)) {
9190 if ((se == SE_HP) || !ndi_dev_is_hotplug_node(child)) {
9191 if (ndi_devi_device_insert(child))
9192 SCSI_HBA_LOG((_LOGCFG, self, NULL,
9193 "devinfo iport@%s device_reinsert",
9194 addr));
9195 } else
9196 return (NULL);
9197 }
9198 return (child);
9199 }
9200
9201
9202 /*
9203 * If config based on scsi_hba_iportmap API, only allow create
9204 * from hotplug.
9205 */
9206 tran = ndi_flavorv_get(self, SCSA_FLAVOR_SCSI_DEVICE);
9207 ASSERT(tran);
9208 if (tran->tran_iportmap && (se != SE_HP))
9209 return (NULL);
9210
9211 /* allocate and initialize a new "iport" node */
9212 ndi_devi_alloc_sleep(self, "iport",
9213 (se == SE_HP) ? DEVI_SID_HP_NODEID : DEVI_SID_NODEID,
9214 &child);
9215 ASSERT(child);
9216 /*
9217 * Set the flavor of the child to be IPORT flavored
9218 */
9219 ndi_flavor_set(child, SCSA_FLAVOR_IPORT);
9220
9221 /*
9222 * Add the SCSI_ADDR_PROP_IPORTUA addressing property for this child.
9223 * This property is used to identify a iport node, and to represent the
9224 * nodes @addr form via node properties.
9225 *
9226 * Add "compatible" property to the "scsi-iport" node to cause it bind
9227 * to the same driver as the HBA driver. Use the "driver" name
9228 * instead of the "binding name" to distinguish from hw node.
9229 *
9230 * Give the HBA a chance, via tran_set_name_prop, to set additional
9231 * iport node properties or to change the "compatible" binding
9232 * prior to init_child.
9233 *
9234 * NOTE: the order of these operations is important so that
9235 * scsi_hba_iport works when called.
9236 */
9237 compat = (char *)ddi_driver_name(self);
9238 if ((ndi_prop_update_string(DDI_DEV_T_NONE, child,
9239 SCSI_ADDR_PROP_IPORTUA, addr) != DDI_PROP_SUCCESS) ||
9240 (ndi_prop_update_string_array(DDI_DEV_T_NONE, child,
9241 "compatible", &compat, 1) != DDI_PROP_SUCCESS) ||
9242 ddi_pathname_obp_set(child, NULL) != DDI_SUCCESS) {
9243 SCSI_HBA_LOG((_LOG_NF(WARN), "%s failed dynamic decoration",
9244 nameaddr));
9245 (void) ddi_remove_child(child, 0);
9246 child = NULL;
9247 } else {
9248 /*
9249 * Online/attach in order to get events so devfsadm will
9250 * create public names.
9251 */
9252 ndi_hold_devi(child);
9253 if (ndi_devi_online(child, 0) != NDI_SUCCESS) {
9254 ndi_rele_devi(child);
9255 ndi_prop_remove_all(child);
9256 (void) ndi_devi_free(child);
9257 child = NULL;
9258 } else
9259 ndi_rele_devi(child);
9260 }
9261
9262 return (child);
9263 }
9264
9265 #ifdef sparc
9266 /*
9267 * Future: When iportmap boot support is added, consider rewriting this to
9268 * perform a scsi_hba_bus_config(BUS_CONFIG_ALL) on self (HBA) followed by
9269 * a scsi_hba_bus_config(BUS_CONFIG_ONE) on each child of self (each iport).
9270 */
9271 /* ARGSUSED */
9272 static int
scsi_hba_bus_config_prom_node(dev_info_t * self,uint_t flags,void * arg,dev_info_t ** childp)9273 scsi_hba_bus_config_prom_node(dev_info_t *self, uint_t flags,
9274 void *arg, dev_info_t **childp)
9275 {
9276 char **iports;
9277 boolean_t enteredv;
9278 int i;
9279 int ret = NDI_FAILURE;
9280 unsigned int num_iports = 0;
9281 dev_info_t *pdip = NULL;
9282 char *addr = NULL;
9283
9284 /* check to see if this is an HBA that defined scsi iports */
9285 ret = ddi_prop_lookup_string_array(DDI_DEV_T_ANY, self,
9286 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "scsi-iports", &iports,
9287 &num_iports);
9288
9289 if (ret != DDI_SUCCESS) {
9290 return (ret);
9291 }
9292
9293 ASSERT(num_iports > 0);
9294
9295 addr = kmem_zalloc(SCSI_MAXNAMELEN, KM_SLEEP);
9296
9297 ret = NDI_FAILURE;
9298
9299 scsi_hba_devi_enter(self, &enteredv);
9300
9301 /* create iport nodes for each scsi port/bus */
9302 for (i = 0; i < num_iports; i++) {
9303 bzero(addr, SCSI_MAXNAMELEN);
9304 /* Prepend the iport name */
9305 (void) snprintf(addr, SCSI_MAXNAMELEN, "iport@%s",
9306 iports[i]);
9307 if (pdip = scsi_hba_bus_config_port(self, addr, SE_BUSCONFIG)) {
9308 if (ndi_busop_bus_config(self, NDI_NO_EVENT,
9309 BUS_CONFIG_ONE, addr, &pdip, 0) !=
9310 NDI_SUCCESS) {
9311 continue;
9312 }
9313 /*
9314 * Try to configure child under iport see wehter
9315 * request node is the child of the iport node
9316 */
9317 if (ndi_devi_config_one(pdip, arg, childp,
9318 NDI_NO_EVENT) == NDI_SUCCESS) {
9319 ret = NDI_SUCCESS;
9320 break;
9321 }
9322 }
9323 }
9324
9325 scsi_hba_devi_exit(self, enteredv);
9326
9327 kmem_free(addr, SCSI_MAXNAMELEN);
9328
9329 ddi_prop_free(iports);
9330
9331 return (ret);
9332 }
9333 #endif
9334
9335 /*
9336 * Perform iport port/bus bus_config.
9337 */
9338 static int
scsi_hba_bus_config_iports(dev_info_t * self,uint_t flags,ddi_bus_config_op_t op,void * arg,dev_info_t ** childp)9339 scsi_hba_bus_config_iports(dev_info_t *self, uint_t flags,
9340 ddi_bus_config_op_t op, void *arg, dev_info_t **childp)
9341 {
9342 char *nameaddr, *addr;
9343 char **iports;
9344 boolean_t enteredv;
9345 int i;
9346 int ret = NDI_FAILURE;
9347 unsigned int num_iports = 0;
9348
9349 /* check to see if this is an HBA that defined scsi iports */
9350 ret = ddi_prop_lookup_string_array(DDI_DEV_T_ANY, self,
9351 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "scsi-iports", &iports,
9352 &num_iports);
9353
9354 if (ret != DDI_SUCCESS) {
9355 return (ret);
9356 }
9357
9358 ASSERT(num_iports > 0);
9359
9360 scsi_hba_devi_enter(self, &enteredv);
9361
9362 switch (op) {
9363 case BUS_CONFIG_ONE:
9364 /* return if this operation is not against an iport node */
9365 nameaddr = (char *)arg;
9366 if ((nameaddr == NULL) ||
9367 (strncmp(nameaddr, "iport@", strlen("iport@")) != 0)) {
9368 ret = NDI_FAILURE;
9369 scsi_hba_devi_exit(self, enteredv);
9370 ddi_prop_free(iports);
9371 return (ret);
9372 }
9373
9374 /* parse the port number from "iport@%s" */
9375 addr = nameaddr + strlen("iport@");
9376
9377 /* check to see if this port was registered */
9378 for (i = 0; i < num_iports; i++) {
9379 if (strcmp((iports[i]), addr) == 0)
9380 break;
9381 }
9382
9383 if (i == num_iports) {
9384 ret = NDI_FAILURE;
9385 break;
9386 }
9387
9388 /* create the iport node child */
9389 if (scsi_hba_bus_config_port(self, nameaddr, SE_BUSCONFIG)) {
9390 ret = NDI_SUCCESS;
9391 }
9392 break;
9393
9394 case BUS_CONFIG_ALL:
9395 case BUS_CONFIG_DRIVER:
9396 addr = kmem_zalloc(SCSI_MAXNAMELEN, KM_SLEEP);
9397 /* create iport nodes for each scsi port/bus */
9398 for (i = 0; i < num_iports; i++) {
9399 bzero(addr, SCSI_MAXNAMELEN);
9400 /* Prepend the iport name */
9401 (void) snprintf(addr, SCSI_MAXNAMELEN, "iport@%s",
9402 iports[i]);
9403 (void) scsi_hba_bus_config_port(self, addr,
9404 SE_BUSCONFIG);
9405 }
9406
9407 kmem_free(addr, SCSI_MAXNAMELEN);
9408 ret = NDI_SUCCESS;
9409 break;
9410 }
9411 if (ret == NDI_SUCCESS) {
9412 #ifdef sparc
9413 /*
9414 * Mask NDI_PROMNAME since PROM doesn't have iport
9415 * node at all.
9416 */
9417 flags &= (~NDI_PROMNAME);
9418 #endif
9419 flags |= NDI_MDI_FALLBACK; /* devinfo&pathinfo children */
9420 ret = ndi_busop_bus_config(self, flags, op,
9421 arg, childp, 0);
9422 }
9423 scsi_hba_devi_exit(self, enteredv);
9424
9425 ddi_prop_free(iports);
9426
9427 return (ret);
9428 }
9429
9430 static int
scsi_iportmap_config(void * arg,damap_t * mapp,damap_id_t tgtid)9431 scsi_iportmap_config(void *arg, damap_t *mapp, damap_id_t tgtid)
9432 {
9433 dev_info_t *self = (dev_info_t *)arg;
9434 boolean_t enteredv;
9435 char nameaddr[SCSI_MAXNAMELEN];
9436 char *iport_addr;
9437 dev_info_t *childp;
9438
9439 scsi_hba_devi_enter(self, &enteredv);
9440
9441 iport_addr = damap_id2addr(mapp, tgtid);
9442 SCSI_HBA_LOG((_LOGIPT, self, NULL,
9443 "%s @%s", damap_name(mapp), iport_addr));
9444
9445 (void) snprintf(nameaddr, sizeof (nameaddr), "iport@%s", iport_addr);
9446 childp = scsi_hba_bus_config_port(self, nameaddr, SE_HP);
9447 scsi_hba_devi_exit(self, enteredv);
9448 return (childp != NULL ? DAM_SUCCESS : DAM_FAILURE);
9449 }
9450
9451 static int
scsi_iportmap_unconfig(void * arg,damap_t * mapp,damap_id_t tgtid)9452 scsi_iportmap_unconfig(void *arg, damap_t *mapp, damap_id_t tgtid)
9453 {
9454 dev_info_t *self = arg;
9455 dev_info_t *childp; /* iport child of HBA node */
9456 boolean_t enteredv;
9457 int empty;
9458 char *addr;
9459 char nameaddr[SCSI_MAXNAMELEN];
9460 scsi_hba_tran_t *tran;
9461
9462 addr = damap_id2addr(mapp, tgtid);
9463 SCSI_HBA_LOG((_LOGIPT, self, NULL, "%s @%s", damap_name(mapp), addr));
9464
9465 (void) snprintf(nameaddr, sizeof (nameaddr), "iport@%s", addr);
9466 scsi_hba_devi_enter(self, &enteredv);
9467 if ((childp = ndi_devi_findchild(self, nameaddr)) == NULL) {
9468 scsi_hba_devi_exit(self, enteredv);
9469 return (DAM_FAILURE);
9470 }
9471
9472 tran = ddi_get_driver_private(childp);
9473 ASSERT(tran);
9474
9475 ndi_hold_devi(childp);
9476 scsi_hba_devi_exit(self, enteredv);
9477
9478 /*
9479 * A begin/end (clear) against the iport's
9480 * tgtmap will trigger unconfigure of all
9481 * targets on the iport.
9482 *
9483 * Future: This bit of code only works if the
9484 * target map reporting style is are full
9485 * reports and not per-address. Maybe we
9486 * should plan on handling this by
9487 * auto-unconfiguration when destroying the
9488 * target map(s).
9489 */
9490 (void) scsi_hba_tgtmap_set_begin(tran->tran_tgtmap);
9491 (void) scsi_hba_tgtmap_set_end(tran->tran_tgtmap, 0);
9492
9493 /* wait for unconfigure */
9494 (void) scsi_tgtmap_sync(tran->tran_tgtmap, 0);
9495 empty = scsi_tgtmap_is_empty(tran->tran_tgtmap);
9496
9497 scsi_hba_devi_enter(self, &enteredv);
9498 ndi_rele_devi(childp);
9499
9500 /* If begin/end/sync ends in empty map, offline/remove. */
9501 if (empty) {
9502 if (ndi_devi_offline(childp,
9503 NDI_DEVFS_CLEAN | NDI_DEVI_REMOVE) == DDI_SUCCESS) {
9504 SCSI_HBA_LOG((_LOGUNCFG, self, NULL,
9505 "devinfo iport@%s offlined and removed",
9506 addr));
9507 } else if (ndi_devi_device_remove(childp)) {
9508 /* Offline/rem failed, note new device_remove */
9509 SCSI_HBA_LOG((_LOGUNCFG, self, NULL,
9510 "devinfo iport@%s offline failed, "
9511 "device_remove", addr));
9512 }
9513 }
9514 scsi_hba_devi_exit(self, enteredv);
9515 return (empty ? DAM_SUCCESS : DAM_FAILURE);
9516 }
9517
9518
9519 int
scsi_hba_iportmap_create(dev_info_t * self,int csync_usec,int settle_usec,scsi_hba_iportmap_t ** handle)9520 scsi_hba_iportmap_create(dev_info_t *self, int csync_usec, int settle_usec,
9521 scsi_hba_iportmap_t **handle)
9522 {
9523 scsi_hba_tran_t *tran;
9524 damap_t *mapp;
9525 char context[64];
9526 impl_scsi_iportmap_t *iportmap;
9527
9528 if (self == NULL || csync_usec == 0 ||
9529 settle_usec == 0 || handle == NULL)
9530 return (DDI_FAILURE);
9531
9532 *handle = NULL;
9533
9534 if (scsi_hba_iport_unit_address(self) != NULL)
9535 return (DDI_FAILURE);
9536
9537 tran = (scsi_hba_tran_t *)ddi_get_driver_private(self);
9538 ASSERT(tran);
9539 if (tran == NULL)
9540 return (DDI_FAILURE);
9541
9542 (void) snprintf(context, sizeof (context), "%s%d.iportmap",
9543 ddi_driver_name(self), ddi_get_instance(self));
9544
9545 if (damap_create(context, DAMAP_REPORT_PERADDR, DAMAP_SERIALCONFIG,
9546 settle_usec, NULL, NULL, NULL, self,
9547 scsi_iportmap_config, scsi_iportmap_unconfig, &mapp) !=
9548 DAM_SUCCESS) {
9549 return (DDI_FAILURE);
9550 }
9551 iportmap = kmem_zalloc(sizeof (*iportmap), KM_SLEEP);
9552 iportmap->iportmap_hba_dip = self;
9553 iportmap->iportmap_dam = mapp;
9554
9555 iportmap->iportmap_create_window = 1; /* start with window */
9556 iportmap->iportmap_create_time = ddi_get_lbolt64();
9557 iportmap->iportmap_create_csync_usec = csync_usec;
9558 iportmap->iportmap_settle_usec = settle_usec;
9559 iportmap->iportmap_sync_cnt = 0;
9560
9561 tran->tran_iportmap = (scsi_hba_iportmap_t *)iportmap;
9562 *handle = (scsi_hba_iportmap_t *)iportmap;
9563
9564 SCSI_HBA_LOG((_LOGIPT, self, NULL, "%s", damap_name(mapp)));
9565 return (DDI_SUCCESS);
9566 }
9567
9568 void
scsi_hba_iportmap_destroy(scsi_hba_iportmap_t * handle)9569 scsi_hba_iportmap_destroy(scsi_hba_iportmap_t *handle)
9570 {
9571 impl_scsi_iportmap_t *iportmap = (impl_scsi_iportmap_t *)handle;
9572 dev_info_t *self = iportmap->iportmap_hba_dip;
9573
9574 SCSI_HBA_LOG((_LOGIPT, self, NULL,
9575 "%s", damap_name(iportmap->iportmap_dam)));
9576
9577 damap_destroy(iportmap->iportmap_dam);
9578 kmem_free(iportmap, sizeof (*iportmap));
9579 }
9580
9581 int
scsi_hba_iportmap_iport_add(scsi_hba_iportmap_t * handle,char * iport_addr,void * iport_priv)9582 scsi_hba_iportmap_iport_add(scsi_hba_iportmap_t *handle,
9583 char *iport_addr, void *iport_priv)
9584 {
9585 impl_scsi_iportmap_t *iportmap = (impl_scsi_iportmap_t *)handle;
9586 dev_info_t *self = iportmap->iportmap_hba_dip;
9587
9588 SCSI_HBA_LOG((_LOGIPT, self, NULL,
9589 "%s @%s", damap_name(iportmap->iportmap_dam), iport_addr));
9590
9591 return ((damap_addr_add(iportmap->iportmap_dam, iport_addr, NULL,
9592 NULL, iport_priv) == DAM_SUCCESS) ? DDI_SUCCESS : DDI_FAILURE);
9593 }
9594
9595 int
scsi_hba_iportmap_iport_remove(scsi_hba_iportmap_t * handle,char * iport_addr)9596 scsi_hba_iportmap_iport_remove(scsi_hba_iportmap_t *handle,
9597 char *iport_addr)
9598 {
9599 impl_scsi_iportmap_t *iportmap = (impl_scsi_iportmap_t *)handle;
9600 dev_info_t *self = iportmap->iportmap_hba_dip;
9601
9602 SCSI_HBA_LOG((_LOGIPT, self, NULL,
9603 "%s @%s", damap_name(iportmap->iportmap_dam), iport_addr));
9604
9605 return ((damap_addr_del(iportmap->iportmap_dam,
9606 iport_addr) == DAM_SUCCESS) ? DDI_SUCCESS : DDI_FAILURE);
9607 }
9608
9609 int
scsi_hba_iportmap_lookup(scsi_hba_iportmap_t * handle,char * iport_addr)9610 scsi_hba_iportmap_lookup(scsi_hba_iportmap_t *handle,
9611 char *iport_addr)
9612 {
9613 impl_scsi_iportmap_t *iportmap = (impl_scsi_iportmap_t *)handle;
9614 dev_info_t *self = iportmap->iportmap_hba_dip;
9615 damap_id_t iportid;
9616
9617 iportid = damap_lookup(iportmap->iportmap_dam, iport_addr);
9618 if (iportid != NODAM) {
9619 SCSI_HBA_LOG((_LOG(3), self, NULL,
9620 "%s @%s found",
9621 damap_name(iportmap->iportmap_dam), iport_addr));
9622 damap_id_rele(iportmap->iportmap_dam, iportid);
9623 return (DDI_SUCCESS);
9624 }
9625
9626 SCSI_HBA_LOG((_LOG(3), self, NULL,
9627 "%s @%s not found",
9628 damap_name(iportmap->iportmap_dam), iport_addr));
9629 return (DDI_FAILURE);
9630 }
9631
9632
9633 static int
scsi_lunmap_config(void * arg,damap_t * lundam,damap_id_t lunid)9634 scsi_lunmap_config(void *arg, damap_t *lundam, damap_id_t lunid)
9635 {
9636 impl_scsi_tgtmap_t *tgtmap = (impl_scsi_tgtmap_t *)arg;
9637 scsi_hba_tran_t *tran = tgtmap->tgtmap_tran;
9638 dev_info_t *self = tran->tran_iport_dip;
9639 char *addr;
9640
9641 addr = damap_id2addr(lundam, lunid);
9642 SCSI_HBA_LOG((_LOGLUN, self, NULL,
9643 "%s @%s", damap_name(lundam), addr));
9644 if (scsi_hba_bus_configone_addr(self, addr, SE_HP) != NULL)
9645 return (DAM_SUCCESS);
9646 else
9647 return (DAM_FAILURE);
9648 }
9649
9650 static int
scsi_lunmap_unconfig(void * arg,damap_t * lundam,damap_id_t lunid)9651 scsi_lunmap_unconfig(void *arg, damap_t *lundam, damap_id_t lunid)
9652 {
9653 impl_scsi_tgtmap_t *tgtmap = (impl_scsi_tgtmap_t *)arg;
9654 scsi_hba_tran_t *tran = tgtmap->tgtmap_tran;
9655 dev_info_t *self = tran->tran_iport_dip;
9656 char *addr;
9657
9658 addr = damap_id2addr(lundam, lunid);
9659 SCSI_HBA_LOG((_LOGLUN, self, NULL, "%s @%s", damap_name(lundam),
9660 addr));
9661
9662 scsi_hba_bus_unconfigone_addr(self, addr);
9663 return (DAM_SUCCESS);
9664 }
9665
9666 static int
scsi_lunmap_create(dev_info_t * self,impl_scsi_tgtmap_t * tgtmap,char * taddr)9667 scsi_lunmap_create(dev_info_t *self, impl_scsi_tgtmap_t *tgtmap, char *taddr)
9668 {
9669 char context[64];
9670 damap_t *tgtdam;
9671 damap_id_t tgtid;
9672 damap_t *lundam;
9673 int optflags;
9674
9675 (void) snprintf(context, sizeof (context), "%s%d.%s.lunmap",
9676 ddi_driver_name(self), ddi_get_instance(self), taddr);
9677
9678 tgtdam = tgtmap->tgtmap_dam[SCSI_TGT_SCSI_DEVICE];
9679 tgtid = damap_lookup(tgtdam, taddr);
9680 if (tgtid == NODAM) {
9681 SCSI_HBA_LOG((_LOG(1), self, NULL,
9682 "target %s not found", context));
9683 return (DDI_FAILURE);
9684 }
9685
9686 lundam = damap_id_priv_get(tgtdam, tgtid);
9687 if (lundam) {
9688 SCSI_HBA_LOG((_LOG(1), self, NULL,
9689 "lunmap %s already created", context));
9690 damap_id_rele(tgtdam, tgtid);
9691 return (DDI_FAILURE);
9692 }
9693
9694 optflags = (ddi_prop_get_int(DDI_DEV_T_ANY, self,
9695 DDI_PROP_NOTPROM | DDI_PROP_DONTPASS, "scsi-enumeration",
9696 scsi_enumeration) & SCSI_ENUMERATION_MT_LUN_DISABLE) ?
9697 DAMAP_SERIALCONFIG : DAMAP_MTCONFIG;
9698
9699 /* NOTE: expected ref at tgtid/taddr: 2: caller + lookup. */
9700 ASSERT(damap_id_ref(tgtdam, tgtid) == 2);
9701 SCSI_HBA_LOG((_LOGLUN, self, NULL, "%s creat, id %d ref %d",
9702 context, tgtid, damap_id_ref(tgtdam, tgtid)));
9703
9704 /* create lundam */
9705 if (damap_create(context, DAMAP_REPORT_FULLSET, optflags, 1,
9706 NULL, NULL, NULL, tgtmap, scsi_lunmap_config, scsi_lunmap_unconfig,
9707 &lundam) != DAM_SUCCESS) {
9708 SCSI_HBA_LOG((_LOG(1), self, NULL,
9709 "%s create failed, id %d ref %d",
9710 context, tgtid, damap_id_ref(tgtdam, tgtid)));
9711 damap_id_rele(tgtdam, tgtid);
9712 return (DDI_FAILURE);
9713 }
9714
9715 /*
9716 * Return with damap_id_hold at tgtid/taddr from damap_lookup to
9717 * account for damap_id_prv_set below.
9718 */
9719 damap_id_priv_set(tgtdam, tgtid, lundam);
9720 return (DDI_SUCCESS);
9721 }
9722
9723 static void
scsi_lunmap_destroy(dev_info_t * self,impl_scsi_tgtmap_t * tgtmap,char * taddr)9724 scsi_lunmap_destroy(dev_info_t *self, impl_scsi_tgtmap_t *tgtmap, char *taddr)
9725 {
9726 char context[64];
9727 damap_t *tgtdam;
9728 damap_id_t tgtid;
9729 damap_t *lundam;
9730
9731 (void) snprintf(context, sizeof (context), "%s%d.%s.lunmap",
9732 ddi_driver_name(self), ddi_get_instance(self), taddr);
9733
9734 tgtdam = tgtmap->tgtmap_dam[SCSI_TGT_SCSI_DEVICE];
9735 tgtid = damap_lookup(tgtdam, taddr);
9736 if (tgtid == NODAM) {
9737 SCSI_HBA_LOG((_LOG(1), self, NULL,
9738 "target %s not found", context));
9739 return;
9740 }
9741
9742 lundam = (damap_t *)damap_id_priv_get(tgtdam, tgtid);
9743 if (lundam == NULL) {
9744 damap_id_rele(tgtdam, tgtid); /* from damap_lookup */
9745 SCSI_HBA_LOG((_LOG(1), self, NULL,
9746 "lunmap %s already destroyed", context));
9747 return;
9748 }
9749
9750 /* NOTE: expected ref at tgtid/taddr: 3: priv_set + caller + lookup. */
9751 ASSERT(damap_id_ref(tgtdam, tgtid) == 3);
9752 SCSI_HBA_LOG((_LOGLUN, self, NULL, "%s, id %d ref %d",
9753 damap_name(lundam), tgtid, damap_id_ref(tgtdam, tgtid)));
9754
9755 /*
9756 * A begin/end (clear) against a target's lunmap will trigger
9757 * unconfigure of all LUNs on the target.
9758 */
9759 scsi_lunmap_set_begin(self, lundam);
9760 scsi_lunmap_set_end(self, lundam);
9761
9762 SCSI_HBA_LOG((_LOGLUN, self, NULL,
9763 "%s sync begin", damap_name(lundam)));
9764
9765 (void) damap_sync(lundam, 0); /* wait for unconfigure */
9766
9767 SCSI_HBA_LOG((_LOGLUN, self, NULL,
9768 "%s sync end", damap_name(lundam)));
9769
9770 damap_id_priv_set(tgtdam, tgtid, NULL);
9771
9772 /* release hold established by damap_lookup above */
9773 damap_id_rele(tgtdam, tgtid);
9774
9775 /* release hold established since scsi_lunmap_create() */
9776 damap_id_rele(tgtdam, tgtid);
9777
9778 damap_destroy(lundam);
9779 }
9780
9781 static void
scsi_lunmap_set_begin(dev_info_t * self,damap_t * lundam)9782 scsi_lunmap_set_begin(dev_info_t *self, damap_t *lundam)
9783 {
9784 SCSI_HBA_LOG((_LOGLUN, self, NULL, "%s", damap_name(lundam)));
9785
9786 (void) damap_addrset_begin(lundam);
9787 }
9788
9789 static int
scsi_lunmap_set_add(dev_info_t * self,damap_t * lundam,char * taddr,scsi_lun64_t lun64,int sfunc)9790 scsi_lunmap_set_add(dev_info_t *self, damap_t *lundam,
9791 char *taddr, scsi_lun64_t lun64, int sfunc)
9792 {
9793 char ua[SCSI_MAXNAMELEN];
9794
9795 /* make unit address string form of "@taddr,lun[,sfunc]" */
9796 if (sfunc == -1)
9797 (void) snprintf(ua, sizeof (ua), "%s,%" PRIx64, taddr, lun64);
9798 else
9799 (void) snprintf(ua, sizeof (ua), "%s,%" PRIx64 ",%x",
9800 taddr, lun64, sfunc);
9801
9802 SCSI_HBA_LOG((_LOGLUN, self, NULL, "%s @%s", damap_name(lundam), ua));
9803
9804 return ((damap_addrset_add(lundam, ua, NULL, NULL,
9805 NULL) == DAM_SUCCESS) ? DDI_SUCCESS : DDI_FAILURE);
9806 }
9807
9808 static void
scsi_lunmap_set_end(dev_info_t * self,damap_t * lundam)9809 scsi_lunmap_set_end(dev_info_t *self, damap_t *lundam)
9810 {
9811 SCSI_HBA_LOG((_LOGLUN, self, NULL, "%s", damap_name(lundam)));
9812
9813 (void) damap_addrset_end(lundam, 0);
9814 }
9815
9816 int
scsi_lunmap_lookup(dev_info_t * self,damap_t * lundam,char * addr)9817 scsi_lunmap_lookup(dev_info_t *self, damap_t *lundam, char *addr)
9818 {
9819 damap_id_t lunid;
9820
9821 if ((lunid = damap_lookup(lundam, addr)) != NODAM) {
9822 SCSI_HBA_LOG((_LOG(3), self, NULL,
9823 "%s @%s found", damap_name(lundam), addr));
9824 damap_id_rele(lundam, lunid);
9825 return (DDI_SUCCESS);
9826 }
9827
9828 SCSI_HBA_LOG((_LOG(3), self, NULL,
9829 "%s @%s not found", damap_name(lundam), addr));
9830 return (DDI_FAILURE);
9831 }
9832
9833 /*
9834 * phymap implementation
9835 *
9836 * We manage the timed aggregation of phys into a phy map * by creating a
9837 * SAS port construct (based upon 'name' of "local,remote" SAS addresses)
9838 * upon the first link up. As time goes on additional phys may join that port.
9839 * After an appropriate amount of settle time, we trigger the activation
9840 * callback which will then take the resultant bit mask of phys (phymask) in
9841 * the SAS port and use that to call back to the callback function
9842 * provided by the additional caller.
9843 *
9844 * We cross check to make sure that phys only exist in one SAS port at a
9845 * time by having soft state for each phy point back to the created
9846 * SAS port.
9847 *
9848 * NOTE: Make SAS_PHY_UA_LEN max(SAS_PHY_PHYMASK_LEN, SAS_PHY_NAME_LEN)
9849 * so we have enough space if sas_phymap_bitset2phymaskua phymask address
9850 * is already in use, and we end up using port name as unit address.
9851 */
9852 #define SAS_PHY_NAME_FMT "%" PRIx64 ",%" PRIx64
9853 #define SAS_PHY_NAME_LEN (16 + 1 + 16 + 1)
9854 #define SAS_PHY_NPHY (SAS2_PHYNUM_MAX + 1)
9855 #define SAS_PHY_PHYMASK_LEN ((roundup(SAS_PHY_NPHY, 4)) / 4)
9856 #if (SAS_PHY_PHYMASK_LEN > SAS_PHY_NAME_LEN)
9857 #define SAS_PHY_UA_LEN SAS_PHY_PHYMASK_LEN
9858 #else
9859 #define SAS_PHY_UA_LEN SAS_PHY_NAME_LEN
9860 #endif
9861 typedef struct impl_sas_physet { /* needed for name2phys destroy */
9862 struct impl_sas_physet *physet_next;
9863 char *physet_name;
9864 bitset_t *physet_phys;
9865 } impl_sas_physet_t;
9866 typedef struct impl_sas_phymap {
9867 dev_info_t *phymap_self;
9868
9869 kmutex_t phymap_lock;
9870 damap_t *phymap_dam;
9871 void *phymap_phy2name;
9872 ddi_soft_state_bystr *phymap_name2phys; /* bitset */
9873 ddi_soft_state_bystr *phymap_name2ua;
9874 ddi_soft_state_bystr *phymap_ua2name;
9875
9876 /* Noisy phy information - ensure forward progress for noisy phys */
9877 int phymap_phy_max; /* max phy# */
9878 int phymap_reports; /* per period */
9879 int phymap_reports_max; /* scales */
9880 int phymap_phys_noisy; /* detected */
9881
9882 /* These are for callbacks to the consumer. */
9883 sas_phymap_activate_cb_t phymap_acp;
9884 sas_phymap_deactivate_cb_t phymap_dcp;
9885 void *phymap_private;
9886
9887 struct impl_sas_physet *phymap_physets;
9888 } impl_sas_phymap_t;
9889
9890 /* Detect noisy phy: max changes per stabilization period per phy. */
9891 static int sas_phymap_phy_max_factor = 16;
9892
9893 /*
9894 * Convert bitset into a unit-address string. The maximum string length would
9895 * be the maximum number of phys, rounded up by 4 and divided by 4.
9896 */
9897 static void
sas_phymap_bitset2phymaskua(bitset_t * phys,char * buf)9898 sas_phymap_bitset2phymaskua(bitset_t *phys, char *buf)
9899 {
9900 char *ptr;
9901 int grp;
9902 int cur;
9903 uint_t bit;
9904
9905 bit = roundup(SAS_PHY_NPHY, 4);
9906 grp = 4;
9907 ptr = buf;
9908 cur = 0;
9909 do {
9910 bit -= 1;
9911 grp -= 1;
9912 if (bitset_in_set(phys, bit)) {
9913 cur |= (1 << grp);
9914 }
9915 if (grp == 0) {
9916 grp = 4;
9917 if (cur || ptr != buf) {
9918 *ptr++ = "0123456789abcdef"[cur];
9919 *ptr = 0;
9920 }
9921 cur = 0;
9922 }
9923 } while (bit != 0);
9924 if (ptr == buf) {
9925 *ptr++ = '0';
9926 *ptr = 0;
9927 }
9928 }
9929
9930 static int
sas_phymap_config(void * arg,damap_t * phydam,damap_id_t phyid)9931 sas_phymap_config(void *arg, damap_t *phydam, damap_id_t phyid)
9932 {
9933 impl_sas_phymap_t *phymap = (impl_sas_phymap_t *)arg;
9934 char *context = damap_name(phymap->phymap_dam);
9935 char *damn;
9936 char *name;
9937 bitset_t *phys;
9938 char *ua;
9939 void *ua_priv;
9940
9941 ASSERT(context);
9942
9943 mutex_enter(&phymap->phymap_lock);
9944 phymap->phymap_reports = phymap->phymap_phys_noisy = 0;
9945
9946 /* Get the name ("local,remote" address string) from damap. */
9947 damn = damap_id2addr(phydam, phyid);
9948
9949 /* Get the bitset of phys currently forming the port. */
9950 phys = ddi_soft_state_bystr_get(phymap->phymap_name2phys, damn);
9951 if (phys == NULL) {
9952 SCSI_HBA_LOG((_LOG_NF(WARN), "%s: %s: no phys",
9953 context, damn));
9954 mutex_exit(&phymap->phymap_lock);
9955 return (DAM_FAILURE);
9956 }
9957
9958 /* allocate, get, and initialize name index of name2ua map */
9959 if (ddi_soft_state_bystr_zalloc(phymap->phymap_name2ua, damn) !=
9960 DDI_SUCCESS) {
9961 SCSI_HBA_LOG((_LOG_NF(WARN),
9962 "%s: %s: failed name2ua alloc", context, damn));
9963 mutex_exit(&phymap->phymap_lock);
9964 return (DAM_FAILURE);
9965 }
9966 if (!(ua = ddi_soft_state_bystr_get(phymap->phymap_name2ua, damn))) {
9967 SCSI_HBA_LOG((_LOG_NF(WARN),
9968 "%s: %s: no name2ua", context, damn));
9969 mutex_exit(&phymap->phymap_lock);
9970 return (DAM_FAILURE);
9971 }
9972 sas_phymap_bitset2phymaskua(phys, ua); /* set ua */
9973
9974 /* see if phymask ua index already allocated in ua2name map */
9975 if (name = ddi_soft_state_bystr_get(phymap->phymap_ua2name, ua)) {
9976 /*
9977 * The 'phymask' sas_phymap_bitset2phymaskua ua is
9978 * already in use. This means that original phys have
9979 * formed into a new port, and that the original port
9980 * still exists (it has migrated to some completely
9981 * different set of phys). In this corner-case we use
9982 * "local,remote" name as a 'temporary' unit address.
9983 * Reset ua in name2ua map.
9984 */
9985 (void) strlcpy(ua, damn, SAS_PHY_NAME_LEN);
9986 name = ddi_soft_state_bystr_get(phymap->phymap_ua2name, ua);
9987 if (name) {
9988 /* The "local,remote" ua should be new... */
9989 SCSI_HBA_LOG((_LOG_NF(WARN),
9990 "%s: %s ua already configured",
9991 context, ua));
9992 mutex_exit(&phymap->phymap_lock);
9993 return (DAM_SUCCESS);
9994 }
9995 }
9996
9997 /* allocate, get, and init ua index of ua2name map */
9998 if (ddi_soft_state_bystr_zalloc(phymap->phymap_ua2name, ua) !=
9999 DDI_SUCCESS) {
10000 ddi_soft_state_bystr_free(phymap->phymap_name2ua, damn);
10001 SCSI_HBA_LOG((_LOG_NF(WARN), "%s: %s: failed ua2name alloc",
10002 context, damn));
10003 mutex_exit(&phymap->phymap_lock);
10004 return (DAM_FAILURE);
10005 }
10006 name = ddi_soft_state_bystr_get(phymap->phymap_ua2name, ua);
10007 if (name == NULL) {
10008 ddi_soft_state_bystr_free(phymap->phymap_name2ua, damn);
10009 SCSI_HBA_LOG((_LOG_NF(WARN),
10010 "%s: %s: no ua2name", context, ua));
10011 mutex_exit(&phymap->phymap_lock);
10012 return (DAM_FAILURE);
10013 }
10014
10015 /* set name in ua2name map */
10016 (void) strlcpy(name, damn, SAS_PHY_NAME_LEN);
10017
10018 SCSI_HBA_LOG((_LOGPHY, phymap->phymap_self, NULL,
10019 "%s: %s: ua %s: activate", context, damn, ua));
10020
10021 if (phymap->phymap_acp) {
10022 /*
10023 * drop our lock and invoke the activation callback
10024 */
10025 mutex_exit(&phymap->phymap_lock);
10026 ua_priv = NULL;
10027 (phymap->phymap_acp)(phymap->phymap_private, ua, &ua_priv);
10028 mutex_enter(&phymap->phymap_lock);
10029 damap_id_priv_set(phydam, phyid, ua_priv);
10030 }
10031 SCSI_HBA_LOG((_LOGPHY, phymap->phymap_self, NULL,
10032 "%s: %s: ua %s: activate complete", context, damn, ua));
10033 mutex_exit(&phymap->phymap_lock);
10034 return (DAM_SUCCESS);
10035 }
10036
10037 /*ARGSUSED*/
10038 static int
sas_phymap_unconfig(void * arg,damap_t * phydam,damap_id_t phyid)10039 sas_phymap_unconfig(void *arg, damap_t *phydam, damap_id_t phyid)
10040 {
10041 impl_sas_phymap_t *phymap = (impl_sas_phymap_t *)arg;
10042 char *context = damap_name(phymap->phymap_dam);
10043 char *damn;
10044 char *ua;
10045 void *ua_priv;
10046
10047 ASSERT(context);
10048
10049 mutex_enter(&phymap->phymap_lock);
10050 phymap->phymap_reports = phymap->phymap_phys_noisy = 0;
10051
10052 /* Get the name ("local,remote" address string) from damap. */
10053 damn = damap_id2addr(phydam, phyid);
10054
10055 if (!(ua = ddi_soft_state_bystr_get(phymap->phymap_name2ua, damn))) {
10056 SCSI_HBA_LOG((_LOG_NF(WARN),
10057 "%s: %s: no name2ua", context, damn));
10058 mutex_exit(&phymap->phymap_lock);
10059 return (DAM_FAILURE);
10060 }
10061
10062 SCSI_HBA_LOG((_LOGPHY, phymap->phymap_self, NULL,
10063 "%s: %s: ua %s: deactivate", context, damn, ua));
10064 if (phymap->phymap_dcp) {
10065 ua_priv = damap_id_priv_get(phydam, phyid);
10066 mutex_exit(&phymap->phymap_lock);
10067 (phymap->phymap_dcp)(phymap->phymap_private, ua, ua_priv);
10068 mutex_enter(&phymap->phymap_lock);
10069 }
10070 SCSI_HBA_LOG((_LOGPHY, phymap->phymap_self, NULL,
10071 "%s: %s: ua %s: deactivate complete", context, damn, ua));
10072
10073 /* delete ua<->name mappings */
10074 ddi_soft_state_bystr_free(phymap->phymap_ua2name, ua);
10075 ddi_soft_state_bystr_free(phymap->phymap_name2ua, damn);
10076 mutex_exit(&phymap->phymap_lock);
10077 return (DAM_SUCCESS);
10078 }
10079
10080 int
sas_phymap_create(dev_info_t * self,int settle_usec,sas_phymap_mode_t mode,void * mode_argument,void * phymap_priv,sas_phymap_activate_cb_t activate_cb,sas_phymap_deactivate_cb_t deactivate_cb,sas_phymap_t ** handlep)10081 sas_phymap_create(dev_info_t *self, int settle_usec,
10082 sas_phymap_mode_t mode, void *mode_argument, void *phymap_priv,
10083 sas_phymap_activate_cb_t activate_cb,
10084 sas_phymap_deactivate_cb_t deactivate_cb,
10085 sas_phymap_t **handlep)
10086 {
10087 _NOTE(ARGUNUSED(mode_argument));
10088 char context[64];
10089 impl_sas_phymap_t *phymap;
10090
10091 if (self == NULL || settle_usec == 0 || handlep == NULL)
10092 return (DDI_FAILURE);
10093
10094 if (mode != PHYMAP_MODE_SIMPLE)
10095 return (DDI_FAILURE);
10096
10097 phymap = kmem_zalloc(sizeof (*phymap), KM_SLEEP);
10098 phymap->phymap_self = self;
10099 phymap->phymap_reports_max = 1 * sas_phymap_phy_max_factor;
10100 phymap->phymap_acp = activate_cb;
10101 phymap->phymap_dcp = deactivate_cb;
10102 phymap->phymap_private = phymap_priv;
10103 mutex_init(&phymap->phymap_lock, NULL, MUTEX_DRIVER, NULL);
10104
10105 (void) snprintf(context, sizeof (context), "%s%d.phymap",
10106 ddi_driver_name(self), ddi_get_instance(self));
10107 SCSI_HBA_LOG((_LOGPHY, self, NULL, "%s", context));
10108
10109 if (ddi_soft_state_init(&phymap->phymap_phy2name,
10110 SAS_PHY_NAME_LEN, SAS_PHY_NPHY) != 0)
10111 goto fail;
10112 if (ddi_soft_state_bystr_init(&phymap->phymap_name2phys,
10113 sizeof (bitset_t), SAS_PHY_NPHY) != 0)
10114 goto fail;
10115
10116 if (ddi_soft_state_bystr_init(&phymap->phymap_name2ua,
10117 SAS_PHY_UA_LEN, SAS_PHY_NPHY) != 0)
10118 goto fail;
10119 if (ddi_soft_state_bystr_init(&phymap->phymap_ua2name,
10120 SAS_PHY_NAME_LEN, SAS_PHY_NPHY) != 0)
10121 goto fail;
10122
10123 if (damap_create(context, DAMAP_REPORT_PERADDR, DAMAP_SERIALCONFIG,
10124 settle_usec, NULL, NULL, NULL,
10125 phymap, sas_phymap_config, sas_phymap_unconfig,
10126 &phymap->phymap_dam) != DAM_SUCCESS)
10127 goto fail;
10128
10129
10130 *handlep = (sas_phymap_t *)phymap;
10131 return (DDI_SUCCESS);
10132
10133 fail: sas_phymap_destroy((sas_phymap_t *)phymap);
10134 *handlep = NULL;
10135 return (DDI_FAILURE);
10136 }
10137
10138 void
sas_phymap_destroy(sas_phymap_t * handle)10139 sas_phymap_destroy(sas_phymap_t *handle)
10140 {
10141 impl_sas_phymap_t *phymap = (impl_sas_phymap_t *)handle;
10142 char *context;
10143 struct impl_sas_physet *physet, *nphyset;
10144 bitset_t *phys;
10145 char *name;
10146
10147 context = phymap->phymap_dam ?
10148 damap_name(phymap->phymap_dam) : "unknown";
10149 SCSI_HBA_LOG((_LOGPHY, phymap->phymap_self, NULL, "%s", context));
10150
10151 if (phymap->phymap_dam)
10152 damap_destroy(phymap->phymap_dam);
10153
10154 /* free the bitsets of allocated physets */
10155 for (physet = phymap->phymap_physets; physet; physet = nphyset) {
10156 nphyset = physet->physet_next;
10157 phys = physet->physet_phys;
10158 name = physet->physet_name;
10159
10160 if (phys)
10161 bitset_fini(phys);
10162 if (name) {
10163 ddi_soft_state_bystr_free(
10164 phymap->phymap_name2phys, name);
10165 strfree(name);
10166 }
10167 kmem_free(physet, sizeof (*physet));
10168 }
10169
10170 /* free the maps */
10171 if (phymap->phymap_ua2name)
10172 ddi_soft_state_bystr_fini(&phymap->phymap_ua2name);
10173 if (phymap->phymap_name2ua)
10174 ddi_soft_state_bystr_fini(&phymap->phymap_name2ua);
10175
10176 if (phymap->phymap_name2phys)
10177 ddi_soft_state_bystr_fini(&phymap->phymap_name2phys);
10178 if (phymap->phymap_phy2name)
10179 ddi_soft_state_fini(&phymap->phymap_phy2name);
10180
10181 mutex_destroy(&phymap->phymap_lock);
10182 kmem_free(phymap, sizeof (*phymap));
10183 }
10184
10185
10186 int
sas_phymap_phy_add(sas_phymap_t * handle,int phy,uint64_t local,uint64_t remote)10187 sas_phymap_phy_add(sas_phymap_t *handle,
10188 int phy, uint64_t local, uint64_t remote)
10189 {
10190 impl_sas_phymap_t *phymap = (impl_sas_phymap_t *)handle;
10191 char *context = damap_name(phymap->phymap_dam);
10192 char port[SAS_PHY_NAME_LEN];
10193 char *name;
10194 int phy2name_allocated = 0;
10195 bitset_t *phys;
10196 struct impl_sas_physet *physet;
10197 int rv;
10198
10199 /* Create the SAS port name from the local and remote addresses. */
10200 (void) snprintf(port, SAS_PHY_NAME_LEN, SAS_PHY_NAME_FMT,
10201 local, remote);
10202
10203 mutex_enter(&phymap->phymap_lock);
10204 SCSI_HBA_LOG((_LOGPHY, phymap->phymap_self, NULL, "%s: %s: add phy %d",
10205 context, port, phy));
10206
10207 /* Check for conflict in phy2name map */
10208 name = ddi_get_soft_state(phymap->phymap_phy2name, phy);
10209 if (name) {
10210 if (strcmp(name, port) != 0)
10211 SCSI_HBA_LOG((_LOG_NF(WARN), "%s: %s: add phy %d: "
10212 "already in %s", context, port, phy, name));
10213 else
10214 SCSI_HBA_LOG((_LOG_NF(WARN), "%s: %s: add phy %d: "
10215 "duplicate add", context, port, phy));
10216 mutex_exit(&phymap->phymap_lock);
10217 return (DDI_FAILURE);
10218 }
10219
10220 /* allocate, get, and initialize phy index of phy2name map */
10221 if (ddi_soft_state_zalloc(
10222 phymap->phymap_phy2name, phy) != DDI_SUCCESS) {
10223 SCSI_HBA_LOG((_LOG_NF(WARN),
10224 "%s: %s: failed phy2name alloc", context, port));
10225 goto fail;
10226 }
10227 name = ddi_get_soft_state(phymap->phymap_phy2name, phy);
10228 if (name == NULL) {
10229 SCSI_HBA_LOG((_LOG_NF(WARN),
10230 "%s: %s: no phy2name", context, port));
10231 goto fail;
10232 }
10233 phy2name_allocated = 1;
10234 (void) strlcpy(name, port, SAS_PHY_NAME_LEN); /* set name */
10235
10236 /* Find/alloc, initialize name index of name2phys map */
10237 phys = ddi_soft_state_bystr_get(phymap->phymap_name2phys, name);
10238 if (phys == NULL) {
10239 if (ddi_soft_state_bystr_zalloc(phymap->phymap_name2phys,
10240 name) != DDI_SUCCESS) {
10241 SCSI_HBA_LOG((_LOG_NF(WARN),
10242 "%s: %s: failed name2phys alloc", context, name));
10243 goto fail;
10244 }
10245 phys = ddi_soft_state_bystr_get(phymap->phymap_name2phys, name);
10246 if (phys == NULL) {
10247 SCSI_HBA_LOG((_LOG_NF(WARN),
10248 "%s: %s: no name2phys", context, name));
10249 goto fail;
10250 }
10251
10252 /* Initialize bitset of phys. */
10253 bitset_init(phys);
10254 bitset_resize(phys, SAS_PHY_NPHY);
10255
10256 /* Keep a list of information for destroy. */
10257 physet = kmem_zalloc(sizeof (*physet), KM_SLEEP);
10258 physet->physet_name = strdup(name);
10259 physet->physet_phys = phys;
10260 physet->physet_next = phymap->phymap_physets;
10261 phymap->phymap_physets = physet;
10262 }
10263 ASSERT(phys);
10264
10265 /* Reflect 'add' in phys bitset. */
10266 if (bitset_atomic_test_and_add(phys, phy) < 0) {
10267 /* It is an error if the phy was already recorded. */
10268 SCSI_HBA_LOG((_LOG_NF(WARN),
10269 "%s: %s: phy bit %d already in port", context, name, phy));
10270 goto fail;
10271 }
10272
10273 /*
10274 * Check to see if we have a new phy_max for this map, and if so
10275 * scale phymap_reports_max to the new number of phys.
10276 */
10277 if (phy > phymap->phymap_phy_max) {
10278 phymap->phymap_phy_max = phy + 1;
10279 phymap->phymap_reports_max = phymap->phymap_phy_max *
10280 sas_phymap_phy_max_factor;
10281 }
10282
10283 /*
10284 * If we have not reached phymap_reports_max, start/restart the
10285 * activate timer. Otherwise, if phymap->phymap_reports add/rem reports
10286 * ever exceeds phymap_reports_max due to noisy phys, then report the
10287 * noise and force stabilization by stopping reports into the damap.
10288 *
10289 * The first config/unconfig callout out of the damap will reset
10290 * phymap->phymap_reports.
10291 */
10292 rv = DDI_SUCCESS;
10293 if (phymap->phymap_reports++ < phymap->phymap_reports_max) {
10294 if (damap_addr_add(phymap->phymap_dam, name,
10295 NULL, NULL, NULL) == DAM_SUCCESS) {
10296 SCSI_HBA_LOG((_LOGPHY, phymap->phymap_self, NULL,
10297 "%s: %s: damap_addr_add", context, name));
10298 } else {
10299 SCSI_HBA_LOG((_LOG_NF(WARN),
10300 "%s: %s: damap_addr_add failed", context, name));
10301 rv = DDI_FAILURE;
10302 }
10303 } else {
10304 phymap->phymap_phys_noisy++;
10305 if (phymap->phymap_phys_noisy == 1)
10306 SCSI_HBA_LOG((_LOG_NF(WARN),
10307 "%s: %s: noisy phys", context, name));
10308 }
10309 mutex_exit(&phymap->phymap_lock);
10310 return (rv);
10311
10312 fail: if (phy2name_allocated)
10313 ddi_soft_state_free(phymap->phymap_phy2name, phy);
10314 mutex_exit(&phymap->phymap_lock);
10315 return (DDI_FAILURE);
10316 }
10317
10318 int
sas_phymap_phy_rem(sas_phymap_t * handle,int phy)10319 sas_phymap_phy_rem(sas_phymap_t *handle, int phy)
10320 {
10321 impl_sas_phymap_t *phymap = (impl_sas_phymap_t *)handle;
10322 char *context = damap_name(phymap->phymap_dam);
10323 char *name;
10324 bitset_t *phys;
10325 int rv = DDI_FAILURE;
10326
10327 ASSERT(context);
10328
10329 mutex_enter(&phymap->phymap_lock);
10330 phymap->phymap_reports++;
10331
10332 /* Find and free phy index of phy2name map */
10333 name = ddi_get_soft_state(phymap->phymap_phy2name, phy);
10334 if (name == NULL) {
10335 SCSI_HBA_LOG((_LOG_NF(WARN), "%s: rem phy %d: never added",
10336 context, phy));
10337 goto fail;
10338 }
10339 /* NOTE: always free phy index of phy2name map before return... */
10340
10341 SCSI_HBA_LOG((_LOGPHY, phymap->phymap_self, NULL, "%s: %s: rem phy %d",
10342 context, name, phy));
10343
10344 /* Get bitset of phys currently associated with named port. */
10345 phys = ddi_soft_state_bystr_get(phymap->phymap_name2phys, name);
10346 if (phys == NULL) {
10347 SCSI_HBA_LOG((_LOG_NF(WARN), "%s: %s: name2phys failed",
10348 context, name));
10349 goto fail;
10350 }
10351
10352 /* Reflect 'rem' in phys bitset. */
10353 if (bitset_atomic_test_and_del(phys, phy) < 0) {
10354 /* It is an error if the phy wasn't one of the port's phys. */
10355 SCSI_HBA_LOG((_LOG_NF(WARN),
10356 "%s: %s: phy bit %d not in port", context, name, phy));
10357 goto fail;
10358 }
10359
10360 /* If this was the last phy in the port, start the deactivate timer. */
10361 if (bitset_is_null(phys) &&
10362 (phymap->phymap_reports++ < phymap->phymap_reports_max)) {
10363 if (damap_addr_del(phymap->phymap_dam, name) == DAM_SUCCESS) {
10364 SCSI_HBA_LOG((_LOGPHY, phymap->phymap_self, NULL,
10365 "%s: %s: damap_addr_del", context, name));
10366 } else {
10367 SCSI_HBA_LOG((_LOG_NF(WARN),
10368 "%s: %s: damap_addr_del failure", context, name));
10369 goto fail;
10370 }
10371 }
10372 rv = DDI_SUCCESS;
10373
10374 /* free phy index of phy2name map */
10375 fail: if (name)
10376 ddi_soft_state_free(phymap->phymap_phy2name, phy); /* free */
10377 mutex_exit(&phymap->phymap_lock);
10378 return (rv);
10379 }
10380
10381 char *
sas_phymap_lookup_ua(sas_phymap_t * handle,uint64_t local,uint64_t remote)10382 sas_phymap_lookup_ua(sas_phymap_t *handle, uint64_t local, uint64_t remote)
10383 {
10384 impl_sas_phymap_t *phymap = (impl_sas_phymap_t *)handle;
10385 char *context = damap_name(phymap->phymap_dam);
10386 char name[SAS_PHY_NAME_LEN];
10387 char *ua;
10388
10389 ASSERT(context);
10390
10391 (void) snprintf(name, SAS_PHY_NAME_LEN, SAS_PHY_NAME_FMT,
10392 local, remote);
10393
10394 mutex_enter(&phymap->phymap_lock);
10395 ua = ddi_soft_state_bystr_get(phymap->phymap_name2ua, name);
10396 SCSI_HBA_LOG((_LOG(3), phymap->phymap_self, NULL,
10397 "%s: %s: ua %s", context, name, ua ? ua : "NULL"));
10398 mutex_exit(&phymap->phymap_lock);
10399 return (ua);
10400 }
10401
10402 void *
sas_phymap_lookup_uapriv(sas_phymap_t * handle,char * ua)10403 sas_phymap_lookup_uapriv(sas_phymap_t *handle, char *ua)
10404 {
10405 impl_sas_phymap_t *phymap = (impl_sas_phymap_t *)handle;
10406 char *context = damap_name(phymap->phymap_dam);
10407 char *name;
10408 damap_id_t phyid;
10409 void *ua_priv = NULL;
10410
10411 ASSERT(context);
10412
10413 mutex_enter(&phymap->phymap_lock);
10414 name = ddi_soft_state_bystr_get(phymap->phymap_ua2name, ua);
10415 if (name) {
10416 phyid = damap_lookup(phymap->phymap_dam, name);
10417 if (phyid != NODAM) {
10418 ua_priv = damap_id_priv_get(phymap->phymap_dam, phyid);
10419 damap_id_rele(phymap->phymap_dam, phyid);
10420 }
10421 }
10422
10423 SCSI_HBA_LOG((_LOG(3), phymap->phymap_self, NULL,
10424 "%s: %s: ua %s ua_priv %p", context, name,
10425 ua ? ua : "NULL", ua_priv));
10426 mutex_exit(&phymap->phymap_lock);
10427 return (ua_priv);
10428 }
10429
10430 int
sas_phymap_uahasphys(sas_phymap_t * handle,char * ua)10431 sas_phymap_uahasphys(sas_phymap_t *handle, char *ua)
10432 {
10433 impl_sas_phymap_t *phymap = (impl_sas_phymap_t *)handle;
10434 char *name;
10435 bitset_t *phys;
10436 int n = 0;
10437
10438 mutex_enter(&phymap->phymap_lock);
10439 name = ddi_soft_state_bystr_get(phymap->phymap_ua2name, ua);
10440 if (name) {
10441 phys = ddi_soft_state_bystr_get(phymap->phymap_name2phys, name);
10442 if (phys)
10443 n = bitset_is_null(phys) ? 0 : 1;
10444 }
10445 mutex_exit(&phymap->phymap_lock);
10446 return (n);
10447 }
10448
10449 sas_phymap_phys_t *
sas_phymap_ua2phys(sas_phymap_t * handle,char * ua)10450 sas_phymap_ua2phys(sas_phymap_t *handle, char *ua)
10451 {
10452 impl_sas_phymap_t *phymap = (impl_sas_phymap_t *)handle;
10453 char *name;
10454 bitset_t *phys;
10455 bitset_t *cphys = NULL;
10456
10457 mutex_enter(&phymap->phymap_lock);
10458 name = ddi_soft_state_bystr_get(phymap->phymap_ua2name, ua);
10459 if (name == NULL)
10460 goto fail;
10461
10462 phys = ddi_soft_state_bystr_get(phymap->phymap_name2phys, name);
10463 if (phys == NULL)
10464 goto fail;
10465
10466 /* dup the phys and return */
10467 cphys = kmem_alloc(sizeof (*cphys), KM_SLEEP);
10468 bitset_init(cphys);
10469 bitset_resize(cphys, SAS_PHY_NPHY);
10470 bitset_copy(phys, cphys);
10471
10472 fail: mutex_exit(&phymap->phymap_lock);
10473 return ((sas_phymap_phys_t *)cphys);
10474 }
10475
10476 int
sas_phymap_phys_next(sas_phymap_phys_t * phys)10477 sas_phymap_phys_next(sas_phymap_phys_t *phys)
10478 {
10479 bitset_t *cphys = (bitset_t *)phys;
10480 int phy;
10481
10482 phy = bitset_find(cphys);
10483 if (phy != -1)
10484 bitset_del(cphys, phy);
10485 return (phy);
10486 }
10487
10488 void
sas_phymap_phys_free(sas_phymap_phys_t * phys)10489 sas_phymap_phys_free(sas_phymap_phys_t *phys)
10490 {
10491 bitset_t *cphys = (bitset_t *)phys;
10492
10493 if (cphys) {
10494 bitset_fini(cphys);
10495 kmem_free(cphys, sizeof (*cphys));
10496 }
10497 }
10498
10499 char *
sas_phymap_phy2ua(sas_phymap_t * handle,int phy)10500 sas_phymap_phy2ua(sas_phymap_t *handle, int phy)
10501 {
10502 impl_sas_phymap_t *phymap = (impl_sas_phymap_t *)handle;
10503 char *name;
10504 char *ua;
10505 char *rua = NULL;
10506
10507 mutex_enter(&phymap->phymap_lock);
10508 name = ddi_get_soft_state(phymap->phymap_phy2name, phy);
10509 if (name == NULL)
10510 goto fail;
10511 ua = ddi_soft_state_bystr_get(phymap->phymap_name2ua, name);
10512 if (ua == NULL)
10513 goto fail;
10514
10515 /* dup the ua and return */
10516 rua = strdup(ua);
10517
10518 fail: mutex_exit(&phymap->phymap_lock);
10519 return (rua);
10520 }
10521
10522 void
sas_phymap_ua_free(char * ua)10523 sas_phymap_ua_free(char *ua)
10524 {
10525 if (ua)
10526 strfree(ua);
10527 }
10528