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) 1990, 2010, Oracle and/or its affiliates. All rights reserved.
24 */
25 /*
26 * Copyright (c) 2011 Bayard G. Bell. All rights reserved.
27 * Copyright (c) 2012, 2016 by Delphix. All rights reserved.
28 * Copyright 2012 DEY Storage Systems, Inc. All rights reserved.
29 * Copyright 2017 Nexenta Systems, Inc.
30 */
31 /*
32 * Copyright 2011 cyril.galibern@opensvc.com
33 */
34
35 /*
36 * SCSI disk target driver.
37 */
38 #include <sys/scsi/scsi.h>
39 #include <sys/dkbad.h>
40 #include <sys/dklabel.h>
41 #include <sys/dkio.h>
42 #include <sys/fdio.h>
43 #include <sys/cdio.h>
44 #include <sys/mhd.h>
45 #include <sys/vtoc.h>
46 #include <sys/dktp/fdisk.h>
47 #include <sys/kstat.h>
48 #include <sys/vtrace.h>
49 #include <sys/note.h>
50 #include <sys/thread.h>
51 #include <sys/proc.h>
52 #include <sys/efi_partition.h>
53 #include <sys/var.h>
54 #include <sys/aio_req.h>
55
56 #ifdef __lock_lint
57 #define _LP64
58 #define __amd64
59 #endif
60
61 #if (defined(__fibre))
62 /* Note: is there a leadville version of the following? */
63 #include <sys/fc4/fcal_linkapp.h>
64 #endif
65 #include <sys/taskq.h>
66 #include <sys/uuid.h>
67 #include <sys/byteorder.h>
68 #include <sys/sdt.h>
69
70 #include "sd_xbuf.h"
71
72 #include <sys/scsi/targets/sddef.h>
73 #include <sys/cmlb.h>
74 #include <sys/sysevent/eventdefs.h>
75 #include <sys/sysevent/dev.h>
76
77 #include <sys/fm/protocol.h>
78
79 /*
80 * Loadable module info.
81 */
82 #if (defined(__fibre))
83 #define SD_MODULE_NAME "SCSI SSA/FCAL Disk Driver"
84 #else /* !__fibre */
85 #define SD_MODULE_NAME "SCSI Disk Driver"
86 #endif /* !__fibre */
87
88 /*
89 * Define the interconnect type, to allow the driver to distinguish
90 * between parallel SCSI (sd) and fibre channel (ssd) behaviors.
91 *
92 * This is really for backward compatibility. In the future, the driver
93 * should actually check the "interconnect-type" property as reported by
94 * the HBA; however at present this property is not defined by all HBAs,
95 * so we will use this #define (1) to permit the driver to run in
96 * backward-compatibility mode; and (2) to print a notification message
97 * if an FC HBA does not support the "interconnect-type" property. The
98 * behavior of the driver will be to assume parallel SCSI behaviors unless
99 * the "interconnect-type" property is defined by the HBA **AND** has a
100 * value of either INTERCONNECT_FIBRE, INTERCONNECT_SSA, or
101 * INTERCONNECT_FABRIC, in which case the driver will assume Fibre
102 * Channel behaviors (as per the old ssd). (Note that the
103 * INTERCONNECT_1394 and INTERCONNECT_USB types are not supported and
104 * will result in the driver assuming parallel SCSI behaviors.)
105 *
106 * (see common/sys/scsi/impl/services.h)
107 *
108 * Note: For ssd semantics, don't use INTERCONNECT_FABRIC as the default
109 * since some FC HBAs may already support that, and there is some code in
110 * the driver that already looks for it. Using INTERCONNECT_FABRIC as the
111 * default would confuse that code, and besides things should work fine
112 * anyways if the FC HBA already reports INTERCONNECT_FABRIC for the
113 * "interconnect_type" property.
114 *
115 */
116 #if (defined(__fibre))
117 #define SD_DEFAULT_INTERCONNECT_TYPE SD_INTERCONNECT_FIBRE
118 #else
119 #define SD_DEFAULT_INTERCONNECT_TYPE SD_INTERCONNECT_PARALLEL
120 #endif
121
122 /*
123 * The name of the driver, established from the module name in _init.
124 */
125 static char *sd_label = NULL;
126
127 /*
128 * Driver name is unfortunately prefixed on some driver.conf properties.
129 */
130 #if (defined(__fibre))
131 #define sd_max_xfer_size ssd_max_xfer_size
132 #define sd_config_list ssd_config_list
133 static char *sd_max_xfer_size = "ssd_max_xfer_size";
134 static char *sd_config_list = "ssd-config-list";
135 #else
136 static char *sd_max_xfer_size = "sd_max_xfer_size";
137 static char *sd_config_list = "sd-config-list";
138 #endif
139
140 /*
141 * Driver global variables
142 */
143
144 #if (defined(__fibre))
145 /*
146 * These #defines are to avoid namespace collisions that occur because this
147 * code is currently used to compile two separate driver modules: sd and ssd.
148 * All global variables need to be treated this way (even if declared static)
149 * in order to allow the debugger to resolve the names properly.
150 * It is anticipated that in the near future the ssd module will be obsoleted,
151 * at which time this namespace issue should go away.
152 */
153 #define sd_state ssd_state
154 #define sd_io_time ssd_io_time
155 #define sd_failfast_enable ssd_failfast_enable
156 #define sd_ua_retry_count ssd_ua_retry_count
157 #define sd_report_pfa ssd_report_pfa
158 #define sd_max_throttle ssd_max_throttle
159 #define sd_min_throttle ssd_min_throttle
160 #define sd_rot_delay ssd_rot_delay
161
162 #define sd_retry_on_reservation_conflict \
163 ssd_retry_on_reservation_conflict
164 #define sd_reinstate_resv_delay ssd_reinstate_resv_delay
165 #define sd_resv_conflict_name ssd_resv_conflict_name
166
167 #define sd_component_mask ssd_component_mask
168 #define sd_level_mask ssd_level_mask
169 #define sd_debug_un ssd_debug_un
170 #define sd_error_level ssd_error_level
171
172 #define sd_xbuf_active_limit ssd_xbuf_active_limit
173 #define sd_xbuf_reserve_limit ssd_xbuf_reserve_limit
174
175 #define sd_tr ssd_tr
176 #define sd_reset_throttle_timeout ssd_reset_throttle_timeout
177 #define sd_qfull_throttle_timeout ssd_qfull_throttle_timeout
178 #define sd_qfull_throttle_enable ssd_qfull_throttle_enable
179 #define sd_check_media_time ssd_check_media_time
180 #define sd_wait_cmds_complete ssd_wait_cmds_complete
181 #define sd_label_mutex ssd_label_mutex
182 #define sd_detach_mutex ssd_detach_mutex
183 #define sd_log_buf ssd_log_buf
184 #define sd_log_mutex ssd_log_mutex
185
186 #define sd_disk_table ssd_disk_table
187 #define sd_disk_table_size ssd_disk_table_size
188 #define sd_sense_mutex ssd_sense_mutex
189 #define sd_cdbtab ssd_cdbtab
190
191 #define sd_cb_ops ssd_cb_ops
192 #define sd_ops ssd_ops
193 #define sd_additional_codes ssd_additional_codes
194 #define sd_tgops ssd_tgops
195
196 #define sd_minor_data ssd_minor_data
197 #define sd_minor_data_efi ssd_minor_data_efi
198
199 #define sd_tq ssd_tq
200 #define sd_wmr_tq ssd_wmr_tq
201 #define sd_taskq_name ssd_taskq_name
202 #define sd_wmr_taskq_name ssd_wmr_taskq_name
203 #define sd_taskq_minalloc ssd_taskq_minalloc
204 #define sd_taskq_maxalloc ssd_taskq_maxalloc
205
206 #define sd_dump_format_string ssd_dump_format_string
207
208 #define sd_iostart_chain ssd_iostart_chain
209 #define sd_iodone_chain ssd_iodone_chain
210
211 #define sd_pm_idletime ssd_pm_idletime
212
213 #define sd_force_pm_supported ssd_force_pm_supported
214
215 #define sd_dtype_optical_bind ssd_dtype_optical_bind
216
217 #define sd_ssc_init ssd_ssc_init
218 #define sd_ssc_send ssd_ssc_send
219 #define sd_ssc_fini ssd_ssc_fini
220 #define sd_ssc_assessment ssd_ssc_assessment
221 #define sd_ssc_post ssd_ssc_post
222 #define sd_ssc_print ssd_ssc_print
223 #define sd_ssc_ereport_post ssd_ssc_ereport_post
224 #define sd_ssc_set_info ssd_ssc_set_info
225 #define sd_ssc_extract_info ssd_ssc_extract_info
226
227 #endif
228
229 #ifdef SDDEBUG
230 int sd_force_pm_supported = 0;
231 #endif /* SDDEBUG */
232
233 void *sd_state = NULL;
234 int sd_io_time = SD_IO_TIME;
235 int sd_failfast_enable = 1;
236 int sd_ua_retry_count = SD_UA_RETRY_COUNT;
237 int sd_report_pfa = 1;
238 int sd_max_throttle = SD_MAX_THROTTLE;
239 int sd_min_throttle = SD_MIN_THROTTLE;
240 int sd_rot_delay = 4; /* Default 4ms Rotation delay */
241 int sd_qfull_throttle_enable = TRUE;
242
243 int sd_retry_on_reservation_conflict = 1;
244 int sd_reinstate_resv_delay = SD_REINSTATE_RESV_DELAY;
245 _NOTE(SCHEME_PROTECTS_DATA("safe sharing", sd_reinstate_resv_delay))
246
247 static int sd_dtype_optical_bind = -1;
248
249 /* Note: the following is not a bug, it really is "sd_" and not "ssd_" */
250 static char *sd_resv_conflict_name = "sd_retry_on_reservation_conflict";
251
252 /*
253 * Global data for debug logging. To enable debug printing, sd_component_mask
254 * and sd_level_mask should be set to the desired bit patterns as outlined in
255 * sddef.h.
256 */
257 uint_t sd_component_mask = 0x0;
258 uint_t sd_level_mask = 0x0;
259 struct sd_lun *sd_debug_un = NULL;
260 uint_t sd_error_level = SCSI_ERR_RETRYABLE;
261
262 /* Note: these may go away in the future... */
263 static uint32_t sd_xbuf_active_limit = 512;
264 static uint32_t sd_xbuf_reserve_limit = 16;
265
266 static struct sd_resv_reclaim_request sd_tr = { NULL, NULL, NULL, 0, 0, 0 };
267
268 /*
269 * Timer value used to reset the throttle after it has been reduced
270 * (typically in response to TRAN_BUSY or STATUS_QFULL)
271 */
272 static int sd_reset_throttle_timeout = SD_RESET_THROTTLE_TIMEOUT;
273 static int sd_qfull_throttle_timeout = SD_QFULL_THROTTLE_TIMEOUT;
274
275 /*
276 * Interval value associated with the media change scsi watch.
277 */
278 static int sd_check_media_time = 3000000;
279
280 /*
281 * Wait value used for in progress operations during a DDI_SUSPEND
282 */
283 static int sd_wait_cmds_complete = SD_WAIT_CMDS_COMPLETE;
284
285 /*
286 * sd_label_mutex protects a static buffer used in the disk label
287 * component of the driver
288 */
289 static kmutex_t sd_label_mutex;
290
291 /*
292 * sd_detach_mutex protects un_layer_count, un_detach_count, and
293 * un_opens_in_progress in the sd_lun structure.
294 */
295 static kmutex_t sd_detach_mutex;
296
297 _NOTE(MUTEX_PROTECTS_DATA(sd_detach_mutex,
298 sd_lun::{un_layer_count un_detach_count un_opens_in_progress}))
299
300 /*
301 * Global buffer and mutex for debug logging
302 */
303 static char sd_log_buf[1024];
304 static kmutex_t sd_log_mutex;
305
306 /*
307 * Structs and globals for recording attached lun information.
308 * This maintains a chain. Each node in the chain represents a SCSI controller.
309 * The structure records the number of luns attached to each target connected
310 * with the controller.
311 * For parallel scsi device only.
312 */
313 struct sd_scsi_hba_tgt_lun {
314 struct sd_scsi_hba_tgt_lun *next;
315 dev_info_t *pdip;
316 int nlun[NTARGETS_WIDE];
317 };
318
319 /*
320 * Flag to indicate the lun is attached or detached
321 */
322 #define SD_SCSI_LUN_ATTACH 0
323 #define SD_SCSI_LUN_DETACH 1
324
325 static kmutex_t sd_scsi_target_lun_mutex;
326 static struct sd_scsi_hba_tgt_lun *sd_scsi_target_lun_head = NULL;
327
328 _NOTE(MUTEX_PROTECTS_DATA(sd_scsi_target_lun_mutex,
329 sd_scsi_hba_tgt_lun::next sd_scsi_hba_tgt_lun::pdip))
330
331 _NOTE(MUTEX_PROTECTS_DATA(sd_scsi_target_lun_mutex,
332 sd_scsi_target_lun_head))
333
334 /*
335 * "Smart" Probe Caching structs, globals, #defines, etc.
336 * For parallel scsi and non-self-identify device only.
337 */
338
339 /*
340 * The following resources and routines are implemented to support
341 * "smart" probing, which caches the scsi_probe() results in an array,
342 * in order to help avoid long probe times.
343 */
344 struct sd_scsi_probe_cache {
345 struct sd_scsi_probe_cache *next;
346 dev_info_t *pdip;
347 int cache[NTARGETS_WIDE];
348 };
349
350 static kmutex_t sd_scsi_probe_cache_mutex;
351 static struct sd_scsi_probe_cache *sd_scsi_probe_cache_head = NULL;
352
353 /*
354 * Really we only need protection on the head of the linked list, but
355 * better safe than sorry.
356 */
357 _NOTE(MUTEX_PROTECTS_DATA(sd_scsi_probe_cache_mutex,
358 sd_scsi_probe_cache::next sd_scsi_probe_cache::pdip))
359
360 _NOTE(MUTEX_PROTECTS_DATA(sd_scsi_probe_cache_mutex,
361 sd_scsi_probe_cache_head))
362
363 /*
364 * Power attribute table
365 */
366 static sd_power_attr_ss sd_pwr_ss = {
367 { "NAME=spindle-motor", "0=off", "1=on", NULL },
368 {0, 100},
369 {30, 0},
370 {20000, 0}
371 };
372
373 static sd_power_attr_pc sd_pwr_pc = {
374 { "NAME=spindle-motor", "0=stopped", "1=standby", "2=idle",
375 "3=active", NULL },
376 {0, 0, 0, 100},
377 {90, 90, 20, 0},
378 {15000, 15000, 1000, 0}
379 };
380
381 /*
382 * Power level to power condition
383 */
384 static int sd_pl2pc[] = {
385 SD_TARGET_START_VALID,
386 SD_TARGET_STANDBY,
387 SD_TARGET_IDLE,
388 SD_TARGET_ACTIVE
389 };
390
391 /*
392 * Vendor specific data name property declarations
393 */
394
395 #if defined(__fibre) || defined(__i386) ||defined(__amd64)
396
397 static sd_tunables seagate_properties = {
398 SEAGATE_THROTTLE_VALUE,
399 0,
400 0,
401 0,
402 0,
403 0,
404 0,
405 0,
406 0
407 };
408
409
410 static sd_tunables fujitsu_properties = {
411 FUJITSU_THROTTLE_VALUE,
412 0,
413 0,
414 0,
415 0,
416 0,
417 0,
418 0,
419 0
420 };
421
422 static sd_tunables ibm_properties = {
423 IBM_THROTTLE_VALUE,
424 0,
425 0,
426 0,
427 0,
428 0,
429 0,
430 0,
431 0
432 };
433
434 static sd_tunables purple_properties = {
435 PURPLE_THROTTLE_VALUE,
436 0,
437 0,
438 PURPLE_BUSY_RETRIES,
439 PURPLE_RESET_RETRY_COUNT,
440 PURPLE_RESERVE_RELEASE_TIME,
441 0,
442 0,
443 0
444 };
445
446 static sd_tunables sve_properties = {
447 SVE_THROTTLE_VALUE,
448 0,
449 0,
450 SVE_BUSY_RETRIES,
451 SVE_RESET_RETRY_COUNT,
452 SVE_RESERVE_RELEASE_TIME,
453 SVE_MIN_THROTTLE_VALUE,
454 SVE_DISKSORT_DISABLED_FLAG,
455 0
456 };
457
458 static sd_tunables maserati_properties = {
459 0,
460 0,
461 0,
462 0,
463 0,
464 0,
465 0,
466 MASERATI_DISKSORT_DISABLED_FLAG,
467 MASERATI_LUN_RESET_ENABLED_FLAG
468 };
469
470 static sd_tunables pirus_properties = {
471 PIRUS_THROTTLE_VALUE,
472 0,
473 PIRUS_NRR_COUNT,
474 PIRUS_BUSY_RETRIES,
475 PIRUS_RESET_RETRY_COUNT,
476 0,
477 PIRUS_MIN_THROTTLE_VALUE,
478 PIRUS_DISKSORT_DISABLED_FLAG,
479 PIRUS_LUN_RESET_ENABLED_FLAG
480 };
481
482 #endif
483
484 #if (defined(__sparc) && !defined(__fibre)) || \
485 (defined(__i386) || defined(__amd64))
486
487
488 static sd_tunables elite_properties = {
489 ELITE_THROTTLE_VALUE,
490 0,
491 0,
492 0,
493 0,
494 0,
495 0,
496 0,
497 0
498 };
499
500 static sd_tunables st31200n_properties = {
501 ST31200N_THROTTLE_VALUE,
502 0,
503 0,
504 0,
505 0,
506 0,
507 0,
508 0,
509 0
510 };
511
512 #endif /* Fibre or not */
513
514 static sd_tunables lsi_properties_scsi = {
515 LSI_THROTTLE_VALUE,
516 0,
517 LSI_NOTREADY_RETRIES,
518 0,
519 0,
520 0,
521 0,
522 0,
523 0
524 };
525
526 static sd_tunables symbios_properties = {
527 SYMBIOS_THROTTLE_VALUE,
528 0,
529 SYMBIOS_NOTREADY_RETRIES,
530 0,
531 0,
532 0,
533 0,
534 0,
535 0
536 };
537
538 static sd_tunables lsi_properties = {
539 0,
540 0,
541 LSI_NOTREADY_RETRIES,
542 0,
543 0,
544 0,
545 0,
546 0,
547 0
548 };
549
550 static sd_tunables lsi_oem_properties = {
551 0,
552 0,
553 LSI_OEM_NOTREADY_RETRIES,
554 0,
555 0,
556 0,
557 0,
558 0,
559 0,
560 1
561 };
562
563
564
565 #if (defined(SD_PROP_TST))
566
567 #define SD_TST_CTYPE_VAL CTYPE_CDROM
568 #define SD_TST_THROTTLE_VAL 16
569 #define SD_TST_NOTREADY_VAL 12
570 #define SD_TST_BUSY_VAL 60
571 #define SD_TST_RST_RETRY_VAL 36
572 #define SD_TST_RSV_REL_TIME 60
573
574 static sd_tunables tst_properties = {
575 SD_TST_THROTTLE_VAL,
576 SD_TST_CTYPE_VAL,
577 SD_TST_NOTREADY_VAL,
578 SD_TST_BUSY_VAL,
579 SD_TST_RST_RETRY_VAL,
580 SD_TST_RSV_REL_TIME,
581 0,
582 0,
583 0
584 };
585 #endif
586
587 /* This is similar to the ANSI toupper implementation */
588 #define SD_TOUPPER(C) (((C) >= 'a' && (C) <= 'z') ? (C) - 'a' + 'A' : (C))
589
590 /*
591 * Static Driver Configuration Table
592 *
593 * This is the table of disks which need throttle adjustment (or, perhaps
594 * something else as defined by the flags at a future time.) device_id
595 * is a string consisting of concatenated vid (vendor), pid (product/model)
596 * and revision strings as defined in the scsi_inquiry structure. Offsets of
597 * the parts of the string are as defined by the sizes in the scsi_inquiry
598 * structure. Device type is searched as far as the device_id string is
599 * defined. Flags defines which values are to be set in the driver from the
600 * properties list.
601 *
602 * Entries below which begin and end with a "*" are a special case.
603 * These do not have a specific vendor, and the string which follows
604 * can appear anywhere in the 16 byte PID portion of the inquiry data.
605 *
606 * Entries below which begin and end with a " " (blank) are a special
607 * case. The comparison function will treat multiple consecutive blanks
608 * as equivalent to a single blank. For example, this causes a
609 * sd_disk_table entry of " NEC CDROM " to match a device's id string
610 * of "NEC CDROM".
611 *
612 * Note: The MD21 controller type has been obsoleted.
613 * ST318202F is a Legacy device
614 * MAM3182FC, MAM3364FC, MAM3738FC do not appear to have ever been
615 * made with an FC connection. The entries here are a legacy.
616 */
617 static sd_disk_config_t sd_disk_table[] = {
618 #if defined(__fibre) || defined(__i386) || defined(__amd64)
619 { "SEAGATE ST34371FC", SD_CONF_BSET_THROTTLE, &seagate_properties },
620 { "SEAGATE ST19171FC", SD_CONF_BSET_THROTTLE, &seagate_properties },
621 { "SEAGATE ST39102FC", SD_CONF_BSET_THROTTLE, &seagate_properties },
622 { "SEAGATE ST39103FC", SD_CONF_BSET_THROTTLE, &seagate_properties },
623 { "SEAGATE ST118273F", SD_CONF_BSET_THROTTLE, &seagate_properties },
624 { "SEAGATE ST318202F", SD_CONF_BSET_THROTTLE, &seagate_properties },
625 { "SEAGATE ST318203F", SD_CONF_BSET_THROTTLE, &seagate_properties },
626 { "SEAGATE ST136403F", SD_CONF_BSET_THROTTLE, &seagate_properties },
627 { "SEAGATE ST318304F", SD_CONF_BSET_THROTTLE, &seagate_properties },
628 { "SEAGATE ST336704F", SD_CONF_BSET_THROTTLE, &seagate_properties },
629 { "SEAGATE ST373405F", SD_CONF_BSET_THROTTLE, &seagate_properties },
630 { "SEAGATE ST336605F", SD_CONF_BSET_THROTTLE, &seagate_properties },
631 { "SEAGATE ST336752F", SD_CONF_BSET_THROTTLE, &seagate_properties },
632 { "SEAGATE ST318452F", SD_CONF_BSET_THROTTLE, &seagate_properties },
633 { "FUJITSU MAG3091F", SD_CONF_BSET_THROTTLE, &fujitsu_properties },
634 { "FUJITSU MAG3182F", SD_CONF_BSET_THROTTLE, &fujitsu_properties },
635 { "FUJITSU MAA3182F", SD_CONF_BSET_THROTTLE, &fujitsu_properties },
636 { "FUJITSU MAF3364F", SD_CONF_BSET_THROTTLE, &fujitsu_properties },
637 { "FUJITSU MAL3364F", SD_CONF_BSET_THROTTLE, &fujitsu_properties },
638 { "FUJITSU MAL3738F", SD_CONF_BSET_THROTTLE, &fujitsu_properties },
639 { "FUJITSU MAM3182FC", SD_CONF_BSET_THROTTLE, &fujitsu_properties },
640 { "FUJITSU MAM3364FC", SD_CONF_BSET_THROTTLE, &fujitsu_properties },
641 { "FUJITSU MAM3738FC", SD_CONF_BSET_THROTTLE, &fujitsu_properties },
642 { "IBM DDYFT1835", SD_CONF_BSET_THROTTLE, &ibm_properties },
643 { "IBM DDYFT3695", SD_CONF_BSET_THROTTLE, &ibm_properties },
644 { "IBM IC35LF2D2", SD_CONF_BSET_THROTTLE, &ibm_properties },
645 { "IBM IC35LF2PR", SD_CONF_BSET_THROTTLE, &ibm_properties },
646 { "IBM 1724-100", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
647 { "IBM 1726-2xx", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
648 { "IBM 1726-22x", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
649 { "IBM 1726-4xx", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
650 { "IBM 1726-42x", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
651 { "IBM 1726-3xx", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
652 { "IBM 3526", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
653 { "IBM 3542", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
654 { "IBM 3552", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
655 { "IBM 1722", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
656 { "IBM 1742", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
657 { "IBM 1815", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
658 { "IBM FAStT", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
659 { "IBM 1814", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
660 { "IBM 1814-200", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
661 { "IBM 1818", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
662 { "DELL MD3000", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
663 { "DELL MD3000i", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
664 { "LSI INF", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
665 { "ENGENIO INF", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
666 { "SGI TP", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
667 { "SGI IS", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
668 { "*CSM100_*", SD_CONF_BSET_NRR_COUNT |
669 SD_CONF_BSET_CACHE_IS_NV, &lsi_oem_properties },
670 { "*CSM200_*", SD_CONF_BSET_NRR_COUNT |
671 SD_CONF_BSET_CACHE_IS_NV, &lsi_oem_properties },
672 { "Fujitsu SX300", SD_CONF_BSET_THROTTLE, &lsi_oem_properties },
673 { "LSI", SD_CONF_BSET_NRR_COUNT, &lsi_properties },
674 { "SUN T3", SD_CONF_BSET_THROTTLE |
675 SD_CONF_BSET_BSY_RETRY_COUNT|
676 SD_CONF_BSET_RST_RETRIES|
677 SD_CONF_BSET_RSV_REL_TIME,
678 &purple_properties },
679 { "SUN SESS01", SD_CONF_BSET_THROTTLE |
680 SD_CONF_BSET_BSY_RETRY_COUNT|
681 SD_CONF_BSET_RST_RETRIES|
682 SD_CONF_BSET_RSV_REL_TIME|
683 SD_CONF_BSET_MIN_THROTTLE|
684 SD_CONF_BSET_DISKSORT_DISABLED,
685 &sve_properties },
686 { "SUN T4", SD_CONF_BSET_THROTTLE |
687 SD_CONF_BSET_BSY_RETRY_COUNT|
688 SD_CONF_BSET_RST_RETRIES|
689 SD_CONF_BSET_RSV_REL_TIME,
690 &purple_properties },
691 { "SUN SVE01", SD_CONF_BSET_DISKSORT_DISABLED |
692 SD_CONF_BSET_LUN_RESET_ENABLED,
693 &maserati_properties },
694 { "SUN SE6920", SD_CONF_BSET_THROTTLE |
695 SD_CONF_BSET_NRR_COUNT|
696 SD_CONF_BSET_BSY_RETRY_COUNT|
697 SD_CONF_BSET_RST_RETRIES|
698 SD_CONF_BSET_MIN_THROTTLE|
699 SD_CONF_BSET_DISKSORT_DISABLED|
700 SD_CONF_BSET_LUN_RESET_ENABLED,
701 &pirus_properties },
702 { "SUN SE6940", SD_CONF_BSET_THROTTLE |
703 SD_CONF_BSET_NRR_COUNT|
704 SD_CONF_BSET_BSY_RETRY_COUNT|
705 SD_CONF_BSET_RST_RETRIES|
706 SD_CONF_BSET_MIN_THROTTLE|
707 SD_CONF_BSET_DISKSORT_DISABLED|
708 SD_CONF_BSET_LUN_RESET_ENABLED,
709 &pirus_properties },
710 { "SUN StorageTek 6920", SD_CONF_BSET_THROTTLE |
711 SD_CONF_BSET_NRR_COUNT|
712 SD_CONF_BSET_BSY_RETRY_COUNT|
713 SD_CONF_BSET_RST_RETRIES|
714 SD_CONF_BSET_MIN_THROTTLE|
715 SD_CONF_BSET_DISKSORT_DISABLED|
716 SD_CONF_BSET_LUN_RESET_ENABLED,
717 &pirus_properties },
718 { "SUN StorageTek 6940", SD_CONF_BSET_THROTTLE |
719 SD_CONF_BSET_NRR_COUNT|
720 SD_CONF_BSET_BSY_RETRY_COUNT|
721 SD_CONF_BSET_RST_RETRIES|
722 SD_CONF_BSET_MIN_THROTTLE|
723 SD_CONF_BSET_DISKSORT_DISABLED|
724 SD_CONF_BSET_LUN_RESET_ENABLED,
725 &pirus_properties },
726 { "SUN PSX1000", SD_CONF_BSET_THROTTLE |
727 SD_CONF_BSET_NRR_COUNT|
728 SD_CONF_BSET_BSY_RETRY_COUNT|
729 SD_CONF_BSET_RST_RETRIES|
730 SD_CONF_BSET_MIN_THROTTLE|
731 SD_CONF_BSET_DISKSORT_DISABLED|
732 SD_CONF_BSET_LUN_RESET_ENABLED,
733 &pirus_properties },
734 { "SUN SE6330", SD_CONF_BSET_THROTTLE |
735 SD_CONF_BSET_NRR_COUNT|
736 SD_CONF_BSET_BSY_RETRY_COUNT|
737 SD_CONF_BSET_RST_RETRIES|
738 SD_CONF_BSET_MIN_THROTTLE|
739 SD_CONF_BSET_DISKSORT_DISABLED|
740 SD_CONF_BSET_LUN_RESET_ENABLED,
741 &pirus_properties },
742 { "SUN STK6580_6780", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
743 { "SUN SUN_6180", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
744 { "STK OPENstorage", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
745 { "STK OpenStorage", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
746 { "STK BladeCtlr", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
747 { "STK FLEXLINE", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
748 { "SYMBIOS", SD_CONF_BSET_NRR_COUNT, &symbios_properties },
749 #endif /* fibre or NON-sparc platforms */
750 #if ((defined(__sparc) && !defined(__fibre)) ||\
751 (defined(__i386) || defined(__amd64)))
752 { "SEAGATE ST42400N", SD_CONF_BSET_THROTTLE, &elite_properties },
753 { "SEAGATE ST31200N", SD_CONF_BSET_THROTTLE, &st31200n_properties },
754 { "SEAGATE ST41600N", SD_CONF_BSET_TUR_CHECK, NULL },
755 { "CONNER CP30540", SD_CONF_BSET_NOCACHE, NULL },
756 { "*SUN0104*", SD_CONF_BSET_FAB_DEVID, NULL },
757 { "*SUN0207*", SD_CONF_BSET_FAB_DEVID, NULL },
758 { "*SUN0327*", SD_CONF_BSET_FAB_DEVID, NULL },
759 { "*SUN0340*", SD_CONF_BSET_FAB_DEVID, NULL },
760 { "*SUN0424*", SD_CONF_BSET_FAB_DEVID, NULL },
761 { "*SUN0669*", SD_CONF_BSET_FAB_DEVID, NULL },
762 { "*SUN1.0G*", SD_CONF_BSET_FAB_DEVID, NULL },
763 { "SYMBIOS INF-01-00 ", SD_CONF_BSET_FAB_DEVID, NULL },
764 { "SYMBIOS", SD_CONF_BSET_THROTTLE|SD_CONF_BSET_NRR_COUNT,
765 &symbios_properties },
766 { "LSI", SD_CONF_BSET_THROTTLE | SD_CONF_BSET_NRR_COUNT,
767 &lsi_properties_scsi },
768 #if defined(__i386) || defined(__amd64)
769 { " NEC CD-ROM DRIVE:260 ", (SD_CONF_BSET_PLAYMSF_BCD
770 | SD_CONF_BSET_READSUB_BCD
771 | SD_CONF_BSET_READ_TOC_ADDR_BCD
772 | SD_CONF_BSET_NO_READ_HEADER
773 | SD_CONF_BSET_READ_CD_XD4), NULL },
774
775 { " NEC CD-ROM DRIVE:270 ", (SD_CONF_BSET_PLAYMSF_BCD
776 | SD_CONF_BSET_READSUB_BCD
777 | SD_CONF_BSET_READ_TOC_ADDR_BCD
778 | SD_CONF_BSET_NO_READ_HEADER
779 | SD_CONF_BSET_READ_CD_XD4), NULL },
780 #endif /* __i386 || __amd64 */
781 #endif /* sparc NON-fibre or NON-sparc platforms */
782
783 #if (defined(SD_PROP_TST))
784 { "VENDOR PRODUCT ", (SD_CONF_BSET_THROTTLE
785 | SD_CONF_BSET_CTYPE
786 | SD_CONF_BSET_NRR_COUNT
787 | SD_CONF_BSET_FAB_DEVID
788 | SD_CONF_BSET_NOCACHE
789 | SD_CONF_BSET_BSY_RETRY_COUNT
790 | SD_CONF_BSET_PLAYMSF_BCD
791 | SD_CONF_BSET_READSUB_BCD
792 | SD_CONF_BSET_READ_TOC_TRK_BCD
793 | SD_CONF_BSET_READ_TOC_ADDR_BCD
794 | SD_CONF_BSET_NO_READ_HEADER
795 | SD_CONF_BSET_READ_CD_XD4
796 | SD_CONF_BSET_RST_RETRIES
797 | SD_CONF_BSET_RSV_REL_TIME
798 | SD_CONF_BSET_TUR_CHECK), &tst_properties},
799 #endif
800 };
801
802 static const int sd_disk_table_size =
803 sizeof (sd_disk_table)/ sizeof (sd_disk_config_t);
804
805 /*
806 * Emulation mode disk drive VID/PID table
807 */
808 static char sd_flash_dev_table[][25] = {
809 "ATA MARVELL SD88SA02",
810 "MARVELL SD88SA02",
811 "TOSHIBA THNSNV05",
812 };
813
814 static const int sd_flash_dev_table_size =
815 sizeof (sd_flash_dev_table) / sizeof (sd_flash_dev_table[0]);
816
817 #define SD_INTERCONNECT_PARALLEL 0
818 #define SD_INTERCONNECT_FABRIC 1
819 #define SD_INTERCONNECT_FIBRE 2
820 #define SD_INTERCONNECT_SSA 3
821 #define SD_INTERCONNECT_SATA 4
822 #define SD_INTERCONNECT_SAS 5
823
824 #define SD_IS_PARALLEL_SCSI(un) \
825 ((un)->un_interconnect_type == SD_INTERCONNECT_PARALLEL)
826 #define SD_IS_SERIAL(un) \
827 (((un)->un_interconnect_type == SD_INTERCONNECT_SATA) ||\
828 ((un)->un_interconnect_type == SD_INTERCONNECT_SAS))
829
830 /*
831 * Definitions used by device id registration routines
832 */
833 #define VPD_HEAD_OFFSET 3 /* size of head for vpd page */
834 #define VPD_PAGE_LENGTH 3 /* offset for pge length data */
835 #define VPD_MODE_PAGE 1 /* offset into vpd pg for "page code" */
836
837 static kmutex_t sd_sense_mutex = {0};
838
839 /*
840 * Macros for updates of the driver state
841 */
842 #define New_state(un, s) \
843 (un)->un_last_state = (un)->un_state, (un)->un_state = (s)
844 #define Restore_state(un) \
845 { uchar_t tmp = (un)->un_last_state; New_state((un), tmp); }
846
847 static struct sd_cdbinfo sd_cdbtab[] = {
848 { CDB_GROUP0, 0x00, 0x1FFFFF, 0xFF, },
849 { CDB_GROUP1, SCMD_GROUP1, 0xFFFFFFFF, 0xFFFF, },
850 { CDB_GROUP5, SCMD_GROUP5, 0xFFFFFFFF, 0xFFFFFFFF, },
851 { CDB_GROUP4, SCMD_GROUP4, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFF, },
852 };
853
854 /*
855 * Specifies the number of seconds that must have elapsed since the last
856 * cmd. has completed for a device to be declared idle to the PM framework.
857 */
858 static int sd_pm_idletime = 1;
859
860 /*
861 * Internal function prototypes
862 */
863
864 #if (defined(__fibre))
865 /*
866 * These #defines are to avoid namespace collisions that occur because this
867 * code is currently used to compile two separate driver modules: sd and ssd.
868 * All function names need to be treated this way (even if declared static)
869 * in order to allow the debugger to resolve the names properly.
870 * It is anticipated that in the near future the ssd module will be obsoleted,
871 * at which time this ugliness should go away.
872 */
873 #define sd_log_trace ssd_log_trace
874 #define sd_log_info ssd_log_info
875 #define sd_log_err ssd_log_err
876 #define sdprobe ssdprobe
877 #define sdinfo ssdinfo
878 #define sd_prop_op ssd_prop_op
879 #define sd_scsi_probe_cache_init ssd_scsi_probe_cache_init
880 #define sd_scsi_probe_cache_fini ssd_scsi_probe_cache_fini
881 #define sd_scsi_clear_probe_cache ssd_scsi_clear_probe_cache
882 #define sd_scsi_probe_with_cache ssd_scsi_probe_with_cache
883 #define sd_scsi_target_lun_init ssd_scsi_target_lun_init
884 #define sd_scsi_target_lun_fini ssd_scsi_target_lun_fini
885 #define sd_scsi_get_target_lun_count ssd_scsi_get_target_lun_count
886 #define sd_scsi_update_lun_on_target ssd_scsi_update_lun_on_target
887 #define sd_spin_up_unit ssd_spin_up_unit
888 #define sd_enable_descr_sense ssd_enable_descr_sense
889 #define sd_reenable_dsense_task ssd_reenable_dsense_task
890 #define sd_set_mmc_caps ssd_set_mmc_caps
891 #define sd_read_unit_properties ssd_read_unit_properties
892 #define sd_process_sdconf_file ssd_process_sdconf_file
893 #define sd_process_sdconf_table ssd_process_sdconf_table
894 #define sd_sdconf_id_match ssd_sdconf_id_match
895 #define sd_blank_cmp ssd_blank_cmp
896 #define sd_chk_vers1_data ssd_chk_vers1_data
897 #define sd_set_vers1_properties ssd_set_vers1_properties
898 #define sd_check_bdc_vpd ssd_check_bdc_vpd
899 #define sd_check_emulation_mode ssd_check_emulation_mode
900
901 #define sd_get_physical_geometry ssd_get_physical_geometry
902 #define sd_get_virtual_geometry ssd_get_virtual_geometry
903 #define sd_update_block_info ssd_update_block_info
904 #define sd_register_devid ssd_register_devid
905 #define sd_get_devid ssd_get_devid
906 #define sd_create_devid ssd_create_devid
907 #define sd_write_deviceid ssd_write_deviceid
908 #define sd_check_vpd_page_support ssd_check_vpd_page_support
909 #define sd_setup_pm ssd_setup_pm
910 #define sd_create_pm_components ssd_create_pm_components
911 #define sd_ddi_suspend ssd_ddi_suspend
912 #define sd_ddi_resume ssd_ddi_resume
913 #define sd_pm_state_change ssd_pm_state_change
914 #define sdpower ssdpower
915 #define sdattach ssdattach
916 #define sddetach ssddetach
917 #define sd_unit_attach ssd_unit_attach
918 #define sd_unit_detach ssd_unit_detach
919 #define sd_set_unit_attributes ssd_set_unit_attributes
920 #define sd_create_errstats ssd_create_errstats
921 #define sd_set_errstats ssd_set_errstats
922 #define sd_set_pstats ssd_set_pstats
923 #define sddump ssddump
924 #define sd_scsi_poll ssd_scsi_poll
925 #define sd_send_polled_RQS ssd_send_polled_RQS
926 #define sd_ddi_scsi_poll ssd_ddi_scsi_poll
927 #define sd_init_event_callbacks ssd_init_event_callbacks
928 #define sd_event_callback ssd_event_callback
929 #define sd_cache_control ssd_cache_control
930 #define sd_get_write_cache_enabled ssd_get_write_cache_enabled
931 #define sd_get_write_cache_changeable ssd_get_write_cache_changeable
932 #define sd_get_nv_sup ssd_get_nv_sup
933 #define sd_make_device ssd_make_device
934 #define sdopen ssdopen
935 #define sdclose ssdclose
936 #define sd_ready_and_valid ssd_ready_and_valid
937 #define sdmin ssdmin
938 #define sdread ssdread
939 #define sdwrite ssdwrite
940 #define sdaread ssdaread
941 #define sdawrite ssdawrite
942 #define sdstrategy ssdstrategy
943 #define sdioctl ssdioctl
944 #define sd_mapblockaddr_iostart ssd_mapblockaddr_iostart
945 #define sd_mapblocksize_iostart ssd_mapblocksize_iostart
946 #define sd_checksum_iostart ssd_checksum_iostart
947 #define sd_checksum_uscsi_iostart ssd_checksum_uscsi_iostart
948 #define sd_pm_iostart ssd_pm_iostart
949 #define sd_core_iostart ssd_core_iostart
950 #define sd_mapblockaddr_iodone ssd_mapblockaddr_iodone
951 #define sd_mapblocksize_iodone ssd_mapblocksize_iodone
952 #define sd_checksum_iodone ssd_checksum_iodone
953 #define sd_checksum_uscsi_iodone ssd_checksum_uscsi_iodone
954 #define sd_pm_iodone ssd_pm_iodone
955 #define sd_initpkt_for_buf ssd_initpkt_for_buf
956 #define sd_destroypkt_for_buf ssd_destroypkt_for_buf
957 #define sd_setup_rw_pkt ssd_setup_rw_pkt
958 #define sd_setup_next_rw_pkt ssd_setup_next_rw_pkt
959 #define sd_buf_iodone ssd_buf_iodone
960 #define sd_uscsi_strategy ssd_uscsi_strategy
961 #define sd_initpkt_for_uscsi ssd_initpkt_for_uscsi
962 #define sd_destroypkt_for_uscsi ssd_destroypkt_for_uscsi
963 #define sd_uscsi_iodone ssd_uscsi_iodone
964 #define sd_xbuf_strategy ssd_xbuf_strategy
965 #define sd_xbuf_init ssd_xbuf_init
966 #define sd_pm_entry ssd_pm_entry
967 #define sd_pm_exit ssd_pm_exit
968
969 #define sd_pm_idletimeout_handler ssd_pm_idletimeout_handler
970 #define sd_pm_timeout_handler ssd_pm_timeout_handler
971
972 #define sd_add_buf_to_waitq ssd_add_buf_to_waitq
973 #define sdintr ssdintr
974 #define sd_start_cmds ssd_start_cmds
975 #define sd_send_scsi_cmd ssd_send_scsi_cmd
976 #define sd_bioclone_alloc ssd_bioclone_alloc
977 #define sd_bioclone_free ssd_bioclone_free
978 #define sd_shadow_buf_alloc ssd_shadow_buf_alloc
979 #define sd_shadow_buf_free ssd_shadow_buf_free
980 #define sd_print_transport_rejected_message \
981 ssd_print_transport_rejected_message
982 #define sd_retry_command ssd_retry_command
983 #define sd_set_retry_bp ssd_set_retry_bp
984 #define sd_send_request_sense_command ssd_send_request_sense_command
985 #define sd_start_retry_command ssd_start_retry_command
986 #define sd_start_direct_priority_command \
987 ssd_start_direct_priority_command
988 #define sd_return_failed_command ssd_return_failed_command
989 #define sd_return_failed_command_no_restart \
990 ssd_return_failed_command_no_restart
991 #define sd_return_command ssd_return_command
992 #define sd_sync_with_callback ssd_sync_with_callback
993 #define sdrunout ssdrunout
994 #define sd_mark_rqs_busy ssd_mark_rqs_busy
995 #define sd_mark_rqs_idle ssd_mark_rqs_idle
996 #define sd_reduce_throttle ssd_reduce_throttle
997 #define sd_restore_throttle ssd_restore_throttle
998 #define sd_print_incomplete_msg ssd_print_incomplete_msg
999 #define sd_init_cdb_limits ssd_init_cdb_limits
1000 #define sd_pkt_status_good ssd_pkt_status_good
1001 #define sd_pkt_status_check_condition ssd_pkt_status_check_condition
1002 #define sd_pkt_status_busy ssd_pkt_status_busy
1003 #define sd_pkt_status_reservation_conflict \
1004 ssd_pkt_status_reservation_conflict
1005 #define sd_pkt_status_qfull ssd_pkt_status_qfull
1006 #define sd_handle_request_sense ssd_handle_request_sense
1007 #define sd_handle_auto_request_sense ssd_handle_auto_request_sense
1008 #define sd_print_sense_failed_msg ssd_print_sense_failed_msg
1009 #define sd_validate_sense_data ssd_validate_sense_data
1010 #define sd_decode_sense ssd_decode_sense
1011 #define sd_print_sense_msg ssd_print_sense_msg
1012 #define sd_sense_key_no_sense ssd_sense_key_no_sense
1013 #define sd_sense_key_recoverable_error ssd_sense_key_recoverable_error
1014 #define sd_sense_key_not_ready ssd_sense_key_not_ready
1015 #define sd_sense_key_medium_or_hardware_error \
1016 ssd_sense_key_medium_or_hardware_error
1017 #define sd_sense_key_illegal_request ssd_sense_key_illegal_request
1018 #define sd_sense_key_unit_attention ssd_sense_key_unit_attention
1019 #define sd_sense_key_fail_command ssd_sense_key_fail_command
1020 #define sd_sense_key_blank_check ssd_sense_key_blank_check
1021 #define sd_sense_key_aborted_command ssd_sense_key_aborted_command
1022 #define sd_sense_key_default ssd_sense_key_default
1023 #define sd_print_retry_msg ssd_print_retry_msg
1024 #define sd_print_cmd_incomplete_msg ssd_print_cmd_incomplete_msg
1025 #define sd_pkt_reason_cmd_incomplete ssd_pkt_reason_cmd_incomplete
1026 #define sd_pkt_reason_cmd_tran_err ssd_pkt_reason_cmd_tran_err
1027 #define sd_pkt_reason_cmd_reset ssd_pkt_reason_cmd_reset
1028 #define sd_pkt_reason_cmd_aborted ssd_pkt_reason_cmd_aborted
1029 #define sd_pkt_reason_cmd_timeout ssd_pkt_reason_cmd_timeout
1030 #define sd_pkt_reason_cmd_unx_bus_free ssd_pkt_reason_cmd_unx_bus_free
1031 #define sd_pkt_reason_cmd_tag_reject ssd_pkt_reason_cmd_tag_reject
1032 #define sd_pkt_reason_default ssd_pkt_reason_default
1033 #define sd_reset_target ssd_reset_target
1034 #define sd_start_stop_unit_callback ssd_start_stop_unit_callback
1035 #define sd_start_stop_unit_task ssd_start_stop_unit_task
1036 #define sd_taskq_create ssd_taskq_create
1037 #define sd_taskq_delete ssd_taskq_delete
1038 #define sd_target_change_task ssd_target_change_task
1039 #define sd_log_dev_status_event ssd_log_dev_status_event
1040 #define sd_log_lun_expansion_event ssd_log_lun_expansion_event
1041 #define sd_log_eject_request_event ssd_log_eject_request_event
1042 #define sd_media_change_task ssd_media_change_task
1043 #define sd_handle_mchange ssd_handle_mchange
1044 #define sd_send_scsi_DOORLOCK ssd_send_scsi_DOORLOCK
1045 #define sd_send_scsi_READ_CAPACITY ssd_send_scsi_READ_CAPACITY
1046 #define sd_send_scsi_READ_CAPACITY_16 ssd_send_scsi_READ_CAPACITY_16
1047 #define sd_send_scsi_GET_CONFIGURATION ssd_send_scsi_GET_CONFIGURATION
1048 #define sd_send_scsi_feature_GET_CONFIGURATION \
1049 sd_send_scsi_feature_GET_CONFIGURATION
1050 #define sd_send_scsi_START_STOP_UNIT ssd_send_scsi_START_STOP_UNIT
1051 #define sd_send_scsi_INQUIRY ssd_send_scsi_INQUIRY
1052 #define sd_send_scsi_TEST_UNIT_READY ssd_send_scsi_TEST_UNIT_READY
1053 #define sd_send_scsi_PERSISTENT_RESERVE_IN \
1054 ssd_send_scsi_PERSISTENT_RESERVE_IN
1055 #define sd_send_scsi_PERSISTENT_RESERVE_OUT \
1056 ssd_send_scsi_PERSISTENT_RESERVE_OUT
1057 #define sd_send_scsi_SYNCHRONIZE_CACHE ssd_send_scsi_SYNCHRONIZE_CACHE
1058 #define sd_send_scsi_SYNCHRONIZE_CACHE_biodone \
1059 ssd_send_scsi_SYNCHRONIZE_CACHE_biodone
1060 #define sd_send_scsi_MODE_SENSE ssd_send_scsi_MODE_SENSE
1061 #define sd_send_scsi_MODE_SELECT ssd_send_scsi_MODE_SELECT
1062 #define sd_send_scsi_RDWR ssd_send_scsi_RDWR
1063 #define sd_send_scsi_LOG_SENSE ssd_send_scsi_LOG_SENSE
1064 #define sd_send_scsi_GET_EVENT_STATUS_NOTIFICATION \
1065 ssd_send_scsi_GET_EVENT_STATUS_NOTIFICATION
1066 #define sd_gesn_media_data_valid ssd_gesn_media_data_valid
1067 #define sd_alloc_rqs ssd_alloc_rqs
1068 #define sd_free_rqs ssd_free_rqs
1069 #define sd_dump_memory ssd_dump_memory
1070 #define sd_get_media_info_com ssd_get_media_info_com
1071 #define sd_get_media_info ssd_get_media_info
1072 #define sd_get_media_info_ext ssd_get_media_info_ext
1073 #define sd_dkio_ctrl_info ssd_dkio_ctrl_info
1074 #define sd_nvpair_str_decode ssd_nvpair_str_decode
1075 #define sd_strtok_r ssd_strtok_r
1076 #define sd_set_properties ssd_set_properties
1077 #define sd_get_tunables_from_conf ssd_get_tunables_from_conf
1078 #define sd_setup_next_xfer ssd_setup_next_xfer
1079 #define sd_dkio_get_temp ssd_dkio_get_temp
1080 #define sd_check_mhd ssd_check_mhd
1081 #define sd_mhd_watch_cb ssd_mhd_watch_cb
1082 #define sd_mhd_watch_incomplete ssd_mhd_watch_incomplete
1083 #define sd_sname ssd_sname
1084 #define sd_mhd_resvd_recover ssd_mhd_resvd_recover
1085 #define sd_resv_reclaim_thread ssd_resv_reclaim_thread
1086 #define sd_take_ownership ssd_take_ownership
1087 #define sd_reserve_release ssd_reserve_release
1088 #define sd_rmv_resv_reclaim_req ssd_rmv_resv_reclaim_req
1089 #define sd_mhd_reset_notify_cb ssd_mhd_reset_notify_cb
1090 #define sd_persistent_reservation_in_read_keys \
1091 ssd_persistent_reservation_in_read_keys
1092 #define sd_persistent_reservation_in_read_resv \
1093 ssd_persistent_reservation_in_read_resv
1094 #define sd_mhdioc_takeown ssd_mhdioc_takeown
1095 #define sd_mhdioc_failfast ssd_mhdioc_failfast
1096 #define sd_mhdioc_release ssd_mhdioc_release
1097 #define sd_mhdioc_register_devid ssd_mhdioc_register_devid
1098 #define sd_mhdioc_inkeys ssd_mhdioc_inkeys
1099 #define sd_mhdioc_inresv ssd_mhdioc_inresv
1100 #define sr_change_blkmode ssr_change_blkmode
1101 #define sr_change_speed ssr_change_speed
1102 #define sr_atapi_change_speed ssr_atapi_change_speed
1103 #define sr_pause_resume ssr_pause_resume
1104 #define sr_play_msf ssr_play_msf
1105 #define sr_play_trkind ssr_play_trkind
1106 #define sr_read_all_subcodes ssr_read_all_subcodes
1107 #define sr_read_subchannel ssr_read_subchannel
1108 #define sr_read_tocentry ssr_read_tocentry
1109 #define sr_read_tochdr ssr_read_tochdr
1110 #define sr_read_cdda ssr_read_cdda
1111 #define sr_read_cdxa ssr_read_cdxa
1112 #define sr_read_mode1 ssr_read_mode1
1113 #define sr_read_mode2 ssr_read_mode2
1114 #define sr_read_cd_mode2 ssr_read_cd_mode2
1115 #define sr_sector_mode ssr_sector_mode
1116 #define sr_eject ssr_eject
1117 #define sr_ejected ssr_ejected
1118 #define sr_check_wp ssr_check_wp
1119 #define sd_watch_request_submit ssd_watch_request_submit
1120 #define sd_check_media ssd_check_media
1121 #define sd_media_watch_cb ssd_media_watch_cb
1122 #define sd_delayed_cv_broadcast ssd_delayed_cv_broadcast
1123 #define sr_volume_ctrl ssr_volume_ctrl
1124 #define sr_read_sony_session_offset ssr_read_sony_session_offset
1125 #define sd_log_page_supported ssd_log_page_supported
1126 #define sd_check_for_writable_cd ssd_check_for_writable_cd
1127 #define sd_wm_cache_constructor ssd_wm_cache_constructor
1128 #define sd_wm_cache_destructor ssd_wm_cache_destructor
1129 #define sd_range_lock ssd_range_lock
1130 #define sd_get_range ssd_get_range
1131 #define sd_free_inlist_wmap ssd_free_inlist_wmap
1132 #define sd_range_unlock ssd_range_unlock
1133 #define sd_read_modify_write_task ssd_read_modify_write_task
1134 #define sddump_do_read_of_rmw ssddump_do_read_of_rmw
1135
1136 #define sd_iostart_chain ssd_iostart_chain
1137 #define sd_iodone_chain ssd_iodone_chain
1138 #define sd_initpkt_map ssd_initpkt_map
1139 #define sd_destroypkt_map ssd_destroypkt_map
1140 #define sd_chain_type_map ssd_chain_type_map
1141 #define sd_chain_index_map ssd_chain_index_map
1142
1143 #define sd_failfast_flushctl ssd_failfast_flushctl
1144 #define sd_failfast_flushq ssd_failfast_flushq
1145 #define sd_failfast_flushq_callback ssd_failfast_flushq_callback
1146
1147 #define sd_is_lsi ssd_is_lsi
1148 #define sd_tg_rdwr ssd_tg_rdwr
1149 #define sd_tg_getinfo ssd_tg_getinfo
1150 #define sd_rmw_msg_print_handler ssd_rmw_msg_print_handler
1151
1152 #endif /* #if (defined(__fibre)) */
1153
1154
1155 int _init(void);
1156 int _fini(void);
1157 int _info(struct modinfo *modinfop);
1158
1159 /*PRINTFLIKE3*/
1160 static void sd_log_trace(uint_t comp, struct sd_lun *un, const char *fmt, ...);
1161 /*PRINTFLIKE3*/
1162 static void sd_log_info(uint_t comp, struct sd_lun *un, const char *fmt, ...);
1163 /*PRINTFLIKE3*/
1164 static void sd_log_err(uint_t comp, struct sd_lun *un, const char *fmt, ...);
1165
1166 static int sdprobe(dev_info_t *devi);
1167 static int sdinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg,
1168 void **result);
1169 static int sd_prop_op(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op,
1170 int mod_flags, char *name, caddr_t valuep, int *lengthp);
1171
1172 /*
1173 * Smart probe for parallel scsi
1174 */
1175 static void sd_scsi_probe_cache_init(void);
1176 static void sd_scsi_probe_cache_fini(void);
1177 static void sd_scsi_clear_probe_cache(void);
1178 static int sd_scsi_probe_with_cache(struct scsi_device *devp, int (*fn)());
1179
1180 /*
1181 * Attached luns on target for parallel scsi
1182 */
1183 static void sd_scsi_target_lun_init(void);
1184 static void sd_scsi_target_lun_fini(void);
1185 static int sd_scsi_get_target_lun_count(dev_info_t *dip, int target);
1186 static void sd_scsi_update_lun_on_target(dev_info_t *dip, int target, int flag);
1187
1188 static int sd_spin_up_unit(sd_ssc_t *ssc);
1189
1190 /*
1191 * Using sd_ssc_init to establish sd_ssc_t struct
1192 * Using sd_ssc_send to send uscsi internal command
1193 * Using sd_ssc_fini to free sd_ssc_t struct
1194 */
1195 static sd_ssc_t *sd_ssc_init(struct sd_lun *un);
1196 static int sd_ssc_send(sd_ssc_t *ssc, struct uscsi_cmd *incmd,
1197 int flag, enum uio_seg dataspace, int path_flag);
1198 static void sd_ssc_fini(sd_ssc_t *ssc);
1199
1200 /*
1201 * Using sd_ssc_assessment to set correct type-of-assessment
1202 * Using sd_ssc_post to post ereport & system log
1203 * sd_ssc_post will call sd_ssc_print to print system log
1204 * sd_ssc_post will call sd_ssd_ereport_post to post ereport
1205 */
1206 static void sd_ssc_assessment(sd_ssc_t *ssc,
1207 enum sd_type_assessment tp_assess);
1208
1209 static void sd_ssc_post(sd_ssc_t *ssc, enum sd_driver_assessment sd_assess);
1210 static void sd_ssc_print(sd_ssc_t *ssc, int sd_severity);
1211 static void sd_ssc_ereport_post(sd_ssc_t *ssc,
1212 enum sd_driver_assessment drv_assess);
1213
1214 /*
1215 * Using sd_ssc_set_info to mark an un-decodable-data error.
1216 * Using sd_ssc_extract_info to transfer information from internal
1217 * data structures to sd_ssc_t.
1218 */
1219 static void sd_ssc_set_info(sd_ssc_t *ssc, int ssc_flags, uint_t comp,
1220 const char *fmt, ...);
1221 static void sd_ssc_extract_info(sd_ssc_t *ssc, struct sd_lun *un,
1222 struct scsi_pkt *pktp, struct buf *bp, struct sd_xbuf *xp);
1223
1224 static int sd_send_scsi_cmd(dev_t dev, struct uscsi_cmd *incmd, int flag,
1225 enum uio_seg dataspace, int path_flag);
1226
1227 #ifdef _LP64
1228 static void sd_enable_descr_sense(sd_ssc_t *ssc);
1229 static void sd_reenable_dsense_task(void *arg);
1230 #endif /* _LP64 */
1231
1232 static void sd_set_mmc_caps(sd_ssc_t *ssc);
1233
1234 static void sd_read_unit_properties(struct sd_lun *un);
1235 static int sd_process_sdconf_file(struct sd_lun *un);
1236 static void sd_nvpair_str_decode(struct sd_lun *un, char *nvpair_str);
1237 static char *sd_strtok_r(char *string, const char *sepset, char **lasts);
1238 static void sd_set_properties(struct sd_lun *un, char *name, char *value);
1239 static void sd_get_tunables_from_conf(struct sd_lun *un, int flags,
1240 int *data_list, sd_tunables *values);
1241 static void sd_process_sdconf_table(struct sd_lun *un);
1242 static int sd_sdconf_id_match(struct sd_lun *un, char *id, int idlen);
1243 static int sd_blank_cmp(struct sd_lun *un, char *id, int idlen);
1244 static int sd_chk_vers1_data(struct sd_lun *un, int flags, int *prop_list,
1245 int list_len, char *dataname_ptr);
1246 static void sd_set_vers1_properties(struct sd_lun *un, int flags,
1247 sd_tunables *prop_list);
1248
1249 static void sd_register_devid(sd_ssc_t *ssc, dev_info_t *devi,
1250 int reservation_flag);
1251 static int sd_get_devid(sd_ssc_t *ssc);
1252 static ddi_devid_t sd_create_devid(sd_ssc_t *ssc);
1253 static int sd_write_deviceid(sd_ssc_t *ssc);
1254 static int sd_check_vpd_page_support(sd_ssc_t *ssc);
1255
1256 static void sd_setup_pm(sd_ssc_t *ssc, dev_info_t *devi);
1257 static void sd_create_pm_components(dev_info_t *devi, struct sd_lun *un);
1258
1259 static int sd_ddi_suspend(dev_info_t *devi);
1260 static int sd_ddi_resume(dev_info_t *devi);
1261 static int sd_pm_state_change(struct sd_lun *un, int level, int flag);
1262 static int sdpower(dev_info_t *devi, int component, int level);
1263
1264 static int sdattach(dev_info_t *devi, ddi_attach_cmd_t cmd);
1265 static int sddetach(dev_info_t *devi, ddi_detach_cmd_t cmd);
1266 static int sd_unit_attach(dev_info_t *devi);
1267 static int sd_unit_detach(dev_info_t *devi);
1268
1269 static void sd_set_unit_attributes(struct sd_lun *un, dev_info_t *devi);
1270 static void sd_create_errstats(struct sd_lun *un, int instance);
1271 static void sd_set_errstats(struct sd_lun *un);
1272 static void sd_set_pstats(struct sd_lun *un);
1273
1274 static int sddump(dev_t dev, caddr_t addr, daddr_t blkno, int nblk);
1275 static int sd_scsi_poll(struct sd_lun *un, struct scsi_pkt *pkt);
1276 static int sd_send_polled_RQS(struct sd_lun *un);
1277 static int sd_ddi_scsi_poll(struct scsi_pkt *pkt);
1278
1279 #if (defined(__fibre))
1280 /*
1281 * Event callbacks (photon)
1282 */
1283 static void sd_init_event_callbacks(struct sd_lun *un);
1284 static void sd_event_callback(dev_info_t *, ddi_eventcookie_t, void *, void *);
1285 #endif
1286
1287 /*
1288 * Defines for sd_cache_control
1289 */
1290
1291 #define SD_CACHE_ENABLE 1
1292 #define SD_CACHE_DISABLE 0
1293 #define SD_CACHE_NOCHANGE -1
1294
1295 static int sd_cache_control(sd_ssc_t *ssc, int rcd_flag, int wce_flag);
1296 static int sd_get_write_cache_enabled(sd_ssc_t *ssc, int *is_enabled);
1297 static void sd_get_write_cache_changeable(sd_ssc_t *ssc, int *is_changeable);
1298 static void sd_get_nv_sup(sd_ssc_t *ssc);
1299 static dev_t sd_make_device(dev_info_t *devi);
1300 static void sd_check_bdc_vpd(sd_ssc_t *ssc);
1301 static void sd_check_emulation_mode(sd_ssc_t *ssc);
1302 static void sd_update_block_info(struct sd_lun *un, uint32_t lbasize,
1303 uint64_t capacity);
1304
1305 /*
1306 * Driver entry point functions.
1307 */
1308 static int sdopen(dev_t *dev_p, int flag, int otyp, cred_t *cred_p);
1309 static int sdclose(dev_t dev, int flag, int otyp, cred_t *cred_p);
1310 static int sd_ready_and_valid(sd_ssc_t *ssc, int part);
1311
1312 static void sdmin(struct buf *bp);
1313 static int sdread(dev_t dev, struct uio *uio, cred_t *cred_p);
1314 static int sdwrite(dev_t dev, struct uio *uio, cred_t *cred_p);
1315 static int sdaread(dev_t dev, struct aio_req *aio, cred_t *cred_p);
1316 static int sdawrite(dev_t dev, struct aio_req *aio, cred_t *cred_p);
1317
1318 static int sdstrategy(struct buf *bp);
1319 static int sdioctl(dev_t, int, intptr_t, int, cred_t *, int *);
1320
1321 /*
1322 * Function prototypes for layering functions in the iostart chain.
1323 */
1324 static void sd_mapblockaddr_iostart(int index, struct sd_lun *un,
1325 struct buf *bp);
1326 static void sd_mapblocksize_iostart(int index, struct sd_lun *un,
1327 struct buf *bp);
1328 static void sd_checksum_iostart(int index, struct sd_lun *un, struct buf *bp);
1329 static void sd_checksum_uscsi_iostart(int index, struct sd_lun *un,
1330 struct buf *bp);
1331 static void sd_pm_iostart(int index, struct sd_lun *un, struct buf *bp);
1332 static void sd_core_iostart(int index, struct sd_lun *un, struct buf *bp);
1333
1334 /*
1335 * Function prototypes for layering functions in the iodone chain.
1336 */
1337 static void sd_buf_iodone(int index, struct sd_lun *un, struct buf *bp);
1338 static void sd_uscsi_iodone(int index, struct sd_lun *un, struct buf *bp);
1339 static void sd_mapblockaddr_iodone(int index, struct sd_lun *un,
1340 struct buf *bp);
1341 static void sd_mapblocksize_iodone(int index, struct sd_lun *un,
1342 struct buf *bp);
1343 static void sd_checksum_iodone(int index, struct sd_lun *un, struct buf *bp);
1344 static void sd_checksum_uscsi_iodone(int index, struct sd_lun *un,
1345 struct buf *bp);
1346 static void sd_pm_iodone(int index, struct sd_lun *un, struct buf *bp);
1347
1348 /*
1349 * Prototypes for functions to support buf(9S) based IO.
1350 */
1351 static void sd_xbuf_strategy(struct buf *bp, ddi_xbuf_t xp, void *arg);
1352 static int sd_initpkt_for_buf(struct buf *, struct scsi_pkt **);
1353 static void sd_destroypkt_for_buf(struct buf *);
1354 static int sd_setup_rw_pkt(struct sd_lun *un, struct scsi_pkt **pktpp,
1355 struct buf *bp, int flags,
1356 int (*callback)(caddr_t), caddr_t callback_arg,
1357 diskaddr_t lba, uint32_t blockcount);
1358 static int sd_setup_next_rw_pkt(struct sd_lun *un, struct scsi_pkt *pktp,
1359 struct buf *bp, diskaddr_t lba, uint32_t blockcount);
1360
1361 /*
1362 * Prototypes for functions to support USCSI IO.
1363 */
1364 static int sd_uscsi_strategy(struct buf *bp);
1365 static int sd_initpkt_for_uscsi(struct buf *, struct scsi_pkt **);
1366 static void sd_destroypkt_for_uscsi(struct buf *);
1367
1368 static void sd_xbuf_init(struct sd_lun *un, struct buf *bp, struct sd_xbuf *xp,
1369 uchar_t chain_type, void *pktinfop);
1370
1371 static int sd_pm_entry(struct sd_lun *un);
1372 static void sd_pm_exit(struct sd_lun *un);
1373
1374 static void sd_pm_idletimeout_handler(void *arg);
1375
1376 /*
1377 * sd_core internal functions (used at the sd_core_io layer).
1378 */
1379 static void sd_add_buf_to_waitq(struct sd_lun *un, struct buf *bp);
1380 static void sdintr(struct scsi_pkt *pktp);
1381 static void sd_start_cmds(struct sd_lun *un, struct buf *immed_bp);
1382
1383 static int sd_send_scsi_cmd(dev_t dev, struct uscsi_cmd *incmd, int flag,
1384 enum uio_seg dataspace, int path_flag);
1385
1386 static struct buf *sd_bioclone_alloc(struct buf *bp, size_t datalen,
1387 daddr_t blkno, int (*func)(struct buf *));
1388 static struct buf *sd_shadow_buf_alloc(struct buf *bp, size_t datalen,
1389 uint_t bflags, daddr_t blkno, int (*func)(struct buf *));
1390 static void sd_bioclone_free(struct buf *bp);
1391 static void sd_shadow_buf_free(struct buf *bp);
1392
1393 static void sd_print_transport_rejected_message(struct sd_lun *un,
1394 struct sd_xbuf *xp, int code);
1395 static void sd_print_incomplete_msg(struct sd_lun *un, struct buf *bp,
1396 void *arg, int code);
1397 static void sd_print_sense_failed_msg(struct sd_lun *un, struct buf *bp,
1398 void *arg, int code);
1399 static void sd_print_cmd_incomplete_msg(struct sd_lun *un, struct buf *bp,
1400 void *arg, int code);
1401
1402 static void sd_retry_command(struct sd_lun *un, struct buf *bp,
1403 int retry_check_flag,
1404 void (*user_funcp)(struct sd_lun *un, struct buf *bp, void *argp,
1405 int c),
1406 void *user_arg, int failure_code, clock_t retry_delay,
1407 void (*statp)(kstat_io_t *));
1408
1409 static void sd_set_retry_bp(struct sd_lun *un, struct buf *bp,
1410 clock_t retry_delay, void (*statp)(kstat_io_t *));
1411
1412 static void sd_send_request_sense_command(struct sd_lun *un, struct buf *bp,
1413 struct scsi_pkt *pktp);
1414 static void sd_start_retry_command(void *arg);
1415 static void sd_start_direct_priority_command(void *arg);
1416 static void sd_return_failed_command(struct sd_lun *un, struct buf *bp,
1417 int errcode);
1418 static void sd_return_failed_command_no_restart(struct sd_lun *un,
1419 struct buf *bp, int errcode);
1420 static void sd_return_command(struct sd_lun *un, struct buf *bp);
1421 static void sd_sync_with_callback(struct sd_lun *un);
1422 static int sdrunout(caddr_t arg);
1423
1424 static void sd_mark_rqs_busy(struct sd_lun *un, struct buf *bp);
1425 static struct buf *sd_mark_rqs_idle(struct sd_lun *un, struct sd_xbuf *xp);
1426
1427 static void sd_reduce_throttle(struct sd_lun *un, int throttle_type);
1428 static void sd_restore_throttle(void *arg);
1429
1430 static void sd_init_cdb_limits(struct sd_lun *un);
1431
1432 static void sd_pkt_status_good(struct sd_lun *un, struct buf *bp,
1433 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1434
1435 /*
1436 * Error handling functions
1437 */
1438 static void sd_pkt_status_check_condition(struct sd_lun *un, struct buf *bp,
1439 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1440 static void sd_pkt_status_busy(struct sd_lun *un, struct buf *bp,
1441 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1442 static void sd_pkt_status_reservation_conflict(struct sd_lun *un,
1443 struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp);
1444 static void sd_pkt_status_qfull(struct sd_lun *un, struct buf *bp,
1445 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1446
1447 static void sd_handle_request_sense(struct sd_lun *un, struct buf *bp,
1448 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1449 static void sd_handle_auto_request_sense(struct sd_lun *un, struct buf *bp,
1450 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1451 static int sd_validate_sense_data(struct sd_lun *un, struct buf *bp,
1452 struct sd_xbuf *xp, size_t actual_len);
1453 static void sd_decode_sense(struct sd_lun *un, struct buf *bp,
1454 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1455
1456 static void sd_print_sense_msg(struct sd_lun *un, struct buf *bp,
1457 void *arg, int code);
1458
1459 static void sd_sense_key_no_sense(struct sd_lun *un, struct buf *bp,
1460 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1461 static void sd_sense_key_recoverable_error(struct sd_lun *un,
1462 uint8_t *sense_datap,
1463 struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp);
1464 static void sd_sense_key_not_ready(struct sd_lun *un,
1465 uint8_t *sense_datap,
1466 struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp);
1467 static void sd_sense_key_medium_or_hardware_error(struct sd_lun *un,
1468 uint8_t *sense_datap,
1469 struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp);
1470 static void sd_sense_key_illegal_request(struct sd_lun *un, struct buf *bp,
1471 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1472 static void sd_sense_key_unit_attention(struct sd_lun *un,
1473 uint8_t *sense_datap,
1474 struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp);
1475 static void sd_sense_key_fail_command(struct sd_lun *un, struct buf *bp,
1476 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1477 static void sd_sense_key_blank_check(struct sd_lun *un, struct buf *bp,
1478 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1479 static void sd_sense_key_aborted_command(struct sd_lun *un, struct buf *bp,
1480 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1481 static void sd_sense_key_default(struct sd_lun *un,
1482 uint8_t *sense_datap,
1483 struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp);
1484
1485 static void sd_print_retry_msg(struct sd_lun *un, struct buf *bp,
1486 void *arg, int flag);
1487
1488 static void sd_pkt_reason_cmd_incomplete(struct sd_lun *un, struct buf *bp,
1489 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1490 static void sd_pkt_reason_cmd_tran_err(struct sd_lun *un, struct buf *bp,
1491 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1492 static void sd_pkt_reason_cmd_reset(struct sd_lun *un, struct buf *bp,
1493 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1494 static void sd_pkt_reason_cmd_aborted(struct sd_lun *un, struct buf *bp,
1495 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1496 static void sd_pkt_reason_cmd_timeout(struct sd_lun *un, struct buf *bp,
1497 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1498 static void sd_pkt_reason_cmd_unx_bus_free(struct sd_lun *un, struct buf *bp,
1499 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1500 static void sd_pkt_reason_cmd_tag_reject(struct sd_lun *un, struct buf *bp,
1501 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1502 static void sd_pkt_reason_default(struct sd_lun *un, struct buf *bp,
1503 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1504
1505 static void sd_reset_target(struct sd_lun *un, struct scsi_pkt *pktp);
1506
1507 static void sd_start_stop_unit_callback(void *arg);
1508 static void sd_start_stop_unit_task(void *arg);
1509
1510 static void sd_taskq_create(void);
1511 static void sd_taskq_delete(void);
1512 static void sd_target_change_task(void *arg);
1513 static void sd_log_dev_status_event(struct sd_lun *un, char *esc, int km_flag);
1514 static void sd_log_lun_expansion_event(struct sd_lun *un, int km_flag);
1515 static void sd_log_eject_request_event(struct sd_lun *un, int km_flag);
1516 static void sd_media_change_task(void *arg);
1517
1518 static int sd_handle_mchange(struct sd_lun *un);
1519 static int sd_send_scsi_DOORLOCK(sd_ssc_t *ssc, int flag, int path_flag);
1520 static int sd_send_scsi_READ_CAPACITY(sd_ssc_t *ssc, uint64_t *capp,
1521 uint32_t *lbap, int path_flag);
1522 static int sd_send_scsi_READ_CAPACITY_16(sd_ssc_t *ssc, uint64_t *capp,
1523 uint32_t *lbap, uint32_t *psp, int path_flag);
1524 static int sd_send_scsi_START_STOP_UNIT(sd_ssc_t *ssc, int pc_flag,
1525 int flag, int path_flag);
1526 static int sd_send_scsi_INQUIRY(sd_ssc_t *ssc, uchar_t *bufaddr,
1527 size_t buflen, uchar_t evpd, uchar_t page_code, size_t *residp);
1528 static int sd_send_scsi_TEST_UNIT_READY(sd_ssc_t *ssc, int flag);
1529 static int sd_send_scsi_PERSISTENT_RESERVE_IN(sd_ssc_t *ssc,
1530 uchar_t usr_cmd, uint16_t data_len, uchar_t *data_bufp);
1531 static int sd_send_scsi_PERSISTENT_RESERVE_OUT(sd_ssc_t *ssc,
1532 uchar_t usr_cmd, uchar_t *usr_bufp);
1533 static int sd_send_scsi_SYNCHRONIZE_CACHE(struct sd_lun *un,
1534 struct dk_callback *dkc);
1535 static int sd_send_scsi_SYNCHRONIZE_CACHE_biodone(struct buf *bp);
1536 static int sd_send_scsi_GET_CONFIGURATION(sd_ssc_t *ssc,
1537 struct uscsi_cmd *ucmdbuf, uchar_t *rqbuf, uint_t rqbuflen,
1538 uchar_t *bufaddr, uint_t buflen, int path_flag);
1539 static int sd_send_scsi_feature_GET_CONFIGURATION(sd_ssc_t *ssc,
1540 struct uscsi_cmd *ucmdbuf, uchar_t *rqbuf, uint_t rqbuflen,
1541 uchar_t *bufaddr, uint_t buflen, char feature, int path_flag);
1542 static int sd_send_scsi_MODE_SENSE(sd_ssc_t *ssc, int cdbsize,
1543 uchar_t *bufaddr, size_t buflen, uchar_t page_code, int path_flag);
1544 static int sd_send_scsi_MODE_SELECT(sd_ssc_t *ssc, int cdbsize,
1545 uchar_t *bufaddr, size_t buflen, uchar_t save_page, int path_flag);
1546 static int sd_send_scsi_RDWR(sd_ssc_t *ssc, uchar_t cmd, void *bufaddr,
1547 size_t buflen, daddr_t start_block, int path_flag);
1548 #define sd_send_scsi_READ(ssc, bufaddr, buflen, start_block, path_flag) \
1549 sd_send_scsi_RDWR(ssc, SCMD_READ, bufaddr, buflen, start_block, \
1550 path_flag)
1551 #define sd_send_scsi_WRITE(ssc, bufaddr, buflen, start_block, path_flag)\
1552 sd_send_scsi_RDWR(ssc, SCMD_WRITE, bufaddr, buflen, start_block,\
1553 path_flag)
1554
1555 static int sd_send_scsi_LOG_SENSE(sd_ssc_t *ssc, uchar_t *bufaddr,
1556 uint16_t buflen, uchar_t page_code, uchar_t page_control,
1557 uint16_t param_ptr, int path_flag);
1558 static int sd_send_scsi_GET_EVENT_STATUS_NOTIFICATION(sd_ssc_t *ssc,
1559 uchar_t *bufaddr, size_t buflen, uchar_t class_req);
1560 static boolean_t sd_gesn_media_data_valid(uchar_t *data);
1561
1562 static int sd_alloc_rqs(struct scsi_device *devp, struct sd_lun *un);
1563 static void sd_free_rqs(struct sd_lun *un);
1564
1565 static void sd_dump_memory(struct sd_lun *un, uint_t comp, char *title,
1566 uchar_t *data, int len, int fmt);
1567 static void sd_panic_for_res_conflict(struct sd_lun *un);
1568
1569 /*
1570 * Disk Ioctl Function Prototypes
1571 */
1572 static int sd_get_media_info(dev_t dev, caddr_t arg, int flag);
1573 static int sd_get_media_info_ext(dev_t dev, caddr_t arg, int flag);
1574 static int sd_dkio_ctrl_info(dev_t dev, caddr_t arg, int flag);
1575 static int sd_dkio_get_temp(dev_t dev, caddr_t arg, int flag);
1576
1577 /*
1578 * Multi-host Ioctl Prototypes
1579 */
1580 static int sd_check_mhd(dev_t dev, int interval);
1581 static int sd_mhd_watch_cb(caddr_t arg, struct scsi_watch_result *resultp);
1582 static void sd_mhd_watch_incomplete(struct sd_lun *un, struct scsi_pkt *pkt);
1583 static char *sd_sname(uchar_t status);
1584 static void sd_mhd_resvd_recover(void *arg);
1585 static void sd_resv_reclaim_thread();
1586 static int sd_take_ownership(dev_t dev, struct mhioctkown *p);
1587 static int sd_reserve_release(dev_t dev, int cmd);
1588 static void sd_rmv_resv_reclaim_req(dev_t dev);
1589 static void sd_mhd_reset_notify_cb(caddr_t arg);
1590 static int sd_persistent_reservation_in_read_keys(struct sd_lun *un,
1591 mhioc_inkeys_t *usrp, int flag);
1592 static int sd_persistent_reservation_in_read_resv(struct sd_lun *un,
1593 mhioc_inresvs_t *usrp, int flag);
1594 static int sd_mhdioc_takeown(dev_t dev, caddr_t arg, int flag);
1595 static int sd_mhdioc_failfast(dev_t dev, caddr_t arg, int flag);
1596 static int sd_mhdioc_release(dev_t dev);
1597 static int sd_mhdioc_register_devid(dev_t dev);
1598 static int sd_mhdioc_inkeys(dev_t dev, caddr_t arg, int flag);
1599 static int sd_mhdioc_inresv(dev_t dev, caddr_t arg, int flag);
1600
1601 /*
1602 * SCSI removable prototypes
1603 */
1604 static int sr_change_blkmode(dev_t dev, int cmd, intptr_t data, int flag);
1605 static int sr_change_speed(dev_t dev, int cmd, intptr_t data, int flag);
1606 static int sr_atapi_change_speed(dev_t dev, int cmd, intptr_t data, int flag);
1607 static int sr_pause_resume(dev_t dev, int mode);
1608 static int sr_play_msf(dev_t dev, caddr_t data, int flag);
1609 static int sr_play_trkind(dev_t dev, caddr_t data, int flag);
1610 static int sr_read_all_subcodes(dev_t dev, caddr_t data, int flag);
1611 static int sr_read_subchannel(dev_t dev, caddr_t data, int flag);
1612 static int sr_read_tocentry(dev_t dev, caddr_t data, int flag);
1613 static int sr_read_tochdr(dev_t dev, caddr_t data, int flag);
1614 static int sr_read_cdda(dev_t dev, caddr_t data, int flag);
1615 static int sr_read_cdxa(dev_t dev, caddr_t data, int flag);
1616 static int sr_read_mode1(dev_t dev, caddr_t data, int flag);
1617 static int sr_read_mode2(dev_t dev, caddr_t data, int flag);
1618 static int sr_read_cd_mode2(dev_t dev, caddr_t data, int flag);
1619 static int sr_sector_mode(dev_t dev, uint32_t blksize);
1620 static int sr_eject(dev_t dev);
1621 static void sr_ejected(register struct sd_lun *un);
1622 static int sr_check_wp(dev_t dev);
1623 static opaque_t sd_watch_request_submit(struct sd_lun *un);
1624 static int sd_check_media(dev_t dev, enum dkio_state state);
1625 static int sd_media_watch_cb(caddr_t arg, struct scsi_watch_result *resultp);
1626 static void sd_delayed_cv_broadcast(void *arg);
1627 static int sr_volume_ctrl(dev_t dev, caddr_t data, int flag);
1628 static int sr_read_sony_session_offset(dev_t dev, caddr_t data, int flag);
1629
1630 static int sd_log_page_supported(sd_ssc_t *ssc, int log_page);
1631
1632 /*
1633 * Function Prototype for the non-512 support (DVDRAM, MO etc.) functions.
1634 */
1635 static void sd_check_for_writable_cd(sd_ssc_t *ssc, int path_flag);
1636 static int sd_wm_cache_constructor(void *wm, void *un, int flags);
1637 static void sd_wm_cache_destructor(void *wm, void *un);
1638 static struct sd_w_map *sd_range_lock(struct sd_lun *un, daddr_t startb,
1639 daddr_t endb, ushort_t typ);
1640 static struct sd_w_map *sd_get_range(struct sd_lun *un, daddr_t startb,
1641 daddr_t endb);
1642 static void sd_free_inlist_wmap(struct sd_lun *un, struct sd_w_map *wmp);
1643 static void sd_range_unlock(struct sd_lun *un, struct sd_w_map *wm);
1644 static void sd_read_modify_write_task(void * arg);
1645 static int
1646 sddump_do_read_of_rmw(struct sd_lun *un, uint64_t blkno, uint64_t nblk,
1647 struct buf **bpp);
1648
1649
1650 /*
1651 * Function prototypes for failfast support.
1652 */
1653 static void sd_failfast_flushq(struct sd_lun *un);
1654 static int sd_failfast_flushq_callback(struct buf *bp);
1655
1656 /*
1657 * Function prototypes to check for lsi devices
1658 */
1659 static void sd_is_lsi(struct sd_lun *un);
1660
1661 /*
1662 * Function prototypes for partial DMA support
1663 */
1664 static int sd_setup_next_xfer(struct sd_lun *un, struct buf *bp,
1665 struct scsi_pkt *pkt, struct sd_xbuf *xp);
1666
1667
1668 /* Function prototypes for cmlb */
1669 static int sd_tg_rdwr(dev_info_t *devi, uchar_t cmd, void *bufaddr,
1670 diskaddr_t start_block, size_t reqlength, void *tg_cookie);
1671
1672 static int sd_tg_getinfo(dev_info_t *devi, int cmd, void *arg, void *tg_cookie);
1673
1674 /*
1675 * For printing RMW warning message timely
1676 */
1677 static void sd_rmw_msg_print_handler(void *arg);
1678
1679 /*
1680 * Constants for failfast support:
1681 *
1682 * SD_FAILFAST_INACTIVE: Instance is currently in a normal state, with NO
1683 * failfast processing being performed.
1684 *
1685 * SD_FAILFAST_ACTIVE: Instance is in the failfast state and is performing
1686 * failfast processing on all bufs with B_FAILFAST set.
1687 */
1688
1689 #define SD_FAILFAST_INACTIVE 0
1690 #define SD_FAILFAST_ACTIVE 1
1691
1692 /*
1693 * Bitmask to control behavior of buf(9S) flushes when a transition to
1694 * the failfast state occurs. Optional bits include:
1695 *
1696 * SD_FAILFAST_FLUSH_ALL_BUFS: When set, flush ALL bufs including those that
1697 * do NOT have B_FAILFAST set. When clear, only bufs with B_FAILFAST will
1698 * be flushed.
1699 *
1700 * SD_FAILFAST_FLUSH_ALL_QUEUES: When set, flush any/all other queues in the
1701 * driver, in addition to the regular wait queue. This includes the xbuf
1702 * queues. When clear, only the driver's wait queue will be flushed.
1703 */
1704 #define SD_FAILFAST_FLUSH_ALL_BUFS 0x01
1705 #define SD_FAILFAST_FLUSH_ALL_QUEUES 0x02
1706
1707 /*
1708 * The default behavior is to only flush bufs that have B_FAILFAST set, but
1709 * to flush all queues within the driver.
1710 */
1711 static int sd_failfast_flushctl = SD_FAILFAST_FLUSH_ALL_QUEUES;
1712
1713
1714 /*
1715 * SD Testing Fault Injection
1716 */
1717 #ifdef SD_FAULT_INJECTION
1718 static void sd_faultinjection_ioctl(int cmd, intptr_t arg, struct sd_lun *un);
1719 static void sd_faultinjection(struct scsi_pkt *pktp);
1720 static void sd_injection_log(char *buf, struct sd_lun *un);
1721 #endif
1722
1723 /*
1724 * Device driver ops vector
1725 */
1726 static struct cb_ops sd_cb_ops = {
1727 sdopen, /* open */
1728 sdclose, /* close */
1729 sdstrategy, /* strategy */
1730 nodev, /* print */
1731 sddump, /* dump */
1732 sdread, /* read */
1733 sdwrite, /* write */
1734 sdioctl, /* ioctl */
1735 nodev, /* devmap */
1736 nodev, /* mmap */
1737 nodev, /* segmap */
1738 nochpoll, /* poll */
1739 sd_prop_op, /* cb_prop_op */
1740 0, /* streamtab */
1741 D_64BIT | D_MP | D_NEW | D_HOTPLUG, /* Driver compatibility flags */
1742 CB_REV, /* cb_rev */
1743 sdaread, /* async I/O read entry point */
1744 sdawrite /* async I/O write entry point */
1745 };
1746
1747 struct dev_ops sd_ops = {
1748 DEVO_REV, /* devo_rev, */
1749 0, /* refcnt */
1750 sdinfo, /* info */
1751 nulldev, /* identify */
1752 sdprobe, /* probe */
1753 sdattach, /* attach */
1754 sddetach, /* detach */
1755 nodev, /* reset */
1756 &sd_cb_ops, /* driver operations */
1757 NULL, /* bus operations */
1758 sdpower, /* power */
1759 ddi_quiesce_not_needed, /* quiesce */
1760 };
1761
1762 /*
1763 * This is the loadable module wrapper.
1764 */
1765 #include <sys/modctl.h>
1766
1767 static struct modldrv modldrv = {
1768 &mod_driverops, /* Type of module. This one is a driver */
1769 SD_MODULE_NAME, /* Module name. */
1770 &sd_ops /* driver ops */
1771 };
1772
1773 static struct modlinkage modlinkage = {
1774 MODREV_1, &modldrv, NULL
1775 };
1776
1777 static cmlb_tg_ops_t sd_tgops = {
1778 TG_DK_OPS_VERSION_1,
1779 sd_tg_rdwr,
1780 sd_tg_getinfo
1781 };
1782
1783 static struct scsi_asq_key_strings sd_additional_codes[] = {
1784 0x81, 0, "Logical Unit is Reserved",
1785 0x85, 0, "Audio Address Not Valid",
1786 0xb6, 0, "Media Load Mechanism Failed",
1787 0xB9, 0, "Audio Play Operation Aborted",
1788 0xbf, 0, "Buffer Overflow for Read All Subcodes Command",
1789 0x53, 2, "Medium removal prevented",
1790 0x6f, 0, "Authentication failed during key exchange",
1791 0x6f, 1, "Key not present",
1792 0x6f, 2, "Key not established",
1793 0x6f, 3, "Read without proper authentication",
1794 0x6f, 4, "Mismatched region to this logical unit",
1795 0x6f, 5, "Region reset count error",
1796 0xffff, 0x0, NULL
1797 };
1798
1799
1800 /*
1801 * Struct for passing printing information for sense data messages
1802 */
1803 struct sd_sense_info {
1804 int ssi_severity;
1805 int ssi_pfa_flag;
1806 };
1807
1808 /*
1809 * Table of function pointers for iostart-side routines. Separate "chains"
1810 * of layered function calls are formed by placing the function pointers
1811 * sequentially in the desired order. Functions are called according to an
1812 * incrementing table index ordering. The last function in each chain must
1813 * be sd_core_iostart(). The corresponding iodone-side routines are expected
1814 * in the sd_iodone_chain[] array.
1815 *
1816 * Note: It may seem more natural to organize both the iostart and iodone
1817 * functions together, into an array of structures (or some similar
1818 * organization) with a common index, rather than two separate arrays which
1819 * must be maintained in synchronization. The purpose of this division is
1820 * to achieve improved performance: individual arrays allows for more
1821 * effective cache line utilization on certain platforms.
1822 */
1823
1824 typedef void (*sd_chain_t)(int index, struct sd_lun *un, struct buf *bp);
1825
1826
1827 static sd_chain_t sd_iostart_chain[] = {
1828
1829 /* Chain for buf IO for disk drive targets (PM enabled) */
1830 sd_mapblockaddr_iostart, /* Index: 0 */
1831 sd_pm_iostart, /* Index: 1 */
1832 sd_core_iostart, /* Index: 2 */
1833
1834 /* Chain for buf IO for disk drive targets (PM disabled) */
1835 sd_mapblockaddr_iostart, /* Index: 3 */
1836 sd_core_iostart, /* Index: 4 */
1837
1838 /*
1839 * Chain for buf IO for removable-media or large sector size
1840 * disk drive targets with RMW needed (PM enabled)
1841 */
1842 sd_mapblockaddr_iostart, /* Index: 5 */
1843 sd_mapblocksize_iostart, /* Index: 6 */
1844 sd_pm_iostart, /* Index: 7 */
1845 sd_core_iostart, /* Index: 8 */
1846
1847 /*
1848 * Chain for buf IO for removable-media or large sector size
1849 * disk drive targets with RMW needed (PM disabled)
1850 */
1851 sd_mapblockaddr_iostart, /* Index: 9 */
1852 sd_mapblocksize_iostart, /* Index: 10 */
1853 sd_core_iostart, /* Index: 11 */
1854
1855 /* Chain for buf IO for disk drives with checksumming (PM enabled) */
1856 sd_mapblockaddr_iostart, /* Index: 12 */
1857 sd_checksum_iostart, /* Index: 13 */
1858 sd_pm_iostart, /* Index: 14 */
1859 sd_core_iostart, /* Index: 15 */
1860
1861 /* Chain for buf IO for disk drives with checksumming (PM disabled) */
1862 sd_mapblockaddr_iostart, /* Index: 16 */
1863 sd_checksum_iostart, /* Index: 17 */
1864 sd_core_iostart, /* Index: 18 */
1865
1866 /* Chain for USCSI commands (all targets) */
1867 sd_pm_iostart, /* Index: 19 */
1868 sd_core_iostart, /* Index: 20 */
1869
1870 /* Chain for checksumming USCSI commands (all targets) */
1871 sd_checksum_uscsi_iostart, /* Index: 21 */
1872 sd_pm_iostart, /* Index: 22 */
1873 sd_core_iostart, /* Index: 23 */
1874
1875 /* Chain for "direct" USCSI commands (all targets) */
1876 sd_core_iostart, /* Index: 24 */
1877
1878 /* Chain for "direct priority" USCSI commands (all targets) */
1879 sd_core_iostart, /* Index: 25 */
1880
1881 /*
1882 * Chain for buf IO for large sector size disk drive targets
1883 * with RMW needed with checksumming (PM enabled)
1884 */
1885 sd_mapblockaddr_iostart, /* Index: 26 */
1886 sd_mapblocksize_iostart, /* Index: 27 */
1887 sd_checksum_iostart, /* Index: 28 */
1888 sd_pm_iostart, /* Index: 29 */
1889 sd_core_iostart, /* Index: 30 */
1890
1891 /*
1892 * Chain for buf IO for large sector size disk drive targets
1893 * with RMW needed with checksumming (PM disabled)
1894 */
1895 sd_mapblockaddr_iostart, /* Index: 31 */
1896 sd_mapblocksize_iostart, /* Index: 32 */
1897 sd_checksum_iostart, /* Index: 33 */
1898 sd_core_iostart, /* Index: 34 */
1899
1900 };
1901
1902 /*
1903 * Macros to locate the first function of each iostart chain in the
1904 * sd_iostart_chain[] array. These are located by the index in the array.
1905 */
1906 #define SD_CHAIN_DISK_IOSTART 0
1907 #define SD_CHAIN_DISK_IOSTART_NO_PM 3
1908 #define SD_CHAIN_MSS_DISK_IOSTART 5
1909 #define SD_CHAIN_RMMEDIA_IOSTART 5
1910 #define SD_CHAIN_MSS_DISK_IOSTART_NO_PM 9
1911 #define SD_CHAIN_RMMEDIA_IOSTART_NO_PM 9
1912 #define SD_CHAIN_CHKSUM_IOSTART 12
1913 #define SD_CHAIN_CHKSUM_IOSTART_NO_PM 16
1914 #define SD_CHAIN_USCSI_CMD_IOSTART 19
1915 #define SD_CHAIN_USCSI_CHKSUM_IOSTART 21
1916 #define SD_CHAIN_DIRECT_CMD_IOSTART 24
1917 #define SD_CHAIN_PRIORITY_CMD_IOSTART 25
1918 #define SD_CHAIN_MSS_CHKSUM_IOSTART 26
1919 #define SD_CHAIN_MSS_CHKSUM_IOSTART_NO_PM 31
1920
1921
1922 /*
1923 * Table of function pointers for the iodone-side routines for the driver-
1924 * internal layering mechanism. The calling sequence for iodone routines
1925 * uses a decrementing table index, so the last routine called in a chain
1926 * must be at the lowest array index location for that chain. The last
1927 * routine for each chain must be either sd_buf_iodone() (for buf(9S) IOs)
1928 * or sd_uscsi_iodone() (for uscsi IOs). Other than this, the ordering
1929 * of the functions in an iodone side chain must correspond to the ordering
1930 * of the iostart routines for that chain. Note that there is no iodone
1931 * side routine that corresponds to sd_core_iostart(), so there is no
1932 * entry in the table for this.
1933 */
1934
1935 static sd_chain_t sd_iodone_chain[] = {
1936
1937 /* Chain for buf IO for disk drive targets (PM enabled) */
1938 sd_buf_iodone, /* Index: 0 */
1939 sd_mapblockaddr_iodone, /* Index: 1 */
1940 sd_pm_iodone, /* Index: 2 */
1941
1942 /* Chain for buf IO for disk drive targets (PM disabled) */
1943 sd_buf_iodone, /* Index: 3 */
1944 sd_mapblockaddr_iodone, /* Index: 4 */
1945
1946 /*
1947 * Chain for buf IO for removable-media or large sector size
1948 * disk drive targets with RMW needed (PM enabled)
1949 */
1950 sd_buf_iodone, /* Index: 5 */
1951 sd_mapblockaddr_iodone, /* Index: 6 */
1952 sd_mapblocksize_iodone, /* Index: 7 */
1953 sd_pm_iodone, /* Index: 8 */
1954
1955 /*
1956 * Chain for buf IO for removable-media or large sector size
1957 * disk drive targets with RMW needed (PM disabled)
1958 */
1959 sd_buf_iodone, /* Index: 9 */
1960 sd_mapblockaddr_iodone, /* Index: 10 */
1961 sd_mapblocksize_iodone, /* Index: 11 */
1962
1963 /* Chain for buf IO for disk drives with checksumming (PM enabled) */
1964 sd_buf_iodone, /* Index: 12 */
1965 sd_mapblockaddr_iodone, /* Index: 13 */
1966 sd_checksum_iodone, /* Index: 14 */
1967 sd_pm_iodone, /* Index: 15 */
1968
1969 /* Chain for buf IO for disk drives with checksumming (PM disabled) */
1970 sd_buf_iodone, /* Index: 16 */
1971 sd_mapblockaddr_iodone, /* Index: 17 */
1972 sd_checksum_iodone, /* Index: 18 */
1973
1974 /* Chain for USCSI commands (non-checksum targets) */
1975 sd_uscsi_iodone, /* Index: 19 */
1976 sd_pm_iodone, /* Index: 20 */
1977
1978 /* Chain for USCSI commands (checksum targets) */
1979 sd_uscsi_iodone, /* Index: 21 */
1980 sd_checksum_uscsi_iodone, /* Index: 22 */
1981 sd_pm_iodone, /* Index: 22 */
1982
1983 /* Chain for "direct" USCSI commands (all targets) */
1984 sd_uscsi_iodone, /* Index: 24 */
1985
1986 /* Chain for "direct priority" USCSI commands (all targets) */
1987 sd_uscsi_iodone, /* Index: 25 */
1988
1989 /*
1990 * Chain for buf IO for large sector size disk drive targets
1991 * with checksumming (PM enabled)
1992 */
1993 sd_buf_iodone, /* Index: 26 */
1994 sd_mapblockaddr_iodone, /* Index: 27 */
1995 sd_mapblocksize_iodone, /* Index: 28 */
1996 sd_checksum_iodone, /* Index: 29 */
1997 sd_pm_iodone, /* Index: 30 */
1998
1999 /*
2000 * Chain for buf IO for large sector size disk drive targets
2001 * with checksumming (PM disabled)
2002 */
2003 sd_buf_iodone, /* Index: 31 */
2004 sd_mapblockaddr_iodone, /* Index: 32 */
2005 sd_mapblocksize_iodone, /* Index: 33 */
2006 sd_checksum_iodone, /* Index: 34 */
2007 };
2008
2009
2010 /*
2011 * Macros to locate the "first" function in the sd_iodone_chain[] array for
2012 * each iodone-side chain. These are located by the array index, but as the
2013 * iodone side functions are called in a decrementing-index order, the
2014 * highest index number in each chain must be specified (as these correspond
2015 * to the first function in the iodone chain that will be called by the core
2016 * at IO completion time).
2017 */
2018
2019 #define SD_CHAIN_DISK_IODONE 2
2020 #define SD_CHAIN_DISK_IODONE_NO_PM 4
2021 #define SD_CHAIN_RMMEDIA_IODONE 8
2022 #define SD_CHAIN_MSS_DISK_IODONE 8
2023 #define SD_CHAIN_RMMEDIA_IODONE_NO_PM 11
2024 #define SD_CHAIN_MSS_DISK_IODONE_NO_PM 11
2025 #define SD_CHAIN_CHKSUM_IODONE 15
2026 #define SD_CHAIN_CHKSUM_IODONE_NO_PM 18
2027 #define SD_CHAIN_USCSI_CMD_IODONE 20
2028 #define SD_CHAIN_USCSI_CHKSUM_IODONE 22
2029 #define SD_CHAIN_DIRECT_CMD_IODONE 24
2030 #define SD_CHAIN_PRIORITY_CMD_IODONE 25
2031 #define SD_CHAIN_MSS_CHKSUM_IODONE 30
2032 #define SD_CHAIN_MSS_CHKSUM_IODONE_NO_PM 34
2033
2034
2035
2036 /*
2037 * Array to map a layering chain index to the appropriate initpkt routine.
2038 * The redundant entries are present so that the index used for accessing
2039 * the above sd_iostart_chain and sd_iodone_chain tables can be used directly
2040 * with this table as well.
2041 */
2042 typedef int (*sd_initpkt_t)(struct buf *, struct scsi_pkt **);
2043
2044 static sd_initpkt_t sd_initpkt_map[] = {
2045
2046 /* Chain for buf IO for disk drive targets (PM enabled) */
2047 sd_initpkt_for_buf, /* Index: 0 */
2048 sd_initpkt_for_buf, /* Index: 1 */
2049 sd_initpkt_for_buf, /* Index: 2 */
2050
2051 /* Chain for buf IO for disk drive targets (PM disabled) */
2052 sd_initpkt_for_buf, /* Index: 3 */
2053 sd_initpkt_for_buf, /* Index: 4 */
2054
2055 /*
2056 * Chain for buf IO for removable-media or large sector size
2057 * disk drive targets (PM enabled)
2058 */
2059 sd_initpkt_for_buf, /* Index: 5 */
2060 sd_initpkt_for_buf, /* Index: 6 */
2061 sd_initpkt_for_buf, /* Index: 7 */
2062 sd_initpkt_for_buf, /* Index: 8 */
2063
2064 /*
2065 * Chain for buf IO for removable-media or large sector size
2066 * disk drive targets (PM disabled)
2067 */
2068 sd_initpkt_for_buf, /* Index: 9 */
2069 sd_initpkt_for_buf, /* Index: 10 */
2070 sd_initpkt_for_buf, /* Index: 11 */
2071
2072 /* Chain for buf IO for disk drives with checksumming (PM enabled) */
2073 sd_initpkt_for_buf, /* Index: 12 */
2074 sd_initpkt_for_buf, /* Index: 13 */
2075 sd_initpkt_for_buf, /* Index: 14 */
2076 sd_initpkt_for_buf, /* Index: 15 */
2077
2078 /* Chain for buf IO for disk drives with checksumming (PM disabled) */
2079 sd_initpkt_for_buf, /* Index: 16 */
2080 sd_initpkt_for_buf, /* Index: 17 */
2081 sd_initpkt_for_buf, /* Index: 18 */
2082
2083 /* Chain for USCSI commands (non-checksum targets) */
2084 sd_initpkt_for_uscsi, /* Index: 19 */
2085 sd_initpkt_for_uscsi, /* Index: 20 */
2086
2087 /* Chain for USCSI commands (checksum targets) */
2088 sd_initpkt_for_uscsi, /* Index: 21 */
2089 sd_initpkt_for_uscsi, /* Index: 22 */
2090 sd_initpkt_for_uscsi, /* Index: 22 */
2091
2092 /* Chain for "direct" USCSI commands (all targets) */
2093 sd_initpkt_for_uscsi, /* Index: 24 */
2094
2095 /* Chain for "direct priority" USCSI commands (all targets) */
2096 sd_initpkt_for_uscsi, /* Index: 25 */
2097
2098 /*
2099 * Chain for buf IO for large sector size disk drive targets
2100 * with checksumming (PM enabled)
2101 */
2102 sd_initpkt_for_buf, /* Index: 26 */
2103 sd_initpkt_for_buf, /* Index: 27 */
2104 sd_initpkt_for_buf, /* Index: 28 */
2105 sd_initpkt_for_buf, /* Index: 29 */
2106 sd_initpkt_for_buf, /* Index: 30 */
2107
2108 /*
2109 * Chain for buf IO for large sector size disk drive targets
2110 * with checksumming (PM disabled)
2111 */
2112 sd_initpkt_for_buf, /* Index: 31 */
2113 sd_initpkt_for_buf, /* Index: 32 */
2114 sd_initpkt_for_buf, /* Index: 33 */
2115 sd_initpkt_for_buf, /* Index: 34 */
2116 };
2117
2118
2119 /*
2120 * Array to map a layering chain index to the appropriate destroypktpkt routine.
2121 * The redundant entries are present so that the index used for accessing
2122 * the above sd_iostart_chain and sd_iodone_chain tables can be used directly
2123 * with this table as well.
2124 */
2125 typedef void (*sd_destroypkt_t)(struct buf *);
2126
2127 static sd_destroypkt_t sd_destroypkt_map[] = {
2128
2129 /* Chain for buf IO for disk drive targets (PM enabled) */
2130 sd_destroypkt_for_buf, /* Index: 0 */
2131 sd_destroypkt_for_buf, /* Index: 1 */
2132 sd_destroypkt_for_buf, /* Index: 2 */
2133
2134 /* Chain for buf IO for disk drive targets (PM disabled) */
2135 sd_destroypkt_for_buf, /* Index: 3 */
2136 sd_destroypkt_for_buf, /* Index: 4 */
2137
2138 /*
2139 * Chain for buf IO for removable-media or large sector size
2140 * disk drive targets (PM enabled)
2141 */
2142 sd_destroypkt_for_buf, /* Index: 5 */
2143 sd_destroypkt_for_buf, /* Index: 6 */
2144 sd_destroypkt_for_buf, /* Index: 7 */
2145 sd_destroypkt_for_buf, /* Index: 8 */
2146
2147 /*
2148 * Chain for buf IO for removable-media or large sector size
2149 * disk drive targets (PM disabled)
2150 */
2151 sd_destroypkt_for_buf, /* Index: 9 */
2152 sd_destroypkt_for_buf, /* Index: 10 */
2153 sd_destroypkt_for_buf, /* Index: 11 */
2154
2155 /* Chain for buf IO for disk drives with checksumming (PM enabled) */
2156 sd_destroypkt_for_buf, /* Index: 12 */
2157 sd_destroypkt_for_buf, /* Index: 13 */
2158 sd_destroypkt_for_buf, /* Index: 14 */
2159 sd_destroypkt_for_buf, /* Index: 15 */
2160
2161 /* Chain for buf IO for disk drives with checksumming (PM disabled) */
2162 sd_destroypkt_for_buf, /* Index: 16 */
2163 sd_destroypkt_for_buf, /* Index: 17 */
2164 sd_destroypkt_for_buf, /* Index: 18 */
2165
2166 /* Chain for USCSI commands (non-checksum targets) */
2167 sd_destroypkt_for_uscsi, /* Index: 19 */
2168 sd_destroypkt_for_uscsi, /* Index: 20 */
2169
2170 /* Chain for USCSI commands (checksum targets) */
2171 sd_destroypkt_for_uscsi, /* Index: 21 */
2172 sd_destroypkt_for_uscsi, /* Index: 22 */
2173 sd_destroypkt_for_uscsi, /* Index: 22 */
2174
2175 /* Chain for "direct" USCSI commands (all targets) */
2176 sd_destroypkt_for_uscsi, /* Index: 24 */
2177
2178 /* Chain for "direct priority" USCSI commands (all targets) */
2179 sd_destroypkt_for_uscsi, /* Index: 25 */
2180
2181 /*
2182 * Chain for buf IO for large sector size disk drive targets
2183 * with checksumming (PM disabled)
2184 */
2185 sd_destroypkt_for_buf, /* Index: 26 */
2186 sd_destroypkt_for_buf, /* Index: 27 */
2187 sd_destroypkt_for_buf, /* Index: 28 */
2188 sd_destroypkt_for_buf, /* Index: 29 */
2189 sd_destroypkt_for_buf, /* Index: 30 */
2190
2191 /*
2192 * Chain for buf IO for large sector size disk drive targets
2193 * with checksumming (PM enabled)
2194 */
2195 sd_destroypkt_for_buf, /* Index: 31 */
2196 sd_destroypkt_for_buf, /* Index: 32 */
2197 sd_destroypkt_for_buf, /* Index: 33 */
2198 sd_destroypkt_for_buf, /* Index: 34 */
2199 };
2200
2201
2202
2203 /*
2204 * Array to map a layering chain index to the appropriate chain "type".
2205 * The chain type indicates a specific property/usage of the chain.
2206 * The redundant entries are present so that the index used for accessing
2207 * the above sd_iostart_chain and sd_iodone_chain tables can be used directly
2208 * with this table as well.
2209 */
2210
2211 #define SD_CHAIN_NULL 0 /* for the special RQS cmd */
2212 #define SD_CHAIN_BUFIO 1 /* regular buf IO */
2213 #define SD_CHAIN_USCSI 2 /* regular USCSI commands */
2214 #define SD_CHAIN_DIRECT 3 /* uscsi, w/ bypass power mgt */
2215 #define SD_CHAIN_DIRECT_PRIORITY 4 /* uscsi, w/ bypass power mgt */
2216 /* (for error recovery) */
2217
2218 static int sd_chain_type_map[] = {
2219
2220 /* Chain for buf IO for disk drive targets (PM enabled) */
2221 SD_CHAIN_BUFIO, /* Index: 0 */
2222 SD_CHAIN_BUFIO, /* Index: 1 */
2223 SD_CHAIN_BUFIO, /* Index: 2 */
2224
2225 /* Chain for buf IO for disk drive targets (PM disabled) */
2226 SD_CHAIN_BUFIO, /* Index: 3 */
2227 SD_CHAIN_BUFIO, /* Index: 4 */
2228
2229 /*
2230 * Chain for buf IO for removable-media or large sector size
2231 * disk drive targets (PM enabled)
2232 */
2233 SD_CHAIN_BUFIO, /* Index: 5 */
2234 SD_CHAIN_BUFIO, /* Index: 6 */
2235 SD_CHAIN_BUFIO, /* Index: 7 */
2236 SD_CHAIN_BUFIO, /* Index: 8 */
2237
2238 /*
2239 * Chain for buf IO for removable-media or large sector size
2240 * disk drive targets (PM disabled)
2241 */
2242 SD_CHAIN_BUFIO, /* Index: 9 */
2243 SD_CHAIN_BUFIO, /* Index: 10 */
2244 SD_CHAIN_BUFIO, /* Index: 11 */
2245
2246 /* Chain for buf IO for disk drives with checksumming (PM enabled) */
2247 SD_CHAIN_BUFIO, /* Index: 12 */
2248 SD_CHAIN_BUFIO, /* Index: 13 */
2249 SD_CHAIN_BUFIO, /* Index: 14 */
2250 SD_CHAIN_BUFIO, /* Index: 15 */
2251
2252 /* Chain for buf IO for disk drives with checksumming (PM disabled) */
2253 SD_CHAIN_BUFIO, /* Index: 16 */
2254 SD_CHAIN_BUFIO, /* Index: 17 */
2255 SD_CHAIN_BUFIO, /* Index: 18 */
2256
2257 /* Chain for USCSI commands (non-checksum targets) */
2258 SD_CHAIN_USCSI, /* Index: 19 */
2259 SD_CHAIN_USCSI, /* Index: 20 */
2260
2261 /* Chain for USCSI commands (checksum targets) */
2262 SD_CHAIN_USCSI, /* Index: 21 */
2263 SD_CHAIN_USCSI, /* Index: 22 */
2264 SD_CHAIN_USCSI, /* Index: 23 */
2265
2266 /* Chain for "direct" USCSI commands (all targets) */
2267 SD_CHAIN_DIRECT, /* Index: 24 */
2268
2269 /* Chain for "direct priority" USCSI commands (all targets) */
2270 SD_CHAIN_DIRECT_PRIORITY, /* Index: 25 */
2271
2272 /*
2273 * Chain for buf IO for large sector size disk drive targets
2274 * with checksumming (PM enabled)
2275 */
2276 SD_CHAIN_BUFIO, /* Index: 26 */
2277 SD_CHAIN_BUFIO, /* Index: 27 */
2278 SD_CHAIN_BUFIO, /* Index: 28 */
2279 SD_CHAIN_BUFIO, /* Index: 29 */
2280 SD_CHAIN_BUFIO, /* Index: 30 */
2281
2282 /*
2283 * Chain for buf IO for large sector size disk drive targets
2284 * with checksumming (PM disabled)
2285 */
2286 SD_CHAIN_BUFIO, /* Index: 31 */
2287 SD_CHAIN_BUFIO, /* Index: 32 */
2288 SD_CHAIN_BUFIO, /* Index: 33 */
2289 SD_CHAIN_BUFIO, /* Index: 34 */
2290 };
2291
2292
2293 /* Macro to return TRUE if the IO has come from the sd_buf_iostart() chain. */
2294 #define SD_IS_BUFIO(xp) \
2295 (sd_chain_type_map[(xp)->xb_chain_iostart] == SD_CHAIN_BUFIO)
2296
2297 /* Macro to return TRUE if the IO has come from the "direct priority" chain. */
2298 #define SD_IS_DIRECT_PRIORITY(xp) \
2299 (sd_chain_type_map[(xp)->xb_chain_iostart] == SD_CHAIN_DIRECT_PRIORITY)
2300
2301
2302
2303 /*
2304 * Struct, array, and macros to map a specific chain to the appropriate
2305 * layering indexes in the sd_iostart_chain[] and sd_iodone_chain[] arrays.
2306 *
2307 * The sd_chain_index_map[] array is used at attach time to set the various
2308 * un_xxx_chain type members of the sd_lun softstate to the specific layering
2309 * chain to be used with the instance. This allows different instances to use
2310 * different chain for buf IO, uscsi IO, etc.. Also, since the xb_chain_iostart
2311 * and xb_chain_iodone index values in the sd_xbuf are initialized to these
2312 * values at sd_xbuf init time, this allows (1) layering chains may be changed
2313 * dynamically & without the use of locking; and (2) a layer may update the
2314 * xb_chain_io[start|done] member in a given xbuf with its current index value,
2315 * to allow for deferred processing of an IO within the same chain from a
2316 * different execution context.
2317 */
2318
2319 struct sd_chain_index {
2320 int sci_iostart_index;
2321 int sci_iodone_index;
2322 };
2323
2324 static struct sd_chain_index sd_chain_index_map[] = {
2325 { SD_CHAIN_DISK_IOSTART, SD_CHAIN_DISK_IODONE },
2326 { SD_CHAIN_DISK_IOSTART_NO_PM, SD_CHAIN_DISK_IODONE_NO_PM },
2327 { SD_CHAIN_RMMEDIA_IOSTART, SD_CHAIN_RMMEDIA_IODONE },
2328 { SD_CHAIN_RMMEDIA_IOSTART_NO_PM, SD_CHAIN_RMMEDIA_IODONE_NO_PM },
2329 { SD_CHAIN_CHKSUM_IOSTART, SD_CHAIN_CHKSUM_IODONE },
2330 { SD_CHAIN_CHKSUM_IOSTART_NO_PM, SD_CHAIN_CHKSUM_IODONE_NO_PM },
2331 { SD_CHAIN_USCSI_CMD_IOSTART, SD_CHAIN_USCSI_CMD_IODONE },
2332 { SD_CHAIN_USCSI_CHKSUM_IOSTART, SD_CHAIN_USCSI_CHKSUM_IODONE },
2333 { SD_CHAIN_DIRECT_CMD_IOSTART, SD_CHAIN_DIRECT_CMD_IODONE },
2334 { SD_CHAIN_PRIORITY_CMD_IOSTART, SD_CHAIN_PRIORITY_CMD_IODONE },
2335 { SD_CHAIN_MSS_CHKSUM_IOSTART, SD_CHAIN_MSS_CHKSUM_IODONE },
2336 { SD_CHAIN_MSS_CHKSUM_IOSTART_NO_PM, SD_CHAIN_MSS_CHKSUM_IODONE_NO_PM },
2337
2338 };
2339
2340
2341 /*
2342 * The following are indexes into the sd_chain_index_map[] array.
2343 */
2344
2345 /* un->un_buf_chain_type must be set to one of these */
2346 #define SD_CHAIN_INFO_DISK 0
2347 #define SD_CHAIN_INFO_DISK_NO_PM 1
2348 #define SD_CHAIN_INFO_RMMEDIA 2
2349 #define SD_CHAIN_INFO_MSS_DISK 2
2350 #define SD_CHAIN_INFO_RMMEDIA_NO_PM 3
2351 #define SD_CHAIN_INFO_MSS_DSK_NO_PM 3
2352 #define SD_CHAIN_INFO_CHKSUM 4
2353 #define SD_CHAIN_INFO_CHKSUM_NO_PM 5
2354 #define SD_CHAIN_INFO_MSS_DISK_CHKSUM 10
2355 #define SD_CHAIN_INFO_MSS_DISK_CHKSUM_NO_PM 11
2356
2357 /* un->un_uscsi_chain_type must be set to one of these */
2358 #define SD_CHAIN_INFO_USCSI_CMD 6
2359 /* USCSI with PM disabled is the same as DIRECT */
2360 #define SD_CHAIN_INFO_USCSI_CMD_NO_PM 8
2361 #define SD_CHAIN_INFO_USCSI_CHKSUM 7
2362
2363 /* un->un_direct_chain_type must be set to one of these */
2364 #define SD_CHAIN_INFO_DIRECT_CMD 8
2365
2366 /* un->un_priority_chain_type must be set to one of these */
2367 #define SD_CHAIN_INFO_PRIORITY_CMD 9
2368
2369 /* size for devid inquiries */
2370 #define MAX_INQUIRY_SIZE 0xF0
2371
2372 /*
2373 * Macros used by functions to pass a given buf(9S) struct along to the
2374 * next function in the layering chain for further processing.
2375 *
2376 * In the following macros, passing more than three arguments to the called
2377 * routines causes the optimizer for the SPARC compiler to stop doing tail
2378 * call elimination which results in significant performance degradation.
2379 */
2380 #define SD_BEGIN_IOSTART(index, un, bp) \
2381 ((*(sd_iostart_chain[index]))(index, un, bp))
2382
2383 #define SD_BEGIN_IODONE(index, un, bp) \
2384 ((*(sd_iodone_chain[index]))(index, un, bp))
2385
2386 #define SD_NEXT_IOSTART(index, un, bp) \
2387 ((*(sd_iostart_chain[(index) + 1]))((index) + 1, un, bp))
2388
2389 #define SD_NEXT_IODONE(index, un, bp) \
2390 ((*(sd_iodone_chain[(index) - 1]))((index) - 1, un, bp))
2391
2392 /*
2393 * Function: _init
2394 *
2395 * Description: This is the driver _init(9E) entry point.
2396 *
2397 * Return Code: Returns the value from mod_install(9F) or
2398 * ddi_soft_state_init(9F) as appropriate.
2399 *
2400 * Context: Called when driver module loaded.
2401 */
2402
2403 int
2404 _init(void)
2405 {
2406 int err;
2407
2408 /* establish driver name from module name */
2409 sd_label = (char *)mod_modname(&modlinkage);
2410
2411 err = ddi_soft_state_init(&sd_state, sizeof (struct sd_lun),
2412 SD_MAXUNIT);
2413 if (err != 0) {
2414 return (err);
2415 }
2416
2417 mutex_init(&sd_detach_mutex, NULL, MUTEX_DRIVER, NULL);
2418 mutex_init(&sd_log_mutex, NULL, MUTEX_DRIVER, NULL);
2419 mutex_init(&sd_label_mutex, NULL, MUTEX_DRIVER, NULL);
2420
2421 mutex_init(&sd_tr.srq_resv_reclaim_mutex, NULL, MUTEX_DRIVER, NULL);
2422 cv_init(&sd_tr.srq_resv_reclaim_cv, NULL, CV_DRIVER, NULL);
2423 cv_init(&sd_tr.srq_inprocess_cv, NULL, CV_DRIVER, NULL);
2424
2425 /*
2426 * it's ok to init here even for fibre device
2427 */
2428 sd_scsi_probe_cache_init();
2429
2430 sd_scsi_target_lun_init();
2431
2432 /*
2433 * Creating taskq before mod_install ensures that all callers (threads)
2434 * that enter the module after a successful mod_install encounter
2435 * a valid taskq.
2436 */
2437 sd_taskq_create();
2438
2439 err = mod_install(&modlinkage);
2440 if (err != 0) {
2441 /* delete taskq if install fails */
2442 sd_taskq_delete();
2443
2444 mutex_destroy(&sd_detach_mutex);
2445 mutex_destroy(&sd_log_mutex);
2446 mutex_destroy(&sd_label_mutex);
2447
2448 mutex_destroy(&sd_tr.srq_resv_reclaim_mutex);
2449 cv_destroy(&sd_tr.srq_resv_reclaim_cv);
2450 cv_destroy(&sd_tr.srq_inprocess_cv);
2451
2452 sd_scsi_probe_cache_fini();
2453
2454 sd_scsi_target_lun_fini();
2455
2456 ddi_soft_state_fini(&sd_state);
2457
2458 return (err);
2459 }
2460
2461 return (err);
2462 }
2463
2464
2465 /*
2466 * Function: _fini
2467 *
2468 * Description: This is the driver _fini(9E) entry point.
2469 *
2470 * Return Code: Returns the value from mod_remove(9F)
2471 *
2472 * Context: Called when driver module is unloaded.
2473 */
2474
2475 int
2476 _fini(void)
2477 {
2478 int err;
2479
2480 if ((err = mod_remove(&modlinkage)) != 0) {
2481 return (err);
2482 }
2483
2484 sd_taskq_delete();
2485
2486 mutex_destroy(&sd_detach_mutex);
2487 mutex_destroy(&sd_log_mutex);
2488 mutex_destroy(&sd_label_mutex);
2489 mutex_destroy(&sd_tr.srq_resv_reclaim_mutex);
2490
2491 sd_scsi_probe_cache_fini();
2492
2493 sd_scsi_target_lun_fini();
2494
2495 cv_destroy(&sd_tr.srq_resv_reclaim_cv);
2496 cv_destroy(&sd_tr.srq_inprocess_cv);
2497
2498 ddi_soft_state_fini(&sd_state);
2499
2500 return (err);
2501 }
2502
2503
2504 /*
2505 * Function: _info
2506 *
2507 * Description: This is the driver _info(9E) entry point.
2508 *
2509 * Arguments: modinfop - pointer to the driver modinfo structure
2510 *
2511 * Return Code: Returns the value from mod_info(9F).
2512 *
2513 * Context: Kernel thread context
2514 */
2515
2516 int
2517 _info(struct modinfo *modinfop)
2518 {
2519 return (mod_info(&modlinkage, modinfop));
2520 }
2521
2522
2523 /*
2524 * The following routines implement the driver message logging facility.
2525 * They provide component- and level- based debug output filtering.
2526 * Output may also be restricted to messages for a single instance by
2527 * specifying a soft state pointer in sd_debug_un. If sd_debug_un is set
2528 * to NULL, then messages for all instances are printed.
2529 *
2530 * These routines have been cloned from each other due to the language
2531 * constraints of macros and variable argument list processing.
2532 */
2533
2534
2535 /*
2536 * Function: sd_log_err
2537 *
2538 * Description: This routine is called by the SD_ERROR macro for debug
2539 * logging of error conditions.
2540 *
2541 * Arguments: comp - driver component being logged
2542 * dev - pointer to driver info structure
2543 * fmt - error string and format to be logged
2544 */
2545
2546 static void
2547 sd_log_err(uint_t comp, struct sd_lun *un, const char *fmt, ...)
2548 {
2549 va_list ap;
2550 dev_info_t *dev;
2551
2552 ASSERT(un != NULL);
2553 dev = SD_DEVINFO(un);
2554 ASSERT(dev != NULL);
2555
2556 /*
2557 * Filter messages based on the global component and level masks.
2558 * Also print if un matches the value of sd_debug_un, or if
2559 * sd_debug_un is set to NULL.
2560 */
2561 if ((sd_component_mask & comp) && (sd_level_mask & SD_LOGMASK_ERROR) &&
2562 ((sd_debug_un == NULL) || (sd_debug_un == un))) {
2563 mutex_enter(&sd_log_mutex);
2564 va_start(ap, fmt);
2565 (void) vsprintf(sd_log_buf, fmt, ap);
2566 va_end(ap);
2567 scsi_log(dev, sd_label, CE_CONT, "%s", sd_log_buf);
2568 mutex_exit(&sd_log_mutex);
2569 }
2570 #ifdef SD_FAULT_INJECTION
2571 _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::sd_injection_mask));
2572 if (un->sd_injection_mask & comp) {
2573 mutex_enter(&sd_log_mutex);
2574 va_start(ap, fmt);
2575 (void) vsprintf(sd_log_buf, fmt, ap);
2576 va_end(ap);
2577 sd_injection_log(sd_log_buf, un);
2578 mutex_exit(&sd_log_mutex);
2579 }
2580 #endif
2581 }
2582
2583
2584 /*
2585 * Function: sd_log_info
2586 *
2587 * Description: This routine is called by the SD_INFO macro for debug
2588 * logging of general purpose informational conditions.
2589 *
2590 * Arguments: comp - driver component being logged
2591 * dev - pointer to driver info structure
2592 * fmt - info string and format to be logged
2593 */
2594
2595 static void
2596 sd_log_info(uint_t component, struct sd_lun *un, const char *fmt, ...)
2597 {
2598 va_list ap;
2599 dev_info_t *dev;
2600
2601 ASSERT(un != NULL);
2602 dev = SD_DEVINFO(un);
2603 ASSERT(dev != NULL);
2604
2605 /*
2606 * Filter messages based on the global component and level masks.
2607 * Also print if un matches the value of sd_debug_un, or if
2608 * sd_debug_un is set to NULL.
2609 */
2610 if ((sd_component_mask & component) &&
2611 (sd_level_mask & SD_LOGMASK_INFO) &&
2612 ((sd_debug_un == NULL) || (sd_debug_un == un))) {
2613 mutex_enter(&sd_log_mutex);
2614 va_start(ap, fmt);
2615 (void) vsprintf(sd_log_buf, fmt, ap);
2616 va_end(ap);
2617 scsi_log(dev, sd_label, CE_CONT, "%s", sd_log_buf);
2618 mutex_exit(&sd_log_mutex);
2619 }
2620 #ifdef SD_FAULT_INJECTION
2621 _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::sd_injection_mask));
2622 if (un->sd_injection_mask & component) {
2623 mutex_enter(&sd_log_mutex);
2624 va_start(ap, fmt);
2625 (void) vsprintf(sd_log_buf, fmt, ap);
2626 va_end(ap);
2627 sd_injection_log(sd_log_buf, un);
2628 mutex_exit(&sd_log_mutex);
2629 }
2630 #endif
2631 }
2632
2633
2634 /*
2635 * Function: sd_log_trace
2636 *
2637 * Description: This routine is called by the SD_TRACE macro for debug
2638 * logging of trace conditions (i.e. function entry/exit).
2639 *
2640 * Arguments: comp - driver component being logged
2641 * dev - pointer to driver info structure
2642 * fmt - trace string and format to be logged
2643 */
2644
2645 static void
2646 sd_log_trace(uint_t component, struct sd_lun *un, const char *fmt, ...)
2647 {
2648 va_list ap;
2649 dev_info_t *dev;
2650
2651 ASSERT(un != NULL);
2652 dev = SD_DEVINFO(un);
2653 ASSERT(dev != NULL);
2654
2655 /*
2656 * Filter messages based on the global component and level masks.
2657 * Also print if un matches the value of sd_debug_un, or if
2658 * sd_debug_un is set to NULL.
2659 */
2660 if ((sd_component_mask & component) &&
2661 (sd_level_mask & SD_LOGMASK_TRACE) &&
2662 ((sd_debug_un == NULL) || (sd_debug_un == un))) {
2663 mutex_enter(&sd_log_mutex);
2664 va_start(ap, fmt);
2665 (void) vsprintf(sd_log_buf, fmt, ap);
2666 va_end(ap);
2667 scsi_log(dev, sd_label, CE_CONT, "%s", sd_log_buf);
2668 mutex_exit(&sd_log_mutex);
2669 }
2670 #ifdef SD_FAULT_INJECTION
2671 _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::sd_injection_mask));
2672 if (un->sd_injection_mask & component) {
2673 mutex_enter(&sd_log_mutex);
2674 va_start(ap, fmt);
2675 (void) vsprintf(sd_log_buf, fmt, ap);
2676 va_end(ap);
2677 sd_injection_log(sd_log_buf, un);
2678 mutex_exit(&sd_log_mutex);
2679 }
2680 #endif
2681 }
2682
2683
2684 /*
2685 * Function: sdprobe
2686 *
2687 * Description: This is the driver probe(9e) entry point function.
2688 *
2689 * Arguments: devi - opaque device info handle
2690 *
2691 * Return Code: DDI_PROBE_SUCCESS: If the probe was successful.
2692 * DDI_PROBE_FAILURE: If the probe failed.
2693 * DDI_PROBE_PARTIAL: If the instance is not present now,
2694 * but may be present in the future.
2695 */
2696
2697 static int
2698 sdprobe(dev_info_t *devi)
2699 {
2700 struct scsi_device *devp;
2701 int rval;
2702 int instance = ddi_get_instance(devi);
2703
2704 /*
2705 * if it wasn't for pln, sdprobe could actually be nulldev
2706 * in the "__fibre" case.
2707 */
2708 if (ddi_dev_is_sid(devi) == DDI_SUCCESS) {
2709 return (DDI_PROBE_DONTCARE);
2710 }
2711
2712 devp = ddi_get_driver_private(devi);
2713
2714 if (devp == NULL) {
2715 /* Ooops... nexus driver is mis-configured... */
2716 return (DDI_PROBE_FAILURE);
2717 }
2718
2719 if (ddi_get_soft_state(sd_state, instance) != NULL) {
2720 return (DDI_PROBE_PARTIAL);
2721 }
2722
2723 /*
2724 * Call the SCSA utility probe routine to see if we actually
2725 * have a target at this SCSI nexus.
2726 */
2727 switch (sd_scsi_probe_with_cache(devp, NULL_FUNC)) {
2728 case SCSIPROBE_EXISTS:
2729 switch (devp->sd_inq->inq_dtype) {
2730 case DTYPE_DIRECT:
2731 rval = DDI_PROBE_SUCCESS;
2732 break;
2733 case DTYPE_RODIRECT:
2734 /* CDs etc. Can be removable media */
2735 rval = DDI_PROBE_SUCCESS;
2736 break;
2737 case DTYPE_OPTICAL:
2738 /*
2739 * Rewritable optical driver HP115AA
2740 * Can also be removable media
2741 */
2742
2743 /*
2744 * Do not attempt to bind to DTYPE_OPTICAL if
2745 * pre solaris 9 sparc sd behavior is required
2746 *
2747 * If first time through and sd_dtype_optical_bind
2748 * has not been set in /etc/system check properties
2749 */
2750
2751 if (sd_dtype_optical_bind < 0) {
2752 sd_dtype_optical_bind = ddi_prop_get_int
2753 (DDI_DEV_T_ANY, devi, 0,
2754 "optical-device-bind", 1);
2755 }
2756
2757 if (sd_dtype_optical_bind == 0) {
2758 rval = DDI_PROBE_FAILURE;
2759 } else {
2760 rval = DDI_PROBE_SUCCESS;
2761 }
2762 break;
2763
2764 case DTYPE_NOTPRESENT:
2765 default:
2766 rval = DDI_PROBE_FAILURE;
2767 break;
2768 }
2769 break;
2770 default:
2771 rval = DDI_PROBE_PARTIAL;
2772 break;
2773 }
2774
2775 /*
2776 * This routine checks for resource allocation prior to freeing,
2777 * so it will take care of the "smart probing" case where a
2778 * scsi_probe() may or may not have been issued and will *not*
2779 * free previously-freed resources.
2780 */
2781 scsi_unprobe(devp);
2782 return (rval);
2783 }
2784
2785
2786 /*
2787 * Function: sdinfo
2788 *
2789 * Description: This is the driver getinfo(9e) entry point function.
2790 * Given the device number, return the devinfo pointer from
2791 * the scsi_device structure or the instance number
2792 * associated with the dev_t.
2793 *
2794 * Arguments: dip - pointer to device info structure
2795 * infocmd - command argument (DDI_INFO_DEVT2DEVINFO,
2796 * DDI_INFO_DEVT2INSTANCE)
2797 * arg - driver dev_t
2798 * resultp - user buffer for request response
2799 *
2800 * Return Code: DDI_SUCCESS
2801 * DDI_FAILURE
2802 */
2803 /* ARGSUSED */
2804 static int
2805 sdinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
2806 {
2807 struct sd_lun *un;
2808 dev_t dev;
2809 int instance;
2810 int error;
2811
2812 switch (infocmd) {
2813 case DDI_INFO_DEVT2DEVINFO:
2814 dev = (dev_t)arg;
2815 instance = SDUNIT(dev);
2816 if ((un = ddi_get_soft_state(sd_state, instance)) == NULL) {
2817 return (DDI_FAILURE);
2818 }
2819 *result = (void *) SD_DEVINFO(un);
2820 error = DDI_SUCCESS;
2821 break;
2822 case DDI_INFO_DEVT2INSTANCE:
2823 dev = (dev_t)arg;
2824 instance = SDUNIT(dev);
2825 *result = (void *)(uintptr_t)instance;
2826 error = DDI_SUCCESS;
2827 break;
2828 default:
2829 error = DDI_FAILURE;
2830 }
2831 return (error);
2832 }
2833
2834 /*
2835 * Function: sd_prop_op
2836 *
2837 * Description: This is the driver prop_op(9e) entry point function.
2838 * Return the number of blocks for the partition in question
2839 * or forward the request to the property facilities.
2840 *
2841 * Arguments: dev - device number
2842 * dip - pointer to device info structure
2843 * prop_op - property operator
2844 * mod_flags - DDI_PROP_DONTPASS, don't pass to parent
2845 * name - pointer to property name
2846 * valuep - pointer or address of the user buffer
2847 * lengthp - property length
2848 *
2849 * Return Code: DDI_PROP_SUCCESS
2850 * DDI_PROP_NOT_FOUND
2851 * DDI_PROP_UNDEFINED
2852 * DDI_PROP_NO_MEMORY
2853 * DDI_PROP_BUF_TOO_SMALL
2854 */
2855
2856 static int
2857 sd_prop_op(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op, int mod_flags,
2858 char *name, caddr_t valuep, int *lengthp)
2859 {
2860 struct sd_lun *un;
2861
2862 if ((un = ddi_get_soft_state(sd_state, ddi_get_instance(dip))) == NULL)
2863 return (ddi_prop_op(dev, dip, prop_op, mod_flags,
2864 name, valuep, lengthp));
2865
2866 return (cmlb_prop_op(un->un_cmlbhandle,
2867 dev, dip, prop_op, mod_flags, name, valuep, lengthp,
2868 SDPART(dev), (void *)SD_PATH_DIRECT));
2869 }
2870
2871 /*
2872 * The following functions are for smart probing:
2873 * sd_scsi_probe_cache_init()
2874 * sd_scsi_probe_cache_fini()
2875 * sd_scsi_clear_probe_cache()
2876 * sd_scsi_probe_with_cache()
2877 */
2878
2879 /*
2880 * Function: sd_scsi_probe_cache_init
2881 *
2882 * Description: Initializes the probe response cache mutex and head pointer.
2883 *
2884 * Context: Kernel thread context
2885 */
2886
2887 static void
2888 sd_scsi_probe_cache_init(void)
2889 {
2890 mutex_init(&sd_scsi_probe_cache_mutex, NULL, MUTEX_DRIVER, NULL);
2891 sd_scsi_probe_cache_head = NULL;
2892 }
2893
2894
2895 /*
2896 * Function: sd_scsi_probe_cache_fini
2897 *
2898 * Description: Frees all resources associated with the probe response cache.
2899 *
2900 * Context: Kernel thread context
2901 */
2902
2903 static void
2904 sd_scsi_probe_cache_fini(void)
2905 {
2906 struct sd_scsi_probe_cache *cp;
2907 struct sd_scsi_probe_cache *ncp;
2908
2909 /* Clean up our smart probing linked list */
2910 for (cp = sd_scsi_probe_cache_head; cp != NULL; cp = ncp) {
2911 ncp = cp->next;
2912 kmem_free(cp, sizeof (struct sd_scsi_probe_cache));
2913 }
2914 sd_scsi_probe_cache_head = NULL;
2915 mutex_destroy(&sd_scsi_probe_cache_mutex);
2916 }
2917
2918
2919 /*
2920 * Function: sd_scsi_clear_probe_cache
2921 *
2922 * Description: This routine clears the probe response cache. This is
2923 * done when open() returns ENXIO so that when deferred
2924 * attach is attempted (possibly after a device has been
2925 * turned on) we will retry the probe. Since we don't know
2926 * which target we failed to open, we just clear the
2927 * entire cache.
2928 *
2929 * Context: Kernel thread context
2930 */
2931
2932 static void
2933 sd_scsi_clear_probe_cache(void)
2934 {
2935 struct sd_scsi_probe_cache *cp;
2936 int i;
2937
2938 mutex_enter(&sd_scsi_probe_cache_mutex);
2939 for (cp = sd_scsi_probe_cache_head; cp != NULL; cp = cp->next) {
2940 /*
2941 * Reset all entries to SCSIPROBE_EXISTS. This will
2942 * force probing to be performed the next time
2943 * sd_scsi_probe_with_cache is called.
2944 */
2945 for (i = 0; i < NTARGETS_WIDE; i++) {
2946 cp->cache[i] = SCSIPROBE_EXISTS;
2947 }
2948 }
2949 mutex_exit(&sd_scsi_probe_cache_mutex);
2950 }
2951
2952
2953 /*
2954 * Function: sd_scsi_probe_with_cache
2955 *
2956 * Description: This routine implements support for a scsi device probe
2957 * with cache. The driver maintains a cache of the target
2958 * responses to scsi probes. If we get no response from a
2959 * target during a probe inquiry, we remember that, and we
2960 * avoid additional calls to scsi_probe on non-zero LUNs
2961 * on the same target until the cache is cleared. By doing
2962 * so we avoid the 1/4 sec selection timeout for nonzero
2963 * LUNs. lun0 of a target is always probed.
2964 *
2965 * Arguments: devp - Pointer to a scsi_device(9S) structure
2966 * waitfunc - indicates what the allocator routines should
2967 * do when resources are not available. This value
2968 * is passed on to scsi_probe() when that routine
2969 * is called.
2970 *
2971 * Return Code: SCSIPROBE_NORESP if a NORESP in probe response cache;
2972 * otherwise the value returned by scsi_probe(9F).
2973 *
2974 * Context: Kernel thread context
2975 */
2976
2977 static int
2978 sd_scsi_probe_with_cache(struct scsi_device *devp, int (*waitfn)())
2979 {
2980 struct sd_scsi_probe_cache *cp;
2981 dev_info_t *pdip = ddi_get_parent(devp->sd_dev);
2982 int lun, tgt;
2983
2984 lun = ddi_prop_get_int(DDI_DEV_T_ANY, devp->sd_dev, DDI_PROP_DONTPASS,
2985 SCSI_ADDR_PROP_LUN, 0);
2986 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, devp->sd_dev, DDI_PROP_DONTPASS,
2987 SCSI_ADDR_PROP_TARGET, -1);
2988
2989 /* Make sure caching enabled and target in range */
2990 if ((tgt < 0) || (tgt >= NTARGETS_WIDE)) {
2991 /* do it the old way (no cache) */
2992 return (scsi_probe(devp, waitfn));
2993 }
2994
2995 mutex_enter(&sd_scsi_probe_cache_mutex);
2996
2997 /* Find the cache for this scsi bus instance */
2998 for (cp = sd_scsi_probe_cache_head; cp != NULL; cp = cp->next) {
2999 if (cp->pdip == pdip) {
3000 break;
3001 }
3002 }
3003
3004 /* If we can't find a cache for this pdip, create one */
3005 if (cp == NULL) {
3006 int i;
3007
3008 cp = kmem_zalloc(sizeof (struct sd_scsi_probe_cache),
3009 KM_SLEEP);
3010 cp->pdip = pdip;
3011 cp->next = sd_scsi_probe_cache_head;
3012 sd_scsi_probe_cache_head = cp;
3013 for (i = 0; i < NTARGETS_WIDE; i++) {
3014 cp->cache[i] = SCSIPROBE_EXISTS;
3015 }
3016 }
3017
3018 mutex_exit(&sd_scsi_probe_cache_mutex);
3019
3020 /* Recompute the cache for this target if LUN zero */
3021 if (lun == 0) {
3022 cp->cache[tgt] = SCSIPROBE_EXISTS;
3023 }
3024
3025 /* Don't probe if cache remembers a NORESP from a previous LUN. */
3026 if (cp->cache[tgt] != SCSIPROBE_EXISTS) {
3027 return (SCSIPROBE_NORESP);
3028 }
3029
3030 /* Do the actual probe; save & return the result */
3031 return (cp->cache[tgt] = scsi_probe(devp, waitfn));
3032 }
3033
3034
3035 /*
3036 * Function: sd_scsi_target_lun_init
3037 *
3038 * Description: Initializes the attached lun chain mutex and head pointer.
3039 *
3040 * Context: Kernel thread context
3041 */
3042
3043 static void
3044 sd_scsi_target_lun_init(void)
3045 {
3046 mutex_init(&sd_scsi_target_lun_mutex, NULL, MUTEX_DRIVER, NULL);
3047 sd_scsi_target_lun_head = NULL;
3048 }
3049
3050
3051 /*
3052 * Function: sd_scsi_target_lun_fini
3053 *
3054 * Description: Frees all resources associated with the attached lun
3055 * chain
3056 *
3057 * Context: Kernel thread context
3058 */
3059
3060 static void
3061 sd_scsi_target_lun_fini(void)
3062 {
3063 struct sd_scsi_hba_tgt_lun *cp;
3064 struct sd_scsi_hba_tgt_lun *ncp;
3065
3066 for (cp = sd_scsi_target_lun_head; cp != NULL; cp = ncp) {
3067 ncp = cp->next;
3068 kmem_free(cp, sizeof (struct sd_scsi_hba_tgt_lun));
3069 }
3070 sd_scsi_target_lun_head = NULL;
3071 mutex_destroy(&sd_scsi_target_lun_mutex);
3072 }
3073
3074
3075 /*
3076 * Function: sd_scsi_get_target_lun_count
3077 *
3078 * Description: This routine will check in the attached lun chain to see
3079 * how many luns are attached on the required SCSI controller
3080 * and target. Currently, some capabilities like tagged queue
3081 * are supported per target based by HBA. So all luns in a
3082 * target have the same capabilities. Based on this assumption,
3083 * sd should only set these capabilities once per target. This
3084 * function is called when sd needs to decide how many luns
3085 * already attached on a target.
3086 *
3087 * Arguments: dip - Pointer to the system's dev_info_t for the SCSI
3088 * controller device.
3089 * target - The target ID on the controller's SCSI bus.
3090 *
3091 * Return Code: The number of luns attached on the required target and
3092 * controller.
3093 * -1 if target ID is not in parallel SCSI scope or the given
3094 * dip is not in the chain.
3095 *
3096 * Context: Kernel thread context
3097 */
3098
3099 static int
3100 sd_scsi_get_target_lun_count(dev_info_t *dip, int target)
3101 {
3102 struct sd_scsi_hba_tgt_lun *cp;
3103
3104 if ((target < 0) || (target >= NTARGETS_WIDE)) {
3105 return (-1);
3106 }
3107
3108 mutex_enter(&sd_scsi_target_lun_mutex);
3109
3110 for (cp = sd_scsi_target_lun_head; cp != NULL; cp = cp->next) {
3111 if (cp->pdip == dip) {
3112 break;
3113 }
3114 }
3115
3116 mutex_exit(&sd_scsi_target_lun_mutex);
3117
3118 if (cp == NULL) {
3119 return (-1);
3120 }
3121
3122 return (cp->nlun[target]);
3123 }
3124
3125
3126 /*
3127 * Function: sd_scsi_update_lun_on_target
3128 *
3129 * Description: This routine is used to update the attached lun chain when a
3130 * lun is attached or detached on a target.
3131 *
3132 * Arguments: dip - Pointer to the system's dev_info_t for the SCSI
3133 * controller device.
3134 * target - The target ID on the controller's SCSI bus.
3135 * flag - Indicate the lun is attached or detached.
3136 *
3137 * Context: Kernel thread context
3138 */
3139
3140 static void
3141 sd_scsi_update_lun_on_target(dev_info_t *dip, int target, int flag)
3142 {
3143 struct sd_scsi_hba_tgt_lun *cp;
3144
3145 mutex_enter(&sd_scsi_target_lun_mutex);
3146
3147 for (cp = sd_scsi_target_lun_head; cp != NULL; cp = cp->next) {
3148 if (cp->pdip == dip) {
3149 break;
3150 }
3151 }
3152
3153 if ((cp == NULL) && (flag == SD_SCSI_LUN_ATTACH)) {
3154 cp = kmem_zalloc(sizeof (struct sd_scsi_hba_tgt_lun),
3155 KM_SLEEP);
3156 cp->pdip = dip;
3157 cp->next = sd_scsi_target_lun_head;
3158 sd_scsi_target_lun_head = cp;
3159 }
3160
3161 mutex_exit(&sd_scsi_target_lun_mutex);
3162
3163 if (cp != NULL) {
3164 if (flag == SD_SCSI_LUN_ATTACH) {
3165 cp->nlun[target] ++;
3166 } else {
3167 cp->nlun[target] --;
3168 }
3169 }
3170 }
3171
3172
3173 /*
3174 * Function: sd_spin_up_unit
3175 *
3176 * Description: Issues the following commands to spin-up the device:
3177 * START STOP UNIT, and INQUIRY.
3178 *
3179 * Arguments: ssc - ssc contains pointer to driver soft state (unit)
3180 * structure for this target.
3181 *
3182 * Return Code: 0 - success
3183 * EIO - failure
3184 * EACCES - reservation conflict
3185 *
3186 * Context: Kernel thread context
3187 */
3188
3189 static int
3190 sd_spin_up_unit(sd_ssc_t *ssc)
3191 {
3192 size_t resid = 0;
3193 int has_conflict = FALSE;
3194 uchar_t *bufaddr;
3195 int status;
3196 struct sd_lun *un;
3197
3198 ASSERT(ssc != NULL);
3199 un = ssc->ssc_un;
3200 ASSERT(un != NULL);
3201
3202 /*
3203 * Send a throwaway START UNIT command.
3204 *
3205 * If we fail on this, we don't care presently what precisely
3206 * is wrong. EMC's arrays will also fail this with a check
3207 * condition (0x2/0x4/0x3) if the device is "inactive," but
3208 * we don't want to fail the attach because it may become
3209 * "active" later.
3210 * We don't know if power condition is supported or not at
3211 * this stage, use START STOP bit.
3212 */
3213 status = sd_send_scsi_START_STOP_UNIT(ssc, SD_START_STOP,
3214 SD_TARGET_START, SD_PATH_DIRECT);
3215
3216 if (status != 0) {
3217 if (status == EACCES)
3218 has_conflict = TRUE;
3219 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
3220 }
3221
3222 /*
3223 * Send another INQUIRY command to the target. This is necessary for
3224 * non-removable media direct access devices because their INQUIRY data
3225 * may not be fully qualified until they are spun up (perhaps via the
3226 * START command above). Note: This seems to be needed for some
3227 * legacy devices only.) The INQUIRY command should succeed even if a
3228 * Reservation Conflict is present.
3229 */
3230 bufaddr = kmem_zalloc(SUN_INQSIZE, KM_SLEEP);
3231
3232 if (sd_send_scsi_INQUIRY(ssc, bufaddr, SUN_INQSIZE, 0, 0, &resid)
3233 != 0) {
3234 kmem_free(bufaddr, SUN_INQSIZE);
3235 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
3236 return (EIO);
3237 }
3238
3239 /*
3240 * If we got enough INQUIRY data, copy it over the old INQUIRY data.
3241 * Note that this routine does not return a failure here even if the
3242 * INQUIRY command did not return any data. This is a legacy behavior.
3243 */
3244 if ((SUN_INQSIZE - resid) >= SUN_MIN_INQLEN) {
3245 bcopy(bufaddr, SD_INQUIRY(un), SUN_INQSIZE);
3246 }
3247
3248 kmem_free(bufaddr, SUN_INQSIZE);
3249
3250 /* If we hit a reservation conflict above, tell the caller. */
3251 if (has_conflict == TRUE) {
3252 return (EACCES);
3253 }
3254
3255 return (0);
3256 }
3257
3258 #ifdef _LP64
3259 /*
3260 * Function: sd_enable_descr_sense
3261 *
3262 * Description: This routine attempts to select descriptor sense format
3263 * using the Control mode page. Devices that support 64 bit
3264 * LBAs (for >2TB luns) should also implement descriptor
3265 * sense data so we will call this function whenever we see
3266 * a lun larger than 2TB. If for some reason the device
3267 * supports 64 bit LBAs but doesn't support descriptor sense
3268 * presumably the mode select will fail. Everything will
3269 * continue to work normally except that we will not get
3270 * complete sense data for commands that fail with an LBA
3271 * larger than 32 bits.
3272 *
3273 * Arguments: ssc - ssc contains pointer to driver soft state (unit)
3274 * structure for this target.
3275 *
3276 * Context: Kernel thread context only
3277 */
3278
3279 static void
3280 sd_enable_descr_sense(sd_ssc_t *ssc)
3281 {
3282 uchar_t *header;
3283 struct mode_control_scsi3 *ctrl_bufp;
3284 size_t buflen;
3285 size_t bd_len;
3286 int status;
3287 struct sd_lun *un;
3288
3289 ASSERT(ssc != NULL);
3290 un = ssc->ssc_un;
3291 ASSERT(un != NULL);
3292
3293 /*
3294 * Read MODE SENSE page 0xA, Control Mode Page
3295 */
3296 buflen = MODE_HEADER_LENGTH + MODE_BLK_DESC_LENGTH +
3297 sizeof (struct mode_control_scsi3);
3298 header = kmem_zalloc(buflen, KM_SLEEP);
3299
3300 status = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP0, header, buflen,
3301 MODEPAGE_CTRL_MODE, SD_PATH_DIRECT);
3302
3303 if (status != 0) {
3304 SD_ERROR(SD_LOG_COMMON, un,
3305 "sd_enable_descr_sense: mode sense ctrl page failed\n");
3306 goto eds_exit;
3307 }
3308
3309 /*
3310 * Determine size of Block Descriptors in order to locate
3311 * the mode page data. ATAPI devices return 0, SCSI devices
3312 * should return MODE_BLK_DESC_LENGTH.
3313 */
3314 bd_len = ((struct mode_header *)header)->bdesc_length;
3315
3316 /* Clear the mode data length field for MODE SELECT */
3317 ((struct mode_header *)header)->length = 0;
3318
3319 ctrl_bufp = (struct mode_control_scsi3 *)
3320 (header + MODE_HEADER_LENGTH + bd_len);
3321
3322 /*
3323 * If the page length is smaller than the expected value,
3324 * the target device doesn't support D_SENSE. Bail out here.
3325 */
3326 if (ctrl_bufp->mode_page.length <
3327 sizeof (struct mode_control_scsi3) - 2) {
3328 SD_ERROR(SD_LOG_COMMON, un,
3329 "sd_enable_descr_sense: enable D_SENSE failed\n");
3330 goto eds_exit;
3331 }
3332
3333 /*
3334 * Clear PS bit for MODE SELECT
3335 */
3336 ctrl_bufp->mode_page.ps = 0;
3337
3338 /*
3339 * Set D_SENSE to enable descriptor sense format.
3340 */
3341 ctrl_bufp->d_sense = 1;
3342
3343 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
3344
3345 /*
3346 * Use MODE SELECT to commit the change to the D_SENSE bit
3347 */
3348 status = sd_send_scsi_MODE_SELECT(ssc, CDB_GROUP0, header,
3349 buflen, SD_DONTSAVE_PAGE, SD_PATH_DIRECT);
3350
3351 if (status != 0) {
3352 SD_INFO(SD_LOG_COMMON, un,
3353 "sd_enable_descr_sense: mode select ctrl page failed\n");
3354 } else {
3355 kmem_free(header, buflen);
3356 return;
3357 }
3358
3359 eds_exit:
3360 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
3361 kmem_free(header, buflen);
3362 }
3363
3364 /*
3365 * Function: sd_reenable_dsense_task
3366 *
3367 * Description: Re-enable descriptor sense after device or bus reset
3368 *
3369 * Context: Executes in a taskq() thread context
3370 */
3371 static void
3372 sd_reenable_dsense_task(void *arg)
3373 {
3374 struct sd_lun *un = arg;
3375 sd_ssc_t *ssc;
3376
3377 ASSERT(un != NULL);
3378
3379 ssc = sd_ssc_init(un);
3380 sd_enable_descr_sense(ssc);
3381 sd_ssc_fini(ssc);
3382 }
3383 #endif /* _LP64 */
3384
3385 /*
3386 * Function: sd_set_mmc_caps
3387 *
3388 * Description: This routine determines if the device is MMC compliant and if
3389 * the device supports CDDA via a mode sense of the CDVD
3390 * capabilities mode page. Also checks if the device is a
3391 * dvdram writable device.
3392 *
3393 * Arguments: ssc - ssc contains pointer to driver soft state (unit)
3394 * structure for this target.
3395 *
3396 * Context: Kernel thread context only
3397 */
3398
3399 static void
3400 sd_set_mmc_caps(sd_ssc_t *ssc)
3401 {
3402 struct mode_header_grp2 *sense_mhp;
3403 uchar_t *sense_page;
3404 caddr_t buf;
3405 int bd_len;
3406 int status;
3407 struct uscsi_cmd com;
3408 int rtn;
3409 uchar_t *out_data_rw, *out_data_hd;
3410 uchar_t *rqbuf_rw, *rqbuf_hd;
3411 uchar_t *out_data_gesn;
3412 int gesn_len;
3413 struct sd_lun *un;
3414
3415 ASSERT(ssc != NULL);
3416 un = ssc->ssc_un;
3417 ASSERT(un != NULL);
3418
3419 /*
3420 * The flags which will be set in this function are - mmc compliant,
3421 * dvdram writable device, cdda support. Initialize them to FALSE
3422 * and if a capability is detected - it will be set to TRUE.
3423 */
3424 un->un_f_mmc_cap = FALSE;
3425 un->un_f_dvdram_writable_device = FALSE;
3426 un->un_f_cfg_cdda = FALSE;
3427
3428 buf = kmem_zalloc(BUFLEN_MODE_CDROM_CAP, KM_SLEEP);
3429 status = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP1, (uchar_t *)buf,
3430 BUFLEN_MODE_CDROM_CAP, MODEPAGE_CDROM_CAP, SD_PATH_DIRECT);
3431
3432 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
3433
3434 if (status != 0) {
3435 /* command failed; just return */
3436 kmem_free(buf, BUFLEN_MODE_CDROM_CAP);
3437 return;
3438 }
3439 /*
3440 * If the mode sense request for the CDROM CAPABILITIES
3441 * page (0x2A) succeeds the device is assumed to be MMC.
3442 */
3443 un->un_f_mmc_cap = TRUE;
3444
3445 /* See if GET STATUS EVENT NOTIFICATION is supported */
3446 if (un->un_f_mmc_gesn_polling) {
3447 gesn_len = SD_GESN_HEADER_LEN + SD_GESN_MEDIA_DATA_LEN;
3448 out_data_gesn = kmem_zalloc(gesn_len, KM_SLEEP);
3449
3450 rtn = sd_send_scsi_GET_EVENT_STATUS_NOTIFICATION(ssc,
3451 out_data_gesn, gesn_len, 1 << SD_GESN_MEDIA_CLASS);
3452
3453 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
3454
3455 if ((rtn != 0) || !sd_gesn_media_data_valid(out_data_gesn)) {
3456 un->un_f_mmc_gesn_polling = FALSE;
3457 SD_INFO(SD_LOG_ATTACH_DETACH, un,
3458 "sd_set_mmc_caps: gesn not supported "
3459 "%d %x %x %x %x\n", rtn,
3460 out_data_gesn[0], out_data_gesn[1],
3461 out_data_gesn[2], out_data_gesn[3]);
3462 }
3463
3464 kmem_free(out_data_gesn, gesn_len);
3465 }
3466
3467 /* Get to the page data */
3468 sense_mhp = (struct mode_header_grp2 *)buf;
3469 bd_len = (sense_mhp->bdesc_length_hi << 8) |
3470 sense_mhp->bdesc_length_lo;
3471 if (bd_len > MODE_BLK_DESC_LENGTH) {
3472 /*
3473 * We did not get back the expected block descriptor
3474 * length so we cannot determine if the device supports
3475 * CDDA. However, we still indicate the device is MMC
3476 * according to the successful response to the page
3477 * 0x2A mode sense request.
3478 */
3479 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
3480 "sd_set_mmc_caps: Mode Sense returned "
3481 "invalid block descriptor length\n");
3482 kmem_free(buf, BUFLEN_MODE_CDROM_CAP);
3483 return;
3484 }
3485
3486 /* See if read CDDA is supported */
3487 sense_page = (uchar_t *)(buf + MODE_HEADER_LENGTH_GRP2 +
3488 bd_len);
3489 un->un_f_cfg_cdda = (sense_page[5] & 0x01) ? TRUE : FALSE;
3490
3491 /* See if writing DVD RAM is supported. */
3492 un->un_f_dvdram_writable_device = (sense_page[3] & 0x20) ? TRUE : FALSE;
3493 if (un->un_f_dvdram_writable_device == TRUE) {
3494 kmem_free(buf, BUFLEN_MODE_CDROM_CAP);
3495 return;
3496 }
3497
3498 /*
3499 * If the device presents DVD or CD capabilities in the mode
3500 * page, we can return here since a RRD will not have
3501 * these capabilities.
3502 */
3503 if ((sense_page[2] & 0x3f) || (sense_page[3] & 0x3f)) {
3504 kmem_free(buf, BUFLEN_MODE_CDROM_CAP);
3505 return;
3506 }
3507 kmem_free(buf, BUFLEN_MODE_CDROM_CAP);
3508
3509 /*
3510 * If un->un_f_dvdram_writable_device is still FALSE,
3511 * check for a Removable Rigid Disk (RRD). A RRD
3512 * device is identified by the features RANDOM_WRITABLE and
3513 * HARDWARE_DEFECT_MANAGEMENT.
3514 */
3515 out_data_rw = kmem_zalloc(SD_CURRENT_FEATURE_LEN, KM_SLEEP);
3516 rqbuf_rw = kmem_zalloc(SENSE_LENGTH, KM_SLEEP);
3517
3518 rtn = sd_send_scsi_feature_GET_CONFIGURATION(ssc, &com, rqbuf_rw,
3519 SENSE_LENGTH, out_data_rw, SD_CURRENT_FEATURE_LEN,
3520 RANDOM_WRITABLE, SD_PATH_STANDARD);
3521
3522 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
3523
3524 if (rtn != 0) {
3525 kmem_free(out_data_rw, SD_CURRENT_FEATURE_LEN);
3526 kmem_free(rqbuf_rw, SENSE_LENGTH);
3527 return;
3528 }
3529
3530 out_data_hd = kmem_zalloc(SD_CURRENT_FEATURE_LEN, KM_SLEEP);
3531 rqbuf_hd = kmem_zalloc(SENSE_LENGTH, KM_SLEEP);
3532
3533 rtn = sd_send_scsi_feature_GET_CONFIGURATION(ssc, &com, rqbuf_hd,
3534 SENSE_LENGTH, out_data_hd, SD_CURRENT_FEATURE_LEN,
3535 HARDWARE_DEFECT_MANAGEMENT, SD_PATH_STANDARD);
3536
3537 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
3538
3539 if (rtn == 0) {
3540 /*
3541 * We have good information, check for random writable
3542 * and hardware defect features.
3543 */
3544 if ((out_data_rw[9] & RANDOM_WRITABLE) &&
3545 (out_data_hd[9] & HARDWARE_DEFECT_MANAGEMENT)) {
3546 un->un_f_dvdram_writable_device = TRUE;
3547 }
3548 }
3549
3550 kmem_free(out_data_rw, SD_CURRENT_FEATURE_LEN);
3551 kmem_free(rqbuf_rw, SENSE_LENGTH);
3552 kmem_free(out_data_hd, SD_CURRENT_FEATURE_LEN);
3553 kmem_free(rqbuf_hd, SENSE_LENGTH);
3554 }
3555
3556 /*
3557 * Function: sd_check_for_writable_cd
3558 *
3559 * Description: This routine determines if the media in the device is
3560 * writable or not. It uses the get configuration command (0x46)
3561 * to determine if the media is writable
3562 *
3563 * Arguments: un - driver soft state (unit) structure
3564 * path_flag - SD_PATH_DIRECT to use the USCSI "direct"
3565 * chain and the normal command waitq, or
3566 * SD_PATH_DIRECT_PRIORITY to use the USCSI
3567 * "direct" chain and bypass the normal command
3568 * waitq.
3569 *
3570 * Context: Never called at interrupt context.
3571 */
3572
3573 static void
3574 sd_check_for_writable_cd(sd_ssc_t *ssc, int path_flag)
3575 {
3576 struct uscsi_cmd com;
3577 uchar_t *out_data;
3578 uchar_t *rqbuf;
3579 int rtn;
3580 uchar_t *out_data_rw, *out_data_hd;
3581 uchar_t *rqbuf_rw, *rqbuf_hd;
3582 struct mode_header_grp2 *sense_mhp;
3583 uchar_t *sense_page;
3584 caddr_t buf;
3585 int bd_len;
3586 int status;
3587 struct sd_lun *un;
3588
3589 ASSERT(ssc != NULL);
3590 un = ssc->ssc_un;
3591 ASSERT(un != NULL);
3592 ASSERT(mutex_owned(SD_MUTEX(un)));
3593
3594 /*
3595 * Initialize the writable media to false, if configuration info.
3596 * tells us otherwise then only we will set it.
3597 */
3598 un->un_f_mmc_writable_media = FALSE;
3599 mutex_exit(SD_MUTEX(un));
3600
3601 out_data = kmem_zalloc(SD_PROFILE_HEADER_LEN, KM_SLEEP);
3602 rqbuf = kmem_zalloc(SENSE_LENGTH, KM_SLEEP);
3603
3604 rtn = sd_send_scsi_GET_CONFIGURATION(ssc, &com, rqbuf, SENSE_LENGTH,
3605 out_data, SD_PROFILE_HEADER_LEN, path_flag);
3606
3607 if (rtn != 0)
3608 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
3609
3610 mutex_enter(SD_MUTEX(un));
3611 if (rtn == 0) {
3612 /*
3613 * We have good information, check for writable DVD.
3614 */
3615 if ((out_data[6] == 0) && (out_data[7] == 0x12)) {
3616 un->un_f_mmc_writable_media = TRUE;
3617 kmem_free(out_data, SD_PROFILE_HEADER_LEN);
3618 kmem_free(rqbuf, SENSE_LENGTH);
3619 return;
3620 }
3621 }
3622
3623 kmem_free(out_data, SD_PROFILE_HEADER_LEN);
3624 kmem_free(rqbuf, SENSE_LENGTH);
3625
3626 /*
3627 * Determine if this is a RRD type device.
3628 */
3629 mutex_exit(SD_MUTEX(un));
3630 buf = kmem_zalloc(BUFLEN_MODE_CDROM_CAP, KM_SLEEP);
3631 status = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP1, (uchar_t *)buf,
3632 BUFLEN_MODE_CDROM_CAP, MODEPAGE_CDROM_CAP, path_flag);
3633
3634 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
3635
3636 mutex_enter(SD_MUTEX(un));
3637 if (status != 0) {
3638 /* command failed; just return */
3639 kmem_free(buf, BUFLEN_MODE_CDROM_CAP);
3640 return;
3641 }
3642
3643 /* Get to the page data */
3644 sense_mhp = (struct mode_header_grp2 *)buf;
3645 bd_len = (sense_mhp->bdesc_length_hi << 8) | sense_mhp->bdesc_length_lo;
3646 if (bd_len > MODE_BLK_DESC_LENGTH) {
3647 /*
3648 * We did not get back the expected block descriptor length so
3649 * we cannot check the mode page.
3650 */
3651 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
3652 "sd_check_for_writable_cd: Mode Sense returned "
3653 "invalid block descriptor length\n");
3654 kmem_free(buf, BUFLEN_MODE_CDROM_CAP);
3655 return;
3656 }
3657
3658 /*
3659 * If the device presents DVD or CD capabilities in the mode
3660 * page, we can return here since a RRD device will not have
3661 * these capabilities.
3662 */
3663 sense_page = (uchar_t *)(buf + MODE_HEADER_LENGTH_GRP2 + bd_len);
3664 if ((sense_page[2] & 0x3f) || (sense_page[3] & 0x3f)) {
3665 kmem_free(buf, BUFLEN_MODE_CDROM_CAP);
3666 return;
3667 }
3668 kmem_free(buf, BUFLEN_MODE_CDROM_CAP);
3669
3670 /*
3671 * If un->un_f_mmc_writable_media is still FALSE,
3672 * check for RRD type media. A RRD device is identified
3673 * by the features RANDOM_WRITABLE and HARDWARE_DEFECT_MANAGEMENT.
3674 */
3675 mutex_exit(SD_MUTEX(un));
3676 out_data_rw = kmem_zalloc(SD_CURRENT_FEATURE_LEN, KM_SLEEP);
3677 rqbuf_rw = kmem_zalloc(SENSE_LENGTH, KM_SLEEP);
3678
3679 rtn = sd_send_scsi_feature_GET_CONFIGURATION(ssc, &com, rqbuf_rw,
3680 SENSE_LENGTH, out_data_rw, SD_CURRENT_FEATURE_LEN,
3681 RANDOM_WRITABLE, path_flag);
3682
3683 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
3684 if (rtn != 0) {
3685 kmem_free(out_data_rw, SD_CURRENT_FEATURE_LEN);
3686 kmem_free(rqbuf_rw, SENSE_LENGTH);
3687 mutex_enter(SD_MUTEX(un));
3688 return;
3689 }
3690
3691 out_data_hd = kmem_zalloc(SD_CURRENT_FEATURE_LEN, KM_SLEEP);
3692 rqbuf_hd = kmem_zalloc(SENSE_LENGTH, KM_SLEEP);
3693
3694 rtn = sd_send_scsi_feature_GET_CONFIGURATION(ssc, &com, rqbuf_hd,
3695 SENSE_LENGTH, out_data_hd, SD_CURRENT_FEATURE_LEN,
3696 HARDWARE_DEFECT_MANAGEMENT, path_flag);
3697
3698 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
3699 mutex_enter(SD_MUTEX(un));
3700 if (rtn == 0) {
3701 /*
3702 * We have good information, check for random writable
3703 * and hardware defect features as current.
3704 */
3705 if ((out_data_rw[9] & RANDOM_WRITABLE) &&
3706 (out_data_rw[10] & 0x1) &&
3707 (out_data_hd[9] & HARDWARE_DEFECT_MANAGEMENT) &&
3708 (out_data_hd[10] & 0x1)) {
3709 un->un_f_mmc_writable_media = TRUE;
3710 }
3711 }
3712
3713 kmem_free(out_data_rw, SD_CURRENT_FEATURE_LEN);
3714 kmem_free(rqbuf_rw, SENSE_LENGTH);
3715 kmem_free(out_data_hd, SD_CURRENT_FEATURE_LEN);
3716 kmem_free(rqbuf_hd, SENSE_LENGTH);
3717 }
3718
3719 /*
3720 * Function: sd_read_unit_properties
3721 *
3722 * Description: The following implements a property lookup mechanism.
3723 * Properties for particular disks (keyed on vendor, model
3724 * and rev numbers) are sought in the sd.conf file via
3725 * sd_process_sdconf_file(), and if not found there, are
3726 * looked for in a list hardcoded in this driver via
3727 * sd_process_sdconf_table() Once located the properties
3728 * are used to update the driver unit structure.
3729 *
3730 * Arguments: un - driver soft state (unit) structure
3731 */
3732
3733 static void
3734 sd_read_unit_properties(struct sd_lun *un)
3735 {
3736 /*
3737 * sd_process_sdconf_file returns SD_FAILURE if it cannot find
3738 * the "sd-config-list" property (from the sd.conf file) or if
3739 * there was not a match for the inquiry vid/pid. If this event
3740 * occurs the static driver configuration table is searched for
3741 * a match.
3742 */
3743 ASSERT(un != NULL);
3744 if (sd_process_sdconf_file(un) == SD_FAILURE) {
3745 sd_process_sdconf_table(un);
3746 }
3747
3748 /* check for LSI device */
3749 sd_is_lsi(un);
3750
3751
3752 }
3753
3754
3755 /*
3756 * Function: sd_process_sdconf_file
3757 *
3758 * Description: Use ddi_prop_lookup(9F) to obtain the properties from the
3759 * driver's config file (ie, sd.conf) and update the driver
3760 * soft state structure accordingly.
3761 *
3762 * Arguments: un - driver soft state (unit) structure
3763 *
3764 * Return Code: SD_SUCCESS - The properties were successfully set according
3765 * to the driver configuration file.
3766 * SD_FAILURE - The driver config list was not obtained or
3767 * there was no vid/pid match. This indicates that
3768 * the static config table should be used.
3769 *
3770 * The config file has a property, "sd-config-list". Currently we support
3771 * two kinds of formats. For both formats, the value of this property
3772 * is a list of duplets:
3773 *
3774 * sd-config-list=
3775 * <duplet>,
3776 * [,<duplet>]*;
3777 *
3778 * For the improved format, where
3779 *
3780 * <duplet>:= "<vid+pid>","<tunable-list>"
3781 *
3782 * and
3783 *
3784 * <tunable-list>:= <tunable> [, <tunable> ]*;
3785 * <tunable> = <name> : <value>
3786 *
3787 * The <vid+pid> is the string that is returned by the target device on a
3788 * SCSI inquiry command, the <tunable-list> contains one or more tunables
3789 * to apply to all target devices with the specified <vid+pid>.
3790 *
3791 * Each <tunable> is a "<name> : <value>" pair.
3792 *
3793 * For the old format, the structure of each duplet is as follows:
3794 *
3795 * <duplet>:= "<vid+pid>","<data-property-name_list>"
3796 *
3797 * The first entry of the duplet is the device ID string (the concatenated
3798 * vid & pid; not to be confused with a device_id). This is defined in
3799 * the same way as in the sd_disk_table.
3800 *
3801 * The second part of the duplet is a string that identifies a
3802 * data-property-name-list. The data-property-name-list is defined as
3803 * follows:
3804 *
3805 * <data-property-name-list>:=<data-property-name> [<data-property-name>]
3806 *
3807 * The syntax of <data-property-name> depends on the <version> field.
3808 *
3809 * If version = SD_CONF_VERSION_1 we have the following syntax:
3810 *
3811 * <data-property-name>:=<version>,<flags>,<prop0>,<prop1>,.....<propN>
3812 *
3813 * where the prop0 value will be used to set prop0 if bit0 set in the
3814 * flags, prop1 if bit1 set, etc. and N = SD_CONF_MAX_ITEMS -1
3815 *
3816 */
3817
3818 static int
3819 sd_process_sdconf_file(struct sd_lun *un)
3820 {
3821 char **config_list = NULL;
3822 uint_t nelements;
3823 char *vidptr;
3824 int vidlen;
3825 char *dnlist_ptr;
3826 char *dataname_ptr;
3827 char *dataname_lasts;
3828 int *data_list = NULL;
3829 uint_t data_list_len;
3830 int rval = SD_FAILURE;
3831 int i;
3832
3833 ASSERT(un != NULL);
3834
3835 /* Obtain the configuration list associated with the .conf file */
3836 if (ddi_prop_lookup_string_array(DDI_DEV_T_ANY, SD_DEVINFO(un),
3837 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, sd_config_list,
3838 &config_list, &nelements) != DDI_PROP_SUCCESS) {
3839 return (SD_FAILURE);
3840 }
3841
3842 /*
3843 * Compare vids in each duplet to the inquiry vid - if a match is
3844 * made, get the data value and update the soft state structure
3845 * accordingly.
3846 *
3847 * Each duplet should show as a pair of strings, return SD_FAILURE
3848 * otherwise.
3849 */
3850 if (nelements & 1) {
3851 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
3852 "sd-config-list should show as pairs of strings.\n");
3853 if (config_list)
3854 ddi_prop_free(config_list);
3855 return (SD_FAILURE);
3856 }
3857
3858 for (i = 0; i < nelements; i += 2) {
3859 /*
3860 * Note: The assumption here is that each vid entry is on
3861 * a unique line from its associated duplet.
3862 */
3863 vidptr = config_list[i];
3864 vidlen = (int)strlen(vidptr);
3865 if (sd_sdconf_id_match(un, vidptr, vidlen) != SD_SUCCESS) {
3866 continue;
3867 }
3868
3869 /*
3870 * dnlist contains 1 or more blank separated
3871 * data-property-name entries
3872 */
3873 dnlist_ptr = config_list[i + 1];
3874
3875 if (strchr(dnlist_ptr, ':') != NULL) {
3876 /*
3877 * Decode the improved format sd-config-list.
3878 */
3879 sd_nvpair_str_decode(un, dnlist_ptr);
3880 } else {
3881 /*
3882 * The old format sd-config-list, loop through all
3883 * data-property-name entries in the
3884 * data-property-name-list
3885 * setting the properties for each.
3886 */
3887 for (dataname_ptr = sd_strtok_r(dnlist_ptr, " \t",
3888 &dataname_lasts); dataname_ptr != NULL;
3889 dataname_ptr = sd_strtok_r(NULL, " \t",
3890 &dataname_lasts)) {
3891 int version;
3892
3893 SD_INFO(SD_LOG_ATTACH_DETACH, un,
3894 "sd_process_sdconf_file: disk:%s, "
3895 "data:%s\n", vidptr, dataname_ptr);
3896
3897 /* Get the data list */
3898 if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY,
3899 SD_DEVINFO(un), 0, dataname_ptr, &data_list,
3900 &data_list_len) != DDI_PROP_SUCCESS) {
3901 SD_INFO(SD_LOG_ATTACH_DETACH, un,
3902 "sd_process_sdconf_file: data "
3903 "property (%s) has no value\n",
3904 dataname_ptr);
3905 continue;
3906 }
3907
3908 version = data_list[0];
3909
3910 if (version == SD_CONF_VERSION_1) {
3911 sd_tunables values;
3912
3913 /* Set the properties */
3914 if (sd_chk_vers1_data(un, data_list[1],
3915 &data_list[2], data_list_len,
3916 dataname_ptr) == SD_SUCCESS) {
3917 sd_get_tunables_from_conf(un,
3918 data_list[1], &data_list[2],
3919 &values);
3920 sd_set_vers1_properties(un,
3921 data_list[1], &values);
3922 rval = SD_SUCCESS;
3923 } else {
3924 rval = SD_FAILURE;
3925 }
3926 } else {
3927 scsi_log(SD_DEVINFO(un), sd_label,
3928 CE_WARN, "data property %s version "
3929 "0x%x is invalid.",
3930 dataname_ptr, version);
3931 rval = SD_FAILURE;
3932 }
3933 if (data_list)
3934 ddi_prop_free(data_list);
3935 }
3936 }
3937 }
3938
3939 /* free up the memory allocated by ddi_prop_lookup_string_array(). */
3940 if (config_list) {
3941 ddi_prop_free(config_list);
3942 }
3943
3944 return (rval);
3945 }
3946
3947 /*
3948 * Function: sd_nvpair_str_decode()
3949 *
3950 * Description: Parse the improved format sd-config-list to get
3951 * each entry of tunable, which includes a name-value pair.
3952 * Then call sd_set_properties() to set the property.
3953 *
3954 * Arguments: un - driver soft state (unit) structure
3955 * nvpair_str - the tunable list
3956 */
3957 static void
3958 sd_nvpair_str_decode(struct sd_lun *un, char *nvpair_str)
3959 {
3960 char *nv, *name, *value, *token;
3961 char *nv_lasts, *v_lasts, *x_lasts;
3962
3963 for (nv = sd_strtok_r(nvpair_str, ",", &nv_lasts); nv != NULL;
3964 nv = sd_strtok_r(NULL, ",", &nv_lasts)) {
3965 token = sd_strtok_r(nv, ":", &v_lasts);
3966 name = sd_strtok_r(token, " \t", &x_lasts);
3967 token = sd_strtok_r(NULL, ":", &v_lasts);
3968 value = sd_strtok_r(token, " \t", &x_lasts);
3969 if (name == NULL || value == NULL) {
3970 SD_INFO(SD_LOG_ATTACH_DETACH, un,
3971 "sd_nvpair_str_decode: "
3972 "name or value is not valid!\n");
3973 } else {
3974 sd_set_properties(un, name, value);
3975 }
3976 }
3977 }
3978
3979 /*
3980 * Function: sd_strtok_r()
3981 *
3982 * Description: This function uses strpbrk and strspn to break
3983 * string into tokens on sequentially subsequent calls. Return
3984 * NULL when no non-separator characters remain. The first
3985 * argument is NULL for subsequent calls.
3986 */
3987 static char *
3988 sd_strtok_r(char *string, const char *sepset, char **lasts)
3989 {
3990 char *q, *r;
3991
3992 /* First or subsequent call */
3993 if (string == NULL)
3994 string = *lasts;
3995
3996 if (string == NULL)
3997 return (NULL);
3998
3999 /* Skip leading separators */
4000 q = string + strspn(string, sepset);
4001
4002 if (*q == '\0')
4003 return (NULL);
4004
4005 if ((r = strpbrk(q, sepset)) == NULL)
4006 *lasts = NULL;
4007 else {
4008 *r = '\0';
4009 *lasts = r + 1;
4010 }
4011 return (q);
4012 }
4013
4014 /*
4015 * Function: sd_set_properties()
4016 *
4017 * Description: Set device properties based on the improved
4018 * format sd-config-list.
4019 *
4020 * Arguments: un - driver soft state (unit) structure
4021 * name - supported tunable name
4022 * value - tunable value
4023 */
4024 static void
4025 sd_set_properties(struct sd_lun *un, char *name, char *value)
4026 {
4027 char *endptr = NULL;
4028 long val = 0;
4029
4030 if (strcasecmp(name, "cache-nonvolatile") == 0) {
4031 if (strcasecmp(value, "true") == 0) {
4032 un->un_f_suppress_cache_flush = TRUE;
4033 } else if (strcasecmp(value, "false") == 0) {
4034 un->un_f_suppress_cache_flush = FALSE;
4035 } else {
4036 goto value_invalid;
4037 }
4038 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4039 "suppress_cache_flush flag set to %d\n",
4040 un->un_f_suppress_cache_flush);
4041 return;
4042 }
4043
4044 if (strcasecmp(name, "controller-type") == 0) {
4045 if (ddi_strtol(value, &endptr, 0, &val) == 0) {
4046 un->un_ctype = val;
4047 } else {
4048 goto value_invalid;
4049 }
4050 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4051 "ctype set to %d\n", un->un_ctype);
4052 return;
4053 }
4054
4055 if (strcasecmp(name, "delay-busy") == 0) {
4056 if (ddi_strtol(value, &endptr, 0, &val) == 0) {
4057 un->un_busy_timeout = drv_usectohz(val / 1000);
4058 } else {
4059 goto value_invalid;
4060 }
4061 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4062 "busy_timeout set to %d\n", un->un_busy_timeout);
4063 return;
4064 }
4065
4066 if (strcasecmp(name, "disksort") == 0) {
4067 if (strcasecmp(value, "true") == 0) {
4068 un->un_f_disksort_disabled = FALSE;
4069 } else if (strcasecmp(value, "false") == 0) {
4070 un->un_f_disksort_disabled = TRUE;
4071 } else {
4072 goto value_invalid;
4073 }
4074 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4075 "disksort disabled flag set to %d\n",
4076 un->un_f_disksort_disabled);
4077 return;
4078 }
4079
4080 if (strcasecmp(name, "power-condition") == 0) {
4081 if (strcasecmp(value, "true") == 0) {
4082 un->un_f_power_condition_disabled = FALSE;
4083 } else if (strcasecmp(value, "false") == 0) {
4084 un->un_f_power_condition_disabled = TRUE;
4085 } else {
4086 goto value_invalid;
4087 }
4088 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4089 "power condition disabled flag set to %d\n",
4090 un->un_f_power_condition_disabled);
4091 return;
4092 }
4093
4094 if (strcasecmp(name, "timeout-releasereservation") == 0) {
4095 if (ddi_strtol(value, &endptr, 0, &val) == 0) {
4096 un->un_reserve_release_time = val;
4097 } else {
4098 goto value_invalid;
4099 }
4100 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4101 "reservation release timeout set to %d\n",
4102 un->un_reserve_release_time);
4103 return;
4104 }
4105
4106 if (strcasecmp(name, "reset-lun") == 0) {
4107 if (strcasecmp(value, "true") == 0) {
4108 un->un_f_lun_reset_enabled = TRUE;
4109 } else if (strcasecmp(value, "false") == 0) {
4110 un->un_f_lun_reset_enabled = FALSE;
4111 } else {
4112 goto value_invalid;
4113 }
4114 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4115 "lun reset enabled flag set to %d\n",
4116 un->un_f_lun_reset_enabled);
4117 return;
4118 }
4119
4120 if (strcasecmp(name, "retries-busy") == 0) {
4121 if (ddi_strtol(value, &endptr, 0, &val) == 0) {
4122 un->un_busy_retry_count = val;
4123 } else {
4124 goto value_invalid;
4125 }
4126 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4127 "busy retry count set to %d\n", un->un_busy_retry_count);
4128 return;
4129 }
4130
4131 if (strcasecmp(name, "retries-timeout") == 0) {
4132 if (ddi_strtol(value, &endptr, 0, &val) == 0) {
4133 un->un_retry_count = val;
4134 } else {
4135 goto value_invalid;
4136 }
4137 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4138 "timeout retry count set to %d\n", un->un_retry_count);
4139 return;
4140 }
4141
4142 if (strcasecmp(name, "retries-notready") == 0) {
4143 if (ddi_strtol(value, &endptr, 0, &val) == 0) {
4144 un->un_notready_retry_count = val;
4145 } else {
4146 goto value_invalid;
4147 }
4148 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4149 "notready retry count set to %d\n",
4150 un->un_notready_retry_count);
4151 return;
4152 }
4153
4154 if (strcasecmp(name, "retries-reset") == 0) {
4155 if (ddi_strtol(value, &endptr, 0, &val) == 0) {
4156 un->un_reset_retry_count = val;
4157 } else {
4158 goto value_invalid;
4159 }
4160 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4161 "reset retry count set to %d\n",
4162 un->un_reset_retry_count);
4163 return;
4164 }
4165
4166 if (strcasecmp(name, "throttle-max") == 0) {
4167 if (ddi_strtol(value, &endptr, 0, &val) == 0) {
4168 un->un_saved_throttle = un->un_throttle = val;
4169 } else {
4170 goto value_invalid;
4171 }
4172 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4173 "throttle set to %d\n", un->un_throttle);
4174 }
4175
4176 if (strcasecmp(name, "throttle-min") == 0) {
4177 if (ddi_strtol(value, &endptr, 0, &val) == 0) {
4178 un->un_min_throttle = val;
4179 } else {
4180 goto value_invalid;
4181 }
4182 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4183 "min throttle set to %d\n", un->un_min_throttle);
4184 }
4185
4186 if (strcasecmp(name, "rmw-type") == 0) {
4187 if (ddi_strtol(value, &endptr, 0, &val) == 0) {
4188 un->un_f_rmw_type = val;
4189 } else {
4190 goto value_invalid;
4191 }
4192 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4193 "RMW type set to %d\n", un->un_f_rmw_type);
4194 }
4195
4196 if (strcasecmp(name, "physical-block-size") == 0) {
4197 if (ddi_strtol(value, &endptr, 0, &val) == 0 &&
4198 ISP2(val) && val >= un->un_tgt_blocksize &&
4199 val >= un->un_sys_blocksize) {
4200 un->un_phy_blocksize = val;
4201 } else {
4202 goto value_invalid;
4203 }
4204 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4205 "physical block size set to %d\n", un->un_phy_blocksize);
4206 }
4207
4208 if (strcasecmp(name, "retries-victim") == 0) {
4209 if (ddi_strtol(value, &endptr, 0, &val) == 0) {
4210 un->un_victim_retry_count = val;
4211 } else {
4212 goto value_invalid;
4213 }
4214 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4215 "victim retry count set to %d\n",
4216 un->un_victim_retry_count);
4217 return;
4218 }
4219
4220 /*
4221 * Validate the throttle values.
4222 * If any of the numbers are invalid, set everything to defaults.
4223 */
4224 if ((un->un_throttle < SD_LOWEST_VALID_THROTTLE) ||
4225 (un->un_min_throttle < SD_LOWEST_VALID_THROTTLE) ||
4226 (un->un_min_throttle > un->un_throttle)) {
4227 un->un_saved_throttle = un->un_throttle = sd_max_throttle;
4228 un->un_min_throttle = sd_min_throttle;
4229 }
4230
4231 if (strcasecmp(name, "mmc-gesn-polling") == 0) {
4232 if (strcasecmp(value, "true") == 0) {
4233 un->un_f_mmc_gesn_polling = TRUE;
4234 } else if (strcasecmp(value, "false") == 0) {
4235 un->un_f_mmc_gesn_polling = FALSE;
4236 } else {
4237 goto value_invalid;
4238 }
4239 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4240 "mmc-gesn-polling set to %d\n",
4241 un->un_f_mmc_gesn_polling);
4242 }
4243
4244 return;
4245
4246 value_invalid:
4247 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4248 "value of prop %s is invalid\n", name);
4249 }
4250
4251 /*
4252 * Function: sd_get_tunables_from_conf()
4253 *
4254 *
4255 * This function reads the data list from the sd.conf file and pulls
4256 * the values that can have numeric values as arguments and places
4257 * the values in the appropriate sd_tunables member.
4258 * Since the order of the data list members varies across platforms
4259 * This function reads them from the data list in a platform specific
4260 * order and places them into the correct sd_tunable member that is
4261 * consistent across all platforms.
4262 */
4263 static void
4264 sd_get_tunables_from_conf(struct sd_lun *un, int flags, int *data_list,
4265 sd_tunables *values)
4266 {
4267 int i;
4268 int mask;
4269
4270 bzero(values, sizeof (sd_tunables));
4271
4272 for (i = 0; i < SD_CONF_MAX_ITEMS; i++) {
4273
4274 mask = 1 << i;
4275 if (mask > flags) {
4276 break;
4277 }
4278
4279 switch (mask & flags) {
4280 case 0: /* This mask bit not set in flags */
4281 continue;
4282 case SD_CONF_BSET_THROTTLE:
4283 values->sdt_throttle = data_list[i];
4284 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4285 "sd_get_tunables_from_conf: throttle = %d\n",
4286 values->sdt_throttle);
4287 break;
4288 case SD_CONF_BSET_CTYPE:
4289 values->sdt_ctype = data_list[i];
4290 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4291 "sd_get_tunables_from_conf: ctype = %d\n",
4292 values->sdt_ctype);
4293 break;
4294 case SD_CONF_BSET_NRR_COUNT:
4295 values->sdt_not_rdy_retries = data_list[i];
4296 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4297 "sd_get_tunables_from_conf: not_rdy_retries = %d\n",
4298 values->sdt_not_rdy_retries);
4299 break;
4300 case SD_CONF_BSET_BSY_RETRY_COUNT:
4301 values->sdt_busy_retries = data_list[i];
4302 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4303 "sd_get_tunables_from_conf: busy_retries = %d\n",
4304 values->sdt_busy_retries);
4305 break;
4306 case SD_CONF_BSET_RST_RETRIES:
4307 values->sdt_reset_retries = data_list[i];
4308 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4309 "sd_get_tunables_from_conf: reset_retries = %d\n",
4310 values->sdt_reset_retries);
4311 break;
4312 case SD_CONF_BSET_RSV_REL_TIME:
4313 values->sdt_reserv_rel_time = data_list[i];
4314 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4315 "sd_get_tunables_from_conf: reserv_rel_time = %d\n",
4316 values->sdt_reserv_rel_time);
4317 break;
4318 case SD_CONF_BSET_MIN_THROTTLE:
4319 values->sdt_min_throttle = data_list[i];
4320 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4321 "sd_get_tunables_from_conf: min_throttle = %d\n",
4322 values->sdt_min_throttle);
4323 break;
4324 case SD_CONF_BSET_DISKSORT_DISABLED:
4325 values->sdt_disk_sort_dis = data_list[i];
4326 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4327 "sd_get_tunables_from_conf: disk_sort_dis = %d\n",
4328 values->sdt_disk_sort_dis);
4329 break;
4330 case SD_CONF_BSET_LUN_RESET_ENABLED:
4331 values->sdt_lun_reset_enable = data_list[i];
4332 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4333 "sd_get_tunables_from_conf: lun_reset_enable = %d"
4334 "\n", values->sdt_lun_reset_enable);
4335 break;
4336 case SD_CONF_BSET_CACHE_IS_NV:
4337 values->sdt_suppress_cache_flush = data_list[i];
4338 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4339 "sd_get_tunables_from_conf: \
4340 suppress_cache_flush = %d"
4341 "\n", values->sdt_suppress_cache_flush);
4342 break;
4343 case SD_CONF_BSET_PC_DISABLED:
4344 values->sdt_disk_sort_dis = data_list[i];
4345 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4346 "sd_get_tunables_from_conf: power_condition_dis = "
4347 "%d\n", values->sdt_power_condition_dis);
4348 break;
4349 }
4350 }
4351 }
4352
4353 /*
4354 * Function: sd_process_sdconf_table
4355 *
4356 * Description: Search the static configuration table for a match on the
4357 * inquiry vid/pid and update the driver soft state structure
4358 * according to the table property values for the device.
4359 *
4360 * The form of a configuration table entry is:
4361 * <vid+pid>,<flags>,<property-data>
4362 * "SEAGATE ST42400N",1,0x40000,
4363 * 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1;
4364 *
4365 * Arguments: un - driver soft state (unit) structure
4366 */
4367
4368 static void
4369 sd_process_sdconf_table(struct sd_lun *un)
4370 {
4371 char *id = NULL;
4372 int table_index;
4373 int idlen;
4374
4375 ASSERT(un != NULL);
4376 for (table_index = 0; table_index < sd_disk_table_size;
4377 table_index++) {
4378 id = sd_disk_table[table_index].device_id;
4379 idlen = strlen(id);
4380
4381 /*
4382 * The static configuration table currently does not
4383 * implement version 10 properties. Additionally,
4384 * multiple data-property-name entries are not
4385 * implemented in the static configuration table.
4386 */
4387 if (sd_sdconf_id_match(un, id, idlen) == SD_SUCCESS) {
4388 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4389 "sd_process_sdconf_table: disk %s\n", id);
4390 sd_set_vers1_properties(un,
4391 sd_disk_table[table_index].flags,
4392 sd_disk_table[table_index].properties);
4393 break;
4394 }
4395 }
4396 }
4397
4398
4399 /*
4400 * Function: sd_sdconf_id_match
4401 *
4402 * Description: This local function implements a case sensitive vid/pid
4403 * comparison as well as the boundary cases of wild card and
4404 * multiple blanks.
4405 *
4406 * Note: An implicit assumption made here is that the scsi
4407 * inquiry structure will always keep the vid, pid and
4408 * revision strings in consecutive sequence, so they can be
4409 * read as a single string. If this assumption is not the
4410 * case, a separate string, to be used for the check, needs
4411 * to be built with these strings concatenated.
4412 *
4413 * Arguments: un - driver soft state (unit) structure
4414 * id - table or config file vid/pid
4415 * idlen - length of the vid/pid (bytes)
4416 *
4417 * Return Code: SD_SUCCESS - Indicates a match with the inquiry vid/pid
4418 * SD_FAILURE - Indicates no match with the inquiry vid/pid
4419 */
4420
4421 static int
4422 sd_sdconf_id_match(struct sd_lun *un, char *id, int idlen)
4423 {
4424 struct scsi_inquiry *sd_inq;
4425 int rval = SD_SUCCESS;
4426
4427 ASSERT(un != NULL);
4428 sd_inq = un->un_sd->sd_inq;
4429 ASSERT(id != NULL);
4430
4431 /*
4432 * We use the inq_vid as a pointer to a buffer containing the
4433 * vid and pid and use the entire vid/pid length of the table
4434 * entry for the comparison. This works because the inq_pid
4435 * data member follows inq_vid in the scsi_inquiry structure.
4436 */
4437 if (strncasecmp(sd_inq->inq_vid, id, idlen) != 0) {
4438 /*
4439 * The user id string is compared to the inquiry vid/pid
4440 * using a case insensitive comparison and ignoring
4441 * multiple spaces.
4442 */
4443 rval = sd_blank_cmp(un, id, idlen);
4444 if (rval != SD_SUCCESS) {
4445 /*
4446 * User id strings that start and end with a "*"
4447 * are a special case. These do not have a
4448 * specific vendor, and the product string can
4449 * appear anywhere in the 16 byte PID portion of
4450 * the inquiry data. This is a simple strstr()
4451 * type search for the user id in the inquiry data.
4452 */
4453 if ((id[0] == '*') && (id[idlen - 1] == '*')) {
4454 char *pidptr = &id[1];
4455 int i;
4456 int j;
4457 int pidstrlen = idlen - 2;
4458 j = sizeof (SD_INQUIRY(un)->inq_pid) -
4459 pidstrlen;
4460
4461 if (j < 0) {
4462 return (SD_FAILURE);
4463 }
4464 for (i = 0; i < j; i++) {
4465 if (bcmp(&SD_INQUIRY(un)->inq_pid[i],
4466 pidptr, pidstrlen) == 0) {
4467 rval = SD_SUCCESS;
4468 break;
4469 }
4470 }
4471 }
4472 }
4473 }
4474 return (rval);
4475 }
4476
4477
4478 /*
4479 * Function: sd_blank_cmp
4480 *
4481 * Description: If the id string starts and ends with a space, treat
4482 * multiple consecutive spaces as equivalent to a single
4483 * space. For example, this causes a sd_disk_table entry
4484 * of " NEC CDROM " to match a device's id string of
4485 * "NEC CDROM".
4486 *
4487 * Note: The success exit condition for this routine is if
4488 * the pointer to the table entry is '\0' and the cnt of
4489 * the inquiry length is zero. This will happen if the inquiry
4490 * string returned by the device is padded with spaces to be
4491 * exactly 24 bytes in length (8 byte vid + 16 byte pid). The
4492 * SCSI spec states that the inquiry string is to be padded with
4493 * spaces.
4494 *
4495 * Arguments: un - driver soft state (unit) structure
4496 * id - table or config file vid/pid
4497 * idlen - length of the vid/pid (bytes)
4498 *
4499 * Return Code: SD_SUCCESS - Indicates a match with the inquiry vid/pid
4500 * SD_FAILURE - Indicates no match with the inquiry vid/pid
4501 */
4502
4503 static int
4504 sd_blank_cmp(struct sd_lun *un, char *id, int idlen)
4505 {
4506 char *p1;
4507 char *p2;
4508 int cnt;
4509 cnt = sizeof (SD_INQUIRY(un)->inq_vid) +
4510 sizeof (SD_INQUIRY(un)->inq_pid);
4511
4512 ASSERT(un != NULL);
4513 p2 = un->un_sd->sd_inq->inq_vid;
4514 ASSERT(id != NULL);
4515 p1 = id;
4516
4517 if ((id[0] == ' ') && (id[idlen - 1] == ' ')) {
4518 /*
4519 * Note: string p1 is terminated by a NUL but string p2
4520 * isn't. The end of p2 is determined by cnt.
4521 */
4522 for (;;) {
4523 /* skip over any extra blanks in both strings */
4524 while ((*p1 != '\0') && (*p1 == ' ')) {
4525 p1++;
4526 }
4527 while ((cnt != 0) && (*p2 == ' ')) {
4528 p2++;
4529 cnt--;
4530 }
4531
4532 /* compare the two strings */
4533 if ((cnt == 0) ||
4534 (SD_TOUPPER(*p1) != SD_TOUPPER(*p2))) {
4535 break;
4536 }
4537 while ((cnt > 0) &&
4538 (SD_TOUPPER(*p1) == SD_TOUPPER(*p2))) {
4539 p1++;
4540 p2++;
4541 cnt--;
4542 }
4543 }
4544 }
4545
4546 /* return SD_SUCCESS if both strings match */
4547 return (((*p1 == '\0') && (cnt == 0)) ? SD_SUCCESS : SD_FAILURE);
4548 }
4549
4550
4551 /*
4552 * Function: sd_chk_vers1_data
4553 *
4554 * Description: Verify the version 1 device properties provided by the
4555 * user via the configuration file
4556 *
4557 * Arguments: un - driver soft state (unit) structure
4558 * flags - integer mask indicating properties to be set
4559 * prop_list - integer list of property values
4560 * list_len - number of the elements
4561 *
4562 * Return Code: SD_SUCCESS - Indicates the user provided data is valid
4563 * SD_FAILURE - Indicates the user provided data is invalid
4564 */
4565
4566 static int
4567 sd_chk_vers1_data(struct sd_lun *un, int flags, int *prop_list,
4568 int list_len, char *dataname_ptr)
4569 {
4570 int i;
4571 int mask = 1;
4572 int index = 0;
4573
4574 ASSERT(un != NULL);
4575
4576 /* Check for a NULL property name and list */
4577 if (dataname_ptr == NULL) {
4578 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
4579 "sd_chk_vers1_data: NULL data property name.");
4580 return (SD_FAILURE);
4581 }
4582 if (prop_list == NULL) {
4583 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
4584 "sd_chk_vers1_data: %s NULL data property list.",
4585 dataname_ptr);
4586 return (SD_FAILURE);
4587 }
4588
4589 /* Display a warning if undefined bits are set in the flags */
4590 if (flags & ~SD_CONF_BIT_MASK) {
4591 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
4592 "sd_chk_vers1_data: invalid bits 0x%x in data list %s. "
4593 "Properties not set.",
4594 (flags & ~SD_CONF_BIT_MASK), dataname_ptr);
4595 return (SD_FAILURE);
4596 }
4597
4598 /*
4599 * Verify the length of the list by identifying the highest bit set
4600 * in the flags and validating that the property list has a length
4601 * up to the index of this bit.
4602 */
4603 for (i = 0; i < SD_CONF_MAX_ITEMS; i++) {
4604 if (flags & mask) {
4605 index++;
4606 }
4607 mask = 1 << i;
4608 }
4609 if (list_len < (index + 2)) {
4610 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
4611 "sd_chk_vers1_data: "
4612 "Data property list %s size is incorrect. "
4613 "Properties not set.", dataname_ptr);
4614 scsi_log(SD_DEVINFO(un), sd_label, CE_CONT, "Size expected: "
4615 "version + 1 flagword + %d properties", SD_CONF_MAX_ITEMS);
4616 return (SD_FAILURE);
4617 }
4618 return (SD_SUCCESS);
4619 }
4620
4621
4622 /*
4623 * Function: sd_set_vers1_properties
4624 *
4625 * Description: Set version 1 device properties based on a property list
4626 * retrieved from the driver configuration file or static
4627 * configuration table. Version 1 properties have the format:
4628 *
4629 * <data-property-name>:=<version>,<flags>,<prop0>,<prop1>,.....<propN>
4630 *
4631 * where the prop0 value will be used to set prop0 if bit0
4632 * is set in the flags
4633 *
4634 * Arguments: un - driver soft state (unit) structure
4635 * flags - integer mask indicating properties to be set
4636 * prop_list - integer list of property values
4637 */
4638
4639 static void
4640 sd_set_vers1_properties(struct sd_lun *un, int flags, sd_tunables *prop_list)
4641 {
4642 ASSERT(un != NULL);
4643
4644 /*
4645 * Set the flag to indicate cache is to be disabled. An attempt
4646 * to disable the cache via sd_cache_control() will be made
4647 * later during attach once the basic initialization is complete.
4648 */
4649 if (flags & SD_CONF_BSET_NOCACHE) {
4650 un->un_f_opt_disable_cache = TRUE;
4651 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4652 "sd_set_vers1_properties: caching disabled flag set\n");
4653 }
4654
4655 /* CD-specific configuration parameters */
4656 if (flags & SD_CONF_BSET_PLAYMSF_BCD) {
4657 un->un_f_cfg_playmsf_bcd = TRUE;
4658 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4659 "sd_set_vers1_properties: playmsf_bcd set\n");
4660 }
4661 if (flags & SD_CONF_BSET_READSUB_BCD) {
4662 un->un_f_cfg_readsub_bcd = TRUE;
4663 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4664 "sd_set_vers1_properties: readsub_bcd set\n");
4665 }
4666 if (flags & SD_CONF_BSET_READ_TOC_TRK_BCD) {
4667 un->un_f_cfg_read_toc_trk_bcd = TRUE;
4668 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4669 "sd_set_vers1_properties: read_toc_trk_bcd set\n");
4670 }
4671 if (flags & SD_CONF_BSET_READ_TOC_ADDR_BCD) {
4672 un->un_f_cfg_read_toc_addr_bcd = TRUE;
4673 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4674 "sd_set_vers1_properties: read_toc_addr_bcd set\n");
4675 }
4676 if (flags & SD_CONF_BSET_NO_READ_HEADER) {
4677 un->un_f_cfg_no_read_header = TRUE;
4678 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4679 "sd_set_vers1_properties: no_read_header set\n");
4680 }
4681 if (flags & SD_CONF_BSET_READ_CD_XD4) {
4682 un->un_f_cfg_read_cd_xd4 = TRUE;
4683 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4684 "sd_set_vers1_properties: read_cd_xd4 set\n");
4685 }
4686
4687 /* Support for devices which do not have valid/unique serial numbers */
4688 if (flags & SD_CONF_BSET_FAB_DEVID) {
4689 un->un_f_opt_fab_devid = TRUE;
4690 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4691 "sd_set_vers1_properties: fab_devid bit set\n");
4692 }
4693
4694 /* Support for user throttle configuration */
4695 if (flags & SD_CONF_BSET_THROTTLE) {
4696 ASSERT(prop_list != NULL);
4697 un->un_saved_throttle = un->un_throttle =
4698 prop_list->sdt_throttle;
4699 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4700 "sd_set_vers1_properties: throttle set to %d\n",
4701 prop_list->sdt_throttle);
4702 }
4703
4704 /* Set the per disk retry count according to the conf file or table. */
4705 if (flags & SD_CONF_BSET_NRR_COUNT) {
4706 ASSERT(prop_list != NULL);
4707 if (prop_list->sdt_not_rdy_retries) {
4708 un->un_notready_retry_count =
4709 prop_list->sdt_not_rdy_retries;
4710 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4711 "sd_set_vers1_properties: not ready retry count"
4712 " set to %d\n", un->un_notready_retry_count);
4713 }
4714 }
4715
4716 /* The controller type is reported for generic disk driver ioctls */
4717 if (flags & SD_CONF_BSET_CTYPE) {
4718 ASSERT(prop_list != NULL);
4719 switch (prop_list->sdt_ctype) {
4720 case CTYPE_CDROM:
4721 un->un_ctype = prop_list->sdt_ctype;
4722 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4723 "sd_set_vers1_properties: ctype set to "
4724 "CTYPE_CDROM\n");
4725 break;
4726 case CTYPE_CCS:
4727 un->un_ctype = prop_list->sdt_ctype;
4728 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4729 "sd_set_vers1_properties: ctype set to "
4730 "CTYPE_CCS\n");
4731 break;
4732 case CTYPE_ROD: /* RW optical */
4733 un->un_ctype = prop_list->sdt_ctype;
4734 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4735 "sd_set_vers1_properties: ctype set to "
4736 "CTYPE_ROD\n");
4737 break;
4738 default:
4739 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
4740 "sd_set_vers1_properties: Could not set "
4741 "invalid ctype value (%d)",
4742 prop_list->sdt_ctype);
4743 }
4744 }
4745
4746 /* Purple failover timeout */
4747 if (flags & SD_CONF_BSET_BSY_RETRY_COUNT) {
4748 ASSERT(prop_list != NULL);
4749 un->un_busy_retry_count =
4750 prop_list->sdt_busy_retries;
4751 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4752 "sd_set_vers1_properties: "
4753 "busy retry count set to %d\n",
4754 un->un_busy_retry_count);
4755 }
4756
4757 /* Purple reset retry count */
4758 if (flags & SD_CONF_BSET_RST_RETRIES) {
4759 ASSERT(prop_list != NULL);
4760 un->un_reset_retry_count =
4761 prop_list->sdt_reset_retries;
4762 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4763 "sd_set_vers1_properties: "
4764 "reset retry count set to %d\n",
4765 un->un_reset_retry_count);
4766 }
4767
4768 /* Purple reservation release timeout */
4769 if (flags & SD_CONF_BSET_RSV_REL_TIME) {
4770 ASSERT(prop_list != NULL);
4771 un->un_reserve_release_time =
4772 prop_list->sdt_reserv_rel_time;
4773 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4774 "sd_set_vers1_properties: "
4775 "reservation release timeout set to %d\n",
4776 un->un_reserve_release_time);
4777 }
4778
4779 /*
4780 * Driver flag telling the driver to verify that no commands are pending
4781 * for a device before issuing a Test Unit Ready. This is a workaround
4782 * for a firmware bug in some Seagate eliteI drives.
4783 */
4784 if (flags & SD_CONF_BSET_TUR_CHECK) {
4785 un->un_f_cfg_tur_check = TRUE;
4786 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4787 "sd_set_vers1_properties: tur queue check set\n");
4788 }
4789
4790 if (flags & SD_CONF_BSET_MIN_THROTTLE) {
4791 un->un_min_throttle = prop_list->sdt_min_throttle;
4792 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4793 "sd_set_vers1_properties: min throttle set to %d\n",
4794 un->un_min_throttle);
4795 }
4796
4797 if (flags & SD_CONF_BSET_DISKSORT_DISABLED) {
4798 un->un_f_disksort_disabled =
4799 (prop_list->sdt_disk_sort_dis != 0) ?
4800 TRUE : FALSE;
4801 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4802 "sd_set_vers1_properties: disksort disabled "
4803 "flag set to %d\n",
4804 prop_list->sdt_disk_sort_dis);
4805 }
4806
4807 if (flags & SD_CONF_BSET_LUN_RESET_ENABLED) {
4808 un->un_f_lun_reset_enabled =
4809 (prop_list->sdt_lun_reset_enable != 0) ?
4810 TRUE : FALSE;
4811 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4812 "sd_set_vers1_properties: lun reset enabled "
4813 "flag set to %d\n",
4814 prop_list->sdt_lun_reset_enable);
4815 }
4816
4817 if (flags & SD_CONF_BSET_CACHE_IS_NV) {
4818 un->un_f_suppress_cache_flush =
4819 (prop_list->sdt_suppress_cache_flush != 0) ?
4820 TRUE : FALSE;
4821 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4822 "sd_set_vers1_properties: suppress_cache_flush "
4823 "flag set to %d\n",
4824 prop_list->sdt_suppress_cache_flush);
4825 }
4826
4827 if (flags & SD_CONF_BSET_PC_DISABLED) {
4828 un->un_f_power_condition_disabled =
4829 (prop_list->sdt_power_condition_dis != 0) ?
4830 TRUE : FALSE;
4831 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4832 "sd_set_vers1_properties: power_condition_disabled "
4833 "flag set to %d\n",
4834 prop_list->sdt_power_condition_dis);
4835 }
4836
4837 /*
4838 * Validate the throttle values.
4839 * If any of the numbers are invalid, set everything to defaults.
4840 */
4841 if ((un->un_throttle < SD_LOWEST_VALID_THROTTLE) ||
4842 (un->un_min_throttle < SD_LOWEST_VALID_THROTTLE) ||
4843 (un->un_min_throttle > un->un_throttle)) {
4844 un->un_saved_throttle = un->un_throttle = sd_max_throttle;
4845 un->un_min_throttle = sd_min_throttle;
4846 }
4847 }
4848
4849 /*
4850 * Function: sd_is_lsi()
4851 *
4852 * Description: Check for lsi devices, step through the static device
4853 * table to match vid/pid.
4854 *
4855 * Args: un - ptr to sd_lun
4856 *
4857 * Notes: When creating new LSI property, need to add the new LSI property
4858 * to this function.
4859 */
4860 static void
4861 sd_is_lsi(struct sd_lun *un)
4862 {
4863 char *id = NULL;
4864 int table_index;
4865 int idlen;
4866 void *prop;
4867
4868 ASSERT(un != NULL);
4869 for (table_index = 0; table_index < sd_disk_table_size;
4870 table_index++) {
4871 id = sd_disk_table[table_index].device_id;
4872 idlen = strlen(id);
4873 if (idlen == 0) {
4874 continue;
4875 }
4876
4877 if (sd_sdconf_id_match(un, id, idlen) == SD_SUCCESS) {
4878 prop = sd_disk_table[table_index].properties;
4879 if (prop == &lsi_properties ||
4880 prop == &lsi_oem_properties ||
4881 prop == &lsi_properties_scsi ||
4882 prop == &symbios_properties) {
4883 un->un_f_cfg_is_lsi = TRUE;
4884 }
4885 break;
4886 }
4887 }
4888 }
4889
4890 /*
4891 * Function: sd_get_physical_geometry
4892 *
4893 * Description: Retrieve the MODE SENSE page 3 (Format Device Page) and
4894 * MODE SENSE page 4 (Rigid Disk Drive Geometry Page) from the
4895 * target, and use this information to initialize the physical
4896 * geometry cache specified by pgeom_p.
4897 *
4898 * MODE SENSE is an optional command, so failure in this case
4899 * does not necessarily denote an error. We want to use the
4900 * MODE SENSE commands to derive the physical geometry of the
4901 * device, but if either command fails, the logical geometry is
4902 * used as the fallback for disk label geometry in cmlb.
4903 *
4904 * This requires that un->un_blockcount and un->un_tgt_blocksize
4905 * have already been initialized for the current target and
4906 * that the current values be passed as args so that we don't
4907 * end up ever trying to use -1 as a valid value. This could
4908 * happen if either value is reset while we're not holding
4909 * the mutex.
4910 *
4911 * Arguments: un - driver soft state (unit) structure
4912 * path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and
4913 * the normal command waitq, or SD_PATH_DIRECT_PRIORITY
4914 * to use the USCSI "direct" chain and bypass the normal
4915 * command waitq.
4916 *
4917 * Context: Kernel thread only (can sleep).
4918 */
4919
4920 static int
4921 sd_get_physical_geometry(struct sd_lun *un, cmlb_geom_t *pgeom_p,
4922 diskaddr_t capacity, int lbasize, int path_flag)
4923 {
4924 struct mode_format *page3p;
4925 struct mode_geometry *page4p;
4926 struct mode_header *headerp;
4927 int sector_size;
4928 int nsect;
4929 int nhead;
4930 int ncyl;
4931 int intrlv;
4932 int spc;
4933 diskaddr_t modesense_capacity;
4934 int rpm;
4935 int bd_len;
4936 int mode_header_length;
4937 uchar_t *p3bufp;
4938 uchar_t *p4bufp;
4939 int cdbsize;
4940 int ret = EIO;
4941 sd_ssc_t *ssc;
4942 int status;
4943
4944 ASSERT(un != NULL);
4945
4946 if (lbasize == 0) {
4947 if (ISCD(un)) {
4948 lbasize = 2048;
4949 } else {
4950 lbasize = un->un_sys_blocksize;
4951 }
4952 }
4953 pgeom_p->g_secsize = (unsigned short)lbasize;
4954
4955 /*
4956 * If the unit is a cd/dvd drive MODE SENSE page three
4957 * and MODE SENSE page four are reserved (see SBC spec
4958 * and MMC spec). To prevent soft errors just return
4959 * using the default LBA size.
4960 *
4961 * Since SATA MODE SENSE function (sata_txlt_mode_sense()) does not
4962 * implement support for mode pages 3 and 4 return here to prevent
4963 * illegal requests on SATA drives.
4964 *
4965 * These pages are also reserved in SBC-2 and later. We assume SBC-2
4966 * or later for a direct-attached block device if the SCSI version is
4967 * at least SPC-3.
4968 */
4969
4970 if (ISCD(un) ||
4971 un->un_interconnect_type == SD_INTERCONNECT_SATA ||
4972 (un->un_ctype == CTYPE_CCS && SD_INQUIRY(un)->inq_ansi >= 5))
4973 return (ret);
4974
4975 cdbsize = (un->un_f_cfg_is_atapi == TRUE) ? CDB_GROUP2 : CDB_GROUP0;
4976
4977 /*
4978 * Retrieve MODE SENSE page 3 - Format Device Page
4979 */
4980 p3bufp = kmem_zalloc(SD_MODE_SENSE_PAGE3_LENGTH, KM_SLEEP);
4981 ssc = sd_ssc_init(un);
4982 status = sd_send_scsi_MODE_SENSE(ssc, cdbsize, p3bufp,
4983 SD_MODE_SENSE_PAGE3_LENGTH, SD_MODE_SENSE_PAGE3_CODE, path_flag);
4984 if (status != 0) {
4985 SD_ERROR(SD_LOG_COMMON, un,
4986 "sd_get_physical_geometry: mode sense page 3 failed\n");
4987 goto page3_exit;
4988 }
4989
4990 /*
4991 * Determine size of Block Descriptors in order to locate the mode
4992 * page data. ATAPI devices return 0, SCSI devices should return
4993 * MODE_BLK_DESC_LENGTH.
4994 */
4995 headerp = (struct mode_header *)p3bufp;
4996 if (un->un_f_cfg_is_atapi == TRUE) {
4997 struct mode_header_grp2 *mhp =
4998 (struct mode_header_grp2 *)headerp;
4999 mode_header_length = MODE_HEADER_LENGTH_GRP2;
5000 bd_len = (mhp->bdesc_length_hi << 8) | mhp->bdesc_length_lo;
5001 } else {
5002 mode_header_length = MODE_HEADER_LENGTH;
5003 bd_len = ((struct mode_header *)headerp)->bdesc_length;
5004 }
5005
5006 if (bd_len > MODE_BLK_DESC_LENGTH) {
5007 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, SD_LOG_COMMON,
5008 "sd_get_physical_geometry: received unexpected bd_len "
5009 "of %d, page3\n", bd_len);
5010 status = EIO;
5011 goto page3_exit;
5012 }
5013
5014 page3p = (struct mode_format *)
5015 ((caddr_t)headerp + mode_header_length + bd_len);
5016
5017 if (page3p->mode_page.code != SD_MODE_SENSE_PAGE3_CODE) {
5018 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, SD_LOG_COMMON,
5019 "sd_get_physical_geometry: mode sense pg3 code mismatch "
5020 "%d\n", page3p->mode_page.code);
5021 status = EIO;
5022 goto page3_exit;
5023 }
5024
5025 /*
5026 * Use this physical geometry data only if BOTH MODE SENSE commands
5027 * complete successfully; otherwise, revert to the logical geometry.
5028 * So, we need to save everything in temporary variables.
5029 */
5030 sector_size = BE_16(page3p->data_bytes_sect);
5031
5032 /*
5033 * 1243403: The NEC D38x7 drives do not support MODE SENSE sector size
5034 */
5035 if (sector_size == 0) {
5036 sector_size = un->un_sys_blocksize;
5037 } else {
5038 sector_size &= ~(un->un_sys_blocksize - 1);
5039 }
5040
5041 nsect = BE_16(page3p->sect_track);
5042 intrlv = BE_16(page3p->interleave);
5043
5044 SD_INFO(SD_LOG_COMMON, un,
5045 "sd_get_physical_geometry: Format Parameters (page 3)\n");
5046 SD_INFO(SD_LOG_COMMON, un,
5047 " mode page: %d; nsect: %d; sector size: %d;\n",
5048 page3p->mode_page.code, nsect, sector_size);
5049 SD_INFO(SD_LOG_COMMON, un,
5050 " interleave: %d; track skew: %d; cylinder skew: %d;\n", intrlv,
5051 BE_16(page3p->track_skew),
5052 BE_16(page3p->cylinder_skew));
5053
5054 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
5055
5056 /*
5057 * Retrieve MODE SENSE page 4 - Rigid Disk Drive Geometry Page
5058 */
5059 p4bufp = kmem_zalloc(SD_MODE_SENSE_PAGE4_LENGTH, KM_SLEEP);
5060 status = sd_send_scsi_MODE_SENSE(ssc, cdbsize, p4bufp,
5061 SD_MODE_SENSE_PAGE4_LENGTH, SD_MODE_SENSE_PAGE4_CODE, path_flag);
5062 if (status != 0) {
5063 SD_ERROR(SD_LOG_COMMON, un,
5064 "sd_get_physical_geometry: mode sense page 4 failed\n");
5065 goto page4_exit;
5066 }
5067
5068 /*
5069 * Determine size of Block Descriptors in order to locate the mode
5070 * page data. ATAPI devices return 0, SCSI devices should return
5071 * MODE_BLK_DESC_LENGTH.
5072 */
5073 headerp = (struct mode_header *)p4bufp;
5074 if (un->un_f_cfg_is_atapi == TRUE) {
5075 struct mode_header_grp2 *mhp =
5076 (struct mode_header_grp2 *)headerp;
5077 bd_len = (mhp->bdesc_length_hi << 8) | mhp->bdesc_length_lo;
5078 } else {
5079 bd_len = ((struct mode_header *)headerp)->bdesc_length;
5080 }
5081
5082 if (bd_len > MODE_BLK_DESC_LENGTH) {
5083 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, SD_LOG_COMMON,
5084 "sd_get_physical_geometry: received unexpected bd_len of "
5085 "%d, page4\n", bd_len);
5086 status = EIO;
5087 goto page4_exit;
5088 }
5089
5090 page4p = (struct mode_geometry *)
5091 ((caddr_t)headerp + mode_header_length + bd_len);
5092
5093 if (page4p->mode_page.code != SD_MODE_SENSE_PAGE4_CODE) {
5094 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, SD_LOG_COMMON,
5095 "sd_get_physical_geometry: mode sense pg4 code mismatch "
5096 "%d\n", page4p->mode_page.code);
5097 status = EIO;
5098 goto page4_exit;
5099 }
5100
5101 /*
5102 * Stash the data now, after we know that both commands completed.
5103 */
5104
5105
5106 nhead = (int)page4p->heads; /* uchar, so no conversion needed */
5107 spc = nhead * nsect;
5108 ncyl = (page4p->cyl_ub << 16) + (page4p->cyl_mb << 8) + page4p->cyl_lb;
5109 rpm = BE_16(page4p->rpm);
5110
5111 modesense_capacity = spc * ncyl;
5112
5113 SD_INFO(SD_LOG_COMMON, un,
5114 "sd_get_physical_geometry: Geometry Parameters (page 4)\n");
5115 SD_INFO(SD_LOG_COMMON, un,
5116 " cylinders: %d; heads: %d; rpm: %d;\n", ncyl, nhead, rpm);
5117 SD_INFO(SD_LOG_COMMON, un,
5118 " computed capacity(h*s*c): %d;\n", modesense_capacity);
5119 SD_INFO(SD_LOG_COMMON, un, " pgeom_p: %p; read cap: %d\n",
5120 (void *)pgeom_p, capacity);
5121
5122 /*
5123 * Compensate if the drive's geometry is not rectangular, i.e.,
5124 * the product of C * H * S returned by MODE SENSE >= that returned
5125 * by read capacity. This is an idiosyncrasy of the original x86
5126 * disk subsystem.
5127 */
5128 if (modesense_capacity >= capacity) {
5129 SD_INFO(SD_LOG_COMMON, un,
5130 "sd_get_physical_geometry: adjusting acyl; "
5131 "old: %d; new: %d\n", pgeom_p->g_acyl,
5132 (modesense_capacity - capacity + spc - 1) / spc);
5133 if (sector_size != 0) {
5134 /* 1243403: NEC D38x7 drives don't support sec size */
5135 pgeom_p->g_secsize = (unsigned short)sector_size;
5136 }
5137 pgeom_p->g_nsect = (unsigned short)nsect;
5138 pgeom_p->g_nhead = (unsigned short)nhead;
5139 pgeom_p->g_capacity = capacity;
5140 pgeom_p->g_acyl =
5141 (modesense_capacity - pgeom_p->g_capacity + spc - 1) / spc;
5142 pgeom_p->g_ncyl = ncyl - pgeom_p->g_acyl;
5143 }
5144
5145 pgeom_p->g_rpm = (unsigned short)rpm;
5146 pgeom_p->g_intrlv = (unsigned short)intrlv;
5147 ret = 0;
5148
5149 SD_INFO(SD_LOG_COMMON, un,
5150 "sd_get_physical_geometry: mode sense geometry:\n");
5151 SD_INFO(SD_LOG_COMMON, un,
5152 " nsect: %d; sector size: %d; interlv: %d\n",
5153 nsect, sector_size, intrlv);
5154 SD_INFO(SD_LOG_COMMON, un,
5155 " nhead: %d; ncyl: %d; rpm: %d; capacity(ms): %d\n",
5156 nhead, ncyl, rpm, modesense_capacity);
5157 SD_INFO(SD_LOG_COMMON, un,
5158 "sd_get_physical_geometry: (cached)\n");
5159 SD_INFO(SD_LOG_COMMON, un,
5160 " ncyl: %ld; acyl: %d; nhead: %d; nsect: %d\n",
5161 pgeom_p->g_ncyl, pgeom_p->g_acyl,
5162 pgeom_p->g_nhead, pgeom_p->g_nsect);
5163 SD_INFO(SD_LOG_COMMON, un,
5164 " lbasize: %d; capacity: %ld; intrlv: %d; rpm: %d\n",
5165 pgeom_p->g_secsize, pgeom_p->g_capacity,
5166 pgeom_p->g_intrlv, pgeom_p->g_rpm);
5167 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
5168
5169 page4_exit:
5170 kmem_free(p4bufp, SD_MODE_SENSE_PAGE4_LENGTH);
5171
5172 page3_exit:
5173 kmem_free(p3bufp, SD_MODE_SENSE_PAGE3_LENGTH);
5174
5175 if (status != 0) {
5176 if (status == EIO) {
5177 /*
5178 * Some disks do not support mode sense(6), we
5179 * should ignore this kind of error(sense key is
5180 * 0x5 - illegal request).
5181 */
5182 uint8_t *sensep;
5183 int senlen;
5184
5185 sensep = (uint8_t *)ssc->ssc_uscsi_cmd->uscsi_rqbuf;
5186 senlen = (int)(ssc->ssc_uscsi_cmd->uscsi_rqlen -
5187 ssc->ssc_uscsi_cmd->uscsi_rqresid);
5188
5189 if (senlen > 0 &&
5190 scsi_sense_key(sensep) == KEY_ILLEGAL_REQUEST) {
5191 sd_ssc_assessment(ssc,
5192 SD_FMT_IGNORE_COMPROMISE);
5193 } else {
5194 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
5195 }
5196 } else {
5197 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
5198 }
5199 }
5200 sd_ssc_fini(ssc);
5201 return (ret);
5202 }
5203
5204 /*
5205 * Function: sd_get_virtual_geometry
5206 *
5207 * Description: Ask the controller to tell us about the target device.
5208 *
5209 * Arguments: un - pointer to softstate
5210 * capacity - disk capacity in #blocks
5211 * lbasize - disk block size in bytes
5212 *
5213 * Context: Kernel thread only
5214 */
5215
5216 static int
5217 sd_get_virtual_geometry(struct sd_lun *un, cmlb_geom_t *lgeom_p,
5218 diskaddr_t capacity, int lbasize)
5219 {
5220 uint_t geombuf;
5221 int spc;
5222
5223 ASSERT(un != NULL);
5224
5225 /* Set sector size, and total number of sectors */
5226 (void) scsi_ifsetcap(SD_ADDRESS(un), "sector-size", lbasize, 1);
5227 (void) scsi_ifsetcap(SD_ADDRESS(un), "total-sectors", capacity, 1);
5228
5229 /* Let the HBA tell us its geometry */
5230 geombuf = (uint_t)scsi_ifgetcap(SD_ADDRESS(un), "geometry", 1);
5231
5232 /* A value of -1 indicates an undefined "geometry" property */
5233 if (geombuf == (-1)) {
5234 return (EINVAL);
5235 }
5236
5237 /* Initialize the logical geometry cache. */
5238 lgeom_p->g_nhead = (geombuf >> 16) & 0xffff;
5239 lgeom_p->g_nsect = geombuf & 0xffff;
5240 lgeom_p->g_secsize = un->un_sys_blocksize;
5241
5242 spc = lgeom_p->g_nhead * lgeom_p->g_nsect;
5243
5244 /*
5245 * Note: The driver originally converted the capacity value from
5246 * target blocks to system blocks. However, the capacity value passed
5247 * to this routine is already in terms of system blocks (this scaling
5248 * is done when the READ CAPACITY command is issued and processed).
5249 * This 'error' may have gone undetected because the usage of g_ncyl
5250 * (which is based upon g_capacity) is very limited within the driver
5251 */
5252 lgeom_p->g_capacity = capacity;
5253
5254 /*
5255 * Set ncyl to zero if the hba returned a zero nhead or nsect value. The
5256 * hba may return zero values if the device has been removed.
5257 */
5258 if (spc == 0) {
5259 lgeom_p->g_ncyl = 0;
5260 } else {
5261 lgeom_p->g_ncyl = lgeom_p->g_capacity / spc;
5262 }
5263 lgeom_p->g_acyl = 0;
5264
5265 SD_INFO(SD_LOG_COMMON, un, "sd_get_virtual_geometry: (cached)\n");
5266 return (0);
5267
5268 }
5269 /*
5270 * Function: sd_update_block_info
5271 *
5272 * Description: Calculate a byte count to sector count bitshift value
5273 * from sector size.
5274 *
5275 * Arguments: un: unit struct.
5276 * lbasize: new target sector size
5277 * capacity: new target capacity, ie. block count
5278 *
5279 * Context: Kernel thread context
5280 */
5281
5282 static void
5283 sd_update_block_info(struct sd_lun *un, uint32_t lbasize, uint64_t capacity)
5284 {
5285 if (lbasize != 0) {
5286 un->un_tgt_blocksize = lbasize;
5287 un->un_f_tgt_blocksize_is_valid = TRUE;
5288 if (!un->un_f_has_removable_media) {
5289 un->un_sys_blocksize = lbasize;
5290 }
5291 }
5292
5293 if (capacity != 0) {
5294 un->un_blockcount = capacity;
5295 un->un_f_blockcount_is_valid = TRUE;
5296
5297 /*
5298 * The capacity has changed so update the errstats.
5299 */
5300 if (un->un_errstats != NULL) {
5301 struct sd_errstats *stp;
5302
5303 capacity *= un->un_sys_blocksize;
5304 stp = (struct sd_errstats *)un->un_errstats->ks_data;
5305 if (stp->sd_capacity.value.ui64 < capacity)
5306 stp->sd_capacity.value.ui64 = capacity;
5307 }
5308 }
5309 }
5310
5311
5312 /*
5313 * Function: sd_register_devid
5314 *
5315 * Description: This routine will obtain the device id information from the
5316 * target, obtain the serial number, and register the device
5317 * id with the ddi framework.
5318 *
5319 * Arguments: devi - the system's dev_info_t for the device.
5320 * un - driver soft state (unit) structure
5321 * reservation_flag - indicates if a reservation conflict
5322 * occurred during attach
5323 *
5324 * Context: Kernel Thread
5325 */
5326 static void
5327 sd_register_devid(sd_ssc_t *ssc, dev_info_t *devi, int reservation_flag)
5328 {
5329 int rval = 0;
5330 uchar_t *inq80 = NULL;
5331 size_t inq80_len = MAX_INQUIRY_SIZE;
5332 size_t inq80_resid = 0;
5333 uchar_t *inq83 = NULL;
5334 size_t inq83_len = MAX_INQUIRY_SIZE;
5335 size_t inq83_resid = 0;
5336 int dlen, len;
5337 char *sn;
5338 struct sd_lun *un;
5339
5340 ASSERT(ssc != NULL);
5341 un = ssc->ssc_un;
5342 ASSERT(un != NULL);
5343 ASSERT(mutex_owned(SD_MUTEX(un)));
5344 ASSERT((SD_DEVINFO(un)) == devi);
5345
5346
5347 /*
5348 * We check the availability of the World Wide Name (0x83) and Unit
5349 * Serial Number (0x80) pages in sd_check_vpd_page_support(), and using
5350 * un_vpd_page_mask from them, we decide which way to get the WWN. If
5351 * 0x83 is available, that is the best choice. Our next choice is
5352 * 0x80. If neither are available, we munge the devid from the device
5353 * vid/pid/serial # for Sun qualified disks, or use the ddi framework
5354 * to fabricate a devid for non-Sun qualified disks.
5355 */
5356 if (sd_check_vpd_page_support(ssc) == 0) {
5357 /* collect page 80 data if available */
5358 if (un->un_vpd_page_mask & SD_VPD_UNIT_SERIAL_PG) {
5359
5360 mutex_exit(SD_MUTEX(un));
5361 inq80 = kmem_zalloc(inq80_len, KM_SLEEP);
5362
5363 rval = sd_send_scsi_INQUIRY(ssc, inq80, inq80_len,
5364 0x01, 0x80, &inq80_resid);
5365
5366 if (rval != 0) {
5367 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
5368 kmem_free(inq80, inq80_len);
5369 inq80 = NULL;
5370 inq80_len = 0;
5371 } else if (ddi_prop_exists(
5372 DDI_DEV_T_NONE, SD_DEVINFO(un),
5373 DDI_PROP_NOTPROM | DDI_PROP_DONTPASS,
5374 INQUIRY_SERIAL_NO) == 0) {
5375 /*
5376 * If we don't already have a serial number
5377 * property, do quick verify of data returned
5378 * and define property.
5379 */
5380 dlen = inq80_len - inq80_resid;
5381 len = (size_t)inq80[3];
5382 if ((dlen >= 4) && ((len + 4) <= dlen)) {
5383 /*
5384 * Ensure sn termination, skip leading
5385 * blanks, and create property
5386 * 'inquiry-serial-no'.
5387 */
5388 sn = (char *)&inq80[4];
5389 sn[len] = 0;
5390 while (*sn && (*sn == ' '))
5391 sn++;
5392 if (*sn) {
5393 (void) ddi_prop_update_string(
5394 DDI_DEV_T_NONE,
5395 SD_DEVINFO(un),
5396 INQUIRY_SERIAL_NO, sn);
5397 }
5398 }
5399 }
5400 mutex_enter(SD_MUTEX(un));
5401 }
5402
5403 /* collect page 83 data if available */
5404 if (un->un_vpd_page_mask & SD_VPD_DEVID_WWN_PG) {
5405 mutex_exit(SD_MUTEX(un));
5406 inq83 = kmem_zalloc(inq83_len, KM_SLEEP);
5407
5408 rval = sd_send_scsi_INQUIRY(ssc, inq83, inq83_len,
5409 0x01, 0x83, &inq83_resid);
5410
5411 if (rval != 0) {
5412 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
5413 kmem_free(inq83, inq83_len);
5414 inq83 = NULL;
5415 inq83_len = 0;
5416 }
5417 mutex_enter(SD_MUTEX(un));
5418 }
5419 }
5420
5421 /*
5422 * If transport has already registered a devid for this target
5423 * then that takes precedence over the driver's determination
5424 * of the devid.
5425 *
5426 * NOTE: The reason this check is done here instead of at the beginning
5427 * of the function is to allow the code above to create the
5428 * 'inquiry-serial-no' property.
5429 */
5430 if (ddi_devid_get(SD_DEVINFO(un), &un->un_devid) == DDI_SUCCESS) {
5431 ASSERT(un->un_devid);
5432 un->un_f_devid_transport_defined = TRUE;
5433 goto cleanup; /* use devid registered by the transport */
5434 }
5435
5436 /*
5437 * This is the case of antiquated Sun disk drives that have the
5438 * FAB_DEVID property set in the disk_table. These drives
5439 * manage the devid's by storing them in last 2 available sectors
5440 * on the drive and have them fabricated by the ddi layer by calling
5441 * ddi_devid_init and passing the DEVID_FAB flag.
5442 */
5443 if (un->un_f_opt_fab_devid == TRUE) {
5444 /*
5445 * Depending on EINVAL isn't reliable, since a reserved disk
5446 * may result in invalid geometry, so check to make sure a
5447 * reservation conflict did not occur during attach.
5448 */
5449 if ((sd_get_devid(ssc) == EINVAL) &&
5450 (reservation_flag != SD_TARGET_IS_RESERVED)) {
5451 /*
5452 * The devid is invalid AND there is no reservation
5453 * conflict. Fabricate a new devid.
5454 */
5455 (void) sd_create_devid(ssc);
5456 }
5457
5458 /* Register the devid if it exists */
5459 if (un->un_devid != NULL) {
5460 (void) ddi_devid_register(SD_DEVINFO(un),
5461 un->un_devid);
5462 SD_INFO(SD_LOG_ATTACH_DETACH, un,
5463 "sd_register_devid: Devid Fabricated\n");
5464 }
5465 goto cleanup;
5466 }
5467
5468 /* encode best devid possible based on data available */
5469 if (ddi_devid_scsi_encode(DEVID_SCSI_ENCODE_VERSION_LATEST,
5470 (char *)ddi_driver_name(SD_DEVINFO(un)),
5471 (uchar_t *)SD_INQUIRY(un), sizeof (*SD_INQUIRY(un)),
5472 inq80, inq80_len - inq80_resid, inq83, inq83_len -
5473 inq83_resid, &un->un_devid) == DDI_SUCCESS) {
5474
5475 /* devid successfully encoded, register devid */
5476 (void) ddi_devid_register(SD_DEVINFO(un), un->un_devid);
5477
5478 } else {
5479 /*
5480 * Unable to encode a devid based on data available.
5481 * This is not a Sun qualified disk. Older Sun disk
5482 * drives that have the SD_FAB_DEVID property
5483 * set in the disk_table and non Sun qualified
5484 * disks are treated in the same manner. These
5485 * drives manage the devid's by storing them in
5486 * last 2 available sectors on the drive and
5487 * have them fabricated by the ddi layer by
5488 * calling ddi_devid_init and passing the
5489 * DEVID_FAB flag.
5490 * Create a fabricate devid only if there's no
5491 * fabricate devid existed.
5492 */
5493 if (sd_get_devid(ssc) == EINVAL) {
5494 (void) sd_create_devid(ssc);
5495 }
5496 un->un_f_opt_fab_devid = TRUE;
5497
5498 /* Register the devid if it exists */
5499 if (un->un_devid != NULL) {
5500 (void) ddi_devid_register(SD_DEVINFO(un),
5501 un->un_devid);
5502 SD_INFO(SD_LOG_ATTACH_DETACH, un,
5503 "sd_register_devid: devid fabricated using "
5504 "ddi framework\n");
5505 }
5506 }
5507
5508 cleanup:
5509 /* clean up resources */
5510 if (inq80 != NULL) {
5511 kmem_free(inq80, inq80_len);
5512 }
5513 if (inq83 != NULL) {
5514 kmem_free(inq83, inq83_len);
5515 }
5516 }
5517
5518
5519
5520 /*
5521 * Function: sd_get_devid
5522 *
5523 * Description: This routine will return 0 if a valid device id has been
5524 * obtained from the target and stored in the soft state. If a
5525 * valid device id has not been previously read and stored, a
5526 * read attempt will be made.
5527 *
5528 * Arguments: un - driver soft state (unit) structure
5529 *
5530 * Return Code: 0 if we successfully get the device id
5531 *
5532 * Context: Kernel Thread
5533 */
5534
5535 static int
5536 sd_get_devid(sd_ssc_t *ssc)
5537 {
5538 struct dk_devid *dkdevid;
5539 ddi_devid_t tmpid;
5540 uint_t *ip;
5541 size_t sz;
5542 diskaddr_t blk;
5543 int status;
5544 int chksum;
5545 int i;
5546 size_t buffer_size;
5547 struct sd_lun *un;
5548
5549 ASSERT(ssc != NULL);
5550 un = ssc->ssc_un;
5551 ASSERT(un != NULL);
5552 ASSERT(mutex_owned(SD_MUTEX(un)));
5553
5554 SD_TRACE(SD_LOG_ATTACH_DETACH, un, "sd_get_devid: entry: un: 0x%p\n",
5555 un);
5556
5557 if (un->un_devid != NULL) {
5558 return (0);
5559 }
5560
5561 mutex_exit(SD_MUTEX(un));
5562 if (cmlb_get_devid_block(un->un_cmlbhandle, &blk,
5563 (void *)SD_PATH_DIRECT) != 0) {
5564 mutex_enter(SD_MUTEX(un));
5565 return (EINVAL);
5566 }
5567
5568 /*
5569 * Read and verify device id, stored in the reserved cylinders at the
5570 * end of the disk. Backup label is on the odd sectors of the last
5571 * track of the last cylinder. Device id will be on track of the next
5572 * to last cylinder.
5573 */
5574 mutex_enter(SD_MUTEX(un));
5575 buffer_size = SD_REQBYTES2TGTBYTES(un, sizeof (struct dk_devid));
5576 mutex_exit(SD_MUTEX(un));
5577 dkdevid = kmem_alloc(buffer_size, KM_SLEEP);
5578 status = sd_send_scsi_READ(ssc, dkdevid, buffer_size, blk,
5579 SD_PATH_DIRECT);
5580
5581 if (status != 0) {
5582 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
5583 goto error;
5584 }
5585
5586 /* Validate the revision */
5587 if ((dkdevid->dkd_rev_hi != DK_DEVID_REV_MSB) ||
5588 (dkdevid->dkd_rev_lo != DK_DEVID_REV_LSB)) {
5589 status = EINVAL;
5590 goto error;
5591 }
5592
5593 /* Calculate the checksum */
5594 chksum = 0;
5595 ip = (uint_t *)dkdevid;
5596 for (i = 0; i < ((DEV_BSIZE - sizeof (int)) / sizeof (int));
5597 i++) {
5598 chksum ^= ip[i];
5599 }
5600
5601 /* Compare the checksums */
5602 if (DKD_GETCHKSUM(dkdevid) != chksum) {
5603 status = EINVAL;
5604 goto error;
5605 }
5606
5607 /* Validate the device id */
5608 if (ddi_devid_valid((ddi_devid_t)&dkdevid->dkd_devid) != DDI_SUCCESS) {
5609 status = EINVAL;
5610 goto error;
5611 }
5612
5613 /*
5614 * Store the device id in the driver soft state
5615 */
5616 sz = ddi_devid_sizeof((ddi_devid_t)&dkdevid->dkd_devid);
5617 tmpid = kmem_alloc(sz, KM_SLEEP);
5618
5619 mutex_enter(SD_MUTEX(un));
5620
5621 un->un_devid = tmpid;
5622 bcopy(&dkdevid->dkd_devid, un->un_devid, sz);
5623
5624 kmem_free(dkdevid, buffer_size);
5625
5626 SD_TRACE(SD_LOG_ATTACH_DETACH, un, "sd_get_devid: exit: un:0x%p\n", un);
5627
5628 return (status);
5629 error:
5630 mutex_enter(SD_MUTEX(un));
5631 kmem_free(dkdevid, buffer_size);
5632 return (status);
5633 }
5634
5635
5636 /*
5637 * Function: sd_create_devid
5638 *
5639 * Description: This routine will fabricate the device id and write it
5640 * to the disk.
5641 *
5642 * Arguments: un - driver soft state (unit) structure
5643 *
5644 * Return Code: value of the fabricated device id
5645 *
5646 * Context: Kernel Thread
5647 */
5648
5649 static ddi_devid_t
5650 sd_create_devid(sd_ssc_t *ssc)
5651 {
5652 struct sd_lun *un;
5653
5654 ASSERT(ssc != NULL);
5655 un = ssc->ssc_un;
5656 ASSERT(un != NULL);
5657
5658 /* Fabricate the devid */
5659 if (ddi_devid_init(SD_DEVINFO(un), DEVID_FAB, 0, NULL, &un->un_devid)
5660 == DDI_FAILURE) {
5661 return (NULL);
5662 }
5663
5664 /* Write the devid to disk */
5665 if (sd_write_deviceid(ssc) != 0) {
5666 ddi_devid_free(un->un_devid);
5667 un->un_devid = NULL;
5668 }
5669
5670 return (un->un_devid);
5671 }
5672
5673
5674 /*
5675 * Function: sd_write_deviceid
5676 *
5677 * Description: This routine will write the device id to the disk
5678 * reserved sector.
5679 *
5680 * Arguments: un - driver soft state (unit) structure
5681 *
5682 * Return Code: EINVAL
5683 * value returned by sd_send_scsi_cmd
5684 *
5685 * Context: Kernel Thread
5686 */
5687
5688 static int
5689 sd_write_deviceid(sd_ssc_t *ssc)
5690 {
5691 struct dk_devid *dkdevid;
5692 uchar_t *buf;
5693 diskaddr_t blk;
5694 uint_t *ip, chksum;
5695 int status;
5696 int i;
5697 struct sd_lun *un;
5698
5699 ASSERT(ssc != NULL);
5700 un = ssc->ssc_un;
5701 ASSERT(un != NULL);
5702 ASSERT(mutex_owned(SD_MUTEX(un)));
5703
5704 mutex_exit(SD_MUTEX(un));
5705 if (cmlb_get_devid_block(un->un_cmlbhandle, &blk,
5706 (void *)SD_PATH_DIRECT) != 0) {
5707 mutex_enter(SD_MUTEX(un));
5708 return (-1);
5709 }
5710
5711
5712 /* Allocate the buffer */
5713 buf = kmem_zalloc(un->un_sys_blocksize, KM_SLEEP);
5714 dkdevid = (struct dk_devid *)buf;
5715
5716 /* Fill in the revision */
5717 dkdevid->dkd_rev_hi = DK_DEVID_REV_MSB;
5718 dkdevid->dkd_rev_lo = DK_DEVID_REV_LSB;
5719
5720 /* Copy in the device id */
5721 mutex_enter(SD_MUTEX(un));
5722 bcopy(un->un_devid, &dkdevid->dkd_devid,
5723 ddi_devid_sizeof(un->un_devid));
5724 mutex_exit(SD_MUTEX(un));
5725
5726 /* Calculate the checksum */
5727 chksum = 0;
5728 ip = (uint_t *)dkdevid;
5729 for (i = 0; i < ((DEV_BSIZE - sizeof (int)) / sizeof (int));
5730 i++) {
5731 chksum ^= ip[i];
5732 }
5733
5734 /* Fill-in checksum */
5735 DKD_FORMCHKSUM(chksum, dkdevid);
5736
5737 /* Write the reserved sector */
5738 status = sd_send_scsi_WRITE(ssc, buf, un->un_sys_blocksize, blk,
5739 SD_PATH_DIRECT);
5740 if (status != 0)
5741 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
5742
5743 kmem_free(buf, un->un_sys_blocksize);
5744
5745 mutex_enter(SD_MUTEX(un));
5746 return (status);
5747 }
5748
5749
5750 /*
5751 * Function: sd_check_vpd_page_support
5752 *
5753 * Description: This routine sends an inquiry command with the EVPD bit set and
5754 * a page code of 0x00 to the device. It is used to determine which
5755 * vital product pages are available to find the devid. We are
5756 * looking for pages 0x83 0x80 or 0xB1. If we return a negative 1,
5757 * the device does not support that command.
5758 *
5759 * Arguments: un - driver soft state (unit) structure
5760 *
5761 * Return Code: 0 - success
5762 * 1 - check condition
5763 *
5764 * Context: This routine can sleep.
5765 */
5766
5767 static int
5768 sd_check_vpd_page_support(sd_ssc_t *ssc)
5769 {
5770 uchar_t *page_list = NULL;
5771 uchar_t page_length = 0xff; /* Use max possible length */
5772 uchar_t evpd = 0x01; /* Set the EVPD bit */
5773 uchar_t page_code = 0x00; /* Supported VPD Pages */
5774 int rval = 0;
5775 int counter;
5776 struct sd_lun *un;
5777
5778 ASSERT(ssc != NULL);
5779 un = ssc->ssc_un;
5780 ASSERT(un != NULL);
5781 ASSERT(mutex_owned(SD_MUTEX(un)));
5782
5783 mutex_exit(SD_MUTEX(un));
5784
5785 /*
5786 * We'll set the page length to the maximum to save figuring it out
5787 * with an additional call.
5788 */
5789 page_list = kmem_zalloc(page_length, KM_SLEEP);
5790
5791 rval = sd_send_scsi_INQUIRY(ssc, page_list, page_length, evpd,
5792 page_code, NULL);
5793
5794 if (rval != 0)
5795 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
5796
5797 mutex_enter(SD_MUTEX(un));
5798
5799 /*
5800 * Now we must validate that the device accepted the command, as some
5801 * drives do not support it. If the drive does support it, we will
5802 * return 0, and the supported pages will be in un_vpd_page_mask. If
5803 * not, we return -1.
5804 */
5805 if ((rval == 0) && (page_list[VPD_MODE_PAGE] == 0x00)) {
5806 /* Loop to find one of the 2 pages we need */
5807 counter = 4; /* Supported pages start at byte 4, with 0x00 */
5808
5809 /*
5810 * Pages are returned in ascending order, and 0x83 is what we
5811 * are hoping for.
5812 */
5813 while ((page_list[counter] <= 0xB1) &&
5814 (counter <= (page_list[VPD_PAGE_LENGTH] +
5815 VPD_HEAD_OFFSET))) {
5816 /*
5817 * Add 3 because page_list[3] is the number of
5818 * pages minus 3
5819 */
5820
5821 switch (page_list[counter]) {
5822 case 0x00:
5823 un->un_vpd_page_mask |= SD_VPD_SUPPORTED_PG;
5824 break;
5825 case 0x80:
5826 un->un_vpd_page_mask |= SD_VPD_UNIT_SERIAL_PG;
5827 break;
5828 case 0x81:
5829 un->un_vpd_page_mask |= SD_VPD_OPERATING_PG;
5830 break;
5831 case 0x82:
5832 un->un_vpd_page_mask |= SD_VPD_ASCII_OP_PG;
5833 break;
5834 case 0x83:
5835 un->un_vpd_page_mask |= SD_VPD_DEVID_WWN_PG;
5836 break;
5837 case 0x86:
5838 un->un_vpd_page_mask |= SD_VPD_EXTENDED_DATA_PG;
5839 break;
5840 case 0xB1:
5841 un->un_vpd_page_mask |= SD_VPD_DEV_CHARACTER_PG;
5842 break;
5843 }
5844 counter++;
5845 }
5846
5847 } else {
5848 rval = -1;
5849
5850 SD_INFO(SD_LOG_ATTACH_DETACH, un,
5851 "sd_check_vpd_page_support: This drive does not implement "
5852 "VPD pages.\n");
5853 }
5854
5855 kmem_free(page_list, page_length);
5856
5857 return (rval);
5858 }
5859
5860
5861 /*
5862 * Function: sd_setup_pm
5863 *
5864 * Description: Initialize Power Management on the device
5865 *
5866 * Context: Kernel Thread
5867 */
5868
5869 static void
5870 sd_setup_pm(sd_ssc_t *ssc, dev_info_t *devi)
5871 {
5872 uint_t log_page_size;
5873 uchar_t *log_page_data;
5874 int rval = 0;
5875 struct sd_lun *un;
5876
5877 ASSERT(ssc != NULL);
5878 un = ssc->ssc_un;
5879 ASSERT(un != NULL);
5880
5881 /*
5882 * Since we are called from attach, holding a mutex for
5883 * un is unnecessary. Because some of the routines called
5884 * from here require SD_MUTEX to not be held, assert this
5885 * right up front.
5886 */
5887 ASSERT(!mutex_owned(SD_MUTEX(un)));
5888 /*
5889 * Since the sd device does not have the 'reg' property,
5890 * cpr will not call its DDI_SUSPEND/DDI_RESUME entries.
5891 * The following code is to tell cpr that this device
5892 * DOES need to be suspended and resumed.
5893 */
5894 (void) ddi_prop_update_string(DDI_DEV_T_NONE, devi,
5895 "pm-hardware-state", "needs-suspend-resume");
5896
5897 /*
5898 * This complies with the new power management framework
5899 * for certain desktop machines. Create the pm_components
5900 * property as a string array property.
5901 * If un_f_pm_supported is TRUE, that means the disk
5902 * attached HBA has set the "pm-capable" property and
5903 * the value of this property is bigger than 0.
5904 */
5905 if (un->un_f_pm_supported) {
5906 /*
5907 * not all devices have a motor, try it first.
5908 * some devices may return ILLEGAL REQUEST, some
5909 * will hang
5910 * The following START_STOP_UNIT is used to check if target
5911 * device has a motor.
5912 */
5913 un->un_f_start_stop_supported = TRUE;
5914
5915 if (un->un_f_power_condition_supported) {
5916 rval = sd_send_scsi_START_STOP_UNIT(ssc,
5917 SD_POWER_CONDITION, SD_TARGET_ACTIVE,
5918 SD_PATH_DIRECT);
5919 if (rval != 0) {
5920 un->un_f_power_condition_supported = FALSE;
5921 }
5922 }
5923 if (!un->un_f_power_condition_supported) {
5924 rval = sd_send_scsi_START_STOP_UNIT(ssc,
5925 SD_START_STOP, SD_TARGET_START, SD_PATH_DIRECT);
5926 }
5927 if (rval != 0) {
5928 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
5929 un->un_f_start_stop_supported = FALSE;
5930 }
5931
5932 /*
5933 * create pm properties anyways otherwise the parent can't
5934 * go to sleep
5935 */
5936 un->un_f_pm_is_enabled = TRUE;
5937 (void) sd_create_pm_components(devi, un);
5938
5939 /*
5940 * If it claims that log sense is supported, check it out.
5941 */
5942 if (un->un_f_log_sense_supported) {
5943 rval = sd_log_page_supported(ssc,
5944 START_STOP_CYCLE_PAGE);
5945 if (rval == 1) {
5946 /* Page found, use it. */
5947 un->un_start_stop_cycle_page =
5948 START_STOP_CYCLE_PAGE;
5949 } else {
5950 /*
5951 * Page not found or log sense is not
5952 * supported.
5953 * Notice we do not check the old style
5954 * START_STOP_CYCLE_VU_PAGE because this
5955 * code path does not apply to old disks.
5956 */
5957 un->un_f_log_sense_supported = FALSE;
5958 un->un_f_pm_log_sense_smart = FALSE;
5959 }
5960 }
5961
5962 return;
5963 }
5964
5965 /*
5966 * For the disk whose attached HBA has not set the "pm-capable"
5967 * property, check if it supports the power management.
5968 */
5969 if (!un->un_f_log_sense_supported) {
5970 un->un_power_level = SD_SPINDLE_ON;
5971 un->un_f_pm_is_enabled = FALSE;
5972 return;
5973 }
5974
5975 rval = sd_log_page_supported(ssc, START_STOP_CYCLE_PAGE);
5976
5977 #ifdef SDDEBUG
5978 if (sd_force_pm_supported) {
5979 /* Force a successful result */
5980 rval = 1;
5981 }
5982 #endif
5983
5984 /*
5985 * If the start-stop cycle counter log page is not supported
5986 * or if the pm-capable property is set to be false (0),
5987 * then we should not create the pm_components property.
5988 */
5989 if (rval == -1) {
5990 /*
5991 * Error.
5992 * Reading log sense failed, most likely this is
5993 * an older drive that does not support log sense.
5994 * If this fails auto-pm is not supported.
5995 */
5996 un->un_power_level = SD_SPINDLE_ON;
5997 un->un_f_pm_is_enabled = FALSE;
5998
5999 } else if (rval == 0) {
6000 /*
6001 * Page not found.
6002 * The start stop cycle counter is implemented as page
6003 * START_STOP_CYCLE_PAGE_VU_PAGE (0x31) in older disks. For
6004 * newer disks it is implemented as START_STOP_CYCLE_PAGE (0xE).
6005 */
6006 if (sd_log_page_supported(ssc, START_STOP_CYCLE_VU_PAGE) == 1) {
6007 /*
6008 * Page found, use this one.
6009 */
6010 un->un_start_stop_cycle_page = START_STOP_CYCLE_VU_PAGE;
6011 un->un_f_pm_is_enabled = TRUE;
6012 } else {
6013 /*
6014 * Error or page not found.
6015 * auto-pm is not supported for this device.
6016 */
6017 un->un_power_level = SD_SPINDLE_ON;
6018 un->un_f_pm_is_enabled = FALSE;
6019 }
6020 } else {
6021 /*
6022 * Page found, use it.
6023 */
6024 un->un_start_stop_cycle_page = START_STOP_CYCLE_PAGE;
6025 un->un_f_pm_is_enabled = TRUE;
6026 }
6027
6028
6029 if (un->un_f_pm_is_enabled == TRUE) {
6030 log_page_size = START_STOP_CYCLE_COUNTER_PAGE_SIZE;
6031 log_page_data = kmem_zalloc(log_page_size, KM_SLEEP);
6032
6033 rval = sd_send_scsi_LOG_SENSE(ssc, log_page_data,
6034 log_page_size, un->un_start_stop_cycle_page,
6035 0x01, 0, SD_PATH_DIRECT);
6036
6037 if (rval != 0) {
6038 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
6039 }
6040
6041 #ifdef SDDEBUG
6042 if (sd_force_pm_supported) {
6043 /* Force a successful result */
6044 rval = 0;
6045 }
6046 #endif
6047
6048 /*
6049 * If the Log sense for Page( Start/stop cycle counter page)
6050 * succeeds, then power management is supported and we can
6051 * enable auto-pm.
6052 */
6053 if (rval == 0) {
6054 (void) sd_create_pm_components(devi, un);
6055 } else {
6056 un->un_power_level = SD_SPINDLE_ON;
6057 un->un_f_pm_is_enabled = FALSE;
6058 }
6059
6060 kmem_free(log_page_data, log_page_size);
6061 }
6062 }
6063
6064
6065 /*
6066 * Function: sd_create_pm_components
6067 *
6068 * Description: Initialize PM property.
6069 *
6070 * Context: Kernel thread context
6071 */
6072
6073 static void
6074 sd_create_pm_components(dev_info_t *devi, struct sd_lun *un)
6075 {
6076 ASSERT(!mutex_owned(SD_MUTEX(un)));
6077
6078 if (un->un_f_power_condition_supported) {
6079 if (ddi_prop_update_string_array(DDI_DEV_T_NONE, devi,
6080 "pm-components", sd_pwr_pc.pm_comp, 5)
6081 != DDI_PROP_SUCCESS) {
6082 un->un_power_level = SD_SPINDLE_ACTIVE;
6083 un->un_f_pm_is_enabled = FALSE;
6084 return;
6085 }
6086 } else {
6087 if (ddi_prop_update_string_array(DDI_DEV_T_NONE, devi,
6088 "pm-components", sd_pwr_ss.pm_comp, 3)
6089 != DDI_PROP_SUCCESS) {
6090 un->un_power_level = SD_SPINDLE_ON;
6091 un->un_f_pm_is_enabled = FALSE;
6092 return;
6093 }
6094 }
6095 /*
6096 * When components are initially created they are idle,
6097 * power up any non-removables.
6098 * Note: the return value of pm_raise_power can't be used
6099 * for determining if PM should be enabled for this device.
6100 * Even if you check the return values and remove this
6101 * property created above, the PM framework will not honor the
6102 * change after the first call to pm_raise_power. Hence,
6103 * removal of that property does not help if pm_raise_power
6104 * fails. In the case of removable media, the start/stop
6105 * will fail if the media is not present.
6106 */
6107 if (un->un_f_attach_spinup && (pm_raise_power(SD_DEVINFO(un), 0,
6108 SD_PM_STATE_ACTIVE(un)) == DDI_SUCCESS)) {
6109 mutex_enter(SD_MUTEX(un));
6110 un->un_power_level = SD_PM_STATE_ACTIVE(un);
6111 mutex_enter(&un->un_pm_mutex);
6112 /* Set to on and not busy. */
6113 un->un_pm_count = 0;
6114 } else {
6115 mutex_enter(SD_MUTEX(un));
6116 un->un_power_level = SD_PM_STATE_STOPPED(un);
6117 mutex_enter(&un->un_pm_mutex);
6118 /* Set to off. */
6119 un->un_pm_count = -1;
6120 }
6121 mutex_exit(&un->un_pm_mutex);
6122 mutex_exit(SD_MUTEX(un));
6123 }
6124
6125
6126 /*
6127 * Function: sd_ddi_suspend
6128 *
6129 * Description: Performs system power-down operations. This includes
6130 * setting the drive state to indicate its suspended so
6131 * that no new commands will be accepted. Also, wait for
6132 * all commands that are in transport or queued to a timer
6133 * for retry to complete. All timeout threads are cancelled.
6134 *
6135 * Return Code: DDI_FAILURE or DDI_SUCCESS
6136 *
6137 * Context: Kernel thread context
6138 */
6139
6140 static int
6141 sd_ddi_suspend(dev_info_t *devi)
6142 {
6143 struct sd_lun *un;
6144 clock_t wait_cmds_complete;
6145
6146 un = ddi_get_soft_state(sd_state, ddi_get_instance(devi));
6147 if (un == NULL) {
6148 return (DDI_FAILURE);
6149 }
6150
6151 SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_suspend: entry\n");
6152
6153 mutex_enter(SD_MUTEX(un));
6154
6155 /* Return success if the device is already suspended. */
6156 if (un->un_state == SD_STATE_SUSPENDED) {
6157 mutex_exit(SD_MUTEX(un));
6158 SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_suspend: "
6159 "device already suspended, exiting\n");
6160 return (DDI_SUCCESS);
6161 }
6162
6163 /* Return failure if the device is being used by HA */
6164 if (un->un_resvd_status &
6165 (SD_RESERVE | SD_WANT_RESERVE | SD_LOST_RESERVE)) {
6166 mutex_exit(SD_MUTEX(un));
6167 SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_suspend: "
6168 "device in use by HA, exiting\n");
6169 return (DDI_FAILURE);
6170 }
6171
6172 /*
6173 * Return failure if the device is in a resource wait
6174 * or power changing state.
6175 */
6176 if ((un->un_state == SD_STATE_RWAIT) ||
6177 (un->un_state == SD_STATE_PM_CHANGING)) {
6178 mutex_exit(SD_MUTEX(un));
6179 SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_suspend: "
6180 "device in resource wait state, exiting\n");
6181 return (DDI_FAILURE);
6182 }
6183
6184
6185 un->un_save_state = un->un_last_state;
6186 New_state(un, SD_STATE_SUSPENDED);
6187
6188 /*
6189 * Wait for all commands that are in transport or queued to a timer
6190 * for retry to complete.
6191 *
6192 * While waiting, no new commands will be accepted or sent because of
6193 * the new state we set above.
6194 *
6195 * Wait till current operation has completed. If we are in the resource
6196 * wait state (with an intr outstanding) then we need to wait till the
6197 * intr completes and starts the next cmd. We want to wait for
6198 * SD_WAIT_CMDS_COMPLETE seconds before failing the DDI_SUSPEND.
6199 */
6200 wait_cmds_complete = ddi_get_lbolt() +
6201 (sd_wait_cmds_complete * drv_usectohz(1000000));
6202
6203 while (un->un_ncmds_in_transport != 0) {
6204 /*
6205 * Fail if commands do not finish in the specified time.
6206 */
6207 if (cv_timedwait(&un->un_disk_busy_cv, SD_MUTEX(un),
6208 wait_cmds_complete) == -1) {
6209 /*
6210 * Undo the state changes made above. Everything
6211 * must go back to it's original value.
6212 */
6213 Restore_state(un);
6214 un->un_last_state = un->un_save_state;
6215 /* Wake up any threads that might be waiting. */
6216 cv_broadcast(&un->un_suspend_cv);
6217 mutex_exit(SD_MUTEX(un));
6218 SD_ERROR(SD_LOG_IO_PM, un,
6219 "sd_ddi_suspend: failed due to outstanding cmds\n");
6220 SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_suspend: exiting\n");
6221 return (DDI_FAILURE);
6222 }
6223 }
6224
6225 /*
6226 * Cancel SCSI watch thread and timeouts, if any are active
6227 */
6228
6229 if (SD_OK_TO_SUSPEND_SCSI_WATCHER(un)) {
6230 opaque_t temp_token = un->un_swr_token;
6231 mutex_exit(SD_MUTEX(un));
6232 scsi_watch_suspend(temp_token);
6233 mutex_enter(SD_MUTEX(un));
6234 }
6235
6236 if (un->un_reset_throttle_timeid != NULL) {
6237 timeout_id_t temp_id = un->un_reset_throttle_timeid;
6238 un->un_reset_throttle_timeid = NULL;
6239 mutex_exit(SD_MUTEX(un));
6240 (void) untimeout(temp_id);
6241 mutex_enter(SD_MUTEX(un));
6242 }
6243
6244 if (un->un_dcvb_timeid != NULL) {
6245 timeout_id_t temp_id = un->un_dcvb_timeid;
6246 un->un_dcvb_timeid = NULL;
6247 mutex_exit(SD_MUTEX(un));
6248 (void) untimeout(temp_id);
6249 mutex_enter(SD_MUTEX(un));
6250 }
6251
6252 mutex_enter(&un->un_pm_mutex);
6253 if (un->un_pm_timeid != NULL) {
6254 timeout_id_t temp_id = un->un_pm_timeid;
6255 un->un_pm_timeid = NULL;
6256 mutex_exit(&un->un_pm_mutex);
6257 mutex_exit(SD_MUTEX(un));
6258 (void) untimeout(temp_id);
6259 mutex_enter(SD_MUTEX(un));
6260 } else {
6261 mutex_exit(&un->un_pm_mutex);
6262 }
6263
6264 if (un->un_rmw_msg_timeid != NULL) {
6265 timeout_id_t temp_id = un->un_rmw_msg_timeid;
6266 un->un_rmw_msg_timeid = NULL;
6267 mutex_exit(SD_MUTEX(un));
6268 (void) untimeout(temp_id);
6269 mutex_enter(SD_MUTEX(un));
6270 }
6271
6272 if (un->un_retry_timeid != NULL) {
6273 timeout_id_t temp_id = un->un_retry_timeid;
6274 un->un_retry_timeid = NULL;
6275 mutex_exit(SD_MUTEX(un));
6276 (void) untimeout(temp_id);
6277 mutex_enter(SD_MUTEX(un));
6278
6279 if (un->un_retry_bp != NULL) {
6280 un->un_retry_bp->av_forw = un->un_waitq_headp;
6281 un->un_waitq_headp = un->un_retry_bp;
6282 if (un->un_waitq_tailp == NULL) {
6283 un->un_waitq_tailp = un->un_retry_bp;
6284 }
6285 un->un_retry_bp = NULL;
6286 un->un_retry_statp = NULL;
6287 }
6288 }
6289
6290 if (un->un_direct_priority_timeid != NULL) {
6291 timeout_id_t temp_id = un->un_direct_priority_timeid;
6292 un->un_direct_priority_timeid = NULL;
6293 mutex_exit(SD_MUTEX(un));
6294 (void) untimeout(temp_id);
6295 mutex_enter(SD_MUTEX(un));
6296 }
6297
6298 if (un->un_f_is_fibre == TRUE) {
6299 /*
6300 * Remove callbacks for insert and remove events
6301 */
6302 if (un->un_insert_event != NULL) {
6303 mutex_exit(SD_MUTEX(un));
6304 (void) ddi_remove_event_handler(un->un_insert_cb_id);
6305 mutex_enter(SD_MUTEX(un));
6306 un->un_insert_event = NULL;
6307 }
6308
6309 if (un->un_remove_event != NULL) {
6310 mutex_exit(SD_MUTEX(un));
6311 (void) ddi_remove_event_handler(un->un_remove_cb_id);
6312 mutex_enter(SD_MUTEX(un));
6313 un->un_remove_event = NULL;
6314 }
6315 }
6316
6317 mutex_exit(SD_MUTEX(un));
6318
6319 SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_suspend: exit\n");
6320
6321 return (DDI_SUCCESS);
6322 }
6323
6324
6325 /*
6326 * Function: sd_ddi_resume
6327 *
6328 * Description: Performs system power-up operations..
6329 *
6330 * Return Code: DDI_SUCCESS
6331 * DDI_FAILURE
6332 *
6333 * Context: Kernel thread context
6334 */
6335
6336 static int
6337 sd_ddi_resume(dev_info_t *devi)
6338 {
6339 struct sd_lun *un;
6340
6341 un = ddi_get_soft_state(sd_state, ddi_get_instance(devi));
6342 if (un == NULL) {
6343 return (DDI_FAILURE);
6344 }
6345
6346 SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_resume: entry\n");
6347
6348 mutex_enter(SD_MUTEX(un));
6349 Restore_state(un);
6350
6351 /*
6352 * Restore the state which was saved to give the
6353 * the right state in un_last_state
6354 */
6355 un->un_last_state = un->un_save_state;
6356 /*
6357 * Note: throttle comes back at full.
6358 * Also note: this MUST be done before calling pm_raise_power
6359 * otherwise the system can get hung in biowait. The scenario where
6360 * this'll happen is under cpr suspend. Writing of the system
6361 * state goes through sddump, which writes 0 to un_throttle. If
6362 * writing the system state then fails, example if the partition is
6363 * too small, then cpr attempts a resume. If throttle isn't restored
6364 * from the saved value until after calling pm_raise_power then
6365 * cmds sent in sdpower are not transported and sd_send_scsi_cmd hangs
6366 * in biowait.
6367 */
6368 un->un_throttle = un->un_saved_throttle;
6369
6370 /*
6371 * The chance of failure is very rare as the only command done in power
6372 * entry point is START command when you transition from 0->1 or
6373 * unknown->1. Put it to SPINDLE ON state irrespective of the state at
6374 * which suspend was done. Ignore the return value as the resume should
6375 * not be failed. In the case of removable media the media need not be
6376 * inserted and hence there is a chance that raise power will fail with
6377 * media not present.
6378 */
6379 if (un->un_f_attach_spinup) {
6380 mutex_exit(SD_MUTEX(un));
6381 (void) pm_raise_power(SD_DEVINFO(un), 0,
6382 SD_PM_STATE_ACTIVE(un));
6383 mutex_enter(SD_MUTEX(un));
6384 }
6385
6386 /*
6387 * Don't broadcast to the suspend cv and therefore possibly
6388 * start I/O until after power has been restored.
6389 */
6390 cv_broadcast(&un->un_suspend_cv);
6391 cv_broadcast(&un->un_state_cv);
6392
6393 /* restart thread */
6394 if (SD_OK_TO_RESUME_SCSI_WATCHER(un)) {
6395 scsi_watch_resume(un->un_swr_token);
6396 }
6397
6398 #if (defined(__fibre))
6399 if (un->un_f_is_fibre == TRUE) {
6400 /*
6401 * Add callbacks for insert and remove events
6402 */
6403 if (strcmp(un->un_node_type, DDI_NT_BLOCK_CHAN)) {
6404 sd_init_event_callbacks(un);
6405 }
6406 }
6407 #endif
6408
6409 /*
6410 * Transport any pending commands to the target.
6411 *
6412 * If this is a low-activity device commands in queue will have to wait
6413 * until new commands come in, which may take awhile. Also, we
6414 * specifically don't check un_ncmds_in_transport because we know that
6415 * there really are no commands in progress after the unit was
6416 * suspended and we could have reached the throttle level, been
6417 * suspended, and have no new commands coming in for awhile. Highly
6418 * unlikely, but so is the low-activity disk scenario.
6419 */
6420 ddi_xbuf_dispatch(un->un_xbuf_attr);
6421
6422 sd_start_cmds(un, NULL);
6423 mutex_exit(SD_MUTEX(un));
6424
6425 SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_resume: exit\n");
6426
6427 return (DDI_SUCCESS);
6428 }
6429
6430
6431 /*
6432 * Function: sd_pm_state_change
6433 *
6434 * Description: Change the driver power state.
6435 * Someone else is required to actually change the driver
6436 * power level.
6437 *
6438 * Arguments: un - driver soft state (unit) structure
6439 * level - the power level that is changed to
6440 * flag - to decide how to change the power state
6441 *
6442 * Return Code: DDI_SUCCESS
6443 *
6444 * Context: Kernel thread context
6445 */
6446 static int
6447 sd_pm_state_change(struct sd_lun *un, int level, int flag)
6448 {
6449 ASSERT(un != NULL);
6450 SD_TRACE(SD_LOG_POWER, un, "sd_pm_state_change: entry\n");
6451
6452 ASSERT(!mutex_owned(SD_MUTEX(un)));
6453 mutex_enter(SD_MUTEX(un));
6454
6455 if (flag == SD_PM_STATE_ROLLBACK || SD_PM_IS_IO_CAPABLE(un, level)) {
6456 un->un_power_level = level;
6457 ASSERT(!mutex_owned(&un->un_pm_mutex));
6458 mutex_enter(&un->un_pm_mutex);
6459 if (SD_DEVICE_IS_IN_LOW_POWER(un)) {
6460 un->un_pm_count++;
6461 ASSERT(un->un_pm_count == 0);
6462 }
6463 mutex_exit(&un->un_pm_mutex);
6464 } else {
6465 /*
6466 * Exit if power management is not enabled for this device,
6467 * or if the device is being used by HA.
6468 */
6469 if ((un->un_f_pm_is_enabled == FALSE) || (un->un_resvd_status &
6470 (SD_RESERVE | SD_WANT_RESERVE | SD_LOST_RESERVE))) {
6471 mutex_exit(SD_MUTEX(un));
6472 SD_TRACE(SD_LOG_POWER, un,
6473 "sd_pm_state_change: exiting\n");
6474 return (DDI_FAILURE);
6475 }
6476
6477 SD_INFO(SD_LOG_POWER, un, "sd_pm_state_change: "
6478 "un_ncmds_in_driver=%ld\n", un->un_ncmds_in_driver);
6479
6480 /*
6481 * See if the device is not busy, ie.:
6482 * - we have no commands in the driver for this device
6483 * - not waiting for resources
6484 */
6485 if ((un->un_ncmds_in_driver == 0) &&
6486 (un->un_state != SD_STATE_RWAIT)) {
6487 /*
6488 * The device is not busy, so it is OK to go to low
6489 * power state. Indicate low power, but rely on someone
6490 * else to actually change it.
6491 */
6492 mutex_enter(&un->un_pm_mutex);
6493 un->un_pm_count = -1;
6494 mutex_exit(&un->un_pm_mutex);
6495 un->un_power_level = level;
6496 }
6497 }
6498
6499 mutex_exit(SD_MUTEX(un));
6500
6501 SD_TRACE(SD_LOG_POWER, un, "sd_pm_state_change: exit\n");
6502
6503 return (DDI_SUCCESS);
6504 }
6505
6506
6507 /*
6508 * Function: sd_pm_idletimeout_handler
6509 *
6510 * Description: A timer routine that's active only while a device is busy.
6511 * The purpose is to extend slightly the pm framework's busy
6512 * view of the device to prevent busy/idle thrashing for
6513 * back-to-back commands. Do this by comparing the current time
6514 * to the time at which the last command completed and when the
6515 * difference is greater than sd_pm_idletime, call
6516 * pm_idle_component. In addition to indicating idle to the pm
6517 * framework, update the chain type to again use the internal pm
6518 * layers of the driver.
6519 *
6520 * Arguments: arg - driver soft state (unit) structure
6521 *
6522 * Context: Executes in a timeout(9F) thread context
6523 */
6524
6525 static void
6526 sd_pm_idletimeout_handler(void *arg)
6527 {
6528 const hrtime_t idletime = sd_pm_idletime * NANOSEC;
6529 struct sd_lun *un = arg;
6530
6531 mutex_enter(&sd_detach_mutex);
6532 if (un->un_detach_count != 0) {
6533 /* Abort if the instance is detaching */
6534 mutex_exit(&sd_detach_mutex);
6535 return;
6536 }
6537 mutex_exit(&sd_detach_mutex);
6538
6539 /*
6540 * Grab both mutexes, in the proper order, since we're accessing
6541 * both PM and softstate variables.
6542 */
6543 mutex_enter(SD_MUTEX(un));
6544 mutex_enter(&un->un_pm_mutex);
6545 if (((gethrtime() - un->un_pm_idle_time) > idletime) &&
6546 (un->un_ncmds_in_driver == 0) && (un->un_pm_count == 0)) {
6547 /*
6548 * Update the chain types.
6549 * This takes affect on the next new command received.
6550 */
6551 if (un->un_f_non_devbsize_supported) {
6552 un->un_buf_chain_type = SD_CHAIN_INFO_RMMEDIA;
6553 } else {
6554 un->un_buf_chain_type = SD_CHAIN_INFO_DISK;
6555 }
6556 un->un_uscsi_chain_type = SD_CHAIN_INFO_USCSI_CMD;
6557
6558 SD_TRACE(SD_LOG_IO_PM, un,
6559 "sd_pm_idletimeout_handler: idling device\n");
6560 (void) pm_idle_component(SD_DEVINFO(un), 0);
6561 un->un_pm_idle_timeid = NULL;
6562 } else {
6563 un->un_pm_idle_timeid =
6564 timeout(sd_pm_idletimeout_handler, un,
6565 (drv_usectohz((clock_t)300000))); /* 300 ms. */
6566 }
6567 mutex_exit(&un->un_pm_mutex);
6568 mutex_exit(SD_MUTEX(un));
6569 }
6570
6571
6572 /*
6573 * Function: sd_pm_timeout_handler
6574 *
6575 * Description: Callback to tell framework we are idle.
6576 *
6577 * Context: timeout(9f) thread context.
6578 */
6579
6580 static void
6581 sd_pm_timeout_handler(void *arg)
6582 {
6583 struct sd_lun *un = arg;
6584
6585 (void) pm_idle_component(SD_DEVINFO(un), 0);
6586 mutex_enter(&un->un_pm_mutex);
6587 un->un_pm_timeid = NULL;
6588 mutex_exit(&un->un_pm_mutex);
6589 }
6590
6591
6592 /*
6593 * Function: sdpower
6594 *
6595 * Description: PM entry point.
6596 *
6597 * Return Code: DDI_SUCCESS
6598 * DDI_FAILURE
6599 *
6600 * Context: Kernel thread context
6601 */
6602
6603 static int
6604 sdpower(dev_info_t *devi, int component, int level)
6605 {
6606 struct sd_lun *un;
6607 int instance;
6608 int rval = DDI_SUCCESS;
6609 uint_t i, log_page_size, maxcycles, ncycles;
6610 uchar_t *log_page_data;
6611 int log_sense_page;
6612 int medium_present;
6613 time_t intvlp;
6614 struct pm_trans_data sd_pm_tran_data;
6615 uchar_t save_state = SD_STATE_NORMAL;
6616 int sval;
6617 uchar_t state_before_pm;
6618 int got_semaphore_here;
6619 sd_ssc_t *ssc;
6620 int last_power_level = SD_SPINDLE_UNINIT;
6621
6622 instance = ddi_get_instance(devi);
6623
6624 if (((un = ddi_get_soft_state(sd_state, instance)) == NULL) ||
6625 !SD_PM_IS_LEVEL_VALID(un, level) || component != 0) {
6626 return (DDI_FAILURE);
6627 }
6628
6629 ssc = sd_ssc_init(un);
6630
6631 SD_TRACE(SD_LOG_IO_PM, un, "sdpower: entry, level = %d\n", level);
6632
6633 /*
6634 * Must synchronize power down with close.
6635 * Attempt to decrement/acquire the open/close semaphore,
6636 * but do NOT wait on it. If it's not greater than zero,
6637 * ie. it can't be decremented without waiting, then
6638 * someone else, either open or close, already has it
6639 * and the try returns 0. Use that knowledge here to determine
6640 * if it's OK to change the device power level.
6641 * Also, only increment it on exit if it was decremented, ie. gotten,
6642 * here.
6643 */
6644 got_semaphore_here = sema_tryp(&un->un_semoclose);
6645
6646 mutex_enter(SD_MUTEX(un));
6647
6648 SD_INFO(SD_LOG_POWER, un, "sdpower: un_ncmds_in_driver = %ld\n",
6649 un->un_ncmds_in_driver);
6650
6651 /*
6652 * If un_ncmds_in_driver is non-zero it indicates commands are
6653 * already being processed in the driver, or if the semaphore was
6654 * not gotten here it indicates an open or close is being processed.
6655 * At the same time somebody is requesting to go to a lower power
6656 * that can't perform I/O, which can't happen, therefore we need to
6657 * return failure.
6658 */
6659 if ((!SD_PM_IS_IO_CAPABLE(un, level)) &&
6660 ((un->un_ncmds_in_driver != 0) || (got_semaphore_here == 0))) {
6661 mutex_exit(SD_MUTEX(un));
6662
6663 if (got_semaphore_here != 0) {
6664 sema_v(&un->un_semoclose);
6665 }
6666 SD_TRACE(SD_LOG_IO_PM, un,
6667 "sdpower: exit, device has queued cmds.\n");
6668
6669 goto sdpower_failed;
6670 }
6671
6672 /*
6673 * if it is OFFLINE that means the disk is completely dead
6674 * in our case we have to put the disk in on or off by sending commands
6675 * Of course that will fail anyway so return back here.
6676 *
6677 * Power changes to a device that's OFFLINE or SUSPENDED
6678 * are not allowed.
6679 */
6680 if ((un->un_state == SD_STATE_OFFLINE) ||
6681 (un->un_state == SD_STATE_SUSPENDED)) {
6682 mutex_exit(SD_MUTEX(un));
6683
6684 if (got_semaphore_here != 0) {
6685 sema_v(&un->un_semoclose);
6686 }
6687 SD_TRACE(SD_LOG_IO_PM, un,
6688 "sdpower: exit, device is off-line.\n");
6689
6690 goto sdpower_failed;
6691 }
6692
6693 /*
6694 * Change the device's state to indicate it's power level
6695 * is being changed. Do this to prevent a power off in the
6696 * middle of commands, which is especially bad on devices
6697 * that are really powered off instead of just spun down.
6698 */
6699 state_before_pm = un->un_state;
6700 un->un_state = SD_STATE_PM_CHANGING;
6701
6702 mutex_exit(SD_MUTEX(un));
6703
6704 /*
6705 * If log sense command is not supported, bypass the
6706 * following checking, otherwise, check the log sense
6707 * information for this device.
6708 */
6709 if (SD_PM_STOP_MOTOR_NEEDED(un, level) &&
6710 un->un_f_log_sense_supported) {
6711 /*
6712 * Get the log sense information to understand whether the
6713 * the powercycle counts have gone beyond the threshhold.
6714 */
6715 log_page_size = START_STOP_CYCLE_COUNTER_PAGE_SIZE;
6716 log_page_data = kmem_zalloc(log_page_size, KM_SLEEP);
6717
6718 mutex_enter(SD_MUTEX(un));
6719 log_sense_page = un->un_start_stop_cycle_page;
6720 mutex_exit(SD_MUTEX(un));
6721
6722 rval = sd_send_scsi_LOG_SENSE(ssc, log_page_data,
6723 log_page_size, log_sense_page, 0x01, 0, SD_PATH_DIRECT);
6724
6725 if (rval != 0) {
6726 if (rval == EIO)
6727 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
6728 else
6729 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
6730 }
6731
6732 #ifdef SDDEBUG
6733 if (sd_force_pm_supported) {
6734 /* Force a successful result */
6735 rval = 0;
6736 }
6737 #endif
6738 if (rval != 0) {
6739 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
6740 "Log Sense Failed\n");
6741
6742 kmem_free(log_page_data, log_page_size);
6743 /* Cannot support power management on those drives */
6744
6745 if (got_semaphore_here != 0) {
6746 sema_v(&un->un_semoclose);
6747 }
6748 /*
6749 * On exit put the state back to it's original value
6750 * and broadcast to anyone waiting for the power
6751 * change completion.
6752 */
6753 mutex_enter(SD_MUTEX(un));
6754 un->un_state = state_before_pm;
6755 cv_broadcast(&un->un_suspend_cv);
6756 mutex_exit(SD_MUTEX(un));
6757 SD_TRACE(SD_LOG_IO_PM, un,
6758 "sdpower: exit, Log Sense Failed.\n");
6759
6760 goto sdpower_failed;
6761 }
6762
6763 /*
6764 * From the page data - Convert the essential information to
6765 * pm_trans_data
6766 */
6767 maxcycles =
6768 (log_page_data[0x1c] << 24) | (log_page_data[0x1d] << 16) |
6769 (log_page_data[0x1E] << 8) | log_page_data[0x1F];
6770
6771 ncycles =
6772 (log_page_data[0x24] << 24) | (log_page_data[0x25] << 16) |
6773 (log_page_data[0x26] << 8) | log_page_data[0x27];
6774
6775 if (un->un_f_pm_log_sense_smart) {
6776 sd_pm_tran_data.un.smart_count.allowed = maxcycles;
6777 sd_pm_tran_data.un.smart_count.consumed = ncycles;
6778 sd_pm_tran_data.un.smart_count.flag = 0;
6779 sd_pm_tran_data.format = DC_SMART_FORMAT;
6780 } else {
6781 sd_pm_tran_data.un.scsi_cycles.lifemax = maxcycles;
6782 sd_pm_tran_data.un.scsi_cycles.ncycles = ncycles;
6783 for (i = 0; i < DC_SCSI_MFR_LEN; i++) {
6784 sd_pm_tran_data.un.scsi_cycles.svc_date[i] =
6785 log_page_data[8+i];
6786 }
6787 sd_pm_tran_data.un.scsi_cycles.flag = 0;
6788 sd_pm_tran_data.format = DC_SCSI_FORMAT;
6789 }
6790
6791 kmem_free(log_page_data, log_page_size);
6792
6793 /*
6794 * Call pm_trans_check routine to get the Ok from
6795 * the global policy
6796 */
6797 rval = pm_trans_check(&sd_pm_tran_data, &intvlp);
6798 #ifdef SDDEBUG
6799 if (sd_force_pm_supported) {
6800 /* Force a successful result */
6801 rval = 1;
6802 }
6803 #endif
6804 switch (rval) {
6805 case 0:
6806 /*
6807 * Not Ok to Power cycle or error in parameters passed
6808 * Would have given the advised time to consider power
6809 * cycle. Based on the new intvlp parameter we are
6810 * supposed to pretend we are busy so that pm framework
6811 * will never call our power entry point. Because of
6812 * that install a timeout handler and wait for the
6813 * recommended time to elapse so that power management
6814 * can be effective again.
6815 *
6816 * To effect this behavior, call pm_busy_component to
6817 * indicate to the framework this device is busy.
6818 * By not adjusting un_pm_count the rest of PM in
6819 * the driver will function normally, and independent
6820 * of this but because the framework is told the device
6821 * is busy it won't attempt powering down until it gets
6822 * a matching idle. The timeout handler sends this.
6823 * Note: sd_pm_entry can't be called here to do this
6824 * because sdpower may have been called as a result
6825 * of a call to pm_raise_power from within sd_pm_entry.
6826 *
6827 * If a timeout handler is already active then
6828 * don't install another.
6829 */
6830 mutex_enter(&un->un_pm_mutex);
6831 if (un->un_pm_timeid == NULL) {
6832 un->un_pm_timeid =
6833 timeout(sd_pm_timeout_handler,
6834 un, intvlp * drv_usectohz(1000000));
6835 mutex_exit(&un->un_pm_mutex);
6836 (void) pm_busy_component(SD_DEVINFO(un), 0);
6837 } else {
6838 mutex_exit(&un->un_pm_mutex);
6839 }
6840 if (got_semaphore_here != 0) {
6841 sema_v(&un->un_semoclose);
6842 }
6843 /*
6844 * On exit put the state back to it's original value
6845 * and broadcast to anyone waiting for the power
6846 * change completion.
6847 */
6848 mutex_enter(SD_MUTEX(un));
6849 un->un_state = state_before_pm;
6850 cv_broadcast(&un->un_suspend_cv);
6851 mutex_exit(SD_MUTEX(un));
6852
6853 SD_TRACE(SD_LOG_IO_PM, un, "sdpower: exit, "
6854 "trans check Failed, not ok to power cycle.\n");
6855
6856 goto sdpower_failed;
6857 case -1:
6858 if (got_semaphore_here != 0) {
6859 sema_v(&un->un_semoclose);
6860 }
6861 /*
6862 * On exit put the state back to it's original value
6863 * and broadcast to anyone waiting for the power
6864 * change completion.
6865 */
6866 mutex_enter(SD_MUTEX(un));
6867 un->un_state = state_before_pm;
6868 cv_broadcast(&un->un_suspend_cv);
6869 mutex_exit(SD_MUTEX(un));
6870 SD_TRACE(SD_LOG_IO_PM, un,
6871 "sdpower: exit, trans check command Failed.\n");
6872
6873 goto sdpower_failed;
6874 }
6875 }
6876
6877 if (!SD_PM_IS_IO_CAPABLE(un, level)) {
6878 /*
6879 * Save the last state... if the STOP FAILS we need it
6880 * for restoring
6881 */
6882 mutex_enter(SD_MUTEX(un));
6883 save_state = un->un_last_state;
6884 last_power_level = un->un_power_level;
6885 /*
6886 * There must not be any cmds. getting processed
6887 * in the driver when we get here. Power to the
6888 * device is potentially going off.
6889 */
6890 ASSERT(un->un_ncmds_in_driver == 0);
6891 mutex_exit(SD_MUTEX(un));
6892
6893 /*
6894 * For now PM suspend the device completely before spindle is
6895 * turned off
6896 */
6897 if ((rval = sd_pm_state_change(un, level, SD_PM_STATE_CHANGE))
6898 == DDI_FAILURE) {
6899 if (got_semaphore_here != 0) {
6900 sema_v(&un->un_semoclose);
6901 }
6902 /*
6903 * On exit put the state back to it's original value
6904 * and broadcast to anyone waiting for the power
6905 * change completion.
6906 */
6907 mutex_enter(SD_MUTEX(un));
6908 un->un_state = state_before_pm;
6909 un->un_power_level = last_power_level;
6910 cv_broadcast(&un->un_suspend_cv);
6911 mutex_exit(SD_MUTEX(un));
6912 SD_TRACE(SD_LOG_IO_PM, un,
6913 "sdpower: exit, PM suspend Failed.\n");
6914
6915 goto sdpower_failed;
6916 }
6917 }
6918
6919 /*
6920 * The transition from SPINDLE_OFF to SPINDLE_ON can happen in open,
6921 * close, or strategy. Dump no long uses this routine, it uses it's
6922 * own code so it can be done in polled mode.
6923 */
6924
6925 medium_present = TRUE;
6926
6927 /*
6928 * When powering up, issue a TUR in case the device is at unit
6929 * attention. Don't do retries. Bypass the PM layer, otherwise
6930 * a deadlock on un_pm_busy_cv will occur.
6931 */
6932 if (SD_PM_IS_IO_CAPABLE(un, level)) {
6933 sval = sd_send_scsi_TEST_UNIT_READY(ssc,
6934 SD_DONT_RETRY_TUR | SD_BYPASS_PM);
6935 if (sval != 0)
6936 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
6937 }
6938
6939 if (un->un_f_power_condition_supported) {
6940 char *pm_condition_name[] = {"STOPPED", "STANDBY",
6941 "IDLE", "ACTIVE"};
6942 SD_TRACE(SD_LOG_IO_PM, un,
6943 "sdpower: sending \'%s\' power condition",
6944 pm_condition_name[level]);
6945 sval = sd_send_scsi_START_STOP_UNIT(ssc, SD_POWER_CONDITION,
6946 sd_pl2pc[level], SD_PATH_DIRECT);
6947 } else {
6948 SD_TRACE(SD_LOG_IO_PM, un, "sdpower: sending \'%s\' unit\n",
6949 ((level == SD_SPINDLE_ON) ? "START" : "STOP"));
6950 sval = sd_send_scsi_START_STOP_UNIT(ssc, SD_START_STOP,
6951 ((level == SD_SPINDLE_ON) ? SD_TARGET_START :
6952 SD_TARGET_STOP), SD_PATH_DIRECT);
6953 }
6954 if (sval != 0) {
6955 if (sval == EIO)
6956 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
6957 else
6958 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
6959 }
6960
6961 /* Command failed, check for media present. */
6962 if ((sval == ENXIO) && un->un_f_has_removable_media) {
6963 medium_present = FALSE;
6964 }
6965
6966 /*
6967 * The conditions of interest here are:
6968 * if a spindle off with media present fails,
6969 * then restore the state and return an error.
6970 * else if a spindle on fails,
6971 * then return an error (there's no state to restore).
6972 * In all other cases we setup for the new state
6973 * and return success.
6974 */
6975 if (!SD_PM_IS_IO_CAPABLE(un, level)) {
6976 if ((medium_present == TRUE) && (sval != 0)) {
6977 /* The stop command from above failed */
6978 rval = DDI_FAILURE;
6979 /*
6980 * The stop command failed, and we have media
6981 * present. Put the level back by calling the
6982 * sd_pm_resume() and set the state back to
6983 * it's previous value.
6984 */
6985 (void) sd_pm_state_change(un, last_power_level,
6986 SD_PM_STATE_ROLLBACK);
6987 mutex_enter(SD_MUTEX(un));
6988 un->un_last_state = save_state;
6989 mutex_exit(SD_MUTEX(un));
6990 } else if (un->un_f_monitor_media_state) {
6991 /*
6992 * The stop command from above succeeded.
6993 * Terminate watch thread in case of removable media
6994 * devices going into low power state. This is as per
6995 * the requirements of pm framework, otherwise commands
6996 * will be generated for the device (through watch
6997 * thread), even when the device is in low power state.
6998 */
6999 mutex_enter(SD_MUTEX(un));
7000 un->un_f_watcht_stopped = FALSE;
7001 if (un->un_swr_token != NULL) {
7002 opaque_t temp_token = un->un_swr_token;
7003 un->un_f_watcht_stopped = TRUE;
7004 un->un_swr_token = NULL;
7005 mutex_exit(SD_MUTEX(un));
7006 (void) scsi_watch_request_terminate(temp_token,
7007 SCSI_WATCH_TERMINATE_ALL_WAIT);
7008 } else {
7009 mutex_exit(SD_MUTEX(un));
7010 }
7011 }
7012 } else {
7013 /*
7014 * The level requested is I/O capable.
7015 * Legacy behavior: return success on a failed spinup
7016 * if there is no media in the drive.
7017 * Do this by looking at medium_present here.
7018 */
7019 if ((sval != 0) && medium_present) {
7020 /* The start command from above failed */
7021 rval = DDI_FAILURE;
7022 } else {
7023 /*
7024 * The start command from above succeeded
7025 * PM resume the devices now that we have
7026 * started the disks
7027 */
7028 (void) sd_pm_state_change(un, level,
7029 SD_PM_STATE_CHANGE);
7030
7031 /*
7032 * Resume the watch thread since it was suspended
7033 * when the device went into low power mode.
7034 */
7035 if (un->un_f_monitor_media_state) {
7036 mutex_enter(SD_MUTEX(un));
7037 if (un->un_f_watcht_stopped == TRUE) {
7038 opaque_t temp_token;
7039
7040 un->un_f_watcht_stopped = FALSE;
7041 mutex_exit(SD_MUTEX(un));
7042 temp_token =
7043 sd_watch_request_submit(un);
7044 mutex_enter(SD_MUTEX(un));
7045 un->un_swr_token = temp_token;
7046 }
7047 mutex_exit(SD_MUTEX(un));
7048 }
7049 }
7050 }
7051
7052 if (got_semaphore_here != 0) {
7053 sema_v(&un->un_semoclose);
7054 }
7055 /*
7056 * On exit put the state back to it's original value
7057 * and broadcast to anyone waiting for the power
7058 * change completion.
7059 */
7060 mutex_enter(SD_MUTEX(un));
7061 un->un_state = state_before_pm;
7062 cv_broadcast(&un->un_suspend_cv);
7063 mutex_exit(SD_MUTEX(un));
7064
7065 SD_TRACE(SD_LOG_IO_PM, un, "sdpower: exit, status = 0x%x\n", rval);
7066
7067 sd_ssc_fini(ssc);
7068 return (rval);
7069
7070 sdpower_failed:
7071
7072 sd_ssc_fini(ssc);
7073 return (DDI_FAILURE);
7074 }
7075
7076
7077
7078 /*
7079 * Function: sdattach
7080 *
7081 * Description: Driver's attach(9e) entry point function.
7082 *
7083 * Arguments: devi - opaque device info handle
7084 * cmd - attach type
7085 *
7086 * Return Code: DDI_SUCCESS
7087 * DDI_FAILURE
7088 *
7089 * Context: Kernel thread context
7090 */
7091
7092 static int
7093 sdattach(dev_info_t *devi, ddi_attach_cmd_t cmd)
7094 {
7095 switch (cmd) {
7096 case DDI_ATTACH:
7097 return (sd_unit_attach(devi));
7098 case DDI_RESUME:
7099 return (sd_ddi_resume(devi));
7100 default:
7101 break;
7102 }
7103 return (DDI_FAILURE);
7104 }
7105
7106
7107 /*
7108 * Function: sddetach
7109 *
7110 * Description: Driver's detach(9E) entry point function.
7111 *
7112 * Arguments: devi - opaque device info handle
7113 * cmd - detach type
7114 *
7115 * Return Code: DDI_SUCCESS
7116 * DDI_FAILURE
7117 *
7118 * Context: Kernel thread context
7119 */
7120
7121 static int
7122 sddetach(dev_info_t *devi, ddi_detach_cmd_t cmd)
7123 {
7124 switch (cmd) {
7125 case DDI_DETACH:
7126 return (sd_unit_detach(devi));
7127 case DDI_SUSPEND:
7128 return (sd_ddi_suspend(devi));
7129 default:
7130 break;
7131 }
7132 return (DDI_FAILURE);
7133 }
7134
7135
7136 /*
7137 * Function: sd_sync_with_callback
7138 *
7139 * Description: Prevents sd_unit_attach or sd_unit_detach from freeing the soft
7140 * state while the callback routine is active.
7141 *
7142 * Arguments: un: softstate structure for the instance
7143 *
7144 * Context: Kernel thread context
7145 */
7146
7147 static void
7148 sd_sync_with_callback(struct sd_lun *un)
7149 {
7150 ASSERT(un != NULL);
7151
7152 mutex_enter(SD_MUTEX(un));
7153
7154 ASSERT(un->un_in_callback >= 0);
7155
7156 while (un->un_in_callback > 0) {
7157 mutex_exit(SD_MUTEX(un));
7158 delay(2);
7159 mutex_enter(SD_MUTEX(un));
7160 }
7161
7162 mutex_exit(SD_MUTEX(un));
7163 }
7164
7165 /*
7166 * Function: sd_unit_attach
7167 *
7168 * Description: Performs DDI_ATTACH processing for sdattach(). Allocates
7169 * the soft state structure for the device and performs
7170 * all necessary structure and device initializations.
7171 *
7172 * Arguments: devi: the system's dev_info_t for the device.
7173 *
7174 * Return Code: DDI_SUCCESS if attach is successful.
7175 * DDI_FAILURE if any part of the attach fails.
7176 *
7177 * Context: Called at attach(9e) time for the DDI_ATTACH flag.
7178 * Kernel thread context only. Can sleep.
7179 */
7180
7181 static int
7182 sd_unit_attach(dev_info_t *devi)
7183 {
7184 struct scsi_device *devp;
7185 struct sd_lun *un;
7186 char *variantp;
7187 char name_str[48];
7188 int reservation_flag = SD_TARGET_IS_UNRESERVED;
7189 int instance;
7190 int rval;
7191 int wc_enabled;
7192 int wc_changeable;
7193 int tgt;
7194 uint64_t capacity;
7195 uint_t lbasize = 0;
7196 dev_info_t *pdip = ddi_get_parent(devi);
7197 int offbyone = 0;
7198 int geom_label_valid = 0;
7199 sd_ssc_t *ssc;
7200 int status;
7201 struct sd_fm_internal *sfip = NULL;
7202 int max_xfer_size;
7203
7204 /*
7205 * Retrieve the target driver's private data area. This was set
7206 * up by the HBA.
7207 */
7208 devp = ddi_get_driver_private(devi);
7209
7210 /*
7211 * Retrieve the target ID of the device.
7212 */
7213 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS,
7214 SCSI_ADDR_PROP_TARGET, -1);
7215
7216 /*
7217 * Since we have no idea what state things were left in by the last
7218 * user of the device, set up some 'default' settings, ie. turn 'em
7219 * off. The scsi_ifsetcap calls force re-negotiations with the drive.
7220 * Do this before the scsi_probe, which sends an inquiry.
7221 * This is a fix for bug (4430280).
7222 * Of special importance is wide-xfer. The drive could have been left
7223 * in wide transfer mode by the last driver to communicate with it,
7224 * this includes us. If that's the case, and if the following is not
7225 * setup properly or we don't re-negotiate with the drive prior to
7226 * transferring data to/from the drive, it causes bus parity errors,
7227 * data overruns, and unexpected interrupts. This first occurred when
7228 * the fix for bug (4378686) was made.
7229 */
7230 (void) scsi_ifsetcap(&devp->sd_address, "lun-reset", 0, 1);
7231 (void) scsi_ifsetcap(&devp->sd_address, "wide-xfer", 0, 1);
7232 (void) scsi_ifsetcap(&devp->sd_address, "auto-rqsense", 0, 1);
7233
7234 /*
7235 * Currently, scsi_ifsetcap sets tagged-qing capability for all LUNs
7236 * on a target. Setting it per lun instance actually sets the
7237 * capability of this target, which affects those luns already
7238 * attached on the same target. So during attach, we can only disable
7239 * this capability only when no other lun has been attached on this
7240 * target. By doing this, we assume a target has the same tagged-qing
7241 * capability for every lun. The condition can be removed when HBA
7242 * is changed to support per lun based tagged-qing capability.
7243 */
7244 if (sd_scsi_get_target_lun_count(pdip, tgt) < 1) {
7245 (void) scsi_ifsetcap(&devp->sd_address, "tagged-qing", 0, 1);
7246 }
7247
7248 /*
7249 * Use scsi_probe() to issue an INQUIRY command to the device.
7250 * This call will allocate and fill in the scsi_inquiry structure
7251 * and point the sd_inq member of the scsi_device structure to it.
7252 * If the attach succeeds, then this memory will not be de-allocated
7253 * (via scsi_unprobe()) until the instance is detached.
7254 */
7255 if (scsi_probe(devp, SLEEP_FUNC) != SCSIPROBE_EXISTS) {
7256 goto probe_failed;
7257 }
7258
7259 /*
7260 * Check the device type as specified in the inquiry data and
7261 * claim it if it is of a type that we support.
7262 */
7263 switch (devp->sd_inq->inq_dtype) {
7264 case DTYPE_DIRECT:
7265 break;
7266 case DTYPE_RODIRECT:
7267 break;
7268 case DTYPE_OPTICAL:
7269 break;
7270 case DTYPE_NOTPRESENT:
7271 default:
7272 /* Unsupported device type; fail the attach. */
7273 goto probe_failed;
7274 }
7275
7276 /*
7277 * Allocate the soft state structure for this unit.
7278 *
7279 * We rely upon this memory being set to all zeroes by
7280 * ddi_soft_state_zalloc(). We assume that any member of the
7281 * soft state structure that is not explicitly initialized by
7282 * this routine will have a value of zero.
7283 */
7284 instance = ddi_get_instance(devp->sd_dev);
7285 if (ddi_soft_state_zalloc(sd_state, instance) != DDI_SUCCESS) {
7286 goto probe_failed;
7287 }
7288
7289 /*
7290 * Retrieve a pointer to the newly-allocated soft state.
7291 *
7292 * This should NEVER fail if the ddi_soft_state_zalloc() call above
7293 * was successful, unless something has gone horribly wrong and the
7294 * ddi's soft state internals are corrupt (in which case it is
7295 * probably better to halt here than just fail the attach....)
7296 */
7297 if ((un = ddi_get_soft_state(sd_state, instance)) == NULL) {
7298 panic("sd_unit_attach: NULL soft state on instance:0x%x",
7299 instance);
7300 /*NOTREACHED*/
7301 }
7302
7303 /*
7304 * Link the back ptr of the driver soft state to the scsi_device
7305 * struct for this lun.
7306 * Save a pointer to the softstate in the driver-private area of
7307 * the scsi_device struct.
7308 * Note: We cannot call SD_INFO, SD_TRACE, SD_ERROR, or SD_DIAG until
7309 * we first set un->un_sd below.
7310 */
7311 un->un_sd = devp;
7312 devp->sd_private = (opaque_t)un;
7313
7314 /*
7315 * The following must be after devp is stored in the soft state struct.
7316 */
7317 #ifdef SDDEBUG
7318 SD_TRACE(SD_LOG_ATTACH_DETACH, un,
7319 "%s_unit_attach: un:0x%p instance:%d\n",
7320 ddi_driver_name(devi), un, instance);
7321 #endif
7322
7323 /*
7324 * Set up the device type and node type (for the minor nodes).
7325 * By default we assume that the device can at least support the
7326 * Common Command Set. Call it a CD-ROM if it reports itself
7327 * as a RODIRECT device.
7328 */
7329 switch (devp->sd_inq->inq_dtype) {
7330 case DTYPE_RODIRECT:
7331 un->un_node_type = DDI_NT_CD_CHAN;
7332 un->un_ctype = CTYPE_CDROM;
7333 break;
7334 case DTYPE_OPTICAL:
7335 un->un_node_type = DDI_NT_BLOCK_CHAN;
7336 un->un_ctype = CTYPE_ROD;
7337 break;
7338 default:
7339 un->un_node_type = DDI_NT_BLOCK_CHAN;
7340 un->un_ctype = CTYPE_CCS;
7341 break;
7342 }
7343
7344 /*
7345 * Try to read the interconnect type from the HBA.
7346 *
7347 * Note: This driver is currently compiled as two binaries, a parallel
7348 * scsi version (sd) and a fibre channel version (ssd). All functional
7349 * differences are determined at compile time. In the future a single
7350 * binary will be provided and the interconnect type will be used to
7351 * differentiate between fibre and parallel scsi behaviors. At that time
7352 * it will be necessary for all fibre channel HBAs to support this
7353 * property.
7354 *
7355 * set un_f_is_fiber to TRUE ( default fiber )
7356 */
7357 un->un_f_is_fibre = TRUE;
7358 switch (scsi_ifgetcap(SD_ADDRESS(un), "interconnect-type", -1)) {
7359 case INTERCONNECT_SSA:
7360 un->un_interconnect_type = SD_INTERCONNECT_SSA;
7361 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7362 "sd_unit_attach: un:0x%p SD_INTERCONNECT_SSA\n", un);
7363 break;
7364 case INTERCONNECT_PARALLEL:
7365 un->un_f_is_fibre = FALSE;
7366 un->un_interconnect_type = SD_INTERCONNECT_PARALLEL;
7367 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7368 "sd_unit_attach: un:0x%p SD_INTERCONNECT_PARALLEL\n", un);
7369 break;
7370 case INTERCONNECT_SAS:
7371 un->un_f_is_fibre = FALSE;
7372 un->un_interconnect_type = SD_INTERCONNECT_SAS;
7373 un->un_node_type = DDI_NT_BLOCK_SAS;
7374 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7375 "sd_unit_attach: un:0x%p SD_INTERCONNECT_SAS\n", un);
7376 break;
7377 case INTERCONNECT_SATA:
7378 un->un_f_is_fibre = FALSE;
7379 un->un_interconnect_type = SD_INTERCONNECT_SATA;
7380 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7381 "sd_unit_attach: un:0x%p SD_INTERCONNECT_SATA\n", un);
7382 break;
7383 case INTERCONNECT_FIBRE:
7384 un->un_interconnect_type = SD_INTERCONNECT_FIBRE;
7385 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7386 "sd_unit_attach: un:0x%p SD_INTERCONNECT_FIBRE\n", un);
7387 break;
7388 case INTERCONNECT_FABRIC:
7389 un->un_interconnect_type = SD_INTERCONNECT_FABRIC;
7390 un->un_node_type = DDI_NT_BLOCK_FABRIC;
7391 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7392 "sd_unit_attach: un:0x%p SD_INTERCONNECT_FABRIC\n", un);
7393 break;
7394 default:
7395 #ifdef SD_DEFAULT_INTERCONNECT_TYPE
7396 /*
7397 * The HBA does not support the "interconnect-type" property
7398 * (or did not provide a recognized type).
7399 *
7400 * Note: This will be obsoleted when a single fibre channel
7401 * and parallel scsi driver is delivered. In the meantime the
7402 * interconnect type will be set to the platform default.If that
7403 * type is not parallel SCSI, it means that we should be
7404 * assuming "ssd" semantics. However, here this also means that
7405 * the FC HBA is not supporting the "interconnect-type" property
7406 * like we expect it to, so log this occurrence.
7407 */
7408 un->un_interconnect_type = SD_DEFAULT_INTERCONNECT_TYPE;
7409 if (!SD_IS_PARALLEL_SCSI(un)) {
7410 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7411 "sd_unit_attach: un:0x%p Assuming "
7412 "INTERCONNECT_FIBRE\n", un);
7413 } else {
7414 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7415 "sd_unit_attach: un:0x%p Assuming "
7416 "INTERCONNECT_PARALLEL\n", un);
7417 un->un_f_is_fibre = FALSE;
7418 }
7419 #else
7420 /*
7421 * Note: This source will be implemented when a single fibre
7422 * channel and parallel scsi driver is delivered. The default
7423 * will be to assume that if a device does not support the
7424 * "interconnect-type" property it is a parallel SCSI HBA and
7425 * we will set the interconnect type for parallel scsi.
7426 */
7427 un->un_interconnect_type = SD_INTERCONNECT_PARALLEL;
7428 un->un_f_is_fibre = FALSE;
7429 #endif
7430 break;
7431 }
7432
7433 if (un->un_f_is_fibre == TRUE) {
7434 if (scsi_ifgetcap(SD_ADDRESS(un), "scsi-version", 1) ==
7435 SCSI_VERSION_3) {
7436 switch (un->un_interconnect_type) {
7437 case SD_INTERCONNECT_FIBRE:
7438 case SD_INTERCONNECT_SSA:
7439 un->un_node_type = DDI_NT_BLOCK_WWN;
7440 break;
7441 default:
7442 break;
7443 }
7444 }
7445 }
7446
7447 /*
7448 * Initialize the Request Sense command for the target
7449 */
7450 if (sd_alloc_rqs(devp, un) != DDI_SUCCESS) {
7451 goto alloc_rqs_failed;
7452 }
7453
7454 /*
7455 * Set un_retry_count with SD_RETRY_COUNT, this is ok for Sparc
7456 * with separate binary for sd and ssd.
7457 *
7458 * x86 has 1 binary, un_retry_count is set base on connection type.
7459 * The hardcoded values will go away when Sparc uses 1 binary
7460 * for sd and ssd. This hardcoded values need to match
7461 * SD_RETRY_COUNT in sddef.h
7462 * The value used is base on interconnect type.
7463 * fibre = 3, parallel = 5
7464 */
7465 #if defined(__i386) || defined(__amd64)
7466 un->un_retry_count = un->un_f_is_fibre ? 3 : 5;
7467 #else
7468 un->un_retry_count = SD_RETRY_COUNT;
7469 #endif
7470
7471 /*
7472 * Set the per disk retry count to the default number of retries
7473 * for disks and CDROMs. This value can be overridden by the
7474 * disk property list or an entry in sd.conf.
7475 */
7476 un->un_notready_retry_count =
7477 ISCD(un) ? CD_NOT_READY_RETRY_COUNT(un)
7478 : DISK_NOT_READY_RETRY_COUNT(un);
7479
7480 /*
7481 * Set the busy retry count to the default value of un_retry_count.
7482 * This can be overridden by entries in sd.conf or the device
7483 * config table.
7484 */
7485 un->un_busy_retry_count = un->un_retry_count;
7486
7487 /*
7488 * Init the reset threshold for retries. This number determines
7489 * how many retries must be performed before a reset can be issued
7490 * (for certain error conditions). This can be overridden by entries
7491 * in sd.conf or the device config table.
7492 */
7493 un->un_reset_retry_count = (un->un_retry_count / 2);
7494
7495 /*
7496 * Set the victim_retry_count to the default un_retry_count
7497 */
7498 un->un_victim_retry_count = (2 * un->un_retry_count);
7499
7500 /*
7501 * Set the reservation release timeout to the default value of
7502 * 5 seconds. This can be overridden by entries in ssd.conf or the
7503 * device config table.
7504 */
7505 un->un_reserve_release_time = 5;
7506
7507 /*
7508 * Set up the default maximum transfer size. Note that this may
7509 * get updated later in the attach, when setting up default wide
7510 * operations for disks.
7511 */
7512 #if defined(__i386) || defined(__amd64)
7513 un->un_max_xfer_size = (uint_t)SD_DEFAULT_MAX_XFER_SIZE;
7514 un->un_partial_dma_supported = 1;
7515 #else
7516 un->un_max_xfer_size = (uint_t)maxphys;
7517 #endif
7518
7519 /*
7520 * Get "allow bus device reset" property (defaults to "enabled" if
7521 * the property was not defined). This is to disable bus resets for
7522 * certain kinds of error recovery. Note: In the future when a run-time
7523 * fibre check is available the soft state flag should default to
7524 * enabled.
7525 */
7526 if (un->un_f_is_fibre == TRUE) {
7527 un->un_f_allow_bus_device_reset = TRUE;
7528 } else {
7529 if (ddi_getprop(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS,
7530 "allow-bus-device-reset", 1) != 0) {
7531 un->un_f_allow_bus_device_reset = TRUE;
7532 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7533 "sd_unit_attach: un:0x%p Bus device reset "
7534 "enabled\n", un);
7535 } else {
7536 un->un_f_allow_bus_device_reset = FALSE;
7537 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7538 "sd_unit_attach: un:0x%p Bus device reset "
7539 "disabled\n", un);
7540 }
7541 }
7542
7543 /*
7544 * Check if this is an ATAPI device. ATAPI devices use Group 1
7545 * Read/Write commands and Group 2 Mode Sense/Select commands.
7546 *
7547 * Note: The "obsolete" way of doing this is to check for the "atapi"
7548 * property. The new "variant" property with a value of "atapi" has been
7549 * introduced so that future 'variants' of standard SCSI behavior (like
7550 * atapi) could be specified by the underlying HBA drivers by supplying
7551 * a new value for the "variant" property, instead of having to define a
7552 * new property.
7553 */
7554 if (ddi_prop_get_int(DDI_DEV_T_ANY, devi, 0, "atapi", -1) != -1) {
7555 un->un_f_cfg_is_atapi = TRUE;
7556 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7557 "sd_unit_attach: un:0x%p Atapi device\n", un);
7558 }
7559 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, devi, 0, "variant",
7560 &variantp) == DDI_PROP_SUCCESS) {
7561 if (strcmp(variantp, "atapi") == 0) {
7562 un->un_f_cfg_is_atapi = TRUE;
7563 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7564 "sd_unit_attach: un:0x%p Atapi device\n", un);
7565 }
7566 ddi_prop_free(variantp);
7567 }
7568
7569 un->un_cmd_timeout = SD_IO_TIME;
7570
7571 un->un_busy_timeout = SD_BSY_TIMEOUT;
7572
7573 /* Info on current states, statuses, etc. (Updated frequently) */
7574 un->un_state = SD_STATE_NORMAL;
7575 un->un_last_state = SD_STATE_NORMAL;
7576
7577 /* Control & status info for command throttling */
7578 un->un_throttle = sd_max_throttle;
7579 un->un_saved_throttle = sd_max_throttle;
7580 un->un_min_throttle = sd_min_throttle;
7581
7582 if (un->un_f_is_fibre == TRUE) {
7583 un->un_f_use_adaptive_throttle = TRUE;
7584 } else {
7585 un->un_f_use_adaptive_throttle = FALSE;
7586 }
7587
7588 /* Removable media support. */
7589 cv_init(&un->un_state_cv, NULL, CV_DRIVER, NULL);
7590 un->un_mediastate = DKIO_NONE;
7591 un->un_specified_mediastate = DKIO_NONE;
7592
7593 /* CVs for suspend/resume (PM or DR) */
7594 cv_init(&un->un_suspend_cv, NULL, CV_DRIVER, NULL);
7595 cv_init(&un->un_disk_busy_cv, NULL, CV_DRIVER, NULL);
7596
7597 /* Power management support. */
7598 un->un_power_level = SD_SPINDLE_UNINIT;
7599
7600 cv_init(&un->un_wcc_cv, NULL, CV_DRIVER, NULL);
7601 un->un_f_wcc_inprog = 0;
7602
7603 /*
7604 * The open/close semaphore is used to serialize threads executing
7605 * in the driver's open & close entry point routines for a given
7606 * instance.
7607 */
7608 (void) sema_init(&un->un_semoclose, 1, NULL, SEMA_DRIVER, NULL);
7609
7610 /*
7611 * The conf file entry and softstate variable is a forceful override,
7612 * meaning a non-zero value must be entered to change the default.
7613 */
7614 un->un_f_disksort_disabled = FALSE;
7615 un->un_f_rmw_type = SD_RMW_TYPE_DEFAULT;
7616 un->un_f_enable_rmw = FALSE;
7617
7618 /*
7619 * GET EVENT STATUS NOTIFICATION media polling enabled by default, but
7620 * can be overridden via [s]sd-config-list "mmc-gesn-polling" property.
7621 */
7622 un->un_f_mmc_gesn_polling = TRUE;
7623
7624 /*
7625 * physical sector size defaults to DEV_BSIZE currently. We can
7626 * override this value via the driver configuration file so we must
7627 * set it before calling sd_read_unit_properties().
7628 */
7629 un->un_phy_blocksize = DEV_BSIZE;
7630
7631 /*
7632 * Retrieve the properties from the static driver table or the driver
7633 * configuration file (.conf) for this unit and update the soft state
7634 * for the device as needed for the indicated properties.
7635 * Note: the property configuration needs to occur here as some of the
7636 * following routines may have dependencies on soft state flags set
7637 * as part of the driver property configuration.
7638 */
7639 sd_read_unit_properties(un);
7640 SD_TRACE(SD_LOG_ATTACH_DETACH, un,
7641 "sd_unit_attach: un:0x%p property configuration complete.\n", un);
7642
7643 /*
7644 * Only if a device has "hotpluggable" property, it is
7645 * treated as hotpluggable device. Otherwise, it is
7646 * regarded as non-hotpluggable one.
7647 */
7648 if (ddi_prop_get_int(DDI_DEV_T_ANY, devi, 0, "hotpluggable",
7649 -1) != -1) {
7650 un->un_f_is_hotpluggable = TRUE;
7651 }
7652
7653 /*
7654 * set unit's attributes(flags) according to "hotpluggable" and
7655 * RMB bit in INQUIRY data.
7656 */
7657 sd_set_unit_attributes(un, devi);
7658
7659 /*
7660 * By default, we mark the capacity, lbasize, and geometry
7661 * as invalid. Only if we successfully read a valid capacity
7662 * will we update the un_blockcount and un_tgt_blocksize with the
7663 * valid values (the geometry will be validated later).
7664 */
7665 un->un_f_blockcount_is_valid = FALSE;
7666 un->un_f_tgt_blocksize_is_valid = FALSE;
7667
7668 /*
7669 * Use DEV_BSIZE and DEV_BSHIFT as defaults, until we can determine
7670 * otherwise.
7671 */
7672 un->un_tgt_blocksize = un->un_sys_blocksize = DEV_BSIZE;
7673 un->un_blockcount = 0;
7674
7675 /*
7676 * Set up the per-instance info needed to determine the correct
7677 * CDBs and other info for issuing commands to the target.
7678 */
7679 sd_init_cdb_limits(un);
7680
7681 /*
7682 * Set up the IO chains to use, based upon the target type.
7683 */
7684 if (un->un_f_non_devbsize_supported) {
7685 un->un_buf_chain_type = SD_CHAIN_INFO_RMMEDIA;
7686 } else {
7687 un->un_buf_chain_type = SD_CHAIN_INFO_DISK;
7688 }
7689 un->un_uscsi_chain_type = SD_CHAIN_INFO_USCSI_CMD;
7690 un->un_direct_chain_type = SD_CHAIN_INFO_DIRECT_CMD;
7691 un->un_priority_chain_type = SD_CHAIN_INFO_PRIORITY_CMD;
7692
7693 un->un_xbuf_attr = ddi_xbuf_attr_create(sizeof (struct sd_xbuf),
7694 sd_xbuf_strategy, un, sd_xbuf_active_limit, sd_xbuf_reserve_limit,
7695 ddi_driver_major(devi), DDI_XBUF_QTHREAD_DRIVER);
7696 ddi_xbuf_attr_register_devinfo(un->un_xbuf_attr, devi);
7697
7698
7699 if (ISCD(un)) {
7700 un->un_additional_codes = sd_additional_codes;
7701 } else {
7702 un->un_additional_codes = NULL;
7703 }
7704
7705 /*
7706 * Create the kstats here so they can be available for attach-time
7707 * routines that send commands to the unit (either polled or via
7708 * sd_send_scsi_cmd).
7709 *
7710 * Note: This is a critical sequence that needs to be maintained:
7711 * 1) Instantiate the kstats here, before any routines using the
7712 * iopath (i.e. sd_send_scsi_cmd).
7713 * 2) Instantiate and initialize the partition stats
7714 * (sd_set_pstats).
7715 * 3) Initialize the error stats (sd_set_errstats), following
7716 * sd_validate_geometry(),sd_register_devid(),
7717 * and sd_cache_control().
7718 */
7719
7720 un->un_stats = kstat_create(sd_label, instance,
7721 NULL, "disk", KSTAT_TYPE_IO, 1, KSTAT_FLAG_PERSISTENT);
7722 if (un->un_stats != NULL) {
7723 un->un_stats->ks_lock = SD_MUTEX(un);
7724 kstat_install(un->un_stats);
7725 }
7726 SD_TRACE(SD_LOG_ATTACH_DETACH, un,
7727 "sd_unit_attach: un:0x%p un_stats created\n", un);
7728
7729 sd_create_errstats(un, instance);
7730 if (un->un_errstats == NULL) {
7731 goto create_errstats_failed;
7732 }
7733 SD_TRACE(SD_LOG_ATTACH_DETACH, un,
7734 "sd_unit_attach: un:0x%p errstats created\n", un);
7735
7736 /*
7737 * The following if/else code was relocated here from below as part
7738 * of the fix for bug (4430280). However with the default setup added
7739 * on entry to this routine, it's no longer absolutely necessary for
7740 * this to be before the call to sd_spin_up_unit.
7741 */
7742 if (SD_IS_PARALLEL_SCSI(un) || SD_IS_SERIAL(un)) {
7743 int tq_trigger_flag = (((devp->sd_inq->inq_ansi == 4) ||
7744 (devp->sd_inq->inq_ansi == 5)) &&
7745 devp->sd_inq->inq_bque) || devp->sd_inq->inq_cmdque;
7746
7747 /*
7748 * If tagged queueing is supported by the target
7749 * and by the host adapter then we will enable it
7750 */
7751 un->un_tagflags = 0;
7752 if ((devp->sd_inq->inq_rdf == RDF_SCSI2) && tq_trigger_flag &&
7753 (un->un_f_arq_enabled == TRUE)) {
7754 if (scsi_ifsetcap(SD_ADDRESS(un), "tagged-qing",
7755 1, 1) == 1) {
7756 un->un_tagflags = FLAG_STAG;
7757 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7758 "sd_unit_attach: un:0x%p tag queueing "
7759 "enabled\n", un);
7760 } else if (scsi_ifgetcap(SD_ADDRESS(un),
7761 "untagged-qing", 0) == 1) {
7762 un->un_f_opt_queueing = TRUE;
7763 un->un_saved_throttle = un->un_throttle =
7764 min(un->un_throttle, 3);
7765 } else {
7766 un->un_f_opt_queueing = FALSE;
7767 un->un_saved_throttle = un->un_throttle = 1;
7768 }
7769 } else if ((scsi_ifgetcap(SD_ADDRESS(un), "untagged-qing", 0)
7770 == 1) && (un->un_f_arq_enabled == TRUE)) {
7771 /* The Host Adapter supports internal queueing. */
7772 un->un_f_opt_queueing = TRUE;
7773 un->un_saved_throttle = un->un_throttle =
7774 min(un->un_throttle, 3);
7775 } else {
7776 un->un_f_opt_queueing = FALSE;
7777 un->un_saved_throttle = un->un_throttle = 1;
7778 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7779 "sd_unit_attach: un:0x%p no tag queueing\n", un);
7780 }
7781
7782 /*
7783 * Enable large transfers for SATA/SAS drives
7784 */
7785 if (SD_IS_SERIAL(un)) {
7786 un->un_max_xfer_size =
7787 ddi_getprop(DDI_DEV_T_ANY, devi, 0,
7788 sd_max_xfer_size, SD_MAX_XFER_SIZE);
7789 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7790 "sd_unit_attach: un:0x%p max transfer "
7791 "size=0x%x\n", un, un->un_max_xfer_size);
7792
7793 }
7794
7795 /* Setup or tear down default wide operations for disks */
7796
7797 /*
7798 * Note: Legacy: it may be possible for both "sd_max_xfer_size"
7799 * and "ssd_max_xfer_size" to exist simultaneously on the same
7800 * system and be set to different values. In the future this
7801 * code may need to be updated when the ssd module is
7802 * obsoleted and removed from the system. (4299588)
7803 */
7804 if (SD_IS_PARALLEL_SCSI(un) &&
7805 (devp->sd_inq->inq_rdf == RDF_SCSI2) &&
7806 (devp->sd_inq->inq_wbus16 || devp->sd_inq->inq_wbus32)) {
7807 if (scsi_ifsetcap(SD_ADDRESS(un), "wide-xfer",
7808 1, 1) == 1) {
7809 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7810 "sd_unit_attach: un:0x%p Wide Transfer "
7811 "enabled\n", un);
7812 }
7813
7814 /*
7815 * If tagged queuing has also been enabled, then
7816 * enable large xfers
7817 */
7818 if (un->un_saved_throttle == sd_max_throttle) {
7819 un->un_max_xfer_size =
7820 ddi_getprop(DDI_DEV_T_ANY, devi, 0,
7821 sd_max_xfer_size, SD_MAX_XFER_SIZE);
7822 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7823 "sd_unit_attach: un:0x%p max transfer "
7824 "size=0x%x\n", un, un->un_max_xfer_size);
7825 }
7826 } else {
7827 if (scsi_ifsetcap(SD_ADDRESS(un), "wide-xfer",
7828 0, 1) == 1) {
7829 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7830 "sd_unit_attach: un:0x%p "
7831 "Wide Transfer disabled\n", un);
7832 }
7833 }
7834 } else {
7835 un->un_tagflags = FLAG_STAG;
7836 un->un_max_xfer_size = ddi_getprop(DDI_DEV_T_ANY,
7837 devi, 0, sd_max_xfer_size, SD_MAX_XFER_SIZE);
7838 }
7839
7840 /*
7841 * If this target supports LUN reset, try to enable it.
7842 */
7843 if (un->un_f_lun_reset_enabled) {
7844 if (scsi_ifsetcap(SD_ADDRESS(un), "lun-reset", 1, 1) == 1) {
7845 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_unit_attach: "
7846 "un:0x%p lun_reset capability set\n", un);
7847 } else {
7848 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_unit_attach: "
7849 "un:0x%p lun-reset capability not set\n", un);
7850 }
7851 }
7852
7853 /*
7854 * Adjust the maximum transfer size. This is to fix
7855 * the problem of partial DMA support on SPARC. Some
7856 * HBA driver, like aac, has very small dma_attr_maxxfer
7857 * size, which requires partial DMA support on SPARC.
7858 * In the future the SPARC pci nexus driver may solve
7859 * the problem instead of this fix.
7860 */
7861 max_xfer_size = scsi_ifgetcap(SD_ADDRESS(un), "dma-max", 1);
7862 if ((max_xfer_size > 0) && (max_xfer_size < un->un_max_xfer_size)) {
7863 /* We need DMA partial even on sparc to ensure sddump() works */
7864 un->un_max_xfer_size = max_xfer_size;
7865 if (un->un_partial_dma_supported == 0)
7866 un->un_partial_dma_supported = 1;
7867 }
7868 if (ddi_prop_get_int(DDI_DEV_T_ANY, SD_DEVINFO(un),
7869 DDI_PROP_DONTPASS, "buf_break", 0) == 1) {
7870 if (ddi_xbuf_attr_setup_brk(un->un_xbuf_attr,
7871 un->un_max_xfer_size) == 1) {
7872 un->un_buf_breakup_supported = 1;
7873 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_unit_attach: "
7874 "un:0x%p Buf breakup enabled\n", un);
7875 }
7876 }
7877
7878 /*
7879 * Set PKT_DMA_PARTIAL flag.
7880 */
7881 if (un->un_partial_dma_supported == 1) {
7882 un->un_pkt_flags = PKT_DMA_PARTIAL;
7883 } else {
7884 un->un_pkt_flags = 0;
7885 }
7886
7887 /* Initialize sd_ssc_t for internal uscsi commands */
7888 ssc = sd_ssc_init(un);
7889 scsi_fm_init(devp);
7890
7891 /*
7892 * Allocate memory for SCSI FMA stuffs.
7893 */
7894 un->un_fm_private =
7895 kmem_zalloc(sizeof (struct sd_fm_internal), KM_SLEEP);
7896 sfip = (struct sd_fm_internal *)un->un_fm_private;
7897 sfip->fm_ssc.ssc_uscsi_cmd = &sfip->fm_ucmd;
7898 sfip->fm_ssc.ssc_uscsi_info = &sfip->fm_uinfo;
7899 sfip->fm_ssc.ssc_un = un;
7900
7901 if (ISCD(un) ||
7902 un->un_f_has_removable_media ||
7903 devp->sd_fm_capable == DDI_FM_NOT_CAPABLE) {
7904 /*
7905 * We don't touch CDROM or the DDI_FM_NOT_CAPABLE device.
7906 * Their log are unchanged.
7907 */
7908 sfip->fm_log_level = SD_FM_LOG_NSUP;
7909 } else {
7910 /*
7911 * If enter here, it should be non-CDROM and FM-capable
7912 * device, and it will not keep the old scsi_log as before
7913 * in /var/adm/messages. However, the property
7914 * "fm-scsi-log" will control whether the FM telemetry will
7915 * be logged in /var/adm/messages.
7916 */
7917 int fm_scsi_log;
7918 fm_scsi_log = ddi_prop_get_int(DDI_DEV_T_ANY, SD_DEVINFO(un),
7919 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "fm-scsi-log", 0);
7920
7921 if (fm_scsi_log)
7922 sfip->fm_log_level = SD_FM_LOG_EREPORT;
7923 else
7924 sfip->fm_log_level = SD_FM_LOG_SILENT;
7925 }
7926
7927 /*
7928 * At this point in the attach, we have enough info in the
7929 * soft state to be able to issue commands to the target.
7930 *
7931 * All command paths used below MUST issue their commands as
7932 * SD_PATH_DIRECT. This is important as intermediate layers
7933 * are not all initialized yet (such as PM).
7934 */
7935
7936 /*
7937 * Send a TEST UNIT READY command to the device. This should clear
7938 * any outstanding UNIT ATTENTION that may be present.
7939 *
7940 * Note: Don't check for success, just track if there is a reservation,
7941 * this is a throw away command to clear any unit attentions.
7942 *
7943 * Note: This MUST be the first command issued to the target during
7944 * attach to ensure power on UNIT ATTENTIONS are cleared.
7945 * Pass in flag SD_DONT_RETRY_TUR to prevent the long delays associated
7946 * with attempts at spinning up a device with no media.
7947 */
7948 status = sd_send_scsi_TEST_UNIT_READY(ssc, SD_DONT_RETRY_TUR);
7949 if (status != 0) {
7950 if (status == EACCES)
7951 reservation_flag = SD_TARGET_IS_RESERVED;
7952 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
7953 }
7954
7955 /*
7956 * If the device is NOT a removable media device, attempt to spin
7957 * it up (using the START_STOP_UNIT command) and read its capacity
7958 * (using the READ CAPACITY command). Note, however, that either
7959 * of these could fail and in some cases we would continue with
7960 * the attach despite the failure (see below).
7961 */
7962 if (un->un_f_descr_format_supported) {
7963
7964 switch (sd_spin_up_unit(ssc)) {
7965 case 0:
7966 /*
7967 * Spin-up was successful; now try to read the
7968 * capacity. If successful then save the results
7969 * and mark the capacity & lbasize as valid.
7970 */
7971 SD_TRACE(SD_LOG_ATTACH_DETACH, un,
7972 "sd_unit_attach: un:0x%p spin-up successful\n", un);
7973
7974 status = sd_send_scsi_READ_CAPACITY(ssc, &capacity,
7975 &lbasize, SD_PATH_DIRECT);
7976
7977 switch (status) {
7978 case 0: {
7979 if (capacity > DK_MAX_BLOCKS) {
7980 #ifdef _LP64
7981 if ((capacity + 1) >
7982 SD_GROUP1_MAX_ADDRESS) {
7983 /*
7984 * Enable descriptor format
7985 * sense data so that we can
7986 * get 64 bit sense data
7987 * fields.
7988 */
7989 sd_enable_descr_sense(ssc);
7990 }
7991 #else
7992 /* 32-bit kernels can't handle this */
7993 scsi_log(SD_DEVINFO(un),
7994 sd_label, CE_WARN,
7995 "disk has %llu blocks, which "
7996 "is too large for a 32-bit "
7997 "kernel", capacity);
7998
7999 #if defined(__i386) || defined(__amd64)
8000 /*
8001 * 1TB disk was treated as (1T - 512)B
8002 * in the past, so that it might have
8003 * valid VTOC and solaris partitions,
8004 * we have to allow it to continue to
8005 * work.
8006 */
8007 if (capacity -1 > DK_MAX_BLOCKS)
8008 #endif
8009 goto spinup_failed;
8010 #endif
8011 }
8012
8013 /*
8014 * Here it's not necessary to check the case:
8015 * the capacity of the device is bigger than
8016 * what the max hba cdb can support. Because
8017 * sd_send_scsi_READ_CAPACITY will retrieve
8018 * the capacity by sending USCSI command, which
8019 * is constrained by the max hba cdb. Actually,
8020 * sd_send_scsi_READ_CAPACITY will return
8021 * EINVAL when using bigger cdb than required
8022 * cdb length. Will handle this case in
8023 * "case EINVAL".
8024 */
8025
8026 /*
8027 * The following relies on
8028 * sd_send_scsi_READ_CAPACITY never
8029 * returning 0 for capacity and/or lbasize.
8030 */
8031 sd_update_block_info(un, lbasize, capacity);
8032
8033 SD_INFO(SD_LOG_ATTACH_DETACH, un,
8034 "sd_unit_attach: un:0x%p capacity = %ld "
8035 "blocks; lbasize= %ld.\n", un,
8036 un->un_blockcount, un->un_tgt_blocksize);
8037
8038 break;
8039 }
8040 case EINVAL:
8041 /*
8042 * In the case where the max-cdb-length property
8043 * is smaller than the required CDB length for
8044 * a SCSI device, a target driver can fail to
8045 * attach to that device.
8046 */
8047 scsi_log(SD_DEVINFO(un),
8048 sd_label, CE_WARN,
8049 "disk capacity is too large "
8050 "for current cdb length");
8051 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
8052
8053 goto spinup_failed;
8054 case EACCES:
8055 /*
8056 * Should never get here if the spin-up
8057 * succeeded, but code it in anyway.
8058 * From here, just continue with the attach...
8059 */
8060 SD_INFO(SD_LOG_ATTACH_DETACH, un,
8061 "sd_unit_attach: un:0x%p "
8062 "sd_send_scsi_READ_CAPACITY "
8063 "returned reservation conflict\n", un);
8064 reservation_flag = SD_TARGET_IS_RESERVED;
8065 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
8066 break;
8067 default:
8068 /*
8069 * Likewise, should never get here if the
8070 * spin-up succeeded. Just continue with
8071 * the attach...
8072 */
8073 if (status == EIO)
8074 sd_ssc_assessment(ssc,
8075 SD_FMT_STATUS_CHECK);
8076 else
8077 sd_ssc_assessment(ssc,
8078 SD_FMT_IGNORE);
8079 break;
8080 }
8081 break;
8082 case EACCES:
8083 /*
8084 * Device is reserved by another host. In this case
8085 * we could not spin it up or read the capacity, but
8086 * we continue with the attach anyway.
8087 */
8088 SD_INFO(SD_LOG_ATTACH_DETACH, un,
8089 "sd_unit_attach: un:0x%p spin-up reservation "
8090 "conflict.\n", un);
8091 reservation_flag = SD_TARGET_IS_RESERVED;
8092 break;
8093 default:
8094 /* Fail the attach if the spin-up failed. */
8095 SD_INFO(SD_LOG_ATTACH_DETACH, un,
8096 "sd_unit_attach: un:0x%p spin-up failed.", un);
8097 goto spinup_failed;
8098 }
8099
8100 }
8101
8102 /*
8103 * Check to see if this is a MMC drive
8104 */
8105 if (ISCD(un)) {
8106 sd_set_mmc_caps(ssc);
8107 }
8108
8109 /*
8110 * Add a zero-length attribute to tell the world we support
8111 * kernel ioctls (for layered drivers)
8112 */
8113 (void) ddi_prop_create(DDI_DEV_T_NONE, devi, DDI_PROP_CANSLEEP,
8114 DDI_KERNEL_IOCTL, NULL, 0);
8115
8116 /*
8117 * Add a boolean property to tell the world we support
8118 * the B_FAILFAST flag (for layered drivers)
8119 */
8120 (void) ddi_prop_create(DDI_DEV_T_NONE, devi, DDI_PROP_CANSLEEP,
8121 "ddi-failfast-supported", NULL, 0);
8122
8123 /*
8124 * Initialize power management
8125 */
8126 mutex_init(&un->un_pm_mutex, NULL, MUTEX_DRIVER, NULL);
8127 cv_init(&un->un_pm_busy_cv, NULL, CV_DRIVER, NULL);
8128 sd_setup_pm(ssc, devi);
8129 if (un->un_f_pm_is_enabled == FALSE) {
8130 /*
8131 * For performance, point to a jump table that does
8132 * not include pm.
8133 * The direct and priority chains don't change with PM.
8134 *
8135 * Note: this is currently done based on individual device
8136 * capabilities. When an interface for determining system
8137 * power enabled state becomes available, or when additional
8138 * layers are added to the command chain, these values will
8139 * have to be re-evaluated for correctness.
8140 */
8141 if (un->un_f_non_devbsize_supported) {
8142 un->un_buf_chain_type = SD_CHAIN_INFO_RMMEDIA_NO_PM;
8143 } else {
8144 un->un_buf_chain_type = SD_CHAIN_INFO_DISK_NO_PM;
8145 }
8146 un->un_uscsi_chain_type = SD_CHAIN_INFO_USCSI_CMD_NO_PM;
8147 }
8148
8149 /*
8150 * This property is set to 0 by HA software to avoid retries
8151 * on a reserved disk. (The preferred property name is
8152 * "retry-on-reservation-conflict") (1189689)
8153 *
8154 * Note: The use of a global here can have unintended consequences. A
8155 * per instance variable is preferable to match the capabilities of
8156 * different underlying hba's (4402600)
8157 */
8158 sd_retry_on_reservation_conflict = ddi_getprop(DDI_DEV_T_ANY, devi,
8159 DDI_PROP_DONTPASS, "retry-on-reservation-conflict",
8160 sd_retry_on_reservation_conflict);
8161 if (sd_retry_on_reservation_conflict != 0) {
8162 sd_retry_on_reservation_conflict = ddi_getprop(DDI_DEV_T_ANY,
8163 devi, DDI_PROP_DONTPASS, sd_resv_conflict_name,
8164 sd_retry_on_reservation_conflict);
8165 }
8166
8167 /* Set up options for QFULL handling. */
8168 if ((rval = ddi_getprop(DDI_DEV_T_ANY, devi, 0,
8169 "qfull-retries", -1)) != -1) {
8170 (void) scsi_ifsetcap(SD_ADDRESS(un), "qfull-retries",
8171 rval, 1);
8172 }
8173 if ((rval = ddi_getprop(DDI_DEV_T_ANY, devi, 0,
8174 "qfull-retry-interval", -1)) != -1) {
8175 (void) scsi_ifsetcap(SD_ADDRESS(un), "qfull-retry-interval",
8176 rval, 1);
8177 }
8178
8179 /*
8180 * This just prints a message that announces the existence of the
8181 * device. The message is always printed in the system logfile, but
8182 * only appears on the console if the system is booted with the
8183 * -v (verbose) argument.
8184 */
8185 ddi_report_dev(devi);
8186
8187 un->un_mediastate = DKIO_NONE;
8188
8189 /*
8190 * Check Block Device Characteristics VPD.
8191 */
8192 sd_check_bdc_vpd(ssc);
8193
8194 /*
8195 * Check whether the drive is in emulation mode.
8196 */
8197 sd_check_emulation_mode(ssc);
8198
8199 cmlb_alloc_handle(&un->un_cmlbhandle);
8200
8201 #if defined(__i386) || defined(__amd64)
8202 /*
8203 * On x86, compensate for off-by-1 legacy error
8204 */
8205 if (!un->un_f_has_removable_media && !un->un_f_is_hotpluggable &&
8206 (lbasize == un->un_sys_blocksize))
8207 offbyone = CMLB_OFF_BY_ONE;
8208 #endif
8209
8210 if (cmlb_attach(devi, &sd_tgops, (int)devp->sd_inq->inq_dtype,
8211 VOID2BOOLEAN(un->un_f_has_removable_media != 0),
8212 VOID2BOOLEAN(un->un_f_is_hotpluggable != 0),
8213 un->un_node_type, offbyone, un->un_cmlbhandle,
8214 (void *)SD_PATH_DIRECT) != 0) {
8215 goto cmlb_attach_failed;
8216 }
8217
8218
8219 /*
8220 * Read and validate the device's geometry (ie, disk label)
8221 * A new unformatted drive will not have a valid geometry, but
8222 * the driver needs to successfully attach to this device so
8223 * the drive can be formatted via ioctls.
8224 */
8225 geom_label_valid = (cmlb_validate(un->un_cmlbhandle, 0,
8226 (void *)SD_PATH_DIRECT) == 0) ? 1: 0;
8227
8228 mutex_enter(SD_MUTEX(un));
8229
8230 /*
8231 * Read and initialize the devid for the unit.
8232 */
8233 if (un->un_f_devid_supported) {
8234 sd_register_devid(ssc, devi, reservation_flag);
8235 }
8236 mutex_exit(SD_MUTEX(un));
8237
8238 #if (defined(__fibre))
8239 /*
8240 * Register callbacks for fibre only. You can't do this solely
8241 * on the basis of the devid_type because this is hba specific.
8242 * We need to query our hba capabilities to find out whether to
8243 * register or not.
8244 */
8245 if (un->un_f_is_fibre) {
8246 if (strcmp(un->un_node_type, DDI_NT_BLOCK_CHAN)) {
8247 sd_init_event_callbacks(un);
8248 SD_TRACE(SD_LOG_ATTACH_DETACH, un,
8249 "sd_unit_attach: un:0x%p event callbacks inserted",
8250 un);
8251 }
8252 }
8253 #endif
8254
8255 if (un->un_f_opt_disable_cache == TRUE) {
8256 /*
8257 * Disable both read cache and write cache. This is
8258 * the historic behavior of the keywords in the config file.
8259 */
8260 if (sd_cache_control(ssc, SD_CACHE_DISABLE, SD_CACHE_DISABLE) !=
8261 0) {
8262 SD_ERROR(SD_LOG_ATTACH_DETACH, un,
8263 "sd_unit_attach: un:0x%p Could not disable "
8264 "caching", un);
8265 goto devid_failed;
8266 }
8267 }
8268
8269 /*
8270 * Check the value of the WCE bit and if it's allowed to be changed,
8271 * set un_f_write_cache_enabled and un_f_cache_mode_changeable
8272 * accordingly.
8273 */
8274 (void) sd_get_write_cache_enabled(ssc, &wc_enabled);
8275 sd_get_write_cache_changeable(ssc, &wc_changeable);
8276 mutex_enter(SD_MUTEX(un));
8277 un->un_f_write_cache_enabled = (wc_enabled != 0);
8278 un->un_f_cache_mode_changeable = (wc_changeable != 0);
8279 mutex_exit(SD_MUTEX(un));
8280
8281 if ((un->un_f_rmw_type != SD_RMW_TYPE_RETURN_ERROR &&
8282 un->un_tgt_blocksize != DEV_BSIZE) ||
8283 un->un_f_enable_rmw) {
8284 if (!(un->un_wm_cache)) {
8285 (void) snprintf(name_str, sizeof (name_str),
8286 "%s%d_cache",
8287 ddi_driver_name(SD_DEVINFO(un)),
8288 ddi_get_instance(SD_DEVINFO(un)));
8289 un->un_wm_cache = kmem_cache_create(
8290 name_str, sizeof (struct sd_w_map),
8291 8, sd_wm_cache_constructor,
8292 sd_wm_cache_destructor, NULL,
8293 (void *)un, NULL, 0);
8294 if (!(un->un_wm_cache)) {
8295 goto wm_cache_failed;
8296 }
8297 }
8298 }
8299
8300 /*
8301 * Check the value of the NV_SUP bit and set
8302 * un_f_suppress_cache_flush accordingly.
8303 */
8304 sd_get_nv_sup(ssc);
8305
8306 /*
8307 * Find out what type of reservation this disk supports.
8308 */
8309 status = sd_send_scsi_PERSISTENT_RESERVE_IN(ssc, SD_READ_KEYS, 0, NULL);
8310
8311 switch (status) {
8312 case 0:
8313 /*
8314 * SCSI-3 reservations are supported.
8315 */
8316 un->un_reservation_type = SD_SCSI3_RESERVATION;
8317 SD_INFO(SD_LOG_ATTACH_DETACH, un,
8318 "sd_unit_attach: un:0x%p SCSI-3 reservations\n", un);
8319 break;
8320 case ENOTSUP:
8321 /*
8322 * The PERSISTENT RESERVE IN command would not be recognized by
8323 * a SCSI-2 device, so assume the reservation type is SCSI-2.
8324 */
8325 SD_INFO(SD_LOG_ATTACH_DETACH, un,
8326 "sd_unit_attach: un:0x%p SCSI-2 reservations\n", un);
8327 un->un_reservation_type = SD_SCSI2_RESERVATION;
8328
8329 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
8330 break;
8331 default:
8332 /*
8333 * default to SCSI-3 reservations
8334 */
8335 SD_INFO(SD_LOG_ATTACH_DETACH, un,
8336 "sd_unit_attach: un:0x%p default SCSI3 reservations\n", un);
8337 un->un_reservation_type = SD_SCSI3_RESERVATION;
8338
8339 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
8340 break;
8341 }
8342
8343 /*
8344 * Set the pstat and error stat values here, so data obtained during the
8345 * previous attach-time routines is available.
8346 *
8347 * Note: This is a critical sequence that needs to be maintained:
8348 * 1) Instantiate the kstats before any routines using the iopath
8349 * (i.e. sd_send_scsi_cmd).
8350 * 2) Initialize the error stats (sd_set_errstats) and partition
8351 * stats (sd_set_pstats)here, following
8352 * cmlb_validate_geometry(), sd_register_devid(), and
8353 * sd_cache_control().
8354 */
8355
8356 if (un->un_f_pkstats_enabled && geom_label_valid) {
8357 sd_set_pstats(un);
8358 SD_TRACE(SD_LOG_IO_PARTITION, un,
8359 "sd_unit_attach: un:0x%p pstats created and set\n", un);
8360 }
8361
8362 sd_set_errstats(un);
8363 SD_TRACE(SD_LOG_ATTACH_DETACH, un,
8364 "sd_unit_attach: un:0x%p errstats set\n", un);
8365
8366
8367 /*
8368 * After successfully attaching an instance, we record the information
8369 * of how many luns have been attached on the relative target and
8370 * controller for parallel SCSI. This information is used when sd tries
8371 * to set the tagged queuing capability in HBA.
8372 */
8373 if (SD_IS_PARALLEL_SCSI(un) && (tgt >= 0) && (tgt < NTARGETS_WIDE)) {
8374 sd_scsi_update_lun_on_target(pdip, tgt, SD_SCSI_LUN_ATTACH);
8375 }
8376
8377 SD_TRACE(SD_LOG_ATTACH_DETACH, un,
8378 "sd_unit_attach: un:0x%p exit success\n", un);
8379
8380 /* Uninitialize sd_ssc_t pointer */
8381 sd_ssc_fini(ssc);
8382
8383 return (DDI_SUCCESS);
8384
8385 /*
8386 * An error occurred during the attach; clean up & return failure.
8387 */
8388 wm_cache_failed:
8389 devid_failed:
8390 ddi_remove_minor_node(devi, NULL);
8391
8392 cmlb_attach_failed:
8393 /*
8394 * Cleanup from the scsi_ifsetcap() calls (437868)
8395 */
8396 (void) scsi_ifsetcap(SD_ADDRESS(un), "lun-reset", 0, 1);
8397 (void) scsi_ifsetcap(SD_ADDRESS(un), "wide-xfer", 0, 1);
8398
8399 /*
8400 * Refer to the comments of setting tagged-qing in the beginning of
8401 * sd_unit_attach. We can only disable tagged queuing when there is
8402 * no lun attached on the target.
8403 */
8404 if (sd_scsi_get_target_lun_count(pdip, tgt) < 1) {
8405 (void) scsi_ifsetcap(SD_ADDRESS(un), "tagged-qing", 0, 1);
8406 }
8407
8408 if (un->un_f_is_fibre == FALSE) {
8409 (void) scsi_ifsetcap(SD_ADDRESS(un), "auto-rqsense", 0, 1);
8410 }
8411
8412 spinup_failed:
8413
8414 /* Uninitialize sd_ssc_t pointer */
8415 sd_ssc_fini(ssc);
8416
8417 mutex_enter(SD_MUTEX(un));
8418
8419 /* Deallocate SCSI FMA memory spaces */
8420 kmem_free(un->un_fm_private, sizeof (struct sd_fm_internal));
8421
8422 /* Cancel callback for SD_PATH_DIRECT_PRIORITY cmd. restart */
8423 if (un->un_direct_priority_timeid != NULL) {
8424 timeout_id_t temp_id = un->un_direct_priority_timeid;
8425 un->un_direct_priority_timeid = NULL;
8426 mutex_exit(SD_MUTEX(un));
8427 (void) untimeout(temp_id);
8428 mutex_enter(SD_MUTEX(un));
8429 }
8430
8431 /* Cancel any pending start/stop timeouts */
8432 if (un->un_startstop_timeid != NULL) {
8433 timeout_id_t temp_id = un->un_startstop_timeid;
8434 un->un_startstop_timeid = NULL;
8435 mutex_exit(SD_MUTEX(un));
8436 (void) untimeout(temp_id);
8437 mutex_enter(SD_MUTEX(un));
8438 }
8439
8440 /* Cancel any pending reset-throttle timeouts */
8441 if (un->un_reset_throttle_timeid != NULL) {
8442 timeout_id_t temp_id = un->un_reset_throttle_timeid;
8443 un->un_reset_throttle_timeid = NULL;
8444 mutex_exit(SD_MUTEX(un));
8445 (void) untimeout(temp_id);
8446 mutex_enter(SD_MUTEX(un));
8447 }
8448
8449 /* Cancel rmw warning message timeouts */
8450 if (un->un_rmw_msg_timeid != NULL) {
8451 timeout_id_t temp_id = un->un_rmw_msg_timeid;
8452 un->un_rmw_msg_timeid = NULL;
8453 mutex_exit(SD_MUTEX(un));
8454 (void) untimeout(temp_id);
8455 mutex_enter(SD_MUTEX(un));
8456 }
8457
8458 /* Cancel any pending retry timeouts */
8459 if (un->un_retry_timeid != NULL) {
8460 timeout_id_t temp_id = un->un_retry_timeid;
8461 un->un_retry_timeid = NULL;
8462 mutex_exit(SD_MUTEX(un));
8463 (void) untimeout(temp_id);
8464 mutex_enter(SD_MUTEX(un));
8465 }
8466
8467 /* Cancel any pending delayed cv broadcast timeouts */
8468 if (un->un_dcvb_timeid != NULL) {
8469 timeout_id_t temp_id = un->un_dcvb_timeid;
8470 un->un_dcvb_timeid = NULL;
8471 mutex_exit(SD_MUTEX(un));
8472 (void) untimeout(temp_id);
8473 mutex_enter(SD_MUTEX(un));
8474 }
8475
8476 mutex_exit(SD_MUTEX(un));
8477
8478 /* There should not be any in-progress I/O so ASSERT this check */
8479 ASSERT(un->un_ncmds_in_transport == 0);
8480 ASSERT(un->un_ncmds_in_driver == 0);
8481
8482 /* Do not free the softstate if the callback routine is active */
8483 sd_sync_with_callback(un);
8484
8485 /*
8486 * Partition stats apparently are not used with removables. These would
8487 * not have been created during attach, so no need to clean them up...
8488 */
8489 if (un->un_errstats != NULL) {
8490 kstat_delete(un->un_errstats);
8491 un->un_errstats = NULL;
8492 }
8493
8494 create_errstats_failed:
8495
8496 if (un->un_stats != NULL) {
8497 kstat_delete(un->un_stats);
8498 un->un_stats = NULL;
8499 }
8500
8501 ddi_xbuf_attr_unregister_devinfo(un->un_xbuf_attr, devi);
8502 ddi_xbuf_attr_destroy(un->un_xbuf_attr);
8503
8504 ddi_prop_remove_all(devi);
8505 sema_destroy(&un->un_semoclose);
8506 cv_destroy(&un->un_state_cv);
8507
8508 sd_free_rqs(un);
8509
8510 alloc_rqs_failed:
8511
8512 devp->sd_private = NULL;
8513 bzero(un, sizeof (struct sd_lun)); /* Clear any stale data! */
8514
8515 /*
8516 * Note: the man pages are unclear as to whether or not doing a
8517 * ddi_soft_state_free(sd_state, instance) is the right way to
8518 * clean up after the ddi_soft_state_zalloc() if the subsequent
8519 * ddi_get_soft_state() fails. The implication seems to be
8520 * that the get_soft_state cannot fail if the zalloc succeeds.
8521 */
8522 #ifndef XPV_HVM_DRIVER
8523 ddi_soft_state_free(sd_state, instance);
8524 #endif /* !XPV_HVM_DRIVER */
8525
8526 probe_failed:
8527 scsi_unprobe(devp);
8528
8529 return (DDI_FAILURE);
8530 }
8531
8532
8533 /*
8534 * Function: sd_unit_detach
8535 *
8536 * Description: Performs DDI_DETACH processing for sddetach().
8537 *
8538 * Return Code: DDI_SUCCESS
8539 * DDI_FAILURE
8540 *
8541 * Context: Kernel thread context
8542 */
8543
8544 static int
8545 sd_unit_detach(dev_info_t *devi)
8546 {
8547 struct scsi_device *devp;
8548 struct sd_lun *un;
8549 int i;
8550 int tgt;
8551 dev_t dev;
8552 dev_info_t *pdip = ddi_get_parent(devi);
8553 int instance = ddi_get_instance(devi);
8554 int devigone = DEVI(devi)->devi_gone;
8555
8556 mutex_enter(&sd_detach_mutex);
8557
8558 /*
8559 * Fail the detach for any of the following:
8560 * - Unable to get the sd_lun struct for the instance
8561 * - Another thread is already detaching this instance
8562 * - Another thread is currently performing an open
8563 *
8564 * Additionaly, if "device gone" flag is not set:
8565 * - There are outstanding commands in driver
8566 * - There are outstanding commands in transport
8567 */
8568 devp = ddi_get_driver_private(devi);
8569 if (devp == NULL || (un = (struct sd_lun *)devp->sd_private) == NULL ||
8570 un->un_detach_count != 0 || un->un_opens_in_progress != 0 ||
8571 (!devigone && (un->un_ncmds_in_driver != 0 ||
8572 un->un_ncmds_in_transport != 0 ||
8573 un->un_state == SD_STATE_RWAIT))) {
8574 mutex_exit(&sd_detach_mutex);
8575 return (DDI_FAILURE);
8576 }
8577
8578 SD_TRACE(SD_LOG_ATTACH_DETACH, un, "%s: entry 0x%p\n", __func__, un);
8579
8580 /*
8581 * Mark this instance as currently in a detach, to inhibit any
8582 * opens from a layered driver.
8583 */
8584 un->un_detach_count++;
8585 mutex_exit(&sd_detach_mutex);
8586
8587 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS,
8588 SCSI_ADDR_PROP_TARGET, -1);
8589
8590 dev = sd_make_device(SD_DEVINFO(un));
8591
8592 mutex_enter(SD_MUTEX(un));
8593
8594 /*
8595 * Fail the detach if there are any outstanding layered
8596 * opens on this device.
8597 */
8598 for (i = 0; i < NDKMAP; i++) {
8599 if (un->un_ocmap.lyropen[i] != 0) {
8600 goto err_notclosed;
8601 }
8602 }
8603
8604 /*
8605 * If we have the device reserved, release the reservation.
8606 */
8607 if (!devigone &&
8608 (un->un_resvd_status & SD_RESERVE) &&
8609 !(un->un_resvd_status & SD_LOST_RESERVE)) {
8610 mutex_exit(SD_MUTEX(un));
8611 /*
8612 * Note: sd_reserve_release sends a command to the device
8613 * via the sd_ioctlcmd() path, and can sleep.
8614 */
8615 if (sd_reserve_release(dev, SD_RELEASE) != 0) {
8616 SD_ERROR(SD_LOG_ATTACH_DETACH, un,
8617 "%s: cannot release reservation\n", __func__);
8618 }
8619 } else {
8620 mutex_exit(SD_MUTEX(un));
8621 }
8622
8623 /*
8624 * Untimeout any reserve recover, throttle reset, restart unit
8625 * and delayed broadcast timeout threads. Protect the timeout pointer
8626 * from getting nulled by their callback functions.
8627 */
8628 mutex_enter(SD_MUTEX(un));
8629 if (un->un_resvd_timeid != NULL) {
8630 timeout_id_t temp_id = un->un_resvd_timeid;
8631 un->un_resvd_timeid = NULL;
8632 mutex_exit(SD_MUTEX(un));
8633 (void) untimeout(temp_id);
8634 mutex_enter(SD_MUTEX(un));
8635 }
8636
8637 if (un->un_reset_throttle_timeid != NULL) {
8638 timeout_id_t temp_id = un->un_reset_throttle_timeid;
8639 un->un_reset_throttle_timeid = NULL;
8640 mutex_exit(SD_MUTEX(un));
8641 (void) untimeout(temp_id);
8642 mutex_enter(SD_MUTEX(un));
8643 }
8644
8645 if (un->un_startstop_timeid != NULL) {
8646 timeout_id_t temp_id = un->un_startstop_timeid;
8647 un->un_startstop_timeid = NULL;
8648 mutex_exit(SD_MUTEX(un));
8649 (void) untimeout(temp_id);
8650 mutex_enter(SD_MUTEX(un));
8651 }
8652
8653 if (un->un_rmw_msg_timeid != NULL) {
8654 timeout_id_t temp_id = un->un_rmw_msg_timeid;
8655 un->un_rmw_msg_timeid = NULL;
8656 mutex_exit(SD_MUTEX(un));
8657 (void) untimeout(temp_id);
8658 mutex_enter(SD_MUTEX(un));
8659 }
8660
8661 if (un->un_dcvb_timeid != NULL) {
8662 timeout_id_t temp_id = un->un_dcvb_timeid;
8663 un->un_dcvb_timeid = NULL;
8664 mutex_exit(SD_MUTEX(un));
8665 (void) untimeout(temp_id);
8666 } else {
8667 mutex_exit(SD_MUTEX(un));
8668 }
8669
8670 /* Remove any pending reservation reclaim requests for this device */
8671 sd_rmv_resv_reclaim_req(dev);
8672
8673 mutex_enter(SD_MUTEX(un));
8674 if (un->un_retry_timeid != NULL) {
8675 timeout_id_t temp_id = un->un_retry_timeid;
8676 un->un_retry_timeid = NULL;
8677 mutex_exit(SD_MUTEX(un));
8678 (void) untimeout(temp_id);
8679 mutex_enter(SD_MUTEX(un));
8680 }
8681
8682 /* Cancel any pending callbacks for SD_PATH_DIRECT_PRIORITY cmd. */
8683 if (un->un_direct_priority_timeid != NULL) {
8684 timeout_id_t temp_id = un->un_direct_priority_timeid;
8685 un->un_direct_priority_timeid = NULL;
8686 mutex_exit(SD_MUTEX(un));
8687 (void) untimeout(temp_id);
8688 mutex_enter(SD_MUTEX(un));
8689 }
8690
8691 /* Cancel any active multi-host disk watch thread requests */
8692 if (un->un_mhd_token != NULL) {
8693 mutex_exit(SD_MUTEX(un));
8694 _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::un_mhd_token));
8695 if (scsi_watch_request_terminate(un->un_mhd_token,
8696 SCSI_WATCH_TERMINATE_NOWAIT)) {
8697 SD_ERROR(SD_LOG_ATTACH_DETACH, un,
8698 "%s: cannot cancel mhd watch request\n", __func__);
8699 /*
8700 * Note: We are returning here after having removed
8701 * some driver timeouts above. This is consistent with
8702 * the legacy implementation but perhaps the watch
8703 * terminate call should be made with the wait flag set.
8704 */
8705 goto err_stillbusy;
8706 }
8707 mutex_enter(SD_MUTEX(un));
8708 un->un_mhd_token = NULL;
8709 }
8710
8711 if (un->un_swr_token != NULL) {
8712 mutex_exit(SD_MUTEX(un));
8713 _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::un_swr_token));
8714 if (scsi_watch_request_terminate(un->un_swr_token,
8715 SCSI_WATCH_TERMINATE_NOWAIT)) {
8716 SD_ERROR(SD_LOG_ATTACH_DETACH, un,
8717 "%s: cannot cancel swr watch request\n", __func__);
8718 /*
8719 * Note: We are returning here after having removed
8720 * some driver timeouts above. This is consistent with
8721 * the legacy implementation but perhaps the watch
8722 * terminate call should be made with the wait flag set.
8723 */
8724 goto err_stillbusy;
8725 }
8726 mutex_enter(SD_MUTEX(un));
8727 un->un_swr_token = NULL;
8728 }
8729
8730 /*
8731 * Clear any scsi_reset_notifies. We clear the reset notifies
8732 * if we have not registered one.
8733 * Note: The sd_mhd_reset_notify_cb() fn tries to acquire SD_MUTEX!
8734 */
8735 mutex_exit(SD_MUTEX(un));
8736 (void) scsi_reset_notify(SD_ADDRESS(un), SCSI_RESET_CANCEL,
8737 sd_mhd_reset_notify_cb, (caddr_t)un);
8738
8739 /*
8740 * protect the timeout pointers from getting nulled by
8741 * their callback functions during the cancellation process.
8742 * In such a scenario untimeout can be invoked with a null value.
8743 */
8744 _NOTE(NO_COMPETING_THREADS_NOW);
8745
8746 mutex_enter(&un->un_pm_mutex);
8747 if (un->un_pm_idle_timeid != NULL) {
8748 timeout_id_t temp_id = un->un_pm_idle_timeid;
8749 un->un_pm_idle_timeid = NULL;
8750 mutex_exit(&un->un_pm_mutex);
8751
8752 /*
8753 * Timeout is active; cancel it.
8754 * Note that it'll never be active on a device
8755 * that does not support PM therefore we don't
8756 * have to check before calling pm_idle_component.
8757 */
8758 (void) untimeout(temp_id);
8759 (void) pm_idle_component(SD_DEVINFO(un), 0);
8760 mutex_enter(&un->un_pm_mutex);
8761 }
8762
8763 /*
8764 * Check whether there is already a timeout scheduled for power
8765 * management. If yes then don't lower the power here, that's.
8766 * the timeout handler's job.
8767 */
8768 if (un->un_pm_timeid != NULL) {
8769 timeout_id_t temp_id = un->un_pm_timeid;
8770 un->un_pm_timeid = NULL;
8771 mutex_exit(&un->un_pm_mutex);
8772 /*
8773 * Timeout is active; cancel it.
8774 * Note that it'll never be active on a device
8775 * that does not support PM therefore we don't
8776 * have to check before calling pm_idle_component.
8777 */
8778 (void) untimeout(temp_id);
8779 (void) pm_idle_component(SD_DEVINFO(un), 0);
8780
8781 } else {
8782 mutex_exit(&un->un_pm_mutex);
8783 if ((un->un_f_pm_is_enabled == TRUE) &&
8784 (pm_lower_power(SD_DEVINFO(un), 0, SD_PM_STATE_STOPPED(un))
8785 != DDI_SUCCESS)) {
8786 SD_ERROR(SD_LOG_ATTACH_DETACH, un,
8787 "%s: lower power request failed, ignoring\n",
8788 __func__);
8789 /*
8790 * The above test now includes a check to see if PM is
8791 * supported by this device before call
8792 * pm_lower_power().
8793 * Note, the following is not dead code. The call to
8794 * pm_lower_power above will generate a call back into
8795 * our sdpower routine which might result in a timeout
8796 * handler getting activated. Therefore the following
8797 * code is valid and necessary.
8798 */
8799 mutex_enter(&un->un_pm_mutex);
8800 if (un->un_pm_timeid != NULL) {
8801 timeout_id_t temp_id = un->un_pm_timeid;
8802 un->un_pm_timeid = NULL;
8803 mutex_exit(&un->un_pm_mutex);
8804 (void) untimeout(temp_id);
8805 (void) pm_idle_component(SD_DEVINFO(un), 0);
8806 } else {
8807 mutex_exit(&un->un_pm_mutex);
8808 }
8809 }
8810 }
8811
8812 /*
8813 * Cleanup from the scsi_ifsetcap() calls (437868)
8814 * Relocated here from above to be after the call to
8815 * pm_lower_power, which was getting errors.
8816 */
8817 (void) scsi_ifsetcap(SD_ADDRESS(un), "lun-reset", 0, 1);
8818 (void) scsi_ifsetcap(SD_ADDRESS(un), "wide-xfer", 0, 1);
8819
8820 /*
8821 * Currently, tagged queuing is supported per target based by HBA.
8822 * Setting this per lun instance actually sets the capability of this
8823 * target in HBA, which affects those luns already attached on the
8824 * same target. So during detach, we can only disable this capability
8825 * only when this is the only lun left on this target. By doing
8826 * this, we assume a target has the same tagged queuing capability
8827 * for every lun. The condition can be removed when HBA is changed to
8828 * support per lun based tagged queuing capability.
8829 */
8830 if (sd_scsi_get_target_lun_count(pdip, tgt) <= 1) {
8831 (void) scsi_ifsetcap(SD_ADDRESS(un), "tagged-qing", 0, 1);
8832 }
8833
8834 if (un->un_f_is_fibre == FALSE) {
8835 (void) scsi_ifsetcap(SD_ADDRESS(un), "auto-rqsense", 0, 1);
8836 }
8837
8838 /*
8839 * Remove any event callbacks, fibre only
8840 */
8841 if (un->un_f_is_fibre == TRUE) {
8842 if ((un->un_insert_event != NULL) &&
8843 (ddi_remove_event_handler(un->un_insert_cb_id) !=
8844 DDI_SUCCESS)) {
8845 /*
8846 * Note: We are returning here after having done
8847 * substantial cleanup above. This is consistent
8848 * with the legacy implementation but this may not
8849 * be the right thing to do.
8850 */
8851 SD_ERROR(SD_LOG_ATTACH_DETACH, un,
8852 "%s: cannot cancel insert event\n", __func__);
8853 goto err_remove_event;
8854 }
8855 un->un_insert_event = NULL;
8856
8857 if ((un->un_remove_event != NULL) &&
8858 (ddi_remove_event_handler(un->un_remove_cb_id) !=
8859 DDI_SUCCESS)) {
8860 /*
8861 * Note: We are returning here after having done
8862 * substantial cleanup above. This is consistent
8863 * with the legacy implementation but this may not
8864 * be the right thing to do.
8865 */
8866 SD_ERROR(SD_LOG_ATTACH_DETACH, un,
8867 "%s: cannot cancel remove event\n", __func__);
8868 goto err_remove_event;
8869 }
8870 un->un_remove_event = NULL;
8871 }
8872
8873 /* Do not free the softstate if the callback routine is active */
8874 sd_sync_with_callback(un);
8875
8876 cmlb_detach(un->un_cmlbhandle, (void *)SD_PATH_DIRECT);
8877 cmlb_free_handle(&un->un_cmlbhandle);
8878
8879 /*
8880 * Hold the detach mutex here, to make sure that no other threads ever
8881 * can access a (partially) freed soft state structure.
8882 */
8883 mutex_enter(&sd_detach_mutex);
8884
8885 /*
8886 * Clean up the soft state struct.
8887 * Cleanup is done in reverse order of allocs/inits.
8888 * At this point there should be no competing threads anymore.
8889 */
8890
8891 scsi_fm_fini(devp);
8892
8893 /*
8894 * Deallocate memory for SCSI FMA.
8895 */
8896 kmem_free(un->un_fm_private, sizeof (struct sd_fm_internal));
8897
8898 /*
8899 * Unregister and free device id if it was not registered
8900 * by the transport.
8901 */
8902 if (un->un_f_devid_transport_defined == FALSE)
8903 ddi_devid_unregister(devi);
8904
8905 /*
8906 * free the devid structure if allocated before (by ddi_devid_init()
8907 * or ddi_devid_get()).
8908 */
8909 if (un->un_devid) {
8910 ddi_devid_free(un->un_devid);
8911 un->un_devid = NULL;
8912 }
8913
8914 /*
8915 * Destroy wmap cache if it exists.
8916 */
8917 if (un->un_wm_cache != NULL) {
8918 kmem_cache_destroy(un->un_wm_cache);
8919 un->un_wm_cache = NULL;
8920 }
8921
8922 /*
8923 * kstat cleanup is done in detach for all device types (4363169).
8924 * We do not want to fail detach if the device kstats are not deleted
8925 * since there is a confusion about the devo_refcnt for the device.
8926 * We just delete the kstats and let detach complete successfully.
8927 */
8928 if (un->un_stats != NULL) {
8929 kstat_delete(un->un_stats);
8930 un->un_stats = NULL;
8931 }
8932 if (un->un_errstats != NULL) {
8933 kstat_delete(un->un_errstats);
8934 un->un_errstats = NULL;
8935 }
8936
8937 /* Remove partition stats */
8938 if (un->un_f_pkstats_enabled) {
8939 for (i = 0; i < NSDMAP; i++) {
8940 if (un->un_pstats[i] != NULL) {
8941 kstat_delete(un->un_pstats[i]);
8942 un->un_pstats[i] = NULL;
8943 }
8944 }
8945 }
8946
8947 /* Remove xbuf registration */
8948 ddi_xbuf_attr_unregister_devinfo(un->un_xbuf_attr, devi);
8949 ddi_xbuf_attr_destroy(un->un_xbuf_attr);
8950
8951 /* Remove driver properties */
8952 ddi_prop_remove_all(devi);
8953
8954 mutex_destroy(&un->un_pm_mutex);
8955 cv_destroy(&un->un_pm_busy_cv);
8956
8957 cv_destroy(&un->un_wcc_cv);
8958
8959 /* Open/close semaphore */
8960 sema_destroy(&un->un_semoclose);
8961
8962 /* Removable media condvar. */
8963 cv_destroy(&un->un_state_cv);
8964
8965 /* Suspend/resume condvar. */
8966 cv_destroy(&un->un_suspend_cv);
8967 cv_destroy(&un->un_disk_busy_cv);
8968
8969 sd_free_rqs(un);
8970
8971 /* Free up soft state */
8972 devp->sd_private = NULL;
8973
8974 bzero(un, sizeof (struct sd_lun));
8975
8976 ddi_soft_state_free(sd_state, instance);
8977
8978 mutex_exit(&sd_detach_mutex);
8979
8980 /* This frees up the INQUIRY data associated with the device. */
8981 scsi_unprobe(devp);
8982
8983 /*
8984 * After successfully detaching an instance, we update the information
8985 * of how many luns have been attached in the relative target and
8986 * controller for parallel SCSI. This information is used when sd tries
8987 * to set the tagged queuing capability in HBA.
8988 * Since un has been released, we can't use SD_IS_PARALLEL_SCSI(un) to
8989 * check if the device is parallel SCSI. However, we don't need to
8990 * check here because we've already checked during attach. No device
8991 * that is not parallel SCSI is in the chain.
8992 */
8993 if ((tgt >= 0) && (tgt < NTARGETS_WIDE)) {
8994 sd_scsi_update_lun_on_target(pdip, tgt, SD_SCSI_LUN_DETACH);
8995 }
8996
8997 return (DDI_SUCCESS);
8998
8999 err_notclosed:
9000 mutex_exit(SD_MUTEX(un));
9001
9002 err_stillbusy:
9003 _NOTE(NO_COMPETING_THREADS_NOW);
9004
9005 err_remove_event:
9006 mutex_enter(&sd_detach_mutex);
9007 un->un_detach_count--;
9008 mutex_exit(&sd_detach_mutex);
9009
9010 SD_TRACE(SD_LOG_ATTACH_DETACH, un, "%s: exit failure\n", __func__);
9011 return (DDI_FAILURE);
9012 }
9013
9014
9015 /*
9016 * Function: sd_create_errstats
9017 *
9018 * Description: This routine instantiates the device error stats.
9019 *
9020 * Note: During attach the stats are instantiated first so they are
9021 * available for attach-time routines that utilize the driver
9022 * iopath to send commands to the device. The stats are initialized
9023 * separately so data obtained during some attach-time routines is
9024 * available. (4362483)
9025 *
9026 * Arguments: un - driver soft state (unit) structure
9027 * instance - driver instance
9028 *
9029 * Context: Kernel thread context
9030 */
9031
9032 static void
9033 sd_create_errstats(struct sd_lun *un, int instance)
9034 {
9035 struct sd_errstats *stp;
9036 char kstatmodule_err[KSTAT_STRLEN];
9037 char kstatname[KSTAT_STRLEN];
9038 int ndata = (sizeof (struct sd_errstats) / sizeof (kstat_named_t));
9039
9040 ASSERT(un != NULL);
9041
9042 if (un->un_errstats != NULL) {
9043 return;
9044 }
9045
9046 (void) snprintf(kstatmodule_err, sizeof (kstatmodule_err),
9047 "%serr", sd_label);
9048 (void) snprintf(kstatname, sizeof (kstatname),
9049 "%s%d,err", sd_label, instance);
9050
9051 un->un_errstats = kstat_create(kstatmodule_err, instance, kstatname,
9052 "device_error", KSTAT_TYPE_NAMED, ndata, KSTAT_FLAG_PERSISTENT);
9053
9054 if (un->un_errstats == NULL) {
9055 SD_ERROR(SD_LOG_ATTACH_DETACH, un,
9056 "sd_create_errstats: Failed kstat_create\n");
9057 return;
9058 }
9059
9060 stp = (struct sd_errstats *)un->un_errstats->ks_data;
9061 kstat_named_init(&stp->sd_softerrs, "Soft Errors",
9062 KSTAT_DATA_UINT32);
9063 kstat_named_init(&stp->sd_harderrs, "Hard Errors",
9064 KSTAT_DATA_UINT32);
9065 kstat_named_init(&stp->sd_transerrs, "Transport Errors",
9066 KSTAT_DATA_UINT32);
9067 kstat_named_init(&stp->sd_vid, "Vendor",
9068 KSTAT_DATA_CHAR);
9069 kstat_named_init(&stp->sd_pid, "Product",
9070 KSTAT_DATA_CHAR);
9071 kstat_named_init(&stp->sd_revision, "Revision",
9072 KSTAT_DATA_CHAR);
9073 kstat_named_init(&stp->sd_serial, "Serial No",
9074 KSTAT_DATA_CHAR);
9075 kstat_named_init(&stp->sd_capacity, "Size",
9076 KSTAT_DATA_ULONGLONG);
9077 kstat_named_init(&stp->sd_rq_media_err, "Media Error",
9078 KSTAT_DATA_UINT32);
9079 kstat_named_init(&stp->sd_rq_ntrdy_err, "Device Not Ready",
9080 KSTAT_DATA_UINT32);
9081 kstat_named_init(&stp->sd_rq_nodev_err, "No Device",
9082 KSTAT_DATA_UINT32);
9083 kstat_named_init(&stp->sd_rq_recov_err, "Recoverable",
9084 KSTAT_DATA_UINT32);
9085 kstat_named_init(&stp->sd_rq_illrq_err, "Illegal Request",
9086 KSTAT_DATA_UINT32);
9087 kstat_named_init(&stp->sd_rq_pfa_err, "Predictive Failure Analysis",
9088 KSTAT_DATA_UINT32);
9089
9090 un->un_errstats->ks_private = un;
9091 un->un_errstats->ks_update = nulldev;
9092
9093 kstat_install(un->un_errstats);
9094 }
9095
9096
9097 /*
9098 * Function: sd_set_errstats
9099 *
9100 * Description: This routine sets the value of the vendor id, product id,
9101 * revision, serial number, and capacity device error stats.
9102 *
9103 * Note: During attach the stats are instantiated first so they are
9104 * available for attach-time routines that utilize the driver
9105 * iopath to send commands to the device. The stats are initialized
9106 * separately so data obtained during some attach-time routines is
9107 * available. (4362483)
9108 *
9109 * Arguments: un - driver soft state (unit) structure
9110 *
9111 * Context: Kernel thread context
9112 */
9113
9114 static void
9115 sd_set_errstats(struct sd_lun *un)
9116 {
9117 struct sd_errstats *stp;
9118 char *sn;
9119
9120 ASSERT(un != NULL);
9121 ASSERT(un->un_errstats != NULL);
9122 stp = (struct sd_errstats *)un->un_errstats->ks_data;
9123 ASSERT(stp != NULL);
9124 (void) strncpy(stp->sd_vid.value.c, un->un_sd->sd_inq->inq_vid, 8);
9125 (void) strncpy(stp->sd_pid.value.c, un->un_sd->sd_inq->inq_pid, 16);
9126 (void) strncpy(stp->sd_revision.value.c,
9127 un->un_sd->sd_inq->inq_revision, 4);
9128
9129 /*
9130 * All the errstats are persistent across detach/attach,
9131 * so reset all the errstats here in case of the hot
9132 * replacement of disk drives, except for not changed
9133 * Sun qualified drives.
9134 */
9135 if ((bcmp(&SD_INQUIRY(un)->inq_pid[9], "SUN", 3) != 0) ||
9136 (bcmp(&SD_INQUIRY(un)->inq_serial, stp->sd_serial.value.c,
9137 sizeof (SD_INQUIRY(un)->inq_serial)) != 0)) {
9138 stp->sd_softerrs.value.ui32 = 0;
9139 stp->sd_harderrs.value.ui32 = 0;
9140 stp->sd_transerrs.value.ui32 = 0;
9141 stp->sd_rq_media_err.value.ui32 = 0;
9142 stp->sd_rq_ntrdy_err.value.ui32 = 0;
9143 stp->sd_rq_nodev_err.value.ui32 = 0;
9144 stp->sd_rq_recov_err.value.ui32 = 0;
9145 stp->sd_rq_illrq_err.value.ui32 = 0;
9146 stp->sd_rq_pfa_err.value.ui32 = 0;
9147 }
9148
9149 /*
9150 * Set the "Serial No" kstat for Sun qualified drives (indicated by
9151 * "SUN" in bytes 25-27 of the inquiry data (bytes 9-11 of the pid)
9152 * (4376302))
9153 */
9154 if (bcmp(&SD_INQUIRY(un)->inq_pid[9], "SUN", 3) == 0) {
9155 bcopy(&SD_INQUIRY(un)->inq_serial, stp->sd_serial.value.c,
9156 sizeof (SD_INQUIRY(un)->inq_serial));
9157 } else {
9158 /*
9159 * Set the "Serial No" kstat for non-Sun qualified drives
9160 */
9161 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, SD_DEVINFO(un),
9162 DDI_PROP_NOTPROM | DDI_PROP_DONTPASS,
9163 INQUIRY_SERIAL_NO, &sn) == DDI_SUCCESS) {
9164 (void) strlcpy(stp->sd_serial.value.c, sn,
9165 sizeof (stp->sd_serial.value.c));
9166 ddi_prop_free(sn);
9167 }
9168 }
9169
9170 if (un->un_f_blockcount_is_valid != TRUE) {
9171 /*
9172 * Set capacity error stat to 0 for no media. This ensures
9173 * a valid capacity is displayed in response to 'iostat -E'
9174 * when no media is present in the device.
9175 */
9176 stp->sd_capacity.value.ui64 = 0;
9177 } else {
9178 /*
9179 * Multiply un_blockcount by un->un_sys_blocksize to get
9180 * capacity.
9181 *
9182 * Note: for non-512 blocksize devices "un_blockcount" has been
9183 * "scaled" in sd_send_scsi_READ_CAPACITY by multiplying by
9184 * (un_tgt_blocksize / un->un_sys_blocksize).
9185 */
9186 stp->sd_capacity.value.ui64 = (uint64_t)
9187 ((uint64_t)un->un_blockcount * un->un_sys_blocksize);
9188 }
9189 }
9190
9191
9192 /*
9193 * Function: sd_set_pstats
9194 *
9195 * Description: This routine instantiates and initializes the partition
9196 * stats for each partition with more than zero blocks.
9197 * (4363169)
9198 *
9199 * Arguments: un - driver soft state (unit) structure
9200 *
9201 * Context: Kernel thread context
9202 */
9203
9204 static void
9205 sd_set_pstats(struct sd_lun *un)
9206 {
9207 char kstatname[KSTAT_STRLEN];
9208 int instance;
9209 int i;
9210 diskaddr_t nblks = 0;
9211 char *partname = NULL;
9212
9213 ASSERT(un != NULL);
9214
9215 instance = ddi_get_instance(SD_DEVINFO(un));
9216
9217 /* Note:x86: is this a VTOC8/VTOC16 difference? */
9218 for (i = 0; i < NSDMAP; i++) {
9219
9220 if (cmlb_partinfo(un->un_cmlbhandle, i,
9221 &nblks, NULL, &partname, NULL, (void *)SD_PATH_DIRECT) != 0)
9222 continue;
9223 mutex_enter(SD_MUTEX(un));
9224
9225 if ((un->un_pstats[i] == NULL) &&
9226 (nblks != 0)) {
9227
9228 (void) snprintf(kstatname, sizeof (kstatname),
9229 "%s%d,%s", sd_label, instance,
9230 partname);
9231
9232 un->un_pstats[i] = kstat_create(sd_label,
9233 instance, kstatname, "partition", KSTAT_TYPE_IO,
9234 1, KSTAT_FLAG_PERSISTENT);
9235 if (un->un_pstats[i] != NULL) {
9236 un->un_pstats[i]->ks_lock = SD_MUTEX(un);
9237 kstat_install(un->un_pstats[i]);
9238 }
9239 }
9240 mutex_exit(SD_MUTEX(un));
9241 }
9242 }
9243
9244
9245 #if (defined(__fibre))
9246 /*
9247 * Function: sd_init_event_callbacks
9248 *
9249 * Description: This routine initializes the insertion and removal event
9250 * callbacks. (fibre only)
9251 *
9252 * Arguments: un - driver soft state (unit) structure
9253 *
9254 * Context: Kernel thread context
9255 */
9256
9257 static void
9258 sd_init_event_callbacks(struct sd_lun *un)
9259 {
9260 ASSERT(un != NULL);
9261
9262 if ((un->un_insert_event == NULL) &&
9263 (ddi_get_eventcookie(SD_DEVINFO(un), FCAL_INSERT_EVENT,
9264 &un->un_insert_event) == DDI_SUCCESS)) {
9265 /*
9266 * Add the callback for an insertion event
9267 */
9268 (void) ddi_add_event_handler(SD_DEVINFO(un),
9269 un->un_insert_event, sd_event_callback, (void *)un,
9270 &(un->un_insert_cb_id));
9271 }
9272
9273 if ((un->un_remove_event == NULL) &&
9274 (ddi_get_eventcookie(SD_DEVINFO(un), FCAL_REMOVE_EVENT,
9275 &un->un_remove_event) == DDI_SUCCESS)) {
9276 /*
9277 * Add the callback for a removal event
9278 */
9279 (void) ddi_add_event_handler(SD_DEVINFO(un),
9280 un->un_remove_event, sd_event_callback, (void *)un,
9281 &(un->un_remove_cb_id));
9282 }
9283 }
9284
9285
9286 /*
9287 * Function: sd_event_callback
9288 *
9289 * Description: This routine handles insert/remove events (photon). The
9290 * state is changed to OFFLINE which can be used to supress
9291 * error msgs. (fibre only)
9292 *
9293 * Arguments: un - driver soft state (unit) structure
9294 *
9295 * Context: Callout thread context
9296 */
9297 /* ARGSUSED */
9298 static void
9299 sd_event_callback(dev_info_t *dip, ddi_eventcookie_t event, void *arg,
9300 void *bus_impldata)
9301 {
9302 struct sd_lun *un = (struct sd_lun *)arg;
9303
9304 _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::un_insert_event));
9305 if (event == un->un_insert_event) {
9306 SD_TRACE(SD_LOG_COMMON, un, "sd_event_callback: insert event");
9307 mutex_enter(SD_MUTEX(un));
9308 if (un->un_state == SD_STATE_OFFLINE) {
9309 if (un->un_last_state != SD_STATE_SUSPENDED) {
9310 un->un_state = un->un_last_state;
9311 } else {
9312 /*
9313 * We have gone through SUSPEND/RESUME while
9314 * we were offline. Restore the last state
9315 */
9316 un->un_state = un->un_save_state;
9317 }
9318 }
9319 mutex_exit(SD_MUTEX(un));
9320
9321 _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::un_remove_event));
9322 } else if (event == un->un_remove_event) {
9323 SD_TRACE(SD_LOG_COMMON, un, "sd_event_callback: remove event");
9324 mutex_enter(SD_MUTEX(un));
9325 /*
9326 * We need to handle an event callback that occurs during
9327 * the suspend operation, since we don't prevent it.
9328 */
9329 if (un->un_state != SD_STATE_OFFLINE) {
9330 if (un->un_state != SD_STATE_SUSPENDED) {
9331 New_state(un, SD_STATE_OFFLINE);
9332 } else {
9333 un->un_last_state = SD_STATE_OFFLINE;
9334 }
9335 }
9336 mutex_exit(SD_MUTEX(un));
9337 } else {
9338 scsi_log(SD_DEVINFO(un), sd_label, CE_NOTE,
9339 "!Unknown event\n");
9340 }
9341
9342 }
9343 #endif
9344
9345 /*
9346 * Values related to caching mode page depending on whether the unit is ATAPI.
9347 */
9348 #define SDC_CDB_GROUP(un) ((un->un_f_cfg_is_atapi == TRUE) ? \
9349 CDB_GROUP1 : CDB_GROUP0)
9350 #define SDC_HDRLEN(un) ((un->un_f_cfg_is_atapi == TRUE) ? \
9351 MODE_HEADER_LENGTH_GRP2 : MODE_HEADER_LENGTH)
9352 /*
9353 * Use mode_cache_scsi3 to ensure we get all of the mode sense data, otherwise
9354 * the mode select will fail (mode_cache_scsi3 is a superset of mode_caching).
9355 */
9356 #define SDC_BUFLEN(un) (SDC_HDRLEN(un) + MODE_BLK_DESC_LENGTH + \
9357 sizeof (struct mode_cache_scsi3))
9358
9359 static int
9360 sd_get_caching_mode_page(sd_ssc_t *ssc, uchar_t page_control, uchar_t **header,
9361 int *bdlen)
9362 {
9363 struct sd_lun *un = ssc->ssc_un;
9364 struct mode_caching *mode_caching_page;
9365 size_t buflen = SDC_BUFLEN(un);
9366 int hdrlen = SDC_HDRLEN(un);
9367 int rval;
9368
9369 /*
9370 * Do a test unit ready, otherwise a mode sense may not work if this
9371 * is the first command sent to the device after boot.
9372 */
9373 if (sd_send_scsi_TEST_UNIT_READY(ssc, 0) != 0)
9374 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
9375
9376 /*
9377 * Allocate memory for the retrieved mode page and its headers. Set
9378 * a pointer to the page itself.
9379 */
9380 *header = kmem_zalloc(buflen, KM_SLEEP);
9381
9382 /* Get the information from the device */
9383 rval = sd_send_scsi_MODE_SENSE(ssc, SDC_CDB_GROUP(un), *header, buflen,
9384 page_control | MODEPAGE_CACHING, SD_PATH_DIRECT);
9385 if (rval != 0) {
9386 SD_ERROR(SD_LOG_IOCTL_RMMEDIA, un, "%s: Mode Sense Failed\n",
9387 __func__);
9388 goto mode_sense_failed;
9389 }
9390
9391 /*
9392 * Determine size of Block Descriptors in order to locate
9393 * the mode page data. ATAPI devices return 0, SCSI devices
9394 * should return MODE_BLK_DESC_LENGTH.
9395 */
9396 if (un->un_f_cfg_is_atapi == TRUE) {
9397 struct mode_header_grp2 *mhp =
9398 (struct mode_header_grp2 *)(*header);
9399 *bdlen = (mhp->bdesc_length_hi << 8) | mhp->bdesc_length_lo;
9400 } else {
9401 *bdlen = ((struct mode_header *)(*header))->bdesc_length;
9402 }
9403
9404 if (*bdlen > MODE_BLK_DESC_LENGTH) {
9405 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, 0,
9406 "%s: Mode Sense returned invalid block descriptor length\n",
9407 __func__);
9408 rval = EIO;
9409 goto mode_sense_failed;
9410 }
9411
9412 mode_caching_page = (struct mode_caching *)(*header + hdrlen + *bdlen);
9413 if (mode_caching_page->mode_page.code != MODEPAGE_CACHING) {
9414 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, SD_LOG_COMMON,
9415 "%s: Mode Sense caching page code mismatch %d\n",
9416 __func__, mode_caching_page->mode_page.code);
9417 rval = EIO;
9418 }
9419
9420 mode_sense_failed:
9421 if (rval != 0) {
9422 kmem_free(*header, buflen);
9423 *header = NULL;
9424 *bdlen = 0;
9425 }
9426 return (rval);
9427 }
9428
9429 /*
9430 * Function: sd_cache_control()
9431 *
9432 * Description: This routine is the driver entry point for setting
9433 * read and write caching by modifying the WCE (write cache
9434 * enable) and RCD (read cache disable) bits of mode
9435 * page 8 (MODEPAGE_CACHING).
9436 *
9437 * Arguments: ssc - ssc contains pointer to driver soft state
9438 * (unit) structure for this target.
9439 * rcd_flag - flag for controlling the read cache
9440 * wce_flag - flag for controlling the write cache
9441 *
9442 * Return Code: EIO
9443 * code returned by sd_send_scsi_MODE_SENSE and
9444 * sd_send_scsi_MODE_SELECT
9445 *
9446 * Context: Kernel Thread
9447 */
9448
9449 static int
9450 sd_cache_control(sd_ssc_t *ssc, int rcd_flag, int wce_flag)
9451 {
9452 struct sd_lun *un = ssc->ssc_un;
9453 struct mode_caching *mode_caching_page;
9454 uchar_t *header;
9455 size_t buflen = SDC_BUFLEN(un);
9456 int hdrlen = SDC_HDRLEN(un);
9457 int bdlen;
9458 int rval;
9459
9460 rval = sd_get_caching_mode_page(ssc, MODEPAGE_CURRENT, &header, &bdlen);
9461 switch (rval) {
9462 case 0:
9463 /* Check the relevant bits on successful mode sense */
9464 mode_caching_page = (struct mode_caching *)(header + hdrlen +
9465 bdlen);
9466 if ((mode_caching_page->rcd && rcd_flag == SD_CACHE_ENABLE) ||
9467 (!mode_caching_page->rcd && rcd_flag == SD_CACHE_DISABLE) ||
9468 (mode_caching_page->wce && wce_flag == SD_CACHE_DISABLE) ||
9469 (!mode_caching_page->wce && wce_flag == SD_CACHE_ENABLE)) {
9470 size_t sbuflen;
9471 uchar_t save_pg;
9472
9473 /*
9474 * Construct select buffer length based on the
9475 * length of the sense data returned.
9476 */
9477 sbuflen = hdrlen + bdlen + sizeof (struct mode_page) +
9478 (int)mode_caching_page->mode_page.length;
9479
9480 /* Set the caching bits as requested */
9481 if (rcd_flag == SD_CACHE_ENABLE)
9482 mode_caching_page->rcd = 0;
9483 else if (rcd_flag == SD_CACHE_DISABLE)
9484 mode_caching_page->rcd = 1;
9485
9486 if (wce_flag == SD_CACHE_ENABLE)
9487 mode_caching_page->wce = 1;
9488 else if (wce_flag == SD_CACHE_DISABLE)
9489 mode_caching_page->wce = 0;
9490
9491 /*
9492 * Save the page if the mode sense says the
9493 * drive supports it.
9494 */
9495 save_pg = mode_caching_page->mode_page.ps ?
9496 SD_SAVE_PAGE : SD_DONTSAVE_PAGE;
9497
9498 /* Clear reserved bits before mode select */
9499 mode_caching_page->mode_page.ps = 0;
9500
9501 /*
9502 * Clear out mode header for mode select.
9503 * The rest of the retrieved page will be reused.
9504 */
9505 bzero(header, hdrlen);
9506
9507 if (un->un_f_cfg_is_atapi == TRUE) {
9508 struct mode_header_grp2 *mhp =
9509 (struct mode_header_grp2 *)header;
9510 mhp->bdesc_length_hi = bdlen >> 8;
9511 mhp->bdesc_length_lo = (uchar_t)bdlen & 0xff;
9512 } else {
9513 ((struct mode_header *)header)->bdesc_length =
9514 bdlen;
9515 }
9516
9517 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
9518
9519 /* Issue mode select to change the cache settings */
9520 rval = sd_send_scsi_MODE_SELECT(ssc, SDC_CDB_GROUP(un),
9521 header, sbuflen, save_pg, SD_PATH_DIRECT);
9522 }
9523 kmem_free(header, buflen);
9524 break;
9525 case EIO:
9526 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
9527 break;
9528 default:
9529 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
9530 break;
9531 }
9532
9533 return (rval);
9534 }
9535
9536
9537 /*
9538 * Function: sd_get_write_cache_enabled()
9539 *
9540 * Description: This routine is the driver entry point for determining if write
9541 * caching is enabled. It examines the WCE (write cache enable)
9542 * bits of mode page 8 (MODEPAGE_CACHING) with Page Control field
9543 * bits set to MODEPAGE_CURRENT.
9544 *
9545 * Arguments: ssc - ssc contains pointer to driver soft state
9546 * (unit) structure for this target.
9547 * is_enabled - pointer to int where write cache enabled state
9548 * is returned (non-zero -> write cache enabled)
9549 *
9550 * Return Code: EIO
9551 * code returned by sd_send_scsi_MODE_SENSE
9552 *
9553 * Context: Kernel Thread
9554 *
9555 * NOTE: If ioctl is added to disable write cache, this sequence should
9556 * be followed so that no locking is required for accesses to
9557 * un->un_f_write_cache_enabled:
9558 * do mode select to clear wce
9559 * do synchronize cache to flush cache
9560 * set un->un_f_write_cache_enabled = FALSE
9561 *
9562 * Conversely, an ioctl to enable the write cache should be done
9563 * in this order:
9564 * set un->un_f_write_cache_enabled = TRUE
9565 * do mode select to set wce
9566 */
9567
9568 static int
9569 sd_get_write_cache_enabled(sd_ssc_t *ssc, int *is_enabled)
9570 {
9571 struct sd_lun *un = ssc->ssc_un;
9572 struct mode_caching *mode_caching_page;
9573 uchar_t *header;
9574 size_t buflen = SDC_BUFLEN(un);
9575 int hdrlen = SDC_HDRLEN(un);
9576 int bdlen;
9577 int rval;
9578
9579 /* In case of error, flag as enabled */
9580 *is_enabled = TRUE;
9581
9582 rval = sd_get_caching_mode_page(ssc, MODEPAGE_CURRENT, &header, &bdlen);
9583 switch (rval) {
9584 case 0:
9585 mode_caching_page = (struct mode_caching *)(header + hdrlen +
9586 bdlen);
9587 *is_enabled = mode_caching_page->wce;
9588 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
9589 kmem_free(header, buflen);
9590 break;
9591 case EIO: {
9592 /*
9593 * Some disks do not support Mode Sense(6), we
9594 * should ignore this kind of error (sense key is
9595 * 0x5 - illegal request).
9596 */
9597 uint8_t *sensep;
9598 int senlen;
9599
9600 sensep = (uint8_t *)ssc->ssc_uscsi_cmd->uscsi_rqbuf;
9601 senlen = (int)(ssc->ssc_uscsi_cmd->uscsi_rqlen -
9602 ssc->ssc_uscsi_cmd->uscsi_rqresid);
9603
9604 if (senlen > 0 &&
9605 scsi_sense_key(sensep) == KEY_ILLEGAL_REQUEST) {
9606 sd_ssc_assessment(ssc, SD_FMT_IGNORE_COMPROMISE);
9607 } else {
9608 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
9609 }
9610 break;
9611 }
9612 default:
9613 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
9614 break;
9615 }
9616
9617 return (rval);
9618 }
9619
9620 /*
9621 * Function: sd_get_write_cache_changeable()
9622 *
9623 * Description: This routine is the driver entry point for determining if write
9624 * caching is changeable. It examines the WCE (write cache enable)
9625 * bits of mode page 8 (MODEPAGE_CACHING) with Page Control field
9626 * bits set to MODEPAGE_CHANGEABLE.
9627 *
9628 * Arguments: ssc - ssc contains pointer to driver soft state
9629 * (unit) structure for this target.
9630 * is_changeable - pointer to int where write cache changeable
9631 * state is returned (non-zero -> write cache
9632 * changeable)
9633 *
9634 * Context: Kernel Thread
9635 */
9636
9637 static void
9638 sd_get_write_cache_changeable(sd_ssc_t *ssc, int *is_changeable)
9639 {
9640 struct sd_lun *un = ssc->ssc_un;
9641 struct mode_caching *mode_caching_page;
9642 uchar_t *header;
9643 size_t buflen = SDC_BUFLEN(un);
9644 int hdrlen = SDC_HDRLEN(un);
9645 int bdlen;
9646 int rval;
9647
9648 /* In case of error, flag as enabled */
9649 *is_changeable = TRUE;
9650
9651 rval = sd_get_caching_mode_page(ssc, MODEPAGE_CHANGEABLE, &header,
9652 &bdlen);
9653 switch (rval) {
9654 case 0:
9655 mode_caching_page = (struct mode_caching *)(header + hdrlen +
9656 bdlen);
9657 *is_changeable = mode_caching_page->wce;
9658 kmem_free(header, buflen);
9659 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
9660 break;
9661 case EIO:
9662 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
9663 break;
9664 default:
9665 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
9666 break;
9667 }
9668 }
9669
9670 /*
9671 * Function: sd_get_nv_sup()
9672 *
9673 * Description: This routine is the driver entry point for
9674 * determining whether non-volatile cache is supported. This
9675 * determination process works as follows:
9676 *
9677 * 1. sd first queries sd.conf on whether
9678 * suppress_cache_flush bit is set for this device.
9679 *
9680 * 2. if not there, then queries the internal disk table.
9681 *
9682 * 3. if either sd.conf or internal disk table specifies
9683 * cache flush be suppressed, we don't bother checking
9684 * NV_SUP bit.
9685 *
9686 * If SUPPRESS_CACHE_FLUSH bit is not set to 1, sd queries
9687 * the optional INQUIRY VPD page 0x86. If the device
9688 * supports VPD page 0x86, sd examines the NV_SUP
9689 * (non-volatile cache support) bit in the INQUIRY VPD page
9690 * 0x86:
9691 * o If NV_SUP bit is set, sd assumes the device has a
9692 * non-volatile cache and set the
9693 * un_f_sync_nv_supported to TRUE.
9694 * o Otherwise cache is not non-volatile,
9695 * un_f_sync_nv_supported is set to FALSE.
9696 *
9697 * Arguments: un - driver soft state (unit) structure
9698 *
9699 * Return Code:
9700 *
9701 * Context: Kernel Thread
9702 */
9703
9704 static void
9705 sd_get_nv_sup(sd_ssc_t *ssc)
9706 {
9707 int rval = 0;
9708 uchar_t *inq86 = NULL;
9709 size_t inq86_len = MAX_INQUIRY_SIZE;
9710 size_t inq86_resid = 0;
9711 struct dk_callback *dkc;
9712 struct sd_lun *un;
9713
9714 ASSERT(ssc != NULL);
9715 un = ssc->ssc_un;
9716 ASSERT(un != NULL);
9717
9718 mutex_enter(SD_MUTEX(un));
9719
9720 /*
9721 * Be conservative on the device's support of
9722 * SYNC_NV bit: un_f_sync_nv_supported is
9723 * initialized to be false.
9724 */
9725 un->un_f_sync_nv_supported = FALSE;
9726
9727 /*
9728 * If either sd.conf or internal disk table
9729 * specifies cache flush be suppressed, then
9730 * we don't bother checking NV_SUP bit.
9731 */
9732 if (un->un_f_suppress_cache_flush == TRUE) {
9733 mutex_exit(SD_MUTEX(un));
9734 return;
9735 }
9736
9737 if (sd_check_vpd_page_support(ssc) == 0 &&
9738 un->un_vpd_page_mask & SD_VPD_EXTENDED_DATA_PG) {
9739 mutex_exit(SD_MUTEX(un));
9740 /* collect page 86 data if available */
9741 inq86 = kmem_zalloc(inq86_len, KM_SLEEP);
9742
9743 rval = sd_send_scsi_INQUIRY(ssc, inq86, inq86_len,
9744 0x01, 0x86, &inq86_resid);
9745
9746 if (rval == 0 && (inq86_len - inq86_resid > 6)) {
9747 SD_TRACE(SD_LOG_COMMON, un,
9748 "sd_get_nv_sup: \
9749 successfully get VPD page: %x \
9750 PAGE LENGTH: %x BYTE 6: %x\n",
9751 inq86[1], inq86[3], inq86[6]);
9752
9753 mutex_enter(SD_MUTEX(un));
9754 /*
9755 * check the value of NV_SUP bit: only if the device
9756 * reports NV_SUP bit to be 1, the
9757 * un_f_sync_nv_supported bit will be set to true.
9758 */
9759 if (inq86[6] & SD_VPD_NV_SUP) {
9760 un->un_f_sync_nv_supported = TRUE;
9761 }
9762 mutex_exit(SD_MUTEX(un));
9763 } else if (rval != 0) {
9764 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
9765 }
9766
9767 kmem_free(inq86, inq86_len);
9768 } else {
9769 mutex_exit(SD_MUTEX(un));
9770 }
9771
9772 /*
9773 * Send a SYNC CACHE command to check whether
9774 * SYNC_NV bit is supported. This command should have
9775 * un_f_sync_nv_supported set to correct value.
9776 */
9777 mutex_enter(SD_MUTEX(un));
9778 if (un->un_f_sync_nv_supported) {
9779 mutex_exit(SD_MUTEX(un));
9780 dkc = kmem_zalloc(sizeof (struct dk_callback), KM_SLEEP);
9781 dkc->dkc_flag = FLUSH_VOLATILE;
9782 (void) sd_send_scsi_SYNCHRONIZE_CACHE(un, dkc);
9783
9784 /*
9785 * Send a TEST UNIT READY command to the device. This should
9786 * clear any outstanding UNIT ATTENTION that may be present.
9787 */
9788 rval = sd_send_scsi_TEST_UNIT_READY(ssc, SD_DONT_RETRY_TUR);
9789 if (rval != 0)
9790 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
9791
9792 kmem_free(dkc, sizeof (struct dk_callback));
9793 } else {
9794 mutex_exit(SD_MUTEX(un));
9795 }
9796
9797 SD_TRACE(SD_LOG_COMMON, un, "sd_get_nv_sup: \
9798 un_f_suppress_cache_flush is set to %d\n",
9799 un->un_f_suppress_cache_flush);
9800 }
9801
9802 /*
9803 * Function: sd_make_device
9804 *
9805 * Description: Utility routine to return the Solaris device number from
9806 * the data in the device's dev_info structure.
9807 *
9808 * Return Code: The Solaris device number
9809 *
9810 * Context: Any
9811 */
9812
9813 static dev_t
9814 sd_make_device(dev_info_t *devi)
9815 {
9816 return (makedevice(ddi_driver_major(devi),
9817 ddi_get_instance(devi) << SDUNIT_SHIFT));
9818 }
9819
9820
9821 /*
9822 * Function: sd_pm_entry
9823 *
9824 * Description: Called at the start of a new command to manage power
9825 * and busy status of a device. This includes determining whether
9826 * the current power state of the device is sufficient for
9827 * performing the command or whether it must be changed.
9828 * The PM framework is notified appropriately.
9829 * Only with a return status of DDI_SUCCESS will the
9830 * component be busy to the framework.
9831 *
9832 * All callers of sd_pm_entry must check the return status
9833 * and only call sd_pm_exit it it was DDI_SUCCESS. A status
9834 * of DDI_FAILURE indicates the device failed to power up.
9835 * In this case un_pm_count has been adjusted so the result
9836 * on exit is still powered down, ie. count is less than 0.
9837 * Calling sd_pm_exit with this count value hits an ASSERT.
9838 *
9839 * Return Code: DDI_SUCCESS or DDI_FAILURE
9840 *
9841 * Context: Kernel thread context.
9842 */
9843
9844 static int
9845 sd_pm_entry(struct sd_lun *un)
9846 {
9847 int return_status = DDI_SUCCESS;
9848
9849 ASSERT(!mutex_owned(SD_MUTEX(un)));
9850 ASSERT(!mutex_owned(&un->un_pm_mutex));
9851
9852 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_entry: entry\n");
9853
9854 if (un->un_f_pm_is_enabled == FALSE) {
9855 SD_TRACE(SD_LOG_IO_PM, un,
9856 "sd_pm_entry: exiting, PM not enabled\n");
9857 return (return_status);
9858 }
9859
9860 /*
9861 * Just increment a counter if PM is enabled. On the transition from
9862 * 0 ==> 1, mark the device as busy. The iodone side will decrement
9863 * the count with each IO and mark the device as idle when the count
9864 * hits 0.
9865 *
9866 * If the count is less than 0 the device is powered down. If a powered
9867 * down device is successfully powered up then the count must be
9868 * incremented to reflect the power up. Note that it'll get incremented
9869 * a second time to become busy.
9870 *
9871 * Because the following has the potential to change the device state
9872 * and must release the un_pm_mutex to do so, only one thread can be
9873 * allowed through at a time.
9874 */
9875
9876 mutex_enter(&un->un_pm_mutex);
9877 while (un->un_pm_busy == TRUE) {
9878 cv_wait(&un->un_pm_busy_cv, &un->un_pm_mutex);
9879 }
9880 un->un_pm_busy = TRUE;
9881
9882 if (un->un_pm_count < 1) {
9883
9884 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_entry: busy component\n");
9885
9886 /*
9887 * Indicate we are now busy so the framework won't attempt to
9888 * power down the device. This call will only fail if either
9889 * we passed a bad component number or the device has no
9890 * components. Neither of these should ever happen.
9891 */
9892 mutex_exit(&un->un_pm_mutex);
9893 return_status = pm_busy_component(SD_DEVINFO(un), 0);
9894 ASSERT(return_status == DDI_SUCCESS);
9895
9896 mutex_enter(&un->un_pm_mutex);
9897
9898 if (un->un_pm_count < 0) {
9899 mutex_exit(&un->un_pm_mutex);
9900
9901 SD_TRACE(SD_LOG_IO_PM, un,
9902 "sd_pm_entry: power up component\n");
9903
9904 /*
9905 * pm_raise_power will cause sdpower to be called
9906 * which brings the device power level to the
9907 * desired state, If successful, un_pm_count and
9908 * un_power_level will be updated appropriately.
9909 */
9910 return_status = pm_raise_power(SD_DEVINFO(un), 0,
9911 SD_PM_STATE_ACTIVE(un));
9912
9913 mutex_enter(&un->un_pm_mutex);
9914
9915 if (return_status != DDI_SUCCESS) {
9916 /*
9917 * Power up failed.
9918 * Idle the device and adjust the count
9919 * so the result on exit is that we're
9920 * still powered down, ie. count is less than 0.
9921 */
9922 SD_TRACE(SD_LOG_IO_PM, un,
9923 "sd_pm_entry: power up failed,"
9924 " idle the component\n");
9925
9926 (void) pm_idle_component(SD_DEVINFO(un), 0);
9927 un->un_pm_count--;
9928 } else {
9929 /*
9930 * Device is powered up, verify the
9931 * count is non-negative.
9932 * This is debug only.
9933 */
9934 ASSERT(un->un_pm_count == 0);
9935 }
9936 }
9937
9938 if (return_status == DDI_SUCCESS) {
9939 /*
9940 * For performance, now that the device has been tagged
9941 * as busy, and it's known to be powered up, update the
9942 * chain types to use jump tables that do not include
9943 * pm. This significantly lowers the overhead and
9944 * therefore improves performance.
9945 */
9946
9947 mutex_exit(&un->un_pm_mutex);
9948 mutex_enter(SD_MUTEX(un));
9949 SD_TRACE(SD_LOG_IO_PM, un,
9950 "sd_pm_entry: changing uscsi_chain_type from %d\n",
9951 un->un_uscsi_chain_type);
9952
9953 if (un->un_f_non_devbsize_supported) {
9954 un->un_buf_chain_type =
9955 SD_CHAIN_INFO_RMMEDIA_NO_PM;
9956 } else {
9957 un->un_buf_chain_type =
9958 SD_CHAIN_INFO_DISK_NO_PM;
9959 }
9960 un->un_uscsi_chain_type = SD_CHAIN_INFO_USCSI_CMD_NO_PM;
9961
9962 SD_TRACE(SD_LOG_IO_PM, un,
9963 " changed uscsi_chain_type to %d\n",
9964 un->un_uscsi_chain_type);
9965 mutex_exit(SD_MUTEX(un));
9966 mutex_enter(&un->un_pm_mutex);
9967
9968 if (un->un_pm_idle_timeid == NULL) {
9969 /* 300 ms. */
9970 un->un_pm_idle_timeid =
9971 timeout(sd_pm_idletimeout_handler, un,
9972 (drv_usectohz((clock_t)300000)));
9973 /*
9974 * Include an extra call to busy which keeps the
9975 * device busy with-respect-to the PM layer
9976 * until the timer fires, at which time it'll
9977 * get the extra idle call.
9978 */
9979 (void) pm_busy_component(SD_DEVINFO(un), 0);
9980 }
9981 }
9982 }
9983 un->un_pm_busy = FALSE;
9984 /* Next... */
9985 cv_signal(&un->un_pm_busy_cv);
9986
9987 un->un_pm_count++;
9988
9989 SD_TRACE(SD_LOG_IO_PM, un,
9990 "sd_pm_entry: exiting, un_pm_count = %d\n", un->un_pm_count);
9991
9992 mutex_exit(&un->un_pm_mutex);
9993
9994 return (return_status);
9995 }
9996
9997
9998 /*
9999 * Function: sd_pm_exit
10000 *
10001 * Description: Called at the completion of a command to manage busy
10002 * status for the device. If the device becomes idle the
10003 * PM framework is notified.
10004 *
10005 * Context: Kernel thread context
10006 */
10007
10008 static void
10009 sd_pm_exit(struct sd_lun *un)
10010 {
10011 ASSERT(!mutex_owned(SD_MUTEX(un)));
10012 ASSERT(!mutex_owned(&un->un_pm_mutex));
10013
10014 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_exit: entry\n");
10015
10016 /*
10017 * After attach the following flag is only read, so don't
10018 * take the penalty of acquiring a mutex for it.
10019 */
10020 if (un->un_f_pm_is_enabled == TRUE) {
10021
10022 mutex_enter(&un->un_pm_mutex);
10023 un->un_pm_count--;
10024
10025 SD_TRACE(SD_LOG_IO_PM, un,
10026 "sd_pm_exit: un_pm_count = %d\n", un->un_pm_count);
10027
10028 ASSERT(un->un_pm_count >= 0);
10029 if (un->un_pm_count == 0) {
10030 mutex_exit(&un->un_pm_mutex);
10031
10032 SD_TRACE(SD_LOG_IO_PM, un,
10033 "sd_pm_exit: idle component\n");
10034
10035 (void) pm_idle_component(SD_DEVINFO(un), 0);
10036
10037 } else {
10038 mutex_exit(&un->un_pm_mutex);
10039 }
10040 }
10041
10042 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_exit: exiting\n");
10043 }
10044
10045
10046 /*
10047 * Function: sdopen
10048 *
10049 * Description: Driver's open(9e) entry point function.
10050 *
10051 * Arguments: dev_i - pointer to device number
10052 * flag - how to open file (FEXCL, FNDELAY, FREAD, FWRITE)
10053 * otyp - open type (OTYP_BLK, OTYP_CHR, OTYP_LYR)
10054 * cred_p - user credential pointer
10055 *
10056 * Return Code: EINVAL
10057 * ENXIO
10058 * EIO
10059 * EROFS
10060 * EBUSY
10061 *
10062 * Context: Kernel thread context
10063 */
10064 /* ARGSUSED */
10065 static int
10066 sdopen(dev_t *dev_p, int flag, int otyp, cred_t *cred_p)
10067 {
10068 struct sd_lun *un;
10069 int nodelay;
10070 int part;
10071 uint64_t partmask;
10072 int instance;
10073 dev_t dev;
10074 int rval = EIO;
10075 diskaddr_t nblks = 0;
10076 diskaddr_t label_cap;
10077
10078 /* Validate the open type */
10079 if (otyp >= OTYPCNT) {
10080 return (EINVAL);
10081 }
10082
10083 dev = *dev_p;
10084 instance = SDUNIT(dev);
10085 mutex_enter(&sd_detach_mutex);
10086
10087 /*
10088 * Fail the open if there is no softstate for the instance, or
10089 * if another thread somewhere is trying to detach the instance.
10090 */
10091 if (((un = ddi_get_soft_state(sd_state, instance)) == NULL) ||
10092 (un->un_detach_count != 0)) {
10093 mutex_exit(&sd_detach_mutex);
10094 /*
10095 * The probe cache only needs to be cleared when open (9e) fails
10096 * with ENXIO (4238046).
10097 */
10098 /*
10099 * un-conditionally clearing probe cache is ok with
10100 * separate sd/ssd binaries
10101 * x86 platform can be an issue with both parallel
10102 * and fibre in 1 binary
10103 */
10104 sd_scsi_clear_probe_cache();
10105 return (ENXIO);
10106 }
10107
10108 /*
10109 * The un_layer_count is to prevent another thread in specfs from
10110 * trying to detach the instance, which can happen when we are
10111 * called from a higher-layer driver instead of thru specfs.
10112 * This will not be needed when DDI provides a layered driver
10113 * interface that allows specfs to know that an instance is in
10114 * use by a layered driver & should not be detached.
10115 *
10116 * Note: the semantics for layered driver opens are exactly one
10117 * close for every open.
10118 */
10119 if (otyp == OTYP_LYR) {
10120 un->un_layer_count++;
10121 }
10122
10123 /*
10124 * Keep a count of the current # of opens in progress. This is because
10125 * some layered drivers try to call us as a regular open. This can
10126 * cause problems that we cannot prevent, however by keeping this count
10127 * we can at least keep our open and detach routines from racing against
10128 * each other under such conditions.
10129 */
10130 un->un_opens_in_progress++;
10131 mutex_exit(&sd_detach_mutex);
10132
10133 nodelay = (flag & (FNDELAY | FNONBLOCK));
10134 part = SDPART(dev);
10135 partmask = 1 << part;
10136
10137 /*
10138 * We use a semaphore here in order to serialize
10139 * open and close requests on the device.
10140 */
10141 sema_p(&un->un_semoclose);
10142
10143 mutex_enter(SD_MUTEX(un));
10144
10145 /*
10146 * All device accesses go thru sdstrategy() where we check
10147 * on suspend status but there could be a scsi_poll command,
10148 * which bypasses sdstrategy(), so we need to check pm
10149 * status.
10150 */
10151
10152 if (!nodelay) {
10153 while ((un->un_state == SD_STATE_SUSPENDED) ||
10154 (un->un_state == SD_STATE_PM_CHANGING)) {
10155 cv_wait(&un->un_suspend_cv, SD_MUTEX(un));
10156 }
10157
10158 mutex_exit(SD_MUTEX(un));
10159 if (sd_pm_entry(un) != DDI_SUCCESS) {
10160 rval = EIO;
10161 SD_ERROR(SD_LOG_OPEN_CLOSE, un,
10162 "sdopen: sd_pm_entry failed\n");
10163 goto open_failed_with_pm;
10164 }
10165 mutex_enter(SD_MUTEX(un));
10166 }
10167
10168 /* check for previous exclusive open */
10169 SD_TRACE(SD_LOG_OPEN_CLOSE, un, "sdopen: un=%p\n", (void *)un);
10170 SD_TRACE(SD_LOG_OPEN_CLOSE, un,
10171 "sdopen: exclopen=%x, flag=%x, regopen=%x\n",
10172 un->un_exclopen, flag, un->un_ocmap.regopen[otyp]);
10173
10174 if (un->un_exclopen & (partmask)) {
10175 goto excl_open_fail;
10176 }
10177
10178 if (flag & FEXCL) {
10179 int i;
10180 if (un->un_ocmap.lyropen[part]) {
10181 goto excl_open_fail;
10182 }
10183 for (i = 0; i < (OTYPCNT - 1); i++) {
10184 if (un->un_ocmap.regopen[i] & (partmask)) {
10185 goto excl_open_fail;
10186 }
10187 }
10188 }
10189
10190 /*
10191 * Check the write permission if this is a removable media device,
10192 * NDELAY has not been set, and writable permission is requested.
10193 *
10194 * Note: If NDELAY was set and this is write-protected media the WRITE
10195 * attempt will fail with EIO as part of the I/O processing. This is a
10196 * more permissive implementation that allows the open to succeed and
10197 * WRITE attempts to fail when appropriate.
10198 */
10199 if (un->un_f_chk_wp_open) {
10200 if ((flag & FWRITE) && (!nodelay)) {
10201 mutex_exit(SD_MUTEX(un));
10202 /*
10203 * Defer the check for write permission on writable
10204 * DVD drive till sdstrategy and will not fail open even
10205 * if FWRITE is set as the device can be writable
10206 * depending upon the media and the media can change
10207 * after the call to open().
10208 */
10209 if (un->un_f_dvdram_writable_device == FALSE) {
10210 if (ISCD(un) || sr_check_wp(dev)) {
10211 rval = EROFS;
10212 mutex_enter(SD_MUTEX(un));
10213 SD_ERROR(SD_LOG_OPEN_CLOSE, un, "sdopen: "
10214 "write to cd or write protected media\n");
10215 goto open_fail;
10216 }
10217 }
10218 mutex_enter(SD_MUTEX(un));
10219 }
10220 }
10221
10222 /*
10223 * If opening in NDELAY/NONBLOCK mode, just return.
10224 * Check if disk is ready and has a valid geometry later.
10225 */
10226 if (!nodelay) {
10227 sd_ssc_t *ssc;
10228
10229 mutex_exit(SD_MUTEX(un));
10230 ssc = sd_ssc_init(un);
10231 rval = sd_ready_and_valid(ssc, part);
10232 sd_ssc_fini(ssc);
10233 mutex_enter(SD_MUTEX(un));
10234 /*
10235 * Fail if device is not ready or if the number of disk
10236 * blocks is zero or negative for non CD devices.
10237 */
10238
10239 nblks = 0;
10240
10241 if (rval == SD_READY_VALID && (!ISCD(un))) {
10242 /* if cmlb_partinfo fails, nblks remains 0 */
10243 mutex_exit(SD_MUTEX(un));
10244 (void) cmlb_partinfo(un->un_cmlbhandle, part, &nblks,
10245 NULL, NULL, NULL, (void *)SD_PATH_DIRECT);
10246 mutex_enter(SD_MUTEX(un));
10247 }
10248
10249 if ((rval != SD_READY_VALID) ||
10250 (!ISCD(un) && nblks <= 0)) {
10251 rval = un->un_f_has_removable_media ? ENXIO : EIO;
10252 SD_ERROR(SD_LOG_OPEN_CLOSE, un, "sdopen: "
10253 "device not ready or invalid disk block value\n");
10254 goto open_fail;
10255 }
10256 #if defined(__i386) || defined(__amd64)
10257 } else {
10258 uchar_t *cp;
10259 /*
10260 * x86 requires special nodelay handling, so that p0 is
10261 * always defined and accessible.
10262 * Invalidate geometry only if device is not already open.
10263 */
10264 cp = &un->un_ocmap.chkd[0];
10265 while (cp < &un->un_ocmap.chkd[OCSIZE]) {
10266 if (*cp != (uchar_t)0) {
10267 break;
10268 }
10269 cp++;
10270 }
10271 if (cp == &un->un_ocmap.chkd[OCSIZE]) {
10272 mutex_exit(SD_MUTEX(un));
10273 cmlb_invalidate(un->un_cmlbhandle,
10274 (void *)SD_PATH_DIRECT);
10275 mutex_enter(SD_MUTEX(un));
10276 }
10277
10278 #endif
10279 }
10280
10281 if (otyp == OTYP_LYR) {
10282 un->un_ocmap.lyropen[part]++;
10283 } else {
10284 un->un_ocmap.regopen[otyp] |= partmask;
10285 }
10286
10287 /* Set up open and exclusive open flags */
10288 if (flag & FEXCL) {
10289 un->un_exclopen |= (partmask);
10290 }
10291
10292 /*
10293 * If the lun is EFI labeled and lun capacity is greater than the
10294 * capacity contained in the label, log a sys-event to notify the
10295 * interested module.
10296 * To avoid an infinite loop of logging sys-event, we only log the
10297 * event when the lun is not opened in NDELAY mode. The event handler
10298 * should open the lun in NDELAY mode.
10299 */
10300 if (!nodelay) {
10301 mutex_exit(SD_MUTEX(un));
10302 if (cmlb_efi_label_capacity(un->un_cmlbhandle, &label_cap,
10303 (void*)SD_PATH_DIRECT) == 0) {
10304 mutex_enter(SD_MUTEX(un));
10305 if (un->un_f_blockcount_is_valid &&
10306 un->un_blockcount > label_cap &&
10307 un->un_f_expnevent == B_FALSE) {
10308 un->un_f_expnevent = B_TRUE;
10309 mutex_exit(SD_MUTEX(un));
10310 sd_log_lun_expansion_event(un,
10311 (nodelay ? KM_NOSLEEP : KM_SLEEP));
10312 mutex_enter(SD_MUTEX(un));
10313 }
10314 } else {
10315 mutex_enter(SD_MUTEX(un));
10316 }
10317 }
10318
10319 SD_TRACE(SD_LOG_OPEN_CLOSE, un, "sdopen: "
10320 "open of part %d type %d\n", part, otyp);
10321
10322 mutex_exit(SD_MUTEX(un));
10323 if (!nodelay) {
10324 sd_pm_exit(un);
10325 }
10326
10327 sema_v(&un->un_semoclose);
10328
10329 mutex_enter(&sd_detach_mutex);
10330 un->un_opens_in_progress--;
10331 mutex_exit(&sd_detach_mutex);
10332
10333 SD_TRACE(SD_LOG_OPEN_CLOSE, un, "sdopen: exit success\n");
10334 return (DDI_SUCCESS);
10335
10336 excl_open_fail:
10337 SD_ERROR(SD_LOG_OPEN_CLOSE, un, "sdopen: fail exclusive open\n");
10338 rval = EBUSY;
10339
10340 open_fail:
10341 mutex_exit(SD_MUTEX(un));
10342
10343 /*
10344 * On a failed open we must exit the pm management.
10345 */
10346 if (!nodelay) {
10347 sd_pm_exit(un);
10348 }
10349 open_failed_with_pm:
10350 sema_v(&un->un_semoclose);
10351
10352 mutex_enter(&sd_detach_mutex);
10353 un->un_opens_in_progress--;
10354 if (otyp == OTYP_LYR) {
10355 un->un_layer_count--;
10356 }
10357 mutex_exit(&sd_detach_mutex);
10358
10359 return (rval);
10360 }
10361
10362
10363 /*
10364 * Function: sdclose
10365 *
10366 * Description: Driver's close(9e) entry point function.
10367 *
10368 * Arguments: dev - device number
10369 * flag - file status flag, informational only
10370 * otyp - close type (OTYP_BLK, OTYP_CHR, OTYP_LYR)
10371 * cred_p - user credential pointer
10372 *
10373 * Return Code: ENXIO
10374 *
10375 * Context: Kernel thread context
10376 */
10377 /* ARGSUSED */
10378 static int
10379 sdclose(dev_t dev, int flag, int otyp, cred_t *cred_p)
10380 {
10381 struct sd_lun *un;
10382 uchar_t *cp;
10383 int part;
10384 int nodelay;
10385 int rval = 0;
10386
10387 /* Validate the open type */
10388 if (otyp >= OTYPCNT) {
10389 return (ENXIO);
10390 }
10391
10392 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
10393 return (ENXIO);
10394 }
10395
10396 part = SDPART(dev);
10397 nodelay = flag & (FNDELAY | FNONBLOCK);
10398
10399 SD_TRACE(SD_LOG_OPEN_CLOSE, un,
10400 "sdclose: close of part %d type %d\n", part, otyp);
10401
10402 /*
10403 * We use a semaphore here in order to serialize
10404 * open and close requests on the device.
10405 */
10406 sema_p(&un->un_semoclose);
10407
10408 mutex_enter(SD_MUTEX(un));
10409
10410 /* Don't proceed if power is being changed. */
10411 while (un->un_state == SD_STATE_PM_CHANGING) {
10412 cv_wait(&un->un_suspend_cv, SD_MUTEX(un));
10413 }
10414
10415 if (un->un_exclopen & (1 << part)) {
10416 un->un_exclopen &= ~(1 << part);
10417 }
10418
10419 /* Update the open partition map */
10420 if (otyp == OTYP_LYR) {
10421 un->un_ocmap.lyropen[part] -= 1;
10422 } else {
10423 un->un_ocmap.regopen[otyp] &= ~(1 << part);
10424 }
10425
10426 cp = &un->un_ocmap.chkd[0];
10427 while (cp < &un->un_ocmap.chkd[OCSIZE]) {
10428 if (*cp != NULL) {
10429 break;
10430 }
10431 cp++;
10432 }
10433
10434 if (cp == &un->un_ocmap.chkd[OCSIZE]) {
10435 SD_TRACE(SD_LOG_OPEN_CLOSE, un, "sdclose: last close\n");
10436
10437 /*
10438 * We avoid persistance upon the last close, and set
10439 * the throttle back to the maximum.
10440 */
10441 un->un_throttle = un->un_saved_throttle;
10442
10443 if (un->un_state == SD_STATE_OFFLINE) {
10444 if (un->un_f_is_fibre == FALSE) {
10445 scsi_log(SD_DEVINFO(un), sd_label,
10446 CE_WARN, "offline\n");
10447 }
10448 mutex_exit(SD_MUTEX(un));
10449 cmlb_invalidate(un->un_cmlbhandle,
10450 (void *)SD_PATH_DIRECT);
10451 mutex_enter(SD_MUTEX(un));
10452
10453 } else {
10454 /*
10455 * Flush any outstanding writes in NVRAM cache.
10456 * Note: SYNCHRONIZE CACHE is an optional SCSI-2
10457 * cmd, it may not work for non-Pluto devices.
10458 * SYNCHRONIZE CACHE is not required for removables,
10459 * except DVD-RAM drives.
10460 *
10461 * Also note: because SYNCHRONIZE CACHE is currently
10462 * the only command issued here that requires the
10463 * drive be powered up, only do the power up before
10464 * sending the Sync Cache command. If additional
10465 * commands are added which require a powered up
10466 * drive, the following sequence may have to change.
10467 *
10468 * And finally, note that parallel SCSI on SPARC
10469 * only issues a Sync Cache to DVD-RAM, a newly
10470 * supported device.
10471 */
10472 #if defined(__i386) || defined(__amd64)
10473 if ((un->un_f_sync_cache_supported &&
10474 un->un_f_sync_cache_required) ||
10475 un->un_f_dvdram_writable_device == TRUE) {
10476 #else
10477 if (un->un_f_dvdram_writable_device == TRUE) {
10478 #endif
10479 mutex_exit(SD_MUTEX(un));
10480 if (sd_pm_entry(un) == DDI_SUCCESS) {
10481 rval =
10482 sd_send_scsi_SYNCHRONIZE_CACHE(un,
10483 NULL);
10484 /* ignore error if not supported */
10485 if (rval == ENOTSUP) {
10486 rval = 0;
10487 } else if (rval != 0) {
10488 rval = EIO;
10489 }
10490 sd_pm_exit(un);
10491 } else {
10492 rval = EIO;
10493 }
10494 mutex_enter(SD_MUTEX(un));
10495 }
10496
10497 /*
10498 * For devices which supports DOOR_LOCK, send an ALLOW
10499 * MEDIA REMOVAL command, but don't get upset if it
10500 * fails. We need to raise the power of the drive before
10501 * we can call sd_send_scsi_DOORLOCK()
10502 */
10503 if (un->un_f_doorlock_supported) {
10504 mutex_exit(SD_MUTEX(un));
10505 if (sd_pm_entry(un) == DDI_SUCCESS) {
10506 sd_ssc_t *ssc;
10507
10508 ssc = sd_ssc_init(un);
10509 rval = sd_send_scsi_DOORLOCK(ssc,
10510 SD_REMOVAL_ALLOW, SD_PATH_DIRECT);
10511 if (rval != 0)
10512 sd_ssc_assessment(ssc,
10513 SD_FMT_IGNORE);
10514 sd_ssc_fini(ssc);
10515
10516 sd_pm_exit(un);
10517 if (ISCD(un) && (rval != 0) &&
10518 (nodelay != 0)) {
10519 rval = ENXIO;
10520 }
10521 } else {
10522 rval = EIO;
10523 }
10524 mutex_enter(SD_MUTEX(un));
10525 }
10526
10527 /*
10528 * If a device has removable media, invalidate all
10529 * parameters related to media, such as geometry,
10530 * blocksize, and blockcount.
10531 */
10532 if (un->un_f_has_removable_media) {
10533 sr_ejected(un);
10534 }
10535
10536 /*
10537 * Destroy the cache (if it exists) which was
10538 * allocated for the write maps since this is
10539 * the last close for this media.
10540 */
10541 if (un->un_wm_cache) {
10542 /*
10543 * Check if there are pending commands.
10544 * and if there are give a warning and
10545 * do not destroy the cache.
10546 */
10547 if (un->un_ncmds_in_driver > 0) {
10548 scsi_log(SD_DEVINFO(un),
10549 sd_label, CE_WARN,
10550 "Unable to clean up memory "
10551 "because of pending I/O\n");
10552 } else {
10553 kmem_cache_destroy(
10554 un->un_wm_cache);
10555 un->un_wm_cache = NULL;
10556 }
10557 }
10558 }
10559 }
10560
10561 mutex_exit(SD_MUTEX(un));
10562 sema_v(&un->un_semoclose);
10563
10564 if (otyp == OTYP_LYR) {
10565 mutex_enter(&sd_detach_mutex);
10566 /*
10567 * The detach routine may run when the layer count
10568 * drops to zero.
10569 */
10570 un->un_layer_count--;
10571 mutex_exit(&sd_detach_mutex);
10572 }
10573
10574 return (rval);
10575 }
10576
10577
10578 /*
10579 * Function: sd_ready_and_valid
10580 *
10581 * Description: Test if device is ready and has a valid geometry.
10582 *
10583 * Arguments: ssc - sd_ssc_t will contain un
10584 * un - driver soft state (unit) structure
10585 *
10586 * Return Code: SD_READY_VALID ready and valid label
10587 * SD_NOT_READY_VALID not ready, no label
10588 * SD_RESERVED_BY_OTHERS reservation conflict
10589 *
10590 * Context: Never called at interrupt context.
10591 */
10592
10593 static int
10594 sd_ready_and_valid(sd_ssc_t *ssc, int part)
10595 {
10596 struct sd_errstats *stp;
10597 uint64_t capacity;
10598 uint_t lbasize;
10599 int rval = SD_READY_VALID;
10600 char name_str[48];
10601 boolean_t is_valid;
10602 struct sd_lun *un;
10603 int status;
10604
10605 ASSERT(ssc != NULL);
10606 un = ssc->ssc_un;
10607 ASSERT(un != NULL);
10608 ASSERT(!mutex_owned(SD_MUTEX(un)));
10609
10610 mutex_enter(SD_MUTEX(un));
10611 /*
10612 * If a device has removable media, we must check if media is
10613 * ready when checking if this device is ready and valid.
10614 */
10615 if (un->un_f_has_removable_media) {
10616 mutex_exit(SD_MUTEX(un));
10617 status = sd_send_scsi_TEST_UNIT_READY(ssc, 0);
10618
10619 if (status != 0) {
10620 rval = SD_NOT_READY_VALID;
10621 mutex_enter(SD_MUTEX(un));
10622
10623 /* Ignore all failed status for removalbe media */
10624 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
10625
10626 goto done;
10627 }
10628
10629 is_valid = SD_IS_VALID_LABEL(un);
10630 mutex_enter(SD_MUTEX(un));
10631 if (!is_valid ||
10632 (un->un_f_blockcount_is_valid == FALSE) ||
10633 (un->un_f_tgt_blocksize_is_valid == FALSE)) {
10634
10635 /* capacity has to be read every open. */
10636 mutex_exit(SD_MUTEX(un));
10637 status = sd_send_scsi_READ_CAPACITY(ssc, &capacity,
10638 &lbasize, SD_PATH_DIRECT);
10639
10640 if (status != 0) {
10641 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
10642
10643 cmlb_invalidate(un->un_cmlbhandle,
10644 (void *)SD_PATH_DIRECT);
10645 mutex_enter(SD_MUTEX(un));
10646 rval = SD_NOT_READY_VALID;
10647
10648 goto done;
10649 } else {
10650 mutex_enter(SD_MUTEX(un));
10651 sd_update_block_info(un, lbasize, capacity);
10652 }
10653 }
10654
10655 /*
10656 * Check if the media in the device is writable or not.
10657 */
10658 if (!is_valid && ISCD(un)) {
10659 sd_check_for_writable_cd(ssc, SD_PATH_DIRECT);
10660 }
10661
10662 } else {
10663 /*
10664 * Do a test unit ready to clear any unit attention from non-cd
10665 * devices.
10666 */
10667 mutex_exit(SD_MUTEX(un));
10668
10669 status = sd_send_scsi_TEST_UNIT_READY(ssc, 0);
10670 if (status != 0) {
10671 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
10672 }
10673
10674 mutex_enter(SD_MUTEX(un));
10675 }
10676
10677
10678 /*
10679 * If this is a non 512 block device, allocate space for
10680 * the wmap cache. This is being done here since every time
10681 * a media is changed this routine will be called and the
10682 * block size is a function of media rather than device.
10683 */
10684 if (((un->un_f_rmw_type != SD_RMW_TYPE_RETURN_ERROR ||
10685 un->un_f_non_devbsize_supported) &&
10686 un->un_tgt_blocksize != DEV_BSIZE) ||
10687 un->un_f_enable_rmw) {
10688 if (!(un->un_wm_cache)) {
10689 (void) snprintf(name_str, sizeof (name_str),
10690 "%s%d_cache",
10691 ddi_driver_name(SD_DEVINFO(un)),
10692 ddi_get_instance(SD_DEVINFO(un)));
10693 un->un_wm_cache = kmem_cache_create(
10694 name_str, sizeof (struct sd_w_map),
10695 8, sd_wm_cache_constructor,
10696 sd_wm_cache_destructor, NULL,
10697 (void *)un, NULL, 0);
10698 if (!(un->un_wm_cache)) {
10699 rval = ENOMEM;
10700 goto done;
10701 }
10702 }
10703 }
10704
10705 if (un->un_state == SD_STATE_NORMAL) {
10706 /*
10707 * If the target is not yet ready here (defined by a TUR
10708 * failure), invalidate the geometry and print an 'offline'
10709 * message. This is a legacy message, as the state of the
10710 * target is not actually changed to SD_STATE_OFFLINE.
10711 *
10712 * If the TUR fails for EACCES (Reservation Conflict),
10713 * SD_RESERVED_BY_OTHERS will be returned to indicate
10714 * reservation conflict. If the TUR fails for other
10715 * reasons, SD_NOT_READY_VALID will be returned.
10716 */
10717 int err;
10718
10719 mutex_exit(SD_MUTEX(un));
10720 err = sd_send_scsi_TEST_UNIT_READY(ssc, 0);
10721 mutex_enter(SD_MUTEX(un));
10722
10723 if (err != 0) {
10724 mutex_exit(SD_MUTEX(un));
10725 cmlb_invalidate(un->un_cmlbhandle,
10726 (void *)SD_PATH_DIRECT);
10727 mutex_enter(SD_MUTEX(un));
10728 if (err == EACCES) {
10729 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
10730 "reservation conflict\n");
10731 rval = SD_RESERVED_BY_OTHERS;
10732 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
10733 } else {
10734 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
10735 "drive offline\n");
10736 rval = SD_NOT_READY_VALID;
10737 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
10738 }
10739 goto done;
10740 }
10741 }
10742
10743 if (un->un_f_format_in_progress == FALSE) {
10744 mutex_exit(SD_MUTEX(un));
10745
10746 (void) cmlb_validate(un->un_cmlbhandle, 0,
10747 (void *)SD_PATH_DIRECT);
10748 if (cmlb_partinfo(un->un_cmlbhandle, part, NULL, NULL, NULL,
10749 NULL, (void *) SD_PATH_DIRECT) != 0) {
10750 rval = SD_NOT_READY_VALID;
10751 mutex_enter(SD_MUTEX(un));
10752
10753 goto done;
10754 }
10755 if (un->un_f_pkstats_enabled) {
10756 sd_set_pstats(un);
10757 SD_TRACE(SD_LOG_IO_PARTITION, un,
10758 "sd_ready_and_valid: un:0x%p pstats created and "
10759 "set\n", un);
10760 }
10761 mutex_enter(SD_MUTEX(un));
10762 }
10763
10764 /*
10765 * If this device supports DOOR_LOCK command, try and send
10766 * this command to PREVENT MEDIA REMOVAL, but don't get upset
10767 * if it fails. For a CD, however, it is an error
10768 */
10769 if (un->un_f_doorlock_supported) {
10770 mutex_exit(SD_MUTEX(un));
10771 status = sd_send_scsi_DOORLOCK(ssc, SD_REMOVAL_PREVENT,
10772 SD_PATH_DIRECT);
10773
10774 if ((status != 0) && ISCD(un)) {
10775 rval = SD_NOT_READY_VALID;
10776 mutex_enter(SD_MUTEX(un));
10777
10778 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
10779
10780 goto done;
10781 } else if (status != 0)
10782 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
10783 mutex_enter(SD_MUTEX(un));
10784 }
10785
10786 /* The state has changed, inform the media watch routines */
10787 un->un_mediastate = DKIO_INSERTED;
10788 cv_broadcast(&un->un_state_cv);
10789 rval = SD_READY_VALID;
10790
10791 done:
10792
10793 /*
10794 * Initialize the capacity kstat value, if no media previously
10795 * (capacity kstat is 0) and a media has been inserted
10796 * (un_blockcount > 0).
10797 */
10798 if (un->un_errstats != NULL) {
10799 stp = (struct sd_errstats *)un->un_errstats->ks_data;
10800 if ((stp->sd_capacity.value.ui64 == 0) &&
10801 (un->un_f_blockcount_is_valid == TRUE)) {
10802 stp->sd_capacity.value.ui64 =
10803 (uint64_t)((uint64_t)un->un_blockcount *
10804 un->un_sys_blocksize);
10805 }
10806 }
10807
10808 mutex_exit(SD_MUTEX(un));
10809 return (rval);
10810 }
10811
10812
10813 /*
10814 * Function: sdmin
10815 *
10816 * Description: Routine to limit the size of a data transfer. Used in
10817 * conjunction with physio(9F).
10818 *
10819 * Arguments: bp - pointer to the indicated buf(9S) struct.
10820 *
10821 * Context: Kernel thread context.
10822 */
10823
10824 static void
10825 sdmin(struct buf *bp)
10826 {
10827 struct sd_lun *un;
10828 int instance;
10829
10830 instance = SDUNIT(bp->b_edev);
10831
10832 un = ddi_get_soft_state(sd_state, instance);
10833 ASSERT(un != NULL);
10834
10835 /*
10836 * We depend on buf breakup to restrict
10837 * IO size if it is enabled.
10838 */
10839 if (un->un_buf_breakup_supported) {
10840 return;
10841 }
10842
10843 if (bp->b_bcount > un->un_max_xfer_size) {
10844 bp->b_bcount = un->un_max_xfer_size;
10845 }
10846 }
10847
10848
10849 /*
10850 * Function: sdread
10851 *
10852 * Description: Driver's read(9e) entry point function.
10853 *
10854 * Arguments: dev - device number
10855 * uio - structure pointer describing where data is to be stored
10856 * in user's space
10857 * cred_p - user credential pointer
10858 *
10859 * Return Code: ENXIO
10860 * EIO
10861 * EINVAL
10862 * value returned by physio
10863 *
10864 * Context: Kernel thread context.
10865 */
10866 /* ARGSUSED */
10867 static int
10868 sdread(dev_t dev, struct uio *uio, cred_t *cred_p)
10869 {
10870 struct sd_lun *un = NULL;
10871 int secmask;
10872 int err = 0;
10873 sd_ssc_t *ssc;
10874
10875 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
10876 return (ENXIO);
10877 }
10878
10879 ASSERT(!mutex_owned(SD_MUTEX(un)));
10880
10881
10882 if (!SD_IS_VALID_LABEL(un) && !ISCD(un)) {
10883 mutex_enter(SD_MUTEX(un));
10884 /*
10885 * Because the call to sd_ready_and_valid will issue I/O we
10886 * must wait here if either the device is suspended or
10887 * if it's power level is changing.
10888 */
10889 while ((un->un_state == SD_STATE_SUSPENDED) ||
10890 (un->un_state == SD_STATE_PM_CHANGING)) {
10891 cv_wait(&un->un_suspend_cv, SD_MUTEX(un));
10892 }
10893 un->un_ncmds_in_driver++;
10894 mutex_exit(SD_MUTEX(un));
10895
10896 /* Initialize sd_ssc_t for internal uscsi commands */
10897 ssc = sd_ssc_init(un);
10898 if ((sd_ready_and_valid(ssc, SDPART(dev))) != SD_READY_VALID) {
10899 err = EIO;
10900 } else {
10901 err = 0;
10902 }
10903 sd_ssc_fini(ssc);
10904
10905 mutex_enter(SD_MUTEX(un));
10906 un->un_ncmds_in_driver--;
10907 ASSERT(un->un_ncmds_in_driver >= 0);
10908 mutex_exit(SD_MUTEX(un));
10909 if (err != 0)
10910 return (err);
10911 }
10912
10913 /*
10914 * Read requests are restricted to multiples of the system block size.
10915 */
10916 if (un->un_f_rmw_type == SD_RMW_TYPE_RETURN_ERROR &&
10917 !un->un_f_enable_rmw)
10918 secmask = un->un_tgt_blocksize - 1;
10919 else
10920 secmask = DEV_BSIZE - 1;
10921
10922 if (uio->uio_loffset & ((offset_t)(secmask))) {
10923 SD_ERROR(SD_LOG_READ_WRITE, un,
10924 "sdread: file offset not modulo %d\n",
10925 secmask + 1);
10926 err = EINVAL;
10927 } else if (uio->uio_iov->iov_len & (secmask)) {
10928 SD_ERROR(SD_LOG_READ_WRITE, un,
10929 "sdread: transfer length not modulo %d\n",
10930 secmask + 1);
10931 err = EINVAL;
10932 } else {
10933 err = physio(sdstrategy, NULL, dev, B_READ, sdmin, uio);
10934 }
10935
10936 return (err);
10937 }
10938
10939
10940 /*
10941 * Function: sdwrite
10942 *
10943 * Description: Driver's write(9e) entry point function.
10944 *
10945 * Arguments: dev - device number
10946 * uio - structure pointer describing where data is stored in
10947 * user's space
10948 * cred_p - user credential pointer
10949 *
10950 * Return Code: ENXIO
10951 * EIO
10952 * EINVAL
10953 * value returned by physio
10954 *
10955 * Context: Kernel thread context.
10956 */
10957 /* ARGSUSED */
10958 static int
10959 sdwrite(dev_t dev, struct uio *uio, cred_t *cred_p)
10960 {
10961 struct sd_lun *un = NULL;
10962 int secmask;
10963 int err = 0;
10964 sd_ssc_t *ssc;
10965
10966 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
10967 return (ENXIO);
10968 }
10969
10970 ASSERT(!mutex_owned(SD_MUTEX(un)));
10971
10972 if (!SD_IS_VALID_LABEL(un) && !ISCD(un)) {
10973 mutex_enter(SD_MUTEX(un));
10974 /*
10975 * Because the call to sd_ready_and_valid will issue I/O we
10976 * must wait here if either the device is suspended or
10977 * if it's power level is changing.
10978 */
10979 while ((un->un_state == SD_STATE_SUSPENDED) ||
10980 (un->un_state == SD_STATE_PM_CHANGING)) {
10981 cv_wait(&un->un_suspend_cv, SD_MUTEX(un));
10982 }
10983 un->un_ncmds_in_driver++;
10984 mutex_exit(SD_MUTEX(un));
10985
10986 /* Initialize sd_ssc_t for internal uscsi commands */
10987 ssc = sd_ssc_init(un);
10988 if ((sd_ready_and_valid(ssc, SDPART(dev))) != SD_READY_VALID) {
10989 err = EIO;
10990 } else {
10991 err = 0;
10992 }
10993 sd_ssc_fini(ssc);
10994
10995 mutex_enter(SD_MUTEX(un));
10996 un->un_ncmds_in_driver--;
10997 ASSERT(un->un_ncmds_in_driver >= 0);
10998 mutex_exit(SD_MUTEX(un));
10999 if (err != 0)
11000 return (err);
11001 }
11002
11003 /*
11004 * Write requests are restricted to multiples of the system block size.
11005 */
11006 if (un->un_f_rmw_type == SD_RMW_TYPE_RETURN_ERROR &&
11007 !un->un_f_enable_rmw)
11008 secmask = un->un_tgt_blocksize - 1;
11009 else
11010 secmask = DEV_BSIZE - 1;
11011
11012 if (uio->uio_loffset & ((offset_t)(secmask))) {
11013 SD_ERROR(SD_LOG_READ_WRITE, un,
11014 "sdwrite: file offset not modulo %d\n",
11015 secmask + 1);
11016 err = EINVAL;
11017 } else if (uio->uio_iov->iov_len & (secmask)) {
11018 SD_ERROR(SD_LOG_READ_WRITE, un,
11019 "sdwrite: transfer length not modulo %d\n",
11020 secmask + 1);
11021 err = EINVAL;
11022 } else {
11023 err = physio(sdstrategy, NULL, dev, B_WRITE, sdmin, uio);
11024 }
11025
11026 return (err);
11027 }
11028
11029
11030 /*
11031 * Function: sdaread
11032 *
11033 * Description: Driver's aread(9e) entry point function.
11034 *
11035 * Arguments: dev - device number
11036 * aio - structure pointer describing where data is to be stored
11037 * cred_p - user credential pointer
11038 *
11039 * Return Code: ENXIO
11040 * EIO
11041 * EINVAL
11042 * value returned by aphysio
11043 *
11044 * Context: Kernel thread context.
11045 */
11046 /* ARGSUSED */
11047 static int
11048 sdaread(dev_t dev, struct aio_req *aio, cred_t *cred_p)
11049 {
11050 struct sd_lun *un = NULL;
11051 struct uio *uio = aio->aio_uio;
11052 int secmask;
11053 int err = 0;
11054 sd_ssc_t *ssc;
11055
11056 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
11057 return (ENXIO);
11058 }
11059
11060 ASSERT(!mutex_owned(SD_MUTEX(un)));
11061
11062 if (!SD_IS_VALID_LABEL(un) && !ISCD(un)) {
11063 mutex_enter(SD_MUTEX(un));
11064 /*
11065 * Because the call to sd_ready_and_valid will issue I/O we
11066 * must wait here if either the device is suspended or
11067 * if it's power level is changing.
11068 */
11069 while ((un->un_state == SD_STATE_SUSPENDED) ||
11070 (un->un_state == SD_STATE_PM_CHANGING)) {
11071 cv_wait(&un->un_suspend_cv, SD_MUTEX(un));
11072 }
11073 un->un_ncmds_in_driver++;
11074 mutex_exit(SD_MUTEX(un));
11075
11076 /* Initialize sd_ssc_t for internal uscsi commands */
11077 ssc = sd_ssc_init(un);
11078 if ((sd_ready_and_valid(ssc, SDPART(dev))) != SD_READY_VALID) {
11079 err = EIO;
11080 } else {
11081 err = 0;
11082 }
11083 sd_ssc_fini(ssc);
11084
11085 mutex_enter(SD_MUTEX(un));
11086 un->un_ncmds_in_driver--;
11087 ASSERT(un->un_ncmds_in_driver >= 0);
11088 mutex_exit(SD_MUTEX(un));
11089 if (err != 0)
11090 return (err);
11091 }
11092
11093 /*
11094 * Read requests are restricted to multiples of the system block size.
11095 */
11096 if (un->un_f_rmw_type == SD_RMW_TYPE_RETURN_ERROR &&
11097 !un->un_f_enable_rmw)
11098 secmask = un->un_tgt_blocksize - 1;
11099 else
11100 secmask = DEV_BSIZE - 1;
11101
11102 if (uio->uio_loffset & ((offset_t)(secmask))) {
11103 SD_ERROR(SD_LOG_READ_WRITE, un,
11104 "sdaread: file offset not modulo %d\n",
11105 secmask + 1);
11106 err = EINVAL;
11107 } else if (uio->uio_iov->iov_len & (secmask)) {
11108 SD_ERROR(SD_LOG_READ_WRITE, un,
11109 "sdaread: transfer length not modulo %d\n",
11110 secmask + 1);
11111 err = EINVAL;
11112 } else {
11113 err = aphysio(sdstrategy, anocancel, dev, B_READ, sdmin, aio);
11114 }
11115
11116 return (err);
11117 }
11118
11119
11120 /*
11121 * Function: sdawrite
11122 *
11123 * Description: Driver's awrite(9e) entry point function.
11124 *
11125 * Arguments: dev - device number
11126 * aio - structure pointer describing where data is stored
11127 * cred_p - user credential pointer
11128 *
11129 * Return Code: ENXIO
11130 * EIO
11131 * EINVAL
11132 * value returned by aphysio
11133 *
11134 * Context: Kernel thread context.
11135 */
11136 /* ARGSUSED */
11137 static int
11138 sdawrite(dev_t dev, struct aio_req *aio, cred_t *cred_p)
11139 {
11140 struct sd_lun *un = NULL;
11141 struct uio *uio = aio->aio_uio;
11142 int secmask;
11143 int err = 0;
11144 sd_ssc_t *ssc;
11145
11146 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
11147 return (ENXIO);
11148 }
11149
11150 ASSERT(!mutex_owned(SD_MUTEX(un)));
11151
11152 if (!SD_IS_VALID_LABEL(un) && !ISCD(un)) {
11153 mutex_enter(SD_MUTEX(un));
11154 /*
11155 * Because the call to sd_ready_and_valid will issue I/O we
11156 * must wait here if either the device is suspended or
11157 * if it's power level is changing.
11158 */
11159 while ((un->un_state == SD_STATE_SUSPENDED) ||
11160 (un->un_state == SD_STATE_PM_CHANGING)) {
11161 cv_wait(&un->un_suspend_cv, SD_MUTEX(un));
11162 }
11163 un->un_ncmds_in_driver++;
11164 mutex_exit(SD_MUTEX(un));
11165
11166 /* Initialize sd_ssc_t for internal uscsi commands */
11167 ssc = sd_ssc_init(un);
11168 if ((sd_ready_and_valid(ssc, SDPART(dev))) != SD_READY_VALID) {
11169 err = EIO;
11170 } else {
11171 err = 0;
11172 }
11173 sd_ssc_fini(ssc);
11174
11175 mutex_enter(SD_MUTEX(un));
11176 un->un_ncmds_in_driver--;
11177 ASSERT(un->un_ncmds_in_driver >= 0);
11178 mutex_exit(SD_MUTEX(un));
11179 if (err != 0)
11180 return (err);
11181 }
11182
11183 /*
11184 * Write requests are restricted to multiples of the system block size.
11185 */
11186 if (un->un_f_rmw_type == SD_RMW_TYPE_RETURN_ERROR &&
11187 !un->un_f_enable_rmw)
11188 secmask = un->un_tgt_blocksize - 1;
11189 else
11190 secmask = DEV_BSIZE - 1;
11191
11192 if (uio->uio_loffset & ((offset_t)(secmask))) {
11193 SD_ERROR(SD_LOG_READ_WRITE, un,
11194 "sdawrite: file offset not modulo %d\n",
11195 secmask + 1);
11196 err = EINVAL;
11197 } else if (uio->uio_iov->iov_len & (secmask)) {
11198 SD_ERROR(SD_LOG_READ_WRITE, un,
11199 "sdawrite: transfer length not modulo %d\n",
11200 secmask + 1);
11201 err = EINVAL;
11202 } else {
11203 err = aphysio(sdstrategy, anocancel, dev, B_WRITE, sdmin, aio);
11204 }
11205
11206 return (err);
11207 }
11208
11209
11210
11211
11212
11213 /*
11214 * Driver IO processing follows the following sequence:
11215 *
11216 * sdioctl(9E) sdstrategy(9E) biodone(9F)
11217 * | | ^
11218 * v v |
11219 * sd_send_scsi_cmd() ddi_xbuf_qstrategy() +-------------------+
11220 * | | | |
11221 * v | | |
11222 * sd_uscsi_strategy() sd_xbuf_strategy() sd_buf_iodone() sd_uscsi_iodone()
11223 * | | ^ ^
11224 * v v | |
11225 * SD_BEGIN_IOSTART() SD_BEGIN_IOSTART() | |
11226 * | | | |
11227 * +---+ | +------------+ +-------+
11228 * | | | |
11229 * | SD_NEXT_IOSTART()| SD_NEXT_IODONE()| |
11230 * | v | |
11231 * | sd_mapblockaddr_iostart() sd_mapblockaddr_iodone() |
11232 * | | ^ |
11233 * | SD_NEXT_IOSTART()| SD_NEXT_IODONE()| |
11234 * | v | |
11235 * | sd_mapblocksize_iostart() sd_mapblocksize_iodone() |
11236 * | | ^ |
11237 * | SD_NEXT_IOSTART()| SD_NEXT_IODONE()| |
11238 * | v | |
11239 * | sd_checksum_iostart() sd_checksum_iodone() |
11240 * | | ^ |
11241 * +-> SD_NEXT_IOSTART()| SD_NEXT_IODONE()+------------->+
11242 * | v | |
11243 * | sd_pm_iostart() sd_pm_iodone() |
11244 * | | ^ |
11245 * | | | |
11246 * +-> SD_NEXT_IOSTART()| SD_BEGIN_IODONE()--+--------------+
11247 * | ^
11248 * v |
11249 * sd_core_iostart() |
11250 * | |
11251 * | +------>(*destroypkt)()
11252 * +-> sd_start_cmds() <-+ | |
11253 * | | | v
11254 * | | | scsi_destroy_pkt(9F)
11255 * | | |
11256 * +->(*initpkt)() +- sdintr()
11257 * | | | |
11258 * | +-> scsi_init_pkt(9F) | +-> sd_handle_xxx()
11259 * | +-> scsi_setup_cdb(9F) |
11260 * | |
11261 * +--> scsi_transport(9F) |
11262 * | |
11263 * +----> SCSA ---->+
11264 *
11265 *
11266 * This code is based upon the following presumptions:
11267 *
11268 * - iostart and iodone functions operate on buf(9S) structures. These
11269 * functions perform the necessary operations on the buf(9S) and pass
11270 * them along to the next function in the chain by using the macros
11271 * SD_NEXT_IOSTART() (for iostart side functions) and SD_NEXT_IODONE()
11272 * (for iodone side functions).
11273 *
11274 * - The iostart side functions may sleep. The iodone side functions
11275 * are called under interrupt context and may NOT sleep. Therefore
11276 * iodone side functions also may not call iostart side functions.
11277 * (NOTE: iostart side functions should NOT sleep for memory, as
11278 * this could result in deadlock.)
11279 *
11280 * - An iostart side function may call its corresponding iodone side
11281 * function directly (if necessary).
11282 *
11283 * - In the event of an error, an iostart side function can return a buf(9S)
11284 * to its caller by calling SD_BEGIN_IODONE() (after setting B_ERROR and
11285 * b_error in the usual way of course).
11286 *
11287 * - The taskq mechanism may be used by the iodone side functions to dispatch
11288 * requests to the iostart side functions. The iostart side functions in
11289 * this case would be called under the context of a taskq thread, so it's
11290 * OK for them to block/sleep/spin in this case.
11291 *
11292 * - iostart side functions may allocate "shadow" buf(9S) structs and
11293 * pass them along to the next function in the chain. The corresponding
11294 * iodone side functions must coalesce the "shadow" bufs and return
11295 * the "original" buf to the next higher layer.
11296 *
11297 * - The b_private field of the buf(9S) struct holds a pointer to
11298 * an sd_xbuf struct, which contains information needed to
11299 * construct the scsi_pkt for the command.
11300 *
11301 * - The SD_MUTEX(un) is NOT held across calls to the next layer. Each
11302 * layer must acquire & release the SD_MUTEX(un) as needed.
11303 */
11304
11305
11306 /*
11307 * Create taskq for all targets in the system. This is created at
11308 * _init(9E) and destroyed at _fini(9E).
11309 *
11310 * Note: here we set the minalloc to a reasonably high number to ensure that
11311 * we will have an adequate supply of task entries available at interrupt time.
11312 * This is used in conjunction with the TASKQ_PREPOPULATE flag in
11313 * sd_create_taskq(). Since we do not want to sleep for allocations at
11314 * interrupt time, set maxalloc equal to minalloc. That way we will just fail
11315 * the command if we ever try to dispatch more than SD_TASKQ_MAXALLOC taskq
11316 * requests any one instant in time.
11317 */
11318 #define SD_TASKQ_NUMTHREADS 8
11319 #define SD_TASKQ_MINALLOC 256
11320 #define SD_TASKQ_MAXALLOC 256
11321
11322 static taskq_t *sd_tq = NULL;
11323 _NOTE(SCHEME_PROTECTS_DATA("stable data", sd_tq))
11324
11325 static int sd_taskq_minalloc = SD_TASKQ_MINALLOC;
11326 static int sd_taskq_maxalloc = SD_TASKQ_MAXALLOC;
11327
11328 /*
11329 * The following task queue is being created for the write part of
11330 * read-modify-write of non-512 block size devices.
11331 * Limit the number of threads to 1 for now. This number has been chosen
11332 * considering the fact that it applies only to dvd ram drives/MO drives
11333 * currently. Performance for which is not main criteria at this stage.
11334 * Note: It needs to be explored if we can use a single taskq in future
11335 */
11336 #define SD_WMR_TASKQ_NUMTHREADS 1
11337 static taskq_t *sd_wmr_tq = NULL;
11338 _NOTE(SCHEME_PROTECTS_DATA("stable data", sd_wmr_tq))
11339
11340 /*
11341 * Function: sd_taskq_create
11342 *
11343 * Description: Create taskq thread(s) and preallocate task entries
11344 *
11345 * Return Code: Returns a pointer to the allocated taskq_t.
11346 *
11347 * Context: Can sleep. Requires blockable context.
11348 *
11349 * Notes: - The taskq() facility currently is NOT part of the DDI.
11350 * (definitely NOT recommeded for 3rd-party drivers!) :-)
11351 * - taskq_create() will block for memory, also it will panic
11352 * if it cannot create the requested number of threads.
11353 * - Currently taskq_create() creates threads that cannot be
11354 * swapped.
11355 * - We use TASKQ_PREPOPULATE to ensure we have an adequate
11356 * supply of taskq entries at interrupt time (ie, so that we
11357 * do not have to sleep for memory)
11358 */
11359
11360 static void
11361 sd_taskq_create(void)
11362 {
11363 char taskq_name[TASKQ_NAMELEN];
11364
11365 ASSERT(sd_tq == NULL);
11366 ASSERT(sd_wmr_tq == NULL);
11367
11368 (void) snprintf(taskq_name, sizeof (taskq_name),
11369 "%s_drv_taskq", sd_label);
11370 sd_tq = (taskq_create(taskq_name, SD_TASKQ_NUMTHREADS,
11371 (v.v_maxsyspri - 2), sd_taskq_minalloc, sd_taskq_maxalloc,
11372 TASKQ_PREPOPULATE));
11373
11374 (void) snprintf(taskq_name, sizeof (taskq_name),
11375 "%s_rmw_taskq", sd_label);
11376 sd_wmr_tq = (taskq_create(taskq_name, SD_WMR_TASKQ_NUMTHREADS,
11377 (v.v_maxsyspri - 2), sd_taskq_minalloc, sd_taskq_maxalloc,
11378 TASKQ_PREPOPULATE));
11379 }
11380
11381
11382 /*
11383 * Function: sd_taskq_delete
11384 *
11385 * Description: Complementary cleanup routine for sd_taskq_create().
11386 *
11387 * Context: Kernel thread context.
11388 */
11389
11390 static void
11391 sd_taskq_delete(void)
11392 {
11393 ASSERT(sd_tq != NULL);
11394 ASSERT(sd_wmr_tq != NULL);
11395 taskq_destroy(sd_tq);
11396 taskq_destroy(sd_wmr_tq);
11397 sd_tq = NULL;
11398 sd_wmr_tq = NULL;
11399 }
11400
11401
11402 /*
11403 * Function: sdstrategy
11404 *
11405 * Description: Driver's strategy (9E) entry point function.
11406 *
11407 * Arguments: bp - pointer to buf(9S)
11408 *
11409 * Return Code: Always returns zero
11410 *
11411 * Context: Kernel thread context.
11412 */
11413
11414 static int
11415 sdstrategy(struct buf *bp)
11416 {
11417 struct sd_lun *un;
11418
11419 un = ddi_get_soft_state(sd_state, SD_GET_INSTANCE_FROM_BUF(bp));
11420 if (un == NULL) {
11421 bioerror(bp, EIO);
11422 bp->b_resid = bp->b_bcount;
11423 biodone(bp);
11424 return (0);
11425 }
11426
11427 /* As was done in the past, fail new cmds. if state is dumping. */
11428 if (un->un_state == SD_STATE_DUMPING) {
11429 bioerror(bp, ENXIO);
11430 bp->b_resid = bp->b_bcount;
11431 biodone(bp);
11432 return (0);
11433 }
11434
11435 ASSERT(!mutex_owned(SD_MUTEX(un)));
11436
11437 /*
11438 * Commands may sneak in while we released the mutex in
11439 * DDI_SUSPEND, we should block new commands. However, old
11440 * commands that are still in the driver at this point should
11441 * still be allowed to drain.
11442 */
11443 mutex_enter(SD_MUTEX(un));
11444 /*
11445 * Must wait here if either the device is suspended or
11446 * if it's power level is changing.
11447 */
11448 while ((un->un_state == SD_STATE_SUSPENDED) ||
11449 (un->un_state == SD_STATE_PM_CHANGING)) {
11450 cv_wait(&un->un_suspend_cv, SD_MUTEX(un));
11451 }
11452
11453 un->un_ncmds_in_driver++;
11454
11455 /*
11456 * atapi: Since we are running the CD for now in PIO mode we need to
11457 * call bp_mapin here to avoid bp_mapin called interrupt context under
11458 * the HBA's init_pkt routine.
11459 */
11460 if (un->un_f_cfg_is_atapi == TRUE) {
11461 mutex_exit(SD_MUTEX(un));
11462 bp_mapin(bp);
11463 mutex_enter(SD_MUTEX(un));
11464 }
11465 SD_INFO(SD_LOG_IO, un, "sdstrategy: un_ncmds_in_driver = %ld\n",
11466 un->un_ncmds_in_driver);
11467
11468 if (bp->b_flags & B_WRITE)
11469 un->un_f_sync_cache_required = TRUE;
11470
11471 mutex_exit(SD_MUTEX(un));
11472
11473 /*
11474 * This will (eventually) allocate the sd_xbuf area and
11475 * call sd_xbuf_strategy(). We just want to return the
11476 * result of ddi_xbuf_qstrategy so that we have an opt-
11477 * imized tail call which saves us a stack frame.
11478 */
11479 return (ddi_xbuf_qstrategy(bp, un->un_xbuf_attr));
11480 }
11481
11482
11483 /*
11484 * Function: sd_xbuf_strategy
11485 *
11486 * Description: Function for initiating IO operations via the
11487 * ddi_xbuf_qstrategy() mechanism.
11488 *
11489 * Context: Kernel thread context.
11490 */
11491
11492 static void
11493 sd_xbuf_strategy(struct buf *bp, ddi_xbuf_t xp, void *arg)
11494 {
11495 struct sd_lun *un = arg;
11496
11497 ASSERT(bp != NULL);
11498 ASSERT(xp != NULL);
11499 ASSERT(un != NULL);
11500 ASSERT(!mutex_owned(SD_MUTEX(un)));
11501
11502 /*
11503 * Initialize the fields in the xbuf and save a pointer to the
11504 * xbuf in bp->b_private.
11505 */
11506 sd_xbuf_init(un, bp, xp, SD_CHAIN_BUFIO, NULL);
11507
11508 /* Send the buf down the iostart chain */
11509 SD_BEGIN_IOSTART(((struct sd_xbuf *)xp)->xb_chain_iostart, un, bp);
11510 }
11511
11512
11513 /*
11514 * Function: sd_xbuf_init
11515 *
11516 * Description: Prepare the given sd_xbuf struct for use.
11517 *
11518 * Arguments: un - ptr to softstate
11519 * bp - ptr to associated buf(9S)
11520 * xp - ptr to associated sd_xbuf
11521 * chain_type - IO chain type to use:
11522 * SD_CHAIN_NULL
11523 * SD_CHAIN_BUFIO
11524 * SD_CHAIN_USCSI
11525 * SD_CHAIN_DIRECT
11526 * SD_CHAIN_DIRECT_PRIORITY
11527 * pktinfop - ptr to private data struct for scsi_pkt(9S)
11528 * initialization; may be NULL if none.
11529 *
11530 * Context: Kernel thread context
11531 */
11532
11533 static void
11534 sd_xbuf_init(struct sd_lun *un, struct buf *bp, struct sd_xbuf *xp,
11535 uchar_t chain_type, void *pktinfop)
11536 {
11537 int index;
11538
11539 ASSERT(un != NULL);
11540 ASSERT(bp != NULL);
11541 ASSERT(xp != NULL);
11542
11543 SD_INFO(SD_LOG_IO, un, "sd_xbuf_init: buf:0x%p chain type:0x%x\n",
11544 bp, chain_type);
11545
11546 xp->xb_un = un;
11547 xp->xb_pktp = NULL;
11548 xp->xb_pktinfo = pktinfop;
11549 xp->xb_private = bp->b_private;
11550 xp->xb_blkno = (daddr_t)bp->b_blkno;
11551
11552 /*
11553 * Set up the iostart and iodone chain indexes in the xbuf, based
11554 * upon the specified chain type to use.
11555 */
11556 switch (chain_type) {
11557 case SD_CHAIN_NULL:
11558 /*
11559 * Fall thru to just use the values for the buf type, even
11560 * tho for the NULL chain these values will never be used.
11561 */
11562 /* FALLTHRU */
11563 case SD_CHAIN_BUFIO:
11564 index = un->un_buf_chain_type;
11565 if ((!un->un_f_has_removable_media) &&
11566 (un->un_tgt_blocksize != 0) &&
11567 (un->un_tgt_blocksize != DEV_BSIZE ||
11568 un->un_f_enable_rmw)) {
11569 int secmask = 0, blknomask = 0;
11570 if (un->un_f_enable_rmw) {
11571 blknomask =
11572 (un->un_phy_blocksize / DEV_BSIZE) - 1;
11573 secmask = un->un_phy_blocksize - 1;
11574 } else {
11575 blknomask =
11576 (un->un_tgt_blocksize / DEV_BSIZE) - 1;
11577 secmask = un->un_tgt_blocksize - 1;
11578 }
11579
11580 if ((bp->b_lblkno & (blknomask)) ||
11581 (bp->b_bcount & (secmask))) {
11582 if ((un->un_f_rmw_type !=
11583 SD_RMW_TYPE_RETURN_ERROR) ||
11584 un->un_f_enable_rmw) {
11585 if (un->un_f_pm_is_enabled == FALSE)
11586 index =
11587 SD_CHAIN_INFO_MSS_DSK_NO_PM;
11588 else
11589 index =
11590 SD_CHAIN_INFO_MSS_DISK;
11591 }
11592 }
11593 }
11594 break;
11595 case SD_CHAIN_USCSI:
11596 index = un->un_uscsi_chain_type;
11597 break;
11598 case SD_CHAIN_DIRECT:
11599 index = un->un_direct_chain_type;
11600 break;
11601 case SD_CHAIN_DIRECT_PRIORITY:
11602 index = un->un_priority_chain_type;
11603 break;
11604 default:
11605 /* We're really broken if we ever get here... */
11606 panic("sd_xbuf_init: illegal chain type!");
11607 /*NOTREACHED*/
11608 }
11609
11610 xp->xb_chain_iostart = sd_chain_index_map[index].sci_iostart_index;
11611 xp->xb_chain_iodone = sd_chain_index_map[index].sci_iodone_index;
11612
11613 /*
11614 * It might be a bit easier to simply bzero the entire xbuf above,
11615 * but it turns out that since we init a fair number of members anyway,
11616 * we save a fair number cycles by doing explicit assignment of zero.
11617 */
11618 xp->xb_pkt_flags = 0;
11619 xp->xb_dma_resid = 0;
11620 xp->xb_retry_count = 0;
11621 xp->xb_victim_retry_count = 0;
11622 xp->xb_ua_retry_count = 0;
11623 xp->xb_nr_retry_count = 0;
11624 xp->xb_sense_bp = NULL;
11625 xp->xb_sense_status = 0;
11626 xp->xb_sense_state = 0;
11627 xp->xb_sense_resid = 0;
11628 xp->xb_ena = 0;
11629
11630 bp->b_private = xp;
11631 bp->b_flags &= ~(B_DONE | B_ERROR);
11632 bp->b_resid = 0;
11633 bp->av_forw = NULL;
11634 bp->av_back = NULL;
11635 bioerror(bp, 0);
11636
11637 SD_INFO(SD_LOG_IO, un, "sd_xbuf_init: done.\n");
11638 }
11639
11640
11641 /*
11642 * Function: sd_uscsi_strategy
11643 *
11644 * Description: Wrapper for calling into the USCSI chain via physio(9F)
11645 *
11646 * Arguments: bp - buf struct ptr
11647 *
11648 * Return Code: Always returns 0
11649 *
11650 * Context: Kernel thread context
11651 */
11652
11653 static int
11654 sd_uscsi_strategy(struct buf *bp)
11655 {
11656 struct sd_lun *un;
11657 struct sd_uscsi_info *uip;
11658 struct sd_xbuf *xp;
11659 uchar_t chain_type;
11660 uchar_t cmd;
11661
11662 ASSERT(bp != NULL);
11663
11664 un = ddi_get_soft_state(sd_state, SD_GET_INSTANCE_FROM_BUF(bp));
11665 if (un == NULL) {
11666 bioerror(bp, EIO);
11667 bp->b_resid = bp->b_bcount;
11668 biodone(bp);
11669 return (0);
11670 }
11671
11672 ASSERT(!mutex_owned(SD_MUTEX(un)));
11673
11674 SD_TRACE(SD_LOG_IO, un, "sd_uscsi_strategy: entry: buf:0x%p\n", bp);
11675
11676 /*
11677 * A pointer to a struct sd_uscsi_info is expected in bp->b_private
11678 */
11679 ASSERT(bp->b_private != NULL);
11680 uip = (struct sd_uscsi_info *)bp->b_private;
11681 cmd = ((struct uscsi_cmd *)(uip->ui_cmdp))->uscsi_cdb[0];
11682
11683 mutex_enter(SD_MUTEX(un));
11684 /*
11685 * atapi: Since we are running the CD for now in PIO mode we need to
11686 * call bp_mapin here to avoid bp_mapin called interrupt context under
11687 * the HBA's init_pkt routine.
11688 */
11689 if (un->un_f_cfg_is_atapi == TRUE) {
11690 mutex_exit(SD_MUTEX(un));
11691 bp_mapin(bp);
11692 mutex_enter(SD_MUTEX(un));
11693 }
11694 un->un_ncmds_in_driver++;
11695 SD_INFO(SD_LOG_IO, un, "sd_uscsi_strategy: un_ncmds_in_driver = %ld\n",
11696 un->un_ncmds_in_driver);
11697
11698 if ((bp->b_flags & B_WRITE) && (bp->b_bcount != 0) &&
11699 (cmd != SCMD_MODE_SELECT) && (cmd != SCMD_MODE_SELECT_G1))
11700 un->un_f_sync_cache_required = TRUE;
11701
11702 mutex_exit(SD_MUTEX(un));
11703
11704 switch (uip->ui_flags) {
11705 case SD_PATH_DIRECT:
11706 chain_type = SD_CHAIN_DIRECT;
11707 break;
11708 case SD_PATH_DIRECT_PRIORITY:
11709 chain_type = SD_CHAIN_DIRECT_PRIORITY;
11710 break;
11711 default:
11712 chain_type = SD_CHAIN_USCSI;
11713 break;
11714 }
11715
11716 /*
11717 * We may allocate extra buf for external USCSI commands. If the
11718 * application asks for bigger than 20-byte sense data via USCSI,
11719 * SCSA layer will allocate 252 bytes sense buf for that command.
11720 */
11721 if (((struct uscsi_cmd *)(uip->ui_cmdp))->uscsi_rqlen >
11722 SENSE_LENGTH) {
11723 xp = kmem_zalloc(sizeof (struct sd_xbuf) - SENSE_LENGTH +
11724 MAX_SENSE_LENGTH, KM_SLEEP);
11725 } else {
11726 xp = kmem_zalloc(sizeof (struct sd_xbuf), KM_SLEEP);
11727 }
11728
11729 sd_xbuf_init(un, bp, xp, chain_type, uip->ui_cmdp);
11730
11731 /* Use the index obtained within xbuf_init */
11732 SD_BEGIN_IOSTART(xp->xb_chain_iostart, un, bp);
11733
11734 SD_TRACE(SD_LOG_IO, un, "sd_uscsi_strategy: exit: buf:0x%p\n", bp);
11735
11736 return (0);
11737 }
11738
11739 /*
11740 * Function: sd_send_scsi_cmd
11741 *
11742 * Description: Runs a USCSI command for user (when called thru sdioctl),
11743 * or for the driver
11744 *
11745 * Arguments: dev - the dev_t for the device
11746 * incmd - ptr to a valid uscsi_cmd struct
11747 * flag - bit flag, indicating open settings, 32/64 bit type
11748 * dataspace - UIO_USERSPACE or UIO_SYSSPACE
11749 * path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and
11750 * the normal command waitq, or SD_PATH_DIRECT_PRIORITY
11751 * to use the USCSI "direct" chain and bypass the normal
11752 * command waitq.
11753 *
11754 * Return Code: 0 - successful completion of the given command
11755 * EIO - scsi_uscsi_handle_command() failed
11756 * ENXIO - soft state not found for specified dev
11757 * EINVAL
11758 * EFAULT - copyin/copyout error
11759 * return code of scsi_uscsi_handle_command():
11760 * EIO
11761 * ENXIO
11762 * EACCES
11763 *
11764 * Context: Waits for command to complete. Can sleep.
11765 */
11766
11767 static int
11768 sd_send_scsi_cmd(dev_t dev, struct uscsi_cmd *incmd, int flag,
11769 enum uio_seg dataspace, int path_flag)
11770 {
11771 struct sd_lun *un;
11772 sd_ssc_t *ssc;
11773 int rval;
11774
11775 un = ddi_get_soft_state(sd_state, SDUNIT(dev));
11776 if (un == NULL) {
11777 return (ENXIO);
11778 }
11779
11780 /*
11781 * Using sd_ssc_send to handle uscsi cmd
11782 */
11783 ssc = sd_ssc_init(un);
11784 rval = sd_ssc_send(ssc, incmd, flag, dataspace, path_flag);
11785 sd_ssc_fini(ssc);
11786
11787 return (rval);
11788 }
11789
11790 /*
11791 * Function: sd_ssc_init
11792 *
11793 * Description: Uscsi end-user call this function to initialize necessary
11794 * fields, such as uscsi_cmd and sd_uscsi_info struct.
11795 *
11796 * The return value of sd_send_scsi_cmd will be treated as a
11797 * fault in various conditions. Even it is not Zero, some
11798 * callers may ignore the return value. That is to say, we can
11799 * not make an accurate assessment in sdintr, since if a
11800 * command is failed in sdintr it does not mean the caller of
11801 * sd_send_scsi_cmd will treat it as a real failure.
11802 *
11803 * To avoid printing too many error logs for a failed uscsi
11804 * packet that the caller may not treat it as a failure, the
11805 * sd will keep silent for handling all uscsi commands.
11806 *
11807 * During detach->attach and attach-open, for some types of
11808 * problems, the driver should be providing information about
11809 * the problem encountered. Device use USCSI_SILENT, which
11810 * suppresses all driver information. The result is that no
11811 * information about the problem is available. Being
11812 * completely silent during this time is inappropriate. The
11813 * driver needs a more selective filter than USCSI_SILENT, so
11814 * that information related to faults is provided.
11815 *
11816 * To make the accurate accessment, the caller of
11817 * sd_send_scsi_USCSI_CMD should take the ownership and
11818 * get necessary information to print error messages.
11819 *
11820 * If we want to print necessary info of uscsi command, we need to
11821 * keep the uscsi_cmd and sd_uscsi_info till we can make the
11822 * assessment. We use sd_ssc_init to alloc necessary
11823 * structs for sending an uscsi command and we are also
11824 * responsible for free the memory by calling
11825 * sd_ssc_fini.
11826 *
11827 * The calling secquences will look like:
11828 * sd_ssc_init->
11829 *
11830 * ...
11831 *
11832 * sd_send_scsi_USCSI_CMD->
11833 * sd_ssc_send-> - - - sdintr
11834 * ...
11835 *
11836 * if we think the return value should be treated as a
11837 * failure, we make the accessment here and print out
11838 * necessary by retrieving uscsi_cmd and sd_uscsi_info'
11839 *
11840 * ...
11841 *
11842 * sd_ssc_fini
11843 *
11844 *
11845 * Arguments: un - pointer to driver soft state (unit) structure for this
11846 * target.
11847 *
11848 * Return code: sd_ssc_t - pointer to allocated sd_ssc_t struct, it contains
11849 * uscsi_cmd and sd_uscsi_info.
11850 * NULL - if can not alloc memory for sd_ssc_t struct
11851 *
11852 * Context: Kernel Thread.
11853 */
11854 static sd_ssc_t *
11855 sd_ssc_init(struct sd_lun *un)
11856 {
11857 sd_ssc_t *ssc;
11858 struct uscsi_cmd *ucmdp;
11859 struct sd_uscsi_info *uip;
11860
11861 ASSERT(un != NULL);
11862 ASSERT(!mutex_owned(SD_MUTEX(un)));
11863
11864 /*
11865 * Allocate sd_ssc_t structure
11866 */
11867 ssc = kmem_zalloc(sizeof (sd_ssc_t), KM_SLEEP);
11868
11869 /*
11870 * Allocate uscsi_cmd by calling scsi_uscsi_alloc common routine
11871 */
11872 ucmdp = scsi_uscsi_alloc();
11873
11874 /*
11875 * Allocate sd_uscsi_info structure
11876 */
11877 uip = kmem_zalloc(sizeof (struct sd_uscsi_info), KM_SLEEP);
11878
11879 ssc->ssc_uscsi_cmd = ucmdp;
11880 ssc->ssc_uscsi_info = uip;
11881 ssc->ssc_un = un;
11882
11883 return (ssc);
11884 }
11885
11886 /*
11887 * Function: sd_ssc_fini
11888 *
11889 * Description: To free sd_ssc_t and it's hanging off
11890 *
11891 * Arguments: ssc - struct pointer of sd_ssc_t.
11892 */
11893 static void
11894 sd_ssc_fini(sd_ssc_t *ssc)
11895 {
11896 scsi_uscsi_free(ssc->ssc_uscsi_cmd);
11897
11898 if (ssc->ssc_uscsi_info != NULL) {
11899 kmem_free(ssc->ssc_uscsi_info, sizeof (struct sd_uscsi_info));
11900 ssc->ssc_uscsi_info = NULL;
11901 }
11902
11903 kmem_free(ssc, sizeof (sd_ssc_t));
11904 ssc = NULL;
11905 }
11906
11907 /*
11908 * Function: sd_ssc_send
11909 *
11910 * Description: Runs a USCSI command for user when called through sdioctl,
11911 * or for the driver.
11912 *
11913 * Arguments: ssc - the struct of sd_ssc_t will bring uscsi_cmd and
11914 * sd_uscsi_info in.
11915 * incmd - ptr to a valid uscsi_cmd struct
11916 * flag - bit flag, indicating open settings, 32/64 bit type
11917 * dataspace - UIO_USERSPACE or UIO_SYSSPACE
11918 * path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and
11919 * the normal command waitq, or SD_PATH_DIRECT_PRIORITY
11920 * to use the USCSI "direct" chain and bypass the normal
11921 * command waitq.
11922 *
11923 * Return Code: 0 - successful completion of the given command
11924 * EIO - scsi_uscsi_handle_command() failed
11925 * ENXIO - soft state not found for specified dev
11926 * ECANCELED - command cancelled due to low power
11927 * EINVAL
11928 * EFAULT - copyin/copyout error
11929 * return code of scsi_uscsi_handle_command():
11930 * EIO
11931 * ENXIO
11932 * EACCES
11933 *
11934 * Context: Kernel Thread;
11935 * Waits for command to complete. Can sleep.
11936 */
11937 static int
11938 sd_ssc_send(sd_ssc_t *ssc, struct uscsi_cmd *incmd, int flag,
11939 enum uio_seg dataspace, int path_flag)
11940 {
11941 struct sd_uscsi_info *uip;
11942 struct uscsi_cmd *uscmd;
11943 struct sd_lun *un;
11944 dev_t dev;
11945
11946 int format = 0;
11947 int rval;
11948
11949 ASSERT(ssc != NULL);
11950 un = ssc->ssc_un;
11951 ASSERT(un != NULL);
11952 uscmd = ssc->ssc_uscsi_cmd;
11953 ASSERT(uscmd != NULL);
11954 ASSERT(!mutex_owned(SD_MUTEX(un)));
11955 if (ssc->ssc_flags & SSC_FLAGS_NEED_ASSESSMENT) {
11956 /*
11957 * If enter here, it indicates that the previous uscsi
11958 * command has not been processed by sd_ssc_assessment.
11959 * This is violating our rules of FMA telemetry processing.
11960 * We should print out this message and the last undisposed
11961 * uscsi command.
11962 */
11963 if (uscmd->uscsi_cdb != NULL) {
11964 SD_INFO(SD_LOG_SDTEST, un,
11965 "sd_ssc_send is missing the alternative "
11966 "sd_ssc_assessment when running command 0x%x.\n",
11967 uscmd->uscsi_cdb[0]);
11968 }
11969 /*
11970 * Set the ssc_flags to SSC_FLAGS_UNKNOWN, which should be
11971 * the initial status.
11972 */
11973 ssc->ssc_flags = SSC_FLAGS_UNKNOWN;
11974 }
11975
11976 /*
11977 * We need to make sure sd_ssc_send will have sd_ssc_assessment
11978 * followed to avoid missing FMA telemetries.
11979 */
11980 ssc->ssc_flags |= SSC_FLAGS_NEED_ASSESSMENT;
11981
11982 /*
11983 * if USCSI_PMFAILFAST is set and un is in low power, fail the
11984 * command immediately.
11985 */
11986 mutex_enter(SD_MUTEX(un));
11987 mutex_enter(&un->un_pm_mutex);
11988 if ((uscmd->uscsi_flags & USCSI_PMFAILFAST) &&
11989 SD_DEVICE_IS_IN_LOW_POWER(un)) {
11990 SD_TRACE(SD_LOG_IO, un, "sd_ssc_send:"
11991 "un:0x%p is in low power\n", un);
11992 mutex_exit(&un->un_pm_mutex);
11993 mutex_exit(SD_MUTEX(un));
11994 return (ECANCELED);
11995 }
11996 mutex_exit(&un->un_pm_mutex);
11997 mutex_exit(SD_MUTEX(un));
11998
11999 #ifdef SDDEBUG
12000 switch (dataspace) {
12001 case UIO_USERSPACE:
12002 SD_TRACE(SD_LOG_IO, un,
12003 "sd_ssc_send: entry: un:0x%p UIO_USERSPACE\n", un);
12004 break;
12005 case UIO_SYSSPACE:
12006 SD_TRACE(SD_LOG_IO, un,
12007 "sd_ssc_send: entry: un:0x%p UIO_SYSSPACE\n", un);
12008 break;
12009 default:
12010 SD_TRACE(SD_LOG_IO, un,
12011 "sd_ssc_send: entry: un:0x%p UNEXPECTED SPACE\n", un);
12012 break;
12013 }
12014 #endif
12015
12016 rval = scsi_uscsi_copyin((intptr_t)incmd, flag,
12017 SD_ADDRESS(un), &uscmd);
12018 if (rval != 0) {
12019 SD_TRACE(SD_LOG_IO, un, "sd_sense_scsi_cmd: "
12020 "scsi_uscsi_alloc_and_copyin failed\n", un);
12021 return (rval);
12022 }
12023
12024 if ((uscmd->uscsi_cdb != NULL) &&
12025 (uscmd->uscsi_cdb[0] == SCMD_FORMAT)) {
12026 mutex_enter(SD_MUTEX(un));
12027 un->un_f_format_in_progress = TRUE;
12028 mutex_exit(SD_MUTEX(un));
12029 format = 1;
12030 }
12031
12032 /*
12033 * Allocate an sd_uscsi_info struct and fill it with the info
12034 * needed by sd_initpkt_for_uscsi(). Then put the pointer into
12035 * b_private in the buf for sd_initpkt_for_uscsi(). Note that
12036 * since we allocate the buf here in this function, we do not
12037 * need to preserve the prior contents of b_private.
12038 * The sd_uscsi_info struct is also used by sd_uscsi_strategy()
12039 */
12040 uip = ssc->ssc_uscsi_info;
12041 uip->ui_flags = path_flag;
12042 uip->ui_cmdp = uscmd;
12043
12044 /*
12045 * Commands sent with priority are intended for error recovery
12046 * situations, and do not have retries performed.
12047 */
12048 if (path_flag == SD_PATH_DIRECT_PRIORITY) {
12049 uscmd->uscsi_flags |= USCSI_DIAGNOSE;
12050 }
12051 uscmd->uscsi_flags &= ~USCSI_NOINTR;
12052
12053 dev = SD_GET_DEV(un);
12054 rval = scsi_uscsi_handle_cmd(dev, dataspace, uscmd,
12055 sd_uscsi_strategy, NULL, uip);
12056
12057 /*
12058 * mark ssc_flags right after handle_cmd to make sure
12059 * the uscsi has been sent
12060 */
12061 ssc->ssc_flags |= SSC_FLAGS_CMD_ISSUED;
12062
12063 #ifdef SDDEBUG
12064 SD_INFO(SD_LOG_IO, un, "sd_ssc_send: "
12065 "uscsi_status: 0x%02x uscsi_resid:0x%x\n",
12066 uscmd->uscsi_status, uscmd->uscsi_resid);
12067 if (uscmd->uscsi_bufaddr != NULL) {
12068 SD_INFO(SD_LOG_IO, un, "sd_ssc_send: "
12069 "uscmd->uscsi_bufaddr: 0x%p uscmd->uscsi_buflen:%d\n",
12070 uscmd->uscsi_bufaddr, uscmd->uscsi_buflen);
12071 if (dataspace == UIO_SYSSPACE) {
12072 SD_DUMP_MEMORY(un, SD_LOG_IO,
12073 "data", (uchar_t *)uscmd->uscsi_bufaddr,
12074 uscmd->uscsi_buflen, SD_LOG_HEX);
12075 }
12076 }
12077 #endif
12078
12079 if (format == 1) {
12080 mutex_enter(SD_MUTEX(un));
12081 un->un_f_format_in_progress = FALSE;
12082 mutex_exit(SD_MUTEX(un));
12083 }
12084
12085 (void) scsi_uscsi_copyout((intptr_t)incmd, uscmd);
12086
12087 return (rval);
12088 }
12089
12090 /*
12091 * Function: sd_ssc_print
12092 *
12093 * Description: Print information available to the console.
12094 *
12095 * Arguments: ssc - the struct of sd_ssc_t will bring uscsi_cmd and
12096 * sd_uscsi_info in.
12097 * sd_severity - log level.
12098 * Context: Kernel thread or interrupt context.
12099 */
12100 static void
12101 sd_ssc_print(sd_ssc_t *ssc, int sd_severity)
12102 {
12103 struct uscsi_cmd *ucmdp;
12104 struct scsi_device *devp;
12105 dev_info_t *devinfo;
12106 uchar_t *sensep;
12107 int senlen;
12108 union scsi_cdb *cdbp;
12109 uchar_t com;
12110 extern struct scsi_key_strings scsi_cmds[];
12111
12112 ASSERT(ssc != NULL);
12113 ASSERT(ssc->ssc_un != NULL);
12114
12115 if (SD_FM_LOG(ssc->ssc_un) != SD_FM_LOG_EREPORT)
12116 return;
12117 ucmdp = ssc->ssc_uscsi_cmd;
12118 devp = SD_SCSI_DEVP(ssc->ssc_un);
12119 devinfo = SD_DEVINFO(ssc->ssc_un);
12120 ASSERT(ucmdp != NULL);
12121 ASSERT(devp != NULL);
12122 ASSERT(devinfo != NULL);
12123 sensep = (uint8_t *)ucmdp->uscsi_rqbuf;
12124 senlen = ucmdp->uscsi_rqlen - ucmdp->uscsi_rqresid;
12125 cdbp = (union scsi_cdb *)ucmdp->uscsi_cdb;
12126
12127 /* In certain case (like DOORLOCK), the cdb could be NULL. */
12128 if (cdbp == NULL)
12129 return;
12130 /* We don't print log if no sense data available. */
12131 if (senlen == 0)
12132 sensep = NULL;
12133 com = cdbp->scc_cmd;
12134 scsi_generic_errmsg(devp, sd_label, sd_severity, 0, 0, com,
12135 scsi_cmds, sensep, ssc->ssc_un->un_additional_codes, NULL);
12136 }
12137
12138 /*
12139 * Function: sd_ssc_assessment
12140 *
12141 * Description: We use this function to make an assessment at the point
12142 * where SD driver may encounter a potential error.
12143 *
12144 * Arguments: ssc - the struct of sd_ssc_t will bring uscsi_cmd and
12145 * sd_uscsi_info in.
12146 * tp_assess - a hint of strategy for ereport posting.
12147 * Possible values of tp_assess include:
12148 * SD_FMT_IGNORE - we don't post any ereport because we're
12149 * sure that it is ok to ignore the underlying problems.
12150 * SD_FMT_IGNORE_COMPROMISE - we don't post any ereport for now
12151 * but it might be not correct to ignore the underlying hardware
12152 * error.
12153 * SD_FMT_STATUS_CHECK - we will post an ereport with the
12154 * payload driver-assessment of value "fail" or
12155 * "fatal"(depending on what information we have here). This
12156 * assessment value is usually set when SD driver think there
12157 * is a potential error occurred(Typically, when return value
12158 * of the SCSI command is EIO).
12159 * SD_FMT_STANDARD - we will post an ereport with the payload
12160 * driver-assessment of value "info". This assessment value is
12161 * set when the SCSI command returned successfully and with
12162 * sense data sent back.
12163 *
12164 * Context: Kernel thread.
12165 */
12166 static void
12167 sd_ssc_assessment(sd_ssc_t *ssc, enum sd_type_assessment tp_assess)
12168 {
12169 int senlen = 0;
12170 struct uscsi_cmd *ucmdp = NULL;
12171 struct sd_lun *un;
12172
12173 ASSERT(ssc != NULL);
12174 un = ssc->ssc_un;
12175 ASSERT(un != NULL);
12176 ucmdp = ssc->ssc_uscsi_cmd;
12177 ASSERT(ucmdp != NULL);
12178
12179 if (ssc->ssc_flags & SSC_FLAGS_NEED_ASSESSMENT) {
12180 ssc->ssc_flags &= ~SSC_FLAGS_NEED_ASSESSMENT;
12181 } else {
12182 /*
12183 * If enter here, it indicates that we have a wrong
12184 * calling sequence of sd_ssc_send and sd_ssc_assessment,
12185 * both of which should be called in a pair in case of
12186 * loss of FMA telemetries.
12187 */
12188 if (ucmdp->uscsi_cdb != NULL) {
12189 SD_INFO(SD_LOG_SDTEST, un,
12190 "sd_ssc_assessment is missing the "
12191 "alternative sd_ssc_send when running 0x%x, "
12192 "or there are superfluous sd_ssc_assessment for "
12193 "the same sd_ssc_send.\n",
12194 ucmdp->uscsi_cdb[0]);
12195 }
12196 /*
12197 * Set the ssc_flags to the initial value to avoid passing
12198 * down dirty flags to the following sd_ssc_send function.
12199 */
12200 ssc->ssc_flags = SSC_FLAGS_UNKNOWN;
12201 return;
12202 }
12203
12204 /*
12205 * Only handle an issued command which is waiting for assessment.
12206 * A command which is not issued will not have
12207 * SSC_FLAGS_INVALID_DATA set, so it'ok we just return here.
12208 */
12209 if (!(ssc->ssc_flags & SSC_FLAGS_CMD_ISSUED)) {
12210 sd_ssc_print(ssc, SCSI_ERR_INFO);
12211 return;
12212 } else {
12213 /*
12214 * For an issued command, we should clear this flag in
12215 * order to make the sd_ssc_t structure be used off
12216 * multiple uscsi commands.
12217 */
12218 ssc->ssc_flags &= ~SSC_FLAGS_CMD_ISSUED;
12219 }
12220
12221 /*
12222 * We will not deal with non-retryable(flag USCSI_DIAGNOSE set)
12223 * commands here. And we should clear the ssc_flags before return.
12224 */
12225 if (ucmdp->uscsi_flags & USCSI_DIAGNOSE) {
12226 ssc->ssc_flags = SSC_FLAGS_UNKNOWN;
12227 return;
12228 }
12229
12230 switch (tp_assess) {
12231 case SD_FMT_IGNORE:
12232 case SD_FMT_IGNORE_COMPROMISE:
12233 break;
12234 case SD_FMT_STATUS_CHECK:
12235 /*
12236 * For a failed command(including the succeeded command
12237 * with invalid data sent back).
12238 */
12239 sd_ssc_post(ssc, SD_FM_DRV_FATAL);
12240 break;
12241 case SD_FMT_STANDARD:
12242 /*
12243 * Always for the succeeded commands probably with sense
12244 * data sent back.
12245 * Limitation:
12246 * We can only handle a succeeded command with sense
12247 * data sent back when auto-request-sense is enabled.
12248 */
12249 senlen = ssc->ssc_uscsi_cmd->uscsi_rqlen -
12250 ssc->ssc_uscsi_cmd->uscsi_rqresid;
12251 if ((ssc->ssc_uscsi_info->ui_pkt_state & STATE_ARQ_DONE) &&
12252 (un->un_f_arq_enabled == TRUE) &&
12253 senlen > 0 &&
12254 ssc->ssc_uscsi_cmd->uscsi_rqbuf != NULL) {
12255 sd_ssc_post(ssc, SD_FM_DRV_NOTICE);
12256 }
12257 break;
12258 default:
12259 /*
12260 * Should not have other type of assessment.
12261 */
12262 scsi_log(SD_DEVINFO(un), sd_label, CE_CONT,
12263 "sd_ssc_assessment got wrong "
12264 "sd_type_assessment %d.\n", tp_assess);
12265 break;
12266 }
12267 /*
12268 * Clear up the ssc_flags before return.
12269 */
12270 ssc->ssc_flags = SSC_FLAGS_UNKNOWN;
12271 }
12272
12273 /*
12274 * Function: sd_ssc_post
12275 *
12276 * Description: 1. read the driver property to get fm-scsi-log flag.
12277 * 2. print log if fm_log_capable is non-zero.
12278 * 3. call sd_ssc_ereport_post to post ereport if possible.
12279 *
12280 * Context: May be called from kernel thread or interrupt context.
12281 */
12282 static void
12283 sd_ssc_post(sd_ssc_t *ssc, enum sd_driver_assessment sd_assess)
12284 {
12285 struct sd_lun *un;
12286 int sd_severity;
12287
12288 ASSERT(ssc != NULL);
12289 un = ssc->ssc_un;
12290 ASSERT(un != NULL);
12291
12292 /*
12293 * We may enter here from sd_ssc_assessment(for USCSI command) or
12294 * by directly called from sdintr context.
12295 * We don't handle a non-disk drive(CD-ROM, removable media).
12296 * Clear the ssc_flags before return in case we've set
12297 * SSC_FLAGS_INVALID_XXX which should be skipped for a non-disk
12298 * driver.
12299 */
12300 if (ISCD(un) || un->un_f_has_removable_media) {
12301 ssc->ssc_flags = SSC_FLAGS_UNKNOWN;
12302 return;
12303 }
12304
12305 switch (sd_assess) {
12306 case SD_FM_DRV_FATAL:
12307 sd_severity = SCSI_ERR_FATAL;
12308 break;
12309 case SD_FM_DRV_RECOVERY:
12310 sd_severity = SCSI_ERR_RECOVERED;
12311 break;
12312 case SD_FM_DRV_RETRY:
12313 sd_severity = SCSI_ERR_RETRYABLE;
12314 break;
12315 case SD_FM_DRV_NOTICE:
12316 sd_severity = SCSI_ERR_INFO;
12317 break;
12318 default:
12319 sd_severity = SCSI_ERR_UNKNOWN;
12320 }
12321 /* print log */
12322 sd_ssc_print(ssc, sd_severity);
12323
12324 /* always post ereport */
12325 sd_ssc_ereport_post(ssc, sd_assess);
12326 }
12327
12328 /*
12329 * Function: sd_ssc_set_info
12330 *
12331 * Description: Mark ssc_flags and set ssc_info which would be the
12332 * payload of uderr ereport. This function will cause
12333 * sd_ssc_ereport_post to post uderr ereport only.
12334 * Besides, when ssc_flags == SSC_FLAGS_INVALID_DATA(USCSI),
12335 * the function will also call SD_ERROR or scsi_log for a
12336 * CDROM/removable-media/DDI_FM_NOT_CAPABLE device.
12337 *
12338 * Arguments: ssc - the struct of sd_ssc_t will bring uscsi_cmd and
12339 * sd_uscsi_info in.
12340 * ssc_flags - indicate the sub-category of a uderr.
12341 * comp - this argument is meaningful only when
12342 * ssc_flags == SSC_FLAGS_INVALID_DATA, and its possible
12343 * values include:
12344 * > 0, SD_ERROR is used with comp as the driver logging
12345 * component;
12346 * = 0, scsi-log is used to log error telemetries;
12347 * < 0, no log available for this telemetry.
12348 *
12349 * Context: Kernel thread or interrupt context
12350 */
12351 static void
12352 sd_ssc_set_info(sd_ssc_t *ssc, int ssc_flags, uint_t comp, const char *fmt, ...)
12353 {
12354 va_list ap;
12355
12356 ASSERT(ssc != NULL);
12357 ASSERT(ssc->ssc_un != NULL);
12358
12359 ssc->ssc_flags |= ssc_flags;
12360 va_start(ap, fmt);
12361 (void) vsnprintf(ssc->ssc_info, sizeof (ssc->ssc_info), fmt, ap);
12362 va_end(ap);
12363
12364 /*
12365 * If SSC_FLAGS_INVALID_DATA is set, it should be a uscsi command
12366 * with invalid data sent back. For non-uscsi command, the
12367 * following code will be bypassed.
12368 */
12369 if (ssc_flags & SSC_FLAGS_INVALID_DATA) {
12370 if (SD_FM_LOG(ssc->ssc_un) == SD_FM_LOG_NSUP) {
12371 /*
12372 * If the error belong to certain component and we
12373 * do not want it to show up on the console, we
12374 * will use SD_ERROR, otherwise scsi_log is
12375 * preferred.
12376 */
12377 if (comp > 0) {
12378 SD_ERROR(comp, ssc->ssc_un, ssc->ssc_info);
12379 } else if (comp == 0) {
12380 scsi_log(SD_DEVINFO(ssc->ssc_un), sd_label,
12381 CE_WARN, ssc->ssc_info);
12382 }
12383 }
12384 }
12385 }
12386
12387 /*
12388 * Function: sd_buf_iodone
12389 *
12390 * Description: Frees the sd_xbuf & returns the buf to its originator.
12391 *
12392 * Context: May be called from interrupt context.
12393 */
12394 /* ARGSUSED */
12395 static void
12396 sd_buf_iodone(int index, struct sd_lun *un, struct buf *bp)
12397 {
12398 struct sd_xbuf *xp;
12399
12400 ASSERT(un != NULL);
12401 ASSERT(bp != NULL);
12402 ASSERT(!mutex_owned(SD_MUTEX(un)));
12403
12404 SD_TRACE(SD_LOG_IO_CORE, un, "sd_buf_iodone: entry.\n");
12405
12406 xp = SD_GET_XBUF(bp);
12407 ASSERT(xp != NULL);
12408
12409 /* xbuf is gone after this */
12410 if (ddi_xbuf_done(bp, un->un_xbuf_attr)) {
12411 mutex_enter(SD_MUTEX(un));
12412
12413 /*
12414 * Grab time when the cmd completed.
12415 * This is used for determining if the system has been
12416 * idle long enough to make it idle to the PM framework.
12417 * This is for lowering the overhead, and therefore improving
12418 * performance per I/O operation.
12419 */
12420 un->un_pm_idle_time = gethrtime();
12421
12422 un->un_ncmds_in_driver--;
12423 ASSERT(un->un_ncmds_in_driver >= 0);
12424 SD_INFO(SD_LOG_IO, un,
12425 "sd_buf_iodone: un_ncmds_in_driver = %ld\n",
12426 un->un_ncmds_in_driver);
12427
12428 mutex_exit(SD_MUTEX(un));
12429 }
12430
12431 biodone(bp); /* bp is gone after this */
12432
12433 SD_TRACE(SD_LOG_IO_CORE, un, "sd_buf_iodone: exit.\n");
12434 }
12435
12436
12437 /*
12438 * Function: sd_uscsi_iodone
12439 *
12440 * Description: Frees the sd_xbuf & returns the buf to its originator.
12441 *
12442 * Context: May be called from interrupt context.
12443 */
12444 /* ARGSUSED */
12445 static void
12446 sd_uscsi_iodone(int index, struct sd_lun *un, struct buf *bp)
12447 {
12448 struct sd_xbuf *xp;
12449
12450 ASSERT(un != NULL);
12451 ASSERT(bp != NULL);
12452
12453 xp = SD_GET_XBUF(bp);
12454 ASSERT(xp != NULL);
12455 ASSERT(!mutex_owned(SD_MUTEX(un)));
12456
12457 SD_INFO(SD_LOG_IO, un, "sd_uscsi_iodone: entry.\n");
12458
12459 bp->b_private = xp->xb_private;
12460
12461 mutex_enter(SD_MUTEX(un));
12462
12463 /*
12464 * Grab time when the cmd completed.
12465 * This is used for determining if the system has been
12466 * idle long enough to make it idle to the PM framework.
12467 * This is for lowering the overhead, and therefore improving
12468 * performance per I/O operation.
12469 */
12470 un->un_pm_idle_time = gethrtime();
12471
12472 un->un_ncmds_in_driver--;
12473 ASSERT(un->un_ncmds_in_driver >= 0);
12474 SD_INFO(SD_LOG_IO, un, "sd_uscsi_iodone: un_ncmds_in_driver = %ld\n",
12475 un->un_ncmds_in_driver);
12476
12477 mutex_exit(SD_MUTEX(un));
12478
12479 if (((struct uscsi_cmd *)(xp->xb_pktinfo))->uscsi_rqlen >
12480 SENSE_LENGTH) {
12481 kmem_free(xp, sizeof (struct sd_xbuf) - SENSE_LENGTH +
12482 MAX_SENSE_LENGTH);
12483 } else {
12484 kmem_free(xp, sizeof (struct sd_xbuf));
12485 }
12486
12487 biodone(bp);
12488
12489 SD_INFO(SD_LOG_IO, un, "sd_uscsi_iodone: exit.\n");
12490 }
12491
12492
12493 /*
12494 * Function: sd_mapblockaddr_iostart
12495 *
12496 * Description: Verify request lies within the partition limits for
12497 * the indicated minor device. Issue "overrun" buf if
12498 * request would exceed partition range. Converts
12499 * partition-relative block address to absolute.
12500 *
12501 * Upon exit of this function:
12502 * 1.I/O is aligned
12503 * xp->xb_blkno represents the absolute sector address
12504 * 2.I/O is misaligned
12505 * xp->xb_blkno represents the absolute logical block address
12506 * based on DEV_BSIZE. The logical block address will be
12507 * converted to physical sector address in sd_mapblocksize_\
12508 * iostart.
12509 * 3.I/O is misaligned but is aligned in "overrun" buf
12510 * xp->xb_blkno represents the absolute logical block address
12511 * based on DEV_BSIZE. The logical block address will be
12512 * converted to physical sector address in sd_mapblocksize_\
12513 * iostart. But no RMW will be issued in this case.
12514 *
12515 * Context: Can sleep
12516 *
12517 * Issues: This follows what the old code did, in terms of accessing
12518 * some of the partition info in the unit struct without holding
12519 * the mutext. This is a general issue, if the partition info
12520 * can be altered while IO is in progress... as soon as we send
12521 * a buf, its partitioning can be invalid before it gets to the
12522 * device. Probably the right fix is to move partitioning out
12523 * of the driver entirely.
12524 */
12525
12526 static void
12527 sd_mapblockaddr_iostart(int index, struct sd_lun *un, struct buf *bp)
12528 {
12529 diskaddr_t nblocks; /* #blocks in the given partition */
12530 daddr_t blocknum; /* Block number specified by the buf */
12531 size_t requested_nblocks;
12532 size_t available_nblocks;
12533 int partition;
12534 diskaddr_t partition_offset;
12535 struct sd_xbuf *xp;
12536 int secmask = 0, blknomask = 0;
12537 ushort_t is_aligned = TRUE;
12538
12539 ASSERT(un != NULL);
12540 ASSERT(bp != NULL);
12541 ASSERT(!mutex_owned(SD_MUTEX(un)));
12542
12543 SD_TRACE(SD_LOG_IO_PARTITION, un,
12544 "sd_mapblockaddr_iostart: entry: buf:0x%p\n", bp);
12545
12546 xp = SD_GET_XBUF(bp);
12547 ASSERT(xp != NULL);
12548
12549 /*
12550 * If the geometry is not indicated as valid, attempt to access
12551 * the unit & verify the geometry/label. This can be the case for
12552 * removable-media devices, of if the device was opened in
12553 * NDELAY/NONBLOCK mode.
12554 */
12555 partition = SDPART(bp->b_edev);
12556
12557 if (!SD_IS_VALID_LABEL(un)) {
12558 sd_ssc_t *ssc;
12559 /*
12560 * Initialize sd_ssc_t for internal uscsi commands
12561 * In case of potential porformance issue, we need
12562 * to alloc memory only if there is invalid label
12563 */
12564 ssc = sd_ssc_init(un);
12565
12566 if (sd_ready_and_valid(ssc, partition) != SD_READY_VALID) {
12567 /*
12568 * For removable devices it is possible to start an
12569 * I/O without a media by opening the device in nodelay
12570 * mode. Also for writable CDs there can be many
12571 * scenarios where there is no geometry yet but volume
12572 * manager is trying to issue a read() just because
12573 * it can see TOC on the CD. So do not print a message
12574 * for removables.
12575 */
12576 if (!un->un_f_has_removable_media) {
12577 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
12578 "i/o to invalid geometry\n");
12579 }
12580 bioerror(bp, EIO);
12581 bp->b_resid = bp->b_bcount;
12582 SD_BEGIN_IODONE(index, un, bp);
12583
12584 sd_ssc_fini(ssc);
12585 return;
12586 }
12587 sd_ssc_fini(ssc);
12588 }
12589
12590 nblocks = 0;
12591 (void) cmlb_partinfo(un->un_cmlbhandle, partition,
12592 &nblocks, &partition_offset, NULL, NULL, (void *)SD_PATH_DIRECT);
12593
12594 if (un->un_f_enable_rmw) {
12595 blknomask = (un->un_phy_blocksize / DEV_BSIZE) - 1;
12596 secmask = un->un_phy_blocksize - 1;
12597 } else {
12598 blknomask = (un->un_tgt_blocksize / DEV_BSIZE) - 1;
12599 secmask = un->un_tgt_blocksize - 1;
12600 }
12601
12602 if ((bp->b_lblkno & (blknomask)) || (bp->b_bcount & (secmask))) {
12603 is_aligned = FALSE;
12604 }
12605
12606 if (!(NOT_DEVBSIZE(un)) || un->un_f_enable_rmw) {
12607 /*
12608 * If I/O is aligned, no need to involve RMW(Read Modify Write)
12609 * Convert the logical block number to target's physical sector
12610 * number.
12611 */
12612 if (is_aligned) {
12613 xp->xb_blkno = SD_SYS2TGTBLOCK(un, xp->xb_blkno);
12614 } else {
12615 /*
12616 * There is no RMW if we're just reading, so don't
12617 * warn or error out because of it.
12618 */
12619 if (bp->b_flags & B_READ) {
12620 /*EMPTY*/
12621 } else if (!un->un_f_enable_rmw &&
12622 un->un_f_rmw_type == SD_RMW_TYPE_RETURN_ERROR) {
12623 bp->b_flags |= B_ERROR;
12624 goto error_exit;
12625 } else if (un->un_f_rmw_type == SD_RMW_TYPE_DEFAULT) {
12626 mutex_enter(SD_MUTEX(un));
12627 if (!un->un_f_enable_rmw &&
12628 un->un_rmw_msg_timeid == NULL) {
12629 scsi_log(SD_DEVINFO(un), sd_label,
12630 CE_WARN, "I/O request is not "
12631 "aligned with %d disk sector size. "
12632 "It is handled through Read Modify "
12633 "Write but the performance is "
12634 "very low.\n",
12635 un->un_tgt_blocksize);
12636 un->un_rmw_msg_timeid =
12637 timeout(sd_rmw_msg_print_handler,
12638 un, SD_RMW_MSG_PRINT_TIMEOUT);
12639 } else {
12640 un->un_rmw_incre_count ++;
12641 }
12642 mutex_exit(SD_MUTEX(un));
12643 }
12644
12645 nblocks = SD_TGT2SYSBLOCK(un, nblocks);
12646 partition_offset = SD_TGT2SYSBLOCK(un,
12647 partition_offset);
12648 }
12649 }
12650
12651 /*
12652 * blocknum is the starting block number of the request. At this
12653 * point it is still relative to the start of the minor device.
12654 */
12655 blocknum = xp->xb_blkno;
12656
12657 /*
12658 * Legacy: If the starting block number is one past the last block
12659 * in the partition, do not set B_ERROR in the buf.
12660 */
12661 if (blocknum == nblocks) {
12662 goto error_exit;
12663 }
12664
12665 /*
12666 * Confirm that the first block of the request lies within the
12667 * partition limits. Also the requested number of bytes must be
12668 * a multiple of the system block size.
12669 */
12670 if ((blocknum < 0) || (blocknum >= nblocks) ||
12671 ((bp->b_bcount & (DEV_BSIZE - 1)) != 0)) {
12672 bp->b_flags |= B_ERROR;
12673 goto error_exit;
12674 }
12675
12676 /*
12677 * If the requsted # blocks exceeds the available # blocks, that
12678 * is an overrun of the partition.
12679 */
12680 if ((!NOT_DEVBSIZE(un)) && is_aligned) {
12681 requested_nblocks = SD_BYTES2TGTBLOCKS(un, bp->b_bcount);
12682 } else {
12683 requested_nblocks = SD_BYTES2SYSBLOCKS(bp->b_bcount);
12684 }
12685
12686 available_nblocks = (size_t)(nblocks - blocknum);
12687 ASSERT(nblocks >= blocknum);
12688
12689 if (requested_nblocks > available_nblocks) {
12690 size_t resid;
12691
12692 /*
12693 * Allocate an "overrun" buf to allow the request to proceed
12694 * for the amount of space available in the partition. The
12695 * amount not transferred will be added into the b_resid
12696 * when the operation is complete. The overrun buf
12697 * replaces the original buf here, and the original buf
12698 * is saved inside the overrun buf, for later use.
12699 */
12700 if ((!NOT_DEVBSIZE(un)) && is_aligned) {
12701 resid = SD_TGTBLOCKS2BYTES(un,
12702 (offset_t)(requested_nblocks - available_nblocks));
12703 } else {
12704 resid = SD_SYSBLOCKS2BYTES(
12705 (offset_t)(requested_nblocks - available_nblocks));
12706 }
12707
12708 size_t count = bp->b_bcount - resid;
12709 /*
12710 * Note: count is an unsigned entity thus it'll NEVER
12711 * be less than 0 so ASSERT the original values are
12712 * correct.
12713 */
12714 ASSERT(bp->b_bcount >= resid);
12715
12716 bp = sd_bioclone_alloc(bp, count, blocknum,
12717 (int (*)(struct buf *)) sd_mapblockaddr_iodone);
12718 xp = SD_GET_XBUF(bp); /* Update for 'new' bp! */
12719 ASSERT(xp != NULL);
12720 }
12721
12722 /* At this point there should be no residual for this buf. */
12723 ASSERT(bp->b_resid == 0);
12724
12725 /* Convert the block number to an absolute address. */
12726 xp->xb_blkno += partition_offset;
12727
12728 SD_NEXT_IOSTART(index, un, bp);
12729
12730 SD_TRACE(SD_LOG_IO_PARTITION, un,
12731 "sd_mapblockaddr_iostart: exit 0: buf:0x%p\n", bp);
12732
12733 return;
12734
12735 error_exit:
12736 bp->b_resid = bp->b_bcount;
12737 SD_BEGIN_IODONE(index, un, bp);
12738 SD_TRACE(SD_LOG_IO_PARTITION, un,
12739 "sd_mapblockaddr_iostart: exit 1: buf:0x%p\n", bp);
12740 }
12741
12742
12743 /*
12744 * Function: sd_mapblockaddr_iodone
12745 *
12746 * Description: Completion-side processing for partition management.
12747 *
12748 * Context: May be called under interrupt context
12749 */
12750
12751 static void
12752 sd_mapblockaddr_iodone(int index, struct sd_lun *un, struct buf *bp)
12753 {
12754 /* int partition; */ /* Not used, see below. */
12755 ASSERT(un != NULL);
12756 ASSERT(bp != NULL);
12757 ASSERT(!mutex_owned(SD_MUTEX(un)));
12758
12759 SD_TRACE(SD_LOG_IO_PARTITION, un,
12760 "sd_mapblockaddr_iodone: entry: buf:0x%p\n", bp);
12761
12762 if (bp->b_iodone == (int (*)(struct buf *)) sd_mapblockaddr_iodone) {
12763 /*
12764 * We have an "overrun" buf to deal with...
12765 */
12766 struct sd_xbuf *xp;
12767 struct buf *obp; /* ptr to the original buf */
12768
12769 xp = SD_GET_XBUF(bp);
12770 ASSERT(xp != NULL);
12771
12772 /* Retrieve the pointer to the original buf */
12773 obp = (struct buf *)xp->xb_private;
12774 ASSERT(obp != NULL);
12775
12776 obp->b_resid = obp->b_bcount - (bp->b_bcount - bp->b_resid);
12777 bioerror(obp, bp->b_error);
12778
12779 sd_bioclone_free(bp);
12780
12781 /*
12782 * Get back the original buf.
12783 * Note that since the restoration of xb_blkno below
12784 * was removed, the sd_xbuf is not needed.
12785 */
12786 bp = obp;
12787 /*
12788 * xp = SD_GET_XBUF(bp);
12789 * ASSERT(xp != NULL);
12790 */
12791 }
12792
12793 /*
12794 * Convert sd->xb_blkno back to a minor-device relative value.
12795 * Note: this has been commented out, as it is not needed in the
12796 * current implementation of the driver (ie, since this function
12797 * is at the top of the layering chains, so the info will be
12798 * discarded) and it is in the "hot" IO path.
12799 *
12800 * partition = getminor(bp->b_edev) & SDPART_MASK;
12801 * xp->xb_blkno -= un->un_offset[partition];
12802 */
12803
12804 SD_NEXT_IODONE(index, un, bp);
12805
12806 SD_TRACE(SD_LOG_IO_PARTITION, un,
12807 "sd_mapblockaddr_iodone: exit: buf:0x%p\n", bp);
12808 }
12809
12810
12811 /*
12812 * Function: sd_mapblocksize_iostart
12813 *
12814 * Description: Convert between system block size (un->un_sys_blocksize)
12815 * and target block size (un->un_tgt_blocksize).
12816 *
12817 * Context: Can sleep to allocate resources.
12818 *
12819 * Assumptions: A higher layer has already performed any partition validation,
12820 * and converted the xp->xb_blkno to an absolute value relative
12821 * to the start of the device.
12822 *
12823 * It is also assumed that the higher layer has implemented
12824 * an "overrun" mechanism for the case where the request would
12825 * read/write beyond the end of a partition. In this case we
12826 * assume (and ASSERT) that bp->b_resid == 0.
12827 *
12828 * Note: The implementation for this routine assumes the target
12829 * block size remains constant between allocation and transport.
12830 */
12831
12832 static void
12833 sd_mapblocksize_iostart(int index, struct sd_lun *un, struct buf *bp)
12834 {
12835 struct sd_mapblocksize_info *bsp;
12836 struct sd_xbuf *xp;
12837 offset_t first_byte;
12838 daddr_t start_block, end_block;
12839 daddr_t request_bytes;
12840 ushort_t is_aligned = FALSE;
12841
12842 ASSERT(un != NULL);
12843 ASSERT(bp != NULL);
12844 ASSERT(!mutex_owned(SD_MUTEX(un)));
12845 ASSERT(bp->b_resid == 0);
12846
12847 SD_TRACE(SD_LOG_IO_RMMEDIA, un,
12848 "sd_mapblocksize_iostart: entry: buf:0x%p\n", bp);
12849
12850 /*
12851 * For a non-writable CD, a write request is an error
12852 */
12853 if (ISCD(un) && ((bp->b_flags & B_READ) == 0) &&
12854 (un->un_f_mmc_writable_media == FALSE)) {
12855 bioerror(bp, EIO);
12856 bp->b_resid = bp->b_bcount;
12857 SD_BEGIN_IODONE(index, un, bp);
12858 return;
12859 }
12860
12861 /*
12862 * We do not need a shadow buf if the device is using
12863 * un->un_sys_blocksize as its block size or if bcount == 0.
12864 * In this case there is no layer-private data block allocated.
12865 */
12866 if ((un->un_tgt_blocksize == DEV_BSIZE && !un->un_f_enable_rmw) ||
12867 (bp->b_bcount == 0)) {
12868 goto done;
12869 }
12870
12871 #if defined(__i386) || defined(__amd64)
12872 /* We do not support non-block-aligned transfers for ROD devices */
12873 ASSERT(!ISROD(un));
12874 #endif
12875
12876 xp = SD_GET_XBUF(bp);
12877 ASSERT(xp != NULL);
12878
12879 SD_INFO(SD_LOG_IO_RMMEDIA, un, "sd_mapblocksize_iostart: "
12880 "tgt_blocksize:0x%x sys_blocksize: 0x%x\n",
12881 un->un_tgt_blocksize, DEV_BSIZE);
12882 SD_INFO(SD_LOG_IO_RMMEDIA, un, "sd_mapblocksize_iostart: "
12883 "request start block:0x%x\n", xp->xb_blkno);
12884 SD_INFO(SD_LOG_IO_RMMEDIA, un, "sd_mapblocksize_iostart: "
12885 "request len:0x%x\n", bp->b_bcount);
12886
12887 /*
12888 * Allocate the layer-private data area for the mapblocksize layer.
12889 * Layers are allowed to use the xp_private member of the sd_xbuf
12890 * struct to store the pointer to their layer-private data block, but
12891 * each layer also has the responsibility of restoring the prior
12892 * contents of xb_private before returning the buf/xbuf to the
12893 * higher layer that sent it.
12894 *
12895 * Here we save the prior contents of xp->xb_private into the
12896 * bsp->mbs_oprivate field of our layer-private data area. This value
12897 * is restored by sd_mapblocksize_iodone() just prior to freeing up
12898 * the layer-private area and returning the buf/xbuf to the layer
12899 * that sent it.
12900 *
12901 * Note that here we use kmem_zalloc for the allocation as there are
12902 * parts of the mapblocksize code that expect certain fields to be
12903 * zero unless explicitly set to a required value.
12904 */
12905 bsp = kmem_zalloc(sizeof (struct sd_mapblocksize_info), KM_SLEEP);
12906 bsp->mbs_oprivate = xp->xb_private;
12907 xp->xb_private = bsp;
12908
12909 /*
12910 * This treats the data on the disk (target) as an array of bytes.
12911 * first_byte is the byte offset, from the beginning of the device,
12912 * to the location of the request. This is converted from a
12913 * un->un_sys_blocksize block address to a byte offset, and then back
12914 * to a block address based upon a un->un_tgt_blocksize block size.
12915 *
12916 * xp->xb_blkno should be absolute upon entry into this function,
12917 * but, but it is based upon partitions that use the "system"
12918 * block size. It must be adjusted to reflect the block size of
12919 * the target.
12920 *
12921 * Note that end_block is actually the block that follows the last
12922 * block of the request, but that's what is needed for the computation.
12923 */
12924 first_byte = SD_SYSBLOCKS2BYTES((offset_t)xp->xb_blkno);
12925 if (un->un_f_enable_rmw) {
12926 start_block = xp->xb_blkno =
12927 (first_byte / un->un_phy_blocksize) *
12928 (un->un_phy_blocksize / DEV_BSIZE);
12929 end_block = ((first_byte + bp->b_bcount +
12930 un->un_phy_blocksize - 1) / un->un_phy_blocksize) *
12931 (un->un_phy_blocksize / DEV_BSIZE);
12932 } else {
12933 start_block = xp->xb_blkno = first_byte / un->un_tgt_blocksize;
12934 end_block = (first_byte + bp->b_bcount +
12935 un->un_tgt_blocksize - 1) / un->un_tgt_blocksize;
12936 }
12937
12938 /* request_bytes is rounded up to a multiple of the target block size */
12939 request_bytes = (end_block - start_block) * un->un_tgt_blocksize;
12940
12941 /*
12942 * See if the starting address of the request and the request
12943 * length are aligned on a un->un_tgt_blocksize boundary. If aligned
12944 * then we do not need to allocate a shadow buf to handle the request.
12945 */
12946 if (un->un_f_enable_rmw) {
12947 if (((first_byte % un->un_phy_blocksize) == 0) &&
12948 ((bp->b_bcount % un->un_phy_blocksize) == 0)) {
12949 is_aligned = TRUE;
12950 }
12951 } else {
12952 if (((first_byte % un->un_tgt_blocksize) == 0) &&
12953 ((bp->b_bcount % un->un_tgt_blocksize) == 0)) {
12954 is_aligned = TRUE;
12955 }
12956 }
12957
12958 if ((bp->b_flags & B_READ) == 0) {
12959 /*
12960 * Lock the range for a write operation. An aligned request is
12961 * considered a simple write; otherwise the request must be a
12962 * read-modify-write.
12963 */
12964 bsp->mbs_wmp = sd_range_lock(un, start_block, end_block - 1,
12965 (is_aligned == TRUE) ? SD_WTYPE_SIMPLE : SD_WTYPE_RMW);
12966 }
12967
12968 /*
12969 * Alloc a shadow buf if the request is not aligned. Also, this is
12970 * where the READ command is generated for a read-modify-write. (The
12971 * write phase is deferred until after the read completes.)
12972 */
12973 if (is_aligned == FALSE) {
12974
12975 struct sd_mapblocksize_info *shadow_bsp;
12976 struct sd_xbuf *shadow_xp;
12977 struct buf *shadow_bp;
12978
12979 /*
12980 * Allocate the shadow buf and it associated xbuf. Note that
12981 * after this call the xb_blkno value in both the original
12982 * buf's sd_xbuf _and_ the shadow buf's sd_xbuf will be the
12983 * same: absolute relative to the start of the device, and
12984 * adjusted for the target block size. The b_blkno in the
12985 * shadow buf will also be set to this value. We should never
12986 * change b_blkno in the original bp however.
12987 *
12988 * Note also that the shadow buf will always need to be a
12989 * READ command, regardless of whether the incoming command
12990 * is a READ or a WRITE.
12991 */
12992 shadow_bp = sd_shadow_buf_alloc(bp, request_bytes, B_READ,
12993 xp->xb_blkno,
12994 (int (*)(struct buf *)) sd_mapblocksize_iodone);
12995
12996 shadow_xp = SD_GET_XBUF(shadow_bp);
12997
12998 /*
12999 * Allocate the layer-private data for the shadow buf.
13000 * (No need to preserve xb_private in the shadow xbuf.)
13001 */
13002 shadow_xp->xb_private = shadow_bsp =
13003 kmem_zalloc(sizeof (struct sd_mapblocksize_info), KM_SLEEP);
13004
13005 /*
13006 * bsp->mbs_copy_offset is used later by sd_mapblocksize_iodone
13007 * to figure out where the start of the user data is (based upon
13008 * the system block size) in the data returned by the READ
13009 * command (which will be based upon the target blocksize). Note
13010 * that this is only really used if the request is unaligned.
13011 */
13012 if (un->un_f_enable_rmw) {
13013 bsp->mbs_copy_offset = (ssize_t)(first_byte -
13014 ((offset_t)xp->xb_blkno * un->un_sys_blocksize));
13015 ASSERT((bsp->mbs_copy_offset >= 0) &&
13016 (bsp->mbs_copy_offset < un->un_phy_blocksize));
13017 } else {
13018 bsp->mbs_copy_offset = (ssize_t)(first_byte -
13019 ((offset_t)xp->xb_blkno * un->un_tgt_blocksize));
13020 ASSERT((bsp->mbs_copy_offset >= 0) &&
13021 (bsp->mbs_copy_offset < un->un_tgt_blocksize));
13022 }
13023
13024 shadow_bsp->mbs_copy_offset = bsp->mbs_copy_offset;
13025
13026 shadow_bsp->mbs_layer_index = bsp->mbs_layer_index = index;
13027
13028 /* Transfer the wmap (if any) to the shadow buf */
13029 shadow_bsp->mbs_wmp = bsp->mbs_wmp;
13030 bsp->mbs_wmp = NULL;
13031
13032 /*
13033 * The shadow buf goes on from here in place of the
13034 * original buf.
13035 */
13036 shadow_bsp->mbs_orig_bp = bp;
13037 bp = shadow_bp;
13038 }
13039
13040 SD_INFO(SD_LOG_IO_RMMEDIA, un,
13041 "sd_mapblocksize_iostart: tgt start block:0x%x\n", xp->xb_blkno);
13042 SD_INFO(SD_LOG_IO_RMMEDIA, un,
13043 "sd_mapblocksize_iostart: tgt request len:0x%x\n",
13044 request_bytes);
13045 SD_INFO(SD_LOG_IO_RMMEDIA, un,
13046 "sd_mapblocksize_iostart: shadow buf:0x%x\n", bp);
13047
13048 done:
13049 SD_NEXT_IOSTART(index, un, bp);
13050
13051 SD_TRACE(SD_LOG_IO_RMMEDIA, un,
13052 "sd_mapblocksize_iostart: exit: buf:0x%p\n", bp);
13053 }
13054
13055
13056 /*
13057 * Function: sd_mapblocksize_iodone
13058 *
13059 * Description: Completion side processing for block-size mapping.
13060 *
13061 * Context: May be called under interrupt context
13062 */
13063
13064 static void
13065 sd_mapblocksize_iodone(int index, struct sd_lun *un, struct buf *bp)
13066 {
13067 struct sd_mapblocksize_info *bsp;
13068 struct sd_xbuf *xp;
13069 struct sd_xbuf *orig_xp; /* sd_xbuf for the original buf */
13070 struct buf *orig_bp; /* ptr to the original buf */
13071 offset_t shadow_end;
13072 offset_t request_end;
13073 offset_t shadow_start;
13074 ssize_t copy_offset;
13075 size_t copy_length;
13076 size_t shortfall;
13077 uint_t is_write; /* TRUE if this bp is a WRITE */
13078 uint_t has_wmap; /* TRUE is this bp has a wmap */
13079
13080 ASSERT(un != NULL);
13081 ASSERT(bp != NULL);
13082
13083 SD_TRACE(SD_LOG_IO_RMMEDIA, un,
13084 "sd_mapblocksize_iodone: entry: buf:0x%p\n", bp);
13085
13086 /*
13087 * There is no shadow buf or layer-private data if the target is
13088 * using un->un_sys_blocksize as its block size or if bcount == 0.
13089 */
13090 if ((un->un_tgt_blocksize == DEV_BSIZE && !un->un_f_enable_rmw) ||
13091 (bp->b_bcount == 0)) {
13092 goto exit;
13093 }
13094
13095 xp = SD_GET_XBUF(bp);
13096 ASSERT(xp != NULL);
13097
13098 /* Retrieve the pointer to the layer-private data area from the xbuf. */
13099 bsp = xp->xb_private;
13100
13101 is_write = ((bp->b_flags & B_READ) == 0) ? TRUE : FALSE;
13102 has_wmap = (bsp->mbs_wmp != NULL) ? TRUE : FALSE;
13103
13104 if (is_write) {
13105 /*
13106 * For a WRITE request we must free up the block range that
13107 * we have locked up. This holds regardless of whether this is
13108 * an aligned write request or a read-modify-write request.
13109 */
13110 sd_range_unlock(un, bsp->mbs_wmp);
13111 bsp->mbs_wmp = NULL;
13112 }
13113
13114 if ((bp->b_iodone != (int(*)(struct buf *))sd_mapblocksize_iodone)) {
13115 /*
13116 * An aligned read or write command will have no shadow buf;
13117 * there is not much else to do with it.
13118 */
13119 goto done;
13120 }
13121
13122 orig_bp = bsp->mbs_orig_bp;
13123 ASSERT(orig_bp != NULL);
13124 orig_xp = SD_GET_XBUF(orig_bp);
13125 ASSERT(orig_xp != NULL);
13126 ASSERT(!mutex_owned(SD_MUTEX(un)));
13127
13128 if (!is_write && has_wmap) {
13129 /*
13130 * A READ with a wmap means this is the READ phase of a
13131 * read-modify-write. If an error occurred on the READ then
13132 * we do not proceed with the WRITE phase or copy any data.
13133 * Just release the write maps and return with an error.
13134 */
13135 if ((bp->b_resid != 0) || (bp->b_error != 0)) {
13136 orig_bp->b_resid = orig_bp->b_bcount;
13137 bioerror(orig_bp, bp->b_error);
13138 sd_range_unlock(un, bsp->mbs_wmp);
13139 goto freebuf_done;
13140 }
13141 }
13142
13143 /*
13144 * Here is where we set up to copy the data from the shadow buf
13145 * into the space associated with the original buf.
13146 *
13147 * To deal with the conversion between block sizes, these
13148 * computations treat the data as an array of bytes, with the
13149 * first byte (byte 0) corresponding to the first byte in the
13150 * first block on the disk.
13151 */
13152
13153 /*
13154 * shadow_start and shadow_len indicate the location and size of
13155 * the data returned with the shadow IO request.
13156 */
13157 if (un->un_f_enable_rmw) {
13158 shadow_start = SD_SYSBLOCKS2BYTES((offset_t)xp->xb_blkno);
13159 } else {
13160 shadow_start = SD_TGTBLOCKS2BYTES(un, (offset_t)xp->xb_blkno);
13161 }
13162 shadow_end = shadow_start + bp->b_bcount - bp->b_resid;
13163
13164 /*
13165 * copy_offset gives the offset (in bytes) from the start of the first
13166 * block of the READ request to the beginning of the data. We retrieve
13167 * this value from xb_pktp in the ORIGINAL xbuf, as it has been saved
13168 * there by sd_mapblockize_iostart(). copy_length gives the amount of
13169 * data to be copied (in bytes).
13170 */
13171 copy_offset = bsp->mbs_copy_offset;
13172 if (un->un_f_enable_rmw) {
13173 ASSERT((copy_offset >= 0) &&
13174 (copy_offset < un->un_phy_blocksize));
13175 } else {
13176 ASSERT((copy_offset >= 0) &&
13177 (copy_offset < un->un_tgt_blocksize));
13178 }
13179
13180 copy_length = orig_bp->b_bcount;
13181 request_end = shadow_start + copy_offset + orig_bp->b_bcount;
13182
13183 /*
13184 * Set up the resid and error fields of orig_bp as appropriate.
13185 */
13186 if (shadow_end >= request_end) {
13187 /* We got all the requested data; set resid to zero */
13188 orig_bp->b_resid = 0;
13189 } else {
13190 /*
13191 * We failed to get enough data to fully satisfy the original
13192 * request. Just copy back whatever data we got and set
13193 * up the residual and error code as required.
13194 *
13195 * 'shortfall' is the amount by which the data received with the
13196 * shadow buf has "fallen short" of the requested amount.
13197 */
13198 shortfall = (size_t)(request_end - shadow_end);
13199
13200 if (shortfall > orig_bp->b_bcount) {
13201 /*
13202 * We did not get enough data to even partially
13203 * fulfill the original request. The residual is
13204 * equal to the amount requested.
13205 */
13206 orig_bp->b_resid = orig_bp->b_bcount;
13207 } else {
13208 /*
13209 * We did not get all the data that we requested
13210 * from the device, but we will try to return what
13211 * portion we did get.
13212 */
13213 orig_bp->b_resid = shortfall;
13214 }
13215 ASSERT(copy_length >= orig_bp->b_resid);
13216 copy_length -= orig_bp->b_resid;
13217 }
13218
13219 /* Propagate the error code from the shadow buf to the original buf */
13220 bioerror(orig_bp, bp->b_error);
13221
13222 if (is_write) {
13223 goto freebuf_done; /* No data copying for a WRITE */
13224 }
13225
13226 if (has_wmap) {
13227 /*
13228 * This is a READ command from the READ phase of a
13229 * read-modify-write request. We have to copy the data given
13230 * by the user OVER the data returned by the READ command,
13231 * then convert the command from a READ to a WRITE and send
13232 * it back to the target.
13233 */
13234 bcopy(orig_bp->b_un.b_addr, bp->b_un.b_addr + copy_offset,
13235 copy_length);
13236
13237 bp->b_flags &= ~((int)B_READ); /* Convert to a WRITE */
13238
13239 /*
13240 * Dispatch the WRITE command to the taskq thread, which
13241 * will in turn send the command to the target. When the
13242 * WRITE command completes, we (sd_mapblocksize_iodone())
13243 * will get called again as part of the iodone chain
13244 * processing for it. Note that we will still be dealing
13245 * with the shadow buf at that point.
13246 */
13247 if (taskq_dispatch(sd_wmr_tq, sd_read_modify_write_task, bp,
13248 KM_NOSLEEP) != 0) {
13249 /*
13250 * Dispatch was successful so we are done. Return
13251 * without going any higher up the iodone chain. Do
13252 * not free up any layer-private data until after the
13253 * WRITE completes.
13254 */
13255 return;
13256 }
13257
13258 /*
13259 * Dispatch of the WRITE command failed; set up the error
13260 * condition and send this IO back up the iodone chain.
13261 */
13262 bioerror(orig_bp, EIO);
13263 orig_bp->b_resid = orig_bp->b_bcount;
13264
13265 } else {
13266 /*
13267 * This is a regular READ request (ie, not a RMW). Copy the
13268 * data from the shadow buf into the original buf. The
13269 * copy_offset compensates for any "misalignment" between the
13270 * shadow buf (with its un->un_tgt_blocksize blocks) and the
13271 * original buf (with its un->un_sys_blocksize blocks).
13272 */
13273 bcopy(bp->b_un.b_addr + copy_offset, orig_bp->b_un.b_addr,
13274 copy_length);
13275 }
13276
13277 freebuf_done:
13278
13279 /*
13280 * At this point we still have both the shadow buf AND the original
13281 * buf to deal with, as well as the layer-private data area in each.
13282 * Local variables are as follows:
13283 *
13284 * bp -- points to shadow buf
13285 * xp -- points to xbuf of shadow buf
13286 * bsp -- points to layer-private data area of shadow buf
13287 * orig_bp -- points to original buf
13288 *
13289 * First free the shadow buf and its associated xbuf, then free the
13290 * layer-private data area from the shadow buf. There is no need to
13291 * restore xb_private in the shadow xbuf.
13292 */
13293 sd_shadow_buf_free(bp);
13294 kmem_free(bsp, sizeof (struct sd_mapblocksize_info));
13295
13296 /*
13297 * Now update the local variables to point to the original buf, xbuf,
13298 * and layer-private area.
13299 */
13300 bp = orig_bp;
13301 xp = SD_GET_XBUF(bp);
13302 ASSERT(xp != NULL);
13303 ASSERT(xp == orig_xp);
13304 bsp = xp->xb_private;
13305 ASSERT(bsp != NULL);
13306
13307 done:
13308 /*
13309 * Restore xb_private to whatever it was set to by the next higher
13310 * layer in the chain, then free the layer-private data area.
13311 */
13312 xp->xb_private = bsp->mbs_oprivate;
13313 kmem_free(bsp, sizeof (struct sd_mapblocksize_info));
13314
13315 exit:
13316 SD_TRACE(SD_LOG_IO_RMMEDIA, SD_GET_UN(bp),
13317 "sd_mapblocksize_iodone: calling SD_NEXT_IODONE: buf:0x%p\n", bp);
13318
13319 SD_NEXT_IODONE(index, un, bp);
13320 }
13321
13322
13323 /*
13324 * Function: sd_checksum_iostart
13325 *
13326 * Description: A stub function for a layer that's currently not used.
13327 * For now just a placeholder.
13328 *
13329 * Context: Kernel thread context
13330 */
13331
13332 static void
13333 sd_checksum_iostart(int index, struct sd_lun *un, struct buf *bp)
13334 {
13335 ASSERT(un != NULL);
13336 ASSERT(bp != NULL);
13337 ASSERT(!mutex_owned(SD_MUTEX(un)));
13338 SD_NEXT_IOSTART(index, un, bp);
13339 }
13340
13341
13342 /*
13343 * Function: sd_checksum_iodone
13344 *
13345 * Description: A stub function for a layer that's currently not used.
13346 * For now just a placeholder.
13347 *
13348 * Context: May be called under interrupt context
13349 */
13350
13351 static void
13352 sd_checksum_iodone(int index, struct sd_lun *un, struct buf *bp)
13353 {
13354 ASSERT(un != NULL);
13355 ASSERT(bp != NULL);
13356 ASSERT(!mutex_owned(SD_MUTEX(un)));
13357 SD_NEXT_IODONE(index, un, bp);
13358 }
13359
13360
13361 /*
13362 * Function: sd_checksum_uscsi_iostart
13363 *
13364 * Description: A stub function for a layer that's currently not used.
13365 * For now just a placeholder.
13366 *
13367 * Context: Kernel thread context
13368 */
13369
13370 static void
13371 sd_checksum_uscsi_iostart(int index, struct sd_lun *un, struct buf *bp)
13372 {
13373 ASSERT(un != NULL);
13374 ASSERT(bp != NULL);
13375 ASSERT(!mutex_owned(SD_MUTEX(un)));
13376 SD_NEXT_IOSTART(index, un, bp);
13377 }
13378
13379
13380 /*
13381 * Function: sd_checksum_uscsi_iodone
13382 *
13383 * Description: A stub function for a layer that's currently not used.
13384 * For now just a placeholder.
13385 *
13386 * Context: May be called under interrupt context
13387 */
13388
13389 static void
13390 sd_checksum_uscsi_iodone(int index, struct sd_lun *un, struct buf *bp)
13391 {
13392 ASSERT(un != NULL);
13393 ASSERT(bp != NULL);
13394 ASSERT(!mutex_owned(SD_MUTEX(un)));
13395 SD_NEXT_IODONE(index, un, bp);
13396 }
13397
13398
13399 /*
13400 * Function: sd_pm_iostart
13401 *
13402 * Description: iostart-side routine for Power mangement.
13403 *
13404 * Context: Kernel thread context
13405 */
13406
13407 static void
13408 sd_pm_iostart(int index, struct sd_lun *un, struct buf *bp)
13409 {
13410 ASSERT(un != NULL);
13411 ASSERT(bp != NULL);
13412 ASSERT(!mutex_owned(SD_MUTEX(un)));
13413 ASSERT(!mutex_owned(&un->un_pm_mutex));
13414
13415 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_iostart: entry\n");
13416
13417 if (sd_pm_entry(un) != DDI_SUCCESS) {
13418 /*
13419 * Set up to return the failed buf back up the 'iodone'
13420 * side of the calling chain.
13421 */
13422 bioerror(bp, EIO);
13423 bp->b_resid = bp->b_bcount;
13424
13425 SD_BEGIN_IODONE(index, un, bp);
13426
13427 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_iostart: exit\n");
13428 return;
13429 }
13430
13431 SD_NEXT_IOSTART(index, un, bp);
13432
13433 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_iostart: exit\n");
13434 }
13435
13436
13437 /*
13438 * Function: sd_pm_iodone
13439 *
13440 * Description: iodone-side routine for power mangement.
13441 *
13442 * Context: may be called from interrupt context
13443 */
13444
13445 static void
13446 sd_pm_iodone(int index, struct sd_lun *un, struct buf *bp)
13447 {
13448 ASSERT(un != NULL);
13449 ASSERT(bp != NULL);
13450 ASSERT(!mutex_owned(&un->un_pm_mutex));
13451
13452 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_iodone: entry\n");
13453
13454 /*
13455 * After attach the following flag is only read, so don't
13456 * take the penalty of acquiring a mutex for it.
13457 */
13458 if (un->un_f_pm_is_enabled == TRUE) {
13459 sd_pm_exit(un);
13460 }
13461
13462 SD_NEXT_IODONE(index, un, bp);
13463
13464 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_iodone: exit\n");
13465 }
13466
13467
13468 /*
13469 * Function: sd_core_iostart
13470 *
13471 * Description: Primary driver function for enqueuing buf(9S) structs from
13472 * the system and initiating IO to the target device
13473 *
13474 * Context: Kernel thread context. Can sleep.
13475 *
13476 * Assumptions: - The given xp->xb_blkno is absolute
13477 * (ie, relative to the start of the device).
13478 * - The IO is to be done using the native blocksize of
13479 * the device, as specified in un->un_tgt_blocksize.
13480 */
13481 /* ARGSUSED */
13482 static void
13483 sd_core_iostart(int index, struct sd_lun *un, struct buf *bp)
13484 {
13485 struct sd_xbuf *xp;
13486
13487 ASSERT(un != NULL);
13488 ASSERT(bp != NULL);
13489 ASSERT(!mutex_owned(SD_MUTEX(un)));
13490 ASSERT(bp->b_resid == 0);
13491
13492 SD_TRACE(SD_LOG_IO_CORE, un, "sd_core_iostart: entry: bp:0x%p\n", bp);
13493
13494 xp = SD_GET_XBUF(bp);
13495 ASSERT(xp != NULL);
13496
13497 mutex_enter(SD_MUTEX(un));
13498
13499 /*
13500 * If we are currently in the failfast state, fail any new IO
13501 * that has B_FAILFAST set, then return.
13502 */
13503 if ((bp->b_flags & B_FAILFAST) &&
13504 (un->un_failfast_state == SD_FAILFAST_ACTIVE)) {
13505 mutex_exit(SD_MUTEX(un));
13506 bioerror(bp, EIO);
13507 bp->b_resid = bp->b_bcount;
13508 SD_BEGIN_IODONE(index, un, bp);
13509 return;
13510 }
13511
13512 if (SD_IS_DIRECT_PRIORITY(xp)) {
13513 /*
13514 * Priority command -- transport it immediately.
13515 *
13516 * Note: We may want to assert that USCSI_DIAGNOSE is set,
13517 * because all direct priority commands should be associated
13518 * with error recovery actions which we don't want to retry.
13519 */
13520 sd_start_cmds(un, bp);
13521 } else {
13522 /*
13523 * Normal command -- add it to the wait queue, then start
13524 * transporting commands from the wait queue.
13525 */
13526 sd_add_buf_to_waitq(un, bp);
13527 SD_UPDATE_KSTATS(un, kstat_waitq_enter, bp);
13528 sd_start_cmds(un, NULL);
13529 }
13530
13531 mutex_exit(SD_MUTEX(un));
13532
13533 SD_TRACE(SD_LOG_IO_CORE, un, "sd_core_iostart: exit: bp:0x%p\n", bp);
13534 }
13535
13536
13537 /*
13538 * Function: sd_init_cdb_limits
13539 *
13540 * Description: This is to handle scsi_pkt initialization differences
13541 * between the driver platforms.
13542 *
13543 * Legacy behaviors:
13544 *
13545 * If the block number or the sector count exceeds the
13546 * capabilities of a Group 0 command, shift over to a
13547 * Group 1 command. We don't blindly use Group 1
13548 * commands because a) some drives (CDC Wren IVs) get a
13549 * bit confused, and b) there is probably a fair amount
13550 * of speed difference for a target to receive and decode
13551 * a 10 byte command instead of a 6 byte command.
13552 *
13553 * The xfer time difference of 6 vs 10 byte CDBs is
13554 * still significant so this code is still worthwhile.
13555 * 10 byte CDBs are very inefficient with the fas HBA driver
13556 * and older disks. Each CDB byte took 1 usec with some
13557 * popular disks.
13558 *
13559 * Context: Must be called at attach time
13560 */
13561
13562 static void
13563 sd_init_cdb_limits(struct sd_lun *un)
13564 {
13565 int hba_cdb_limit;
13566
13567 /*
13568 * Use CDB_GROUP1 commands for most devices except for
13569 * parallel SCSI fixed drives in which case we get better
13570 * performance using CDB_GROUP0 commands (where applicable).
13571 */
13572 un->un_mincdb = SD_CDB_GROUP1;
13573 #if !defined(__fibre)
13574 if (!un->un_f_is_fibre && !un->un_f_cfg_is_atapi && !ISROD(un) &&
13575 !un->un_f_has_removable_media) {
13576 un->un_mincdb = SD_CDB_GROUP0;
13577 }
13578 #endif
13579
13580 /*
13581 * Try to read the max-cdb-length supported by HBA.
13582 */
13583 un->un_max_hba_cdb = scsi_ifgetcap(SD_ADDRESS(un), "max-cdb-length", 1);
13584 if (0 >= un->un_max_hba_cdb) {
13585 un->un_max_hba_cdb = CDB_GROUP4;
13586 hba_cdb_limit = SD_CDB_GROUP4;
13587 } else if (0 < un->un_max_hba_cdb &&
13588 un->un_max_hba_cdb < CDB_GROUP1) {
13589 hba_cdb_limit = SD_CDB_GROUP0;
13590 } else if (CDB_GROUP1 <= un->un_max_hba_cdb &&
13591 un->un_max_hba_cdb < CDB_GROUP5) {
13592 hba_cdb_limit = SD_CDB_GROUP1;
13593 } else if (CDB_GROUP5 <= un->un_max_hba_cdb &&
13594 un->un_max_hba_cdb < CDB_GROUP4) {
13595 hba_cdb_limit = SD_CDB_GROUP5;
13596 } else {
13597 hba_cdb_limit = SD_CDB_GROUP4;
13598 }
13599
13600 /*
13601 * Use CDB_GROUP5 commands for removable devices. Use CDB_GROUP4
13602 * commands for fixed disks unless we are building for a 32 bit
13603 * kernel.
13604 */
13605 #ifdef _LP64
13606 un->un_maxcdb = (un->un_f_has_removable_media) ? SD_CDB_GROUP5 :
13607 min(hba_cdb_limit, SD_CDB_GROUP4);
13608 #else
13609 un->un_maxcdb = (un->un_f_has_removable_media) ? SD_CDB_GROUP5 :
13610 min(hba_cdb_limit, SD_CDB_GROUP1);
13611 #endif
13612
13613 un->un_status_len = (int)((un->un_f_arq_enabled == TRUE)
13614 ? sizeof (struct scsi_arq_status) : 1);
13615 if (!ISCD(un))
13616 un->un_cmd_timeout = (ushort_t)sd_io_time;
13617 un->un_uscsi_timeout = ((ISCD(un)) ? 2 : 1) * un->un_cmd_timeout;
13618 }
13619
13620
13621 /*
13622 * Function: sd_initpkt_for_buf
13623 *
13624 * Description: Allocate and initialize for transport a scsi_pkt struct,
13625 * based upon the info specified in the given buf struct.
13626 *
13627 * Assumes the xb_blkno in the request is absolute (ie,
13628 * relative to the start of the device (NOT partition!).
13629 * Also assumes that the request is using the native block
13630 * size of the device (as returned by the READ CAPACITY
13631 * command).
13632 *
13633 * Return Code: SD_PKT_ALLOC_SUCCESS
13634 * SD_PKT_ALLOC_FAILURE
13635 * SD_PKT_ALLOC_FAILURE_NO_DMA
13636 * SD_PKT_ALLOC_FAILURE_CDB_TOO_SMALL
13637 *
13638 * Context: Kernel thread and may be called from software interrupt context
13639 * as part of a sdrunout callback. This function may not block or
13640 * call routines that block
13641 */
13642
13643 static int
13644 sd_initpkt_for_buf(struct buf *bp, struct scsi_pkt **pktpp)
13645 {
13646 struct sd_xbuf *xp;
13647 struct scsi_pkt *pktp = NULL;
13648 struct sd_lun *un;
13649 size_t blockcount;
13650 daddr_t startblock;
13651 int rval;
13652 int cmd_flags;
13653
13654 ASSERT(bp != NULL);
13655 ASSERT(pktpp != NULL);
13656 xp = SD_GET_XBUF(bp);
13657 ASSERT(xp != NULL);
13658 un = SD_GET_UN(bp);
13659 ASSERT(un != NULL);
13660 ASSERT(mutex_owned(SD_MUTEX(un)));
13661 ASSERT(bp->b_resid == 0);
13662
13663 SD_TRACE(SD_LOG_IO_CORE, un,
13664 "sd_initpkt_for_buf: entry: buf:0x%p\n", bp);
13665
13666 mutex_exit(SD_MUTEX(un));
13667
13668 #if defined(__i386) || defined(__amd64) /* DMAFREE for x86 only */
13669 if (xp->xb_pkt_flags & SD_XB_DMA_FREED) {
13670 /*
13671 * Already have a scsi_pkt -- just need DMA resources.
13672 * We must recompute the CDB in case the mapping returns
13673 * a nonzero pkt_resid.
13674 * Note: if this is a portion of a PKT_DMA_PARTIAL transfer
13675 * that is being retried, the unmap/remap of the DMA resouces
13676 * will result in the entire transfer starting over again
13677 * from the very first block.
13678 */
13679 ASSERT(xp->xb_pktp != NULL);
13680 pktp = xp->xb_pktp;
13681 } else {
13682 pktp = NULL;
13683 }
13684 #endif /* __i386 || __amd64 */
13685
13686 startblock = xp->xb_blkno; /* Absolute block num. */
13687 blockcount = SD_BYTES2TGTBLOCKS(un, bp->b_bcount);
13688
13689 cmd_flags = un->un_pkt_flags | (xp->xb_pkt_flags & SD_XB_INITPKT_MASK);
13690
13691 /*
13692 * sd_setup_rw_pkt will determine the appropriate CDB group to use,
13693 * call scsi_init_pkt, and build the CDB.
13694 */
13695 rval = sd_setup_rw_pkt(un, &pktp, bp,
13696 cmd_flags, sdrunout, (caddr_t)un,
13697 startblock, blockcount);
13698
13699 if (rval == 0) {
13700 /*
13701 * Success.
13702 *
13703 * If partial DMA is being used and required for this transfer.
13704 * set it up here.
13705 */
13706 if ((un->un_pkt_flags & PKT_DMA_PARTIAL) != 0 &&
13707 (pktp->pkt_resid != 0)) {
13708
13709 /*
13710 * Save the CDB length and pkt_resid for the
13711 * next xfer
13712 */
13713 xp->xb_dma_resid = pktp->pkt_resid;
13714
13715 /* rezero resid */
13716 pktp->pkt_resid = 0;
13717
13718 } else {
13719 xp->xb_dma_resid = 0;
13720 }
13721
13722 pktp->pkt_flags = un->un_tagflags;
13723 pktp->pkt_time = un->un_cmd_timeout;
13724 pktp->pkt_comp = sdintr;
13725
13726 pktp->pkt_private = bp;
13727 *pktpp = pktp;
13728
13729 SD_TRACE(SD_LOG_IO_CORE, un,
13730 "sd_initpkt_for_buf: exit: buf:0x%p\n", bp);
13731
13732 #if defined(__i386) || defined(__amd64) /* DMAFREE for x86 only */
13733 xp->xb_pkt_flags &= ~SD_XB_DMA_FREED;
13734 #endif
13735
13736 mutex_enter(SD_MUTEX(un));
13737 return (SD_PKT_ALLOC_SUCCESS);
13738
13739 }
13740
13741 /*
13742 * SD_PKT_ALLOC_FAILURE is the only expected failure code
13743 * from sd_setup_rw_pkt.
13744 */
13745 ASSERT(rval == SD_PKT_ALLOC_FAILURE);
13746
13747 if (rval == SD_PKT_ALLOC_FAILURE) {
13748 *pktpp = NULL;
13749 /*
13750 * Set the driver state to RWAIT to indicate the driver
13751 * is waiting on resource allocations. The driver will not
13752 * suspend, pm_suspend, or detatch while the state is RWAIT.
13753 */
13754 mutex_enter(SD_MUTEX(un));
13755 New_state(un, SD_STATE_RWAIT);
13756
13757 SD_ERROR(SD_LOG_IO_CORE, un,
13758 "sd_initpkt_for_buf: No pktp. exit bp:0x%p\n", bp);
13759
13760 if ((bp->b_flags & B_ERROR) != 0) {
13761 return (SD_PKT_ALLOC_FAILURE_NO_DMA);
13762 }
13763 return (SD_PKT_ALLOC_FAILURE);
13764 } else {
13765 /*
13766 * PKT_ALLOC_FAILURE_CDB_TOO_SMALL
13767 *
13768 * This should never happen. Maybe someone messed with the
13769 * kernel's minphys?
13770 */
13771 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
13772 "Request rejected: too large for CDB: "
13773 "lba:0x%08lx len:0x%08lx\n", startblock, blockcount);
13774 SD_ERROR(SD_LOG_IO_CORE, un,
13775 "sd_initpkt_for_buf: No cp. exit bp:0x%p\n", bp);
13776 mutex_enter(SD_MUTEX(un));
13777 return (SD_PKT_ALLOC_FAILURE_CDB_TOO_SMALL);
13778
13779 }
13780 }
13781
13782
13783 /*
13784 * Function: sd_destroypkt_for_buf
13785 *
13786 * Description: Free the scsi_pkt(9S) for the given bp (buf IO processing).
13787 *
13788 * Context: Kernel thread or interrupt context
13789 */
13790
13791 static void
13792 sd_destroypkt_for_buf(struct buf *bp)
13793 {
13794 ASSERT(bp != NULL);
13795 ASSERT(SD_GET_UN(bp) != NULL);
13796
13797 SD_TRACE(SD_LOG_IO_CORE, SD_GET_UN(bp),
13798 "sd_destroypkt_for_buf: entry: buf:0x%p\n", bp);
13799
13800 ASSERT(SD_GET_PKTP(bp) != NULL);
13801 scsi_destroy_pkt(SD_GET_PKTP(bp));
13802
13803 SD_TRACE(SD_LOG_IO_CORE, SD_GET_UN(bp),
13804 "sd_destroypkt_for_buf: exit: buf:0x%p\n", bp);
13805 }
13806
13807 /*
13808 * Function: sd_setup_rw_pkt
13809 *
13810 * Description: Determines appropriate CDB group for the requested LBA
13811 * and transfer length, calls scsi_init_pkt, and builds
13812 * the CDB. Do not use for partial DMA transfers except
13813 * for the initial transfer since the CDB size must
13814 * remain constant.
13815 *
13816 * Context: Kernel thread and may be called from software interrupt
13817 * context as part of a sdrunout callback. This function may not
13818 * block or call routines that block
13819 */
13820
13821
13822 int
13823 sd_setup_rw_pkt(struct sd_lun *un,
13824 struct scsi_pkt **pktpp, struct buf *bp, int flags,
13825 int (*callback)(caddr_t), caddr_t callback_arg,
13826 diskaddr_t lba, uint32_t blockcount)
13827 {
13828 struct scsi_pkt *return_pktp;
13829 union scsi_cdb *cdbp;
13830 struct sd_cdbinfo *cp = NULL;
13831 int i;
13832
13833 /*
13834 * See which size CDB to use, based upon the request.
13835 */
13836 for (i = un->un_mincdb; i <= un->un_maxcdb; i++) {
13837
13838 /*
13839 * Check lba and block count against sd_cdbtab limits.
13840 * In the partial DMA case, we have to use the same size
13841 * CDB for all the transfers. Check lba + blockcount
13842 * against the max LBA so we know that segment of the
13843 * transfer can use the CDB we select.
13844 */
13845 if ((lba + blockcount - 1 <= sd_cdbtab[i].sc_maxlba) &&
13846 (blockcount <= sd_cdbtab[i].sc_maxlen)) {
13847
13848 /*
13849 * The command will fit into the CDB type
13850 * specified by sd_cdbtab[i].
13851 */
13852 cp = sd_cdbtab + i;
13853
13854 /*
13855 * Call scsi_init_pkt so we can fill in the
13856 * CDB.
13857 */
13858 return_pktp = scsi_init_pkt(SD_ADDRESS(un), *pktpp,
13859 bp, cp->sc_grpcode, un->un_status_len, 0,
13860 flags, callback, callback_arg);
13861
13862 if (return_pktp != NULL) {
13863
13864 /*
13865 * Return new value of pkt
13866 */
13867 *pktpp = return_pktp;
13868
13869 /*
13870 * To be safe, zero the CDB insuring there is
13871 * no leftover data from a previous command.
13872 */
13873 bzero(return_pktp->pkt_cdbp, cp->sc_grpcode);
13874
13875 /*
13876 * Handle partial DMA mapping
13877 */
13878 if (return_pktp->pkt_resid != 0) {
13879
13880 /*
13881 * Not going to xfer as many blocks as
13882 * originally expected
13883 */
13884 blockcount -=
13885 SD_BYTES2TGTBLOCKS(un,
13886 return_pktp->pkt_resid);
13887 }
13888
13889 cdbp = (union scsi_cdb *)return_pktp->pkt_cdbp;
13890
13891 /*
13892 * Set command byte based on the CDB
13893 * type we matched.
13894 */
13895 cdbp->scc_cmd = cp->sc_grpmask |
13896 ((bp->b_flags & B_READ) ?
13897 SCMD_READ : SCMD_WRITE);
13898
13899 SD_FILL_SCSI1_LUN(un, return_pktp);
13900
13901 /*
13902 * Fill in LBA and length
13903 */
13904 ASSERT((cp->sc_grpcode == CDB_GROUP1) ||
13905 (cp->sc_grpcode == CDB_GROUP4) ||
13906 (cp->sc_grpcode == CDB_GROUP0) ||
13907 (cp->sc_grpcode == CDB_GROUP5));
13908
13909 if (cp->sc_grpcode == CDB_GROUP1) {
13910 FORMG1ADDR(cdbp, lba);
13911 FORMG1COUNT(cdbp, blockcount);
13912 return (0);
13913 } else if (cp->sc_grpcode == CDB_GROUP4) {
13914 FORMG4LONGADDR(cdbp, lba);
13915 FORMG4COUNT(cdbp, blockcount);
13916 return (0);
13917 } else if (cp->sc_grpcode == CDB_GROUP0) {
13918 FORMG0ADDR(cdbp, lba);
13919 FORMG0COUNT(cdbp, blockcount);
13920 return (0);
13921 } else if (cp->sc_grpcode == CDB_GROUP5) {
13922 FORMG5ADDR(cdbp, lba);
13923 FORMG5COUNT(cdbp, blockcount);
13924 return (0);
13925 }
13926
13927 /*
13928 * It should be impossible to not match one
13929 * of the CDB types above, so we should never
13930 * reach this point. Set the CDB command byte
13931 * to test-unit-ready to avoid writing
13932 * to somewhere we don't intend.
13933 */
13934 cdbp->scc_cmd = SCMD_TEST_UNIT_READY;
13935 return (SD_PKT_ALLOC_FAILURE_CDB_TOO_SMALL);
13936 } else {
13937 /*
13938 * Couldn't get scsi_pkt
13939 */
13940 return (SD_PKT_ALLOC_FAILURE);
13941 }
13942 }
13943 }
13944
13945 /*
13946 * None of the available CDB types were suitable. This really
13947 * should never happen: on a 64 bit system we support
13948 * READ16/WRITE16 which will hold an entire 64 bit disk address
13949 * and on a 32 bit system we will refuse to bind to a device
13950 * larger than 2TB so addresses will never be larger than 32 bits.
13951 */
13952 return (SD_PKT_ALLOC_FAILURE_CDB_TOO_SMALL);
13953 }
13954
13955 /*
13956 * Function: sd_setup_next_rw_pkt
13957 *
13958 * Description: Setup packet for partial DMA transfers, except for the
13959 * initial transfer. sd_setup_rw_pkt should be used for
13960 * the initial transfer.
13961 *
13962 * Context: Kernel thread and may be called from interrupt context.
13963 */
13964
13965 int
13966 sd_setup_next_rw_pkt(struct sd_lun *un,
13967 struct scsi_pkt *pktp, struct buf *bp,
13968 diskaddr_t lba, uint32_t blockcount)
13969 {
13970 uchar_t com;
13971 union scsi_cdb *cdbp;
13972 uchar_t cdb_group_id;
13973
13974 ASSERT(pktp != NULL);
13975 ASSERT(pktp->pkt_cdbp != NULL);
13976
13977 cdbp = (union scsi_cdb *)pktp->pkt_cdbp;
13978 com = cdbp->scc_cmd;
13979 cdb_group_id = CDB_GROUPID(com);
13980
13981 ASSERT((cdb_group_id == CDB_GROUPID_0) ||
13982 (cdb_group_id == CDB_GROUPID_1) ||
13983 (cdb_group_id == CDB_GROUPID_4) ||
13984 (cdb_group_id == CDB_GROUPID_5));
13985
13986 /*
13987 * Move pkt to the next portion of the xfer.
13988 * func is NULL_FUNC so we do not have to release
13989 * the disk mutex here.
13990 */
13991 if (scsi_init_pkt(SD_ADDRESS(un), pktp, bp, 0, 0, 0, 0,
13992 NULL_FUNC, NULL) == pktp) {
13993 /* Success. Handle partial DMA */
13994 if (pktp->pkt_resid != 0) {
13995 blockcount -=
13996 SD_BYTES2TGTBLOCKS(un, pktp->pkt_resid);
13997 }
13998
13999 cdbp->scc_cmd = com;
14000 SD_FILL_SCSI1_LUN(un, pktp);
14001 if (cdb_group_id == CDB_GROUPID_1) {
14002 FORMG1ADDR(cdbp, lba);
14003 FORMG1COUNT(cdbp, blockcount);
14004 return (0);
14005 } else if (cdb_group_id == CDB_GROUPID_4) {
14006 FORMG4LONGADDR(cdbp, lba);
14007 FORMG4COUNT(cdbp, blockcount);
14008 return (0);
14009 } else if (cdb_group_id == CDB_GROUPID_0) {
14010 FORMG0ADDR(cdbp, lba);
14011 FORMG0COUNT(cdbp, blockcount);
14012 return (0);
14013 } else if (cdb_group_id == CDB_GROUPID_5) {
14014 FORMG5ADDR(cdbp, lba);
14015 FORMG5COUNT(cdbp, blockcount);
14016 return (0);
14017 }
14018
14019 /* Unreachable */
14020 return (SD_PKT_ALLOC_FAILURE_CDB_TOO_SMALL);
14021 }
14022
14023 /*
14024 * Error setting up next portion of cmd transfer.
14025 * Something is definitely very wrong and this
14026 * should not happen.
14027 */
14028 return (SD_PKT_ALLOC_FAILURE);
14029 }
14030
14031 /*
14032 * Function: sd_initpkt_for_uscsi
14033 *
14034 * Description: Allocate and initialize for transport a scsi_pkt struct,
14035 * based upon the info specified in the given uscsi_cmd struct.
14036 *
14037 * Return Code: SD_PKT_ALLOC_SUCCESS
14038 * SD_PKT_ALLOC_FAILURE
14039 * SD_PKT_ALLOC_FAILURE_NO_DMA
14040 * SD_PKT_ALLOC_FAILURE_CDB_TOO_SMALL
14041 *
14042 * Context: Kernel thread and may be called from software interrupt context
14043 * as part of a sdrunout callback. This function may not block or
14044 * call routines that block
14045 */
14046
14047 static int
14048 sd_initpkt_for_uscsi(struct buf *bp, struct scsi_pkt **pktpp)
14049 {
14050 struct uscsi_cmd *uscmd;
14051 struct sd_xbuf *xp;
14052 struct scsi_pkt *pktp;
14053 struct sd_lun *un;
14054 uint32_t flags = 0;
14055
14056 ASSERT(bp != NULL);
14057 ASSERT(pktpp != NULL);
14058 xp = SD_GET_XBUF(bp);
14059 ASSERT(xp != NULL);
14060 un = SD_GET_UN(bp);
14061 ASSERT(un != NULL);
14062 ASSERT(mutex_owned(SD_MUTEX(un)));
14063
14064 /* The pointer to the uscsi_cmd struct is expected in xb_pktinfo */
14065 uscmd = (struct uscsi_cmd *)xp->xb_pktinfo;
14066 ASSERT(uscmd != NULL);
14067
14068 SD_TRACE(SD_LOG_IO_CORE, un,
14069 "sd_initpkt_for_uscsi: entry: buf:0x%p\n", bp);
14070
14071 /*
14072 * Allocate the scsi_pkt for the command.
14073 * Note: If PKT_DMA_PARTIAL flag is set, scsi_vhci binds a path
14074 * during scsi_init_pkt time and will continue to use the
14075 * same path as long as the same scsi_pkt is used without
14076 * intervening scsi_dma_free(). Since uscsi command does
14077 * not call scsi_dmafree() before retry failed command, it
14078 * is necessary to make sure PKT_DMA_PARTIAL flag is NOT
14079 * set such that scsi_vhci can use other available path for
14080 * retry. Besides, ucsci command does not allow DMA breakup,
14081 * so there is no need to set PKT_DMA_PARTIAL flag.
14082 */
14083 if (uscmd->uscsi_rqlen > SENSE_LENGTH) {
14084 pktp = scsi_init_pkt(SD_ADDRESS(un), NULL,
14085 ((bp->b_bcount != 0) ? bp : NULL), uscmd->uscsi_cdblen,
14086 ((int)(uscmd->uscsi_rqlen) + sizeof (struct scsi_arq_status)
14087 - sizeof (struct scsi_extended_sense)), 0,
14088 (un->un_pkt_flags & ~PKT_DMA_PARTIAL) | PKT_XARQ,
14089 sdrunout, (caddr_t)un);
14090 } else {
14091 pktp = scsi_init_pkt(SD_ADDRESS(un), NULL,
14092 ((bp->b_bcount != 0) ? bp : NULL), uscmd->uscsi_cdblen,
14093 sizeof (struct scsi_arq_status), 0,
14094 (un->un_pkt_flags & ~PKT_DMA_PARTIAL),
14095 sdrunout, (caddr_t)un);
14096 }
14097
14098 if (pktp == NULL) {
14099 *pktpp = NULL;
14100 /*
14101 * Set the driver state to RWAIT to indicate the driver
14102 * is waiting on resource allocations. The driver will not
14103 * suspend, pm_suspend, or detatch while the state is RWAIT.
14104 */
14105 New_state(un, SD_STATE_RWAIT);
14106
14107 SD_ERROR(SD_LOG_IO_CORE, un,
14108 "sd_initpkt_for_uscsi: No pktp. exit bp:0x%p\n", bp);
14109
14110 if ((bp->b_flags & B_ERROR) != 0) {
14111 return (SD_PKT_ALLOC_FAILURE_NO_DMA);
14112 }
14113 return (SD_PKT_ALLOC_FAILURE);
14114 }
14115
14116 /*
14117 * We do not do DMA breakup for USCSI commands, so return failure
14118 * here if all the needed DMA resources were not allocated.
14119 */
14120 if ((un->un_pkt_flags & PKT_DMA_PARTIAL) &&
14121 (bp->b_bcount != 0) && (pktp->pkt_resid != 0)) {
14122 scsi_destroy_pkt(pktp);
14123 SD_ERROR(SD_LOG_IO_CORE, un, "sd_initpkt_for_uscsi: "
14124 "No partial DMA for USCSI. exit: buf:0x%p\n", bp);
14125 return (SD_PKT_ALLOC_FAILURE_PKT_TOO_SMALL);
14126 }
14127
14128 /* Init the cdb from the given uscsi struct */
14129 (void) scsi_setup_cdb((union scsi_cdb *)pktp->pkt_cdbp,
14130 uscmd->uscsi_cdb[0], 0, 0, 0);
14131
14132 SD_FILL_SCSI1_LUN(un, pktp);
14133
14134 /*
14135 * Set up the optional USCSI flags. See the uscsi (7I) man page
14136 * for listing of the supported flags.
14137 */
14138
14139 if (uscmd->uscsi_flags & USCSI_SILENT) {
14140 flags |= FLAG_SILENT;
14141 }
14142
14143 if (uscmd->uscsi_flags & USCSI_DIAGNOSE) {
14144 flags |= FLAG_DIAGNOSE;
14145 }
14146
14147 if (uscmd->uscsi_flags & USCSI_ISOLATE) {
14148 flags |= FLAG_ISOLATE;
14149 }
14150
14151 if (un->un_f_is_fibre == FALSE) {
14152 if (uscmd->uscsi_flags & USCSI_RENEGOT) {
14153 flags |= FLAG_RENEGOTIATE_WIDE_SYNC;
14154 }
14155 }
14156
14157 /*
14158 * Set the pkt flags here so we save time later.
14159 * Note: These flags are NOT in the uscsi man page!!!
14160 */
14161 if (uscmd->uscsi_flags & USCSI_HEAD) {
14162 flags |= FLAG_HEAD;
14163 }
14164
14165 if (uscmd->uscsi_flags & USCSI_NOINTR) {
14166 flags |= FLAG_NOINTR;
14167 }
14168
14169 /*
14170 * For tagged queueing, things get a bit complicated.
14171 * Check first for head of queue and last for ordered queue.
14172 * If neither head nor order, use the default driver tag flags.
14173 */
14174 if ((uscmd->uscsi_flags & USCSI_NOTAG) == 0) {
14175 if (uscmd->uscsi_flags & USCSI_HTAG) {
14176 flags |= FLAG_HTAG;
14177 } else if (uscmd->uscsi_flags & USCSI_OTAG) {
14178 flags |= FLAG_OTAG;
14179 } else {
14180 flags |= un->un_tagflags & FLAG_TAGMASK;
14181 }
14182 }
14183
14184 if (uscmd->uscsi_flags & USCSI_NODISCON) {
14185 flags = (flags & ~FLAG_TAGMASK) | FLAG_NODISCON;
14186 }
14187
14188 pktp->pkt_flags = flags;
14189
14190 /* Transfer uscsi information to scsi_pkt */
14191 (void) scsi_uscsi_pktinit(uscmd, pktp);
14192
14193 /* Copy the caller's CDB into the pkt... */
14194 bcopy(uscmd->uscsi_cdb, pktp->pkt_cdbp, uscmd->uscsi_cdblen);
14195
14196 if (uscmd->uscsi_timeout == 0) {
14197 pktp->pkt_time = un->un_uscsi_timeout;
14198 } else {
14199 pktp->pkt_time = uscmd->uscsi_timeout;
14200 }
14201
14202 /* need it later to identify USCSI request in sdintr */
14203 xp->xb_pkt_flags |= SD_XB_USCSICMD;
14204
14205 xp->xb_sense_resid = uscmd->uscsi_rqresid;
14206
14207 pktp->pkt_private = bp;
14208 pktp->pkt_comp = sdintr;
14209 *pktpp = pktp;
14210
14211 SD_TRACE(SD_LOG_IO_CORE, un,
14212 "sd_initpkt_for_uscsi: exit: buf:0x%p\n", bp);
14213
14214 return (SD_PKT_ALLOC_SUCCESS);
14215 }
14216
14217
14218 /*
14219 * Function: sd_destroypkt_for_uscsi
14220 *
14221 * Description: Free the scsi_pkt(9S) struct for the given bp, for uscsi
14222 * IOs.. Also saves relevant info into the associated uscsi_cmd
14223 * struct.
14224 *
14225 * Context: May be called under interrupt context
14226 */
14227
14228 static void
14229 sd_destroypkt_for_uscsi(struct buf *bp)
14230 {
14231 struct uscsi_cmd *uscmd;
14232 struct sd_xbuf *xp;
14233 struct scsi_pkt *pktp;
14234 struct sd_lun *un;
14235 struct sd_uscsi_info *suip;
14236
14237 ASSERT(bp != NULL);
14238 xp = SD_GET_XBUF(bp);
14239 ASSERT(xp != NULL);
14240 un = SD_GET_UN(bp);
14241 ASSERT(un != NULL);
14242 ASSERT(!mutex_owned(SD_MUTEX(un)));
14243 pktp = SD_GET_PKTP(bp);
14244 ASSERT(pktp != NULL);
14245
14246 SD_TRACE(SD_LOG_IO_CORE, un,
14247 "sd_destroypkt_for_uscsi: entry: buf:0x%p\n", bp);
14248
14249 /* The pointer to the uscsi_cmd struct is expected in xb_pktinfo */
14250 uscmd = (struct uscsi_cmd *)xp->xb_pktinfo;
14251 ASSERT(uscmd != NULL);
14252
14253 /* Save the status and the residual into the uscsi_cmd struct */
14254 uscmd->uscsi_status = ((*(pktp)->pkt_scbp) & STATUS_MASK);
14255 uscmd->uscsi_resid = bp->b_resid;
14256
14257 /* Transfer scsi_pkt information to uscsi */
14258 (void) scsi_uscsi_pktfini(pktp, uscmd);
14259
14260 /*
14261 * If enabled, copy any saved sense data into the area specified
14262 * by the uscsi command.
14263 */
14264 if (((uscmd->uscsi_flags & USCSI_RQENABLE) != 0) &&
14265 (uscmd->uscsi_rqlen != 0) && (uscmd->uscsi_rqbuf != NULL)) {
14266 /*
14267 * Note: uscmd->uscsi_rqbuf should always point to a buffer
14268 * at least SENSE_LENGTH bytes in size (see sd_send_scsi_cmd())
14269 */
14270 uscmd->uscsi_rqstatus = xp->xb_sense_status;
14271 uscmd->uscsi_rqresid = xp->xb_sense_resid;
14272 if (uscmd->uscsi_rqlen > SENSE_LENGTH) {
14273 bcopy(xp->xb_sense_data, uscmd->uscsi_rqbuf,
14274 MAX_SENSE_LENGTH);
14275 } else {
14276 bcopy(xp->xb_sense_data, uscmd->uscsi_rqbuf,
14277 SENSE_LENGTH);
14278 }
14279 }
14280 /*
14281 * The following assignments are for SCSI FMA.
14282 */
14283 ASSERT(xp->xb_private != NULL);
14284 suip = (struct sd_uscsi_info *)xp->xb_private;
14285 suip->ui_pkt_reason = pktp->pkt_reason;
14286 suip->ui_pkt_state = pktp->pkt_state;
14287 suip->ui_pkt_statistics = pktp->pkt_statistics;
14288 suip->ui_lba = (uint64_t)SD_GET_BLKNO(bp);
14289
14290 /* We are done with the scsi_pkt; free it now */
14291 ASSERT(SD_GET_PKTP(bp) != NULL);
14292 scsi_destroy_pkt(SD_GET_PKTP(bp));
14293
14294 SD_TRACE(SD_LOG_IO_CORE, un,
14295 "sd_destroypkt_for_uscsi: exit: buf:0x%p\n", bp);
14296 }
14297
14298
14299 /*
14300 * Function: sd_bioclone_alloc
14301 *
14302 * Description: Allocate a buf(9S) and init it as per the given buf
14303 * and the various arguments. The associated sd_xbuf
14304 * struct is (nearly) duplicated. The struct buf *bp
14305 * argument is saved in new_xp->xb_private.
14306 *
14307 * Arguments: bp - ptr the the buf(9S) to be "shadowed"
14308 * datalen - size of data area for the shadow bp
14309 * blkno - starting LBA
14310 * func - function pointer for b_iodone in the shadow buf. (May
14311 * be NULL if none.)
14312 *
14313 * Return Code: Pointer to allocates buf(9S) struct
14314 *
14315 * Context: Can sleep.
14316 */
14317
14318 static struct buf *
14319 sd_bioclone_alloc(struct buf *bp, size_t datalen, daddr_t blkno,
14320 int (*func)(struct buf *))
14321 {
14322 struct sd_lun *un;
14323 struct sd_xbuf *xp;
14324 struct sd_xbuf *new_xp;
14325 struct buf *new_bp;
14326
14327 ASSERT(bp != NULL);
14328 xp = SD_GET_XBUF(bp);
14329 ASSERT(xp != NULL);
14330 un = SD_GET_UN(bp);
14331 ASSERT(un != NULL);
14332 ASSERT(!mutex_owned(SD_MUTEX(un)));
14333
14334 new_bp = bioclone(bp, 0, datalen, SD_GET_DEV(un), blkno, func,
14335 NULL, KM_SLEEP);
14336
14337 new_bp->b_lblkno = blkno;
14338
14339 /*
14340 * Allocate an xbuf for the shadow bp and copy the contents of the
14341 * original xbuf into it.
14342 */
14343 new_xp = kmem_alloc(sizeof (struct sd_xbuf), KM_SLEEP);
14344 bcopy(xp, new_xp, sizeof (struct sd_xbuf));
14345
14346 /*
14347 * The given bp is automatically saved in the xb_private member
14348 * of the new xbuf. Callers are allowed to depend on this.
14349 */
14350 new_xp->xb_private = bp;
14351
14352 new_bp->b_private = new_xp;
14353
14354 return (new_bp);
14355 }
14356
14357 /*
14358 * Function: sd_shadow_buf_alloc
14359 *
14360 * Description: Allocate a buf(9S) and init it as per the given buf
14361 * and the various arguments. The associated sd_xbuf
14362 * struct is (nearly) duplicated. The struct buf *bp
14363 * argument is saved in new_xp->xb_private.
14364 *
14365 * Arguments: bp - ptr the the buf(9S) to be "shadowed"
14366 * datalen - size of data area for the shadow bp
14367 * bflags - B_READ or B_WRITE (pseudo flag)
14368 * blkno - starting LBA
14369 * func - function pointer for b_iodone in the shadow buf. (May
14370 * be NULL if none.)
14371 *
14372 * Return Code: Pointer to allocates buf(9S) struct
14373 *
14374 * Context: Can sleep.
14375 */
14376
14377 static struct buf *
14378 sd_shadow_buf_alloc(struct buf *bp, size_t datalen, uint_t bflags,
14379 daddr_t blkno, int (*func)(struct buf *))
14380 {
14381 struct sd_lun *un;
14382 struct sd_xbuf *xp;
14383 struct sd_xbuf *new_xp;
14384 struct buf *new_bp;
14385
14386 ASSERT(bp != NULL);
14387 xp = SD_GET_XBUF(bp);
14388 ASSERT(xp != NULL);
14389 un = SD_GET_UN(bp);
14390 ASSERT(un != NULL);
14391 ASSERT(!mutex_owned(SD_MUTEX(un)));
14392
14393 if (bp->b_flags & (B_PAGEIO | B_PHYS)) {
14394 bp_mapin(bp);
14395 }
14396
14397 bflags &= (B_READ | B_WRITE);
14398 #if defined(__i386) || defined(__amd64)
14399 new_bp = getrbuf(KM_SLEEP);
14400 new_bp->b_un.b_addr = kmem_zalloc(datalen, KM_SLEEP);
14401 new_bp->b_bcount = datalen;
14402 new_bp->b_flags = bflags |
14403 (bp->b_flags & ~(B_PAGEIO | B_PHYS | B_REMAPPED | B_SHADOW));
14404 #else
14405 new_bp = scsi_alloc_consistent_buf(SD_ADDRESS(un), NULL,
14406 datalen, bflags, SLEEP_FUNC, NULL);
14407 #endif
14408 new_bp->av_forw = NULL;
14409 new_bp->av_back = NULL;
14410 new_bp->b_dev = bp->b_dev;
14411 new_bp->b_blkno = blkno;
14412 new_bp->b_iodone = func;
14413 new_bp->b_edev = bp->b_edev;
14414 new_bp->b_resid = 0;
14415
14416 /* We need to preserve the B_FAILFAST flag */
14417 if (bp->b_flags & B_FAILFAST) {
14418 new_bp->b_flags |= B_FAILFAST;
14419 }
14420
14421 /*
14422 * Allocate an xbuf for the shadow bp and copy the contents of the
14423 * original xbuf into it.
14424 */
14425 new_xp = kmem_alloc(sizeof (struct sd_xbuf), KM_SLEEP);
14426 bcopy(xp, new_xp, sizeof (struct sd_xbuf));
14427
14428 /* Need later to copy data between the shadow buf & original buf! */
14429 new_xp->xb_pkt_flags |= PKT_CONSISTENT;
14430
14431 /*
14432 * The given bp is automatically saved in the xb_private member
14433 * of the new xbuf. Callers are allowed to depend on this.
14434 */
14435 new_xp->xb_private = bp;
14436
14437 new_bp->b_private = new_xp;
14438
14439 return (new_bp);
14440 }
14441
14442 /*
14443 * Function: sd_bioclone_free
14444 *
14445 * Description: Deallocate a buf(9S) that was used for 'shadow' IO operations
14446 * in the larger than partition operation.
14447 *
14448 * Context: May be called under interrupt context
14449 */
14450
14451 static void
14452 sd_bioclone_free(struct buf *bp)
14453 {
14454 struct sd_xbuf *xp;
14455
14456 ASSERT(bp != NULL);
14457 xp = SD_GET_XBUF(bp);
14458 ASSERT(xp != NULL);
14459
14460 /*
14461 * Call bp_mapout() before freeing the buf, in case a lower
14462 * layer or HBA had done a bp_mapin(). we must do this here
14463 * as we are the "originator" of the shadow buf.
14464 */
14465 bp_mapout(bp);
14466
14467 /*
14468 * Null out b_iodone before freeing the bp, to ensure that the driver
14469 * never gets confused by a stale value in this field. (Just a little
14470 * extra defensiveness here.)
14471 */
14472 bp->b_iodone = NULL;
14473
14474 freerbuf(bp);
14475
14476 kmem_free(xp, sizeof (struct sd_xbuf));
14477 }
14478
14479 /*
14480 * Function: sd_shadow_buf_free
14481 *
14482 * Description: Deallocate a buf(9S) that was used for 'shadow' IO operations.
14483 *
14484 * Context: May be called under interrupt context
14485 */
14486
14487 static void
14488 sd_shadow_buf_free(struct buf *bp)
14489 {
14490 struct sd_xbuf *xp;
14491
14492 ASSERT(bp != NULL);
14493 xp = SD_GET_XBUF(bp);
14494 ASSERT(xp != NULL);
14495
14496 #if defined(__sparc)
14497 /*
14498 * Call bp_mapout() before freeing the buf, in case a lower
14499 * layer or HBA had done a bp_mapin(). we must do this here
14500 * as we are the "originator" of the shadow buf.
14501 */
14502 bp_mapout(bp);
14503 #endif
14504
14505 /*
14506 * Null out b_iodone before freeing the bp, to ensure that the driver
14507 * never gets confused by a stale value in this field. (Just a little
14508 * extra defensiveness here.)
14509 */
14510 bp->b_iodone = NULL;
14511
14512 #if defined(__i386) || defined(__amd64)
14513 kmem_free(bp->b_un.b_addr, bp->b_bcount);
14514 freerbuf(bp);
14515 #else
14516 scsi_free_consistent_buf(bp);
14517 #endif
14518
14519 kmem_free(xp, sizeof (struct sd_xbuf));
14520 }
14521
14522
14523 /*
14524 * Function: sd_print_transport_rejected_message
14525 *
14526 * Description: This implements the ludicrously complex rules for printing
14527 * a "transport rejected" message. This is to address the
14528 * specific problem of having a flood of this error message
14529 * produced when a failover occurs.
14530 *
14531 * Context: Any.
14532 */
14533
14534 static void
14535 sd_print_transport_rejected_message(struct sd_lun *un, struct sd_xbuf *xp,
14536 int code)
14537 {
14538 ASSERT(un != NULL);
14539 ASSERT(mutex_owned(SD_MUTEX(un)));
14540 ASSERT(xp != NULL);
14541
14542 /*
14543 * Print the "transport rejected" message under the following
14544 * conditions:
14545 *
14546 * - Whenever the SD_LOGMASK_DIAG bit of sd_level_mask is set
14547 * - The error code from scsi_transport() is NOT a TRAN_FATAL_ERROR.
14548 * - If the error code IS a TRAN_FATAL_ERROR, then the message is
14549 * printed the FIRST time a TRAN_FATAL_ERROR is returned from
14550 * scsi_transport(9F) (which indicates that the target might have
14551 * gone off-line). This uses the un->un_tran_fatal_count
14552 * count, which is incremented whenever a TRAN_FATAL_ERROR is
14553 * received, and reset to zero whenver a TRAN_ACCEPT is returned
14554 * from scsi_transport().
14555 *
14556 * The FLAG_SILENT in the scsi_pkt must be CLEARED in ALL of
14557 * the preceeding cases in order for the message to be printed.
14558 */
14559 if (((xp->xb_pktp->pkt_flags & FLAG_SILENT) == 0) &&
14560 (SD_FM_LOG(un) == SD_FM_LOG_NSUP)) {
14561 if ((sd_level_mask & SD_LOGMASK_DIAG) ||
14562 (code != TRAN_FATAL_ERROR) ||
14563 (un->un_tran_fatal_count == 1)) {
14564 switch (code) {
14565 case TRAN_BADPKT:
14566 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
14567 "transport rejected bad packet\n");
14568 break;
14569 case TRAN_FATAL_ERROR:
14570 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
14571 "transport rejected fatal error\n");
14572 break;
14573 default:
14574 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
14575 "transport rejected (%d)\n", code);
14576 break;
14577 }
14578 }
14579 }
14580 }
14581
14582
14583 /*
14584 * Function: sd_add_buf_to_waitq
14585 *
14586 * Description: Add the given buf(9S) struct to the wait queue for the
14587 * instance. If sorting is enabled, then the buf is added
14588 * to the queue via an elevator sort algorithm (a la
14589 * disksort(9F)). The SD_GET_BLKNO(bp) is used as the sort key.
14590 * If sorting is not enabled, then the buf is just added
14591 * to the end of the wait queue.
14592 *
14593 * Return Code: void
14594 *
14595 * Context: Does not sleep/block, therefore technically can be called
14596 * from any context. However if sorting is enabled then the
14597 * execution time is indeterminate, and may take long if
14598 * the wait queue grows large.
14599 */
14600
14601 static void
14602 sd_add_buf_to_waitq(struct sd_lun *un, struct buf *bp)
14603 {
14604 struct buf *ap;
14605
14606 ASSERT(bp != NULL);
14607 ASSERT(un != NULL);
14608 ASSERT(mutex_owned(SD_MUTEX(un)));
14609
14610 /* If the queue is empty, add the buf as the only entry & return. */
14611 if (un->un_waitq_headp == NULL) {
14612 ASSERT(un->un_waitq_tailp == NULL);
14613 un->un_waitq_headp = un->un_waitq_tailp = bp;
14614 bp->av_forw = NULL;
14615 return;
14616 }
14617
14618 ASSERT(un->un_waitq_tailp != NULL);
14619
14620 /*
14621 * If sorting is disabled, just add the buf to the tail end of
14622 * the wait queue and return.
14623 */
14624 if (un->un_f_disksort_disabled || un->un_f_enable_rmw) {
14625 un->un_waitq_tailp->av_forw = bp;
14626 un->un_waitq_tailp = bp;
14627 bp->av_forw = NULL;
14628 return;
14629 }
14630
14631 /*
14632 * Sort thru the list of requests currently on the wait queue
14633 * and add the new buf request at the appropriate position.
14634 *
14635 * The un->un_waitq_headp is an activity chain pointer on which
14636 * we keep two queues, sorted in ascending SD_GET_BLKNO() order. The
14637 * first queue holds those requests which are positioned after
14638 * the current SD_GET_BLKNO() (in the first request); the second holds
14639 * requests which came in after their SD_GET_BLKNO() number was passed.
14640 * Thus we implement a one way scan, retracting after reaching
14641 * the end of the drive to the first request on the second
14642 * queue, at which time it becomes the first queue.
14643 * A one-way scan is natural because of the way UNIX read-ahead
14644 * blocks are allocated.
14645 *
14646 * If we lie after the first request, then we must locate the
14647 * second request list and add ourselves to it.
14648 */
14649 ap = un->un_waitq_headp;
14650 if (SD_GET_BLKNO(bp) < SD_GET_BLKNO(ap)) {
14651 while (ap->av_forw != NULL) {
14652 /*
14653 * Look for an "inversion" in the (normally
14654 * ascending) block numbers. This indicates
14655 * the start of the second request list.
14656 */
14657 if (SD_GET_BLKNO(ap->av_forw) < SD_GET_BLKNO(ap)) {
14658 /*
14659 * Search the second request list for the
14660 * first request at a larger block number.
14661 * We go before that; however if there is
14662 * no such request, we go at the end.
14663 */
14664 do {
14665 if (SD_GET_BLKNO(bp) <
14666 SD_GET_BLKNO(ap->av_forw)) {
14667 goto insert;
14668 }
14669 ap = ap->av_forw;
14670 } while (ap->av_forw != NULL);
14671 goto insert; /* after last */
14672 }
14673 ap = ap->av_forw;
14674 }
14675
14676 /*
14677 * No inversions... we will go after the last, and
14678 * be the first request in the second request list.
14679 */
14680 goto insert;
14681 }
14682
14683 /*
14684 * Request is at/after the current request...
14685 * sort in the first request list.
14686 */
14687 while (ap->av_forw != NULL) {
14688 /*
14689 * We want to go after the current request (1) if
14690 * there is an inversion after it (i.e. it is the end
14691 * of the first request list), or (2) if the next
14692 * request is a larger block no. than our request.
14693 */
14694 if ((SD_GET_BLKNO(ap->av_forw) < SD_GET_BLKNO(ap)) ||
14695 (SD_GET_BLKNO(bp) < SD_GET_BLKNO(ap->av_forw))) {
14696 goto insert;
14697 }
14698 ap = ap->av_forw;
14699 }
14700
14701 /*
14702 * Neither a second list nor a larger request, therefore
14703 * we go at the end of the first list (which is the same
14704 * as the end of the whole schebang).
14705 */
14706 insert:
14707 bp->av_forw = ap->av_forw;
14708 ap->av_forw = bp;
14709
14710 /*
14711 * If we inserted onto the tail end of the waitq, make sure the
14712 * tail pointer is updated.
14713 */
14714 if (ap == un->un_waitq_tailp) {
14715 un->un_waitq_tailp = bp;
14716 }
14717 }
14718
14719
14720 /*
14721 * Function: sd_start_cmds
14722 *
14723 * Description: Remove and transport cmds from the driver queues.
14724 *
14725 * Arguments: un - pointer to the unit (soft state) struct for the target.
14726 *
14727 * immed_bp - ptr to a buf to be transported immediately. Only
14728 * the immed_bp is transported; bufs on the waitq are not
14729 * processed and the un_retry_bp is not checked. If immed_bp is
14730 * NULL, then normal queue processing is performed.
14731 *
14732 * Context: May be called from kernel thread context, interrupt context,
14733 * or runout callback context. This function may not block or
14734 * call routines that block.
14735 */
14736
14737 static void
14738 sd_start_cmds(struct sd_lun *un, struct buf *immed_bp)
14739 {
14740 struct sd_xbuf *xp;
14741 struct buf *bp;
14742 void (*statp)(kstat_io_t *);
14743 #if defined(__i386) || defined(__amd64) /* DMAFREE for x86 only */
14744 void (*saved_statp)(kstat_io_t *);
14745 #endif
14746 int rval;
14747 struct sd_fm_internal *sfip = NULL;
14748
14749 ASSERT(un != NULL);
14750 ASSERT(mutex_owned(SD_MUTEX(un)));
14751 ASSERT(un->un_ncmds_in_transport >= 0);
14752 ASSERT(un->un_throttle >= 0);
14753
14754 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_start_cmds: entry\n");
14755
14756 do {
14757 #if defined(__i386) || defined(__amd64) /* DMAFREE for x86 only */
14758 saved_statp = NULL;
14759 #endif
14760
14761 /*
14762 * If we are syncing or dumping, fail the command to
14763 * avoid recursively calling back into scsi_transport().
14764 * The dump I/O itself uses a separate code path so this
14765 * only prevents non-dump I/O from being sent while dumping.
14766 * File system sync takes place before dumping begins.
14767 * During panic, filesystem I/O is allowed provided
14768 * un_in_callback is <= 1. This is to prevent recursion
14769 * such as sd_start_cmds -> scsi_transport -> sdintr ->
14770 * sd_start_cmds and so on. See panic.c for more information
14771 * about the states the system can be in during panic.
14772 */
14773 if ((un->un_state == SD_STATE_DUMPING) ||
14774 (ddi_in_panic() && (un->un_in_callback > 1))) {
14775 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
14776 "sd_start_cmds: panicking\n");
14777 goto exit;
14778 }
14779
14780 if ((bp = immed_bp) != NULL) {
14781 /*
14782 * We have a bp that must be transported immediately.
14783 * It's OK to transport the immed_bp here without doing
14784 * the throttle limit check because the immed_bp is
14785 * always used in a retry/recovery case. This means
14786 * that we know we are not at the throttle limit by
14787 * virtue of the fact that to get here we must have
14788 * already gotten a command back via sdintr(). This also
14789 * relies on (1) the command on un_retry_bp preventing
14790 * further commands from the waitq from being issued;
14791 * and (2) the code in sd_retry_command checking the
14792 * throttle limit before issuing a delayed or immediate
14793 * retry. This holds even if the throttle limit is
14794 * currently ratcheted down from its maximum value.
14795 */
14796 statp = kstat_runq_enter;
14797 if (bp == un->un_retry_bp) {
14798 ASSERT((un->un_retry_statp == NULL) ||
14799 (un->un_retry_statp == kstat_waitq_enter) ||
14800 (un->un_retry_statp ==
14801 kstat_runq_back_to_waitq));
14802 /*
14803 * If the waitq kstat was incremented when
14804 * sd_set_retry_bp() queued this bp for a retry,
14805 * then we must set up statp so that the waitq
14806 * count will get decremented correctly below.
14807 * Also we must clear un->un_retry_statp to
14808 * ensure that we do not act on a stale value
14809 * in this field.
14810 */
14811 if ((un->un_retry_statp == kstat_waitq_enter) ||
14812 (un->un_retry_statp ==
14813 kstat_runq_back_to_waitq)) {
14814 statp = kstat_waitq_to_runq;
14815 }
14816 #if defined(__i386) || defined(__amd64) /* DMAFREE for x86 only */
14817 saved_statp = un->un_retry_statp;
14818 #endif
14819 un->un_retry_statp = NULL;
14820
14821 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un,
14822 "sd_start_cmds: un:0x%p: GOT retry_bp:0x%p "
14823 "un_throttle:%d un_ncmds_in_transport:%d\n",
14824 un, un->un_retry_bp, un->un_throttle,
14825 un->un_ncmds_in_transport);
14826 } else {
14827 SD_TRACE(SD_LOG_IO_CORE, un, "sd_start_cmds: "
14828 "processing priority bp:0x%p\n", bp);
14829 }
14830
14831 } else if ((bp = un->un_waitq_headp) != NULL) {
14832 /*
14833 * A command on the waitq is ready to go, but do not
14834 * send it if:
14835 *
14836 * (1) the throttle limit has been reached, or
14837 * (2) a retry is pending, or
14838 * (3) a START_STOP_UNIT callback pending, or
14839 * (4) a callback for a SD_PATH_DIRECT_PRIORITY
14840 * command is pending.
14841 *
14842 * For all of these conditions, IO processing will
14843 * restart after the condition is cleared.
14844 */
14845 if (un->un_ncmds_in_transport >= un->un_throttle) {
14846 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
14847 "sd_start_cmds: exiting, "
14848 "throttle limit reached!\n");
14849 goto exit;
14850 }
14851 if (un->un_retry_bp != NULL) {
14852 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
14853 "sd_start_cmds: exiting, retry pending!\n");
14854 goto exit;
14855 }
14856 if (un->un_startstop_timeid != NULL) {
14857 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
14858 "sd_start_cmds: exiting, "
14859 "START_STOP pending!\n");
14860 goto exit;
14861 }
14862 if (un->un_direct_priority_timeid != NULL) {
14863 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
14864 "sd_start_cmds: exiting, "
14865 "SD_PATH_DIRECT_PRIORITY cmd. pending!\n");
14866 goto exit;
14867 }
14868
14869 /* Dequeue the command */
14870 un->un_waitq_headp = bp->av_forw;
14871 if (un->un_waitq_headp == NULL) {
14872 un->un_waitq_tailp = NULL;
14873 }
14874 bp->av_forw = NULL;
14875 statp = kstat_waitq_to_runq;
14876 SD_TRACE(SD_LOG_IO_CORE, un,
14877 "sd_start_cmds: processing waitq bp:0x%p\n", bp);
14878
14879 } else {
14880 /* No work to do so bail out now */
14881 SD_TRACE(SD_LOG_IO_CORE, un,
14882 "sd_start_cmds: no more work, exiting!\n");
14883 goto exit;
14884 }
14885
14886 /*
14887 * Reset the state to normal. This is the mechanism by which
14888 * the state transitions from either SD_STATE_RWAIT or
14889 * SD_STATE_OFFLINE to SD_STATE_NORMAL.
14890 * If state is SD_STATE_PM_CHANGING then this command is
14891 * part of the device power control and the state must
14892 * not be put back to normal. Doing so would would
14893 * allow new commands to proceed when they shouldn't,
14894 * the device may be going off.
14895 */
14896 if ((un->un_state != SD_STATE_SUSPENDED) &&
14897 (un->un_state != SD_STATE_PM_CHANGING)) {
14898 New_state(un, SD_STATE_NORMAL);
14899 }
14900
14901 xp = SD_GET_XBUF(bp);
14902 ASSERT(xp != NULL);
14903
14904 #if defined(__i386) || defined(__amd64) /* DMAFREE for x86 only */
14905 /*
14906 * Allocate the scsi_pkt if we need one, or attach DMA
14907 * resources if we have a scsi_pkt that needs them. The
14908 * latter should only occur for commands that are being
14909 * retried.
14910 */
14911 if ((xp->xb_pktp == NULL) ||
14912 ((xp->xb_pkt_flags & SD_XB_DMA_FREED) != 0)) {
14913 #else
14914 if (xp->xb_pktp == NULL) {
14915 #endif
14916 /*
14917 * There is no scsi_pkt allocated for this buf. Call
14918 * the initpkt function to allocate & init one.
14919 *
14920 * The scsi_init_pkt runout callback functionality is
14921 * implemented as follows:
14922 *
14923 * 1) The initpkt function always calls
14924 * scsi_init_pkt(9F) with sdrunout specified as the
14925 * callback routine.
14926 * 2) A successful packet allocation is initialized and
14927 * the I/O is transported.
14928 * 3) The I/O associated with an allocation resource
14929 * failure is left on its queue to be retried via
14930 * runout or the next I/O.
14931 * 4) The I/O associated with a DMA error is removed
14932 * from the queue and failed with EIO. Processing of
14933 * the transport queues is also halted to be
14934 * restarted via runout or the next I/O.
14935 * 5) The I/O associated with a CDB size or packet
14936 * size error is removed from the queue and failed
14937 * with EIO. Processing of the transport queues is
14938 * continued.
14939 *
14940 * Note: there is no interface for canceling a runout
14941 * callback. To prevent the driver from detaching or
14942 * suspending while a runout is pending the driver
14943 * state is set to SD_STATE_RWAIT
14944 *
14945 * Note: using the scsi_init_pkt callback facility can
14946 * result in an I/O request persisting at the head of
14947 * the list which cannot be satisfied even after
14948 * multiple retries. In the future the driver may
14949 * implement some kind of maximum runout count before
14950 * failing an I/O.
14951 *
14952 * Note: the use of funcp below may seem superfluous,
14953 * but it helps warlock figure out the correct
14954 * initpkt function calls (see [s]sd.wlcmd).
14955 */
14956 struct scsi_pkt *pktp;
14957 int (*funcp)(struct buf *bp, struct scsi_pkt **pktp);
14958
14959 ASSERT(bp != un->un_rqs_bp);
14960
14961 funcp = sd_initpkt_map[xp->xb_chain_iostart];
14962 switch ((*funcp)(bp, &pktp)) {
14963 case SD_PKT_ALLOC_SUCCESS:
14964 xp->xb_pktp = pktp;
14965 SD_TRACE(SD_LOG_IO_CORE, un,
14966 "sd_start_cmd: SD_PKT_ALLOC_SUCCESS 0x%p\n",
14967 pktp);
14968 goto got_pkt;
14969
14970 case SD_PKT_ALLOC_FAILURE:
14971 /*
14972 * Temporary (hopefully) resource depletion.
14973 * Since retries and RQS commands always have a
14974 * scsi_pkt allocated, these cases should never
14975 * get here. So the only cases this needs to
14976 * handle is a bp from the waitq (which we put
14977 * back onto the waitq for sdrunout), or a bp
14978 * sent as an immed_bp (which we just fail).
14979 */
14980 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
14981 "sd_start_cmds: SD_PKT_ALLOC_FAILURE\n");
14982
14983 #if defined(__i386) || defined(__amd64) /* DMAFREE for x86 only */
14984
14985 if (bp == immed_bp) {
14986 /*
14987 * If SD_XB_DMA_FREED is clear, then
14988 * this is a failure to allocate a
14989 * scsi_pkt, and we must fail the
14990 * command.
14991 */
14992 if ((xp->xb_pkt_flags &
14993 SD_XB_DMA_FREED) == 0) {
14994 break;
14995 }
14996
14997 /*
14998 * If this immediate command is NOT our
14999 * un_retry_bp, then we must fail it.
15000 */
15001 if (bp != un->un_retry_bp) {
15002 break;
15003 }
15004
15005 /*
15006 * We get here if this cmd is our
15007 * un_retry_bp that was DMAFREED, but
15008 * scsi_init_pkt() failed to reallocate
15009 * DMA resources when we attempted to
15010 * retry it. This can happen when an
15011 * mpxio failover is in progress, but
15012 * we don't want to just fail the
15013 * command in this case.
15014 *
15015 * Use timeout(9F) to restart it after
15016 * a 100ms delay. We don't want to
15017 * let sdrunout() restart it, because
15018 * sdrunout() is just supposed to start
15019 * commands that are sitting on the
15020 * wait queue. The un_retry_bp stays
15021 * set until the command completes, but
15022 * sdrunout can be called many times
15023 * before that happens. Since sdrunout
15024 * cannot tell if the un_retry_bp is
15025 * already in the transport, it could
15026 * end up calling scsi_transport() for
15027 * the un_retry_bp multiple times.
15028 *
15029 * Also: don't schedule the callback
15030 * if some other callback is already
15031 * pending.
15032 */
15033 if (un->un_retry_statp == NULL) {
15034 /*
15035 * restore the kstat pointer to
15036 * keep kstat counts coherent
15037 * when we do retry the command.
15038 */
15039 un->un_retry_statp =
15040 saved_statp;
15041 }
15042
15043 if ((un->un_startstop_timeid == NULL) &&
15044 (un->un_retry_timeid == NULL) &&
15045 (un->un_direct_priority_timeid ==
15046 NULL)) {
15047
15048 un->un_retry_timeid =
15049 timeout(
15050 sd_start_retry_command,
15051 un, SD_RESTART_TIMEOUT);
15052 }
15053 goto exit;
15054 }
15055
15056 #else
15057 if (bp == immed_bp) {
15058 break; /* Just fail the command */
15059 }
15060 #endif
15061
15062 /* Add the buf back to the head of the waitq */
15063 bp->av_forw = un->un_waitq_headp;
15064 un->un_waitq_headp = bp;
15065 if (un->un_waitq_tailp == NULL) {
15066 un->un_waitq_tailp = bp;
15067 }
15068 goto exit;
15069
15070 case SD_PKT_ALLOC_FAILURE_NO_DMA:
15071 /*
15072 * HBA DMA resource failure. Fail the command
15073 * and continue processing of the queues.
15074 */
15075 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15076 "sd_start_cmds: "
15077 "SD_PKT_ALLOC_FAILURE_NO_DMA\n");
15078 break;
15079
15080 case SD_PKT_ALLOC_FAILURE_PKT_TOO_SMALL:
15081 /*
15082 * Note:x86: Partial DMA mapping not supported
15083 * for USCSI commands, and all the needed DMA
15084 * resources were not allocated.
15085 */
15086 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15087 "sd_start_cmds: "
15088 "SD_PKT_ALLOC_FAILURE_PKT_TOO_SMALL\n");
15089 break;
15090
15091 case SD_PKT_ALLOC_FAILURE_CDB_TOO_SMALL:
15092 /*
15093 * Note:x86: Request cannot fit into CDB based
15094 * on lba and len.
15095 */
15096 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15097 "sd_start_cmds: "
15098 "SD_PKT_ALLOC_FAILURE_CDB_TOO_SMALL\n");
15099 break;
15100
15101 default:
15102 /* Should NEVER get here! */
15103 panic("scsi_initpkt error");
15104 /*NOTREACHED*/
15105 }
15106
15107 /*
15108 * Fatal error in allocating a scsi_pkt for this buf.
15109 * Update kstats & return the buf with an error code.
15110 * We must use sd_return_failed_command_no_restart() to
15111 * avoid a recursive call back into sd_start_cmds().
15112 * However this also means that we must keep processing
15113 * the waitq here in order to avoid stalling.
15114 */
15115 if (statp == kstat_waitq_to_runq) {
15116 SD_UPDATE_KSTATS(un, kstat_waitq_exit, bp);
15117 }
15118 sd_return_failed_command_no_restart(un, bp, EIO);
15119 if (bp == immed_bp) {
15120 /* immed_bp is gone by now, so clear this */
15121 immed_bp = NULL;
15122 }
15123 continue;
15124 }
15125 got_pkt:
15126 if (bp == immed_bp) {
15127 /* goto the head of the class.... */
15128 xp->xb_pktp->pkt_flags |= FLAG_HEAD;
15129 }
15130
15131 un->un_ncmds_in_transport++;
15132 SD_UPDATE_KSTATS(un, statp, bp);
15133
15134 /*
15135 * Call scsi_transport() to send the command to the target.
15136 * According to SCSA architecture, we must drop the mutex here
15137 * before calling scsi_transport() in order to avoid deadlock.
15138 * Note that the scsi_pkt's completion routine can be executed
15139 * (from interrupt context) even before the call to
15140 * scsi_transport() returns.
15141 */
15142 SD_TRACE(SD_LOG_IO_CORE, un,
15143 "sd_start_cmds: calling scsi_transport()\n");
15144 DTRACE_PROBE1(scsi__transport__dispatch, struct buf *, bp);
15145
15146 mutex_exit(SD_MUTEX(un));
15147 rval = scsi_transport(xp->xb_pktp);
15148 mutex_enter(SD_MUTEX(un));
15149
15150 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15151 "sd_start_cmds: scsi_transport() returned %d\n", rval);
15152
15153 switch (rval) {
15154 case TRAN_ACCEPT:
15155 /* Clear this with every pkt accepted by the HBA */
15156 un->un_tran_fatal_count = 0;
15157 break; /* Success; try the next cmd (if any) */
15158
15159 case TRAN_BUSY:
15160 un->un_ncmds_in_transport--;
15161 ASSERT(un->un_ncmds_in_transport >= 0);
15162
15163 /*
15164 * Don't retry request sense, the sense data
15165 * is lost when another request is sent.
15166 * Free up the rqs buf and retry
15167 * the original failed cmd. Update kstat.
15168 */
15169 if (bp == un->un_rqs_bp) {
15170 SD_UPDATE_KSTATS(un, kstat_runq_exit, bp);
15171 bp = sd_mark_rqs_idle(un, xp);
15172 sd_retry_command(un, bp, SD_RETRIES_STANDARD,
15173 NULL, NULL, EIO, un->un_busy_timeout / 500,
15174 kstat_waitq_enter);
15175 goto exit;
15176 }
15177
15178 #if defined(__i386) || defined(__amd64) /* DMAFREE for x86 only */
15179 /*
15180 * Free the DMA resources for the scsi_pkt. This will
15181 * allow mpxio to select another path the next time
15182 * we call scsi_transport() with this scsi_pkt.
15183 * See sdintr() for the rationalization behind this.
15184 */
15185 if ((un->un_f_is_fibre == TRUE) &&
15186 ((xp->xb_pkt_flags & SD_XB_USCSICMD) == 0) &&
15187 ((xp->xb_pktp->pkt_flags & FLAG_SENSING) == 0)) {
15188 scsi_dmafree(xp->xb_pktp);
15189 xp->xb_pkt_flags |= SD_XB_DMA_FREED;
15190 }
15191 #endif
15192
15193 if (SD_IS_DIRECT_PRIORITY(SD_GET_XBUF(bp))) {
15194 /*
15195 * Commands that are SD_PATH_DIRECT_PRIORITY
15196 * are for error recovery situations. These do
15197 * not use the normal command waitq, so if they
15198 * get a TRAN_BUSY we cannot put them back onto
15199 * the waitq for later retry. One possible
15200 * problem is that there could already be some
15201 * other command on un_retry_bp that is waiting
15202 * for this one to complete, so we would be
15203 * deadlocked if we put this command back onto
15204 * the waitq for later retry (since un_retry_bp
15205 * must complete before the driver gets back to
15206 * commands on the waitq).
15207 *
15208 * To avoid deadlock we must schedule a callback
15209 * that will restart this command after a set
15210 * interval. This should keep retrying for as
15211 * long as the underlying transport keeps
15212 * returning TRAN_BUSY (just like for other
15213 * commands). Use the same timeout interval as
15214 * for the ordinary TRAN_BUSY retry.
15215 */
15216 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15217 "sd_start_cmds: scsi_transport() returned "
15218 "TRAN_BUSY for DIRECT_PRIORITY cmd!\n");
15219
15220 SD_UPDATE_KSTATS(un, kstat_runq_exit, bp);
15221 un->un_direct_priority_timeid =
15222 timeout(sd_start_direct_priority_command,
15223 bp, un->un_busy_timeout / 500);
15224
15225 goto exit;
15226 }
15227
15228 /*
15229 * For TRAN_BUSY, we want to reduce the throttle value,
15230 * unless we are retrying a command.
15231 */
15232 if (bp != un->un_retry_bp) {
15233 sd_reduce_throttle(un, SD_THROTTLE_TRAN_BUSY);
15234 }
15235
15236 /*
15237 * Set up the bp to be tried again 10 ms later.
15238 * Note:x86: Is there a timeout value in the sd_lun
15239 * for this condition?
15240 */
15241 sd_set_retry_bp(un, bp, un->un_busy_timeout / 500,
15242 kstat_runq_back_to_waitq);
15243 goto exit;
15244
15245 case TRAN_FATAL_ERROR:
15246 un->un_tran_fatal_count++;
15247 /* FALLTHRU */
15248
15249 case TRAN_BADPKT:
15250 default:
15251 un->un_ncmds_in_transport--;
15252 ASSERT(un->un_ncmds_in_transport >= 0);
15253
15254 /*
15255 * If this is our REQUEST SENSE command with a
15256 * transport error, we must get back the pointers
15257 * to the original buf, and mark the REQUEST
15258 * SENSE command as "available".
15259 */
15260 if (bp == un->un_rqs_bp) {
15261 bp = sd_mark_rqs_idle(un, xp);
15262 xp = SD_GET_XBUF(bp);
15263 } else {
15264 /*
15265 * Legacy behavior: do not update transport
15266 * error count for request sense commands.
15267 */
15268 SD_UPDATE_ERRSTATS(un, sd_transerrs);
15269 }
15270
15271 SD_UPDATE_KSTATS(un, kstat_runq_exit, bp);
15272 sd_print_transport_rejected_message(un, xp, rval);
15273
15274 /*
15275 * This command will be terminated by SD driver due
15276 * to a fatal transport error. We should post
15277 * ereport.io.scsi.cmd.disk.tran with driver-assessment
15278 * of "fail" for any command to indicate this
15279 * situation.
15280 */
15281 if (xp->xb_ena > 0) {
15282 ASSERT(un->un_fm_private != NULL);
15283 sfip = un->un_fm_private;
15284 sfip->fm_ssc.ssc_flags |= SSC_FLAGS_TRAN_ABORT;
15285 sd_ssc_extract_info(&sfip->fm_ssc, un,
15286 xp->xb_pktp, bp, xp);
15287 sd_ssc_post(&sfip->fm_ssc, SD_FM_DRV_FATAL);
15288 }
15289
15290 /*
15291 * We must use sd_return_failed_command_no_restart() to
15292 * avoid a recursive call back into sd_start_cmds().
15293 * However this also means that we must keep processing
15294 * the waitq here in order to avoid stalling.
15295 */
15296 sd_return_failed_command_no_restart(un, bp, EIO);
15297
15298 /*
15299 * Notify any threads waiting in sd_ddi_suspend() that
15300 * a command completion has occurred.
15301 */
15302 if (un->un_state == SD_STATE_SUSPENDED) {
15303 cv_broadcast(&un->un_disk_busy_cv);
15304 }
15305
15306 if (bp == immed_bp) {
15307 /* immed_bp is gone by now, so clear this */
15308 immed_bp = NULL;
15309 }
15310 break;
15311 }
15312
15313 } while (immed_bp == NULL);
15314
15315 exit:
15316 ASSERT(mutex_owned(SD_MUTEX(un)));
15317 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_start_cmds: exit\n");
15318 }
15319
15320
15321 /*
15322 * Function: sd_return_command
15323 *
15324 * Description: Returns a command to its originator (with or without an
15325 * error). Also starts commands waiting to be transported
15326 * to the target.
15327 *
15328 * Context: May be called from interrupt, kernel, or timeout context
15329 */
15330
15331 static void
15332 sd_return_command(struct sd_lun *un, struct buf *bp)
15333 {
15334 struct sd_xbuf *xp;
15335 struct scsi_pkt *pktp;
15336 struct sd_fm_internal *sfip;
15337
15338 ASSERT(bp != NULL);
15339 ASSERT(un != NULL);
15340 ASSERT(mutex_owned(SD_MUTEX(un)));
15341 ASSERT(bp != un->un_rqs_bp);
15342 xp = SD_GET_XBUF(bp);
15343 ASSERT(xp != NULL);
15344
15345 pktp = SD_GET_PKTP(bp);
15346 sfip = (struct sd_fm_internal *)un->un_fm_private;
15347 ASSERT(sfip != NULL);
15348
15349 SD_TRACE(SD_LOG_IO_CORE, un, "sd_return_command: entry\n");
15350
15351 /*
15352 * Note: check for the "sdrestart failed" case.
15353 */
15354 if ((un->un_partial_dma_supported == 1) &&
15355 ((xp->xb_pkt_flags & SD_XB_USCSICMD) != SD_XB_USCSICMD) &&
15356 (geterror(bp) == 0) && (xp->xb_dma_resid != 0) &&
15357 (xp->xb_pktp->pkt_resid == 0)) {
15358
15359 if (sd_setup_next_xfer(un, bp, pktp, xp) != 0) {
15360 /*
15361 * Successfully set up next portion of cmd
15362 * transfer, try sending it
15363 */
15364 sd_retry_command(un, bp, SD_RETRIES_NOCHECK,
15365 NULL, NULL, 0, (clock_t)0, NULL);
15366 sd_start_cmds(un, NULL);
15367 return; /* Note:x86: need a return here? */
15368 }
15369 }
15370
15371 /*
15372 * If this is the failfast bp, clear it from un_failfast_bp. This
15373 * can happen if upon being re-tried the failfast bp either
15374 * succeeded or encountered another error (possibly even a different
15375 * error than the one that precipitated the failfast state, but in
15376 * that case it would have had to exhaust retries as well). Regardless,
15377 * this should not occur whenever the instance is in the active
15378 * failfast state.
15379 */
15380 if (bp == un->un_failfast_bp) {
15381 ASSERT(un->un_failfast_state == SD_FAILFAST_INACTIVE);
15382 un->un_failfast_bp = NULL;
15383 }
15384
15385 /*
15386 * Clear the failfast state upon successful completion of ANY cmd.
15387 */
15388 if (bp->b_error == 0) {
15389 un->un_failfast_state = SD_FAILFAST_INACTIVE;
15390 /*
15391 * If this is a successful command, but used to be retried,
15392 * we will take it as a recovered command and post an
15393 * ereport with driver-assessment of "recovered".
15394 */
15395 if (xp->xb_ena > 0) {
15396 sd_ssc_extract_info(&sfip->fm_ssc, un, pktp, bp, xp);
15397 sd_ssc_post(&sfip->fm_ssc, SD_FM_DRV_RECOVERY);
15398 }
15399 } else {
15400 /*
15401 * If this is a failed non-USCSI command we will post an
15402 * ereport with driver-assessment set accordingly("fail" or
15403 * "fatal").
15404 */
15405 if (!(xp->xb_pkt_flags & SD_XB_USCSICMD)) {
15406 sd_ssc_extract_info(&sfip->fm_ssc, un, pktp, bp, xp);
15407 sd_ssc_post(&sfip->fm_ssc, SD_FM_DRV_FATAL);
15408 }
15409 }
15410
15411 /*
15412 * This is used if the command was retried one or more times. Show that
15413 * we are done with it, and allow processing of the waitq to resume.
15414 */
15415 if (bp == un->un_retry_bp) {
15416 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15417 "sd_return_command: un:0x%p: "
15418 "RETURNING retry_bp:0x%p\n", un, un->un_retry_bp);
15419 un->un_retry_bp = NULL;
15420 un->un_retry_statp = NULL;
15421 }
15422
15423 SD_UPDATE_RDWR_STATS(un, bp);
15424 SD_UPDATE_PARTITION_STATS(un, bp);
15425
15426 switch (un->un_state) {
15427 case SD_STATE_SUSPENDED:
15428 /*
15429 * Notify any threads waiting in sd_ddi_suspend() that
15430 * a command completion has occurred.
15431 */
15432 cv_broadcast(&un->un_disk_busy_cv);
15433 break;
15434 default:
15435 sd_start_cmds(un, NULL);
15436 break;
15437 }
15438
15439 /* Return this command up the iodone chain to its originator. */
15440 mutex_exit(SD_MUTEX(un));
15441
15442 (*(sd_destroypkt_map[xp->xb_chain_iodone]))(bp);
15443 xp->xb_pktp = NULL;
15444
15445 SD_BEGIN_IODONE(xp->xb_chain_iodone, un, bp);
15446
15447 ASSERT(!mutex_owned(SD_MUTEX(un)));
15448 mutex_enter(SD_MUTEX(un));
15449
15450 SD_TRACE(SD_LOG_IO_CORE, un, "sd_return_command: exit\n");
15451 }
15452
15453
15454 /*
15455 * Function: sd_return_failed_command
15456 *
15457 * Description: Command completion when an error occurred.
15458 *
15459 * Context: May be called from interrupt context
15460 */
15461
15462 static void
15463 sd_return_failed_command(struct sd_lun *un, struct buf *bp, int errcode)
15464 {
15465 ASSERT(bp != NULL);
15466 ASSERT(un != NULL);
15467 ASSERT(mutex_owned(SD_MUTEX(un)));
15468
15469 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15470 "sd_return_failed_command: entry\n");
15471
15472 /*
15473 * b_resid could already be nonzero due to a partial data
15474 * transfer, so do not change it here.
15475 */
15476 SD_BIOERROR(bp, errcode);
15477
15478 sd_return_command(un, bp);
15479 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15480 "sd_return_failed_command: exit\n");
15481 }
15482
15483
15484 /*
15485 * Function: sd_return_failed_command_no_restart
15486 *
15487 * Description: Same as sd_return_failed_command, but ensures that no
15488 * call back into sd_start_cmds will be issued.
15489 *
15490 * Context: May be called from interrupt context
15491 */
15492
15493 static void
15494 sd_return_failed_command_no_restart(struct sd_lun *un, struct buf *bp,
15495 int errcode)
15496 {
15497 struct sd_xbuf *xp;
15498
15499 ASSERT(bp != NULL);
15500 ASSERT(un != NULL);
15501 ASSERT(mutex_owned(SD_MUTEX(un)));
15502 xp = SD_GET_XBUF(bp);
15503 ASSERT(xp != NULL);
15504 ASSERT(errcode != 0);
15505
15506 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15507 "sd_return_failed_command_no_restart: entry\n");
15508
15509 /*
15510 * b_resid could already be nonzero due to a partial data
15511 * transfer, so do not change it here.
15512 */
15513 SD_BIOERROR(bp, errcode);
15514
15515 /*
15516 * If this is the failfast bp, clear it. This can happen if the
15517 * failfast bp encounterd a fatal error when we attempted to
15518 * re-try it (such as a scsi_transport(9F) failure). However
15519 * we should NOT be in an active failfast state if the failfast
15520 * bp is not NULL.
15521 */
15522 if (bp == un->un_failfast_bp) {
15523 ASSERT(un->un_failfast_state == SD_FAILFAST_INACTIVE);
15524 un->un_failfast_bp = NULL;
15525 }
15526
15527 if (bp == un->un_retry_bp) {
15528 /*
15529 * This command was retried one or more times. Show that we are
15530 * done with it, and allow processing of the waitq to resume.
15531 */
15532 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15533 "sd_return_failed_command_no_restart: "
15534 " un:0x%p: RETURNING retry_bp:0x%p\n", un, un->un_retry_bp);
15535 un->un_retry_bp = NULL;
15536 un->un_retry_statp = NULL;
15537 }
15538
15539 SD_UPDATE_RDWR_STATS(un, bp);
15540 SD_UPDATE_PARTITION_STATS(un, bp);
15541
15542 mutex_exit(SD_MUTEX(un));
15543
15544 if (xp->xb_pktp != NULL) {
15545 (*(sd_destroypkt_map[xp->xb_chain_iodone]))(bp);
15546 xp->xb_pktp = NULL;
15547 }
15548
15549 SD_BEGIN_IODONE(xp->xb_chain_iodone, un, bp);
15550
15551 mutex_enter(SD_MUTEX(un));
15552
15553 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15554 "sd_return_failed_command_no_restart: exit\n");
15555 }
15556
15557
15558 /*
15559 * Function: sd_retry_command
15560 *
15561 * Description: queue up a command for retry, or (optionally) fail it
15562 * if retry counts are exhausted.
15563 *
15564 * Arguments: un - Pointer to the sd_lun struct for the target.
15565 *
15566 * bp - Pointer to the buf for the command to be retried.
15567 *
15568 * retry_check_flag - Flag to see which (if any) of the retry
15569 * counts should be decremented/checked. If the indicated
15570 * retry count is exhausted, then the command will not be
15571 * retried; it will be failed instead. This should use a
15572 * value equal to one of the following:
15573 *
15574 * SD_RETRIES_NOCHECK
15575 * SD_RESD_RETRIES_STANDARD
15576 * SD_RETRIES_VICTIM
15577 *
15578 * Optionally may be bitwise-OR'ed with SD_RETRIES_ISOLATE
15579 * if the check should be made to see of FLAG_ISOLATE is set
15580 * in the pkt. If FLAG_ISOLATE is set, then the command is
15581 * not retried, it is simply failed.
15582 *
15583 * user_funcp - Ptr to function to call before dispatching the
15584 * command. May be NULL if no action needs to be performed.
15585 * (Primarily intended for printing messages.)
15586 *
15587 * user_arg - Optional argument to be passed along to
15588 * the user_funcp call.
15589 *
15590 * failure_code - errno return code to set in the bp if the
15591 * command is going to be failed.
15592 *
15593 * retry_delay - Retry delay interval in (clock_t) units. May
15594 * be zero which indicates that the retry should be retried
15595 * immediately (ie, without an intervening delay).
15596 *
15597 * statp - Ptr to kstat function to be updated if the command
15598 * is queued for a delayed retry. May be NULL if no kstat
15599 * update is desired.
15600 *
15601 * Context: May be called from interrupt context.
15602 */
15603
15604 static void
15605 sd_retry_command(struct sd_lun *un, struct buf *bp, int retry_check_flag,
15606 void (*user_funcp)(struct sd_lun *un, struct buf *bp, void *argp, int code),
15607 void *user_arg, int failure_code, clock_t retry_delay,
15608 void (*statp)(kstat_io_t *))
15609 {
15610 struct sd_xbuf *xp;
15611 struct scsi_pkt *pktp;
15612 struct sd_fm_internal *sfip;
15613
15614 ASSERT(un != NULL);
15615 ASSERT(mutex_owned(SD_MUTEX(un)));
15616 ASSERT(bp != NULL);
15617 xp = SD_GET_XBUF(bp);
15618 ASSERT(xp != NULL);
15619 pktp = SD_GET_PKTP(bp);
15620 ASSERT(pktp != NULL);
15621
15622 sfip = (struct sd_fm_internal *)un->un_fm_private;
15623 ASSERT(sfip != NULL);
15624
15625 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un,
15626 "sd_retry_command: entry: bp:0x%p xp:0x%p\n", bp, xp);
15627
15628 /*
15629 * If we are syncing or dumping, fail the command to avoid
15630 * recursively calling back into scsi_transport().
15631 */
15632 if (ddi_in_panic()) {
15633 goto fail_command_no_log;
15634 }
15635
15636 /*
15637 * We should never be be retrying a command with FLAG_DIAGNOSE set, so
15638 * log an error and fail the command.
15639 */
15640 if ((pktp->pkt_flags & FLAG_DIAGNOSE) != 0) {
15641 scsi_log(SD_DEVINFO(un), sd_label, CE_NOTE,
15642 "ERROR, retrying FLAG_DIAGNOSE command.\n");
15643 sd_dump_memory(un, SD_LOG_IO, "CDB",
15644 (uchar_t *)pktp->pkt_cdbp, CDB_SIZE, SD_LOG_HEX);
15645 sd_dump_memory(un, SD_LOG_IO, "Sense Data",
15646 (uchar_t *)xp->xb_sense_data, SENSE_LENGTH, SD_LOG_HEX);
15647 goto fail_command;
15648 }
15649
15650 /*
15651 * If we are suspended, then put the command onto head of the
15652 * wait queue since we don't want to start more commands, and
15653 * clear the un_retry_bp. Next time when we are resumed, will
15654 * handle the command in the wait queue.
15655 */
15656 switch (un->un_state) {
15657 case SD_STATE_SUSPENDED:
15658 case SD_STATE_DUMPING:
15659 bp->av_forw = un->un_waitq_headp;
15660 un->un_waitq_headp = bp;
15661 if (un->un_waitq_tailp == NULL) {
15662 un->un_waitq_tailp = bp;
15663 }
15664 if (bp == un->un_retry_bp) {
15665 un->un_retry_bp = NULL;
15666 un->un_retry_statp = NULL;
15667 }
15668 SD_UPDATE_KSTATS(un, kstat_waitq_enter, bp);
15669 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_retry_command: "
15670 "exiting; cmd bp:0x%p requeued for SUSPEND/DUMP\n", bp);
15671 return;
15672 default:
15673 break;
15674 }
15675
15676 /*
15677 * If the caller wants us to check FLAG_ISOLATE, then see if that
15678 * is set; if it is then we do not want to retry the command.
15679 * Normally, FLAG_ISOLATE is only used with USCSI cmds.
15680 */
15681 if ((retry_check_flag & SD_RETRIES_ISOLATE) != 0) {
15682 if ((pktp->pkt_flags & FLAG_ISOLATE) != 0) {
15683 goto fail_command;
15684 }
15685 }
15686
15687
15688 /*
15689 * If SD_RETRIES_FAILFAST is set, it indicates that either a
15690 * command timeout or a selection timeout has occurred. This means
15691 * that we were unable to establish an kind of communication with
15692 * the target, and subsequent retries and/or commands are likely
15693 * to encounter similar results and take a long time to complete.
15694 *
15695 * If this is a failfast error condition, we need to update the
15696 * failfast state, even if this bp does not have B_FAILFAST set.
15697 */
15698 if (retry_check_flag & SD_RETRIES_FAILFAST) {
15699 if (un->un_failfast_state == SD_FAILFAST_ACTIVE) {
15700 ASSERT(un->un_failfast_bp == NULL);
15701 /*
15702 * If we are already in the active failfast state, and
15703 * another failfast error condition has been detected,
15704 * then fail this command if it has B_FAILFAST set.
15705 * If B_FAILFAST is clear, then maintain the legacy
15706 * behavior of retrying heroically, even tho this will
15707 * take a lot more time to fail the command.
15708 */
15709 if (bp->b_flags & B_FAILFAST) {
15710 goto fail_command;
15711 }
15712 } else {
15713 /*
15714 * We're not in the active failfast state, but we
15715 * have a failfast error condition, so we must begin
15716 * transition to the next state. We do this regardless
15717 * of whether or not this bp has B_FAILFAST set.
15718 */
15719 if (un->un_failfast_bp == NULL) {
15720 /*
15721 * This is the first bp to meet a failfast
15722 * condition so save it on un_failfast_bp &
15723 * do normal retry processing. Do not enter
15724 * active failfast state yet. This marks
15725 * entry into the "failfast pending" state.
15726 */
15727 un->un_failfast_bp = bp;
15728
15729 } else if (un->un_failfast_bp == bp) {
15730 /*
15731 * This is the second time *this* bp has
15732 * encountered a failfast error condition,
15733 * so enter active failfast state & flush
15734 * queues as appropriate.
15735 */
15736 un->un_failfast_state = SD_FAILFAST_ACTIVE;
15737 un->un_failfast_bp = NULL;
15738 sd_failfast_flushq(un);
15739
15740 /*
15741 * Fail this bp now if B_FAILFAST set;
15742 * otherwise continue with retries. (It would
15743 * be pretty ironic if this bp succeeded on a
15744 * subsequent retry after we just flushed all
15745 * the queues).
15746 */
15747 if (bp->b_flags & B_FAILFAST) {
15748 goto fail_command;
15749 }
15750
15751 #if !defined(lint) && !defined(__lint)
15752 } else {
15753 /*
15754 * If neither of the preceeding conditionals
15755 * was true, it means that there is some
15756 * *other* bp that has met an inital failfast
15757 * condition and is currently either being
15758 * retried or is waiting to be retried. In
15759 * that case we should perform normal retry
15760 * processing on *this* bp, since there is a
15761 * chance that the current failfast condition
15762 * is transient and recoverable. If that does
15763 * not turn out to be the case, then retries
15764 * will be cleared when the wait queue is
15765 * flushed anyway.
15766 */
15767 #endif
15768 }
15769 }
15770 } else {
15771 /*
15772 * SD_RETRIES_FAILFAST is clear, which indicates that we
15773 * likely were able to at least establish some level of
15774 * communication with the target and subsequent commands
15775 * and/or retries are likely to get through to the target,
15776 * In this case we want to be aggressive about clearing
15777 * the failfast state. Note that this does not affect
15778 * the "failfast pending" condition.
15779 */
15780 un->un_failfast_state = SD_FAILFAST_INACTIVE;
15781 }
15782
15783
15784 /*
15785 * Check the specified retry count to see if we can still do
15786 * any retries with this pkt before we should fail it.
15787 */
15788 switch (retry_check_flag & SD_RETRIES_MASK) {
15789 case SD_RETRIES_VICTIM:
15790 /*
15791 * Check the victim retry count. If exhausted, then fall
15792 * thru & check against the standard retry count.
15793 */
15794 if (xp->xb_victim_retry_count < un->un_victim_retry_count) {
15795 /* Increment count & proceed with the retry */
15796 xp->xb_victim_retry_count++;
15797 break;
15798 }
15799 /* Victim retries exhausted, fall back to std. retries... */
15800 /* FALLTHRU */
15801
15802 case SD_RETRIES_STANDARD:
15803 if (xp->xb_retry_count >= un->un_retry_count) {
15804 /* Retries exhausted, fail the command */
15805 SD_TRACE(SD_LOG_IO_CORE, un,
15806 "sd_retry_command: retries exhausted!\n");
15807 /*
15808 * update b_resid for failed SCMD_READ & SCMD_WRITE
15809 * commands with nonzero pkt_resid.
15810 */
15811 if ((pktp->pkt_reason == CMD_CMPLT) &&
15812 (SD_GET_PKT_STATUS(pktp) == STATUS_GOOD) &&
15813 (pktp->pkt_resid != 0)) {
15814 uchar_t op = SD_GET_PKT_OPCODE(pktp) & 0x1F;
15815 if ((op == SCMD_READ) || (op == SCMD_WRITE)) {
15816 SD_UPDATE_B_RESID(bp, pktp);
15817 }
15818 }
15819 goto fail_command;
15820 }
15821 xp->xb_retry_count++;
15822 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15823 "sd_retry_command: retry count:%d\n", xp->xb_retry_count);
15824 break;
15825
15826 case SD_RETRIES_UA:
15827 if (xp->xb_ua_retry_count >= sd_ua_retry_count) {
15828 /* Retries exhausted, fail the command */
15829 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
15830 "Unit Attention retries exhausted. "
15831 "Check the target.\n");
15832 goto fail_command;
15833 }
15834 xp->xb_ua_retry_count++;
15835 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15836 "sd_retry_command: retry count:%d\n",
15837 xp->xb_ua_retry_count);
15838 break;
15839
15840 case SD_RETRIES_BUSY:
15841 if (xp->xb_retry_count >= un->un_busy_retry_count) {
15842 /* Retries exhausted, fail the command */
15843 SD_TRACE(SD_LOG_IO_CORE, un,
15844 "sd_retry_command: retries exhausted!\n");
15845 goto fail_command;
15846 }
15847 xp->xb_retry_count++;
15848 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15849 "sd_retry_command: retry count:%d\n", xp->xb_retry_count);
15850 break;
15851
15852 case SD_RETRIES_NOCHECK:
15853 default:
15854 /* No retry count to check. Just proceed with the retry */
15855 break;
15856 }
15857
15858 xp->xb_pktp->pkt_flags |= FLAG_HEAD;
15859
15860 /*
15861 * If this is a non-USCSI command being retried
15862 * during execution last time, we should post an ereport with
15863 * driver-assessment of the value "retry".
15864 * For partial DMA, request sense and STATUS_QFULL, there are no
15865 * hardware errors, we bypass ereport posting.
15866 */
15867 if (failure_code != 0) {
15868 if (!(xp->xb_pkt_flags & SD_XB_USCSICMD)) {
15869 sd_ssc_extract_info(&sfip->fm_ssc, un, pktp, bp, xp);
15870 sd_ssc_post(&sfip->fm_ssc, SD_FM_DRV_RETRY);
15871 }
15872 }
15873
15874 /*
15875 * If we were given a zero timeout, we must attempt to retry the
15876 * command immediately (ie, without a delay).
15877 */
15878 if (retry_delay == 0) {
15879 /*
15880 * Check some limiting conditions to see if we can actually
15881 * do the immediate retry. If we cannot, then we must
15882 * fall back to queueing up a delayed retry.
15883 */
15884 if (un->un_ncmds_in_transport >= un->un_throttle) {
15885 /*
15886 * We are at the throttle limit for the target,
15887 * fall back to delayed retry.
15888 */
15889 retry_delay = un->un_busy_timeout;
15890 statp = kstat_waitq_enter;
15891 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15892 "sd_retry_command: immed. retry hit "
15893 "throttle!\n");
15894 } else {
15895 /*
15896 * We're clear to proceed with the immediate retry.
15897 * First call the user-provided function (if any)
15898 */
15899 if (user_funcp != NULL) {
15900 (*user_funcp)(un, bp, user_arg,
15901 SD_IMMEDIATE_RETRY_ISSUED);
15902 #ifdef __lock_lint
15903 sd_print_incomplete_msg(un, bp, user_arg,
15904 SD_IMMEDIATE_RETRY_ISSUED);
15905 sd_print_cmd_incomplete_msg(un, bp, user_arg,
15906 SD_IMMEDIATE_RETRY_ISSUED);
15907 sd_print_sense_failed_msg(un, bp, user_arg,
15908 SD_IMMEDIATE_RETRY_ISSUED);
15909 #endif
15910 }
15911
15912 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15913 "sd_retry_command: issuing immediate retry\n");
15914
15915 /*
15916 * Call sd_start_cmds() to transport the command to
15917 * the target.
15918 */
15919 sd_start_cmds(un, bp);
15920
15921 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15922 "sd_retry_command exit\n");
15923 return;
15924 }
15925 }
15926
15927 /*
15928 * Set up to retry the command after a delay.
15929 * First call the user-provided function (if any)
15930 */
15931 if (user_funcp != NULL) {
15932 (*user_funcp)(un, bp, user_arg, SD_DELAYED_RETRY_ISSUED);
15933 }
15934
15935 sd_set_retry_bp(un, bp, retry_delay, statp);
15936
15937 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_retry_command: exit\n");
15938 return;
15939
15940 fail_command:
15941
15942 if (user_funcp != NULL) {
15943 (*user_funcp)(un, bp, user_arg, SD_NO_RETRY_ISSUED);
15944 }
15945
15946 fail_command_no_log:
15947
15948 SD_INFO(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15949 "sd_retry_command: returning failed command\n");
15950
15951 sd_return_failed_command(un, bp, failure_code);
15952
15953 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_retry_command: exit\n");
15954 }
15955
15956
15957 /*
15958 * Function: sd_set_retry_bp
15959 *
15960 * Description: Set up the given bp for retry.
15961 *
15962 * Arguments: un - ptr to associated softstate
15963 * bp - ptr to buf(9S) for the command
15964 * retry_delay - time interval before issuing retry (may be 0)
15965 * statp - optional pointer to kstat function
15966 *
15967 * Context: May be called under interrupt context
15968 */
15969
15970 static void
15971 sd_set_retry_bp(struct sd_lun *un, struct buf *bp, clock_t retry_delay,
15972 void (*statp)(kstat_io_t *))
15973 {
15974 ASSERT(un != NULL);
15975 ASSERT(mutex_owned(SD_MUTEX(un)));
15976 ASSERT(bp != NULL);
15977
15978 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un,
15979 "sd_set_retry_bp: entry: un:0x%p bp:0x%p\n", un, bp);
15980
15981 /*
15982 * Indicate that the command is being retried. This will not allow any
15983 * other commands on the wait queue to be transported to the target
15984 * until this command has been completed (success or failure). The
15985 * "retry command" is not transported to the target until the given
15986 * time delay expires, unless the user specified a 0 retry_delay.
15987 *
15988 * Note: the timeout(9F) callback routine is what actually calls
15989 * sd_start_cmds() to transport the command, with the exception of a
15990 * zero retry_delay. The only current implementor of a zero retry delay
15991 * is the case where a START_STOP_UNIT is sent to spin-up a device.
15992 */
15993 if (un->un_retry_bp == NULL) {
15994 ASSERT(un->un_retry_statp == NULL);
15995 un->un_retry_bp = bp;
15996
15997 /*
15998 * If the user has not specified a delay the command should
15999 * be queued and no timeout should be scheduled.
16000 */
16001 if (retry_delay == 0) {
16002 /*
16003 * Save the kstat pointer that will be used in the
16004 * call to SD_UPDATE_KSTATS() below, so that
16005 * sd_start_cmds() can correctly decrement the waitq
16006 * count when it is time to transport this command.
16007 */
16008 un->un_retry_statp = statp;
16009 goto done;
16010 }
16011 }
16012
16013 if (un->un_retry_bp == bp) {
16014 /*
16015 * Save the kstat pointer that will be used in the call to
16016 * SD_UPDATE_KSTATS() below, so that sd_start_cmds() can
16017 * correctly decrement the waitq count when it is time to
16018 * transport this command.
16019 */
16020 un->un_retry_statp = statp;
16021
16022 /*
16023 * Schedule a timeout if:
16024 * 1) The user has specified a delay.
16025 * 2) There is not a START_STOP_UNIT callback pending.
16026 *
16027 * If no delay has been specified, then it is up to the caller
16028 * to ensure that IO processing continues without stalling.
16029 * Effectively, this means that the caller will issue the
16030 * required call to sd_start_cmds(). The START_STOP_UNIT
16031 * callback does this after the START STOP UNIT command has
16032 * completed. In either of these cases we should not schedule
16033 * a timeout callback here. Also don't schedule the timeout if
16034 * an SD_PATH_DIRECT_PRIORITY command is waiting to restart.
16035 */
16036 if ((retry_delay != 0) && (un->un_startstop_timeid == NULL) &&
16037 (un->un_direct_priority_timeid == NULL)) {
16038 un->un_retry_timeid =
16039 timeout(sd_start_retry_command, un, retry_delay);
16040 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16041 "sd_set_retry_bp: setting timeout: un: 0x%p"
16042 " bp:0x%p un_retry_timeid:0x%p\n",
16043 un, bp, un->un_retry_timeid);
16044 }
16045 } else {
16046 /*
16047 * We only get in here if there is already another command
16048 * waiting to be retried. In this case, we just put the
16049 * given command onto the wait queue, so it can be transported
16050 * after the current retry command has completed.
16051 *
16052 * Also we have to make sure that if the command at the head
16053 * of the wait queue is the un_failfast_bp, that we do not
16054 * put ahead of it any other commands that are to be retried.
16055 */
16056 if ((un->un_failfast_bp != NULL) &&
16057 (un->un_failfast_bp == un->un_waitq_headp)) {
16058 /*
16059 * Enqueue this command AFTER the first command on
16060 * the wait queue (which is also un_failfast_bp).
16061 */
16062 bp->av_forw = un->un_waitq_headp->av_forw;
16063 un->un_waitq_headp->av_forw = bp;
16064 if (un->un_waitq_headp == un->un_waitq_tailp) {
16065 un->un_waitq_tailp = bp;
16066 }
16067 } else {
16068 /* Enqueue this command at the head of the waitq. */
16069 bp->av_forw = un->un_waitq_headp;
16070 un->un_waitq_headp = bp;
16071 if (un->un_waitq_tailp == NULL) {
16072 un->un_waitq_tailp = bp;
16073 }
16074 }
16075
16076 if (statp == NULL) {
16077 statp = kstat_waitq_enter;
16078 }
16079 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16080 "sd_set_retry_bp: un:0x%p already delayed retry\n", un);
16081 }
16082
16083 done:
16084 if (statp != NULL) {
16085 SD_UPDATE_KSTATS(un, statp, bp);
16086 }
16087
16088 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16089 "sd_set_retry_bp: exit un:0x%p\n", un);
16090 }
16091
16092
16093 /*
16094 * Function: sd_start_retry_command
16095 *
16096 * Description: Start the command that has been waiting on the target's
16097 * retry queue. Called from timeout(9F) context after the
16098 * retry delay interval has expired.
16099 *
16100 * Arguments: arg - pointer to associated softstate for the device.
16101 *
16102 * Context: timeout(9F) thread context. May not sleep.
16103 */
16104
16105 static void
16106 sd_start_retry_command(void *arg)
16107 {
16108 struct sd_lun *un = arg;
16109
16110 ASSERT(un != NULL);
16111 ASSERT(!mutex_owned(SD_MUTEX(un)));
16112
16113 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16114 "sd_start_retry_command: entry\n");
16115
16116 mutex_enter(SD_MUTEX(un));
16117
16118 un->un_retry_timeid = NULL;
16119
16120 if (un->un_retry_bp != NULL) {
16121 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16122 "sd_start_retry_command: un:0x%p STARTING bp:0x%p\n",
16123 un, un->un_retry_bp);
16124 sd_start_cmds(un, un->un_retry_bp);
16125 }
16126
16127 mutex_exit(SD_MUTEX(un));
16128
16129 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16130 "sd_start_retry_command: exit\n");
16131 }
16132
16133 /*
16134 * Function: sd_rmw_msg_print_handler
16135 *
16136 * Description: If RMW mode is enabled and warning message is triggered
16137 * print I/O count during a fixed interval.
16138 *
16139 * Arguments: arg - pointer to associated softstate for the device.
16140 *
16141 * Context: timeout(9F) thread context. May not sleep.
16142 */
16143 static void
16144 sd_rmw_msg_print_handler(void *arg)
16145 {
16146 struct sd_lun *un = arg;
16147
16148 ASSERT(un != NULL);
16149 ASSERT(!mutex_owned(SD_MUTEX(un)));
16150
16151 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16152 "sd_rmw_msg_print_handler: entry\n");
16153
16154 mutex_enter(SD_MUTEX(un));
16155
16156 if (un->un_rmw_incre_count > 0) {
16157 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
16158 "%"PRIu64" I/O requests are not aligned with %d disk "
16159 "sector size in %ld seconds. They are handled through "
16160 "Read Modify Write but the performance is very low!\n",
16161 un->un_rmw_incre_count, un->un_tgt_blocksize,
16162 drv_hztousec(SD_RMW_MSG_PRINT_TIMEOUT) / 1000000);
16163 un->un_rmw_incre_count = 0;
16164 un->un_rmw_msg_timeid = timeout(sd_rmw_msg_print_handler,
16165 un, SD_RMW_MSG_PRINT_TIMEOUT);
16166 } else {
16167 un->un_rmw_msg_timeid = NULL;
16168 }
16169
16170 mutex_exit(SD_MUTEX(un));
16171
16172 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16173 "sd_rmw_msg_print_handler: exit\n");
16174 }
16175
16176 /*
16177 * Function: sd_start_direct_priority_command
16178 *
16179 * Description: Used to re-start an SD_PATH_DIRECT_PRIORITY command that had
16180 * received TRAN_BUSY when we called scsi_transport() to send it
16181 * to the underlying HBA. This function is called from timeout(9F)
16182 * context after the delay interval has expired.
16183 *
16184 * Arguments: arg - pointer to associated buf(9S) to be restarted.
16185 *
16186 * Context: timeout(9F) thread context. May not sleep.
16187 */
16188
16189 static void
16190 sd_start_direct_priority_command(void *arg)
16191 {
16192 struct buf *priority_bp = arg;
16193 struct sd_lun *un;
16194
16195 ASSERT(priority_bp != NULL);
16196 un = SD_GET_UN(priority_bp);
16197 ASSERT(un != NULL);
16198 ASSERT(!mutex_owned(SD_MUTEX(un)));
16199
16200 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16201 "sd_start_direct_priority_command: entry\n");
16202
16203 mutex_enter(SD_MUTEX(un));
16204 un->un_direct_priority_timeid = NULL;
16205 sd_start_cmds(un, priority_bp);
16206 mutex_exit(SD_MUTEX(un));
16207
16208 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16209 "sd_start_direct_priority_command: exit\n");
16210 }
16211
16212
16213 /*
16214 * Function: sd_send_request_sense_command
16215 *
16216 * Description: Sends a REQUEST SENSE command to the target
16217 *
16218 * Context: May be called from interrupt context.
16219 */
16220
16221 static void
16222 sd_send_request_sense_command(struct sd_lun *un, struct buf *bp,
16223 struct scsi_pkt *pktp)
16224 {
16225 ASSERT(bp != NULL);
16226 ASSERT(un != NULL);
16227 ASSERT(mutex_owned(SD_MUTEX(un)));
16228
16229 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un, "sd_send_request_sense_command: "
16230 "entry: buf:0x%p\n", bp);
16231
16232 /*
16233 * If we are syncing or dumping, then fail the command to avoid a
16234 * recursive callback into scsi_transport(). Also fail the command
16235 * if we are suspended (legacy behavior).
16236 */
16237 if (ddi_in_panic() || (un->un_state == SD_STATE_SUSPENDED) ||
16238 (un->un_state == SD_STATE_DUMPING)) {
16239 sd_return_failed_command(un, bp, EIO);
16240 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16241 "sd_send_request_sense_command: syncing/dumping, exit\n");
16242 return;
16243 }
16244
16245 /*
16246 * Retry the failed command and don't issue the request sense if:
16247 * 1) the sense buf is busy
16248 * 2) we have 1 or more outstanding commands on the target
16249 * (the sense data will be cleared or invalidated any way)
16250 *
16251 * Note: There could be an issue with not checking a retry limit here,
16252 * the problem is determining which retry limit to check.
16253 */
16254 if ((un->un_sense_isbusy != 0) || (un->un_ncmds_in_transport > 0)) {
16255 /* Don't retry if the command is flagged as non-retryable */
16256 if ((pktp->pkt_flags & FLAG_DIAGNOSE) == 0) {
16257 sd_retry_command(un, bp, SD_RETRIES_NOCHECK,
16258 NULL, NULL, 0, un->un_busy_timeout,
16259 kstat_waitq_enter);
16260 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16261 "sd_send_request_sense_command: "
16262 "at full throttle, retrying exit\n");
16263 } else {
16264 sd_return_failed_command(un, bp, EIO);
16265 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16266 "sd_send_request_sense_command: "
16267 "at full throttle, non-retryable exit\n");
16268 }
16269 return;
16270 }
16271
16272 sd_mark_rqs_busy(un, bp);
16273 sd_start_cmds(un, un->un_rqs_bp);
16274
16275 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16276 "sd_send_request_sense_command: exit\n");
16277 }
16278
16279
16280 /*
16281 * Function: sd_mark_rqs_busy
16282 *
16283 * Description: Indicate that the request sense bp for this instance is
16284 * in use.
16285 *
16286 * Context: May be called under interrupt context
16287 */
16288
16289 static void
16290 sd_mark_rqs_busy(struct sd_lun *un, struct buf *bp)
16291 {
16292 struct sd_xbuf *sense_xp;
16293
16294 ASSERT(un != NULL);
16295 ASSERT(bp != NULL);
16296 ASSERT(mutex_owned(SD_MUTEX(un)));
16297 ASSERT(un->un_sense_isbusy == 0);
16298
16299 SD_TRACE(SD_LOG_IO_CORE, un, "sd_mark_rqs_busy: entry: "
16300 "buf:0x%p xp:0x%p un:0x%p\n", bp, SD_GET_XBUF(bp), un);
16301
16302 sense_xp = SD_GET_XBUF(un->un_rqs_bp);
16303 ASSERT(sense_xp != NULL);
16304
16305 SD_INFO(SD_LOG_IO, un,
16306 "sd_mark_rqs_busy: entry: sense_xp:0x%p\n", sense_xp);
16307
16308 ASSERT(sense_xp->xb_pktp != NULL);
16309 ASSERT((sense_xp->xb_pktp->pkt_flags & (FLAG_SENSING | FLAG_HEAD))
16310 == (FLAG_SENSING | FLAG_HEAD));
16311
16312 un->un_sense_isbusy = 1;
16313 un->un_rqs_bp->b_resid = 0;
16314 sense_xp->xb_pktp->pkt_resid = 0;
16315 sense_xp->xb_pktp->pkt_reason = 0;
16316
16317 /* So we can get back the bp at interrupt time! */
16318 sense_xp->xb_sense_bp = bp;
16319
16320 bzero(un->un_rqs_bp->b_un.b_addr, SENSE_LENGTH);
16321
16322 /*
16323 * Mark this buf as awaiting sense data. (This is already set in
16324 * the pkt_flags for the RQS packet.)
16325 */
16326 ((SD_GET_XBUF(bp))->xb_pktp)->pkt_flags |= FLAG_SENSING;
16327
16328 /* Request sense down same path */
16329 if (scsi_pkt_allocated_correctly((SD_GET_XBUF(bp))->xb_pktp) &&
16330 ((SD_GET_XBUF(bp))->xb_pktp)->pkt_path_instance)
16331 sense_xp->xb_pktp->pkt_path_instance =
16332 ((SD_GET_XBUF(bp))->xb_pktp)->pkt_path_instance;
16333
16334 sense_xp->xb_retry_count = 0;
16335 sense_xp->xb_victim_retry_count = 0;
16336 sense_xp->xb_ua_retry_count = 0;
16337 sense_xp->xb_nr_retry_count = 0;
16338 sense_xp->xb_dma_resid = 0;
16339
16340 /* Clean up the fields for auto-request sense */
16341 sense_xp->xb_sense_status = 0;
16342 sense_xp->xb_sense_state = 0;
16343 sense_xp->xb_sense_resid = 0;
16344 bzero(sense_xp->xb_sense_data, sizeof (sense_xp->xb_sense_data));
16345
16346 SD_TRACE(SD_LOG_IO_CORE, un, "sd_mark_rqs_busy: exit\n");
16347 }
16348
16349
16350 /*
16351 * Function: sd_mark_rqs_idle
16352 *
16353 * Description: SD_MUTEX must be held continuously through this routine
16354 * to prevent reuse of the rqs struct before the caller can
16355 * complete it's processing.
16356 *
16357 * Return Code: Pointer to the RQS buf
16358 *
16359 * Context: May be called under interrupt context
16360 */
16361
16362 static struct buf *
16363 sd_mark_rqs_idle(struct sd_lun *un, struct sd_xbuf *sense_xp)
16364 {
16365 struct buf *bp;
16366 ASSERT(un != NULL);
16367 ASSERT(sense_xp != NULL);
16368 ASSERT(mutex_owned(SD_MUTEX(un)));
16369 ASSERT(un->un_sense_isbusy != 0);
16370
16371 un->un_sense_isbusy = 0;
16372 bp = sense_xp->xb_sense_bp;
16373 sense_xp->xb_sense_bp = NULL;
16374
16375 /* This pkt is no longer interested in getting sense data */
16376 ((SD_GET_XBUF(bp))->xb_pktp)->pkt_flags &= ~FLAG_SENSING;
16377
16378 return (bp);
16379 }
16380
16381
16382
16383 /*
16384 * Function: sd_alloc_rqs
16385 *
16386 * Description: Set up the unit to receive auto request sense data
16387 *
16388 * Return Code: DDI_SUCCESS or DDI_FAILURE
16389 *
16390 * Context: Called under attach(9E) context
16391 */
16392
16393 static int
16394 sd_alloc_rqs(struct scsi_device *devp, struct sd_lun *un)
16395 {
16396 struct sd_xbuf *xp;
16397
16398 ASSERT(un != NULL);
16399 ASSERT(!mutex_owned(SD_MUTEX(un)));
16400 ASSERT(un->un_rqs_bp == NULL);
16401 ASSERT(un->un_rqs_pktp == NULL);
16402
16403 /*
16404 * First allocate the required buf and scsi_pkt structs, then set up
16405 * the CDB in the scsi_pkt for a REQUEST SENSE command.
16406 */
16407 un->un_rqs_bp = scsi_alloc_consistent_buf(&devp->sd_address, NULL,
16408 MAX_SENSE_LENGTH, B_READ, SLEEP_FUNC, NULL);
16409 if (un->un_rqs_bp == NULL) {
16410 return (DDI_FAILURE);
16411 }
16412
16413 un->un_rqs_pktp = scsi_init_pkt(&devp->sd_address, NULL, un->un_rqs_bp,
16414 CDB_GROUP0, 1, 0, PKT_CONSISTENT, SLEEP_FUNC, NULL);
16415
16416 if (un->un_rqs_pktp == NULL) {
16417 sd_free_rqs(un);
16418 return (DDI_FAILURE);
16419 }
16420
16421 /* Set up the CDB in the scsi_pkt for a REQUEST SENSE command. */
16422 (void) scsi_setup_cdb((union scsi_cdb *)un->un_rqs_pktp->pkt_cdbp,
16423 SCMD_REQUEST_SENSE, 0, MAX_SENSE_LENGTH, 0);
16424
16425 SD_FILL_SCSI1_LUN(un, un->un_rqs_pktp);
16426
16427 /* Set up the other needed members in the ARQ scsi_pkt. */
16428 un->un_rqs_pktp->pkt_comp = sdintr;
16429 un->un_rqs_pktp->pkt_time = sd_io_time;
16430 un->un_rqs_pktp->pkt_flags |=
16431 (FLAG_SENSING | FLAG_HEAD); /* (1222170) */
16432
16433 /*
16434 * Allocate & init the sd_xbuf struct for the RQS command. Do not
16435 * provide any intpkt, destroypkt routines as we take care of
16436 * scsi_pkt allocation/freeing here and in sd_free_rqs().
16437 */
16438 xp = kmem_alloc(sizeof (struct sd_xbuf), KM_SLEEP);
16439 sd_xbuf_init(un, un->un_rqs_bp, xp, SD_CHAIN_NULL, NULL);
16440 xp->xb_pktp = un->un_rqs_pktp;
16441 SD_INFO(SD_LOG_ATTACH_DETACH, un,
16442 "sd_alloc_rqs: un 0x%p, rqs xp 0x%p, pkt 0x%p, buf 0x%p\n",
16443 un, xp, un->un_rqs_pktp, un->un_rqs_bp);
16444
16445 /*
16446 * Save the pointer to the request sense private bp so it can
16447 * be retrieved in sdintr.
16448 */
16449 un->un_rqs_pktp->pkt_private = un->un_rqs_bp;
16450 ASSERT(un->un_rqs_bp->b_private == xp);
16451
16452 /*
16453 * See if the HBA supports auto-request sense for the specified
16454 * target/lun. If it does, then try to enable it (if not already
16455 * enabled).
16456 *
16457 * Note: For some HBAs (ifp & sf), scsi_ifsetcap will always return
16458 * failure, while for other HBAs (pln) scsi_ifsetcap will always
16459 * return success. However, in both of these cases ARQ is always
16460 * enabled and scsi_ifgetcap will always return true. The best approach
16461 * is to issue the scsi_ifgetcap() first, then try the scsi_ifsetcap().
16462 *
16463 * The 3rd case is the HBA (adp) always return enabled on
16464 * scsi_ifgetgetcap even when it's not enable, the best approach
16465 * is issue a scsi_ifsetcap then a scsi_ifgetcap
16466 * Note: this case is to circumvent the Adaptec bug. (x86 only)
16467 */
16468
16469 if (un->un_f_is_fibre == TRUE) {
16470 un->un_f_arq_enabled = TRUE;
16471 } else {
16472 #if defined(__i386) || defined(__amd64)
16473 /*
16474 * Circumvent the Adaptec bug, remove this code when
16475 * the bug is fixed
16476 */
16477 (void) scsi_ifsetcap(SD_ADDRESS(un), "auto-rqsense", 1, 1);
16478 #endif
16479 switch (scsi_ifgetcap(SD_ADDRESS(un), "auto-rqsense", 1)) {
16480 case 0:
16481 SD_INFO(SD_LOG_ATTACH_DETACH, un,
16482 "sd_alloc_rqs: HBA supports ARQ\n");
16483 /*
16484 * ARQ is supported by this HBA but currently is not
16485 * enabled. Attempt to enable it and if successful then
16486 * mark this instance as ARQ enabled.
16487 */
16488 if (scsi_ifsetcap(SD_ADDRESS(un), "auto-rqsense", 1, 1)
16489 == 1) {
16490 /* Successfully enabled ARQ in the HBA */
16491 SD_INFO(SD_LOG_ATTACH_DETACH, un,
16492 "sd_alloc_rqs: ARQ enabled\n");
16493 un->un_f_arq_enabled = TRUE;
16494 } else {
16495 /* Could not enable ARQ in the HBA */
16496 SD_INFO(SD_LOG_ATTACH_DETACH, un,
16497 "sd_alloc_rqs: failed ARQ enable\n");
16498 un->un_f_arq_enabled = FALSE;
16499 }
16500 break;
16501 case 1:
16502 /*
16503 * ARQ is supported by this HBA and is already enabled.
16504 * Just mark ARQ as enabled for this instance.
16505 */
16506 SD_INFO(SD_LOG_ATTACH_DETACH, un,
16507 "sd_alloc_rqs: ARQ already enabled\n");
16508 un->un_f_arq_enabled = TRUE;
16509 break;
16510 default:
16511 /*
16512 * ARQ is not supported by this HBA; disable it for this
16513 * instance.
16514 */
16515 SD_INFO(SD_LOG_ATTACH_DETACH, un,
16516 "sd_alloc_rqs: HBA does not support ARQ\n");
16517 un->un_f_arq_enabled = FALSE;
16518 break;
16519 }
16520 }
16521
16522 return (DDI_SUCCESS);
16523 }
16524
16525
16526 /*
16527 * Function: sd_free_rqs
16528 *
16529 * Description: Cleanup for the pre-instance RQS command.
16530 *
16531 * Context: Kernel thread context
16532 */
16533
16534 static void
16535 sd_free_rqs(struct sd_lun *un)
16536 {
16537 ASSERT(un != NULL);
16538
16539 SD_TRACE(SD_LOG_IO_CORE, un, "sd_free_rqs: entry\n");
16540
16541 /*
16542 * If consistent memory is bound to a scsi_pkt, the pkt
16543 * has to be destroyed *before* freeing the consistent memory.
16544 * Don't change the sequence of this operations.
16545 * scsi_destroy_pkt() might access memory, which isn't allowed,
16546 * after it was freed in scsi_free_consistent_buf().
16547 */
16548 if (un->un_rqs_pktp != NULL) {
16549 scsi_destroy_pkt(un->un_rqs_pktp);
16550 un->un_rqs_pktp = NULL;
16551 }
16552
16553 if (un->un_rqs_bp != NULL) {
16554 struct sd_xbuf *xp = SD_GET_XBUF(un->un_rqs_bp);
16555 if (xp != NULL) {
16556 kmem_free(xp, sizeof (struct sd_xbuf));
16557 }
16558 scsi_free_consistent_buf(un->un_rqs_bp);
16559 un->un_rqs_bp = NULL;
16560 }
16561 SD_TRACE(SD_LOG_IO_CORE, un, "sd_free_rqs: exit\n");
16562 }
16563
16564
16565
16566 /*
16567 * Function: sd_reduce_throttle
16568 *
16569 * Description: Reduces the maximum # of outstanding commands on a
16570 * target to the current number of outstanding commands.
16571 * Queues a tiemout(9F) callback to restore the limit
16572 * after a specified interval has elapsed.
16573 * Typically used when we get a TRAN_BUSY return code
16574 * back from scsi_transport().
16575 *
16576 * Arguments: un - ptr to the sd_lun softstate struct
16577 * throttle_type: SD_THROTTLE_TRAN_BUSY or SD_THROTTLE_QFULL
16578 *
16579 * Context: May be called from interrupt context
16580 */
16581
16582 static void
16583 sd_reduce_throttle(struct sd_lun *un, int throttle_type)
16584 {
16585 ASSERT(un != NULL);
16586 ASSERT(mutex_owned(SD_MUTEX(un)));
16587 ASSERT(un->un_ncmds_in_transport >= 0);
16588
16589 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_reduce_throttle: "
16590 "entry: un:0x%p un_throttle:%d un_ncmds_in_transport:%d\n",
16591 un, un->un_throttle, un->un_ncmds_in_transport);
16592
16593 if (un->un_throttle > 1) {
16594 if (un->un_f_use_adaptive_throttle == TRUE) {
16595 switch (throttle_type) {
16596 case SD_THROTTLE_TRAN_BUSY:
16597 if (un->un_busy_throttle == 0) {
16598 un->un_busy_throttle = un->un_throttle;
16599 }
16600 break;
16601 case SD_THROTTLE_QFULL:
16602 un->un_busy_throttle = 0;
16603 break;
16604 default:
16605 ASSERT(FALSE);
16606 }
16607
16608 if (un->un_ncmds_in_transport > 0) {
16609 un->un_throttle = un->un_ncmds_in_transport;
16610 }
16611
16612 } else {
16613 if (un->un_ncmds_in_transport == 0) {
16614 un->un_throttle = 1;
16615 } else {
16616 un->un_throttle = un->un_ncmds_in_transport;
16617 }
16618 }
16619 }
16620
16621 /* Reschedule the timeout if none is currently active */
16622 if (un->un_reset_throttle_timeid == NULL) {
16623 un->un_reset_throttle_timeid = timeout(sd_restore_throttle,
16624 un, SD_THROTTLE_RESET_INTERVAL);
16625 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16626 "sd_reduce_throttle: timeout scheduled!\n");
16627 }
16628
16629 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_reduce_throttle: "
16630 "exit: un:0x%p un_throttle:%d\n", un, un->un_throttle);
16631 }
16632
16633
16634
16635 /*
16636 * Function: sd_restore_throttle
16637 *
16638 * Description: Callback function for timeout(9F). Resets the current
16639 * value of un->un_throttle to its default.
16640 *
16641 * Arguments: arg - pointer to associated softstate for the device.
16642 *
16643 * Context: May be called from interrupt context
16644 */
16645
16646 static void
16647 sd_restore_throttle(void *arg)
16648 {
16649 struct sd_lun *un = arg;
16650
16651 ASSERT(un != NULL);
16652 ASSERT(!mutex_owned(SD_MUTEX(un)));
16653
16654 mutex_enter(SD_MUTEX(un));
16655
16656 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un, "sd_restore_throttle: "
16657 "entry: un:0x%p un_throttle:%d\n", un, un->un_throttle);
16658
16659 un->un_reset_throttle_timeid = NULL;
16660
16661 if (un->un_f_use_adaptive_throttle == TRUE) {
16662 /*
16663 * If un_busy_throttle is nonzero, then it contains the
16664 * value that un_throttle was when we got a TRAN_BUSY back
16665 * from scsi_transport(). We want to revert back to this
16666 * value.
16667 *
16668 * In the QFULL case, the throttle limit will incrementally
16669 * increase until it reaches max throttle.
16670 */
16671 if (un->un_busy_throttle > 0) {
16672 un->un_throttle = un->un_busy_throttle;
16673 un->un_busy_throttle = 0;
16674 } else {
16675 /*
16676 * increase throttle by 10% open gate slowly, schedule
16677 * another restore if saved throttle has not been
16678 * reached
16679 */
16680 short throttle;
16681 if (sd_qfull_throttle_enable) {
16682 throttle = un->un_throttle +
16683 max((un->un_throttle / 10), 1);
16684 un->un_throttle =
16685 (throttle < un->un_saved_throttle) ?
16686 throttle : un->un_saved_throttle;
16687 if (un->un_throttle < un->un_saved_throttle) {
16688 un->un_reset_throttle_timeid =
16689 timeout(sd_restore_throttle,
16690 un,
16691 SD_QFULL_THROTTLE_RESET_INTERVAL);
16692 }
16693 }
16694 }
16695
16696 /*
16697 * If un_throttle has fallen below the low-water mark, we
16698 * restore the maximum value here (and allow it to ratchet
16699 * down again if necessary).
16700 */
16701 if (un->un_throttle < un->un_min_throttle) {
16702 un->un_throttle = un->un_saved_throttle;
16703 }
16704 } else {
16705 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un, "sd_restore_throttle: "
16706 "restoring limit from 0x%x to 0x%x\n",
16707 un->un_throttle, un->un_saved_throttle);
16708 un->un_throttle = un->un_saved_throttle;
16709 }
16710
16711 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un,
16712 "sd_restore_throttle: calling sd_start_cmds!\n");
16713
16714 sd_start_cmds(un, NULL);
16715
16716 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un,
16717 "sd_restore_throttle: exit: un:0x%p un_throttle:%d\n",
16718 un, un->un_throttle);
16719
16720 mutex_exit(SD_MUTEX(un));
16721
16722 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un, "sd_restore_throttle: exit\n");
16723 }
16724
16725 /*
16726 * Function: sdrunout
16727 *
16728 * Description: Callback routine for scsi_init_pkt when a resource allocation
16729 * fails.
16730 *
16731 * Arguments: arg - a pointer to the sd_lun unit struct for the particular
16732 * soft state instance.
16733 *
16734 * Return Code: The scsi_init_pkt routine allows for the callback function to
16735 * return a 0 indicating the callback should be rescheduled or a 1
16736 * indicating not to reschedule. This routine always returns 1
16737 * because the driver always provides a callback function to
16738 * scsi_init_pkt. This results in a callback always being scheduled
16739 * (via the scsi_init_pkt callback implementation) if a resource
16740 * failure occurs.
16741 *
16742 * Context: This callback function may not block or call routines that block
16743 *
16744 * Note: Using the scsi_init_pkt callback facility can result in an I/O
16745 * request persisting at the head of the list which cannot be
16746 * satisfied even after multiple retries. In the future the driver
16747 * may implement some time of maximum runout count before failing
16748 * an I/O.
16749 */
16750
16751 static int
16752 sdrunout(caddr_t arg)
16753 {
16754 struct sd_lun *un = (struct sd_lun *)arg;
16755
16756 ASSERT(un != NULL);
16757 ASSERT(!mutex_owned(SD_MUTEX(un)));
16758
16759 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sdrunout: entry\n");
16760
16761 mutex_enter(SD_MUTEX(un));
16762 sd_start_cmds(un, NULL);
16763 mutex_exit(SD_MUTEX(un));
16764 /*
16765 * This callback routine always returns 1 (i.e. do not reschedule)
16766 * because we always specify sdrunout as the callback handler for
16767 * scsi_init_pkt inside the call to sd_start_cmds.
16768 */
16769 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sdrunout: exit\n");
16770 return (1);
16771 }
16772
16773
16774 /*
16775 * Function: sdintr
16776 *
16777 * Description: Completion callback routine for scsi_pkt(9S) structs
16778 * sent to the HBA driver via scsi_transport(9F).
16779 *
16780 * Context: Interrupt context
16781 */
16782
16783 static void
16784 sdintr(struct scsi_pkt *pktp)
16785 {
16786 struct buf *bp;
16787 struct sd_xbuf *xp;
16788 struct sd_lun *un;
16789 size_t actual_len;
16790 sd_ssc_t *sscp;
16791
16792 ASSERT(pktp != NULL);
16793 bp = (struct buf *)pktp->pkt_private;
16794 ASSERT(bp != NULL);
16795 xp = SD_GET_XBUF(bp);
16796 ASSERT(xp != NULL);
16797 ASSERT(xp->xb_pktp != NULL);
16798 un = SD_GET_UN(bp);
16799 ASSERT(un != NULL);
16800 ASSERT(!mutex_owned(SD_MUTEX(un)));
16801
16802 #ifdef SD_FAULT_INJECTION
16803
16804 SD_INFO(SD_LOG_IOERR, un, "sdintr: sdintr calling Fault injection\n");
16805 /* SD FaultInjection */
16806 sd_faultinjection(pktp);
16807
16808 #endif /* SD_FAULT_INJECTION */
16809
16810 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sdintr: entry: buf:0x%p,"
16811 " xp:0x%p, un:0x%p\n", bp, xp, un);
16812
16813 mutex_enter(SD_MUTEX(un));
16814
16815 ASSERT(un->un_fm_private != NULL);
16816 sscp = &((struct sd_fm_internal *)(un->un_fm_private))->fm_ssc;
16817 ASSERT(sscp != NULL);
16818
16819 /* Reduce the count of the #commands currently in transport */
16820 un->un_ncmds_in_transport--;
16821 ASSERT(un->un_ncmds_in_transport >= 0);
16822
16823 /* Increment counter to indicate that the callback routine is active */
16824 un->un_in_callback++;
16825
16826 SD_UPDATE_KSTATS(un, kstat_runq_exit, bp);
16827
16828 #ifdef SDDEBUG
16829 if (bp == un->un_retry_bp) {
16830 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un, "sdintr: "
16831 "un:0x%p: GOT retry_bp:0x%p un_ncmds_in_transport:%d\n",
16832 un, un->un_retry_bp, un->un_ncmds_in_transport);
16833 }
16834 #endif
16835
16836 /*
16837 * If pkt_reason is CMD_DEV_GONE, fail the command, and update the media
16838 * state if needed.
16839 */
16840 if (pktp->pkt_reason == CMD_DEV_GONE) {
16841 /* Prevent multiple console messages for the same failure. */
16842 if (un->un_last_pkt_reason != CMD_DEV_GONE) {
16843 un->un_last_pkt_reason = CMD_DEV_GONE;
16844 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
16845 "Command failed to complete...Device is gone\n");
16846 }
16847 if (un->un_mediastate != DKIO_DEV_GONE) {
16848 un->un_mediastate = DKIO_DEV_GONE;
16849 cv_broadcast(&un->un_state_cv);
16850 }
16851 /*
16852 * If the command happens to be the REQUEST SENSE command,
16853 * free up the rqs buf and fail the original command.
16854 */
16855 if (bp == un->un_rqs_bp) {
16856 bp = sd_mark_rqs_idle(un, xp);
16857 }
16858 sd_return_failed_command(un, bp, EIO);
16859 goto exit;
16860 }
16861
16862 if (pktp->pkt_state & STATE_XARQ_DONE) {
16863 SD_TRACE(SD_LOG_COMMON, un,
16864 "sdintr: extra sense data received. pkt=%p\n", pktp);
16865 }
16866
16867 /*
16868 * First see if the pkt has auto-request sense data with it....
16869 * Look at the packet state first so we don't take a performance
16870 * hit looking at the arq enabled flag unless absolutely necessary.
16871 */
16872 if ((pktp->pkt_state & STATE_ARQ_DONE) &&
16873 (un->un_f_arq_enabled == TRUE)) {
16874 /*
16875 * The HBA did an auto request sense for this command so check
16876 * for FLAG_DIAGNOSE. If set this indicates a uscsi or internal
16877 * driver command that should not be retried.
16878 */
16879 if ((pktp->pkt_flags & FLAG_DIAGNOSE) != 0) {
16880 /*
16881 * Save the relevant sense info into the xp for the
16882 * original cmd.
16883 */
16884 struct scsi_arq_status *asp;
16885 asp = (struct scsi_arq_status *)(pktp->pkt_scbp);
16886 xp->xb_sense_status =
16887 *((uchar_t *)(&(asp->sts_rqpkt_status)));
16888 xp->xb_sense_state = asp->sts_rqpkt_state;
16889 xp->xb_sense_resid = asp->sts_rqpkt_resid;
16890 if (pktp->pkt_state & STATE_XARQ_DONE) {
16891 actual_len = MAX_SENSE_LENGTH -
16892 xp->xb_sense_resid;
16893 bcopy(&asp->sts_sensedata, xp->xb_sense_data,
16894 MAX_SENSE_LENGTH);
16895 } else {
16896 if (xp->xb_sense_resid > SENSE_LENGTH) {
16897 actual_len = MAX_SENSE_LENGTH -
16898 xp->xb_sense_resid;
16899 } else {
16900 actual_len = SENSE_LENGTH -
16901 xp->xb_sense_resid;
16902 }
16903 if (xp->xb_pkt_flags & SD_XB_USCSICMD) {
16904 if ((((struct uscsi_cmd *)
16905 (xp->xb_pktinfo))->uscsi_rqlen) >
16906 actual_len) {
16907 xp->xb_sense_resid =
16908 (((struct uscsi_cmd *)
16909 (xp->xb_pktinfo))->
16910 uscsi_rqlen) - actual_len;
16911 } else {
16912 xp->xb_sense_resid = 0;
16913 }
16914 }
16915 bcopy(&asp->sts_sensedata, xp->xb_sense_data,
16916 SENSE_LENGTH);
16917 }
16918
16919 /* fail the command */
16920 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16921 "sdintr: arq done and FLAG_DIAGNOSE set\n");
16922 sd_return_failed_command(un, bp, EIO);
16923 goto exit;
16924 }
16925
16926 #if (defined(__i386) || defined(__amd64)) /* DMAFREE for x86 only */
16927 /*
16928 * We want to either retry or fail this command, so free
16929 * the DMA resources here. If we retry the command then
16930 * the DMA resources will be reallocated in sd_start_cmds().
16931 * Note that when PKT_DMA_PARTIAL is used, this reallocation
16932 * causes the *entire* transfer to start over again from the
16933 * beginning of the request, even for PARTIAL chunks that
16934 * have already transferred successfully.
16935 */
16936 if ((un->un_f_is_fibre == TRUE) &&
16937 ((xp->xb_pkt_flags & SD_XB_USCSICMD) == 0) &&
16938 ((pktp->pkt_flags & FLAG_SENSING) == 0)) {
16939 scsi_dmafree(pktp);
16940 xp->xb_pkt_flags |= SD_XB_DMA_FREED;
16941 }
16942 #endif
16943
16944 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16945 "sdintr: arq done, sd_handle_auto_request_sense\n");
16946
16947 sd_handle_auto_request_sense(un, bp, xp, pktp);
16948 goto exit;
16949 }
16950
16951 /* Next see if this is the REQUEST SENSE pkt for the instance */
16952 if (pktp->pkt_flags & FLAG_SENSING) {
16953 /* This pktp is from the unit's REQUEST_SENSE command */
16954 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16955 "sdintr: sd_handle_request_sense\n");
16956 sd_handle_request_sense(un, bp, xp, pktp);
16957 goto exit;
16958 }
16959
16960 /*
16961 * Check to see if the command successfully completed as requested;
16962 * this is the most common case (and also the hot performance path).
16963 *
16964 * Requirements for successful completion are:
16965 * pkt_reason is CMD_CMPLT and packet status is status good.
16966 * In addition:
16967 * - A residual of zero indicates successful completion no matter what
16968 * the command is.
16969 * - If the residual is not zero and the command is not a read or
16970 * write, then it's still defined as successful completion. In other
16971 * words, if the command is a read or write the residual must be
16972 * zero for successful completion.
16973 * - If the residual is not zero and the command is a read or
16974 * write, and it's a USCSICMD, then it's still defined as
16975 * successful completion.
16976 */
16977 if ((pktp->pkt_reason == CMD_CMPLT) &&
16978 (SD_GET_PKT_STATUS(pktp) == STATUS_GOOD)) {
16979
16980 /*
16981 * Since this command is returned with a good status, we
16982 * can reset the count for Sonoma failover.
16983 */
16984 un->un_sonoma_failure_count = 0;
16985
16986 /*
16987 * Return all USCSI commands on good status
16988 */
16989 if (pktp->pkt_resid == 0) {
16990 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16991 "sdintr: returning command for resid == 0\n");
16992 } else if (((SD_GET_PKT_OPCODE(pktp) & 0x1F) != SCMD_READ) &&
16993 ((SD_GET_PKT_OPCODE(pktp) & 0x1F) != SCMD_WRITE)) {
16994 SD_UPDATE_B_RESID(bp, pktp);
16995 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16996 "sdintr: returning command for resid != 0\n");
16997 } else if (xp->xb_pkt_flags & SD_XB_USCSICMD) {
16998 SD_UPDATE_B_RESID(bp, pktp);
16999 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17000 "sdintr: returning uscsi command\n");
17001 } else {
17002 goto not_successful;
17003 }
17004 sd_return_command(un, bp);
17005
17006 /*
17007 * Decrement counter to indicate that the callback routine
17008 * is done.
17009 */
17010 un->un_in_callback--;
17011 ASSERT(un->un_in_callback >= 0);
17012 mutex_exit(SD_MUTEX(un));
17013
17014 return;
17015 }
17016
17017 not_successful:
17018
17019 #if (defined(__i386) || defined(__amd64)) /* DMAFREE for x86 only */
17020 /*
17021 * The following is based upon knowledge of the underlying transport
17022 * and its use of DMA resources. This code should be removed when
17023 * PKT_DMA_PARTIAL support is taken out of the disk driver in favor
17024 * of the new PKT_CMD_BREAKUP protocol. See also sd_initpkt_for_buf()
17025 * and sd_start_cmds().
17026 *
17027 * Free any DMA resources associated with this command if there
17028 * is a chance it could be retried or enqueued for later retry.
17029 * If we keep the DMA binding then mpxio cannot reissue the
17030 * command on another path whenever a path failure occurs.
17031 *
17032 * Note that when PKT_DMA_PARTIAL is used, free/reallocation
17033 * causes the *entire* transfer to start over again from the
17034 * beginning of the request, even for PARTIAL chunks that
17035 * have already transferred successfully.
17036 *
17037 * This is only done for non-uscsi commands (and also skipped for the
17038 * driver's internal RQS command). Also just do this for Fibre Channel
17039 * devices as these are the only ones that support mpxio.
17040 */
17041 if ((un->un_f_is_fibre == TRUE) &&
17042 ((xp->xb_pkt_flags & SD_XB_USCSICMD) == 0) &&
17043 ((pktp->pkt_flags & FLAG_SENSING) == 0)) {
17044 scsi_dmafree(pktp);
17045 xp->xb_pkt_flags |= SD_XB_DMA_FREED;
17046 }
17047 #endif
17048
17049 /*
17050 * The command did not successfully complete as requested so check
17051 * for FLAG_DIAGNOSE. If set this indicates a uscsi or internal
17052 * driver command that should not be retried so just return. If
17053 * FLAG_DIAGNOSE is not set the error will be processed below.
17054 */
17055 if ((pktp->pkt_flags & FLAG_DIAGNOSE) != 0) {
17056 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17057 "sdintr: FLAG_DIAGNOSE: sd_return_failed_command\n");
17058 /*
17059 * Issue a request sense if a check condition caused the error
17060 * (we handle the auto request sense case above), otherwise
17061 * just fail the command.
17062 */
17063 if ((pktp->pkt_reason == CMD_CMPLT) &&
17064 (SD_GET_PKT_STATUS(pktp) == STATUS_CHECK)) {
17065 sd_send_request_sense_command(un, bp, pktp);
17066 } else {
17067 sd_return_failed_command(un, bp, EIO);
17068 }
17069 goto exit;
17070 }
17071
17072 /*
17073 * The command did not successfully complete as requested so process
17074 * the error, retry, and/or attempt recovery.
17075 */
17076 switch (pktp->pkt_reason) {
17077 case CMD_CMPLT:
17078 switch (SD_GET_PKT_STATUS(pktp)) {
17079 case STATUS_GOOD:
17080 /*
17081 * The command completed successfully with a non-zero
17082 * residual
17083 */
17084 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17085 "sdintr: STATUS_GOOD \n");
17086 sd_pkt_status_good(un, bp, xp, pktp);
17087 break;
17088
17089 case STATUS_CHECK:
17090 case STATUS_TERMINATED:
17091 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17092 "sdintr: STATUS_TERMINATED | STATUS_CHECK\n");
17093 sd_pkt_status_check_condition(un, bp, xp, pktp);
17094 break;
17095
17096 case STATUS_BUSY:
17097 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17098 "sdintr: STATUS_BUSY\n");
17099 sd_pkt_status_busy(un, bp, xp, pktp);
17100 break;
17101
17102 case STATUS_RESERVATION_CONFLICT:
17103 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17104 "sdintr: STATUS_RESERVATION_CONFLICT\n");
17105 sd_pkt_status_reservation_conflict(un, bp, xp, pktp);
17106 break;
17107
17108 case STATUS_QFULL:
17109 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17110 "sdintr: STATUS_QFULL\n");
17111 sd_pkt_status_qfull(un, bp, xp, pktp);
17112 break;
17113
17114 case STATUS_MET:
17115 case STATUS_INTERMEDIATE:
17116 case STATUS_SCSI2:
17117 case STATUS_INTERMEDIATE_MET:
17118 case STATUS_ACA_ACTIVE:
17119 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
17120 "Unexpected SCSI status received: 0x%x\n",
17121 SD_GET_PKT_STATUS(pktp));
17122 /*
17123 * Mark the ssc_flags when detected invalid status
17124 * code for non-USCSI command.
17125 */
17126 if (!(xp->xb_pkt_flags & SD_XB_USCSICMD)) {
17127 sd_ssc_set_info(sscp, SSC_FLAGS_INVALID_STATUS,
17128 0, "stat-code");
17129 }
17130 sd_return_failed_command(un, bp, EIO);
17131 break;
17132
17133 default:
17134 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
17135 "Invalid SCSI status received: 0x%x\n",
17136 SD_GET_PKT_STATUS(pktp));
17137 if (!(xp->xb_pkt_flags & SD_XB_USCSICMD)) {
17138 sd_ssc_set_info(sscp, SSC_FLAGS_INVALID_STATUS,
17139 0, "stat-code");
17140 }
17141 sd_return_failed_command(un, bp, EIO);
17142 break;
17143
17144 }
17145 break;
17146
17147 case CMD_INCOMPLETE:
17148 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17149 "sdintr: CMD_INCOMPLETE\n");
17150 sd_pkt_reason_cmd_incomplete(un, bp, xp, pktp);
17151 break;
17152 case CMD_TRAN_ERR:
17153 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17154 "sdintr: CMD_TRAN_ERR\n");
17155 sd_pkt_reason_cmd_tran_err(un, bp, xp, pktp);
17156 break;
17157 case CMD_RESET:
17158 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17159 "sdintr: CMD_RESET \n");
17160 sd_pkt_reason_cmd_reset(un, bp, xp, pktp);
17161 break;
17162 case CMD_ABORTED:
17163 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17164 "sdintr: CMD_ABORTED \n");
17165 sd_pkt_reason_cmd_aborted(un, bp, xp, pktp);
17166 break;
17167 case CMD_TIMEOUT:
17168 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17169 "sdintr: CMD_TIMEOUT\n");
17170 sd_pkt_reason_cmd_timeout(un, bp, xp, pktp);
17171 break;
17172 case CMD_UNX_BUS_FREE:
17173 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17174 "sdintr: CMD_UNX_BUS_FREE \n");
17175 sd_pkt_reason_cmd_unx_bus_free(un, bp, xp, pktp);
17176 break;
17177 case CMD_TAG_REJECT:
17178 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17179 "sdintr: CMD_TAG_REJECT\n");
17180 sd_pkt_reason_cmd_tag_reject(un, bp, xp, pktp);
17181 break;
17182 default:
17183 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17184 "sdintr: default\n");
17185 /*
17186 * Mark the ssc_flags for detecting invliad pkt_reason.
17187 */
17188 if (!(xp->xb_pkt_flags & SD_XB_USCSICMD)) {
17189 sd_ssc_set_info(sscp, SSC_FLAGS_INVALID_PKT_REASON,
17190 0, "pkt-reason");
17191 }
17192 sd_pkt_reason_default(un, bp, xp, pktp);
17193 break;
17194 }
17195
17196 exit:
17197 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sdintr: exit\n");
17198
17199 /* Decrement counter to indicate that the callback routine is done. */
17200 un->un_in_callback--;
17201 ASSERT(un->un_in_callback >= 0);
17202
17203 /*
17204 * At this point, the pkt has been dispatched, ie, it is either
17205 * being re-tried or has been returned to its caller and should
17206 * not be referenced.
17207 */
17208
17209 mutex_exit(SD_MUTEX(un));
17210 }
17211
17212
17213 /*
17214 * Function: sd_print_incomplete_msg
17215 *
17216 * Description: Prints the error message for a CMD_INCOMPLETE error.
17217 *
17218 * Arguments: un - ptr to associated softstate for the device.
17219 * bp - ptr to the buf(9S) for the command.
17220 * arg - message string ptr
17221 * code - SD_DELAYED_RETRY_ISSUED, SD_IMMEDIATE_RETRY_ISSUED,
17222 * or SD_NO_RETRY_ISSUED.
17223 *
17224 * Context: May be called under interrupt context
17225 */
17226
17227 static void
17228 sd_print_incomplete_msg(struct sd_lun *un, struct buf *bp, void *arg, int code)
17229 {
17230 struct scsi_pkt *pktp;
17231 char *msgp;
17232 char *cmdp = arg;
17233
17234 ASSERT(un != NULL);
17235 ASSERT(mutex_owned(SD_MUTEX(un)));
17236 ASSERT(bp != NULL);
17237 ASSERT(arg != NULL);
17238 pktp = SD_GET_PKTP(bp);
17239 ASSERT(pktp != NULL);
17240
17241 switch (code) {
17242 case SD_DELAYED_RETRY_ISSUED:
17243 case SD_IMMEDIATE_RETRY_ISSUED:
17244 msgp = "retrying";
17245 break;
17246 case SD_NO_RETRY_ISSUED:
17247 default:
17248 msgp = "giving up";
17249 break;
17250 }
17251
17252 if ((pktp->pkt_flags & FLAG_SILENT) == 0) {
17253 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
17254 "incomplete %s- %s\n", cmdp, msgp);
17255 }
17256 }
17257
17258
17259
17260 /*
17261 * Function: sd_pkt_status_good
17262 *
17263 * Description: Processing for a STATUS_GOOD code in pkt_status.
17264 *
17265 * Context: May be called under interrupt context
17266 */
17267
17268 static void
17269 sd_pkt_status_good(struct sd_lun *un, struct buf *bp,
17270 struct sd_xbuf *xp, struct scsi_pkt *pktp)
17271 {
17272 char *cmdp;
17273
17274 ASSERT(un != NULL);
17275 ASSERT(mutex_owned(SD_MUTEX(un)));
17276 ASSERT(bp != NULL);
17277 ASSERT(xp != NULL);
17278 ASSERT(pktp != NULL);
17279 ASSERT(pktp->pkt_reason == CMD_CMPLT);
17280 ASSERT(SD_GET_PKT_STATUS(pktp) == STATUS_GOOD);
17281 ASSERT(pktp->pkt_resid != 0);
17282
17283 SD_TRACE(SD_LOG_IO_CORE, un, "sd_pkt_status_good: entry\n");
17284
17285 SD_UPDATE_ERRSTATS(un, sd_harderrs);
17286 switch (SD_GET_PKT_OPCODE(pktp) & 0x1F) {
17287 case SCMD_READ:
17288 cmdp = "read";
17289 break;
17290 case SCMD_WRITE:
17291 cmdp = "write";
17292 break;
17293 default:
17294 SD_UPDATE_B_RESID(bp, pktp);
17295 sd_return_command(un, bp);
17296 SD_TRACE(SD_LOG_IO_CORE, un, "sd_pkt_status_good: exit\n");
17297 return;
17298 }
17299
17300 /*
17301 * See if we can retry the read/write, preferrably immediately.
17302 * If retries are exhaused, then sd_retry_command() will update
17303 * the b_resid count.
17304 */
17305 sd_retry_command(un, bp, SD_RETRIES_STANDARD, sd_print_incomplete_msg,
17306 cmdp, EIO, (clock_t)0, NULL);
17307
17308 SD_TRACE(SD_LOG_IO_CORE, un, "sd_pkt_status_good: exit\n");
17309 }
17310
17311
17312
17313
17314
17315 /*
17316 * Function: sd_handle_request_sense
17317 *
17318 * Description: Processing for non-auto Request Sense command.
17319 *
17320 * Arguments: un - ptr to associated softstate
17321 * sense_bp - ptr to buf(9S) for the RQS command
17322 * sense_xp - ptr to the sd_xbuf for the RQS command
17323 * sense_pktp - ptr to the scsi_pkt(9S) for the RQS command
17324 *
17325 * Context: May be called under interrupt context
17326 */
17327
17328 static void
17329 sd_handle_request_sense(struct sd_lun *un, struct buf *sense_bp,
17330 struct sd_xbuf *sense_xp, struct scsi_pkt *sense_pktp)
17331 {
17332 struct buf *cmd_bp; /* buf for the original command */
17333 struct sd_xbuf *cmd_xp; /* sd_xbuf for the original command */
17334 struct scsi_pkt *cmd_pktp; /* pkt for the original command */
17335 size_t actual_len; /* actual sense data length */
17336
17337 ASSERT(un != NULL);
17338 ASSERT(mutex_owned(SD_MUTEX(un)));
17339 ASSERT(sense_bp != NULL);
17340 ASSERT(sense_xp != NULL);
17341 ASSERT(sense_pktp != NULL);
17342
17343 /*
17344 * Note the sense_bp, sense_xp, and sense_pktp here are for the
17345 * RQS command and not the original command.
17346 */
17347 ASSERT(sense_pktp == un->un_rqs_pktp);
17348 ASSERT(sense_bp == un->un_rqs_bp);
17349 ASSERT((sense_pktp->pkt_flags & (FLAG_SENSING | FLAG_HEAD)) ==
17350 (FLAG_SENSING | FLAG_HEAD));
17351 ASSERT((((SD_GET_XBUF(sense_xp->xb_sense_bp))->xb_pktp->pkt_flags) &
17352 FLAG_SENSING) == FLAG_SENSING);
17353
17354 /* These are the bp, xp, and pktp for the original command */
17355 cmd_bp = sense_xp->xb_sense_bp;
17356 cmd_xp = SD_GET_XBUF(cmd_bp);
17357 cmd_pktp = SD_GET_PKTP(cmd_bp);
17358
17359 if (sense_pktp->pkt_reason != CMD_CMPLT) {
17360 /*
17361 * The REQUEST SENSE command failed. Release the REQUEST
17362 * SENSE command for re-use, get back the bp for the original
17363 * command, and attempt to re-try the original command if
17364 * FLAG_DIAGNOSE is not set in the original packet.
17365 */
17366 SD_UPDATE_ERRSTATS(un, sd_harderrs);
17367 if ((cmd_pktp->pkt_flags & FLAG_DIAGNOSE) == 0) {
17368 cmd_bp = sd_mark_rqs_idle(un, sense_xp);
17369 sd_retry_command(un, cmd_bp, SD_RETRIES_STANDARD,
17370 NULL, NULL, EIO, (clock_t)0, NULL);
17371 return;
17372 }
17373 }
17374
17375 /*
17376 * Save the relevant sense info into the xp for the original cmd.
17377 *
17378 * Note: if the request sense failed the state info will be zero
17379 * as set in sd_mark_rqs_busy()
17380 */
17381 cmd_xp->xb_sense_status = *(sense_pktp->pkt_scbp);
17382 cmd_xp->xb_sense_state = sense_pktp->pkt_state;
17383 actual_len = MAX_SENSE_LENGTH - sense_pktp->pkt_resid;
17384 if ((cmd_xp->xb_pkt_flags & SD_XB_USCSICMD) &&
17385 (((struct uscsi_cmd *)cmd_xp->xb_pktinfo)->uscsi_rqlen >
17386 SENSE_LENGTH)) {
17387 bcopy(sense_bp->b_un.b_addr, cmd_xp->xb_sense_data,
17388 MAX_SENSE_LENGTH);
17389 cmd_xp->xb_sense_resid = sense_pktp->pkt_resid;
17390 } else {
17391 bcopy(sense_bp->b_un.b_addr, cmd_xp->xb_sense_data,
17392 SENSE_LENGTH);
17393 if (actual_len < SENSE_LENGTH) {
17394 cmd_xp->xb_sense_resid = SENSE_LENGTH - actual_len;
17395 } else {
17396 cmd_xp->xb_sense_resid = 0;
17397 }
17398 }
17399
17400 /*
17401 * Free up the RQS command....
17402 * NOTE:
17403 * Must do this BEFORE calling sd_validate_sense_data!
17404 * sd_validate_sense_data may return the original command in
17405 * which case the pkt will be freed and the flags can no
17406 * longer be touched.
17407 * SD_MUTEX is held through this process until the command
17408 * is dispatched based upon the sense data, so there are
17409 * no race conditions.
17410 */
17411 (void) sd_mark_rqs_idle(un, sense_xp);
17412
17413 /*
17414 * For a retryable command see if we have valid sense data, if so then
17415 * turn it over to sd_decode_sense() to figure out the right course of
17416 * action. Just fail a non-retryable command.
17417 */
17418 if ((cmd_pktp->pkt_flags & FLAG_DIAGNOSE) == 0) {
17419 if (sd_validate_sense_data(un, cmd_bp, cmd_xp, actual_len) ==
17420 SD_SENSE_DATA_IS_VALID) {
17421 sd_decode_sense(un, cmd_bp, cmd_xp, cmd_pktp);
17422 }
17423 } else {
17424 SD_DUMP_MEMORY(un, SD_LOG_IO_CORE, "Failed CDB",
17425 (uchar_t *)cmd_pktp->pkt_cdbp, CDB_SIZE, SD_LOG_HEX);
17426 SD_DUMP_MEMORY(un, SD_LOG_IO_CORE, "Sense Data",
17427 (uchar_t *)cmd_xp->xb_sense_data, SENSE_LENGTH, SD_LOG_HEX);
17428 sd_return_failed_command(un, cmd_bp, EIO);
17429 }
17430 }
17431
17432
17433
17434
17435 /*
17436 * Function: sd_handle_auto_request_sense
17437 *
17438 * Description: Processing for auto-request sense information.
17439 *
17440 * Arguments: un - ptr to associated softstate
17441 * bp - ptr to buf(9S) for the command
17442 * xp - ptr to the sd_xbuf for the command
17443 * pktp - ptr to the scsi_pkt(9S) for the command
17444 *
17445 * Context: May be called under interrupt context
17446 */
17447
17448 static void
17449 sd_handle_auto_request_sense(struct sd_lun *un, struct buf *bp,
17450 struct sd_xbuf *xp, struct scsi_pkt *pktp)
17451 {
17452 struct scsi_arq_status *asp;
17453 size_t actual_len;
17454
17455 ASSERT(un != NULL);
17456 ASSERT(mutex_owned(SD_MUTEX(un)));
17457 ASSERT(bp != NULL);
17458 ASSERT(xp != NULL);
17459 ASSERT(pktp != NULL);
17460 ASSERT(pktp != un->un_rqs_pktp);
17461 ASSERT(bp != un->un_rqs_bp);
17462
17463 /*
17464 * For auto-request sense, we get a scsi_arq_status back from
17465 * the HBA, with the sense data in the sts_sensedata member.
17466 * The pkt_scbp of the packet points to this scsi_arq_status.
17467 */
17468 asp = (struct scsi_arq_status *)(pktp->pkt_scbp);
17469
17470 if (asp->sts_rqpkt_reason != CMD_CMPLT) {
17471 /*
17472 * The auto REQUEST SENSE failed; see if we can re-try
17473 * the original command.
17474 */
17475 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
17476 "auto request sense failed (reason=%s)\n",
17477 scsi_rname(asp->sts_rqpkt_reason));
17478
17479 sd_reset_target(un, pktp);
17480
17481 sd_retry_command(un, bp, SD_RETRIES_STANDARD,
17482 NULL, NULL, EIO, (clock_t)0, NULL);
17483 return;
17484 }
17485
17486 /* Save the relevant sense info into the xp for the original cmd. */
17487 xp->xb_sense_status = *((uchar_t *)(&(asp->sts_rqpkt_status)));
17488 xp->xb_sense_state = asp->sts_rqpkt_state;
17489 xp->xb_sense_resid = asp->sts_rqpkt_resid;
17490 if (xp->xb_sense_state & STATE_XARQ_DONE) {
17491 actual_len = MAX_SENSE_LENGTH - xp->xb_sense_resid;
17492 bcopy(&asp->sts_sensedata, xp->xb_sense_data,
17493 MAX_SENSE_LENGTH);
17494 } else {
17495 if (xp->xb_sense_resid > SENSE_LENGTH) {
17496 actual_len = MAX_SENSE_LENGTH - xp->xb_sense_resid;
17497 } else {
17498 actual_len = SENSE_LENGTH - xp->xb_sense_resid;
17499 }
17500 if (xp->xb_pkt_flags & SD_XB_USCSICMD) {
17501 if ((((struct uscsi_cmd *)
17502 (xp->xb_pktinfo))->uscsi_rqlen) > actual_len) {
17503 xp->xb_sense_resid = (((struct uscsi_cmd *)
17504 (xp->xb_pktinfo))->uscsi_rqlen) -
17505 actual_len;
17506 } else {
17507 xp->xb_sense_resid = 0;
17508 }
17509 }
17510 bcopy(&asp->sts_sensedata, xp->xb_sense_data, SENSE_LENGTH);
17511 }
17512
17513 /*
17514 * See if we have valid sense data, if so then turn it over to
17515 * sd_decode_sense() to figure out the right course of action.
17516 */
17517 if (sd_validate_sense_data(un, bp, xp, actual_len) ==
17518 SD_SENSE_DATA_IS_VALID) {
17519 sd_decode_sense(un, bp, xp, pktp);
17520 }
17521 }
17522
17523
17524 /*
17525 * Function: sd_print_sense_failed_msg
17526 *
17527 * Description: Print log message when RQS has failed.
17528 *
17529 * Arguments: un - ptr to associated softstate
17530 * bp - ptr to buf(9S) for the command
17531 * arg - generic message string ptr
17532 * code - SD_IMMEDIATE_RETRY_ISSUED, SD_DELAYED_RETRY_ISSUED,
17533 * or SD_NO_RETRY_ISSUED
17534 *
17535 * Context: May be called from interrupt context
17536 */
17537
17538 static void
17539 sd_print_sense_failed_msg(struct sd_lun *un, struct buf *bp, void *arg,
17540 int code)
17541 {
17542 char *msgp = arg;
17543
17544 ASSERT(un != NULL);
17545 ASSERT(mutex_owned(SD_MUTEX(un)));
17546 ASSERT(bp != NULL);
17547
17548 if ((code == SD_NO_RETRY_ISSUED) && (msgp != NULL)) {
17549 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, msgp);
17550 }
17551 }
17552
17553
17554 /*
17555 * Function: sd_validate_sense_data
17556 *
17557 * Description: Check the given sense data for validity.
17558 * If the sense data is not valid, the command will
17559 * be either failed or retried!
17560 *
17561 * Return Code: SD_SENSE_DATA_IS_INVALID
17562 * SD_SENSE_DATA_IS_VALID
17563 *
17564 * Context: May be called from interrupt context
17565 */
17566
17567 static int
17568 sd_validate_sense_data(struct sd_lun *un, struct buf *bp, struct sd_xbuf *xp,
17569 size_t actual_len)
17570 {
17571 struct scsi_extended_sense *esp;
17572 struct scsi_pkt *pktp;
17573 char *msgp = NULL;
17574 sd_ssc_t *sscp;
17575
17576 ASSERT(un != NULL);
17577 ASSERT(mutex_owned(SD_MUTEX(un)));
17578 ASSERT(bp != NULL);
17579 ASSERT(bp != un->un_rqs_bp);
17580 ASSERT(xp != NULL);
17581 ASSERT(un->un_fm_private != NULL);
17582
17583 pktp = SD_GET_PKTP(bp);
17584 ASSERT(pktp != NULL);
17585
17586 sscp = &((struct sd_fm_internal *)(un->un_fm_private))->fm_ssc;
17587 ASSERT(sscp != NULL);
17588
17589 /*
17590 * Check the status of the RQS command (auto or manual).
17591 */
17592 switch (xp->xb_sense_status & STATUS_MASK) {
17593 case STATUS_GOOD:
17594 break;
17595
17596 case STATUS_RESERVATION_CONFLICT:
17597 sd_pkt_status_reservation_conflict(un, bp, xp, pktp);
17598 return (SD_SENSE_DATA_IS_INVALID);
17599
17600 case STATUS_BUSY:
17601 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
17602 "Busy Status on REQUEST SENSE\n");
17603 sd_retry_command(un, bp, SD_RETRIES_BUSY, NULL,
17604 NULL, EIO, un->un_busy_timeout / 500, kstat_waitq_enter);
17605 return (SD_SENSE_DATA_IS_INVALID);
17606
17607 case STATUS_QFULL:
17608 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
17609 "QFULL Status on REQUEST SENSE\n");
17610 sd_retry_command(un, bp, SD_RETRIES_STANDARD, NULL,
17611 NULL, EIO, un->un_busy_timeout / 500, kstat_waitq_enter);
17612 return (SD_SENSE_DATA_IS_INVALID);
17613
17614 case STATUS_CHECK:
17615 case STATUS_TERMINATED:
17616 msgp = "Check Condition on REQUEST SENSE\n";
17617 goto sense_failed;
17618
17619 default:
17620 msgp = "Not STATUS_GOOD on REQUEST_SENSE\n";
17621 goto sense_failed;
17622 }
17623
17624 /*
17625 * See if we got the minimum required amount of sense data.
17626 * Note: We are assuming the returned sense data is SENSE_LENGTH bytes
17627 * or less.
17628 */
17629 if (((xp->xb_sense_state & STATE_XFERRED_DATA) == 0) ||
17630 (actual_len == 0)) {
17631 msgp = "Request Sense couldn't get sense data\n";
17632 goto sense_failed;
17633 }
17634
17635 if (actual_len < SUN_MIN_SENSE_LENGTH) {
17636 msgp = "Not enough sense information\n";
17637 /* Mark the ssc_flags for detecting invalid sense data */
17638 if (!(xp->xb_pkt_flags & SD_XB_USCSICMD)) {
17639 sd_ssc_set_info(sscp, SSC_FLAGS_INVALID_SENSE, 0,
17640 "sense-data");
17641 }
17642 goto sense_failed;
17643 }
17644
17645 /*
17646 * We require the extended sense data
17647 */
17648 esp = (struct scsi_extended_sense *)xp->xb_sense_data;
17649 if (esp->es_class != CLASS_EXTENDED_SENSE) {
17650 if ((pktp->pkt_flags & FLAG_SILENT) == 0) {
17651 static char tmp[8];
17652 static char buf[148];
17653 char *p = (char *)(xp->xb_sense_data);
17654 int i;
17655
17656 mutex_enter(&sd_sense_mutex);
17657 (void) strcpy(buf, "undecodable sense information:");
17658 for (i = 0; i < actual_len; i++) {
17659 (void) sprintf(tmp, " 0x%x", *(p++)&0xff);
17660 (void) strcpy(&buf[strlen(buf)], tmp);
17661 }
17662 i = strlen(buf);
17663 (void) strcpy(&buf[i], "-(assumed fatal)\n");
17664
17665 if (SD_FM_LOG(un) == SD_FM_LOG_NSUP) {
17666 scsi_log(SD_DEVINFO(un), sd_label,
17667 CE_WARN, buf);
17668 }
17669 mutex_exit(&sd_sense_mutex);
17670 }
17671
17672 /* Mark the ssc_flags for detecting invalid sense data */
17673 if (!(xp->xb_pkt_flags & SD_XB_USCSICMD)) {
17674 sd_ssc_set_info(sscp, SSC_FLAGS_INVALID_SENSE, 0,
17675 "sense-data");
17676 }
17677
17678 /* Note: Legacy behavior, fail the command with no retry */
17679 sd_return_failed_command(un, bp, EIO);
17680 return (SD_SENSE_DATA_IS_INVALID);
17681 }
17682
17683 /*
17684 * Check that es_code is valid (es_class concatenated with es_code
17685 * make up the "response code" field. es_class will always be 7, so
17686 * make sure es_code is 0, 1, 2, 3 or 0xf. es_code will indicate the
17687 * format.
17688 */
17689 if ((esp->es_code != CODE_FMT_FIXED_CURRENT) &&
17690 (esp->es_code != CODE_FMT_FIXED_DEFERRED) &&
17691 (esp->es_code != CODE_FMT_DESCR_CURRENT) &&
17692 (esp->es_code != CODE_FMT_DESCR_DEFERRED) &&
17693 (esp->es_code != CODE_FMT_VENDOR_SPECIFIC)) {
17694 /* Mark the ssc_flags for detecting invalid sense data */
17695 if (!(xp->xb_pkt_flags & SD_XB_USCSICMD)) {
17696 sd_ssc_set_info(sscp, SSC_FLAGS_INVALID_SENSE, 0,
17697 "sense-data");
17698 }
17699 goto sense_failed;
17700 }
17701
17702 return (SD_SENSE_DATA_IS_VALID);
17703
17704 sense_failed:
17705 /*
17706 * If the request sense failed (for whatever reason), attempt
17707 * to retry the original command.
17708 */
17709 #if defined(__i386) || defined(__amd64)
17710 /*
17711 * SD_RETRY_DELAY is conditionally compile (#if fibre) in
17712 * sddef.h for Sparc platform, and x86 uses 1 binary
17713 * for both SCSI/FC.
17714 * The SD_RETRY_DELAY value need to be adjusted here
17715 * when SD_RETRY_DELAY change in sddef.h
17716 */
17717 sd_retry_command(un, bp, SD_RETRIES_STANDARD,
17718 sd_print_sense_failed_msg, msgp, EIO,
17719 un->un_f_is_fibre?drv_usectohz(100000):(clock_t)0, NULL);
17720 #else
17721 sd_retry_command(un, bp, SD_RETRIES_STANDARD,
17722 sd_print_sense_failed_msg, msgp, EIO, SD_RETRY_DELAY, NULL);
17723 #endif
17724
17725 return (SD_SENSE_DATA_IS_INVALID);
17726 }
17727
17728 /*
17729 * Function: sd_decode_sense
17730 *
17731 * Description: Take recovery action(s) when SCSI Sense Data is received.
17732 *
17733 * Context: Interrupt context.
17734 */
17735
17736 static void
17737 sd_decode_sense(struct sd_lun *un, struct buf *bp, struct sd_xbuf *xp,
17738 struct scsi_pkt *pktp)
17739 {
17740 uint8_t sense_key;
17741
17742 ASSERT(un != NULL);
17743 ASSERT(mutex_owned(SD_MUTEX(un)));
17744 ASSERT(bp != NULL);
17745 ASSERT(bp != un->un_rqs_bp);
17746 ASSERT(xp != NULL);
17747 ASSERT(pktp != NULL);
17748
17749 sense_key = scsi_sense_key(xp->xb_sense_data);
17750
17751 switch (sense_key) {
17752 case KEY_NO_SENSE:
17753 sd_sense_key_no_sense(un, bp, xp, pktp);
17754 break;
17755 case KEY_RECOVERABLE_ERROR:
17756 sd_sense_key_recoverable_error(un, xp->xb_sense_data,
17757 bp, xp, pktp);
17758 break;
17759 case KEY_NOT_READY:
17760 sd_sense_key_not_ready(un, xp->xb_sense_data,
17761 bp, xp, pktp);
17762 break;
17763 case KEY_MEDIUM_ERROR:
17764 case KEY_HARDWARE_ERROR:
17765 sd_sense_key_medium_or_hardware_error(un,
17766 xp->xb_sense_data, bp, xp, pktp);
17767 break;
17768 case KEY_ILLEGAL_REQUEST:
17769 sd_sense_key_illegal_request(un, bp, xp, pktp);
17770 break;
17771 case KEY_UNIT_ATTENTION:
17772 sd_sense_key_unit_attention(un, xp->xb_sense_data,
17773 bp, xp, pktp);
17774 break;
17775 case KEY_WRITE_PROTECT:
17776 case KEY_VOLUME_OVERFLOW:
17777 case KEY_MISCOMPARE:
17778 sd_sense_key_fail_command(un, bp, xp, pktp);
17779 break;
17780 case KEY_BLANK_CHECK:
17781 sd_sense_key_blank_check(un, bp, xp, pktp);
17782 break;
17783 case KEY_ABORTED_COMMAND:
17784 sd_sense_key_aborted_command(un, bp, xp, pktp);
17785 break;
17786 case KEY_VENDOR_UNIQUE:
17787 case KEY_COPY_ABORTED:
17788 case KEY_EQUAL:
17789 case KEY_RESERVED:
17790 default:
17791 sd_sense_key_default(un, xp->xb_sense_data,
17792 bp, xp, pktp);
17793 break;
17794 }
17795 }
17796
17797
17798 /*
17799 * Function: sd_dump_memory
17800 *
17801 * Description: Debug logging routine to print the contents of a user provided
17802 * buffer. The output of the buffer is broken up into 256 byte
17803 * segments due to a size constraint of the scsi_log.
17804 * implementation.
17805 *
17806 * Arguments: un - ptr to softstate
17807 * comp - component mask
17808 * title - "title" string to preceed data when printed
17809 * data - ptr to data block to be printed
17810 * len - size of data block to be printed
17811 * fmt - SD_LOG_HEX (use 0x%02x format) or SD_LOG_CHAR (use %c)
17812 *
17813 * Context: May be called from interrupt context
17814 */
17815
17816 #define SD_DUMP_MEMORY_BUF_SIZE 256
17817
17818 static char *sd_dump_format_string[] = {
17819 " 0x%02x",
17820 " %c"
17821 };
17822
17823 static void
17824 sd_dump_memory(struct sd_lun *un, uint_t comp, char *title, uchar_t *data,
17825 int len, int fmt)
17826 {
17827 int i, j;
17828 int avail_count;
17829 int start_offset;
17830 int end_offset;
17831 size_t entry_len;
17832 char *bufp;
17833 char *local_buf;
17834 char *format_string;
17835
17836 ASSERT((fmt == SD_LOG_HEX) || (fmt == SD_LOG_CHAR));
17837
17838 /*
17839 * In the debug version of the driver, this function is called from a
17840 * number of places which are NOPs in the release driver.
17841 * The debug driver therefore has additional methods of filtering
17842 * debug output.
17843 */
17844 #ifdef SDDEBUG
17845 /*
17846 * In the debug version of the driver we can reduce the amount of debug
17847 * messages by setting sd_error_level to something other than
17848 * SCSI_ERR_ALL and clearing bits in sd_level_mask and
17849 * sd_component_mask.
17850 */
17851 if (((sd_level_mask & (SD_LOGMASK_DUMP_MEM | SD_LOGMASK_DIAG)) == 0) ||
17852 (sd_error_level != SCSI_ERR_ALL)) {
17853 return;
17854 }
17855 if (((sd_component_mask & comp) == 0) ||
17856 (sd_error_level != SCSI_ERR_ALL)) {
17857 return;
17858 }
17859 #else
17860 if (sd_error_level != SCSI_ERR_ALL) {
17861 return;
17862 }
17863 #endif
17864
17865 local_buf = kmem_zalloc(SD_DUMP_MEMORY_BUF_SIZE, KM_SLEEP);
17866 bufp = local_buf;
17867 /*
17868 * Available length is the length of local_buf[], minus the
17869 * length of the title string, minus one for the ":", minus
17870 * one for the newline, minus one for the NULL terminator.
17871 * This gives the #bytes available for holding the printed
17872 * values from the given data buffer.
17873 */
17874 if (fmt == SD_LOG_HEX) {
17875 format_string = sd_dump_format_string[0];
17876 } else /* SD_LOG_CHAR */ {
17877 format_string = sd_dump_format_string[1];
17878 }
17879 /*
17880 * Available count is the number of elements from the given
17881 * data buffer that we can fit into the available length.
17882 * This is based upon the size of the format string used.
17883 * Make one entry and find it's size.
17884 */
17885 (void) sprintf(bufp, format_string, data[0]);
17886 entry_len = strlen(bufp);
17887 avail_count = (SD_DUMP_MEMORY_BUF_SIZE - strlen(title) - 3) / entry_len;
17888
17889 j = 0;
17890 while (j < len) {
17891 bufp = local_buf;
17892 bzero(bufp, SD_DUMP_MEMORY_BUF_SIZE);
17893 start_offset = j;
17894
17895 end_offset = start_offset + avail_count;
17896
17897 (void) sprintf(bufp, "%s:", title);
17898 bufp += strlen(bufp);
17899 for (i = start_offset; ((i < end_offset) && (j < len));
17900 i++, j++) {
17901 (void) sprintf(bufp, format_string, data[i]);
17902 bufp += entry_len;
17903 }
17904 (void) sprintf(bufp, "\n");
17905
17906 scsi_log(SD_DEVINFO(un), sd_label, CE_NOTE, "%s", local_buf);
17907 }
17908 kmem_free(local_buf, SD_DUMP_MEMORY_BUF_SIZE);
17909 }
17910
17911 /*
17912 * Function: sd_print_sense_msg
17913 *
17914 * Description: Log a message based upon the given sense data.
17915 *
17916 * Arguments: un - ptr to associated softstate
17917 * bp - ptr to buf(9S) for the command
17918 * arg - ptr to associate sd_sense_info struct
17919 * code - SD_IMMEDIATE_RETRY_ISSUED, SD_DELAYED_RETRY_ISSUED,
17920 * or SD_NO_RETRY_ISSUED
17921 *
17922 * Context: May be called from interrupt context
17923 */
17924
17925 static void
17926 sd_print_sense_msg(struct sd_lun *un, struct buf *bp, void *arg, int code)
17927 {
17928 struct sd_xbuf *xp;
17929 struct scsi_pkt *pktp;
17930 uint8_t *sensep;
17931 daddr_t request_blkno;
17932 diskaddr_t err_blkno;
17933 int severity;
17934 int pfa_flag;
17935 extern struct scsi_key_strings scsi_cmds[];
17936
17937 ASSERT(un != NULL);
17938 ASSERT(mutex_owned(SD_MUTEX(un)));
17939 ASSERT(bp != NULL);
17940 xp = SD_GET_XBUF(bp);
17941 ASSERT(xp != NULL);
17942 pktp = SD_GET_PKTP(bp);
17943 ASSERT(pktp != NULL);
17944 ASSERT(arg != NULL);
17945
17946 severity = ((struct sd_sense_info *)(arg))->ssi_severity;
17947 pfa_flag = ((struct sd_sense_info *)(arg))->ssi_pfa_flag;
17948
17949 if ((code == SD_DELAYED_RETRY_ISSUED) ||
17950 (code == SD_IMMEDIATE_RETRY_ISSUED)) {
17951 severity = SCSI_ERR_RETRYABLE;
17952 }
17953
17954 /* Use absolute block number for the request block number */
17955 request_blkno = xp->xb_blkno;
17956
17957 /*
17958 * Now try to get the error block number from the sense data
17959 */
17960 sensep = xp->xb_sense_data;
17961
17962 if (scsi_sense_info_uint64(sensep, SENSE_LENGTH,
17963 (uint64_t *)&err_blkno)) {
17964 /*
17965 * We retrieved the error block number from the information
17966 * portion of the sense data.
17967 *
17968 * For USCSI commands we are better off using the error
17969 * block no. as the requested block no. (This is the best
17970 * we can estimate.)
17971 */
17972 if ((SD_IS_BUFIO(xp) == FALSE) &&
17973 ((pktp->pkt_flags & FLAG_SILENT) == 0)) {
17974 request_blkno = err_blkno;
17975 }
17976 } else {
17977 /*
17978 * Without the es_valid bit set (for fixed format) or an
17979 * information descriptor (for descriptor format) we cannot
17980 * be certain of the error blkno, so just use the
17981 * request_blkno.
17982 */
17983 err_blkno = (diskaddr_t)request_blkno;
17984 }
17985
17986 /*
17987 * The following will log the buffer contents for the release driver
17988 * if the SD_LOGMASK_DIAG bit of sd_level_mask is set, or the error
17989 * level is set to verbose.
17990 */
17991 sd_dump_memory(un, SD_LOG_IO, "Failed CDB",
17992 (uchar_t *)pktp->pkt_cdbp, CDB_SIZE, SD_LOG_HEX);
17993 sd_dump_memory(un, SD_LOG_IO, "Sense Data",
17994 (uchar_t *)sensep, SENSE_LENGTH, SD_LOG_HEX);
17995
17996 if (pfa_flag == FALSE) {
17997 /* This is normally only set for USCSI */
17998 if ((pktp->pkt_flags & FLAG_SILENT) != 0) {
17999 return;
18000 }
18001
18002 if ((SD_IS_BUFIO(xp) == TRUE) &&
18003 (((sd_level_mask & SD_LOGMASK_DIAG) == 0) &&
18004 (severity < sd_error_level))) {
18005 return;
18006 }
18007 }
18008 /*
18009 * Check for Sonoma Failover and keep a count of how many failed I/O's
18010 */
18011 if ((SD_IS_LSI(un)) &&
18012 (scsi_sense_key(sensep) == KEY_ILLEGAL_REQUEST) &&
18013 (scsi_sense_asc(sensep) == 0x94) &&
18014 (scsi_sense_ascq(sensep) == 0x01)) {
18015 un->un_sonoma_failure_count++;
18016 if (un->un_sonoma_failure_count > 1) {
18017 return;
18018 }
18019 }
18020
18021 if (SD_FM_LOG(un) == SD_FM_LOG_NSUP ||
18022 ((scsi_sense_key(sensep) == KEY_RECOVERABLE_ERROR) &&
18023 (pktp->pkt_resid == 0))) {
18024 scsi_vu_errmsg(SD_SCSI_DEVP(un), pktp, sd_label, severity,
18025 request_blkno, err_blkno, scsi_cmds,
18026 (struct scsi_extended_sense *)sensep,
18027 un->un_additional_codes, NULL);
18028 }
18029 }
18030
18031 /*
18032 * Function: sd_sense_key_no_sense
18033 *
18034 * Description: Recovery action when sense data was not received.
18035 *
18036 * Context: May be called from interrupt context
18037 */
18038
18039 static void
18040 sd_sense_key_no_sense(struct sd_lun *un, struct buf *bp, struct sd_xbuf *xp,
18041 struct scsi_pkt *pktp)
18042 {
18043 struct sd_sense_info si;
18044
18045 ASSERT(un != NULL);
18046 ASSERT(mutex_owned(SD_MUTEX(un)));
18047 ASSERT(bp != NULL);
18048 ASSERT(xp != NULL);
18049 ASSERT(pktp != NULL);
18050
18051 si.ssi_severity = SCSI_ERR_FATAL;
18052 si.ssi_pfa_flag = FALSE;
18053
18054 SD_UPDATE_ERRSTATS(un, sd_softerrs);
18055
18056 sd_retry_command(un, bp, SD_RETRIES_STANDARD, sd_print_sense_msg,
18057 &si, EIO, (clock_t)0, NULL);
18058 }
18059
18060
18061 /*
18062 * Function: sd_sense_key_recoverable_error
18063 *
18064 * Description: Recovery actions for a SCSI "Recovered Error" sense key.
18065 *
18066 * Context: May be called from interrupt context
18067 */
18068
18069 static void
18070 sd_sense_key_recoverable_error(struct sd_lun *un, uint8_t *sense_datap,
18071 struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp)
18072 {
18073 struct sd_sense_info si;
18074 uint8_t asc = scsi_sense_asc(sense_datap);
18075 uint8_t ascq = scsi_sense_ascq(sense_datap);
18076
18077 ASSERT(un != NULL);
18078 ASSERT(mutex_owned(SD_MUTEX(un)));
18079 ASSERT(bp != NULL);
18080 ASSERT(xp != NULL);
18081 ASSERT(pktp != NULL);
18082
18083 /*
18084 * 0x00, 0x1D: ATA PASSTHROUGH INFORMATION AVAILABLE
18085 */
18086 if (asc == 0x00 && ascq == 0x1D) {
18087 sd_return_command(un, bp);
18088 return;
18089 }
18090
18091 /*
18092 * 0x5D: FAILURE PREDICTION THRESHOLD EXCEEDED
18093 */
18094 if ((asc == 0x5D) && (sd_report_pfa != 0)) {
18095 SD_UPDATE_ERRSTATS(un, sd_rq_pfa_err);
18096 si.ssi_severity = SCSI_ERR_INFO;
18097 si.ssi_pfa_flag = TRUE;
18098 } else {
18099 SD_UPDATE_ERRSTATS(un, sd_softerrs);
18100 SD_UPDATE_ERRSTATS(un, sd_rq_recov_err);
18101 si.ssi_severity = SCSI_ERR_RECOVERED;
18102 si.ssi_pfa_flag = FALSE;
18103 }
18104
18105 if (pktp->pkt_resid == 0) {
18106 sd_print_sense_msg(un, bp, &si, SD_NO_RETRY_ISSUED);
18107 sd_return_command(un, bp);
18108 return;
18109 }
18110
18111 sd_retry_command(un, bp, SD_RETRIES_STANDARD, sd_print_sense_msg,
18112 &si, EIO, (clock_t)0, NULL);
18113 }
18114
18115
18116
18117
18118 /*
18119 * Function: sd_sense_key_not_ready
18120 *
18121 * Description: Recovery actions for a SCSI "Not Ready" sense key.
18122 *
18123 * Context: May be called from interrupt context
18124 */
18125
18126 static void
18127 sd_sense_key_not_ready(struct sd_lun *un, uint8_t *sense_datap, struct buf *bp,
18128 struct sd_xbuf *xp, struct scsi_pkt *pktp)
18129 {
18130 struct sd_sense_info si;
18131 uint8_t asc = scsi_sense_asc(sense_datap);
18132 uint8_t ascq = scsi_sense_ascq(sense_datap);
18133
18134 ASSERT(un != NULL);
18135 ASSERT(mutex_owned(SD_MUTEX(un)));
18136 ASSERT(bp != NULL);
18137 ASSERT(xp != NULL);
18138 ASSERT(pktp != NULL);
18139
18140 si.ssi_severity = SCSI_ERR_FATAL;
18141 si.ssi_pfa_flag = FALSE;
18142
18143 /*
18144 * Update error stats after first NOT READY error. Disks may have
18145 * been powered down and may need to be restarted. For CDROMs,
18146 * report NOT READY errors only if media is present.
18147 */
18148 if ((ISCD(un) && (asc == 0x3A)) ||
18149 (xp->xb_nr_retry_count > 0)) {
18150 SD_UPDATE_ERRSTATS(un, sd_harderrs);
18151 SD_UPDATE_ERRSTATS(un, sd_rq_ntrdy_err);
18152 }
18153
18154 /*
18155 * Just fail if the "not ready" retry limit has been reached.
18156 */
18157 if (xp->xb_nr_retry_count >= un->un_notready_retry_count) {
18158 /* Special check for error message printing for removables. */
18159 if (un->un_f_has_removable_media && (asc == 0x04) &&
18160 (ascq >= 0x04)) {
18161 si.ssi_severity = SCSI_ERR_ALL;
18162 }
18163 goto fail_command;
18164 }
18165
18166 /*
18167 * Check the ASC and ASCQ in the sense data as needed, to determine
18168 * what to do.
18169 */
18170 switch (asc) {
18171 case 0x04: /* LOGICAL UNIT NOT READY */
18172 /*
18173 * disk drives that don't spin up result in a very long delay
18174 * in format without warning messages. We will log a message
18175 * if the error level is set to verbose.
18176 */
18177 if (sd_error_level < SCSI_ERR_RETRYABLE) {
18178 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
18179 "logical unit not ready, resetting disk\n");
18180 }
18181
18182 /*
18183 * There are different requirements for CDROMs and disks for
18184 * the number of retries. If a CD-ROM is giving this, it is
18185 * probably reading TOC and is in the process of getting
18186 * ready, so we should keep on trying for a long time to make
18187 * sure that all types of media are taken in account (for
18188 * some media the drive takes a long time to read TOC). For
18189 * disks we do not want to retry this too many times as this
18190 * can cause a long hang in format when the drive refuses to
18191 * spin up (a very common failure).
18192 */
18193 switch (ascq) {
18194 case 0x00: /* LUN NOT READY, CAUSE NOT REPORTABLE */
18195 /*
18196 * Disk drives frequently refuse to spin up which
18197 * results in a very long hang in format without
18198 * warning messages.
18199 *
18200 * Note: This code preserves the legacy behavior of
18201 * comparing xb_nr_retry_count against zero for fibre
18202 * channel targets instead of comparing against the
18203 * un_reset_retry_count value. The reason for this
18204 * discrepancy has been so utterly lost beneath the
18205 * Sands of Time that even Indiana Jones could not
18206 * find it.
18207 */
18208 if (un->un_f_is_fibre == TRUE) {
18209 if (((sd_level_mask & SD_LOGMASK_DIAG) ||
18210 (xp->xb_nr_retry_count > 0)) &&
18211 (un->un_startstop_timeid == NULL)) {
18212 scsi_log(SD_DEVINFO(un), sd_label,
18213 CE_WARN, "logical unit not ready, "
18214 "resetting disk\n");
18215 sd_reset_target(un, pktp);
18216 }
18217 } else {
18218 if (((sd_level_mask & SD_LOGMASK_DIAG) ||
18219 (xp->xb_nr_retry_count >
18220 un->un_reset_retry_count)) &&
18221 (un->un_startstop_timeid == NULL)) {
18222 scsi_log(SD_DEVINFO(un), sd_label,
18223 CE_WARN, "logical unit not ready, "
18224 "resetting disk\n");
18225 sd_reset_target(un, pktp);
18226 }
18227 }
18228 break;
18229
18230 case 0x01: /* LUN IS IN PROCESS OF BECOMING READY */
18231 /*
18232 * If the target is in the process of becoming
18233 * ready, just proceed with the retry. This can
18234 * happen with CD-ROMs that take a long time to
18235 * read TOC after a power cycle or reset.
18236 */
18237 goto do_retry;
18238
18239 case 0x02: /* LUN NOT READY, INITITIALIZING CMD REQUIRED */
18240 break;
18241
18242 case 0x03: /* LUN NOT READY, MANUAL INTERVENTION REQUIRED */
18243 /*
18244 * Retries cannot help here so just fail right away.
18245 */
18246 goto fail_command;
18247
18248 case 0x88:
18249 /*
18250 * Vendor-unique code for T3/T4: it indicates a
18251 * path problem in a mutipathed config, but as far as
18252 * the target driver is concerned it equates to a fatal
18253 * error, so we should just fail the command right away
18254 * (without printing anything to the console). If this
18255 * is not a T3/T4, fall thru to the default recovery
18256 * action.
18257 * T3/T4 is FC only, don't need to check is_fibre
18258 */
18259 if (SD_IS_T3(un) || SD_IS_T4(un)) {
18260 sd_return_failed_command(un, bp, EIO);
18261 return;
18262 }
18263 /* FALLTHRU */
18264
18265 case 0x04: /* LUN NOT READY, FORMAT IN PROGRESS */
18266 case 0x05: /* LUN NOT READY, REBUILD IN PROGRESS */
18267 case 0x06: /* LUN NOT READY, RECALCULATION IN PROGRESS */
18268 case 0x07: /* LUN NOT READY, OPERATION IN PROGRESS */
18269 case 0x08: /* LUN NOT READY, LONG WRITE IN PROGRESS */
18270 default: /* Possible future codes in SCSI spec? */
18271 /*
18272 * For removable-media devices, do not retry if
18273 * ASCQ > 2 as these result mostly from USCSI commands
18274 * on MMC devices issued to check status of an
18275 * operation initiated in immediate mode. Also for
18276 * ASCQ >= 4 do not print console messages as these
18277 * mainly represent a user-initiated operation
18278 * instead of a system failure.
18279 */
18280 if (un->un_f_has_removable_media) {
18281 si.ssi_severity = SCSI_ERR_ALL;
18282 goto fail_command;
18283 }
18284 break;
18285 }
18286
18287 /*
18288 * As part of our recovery attempt for the NOT READY
18289 * condition, we issue a START STOP UNIT command. However
18290 * we want to wait for a short delay before attempting this
18291 * as there may still be more commands coming back from the
18292 * target with the check condition. To do this we use
18293 * timeout(9F) to call sd_start_stop_unit_callback() after
18294 * the delay interval expires. (sd_start_stop_unit_callback()
18295 * dispatches sd_start_stop_unit_task(), which will issue
18296 * the actual START STOP UNIT command. The delay interval
18297 * is one-half of the delay that we will use to retry the
18298 * command that generated the NOT READY condition.
18299 *
18300 * Note that we could just dispatch sd_start_stop_unit_task()
18301 * from here and allow it to sleep for the delay interval,
18302 * but then we would be tying up the taskq thread
18303 * uncesessarily for the duration of the delay.
18304 *
18305 * Do not issue the START STOP UNIT if the current command
18306 * is already a START STOP UNIT.
18307 */
18308 if (pktp->pkt_cdbp[0] == SCMD_START_STOP) {
18309 break;
18310 }
18311
18312 /*
18313 * Do not schedule the timeout if one is already pending.
18314 */
18315 if (un->un_startstop_timeid != NULL) {
18316 SD_INFO(SD_LOG_ERROR, un,
18317 "sd_sense_key_not_ready: restart already issued to"
18318 " %s%d\n", ddi_driver_name(SD_DEVINFO(un)),
18319 ddi_get_instance(SD_DEVINFO(un)));
18320 break;
18321 }
18322
18323 /*
18324 * Schedule the START STOP UNIT command, then queue the command
18325 * for a retry.
18326 *
18327 * Note: A timeout is not scheduled for this retry because we
18328 * want the retry to be serial with the START_STOP_UNIT. The
18329 * retry will be started when the START_STOP_UNIT is completed
18330 * in sd_start_stop_unit_task.
18331 */
18332 un->un_startstop_timeid = timeout(sd_start_stop_unit_callback,
18333 un, un->un_busy_timeout / 2);
18334 xp->xb_nr_retry_count++;
18335 sd_set_retry_bp(un, bp, 0, kstat_waitq_enter);
18336 return;
18337
18338 case 0x05: /* LOGICAL UNIT DOES NOT RESPOND TO SELECTION */
18339 if (sd_error_level < SCSI_ERR_RETRYABLE) {
18340 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
18341 "unit does not respond to selection\n");
18342 }
18343 break;
18344
18345 case 0x3A: /* MEDIUM NOT PRESENT */
18346 if (sd_error_level >= SCSI_ERR_FATAL) {
18347 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
18348 "Caddy not inserted in drive\n");
18349 }
18350
18351 sr_ejected(un);
18352 un->un_mediastate = DKIO_EJECTED;
18353 /* The state has changed, inform the media watch routines */
18354 cv_broadcast(&un->un_state_cv);
18355 /* Just fail if no media is present in the drive. */
18356 goto fail_command;
18357
18358 default:
18359 if (sd_error_level < SCSI_ERR_RETRYABLE) {
18360 scsi_log(SD_DEVINFO(un), sd_label, CE_NOTE,
18361 "Unit not Ready. Additional sense code 0x%x\n",
18362 asc);
18363 }
18364 break;
18365 }
18366
18367 do_retry:
18368
18369 /*
18370 * Retry the command, as some targets may report NOT READY for
18371 * several seconds after being reset.
18372 */
18373 xp->xb_nr_retry_count++;
18374 si.ssi_severity = SCSI_ERR_RETRYABLE;
18375 sd_retry_command(un, bp, SD_RETRIES_NOCHECK, sd_print_sense_msg,
18376 &si, EIO, un->un_busy_timeout, NULL);
18377
18378 return;
18379
18380 fail_command:
18381 sd_print_sense_msg(un, bp, &si, SD_NO_RETRY_ISSUED);
18382 sd_return_failed_command(un, bp, EIO);
18383 }
18384
18385
18386
18387 /*
18388 * Function: sd_sense_key_medium_or_hardware_error
18389 *
18390 * Description: Recovery actions for a SCSI "Medium Error" or "Hardware Error"
18391 * sense key.
18392 *
18393 * Context: May be called from interrupt context
18394 */
18395
18396 static void
18397 sd_sense_key_medium_or_hardware_error(struct sd_lun *un, uint8_t *sense_datap,
18398 struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp)
18399 {
18400 struct sd_sense_info si;
18401 uint8_t sense_key = scsi_sense_key(sense_datap);
18402 uint8_t asc = scsi_sense_asc(sense_datap);
18403
18404 ASSERT(un != NULL);
18405 ASSERT(mutex_owned(SD_MUTEX(un)));
18406 ASSERT(bp != NULL);
18407 ASSERT(xp != NULL);
18408 ASSERT(pktp != NULL);
18409
18410 si.ssi_severity = SCSI_ERR_FATAL;
18411 si.ssi_pfa_flag = FALSE;
18412
18413 if (sense_key == KEY_MEDIUM_ERROR) {
18414 SD_UPDATE_ERRSTATS(un, sd_rq_media_err);
18415 }
18416
18417 SD_UPDATE_ERRSTATS(un, sd_harderrs);
18418
18419 if ((un->un_reset_retry_count != 0) &&
18420 (xp->xb_retry_count == un->un_reset_retry_count)) {
18421 mutex_exit(SD_MUTEX(un));
18422 /* Do NOT do a RESET_ALL here: too intrusive. (4112858) */
18423 if (un->un_f_allow_bus_device_reset == TRUE) {
18424
18425 boolean_t try_resetting_target = B_TRUE;
18426
18427 /*
18428 * We need to be able to handle specific ASC when we are
18429 * handling a KEY_HARDWARE_ERROR. In particular
18430 * taking the default action of resetting the target may
18431 * not be the appropriate way to attempt recovery.
18432 * Resetting a target because of a single LUN failure
18433 * victimizes all LUNs on that target.
18434 *
18435 * This is true for the LSI arrays, if an LSI
18436 * array controller returns an ASC of 0x84 (LUN Dead) we
18437 * should trust it.
18438 */
18439
18440 if (sense_key == KEY_HARDWARE_ERROR) {
18441 switch (asc) {
18442 case 0x84:
18443 if (SD_IS_LSI(un)) {
18444 try_resetting_target = B_FALSE;
18445 }
18446 break;
18447 default:
18448 break;
18449 }
18450 }
18451
18452 if (try_resetting_target == B_TRUE) {
18453 int reset_retval = 0;
18454 if (un->un_f_lun_reset_enabled == TRUE) {
18455 SD_TRACE(SD_LOG_IO_CORE, un,
18456 "sd_sense_key_medium_or_hardware_"
18457 "error: issuing RESET_LUN\n");
18458 reset_retval =
18459 scsi_reset(SD_ADDRESS(un),
18460 RESET_LUN);
18461 }
18462 if (reset_retval == 0) {
18463 SD_TRACE(SD_LOG_IO_CORE, un,
18464 "sd_sense_key_medium_or_hardware_"
18465 "error: issuing RESET_TARGET\n");
18466 (void) scsi_reset(SD_ADDRESS(un),
18467 RESET_TARGET);
18468 }
18469 }
18470 }
18471 mutex_enter(SD_MUTEX(un));
18472 }
18473
18474 /*
18475 * This really ought to be a fatal error, but we will retry anyway
18476 * as some drives report this as a spurious error.
18477 */
18478 sd_retry_command(un, bp, SD_RETRIES_STANDARD, sd_print_sense_msg,
18479 &si, EIO, (clock_t)0, NULL);
18480 }
18481
18482
18483
18484 /*
18485 * Function: sd_sense_key_illegal_request
18486 *
18487 * Description: Recovery actions for a SCSI "Illegal Request" sense key.
18488 *
18489 * Context: May be called from interrupt context
18490 */
18491
18492 static void
18493 sd_sense_key_illegal_request(struct sd_lun *un, struct buf *bp,
18494 struct sd_xbuf *xp, struct scsi_pkt *pktp)
18495 {
18496 struct sd_sense_info si;
18497
18498 ASSERT(un != NULL);
18499 ASSERT(mutex_owned(SD_MUTEX(un)));
18500 ASSERT(bp != NULL);
18501 ASSERT(xp != NULL);
18502 ASSERT(pktp != NULL);
18503
18504 SD_UPDATE_ERRSTATS(un, sd_rq_illrq_err);
18505
18506 si.ssi_severity = SCSI_ERR_INFO;
18507 si.ssi_pfa_flag = FALSE;
18508
18509 /* Pointless to retry if the target thinks it's an illegal request */
18510 sd_print_sense_msg(un, bp, &si, SD_NO_RETRY_ISSUED);
18511 sd_return_failed_command(un, bp, EIO);
18512 }
18513
18514
18515
18516
18517 /*
18518 * Function: sd_sense_key_unit_attention
18519 *
18520 * Description: Recovery actions for a SCSI "Unit Attention" sense key.
18521 *
18522 * Context: May be called from interrupt context
18523 */
18524
18525 static void
18526 sd_sense_key_unit_attention(struct sd_lun *un, uint8_t *sense_datap,
18527 struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp)
18528 {
18529 /*
18530 * For UNIT ATTENTION we allow retries for one minute. Devices
18531 * like Sonoma can return UNIT ATTENTION close to a minute
18532 * under certain conditions.
18533 */
18534 int retry_check_flag = SD_RETRIES_UA;
18535 boolean_t kstat_updated = B_FALSE;
18536 struct sd_sense_info si;
18537 uint8_t asc = scsi_sense_asc(sense_datap);
18538 uint8_t ascq = scsi_sense_ascq(sense_datap);
18539
18540 ASSERT(un != NULL);
18541 ASSERT(mutex_owned(SD_MUTEX(un)));
18542 ASSERT(bp != NULL);
18543 ASSERT(xp != NULL);
18544 ASSERT(pktp != NULL);
18545
18546 si.ssi_severity = SCSI_ERR_INFO;
18547 si.ssi_pfa_flag = FALSE;
18548
18549
18550 switch (asc) {
18551 case 0x5D: /* FAILURE PREDICTION THRESHOLD EXCEEDED */
18552 if (sd_report_pfa != 0) {
18553 SD_UPDATE_ERRSTATS(un, sd_rq_pfa_err);
18554 si.ssi_pfa_flag = TRUE;
18555 retry_check_flag = SD_RETRIES_STANDARD;
18556 goto do_retry;
18557 }
18558
18559 break;
18560
18561 case 0x29: /* POWER ON, RESET, OR BUS DEVICE RESET OCCURRED */
18562 if ((un->un_resvd_status & SD_RESERVE) == SD_RESERVE) {
18563 un->un_resvd_status |=
18564 (SD_LOST_RESERVE | SD_WANT_RESERVE);
18565 }
18566 #ifdef _LP64
18567 if (un->un_blockcount + 1 > SD_GROUP1_MAX_ADDRESS) {
18568 if (taskq_dispatch(sd_tq, sd_reenable_dsense_task,
18569 un, KM_NOSLEEP) == 0) {
18570 /*
18571 * If we can't dispatch the task we'll just
18572 * live without descriptor sense. We can
18573 * try again on the next "unit attention"
18574 */
18575 SD_ERROR(SD_LOG_ERROR, un,
18576 "sd_sense_key_unit_attention: "
18577 "Could not dispatch "
18578 "sd_reenable_dsense_task\n");
18579 }
18580 }
18581 #endif /* _LP64 */
18582 /* FALLTHRU */
18583
18584 case 0x28: /* NOT READY TO READY CHANGE, MEDIUM MAY HAVE CHANGED */
18585 if (!un->un_f_has_removable_media) {
18586 break;
18587 }
18588
18589 /*
18590 * When we get a unit attention from a removable-media device,
18591 * it may be in a state that will take a long time to recover
18592 * (e.g., from a reset). Since we are executing in interrupt
18593 * context here, we cannot wait around for the device to come
18594 * back. So hand this command off to sd_media_change_task()
18595 * for deferred processing under taskq thread context. (Note
18596 * that the command still may be failed if a problem is
18597 * encountered at a later time.)
18598 */
18599 if (taskq_dispatch(sd_tq, sd_media_change_task, pktp,
18600 KM_NOSLEEP) == 0) {
18601 /*
18602 * Cannot dispatch the request so fail the command.
18603 */
18604 SD_UPDATE_ERRSTATS(un, sd_harderrs);
18605 SD_UPDATE_ERRSTATS(un, sd_rq_nodev_err);
18606 si.ssi_severity = SCSI_ERR_FATAL;
18607 sd_print_sense_msg(un, bp, &si, SD_NO_RETRY_ISSUED);
18608 sd_return_failed_command(un, bp, EIO);
18609 }
18610
18611 /*
18612 * If failed to dispatch sd_media_change_task(), we already
18613 * updated kstat. If succeed to dispatch sd_media_change_task(),
18614 * we should update kstat later if it encounters an error. So,
18615 * we update kstat_updated flag here.
18616 */
18617 kstat_updated = B_TRUE;
18618
18619 /*
18620 * Either the command has been successfully dispatched to a
18621 * task Q for retrying, or the dispatch failed. In either case
18622 * do NOT retry again by calling sd_retry_command. This sets up
18623 * two retries of the same command and when one completes and
18624 * frees the resources the other will access freed memory,
18625 * a bad thing.
18626 */
18627 return;
18628
18629 default:
18630 break;
18631 }
18632
18633 /*
18634 * ASC ASCQ
18635 * 2A 09 Capacity data has changed
18636 * 2A 01 Mode parameters changed
18637 * 3F 0E Reported luns data has changed
18638 * Arrays that support logical unit expansion should report
18639 * capacity changes(2Ah/09). Mode parameters changed and
18640 * reported luns data has changed are the approximation.
18641 */
18642 if (((asc == 0x2a) && (ascq == 0x09)) ||
18643 ((asc == 0x2a) && (ascq == 0x01)) ||
18644 ((asc == 0x3f) && (ascq == 0x0e))) {
18645 if (taskq_dispatch(sd_tq, sd_target_change_task, un,
18646 KM_NOSLEEP) == 0) {
18647 SD_ERROR(SD_LOG_ERROR, un,
18648 "sd_sense_key_unit_attention: "
18649 "Could not dispatch sd_target_change_task\n");
18650 }
18651 }
18652
18653 /*
18654 * Update kstat if we haven't done that.
18655 */
18656 if (!kstat_updated) {
18657 SD_UPDATE_ERRSTATS(un, sd_harderrs);
18658 SD_UPDATE_ERRSTATS(un, sd_rq_nodev_err);
18659 }
18660
18661 do_retry:
18662 sd_retry_command(un, bp, retry_check_flag, sd_print_sense_msg, &si,
18663 EIO, SD_UA_RETRY_DELAY, NULL);
18664 }
18665
18666
18667
18668 /*
18669 * Function: sd_sense_key_fail_command
18670 *
18671 * Description: Use to fail a command when we don't like the sense key that
18672 * was returned.
18673 *
18674 * Context: May be called from interrupt context
18675 */
18676
18677 static void
18678 sd_sense_key_fail_command(struct sd_lun *un, struct buf *bp, struct sd_xbuf *xp,
18679 struct scsi_pkt *pktp)
18680 {
18681 struct sd_sense_info si;
18682
18683 ASSERT(un != NULL);
18684 ASSERT(mutex_owned(SD_MUTEX(un)));
18685 ASSERT(bp != NULL);
18686 ASSERT(xp != NULL);
18687 ASSERT(pktp != NULL);
18688
18689 si.ssi_severity = SCSI_ERR_FATAL;
18690 si.ssi_pfa_flag = FALSE;
18691
18692 sd_print_sense_msg(un, bp, &si, SD_NO_RETRY_ISSUED);
18693 sd_return_failed_command(un, bp, EIO);
18694 }
18695
18696
18697
18698 /*
18699 * Function: sd_sense_key_blank_check
18700 *
18701 * Description: Recovery actions for a SCSI "Blank Check" sense key.
18702 * Has no monetary connotation.
18703 *
18704 * Context: May be called from interrupt context
18705 */
18706
18707 static void
18708 sd_sense_key_blank_check(struct sd_lun *un, struct buf *bp, struct sd_xbuf *xp,
18709 struct scsi_pkt *pktp)
18710 {
18711 struct sd_sense_info si;
18712
18713 ASSERT(un != NULL);
18714 ASSERT(mutex_owned(SD_MUTEX(un)));
18715 ASSERT(bp != NULL);
18716 ASSERT(xp != NULL);
18717 ASSERT(pktp != NULL);
18718
18719 /*
18720 * Blank check is not fatal for removable devices, therefore
18721 * it does not require a console message.
18722 */
18723 si.ssi_severity = (un->un_f_has_removable_media) ? SCSI_ERR_ALL :
18724 SCSI_ERR_FATAL;
18725 si.ssi_pfa_flag = FALSE;
18726
18727 sd_print_sense_msg(un, bp, &si, SD_NO_RETRY_ISSUED);
18728 sd_return_failed_command(un, bp, EIO);
18729 }
18730
18731
18732
18733
18734 /*
18735 * Function: sd_sense_key_aborted_command
18736 *
18737 * Description: Recovery actions for a SCSI "Aborted Command" sense key.
18738 *
18739 * Context: May be called from interrupt context
18740 */
18741
18742 static void
18743 sd_sense_key_aborted_command(struct sd_lun *un, struct buf *bp,
18744 struct sd_xbuf *xp, struct scsi_pkt *pktp)
18745 {
18746 struct sd_sense_info si;
18747
18748 ASSERT(un != NULL);
18749 ASSERT(mutex_owned(SD_MUTEX(un)));
18750 ASSERT(bp != NULL);
18751 ASSERT(xp != NULL);
18752 ASSERT(pktp != NULL);
18753
18754 si.ssi_severity = SCSI_ERR_FATAL;
18755 si.ssi_pfa_flag = FALSE;
18756
18757 SD_UPDATE_ERRSTATS(un, sd_harderrs);
18758
18759 /*
18760 * This really ought to be a fatal error, but we will retry anyway
18761 * as some drives report this as a spurious error.
18762 */
18763 sd_retry_command(un, bp, SD_RETRIES_STANDARD, sd_print_sense_msg,
18764 &si, EIO, drv_usectohz(100000), NULL);
18765 }
18766
18767
18768
18769 /*
18770 * Function: sd_sense_key_default
18771 *
18772 * Description: Default recovery action for several SCSI sense keys (basically
18773 * attempts a retry).
18774 *
18775 * Context: May be called from interrupt context
18776 */
18777
18778 static void
18779 sd_sense_key_default(struct sd_lun *un, uint8_t *sense_datap, struct buf *bp,
18780 struct sd_xbuf *xp, struct scsi_pkt *pktp)
18781 {
18782 struct sd_sense_info si;
18783 uint8_t sense_key = scsi_sense_key(sense_datap);
18784
18785 ASSERT(un != NULL);
18786 ASSERT(mutex_owned(SD_MUTEX(un)));
18787 ASSERT(bp != NULL);
18788 ASSERT(xp != NULL);
18789 ASSERT(pktp != NULL);
18790
18791 SD_UPDATE_ERRSTATS(un, sd_harderrs);
18792
18793 /*
18794 * Undecoded sense key. Attempt retries and hope that will fix
18795 * the problem. Otherwise, we're dead.
18796 */
18797 if ((pktp->pkt_flags & FLAG_SILENT) == 0) {
18798 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
18799 "Unhandled Sense Key '%s'\n", sense_keys[sense_key]);
18800 }
18801
18802 si.ssi_severity = SCSI_ERR_FATAL;
18803 si.ssi_pfa_flag = FALSE;
18804
18805 sd_retry_command(un, bp, SD_RETRIES_STANDARD, sd_print_sense_msg,
18806 &si, EIO, (clock_t)0, NULL);
18807 }
18808
18809
18810
18811 /*
18812 * Function: sd_print_retry_msg
18813 *
18814 * Description: Print a message indicating the retry action being taken.
18815 *
18816 * Arguments: un - ptr to associated softstate
18817 * bp - ptr to buf(9S) for the command
18818 * arg - not used.
18819 * flag - SD_IMMEDIATE_RETRY_ISSUED, SD_DELAYED_RETRY_ISSUED,
18820 * or SD_NO_RETRY_ISSUED
18821 *
18822 * Context: May be called from interrupt context
18823 */
18824 /* ARGSUSED */
18825 static void
18826 sd_print_retry_msg(struct sd_lun *un, struct buf *bp, void *arg, int flag)
18827 {
18828 struct sd_xbuf *xp;
18829 struct scsi_pkt *pktp;
18830 char *reasonp;
18831 char *msgp;
18832
18833 ASSERT(un != NULL);
18834 ASSERT(mutex_owned(SD_MUTEX(un)));
18835 ASSERT(bp != NULL);
18836 pktp = SD_GET_PKTP(bp);
18837 ASSERT(pktp != NULL);
18838 xp = SD_GET_XBUF(bp);
18839 ASSERT(xp != NULL);
18840
18841 ASSERT(!mutex_owned(&un->un_pm_mutex));
18842 mutex_enter(&un->un_pm_mutex);
18843 if ((un->un_state == SD_STATE_SUSPENDED) ||
18844 (SD_DEVICE_IS_IN_LOW_POWER(un)) ||
18845 (pktp->pkt_flags & FLAG_SILENT)) {
18846 mutex_exit(&un->un_pm_mutex);
18847 goto update_pkt_reason;
18848 }
18849 mutex_exit(&un->un_pm_mutex);
18850
18851 /*
18852 * Suppress messages if they are all the same pkt_reason; with
18853 * TQ, many (up to 256) are returned with the same pkt_reason.
18854 * If we are in panic, then suppress the retry messages.
18855 */
18856 switch (flag) {
18857 case SD_NO_RETRY_ISSUED:
18858 msgp = "giving up";
18859 break;
18860 case SD_IMMEDIATE_RETRY_ISSUED:
18861 case SD_DELAYED_RETRY_ISSUED:
18862 if (ddi_in_panic() || (un->un_state == SD_STATE_OFFLINE) ||
18863 ((pktp->pkt_reason == un->un_last_pkt_reason) &&
18864 (sd_error_level != SCSI_ERR_ALL))) {
18865 return;
18866 }
18867 msgp = "retrying command";
18868 break;
18869 default:
18870 goto update_pkt_reason;
18871 }
18872
18873 reasonp = (((pktp->pkt_statistics & STAT_PERR) != 0) ? "parity error" :
18874 scsi_rname(pktp->pkt_reason));
18875
18876 if (SD_FM_LOG(un) == SD_FM_LOG_NSUP) {
18877 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
18878 "SCSI transport failed: reason '%s': %s\n", reasonp, msgp);
18879 }
18880
18881 update_pkt_reason:
18882 /*
18883 * Update un->un_last_pkt_reason with the value in pktp->pkt_reason.
18884 * This is to prevent multiple console messages for the same failure
18885 * condition. Note that un->un_last_pkt_reason is NOT restored if &
18886 * when the command is retried successfully because there still may be
18887 * more commands coming back with the same value of pktp->pkt_reason.
18888 */
18889 if ((pktp->pkt_reason != CMD_CMPLT) || (xp->xb_retry_count == 0)) {
18890 un->un_last_pkt_reason = pktp->pkt_reason;
18891 }
18892 }
18893
18894
18895 /*
18896 * Function: sd_print_cmd_incomplete_msg
18897 *
18898 * Description: Message logging fn. for a SCSA "CMD_INCOMPLETE" pkt_reason.
18899 *
18900 * Arguments: un - ptr to associated softstate
18901 * bp - ptr to buf(9S) for the command
18902 * arg - passed to sd_print_retry_msg()
18903 * code - SD_IMMEDIATE_RETRY_ISSUED, SD_DELAYED_RETRY_ISSUED,
18904 * or SD_NO_RETRY_ISSUED
18905 *
18906 * Context: May be called from interrupt context
18907 */
18908
18909 static void
18910 sd_print_cmd_incomplete_msg(struct sd_lun *un, struct buf *bp, void *arg,
18911 int code)
18912 {
18913 dev_info_t *dip;
18914
18915 ASSERT(un != NULL);
18916 ASSERT(mutex_owned(SD_MUTEX(un)));
18917 ASSERT(bp != NULL);
18918
18919 switch (code) {
18920 case SD_NO_RETRY_ISSUED:
18921 /* Command was failed. Someone turned off this target? */
18922 if (un->un_state != SD_STATE_OFFLINE) {
18923 /*
18924 * Suppress message if we are detaching and
18925 * device has been disconnected
18926 * Note that DEVI_IS_DEVICE_REMOVED is a consolidation
18927 * private interface and not part of the DDI
18928 */
18929 dip = un->un_sd->sd_dev;
18930 if (!(DEVI_IS_DETACHING(dip) &&
18931 DEVI_IS_DEVICE_REMOVED(dip))) {
18932 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
18933 "disk not responding to selection\n");
18934 }
18935 New_state(un, SD_STATE_OFFLINE);
18936 }
18937 break;
18938
18939 case SD_DELAYED_RETRY_ISSUED:
18940 case SD_IMMEDIATE_RETRY_ISSUED:
18941 default:
18942 /* Command was successfully queued for retry */
18943 sd_print_retry_msg(un, bp, arg, code);
18944 break;
18945 }
18946 }
18947
18948
18949 /*
18950 * Function: sd_pkt_reason_cmd_incomplete
18951 *
18952 * Description: Recovery actions for a SCSA "CMD_INCOMPLETE" pkt_reason.
18953 *
18954 * Context: May be called from interrupt context
18955 */
18956
18957 static void
18958 sd_pkt_reason_cmd_incomplete(struct sd_lun *un, struct buf *bp,
18959 struct sd_xbuf *xp, struct scsi_pkt *pktp)
18960 {
18961 int flag = SD_RETRIES_STANDARD | SD_RETRIES_ISOLATE;
18962
18963 ASSERT(un != NULL);
18964 ASSERT(mutex_owned(SD_MUTEX(un)));
18965 ASSERT(bp != NULL);
18966 ASSERT(xp != NULL);
18967 ASSERT(pktp != NULL);
18968
18969 /* Do not do a reset if selection did not complete */
18970 /* Note: Should this not just check the bit? */
18971 if (pktp->pkt_state != STATE_GOT_BUS) {
18972 SD_UPDATE_ERRSTATS(un, sd_transerrs);
18973 sd_reset_target(un, pktp);
18974 }
18975
18976 /*
18977 * If the target was not successfully selected, then set
18978 * SD_RETRIES_FAILFAST to indicate that we lost communication
18979 * with the target, and further retries and/or commands are
18980 * likely to take a long time.
18981 */
18982 if ((pktp->pkt_state & STATE_GOT_TARGET) == 0) {
18983 flag |= SD_RETRIES_FAILFAST;
18984 }
18985
18986 SD_UPDATE_RESERVATION_STATUS(un, pktp);
18987
18988 sd_retry_command(un, bp, flag,
18989 sd_print_cmd_incomplete_msg, NULL, EIO, SD_RESTART_TIMEOUT, NULL);
18990 }
18991
18992
18993
18994 /*
18995 * Function: sd_pkt_reason_cmd_tran_err
18996 *
18997 * Description: Recovery actions for a SCSA "CMD_TRAN_ERR" pkt_reason.
18998 *
18999 * Context: May be called from interrupt context
19000 */
19001
19002 static void
19003 sd_pkt_reason_cmd_tran_err(struct sd_lun *un, struct buf *bp,
19004 struct sd_xbuf *xp, struct scsi_pkt *pktp)
19005 {
19006 ASSERT(un != NULL);
19007 ASSERT(mutex_owned(SD_MUTEX(un)));
19008 ASSERT(bp != NULL);
19009 ASSERT(xp != NULL);
19010 ASSERT(pktp != NULL);
19011
19012 /*
19013 * Do not reset if we got a parity error, or if
19014 * selection did not complete.
19015 */
19016 SD_UPDATE_ERRSTATS(un, sd_harderrs);
19017 /* Note: Should this not just check the bit for pkt_state? */
19018 if (((pktp->pkt_statistics & STAT_PERR) == 0) &&
19019 (pktp->pkt_state != STATE_GOT_BUS)) {
19020 SD_UPDATE_ERRSTATS(un, sd_transerrs);
19021 sd_reset_target(un, pktp);
19022 }
19023
19024 SD_UPDATE_RESERVATION_STATUS(un, pktp);
19025
19026 sd_retry_command(un, bp, (SD_RETRIES_STANDARD | SD_RETRIES_ISOLATE),
19027 sd_print_retry_msg, NULL, EIO, SD_RESTART_TIMEOUT, NULL);
19028 }
19029
19030
19031
19032 /*
19033 * Function: sd_pkt_reason_cmd_reset
19034 *
19035 * Description: Recovery actions for a SCSA "CMD_RESET" pkt_reason.
19036 *
19037 * Context: May be called from interrupt context
19038 */
19039
19040 static void
19041 sd_pkt_reason_cmd_reset(struct sd_lun *un, struct buf *bp, struct sd_xbuf *xp,
19042 struct scsi_pkt *pktp)
19043 {
19044 ASSERT(un != NULL);
19045 ASSERT(mutex_owned(SD_MUTEX(un)));
19046 ASSERT(bp != NULL);
19047 ASSERT(xp != NULL);
19048 ASSERT(pktp != NULL);
19049
19050 /* The target may still be running the command, so try to reset. */
19051 SD_UPDATE_ERRSTATS(un, sd_transerrs);
19052 sd_reset_target(un, pktp);
19053
19054 SD_UPDATE_RESERVATION_STATUS(un, pktp);
19055
19056 /*
19057 * If pkt_reason is CMD_RESET chances are that this pkt got
19058 * reset because another target on this bus caused it. The target
19059 * that caused it should get CMD_TIMEOUT with pkt_statistics
19060 * of STAT_TIMEOUT/STAT_DEV_RESET.
19061 */
19062
19063 sd_retry_command(un, bp, (SD_RETRIES_VICTIM | SD_RETRIES_ISOLATE),
19064 sd_print_retry_msg, NULL, EIO, SD_RESTART_TIMEOUT, NULL);
19065 }
19066
19067
19068
19069
19070 /*
19071 * Function: sd_pkt_reason_cmd_aborted
19072 *
19073 * Description: Recovery actions for a SCSA "CMD_ABORTED" pkt_reason.
19074 *
19075 * Context: May be called from interrupt context
19076 */
19077
19078 static void
19079 sd_pkt_reason_cmd_aborted(struct sd_lun *un, struct buf *bp, struct sd_xbuf *xp,
19080 struct scsi_pkt *pktp)
19081 {
19082 ASSERT(un != NULL);
19083 ASSERT(mutex_owned(SD_MUTEX(un)));
19084 ASSERT(bp != NULL);
19085 ASSERT(xp != NULL);
19086 ASSERT(pktp != NULL);
19087
19088 /* The target may still be running the command, so try to reset. */
19089 SD_UPDATE_ERRSTATS(un, sd_transerrs);
19090 sd_reset_target(un, pktp);
19091
19092 SD_UPDATE_RESERVATION_STATUS(un, pktp);
19093
19094 /*
19095 * If pkt_reason is CMD_ABORTED chances are that this pkt got
19096 * aborted because another target on this bus caused it. The target
19097 * that caused it should get CMD_TIMEOUT with pkt_statistics
19098 * of STAT_TIMEOUT/STAT_DEV_RESET.
19099 */
19100
19101 sd_retry_command(un, bp, (SD_RETRIES_VICTIM | SD_RETRIES_ISOLATE),
19102 sd_print_retry_msg, NULL, EIO, SD_RESTART_TIMEOUT, NULL);
19103 }
19104
19105
19106
19107 /*
19108 * Function: sd_pkt_reason_cmd_timeout
19109 *
19110 * Description: Recovery actions for a SCSA "CMD_TIMEOUT" pkt_reason.
19111 *
19112 * Context: May be called from interrupt context
19113 */
19114
19115 static void
19116 sd_pkt_reason_cmd_timeout(struct sd_lun *un, struct buf *bp, struct sd_xbuf *xp,
19117 struct scsi_pkt *pktp)
19118 {
19119 ASSERT(un != NULL);
19120 ASSERT(mutex_owned(SD_MUTEX(un)));
19121 ASSERT(bp != NULL);
19122 ASSERT(xp != NULL);
19123 ASSERT(pktp != NULL);
19124
19125
19126 SD_UPDATE_ERRSTATS(un, sd_transerrs);
19127 sd_reset_target(un, pktp);
19128
19129 SD_UPDATE_RESERVATION_STATUS(un, pktp);
19130
19131 /*
19132 * A command timeout indicates that we could not establish
19133 * communication with the target, so set SD_RETRIES_FAILFAST
19134 * as further retries/commands are likely to take a long time.
19135 */
19136 sd_retry_command(un, bp,
19137 (SD_RETRIES_STANDARD | SD_RETRIES_ISOLATE | SD_RETRIES_FAILFAST),
19138 sd_print_retry_msg, NULL, EIO, SD_RESTART_TIMEOUT, NULL);
19139 }
19140
19141
19142
19143 /*
19144 * Function: sd_pkt_reason_cmd_unx_bus_free
19145 *
19146 * Description: Recovery actions for a SCSA "CMD_UNX_BUS_FREE" pkt_reason.
19147 *
19148 * Context: May be called from interrupt context
19149 */
19150
19151 static void
19152 sd_pkt_reason_cmd_unx_bus_free(struct sd_lun *un, struct buf *bp,
19153 struct sd_xbuf *xp, struct scsi_pkt *pktp)
19154 {
19155 void (*funcp)(struct sd_lun *un, struct buf *bp, void *arg, int code);
19156
19157 ASSERT(un != NULL);
19158 ASSERT(mutex_owned(SD_MUTEX(un)));
19159 ASSERT(bp != NULL);
19160 ASSERT(xp != NULL);
19161 ASSERT(pktp != NULL);
19162
19163 SD_UPDATE_ERRSTATS(un, sd_harderrs);
19164 SD_UPDATE_RESERVATION_STATUS(un, pktp);
19165
19166 funcp = ((pktp->pkt_statistics & STAT_PERR) == 0) ?
19167 sd_print_retry_msg : NULL;
19168
19169 sd_retry_command(un, bp, (SD_RETRIES_STANDARD | SD_RETRIES_ISOLATE),
19170 funcp, NULL, EIO, SD_RESTART_TIMEOUT, NULL);
19171 }
19172
19173
19174 /*
19175 * Function: sd_pkt_reason_cmd_tag_reject
19176 *
19177 * Description: Recovery actions for a SCSA "CMD_TAG_REJECT" pkt_reason.
19178 *
19179 * Context: May be called from interrupt context
19180 */
19181
19182 static void
19183 sd_pkt_reason_cmd_tag_reject(struct sd_lun *un, struct buf *bp,
19184 struct sd_xbuf *xp, struct scsi_pkt *pktp)
19185 {
19186 ASSERT(un != NULL);
19187 ASSERT(mutex_owned(SD_MUTEX(un)));
19188 ASSERT(bp != NULL);
19189 ASSERT(xp != NULL);
19190 ASSERT(pktp != NULL);
19191
19192 SD_UPDATE_ERRSTATS(un, sd_harderrs);
19193 pktp->pkt_flags = 0;
19194 un->un_tagflags = 0;
19195 if (un->un_f_opt_queueing == TRUE) {
19196 un->un_throttle = min(un->un_throttle, 3);
19197 } else {
19198 un->un_throttle = 1;
19199 }
19200 mutex_exit(SD_MUTEX(un));
19201 (void) scsi_ifsetcap(SD_ADDRESS(un), "tagged-qing", 0, 1);
19202 mutex_enter(SD_MUTEX(un));
19203
19204 SD_UPDATE_RESERVATION_STATUS(un, pktp);
19205
19206 /* Legacy behavior not to check retry counts here. */
19207 sd_retry_command(un, bp, (SD_RETRIES_NOCHECK | SD_RETRIES_ISOLATE),
19208 sd_print_retry_msg, NULL, EIO, SD_RESTART_TIMEOUT, NULL);
19209 }
19210
19211
19212 /*
19213 * Function: sd_pkt_reason_default
19214 *
19215 * Description: Default recovery actions for SCSA pkt_reason values that
19216 * do not have more explicit recovery actions.
19217 *
19218 * Context: May be called from interrupt context
19219 */
19220
19221 static void
19222 sd_pkt_reason_default(struct sd_lun *un, struct buf *bp, struct sd_xbuf *xp,
19223 struct scsi_pkt *pktp)
19224 {
19225 ASSERT(un != NULL);
19226 ASSERT(mutex_owned(SD_MUTEX(un)));
19227 ASSERT(bp != NULL);
19228 ASSERT(xp != NULL);
19229 ASSERT(pktp != NULL);
19230
19231 SD_UPDATE_ERRSTATS(un, sd_transerrs);
19232 sd_reset_target(un, pktp);
19233
19234 SD_UPDATE_RESERVATION_STATUS(un, pktp);
19235
19236 sd_retry_command(un, bp, (SD_RETRIES_STANDARD | SD_RETRIES_ISOLATE),
19237 sd_print_retry_msg, NULL, EIO, SD_RESTART_TIMEOUT, NULL);
19238 }
19239
19240
19241
19242 /*
19243 * Function: sd_pkt_status_check_condition
19244 *
19245 * Description: Recovery actions for a "STATUS_CHECK" SCSI command status.
19246 *
19247 * Context: May be called from interrupt context
19248 */
19249
19250 static void
19251 sd_pkt_status_check_condition(struct sd_lun *un, struct buf *bp,
19252 struct sd_xbuf *xp, struct scsi_pkt *pktp)
19253 {
19254 ASSERT(un != NULL);
19255 ASSERT(mutex_owned(SD_MUTEX(un)));
19256 ASSERT(bp != NULL);
19257 ASSERT(xp != NULL);
19258 ASSERT(pktp != NULL);
19259
19260 SD_TRACE(SD_LOG_IO, un, "sd_pkt_status_check_condition: "
19261 "entry: buf:0x%p xp:0x%p\n", bp, xp);
19262
19263 /*
19264 * If ARQ is NOT enabled, then issue a REQUEST SENSE command (the
19265 * command will be retried after the request sense). Otherwise, retry
19266 * the command. Note: we are issuing the request sense even though the
19267 * retry limit may have been reached for the failed command.
19268 */
19269 if (un->un_f_arq_enabled == FALSE) {
19270 SD_INFO(SD_LOG_IO_CORE, un, "sd_pkt_status_check_condition: "
19271 "no ARQ, sending request sense command\n");
19272 sd_send_request_sense_command(un, bp, pktp);
19273 } else {
19274 SD_INFO(SD_LOG_IO_CORE, un, "sd_pkt_status_check_condition: "
19275 "ARQ,retrying request sense command\n");
19276 #if defined(__i386) || defined(__amd64)
19277 /*
19278 * The SD_RETRY_DELAY value need to be adjusted here
19279 * when SD_RETRY_DELAY change in sddef.h
19280 */
19281 sd_retry_command(un, bp, SD_RETRIES_STANDARD, NULL, NULL, EIO,
19282 un->un_f_is_fibre?drv_usectohz(100000):(clock_t)0,
19283 NULL);
19284 #else
19285 sd_retry_command(un, bp, SD_RETRIES_STANDARD, NULL, NULL,
19286 EIO, SD_RETRY_DELAY, NULL);
19287 #endif
19288 }
19289
19290 SD_TRACE(SD_LOG_IO_CORE, un, "sd_pkt_status_check_condition: exit\n");
19291 }
19292
19293
19294 /*
19295 * Function: sd_pkt_status_busy
19296 *
19297 * Description: Recovery actions for a "STATUS_BUSY" SCSI command status.
19298 *
19299 * Context: May be called from interrupt context
19300 */
19301
19302 static void
19303 sd_pkt_status_busy(struct sd_lun *un, struct buf *bp, struct sd_xbuf *xp,
19304 struct scsi_pkt *pktp)
19305 {
19306 ASSERT(un != NULL);
19307 ASSERT(mutex_owned(SD_MUTEX(un)));
19308 ASSERT(bp != NULL);
19309 ASSERT(xp != NULL);
19310 ASSERT(pktp != NULL);
19311
19312 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19313 "sd_pkt_status_busy: entry\n");
19314
19315 /* If retries are exhausted, just fail the command. */
19316 if (xp->xb_retry_count >= un->un_busy_retry_count) {
19317 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
19318 "device busy too long\n");
19319 sd_return_failed_command(un, bp, EIO);
19320 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19321 "sd_pkt_status_busy: exit\n");
19322 return;
19323 }
19324 xp->xb_retry_count++;
19325
19326 /*
19327 * Try to reset the target. However, we do not want to perform
19328 * more than one reset if the device continues to fail. The reset
19329 * will be performed when the retry count reaches the reset
19330 * threshold. This threshold should be set such that at least
19331 * one retry is issued before the reset is performed.
19332 */
19333 if (xp->xb_retry_count ==
19334 ((un->un_reset_retry_count < 2) ? 2 : un->un_reset_retry_count)) {
19335 int rval = 0;
19336 mutex_exit(SD_MUTEX(un));
19337 if (un->un_f_allow_bus_device_reset == TRUE) {
19338 /*
19339 * First try to reset the LUN; if we cannot then
19340 * try to reset the target.
19341 */
19342 if (un->un_f_lun_reset_enabled == TRUE) {
19343 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19344 "sd_pkt_status_busy: RESET_LUN\n");
19345 rval = scsi_reset(SD_ADDRESS(un), RESET_LUN);
19346 }
19347 if (rval == 0) {
19348 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19349 "sd_pkt_status_busy: RESET_TARGET\n");
19350 rval = scsi_reset(SD_ADDRESS(un), RESET_TARGET);
19351 }
19352 }
19353 if (rval == 0) {
19354 /*
19355 * If the RESET_LUN and/or RESET_TARGET failed,
19356 * try RESET_ALL
19357 */
19358 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19359 "sd_pkt_status_busy: RESET_ALL\n");
19360 rval = scsi_reset(SD_ADDRESS(un), RESET_ALL);
19361 }
19362 mutex_enter(SD_MUTEX(un));
19363 if (rval == 0) {
19364 /*
19365 * The RESET_LUN, RESET_TARGET, and/or RESET_ALL failed.
19366 * At this point we give up & fail the command.
19367 */
19368 sd_return_failed_command(un, bp, EIO);
19369 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19370 "sd_pkt_status_busy: exit (failed cmd)\n");
19371 return;
19372 }
19373 }
19374
19375 /*
19376 * Retry the command. Be sure to specify SD_RETRIES_NOCHECK as
19377 * we have already checked the retry counts above.
19378 */
19379 sd_retry_command(un, bp, SD_RETRIES_NOCHECK, NULL, NULL,
19380 EIO, un->un_busy_timeout, NULL);
19381
19382 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19383 "sd_pkt_status_busy: exit\n");
19384 }
19385
19386
19387 /*
19388 * Function: sd_pkt_status_reservation_conflict
19389 *
19390 * Description: Recovery actions for a "STATUS_RESERVATION_CONFLICT" SCSI
19391 * command status.
19392 *
19393 * Context: May be called from interrupt context
19394 */
19395
19396 static void
19397 sd_pkt_status_reservation_conflict(struct sd_lun *un, struct buf *bp,
19398 struct sd_xbuf *xp, struct scsi_pkt *pktp)
19399 {
19400 ASSERT(un != NULL);
19401 ASSERT(mutex_owned(SD_MUTEX(un)));
19402 ASSERT(bp != NULL);
19403 ASSERT(xp != NULL);
19404 ASSERT(pktp != NULL);
19405
19406 /*
19407 * If the command was PERSISTENT_RESERVATION_[IN|OUT] then reservation
19408 * conflict could be due to various reasons like incorrect keys, not
19409 * registered or not reserved etc. So, we return EACCES to the caller.
19410 */
19411 if (un->un_reservation_type == SD_SCSI3_RESERVATION) {
19412 int cmd = SD_GET_PKT_OPCODE(pktp);
19413 if ((cmd == SCMD_PERSISTENT_RESERVE_IN) ||
19414 (cmd == SCMD_PERSISTENT_RESERVE_OUT)) {
19415 sd_return_failed_command(un, bp, EACCES);
19416 return;
19417 }
19418 }
19419
19420 un->un_resvd_status |= SD_RESERVATION_CONFLICT;
19421
19422 if ((un->un_resvd_status & SD_FAILFAST) != 0) {
19423 if (sd_failfast_enable != 0) {
19424 /* By definition, we must panic here.... */
19425 sd_panic_for_res_conflict(un);
19426 /*NOTREACHED*/
19427 }
19428 SD_ERROR(SD_LOG_IO, un,
19429 "sd_handle_resv_conflict: Disk Reserved\n");
19430 sd_return_failed_command(un, bp, EACCES);
19431 return;
19432 }
19433
19434 /*
19435 * 1147670: retry only if sd_retry_on_reservation_conflict
19436 * property is set (default is 1). Retries will not succeed
19437 * on a disk reserved by another initiator. HA systems
19438 * may reset this via sd.conf to avoid these retries.
19439 *
19440 * Note: The legacy return code for this failure is EIO, however EACCES
19441 * seems more appropriate for a reservation conflict.
19442 */
19443 if (sd_retry_on_reservation_conflict == 0) {
19444 SD_ERROR(SD_LOG_IO, un,
19445 "sd_handle_resv_conflict: Device Reserved\n");
19446 sd_return_failed_command(un, bp, EIO);
19447 return;
19448 }
19449
19450 /*
19451 * Retry the command if we can.
19452 *
19453 * Note: The legacy return code for this failure is EIO, however EACCES
19454 * seems more appropriate for a reservation conflict.
19455 */
19456 sd_retry_command(un, bp, SD_RETRIES_STANDARD, NULL, NULL, EIO,
19457 (clock_t)2, NULL);
19458 }
19459
19460
19461
19462 /*
19463 * Function: sd_pkt_status_qfull
19464 *
19465 * Description: Handle a QUEUE FULL condition from the target. This can
19466 * occur if the HBA does not handle the queue full condition.
19467 * (Basically this means third-party HBAs as Sun HBAs will
19468 * handle the queue full condition.) Note that if there are
19469 * some commands already in the transport, then the queue full
19470 * has occurred because the queue for this nexus is actually
19471 * full. If there are no commands in the transport, then the
19472 * queue full is resulting from some other initiator or lun
19473 * consuming all the resources at the target.
19474 *
19475 * Context: May be called from interrupt context
19476 */
19477
19478 static void
19479 sd_pkt_status_qfull(struct sd_lun *un, struct buf *bp, struct sd_xbuf *xp,
19480 struct scsi_pkt *pktp)
19481 {
19482 ASSERT(un != NULL);
19483 ASSERT(mutex_owned(SD_MUTEX(un)));
19484 ASSERT(bp != NULL);
19485 ASSERT(xp != NULL);
19486 ASSERT(pktp != NULL);
19487
19488 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19489 "sd_pkt_status_qfull: entry\n");
19490
19491 /*
19492 * Just lower the QFULL throttle and retry the command. Note that
19493 * we do not limit the number of retries here.
19494 */
19495 sd_reduce_throttle(un, SD_THROTTLE_QFULL);
19496 sd_retry_command(un, bp, SD_RETRIES_NOCHECK, NULL, NULL, 0,
19497 SD_RESTART_TIMEOUT, NULL);
19498
19499 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19500 "sd_pkt_status_qfull: exit\n");
19501 }
19502
19503
19504 /*
19505 * Function: sd_reset_target
19506 *
19507 * Description: Issue a scsi_reset(9F), with either RESET_LUN,
19508 * RESET_TARGET, or RESET_ALL.
19509 *
19510 * Context: May be called under interrupt context.
19511 */
19512
19513 static void
19514 sd_reset_target(struct sd_lun *un, struct scsi_pkt *pktp)
19515 {
19516 int rval = 0;
19517
19518 ASSERT(un != NULL);
19519 ASSERT(mutex_owned(SD_MUTEX(un)));
19520 ASSERT(pktp != NULL);
19521
19522 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_reset_target: entry\n");
19523
19524 /*
19525 * No need to reset if the transport layer has already done so.
19526 */
19527 if ((pktp->pkt_statistics &
19528 (STAT_BUS_RESET | STAT_DEV_RESET | STAT_ABORTED)) != 0) {
19529 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19530 "sd_reset_target: no reset\n");
19531 return;
19532 }
19533
19534 mutex_exit(SD_MUTEX(un));
19535
19536 if (un->un_f_allow_bus_device_reset == TRUE) {
19537 if (un->un_f_lun_reset_enabled == TRUE) {
19538 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19539 "sd_reset_target: RESET_LUN\n");
19540 rval = scsi_reset(SD_ADDRESS(un), RESET_LUN);
19541 }
19542 if (rval == 0) {
19543 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19544 "sd_reset_target: RESET_TARGET\n");
19545 rval = scsi_reset(SD_ADDRESS(un), RESET_TARGET);
19546 }
19547 }
19548
19549 if (rval == 0) {
19550 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19551 "sd_reset_target: RESET_ALL\n");
19552 (void) scsi_reset(SD_ADDRESS(un), RESET_ALL);
19553 }
19554
19555 mutex_enter(SD_MUTEX(un));
19556
19557 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_reset_target: exit\n");
19558 }
19559
19560 /*
19561 * Function: sd_target_change_task
19562 *
19563 * Description: Handle dynamic target change
19564 *
19565 * Context: Executes in a taskq() thread context
19566 */
19567 static void
19568 sd_target_change_task(void *arg)
19569 {
19570 struct sd_lun *un = arg;
19571 uint64_t capacity;
19572 diskaddr_t label_cap;
19573 uint_t lbasize;
19574 sd_ssc_t *ssc;
19575
19576 ASSERT(un != NULL);
19577 ASSERT(!mutex_owned(SD_MUTEX(un)));
19578
19579 if ((un->un_f_blockcount_is_valid == FALSE) ||
19580 (un->un_f_tgt_blocksize_is_valid == FALSE)) {
19581 return;
19582 }
19583
19584 ssc = sd_ssc_init(un);
19585
19586 if (sd_send_scsi_READ_CAPACITY(ssc, &capacity,
19587 &lbasize, SD_PATH_DIRECT) != 0) {
19588 SD_ERROR(SD_LOG_ERROR, un,
19589 "sd_target_change_task: fail to read capacity\n");
19590 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
19591 goto task_exit;
19592 }
19593
19594 mutex_enter(SD_MUTEX(un));
19595 if (capacity <= un->un_blockcount) {
19596 mutex_exit(SD_MUTEX(un));
19597 goto task_exit;
19598 }
19599
19600 sd_update_block_info(un, lbasize, capacity);
19601 mutex_exit(SD_MUTEX(un));
19602
19603 /*
19604 * If lun is EFI labeled and lun capacity is greater than the
19605 * capacity contained in the label, log a sys event.
19606 */
19607 if (cmlb_efi_label_capacity(un->un_cmlbhandle, &label_cap,
19608 (void*)SD_PATH_DIRECT) == 0) {
19609 mutex_enter(SD_MUTEX(un));
19610 if (un->un_f_blockcount_is_valid &&
19611 un->un_blockcount > label_cap) {
19612 mutex_exit(SD_MUTEX(un));
19613 sd_log_lun_expansion_event(un, KM_SLEEP);
19614 } else {
19615 mutex_exit(SD_MUTEX(un));
19616 }
19617 }
19618
19619 task_exit:
19620 sd_ssc_fini(ssc);
19621 }
19622
19623
19624 /*
19625 * Function: sd_log_dev_status_event
19626 *
19627 * Description: Log EC_dev_status sysevent
19628 *
19629 * Context: Never called from interrupt context
19630 */
19631 static void
19632 sd_log_dev_status_event(struct sd_lun *un, char *esc, int km_flag)
19633 {
19634 int err;
19635 char *path;
19636 nvlist_t *attr_list;
19637
19638 /* Allocate and build sysevent attribute list */
19639 err = nvlist_alloc(&attr_list, NV_UNIQUE_NAME_TYPE, km_flag);
19640 if (err != 0) {
19641 SD_ERROR(SD_LOG_ERROR, un,
19642 "sd_log_dev_status_event: fail to allocate space\n");
19643 return;
19644 }
19645
19646 path = kmem_alloc(MAXPATHLEN, km_flag);
19647 if (path == NULL) {
19648 nvlist_free(attr_list);
19649 SD_ERROR(SD_LOG_ERROR, un,
19650 "sd_log_dev_status_event: fail to allocate space\n");
19651 return;
19652 }
19653 /*
19654 * Add path attribute to identify the lun.
19655 * We are using minor node 'a' as the sysevent attribute.
19656 */
19657 (void) snprintf(path, MAXPATHLEN, "/devices");
19658 (void) ddi_pathname(SD_DEVINFO(un), path + strlen(path));
19659 (void) snprintf(path + strlen(path), MAXPATHLEN - strlen(path),
19660 ":a");
19661
19662 err = nvlist_add_string(attr_list, DEV_PHYS_PATH, path);
19663 if (err != 0) {
19664 nvlist_free(attr_list);
19665 kmem_free(path, MAXPATHLEN);
19666 SD_ERROR(SD_LOG_ERROR, un,
19667 "sd_log_dev_status_event: fail to add attribute\n");
19668 return;
19669 }
19670
19671 /* Log dynamic lun expansion sysevent */
19672 err = ddi_log_sysevent(SD_DEVINFO(un), SUNW_VENDOR, EC_DEV_STATUS,
19673 esc, attr_list, NULL, km_flag);
19674 if (err != DDI_SUCCESS) {
19675 SD_ERROR(SD_LOG_ERROR, un,
19676 "sd_log_dev_status_event: fail to log sysevent\n");
19677 }
19678
19679 nvlist_free(attr_list);
19680 kmem_free(path, MAXPATHLEN);
19681 }
19682
19683
19684 /*
19685 * Function: sd_log_lun_expansion_event
19686 *
19687 * Description: Log lun expansion sys event
19688 *
19689 * Context: Never called from interrupt context
19690 */
19691 static void
19692 sd_log_lun_expansion_event(struct sd_lun *un, int km_flag)
19693 {
19694 sd_log_dev_status_event(un, ESC_DEV_DLE, km_flag);
19695 }
19696
19697
19698 /*
19699 * Function: sd_log_eject_request_event
19700 *
19701 * Description: Log eject request sysevent
19702 *
19703 * Context: Never called from interrupt context
19704 */
19705 static void
19706 sd_log_eject_request_event(struct sd_lun *un, int km_flag)
19707 {
19708 sd_log_dev_status_event(un, ESC_DEV_EJECT_REQUEST, km_flag);
19709 }
19710
19711
19712 /*
19713 * Function: sd_media_change_task
19714 *
19715 * Description: Recovery action for CDROM to become available.
19716 *
19717 * Context: Executes in a taskq() thread context
19718 */
19719
19720 static void
19721 sd_media_change_task(void *arg)
19722 {
19723 struct scsi_pkt *pktp = arg;
19724 struct sd_lun *un;
19725 struct buf *bp;
19726 struct sd_xbuf *xp;
19727 int err = 0;
19728 int retry_count = 0;
19729 int retry_limit = SD_UNIT_ATTENTION_RETRY/10;
19730 struct sd_sense_info si;
19731
19732 ASSERT(pktp != NULL);
19733 bp = (struct buf *)pktp->pkt_private;
19734 ASSERT(bp != NULL);
19735 xp = SD_GET_XBUF(bp);
19736 ASSERT(xp != NULL);
19737 un = SD_GET_UN(bp);
19738 ASSERT(un != NULL);
19739 ASSERT(!mutex_owned(SD_MUTEX(un)));
19740 ASSERT(un->un_f_monitor_media_state);
19741
19742 si.ssi_severity = SCSI_ERR_INFO;
19743 si.ssi_pfa_flag = FALSE;
19744
19745 /*
19746 * When a reset is issued on a CDROM, it takes a long time to
19747 * recover. First few attempts to read capacity and other things
19748 * related to handling unit attention fail (with a ASC 0x4 and
19749 * ASCQ 0x1). In that case we want to do enough retries and we want
19750 * to limit the retries in other cases of genuine failures like
19751 * no media in drive.
19752 */
19753 while (retry_count++ < retry_limit) {
19754 if ((err = sd_handle_mchange(un)) == 0) {
19755 break;
19756 }
19757 if (err == EAGAIN) {
19758 retry_limit = SD_UNIT_ATTENTION_RETRY;
19759 }
19760 /* Sleep for 0.5 sec. & try again */
19761 delay(drv_usectohz(500000));
19762 }
19763
19764 /*
19765 * Dispatch (retry or fail) the original command here,
19766 * along with appropriate console messages....
19767 *
19768 * Must grab the mutex before calling sd_retry_command,
19769 * sd_print_sense_msg and sd_return_failed_command.
19770 */
19771 mutex_enter(SD_MUTEX(un));
19772 if (err != SD_CMD_SUCCESS) {
19773 SD_UPDATE_ERRSTATS(un, sd_harderrs);
19774 SD_UPDATE_ERRSTATS(un, sd_rq_nodev_err);
19775 si.ssi_severity = SCSI_ERR_FATAL;
19776 sd_print_sense_msg(un, bp, &si, SD_NO_RETRY_ISSUED);
19777 sd_return_failed_command(un, bp, EIO);
19778 } else {
19779 sd_retry_command(un, bp, SD_RETRIES_UA, sd_print_sense_msg,
19780 &si, EIO, (clock_t)0, NULL);
19781 }
19782 mutex_exit(SD_MUTEX(un));
19783 }
19784
19785
19786
19787 /*
19788 * Function: sd_handle_mchange
19789 *
19790 * Description: Perform geometry validation & other recovery when CDROM
19791 * has been removed from drive.
19792 *
19793 * Return Code: 0 for success
19794 * errno-type return code of either sd_send_scsi_DOORLOCK() or
19795 * sd_send_scsi_READ_CAPACITY()
19796 *
19797 * Context: Executes in a taskq() thread context
19798 */
19799
19800 static int
19801 sd_handle_mchange(struct sd_lun *un)
19802 {
19803 uint64_t capacity;
19804 uint32_t lbasize;
19805 int rval;
19806 sd_ssc_t *ssc;
19807
19808 ASSERT(!mutex_owned(SD_MUTEX(un)));
19809 ASSERT(un->un_f_monitor_media_state);
19810
19811 ssc = sd_ssc_init(un);
19812 rval = sd_send_scsi_READ_CAPACITY(ssc, &capacity, &lbasize,
19813 SD_PATH_DIRECT_PRIORITY);
19814
19815 if (rval != 0)
19816 goto failed;
19817
19818 mutex_enter(SD_MUTEX(un));
19819 sd_update_block_info(un, lbasize, capacity);
19820
19821 if (un->un_errstats != NULL) {
19822 struct sd_errstats *stp =
19823 (struct sd_errstats *)un->un_errstats->ks_data;
19824 stp->sd_capacity.value.ui64 = (uint64_t)
19825 ((uint64_t)un->un_blockcount *
19826 (uint64_t)un->un_tgt_blocksize);
19827 }
19828
19829 /*
19830 * Check if the media in the device is writable or not
19831 */
19832 if (ISCD(un)) {
19833 sd_check_for_writable_cd(ssc, SD_PATH_DIRECT_PRIORITY);
19834 }
19835
19836 /*
19837 * Note: Maybe let the strategy/partitioning chain worry about getting
19838 * valid geometry.
19839 */
19840 mutex_exit(SD_MUTEX(un));
19841 cmlb_invalidate(un->un_cmlbhandle, (void *)SD_PATH_DIRECT_PRIORITY);
19842
19843
19844 if (cmlb_validate(un->un_cmlbhandle, 0,
19845 (void *)SD_PATH_DIRECT_PRIORITY) != 0) {
19846 sd_ssc_fini(ssc);
19847 return (EIO);
19848 } else {
19849 if (un->un_f_pkstats_enabled) {
19850 sd_set_pstats(un);
19851 SD_TRACE(SD_LOG_IO_PARTITION, un,
19852 "sd_handle_mchange: un:0x%p pstats created and "
19853 "set\n", un);
19854 }
19855 }
19856
19857 /*
19858 * Try to lock the door
19859 */
19860 rval = sd_send_scsi_DOORLOCK(ssc, SD_REMOVAL_PREVENT,
19861 SD_PATH_DIRECT_PRIORITY);
19862 failed:
19863 if (rval != 0)
19864 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
19865 sd_ssc_fini(ssc);
19866 return (rval);
19867 }
19868
19869
19870 /*
19871 * Function: sd_send_scsi_DOORLOCK
19872 *
19873 * Description: Issue the scsi DOOR LOCK command
19874 *
19875 * Arguments: ssc - ssc contains pointer to driver soft state (unit)
19876 * structure for this target.
19877 * flag - SD_REMOVAL_ALLOW
19878 * SD_REMOVAL_PREVENT
19879 * path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and
19880 * the normal command waitq, or SD_PATH_DIRECT_PRIORITY
19881 * to use the USCSI "direct" chain and bypass the normal
19882 * command waitq. SD_PATH_DIRECT_PRIORITY is used when this
19883 * command is issued as part of an error recovery action.
19884 *
19885 * Return Code: 0 - Success
19886 * errno return code from sd_ssc_send()
19887 *
19888 * Context: Can sleep.
19889 */
19890
19891 static int
19892 sd_send_scsi_DOORLOCK(sd_ssc_t *ssc, int flag, int path_flag)
19893 {
19894 struct scsi_extended_sense sense_buf;
19895 union scsi_cdb cdb;
19896 struct uscsi_cmd ucmd_buf;
19897 int status;
19898 struct sd_lun *un;
19899
19900 ASSERT(ssc != NULL);
19901 un = ssc->ssc_un;
19902 ASSERT(un != NULL);
19903 ASSERT(!mutex_owned(SD_MUTEX(un)));
19904
19905 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_DOORLOCK: entry: un:0x%p\n", un);
19906
19907 /* already determined doorlock is not supported, fake success */
19908 if (un->un_f_doorlock_supported == FALSE) {
19909 return (0);
19910 }
19911
19912 /*
19913 * If we are ejecting and see an SD_REMOVAL_PREVENT
19914 * ignore the command so we can complete the eject
19915 * operation.
19916 */
19917 if (flag == SD_REMOVAL_PREVENT) {
19918 mutex_enter(SD_MUTEX(un));
19919 if (un->un_f_ejecting == TRUE) {
19920 mutex_exit(SD_MUTEX(un));
19921 return (EAGAIN);
19922 }
19923 mutex_exit(SD_MUTEX(un));
19924 }
19925
19926 bzero(&cdb, sizeof (cdb));
19927 bzero(&ucmd_buf, sizeof (ucmd_buf));
19928
19929 cdb.scc_cmd = SCMD_DOORLOCK;
19930 cdb.cdb_opaque[4] = (uchar_t)flag;
19931
19932 ucmd_buf.uscsi_cdb = (char *)&cdb;
19933 ucmd_buf.uscsi_cdblen = CDB_GROUP0;
19934 ucmd_buf.uscsi_bufaddr = NULL;
19935 ucmd_buf.uscsi_buflen = 0;
19936 ucmd_buf.uscsi_rqbuf = (caddr_t)&sense_buf;
19937 ucmd_buf.uscsi_rqlen = sizeof (sense_buf);
19938 ucmd_buf.uscsi_flags = USCSI_RQENABLE | USCSI_SILENT;
19939 ucmd_buf.uscsi_timeout = 15;
19940
19941 SD_TRACE(SD_LOG_IO, un,
19942 "sd_send_scsi_DOORLOCK: returning sd_ssc_send\n");
19943
19944 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
19945 UIO_SYSSPACE, path_flag);
19946
19947 if (status == 0)
19948 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
19949
19950 if ((status == EIO) && (ucmd_buf.uscsi_status == STATUS_CHECK) &&
19951 (ucmd_buf.uscsi_rqstatus == STATUS_GOOD) &&
19952 (scsi_sense_key((uint8_t *)&sense_buf) == KEY_ILLEGAL_REQUEST)) {
19953 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
19954
19955 /* fake success and skip subsequent doorlock commands */
19956 un->un_f_doorlock_supported = FALSE;
19957 return (0);
19958 }
19959
19960 return (status);
19961 }
19962
19963 /*
19964 * Function: sd_send_scsi_READ_CAPACITY
19965 *
19966 * Description: This routine uses the scsi READ CAPACITY command to determine
19967 * the device capacity in number of blocks and the device native
19968 * block size. If this function returns a failure, then the
19969 * values in *capp and *lbap are undefined. If the capacity
19970 * returned is 0xffffffff then the lun is too large for a
19971 * normal READ CAPACITY command and the results of a
19972 * READ CAPACITY 16 will be used instead.
19973 *
19974 * Arguments: ssc - ssc contains ptr to soft state struct for the target
19975 * capp - ptr to unsigned 64-bit variable to receive the
19976 * capacity value from the command.
19977 * lbap - ptr to unsigned 32-bit varaible to receive the
19978 * block size value from the command
19979 * path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and
19980 * the normal command waitq, or SD_PATH_DIRECT_PRIORITY
19981 * to use the USCSI "direct" chain and bypass the normal
19982 * command waitq. SD_PATH_DIRECT_PRIORITY is used when this
19983 * command is issued as part of an error recovery action.
19984 *
19985 * Return Code: 0 - Success
19986 * EIO - IO error
19987 * EACCES - Reservation conflict detected
19988 * EAGAIN - Device is becoming ready
19989 * errno return code from sd_ssc_send()
19990 *
19991 * Context: Can sleep. Blocks until command completes.
19992 */
19993
19994 #define SD_CAPACITY_SIZE sizeof (struct scsi_capacity)
19995
19996 static int
19997 sd_send_scsi_READ_CAPACITY(sd_ssc_t *ssc, uint64_t *capp, uint32_t *lbap,
19998 int path_flag)
19999 {
20000 struct scsi_extended_sense sense_buf;
20001 struct uscsi_cmd ucmd_buf;
20002 union scsi_cdb cdb;
20003 uint32_t *capacity_buf;
20004 uint64_t capacity;
20005 uint32_t lbasize;
20006 uint32_t pbsize;
20007 int status;
20008 struct sd_lun *un;
20009
20010 ASSERT(ssc != NULL);
20011
20012 un = ssc->ssc_un;
20013 ASSERT(un != NULL);
20014 ASSERT(!mutex_owned(SD_MUTEX(un)));
20015 ASSERT(capp != NULL);
20016 ASSERT(lbap != NULL);
20017
20018 SD_TRACE(SD_LOG_IO, un,
20019 "sd_send_scsi_READ_CAPACITY: entry: un:0x%p\n", un);
20020
20021 /*
20022 * First send a READ_CAPACITY command to the target.
20023 * (This command is mandatory under SCSI-2.)
20024 *
20025 * Set up the CDB for the READ_CAPACITY command. The Partial
20026 * Medium Indicator bit is cleared. The address field must be
20027 * zero if the PMI bit is zero.
20028 */
20029 bzero(&cdb, sizeof (cdb));
20030 bzero(&ucmd_buf, sizeof (ucmd_buf));
20031
20032 capacity_buf = kmem_zalloc(SD_CAPACITY_SIZE, KM_SLEEP);
20033
20034 cdb.scc_cmd = SCMD_READ_CAPACITY;
20035
20036 ucmd_buf.uscsi_cdb = (char *)&cdb;
20037 ucmd_buf.uscsi_cdblen = CDB_GROUP1;
20038 ucmd_buf.uscsi_bufaddr = (caddr_t)capacity_buf;
20039 ucmd_buf.uscsi_buflen = SD_CAPACITY_SIZE;
20040 ucmd_buf.uscsi_rqbuf = (caddr_t)&sense_buf;
20041 ucmd_buf.uscsi_rqlen = sizeof (sense_buf);
20042 ucmd_buf.uscsi_flags = USCSI_RQENABLE | USCSI_READ | USCSI_SILENT;
20043 ucmd_buf.uscsi_timeout = 60;
20044
20045 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
20046 UIO_SYSSPACE, path_flag);
20047
20048 switch (status) {
20049 case 0:
20050 /* Return failure if we did not get valid capacity data. */
20051 if (ucmd_buf.uscsi_resid != 0) {
20052 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, -1,
20053 "sd_send_scsi_READ_CAPACITY received invalid "
20054 "capacity data");
20055 kmem_free(capacity_buf, SD_CAPACITY_SIZE);
20056 return (EIO);
20057 }
20058 /*
20059 * Read capacity and block size from the READ CAPACITY 10 data.
20060 * This data may be adjusted later due to device specific
20061 * issues.
20062 *
20063 * According to the SCSI spec, the READ CAPACITY 10
20064 * command returns the following:
20065 *
20066 * bytes 0-3: Maximum logical block address available.
20067 * (MSB in byte:0 & LSB in byte:3)
20068 *
20069 * bytes 4-7: Block length in bytes
20070 * (MSB in byte:4 & LSB in byte:7)
20071 *
20072 */
20073 capacity = BE_32(capacity_buf[0]);
20074 lbasize = BE_32(capacity_buf[1]);
20075
20076 /*
20077 * Done with capacity_buf
20078 */
20079 kmem_free(capacity_buf, SD_CAPACITY_SIZE);
20080
20081 /*
20082 * if the reported capacity is set to all 0xf's, then
20083 * this disk is too large and requires SBC-2 commands.
20084 * Reissue the request using READ CAPACITY 16.
20085 */
20086 if (capacity == 0xffffffff) {
20087 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
20088 status = sd_send_scsi_READ_CAPACITY_16(ssc, &capacity,
20089 &lbasize, &pbsize, path_flag);
20090 if (status != 0) {
20091 return (status);
20092 } else {
20093 goto rc16_done;
20094 }
20095 }
20096 break; /* Success! */
20097 case EIO:
20098 switch (ucmd_buf.uscsi_status) {
20099 case STATUS_RESERVATION_CONFLICT:
20100 status = EACCES;
20101 break;
20102 case STATUS_CHECK:
20103 /*
20104 * Check condition; look for ASC/ASCQ of 0x04/0x01
20105 * (LOGICAL UNIT IS IN PROCESS OF BECOMING READY)
20106 */
20107 if ((ucmd_buf.uscsi_rqstatus == STATUS_GOOD) &&
20108 (scsi_sense_asc((uint8_t *)&sense_buf) == 0x04) &&
20109 (scsi_sense_ascq((uint8_t *)&sense_buf) == 0x01)) {
20110 kmem_free(capacity_buf, SD_CAPACITY_SIZE);
20111 return (EAGAIN);
20112 }
20113 break;
20114 default:
20115 break;
20116 }
20117 /* FALLTHRU */
20118 default:
20119 kmem_free(capacity_buf, SD_CAPACITY_SIZE);
20120 return (status);
20121 }
20122
20123 /*
20124 * Some ATAPI CD-ROM drives report inaccurate LBA size values
20125 * (2352 and 0 are common) so for these devices always force the value
20126 * to 2048 as required by the ATAPI specs.
20127 */
20128 if ((un->un_f_cfg_is_atapi == TRUE) && (ISCD(un))) {
20129 lbasize = 2048;
20130 }
20131
20132 /*
20133 * Get the maximum LBA value from the READ CAPACITY data.
20134 * Here we assume that the Partial Medium Indicator (PMI) bit
20135 * was cleared when issuing the command. This means that the LBA
20136 * returned from the device is the LBA of the last logical block
20137 * on the logical unit. The actual logical block count will be
20138 * this value plus one.
20139 */
20140 capacity += 1;
20141
20142 /*
20143 * Currently, for removable media, the capacity is saved in terms
20144 * of un->un_sys_blocksize, so scale the capacity value to reflect this.
20145 */
20146 if (un->un_f_has_removable_media)
20147 capacity *= (lbasize / un->un_sys_blocksize);
20148
20149 rc16_done:
20150
20151 /*
20152 * Copy the values from the READ CAPACITY command into the space
20153 * provided by the caller.
20154 */
20155 *capp = capacity;
20156 *lbap = lbasize;
20157
20158 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_READ_CAPACITY: "
20159 "capacity:0x%llx lbasize:0x%x\n", capacity, lbasize);
20160
20161 /*
20162 * Both the lbasize and capacity from the device must be nonzero,
20163 * otherwise we assume that the values are not valid and return
20164 * failure to the caller. (4203735)
20165 */
20166 if ((capacity == 0) || (lbasize == 0)) {
20167 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, -1,
20168 "sd_send_scsi_READ_CAPACITY received invalid value "
20169 "capacity %llu lbasize %d", capacity, lbasize);
20170 return (EIO);
20171 }
20172 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
20173 return (0);
20174 }
20175
20176 /*
20177 * Function: sd_send_scsi_READ_CAPACITY_16
20178 *
20179 * Description: This routine uses the scsi READ CAPACITY 16 command to
20180 * determine the device capacity in number of blocks and the
20181 * device native block size. If this function returns a failure,
20182 * then the values in *capp and *lbap are undefined.
20183 * This routine should be called by sd_send_scsi_READ_CAPACITY
20184 * which will apply any device specific adjustments to capacity
20185 * and lbasize. One exception is it is also called by
20186 * sd_get_media_info_ext. In that function, there is no need to
20187 * adjust the capacity and lbasize.
20188 *
20189 * Arguments: ssc - ssc contains ptr to soft state struct for the target
20190 * capp - ptr to unsigned 64-bit variable to receive the
20191 * capacity value from the command.
20192 * lbap - ptr to unsigned 32-bit varaible to receive the
20193 * block size value from the command
20194 * psp - ptr to unsigned 32-bit variable to receive the
20195 * physical block size value from the command
20196 * path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and
20197 * the normal command waitq, or SD_PATH_DIRECT_PRIORITY
20198 * to use the USCSI "direct" chain and bypass the normal
20199 * command waitq. SD_PATH_DIRECT_PRIORITY is used when
20200 * this command is issued as part of an error recovery
20201 * action.
20202 *
20203 * Return Code: 0 - Success
20204 * EIO - IO error
20205 * EACCES - Reservation conflict detected
20206 * EAGAIN - Device is becoming ready
20207 * errno return code from sd_ssc_send()
20208 *
20209 * Context: Can sleep. Blocks until command completes.
20210 */
20211
20212 #define SD_CAPACITY_16_SIZE sizeof (struct scsi_capacity_16)
20213
20214 static int
20215 sd_send_scsi_READ_CAPACITY_16(sd_ssc_t *ssc, uint64_t *capp, uint32_t *lbap,
20216 uint32_t *psp, int path_flag)
20217 {
20218 struct scsi_extended_sense sense_buf;
20219 struct uscsi_cmd ucmd_buf;
20220 union scsi_cdb cdb;
20221 uint64_t *capacity16_buf;
20222 uint64_t capacity;
20223 uint32_t lbasize;
20224 uint32_t pbsize;
20225 uint32_t lbpb_exp;
20226 int status;
20227 struct sd_lun *un;
20228
20229 ASSERT(ssc != NULL);
20230
20231 un = ssc->ssc_un;
20232 ASSERT(un != NULL);
20233 ASSERT(!mutex_owned(SD_MUTEX(un)));
20234 ASSERT(capp != NULL);
20235 ASSERT(lbap != NULL);
20236
20237 SD_TRACE(SD_LOG_IO, un,
20238 "sd_send_scsi_READ_CAPACITY: entry: un:0x%p\n", un);
20239
20240 /*
20241 * First send a READ_CAPACITY_16 command to the target.
20242 *
20243 * Set up the CDB for the READ_CAPACITY_16 command. The Partial
20244 * Medium Indicator bit is cleared. The address field must be
20245 * zero if the PMI bit is zero.
20246 */
20247 bzero(&cdb, sizeof (cdb));
20248 bzero(&ucmd_buf, sizeof (ucmd_buf));
20249
20250 capacity16_buf = kmem_zalloc(SD_CAPACITY_16_SIZE, KM_SLEEP);
20251
20252 ucmd_buf.uscsi_cdb = (char *)&cdb;
20253 ucmd_buf.uscsi_cdblen = CDB_GROUP4;
20254 ucmd_buf.uscsi_bufaddr = (caddr_t)capacity16_buf;
20255 ucmd_buf.uscsi_buflen = SD_CAPACITY_16_SIZE;
20256 ucmd_buf.uscsi_rqbuf = (caddr_t)&sense_buf;
20257 ucmd_buf.uscsi_rqlen = sizeof (sense_buf);
20258 ucmd_buf.uscsi_flags = USCSI_RQENABLE | USCSI_READ | USCSI_SILENT;
20259 ucmd_buf.uscsi_timeout = 60;
20260
20261 /*
20262 * Read Capacity (16) is a Service Action In command. One
20263 * command byte (0x9E) is overloaded for multiple operations,
20264 * with the second CDB byte specifying the desired operation
20265 */
20266 cdb.scc_cmd = SCMD_SVC_ACTION_IN_G4;
20267 cdb.cdb_opaque[1] = SSVC_ACTION_READ_CAPACITY_G4;
20268
20269 /*
20270 * Fill in allocation length field
20271 */
20272 FORMG4COUNT(&cdb, ucmd_buf.uscsi_buflen);
20273
20274 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
20275 UIO_SYSSPACE, path_flag);
20276
20277 switch (status) {
20278 case 0:
20279 /* Return failure if we did not get valid capacity data. */
20280 if (ucmd_buf.uscsi_resid > 20) {
20281 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, -1,
20282 "sd_send_scsi_READ_CAPACITY_16 received invalid "
20283 "capacity data");
20284 kmem_free(capacity16_buf, SD_CAPACITY_16_SIZE);
20285 return (EIO);
20286 }
20287
20288 /*
20289 * Read capacity and block size from the READ CAPACITY 16 data.
20290 * This data may be adjusted later due to device specific
20291 * issues.
20292 *
20293 * According to the SCSI spec, the READ CAPACITY 16
20294 * command returns the following:
20295 *
20296 * bytes 0-7: Maximum logical block address available.
20297 * (MSB in byte:0 & LSB in byte:7)
20298 *
20299 * bytes 8-11: Block length in bytes
20300 * (MSB in byte:8 & LSB in byte:11)
20301 *
20302 * byte 13: LOGICAL BLOCKS PER PHYSICAL BLOCK EXPONENT
20303 */
20304 capacity = BE_64(capacity16_buf[0]);
20305 lbasize = BE_32(*(uint32_t *)&capacity16_buf[1]);
20306 lbpb_exp = (BE_64(capacity16_buf[1]) >> 16) & 0x0f;
20307
20308 pbsize = lbasize << lbpb_exp;
20309
20310 /*
20311 * Done with capacity16_buf
20312 */
20313 kmem_free(capacity16_buf, SD_CAPACITY_16_SIZE);
20314
20315 /*
20316 * if the reported capacity is set to all 0xf's, then
20317 * this disk is too large. This could only happen with
20318 * a device that supports LBAs larger than 64 bits which
20319 * are not defined by any current T10 standards.
20320 */
20321 if (capacity == 0xffffffffffffffff) {
20322 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, -1,
20323 "disk is too large");
20324 return (EIO);
20325 }
20326 break; /* Success! */
20327 case EIO:
20328 switch (ucmd_buf.uscsi_status) {
20329 case STATUS_RESERVATION_CONFLICT:
20330 status = EACCES;
20331 break;
20332 case STATUS_CHECK:
20333 /*
20334 * Check condition; look for ASC/ASCQ of 0x04/0x01
20335 * (LOGICAL UNIT IS IN PROCESS OF BECOMING READY)
20336 */
20337 if ((ucmd_buf.uscsi_rqstatus == STATUS_GOOD) &&
20338 (scsi_sense_asc((uint8_t *)&sense_buf) == 0x04) &&
20339 (scsi_sense_ascq((uint8_t *)&sense_buf) == 0x01)) {
20340 kmem_free(capacity16_buf, SD_CAPACITY_16_SIZE);
20341 return (EAGAIN);
20342 }
20343 break;
20344 default:
20345 break;
20346 }
20347 /* FALLTHRU */
20348 default:
20349 kmem_free(capacity16_buf, SD_CAPACITY_16_SIZE);
20350 return (status);
20351 }
20352
20353 /*
20354 * Some ATAPI CD-ROM drives report inaccurate LBA size values
20355 * (2352 and 0 are common) so for these devices always force the value
20356 * to 2048 as required by the ATAPI specs.
20357 */
20358 if ((un->un_f_cfg_is_atapi == TRUE) && (ISCD(un))) {
20359 lbasize = 2048;
20360 }
20361
20362 /*
20363 * Get the maximum LBA value from the READ CAPACITY 16 data.
20364 * Here we assume that the Partial Medium Indicator (PMI) bit
20365 * was cleared when issuing the command. This means that the LBA
20366 * returned from the device is the LBA of the last logical block
20367 * on the logical unit. The actual logical block count will be
20368 * this value plus one.
20369 */
20370 capacity += 1;
20371
20372 /*
20373 * Currently, for removable media, the capacity is saved in terms
20374 * of un->un_sys_blocksize, so scale the capacity value to reflect this.
20375 */
20376 if (un->un_f_has_removable_media)
20377 capacity *= (lbasize / un->un_sys_blocksize);
20378
20379 *capp = capacity;
20380 *lbap = lbasize;
20381 *psp = pbsize;
20382
20383 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_READ_CAPACITY_16: "
20384 "capacity:0x%llx lbasize:0x%x, pbsize: 0x%x\n",
20385 capacity, lbasize, pbsize);
20386
20387 if ((capacity == 0) || (lbasize == 0) || (pbsize == 0)) {
20388 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, -1,
20389 "sd_send_scsi_READ_CAPACITY_16 received invalid value "
20390 "capacity %llu lbasize %d pbsize %d", capacity, lbasize);
20391 return (EIO);
20392 }
20393
20394 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
20395 return (0);
20396 }
20397
20398
20399 /*
20400 * Function: sd_send_scsi_START_STOP_UNIT
20401 *
20402 * Description: Issue a scsi START STOP UNIT command to the target.
20403 *
20404 * Arguments: ssc - ssc contatins pointer to driver soft state (unit)
20405 * structure for this target.
20406 * pc_flag - SD_POWER_CONDITION
20407 * SD_START_STOP
20408 * flag - SD_TARGET_START
20409 * SD_TARGET_STOP
20410 * SD_TARGET_EJECT
20411 * SD_TARGET_CLOSE
20412 * path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and
20413 * the normal command waitq, or SD_PATH_DIRECT_PRIORITY
20414 * to use the USCSI "direct" chain and bypass the normal
20415 * command waitq. SD_PATH_DIRECT_PRIORITY is used when this
20416 * command is issued as part of an error recovery action.
20417 *
20418 * Return Code: 0 - Success
20419 * EIO - IO error
20420 * EACCES - Reservation conflict detected
20421 * ENXIO - Not Ready, medium not present
20422 * errno return code from sd_ssc_send()
20423 *
20424 * Context: Can sleep.
20425 */
20426
20427 static int
20428 sd_send_scsi_START_STOP_UNIT(sd_ssc_t *ssc, int pc_flag, int flag,
20429 int path_flag)
20430 {
20431 struct scsi_extended_sense sense_buf;
20432 union scsi_cdb cdb;
20433 struct uscsi_cmd ucmd_buf;
20434 int status;
20435 struct sd_lun *un;
20436
20437 ASSERT(ssc != NULL);
20438 un = ssc->ssc_un;
20439 ASSERT(un != NULL);
20440 ASSERT(!mutex_owned(SD_MUTEX(un)));
20441
20442 SD_TRACE(SD_LOG_IO, un,
20443 "sd_send_scsi_START_STOP_UNIT: entry: un:0x%p\n", un);
20444
20445 if (un->un_f_check_start_stop &&
20446 (pc_flag == SD_START_STOP) &&
20447 ((flag == SD_TARGET_START) || (flag == SD_TARGET_STOP)) &&
20448 (un->un_f_start_stop_supported != TRUE)) {
20449 return (0);
20450 }
20451
20452 /*
20453 * If we are performing an eject operation and
20454 * we receive any command other than SD_TARGET_EJECT
20455 * we should immediately return.
20456 */
20457 if (flag != SD_TARGET_EJECT) {
20458 mutex_enter(SD_MUTEX(un));
20459 if (un->un_f_ejecting == TRUE) {
20460 mutex_exit(SD_MUTEX(un));
20461 return (EAGAIN);
20462 }
20463 mutex_exit(SD_MUTEX(un));
20464 }
20465
20466 bzero(&cdb, sizeof (cdb));
20467 bzero(&ucmd_buf, sizeof (ucmd_buf));
20468 bzero(&sense_buf, sizeof (struct scsi_extended_sense));
20469
20470 cdb.scc_cmd = SCMD_START_STOP;
20471 cdb.cdb_opaque[4] = (pc_flag == SD_POWER_CONDITION) ?
20472 (uchar_t)(flag << 4) : (uchar_t)flag;
20473
20474 ucmd_buf.uscsi_cdb = (char *)&cdb;
20475 ucmd_buf.uscsi_cdblen = CDB_GROUP0;
20476 ucmd_buf.uscsi_bufaddr = NULL;
20477 ucmd_buf.uscsi_buflen = 0;
20478 ucmd_buf.uscsi_rqbuf = (caddr_t)&sense_buf;
20479 ucmd_buf.uscsi_rqlen = sizeof (struct scsi_extended_sense);
20480 ucmd_buf.uscsi_flags = USCSI_RQENABLE | USCSI_SILENT;
20481 ucmd_buf.uscsi_timeout = 200;
20482
20483 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
20484 UIO_SYSSPACE, path_flag);
20485
20486 switch (status) {
20487 case 0:
20488 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
20489 break; /* Success! */
20490 case EIO:
20491 switch (ucmd_buf.uscsi_status) {
20492 case STATUS_RESERVATION_CONFLICT:
20493 status = EACCES;
20494 break;
20495 case STATUS_CHECK:
20496 if (ucmd_buf.uscsi_rqstatus == STATUS_GOOD) {
20497 switch (scsi_sense_key(
20498 (uint8_t *)&sense_buf)) {
20499 case KEY_ILLEGAL_REQUEST:
20500 status = ENOTSUP;
20501 break;
20502 case KEY_NOT_READY:
20503 if (scsi_sense_asc(
20504 (uint8_t *)&sense_buf)
20505 == 0x3A) {
20506 status = ENXIO;
20507 }
20508 break;
20509 default:
20510 break;
20511 }
20512 }
20513 break;
20514 default:
20515 break;
20516 }
20517 break;
20518 default:
20519 break;
20520 }
20521
20522 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_START_STOP_UNIT: exit\n");
20523
20524 return (status);
20525 }
20526
20527
20528 /*
20529 * Function: sd_start_stop_unit_callback
20530 *
20531 * Description: timeout(9F) callback to begin recovery process for a
20532 * device that has spun down.
20533 *
20534 * Arguments: arg - pointer to associated softstate struct.
20535 *
20536 * Context: Executes in a timeout(9F) thread context
20537 */
20538
20539 static void
20540 sd_start_stop_unit_callback(void *arg)
20541 {
20542 struct sd_lun *un = arg;
20543 ASSERT(un != NULL);
20544 ASSERT(!mutex_owned(SD_MUTEX(un)));
20545
20546 SD_TRACE(SD_LOG_IO, un, "sd_start_stop_unit_callback: entry\n");
20547
20548 (void) taskq_dispatch(sd_tq, sd_start_stop_unit_task, un, KM_NOSLEEP);
20549 }
20550
20551
20552 /*
20553 * Function: sd_start_stop_unit_task
20554 *
20555 * Description: Recovery procedure when a drive is spun down.
20556 *
20557 * Arguments: arg - pointer to associated softstate struct.
20558 *
20559 * Context: Executes in a taskq() thread context
20560 */
20561
20562 static void
20563 sd_start_stop_unit_task(void *arg)
20564 {
20565 struct sd_lun *un = arg;
20566 sd_ssc_t *ssc;
20567 int power_level;
20568 int rval;
20569
20570 ASSERT(un != NULL);
20571 ASSERT(!mutex_owned(SD_MUTEX(un)));
20572
20573 SD_TRACE(SD_LOG_IO, un, "sd_start_stop_unit_task: entry\n");
20574
20575 /*
20576 * Some unformatted drives report not ready error, no need to
20577 * restart if format has been initiated.
20578 */
20579 mutex_enter(SD_MUTEX(un));
20580 if (un->un_f_format_in_progress == TRUE) {
20581 mutex_exit(SD_MUTEX(un));
20582 return;
20583 }
20584 mutex_exit(SD_MUTEX(un));
20585
20586 ssc = sd_ssc_init(un);
20587 /*
20588 * When a START STOP command is issued from here, it is part of a
20589 * failure recovery operation and must be issued before any other
20590 * commands, including any pending retries. Thus it must be sent
20591 * using SD_PATH_DIRECT_PRIORITY. It doesn't matter if the spin up
20592 * succeeds or not, we will start I/O after the attempt.
20593 * If power condition is supported and the current power level
20594 * is capable of performing I/O, we should set the power condition
20595 * to that level. Otherwise, set the power condition to ACTIVE.
20596 */
20597 if (un->un_f_power_condition_supported) {
20598 mutex_enter(SD_MUTEX(un));
20599 ASSERT(SD_PM_IS_LEVEL_VALID(un, un->un_power_level));
20600 power_level = sd_pwr_pc.ran_perf[un->un_power_level]
20601 > 0 ? un->un_power_level : SD_SPINDLE_ACTIVE;
20602 mutex_exit(SD_MUTEX(un));
20603 rval = sd_send_scsi_START_STOP_UNIT(ssc, SD_POWER_CONDITION,
20604 sd_pl2pc[power_level], SD_PATH_DIRECT_PRIORITY);
20605 } else {
20606 rval = sd_send_scsi_START_STOP_UNIT(ssc, SD_START_STOP,
20607 SD_TARGET_START, SD_PATH_DIRECT_PRIORITY);
20608 }
20609
20610 if (rval != 0)
20611 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
20612 sd_ssc_fini(ssc);
20613 /*
20614 * The above call blocks until the START_STOP_UNIT command completes.
20615 * Now that it has completed, we must re-try the original IO that
20616 * received the NOT READY condition in the first place. There are
20617 * three possible conditions here:
20618 *
20619 * (1) The original IO is on un_retry_bp.
20620 * (2) The original IO is on the regular wait queue, and un_retry_bp
20621 * is NULL.
20622 * (3) The original IO is on the regular wait queue, and un_retry_bp
20623 * points to some other, unrelated bp.
20624 *
20625 * For each case, we must call sd_start_cmds() with un_retry_bp
20626 * as the argument. If un_retry_bp is NULL, this will initiate
20627 * processing of the regular wait queue. If un_retry_bp is not NULL,
20628 * then this will process the bp on un_retry_bp. That may or may not
20629 * be the original IO, but that does not matter: the important thing
20630 * is to keep the IO processing going at this point.
20631 *
20632 * Note: This is a very specific error recovery sequence associated
20633 * with a drive that is not spun up. We attempt a START_STOP_UNIT and
20634 * serialize the I/O with completion of the spin-up.
20635 */
20636 mutex_enter(SD_MUTEX(un));
20637 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
20638 "sd_start_stop_unit_task: un:0x%p starting bp:0x%p\n",
20639 un, un->un_retry_bp);
20640 un->un_startstop_timeid = NULL; /* Timeout is no longer pending */
20641 sd_start_cmds(un, un->un_retry_bp);
20642 mutex_exit(SD_MUTEX(un));
20643
20644 SD_TRACE(SD_LOG_IO, un, "sd_start_stop_unit_task: exit\n");
20645 }
20646
20647
20648 /*
20649 * Function: sd_send_scsi_INQUIRY
20650 *
20651 * Description: Issue the scsi INQUIRY command.
20652 *
20653 * Arguments: ssc - ssc contains pointer to driver soft state (unit)
20654 * structure for this target.
20655 * bufaddr
20656 * buflen
20657 * evpd
20658 * page_code
20659 * page_length
20660 *
20661 * Return Code: 0 - Success
20662 * errno return code from sd_ssc_send()
20663 *
20664 * Context: Can sleep. Does not return until command is completed.
20665 */
20666
20667 static int
20668 sd_send_scsi_INQUIRY(sd_ssc_t *ssc, uchar_t *bufaddr, size_t buflen,
20669 uchar_t evpd, uchar_t page_code, size_t *residp)
20670 {
20671 union scsi_cdb cdb;
20672 struct uscsi_cmd ucmd_buf;
20673 int status;
20674 struct sd_lun *un;
20675
20676 ASSERT(ssc != NULL);
20677 un = ssc->ssc_un;
20678 ASSERT(un != NULL);
20679 ASSERT(!mutex_owned(SD_MUTEX(un)));
20680 ASSERT(bufaddr != NULL);
20681
20682 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_INQUIRY: entry: un:0x%p\n", un);
20683
20684 bzero(&cdb, sizeof (cdb));
20685 bzero(&ucmd_buf, sizeof (ucmd_buf));
20686 bzero(bufaddr, buflen);
20687
20688 cdb.scc_cmd = SCMD_INQUIRY;
20689 cdb.cdb_opaque[1] = evpd;
20690 cdb.cdb_opaque[2] = page_code;
20691 FORMG0COUNT(&cdb, buflen);
20692
20693 ucmd_buf.uscsi_cdb = (char *)&cdb;
20694 ucmd_buf.uscsi_cdblen = CDB_GROUP0;
20695 ucmd_buf.uscsi_bufaddr = (caddr_t)bufaddr;
20696 ucmd_buf.uscsi_buflen = buflen;
20697 ucmd_buf.uscsi_rqbuf = NULL;
20698 ucmd_buf.uscsi_rqlen = 0;
20699 ucmd_buf.uscsi_flags = USCSI_READ | USCSI_SILENT;
20700 ucmd_buf.uscsi_timeout = 200; /* Excessive legacy value */
20701
20702 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
20703 UIO_SYSSPACE, SD_PATH_DIRECT);
20704
20705 /*
20706 * Only handle status == 0, the upper-level caller
20707 * will put different assessment based on the context.
20708 */
20709 if (status == 0)
20710 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
20711
20712 if ((status == 0) && (residp != NULL)) {
20713 *residp = ucmd_buf.uscsi_resid;
20714 }
20715
20716 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_INQUIRY: exit\n");
20717
20718 return (status);
20719 }
20720
20721
20722 /*
20723 * Function: sd_send_scsi_TEST_UNIT_READY
20724 *
20725 * Description: Issue the scsi TEST UNIT READY command.
20726 * This routine can be told to set the flag USCSI_DIAGNOSE to
20727 * prevent retrying failed commands. Use this when the intent
20728 * is either to check for device readiness, to clear a Unit
20729 * Attention, or to clear any outstanding sense data.
20730 * However under specific conditions the expected behavior
20731 * is for retries to bring a device ready, so use the flag
20732 * with caution.
20733 *
20734 * Arguments: ssc - ssc contains pointer to driver soft state (unit)
20735 * structure for this target.
20736 * flag: SD_CHECK_FOR_MEDIA: return ENXIO if no media present
20737 * SD_DONT_RETRY_TUR: include uscsi flag USCSI_DIAGNOSE.
20738 * 0: dont check for media present, do retries on cmd.
20739 *
20740 * Return Code: 0 - Success
20741 * EIO - IO error
20742 * EACCES - Reservation conflict detected
20743 * ENXIO - Not Ready, medium not present
20744 * errno return code from sd_ssc_send()
20745 *
20746 * Context: Can sleep. Does not return until command is completed.
20747 */
20748
20749 static int
20750 sd_send_scsi_TEST_UNIT_READY(sd_ssc_t *ssc, int flag)
20751 {
20752 struct scsi_extended_sense sense_buf;
20753 union scsi_cdb cdb;
20754 struct uscsi_cmd ucmd_buf;
20755 int status;
20756 struct sd_lun *un;
20757
20758 ASSERT(ssc != NULL);
20759 un = ssc->ssc_un;
20760 ASSERT(un != NULL);
20761 ASSERT(!mutex_owned(SD_MUTEX(un)));
20762
20763 SD_TRACE(SD_LOG_IO, un,
20764 "sd_send_scsi_TEST_UNIT_READY: entry: un:0x%p\n", un);
20765
20766 /*
20767 * Some Seagate elite1 TQ devices get hung with disconnect/reconnect
20768 * timeouts when they receive a TUR and the queue is not empty. Check
20769 * the configuration flag set during attach (indicating the drive has
20770 * this firmware bug) and un_ncmds_in_transport before issuing the
20771 * TUR. If there are
20772 * pending commands return success, this is a bit arbitrary but is ok
20773 * for non-removables (i.e. the eliteI disks) and non-clustering
20774 * configurations.
20775 */
20776 if (un->un_f_cfg_tur_check == TRUE) {
20777 mutex_enter(SD_MUTEX(un));
20778 if (un->un_ncmds_in_transport != 0) {
20779 mutex_exit(SD_MUTEX(un));
20780 return (0);
20781 }
20782 mutex_exit(SD_MUTEX(un));
20783 }
20784
20785 bzero(&cdb, sizeof (cdb));
20786 bzero(&ucmd_buf, sizeof (ucmd_buf));
20787 bzero(&sense_buf, sizeof (struct scsi_extended_sense));
20788
20789 cdb.scc_cmd = SCMD_TEST_UNIT_READY;
20790
20791 ucmd_buf.uscsi_cdb = (char *)&cdb;
20792 ucmd_buf.uscsi_cdblen = CDB_GROUP0;
20793 ucmd_buf.uscsi_bufaddr = NULL;
20794 ucmd_buf.uscsi_buflen = 0;
20795 ucmd_buf.uscsi_rqbuf = (caddr_t)&sense_buf;
20796 ucmd_buf.uscsi_rqlen = sizeof (struct scsi_extended_sense);
20797 ucmd_buf.uscsi_flags = USCSI_RQENABLE | USCSI_SILENT;
20798
20799 /* Use flag USCSI_DIAGNOSE to prevent retries if it fails. */
20800 if ((flag & SD_DONT_RETRY_TUR) != 0) {
20801 ucmd_buf.uscsi_flags |= USCSI_DIAGNOSE;
20802 }
20803 ucmd_buf.uscsi_timeout = 60;
20804
20805 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
20806 UIO_SYSSPACE, ((flag & SD_BYPASS_PM) ? SD_PATH_DIRECT :
20807 SD_PATH_STANDARD));
20808
20809 switch (status) {
20810 case 0:
20811 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
20812 break; /* Success! */
20813 case EIO:
20814 switch (ucmd_buf.uscsi_status) {
20815 case STATUS_RESERVATION_CONFLICT:
20816 status = EACCES;
20817 break;
20818 case STATUS_CHECK:
20819 if ((flag & SD_CHECK_FOR_MEDIA) == 0) {
20820 break;
20821 }
20822 if ((ucmd_buf.uscsi_rqstatus == STATUS_GOOD) &&
20823 (scsi_sense_key((uint8_t *)&sense_buf) ==
20824 KEY_NOT_READY) &&
20825 (scsi_sense_asc((uint8_t *)&sense_buf) == 0x3A)) {
20826 status = ENXIO;
20827 }
20828 break;
20829 default:
20830 break;
20831 }
20832 break;
20833 default:
20834 break;
20835 }
20836
20837 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_TEST_UNIT_READY: exit\n");
20838
20839 return (status);
20840 }
20841
20842 /*
20843 * Function: sd_send_scsi_PERSISTENT_RESERVE_IN
20844 *
20845 * Description: Issue the scsi PERSISTENT RESERVE IN command.
20846 *
20847 * Arguments: ssc - ssc contains pointer to driver soft state (unit)
20848 * structure for this target.
20849 *
20850 * Return Code: 0 - Success
20851 * EACCES
20852 * ENOTSUP
20853 * errno return code from sd_ssc_send()
20854 *
20855 * Context: Can sleep. Does not return until command is completed.
20856 */
20857
20858 static int
20859 sd_send_scsi_PERSISTENT_RESERVE_IN(sd_ssc_t *ssc, uchar_t usr_cmd,
20860 uint16_t data_len, uchar_t *data_bufp)
20861 {
20862 struct scsi_extended_sense sense_buf;
20863 union scsi_cdb cdb;
20864 struct uscsi_cmd ucmd_buf;
20865 int status;
20866 int no_caller_buf = FALSE;
20867 struct sd_lun *un;
20868
20869 ASSERT(ssc != NULL);
20870 un = ssc->ssc_un;
20871 ASSERT(un != NULL);
20872 ASSERT(!mutex_owned(SD_MUTEX(un)));
20873 ASSERT((usr_cmd == SD_READ_KEYS) || (usr_cmd == SD_READ_RESV));
20874
20875 SD_TRACE(SD_LOG_IO, un,
20876 "sd_send_scsi_PERSISTENT_RESERVE_IN: entry: un:0x%p\n", un);
20877
20878 bzero(&cdb, sizeof (cdb));
20879 bzero(&ucmd_buf, sizeof (ucmd_buf));
20880 bzero(&sense_buf, sizeof (struct scsi_extended_sense));
20881 if (data_bufp == NULL) {
20882 /* Allocate a default buf if the caller did not give one */
20883 ASSERT(data_len == 0);
20884 data_len = MHIOC_RESV_KEY_SIZE;
20885 data_bufp = kmem_zalloc(MHIOC_RESV_KEY_SIZE, KM_SLEEP);
20886 no_caller_buf = TRUE;
20887 }
20888
20889 cdb.scc_cmd = SCMD_PERSISTENT_RESERVE_IN;
20890 cdb.cdb_opaque[1] = usr_cmd;
20891 FORMG1COUNT(&cdb, data_len);
20892
20893 ucmd_buf.uscsi_cdb = (char *)&cdb;
20894 ucmd_buf.uscsi_cdblen = CDB_GROUP1;
20895 ucmd_buf.uscsi_bufaddr = (caddr_t)data_bufp;
20896 ucmd_buf.uscsi_buflen = data_len;
20897 ucmd_buf.uscsi_rqbuf = (caddr_t)&sense_buf;
20898 ucmd_buf.uscsi_rqlen = sizeof (struct scsi_extended_sense);
20899 ucmd_buf.uscsi_flags = USCSI_RQENABLE | USCSI_READ | USCSI_SILENT;
20900 ucmd_buf.uscsi_timeout = 60;
20901
20902 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
20903 UIO_SYSSPACE, SD_PATH_STANDARD);
20904
20905 switch (status) {
20906 case 0:
20907 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
20908
20909 break; /* Success! */
20910 case EIO:
20911 switch (ucmd_buf.uscsi_status) {
20912 case STATUS_RESERVATION_CONFLICT:
20913 status = EACCES;
20914 break;
20915 case STATUS_CHECK:
20916 if ((ucmd_buf.uscsi_rqstatus == STATUS_GOOD) &&
20917 (scsi_sense_key((uint8_t *)&sense_buf) ==
20918 KEY_ILLEGAL_REQUEST)) {
20919 status = ENOTSUP;
20920 }
20921 break;
20922 default:
20923 break;
20924 }
20925 break;
20926 default:
20927 break;
20928 }
20929
20930 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_PERSISTENT_RESERVE_IN: exit\n");
20931
20932 if (no_caller_buf == TRUE) {
20933 kmem_free(data_bufp, data_len);
20934 }
20935
20936 return (status);
20937 }
20938
20939
20940 /*
20941 * Function: sd_send_scsi_PERSISTENT_RESERVE_OUT
20942 *
20943 * Description: This routine is the driver entry point for handling CD-ROM
20944 * multi-host persistent reservation requests (MHIOCGRP_INKEYS,
20945 * MHIOCGRP_INRESV) by sending the SCSI-3 PROUT commands to the
20946 * device.
20947 *
20948 * Arguments: ssc - ssc contains un - pointer to soft state struct
20949 * for the target.
20950 * usr_cmd SCSI-3 reservation facility command (one of
20951 * SD_SCSI3_REGISTER, SD_SCSI3_RESERVE, SD_SCSI3_RELEASE,
20952 * SD_SCSI3_PREEMPTANDABORT, SD_SCSI3_CLEAR)
20953 * usr_bufp - user provided pointer register, reserve descriptor or
20954 * preempt and abort structure (mhioc_register_t,
20955 * mhioc_resv_desc_t, mhioc_preemptandabort_t)
20956 *
20957 * Return Code: 0 - Success
20958 * EACCES
20959 * ENOTSUP
20960 * errno return code from sd_ssc_send()
20961 *
20962 * Context: Can sleep. Does not return until command is completed.
20963 */
20964
20965 static int
20966 sd_send_scsi_PERSISTENT_RESERVE_OUT(sd_ssc_t *ssc, uchar_t usr_cmd,
20967 uchar_t *usr_bufp)
20968 {
20969 struct scsi_extended_sense sense_buf;
20970 union scsi_cdb cdb;
20971 struct uscsi_cmd ucmd_buf;
20972 int status;
20973 uchar_t data_len = sizeof (sd_prout_t);
20974 sd_prout_t *prp;
20975 struct sd_lun *un;
20976
20977 ASSERT(ssc != NULL);
20978 un = ssc->ssc_un;
20979 ASSERT(un != NULL);
20980 ASSERT(!mutex_owned(SD_MUTEX(un)));
20981 ASSERT(data_len == 24); /* required by scsi spec */
20982
20983 SD_TRACE(SD_LOG_IO, un,
20984 "sd_send_scsi_PERSISTENT_RESERVE_OUT: entry: un:0x%p\n", un);
20985
20986 if (usr_bufp == NULL) {
20987 return (EINVAL);
20988 }
20989
20990 bzero(&cdb, sizeof (cdb));
20991 bzero(&ucmd_buf, sizeof (ucmd_buf));
20992 bzero(&sense_buf, sizeof (struct scsi_extended_sense));
20993 prp = kmem_zalloc(data_len, KM_SLEEP);
20994
20995 cdb.scc_cmd = SCMD_PERSISTENT_RESERVE_OUT;
20996 cdb.cdb_opaque[1] = usr_cmd;
20997 FORMG1COUNT(&cdb, data_len);
20998
20999 ucmd_buf.uscsi_cdb = (char *)&cdb;
21000 ucmd_buf.uscsi_cdblen = CDB_GROUP1;
21001 ucmd_buf.uscsi_bufaddr = (caddr_t)prp;
21002 ucmd_buf.uscsi_buflen = data_len;
21003 ucmd_buf.uscsi_rqbuf = (caddr_t)&sense_buf;
21004 ucmd_buf.uscsi_rqlen = sizeof (struct scsi_extended_sense);
21005 ucmd_buf.uscsi_flags = USCSI_RQENABLE | USCSI_WRITE | USCSI_SILENT;
21006 ucmd_buf.uscsi_timeout = 60;
21007
21008 switch (usr_cmd) {
21009 case SD_SCSI3_REGISTER: {
21010 mhioc_register_t *ptr = (mhioc_register_t *)usr_bufp;
21011
21012 bcopy(ptr->oldkey.key, prp->res_key, MHIOC_RESV_KEY_SIZE);
21013 bcopy(ptr->newkey.key, prp->service_key,
21014 MHIOC_RESV_KEY_SIZE);
21015 prp->aptpl = ptr->aptpl;
21016 break;
21017 }
21018 case SD_SCSI3_CLEAR: {
21019 mhioc_resv_desc_t *ptr = (mhioc_resv_desc_t *)usr_bufp;
21020
21021 bcopy(ptr->key.key, prp->res_key, MHIOC_RESV_KEY_SIZE);
21022 break;
21023 }
21024 case SD_SCSI3_RESERVE:
21025 case SD_SCSI3_RELEASE: {
21026 mhioc_resv_desc_t *ptr = (mhioc_resv_desc_t *)usr_bufp;
21027
21028 bcopy(ptr->key.key, prp->res_key, MHIOC_RESV_KEY_SIZE);
21029 prp->scope_address = BE_32(ptr->scope_specific_addr);
21030 cdb.cdb_opaque[2] = ptr->type;
21031 break;
21032 }
21033 case SD_SCSI3_PREEMPTANDABORT: {
21034 mhioc_preemptandabort_t *ptr =
21035 (mhioc_preemptandabort_t *)usr_bufp;
21036
21037 bcopy(ptr->resvdesc.key.key, prp->res_key, MHIOC_RESV_KEY_SIZE);
21038 bcopy(ptr->victim_key.key, prp->service_key,
21039 MHIOC_RESV_KEY_SIZE);
21040 prp->scope_address = BE_32(ptr->resvdesc.scope_specific_addr);
21041 cdb.cdb_opaque[2] = ptr->resvdesc.type;
21042 ucmd_buf.uscsi_flags |= USCSI_HEAD;
21043 break;
21044 }
21045 case SD_SCSI3_REGISTERANDIGNOREKEY:
21046 {
21047 mhioc_registerandignorekey_t *ptr;
21048 ptr = (mhioc_registerandignorekey_t *)usr_bufp;
21049 bcopy(ptr->newkey.key,
21050 prp->service_key, MHIOC_RESV_KEY_SIZE);
21051 prp->aptpl = ptr->aptpl;
21052 break;
21053 }
21054 default:
21055 ASSERT(FALSE);
21056 break;
21057 }
21058
21059 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
21060 UIO_SYSSPACE, SD_PATH_STANDARD);
21061
21062 switch (status) {
21063 case 0:
21064 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
21065 break; /* Success! */
21066 case EIO:
21067 switch (ucmd_buf.uscsi_status) {
21068 case STATUS_RESERVATION_CONFLICT:
21069 status = EACCES;
21070 break;
21071 case STATUS_CHECK:
21072 if ((ucmd_buf.uscsi_rqstatus == STATUS_GOOD) &&
21073 (scsi_sense_key((uint8_t *)&sense_buf) ==
21074 KEY_ILLEGAL_REQUEST)) {
21075 status = ENOTSUP;
21076 }
21077 break;
21078 default:
21079 break;
21080 }
21081 break;
21082 default:
21083 break;
21084 }
21085
21086 kmem_free(prp, data_len);
21087 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_PERSISTENT_RESERVE_OUT: exit\n");
21088 return (status);
21089 }
21090
21091
21092 /*
21093 * Function: sd_send_scsi_SYNCHRONIZE_CACHE
21094 *
21095 * Description: Issues a scsi SYNCHRONIZE CACHE command to the target
21096 *
21097 * Arguments: un - pointer to the target's soft state struct
21098 * dkc - pointer to the callback structure
21099 *
21100 * Return Code: 0 - success
21101 * errno-type error code
21102 *
21103 * Context: kernel thread context only.
21104 *
21105 * _______________________________________________________________
21106 * | dkc_flag & | dkc_callback | DKIOCFLUSHWRITECACHE |
21107 * |FLUSH_VOLATILE| | operation |
21108 * |______________|______________|_________________________________|
21109 * | 0 | NULL | Synchronous flush on both |
21110 * | | | volatile and non-volatile cache |
21111 * |______________|______________|_________________________________|
21112 * | 1 | NULL | Synchronous flush on volatile |
21113 * | | | cache; disk drivers may suppress|
21114 * | | | flush if disk table indicates |
21115 * | | | non-volatile cache |
21116 * |______________|______________|_________________________________|
21117 * | 0 | !NULL | Asynchronous flush on both |
21118 * | | | volatile and non-volatile cache;|
21119 * |______________|______________|_________________________________|
21120 * | 1 | !NULL | Asynchronous flush on volatile |
21121 * | | | cache; disk drivers may suppress|
21122 * | | | flush if disk table indicates |
21123 * | | | non-volatile cache |
21124 * |______________|______________|_________________________________|
21125 *
21126 */
21127
21128 static int
21129 sd_send_scsi_SYNCHRONIZE_CACHE(struct sd_lun *un, struct dk_callback *dkc)
21130 {
21131 struct sd_uscsi_info *uip;
21132 struct uscsi_cmd *uscmd;
21133 union scsi_cdb *cdb;
21134 struct buf *bp;
21135 int rval = 0;
21136 int is_async;
21137
21138 SD_TRACE(SD_LOG_IO, un,
21139 "sd_send_scsi_SYNCHRONIZE_CACHE: entry: un:0x%p\n", un);
21140
21141 ASSERT(un != NULL);
21142 ASSERT(!mutex_owned(SD_MUTEX(un)));
21143
21144 if (dkc == NULL || dkc->dkc_callback == NULL) {
21145 is_async = FALSE;
21146 } else {
21147 is_async = TRUE;
21148 }
21149
21150 mutex_enter(SD_MUTEX(un));
21151 /* check whether cache flush should be suppressed */
21152 if (un->un_f_suppress_cache_flush == TRUE) {
21153 mutex_exit(SD_MUTEX(un));
21154 /*
21155 * suppress the cache flush if the device is told to do
21156 * so by sd.conf or disk table
21157 */
21158 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_SYNCHRONIZE_CACHE: \
21159 skip the cache flush since suppress_cache_flush is %d!\n",
21160 un->un_f_suppress_cache_flush);
21161
21162 if (is_async == TRUE) {
21163 /* invoke callback for asynchronous flush */
21164 (*dkc->dkc_callback)(dkc->dkc_cookie, 0);
21165 }
21166 return (rval);
21167 }
21168 mutex_exit(SD_MUTEX(un));
21169
21170 /*
21171 * check dkc_flag & FLUSH_VOLATILE so SYNC_NV bit can be
21172 * set properly
21173 */
21174 cdb = kmem_zalloc(CDB_GROUP1, KM_SLEEP);
21175 cdb->scc_cmd = SCMD_SYNCHRONIZE_CACHE;
21176
21177 mutex_enter(SD_MUTEX(un));
21178 if (dkc != NULL && un->un_f_sync_nv_supported &&
21179 (dkc->dkc_flag & FLUSH_VOLATILE)) {
21180 /*
21181 * if the device supports SYNC_NV bit, turn on
21182 * the SYNC_NV bit to only flush volatile cache
21183 */
21184 cdb->cdb_un.tag |= SD_SYNC_NV_BIT;
21185 }
21186 mutex_exit(SD_MUTEX(un));
21187
21188 /*
21189 * First get some memory for the uscsi_cmd struct and cdb
21190 * and initialize for SYNCHRONIZE_CACHE cmd.
21191 */
21192 uscmd = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP);
21193 uscmd->uscsi_cdblen = CDB_GROUP1;
21194 uscmd->uscsi_cdb = (caddr_t)cdb;
21195 uscmd->uscsi_bufaddr = NULL;
21196 uscmd->uscsi_buflen = 0;
21197 uscmd->uscsi_rqbuf = kmem_zalloc(SENSE_LENGTH, KM_SLEEP);
21198 uscmd->uscsi_rqlen = SENSE_LENGTH;
21199 uscmd->uscsi_rqresid = SENSE_LENGTH;
21200 uscmd->uscsi_flags = USCSI_RQENABLE | USCSI_SILENT;
21201 uscmd->uscsi_timeout = sd_io_time;
21202
21203 /*
21204 * Allocate an sd_uscsi_info struct and fill it with the info
21205 * needed by sd_initpkt_for_uscsi(). Then put the pointer into
21206 * b_private in the buf for sd_initpkt_for_uscsi(). Note that
21207 * since we allocate the buf here in this function, we do not
21208 * need to preserve the prior contents of b_private.
21209 * The sd_uscsi_info struct is also used by sd_uscsi_strategy()
21210 */
21211 uip = kmem_zalloc(sizeof (struct sd_uscsi_info), KM_SLEEP);
21212 uip->ui_flags = SD_PATH_DIRECT;
21213 uip->ui_cmdp = uscmd;
21214
21215 bp = getrbuf(KM_SLEEP);
21216 bp->b_private = uip;
21217
21218 /*
21219 * Setup buffer to carry uscsi request.
21220 */
21221 bp->b_flags = B_BUSY;
21222 bp->b_bcount = 0;
21223 bp->b_blkno = 0;
21224
21225 if (is_async == TRUE) {
21226 bp->b_iodone = sd_send_scsi_SYNCHRONIZE_CACHE_biodone;
21227 uip->ui_dkc = *dkc;
21228 }
21229
21230 bp->b_edev = SD_GET_DEV(un);
21231 bp->b_dev = cmpdev(bp->b_edev); /* maybe unnecessary? */
21232
21233 /*
21234 * Unset un_f_sync_cache_required flag
21235 */
21236 mutex_enter(SD_MUTEX(un));
21237 un->un_f_sync_cache_required = FALSE;
21238 mutex_exit(SD_MUTEX(un));
21239
21240 (void) sd_uscsi_strategy(bp);
21241
21242 /*
21243 * If synchronous request, wait for completion
21244 * If async just return and let b_iodone callback
21245 * cleanup.
21246 * NOTE: On return, u_ncmds_in_driver will be decremented,
21247 * but it was also incremented in sd_uscsi_strategy(), so
21248 * we should be ok.
21249 */
21250 if (is_async == FALSE) {
21251 (void) biowait(bp);
21252 rval = sd_send_scsi_SYNCHRONIZE_CACHE_biodone(bp);
21253 }
21254
21255 return (rval);
21256 }
21257
21258
21259 static int
21260 sd_send_scsi_SYNCHRONIZE_CACHE_biodone(struct buf *bp)
21261 {
21262 struct sd_uscsi_info *uip;
21263 struct uscsi_cmd *uscmd;
21264 uint8_t *sense_buf;
21265 struct sd_lun *un;
21266 int status;
21267 union scsi_cdb *cdb;
21268
21269 uip = (struct sd_uscsi_info *)(bp->b_private);
21270 ASSERT(uip != NULL);
21271
21272 uscmd = uip->ui_cmdp;
21273 ASSERT(uscmd != NULL);
21274
21275 sense_buf = (uint8_t *)uscmd->uscsi_rqbuf;
21276 ASSERT(sense_buf != NULL);
21277
21278 un = ddi_get_soft_state(sd_state, SD_GET_INSTANCE_FROM_BUF(bp));
21279 ASSERT(un != NULL);
21280
21281 cdb = (union scsi_cdb *)uscmd->uscsi_cdb;
21282
21283 status = geterror(bp);
21284 switch (status) {
21285 case 0:
21286 break; /* Success! */
21287 case EIO:
21288 switch (uscmd->uscsi_status) {
21289 case STATUS_RESERVATION_CONFLICT:
21290 /* Ignore reservation conflict */
21291 status = 0;
21292 goto done;
21293
21294 case STATUS_CHECK:
21295 if ((uscmd->uscsi_rqstatus == STATUS_GOOD) &&
21296 (scsi_sense_key(sense_buf) ==
21297 KEY_ILLEGAL_REQUEST)) {
21298 /* Ignore Illegal Request error */
21299 if (cdb->cdb_un.tag&SD_SYNC_NV_BIT) {
21300 mutex_enter(SD_MUTEX(un));
21301 un->un_f_sync_nv_supported = FALSE;
21302 mutex_exit(SD_MUTEX(un));
21303 status = 0;
21304 SD_TRACE(SD_LOG_IO, un,
21305 "un_f_sync_nv_supported \
21306 is set to false.\n");
21307 goto done;
21308 }
21309
21310 mutex_enter(SD_MUTEX(un));
21311 un->un_f_sync_cache_supported = FALSE;
21312 mutex_exit(SD_MUTEX(un));
21313 SD_TRACE(SD_LOG_IO, un,
21314 "sd_send_scsi_SYNCHRONIZE_CACHE_biodone: \
21315 un_f_sync_cache_supported set to false \
21316 with asc = %x, ascq = %x\n",
21317 scsi_sense_asc(sense_buf),
21318 scsi_sense_ascq(sense_buf));
21319 status = ENOTSUP;
21320 goto done;
21321 }
21322 break;
21323 default:
21324 break;
21325 }
21326 /* FALLTHRU */
21327 default:
21328 /*
21329 * Turn on the un_f_sync_cache_required flag
21330 * since the SYNC CACHE command failed
21331 */
21332 mutex_enter(SD_MUTEX(un));
21333 un->un_f_sync_cache_required = TRUE;
21334 mutex_exit(SD_MUTEX(un));
21335
21336 /*
21337 * Don't log an error message if this device
21338 * has removable media.
21339 */
21340 if (!un->un_f_has_removable_media) {
21341 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
21342 "SYNCHRONIZE CACHE command failed (%d)\n", status);
21343 }
21344 break;
21345 }
21346
21347 done:
21348 if (uip->ui_dkc.dkc_callback != NULL) {
21349 (*uip->ui_dkc.dkc_callback)(uip->ui_dkc.dkc_cookie, status);
21350 }
21351
21352 ASSERT((bp->b_flags & B_REMAPPED) == 0);
21353 freerbuf(bp);
21354 kmem_free(uip, sizeof (struct sd_uscsi_info));
21355 kmem_free(uscmd->uscsi_rqbuf, SENSE_LENGTH);
21356 kmem_free(uscmd->uscsi_cdb, (size_t)uscmd->uscsi_cdblen);
21357 kmem_free(uscmd, sizeof (struct uscsi_cmd));
21358
21359 return (status);
21360 }
21361
21362
21363 /*
21364 * Function: sd_send_scsi_GET_CONFIGURATION
21365 *
21366 * Description: Issues the get configuration command to the device.
21367 * Called from sd_check_for_writable_cd & sd_get_media_info
21368 * caller needs to ensure that buflen = SD_PROFILE_HEADER_LEN
21369 * Arguments: ssc
21370 * ucmdbuf
21371 * rqbuf
21372 * rqbuflen
21373 * bufaddr
21374 * buflen
21375 * path_flag
21376 *
21377 * Return Code: 0 - Success
21378 * errno return code from sd_ssc_send()
21379 *
21380 * Context: Can sleep. Does not return until command is completed.
21381 *
21382 */
21383
21384 static int
21385 sd_send_scsi_GET_CONFIGURATION(sd_ssc_t *ssc, struct uscsi_cmd *ucmdbuf,
21386 uchar_t *rqbuf, uint_t rqbuflen, uchar_t *bufaddr, uint_t buflen,
21387 int path_flag)
21388 {
21389 char cdb[CDB_GROUP1];
21390 int status;
21391 struct sd_lun *un;
21392
21393 ASSERT(ssc != NULL);
21394 un = ssc->ssc_un;
21395 ASSERT(un != NULL);
21396 ASSERT(!mutex_owned(SD_MUTEX(un)));
21397 ASSERT(bufaddr != NULL);
21398 ASSERT(ucmdbuf != NULL);
21399 ASSERT(rqbuf != NULL);
21400
21401 SD_TRACE(SD_LOG_IO, un,
21402 "sd_send_scsi_GET_CONFIGURATION: entry: un:0x%p\n", un);
21403
21404 bzero(cdb, sizeof (cdb));
21405 bzero(ucmdbuf, sizeof (struct uscsi_cmd));
21406 bzero(rqbuf, rqbuflen);
21407 bzero(bufaddr, buflen);
21408
21409 /*
21410 * Set up cdb field for the get configuration command.
21411 */
21412 cdb[0] = SCMD_GET_CONFIGURATION;
21413 cdb[1] = 0x02; /* Requested Type */
21414 cdb[8] = SD_PROFILE_HEADER_LEN;
21415 ucmdbuf->uscsi_cdb = cdb;
21416 ucmdbuf->uscsi_cdblen = CDB_GROUP1;
21417 ucmdbuf->uscsi_bufaddr = (caddr_t)bufaddr;
21418 ucmdbuf->uscsi_buflen = buflen;
21419 ucmdbuf->uscsi_timeout = sd_io_time;
21420 ucmdbuf->uscsi_rqbuf = (caddr_t)rqbuf;
21421 ucmdbuf->uscsi_rqlen = rqbuflen;
21422 ucmdbuf->uscsi_flags = USCSI_RQENABLE|USCSI_SILENT|USCSI_READ;
21423
21424 status = sd_ssc_send(ssc, ucmdbuf, FKIOCTL,
21425 UIO_SYSSPACE, path_flag);
21426
21427 switch (status) {
21428 case 0:
21429 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
21430 break; /* Success! */
21431 case EIO:
21432 switch (ucmdbuf->uscsi_status) {
21433 case STATUS_RESERVATION_CONFLICT:
21434 status = EACCES;
21435 break;
21436 default:
21437 break;
21438 }
21439 break;
21440 default:
21441 break;
21442 }
21443
21444 if (status == 0) {
21445 SD_DUMP_MEMORY(un, SD_LOG_IO,
21446 "sd_send_scsi_GET_CONFIGURATION: data",
21447 (uchar_t *)bufaddr, SD_PROFILE_HEADER_LEN, SD_LOG_HEX);
21448 }
21449
21450 SD_TRACE(SD_LOG_IO, un,
21451 "sd_send_scsi_GET_CONFIGURATION: exit\n");
21452
21453 return (status);
21454 }
21455
21456 /*
21457 * Function: sd_send_scsi_feature_GET_CONFIGURATION
21458 *
21459 * Description: Issues the get configuration command to the device to
21460 * retrieve a specific feature. Called from
21461 * sd_check_for_writable_cd & sd_set_mmc_caps.
21462 * Arguments: ssc
21463 * ucmdbuf
21464 * rqbuf
21465 * rqbuflen
21466 * bufaddr
21467 * buflen
21468 * feature
21469 *
21470 * Return Code: 0 - Success
21471 * errno return code from sd_ssc_send()
21472 *
21473 * Context: Can sleep. Does not return until command is completed.
21474 *
21475 */
21476 static int
21477 sd_send_scsi_feature_GET_CONFIGURATION(sd_ssc_t *ssc, struct uscsi_cmd *ucmdbuf,
21478 uchar_t *rqbuf, uint_t rqbuflen, uchar_t *bufaddr, uint_t buflen,
21479 char feature, int path_flag)
21480 {
21481 char cdb[CDB_GROUP1];
21482 int status;
21483 struct sd_lun *un;
21484
21485 ASSERT(ssc != NULL);
21486 un = ssc->ssc_un;
21487 ASSERT(un != NULL);
21488 ASSERT(!mutex_owned(SD_MUTEX(un)));
21489 ASSERT(bufaddr != NULL);
21490 ASSERT(ucmdbuf != NULL);
21491 ASSERT(rqbuf != NULL);
21492
21493 SD_TRACE(SD_LOG_IO, un,
21494 "sd_send_scsi_feature_GET_CONFIGURATION: entry: un:0x%p\n", un);
21495
21496 bzero(cdb, sizeof (cdb));
21497 bzero(ucmdbuf, sizeof (struct uscsi_cmd));
21498 bzero(rqbuf, rqbuflen);
21499 bzero(bufaddr, buflen);
21500
21501 /*
21502 * Set up cdb field for the get configuration command.
21503 */
21504 cdb[0] = SCMD_GET_CONFIGURATION;
21505 cdb[1] = 0x02; /* Requested Type */
21506 cdb[3] = feature;
21507 cdb[8] = buflen;
21508 ucmdbuf->uscsi_cdb = cdb;
21509 ucmdbuf->uscsi_cdblen = CDB_GROUP1;
21510 ucmdbuf->uscsi_bufaddr = (caddr_t)bufaddr;
21511 ucmdbuf->uscsi_buflen = buflen;
21512 ucmdbuf->uscsi_timeout = sd_io_time;
21513 ucmdbuf->uscsi_rqbuf = (caddr_t)rqbuf;
21514 ucmdbuf->uscsi_rqlen = rqbuflen;
21515 ucmdbuf->uscsi_flags = USCSI_RQENABLE|USCSI_SILENT|USCSI_READ;
21516
21517 status = sd_ssc_send(ssc, ucmdbuf, FKIOCTL,
21518 UIO_SYSSPACE, path_flag);
21519
21520 switch (status) {
21521 case 0:
21522
21523 break; /* Success! */
21524 case EIO:
21525 switch (ucmdbuf->uscsi_status) {
21526 case STATUS_RESERVATION_CONFLICT:
21527 status = EACCES;
21528 break;
21529 default:
21530 break;
21531 }
21532 break;
21533 default:
21534 break;
21535 }
21536
21537 if (status == 0) {
21538 SD_DUMP_MEMORY(un, SD_LOG_IO,
21539 "sd_send_scsi_feature_GET_CONFIGURATION: data",
21540 (uchar_t *)bufaddr, SD_PROFILE_HEADER_LEN, SD_LOG_HEX);
21541 }
21542
21543 SD_TRACE(SD_LOG_IO, un,
21544 "sd_send_scsi_feature_GET_CONFIGURATION: exit\n");
21545
21546 return (status);
21547 }
21548
21549
21550 /*
21551 * Function: sd_send_scsi_MODE_SENSE
21552 *
21553 * Description: Utility function for issuing a scsi MODE SENSE command.
21554 * Note: This routine uses a consistent implementation for Group0,
21555 * Group1, and Group2 commands across all platforms. ATAPI devices
21556 * use Group 1 Read/Write commands and Group 2 Mode Sense/Select
21557 *
21558 * Arguments: ssc - ssc contains pointer to driver soft state (unit)
21559 * structure for this target.
21560 * cdbsize - size CDB to be used (CDB_GROUP0 (6 byte), or
21561 * CDB_GROUP[1|2] (10 byte).
21562 * bufaddr - buffer for page data retrieved from the target.
21563 * buflen - size of page to be retrieved.
21564 * page_code - page code of data to be retrieved from the target.
21565 * path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and
21566 * the normal command waitq, or SD_PATH_DIRECT_PRIORITY
21567 * to use the USCSI "direct" chain and bypass the normal
21568 * command waitq.
21569 *
21570 * Return Code: 0 - Success
21571 * errno return code from sd_ssc_send()
21572 *
21573 * Context: Can sleep. Does not return until command is completed.
21574 */
21575
21576 static int
21577 sd_send_scsi_MODE_SENSE(sd_ssc_t *ssc, int cdbsize, uchar_t *bufaddr,
21578 size_t buflen, uchar_t page_code, int path_flag)
21579 {
21580 struct scsi_extended_sense sense_buf;
21581 union scsi_cdb cdb;
21582 struct uscsi_cmd ucmd_buf;
21583 int status;
21584 int headlen;
21585 struct sd_lun *un;
21586
21587 ASSERT(ssc != NULL);
21588 un = ssc->ssc_un;
21589 ASSERT(un != NULL);
21590 ASSERT(!mutex_owned(SD_MUTEX(un)));
21591 ASSERT(bufaddr != NULL);
21592 ASSERT((cdbsize == CDB_GROUP0) || (cdbsize == CDB_GROUP1) ||
21593 (cdbsize == CDB_GROUP2));
21594
21595 SD_TRACE(SD_LOG_IO, un,
21596 "sd_send_scsi_MODE_SENSE: entry: un:0x%p\n", un);
21597
21598 bzero(&cdb, sizeof (cdb));
21599 bzero(&ucmd_buf, sizeof (ucmd_buf));
21600 bzero(&sense_buf, sizeof (struct scsi_extended_sense));
21601 bzero(bufaddr, buflen);
21602
21603 if (cdbsize == CDB_GROUP0) {
21604 cdb.scc_cmd = SCMD_MODE_SENSE;
21605 cdb.cdb_opaque[2] = page_code;
21606 FORMG0COUNT(&cdb, buflen);
21607 headlen = MODE_HEADER_LENGTH;
21608 } else {
21609 cdb.scc_cmd = SCMD_MODE_SENSE_G1;
21610 cdb.cdb_opaque[2] = page_code;
21611 FORMG1COUNT(&cdb, buflen);
21612 headlen = MODE_HEADER_LENGTH_GRP2;
21613 }
21614
21615 ASSERT(headlen <= buflen);
21616 SD_FILL_SCSI1_LUN_CDB(un, &cdb);
21617
21618 ucmd_buf.uscsi_cdb = (char *)&cdb;
21619 ucmd_buf.uscsi_cdblen = (uchar_t)cdbsize;
21620 ucmd_buf.uscsi_bufaddr = (caddr_t)bufaddr;
21621 ucmd_buf.uscsi_buflen = buflen;
21622 ucmd_buf.uscsi_rqbuf = (caddr_t)&sense_buf;
21623 ucmd_buf.uscsi_rqlen = sizeof (struct scsi_extended_sense);
21624 ucmd_buf.uscsi_flags = USCSI_RQENABLE | USCSI_READ | USCSI_SILENT;
21625 ucmd_buf.uscsi_timeout = 60;
21626
21627 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
21628 UIO_SYSSPACE, path_flag);
21629
21630 switch (status) {
21631 case 0:
21632 /*
21633 * sr_check_wp() uses 0x3f page code and check the header of
21634 * mode page to determine if target device is write-protected.
21635 * But some USB devices return 0 bytes for 0x3f page code. For
21636 * this case, make sure that mode page header is returned at
21637 * least.
21638 */
21639 if (buflen - ucmd_buf.uscsi_resid < headlen) {
21640 status = EIO;
21641 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, -1,
21642 "mode page header is not returned");
21643 }
21644 break; /* Success! */
21645 case EIO:
21646 switch (ucmd_buf.uscsi_status) {
21647 case STATUS_RESERVATION_CONFLICT:
21648 status = EACCES;
21649 break;
21650 default:
21651 break;
21652 }
21653 break;
21654 default:
21655 break;
21656 }
21657
21658 if (status == 0) {
21659 SD_DUMP_MEMORY(un, SD_LOG_IO, "sd_send_scsi_MODE_SENSE: data",
21660 (uchar_t *)bufaddr, buflen, SD_LOG_HEX);
21661 }
21662 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_MODE_SENSE: exit\n");
21663
21664 return (status);
21665 }
21666
21667
21668 /*
21669 * Function: sd_send_scsi_MODE_SELECT
21670 *
21671 * Description: Utility function for issuing a scsi MODE SELECT command.
21672 * Note: This routine uses a consistent implementation for Group0,
21673 * Group1, and Group2 commands across all platforms. ATAPI devices
21674 * use Group 1 Read/Write commands and Group 2 Mode Sense/Select
21675 *
21676 * Arguments: ssc - ssc contains pointer to driver soft state (unit)
21677 * structure for this target.
21678 * cdbsize - size CDB to be used (CDB_GROUP0 (6 byte), or
21679 * CDB_GROUP[1|2] (10 byte).
21680 * bufaddr - buffer for page data retrieved from the target.
21681 * buflen - size of page to be retrieved.
21682 * save_page - boolean to determin if SP bit should be set.
21683 * path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and
21684 * the normal command waitq, or SD_PATH_DIRECT_PRIORITY
21685 * to use the USCSI "direct" chain and bypass the normal
21686 * command waitq.
21687 *
21688 * Return Code: 0 - Success
21689 * errno return code from sd_ssc_send()
21690 *
21691 * Context: Can sleep. Does not return until command is completed.
21692 */
21693
21694 static int
21695 sd_send_scsi_MODE_SELECT(sd_ssc_t *ssc, int cdbsize, uchar_t *bufaddr,
21696 size_t buflen, uchar_t save_page, int path_flag)
21697 {
21698 struct scsi_extended_sense sense_buf;
21699 union scsi_cdb cdb;
21700 struct uscsi_cmd ucmd_buf;
21701 int status;
21702 struct sd_lun *un;
21703
21704 ASSERT(ssc != NULL);
21705 un = ssc->ssc_un;
21706 ASSERT(un != NULL);
21707 ASSERT(!mutex_owned(SD_MUTEX(un)));
21708 ASSERT(bufaddr != NULL);
21709 ASSERT((cdbsize == CDB_GROUP0) || (cdbsize == CDB_GROUP1) ||
21710 (cdbsize == CDB_GROUP2));
21711
21712 SD_TRACE(SD_LOG_IO, un,
21713 "sd_send_scsi_MODE_SELECT: entry: un:0x%p\n", un);
21714
21715 bzero(&cdb, sizeof (cdb));
21716 bzero(&ucmd_buf, sizeof (ucmd_buf));
21717 bzero(&sense_buf, sizeof (struct scsi_extended_sense));
21718
21719 /* Set the PF bit for many third party drives */
21720 cdb.cdb_opaque[1] = 0x10;
21721
21722 /* Set the savepage(SP) bit if given */
21723 if (save_page == SD_SAVE_PAGE) {
21724 cdb.cdb_opaque[1] |= 0x01;
21725 }
21726
21727 if (cdbsize == CDB_GROUP0) {
21728 cdb.scc_cmd = SCMD_MODE_SELECT;
21729 FORMG0COUNT(&cdb, buflen);
21730 } else {
21731 cdb.scc_cmd = SCMD_MODE_SELECT_G1;
21732 FORMG1COUNT(&cdb, buflen);
21733 }
21734
21735 SD_FILL_SCSI1_LUN_CDB(un, &cdb);
21736
21737 ucmd_buf.uscsi_cdb = (char *)&cdb;
21738 ucmd_buf.uscsi_cdblen = (uchar_t)cdbsize;
21739 ucmd_buf.uscsi_bufaddr = (caddr_t)bufaddr;
21740 ucmd_buf.uscsi_buflen = buflen;
21741 ucmd_buf.uscsi_rqbuf = (caddr_t)&sense_buf;
21742 ucmd_buf.uscsi_rqlen = sizeof (struct scsi_extended_sense);
21743 ucmd_buf.uscsi_flags = USCSI_RQENABLE | USCSI_WRITE | USCSI_SILENT;
21744 ucmd_buf.uscsi_timeout = 60;
21745
21746 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
21747 UIO_SYSSPACE, path_flag);
21748
21749 switch (status) {
21750 case 0:
21751 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
21752 break; /* Success! */
21753 case EIO:
21754 switch (ucmd_buf.uscsi_status) {
21755 case STATUS_RESERVATION_CONFLICT:
21756 status = EACCES;
21757 break;
21758 default:
21759 break;
21760 }
21761 break;
21762 default:
21763 break;
21764 }
21765
21766 if (status == 0) {
21767 SD_DUMP_MEMORY(un, SD_LOG_IO, "sd_send_scsi_MODE_SELECT: data",
21768 (uchar_t *)bufaddr, buflen, SD_LOG_HEX);
21769 }
21770 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_MODE_SELECT: exit\n");
21771
21772 return (status);
21773 }
21774
21775
21776 /*
21777 * Function: sd_send_scsi_RDWR
21778 *
21779 * Description: Issue a scsi READ or WRITE command with the given parameters.
21780 *
21781 * Arguments: ssc - ssc contains pointer to driver soft state (unit)
21782 * structure for this target.
21783 * cmd: SCMD_READ or SCMD_WRITE
21784 * bufaddr: Address of caller's buffer to receive the RDWR data
21785 * buflen: Length of caller's buffer receive the RDWR data.
21786 * start_block: Block number for the start of the RDWR operation.
21787 * (Assumes target-native block size.)
21788 * residp: Pointer to variable to receive the redisual of the
21789 * RDWR operation (may be NULL of no residual requested).
21790 * path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and
21791 * the normal command waitq, or SD_PATH_DIRECT_PRIORITY
21792 * to use the USCSI "direct" chain and bypass the normal
21793 * command waitq.
21794 *
21795 * Return Code: 0 - Success
21796 * errno return code from sd_ssc_send()
21797 *
21798 * Context: Can sleep. Does not return until command is completed.
21799 */
21800
21801 static int
21802 sd_send_scsi_RDWR(sd_ssc_t *ssc, uchar_t cmd, void *bufaddr,
21803 size_t buflen, daddr_t start_block, int path_flag)
21804 {
21805 struct scsi_extended_sense sense_buf;
21806 union scsi_cdb cdb;
21807 struct uscsi_cmd ucmd_buf;
21808 uint32_t block_count;
21809 int status;
21810 int cdbsize;
21811 uchar_t flag;
21812 struct sd_lun *un;
21813
21814 ASSERT(ssc != NULL);
21815 un = ssc->ssc_un;
21816 ASSERT(un != NULL);
21817 ASSERT(!mutex_owned(SD_MUTEX(un)));
21818 ASSERT(bufaddr != NULL);
21819 ASSERT((cmd == SCMD_READ) || (cmd == SCMD_WRITE));
21820
21821 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_RDWR: entry: un:0x%p\n", un);
21822
21823 if (un->un_f_tgt_blocksize_is_valid != TRUE) {
21824 return (EINVAL);
21825 }
21826
21827 mutex_enter(SD_MUTEX(un));
21828 block_count = SD_BYTES2TGTBLOCKS(un, buflen);
21829 mutex_exit(SD_MUTEX(un));
21830
21831 flag = (cmd == SCMD_READ) ? USCSI_READ : USCSI_WRITE;
21832
21833 SD_INFO(SD_LOG_IO, un, "sd_send_scsi_RDWR: "
21834 "bufaddr:0x%p buflen:0x%x start_block:0x%p block_count:0x%x\n",
21835 bufaddr, buflen, start_block, block_count);
21836
21837 bzero(&cdb, sizeof (cdb));
21838 bzero(&ucmd_buf, sizeof (ucmd_buf));
21839 bzero(&sense_buf, sizeof (struct scsi_extended_sense));
21840
21841 /* Compute CDB size to use */
21842 if (start_block > 0xffffffff)
21843 cdbsize = CDB_GROUP4;
21844 else if ((start_block & 0xFFE00000) ||
21845 (un->un_f_cfg_is_atapi == TRUE))
21846 cdbsize = CDB_GROUP1;
21847 else
21848 cdbsize = CDB_GROUP0;
21849
21850 switch (cdbsize) {
21851 case CDB_GROUP0: /* 6-byte CDBs */
21852 cdb.scc_cmd = cmd;
21853 FORMG0ADDR(&cdb, start_block);
21854 FORMG0COUNT(&cdb, block_count);
21855 break;
21856 case CDB_GROUP1: /* 10-byte CDBs */
21857 cdb.scc_cmd = cmd | SCMD_GROUP1;
21858 FORMG1ADDR(&cdb, start_block);
21859 FORMG1COUNT(&cdb, block_count);
21860 break;
21861 case CDB_GROUP4: /* 16-byte CDBs */
21862 cdb.scc_cmd = cmd | SCMD_GROUP4;
21863 FORMG4LONGADDR(&cdb, (uint64_t)start_block);
21864 FORMG4COUNT(&cdb, block_count);
21865 break;
21866 case CDB_GROUP5: /* 12-byte CDBs (currently unsupported) */
21867 default:
21868 /* All others reserved */
21869 return (EINVAL);
21870 }
21871
21872 /* Set LUN bit(s) in CDB if this is a SCSI-1 device */
21873 SD_FILL_SCSI1_LUN_CDB(un, &cdb);
21874
21875 ucmd_buf.uscsi_cdb = (char *)&cdb;
21876 ucmd_buf.uscsi_cdblen = (uchar_t)cdbsize;
21877 ucmd_buf.uscsi_bufaddr = bufaddr;
21878 ucmd_buf.uscsi_buflen = buflen;
21879 ucmd_buf.uscsi_rqbuf = (caddr_t)&sense_buf;
21880 ucmd_buf.uscsi_rqlen = sizeof (struct scsi_extended_sense);
21881 ucmd_buf.uscsi_flags = flag | USCSI_RQENABLE | USCSI_SILENT;
21882 ucmd_buf.uscsi_timeout = 60;
21883 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
21884 UIO_SYSSPACE, path_flag);
21885
21886 switch (status) {
21887 case 0:
21888 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
21889 break; /* Success! */
21890 case EIO:
21891 switch (ucmd_buf.uscsi_status) {
21892 case STATUS_RESERVATION_CONFLICT:
21893 status = EACCES;
21894 break;
21895 default:
21896 break;
21897 }
21898 break;
21899 default:
21900 break;
21901 }
21902
21903 if (status == 0) {
21904 SD_DUMP_MEMORY(un, SD_LOG_IO, "sd_send_scsi_RDWR: data",
21905 (uchar_t *)bufaddr, buflen, SD_LOG_HEX);
21906 }
21907
21908 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_RDWR: exit\n");
21909
21910 return (status);
21911 }
21912
21913
21914 /*
21915 * Function: sd_send_scsi_LOG_SENSE
21916 *
21917 * Description: Issue a scsi LOG_SENSE command with the given parameters.
21918 *
21919 * Arguments: ssc - ssc contains pointer to driver soft state (unit)
21920 * structure for this target.
21921 *
21922 * Return Code: 0 - Success
21923 * errno return code from sd_ssc_send()
21924 *
21925 * Context: Can sleep. Does not return until command is completed.
21926 */
21927
21928 static int
21929 sd_send_scsi_LOG_SENSE(sd_ssc_t *ssc, uchar_t *bufaddr, uint16_t buflen,
21930 uchar_t page_code, uchar_t page_control, uint16_t param_ptr, int path_flag)
21931 {
21932 struct scsi_extended_sense sense_buf;
21933 union scsi_cdb cdb;
21934 struct uscsi_cmd ucmd_buf;
21935 int status;
21936 struct sd_lun *un;
21937
21938 ASSERT(ssc != NULL);
21939 un = ssc->ssc_un;
21940 ASSERT(un != NULL);
21941 ASSERT(!mutex_owned(SD_MUTEX(un)));
21942
21943 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_LOG_SENSE: entry: un:0x%p\n", un);
21944
21945 bzero(&cdb, sizeof (cdb));
21946 bzero(&ucmd_buf, sizeof (ucmd_buf));
21947 bzero(&sense_buf, sizeof (struct scsi_extended_sense));
21948
21949 cdb.scc_cmd = SCMD_LOG_SENSE_G1;
21950 cdb.cdb_opaque[2] = (page_control << 6) | page_code;
21951 cdb.cdb_opaque[5] = (uchar_t)((param_ptr & 0xFF00) >> 8);
21952 cdb.cdb_opaque[6] = (uchar_t)(param_ptr & 0x00FF);
21953 FORMG1COUNT(&cdb, buflen);
21954
21955 ucmd_buf.uscsi_cdb = (char *)&cdb;
21956 ucmd_buf.uscsi_cdblen = CDB_GROUP1;
21957 ucmd_buf.uscsi_bufaddr = (caddr_t)bufaddr;
21958 ucmd_buf.uscsi_buflen = buflen;
21959 ucmd_buf.uscsi_rqbuf = (caddr_t)&sense_buf;
21960 ucmd_buf.uscsi_rqlen = sizeof (struct scsi_extended_sense);
21961 ucmd_buf.uscsi_flags = USCSI_RQENABLE | USCSI_READ | USCSI_SILENT;
21962 ucmd_buf.uscsi_timeout = 60;
21963
21964 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
21965 UIO_SYSSPACE, path_flag);
21966
21967 switch (status) {
21968 case 0:
21969 break;
21970 case EIO:
21971 switch (ucmd_buf.uscsi_status) {
21972 case STATUS_RESERVATION_CONFLICT:
21973 status = EACCES;
21974 break;
21975 case STATUS_CHECK:
21976 if ((ucmd_buf.uscsi_rqstatus == STATUS_GOOD) &&
21977 (scsi_sense_key((uint8_t *)&sense_buf) ==
21978 KEY_ILLEGAL_REQUEST) &&
21979 (scsi_sense_asc((uint8_t *)&sense_buf) == 0x24)) {
21980 /*
21981 * ASC 0x24: INVALID FIELD IN CDB
21982 */
21983 switch (page_code) {
21984 case START_STOP_CYCLE_PAGE:
21985 /*
21986 * The start stop cycle counter is
21987 * implemented as page 0x31 in earlier
21988 * generation disks. In new generation
21989 * disks the start stop cycle counter is
21990 * implemented as page 0xE. To properly
21991 * handle this case if an attempt for
21992 * log page 0xE is made and fails we
21993 * will try again using page 0x31.
21994 *
21995 * Network storage BU committed to
21996 * maintain the page 0x31 for this
21997 * purpose and will not have any other
21998 * page implemented with page code 0x31
21999 * until all disks transition to the
22000 * standard page.
22001 */
22002 mutex_enter(SD_MUTEX(un));
22003 un->un_start_stop_cycle_page =
22004 START_STOP_CYCLE_VU_PAGE;
22005 cdb.cdb_opaque[2] =
22006 (char)(page_control << 6) |
22007 un->un_start_stop_cycle_page;
22008 mutex_exit(SD_MUTEX(un));
22009 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
22010 status = sd_ssc_send(
22011 ssc, &ucmd_buf, FKIOCTL,
22012 UIO_SYSSPACE, path_flag);
22013
22014 break;
22015 case TEMPERATURE_PAGE:
22016 status = ENOTTY;
22017 break;
22018 default:
22019 break;
22020 }
22021 }
22022 break;
22023 default:
22024 break;
22025 }
22026 break;
22027 default:
22028 break;
22029 }
22030
22031 if (status == 0) {
22032 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
22033 SD_DUMP_MEMORY(un, SD_LOG_IO, "sd_send_scsi_LOG_SENSE: data",
22034 (uchar_t *)bufaddr, buflen, SD_LOG_HEX);
22035 }
22036
22037 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_LOG_SENSE: exit\n");
22038
22039 return (status);
22040 }
22041
22042
22043 /*
22044 * Function: sd_send_scsi_GET_EVENT_STATUS_NOTIFICATION
22045 *
22046 * Description: Issue the scsi GET EVENT STATUS NOTIFICATION command.
22047 *
22048 * Arguments: ssc - ssc contains pointer to driver soft state (unit)
22049 * structure for this target.
22050 * bufaddr
22051 * buflen
22052 * class_req
22053 *
22054 * Return Code: 0 - Success
22055 * errno return code from sd_ssc_send()
22056 *
22057 * Context: Can sleep. Does not return until command is completed.
22058 */
22059
22060 static int
22061 sd_send_scsi_GET_EVENT_STATUS_NOTIFICATION(sd_ssc_t *ssc, uchar_t *bufaddr,
22062 size_t buflen, uchar_t class_req)
22063 {
22064 union scsi_cdb cdb;
22065 struct uscsi_cmd ucmd_buf;
22066 int status;
22067 struct sd_lun *un;
22068
22069 ASSERT(ssc != NULL);
22070 un = ssc->ssc_un;
22071 ASSERT(un != NULL);
22072 ASSERT(!mutex_owned(SD_MUTEX(un)));
22073 ASSERT(bufaddr != NULL);
22074
22075 SD_TRACE(SD_LOG_IO, un,
22076 "sd_send_scsi_GET_EVENT_STATUS_NOTIFICATION: entry: un:0x%p\n", un);
22077
22078 bzero(&cdb, sizeof (cdb));
22079 bzero(&ucmd_buf, sizeof (ucmd_buf));
22080 bzero(bufaddr, buflen);
22081
22082 cdb.scc_cmd = SCMD_GET_EVENT_STATUS_NOTIFICATION;
22083 cdb.cdb_opaque[1] = 1; /* polled */
22084 cdb.cdb_opaque[4] = class_req;
22085 FORMG1COUNT(&cdb, buflen);
22086
22087 ucmd_buf.uscsi_cdb = (char *)&cdb;
22088 ucmd_buf.uscsi_cdblen = CDB_GROUP1;
22089 ucmd_buf.uscsi_bufaddr = (caddr_t)bufaddr;
22090 ucmd_buf.uscsi_buflen = buflen;
22091 ucmd_buf.uscsi_rqbuf = NULL;
22092 ucmd_buf.uscsi_rqlen = 0;
22093 ucmd_buf.uscsi_flags = USCSI_READ | USCSI_SILENT;
22094 ucmd_buf.uscsi_timeout = 60;
22095
22096 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
22097 UIO_SYSSPACE, SD_PATH_DIRECT);
22098
22099 /*
22100 * Only handle status == 0, the upper-level caller
22101 * will put different assessment based on the context.
22102 */
22103 if (status == 0) {
22104 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
22105
22106 if (ucmd_buf.uscsi_resid != 0) {
22107 status = EIO;
22108 }
22109 }
22110
22111 SD_TRACE(SD_LOG_IO, un,
22112 "sd_send_scsi_GET_EVENT_STATUS_NOTIFICATION: exit\n");
22113
22114 return (status);
22115 }
22116
22117
22118 static boolean_t
22119 sd_gesn_media_data_valid(uchar_t *data)
22120 {
22121 uint16_t len;
22122
22123 len = (data[1] << 8) | data[0];
22124 return ((len >= 6) &&
22125 ((data[2] & SD_GESN_HEADER_NEA) == 0) &&
22126 ((data[2] & SD_GESN_HEADER_CLASS) == SD_GESN_MEDIA_CLASS) &&
22127 ((data[3] & (1 << SD_GESN_MEDIA_CLASS)) != 0));
22128 }
22129
22130
22131 /*
22132 * Function: sdioctl
22133 *
22134 * Description: Driver's ioctl(9e) entry point function.
22135 *
22136 * Arguments: dev - device number
22137 * cmd - ioctl operation to be performed
22138 * arg - user argument, contains data to be set or reference
22139 * parameter for get
22140 * flag - bit flag, indicating open settings, 32/64 bit type
22141 * cred_p - user credential pointer
22142 * rval_p - calling process return value (OPT)
22143 *
22144 * Return Code: EINVAL
22145 * ENOTTY
22146 * ENXIO
22147 * EIO
22148 * EFAULT
22149 * ENOTSUP
22150 * EPERM
22151 *
22152 * Context: Called from the device switch at normal priority.
22153 */
22154
22155 static int
22156 sdioctl(dev_t dev, int cmd, intptr_t arg, int flag, cred_t *cred_p, int *rval_p)
22157 {
22158 struct sd_lun *un = NULL;
22159 int err = 0;
22160 int i = 0;
22161 cred_t *cr;
22162 int tmprval = EINVAL;
22163 boolean_t is_valid;
22164 sd_ssc_t *ssc;
22165
22166 /*
22167 * All device accesses go thru sdstrategy where we check on suspend
22168 * status
22169 */
22170 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
22171 return (ENXIO);
22172 }
22173
22174 ASSERT(!mutex_owned(SD_MUTEX(un)));
22175
22176 /* Initialize sd_ssc_t for internal uscsi commands */
22177 ssc = sd_ssc_init(un);
22178
22179 is_valid = SD_IS_VALID_LABEL(un);
22180
22181 /*
22182 * Moved this wait from sd_uscsi_strategy to here for
22183 * reasons of deadlock prevention. Internal driver commands,
22184 * specifically those to change a devices power level, result
22185 * in a call to sd_uscsi_strategy.
22186 */
22187 mutex_enter(SD_MUTEX(un));
22188 while ((un->un_state == SD_STATE_SUSPENDED) ||
22189 (un->un_state == SD_STATE_PM_CHANGING)) {
22190 cv_wait(&un->un_suspend_cv, SD_MUTEX(un));
22191 }
22192 /*
22193 * Twiddling the counter here protects commands from now
22194 * through to the top of sd_uscsi_strategy. Without the
22195 * counter inc. a power down, for example, could get in
22196 * after the above check for state is made and before
22197 * execution gets to the top of sd_uscsi_strategy.
22198 * That would cause problems.
22199 */
22200 un->un_ncmds_in_driver++;
22201
22202 if (!is_valid &&
22203 (flag & (FNDELAY | FNONBLOCK))) {
22204 switch (cmd) {
22205 case DKIOCGGEOM: /* SD_PATH_DIRECT */
22206 case DKIOCGVTOC:
22207 case DKIOCGEXTVTOC:
22208 case DKIOCGAPART:
22209 case DKIOCPARTINFO:
22210 case DKIOCEXTPARTINFO:
22211 case DKIOCSGEOM:
22212 case DKIOCSAPART:
22213 case DKIOCGETEFI:
22214 case DKIOCPARTITION:
22215 case DKIOCSVTOC:
22216 case DKIOCSEXTVTOC:
22217 case DKIOCSETEFI:
22218 case DKIOCGMBOOT:
22219 case DKIOCSMBOOT:
22220 case DKIOCG_PHYGEOM:
22221 case DKIOCG_VIRTGEOM:
22222 #if defined(__i386) || defined(__amd64)
22223 case DKIOCSETEXTPART:
22224 #endif
22225 /* let cmlb handle it */
22226 goto skip_ready_valid;
22227
22228 case CDROMPAUSE:
22229 case CDROMRESUME:
22230 case CDROMPLAYMSF:
22231 case CDROMPLAYTRKIND:
22232 case CDROMREADTOCHDR:
22233 case CDROMREADTOCENTRY:
22234 case CDROMSTOP:
22235 case CDROMSTART:
22236 case CDROMVOLCTRL:
22237 case CDROMSUBCHNL:
22238 case CDROMREADMODE2:
22239 case CDROMREADMODE1:
22240 case CDROMREADOFFSET:
22241 case CDROMSBLKMODE:
22242 case CDROMGBLKMODE:
22243 case CDROMGDRVSPEED:
22244 case CDROMSDRVSPEED:
22245 case CDROMCDDA:
22246 case CDROMCDXA:
22247 case CDROMSUBCODE:
22248 if (!ISCD(un)) {
22249 un->un_ncmds_in_driver--;
22250 ASSERT(un->un_ncmds_in_driver >= 0);
22251 mutex_exit(SD_MUTEX(un));
22252 err = ENOTTY;
22253 goto done_without_assess;
22254 }
22255 break;
22256 case FDEJECT:
22257 case DKIOCEJECT:
22258 case CDROMEJECT:
22259 if (!un->un_f_eject_media_supported) {
22260 un->un_ncmds_in_driver--;
22261 ASSERT(un->un_ncmds_in_driver >= 0);
22262 mutex_exit(SD_MUTEX(un));
22263 err = ENOTTY;
22264 goto done_without_assess;
22265 }
22266 break;
22267 case DKIOCFLUSHWRITECACHE:
22268 mutex_exit(SD_MUTEX(un));
22269 err = sd_send_scsi_TEST_UNIT_READY(ssc, 0);
22270 if (err != 0) {
22271 mutex_enter(SD_MUTEX(un));
22272 un->un_ncmds_in_driver--;
22273 ASSERT(un->un_ncmds_in_driver >= 0);
22274 mutex_exit(SD_MUTEX(un));
22275 err = EIO;
22276 goto done_quick_assess;
22277 }
22278 mutex_enter(SD_MUTEX(un));
22279 /* FALLTHROUGH */
22280 case DKIOCREMOVABLE:
22281 case DKIOCHOTPLUGGABLE:
22282 case DKIOCINFO:
22283 case DKIOCGMEDIAINFO:
22284 case DKIOCGMEDIAINFOEXT:
22285 case DKIOCSOLIDSTATE:
22286 case MHIOCENFAILFAST:
22287 case MHIOCSTATUS:
22288 case MHIOCTKOWN:
22289 case MHIOCRELEASE:
22290 case MHIOCGRP_INKEYS:
22291 case MHIOCGRP_INRESV:
22292 case MHIOCGRP_REGISTER:
22293 case MHIOCGRP_CLEAR:
22294 case MHIOCGRP_RESERVE:
22295 case MHIOCGRP_PREEMPTANDABORT:
22296 case MHIOCGRP_REGISTERANDIGNOREKEY:
22297 case CDROMCLOSETRAY:
22298 case USCSICMD:
22299 goto skip_ready_valid;
22300 default:
22301 break;
22302 }
22303
22304 mutex_exit(SD_MUTEX(un));
22305 err = sd_ready_and_valid(ssc, SDPART(dev));
22306 mutex_enter(SD_MUTEX(un));
22307
22308 if (err != SD_READY_VALID) {
22309 switch (cmd) {
22310 case DKIOCSTATE:
22311 case CDROMGDRVSPEED:
22312 case CDROMSDRVSPEED:
22313 case FDEJECT: /* for eject command */
22314 case DKIOCEJECT:
22315 case CDROMEJECT:
22316 case DKIOCREMOVABLE:
22317 case DKIOCHOTPLUGGABLE:
22318 break;
22319 default:
22320 if (un->un_f_has_removable_media) {
22321 err = ENXIO;
22322 } else {
22323 /* Do not map SD_RESERVED_BY_OTHERS to EIO */
22324 if (err == SD_RESERVED_BY_OTHERS) {
22325 err = EACCES;
22326 } else {
22327 err = EIO;
22328 }
22329 }
22330 un->un_ncmds_in_driver--;
22331 ASSERT(un->un_ncmds_in_driver >= 0);
22332 mutex_exit(SD_MUTEX(un));
22333
22334 goto done_without_assess;
22335 }
22336 }
22337 }
22338
22339 skip_ready_valid:
22340 mutex_exit(SD_MUTEX(un));
22341
22342 switch (cmd) {
22343 case DKIOCINFO:
22344 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCINFO\n");
22345 err = sd_dkio_ctrl_info(dev, (caddr_t)arg, flag);
22346 break;
22347
22348 case DKIOCGMEDIAINFO:
22349 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCGMEDIAINFO\n");
22350 err = sd_get_media_info(dev, (caddr_t)arg, flag);
22351 break;
22352
22353 case DKIOCGMEDIAINFOEXT:
22354 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCGMEDIAINFOEXT\n");
22355 err = sd_get_media_info_ext(dev, (caddr_t)arg, flag);
22356 break;
22357
22358 case DKIOCGGEOM:
22359 case DKIOCGVTOC:
22360 case DKIOCGEXTVTOC:
22361 case DKIOCGAPART:
22362 case DKIOCPARTINFO:
22363 case DKIOCEXTPARTINFO:
22364 case DKIOCSGEOM:
22365 case DKIOCSAPART:
22366 case DKIOCGETEFI:
22367 case DKIOCPARTITION:
22368 case DKIOCSVTOC:
22369 case DKIOCSEXTVTOC:
22370 case DKIOCSETEFI:
22371 case DKIOCGMBOOT:
22372 case DKIOCSMBOOT:
22373 case DKIOCG_PHYGEOM:
22374 case DKIOCG_VIRTGEOM:
22375 #if defined(__i386) || defined(__amd64)
22376 case DKIOCSETEXTPART:
22377 #endif
22378 SD_TRACE(SD_LOG_IOCTL, un, "DKIOC %d\n", cmd);
22379
22380 /* TUR should spin up */
22381
22382 if (un->un_f_has_removable_media)
22383 err = sd_send_scsi_TEST_UNIT_READY(ssc,
22384 SD_CHECK_FOR_MEDIA);
22385
22386 else
22387 err = sd_send_scsi_TEST_UNIT_READY(ssc, 0);
22388
22389 if (err != 0)
22390 goto done_with_assess;
22391
22392 err = cmlb_ioctl(un->un_cmlbhandle, dev,
22393 cmd, arg, flag, cred_p, rval_p, (void *)SD_PATH_DIRECT);
22394
22395 if ((err == 0) &&
22396 ((cmd == DKIOCSETEFI) ||
22397 ((un->un_f_pkstats_enabled) &&
22398 (cmd == DKIOCSAPART || cmd == DKIOCSVTOC ||
22399 cmd == DKIOCSEXTVTOC)))) {
22400
22401 tmprval = cmlb_validate(un->un_cmlbhandle, CMLB_SILENT,
22402 (void *)SD_PATH_DIRECT);
22403 if ((tmprval == 0) && un->un_f_pkstats_enabled) {
22404 sd_set_pstats(un);
22405 SD_TRACE(SD_LOG_IO_PARTITION, un,
22406 "sd_ioctl: un:0x%p pstats created and "
22407 "set\n", un);
22408 }
22409 }
22410
22411 if ((cmd == DKIOCSVTOC || cmd == DKIOCSEXTVTOC) ||
22412 ((cmd == DKIOCSETEFI) && (tmprval == 0))) {
22413
22414 mutex_enter(SD_MUTEX(un));
22415 if (un->un_f_devid_supported &&
22416 (un->un_f_opt_fab_devid == TRUE)) {
22417 if (un->un_devid == NULL) {
22418 sd_register_devid(ssc, SD_DEVINFO(un),
22419 SD_TARGET_IS_UNRESERVED);
22420 } else {
22421 /*
22422 * The device id for this disk
22423 * has been fabricated. The
22424 * device id must be preserved
22425 * by writing it back out to
22426 * disk.
22427 */
22428 if (sd_write_deviceid(ssc) != 0) {
22429 ddi_devid_free(un->un_devid);
22430 un->un_devid = NULL;
22431 }
22432 }
22433 }
22434 mutex_exit(SD_MUTEX(un));
22435 }
22436
22437 break;
22438
22439 case DKIOCLOCK:
22440 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCLOCK\n");
22441 err = sd_send_scsi_DOORLOCK(ssc, SD_REMOVAL_PREVENT,
22442 SD_PATH_STANDARD);
22443 goto done_with_assess;
22444
22445 case DKIOCUNLOCK:
22446 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCUNLOCK\n");
22447 err = sd_send_scsi_DOORLOCK(ssc, SD_REMOVAL_ALLOW,
22448 SD_PATH_STANDARD);
22449 goto done_with_assess;
22450
22451 case DKIOCSTATE: {
22452 enum dkio_state state;
22453 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCSTATE\n");
22454
22455 if (ddi_copyin((void *)arg, &state, sizeof (int), flag) != 0) {
22456 err = EFAULT;
22457 } else {
22458 err = sd_check_media(dev, state);
22459 if (err == 0) {
22460 if (ddi_copyout(&un->un_mediastate, (void *)arg,
22461 sizeof (int), flag) != 0)
22462 err = EFAULT;
22463 }
22464 }
22465 break;
22466 }
22467
22468 case DKIOCREMOVABLE:
22469 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCREMOVABLE\n");
22470 i = un->un_f_has_removable_media ? 1 : 0;
22471 if (ddi_copyout(&i, (void *)arg, sizeof (int), flag) != 0) {
22472 err = EFAULT;
22473 } else {
22474 err = 0;
22475 }
22476 break;
22477
22478 case DKIOCSOLIDSTATE:
22479 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCSOLIDSTATE\n");
22480 i = un->un_f_is_solid_state ? 1 : 0;
22481 if (ddi_copyout(&i, (void *)arg, sizeof (int), flag) != 0) {
22482 err = EFAULT;
22483 } else {
22484 err = 0;
22485 }
22486 break;
22487
22488 case DKIOCHOTPLUGGABLE:
22489 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCHOTPLUGGABLE\n");
22490 i = un->un_f_is_hotpluggable ? 1 : 0;
22491 if (ddi_copyout(&i, (void *)arg, sizeof (int), flag) != 0) {
22492 err = EFAULT;
22493 } else {
22494 err = 0;
22495 }
22496 break;
22497
22498 case DKIOCREADONLY:
22499 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCREADONLY\n");
22500 i = 0;
22501 if ((ISCD(un) && !un->un_f_mmc_writable_media) ||
22502 (sr_check_wp(dev) != 0)) {
22503 i = 1;
22504 }
22505 if (ddi_copyout(&i, (void *)arg, sizeof (int), flag) != 0) {
22506 err = EFAULT;
22507 } else {
22508 err = 0;
22509 }
22510 break;
22511
22512 case DKIOCGTEMPERATURE:
22513 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCGTEMPERATURE\n");
22514 err = sd_dkio_get_temp(dev, (caddr_t)arg, flag);
22515 break;
22516
22517 case MHIOCENFAILFAST:
22518 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCENFAILFAST\n");
22519 if ((err = drv_priv(cred_p)) == 0) {
22520 err = sd_mhdioc_failfast(dev, (caddr_t)arg, flag);
22521 }
22522 break;
22523
22524 case MHIOCTKOWN:
22525 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCTKOWN\n");
22526 if ((err = drv_priv(cred_p)) == 0) {
22527 err = sd_mhdioc_takeown(dev, (caddr_t)arg, flag);
22528 }
22529 break;
22530
22531 case MHIOCRELEASE:
22532 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCRELEASE\n");
22533 if ((err = drv_priv(cred_p)) == 0) {
22534 err = sd_mhdioc_release(dev);
22535 }
22536 break;
22537
22538 case MHIOCSTATUS:
22539 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCSTATUS\n");
22540 if ((err = drv_priv(cred_p)) == 0) {
22541 switch (sd_send_scsi_TEST_UNIT_READY(ssc, 0)) {
22542 case 0:
22543 err = 0;
22544 break;
22545 case EACCES:
22546 *rval_p = 1;
22547 err = 0;
22548 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
22549 break;
22550 default:
22551 err = EIO;
22552 goto done_with_assess;
22553 }
22554 }
22555 break;
22556
22557 case MHIOCQRESERVE:
22558 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCQRESERVE\n");
22559 if ((err = drv_priv(cred_p)) == 0) {
22560 err = sd_reserve_release(dev, SD_RESERVE);
22561 }
22562 break;
22563
22564 case MHIOCREREGISTERDEVID:
22565 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCREREGISTERDEVID\n");
22566 if (drv_priv(cred_p) == EPERM) {
22567 err = EPERM;
22568 } else if (!un->un_f_devid_supported) {
22569 err = ENOTTY;
22570 } else {
22571 err = sd_mhdioc_register_devid(dev);
22572 }
22573 break;
22574
22575 case MHIOCGRP_INKEYS:
22576 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCGRP_INKEYS\n");
22577 if (((err = drv_priv(cred_p)) != EPERM) && arg != NULL) {
22578 if (un->un_reservation_type == SD_SCSI2_RESERVATION) {
22579 err = ENOTSUP;
22580 } else {
22581 err = sd_mhdioc_inkeys(dev, (caddr_t)arg,
22582 flag);
22583 }
22584 }
22585 break;
22586
22587 case MHIOCGRP_INRESV:
22588 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCGRP_INRESV\n");
22589 if (((err = drv_priv(cred_p)) != EPERM) && arg != NULL) {
22590 if (un->un_reservation_type == SD_SCSI2_RESERVATION) {
22591 err = ENOTSUP;
22592 } else {
22593 err = sd_mhdioc_inresv(dev, (caddr_t)arg, flag);
22594 }
22595 }
22596 break;
22597
22598 case MHIOCGRP_REGISTER:
22599 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCGRP_REGISTER\n");
22600 if ((err = drv_priv(cred_p)) != EPERM) {
22601 if (un->un_reservation_type == SD_SCSI2_RESERVATION) {
22602 err = ENOTSUP;
22603 } else if (arg != NULL) {
22604 mhioc_register_t reg;
22605 if (ddi_copyin((void *)arg, ®,
22606 sizeof (mhioc_register_t), flag) != 0) {
22607 err = EFAULT;
22608 } else {
22609 err =
22610 sd_send_scsi_PERSISTENT_RESERVE_OUT(
22611 ssc, SD_SCSI3_REGISTER,
22612 (uchar_t *)®);
22613 if (err != 0)
22614 goto done_with_assess;
22615 }
22616 }
22617 }
22618 break;
22619
22620 case MHIOCGRP_CLEAR:
22621 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCGRP_CLEAR\n");
22622 if ((err = drv_priv(cred_p)) != EPERM) {
22623 if (un->un_reservation_type == SD_SCSI2_RESERVATION) {
22624 err = ENOTSUP;
22625 } else if (arg != NULL) {
22626 mhioc_register_t reg;
22627 if (ddi_copyin((void *)arg, ®,
22628 sizeof (mhioc_register_t), flag) != 0) {
22629 err = EFAULT;
22630 } else {
22631 err =
22632 sd_send_scsi_PERSISTENT_RESERVE_OUT(
22633 ssc, SD_SCSI3_CLEAR,
22634 (uchar_t *)®);
22635 if (err != 0)
22636 goto done_with_assess;
22637 }
22638 }
22639 }
22640 break;
22641
22642 case MHIOCGRP_RESERVE:
22643 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCGRP_RESERVE\n");
22644 if ((err = drv_priv(cred_p)) != EPERM) {
22645 if (un->un_reservation_type == SD_SCSI2_RESERVATION) {
22646 err = ENOTSUP;
22647 } else if (arg != NULL) {
22648 mhioc_resv_desc_t resv_desc;
22649 if (ddi_copyin((void *)arg, &resv_desc,
22650 sizeof (mhioc_resv_desc_t), flag) != 0) {
22651 err = EFAULT;
22652 } else {
22653 err =
22654 sd_send_scsi_PERSISTENT_RESERVE_OUT(
22655 ssc, SD_SCSI3_RESERVE,
22656 (uchar_t *)&resv_desc);
22657 if (err != 0)
22658 goto done_with_assess;
22659 }
22660 }
22661 }
22662 break;
22663
22664 case MHIOCGRP_PREEMPTANDABORT:
22665 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCGRP_PREEMPTANDABORT\n");
22666 if ((err = drv_priv(cred_p)) != EPERM) {
22667 if (un->un_reservation_type == SD_SCSI2_RESERVATION) {
22668 err = ENOTSUP;
22669 } else if (arg != NULL) {
22670 mhioc_preemptandabort_t preempt_abort;
22671 if (ddi_copyin((void *)arg, &preempt_abort,
22672 sizeof (mhioc_preemptandabort_t),
22673 flag) != 0) {
22674 err = EFAULT;
22675 } else {
22676 err =
22677 sd_send_scsi_PERSISTENT_RESERVE_OUT(
22678 ssc, SD_SCSI3_PREEMPTANDABORT,
22679 (uchar_t *)&preempt_abort);
22680 if (err != 0)
22681 goto done_with_assess;
22682 }
22683 }
22684 }
22685 break;
22686
22687 case MHIOCGRP_REGISTERANDIGNOREKEY:
22688 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCGRP_REGISTERANDIGNOREKEY\n");
22689 if ((err = drv_priv(cred_p)) != EPERM) {
22690 if (un->un_reservation_type == SD_SCSI2_RESERVATION) {
22691 err = ENOTSUP;
22692 } else if (arg != NULL) {
22693 mhioc_registerandignorekey_t r_and_i;
22694 if (ddi_copyin((void *)arg, (void *)&r_and_i,
22695 sizeof (mhioc_registerandignorekey_t),
22696 flag) != 0) {
22697 err = EFAULT;
22698 } else {
22699 err =
22700 sd_send_scsi_PERSISTENT_RESERVE_OUT(
22701 ssc, SD_SCSI3_REGISTERANDIGNOREKEY,
22702 (uchar_t *)&r_and_i);
22703 if (err != 0)
22704 goto done_with_assess;
22705 }
22706 }
22707 }
22708 break;
22709
22710 case USCSICMD:
22711 SD_TRACE(SD_LOG_IOCTL, un, "USCSICMD\n");
22712 cr = ddi_get_cred();
22713 if ((drv_priv(cred_p) != 0) && (drv_priv(cr) != 0)) {
22714 err = EPERM;
22715 } else {
22716 enum uio_seg uioseg;
22717
22718 uioseg = (flag & FKIOCTL) ? UIO_SYSSPACE :
22719 UIO_USERSPACE;
22720 if (un->un_f_format_in_progress == TRUE) {
22721 err = EAGAIN;
22722 break;
22723 }
22724
22725 err = sd_ssc_send(ssc,
22726 (struct uscsi_cmd *)arg,
22727 flag, uioseg, SD_PATH_STANDARD);
22728 if (err != 0)
22729 goto done_with_assess;
22730 else
22731 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
22732 }
22733 break;
22734
22735 case CDROMPAUSE:
22736 case CDROMRESUME:
22737 SD_TRACE(SD_LOG_IOCTL, un, "PAUSE-RESUME\n");
22738 if (!ISCD(un)) {
22739 err = ENOTTY;
22740 } else {
22741 err = sr_pause_resume(dev, cmd);
22742 }
22743 break;
22744
22745 case CDROMPLAYMSF:
22746 SD_TRACE(SD_LOG_IOCTL, un, "CDROMPLAYMSF\n");
22747 if (!ISCD(un)) {
22748 err = ENOTTY;
22749 } else {
22750 err = sr_play_msf(dev, (caddr_t)arg, flag);
22751 }
22752 break;
22753
22754 case CDROMPLAYTRKIND:
22755 SD_TRACE(SD_LOG_IOCTL, un, "CDROMPLAYTRKIND\n");
22756 #if defined(__i386) || defined(__amd64)
22757 /*
22758 * not supported on ATAPI CD drives, use CDROMPLAYMSF instead
22759 */
22760 if (!ISCD(un) || (un->un_f_cfg_is_atapi == TRUE)) {
22761 #else
22762 if (!ISCD(un)) {
22763 #endif
22764 err = ENOTTY;
22765 } else {
22766 err = sr_play_trkind(dev, (caddr_t)arg, flag);
22767 }
22768 break;
22769
22770 case CDROMREADTOCHDR:
22771 SD_TRACE(SD_LOG_IOCTL, un, "CDROMREADTOCHDR\n");
22772 if (!ISCD(un)) {
22773 err = ENOTTY;
22774 } else {
22775 err = sr_read_tochdr(dev, (caddr_t)arg, flag);
22776 }
22777 break;
22778
22779 case CDROMREADTOCENTRY:
22780 SD_TRACE(SD_LOG_IOCTL, un, "CDROMREADTOCENTRY\n");
22781 if (!ISCD(un)) {
22782 err = ENOTTY;
22783 } else {
22784 err = sr_read_tocentry(dev, (caddr_t)arg, flag);
22785 }
22786 break;
22787
22788 case CDROMSTOP:
22789 SD_TRACE(SD_LOG_IOCTL, un, "CDROMSTOP\n");
22790 if (!ISCD(un)) {
22791 err = ENOTTY;
22792 } else {
22793 err = sd_send_scsi_START_STOP_UNIT(ssc, SD_START_STOP,
22794 SD_TARGET_STOP, SD_PATH_STANDARD);
22795 goto done_with_assess;
22796 }
22797 break;
22798
22799 case CDROMSTART:
22800 SD_TRACE(SD_LOG_IOCTL, un, "CDROMSTART\n");
22801 if (!ISCD(un)) {
22802 err = ENOTTY;
22803 } else {
22804 err = sd_send_scsi_START_STOP_UNIT(ssc, SD_START_STOP,
22805 SD_TARGET_START, SD_PATH_STANDARD);
22806 goto done_with_assess;
22807 }
22808 break;
22809
22810 case CDROMCLOSETRAY:
22811 SD_TRACE(SD_LOG_IOCTL, un, "CDROMCLOSETRAY\n");
22812 if (!ISCD(un)) {
22813 err = ENOTTY;
22814 } else {
22815 err = sd_send_scsi_START_STOP_UNIT(ssc, SD_START_STOP,
22816 SD_TARGET_CLOSE, SD_PATH_STANDARD);
22817 goto done_with_assess;
22818 }
22819 break;
22820
22821 case FDEJECT: /* for eject command */
22822 case DKIOCEJECT:
22823 case CDROMEJECT:
22824 SD_TRACE(SD_LOG_IOCTL, un, "EJECT\n");
22825 if (!un->un_f_eject_media_supported) {
22826 err = ENOTTY;
22827 } else {
22828 err = sr_eject(dev);
22829 }
22830 break;
22831
22832 case CDROMVOLCTRL:
22833 SD_TRACE(SD_LOG_IOCTL, un, "CDROMVOLCTRL\n");
22834 if (!ISCD(un)) {
22835 err = ENOTTY;
22836 } else {
22837 err = sr_volume_ctrl(dev, (caddr_t)arg, flag);
22838 }
22839 break;
22840
22841 case CDROMSUBCHNL:
22842 SD_TRACE(SD_LOG_IOCTL, un, "CDROMSUBCHNL\n");
22843 if (!ISCD(un)) {
22844 err = ENOTTY;
22845 } else {
22846 err = sr_read_subchannel(dev, (caddr_t)arg, flag);
22847 }
22848 break;
22849
22850 case CDROMREADMODE2:
22851 SD_TRACE(SD_LOG_IOCTL, un, "CDROMREADMODE2\n");
22852 if (!ISCD(un)) {
22853 err = ENOTTY;
22854 } else if (un->un_f_cfg_is_atapi == TRUE) {
22855 /*
22856 * If the drive supports READ CD, use that instead of
22857 * switching the LBA size via a MODE SELECT
22858 * Block Descriptor
22859 */
22860 err = sr_read_cd_mode2(dev, (caddr_t)arg, flag);
22861 } else {
22862 err = sr_read_mode2(dev, (caddr_t)arg, flag);
22863 }
22864 break;
22865
22866 case CDROMREADMODE1:
22867 SD_TRACE(SD_LOG_IOCTL, un, "CDROMREADMODE1\n");
22868 if (!ISCD(un)) {
22869 err = ENOTTY;
22870 } else {
22871 err = sr_read_mode1(dev, (caddr_t)arg, flag);
22872 }
22873 break;
22874
22875 case CDROMREADOFFSET:
22876 SD_TRACE(SD_LOG_IOCTL, un, "CDROMREADOFFSET\n");
22877 if (!ISCD(un)) {
22878 err = ENOTTY;
22879 } else {
22880 err = sr_read_sony_session_offset(dev, (caddr_t)arg,
22881 flag);
22882 }
22883 break;
22884
22885 case CDROMSBLKMODE:
22886 SD_TRACE(SD_LOG_IOCTL, un, "CDROMSBLKMODE\n");
22887 /*
22888 * There is no means of changing block size in case of atapi
22889 * drives, thus return ENOTTY if drive type is atapi
22890 */
22891 if (!ISCD(un) || (un->un_f_cfg_is_atapi == TRUE)) {
22892 err = ENOTTY;
22893 } else if (un->un_f_mmc_cap == TRUE) {
22894
22895 /*
22896 * MMC Devices do not support changing the
22897 * logical block size
22898 *
22899 * Note: EINVAL is being returned instead of ENOTTY to
22900 * maintain consistancy with the original mmc
22901 * driver update.
22902 */
22903 err = EINVAL;
22904 } else {
22905 mutex_enter(SD_MUTEX(un));
22906 if ((!(un->un_exclopen & (1<<SDPART(dev)))) ||
22907 (un->un_ncmds_in_transport > 0)) {
22908 mutex_exit(SD_MUTEX(un));
22909 err = EINVAL;
22910 } else {
22911 mutex_exit(SD_MUTEX(un));
22912 err = sr_change_blkmode(dev, cmd, arg, flag);
22913 }
22914 }
22915 break;
22916
22917 case CDROMGBLKMODE:
22918 SD_TRACE(SD_LOG_IOCTL, un, "CDROMGBLKMODE\n");
22919 if (!ISCD(un)) {
22920 err = ENOTTY;
22921 } else if ((un->un_f_cfg_is_atapi != FALSE) &&
22922 (un->un_f_blockcount_is_valid != FALSE)) {
22923 /*
22924 * Drive is an ATAPI drive so return target block
22925 * size for ATAPI drives since we cannot change the
22926 * blocksize on ATAPI drives. Used primarily to detect
22927 * if an ATAPI cdrom is present.
22928 */
22929 if (ddi_copyout(&un->un_tgt_blocksize, (void *)arg,
22930 sizeof (int), flag) != 0) {
22931 err = EFAULT;
22932 } else {
22933 err = 0;
22934 }
22935
22936 } else {
22937 /*
22938 * Drive supports changing block sizes via a Mode
22939 * Select.
22940 */
22941 err = sr_change_blkmode(dev, cmd, arg, flag);
22942 }
22943 break;
22944
22945 case CDROMGDRVSPEED:
22946 case CDROMSDRVSPEED:
22947 SD_TRACE(SD_LOG_IOCTL, un, "CDROMXDRVSPEED\n");
22948 if (!ISCD(un)) {
22949 err = ENOTTY;
22950 } else if (un->un_f_mmc_cap == TRUE) {
22951 /*
22952 * Note: In the future the driver implementation
22953 * for getting and
22954 * setting cd speed should entail:
22955 * 1) If non-mmc try the Toshiba mode page
22956 * (sr_change_speed)
22957 * 2) If mmc but no support for Real Time Streaming try
22958 * the SET CD SPEED (0xBB) command
22959 * (sr_atapi_change_speed)
22960 * 3) If mmc and support for Real Time Streaming
22961 * try the GET PERFORMANCE and SET STREAMING
22962 * commands (not yet implemented, 4380808)
22963 */
22964 /*
22965 * As per recent MMC spec, CD-ROM speed is variable
22966 * and changes with LBA. Since there is no such
22967 * things as drive speed now, fail this ioctl.
22968 *
22969 * Note: EINVAL is returned for consistancy of original
22970 * implementation which included support for getting
22971 * the drive speed of mmc devices but not setting
22972 * the drive speed. Thus EINVAL would be returned
22973 * if a set request was made for an mmc device.
22974 * We no longer support get or set speed for
22975 * mmc but need to remain consistent with regard
22976 * to the error code returned.
22977 */
22978 err = EINVAL;
22979 } else if (un->un_f_cfg_is_atapi == TRUE) {
22980 err = sr_atapi_change_speed(dev, cmd, arg, flag);
22981 } else {
22982 err = sr_change_speed(dev, cmd, arg, flag);
22983 }
22984 break;
22985
22986 case CDROMCDDA:
22987 SD_TRACE(SD_LOG_IOCTL, un, "CDROMCDDA\n");
22988 if (!ISCD(un)) {
22989 err = ENOTTY;
22990 } else {
22991 err = sr_read_cdda(dev, (void *)arg, flag);
22992 }
22993 break;
22994
22995 case CDROMCDXA:
22996 SD_TRACE(SD_LOG_IOCTL, un, "CDROMCDXA\n");
22997 if (!ISCD(un)) {
22998 err = ENOTTY;
22999 } else {
23000 err = sr_read_cdxa(dev, (caddr_t)arg, flag);
23001 }
23002 break;
23003
23004 case CDROMSUBCODE:
23005 SD_TRACE(SD_LOG_IOCTL, un, "CDROMSUBCODE\n");
23006 if (!ISCD(un)) {
23007 err = ENOTTY;
23008 } else {
23009 err = sr_read_all_subcodes(dev, (caddr_t)arg, flag);
23010 }
23011 break;
23012
23013
23014 #ifdef SDDEBUG
23015 /* RESET/ABORTS testing ioctls */
23016 case DKIOCRESET: {
23017 int reset_level;
23018
23019 if (ddi_copyin((void *)arg, &reset_level, sizeof (int), flag)) {
23020 err = EFAULT;
23021 } else {
23022 SD_INFO(SD_LOG_IOCTL, un, "sdioctl: DKIOCRESET: "
23023 "reset_level = 0x%lx\n", reset_level);
23024 if (scsi_reset(SD_ADDRESS(un), reset_level)) {
23025 err = 0;
23026 } else {
23027 err = EIO;
23028 }
23029 }
23030 break;
23031 }
23032
23033 case DKIOCABORT:
23034 SD_INFO(SD_LOG_IOCTL, un, "sdioctl: DKIOCABORT:\n");
23035 if (scsi_abort(SD_ADDRESS(un), NULL)) {
23036 err = 0;
23037 } else {
23038 err = EIO;
23039 }
23040 break;
23041 #endif
23042
23043 #ifdef SD_FAULT_INJECTION
23044 /* SDIOC FaultInjection testing ioctls */
23045 case SDIOCSTART:
23046 case SDIOCSTOP:
23047 case SDIOCINSERTPKT:
23048 case SDIOCINSERTXB:
23049 case SDIOCINSERTUN:
23050 case SDIOCINSERTARQ:
23051 case SDIOCPUSH:
23052 case SDIOCRETRIEVE:
23053 case SDIOCRUN:
23054 SD_INFO(SD_LOG_SDTEST, un, "sdioctl:"
23055 "SDIOC detected cmd:0x%X:\n", cmd);
23056 /* call error generator */
23057 sd_faultinjection_ioctl(cmd, arg, un);
23058 err = 0;
23059 break;
23060
23061 #endif /* SD_FAULT_INJECTION */
23062
23063 case DKIOCFLUSHWRITECACHE:
23064 {
23065 struct dk_callback *dkc = (struct dk_callback *)arg;
23066
23067 mutex_enter(SD_MUTEX(un));
23068 if (!un->un_f_sync_cache_supported ||
23069 !un->un_f_write_cache_enabled) {
23070 err = un->un_f_sync_cache_supported ?
23071 0 : ENOTSUP;
23072 mutex_exit(SD_MUTEX(un));
23073 if ((flag & FKIOCTL) && dkc != NULL &&
23074 dkc->dkc_callback != NULL) {
23075 (*dkc->dkc_callback)(dkc->dkc_cookie,
23076 err);
23077 /*
23078 * Did callback and reported error.
23079 * Since we did a callback, ioctl
23080 * should return 0.
23081 */
23082 err = 0;
23083 }
23084 break;
23085 }
23086 mutex_exit(SD_MUTEX(un));
23087
23088 if ((flag & FKIOCTL) && dkc != NULL &&
23089 dkc->dkc_callback != NULL) {
23090 /* async SYNC CACHE request */
23091 err = sd_send_scsi_SYNCHRONIZE_CACHE(un, dkc);
23092 } else {
23093 /* synchronous SYNC CACHE request */
23094 err = sd_send_scsi_SYNCHRONIZE_CACHE(un, NULL);
23095 }
23096 }
23097 break;
23098
23099 case DKIOCGETWCE: {
23100
23101 int wce;
23102
23103 if ((err = sd_get_write_cache_enabled(ssc, &wce)) != 0) {
23104 break;
23105 }
23106
23107 if (ddi_copyout(&wce, (void *)arg, sizeof (wce), flag)) {
23108 err = EFAULT;
23109 }
23110 break;
23111 }
23112
23113 case DKIOCSETWCE: {
23114
23115 int wce, sync_supported;
23116 int cur_wce = 0;
23117
23118 if (!un->un_f_cache_mode_changeable) {
23119 err = EINVAL;
23120 break;
23121 }
23122
23123 if (ddi_copyin((void *)arg, &wce, sizeof (wce), flag)) {
23124 err = EFAULT;
23125 break;
23126 }
23127
23128 /*
23129 * Synchronize multiple threads trying to enable
23130 * or disable the cache via the un_f_wcc_cv
23131 * condition variable.
23132 */
23133 mutex_enter(SD_MUTEX(un));
23134
23135 /*
23136 * Don't allow the cache to be enabled if the
23137 * config file has it disabled.
23138 */
23139 if (un->un_f_opt_disable_cache && wce) {
23140 mutex_exit(SD_MUTEX(un));
23141 err = EINVAL;
23142 break;
23143 }
23144
23145 /*
23146 * Wait for write cache change in progress
23147 * bit to be clear before proceeding.
23148 */
23149 while (un->un_f_wcc_inprog)
23150 cv_wait(&un->un_wcc_cv, SD_MUTEX(un));
23151
23152 un->un_f_wcc_inprog = 1;
23153
23154 mutex_exit(SD_MUTEX(un));
23155
23156 /*
23157 * Get the current write cache state
23158 */
23159 if ((err = sd_get_write_cache_enabled(ssc, &cur_wce)) != 0) {
23160 mutex_enter(SD_MUTEX(un));
23161 un->un_f_wcc_inprog = 0;
23162 cv_broadcast(&un->un_wcc_cv);
23163 mutex_exit(SD_MUTEX(un));
23164 break;
23165 }
23166
23167 mutex_enter(SD_MUTEX(un));
23168 un->un_f_write_cache_enabled = (cur_wce != 0);
23169
23170 if (un->un_f_write_cache_enabled && wce == 0) {
23171 /*
23172 * Disable the write cache. Don't clear
23173 * un_f_write_cache_enabled until after
23174 * the mode select and flush are complete.
23175 */
23176 sync_supported = un->un_f_sync_cache_supported;
23177
23178 /*
23179 * If cache flush is suppressed, we assume that the
23180 * controller firmware will take care of managing the
23181 * write cache for us: no need to explicitly
23182 * disable it.
23183 */
23184 if (!un->un_f_suppress_cache_flush) {
23185 mutex_exit(SD_MUTEX(un));
23186 if ((err = sd_cache_control(ssc,
23187 SD_CACHE_NOCHANGE,
23188 SD_CACHE_DISABLE)) == 0 &&
23189 sync_supported) {
23190 err = sd_send_scsi_SYNCHRONIZE_CACHE(un,
23191 NULL);
23192 }
23193 } else {
23194 mutex_exit(SD_MUTEX(un));
23195 }
23196
23197 mutex_enter(SD_MUTEX(un));
23198 if (err == 0) {
23199 un->un_f_write_cache_enabled = 0;
23200 }
23201
23202 } else if (!un->un_f_write_cache_enabled && wce != 0) {
23203 /*
23204 * Set un_f_write_cache_enabled first, so there is
23205 * no window where the cache is enabled, but the
23206 * bit says it isn't.
23207 */
23208 un->un_f_write_cache_enabled = 1;
23209
23210 /*
23211 * If cache flush is suppressed, we assume that the
23212 * controller firmware will take care of managing the
23213 * write cache for us: no need to explicitly
23214 * enable it.
23215 */
23216 if (!un->un_f_suppress_cache_flush) {
23217 mutex_exit(SD_MUTEX(un));
23218 err = sd_cache_control(ssc, SD_CACHE_NOCHANGE,
23219 SD_CACHE_ENABLE);
23220 } else {
23221 mutex_exit(SD_MUTEX(un));
23222 }
23223
23224 mutex_enter(SD_MUTEX(un));
23225
23226 if (err) {
23227 un->un_f_write_cache_enabled = 0;
23228 }
23229 }
23230
23231 un->un_f_wcc_inprog = 0;
23232 cv_broadcast(&un->un_wcc_cv);
23233 mutex_exit(SD_MUTEX(un));
23234 break;
23235 }
23236
23237 default:
23238 err = ENOTTY;
23239 break;
23240 }
23241 mutex_enter(SD_MUTEX(un));
23242 un->un_ncmds_in_driver--;
23243 ASSERT(un->un_ncmds_in_driver >= 0);
23244 mutex_exit(SD_MUTEX(un));
23245
23246
23247 done_without_assess:
23248 sd_ssc_fini(ssc);
23249
23250 SD_TRACE(SD_LOG_IOCTL, un, "sdioctl: exit: %d\n", err);
23251 return (err);
23252
23253 done_with_assess:
23254 mutex_enter(SD_MUTEX(un));
23255 un->un_ncmds_in_driver--;
23256 ASSERT(un->un_ncmds_in_driver >= 0);
23257 mutex_exit(SD_MUTEX(un));
23258
23259 done_quick_assess:
23260 if (err != 0)
23261 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
23262 /* Uninitialize sd_ssc_t pointer */
23263 sd_ssc_fini(ssc);
23264
23265 SD_TRACE(SD_LOG_IOCTL, un, "sdioctl: exit: %d\n", err);
23266 return (err);
23267 }
23268
23269
23270 /*
23271 * Function: sd_dkio_ctrl_info
23272 *
23273 * Description: This routine is the driver entry point for handling controller
23274 * information ioctl requests (DKIOCINFO).
23275 *
23276 * Arguments: dev - the device number
23277 * arg - pointer to user provided dk_cinfo structure
23278 * specifying the controller type and attributes.
23279 * flag - this argument is a pass through to ddi_copyxxx()
23280 * directly from the mode argument of ioctl().
23281 *
23282 * Return Code: 0
23283 * EFAULT
23284 * ENXIO
23285 */
23286
23287 static int
23288 sd_dkio_ctrl_info(dev_t dev, caddr_t arg, int flag)
23289 {
23290 struct sd_lun *un = NULL;
23291 struct dk_cinfo *info;
23292 dev_info_t *pdip;
23293 int lun, tgt;
23294
23295 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
23296 return (ENXIO);
23297 }
23298
23299 info = (struct dk_cinfo *)
23300 kmem_zalloc(sizeof (struct dk_cinfo), KM_SLEEP);
23301
23302 switch (un->un_ctype) {
23303 case CTYPE_CDROM:
23304 info->dki_ctype = DKC_CDROM;
23305 break;
23306 default:
23307 info->dki_ctype = DKC_SCSI_CCS;
23308 break;
23309 }
23310 pdip = ddi_get_parent(SD_DEVINFO(un));
23311 info->dki_cnum = ddi_get_instance(pdip);
23312 if (strlen(ddi_get_name(pdip)) < DK_DEVLEN) {
23313 (void) strcpy(info->dki_cname, ddi_get_name(pdip));
23314 } else {
23315 (void) strncpy(info->dki_cname, ddi_node_name(pdip),
23316 DK_DEVLEN - 1);
23317 }
23318
23319 lun = ddi_prop_get_int(DDI_DEV_T_ANY, SD_DEVINFO(un),
23320 DDI_PROP_DONTPASS, SCSI_ADDR_PROP_LUN, 0);
23321 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, SD_DEVINFO(un),
23322 DDI_PROP_DONTPASS, SCSI_ADDR_PROP_TARGET, 0);
23323
23324 /* Unit Information */
23325 info->dki_unit = ddi_get_instance(SD_DEVINFO(un));
23326 info->dki_slave = ((tgt << 3) | lun);
23327 (void) strncpy(info->dki_dname, ddi_driver_name(SD_DEVINFO(un)),
23328 DK_DEVLEN - 1);
23329 info->dki_flags = DKI_FMTVOL;
23330 info->dki_partition = SDPART(dev);
23331
23332 /* Max Transfer size of this device in blocks */
23333 info->dki_maxtransfer = un->un_max_xfer_size / un->un_sys_blocksize;
23334 info->dki_addr = 0;
23335 info->dki_space = 0;
23336 info->dki_prio = 0;
23337 info->dki_vec = 0;
23338
23339 if (ddi_copyout(info, arg, sizeof (struct dk_cinfo), flag) != 0) {
23340 kmem_free(info, sizeof (struct dk_cinfo));
23341 return (EFAULT);
23342 } else {
23343 kmem_free(info, sizeof (struct dk_cinfo));
23344 return (0);
23345 }
23346 }
23347
23348 /*
23349 * Function: sd_get_media_info_com
23350 *
23351 * Description: This routine returns the information required to populate
23352 * the fields for the dk_minfo/dk_minfo_ext structures.
23353 *
23354 * Arguments: dev - the device number
23355 * dki_media_type - media_type
23356 * dki_lbsize - logical block size
23357 * dki_capacity - capacity in blocks
23358 * dki_pbsize - physical block size (if requested)
23359 *
23360 * Return Code: 0
23361 * EACCESS
23362 * EFAULT
23363 * ENXIO
23364 * EIO
23365 */
23366 static int
23367 sd_get_media_info_com(dev_t dev, uint_t *dki_media_type, uint_t *dki_lbsize,
23368 diskaddr_t *dki_capacity, uint_t *dki_pbsize)
23369 {
23370 struct sd_lun *un = NULL;
23371 struct uscsi_cmd com;
23372 struct scsi_inquiry *sinq;
23373 u_longlong_t media_capacity;
23374 uint64_t capacity;
23375 uint_t lbasize;
23376 uint_t pbsize;
23377 uchar_t *out_data;
23378 uchar_t *rqbuf;
23379 int rval = 0;
23380 int rtn;
23381 sd_ssc_t *ssc;
23382
23383 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
23384 (un->un_state == SD_STATE_OFFLINE)) {
23385 return (ENXIO);
23386 }
23387
23388 SD_TRACE(SD_LOG_IOCTL_DKIO, un, "sd_get_media_info_com: entry\n");
23389
23390 out_data = kmem_zalloc(SD_PROFILE_HEADER_LEN, KM_SLEEP);
23391 rqbuf = kmem_zalloc(SENSE_LENGTH, KM_SLEEP);
23392 ssc = sd_ssc_init(un);
23393
23394 /* Issue a TUR to determine if the drive is ready with media present */
23395 rval = sd_send_scsi_TEST_UNIT_READY(ssc, SD_CHECK_FOR_MEDIA);
23396 if (rval == ENXIO) {
23397 goto done;
23398 } else if (rval != 0) {
23399 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
23400 }
23401
23402 /* Now get configuration data */
23403 if (ISCD(un)) {
23404 *dki_media_type = DK_CDROM;
23405
23406 /* Allow SCMD_GET_CONFIGURATION to MMC devices only */
23407 if (un->un_f_mmc_cap == TRUE) {
23408 rtn = sd_send_scsi_GET_CONFIGURATION(ssc, &com, rqbuf,
23409 SENSE_LENGTH, out_data, SD_PROFILE_HEADER_LEN,
23410 SD_PATH_STANDARD);
23411
23412 if (rtn) {
23413 /*
23414 * We ignore all failures for CD and need to
23415 * put the assessment before processing code
23416 * to avoid missing assessment for FMA.
23417 */
23418 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
23419 /*
23420 * Failed for other than an illegal request
23421 * or command not supported
23422 */
23423 if ((com.uscsi_status == STATUS_CHECK) &&
23424 (com.uscsi_rqstatus == STATUS_GOOD)) {
23425 if ((rqbuf[2] != KEY_ILLEGAL_REQUEST) ||
23426 (rqbuf[12] != 0x20)) {
23427 rval = EIO;
23428 goto no_assessment;
23429 }
23430 }
23431 } else {
23432 /*
23433 * The GET CONFIGURATION command succeeded
23434 * so set the media type according to the
23435 * returned data
23436 */
23437 *dki_media_type = out_data[6];
23438 *dki_media_type <<= 8;
23439 *dki_media_type |= out_data[7];
23440 }
23441 }
23442 } else {
23443 /*
23444 * The profile list is not available, so we attempt to identify
23445 * the media type based on the inquiry data
23446 */
23447 sinq = un->un_sd->sd_inq;
23448 if ((sinq->inq_dtype == DTYPE_DIRECT) ||
23449 (sinq->inq_dtype == DTYPE_OPTICAL)) {
23450 /* This is a direct access device or optical disk */
23451 *dki_media_type = DK_FIXED_DISK;
23452
23453 if ((bcmp(sinq->inq_vid, "IOMEGA", 6) == 0) ||
23454 (bcmp(sinq->inq_vid, "iomega", 6) == 0)) {
23455 if ((bcmp(sinq->inq_pid, "ZIP", 3) == 0)) {
23456 *dki_media_type = DK_ZIP;
23457 } else if (
23458 (bcmp(sinq->inq_pid, "jaz", 3) == 0)) {
23459 *dki_media_type = DK_JAZ;
23460 }
23461 }
23462 } else {
23463 /*
23464 * Not a CD, direct access or optical disk so return
23465 * unknown media
23466 */
23467 *dki_media_type = DK_UNKNOWN;
23468 }
23469 }
23470
23471 /*
23472 * Now read the capacity so we can provide the lbasize,
23473 * pbsize and capacity.
23474 */
23475 if (dki_pbsize && un->un_f_descr_format_supported) {
23476 rval = sd_send_scsi_READ_CAPACITY_16(ssc, &capacity, &lbasize,
23477 &pbsize, SD_PATH_DIRECT);
23478
23479 /*
23480 * Override the physical blocksize if the instance already
23481 * has a larger value.
23482 */
23483 pbsize = MAX(pbsize, un->un_phy_blocksize);
23484 }
23485
23486 if (dki_pbsize == NULL || rval != 0 ||
23487 !un->un_f_descr_format_supported) {
23488 rval = sd_send_scsi_READ_CAPACITY(ssc, &capacity, &lbasize,
23489 SD_PATH_DIRECT);
23490
23491 switch (rval) {
23492 case 0:
23493 if (un->un_f_enable_rmw &&
23494 un->un_phy_blocksize != 0) {
23495 pbsize = un->un_phy_blocksize;
23496 } else {
23497 pbsize = lbasize;
23498 }
23499 media_capacity = capacity;
23500
23501 /*
23502 * sd_send_scsi_READ_CAPACITY() reports capacity in
23503 * un->un_sys_blocksize chunks. So we need to convert
23504 * it into cap.lbsize chunks.
23505 */
23506 if (un->un_f_has_removable_media) {
23507 media_capacity *= un->un_sys_blocksize;
23508 media_capacity /= lbasize;
23509 }
23510 break;
23511 case EACCES:
23512 rval = EACCES;
23513 goto done;
23514 default:
23515 rval = EIO;
23516 goto done;
23517 }
23518 } else {
23519 if (un->un_f_enable_rmw &&
23520 !ISP2(pbsize % DEV_BSIZE)) {
23521 pbsize = SSD_SECSIZE;
23522 } else if (!ISP2(lbasize % DEV_BSIZE) ||
23523 !ISP2(pbsize % DEV_BSIZE)) {
23524 pbsize = lbasize = DEV_BSIZE;
23525 }
23526 media_capacity = capacity;
23527 }
23528
23529 /*
23530 * If lun is expanded dynamically, update the un structure.
23531 */
23532 mutex_enter(SD_MUTEX(un));
23533 if ((un->un_f_blockcount_is_valid == TRUE) &&
23534 (un->un_f_tgt_blocksize_is_valid == TRUE) &&
23535 (capacity > un->un_blockcount)) {
23536 un->un_f_expnevent = B_FALSE;
23537 sd_update_block_info(un, lbasize, capacity);
23538 }
23539 mutex_exit(SD_MUTEX(un));
23540
23541 *dki_lbsize = lbasize;
23542 *dki_capacity = media_capacity;
23543 if (dki_pbsize)
23544 *dki_pbsize = pbsize;
23545
23546 done:
23547 if (rval != 0) {
23548 if (rval == EIO)
23549 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
23550 else
23551 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
23552 }
23553 no_assessment:
23554 sd_ssc_fini(ssc);
23555 kmem_free(out_data, SD_PROFILE_HEADER_LEN);
23556 kmem_free(rqbuf, SENSE_LENGTH);
23557 return (rval);
23558 }
23559
23560 /*
23561 * Function: sd_get_media_info
23562 *
23563 * Description: This routine is the driver entry point for handling ioctl
23564 * requests for the media type or command set profile used by the
23565 * drive to operate on the media (DKIOCGMEDIAINFO).
23566 *
23567 * Arguments: dev - the device number
23568 * arg - pointer to user provided dk_minfo structure
23569 * specifying the media type, logical block size and
23570 * drive capacity.
23571 * flag - this argument is a pass through to ddi_copyxxx()
23572 * directly from the mode argument of ioctl().
23573 *
23574 * Return Code: returns the value from sd_get_media_info_com
23575 */
23576 static int
23577 sd_get_media_info(dev_t dev, caddr_t arg, int flag)
23578 {
23579 struct dk_minfo mi;
23580 int rval;
23581
23582 rval = sd_get_media_info_com(dev, &mi.dki_media_type,
23583 &mi.dki_lbsize, &mi.dki_capacity, NULL);
23584
23585 if (rval)
23586 return (rval);
23587 if (ddi_copyout(&mi, arg, sizeof (struct dk_minfo), flag))
23588 rval = EFAULT;
23589 return (rval);
23590 }
23591
23592 /*
23593 * Function: sd_get_media_info_ext
23594 *
23595 * Description: This routine is the driver entry point for handling ioctl
23596 * requests for the media type or command set profile used by the
23597 * drive to operate on the media (DKIOCGMEDIAINFOEXT). The
23598 * difference this ioctl and DKIOCGMEDIAINFO is the return value
23599 * of this ioctl contains both logical block size and physical
23600 * block size.
23601 *
23602 *
23603 * Arguments: dev - the device number
23604 * arg - pointer to user provided dk_minfo_ext structure
23605 * specifying the media type, logical block size,
23606 * physical block size and disk capacity.
23607 * flag - this argument is a pass through to ddi_copyxxx()
23608 * directly from the mode argument of ioctl().
23609 *
23610 * Return Code: returns the value from sd_get_media_info_com
23611 */
23612 static int
23613 sd_get_media_info_ext(dev_t dev, caddr_t arg, int flag)
23614 {
23615 struct dk_minfo_ext mie;
23616 int rval = 0;
23617
23618 rval = sd_get_media_info_com(dev, &mie.dki_media_type,
23619 &mie.dki_lbsize, &mie.dki_capacity, &mie.dki_pbsize);
23620
23621 if (rval)
23622 return (rval);
23623 if (ddi_copyout(&mie, arg, sizeof (struct dk_minfo_ext), flag))
23624 rval = EFAULT;
23625 return (rval);
23626
23627 }
23628
23629 /*
23630 * Function: sd_watch_request_submit
23631 *
23632 * Description: Call scsi_watch_request_submit or scsi_mmc_watch_request_submit
23633 * depending on which is supported by device.
23634 */
23635 static opaque_t
23636 sd_watch_request_submit(struct sd_lun *un)
23637 {
23638 dev_t dev;
23639
23640 /* All submissions are unified to use same device number */
23641 dev = sd_make_device(SD_DEVINFO(un));
23642
23643 if (un->un_f_mmc_cap && un->un_f_mmc_gesn_polling) {
23644 return (scsi_mmc_watch_request_submit(SD_SCSI_DEVP(un),
23645 sd_check_media_time, SENSE_LENGTH, sd_media_watch_cb,
23646 (caddr_t)dev));
23647 } else {
23648 return (scsi_watch_request_submit(SD_SCSI_DEVP(un),
23649 sd_check_media_time, SENSE_LENGTH, sd_media_watch_cb,
23650 (caddr_t)dev));
23651 }
23652 }
23653
23654
23655 /*
23656 * Function: sd_check_media
23657 *
23658 * Description: This utility routine implements the functionality for the
23659 * DKIOCSTATE ioctl. This ioctl blocks the user thread until the
23660 * driver state changes from that specified by the user
23661 * (inserted or ejected). For example, if the user specifies
23662 * DKIO_EJECTED and the current media state is inserted this
23663 * routine will immediately return DKIO_INSERTED. However, if the
23664 * current media state is not inserted the user thread will be
23665 * blocked until the drive state changes. If DKIO_NONE is specified
23666 * the user thread will block until a drive state change occurs.
23667 *
23668 * Arguments: dev - the device number
23669 * state - user pointer to a dkio_state, updated with the current
23670 * drive state at return.
23671 *
23672 * Return Code: ENXIO
23673 * EIO
23674 * EAGAIN
23675 * EINTR
23676 */
23677
23678 static int
23679 sd_check_media(dev_t dev, enum dkio_state state)
23680 {
23681 struct sd_lun *un = NULL;
23682 enum dkio_state prev_state;
23683 opaque_t token = NULL;
23684 int rval = 0;
23685 sd_ssc_t *ssc;
23686
23687 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
23688 return (ENXIO);
23689 }
23690
23691 SD_TRACE(SD_LOG_COMMON, un, "sd_check_media: entry\n");
23692
23693 ssc = sd_ssc_init(un);
23694
23695 mutex_enter(SD_MUTEX(un));
23696
23697 SD_TRACE(SD_LOG_COMMON, un, "sd_check_media: "
23698 "state=%x, mediastate=%x\n", state, un->un_mediastate);
23699
23700 prev_state = un->un_mediastate;
23701
23702 /* is there anything to do? */
23703 if (state == un->un_mediastate || un->un_mediastate == DKIO_NONE) {
23704 /*
23705 * submit the request to the scsi_watch service;
23706 * scsi_media_watch_cb() does the real work
23707 */
23708 mutex_exit(SD_MUTEX(un));
23709
23710 /*
23711 * This change handles the case where a scsi watch request is
23712 * added to a device that is powered down. To accomplish this
23713 * we power up the device before adding the scsi watch request,
23714 * since the scsi watch sends a TUR directly to the device
23715 * which the device cannot handle if it is powered down.
23716 */
23717 if (sd_pm_entry(un) != DDI_SUCCESS) {
23718 mutex_enter(SD_MUTEX(un));
23719 goto done;
23720 }
23721
23722 token = sd_watch_request_submit(un);
23723
23724 sd_pm_exit(un);
23725
23726 mutex_enter(SD_MUTEX(un));
23727 if (token == NULL) {
23728 rval = EAGAIN;
23729 goto done;
23730 }
23731
23732 /*
23733 * This is a special case IOCTL that doesn't return
23734 * until the media state changes. Routine sdpower
23735 * knows about and handles this so don't count it
23736 * as an active cmd in the driver, which would
23737 * keep the device busy to the pm framework.
23738 * If the count isn't decremented the device can't
23739 * be powered down.
23740 */
23741 un->un_ncmds_in_driver--;
23742 ASSERT(un->un_ncmds_in_driver >= 0);
23743
23744 /*
23745 * if a prior request had been made, this will be the same
23746 * token, as scsi_watch was designed that way.
23747 */
23748 un->un_swr_token = token;
23749 un->un_specified_mediastate = state;
23750
23751 /*
23752 * now wait for media change
23753 * we will not be signalled unless mediastate == state but it is
23754 * still better to test for this condition, since there is a
23755 * 2 sec cv_broadcast delay when mediastate == DKIO_INSERTED
23756 */
23757 SD_TRACE(SD_LOG_COMMON, un,
23758 "sd_check_media: waiting for media state change\n");
23759 while (un->un_mediastate == state) {
23760 if (cv_wait_sig(&un->un_state_cv, SD_MUTEX(un)) == 0) {
23761 SD_TRACE(SD_LOG_COMMON, un,
23762 "sd_check_media: waiting for media state "
23763 "was interrupted\n");
23764 un->un_ncmds_in_driver++;
23765 rval = EINTR;
23766 goto done;
23767 }
23768 SD_TRACE(SD_LOG_COMMON, un,
23769 "sd_check_media: received signal, state=%x\n",
23770 un->un_mediastate);
23771 }
23772 /*
23773 * Inc the counter to indicate the device once again
23774 * has an active outstanding cmd.
23775 */
23776 un->un_ncmds_in_driver++;
23777 }
23778
23779 /* invalidate geometry */
23780 if (prev_state == DKIO_INSERTED && un->un_mediastate == DKIO_EJECTED) {
23781 sr_ejected(un);
23782 }
23783
23784 if (un->un_mediastate == DKIO_INSERTED && prev_state != DKIO_INSERTED) {
23785 uint64_t capacity;
23786 uint_t lbasize;
23787
23788 SD_TRACE(SD_LOG_COMMON, un, "sd_check_media: media inserted\n");
23789 mutex_exit(SD_MUTEX(un));
23790 /*
23791 * Since the following routines use SD_PATH_DIRECT, we must
23792 * call PM directly before the upcoming disk accesses. This
23793 * may cause the disk to be power/spin up.
23794 */
23795
23796 if (sd_pm_entry(un) == DDI_SUCCESS) {
23797 rval = sd_send_scsi_READ_CAPACITY(ssc,
23798 &capacity, &lbasize, SD_PATH_DIRECT);
23799 if (rval != 0) {
23800 sd_pm_exit(un);
23801 if (rval == EIO)
23802 sd_ssc_assessment(ssc,
23803 SD_FMT_STATUS_CHECK);
23804 else
23805 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
23806 mutex_enter(SD_MUTEX(un));
23807 goto done;
23808 }
23809 } else {
23810 rval = EIO;
23811 mutex_enter(SD_MUTEX(un));
23812 goto done;
23813 }
23814 mutex_enter(SD_MUTEX(un));
23815
23816 sd_update_block_info(un, lbasize, capacity);
23817
23818 /*
23819 * Check if the media in the device is writable or not
23820 */
23821 if (ISCD(un)) {
23822 sd_check_for_writable_cd(ssc, SD_PATH_DIRECT);
23823 }
23824
23825 mutex_exit(SD_MUTEX(un));
23826 cmlb_invalidate(un->un_cmlbhandle, (void *)SD_PATH_DIRECT);
23827 if ((cmlb_validate(un->un_cmlbhandle, 0,
23828 (void *)SD_PATH_DIRECT) == 0) && un->un_f_pkstats_enabled) {
23829 sd_set_pstats(un);
23830 SD_TRACE(SD_LOG_IO_PARTITION, un,
23831 "sd_check_media: un:0x%p pstats created and "
23832 "set\n", un);
23833 }
23834
23835 rval = sd_send_scsi_DOORLOCK(ssc, SD_REMOVAL_PREVENT,
23836 SD_PATH_DIRECT);
23837
23838 sd_pm_exit(un);
23839
23840 if (rval != 0) {
23841 if (rval == EIO)
23842 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
23843 else
23844 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
23845 }
23846
23847 mutex_enter(SD_MUTEX(un));
23848 }
23849 done:
23850 sd_ssc_fini(ssc);
23851 un->un_f_watcht_stopped = FALSE;
23852 if (token != NULL && un->un_swr_token != NULL) {
23853 /*
23854 * Use of this local token and the mutex ensures that we avoid
23855 * some race conditions associated with terminating the
23856 * scsi watch.
23857 */
23858 token = un->un_swr_token;
23859 mutex_exit(SD_MUTEX(un));
23860 (void) scsi_watch_request_terminate(token,
23861 SCSI_WATCH_TERMINATE_WAIT);
23862 if (scsi_watch_get_ref_count(token) == 0) {
23863 mutex_enter(SD_MUTEX(un));
23864 un->un_swr_token = (opaque_t)NULL;
23865 } else {
23866 mutex_enter(SD_MUTEX(un));
23867 }
23868 }
23869
23870 /*
23871 * Update the capacity kstat value, if no media previously
23872 * (capacity kstat is 0) and a media has been inserted
23873 * (un_f_blockcount_is_valid == TRUE)
23874 */
23875 if (un->un_errstats) {
23876 struct sd_errstats *stp = NULL;
23877
23878 stp = (struct sd_errstats *)un->un_errstats->ks_data;
23879 if ((stp->sd_capacity.value.ui64 == 0) &&
23880 (un->un_f_blockcount_is_valid == TRUE)) {
23881 stp->sd_capacity.value.ui64 =
23882 (uint64_t)((uint64_t)un->un_blockcount *
23883 un->un_sys_blocksize);
23884 }
23885 }
23886 mutex_exit(SD_MUTEX(un));
23887 SD_TRACE(SD_LOG_COMMON, un, "sd_check_media: done\n");
23888 return (rval);
23889 }
23890
23891
23892 /*
23893 * Function: sd_delayed_cv_broadcast
23894 *
23895 * Description: Delayed cv_broadcast to allow for target to recover from media
23896 * insertion.
23897 *
23898 * Arguments: arg - driver soft state (unit) structure
23899 */
23900
23901 static void
23902 sd_delayed_cv_broadcast(void *arg)
23903 {
23904 struct sd_lun *un = arg;
23905
23906 SD_TRACE(SD_LOG_COMMON, un, "sd_delayed_cv_broadcast\n");
23907
23908 mutex_enter(SD_MUTEX(un));
23909 un->un_dcvb_timeid = NULL;
23910 cv_broadcast(&un->un_state_cv);
23911 mutex_exit(SD_MUTEX(un));
23912 }
23913
23914
23915 /*
23916 * Function: sd_media_watch_cb
23917 *
23918 * Description: Callback routine used for support of the DKIOCSTATE ioctl. This
23919 * routine processes the TUR sense data and updates the driver
23920 * state if a transition has occurred. The user thread
23921 * (sd_check_media) is then signalled.
23922 *
23923 * Arguments: arg - the device 'dev_t' is used for context to discriminate
23924 * among multiple watches that share this callback function
23925 * resultp - scsi watch facility result packet containing scsi
23926 * packet, status byte and sense data
23927 *
23928 * Return Code: 0 for success, -1 for failure
23929 */
23930
23931 static int
23932 sd_media_watch_cb(caddr_t arg, struct scsi_watch_result *resultp)
23933 {
23934 struct sd_lun *un;
23935 struct scsi_status *statusp = resultp->statusp;
23936 uint8_t *sensep = (uint8_t *)resultp->sensep;
23937 enum dkio_state state = DKIO_NONE;
23938 dev_t dev = (dev_t)arg;
23939 uchar_t actual_sense_length;
23940 uint8_t skey, asc, ascq;
23941
23942 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
23943 return (-1);
23944 }
23945 actual_sense_length = resultp->actual_sense_length;
23946
23947 mutex_enter(SD_MUTEX(un));
23948 SD_TRACE(SD_LOG_COMMON, un,
23949 "sd_media_watch_cb: status=%x, sensep=%p, len=%x\n",
23950 *((char *)statusp), (void *)sensep, actual_sense_length);
23951
23952 if (resultp->pkt->pkt_reason == CMD_DEV_GONE) {
23953 un->un_mediastate = DKIO_DEV_GONE;
23954 cv_broadcast(&un->un_state_cv);
23955 mutex_exit(SD_MUTEX(un));
23956
23957 return (0);
23958 }
23959
23960 if (un->un_f_mmc_cap && un->un_f_mmc_gesn_polling) {
23961 if (sd_gesn_media_data_valid(resultp->mmc_data)) {
23962 if ((resultp->mmc_data[5] &
23963 SD_GESN_MEDIA_EVENT_STATUS_PRESENT) != 0) {
23964 state = DKIO_INSERTED;
23965 } else {
23966 state = DKIO_EJECTED;
23967 }
23968 if ((resultp->mmc_data[4] & SD_GESN_MEDIA_EVENT_CODE) ==
23969 SD_GESN_MEDIA_EVENT_EJECTREQUEST) {
23970 sd_log_eject_request_event(un, KM_NOSLEEP);
23971 }
23972 }
23973 } else if (sensep != NULL) {
23974 /*
23975 * If there was a check condition then sensep points to valid
23976 * sense data. If status was not a check condition but a
23977 * reservation or busy status then the new state is DKIO_NONE.
23978 */
23979 skey = scsi_sense_key(sensep);
23980 asc = scsi_sense_asc(sensep);
23981 ascq = scsi_sense_ascq(sensep);
23982
23983 SD_INFO(SD_LOG_COMMON, un,
23984 "sd_media_watch_cb: sense KEY=%x, ASC=%x, ASCQ=%x\n",
23985 skey, asc, ascq);
23986 /* This routine only uses up to 13 bytes of sense data. */
23987 if (actual_sense_length >= 13) {
23988 if (skey == KEY_UNIT_ATTENTION) {
23989 if (asc == 0x28) {
23990 state = DKIO_INSERTED;
23991 }
23992 } else if (skey == KEY_NOT_READY) {
23993 /*
23994 * Sense data of 02/06/00 means that the
23995 * drive could not read the media (No
23996 * reference position found). In this case
23997 * to prevent a hang on the DKIOCSTATE IOCTL
23998 * we set the media state to DKIO_INSERTED.
23999 */
24000 if (asc == 0x06 && ascq == 0x00)
24001 state = DKIO_INSERTED;
24002
24003 /*
24004 * if 02/04/02 means that the host
24005 * should send start command. Explicitly
24006 * leave the media state as is
24007 * (inserted) as the media is inserted
24008 * and host has stopped device for PM
24009 * reasons. Upon next true read/write
24010 * to this media will bring the
24011 * device to the right state good for
24012 * media access.
24013 */
24014 if (asc == 0x3a) {
24015 state = DKIO_EJECTED;
24016 } else {
24017 /*
24018 * If the drive is busy with an
24019 * operation or long write, keep the
24020 * media in an inserted state.
24021 */
24022
24023 if ((asc == 0x04) &&
24024 ((ascq == 0x02) ||
24025 (ascq == 0x07) ||
24026 (ascq == 0x08))) {
24027 state = DKIO_INSERTED;
24028 }
24029 }
24030 } else if (skey == KEY_NO_SENSE) {
24031 if ((asc == 0x00) && (ascq == 0x00)) {
24032 /*
24033 * Sense Data 00/00/00 does not provide
24034 * any information about the state of
24035 * the media. Ignore it.
24036 */
24037 mutex_exit(SD_MUTEX(un));
24038 return (0);
24039 }
24040 }
24041 }
24042 } else if ((*((char *)statusp) == STATUS_GOOD) &&
24043 (resultp->pkt->pkt_reason == CMD_CMPLT)) {
24044 state = DKIO_INSERTED;
24045 }
24046
24047 SD_TRACE(SD_LOG_COMMON, un,
24048 "sd_media_watch_cb: state=%x, specified=%x\n",
24049 state, un->un_specified_mediastate);
24050
24051 /*
24052 * now signal the waiting thread if this is *not* the specified state;
24053 * delay the signal if the state is DKIO_INSERTED to allow the target
24054 * to recover
24055 */
24056 if (state != un->un_specified_mediastate) {
24057 un->un_mediastate = state;
24058 if (state == DKIO_INSERTED) {
24059 /*
24060 * delay the signal to give the drive a chance
24061 * to do what it apparently needs to do
24062 */
24063 SD_TRACE(SD_LOG_COMMON, un,
24064 "sd_media_watch_cb: delayed cv_broadcast\n");
24065 if (un->un_dcvb_timeid == NULL) {
24066 un->un_dcvb_timeid =
24067 timeout(sd_delayed_cv_broadcast, un,
24068 drv_usectohz((clock_t)MEDIA_ACCESS_DELAY));
24069 }
24070 } else {
24071 SD_TRACE(SD_LOG_COMMON, un,
24072 "sd_media_watch_cb: immediate cv_broadcast\n");
24073 cv_broadcast(&un->un_state_cv);
24074 }
24075 }
24076 mutex_exit(SD_MUTEX(un));
24077 return (0);
24078 }
24079
24080
24081 /*
24082 * Function: sd_dkio_get_temp
24083 *
24084 * Description: This routine is the driver entry point for handling ioctl
24085 * requests to get the disk temperature.
24086 *
24087 * Arguments: dev - the device number
24088 * arg - pointer to user provided dk_temperature structure.
24089 * flag - this argument is a pass through to ddi_copyxxx()
24090 * directly from the mode argument of ioctl().
24091 *
24092 * Return Code: 0
24093 * EFAULT
24094 * ENXIO
24095 * EAGAIN
24096 */
24097
24098 static int
24099 sd_dkio_get_temp(dev_t dev, caddr_t arg, int flag)
24100 {
24101 struct sd_lun *un = NULL;
24102 struct dk_temperature *dktemp = NULL;
24103 uchar_t *temperature_page;
24104 int rval = 0;
24105 int path_flag = SD_PATH_STANDARD;
24106 sd_ssc_t *ssc;
24107
24108 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
24109 return (ENXIO);
24110 }
24111
24112 ssc = sd_ssc_init(un);
24113 dktemp = kmem_zalloc(sizeof (struct dk_temperature), KM_SLEEP);
24114
24115 /* copyin the disk temp argument to get the user flags */
24116 if (ddi_copyin((void *)arg, dktemp,
24117 sizeof (struct dk_temperature), flag) != 0) {
24118 rval = EFAULT;
24119 goto done;
24120 }
24121
24122 /* Initialize the temperature to invalid. */
24123 dktemp->dkt_cur_temp = (short)DKT_INVALID_TEMP;
24124 dktemp->dkt_ref_temp = (short)DKT_INVALID_TEMP;
24125
24126 /*
24127 * Note: Investigate removing the "bypass pm" semantic.
24128 * Can we just bypass PM always?
24129 */
24130 if (dktemp->dkt_flags & DKT_BYPASS_PM) {
24131 path_flag = SD_PATH_DIRECT;
24132 ASSERT(!mutex_owned(&un->un_pm_mutex));
24133 mutex_enter(&un->un_pm_mutex);
24134 if (SD_DEVICE_IS_IN_LOW_POWER(un)) {
24135 /*
24136 * If DKT_BYPASS_PM is set, and the drive happens to be
24137 * in low power mode, we can not wake it up, Need to
24138 * return EAGAIN.
24139 */
24140 mutex_exit(&un->un_pm_mutex);
24141 rval = EAGAIN;
24142 goto done;
24143 } else {
24144 /*
24145 * Indicate to PM the device is busy. This is required
24146 * to avoid a race - i.e. the ioctl is issuing a
24147 * command and the pm framework brings down the device
24148 * to low power mode (possible power cut-off on some
24149 * platforms).
24150 */
24151 mutex_exit(&un->un_pm_mutex);
24152 if (sd_pm_entry(un) != DDI_SUCCESS) {
24153 rval = EAGAIN;
24154 goto done;
24155 }
24156 }
24157 }
24158
24159 temperature_page = kmem_zalloc(TEMPERATURE_PAGE_SIZE, KM_SLEEP);
24160
24161 rval = sd_send_scsi_LOG_SENSE(ssc, temperature_page,
24162 TEMPERATURE_PAGE_SIZE, TEMPERATURE_PAGE, 1, 0, path_flag);
24163 if (rval != 0)
24164 goto done2;
24165
24166 /*
24167 * For the current temperature verify that the parameter length is 0x02
24168 * and the parameter code is 0x00
24169 */
24170 if ((temperature_page[7] == 0x02) && (temperature_page[4] == 0x00) &&
24171 (temperature_page[5] == 0x00)) {
24172 if (temperature_page[9] == 0xFF) {
24173 dktemp->dkt_cur_temp = (short)DKT_INVALID_TEMP;
24174 } else {
24175 dktemp->dkt_cur_temp = (short)(temperature_page[9]);
24176 }
24177 }
24178
24179 /*
24180 * For the reference temperature verify that the parameter
24181 * length is 0x02 and the parameter code is 0x01
24182 */
24183 if ((temperature_page[13] == 0x02) && (temperature_page[10] == 0x00) &&
24184 (temperature_page[11] == 0x01)) {
24185 if (temperature_page[15] == 0xFF) {
24186 dktemp->dkt_ref_temp = (short)DKT_INVALID_TEMP;
24187 } else {
24188 dktemp->dkt_ref_temp = (short)(temperature_page[15]);
24189 }
24190 }
24191
24192 /* Do the copyout regardless of the temperature commands status. */
24193 if (ddi_copyout(dktemp, (void *)arg, sizeof (struct dk_temperature),
24194 flag) != 0) {
24195 rval = EFAULT;
24196 goto done1;
24197 }
24198
24199 done2:
24200 if (rval != 0) {
24201 if (rval == EIO)
24202 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
24203 else
24204 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
24205 }
24206 done1:
24207 if (path_flag == SD_PATH_DIRECT) {
24208 sd_pm_exit(un);
24209 }
24210
24211 kmem_free(temperature_page, TEMPERATURE_PAGE_SIZE);
24212 done:
24213 sd_ssc_fini(ssc);
24214 if (dktemp != NULL) {
24215 kmem_free(dktemp, sizeof (struct dk_temperature));
24216 }
24217
24218 return (rval);
24219 }
24220
24221
24222 /*
24223 * Function: sd_log_page_supported
24224 *
24225 * Description: This routine uses sd_send_scsi_LOG_SENSE to find the list of
24226 * supported log pages.
24227 *
24228 * Arguments: ssc - ssc contains pointer to driver soft state (unit)
24229 * structure for this target.
24230 * log_page -
24231 *
24232 * Return Code: -1 - on error (log sense is optional and may not be supported).
24233 * 0 - log page not found.
24234 * 1 - log page found.
24235 */
24236
24237 static int
24238 sd_log_page_supported(sd_ssc_t *ssc, int log_page)
24239 {
24240 uchar_t *log_page_data;
24241 int i;
24242 int match = 0;
24243 int log_size;
24244 int status = 0;
24245 struct sd_lun *un;
24246
24247 ASSERT(ssc != NULL);
24248 un = ssc->ssc_un;
24249 ASSERT(un != NULL);
24250
24251 log_page_data = kmem_zalloc(0xFF, KM_SLEEP);
24252
24253 status = sd_send_scsi_LOG_SENSE(ssc, log_page_data, 0xFF, 0, 0x01, 0,
24254 SD_PATH_DIRECT);
24255
24256 if (status != 0) {
24257 if (status == EIO) {
24258 /*
24259 * Some disks do not support log sense, we
24260 * should ignore this kind of error(sense key is
24261 * 0x5 - illegal request).
24262 */
24263 uint8_t *sensep;
24264 int senlen;
24265
24266 sensep = (uint8_t *)ssc->ssc_uscsi_cmd->uscsi_rqbuf;
24267 senlen = (int)(ssc->ssc_uscsi_cmd->uscsi_rqlen -
24268 ssc->ssc_uscsi_cmd->uscsi_rqresid);
24269
24270 if (senlen > 0 &&
24271 scsi_sense_key(sensep) == KEY_ILLEGAL_REQUEST) {
24272 sd_ssc_assessment(ssc,
24273 SD_FMT_IGNORE_COMPROMISE);
24274 } else {
24275 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
24276 }
24277 } else {
24278 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
24279 }
24280
24281 SD_ERROR(SD_LOG_COMMON, un,
24282 "sd_log_page_supported: failed log page retrieval\n");
24283 kmem_free(log_page_data, 0xFF);
24284 return (-1);
24285 }
24286
24287 log_size = log_page_data[3];
24288
24289 /*
24290 * The list of supported log pages start from the fourth byte. Check
24291 * until we run out of log pages or a match is found.
24292 */
24293 for (i = 4; (i < (log_size + 4)) && !match; i++) {
24294 if (log_page_data[i] == log_page) {
24295 match++;
24296 }
24297 }
24298 kmem_free(log_page_data, 0xFF);
24299 return (match);
24300 }
24301
24302
24303 /*
24304 * Function: sd_mhdioc_failfast
24305 *
24306 * Description: This routine is the driver entry point for handling ioctl
24307 * requests to enable/disable the multihost failfast option.
24308 * (MHIOCENFAILFAST)
24309 *
24310 * Arguments: dev - the device number
24311 * arg - user specified probing interval.
24312 * flag - this argument is a pass through to ddi_copyxxx()
24313 * directly from the mode argument of ioctl().
24314 *
24315 * Return Code: 0
24316 * EFAULT
24317 * ENXIO
24318 */
24319
24320 static int
24321 sd_mhdioc_failfast(dev_t dev, caddr_t arg, int flag)
24322 {
24323 struct sd_lun *un = NULL;
24324 int mh_time;
24325 int rval = 0;
24326
24327 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
24328 return (ENXIO);
24329 }
24330
24331 if (ddi_copyin((void *)arg, &mh_time, sizeof (int), flag))
24332 return (EFAULT);
24333
24334 if (mh_time) {
24335 mutex_enter(SD_MUTEX(un));
24336 un->un_resvd_status |= SD_FAILFAST;
24337 mutex_exit(SD_MUTEX(un));
24338 /*
24339 * If mh_time is INT_MAX, then this ioctl is being used for
24340 * SCSI-3 PGR purposes, and we don't need to spawn watch thread.
24341 */
24342 if (mh_time != INT_MAX) {
24343 rval = sd_check_mhd(dev, mh_time);
24344 }
24345 } else {
24346 (void) sd_check_mhd(dev, 0);
24347 mutex_enter(SD_MUTEX(un));
24348 un->un_resvd_status &= ~SD_FAILFAST;
24349 mutex_exit(SD_MUTEX(un));
24350 }
24351 return (rval);
24352 }
24353
24354
24355 /*
24356 * Function: sd_mhdioc_takeown
24357 *
24358 * Description: This routine is the driver entry point for handling ioctl
24359 * requests to forcefully acquire exclusive access rights to the
24360 * multihost disk (MHIOCTKOWN).
24361 *
24362 * Arguments: dev - the device number
24363 * arg - user provided structure specifying the delay
24364 * parameters in milliseconds
24365 * flag - this argument is a pass through to ddi_copyxxx()
24366 * directly from the mode argument of ioctl().
24367 *
24368 * Return Code: 0
24369 * EFAULT
24370 * ENXIO
24371 */
24372
24373 static int
24374 sd_mhdioc_takeown(dev_t dev, caddr_t arg, int flag)
24375 {
24376 struct sd_lun *un = NULL;
24377 struct mhioctkown *tkown = NULL;
24378 int rval = 0;
24379
24380 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
24381 return (ENXIO);
24382 }
24383
24384 if (arg != NULL) {
24385 tkown = (struct mhioctkown *)
24386 kmem_zalloc(sizeof (struct mhioctkown), KM_SLEEP);
24387 rval = ddi_copyin(arg, tkown, sizeof (struct mhioctkown), flag);
24388 if (rval != 0) {
24389 rval = EFAULT;
24390 goto error;
24391 }
24392 }
24393
24394 rval = sd_take_ownership(dev, tkown);
24395 mutex_enter(SD_MUTEX(un));
24396 if (rval == 0) {
24397 un->un_resvd_status |= SD_RESERVE;
24398 if (tkown != NULL && tkown->reinstate_resv_delay != 0) {
24399 sd_reinstate_resv_delay =
24400 tkown->reinstate_resv_delay * 1000;
24401 } else {
24402 sd_reinstate_resv_delay = SD_REINSTATE_RESV_DELAY;
24403 }
24404 /*
24405 * Give the scsi_watch routine interval set by
24406 * the MHIOCENFAILFAST ioctl precedence here.
24407 */
24408 if ((un->un_resvd_status & SD_FAILFAST) == 0) {
24409 mutex_exit(SD_MUTEX(un));
24410 (void) sd_check_mhd(dev, sd_reinstate_resv_delay/1000);
24411 SD_TRACE(SD_LOG_IOCTL_MHD, un,
24412 "sd_mhdioc_takeown : %d\n",
24413 sd_reinstate_resv_delay);
24414 } else {
24415 mutex_exit(SD_MUTEX(un));
24416 }
24417 (void) scsi_reset_notify(SD_ADDRESS(un), SCSI_RESET_NOTIFY,
24418 sd_mhd_reset_notify_cb, (caddr_t)un);
24419 } else {
24420 un->un_resvd_status &= ~SD_RESERVE;
24421 mutex_exit(SD_MUTEX(un));
24422 }
24423
24424 error:
24425 if (tkown != NULL) {
24426 kmem_free(tkown, sizeof (struct mhioctkown));
24427 }
24428 return (rval);
24429 }
24430
24431
24432 /*
24433 * Function: sd_mhdioc_release
24434 *
24435 * Description: This routine is the driver entry point for handling ioctl
24436 * requests to release exclusive access rights to the multihost
24437 * disk (MHIOCRELEASE).
24438 *
24439 * Arguments: dev - the device number
24440 *
24441 * Return Code: 0
24442 * ENXIO
24443 */
24444
24445 static int
24446 sd_mhdioc_release(dev_t dev)
24447 {
24448 struct sd_lun *un = NULL;
24449 timeout_id_t resvd_timeid_save;
24450 int resvd_status_save;
24451 int rval = 0;
24452
24453 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
24454 return (ENXIO);
24455 }
24456
24457 mutex_enter(SD_MUTEX(un));
24458 resvd_status_save = un->un_resvd_status;
24459 un->un_resvd_status &=
24460 ~(SD_RESERVE | SD_LOST_RESERVE | SD_WANT_RESERVE);
24461 if (un->un_resvd_timeid) {
24462 resvd_timeid_save = un->un_resvd_timeid;
24463 un->un_resvd_timeid = NULL;
24464 mutex_exit(SD_MUTEX(un));
24465 (void) untimeout(resvd_timeid_save);
24466 } else {
24467 mutex_exit(SD_MUTEX(un));
24468 }
24469
24470 /*
24471 * destroy any pending timeout thread that may be attempting to
24472 * reinstate reservation on this device.
24473 */
24474 sd_rmv_resv_reclaim_req(dev);
24475
24476 if ((rval = sd_reserve_release(dev, SD_RELEASE)) == 0) {
24477 mutex_enter(SD_MUTEX(un));
24478 if ((un->un_mhd_token) &&
24479 ((un->un_resvd_status & SD_FAILFAST) == 0)) {
24480 mutex_exit(SD_MUTEX(un));
24481 (void) sd_check_mhd(dev, 0);
24482 } else {
24483 mutex_exit(SD_MUTEX(un));
24484 }
24485 (void) scsi_reset_notify(SD_ADDRESS(un), SCSI_RESET_CANCEL,
24486 sd_mhd_reset_notify_cb, (caddr_t)un);
24487 } else {
24488 /*
24489 * sd_mhd_watch_cb will restart the resvd recover timeout thread
24490 */
24491 mutex_enter(SD_MUTEX(un));
24492 un->un_resvd_status = resvd_status_save;
24493 mutex_exit(SD_MUTEX(un));
24494 }
24495 return (rval);
24496 }
24497
24498
24499 /*
24500 * Function: sd_mhdioc_register_devid
24501 *
24502 * Description: This routine is the driver entry point for handling ioctl
24503 * requests to register the device id (MHIOCREREGISTERDEVID).
24504 *
24505 * Note: The implementation for this ioctl has been updated to
24506 * be consistent with the original PSARC case (1999/357)
24507 * (4375899, 4241671, 4220005)
24508 *
24509 * Arguments: dev - the device number
24510 *
24511 * Return Code: 0
24512 * ENXIO
24513 */
24514
24515 static int
24516 sd_mhdioc_register_devid(dev_t dev)
24517 {
24518 struct sd_lun *un = NULL;
24519 int rval = 0;
24520 sd_ssc_t *ssc;
24521
24522 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
24523 return (ENXIO);
24524 }
24525
24526 ASSERT(!mutex_owned(SD_MUTEX(un)));
24527
24528 mutex_enter(SD_MUTEX(un));
24529
24530 /* If a devid already exists, de-register it */
24531 if (un->un_devid != NULL) {
24532 ddi_devid_unregister(SD_DEVINFO(un));
24533 /*
24534 * After unregister devid, needs to free devid memory
24535 */
24536 ddi_devid_free(un->un_devid);
24537 un->un_devid = NULL;
24538 }
24539
24540 /* Check for reservation conflict */
24541 mutex_exit(SD_MUTEX(un));
24542 ssc = sd_ssc_init(un);
24543 rval = sd_send_scsi_TEST_UNIT_READY(ssc, 0);
24544 mutex_enter(SD_MUTEX(un));
24545
24546 switch (rval) {
24547 case 0:
24548 sd_register_devid(ssc, SD_DEVINFO(un), SD_TARGET_IS_UNRESERVED);
24549 break;
24550 case EACCES:
24551 break;
24552 default:
24553 rval = EIO;
24554 }
24555
24556 mutex_exit(SD_MUTEX(un));
24557 if (rval != 0) {
24558 if (rval == EIO)
24559 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
24560 else
24561 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
24562 }
24563 sd_ssc_fini(ssc);
24564 return (rval);
24565 }
24566
24567
24568 /*
24569 * Function: sd_mhdioc_inkeys
24570 *
24571 * Description: This routine is the driver entry point for handling ioctl
24572 * requests to issue the SCSI-3 Persistent In Read Keys command
24573 * to the device (MHIOCGRP_INKEYS).
24574 *
24575 * Arguments: dev - the device number
24576 * arg - user provided in_keys structure
24577 * flag - this argument is a pass through to ddi_copyxxx()
24578 * directly from the mode argument of ioctl().
24579 *
24580 * Return Code: code returned by sd_persistent_reservation_in_read_keys()
24581 * ENXIO
24582 * EFAULT
24583 */
24584
24585 static int
24586 sd_mhdioc_inkeys(dev_t dev, caddr_t arg, int flag)
24587 {
24588 struct sd_lun *un;
24589 mhioc_inkeys_t inkeys;
24590 int rval = 0;
24591
24592 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
24593 return (ENXIO);
24594 }
24595
24596 #ifdef _MULTI_DATAMODEL
24597 switch (ddi_model_convert_from(flag & FMODELS)) {
24598 case DDI_MODEL_ILP32: {
24599 struct mhioc_inkeys32 inkeys32;
24600
24601 if (ddi_copyin(arg, &inkeys32,
24602 sizeof (struct mhioc_inkeys32), flag) != 0) {
24603 return (EFAULT);
24604 }
24605 inkeys.li = (mhioc_key_list_t *)(uintptr_t)inkeys32.li;
24606 if ((rval = sd_persistent_reservation_in_read_keys(un,
24607 &inkeys, flag)) != 0) {
24608 return (rval);
24609 }
24610 inkeys32.generation = inkeys.generation;
24611 if (ddi_copyout(&inkeys32, arg, sizeof (struct mhioc_inkeys32),
24612 flag) != 0) {
24613 return (EFAULT);
24614 }
24615 break;
24616 }
24617 case DDI_MODEL_NONE:
24618 if (ddi_copyin(arg, &inkeys, sizeof (mhioc_inkeys_t),
24619 flag) != 0) {
24620 return (EFAULT);
24621 }
24622 if ((rval = sd_persistent_reservation_in_read_keys(un,
24623 &inkeys, flag)) != 0) {
24624 return (rval);
24625 }
24626 if (ddi_copyout(&inkeys, arg, sizeof (mhioc_inkeys_t),
24627 flag) != 0) {
24628 return (EFAULT);
24629 }
24630 break;
24631 }
24632
24633 #else /* ! _MULTI_DATAMODEL */
24634
24635 if (ddi_copyin(arg, &inkeys, sizeof (mhioc_inkeys_t), flag) != 0) {
24636 return (EFAULT);
24637 }
24638 rval = sd_persistent_reservation_in_read_keys(un, &inkeys, flag);
24639 if (rval != 0) {
24640 return (rval);
24641 }
24642 if (ddi_copyout(&inkeys, arg, sizeof (mhioc_inkeys_t), flag) != 0) {
24643 return (EFAULT);
24644 }
24645
24646 #endif /* _MULTI_DATAMODEL */
24647
24648 return (rval);
24649 }
24650
24651
24652 /*
24653 * Function: sd_mhdioc_inresv
24654 *
24655 * Description: This routine is the driver entry point for handling ioctl
24656 * requests to issue the SCSI-3 Persistent In Read Reservations
24657 * command to the device (MHIOCGRP_INKEYS).
24658 *
24659 * Arguments: dev - the device number
24660 * arg - user provided in_resv structure
24661 * flag - this argument is a pass through to ddi_copyxxx()
24662 * directly from the mode argument of ioctl().
24663 *
24664 * Return Code: code returned by sd_persistent_reservation_in_read_resv()
24665 * ENXIO
24666 * EFAULT
24667 */
24668
24669 static int
24670 sd_mhdioc_inresv(dev_t dev, caddr_t arg, int flag)
24671 {
24672 struct sd_lun *un;
24673 mhioc_inresvs_t inresvs;
24674 int rval = 0;
24675
24676 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
24677 return (ENXIO);
24678 }
24679
24680 #ifdef _MULTI_DATAMODEL
24681
24682 switch (ddi_model_convert_from(flag & FMODELS)) {
24683 case DDI_MODEL_ILP32: {
24684 struct mhioc_inresvs32 inresvs32;
24685
24686 if (ddi_copyin(arg, &inresvs32,
24687 sizeof (struct mhioc_inresvs32), flag) != 0) {
24688 return (EFAULT);
24689 }
24690 inresvs.li = (mhioc_resv_desc_list_t *)(uintptr_t)inresvs32.li;
24691 if ((rval = sd_persistent_reservation_in_read_resv(un,
24692 &inresvs, flag)) != 0) {
24693 return (rval);
24694 }
24695 inresvs32.generation = inresvs.generation;
24696 if (ddi_copyout(&inresvs32, arg,
24697 sizeof (struct mhioc_inresvs32), flag) != 0) {
24698 return (EFAULT);
24699 }
24700 break;
24701 }
24702 case DDI_MODEL_NONE:
24703 if (ddi_copyin(arg, &inresvs,
24704 sizeof (mhioc_inresvs_t), flag) != 0) {
24705 return (EFAULT);
24706 }
24707 if ((rval = sd_persistent_reservation_in_read_resv(un,
24708 &inresvs, flag)) != 0) {
24709 return (rval);
24710 }
24711 if (ddi_copyout(&inresvs, arg,
24712 sizeof (mhioc_inresvs_t), flag) != 0) {
24713 return (EFAULT);
24714 }
24715 break;
24716 }
24717
24718 #else /* ! _MULTI_DATAMODEL */
24719
24720 if (ddi_copyin(arg, &inresvs, sizeof (mhioc_inresvs_t), flag) != 0) {
24721 return (EFAULT);
24722 }
24723 rval = sd_persistent_reservation_in_read_resv(un, &inresvs, flag);
24724 if (rval != 0) {
24725 return (rval);
24726 }
24727 if (ddi_copyout(&inresvs, arg, sizeof (mhioc_inresvs_t), flag)) {
24728 return (EFAULT);
24729 }
24730
24731 #endif /* ! _MULTI_DATAMODEL */
24732
24733 return (rval);
24734 }
24735
24736
24737 /*
24738 * The following routines support the clustering functionality described below
24739 * and implement lost reservation reclaim functionality.
24740 *
24741 * Clustering
24742 * ----------
24743 * The clustering code uses two different, independent forms of SCSI
24744 * reservation. Traditional SCSI-2 Reserve/Release and the newer SCSI-3
24745 * Persistent Group Reservations. For any particular disk, it will use either
24746 * SCSI-2 or SCSI-3 PGR but never both at the same time for the same disk.
24747 *
24748 * SCSI-2
24749 * The cluster software takes ownership of a multi-hosted disk by issuing the
24750 * MHIOCTKOWN ioctl to the disk driver. It releases ownership by issuing the
24751 * MHIOCRELEASE ioctl. Closely related is the MHIOCENFAILFAST ioctl -- a
24752 * cluster, just after taking ownership of the disk with the MHIOCTKOWN ioctl
24753 * then issues the MHIOCENFAILFAST ioctl. This ioctl "enables failfast" in the
24754 * driver. The meaning of failfast is that if the driver (on this host) ever
24755 * encounters the scsi error return code RESERVATION_CONFLICT from the device,
24756 * it should immediately panic the host. The motivation for this ioctl is that
24757 * if this host does encounter reservation conflict, the underlying cause is
24758 * that some other host of the cluster has decided that this host is no longer
24759 * in the cluster and has seized control of the disks for itself. Since this
24760 * host is no longer in the cluster, it ought to panic itself. The
24761 * MHIOCENFAILFAST ioctl does two things:
24762 * (a) it sets a flag that will cause any returned RESERVATION_CONFLICT
24763 * error to panic the host
24764 * (b) it sets up a periodic timer to test whether this host still has
24765 * "access" (in that no other host has reserved the device): if the
24766 * periodic timer gets RESERVATION_CONFLICT, the host is panicked. The
24767 * purpose of that periodic timer is to handle scenarios where the host is
24768 * otherwise temporarily quiescent, temporarily doing no real i/o.
24769 * The MHIOCTKOWN ioctl will "break" a reservation that is held by another host,
24770 * by issuing a SCSI Bus Device Reset. It will then issue a SCSI Reserve for
24771 * the device itself.
24772 *
24773 * SCSI-3 PGR
24774 * A direct semantic implementation of the SCSI-3 Persistent Reservation
24775 * facility is supported through the shared multihost disk ioctls
24776 * (MHIOCGRP_INKEYS, MHIOCGRP_INRESV, MHIOCGRP_REGISTER, MHIOCGRP_RESERVE,
24777 * MHIOCGRP_PREEMPTANDABORT, MHIOCGRP_CLEAR)
24778 *
24779 * Reservation Reclaim:
24780 * --------------------
24781 * To support the lost reservation reclaim operations this driver creates a
24782 * single thread to handle reinstating reservations on all devices that have
24783 * lost reservations sd_resv_reclaim_requests are logged for all devices that
24784 * have LOST RESERVATIONS when the scsi watch facility callsback sd_mhd_watch_cb
24785 * and the reservation reclaim thread loops through the requests to regain the
24786 * lost reservations.
24787 */
24788
24789 /*
24790 * Function: sd_check_mhd()
24791 *
24792 * Description: This function sets up and submits a scsi watch request or
24793 * terminates an existing watch request. This routine is used in
24794 * support of reservation reclaim.
24795 *
24796 * Arguments: dev - the device 'dev_t' is used for context to discriminate
24797 * among multiple watches that share the callback function
24798 * interval - the number of microseconds specifying the watch
24799 * interval for issuing TEST UNIT READY commands. If
24800 * set to 0 the watch should be terminated. If the
24801 * interval is set to 0 and if the device is required
24802 * to hold reservation while disabling failfast, the
24803 * watch is restarted with an interval of
24804 * reinstate_resv_delay.
24805 *
24806 * Return Code: 0 - Successful submit/terminate of scsi watch request
24807 * ENXIO - Indicates an invalid device was specified
24808 * EAGAIN - Unable to submit the scsi watch request
24809 */
24810
24811 static int
24812 sd_check_mhd(dev_t dev, int interval)
24813 {
24814 struct sd_lun *un;
24815 opaque_t token;
24816
24817 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
24818 return (ENXIO);
24819 }
24820
24821 /* is this a watch termination request? */
24822 if (interval == 0) {
24823 mutex_enter(SD_MUTEX(un));
24824 /* if there is an existing watch task then terminate it */
24825 if (un->un_mhd_token) {
24826 token = un->un_mhd_token;
24827 un->un_mhd_token = NULL;
24828 mutex_exit(SD_MUTEX(un));
24829 (void) scsi_watch_request_terminate(token,
24830 SCSI_WATCH_TERMINATE_ALL_WAIT);
24831 mutex_enter(SD_MUTEX(un));
24832 } else {
24833 mutex_exit(SD_MUTEX(un));
24834 /*
24835 * Note: If we return here we don't check for the
24836 * failfast case. This is the original legacy
24837 * implementation but perhaps we should be checking
24838 * the failfast case.
24839 */
24840 return (0);
24841 }
24842 /*
24843 * If the device is required to hold reservation while
24844 * disabling failfast, we need to restart the scsi_watch
24845 * routine with an interval of reinstate_resv_delay.
24846 */
24847 if (un->un_resvd_status & SD_RESERVE) {
24848 interval = sd_reinstate_resv_delay/1000;
24849 } else {
24850 /* no failfast so bail */
24851 mutex_exit(SD_MUTEX(un));
24852 return (0);
24853 }
24854 mutex_exit(SD_MUTEX(un));
24855 }
24856
24857 /*
24858 * adjust minimum time interval to 1 second,
24859 * and convert from msecs to usecs
24860 */
24861 if (interval > 0 && interval < 1000) {
24862 interval = 1000;
24863 }
24864 interval *= 1000;
24865
24866 /*
24867 * submit the request to the scsi_watch service
24868 */
24869 token = scsi_watch_request_submit(SD_SCSI_DEVP(un), interval,
24870 SENSE_LENGTH, sd_mhd_watch_cb, (caddr_t)dev);
24871 if (token == NULL) {
24872 return (EAGAIN);
24873 }
24874
24875 /*
24876 * save token for termination later on
24877 */
24878 mutex_enter(SD_MUTEX(un));
24879 un->un_mhd_token = token;
24880 mutex_exit(SD_MUTEX(un));
24881 return (0);
24882 }
24883
24884
24885 /*
24886 * Function: sd_mhd_watch_cb()
24887 *
24888 * Description: This function is the call back function used by the scsi watch
24889 * facility. The scsi watch facility sends the "Test Unit Ready"
24890 * and processes the status. If applicable (i.e. a "Unit Attention"
24891 * status and automatic "Request Sense" not used) the scsi watch
24892 * facility will send a "Request Sense" and retrieve the sense data
24893 * to be passed to this callback function. In either case the
24894 * automatic "Request Sense" or the facility submitting one, this
24895 * callback is passed the status and sense data.
24896 *
24897 * Arguments: arg - the device 'dev_t' is used for context to discriminate
24898 * among multiple watches that share this callback function
24899 * resultp - scsi watch facility result packet containing scsi
24900 * packet, status byte and sense data
24901 *
24902 * Return Code: 0 - continue the watch task
24903 * non-zero - terminate the watch task
24904 */
24905
24906 static int
24907 sd_mhd_watch_cb(caddr_t arg, struct scsi_watch_result *resultp)
24908 {
24909 struct sd_lun *un;
24910 struct scsi_status *statusp;
24911 uint8_t *sensep;
24912 struct scsi_pkt *pkt;
24913 uchar_t actual_sense_length;
24914 dev_t dev = (dev_t)arg;
24915
24916 ASSERT(resultp != NULL);
24917 statusp = resultp->statusp;
24918 sensep = (uint8_t *)resultp->sensep;
24919 pkt = resultp->pkt;
24920 actual_sense_length = resultp->actual_sense_length;
24921
24922 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
24923 return (ENXIO);
24924 }
24925
24926 SD_TRACE(SD_LOG_IOCTL_MHD, un,
24927 "sd_mhd_watch_cb: reason '%s', status '%s'\n",
24928 scsi_rname(pkt->pkt_reason), sd_sname(*((unsigned char *)statusp)));
24929
24930 /* Begin processing of the status and/or sense data */
24931 if (pkt->pkt_reason != CMD_CMPLT) {
24932 /* Handle the incomplete packet */
24933 sd_mhd_watch_incomplete(un, pkt);
24934 return (0);
24935 } else if (*((unsigned char *)statusp) != STATUS_GOOD) {
24936 if (*((unsigned char *)statusp)
24937 == STATUS_RESERVATION_CONFLICT) {
24938 /*
24939 * Handle a reservation conflict by panicking if
24940 * configured for failfast or by logging the conflict
24941 * and updating the reservation status
24942 */
24943 mutex_enter(SD_MUTEX(un));
24944 if ((un->un_resvd_status & SD_FAILFAST) &&
24945 (sd_failfast_enable)) {
24946 sd_panic_for_res_conflict(un);
24947 /*NOTREACHED*/
24948 }
24949 SD_INFO(SD_LOG_IOCTL_MHD, un,
24950 "sd_mhd_watch_cb: Reservation Conflict\n");
24951 un->un_resvd_status |= SD_RESERVATION_CONFLICT;
24952 mutex_exit(SD_MUTEX(un));
24953 }
24954 }
24955
24956 if (sensep != NULL) {
24957 if (actual_sense_length >= (SENSE_LENGTH - 2)) {
24958 mutex_enter(SD_MUTEX(un));
24959 if ((scsi_sense_asc(sensep) ==
24960 SD_SCSI_RESET_SENSE_CODE) &&
24961 (un->un_resvd_status & SD_RESERVE)) {
24962 /*
24963 * The additional sense code indicates a power
24964 * on or bus device reset has occurred; update
24965 * the reservation status.
24966 */
24967 un->un_resvd_status |=
24968 (SD_LOST_RESERVE | SD_WANT_RESERVE);
24969 SD_INFO(SD_LOG_IOCTL_MHD, un,
24970 "sd_mhd_watch_cb: Lost Reservation\n");
24971 }
24972 } else {
24973 return (0);
24974 }
24975 } else {
24976 mutex_enter(SD_MUTEX(un));
24977 }
24978
24979 if ((un->un_resvd_status & SD_RESERVE) &&
24980 (un->un_resvd_status & SD_LOST_RESERVE)) {
24981 if (un->un_resvd_status & SD_WANT_RESERVE) {
24982 /*
24983 * A reset occurred in between the last probe and this
24984 * one so if a timeout is pending cancel it.
24985 */
24986 if (un->un_resvd_timeid) {
24987 timeout_id_t temp_id = un->un_resvd_timeid;
24988 un->un_resvd_timeid = NULL;
24989 mutex_exit(SD_MUTEX(un));
24990 (void) untimeout(temp_id);
24991 mutex_enter(SD_MUTEX(un));
24992 }
24993 un->un_resvd_status &= ~SD_WANT_RESERVE;
24994 }
24995 if (un->un_resvd_timeid == 0) {
24996 /* Schedule a timeout to handle the lost reservation */
24997 un->un_resvd_timeid = timeout(sd_mhd_resvd_recover,
24998 (void *)dev,
24999 drv_usectohz(sd_reinstate_resv_delay));
25000 }
25001 }
25002 mutex_exit(SD_MUTEX(un));
25003 return (0);
25004 }
25005
25006
25007 /*
25008 * Function: sd_mhd_watch_incomplete()
25009 *
25010 * Description: This function is used to find out why a scsi pkt sent by the
25011 * scsi watch facility was not completed. Under some scenarios this
25012 * routine will return. Otherwise it will send a bus reset to see
25013 * if the drive is still online.
25014 *
25015 * Arguments: un - driver soft state (unit) structure
25016 * pkt - incomplete scsi pkt
25017 */
25018
25019 static void
25020 sd_mhd_watch_incomplete(struct sd_lun *un, struct scsi_pkt *pkt)
25021 {
25022 int be_chatty;
25023 int perr;
25024
25025 ASSERT(pkt != NULL);
25026 ASSERT(un != NULL);
25027 be_chatty = (!(pkt->pkt_flags & FLAG_SILENT));
25028 perr = (pkt->pkt_statistics & STAT_PERR);
25029
25030 mutex_enter(SD_MUTEX(un));
25031 if (un->un_state == SD_STATE_DUMPING) {
25032 mutex_exit(SD_MUTEX(un));
25033 return;
25034 }
25035
25036 switch (pkt->pkt_reason) {
25037 case CMD_UNX_BUS_FREE:
25038 /*
25039 * If we had a parity error that caused the target to drop BSY*,
25040 * don't be chatty about it.
25041 */
25042 if (perr && be_chatty) {
25043 be_chatty = 0;
25044 }
25045 break;
25046 case CMD_TAG_REJECT:
25047 /*
25048 * The SCSI-2 spec states that a tag reject will be sent by the
25049 * target if tagged queuing is not supported. A tag reject may
25050 * also be sent during certain initialization periods or to
25051 * control internal resources. For the latter case the target
25052 * may also return Queue Full.
25053 *
25054 * If this driver receives a tag reject from a target that is
25055 * going through an init period or controlling internal
25056 * resources tagged queuing will be disabled. This is a less
25057 * than optimal behavior but the driver is unable to determine
25058 * the target state and assumes tagged queueing is not supported
25059 */
25060 pkt->pkt_flags = 0;
25061 un->un_tagflags = 0;
25062
25063 if (un->un_f_opt_queueing == TRUE) {
25064 un->un_throttle = min(un->un_throttle, 3);
25065 } else {
25066 un->un_throttle = 1;
25067 }
25068 mutex_exit(SD_MUTEX(un));
25069 (void) scsi_ifsetcap(SD_ADDRESS(un), "tagged-qing", 0, 1);
25070 mutex_enter(SD_MUTEX(un));
25071 break;
25072 case CMD_INCOMPLETE:
25073 /*
25074 * The transport stopped with an abnormal state, fallthrough and
25075 * reset the target and/or bus unless selection did not complete
25076 * (indicated by STATE_GOT_BUS) in which case we don't want to
25077 * go through a target/bus reset
25078 */
25079 if (pkt->pkt_state == STATE_GOT_BUS) {
25080 break;
25081 }
25082 /*FALLTHROUGH*/
25083
25084 case CMD_TIMEOUT:
25085 default:
25086 /*
25087 * The lun may still be running the command, so a lun reset
25088 * should be attempted. If the lun reset fails or cannot be
25089 * issued, than try a target reset. Lastly try a bus reset.
25090 */
25091 if ((pkt->pkt_statistics &
25092 (STAT_BUS_RESET|STAT_DEV_RESET|STAT_ABORTED)) == 0) {
25093 int reset_retval = 0;
25094 mutex_exit(SD_MUTEX(un));
25095 if (un->un_f_allow_bus_device_reset == TRUE) {
25096 if (un->un_f_lun_reset_enabled == TRUE) {
25097 reset_retval =
25098 scsi_reset(SD_ADDRESS(un),
25099 RESET_LUN);
25100 }
25101 if (reset_retval == 0) {
25102 reset_retval =
25103 scsi_reset(SD_ADDRESS(un),
25104 RESET_TARGET);
25105 }
25106 }
25107 if (reset_retval == 0) {
25108 (void) scsi_reset(SD_ADDRESS(un), RESET_ALL);
25109 }
25110 mutex_enter(SD_MUTEX(un));
25111 }
25112 break;
25113 }
25114
25115 /* A device/bus reset has occurred; update the reservation status. */
25116 if ((pkt->pkt_reason == CMD_RESET) || (pkt->pkt_statistics &
25117 (STAT_BUS_RESET | STAT_DEV_RESET))) {
25118 if ((un->un_resvd_status & SD_RESERVE) == SD_RESERVE) {
25119 un->un_resvd_status |=
25120 (SD_LOST_RESERVE | SD_WANT_RESERVE);
25121 SD_INFO(SD_LOG_IOCTL_MHD, un,
25122 "sd_mhd_watch_incomplete: Lost Reservation\n");
25123 }
25124 }
25125
25126 /*
25127 * The disk has been turned off; Update the device state.
25128 *
25129 * Note: Should we be offlining the disk here?
25130 */
25131 if (pkt->pkt_state == STATE_GOT_BUS) {
25132 SD_INFO(SD_LOG_IOCTL_MHD, un, "sd_mhd_watch_incomplete: "
25133 "Disk not responding to selection\n");
25134 if (un->un_state != SD_STATE_OFFLINE) {
25135 New_state(un, SD_STATE_OFFLINE);
25136 }
25137 } else if (be_chatty) {
25138 /*
25139 * suppress messages if they are all the same pkt reason;
25140 * with TQ, many (up to 256) are returned with the same
25141 * pkt_reason
25142 */
25143 if (pkt->pkt_reason != un->un_last_pkt_reason) {
25144 SD_ERROR(SD_LOG_IOCTL_MHD, un,
25145 "sd_mhd_watch_incomplete: "
25146 "SCSI transport failed: reason '%s'\n",
25147 scsi_rname(pkt->pkt_reason));
25148 }
25149 }
25150 un->un_last_pkt_reason = pkt->pkt_reason;
25151 mutex_exit(SD_MUTEX(un));
25152 }
25153
25154
25155 /*
25156 * Function: sd_sname()
25157 *
25158 * Description: This is a simple little routine to return a string containing
25159 * a printable description of command status byte for use in
25160 * logging.
25161 *
25162 * Arguments: status - pointer to a status byte
25163 *
25164 * Return Code: char * - string containing status description.
25165 */
25166
25167 static char *
25168 sd_sname(uchar_t status)
25169 {
25170 switch (status & STATUS_MASK) {
25171 case STATUS_GOOD:
25172 return ("good status");
25173 case STATUS_CHECK:
25174 return ("check condition");
25175 case STATUS_MET:
25176 return ("condition met");
25177 case STATUS_BUSY:
25178 return ("busy");
25179 case STATUS_INTERMEDIATE:
25180 return ("intermediate");
25181 case STATUS_INTERMEDIATE_MET:
25182 return ("intermediate - condition met");
25183 case STATUS_RESERVATION_CONFLICT:
25184 return ("reservation_conflict");
25185 case STATUS_TERMINATED:
25186 return ("command terminated");
25187 case STATUS_QFULL:
25188 return ("queue full");
25189 default:
25190 return ("<unknown status>");
25191 }
25192 }
25193
25194
25195 /*
25196 * Function: sd_mhd_resvd_recover()
25197 *
25198 * Description: This function adds a reservation entry to the
25199 * sd_resv_reclaim_request list and signals the reservation
25200 * reclaim thread that there is work pending. If the reservation
25201 * reclaim thread has not been previously created this function
25202 * will kick it off.
25203 *
25204 * Arguments: arg - the device 'dev_t' is used for context to discriminate
25205 * among multiple watches that share this callback function
25206 *
25207 * Context: This routine is called by timeout() and is run in interrupt
25208 * context. It must not sleep or call other functions which may
25209 * sleep.
25210 */
25211
25212 static void
25213 sd_mhd_resvd_recover(void *arg)
25214 {
25215 dev_t dev = (dev_t)arg;
25216 struct sd_lun *un;
25217 struct sd_thr_request *sd_treq = NULL;
25218 struct sd_thr_request *sd_cur = NULL;
25219 struct sd_thr_request *sd_prev = NULL;
25220 int already_there = 0;
25221
25222 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
25223 return;
25224 }
25225
25226 mutex_enter(SD_MUTEX(un));
25227 un->un_resvd_timeid = NULL;
25228 if (un->un_resvd_status & SD_WANT_RESERVE) {
25229 /*
25230 * There was a reset so don't issue the reserve, allow the
25231 * sd_mhd_watch_cb callback function to notice this and
25232 * reschedule the timeout for reservation.
25233 */
25234 mutex_exit(SD_MUTEX(un));
25235 return;
25236 }
25237 mutex_exit(SD_MUTEX(un));
25238
25239 /*
25240 * Add this device to the sd_resv_reclaim_request list and the
25241 * sd_resv_reclaim_thread should take care of the rest.
25242 *
25243 * Note: We can't sleep in this context so if the memory allocation
25244 * fails allow the sd_mhd_watch_cb callback function to notice this and
25245 * reschedule the timeout for reservation. (4378460)
25246 */
25247 sd_treq = (struct sd_thr_request *)
25248 kmem_zalloc(sizeof (struct sd_thr_request), KM_NOSLEEP);
25249 if (sd_treq == NULL) {
25250 return;
25251 }
25252
25253 sd_treq->sd_thr_req_next = NULL;
25254 sd_treq->dev = dev;
25255 mutex_enter(&sd_tr.srq_resv_reclaim_mutex);
25256 if (sd_tr.srq_thr_req_head == NULL) {
25257 sd_tr.srq_thr_req_head = sd_treq;
25258 } else {
25259 sd_cur = sd_prev = sd_tr.srq_thr_req_head;
25260 for (; sd_cur != NULL; sd_cur = sd_cur->sd_thr_req_next) {
25261 if (sd_cur->dev == dev) {
25262 /*
25263 * already in Queue so don't log
25264 * another request for the device
25265 */
25266 already_there = 1;
25267 break;
25268 }
25269 sd_prev = sd_cur;
25270 }
25271 if (!already_there) {
25272 SD_INFO(SD_LOG_IOCTL_MHD, un, "sd_mhd_resvd_recover: "
25273 "logging request for %lx\n", dev);
25274 sd_prev->sd_thr_req_next = sd_treq;
25275 } else {
25276 kmem_free(sd_treq, sizeof (struct sd_thr_request));
25277 }
25278 }
25279
25280 /*
25281 * Create a kernel thread to do the reservation reclaim and free up this
25282 * thread. We cannot block this thread while we go away to do the
25283 * reservation reclaim
25284 */
25285 if (sd_tr.srq_resv_reclaim_thread == NULL)
25286 sd_tr.srq_resv_reclaim_thread = thread_create(NULL, 0,
25287 sd_resv_reclaim_thread, NULL,
25288 0, &p0, TS_RUN, v.v_maxsyspri - 2);
25289
25290 /* Tell the reservation reclaim thread that it has work to do */
25291 cv_signal(&sd_tr.srq_resv_reclaim_cv);
25292 mutex_exit(&sd_tr.srq_resv_reclaim_mutex);
25293 }
25294
25295 /*
25296 * Function: sd_resv_reclaim_thread()
25297 *
25298 * Description: This function implements the reservation reclaim operations
25299 *
25300 * Arguments: arg - the device 'dev_t' is used for context to discriminate
25301 * among multiple watches that share this callback function
25302 */
25303
25304 static void
25305 sd_resv_reclaim_thread()
25306 {
25307 struct sd_lun *un;
25308 struct sd_thr_request *sd_mhreq;
25309
25310 /* Wait for work */
25311 mutex_enter(&sd_tr.srq_resv_reclaim_mutex);
25312 if (sd_tr.srq_thr_req_head == NULL) {
25313 cv_wait(&sd_tr.srq_resv_reclaim_cv,
25314 &sd_tr.srq_resv_reclaim_mutex);
25315 }
25316
25317 /* Loop while we have work */
25318 while ((sd_tr.srq_thr_cur_req = sd_tr.srq_thr_req_head) != NULL) {
25319 un = ddi_get_soft_state(sd_state,
25320 SDUNIT(sd_tr.srq_thr_cur_req->dev));
25321 if (un == NULL) {
25322 /*
25323 * softstate structure is NULL so just
25324 * dequeue the request and continue
25325 */
25326 sd_tr.srq_thr_req_head =
25327 sd_tr.srq_thr_cur_req->sd_thr_req_next;
25328 kmem_free(sd_tr.srq_thr_cur_req,
25329 sizeof (struct sd_thr_request));
25330 continue;
25331 }
25332
25333 /* dequeue the request */
25334 sd_mhreq = sd_tr.srq_thr_cur_req;
25335 sd_tr.srq_thr_req_head =
25336 sd_tr.srq_thr_cur_req->sd_thr_req_next;
25337 mutex_exit(&sd_tr.srq_resv_reclaim_mutex);
25338
25339 /*
25340 * Reclaim reservation only if SD_RESERVE is still set. There
25341 * may have been a call to MHIOCRELEASE before we got here.
25342 */
25343 mutex_enter(SD_MUTEX(un));
25344 if ((un->un_resvd_status & SD_RESERVE) == SD_RESERVE) {
25345 /*
25346 * Note: The SD_LOST_RESERVE flag is cleared before
25347 * reclaiming the reservation. If this is done after the
25348 * call to sd_reserve_release a reservation loss in the
25349 * window between pkt completion of reserve cmd and
25350 * mutex_enter below may not be recognized
25351 */
25352 un->un_resvd_status &= ~SD_LOST_RESERVE;
25353 mutex_exit(SD_MUTEX(un));
25354
25355 if (sd_reserve_release(sd_mhreq->dev,
25356 SD_RESERVE) == 0) {
25357 mutex_enter(SD_MUTEX(un));
25358 un->un_resvd_status |= SD_RESERVE;
25359 mutex_exit(SD_MUTEX(un));
25360 SD_INFO(SD_LOG_IOCTL_MHD, un,
25361 "sd_resv_reclaim_thread: "
25362 "Reservation Recovered\n");
25363 } else {
25364 mutex_enter(SD_MUTEX(un));
25365 un->un_resvd_status |= SD_LOST_RESERVE;
25366 mutex_exit(SD_MUTEX(un));
25367 SD_INFO(SD_LOG_IOCTL_MHD, un,
25368 "sd_resv_reclaim_thread: Failed "
25369 "Reservation Recovery\n");
25370 }
25371 } else {
25372 mutex_exit(SD_MUTEX(un));
25373 }
25374 mutex_enter(&sd_tr.srq_resv_reclaim_mutex);
25375 ASSERT(sd_mhreq == sd_tr.srq_thr_cur_req);
25376 kmem_free(sd_mhreq, sizeof (struct sd_thr_request));
25377 sd_mhreq = sd_tr.srq_thr_cur_req = NULL;
25378 /*
25379 * wakeup the destroy thread if anyone is waiting on
25380 * us to complete.
25381 */
25382 cv_signal(&sd_tr.srq_inprocess_cv);
25383 SD_TRACE(SD_LOG_IOCTL_MHD, un,
25384 "sd_resv_reclaim_thread: cv_signalling current request \n");
25385 }
25386
25387 /*
25388 * cleanup the sd_tr structure now that this thread will not exist
25389 */
25390 ASSERT(sd_tr.srq_thr_req_head == NULL);
25391 ASSERT(sd_tr.srq_thr_cur_req == NULL);
25392 sd_tr.srq_resv_reclaim_thread = NULL;
25393 mutex_exit(&sd_tr.srq_resv_reclaim_mutex);
25394 thread_exit();
25395 }
25396
25397
25398 /*
25399 * Function: sd_rmv_resv_reclaim_req()
25400 *
25401 * Description: This function removes any pending reservation reclaim requests
25402 * for the specified device.
25403 *
25404 * Arguments: dev - the device 'dev_t'
25405 */
25406
25407 static void
25408 sd_rmv_resv_reclaim_req(dev_t dev)
25409 {
25410 struct sd_thr_request *sd_mhreq;
25411 struct sd_thr_request *sd_prev;
25412
25413 /* Remove a reservation reclaim request from the list */
25414 mutex_enter(&sd_tr.srq_resv_reclaim_mutex);
25415 if (sd_tr.srq_thr_cur_req && sd_tr.srq_thr_cur_req->dev == dev) {
25416 /*
25417 * We are attempting to reinstate reservation for
25418 * this device. We wait for sd_reserve_release()
25419 * to return before we return.
25420 */
25421 cv_wait(&sd_tr.srq_inprocess_cv,
25422 &sd_tr.srq_resv_reclaim_mutex);
25423 } else {
25424 sd_prev = sd_mhreq = sd_tr.srq_thr_req_head;
25425 if (sd_mhreq && sd_mhreq->dev == dev) {
25426 sd_tr.srq_thr_req_head = sd_mhreq->sd_thr_req_next;
25427 kmem_free(sd_mhreq, sizeof (struct sd_thr_request));
25428 mutex_exit(&sd_tr.srq_resv_reclaim_mutex);
25429 return;
25430 }
25431 for (; sd_mhreq != NULL; sd_mhreq = sd_mhreq->sd_thr_req_next) {
25432 if (sd_mhreq && sd_mhreq->dev == dev) {
25433 break;
25434 }
25435 sd_prev = sd_mhreq;
25436 }
25437 if (sd_mhreq != NULL) {
25438 sd_prev->sd_thr_req_next = sd_mhreq->sd_thr_req_next;
25439 kmem_free(sd_mhreq, sizeof (struct sd_thr_request));
25440 }
25441 }
25442 mutex_exit(&sd_tr.srq_resv_reclaim_mutex);
25443 }
25444
25445
25446 /*
25447 * Function: sd_mhd_reset_notify_cb()
25448 *
25449 * Description: This is a call back function for scsi_reset_notify. This
25450 * function updates the softstate reserved status and logs the
25451 * reset. The driver scsi watch facility callback function
25452 * (sd_mhd_watch_cb) and reservation reclaim thread functionality
25453 * will reclaim the reservation.
25454 *
25455 * Arguments: arg - driver soft state (unit) structure
25456 */
25457
25458 static void
25459 sd_mhd_reset_notify_cb(caddr_t arg)
25460 {
25461 struct sd_lun *un = (struct sd_lun *)arg;
25462
25463 mutex_enter(SD_MUTEX(un));
25464 if ((un->un_resvd_status & SD_RESERVE) == SD_RESERVE) {
25465 un->un_resvd_status |= (SD_LOST_RESERVE | SD_WANT_RESERVE);
25466 SD_INFO(SD_LOG_IOCTL_MHD, un,
25467 "sd_mhd_reset_notify_cb: Lost Reservation\n");
25468 }
25469 mutex_exit(SD_MUTEX(un));
25470 }
25471
25472
25473 /*
25474 * Function: sd_take_ownership()
25475 *
25476 * Description: This routine implements an algorithm to achieve a stable
25477 * reservation on disks which don't implement priority reserve,
25478 * and makes sure that other host lose re-reservation attempts.
25479 * This algorithm contains of a loop that keeps issuing the RESERVE
25480 * for some period of time (min_ownership_delay, default 6 seconds)
25481 * During that loop, it looks to see if there has been a bus device
25482 * reset or bus reset (both of which cause an existing reservation
25483 * to be lost). If the reservation is lost issue RESERVE until a
25484 * period of min_ownership_delay with no resets has gone by, or
25485 * until max_ownership_delay has expired. This loop ensures that
25486 * the host really did manage to reserve the device, in spite of
25487 * resets. The looping for min_ownership_delay (default six
25488 * seconds) is important to early generation clustering products,
25489 * Solstice HA 1.x and Sun Cluster 2.x. Those products use an
25490 * MHIOCENFAILFAST periodic timer of two seconds. By having
25491 * MHIOCTKOWN issue Reserves in a loop for six seconds, and having
25492 * MHIOCENFAILFAST poll every two seconds, the idea is that by the
25493 * time the MHIOCTKOWN ioctl returns, the other host (if any) will
25494 * have already noticed, via the MHIOCENFAILFAST polling, that it
25495 * no longer "owns" the disk and will have panicked itself. Thus,
25496 * the host issuing the MHIOCTKOWN is assured (with timing
25497 * dependencies) that by the time it actually starts to use the
25498 * disk for real work, the old owner is no longer accessing it.
25499 *
25500 * min_ownership_delay is the minimum amount of time for which the
25501 * disk must be reserved continuously devoid of resets before the
25502 * MHIOCTKOWN ioctl will return success.
25503 *
25504 * max_ownership_delay indicates the amount of time by which the
25505 * take ownership should succeed or timeout with an error.
25506 *
25507 * Arguments: dev - the device 'dev_t'
25508 * *p - struct containing timing info.
25509 *
25510 * Return Code: 0 for success or error code
25511 */
25512
25513 static int
25514 sd_take_ownership(dev_t dev, struct mhioctkown *p)
25515 {
25516 struct sd_lun *un;
25517 int rval;
25518 int err;
25519 int reservation_count = 0;
25520 int min_ownership_delay = 6000000; /* in usec */
25521 int max_ownership_delay = 30000000; /* in usec */
25522 clock_t start_time; /* starting time of this algorithm */
25523 clock_t end_time; /* time limit for giving up */
25524 clock_t ownership_time; /* time limit for stable ownership */
25525 clock_t current_time;
25526 clock_t previous_current_time;
25527
25528 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
25529 return (ENXIO);
25530 }
25531
25532 /*
25533 * Attempt a device reservation. A priority reservation is requested.
25534 */
25535 if ((rval = sd_reserve_release(dev, SD_PRIORITY_RESERVE))
25536 != SD_SUCCESS) {
25537 SD_ERROR(SD_LOG_IOCTL_MHD, un,
25538 "sd_take_ownership: return(1)=%d\n", rval);
25539 return (rval);
25540 }
25541
25542 /* Update the softstate reserved status to indicate the reservation */
25543 mutex_enter(SD_MUTEX(un));
25544 un->un_resvd_status |= SD_RESERVE;
25545 un->un_resvd_status &=
25546 ~(SD_LOST_RESERVE | SD_WANT_RESERVE | SD_RESERVATION_CONFLICT);
25547 mutex_exit(SD_MUTEX(un));
25548
25549 if (p != NULL) {
25550 if (p->min_ownership_delay != 0) {
25551 min_ownership_delay = p->min_ownership_delay * 1000;
25552 }
25553 if (p->max_ownership_delay != 0) {
25554 max_ownership_delay = p->max_ownership_delay * 1000;
25555 }
25556 }
25557 SD_INFO(SD_LOG_IOCTL_MHD, un,
25558 "sd_take_ownership: min, max delays: %d, %d\n",
25559 min_ownership_delay, max_ownership_delay);
25560
25561 start_time = ddi_get_lbolt();
25562 current_time = start_time;
25563 ownership_time = current_time + drv_usectohz(min_ownership_delay);
25564 end_time = start_time + drv_usectohz(max_ownership_delay);
25565
25566 while (current_time - end_time < 0) {
25567 delay(drv_usectohz(500000));
25568
25569 if ((err = sd_reserve_release(dev, SD_RESERVE)) != 0) {
25570 if ((sd_reserve_release(dev, SD_RESERVE)) != 0) {
25571 mutex_enter(SD_MUTEX(un));
25572 rval = (un->un_resvd_status &
25573 SD_RESERVATION_CONFLICT) ? EACCES : EIO;
25574 mutex_exit(SD_MUTEX(un));
25575 break;
25576 }
25577 }
25578 previous_current_time = current_time;
25579 current_time = ddi_get_lbolt();
25580 mutex_enter(SD_MUTEX(un));
25581 if (err || (un->un_resvd_status & SD_LOST_RESERVE)) {
25582 ownership_time = ddi_get_lbolt() +
25583 drv_usectohz(min_ownership_delay);
25584 reservation_count = 0;
25585 } else {
25586 reservation_count++;
25587 }
25588 un->un_resvd_status |= SD_RESERVE;
25589 un->un_resvd_status &= ~(SD_LOST_RESERVE | SD_WANT_RESERVE);
25590 mutex_exit(SD_MUTEX(un));
25591
25592 SD_INFO(SD_LOG_IOCTL_MHD, un,
25593 "sd_take_ownership: ticks for loop iteration=%ld, "
25594 "reservation=%s\n", (current_time - previous_current_time),
25595 reservation_count ? "ok" : "reclaimed");
25596
25597 if (current_time - ownership_time >= 0 &&
25598 reservation_count >= 4) {
25599 rval = 0; /* Achieved a stable ownership */
25600 break;
25601 }
25602 if (current_time - end_time >= 0) {
25603 rval = EACCES; /* No ownership in max possible time */
25604 break;
25605 }
25606 }
25607 SD_TRACE(SD_LOG_IOCTL_MHD, un,
25608 "sd_take_ownership: return(2)=%d\n", rval);
25609 return (rval);
25610 }
25611
25612
25613 /*
25614 * Function: sd_reserve_release()
25615 *
25616 * Description: This function builds and sends scsi RESERVE, RELEASE, and
25617 * PRIORITY RESERVE commands based on a user specified command type
25618 *
25619 * Arguments: dev - the device 'dev_t'
25620 * cmd - user specified command type; one of SD_PRIORITY_RESERVE,
25621 * SD_RESERVE, SD_RELEASE
25622 *
25623 * Return Code: 0 or Error Code
25624 */
25625
25626 static int
25627 sd_reserve_release(dev_t dev, int cmd)
25628 {
25629 struct uscsi_cmd *com = NULL;
25630 struct sd_lun *un = NULL;
25631 char cdb[CDB_GROUP0];
25632 int rval;
25633
25634 ASSERT((cmd == SD_RELEASE) || (cmd == SD_RESERVE) ||
25635 (cmd == SD_PRIORITY_RESERVE));
25636
25637 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
25638 return (ENXIO);
25639 }
25640
25641 /* instantiate and initialize the command and cdb */
25642 com = kmem_zalloc(sizeof (*com), KM_SLEEP);
25643 bzero(cdb, CDB_GROUP0);
25644 com->uscsi_flags = USCSI_SILENT;
25645 com->uscsi_timeout = un->un_reserve_release_time;
25646 com->uscsi_cdblen = CDB_GROUP0;
25647 com->uscsi_cdb = cdb;
25648 if (cmd == SD_RELEASE) {
25649 cdb[0] = SCMD_RELEASE;
25650 } else {
25651 cdb[0] = SCMD_RESERVE;
25652 }
25653
25654 /* Send the command. */
25655 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_SYSSPACE,
25656 SD_PATH_STANDARD);
25657
25658 /*
25659 * "break" a reservation that is held by another host, by issuing a
25660 * reset if priority reserve is desired, and we could not get the
25661 * device.
25662 */
25663 if ((cmd == SD_PRIORITY_RESERVE) &&
25664 (rval != 0) && (com->uscsi_status == STATUS_RESERVATION_CONFLICT)) {
25665 /*
25666 * First try to reset the LUN. If we cannot, then try a target
25667 * reset, followed by a bus reset if the target reset fails.
25668 */
25669 int reset_retval = 0;
25670 if (un->un_f_lun_reset_enabled == TRUE) {
25671 reset_retval = scsi_reset(SD_ADDRESS(un), RESET_LUN);
25672 }
25673 if (reset_retval == 0) {
25674 /* The LUN reset either failed or was not issued */
25675 reset_retval = scsi_reset(SD_ADDRESS(un), RESET_TARGET);
25676 }
25677 if ((reset_retval == 0) &&
25678 (scsi_reset(SD_ADDRESS(un), RESET_ALL) == 0)) {
25679 rval = EIO;
25680 kmem_free(com, sizeof (*com));
25681 return (rval);
25682 }
25683
25684 bzero(com, sizeof (struct uscsi_cmd));
25685 com->uscsi_flags = USCSI_SILENT;
25686 com->uscsi_cdb = cdb;
25687 com->uscsi_cdblen = CDB_GROUP0;
25688 com->uscsi_timeout = 5;
25689
25690 /*
25691 * Reissue the last reserve command, this time without request
25692 * sense. Assume that it is just a regular reserve command.
25693 */
25694 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_SYSSPACE,
25695 SD_PATH_STANDARD);
25696 }
25697
25698 /* Return an error if still getting a reservation conflict. */
25699 if ((rval != 0) && (com->uscsi_status == STATUS_RESERVATION_CONFLICT)) {
25700 rval = EACCES;
25701 }
25702
25703 kmem_free(com, sizeof (*com));
25704 return (rval);
25705 }
25706
25707
25708 #define SD_NDUMP_RETRIES 12
25709 /*
25710 * System Crash Dump routine
25711 */
25712
25713 static int
25714 sddump(dev_t dev, caddr_t addr, daddr_t blkno, int nblk)
25715 {
25716 int instance;
25717 int partition;
25718 int i;
25719 int err;
25720 struct sd_lun *un;
25721 struct scsi_pkt *wr_pktp;
25722 struct buf *wr_bp;
25723 struct buf wr_buf;
25724 daddr_t tgt_byte_offset; /* rmw - byte offset for target */
25725 daddr_t tgt_blkno; /* rmw - blkno for target */
25726 size_t tgt_byte_count; /* rmw - # of bytes to xfer */
25727 size_t tgt_nblk; /* rmw - # of tgt blks to xfer */
25728 size_t io_start_offset;
25729 int doing_rmw = FALSE;
25730 int rval;
25731 ssize_t dma_resid;
25732 daddr_t oblkno;
25733 diskaddr_t nblks = 0;
25734 diskaddr_t start_block;
25735
25736 instance = SDUNIT(dev);
25737 if (((un = ddi_get_soft_state(sd_state, instance)) == NULL) ||
25738 !SD_IS_VALID_LABEL(un) || ISCD(un)) {
25739 return (ENXIO);
25740 }
25741
25742 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*un))
25743
25744 SD_TRACE(SD_LOG_DUMP, un, "sddump: entry\n");
25745
25746 partition = SDPART(dev);
25747 SD_INFO(SD_LOG_DUMP, un, "sddump: partition = %d\n", partition);
25748
25749 if (!(NOT_DEVBSIZE(un))) {
25750 int secmask = 0;
25751 int blknomask = 0;
25752
25753 blknomask = (un->un_tgt_blocksize / DEV_BSIZE) - 1;
25754 secmask = un->un_tgt_blocksize - 1;
25755
25756 if (blkno & blknomask) {
25757 SD_TRACE(SD_LOG_DUMP, un,
25758 "sddump: dump start block not modulo %d\n",
25759 un->un_tgt_blocksize);
25760 return (EINVAL);
25761 }
25762
25763 if ((nblk * DEV_BSIZE) & secmask) {
25764 SD_TRACE(SD_LOG_DUMP, un,
25765 "sddump: dump length not modulo %d\n",
25766 un->un_tgt_blocksize);
25767 return (EINVAL);
25768 }
25769
25770 }
25771
25772 /* Validate blocks to dump at against partition size. */
25773
25774 (void) cmlb_partinfo(un->un_cmlbhandle, partition,
25775 &nblks, &start_block, NULL, NULL, (void *)SD_PATH_DIRECT);
25776
25777 if (NOT_DEVBSIZE(un)) {
25778 if ((blkno + nblk) > nblks) {
25779 SD_TRACE(SD_LOG_DUMP, un,
25780 "sddump: dump range larger than partition: "
25781 "blkno = 0x%x, nblk = 0x%x, dkl_nblk = 0x%x\n",
25782 blkno, nblk, nblks);
25783 return (EINVAL);
25784 }
25785 } else {
25786 if (((blkno / (un->un_tgt_blocksize / DEV_BSIZE)) +
25787 (nblk / (un->un_tgt_blocksize / DEV_BSIZE))) > nblks) {
25788 SD_TRACE(SD_LOG_DUMP, un,
25789 "sddump: dump range larger than partition: "
25790 "blkno = 0x%x, nblk = 0x%x, dkl_nblk = 0x%x\n",
25791 blkno, nblk, nblks);
25792 return (EINVAL);
25793 }
25794 }
25795
25796 mutex_enter(&un->un_pm_mutex);
25797 if (SD_DEVICE_IS_IN_LOW_POWER(un)) {
25798 struct scsi_pkt *start_pktp;
25799
25800 mutex_exit(&un->un_pm_mutex);
25801
25802 /*
25803 * use pm framework to power on HBA 1st
25804 */
25805 (void) pm_raise_power(SD_DEVINFO(un), 0,
25806 SD_PM_STATE_ACTIVE(un));
25807
25808 /*
25809 * Dump no long uses sdpower to power on a device, it's
25810 * in-line here so it can be done in polled mode.
25811 */
25812
25813 SD_INFO(SD_LOG_DUMP, un, "sddump: starting device\n");
25814
25815 start_pktp = scsi_init_pkt(SD_ADDRESS(un), NULL, NULL,
25816 CDB_GROUP0, un->un_status_len, 0, 0, NULL_FUNC, NULL);
25817
25818 if (start_pktp == NULL) {
25819 /* We were not given a SCSI packet, fail. */
25820 return (EIO);
25821 }
25822 bzero(start_pktp->pkt_cdbp, CDB_GROUP0);
25823 start_pktp->pkt_cdbp[0] = SCMD_START_STOP;
25824 start_pktp->pkt_cdbp[4] = SD_TARGET_START;
25825 start_pktp->pkt_flags = FLAG_NOINTR;
25826
25827 mutex_enter(SD_MUTEX(un));
25828 SD_FILL_SCSI1_LUN(un, start_pktp);
25829 mutex_exit(SD_MUTEX(un));
25830 /*
25831 * Scsi_poll returns 0 (success) if the command completes and
25832 * the status block is STATUS_GOOD.
25833 */
25834 if (sd_scsi_poll(un, start_pktp) != 0) {
25835 scsi_destroy_pkt(start_pktp);
25836 return (EIO);
25837 }
25838 scsi_destroy_pkt(start_pktp);
25839 (void) sd_pm_state_change(un, SD_PM_STATE_ACTIVE(un),
25840 SD_PM_STATE_CHANGE);
25841 } else {
25842 mutex_exit(&un->un_pm_mutex);
25843 }
25844
25845 mutex_enter(SD_MUTEX(un));
25846 un->un_throttle = 0;
25847
25848 /*
25849 * The first time through, reset the specific target device.
25850 * However, when cpr calls sddump we know that sd is in a
25851 * a good state so no bus reset is required.
25852 * Clear sense data via Request Sense cmd.
25853 * In sddump we don't care about allow_bus_device_reset anymore
25854 */
25855
25856 if ((un->un_state != SD_STATE_SUSPENDED) &&
25857 (un->un_state != SD_STATE_DUMPING)) {
25858
25859 New_state(un, SD_STATE_DUMPING);
25860
25861 if (un->un_f_is_fibre == FALSE) {
25862 mutex_exit(SD_MUTEX(un));
25863 /*
25864 * Attempt a bus reset for parallel scsi.
25865 *
25866 * Note: A bus reset is required because on some host
25867 * systems (i.e. E420R) a bus device reset is
25868 * insufficient to reset the state of the target.
25869 *
25870 * Note: Don't issue the reset for fibre-channel,
25871 * because this tends to hang the bus (loop) for
25872 * too long while everyone is logging out and in
25873 * and the deadman timer for dumping will fire
25874 * before the dump is complete.
25875 */
25876 if (scsi_reset(SD_ADDRESS(un), RESET_ALL) == 0) {
25877 mutex_enter(SD_MUTEX(un));
25878 Restore_state(un);
25879 mutex_exit(SD_MUTEX(un));
25880 return (EIO);
25881 }
25882
25883 /* Delay to give the device some recovery time. */
25884 drv_usecwait(10000);
25885
25886 if (sd_send_polled_RQS(un) == SD_FAILURE) {
25887 SD_INFO(SD_LOG_DUMP, un,
25888 "sddump: sd_send_polled_RQS failed\n");
25889 }
25890 mutex_enter(SD_MUTEX(un));
25891 }
25892 }
25893
25894 /*
25895 * Convert the partition-relative block number to a
25896 * disk physical block number.
25897 */
25898 if (NOT_DEVBSIZE(un)) {
25899 blkno += start_block;
25900 } else {
25901 blkno = blkno / (un->un_tgt_blocksize / DEV_BSIZE);
25902 blkno += start_block;
25903 }
25904
25905 SD_INFO(SD_LOG_DUMP, un, "sddump: disk blkno = 0x%x\n", blkno);
25906
25907
25908 /*
25909 * Check if the device has a non-512 block size.
25910 */
25911 wr_bp = NULL;
25912 if (NOT_DEVBSIZE(un)) {
25913 tgt_byte_offset = blkno * un->un_sys_blocksize;
25914 tgt_byte_count = nblk * un->un_sys_blocksize;
25915 if ((tgt_byte_offset % un->un_tgt_blocksize) ||
25916 (tgt_byte_count % un->un_tgt_blocksize)) {
25917 doing_rmw = TRUE;
25918 /*
25919 * Calculate the block number and number of block
25920 * in terms of the media block size.
25921 */
25922 tgt_blkno = tgt_byte_offset / un->un_tgt_blocksize;
25923 tgt_nblk =
25924 ((tgt_byte_offset + tgt_byte_count +
25925 (un->un_tgt_blocksize - 1)) /
25926 un->un_tgt_blocksize) - tgt_blkno;
25927
25928 /*
25929 * Invoke the routine which is going to do read part
25930 * of read-modify-write.
25931 * Note that this routine returns a pointer to
25932 * a valid bp in wr_bp.
25933 */
25934 err = sddump_do_read_of_rmw(un, tgt_blkno, tgt_nblk,
25935 &wr_bp);
25936 if (err) {
25937 mutex_exit(SD_MUTEX(un));
25938 return (err);
25939 }
25940 /*
25941 * Offset is being calculated as -
25942 * (original block # * system block size) -
25943 * (new block # * target block size)
25944 */
25945 io_start_offset =
25946 ((uint64_t)(blkno * un->un_sys_blocksize)) -
25947 ((uint64_t)(tgt_blkno * un->un_tgt_blocksize));
25948
25949 ASSERT(io_start_offset < un->un_tgt_blocksize);
25950 /*
25951 * Do the modify portion of read modify write.
25952 */
25953 bcopy(addr, &wr_bp->b_un.b_addr[io_start_offset],
25954 (size_t)nblk * un->un_sys_blocksize);
25955 } else {
25956 doing_rmw = FALSE;
25957 tgt_blkno = tgt_byte_offset / un->un_tgt_blocksize;
25958 tgt_nblk = tgt_byte_count / un->un_tgt_blocksize;
25959 }
25960
25961 /* Convert blkno and nblk to target blocks */
25962 blkno = tgt_blkno;
25963 nblk = tgt_nblk;
25964 } else {
25965 wr_bp = &wr_buf;
25966 bzero(wr_bp, sizeof (struct buf));
25967 wr_bp->b_flags = B_BUSY;
25968 wr_bp->b_un.b_addr = addr;
25969 wr_bp->b_bcount = nblk << DEV_BSHIFT;
25970 wr_bp->b_resid = 0;
25971 }
25972
25973 mutex_exit(SD_MUTEX(un));
25974
25975 /*
25976 * Obtain a SCSI packet for the write command.
25977 * It should be safe to call the allocator here without
25978 * worrying about being locked for DVMA mapping because
25979 * the address we're passed is already a DVMA mapping
25980 *
25981 * We are also not going to worry about semaphore ownership
25982 * in the dump buffer. Dumping is single threaded at present.
25983 */
25984
25985 wr_pktp = NULL;
25986
25987 dma_resid = wr_bp->b_bcount;
25988 oblkno = blkno;
25989
25990 if (!(NOT_DEVBSIZE(un))) {
25991 nblk = nblk / (un->un_tgt_blocksize / DEV_BSIZE);
25992 }
25993
25994 while (dma_resid != 0) {
25995
25996 for (i = 0; i < SD_NDUMP_RETRIES; i++) {
25997 wr_bp->b_flags &= ~B_ERROR;
25998
25999 if (un->un_partial_dma_supported == 1) {
26000 blkno = oblkno +
26001 ((wr_bp->b_bcount - dma_resid) /
26002 un->un_tgt_blocksize);
26003 nblk = dma_resid / un->un_tgt_blocksize;
26004
26005 if (wr_pktp) {
26006 /*
26007 * Partial DMA transfers after initial transfer
26008 */
26009 rval = sd_setup_next_rw_pkt(un, wr_pktp, wr_bp,
26010 blkno, nblk);
26011 } else {
26012 /* Initial transfer */
26013 rval = sd_setup_rw_pkt(un, &wr_pktp, wr_bp,
26014 un->un_pkt_flags, NULL_FUNC, NULL,
26015 blkno, nblk);
26016 }
26017 } else {
26018 rval = sd_setup_rw_pkt(un, &wr_pktp, wr_bp,
26019 0, NULL_FUNC, NULL, blkno, nblk);
26020 }
26021
26022 if (rval == 0) {
26023 /* We were given a SCSI packet, continue. */
26024 break;
26025 }
26026
26027 if (i == 0) {
26028 if (wr_bp->b_flags & B_ERROR) {
26029 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
26030 "no resources for dumping; "
26031 "error code: 0x%x, retrying",
26032 geterror(wr_bp));
26033 } else {
26034 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
26035 "no resources for dumping; retrying");
26036 }
26037 } else if (i != (SD_NDUMP_RETRIES - 1)) {
26038 if (wr_bp->b_flags & B_ERROR) {
26039 scsi_log(SD_DEVINFO(un), sd_label, CE_CONT,
26040 "no resources for dumping; error code: "
26041 "0x%x, retrying\n", geterror(wr_bp));
26042 }
26043 } else {
26044 if (wr_bp->b_flags & B_ERROR) {
26045 scsi_log(SD_DEVINFO(un), sd_label, CE_CONT,
26046 "no resources for dumping; "
26047 "error code: 0x%x, retries failed, "
26048 "giving up.\n", geterror(wr_bp));
26049 } else {
26050 scsi_log(SD_DEVINFO(un), sd_label, CE_CONT,
26051 "no resources for dumping; "
26052 "retries failed, giving up.\n");
26053 }
26054 mutex_enter(SD_MUTEX(un));
26055 Restore_state(un);
26056 if (NOT_DEVBSIZE(un) && (doing_rmw == TRUE)) {
26057 mutex_exit(SD_MUTEX(un));
26058 scsi_free_consistent_buf(wr_bp);
26059 } else {
26060 mutex_exit(SD_MUTEX(un));
26061 }
26062 return (EIO);
26063 }
26064 drv_usecwait(10000);
26065 }
26066
26067 if (un->un_partial_dma_supported == 1) {
26068 /*
26069 * save the resid from PARTIAL_DMA
26070 */
26071 dma_resid = wr_pktp->pkt_resid;
26072 if (dma_resid != 0)
26073 nblk -= SD_BYTES2TGTBLOCKS(un, dma_resid);
26074 wr_pktp->pkt_resid = 0;
26075 } else {
26076 dma_resid = 0;
26077 }
26078
26079 /* SunBug 1222170 */
26080 wr_pktp->pkt_flags = FLAG_NOINTR;
26081
26082 err = EIO;
26083 for (i = 0; i < SD_NDUMP_RETRIES; i++) {
26084
26085 /*
26086 * Scsi_poll returns 0 (success) if the command completes and
26087 * the status block is STATUS_GOOD. We should only check
26088 * errors if this condition is not true. Even then we should
26089 * send our own request sense packet only if we have a check
26090 * condition and auto request sense has not been performed by
26091 * the hba.
26092 */
26093 SD_TRACE(SD_LOG_DUMP, un, "sddump: sending write\n");
26094
26095 if ((sd_scsi_poll(un, wr_pktp) == 0) &&
26096 (wr_pktp->pkt_resid == 0)) {
26097 err = SD_SUCCESS;
26098 break;
26099 }
26100
26101 /*
26102 * Check CMD_DEV_GONE 1st, give up if device is gone.
26103 */
26104 if (wr_pktp->pkt_reason == CMD_DEV_GONE) {
26105 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
26106 "Error while dumping state...Device is gone\n");
26107 break;
26108 }
26109
26110 if (SD_GET_PKT_STATUS(wr_pktp) == STATUS_CHECK) {
26111 SD_INFO(SD_LOG_DUMP, un,
26112 "sddump: write failed with CHECK, try # %d\n", i);
26113 if (((wr_pktp->pkt_state & STATE_ARQ_DONE) == 0)) {
26114 (void) sd_send_polled_RQS(un);
26115 }
26116
26117 continue;
26118 }
26119
26120 if (SD_GET_PKT_STATUS(wr_pktp) == STATUS_BUSY) {
26121 int reset_retval = 0;
26122
26123 SD_INFO(SD_LOG_DUMP, un,
26124 "sddump: write failed with BUSY, try # %d\n", i);
26125
26126 if (un->un_f_lun_reset_enabled == TRUE) {
26127 reset_retval = scsi_reset(SD_ADDRESS(un),
26128 RESET_LUN);
26129 }
26130 if (reset_retval == 0) {
26131 (void) scsi_reset(SD_ADDRESS(un), RESET_TARGET);
26132 }
26133 (void) sd_send_polled_RQS(un);
26134
26135 } else {
26136 SD_INFO(SD_LOG_DUMP, un,
26137 "sddump: write failed with 0x%x, try # %d\n",
26138 SD_GET_PKT_STATUS(wr_pktp), i);
26139 mutex_enter(SD_MUTEX(un));
26140 sd_reset_target(un, wr_pktp);
26141 mutex_exit(SD_MUTEX(un));
26142 }
26143
26144 /*
26145 * If we are not getting anywhere with lun/target resets,
26146 * let's reset the bus.
26147 */
26148 if (i == SD_NDUMP_RETRIES/2) {
26149 (void) scsi_reset(SD_ADDRESS(un), RESET_ALL);
26150 (void) sd_send_polled_RQS(un);
26151 }
26152 }
26153 }
26154
26155 scsi_destroy_pkt(wr_pktp);
26156 mutex_enter(SD_MUTEX(un));
26157 if ((NOT_DEVBSIZE(un)) && (doing_rmw == TRUE)) {
26158 mutex_exit(SD_MUTEX(un));
26159 scsi_free_consistent_buf(wr_bp);
26160 } else {
26161 mutex_exit(SD_MUTEX(un));
26162 }
26163 SD_TRACE(SD_LOG_DUMP, un, "sddump: exit: err = %d\n", err);
26164 return (err);
26165 }
26166
26167 /*
26168 * Function: sd_scsi_poll()
26169 *
26170 * Description: This is a wrapper for the scsi_poll call.
26171 *
26172 * Arguments: sd_lun - The unit structure
26173 * scsi_pkt - The scsi packet being sent to the device.
26174 *
26175 * Return Code: 0 - Command completed successfully with good status
26176 * -1 - Command failed. This could indicate a check condition
26177 * or other status value requiring recovery action.
26178 *
26179 * NOTE: This code is only called off sddump().
26180 */
26181
26182 static int
26183 sd_scsi_poll(struct sd_lun *un, struct scsi_pkt *pktp)
26184 {
26185 int status;
26186
26187 ASSERT(un != NULL);
26188 ASSERT(!mutex_owned(SD_MUTEX(un)));
26189 ASSERT(pktp != NULL);
26190
26191 status = SD_SUCCESS;
26192
26193 if (scsi_ifgetcap(&pktp->pkt_address, "tagged-qing", 1) == 1) {
26194 pktp->pkt_flags |= un->un_tagflags;
26195 pktp->pkt_flags &= ~FLAG_NODISCON;
26196 }
26197
26198 status = sd_ddi_scsi_poll(pktp);
26199 /*
26200 * Scsi_poll returns 0 (success) if the command completes and the
26201 * status block is STATUS_GOOD. We should only check errors if this
26202 * condition is not true. Even then we should send our own request
26203 * sense packet only if we have a check condition and auto
26204 * request sense has not been performed by the hba.
26205 * Don't get RQS data if pkt_reason is CMD_DEV_GONE.
26206 */
26207 if ((status != SD_SUCCESS) &&
26208 (SD_GET_PKT_STATUS(pktp) == STATUS_CHECK) &&
26209 (pktp->pkt_state & STATE_ARQ_DONE) == 0 &&
26210 (pktp->pkt_reason != CMD_DEV_GONE))
26211 (void) sd_send_polled_RQS(un);
26212
26213 return (status);
26214 }
26215
26216 /*
26217 * Function: sd_send_polled_RQS()
26218 *
26219 * Description: This sends the request sense command to a device.
26220 *
26221 * Arguments: sd_lun - The unit structure
26222 *
26223 * Return Code: 0 - Command completed successfully with good status
26224 * -1 - Command failed.
26225 *
26226 */
26227
26228 static int
26229 sd_send_polled_RQS(struct sd_lun *un)
26230 {
26231 int ret_val;
26232 struct scsi_pkt *rqs_pktp;
26233 struct buf *rqs_bp;
26234
26235 ASSERT(un != NULL);
26236 ASSERT(!mutex_owned(SD_MUTEX(un)));
26237
26238 ret_val = SD_SUCCESS;
26239
26240 rqs_pktp = un->un_rqs_pktp;
26241 rqs_bp = un->un_rqs_bp;
26242
26243 mutex_enter(SD_MUTEX(un));
26244
26245 if (un->un_sense_isbusy) {
26246 ret_val = SD_FAILURE;
26247 mutex_exit(SD_MUTEX(un));
26248 return (ret_val);
26249 }
26250
26251 /*
26252 * If the request sense buffer (and packet) is not in use,
26253 * let's set the un_sense_isbusy and send our packet
26254 */
26255 un->un_sense_isbusy = 1;
26256 rqs_pktp->pkt_resid = 0;
26257 rqs_pktp->pkt_reason = 0;
26258 rqs_pktp->pkt_flags |= FLAG_NOINTR;
26259 bzero(rqs_bp->b_un.b_addr, SENSE_LENGTH);
26260
26261 mutex_exit(SD_MUTEX(un));
26262
26263 SD_INFO(SD_LOG_COMMON, un, "sd_send_polled_RQS: req sense buf at"
26264 " 0x%p\n", rqs_bp->b_un.b_addr);
26265
26266 /*
26267 * Can't send this to sd_scsi_poll, we wrap ourselves around the
26268 * axle - it has a call into us!
26269 */
26270 if ((ret_val = sd_ddi_scsi_poll(rqs_pktp)) != 0) {
26271 SD_INFO(SD_LOG_COMMON, un,
26272 "sd_send_polled_RQS: RQS failed\n");
26273 }
26274
26275 SD_DUMP_MEMORY(un, SD_LOG_COMMON, "sd_send_polled_RQS:",
26276 (uchar_t *)rqs_bp->b_un.b_addr, SENSE_LENGTH, SD_LOG_HEX);
26277
26278 mutex_enter(SD_MUTEX(un));
26279 un->un_sense_isbusy = 0;
26280 mutex_exit(SD_MUTEX(un));
26281
26282 return (ret_val);
26283 }
26284
26285 /*
26286 * Defines needed for localized version of the scsi_poll routine.
26287 */
26288 #define CSEC 10000 /* usecs */
26289 #define SEC_TO_CSEC (1000000/CSEC)
26290
26291 /*
26292 * Function: sd_ddi_scsi_poll()
26293 *
26294 * Description: Localized version of the scsi_poll routine. The purpose is to
26295 * send a scsi_pkt to a device as a polled command. This version
26296 * is to ensure more robust handling of transport errors.
26297 * Specifically this routine cures not ready, coming ready
26298 * transition for power up and reset of sonoma's. This can take
26299 * up to 45 seconds for power-on and 20 seconds for reset of a
26300 * sonoma lun.
26301 *
26302 * Arguments: scsi_pkt - The scsi_pkt being sent to a device
26303 *
26304 * Return Code: 0 - Command completed successfully with good status
26305 * -1 - Command failed.
26306 *
26307 * NOTE: This code is almost identical to scsi_poll, however before 6668774 can
26308 * be fixed (removing this code), we need to determine how to handle the
26309 * KEY_UNIT_ATTENTION condition below in conditions not as limited as sddump().
26310 *
26311 * NOTE: This code is only called off sddump().
26312 */
26313 static int
26314 sd_ddi_scsi_poll(struct scsi_pkt *pkt)
26315 {
26316 int rval = -1;
26317 int savef;
26318 long savet;
26319 void (*savec)();
26320 int timeout;
26321 int busy_count;
26322 int poll_delay;
26323 int rc;
26324 uint8_t *sensep;
26325 struct scsi_arq_status *arqstat;
26326 extern int do_polled_io;
26327
26328 ASSERT(pkt->pkt_scbp);
26329
26330 /*
26331 * save old flags..
26332 */
26333 savef = pkt->pkt_flags;
26334 savec = pkt->pkt_comp;
26335 savet = pkt->pkt_time;
26336
26337 pkt->pkt_flags |= FLAG_NOINTR;
26338
26339 /*
26340 * XXX there is nothing in the SCSA spec that states that we should not
26341 * do a callback for polled cmds; however, removing this will break sd
26342 * and probably other target drivers
26343 */
26344 pkt->pkt_comp = NULL;
26345
26346 /*
26347 * we don't like a polled command without timeout.
26348 * 60 seconds seems long enough.
26349 */
26350 if (pkt->pkt_time == 0)
26351 pkt->pkt_time = SCSI_POLL_TIMEOUT;
26352
26353 /*
26354 * Send polled cmd.
26355 *
26356 * We do some error recovery for various errors. Tran_busy,
26357 * queue full, and non-dispatched commands are retried every 10 msec.
26358 * as they are typically transient failures. Busy status and Not
26359 * Ready are retried every second as this status takes a while to
26360 * change.
26361 */
26362 timeout = pkt->pkt_time * SEC_TO_CSEC;
26363
26364 for (busy_count = 0; busy_count < timeout; busy_count++) {
26365 /*
26366 * Initialize pkt status variables.
26367 */
26368 *pkt->pkt_scbp = pkt->pkt_reason = pkt->pkt_state = 0;
26369
26370 if ((rc = scsi_transport(pkt)) != TRAN_ACCEPT) {
26371 if (rc != TRAN_BUSY) {
26372 /* Transport failed - give up. */
26373 break;
26374 } else {
26375 /* Transport busy - try again. */
26376 poll_delay = 1 * CSEC; /* 10 msec. */
26377 }
26378 } else {
26379 /*
26380 * Transport accepted - check pkt status.
26381 */
26382 rc = (*pkt->pkt_scbp) & STATUS_MASK;
26383 if ((pkt->pkt_reason == CMD_CMPLT) &&
26384 (rc == STATUS_CHECK) &&
26385 (pkt->pkt_state & STATE_ARQ_DONE)) {
26386 arqstat =
26387 (struct scsi_arq_status *)(pkt->pkt_scbp);
26388 sensep = (uint8_t *)&arqstat->sts_sensedata;
26389 } else {
26390 sensep = NULL;
26391 }
26392
26393 if ((pkt->pkt_reason == CMD_CMPLT) &&
26394 (rc == STATUS_GOOD)) {
26395 /* No error - we're done */
26396 rval = 0;
26397 break;
26398
26399 } else if (pkt->pkt_reason == CMD_DEV_GONE) {
26400 /* Lost connection - give up */
26401 break;
26402
26403 } else if ((pkt->pkt_reason == CMD_INCOMPLETE) &&
26404 (pkt->pkt_state == 0)) {
26405 /* Pkt not dispatched - try again. */
26406 poll_delay = 1 * CSEC; /* 10 msec. */
26407
26408 } else if ((pkt->pkt_reason == CMD_CMPLT) &&
26409 (rc == STATUS_QFULL)) {
26410 /* Queue full - try again. */
26411 poll_delay = 1 * CSEC; /* 10 msec. */
26412
26413 } else if ((pkt->pkt_reason == CMD_CMPLT) &&
26414 (rc == STATUS_BUSY)) {
26415 /* Busy - try again. */
26416 poll_delay = 100 * CSEC; /* 1 sec. */
26417 busy_count += (SEC_TO_CSEC - 1);
26418
26419 } else if ((sensep != NULL) &&
26420 (scsi_sense_key(sensep) == KEY_UNIT_ATTENTION)) {
26421 /*
26422 * Unit Attention - try again.
26423 * Pretend it took 1 sec.
26424 * NOTE: 'continue' avoids poll_delay
26425 */
26426 busy_count += (SEC_TO_CSEC - 1);
26427 continue;
26428
26429 } else if ((sensep != NULL) &&
26430 (scsi_sense_key(sensep) == KEY_NOT_READY) &&
26431 (scsi_sense_asc(sensep) == 0x04) &&
26432 (scsi_sense_ascq(sensep) == 0x01)) {
26433 /*
26434 * Not ready -> ready - try again.
26435 * 04h/01h: LUN IS IN PROCESS OF BECOMING READY
26436 * ...same as STATUS_BUSY
26437 */
26438 poll_delay = 100 * CSEC; /* 1 sec. */
26439 busy_count += (SEC_TO_CSEC - 1);
26440
26441 } else {
26442 /* BAD status - give up. */
26443 break;
26444 }
26445 }
26446
26447 if (((curthread->t_flag & T_INTR_THREAD) == 0) &&
26448 !do_polled_io) {
26449 delay(drv_usectohz(poll_delay));
26450 } else {
26451 /* we busy wait during cpr_dump or interrupt threads */
26452 drv_usecwait(poll_delay);
26453 }
26454 }
26455
26456 pkt->pkt_flags = savef;
26457 pkt->pkt_comp = savec;
26458 pkt->pkt_time = savet;
26459
26460 /* return on error */
26461 if (rval)
26462 return (rval);
26463
26464 /*
26465 * This is not a performance critical code path.
26466 *
26467 * As an accommodation for scsi_poll callers, to avoid ddi_dma_sync()
26468 * issues associated with looking at DMA memory prior to
26469 * scsi_pkt_destroy(), we scsi_sync_pkt() prior to return.
26470 */
26471 scsi_sync_pkt(pkt);
26472 return (0);
26473 }
26474
26475
26476
26477 /*
26478 * Function: sd_persistent_reservation_in_read_keys
26479 *
26480 * Description: This routine is the driver entry point for handling CD-ROM
26481 * multi-host persistent reservation requests (MHIOCGRP_INKEYS)
26482 * by sending the SCSI-3 PRIN commands to the device.
26483 * Processes the read keys command response by copying the
26484 * reservation key information into the user provided buffer.
26485 * Support for the 32/64 bit _MULTI_DATAMODEL is implemented.
26486 *
26487 * Arguments: un - Pointer to soft state struct for the target.
26488 * usrp - user provided pointer to multihost Persistent In Read
26489 * Keys structure (mhioc_inkeys_t)
26490 * flag - this argument is a pass through to ddi_copyxxx()
26491 * directly from the mode argument of ioctl().
26492 *
26493 * Return Code: 0 - Success
26494 * EACCES
26495 * ENOTSUP
26496 * errno return code from sd_send_scsi_cmd()
26497 *
26498 * Context: Can sleep. Does not return until command is completed.
26499 */
26500
26501 static int
26502 sd_persistent_reservation_in_read_keys(struct sd_lun *un,
26503 mhioc_inkeys_t *usrp, int flag)
26504 {
26505 #ifdef _MULTI_DATAMODEL
26506 struct mhioc_key_list32 li32;
26507 #endif
26508 sd_prin_readkeys_t *in;
26509 mhioc_inkeys_t *ptr;
26510 mhioc_key_list_t li;
26511 uchar_t *data_bufp = NULL;
26512 int data_len = 0;
26513 int rval = 0;
26514 size_t copysz = 0;
26515 sd_ssc_t *ssc;
26516
26517 if ((ptr = (mhioc_inkeys_t *)usrp) == NULL) {
26518 return (EINVAL);
26519 }
26520 bzero(&li, sizeof (mhioc_key_list_t));
26521
26522 ssc = sd_ssc_init(un);
26523
26524 /*
26525 * Get the listsize from user
26526 */
26527 #ifdef _MULTI_DATAMODEL
26528 switch (ddi_model_convert_from(flag & FMODELS)) {
26529 case DDI_MODEL_ILP32:
26530 copysz = sizeof (struct mhioc_key_list32);
26531 if (ddi_copyin(ptr->li, &li32, copysz, flag)) {
26532 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26533 "sd_persistent_reservation_in_read_keys: "
26534 "failed ddi_copyin: mhioc_key_list32_t\n");
26535 rval = EFAULT;
26536 goto done;
26537 }
26538 li.listsize = li32.listsize;
26539 li.list = (mhioc_resv_key_t *)(uintptr_t)li32.list;
26540 break;
26541
26542 case DDI_MODEL_NONE:
26543 copysz = sizeof (mhioc_key_list_t);
26544 if (ddi_copyin(ptr->li, &li, copysz, flag)) {
26545 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26546 "sd_persistent_reservation_in_read_keys: "
26547 "failed ddi_copyin: mhioc_key_list_t\n");
26548 rval = EFAULT;
26549 goto done;
26550 }
26551 break;
26552 }
26553
26554 #else /* ! _MULTI_DATAMODEL */
26555 copysz = sizeof (mhioc_key_list_t);
26556 if (ddi_copyin(ptr->li, &li, copysz, flag)) {
26557 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26558 "sd_persistent_reservation_in_read_keys: "
26559 "failed ddi_copyin: mhioc_key_list_t\n");
26560 rval = EFAULT;
26561 goto done;
26562 }
26563 #endif
26564
26565 data_len = li.listsize * MHIOC_RESV_KEY_SIZE;
26566 data_len += (sizeof (sd_prin_readkeys_t) - sizeof (caddr_t));
26567 data_bufp = kmem_zalloc(data_len, KM_SLEEP);
26568
26569 rval = sd_send_scsi_PERSISTENT_RESERVE_IN(ssc, SD_READ_KEYS,
26570 data_len, data_bufp);
26571 if (rval != 0) {
26572 if (rval == EIO)
26573 sd_ssc_assessment(ssc, SD_FMT_IGNORE_COMPROMISE);
26574 else
26575 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
26576 goto done;
26577 }
26578 in = (sd_prin_readkeys_t *)data_bufp;
26579 ptr->generation = BE_32(in->generation);
26580 li.listlen = BE_32(in->len) / MHIOC_RESV_KEY_SIZE;
26581
26582 /*
26583 * Return the min(listsize, listlen) keys
26584 */
26585 #ifdef _MULTI_DATAMODEL
26586
26587 switch (ddi_model_convert_from(flag & FMODELS)) {
26588 case DDI_MODEL_ILP32:
26589 li32.listlen = li.listlen;
26590 if (ddi_copyout(&li32, ptr->li, copysz, flag)) {
26591 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26592 "sd_persistent_reservation_in_read_keys: "
26593 "failed ddi_copyout: mhioc_key_list32_t\n");
26594 rval = EFAULT;
26595 goto done;
26596 }
26597 break;
26598
26599 case DDI_MODEL_NONE:
26600 if (ddi_copyout(&li, ptr->li, copysz, flag)) {
26601 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26602 "sd_persistent_reservation_in_read_keys: "
26603 "failed ddi_copyout: mhioc_key_list_t\n");
26604 rval = EFAULT;
26605 goto done;
26606 }
26607 break;
26608 }
26609
26610 #else /* ! _MULTI_DATAMODEL */
26611
26612 if (ddi_copyout(&li, ptr->li, copysz, flag)) {
26613 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26614 "sd_persistent_reservation_in_read_keys: "
26615 "failed ddi_copyout: mhioc_key_list_t\n");
26616 rval = EFAULT;
26617 goto done;
26618 }
26619
26620 #endif /* _MULTI_DATAMODEL */
26621
26622 copysz = min(li.listlen * MHIOC_RESV_KEY_SIZE,
26623 li.listsize * MHIOC_RESV_KEY_SIZE);
26624 if (ddi_copyout(&in->keylist, li.list, copysz, flag)) {
26625 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26626 "sd_persistent_reservation_in_read_keys: "
26627 "failed ddi_copyout: keylist\n");
26628 rval = EFAULT;
26629 }
26630 done:
26631 sd_ssc_fini(ssc);
26632 kmem_free(data_bufp, data_len);
26633 return (rval);
26634 }
26635
26636
26637 /*
26638 * Function: sd_persistent_reservation_in_read_resv
26639 *
26640 * Description: This routine is the driver entry point for handling CD-ROM
26641 * multi-host persistent reservation requests (MHIOCGRP_INRESV)
26642 * by sending the SCSI-3 PRIN commands to the device.
26643 * Process the read persistent reservations command response by
26644 * copying the reservation information into the user provided
26645 * buffer. Support for the 32/64 _MULTI_DATAMODEL is implemented.
26646 *
26647 * Arguments: un - Pointer to soft state struct for the target.
26648 * usrp - user provided pointer to multihost Persistent In Read
26649 * Keys structure (mhioc_inkeys_t)
26650 * flag - this argument is a pass through to ddi_copyxxx()
26651 * directly from the mode argument of ioctl().
26652 *
26653 * Return Code: 0 - Success
26654 * EACCES
26655 * ENOTSUP
26656 * errno return code from sd_send_scsi_cmd()
26657 *
26658 * Context: Can sleep. Does not return until command is completed.
26659 */
26660
26661 static int
26662 sd_persistent_reservation_in_read_resv(struct sd_lun *un,
26663 mhioc_inresvs_t *usrp, int flag)
26664 {
26665 #ifdef _MULTI_DATAMODEL
26666 struct mhioc_resv_desc_list32 resvlist32;
26667 #endif
26668 sd_prin_readresv_t *in;
26669 mhioc_inresvs_t *ptr;
26670 sd_readresv_desc_t *readresv_ptr;
26671 mhioc_resv_desc_list_t resvlist;
26672 mhioc_resv_desc_t resvdesc;
26673 uchar_t *data_bufp = NULL;
26674 int data_len;
26675 int rval = 0;
26676 int i;
26677 size_t copysz = 0;
26678 mhioc_resv_desc_t *bufp;
26679 sd_ssc_t *ssc;
26680
26681 if ((ptr = usrp) == NULL) {
26682 return (EINVAL);
26683 }
26684
26685 ssc = sd_ssc_init(un);
26686
26687 /*
26688 * Get the listsize from user
26689 */
26690 #ifdef _MULTI_DATAMODEL
26691 switch (ddi_model_convert_from(flag & FMODELS)) {
26692 case DDI_MODEL_ILP32:
26693 copysz = sizeof (struct mhioc_resv_desc_list32);
26694 if (ddi_copyin(ptr->li, &resvlist32, copysz, flag)) {
26695 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26696 "sd_persistent_reservation_in_read_resv: "
26697 "failed ddi_copyin: mhioc_resv_desc_list_t\n");
26698 rval = EFAULT;
26699 goto done;
26700 }
26701 resvlist.listsize = resvlist32.listsize;
26702 resvlist.list = (mhioc_resv_desc_t *)(uintptr_t)resvlist32.list;
26703 break;
26704
26705 case DDI_MODEL_NONE:
26706 copysz = sizeof (mhioc_resv_desc_list_t);
26707 if (ddi_copyin(ptr->li, &resvlist, copysz, flag)) {
26708 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26709 "sd_persistent_reservation_in_read_resv: "
26710 "failed ddi_copyin: mhioc_resv_desc_list_t\n");
26711 rval = EFAULT;
26712 goto done;
26713 }
26714 break;
26715 }
26716 #else /* ! _MULTI_DATAMODEL */
26717 copysz = sizeof (mhioc_resv_desc_list_t);
26718 if (ddi_copyin(ptr->li, &resvlist, copysz, flag)) {
26719 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26720 "sd_persistent_reservation_in_read_resv: "
26721 "failed ddi_copyin: mhioc_resv_desc_list_t\n");
26722 rval = EFAULT;
26723 goto done;
26724 }
26725 #endif /* ! _MULTI_DATAMODEL */
26726
26727 data_len = resvlist.listsize * SCSI3_RESV_DESC_LEN;
26728 data_len += (sizeof (sd_prin_readresv_t) - sizeof (caddr_t));
26729 data_bufp = kmem_zalloc(data_len, KM_SLEEP);
26730
26731 rval = sd_send_scsi_PERSISTENT_RESERVE_IN(ssc, SD_READ_RESV,
26732 data_len, data_bufp);
26733 if (rval != 0) {
26734 if (rval == EIO)
26735 sd_ssc_assessment(ssc, SD_FMT_IGNORE_COMPROMISE);
26736 else
26737 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
26738 goto done;
26739 }
26740 in = (sd_prin_readresv_t *)data_bufp;
26741 ptr->generation = BE_32(in->generation);
26742 resvlist.listlen = BE_32(in->len) / SCSI3_RESV_DESC_LEN;
26743
26744 /*
26745 * Return the min(listsize, listlen( keys
26746 */
26747 #ifdef _MULTI_DATAMODEL
26748
26749 switch (ddi_model_convert_from(flag & FMODELS)) {
26750 case DDI_MODEL_ILP32:
26751 resvlist32.listlen = resvlist.listlen;
26752 if (ddi_copyout(&resvlist32, ptr->li, copysz, flag)) {
26753 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26754 "sd_persistent_reservation_in_read_resv: "
26755 "failed ddi_copyout: mhioc_resv_desc_list_t\n");
26756 rval = EFAULT;
26757 goto done;
26758 }
26759 break;
26760
26761 case DDI_MODEL_NONE:
26762 if (ddi_copyout(&resvlist, ptr->li, copysz, flag)) {
26763 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26764 "sd_persistent_reservation_in_read_resv: "
26765 "failed ddi_copyout: mhioc_resv_desc_list_t\n");
26766 rval = EFAULT;
26767 goto done;
26768 }
26769 break;
26770 }
26771
26772 #else /* ! _MULTI_DATAMODEL */
26773
26774 if (ddi_copyout(&resvlist, ptr->li, copysz, flag)) {
26775 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26776 "sd_persistent_reservation_in_read_resv: "
26777 "failed ddi_copyout: mhioc_resv_desc_list_t\n");
26778 rval = EFAULT;
26779 goto done;
26780 }
26781
26782 #endif /* ! _MULTI_DATAMODEL */
26783
26784 readresv_ptr = (sd_readresv_desc_t *)&in->readresv_desc;
26785 bufp = resvlist.list;
26786 copysz = sizeof (mhioc_resv_desc_t);
26787 for (i = 0; i < min(resvlist.listlen, resvlist.listsize);
26788 i++, readresv_ptr++, bufp++) {
26789
26790 bcopy(&readresv_ptr->resvkey, &resvdesc.key,
26791 MHIOC_RESV_KEY_SIZE);
26792 resvdesc.type = readresv_ptr->type;
26793 resvdesc.scope = readresv_ptr->scope;
26794 resvdesc.scope_specific_addr =
26795 BE_32(readresv_ptr->scope_specific_addr);
26796
26797 if (ddi_copyout(&resvdesc, bufp, copysz, flag)) {
26798 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26799 "sd_persistent_reservation_in_read_resv: "
26800 "failed ddi_copyout: resvlist\n");
26801 rval = EFAULT;
26802 goto done;
26803 }
26804 }
26805 done:
26806 sd_ssc_fini(ssc);
26807 /* only if data_bufp is allocated, we need to free it */
26808 if (data_bufp) {
26809 kmem_free(data_bufp, data_len);
26810 }
26811 return (rval);
26812 }
26813
26814
26815 /*
26816 * Function: sr_change_blkmode()
26817 *
26818 * Description: This routine is the driver entry point for handling CD-ROM
26819 * block mode ioctl requests. Support for returning and changing
26820 * the current block size in use by the device is implemented. The
26821 * LBA size is changed via a MODE SELECT Block Descriptor.
26822 *
26823 * This routine issues a mode sense with an allocation length of
26824 * 12 bytes for the mode page header and a single block descriptor.
26825 *
26826 * Arguments: dev - the device 'dev_t'
26827 * cmd - the request type; one of CDROMGBLKMODE (get) or
26828 * CDROMSBLKMODE (set)
26829 * data - current block size or requested block size
26830 * flag - this argument is a pass through to ddi_copyxxx() directly
26831 * from the mode argument of ioctl().
26832 *
26833 * Return Code: the code returned by sd_send_scsi_cmd()
26834 * EINVAL if invalid arguments are provided
26835 * EFAULT if ddi_copyxxx() fails
26836 * ENXIO if fail ddi_get_soft_state
26837 * EIO if invalid mode sense block descriptor length
26838 *
26839 */
26840
26841 static int
26842 sr_change_blkmode(dev_t dev, int cmd, intptr_t data, int flag)
26843 {
26844 struct sd_lun *un = NULL;
26845 struct mode_header *sense_mhp, *select_mhp;
26846 struct block_descriptor *sense_desc, *select_desc;
26847 int current_bsize;
26848 int rval = EINVAL;
26849 uchar_t *sense = NULL;
26850 uchar_t *select = NULL;
26851 sd_ssc_t *ssc;
26852
26853 ASSERT((cmd == CDROMGBLKMODE) || (cmd == CDROMSBLKMODE));
26854
26855 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
26856 return (ENXIO);
26857 }
26858
26859 /*
26860 * The block length is changed via the Mode Select block descriptor, the
26861 * "Read/Write Error Recovery" mode page (0x1) contents are not actually
26862 * required as part of this routine. Therefore the mode sense allocation
26863 * length is specified to be the length of a mode page header and a
26864 * block descriptor.
26865 */
26866 sense = kmem_zalloc(BUFLEN_CHG_BLK_MODE, KM_SLEEP);
26867
26868 ssc = sd_ssc_init(un);
26869 rval = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP0, sense,
26870 BUFLEN_CHG_BLK_MODE, MODEPAGE_ERR_RECOV, SD_PATH_STANDARD);
26871 sd_ssc_fini(ssc);
26872 if (rval != 0) {
26873 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
26874 "sr_change_blkmode: Mode Sense Failed\n");
26875 kmem_free(sense, BUFLEN_CHG_BLK_MODE);
26876 return (rval);
26877 }
26878
26879 /* Check the block descriptor len to handle only 1 block descriptor */
26880 sense_mhp = (struct mode_header *)sense;
26881 if ((sense_mhp->bdesc_length == 0) ||
26882 (sense_mhp->bdesc_length > MODE_BLK_DESC_LENGTH)) {
26883 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
26884 "sr_change_blkmode: Mode Sense returned invalid block"
26885 " descriptor length\n");
26886 kmem_free(sense, BUFLEN_CHG_BLK_MODE);
26887 return (EIO);
26888 }
26889 sense_desc = (struct block_descriptor *)(sense + MODE_HEADER_LENGTH);
26890 current_bsize = ((sense_desc->blksize_hi << 16) |
26891 (sense_desc->blksize_mid << 8) | sense_desc->blksize_lo);
26892
26893 /* Process command */
26894 switch (cmd) {
26895 case CDROMGBLKMODE:
26896 /* Return the block size obtained during the mode sense */
26897 if (ddi_copyout(¤t_bsize, (void *)data,
26898 sizeof (int), flag) != 0)
26899 rval = EFAULT;
26900 break;
26901 case CDROMSBLKMODE:
26902 /* Validate the requested block size */
26903 switch (data) {
26904 case CDROM_BLK_512:
26905 case CDROM_BLK_1024:
26906 case CDROM_BLK_2048:
26907 case CDROM_BLK_2056:
26908 case CDROM_BLK_2336:
26909 case CDROM_BLK_2340:
26910 case CDROM_BLK_2352:
26911 case CDROM_BLK_2368:
26912 case CDROM_BLK_2448:
26913 case CDROM_BLK_2646:
26914 case CDROM_BLK_2647:
26915 break;
26916 default:
26917 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
26918 "sr_change_blkmode: "
26919 "Block Size '%ld' Not Supported\n", data);
26920 kmem_free(sense, BUFLEN_CHG_BLK_MODE);
26921 return (EINVAL);
26922 }
26923
26924 /*
26925 * The current block size matches the requested block size so
26926 * there is no need to send the mode select to change the size
26927 */
26928 if (current_bsize == data) {
26929 break;
26930 }
26931
26932 /* Build the select data for the requested block size */
26933 select = kmem_zalloc(BUFLEN_CHG_BLK_MODE, KM_SLEEP);
26934 select_mhp = (struct mode_header *)select;
26935 select_desc =
26936 (struct block_descriptor *)(select + MODE_HEADER_LENGTH);
26937 /*
26938 * The LBA size is changed via the block descriptor, so the
26939 * descriptor is built according to the user data
26940 */
26941 select_mhp->bdesc_length = MODE_BLK_DESC_LENGTH;
26942 select_desc->blksize_hi = (char)(((data) & 0x00ff0000) >> 16);
26943 select_desc->blksize_mid = (char)(((data) & 0x0000ff00) >> 8);
26944 select_desc->blksize_lo = (char)((data) & 0x000000ff);
26945
26946 /* Send the mode select for the requested block size */
26947 ssc = sd_ssc_init(un);
26948 rval = sd_send_scsi_MODE_SELECT(ssc, CDB_GROUP0,
26949 select, BUFLEN_CHG_BLK_MODE, SD_DONTSAVE_PAGE,
26950 SD_PATH_STANDARD);
26951 sd_ssc_fini(ssc);
26952 if (rval != 0) {
26953 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
26954 "sr_change_blkmode: Mode Select Failed\n");
26955 /*
26956 * The mode select failed for the requested block size,
26957 * so reset the data for the original block size and
26958 * send it to the target. The error is indicated by the
26959 * return value for the failed mode select.
26960 */
26961 select_desc->blksize_hi = sense_desc->blksize_hi;
26962 select_desc->blksize_mid = sense_desc->blksize_mid;
26963 select_desc->blksize_lo = sense_desc->blksize_lo;
26964 ssc = sd_ssc_init(un);
26965 (void) sd_send_scsi_MODE_SELECT(ssc, CDB_GROUP0,
26966 select, BUFLEN_CHG_BLK_MODE, SD_DONTSAVE_PAGE,
26967 SD_PATH_STANDARD);
26968 sd_ssc_fini(ssc);
26969 } else {
26970 ASSERT(!mutex_owned(SD_MUTEX(un)));
26971 mutex_enter(SD_MUTEX(un));
26972 sd_update_block_info(un, (uint32_t)data, 0);
26973 mutex_exit(SD_MUTEX(un));
26974 }
26975 break;
26976 default:
26977 /* should not reach here, but check anyway */
26978 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
26979 "sr_change_blkmode: Command '%x' Not Supported\n", cmd);
26980 rval = EINVAL;
26981 break;
26982 }
26983
26984 if (select) {
26985 kmem_free(select, BUFLEN_CHG_BLK_MODE);
26986 }
26987 if (sense) {
26988 kmem_free(sense, BUFLEN_CHG_BLK_MODE);
26989 }
26990 return (rval);
26991 }
26992
26993
26994 /*
26995 * Note: The following sr_change_speed() and sr_atapi_change_speed() routines
26996 * implement driver support for getting and setting the CD speed. The command
26997 * set used will be based on the device type. If the device has not been
26998 * identified as MMC the Toshiba vendor specific mode page will be used. If
26999 * the device is MMC but does not support the Real Time Streaming feature
27000 * the SET CD SPEED command will be used to set speed and mode page 0x2A will
27001 * be used to read the speed.
27002 */
27003
27004 /*
27005 * Function: sr_change_speed()
27006 *
27007 * Description: This routine is the driver entry point for handling CD-ROM
27008 * drive speed ioctl requests for devices supporting the Toshiba
27009 * vendor specific drive speed mode page. Support for returning
27010 * and changing the current drive speed in use by the device is
27011 * implemented.
27012 *
27013 * Arguments: dev - the device 'dev_t'
27014 * cmd - the request type; one of CDROMGDRVSPEED (get) or
27015 * CDROMSDRVSPEED (set)
27016 * data - current drive speed or requested drive speed
27017 * flag - this argument is a pass through to ddi_copyxxx() directly
27018 * from the mode argument of ioctl().
27019 *
27020 * Return Code: the code returned by sd_send_scsi_cmd()
27021 * EINVAL if invalid arguments are provided
27022 * EFAULT if ddi_copyxxx() fails
27023 * ENXIO if fail ddi_get_soft_state
27024 * EIO if invalid mode sense block descriptor length
27025 */
27026
27027 static int
27028 sr_change_speed(dev_t dev, int cmd, intptr_t data, int flag)
27029 {
27030 struct sd_lun *un = NULL;
27031 struct mode_header *sense_mhp, *select_mhp;
27032 struct mode_speed *sense_page, *select_page;
27033 int current_speed;
27034 int rval = EINVAL;
27035 int bd_len;
27036 uchar_t *sense = NULL;
27037 uchar_t *select = NULL;
27038 sd_ssc_t *ssc;
27039
27040 ASSERT((cmd == CDROMGDRVSPEED) || (cmd == CDROMSDRVSPEED));
27041 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
27042 return (ENXIO);
27043 }
27044
27045 /*
27046 * Note: The drive speed is being modified here according to a Toshiba
27047 * vendor specific mode page (0x31).
27048 */
27049 sense = kmem_zalloc(BUFLEN_MODE_CDROM_SPEED, KM_SLEEP);
27050
27051 ssc = sd_ssc_init(un);
27052 rval = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP0, sense,
27053 BUFLEN_MODE_CDROM_SPEED, CDROM_MODE_SPEED,
27054 SD_PATH_STANDARD);
27055 sd_ssc_fini(ssc);
27056 if (rval != 0) {
27057 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27058 "sr_change_speed: Mode Sense Failed\n");
27059 kmem_free(sense, BUFLEN_MODE_CDROM_SPEED);
27060 return (rval);
27061 }
27062 sense_mhp = (struct mode_header *)sense;
27063
27064 /* Check the block descriptor len to handle only 1 block descriptor */
27065 bd_len = sense_mhp->bdesc_length;
27066 if (bd_len > MODE_BLK_DESC_LENGTH) {
27067 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27068 "sr_change_speed: Mode Sense returned invalid block "
27069 "descriptor length\n");
27070 kmem_free(sense, BUFLEN_MODE_CDROM_SPEED);
27071 return (EIO);
27072 }
27073
27074 sense_page = (struct mode_speed *)
27075 (sense + MODE_HEADER_LENGTH + sense_mhp->bdesc_length);
27076 current_speed = sense_page->speed;
27077
27078 /* Process command */
27079 switch (cmd) {
27080 case CDROMGDRVSPEED:
27081 /* Return the drive speed obtained during the mode sense */
27082 if (current_speed == 0x2) {
27083 current_speed = CDROM_TWELVE_SPEED;
27084 }
27085 if (ddi_copyout(¤t_speed, (void *)data,
27086 sizeof (int), flag) != 0) {
27087 rval = EFAULT;
27088 }
27089 break;
27090 case CDROMSDRVSPEED:
27091 /* Validate the requested drive speed */
27092 switch ((uchar_t)data) {
27093 case CDROM_TWELVE_SPEED:
27094 data = 0x2;
27095 /*FALLTHROUGH*/
27096 case CDROM_NORMAL_SPEED:
27097 case CDROM_DOUBLE_SPEED:
27098 case CDROM_QUAD_SPEED:
27099 case CDROM_MAXIMUM_SPEED:
27100 break;
27101 default:
27102 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27103 "sr_change_speed: "
27104 "Drive Speed '%d' Not Supported\n", (uchar_t)data);
27105 kmem_free(sense, BUFLEN_MODE_CDROM_SPEED);
27106 return (EINVAL);
27107 }
27108
27109 /*
27110 * The current drive speed matches the requested drive speed so
27111 * there is no need to send the mode select to change the speed
27112 */
27113 if (current_speed == data) {
27114 break;
27115 }
27116
27117 /* Build the select data for the requested drive speed */
27118 select = kmem_zalloc(BUFLEN_MODE_CDROM_SPEED, KM_SLEEP);
27119 select_mhp = (struct mode_header *)select;
27120 select_mhp->bdesc_length = 0;
27121 select_page =
27122 (struct mode_speed *)(select + MODE_HEADER_LENGTH);
27123 select_page =
27124 (struct mode_speed *)(select + MODE_HEADER_LENGTH);
27125 select_page->mode_page.code = CDROM_MODE_SPEED;
27126 select_page->mode_page.length = 2;
27127 select_page->speed = (uchar_t)data;
27128
27129 /* Send the mode select for the requested block size */
27130 ssc = sd_ssc_init(un);
27131 rval = sd_send_scsi_MODE_SELECT(ssc, CDB_GROUP0, select,
27132 MODEPAGE_CDROM_SPEED_LEN + MODE_HEADER_LENGTH,
27133 SD_DONTSAVE_PAGE, SD_PATH_STANDARD);
27134 sd_ssc_fini(ssc);
27135 if (rval != 0) {
27136 /*
27137 * The mode select failed for the requested drive speed,
27138 * so reset the data for the original drive speed and
27139 * send it to the target. The error is indicated by the
27140 * return value for the failed mode select.
27141 */
27142 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27143 "sr_drive_speed: Mode Select Failed\n");
27144 select_page->speed = sense_page->speed;
27145 ssc = sd_ssc_init(un);
27146 (void) sd_send_scsi_MODE_SELECT(ssc, CDB_GROUP0, select,
27147 MODEPAGE_CDROM_SPEED_LEN + MODE_HEADER_LENGTH,
27148 SD_DONTSAVE_PAGE, SD_PATH_STANDARD);
27149 sd_ssc_fini(ssc);
27150 }
27151 break;
27152 default:
27153 /* should not reach here, but check anyway */
27154 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27155 "sr_change_speed: Command '%x' Not Supported\n", cmd);
27156 rval = EINVAL;
27157 break;
27158 }
27159
27160 if (select) {
27161 kmem_free(select, BUFLEN_MODE_CDROM_SPEED);
27162 }
27163 if (sense) {
27164 kmem_free(sense, BUFLEN_MODE_CDROM_SPEED);
27165 }
27166
27167 return (rval);
27168 }
27169
27170
27171 /*
27172 * Function: sr_atapi_change_speed()
27173 *
27174 * Description: This routine is the driver entry point for handling CD-ROM
27175 * drive speed ioctl requests for MMC devices that do not support
27176 * the Real Time Streaming feature (0x107).
27177 *
27178 * Note: This routine will use the SET SPEED command which may not
27179 * be supported by all devices.
27180 *
27181 * Arguments: dev- the device 'dev_t'
27182 * cmd- the request type; one of CDROMGDRVSPEED (get) or
27183 * CDROMSDRVSPEED (set)
27184 * data- current drive speed or requested drive speed
27185 * flag- this argument is a pass through to ddi_copyxxx() directly
27186 * from the mode argument of ioctl().
27187 *
27188 * Return Code: the code returned by sd_send_scsi_cmd()
27189 * EINVAL if invalid arguments are provided
27190 * EFAULT if ddi_copyxxx() fails
27191 * ENXIO if fail ddi_get_soft_state
27192 * EIO if invalid mode sense block descriptor length
27193 */
27194
27195 static int
27196 sr_atapi_change_speed(dev_t dev, int cmd, intptr_t data, int flag)
27197 {
27198 struct sd_lun *un;
27199 struct uscsi_cmd *com = NULL;
27200 struct mode_header_grp2 *sense_mhp;
27201 uchar_t *sense_page;
27202 uchar_t *sense = NULL;
27203 char cdb[CDB_GROUP5];
27204 int bd_len;
27205 int current_speed = 0;
27206 int max_speed = 0;
27207 int rval;
27208 sd_ssc_t *ssc;
27209
27210 ASSERT((cmd == CDROMGDRVSPEED) || (cmd == CDROMSDRVSPEED));
27211
27212 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
27213 return (ENXIO);
27214 }
27215
27216 sense = kmem_zalloc(BUFLEN_MODE_CDROM_CAP, KM_SLEEP);
27217
27218 ssc = sd_ssc_init(un);
27219 rval = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP1, sense,
27220 BUFLEN_MODE_CDROM_CAP, MODEPAGE_CDROM_CAP,
27221 SD_PATH_STANDARD);
27222 sd_ssc_fini(ssc);
27223 if (rval != 0) {
27224 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27225 "sr_atapi_change_speed: Mode Sense Failed\n");
27226 kmem_free(sense, BUFLEN_MODE_CDROM_CAP);
27227 return (rval);
27228 }
27229
27230 /* Check the block descriptor len to handle only 1 block descriptor */
27231 sense_mhp = (struct mode_header_grp2 *)sense;
27232 bd_len = (sense_mhp->bdesc_length_hi << 8) | sense_mhp->bdesc_length_lo;
27233 if (bd_len > MODE_BLK_DESC_LENGTH) {
27234 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27235 "sr_atapi_change_speed: Mode Sense returned invalid "
27236 "block descriptor length\n");
27237 kmem_free(sense, BUFLEN_MODE_CDROM_CAP);
27238 return (EIO);
27239 }
27240
27241 /* Calculate the current and maximum drive speeds */
27242 sense_page = (uchar_t *)(sense + MODE_HEADER_LENGTH_GRP2 + bd_len);
27243 current_speed = (sense_page[14] << 8) | sense_page[15];
27244 max_speed = (sense_page[8] << 8) | sense_page[9];
27245
27246 /* Process the command */
27247 switch (cmd) {
27248 case CDROMGDRVSPEED:
27249 current_speed /= SD_SPEED_1X;
27250 if (ddi_copyout(¤t_speed, (void *)data,
27251 sizeof (int), flag) != 0)
27252 rval = EFAULT;
27253 break;
27254 case CDROMSDRVSPEED:
27255 /* Convert the speed code to KB/sec */
27256 switch ((uchar_t)data) {
27257 case CDROM_NORMAL_SPEED:
27258 current_speed = SD_SPEED_1X;
27259 break;
27260 case CDROM_DOUBLE_SPEED:
27261 current_speed = 2 * SD_SPEED_1X;
27262 break;
27263 case CDROM_QUAD_SPEED:
27264 current_speed = 4 * SD_SPEED_1X;
27265 break;
27266 case CDROM_TWELVE_SPEED:
27267 current_speed = 12 * SD_SPEED_1X;
27268 break;
27269 case CDROM_MAXIMUM_SPEED:
27270 current_speed = 0xffff;
27271 break;
27272 default:
27273 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27274 "sr_atapi_change_speed: invalid drive speed %d\n",
27275 (uchar_t)data);
27276 kmem_free(sense, BUFLEN_MODE_CDROM_CAP);
27277 return (EINVAL);
27278 }
27279
27280 /* Check the request against the drive's max speed. */
27281 if (current_speed != 0xffff) {
27282 if (current_speed > max_speed) {
27283 kmem_free(sense, BUFLEN_MODE_CDROM_CAP);
27284 return (EINVAL);
27285 }
27286 }
27287
27288 /*
27289 * Build and send the SET SPEED command
27290 *
27291 * Note: The SET SPEED (0xBB) command used in this routine is
27292 * obsolete per the SCSI MMC spec but still supported in the
27293 * MT FUJI vendor spec. Most equipment is adhereing to MT FUJI
27294 * therefore the command is still implemented in this routine.
27295 */
27296 bzero(cdb, sizeof (cdb));
27297 cdb[0] = (char)SCMD_SET_CDROM_SPEED;
27298 cdb[2] = (uchar_t)(current_speed >> 8);
27299 cdb[3] = (uchar_t)current_speed;
27300 com = kmem_zalloc(sizeof (*com), KM_SLEEP);
27301 com->uscsi_cdb = (caddr_t)cdb;
27302 com->uscsi_cdblen = CDB_GROUP5;
27303 com->uscsi_bufaddr = NULL;
27304 com->uscsi_buflen = 0;
27305 com->uscsi_flags = USCSI_DIAGNOSE|USCSI_SILENT;
27306 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, 0, SD_PATH_STANDARD);
27307 break;
27308 default:
27309 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27310 "sr_atapi_change_speed: Command '%x' Not Supported\n", cmd);
27311 rval = EINVAL;
27312 }
27313
27314 if (sense) {
27315 kmem_free(sense, BUFLEN_MODE_CDROM_CAP);
27316 }
27317 if (com) {
27318 kmem_free(com, sizeof (*com));
27319 }
27320 return (rval);
27321 }
27322
27323
27324 /*
27325 * Function: sr_pause_resume()
27326 *
27327 * Description: This routine is the driver entry point for handling CD-ROM
27328 * pause/resume ioctl requests. This only affects the audio play
27329 * operation.
27330 *
27331 * Arguments: dev - the device 'dev_t'
27332 * cmd - the request type; one of CDROMPAUSE or CDROMRESUME, used
27333 * for setting the resume bit of the cdb.
27334 *
27335 * Return Code: the code returned by sd_send_scsi_cmd()
27336 * EINVAL if invalid mode specified
27337 *
27338 */
27339
27340 static int
27341 sr_pause_resume(dev_t dev, int cmd)
27342 {
27343 struct sd_lun *un;
27344 struct uscsi_cmd *com;
27345 char cdb[CDB_GROUP1];
27346 int rval;
27347
27348 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
27349 return (ENXIO);
27350 }
27351
27352 com = kmem_zalloc(sizeof (*com), KM_SLEEP);
27353 bzero(cdb, CDB_GROUP1);
27354 cdb[0] = SCMD_PAUSE_RESUME;
27355 switch (cmd) {
27356 case CDROMRESUME:
27357 cdb[8] = 1;
27358 break;
27359 case CDROMPAUSE:
27360 cdb[8] = 0;
27361 break;
27362 default:
27363 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, "sr_pause_resume:"
27364 " Command '%x' Not Supported\n", cmd);
27365 rval = EINVAL;
27366 goto done;
27367 }
27368
27369 com->uscsi_cdb = cdb;
27370 com->uscsi_cdblen = CDB_GROUP1;
27371 com->uscsi_flags = USCSI_DIAGNOSE|USCSI_SILENT;
27372
27373 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_SYSSPACE,
27374 SD_PATH_STANDARD);
27375
27376 done:
27377 kmem_free(com, sizeof (*com));
27378 return (rval);
27379 }
27380
27381
27382 /*
27383 * Function: sr_play_msf()
27384 *
27385 * Description: This routine is the driver entry point for handling CD-ROM
27386 * ioctl requests to output the audio signals at the specified
27387 * starting address and continue the audio play until the specified
27388 * ending address (CDROMPLAYMSF) The address is in Minute Second
27389 * Frame (MSF) format.
27390 *
27391 * Arguments: dev - the device 'dev_t'
27392 * data - pointer to user provided audio msf structure,
27393 * specifying start/end addresses.
27394 * flag - this argument is a pass through to ddi_copyxxx()
27395 * directly from the mode argument of ioctl().
27396 *
27397 * Return Code: the code returned by sd_send_scsi_cmd()
27398 * EFAULT if ddi_copyxxx() fails
27399 * ENXIO if fail ddi_get_soft_state
27400 * EINVAL if data pointer is NULL
27401 */
27402
27403 static int
27404 sr_play_msf(dev_t dev, caddr_t data, int flag)
27405 {
27406 struct sd_lun *un;
27407 struct uscsi_cmd *com;
27408 struct cdrom_msf msf_struct;
27409 struct cdrom_msf *msf = &msf_struct;
27410 char cdb[CDB_GROUP1];
27411 int rval;
27412
27413 if (data == NULL) {
27414 return (EINVAL);
27415 }
27416
27417 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
27418 return (ENXIO);
27419 }
27420
27421 if (ddi_copyin(data, msf, sizeof (struct cdrom_msf), flag)) {
27422 return (EFAULT);
27423 }
27424
27425 com = kmem_zalloc(sizeof (*com), KM_SLEEP);
27426 bzero(cdb, CDB_GROUP1);
27427 cdb[0] = SCMD_PLAYAUDIO_MSF;
27428 if (un->un_f_cfg_playmsf_bcd == TRUE) {
27429 cdb[3] = BYTE_TO_BCD(msf->cdmsf_min0);
27430 cdb[4] = BYTE_TO_BCD(msf->cdmsf_sec0);
27431 cdb[5] = BYTE_TO_BCD(msf->cdmsf_frame0);
27432 cdb[6] = BYTE_TO_BCD(msf->cdmsf_min1);
27433 cdb[7] = BYTE_TO_BCD(msf->cdmsf_sec1);
27434 cdb[8] = BYTE_TO_BCD(msf->cdmsf_frame1);
27435 } else {
27436 cdb[3] = msf->cdmsf_min0;
27437 cdb[4] = msf->cdmsf_sec0;
27438 cdb[5] = msf->cdmsf_frame0;
27439 cdb[6] = msf->cdmsf_min1;
27440 cdb[7] = msf->cdmsf_sec1;
27441 cdb[8] = msf->cdmsf_frame1;
27442 }
27443 com->uscsi_cdb = cdb;
27444 com->uscsi_cdblen = CDB_GROUP1;
27445 com->uscsi_flags = USCSI_DIAGNOSE|USCSI_SILENT;
27446 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_SYSSPACE,
27447 SD_PATH_STANDARD);
27448 kmem_free(com, sizeof (*com));
27449 return (rval);
27450 }
27451
27452
27453 /*
27454 * Function: sr_play_trkind()
27455 *
27456 * Description: This routine is the driver entry point for handling CD-ROM
27457 * ioctl requests to output the audio signals at the specified
27458 * starting address and continue the audio play until the specified
27459 * ending address (CDROMPLAYTRKIND). The address is in Track Index
27460 * format.
27461 *
27462 * Arguments: dev - the device 'dev_t'
27463 * data - pointer to user provided audio track/index structure,
27464 * specifying start/end addresses.
27465 * flag - this argument is a pass through to ddi_copyxxx()
27466 * directly from the mode argument of ioctl().
27467 *
27468 * Return Code: the code returned by sd_send_scsi_cmd()
27469 * EFAULT if ddi_copyxxx() fails
27470 * ENXIO if fail ddi_get_soft_state
27471 * EINVAL if data pointer is NULL
27472 */
27473
27474 static int
27475 sr_play_trkind(dev_t dev, caddr_t data, int flag)
27476 {
27477 struct cdrom_ti ti_struct;
27478 struct cdrom_ti *ti = &ti_struct;
27479 struct uscsi_cmd *com = NULL;
27480 char cdb[CDB_GROUP1];
27481 int rval;
27482
27483 if (data == NULL) {
27484 return (EINVAL);
27485 }
27486
27487 if (ddi_copyin(data, ti, sizeof (struct cdrom_ti), flag)) {
27488 return (EFAULT);
27489 }
27490
27491 com = kmem_zalloc(sizeof (*com), KM_SLEEP);
27492 bzero(cdb, CDB_GROUP1);
27493 cdb[0] = SCMD_PLAYAUDIO_TI;
27494 cdb[4] = ti->cdti_trk0;
27495 cdb[5] = ti->cdti_ind0;
27496 cdb[7] = ti->cdti_trk1;
27497 cdb[8] = ti->cdti_ind1;
27498 com->uscsi_cdb = cdb;
27499 com->uscsi_cdblen = CDB_GROUP1;
27500 com->uscsi_flags = USCSI_DIAGNOSE|USCSI_SILENT;
27501 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_SYSSPACE,
27502 SD_PATH_STANDARD);
27503 kmem_free(com, sizeof (*com));
27504 return (rval);
27505 }
27506
27507
27508 /*
27509 * Function: sr_read_all_subcodes()
27510 *
27511 * Description: This routine is the driver entry point for handling CD-ROM
27512 * ioctl requests to return raw subcode data while the target is
27513 * playing audio (CDROMSUBCODE).
27514 *
27515 * Arguments: dev - the device 'dev_t'
27516 * data - pointer to user provided cdrom subcode structure,
27517 * specifying the transfer length and address.
27518 * flag - this argument is a pass through to ddi_copyxxx()
27519 * directly from the mode argument of ioctl().
27520 *
27521 * Return Code: the code returned by sd_send_scsi_cmd()
27522 * EFAULT if ddi_copyxxx() fails
27523 * ENXIO if fail ddi_get_soft_state
27524 * EINVAL if data pointer is NULL
27525 */
27526
27527 static int
27528 sr_read_all_subcodes(dev_t dev, caddr_t data, int flag)
27529 {
27530 struct sd_lun *un = NULL;
27531 struct uscsi_cmd *com = NULL;
27532 struct cdrom_subcode *subcode = NULL;
27533 int rval;
27534 size_t buflen;
27535 char cdb[CDB_GROUP5];
27536
27537 #ifdef _MULTI_DATAMODEL
27538 /* To support ILP32 applications in an LP64 world */
27539 struct cdrom_subcode32 cdrom_subcode32;
27540 struct cdrom_subcode32 *cdsc32 = &cdrom_subcode32;
27541 #endif
27542 if (data == NULL) {
27543 return (EINVAL);
27544 }
27545
27546 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
27547 return (ENXIO);
27548 }
27549
27550 subcode = kmem_zalloc(sizeof (struct cdrom_subcode), KM_SLEEP);
27551
27552 #ifdef _MULTI_DATAMODEL
27553 switch (ddi_model_convert_from(flag & FMODELS)) {
27554 case DDI_MODEL_ILP32:
27555 if (ddi_copyin(data, cdsc32, sizeof (*cdsc32), flag)) {
27556 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27557 "sr_read_all_subcodes: ddi_copyin Failed\n");
27558 kmem_free(subcode, sizeof (struct cdrom_subcode));
27559 return (EFAULT);
27560 }
27561 /* Convert the ILP32 uscsi data from the application to LP64 */
27562 cdrom_subcode32tocdrom_subcode(cdsc32, subcode);
27563 break;
27564 case DDI_MODEL_NONE:
27565 if (ddi_copyin(data, subcode,
27566 sizeof (struct cdrom_subcode), flag)) {
27567 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27568 "sr_read_all_subcodes: ddi_copyin Failed\n");
27569 kmem_free(subcode, sizeof (struct cdrom_subcode));
27570 return (EFAULT);
27571 }
27572 break;
27573 }
27574 #else /* ! _MULTI_DATAMODEL */
27575 if (ddi_copyin(data, subcode, sizeof (struct cdrom_subcode), flag)) {
27576 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27577 "sr_read_all_subcodes: ddi_copyin Failed\n");
27578 kmem_free(subcode, sizeof (struct cdrom_subcode));
27579 return (EFAULT);
27580 }
27581 #endif /* _MULTI_DATAMODEL */
27582
27583 /*
27584 * Since MMC-2 expects max 3 bytes for length, check if the
27585 * length input is greater than 3 bytes
27586 */
27587 if ((subcode->cdsc_length & 0xFF000000) != 0) {
27588 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27589 "sr_read_all_subcodes: "
27590 "cdrom transfer length too large: %d (limit %d)\n",
27591 subcode->cdsc_length, 0xFFFFFF);
27592 kmem_free(subcode, sizeof (struct cdrom_subcode));
27593 return (EINVAL);
27594 }
27595
27596 buflen = CDROM_BLK_SUBCODE * subcode->cdsc_length;
27597 com = kmem_zalloc(sizeof (*com), KM_SLEEP);
27598 bzero(cdb, CDB_GROUP5);
27599
27600 if (un->un_f_mmc_cap == TRUE) {
27601 cdb[0] = (char)SCMD_READ_CD;
27602 cdb[2] = (char)0xff;
27603 cdb[3] = (char)0xff;
27604 cdb[4] = (char)0xff;
27605 cdb[5] = (char)0xff;
27606 cdb[6] = (((subcode->cdsc_length) & 0x00ff0000) >> 16);
27607 cdb[7] = (((subcode->cdsc_length) & 0x0000ff00) >> 8);
27608 cdb[8] = ((subcode->cdsc_length) & 0x000000ff);
27609 cdb[10] = 1;
27610 } else {
27611 /*
27612 * Note: A vendor specific command (0xDF) is being used here to
27613 * request a read of all subcodes.
27614 */
27615 cdb[0] = (char)SCMD_READ_ALL_SUBCODES;
27616 cdb[6] = (((subcode->cdsc_length) & 0xff000000) >> 24);
27617 cdb[7] = (((subcode->cdsc_length) & 0x00ff0000) >> 16);
27618 cdb[8] = (((subcode->cdsc_length) & 0x0000ff00) >> 8);
27619 cdb[9] = ((subcode->cdsc_length) & 0x000000ff);
27620 }
27621 com->uscsi_cdb = cdb;
27622 com->uscsi_cdblen = CDB_GROUP5;
27623 com->uscsi_bufaddr = (caddr_t)subcode->cdsc_addr;
27624 com->uscsi_buflen = buflen;
27625 com->uscsi_flags = USCSI_DIAGNOSE|USCSI_SILENT|USCSI_READ;
27626 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_USERSPACE,
27627 SD_PATH_STANDARD);
27628 kmem_free(subcode, sizeof (struct cdrom_subcode));
27629 kmem_free(com, sizeof (*com));
27630 return (rval);
27631 }
27632
27633
27634 /*
27635 * Function: sr_read_subchannel()
27636 *
27637 * Description: This routine is the driver entry point for handling CD-ROM
27638 * ioctl requests to return the Q sub-channel data of the CD
27639 * current position block. (CDROMSUBCHNL) The data includes the
27640 * track number, index number, absolute CD-ROM address (LBA or MSF
27641 * format per the user) , track relative CD-ROM address (LBA or MSF
27642 * format per the user), control data and audio status.
27643 *
27644 * Arguments: dev - the device 'dev_t'
27645 * data - pointer to user provided cdrom sub-channel structure
27646 * flag - this argument is a pass through to ddi_copyxxx()
27647 * directly from the mode argument of ioctl().
27648 *
27649 * Return Code: the code returned by sd_send_scsi_cmd()
27650 * EFAULT if ddi_copyxxx() fails
27651 * ENXIO if fail ddi_get_soft_state
27652 * EINVAL if data pointer is NULL
27653 */
27654
27655 static int
27656 sr_read_subchannel(dev_t dev, caddr_t data, int flag)
27657 {
27658 struct sd_lun *un;
27659 struct uscsi_cmd *com;
27660 struct cdrom_subchnl subchanel;
27661 struct cdrom_subchnl *subchnl = &subchanel;
27662 char cdb[CDB_GROUP1];
27663 caddr_t buffer;
27664 int rval;
27665
27666 if (data == NULL) {
27667 return (EINVAL);
27668 }
27669
27670 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
27671 (un->un_state == SD_STATE_OFFLINE)) {
27672 return (ENXIO);
27673 }
27674
27675 if (ddi_copyin(data, subchnl, sizeof (struct cdrom_subchnl), flag)) {
27676 return (EFAULT);
27677 }
27678
27679 buffer = kmem_zalloc((size_t)16, KM_SLEEP);
27680 bzero(cdb, CDB_GROUP1);
27681 cdb[0] = SCMD_READ_SUBCHANNEL;
27682 /* Set the MSF bit based on the user requested address format */
27683 cdb[1] = (subchnl->cdsc_format & CDROM_LBA) ? 0 : 0x02;
27684 /*
27685 * Set the Q bit in byte 2 to indicate that Q sub-channel data be
27686 * returned
27687 */
27688 cdb[2] = 0x40;
27689 /*
27690 * Set byte 3 to specify the return data format. A value of 0x01
27691 * indicates that the CD-ROM current position should be returned.
27692 */
27693 cdb[3] = 0x01;
27694 cdb[8] = 0x10;
27695 com = kmem_zalloc(sizeof (*com), KM_SLEEP);
27696 com->uscsi_cdb = cdb;
27697 com->uscsi_cdblen = CDB_GROUP1;
27698 com->uscsi_bufaddr = buffer;
27699 com->uscsi_buflen = 16;
27700 com->uscsi_flags = USCSI_DIAGNOSE|USCSI_SILENT|USCSI_READ;
27701 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_SYSSPACE,
27702 SD_PATH_STANDARD);
27703 if (rval != 0) {
27704 kmem_free(buffer, 16);
27705 kmem_free(com, sizeof (*com));
27706 return (rval);
27707 }
27708
27709 /* Process the returned Q sub-channel data */
27710 subchnl->cdsc_audiostatus = buffer[1];
27711 subchnl->cdsc_adr = (buffer[5] & 0xF0) >> 4;
27712 subchnl->cdsc_ctrl = (buffer[5] & 0x0F);
27713 subchnl->cdsc_trk = buffer[6];
27714 subchnl->cdsc_ind = buffer[7];
27715 if (subchnl->cdsc_format & CDROM_LBA) {
27716 subchnl->cdsc_absaddr.lba =
27717 ((uchar_t)buffer[8] << 24) + ((uchar_t)buffer[9] << 16) +
27718 ((uchar_t)buffer[10] << 8) + ((uchar_t)buffer[11]);
27719 subchnl->cdsc_reladdr.lba =
27720 ((uchar_t)buffer[12] << 24) + ((uchar_t)buffer[13] << 16) +
27721 ((uchar_t)buffer[14] << 8) + ((uchar_t)buffer[15]);
27722 } else if (un->un_f_cfg_readsub_bcd == TRUE) {
27723 subchnl->cdsc_absaddr.msf.minute = BCD_TO_BYTE(buffer[9]);
27724 subchnl->cdsc_absaddr.msf.second = BCD_TO_BYTE(buffer[10]);
27725 subchnl->cdsc_absaddr.msf.frame = BCD_TO_BYTE(buffer[11]);
27726 subchnl->cdsc_reladdr.msf.minute = BCD_TO_BYTE(buffer[13]);
27727 subchnl->cdsc_reladdr.msf.second = BCD_TO_BYTE(buffer[14]);
27728 subchnl->cdsc_reladdr.msf.frame = BCD_TO_BYTE(buffer[15]);
27729 } else {
27730 subchnl->cdsc_absaddr.msf.minute = buffer[9];
27731 subchnl->cdsc_absaddr.msf.second = buffer[10];
27732 subchnl->cdsc_absaddr.msf.frame = buffer[11];
27733 subchnl->cdsc_reladdr.msf.minute = buffer[13];
27734 subchnl->cdsc_reladdr.msf.second = buffer[14];
27735 subchnl->cdsc_reladdr.msf.frame = buffer[15];
27736 }
27737 kmem_free(buffer, 16);
27738 kmem_free(com, sizeof (*com));
27739 if (ddi_copyout(subchnl, data, sizeof (struct cdrom_subchnl), flag)
27740 != 0) {
27741 return (EFAULT);
27742 }
27743 return (rval);
27744 }
27745
27746
27747 /*
27748 * Function: sr_read_tocentry()
27749 *
27750 * Description: This routine is the driver entry point for handling CD-ROM
27751 * ioctl requests to read from the Table of Contents (TOC)
27752 * (CDROMREADTOCENTRY). This routine provides the ADR and CTRL
27753 * fields, the starting address (LBA or MSF format per the user)
27754 * and the data mode if the user specified track is a data track.
27755 *
27756 * Note: The READ HEADER (0x44) command used in this routine is
27757 * obsolete per the SCSI MMC spec but still supported in the
27758 * MT FUJI vendor spec. Most equipment is adhereing to MT FUJI
27759 * therefore the command is still implemented in this routine.
27760 *
27761 * Arguments: dev - the device 'dev_t'
27762 * data - pointer to user provided toc entry structure,
27763 * specifying the track # and the address format
27764 * (LBA or MSF).
27765 * flag - this argument is a pass through to ddi_copyxxx()
27766 * directly from the mode argument of ioctl().
27767 *
27768 * Return Code: the code returned by sd_send_scsi_cmd()
27769 * EFAULT if ddi_copyxxx() fails
27770 * ENXIO if fail ddi_get_soft_state
27771 * EINVAL if data pointer is NULL
27772 */
27773
27774 static int
27775 sr_read_tocentry(dev_t dev, caddr_t data, int flag)
27776 {
27777 struct sd_lun *un = NULL;
27778 struct uscsi_cmd *com;
27779 struct cdrom_tocentry toc_entry;
27780 struct cdrom_tocentry *entry = &toc_entry;
27781 caddr_t buffer;
27782 int rval;
27783 char cdb[CDB_GROUP1];
27784
27785 if (data == NULL) {
27786 return (EINVAL);
27787 }
27788
27789 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
27790 (un->un_state == SD_STATE_OFFLINE)) {
27791 return (ENXIO);
27792 }
27793
27794 if (ddi_copyin(data, entry, sizeof (struct cdrom_tocentry), flag)) {
27795 return (EFAULT);
27796 }
27797
27798 /* Validate the requested track and address format */
27799 if (!(entry->cdte_format & (CDROM_LBA | CDROM_MSF))) {
27800 return (EINVAL);
27801 }
27802
27803 if (entry->cdte_track == 0) {
27804 return (EINVAL);
27805 }
27806
27807 buffer = kmem_zalloc((size_t)12, KM_SLEEP);
27808 com = kmem_zalloc(sizeof (*com), KM_SLEEP);
27809 bzero(cdb, CDB_GROUP1);
27810
27811 cdb[0] = SCMD_READ_TOC;
27812 /* Set the MSF bit based on the user requested address format */
27813 cdb[1] = ((entry->cdte_format & CDROM_LBA) ? 0 : 2);
27814 if (un->un_f_cfg_read_toc_trk_bcd == TRUE) {
27815 cdb[6] = BYTE_TO_BCD(entry->cdte_track);
27816 } else {
27817 cdb[6] = entry->cdte_track;
27818 }
27819
27820 /*
27821 * Bytes 7 & 8 are the 12 byte allocation length for a single entry.
27822 * (4 byte TOC response header + 8 byte track descriptor)
27823 */
27824 cdb[8] = 12;
27825 com->uscsi_cdb = cdb;
27826 com->uscsi_cdblen = CDB_GROUP1;
27827 com->uscsi_bufaddr = buffer;
27828 com->uscsi_buflen = 0x0C;
27829 com->uscsi_flags = (USCSI_DIAGNOSE | USCSI_SILENT | USCSI_READ);
27830 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_SYSSPACE,
27831 SD_PATH_STANDARD);
27832 if (rval != 0) {
27833 kmem_free(buffer, 12);
27834 kmem_free(com, sizeof (*com));
27835 return (rval);
27836 }
27837
27838 /* Process the toc entry */
27839 entry->cdte_adr = (buffer[5] & 0xF0) >> 4;
27840 entry->cdte_ctrl = (buffer[5] & 0x0F);
27841 if (entry->cdte_format & CDROM_LBA) {
27842 entry->cdte_addr.lba =
27843 ((uchar_t)buffer[8] << 24) + ((uchar_t)buffer[9] << 16) +
27844 ((uchar_t)buffer[10] << 8) + ((uchar_t)buffer[11]);
27845 } else if (un->un_f_cfg_read_toc_addr_bcd == TRUE) {
27846 entry->cdte_addr.msf.minute = BCD_TO_BYTE(buffer[9]);
27847 entry->cdte_addr.msf.second = BCD_TO_BYTE(buffer[10]);
27848 entry->cdte_addr.msf.frame = BCD_TO_BYTE(buffer[11]);
27849 /*
27850 * Send a READ TOC command using the LBA address format to get
27851 * the LBA for the track requested so it can be used in the
27852 * READ HEADER request
27853 *
27854 * Note: The MSF bit of the READ HEADER command specifies the
27855 * output format. The block address specified in that command
27856 * must be in LBA format.
27857 */
27858 cdb[1] = 0;
27859 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_SYSSPACE,
27860 SD_PATH_STANDARD);
27861 if (rval != 0) {
27862 kmem_free(buffer, 12);
27863 kmem_free(com, sizeof (*com));
27864 return (rval);
27865 }
27866 } else {
27867 entry->cdte_addr.msf.minute = buffer[9];
27868 entry->cdte_addr.msf.second = buffer[10];
27869 entry->cdte_addr.msf.frame = buffer[11];
27870 /*
27871 * Send a READ TOC command using the LBA address format to get
27872 * the LBA for the track requested so it can be used in the
27873 * READ HEADER request
27874 *
27875 * Note: The MSF bit of the READ HEADER command specifies the
27876 * output format. The block address specified in that command
27877 * must be in LBA format.
27878 */
27879 cdb[1] = 0;
27880 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_SYSSPACE,
27881 SD_PATH_STANDARD);
27882 if (rval != 0) {
27883 kmem_free(buffer, 12);
27884 kmem_free(com, sizeof (*com));
27885 return (rval);
27886 }
27887 }
27888
27889 /*
27890 * Build and send the READ HEADER command to determine the data mode of
27891 * the user specified track.
27892 */
27893 if ((entry->cdte_ctrl & CDROM_DATA_TRACK) &&
27894 (entry->cdte_track != CDROM_LEADOUT)) {
27895 bzero(cdb, CDB_GROUP1);
27896 cdb[0] = SCMD_READ_HEADER;
27897 cdb[2] = buffer[8];
27898 cdb[3] = buffer[9];
27899 cdb[4] = buffer[10];
27900 cdb[5] = buffer[11];
27901 cdb[8] = 0x08;
27902 com->uscsi_buflen = 0x08;
27903 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_SYSSPACE,
27904 SD_PATH_STANDARD);
27905 if (rval == 0) {
27906 entry->cdte_datamode = buffer[0];
27907 } else {
27908 /*
27909 * READ HEADER command failed, since this is
27910 * obsoleted in one spec, its better to return
27911 * -1 for an invlid track so that we can still
27912 * receive the rest of the TOC data.
27913 */
27914 entry->cdte_datamode = (uchar_t)-1;
27915 }
27916 } else {
27917 entry->cdte_datamode = (uchar_t)-1;
27918 }
27919
27920 kmem_free(buffer, 12);
27921 kmem_free(com, sizeof (*com));
27922 if (ddi_copyout(entry, data, sizeof (struct cdrom_tocentry), flag) != 0)
27923 return (EFAULT);
27924
27925 return (rval);
27926 }
27927
27928
27929 /*
27930 * Function: sr_read_tochdr()
27931 *
27932 * Description: This routine is the driver entry point for handling CD-ROM
27933 * ioctl requests to read the Table of Contents (TOC) header
27934 * (CDROMREADTOHDR). The TOC header consists of the disk starting
27935 * and ending track numbers
27936 *
27937 * Arguments: dev - the device 'dev_t'
27938 * data - pointer to user provided toc header structure,
27939 * specifying the starting and ending track numbers.
27940 * flag - this argument is a pass through to ddi_copyxxx()
27941 * directly from the mode argument of ioctl().
27942 *
27943 * Return Code: the code returned by sd_send_scsi_cmd()
27944 * EFAULT if ddi_copyxxx() fails
27945 * ENXIO if fail ddi_get_soft_state
27946 * EINVAL if data pointer is NULL
27947 */
27948
27949 static int
27950 sr_read_tochdr(dev_t dev, caddr_t data, int flag)
27951 {
27952 struct sd_lun *un;
27953 struct uscsi_cmd *com;
27954 struct cdrom_tochdr toc_header;
27955 struct cdrom_tochdr *hdr = &toc_header;
27956 char cdb[CDB_GROUP1];
27957 int rval;
27958 caddr_t buffer;
27959
27960 if (data == NULL) {
27961 return (EINVAL);
27962 }
27963
27964 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
27965 (un->un_state == SD_STATE_OFFLINE)) {
27966 return (ENXIO);
27967 }
27968
27969 buffer = kmem_zalloc(4, KM_SLEEP);
27970 bzero(cdb, CDB_GROUP1);
27971 cdb[0] = SCMD_READ_TOC;
27972 /*
27973 * Specifying a track number of 0x00 in the READ TOC command indicates
27974 * that the TOC header should be returned
27975 */
27976 cdb[6] = 0x00;
27977 /*
27978 * Bytes 7 & 8 are the 4 byte allocation length for TOC header.
27979 * (2 byte data len + 1 byte starting track # + 1 byte ending track #)
27980 */
27981 cdb[8] = 0x04;
27982 com = kmem_zalloc(sizeof (*com), KM_SLEEP);
27983 com->uscsi_cdb = cdb;
27984 com->uscsi_cdblen = CDB_GROUP1;
27985 com->uscsi_bufaddr = buffer;
27986 com->uscsi_buflen = 0x04;
27987 com->uscsi_timeout = 300;
27988 com->uscsi_flags = USCSI_DIAGNOSE|USCSI_SILENT|USCSI_READ;
27989
27990 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_SYSSPACE,
27991 SD_PATH_STANDARD);
27992 if (un->un_f_cfg_read_toc_trk_bcd == TRUE) {
27993 hdr->cdth_trk0 = BCD_TO_BYTE(buffer[2]);
27994 hdr->cdth_trk1 = BCD_TO_BYTE(buffer[3]);
27995 } else {
27996 hdr->cdth_trk0 = buffer[2];
27997 hdr->cdth_trk1 = buffer[3];
27998 }
27999 kmem_free(buffer, 4);
28000 kmem_free(com, sizeof (*com));
28001 if (ddi_copyout(hdr, data, sizeof (struct cdrom_tochdr), flag) != 0) {
28002 return (EFAULT);
28003 }
28004 return (rval);
28005 }
28006
28007
28008 /*
28009 * Note: The following sr_read_mode1(), sr_read_cd_mode2(), sr_read_mode2(),
28010 * sr_read_cdda(), sr_read_cdxa(), routines implement driver support for
28011 * handling CDROMREAD ioctl requests for mode 1 user data, mode 2 user data,
28012 * digital audio and extended architecture digital audio. These modes are
28013 * defined in the IEC908 (Red Book), ISO10149 (Yellow Book), and the SCSI3
28014 * MMC specs.
28015 *
28016 * In addition to support for the various data formats these routines also
28017 * include support for devices that implement only the direct access READ
28018 * commands (0x08, 0x28), devices that implement the READ_CD commands
28019 * (0xBE, 0xD4), and devices that implement the vendor unique READ CDDA and
28020 * READ CDXA commands (0xD8, 0xDB)
28021 */
28022
28023 /*
28024 * Function: sr_read_mode1()
28025 *
28026 * Description: This routine is the driver entry point for handling CD-ROM
28027 * ioctl read mode1 requests (CDROMREADMODE1).
28028 *
28029 * Arguments: dev - the device 'dev_t'
28030 * data - pointer to user provided cd read structure specifying
28031 * the lba buffer address and length.
28032 * flag - this argument is a pass through to ddi_copyxxx()
28033 * directly from the mode argument of ioctl().
28034 *
28035 * Return Code: the code returned by sd_send_scsi_cmd()
28036 * EFAULT if ddi_copyxxx() fails
28037 * ENXIO if fail ddi_get_soft_state
28038 * EINVAL if data pointer is NULL
28039 */
28040
28041 static int
28042 sr_read_mode1(dev_t dev, caddr_t data, int flag)
28043 {
28044 struct sd_lun *un;
28045 struct cdrom_read mode1_struct;
28046 struct cdrom_read *mode1 = &mode1_struct;
28047 int rval;
28048 sd_ssc_t *ssc;
28049
28050 #ifdef _MULTI_DATAMODEL
28051 /* To support ILP32 applications in an LP64 world */
28052 struct cdrom_read32 cdrom_read32;
28053 struct cdrom_read32 *cdrd32 = &cdrom_read32;
28054 #endif /* _MULTI_DATAMODEL */
28055
28056 if (data == NULL) {
28057 return (EINVAL);
28058 }
28059
28060 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
28061 (un->un_state == SD_STATE_OFFLINE)) {
28062 return (ENXIO);
28063 }
28064
28065 SD_TRACE(SD_LOG_ATTACH_DETACH, un,
28066 "sd_read_mode1: entry: un:0x%p\n", un);
28067
28068 #ifdef _MULTI_DATAMODEL
28069 switch (ddi_model_convert_from(flag & FMODELS)) {
28070 case DDI_MODEL_ILP32:
28071 if (ddi_copyin(data, cdrd32, sizeof (*cdrd32), flag) != 0) {
28072 return (EFAULT);
28073 }
28074 /* Convert the ILP32 uscsi data from the application to LP64 */
28075 cdrom_read32tocdrom_read(cdrd32, mode1);
28076 break;
28077 case DDI_MODEL_NONE:
28078 if (ddi_copyin(data, mode1, sizeof (struct cdrom_read), flag)) {
28079 return (EFAULT);
28080 }
28081 }
28082 #else /* ! _MULTI_DATAMODEL */
28083 if (ddi_copyin(data, mode1, sizeof (struct cdrom_read), flag)) {
28084 return (EFAULT);
28085 }
28086 #endif /* _MULTI_DATAMODEL */
28087
28088 ssc = sd_ssc_init(un);
28089 rval = sd_send_scsi_READ(ssc, mode1->cdread_bufaddr,
28090 mode1->cdread_buflen, mode1->cdread_lba, SD_PATH_STANDARD);
28091 sd_ssc_fini(ssc);
28092
28093 SD_TRACE(SD_LOG_ATTACH_DETACH, un,
28094 "sd_read_mode1: exit: un:0x%p\n", un);
28095
28096 return (rval);
28097 }
28098
28099
28100 /*
28101 * Function: sr_read_cd_mode2()
28102 *
28103 * Description: This routine is the driver entry point for handling CD-ROM
28104 * ioctl read mode2 requests (CDROMREADMODE2) for devices that
28105 * support the READ CD (0xBE) command or the 1st generation
28106 * READ CD (0xD4) command.
28107 *
28108 * Arguments: dev - the device 'dev_t'
28109 * data - pointer to user provided cd read structure specifying
28110 * the lba buffer address and length.
28111 * flag - this argument is a pass through to ddi_copyxxx()
28112 * directly from the mode argument of ioctl().
28113 *
28114 * Return Code: the code returned by sd_send_scsi_cmd()
28115 * EFAULT if ddi_copyxxx() fails
28116 * ENXIO if fail ddi_get_soft_state
28117 * EINVAL if data pointer is NULL
28118 */
28119
28120 static int
28121 sr_read_cd_mode2(dev_t dev, caddr_t data, int flag)
28122 {
28123 struct sd_lun *un;
28124 struct uscsi_cmd *com;
28125 struct cdrom_read mode2_struct;
28126 struct cdrom_read *mode2 = &mode2_struct;
28127 uchar_t cdb[CDB_GROUP5];
28128 int nblocks;
28129 int rval;
28130 #ifdef _MULTI_DATAMODEL
28131 /* To support ILP32 applications in an LP64 world */
28132 struct cdrom_read32 cdrom_read32;
28133 struct cdrom_read32 *cdrd32 = &cdrom_read32;
28134 #endif /* _MULTI_DATAMODEL */
28135
28136 if (data == NULL) {
28137 return (EINVAL);
28138 }
28139
28140 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
28141 (un->un_state == SD_STATE_OFFLINE)) {
28142 return (ENXIO);
28143 }
28144
28145 #ifdef _MULTI_DATAMODEL
28146 switch (ddi_model_convert_from(flag & FMODELS)) {
28147 case DDI_MODEL_ILP32:
28148 if (ddi_copyin(data, cdrd32, sizeof (*cdrd32), flag) != 0) {
28149 return (EFAULT);
28150 }
28151 /* Convert the ILP32 uscsi data from the application to LP64 */
28152 cdrom_read32tocdrom_read(cdrd32, mode2);
28153 break;
28154 case DDI_MODEL_NONE:
28155 if (ddi_copyin(data, mode2, sizeof (*mode2), flag) != 0) {
28156 return (EFAULT);
28157 }
28158 break;
28159 }
28160
28161 #else /* ! _MULTI_DATAMODEL */
28162 if (ddi_copyin(data, mode2, sizeof (*mode2), flag) != 0) {
28163 return (EFAULT);
28164 }
28165 #endif /* _MULTI_DATAMODEL */
28166
28167 bzero(cdb, sizeof (cdb));
28168 if (un->un_f_cfg_read_cd_xd4 == TRUE) {
28169 /* Read command supported by 1st generation atapi drives */
28170 cdb[0] = SCMD_READ_CDD4;
28171 } else {
28172 /* Universal CD Access Command */
28173 cdb[0] = SCMD_READ_CD;
28174 }
28175
28176 /*
28177 * Set expected sector type to: 2336s byte, Mode 2 Yellow Book
28178 */
28179 cdb[1] = CDROM_SECTOR_TYPE_MODE2;
28180
28181 /* set the start address */
28182 cdb[2] = (uchar_t)((mode2->cdread_lba >> 24) & 0XFF);
28183 cdb[3] = (uchar_t)((mode2->cdread_lba >> 16) & 0XFF);
28184 cdb[4] = (uchar_t)((mode2->cdread_lba >> 8) & 0xFF);
28185 cdb[5] = (uchar_t)(mode2->cdread_lba & 0xFF);
28186
28187 /* set the transfer length */
28188 nblocks = mode2->cdread_buflen / 2336;
28189 cdb[6] = (uchar_t)(nblocks >> 16);
28190 cdb[7] = (uchar_t)(nblocks >> 8);
28191 cdb[8] = (uchar_t)nblocks;
28192
28193 /* set the filter bits */
28194 cdb[9] = CDROM_READ_CD_USERDATA;
28195
28196 com = kmem_zalloc(sizeof (*com), KM_SLEEP);
28197 com->uscsi_cdb = (caddr_t)cdb;
28198 com->uscsi_cdblen = sizeof (cdb);
28199 com->uscsi_bufaddr = mode2->cdread_bufaddr;
28200 com->uscsi_buflen = mode2->cdread_buflen;
28201 com->uscsi_flags = USCSI_DIAGNOSE|USCSI_SILENT|USCSI_READ;
28202
28203 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_USERSPACE,
28204 SD_PATH_STANDARD);
28205 kmem_free(com, sizeof (*com));
28206 return (rval);
28207 }
28208
28209
28210 /*
28211 * Function: sr_read_mode2()
28212 *
28213 * Description: This routine is the driver entry point for handling CD-ROM
28214 * ioctl read mode2 requests (CDROMREADMODE2) for devices that
28215 * do not support the READ CD (0xBE) command.
28216 *
28217 * Arguments: dev - the device 'dev_t'
28218 * data - pointer to user provided cd read structure specifying
28219 * the lba buffer address and length.
28220 * flag - this argument is a pass through to ddi_copyxxx()
28221 * directly from the mode argument of ioctl().
28222 *
28223 * Return Code: the code returned by sd_send_scsi_cmd()
28224 * EFAULT if ddi_copyxxx() fails
28225 * ENXIO if fail ddi_get_soft_state
28226 * EINVAL if data pointer is NULL
28227 * EIO if fail to reset block size
28228 * EAGAIN if commands are in progress in the driver
28229 */
28230
28231 static int
28232 sr_read_mode2(dev_t dev, caddr_t data, int flag)
28233 {
28234 struct sd_lun *un;
28235 struct cdrom_read mode2_struct;
28236 struct cdrom_read *mode2 = &mode2_struct;
28237 int rval;
28238 uint32_t restore_blksize;
28239 struct uscsi_cmd *com;
28240 uchar_t cdb[CDB_GROUP0];
28241 int nblocks;
28242
28243 #ifdef _MULTI_DATAMODEL
28244 /* To support ILP32 applications in an LP64 world */
28245 struct cdrom_read32 cdrom_read32;
28246 struct cdrom_read32 *cdrd32 = &cdrom_read32;
28247 #endif /* _MULTI_DATAMODEL */
28248
28249 if (data == NULL) {
28250 return (EINVAL);
28251 }
28252
28253 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
28254 (un->un_state == SD_STATE_OFFLINE)) {
28255 return (ENXIO);
28256 }
28257
28258 /*
28259 * Because this routine will update the device and driver block size
28260 * being used we want to make sure there are no commands in progress.
28261 * If commands are in progress the user will have to try again.
28262 *
28263 * We check for 1 instead of 0 because we increment un_ncmds_in_driver
28264 * in sdioctl to protect commands from sdioctl through to the top of
28265 * sd_uscsi_strategy. See sdioctl for details.
28266 */
28267 mutex_enter(SD_MUTEX(un));
28268 if (un->un_ncmds_in_driver != 1) {
28269 mutex_exit(SD_MUTEX(un));
28270 return (EAGAIN);
28271 }
28272 mutex_exit(SD_MUTEX(un));
28273
28274 SD_TRACE(SD_LOG_ATTACH_DETACH, un,
28275 "sd_read_mode2: entry: un:0x%p\n", un);
28276
28277 #ifdef _MULTI_DATAMODEL
28278 switch (ddi_model_convert_from(flag & FMODELS)) {
28279 case DDI_MODEL_ILP32:
28280 if (ddi_copyin(data, cdrd32, sizeof (*cdrd32), flag) != 0) {
28281 return (EFAULT);
28282 }
28283 /* Convert the ILP32 uscsi data from the application to LP64 */
28284 cdrom_read32tocdrom_read(cdrd32, mode2);
28285 break;
28286 case DDI_MODEL_NONE:
28287 if (ddi_copyin(data, mode2, sizeof (*mode2), flag) != 0) {
28288 return (EFAULT);
28289 }
28290 break;
28291 }
28292 #else /* ! _MULTI_DATAMODEL */
28293 if (ddi_copyin(data, mode2, sizeof (*mode2), flag)) {
28294 return (EFAULT);
28295 }
28296 #endif /* _MULTI_DATAMODEL */
28297
28298 /* Store the current target block size for restoration later */
28299 restore_blksize = un->un_tgt_blocksize;
28300
28301 /* Change the device and soft state target block size to 2336 */
28302 if (sr_sector_mode(dev, SD_MODE2_BLKSIZE) != 0) {
28303 rval = EIO;
28304 goto done;
28305 }
28306
28307
28308 bzero(cdb, sizeof (cdb));
28309
28310 /* set READ operation */
28311 cdb[0] = SCMD_READ;
28312
28313 /* adjust lba for 2kbyte blocks from 512 byte blocks */
28314 mode2->cdread_lba >>= 2;
28315
28316 /* set the start address */
28317 cdb[1] = (uchar_t)((mode2->cdread_lba >> 16) & 0X1F);
28318 cdb[2] = (uchar_t)((mode2->cdread_lba >> 8) & 0xFF);
28319 cdb[3] = (uchar_t)(mode2->cdread_lba & 0xFF);
28320
28321 /* set the transfer length */
28322 nblocks = mode2->cdread_buflen / 2336;
28323 cdb[4] = (uchar_t)nblocks & 0xFF;
28324
28325 /* build command */
28326 com = kmem_zalloc(sizeof (*com), KM_SLEEP);
28327 com->uscsi_cdb = (caddr_t)cdb;
28328 com->uscsi_cdblen = sizeof (cdb);
28329 com->uscsi_bufaddr = mode2->cdread_bufaddr;
28330 com->uscsi_buflen = mode2->cdread_buflen;
28331 com->uscsi_flags = USCSI_DIAGNOSE|USCSI_SILENT|USCSI_READ;
28332
28333 /*
28334 * Issue SCSI command with user space address for read buffer.
28335 *
28336 * This sends the command through main channel in the driver.
28337 *
28338 * Since this is accessed via an IOCTL call, we go through the
28339 * standard path, so that if the device was powered down, then
28340 * it would be 'awakened' to handle the command.
28341 */
28342 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_USERSPACE,
28343 SD_PATH_STANDARD);
28344
28345 kmem_free(com, sizeof (*com));
28346
28347 /* Restore the device and soft state target block size */
28348 if (sr_sector_mode(dev, restore_blksize) != 0) {
28349 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
28350 "can't do switch back to mode 1\n");
28351 /*
28352 * If sd_send_scsi_READ succeeded we still need to report
28353 * an error because we failed to reset the block size
28354 */
28355 if (rval == 0) {
28356 rval = EIO;
28357 }
28358 }
28359
28360 done:
28361 SD_TRACE(SD_LOG_ATTACH_DETACH, un,
28362 "sd_read_mode2: exit: un:0x%p\n", un);
28363
28364 return (rval);
28365 }
28366
28367
28368 /*
28369 * Function: sr_sector_mode()
28370 *
28371 * Description: This utility function is used by sr_read_mode2 to set the target
28372 * block size based on the user specified size. This is a legacy
28373 * implementation based upon a vendor specific mode page
28374 *
28375 * Arguments: dev - the device 'dev_t'
28376 * data - flag indicating if block size is being set to 2336 or
28377 * 512.
28378 *
28379 * Return Code: the code returned by sd_send_scsi_cmd()
28380 * EFAULT if ddi_copyxxx() fails
28381 * ENXIO if fail ddi_get_soft_state
28382 * EINVAL if data pointer is NULL
28383 */
28384
28385 static int
28386 sr_sector_mode(dev_t dev, uint32_t blksize)
28387 {
28388 struct sd_lun *un;
28389 uchar_t *sense;
28390 uchar_t *select;
28391 int rval;
28392 sd_ssc_t *ssc;
28393
28394 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
28395 (un->un_state == SD_STATE_OFFLINE)) {
28396 return (ENXIO);
28397 }
28398
28399 sense = kmem_zalloc(20, KM_SLEEP);
28400
28401 /* Note: This is a vendor specific mode page (0x81) */
28402 ssc = sd_ssc_init(un);
28403 rval = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP0, sense, 20, 0x81,
28404 SD_PATH_STANDARD);
28405 sd_ssc_fini(ssc);
28406 if (rval != 0) {
28407 SD_ERROR(SD_LOG_IOCTL_RMMEDIA, un,
28408 "sr_sector_mode: Mode Sense failed\n");
28409 kmem_free(sense, 20);
28410 return (rval);
28411 }
28412 select = kmem_zalloc(20, KM_SLEEP);
28413 select[3] = 0x08;
28414 select[10] = ((blksize >> 8) & 0xff);
28415 select[11] = (blksize & 0xff);
28416 select[12] = 0x01;
28417 select[13] = 0x06;
28418 select[14] = sense[14];
28419 select[15] = sense[15];
28420 if (blksize == SD_MODE2_BLKSIZE) {
28421 select[14] |= 0x01;
28422 }
28423
28424 ssc = sd_ssc_init(un);
28425 rval = sd_send_scsi_MODE_SELECT(ssc, CDB_GROUP0, select, 20,
28426 SD_DONTSAVE_PAGE, SD_PATH_STANDARD);
28427 sd_ssc_fini(ssc);
28428 if (rval != 0) {
28429 SD_ERROR(SD_LOG_IOCTL_RMMEDIA, un,
28430 "sr_sector_mode: Mode Select failed\n");
28431 } else {
28432 /*
28433 * Only update the softstate block size if we successfully
28434 * changed the device block mode.
28435 */
28436 mutex_enter(SD_MUTEX(un));
28437 sd_update_block_info(un, blksize, 0);
28438 mutex_exit(SD_MUTEX(un));
28439 }
28440 kmem_free(sense, 20);
28441 kmem_free(select, 20);
28442 return (rval);
28443 }
28444
28445
28446 /*
28447 * Function: sr_read_cdda()
28448 *
28449 * Description: This routine is the driver entry point for handling CD-ROM
28450 * ioctl requests to return CD-DA or subcode data. (CDROMCDDA) If
28451 * the target supports CDDA these requests are handled via a vendor
28452 * specific command (0xD8) If the target does not support CDDA
28453 * these requests are handled via the READ CD command (0xBE).
28454 *
28455 * Arguments: dev - the device 'dev_t'
28456 * data - pointer to user provided CD-DA structure specifying
28457 * the track starting address, transfer length, and
28458 * subcode options.
28459 * flag - this argument is a pass through to ddi_copyxxx()
28460 * directly from the mode argument of ioctl().
28461 *
28462 * Return Code: the code returned by sd_send_scsi_cmd()
28463 * EFAULT if ddi_copyxxx() fails
28464 * ENXIO if fail ddi_get_soft_state
28465 * EINVAL if invalid arguments are provided
28466 * ENOTTY
28467 */
28468
28469 static int
28470 sr_read_cdda(dev_t dev, caddr_t data, int flag)
28471 {
28472 struct sd_lun *un;
28473 struct uscsi_cmd *com;
28474 struct cdrom_cdda *cdda;
28475 int rval;
28476 size_t buflen;
28477 char cdb[CDB_GROUP5];
28478
28479 #ifdef _MULTI_DATAMODEL
28480 /* To support ILP32 applications in an LP64 world */
28481 struct cdrom_cdda32 cdrom_cdda32;
28482 struct cdrom_cdda32 *cdda32 = &cdrom_cdda32;
28483 #endif /* _MULTI_DATAMODEL */
28484
28485 if (data == NULL) {
28486 return (EINVAL);
28487 }
28488
28489 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
28490 return (ENXIO);
28491 }
28492
28493 cdda = kmem_zalloc(sizeof (struct cdrom_cdda), KM_SLEEP);
28494
28495 #ifdef _MULTI_DATAMODEL
28496 switch (ddi_model_convert_from(flag & FMODELS)) {
28497 case DDI_MODEL_ILP32:
28498 if (ddi_copyin(data, cdda32, sizeof (*cdda32), flag)) {
28499 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
28500 "sr_read_cdda: ddi_copyin Failed\n");
28501 kmem_free(cdda, sizeof (struct cdrom_cdda));
28502 return (EFAULT);
28503 }
28504 /* Convert the ILP32 uscsi data from the application to LP64 */
28505 cdrom_cdda32tocdrom_cdda(cdda32, cdda);
28506 break;
28507 case DDI_MODEL_NONE:
28508 if (ddi_copyin(data, cdda, sizeof (struct cdrom_cdda), flag)) {
28509 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
28510 "sr_read_cdda: ddi_copyin Failed\n");
28511 kmem_free(cdda, sizeof (struct cdrom_cdda));
28512 return (EFAULT);
28513 }
28514 break;
28515 }
28516 #else /* ! _MULTI_DATAMODEL */
28517 if (ddi_copyin(data, cdda, sizeof (struct cdrom_cdda), flag)) {
28518 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
28519 "sr_read_cdda: ddi_copyin Failed\n");
28520 kmem_free(cdda, sizeof (struct cdrom_cdda));
28521 return (EFAULT);
28522 }
28523 #endif /* _MULTI_DATAMODEL */
28524
28525 /*
28526 * Since MMC-2 expects max 3 bytes for length, check if the
28527 * length input is greater than 3 bytes
28528 */
28529 if ((cdda->cdda_length & 0xFF000000) != 0) {
28530 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, "sr_read_cdda: "
28531 "cdrom transfer length too large: %d (limit %d)\n",
28532 cdda->cdda_length, 0xFFFFFF);
28533 kmem_free(cdda, sizeof (struct cdrom_cdda));
28534 return (EINVAL);
28535 }
28536
28537 switch (cdda->cdda_subcode) {
28538 case CDROM_DA_NO_SUBCODE:
28539 buflen = CDROM_BLK_2352 * cdda->cdda_length;
28540 break;
28541 case CDROM_DA_SUBQ:
28542 buflen = CDROM_BLK_2368 * cdda->cdda_length;
28543 break;
28544 case CDROM_DA_ALL_SUBCODE:
28545 buflen = CDROM_BLK_2448 * cdda->cdda_length;
28546 break;
28547 case CDROM_DA_SUBCODE_ONLY:
28548 buflen = CDROM_BLK_SUBCODE * cdda->cdda_length;
28549 break;
28550 default:
28551 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
28552 "sr_read_cdda: Subcode '0x%x' Not Supported\n",
28553 cdda->cdda_subcode);
28554 kmem_free(cdda, sizeof (struct cdrom_cdda));
28555 return (EINVAL);
28556 }
28557
28558 /* Build and send the command */
28559 com = kmem_zalloc(sizeof (*com), KM_SLEEP);
28560 bzero(cdb, CDB_GROUP5);
28561
28562 if (un->un_f_cfg_cdda == TRUE) {
28563 cdb[0] = (char)SCMD_READ_CD;
28564 cdb[1] = 0x04;
28565 cdb[2] = (((cdda->cdda_addr) & 0xff000000) >> 24);
28566 cdb[3] = (((cdda->cdda_addr) & 0x00ff0000) >> 16);
28567 cdb[4] = (((cdda->cdda_addr) & 0x0000ff00) >> 8);
28568 cdb[5] = ((cdda->cdda_addr) & 0x000000ff);
28569 cdb[6] = (((cdda->cdda_length) & 0x00ff0000) >> 16);
28570 cdb[7] = (((cdda->cdda_length) & 0x0000ff00) >> 8);
28571 cdb[8] = ((cdda->cdda_length) & 0x000000ff);
28572 cdb[9] = 0x10;
28573 switch (cdda->cdda_subcode) {
28574 case CDROM_DA_NO_SUBCODE :
28575 cdb[10] = 0x0;
28576 break;
28577 case CDROM_DA_SUBQ :
28578 cdb[10] = 0x2;
28579 break;
28580 case CDROM_DA_ALL_SUBCODE :
28581 cdb[10] = 0x1;
28582 break;
28583 case CDROM_DA_SUBCODE_ONLY :
28584 /* FALLTHROUGH */
28585 default :
28586 kmem_free(cdda, sizeof (struct cdrom_cdda));
28587 kmem_free(com, sizeof (*com));
28588 return (ENOTTY);
28589 }
28590 } else {
28591 cdb[0] = (char)SCMD_READ_CDDA;
28592 cdb[2] = (((cdda->cdda_addr) & 0xff000000) >> 24);
28593 cdb[3] = (((cdda->cdda_addr) & 0x00ff0000) >> 16);
28594 cdb[4] = (((cdda->cdda_addr) & 0x0000ff00) >> 8);
28595 cdb[5] = ((cdda->cdda_addr) & 0x000000ff);
28596 cdb[6] = (((cdda->cdda_length) & 0xff000000) >> 24);
28597 cdb[7] = (((cdda->cdda_length) & 0x00ff0000) >> 16);
28598 cdb[8] = (((cdda->cdda_length) & 0x0000ff00) >> 8);
28599 cdb[9] = ((cdda->cdda_length) & 0x000000ff);
28600 cdb[10] = cdda->cdda_subcode;
28601 }
28602
28603 com->uscsi_cdb = cdb;
28604 com->uscsi_cdblen = CDB_GROUP5;
28605 com->uscsi_bufaddr = (caddr_t)cdda->cdda_data;
28606 com->uscsi_buflen = buflen;
28607 com->uscsi_flags = USCSI_DIAGNOSE|USCSI_SILENT|USCSI_READ;
28608
28609 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_USERSPACE,
28610 SD_PATH_STANDARD);
28611
28612 kmem_free(cdda, sizeof (struct cdrom_cdda));
28613 kmem_free(com, sizeof (*com));
28614 return (rval);
28615 }
28616
28617
28618 /*
28619 * Function: sr_read_cdxa()
28620 *
28621 * Description: This routine is the driver entry point for handling CD-ROM
28622 * ioctl requests to return CD-XA (Extended Architecture) data.
28623 * (CDROMCDXA).
28624 *
28625 * Arguments: dev - the device 'dev_t'
28626 * data - pointer to user provided CD-XA structure specifying
28627 * the data starting address, transfer length, and format
28628 * flag - this argument is a pass through to ddi_copyxxx()
28629 * directly from the mode argument of ioctl().
28630 *
28631 * Return Code: the code returned by sd_send_scsi_cmd()
28632 * EFAULT if ddi_copyxxx() fails
28633 * ENXIO if fail ddi_get_soft_state
28634 * EINVAL if data pointer is NULL
28635 */
28636
28637 static int
28638 sr_read_cdxa(dev_t dev, caddr_t data, int flag)
28639 {
28640 struct sd_lun *un;
28641 struct uscsi_cmd *com;
28642 struct cdrom_cdxa *cdxa;
28643 int rval;
28644 size_t buflen;
28645 char cdb[CDB_GROUP5];
28646 uchar_t read_flags;
28647
28648 #ifdef _MULTI_DATAMODEL
28649 /* To support ILP32 applications in an LP64 world */
28650 struct cdrom_cdxa32 cdrom_cdxa32;
28651 struct cdrom_cdxa32 *cdxa32 = &cdrom_cdxa32;
28652 #endif /* _MULTI_DATAMODEL */
28653
28654 if (data == NULL) {
28655 return (EINVAL);
28656 }
28657
28658 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
28659 return (ENXIO);
28660 }
28661
28662 cdxa = kmem_zalloc(sizeof (struct cdrom_cdxa), KM_SLEEP);
28663
28664 #ifdef _MULTI_DATAMODEL
28665 switch (ddi_model_convert_from(flag & FMODELS)) {
28666 case DDI_MODEL_ILP32:
28667 if (ddi_copyin(data, cdxa32, sizeof (*cdxa32), flag)) {
28668 kmem_free(cdxa, sizeof (struct cdrom_cdxa));
28669 return (EFAULT);
28670 }
28671 /*
28672 * Convert the ILP32 uscsi data from the
28673 * application to LP64 for internal use.
28674 */
28675 cdrom_cdxa32tocdrom_cdxa(cdxa32, cdxa);
28676 break;
28677 case DDI_MODEL_NONE:
28678 if (ddi_copyin(data, cdxa, sizeof (struct cdrom_cdxa), flag)) {
28679 kmem_free(cdxa, sizeof (struct cdrom_cdxa));
28680 return (EFAULT);
28681 }
28682 break;
28683 }
28684 #else /* ! _MULTI_DATAMODEL */
28685 if (ddi_copyin(data, cdxa, sizeof (struct cdrom_cdxa), flag)) {
28686 kmem_free(cdxa, sizeof (struct cdrom_cdxa));
28687 return (EFAULT);
28688 }
28689 #endif /* _MULTI_DATAMODEL */
28690
28691 /*
28692 * Since MMC-2 expects max 3 bytes for length, check if the
28693 * length input is greater than 3 bytes
28694 */
28695 if ((cdxa->cdxa_length & 0xFF000000) != 0) {
28696 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, "sr_read_cdxa: "
28697 "cdrom transfer length too large: %d (limit %d)\n",
28698 cdxa->cdxa_length, 0xFFFFFF);
28699 kmem_free(cdxa, sizeof (struct cdrom_cdxa));
28700 return (EINVAL);
28701 }
28702
28703 switch (cdxa->cdxa_format) {
28704 case CDROM_XA_DATA:
28705 buflen = CDROM_BLK_2048 * cdxa->cdxa_length;
28706 read_flags = 0x10;
28707 break;
28708 case CDROM_XA_SECTOR_DATA:
28709 buflen = CDROM_BLK_2352 * cdxa->cdxa_length;
28710 read_flags = 0xf8;
28711 break;
28712 case CDROM_XA_DATA_W_ERROR:
28713 buflen = CDROM_BLK_2646 * cdxa->cdxa_length;
28714 read_flags = 0xfc;
28715 break;
28716 default:
28717 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
28718 "sr_read_cdxa: Format '0x%x' Not Supported\n",
28719 cdxa->cdxa_format);
28720 kmem_free(cdxa, sizeof (struct cdrom_cdxa));
28721 return (EINVAL);
28722 }
28723
28724 com = kmem_zalloc(sizeof (*com), KM_SLEEP);
28725 bzero(cdb, CDB_GROUP5);
28726 if (un->un_f_mmc_cap == TRUE) {
28727 cdb[0] = (char)SCMD_READ_CD;
28728 cdb[2] = (((cdxa->cdxa_addr) & 0xff000000) >> 24);
28729 cdb[3] = (((cdxa->cdxa_addr) & 0x00ff0000) >> 16);
28730 cdb[4] = (((cdxa->cdxa_addr) & 0x0000ff00) >> 8);
28731 cdb[5] = ((cdxa->cdxa_addr) & 0x000000ff);
28732 cdb[6] = (((cdxa->cdxa_length) & 0x00ff0000) >> 16);
28733 cdb[7] = (((cdxa->cdxa_length) & 0x0000ff00) >> 8);
28734 cdb[8] = ((cdxa->cdxa_length) & 0x000000ff);
28735 cdb[9] = (char)read_flags;
28736 } else {
28737 /*
28738 * Note: A vendor specific command (0xDB) is being used her to
28739 * request a read of all subcodes.
28740 */
28741 cdb[0] = (char)SCMD_READ_CDXA;
28742 cdb[2] = (((cdxa->cdxa_addr) & 0xff000000) >> 24);
28743 cdb[3] = (((cdxa->cdxa_addr) & 0x00ff0000) >> 16);
28744 cdb[4] = (((cdxa->cdxa_addr) & 0x0000ff00) >> 8);
28745 cdb[5] = ((cdxa->cdxa_addr) & 0x000000ff);
28746 cdb[6] = (((cdxa->cdxa_length) & 0xff000000) >> 24);
28747 cdb[7] = (((cdxa->cdxa_length) & 0x00ff0000) >> 16);
28748 cdb[8] = (((cdxa->cdxa_length) & 0x0000ff00) >> 8);
28749 cdb[9] = ((cdxa->cdxa_length) & 0x000000ff);
28750 cdb[10] = cdxa->cdxa_format;
28751 }
28752 com->uscsi_cdb = cdb;
28753 com->uscsi_cdblen = CDB_GROUP5;
28754 com->uscsi_bufaddr = (caddr_t)cdxa->cdxa_data;
28755 com->uscsi_buflen = buflen;
28756 com->uscsi_flags = USCSI_DIAGNOSE|USCSI_SILENT|USCSI_READ;
28757 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_USERSPACE,
28758 SD_PATH_STANDARD);
28759 kmem_free(cdxa, sizeof (struct cdrom_cdxa));
28760 kmem_free(com, sizeof (*com));
28761 return (rval);
28762 }
28763
28764
28765 /*
28766 * Function: sr_eject()
28767 *
28768 * Description: This routine is the driver entry point for handling CD-ROM
28769 * eject ioctl requests (FDEJECT, DKIOCEJECT, CDROMEJECT)
28770 *
28771 * Arguments: dev - the device 'dev_t'
28772 *
28773 * Return Code: the code returned by sd_send_scsi_cmd()
28774 */
28775
28776 static int
28777 sr_eject(dev_t dev)
28778 {
28779 struct sd_lun *un;
28780 int rval;
28781 sd_ssc_t *ssc;
28782
28783 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
28784 (un->un_state == SD_STATE_OFFLINE)) {
28785 return (ENXIO);
28786 }
28787
28788 /*
28789 * To prevent race conditions with the eject
28790 * command, keep track of an eject command as
28791 * it progresses. If we are already handling
28792 * an eject command in the driver for the given
28793 * unit and another request to eject is received
28794 * immediately return EAGAIN so we don't lose
28795 * the command if the current eject command fails.
28796 */
28797 mutex_enter(SD_MUTEX(un));
28798 if (un->un_f_ejecting == TRUE) {
28799 mutex_exit(SD_MUTEX(un));
28800 return (EAGAIN);
28801 }
28802 un->un_f_ejecting = TRUE;
28803 mutex_exit(SD_MUTEX(un));
28804
28805 ssc = sd_ssc_init(un);
28806 rval = sd_send_scsi_DOORLOCK(ssc, SD_REMOVAL_ALLOW,
28807 SD_PATH_STANDARD);
28808 sd_ssc_fini(ssc);
28809
28810 if (rval != 0) {
28811 mutex_enter(SD_MUTEX(un));
28812 un->un_f_ejecting = FALSE;
28813 mutex_exit(SD_MUTEX(un));
28814 return (rval);
28815 }
28816
28817 ssc = sd_ssc_init(un);
28818 rval = sd_send_scsi_START_STOP_UNIT(ssc, SD_START_STOP,
28819 SD_TARGET_EJECT, SD_PATH_STANDARD);
28820 sd_ssc_fini(ssc);
28821
28822 if (rval == 0) {
28823 mutex_enter(SD_MUTEX(un));
28824 sr_ejected(un);
28825 un->un_mediastate = DKIO_EJECTED;
28826 un->un_f_ejecting = FALSE;
28827 cv_broadcast(&un->un_state_cv);
28828 mutex_exit(SD_MUTEX(un));
28829 } else {
28830 mutex_enter(SD_MUTEX(un));
28831 un->un_f_ejecting = FALSE;
28832 mutex_exit(SD_MUTEX(un));
28833 }
28834 return (rval);
28835 }
28836
28837
28838 /*
28839 * Function: sr_ejected()
28840 *
28841 * Description: This routine updates the soft state structure to invalidate the
28842 * geometry information after the media has been ejected or a
28843 * media eject has been detected.
28844 *
28845 * Arguments: un - driver soft state (unit) structure
28846 */
28847
28848 static void
28849 sr_ejected(struct sd_lun *un)
28850 {
28851 struct sd_errstats *stp;
28852
28853 ASSERT(un != NULL);
28854 ASSERT(mutex_owned(SD_MUTEX(un)));
28855
28856 un->un_f_blockcount_is_valid = FALSE;
28857 un->un_f_tgt_blocksize_is_valid = FALSE;
28858 mutex_exit(SD_MUTEX(un));
28859 cmlb_invalidate(un->un_cmlbhandle, (void *)SD_PATH_DIRECT_PRIORITY);
28860 mutex_enter(SD_MUTEX(un));
28861
28862 if (un->un_errstats != NULL) {
28863 stp = (struct sd_errstats *)un->un_errstats->ks_data;
28864 stp->sd_capacity.value.ui64 = 0;
28865 }
28866 }
28867
28868
28869 /*
28870 * Function: sr_check_wp()
28871 *
28872 * Description: This routine checks the write protection of a removable
28873 * media disk and hotpluggable devices via the write protect bit of
28874 * the Mode Page Header device specific field. Some devices choke
28875 * on unsupported mode page. In order to workaround this issue,
28876 * this routine has been implemented to use 0x3f mode page(request
28877 * for all pages) for all device types.
28878 *
28879 * Arguments: dev - the device 'dev_t'
28880 *
28881 * Return Code: int indicating if the device is write protected (1) or not (0)
28882 *
28883 * Context: Kernel thread.
28884 *
28885 */
28886
28887 static int
28888 sr_check_wp(dev_t dev)
28889 {
28890 struct sd_lun *un;
28891 uchar_t device_specific;
28892 uchar_t *sense;
28893 int hdrlen;
28894 int rval = FALSE;
28895 int status;
28896 sd_ssc_t *ssc;
28897
28898 /*
28899 * Note: The return codes for this routine should be reworked to
28900 * properly handle the case of a NULL softstate.
28901 */
28902 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
28903 return (FALSE);
28904 }
28905
28906 if (un->un_f_cfg_is_atapi == TRUE) {
28907 /*
28908 * The mode page contents are not required; set the allocation
28909 * length for the mode page header only
28910 */
28911 hdrlen = MODE_HEADER_LENGTH_GRP2;
28912 sense = kmem_zalloc(hdrlen, KM_SLEEP);
28913 ssc = sd_ssc_init(un);
28914 status = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP1, sense, hdrlen,
28915 MODEPAGE_ALLPAGES, SD_PATH_STANDARD);
28916 sd_ssc_fini(ssc);
28917 if (status != 0)
28918 goto err_exit;
28919 device_specific =
28920 ((struct mode_header_grp2 *)sense)->device_specific;
28921 } else {
28922 hdrlen = MODE_HEADER_LENGTH;
28923 sense = kmem_zalloc(hdrlen, KM_SLEEP);
28924 ssc = sd_ssc_init(un);
28925 status = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP0, sense, hdrlen,
28926 MODEPAGE_ALLPAGES, SD_PATH_STANDARD);
28927 sd_ssc_fini(ssc);
28928 if (status != 0)
28929 goto err_exit;
28930 device_specific =
28931 ((struct mode_header *)sense)->device_specific;
28932 }
28933
28934
28935 /*
28936 * Write protect mode sense failed; not all disks
28937 * understand this query. Return FALSE assuming that
28938 * these devices are not writable.
28939 */
28940 if (device_specific & WRITE_PROTECT) {
28941 rval = TRUE;
28942 }
28943
28944 err_exit:
28945 kmem_free(sense, hdrlen);
28946 return (rval);
28947 }
28948
28949 /*
28950 * Function: sr_volume_ctrl()
28951 *
28952 * Description: This routine is the driver entry point for handling CD-ROM
28953 * audio output volume ioctl requests. (CDROMVOLCTRL)
28954 *
28955 * Arguments: dev - the device 'dev_t'
28956 * data - pointer to user audio volume control structure
28957 * flag - this argument is a pass through to ddi_copyxxx()
28958 * directly from the mode argument of ioctl().
28959 *
28960 * Return Code: the code returned by sd_send_scsi_cmd()
28961 * EFAULT if ddi_copyxxx() fails
28962 * ENXIO if fail ddi_get_soft_state
28963 * EINVAL if data pointer is NULL
28964 *
28965 */
28966
28967 static int
28968 sr_volume_ctrl(dev_t dev, caddr_t data, int flag)
28969 {
28970 struct sd_lun *un;
28971 struct cdrom_volctrl volume;
28972 struct cdrom_volctrl *vol = &volume;
28973 uchar_t *sense_page;
28974 uchar_t *select_page;
28975 uchar_t *sense;
28976 uchar_t *select;
28977 int sense_buflen;
28978 int select_buflen;
28979 int rval;
28980 sd_ssc_t *ssc;
28981
28982 if (data == NULL) {
28983 return (EINVAL);
28984 }
28985
28986 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
28987 (un->un_state == SD_STATE_OFFLINE)) {
28988 return (ENXIO);
28989 }
28990
28991 if (ddi_copyin(data, vol, sizeof (struct cdrom_volctrl), flag)) {
28992 return (EFAULT);
28993 }
28994
28995 if ((un->un_f_cfg_is_atapi == TRUE) || (un->un_f_mmc_cap == TRUE)) {
28996 struct mode_header_grp2 *sense_mhp;
28997 struct mode_header_grp2 *select_mhp;
28998 int bd_len;
28999
29000 sense_buflen = MODE_PARAM_LENGTH_GRP2 + MODEPAGE_AUDIO_CTRL_LEN;
29001 select_buflen = MODE_HEADER_LENGTH_GRP2 +
29002 MODEPAGE_AUDIO_CTRL_LEN;
29003 sense = kmem_zalloc(sense_buflen, KM_SLEEP);
29004 select = kmem_zalloc(select_buflen, KM_SLEEP);
29005 ssc = sd_ssc_init(un);
29006 rval = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP1, sense,
29007 sense_buflen, MODEPAGE_AUDIO_CTRL,
29008 SD_PATH_STANDARD);
29009 sd_ssc_fini(ssc);
29010
29011 if (rval != 0) {
29012 SD_ERROR(SD_LOG_IOCTL_RMMEDIA, un,
29013 "sr_volume_ctrl: Mode Sense Failed\n");
29014 kmem_free(sense, sense_buflen);
29015 kmem_free(select, select_buflen);
29016 return (rval);
29017 }
29018 sense_mhp = (struct mode_header_grp2 *)sense;
29019 select_mhp = (struct mode_header_grp2 *)select;
29020 bd_len = (sense_mhp->bdesc_length_hi << 8) |
29021 sense_mhp->bdesc_length_lo;
29022 if (bd_len > MODE_BLK_DESC_LENGTH) {
29023 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
29024 "sr_volume_ctrl: Mode Sense returned invalid "
29025 "block descriptor length\n");
29026 kmem_free(sense, sense_buflen);
29027 kmem_free(select, select_buflen);
29028 return (EIO);
29029 }
29030 sense_page = (uchar_t *)
29031 (sense + MODE_HEADER_LENGTH_GRP2 + bd_len);
29032 select_page = (uchar_t *)(select + MODE_HEADER_LENGTH_GRP2);
29033 select_mhp->length_msb = 0;
29034 select_mhp->length_lsb = 0;
29035 select_mhp->bdesc_length_hi = 0;
29036 select_mhp->bdesc_length_lo = 0;
29037 } else {
29038 struct mode_header *sense_mhp, *select_mhp;
29039
29040 sense_buflen = MODE_PARAM_LENGTH + MODEPAGE_AUDIO_CTRL_LEN;
29041 select_buflen = MODE_HEADER_LENGTH + MODEPAGE_AUDIO_CTRL_LEN;
29042 sense = kmem_zalloc(sense_buflen, KM_SLEEP);
29043 select = kmem_zalloc(select_buflen, KM_SLEEP);
29044 ssc = sd_ssc_init(un);
29045 rval = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP0, sense,
29046 sense_buflen, MODEPAGE_AUDIO_CTRL,
29047 SD_PATH_STANDARD);
29048 sd_ssc_fini(ssc);
29049
29050 if (rval != 0) {
29051 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
29052 "sr_volume_ctrl: Mode Sense Failed\n");
29053 kmem_free(sense, sense_buflen);
29054 kmem_free(select, select_buflen);
29055 return (rval);
29056 }
29057 sense_mhp = (struct mode_header *)sense;
29058 select_mhp = (struct mode_header *)select;
29059 if (sense_mhp->bdesc_length > MODE_BLK_DESC_LENGTH) {
29060 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
29061 "sr_volume_ctrl: Mode Sense returned invalid "
29062 "block descriptor length\n");
29063 kmem_free(sense, sense_buflen);
29064 kmem_free(select, select_buflen);
29065 return (EIO);
29066 }
29067 sense_page = (uchar_t *)
29068 (sense + MODE_HEADER_LENGTH + sense_mhp->bdesc_length);
29069 select_page = (uchar_t *)(select + MODE_HEADER_LENGTH);
29070 select_mhp->length = 0;
29071 select_mhp->bdesc_length = 0;
29072 }
29073 /*
29074 * Note: An audio control data structure could be created and overlayed
29075 * on the following in place of the array indexing method implemented.
29076 */
29077
29078 /* Build the select data for the user volume data */
29079 select_page[0] = MODEPAGE_AUDIO_CTRL;
29080 select_page[1] = 0xE;
29081 /* Set the immediate bit */
29082 select_page[2] = 0x04;
29083 /* Zero out reserved fields */
29084 select_page[3] = 0x00;
29085 select_page[4] = 0x00;
29086 /* Return sense data for fields not to be modified */
29087 select_page[5] = sense_page[5];
29088 select_page[6] = sense_page[6];
29089 select_page[7] = sense_page[7];
29090 /* Set the user specified volume levels for channel 0 and 1 */
29091 select_page[8] = 0x01;
29092 select_page[9] = vol->channel0;
29093 select_page[10] = 0x02;
29094 select_page[11] = vol->channel1;
29095 /* Channel 2 and 3 are currently unsupported so return the sense data */
29096 select_page[12] = sense_page[12];
29097 select_page[13] = sense_page[13];
29098 select_page[14] = sense_page[14];
29099 select_page[15] = sense_page[15];
29100
29101 ssc = sd_ssc_init(un);
29102 if ((un->un_f_cfg_is_atapi == TRUE) || (un->un_f_mmc_cap == TRUE)) {
29103 rval = sd_send_scsi_MODE_SELECT(ssc, CDB_GROUP1, select,
29104 select_buflen, SD_DONTSAVE_PAGE, SD_PATH_STANDARD);
29105 } else {
29106 rval = sd_send_scsi_MODE_SELECT(ssc, CDB_GROUP0, select,
29107 select_buflen, SD_DONTSAVE_PAGE, SD_PATH_STANDARD);
29108 }
29109 sd_ssc_fini(ssc);
29110
29111 kmem_free(sense, sense_buflen);
29112 kmem_free(select, select_buflen);
29113 return (rval);
29114 }
29115
29116
29117 /*
29118 * Function: sr_read_sony_session_offset()
29119 *
29120 * Description: This routine is the driver entry point for handling CD-ROM
29121 * ioctl requests for session offset information. (CDROMREADOFFSET)
29122 * The address of the first track in the last session of a
29123 * multi-session CD-ROM is returned
29124 *
29125 * Note: This routine uses a vendor specific key value in the
29126 * command control field without implementing any vendor check here
29127 * or in the ioctl routine.
29128 *
29129 * Arguments: dev - the device 'dev_t'
29130 * data - pointer to an int to hold the requested address
29131 * flag - this argument is a pass through to ddi_copyxxx()
29132 * directly from the mode argument of ioctl().
29133 *
29134 * Return Code: the code returned by sd_send_scsi_cmd()
29135 * EFAULT if ddi_copyxxx() fails
29136 * ENXIO if fail ddi_get_soft_state
29137 * EINVAL if data pointer is NULL
29138 */
29139
29140 static int
29141 sr_read_sony_session_offset(dev_t dev, caddr_t data, int flag)
29142 {
29143 struct sd_lun *un;
29144 struct uscsi_cmd *com;
29145 caddr_t buffer;
29146 char cdb[CDB_GROUP1];
29147 int session_offset = 0;
29148 int rval;
29149
29150 if (data == NULL) {
29151 return (EINVAL);
29152 }
29153
29154 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
29155 (un->un_state == SD_STATE_OFFLINE)) {
29156 return (ENXIO);
29157 }
29158
29159 buffer = kmem_zalloc((size_t)SONY_SESSION_OFFSET_LEN, KM_SLEEP);
29160 bzero(cdb, CDB_GROUP1);
29161 cdb[0] = SCMD_READ_TOC;
29162 /*
29163 * Bytes 7 & 8 are the 12 byte allocation length for a single entry.
29164 * (4 byte TOC response header + 8 byte response data)
29165 */
29166 cdb[8] = SONY_SESSION_OFFSET_LEN;
29167 /* Byte 9 is the control byte. A vendor specific value is used */
29168 cdb[9] = SONY_SESSION_OFFSET_KEY;
29169 com = kmem_zalloc(sizeof (*com), KM_SLEEP);
29170 com->uscsi_cdb = cdb;
29171 com->uscsi_cdblen = CDB_GROUP1;
29172 com->uscsi_bufaddr = buffer;
29173 com->uscsi_buflen = SONY_SESSION_OFFSET_LEN;
29174 com->uscsi_flags = USCSI_DIAGNOSE|USCSI_SILENT|USCSI_READ;
29175
29176 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_SYSSPACE,
29177 SD_PATH_STANDARD);
29178 if (rval != 0) {
29179 kmem_free(buffer, SONY_SESSION_OFFSET_LEN);
29180 kmem_free(com, sizeof (*com));
29181 return (rval);
29182 }
29183 if (buffer[1] == SONY_SESSION_OFFSET_VALID) {
29184 session_offset =
29185 ((uchar_t)buffer[8] << 24) + ((uchar_t)buffer[9] << 16) +
29186 ((uchar_t)buffer[10] << 8) + ((uchar_t)buffer[11]);
29187 /*
29188 * Offset returned offset in current lbasize block's. Convert to
29189 * 2k block's to return to the user
29190 */
29191 if (un->un_tgt_blocksize == CDROM_BLK_512) {
29192 session_offset >>= 2;
29193 } else if (un->un_tgt_blocksize == CDROM_BLK_1024) {
29194 session_offset >>= 1;
29195 }
29196 }
29197
29198 if (ddi_copyout(&session_offset, data, sizeof (int), flag) != 0) {
29199 rval = EFAULT;
29200 }
29201
29202 kmem_free(buffer, SONY_SESSION_OFFSET_LEN);
29203 kmem_free(com, sizeof (*com));
29204 return (rval);
29205 }
29206
29207
29208 /*
29209 * Function: sd_wm_cache_constructor()
29210 *
29211 * Description: Cache Constructor for the wmap cache for the read/modify/write
29212 * devices.
29213 *
29214 * Arguments: wm - A pointer to the sd_w_map to be initialized.
29215 * un - sd_lun structure for the device.
29216 * flag - the km flags passed to constructor
29217 *
29218 * Return Code: 0 on success.
29219 * -1 on failure.
29220 */
29221
29222 /*ARGSUSED*/
29223 static int
29224 sd_wm_cache_constructor(void *wm, void *un, int flags)
29225 {
29226 bzero(wm, sizeof (struct sd_w_map));
29227 cv_init(&((struct sd_w_map *)wm)->wm_avail, NULL, CV_DRIVER, NULL);
29228 return (0);
29229 }
29230
29231
29232 /*
29233 * Function: sd_wm_cache_destructor()
29234 *
29235 * Description: Cache destructor for the wmap cache for the read/modify/write
29236 * devices.
29237 *
29238 * Arguments: wm - A pointer to the sd_w_map to be initialized.
29239 * un - sd_lun structure for the device.
29240 */
29241 /*ARGSUSED*/
29242 static void
29243 sd_wm_cache_destructor(void *wm, void *un)
29244 {
29245 cv_destroy(&((struct sd_w_map *)wm)->wm_avail);
29246 }
29247
29248
29249 /*
29250 * Function: sd_range_lock()
29251 *
29252 * Description: Lock the range of blocks specified as parameter to ensure
29253 * that read, modify write is atomic and no other i/o writes
29254 * to the same location. The range is specified in terms
29255 * of start and end blocks. Block numbers are the actual
29256 * media block numbers and not system.
29257 *
29258 * Arguments: un - sd_lun structure for the device.
29259 * startb - The starting block number
29260 * endb - The end block number
29261 * typ - type of i/o - simple/read_modify_write
29262 *
29263 * Return Code: wm - pointer to the wmap structure.
29264 *
29265 * Context: This routine can sleep.
29266 */
29267
29268 static struct sd_w_map *
29269 sd_range_lock(struct sd_lun *un, daddr_t startb, daddr_t endb, ushort_t typ)
29270 {
29271 struct sd_w_map *wmp = NULL;
29272 struct sd_w_map *sl_wmp = NULL;
29273 struct sd_w_map *tmp_wmp;
29274 wm_state state = SD_WM_CHK_LIST;
29275
29276
29277 ASSERT(un != NULL);
29278 ASSERT(!mutex_owned(SD_MUTEX(un)));
29279
29280 mutex_enter(SD_MUTEX(un));
29281
29282 while (state != SD_WM_DONE) {
29283
29284 switch (state) {
29285 case SD_WM_CHK_LIST:
29286 /*
29287 * This is the starting state. Check the wmap list
29288 * to see if the range is currently available.
29289 */
29290 if (!(typ & SD_WTYPE_RMW) && !(un->un_rmw_count)) {
29291 /*
29292 * If this is a simple write and no rmw
29293 * i/o is pending then try to lock the
29294 * range as the range should be available.
29295 */
29296 state = SD_WM_LOCK_RANGE;
29297 } else {
29298 tmp_wmp = sd_get_range(un, startb, endb);
29299 if (tmp_wmp != NULL) {
29300 if ((wmp != NULL) && ONLIST(un, wmp)) {
29301 /*
29302 * Should not keep onlist wmps
29303 * while waiting this macro
29304 * will also do wmp = NULL;
29305 */
29306 FREE_ONLIST_WMAP(un, wmp);
29307 }
29308 /*
29309 * sl_wmp is the wmap on which wait
29310 * is done, since the tmp_wmp points
29311 * to the inuse wmap, set sl_wmp to
29312 * tmp_wmp and change the state to sleep
29313 */
29314 sl_wmp = tmp_wmp;
29315 state = SD_WM_WAIT_MAP;
29316 } else {
29317 state = SD_WM_LOCK_RANGE;
29318 }
29319
29320 }
29321 break;
29322
29323 case SD_WM_LOCK_RANGE:
29324 ASSERT(un->un_wm_cache);
29325 /*
29326 * The range need to be locked, try to get a wmap.
29327 * First attempt it with NO_SLEEP, want to avoid a sleep
29328 * if possible as we will have to release the sd mutex
29329 * if we have to sleep.
29330 */
29331 if (wmp == NULL)
29332 wmp = kmem_cache_alloc(un->un_wm_cache,
29333 KM_NOSLEEP);
29334 if (wmp == NULL) {
29335 mutex_exit(SD_MUTEX(un));
29336 _NOTE(DATA_READABLE_WITHOUT_LOCK
29337 (sd_lun::un_wm_cache))
29338 wmp = kmem_cache_alloc(un->un_wm_cache,
29339 KM_SLEEP);
29340 mutex_enter(SD_MUTEX(un));
29341 /*
29342 * we released the mutex so recheck and go to
29343 * check list state.
29344 */
29345 state = SD_WM_CHK_LIST;
29346 } else {
29347 /*
29348 * We exit out of state machine since we
29349 * have the wmap. Do the housekeeping first.
29350 * place the wmap on the wmap list if it is not
29351 * on it already and then set the state to done.
29352 */
29353 wmp->wm_start = startb;
29354 wmp->wm_end = endb;
29355 wmp->wm_flags = typ | SD_WM_BUSY;
29356 if (typ & SD_WTYPE_RMW) {
29357 un->un_rmw_count++;
29358 }
29359 /*
29360 * If not already on the list then link
29361 */
29362 if (!ONLIST(un, wmp)) {
29363 wmp->wm_next = un->un_wm;
29364 wmp->wm_prev = NULL;
29365 if (wmp->wm_next)
29366 wmp->wm_next->wm_prev = wmp;
29367 un->un_wm = wmp;
29368 }
29369 state = SD_WM_DONE;
29370 }
29371 break;
29372
29373 case SD_WM_WAIT_MAP:
29374 ASSERT(sl_wmp->wm_flags & SD_WM_BUSY);
29375 /*
29376 * Wait is done on sl_wmp, which is set in the
29377 * check_list state.
29378 */
29379 sl_wmp->wm_wanted_count++;
29380 cv_wait(&sl_wmp->wm_avail, SD_MUTEX(un));
29381 sl_wmp->wm_wanted_count--;
29382 /*
29383 * We can reuse the memory from the completed sl_wmp
29384 * lock range for our new lock, but only if noone is
29385 * waiting for it.
29386 */
29387 ASSERT(!(sl_wmp->wm_flags & SD_WM_BUSY));
29388 if (sl_wmp->wm_wanted_count == 0) {
29389 if (wmp != NULL) {
29390 CHK_N_FREEWMP(un, wmp);
29391 }
29392 wmp = sl_wmp;
29393 }
29394 sl_wmp = NULL;
29395 /*
29396 * After waking up, need to recheck for availability of
29397 * range.
29398 */
29399 state = SD_WM_CHK_LIST;
29400 break;
29401
29402 default:
29403 panic("sd_range_lock: "
29404 "Unknown state %d in sd_range_lock", state);
29405 /*NOTREACHED*/
29406 } /* switch(state) */
29407
29408 } /* while(state != SD_WM_DONE) */
29409
29410 mutex_exit(SD_MUTEX(un));
29411
29412 ASSERT(wmp != NULL);
29413
29414 return (wmp);
29415 }
29416
29417
29418 /*
29419 * Function: sd_get_range()
29420 *
29421 * Description: Find if there any overlapping I/O to this one
29422 * Returns the write-map of 1st such I/O, NULL otherwise.
29423 *
29424 * Arguments: un - sd_lun structure for the device.
29425 * startb - The starting block number
29426 * endb - The end block number
29427 *
29428 * Return Code: wm - pointer to the wmap structure.
29429 */
29430
29431 static struct sd_w_map *
29432 sd_get_range(struct sd_lun *un, daddr_t startb, daddr_t endb)
29433 {
29434 struct sd_w_map *wmp;
29435
29436 ASSERT(un != NULL);
29437
29438 for (wmp = un->un_wm; wmp != NULL; wmp = wmp->wm_next) {
29439 if (!(wmp->wm_flags & SD_WM_BUSY)) {
29440 continue;
29441 }
29442 if ((startb >= wmp->wm_start) && (startb <= wmp->wm_end)) {
29443 break;
29444 }
29445 if ((endb >= wmp->wm_start) && (endb <= wmp->wm_end)) {
29446 break;
29447 }
29448 }
29449
29450 return (wmp);
29451 }
29452
29453
29454 /*
29455 * Function: sd_free_inlist_wmap()
29456 *
29457 * Description: Unlink and free a write map struct.
29458 *
29459 * Arguments: un - sd_lun structure for the device.
29460 * wmp - sd_w_map which needs to be unlinked.
29461 */
29462
29463 static void
29464 sd_free_inlist_wmap(struct sd_lun *un, struct sd_w_map *wmp)
29465 {
29466 ASSERT(un != NULL);
29467
29468 if (un->un_wm == wmp) {
29469 un->un_wm = wmp->wm_next;
29470 } else {
29471 wmp->wm_prev->wm_next = wmp->wm_next;
29472 }
29473
29474 if (wmp->wm_next) {
29475 wmp->wm_next->wm_prev = wmp->wm_prev;
29476 }
29477
29478 wmp->wm_next = wmp->wm_prev = NULL;
29479
29480 kmem_cache_free(un->un_wm_cache, wmp);
29481 }
29482
29483
29484 /*
29485 * Function: sd_range_unlock()
29486 *
29487 * Description: Unlock the range locked by wm.
29488 * Free write map if nobody else is waiting on it.
29489 *
29490 * Arguments: un - sd_lun structure for the device.
29491 * wmp - sd_w_map which needs to be unlinked.
29492 */
29493
29494 static void
29495 sd_range_unlock(struct sd_lun *un, struct sd_w_map *wm)
29496 {
29497 ASSERT(un != NULL);
29498 ASSERT(wm != NULL);
29499 ASSERT(!mutex_owned(SD_MUTEX(un)));
29500
29501 mutex_enter(SD_MUTEX(un));
29502
29503 if (wm->wm_flags & SD_WTYPE_RMW) {
29504 un->un_rmw_count--;
29505 }
29506
29507 if (wm->wm_wanted_count) {
29508 wm->wm_flags = 0;
29509 /*
29510 * Broadcast that the wmap is available now.
29511 */
29512 cv_broadcast(&wm->wm_avail);
29513 } else {
29514 /*
29515 * If no one is waiting on the map, it should be free'ed.
29516 */
29517 sd_free_inlist_wmap(un, wm);
29518 }
29519
29520 mutex_exit(SD_MUTEX(un));
29521 }
29522
29523
29524 /*
29525 * Function: sd_read_modify_write_task
29526 *
29527 * Description: Called from a taskq thread to initiate the write phase of
29528 * a read-modify-write request. This is used for targets where
29529 * un->un_sys_blocksize != un->un_tgt_blocksize.
29530 *
29531 * Arguments: arg - a pointer to the buf(9S) struct for the write command.
29532 *
29533 * Context: Called under taskq thread context.
29534 */
29535
29536 static void
29537 sd_read_modify_write_task(void *arg)
29538 {
29539 struct sd_mapblocksize_info *bsp;
29540 struct buf *bp;
29541 struct sd_xbuf *xp;
29542 struct sd_lun *un;
29543
29544 bp = arg; /* The bp is given in arg */
29545 ASSERT(bp != NULL);
29546
29547 /* Get the pointer to the layer-private data struct */
29548 xp = SD_GET_XBUF(bp);
29549 ASSERT(xp != NULL);
29550 bsp = xp->xb_private;
29551 ASSERT(bsp != NULL);
29552
29553 un = SD_GET_UN(bp);
29554 ASSERT(un != NULL);
29555 ASSERT(!mutex_owned(SD_MUTEX(un)));
29556
29557 SD_TRACE(SD_LOG_IO_RMMEDIA, un,
29558 "sd_read_modify_write_task: entry: buf:0x%p\n", bp);
29559
29560 /*
29561 * This is the write phase of a read-modify-write request, called
29562 * under the context of a taskq thread in response to the completion
29563 * of the read portion of the rmw request completing under interrupt
29564 * context. The write request must be sent from here down the iostart
29565 * chain as if it were being sent from sd_mapblocksize_iostart(), so
29566 * we use the layer index saved in the layer-private data area.
29567 */
29568 SD_NEXT_IOSTART(bsp->mbs_layer_index, un, bp);
29569
29570 SD_TRACE(SD_LOG_IO_RMMEDIA, un,
29571 "sd_read_modify_write_task: exit: buf:0x%p\n", bp);
29572 }
29573
29574
29575 /*
29576 * Function: sddump_do_read_of_rmw()
29577 *
29578 * Description: This routine will be called from sddump, If sddump is called
29579 * with an I/O which not aligned on device blocksize boundary
29580 * then the write has to be converted to read-modify-write.
29581 * Do the read part here in order to keep sddump simple.
29582 * Note - That the sd_mutex is held across the call to this
29583 * routine.
29584 *
29585 * Arguments: un - sd_lun
29586 * blkno - block number in terms of media block size.
29587 * nblk - number of blocks.
29588 * bpp - pointer to pointer to the buf structure. On return
29589 * from this function, *bpp points to the valid buffer
29590 * to which the write has to be done.
29591 *
29592 * Return Code: 0 for success or errno-type return code
29593 */
29594
29595 static int
29596 sddump_do_read_of_rmw(struct sd_lun *un, uint64_t blkno, uint64_t nblk,
29597 struct buf **bpp)
29598 {
29599 int err;
29600 int i;
29601 int rval;
29602 struct buf *bp;
29603 struct scsi_pkt *pkt = NULL;
29604 uint32_t target_blocksize;
29605
29606 ASSERT(un != NULL);
29607 ASSERT(mutex_owned(SD_MUTEX(un)));
29608
29609 target_blocksize = un->un_tgt_blocksize;
29610
29611 mutex_exit(SD_MUTEX(un));
29612
29613 bp = scsi_alloc_consistent_buf(SD_ADDRESS(un), (struct buf *)NULL,
29614 (size_t)(nblk * target_blocksize), B_READ, NULL_FUNC, NULL);
29615 if (bp == NULL) {
29616 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
29617 "no resources for dumping; giving up");
29618 err = ENOMEM;
29619 goto done;
29620 }
29621
29622 rval = sd_setup_rw_pkt(un, &pkt, bp, 0, NULL_FUNC, NULL,
29623 blkno, nblk);
29624 if (rval != 0) {
29625 scsi_free_consistent_buf(bp);
29626 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
29627 "no resources for dumping; giving up");
29628 err = ENOMEM;
29629 goto done;
29630 }
29631
29632 pkt->pkt_flags |= FLAG_NOINTR;
29633
29634 err = EIO;
29635 for (i = 0; i < SD_NDUMP_RETRIES; i++) {
29636
29637 /*
29638 * Scsi_poll returns 0 (success) if the command completes and
29639 * the status block is STATUS_GOOD. We should only check
29640 * errors if this condition is not true. Even then we should
29641 * send our own request sense packet only if we have a check
29642 * condition and auto request sense has not been performed by
29643 * the hba.
29644 */
29645 SD_TRACE(SD_LOG_DUMP, un, "sddump: sending read\n");
29646
29647 if ((sd_scsi_poll(un, pkt) == 0) && (pkt->pkt_resid == 0)) {
29648 err = 0;
29649 break;
29650 }
29651
29652 /*
29653 * Check CMD_DEV_GONE 1st, give up if device is gone,
29654 * no need to read RQS data.
29655 */
29656 if (pkt->pkt_reason == CMD_DEV_GONE) {
29657 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
29658 "Error while dumping state with rmw..."
29659 "Device is gone\n");
29660 break;
29661 }
29662
29663 if (SD_GET_PKT_STATUS(pkt) == STATUS_CHECK) {
29664 SD_INFO(SD_LOG_DUMP, un,
29665 "sddump: read failed with CHECK, try # %d\n", i);
29666 if (((pkt->pkt_state & STATE_ARQ_DONE) == 0)) {
29667 (void) sd_send_polled_RQS(un);
29668 }
29669
29670 continue;
29671 }
29672
29673 if (SD_GET_PKT_STATUS(pkt) == STATUS_BUSY) {
29674 int reset_retval = 0;
29675
29676 SD_INFO(SD_LOG_DUMP, un,
29677 "sddump: read failed with BUSY, try # %d\n", i);
29678
29679 if (un->un_f_lun_reset_enabled == TRUE) {
29680 reset_retval = scsi_reset(SD_ADDRESS(un),
29681 RESET_LUN);
29682 }
29683 if (reset_retval == 0) {
29684 (void) scsi_reset(SD_ADDRESS(un), RESET_TARGET);
29685 }
29686 (void) sd_send_polled_RQS(un);
29687
29688 } else {
29689 SD_INFO(SD_LOG_DUMP, un,
29690 "sddump: read failed with 0x%x, try # %d\n",
29691 SD_GET_PKT_STATUS(pkt), i);
29692 mutex_enter(SD_MUTEX(un));
29693 sd_reset_target(un, pkt);
29694 mutex_exit(SD_MUTEX(un));
29695 }
29696
29697 /*
29698 * If we are not getting anywhere with lun/target resets,
29699 * let's reset the bus.
29700 */
29701 if (i > SD_NDUMP_RETRIES/2) {
29702 (void) scsi_reset(SD_ADDRESS(un), RESET_ALL);
29703 (void) sd_send_polled_RQS(un);
29704 }
29705
29706 }
29707 scsi_destroy_pkt(pkt);
29708
29709 if (err != 0) {
29710 scsi_free_consistent_buf(bp);
29711 *bpp = NULL;
29712 } else {
29713 *bpp = bp;
29714 }
29715
29716 done:
29717 mutex_enter(SD_MUTEX(un));
29718 return (err);
29719 }
29720
29721
29722 /*
29723 * Function: sd_failfast_flushq
29724 *
29725 * Description: Take all bp's on the wait queue that have B_FAILFAST set
29726 * in b_flags and move them onto the failfast queue, then kick
29727 * off a thread to return all bp's on the failfast queue to
29728 * their owners with an error set.
29729 *
29730 * Arguments: un - pointer to the soft state struct for the instance.
29731 *
29732 * Context: may execute in interrupt context.
29733 */
29734
29735 static void
29736 sd_failfast_flushq(struct sd_lun *un)
29737 {
29738 struct buf *bp;
29739 struct buf *next_waitq_bp;
29740 struct buf *prev_waitq_bp = NULL;
29741
29742 ASSERT(un != NULL);
29743 ASSERT(mutex_owned(SD_MUTEX(un)));
29744 ASSERT(un->un_failfast_state == SD_FAILFAST_ACTIVE);
29745 ASSERT(un->un_failfast_bp == NULL);
29746
29747 SD_TRACE(SD_LOG_IO_FAILFAST, un,
29748 "sd_failfast_flushq: entry: un:0x%p\n", un);
29749
29750 /*
29751 * Check if we should flush all bufs when entering failfast state, or
29752 * just those with B_FAILFAST set.
29753 */
29754 if (sd_failfast_flushctl & SD_FAILFAST_FLUSH_ALL_BUFS) {
29755 /*
29756 * Move *all* bp's on the wait queue to the failfast flush
29757 * queue, including those that do NOT have B_FAILFAST set.
29758 */
29759 if (un->un_failfast_headp == NULL) {
29760 ASSERT(un->un_failfast_tailp == NULL);
29761 un->un_failfast_headp = un->un_waitq_headp;
29762 } else {
29763 ASSERT(un->un_failfast_tailp != NULL);
29764 un->un_failfast_tailp->av_forw = un->un_waitq_headp;
29765 }
29766
29767 un->un_failfast_tailp = un->un_waitq_tailp;
29768
29769 /* update kstat for each bp moved out of the waitq */
29770 for (bp = un->un_waitq_headp; bp != NULL; bp = bp->av_forw) {
29771 SD_UPDATE_KSTATS(un, kstat_waitq_exit, bp);
29772 }
29773
29774 /* empty the waitq */
29775 un->un_waitq_headp = un->un_waitq_tailp = NULL;
29776
29777 } else {
29778 /*
29779 * Go thru the wait queue, pick off all entries with
29780 * B_FAILFAST set, and move these onto the failfast queue.
29781 */
29782 for (bp = un->un_waitq_headp; bp != NULL; bp = next_waitq_bp) {
29783 /*
29784 * Save the pointer to the next bp on the wait queue,
29785 * so we get to it on the next iteration of this loop.
29786 */
29787 next_waitq_bp = bp->av_forw;
29788
29789 /*
29790 * If this bp from the wait queue does NOT have
29791 * B_FAILFAST set, just move on to the next element
29792 * in the wait queue. Note, this is the only place
29793 * where it is correct to set prev_waitq_bp.
29794 */
29795 if ((bp->b_flags & B_FAILFAST) == 0) {
29796 prev_waitq_bp = bp;
29797 continue;
29798 }
29799
29800 /*
29801 * Remove the bp from the wait queue.
29802 */
29803 if (bp == un->un_waitq_headp) {
29804 /* The bp is the first element of the waitq. */
29805 un->un_waitq_headp = next_waitq_bp;
29806 if (un->un_waitq_headp == NULL) {
29807 /* The wait queue is now empty */
29808 un->un_waitq_tailp = NULL;
29809 }
29810 } else {
29811 /*
29812 * The bp is either somewhere in the middle
29813 * or at the end of the wait queue.
29814 */
29815 ASSERT(un->un_waitq_headp != NULL);
29816 ASSERT(prev_waitq_bp != NULL);
29817 ASSERT((prev_waitq_bp->b_flags & B_FAILFAST)
29818 == 0);
29819 if (bp == un->un_waitq_tailp) {
29820 /* bp is the last entry on the waitq. */
29821 ASSERT(next_waitq_bp == NULL);
29822 un->un_waitq_tailp = prev_waitq_bp;
29823 }
29824 prev_waitq_bp->av_forw = next_waitq_bp;
29825 }
29826 bp->av_forw = NULL;
29827
29828 /*
29829 * update kstat since the bp is moved out of
29830 * the waitq
29831 */
29832 SD_UPDATE_KSTATS(un, kstat_waitq_exit, bp);
29833
29834 /*
29835 * Now put the bp onto the failfast queue.
29836 */
29837 if (un->un_failfast_headp == NULL) {
29838 /* failfast queue is currently empty */
29839 ASSERT(un->un_failfast_tailp == NULL);
29840 un->un_failfast_headp =
29841 un->un_failfast_tailp = bp;
29842 } else {
29843 /* Add the bp to the end of the failfast q */
29844 ASSERT(un->un_failfast_tailp != NULL);
29845 ASSERT(un->un_failfast_tailp->b_flags &
29846 B_FAILFAST);
29847 un->un_failfast_tailp->av_forw = bp;
29848 un->un_failfast_tailp = bp;
29849 }
29850 }
29851 }
29852
29853 /*
29854 * Now return all bp's on the failfast queue to their owners.
29855 */
29856 while ((bp = un->un_failfast_headp) != NULL) {
29857
29858 un->un_failfast_headp = bp->av_forw;
29859 if (un->un_failfast_headp == NULL) {
29860 un->un_failfast_tailp = NULL;
29861 }
29862
29863 /*
29864 * We want to return the bp with a failure error code, but
29865 * we do not want a call to sd_start_cmds() to occur here,
29866 * so use sd_return_failed_command_no_restart() instead of
29867 * sd_return_failed_command().
29868 */
29869 sd_return_failed_command_no_restart(un, bp, EIO);
29870 }
29871
29872 /* Flush the xbuf queues if required. */
29873 if (sd_failfast_flushctl & SD_FAILFAST_FLUSH_ALL_QUEUES) {
29874 ddi_xbuf_flushq(un->un_xbuf_attr, sd_failfast_flushq_callback);
29875 }
29876
29877 SD_TRACE(SD_LOG_IO_FAILFAST, un,
29878 "sd_failfast_flushq: exit: un:0x%p\n", un);
29879 }
29880
29881
29882 /*
29883 * Function: sd_failfast_flushq_callback
29884 *
29885 * Description: Return TRUE if the given bp meets the criteria for failfast
29886 * flushing. Used with ddi_xbuf_flushq(9F).
29887 *
29888 * Arguments: bp - ptr to buf struct to be examined.
29889 *
29890 * Context: Any
29891 */
29892
29893 static int
29894 sd_failfast_flushq_callback(struct buf *bp)
29895 {
29896 /*
29897 * Return TRUE if (1) we want to flush ALL bufs when the failfast
29898 * state is entered; OR (2) the given bp has B_FAILFAST set.
29899 */
29900 return (((sd_failfast_flushctl & SD_FAILFAST_FLUSH_ALL_BUFS) ||
29901 (bp->b_flags & B_FAILFAST)) ? TRUE : FALSE);
29902 }
29903
29904
29905
29906 /*
29907 * Function: sd_setup_next_xfer
29908 *
29909 * Description: Prepare next I/O operation using DMA_PARTIAL
29910 *
29911 */
29912
29913 static int
29914 sd_setup_next_xfer(struct sd_lun *un, struct buf *bp,
29915 struct scsi_pkt *pkt, struct sd_xbuf *xp)
29916 {
29917 ssize_t num_blks_not_xfered;
29918 daddr_t strt_blk_num;
29919 ssize_t bytes_not_xfered;
29920 int rval;
29921
29922 ASSERT(pkt->pkt_resid == 0);
29923
29924 /*
29925 * Calculate next block number and amount to be transferred.
29926 *
29927 * How much data NOT transfered to the HBA yet.
29928 */
29929 bytes_not_xfered = xp->xb_dma_resid;
29930
29931 /*
29932 * figure how many blocks NOT transfered to the HBA yet.
29933 */
29934 num_blks_not_xfered = SD_BYTES2TGTBLOCKS(un, bytes_not_xfered);
29935
29936 /*
29937 * set starting block number to the end of what WAS transfered.
29938 */
29939 strt_blk_num = xp->xb_blkno +
29940 SD_BYTES2TGTBLOCKS(un, bp->b_bcount - bytes_not_xfered);
29941
29942 /*
29943 * Move pkt to the next portion of the xfer. sd_setup_next_rw_pkt
29944 * will call scsi_initpkt with NULL_FUNC so we do not have to release
29945 * the disk mutex here.
29946 */
29947 rval = sd_setup_next_rw_pkt(un, pkt, bp,
29948 strt_blk_num, num_blks_not_xfered);
29949
29950 if (rval == 0) {
29951
29952 /*
29953 * Success.
29954 *
29955 * Adjust things if there are still more blocks to be
29956 * transfered.
29957 */
29958 xp->xb_dma_resid = pkt->pkt_resid;
29959 pkt->pkt_resid = 0;
29960
29961 return (1);
29962 }
29963
29964 /*
29965 * There's really only one possible return value from
29966 * sd_setup_next_rw_pkt which occurs when scsi_init_pkt
29967 * returns NULL.
29968 */
29969 ASSERT(rval == SD_PKT_ALLOC_FAILURE);
29970
29971 bp->b_resid = bp->b_bcount;
29972 bp->b_flags |= B_ERROR;
29973
29974 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
29975 "Error setting up next portion of DMA transfer\n");
29976
29977 return (0);
29978 }
29979
29980 /*
29981 * Function: sd_panic_for_res_conflict
29982 *
29983 * Description: Call panic with a string formatted with "Reservation Conflict"
29984 * and a human readable identifier indicating the SD instance
29985 * that experienced the reservation conflict.
29986 *
29987 * Arguments: un - pointer to the soft state struct for the instance.
29988 *
29989 * Context: may execute in interrupt context.
29990 */
29991
29992 #define SD_RESV_CONFLICT_FMT_LEN 40
29993 void
29994 sd_panic_for_res_conflict(struct sd_lun *un)
29995 {
29996 char panic_str[SD_RESV_CONFLICT_FMT_LEN+MAXPATHLEN];
29997 char path_str[MAXPATHLEN];
29998
29999 (void) snprintf(panic_str, sizeof (panic_str),
30000 "Reservation Conflict\nDisk: %s",
30001 ddi_pathname(SD_DEVINFO(un), path_str));
30002
30003 panic(panic_str);
30004 }
30005
30006 /*
30007 * Note: The following sd_faultinjection_ioctl( ) routines implement
30008 * driver support for handling fault injection for error analysis
30009 * causing faults in multiple layers of the driver.
30010 *
30011 */
30012
30013 #ifdef SD_FAULT_INJECTION
30014 static uint_t sd_fault_injection_on = 0;
30015
30016 /*
30017 * Function: sd_faultinjection_ioctl()
30018 *
30019 * Description: This routine is the driver entry point for handling
30020 * faultinjection ioctls to inject errors into the
30021 * layer model
30022 *
30023 * Arguments: cmd - the ioctl cmd received
30024 * arg - the arguments from user and returns
30025 */
30026
30027 static void
30028 sd_faultinjection_ioctl(int cmd, intptr_t arg, struct sd_lun *un)
30029 {
30030 uint_t i = 0;
30031 uint_t rval;
30032
30033 SD_TRACE(SD_LOG_IOERR, un, "sd_faultinjection_ioctl: entry\n");
30034
30035 mutex_enter(SD_MUTEX(un));
30036
30037 switch (cmd) {
30038 case SDIOCRUN:
30039 /* Allow pushed faults to be injected */
30040 SD_INFO(SD_LOG_SDTEST, un,
30041 "sd_faultinjection_ioctl: Injecting Fault Run\n");
30042
30043 sd_fault_injection_on = 1;
30044
30045 SD_INFO(SD_LOG_IOERR, un,
30046 "sd_faultinjection_ioctl: run finished\n");
30047 break;
30048
30049 case SDIOCSTART:
30050 /* Start Injection Session */
30051 SD_INFO(SD_LOG_SDTEST, un,
30052 "sd_faultinjection_ioctl: Injecting Fault Start\n");
30053
30054 sd_fault_injection_on = 0;
30055 un->sd_injection_mask = 0xFFFFFFFF;
30056 for (i = 0; i < SD_FI_MAX_ERROR; i++) {
30057 un->sd_fi_fifo_pkt[i] = NULL;
30058 un->sd_fi_fifo_xb[i] = NULL;
30059 un->sd_fi_fifo_un[i] = NULL;
30060 un->sd_fi_fifo_arq[i] = NULL;
30061 }
30062 un->sd_fi_fifo_start = 0;
30063 un->sd_fi_fifo_end = 0;
30064
30065 mutex_enter(&(un->un_fi_mutex));
30066 un->sd_fi_log[0] = '\0';
30067 un->sd_fi_buf_len = 0;
30068 mutex_exit(&(un->un_fi_mutex));
30069
30070 SD_INFO(SD_LOG_IOERR, un,
30071 "sd_faultinjection_ioctl: start finished\n");
30072 break;
30073
30074 case SDIOCSTOP:
30075 /* Stop Injection Session */
30076 SD_INFO(SD_LOG_SDTEST, un,
30077 "sd_faultinjection_ioctl: Injecting Fault Stop\n");
30078 sd_fault_injection_on = 0;
30079 un->sd_injection_mask = 0x0;
30080
30081 /* Empty stray or unuseds structs from fifo */
30082 for (i = 0; i < SD_FI_MAX_ERROR; i++) {
30083 if (un->sd_fi_fifo_pkt[i] != NULL) {
30084 kmem_free(un->sd_fi_fifo_pkt[i],
30085 sizeof (struct sd_fi_pkt));
30086 }
30087 if (un->sd_fi_fifo_xb[i] != NULL) {
30088 kmem_free(un->sd_fi_fifo_xb[i],
30089 sizeof (struct sd_fi_xb));
30090 }
30091 if (un->sd_fi_fifo_un[i] != NULL) {
30092 kmem_free(un->sd_fi_fifo_un[i],
30093 sizeof (struct sd_fi_un));
30094 }
30095 if (un->sd_fi_fifo_arq[i] != NULL) {
30096 kmem_free(un->sd_fi_fifo_arq[i],
30097 sizeof (struct sd_fi_arq));
30098 }
30099 un->sd_fi_fifo_pkt[i] = NULL;
30100 un->sd_fi_fifo_un[i] = NULL;
30101 un->sd_fi_fifo_xb[i] = NULL;
30102 un->sd_fi_fifo_arq[i] = NULL;
30103 }
30104 un->sd_fi_fifo_start = 0;
30105 un->sd_fi_fifo_end = 0;
30106
30107 SD_INFO(SD_LOG_IOERR, un,
30108 "sd_faultinjection_ioctl: stop finished\n");
30109 break;
30110
30111 case SDIOCINSERTPKT:
30112 /* Store a packet struct to be pushed onto fifo */
30113 SD_INFO(SD_LOG_SDTEST, un,
30114 "sd_faultinjection_ioctl: Injecting Fault Insert Pkt\n");
30115
30116 i = un->sd_fi_fifo_end % SD_FI_MAX_ERROR;
30117
30118 sd_fault_injection_on = 0;
30119
30120 /* No more that SD_FI_MAX_ERROR allowed in Queue */
30121 if (un->sd_fi_fifo_pkt[i] != NULL) {
30122 kmem_free(un->sd_fi_fifo_pkt[i],
30123 sizeof (struct sd_fi_pkt));
30124 }
30125 if (arg != NULL) {
30126 un->sd_fi_fifo_pkt[i] =
30127 kmem_alloc(sizeof (struct sd_fi_pkt), KM_NOSLEEP);
30128 if (un->sd_fi_fifo_pkt[i] == NULL) {
30129 /* Alloc failed don't store anything */
30130 break;
30131 }
30132 rval = ddi_copyin((void *)arg, un->sd_fi_fifo_pkt[i],
30133 sizeof (struct sd_fi_pkt), 0);
30134 if (rval == -1) {
30135 kmem_free(un->sd_fi_fifo_pkt[i],
30136 sizeof (struct sd_fi_pkt));
30137 un->sd_fi_fifo_pkt[i] = NULL;
30138 }
30139 } else {
30140 SD_INFO(SD_LOG_IOERR, un,
30141 "sd_faultinjection_ioctl: pkt null\n");
30142 }
30143 break;
30144
30145 case SDIOCINSERTXB:
30146 /* Store a xb struct to be pushed onto fifo */
30147 SD_INFO(SD_LOG_SDTEST, un,
30148 "sd_faultinjection_ioctl: Injecting Fault Insert XB\n");
30149
30150 i = un->sd_fi_fifo_end % SD_FI_MAX_ERROR;
30151
30152 sd_fault_injection_on = 0;
30153
30154 if (un->sd_fi_fifo_xb[i] != NULL) {
30155 kmem_free(un->sd_fi_fifo_xb[i],
30156 sizeof (struct sd_fi_xb));
30157 un->sd_fi_fifo_xb[i] = NULL;
30158 }
30159 if (arg != NULL) {
30160 un->sd_fi_fifo_xb[i] =
30161 kmem_alloc(sizeof (struct sd_fi_xb), KM_NOSLEEP);
30162 if (un->sd_fi_fifo_xb[i] == NULL) {
30163 /* Alloc failed don't store anything */
30164 break;
30165 }
30166 rval = ddi_copyin((void *)arg, un->sd_fi_fifo_xb[i],
30167 sizeof (struct sd_fi_xb), 0);
30168
30169 if (rval == -1) {
30170 kmem_free(un->sd_fi_fifo_xb[i],
30171 sizeof (struct sd_fi_xb));
30172 un->sd_fi_fifo_xb[i] = NULL;
30173 }
30174 } else {
30175 SD_INFO(SD_LOG_IOERR, un,
30176 "sd_faultinjection_ioctl: xb null\n");
30177 }
30178 break;
30179
30180 case SDIOCINSERTUN:
30181 /* Store a un struct to be pushed onto fifo */
30182 SD_INFO(SD_LOG_SDTEST, un,
30183 "sd_faultinjection_ioctl: Injecting Fault Insert UN\n");
30184
30185 i = un->sd_fi_fifo_end % SD_FI_MAX_ERROR;
30186
30187 sd_fault_injection_on = 0;
30188
30189 if (un->sd_fi_fifo_un[i] != NULL) {
30190 kmem_free(un->sd_fi_fifo_un[i],
30191 sizeof (struct sd_fi_un));
30192 un->sd_fi_fifo_un[i] = NULL;
30193 }
30194 if (arg != NULL) {
30195 un->sd_fi_fifo_un[i] =
30196 kmem_alloc(sizeof (struct sd_fi_un), KM_NOSLEEP);
30197 if (un->sd_fi_fifo_un[i] == NULL) {
30198 /* Alloc failed don't store anything */
30199 break;
30200 }
30201 rval = ddi_copyin((void *)arg, un->sd_fi_fifo_un[i],
30202 sizeof (struct sd_fi_un), 0);
30203 if (rval == -1) {
30204 kmem_free(un->sd_fi_fifo_un[i],
30205 sizeof (struct sd_fi_un));
30206 un->sd_fi_fifo_un[i] = NULL;
30207 }
30208
30209 } else {
30210 SD_INFO(SD_LOG_IOERR, un,
30211 "sd_faultinjection_ioctl: un null\n");
30212 }
30213
30214 break;
30215
30216 case SDIOCINSERTARQ:
30217 /* Store a arq struct to be pushed onto fifo */
30218 SD_INFO(SD_LOG_SDTEST, un,
30219 "sd_faultinjection_ioctl: Injecting Fault Insert ARQ\n");
30220 i = un->sd_fi_fifo_end % SD_FI_MAX_ERROR;
30221
30222 sd_fault_injection_on = 0;
30223
30224 if (un->sd_fi_fifo_arq[i] != NULL) {
30225 kmem_free(un->sd_fi_fifo_arq[i],
30226 sizeof (struct sd_fi_arq));
30227 un->sd_fi_fifo_arq[i] = NULL;
30228 }
30229 if (arg != NULL) {
30230 un->sd_fi_fifo_arq[i] =
30231 kmem_alloc(sizeof (struct sd_fi_arq), KM_NOSLEEP);
30232 if (un->sd_fi_fifo_arq[i] == NULL) {
30233 /* Alloc failed don't store anything */
30234 break;
30235 }
30236 rval = ddi_copyin((void *)arg, un->sd_fi_fifo_arq[i],
30237 sizeof (struct sd_fi_arq), 0);
30238 if (rval == -1) {
30239 kmem_free(un->sd_fi_fifo_arq[i],
30240 sizeof (struct sd_fi_arq));
30241 un->sd_fi_fifo_arq[i] = NULL;
30242 }
30243
30244 } else {
30245 SD_INFO(SD_LOG_IOERR, un,
30246 "sd_faultinjection_ioctl: arq null\n");
30247 }
30248
30249 break;
30250
30251 case SDIOCPUSH:
30252 /* Push stored xb, pkt, un, and arq onto fifo */
30253 sd_fault_injection_on = 0;
30254
30255 if (arg != NULL) {
30256 rval = ddi_copyin((void *)arg, &i, sizeof (uint_t), 0);
30257 if (rval != -1 &&
30258 un->sd_fi_fifo_end + i < SD_FI_MAX_ERROR) {
30259 un->sd_fi_fifo_end += i;
30260 }
30261 } else {
30262 SD_INFO(SD_LOG_IOERR, un,
30263 "sd_faultinjection_ioctl: push arg null\n");
30264 if (un->sd_fi_fifo_end + i < SD_FI_MAX_ERROR) {
30265 un->sd_fi_fifo_end++;
30266 }
30267 }
30268 SD_INFO(SD_LOG_IOERR, un,
30269 "sd_faultinjection_ioctl: push to end=%d\n",
30270 un->sd_fi_fifo_end);
30271 break;
30272
30273 case SDIOCRETRIEVE:
30274 /* Return buffer of log from Injection session */
30275 SD_INFO(SD_LOG_SDTEST, un,
30276 "sd_faultinjection_ioctl: Injecting Fault Retreive");
30277
30278 sd_fault_injection_on = 0;
30279
30280 mutex_enter(&(un->un_fi_mutex));
30281 rval = ddi_copyout(un->sd_fi_log, (void *)arg,
30282 un->sd_fi_buf_len+1, 0);
30283 mutex_exit(&(un->un_fi_mutex));
30284
30285 if (rval == -1) {
30286 /*
30287 * arg is possibly invalid setting
30288 * it to NULL for return
30289 */
30290 arg = NULL;
30291 }
30292 break;
30293 }
30294
30295 mutex_exit(SD_MUTEX(un));
30296 SD_TRACE(SD_LOG_IOERR, un, "sd_faultinjection_ioctl: exit\n");
30297 }
30298
30299
30300 /*
30301 * Function: sd_injection_log()
30302 *
30303 * Description: This routine adds buff to the already existing injection log
30304 * for retrieval via faultinjection_ioctl for use in fault
30305 * detection and recovery
30306 *
30307 * Arguments: buf - the string to add to the log
30308 */
30309
30310 static void
30311 sd_injection_log(char *buf, struct sd_lun *un)
30312 {
30313 uint_t len;
30314
30315 ASSERT(un != NULL);
30316 ASSERT(buf != NULL);
30317
30318 mutex_enter(&(un->un_fi_mutex));
30319
30320 len = min(strlen(buf), 255);
30321 /* Add logged value to Injection log to be returned later */
30322 if (len + un->sd_fi_buf_len < SD_FI_MAX_BUF) {
30323 uint_t offset = strlen((char *)un->sd_fi_log);
30324 char *destp = (char *)un->sd_fi_log + offset;
30325 int i;
30326 for (i = 0; i < len; i++) {
30327 *destp++ = *buf++;
30328 }
30329 un->sd_fi_buf_len += len;
30330 un->sd_fi_log[un->sd_fi_buf_len] = '\0';
30331 }
30332
30333 mutex_exit(&(un->un_fi_mutex));
30334 }
30335
30336
30337 /*
30338 * Function: sd_faultinjection()
30339 *
30340 * Description: This routine takes the pkt and changes its
30341 * content based on error injection scenerio.
30342 *
30343 * Arguments: pktp - packet to be changed
30344 */
30345
30346 static void
30347 sd_faultinjection(struct scsi_pkt *pktp)
30348 {
30349 uint_t i;
30350 struct sd_fi_pkt *fi_pkt;
30351 struct sd_fi_xb *fi_xb;
30352 struct sd_fi_un *fi_un;
30353 struct sd_fi_arq *fi_arq;
30354 struct buf *bp;
30355 struct sd_xbuf *xb;
30356 struct sd_lun *un;
30357
30358 ASSERT(pktp != NULL);
30359
30360 /* pull bp xb and un from pktp */
30361 bp = (struct buf *)pktp->pkt_private;
30362 xb = SD_GET_XBUF(bp);
30363 un = SD_GET_UN(bp);
30364
30365 ASSERT(un != NULL);
30366
30367 mutex_enter(SD_MUTEX(un));
30368
30369 SD_TRACE(SD_LOG_SDTEST, un,
30370 "sd_faultinjection: entry Injection from sdintr\n");
30371
30372 /* if injection is off return */
30373 if (sd_fault_injection_on == 0 ||
30374 un->sd_fi_fifo_start == un->sd_fi_fifo_end) {
30375 mutex_exit(SD_MUTEX(un));
30376 return;
30377 }
30378
30379 SD_INFO(SD_LOG_SDTEST, un,
30380 "sd_faultinjection: is working for copying\n");
30381
30382 /* take next set off fifo */
30383 i = un->sd_fi_fifo_start % SD_FI_MAX_ERROR;
30384
30385 fi_pkt = un->sd_fi_fifo_pkt[i];
30386 fi_xb = un->sd_fi_fifo_xb[i];
30387 fi_un = un->sd_fi_fifo_un[i];
30388 fi_arq = un->sd_fi_fifo_arq[i];
30389
30390
30391 /* set variables accordingly */
30392 /* set pkt if it was on fifo */
30393 if (fi_pkt != NULL) {
30394 SD_CONDSET(pktp, pkt, pkt_flags, "pkt_flags");
30395 SD_CONDSET(*pktp, pkt, pkt_scbp, "pkt_scbp");
30396 if (fi_pkt->pkt_cdbp != 0xff)
30397 SD_CONDSET(*pktp, pkt, pkt_cdbp, "pkt_cdbp");
30398 SD_CONDSET(pktp, pkt, pkt_state, "pkt_state");
30399 SD_CONDSET(pktp, pkt, pkt_statistics, "pkt_statistics");
30400 SD_CONDSET(pktp, pkt, pkt_reason, "pkt_reason");
30401
30402 }
30403 /* set xb if it was on fifo */
30404 if (fi_xb != NULL) {
30405 SD_CONDSET(xb, xb, xb_blkno, "xb_blkno");
30406 SD_CONDSET(xb, xb, xb_dma_resid, "xb_dma_resid");
30407 if (fi_xb->xb_retry_count != 0)
30408 SD_CONDSET(xb, xb, xb_retry_count, "xb_retry_count");
30409 SD_CONDSET(xb, xb, xb_victim_retry_count,
30410 "xb_victim_retry_count");
30411 SD_CONDSET(xb, xb, xb_sense_status, "xb_sense_status");
30412 SD_CONDSET(xb, xb, xb_sense_state, "xb_sense_state");
30413 SD_CONDSET(xb, xb, xb_sense_resid, "xb_sense_resid");
30414
30415 /* copy in block data from sense */
30416 /*
30417 * if (fi_xb->xb_sense_data[0] != -1) {
30418 * bcopy(fi_xb->xb_sense_data, xb->xb_sense_data,
30419 * SENSE_LENGTH);
30420 * }
30421 */
30422 bcopy(fi_xb->xb_sense_data, xb->xb_sense_data, SENSE_LENGTH);
30423
30424 /* copy in extended sense codes */
30425 SD_CONDSET(((struct scsi_extended_sense *)xb->xb_sense_data),
30426 xb, es_code, "es_code");
30427 SD_CONDSET(((struct scsi_extended_sense *)xb->xb_sense_data),
30428 xb, es_key, "es_key");
30429 SD_CONDSET(((struct scsi_extended_sense *)xb->xb_sense_data),
30430 xb, es_add_code, "es_add_code");
30431 SD_CONDSET(((struct scsi_extended_sense *)xb->xb_sense_data),
30432 xb, es_qual_code, "es_qual_code");
30433 struct scsi_extended_sense *esp;
30434 esp = (struct scsi_extended_sense *)xb->xb_sense_data;
30435 esp->es_class = CLASS_EXTENDED_SENSE;
30436 }
30437
30438 /* set un if it was on fifo */
30439 if (fi_un != NULL) {
30440 SD_CONDSET(un->un_sd->sd_inq, un, inq_rmb, "inq_rmb");
30441 SD_CONDSET(un, un, un_ctype, "un_ctype");
30442 SD_CONDSET(un, un, un_reset_retry_count,
30443 "un_reset_retry_count");
30444 SD_CONDSET(un, un, un_reservation_type, "un_reservation_type");
30445 SD_CONDSET(un, un, un_resvd_status, "un_resvd_status");
30446 SD_CONDSET(un, un, un_f_arq_enabled, "un_f_arq_enabled");
30447 SD_CONDSET(un, un, un_f_allow_bus_device_reset,
30448 "un_f_allow_bus_device_reset");
30449 SD_CONDSET(un, un, un_f_opt_queueing, "un_f_opt_queueing");
30450
30451 }
30452
30453 /* copy in auto request sense if it was on fifo */
30454 if (fi_arq != NULL) {
30455 bcopy(fi_arq, pktp->pkt_scbp, sizeof (struct sd_fi_arq));
30456 }
30457
30458 /* free structs */
30459 if (un->sd_fi_fifo_pkt[i] != NULL) {
30460 kmem_free(un->sd_fi_fifo_pkt[i], sizeof (struct sd_fi_pkt));
30461 }
30462 if (un->sd_fi_fifo_xb[i] != NULL) {
30463 kmem_free(un->sd_fi_fifo_xb[i], sizeof (struct sd_fi_xb));
30464 }
30465 if (un->sd_fi_fifo_un[i] != NULL) {
30466 kmem_free(un->sd_fi_fifo_un[i], sizeof (struct sd_fi_un));
30467 }
30468 if (un->sd_fi_fifo_arq[i] != NULL) {
30469 kmem_free(un->sd_fi_fifo_arq[i], sizeof (struct sd_fi_arq));
30470 }
30471
30472 /*
30473 * kmem_free does not gurantee to set to NULL
30474 * since we uses these to determine if we set
30475 * values or not lets confirm they are always
30476 * NULL after free
30477 */
30478 un->sd_fi_fifo_pkt[i] = NULL;
30479 un->sd_fi_fifo_un[i] = NULL;
30480 un->sd_fi_fifo_xb[i] = NULL;
30481 un->sd_fi_fifo_arq[i] = NULL;
30482
30483 un->sd_fi_fifo_start++;
30484
30485 mutex_exit(SD_MUTEX(un));
30486
30487 SD_INFO(SD_LOG_SDTEST, un, "sd_faultinjection: exit\n");
30488 }
30489
30490 #endif /* SD_FAULT_INJECTION */
30491
30492 /*
30493 * This routine is invoked in sd_unit_attach(). Before calling it, the
30494 * properties in conf file should be processed already, and "hotpluggable"
30495 * property was processed also.
30496 *
30497 * The sd driver distinguishes 3 different type of devices: removable media,
30498 * non-removable media, and hotpluggable. Below the differences are defined:
30499 *
30500 * 1. Device ID
30501 *
30502 * The device ID of a device is used to identify this device. Refer to
30503 * ddi_devid_register(9F).
30504 *
30505 * For a non-removable media disk device which can provide 0x80 or 0x83
30506 * VPD page (refer to INQUIRY command of SCSI SPC specification), a unique
30507 * device ID is created to identify this device. For other non-removable
30508 * media devices, a default device ID is created only if this device has
30509 * at least 2 alter cylinders. Otherwise, this device has no devid.
30510 *
30511 * -------------------------------------------------------
30512 * removable media hotpluggable | Can Have Device ID
30513 * -------------------------------------------------------
30514 * false false | Yes
30515 * false true | Yes
30516 * true x | No
30517 * ------------------------------------------------------
30518 *
30519 *
30520 * 2. SCSI group 4 commands
30521 *
30522 * In SCSI specs, only some commands in group 4 command set can use
30523 * 8-byte addresses that can be used to access >2TB storage spaces.
30524 * Other commands have no such capability. Without supporting group4,
30525 * it is impossible to make full use of storage spaces of a disk with
30526 * capacity larger than 2TB.
30527 *
30528 * -----------------------------------------------
30529 * removable media hotpluggable LP64 | Group
30530 * -----------------------------------------------
30531 * false false false | 1
30532 * false false true | 4
30533 * false true false | 1
30534 * false true true | 4
30535 * true x x | 5
30536 * -----------------------------------------------
30537 *
30538 *
30539 * 3. Check for VTOC Label
30540 *
30541 * If a direct-access disk has no EFI label, sd will check if it has a
30542 * valid VTOC label. Now, sd also does that check for removable media
30543 * and hotpluggable devices.
30544 *
30545 * --------------------------------------------------------------
30546 * Direct-Access removable media hotpluggable | Check Label
30547 * -------------------------------------------------------------
30548 * false false false | No
30549 * false false true | No
30550 * false true false | Yes
30551 * false true true | Yes
30552 * true x x | Yes
30553 * --------------------------------------------------------------
30554 *
30555 *
30556 * 4. Building default VTOC label
30557 *
30558 * As section 3 says, sd checks if some kinds of devices have VTOC label.
30559 * If those devices have no valid VTOC label, sd(7d) will attempt to
30560 * create default VTOC for them. Currently sd creates default VTOC label
30561 * for all devices on x86 platform (VTOC_16), but only for removable
30562 * media devices on SPARC (VTOC_8).
30563 *
30564 * -----------------------------------------------------------
30565 * removable media hotpluggable platform | Default Label
30566 * -----------------------------------------------------------
30567 * false false sparc | No
30568 * false true x86 | Yes
30569 * false true sparc | Yes
30570 * true x x | Yes
30571 * ----------------------------------------------------------
30572 *
30573 *
30574 * 5. Supported blocksizes of target devices
30575 *
30576 * Sd supports non-512-byte blocksize for removable media devices only.
30577 * For other devices, only 512-byte blocksize is supported. This may be
30578 * changed in near future because some RAID devices require non-512-byte
30579 * blocksize
30580 *
30581 * -----------------------------------------------------------
30582 * removable media hotpluggable | non-512-byte blocksize
30583 * -----------------------------------------------------------
30584 * false false | No
30585 * false true | No
30586 * true x | Yes
30587 * -----------------------------------------------------------
30588 *
30589 *
30590 * 6. Automatic mount & unmount
30591 *
30592 * Sd(7d) driver provides DKIOCREMOVABLE ioctl. This ioctl is used to query
30593 * if a device is removable media device. It return 1 for removable media
30594 * devices, and 0 for others.
30595 *
30596 * The automatic mounting subsystem should distinguish between the types
30597 * of devices and apply automounting policies to each.
30598 *
30599 *
30600 * 7. fdisk partition management
30601 *
30602 * Fdisk is traditional partition method on x86 platform. Sd(7d) driver
30603 * just supports fdisk partitions on x86 platform. On sparc platform, sd
30604 * doesn't support fdisk partitions at all. Note: pcfs(7fs) can recognize
30605 * fdisk partitions on both x86 and SPARC platform.
30606 *
30607 * -----------------------------------------------------------
30608 * platform removable media USB/1394 | fdisk supported
30609 * -----------------------------------------------------------
30610 * x86 X X | true
30611 * ------------------------------------------------------------
30612 * sparc X X | false
30613 * ------------------------------------------------------------
30614 *
30615 *
30616 * 8. MBOOT/MBR
30617 *
30618 * Although sd(7d) doesn't support fdisk on SPARC platform, it does support
30619 * read/write mboot for removable media devices on sparc platform.
30620 *
30621 * -----------------------------------------------------------
30622 * platform removable media USB/1394 | mboot supported
30623 * -----------------------------------------------------------
30624 * x86 X X | true
30625 * ------------------------------------------------------------
30626 * sparc false false | false
30627 * sparc false true | true
30628 * sparc true false | true
30629 * sparc true true | true
30630 * ------------------------------------------------------------
30631 *
30632 *
30633 * 9. error handling during opening device
30634 *
30635 * If failed to open a disk device, an errno is returned. For some kinds
30636 * of errors, different errno is returned depending on if this device is
30637 * a removable media device. This brings USB/1394 hard disks in line with
30638 * expected hard disk behavior. It is not expected that this breaks any
30639 * application.
30640 *
30641 * ------------------------------------------------------
30642 * removable media hotpluggable | errno
30643 * ------------------------------------------------------
30644 * false false | EIO
30645 * false true | EIO
30646 * true x | ENXIO
30647 * ------------------------------------------------------
30648 *
30649 *
30650 * 11. ioctls: DKIOCEJECT, CDROMEJECT
30651 *
30652 * These IOCTLs are applicable only to removable media devices.
30653 *
30654 * -----------------------------------------------------------
30655 * removable media hotpluggable |DKIOCEJECT, CDROMEJECT
30656 * -----------------------------------------------------------
30657 * false false | No
30658 * false true | No
30659 * true x | Yes
30660 * -----------------------------------------------------------
30661 *
30662 *
30663 * 12. Kstats for partitions
30664 *
30665 * sd creates partition kstat for non-removable media devices. USB and
30666 * Firewire hard disks now have partition kstats
30667 *
30668 * ------------------------------------------------------
30669 * removable media hotpluggable | kstat
30670 * ------------------------------------------------------
30671 * false false | Yes
30672 * false true | Yes
30673 * true x | No
30674 * ------------------------------------------------------
30675 *
30676 *
30677 * 13. Removable media & hotpluggable properties
30678 *
30679 * Sd driver creates a "removable-media" property for removable media
30680 * devices. Parent nexus drivers create a "hotpluggable" property if
30681 * it supports hotplugging.
30682 *
30683 * ---------------------------------------------------------------------
30684 * removable media hotpluggable | "removable-media" " hotpluggable"
30685 * ---------------------------------------------------------------------
30686 * false false | No No
30687 * false true | No Yes
30688 * true false | Yes No
30689 * true true | Yes Yes
30690 * ---------------------------------------------------------------------
30691 *
30692 *
30693 * 14. Power Management
30694 *
30695 * sd only power manages removable media devices or devices that support
30696 * LOG_SENSE or have a "pm-capable" property (PSARC/2002/250)
30697 *
30698 * A parent nexus that supports hotplugging can also set "pm-capable"
30699 * if the disk can be power managed.
30700 *
30701 * ------------------------------------------------------------
30702 * removable media hotpluggable pm-capable | power manage
30703 * ------------------------------------------------------------
30704 * false false false | No
30705 * false false true | Yes
30706 * false true false | No
30707 * false true true | Yes
30708 * true x x | Yes
30709 * ------------------------------------------------------------
30710 *
30711 * USB and firewire hard disks can now be power managed independently
30712 * of the framebuffer
30713 *
30714 *
30715 * 15. Support for USB disks with capacity larger than 1TB
30716 *
30717 * Currently, sd doesn't permit a fixed disk device with capacity
30718 * larger than 1TB to be used in a 32-bit operating system environment.
30719 * However, sd doesn't do that for removable media devices. Instead, it
30720 * assumes that removable media devices cannot have a capacity larger
30721 * than 1TB. Therefore, using those devices on 32-bit system is partially
30722 * supported, which can cause some unexpected results.
30723 *
30724 * ---------------------------------------------------------------------
30725 * removable media USB/1394 | Capacity > 1TB | Used in 32-bit env
30726 * ---------------------------------------------------------------------
30727 * false false | true | no
30728 * false true | true | no
30729 * true false | true | Yes
30730 * true true | true | Yes
30731 * ---------------------------------------------------------------------
30732 *
30733 *
30734 * 16. Check write-protection at open time
30735 *
30736 * When a removable media device is being opened for writing without NDELAY
30737 * flag, sd will check if this device is writable. If attempting to open
30738 * without NDELAY flag a write-protected device, this operation will abort.
30739 *
30740 * ------------------------------------------------------------
30741 * removable media USB/1394 | WP Check
30742 * ------------------------------------------------------------
30743 * false false | No
30744 * false true | No
30745 * true false | Yes
30746 * true true | Yes
30747 * ------------------------------------------------------------
30748 *
30749 *
30750 * 17. syslog when corrupted VTOC is encountered
30751 *
30752 * Currently, if an invalid VTOC is encountered, sd only print syslog
30753 * for fixed SCSI disks.
30754 * ------------------------------------------------------------
30755 * removable media USB/1394 | print syslog
30756 * ------------------------------------------------------------
30757 * false false | Yes
30758 * false true | No
30759 * true false | No
30760 * true true | No
30761 * ------------------------------------------------------------
30762 */
30763 static void
30764 sd_set_unit_attributes(struct sd_lun *un, dev_info_t *devi)
30765 {
30766 int pm_cap;
30767
30768 ASSERT(un->un_sd);
30769 ASSERT(un->un_sd->sd_inq);
30770
30771 /*
30772 * Enable SYNC CACHE support for all devices.
30773 */
30774 un->un_f_sync_cache_supported = TRUE;
30775
30776 /*
30777 * Set the sync cache required flag to false.
30778 * This would ensure that there is no SYNC CACHE
30779 * sent when there are no writes
30780 */
30781 un->un_f_sync_cache_required = FALSE;
30782
30783 if (un->un_sd->sd_inq->inq_rmb) {
30784 /*
30785 * The media of this device is removable. And for this kind
30786 * of devices, it is possible to change medium after opening
30787 * devices. Thus we should support this operation.
30788 */
30789 un->un_f_has_removable_media = TRUE;
30790
30791 /*
30792 * support non-512-byte blocksize of removable media devices
30793 */
30794 un->un_f_non_devbsize_supported = TRUE;
30795
30796 /*
30797 * Assume that all removable media devices support DOOR_LOCK
30798 */
30799 un->un_f_doorlock_supported = TRUE;
30800
30801 /*
30802 * For a removable media device, it is possible to be opened
30803 * with NDELAY flag when there is no media in drive, in this
30804 * case we don't care if device is writable. But if without
30805 * NDELAY flag, we need to check if media is write-protected.
30806 */
30807 un->un_f_chk_wp_open = TRUE;
30808
30809 /*
30810 * need to start a SCSI watch thread to monitor media state,
30811 * when media is being inserted or ejected, notify syseventd.
30812 */
30813 un->un_f_monitor_media_state = TRUE;
30814
30815 /*
30816 * Some devices don't support START_STOP_UNIT command.
30817 * Therefore, we'd better check if a device supports it
30818 * before sending it.
30819 */
30820 un->un_f_check_start_stop = TRUE;
30821
30822 /*
30823 * support eject media ioctl:
30824 * FDEJECT, DKIOCEJECT, CDROMEJECT
30825 */
30826 un->un_f_eject_media_supported = TRUE;
30827
30828 /*
30829 * Because many removable-media devices don't support
30830 * LOG_SENSE, we couldn't use this command to check if
30831 * a removable media device support power-management.
30832 * We assume that they support power-management via
30833 * START_STOP_UNIT command and can be spun up and down
30834 * without limitations.
30835 */
30836 un->un_f_pm_supported = TRUE;
30837
30838 /*
30839 * Need to create a zero length (Boolean) property
30840 * removable-media for the removable media devices.
30841 * Note that the return value of the property is not being
30842 * checked, since if unable to create the property
30843 * then do not want the attach to fail altogether. Consistent
30844 * with other property creation in attach.
30845 */
30846 (void) ddi_prop_create(DDI_DEV_T_NONE, devi,
30847 DDI_PROP_CANSLEEP, "removable-media", NULL, 0);
30848
30849 } else {
30850 /*
30851 * create device ID for device
30852 */
30853 un->un_f_devid_supported = TRUE;
30854
30855 /*
30856 * Spin up non-removable-media devices once it is attached
30857 */
30858 un->un_f_attach_spinup = TRUE;
30859
30860 /*
30861 * According to SCSI specification, Sense data has two kinds of
30862 * format: fixed format, and descriptor format. At present, we
30863 * don't support descriptor format sense data for removable
30864 * media.
30865 */
30866 if (SD_INQUIRY(un)->inq_dtype == DTYPE_DIRECT) {
30867 un->un_f_descr_format_supported = TRUE;
30868 }
30869
30870 /*
30871 * kstats are created only for non-removable media devices.
30872 *
30873 * Set this in sd.conf to 0 in order to disable kstats. The
30874 * default is 1, so they are enabled by default.
30875 */
30876 un->un_f_pkstats_enabled = (ddi_prop_get_int(DDI_DEV_T_ANY,
30877 SD_DEVINFO(un), DDI_PROP_DONTPASS,
30878 "enable-partition-kstats", 1));
30879
30880 /*
30881 * Check if HBA has set the "pm-capable" property.
30882 * If "pm-capable" exists and is non-zero then we can
30883 * power manage the device without checking the start/stop
30884 * cycle count log sense page.
30885 *
30886 * If "pm-capable" exists and is set to be false (0),
30887 * then we should not power manage the device.
30888 *
30889 * If "pm-capable" doesn't exist then pm_cap will
30890 * be set to SD_PM_CAPABLE_UNDEFINED (-1). In this case,
30891 * sd will check the start/stop cycle count log sense page
30892 * and power manage the device if the cycle count limit has
30893 * not been exceeded.
30894 */
30895 pm_cap = ddi_prop_get_int(DDI_DEV_T_ANY, devi,
30896 DDI_PROP_DONTPASS, "pm-capable", SD_PM_CAPABLE_UNDEFINED);
30897 if (SD_PM_CAPABLE_IS_UNDEFINED(pm_cap)) {
30898 un->un_f_log_sense_supported = TRUE;
30899 if (!un->un_f_power_condition_disabled &&
30900 SD_INQUIRY(un)->inq_ansi == 6) {
30901 un->un_f_power_condition_supported = TRUE;
30902 }
30903 } else {
30904 /*
30905 * pm-capable property exists.
30906 *
30907 * Convert "TRUE" values for pm_cap to
30908 * SD_PM_CAPABLE_IS_TRUE to make it easier to check
30909 * later. "TRUE" values are any values defined in
30910 * inquiry.h.
30911 */
30912 if (SD_PM_CAPABLE_IS_FALSE(pm_cap)) {
30913 un->un_f_log_sense_supported = FALSE;
30914 } else {
30915 /* SD_PM_CAPABLE_IS_TRUE case */
30916 un->un_f_pm_supported = TRUE;
30917 if (!un->un_f_power_condition_disabled &&
30918 SD_PM_CAPABLE_IS_SPC_4(pm_cap)) {
30919 un->un_f_power_condition_supported =
30920 TRUE;
30921 }
30922 if (SD_PM_CAP_LOG_SUPPORTED(pm_cap)) {
30923 un->un_f_log_sense_supported = TRUE;
30924 un->un_f_pm_log_sense_smart =
30925 SD_PM_CAP_SMART_LOG(pm_cap);
30926 }
30927 }
30928
30929 SD_INFO(SD_LOG_ATTACH_DETACH, un,
30930 "sd_unit_attach: un:0x%p pm-capable "
30931 "property set to %d.\n", un, un->un_f_pm_supported);
30932 }
30933 }
30934
30935 if (un->un_f_is_hotpluggable) {
30936
30937 /*
30938 * Have to watch hotpluggable devices as well, since
30939 * that's the only way for userland applications to
30940 * detect hot removal while device is busy/mounted.
30941 */
30942 un->un_f_monitor_media_state = TRUE;
30943
30944 un->un_f_check_start_stop = TRUE;
30945
30946 }
30947 }
30948
30949 /*
30950 * sd_tg_rdwr:
30951 * Provides rdwr access for cmlb via sd_tgops. The start_block is
30952 * in sys block size, req_length in bytes.
30953 *
30954 */
30955 static int
30956 sd_tg_rdwr(dev_info_t *devi, uchar_t cmd, void *bufaddr,
30957 diskaddr_t start_block, size_t reqlength, void *tg_cookie)
30958 {
30959 struct sd_lun *un;
30960 int path_flag = (int)(uintptr_t)tg_cookie;
30961 char *dkl = NULL;
30962 diskaddr_t real_addr = start_block;
30963 diskaddr_t first_byte, end_block;
30964
30965 size_t buffer_size = reqlength;
30966 int rval = 0;
30967 diskaddr_t cap;
30968 uint32_t lbasize;
30969 sd_ssc_t *ssc;
30970
30971 un = ddi_get_soft_state(sd_state, ddi_get_instance(devi));
30972 if (un == NULL)
30973 return (ENXIO);
30974
30975 if (cmd != TG_READ && cmd != TG_WRITE)
30976 return (EINVAL);
30977
30978 ssc = sd_ssc_init(un);
30979 mutex_enter(SD_MUTEX(un));
30980 if (un->un_f_tgt_blocksize_is_valid == FALSE) {
30981 mutex_exit(SD_MUTEX(un));
30982 rval = sd_send_scsi_READ_CAPACITY(ssc, (uint64_t *)&cap,
30983 &lbasize, path_flag);
30984 if (rval != 0)
30985 goto done1;
30986 mutex_enter(SD_MUTEX(un));
30987 sd_update_block_info(un, lbasize, cap);
30988 if ((un->un_f_tgt_blocksize_is_valid == FALSE)) {
30989 mutex_exit(SD_MUTEX(un));
30990 rval = EIO;
30991 goto done;
30992 }
30993 }
30994
30995 if (NOT_DEVBSIZE(un)) {
30996 /*
30997 * sys_blocksize != tgt_blocksize, need to re-adjust
30998 * blkno and save the index to beginning of dk_label
30999 */
31000 first_byte = SD_SYSBLOCKS2BYTES(start_block);
31001 real_addr = first_byte / un->un_tgt_blocksize;
31002
31003 end_block = (first_byte + reqlength +
31004 un->un_tgt_blocksize - 1) / un->un_tgt_blocksize;
31005
31006 /* round up buffer size to multiple of target block size */
31007 buffer_size = (end_block - real_addr) * un->un_tgt_blocksize;
31008
31009 SD_TRACE(SD_LOG_IO_PARTITION, un, "sd_tg_rdwr",
31010 "label_addr: 0x%x allocation size: 0x%x\n",
31011 real_addr, buffer_size);
31012
31013 if (((first_byte % un->un_tgt_blocksize) != 0) ||
31014 (reqlength % un->un_tgt_blocksize) != 0)
31015 /* the request is not aligned */
31016 dkl = kmem_zalloc(buffer_size, KM_SLEEP);
31017 }
31018
31019 /*
31020 * The MMC standard allows READ CAPACITY to be
31021 * inaccurate by a bounded amount (in the interest of
31022 * response latency). As a result, failed READs are
31023 * commonplace (due to the reading of metadata and not
31024 * data). Depending on the per-Vendor/drive Sense data,
31025 * the failed READ can cause many (unnecessary) retries.
31026 */
31027
31028 if (ISCD(un) && (cmd == TG_READ) &&
31029 (un->un_f_blockcount_is_valid == TRUE) &&
31030 ((start_block == (un->un_blockcount - 1))||
31031 (start_block == (un->un_blockcount - 2)))) {
31032 path_flag = SD_PATH_DIRECT_PRIORITY;
31033 }
31034
31035 mutex_exit(SD_MUTEX(un));
31036 if (cmd == TG_READ) {
31037 rval = sd_send_scsi_READ(ssc, (dkl != NULL)? dkl: bufaddr,
31038 buffer_size, real_addr, path_flag);
31039 if (dkl != NULL)
31040 bcopy(dkl + SD_TGTBYTEOFFSET(un, start_block,
31041 real_addr), bufaddr, reqlength);
31042 } else {
31043 if (dkl) {
31044 rval = sd_send_scsi_READ(ssc, dkl, buffer_size,
31045 real_addr, path_flag);
31046 if (rval) {
31047 goto done1;
31048 }
31049 bcopy(bufaddr, dkl + SD_TGTBYTEOFFSET(un, start_block,
31050 real_addr), reqlength);
31051 }
31052 rval = sd_send_scsi_WRITE(ssc, (dkl != NULL)? dkl: bufaddr,
31053 buffer_size, real_addr, path_flag);
31054 }
31055
31056 done1:
31057 if (dkl != NULL)
31058 kmem_free(dkl, buffer_size);
31059
31060 if (rval != 0) {
31061 if (rval == EIO)
31062 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
31063 else
31064 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
31065 }
31066 done:
31067 sd_ssc_fini(ssc);
31068 return (rval);
31069 }
31070
31071
31072 static int
31073 sd_tg_getinfo(dev_info_t *devi, int cmd, void *arg, void *tg_cookie)
31074 {
31075
31076 struct sd_lun *un;
31077 diskaddr_t cap;
31078 uint32_t lbasize;
31079 int path_flag = (int)(uintptr_t)tg_cookie;
31080 int ret = 0;
31081
31082 un = ddi_get_soft_state(sd_state, ddi_get_instance(devi));
31083 if (un == NULL)
31084 return (ENXIO);
31085
31086 switch (cmd) {
31087 case TG_GETPHYGEOM:
31088 case TG_GETVIRTGEOM:
31089 case TG_GETCAPACITY:
31090 case TG_GETBLOCKSIZE:
31091 mutex_enter(SD_MUTEX(un));
31092
31093 if ((un->un_f_blockcount_is_valid == TRUE) &&
31094 (un->un_f_tgt_blocksize_is_valid == TRUE)) {
31095 cap = un->un_blockcount;
31096 lbasize = un->un_tgt_blocksize;
31097 mutex_exit(SD_MUTEX(un));
31098 } else {
31099 sd_ssc_t *ssc;
31100 mutex_exit(SD_MUTEX(un));
31101 ssc = sd_ssc_init(un);
31102 ret = sd_send_scsi_READ_CAPACITY(ssc, (uint64_t *)&cap,
31103 &lbasize, path_flag);
31104 if (ret != 0) {
31105 if (ret == EIO)
31106 sd_ssc_assessment(ssc,
31107 SD_FMT_STATUS_CHECK);
31108 else
31109 sd_ssc_assessment(ssc,
31110 SD_FMT_IGNORE);
31111 sd_ssc_fini(ssc);
31112 return (ret);
31113 }
31114 sd_ssc_fini(ssc);
31115 mutex_enter(SD_MUTEX(un));
31116 sd_update_block_info(un, lbasize, cap);
31117 if ((un->un_f_blockcount_is_valid == FALSE) ||
31118 (un->un_f_tgt_blocksize_is_valid == FALSE)) {
31119 mutex_exit(SD_MUTEX(un));
31120 return (EIO);
31121 }
31122 mutex_exit(SD_MUTEX(un));
31123 }
31124
31125 if (cmd == TG_GETCAPACITY) {
31126 *(diskaddr_t *)arg = cap;
31127 return (0);
31128 }
31129
31130 if (cmd == TG_GETBLOCKSIZE) {
31131 *(uint32_t *)arg = lbasize;
31132 return (0);
31133 }
31134
31135 if (cmd == TG_GETPHYGEOM)
31136 ret = sd_get_physical_geometry(un, (cmlb_geom_t *)arg,
31137 cap, lbasize, path_flag);
31138 else
31139 /* TG_GETVIRTGEOM */
31140 ret = sd_get_virtual_geometry(un,
31141 (cmlb_geom_t *)arg, cap, lbasize);
31142
31143 return (ret);
31144
31145 case TG_GETATTR:
31146 mutex_enter(SD_MUTEX(un));
31147 ((tg_attribute_t *)arg)->media_is_writable =
31148 un->un_f_mmc_writable_media;
31149 ((tg_attribute_t *)arg)->media_is_solid_state =
31150 un->un_f_is_solid_state;
31151 ((tg_attribute_t *)arg)->media_is_rotational =
31152 un->un_f_is_rotational;
31153 mutex_exit(SD_MUTEX(un));
31154 return (0);
31155 default:
31156 return (ENOTTY);
31157
31158 }
31159 }
31160
31161 /*
31162 * Function: sd_ssc_ereport_post
31163 *
31164 * Description: Will be called when SD driver need to post an ereport.
31165 *
31166 * Context: Kernel thread or interrupt context.
31167 */
31168
31169 #define DEVID_IF_KNOWN(d) "devid", DATA_TYPE_STRING, (d) ? (d) : "unknown"
31170
31171 static void
31172 sd_ssc_ereport_post(sd_ssc_t *ssc, enum sd_driver_assessment drv_assess)
31173 {
31174 int uscsi_path_instance = 0;
31175 uchar_t uscsi_pkt_reason;
31176 uint32_t uscsi_pkt_state;
31177 uint32_t uscsi_pkt_statistics;
31178 uint64_t uscsi_ena;
31179 uchar_t op_code;
31180 uint8_t *sensep;
31181 union scsi_cdb *cdbp;
31182 uint_t cdblen = 0;
31183 uint_t senlen = 0;
31184 struct sd_lun *un;
31185 dev_info_t *dip;
31186 char *devid;
31187 int ssc_invalid_flags = SSC_FLAGS_INVALID_PKT_REASON |
31188 SSC_FLAGS_INVALID_STATUS |
31189 SSC_FLAGS_INVALID_SENSE |
31190 SSC_FLAGS_INVALID_DATA;
31191 char assessment[16];
31192
31193 ASSERT(ssc != NULL);
31194 ASSERT(ssc->ssc_uscsi_cmd != NULL);
31195 ASSERT(ssc->ssc_uscsi_info != NULL);
31196
31197 un = ssc->ssc_un;
31198 ASSERT(un != NULL);
31199
31200 dip = un->un_sd->sd_dev;
31201
31202 /*
31203 * Get the devid:
31204 * devid will only be passed to non-transport error reports.
31205 */
31206 devid = DEVI(dip)->devi_devid_str;
31207
31208 /*
31209 * If we are syncing or dumping, the command will not be executed
31210 * so we bypass this situation.
31211 */
31212 if (ddi_in_panic() || (un->un_state == SD_STATE_SUSPENDED) ||
31213 (un->un_state == SD_STATE_DUMPING))
31214 return;
31215
31216 uscsi_pkt_reason = ssc->ssc_uscsi_info->ui_pkt_reason;
31217 uscsi_path_instance = ssc->ssc_uscsi_cmd->uscsi_path_instance;
31218 uscsi_pkt_state = ssc->ssc_uscsi_info->ui_pkt_state;
31219 uscsi_pkt_statistics = ssc->ssc_uscsi_info->ui_pkt_statistics;
31220 uscsi_ena = ssc->ssc_uscsi_info->ui_ena;
31221
31222 sensep = (uint8_t *)ssc->ssc_uscsi_cmd->uscsi_rqbuf;
31223 cdbp = (union scsi_cdb *)ssc->ssc_uscsi_cmd->uscsi_cdb;
31224
31225 /* In rare cases, EG:DOORLOCK, the cdb could be NULL */
31226 if (cdbp == NULL) {
31227 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
31228 "sd_ssc_ereport_post meet empty cdb\n");
31229 return;
31230 }
31231
31232 op_code = cdbp->scc_cmd;
31233
31234 cdblen = (int)ssc->ssc_uscsi_cmd->uscsi_cdblen;
31235 senlen = (int)(ssc->ssc_uscsi_cmd->uscsi_rqlen -
31236 ssc->ssc_uscsi_cmd->uscsi_rqresid);
31237
31238 if (senlen > 0)
31239 ASSERT(sensep != NULL);
31240
31241 /*
31242 * Initialize drv_assess to corresponding values.
31243 * SD_FM_DRV_FATAL will be mapped to "fail" or "fatal" depending
31244 * on the sense-key returned back.
31245 */
31246 switch (drv_assess) {
31247 case SD_FM_DRV_RECOVERY:
31248 (void) sprintf(assessment, "%s", "recovered");
31249 break;
31250 case SD_FM_DRV_RETRY:
31251 (void) sprintf(assessment, "%s", "retry");
31252 break;
31253 case SD_FM_DRV_NOTICE:
31254 (void) sprintf(assessment, "%s", "info");
31255 break;
31256 case SD_FM_DRV_FATAL:
31257 default:
31258 (void) sprintf(assessment, "%s", "unknown");
31259 }
31260 /*
31261 * If drv_assess == SD_FM_DRV_RECOVERY, this should be a recovered
31262 * command, we will post ereport.io.scsi.cmd.disk.recovered.
31263 * driver-assessment will always be "recovered" here.
31264 */
31265 if (drv_assess == SD_FM_DRV_RECOVERY) {
31266 scsi_fm_ereport_post(un->un_sd, uscsi_path_instance, NULL,
31267 "cmd.disk.recovered", uscsi_ena, devid, NULL,
31268 DDI_NOSLEEP, NULL,
31269 FM_VERSION, DATA_TYPE_UINT8, FM_EREPORT_VERS0,
31270 DEVID_IF_KNOWN(devid),
31271 "driver-assessment", DATA_TYPE_STRING, assessment,
31272 "op-code", DATA_TYPE_UINT8, op_code,
31273 "cdb", DATA_TYPE_UINT8_ARRAY,
31274 cdblen, ssc->ssc_uscsi_cmd->uscsi_cdb,
31275 "pkt-reason", DATA_TYPE_UINT8, uscsi_pkt_reason,
31276 "pkt-state", DATA_TYPE_UINT32, uscsi_pkt_state,
31277 "pkt-stats", DATA_TYPE_UINT32, uscsi_pkt_statistics,
31278 NULL);
31279 return;
31280 }
31281
31282 /*
31283 * If there is un-expected/un-decodable data, we should post
31284 * ereport.io.scsi.cmd.disk.dev.uderr.
31285 * driver-assessment will be set based on parameter drv_assess.
31286 * SSC_FLAGS_INVALID_SENSE - invalid sense data sent back.
31287 * SSC_FLAGS_INVALID_PKT_REASON - invalid pkt-reason encountered.
31288 * SSC_FLAGS_INVALID_STATUS - invalid stat-code encountered.
31289 * SSC_FLAGS_INVALID_DATA - invalid data sent back.
31290 */
31291 if (ssc->ssc_flags & ssc_invalid_flags) {
31292 if (ssc->ssc_flags & SSC_FLAGS_INVALID_SENSE) {
31293 scsi_fm_ereport_post(un->un_sd, uscsi_path_instance,
31294 NULL, "cmd.disk.dev.uderr", uscsi_ena, devid,
31295 NULL, DDI_NOSLEEP, NULL,
31296 FM_VERSION, DATA_TYPE_UINT8, FM_EREPORT_VERS0,
31297 DEVID_IF_KNOWN(devid),
31298 "driver-assessment", DATA_TYPE_STRING,
31299 drv_assess == SD_FM_DRV_FATAL ?
31300 "fail" : assessment,
31301 "op-code", DATA_TYPE_UINT8, op_code,
31302 "cdb", DATA_TYPE_UINT8_ARRAY,
31303 cdblen, ssc->ssc_uscsi_cmd->uscsi_cdb,
31304 "pkt-reason", DATA_TYPE_UINT8, uscsi_pkt_reason,
31305 "pkt-state", DATA_TYPE_UINT32, uscsi_pkt_state,
31306 "pkt-stats", DATA_TYPE_UINT32,
31307 uscsi_pkt_statistics,
31308 "stat-code", DATA_TYPE_UINT8,
31309 ssc->ssc_uscsi_cmd->uscsi_status,
31310 "un-decode-info", DATA_TYPE_STRING,
31311 ssc->ssc_info,
31312 "un-decode-value", DATA_TYPE_UINT8_ARRAY,
31313 senlen, sensep,
31314 NULL);
31315 } else {
31316 /*
31317 * For other type of invalid data, the
31318 * un-decode-value field would be empty because the
31319 * un-decodable content could be seen from upper
31320 * level payload or inside un-decode-info.
31321 */
31322 scsi_fm_ereport_post(un->un_sd, uscsi_path_instance,
31323 NULL,
31324 "cmd.disk.dev.uderr", uscsi_ena, devid,
31325 NULL, DDI_NOSLEEP, NULL,
31326 FM_VERSION, DATA_TYPE_UINT8, FM_EREPORT_VERS0,
31327 DEVID_IF_KNOWN(devid),
31328 "driver-assessment", DATA_TYPE_STRING,
31329 drv_assess == SD_FM_DRV_FATAL ?
31330 "fail" : assessment,
31331 "op-code", DATA_TYPE_UINT8, op_code,
31332 "cdb", DATA_TYPE_UINT8_ARRAY,
31333 cdblen, ssc->ssc_uscsi_cmd->uscsi_cdb,
31334 "pkt-reason", DATA_TYPE_UINT8, uscsi_pkt_reason,
31335 "pkt-state", DATA_TYPE_UINT32, uscsi_pkt_state,
31336 "pkt-stats", DATA_TYPE_UINT32,
31337 uscsi_pkt_statistics,
31338 "stat-code", DATA_TYPE_UINT8,
31339 ssc->ssc_uscsi_cmd->uscsi_status,
31340 "un-decode-info", DATA_TYPE_STRING,
31341 ssc->ssc_info,
31342 "un-decode-value", DATA_TYPE_UINT8_ARRAY,
31343 0, NULL,
31344 NULL);
31345 }
31346 ssc->ssc_flags &= ~ssc_invalid_flags;
31347 return;
31348 }
31349
31350 if (uscsi_pkt_reason != CMD_CMPLT ||
31351 (ssc->ssc_flags & SSC_FLAGS_TRAN_ABORT)) {
31352 /*
31353 * pkt-reason != CMD_CMPLT or SSC_FLAGS_TRAN_ABORT was
31354 * set inside sd_start_cmds due to errors(bad packet or
31355 * fatal transport error), we should take it as a
31356 * transport error, so we post ereport.io.scsi.cmd.disk.tran.
31357 * driver-assessment will be set based on drv_assess.
31358 * We will set devid to NULL because it is a transport
31359 * error.
31360 */
31361 if (ssc->ssc_flags & SSC_FLAGS_TRAN_ABORT)
31362 ssc->ssc_flags &= ~SSC_FLAGS_TRAN_ABORT;
31363
31364 scsi_fm_ereport_post(un->un_sd, uscsi_path_instance, NULL,
31365 "cmd.disk.tran", uscsi_ena, NULL, NULL, DDI_NOSLEEP, NULL,
31366 FM_VERSION, DATA_TYPE_UINT8, FM_EREPORT_VERS0,
31367 DEVID_IF_KNOWN(devid),
31368 "driver-assessment", DATA_TYPE_STRING,
31369 drv_assess == SD_FM_DRV_FATAL ? "fail" : assessment,
31370 "op-code", DATA_TYPE_UINT8, op_code,
31371 "cdb", DATA_TYPE_UINT8_ARRAY,
31372 cdblen, ssc->ssc_uscsi_cmd->uscsi_cdb,
31373 "pkt-reason", DATA_TYPE_UINT8, uscsi_pkt_reason,
31374 "pkt-state", DATA_TYPE_UINT8, uscsi_pkt_state,
31375 "pkt-stats", DATA_TYPE_UINT32, uscsi_pkt_statistics,
31376 NULL);
31377 } else {
31378 /*
31379 * If we got here, we have a completed command, and we need
31380 * to further investigate the sense data to see what kind
31381 * of ereport we should post.
31382 * No ereport is needed if sense-key is KEY_RECOVERABLE_ERROR
31383 * and asc/ascq is "ATA PASS-THROUGH INFORMATION AVAILABLE".
31384 * Post ereport.io.scsi.cmd.disk.dev.rqs.merr if sense-key is
31385 * KEY_MEDIUM_ERROR.
31386 * Post ereport.io.scsi.cmd.disk.dev.rqs.derr otherwise.
31387 * driver-assessment will be set based on the parameter
31388 * drv_assess.
31389 */
31390 if (senlen > 0) {
31391 /*
31392 * Here we have sense data available.
31393 */
31394 uint8_t sense_key = scsi_sense_key(sensep);
31395 uint8_t sense_asc = scsi_sense_asc(sensep);
31396 uint8_t sense_ascq = scsi_sense_ascq(sensep);
31397
31398 if (sense_key == KEY_RECOVERABLE_ERROR &&
31399 sense_asc == 0x00 && sense_ascq == 0x1d)
31400 return;
31401
31402 if (sense_key == KEY_MEDIUM_ERROR) {
31403 /*
31404 * driver-assessment should be "fatal" if
31405 * drv_assess is SD_FM_DRV_FATAL.
31406 */
31407 scsi_fm_ereport_post(un->un_sd,
31408 uscsi_path_instance, NULL,
31409 "cmd.disk.dev.rqs.merr",
31410 uscsi_ena, devid, NULL, DDI_NOSLEEP, NULL,
31411 FM_VERSION, DATA_TYPE_UINT8,
31412 FM_EREPORT_VERS0,
31413 DEVID_IF_KNOWN(devid),
31414 "driver-assessment",
31415 DATA_TYPE_STRING,
31416 drv_assess == SD_FM_DRV_FATAL ?
31417 "fatal" : assessment,
31418 "op-code",
31419 DATA_TYPE_UINT8, op_code,
31420 "cdb",
31421 DATA_TYPE_UINT8_ARRAY, cdblen,
31422 ssc->ssc_uscsi_cmd->uscsi_cdb,
31423 "pkt-reason",
31424 DATA_TYPE_UINT8, uscsi_pkt_reason,
31425 "pkt-state",
31426 DATA_TYPE_UINT8, uscsi_pkt_state,
31427 "pkt-stats",
31428 DATA_TYPE_UINT32,
31429 uscsi_pkt_statistics,
31430 "stat-code",
31431 DATA_TYPE_UINT8,
31432 ssc->ssc_uscsi_cmd->uscsi_status,
31433 "key",
31434 DATA_TYPE_UINT8,
31435 scsi_sense_key(sensep),
31436 "asc",
31437 DATA_TYPE_UINT8,
31438 scsi_sense_asc(sensep),
31439 "ascq",
31440 DATA_TYPE_UINT8,
31441 scsi_sense_ascq(sensep),
31442 "sense-data",
31443 DATA_TYPE_UINT8_ARRAY,
31444 senlen, sensep,
31445 "lba",
31446 DATA_TYPE_UINT64,
31447 ssc->ssc_uscsi_info->ui_lba,
31448 NULL);
31449 } else {
31450 /*
31451 * if sense-key == 0x4(hardware
31452 * error), driver-assessment should
31453 * be "fatal" if drv_assess is
31454 * SD_FM_DRV_FATAL.
31455 */
31456 scsi_fm_ereport_post(un->un_sd,
31457 uscsi_path_instance, NULL,
31458 "cmd.disk.dev.rqs.derr",
31459 uscsi_ena, devid,
31460 NULL, DDI_NOSLEEP, NULL,
31461 FM_VERSION,
31462 DATA_TYPE_UINT8, FM_EREPORT_VERS0,
31463 DEVID_IF_KNOWN(devid),
31464 "driver-assessment",
31465 DATA_TYPE_STRING,
31466 drv_assess == SD_FM_DRV_FATAL ?
31467 (sense_key == 0x4 ?
31468 "fatal" : "fail") : assessment,
31469 "op-code",
31470 DATA_TYPE_UINT8, op_code,
31471 "cdb",
31472 DATA_TYPE_UINT8_ARRAY, cdblen,
31473 ssc->ssc_uscsi_cmd->uscsi_cdb,
31474 "pkt-reason",
31475 DATA_TYPE_UINT8, uscsi_pkt_reason,
31476 "pkt-state",
31477 DATA_TYPE_UINT8, uscsi_pkt_state,
31478 "pkt-stats",
31479 DATA_TYPE_UINT32,
31480 uscsi_pkt_statistics,
31481 "stat-code",
31482 DATA_TYPE_UINT8,
31483 ssc->ssc_uscsi_cmd->uscsi_status,
31484 "key",
31485 DATA_TYPE_UINT8,
31486 scsi_sense_key(sensep),
31487 "asc",
31488 DATA_TYPE_UINT8,
31489 scsi_sense_asc(sensep),
31490 "ascq",
31491 DATA_TYPE_UINT8,
31492 scsi_sense_ascq(sensep),
31493 "sense-data",
31494 DATA_TYPE_UINT8_ARRAY,
31495 senlen, sensep,
31496 NULL);
31497 }
31498 } else {
31499 /*
31500 * For stat_code == STATUS_GOOD, this is not a
31501 * hardware error.
31502 */
31503 if (ssc->ssc_uscsi_cmd->uscsi_status == STATUS_GOOD)
31504 return;
31505
31506 /*
31507 * Post ereport.io.scsi.cmd.disk.dev.serr if we got the
31508 * stat-code but with sense data unavailable.
31509 * driver-assessment will be set based on parameter
31510 * drv_assess.
31511 */
31512 scsi_fm_ereport_post(un->un_sd, uscsi_path_instance,
31513 NULL,
31514 "cmd.disk.dev.serr", uscsi_ena,
31515 devid, NULL, DDI_NOSLEEP, NULL,
31516 FM_VERSION, DATA_TYPE_UINT8, FM_EREPORT_VERS0,
31517 DEVID_IF_KNOWN(devid),
31518 "driver-assessment", DATA_TYPE_STRING,
31519 drv_assess == SD_FM_DRV_FATAL ? "fail" : assessment,
31520 "op-code", DATA_TYPE_UINT8, op_code,
31521 "cdb",
31522 DATA_TYPE_UINT8_ARRAY,
31523 cdblen, ssc->ssc_uscsi_cmd->uscsi_cdb,
31524 "pkt-reason",
31525 DATA_TYPE_UINT8, uscsi_pkt_reason,
31526 "pkt-state",
31527 DATA_TYPE_UINT8, uscsi_pkt_state,
31528 "pkt-stats",
31529 DATA_TYPE_UINT32, uscsi_pkt_statistics,
31530 "stat-code",
31531 DATA_TYPE_UINT8,
31532 ssc->ssc_uscsi_cmd->uscsi_status,
31533 NULL);
31534 }
31535 }
31536 }
31537
31538 /*
31539 * Function: sd_ssc_extract_info
31540 *
31541 * Description: Extract information available to help generate ereport.
31542 *
31543 * Context: Kernel thread or interrupt context.
31544 */
31545 static void
31546 sd_ssc_extract_info(sd_ssc_t *ssc, struct sd_lun *un, struct scsi_pkt *pktp,
31547 struct buf *bp, struct sd_xbuf *xp)
31548 {
31549 size_t senlen = 0;
31550 union scsi_cdb *cdbp;
31551 int path_instance;
31552 /*
31553 * Need scsi_cdb_size array to determine the cdb length.
31554 */
31555 extern uchar_t scsi_cdb_size[];
31556
31557 ASSERT(un != NULL);
31558 ASSERT(pktp != NULL);
31559 ASSERT(bp != NULL);
31560 ASSERT(xp != NULL);
31561 ASSERT(ssc != NULL);
31562 ASSERT(mutex_owned(SD_MUTEX(un)));
31563
31564 /*
31565 * Transfer the cdb buffer pointer here.
31566 */
31567 cdbp = (union scsi_cdb *)pktp->pkt_cdbp;
31568
31569 ssc->ssc_uscsi_cmd->uscsi_cdblen = scsi_cdb_size[GETGROUP(cdbp)];
31570 ssc->ssc_uscsi_cmd->uscsi_cdb = (caddr_t)cdbp;
31571
31572 /*
31573 * Transfer the sense data buffer pointer if sense data is available,
31574 * calculate the sense data length first.
31575 */
31576 if ((xp->xb_sense_state & STATE_XARQ_DONE) ||
31577 (xp->xb_sense_state & STATE_ARQ_DONE)) {
31578 /*
31579 * For arq case, we will enter here.
31580 */
31581 if (xp->xb_sense_state & STATE_XARQ_DONE) {
31582 senlen = MAX_SENSE_LENGTH - xp->xb_sense_resid;
31583 } else {
31584 senlen = SENSE_LENGTH;
31585 }
31586 } else {
31587 /*
31588 * For non-arq case, we will enter this branch.
31589 */
31590 if (SD_GET_PKT_STATUS(pktp) == STATUS_CHECK &&
31591 (xp->xb_sense_state & STATE_XFERRED_DATA)) {
31592 senlen = SENSE_LENGTH - xp->xb_sense_resid;
31593 }
31594
31595 }
31596
31597 ssc->ssc_uscsi_cmd->uscsi_rqlen = (senlen & 0xff);
31598 ssc->ssc_uscsi_cmd->uscsi_rqresid = 0;
31599 ssc->ssc_uscsi_cmd->uscsi_rqbuf = (caddr_t)xp->xb_sense_data;
31600
31601 ssc->ssc_uscsi_cmd->uscsi_status = ((*(pktp)->pkt_scbp) & STATUS_MASK);
31602
31603 /*
31604 * Only transfer path_instance when scsi_pkt was properly allocated.
31605 */
31606 path_instance = pktp->pkt_path_instance;
31607 if (scsi_pkt_allocated_correctly(pktp) && path_instance)
31608 ssc->ssc_uscsi_cmd->uscsi_path_instance = path_instance;
31609 else
31610 ssc->ssc_uscsi_cmd->uscsi_path_instance = 0;
31611
31612 /*
31613 * Copy in the other fields we may need when posting ereport.
31614 */
31615 ssc->ssc_uscsi_info->ui_pkt_reason = pktp->pkt_reason;
31616 ssc->ssc_uscsi_info->ui_pkt_state = pktp->pkt_state;
31617 ssc->ssc_uscsi_info->ui_pkt_statistics = pktp->pkt_statistics;
31618 ssc->ssc_uscsi_info->ui_lba = (uint64_t)SD_GET_BLKNO(bp);
31619
31620 /*
31621 * For partially read/write command, we will not create ena
31622 * in case of a successful command be reconized as recovered.
31623 */
31624 if ((pktp->pkt_reason == CMD_CMPLT) &&
31625 (ssc->ssc_uscsi_cmd->uscsi_status == STATUS_GOOD) &&
31626 (senlen == 0)) {
31627 return;
31628 }
31629
31630 /*
31631 * To associate ereports of a single command execution flow, we
31632 * need a shared ena for a specific command.
31633 */
31634 if (xp->xb_ena == 0)
31635 xp->xb_ena = fm_ena_generate(0, FM_ENA_FMT1);
31636 ssc->ssc_uscsi_info->ui_ena = xp->xb_ena;
31637 }
31638
31639
31640 /*
31641 * Function: sd_check_bdc_vpd
31642 *
31643 * Description: Query the optional INQUIRY VPD page 0xb1. If the device
31644 * supports VPD page 0xb1, sd examines the MEDIUM ROTATION
31645 * RATE.
31646 *
31647 * Set the following based on RPM value:
31648 * = 0 device is not solid state, non-rotational
31649 * = 1 device is solid state, non-rotational
31650 * > 1 device is not solid state, rotational
31651 *
31652 * Context: Kernel thread or interrupt context.
31653 */
31654
31655 static void
31656 sd_check_bdc_vpd(sd_ssc_t *ssc)
31657 {
31658 int rval = 0;
31659 uchar_t *inqb1 = NULL;
31660 size_t inqb1_len = MAX_INQUIRY_SIZE;
31661 size_t inqb1_resid = 0;
31662 struct sd_lun *un;
31663
31664 ASSERT(ssc != NULL);
31665 un = ssc->ssc_un;
31666 ASSERT(un != NULL);
31667 ASSERT(!mutex_owned(SD_MUTEX(un)));
31668
31669 mutex_enter(SD_MUTEX(un));
31670 un->un_f_is_rotational = TRUE;
31671 un->un_f_is_solid_state = FALSE;
31672
31673 if (ISCD(un)) {
31674 mutex_exit(SD_MUTEX(un));
31675 return;
31676 }
31677
31678 if (sd_check_vpd_page_support(ssc) == 0 &&
31679 un->un_vpd_page_mask & SD_VPD_DEV_CHARACTER_PG) {
31680 mutex_exit(SD_MUTEX(un));
31681 /* collect page b1 data */
31682 inqb1 = kmem_zalloc(inqb1_len, KM_SLEEP);
31683
31684 rval = sd_send_scsi_INQUIRY(ssc, inqb1, inqb1_len,
31685 0x01, 0xB1, &inqb1_resid);
31686
31687 if (rval == 0 && (inqb1_len - inqb1_resid > 5)) {
31688 SD_TRACE(SD_LOG_COMMON, un,
31689 "sd_check_bdc_vpd: \
31690 successfully get VPD page: %x \
31691 PAGE LENGTH: %x BYTE 4: %x \
31692 BYTE 5: %x", inqb1[1], inqb1[3], inqb1[4],
31693 inqb1[5]);
31694
31695 mutex_enter(SD_MUTEX(un));
31696 /*
31697 * Check the MEDIUM ROTATION RATE.
31698 */
31699 if (inqb1[4] == 0) {
31700 if (inqb1[5] == 0) {
31701 un->un_f_is_rotational = FALSE;
31702 } else if (inqb1[5] == 1) {
31703 un->un_f_is_rotational = FALSE;
31704 un->un_f_is_solid_state = TRUE;
31705 /*
31706 * Solid state drives don't need
31707 * disksort.
31708 */
31709 un->un_f_disksort_disabled = TRUE;
31710 }
31711 }
31712 mutex_exit(SD_MUTEX(un));
31713 } else if (rval != 0) {
31714 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
31715 }
31716
31717 kmem_free(inqb1, inqb1_len);
31718 } else {
31719 mutex_exit(SD_MUTEX(un));
31720 }
31721 }
31722
31723 /*
31724 * Function: sd_check_emulation_mode
31725 *
31726 * Description: Check whether the SSD is at emulation mode
31727 * by issuing READ_CAPACITY_16 to see whether
31728 * we can get physical block size of the drive.
31729 *
31730 * Context: Kernel thread or interrupt context.
31731 */
31732
31733 static void
31734 sd_check_emulation_mode(sd_ssc_t *ssc)
31735 {
31736 int rval = 0;
31737 uint64_t capacity;
31738 uint_t lbasize;
31739 uint_t pbsize;
31740 int i;
31741 int devid_len;
31742 struct sd_lun *un;
31743
31744 ASSERT(ssc != NULL);
31745 un = ssc->ssc_un;
31746 ASSERT(un != NULL);
31747 ASSERT(!mutex_owned(SD_MUTEX(un)));
31748
31749 mutex_enter(SD_MUTEX(un));
31750 if (ISCD(un)) {
31751 mutex_exit(SD_MUTEX(un));
31752 return;
31753 }
31754
31755 if (un->un_f_descr_format_supported) {
31756 mutex_exit(SD_MUTEX(un));
31757 rval = sd_send_scsi_READ_CAPACITY_16(ssc, &capacity, &lbasize,
31758 &pbsize, SD_PATH_DIRECT);
31759 mutex_enter(SD_MUTEX(un));
31760
31761 if (rval != 0) {
31762 un->un_phy_blocksize = DEV_BSIZE;
31763 } else {
31764 if (!ISP2(pbsize % DEV_BSIZE) || pbsize == 0) {
31765 un->un_phy_blocksize = DEV_BSIZE;
31766 } else if (pbsize > un->un_phy_blocksize) {
31767 /*
31768 * Don't reset the physical blocksize
31769 * unless we've detected a larger value.
31770 */
31771 un->un_phy_blocksize = pbsize;
31772 }
31773 }
31774 }
31775
31776 for (i = 0; i < sd_flash_dev_table_size; i++) {
31777 devid_len = (int)strlen(sd_flash_dev_table[i]);
31778 if (sd_sdconf_id_match(un, sd_flash_dev_table[i], devid_len)
31779 == SD_SUCCESS) {
31780 un->un_phy_blocksize = SSD_SECSIZE;
31781 if (un->un_f_is_solid_state &&
31782 un->un_phy_blocksize != un->un_tgt_blocksize)
31783 un->un_f_enable_rmw = TRUE;
31784 }
31785 }
31786
31787 mutex_exit(SD_MUTEX(un));
31788 }