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 by Delphix. All rights reserved.
28 * Copyright 2014 Nexenta Systems, Inc. All rights reserved.
29 * Copyright 2012 DEY Storage Systems, Inc. All rights reserved.
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_solid_state ssd_check_solid_state
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_nv_sup ssd_get_nv_sup
932 #define sd_make_device ssd_make_device
933 #define sdopen ssdopen
934 #define sdclose ssdclose
935 #define sd_ready_and_valid ssd_ready_and_valid
936 #define sdmin ssdmin
937 #define sdread ssdread
938 #define sdwrite ssdwrite
939 #define sdaread ssdaread
940 #define sdawrite ssdawrite
941 #define sdstrategy ssdstrategy
942 #define sdioctl ssdioctl
943 #define sd_mapblockaddr_iostart ssd_mapblockaddr_iostart
944 #define sd_mapblocksize_iostart ssd_mapblocksize_iostart
945 #define sd_checksum_iostart ssd_checksum_iostart
946 #define sd_checksum_uscsi_iostart ssd_checksum_uscsi_iostart
947 #define sd_pm_iostart ssd_pm_iostart
948 #define sd_core_iostart ssd_core_iostart
949 #define sd_mapblockaddr_iodone ssd_mapblockaddr_iodone
950 #define sd_mapblocksize_iodone ssd_mapblocksize_iodone
951 #define sd_checksum_iodone ssd_checksum_iodone
952 #define sd_checksum_uscsi_iodone ssd_checksum_uscsi_iodone
953 #define sd_pm_iodone ssd_pm_iodone
954 #define sd_initpkt_for_buf ssd_initpkt_for_buf
955 #define sd_destroypkt_for_buf ssd_destroypkt_for_buf
956 #define sd_setup_rw_pkt ssd_setup_rw_pkt
957 #define sd_setup_next_rw_pkt ssd_setup_next_rw_pkt
958 #define sd_buf_iodone ssd_buf_iodone
959 #define sd_uscsi_strategy ssd_uscsi_strategy
960 #define sd_initpkt_for_uscsi ssd_initpkt_for_uscsi
961 #define sd_destroypkt_for_uscsi ssd_destroypkt_for_uscsi
962 #define sd_uscsi_iodone ssd_uscsi_iodone
963 #define sd_xbuf_strategy ssd_xbuf_strategy
964 #define sd_xbuf_init ssd_xbuf_init
965 #define sd_pm_entry ssd_pm_entry
966 #define sd_pm_exit ssd_pm_exit
967
968 #define sd_pm_idletimeout_handler ssd_pm_idletimeout_handler
969 #define sd_pm_timeout_handler ssd_pm_timeout_handler
970
971 #define sd_add_buf_to_waitq ssd_add_buf_to_waitq
972 #define sdintr ssdintr
973 #define sd_start_cmds ssd_start_cmds
974 #define sd_send_scsi_cmd ssd_send_scsi_cmd
975 #define sd_bioclone_alloc ssd_bioclone_alloc
976 #define sd_bioclone_free ssd_bioclone_free
977 #define sd_shadow_buf_alloc ssd_shadow_buf_alloc
978 #define sd_shadow_buf_free ssd_shadow_buf_free
979 #define sd_print_transport_rejected_message \
980 ssd_print_transport_rejected_message
981 #define sd_retry_command ssd_retry_command
982 #define sd_set_retry_bp ssd_set_retry_bp
983 #define sd_send_request_sense_command ssd_send_request_sense_command
984 #define sd_start_retry_command ssd_start_retry_command
985 #define sd_start_direct_priority_command \
986 ssd_start_direct_priority_command
987 #define sd_return_failed_command ssd_return_failed_command
988 #define sd_return_failed_command_no_restart \
989 ssd_return_failed_command_no_restart
990 #define sd_return_command ssd_return_command
991 #define sd_sync_with_callback ssd_sync_with_callback
992 #define sdrunout ssdrunout
993 #define sd_mark_rqs_busy ssd_mark_rqs_busy
994 #define sd_mark_rqs_idle ssd_mark_rqs_idle
995 #define sd_reduce_throttle ssd_reduce_throttle
996 #define sd_restore_throttle ssd_restore_throttle
997 #define sd_print_incomplete_msg ssd_print_incomplete_msg
998 #define sd_init_cdb_limits ssd_init_cdb_limits
999 #define sd_pkt_status_good ssd_pkt_status_good
1000 #define sd_pkt_status_check_condition ssd_pkt_status_check_condition
1001 #define sd_pkt_status_busy ssd_pkt_status_busy
1002 #define sd_pkt_status_reservation_conflict \
1003 ssd_pkt_status_reservation_conflict
1004 #define sd_pkt_status_qfull ssd_pkt_status_qfull
1005 #define sd_handle_request_sense ssd_handle_request_sense
1006 #define sd_handle_auto_request_sense ssd_handle_auto_request_sense
1007 #define sd_print_sense_failed_msg ssd_print_sense_failed_msg
1008 #define sd_validate_sense_data ssd_validate_sense_data
1009 #define sd_decode_sense ssd_decode_sense
1010 #define sd_print_sense_msg ssd_print_sense_msg
1011 #define sd_sense_key_no_sense ssd_sense_key_no_sense
1012 #define sd_sense_key_recoverable_error ssd_sense_key_recoverable_error
1013 #define sd_sense_key_not_ready ssd_sense_key_not_ready
1014 #define sd_sense_key_medium_or_hardware_error \
1015 ssd_sense_key_medium_or_hardware_error
1016 #define sd_sense_key_illegal_request ssd_sense_key_illegal_request
1017 #define sd_sense_key_unit_attention ssd_sense_key_unit_attention
1018 #define sd_sense_key_fail_command ssd_sense_key_fail_command
1019 #define sd_sense_key_blank_check ssd_sense_key_blank_check
1020 #define sd_sense_key_aborted_command ssd_sense_key_aborted_command
1021 #define sd_sense_key_default ssd_sense_key_default
1022 #define sd_print_retry_msg ssd_print_retry_msg
1023 #define sd_print_cmd_incomplete_msg ssd_print_cmd_incomplete_msg
1024 #define sd_pkt_reason_cmd_incomplete ssd_pkt_reason_cmd_incomplete
1025 #define sd_pkt_reason_cmd_tran_err ssd_pkt_reason_cmd_tran_err
1026 #define sd_pkt_reason_cmd_reset ssd_pkt_reason_cmd_reset
1027 #define sd_pkt_reason_cmd_aborted ssd_pkt_reason_cmd_aborted
1028 #define sd_pkt_reason_cmd_timeout ssd_pkt_reason_cmd_timeout
1029 #define sd_pkt_reason_cmd_unx_bus_free ssd_pkt_reason_cmd_unx_bus_free
1030 #define sd_pkt_reason_cmd_tag_reject ssd_pkt_reason_cmd_tag_reject
1031 #define sd_pkt_reason_default ssd_pkt_reason_default
1032 #define sd_reset_target ssd_reset_target
1033 #define sd_start_stop_unit_callback ssd_start_stop_unit_callback
1034 #define sd_start_stop_unit_task ssd_start_stop_unit_task
1035 #define sd_taskq_create ssd_taskq_create
1036 #define sd_taskq_delete ssd_taskq_delete
1037 #define sd_target_change_task ssd_target_change_task
1038 #define sd_log_dev_status_event ssd_log_dev_status_event
1039 #define sd_log_lun_expansion_event ssd_log_lun_expansion_event
1040 #define sd_log_eject_request_event ssd_log_eject_request_event
1041 #define sd_media_change_task ssd_media_change_task
1042 #define sd_handle_mchange ssd_handle_mchange
1043 #define sd_send_scsi_DOORLOCK ssd_send_scsi_DOORLOCK
1044 #define sd_send_scsi_READ_CAPACITY ssd_send_scsi_READ_CAPACITY
1045 #define sd_send_scsi_READ_CAPACITY_16 ssd_send_scsi_READ_CAPACITY_16
1046 #define sd_send_scsi_GET_CONFIGURATION ssd_send_scsi_GET_CONFIGURATION
1047 #define sd_send_scsi_feature_GET_CONFIGURATION \
1048 sd_send_scsi_feature_GET_CONFIGURATION
1049 #define sd_send_scsi_START_STOP_UNIT ssd_send_scsi_START_STOP_UNIT
1050 #define sd_send_scsi_INQUIRY ssd_send_scsi_INQUIRY
1051 #define sd_send_scsi_TEST_UNIT_READY ssd_send_scsi_TEST_UNIT_READY
1052 #define sd_send_scsi_PERSISTENT_RESERVE_IN \
1053 ssd_send_scsi_PERSISTENT_RESERVE_IN
1054 #define sd_send_scsi_PERSISTENT_RESERVE_OUT \
1055 ssd_send_scsi_PERSISTENT_RESERVE_OUT
1056 #define sd_send_scsi_SYNCHRONIZE_CACHE ssd_send_scsi_SYNCHRONIZE_CACHE
1057 #define sd_send_scsi_SYNCHRONIZE_CACHE_biodone \
1058 ssd_send_scsi_SYNCHRONIZE_CACHE_biodone
1059 #define sd_send_scsi_MODE_SENSE ssd_send_scsi_MODE_SENSE
1060 #define sd_send_scsi_MODE_SELECT ssd_send_scsi_MODE_SELECT
1061 #define sd_send_scsi_RDWR ssd_send_scsi_RDWR
1062 #define sd_send_scsi_LOG_SENSE ssd_send_scsi_LOG_SENSE
1063 #define sd_send_scsi_GET_EVENT_STATUS_NOTIFICATION \
1064 ssd_send_scsi_GET_EVENT_STATUS_NOTIFICATION
1065 #define sd_gesn_media_data_valid ssd_gesn_media_data_valid
1066 #define sd_alloc_rqs ssd_alloc_rqs
1067 #define sd_free_rqs ssd_free_rqs
1068 #define sd_dump_memory ssd_dump_memory
1069 #define sd_get_media_info_com ssd_get_media_info_com
1070 #define sd_get_media_info ssd_get_media_info
1071 #define sd_get_media_info_ext ssd_get_media_info_ext
1072 #define sd_dkio_ctrl_info ssd_dkio_ctrl_info
1073 #define sd_nvpair_str_decode ssd_nvpair_str_decode
1074 #define sd_strtok_r ssd_strtok_r
1075 #define sd_set_properties ssd_set_properties
1076 #define sd_get_tunables_from_conf ssd_get_tunables_from_conf
1077 #define sd_setup_next_xfer ssd_setup_next_xfer
1078 #define sd_dkio_get_temp ssd_dkio_get_temp
1079 #define sd_check_mhd ssd_check_mhd
1080 #define sd_mhd_watch_cb ssd_mhd_watch_cb
1081 #define sd_mhd_watch_incomplete ssd_mhd_watch_incomplete
1082 #define sd_sname ssd_sname
1083 #define sd_mhd_resvd_recover ssd_mhd_resvd_recover
1084 #define sd_resv_reclaim_thread ssd_resv_reclaim_thread
1085 #define sd_take_ownership ssd_take_ownership
1086 #define sd_reserve_release ssd_reserve_release
1087 #define sd_rmv_resv_reclaim_req ssd_rmv_resv_reclaim_req
1088 #define sd_mhd_reset_notify_cb ssd_mhd_reset_notify_cb
1089 #define sd_persistent_reservation_in_read_keys \
1090 ssd_persistent_reservation_in_read_keys
1091 #define sd_persistent_reservation_in_read_resv \
1092 ssd_persistent_reservation_in_read_resv
1093 #define sd_mhdioc_takeown ssd_mhdioc_takeown
1094 #define sd_mhdioc_failfast ssd_mhdioc_failfast
1095 #define sd_mhdioc_release ssd_mhdioc_release
1096 #define sd_mhdioc_register_devid ssd_mhdioc_register_devid
1097 #define sd_mhdioc_inkeys ssd_mhdioc_inkeys
1098 #define sd_mhdioc_inresv ssd_mhdioc_inresv
1099 #define sr_change_blkmode ssr_change_blkmode
1100 #define sr_change_speed ssr_change_speed
1101 #define sr_atapi_change_speed ssr_atapi_change_speed
1102 #define sr_pause_resume ssr_pause_resume
1103 #define sr_play_msf ssr_play_msf
1104 #define sr_play_trkind ssr_play_trkind
1105 #define sr_read_all_subcodes ssr_read_all_subcodes
1106 #define sr_read_subchannel ssr_read_subchannel
1107 #define sr_read_tocentry ssr_read_tocentry
1108 #define sr_read_tochdr ssr_read_tochdr
1109 #define sr_read_cdda ssr_read_cdda
1110 #define sr_read_cdxa ssr_read_cdxa
1111 #define sr_read_mode1 ssr_read_mode1
1112 #define sr_read_mode2 ssr_read_mode2
1113 #define sr_read_cd_mode2 ssr_read_cd_mode2
1114 #define sr_sector_mode ssr_sector_mode
1115 #define sr_eject ssr_eject
1116 #define sr_ejected ssr_ejected
1117 #define sr_check_wp ssr_check_wp
1118 #define sd_watch_request_submit ssd_watch_request_submit
1119 #define sd_check_media ssd_check_media
1120 #define sd_media_watch_cb ssd_media_watch_cb
1121 #define sd_delayed_cv_broadcast ssd_delayed_cv_broadcast
1122 #define sr_volume_ctrl ssr_volume_ctrl
1123 #define sr_read_sony_session_offset ssr_read_sony_session_offset
1124 #define sd_log_page_supported ssd_log_page_supported
1125 #define sd_check_for_writable_cd ssd_check_for_writable_cd
1126 #define sd_wm_cache_constructor ssd_wm_cache_constructor
1127 #define sd_wm_cache_destructor ssd_wm_cache_destructor
1128 #define sd_range_lock ssd_range_lock
1129 #define sd_get_range ssd_get_range
1130 #define sd_free_inlist_wmap ssd_free_inlist_wmap
1131 #define sd_range_unlock ssd_range_unlock
1132 #define sd_read_modify_write_task ssd_read_modify_write_task
1133 #define sddump_do_read_of_rmw ssddump_do_read_of_rmw
1134
1135 #define sd_iostart_chain ssd_iostart_chain
1136 #define sd_iodone_chain ssd_iodone_chain
1137 #define sd_initpkt_map ssd_initpkt_map
1138 #define sd_destroypkt_map ssd_destroypkt_map
1139 #define sd_chain_type_map ssd_chain_type_map
1140 #define sd_chain_index_map ssd_chain_index_map
1141
1142 #define sd_failfast_flushctl ssd_failfast_flushctl
1143 #define sd_failfast_flushq ssd_failfast_flushq
1144 #define sd_failfast_flushq_callback ssd_failfast_flushq_callback
1145
1146 #define sd_is_lsi ssd_is_lsi
1147 #define sd_tg_rdwr ssd_tg_rdwr
1148 #define sd_tg_getinfo ssd_tg_getinfo
1149 #define sd_rmw_msg_print_handler ssd_rmw_msg_print_handler
1150
1151 #endif /* #if (defined(__fibre)) */
1152
1153
1154 int _init(void);
1155 int _fini(void);
1156 int _info(struct modinfo *modinfop);
1157
1158 /*PRINTFLIKE3*/
1159 static void sd_log_trace(uint_t comp, struct sd_lun *un, const char *fmt, ...);
1160 /*PRINTFLIKE3*/
1161 static void sd_log_info(uint_t comp, struct sd_lun *un, const char *fmt, ...);
1162 /*PRINTFLIKE3*/
1163 static void sd_log_err(uint_t comp, struct sd_lun *un, const char *fmt, ...);
1164
1165 static int sdprobe(dev_info_t *devi);
1166 static int sdinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg,
1167 void **result);
1168 static int sd_prop_op(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op,
1169 int mod_flags, char *name, caddr_t valuep, int *lengthp);
1170
1171 /*
1172 * Smart probe for parallel scsi
1173 */
1174 static void sd_scsi_probe_cache_init(void);
1175 static void sd_scsi_probe_cache_fini(void);
1176 static void sd_scsi_clear_probe_cache(void);
1177 static int sd_scsi_probe_with_cache(struct scsi_device *devp, int (*fn)());
1178
1179 /*
1180 * Attached luns on target for parallel scsi
1181 */
1182 static void sd_scsi_target_lun_init(void);
1183 static void sd_scsi_target_lun_fini(void);
1184 static int sd_scsi_get_target_lun_count(dev_info_t *dip, int target);
1185 static void sd_scsi_update_lun_on_target(dev_info_t *dip, int target, int flag);
1186
1187 static int sd_spin_up_unit(sd_ssc_t *ssc);
1188
1189 /*
1190 * Using sd_ssc_init to establish sd_ssc_t struct
1191 * Using sd_ssc_send to send uscsi internal command
1192 * Using sd_ssc_fini to free sd_ssc_t struct
1193 */
1194 static sd_ssc_t *sd_ssc_init(struct sd_lun *un);
1195 static int sd_ssc_send(sd_ssc_t *ssc, struct uscsi_cmd *incmd,
1196 int flag, enum uio_seg dataspace, int path_flag);
1197 static void sd_ssc_fini(sd_ssc_t *ssc);
1198
1199 /*
1200 * Using sd_ssc_assessment to set correct type-of-assessment
1201 * Using sd_ssc_post to post ereport & system log
1202 * sd_ssc_post will call sd_ssc_print to print system log
1203 * sd_ssc_post will call sd_ssd_ereport_post to post ereport
1204 */
1205 static void sd_ssc_assessment(sd_ssc_t *ssc,
1206 enum sd_type_assessment tp_assess);
1207
1208 static void sd_ssc_post(sd_ssc_t *ssc, enum sd_driver_assessment sd_assess);
1209 static void sd_ssc_print(sd_ssc_t *ssc, int sd_severity);
1210 static void sd_ssc_ereport_post(sd_ssc_t *ssc,
1211 enum sd_driver_assessment drv_assess);
1212
1213 /*
1214 * Using sd_ssc_set_info to mark an un-decodable-data error.
1215 * Using sd_ssc_extract_info to transfer information from internal
1216 * data structures to sd_ssc_t.
1217 */
1218 static void sd_ssc_set_info(sd_ssc_t *ssc, int ssc_flags, uint_t comp,
1219 const char *fmt, ...);
1220 static void sd_ssc_extract_info(sd_ssc_t *ssc, struct sd_lun *un,
1221 struct scsi_pkt *pktp, struct buf *bp, struct sd_xbuf *xp);
1222
1223 static int sd_send_scsi_cmd(dev_t dev, struct uscsi_cmd *incmd, int flag,
1224 enum uio_seg dataspace, int path_flag);
1225
1226 #ifdef _LP64
1227 static void sd_enable_descr_sense(sd_ssc_t *ssc);
1228 static void sd_reenable_dsense_task(void *arg);
1229 #endif /* _LP64 */
1230
1231 static void sd_set_mmc_caps(sd_ssc_t *ssc);
1232
1233 static void sd_read_unit_properties(struct sd_lun *un);
1234 static int sd_process_sdconf_file(struct sd_lun *un);
1235 static void sd_nvpair_str_decode(struct sd_lun *un, char *nvpair_str);
1236 static char *sd_strtok_r(char *string, const char *sepset, char **lasts);
1237 static void sd_set_properties(struct sd_lun *un, char *name, char *value);
1238 static void sd_get_tunables_from_conf(struct sd_lun *un, int flags,
1239 int *data_list, sd_tunables *values);
1240 static void sd_process_sdconf_table(struct sd_lun *un);
1241 static int sd_sdconf_id_match(struct sd_lun *un, char *id, int idlen);
1242 static int sd_blank_cmp(struct sd_lun *un, char *id, int idlen);
1243 static int sd_chk_vers1_data(struct sd_lun *un, int flags, int *prop_list,
1244 int list_len, char *dataname_ptr);
1245 static void sd_set_vers1_properties(struct sd_lun *un, int flags,
1246 sd_tunables *prop_list);
1247
1248 static void sd_register_devid(sd_ssc_t *ssc, dev_info_t *devi,
1249 int reservation_flag);
1250 static int sd_get_devid(sd_ssc_t *ssc);
1251 static ddi_devid_t sd_create_devid(sd_ssc_t *ssc);
1252 static int sd_write_deviceid(sd_ssc_t *ssc);
1253 static int sd_get_devid_page(struct sd_lun *un, uchar_t *wwn, int *len);
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_nv_sup(sd_ssc_t *ssc);
1298 static dev_t sd_make_device(dev_info_t *devi);
1299 static void sd_check_solid_state(sd_ssc_t *ssc);
1300 static void sd_check_emulation_mode(sd_ssc_t *ssc);
1301 static void sd_update_block_info(struct sd_lun *un, uint32_t lbasize,
1302 uint64_t capacity);
1303
1304 /*
1305 * Driver entry point functions.
1306 */
1307 static int sdopen(dev_t *dev_p, int flag, int otyp, cred_t *cred_p);
1308 static int sdclose(dev_t dev, int flag, int otyp, cred_t *cred_p);
1309 static int sd_ready_and_valid(sd_ssc_t *ssc, int part);
1310
1311 static void sdmin(struct buf *bp);
1312 static int sdread(dev_t dev, struct uio *uio, cred_t *cred_p);
1313 static int sdwrite(dev_t dev, struct uio *uio, cred_t *cred_p);
1314 static int sdaread(dev_t dev, struct aio_req *aio, cred_t *cred_p);
1315 static int sdawrite(dev_t dev, struct aio_req *aio, cred_t *cred_p);
1316
1317 static int sdstrategy(struct buf *bp);
1318 static int sdioctl(dev_t, int, intptr_t, int, cred_t *, int *);
1319
1320 /*
1321 * Function prototypes for layering functions in the iostart chain.
1322 */
1323 static void sd_mapblockaddr_iostart(int index, struct sd_lun *un,
1324 struct buf *bp);
1325 static void sd_mapblocksize_iostart(int index, struct sd_lun *un,
1326 struct buf *bp);
1327 static void sd_checksum_iostart(int index, struct sd_lun *un, struct buf *bp);
1328 static void sd_checksum_uscsi_iostart(int index, struct sd_lun *un,
1329 struct buf *bp);
1330 static void sd_pm_iostart(int index, struct sd_lun *un, struct buf *bp);
1331 static void sd_core_iostart(int index, struct sd_lun *un, struct buf *bp);
1332
1333 /*
1334 * Function prototypes for layering functions in the iodone chain.
1335 */
1336 static void sd_buf_iodone(int index, struct sd_lun *un, struct buf *bp);
1337 static void sd_uscsi_iodone(int index, struct sd_lun *un, struct buf *bp);
1338 static void sd_mapblockaddr_iodone(int index, struct sd_lun *un,
1339 struct buf *bp);
1340 static void sd_mapblocksize_iodone(int index, struct sd_lun *un,
1341 struct buf *bp);
1342 static void sd_checksum_iodone(int index, struct sd_lun *un, struct buf *bp);
1343 static void sd_checksum_uscsi_iodone(int index, struct sd_lun *un,
1344 struct buf *bp);
1345 static void sd_pm_iodone(int index, struct sd_lun *un, struct buf *bp);
1346
1347 /*
1348 * Prototypes for functions to support buf(9S) based IO.
1349 */
1350 static void sd_xbuf_strategy(struct buf *bp, ddi_xbuf_t xp, void *arg);
1351 static int sd_initpkt_for_buf(struct buf *, struct scsi_pkt **);
1352 static void sd_destroypkt_for_buf(struct buf *);
1353 static int sd_setup_rw_pkt(struct sd_lun *un, struct scsi_pkt **pktpp,
1354 struct buf *bp, int flags,
1355 int (*callback)(caddr_t), caddr_t callback_arg,
1356 diskaddr_t lba, uint32_t blockcount);
1357 static int sd_setup_next_rw_pkt(struct sd_lun *un, struct scsi_pkt *pktp,
1358 struct buf *bp, diskaddr_t lba, uint32_t blockcount);
1359
1360 /*
1361 * Prototypes for functions to support USCSI IO.
1362 */
1363 static int sd_uscsi_strategy(struct buf *bp);
1364 static int sd_initpkt_for_uscsi(struct buf *, struct scsi_pkt **);
1365 static void sd_destroypkt_for_uscsi(struct buf *);
1366
1367 static void sd_xbuf_init(struct sd_lun *un, struct buf *bp, struct sd_xbuf *xp,
1368 uchar_t chain_type, void *pktinfop);
1369
1370 static int sd_pm_entry(struct sd_lun *un);
1371 static void sd_pm_exit(struct sd_lun *un);
1372
1373 static void sd_pm_idletimeout_handler(void *arg);
1374
1375 /*
1376 * sd_core internal functions (used at the sd_core_io layer).
1377 */
1378 static void sd_add_buf_to_waitq(struct sd_lun *un, struct buf *bp);
1379 static void sdintr(struct scsi_pkt *pktp);
1380 static void sd_start_cmds(struct sd_lun *un, struct buf *immed_bp);
1381
1382 static int sd_send_scsi_cmd(dev_t dev, struct uscsi_cmd *incmd, int flag,
1383 enum uio_seg dataspace, int path_flag);
1384
1385 static struct buf *sd_bioclone_alloc(struct buf *bp, size_t datalen,
1386 daddr_t blkno, int (*func)(struct buf *));
1387 static struct buf *sd_shadow_buf_alloc(struct buf *bp, size_t datalen,
1388 uint_t bflags, daddr_t blkno, int (*func)(struct buf *));
1389 static void sd_bioclone_free(struct buf *bp);
1390 static void sd_shadow_buf_free(struct buf *bp);
1391
1392 static void sd_print_transport_rejected_message(struct sd_lun *un,
1393 struct sd_xbuf *xp, int code);
1394 static void sd_print_incomplete_msg(struct sd_lun *un, struct buf *bp,
1395 void *arg, int code);
1396 static void sd_print_sense_failed_msg(struct sd_lun *un, struct buf *bp,
1397 void *arg, int code);
1398 static void sd_print_cmd_incomplete_msg(struct sd_lun *un, struct buf *bp,
1399 void *arg, int code);
1400
1401 static void sd_retry_command(struct sd_lun *un, struct buf *bp,
1402 int retry_check_flag,
1403 void (*user_funcp)(struct sd_lun *un, struct buf *bp, void *argp,
1404 int c),
1405 void *user_arg, int failure_code, clock_t retry_delay,
1406 void (*statp)(kstat_io_t *));
1407
1408 static void sd_set_retry_bp(struct sd_lun *un, struct buf *bp,
1409 clock_t retry_delay, void (*statp)(kstat_io_t *));
1410
1411 static void sd_send_request_sense_command(struct sd_lun *un, struct buf *bp,
1412 struct scsi_pkt *pktp);
1413 static void sd_start_retry_command(void *arg);
1414 static void sd_start_direct_priority_command(void *arg);
1415 static void sd_return_failed_command(struct sd_lun *un, struct buf *bp,
1416 int errcode);
1417 static void sd_return_failed_command_no_restart(struct sd_lun *un,
1418 struct buf *bp, int errcode);
1419 static void sd_return_command(struct sd_lun *un, struct buf *bp);
1420 static void sd_sync_with_callback(struct sd_lun *un);
1421 static int sdrunout(caddr_t arg);
1422
1423 static void sd_mark_rqs_busy(struct sd_lun *un, struct buf *bp);
1424 static struct buf *sd_mark_rqs_idle(struct sd_lun *un, struct sd_xbuf *xp);
1425
1426 static void sd_reduce_throttle(struct sd_lun *un, int throttle_type);
1427 static void sd_restore_throttle(void *arg);
1428
1429 static void sd_init_cdb_limits(struct sd_lun *un);
1430
1431 static void sd_pkt_status_good(struct sd_lun *un, struct buf *bp,
1432 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1433
1434 /*
1435 * Error handling functions
1436 */
1437 static void sd_pkt_status_check_condition(struct sd_lun *un, struct buf *bp,
1438 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1439 static void sd_pkt_status_busy(struct sd_lun *un, struct buf *bp,
1440 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1441 static void sd_pkt_status_reservation_conflict(struct sd_lun *un,
1442 struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp);
1443 static void sd_pkt_status_qfull(struct sd_lun *un, struct buf *bp,
1444 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1445
1446 static void sd_handle_request_sense(struct sd_lun *un, struct buf *bp,
1447 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1448 static void sd_handle_auto_request_sense(struct sd_lun *un, struct buf *bp,
1449 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1450 static int sd_validate_sense_data(struct sd_lun *un, struct buf *bp,
1451 struct sd_xbuf *xp, size_t actual_len);
1452 static void sd_decode_sense(struct sd_lun *un, struct buf *bp,
1453 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1454
1455 static void sd_print_sense_msg(struct sd_lun *un, struct buf *bp,
1456 void *arg, int code);
1457
1458 static void sd_sense_key_no_sense(struct sd_lun *un, struct buf *bp,
1459 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1460 static void sd_sense_key_recoverable_error(struct sd_lun *un,
1461 uint8_t *sense_datap,
1462 struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp);
1463 static void sd_sense_key_not_ready(struct sd_lun *un,
1464 uint8_t *sense_datap,
1465 struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp);
1466 static void sd_sense_key_medium_or_hardware_error(struct sd_lun *un,
1467 uint8_t *sense_datap,
1468 struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp);
1469 static void sd_sense_key_illegal_request(struct sd_lun *un, struct buf *bp,
1470 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1471 static void sd_sense_key_unit_attention(struct sd_lun *un,
1472 uint8_t *sense_datap,
1473 struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp);
1474 static void sd_sense_key_fail_command(struct sd_lun *un, struct buf *bp,
1475 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1476 static void sd_sense_key_blank_check(struct sd_lun *un, struct buf *bp,
1477 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1478 static void sd_sense_key_aborted_command(struct sd_lun *un, struct buf *bp,
1479 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1480 static void sd_sense_key_default(struct sd_lun *un,
1481 uint8_t *sense_datap,
1482 struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp);
1483
1484 static void sd_print_retry_msg(struct sd_lun *un, struct buf *bp,
1485 void *arg, int flag);
1486
1487 static void sd_pkt_reason_cmd_incomplete(struct sd_lun *un, struct buf *bp,
1488 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1489 static void sd_pkt_reason_cmd_tran_err(struct sd_lun *un, struct buf *bp,
1490 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1491 static void sd_pkt_reason_cmd_reset(struct sd_lun *un, struct buf *bp,
1492 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1493 static void sd_pkt_reason_cmd_aborted(struct sd_lun *un, struct buf *bp,
1494 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1495 static void sd_pkt_reason_cmd_timeout(struct sd_lun *un, struct buf *bp,
1496 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1497 static void sd_pkt_reason_cmd_unx_bus_free(struct sd_lun *un, struct buf *bp,
1498 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1499 static void sd_pkt_reason_cmd_tag_reject(struct sd_lun *un, struct buf *bp,
1500 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1501 static void sd_pkt_reason_default(struct sd_lun *un, struct buf *bp,
1502 struct sd_xbuf *xp, struct scsi_pkt *pktp);
1503
1504 static void sd_reset_target(struct sd_lun *un, struct scsi_pkt *pktp);
1505
1506 static void sd_start_stop_unit_callback(void *arg);
1507 static void sd_start_stop_unit_task(void *arg);
1508
1509 static void sd_taskq_create(void);
1510 static void sd_taskq_delete(void);
1511 static void sd_target_change_task(void *arg);
1512 static void sd_log_dev_status_event(struct sd_lun *un, char *esc, int km_flag);
1513 static void sd_log_lun_expansion_event(struct sd_lun *un, int km_flag);
1514 static void sd_log_eject_request_event(struct sd_lun *un, int km_flag);
1515 static void sd_media_change_task(void *arg);
1516
1517 static int sd_handle_mchange(struct sd_lun *un);
1518 static int sd_send_scsi_DOORLOCK(sd_ssc_t *ssc, int flag, int path_flag);
1519 static int sd_send_scsi_READ_CAPACITY(sd_ssc_t *ssc, uint64_t *capp,
1520 uint32_t *lbap, int path_flag);
1521 static int sd_send_scsi_READ_CAPACITY_16(sd_ssc_t *ssc, uint64_t *capp,
1522 uint32_t *lbap, uint32_t *psp, int path_flag);
1523 static int sd_send_scsi_START_STOP_UNIT(sd_ssc_t *ssc, int pc_flag,
1524 int flag, int path_flag);
1525 static int sd_send_scsi_INQUIRY(sd_ssc_t *ssc, uchar_t *bufaddr,
1526 size_t buflen, uchar_t evpd, uchar_t page_code, size_t *residp);
1527 static int sd_send_scsi_TEST_UNIT_READY(sd_ssc_t *ssc, int flag);
1528 static int sd_send_scsi_PERSISTENT_RESERVE_IN(sd_ssc_t *ssc,
1529 uchar_t usr_cmd, uint16_t data_len, uchar_t *data_bufp);
1530 static int sd_send_scsi_PERSISTENT_RESERVE_OUT(sd_ssc_t *ssc,
1531 uchar_t usr_cmd, uchar_t *usr_bufp);
1532 static int sd_send_scsi_SYNCHRONIZE_CACHE(struct sd_lun *un,
1533 struct dk_callback *dkc);
1534 static int sd_send_scsi_SYNCHRONIZE_CACHE_biodone(struct buf *bp);
1535 static int sd_send_scsi_GET_CONFIGURATION(sd_ssc_t *ssc,
1536 struct uscsi_cmd *ucmdbuf, uchar_t *rqbuf, uint_t rqbuflen,
1537 uchar_t *bufaddr, uint_t buflen, int path_flag);
1538 static int sd_send_scsi_feature_GET_CONFIGURATION(sd_ssc_t *ssc,
1539 struct uscsi_cmd *ucmdbuf, uchar_t *rqbuf, uint_t rqbuflen,
1540 uchar_t *bufaddr, uint_t buflen, char feature, int path_flag);
1541 static int sd_send_scsi_MODE_SENSE(sd_ssc_t *ssc, int cdbsize,
1542 uchar_t *bufaddr, size_t buflen, uchar_t page_code, int path_flag);
1543 static int sd_send_scsi_MODE_SELECT(sd_ssc_t *ssc, int cdbsize,
1544 uchar_t *bufaddr, size_t buflen, uchar_t save_page, int path_flag);
1545 static int sd_send_scsi_RDWR(sd_ssc_t *ssc, uchar_t cmd, void *bufaddr,
1546 size_t buflen, daddr_t start_block, int path_flag);
1547 #define sd_send_scsi_READ(ssc, bufaddr, buflen, start_block, path_flag) \
1548 sd_send_scsi_RDWR(ssc, SCMD_READ, bufaddr, buflen, start_block, \
1549 path_flag)
1550 #define sd_send_scsi_WRITE(ssc, bufaddr, buflen, start_block, path_flag)\
1551 sd_send_scsi_RDWR(ssc, SCMD_WRITE, bufaddr, buflen, start_block,\
1552 path_flag)
1553
1554 static int sd_send_scsi_LOG_SENSE(sd_ssc_t *ssc, uchar_t *bufaddr,
1555 uint16_t buflen, uchar_t page_code, uchar_t page_control,
1556 uint16_t param_ptr, int path_flag);
1557 static int sd_send_scsi_GET_EVENT_STATUS_NOTIFICATION(sd_ssc_t *ssc,
1558 uchar_t *bufaddr, size_t buflen, uchar_t class_req);
1559 static boolean_t sd_gesn_media_data_valid(uchar_t *data);
1560
1561 static int sd_alloc_rqs(struct scsi_device *devp, struct sd_lun *un);
1562 static void sd_free_rqs(struct sd_lun *un);
1563
1564 static void sd_dump_memory(struct sd_lun *un, uint_t comp, char *title,
1565 uchar_t *data, int len, int fmt);
1566 static void sd_panic_for_res_conflict(struct sd_lun *un);
1567
1568 /*
1569 * Disk Ioctl Function Prototypes
1570 */
1571 static int sd_get_media_info(dev_t dev, caddr_t arg, int flag);
1572 static int sd_get_media_info_ext(dev_t dev, caddr_t arg, int flag);
1573 static int sd_dkio_ctrl_info(dev_t dev, caddr_t arg, int flag);
1574 static int sd_dkio_get_temp(dev_t dev, caddr_t arg, int flag);
1575
1576 /*
1577 * Multi-host Ioctl Prototypes
1578 */
1579 static int sd_check_mhd(dev_t dev, int interval);
1580 static int sd_mhd_watch_cb(caddr_t arg, struct scsi_watch_result *resultp);
1581 static void sd_mhd_watch_incomplete(struct sd_lun *un, struct scsi_pkt *pkt);
1582 static char *sd_sname(uchar_t status);
1583 static void sd_mhd_resvd_recover(void *arg);
1584 static void sd_resv_reclaim_thread();
1585 static int sd_take_ownership(dev_t dev, struct mhioctkown *p);
1586 static int sd_reserve_release(dev_t dev, int cmd);
1587 static void sd_rmv_resv_reclaim_req(dev_t dev);
1588 static void sd_mhd_reset_notify_cb(caddr_t arg);
1589 static int sd_persistent_reservation_in_read_keys(struct sd_lun *un,
1590 mhioc_inkeys_t *usrp, int flag);
1591 static int sd_persistent_reservation_in_read_resv(struct sd_lun *un,
1592 mhioc_inresvs_t *usrp, int flag);
1593 static int sd_mhdioc_takeown(dev_t dev, caddr_t arg, int flag);
1594 static int sd_mhdioc_failfast(dev_t dev, caddr_t arg, int flag);
1595 static int sd_mhdioc_release(dev_t dev);
1596 static int sd_mhdioc_register_devid(dev_t dev);
1597 static int sd_mhdioc_inkeys(dev_t dev, caddr_t arg, int flag);
1598 static int sd_mhdioc_inresv(dev_t dev, caddr_t arg, int flag);
1599
1600 /*
1601 * SCSI removable prototypes
1602 */
1603 static int sr_change_blkmode(dev_t dev, int cmd, intptr_t data, int flag);
1604 static int sr_change_speed(dev_t dev, int cmd, intptr_t data, int flag);
1605 static int sr_atapi_change_speed(dev_t dev, int cmd, intptr_t data, int flag);
1606 static int sr_pause_resume(dev_t dev, int mode);
1607 static int sr_play_msf(dev_t dev, caddr_t data, int flag);
1608 static int sr_play_trkind(dev_t dev, caddr_t data, int flag);
1609 static int sr_read_all_subcodes(dev_t dev, caddr_t data, int flag);
1610 static int sr_read_subchannel(dev_t dev, caddr_t data, int flag);
1611 static int sr_read_tocentry(dev_t dev, caddr_t data, int flag);
1612 static int sr_read_tochdr(dev_t dev, caddr_t data, int flag);
1613 static int sr_read_cdda(dev_t dev, caddr_t data, int flag);
1614 static int sr_read_cdxa(dev_t dev, caddr_t data, int flag);
1615 static int sr_read_mode1(dev_t dev, caddr_t data, int flag);
1616 static int sr_read_mode2(dev_t dev, caddr_t data, int flag);
1617 static int sr_read_cd_mode2(dev_t dev, caddr_t data, int flag);
1618 static int sr_sector_mode(dev_t dev, uint32_t blksize);
1619 static int sr_eject(dev_t dev);
1620 static void sr_ejected(register struct sd_lun *un);
1621 static int sr_check_wp(dev_t dev);
1622 static opaque_t sd_watch_request_submit(struct sd_lun *un);
1623 static int sd_check_media(dev_t dev, enum dkio_state state);
1624 static int sd_media_watch_cb(caddr_t arg, struct scsi_watch_result *resultp);
1625 static void sd_delayed_cv_broadcast(void *arg);
1626 static int sr_volume_ctrl(dev_t dev, caddr_t data, int flag);
1627 static int sr_read_sony_session_offset(dev_t dev, caddr_t data, int flag);
1628
1629 static int sd_log_page_supported(sd_ssc_t *ssc, int log_page);
1630
1631 /*
1632 * Function Prototype for the non-512 support (DVDRAM, MO etc.) functions.
1633 */
1634 static void sd_check_for_writable_cd(sd_ssc_t *ssc, int path_flag);
1635 static int sd_wm_cache_constructor(void *wm, void *un, int flags);
1636 static void sd_wm_cache_destructor(void *wm, void *un);
1637 static struct sd_w_map *sd_range_lock(struct sd_lun *un, daddr_t startb,
1638 daddr_t endb, ushort_t typ);
1639 static struct sd_w_map *sd_get_range(struct sd_lun *un, daddr_t startb,
1640 daddr_t endb);
1641 static void sd_free_inlist_wmap(struct sd_lun *un, struct sd_w_map *wmp);
1642 static void sd_range_unlock(struct sd_lun *un, struct sd_w_map *wm);
1643 static void sd_read_modify_write_task(void * arg);
1644 static int
1645 sddump_do_read_of_rmw(struct sd_lun *un, uint64_t blkno, uint64_t nblk,
1646 struct buf **bpp);
1647
1648
1649 /*
1650 * Function prototypes for failfast support.
1651 */
1652 static void sd_failfast_flushq(struct sd_lun *un);
1653 static int sd_failfast_flushq_callback(struct buf *bp);
1654
1655 /*
1656 * Function prototypes to check for lsi devices
1657 */
1658 static void sd_is_lsi(struct sd_lun *un);
1659
1660 /*
1661 * Function prototypes for partial DMA support
1662 */
1663 static int sd_setup_next_xfer(struct sd_lun *un, struct buf *bp,
1664 struct scsi_pkt *pkt, struct sd_xbuf *xp);
1665
1666
1667 /* Function prototypes for cmlb */
1668 static int sd_tg_rdwr(dev_info_t *devi, uchar_t cmd, void *bufaddr,
1669 diskaddr_t start_block, size_t reqlength, void *tg_cookie);
1670
1671 static int sd_tg_getinfo(dev_info_t *devi, int cmd, void *arg, void *tg_cookie);
1672
1673 /*
1674 * For printing RMW warning message timely
1675 */
1676 static void sd_rmw_msg_print_handler(void *arg);
1677
1678 /*
1679 * Constants for failfast support:
1680 *
1681 * SD_FAILFAST_INACTIVE: Instance is currently in a normal state, with NO
1682 * failfast processing being performed.
1683 *
1684 * SD_FAILFAST_ACTIVE: Instance is in the failfast state and is performing
1685 * failfast processing on all bufs with B_FAILFAST set.
1686 */
1687
1688 #define SD_FAILFAST_INACTIVE 0
1689 #define SD_FAILFAST_ACTIVE 1
1690
1691 /*
1692 * Bitmask to control behavior of buf(9S) flushes when a transition to
1693 * the failfast state occurs. Optional bits include:
1694 *
1695 * SD_FAILFAST_FLUSH_ALL_BUFS: When set, flush ALL bufs including those that
1696 * do NOT have B_FAILFAST set. When clear, only bufs with B_FAILFAST will
1697 * be flushed.
1698 *
1699 * SD_FAILFAST_FLUSH_ALL_QUEUES: When set, flush any/all other queues in the
1700 * driver, in addition to the regular wait queue. This includes the xbuf
1701 * queues. When clear, only the driver's wait queue will be flushed.
1702 */
1703 #define SD_FAILFAST_FLUSH_ALL_BUFS 0x01
1704 #define SD_FAILFAST_FLUSH_ALL_QUEUES 0x02
1705
1706 /*
1707 * The default behavior is to only flush bufs that have B_FAILFAST set, but
1708 * to flush all queues within the driver.
1709 */
1710 static int sd_failfast_flushctl = SD_FAILFAST_FLUSH_ALL_QUEUES;
1711
1712
1713 /*
1714 * SD Testing Fault Injection
1715 */
1716 #ifdef SD_FAULT_INJECTION
1717 static void sd_faultinjection_ioctl(int cmd, intptr_t arg, struct sd_lun *un);
1718 static void sd_faultinjection(struct scsi_pkt *pktp);
1719 static void sd_injection_log(char *buf, struct sd_lun *un);
1720 #endif
1721
1722 /*
1723 * Device driver ops vector
1724 */
1725 static struct cb_ops sd_cb_ops = {
1726 sdopen, /* open */
1727 sdclose, /* close */
1728 sdstrategy, /* strategy */
1729 nodev, /* print */
1730 sddump, /* dump */
1731 sdread, /* read */
1732 sdwrite, /* write */
1733 sdioctl, /* ioctl */
1734 nodev, /* devmap */
1735 nodev, /* mmap */
1736 nodev, /* segmap */
1737 nochpoll, /* poll */
1738 sd_prop_op, /* cb_prop_op */
1739 0, /* streamtab */
1740 D_64BIT | D_MP | D_NEW | D_HOTPLUG, /* Driver compatibility flags */
1741 CB_REV, /* cb_rev */
1742 sdaread, /* async I/O read entry point */
1743 sdawrite /* async I/O write entry point */
1744 };
1745
1746 struct dev_ops sd_ops = {
1747 DEVO_REV, /* devo_rev, */
1748 0, /* refcnt */
1749 sdinfo, /* info */
1750 nulldev, /* identify */
1751 sdprobe, /* probe */
1752 sdattach, /* attach */
1753 sddetach, /* detach */
1754 nodev, /* reset */
1755 &sd_cb_ops, /* driver operations */
1756 NULL, /* bus operations */
1757 sdpower, /* power */
1758 ddi_quiesce_not_needed, /* quiesce */
1759 };
1760
1761 /*
1762 * This is the loadable module wrapper.
1763 */
1764 #include <sys/modctl.h>
1765
1766 #ifndef XPV_HVM_DRIVER
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 #else /* XPV_HVM_DRIVER */
1778 static struct modlmisc modlmisc = {
1779 &mod_miscops, /* Type of module. This one is a misc */
1780 "HVM " SD_MODULE_NAME, /* Module name. */
1781 };
1782
1783 static struct modlinkage modlinkage = {
1784 MODREV_1, &modlmisc, NULL
1785 };
1786
1787 #endif /* XPV_HVM_DRIVER */
1788
1789 static cmlb_tg_ops_t sd_tgops = {
1790 TG_DK_OPS_VERSION_1,
1791 sd_tg_rdwr,
1792 sd_tg_getinfo
1793 };
1794
1795 static struct scsi_asq_key_strings sd_additional_codes[] = {
1796 0x81, 0, "Logical Unit is Reserved",
1797 0x85, 0, "Audio Address Not Valid",
1798 0xb6, 0, "Media Load Mechanism Failed",
1799 0xB9, 0, "Audio Play Operation Aborted",
1800 0xbf, 0, "Buffer Overflow for Read All Subcodes Command",
1801 0x53, 2, "Medium removal prevented",
1802 0x6f, 0, "Authentication failed during key exchange",
1803 0x6f, 1, "Key not present",
1804 0x6f, 2, "Key not established",
1805 0x6f, 3, "Read without proper authentication",
1806 0x6f, 4, "Mismatched region to this logical unit",
1807 0x6f, 5, "Region reset count error",
1808 0xffff, 0x0, NULL
1809 };
1810
1811
1812 /*
1813 * Struct for passing printing information for sense data messages
1814 */
1815 struct sd_sense_info {
1816 int ssi_severity;
1817 int ssi_pfa_flag;
1818 };
1819
1820 /*
1821 * Table of function pointers for iostart-side routines. Separate "chains"
1822 * of layered function calls are formed by placing the function pointers
1823 * sequentially in the desired order. Functions are called according to an
1824 * incrementing table index ordering. The last function in each chain must
1825 * be sd_core_iostart(). The corresponding iodone-side routines are expected
1826 * in the sd_iodone_chain[] array.
1827 *
1828 * Note: It may seem more natural to organize both the iostart and iodone
1829 * functions together, into an array of structures (or some similar
1830 * organization) with a common index, rather than two separate arrays which
1831 * must be maintained in synchronization. The purpose of this division is
1832 * to achieve improved performance: individual arrays allows for more
1833 * effective cache line utilization on certain platforms.
1834 */
1835
1836 typedef void (*sd_chain_t)(int index, struct sd_lun *un, struct buf *bp);
1837
1838
1839 static sd_chain_t sd_iostart_chain[] = {
1840
1841 /* Chain for buf IO for disk drive targets (PM enabled) */
1842 sd_mapblockaddr_iostart, /* Index: 0 */
1843 sd_pm_iostart, /* Index: 1 */
1844 sd_core_iostart, /* Index: 2 */
1845
1846 /* Chain for buf IO for disk drive targets (PM disabled) */
1847 sd_mapblockaddr_iostart, /* Index: 3 */
1848 sd_core_iostart, /* Index: 4 */
1849
1850 /*
1851 * Chain for buf IO for removable-media or large sector size
1852 * disk drive targets with RMW needed (PM enabled)
1853 */
1854 sd_mapblockaddr_iostart, /* Index: 5 */
1855 sd_mapblocksize_iostart, /* Index: 6 */
1856 sd_pm_iostart, /* Index: 7 */
1857 sd_core_iostart, /* Index: 8 */
1858
1859 /*
1860 * Chain for buf IO for removable-media or large sector size
1861 * disk drive targets with RMW needed (PM disabled)
1862 */
1863 sd_mapblockaddr_iostart, /* Index: 9 */
1864 sd_mapblocksize_iostart, /* Index: 10 */
1865 sd_core_iostart, /* Index: 11 */
1866
1867 /* Chain for buf IO for disk drives with checksumming (PM enabled) */
1868 sd_mapblockaddr_iostart, /* Index: 12 */
1869 sd_checksum_iostart, /* Index: 13 */
1870 sd_pm_iostart, /* Index: 14 */
1871 sd_core_iostart, /* Index: 15 */
1872
1873 /* Chain for buf IO for disk drives with checksumming (PM disabled) */
1874 sd_mapblockaddr_iostart, /* Index: 16 */
1875 sd_checksum_iostart, /* Index: 17 */
1876 sd_core_iostart, /* Index: 18 */
1877
1878 /* Chain for USCSI commands (all targets) */
1879 sd_pm_iostart, /* Index: 19 */
1880 sd_core_iostart, /* Index: 20 */
1881
1882 /* Chain for checksumming USCSI commands (all targets) */
1883 sd_checksum_uscsi_iostart, /* Index: 21 */
1884 sd_pm_iostart, /* Index: 22 */
1885 sd_core_iostart, /* Index: 23 */
1886
1887 /* Chain for "direct" USCSI commands (all targets) */
1888 sd_core_iostart, /* Index: 24 */
1889
1890 /* Chain for "direct priority" USCSI commands (all targets) */
1891 sd_core_iostart, /* Index: 25 */
1892
1893 /*
1894 * Chain for buf IO for large sector size disk drive targets
1895 * with RMW needed with checksumming (PM enabled)
1896 */
1897 sd_mapblockaddr_iostart, /* Index: 26 */
1898 sd_mapblocksize_iostart, /* Index: 27 */
1899 sd_checksum_iostart, /* Index: 28 */
1900 sd_pm_iostart, /* Index: 29 */
1901 sd_core_iostart, /* Index: 30 */
1902
1903 /*
1904 * Chain for buf IO for large sector size disk drive targets
1905 * with RMW needed with checksumming (PM disabled)
1906 */
1907 sd_mapblockaddr_iostart, /* Index: 31 */
1908 sd_mapblocksize_iostart, /* Index: 32 */
1909 sd_checksum_iostart, /* Index: 33 */
1910 sd_core_iostart, /* Index: 34 */
1911
1912 };
1913
1914 /*
1915 * Macros to locate the first function of each iostart chain in the
1916 * sd_iostart_chain[] array. These are located by the index in the array.
1917 */
1918 #define SD_CHAIN_DISK_IOSTART 0
1919 #define SD_CHAIN_DISK_IOSTART_NO_PM 3
1920 #define SD_CHAIN_MSS_DISK_IOSTART 5
1921 #define SD_CHAIN_RMMEDIA_IOSTART 5
1922 #define SD_CHAIN_MSS_DISK_IOSTART_NO_PM 9
1923 #define SD_CHAIN_RMMEDIA_IOSTART_NO_PM 9
1924 #define SD_CHAIN_CHKSUM_IOSTART 12
1925 #define SD_CHAIN_CHKSUM_IOSTART_NO_PM 16
1926 #define SD_CHAIN_USCSI_CMD_IOSTART 19
1927 #define SD_CHAIN_USCSI_CHKSUM_IOSTART 21
1928 #define SD_CHAIN_DIRECT_CMD_IOSTART 24
1929 #define SD_CHAIN_PRIORITY_CMD_IOSTART 25
1930 #define SD_CHAIN_MSS_CHKSUM_IOSTART 26
1931 #define SD_CHAIN_MSS_CHKSUM_IOSTART_NO_PM 31
1932
1933
1934 /*
1935 * Table of function pointers for the iodone-side routines for the driver-
1936 * internal layering mechanism. The calling sequence for iodone routines
1937 * uses a decrementing table index, so the last routine called in a chain
1938 * must be at the lowest array index location for that chain. The last
1939 * routine for each chain must be either sd_buf_iodone() (for buf(9S) IOs)
1940 * or sd_uscsi_iodone() (for uscsi IOs). Other than this, the ordering
1941 * of the functions in an iodone side chain must correspond to the ordering
1942 * of the iostart routines for that chain. Note that there is no iodone
1943 * side routine that corresponds to sd_core_iostart(), so there is no
1944 * entry in the table for this.
1945 */
1946
1947 static sd_chain_t sd_iodone_chain[] = {
1948
1949 /* Chain for buf IO for disk drive targets (PM enabled) */
1950 sd_buf_iodone, /* Index: 0 */
1951 sd_mapblockaddr_iodone, /* Index: 1 */
1952 sd_pm_iodone, /* Index: 2 */
1953
1954 /* Chain for buf IO for disk drive targets (PM disabled) */
1955 sd_buf_iodone, /* Index: 3 */
1956 sd_mapblockaddr_iodone, /* Index: 4 */
1957
1958 /*
1959 * Chain for buf IO for removable-media or large sector size
1960 * disk drive targets with RMW needed (PM enabled)
1961 */
1962 sd_buf_iodone, /* Index: 5 */
1963 sd_mapblockaddr_iodone, /* Index: 6 */
1964 sd_mapblocksize_iodone, /* Index: 7 */
1965 sd_pm_iodone, /* Index: 8 */
1966
1967 /*
1968 * Chain for buf IO for removable-media or large sector size
1969 * disk drive targets with RMW needed (PM disabled)
1970 */
1971 sd_buf_iodone, /* Index: 9 */
1972 sd_mapblockaddr_iodone, /* Index: 10 */
1973 sd_mapblocksize_iodone, /* Index: 11 */
1974
1975 /* Chain for buf IO for disk drives with checksumming (PM enabled) */
1976 sd_buf_iodone, /* Index: 12 */
1977 sd_mapblockaddr_iodone, /* Index: 13 */
1978 sd_checksum_iodone, /* Index: 14 */
1979 sd_pm_iodone, /* Index: 15 */
1980
1981 /* Chain for buf IO for disk drives with checksumming (PM disabled) */
1982 sd_buf_iodone, /* Index: 16 */
1983 sd_mapblockaddr_iodone, /* Index: 17 */
1984 sd_checksum_iodone, /* Index: 18 */
1985
1986 /* Chain for USCSI commands (non-checksum targets) */
1987 sd_uscsi_iodone, /* Index: 19 */
1988 sd_pm_iodone, /* Index: 20 */
1989
1990 /* Chain for USCSI commands (checksum targets) */
1991 sd_uscsi_iodone, /* Index: 21 */
1992 sd_checksum_uscsi_iodone, /* Index: 22 */
1993 sd_pm_iodone, /* Index: 22 */
1994
1995 /* Chain for "direct" USCSI commands (all targets) */
1996 sd_uscsi_iodone, /* Index: 24 */
1997
1998 /* Chain for "direct priority" USCSI commands (all targets) */
1999 sd_uscsi_iodone, /* Index: 25 */
2000
2001 /*
2002 * Chain for buf IO for large sector size disk drive targets
2003 * with checksumming (PM enabled)
2004 */
2005 sd_buf_iodone, /* Index: 26 */
2006 sd_mapblockaddr_iodone, /* Index: 27 */
2007 sd_mapblocksize_iodone, /* Index: 28 */
2008 sd_checksum_iodone, /* Index: 29 */
2009 sd_pm_iodone, /* Index: 30 */
2010
2011 /*
2012 * Chain for buf IO for large sector size disk drive targets
2013 * with checksumming (PM disabled)
2014 */
2015 sd_buf_iodone, /* Index: 31 */
2016 sd_mapblockaddr_iodone, /* Index: 32 */
2017 sd_mapblocksize_iodone, /* Index: 33 */
2018 sd_checksum_iodone, /* Index: 34 */
2019 };
2020
2021
2022 /*
2023 * Macros to locate the "first" function in the sd_iodone_chain[] array for
2024 * each iodone-side chain. These are located by the array index, but as the
2025 * iodone side functions are called in a decrementing-index order, the
2026 * highest index number in each chain must be specified (as these correspond
2027 * to the first function in the iodone chain that will be called by the core
2028 * at IO completion time).
2029 */
2030
2031 #define SD_CHAIN_DISK_IODONE 2
2032 #define SD_CHAIN_DISK_IODONE_NO_PM 4
2033 #define SD_CHAIN_RMMEDIA_IODONE 8
2034 #define SD_CHAIN_MSS_DISK_IODONE 8
2035 #define SD_CHAIN_RMMEDIA_IODONE_NO_PM 11
2036 #define SD_CHAIN_MSS_DISK_IODONE_NO_PM 11
2037 #define SD_CHAIN_CHKSUM_IODONE 15
2038 #define SD_CHAIN_CHKSUM_IODONE_NO_PM 18
2039 #define SD_CHAIN_USCSI_CMD_IODONE 20
2040 #define SD_CHAIN_USCSI_CHKSUM_IODONE 22
2041 #define SD_CHAIN_DIRECT_CMD_IODONE 24
2042 #define SD_CHAIN_PRIORITY_CMD_IODONE 25
2043 #define SD_CHAIN_MSS_CHKSUM_IODONE 30
2044 #define SD_CHAIN_MSS_CHKSUM_IODONE_NO_PM 34
2045
2046
2047
2048 /*
2049 * Array to map a layering chain index to the appropriate initpkt routine.
2050 * The redundant entries are present so that the index used for accessing
2051 * the above sd_iostart_chain and sd_iodone_chain tables can be used directly
2052 * with this table as well.
2053 */
2054 typedef int (*sd_initpkt_t)(struct buf *, struct scsi_pkt **);
2055
2056 static sd_initpkt_t sd_initpkt_map[] = {
2057
2058 /* Chain for buf IO for disk drive targets (PM enabled) */
2059 sd_initpkt_for_buf, /* Index: 0 */
2060 sd_initpkt_for_buf, /* Index: 1 */
2061 sd_initpkt_for_buf, /* Index: 2 */
2062
2063 /* Chain for buf IO for disk drive targets (PM disabled) */
2064 sd_initpkt_for_buf, /* Index: 3 */
2065 sd_initpkt_for_buf, /* Index: 4 */
2066
2067 /*
2068 * Chain for buf IO for removable-media or large sector size
2069 * disk drive targets (PM enabled)
2070 */
2071 sd_initpkt_for_buf, /* Index: 5 */
2072 sd_initpkt_for_buf, /* Index: 6 */
2073 sd_initpkt_for_buf, /* Index: 7 */
2074 sd_initpkt_for_buf, /* Index: 8 */
2075
2076 /*
2077 * Chain for buf IO for removable-media or large sector size
2078 * disk drive targets (PM disabled)
2079 */
2080 sd_initpkt_for_buf, /* Index: 9 */
2081 sd_initpkt_for_buf, /* Index: 10 */
2082 sd_initpkt_for_buf, /* Index: 11 */
2083
2084 /* Chain for buf IO for disk drives with checksumming (PM enabled) */
2085 sd_initpkt_for_buf, /* Index: 12 */
2086 sd_initpkt_for_buf, /* Index: 13 */
2087 sd_initpkt_for_buf, /* Index: 14 */
2088 sd_initpkt_for_buf, /* Index: 15 */
2089
2090 /* Chain for buf IO for disk drives with checksumming (PM disabled) */
2091 sd_initpkt_for_buf, /* Index: 16 */
2092 sd_initpkt_for_buf, /* Index: 17 */
2093 sd_initpkt_for_buf, /* Index: 18 */
2094
2095 /* Chain for USCSI commands (non-checksum targets) */
2096 sd_initpkt_for_uscsi, /* Index: 19 */
2097 sd_initpkt_for_uscsi, /* Index: 20 */
2098
2099 /* Chain for USCSI commands (checksum targets) */
2100 sd_initpkt_for_uscsi, /* Index: 21 */
2101 sd_initpkt_for_uscsi, /* Index: 22 */
2102 sd_initpkt_for_uscsi, /* Index: 22 */
2103
2104 /* Chain for "direct" USCSI commands (all targets) */
2105 sd_initpkt_for_uscsi, /* Index: 24 */
2106
2107 /* Chain for "direct priority" USCSI commands (all targets) */
2108 sd_initpkt_for_uscsi, /* Index: 25 */
2109
2110 /*
2111 * Chain for buf IO for large sector size disk drive targets
2112 * with checksumming (PM enabled)
2113 */
2114 sd_initpkt_for_buf, /* Index: 26 */
2115 sd_initpkt_for_buf, /* Index: 27 */
2116 sd_initpkt_for_buf, /* Index: 28 */
2117 sd_initpkt_for_buf, /* Index: 29 */
2118 sd_initpkt_for_buf, /* Index: 30 */
2119
2120 /*
2121 * Chain for buf IO for large sector size disk drive targets
2122 * with checksumming (PM disabled)
2123 */
2124 sd_initpkt_for_buf, /* Index: 31 */
2125 sd_initpkt_for_buf, /* Index: 32 */
2126 sd_initpkt_for_buf, /* Index: 33 */
2127 sd_initpkt_for_buf, /* Index: 34 */
2128 };
2129
2130
2131 /*
2132 * Array to map a layering chain index to the appropriate destroypktpkt routine.
2133 * The redundant entries are present so that the index used for accessing
2134 * the above sd_iostart_chain and sd_iodone_chain tables can be used directly
2135 * with this table as well.
2136 */
2137 typedef void (*sd_destroypkt_t)(struct buf *);
2138
2139 static sd_destroypkt_t sd_destroypkt_map[] = {
2140
2141 /* Chain for buf IO for disk drive targets (PM enabled) */
2142 sd_destroypkt_for_buf, /* Index: 0 */
2143 sd_destroypkt_for_buf, /* Index: 1 */
2144 sd_destroypkt_for_buf, /* Index: 2 */
2145
2146 /* Chain for buf IO for disk drive targets (PM disabled) */
2147 sd_destroypkt_for_buf, /* Index: 3 */
2148 sd_destroypkt_for_buf, /* Index: 4 */
2149
2150 /*
2151 * Chain for buf IO for removable-media or large sector size
2152 * disk drive targets (PM enabled)
2153 */
2154 sd_destroypkt_for_buf, /* Index: 5 */
2155 sd_destroypkt_for_buf, /* Index: 6 */
2156 sd_destroypkt_for_buf, /* Index: 7 */
2157 sd_destroypkt_for_buf, /* Index: 8 */
2158
2159 /*
2160 * Chain for buf IO for removable-media or large sector size
2161 * disk drive targets (PM disabled)
2162 */
2163 sd_destroypkt_for_buf, /* Index: 9 */
2164 sd_destroypkt_for_buf, /* Index: 10 */
2165 sd_destroypkt_for_buf, /* Index: 11 */
2166
2167 /* Chain for buf IO for disk drives with checksumming (PM enabled) */
2168 sd_destroypkt_for_buf, /* Index: 12 */
2169 sd_destroypkt_for_buf, /* Index: 13 */
2170 sd_destroypkt_for_buf, /* Index: 14 */
2171 sd_destroypkt_for_buf, /* Index: 15 */
2172
2173 /* Chain for buf IO for disk drives with checksumming (PM disabled) */
2174 sd_destroypkt_for_buf, /* Index: 16 */
2175 sd_destroypkt_for_buf, /* Index: 17 */
2176 sd_destroypkt_for_buf, /* Index: 18 */
2177
2178 /* Chain for USCSI commands (non-checksum targets) */
2179 sd_destroypkt_for_uscsi, /* Index: 19 */
2180 sd_destroypkt_for_uscsi, /* Index: 20 */
2181
2182 /* Chain for USCSI commands (checksum targets) */
2183 sd_destroypkt_for_uscsi, /* Index: 21 */
2184 sd_destroypkt_for_uscsi, /* Index: 22 */
2185 sd_destroypkt_for_uscsi, /* Index: 22 */
2186
2187 /* Chain for "direct" USCSI commands (all targets) */
2188 sd_destroypkt_for_uscsi, /* Index: 24 */
2189
2190 /* Chain for "direct priority" USCSI commands (all targets) */
2191 sd_destroypkt_for_uscsi, /* Index: 25 */
2192
2193 /*
2194 * Chain for buf IO for large sector size disk drive targets
2195 * with checksumming (PM disabled)
2196 */
2197 sd_destroypkt_for_buf, /* Index: 26 */
2198 sd_destroypkt_for_buf, /* Index: 27 */
2199 sd_destroypkt_for_buf, /* Index: 28 */
2200 sd_destroypkt_for_buf, /* Index: 29 */
2201 sd_destroypkt_for_buf, /* Index: 30 */
2202
2203 /*
2204 * Chain for buf IO for large sector size disk drive targets
2205 * with checksumming (PM enabled)
2206 */
2207 sd_destroypkt_for_buf, /* Index: 31 */
2208 sd_destroypkt_for_buf, /* Index: 32 */
2209 sd_destroypkt_for_buf, /* Index: 33 */
2210 sd_destroypkt_for_buf, /* Index: 34 */
2211 };
2212
2213
2214
2215 /*
2216 * Array to map a layering chain index to the appropriate chain "type".
2217 * The chain type indicates a specific property/usage of the chain.
2218 * The redundant entries are present so that the index used for accessing
2219 * the above sd_iostart_chain and sd_iodone_chain tables can be used directly
2220 * with this table as well.
2221 */
2222
2223 #define SD_CHAIN_NULL 0 /* for the special RQS cmd */
2224 #define SD_CHAIN_BUFIO 1 /* regular buf IO */
2225 #define SD_CHAIN_USCSI 2 /* regular USCSI commands */
2226 #define SD_CHAIN_DIRECT 3 /* uscsi, w/ bypass power mgt */
2227 #define SD_CHAIN_DIRECT_PRIORITY 4 /* uscsi, w/ bypass power mgt */
2228 /* (for error recovery) */
2229
2230 static int sd_chain_type_map[] = {
2231
2232 /* Chain for buf IO for disk drive targets (PM enabled) */
2233 SD_CHAIN_BUFIO, /* Index: 0 */
2234 SD_CHAIN_BUFIO, /* Index: 1 */
2235 SD_CHAIN_BUFIO, /* Index: 2 */
2236
2237 /* Chain for buf IO for disk drive targets (PM disabled) */
2238 SD_CHAIN_BUFIO, /* Index: 3 */
2239 SD_CHAIN_BUFIO, /* Index: 4 */
2240
2241 /*
2242 * Chain for buf IO for removable-media or large sector size
2243 * disk drive targets (PM enabled)
2244 */
2245 SD_CHAIN_BUFIO, /* Index: 5 */
2246 SD_CHAIN_BUFIO, /* Index: 6 */
2247 SD_CHAIN_BUFIO, /* Index: 7 */
2248 SD_CHAIN_BUFIO, /* Index: 8 */
2249
2250 /*
2251 * Chain for buf IO for removable-media or large sector size
2252 * disk drive targets (PM disabled)
2253 */
2254 SD_CHAIN_BUFIO, /* Index: 9 */
2255 SD_CHAIN_BUFIO, /* Index: 10 */
2256 SD_CHAIN_BUFIO, /* Index: 11 */
2257
2258 /* Chain for buf IO for disk drives with checksumming (PM enabled) */
2259 SD_CHAIN_BUFIO, /* Index: 12 */
2260 SD_CHAIN_BUFIO, /* Index: 13 */
2261 SD_CHAIN_BUFIO, /* Index: 14 */
2262 SD_CHAIN_BUFIO, /* Index: 15 */
2263
2264 /* Chain for buf IO for disk drives with checksumming (PM disabled) */
2265 SD_CHAIN_BUFIO, /* Index: 16 */
2266 SD_CHAIN_BUFIO, /* Index: 17 */
2267 SD_CHAIN_BUFIO, /* Index: 18 */
2268
2269 /* Chain for USCSI commands (non-checksum targets) */
2270 SD_CHAIN_USCSI, /* Index: 19 */
2271 SD_CHAIN_USCSI, /* Index: 20 */
2272
2273 /* Chain for USCSI commands (checksum targets) */
2274 SD_CHAIN_USCSI, /* Index: 21 */
2275 SD_CHAIN_USCSI, /* Index: 22 */
2276 SD_CHAIN_USCSI, /* Index: 23 */
2277
2278 /* Chain for "direct" USCSI commands (all targets) */
2279 SD_CHAIN_DIRECT, /* Index: 24 */
2280
2281 /* Chain for "direct priority" USCSI commands (all targets) */
2282 SD_CHAIN_DIRECT_PRIORITY, /* Index: 25 */
2283
2284 /*
2285 * Chain for buf IO for large sector size disk drive targets
2286 * with checksumming (PM enabled)
2287 */
2288 SD_CHAIN_BUFIO, /* Index: 26 */
2289 SD_CHAIN_BUFIO, /* Index: 27 */
2290 SD_CHAIN_BUFIO, /* Index: 28 */
2291 SD_CHAIN_BUFIO, /* Index: 29 */
2292 SD_CHAIN_BUFIO, /* Index: 30 */
2293
2294 /*
2295 * Chain for buf IO for large sector size disk drive targets
2296 * with checksumming (PM disabled)
2297 */
2298 SD_CHAIN_BUFIO, /* Index: 31 */
2299 SD_CHAIN_BUFIO, /* Index: 32 */
2300 SD_CHAIN_BUFIO, /* Index: 33 */
2301 SD_CHAIN_BUFIO, /* Index: 34 */
2302 };
2303
2304
2305 /* Macro to return TRUE if the IO has come from the sd_buf_iostart() chain. */
2306 #define SD_IS_BUFIO(xp) \
2307 (sd_chain_type_map[(xp)->xb_chain_iostart] == SD_CHAIN_BUFIO)
2308
2309 /* Macro to return TRUE if the IO has come from the "direct priority" chain. */
2310 #define SD_IS_DIRECT_PRIORITY(xp) \
2311 (sd_chain_type_map[(xp)->xb_chain_iostart] == SD_CHAIN_DIRECT_PRIORITY)
2312
2313
2314
2315 /*
2316 * Struct, array, and macros to map a specific chain to the appropriate
2317 * layering indexes in the sd_iostart_chain[] and sd_iodone_chain[] arrays.
2318 *
2319 * The sd_chain_index_map[] array is used at attach time to set the various
2320 * un_xxx_chain type members of the sd_lun softstate to the specific layering
2321 * chain to be used with the instance. This allows different instances to use
2322 * different chain for buf IO, uscsi IO, etc.. Also, since the xb_chain_iostart
2323 * and xb_chain_iodone index values in the sd_xbuf are initialized to these
2324 * values at sd_xbuf init time, this allows (1) layering chains may be changed
2325 * dynamically & without the use of locking; and (2) a layer may update the
2326 * xb_chain_io[start|done] member in a given xbuf with its current index value,
2327 * to allow for deferred processing of an IO within the same chain from a
2328 * different execution context.
2329 */
2330
2331 struct sd_chain_index {
2332 int sci_iostart_index;
2333 int sci_iodone_index;
2334 };
2335
2336 static struct sd_chain_index sd_chain_index_map[] = {
2337 { SD_CHAIN_DISK_IOSTART, SD_CHAIN_DISK_IODONE },
2338 { SD_CHAIN_DISK_IOSTART_NO_PM, SD_CHAIN_DISK_IODONE_NO_PM },
2339 { SD_CHAIN_RMMEDIA_IOSTART, SD_CHAIN_RMMEDIA_IODONE },
2340 { SD_CHAIN_RMMEDIA_IOSTART_NO_PM, SD_CHAIN_RMMEDIA_IODONE_NO_PM },
2341 { SD_CHAIN_CHKSUM_IOSTART, SD_CHAIN_CHKSUM_IODONE },
2342 { SD_CHAIN_CHKSUM_IOSTART_NO_PM, SD_CHAIN_CHKSUM_IODONE_NO_PM },
2343 { SD_CHAIN_USCSI_CMD_IOSTART, SD_CHAIN_USCSI_CMD_IODONE },
2344 { SD_CHAIN_USCSI_CHKSUM_IOSTART, SD_CHAIN_USCSI_CHKSUM_IODONE },
2345 { SD_CHAIN_DIRECT_CMD_IOSTART, SD_CHAIN_DIRECT_CMD_IODONE },
2346 { SD_CHAIN_PRIORITY_CMD_IOSTART, SD_CHAIN_PRIORITY_CMD_IODONE },
2347 { SD_CHAIN_MSS_CHKSUM_IOSTART, SD_CHAIN_MSS_CHKSUM_IODONE },
2348 { SD_CHAIN_MSS_CHKSUM_IOSTART_NO_PM, SD_CHAIN_MSS_CHKSUM_IODONE_NO_PM },
2349
2350 };
2351
2352
2353 /*
2354 * The following are indexes into the sd_chain_index_map[] array.
2355 */
2356
2357 /* un->un_buf_chain_type must be set to one of these */
2358 #define SD_CHAIN_INFO_DISK 0
2359 #define SD_CHAIN_INFO_DISK_NO_PM 1
2360 #define SD_CHAIN_INFO_RMMEDIA 2
2361 #define SD_CHAIN_INFO_MSS_DISK 2
2362 #define SD_CHAIN_INFO_RMMEDIA_NO_PM 3
2363 #define SD_CHAIN_INFO_MSS_DSK_NO_PM 3
2364 #define SD_CHAIN_INFO_CHKSUM 4
2365 #define SD_CHAIN_INFO_CHKSUM_NO_PM 5
2366 #define SD_CHAIN_INFO_MSS_DISK_CHKSUM 10
2367 #define SD_CHAIN_INFO_MSS_DISK_CHKSUM_NO_PM 11
2368
2369 /* un->un_uscsi_chain_type must be set to one of these */
2370 #define SD_CHAIN_INFO_USCSI_CMD 6
2371 /* USCSI with PM disabled is the same as DIRECT */
2372 #define SD_CHAIN_INFO_USCSI_CMD_NO_PM 8
2373 #define SD_CHAIN_INFO_USCSI_CHKSUM 7
2374
2375 /* un->un_direct_chain_type must be set to one of these */
2376 #define SD_CHAIN_INFO_DIRECT_CMD 8
2377
2378 /* un->un_priority_chain_type must be set to one of these */
2379 #define SD_CHAIN_INFO_PRIORITY_CMD 9
2380
2381 /* size for devid inquiries */
2382 #define MAX_INQUIRY_SIZE 0xF0
2383
2384 /*
2385 * Macros used by functions to pass a given buf(9S) struct along to the
2386 * next function in the layering chain for further processing.
2387 *
2388 * In the following macros, passing more than three arguments to the called
2389 * routines causes the optimizer for the SPARC compiler to stop doing tail
2390 * call elimination which results in significant performance degradation.
2391 */
2392 #define SD_BEGIN_IOSTART(index, un, bp) \
2393 ((*(sd_iostart_chain[index]))(index, un, bp))
2394
2395 #define SD_BEGIN_IODONE(index, un, bp) \
2396 ((*(sd_iodone_chain[index]))(index, un, bp))
2397
2398 #define SD_NEXT_IOSTART(index, un, bp) \
2399 ((*(sd_iostart_chain[(index) + 1]))((index) + 1, un, bp))
2400
2401 #define SD_NEXT_IODONE(index, un, bp) \
2402 ((*(sd_iodone_chain[(index) - 1]))((index) - 1, un, bp))
2403
2404 /*
2405 * Function: _init
2406 *
2407 * Description: This is the driver _init(9E) entry point.
2408 *
2409 * Return Code: Returns the value from mod_install(9F) or
2410 * ddi_soft_state_init(9F) as appropriate.
2411 *
2412 * Context: Called when driver module loaded.
2413 */
2414
2415 int
2416 _init(void)
2417 {
2418 int err;
2419
2420 /* establish driver name from module name */
2421 sd_label = (char *)mod_modname(&modlinkage);
2422
2423 #ifndef XPV_HVM_DRIVER
2424 err = ddi_soft_state_init(&sd_state, sizeof (struct sd_lun),
2425 SD_MAXUNIT);
2426 if (err != 0) {
2427 return (err);
2428 }
2429
2430 #else /* XPV_HVM_DRIVER */
2431 /* Remove the leading "hvm_" from the module name */
2432 ASSERT(strncmp(sd_label, "hvm_", strlen("hvm_")) == 0);
2433 sd_label += strlen("hvm_");
2434
2435 #endif /* XPV_HVM_DRIVER */
2436
2437 mutex_init(&sd_detach_mutex, NULL, MUTEX_DRIVER, NULL);
2438 mutex_init(&sd_log_mutex, NULL, MUTEX_DRIVER, NULL);
2439 mutex_init(&sd_label_mutex, NULL, MUTEX_DRIVER, NULL);
2440
2441 mutex_init(&sd_tr.srq_resv_reclaim_mutex, NULL, MUTEX_DRIVER, NULL);
2442 cv_init(&sd_tr.srq_resv_reclaim_cv, NULL, CV_DRIVER, NULL);
2443 cv_init(&sd_tr.srq_inprocess_cv, NULL, CV_DRIVER, NULL);
2444
2445 /*
2446 * it's ok to init here even for fibre device
2447 */
2448 sd_scsi_probe_cache_init();
2449
2450 sd_scsi_target_lun_init();
2451
2452 /*
2453 * Creating taskq before mod_install ensures that all callers (threads)
2454 * that enter the module after a successful mod_install encounter
2455 * a valid taskq.
2456 */
2457 sd_taskq_create();
2458
2459 err = mod_install(&modlinkage);
2460 if (err != 0) {
2461 /* delete taskq if install fails */
2462 sd_taskq_delete();
2463
2464 mutex_destroy(&sd_detach_mutex);
2465 mutex_destroy(&sd_log_mutex);
2466 mutex_destroy(&sd_label_mutex);
2467
2468 mutex_destroy(&sd_tr.srq_resv_reclaim_mutex);
2469 cv_destroy(&sd_tr.srq_resv_reclaim_cv);
2470 cv_destroy(&sd_tr.srq_inprocess_cv);
2471
2472 sd_scsi_probe_cache_fini();
2473
2474 sd_scsi_target_lun_fini();
2475
2476 #ifndef XPV_HVM_DRIVER
2477 ddi_soft_state_fini(&sd_state);
2478 #endif /* !XPV_HVM_DRIVER */
2479 return (err);
2480 }
2481
2482 return (err);
2483 }
2484
2485
2486 /*
2487 * Function: _fini
2488 *
2489 * Description: This is the driver _fini(9E) entry point.
2490 *
2491 * Return Code: Returns the value from mod_remove(9F)
2492 *
2493 * Context: Called when driver module is unloaded.
2494 */
2495
2496 int
2497 _fini(void)
2498 {
2499 int err;
2500
2501 if ((err = mod_remove(&modlinkage)) != 0) {
2502 return (err);
2503 }
2504
2505 sd_taskq_delete();
2506
2507 mutex_destroy(&sd_detach_mutex);
2508 mutex_destroy(&sd_log_mutex);
2509 mutex_destroy(&sd_label_mutex);
2510 mutex_destroy(&sd_tr.srq_resv_reclaim_mutex);
2511
2512 sd_scsi_probe_cache_fini();
2513
2514 sd_scsi_target_lun_fini();
2515
2516 cv_destroy(&sd_tr.srq_resv_reclaim_cv);
2517 cv_destroy(&sd_tr.srq_inprocess_cv);
2518
2519 #ifndef XPV_HVM_DRIVER
2520 ddi_soft_state_fini(&sd_state);
2521 #endif /* !XPV_HVM_DRIVER */
2522
2523 return (err);
2524 }
2525
2526
2527 /*
2528 * Function: _info
2529 *
2530 * Description: This is the driver _info(9E) entry point.
2531 *
2532 * Arguments: modinfop - pointer to the driver modinfo structure
2533 *
2534 * Return Code: Returns the value from mod_info(9F).
2535 *
2536 * Context: Kernel thread context
2537 */
2538
2539 int
2540 _info(struct modinfo *modinfop)
2541 {
2542 return (mod_info(&modlinkage, modinfop));
2543 }
2544
2545
2546 /*
2547 * The following routines implement the driver message logging facility.
2548 * They provide component- and level- based debug output filtering.
2549 * Output may also be restricted to messages for a single instance by
2550 * specifying a soft state pointer in sd_debug_un. If sd_debug_un is set
2551 * to NULL, then messages for all instances are printed.
2552 *
2553 * These routines have been cloned from each other due to the language
2554 * constraints of macros and variable argument list processing.
2555 */
2556
2557
2558 /*
2559 * Function: sd_log_err
2560 *
2561 * Description: This routine is called by the SD_ERROR macro for debug
2562 * logging of error conditions.
2563 *
2564 * Arguments: comp - driver component being logged
2565 * dev - pointer to driver info structure
2566 * fmt - error string and format to be logged
2567 */
2568
2569 static void
2570 sd_log_err(uint_t comp, struct sd_lun *un, const char *fmt, ...)
2571 {
2572 va_list ap;
2573 dev_info_t *dev;
2574
2575 ASSERT(un != NULL);
2576 dev = SD_DEVINFO(un);
2577 ASSERT(dev != NULL);
2578
2579 /*
2580 * Filter messages based on the global component and level masks.
2581 * Also print if un matches the value of sd_debug_un, or if
2582 * sd_debug_un is set to NULL.
2583 */
2584 if ((sd_component_mask & comp) && (sd_level_mask & SD_LOGMASK_ERROR) &&
2585 ((sd_debug_un == NULL) || (sd_debug_un == un))) {
2586 mutex_enter(&sd_log_mutex);
2587 va_start(ap, fmt);
2588 (void) vsprintf(sd_log_buf, fmt, ap);
2589 va_end(ap);
2590 scsi_log(dev, sd_label, CE_CONT, "%s", sd_log_buf);
2591 mutex_exit(&sd_log_mutex);
2592 }
2593 #ifdef SD_FAULT_INJECTION
2594 _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::sd_injection_mask));
2595 if (un->sd_injection_mask & comp) {
2596 mutex_enter(&sd_log_mutex);
2597 va_start(ap, fmt);
2598 (void) vsprintf(sd_log_buf, fmt, ap);
2599 va_end(ap);
2600 sd_injection_log(sd_log_buf, un);
2601 mutex_exit(&sd_log_mutex);
2602 }
2603 #endif
2604 }
2605
2606
2607 /*
2608 * Function: sd_log_info
2609 *
2610 * Description: This routine is called by the SD_INFO macro for debug
2611 * logging of general purpose informational conditions.
2612 *
2613 * Arguments: comp - driver component being logged
2614 * dev - pointer to driver info structure
2615 * fmt - info string and format to be logged
2616 */
2617
2618 static void
2619 sd_log_info(uint_t component, struct sd_lun *un, const char *fmt, ...)
2620 {
2621 va_list ap;
2622 dev_info_t *dev;
2623
2624 ASSERT(un != NULL);
2625 dev = SD_DEVINFO(un);
2626 ASSERT(dev != NULL);
2627
2628 /*
2629 * Filter messages based on the global component and level masks.
2630 * Also print if un matches the value of sd_debug_un, or if
2631 * sd_debug_un is set to NULL.
2632 */
2633 if ((sd_component_mask & component) &&
2634 (sd_level_mask & SD_LOGMASK_INFO) &&
2635 ((sd_debug_un == NULL) || (sd_debug_un == un))) {
2636 mutex_enter(&sd_log_mutex);
2637 va_start(ap, fmt);
2638 (void) vsprintf(sd_log_buf, fmt, ap);
2639 va_end(ap);
2640 scsi_log(dev, sd_label, CE_CONT, "%s", sd_log_buf);
2641 mutex_exit(&sd_log_mutex);
2642 }
2643 #ifdef SD_FAULT_INJECTION
2644 _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::sd_injection_mask));
2645 if (un->sd_injection_mask & component) {
2646 mutex_enter(&sd_log_mutex);
2647 va_start(ap, fmt);
2648 (void) vsprintf(sd_log_buf, fmt, ap);
2649 va_end(ap);
2650 sd_injection_log(sd_log_buf, un);
2651 mutex_exit(&sd_log_mutex);
2652 }
2653 #endif
2654 }
2655
2656
2657 /*
2658 * Function: sd_log_trace
2659 *
2660 * Description: This routine is called by the SD_TRACE macro for debug
2661 * logging of trace conditions (i.e. function entry/exit).
2662 *
2663 * Arguments: comp - driver component being logged
2664 * dev - pointer to driver info structure
2665 * fmt - trace string and format to be logged
2666 */
2667
2668 static void
2669 sd_log_trace(uint_t component, struct sd_lun *un, const char *fmt, ...)
2670 {
2671 va_list ap;
2672 dev_info_t *dev;
2673
2674 ASSERT(un != NULL);
2675 dev = SD_DEVINFO(un);
2676 ASSERT(dev != NULL);
2677
2678 /*
2679 * Filter messages based on the global component and level masks.
2680 * Also print if un matches the value of sd_debug_un, or if
2681 * sd_debug_un is set to NULL.
2682 */
2683 if ((sd_component_mask & component) &&
2684 (sd_level_mask & SD_LOGMASK_TRACE) &&
2685 ((sd_debug_un == NULL) || (sd_debug_un == un))) {
2686 mutex_enter(&sd_log_mutex);
2687 va_start(ap, fmt);
2688 (void) vsprintf(sd_log_buf, fmt, ap);
2689 va_end(ap);
2690 scsi_log(dev, sd_label, CE_CONT, "%s", sd_log_buf);
2691 mutex_exit(&sd_log_mutex);
2692 }
2693 #ifdef SD_FAULT_INJECTION
2694 _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::sd_injection_mask));
2695 if (un->sd_injection_mask & component) {
2696 mutex_enter(&sd_log_mutex);
2697 va_start(ap, fmt);
2698 (void) vsprintf(sd_log_buf, fmt, ap);
2699 va_end(ap);
2700 sd_injection_log(sd_log_buf, un);
2701 mutex_exit(&sd_log_mutex);
2702 }
2703 #endif
2704 }
2705
2706
2707 /*
2708 * Function: sdprobe
2709 *
2710 * Description: This is the driver probe(9e) entry point function.
2711 *
2712 * Arguments: devi - opaque device info handle
2713 *
2714 * Return Code: DDI_PROBE_SUCCESS: If the probe was successful.
2715 * DDI_PROBE_FAILURE: If the probe failed.
2716 * DDI_PROBE_PARTIAL: If the instance is not present now,
2717 * but may be present in the future.
2718 */
2719
2720 static int
2721 sdprobe(dev_info_t *devi)
2722 {
2723 struct scsi_device *devp;
2724 int rval;
2725 #ifndef XPV_HVM_DRIVER
2726 int instance = ddi_get_instance(devi);
2727 #endif /* !XPV_HVM_DRIVER */
2728
2729 /*
2730 * if it wasn't for pln, sdprobe could actually be nulldev
2731 * in the "__fibre" case.
2732 */
2733 if (ddi_dev_is_sid(devi) == DDI_SUCCESS) {
2734 return (DDI_PROBE_DONTCARE);
2735 }
2736
2737 devp = ddi_get_driver_private(devi);
2738
2739 if (devp == NULL) {
2740 /* Ooops... nexus driver is mis-configured... */
2741 return (DDI_PROBE_FAILURE);
2742 }
2743
2744 #ifndef XPV_HVM_DRIVER
2745 if (ddi_get_soft_state(sd_state, instance) != NULL) {
2746 return (DDI_PROBE_PARTIAL);
2747 }
2748 #endif /* !XPV_HVM_DRIVER */
2749
2750 /*
2751 * Call the SCSA utility probe routine to see if we actually
2752 * have a target at this SCSI nexus.
2753 */
2754 switch (sd_scsi_probe_with_cache(devp, NULL_FUNC)) {
2755 case SCSIPROBE_EXISTS:
2756 switch (devp->sd_inq->inq_dtype) {
2757 case DTYPE_DIRECT:
2758 rval = DDI_PROBE_SUCCESS;
2759 break;
2760 case DTYPE_RODIRECT:
2761 /* CDs etc. Can be removable media */
2762 rval = DDI_PROBE_SUCCESS;
2763 break;
2764 case DTYPE_OPTICAL:
2765 /*
2766 * Rewritable optical driver HP115AA
2767 * Can also be removable media
2768 */
2769
2770 /*
2771 * Do not attempt to bind to DTYPE_OPTICAL if
2772 * pre solaris 9 sparc sd behavior is required
2773 *
2774 * If first time through and sd_dtype_optical_bind
2775 * has not been set in /etc/system check properties
2776 */
2777
2778 if (sd_dtype_optical_bind < 0) {
2779 sd_dtype_optical_bind = ddi_prop_get_int
2780 (DDI_DEV_T_ANY, devi, 0,
2781 "optical-device-bind", 1);
2782 }
2783
2784 if (sd_dtype_optical_bind == 0) {
2785 rval = DDI_PROBE_FAILURE;
2786 } else {
2787 rval = DDI_PROBE_SUCCESS;
2788 }
2789 break;
2790
2791 case DTYPE_NOTPRESENT:
2792 default:
2793 rval = DDI_PROBE_FAILURE;
2794 break;
2795 }
2796 break;
2797 default:
2798 rval = DDI_PROBE_PARTIAL;
2799 break;
2800 }
2801
2802 /*
2803 * This routine checks for resource allocation prior to freeing,
2804 * so it will take care of the "smart probing" case where a
2805 * scsi_probe() may or may not have been issued and will *not*
2806 * free previously-freed resources.
2807 */
2808 scsi_unprobe(devp);
2809 return (rval);
2810 }
2811
2812
2813 /*
2814 * Function: sdinfo
2815 *
2816 * Description: This is the driver getinfo(9e) entry point function.
2817 * Given the device number, return the devinfo pointer from
2818 * the scsi_device structure or the instance number
2819 * associated with the dev_t.
2820 *
2821 * Arguments: dip - pointer to device info structure
2822 * infocmd - command argument (DDI_INFO_DEVT2DEVINFO,
2823 * DDI_INFO_DEVT2INSTANCE)
2824 * arg - driver dev_t
2825 * resultp - user buffer for request response
2826 *
2827 * Return Code: DDI_SUCCESS
2828 * DDI_FAILURE
2829 */
2830 /* ARGSUSED */
2831 static int
2832 sdinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
2833 {
2834 struct sd_lun *un;
2835 dev_t dev;
2836 int instance;
2837 int error;
2838
2839 switch (infocmd) {
2840 case DDI_INFO_DEVT2DEVINFO:
2841 dev = (dev_t)arg;
2842 instance = SDUNIT(dev);
2843 if ((un = ddi_get_soft_state(sd_state, instance)) == NULL) {
2844 return (DDI_FAILURE);
2845 }
2846 *result = (void *) SD_DEVINFO(un);
2847 error = DDI_SUCCESS;
2848 break;
2849 case DDI_INFO_DEVT2INSTANCE:
2850 dev = (dev_t)arg;
2851 instance = SDUNIT(dev);
2852 *result = (void *)(uintptr_t)instance;
2853 error = DDI_SUCCESS;
2854 break;
2855 default:
2856 error = DDI_FAILURE;
2857 }
2858 return (error);
2859 }
2860
2861 /*
2862 * Function: sd_prop_op
2863 *
2864 * Description: This is the driver prop_op(9e) entry point function.
2865 * Return the number of blocks for the partition in question
2866 * or forward the request to the property facilities.
2867 *
2868 * Arguments: dev - device number
2869 * dip - pointer to device info structure
2870 * prop_op - property operator
2871 * mod_flags - DDI_PROP_DONTPASS, don't pass to parent
2872 * name - pointer to property name
2873 * valuep - pointer or address of the user buffer
2874 * lengthp - property length
2875 *
2876 * Return Code: DDI_PROP_SUCCESS
2877 * DDI_PROP_NOT_FOUND
2878 * DDI_PROP_UNDEFINED
2879 * DDI_PROP_NO_MEMORY
2880 * DDI_PROP_BUF_TOO_SMALL
2881 */
2882
2883 static int
2884 sd_prop_op(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op, int mod_flags,
2885 char *name, caddr_t valuep, int *lengthp)
2886 {
2887 struct sd_lun *un;
2888
2889 if ((un = ddi_get_soft_state(sd_state, ddi_get_instance(dip))) == NULL)
2890 return (ddi_prop_op(dev, dip, prop_op, mod_flags,
2891 name, valuep, lengthp));
2892
2893 return (cmlb_prop_op(un->un_cmlbhandle,
2894 dev, dip, prop_op, mod_flags, name, valuep, lengthp,
2895 SDPART(dev), (void *)SD_PATH_DIRECT));
2896 }
2897
2898 /*
2899 * The following functions are for smart probing:
2900 * sd_scsi_probe_cache_init()
2901 * sd_scsi_probe_cache_fini()
2902 * sd_scsi_clear_probe_cache()
2903 * sd_scsi_probe_with_cache()
2904 */
2905
2906 /*
2907 * Function: sd_scsi_probe_cache_init
2908 *
2909 * Description: Initializes the probe response cache mutex and head pointer.
2910 *
2911 * Context: Kernel thread context
2912 */
2913
2914 static void
2915 sd_scsi_probe_cache_init(void)
2916 {
2917 mutex_init(&sd_scsi_probe_cache_mutex, NULL, MUTEX_DRIVER, NULL);
2918 sd_scsi_probe_cache_head = NULL;
2919 }
2920
2921
2922 /*
2923 * Function: sd_scsi_probe_cache_fini
2924 *
2925 * Description: Frees all resources associated with the probe response cache.
2926 *
2927 * Context: Kernel thread context
2928 */
2929
2930 static void
2931 sd_scsi_probe_cache_fini(void)
2932 {
2933 struct sd_scsi_probe_cache *cp;
2934 struct sd_scsi_probe_cache *ncp;
2935
2936 /* Clean up our smart probing linked list */
2937 for (cp = sd_scsi_probe_cache_head; cp != NULL; cp = ncp) {
2938 ncp = cp->next;
2939 kmem_free(cp, sizeof (struct sd_scsi_probe_cache));
2940 }
2941 sd_scsi_probe_cache_head = NULL;
2942 mutex_destroy(&sd_scsi_probe_cache_mutex);
2943 }
2944
2945
2946 /*
2947 * Function: sd_scsi_clear_probe_cache
2948 *
2949 * Description: This routine clears the probe response cache. This is
2950 * done when open() returns ENXIO so that when deferred
2951 * attach is attempted (possibly after a device has been
2952 * turned on) we will retry the probe. Since we don't know
2953 * which target we failed to open, we just clear the
2954 * entire cache.
2955 *
2956 * Context: Kernel thread context
2957 */
2958
2959 static void
2960 sd_scsi_clear_probe_cache(void)
2961 {
2962 struct sd_scsi_probe_cache *cp;
2963 int i;
2964
2965 mutex_enter(&sd_scsi_probe_cache_mutex);
2966 for (cp = sd_scsi_probe_cache_head; cp != NULL; cp = cp->next) {
2967 /*
2968 * Reset all entries to SCSIPROBE_EXISTS. This will
2969 * force probing to be performed the next time
2970 * sd_scsi_probe_with_cache is called.
2971 */
2972 for (i = 0; i < NTARGETS_WIDE; i++) {
2973 cp->cache[i] = SCSIPROBE_EXISTS;
2974 }
2975 }
2976 mutex_exit(&sd_scsi_probe_cache_mutex);
2977 }
2978
2979
2980 /*
2981 * Function: sd_scsi_probe_with_cache
2982 *
2983 * Description: This routine implements support for a scsi device probe
2984 * with cache. The driver maintains a cache of the target
2985 * responses to scsi probes. If we get no response from a
2986 * target during a probe inquiry, we remember that, and we
2987 * avoid additional calls to scsi_probe on non-zero LUNs
2988 * on the same target until the cache is cleared. By doing
2989 * so we avoid the 1/4 sec selection timeout for nonzero
2990 * LUNs. lun0 of a target is always probed.
2991 *
2992 * Arguments: devp - Pointer to a scsi_device(9S) structure
2993 * waitfunc - indicates what the allocator routines should
2994 * do when resources are not available. This value
2995 * is passed on to scsi_probe() when that routine
2996 * is called.
2997 *
2998 * Return Code: SCSIPROBE_NORESP if a NORESP in probe response cache;
2999 * otherwise the value returned by scsi_probe(9F).
3000 *
3001 * Context: Kernel thread context
3002 */
3003
3004 static int
3005 sd_scsi_probe_with_cache(struct scsi_device *devp, int (*waitfn)())
3006 {
3007 struct sd_scsi_probe_cache *cp;
3008 dev_info_t *pdip = ddi_get_parent(devp->sd_dev);
3009 int lun, tgt;
3010
3011 lun = ddi_prop_get_int(DDI_DEV_T_ANY, devp->sd_dev, DDI_PROP_DONTPASS,
3012 SCSI_ADDR_PROP_LUN, 0);
3013 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, devp->sd_dev, DDI_PROP_DONTPASS,
3014 SCSI_ADDR_PROP_TARGET, -1);
3015
3016 /* Make sure caching enabled and target in range */
3017 if ((tgt < 0) || (tgt >= NTARGETS_WIDE)) {
3018 /* do it the old way (no cache) */
3019 return (scsi_probe(devp, waitfn));
3020 }
3021
3022 mutex_enter(&sd_scsi_probe_cache_mutex);
3023
3024 /* Find the cache for this scsi bus instance */
3025 for (cp = sd_scsi_probe_cache_head; cp != NULL; cp = cp->next) {
3026 if (cp->pdip == pdip) {
3027 break;
3028 }
3029 }
3030
3031 /* If we can't find a cache for this pdip, create one */
3032 if (cp == NULL) {
3033 int i;
3034
3035 cp = kmem_zalloc(sizeof (struct sd_scsi_probe_cache),
3036 KM_SLEEP);
3037 cp->pdip = pdip;
3038 cp->next = sd_scsi_probe_cache_head;
3039 sd_scsi_probe_cache_head = cp;
3040 for (i = 0; i < NTARGETS_WIDE; i++) {
3041 cp->cache[i] = SCSIPROBE_EXISTS;
3042 }
3043 }
3044
3045 mutex_exit(&sd_scsi_probe_cache_mutex);
3046
3047 /* Recompute the cache for this target if LUN zero */
3048 if (lun == 0) {
3049 cp->cache[tgt] = SCSIPROBE_EXISTS;
3050 }
3051
3052 /* Don't probe if cache remembers a NORESP from a previous LUN. */
3053 if (cp->cache[tgt] != SCSIPROBE_EXISTS) {
3054 return (SCSIPROBE_NORESP);
3055 }
3056
3057 /* Do the actual probe; save & return the result */
3058 return (cp->cache[tgt] = scsi_probe(devp, waitfn));
3059 }
3060
3061
3062 /*
3063 * Function: sd_scsi_target_lun_init
3064 *
3065 * Description: Initializes the attached lun chain mutex and head pointer.
3066 *
3067 * Context: Kernel thread context
3068 */
3069
3070 static void
3071 sd_scsi_target_lun_init(void)
3072 {
3073 mutex_init(&sd_scsi_target_lun_mutex, NULL, MUTEX_DRIVER, NULL);
3074 sd_scsi_target_lun_head = NULL;
3075 }
3076
3077
3078 /*
3079 * Function: sd_scsi_target_lun_fini
3080 *
3081 * Description: Frees all resources associated with the attached lun
3082 * chain
3083 *
3084 * Context: Kernel thread context
3085 */
3086
3087 static void
3088 sd_scsi_target_lun_fini(void)
3089 {
3090 struct sd_scsi_hba_tgt_lun *cp;
3091 struct sd_scsi_hba_tgt_lun *ncp;
3092
3093 for (cp = sd_scsi_target_lun_head; cp != NULL; cp = ncp) {
3094 ncp = cp->next;
3095 kmem_free(cp, sizeof (struct sd_scsi_hba_tgt_lun));
3096 }
3097 sd_scsi_target_lun_head = NULL;
3098 mutex_destroy(&sd_scsi_target_lun_mutex);
3099 }
3100
3101
3102 /*
3103 * Function: sd_scsi_get_target_lun_count
3104 *
3105 * Description: This routine will check in the attached lun chain to see
3106 * how many luns are attached on the required SCSI controller
3107 * and target. Currently, some capabilities like tagged queue
3108 * are supported per target based by HBA. So all luns in a
3109 * target have the same capabilities. Based on this assumption,
3110 * sd should only set these capabilities once per target. This
3111 * function is called when sd needs to decide how many luns
3112 * already attached on a target.
3113 *
3114 * Arguments: dip - Pointer to the system's dev_info_t for the SCSI
3115 * controller device.
3116 * target - The target ID on the controller's SCSI bus.
3117 *
3118 * Return Code: The number of luns attached on the required target and
3119 * controller.
3120 * -1 if target ID is not in parallel SCSI scope or the given
3121 * dip is not in the chain.
3122 *
3123 * Context: Kernel thread context
3124 */
3125
3126 static int
3127 sd_scsi_get_target_lun_count(dev_info_t *dip, int target)
3128 {
3129 struct sd_scsi_hba_tgt_lun *cp;
3130
3131 if ((target < 0) || (target >= NTARGETS_WIDE)) {
3132 return (-1);
3133 }
3134
3135 mutex_enter(&sd_scsi_target_lun_mutex);
3136
3137 for (cp = sd_scsi_target_lun_head; cp != NULL; cp = cp->next) {
3138 if (cp->pdip == dip) {
3139 break;
3140 }
3141 }
3142
3143 mutex_exit(&sd_scsi_target_lun_mutex);
3144
3145 if (cp == NULL) {
3146 return (-1);
3147 }
3148
3149 return (cp->nlun[target]);
3150 }
3151
3152
3153 /*
3154 * Function: sd_scsi_update_lun_on_target
3155 *
3156 * Description: This routine is used to update the attached lun chain when a
3157 * lun is attached or detached on a target.
3158 *
3159 * Arguments: dip - Pointer to the system's dev_info_t for the SCSI
3160 * controller device.
3161 * target - The target ID on the controller's SCSI bus.
3162 * flag - Indicate the lun is attached or detached.
3163 *
3164 * Context: Kernel thread context
3165 */
3166
3167 static void
3168 sd_scsi_update_lun_on_target(dev_info_t *dip, int target, int flag)
3169 {
3170 struct sd_scsi_hba_tgt_lun *cp;
3171
3172 mutex_enter(&sd_scsi_target_lun_mutex);
3173
3174 for (cp = sd_scsi_target_lun_head; cp != NULL; cp = cp->next) {
3175 if (cp->pdip == dip) {
3176 break;
3177 }
3178 }
3179
3180 if ((cp == NULL) && (flag == SD_SCSI_LUN_ATTACH)) {
3181 cp = kmem_zalloc(sizeof (struct sd_scsi_hba_tgt_lun),
3182 KM_SLEEP);
3183 cp->pdip = dip;
3184 cp->next = sd_scsi_target_lun_head;
3185 sd_scsi_target_lun_head = cp;
3186 }
3187
3188 mutex_exit(&sd_scsi_target_lun_mutex);
3189
3190 if (cp != NULL) {
3191 if (flag == SD_SCSI_LUN_ATTACH) {
3192 cp->nlun[target] ++;
3193 } else {
3194 cp->nlun[target] --;
3195 }
3196 }
3197 }
3198
3199
3200 /*
3201 * Function: sd_spin_up_unit
3202 *
3203 * Description: Issues the following commands to spin-up the device:
3204 * START STOP UNIT, and INQUIRY.
3205 *
3206 * Arguments: ssc - ssc contains pointer to driver soft state (unit)
3207 * structure for this target.
3208 *
3209 * Return Code: 0 - success
3210 * EIO - failure
3211 * EACCES - reservation conflict
3212 *
3213 * Context: Kernel thread context
3214 */
3215
3216 static int
3217 sd_spin_up_unit(sd_ssc_t *ssc)
3218 {
3219 size_t resid = 0;
3220 int has_conflict = FALSE;
3221 uchar_t *bufaddr;
3222 int status;
3223 struct sd_lun *un;
3224
3225 ASSERT(ssc != NULL);
3226 un = ssc->ssc_un;
3227 ASSERT(un != NULL);
3228
3229 /*
3230 * Send a throwaway START UNIT command.
3231 *
3232 * If we fail on this, we don't care presently what precisely
3233 * is wrong. EMC's arrays will also fail this with a check
3234 * condition (0x2/0x4/0x3) if the device is "inactive," but
3235 * we don't want to fail the attach because it may become
3236 * "active" later.
3237 * We don't know if power condition is supported or not at
3238 * this stage, use START STOP bit.
3239 */
3240 status = sd_send_scsi_START_STOP_UNIT(ssc, SD_START_STOP,
3241 SD_TARGET_START, SD_PATH_DIRECT);
3242
3243 if (status != 0) {
3244 if (status == EACCES)
3245 has_conflict = TRUE;
3246 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
3247 }
3248
3249 /*
3250 * Send another INQUIRY command to the target. This is necessary for
3251 * non-removable media direct access devices because their INQUIRY data
3252 * may not be fully qualified until they are spun up (perhaps via the
3253 * START command above). Note: This seems to be needed for some
3254 * legacy devices only.) The INQUIRY command should succeed even if a
3255 * Reservation Conflict is present.
3256 */
3257 bufaddr = kmem_zalloc(SUN_INQSIZE, KM_SLEEP);
3258
3259 if (sd_send_scsi_INQUIRY(ssc, bufaddr, SUN_INQSIZE, 0, 0, &resid)
3260 != 0) {
3261 kmem_free(bufaddr, SUN_INQSIZE);
3262 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
3263 return (EIO);
3264 }
3265
3266 /*
3267 * If we got enough INQUIRY data, copy it over the old INQUIRY data.
3268 * Note that this routine does not return a failure here even if the
3269 * INQUIRY command did not return any data. This is a legacy behavior.
3270 */
3271 if ((SUN_INQSIZE - resid) >= SUN_MIN_INQLEN) {
3272 bcopy(bufaddr, SD_INQUIRY(un), SUN_INQSIZE);
3273 }
3274
3275 kmem_free(bufaddr, SUN_INQSIZE);
3276
3277 /* If we hit a reservation conflict above, tell the caller. */
3278 if (has_conflict == TRUE) {
3279 return (EACCES);
3280 }
3281
3282 return (0);
3283 }
3284
3285 #ifdef _LP64
3286 /*
3287 * Function: sd_enable_descr_sense
3288 *
3289 * Description: This routine attempts to select descriptor sense format
3290 * using the Control mode page. Devices that support 64 bit
3291 * LBAs (for >2TB luns) should also implement descriptor
3292 * sense data so we will call this function whenever we see
3293 * a lun larger than 2TB. If for some reason the device
3294 * supports 64 bit LBAs but doesn't support descriptor sense
3295 * presumably the mode select will fail. Everything will
3296 * continue to work normally except that we will not get
3297 * complete sense data for commands that fail with an LBA
3298 * larger than 32 bits.
3299 *
3300 * Arguments: ssc - ssc contains pointer to driver soft state (unit)
3301 * structure for this target.
3302 *
3303 * Context: Kernel thread context only
3304 */
3305
3306 static void
3307 sd_enable_descr_sense(sd_ssc_t *ssc)
3308 {
3309 uchar_t *header;
3310 struct mode_control_scsi3 *ctrl_bufp;
3311 size_t buflen;
3312 size_t bd_len;
3313 int status;
3314 struct sd_lun *un;
3315
3316 ASSERT(ssc != NULL);
3317 un = ssc->ssc_un;
3318 ASSERT(un != NULL);
3319
3320 /*
3321 * Read MODE SENSE page 0xA, Control Mode Page
3322 */
3323 buflen = MODE_HEADER_LENGTH + MODE_BLK_DESC_LENGTH +
3324 sizeof (struct mode_control_scsi3);
3325 header = kmem_zalloc(buflen, KM_SLEEP);
3326
3327 status = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP0, header, buflen,
3328 MODEPAGE_CTRL_MODE, SD_PATH_DIRECT);
3329
3330 if (status != 0) {
3331 SD_ERROR(SD_LOG_COMMON, un,
3332 "sd_enable_descr_sense: mode sense ctrl page failed\n");
3333 goto eds_exit;
3334 }
3335
3336 /*
3337 * Determine size of Block Descriptors in order to locate
3338 * the mode page data. ATAPI devices return 0, SCSI devices
3339 * should return MODE_BLK_DESC_LENGTH.
3340 */
3341 bd_len = ((struct mode_header *)header)->bdesc_length;
3342
3343 /* Clear the mode data length field for MODE SELECT */
3344 ((struct mode_header *)header)->length = 0;
3345
3346 ctrl_bufp = (struct mode_control_scsi3 *)
3347 (header + MODE_HEADER_LENGTH + bd_len);
3348
3349 /*
3350 * If the page length is smaller than the expected value,
3351 * the target device doesn't support D_SENSE. Bail out here.
3352 */
3353 if (ctrl_bufp->mode_page.length <
3354 sizeof (struct mode_control_scsi3) - 2) {
3355 SD_ERROR(SD_LOG_COMMON, un,
3356 "sd_enable_descr_sense: enable D_SENSE failed\n");
3357 goto eds_exit;
3358 }
3359
3360 /*
3361 * Clear PS bit for MODE SELECT
3362 */
3363 ctrl_bufp->mode_page.ps = 0;
3364
3365 /*
3366 * Set D_SENSE to enable descriptor sense format.
3367 */
3368 ctrl_bufp->d_sense = 1;
3369
3370 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
3371
3372 /*
3373 * Use MODE SELECT to commit the change to the D_SENSE bit
3374 */
3375 status = sd_send_scsi_MODE_SELECT(ssc, CDB_GROUP0, header,
3376 buflen, SD_DONTSAVE_PAGE, SD_PATH_DIRECT);
3377
3378 if (status != 0) {
3379 SD_INFO(SD_LOG_COMMON, un,
3380 "sd_enable_descr_sense: mode select ctrl page failed\n");
3381 } else {
3382 kmem_free(header, buflen);
3383 return;
3384 }
3385
3386 eds_exit:
3387 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
3388 kmem_free(header, buflen);
3389 }
3390
3391 /*
3392 * Function: sd_reenable_dsense_task
3393 *
3394 * Description: Re-enable descriptor sense after device or bus reset
3395 *
3396 * Context: Executes in a taskq() thread context
3397 */
3398 static void
3399 sd_reenable_dsense_task(void *arg)
3400 {
3401 struct sd_lun *un = arg;
3402 sd_ssc_t *ssc;
3403
3404 ASSERT(un != NULL);
3405
3406 ssc = sd_ssc_init(un);
3407 sd_enable_descr_sense(ssc);
3408 sd_ssc_fini(ssc);
3409 }
3410 #endif /* _LP64 */
3411
3412 /*
3413 * Function: sd_set_mmc_caps
3414 *
3415 * Description: This routine determines if the device is MMC compliant and if
3416 * the device supports CDDA via a mode sense of the CDVD
3417 * capabilities mode page. Also checks if the device is a
3418 * dvdram writable device.
3419 *
3420 * Arguments: ssc - ssc contains pointer to driver soft state (unit)
3421 * structure for this target.
3422 *
3423 * Context: Kernel thread context only
3424 */
3425
3426 static void
3427 sd_set_mmc_caps(sd_ssc_t *ssc)
3428 {
3429 struct mode_header_grp2 *sense_mhp;
3430 uchar_t *sense_page;
3431 caddr_t buf;
3432 int bd_len;
3433 int status;
3434 struct uscsi_cmd com;
3435 int rtn;
3436 uchar_t *out_data_rw, *out_data_hd;
3437 uchar_t *rqbuf_rw, *rqbuf_hd;
3438 uchar_t *out_data_gesn;
3439 int gesn_len;
3440 struct sd_lun *un;
3441
3442 ASSERT(ssc != NULL);
3443 un = ssc->ssc_un;
3444 ASSERT(un != NULL);
3445
3446 /*
3447 * The flags which will be set in this function are - mmc compliant,
3448 * dvdram writable device, cdda support. Initialize them to FALSE
3449 * and if a capability is detected - it will be set to TRUE.
3450 */
3451 un->un_f_mmc_cap = FALSE;
3452 un->un_f_dvdram_writable_device = FALSE;
3453 un->un_f_cfg_cdda = FALSE;
3454
3455 buf = kmem_zalloc(BUFLEN_MODE_CDROM_CAP, KM_SLEEP);
3456 status = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP1, (uchar_t *)buf,
3457 BUFLEN_MODE_CDROM_CAP, MODEPAGE_CDROM_CAP, SD_PATH_DIRECT);
3458
3459 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
3460
3461 if (status != 0) {
3462 /* command failed; just return */
3463 kmem_free(buf, BUFLEN_MODE_CDROM_CAP);
3464 return;
3465 }
3466 /*
3467 * If the mode sense request for the CDROM CAPABILITIES
3468 * page (0x2A) succeeds the device is assumed to be MMC.
3469 */
3470 un->un_f_mmc_cap = TRUE;
3471
3472 /* See if GET STATUS EVENT NOTIFICATION is supported */
3473 if (un->un_f_mmc_gesn_polling) {
3474 gesn_len = SD_GESN_HEADER_LEN + SD_GESN_MEDIA_DATA_LEN;
3475 out_data_gesn = kmem_zalloc(gesn_len, KM_SLEEP);
3476
3477 rtn = sd_send_scsi_GET_EVENT_STATUS_NOTIFICATION(ssc,
3478 out_data_gesn, gesn_len, 1 << SD_GESN_MEDIA_CLASS);
3479
3480 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
3481
3482 if ((rtn != 0) || !sd_gesn_media_data_valid(out_data_gesn)) {
3483 un->un_f_mmc_gesn_polling = FALSE;
3484 SD_INFO(SD_LOG_ATTACH_DETACH, un,
3485 "sd_set_mmc_caps: gesn not supported "
3486 "%d %x %x %x %x\n", rtn,
3487 out_data_gesn[0], out_data_gesn[1],
3488 out_data_gesn[2], out_data_gesn[3]);
3489 }
3490
3491 kmem_free(out_data_gesn, gesn_len);
3492 }
3493
3494 /* Get to the page data */
3495 sense_mhp = (struct mode_header_grp2 *)buf;
3496 bd_len = (sense_mhp->bdesc_length_hi << 8) |
3497 sense_mhp->bdesc_length_lo;
3498 if (bd_len > MODE_BLK_DESC_LENGTH) {
3499 /*
3500 * We did not get back the expected block descriptor
3501 * length so we cannot determine if the device supports
3502 * CDDA. However, we still indicate the device is MMC
3503 * according to the successful response to the page
3504 * 0x2A mode sense request.
3505 */
3506 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
3507 "sd_set_mmc_caps: Mode Sense returned "
3508 "invalid block descriptor length\n");
3509 kmem_free(buf, BUFLEN_MODE_CDROM_CAP);
3510 return;
3511 }
3512
3513 /* See if read CDDA is supported */
3514 sense_page = (uchar_t *)(buf + MODE_HEADER_LENGTH_GRP2 +
3515 bd_len);
3516 un->un_f_cfg_cdda = (sense_page[5] & 0x01) ? TRUE : FALSE;
3517
3518 /* See if writing DVD RAM is supported. */
3519 un->un_f_dvdram_writable_device = (sense_page[3] & 0x20) ? TRUE : FALSE;
3520 if (un->un_f_dvdram_writable_device == TRUE) {
3521 kmem_free(buf, BUFLEN_MODE_CDROM_CAP);
3522 return;
3523 }
3524
3525 /*
3526 * If the device presents DVD or CD capabilities in the mode
3527 * page, we can return here since a RRD will not have
3528 * these capabilities.
3529 */
3530 if ((sense_page[2] & 0x3f) || (sense_page[3] & 0x3f)) {
3531 kmem_free(buf, BUFLEN_MODE_CDROM_CAP);
3532 return;
3533 }
3534 kmem_free(buf, BUFLEN_MODE_CDROM_CAP);
3535
3536 /*
3537 * If un->un_f_dvdram_writable_device is still FALSE,
3538 * check for a Removable Rigid Disk (RRD). A RRD
3539 * device is identified by the features RANDOM_WRITABLE and
3540 * HARDWARE_DEFECT_MANAGEMENT.
3541 */
3542 out_data_rw = kmem_zalloc(SD_CURRENT_FEATURE_LEN, KM_SLEEP);
3543 rqbuf_rw = kmem_zalloc(SENSE_LENGTH, KM_SLEEP);
3544
3545 rtn = sd_send_scsi_feature_GET_CONFIGURATION(ssc, &com, rqbuf_rw,
3546 SENSE_LENGTH, out_data_rw, SD_CURRENT_FEATURE_LEN,
3547 RANDOM_WRITABLE, SD_PATH_STANDARD);
3548
3549 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
3550
3551 if (rtn != 0) {
3552 kmem_free(out_data_rw, SD_CURRENT_FEATURE_LEN);
3553 kmem_free(rqbuf_rw, SENSE_LENGTH);
3554 return;
3555 }
3556
3557 out_data_hd = kmem_zalloc(SD_CURRENT_FEATURE_LEN, KM_SLEEP);
3558 rqbuf_hd = kmem_zalloc(SENSE_LENGTH, KM_SLEEP);
3559
3560 rtn = sd_send_scsi_feature_GET_CONFIGURATION(ssc, &com, rqbuf_hd,
3561 SENSE_LENGTH, out_data_hd, SD_CURRENT_FEATURE_LEN,
3562 HARDWARE_DEFECT_MANAGEMENT, SD_PATH_STANDARD);
3563
3564 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
3565
3566 if (rtn == 0) {
3567 /*
3568 * We have good information, check for random writable
3569 * and hardware defect features.
3570 */
3571 if ((out_data_rw[9] & RANDOM_WRITABLE) &&
3572 (out_data_hd[9] & HARDWARE_DEFECT_MANAGEMENT)) {
3573 un->un_f_dvdram_writable_device = TRUE;
3574 }
3575 }
3576
3577 kmem_free(out_data_rw, SD_CURRENT_FEATURE_LEN);
3578 kmem_free(rqbuf_rw, SENSE_LENGTH);
3579 kmem_free(out_data_hd, SD_CURRENT_FEATURE_LEN);
3580 kmem_free(rqbuf_hd, SENSE_LENGTH);
3581 }
3582
3583 /*
3584 * Function: sd_check_for_writable_cd
3585 *
3586 * Description: This routine determines if the media in the device is
3587 * writable or not. It uses the get configuration command (0x46)
3588 * to determine if the media is writable
3589 *
3590 * Arguments: un - driver soft state (unit) structure
3591 * path_flag - SD_PATH_DIRECT to use the USCSI "direct"
3592 * chain and the normal command waitq, or
3593 * SD_PATH_DIRECT_PRIORITY to use the USCSI
3594 * "direct" chain and bypass the normal command
3595 * waitq.
3596 *
3597 * Context: Never called at interrupt context.
3598 */
3599
3600 static void
3601 sd_check_for_writable_cd(sd_ssc_t *ssc, int path_flag)
3602 {
3603 struct uscsi_cmd com;
3604 uchar_t *out_data;
3605 uchar_t *rqbuf;
3606 int rtn;
3607 uchar_t *out_data_rw, *out_data_hd;
3608 uchar_t *rqbuf_rw, *rqbuf_hd;
3609 struct mode_header_grp2 *sense_mhp;
3610 uchar_t *sense_page;
3611 caddr_t buf;
3612 int bd_len;
3613 int status;
3614 struct sd_lun *un;
3615
3616 ASSERT(ssc != NULL);
3617 un = ssc->ssc_un;
3618 ASSERT(un != NULL);
3619 ASSERT(mutex_owned(SD_MUTEX(un)));
3620
3621 /*
3622 * Initialize the writable media to false, if configuration info.
3623 * tells us otherwise then only we will set it.
3624 */
3625 un->un_f_mmc_writable_media = FALSE;
3626 mutex_exit(SD_MUTEX(un));
3627
3628 out_data = kmem_zalloc(SD_PROFILE_HEADER_LEN, KM_SLEEP);
3629 rqbuf = kmem_zalloc(SENSE_LENGTH, KM_SLEEP);
3630
3631 rtn = sd_send_scsi_GET_CONFIGURATION(ssc, &com, rqbuf, SENSE_LENGTH,
3632 out_data, SD_PROFILE_HEADER_LEN, path_flag);
3633
3634 if (rtn != 0)
3635 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
3636
3637 mutex_enter(SD_MUTEX(un));
3638 if (rtn == 0) {
3639 /*
3640 * We have good information, check for writable DVD.
3641 */
3642 if ((out_data[6] == 0) && (out_data[7] == 0x12)) {
3643 un->un_f_mmc_writable_media = TRUE;
3644 kmem_free(out_data, SD_PROFILE_HEADER_LEN);
3645 kmem_free(rqbuf, SENSE_LENGTH);
3646 return;
3647 }
3648 }
3649
3650 kmem_free(out_data, SD_PROFILE_HEADER_LEN);
3651 kmem_free(rqbuf, SENSE_LENGTH);
3652
3653 /*
3654 * Determine if this is a RRD type device.
3655 */
3656 mutex_exit(SD_MUTEX(un));
3657 buf = kmem_zalloc(BUFLEN_MODE_CDROM_CAP, KM_SLEEP);
3658 status = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP1, (uchar_t *)buf,
3659 BUFLEN_MODE_CDROM_CAP, MODEPAGE_CDROM_CAP, path_flag);
3660
3661 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
3662
3663 mutex_enter(SD_MUTEX(un));
3664 if (status != 0) {
3665 /* command failed; just return */
3666 kmem_free(buf, BUFLEN_MODE_CDROM_CAP);
3667 return;
3668 }
3669
3670 /* Get to the page data */
3671 sense_mhp = (struct mode_header_grp2 *)buf;
3672 bd_len = (sense_mhp->bdesc_length_hi << 8) | sense_mhp->bdesc_length_lo;
3673 if (bd_len > MODE_BLK_DESC_LENGTH) {
3674 /*
3675 * We did not get back the expected block descriptor length so
3676 * we cannot check the mode page.
3677 */
3678 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
3679 "sd_check_for_writable_cd: Mode Sense returned "
3680 "invalid block descriptor length\n");
3681 kmem_free(buf, BUFLEN_MODE_CDROM_CAP);
3682 return;
3683 }
3684
3685 /*
3686 * If the device presents DVD or CD capabilities in the mode
3687 * page, we can return here since a RRD device will not have
3688 * these capabilities.
3689 */
3690 sense_page = (uchar_t *)(buf + MODE_HEADER_LENGTH_GRP2 + bd_len);
3691 if ((sense_page[2] & 0x3f) || (sense_page[3] & 0x3f)) {
3692 kmem_free(buf, BUFLEN_MODE_CDROM_CAP);
3693 return;
3694 }
3695 kmem_free(buf, BUFLEN_MODE_CDROM_CAP);
3696
3697 /*
3698 * If un->un_f_mmc_writable_media is still FALSE,
3699 * check for RRD type media. A RRD device is identified
3700 * by the features RANDOM_WRITABLE and HARDWARE_DEFECT_MANAGEMENT.
3701 */
3702 mutex_exit(SD_MUTEX(un));
3703 out_data_rw = kmem_zalloc(SD_CURRENT_FEATURE_LEN, KM_SLEEP);
3704 rqbuf_rw = kmem_zalloc(SENSE_LENGTH, KM_SLEEP);
3705
3706 rtn = sd_send_scsi_feature_GET_CONFIGURATION(ssc, &com, rqbuf_rw,
3707 SENSE_LENGTH, out_data_rw, SD_CURRENT_FEATURE_LEN,
3708 RANDOM_WRITABLE, path_flag);
3709
3710 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
3711 if (rtn != 0) {
3712 kmem_free(out_data_rw, SD_CURRENT_FEATURE_LEN);
3713 kmem_free(rqbuf_rw, SENSE_LENGTH);
3714 mutex_enter(SD_MUTEX(un));
3715 return;
3716 }
3717
3718 out_data_hd = kmem_zalloc(SD_CURRENT_FEATURE_LEN, KM_SLEEP);
3719 rqbuf_hd = kmem_zalloc(SENSE_LENGTH, KM_SLEEP);
3720
3721 rtn = sd_send_scsi_feature_GET_CONFIGURATION(ssc, &com, rqbuf_hd,
3722 SENSE_LENGTH, out_data_hd, SD_CURRENT_FEATURE_LEN,
3723 HARDWARE_DEFECT_MANAGEMENT, path_flag);
3724
3725 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
3726 mutex_enter(SD_MUTEX(un));
3727 if (rtn == 0) {
3728 /*
3729 * We have good information, check for random writable
3730 * and hardware defect features as current.
3731 */
3732 if ((out_data_rw[9] & RANDOM_WRITABLE) &&
3733 (out_data_rw[10] & 0x1) &&
3734 (out_data_hd[9] & HARDWARE_DEFECT_MANAGEMENT) &&
3735 (out_data_hd[10] & 0x1)) {
3736 un->un_f_mmc_writable_media = TRUE;
3737 }
3738 }
3739
3740 kmem_free(out_data_rw, SD_CURRENT_FEATURE_LEN);
3741 kmem_free(rqbuf_rw, SENSE_LENGTH);
3742 kmem_free(out_data_hd, SD_CURRENT_FEATURE_LEN);
3743 kmem_free(rqbuf_hd, SENSE_LENGTH);
3744 }
3745
3746 /*
3747 * Function: sd_read_unit_properties
3748 *
3749 * Description: The following implements a property lookup mechanism.
3750 * Properties for particular disks (keyed on vendor, model
3751 * and rev numbers) are sought in the sd.conf file via
3752 * sd_process_sdconf_file(), and if not found there, are
3753 * looked for in a list hardcoded in this driver via
3754 * sd_process_sdconf_table() Once located the properties
3755 * are used to update the driver unit structure.
3756 *
3757 * Arguments: un - driver soft state (unit) structure
3758 */
3759
3760 static void
3761 sd_read_unit_properties(struct sd_lun *un)
3762 {
3763 /*
3764 * sd_process_sdconf_file returns SD_FAILURE if it cannot find
3765 * the "sd-config-list" property (from the sd.conf file) or if
3766 * there was not a match for the inquiry vid/pid. If this event
3767 * occurs the static driver configuration table is searched for
3768 * a match.
3769 */
3770 ASSERT(un != NULL);
3771 if (sd_process_sdconf_file(un) == SD_FAILURE) {
3772 sd_process_sdconf_table(un);
3773 }
3774
3775 /* check for LSI device */
3776 sd_is_lsi(un);
3777
3778
3779 }
3780
3781
3782 /*
3783 * Function: sd_process_sdconf_file
3784 *
3785 * Description: Use ddi_prop_lookup(9F) to obtain the properties from the
3786 * driver's config file (ie, sd.conf) and update the driver
3787 * soft state structure accordingly.
3788 *
3789 * Arguments: un - driver soft state (unit) structure
3790 *
3791 * Return Code: SD_SUCCESS - The properties were successfully set according
3792 * to the driver configuration file.
3793 * SD_FAILURE - The driver config list was not obtained or
3794 * there was no vid/pid match. This indicates that
3795 * the static config table should be used.
3796 *
3797 * The config file has a property, "sd-config-list". Currently we support
3798 * two kinds of formats. For both formats, the value of this property
3799 * is a list of duplets:
3800 *
3801 * sd-config-list=
3802 * <duplet>,
3803 * [,<duplet>]*;
3804 *
3805 * For the improved format, where
3806 *
3807 * <duplet>:= "<vid+pid>","<tunable-list>"
3808 *
3809 * and
3810 *
3811 * <tunable-list>:= <tunable> [, <tunable> ]*;
3812 * <tunable> = <name> : <value>
3813 *
3814 * The <vid+pid> is the string that is returned by the target device on a
3815 * SCSI inquiry command, the <tunable-list> contains one or more tunables
3816 * to apply to all target devices with the specified <vid+pid>.
3817 *
3818 * Each <tunable> is a "<name> : <value>" pair.
3819 *
3820 * For the old format, the structure of each duplet is as follows:
3821 *
3822 * <duplet>:= "<vid+pid>","<data-property-name_list>"
3823 *
3824 * The first entry of the duplet is the device ID string (the concatenated
3825 * vid & pid; not to be confused with a device_id). This is defined in
3826 * the same way as in the sd_disk_table.
3827 *
3828 * The second part of the duplet is a string that identifies a
3829 * data-property-name-list. The data-property-name-list is defined as
3830 * follows:
3831 *
3832 * <data-property-name-list>:=<data-property-name> [<data-property-name>]
3833 *
3834 * The syntax of <data-property-name> depends on the <version> field.
3835 *
3836 * If version = SD_CONF_VERSION_1 we have the following syntax:
3837 *
3838 * <data-property-name>:=<version>,<flags>,<prop0>,<prop1>,.....<propN>
3839 *
3840 * where the prop0 value will be used to set prop0 if bit0 set in the
3841 * flags, prop1 if bit1 set, etc. and N = SD_CONF_MAX_ITEMS -1
3842 *
3843 */
3844
3845 static int
3846 sd_process_sdconf_file(struct sd_lun *un)
3847 {
3848 char **config_list = NULL;
3849 uint_t nelements;
3850 char *vidptr;
3851 int vidlen;
3852 char *dnlist_ptr;
3853 char *dataname_ptr;
3854 char *dataname_lasts;
3855 int *data_list = NULL;
3856 uint_t data_list_len;
3857 int rval = SD_FAILURE;
3858 int i;
3859
3860 ASSERT(un != NULL);
3861
3862 /* Obtain the configuration list associated with the .conf file */
3863 if (ddi_prop_lookup_string_array(DDI_DEV_T_ANY, SD_DEVINFO(un),
3864 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, sd_config_list,
3865 &config_list, &nelements) != DDI_PROP_SUCCESS) {
3866 return (SD_FAILURE);
3867 }
3868
3869 /*
3870 * Compare vids in each duplet to the inquiry vid - if a match is
3871 * made, get the data value and update the soft state structure
3872 * accordingly.
3873 *
3874 * Each duplet should show as a pair of strings, return SD_FAILURE
3875 * otherwise.
3876 */
3877 if (nelements & 1) {
3878 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
3879 "sd-config-list should show as pairs of strings.\n");
3880 if (config_list)
3881 ddi_prop_free(config_list);
3882 return (SD_FAILURE);
3883 }
3884
3885 for (i = 0; i < nelements; i += 2) {
3886 /*
3887 * Note: The assumption here is that each vid entry is on
3888 * a unique line from its associated duplet.
3889 */
3890 vidptr = config_list[i];
3891 vidlen = (int)strlen(vidptr);
3892 if (sd_sdconf_id_match(un, vidptr, vidlen) != SD_SUCCESS) {
3893 continue;
3894 }
3895
3896 /*
3897 * dnlist contains 1 or more blank separated
3898 * data-property-name entries
3899 */
3900 dnlist_ptr = config_list[i + 1];
3901
3902 if (strchr(dnlist_ptr, ':') != NULL) {
3903 /*
3904 * Decode the improved format sd-config-list.
3905 */
3906 sd_nvpair_str_decode(un, dnlist_ptr);
3907 } else {
3908 /*
3909 * The old format sd-config-list, loop through all
3910 * data-property-name entries in the
3911 * data-property-name-list
3912 * setting the properties for each.
3913 */
3914 for (dataname_ptr = sd_strtok_r(dnlist_ptr, " \t",
3915 &dataname_lasts); dataname_ptr != NULL;
3916 dataname_ptr = sd_strtok_r(NULL, " \t",
3917 &dataname_lasts)) {
3918 int version;
3919
3920 SD_INFO(SD_LOG_ATTACH_DETACH, un,
3921 "sd_process_sdconf_file: disk:%s, "
3922 "data:%s\n", vidptr, dataname_ptr);
3923
3924 /* Get the data list */
3925 if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY,
3926 SD_DEVINFO(un), 0, dataname_ptr, &data_list,
3927 &data_list_len) != DDI_PROP_SUCCESS) {
3928 SD_INFO(SD_LOG_ATTACH_DETACH, un,
3929 "sd_process_sdconf_file: data "
3930 "property (%s) has no value\n",
3931 dataname_ptr);
3932 continue;
3933 }
3934
3935 version = data_list[0];
3936
3937 if (version == SD_CONF_VERSION_1) {
3938 sd_tunables values;
3939
3940 /* Set the properties */
3941 if (sd_chk_vers1_data(un, data_list[1],
3942 &data_list[2], data_list_len,
3943 dataname_ptr) == SD_SUCCESS) {
3944 sd_get_tunables_from_conf(un,
3945 data_list[1], &data_list[2],
3946 &values);
3947 sd_set_vers1_properties(un,
3948 data_list[1], &values);
3949 rval = SD_SUCCESS;
3950 } else {
3951 rval = SD_FAILURE;
3952 }
3953 } else {
3954 scsi_log(SD_DEVINFO(un), sd_label,
3955 CE_WARN, "data property %s version "
3956 "0x%x is invalid.",
3957 dataname_ptr, version);
3958 rval = SD_FAILURE;
3959 }
3960 if (data_list)
3961 ddi_prop_free(data_list);
3962 }
3963 }
3964 }
3965
3966 /* free up the memory allocated by ddi_prop_lookup_string_array(). */
3967 if (config_list) {
3968 ddi_prop_free(config_list);
3969 }
3970
3971 return (rval);
3972 }
3973
3974 /*
3975 * Function: sd_nvpair_str_decode()
3976 *
3977 * Description: Parse the improved format sd-config-list to get
3978 * each entry of tunable, which includes a name-value pair.
3979 * Then call sd_set_properties() to set the property.
3980 *
3981 * Arguments: un - driver soft state (unit) structure
3982 * nvpair_str - the tunable list
3983 */
3984 static void
3985 sd_nvpair_str_decode(struct sd_lun *un, char *nvpair_str)
3986 {
3987 char *nv, *name, *value, *token;
3988 char *nv_lasts, *v_lasts, *x_lasts;
3989
3990 for (nv = sd_strtok_r(nvpair_str, ",", &nv_lasts); nv != NULL;
3991 nv = sd_strtok_r(NULL, ",", &nv_lasts)) {
3992 token = sd_strtok_r(nv, ":", &v_lasts);
3993 name = sd_strtok_r(token, " \t", &x_lasts);
3994 token = sd_strtok_r(NULL, ":", &v_lasts);
3995 value = sd_strtok_r(token, " \t", &x_lasts);
3996 if (name == NULL || value == NULL) {
3997 SD_INFO(SD_LOG_ATTACH_DETACH, un,
3998 "sd_nvpair_str_decode: "
3999 "name or value is not valid!\n");
4000 } else {
4001 sd_set_properties(un, name, value);
4002 }
4003 }
4004 }
4005
4006 /*
4007 * Function: sd_strtok_r()
4008 *
4009 * Description: This function uses strpbrk and strspn to break
4010 * string into tokens on sequentially subsequent calls. Return
4011 * NULL when no non-separator characters remain. The first
4012 * argument is NULL for subsequent calls.
4013 */
4014 static char *
4015 sd_strtok_r(char *string, const char *sepset, char **lasts)
4016 {
4017 char *q, *r;
4018
4019 /* First or subsequent call */
4020 if (string == NULL)
4021 string = *lasts;
4022
4023 if (string == NULL)
4024 return (NULL);
4025
4026 /* Skip leading separators */
4027 q = string + strspn(string, sepset);
4028
4029 if (*q == '\0')
4030 return (NULL);
4031
4032 if ((r = strpbrk(q, sepset)) == NULL)
4033 *lasts = NULL;
4034 else {
4035 *r = '\0';
4036 *lasts = r + 1;
4037 }
4038 return (q);
4039 }
4040
4041 /*
4042 * Function: sd_set_properties()
4043 *
4044 * Description: Set device properties based on the improved
4045 * format sd-config-list.
4046 *
4047 * Arguments: un - driver soft state (unit) structure
4048 * name - supported tunable name
4049 * value - tunable value
4050 */
4051 static void
4052 sd_set_properties(struct sd_lun *un, char *name, char *value)
4053 {
4054 char *endptr = NULL;
4055 long val = 0;
4056
4057 if (strcasecmp(name, "cache-nonvolatile") == 0) {
4058 if (strcasecmp(value, "true") == 0) {
4059 un->un_f_suppress_cache_flush = TRUE;
4060 } else if (strcasecmp(value, "false") == 0) {
4061 un->un_f_suppress_cache_flush = FALSE;
4062 } else {
4063 goto value_invalid;
4064 }
4065 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4066 "suppress_cache_flush flag set to %d\n",
4067 un->un_f_suppress_cache_flush);
4068 return;
4069 }
4070
4071 if (strcasecmp(name, "controller-type") == 0) {
4072 if (ddi_strtol(value, &endptr, 0, &val) == 0) {
4073 un->un_ctype = val;
4074 } else {
4075 goto value_invalid;
4076 }
4077 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4078 "ctype set to %d\n", un->un_ctype);
4079 return;
4080 }
4081
4082 if (strcasecmp(name, "delay-busy") == 0) {
4083 if (ddi_strtol(value, &endptr, 0, &val) == 0) {
4084 un->un_busy_timeout = drv_usectohz(val / 1000);
4085 } else {
4086 goto value_invalid;
4087 }
4088 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4089 "busy_timeout set to %d\n", un->un_busy_timeout);
4090 return;
4091 }
4092
4093 if (strcasecmp(name, "disksort") == 0) {
4094 if (strcasecmp(value, "true") == 0) {
4095 un->un_f_disksort_disabled = FALSE;
4096 } else if (strcasecmp(value, "false") == 0) {
4097 un->un_f_disksort_disabled = TRUE;
4098 } else {
4099 goto value_invalid;
4100 }
4101 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4102 "disksort disabled flag set to %d\n",
4103 un->un_f_disksort_disabled);
4104 return;
4105 }
4106
4107 if (strcasecmp(name, "power-condition") == 0) {
4108 if (strcasecmp(value, "true") == 0) {
4109 un->un_f_power_condition_disabled = FALSE;
4110 } else if (strcasecmp(value, "false") == 0) {
4111 un->un_f_power_condition_disabled = TRUE;
4112 } else {
4113 goto value_invalid;
4114 }
4115 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4116 "power condition disabled flag set to %d\n",
4117 un->un_f_power_condition_disabled);
4118 return;
4119 }
4120
4121 if (strcasecmp(name, "timeout-releasereservation") == 0) {
4122 if (ddi_strtol(value, &endptr, 0, &val) == 0) {
4123 un->un_reserve_release_time = val;
4124 } else {
4125 goto value_invalid;
4126 }
4127 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4128 "reservation release timeout set to %d\n",
4129 un->un_reserve_release_time);
4130 return;
4131 }
4132
4133 if (strcasecmp(name, "reset-lun") == 0) {
4134 if (strcasecmp(value, "true") == 0) {
4135 un->un_f_lun_reset_enabled = TRUE;
4136 } else if (strcasecmp(value, "false") == 0) {
4137 un->un_f_lun_reset_enabled = FALSE;
4138 } else {
4139 goto value_invalid;
4140 }
4141 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4142 "lun reset enabled flag set to %d\n",
4143 un->un_f_lun_reset_enabled);
4144 return;
4145 }
4146
4147 if (strcasecmp(name, "retries-busy") == 0) {
4148 if (ddi_strtol(value, &endptr, 0, &val) == 0) {
4149 un->un_busy_retry_count = val;
4150 } else {
4151 goto value_invalid;
4152 }
4153 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4154 "busy retry count set to %d\n", un->un_busy_retry_count);
4155 return;
4156 }
4157
4158 if (strcasecmp(name, "retries-timeout") == 0) {
4159 if (ddi_strtol(value, &endptr, 0, &val) == 0) {
4160 un->un_retry_count = val;
4161 } else {
4162 goto value_invalid;
4163 }
4164 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4165 "timeout retry count set to %d\n", un->un_retry_count);
4166 return;
4167 }
4168
4169 if (strcasecmp(name, "retries-notready") == 0) {
4170 if (ddi_strtol(value, &endptr, 0, &val) == 0) {
4171 un->un_notready_retry_count = val;
4172 } else {
4173 goto value_invalid;
4174 }
4175 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4176 "notready retry count set to %d\n",
4177 un->un_notready_retry_count);
4178 return;
4179 }
4180
4181 if (strcasecmp(name, "retries-reset") == 0) {
4182 if (ddi_strtol(value, &endptr, 0, &val) == 0) {
4183 un->un_reset_retry_count = val;
4184 } else {
4185 goto value_invalid;
4186 }
4187 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4188 "reset retry count set to %d\n",
4189 un->un_reset_retry_count);
4190 return;
4191 }
4192
4193 if (strcasecmp(name, "throttle-max") == 0) {
4194 if (ddi_strtol(value, &endptr, 0, &val) == 0) {
4195 un->un_saved_throttle = un->un_throttle = val;
4196 } else {
4197 goto value_invalid;
4198 }
4199 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4200 "throttle set to %d\n", un->un_throttle);
4201 }
4202
4203 if (strcasecmp(name, "throttle-min") == 0) {
4204 if (ddi_strtol(value, &endptr, 0, &val) == 0) {
4205 un->un_min_throttle = val;
4206 } else {
4207 goto value_invalid;
4208 }
4209 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4210 "min throttle set to %d\n", un->un_min_throttle);
4211 }
4212
4213 if (strcasecmp(name, "rmw-type") == 0) {
4214 if (ddi_strtol(value, &endptr, 0, &val) == 0) {
4215 un->un_f_rmw_type = val;
4216 } else {
4217 goto value_invalid;
4218 }
4219 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4220 "RMW type set to %d\n", un->un_f_rmw_type);
4221 }
4222
4223 if (strcasecmp(name, "physical-block-size") == 0) {
4224 if (ddi_strtol(value, &endptr, 0, &val) == 0 &&
4225 ISP2(val) && val >= un->un_tgt_blocksize &&
4226 val >= un->un_sys_blocksize) {
4227 un->un_phy_blocksize = val;
4228 } else {
4229 goto value_invalid;
4230 }
4231 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4232 "physical block size set to %d\n", un->un_phy_blocksize);
4233 }
4234
4235 if (strcasecmp(name, "retries-victim") == 0) {
4236 if (ddi_strtol(value, &endptr, 0, &val) == 0) {
4237 un->un_victim_retry_count = val;
4238 } else {
4239 goto value_invalid;
4240 }
4241 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4242 "victim retry count set to %d\n",
4243 un->un_victim_retry_count);
4244 return;
4245 }
4246
4247 /*
4248 * Validate the throttle values.
4249 * If any of the numbers are invalid, set everything to defaults.
4250 */
4251 if ((un->un_throttle < SD_LOWEST_VALID_THROTTLE) ||
4252 (un->un_min_throttle < SD_LOWEST_VALID_THROTTLE) ||
4253 (un->un_min_throttle > un->un_throttle)) {
4254 un->un_saved_throttle = un->un_throttle = sd_max_throttle;
4255 un->un_min_throttle = sd_min_throttle;
4256 }
4257
4258 if (strcasecmp(name, "mmc-gesn-polling") == 0) {
4259 if (strcasecmp(value, "true") == 0) {
4260 un->un_f_mmc_gesn_polling = TRUE;
4261 } else if (strcasecmp(value, "false") == 0) {
4262 un->un_f_mmc_gesn_polling = FALSE;
4263 } else {
4264 goto value_invalid;
4265 }
4266 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4267 "mmc-gesn-polling set to %d\n",
4268 un->un_f_mmc_gesn_polling);
4269 }
4270
4271 return;
4272
4273 value_invalid:
4274 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4275 "value of prop %s is invalid\n", name);
4276 }
4277
4278 /*
4279 * Function: sd_get_tunables_from_conf()
4280 *
4281 *
4282 * This function reads the data list from the sd.conf file and pulls
4283 * the values that can have numeric values as arguments and places
4284 * the values in the appropriate sd_tunables member.
4285 * Since the order of the data list members varies across platforms
4286 * This function reads them from the data list in a platform specific
4287 * order and places them into the correct sd_tunable member that is
4288 * consistent across all platforms.
4289 */
4290 static void
4291 sd_get_tunables_from_conf(struct sd_lun *un, int flags, int *data_list,
4292 sd_tunables *values)
4293 {
4294 int i;
4295 int mask;
4296
4297 bzero(values, sizeof (sd_tunables));
4298
4299 for (i = 0; i < SD_CONF_MAX_ITEMS; i++) {
4300
4301 mask = 1 << i;
4302 if (mask > flags) {
4303 break;
4304 }
4305
4306 switch (mask & flags) {
4307 case 0: /* This mask bit not set in flags */
4308 continue;
4309 case SD_CONF_BSET_THROTTLE:
4310 values->sdt_throttle = data_list[i];
4311 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4312 "sd_get_tunables_from_conf: throttle = %d\n",
4313 values->sdt_throttle);
4314 break;
4315 case SD_CONF_BSET_CTYPE:
4316 values->sdt_ctype = data_list[i];
4317 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4318 "sd_get_tunables_from_conf: ctype = %d\n",
4319 values->sdt_ctype);
4320 break;
4321 case SD_CONF_BSET_NRR_COUNT:
4322 values->sdt_not_rdy_retries = data_list[i];
4323 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4324 "sd_get_tunables_from_conf: not_rdy_retries = %d\n",
4325 values->sdt_not_rdy_retries);
4326 break;
4327 case SD_CONF_BSET_BSY_RETRY_COUNT:
4328 values->sdt_busy_retries = data_list[i];
4329 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4330 "sd_get_tunables_from_conf: busy_retries = %d\n",
4331 values->sdt_busy_retries);
4332 break;
4333 case SD_CONF_BSET_RST_RETRIES:
4334 values->sdt_reset_retries = data_list[i];
4335 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4336 "sd_get_tunables_from_conf: reset_retries = %d\n",
4337 values->sdt_reset_retries);
4338 break;
4339 case SD_CONF_BSET_RSV_REL_TIME:
4340 values->sdt_reserv_rel_time = data_list[i];
4341 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4342 "sd_get_tunables_from_conf: reserv_rel_time = %d\n",
4343 values->sdt_reserv_rel_time);
4344 break;
4345 case SD_CONF_BSET_MIN_THROTTLE:
4346 values->sdt_min_throttle = data_list[i];
4347 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4348 "sd_get_tunables_from_conf: min_throttle = %d\n",
4349 values->sdt_min_throttle);
4350 break;
4351 case SD_CONF_BSET_DISKSORT_DISABLED:
4352 values->sdt_disk_sort_dis = data_list[i];
4353 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4354 "sd_get_tunables_from_conf: disk_sort_dis = %d\n",
4355 values->sdt_disk_sort_dis);
4356 break;
4357 case SD_CONF_BSET_LUN_RESET_ENABLED:
4358 values->sdt_lun_reset_enable = data_list[i];
4359 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4360 "sd_get_tunables_from_conf: lun_reset_enable = %d"
4361 "\n", values->sdt_lun_reset_enable);
4362 break;
4363 case SD_CONF_BSET_CACHE_IS_NV:
4364 values->sdt_suppress_cache_flush = data_list[i];
4365 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4366 "sd_get_tunables_from_conf: \
4367 suppress_cache_flush = %d"
4368 "\n", values->sdt_suppress_cache_flush);
4369 break;
4370 case SD_CONF_BSET_PC_DISABLED:
4371 values->sdt_disk_sort_dis = data_list[i];
4372 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4373 "sd_get_tunables_from_conf: power_condition_dis = "
4374 "%d\n", values->sdt_power_condition_dis);
4375 break;
4376 }
4377 }
4378 }
4379
4380 /*
4381 * Function: sd_process_sdconf_table
4382 *
4383 * Description: Search the static configuration table for a match on the
4384 * inquiry vid/pid and update the driver soft state structure
4385 * according to the table property values for the device.
4386 *
4387 * The form of a configuration table entry is:
4388 * <vid+pid>,<flags>,<property-data>
4389 * "SEAGATE ST42400N",1,0x40000,
4390 * 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1;
4391 *
4392 * Arguments: un - driver soft state (unit) structure
4393 */
4394
4395 static void
4396 sd_process_sdconf_table(struct sd_lun *un)
4397 {
4398 char *id = NULL;
4399 int table_index;
4400 int idlen;
4401
4402 ASSERT(un != NULL);
4403 for (table_index = 0; table_index < sd_disk_table_size;
4404 table_index++) {
4405 id = sd_disk_table[table_index].device_id;
4406 idlen = strlen(id);
4407
4408 /*
4409 * The static configuration table currently does not
4410 * implement version 10 properties. Additionally,
4411 * multiple data-property-name entries are not
4412 * implemented in the static configuration table.
4413 */
4414 if (sd_sdconf_id_match(un, id, idlen) == SD_SUCCESS) {
4415 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4416 "sd_process_sdconf_table: disk %s\n", id);
4417 sd_set_vers1_properties(un,
4418 sd_disk_table[table_index].flags,
4419 sd_disk_table[table_index].properties);
4420 break;
4421 }
4422 }
4423 }
4424
4425
4426 /*
4427 * Function: sd_sdconf_id_match
4428 *
4429 * Description: This local function implements a case sensitive vid/pid
4430 * comparison as well as the boundary cases of wild card and
4431 * multiple blanks.
4432 *
4433 * Note: An implicit assumption made here is that the scsi
4434 * inquiry structure will always keep the vid, pid and
4435 * revision strings in consecutive sequence, so they can be
4436 * read as a single string. If this assumption is not the
4437 * case, a separate string, to be used for the check, needs
4438 * to be built with these strings concatenated.
4439 *
4440 * Arguments: un - driver soft state (unit) structure
4441 * id - table or config file vid/pid
4442 * idlen - length of the vid/pid (bytes)
4443 *
4444 * Return Code: SD_SUCCESS - Indicates a match with the inquiry vid/pid
4445 * SD_FAILURE - Indicates no match with the inquiry vid/pid
4446 */
4447
4448 static int
4449 sd_sdconf_id_match(struct sd_lun *un, char *id, int idlen)
4450 {
4451 struct scsi_inquiry *sd_inq;
4452 int rval = SD_SUCCESS;
4453
4454 ASSERT(un != NULL);
4455 sd_inq = un->un_sd->sd_inq;
4456 ASSERT(id != NULL);
4457
4458 /*
4459 * We use the inq_vid as a pointer to a buffer containing the
4460 * vid and pid and use the entire vid/pid length of the table
4461 * entry for the comparison. This works because the inq_pid
4462 * data member follows inq_vid in the scsi_inquiry structure.
4463 */
4464 if (strncasecmp(sd_inq->inq_vid, id, idlen) != 0) {
4465 /*
4466 * The user id string is compared to the inquiry vid/pid
4467 * using a case insensitive comparison and ignoring
4468 * multiple spaces.
4469 */
4470 rval = sd_blank_cmp(un, id, idlen);
4471 if (rval != SD_SUCCESS) {
4472 /*
4473 * User id strings that start and end with a "*"
4474 * are a special case. These do not have a
4475 * specific vendor, and the product string can
4476 * appear anywhere in the 16 byte PID portion of
4477 * the inquiry data. This is a simple strstr()
4478 * type search for the user id in the inquiry data.
4479 */
4480 if ((id[0] == '*') && (id[idlen - 1] == '*')) {
4481 char *pidptr = &id[1];
4482 int i;
4483 int j;
4484 int pidstrlen = idlen - 2;
4485 j = sizeof (SD_INQUIRY(un)->inq_pid) -
4486 pidstrlen;
4487
4488 if (j < 0) {
4489 return (SD_FAILURE);
4490 }
4491 for (i = 0; i < j; i++) {
4492 if (bcmp(&SD_INQUIRY(un)->inq_pid[i],
4493 pidptr, pidstrlen) == 0) {
4494 rval = SD_SUCCESS;
4495 break;
4496 }
4497 }
4498 }
4499 }
4500 }
4501 return (rval);
4502 }
4503
4504
4505 /*
4506 * Function: sd_blank_cmp
4507 *
4508 * Description: If the id string starts and ends with a space, treat
4509 * multiple consecutive spaces as equivalent to a single
4510 * space. For example, this causes a sd_disk_table entry
4511 * of " NEC CDROM " to match a device's id string of
4512 * "NEC CDROM".
4513 *
4514 * Note: The success exit condition for this routine is if
4515 * the pointer to the table entry is '\0' and the cnt of
4516 * the inquiry length is zero. This will happen if the inquiry
4517 * string returned by the device is padded with spaces to be
4518 * exactly 24 bytes in length (8 byte vid + 16 byte pid). The
4519 * SCSI spec states that the inquiry string is to be padded with
4520 * spaces.
4521 *
4522 * Arguments: un - driver soft state (unit) structure
4523 * id - table or config file vid/pid
4524 * idlen - length of the vid/pid (bytes)
4525 *
4526 * Return Code: SD_SUCCESS - Indicates a match with the inquiry vid/pid
4527 * SD_FAILURE - Indicates no match with the inquiry vid/pid
4528 */
4529
4530 static int
4531 sd_blank_cmp(struct sd_lun *un, char *id, int idlen)
4532 {
4533 char *p1;
4534 char *p2;
4535 int cnt;
4536 cnt = sizeof (SD_INQUIRY(un)->inq_vid) +
4537 sizeof (SD_INQUIRY(un)->inq_pid);
4538
4539 ASSERT(un != NULL);
4540 p2 = un->un_sd->sd_inq->inq_vid;
4541 ASSERT(id != NULL);
4542 p1 = id;
4543
4544 if ((id[0] == ' ') && (id[idlen - 1] == ' ')) {
4545 /*
4546 * Note: string p1 is terminated by a NUL but string p2
4547 * isn't. The end of p2 is determined by cnt.
4548 */
4549 for (;;) {
4550 /* skip over any extra blanks in both strings */
4551 while ((*p1 != '\0') && (*p1 == ' ')) {
4552 p1++;
4553 }
4554 while ((cnt != 0) && (*p2 == ' ')) {
4555 p2++;
4556 cnt--;
4557 }
4558
4559 /* compare the two strings */
4560 if ((cnt == 0) ||
4561 (SD_TOUPPER(*p1) != SD_TOUPPER(*p2))) {
4562 break;
4563 }
4564 while ((cnt > 0) &&
4565 (SD_TOUPPER(*p1) == SD_TOUPPER(*p2))) {
4566 p1++;
4567 p2++;
4568 cnt--;
4569 }
4570 }
4571 }
4572
4573 /* return SD_SUCCESS if both strings match */
4574 return (((*p1 == '\0') && (cnt == 0)) ? SD_SUCCESS : SD_FAILURE);
4575 }
4576
4577
4578 /*
4579 * Function: sd_chk_vers1_data
4580 *
4581 * Description: Verify the version 1 device properties provided by the
4582 * user via the configuration file
4583 *
4584 * Arguments: un - driver soft state (unit) structure
4585 * flags - integer mask indicating properties to be set
4586 * prop_list - integer list of property values
4587 * list_len - number of the elements
4588 *
4589 * Return Code: SD_SUCCESS - Indicates the user provided data is valid
4590 * SD_FAILURE - Indicates the user provided data is invalid
4591 */
4592
4593 static int
4594 sd_chk_vers1_data(struct sd_lun *un, int flags, int *prop_list,
4595 int list_len, char *dataname_ptr)
4596 {
4597 int i;
4598 int mask = 1;
4599 int index = 0;
4600
4601 ASSERT(un != NULL);
4602
4603 /* Check for a NULL property name and list */
4604 if (dataname_ptr == NULL) {
4605 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
4606 "sd_chk_vers1_data: NULL data property name.");
4607 return (SD_FAILURE);
4608 }
4609 if (prop_list == NULL) {
4610 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
4611 "sd_chk_vers1_data: %s NULL data property list.",
4612 dataname_ptr);
4613 return (SD_FAILURE);
4614 }
4615
4616 /* Display a warning if undefined bits are set in the flags */
4617 if (flags & ~SD_CONF_BIT_MASK) {
4618 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
4619 "sd_chk_vers1_data: invalid bits 0x%x in data list %s. "
4620 "Properties not set.",
4621 (flags & ~SD_CONF_BIT_MASK), dataname_ptr);
4622 return (SD_FAILURE);
4623 }
4624
4625 /*
4626 * Verify the length of the list by identifying the highest bit set
4627 * in the flags and validating that the property list has a length
4628 * up to the index of this bit.
4629 */
4630 for (i = 0; i < SD_CONF_MAX_ITEMS; i++) {
4631 if (flags & mask) {
4632 index++;
4633 }
4634 mask = 1 << i;
4635 }
4636 if (list_len < (index + 2)) {
4637 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
4638 "sd_chk_vers1_data: "
4639 "Data property list %s size is incorrect. "
4640 "Properties not set.", dataname_ptr);
4641 scsi_log(SD_DEVINFO(un), sd_label, CE_CONT, "Size expected: "
4642 "version + 1 flagword + %d properties", SD_CONF_MAX_ITEMS);
4643 return (SD_FAILURE);
4644 }
4645 return (SD_SUCCESS);
4646 }
4647
4648
4649 /*
4650 * Function: sd_set_vers1_properties
4651 *
4652 * Description: Set version 1 device properties based on a property list
4653 * retrieved from the driver configuration file or static
4654 * configuration table. Version 1 properties have the format:
4655 *
4656 * <data-property-name>:=<version>,<flags>,<prop0>,<prop1>,.....<propN>
4657 *
4658 * where the prop0 value will be used to set prop0 if bit0
4659 * is set in the flags
4660 *
4661 * Arguments: un - driver soft state (unit) structure
4662 * flags - integer mask indicating properties to be set
4663 * prop_list - integer list of property values
4664 */
4665
4666 static void
4667 sd_set_vers1_properties(struct sd_lun *un, int flags, sd_tunables *prop_list)
4668 {
4669 ASSERT(un != NULL);
4670
4671 /*
4672 * Set the flag to indicate cache is to be disabled. An attempt
4673 * to disable the cache via sd_cache_control() will be made
4674 * later during attach once the basic initialization is complete.
4675 */
4676 if (flags & SD_CONF_BSET_NOCACHE) {
4677 un->un_f_opt_disable_cache = TRUE;
4678 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4679 "sd_set_vers1_properties: caching disabled flag set\n");
4680 }
4681
4682 /* CD-specific configuration parameters */
4683 if (flags & SD_CONF_BSET_PLAYMSF_BCD) {
4684 un->un_f_cfg_playmsf_bcd = TRUE;
4685 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4686 "sd_set_vers1_properties: playmsf_bcd set\n");
4687 }
4688 if (flags & SD_CONF_BSET_READSUB_BCD) {
4689 un->un_f_cfg_readsub_bcd = TRUE;
4690 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4691 "sd_set_vers1_properties: readsub_bcd set\n");
4692 }
4693 if (flags & SD_CONF_BSET_READ_TOC_TRK_BCD) {
4694 un->un_f_cfg_read_toc_trk_bcd = TRUE;
4695 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4696 "sd_set_vers1_properties: read_toc_trk_bcd set\n");
4697 }
4698 if (flags & SD_CONF_BSET_READ_TOC_ADDR_BCD) {
4699 un->un_f_cfg_read_toc_addr_bcd = TRUE;
4700 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4701 "sd_set_vers1_properties: read_toc_addr_bcd set\n");
4702 }
4703 if (flags & SD_CONF_BSET_NO_READ_HEADER) {
4704 un->un_f_cfg_no_read_header = TRUE;
4705 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4706 "sd_set_vers1_properties: no_read_header set\n");
4707 }
4708 if (flags & SD_CONF_BSET_READ_CD_XD4) {
4709 un->un_f_cfg_read_cd_xd4 = TRUE;
4710 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4711 "sd_set_vers1_properties: read_cd_xd4 set\n");
4712 }
4713
4714 /* Support for devices which do not have valid/unique serial numbers */
4715 if (flags & SD_CONF_BSET_FAB_DEVID) {
4716 un->un_f_opt_fab_devid = TRUE;
4717 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4718 "sd_set_vers1_properties: fab_devid bit set\n");
4719 }
4720
4721 /* Support for user throttle configuration */
4722 if (flags & SD_CONF_BSET_THROTTLE) {
4723 ASSERT(prop_list != NULL);
4724 un->un_saved_throttle = un->un_throttle =
4725 prop_list->sdt_throttle;
4726 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4727 "sd_set_vers1_properties: throttle set to %d\n",
4728 prop_list->sdt_throttle);
4729 }
4730
4731 /* Set the per disk retry count according to the conf file or table. */
4732 if (flags & SD_CONF_BSET_NRR_COUNT) {
4733 ASSERT(prop_list != NULL);
4734 if (prop_list->sdt_not_rdy_retries) {
4735 un->un_notready_retry_count =
4736 prop_list->sdt_not_rdy_retries;
4737 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4738 "sd_set_vers1_properties: not ready retry count"
4739 " set to %d\n", un->un_notready_retry_count);
4740 }
4741 }
4742
4743 /* The controller type is reported for generic disk driver ioctls */
4744 if (flags & SD_CONF_BSET_CTYPE) {
4745 ASSERT(prop_list != NULL);
4746 switch (prop_list->sdt_ctype) {
4747 case CTYPE_CDROM:
4748 un->un_ctype = prop_list->sdt_ctype;
4749 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4750 "sd_set_vers1_properties: ctype set to "
4751 "CTYPE_CDROM\n");
4752 break;
4753 case CTYPE_CCS:
4754 un->un_ctype = prop_list->sdt_ctype;
4755 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4756 "sd_set_vers1_properties: ctype set to "
4757 "CTYPE_CCS\n");
4758 break;
4759 case CTYPE_ROD: /* RW optical */
4760 un->un_ctype = prop_list->sdt_ctype;
4761 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4762 "sd_set_vers1_properties: ctype set to "
4763 "CTYPE_ROD\n");
4764 break;
4765 default:
4766 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
4767 "sd_set_vers1_properties: Could not set "
4768 "invalid ctype value (%d)",
4769 prop_list->sdt_ctype);
4770 }
4771 }
4772
4773 /* Purple failover timeout */
4774 if (flags & SD_CONF_BSET_BSY_RETRY_COUNT) {
4775 ASSERT(prop_list != NULL);
4776 un->un_busy_retry_count =
4777 prop_list->sdt_busy_retries;
4778 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4779 "sd_set_vers1_properties: "
4780 "busy retry count set to %d\n",
4781 un->un_busy_retry_count);
4782 }
4783
4784 /* Purple reset retry count */
4785 if (flags & SD_CONF_BSET_RST_RETRIES) {
4786 ASSERT(prop_list != NULL);
4787 un->un_reset_retry_count =
4788 prop_list->sdt_reset_retries;
4789 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4790 "sd_set_vers1_properties: "
4791 "reset retry count set to %d\n",
4792 un->un_reset_retry_count);
4793 }
4794
4795 /* Purple reservation release timeout */
4796 if (flags & SD_CONF_BSET_RSV_REL_TIME) {
4797 ASSERT(prop_list != NULL);
4798 un->un_reserve_release_time =
4799 prop_list->sdt_reserv_rel_time;
4800 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4801 "sd_set_vers1_properties: "
4802 "reservation release timeout set to %d\n",
4803 un->un_reserve_release_time);
4804 }
4805
4806 /*
4807 * Driver flag telling the driver to verify that no commands are pending
4808 * for a device before issuing a Test Unit Ready. This is a workaround
4809 * for a firmware bug in some Seagate eliteI drives.
4810 */
4811 if (flags & SD_CONF_BSET_TUR_CHECK) {
4812 un->un_f_cfg_tur_check = TRUE;
4813 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4814 "sd_set_vers1_properties: tur queue check set\n");
4815 }
4816
4817 if (flags & SD_CONF_BSET_MIN_THROTTLE) {
4818 un->un_min_throttle = prop_list->sdt_min_throttle;
4819 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4820 "sd_set_vers1_properties: min throttle set to %d\n",
4821 un->un_min_throttle);
4822 }
4823
4824 if (flags & SD_CONF_BSET_DISKSORT_DISABLED) {
4825 un->un_f_disksort_disabled =
4826 (prop_list->sdt_disk_sort_dis != 0) ?
4827 TRUE : FALSE;
4828 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4829 "sd_set_vers1_properties: disksort disabled "
4830 "flag set to %d\n",
4831 prop_list->sdt_disk_sort_dis);
4832 }
4833
4834 if (flags & SD_CONF_BSET_LUN_RESET_ENABLED) {
4835 un->un_f_lun_reset_enabled =
4836 (prop_list->sdt_lun_reset_enable != 0) ?
4837 TRUE : FALSE;
4838 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4839 "sd_set_vers1_properties: lun reset enabled "
4840 "flag set to %d\n",
4841 prop_list->sdt_lun_reset_enable);
4842 }
4843
4844 if (flags & SD_CONF_BSET_CACHE_IS_NV) {
4845 un->un_f_suppress_cache_flush =
4846 (prop_list->sdt_suppress_cache_flush != 0) ?
4847 TRUE : FALSE;
4848 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4849 "sd_set_vers1_properties: suppress_cache_flush "
4850 "flag set to %d\n",
4851 prop_list->sdt_suppress_cache_flush);
4852 }
4853
4854 if (flags & SD_CONF_BSET_PC_DISABLED) {
4855 un->un_f_power_condition_disabled =
4856 (prop_list->sdt_power_condition_dis != 0) ?
4857 TRUE : FALSE;
4858 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4859 "sd_set_vers1_properties: power_condition_disabled "
4860 "flag set to %d\n",
4861 prop_list->sdt_power_condition_dis);
4862 }
4863
4864 /*
4865 * Validate the throttle values.
4866 * If any of the numbers are invalid, set everything to defaults.
4867 */
4868 if ((un->un_throttle < SD_LOWEST_VALID_THROTTLE) ||
4869 (un->un_min_throttle < SD_LOWEST_VALID_THROTTLE) ||
4870 (un->un_min_throttle > un->un_throttle)) {
4871 un->un_saved_throttle = un->un_throttle = sd_max_throttle;
4872 un->un_min_throttle = sd_min_throttle;
4873 }
4874 }
4875
4876 /*
4877 * Function: sd_is_lsi()
4878 *
4879 * Description: Check for lsi devices, step through the static device
4880 * table to match vid/pid.
4881 *
4882 * Args: un - ptr to sd_lun
4883 *
4884 * Notes: When creating new LSI property, need to add the new LSI property
4885 * to this function.
4886 */
4887 static void
4888 sd_is_lsi(struct sd_lun *un)
4889 {
4890 char *id = NULL;
4891 int table_index;
4892 int idlen;
4893 void *prop;
4894
4895 ASSERT(un != NULL);
4896 for (table_index = 0; table_index < sd_disk_table_size;
4897 table_index++) {
4898 id = sd_disk_table[table_index].device_id;
4899 idlen = strlen(id);
4900 if (idlen == 0) {
4901 continue;
4902 }
4903
4904 if (sd_sdconf_id_match(un, id, idlen) == SD_SUCCESS) {
4905 prop = sd_disk_table[table_index].properties;
4906 if (prop == &lsi_properties ||
4907 prop == &lsi_oem_properties ||
4908 prop == &lsi_properties_scsi ||
4909 prop == &symbios_properties) {
4910 un->un_f_cfg_is_lsi = TRUE;
4911 }
4912 break;
4913 }
4914 }
4915 }
4916
4917 /*
4918 * Function: sd_get_physical_geometry
4919 *
4920 * Description: Retrieve the MODE SENSE page 3 (Format Device Page) and
4921 * MODE SENSE page 4 (Rigid Disk Drive Geometry Page) from the
4922 * target, and use this information to initialize the physical
4923 * geometry cache specified by pgeom_p.
4924 *
4925 * MODE SENSE is an optional command, so failure in this case
4926 * does not necessarily denote an error. We want to use the
4927 * MODE SENSE commands to derive the physical geometry of the
4928 * device, but if either command fails, the logical geometry is
4929 * used as the fallback for disk label geometry in cmlb.
4930 *
4931 * This requires that un->un_blockcount and un->un_tgt_blocksize
4932 * have already been initialized for the current target and
4933 * that the current values be passed as args so that we don't
4934 * end up ever trying to use -1 as a valid value. This could
4935 * happen if either value is reset while we're not holding
4936 * the mutex.
4937 *
4938 * Arguments: un - driver soft state (unit) structure
4939 * path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and
4940 * the normal command waitq, or SD_PATH_DIRECT_PRIORITY
4941 * to use the USCSI "direct" chain and bypass the normal
4942 * command waitq.
4943 *
4944 * Context: Kernel thread only (can sleep).
4945 */
4946
4947 static int
4948 sd_get_physical_geometry(struct sd_lun *un, cmlb_geom_t *pgeom_p,
4949 diskaddr_t capacity, int lbasize, int path_flag)
4950 {
4951 struct mode_format *page3p;
4952 struct mode_geometry *page4p;
4953 struct mode_header *headerp;
4954 int sector_size;
4955 int nsect;
4956 int nhead;
4957 int ncyl;
4958 int intrlv;
4959 int spc;
4960 diskaddr_t modesense_capacity;
4961 int rpm;
4962 int bd_len;
4963 int mode_header_length;
4964 uchar_t *p3bufp;
4965 uchar_t *p4bufp;
4966 int cdbsize;
4967 int ret = EIO;
4968 sd_ssc_t *ssc;
4969 int status;
4970
4971 ASSERT(un != NULL);
4972
4973 if (lbasize == 0) {
4974 if (ISCD(un)) {
4975 lbasize = 2048;
4976 } else {
4977 lbasize = un->un_sys_blocksize;
4978 }
4979 }
4980 pgeom_p->g_secsize = (unsigned short)lbasize;
4981
4982 /*
4983 * If the unit is a cd/dvd drive MODE SENSE page three
4984 * and MODE SENSE page four are reserved (see SBC spec
4985 * and MMC spec). To prevent soft errors just return
4986 * using the default LBA size.
4987 */
4988 if (ISCD(un))
4989 return (ret);
4990
4991 cdbsize = (un->un_f_cfg_is_atapi == TRUE) ? CDB_GROUP2 : CDB_GROUP0;
4992
4993 /*
4994 * Retrieve MODE SENSE page 3 - Format Device Page
4995 */
4996 p3bufp = kmem_zalloc(SD_MODE_SENSE_PAGE3_LENGTH, KM_SLEEP);
4997 ssc = sd_ssc_init(un);
4998 status = sd_send_scsi_MODE_SENSE(ssc, cdbsize, p3bufp,
4999 SD_MODE_SENSE_PAGE3_LENGTH, SD_MODE_SENSE_PAGE3_CODE, path_flag);
5000 if (status != 0) {
5001 SD_ERROR(SD_LOG_COMMON, un,
5002 "sd_get_physical_geometry: mode sense page 3 failed\n");
5003 goto page3_exit;
5004 }
5005
5006 /*
5007 * Determine size of Block Descriptors in order to locate the mode
5008 * page data. ATAPI devices return 0, SCSI devices should return
5009 * MODE_BLK_DESC_LENGTH.
5010 */
5011 headerp = (struct mode_header *)p3bufp;
5012 if (un->un_f_cfg_is_atapi == TRUE) {
5013 struct mode_header_grp2 *mhp =
5014 (struct mode_header_grp2 *)headerp;
5015 mode_header_length = MODE_HEADER_LENGTH_GRP2;
5016 bd_len = (mhp->bdesc_length_hi << 8) | mhp->bdesc_length_lo;
5017 } else {
5018 mode_header_length = MODE_HEADER_LENGTH;
5019 bd_len = ((struct mode_header *)headerp)->bdesc_length;
5020 }
5021
5022 if (bd_len > MODE_BLK_DESC_LENGTH) {
5023 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, SD_LOG_COMMON,
5024 "sd_get_physical_geometry: received unexpected bd_len "
5025 "of %d, page3\n", bd_len);
5026 status = EIO;
5027 goto page3_exit;
5028 }
5029
5030 page3p = (struct mode_format *)
5031 ((caddr_t)headerp + mode_header_length + bd_len);
5032
5033 if (page3p->mode_page.code != SD_MODE_SENSE_PAGE3_CODE) {
5034 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, SD_LOG_COMMON,
5035 "sd_get_physical_geometry: mode sense pg3 code mismatch "
5036 "%d\n", page3p->mode_page.code);
5037 status = EIO;
5038 goto page3_exit;
5039 }
5040
5041 /*
5042 * Use this physical geometry data only if BOTH MODE SENSE commands
5043 * complete successfully; otherwise, revert to the logical geometry.
5044 * So, we need to save everything in temporary variables.
5045 */
5046 sector_size = BE_16(page3p->data_bytes_sect);
5047
5048 /*
5049 * 1243403: The NEC D38x7 drives do not support MODE SENSE sector size
5050 */
5051 if (sector_size == 0) {
5052 sector_size = un->un_sys_blocksize;
5053 } else {
5054 sector_size &= ~(un->un_sys_blocksize - 1);
5055 }
5056
5057 nsect = BE_16(page3p->sect_track);
5058 intrlv = BE_16(page3p->interleave);
5059
5060 SD_INFO(SD_LOG_COMMON, un,
5061 "sd_get_physical_geometry: Format Parameters (page 3)\n");
5062 SD_INFO(SD_LOG_COMMON, un,
5063 " mode page: %d; nsect: %d; sector size: %d;\n",
5064 page3p->mode_page.code, nsect, sector_size);
5065 SD_INFO(SD_LOG_COMMON, un,
5066 " interleave: %d; track skew: %d; cylinder skew: %d;\n", intrlv,
5067 BE_16(page3p->track_skew),
5068 BE_16(page3p->cylinder_skew));
5069
5070 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
5071
5072 /*
5073 * Retrieve MODE SENSE page 4 - Rigid Disk Drive Geometry Page
5074 */
5075 p4bufp = kmem_zalloc(SD_MODE_SENSE_PAGE4_LENGTH, KM_SLEEP);
5076 status = sd_send_scsi_MODE_SENSE(ssc, cdbsize, p4bufp,
5077 SD_MODE_SENSE_PAGE4_LENGTH, SD_MODE_SENSE_PAGE4_CODE, path_flag);
5078 if (status != 0) {
5079 SD_ERROR(SD_LOG_COMMON, un,
5080 "sd_get_physical_geometry: mode sense page 4 failed\n");
5081 goto page4_exit;
5082 }
5083
5084 /*
5085 * Determine size of Block Descriptors in order to locate the mode
5086 * page data. ATAPI devices return 0, SCSI devices should return
5087 * MODE_BLK_DESC_LENGTH.
5088 */
5089 headerp = (struct mode_header *)p4bufp;
5090 if (un->un_f_cfg_is_atapi == TRUE) {
5091 struct mode_header_grp2 *mhp =
5092 (struct mode_header_grp2 *)headerp;
5093 bd_len = (mhp->bdesc_length_hi << 8) | mhp->bdesc_length_lo;
5094 } else {
5095 bd_len = ((struct mode_header *)headerp)->bdesc_length;
5096 }
5097
5098 if (bd_len > MODE_BLK_DESC_LENGTH) {
5099 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, SD_LOG_COMMON,
5100 "sd_get_physical_geometry: received unexpected bd_len of "
5101 "%d, page4\n", bd_len);
5102 status = EIO;
5103 goto page4_exit;
5104 }
5105
5106 page4p = (struct mode_geometry *)
5107 ((caddr_t)headerp + mode_header_length + bd_len);
5108
5109 if (page4p->mode_page.code != SD_MODE_SENSE_PAGE4_CODE) {
5110 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, SD_LOG_COMMON,
5111 "sd_get_physical_geometry: mode sense pg4 code mismatch "
5112 "%d\n", page4p->mode_page.code);
5113 status = EIO;
5114 goto page4_exit;
5115 }
5116
5117 /*
5118 * Stash the data now, after we know that both commands completed.
5119 */
5120
5121
5122 nhead = (int)page4p->heads; /* uchar, so no conversion needed */
5123 spc = nhead * nsect;
5124 ncyl = (page4p->cyl_ub << 16) + (page4p->cyl_mb << 8) + page4p->cyl_lb;
5125 rpm = BE_16(page4p->rpm);
5126
5127 modesense_capacity = spc * ncyl;
5128
5129 SD_INFO(SD_LOG_COMMON, un,
5130 "sd_get_physical_geometry: Geometry Parameters (page 4)\n");
5131 SD_INFO(SD_LOG_COMMON, un,
5132 " cylinders: %d; heads: %d; rpm: %d;\n", ncyl, nhead, rpm);
5133 SD_INFO(SD_LOG_COMMON, un,
5134 " computed capacity(h*s*c): %d;\n", modesense_capacity);
5135 SD_INFO(SD_LOG_COMMON, un, " pgeom_p: %p; read cap: %d\n",
5136 (void *)pgeom_p, capacity);
5137
5138 /*
5139 * Compensate if the drive's geometry is not rectangular, i.e.,
5140 * the product of C * H * S returned by MODE SENSE >= that returned
5141 * by read capacity. This is an idiosyncrasy of the original x86
5142 * disk subsystem.
5143 */
5144 if (modesense_capacity >= capacity) {
5145 SD_INFO(SD_LOG_COMMON, un,
5146 "sd_get_physical_geometry: adjusting acyl; "
5147 "old: %d; new: %d\n", pgeom_p->g_acyl,
5148 (modesense_capacity - capacity + spc - 1) / spc);
5149 if (sector_size != 0) {
5150 /* 1243403: NEC D38x7 drives don't support sec size */
5151 pgeom_p->g_secsize = (unsigned short)sector_size;
5152 }
5153 pgeom_p->g_nsect = (unsigned short)nsect;
5154 pgeom_p->g_nhead = (unsigned short)nhead;
5155 pgeom_p->g_capacity = capacity;
5156 pgeom_p->g_acyl =
5157 (modesense_capacity - pgeom_p->g_capacity + spc - 1) / spc;
5158 pgeom_p->g_ncyl = ncyl - pgeom_p->g_acyl;
5159 }
5160
5161 pgeom_p->g_rpm = (unsigned short)rpm;
5162 pgeom_p->g_intrlv = (unsigned short)intrlv;
5163 ret = 0;
5164
5165 SD_INFO(SD_LOG_COMMON, un,
5166 "sd_get_physical_geometry: mode sense geometry:\n");
5167 SD_INFO(SD_LOG_COMMON, un,
5168 " nsect: %d; sector size: %d; interlv: %d\n",
5169 nsect, sector_size, intrlv);
5170 SD_INFO(SD_LOG_COMMON, un,
5171 " nhead: %d; ncyl: %d; rpm: %d; capacity(ms): %d\n",
5172 nhead, ncyl, rpm, modesense_capacity);
5173 SD_INFO(SD_LOG_COMMON, un,
5174 "sd_get_physical_geometry: (cached)\n");
5175 SD_INFO(SD_LOG_COMMON, un,
5176 " ncyl: %ld; acyl: %d; nhead: %d; nsect: %d\n",
5177 pgeom_p->g_ncyl, pgeom_p->g_acyl,
5178 pgeom_p->g_nhead, pgeom_p->g_nsect);
5179 SD_INFO(SD_LOG_COMMON, un,
5180 " lbasize: %d; capacity: %ld; intrlv: %d; rpm: %d\n",
5181 pgeom_p->g_secsize, pgeom_p->g_capacity,
5182 pgeom_p->g_intrlv, pgeom_p->g_rpm);
5183 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
5184
5185 page4_exit:
5186 kmem_free(p4bufp, SD_MODE_SENSE_PAGE4_LENGTH);
5187
5188 page3_exit:
5189 kmem_free(p3bufp, SD_MODE_SENSE_PAGE3_LENGTH);
5190
5191 if (status != 0) {
5192 if (status == EIO) {
5193 /*
5194 * Some disks do not support mode sense(6), we
5195 * should ignore this kind of error(sense key is
5196 * 0x5 - illegal request).
5197 */
5198 uint8_t *sensep;
5199 int senlen;
5200
5201 sensep = (uint8_t *)ssc->ssc_uscsi_cmd->uscsi_rqbuf;
5202 senlen = (int)(ssc->ssc_uscsi_cmd->uscsi_rqlen -
5203 ssc->ssc_uscsi_cmd->uscsi_rqresid);
5204
5205 if (senlen > 0 &&
5206 scsi_sense_key(sensep) == KEY_ILLEGAL_REQUEST) {
5207 sd_ssc_assessment(ssc,
5208 SD_FMT_IGNORE_COMPROMISE);
5209 } else {
5210 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
5211 }
5212 } else {
5213 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
5214 }
5215 }
5216 sd_ssc_fini(ssc);
5217 return (ret);
5218 }
5219
5220 /*
5221 * Function: sd_get_virtual_geometry
5222 *
5223 * Description: Ask the controller to tell us about the target device.
5224 *
5225 * Arguments: un - pointer to softstate
5226 * capacity - disk capacity in #blocks
5227 * lbasize - disk block size in bytes
5228 *
5229 * Context: Kernel thread only
5230 */
5231
5232 static int
5233 sd_get_virtual_geometry(struct sd_lun *un, cmlb_geom_t *lgeom_p,
5234 diskaddr_t capacity, int lbasize)
5235 {
5236 uint_t geombuf;
5237 int spc;
5238
5239 ASSERT(un != NULL);
5240
5241 /* Set sector size, and total number of sectors */
5242 (void) scsi_ifsetcap(SD_ADDRESS(un), "sector-size", lbasize, 1);
5243 (void) scsi_ifsetcap(SD_ADDRESS(un), "total-sectors", capacity, 1);
5244
5245 /* Let the HBA tell us its geometry */
5246 geombuf = (uint_t)scsi_ifgetcap(SD_ADDRESS(un), "geometry", 1);
5247
5248 /* A value of -1 indicates an undefined "geometry" property */
5249 if (geombuf == (-1)) {
5250 return (EINVAL);
5251 }
5252
5253 /* Initialize the logical geometry cache. */
5254 lgeom_p->g_nhead = (geombuf >> 16) & 0xffff;
5255 lgeom_p->g_nsect = geombuf & 0xffff;
5256 lgeom_p->g_secsize = un->un_sys_blocksize;
5257
5258 spc = lgeom_p->g_nhead * lgeom_p->g_nsect;
5259
5260 /*
5261 * Note: The driver originally converted the capacity value from
5262 * target blocks to system blocks. However, the capacity value passed
5263 * to this routine is already in terms of system blocks (this scaling
5264 * is done when the READ CAPACITY command is issued and processed).
5265 * This 'error' may have gone undetected because the usage of g_ncyl
5266 * (which is based upon g_capacity) is very limited within the driver
5267 */
5268 lgeom_p->g_capacity = capacity;
5269
5270 /*
5271 * Set ncyl to zero if the hba returned a zero nhead or nsect value. The
5272 * hba may return zero values if the device has been removed.
5273 */
5274 if (spc == 0) {
5275 lgeom_p->g_ncyl = 0;
5276 } else {
5277 lgeom_p->g_ncyl = lgeom_p->g_capacity / spc;
5278 }
5279 lgeom_p->g_acyl = 0;
5280
5281 SD_INFO(SD_LOG_COMMON, un, "sd_get_virtual_geometry: (cached)\n");
5282 return (0);
5283
5284 }
5285 /*
5286 * Function: sd_update_block_info
5287 *
5288 * Description: Calculate a byte count to sector count bitshift value
5289 * from sector size.
5290 *
5291 * Arguments: un: unit struct.
5292 * lbasize: new target sector size
5293 * capacity: new target capacity, ie. block count
5294 *
5295 * Context: Kernel thread context
5296 */
5297
5298 static void
5299 sd_update_block_info(struct sd_lun *un, uint32_t lbasize, uint64_t capacity)
5300 {
5301 if (lbasize != 0) {
5302 un->un_tgt_blocksize = lbasize;
5303 un->un_f_tgt_blocksize_is_valid = TRUE;
5304 if (!un->un_f_has_removable_media) {
5305 un->un_sys_blocksize = lbasize;
5306 }
5307 }
5308
5309 if (capacity != 0) {
5310 un->un_blockcount = capacity;
5311 un->un_f_blockcount_is_valid = TRUE;
5312
5313 /*
5314 * The capacity has changed so update the errstats.
5315 */
5316 if (un->un_errstats != NULL) {
5317 struct sd_errstats *stp;
5318
5319 capacity *= un->un_sys_blocksize;
5320 stp = (struct sd_errstats *)un->un_errstats->ks_data;
5321 if (stp->sd_capacity.value.ui64 < capacity)
5322 stp->sd_capacity.value.ui64 = capacity;
5323 }
5324 }
5325 }
5326
5327
5328 /*
5329 * Function: sd_register_devid
5330 *
5331 * Description: This routine will obtain the device id information from the
5332 * target, obtain the serial number, and register the device
5333 * id with the ddi framework.
5334 *
5335 * Arguments: devi - the system's dev_info_t for the device.
5336 * un - driver soft state (unit) structure
5337 * reservation_flag - indicates if a reservation conflict
5338 * occurred during attach
5339 *
5340 * Context: Kernel Thread
5341 */
5342 static void
5343 sd_register_devid(sd_ssc_t *ssc, dev_info_t *devi, int reservation_flag)
5344 {
5345 int rval = 0;
5346 uchar_t *inq80 = NULL;
5347 size_t inq80_len = MAX_INQUIRY_SIZE;
5348 size_t inq80_resid = 0;
5349 uchar_t *inq83 = NULL;
5350 size_t inq83_len = MAX_INQUIRY_SIZE;
5351 size_t inq83_resid = 0;
5352 int dlen, len;
5353 char *sn;
5354 struct sd_lun *un;
5355
5356 ASSERT(ssc != NULL);
5357 un = ssc->ssc_un;
5358 ASSERT(un != NULL);
5359 ASSERT(mutex_owned(SD_MUTEX(un)));
5360 ASSERT((SD_DEVINFO(un)) == devi);
5361
5362
5363 /*
5364 * We check the availability of the World Wide Name (0x83) and Unit
5365 * Serial Number (0x80) pages in sd_check_vpd_page_support(), and using
5366 * un_vpd_page_mask from them, we decide which way to get the WWN. If
5367 * 0x83 is available, that is the best choice. Our next choice is
5368 * 0x80. If neither are available, we munge the devid from the device
5369 * vid/pid/serial # for Sun qualified disks, or use the ddi framework
5370 * to fabricate a devid for non-Sun qualified disks.
5371 */
5372 if (sd_check_vpd_page_support(ssc) == 0) {
5373 /* collect page 80 data if available */
5374 if (un->un_vpd_page_mask & SD_VPD_UNIT_SERIAL_PG) {
5375
5376 mutex_exit(SD_MUTEX(un));
5377 inq80 = kmem_zalloc(inq80_len, KM_SLEEP);
5378
5379 rval = sd_send_scsi_INQUIRY(ssc, inq80, inq80_len,
5380 0x01, 0x80, &inq80_resid);
5381
5382 if (rval != 0) {
5383 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
5384 kmem_free(inq80, inq80_len);
5385 inq80 = NULL;
5386 inq80_len = 0;
5387 } else if (ddi_prop_exists(
5388 DDI_DEV_T_NONE, SD_DEVINFO(un),
5389 DDI_PROP_NOTPROM | DDI_PROP_DONTPASS,
5390 INQUIRY_SERIAL_NO) == 0) {
5391 /*
5392 * If we don't already have a serial number
5393 * property, do quick verify of data returned
5394 * and define property.
5395 */
5396 dlen = inq80_len - inq80_resid;
5397 len = (size_t)inq80[3];
5398 if ((dlen >= 4) && ((len + 4) <= dlen)) {
5399 /*
5400 * Ensure sn termination, skip leading
5401 * blanks, and create property
5402 * 'inquiry-serial-no'.
5403 */
5404 sn = (char *)&inq80[4];
5405 sn[len] = 0;
5406 while (*sn && (*sn == ' '))
5407 sn++;
5408 if (*sn) {
5409 (void) ddi_prop_update_string(
5410 DDI_DEV_T_NONE,
5411 SD_DEVINFO(un),
5412 INQUIRY_SERIAL_NO, sn);
5413 }
5414 }
5415 }
5416 mutex_enter(SD_MUTEX(un));
5417 }
5418
5419 /* collect page 83 data if available */
5420 if (un->un_vpd_page_mask & SD_VPD_DEVID_WWN_PG) {
5421 mutex_exit(SD_MUTEX(un));
5422 inq83 = kmem_zalloc(inq83_len, KM_SLEEP);
5423
5424 rval = sd_send_scsi_INQUIRY(ssc, inq83, inq83_len,
5425 0x01, 0x83, &inq83_resid);
5426
5427 if (rval != 0) {
5428 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
5429 kmem_free(inq83, inq83_len);
5430 inq83 = NULL;
5431 inq83_len = 0;
5432 }
5433 mutex_enter(SD_MUTEX(un));
5434 }
5435 }
5436
5437 /*
5438 * If transport has already registered a devid for this target
5439 * then that takes precedence over the driver's determination
5440 * of the devid.
5441 *
5442 * NOTE: The reason this check is done here instead of at the beginning
5443 * of the function is to allow the code above to create the
5444 * 'inquiry-serial-no' property.
5445 */
5446 if (ddi_devid_get(SD_DEVINFO(un), &un->un_devid) == DDI_SUCCESS) {
5447 ASSERT(un->un_devid);
5448 un->un_f_devid_transport_defined = TRUE;
5449 goto cleanup; /* use devid registered by the transport */
5450 }
5451
5452 /*
5453 * This is the case of antiquated Sun disk drives that have the
5454 * FAB_DEVID property set in the disk_table. These drives
5455 * manage the devid's by storing them in last 2 available sectors
5456 * on the drive and have them fabricated by the ddi layer by calling
5457 * ddi_devid_init and passing the DEVID_FAB flag.
5458 */
5459 if (un->un_f_opt_fab_devid == TRUE) {
5460 /*
5461 * Depending on EINVAL isn't reliable, since a reserved disk
5462 * may result in invalid geometry, so check to make sure a
5463 * reservation conflict did not occur during attach.
5464 */
5465 if ((sd_get_devid(ssc) == EINVAL) &&
5466 (reservation_flag != SD_TARGET_IS_RESERVED)) {
5467 /*
5468 * The devid is invalid AND there is no reservation
5469 * conflict. Fabricate a new devid.
5470 */
5471 (void) sd_create_devid(ssc);
5472 }
5473
5474 /* Register the devid if it exists */
5475 if (un->un_devid != NULL) {
5476 (void) ddi_devid_register(SD_DEVINFO(un),
5477 un->un_devid);
5478 SD_INFO(SD_LOG_ATTACH_DETACH, un,
5479 "sd_register_devid: Devid Fabricated\n");
5480 }
5481 goto cleanup;
5482 }
5483
5484 /* encode best devid possible based on data available */
5485 if (ddi_devid_scsi_encode(DEVID_SCSI_ENCODE_VERSION_LATEST,
5486 (char *)ddi_driver_name(SD_DEVINFO(un)),
5487 (uchar_t *)SD_INQUIRY(un), sizeof (*SD_INQUIRY(un)),
5488 inq80, inq80_len - inq80_resid, inq83, inq83_len -
5489 inq83_resid, &un->un_devid) == DDI_SUCCESS) {
5490
5491 /* devid successfully encoded, register devid */
5492 (void) ddi_devid_register(SD_DEVINFO(un), un->un_devid);
5493
5494 } else {
5495 /*
5496 * Unable to encode a devid based on data available.
5497 * This is not a Sun qualified disk. Older Sun disk
5498 * drives that have the SD_FAB_DEVID property
5499 * set in the disk_table and non Sun qualified
5500 * disks are treated in the same manner. These
5501 * drives manage the devid's by storing them in
5502 * last 2 available sectors on the drive and
5503 * have them fabricated by the ddi layer by
5504 * calling ddi_devid_init and passing the
5505 * DEVID_FAB flag.
5506 * Create a fabricate devid only if there's no
5507 * fabricate devid existed.
5508 */
5509 if (sd_get_devid(ssc) == EINVAL) {
5510 (void) sd_create_devid(ssc);
5511 }
5512 un->un_f_opt_fab_devid = TRUE;
5513
5514 /* Register the devid if it exists */
5515 if (un->un_devid != NULL) {
5516 (void) ddi_devid_register(SD_DEVINFO(un),
5517 un->un_devid);
5518 SD_INFO(SD_LOG_ATTACH_DETACH, un,
5519 "sd_register_devid: devid fabricated using "
5520 "ddi framework\n");
5521 }
5522 }
5523
5524 cleanup:
5525 /* clean up resources */
5526 if (inq80 != NULL) {
5527 kmem_free(inq80, inq80_len);
5528 }
5529 if (inq83 != NULL) {
5530 kmem_free(inq83, inq83_len);
5531 }
5532 }
5533
5534
5535
5536 /*
5537 * Function: sd_get_devid
5538 *
5539 * Description: This routine will return 0 if a valid device id has been
5540 * obtained from the target and stored in the soft state. If a
5541 * valid device id has not been previously read and stored, a
5542 * read attempt will be made.
5543 *
5544 * Arguments: un - driver soft state (unit) structure
5545 *
5546 * Return Code: 0 if we successfully get the device id
5547 *
5548 * Context: Kernel Thread
5549 */
5550
5551 static int
5552 sd_get_devid(sd_ssc_t *ssc)
5553 {
5554 struct dk_devid *dkdevid;
5555 ddi_devid_t tmpid;
5556 uint_t *ip;
5557 size_t sz;
5558 diskaddr_t blk;
5559 int status;
5560 int chksum;
5561 int i;
5562 size_t buffer_size;
5563 struct sd_lun *un;
5564
5565 ASSERT(ssc != NULL);
5566 un = ssc->ssc_un;
5567 ASSERT(un != NULL);
5568 ASSERT(mutex_owned(SD_MUTEX(un)));
5569
5570 SD_TRACE(SD_LOG_ATTACH_DETACH, un, "sd_get_devid: entry: un: 0x%p\n",
5571 un);
5572
5573 if (un->un_devid != NULL) {
5574 return (0);
5575 }
5576
5577 mutex_exit(SD_MUTEX(un));
5578 if (cmlb_get_devid_block(un->un_cmlbhandle, &blk,
5579 (void *)SD_PATH_DIRECT) != 0) {
5580 mutex_enter(SD_MUTEX(un));
5581 return (EINVAL);
5582 }
5583
5584 /*
5585 * Read and verify device id, stored in the reserved cylinders at the
5586 * end of the disk. Backup label is on the odd sectors of the last
5587 * track of the last cylinder. Device id will be on track of the next
5588 * to last cylinder.
5589 */
5590 mutex_enter(SD_MUTEX(un));
5591 buffer_size = SD_REQBYTES2TGTBYTES(un, sizeof (struct dk_devid));
5592 mutex_exit(SD_MUTEX(un));
5593 dkdevid = kmem_alloc(buffer_size, KM_SLEEP);
5594 status = sd_send_scsi_READ(ssc, dkdevid, buffer_size, blk,
5595 SD_PATH_DIRECT);
5596
5597 if (status != 0) {
5598 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
5599 goto error;
5600 }
5601
5602 /* Validate the revision */
5603 if ((dkdevid->dkd_rev_hi != DK_DEVID_REV_MSB) ||
5604 (dkdevid->dkd_rev_lo != DK_DEVID_REV_LSB)) {
5605 status = EINVAL;
5606 goto error;
5607 }
5608
5609 /* Calculate the checksum */
5610 chksum = 0;
5611 ip = (uint_t *)dkdevid;
5612 for (i = 0; i < ((DEV_BSIZE - sizeof (int)) / sizeof (int));
5613 i++) {
5614 chksum ^= ip[i];
5615 }
5616
5617 /* Compare the checksums */
5618 if (DKD_GETCHKSUM(dkdevid) != chksum) {
5619 status = EINVAL;
5620 goto error;
5621 }
5622
5623 /* Validate the device id */
5624 if (ddi_devid_valid((ddi_devid_t)&dkdevid->dkd_devid) != DDI_SUCCESS) {
5625 status = EINVAL;
5626 goto error;
5627 }
5628
5629 /*
5630 * Store the device id in the driver soft state
5631 */
5632 sz = ddi_devid_sizeof((ddi_devid_t)&dkdevid->dkd_devid);
5633 tmpid = kmem_alloc(sz, KM_SLEEP);
5634
5635 mutex_enter(SD_MUTEX(un));
5636
5637 un->un_devid = tmpid;
5638 bcopy(&dkdevid->dkd_devid, un->un_devid, sz);
5639
5640 kmem_free(dkdevid, buffer_size);
5641
5642 SD_TRACE(SD_LOG_ATTACH_DETACH, un, "sd_get_devid: exit: un:0x%p\n", un);
5643
5644 return (status);
5645 error:
5646 mutex_enter(SD_MUTEX(un));
5647 kmem_free(dkdevid, buffer_size);
5648 return (status);
5649 }
5650
5651
5652 /*
5653 * Function: sd_create_devid
5654 *
5655 * Description: This routine will fabricate the device id and write it
5656 * to the disk.
5657 *
5658 * Arguments: un - driver soft state (unit) structure
5659 *
5660 * Return Code: value of the fabricated device id
5661 *
5662 * Context: Kernel Thread
5663 */
5664
5665 static ddi_devid_t
5666 sd_create_devid(sd_ssc_t *ssc)
5667 {
5668 struct sd_lun *un;
5669
5670 ASSERT(ssc != NULL);
5671 un = ssc->ssc_un;
5672 ASSERT(un != NULL);
5673
5674 /* Fabricate the devid */
5675 if (ddi_devid_init(SD_DEVINFO(un), DEVID_FAB, 0, NULL, &un->un_devid)
5676 == DDI_FAILURE) {
5677 return (NULL);
5678 }
5679
5680 /* Write the devid to disk */
5681 if (sd_write_deviceid(ssc) != 0) {
5682 ddi_devid_free(un->un_devid);
5683 un->un_devid = NULL;
5684 }
5685
5686 return (un->un_devid);
5687 }
5688
5689
5690 /*
5691 * Function: sd_write_deviceid
5692 *
5693 * Description: This routine will write the device id to the disk
5694 * reserved sector.
5695 *
5696 * Arguments: un - driver soft state (unit) structure
5697 *
5698 * Return Code: EINVAL
5699 * value returned by sd_send_scsi_cmd
5700 *
5701 * Context: Kernel Thread
5702 */
5703
5704 static int
5705 sd_write_deviceid(sd_ssc_t *ssc)
5706 {
5707 struct dk_devid *dkdevid;
5708 uchar_t *buf;
5709 diskaddr_t blk;
5710 uint_t *ip, chksum;
5711 int status;
5712 int i;
5713 struct sd_lun *un;
5714
5715 ASSERT(ssc != NULL);
5716 un = ssc->ssc_un;
5717 ASSERT(un != NULL);
5718 ASSERT(mutex_owned(SD_MUTEX(un)));
5719
5720 mutex_exit(SD_MUTEX(un));
5721 if (cmlb_get_devid_block(un->un_cmlbhandle, &blk,
5722 (void *)SD_PATH_DIRECT) != 0) {
5723 mutex_enter(SD_MUTEX(un));
5724 return (-1);
5725 }
5726
5727
5728 /* Allocate the buffer */
5729 buf = kmem_zalloc(un->un_sys_blocksize, KM_SLEEP);
5730 dkdevid = (struct dk_devid *)buf;
5731
5732 /* Fill in the revision */
5733 dkdevid->dkd_rev_hi = DK_DEVID_REV_MSB;
5734 dkdevid->dkd_rev_lo = DK_DEVID_REV_LSB;
5735
5736 /* Copy in the device id */
5737 mutex_enter(SD_MUTEX(un));
5738 bcopy(un->un_devid, &dkdevid->dkd_devid,
5739 ddi_devid_sizeof(un->un_devid));
5740 mutex_exit(SD_MUTEX(un));
5741
5742 /* Calculate the checksum */
5743 chksum = 0;
5744 ip = (uint_t *)dkdevid;
5745 for (i = 0; i < ((DEV_BSIZE - sizeof (int)) / sizeof (int));
5746 i++) {
5747 chksum ^= ip[i];
5748 }
5749
5750 /* Fill-in checksum */
5751 DKD_FORMCHKSUM(chksum, dkdevid);
5752
5753 /* Write the reserved sector */
5754 status = sd_send_scsi_WRITE(ssc, buf, un->un_sys_blocksize, blk,
5755 SD_PATH_DIRECT);
5756 if (status != 0)
5757 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
5758
5759 kmem_free(buf, un->un_sys_blocksize);
5760
5761 mutex_enter(SD_MUTEX(un));
5762 return (status);
5763 }
5764
5765
5766 /*
5767 * Function: sd_check_vpd_page_support
5768 *
5769 * Description: This routine sends an inquiry command with the EVPD bit set and
5770 * a page code of 0x00 to the device. It is used to determine which
5771 * vital product pages are available to find the devid. We are
5772 * looking for pages 0x83 0x80 or 0xB1. If we return a negative 1,
5773 * the device does not support that command.
5774 *
5775 * Arguments: un - driver soft state (unit) structure
5776 *
5777 * Return Code: 0 - success
5778 * 1 - check condition
5779 *
5780 * Context: This routine can sleep.
5781 */
5782
5783 static int
5784 sd_check_vpd_page_support(sd_ssc_t *ssc)
5785 {
5786 uchar_t *page_list = NULL;
5787 uchar_t page_length = 0xff; /* Use max possible length */
5788 uchar_t evpd = 0x01; /* Set the EVPD bit */
5789 uchar_t page_code = 0x00; /* Supported VPD Pages */
5790 int rval = 0;
5791 int counter;
5792 struct sd_lun *un;
5793
5794 ASSERT(ssc != NULL);
5795 un = ssc->ssc_un;
5796 ASSERT(un != NULL);
5797 ASSERT(mutex_owned(SD_MUTEX(un)));
5798
5799 mutex_exit(SD_MUTEX(un));
5800
5801 /*
5802 * We'll set the page length to the maximum to save figuring it out
5803 * with an additional call.
5804 */
5805 page_list = kmem_zalloc(page_length, KM_SLEEP);
5806
5807 rval = sd_send_scsi_INQUIRY(ssc, page_list, page_length, evpd,
5808 page_code, NULL);
5809
5810 if (rval != 0)
5811 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
5812
5813 mutex_enter(SD_MUTEX(un));
5814
5815 /*
5816 * Now we must validate that the device accepted the command, as some
5817 * drives do not support it. If the drive does support it, we will
5818 * return 0, and the supported pages will be in un_vpd_page_mask. If
5819 * not, we return -1.
5820 */
5821 if ((rval == 0) && (page_list[VPD_MODE_PAGE] == 0x00)) {
5822 /* Loop to find one of the 2 pages we need */
5823 counter = 4; /* Supported pages start at byte 4, with 0x00 */
5824
5825 /*
5826 * Pages are returned in ascending order, and 0x83 is what we
5827 * are hoping for.
5828 */
5829 while ((page_list[counter] <= 0xB1) &&
5830 (counter <= (page_list[VPD_PAGE_LENGTH] +
5831 VPD_HEAD_OFFSET))) {
5832 /*
5833 * Add 3 because page_list[3] is the number of
5834 * pages minus 3
5835 */
5836
5837 switch (page_list[counter]) {
5838 case 0x00:
5839 un->un_vpd_page_mask |= SD_VPD_SUPPORTED_PG;
5840 break;
5841 case 0x80:
5842 un->un_vpd_page_mask |= SD_VPD_UNIT_SERIAL_PG;
5843 break;
5844 case 0x81:
5845 un->un_vpd_page_mask |= SD_VPD_OPERATING_PG;
5846 break;
5847 case 0x82:
5848 un->un_vpd_page_mask |= SD_VPD_ASCII_OP_PG;
5849 break;
5850 case 0x83:
5851 un->un_vpd_page_mask |= SD_VPD_DEVID_WWN_PG;
5852 break;
5853 case 0x86:
5854 un->un_vpd_page_mask |= SD_VPD_EXTENDED_DATA_PG;
5855 break;
5856 case 0xB1:
5857 un->un_vpd_page_mask |= SD_VPD_DEV_CHARACTER_PG;
5858 break;
5859 }
5860 counter++;
5861 }
5862
5863 } else {
5864 rval = -1;
5865
5866 SD_INFO(SD_LOG_ATTACH_DETACH, un,
5867 "sd_check_vpd_page_support: This drive does not implement "
5868 "VPD pages.\n");
5869 }
5870
5871 kmem_free(page_list, page_length);
5872
5873 return (rval);
5874 }
5875
5876
5877 /*
5878 * Function: sd_setup_pm
5879 *
5880 * Description: Initialize Power Management on the device
5881 *
5882 * Context: Kernel Thread
5883 */
5884
5885 static void
5886 sd_setup_pm(sd_ssc_t *ssc, dev_info_t *devi)
5887 {
5888 uint_t log_page_size;
5889 uchar_t *log_page_data;
5890 int rval = 0;
5891 struct sd_lun *un;
5892
5893 ASSERT(ssc != NULL);
5894 un = ssc->ssc_un;
5895 ASSERT(un != NULL);
5896
5897 /*
5898 * Since we are called from attach, holding a mutex for
5899 * un is unnecessary. Because some of the routines called
5900 * from here require SD_MUTEX to not be held, assert this
5901 * right up front.
5902 */
5903 ASSERT(!mutex_owned(SD_MUTEX(un)));
5904 /*
5905 * Since the sd device does not have the 'reg' property,
5906 * cpr will not call its DDI_SUSPEND/DDI_RESUME entries.
5907 * The following code is to tell cpr that this device
5908 * DOES need to be suspended and resumed.
5909 */
5910 (void) ddi_prop_update_string(DDI_DEV_T_NONE, devi,
5911 "pm-hardware-state", "needs-suspend-resume");
5912
5913 /*
5914 * This complies with the new power management framework
5915 * for certain desktop machines. Create the pm_components
5916 * property as a string array property.
5917 * If un_f_pm_supported is TRUE, that means the disk
5918 * attached HBA has set the "pm-capable" property and
5919 * the value of this property is bigger than 0.
5920 */
5921 if (un->un_f_pm_supported) {
5922 /*
5923 * not all devices have a motor, try it first.
5924 * some devices may return ILLEGAL REQUEST, some
5925 * will hang
5926 * The following START_STOP_UNIT is used to check if target
5927 * device has a motor.
5928 */
5929 un->un_f_start_stop_supported = TRUE;
5930
5931 if (un->un_f_power_condition_supported) {
5932 rval = sd_send_scsi_START_STOP_UNIT(ssc,
5933 SD_POWER_CONDITION, SD_TARGET_ACTIVE,
5934 SD_PATH_DIRECT);
5935 if (rval != 0) {
5936 un->un_f_power_condition_supported = FALSE;
5937 }
5938 }
5939 if (!un->un_f_power_condition_supported) {
5940 rval = sd_send_scsi_START_STOP_UNIT(ssc,
5941 SD_START_STOP, SD_TARGET_START, SD_PATH_DIRECT);
5942 }
5943 if (rval != 0) {
5944 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
5945 un->un_f_start_stop_supported = FALSE;
5946 }
5947
5948 /*
5949 * create pm properties anyways otherwise the parent can't
5950 * go to sleep
5951 */
5952 un->un_f_pm_is_enabled = TRUE;
5953 (void) sd_create_pm_components(devi, un);
5954
5955 /*
5956 * If it claims that log sense is supported, check it out.
5957 */
5958 if (un->un_f_log_sense_supported) {
5959 rval = sd_log_page_supported(ssc,
5960 START_STOP_CYCLE_PAGE);
5961 if (rval == 1) {
5962 /* Page found, use it. */
5963 un->un_start_stop_cycle_page =
5964 START_STOP_CYCLE_PAGE;
5965 } else {
5966 /*
5967 * Page not found or log sense is not
5968 * supported.
5969 * Notice we do not check the old style
5970 * START_STOP_CYCLE_VU_PAGE because this
5971 * code path does not apply to old disks.
5972 */
5973 un->un_f_log_sense_supported = FALSE;
5974 un->un_f_pm_log_sense_smart = FALSE;
5975 }
5976 }
5977
5978 return;
5979 }
5980
5981 /*
5982 * For the disk whose attached HBA has not set the "pm-capable"
5983 * property, check if it supports the power management.
5984 */
5985 if (!un->un_f_log_sense_supported) {
5986 un->un_power_level = SD_SPINDLE_ON;
5987 un->un_f_pm_is_enabled = FALSE;
5988 return;
5989 }
5990
5991 rval = sd_log_page_supported(ssc, START_STOP_CYCLE_PAGE);
5992
5993 #ifdef SDDEBUG
5994 if (sd_force_pm_supported) {
5995 /* Force a successful result */
5996 rval = 1;
5997 }
5998 #endif
5999
6000 /*
6001 * If the start-stop cycle counter log page is not supported
6002 * or if the pm-capable property is set to be false (0),
6003 * then we should not create the pm_components property.
6004 */
6005 if (rval == -1) {
6006 /*
6007 * Error.
6008 * Reading log sense failed, most likely this is
6009 * an older drive that does not support log sense.
6010 * If this fails auto-pm is not supported.
6011 */
6012 un->un_power_level = SD_SPINDLE_ON;
6013 un->un_f_pm_is_enabled = FALSE;
6014
6015 } else if (rval == 0) {
6016 /*
6017 * Page not found.
6018 * The start stop cycle counter is implemented as page
6019 * START_STOP_CYCLE_PAGE_VU_PAGE (0x31) in older disks. For
6020 * newer disks it is implemented as START_STOP_CYCLE_PAGE (0xE).
6021 */
6022 if (sd_log_page_supported(ssc, START_STOP_CYCLE_VU_PAGE) == 1) {
6023 /*
6024 * Page found, use this one.
6025 */
6026 un->un_start_stop_cycle_page = START_STOP_CYCLE_VU_PAGE;
6027 un->un_f_pm_is_enabled = TRUE;
6028 } else {
6029 /*
6030 * Error or page not found.
6031 * auto-pm is not supported for this device.
6032 */
6033 un->un_power_level = SD_SPINDLE_ON;
6034 un->un_f_pm_is_enabled = FALSE;
6035 }
6036 } else {
6037 /*
6038 * Page found, use it.
6039 */
6040 un->un_start_stop_cycle_page = START_STOP_CYCLE_PAGE;
6041 un->un_f_pm_is_enabled = TRUE;
6042 }
6043
6044
6045 if (un->un_f_pm_is_enabled == TRUE) {
6046 log_page_size = START_STOP_CYCLE_COUNTER_PAGE_SIZE;
6047 log_page_data = kmem_zalloc(log_page_size, KM_SLEEP);
6048
6049 rval = sd_send_scsi_LOG_SENSE(ssc, log_page_data,
6050 log_page_size, un->un_start_stop_cycle_page,
6051 0x01, 0, SD_PATH_DIRECT);
6052
6053 if (rval != 0) {
6054 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
6055 }
6056
6057 #ifdef SDDEBUG
6058 if (sd_force_pm_supported) {
6059 /* Force a successful result */
6060 rval = 0;
6061 }
6062 #endif
6063
6064 /*
6065 * If the Log sense for Page( Start/stop cycle counter page)
6066 * succeeds, then power management is supported and we can
6067 * enable auto-pm.
6068 */
6069 if (rval == 0) {
6070 (void) sd_create_pm_components(devi, un);
6071 } else {
6072 un->un_power_level = SD_SPINDLE_ON;
6073 un->un_f_pm_is_enabled = FALSE;
6074 }
6075
6076 kmem_free(log_page_data, log_page_size);
6077 }
6078 }
6079
6080
6081 /*
6082 * Function: sd_create_pm_components
6083 *
6084 * Description: Initialize PM property.
6085 *
6086 * Context: Kernel thread context
6087 */
6088
6089 static void
6090 sd_create_pm_components(dev_info_t *devi, struct sd_lun *un)
6091 {
6092 ASSERT(!mutex_owned(SD_MUTEX(un)));
6093
6094 if (un->un_f_power_condition_supported) {
6095 if (ddi_prop_update_string_array(DDI_DEV_T_NONE, devi,
6096 "pm-components", sd_pwr_pc.pm_comp, 5)
6097 != DDI_PROP_SUCCESS) {
6098 un->un_power_level = SD_SPINDLE_ACTIVE;
6099 un->un_f_pm_is_enabled = FALSE;
6100 return;
6101 }
6102 } else {
6103 if (ddi_prop_update_string_array(DDI_DEV_T_NONE, devi,
6104 "pm-components", sd_pwr_ss.pm_comp, 3)
6105 != DDI_PROP_SUCCESS) {
6106 un->un_power_level = SD_SPINDLE_ON;
6107 un->un_f_pm_is_enabled = FALSE;
6108 return;
6109 }
6110 }
6111 /*
6112 * When components are initially created they are idle,
6113 * power up any non-removables.
6114 * Note: the return value of pm_raise_power can't be used
6115 * for determining if PM should be enabled for this device.
6116 * Even if you check the return values and remove this
6117 * property created above, the PM framework will not honor the
6118 * change after the first call to pm_raise_power. Hence,
6119 * removal of that property does not help if pm_raise_power
6120 * fails. In the case of removable media, the start/stop
6121 * will fail if the media is not present.
6122 */
6123 if (un->un_f_attach_spinup && (pm_raise_power(SD_DEVINFO(un), 0,
6124 SD_PM_STATE_ACTIVE(un)) == DDI_SUCCESS)) {
6125 mutex_enter(SD_MUTEX(un));
6126 un->un_power_level = SD_PM_STATE_ACTIVE(un);
6127 mutex_enter(&un->un_pm_mutex);
6128 /* Set to on and not busy. */
6129 un->un_pm_count = 0;
6130 } else {
6131 mutex_enter(SD_MUTEX(un));
6132 un->un_power_level = SD_PM_STATE_STOPPED(un);
6133 mutex_enter(&un->un_pm_mutex);
6134 /* Set to off. */
6135 un->un_pm_count = -1;
6136 }
6137 mutex_exit(&un->un_pm_mutex);
6138 mutex_exit(SD_MUTEX(un));
6139 }
6140
6141
6142 /*
6143 * Function: sd_ddi_suspend
6144 *
6145 * Description: Performs system power-down operations. This includes
6146 * setting the drive state to indicate its suspended so
6147 * that no new commands will be accepted. Also, wait for
6148 * all commands that are in transport or queued to a timer
6149 * for retry to complete. All timeout threads are cancelled.
6150 *
6151 * Return Code: DDI_FAILURE or DDI_SUCCESS
6152 *
6153 * Context: Kernel thread context
6154 */
6155
6156 static int
6157 sd_ddi_suspend(dev_info_t *devi)
6158 {
6159 struct sd_lun *un;
6160 clock_t wait_cmds_complete;
6161
6162 un = ddi_get_soft_state(sd_state, ddi_get_instance(devi));
6163 if (un == NULL) {
6164 return (DDI_FAILURE);
6165 }
6166
6167 SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_suspend: entry\n");
6168
6169 mutex_enter(SD_MUTEX(un));
6170
6171 /* Return success if the device is already suspended. */
6172 if (un->un_state == SD_STATE_SUSPENDED) {
6173 mutex_exit(SD_MUTEX(un));
6174 SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_suspend: "
6175 "device already suspended, exiting\n");
6176 return (DDI_SUCCESS);
6177 }
6178
6179 /* Return failure if the device is being used by HA */
6180 if (un->un_resvd_status &
6181 (SD_RESERVE | SD_WANT_RESERVE | SD_LOST_RESERVE)) {
6182 mutex_exit(SD_MUTEX(un));
6183 SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_suspend: "
6184 "device in use by HA, exiting\n");
6185 return (DDI_FAILURE);
6186 }
6187
6188 /*
6189 * Return failure if the device is in a resource wait
6190 * or power changing state.
6191 */
6192 if ((un->un_state == SD_STATE_RWAIT) ||
6193 (un->un_state == SD_STATE_PM_CHANGING)) {
6194 mutex_exit(SD_MUTEX(un));
6195 SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_suspend: "
6196 "device in resource wait state, exiting\n");
6197 return (DDI_FAILURE);
6198 }
6199
6200
6201 un->un_save_state = un->un_last_state;
6202 New_state(un, SD_STATE_SUSPENDED);
6203
6204 /*
6205 * Wait for all commands that are in transport or queued to a timer
6206 * for retry to complete.
6207 *
6208 * While waiting, no new commands will be accepted or sent because of
6209 * the new state we set above.
6210 *
6211 * Wait till current operation has completed. If we are in the resource
6212 * wait state (with an intr outstanding) then we need to wait till the
6213 * intr completes and starts the next cmd. We want to wait for
6214 * SD_WAIT_CMDS_COMPLETE seconds before failing the DDI_SUSPEND.
6215 */
6216 wait_cmds_complete = ddi_get_lbolt() +
6217 (sd_wait_cmds_complete * drv_usectohz(1000000));
6218
6219 while (un->un_ncmds_in_transport != 0) {
6220 /*
6221 * Fail if commands do not finish in the specified time.
6222 */
6223 if (cv_timedwait(&un->un_disk_busy_cv, SD_MUTEX(un),
6224 wait_cmds_complete) == -1) {
6225 /*
6226 * Undo the state changes made above. Everything
6227 * must go back to it's original value.
6228 */
6229 Restore_state(un);
6230 un->un_last_state = un->un_save_state;
6231 /* Wake up any threads that might be waiting. */
6232 cv_broadcast(&un->un_suspend_cv);
6233 mutex_exit(SD_MUTEX(un));
6234 SD_ERROR(SD_LOG_IO_PM, un,
6235 "sd_ddi_suspend: failed due to outstanding cmds\n");
6236 SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_suspend: exiting\n");
6237 return (DDI_FAILURE);
6238 }
6239 }
6240
6241 /*
6242 * Cancel SCSI watch thread and timeouts, if any are active
6243 */
6244
6245 if (SD_OK_TO_SUSPEND_SCSI_WATCHER(un)) {
6246 opaque_t temp_token = un->un_swr_token;
6247 mutex_exit(SD_MUTEX(un));
6248 scsi_watch_suspend(temp_token);
6249 mutex_enter(SD_MUTEX(un));
6250 }
6251
6252 if (un->un_reset_throttle_timeid != NULL) {
6253 timeout_id_t temp_id = un->un_reset_throttle_timeid;
6254 un->un_reset_throttle_timeid = NULL;
6255 mutex_exit(SD_MUTEX(un));
6256 (void) untimeout(temp_id);
6257 mutex_enter(SD_MUTEX(un));
6258 }
6259
6260 if (un->un_dcvb_timeid != NULL) {
6261 timeout_id_t temp_id = un->un_dcvb_timeid;
6262 un->un_dcvb_timeid = NULL;
6263 mutex_exit(SD_MUTEX(un));
6264 (void) untimeout(temp_id);
6265 mutex_enter(SD_MUTEX(un));
6266 }
6267
6268 mutex_enter(&un->un_pm_mutex);
6269 if (un->un_pm_timeid != NULL) {
6270 timeout_id_t temp_id = un->un_pm_timeid;
6271 un->un_pm_timeid = NULL;
6272 mutex_exit(&un->un_pm_mutex);
6273 mutex_exit(SD_MUTEX(un));
6274 (void) untimeout(temp_id);
6275 mutex_enter(SD_MUTEX(un));
6276 } else {
6277 mutex_exit(&un->un_pm_mutex);
6278 }
6279
6280 if (un->un_rmw_msg_timeid != NULL) {
6281 timeout_id_t temp_id = un->un_rmw_msg_timeid;
6282 un->un_rmw_msg_timeid = NULL;
6283 mutex_exit(SD_MUTEX(un));
6284 (void) untimeout(temp_id);
6285 mutex_enter(SD_MUTEX(un));
6286 }
6287
6288 if (un->un_retry_timeid != NULL) {
6289 timeout_id_t temp_id = un->un_retry_timeid;
6290 un->un_retry_timeid = NULL;
6291 mutex_exit(SD_MUTEX(un));
6292 (void) untimeout(temp_id);
6293 mutex_enter(SD_MUTEX(un));
6294
6295 if (un->un_retry_bp != NULL) {
6296 un->un_retry_bp->av_forw = un->un_waitq_headp;
6297 un->un_waitq_headp = un->un_retry_bp;
6298 if (un->un_waitq_tailp == NULL) {
6299 un->un_waitq_tailp = un->un_retry_bp;
6300 }
6301 un->un_retry_bp = NULL;
6302 un->un_retry_statp = NULL;
6303 }
6304 }
6305
6306 if (un->un_direct_priority_timeid != NULL) {
6307 timeout_id_t temp_id = un->un_direct_priority_timeid;
6308 un->un_direct_priority_timeid = NULL;
6309 mutex_exit(SD_MUTEX(un));
6310 (void) untimeout(temp_id);
6311 mutex_enter(SD_MUTEX(un));
6312 }
6313
6314 if (un->un_f_is_fibre == TRUE) {
6315 /*
6316 * Remove callbacks for insert and remove events
6317 */
6318 if (un->un_insert_event != NULL) {
6319 mutex_exit(SD_MUTEX(un));
6320 (void) ddi_remove_event_handler(un->un_insert_cb_id);
6321 mutex_enter(SD_MUTEX(un));
6322 un->un_insert_event = NULL;
6323 }
6324
6325 if (un->un_remove_event != NULL) {
6326 mutex_exit(SD_MUTEX(un));
6327 (void) ddi_remove_event_handler(un->un_remove_cb_id);
6328 mutex_enter(SD_MUTEX(un));
6329 un->un_remove_event = NULL;
6330 }
6331 }
6332
6333 mutex_exit(SD_MUTEX(un));
6334
6335 SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_suspend: exit\n");
6336
6337 return (DDI_SUCCESS);
6338 }
6339
6340
6341 /*
6342 * Function: sd_ddi_resume
6343 *
6344 * Description: Performs system power-up operations..
6345 *
6346 * Return Code: DDI_SUCCESS
6347 * DDI_FAILURE
6348 *
6349 * Context: Kernel thread context
6350 */
6351
6352 static int
6353 sd_ddi_resume(dev_info_t *devi)
6354 {
6355 struct sd_lun *un;
6356
6357 un = ddi_get_soft_state(sd_state, ddi_get_instance(devi));
6358 if (un == NULL) {
6359 return (DDI_FAILURE);
6360 }
6361
6362 SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_resume: entry\n");
6363
6364 mutex_enter(SD_MUTEX(un));
6365 Restore_state(un);
6366
6367 /*
6368 * Restore the state which was saved to give the
6369 * the right state in un_last_state
6370 */
6371 un->un_last_state = un->un_save_state;
6372 /*
6373 * Note: throttle comes back at full.
6374 * Also note: this MUST be done before calling pm_raise_power
6375 * otherwise the system can get hung in biowait. The scenario where
6376 * this'll happen is under cpr suspend. Writing of the system
6377 * state goes through sddump, which writes 0 to un_throttle. If
6378 * writing the system state then fails, example if the partition is
6379 * too small, then cpr attempts a resume. If throttle isn't restored
6380 * from the saved value until after calling pm_raise_power then
6381 * cmds sent in sdpower are not transported and sd_send_scsi_cmd hangs
6382 * in biowait.
6383 */
6384 un->un_throttle = un->un_saved_throttle;
6385
6386 /*
6387 * The chance of failure is very rare as the only command done in power
6388 * entry point is START command when you transition from 0->1 or
6389 * unknown->1. Put it to SPINDLE ON state irrespective of the state at
6390 * which suspend was done. Ignore the return value as the resume should
6391 * not be failed. In the case of removable media the media need not be
6392 * inserted and hence there is a chance that raise power will fail with
6393 * media not present.
6394 */
6395 if (un->un_f_attach_spinup) {
6396 mutex_exit(SD_MUTEX(un));
6397 (void) pm_raise_power(SD_DEVINFO(un), 0,
6398 SD_PM_STATE_ACTIVE(un));
6399 mutex_enter(SD_MUTEX(un));
6400 }
6401
6402 /*
6403 * Don't broadcast to the suspend cv and therefore possibly
6404 * start I/O until after power has been restored.
6405 */
6406 cv_broadcast(&un->un_suspend_cv);
6407 cv_broadcast(&un->un_state_cv);
6408
6409 /* restart thread */
6410 if (SD_OK_TO_RESUME_SCSI_WATCHER(un)) {
6411 scsi_watch_resume(un->un_swr_token);
6412 }
6413
6414 #if (defined(__fibre))
6415 if (un->un_f_is_fibre == TRUE) {
6416 /*
6417 * Add callbacks for insert and remove events
6418 */
6419 if (strcmp(un->un_node_type, DDI_NT_BLOCK_CHAN)) {
6420 sd_init_event_callbacks(un);
6421 }
6422 }
6423 #endif
6424
6425 /*
6426 * Transport any pending commands to the target.
6427 *
6428 * If this is a low-activity device commands in queue will have to wait
6429 * until new commands come in, which may take awhile. Also, we
6430 * specifically don't check un_ncmds_in_transport because we know that
6431 * there really are no commands in progress after the unit was
6432 * suspended and we could have reached the throttle level, been
6433 * suspended, and have no new commands coming in for awhile. Highly
6434 * unlikely, but so is the low-activity disk scenario.
6435 */
6436 ddi_xbuf_dispatch(un->un_xbuf_attr);
6437
6438 sd_start_cmds(un, NULL);
6439 mutex_exit(SD_MUTEX(un));
6440
6441 SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_resume: exit\n");
6442
6443 return (DDI_SUCCESS);
6444 }
6445
6446
6447 /*
6448 * Function: sd_pm_state_change
6449 *
6450 * Description: Change the driver power state.
6451 * Someone else is required to actually change the driver
6452 * power level.
6453 *
6454 * Arguments: un - driver soft state (unit) structure
6455 * level - the power level that is changed to
6456 * flag - to decide how to change the power state
6457 *
6458 * Return Code: DDI_SUCCESS
6459 *
6460 * Context: Kernel thread context
6461 */
6462 static int
6463 sd_pm_state_change(struct sd_lun *un, int level, int flag)
6464 {
6465 ASSERT(un != NULL);
6466 SD_TRACE(SD_LOG_POWER, un, "sd_pm_state_change: entry\n");
6467
6468 ASSERT(!mutex_owned(SD_MUTEX(un)));
6469 mutex_enter(SD_MUTEX(un));
6470
6471 if (flag == SD_PM_STATE_ROLLBACK || SD_PM_IS_IO_CAPABLE(un, level)) {
6472 un->un_power_level = level;
6473 ASSERT(!mutex_owned(&un->un_pm_mutex));
6474 mutex_enter(&un->un_pm_mutex);
6475 if (SD_DEVICE_IS_IN_LOW_POWER(un)) {
6476 un->un_pm_count++;
6477 ASSERT(un->un_pm_count == 0);
6478 }
6479 mutex_exit(&un->un_pm_mutex);
6480 } else {
6481 /*
6482 * Exit if power management is not enabled for this device,
6483 * or if the device is being used by HA.
6484 */
6485 if ((un->un_f_pm_is_enabled == FALSE) || (un->un_resvd_status &
6486 (SD_RESERVE | SD_WANT_RESERVE | SD_LOST_RESERVE))) {
6487 mutex_exit(SD_MUTEX(un));
6488 SD_TRACE(SD_LOG_POWER, un,
6489 "sd_pm_state_change: exiting\n");
6490 return (DDI_FAILURE);
6491 }
6492
6493 SD_INFO(SD_LOG_POWER, un, "sd_pm_state_change: "
6494 "un_ncmds_in_driver=%ld\n", un->un_ncmds_in_driver);
6495
6496 /*
6497 * See if the device is not busy, ie.:
6498 * - we have no commands in the driver for this device
6499 * - not waiting for resources
6500 */
6501 if ((un->un_ncmds_in_driver == 0) &&
6502 (un->un_state != SD_STATE_RWAIT)) {
6503 /*
6504 * The device is not busy, so it is OK to go to low
6505 * power state. Indicate low power, but rely on someone
6506 * else to actually change it.
6507 */
6508 mutex_enter(&un->un_pm_mutex);
6509 un->un_pm_count = -1;
6510 mutex_exit(&un->un_pm_mutex);
6511 un->un_power_level = level;
6512 }
6513 }
6514
6515 mutex_exit(SD_MUTEX(un));
6516
6517 SD_TRACE(SD_LOG_POWER, un, "sd_pm_state_change: exit\n");
6518
6519 return (DDI_SUCCESS);
6520 }
6521
6522
6523 /*
6524 * Function: sd_pm_idletimeout_handler
6525 *
6526 * Description: A timer routine that's active only while a device is busy.
6527 * The purpose is to extend slightly the pm framework's busy
6528 * view of the device to prevent busy/idle thrashing for
6529 * back-to-back commands. Do this by comparing the current time
6530 * to the time at which the last command completed and when the
6531 * difference is greater than sd_pm_idletime, call
6532 * pm_idle_component. In addition to indicating idle to the pm
6533 * framework, update the chain type to again use the internal pm
6534 * layers of the driver.
6535 *
6536 * Arguments: arg - driver soft state (unit) structure
6537 *
6538 * Context: Executes in a timeout(9F) thread context
6539 */
6540
6541 static void
6542 sd_pm_idletimeout_handler(void *arg)
6543 {
6544 const hrtime_t idletime = sd_pm_idletime * NANOSEC;
6545 struct sd_lun *un = arg;
6546
6547 mutex_enter(&sd_detach_mutex);
6548 if (un->un_detach_count != 0) {
6549 /* Abort if the instance is detaching */
6550 mutex_exit(&sd_detach_mutex);
6551 return;
6552 }
6553 mutex_exit(&sd_detach_mutex);
6554
6555 /*
6556 * Grab both mutexes, in the proper order, since we're accessing
6557 * both PM and softstate variables.
6558 */
6559 mutex_enter(SD_MUTEX(un));
6560 mutex_enter(&un->un_pm_mutex);
6561 if (((gethrtime() - un->un_pm_idle_time) > idletime) &&
6562 (un->un_ncmds_in_driver == 0) && (un->un_pm_count == 0)) {
6563 /*
6564 * Update the chain types.
6565 * This takes affect on the next new command received.
6566 */
6567 if (un->un_f_non_devbsize_supported) {
6568 un->un_buf_chain_type = SD_CHAIN_INFO_RMMEDIA;
6569 } else {
6570 un->un_buf_chain_type = SD_CHAIN_INFO_DISK;
6571 }
6572 un->un_uscsi_chain_type = SD_CHAIN_INFO_USCSI_CMD;
6573
6574 SD_TRACE(SD_LOG_IO_PM, un,
6575 "sd_pm_idletimeout_handler: idling device\n");
6576 (void) pm_idle_component(SD_DEVINFO(un), 0);
6577 un->un_pm_idle_timeid = NULL;
6578 } else {
6579 un->un_pm_idle_timeid =
6580 timeout(sd_pm_idletimeout_handler, un,
6581 (drv_usectohz((clock_t)300000))); /* 300 ms. */
6582 }
6583 mutex_exit(&un->un_pm_mutex);
6584 mutex_exit(SD_MUTEX(un));
6585 }
6586
6587
6588 /*
6589 * Function: sd_pm_timeout_handler
6590 *
6591 * Description: Callback to tell framework we are idle.
6592 *
6593 * Context: timeout(9f) thread context.
6594 */
6595
6596 static void
6597 sd_pm_timeout_handler(void *arg)
6598 {
6599 struct sd_lun *un = arg;
6600
6601 (void) pm_idle_component(SD_DEVINFO(un), 0);
6602 mutex_enter(&un->un_pm_mutex);
6603 un->un_pm_timeid = NULL;
6604 mutex_exit(&un->un_pm_mutex);
6605 }
6606
6607
6608 /*
6609 * Function: sdpower
6610 *
6611 * Description: PM entry point.
6612 *
6613 * Return Code: DDI_SUCCESS
6614 * DDI_FAILURE
6615 *
6616 * Context: Kernel thread context
6617 */
6618
6619 static int
6620 sdpower(dev_info_t *devi, int component, int level)
6621 {
6622 struct sd_lun *un;
6623 int instance;
6624 int rval = DDI_SUCCESS;
6625 uint_t i, log_page_size, maxcycles, ncycles;
6626 uchar_t *log_page_data;
6627 int log_sense_page;
6628 int medium_present;
6629 time_t intvlp;
6630 struct pm_trans_data sd_pm_tran_data;
6631 uchar_t save_state;
6632 int sval;
6633 uchar_t state_before_pm;
6634 int got_semaphore_here;
6635 sd_ssc_t *ssc;
6636 int last_power_level;
6637
6638 instance = ddi_get_instance(devi);
6639
6640 if (((un = ddi_get_soft_state(sd_state, instance)) == NULL) ||
6641 !SD_PM_IS_LEVEL_VALID(un, level) || component != 0) {
6642 return (DDI_FAILURE);
6643 }
6644
6645 ssc = sd_ssc_init(un);
6646
6647 SD_TRACE(SD_LOG_IO_PM, un, "sdpower: entry, level = %d\n", level);
6648
6649 /*
6650 * Must synchronize power down with close.
6651 * Attempt to decrement/acquire the open/close semaphore,
6652 * but do NOT wait on it. If it's not greater than zero,
6653 * ie. it can't be decremented without waiting, then
6654 * someone else, either open or close, already has it
6655 * and the try returns 0. Use that knowledge here to determine
6656 * if it's OK to change the device power level.
6657 * Also, only increment it on exit if it was decremented, ie. gotten,
6658 * here.
6659 */
6660 got_semaphore_here = sema_tryp(&un->un_semoclose);
6661
6662 mutex_enter(SD_MUTEX(un));
6663
6664 SD_INFO(SD_LOG_POWER, un, "sdpower: un_ncmds_in_driver = %ld\n",
6665 un->un_ncmds_in_driver);
6666
6667 /*
6668 * If un_ncmds_in_driver is non-zero it indicates commands are
6669 * already being processed in the driver, or if the semaphore was
6670 * not gotten here it indicates an open or close is being processed.
6671 * At the same time somebody is requesting to go to a lower power
6672 * that can't perform I/O, which can't happen, therefore we need to
6673 * return failure.
6674 */
6675 if ((!SD_PM_IS_IO_CAPABLE(un, level)) &&
6676 ((un->un_ncmds_in_driver != 0) || (got_semaphore_here == 0))) {
6677 mutex_exit(SD_MUTEX(un));
6678
6679 if (got_semaphore_here != 0) {
6680 sema_v(&un->un_semoclose);
6681 }
6682 SD_TRACE(SD_LOG_IO_PM, un,
6683 "sdpower: exit, device has queued cmds.\n");
6684
6685 goto sdpower_failed;
6686 }
6687
6688 /*
6689 * if it is OFFLINE that means the disk is completely dead
6690 * in our case we have to put the disk in on or off by sending commands
6691 * Of course that will fail anyway so return back here.
6692 *
6693 * Power changes to a device that's OFFLINE or SUSPENDED
6694 * are not allowed.
6695 */
6696 if ((un->un_state == SD_STATE_OFFLINE) ||
6697 (un->un_state == SD_STATE_SUSPENDED)) {
6698 mutex_exit(SD_MUTEX(un));
6699
6700 if (got_semaphore_here != 0) {
6701 sema_v(&un->un_semoclose);
6702 }
6703 SD_TRACE(SD_LOG_IO_PM, un,
6704 "sdpower: exit, device is off-line.\n");
6705
6706 goto sdpower_failed;
6707 }
6708
6709 /*
6710 * Change the device's state to indicate it's power level
6711 * is being changed. Do this to prevent a power off in the
6712 * middle of commands, which is especially bad on devices
6713 * that are really powered off instead of just spun down.
6714 */
6715 state_before_pm = un->un_state;
6716 un->un_state = SD_STATE_PM_CHANGING;
6717
6718 mutex_exit(SD_MUTEX(un));
6719
6720 /*
6721 * If log sense command is not supported, bypass the
6722 * following checking, otherwise, check the log sense
6723 * information for this device.
6724 */
6725 if (SD_PM_STOP_MOTOR_NEEDED(un, level) &&
6726 un->un_f_log_sense_supported) {
6727 /*
6728 * Get the log sense information to understand whether the
6729 * the powercycle counts have gone beyond the threshhold.
6730 */
6731 log_page_size = START_STOP_CYCLE_COUNTER_PAGE_SIZE;
6732 log_page_data = kmem_zalloc(log_page_size, KM_SLEEP);
6733
6734 mutex_enter(SD_MUTEX(un));
6735 log_sense_page = un->un_start_stop_cycle_page;
6736 mutex_exit(SD_MUTEX(un));
6737
6738 rval = sd_send_scsi_LOG_SENSE(ssc, log_page_data,
6739 log_page_size, log_sense_page, 0x01, 0, SD_PATH_DIRECT);
6740
6741 if (rval != 0) {
6742 if (rval == EIO)
6743 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
6744 else
6745 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
6746 }
6747
6748 #ifdef SDDEBUG
6749 if (sd_force_pm_supported) {
6750 /* Force a successful result */
6751 rval = 0;
6752 }
6753 #endif
6754 if (rval != 0) {
6755 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
6756 "Log Sense Failed\n");
6757
6758 kmem_free(log_page_data, log_page_size);
6759 /* Cannot support power management on those drives */
6760
6761 if (got_semaphore_here != 0) {
6762 sema_v(&un->un_semoclose);
6763 }
6764 /*
6765 * On exit put the state back to it's original value
6766 * and broadcast to anyone waiting for the power
6767 * change completion.
6768 */
6769 mutex_enter(SD_MUTEX(un));
6770 un->un_state = state_before_pm;
6771 cv_broadcast(&un->un_suspend_cv);
6772 mutex_exit(SD_MUTEX(un));
6773 SD_TRACE(SD_LOG_IO_PM, un,
6774 "sdpower: exit, Log Sense Failed.\n");
6775
6776 goto sdpower_failed;
6777 }
6778
6779 /*
6780 * From the page data - Convert the essential information to
6781 * pm_trans_data
6782 */
6783 maxcycles =
6784 (log_page_data[0x1c] << 24) | (log_page_data[0x1d] << 16) |
6785 (log_page_data[0x1E] << 8) | log_page_data[0x1F];
6786
6787 ncycles =
6788 (log_page_data[0x24] << 24) | (log_page_data[0x25] << 16) |
6789 (log_page_data[0x26] << 8) | log_page_data[0x27];
6790
6791 if (un->un_f_pm_log_sense_smart) {
6792 sd_pm_tran_data.un.smart_count.allowed = maxcycles;
6793 sd_pm_tran_data.un.smart_count.consumed = ncycles;
6794 sd_pm_tran_data.un.smart_count.flag = 0;
6795 sd_pm_tran_data.format = DC_SMART_FORMAT;
6796 } else {
6797 sd_pm_tran_data.un.scsi_cycles.lifemax = maxcycles;
6798 sd_pm_tran_data.un.scsi_cycles.ncycles = ncycles;
6799 for (i = 0; i < DC_SCSI_MFR_LEN; i++) {
6800 sd_pm_tran_data.un.scsi_cycles.svc_date[i] =
6801 log_page_data[8+i];
6802 }
6803 sd_pm_tran_data.un.scsi_cycles.flag = 0;
6804 sd_pm_tran_data.format = DC_SCSI_FORMAT;
6805 }
6806
6807 kmem_free(log_page_data, log_page_size);
6808
6809 /*
6810 * Call pm_trans_check routine to get the Ok from
6811 * the global policy
6812 */
6813 rval = pm_trans_check(&sd_pm_tran_data, &intvlp);
6814 #ifdef SDDEBUG
6815 if (sd_force_pm_supported) {
6816 /* Force a successful result */
6817 rval = 1;
6818 }
6819 #endif
6820 switch (rval) {
6821 case 0:
6822 /*
6823 * Not Ok to Power cycle or error in parameters passed
6824 * Would have given the advised time to consider power
6825 * cycle. Based on the new intvlp parameter we are
6826 * supposed to pretend we are busy so that pm framework
6827 * will never call our power entry point. Because of
6828 * that install a timeout handler and wait for the
6829 * recommended time to elapse so that power management
6830 * can be effective again.
6831 *
6832 * To effect this behavior, call pm_busy_component to
6833 * indicate to the framework this device is busy.
6834 * By not adjusting un_pm_count the rest of PM in
6835 * the driver will function normally, and independent
6836 * of this but because the framework is told the device
6837 * is busy it won't attempt powering down until it gets
6838 * a matching idle. The timeout handler sends this.
6839 * Note: sd_pm_entry can't be called here to do this
6840 * because sdpower may have been called as a result
6841 * of a call to pm_raise_power from within sd_pm_entry.
6842 *
6843 * If a timeout handler is already active then
6844 * don't install another.
6845 */
6846 mutex_enter(&un->un_pm_mutex);
6847 if (un->un_pm_timeid == NULL) {
6848 un->un_pm_timeid =
6849 timeout(sd_pm_timeout_handler,
6850 un, intvlp * drv_usectohz(1000000));
6851 mutex_exit(&un->un_pm_mutex);
6852 (void) pm_busy_component(SD_DEVINFO(un), 0);
6853 } else {
6854 mutex_exit(&un->un_pm_mutex);
6855 }
6856 if (got_semaphore_here != 0) {
6857 sema_v(&un->un_semoclose);
6858 }
6859 /*
6860 * On exit put the state back to it's original value
6861 * and broadcast to anyone waiting for the power
6862 * change completion.
6863 */
6864 mutex_enter(SD_MUTEX(un));
6865 un->un_state = state_before_pm;
6866 cv_broadcast(&un->un_suspend_cv);
6867 mutex_exit(SD_MUTEX(un));
6868
6869 SD_TRACE(SD_LOG_IO_PM, un, "sdpower: exit, "
6870 "trans check Failed, not ok to power cycle.\n");
6871
6872 goto sdpower_failed;
6873 case -1:
6874 if (got_semaphore_here != 0) {
6875 sema_v(&un->un_semoclose);
6876 }
6877 /*
6878 * On exit put the state back to it's original value
6879 * and broadcast to anyone waiting for the power
6880 * change completion.
6881 */
6882 mutex_enter(SD_MUTEX(un));
6883 un->un_state = state_before_pm;
6884 cv_broadcast(&un->un_suspend_cv);
6885 mutex_exit(SD_MUTEX(un));
6886 SD_TRACE(SD_LOG_IO_PM, un,
6887 "sdpower: exit, trans check command Failed.\n");
6888
6889 goto sdpower_failed;
6890 }
6891 }
6892
6893 if (!SD_PM_IS_IO_CAPABLE(un, level)) {
6894 /*
6895 * Save the last state... if the STOP FAILS we need it
6896 * for restoring
6897 */
6898 mutex_enter(SD_MUTEX(un));
6899 save_state = un->un_last_state;
6900 last_power_level = un->un_power_level;
6901 /*
6902 * There must not be any cmds. getting processed
6903 * in the driver when we get here. Power to the
6904 * device is potentially going off.
6905 */
6906 ASSERT(un->un_ncmds_in_driver == 0);
6907 mutex_exit(SD_MUTEX(un));
6908
6909 /*
6910 * For now PM suspend the device completely before spindle is
6911 * turned off
6912 */
6913 if ((rval = sd_pm_state_change(un, level, SD_PM_STATE_CHANGE))
6914 == DDI_FAILURE) {
6915 if (got_semaphore_here != 0) {
6916 sema_v(&un->un_semoclose);
6917 }
6918 /*
6919 * On exit put the state back to it's original value
6920 * and broadcast to anyone waiting for the power
6921 * change completion.
6922 */
6923 mutex_enter(SD_MUTEX(un));
6924 un->un_state = state_before_pm;
6925 un->un_power_level = last_power_level;
6926 cv_broadcast(&un->un_suspend_cv);
6927 mutex_exit(SD_MUTEX(un));
6928 SD_TRACE(SD_LOG_IO_PM, un,
6929 "sdpower: exit, PM suspend Failed.\n");
6930
6931 goto sdpower_failed;
6932 }
6933 }
6934
6935 /*
6936 * The transition from SPINDLE_OFF to SPINDLE_ON can happen in open,
6937 * close, or strategy. Dump no long uses this routine, it uses it's
6938 * own code so it can be done in polled mode.
6939 */
6940
6941 medium_present = TRUE;
6942
6943 /*
6944 * When powering up, issue a TUR in case the device is at unit
6945 * attention. Don't do retries. Bypass the PM layer, otherwise
6946 * a deadlock on un_pm_busy_cv will occur.
6947 */
6948 if (SD_PM_IS_IO_CAPABLE(un, level)) {
6949 sval = sd_send_scsi_TEST_UNIT_READY(ssc,
6950 SD_DONT_RETRY_TUR | SD_BYPASS_PM);
6951 if (sval != 0)
6952 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
6953 }
6954
6955 if (un->un_f_power_condition_supported) {
6956 char *pm_condition_name[] = {"STOPPED", "STANDBY",
6957 "IDLE", "ACTIVE"};
6958 SD_TRACE(SD_LOG_IO_PM, un,
6959 "sdpower: sending \'%s\' power condition",
6960 pm_condition_name[level]);
6961 sval = sd_send_scsi_START_STOP_UNIT(ssc, SD_POWER_CONDITION,
6962 sd_pl2pc[level], SD_PATH_DIRECT);
6963 } else {
6964 SD_TRACE(SD_LOG_IO_PM, un, "sdpower: sending \'%s\' unit\n",
6965 ((level == SD_SPINDLE_ON) ? "START" : "STOP"));
6966 sval = sd_send_scsi_START_STOP_UNIT(ssc, SD_START_STOP,
6967 ((level == SD_SPINDLE_ON) ? SD_TARGET_START :
6968 SD_TARGET_STOP), SD_PATH_DIRECT);
6969 }
6970 if (sval != 0) {
6971 if (sval == EIO)
6972 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
6973 else
6974 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
6975 }
6976
6977 /* Command failed, check for media present. */
6978 if ((sval == ENXIO) && un->un_f_has_removable_media) {
6979 medium_present = FALSE;
6980 }
6981
6982 /*
6983 * The conditions of interest here are:
6984 * if a spindle off with media present fails,
6985 * then restore the state and return an error.
6986 * else if a spindle on fails,
6987 * then return an error (there's no state to restore).
6988 * In all other cases we setup for the new state
6989 * and return success.
6990 */
6991 if (!SD_PM_IS_IO_CAPABLE(un, level)) {
6992 if ((medium_present == TRUE) && (sval != 0)) {
6993 /* The stop command from above failed */
6994 rval = DDI_FAILURE;
6995 /*
6996 * The stop command failed, and we have media
6997 * present. Put the level back by calling the
6998 * sd_pm_resume() and set the state back to
6999 * it's previous value.
7000 */
7001 (void) sd_pm_state_change(un, last_power_level,
7002 SD_PM_STATE_ROLLBACK);
7003 mutex_enter(SD_MUTEX(un));
7004 un->un_last_state = save_state;
7005 mutex_exit(SD_MUTEX(un));
7006 } else if (un->un_f_monitor_media_state) {
7007 /*
7008 * The stop command from above succeeded.
7009 * Terminate watch thread in case of removable media
7010 * devices going into low power state. This is as per
7011 * the requirements of pm framework, otherwise commands
7012 * will be generated for the device (through watch
7013 * thread), even when the device is in low power state.
7014 */
7015 mutex_enter(SD_MUTEX(un));
7016 un->un_f_watcht_stopped = FALSE;
7017 if (un->un_swr_token != NULL) {
7018 opaque_t temp_token = un->un_swr_token;
7019 un->un_f_watcht_stopped = TRUE;
7020 un->un_swr_token = NULL;
7021 mutex_exit(SD_MUTEX(un));
7022 (void) scsi_watch_request_terminate(temp_token,
7023 SCSI_WATCH_TERMINATE_ALL_WAIT);
7024 } else {
7025 mutex_exit(SD_MUTEX(un));
7026 }
7027 }
7028 } else {
7029 /*
7030 * The level requested is I/O capable.
7031 * Legacy behavior: return success on a failed spinup
7032 * if there is no media in the drive.
7033 * Do this by looking at medium_present here.
7034 */
7035 if ((sval != 0) && medium_present) {
7036 /* The start command from above failed */
7037 rval = DDI_FAILURE;
7038 } else {
7039 /*
7040 * The start command from above succeeded
7041 * PM resume the devices now that we have
7042 * started the disks
7043 */
7044 (void) sd_pm_state_change(un, level,
7045 SD_PM_STATE_CHANGE);
7046
7047 /*
7048 * Resume the watch thread since it was suspended
7049 * when the device went into low power mode.
7050 */
7051 if (un->un_f_monitor_media_state) {
7052 mutex_enter(SD_MUTEX(un));
7053 if (un->un_f_watcht_stopped == TRUE) {
7054 opaque_t temp_token;
7055
7056 un->un_f_watcht_stopped = FALSE;
7057 mutex_exit(SD_MUTEX(un));
7058 temp_token =
7059 sd_watch_request_submit(un);
7060 mutex_enter(SD_MUTEX(un));
7061 un->un_swr_token = temp_token;
7062 }
7063 mutex_exit(SD_MUTEX(un));
7064 }
7065 }
7066 }
7067
7068 if (got_semaphore_here != 0) {
7069 sema_v(&un->un_semoclose);
7070 }
7071 /*
7072 * On exit put the state back to it's original value
7073 * and broadcast to anyone waiting for the power
7074 * change completion.
7075 */
7076 mutex_enter(SD_MUTEX(un));
7077 un->un_state = state_before_pm;
7078 cv_broadcast(&un->un_suspend_cv);
7079 mutex_exit(SD_MUTEX(un));
7080
7081 SD_TRACE(SD_LOG_IO_PM, un, "sdpower: exit, status = 0x%x\n", rval);
7082
7083 sd_ssc_fini(ssc);
7084 return (rval);
7085
7086 sdpower_failed:
7087
7088 sd_ssc_fini(ssc);
7089 return (DDI_FAILURE);
7090 }
7091
7092
7093
7094 /*
7095 * Function: sdattach
7096 *
7097 * Description: Driver's attach(9e) entry point function.
7098 *
7099 * Arguments: devi - opaque device info handle
7100 * cmd - attach type
7101 *
7102 * Return Code: DDI_SUCCESS
7103 * DDI_FAILURE
7104 *
7105 * Context: Kernel thread context
7106 */
7107
7108 static int
7109 sdattach(dev_info_t *devi, ddi_attach_cmd_t cmd)
7110 {
7111 switch (cmd) {
7112 case DDI_ATTACH:
7113 return (sd_unit_attach(devi));
7114 case DDI_RESUME:
7115 return (sd_ddi_resume(devi));
7116 default:
7117 break;
7118 }
7119 return (DDI_FAILURE);
7120 }
7121
7122
7123 /*
7124 * Function: sddetach
7125 *
7126 * Description: Driver's detach(9E) entry point function.
7127 *
7128 * Arguments: devi - opaque device info handle
7129 * cmd - detach type
7130 *
7131 * Return Code: DDI_SUCCESS
7132 * DDI_FAILURE
7133 *
7134 * Context: Kernel thread context
7135 */
7136
7137 static int
7138 sddetach(dev_info_t *devi, ddi_detach_cmd_t cmd)
7139 {
7140 switch (cmd) {
7141 case DDI_DETACH:
7142 return (sd_unit_detach(devi));
7143 case DDI_SUSPEND:
7144 return (sd_ddi_suspend(devi));
7145 default:
7146 break;
7147 }
7148 return (DDI_FAILURE);
7149 }
7150
7151
7152 /*
7153 * Function: sd_sync_with_callback
7154 *
7155 * Description: Prevents sd_unit_attach or sd_unit_detach from freeing the soft
7156 * state while the callback routine is active.
7157 *
7158 * Arguments: un: softstate structure for the instance
7159 *
7160 * Context: Kernel thread context
7161 */
7162
7163 static void
7164 sd_sync_with_callback(struct sd_lun *un)
7165 {
7166 ASSERT(un != NULL);
7167
7168 mutex_enter(SD_MUTEX(un));
7169
7170 ASSERT(un->un_in_callback >= 0);
7171
7172 while (un->un_in_callback > 0) {
7173 mutex_exit(SD_MUTEX(un));
7174 delay(2);
7175 mutex_enter(SD_MUTEX(un));
7176 }
7177
7178 mutex_exit(SD_MUTEX(un));
7179 }
7180
7181 /*
7182 * Function: sd_unit_attach
7183 *
7184 * Description: Performs DDI_ATTACH processing for sdattach(). Allocates
7185 * the soft state structure for the device and performs
7186 * all necessary structure and device initializations.
7187 *
7188 * Arguments: devi: the system's dev_info_t for the device.
7189 *
7190 * Return Code: DDI_SUCCESS if attach is successful.
7191 * DDI_FAILURE if any part of the attach fails.
7192 *
7193 * Context: Called at attach(9e) time for the DDI_ATTACH flag.
7194 * Kernel thread context only. Can sleep.
7195 */
7196
7197 static int
7198 sd_unit_attach(dev_info_t *devi)
7199 {
7200 struct scsi_device *devp;
7201 struct sd_lun *un;
7202 char *variantp;
7203 char name_str[48];
7204 int reservation_flag = SD_TARGET_IS_UNRESERVED;
7205 int instance;
7206 int rval;
7207 int wc_enabled;
7208 int tgt;
7209 uint64_t capacity;
7210 uint_t lbasize = 0;
7211 dev_info_t *pdip = ddi_get_parent(devi);
7212 int offbyone = 0;
7213 int geom_label_valid = 0;
7214 sd_ssc_t *ssc;
7215 int status;
7216 struct sd_fm_internal *sfip = NULL;
7217 int max_xfer_size;
7218
7219 /*
7220 * Retrieve the target driver's private data area. This was set
7221 * up by the HBA.
7222 */
7223 devp = ddi_get_driver_private(devi);
7224
7225 /*
7226 * Retrieve the target ID of the device.
7227 */
7228 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS,
7229 SCSI_ADDR_PROP_TARGET, -1);
7230
7231 /*
7232 * Since we have no idea what state things were left in by the last
7233 * user of the device, set up some 'default' settings, ie. turn 'em
7234 * off. The scsi_ifsetcap calls force re-negotiations with the drive.
7235 * Do this before the scsi_probe, which sends an inquiry.
7236 * This is a fix for bug (4430280).
7237 * Of special importance is wide-xfer. The drive could have been left
7238 * in wide transfer mode by the last driver to communicate with it,
7239 * this includes us. If that's the case, and if the following is not
7240 * setup properly or we don't re-negotiate with the drive prior to
7241 * transferring data to/from the drive, it causes bus parity errors,
7242 * data overruns, and unexpected interrupts. This first occurred when
7243 * the fix for bug (4378686) was made.
7244 */
7245 (void) scsi_ifsetcap(&devp->sd_address, "lun-reset", 0, 1);
7246 (void) scsi_ifsetcap(&devp->sd_address, "wide-xfer", 0, 1);
7247 (void) scsi_ifsetcap(&devp->sd_address, "auto-rqsense", 0, 1);
7248
7249 /*
7250 * Currently, scsi_ifsetcap sets tagged-qing capability for all LUNs
7251 * on a target. Setting it per lun instance actually sets the
7252 * capability of this target, which affects those luns already
7253 * attached on the same target. So during attach, we can only disable
7254 * this capability only when no other lun has been attached on this
7255 * target. By doing this, we assume a target has the same tagged-qing
7256 * capability for every lun. The condition can be removed when HBA
7257 * is changed to support per lun based tagged-qing capability.
7258 */
7259 if (sd_scsi_get_target_lun_count(pdip, tgt) < 1) {
7260 (void) scsi_ifsetcap(&devp->sd_address, "tagged-qing", 0, 1);
7261 }
7262
7263 /*
7264 * Use scsi_probe() to issue an INQUIRY command to the device.
7265 * This call will allocate and fill in the scsi_inquiry structure
7266 * and point the sd_inq member of the scsi_device structure to it.
7267 * If the attach succeeds, then this memory will not be de-allocated
7268 * (via scsi_unprobe()) until the instance is detached.
7269 */
7270 if (scsi_probe(devp, SLEEP_FUNC) != SCSIPROBE_EXISTS) {
7271 goto probe_failed;
7272 }
7273
7274 /*
7275 * Check the device type as specified in the inquiry data and
7276 * claim it if it is of a type that we support.
7277 */
7278 switch (devp->sd_inq->inq_dtype) {
7279 case DTYPE_DIRECT:
7280 break;
7281 case DTYPE_RODIRECT:
7282 break;
7283 case DTYPE_OPTICAL:
7284 break;
7285 case DTYPE_NOTPRESENT:
7286 default:
7287 /* Unsupported device type; fail the attach. */
7288 goto probe_failed;
7289 }
7290
7291 /*
7292 * Allocate the soft state structure for this unit.
7293 *
7294 * We rely upon this memory being set to all zeroes by
7295 * ddi_soft_state_zalloc(). We assume that any member of the
7296 * soft state structure that is not explicitly initialized by
7297 * this routine will have a value of zero.
7298 */
7299 instance = ddi_get_instance(devp->sd_dev);
7300 #ifndef XPV_HVM_DRIVER
7301 if (ddi_soft_state_zalloc(sd_state, instance) != DDI_SUCCESS) {
7302 goto probe_failed;
7303 }
7304 #endif /* !XPV_HVM_DRIVER */
7305
7306 /*
7307 * Retrieve a pointer to the newly-allocated soft state.
7308 *
7309 * This should NEVER fail if the ddi_soft_state_zalloc() call above
7310 * was successful, unless something has gone horribly wrong and the
7311 * ddi's soft state internals are corrupt (in which case it is
7312 * probably better to halt here than just fail the attach....)
7313 */
7314 if ((un = ddi_get_soft_state(sd_state, instance)) == NULL) {
7315 panic("sd_unit_attach: NULL soft state on instance:0x%x",
7316 instance);
7317 /*NOTREACHED*/
7318 }
7319
7320 /*
7321 * Link the back ptr of the driver soft state to the scsi_device
7322 * struct for this lun.
7323 * Save a pointer to the softstate in the driver-private area of
7324 * the scsi_device struct.
7325 * Note: We cannot call SD_INFO, SD_TRACE, SD_ERROR, or SD_DIAG until
7326 * we first set un->un_sd below.
7327 */
7328 un->un_sd = devp;
7329 devp->sd_private = (opaque_t)un;
7330
7331 /*
7332 * The following must be after devp is stored in the soft state struct.
7333 */
7334 #ifdef SDDEBUG
7335 SD_TRACE(SD_LOG_ATTACH_DETACH, un,
7336 "%s_unit_attach: un:0x%p instance:%d\n",
7337 ddi_driver_name(devi), un, instance);
7338 #endif
7339
7340 /*
7341 * Set up the device type and node type (for the minor nodes).
7342 * By default we assume that the device can at least support the
7343 * Common Command Set. Call it a CD-ROM if it reports itself
7344 * as a RODIRECT device.
7345 */
7346 switch (devp->sd_inq->inq_dtype) {
7347 case DTYPE_RODIRECT:
7348 un->un_node_type = DDI_NT_CD_CHAN;
7349 un->un_ctype = CTYPE_CDROM;
7350 break;
7351 case DTYPE_OPTICAL:
7352 un->un_node_type = DDI_NT_BLOCK_CHAN;
7353 un->un_ctype = CTYPE_ROD;
7354 break;
7355 default:
7356 un->un_node_type = DDI_NT_BLOCK_CHAN;
7357 un->un_ctype = CTYPE_CCS;
7358 break;
7359 }
7360
7361 /*
7362 * Try to read the interconnect type from the HBA.
7363 *
7364 * Note: This driver is currently compiled as two binaries, a parallel
7365 * scsi version (sd) and a fibre channel version (ssd). All functional
7366 * differences are determined at compile time. In the future a single
7367 * binary will be provided and the interconnect type will be used to
7368 * differentiate between fibre and parallel scsi behaviors. At that time
7369 * it will be necessary for all fibre channel HBAs to support this
7370 * property.
7371 *
7372 * set un_f_is_fiber to TRUE ( default fiber )
7373 */
7374 un->un_f_is_fibre = TRUE;
7375 switch (scsi_ifgetcap(SD_ADDRESS(un), "interconnect-type", -1)) {
7376 case INTERCONNECT_SSA:
7377 un->un_interconnect_type = SD_INTERCONNECT_SSA;
7378 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7379 "sd_unit_attach: un:0x%p SD_INTERCONNECT_SSA\n", un);
7380 break;
7381 case INTERCONNECT_PARALLEL:
7382 un->un_f_is_fibre = FALSE;
7383 un->un_interconnect_type = SD_INTERCONNECT_PARALLEL;
7384 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7385 "sd_unit_attach: un:0x%p SD_INTERCONNECT_PARALLEL\n", un);
7386 break;
7387 case INTERCONNECT_SAS:
7388 un->un_f_is_fibre = FALSE;
7389 un->un_interconnect_type = SD_INTERCONNECT_SAS;
7390 un->un_node_type = DDI_NT_BLOCK_SAS;
7391 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7392 "sd_unit_attach: un:0x%p SD_INTERCONNECT_SAS\n", un);
7393 break;
7394 case INTERCONNECT_SATA:
7395 un->un_f_is_fibre = FALSE;
7396 un->un_interconnect_type = SD_INTERCONNECT_SATA;
7397 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7398 "sd_unit_attach: un:0x%p SD_INTERCONNECT_SATA\n", un);
7399 break;
7400 case INTERCONNECT_FIBRE:
7401 un->un_interconnect_type = SD_INTERCONNECT_FIBRE;
7402 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7403 "sd_unit_attach: un:0x%p SD_INTERCONNECT_FIBRE\n", un);
7404 break;
7405 case INTERCONNECT_FABRIC:
7406 un->un_interconnect_type = SD_INTERCONNECT_FABRIC;
7407 un->un_node_type = DDI_NT_BLOCK_FABRIC;
7408 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7409 "sd_unit_attach: un:0x%p SD_INTERCONNECT_FABRIC\n", un);
7410 break;
7411 default:
7412 #ifdef SD_DEFAULT_INTERCONNECT_TYPE
7413 /*
7414 * The HBA does not support the "interconnect-type" property
7415 * (or did not provide a recognized type).
7416 *
7417 * Note: This will be obsoleted when a single fibre channel
7418 * and parallel scsi driver is delivered. In the meantime the
7419 * interconnect type will be set to the platform default.If that
7420 * type is not parallel SCSI, it means that we should be
7421 * assuming "ssd" semantics. However, here this also means that
7422 * the FC HBA is not supporting the "interconnect-type" property
7423 * like we expect it to, so log this occurrence.
7424 */
7425 un->un_interconnect_type = SD_DEFAULT_INTERCONNECT_TYPE;
7426 if (!SD_IS_PARALLEL_SCSI(un)) {
7427 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7428 "sd_unit_attach: un:0x%p Assuming "
7429 "INTERCONNECT_FIBRE\n", un);
7430 } else {
7431 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7432 "sd_unit_attach: un:0x%p Assuming "
7433 "INTERCONNECT_PARALLEL\n", un);
7434 un->un_f_is_fibre = FALSE;
7435 }
7436 #else
7437 /*
7438 * Note: This source will be implemented when a single fibre
7439 * channel and parallel scsi driver is delivered. The default
7440 * will be to assume that if a device does not support the
7441 * "interconnect-type" property it is a parallel SCSI HBA and
7442 * we will set the interconnect type for parallel scsi.
7443 */
7444 un->un_interconnect_type = SD_INTERCONNECT_PARALLEL;
7445 un->un_f_is_fibre = FALSE;
7446 #endif
7447 break;
7448 }
7449
7450 if (un->un_f_is_fibre == TRUE) {
7451 if (scsi_ifgetcap(SD_ADDRESS(un), "scsi-version", 1) ==
7452 SCSI_VERSION_3) {
7453 switch (un->un_interconnect_type) {
7454 case SD_INTERCONNECT_FIBRE:
7455 case SD_INTERCONNECT_SSA:
7456 un->un_node_type = DDI_NT_BLOCK_WWN;
7457 break;
7458 default:
7459 break;
7460 }
7461 }
7462 }
7463
7464 /*
7465 * Initialize the Request Sense command for the target
7466 */
7467 if (sd_alloc_rqs(devp, un) != DDI_SUCCESS) {
7468 goto alloc_rqs_failed;
7469 }
7470
7471 /*
7472 * Set un_retry_count with SD_RETRY_COUNT, this is ok for Sparc
7473 * with separate binary for sd and ssd.
7474 *
7475 * x86 has 1 binary, un_retry_count is set base on connection type.
7476 * The hardcoded values will go away when Sparc uses 1 binary
7477 * for sd and ssd. This hardcoded values need to match
7478 * SD_RETRY_COUNT in sddef.h
7479 * The value used is base on interconnect type.
7480 * fibre = 3, parallel = 5
7481 */
7482 #if defined(__i386) || defined(__amd64)
7483 un->un_retry_count = un->un_f_is_fibre ? 3 : 5;
7484 #else
7485 un->un_retry_count = SD_RETRY_COUNT;
7486 #endif
7487
7488 /*
7489 * Set the per disk retry count to the default number of retries
7490 * for disks and CDROMs. This value can be overridden by the
7491 * disk property list or an entry in sd.conf.
7492 */
7493 un->un_notready_retry_count =
7494 ISCD(un) ? CD_NOT_READY_RETRY_COUNT(un)
7495 : DISK_NOT_READY_RETRY_COUNT(un);
7496
7497 /*
7498 * Set the busy retry count to the default value of un_retry_count.
7499 * This can be overridden by entries in sd.conf or the device
7500 * config table.
7501 */
7502 un->un_busy_retry_count = un->un_retry_count;
7503
7504 /*
7505 * Init the reset threshold for retries. This number determines
7506 * how many retries must be performed before a reset can be issued
7507 * (for certain error conditions). This can be overridden by entries
7508 * in sd.conf or the device config table.
7509 */
7510 un->un_reset_retry_count = (un->un_retry_count / 2);
7511
7512 /*
7513 * Set the victim_retry_count to the default un_retry_count
7514 */
7515 un->un_victim_retry_count = (2 * un->un_retry_count);
7516
7517 /*
7518 * Set the reservation release timeout to the default value of
7519 * 5 seconds. This can be overridden by entries in ssd.conf or the
7520 * device config table.
7521 */
7522 un->un_reserve_release_time = 5;
7523
7524 /*
7525 * Set up the default maximum transfer size. Note that this may
7526 * get updated later in the attach, when setting up default wide
7527 * operations for disks.
7528 */
7529 #if defined(__i386) || defined(__amd64)
7530 un->un_max_xfer_size = (uint_t)SD_DEFAULT_MAX_XFER_SIZE;
7531 un->un_partial_dma_supported = 1;
7532 #else
7533 un->un_max_xfer_size = (uint_t)maxphys;
7534 #endif
7535
7536 /*
7537 * Get "allow bus device reset" property (defaults to "enabled" if
7538 * the property was not defined). This is to disable bus resets for
7539 * certain kinds of error recovery. Note: In the future when a run-time
7540 * fibre check is available the soft state flag should default to
7541 * enabled.
7542 */
7543 if (un->un_f_is_fibre == TRUE) {
7544 un->un_f_allow_bus_device_reset = TRUE;
7545 } else {
7546 if (ddi_getprop(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS,
7547 "allow-bus-device-reset", 1) != 0) {
7548 un->un_f_allow_bus_device_reset = TRUE;
7549 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7550 "sd_unit_attach: un:0x%p Bus device reset "
7551 "enabled\n", un);
7552 } else {
7553 un->un_f_allow_bus_device_reset = FALSE;
7554 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7555 "sd_unit_attach: un:0x%p Bus device reset "
7556 "disabled\n", un);
7557 }
7558 }
7559
7560 /*
7561 * Check if this is an ATAPI device. ATAPI devices use Group 1
7562 * Read/Write commands and Group 2 Mode Sense/Select commands.
7563 *
7564 * Note: The "obsolete" way of doing this is to check for the "atapi"
7565 * property. The new "variant" property with a value of "atapi" has been
7566 * introduced so that future 'variants' of standard SCSI behavior (like
7567 * atapi) could be specified by the underlying HBA drivers by supplying
7568 * a new value for the "variant" property, instead of having to define a
7569 * new property.
7570 */
7571 if (ddi_prop_get_int(DDI_DEV_T_ANY, devi, 0, "atapi", -1) != -1) {
7572 un->un_f_cfg_is_atapi = TRUE;
7573 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7574 "sd_unit_attach: un:0x%p Atapi device\n", un);
7575 }
7576 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, devi, 0, "variant",
7577 &variantp) == DDI_PROP_SUCCESS) {
7578 if (strcmp(variantp, "atapi") == 0) {
7579 un->un_f_cfg_is_atapi = TRUE;
7580 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7581 "sd_unit_attach: un:0x%p Atapi device\n", un);
7582 }
7583 ddi_prop_free(variantp);
7584 }
7585
7586 un->un_cmd_timeout = SD_IO_TIME;
7587
7588 un->un_busy_timeout = SD_BSY_TIMEOUT;
7589
7590 /* Info on current states, statuses, etc. (Updated frequently) */
7591 un->un_state = SD_STATE_NORMAL;
7592 un->un_last_state = SD_STATE_NORMAL;
7593
7594 /* Control & status info for command throttling */
7595 un->un_throttle = sd_max_throttle;
7596 un->un_saved_throttle = sd_max_throttle;
7597 un->un_min_throttle = sd_min_throttle;
7598
7599 if (un->un_f_is_fibre == TRUE) {
7600 un->un_f_use_adaptive_throttle = TRUE;
7601 } else {
7602 un->un_f_use_adaptive_throttle = FALSE;
7603 }
7604
7605 /* Removable media support. */
7606 cv_init(&un->un_state_cv, NULL, CV_DRIVER, NULL);
7607 un->un_mediastate = DKIO_NONE;
7608 un->un_specified_mediastate = DKIO_NONE;
7609
7610 /* CVs for suspend/resume (PM or DR) */
7611 cv_init(&un->un_suspend_cv, NULL, CV_DRIVER, NULL);
7612 cv_init(&un->un_disk_busy_cv, NULL, CV_DRIVER, NULL);
7613
7614 /* Power management support. */
7615 un->un_power_level = SD_SPINDLE_UNINIT;
7616
7617 cv_init(&un->un_wcc_cv, NULL, CV_DRIVER, NULL);
7618 un->un_f_wcc_inprog = 0;
7619
7620 /*
7621 * The open/close semaphore is used to serialize threads executing
7622 * in the driver's open & close entry point routines for a given
7623 * instance.
7624 */
7625 (void) sema_init(&un->un_semoclose, 1, NULL, SEMA_DRIVER, NULL);
7626
7627 /*
7628 * The conf file entry and softstate variable is a forceful override,
7629 * meaning a non-zero value must be entered to change the default.
7630 */
7631 un->un_f_disksort_disabled = FALSE;
7632 un->un_f_rmw_type = SD_RMW_TYPE_DEFAULT;
7633 un->un_f_enable_rmw = FALSE;
7634
7635 /*
7636 * GET EVENT STATUS NOTIFICATION media polling enabled by default, but
7637 * can be overridden via [s]sd-config-list "mmc-gesn-polling" property.
7638 */
7639 un->un_f_mmc_gesn_polling = TRUE;
7640
7641 /*
7642 * physical sector size defaults to DEV_BSIZE currently. We can
7643 * override this value via the driver configuration file so we must
7644 * set it before calling sd_read_unit_properties().
7645 */
7646 un->un_phy_blocksize = DEV_BSIZE;
7647
7648 /*
7649 * Retrieve the properties from the static driver table or the driver
7650 * configuration file (.conf) for this unit and update the soft state
7651 * for the device as needed for the indicated properties.
7652 * Note: the property configuration needs to occur here as some of the
7653 * following routines may have dependencies on soft state flags set
7654 * as part of the driver property configuration.
7655 */
7656 sd_read_unit_properties(un);
7657 SD_TRACE(SD_LOG_ATTACH_DETACH, un,
7658 "sd_unit_attach: un:0x%p property configuration complete.\n", un);
7659
7660 /*
7661 * Only if a device has "hotpluggable" property, it is
7662 * treated as hotpluggable device. Otherwise, it is
7663 * regarded as non-hotpluggable one.
7664 */
7665 if (ddi_prop_get_int(DDI_DEV_T_ANY, devi, 0, "hotpluggable",
7666 -1) != -1) {
7667 un->un_f_is_hotpluggable = TRUE;
7668 }
7669
7670 /*
7671 * set unit's attributes(flags) according to "hotpluggable" and
7672 * RMB bit in INQUIRY data.
7673 */
7674 sd_set_unit_attributes(un, devi);
7675
7676 /*
7677 * By default, we mark the capacity, lbasize, and geometry
7678 * as invalid. Only if we successfully read a valid capacity
7679 * will we update the un_blockcount and un_tgt_blocksize with the
7680 * valid values (the geometry will be validated later).
7681 */
7682 un->un_f_blockcount_is_valid = FALSE;
7683 un->un_f_tgt_blocksize_is_valid = FALSE;
7684
7685 /*
7686 * Use DEV_BSIZE and DEV_BSHIFT as defaults, until we can determine
7687 * otherwise.
7688 */
7689 un->un_tgt_blocksize = un->un_sys_blocksize = DEV_BSIZE;
7690 un->un_blockcount = 0;
7691
7692 /*
7693 * Set up the per-instance info needed to determine the correct
7694 * CDBs and other info for issuing commands to the target.
7695 */
7696 sd_init_cdb_limits(un);
7697
7698 /*
7699 * Set up the IO chains to use, based upon the target type.
7700 */
7701 if (un->un_f_non_devbsize_supported) {
7702 un->un_buf_chain_type = SD_CHAIN_INFO_RMMEDIA;
7703 } else {
7704 un->un_buf_chain_type = SD_CHAIN_INFO_DISK;
7705 }
7706 un->un_uscsi_chain_type = SD_CHAIN_INFO_USCSI_CMD;
7707 un->un_direct_chain_type = SD_CHAIN_INFO_DIRECT_CMD;
7708 un->un_priority_chain_type = SD_CHAIN_INFO_PRIORITY_CMD;
7709
7710 un->un_xbuf_attr = ddi_xbuf_attr_create(sizeof (struct sd_xbuf),
7711 sd_xbuf_strategy, un, sd_xbuf_active_limit, sd_xbuf_reserve_limit,
7712 ddi_driver_major(devi), DDI_XBUF_QTHREAD_DRIVER);
7713 ddi_xbuf_attr_register_devinfo(un->un_xbuf_attr, devi);
7714
7715
7716 if (ISCD(un)) {
7717 un->un_additional_codes = sd_additional_codes;
7718 } else {
7719 un->un_additional_codes = NULL;
7720 }
7721
7722 /*
7723 * Create the kstats here so they can be available for attach-time
7724 * routines that send commands to the unit (either polled or via
7725 * sd_send_scsi_cmd).
7726 *
7727 * Note: This is a critical sequence that needs to be maintained:
7728 * 1) Instantiate the kstats here, before any routines using the
7729 * iopath (i.e. sd_send_scsi_cmd).
7730 * 2) Instantiate and initialize the partition stats
7731 * (sd_set_pstats).
7732 * 3) Initialize the error stats (sd_set_errstats), following
7733 * sd_validate_geometry(),sd_register_devid(),
7734 * and sd_cache_control().
7735 */
7736
7737 un->un_stats = kstat_create(sd_label, instance,
7738 NULL, "disk", KSTAT_TYPE_IO, 1, KSTAT_FLAG_PERSISTENT);
7739 if (un->un_stats != NULL) {
7740 un->un_stats->ks_lock = SD_MUTEX(un);
7741 kstat_install(un->un_stats);
7742 }
7743 SD_TRACE(SD_LOG_ATTACH_DETACH, un,
7744 "sd_unit_attach: un:0x%p un_stats created\n", un);
7745
7746 sd_create_errstats(un, instance);
7747 if (un->un_errstats == NULL) {
7748 goto create_errstats_failed;
7749 }
7750 SD_TRACE(SD_LOG_ATTACH_DETACH, un,
7751 "sd_unit_attach: un:0x%p errstats created\n", un);
7752
7753 /*
7754 * The following if/else code was relocated here from below as part
7755 * of the fix for bug (4430280). However with the default setup added
7756 * on entry to this routine, it's no longer absolutely necessary for
7757 * this to be before the call to sd_spin_up_unit.
7758 */
7759 if (SD_IS_PARALLEL_SCSI(un) || SD_IS_SERIAL(un)) {
7760 int tq_trigger_flag = (((devp->sd_inq->inq_ansi == 4) ||
7761 (devp->sd_inq->inq_ansi == 5)) &&
7762 devp->sd_inq->inq_bque) || devp->sd_inq->inq_cmdque;
7763
7764 /*
7765 * If tagged queueing is supported by the target
7766 * and by the host adapter then we will enable it
7767 */
7768 un->un_tagflags = 0;
7769 if ((devp->sd_inq->inq_rdf == RDF_SCSI2) && tq_trigger_flag &&
7770 (un->un_f_arq_enabled == TRUE)) {
7771 if (scsi_ifsetcap(SD_ADDRESS(un), "tagged-qing",
7772 1, 1) == 1) {
7773 un->un_tagflags = FLAG_STAG;
7774 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7775 "sd_unit_attach: un:0x%p tag queueing "
7776 "enabled\n", un);
7777 } else if (scsi_ifgetcap(SD_ADDRESS(un),
7778 "untagged-qing", 0) == 1) {
7779 un->un_f_opt_queueing = TRUE;
7780 un->un_saved_throttle = un->un_throttle =
7781 min(un->un_throttle, 3);
7782 } else {
7783 un->un_f_opt_queueing = FALSE;
7784 un->un_saved_throttle = un->un_throttle = 1;
7785 }
7786 } else if ((scsi_ifgetcap(SD_ADDRESS(un), "untagged-qing", 0)
7787 == 1) && (un->un_f_arq_enabled == TRUE)) {
7788 /* The Host Adapter supports internal queueing. */
7789 un->un_f_opt_queueing = TRUE;
7790 un->un_saved_throttle = un->un_throttle =
7791 min(un->un_throttle, 3);
7792 } else {
7793 un->un_f_opt_queueing = FALSE;
7794 un->un_saved_throttle = un->un_throttle = 1;
7795 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7796 "sd_unit_attach: un:0x%p no tag queueing\n", un);
7797 }
7798
7799 /*
7800 * Enable large transfers for SATA/SAS drives
7801 */
7802 if (SD_IS_SERIAL(un)) {
7803 un->un_max_xfer_size =
7804 ddi_getprop(DDI_DEV_T_ANY, devi, 0,
7805 sd_max_xfer_size, SD_MAX_XFER_SIZE);
7806 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7807 "sd_unit_attach: un:0x%p max transfer "
7808 "size=0x%x\n", un, un->un_max_xfer_size);
7809
7810 }
7811
7812 /* Setup or tear down default wide operations for disks */
7813
7814 /*
7815 * Note: Legacy: it may be possible for both "sd_max_xfer_size"
7816 * and "ssd_max_xfer_size" to exist simultaneously on the same
7817 * system and be set to different values. In the future this
7818 * code may need to be updated when the ssd module is
7819 * obsoleted and removed from the system. (4299588)
7820 */
7821 if (SD_IS_PARALLEL_SCSI(un) &&
7822 (devp->sd_inq->inq_rdf == RDF_SCSI2) &&
7823 (devp->sd_inq->inq_wbus16 || devp->sd_inq->inq_wbus32)) {
7824 if (scsi_ifsetcap(SD_ADDRESS(un), "wide-xfer",
7825 1, 1) == 1) {
7826 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7827 "sd_unit_attach: un:0x%p Wide Transfer "
7828 "enabled\n", un);
7829 }
7830
7831 /*
7832 * If tagged queuing has also been enabled, then
7833 * enable large xfers
7834 */
7835 if (un->un_saved_throttle == sd_max_throttle) {
7836 un->un_max_xfer_size =
7837 ddi_getprop(DDI_DEV_T_ANY, devi, 0,
7838 sd_max_xfer_size, SD_MAX_XFER_SIZE);
7839 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7840 "sd_unit_attach: un:0x%p max transfer "
7841 "size=0x%x\n", un, un->un_max_xfer_size);
7842 }
7843 } else {
7844 if (scsi_ifsetcap(SD_ADDRESS(un), "wide-xfer",
7845 0, 1) == 1) {
7846 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7847 "sd_unit_attach: un:0x%p "
7848 "Wide Transfer disabled\n", un);
7849 }
7850 }
7851 } else {
7852 un->un_tagflags = FLAG_STAG;
7853 un->un_max_xfer_size = ddi_getprop(DDI_DEV_T_ANY,
7854 devi, 0, sd_max_xfer_size, SD_MAX_XFER_SIZE);
7855 }
7856
7857 /*
7858 * If this target supports LUN reset, try to enable it.
7859 */
7860 if (un->un_f_lun_reset_enabled) {
7861 if (scsi_ifsetcap(SD_ADDRESS(un), "lun-reset", 1, 1) == 1) {
7862 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_unit_attach: "
7863 "un:0x%p lun_reset capability set\n", un);
7864 } else {
7865 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_unit_attach: "
7866 "un:0x%p lun-reset capability not set\n", un);
7867 }
7868 }
7869
7870 /*
7871 * Adjust the maximum transfer size. This is to fix
7872 * the problem of partial DMA support on SPARC. Some
7873 * HBA driver, like aac, has very small dma_attr_maxxfer
7874 * size, which requires partial DMA support on SPARC.
7875 * In the future the SPARC pci nexus driver may solve
7876 * the problem instead of this fix.
7877 */
7878 max_xfer_size = scsi_ifgetcap(SD_ADDRESS(un), "dma-max", 1);
7879 if ((max_xfer_size > 0) && (max_xfer_size < un->un_max_xfer_size)) {
7880 /* We need DMA partial even on sparc to ensure sddump() works */
7881 un->un_max_xfer_size = max_xfer_size;
7882 if (un->un_partial_dma_supported == 0)
7883 un->un_partial_dma_supported = 1;
7884 }
7885 if (ddi_prop_get_int(DDI_DEV_T_ANY, SD_DEVINFO(un),
7886 DDI_PROP_DONTPASS, "buf_break", 0) == 1) {
7887 if (ddi_xbuf_attr_setup_brk(un->un_xbuf_attr,
7888 un->un_max_xfer_size) == 1) {
7889 un->un_buf_breakup_supported = 1;
7890 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_unit_attach: "
7891 "un:0x%p Buf breakup enabled\n", un);
7892 }
7893 }
7894
7895 /*
7896 * Set PKT_DMA_PARTIAL flag.
7897 */
7898 if (un->un_partial_dma_supported == 1) {
7899 un->un_pkt_flags = PKT_DMA_PARTIAL;
7900 } else {
7901 un->un_pkt_flags = 0;
7902 }
7903
7904 /* Initialize sd_ssc_t for internal uscsi commands */
7905 ssc = sd_ssc_init(un);
7906 scsi_fm_init(devp);
7907
7908 /*
7909 * Allocate memory for SCSI FMA stuffs.
7910 */
7911 un->un_fm_private =
7912 kmem_zalloc(sizeof (struct sd_fm_internal), KM_SLEEP);
7913 sfip = (struct sd_fm_internal *)un->un_fm_private;
7914 sfip->fm_ssc.ssc_uscsi_cmd = &sfip->fm_ucmd;
7915 sfip->fm_ssc.ssc_uscsi_info = &sfip->fm_uinfo;
7916 sfip->fm_ssc.ssc_un = un;
7917
7918 if (ISCD(un) ||
7919 un->un_f_has_removable_media ||
7920 devp->sd_fm_capable == DDI_FM_NOT_CAPABLE) {
7921 /*
7922 * We don't touch CDROM or the DDI_FM_NOT_CAPABLE device.
7923 * Their log are unchanged.
7924 */
7925 sfip->fm_log_level = SD_FM_LOG_NSUP;
7926 } else {
7927 /*
7928 * If enter here, it should be non-CDROM and FM-capable
7929 * device, and it will not keep the old scsi_log as before
7930 * in /var/adm/messages. However, the property
7931 * "fm-scsi-log" will control whether the FM telemetry will
7932 * be logged in /var/adm/messages.
7933 */
7934 int fm_scsi_log;
7935 fm_scsi_log = ddi_prop_get_int(DDI_DEV_T_ANY, SD_DEVINFO(un),
7936 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "fm-scsi-log", 0);
7937
7938 if (fm_scsi_log)
7939 sfip->fm_log_level = SD_FM_LOG_EREPORT;
7940 else
7941 sfip->fm_log_level = SD_FM_LOG_SILENT;
7942 }
7943
7944 /*
7945 * At this point in the attach, we have enough info in the
7946 * soft state to be able to issue commands to the target.
7947 *
7948 * All command paths used below MUST issue their commands as
7949 * SD_PATH_DIRECT. This is important as intermediate layers
7950 * are not all initialized yet (such as PM).
7951 */
7952
7953 /*
7954 * Send a TEST UNIT READY command to the device. This should clear
7955 * any outstanding UNIT ATTENTION that may be present.
7956 *
7957 * Note: Don't check for success, just track if there is a reservation,
7958 * this is a throw away command to clear any unit attentions.
7959 *
7960 * Note: This MUST be the first command issued to the target during
7961 * attach to ensure power on UNIT ATTENTIONS are cleared.
7962 * Pass in flag SD_DONT_RETRY_TUR to prevent the long delays associated
7963 * with attempts at spinning up a device with no media.
7964 */
7965 status = sd_send_scsi_TEST_UNIT_READY(ssc, SD_DONT_RETRY_TUR);
7966 if (status != 0) {
7967 if (status == EACCES)
7968 reservation_flag = SD_TARGET_IS_RESERVED;
7969 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
7970 }
7971
7972 /*
7973 * If the device is NOT a removable media device, attempt to spin
7974 * it up (using the START_STOP_UNIT command) and read its capacity
7975 * (using the READ CAPACITY command). Note, however, that either
7976 * of these could fail and in some cases we would continue with
7977 * the attach despite the failure (see below).
7978 */
7979 if (un->un_f_descr_format_supported) {
7980
7981 switch (sd_spin_up_unit(ssc)) {
7982 case 0:
7983 /*
7984 * Spin-up was successful; now try to read the
7985 * capacity. If successful then save the results
7986 * and mark the capacity & lbasize as valid.
7987 */
7988 SD_TRACE(SD_LOG_ATTACH_DETACH, un,
7989 "sd_unit_attach: un:0x%p spin-up successful\n", un);
7990
7991 status = sd_send_scsi_READ_CAPACITY(ssc, &capacity,
7992 &lbasize, SD_PATH_DIRECT);
7993
7994 switch (status) {
7995 case 0: {
7996 if (capacity > DK_MAX_BLOCKS) {
7997 #ifdef _LP64
7998 if ((capacity + 1) >
7999 SD_GROUP1_MAX_ADDRESS) {
8000 /*
8001 * Enable descriptor format
8002 * sense data so that we can
8003 * get 64 bit sense data
8004 * fields.
8005 */
8006 sd_enable_descr_sense(ssc);
8007 }
8008 #else
8009 /* 32-bit kernels can't handle this */
8010 scsi_log(SD_DEVINFO(un),
8011 sd_label, CE_WARN,
8012 "disk has %llu blocks, which "
8013 "is too large for a 32-bit "
8014 "kernel", capacity);
8015
8016 #if defined(__i386) || defined(__amd64)
8017 /*
8018 * 1TB disk was treated as (1T - 512)B
8019 * in the past, so that it might have
8020 * valid VTOC and solaris partitions,
8021 * we have to allow it to continue to
8022 * work.
8023 */
8024 if (capacity -1 > DK_MAX_BLOCKS)
8025 #endif
8026 goto spinup_failed;
8027 #endif
8028 }
8029
8030 /*
8031 * Here it's not necessary to check the case:
8032 * the capacity of the device is bigger than
8033 * what the max hba cdb can support. Because
8034 * sd_send_scsi_READ_CAPACITY will retrieve
8035 * the capacity by sending USCSI command, which
8036 * is constrained by the max hba cdb. Actually,
8037 * sd_send_scsi_READ_CAPACITY will return
8038 * EINVAL when using bigger cdb than required
8039 * cdb length. Will handle this case in
8040 * "case EINVAL".
8041 */
8042
8043 /*
8044 * The following relies on
8045 * sd_send_scsi_READ_CAPACITY never
8046 * returning 0 for capacity and/or lbasize.
8047 */
8048 sd_update_block_info(un, lbasize, capacity);
8049
8050 SD_INFO(SD_LOG_ATTACH_DETACH, un,
8051 "sd_unit_attach: un:0x%p capacity = %ld "
8052 "blocks; lbasize= %ld.\n", un,
8053 un->un_blockcount, un->un_tgt_blocksize);
8054
8055 break;
8056 }
8057 case EINVAL:
8058 /*
8059 * In the case where the max-cdb-length property
8060 * is smaller than the required CDB length for
8061 * a SCSI device, a target driver can fail to
8062 * attach to that device.
8063 */
8064 scsi_log(SD_DEVINFO(un),
8065 sd_label, CE_WARN,
8066 "disk capacity is too large "
8067 "for current cdb length");
8068 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
8069
8070 goto spinup_failed;
8071 case EACCES:
8072 /*
8073 * Should never get here if the spin-up
8074 * succeeded, but code it in anyway.
8075 * From here, just continue with the attach...
8076 */
8077 SD_INFO(SD_LOG_ATTACH_DETACH, un,
8078 "sd_unit_attach: un:0x%p "
8079 "sd_send_scsi_READ_CAPACITY "
8080 "returned reservation conflict\n", un);
8081 reservation_flag = SD_TARGET_IS_RESERVED;
8082 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
8083 break;
8084 default:
8085 /*
8086 * Likewise, should never get here if the
8087 * spin-up succeeded. Just continue with
8088 * the attach...
8089 */
8090 if (status == EIO)
8091 sd_ssc_assessment(ssc,
8092 SD_FMT_STATUS_CHECK);
8093 else
8094 sd_ssc_assessment(ssc,
8095 SD_FMT_IGNORE);
8096 break;
8097 }
8098 break;
8099 case EACCES:
8100 /*
8101 * Device is reserved by another host. In this case
8102 * we could not spin it up or read the capacity, but
8103 * we continue with the attach anyway.
8104 */
8105 SD_INFO(SD_LOG_ATTACH_DETACH, un,
8106 "sd_unit_attach: un:0x%p spin-up reservation "
8107 "conflict.\n", un);
8108 reservation_flag = SD_TARGET_IS_RESERVED;
8109 break;
8110 default:
8111 /* Fail the attach if the spin-up failed. */
8112 SD_INFO(SD_LOG_ATTACH_DETACH, un,
8113 "sd_unit_attach: un:0x%p spin-up failed.", un);
8114 goto spinup_failed;
8115 }
8116
8117 }
8118
8119 /*
8120 * Check to see if this is a MMC drive
8121 */
8122 if (ISCD(un)) {
8123 sd_set_mmc_caps(ssc);
8124 }
8125
8126 /*
8127 * Add a zero-length attribute to tell the world we support
8128 * kernel ioctls (for layered drivers)
8129 */
8130 (void) ddi_prop_create(DDI_DEV_T_NONE, devi, DDI_PROP_CANSLEEP,
8131 DDI_KERNEL_IOCTL, NULL, 0);
8132
8133 /*
8134 * Add a boolean property to tell the world we support
8135 * the B_FAILFAST flag (for layered drivers)
8136 */
8137 (void) ddi_prop_create(DDI_DEV_T_NONE, devi, DDI_PROP_CANSLEEP,
8138 "ddi-failfast-supported", NULL, 0);
8139
8140 /*
8141 * Initialize power management
8142 */
8143 mutex_init(&un->un_pm_mutex, NULL, MUTEX_DRIVER, NULL);
8144 cv_init(&un->un_pm_busy_cv, NULL, CV_DRIVER, NULL);
8145 sd_setup_pm(ssc, devi);
8146 if (un->un_f_pm_is_enabled == FALSE) {
8147 /*
8148 * For performance, point to a jump table that does
8149 * not include pm.
8150 * The direct and priority chains don't change with PM.
8151 *
8152 * Note: this is currently done based on individual device
8153 * capabilities. When an interface for determining system
8154 * power enabled state becomes available, or when additional
8155 * layers are added to the command chain, these values will
8156 * have to be re-evaluated for correctness.
8157 */
8158 if (un->un_f_non_devbsize_supported) {
8159 un->un_buf_chain_type = SD_CHAIN_INFO_RMMEDIA_NO_PM;
8160 } else {
8161 un->un_buf_chain_type = SD_CHAIN_INFO_DISK_NO_PM;
8162 }
8163 un->un_uscsi_chain_type = SD_CHAIN_INFO_USCSI_CMD_NO_PM;
8164 }
8165
8166 /*
8167 * This property is set to 0 by HA software to avoid retries
8168 * on a reserved disk. (The preferred property name is
8169 * "retry-on-reservation-conflict") (1189689)
8170 *
8171 * Note: The use of a global here can have unintended consequences. A
8172 * per instance variable is preferable to match the capabilities of
8173 * different underlying hba's (4402600)
8174 */
8175 sd_retry_on_reservation_conflict = ddi_getprop(DDI_DEV_T_ANY, devi,
8176 DDI_PROP_DONTPASS, "retry-on-reservation-conflict",
8177 sd_retry_on_reservation_conflict);
8178 if (sd_retry_on_reservation_conflict != 0) {
8179 sd_retry_on_reservation_conflict = ddi_getprop(DDI_DEV_T_ANY,
8180 devi, DDI_PROP_DONTPASS, sd_resv_conflict_name,
8181 sd_retry_on_reservation_conflict);
8182 }
8183
8184 /* Set up options for QFULL handling. */
8185 if ((rval = ddi_getprop(DDI_DEV_T_ANY, devi, 0,
8186 "qfull-retries", -1)) != -1) {
8187 (void) scsi_ifsetcap(SD_ADDRESS(un), "qfull-retries",
8188 rval, 1);
8189 }
8190 if ((rval = ddi_getprop(DDI_DEV_T_ANY, devi, 0,
8191 "qfull-retry-interval", -1)) != -1) {
8192 (void) scsi_ifsetcap(SD_ADDRESS(un), "qfull-retry-interval",
8193 rval, 1);
8194 }
8195
8196 /*
8197 * This just prints a message that announces the existence of the
8198 * device. The message is always printed in the system logfile, but
8199 * only appears on the console if the system is booted with the
8200 * -v (verbose) argument.
8201 */
8202 ddi_report_dev(devi);
8203
8204 un->un_mediastate = DKIO_NONE;
8205
8206 /*
8207 * Check if this is a SSD(Solid State Drive).
8208 */
8209 sd_check_solid_state(ssc);
8210
8211 /*
8212 * Check whether the drive is in emulation mode.
8213 */
8214 sd_check_emulation_mode(ssc);
8215
8216 cmlb_alloc_handle(&un->un_cmlbhandle);
8217
8218 #if defined(__i386) || defined(__amd64)
8219 /*
8220 * On x86, compensate for off-by-1 legacy error
8221 */
8222 if (!un->un_f_has_removable_media && !un->un_f_is_hotpluggable &&
8223 (lbasize == un->un_sys_blocksize))
8224 offbyone = CMLB_OFF_BY_ONE;
8225 #endif
8226
8227 if (cmlb_attach(devi, &sd_tgops, (int)devp->sd_inq->inq_dtype,
8228 VOID2BOOLEAN(un->un_f_has_removable_media != 0),
8229 VOID2BOOLEAN(un->un_f_is_hotpluggable != 0),
8230 un->un_node_type, offbyone, un->un_cmlbhandle,
8231 (void *)SD_PATH_DIRECT) != 0) {
8232 goto cmlb_attach_failed;
8233 }
8234
8235
8236 /*
8237 * Read and validate the device's geometry (ie, disk label)
8238 * A new unformatted drive will not have a valid geometry, but
8239 * the driver needs to successfully attach to this device so
8240 * the drive can be formatted via ioctls.
8241 */
8242 geom_label_valid = (cmlb_validate(un->un_cmlbhandle, 0,
8243 (void *)SD_PATH_DIRECT) == 0) ? 1: 0;
8244
8245 mutex_enter(SD_MUTEX(un));
8246
8247 /*
8248 * Read and initialize the devid for the unit.
8249 */
8250 if (un->un_f_devid_supported) {
8251 sd_register_devid(ssc, devi, reservation_flag);
8252 }
8253 mutex_exit(SD_MUTEX(un));
8254
8255 #if (defined(__fibre))
8256 /*
8257 * Register callbacks for fibre only. You can't do this solely
8258 * on the basis of the devid_type because this is hba specific.
8259 * We need to query our hba capabilities to find out whether to
8260 * register or not.
8261 */
8262 if (un->un_f_is_fibre) {
8263 if (strcmp(un->un_node_type, DDI_NT_BLOCK_CHAN)) {
8264 sd_init_event_callbacks(un);
8265 SD_TRACE(SD_LOG_ATTACH_DETACH, un,
8266 "sd_unit_attach: un:0x%p event callbacks inserted",
8267 un);
8268 }
8269 }
8270 #endif
8271
8272 if (un->un_f_opt_disable_cache == TRUE) {
8273 /*
8274 * Disable both read cache and write cache. This is
8275 * the historic behavior of the keywords in the config file.
8276 */
8277 if (sd_cache_control(ssc, SD_CACHE_DISABLE, SD_CACHE_DISABLE) !=
8278 0) {
8279 SD_ERROR(SD_LOG_ATTACH_DETACH, un,
8280 "sd_unit_attach: un:0x%p Could not disable "
8281 "caching", un);
8282 goto devid_failed;
8283 }
8284 }
8285
8286 /*
8287 * Check the value of the WCE bit now and
8288 * set un_f_write_cache_enabled accordingly.
8289 */
8290 (void) sd_get_write_cache_enabled(ssc, &wc_enabled);
8291 mutex_enter(SD_MUTEX(un));
8292 un->un_f_write_cache_enabled = (wc_enabled != 0);
8293 mutex_exit(SD_MUTEX(un));
8294
8295 if ((un->un_f_rmw_type != SD_RMW_TYPE_RETURN_ERROR &&
8296 un->un_tgt_blocksize != DEV_BSIZE) ||
8297 un->un_f_enable_rmw) {
8298 if (!(un->un_wm_cache)) {
8299 (void) snprintf(name_str, sizeof (name_str),
8300 "%s%d_cache",
8301 ddi_driver_name(SD_DEVINFO(un)),
8302 ddi_get_instance(SD_DEVINFO(un)));
8303 un->un_wm_cache = kmem_cache_create(
8304 name_str, sizeof (struct sd_w_map),
8305 8, sd_wm_cache_constructor,
8306 sd_wm_cache_destructor, NULL,
8307 (void *)un, NULL, 0);
8308 if (!(un->un_wm_cache)) {
8309 goto wm_cache_failed;
8310 }
8311 }
8312 }
8313
8314 /*
8315 * Check the value of the NV_SUP bit and set
8316 * un_f_suppress_cache_flush accordingly.
8317 */
8318 sd_get_nv_sup(ssc);
8319
8320 /*
8321 * Find out what type of reservation this disk supports.
8322 */
8323 status = sd_send_scsi_PERSISTENT_RESERVE_IN(ssc, SD_READ_KEYS, 0, NULL);
8324
8325 switch (status) {
8326 case 0:
8327 /*
8328 * SCSI-3 reservations are supported.
8329 */
8330 un->un_reservation_type = SD_SCSI3_RESERVATION;
8331 SD_INFO(SD_LOG_ATTACH_DETACH, un,
8332 "sd_unit_attach: un:0x%p SCSI-3 reservations\n", un);
8333 break;
8334 case ENOTSUP:
8335 /*
8336 * The PERSISTENT RESERVE IN command would not be recognized by
8337 * a SCSI-2 device, so assume the reservation type is SCSI-2.
8338 */
8339 SD_INFO(SD_LOG_ATTACH_DETACH, un,
8340 "sd_unit_attach: un:0x%p SCSI-2 reservations\n", un);
8341 un->un_reservation_type = SD_SCSI2_RESERVATION;
8342
8343 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
8344 break;
8345 default:
8346 /*
8347 * default to SCSI-3 reservations
8348 */
8349 SD_INFO(SD_LOG_ATTACH_DETACH, un,
8350 "sd_unit_attach: un:0x%p default SCSI3 reservations\n", un);
8351 un->un_reservation_type = SD_SCSI3_RESERVATION;
8352
8353 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
8354 break;
8355 }
8356
8357 /*
8358 * Set the pstat and error stat values here, so data obtained during the
8359 * previous attach-time routines is available.
8360 *
8361 * Note: This is a critical sequence that needs to be maintained:
8362 * 1) Instantiate the kstats before any routines using the iopath
8363 * (i.e. sd_send_scsi_cmd).
8364 * 2) Initialize the error stats (sd_set_errstats) and partition
8365 * stats (sd_set_pstats)here, following
8366 * cmlb_validate_geometry(), sd_register_devid(), and
8367 * sd_cache_control().
8368 */
8369
8370 if (un->un_f_pkstats_enabled && geom_label_valid) {
8371 sd_set_pstats(un);
8372 SD_TRACE(SD_LOG_IO_PARTITION, un,
8373 "sd_unit_attach: un:0x%p pstats created and set\n", un);
8374 }
8375
8376 sd_set_errstats(un);
8377 SD_TRACE(SD_LOG_ATTACH_DETACH, un,
8378 "sd_unit_attach: un:0x%p errstats set\n", un);
8379
8380
8381 /*
8382 * After successfully attaching an instance, we record the information
8383 * of how many luns have been attached on the relative target and
8384 * controller for parallel SCSI. This information is used when sd tries
8385 * to set the tagged queuing capability in HBA.
8386 */
8387 if (SD_IS_PARALLEL_SCSI(un) && (tgt >= 0) && (tgt < NTARGETS_WIDE)) {
8388 sd_scsi_update_lun_on_target(pdip, tgt, SD_SCSI_LUN_ATTACH);
8389 }
8390
8391 SD_TRACE(SD_LOG_ATTACH_DETACH, un,
8392 "sd_unit_attach: un:0x%p exit success\n", un);
8393
8394 /* Uninitialize sd_ssc_t pointer */
8395 sd_ssc_fini(ssc);
8396
8397 return (DDI_SUCCESS);
8398
8399 /*
8400 * An error occurred during the attach; clean up & return failure.
8401 */
8402 wm_cache_failed:
8403 devid_failed:
8404
8405 setup_pm_failed:
8406 ddi_remove_minor_node(devi, NULL);
8407
8408 cmlb_attach_failed:
8409 /*
8410 * Cleanup from the scsi_ifsetcap() calls (437868)
8411 */
8412 (void) scsi_ifsetcap(SD_ADDRESS(un), "lun-reset", 0, 1);
8413 (void) scsi_ifsetcap(SD_ADDRESS(un), "wide-xfer", 0, 1);
8414
8415 /*
8416 * Refer to the comments of setting tagged-qing in the beginning of
8417 * sd_unit_attach. We can only disable tagged queuing when there is
8418 * no lun attached on the target.
8419 */
8420 if (sd_scsi_get_target_lun_count(pdip, tgt) < 1) {
8421 (void) scsi_ifsetcap(SD_ADDRESS(un), "tagged-qing", 0, 1);
8422 }
8423
8424 if (un->un_f_is_fibre == FALSE) {
8425 (void) scsi_ifsetcap(SD_ADDRESS(un), "auto-rqsense", 0, 1);
8426 }
8427
8428 spinup_failed:
8429
8430 /* Uninitialize sd_ssc_t pointer */
8431 sd_ssc_fini(ssc);
8432
8433 mutex_enter(SD_MUTEX(un));
8434
8435 /* Deallocate SCSI FMA memory spaces */
8436 kmem_free(un->un_fm_private, sizeof (struct sd_fm_internal));
8437
8438 /* Cancel callback for SD_PATH_DIRECT_PRIORITY cmd. restart */
8439 if (un->un_direct_priority_timeid != NULL) {
8440 timeout_id_t temp_id = un->un_direct_priority_timeid;
8441 un->un_direct_priority_timeid = NULL;
8442 mutex_exit(SD_MUTEX(un));
8443 (void) untimeout(temp_id);
8444 mutex_enter(SD_MUTEX(un));
8445 }
8446
8447 /* Cancel any pending start/stop timeouts */
8448 if (un->un_startstop_timeid != NULL) {
8449 timeout_id_t temp_id = un->un_startstop_timeid;
8450 un->un_startstop_timeid = NULL;
8451 mutex_exit(SD_MUTEX(un));
8452 (void) untimeout(temp_id);
8453 mutex_enter(SD_MUTEX(un));
8454 }
8455
8456 /* Cancel any pending reset-throttle timeouts */
8457 if (un->un_reset_throttle_timeid != NULL) {
8458 timeout_id_t temp_id = un->un_reset_throttle_timeid;
8459 un->un_reset_throttle_timeid = NULL;
8460 mutex_exit(SD_MUTEX(un));
8461 (void) untimeout(temp_id);
8462 mutex_enter(SD_MUTEX(un));
8463 }
8464
8465 /* Cancel rmw warning message timeouts */
8466 if (un->un_rmw_msg_timeid != NULL) {
8467 timeout_id_t temp_id = un->un_rmw_msg_timeid;
8468 un->un_rmw_msg_timeid = NULL;
8469 mutex_exit(SD_MUTEX(un));
8470 (void) untimeout(temp_id);
8471 mutex_enter(SD_MUTEX(un));
8472 }
8473
8474 /* Cancel any pending retry timeouts */
8475 if (un->un_retry_timeid != NULL) {
8476 timeout_id_t temp_id = un->un_retry_timeid;
8477 un->un_retry_timeid = NULL;
8478 mutex_exit(SD_MUTEX(un));
8479 (void) untimeout(temp_id);
8480 mutex_enter(SD_MUTEX(un));
8481 }
8482
8483 /* Cancel any pending delayed cv broadcast timeouts */
8484 if (un->un_dcvb_timeid != NULL) {
8485 timeout_id_t temp_id = un->un_dcvb_timeid;
8486 un->un_dcvb_timeid = NULL;
8487 mutex_exit(SD_MUTEX(un));
8488 (void) untimeout(temp_id);
8489 mutex_enter(SD_MUTEX(un));
8490 }
8491
8492 mutex_exit(SD_MUTEX(un));
8493
8494 /* There should not be any in-progress I/O so ASSERT this check */
8495 ASSERT(un->un_ncmds_in_transport == 0);
8496 ASSERT(un->un_ncmds_in_driver == 0);
8497
8498 /* Do not free the softstate if the callback routine is active */
8499 sd_sync_with_callback(un);
8500
8501 /*
8502 * Partition stats apparently are not used with removables. These would
8503 * not have been created during attach, so no need to clean them up...
8504 */
8505 if (un->un_errstats != NULL) {
8506 kstat_delete(un->un_errstats);
8507 un->un_errstats = NULL;
8508 }
8509
8510 create_errstats_failed:
8511
8512 if (un->un_stats != NULL) {
8513 kstat_delete(un->un_stats);
8514 un->un_stats = NULL;
8515 }
8516
8517 ddi_xbuf_attr_unregister_devinfo(un->un_xbuf_attr, devi);
8518 ddi_xbuf_attr_destroy(un->un_xbuf_attr);
8519
8520 ddi_prop_remove_all(devi);
8521 sema_destroy(&un->un_semoclose);
8522 cv_destroy(&un->un_state_cv);
8523
8524 getrbuf_failed:
8525
8526 sd_free_rqs(un);
8527
8528 alloc_rqs_failed:
8529
8530 devp->sd_private = NULL;
8531 bzero(un, sizeof (struct sd_lun)); /* Clear any stale data! */
8532
8533 get_softstate_failed:
8534 /*
8535 * Note: the man pages are unclear as to whether or not doing a
8536 * ddi_soft_state_free(sd_state, instance) is the right way to
8537 * clean up after the ddi_soft_state_zalloc() if the subsequent
8538 * ddi_get_soft_state() fails. The implication seems to be
8539 * that the get_soft_state cannot fail if the zalloc succeeds.
8540 */
8541 #ifndef XPV_HVM_DRIVER
8542 ddi_soft_state_free(sd_state, instance);
8543 #endif /* !XPV_HVM_DRIVER */
8544
8545 probe_failed:
8546 scsi_unprobe(devp);
8547
8548 return (DDI_FAILURE);
8549 }
8550
8551
8552 /*
8553 * Function: sd_unit_detach
8554 *
8555 * Description: Performs DDI_DETACH processing for sddetach().
8556 *
8557 * Return Code: DDI_SUCCESS
8558 * DDI_FAILURE
8559 *
8560 * Context: Kernel thread context
8561 */
8562
8563 static int
8564 sd_unit_detach(dev_info_t *devi)
8565 {
8566 struct scsi_device *devp;
8567 struct sd_lun *un;
8568 int i;
8569 int tgt;
8570 dev_t dev;
8571 dev_info_t *pdip = ddi_get_parent(devi);
8572 #ifndef XPV_HVM_DRIVER
8573 int instance = ddi_get_instance(devi);
8574 #endif /* !XPV_HVM_DRIVER */
8575
8576 mutex_enter(&sd_detach_mutex);
8577
8578 /*
8579 * Fail the detach for any of the following:
8580 * - Unable to get the sd_lun struct for the instance
8581 * - A layered driver has an outstanding open on the instance
8582 * - Another thread is already detaching this instance
8583 * - Another thread is currently performing an open
8584 */
8585 devp = ddi_get_driver_private(devi);
8586 if ((devp == NULL) ||
8587 ((un = (struct sd_lun *)devp->sd_private) == NULL) ||
8588 (un->un_ncmds_in_driver != 0) || (un->un_layer_count != 0) ||
8589 (un->un_detach_count != 0) || (un->un_opens_in_progress != 0)) {
8590 mutex_exit(&sd_detach_mutex);
8591 return (DDI_FAILURE);
8592 }
8593
8594 SD_TRACE(SD_LOG_ATTACH_DETACH, un, "sd_unit_detach: entry 0x%p\n", un);
8595
8596 /*
8597 * Mark this instance as currently in a detach, to inhibit any
8598 * opens from a layered driver.
8599 */
8600 un->un_detach_count++;
8601 mutex_exit(&sd_detach_mutex);
8602
8603 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS,
8604 SCSI_ADDR_PROP_TARGET, -1);
8605
8606 dev = sd_make_device(SD_DEVINFO(un));
8607
8608 #ifndef lint
8609 _NOTE(COMPETING_THREADS_NOW);
8610 #endif
8611
8612 mutex_enter(SD_MUTEX(un));
8613
8614 /*
8615 * Fail the detach if there are any outstanding layered
8616 * opens on this device.
8617 */
8618 for (i = 0; i < NDKMAP; i++) {
8619 if (un->un_ocmap.lyropen[i] != 0) {
8620 goto err_notclosed;
8621 }
8622 }
8623
8624 /*
8625 * Verify there are NO outstanding commands issued to this device.
8626 * ie, un_ncmds_in_transport == 0.
8627 * It's possible to have outstanding commands through the physio
8628 * code path, even though everything's closed.
8629 */
8630 if ((un->un_ncmds_in_transport != 0) || (un->un_retry_timeid != NULL) ||
8631 (un->un_direct_priority_timeid != NULL) ||
8632 (un->un_state == SD_STATE_RWAIT)) {
8633 mutex_exit(SD_MUTEX(un));
8634 SD_ERROR(SD_LOG_ATTACH_DETACH, un,
8635 "sd_dr_detach: Detach failure due to outstanding cmds\n");
8636 goto err_stillbusy;
8637 }
8638
8639 /*
8640 * If we have the device reserved, release the reservation.
8641 */
8642 if ((un->un_resvd_status & SD_RESERVE) &&
8643 !(un->un_resvd_status & SD_LOST_RESERVE)) {
8644 mutex_exit(SD_MUTEX(un));
8645 /*
8646 * Note: sd_reserve_release sends a command to the device
8647 * via the sd_ioctlcmd() path, and can sleep.
8648 */
8649 if (sd_reserve_release(dev, SD_RELEASE) != 0) {
8650 SD_ERROR(SD_LOG_ATTACH_DETACH, un,
8651 "sd_dr_detach: Cannot release reservation \n");
8652 }
8653 } else {
8654 mutex_exit(SD_MUTEX(un));
8655 }
8656
8657 /*
8658 * Untimeout any reserve recover, throttle reset, restart unit
8659 * and delayed broadcast timeout threads. Protect the timeout pointer
8660 * from getting nulled by their callback functions.
8661 */
8662 mutex_enter(SD_MUTEX(un));
8663 if (un->un_resvd_timeid != NULL) {
8664 timeout_id_t temp_id = un->un_resvd_timeid;
8665 un->un_resvd_timeid = NULL;
8666 mutex_exit(SD_MUTEX(un));
8667 (void) untimeout(temp_id);
8668 mutex_enter(SD_MUTEX(un));
8669 }
8670
8671 if (un->un_reset_throttle_timeid != NULL) {
8672 timeout_id_t temp_id = un->un_reset_throttle_timeid;
8673 un->un_reset_throttle_timeid = NULL;
8674 mutex_exit(SD_MUTEX(un));
8675 (void) untimeout(temp_id);
8676 mutex_enter(SD_MUTEX(un));
8677 }
8678
8679 if (un->un_startstop_timeid != NULL) {
8680 timeout_id_t temp_id = un->un_startstop_timeid;
8681 un->un_startstop_timeid = NULL;
8682 mutex_exit(SD_MUTEX(un));
8683 (void) untimeout(temp_id);
8684 mutex_enter(SD_MUTEX(un));
8685 }
8686
8687 if (un->un_rmw_msg_timeid != NULL) {
8688 timeout_id_t temp_id = un->un_rmw_msg_timeid;
8689 un->un_rmw_msg_timeid = NULL;
8690 mutex_exit(SD_MUTEX(un));
8691 (void) untimeout(temp_id);
8692 mutex_enter(SD_MUTEX(un));
8693 }
8694
8695 if (un->un_dcvb_timeid != NULL) {
8696 timeout_id_t temp_id = un->un_dcvb_timeid;
8697 un->un_dcvb_timeid = NULL;
8698 mutex_exit(SD_MUTEX(un));
8699 (void) untimeout(temp_id);
8700 } else {
8701 mutex_exit(SD_MUTEX(un));
8702 }
8703
8704 /* Remove any pending reservation reclaim requests for this device */
8705 sd_rmv_resv_reclaim_req(dev);
8706
8707 mutex_enter(SD_MUTEX(un));
8708
8709 /* Cancel any pending callbacks for SD_PATH_DIRECT_PRIORITY cmd. */
8710 if (un->un_direct_priority_timeid != NULL) {
8711 timeout_id_t temp_id = un->un_direct_priority_timeid;
8712 un->un_direct_priority_timeid = NULL;
8713 mutex_exit(SD_MUTEX(un));
8714 (void) untimeout(temp_id);
8715 mutex_enter(SD_MUTEX(un));
8716 }
8717
8718 /* Cancel any active multi-host disk watch thread requests */
8719 if (un->un_mhd_token != NULL) {
8720 mutex_exit(SD_MUTEX(un));
8721 _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::un_mhd_token));
8722 if (scsi_watch_request_terminate(un->un_mhd_token,
8723 SCSI_WATCH_TERMINATE_NOWAIT)) {
8724 SD_ERROR(SD_LOG_ATTACH_DETACH, un,
8725 "sd_dr_detach: Cannot cancel mhd watch request\n");
8726 /*
8727 * Note: We are returning here after having removed
8728 * some driver timeouts above. This is consistent with
8729 * the legacy implementation but perhaps the watch
8730 * terminate call should be made with the wait flag set.
8731 */
8732 goto err_stillbusy;
8733 }
8734 mutex_enter(SD_MUTEX(un));
8735 un->un_mhd_token = NULL;
8736 }
8737
8738 if (un->un_swr_token != NULL) {
8739 mutex_exit(SD_MUTEX(un));
8740 _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::un_swr_token));
8741 if (scsi_watch_request_terminate(un->un_swr_token,
8742 SCSI_WATCH_TERMINATE_NOWAIT)) {
8743 SD_ERROR(SD_LOG_ATTACH_DETACH, un,
8744 "sd_dr_detach: Cannot cancel swr watch request\n");
8745 /*
8746 * Note: We are returning here after having removed
8747 * some driver timeouts above. This is consistent with
8748 * the legacy implementation but perhaps the watch
8749 * terminate call should be made with the wait flag set.
8750 */
8751 goto err_stillbusy;
8752 }
8753 mutex_enter(SD_MUTEX(un));
8754 un->un_swr_token = NULL;
8755 }
8756
8757 mutex_exit(SD_MUTEX(un));
8758
8759 /*
8760 * Clear any scsi_reset_notifies. We clear the reset notifies
8761 * if we have not registered one.
8762 * Note: The sd_mhd_reset_notify_cb() fn tries to acquire SD_MUTEX!
8763 */
8764 (void) scsi_reset_notify(SD_ADDRESS(un), SCSI_RESET_CANCEL,
8765 sd_mhd_reset_notify_cb, (caddr_t)un);
8766
8767 /*
8768 * protect the timeout pointers from getting nulled by
8769 * their callback functions during the cancellation process.
8770 * In such a scenario untimeout can be invoked with a null value.
8771 */
8772 _NOTE(NO_COMPETING_THREADS_NOW);
8773
8774 mutex_enter(&un->un_pm_mutex);
8775 if (un->un_pm_idle_timeid != NULL) {
8776 timeout_id_t temp_id = un->un_pm_idle_timeid;
8777 un->un_pm_idle_timeid = NULL;
8778 mutex_exit(&un->un_pm_mutex);
8779
8780 /*
8781 * Timeout is active; cancel it.
8782 * Note that it'll never be active on a device
8783 * that does not support PM therefore we don't
8784 * have to check before calling pm_idle_component.
8785 */
8786 (void) untimeout(temp_id);
8787 (void) pm_idle_component(SD_DEVINFO(un), 0);
8788 mutex_enter(&un->un_pm_mutex);
8789 }
8790
8791 /*
8792 * Check whether there is already a timeout scheduled for power
8793 * management. If yes then don't lower the power here, that's.
8794 * the timeout handler's job.
8795 */
8796 if (un->un_pm_timeid != NULL) {
8797 timeout_id_t temp_id = un->un_pm_timeid;
8798 un->un_pm_timeid = NULL;
8799 mutex_exit(&un->un_pm_mutex);
8800 /*
8801 * Timeout is active; cancel it.
8802 * Note that it'll never be active on a device
8803 * that does not support PM therefore we don't
8804 * have to check before calling pm_idle_component.
8805 */
8806 (void) untimeout(temp_id);
8807 (void) pm_idle_component(SD_DEVINFO(un), 0);
8808
8809 } else {
8810 mutex_exit(&un->un_pm_mutex);
8811 if ((un->un_f_pm_is_enabled == TRUE) &&
8812 (pm_lower_power(SD_DEVINFO(un), 0, SD_PM_STATE_STOPPED(un))
8813 != DDI_SUCCESS)) {
8814 SD_ERROR(SD_LOG_ATTACH_DETACH, un,
8815 "sd_dr_detach: Lower power request failed, ignoring.\n");
8816 /*
8817 * Fix for bug: 4297749, item # 13
8818 * The above test now includes a check to see if PM is
8819 * supported by this device before call
8820 * pm_lower_power().
8821 * Note, the following is not dead code. The call to
8822 * pm_lower_power above will generate a call back into
8823 * our sdpower routine which might result in a timeout
8824 * handler getting activated. Therefore the following
8825 * code is valid and necessary.
8826 */
8827 mutex_enter(&un->un_pm_mutex);
8828 if (un->un_pm_timeid != NULL) {
8829 timeout_id_t temp_id = un->un_pm_timeid;
8830 un->un_pm_timeid = NULL;
8831 mutex_exit(&un->un_pm_mutex);
8832 (void) untimeout(temp_id);
8833 (void) pm_idle_component(SD_DEVINFO(un), 0);
8834 } else {
8835 mutex_exit(&un->un_pm_mutex);
8836 }
8837 }
8838 }
8839
8840 /*
8841 * Cleanup from the scsi_ifsetcap() calls (437868)
8842 * Relocated here from above to be after the call to
8843 * pm_lower_power, which was getting errors.
8844 */
8845 (void) scsi_ifsetcap(SD_ADDRESS(un), "lun-reset", 0, 1);
8846 (void) scsi_ifsetcap(SD_ADDRESS(un), "wide-xfer", 0, 1);
8847
8848 /*
8849 * Currently, tagged queuing is supported per target based by HBA.
8850 * Setting this per lun instance actually sets the capability of this
8851 * target in HBA, which affects those luns already attached on the
8852 * same target. So during detach, we can only disable this capability
8853 * only when this is the only lun left on this target. By doing
8854 * this, we assume a target has the same tagged queuing capability
8855 * for every lun. The condition can be removed when HBA is changed to
8856 * support per lun based tagged queuing capability.
8857 */
8858 if (sd_scsi_get_target_lun_count(pdip, tgt) <= 1) {
8859 (void) scsi_ifsetcap(SD_ADDRESS(un), "tagged-qing", 0, 1);
8860 }
8861
8862 if (un->un_f_is_fibre == FALSE) {
8863 (void) scsi_ifsetcap(SD_ADDRESS(un), "auto-rqsense", 0, 1);
8864 }
8865
8866 /*
8867 * Remove any event callbacks, fibre only
8868 */
8869 if (un->un_f_is_fibre == TRUE) {
8870 if ((un->un_insert_event != NULL) &&
8871 (ddi_remove_event_handler(un->un_insert_cb_id) !=
8872 DDI_SUCCESS)) {
8873 /*
8874 * Note: We are returning here after having done
8875 * substantial cleanup above. This is consistent
8876 * with the legacy implementation but this may not
8877 * be the right thing to do.
8878 */
8879 SD_ERROR(SD_LOG_ATTACH_DETACH, un,
8880 "sd_dr_detach: Cannot cancel insert event\n");
8881 goto err_remove_event;
8882 }
8883 un->un_insert_event = NULL;
8884
8885 if ((un->un_remove_event != NULL) &&
8886 (ddi_remove_event_handler(un->un_remove_cb_id) !=
8887 DDI_SUCCESS)) {
8888 /*
8889 * Note: We are returning here after having done
8890 * substantial cleanup above. This is consistent
8891 * with the legacy implementation but this may not
8892 * be the right thing to do.
8893 */
8894 SD_ERROR(SD_LOG_ATTACH_DETACH, un,
8895 "sd_dr_detach: Cannot cancel remove event\n");
8896 goto err_remove_event;
8897 }
8898 un->un_remove_event = NULL;
8899 }
8900
8901 /* Do not free the softstate if the callback routine is active */
8902 sd_sync_with_callback(un);
8903
8904 cmlb_detach(un->un_cmlbhandle, (void *)SD_PATH_DIRECT);
8905 cmlb_free_handle(&un->un_cmlbhandle);
8906
8907 /*
8908 * Hold the detach mutex here, to make sure that no other threads ever
8909 * can access a (partially) freed soft state structure.
8910 */
8911 mutex_enter(&sd_detach_mutex);
8912
8913 /*
8914 * Clean up the soft state struct.
8915 * Cleanup is done in reverse order of allocs/inits.
8916 * At this point there should be no competing threads anymore.
8917 */
8918
8919 scsi_fm_fini(devp);
8920
8921 /*
8922 * Deallocate memory for SCSI FMA.
8923 */
8924 kmem_free(un->un_fm_private, sizeof (struct sd_fm_internal));
8925
8926 /*
8927 * Unregister and free device id if it was not registered
8928 * by the transport.
8929 */
8930 if (un->un_f_devid_transport_defined == FALSE)
8931 ddi_devid_unregister(devi);
8932
8933 /*
8934 * free the devid structure if allocated before (by ddi_devid_init()
8935 * or ddi_devid_get()).
8936 */
8937 if (un->un_devid) {
8938 ddi_devid_free(un->un_devid);
8939 un->un_devid = NULL;
8940 }
8941
8942 /*
8943 * Destroy wmap cache if it exists.
8944 */
8945 if (un->un_wm_cache != NULL) {
8946 kmem_cache_destroy(un->un_wm_cache);
8947 un->un_wm_cache = NULL;
8948 }
8949
8950 /*
8951 * kstat cleanup is done in detach for all device types (4363169).
8952 * We do not want to fail detach if the device kstats are not deleted
8953 * since there is a confusion about the devo_refcnt for the device.
8954 * We just delete the kstats and let detach complete successfully.
8955 */
8956 if (un->un_stats != NULL) {
8957 kstat_delete(un->un_stats);
8958 un->un_stats = NULL;
8959 }
8960 if (un->un_errstats != NULL) {
8961 kstat_delete(un->un_errstats);
8962 un->un_errstats = NULL;
8963 }
8964
8965 /* Remove partition stats */
8966 if (un->un_f_pkstats_enabled) {
8967 for (i = 0; i < NSDMAP; i++) {
8968 if (un->un_pstats[i] != NULL) {
8969 kstat_delete(un->un_pstats[i]);
8970 un->un_pstats[i] = NULL;
8971 }
8972 }
8973 }
8974
8975 /* Remove xbuf registration */
8976 ddi_xbuf_attr_unregister_devinfo(un->un_xbuf_attr, devi);
8977 ddi_xbuf_attr_destroy(un->un_xbuf_attr);
8978
8979 /* Remove driver properties */
8980 ddi_prop_remove_all(devi);
8981
8982 mutex_destroy(&un->un_pm_mutex);
8983 cv_destroy(&un->un_pm_busy_cv);
8984
8985 cv_destroy(&un->un_wcc_cv);
8986
8987 /* Open/close semaphore */
8988 sema_destroy(&un->un_semoclose);
8989
8990 /* Removable media condvar. */
8991 cv_destroy(&un->un_state_cv);
8992
8993 /* Suspend/resume condvar. */
8994 cv_destroy(&un->un_suspend_cv);
8995 cv_destroy(&un->un_disk_busy_cv);
8996
8997 sd_free_rqs(un);
8998
8999 /* Free up soft state */
9000 devp->sd_private = NULL;
9001
9002 bzero(un, sizeof (struct sd_lun));
9003 #ifndef XPV_HVM_DRIVER
9004 ddi_soft_state_free(sd_state, instance);
9005 #endif /* !XPV_HVM_DRIVER */
9006
9007 mutex_exit(&sd_detach_mutex);
9008
9009 /* This frees up the INQUIRY data associated with the device. */
9010 scsi_unprobe(devp);
9011
9012 /*
9013 * After successfully detaching an instance, we update the information
9014 * of how many luns have been attached in the relative target and
9015 * controller for parallel SCSI. This information is used when sd tries
9016 * to set the tagged queuing capability in HBA.
9017 * Since un has been released, we can't use SD_IS_PARALLEL_SCSI(un) to
9018 * check if the device is parallel SCSI. However, we don't need to
9019 * check here because we've already checked during attach. No device
9020 * that is not parallel SCSI is in the chain.
9021 */
9022 if ((tgt >= 0) && (tgt < NTARGETS_WIDE)) {
9023 sd_scsi_update_lun_on_target(pdip, tgt, SD_SCSI_LUN_DETACH);
9024 }
9025
9026 return (DDI_SUCCESS);
9027
9028 err_notclosed:
9029 mutex_exit(SD_MUTEX(un));
9030
9031 err_stillbusy:
9032 _NOTE(NO_COMPETING_THREADS_NOW);
9033
9034 err_remove_event:
9035 mutex_enter(&sd_detach_mutex);
9036 un->un_detach_count--;
9037 mutex_exit(&sd_detach_mutex);
9038
9039 SD_TRACE(SD_LOG_ATTACH_DETACH, un, "sd_unit_detach: exit failure\n");
9040 return (DDI_FAILURE);
9041 }
9042
9043
9044 /*
9045 * Function: sd_create_errstats
9046 *
9047 * Description: This routine instantiates the device error stats.
9048 *
9049 * Note: During attach the stats are instantiated first so they are
9050 * available for attach-time routines that utilize the driver
9051 * iopath to send commands to the device. The stats are initialized
9052 * separately so data obtained during some attach-time routines is
9053 * available. (4362483)
9054 *
9055 * Arguments: un - driver soft state (unit) structure
9056 * instance - driver instance
9057 *
9058 * Context: Kernel thread context
9059 */
9060
9061 static void
9062 sd_create_errstats(struct sd_lun *un, int instance)
9063 {
9064 struct sd_errstats *stp;
9065 char kstatmodule_err[KSTAT_STRLEN];
9066 char kstatname[KSTAT_STRLEN];
9067 int ndata = (sizeof (struct sd_errstats) / sizeof (kstat_named_t));
9068
9069 ASSERT(un != NULL);
9070
9071 if (un->un_errstats != NULL) {
9072 return;
9073 }
9074
9075 (void) snprintf(kstatmodule_err, sizeof (kstatmodule_err),
9076 "%serr", sd_label);
9077 (void) snprintf(kstatname, sizeof (kstatname),
9078 "%s%d,err", sd_label, instance);
9079
9080 un->un_errstats = kstat_create(kstatmodule_err, instance, kstatname,
9081 "device_error", KSTAT_TYPE_NAMED, ndata, KSTAT_FLAG_PERSISTENT);
9082
9083 if (un->un_errstats == NULL) {
9084 SD_ERROR(SD_LOG_ATTACH_DETACH, un,
9085 "sd_create_errstats: Failed kstat_create\n");
9086 return;
9087 }
9088
9089 stp = (struct sd_errstats *)un->un_errstats->ks_data;
9090 kstat_named_init(&stp->sd_softerrs, "Soft Errors",
9091 KSTAT_DATA_UINT32);
9092 kstat_named_init(&stp->sd_harderrs, "Hard Errors",
9093 KSTAT_DATA_UINT32);
9094 kstat_named_init(&stp->sd_transerrs, "Transport Errors",
9095 KSTAT_DATA_UINT32);
9096 kstat_named_init(&stp->sd_vid, "Vendor",
9097 KSTAT_DATA_CHAR);
9098 kstat_named_init(&stp->sd_pid, "Product",
9099 KSTAT_DATA_CHAR);
9100 kstat_named_init(&stp->sd_revision, "Revision",
9101 KSTAT_DATA_CHAR);
9102 kstat_named_init(&stp->sd_serial, "Serial No",
9103 KSTAT_DATA_CHAR);
9104 kstat_named_init(&stp->sd_capacity, "Size",
9105 KSTAT_DATA_ULONGLONG);
9106 kstat_named_init(&stp->sd_rq_media_err, "Media Error",
9107 KSTAT_DATA_UINT32);
9108 kstat_named_init(&stp->sd_rq_ntrdy_err, "Device Not Ready",
9109 KSTAT_DATA_UINT32);
9110 kstat_named_init(&stp->sd_rq_nodev_err, "No Device",
9111 KSTAT_DATA_UINT32);
9112 kstat_named_init(&stp->sd_rq_recov_err, "Recoverable",
9113 KSTAT_DATA_UINT32);
9114 kstat_named_init(&stp->sd_rq_illrq_err, "Illegal Request",
9115 KSTAT_DATA_UINT32);
9116 kstat_named_init(&stp->sd_rq_pfa_err, "Predictive Failure Analysis",
9117 KSTAT_DATA_UINT32);
9118
9119 un->un_errstats->ks_private = un;
9120 un->un_errstats->ks_update = nulldev;
9121
9122 kstat_install(un->un_errstats);
9123 }
9124
9125
9126 /*
9127 * Function: sd_set_errstats
9128 *
9129 * Description: This routine sets the value of the vendor id, product id,
9130 * revision, serial number, and capacity device error stats.
9131 *
9132 * Note: During attach the stats are instantiated first so they are
9133 * available for attach-time routines that utilize the driver
9134 * iopath to send commands to the device. The stats are initialized
9135 * separately so data obtained during some attach-time routines is
9136 * available. (4362483)
9137 *
9138 * Arguments: un - driver soft state (unit) structure
9139 *
9140 * Context: Kernel thread context
9141 */
9142
9143 static void
9144 sd_set_errstats(struct sd_lun *un)
9145 {
9146 struct sd_errstats *stp;
9147 char *sn;
9148
9149 ASSERT(un != NULL);
9150 ASSERT(un->un_errstats != NULL);
9151 stp = (struct sd_errstats *)un->un_errstats->ks_data;
9152 ASSERT(stp != NULL);
9153 (void) strncpy(stp->sd_vid.value.c, un->un_sd->sd_inq->inq_vid, 8);
9154 (void) strncpy(stp->sd_pid.value.c, un->un_sd->sd_inq->inq_pid, 16);
9155 (void) strncpy(stp->sd_revision.value.c,
9156 un->un_sd->sd_inq->inq_revision, 4);
9157
9158 /*
9159 * All the errstats are persistent across detach/attach,
9160 * so reset all the errstats here in case of the hot
9161 * replacement of disk drives, except for not changed
9162 * Sun qualified drives.
9163 */
9164 if ((bcmp(&SD_INQUIRY(un)->inq_pid[9], "SUN", 3) != 0) ||
9165 (bcmp(&SD_INQUIRY(un)->inq_serial, stp->sd_serial.value.c,
9166 sizeof (SD_INQUIRY(un)->inq_serial)) != 0)) {
9167 stp->sd_softerrs.value.ui32 = 0;
9168 stp->sd_harderrs.value.ui32 = 0;
9169 stp->sd_transerrs.value.ui32 = 0;
9170 stp->sd_rq_media_err.value.ui32 = 0;
9171 stp->sd_rq_ntrdy_err.value.ui32 = 0;
9172 stp->sd_rq_nodev_err.value.ui32 = 0;
9173 stp->sd_rq_recov_err.value.ui32 = 0;
9174 stp->sd_rq_illrq_err.value.ui32 = 0;
9175 stp->sd_rq_pfa_err.value.ui32 = 0;
9176 }
9177
9178 /*
9179 * Set the "Serial No" kstat for Sun qualified drives (indicated by
9180 * "SUN" in bytes 25-27 of the inquiry data (bytes 9-11 of the pid)
9181 * (4376302))
9182 */
9183 if (bcmp(&SD_INQUIRY(un)->inq_pid[9], "SUN", 3) == 0) {
9184 bcopy(&SD_INQUIRY(un)->inq_serial, stp->sd_serial.value.c,
9185 sizeof (SD_INQUIRY(un)->inq_serial));
9186 } else {
9187 /*
9188 * Set the "Serial No" kstat for non-Sun qualified drives
9189 */
9190 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, SD_DEVINFO(un),
9191 DDI_PROP_NOTPROM | DDI_PROP_DONTPASS,
9192 INQUIRY_SERIAL_NO, &sn) == DDI_SUCCESS) {
9193 (void) strlcpy(stp->sd_serial.value.c, sn,
9194 sizeof (stp->sd_serial.value.c));
9195 ddi_prop_free(sn);
9196 }
9197 }
9198
9199 if (un->un_f_blockcount_is_valid != TRUE) {
9200 /*
9201 * Set capacity error stat to 0 for no media. This ensures
9202 * a valid capacity is displayed in response to 'iostat -E'
9203 * when no media is present in the device.
9204 */
9205 stp->sd_capacity.value.ui64 = 0;
9206 } else {
9207 /*
9208 * Multiply un_blockcount by un->un_sys_blocksize to get
9209 * capacity.
9210 *
9211 * Note: for non-512 blocksize devices "un_blockcount" has been
9212 * "scaled" in sd_send_scsi_READ_CAPACITY by multiplying by
9213 * (un_tgt_blocksize / un->un_sys_blocksize).
9214 */
9215 stp->sd_capacity.value.ui64 = (uint64_t)
9216 ((uint64_t)un->un_blockcount * un->un_sys_blocksize);
9217 }
9218 }
9219
9220
9221 /*
9222 * Function: sd_set_pstats
9223 *
9224 * Description: This routine instantiates and initializes the partition
9225 * stats for each partition with more than zero blocks.
9226 * (4363169)
9227 *
9228 * Arguments: un - driver soft state (unit) structure
9229 *
9230 * Context: Kernel thread context
9231 */
9232
9233 static void
9234 sd_set_pstats(struct sd_lun *un)
9235 {
9236 char kstatname[KSTAT_STRLEN];
9237 int instance;
9238 int i;
9239 diskaddr_t nblks = 0;
9240 char *partname = NULL;
9241
9242 ASSERT(un != NULL);
9243
9244 instance = ddi_get_instance(SD_DEVINFO(un));
9245
9246 /* Note:x86: is this a VTOC8/VTOC16 difference? */
9247 for (i = 0; i < NSDMAP; i++) {
9248
9249 if (cmlb_partinfo(un->un_cmlbhandle, i,
9250 &nblks, NULL, &partname, NULL, (void *)SD_PATH_DIRECT) != 0)
9251 continue;
9252 mutex_enter(SD_MUTEX(un));
9253
9254 if ((un->un_pstats[i] == NULL) &&
9255 (nblks != 0)) {
9256
9257 (void) snprintf(kstatname, sizeof (kstatname),
9258 "%s%d,%s", sd_label, instance,
9259 partname);
9260
9261 un->un_pstats[i] = kstat_create(sd_label,
9262 instance, kstatname, "partition", KSTAT_TYPE_IO,
9263 1, KSTAT_FLAG_PERSISTENT);
9264 if (un->un_pstats[i] != NULL) {
9265 un->un_pstats[i]->ks_lock = SD_MUTEX(un);
9266 kstat_install(un->un_pstats[i]);
9267 }
9268 }
9269 mutex_exit(SD_MUTEX(un));
9270 }
9271 }
9272
9273
9274 #if (defined(__fibre))
9275 /*
9276 * Function: sd_init_event_callbacks
9277 *
9278 * Description: This routine initializes the insertion and removal event
9279 * callbacks. (fibre only)
9280 *
9281 * Arguments: un - driver soft state (unit) structure
9282 *
9283 * Context: Kernel thread context
9284 */
9285
9286 static void
9287 sd_init_event_callbacks(struct sd_lun *un)
9288 {
9289 ASSERT(un != NULL);
9290
9291 if ((un->un_insert_event == NULL) &&
9292 (ddi_get_eventcookie(SD_DEVINFO(un), FCAL_INSERT_EVENT,
9293 &un->un_insert_event) == DDI_SUCCESS)) {
9294 /*
9295 * Add the callback for an insertion event
9296 */
9297 (void) ddi_add_event_handler(SD_DEVINFO(un),
9298 un->un_insert_event, sd_event_callback, (void *)un,
9299 &(un->un_insert_cb_id));
9300 }
9301
9302 if ((un->un_remove_event == NULL) &&
9303 (ddi_get_eventcookie(SD_DEVINFO(un), FCAL_REMOVE_EVENT,
9304 &un->un_remove_event) == DDI_SUCCESS)) {
9305 /*
9306 * Add the callback for a removal event
9307 */
9308 (void) ddi_add_event_handler(SD_DEVINFO(un),
9309 un->un_remove_event, sd_event_callback, (void *)un,
9310 &(un->un_remove_cb_id));
9311 }
9312 }
9313
9314
9315 /*
9316 * Function: sd_event_callback
9317 *
9318 * Description: This routine handles insert/remove events (photon). The
9319 * state is changed to OFFLINE which can be used to supress
9320 * error msgs. (fibre only)
9321 *
9322 * Arguments: un - driver soft state (unit) structure
9323 *
9324 * Context: Callout thread context
9325 */
9326 /* ARGSUSED */
9327 static void
9328 sd_event_callback(dev_info_t *dip, ddi_eventcookie_t event, void *arg,
9329 void *bus_impldata)
9330 {
9331 struct sd_lun *un = (struct sd_lun *)arg;
9332
9333 _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::un_insert_event));
9334 if (event == un->un_insert_event) {
9335 SD_TRACE(SD_LOG_COMMON, un, "sd_event_callback: insert event");
9336 mutex_enter(SD_MUTEX(un));
9337 if (un->un_state == SD_STATE_OFFLINE) {
9338 if (un->un_last_state != SD_STATE_SUSPENDED) {
9339 un->un_state = un->un_last_state;
9340 } else {
9341 /*
9342 * We have gone through SUSPEND/RESUME while
9343 * we were offline. Restore the last state
9344 */
9345 un->un_state = un->un_save_state;
9346 }
9347 }
9348 mutex_exit(SD_MUTEX(un));
9349
9350 _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::un_remove_event));
9351 } else if (event == un->un_remove_event) {
9352 SD_TRACE(SD_LOG_COMMON, un, "sd_event_callback: remove event");
9353 mutex_enter(SD_MUTEX(un));
9354 /*
9355 * We need to handle an event callback that occurs during
9356 * the suspend operation, since we don't prevent it.
9357 */
9358 if (un->un_state != SD_STATE_OFFLINE) {
9359 if (un->un_state != SD_STATE_SUSPENDED) {
9360 New_state(un, SD_STATE_OFFLINE);
9361 } else {
9362 un->un_last_state = SD_STATE_OFFLINE;
9363 }
9364 }
9365 mutex_exit(SD_MUTEX(un));
9366 } else {
9367 scsi_log(SD_DEVINFO(un), sd_label, CE_NOTE,
9368 "!Unknown event\n");
9369 }
9370
9371 }
9372 #endif
9373
9374 /*
9375 * Function: sd_cache_control()
9376 *
9377 * Description: This routine is the driver entry point for setting
9378 * read and write caching by modifying the WCE (write cache
9379 * enable) and RCD (read cache disable) bits of mode
9380 * page 8 (MODEPAGE_CACHING).
9381 *
9382 * Arguments: ssc - ssc contains pointer to driver soft state (unit)
9383 * structure for this target.
9384 * rcd_flag - flag for controlling the read cache
9385 * wce_flag - flag for controlling the write cache
9386 *
9387 * Return Code: EIO
9388 * code returned by sd_send_scsi_MODE_SENSE and
9389 * sd_send_scsi_MODE_SELECT
9390 *
9391 * Context: Kernel Thread
9392 */
9393
9394 static int
9395 sd_cache_control(sd_ssc_t *ssc, int rcd_flag, int wce_flag)
9396 {
9397 struct mode_caching *mode_caching_page;
9398 uchar_t *header;
9399 size_t buflen;
9400 int hdrlen;
9401 int bd_len;
9402 int rval = 0;
9403 struct mode_header_grp2 *mhp;
9404 struct sd_lun *un;
9405 int status;
9406
9407 ASSERT(ssc != NULL);
9408 un = ssc->ssc_un;
9409 ASSERT(un != NULL);
9410
9411 /*
9412 * Do a test unit ready, otherwise a mode sense may not work if this
9413 * is the first command sent to the device after boot.
9414 */
9415 status = sd_send_scsi_TEST_UNIT_READY(ssc, 0);
9416 if (status != 0)
9417 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
9418
9419 if (un->un_f_cfg_is_atapi == TRUE) {
9420 hdrlen = MODE_HEADER_LENGTH_GRP2;
9421 } else {
9422 hdrlen = MODE_HEADER_LENGTH;
9423 }
9424
9425 /*
9426 * Allocate memory for the retrieved mode page and its headers. Set
9427 * a pointer to the page itself. Use mode_cache_scsi3 to insure
9428 * we get all of the mode sense data otherwise, the mode select
9429 * will fail. mode_cache_scsi3 is a superset of mode_caching.
9430 */
9431 buflen = hdrlen + MODE_BLK_DESC_LENGTH +
9432 sizeof (struct mode_cache_scsi3);
9433
9434 header = kmem_zalloc(buflen, KM_SLEEP);
9435
9436 /* Get the information from the device. */
9437 if (un->un_f_cfg_is_atapi == TRUE) {
9438 rval = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP1, header, buflen,
9439 MODEPAGE_CACHING, SD_PATH_DIRECT);
9440 } else {
9441 rval = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP0, header, buflen,
9442 MODEPAGE_CACHING, SD_PATH_DIRECT);
9443 }
9444
9445 if (rval != 0) {
9446 SD_ERROR(SD_LOG_IOCTL_RMMEDIA, un,
9447 "sd_cache_control: Mode Sense Failed\n");
9448 goto mode_sense_failed;
9449 }
9450
9451 /*
9452 * Determine size of Block Descriptors in order to locate
9453 * the mode page data. ATAPI devices return 0, SCSI devices
9454 * should return MODE_BLK_DESC_LENGTH.
9455 */
9456 if (un->un_f_cfg_is_atapi == TRUE) {
9457 mhp = (struct mode_header_grp2 *)header;
9458 bd_len = (mhp->bdesc_length_hi << 8) | mhp->bdesc_length_lo;
9459 } else {
9460 bd_len = ((struct mode_header *)header)->bdesc_length;
9461 }
9462
9463 if (bd_len > MODE_BLK_DESC_LENGTH) {
9464 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, 0,
9465 "sd_cache_control: Mode Sense returned invalid block "
9466 "descriptor length\n");
9467 rval = EIO;
9468 goto mode_sense_failed;
9469 }
9470
9471 mode_caching_page = (struct mode_caching *)(header + hdrlen + bd_len);
9472 if (mode_caching_page->mode_page.code != MODEPAGE_CACHING) {
9473 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, SD_LOG_COMMON,
9474 "sd_cache_control: Mode Sense caching page code mismatch "
9475 "%d\n", mode_caching_page->mode_page.code);
9476 rval = EIO;
9477 goto mode_sense_failed;
9478 }
9479
9480 /* Check the relevant bits on successful mode sense. */
9481 if ((mode_caching_page->rcd && rcd_flag == SD_CACHE_ENABLE) ||
9482 (!mode_caching_page->rcd && rcd_flag == SD_CACHE_DISABLE) ||
9483 (mode_caching_page->wce && wce_flag == SD_CACHE_DISABLE) ||
9484 (!mode_caching_page->wce && wce_flag == SD_CACHE_ENABLE)) {
9485
9486 size_t sbuflen;
9487 uchar_t save_pg;
9488
9489 /*
9490 * Construct select buffer length based on the
9491 * length of the sense data returned.
9492 */
9493 sbuflen = hdrlen + bd_len +
9494 sizeof (struct mode_page) +
9495 (int)mode_caching_page->mode_page.length;
9496
9497 /*
9498 * Set the caching bits as requested.
9499 */
9500 if (rcd_flag == SD_CACHE_ENABLE)
9501 mode_caching_page->rcd = 0;
9502 else if (rcd_flag == SD_CACHE_DISABLE)
9503 mode_caching_page->rcd = 1;
9504
9505 if (wce_flag == SD_CACHE_ENABLE)
9506 mode_caching_page->wce = 1;
9507 else if (wce_flag == SD_CACHE_DISABLE)
9508 mode_caching_page->wce = 0;
9509
9510 /*
9511 * Save the page if the mode sense says the
9512 * drive supports it.
9513 */
9514 save_pg = mode_caching_page->mode_page.ps ?
9515 SD_SAVE_PAGE : SD_DONTSAVE_PAGE;
9516
9517 /* Clear reserved bits before mode select. */
9518 mode_caching_page->mode_page.ps = 0;
9519
9520 /*
9521 * Clear out mode header for mode select.
9522 * The rest of the retrieved page will be reused.
9523 */
9524 bzero(header, hdrlen);
9525
9526 if (un->un_f_cfg_is_atapi == TRUE) {
9527 mhp = (struct mode_header_grp2 *)header;
9528 mhp->bdesc_length_hi = bd_len >> 8;
9529 mhp->bdesc_length_lo = (uchar_t)bd_len & 0xff;
9530 } else {
9531 ((struct mode_header *)header)->bdesc_length = bd_len;
9532 }
9533
9534 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
9535
9536 /* Issue mode select to change the cache settings */
9537 if (un->un_f_cfg_is_atapi == TRUE) {
9538 rval = sd_send_scsi_MODE_SELECT(ssc, CDB_GROUP1, header,
9539 sbuflen, save_pg, SD_PATH_DIRECT);
9540 } else {
9541 rval = sd_send_scsi_MODE_SELECT(ssc, CDB_GROUP0, header,
9542 sbuflen, save_pg, SD_PATH_DIRECT);
9543 }
9544
9545 }
9546
9547
9548 mode_sense_failed:
9549
9550 kmem_free(header, buflen);
9551
9552 if (rval != 0) {
9553 if (rval == EIO)
9554 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
9555 else
9556 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
9557 }
9558 return (rval);
9559 }
9560
9561
9562 /*
9563 * Function: sd_get_write_cache_enabled()
9564 *
9565 * Description: This routine is the driver entry point for determining if
9566 * write caching is enabled. It examines the WCE (write cache
9567 * enable) bits of mode page 8 (MODEPAGE_CACHING).
9568 *
9569 * Arguments: ssc - ssc contains pointer to driver soft state (unit)
9570 * structure for this target.
9571 * is_enabled - pointer to int where write cache enabled state
9572 * is returned (non-zero -> write cache enabled)
9573 *
9574 *
9575 * Return Code: EIO
9576 * code returned by sd_send_scsi_MODE_SENSE
9577 *
9578 * Context: Kernel Thread
9579 *
9580 * NOTE: If ioctl is added to disable write cache, this sequence should
9581 * be followed so that no locking is required for accesses to
9582 * un->un_f_write_cache_enabled:
9583 * do mode select to clear wce
9584 * do synchronize cache to flush cache
9585 * set un->un_f_write_cache_enabled = FALSE
9586 *
9587 * Conversely, an ioctl to enable the write cache should be done
9588 * in this order:
9589 * set un->un_f_write_cache_enabled = TRUE
9590 * do mode select to set wce
9591 */
9592
9593 static int
9594 sd_get_write_cache_enabled(sd_ssc_t *ssc, int *is_enabled)
9595 {
9596 struct mode_caching *mode_caching_page;
9597 uchar_t *header;
9598 size_t buflen;
9599 int hdrlen;
9600 int bd_len;
9601 int rval = 0;
9602 struct sd_lun *un;
9603 int status;
9604
9605 ASSERT(ssc != NULL);
9606 un = ssc->ssc_un;
9607 ASSERT(un != NULL);
9608 ASSERT(is_enabled != NULL);
9609
9610 /* in case of error, flag as enabled */
9611 *is_enabled = TRUE;
9612
9613 /*
9614 * Do a test unit ready, otherwise a mode sense may not work if this
9615 * is the first command sent to the device after boot.
9616 */
9617 status = sd_send_scsi_TEST_UNIT_READY(ssc, 0);
9618
9619 if (status != 0)
9620 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
9621
9622 if (un->un_f_cfg_is_atapi == TRUE) {
9623 hdrlen = MODE_HEADER_LENGTH_GRP2;
9624 } else {
9625 hdrlen = MODE_HEADER_LENGTH;
9626 }
9627
9628 /*
9629 * Allocate memory for the retrieved mode page and its headers. Set
9630 * a pointer to the page itself.
9631 */
9632 buflen = hdrlen + MODE_BLK_DESC_LENGTH + sizeof (struct mode_caching);
9633 header = kmem_zalloc(buflen, KM_SLEEP);
9634
9635 /* Get the information from the device. */
9636 if (un->un_f_cfg_is_atapi == TRUE) {
9637 rval = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP1, header, buflen,
9638 MODEPAGE_CACHING, SD_PATH_DIRECT);
9639 } else {
9640 rval = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP0, header, buflen,
9641 MODEPAGE_CACHING, SD_PATH_DIRECT);
9642 }
9643
9644 if (rval != 0) {
9645 SD_ERROR(SD_LOG_IOCTL_RMMEDIA, un,
9646 "sd_get_write_cache_enabled: Mode Sense Failed\n");
9647 goto mode_sense_failed;
9648 }
9649
9650 /*
9651 * Determine size of Block Descriptors in order to locate
9652 * the mode page data. ATAPI devices return 0, SCSI devices
9653 * should return MODE_BLK_DESC_LENGTH.
9654 */
9655 if (un->un_f_cfg_is_atapi == TRUE) {
9656 struct mode_header_grp2 *mhp;
9657 mhp = (struct mode_header_grp2 *)header;
9658 bd_len = (mhp->bdesc_length_hi << 8) | mhp->bdesc_length_lo;
9659 } else {
9660 bd_len = ((struct mode_header *)header)->bdesc_length;
9661 }
9662
9663 if (bd_len > MODE_BLK_DESC_LENGTH) {
9664 /* FMA should make upset complain here */
9665 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, 0,
9666 "sd_get_write_cache_enabled: Mode Sense returned invalid "
9667 "block descriptor length\n");
9668 rval = EIO;
9669 goto mode_sense_failed;
9670 }
9671
9672 mode_caching_page = (struct mode_caching *)(header + hdrlen + bd_len);
9673 if (mode_caching_page->mode_page.code != MODEPAGE_CACHING) {
9674 /* FMA could make upset complain here */
9675 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, SD_LOG_COMMON,
9676 "sd_get_write_cache_enabled: Mode Sense caching page "
9677 "code mismatch %d\n", mode_caching_page->mode_page.code);
9678 rval = EIO;
9679 goto mode_sense_failed;
9680 }
9681 *is_enabled = mode_caching_page->wce;
9682
9683 mode_sense_failed:
9684 if (rval == 0) {
9685 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
9686 } else if (rval == EIO) {
9687 /*
9688 * Some disks do not support mode sense(6), we
9689 * should ignore this kind of error(sense key is
9690 * 0x5 - illegal request).
9691 */
9692 uint8_t *sensep;
9693 int senlen;
9694
9695 sensep = (uint8_t *)ssc->ssc_uscsi_cmd->uscsi_rqbuf;
9696 senlen = (int)(ssc->ssc_uscsi_cmd->uscsi_rqlen -
9697 ssc->ssc_uscsi_cmd->uscsi_rqresid);
9698
9699 if (senlen > 0 &&
9700 scsi_sense_key(sensep) == KEY_ILLEGAL_REQUEST) {
9701 sd_ssc_assessment(ssc, SD_FMT_IGNORE_COMPROMISE);
9702 } else {
9703 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
9704 }
9705 } else {
9706 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
9707 }
9708 kmem_free(header, buflen);
9709 return (rval);
9710 }
9711
9712 /*
9713 * Function: sd_get_nv_sup()
9714 *
9715 * Description: This routine is the driver entry point for
9716 * determining whether non-volatile cache is supported. This
9717 * determination process works as follows:
9718 *
9719 * 1. sd first queries sd.conf on whether
9720 * suppress_cache_flush bit is set for this device.
9721 *
9722 * 2. if not there, then queries the internal disk table.
9723 *
9724 * 3. if either sd.conf or internal disk table specifies
9725 * cache flush be suppressed, we don't bother checking
9726 * NV_SUP bit.
9727 *
9728 * If SUPPRESS_CACHE_FLUSH bit is not set to 1, sd queries
9729 * the optional INQUIRY VPD page 0x86. If the device
9730 * supports VPD page 0x86, sd examines the NV_SUP
9731 * (non-volatile cache support) bit in the INQUIRY VPD page
9732 * 0x86:
9733 * o If NV_SUP bit is set, sd assumes the device has a
9734 * non-volatile cache and set the
9735 * un_f_sync_nv_supported to TRUE.
9736 * o Otherwise cache is not non-volatile,
9737 * un_f_sync_nv_supported is set to FALSE.
9738 *
9739 * Arguments: un - driver soft state (unit) structure
9740 *
9741 * Return Code:
9742 *
9743 * Context: Kernel Thread
9744 */
9745
9746 static void
9747 sd_get_nv_sup(sd_ssc_t *ssc)
9748 {
9749 int rval = 0;
9750 uchar_t *inq86 = NULL;
9751 size_t inq86_len = MAX_INQUIRY_SIZE;
9752 size_t inq86_resid = 0;
9753 struct dk_callback *dkc;
9754 struct sd_lun *un;
9755
9756 ASSERT(ssc != NULL);
9757 un = ssc->ssc_un;
9758 ASSERT(un != NULL);
9759
9760 mutex_enter(SD_MUTEX(un));
9761
9762 /*
9763 * Be conservative on the device's support of
9764 * SYNC_NV bit: un_f_sync_nv_supported is
9765 * initialized to be false.
9766 */
9767 un->un_f_sync_nv_supported = FALSE;
9768
9769 /*
9770 * If either sd.conf or internal disk table
9771 * specifies cache flush be suppressed, then
9772 * we don't bother checking NV_SUP bit.
9773 */
9774 if (un->un_f_suppress_cache_flush == TRUE) {
9775 mutex_exit(SD_MUTEX(un));
9776 return;
9777 }
9778
9779 if (sd_check_vpd_page_support(ssc) == 0 &&
9780 un->un_vpd_page_mask & SD_VPD_EXTENDED_DATA_PG) {
9781 mutex_exit(SD_MUTEX(un));
9782 /* collect page 86 data if available */
9783 inq86 = kmem_zalloc(inq86_len, KM_SLEEP);
9784
9785 rval = sd_send_scsi_INQUIRY(ssc, inq86, inq86_len,
9786 0x01, 0x86, &inq86_resid);
9787
9788 if (rval == 0 && (inq86_len - inq86_resid > 6)) {
9789 SD_TRACE(SD_LOG_COMMON, un,
9790 "sd_get_nv_sup: \
9791 successfully get VPD page: %x \
9792 PAGE LENGTH: %x BYTE 6: %x\n",
9793 inq86[1], inq86[3], inq86[6]);
9794
9795 mutex_enter(SD_MUTEX(un));
9796 /*
9797 * check the value of NV_SUP bit: only if the device
9798 * reports NV_SUP bit to be 1, the
9799 * un_f_sync_nv_supported bit will be set to true.
9800 */
9801 if (inq86[6] & SD_VPD_NV_SUP) {
9802 un->un_f_sync_nv_supported = TRUE;
9803 }
9804 mutex_exit(SD_MUTEX(un));
9805 } else if (rval != 0) {
9806 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
9807 }
9808
9809 kmem_free(inq86, inq86_len);
9810 } else {
9811 mutex_exit(SD_MUTEX(un));
9812 }
9813
9814 /*
9815 * Send a SYNC CACHE command to check whether
9816 * SYNC_NV bit is supported. This command should have
9817 * un_f_sync_nv_supported set to correct value.
9818 */
9819 mutex_enter(SD_MUTEX(un));
9820 if (un->un_f_sync_nv_supported) {
9821 mutex_exit(SD_MUTEX(un));
9822 dkc = kmem_zalloc(sizeof (struct dk_callback), KM_SLEEP);
9823 dkc->dkc_flag = FLUSH_VOLATILE;
9824 (void) sd_send_scsi_SYNCHRONIZE_CACHE(un, dkc);
9825
9826 /*
9827 * Send a TEST UNIT READY command to the device. This should
9828 * clear any outstanding UNIT ATTENTION that may be present.
9829 */
9830 rval = sd_send_scsi_TEST_UNIT_READY(ssc, SD_DONT_RETRY_TUR);
9831 if (rval != 0)
9832 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
9833
9834 kmem_free(dkc, sizeof (struct dk_callback));
9835 } else {
9836 mutex_exit(SD_MUTEX(un));
9837 }
9838
9839 SD_TRACE(SD_LOG_COMMON, un, "sd_get_nv_sup: \
9840 un_f_suppress_cache_flush is set to %d\n",
9841 un->un_f_suppress_cache_flush);
9842 }
9843
9844 /*
9845 * Function: sd_make_device
9846 *
9847 * Description: Utility routine to return the Solaris device number from
9848 * the data in the device's dev_info structure.
9849 *
9850 * Return Code: The Solaris device number
9851 *
9852 * Context: Any
9853 */
9854
9855 static dev_t
9856 sd_make_device(dev_info_t *devi)
9857 {
9858 return (makedevice(ddi_driver_major(devi),
9859 ddi_get_instance(devi) << SDUNIT_SHIFT));
9860 }
9861
9862
9863 /*
9864 * Function: sd_pm_entry
9865 *
9866 * Description: Called at the start of a new command to manage power
9867 * and busy status of a device. This includes determining whether
9868 * the current power state of the device is sufficient for
9869 * performing the command or whether it must be changed.
9870 * The PM framework is notified appropriately.
9871 * Only with a return status of DDI_SUCCESS will the
9872 * component be busy to the framework.
9873 *
9874 * All callers of sd_pm_entry must check the return status
9875 * and only call sd_pm_exit it it was DDI_SUCCESS. A status
9876 * of DDI_FAILURE indicates the device failed to power up.
9877 * In this case un_pm_count has been adjusted so the result
9878 * on exit is still powered down, ie. count is less than 0.
9879 * Calling sd_pm_exit with this count value hits an ASSERT.
9880 *
9881 * Return Code: DDI_SUCCESS or DDI_FAILURE
9882 *
9883 * Context: Kernel thread context.
9884 */
9885
9886 static int
9887 sd_pm_entry(struct sd_lun *un)
9888 {
9889 int return_status = DDI_SUCCESS;
9890
9891 ASSERT(!mutex_owned(SD_MUTEX(un)));
9892 ASSERT(!mutex_owned(&un->un_pm_mutex));
9893
9894 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_entry: entry\n");
9895
9896 if (un->un_f_pm_is_enabled == FALSE) {
9897 SD_TRACE(SD_LOG_IO_PM, un,
9898 "sd_pm_entry: exiting, PM not enabled\n");
9899 return (return_status);
9900 }
9901
9902 /*
9903 * Just increment a counter if PM is enabled. On the transition from
9904 * 0 ==> 1, mark the device as busy. The iodone side will decrement
9905 * the count with each IO and mark the device as idle when the count
9906 * hits 0.
9907 *
9908 * If the count is less than 0 the device is powered down. If a powered
9909 * down device is successfully powered up then the count must be
9910 * incremented to reflect the power up. Note that it'll get incremented
9911 * a second time to become busy.
9912 *
9913 * Because the following has the potential to change the device state
9914 * and must release the un_pm_mutex to do so, only one thread can be
9915 * allowed through at a time.
9916 */
9917
9918 mutex_enter(&un->un_pm_mutex);
9919 while (un->un_pm_busy == TRUE) {
9920 cv_wait(&un->un_pm_busy_cv, &un->un_pm_mutex);
9921 }
9922 un->un_pm_busy = TRUE;
9923
9924 if (un->un_pm_count < 1) {
9925
9926 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_entry: busy component\n");
9927
9928 /*
9929 * Indicate we are now busy so the framework won't attempt to
9930 * power down the device. This call will only fail if either
9931 * we passed a bad component number or the device has no
9932 * components. Neither of these should ever happen.
9933 */
9934 mutex_exit(&un->un_pm_mutex);
9935 return_status = pm_busy_component(SD_DEVINFO(un), 0);
9936 ASSERT(return_status == DDI_SUCCESS);
9937
9938 mutex_enter(&un->un_pm_mutex);
9939
9940 if (un->un_pm_count < 0) {
9941 mutex_exit(&un->un_pm_mutex);
9942
9943 SD_TRACE(SD_LOG_IO_PM, un,
9944 "sd_pm_entry: power up component\n");
9945
9946 /*
9947 * pm_raise_power will cause sdpower to be called
9948 * which brings the device power level to the
9949 * desired state, If successful, un_pm_count and
9950 * un_power_level will be updated appropriately.
9951 */
9952 return_status = pm_raise_power(SD_DEVINFO(un), 0,
9953 SD_PM_STATE_ACTIVE(un));
9954
9955 mutex_enter(&un->un_pm_mutex);
9956
9957 if (return_status != DDI_SUCCESS) {
9958 /*
9959 * Power up failed.
9960 * Idle the device and adjust the count
9961 * so the result on exit is that we're
9962 * still powered down, ie. count is less than 0.
9963 */
9964 SD_TRACE(SD_LOG_IO_PM, un,
9965 "sd_pm_entry: power up failed,"
9966 " idle the component\n");
9967
9968 (void) pm_idle_component(SD_DEVINFO(un), 0);
9969 un->un_pm_count--;
9970 } else {
9971 /*
9972 * Device is powered up, verify the
9973 * count is non-negative.
9974 * This is debug only.
9975 */
9976 ASSERT(un->un_pm_count == 0);
9977 }
9978 }
9979
9980 if (return_status == DDI_SUCCESS) {
9981 /*
9982 * For performance, now that the device has been tagged
9983 * as busy, and it's known to be powered up, update the
9984 * chain types to use jump tables that do not include
9985 * pm. This significantly lowers the overhead and
9986 * therefore improves performance.
9987 */
9988
9989 mutex_exit(&un->un_pm_mutex);
9990 mutex_enter(SD_MUTEX(un));
9991 SD_TRACE(SD_LOG_IO_PM, un,
9992 "sd_pm_entry: changing uscsi_chain_type from %d\n",
9993 un->un_uscsi_chain_type);
9994
9995 if (un->un_f_non_devbsize_supported) {
9996 un->un_buf_chain_type =
9997 SD_CHAIN_INFO_RMMEDIA_NO_PM;
9998 } else {
9999 un->un_buf_chain_type =
10000 SD_CHAIN_INFO_DISK_NO_PM;
10001 }
10002 un->un_uscsi_chain_type = SD_CHAIN_INFO_USCSI_CMD_NO_PM;
10003
10004 SD_TRACE(SD_LOG_IO_PM, un,
10005 " changed uscsi_chain_type to %d\n",
10006 un->un_uscsi_chain_type);
10007 mutex_exit(SD_MUTEX(un));
10008 mutex_enter(&un->un_pm_mutex);
10009
10010 if (un->un_pm_idle_timeid == NULL) {
10011 /* 300 ms. */
10012 un->un_pm_idle_timeid =
10013 timeout(sd_pm_idletimeout_handler, un,
10014 (drv_usectohz((clock_t)300000)));
10015 /*
10016 * Include an extra call to busy which keeps the
10017 * device busy with-respect-to the PM layer
10018 * until the timer fires, at which time it'll
10019 * get the extra idle call.
10020 */
10021 (void) pm_busy_component(SD_DEVINFO(un), 0);
10022 }
10023 }
10024 }
10025 un->un_pm_busy = FALSE;
10026 /* Next... */
10027 cv_signal(&un->un_pm_busy_cv);
10028
10029 un->un_pm_count++;
10030
10031 SD_TRACE(SD_LOG_IO_PM, un,
10032 "sd_pm_entry: exiting, un_pm_count = %d\n", un->un_pm_count);
10033
10034 mutex_exit(&un->un_pm_mutex);
10035
10036 return (return_status);
10037 }
10038
10039
10040 /*
10041 * Function: sd_pm_exit
10042 *
10043 * Description: Called at the completion of a command to manage busy
10044 * status for the device. If the device becomes idle the
10045 * PM framework is notified.
10046 *
10047 * Context: Kernel thread context
10048 */
10049
10050 static void
10051 sd_pm_exit(struct sd_lun *un)
10052 {
10053 ASSERT(!mutex_owned(SD_MUTEX(un)));
10054 ASSERT(!mutex_owned(&un->un_pm_mutex));
10055
10056 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_exit: entry\n");
10057
10058 /*
10059 * After attach the following flag is only read, so don't
10060 * take the penalty of acquiring a mutex for it.
10061 */
10062 if (un->un_f_pm_is_enabled == TRUE) {
10063
10064 mutex_enter(&un->un_pm_mutex);
10065 un->un_pm_count--;
10066
10067 SD_TRACE(SD_LOG_IO_PM, un,
10068 "sd_pm_exit: un_pm_count = %d\n", un->un_pm_count);
10069
10070 ASSERT(un->un_pm_count >= 0);
10071 if (un->un_pm_count == 0) {
10072 mutex_exit(&un->un_pm_mutex);
10073
10074 SD_TRACE(SD_LOG_IO_PM, un,
10075 "sd_pm_exit: idle component\n");
10076
10077 (void) pm_idle_component(SD_DEVINFO(un), 0);
10078
10079 } else {
10080 mutex_exit(&un->un_pm_mutex);
10081 }
10082 }
10083
10084 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_exit: exiting\n");
10085 }
10086
10087
10088 /*
10089 * Function: sdopen
10090 *
10091 * Description: Driver's open(9e) entry point function.
10092 *
10093 * Arguments: dev_i - pointer to device number
10094 * flag - how to open file (FEXCL, FNDELAY, FREAD, FWRITE)
10095 * otyp - open type (OTYP_BLK, OTYP_CHR, OTYP_LYR)
10096 * cred_p - user credential pointer
10097 *
10098 * Return Code: EINVAL
10099 * ENXIO
10100 * EIO
10101 * EROFS
10102 * EBUSY
10103 *
10104 * Context: Kernel thread context
10105 */
10106 /* ARGSUSED */
10107 static int
10108 sdopen(dev_t *dev_p, int flag, int otyp, cred_t *cred_p)
10109 {
10110 struct sd_lun *un;
10111 int nodelay;
10112 int part;
10113 uint64_t partmask;
10114 int instance;
10115 dev_t dev;
10116 int rval = EIO;
10117 diskaddr_t nblks = 0;
10118 diskaddr_t label_cap;
10119
10120 /* Validate the open type */
10121 if (otyp >= OTYPCNT) {
10122 return (EINVAL);
10123 }
10124
10125 dev = *dev_p;
10126 instance = SDUNIT(dev);
10127 mutex_enter(&sd_detach_mutex);
10128
10129 /*
10130 * Fail the open if there is no softstate for the instance, or
10131 * if another thread somewhere is trying to detach the instance.
10132 */
10133 if (((un = ddi_get_soft_state(sd_state, instance)) == NULL) ||
10134 (un->un_detach_count != 0)) {
10135 mutex_exit(&sd_detach_mutex);
10136 /*
10137 * The probe cache only needs to be cleared when open (9e) fails
10138 * with ENXIO (4238046).
10139 */
10140 /*
10141 * un-conditionally clearing probe cache is ok with
10142 * separate sd/ssd binaries
10143 * x86 platform can be an issue with both parallel
10144 * and fibre in 1 binary
10145 */
10146 sd_scsi_clear_probe_cache();
10147 return (ENXIO);
10148 }
10149
10150 /*
10151 * The un_layer_count is to prevent another thread in specfs from
10152 * trying to detach the instance, which can happen when we are
10153 * called from a higher-layer driver instead of thru specfs.
10154 * This will not be needed when DDI provides a layered driver
10155 * interface that allows specfs to know that an instance is in
10156 * use by a layered driver & should not be detached.
10157 *
10158 * Note: the semantics for layered driver opens are exactly one
10159 * close for every open.
10160 */
10161 if (otyp == OTYP_LYR) {
10162 un->un_layer_count++;
10163 }
10164
10165 /*
10166 * Keep a count of the current # of opens in progress. This is because
10167 * some layered drivers try to call us as a regular open. This can
10168 * cause problems that we cannot prevent, however by keeping this count
10169 * we can at least keep our open and detach routines from racing against
10170 * each other under such conditions.
10171 */
10172 un->un_opens_in_progress++;
10173 mutex_exit(&sd_detach_mutex);
10174
10175 nodelay = (flag & (FNDELAY | FNONBLOCK));
10176 part = SDPART(dev);
10177 partmask = 1 << part;
10178
10179 /*
10180 * We use a semaphore here in order to serialize
10181 * open and close requests on the device.
10182 */
10183 sema_p(&un->un_semoclose);
10184
10185 mutex_enter(SD_MUTEX(un));
10186
10187 /*
10188 * All device accesses go thru sdstrategy() where we check
10189 * on suspend status but there could be a scsi_poll command,
10190 * which bypasses sdstrategy(), so we need to check pm
10191 * status.
10192 */
10193
10194 if (!nodelay) {
10195 while ((un->un_state == SD_STATE_SUSPENDED) ||
10196 (un->un_state == SD_STATE_PM_CHANGING)) {
10197 cv_wait(&un->un_suspend_cv, SD_MUTEX(un));
10198 }
10199
10200 mutex_exit(SD_MUTEX(un));
10201 if (sd_pm_entry(un) != DDI_SUCCESS) {
10202 rval = EIO;
10203 SD_ERROR(SD_LOG_OPEN_CLOSE, un,
10204 "sdopen: sd_pm_entry failed\n");
10205 goto open_failed_with_pm;
10206 }
10207 mutex_enter(SD_MUTEX(un));
10208 }
10209
10210 /* check for previous exclusive open */
10211 SD_TRACE(SD_LOG_OPEN_CLOSE, un, "sdopen: un=%p\n", (void *)un);
10212 SD_TRACE(SD_LOG_OPEN_CLOSE, un,
10213 "sdopen: exclopen=%x, flag=%x, regopen=%x\n",
10214 un->un_exclopen, flag, un->un_ocmap.regopen[otyp]);
10215
10216 if (un->un_exclopen & (partmask)) {
10217 goto excl_open_fail;
10218 }
10219
10220 if (flag & FEXCL) {
10221 int i;
10222 if (un->un_ocmap.lyropen[part]) {
10223 goto excl_open_fail;
10224 }
10225 for (i = 0; i < (OTYPCNT - 1); i++) {
10226 if (un->un_ocmap.regopen[i] & (partmask)) {
10227 goto excl_open_fail;
10228 }
10229 }
10230 }
10231
10232 /*
10233 * Check the write permission if this is a removable media device,
10234 * NDELAY has not been set, and writable permission is requested.
10235 *
10236 * Note: If NDELAY was set and this is write-protected media the WRITE
10237 * attempt will fail with EIO as part of the I/O processing. This is a
10238 * more permissive implementation that allows the open to succeed and
10239 * WRITE attempts to fail when appropriate.
10240 */
10241 if (un->un_f_chk_wp_open) {
10242 if ((flag & FWRITE) && (!nodelay)) {
10243 mutex_exit(SD_MUTEX(un));
10244 /*
10245 * Defer the check for write permission on writable
10246 * DVD drive till sdstrategy and will not fail open even
10247 * if FWRITE is set as the device can be writable
10248 * depending upon the media and the media can change
10249 * after the call to open().
10250 */
10251 if (un->un_f_dvdram_writable_device == FALSE) {
10252 if (ISCD(un) || sr_check_wp(dev)) {
10253 rval = EROFS;
10254 mutex_enter(SD_MUTEX(un));
10255 SD_ERROR(SD_LOG_OPEN_CLOSE, un, "sdopen: "
10256 "write to cd or write protected media\n");
10257 goto open_fail;
10258 }
10259 }
10260 mutex_enter(SD_MUTEX(un));
10261 }
10262 }
10263
10264 /*
10265 * If opening in NDELAY/NONBLOCK mode, just return.
10266 * Check if disk is ready and has a valid geometry later.
10267 */
10268 if (!nodelay) {
10269 sd_ssc_t *ssc;
10270
10271 mutex_exit(SD_MUTEX(un));
10272 ssc = sd_ssc_init(un);
10273 rval = sd_ready_and_valid(ssc, part);
10274 sd_ssc_fini(ssc);
10275 mutex_enter(SD_MUTEX(un));
10276 /*
10277 * Fail if device is not ready or if the number of disk
10278 * blocks is zero or negative for non CD devices.
10279 */
10280
10281 nblks = 0;
10282
10283 if (rval == SD_READY_VALID && (!ISCD(un))) {
10284 /* if cmlb_partinfo fails, nblks remains 0 */
10285 mutex_exit(SD_MUTEX(un));
10286 (void) cmlb_partinfo(un->un_cmlbhandle, part, &nblks,
10287 NULL, NULL, NULL, (void *)SD_PATH_DIRECT);
10288 mutex_enter(SD_MUTEX(un));
10289 }
10290
10291 if ((rval != SD_READY_VALID) ||
10292 (!ISCD(un) && nblks <= 0)) {
10293 rval = un->un_f_has_removable_media ? ENXIO : EIO;
10294 SD_ERROR(SD_LOG_OPEN_CLOSE, un, "sdopen: "
10295 "device not ready or invalid disk block value\n");
10296 goto open_fail;
10297 }
10298 #if defined(__i386) || defined(__amd64)
10299 } else {
10300 uchar_t *cp;
10301 /*
10302 * x86 requires special nodelay handling, so that p0 is
10303 * always defined and accessible.
10304 * Invalidate geometry only if device is not already open.
10305 */
10306 cp = &un->un_ocmap.chkd[0];
10307 while (cp < &un->un_ocmap.chkd[OCSIZE]) {
10308 if (*cp != (uchar_t)0) {
10309 break;
10310 }
10311 cp++;
10312 }
10313 if (cp == &un->un_ocmap.chkd[OCSIZE]) {
10314 mutex_exit(SD_MUTEX(un));
10315 cmlb_invalidate(un->un_cmlbhandle,
10316 (void *)SD_PATH_DIRECT);
10317 mutex_enter(SD_MUTEX(un));
10318 }
10319
10320 #endif
10321 }
10322
10323 if (otyp == OTYP_LYR) {
10324 un->un_ocmap.lyropen[part]++;
10325 } else {
10326 un->un_ocmap.regopen[otyp] |= partmask;
10327 }
10328
10329 /* Set up open and exclusive open flags */
10330 if (flag & FEXCL) {
10331 un->un_exclopen |= (partmask);
10332 }
10333
10334 /*
10335 * If the lun is EFI labeled and lun capacity is greater than the
10336 * capacity contained in the label, log a sys-event to notify the
10337 * interested module.
10338 * To avoid an infinite loop of logging sys-event, we only log the
10339 * event when the lun is not opened in NDELAY mode. The event handler
10340 * should open the lun in NDELAY mode.
10341 */
10342 if (!nodelay) {
10343 mutex_exit(SD_MUTEX(un));
10344 if (cmlb_efi_label_capacity(un->un_cmlbhandle, &label_cap,
10345 (void*)SD_PATH_DIRECT) == 0) {
10346 mutex_enter(SD_MUTEX(un));
10347 if (un->un_f_blockcount_is_valid &&
10348 un->un_blockcount > label_cap &&
10349 un->un_f_expnevent == B_FALSE) {
10350 un->un_f_expnevent = B_TRUE;
10351 mutex_exit(SD_MUTEX(un));
10352 sd_log_lun_expansion_event(un,
10353 (nodelay ? KM_NOSLEEP : KM_SLEEP));
10354 mutex_enter(SD_MUTEX(un));
10355 }
10356 } else {
10357 mutex_enter(SD_MUTEX(un));
10358 }
10359 }
10360
10361 SD_TRACE(SD_LOG_OPEN_CLOSE, un, "sdopen: "
10362 "open of part %d type %d\n", part, otyp);
10363
10364 mutex_exit(SD_MUTEX(un));
10365 if (!nodelay) {
10366 sd_pm_exit(un);
10367 }
10368
10369 sema_v(&un->un_semoclose);
10370
10371 mutex_enter(&sd_detach_mutex);
10372 un->un_opens_in_progress--;
10373 mutex_exit(&sd_detach_mutex);
10374
10375 SD_TRACE(SD_LOG_OPEN_CLOSE, un, "sdopen: exit success\n");
10376 return (DDI_SUCCESS);
10377
10378 excl_open_fail:
10379 SD_ERROR(SD_LOG_OPEN_CLOSE, un, "sdopen: fail exclusive open\n");
10380 rval = EBUSY;
10381
10382 open_fail:
10383 mutex_exit(SD_MUTEX(un));
10384
10385 /*
10386 * On a failed open we must exit the pm management.
10387 */
10388 if (!nodelay) {
10389 sd_pm_exit(un);
10390 }
10391 open_failed_with_pm:
10392 sema_v(&un->un_semoclose);
10393
10394 mutex_enter(&sd_detach_mutex);
10395 un->un_opens_in_progress--;
10396 if (otyp == OTYP_LYR) {
10397 un->un_layer_count--;
10398 }
10399 mutex_exit(&sd_detach_mutex);
10400
10401 return (rval);
10402 }
10403
10404
10405 /*
10406 * Function: sdclose
10407 *
10408 * Description: Driver's close(9e) entry point function.
10409 *
10410 * Arguments: dev - device number
10411 * flag - file status flag, informational only
10412 * otyp - close type (OTYP_BLK, OTYP_CHR, OTYP_LYR)
10413 * cred_p - user credential pointer
10414 *
10415 * Return Code: ENXIO
10416 *
10417 * Context: Kernel thread context
10418 */
10419 /* ARGSUSED */
10420 static int
10421 sdclose(dev_t dev, int flag, int otyp, cred_t *cred_p)
10422 {
10423 struct sd_lun *un;
10424 uchar_t *cp;
10425 int part;
10426 int nodelay;
10427 int rval = 0;
10428
10429 /* Validate the open type */
10430 if (otyp >= OTYPCNT) {
10431 return (ENXIO);
10432 }
10433
10434 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
10435 return (ENXIO);
10436 }
10437
10438 part = SDPART(dev);
10439 nodelay = flag & (FNDELAY | FNONBLOCK);
10440
10441 SD_TRACE(SD_LOG_OPEN_CLOSE, un,
10442 "sdclose: close of part %d type %d\n", part, otyp);
10443
10444 /*
10445 * We use a semaphore here in order to serialize
10446 * open and close requests on the device.
10447 */
10448 sema_p(&un->un_semoclose);
10449
10450 mutex_enter(SD_MUTEX(un));
10451
10452 /* Don't proceed if power is being changed. */
10453 while (un->un_state == SD_STATE_PM_CHANGING) {
10454 cv_wait(&un->un_suspend_cv, SD_MUTEX(un));
10455 }
10456
10457 if (un->un_exclopen & (1 << part)) {
10458 un->un_exclopen &= ~(1 << part);
10459 }
10460
10461 /* Update the open partition map */
10462 if (otyp == OTYP_LYR) {
10463 un->un_ocmap.lyropen[part] -= 1;
10464 } else {
10465 un->un_ocmap.regopen[otyp] &= ~(1 << part);
10466 }
10467
10468 cp = &un->un_ocmap.chkd[0];
10469 while (cp < &un->un_ocmap.chkd[OCSIZE]) {
10470 if (*cp != NULL) {
10471 break;
10472 }
10473 cp++;
10474 }
10475
10476 if (cp == &un->un_ocmap.chkd[OCSIZE]) {
10477 SD_TRACE(SD_LOG_OPEN_CLOSE, un, "sdclose: last close\n");
10478
10479 /*
10480 * We avoid persistance upon the last close, and set
10481 * the throttle back to the maximum.
10482 */
10483 un->un_throttle = un->un_saved_throttle;
10484
10485 if (un->un_state == SD_STATE_OFFLINE) {
10486 if (un->un_f_is_fibre == FALSE) {
10487 scsi_log(SD_DEVINFO(un), sd_label,
10488 CE_WARN, "offline\n");
10489 }
10490 mutex_exit(SD_MUTEX(un));
10491 cmlb_invalidate(un->un_cmlbhandle,
10492 (void *)SD_PATH_DIRECT);
10493 mutex_enter(SD_MUTEX(un));
10494
10495 } else {
10496 /*
10497 * Flush any outstanding writes in NVRAM cache.
10498 * Note: SYNCHRONIZE CACHE is an optional SCSI-2
10499 * cmd, it may not work for non-Pluto devices.
10500 * SYNCHRONIZE CACHE is not required for removables,
10501 * except DVD-RAM drives.
10502 *
10503 * Also note: because SYNCHRONIZE CACHE is currently
10504 * the only command issued here that requires the
10505 * drive be powered up, only do the power up before
10506 * sending the Sync Cache command. If additional
10507 * commands are added which require a powered up
10508 * drive, the following sequence may have to change.
10509 *
10510 * And finally, note that parallel SCSI on SPARC
10511 * only issues a Sync Cache to DVD-RAM, a newly
10512 * supported device.
10513 */
10514 #if defined(__i386) || defined(__amd64)
10515 if ((un->un_f_sync_cache_supported &&
10516 un->un_f_sync_cache_required) ||
10517 un->un_f_dvdram_writable_device == TRUE) {
10518 #else
10519 if (un->un_f_dvdram_writable_device == TRUE) {
10520 #endif
10521 mutex_exit(SD_MUTEX(un));
10522 if (sd_pm_entry(un) == DDI_SUCCESS) {
10523 rval =
10524 sd_send_scsi_SYNCHRONIZE_CACHE(un,
10525 NULL);
10526 /* ignore error if not supported */
10527 if (rval == ENOTSUP) {
10528 rval = 0;
10529 } else if (rval != 0) {
10530 rval = EIO;
10531 }
10532 sd_pm_exit(un);
10533 } else {
10534 rval = EIO;
10535 }
10536 mutex_enter(SD_MUTEX(un));
10537 }
10538
10539 /*
10540 * For devices which supports DOOR_LOCK, send an ALLOW
10541 * MEDIA REMOVAL command, but don't get upset if it
10542 * fails. We need to raise the power of the drive before
10543 * we can call sd_send_scsi_DOORLOCK()
10544 */
10545 if (un->un_f_doorlock_supported) {
10546 mutex_exit(SD_MUTEX(un));
10547 if (sd_pm_entry(un) == DDI_SUCCESS) {
10548 sd_ssc_t *ssc;
10549
10550 ssc = sd_ssc_init(un);
10551 rval = sd_send_scsi_DOORLOCK(ssc,
10552 SD_REMOVAL_ALLOW, SD_PATH_DIRECT);
10553 if (rval != 0)
10554 sd_ssc_assessment(ssc,
10555 SD_FMT_IGNORE);
10556 sd_ssc_fini(ssc);
10557
10558 sd_pm_exit(un);
10559 if (ISCD(un) && (rval != 0) &&
10560 (nodelay != 0)) {
10561 rval = ENXIO;
10562 }
10563 } else {
10564 rval = EIO;
10565 }
10566 mutex_enter(SD_MUTEX(un));
10567 }
10568
10569 /*
10570 * If a device has removable media, invalidate all
10571 * parameters related to media, such as geometry,
10572 * blocksize, and blockcount.
10573 */
10574 if (un->un_f_has_removable_media) {
10575 sr_ejected(un);
10576 }
10577
10578 /*
10579 * Destroy the cache (if it exists) which was
10580 * allocated for the write maps since this is
10581 * the last close for this media.
10582 */
10583 if (un->un_wm_cache) {
10584 /*
10585 * Check if there are pending commands.
10586 * and if there are give a warning and
10587 * do not destroy the cache.
10588 */
10589 if (un->un_ncmds_in_driver > 0) {
10590 scsi_log(SD_DEVINFO(un),
10591 sd_label, CE_WARN,
10592 "Unable to clean up memory "
10593 "because of pending I/O\n");
10594 } else {
10595 kmem_cache_destroy(
10596 un->un_wm_cache);
10597 un->un_wm_cache = NULL;
10598 }
10599 }
10600 }
10601 }
10602
10603 mutex_exit(SD_MUTEX(un));
10604 sema_v(&un->un_semoclose);
10605
10606 if (otyp == OTYP_LYR) {
10607 mutex_enter(&sd_detach_mutex);
10608 /*
10609 * The detach routine may run when the layer count
10610 * drops to zero.
10611 */
10612 un->un_layer_count--;
10613 mutex_exit(&sd_detach_mutex);
10614 }
10615
10616 return (rval);
10617 }
10618
10619
10620 /*
10621 * Function: sd_ready_and_valid
10622 *
10623 * Description: Test if device is ready and has a valid geometry.
10624 *
10625 * Arguments: ssc - sd_ssc_t will contain un
10626 * un - driver soft state (unit) structure
10627 *
10628 * Return Code: SD_READY_VALID ready and valid label
10629 * SD_NOT_READY_VALID not ready, no label
10630 * SD_RESERVED_BY_OTHERS reservation conflict
10631 *
10632 * Context: Never called at interrupt context.
10633 */
10634
10635 static int
10636 sd_ready_and_valid(sd_ssc_t *ssc, int part)
10637 {
10638 struct sd_errstats *stp;
10639 uint64_t capacity;
10640 uint_t lbasize;
10641 int rval = SD_READY_VALID;
10642 char name_str[48];
10643 boolean_t is_valid;
10644 struct sd_lun *un;
10645 int status;
10646
10647 ASSERT(ssc != NULL);
10648 un = ssc->ssc_un;
10649 ASSERT(un != NULL);
10650 ASSERT(!mutex_owned(SD_MUTEX(un)));
10651
10652 mutex_enter(SD_MUTEX(un));
10653 /*
10654 * If a device has removable media, we must check if media is
10655 * ready when checking if this device is ready and valid.
10656 */
10657 if (un->un_f_has_removable_media) {
10658 mutex_exit(SD_MUTEX(un));
10659 status = sd_send_scsi_TEST_UNIT_READY(ssc, 0);
10660
10661 if (status != 0) {
10662 rval = SD_NOT_READY_VALID;
10663 mutex_enter(SD_MUTEX(un));
10664
10665 /* Ignore all failed status for removalbe media */
10666 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
10667
10668 goto done;
10669 }
10670
10671 is_valid = SD_IS_VALID_LABEL(un);
10672 mutex_enter(SD_MUTEX(un));
10673 if (!is_valid ||
10674 (un->un_f_blockcount_is_valid == FALSE) ||
10675 (un->un_f_tgt_blocksize_is_valid == FALSE)) {
10676
10677 /* capacity has to be read every open. */
10678 mutex_exit(SD_MUTEX(un));
10679 status = sd_send_scsi_READ_CAPACITY(ssc, &capacity,
10680 &lbasize, SD_PATH_DIRECT);
10681
10682 if (status != 0) {
10683 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
10684
10685 cmlb_invalidate(un->un_cmlbhandle,
10686 (void *)SD_PATH_DIRECT);
10687 mutex_enter(SD_MUTEX(un));
10688 rval = SD_NOT_READY_VALID;
10689
10690 goto done;
10691 } else {
10692 mutex_enter(SD_MUTEX(un));
10693 sd_update_block_info(un, lbasize, capacity);
10694 }
10695 }
10696
10697 /*
10698 * Check if the media in the device is writable or not.
10699 */
10700 if (!is_valid && ISCD(un)) {
10701 sd_check_for_writable_cd(ssc, SD_PATH_DIRECT);
10702 }
10703
10704 } else {
10705 /*
10706 * Do a test unit ready to clear any unit attention from non-cd
10707 * devices.
10708 */
10709 mutex_exit(SD_MUTEX(un));
10710
10711 status = sd_send_scsi_TEST_UNIT_READY(ssc, 0);
10712 if (status != 0) {
10713 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
10714 }
10715
10716 mutex_enter(SD_MUTEX(un));
10717 }
10718
10719
10720 /*
10721 * If this is a non 512 block device, allocate space for
10722 * the wmap cache. This is being done here since every time
10723 * a media is changed this routine will be called and the
10724 * block size is a function of media rather than device.
10725 */
10726 if (((un->un_f_rmw_type != SD_RMW_TYPE_RETURN_ERROR ||
10727 un->un_f_non_devbsize_supported) &&
10728 un->un_tgt_blocksize != DEV_BSIZE) ||
10729 un->un_f_enable_rmw) {
10730 if (!(un->un_wm_cache)) {
10731 (void) snprintf(name_str, sizeof (name_str),
10732 "%s%d_cache",
10733 ddi_driver_name(SD_DEVINFO(un)),
10734 ddi_get_instance(SD_DEVINFO(un)));
10735 un->un_wm_cache = kmem_cache_create(
10736 name_str, sizeof (struct sd_w_map),
10737 8, sd_wm_cache_constructor,
10738 sd_wm_cache_destructor, NULL,
10739 (void *)un, NULL, 0);
10740 if (!(un->un_wm_cache)) {
10741 rval = ENOMEM;
10742 goto done;
10743 }
10744 }
10745 }
10746
10747 if (un->un_state == SD_STATE_NORMAL) {
10748 /*
10749 * If the target is not yet ready here (defined by a TUR
10750 * failure), invalidate the geometry and print an 'offline'
10751 * message. This is a legacy message, as the state of the
10752 * target is not actually changed to SD_STATE_OFFLINE.
10753 *
10754 * If the TUR fails for EACCES (Reservation Conflict),
10755 * SD_RESERVED_BY_OTHERS will be returned to indicate
10756 * reservation conflict. If the TUR fails for other
10757 * reasons, SD_NOT_READY_VALID will be returned.
10758 */
10759 int err;
10760
10761 mutex_exit(SD_MUTEX(un));
10762 err = sd_send_scsi_TEST_UNIT_READY(ssc, 0);
10763 mutex_enter(SD_MUTEX(un));
10764
10765 if (err != 0) {
10766 mutex_exit(SD_MUTEX(un));
10767 cmlb_invalidate(un->un_cmlbhandle,
10768 (void *)SD_PATH_DIRECT);
10769 mutex_enter(SD_MUTEX(un));
10770 if (err == EACCES) {
10771 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
10772 "reservation conflict\n");
10773 rval = SD_RESERVED_BY_OTHERS;
10774 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
10775 } else {
10776 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
10777 "drive offline\n");
10778 rval = SD_NOT_READY_VALID;
10779 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
10780 }
10781 goto done;
10782 }
10783 }
10784
10785 if (un->un_f_format_in_progress == FALSE) {
10786 mutex_exit(SD_MUTEX(un));
10787
10788 (void) cmlb_validate(un->un_cmlbhandle, 0,
10789 (void *)SD_PATH_DIRECT);
10790 if (cmlb_partinfo(un->un_cmlbhandle, part, NULL, NULL, NULL,
10791 NULL, (void *) SD_PATH_DIRECT) != 0) {
10792 rval = SD_NOT_READY_VALID;
10793 mutex_enter(SD_MUTEX(un));
10794
10795 goto done;
10796 }
10797 if (un->un_f_pkstats_enabled) {
10798 sd_set_pstats(un);
10799 SD_TRACE(SD_LOG_IO_PARTITION, un,
10800 "sd_ready_and_valid: un:0x%p pstats created and "
10801 "set\n", un);
10802 }
10803 mutex_enter(SD_MUTEX(un));
10804 }
10805
10806 /*
10807 * If this device supports DOOR_LOCK command, try and send
10808 * this command to PREVENT MEDIA REMOVAL, but don't get upset
10809 * if it fails. For a CD, however, it is an error
10810 */
10811 if (un->un_f_doorlock_supported) {
10812 mutex_exit(SD_MUTEX(un));
10813 status = sd_send_scsi_DOORLOCK(ssc, SD_REMOVAL_PREVENT,
10814 SD_PATH_DIRECT);
10815
10816 if ((status != 0) && ISCD(un)) {
10817 rval = SD_NOT_READY_VALID;
10818 mutex_enter(SD_MUTEX(un));
10819
10820 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
10821
10822 goto done;
10823 } else if (status != 0)
10824 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
10825 mutex_enter(SD_MUTEX(un));
10826 }
10827
10828 /* The state has changed, inform the media watch routines */
10829 un->un_mediastate = DKIO_INSERTED;
10830 cv_broadcast(&un->un_state_cv);
10831 rval = SD_READY_VALID;
10832
10833 done:
10834
10835 /*
10836 * Initialize the capacity kstat value, if no media previously
10837 * (capacity kstat is 0) and a media has been inserted
10838 * (un_blockcount > 0).
10839 */
10840 if (un->un_errstats != NULL) {
10841 stp = (struct sd_errstats *)un->un_errstats->ks_data;
10842 if ((stp->sd_capacity.value.ui64 == 0) &&
10843 (un->un_f_blockcount_is_valid == TRUE)) {
10844 stp->sd_capacity.value.ui64 =
10845 (uint64_t)((uint64_t)un->un_blockcount *
10846 un->un_sys_blocksize);
10847 }
10848 }
10849
10850 mutex_exit(SD_MUTEX(un));
10851 return (rval);
10852 }
10853
10854
10855 /*
10856 * Function: sdmin
10857 *
10858 * Description: Routine to limit the size of a data transfer. Used in
10859 * conjunction with physio(9F).
10860 *
10861 * Arguments: bp - pointer to the indicated buf(9S) struct.
10862 *
10863 * Context: Kernel thread context.
10864 */
10865
10866 static void
10867 sdmin(struct buf *bp)
10868 {
10869 struct sd_lun *un;
10870 int instance;
10871
10872 instance = SDUNIT(bp->b_edev);
10873
10874 un = ddi_get_soft_state(sd_state, instance);
10875 ASSERT(un != NULL);
10876
10877 /*
10878 * We depend on buf breakup to restrict
10879 * IO size if it is enabled.
10880 */
10881 if (un->un_buf_breakup_supported) {
10882 return;
10883 }
10884
10885 if (bp->b_bcount > un->un_max_xfer_size) {
10886 bp->b_bcount = un->un_max_xfer_size;
10887 }
10888 }
10889
10890
10891 /*
10892 * Function: sdread
10893 *
10894 * Description: Driver's read(9e) entry point function.
10895 *
10896 * Arguments: dev - device number
10897 * uio - structure pointer describing where data is to be stored
10898 * in user's space
10899 * cred_p - user credential pointer
10900 *
10901 * Return Code: ENXIO
10902 * EIO
10903 * EINVAL
10904 * value returned by physio
10905 *
10906 * Context: Kernel thread context.
10907 */
10908 /* ARGSUSED */
10909 static int
10910 sdread(dev_t dev, struct uio *uio, cred_t *cred_p)
10911 {
10912 struct sd_lun *un = NULL;
10913 int secmask;
10914 int err = 0;
10915 sd_ssc_t *ssc;
10916
10917 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
10918 return (ENXIO);
10919 }
10920
10921 ASSERT(!mutex_owned(SD_MUTEX(un)));
10922
10923
10924 if (!SD_IS_VALID_LABEL(un) && !ISCD(un)) {
10925 mutex_enter(SD_MUTEX(un));
10926 /*
10927 * Because the call to sd_ready_and_valid will issue I/O we
10928 * must wait here if either the device is suspended or
10929 * if it's power level is changing.
10930 */
10931 while ((un->un_state == SD_STATE_SUSPENDED) ||
10932 (un->un_state == SD_STATE_PM_CHANGING)) {
10933 cv_wait(&un->un_suspend_cv, SD_MUTEX(un));
10934 }
10935 un->un_ncmds_in_driver++;
10936 mutex_exit(SD_MUTEX(un));
10937
10938 /* Initialize sd_ssc_t for internal uscsi commands */
10939 ssc = sd_ssc_init(un);
10940 if ((sd_ready_and_valid(ssc, SDPART(dev))) != SD_READY_VALID) {
10941 err = EIO;
10942 } else {
10943 err = 0;
10944 }
10945 sd_ssc_fini(ssc);
10946
10947 mutex_enter(SD_MUTEX(un));
10948 un->un_ncmds_in_driver--;
10949 ASSERT(un->un_ncmds_in_driver >= 0);
10950 mutex_exit(SD_MUTEX(un));
10951 if (err != 0)
10952 return (err);
10953 }
10954
10955 /*
10956 * Read requests are restricted to multiples of the system block size.
10957 */
10958 if (un->un_f_rmw_type == SD_RMW_TYPE_RETURN_ERROR &&
10959 !un->un_f_enable_rmw)
10960 secmask = un->un_tgt_blocksize - 1;
10961 else
10962 secmask = DEV_BSIZE - 1;
10963
10964 if (uio->uio_loffset & ((offset_t)(secmask))) {
10965 SD_ERROR(SD_LOG_READ_WRITE, un,
10966 "sdread: file offset not modulo %d\n",
10967 secmask + 1);
10968 err = EINVAL;
10969 } else if (uio->uio_iov->iov_len & (secmask)) {
10970 SD_ERROR(SD_LOG_READ_WRITE, un,
10971 "sdread: transfer length not modulo %d\n",
10972 secmask + 1);
10973 err = EINVAL;
10974 } else {
10975 err = physio(sdstrategy, NULL, dev, B_READ, sdmin, uio);
10976 }
10977
10978 return (err);
10979 }
10980
10981
10982 /*
10983 * Function: sdwrite
10984 *
10985 * Description: Driver's write(9e) entry point function.
10986 *
10987 * Arguments: dev - device number
10988 * uio - structure pointer describing where data is stored in
10989 * user's space
10990 * cred_p - user credential pointer
10991 *
10992 * Return Code: ENXIO
10993 * EIO
10994 * EINVAL
10995 * value returned by physio
10996 *
10997 * Context: Kernel thread context.
10998 */
10999 /* ARGSUSED */
11000 static int
11001 sdwrite(dev_t dev, struct uio *uio, cred_t *cred_p)
11002 {
11003 struct sd_lun *un = NULL;
11004 int secmask;
11005 int err = 0;
11006 sd_ssc_t *ssc;
11007
11008 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
11009 return (ENXIO);
11010 }
11011
11012 ASSERT(!mutex_owned(SD_MUTEX(un)));
11013
11014 if (!SD_IS_VALID_LABEL(un) && !ISCD(un)) {
11015 mutex_enter(SD_MUTEX(un));
11016 /*
11017 * Because the call to sd_ready_and_valid will issue I/O we
11018 * must wait here if either the device is suspended or
11019 * if it's power level is changing.
11020 */
11021 while ((un->un_state == SD_STATE_SUSPENDED) ||
11022 (un->un_state == SD_STATE_PM_CHANGING)) {
11023 cv_wait(&un->un_suspend_cv, SD_MUTEX(un));
11024 }
11025 un->un_ncmds_in_driver++;
11026 mutex_exit(SD_MUTEX(un));
11027
11028 /* Initialize sd_ssc_t for internal uscsi commands */
11029 ssc = sd_ssc_init(un);
11030 if ((sd_ready_and_valid(ssc, SDPART(dev))) != SD_READY_VALID) {
11031 err = EIO;
11032 } else {
11033 err = 0;
11034 }
11035 sd_ssc_fini(ssc);
11036
11037 mutex_enter(SD_MUTEX(un));
11038 un->un_ncmds_in_driver--;
11039 ASSERT(un->un_ncmds_in_driver >= 0);
11040 mutex_exit(SD_MUTEX(un));
11041 if (err != 0)
11042 return (err);
11043 }
11044
11045 /*
11046 * Write requests are restricted to multiples of the system block size.
11047 */
11048 if (un->un_f_rmw_type == SD_RMW_TYPE_RETURN_ERROR &&
11049 !un->un_f_enable_rmw)
11050 secmask = un->un_tgt_blocksize - 1;
11051 else
11052 secmask = DEV_BSIZE - 1;
11053
11054 if (uio->uio_loffset & ((offset_t)(secmask))) {
11055 SD_ERROR(SD_LOG_READ_WRITE, un,
11056 "sdwrite: file offset not modulo %d\n",
11057 secmask + 1);
11058 err = EINVAL;
11059 } else if (uio->uio_iov->iov_len & (secmask)) {
11060 SD_ERROR(SD_LOG_READ_WRITE, un,
11061 "sdwrite: transfer length not modulo %d\n",
11062 secmask + 1);
11063 err = EINVAL;
11064 } else {
11065 err = physio(sdstrategy, NULL, dev, B_WRITE, sdmin, uio);
11066 }
11067
11068 return (err);
11069 }
11070
11071
11072 /*
11073 * Function: sdaread
11074 *
11075 * Description: Driver's aread(9e) entry point function.
11076 *
11077 * Arguments: dev - device number
11078 * aio - structure pointer describing where data is to be stored
11079 * cred_p - user credential pointer
11080 *
11081 * Return Code: ENXIO
11082 * EIO
11083 * EINVAL
11084 * value returned by aphysio
11085 *
11086 * Context: Kernel thread context.
11087 */
11088 /* ARGSUSED */
11089 static int
11090 sdaread(dev_t dev, struct aio_req *aio, cred_t *cred_p)
11091 {
11092 struct sd_lun *un = NULL;
11093 struct uio *uio = aio->aio_uio;
11094 int secmask;
11095 int err = 0;
11096 sd_ssc_t *ssc;
11097
11098 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
11099 return (ENXIO);
11100 }
11101
11102 ASSERT(!mutex_owned(SD_MUTEX(un)));
11103
11104 if (!SD_IS_VALID_LABEL(un) && !ISCD(un)) {
11105 mutex_enter(SD_MUTEX(un));
11106 /*
11107 * Because the call to sd_ready_and_valid will issue I/O we
11108 * must wait here if either the device is suspended or
11109 * if it's power level is changing.
11110 */
11111 while ((un->un_state == SD_STATE_SUSPENDED) ||
11112 (un->un_state == SD_STATE_PM_CHANGING)) {
11113 cv_wait(&un->un_suspend_cv, SD_MUTEX(un));
11114 }
11115 un->un_ncmds_in_driver++;
11116 mutex_exit(SD_MUTEX(un));
11117
11118 /* Initialize sd_ssc_t for internal uscsi commands */
11119 ssc = sd_ssc_init(un);
11120 if ((sd_ready_and_valid(ssc, SDPART(dev))) != SD_READY_VALID) {
11121 err = EIO;
11122 } else {
11123 err = 0;
11124 }
11125 sd_ssc_fini(ssc);
11126
11127 mutex_enter(SD_MUTEX(un));
11128 un->un_ncmds_in_driver--;
11129 ASSERT(un->un_ncmds_in_driver >= 0);
11130 mutex_exit(SD_MUTEX(un));
11131 if (err != 0)
11132 return (err);
11133 }
11134
11135 /*
11136 * Read requests are restricted to multiples of the system block size.
11137 */
11138 if (un->un_f_rmw_type == SD_RMW_TYPE_RETURN_ERROR &&
11139 !un->un_f_enable_rmw)
11140 secmask = un->un_tgt_blocksize - 1;
11141 else
11142 secmask = DEV_BSIZE - 1;
11143
11144 if (uio->uio_loffset & ((offset_t)(secmask))) {
11145 SD_ERROR(SD_LOG_READ_WRITE, un,
11146 "sdaread: file offset not modulo %d\n",
11147 secmask + 1);
11148 err = EINVAL;
11149 } else if (uio->uio_iov->iov_len & (secmask)) {
11150 SD_ERROR(SD_LOG_READ_WRITE, un,
11151 "sdaread: transfer length not modulo %d\n",
11152 secmask + 1);
11153 err = EINVAL;
11154 } else {
11155 err = aphysio(sdstrategy, anocancel, dev, B_READ, sdmin, aio);
11156 }
11157
11158 return (err);
11159 }
11160
11161
11162 /*
11163 * Function: sdawrite
11164 *
11165 * Description: Driver's awrite(9e) entry point function.
11166 *
11167 * Arguments: dev - device number
11168 * aio - structure pointer describing where data is stored
11169 * cred_p - user credential pointer
11170 *
11171 * Return Code: ENXIO
11172 * EIO
11173 * EINVAL
11174 * value returned by aphysio
11175 *
11176 * Context: Kernel thread context.
11177 */
11178 /* ARGSUSED */
11179 static int
11180 sdawrite(dev_t dev, struct aio_req *aio, cred_t *cred_p)
11181 {
11182 struct sd_lun *un = NULL;
11183 struct uio *uio = aio->aio_uio;
11184 int secmask;
11185 int err = 0;
11186 sd_ssc_t *ssc;
11187
11188 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
11189 return (ENXIO);
11190 }
11191
11192 ASSERT(!mutex_owned(SD_MUTEX(un)));
11193
11194 if (!SD_IS_VALID_LABEL(un) && !ISCD(un)) {
11195 mutex_enter(SD_MUTEX(un));
11196 /*
11197 * Because the call to sd_ready_and_valid will issue I/O we
11198 * must wait here if either the device is suspended or
11199 * if it's power level is changing.
11200 */
11201 while ((un->un_state == SD_STATE_SUSPENDED) ||
11202 (un->un_state == SD_STATE_PM_CHANGING)) {
11203 cv_wait(&un->un_suspend_cv, SD_MUTEX(un));
11204 }
11205 un->un_ncmds_in_driver++;
11206 mutex_exit(SD_MUTEX(un));
11207
11208 /* Initialize sd_ssc_t for internal uscsi commands */
11209 ssc = sd_ssc_init(un);
11210 if ((sd_ready_and_valid(ssc, SDPART(dev))) != SD_READY_VALID) {
11211 err = EIO;
11212 } else {
11213 err = 0;
11214 }
11215 sd_ssc_fini(ssc);
11216
11217 mutex_enter(SD_MUTEX(un));
11218 un->un_ncmds_in_driver--;
11219 ASSERT(un->un_ncmds_in_driver >= 0);
11220 mutex_exit(SD_MUTEX(un));
11221 if (err != 0)
11222 return (err);
11223 }
11224
11225 /*
11226 * Write requests are restricted to multiples of the system block size.
11227 */
11228 if (un->un_f_rmw_type == SD_RMW_TYPE_RETURN_ERROR &&
11229 !un->un_f_enable_rmw)
11230 secmask = un->un_tgt_blocksize - 1;
11231 else
11232 secmask = DEV_BSIZE - 1;
11233
11234 if (uio->uio_loffset & ((offset_t)(secmask))) {
11235 SD_ERROR(SD_LOG_READ_WRITE, un,
11236 "sdawrite: file offset not modulo %d\n",
11237 secmask + 1);
11238 err = EINVAL;
11239 } else if (uio->uio_iov->iov_len & (secmask)) {
11240 SD_ERROR(SD_LOG_READ_WRITE, un,
11241 "sdawrite: transfer length not modulo %d\n",
11242 secmask + 1);
11243 err = EINVAL;
11244 } else {
11245 err = aphysio(sdstrategy, anocancel, dev, B_WRITE, sdmin, aio);
11246 }
11247
11248 return (err);
11249 }
11250
11251
11252
11253
11254
11255 /*
11256 * Driver IO processing follows the following sequence:
11257 *
11258 * sdioctl(9E) sdstrategy(9E) biodone(9F)
11259 * | | ^
11260 * v v |
11261 * sd_send_scsi_cmd() ddi_xbuf_qstrategy() +-------------------+
11262 * | | | |
11263 * v | | |
11264 * sd_uscsi_strategy() sd_xbuf_strategy() sd_buf_iodone() sd_uscsi_iodone()
11265 * | | ^ ^
11266 * v v | |
11267 * SD_BEGIN_IOSTART() SD_BEGIN_IOSTART() | |
11268 * | | | |
11269 * +---+ | +------------+ +-------+
11270 * | | | |
11271 * | SD_NEXT_IOSTART()| SD_NEXT_IODONE()| |
11272 * | v | |
11273 * | sd_mapblockaddr_iostart() sd_mapblockaddr_iodone() |
11274 * | | ^ |
11275 * | SD_NEXT_IOSTART()| SD_NEXT_IODONE()| |
11276 * | v | |
11277 * | sd_mapblocksize_iostart() sd_mapblocksize_iodone() |
11278 * | | ^ |
11279 * | SD_NEXT_IOSTART()| SD_NEXT_IODONE()| |
11280 * | v | |
11281 * | sd_checksum_iostart() sd_checksum_iodone() |
11282 * | | ^ |
11283 * +-> SD_NEXT_IOSTART()| SD_NEXT_IODONE()+------------->+
11284 * | v | |
11285 * | sd_pm_iostart() sd_pm_iodone() |
11286 * | | ^ |
11287 * | | | |
11288 * +-> SD_NEXT_IOSTART()| SD_BEGIN_IODONE()--+--------------+
11289 * | ^
11290 * v |
11291 * sd_core_iostart() |
11292 * | |
11293 * | +------>(*destroypkt)()
11294 * +-> sd_start_cmds() <-+ | |
11295 * | | | v
11296 * | | | scsi_destroy_pkt(9F)
11297 * | | |
11298 * +->(*initpkt)() +- sdintr()
11299 * | | | |
11300 * | +-> scsi_init_pkt(9F) | +-> sd_handle_xxx()
11301 * | +-> scsi_setup_cdb(9F) |
11302 * | |
11303 * +--> scsi_transport(9F) |
11304 * | |
11305 * +----> SCSA ---->+
11306 *
11307 *
11308 * This code is based upon the following presumptions:
11309 *
11310 * - iostart and iodone functions operate on buf(9S) structures. These
11311 * functions perform the necessary operations on the buf(9S) and pass
11312 * them along to the next function in the chain by using the macros
11313 * SD_NEXT_IOSTART() (for iostart side functions) and SD_NEXT_IODONE()
11314 * (for iodone side functions).
11315 *
11316 * - The iostart side functions may sleep. The iodone side functions
11317 * are called under interrupt context and may NOT sleep. Therefore
11318 * iodone side functions also may not call iostart side functions.
11319 * (NOTE: iostart side functions should NOT sleep for memory, as
11320 * this could result in deadlock.)
11321 *
11322 * - An iostart side function may call its corresponding iodone side
11323 * function directly (if necessary).
11324 *
11325 * - In the event of an error, an iostart side function can return a buf(9S)
11326 * to its caller by calling SD_BEGIN_IODONE() (after setting B_ERROR and
11327 * b_error in the usual way of course).
11328 *
11329 * - The taskq mechanism may be used by the iodone side functions to dispatch
11330 * requests to the iostart side functions. The iostart side functions in
11331 * this case would be called under the context of a taskq thread, so it's
11332 * OK for them to block/sleep/spin in this case.
11333 *
11334 * - iostart side functions may allocate "shadow" buf(9S) structs and
11335 * pass them along to the next function in the chain. The corresponding
11336 * iodone side functions must coalesce the "shadow" bufs and return
11337 * the "original" buf to the next higher layer.
11338 *
11339 * - The b_private field of the buf(9S) struct holds a pointer to
11340 * an sd_xbuf struct, which contains information needed to
11341 * construct the scsi_pkt for the command.
11342 *
11343 * - The SD_MUTEX(un) is NOT held across calls to the next layer. Each
11344 * layer must acquire & release the SD_MUTEX(un) as needed.
11345 */
11346
11347
11348 /*
11349 * Create taskq for all targets in the system. This is created at
11350 * _init(9E) and destroyed at _fini(9E).
11351 *
11352 * Note: here we set the minalloc to a reasonably high number to ensure that
11353 * we will have an adequate supply of task entries available at interrupt time.
11354 * This is used in conjunction with the TASKQ_PREPOPULATE flag in
11355 * sd_create_taskq(). Since we do not want to sleep for allocations at
11356 * interrupt time, set maxalloc equal to minalloc. That way we will just fail
11357 * the command if we ever try to dispatch more than SD_TASKQ_MAXALLOC taskq
11358 * requests any one instant in time.
11359 */
11360 #define SD_TASKQ_NUMTHREADS 8
11361 #define SD_TASKQ_MINALLOC 256
11362 #define SD_TASKQ_MAXALLOC 256
11363
11364 static taskq_t *sd_tq = NULL;
11365 _NOTE(SCHEME_PROTECTS_DATA("stable data", sd_tq))
11366
11367 static int sd_taskq_minalloc = SD_TASKQ_MINALLOC;
11368 static int sd_taskq_maxalloc = SD_TASKQ_MAXALLOC;
11369
11370 /*
11371 * The following task queue is being created for the write part of
11372 * read-modify-write of non-512 block size devices.
11373 * Limit the number of threads to 1 for now. This number has been chosen
11374 * considering the fact that it applies only to dvd ram drives/MO drives
11375 * currently. Performance for which is not main criteria at this stage.
11376 * Note: It needs to be explored if we can use a single taskq in future
11377 */
11378 #define SD_WMR_TASKQ_NUMTHREADS 1
11379 static taskq_t *sd_wmr_tq = NULL;
11380 _NOTE(SCHEME_PROTECTS_DATA("stable data", sd_wmr_tq))
11381
11382 /*
11383 * Function: sd_taskq_create
11384 *
11385 * Description: Create taskq thread(s) and preallocate task entries
11386 *
11387 * Return Code: Returns a pointer to the allocated taskq_t.
11388 *
11389 * Context: Can sleep. Requires blockable context.
11390 *
11391 * Notes: - The taskq() facility currently is NOT part of the DDI.
11392 * (definitely NOT recommeded for 3rd-party drivers!) :-)
11393 * - taskq_create() will block for memory, also it will panic
11394 * if it cannot create the requested number of threads.
11395 * - Currently taskq_create() creates threads that cannot be
11396 * swapped.
11397 * - We use TASKQ_PREPOPULATE to ensure we have an adequate
11398 * supply of taskq entries at interrupt time (ie, so that we
11399 * do not have to sleep for memory)
11400 */
11401
11402 static void
11403 sd_taskq_create(void)
11404 {
11405 char taskq_name[TASKQ_NAMELEN];
11406
11407 ASSERT(sd_tq == NULL);
11408 ASSERT(sd_wmr_tq == NULL);
11409
11410 (void) snprintf(taskq_name, sizeof (taskq_name),
11411 "%s_drv_taskq", sd_label);
11412 sd_tq = (taskq_create(taskq_name, SD_TASKQ_NUMTHREADS,
11413 (v.v_maxsyspri - 2), sd_taskq_minalloc, sd_taskq_maxalloc,
11414 TASKQ_PREPOPULATE));
11415
11416 (void) snprintf(taskq_name, sizeof (taskq_name),
11417 "%s_rmw_taskq", sd_label);
11418 sd_wmr_tq = (taskq_create(taskq_name, SD_WMR_TASKQ_NUMTHREADS,
11419 (v.v_maxsyspri - 2), sd_taskq_minalloc, sd_taskq_maxalloc,
11420 TASKQ_PREPOPULATE));
11421 }
11422
11423
11424 /*
11425 * Function: sd_taskq_delete
11426 *
11427 * Description: Complementary cleanup routine for sd_taskq_create().
11428 *
11429 * Context: Kernel thread context.
11430 */
11431
11432 static void
11433 sd_taskq_delete(void)
11434 {
11435 ASSERT(sd_tq != NULL);
11436 ASSERT(sd_wmr_tq != NULL);
11437 taskq_destroy(sd_tq);
11438 taskq_destroy(sd_wmr_tq);
11439 sd_tq = NULL;
11440 sd_wmr_tq = NULL;
11441 }
11442
11443
11444 /*
11445 * Function: sdstrategy
11446 *
11447 * Description: Driver's strategy (9E) entry point function.
11448 *
11449 * Arguments: bp - pointer to buf(9S)
11450 *
11451 * Return Code: Always returns zero
11452 *
11453 * Context: Kernel thread context.
11454 */
11455
11456 static int
11457 sdstrategy(struct buf *bp)
11458 {
11459 struct sd_lun *un;
11460
11461 un = ddi_get_soft_state(sd_state, SD_GET_INSTANCE_FROM_BUF(bp));
11462 if (un == NULL) {
11463 bioerror(bp, EIO);
11464 bp->b_resid = bp->b_bcount;
11465 biodone(bp);
11466 return (0);
11467 }
11468
11469 /* As was done in the past, fail new cmds. if state is dumping. */
11470 if (un->un_state == SD_STATE_DUMPING) {
11471 bioerror(bp, ENXIO);
11472 bp->b_resid = bp->b_bcount;
11473 biodone(bp);
11474 return (0);
11475 }
11476
11477 ASSERT(!mutex_owned(SD_MUTEX(un)));
11478
11479 /*
11480 * Commands may sneak in while we released the mutex in
11481 * DDI_SUSPEND, we should block new commands. However, old
11482 * commands that are still in the driver at this point should
11483 * still be allowed to drain.
11484 */
11485 mutex_enter(SD_MUTEX(un));
11486 /*
11487 * Must wait here if either the device is suspended or
11488 * if it's power level is changing.
11489 */
11490 while ((un->un_state == SD_STATE_SUSPENDED) ||
11491 (un->un_state == SD_STATE_PM_CHANGING)) {
11492 cv_wait(&un->un_suspend_cv, SD_MUTEX(un));
11493 }
11494
11495 un->un_ncmds_in_driver++;
11496
11497 /*
11498 * atapi: Since we are running the CD for now in PIO mode we need to
11499 * call bp_mapin here to avoid bp_mapin called interrupt context under
11500 * the HBA's init_pkt routine.
11501 */
11502 if (un->un_f_cfg_is_atapi == TRUE) {
11503 mutex_exit(SD_MUTEX(un));
11504 bp_mapin(bp);
11505 mutex_enter(SD_MUTEX(un));
11506 }
11507 SD_INFO(SD_LOG_IO, un, "sdstrategy: un_ncmds_in_driver = %ld\n",
11508 un->un_ncmds_in_driver);
11509
11510 if (bp->b_flags & B_WRITE)
11511 un->un_f_sync_cache_required = TRUE;
11512
11513 mutex_exit(SD_MUTEX(un));
11514
11515 /*
11516 * This will (eventually) allocate the sd_xbuf area and
11517 * call sd_xbuf_strategy(). We just want to return the
11518 * result of ddi_xbuf_qstrategy so that we have an opt-
11519 * imized tail call which saves us a stack frame.
11520 */
11521 return (ddi_xbuf_qstrategy(bp, un->un_xbuf_attr));
11522 }
11523
11524
11525 /*
11526 * Function: sd_xbuf_strategy
11527 *
11528 * Description: Function for initiating IO operations via the
11529 * ddi_xbuf_qstrategy() mechanism.
11530 *
11531 * Context: Kernel thread context.
11532 */
11533
11534 static void
11535 sd_xbuf_strategy(struct buf *bp, ddi_xbuf_t xp, void *arg)
11536 {
11537 struct sd_lun *un = arg;
11538
11539 ASSERT(bp != NULL);
11540 ASSERT(xp != NULL);
11541 ASSERT(un != NULL);
11542 ASSERT(!mutex_owned(SD_MUTEX(un)));
11543
11544 /*
11545 * Initialize the fields in the xbuf and save a pointer to the
11546 * xbuf in bp->b_private.
11547 */
11548 sd_xbuf_init(un, bp, xp, SD_CHAIN_BUFIO, NULL);
11549
11550 /* Send the buf down the iostart chain */
11551 SD_BEGIN_IOSTART(((struct sd_xbuf *)xp)->xb_chain_iostart, un, bp);
11552 }
11553
11554
11555 /*
11556 * Function: sd_xbuf_init
11557 *
11558 * Description: Prepare the given sd_xbuf struct for use.
11559 *
11560 * Arguments: un - ptr to softstate
11561 * bp - ptr to associated buf(9S)
11562 * xp - ptr to associated sd_xbuf
11563 * chain_type - IO chain type to use:
11564 * SD_CHAIN_NULL
11565 * SD_CHAIN_BUFIO
11566 * SD_CHAIN_USCSI
11567 * SD_CHAIN_DIRECT
11568 * SD_CHAIN_DIRECT_PRIORITY
11569 * pktinfop - ptr to private data struct for scsi_pkt(9S)
11570 * initialization; may be NULL if none.
11571 *
11572 * Context: Kernel thread context
11573 */
11574
11575 static void
11576 sd_xbuf_init(struct sd_lun *un, struct buf *bp, struct sd_xbuf *xp,
11577 uchar_t chain_type, void *pktinfop)
11578 {
11579 int index;
11580
11581 ASSERT(un != NULL);
11582 ASSERT(bp != NULL);
11583 ASSERT(xp != NULL);
11584
11585 SD_INFO(SD_LOG_IO, un, "sd_xbuf_init: buf:0x%p chain type:0x%x\n",
11586 bp, chain_type);
11587
11588 xp->xb_un = un;
11589 xp->xb_pktp = NULL;
11590 xp->xb_pktinfo = pktinfop;
11591 xp->xb_private = bp->b_private;
11592 xp->xb_blkno = (daddr_t)bp->b_blkno;
11593
11594 /*
11595 * Set up the iostart and iodone chain indexes in the xbuf, based
11596 * upon the specified chain type to use.
11597 */
11598 switch (chain_type) {
11599 case SD_CHAIN_NULL:
11600 /*
11601 * Fall thru to just use the values for the buf type, even
11602 * tho for the NULL chain these values will never be used.
11603 */
11604 /* FALLTHRU */
11605 case SD_CHAIN_BUFIO:
11606 index = un->un_buf_chain_type;
11607 if ((!un->un_f_has_removable_media) &&
11608 (un->un_tgt_blocksize != 0) &&
11609 (un->un_tgt_blocksize != DEV_BSIZE ||
11610 un->un_f_enable_rmw)) {
11611 int secmask = 0, blknomask = 0;
11612 if (un->un_f_enable_rmw) {
11613 blknomask =
11614 (un->un_phy_blocksize / DEV_BSIZE) - 1;
11615 secmask = un->un_phy_blocksize - 1;
11616 } else {
11617 blknomask =
11618 (un->un_tgt_blocksize / DEV_BSIZE) - 1;
11619 secmask = un->un_tgt_blocksize - 1;
11620 }
11621
11622 if ((bp->b_lblkno & (blknomask)) ||
11623 (bp->b_bcount & (secmask))) {
11624 if ((un->un_f_rmw_type !=
11625 SD_RMW_TYPE_RETURN_ERROR) ||
11626 un->un_f_enable_rmw) {
11627 if (un->un_f_pm_is_enabled == FALSE)
11628 index =
11629 SD_CHAIN_INFO_MSS_DSK_NO_PM;
11630 else
11631 index =
11632 SD_CHAIN_INFO_MSS_DISK;
11633 }
11634 }
11635 }
11636 break;
11637 case SD_CHAIN_USCSI:
11638 index = un->un_uscsi_chain_type;
11639 break;
11640 case SD_CHAIN_DIRECT:
11641 index = un->un_direct_chain_type;
11642 break;
11643 case SD_CHAIN_DIRECT_PRIORITY:
11644 index = un->un_priority_chain_type;
11645 break;
11646 default:
11647 /* We're really broken if we ever get here... */
11648 panic("sd_xbuf_init: illegal chain type!");
11649 /*NOTREACHED*/
11650 }
11651
11652 xp->xb_chain_iostart = sd_chain_index_map[index].sci_iostart_index;
11653 xp->xb_chain_iodone = sd_chain_index_map[index].sci_iodone_index;
11654
11655 /*
11656 * It might be a bit easier to simply bzero the entire xbuf above,
11657 * but it turns out that since we init a fair number of members anyway,
11658 * we save a fair number cycles by doing explicit assignment of zero.
11659 */
11660 xp->xb_pkt_flags = 0;
11661 xp->xb_dma_resid = 0;
11662 xp->xb_retry_count = 0;
11663 xp->xb_victim_retry_count = 0;
11664 xp->xb_ua_retry_count = 0;
11665 xp->xb_nr_retry_count = 0;
11666 xp->xb_sense_bp = NULL;
11667 xp->xb_sense_status = 0;
11668 xp->xb_sense_state = 0;
11669 xp->xb_sense_resid = 0;
11670 xp->xb_ena = 0;
11671
11672 bp->b_private = xp;
11673 bp->b_flags &= ~(B_DONE | B_ERROR);
11674 bp->b_resid = 0;
11675 bp->av_forw = NULL;
11676 bp->av_back = NULL;
11677 bioerror(bp, 0);
11678
11679 SD_INFO(SD_LOG_IO, un, "sd_xbuf_init: done.\n");
11680 }
11681
11682
11683 /*
11684 * Function: sd_uscsi_strategy
11685 *
11686 * Description: Wrapper for calling into the USCSI chain via physio(9F)
11687 *
11688 * Arguments: bp - buf struct ptr
11689 *
11690 * Return Code: Always returns 0
11691 *
11692 * Context: Kernel thread context
11693 */
11694
11695 static int
11696 sd_uscsi_strategy(struct buf *bp)
11697 {
11698 struct sd_lun *un;
11699 struct sd_uscsi_info *uip;
11700 struct sd_xbuf *xp;
11701 uchar_t chain_type;
11702 uchar_t cmd;
11703
11704 ASSERT(bp != NULL);
11705
11706 un = ddi_get_soft_state(sd_state, SD_GET_INSTANCE_FROM_BUF(bp));
11707 if (un == NULL) {
11708 bioerror(bp, EIO);
11709 bp->b_resid = bp->b_bcount;
11710 biodone(bp);
11711 return (0);
11712 }
11713
11714 ASSERT(!mutex_owned(SD_MUTEX(un)));
11715
11716 SD_TRACE(SD_LOG_IO, un, "sd_uscsi_strategy: entry: buf:0x%p\n", bp);
11717
11718 /*
11719 * A pointer to a struct sd_uscsi_info is expected in bp->b_private
11720 */
11721 ASSERT(bp->b_private != NULL);
11722 uip = (struct sd_uscsi_info *)bp->b_private;
11723 cmd = ((struct uscsi_cmd *)(uip->ui_cmdp))->uscsi_cdb[0];
11724
11725 mutex_enter(SD_MUTEX(un));
11726 /*
11727 * atapi: Since we are running the CD for now in PIO mode we need to
11728 * call bp_mapin here to avoid bp_mapin called interrupt context under
11729 * the HBA's init_pkt routine.
11730 */
11731 if (un->un_f_cfg_is_atapi == TRUE) {
11732 mutex_exit(SD_MUTEX(un));
11733 bp_mapin(bp);
11734 mutex_enter(SD_MUTEX(un));
11735 }
11736 un->un_ncmds_in_driver++;
11737 SD_INFO(SD_LOG_IO, un, "sd_uscsi_strategy: un_ncmds_in_driver = %ld\n",
11738 un->un_ncmds_in_driver);
11739
11740 if ((bp->b_flags & B_WRITE) && (bp->b_bcount != 0) &&
11741 (cmd != SCMD_MODE_SELECT) && (cmd != SCMD_MODE_SELECT_G1))
11742 un->un_f_sync_cache_required = TRUE;
11743
11744 mutex_exit(SD_MUTEX(un));
11745
11746 switch (uip->ui_flags) {
11747 case SD_PATH_DIRECT:
11748 chain_type = SD_CHAIN_DIRECT;
11749 break;
11750 case SD_PATH_DIRECT_PRIORITY:
11751 chain_type = SD_CHAIN_DIRECT_PRIORITY;
11752 break;
11753 default:
11754 chain_type = SD_CHAIN_USCSI;
11755 break;
11756 }
11757
11758 /*
11759 * We may allocate extra buf for external USCSI commands. If the
11760 * application asks for bigger than 20-byte sense data via USCSI,
11761 * SCSA layer will allocate 252 bytes sense buf for that command.
11762 */
11763 if (((struct uscsi_cmd *)(uip->ui_cmdp))->uscsi_rqlen >
11764 SENSE_LENGTH) {
11765 xp = kmem_zalloc(sizeof (struct sd_xbuf) - SENSE_LENGTH +
11766 MAX_SENSE_LENGTH, KM_SLEEP);
11767 } else {
11768 xp = kmem_zalloc(sizeof (struct sd_xbuf), KM_SLEEP);
11769 }
11770
11771 sd_xbuf_init(un, bp, xp, chain_type, uip->ui_cmdp);
11772
11773 /* Use the index obtained within xbuf_init */
11774 SD_BEGIN_IOSTART(xp->xb_chain_iostart, un, bp);
11775
11776 SD_TRACE(SD_LOG_IO, un, "sd_uscsi_strategy: exit: buf:0x%p\n", bp);
11777
11778 return (0);
11779 }
11780
11781 /*
11782 * Function: sd_send_scsi_cmd
11783 *
11784 * Description: Runs a USCSI command for user (when called thru sdioctl),
11785 * or for the driver
11786 *
11787 * Arguments: dev - the dev_t for the device
11788 * incmd - ptr to a valid uscsi_cmd struct
11789 * flag - bit flag, indicating open settings, 32/64 bit type
11790 * dataspace - UIO_USERSPACE or UIO_SYSSPACE
11791 * path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and
11792 * the normal command waitq, or SD_PATH_DIRECT_PRIORITY
11793 * to use the USCSI "direct" chain and bypass the normal
11794 * command waitq.
11795 *
11796 * Return Code: 0 - successful completion of the given command
11797 * EIO - scsi_uscsi_handle_command() failed
11798 * ENXIO - soft state not found for specified dev
11799 * EINVAL
11800 * EFAULT - copyin/copyout error
11801 * return code of scsi_uscsi_handle_command():
11802 * EIO
11803 * ENXIO
11804 * EACCES
11805 *
11806 * Context: Waits for command to complete. Can sleep.
11807 */
11808
11809 static int
11810 sd_send_scsi_cmd(dev_t dev, struct uscsi_cmd *incmd, int flag,
11811 enum uio_seg dataspace, int path_flag)
11812 {
11813 struct sd_lun *un;
11814 sd_ssc_t *ssc;
11815 int rval;
11816
11817 un = ddi_get_soft_state(sd_state, SDUNIT(dev));
11818 if (un == NULL) {
11819 return (ENXIO);
11820 }
11821
11822 /*
11823 * Using sd_ssc_send to handle uscsi cmd
11824 */
11825 ssc = sd_ssc_init(un);
11826 rval = sd_ssc_send(ssc, incmd, flag, dataspace, path_flag);
11827 sd_ssc_fini(ssc);
11828
11829 return (rval);
11830 }
11831
11832 /*
11833 * Function: sd_ssc_init
11834 *
11835 * Description: Uscsi end-user call this function to initialize necessary
11836 * fields, such as uscsi_cmd and sd_uscsi_info struct.
11837 *
11838 * The return value of sd_send_scsi_cmd will be treated as a
11839 * fault in various conditions. Even it is not Zero, some
11840 * callers may ignore the return value. That is to say, we can
11841 * not make an accurate assessment in sdintr, since if a
11842 * command is failed in sdintr it does not mean the caller of
11843 * sd_send_scsi_cmd will treat it as a real failure.
11844 *
11845 * To avoid printing too many error logs for a failed uscsi
11846 * packet that the caller may not treat it as a failure, the
11847 * sd will keep silent for handling all uscsi commands.
11848 *
11849 * During detach->attach and attach-open, for some types of
11850 * problems, the driver should be providing information about
11851 * the problem encountered. Device use USCSI_SILENT, which
11852 * suppresses all driver information. The result is that no
11853 * information about the problem is available. Being
11854 * completely silent during this time is inappropriate. The
11855 * driver needs a more selective filter than USCSI_SILENT, so
11856 * that information related to faults is provided.
11857 *
11858 * To make the accurate accessment, the caller of
11859 * sd_send_scsi_USCSI_CMD should take the ownership and
11860 * get necessary information to print error messages.
11861 *
11862 * If we want to print necessary info of uscsi command, we need to
11863 * keep the uscsi_cmd and sd_uscsi_info till we can make the
11864 * assessment. We use sd_ssc_init to alloc necessary
11865 * structs for sending an uscsi command and we are also
11866 * responsible for free the memory by calling
11867 * sd_ssc_fini.
11868 *
11869 * The calling secquences will look like:
11870 * sd_ssc_init->
11871 *
11872 * ...
11873 *
11874 * sd_send_scsi_USCSI_CMD->
11875 * sd_ssc_send-> - - - sdintr
11876 * ...
11877 *
11878 * if we think the return value should be treated as a
11879 * failure, we make the accessment here and print out
11880 * necessary by retrieving uscsi_cmd and sd_uscsi_info'
11881 *
11882 * ...
11883 *
11884 * sd_ssc_fini
11885 *
11886 *
11887 * Arguments: un - pointer to driver soft state (unit) structure for this
11888 * target.
11889 *
11890 * Return code: sd_ssc_t - pointer to allocated sd_ssc_t struct, it contains
11891 * uscsi_cmd and sd_uscsi_info.
11892 * NULL - if can not alloc memory for sd_ssc_t struct
11893 *
11894 * Context: Kernel Thread.
11895 */
11896 static sd_ssc_t *
11897 sd_ssc_init(struct sd_lun *un)
11898 {
11899 sd_ssc_t *ssc;
11900 struct uscsi_cmd *ucmdp;
11901 struct sd_uscsi_info *uip;
11902
11903 ASSERT(un != NULL);
11904 ASSERT(!mutex_owned(SD_MUTEX(un)));
11905
11906 /*
11907 * Allocate sd_ssc_t structure
11908 */
11909 ssc = kmem_zalloc(sizeof (sd_ssc_t), KM_SLEEP);
11910
11911 /*
11912 * Allocate uscsi_cmd by calling scsi_uscsi_alloc common routine
11913 */
11914 ucmdp = scsi_uscsi_alloc();
11915
11916 /*
11917 * Allocate sd_uscsi_info structure
11918 */
11919 uip = kmem_zalloc(sizeof (struct sd_uscsi_info), KM_SLEEP);
11920
11921 ssc->ssc_uscsi_cmd = ucmdp;
11922 ssc->ssc_uscsi_info = uip;
11923 ssc->ssc_un = un;
11924
11925 return (ssc);
11926 }
11927
11928 /*
11929 * Function: sd_ssc_fini
11930 *
11931 * Description: To free sd_ssc_t and it's hanging off
11932 *
11933 * Arguments: ssc - struct pointer of sd_ssc_t.
11934 */
11935 static void
11936 sd_ssc_fini(sd_ssc_t *ssc)
11937 {
11938 scsi_uscsi_free(ssc->ssc_uscsi_cmd);
11939
11940 if (ssc->ssc_uscsi_info != NULL) {
11941 kmem_free(ssc->ssc_uscsi_info, sizeof (struct sd_uscsi_info));
11942 ssc->ssc_uscsi_info = NULL;
11943 }
11944
11945 kmem_free(ssc, sizeof (sd_ssc_t));
11946 ssc = NULL;
11947 }
11948
11949 /*
11950 * Function: sd_ssc_send
11951 *
11952 * Description: Runs a USCSI command for user when called through sdioctl,
11953 * or for the driver.
11954 *
11955 * Arguments: ssc - the struct of sd_ssc_t will bring uscsi_cmd and
11956 * sd_uscsi_info in.
11957 * incmd - ptr to a valid uscsi_cmd struct
11958 * flag - bit flag, indicating open settings, 32/64 bit type
11959 * dataspace - UIO_USERSPACE or UIO_SYSSPACE
11960 * path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and
11961 * the normal command waitq, or SD_PATH_DIRECT_PRIORITY
11962 * to use the USCSI "direct" chain and bypass the normal
11963 * command waitq.
11964 *
11965 * Return Code: 0 - successful completion of the given command
11966 * EIO - scsi_uscsi_handle_command() failed
11967 * ENXIO - soft state not found for specified dev
11968 * ECANCELED - command cancelled due to low power
11969 * EINVAL
11970 * EFAULT - copyin/copyout error
11971 * return code of scsi_uscsi_handle_command():
11972 * EIO
11973 * ENXIO
11974 * EACCES
11975 *
11976 * Context: Kernel Thread;
11977 * Waits for command to complete. Can sleep.
11978 */
11979 static int
11980 sd_ssc_send(sd_ssc_t *ssc, struct uscsi_cmd *incmd, int flag,
11981 enum uio_seg dataspace, int path_flag)
11982 {
11983 struct sd_uscsi_info *uip;
11984 struct uscsi_cmd *uscmd;
11985 struct sd_lun *un;
11986 dev_t dev;
11987
11988 int format = 0;
11989 int rval;
11990
11991 ASSERT(ssc != NULL);
11992 un = ssc->ssc_un;
11993 ASSERT(un != NULL);
11994 uscmd = ssc->ssc_uscsi_cmd;
11995 ASSERT(uscmd != NULL);
11996 ASSERT(!mutex_owned(SD_MUTEX(un)));
11997 if (ssc->ssc_flags & SSC_FLAGS_NEED_ASSESSMENT) {
11998 /*
11999 * If enter here, it indicates that the previous uscsi
12000 * command has not been processed by sd_ssc_assessment.
12001 * This is violating our rules of FMA telemetry processing.
12002 * We should print out this message and the last undisposed
12003 * uscsi command.
12004 */
12005 if (uscmd->uscsi_cdb != NULL) {
12006 SD_INFO(SD_LOG_SDTEST, un,
12007 "sd_ssc_send is missing the alternative "
12008 "sd_ssc_assessment when running command 0x%x.\n",
12009 uscmd->uscsi_cdb[0]);
12010 }
12011 /*
12012 * Set the ssc_flags to SSC_FLAGS_UNKNOWN, which should be
12013 * the initial status.
12014 */
12015 ssc->ssc_flags = SSC_FLAGS_UNKNOWN;
12016 }
12017
12018 /*
12019 * We need to make sure sd_ssc_send will have sd_ssc_assessment
12020 * followed to avoid missing FMA telemetries.
12021 */
12022 ssc->ssc_flags |= SSC_FLAGS_NEED_ASSESSMENT;
12023
12024 /*
12025 * if USCSI_PMFAILFAST is set and un is in low power, fail the
12026 * command immediately.
12027 */
12028 mutex_enter(SD_MUTEX(un));
12029 mutex_enter(&un->un_pm_mutex);
12030 if ((uscmd->uscsi_flags & USCSI_PMFAILFAST) &&
12031 SD_DEVICE_IS_IN_LOW_POWER(un)) {
12032 SD_TRACE(SD_LOG_IO, un, "sd_ssc_send:"
12033 "un:0x%p is in low power\n", un);
12034 mutex_exit(&un->un_pm_mutex);
12035 mutex_exit(SD_MUTEX(un));
12036 return (ECANCELED);
12037 }
12038 mutex_exit(&un->un_pm_mutex);
12039 mutex_exit(SD_MUTEX(un));
12040
12041 #ifdef SDDEBUG
12042 switch (dataspace) {
12043 case UIO_USERSPACE:
12044 SD_TRACE(SD_LOG_IO, un,
12045 "sd_ssc_send: entry: un:0x%p UIO_USERSPACE\n", un);
12046 break;
12047 case UIO_SYSSPACE:
12048 SD_TRACE(SD_LOG_IO, un,
12049 "sd_ssc_send: entry: un:0x%p UIO_SYSSPACE\n", un);
12050 break;
12051 default:
12052 SD_TRACE(SD_LOG_IO, un,
12053 "sd_ssc_send: entry: un:0x%p UNEXPECTED SPACE\n", un);
12054 break;
12055 }
12056 #endif
12057
12058 rval = scsi_uscsi_copyin((intptr_t)incmd, flag,
12059 SD_ADDRESS(un), &uscmd);
12060 if (rval != 0) {
12061 SD_TRACE(SD_LOG_IO, un, "sd_sense_scsi_cmd: "
12062 "scsi_uscsi_alloc_and_copyin failed\n", un);
12063 return (rval);
12064 }
12065
12066 if ((uscmd->uscsi_cdb != NULL) &&
12067 (uscmd->uscsi_cdb[0] == SCMD_FORMAT)) {
12068 mutex_enter(SD_MUTEX(un));
12069 un->un_f_format_in_progress = TRUE;
12070 mutex_exit(SD_MUTEX(un));
12071 format = 1;
12072 }
12073
12074 /*
12075 * Allocate an sd_uscsi_info struct and fill it with the info
12076 * needed by sd_initpkt_for_uscsi(). Then put the pointer into
12077 * b_private in the buf for sd_initpkt_for_uscsi(). Note that
12078 * since we allocate the buf here in this function, we do not
12079 * need to preserve the prior contents of b_private.
12080 * The sd_uscsi_info struct is also used by sd_uscsi_strategy()
12081 */
12082 uip = ssc->ssc_uscsi_info;
12083 uip->ui_flags = path_flag;
12084 uip->ui_cmdp = uscmd;
12085
12086 /*
12087 * Commands sent with priority are intended for error recovery
12088 * situations, and do not have retries performed.
12089 */
12090 if (path_flag == SD_PATH_DIRECT_PRIORITY) {
12091 uscmd->uscsi_flags |= USCSI_DIAGNOSE;
12092 }
12093 uscmd->uscsi_flags &= ~USCSI_NOINTR;
12094
12095 dev = SD_GET_DEV(un);
12096 rval = scsi_uscsi_handle_cmd(dev, dataspace, uscmd,
12097 sd_uscsi_strategy, NULL, uip);
12098
12099 /*
12100 * mark ssc_flags right after handle_cmd to make sure
12101 * the uscsi has been sent
12102 */
12103 ssc->ssc_flags |= SSC_FLAGS_CMD_ISSUED;
12104
12105 #ifdef SDDEBUG
12106 SD_INFO(SD_LOG_IO, un, "sd_ssc_send: "
12107 "uscsi_status: 0x%02x uscsi_resid:0x%x\n",
12108 uscmd->uscsi_status, uscmd->uscsi_resid);
12109 if (uscmd->uscsi_bufaddr != NULL) {
12110 SD_INFO(SD_LOG_IO, un, "sd_ssc_send: "
12111 "uscmd->uscsi_bufaddr: 0x%p uscmd->uscsi_buflen:%d\n",
12112 uscmd->uscsi_bufaddr, uscmd->uscsi_buflen);
12113 if (dataspace == UIO_SYSSPACE) {
12114 SD_DUMP_MEMORY(un, SD_LOG_IO,
12115 "data", (uchar_t *)uscmd->uscsi_bufaddr,
12116 uscmd->uscsi_buflen, SD_LOG_HEX);
12117 }
12118 }
12119 #endif
12120
12121 if (format == 1) {
12122 mutex_enter(SD_MUTEX(un));
12123 un->un_f_format_in_progress = FALSE;
12124 mutex_exit(SD_MUTEX(un));
12125 }
12126
12127 (void) scsi_uscsi_copyout((intptr_t)incmd, uscmd);
12128
12129 return (rval);
12130 }
12131
12132 /*
12133 * Function: sd_ssc_print
12134 *
12135 * Description: Print information available to the console.
12136 *
12137 * Arguments: ssc - the struct of sd_ssc_t will bring uscsi_cmd and
12138 * sd_uscsi_info in.
12139 * sd_severity - log level.
12140 * Context: Kernel thread or interrupt context.
12141 */
12142 static void
12143 sd_ssc_print(sd_ssc_t *ssc, int sd_severity)
12144 {
12145 struct uscsi_cmd *ucmdp;
12146 struct scsi_device *devp;
12147 dev_info_t *devinfo;
12148 uchar_t *sensep;
12149 int senlen;
12150 union scsi_cdb *cdbp;
12151 uchar_t com;
12152 extern struct scsi_key_strings scsi_cmds[];
12153
12154 ASSERT(ssc != NULL);
12155 ASSERT(ssc->ssc_un != NULL);
12156
12157 if (SD_FM_LOG(ssc->ssc_un) != SD_FM_LOG_EREPORT)
12158 return;
12159 ucmdp = ssc->ssc_uscsi_cmd;
12160 devp = SD_SCSI_DEVP(ssc->ssc_un);
12161 devinfo = SD_DEVINFO(ssc->ssc_un);
12162 ASSERT(ucmdp != NULL);
12163 ASSERT(devp != NULL);
12164 ASSERT(devinfo != NULL);
12165 sensep = (uint8_t *)ucmdp->uscsi_rqbuf;
12166 senlen = ucmdp->uscsi_rqlen - ucmdp->uscsi_rqresid;
12167 cdbp = (union scsi_cdb *)ucmdp->uscsi_cdb;
12168
12169 /* In certain case (like DOORLOCK), the cdb could be NULL. */
12170 if (cdbp == NULL)
12171 return;
12172 /* We don't print log if no sense data available. */
12173 if (senlen == 0)
12174 sensep = NULL;
12175 com = cdbp->scc_cmd;
12176 scsi_generic_errmsg(devp, sd_label, sd_severity, 0, 0, com,
12177 scsi_cmds, sensep, ssc->ssc_un->un_additional_codes, NULL);
12178 }
12179
12180 /*
12181 * Function: sd_ssc_assessment
12182 *
12183 * Description: We use this function to make an assessment at the point
12184 * where SD driver may encounter a potential error.
12185 *
12186 * Arguments: ssc - the struct of sd_ssc_t will bring uscsi_cmd and
12187 * sd_uscsi_info in.
12188 * tp_assess - a hint of strategy for ereport posting.
12189 * Possible values of tp_assess include:
12190 * SD_FMT_IGNORE - we don't post any ereport because we're
12191 * sure that it is ok to ignore the underlying problems.
12192 * SD_FMT_IGNORE_COMPROMISE - we don't post any ereport for now
12193 * but it might be not correct to ignore the underlying hardware
12194 * error.
12195 * SD_FMT_STATUS_CHECK - we will post an ereport with the
12196 * payload driver-assessment of value "fail" or
12197 * "fatal"(depending on what information we have here). This
12198 * assessment value is usually set when SD driver think there
12199 * is a potential error occurred(Typically, when return value
12200 * of the SCSI command is EIO).
12201 * SD_FMT_STANDARD - we will post an ereport with the payload
12202 * driver-assessment of value "info". This assessment value is
12203 * set when the SCSI command returned successfully and with
12204 * sense data sent back.
12205 *
12206 * Context: Kernel thread.
12207 */
12208 static void
12209 sd_ssc_assessment(sd_ssc_t *ssc, enum sd_type_assessment tp_assess)
12210 {
12211 int senlen = 0;
12212 struct uscsi_cmd *ucmdp = NULL;
12213 struct sd_lun *un;
12214
12215 ASSERT(ssc != NULL);
12216 un = ssc->ssc_un;
12217 ASSERT(un != NULL);
12218 ucmdp = ssc->ssc_uscsi_cmd;
12219 ASSERT(ucmdp != NULL);
12220
12221 if (ssc->ssc_flags & SSC_FLAGS_NEED_ASSESSMENT) {
12222 ssc->ssc_flags &= ~SSC_FLAGS_NEED_ASSESSMENT;
12223 } else {
12224 /*
12225 * If enter here, it indicates that we have a wrong
12226 * calling sequence of sd_ssc_send and sd_ssc_assessment,
12227 * both of which should be called in a pair in case of
12228 * loss of FMA telemetries.
12229 */
12230 if (ucmdp->uscsi_cdb != NULL) {
12231 SD_INFO(SD_LOG_SDTEST, un,
12232 "sd_ssc_assessment is missing the "
12233 "alternative sd_ssc_send when running 0x%x, "
12234 "or there are superfluous sd_ssc_assessment for "
12235 "the same sd_ssc_send.\n",
12236 ucmdp->uscsi_cdb[0]);
12237 }
12238 /*
12239 * Set the ssc_flags to the initial value to avoid passing
12240 * down dirty flags to the following sd_ssc_send function.
12241 */
12242 ssc->ssc_flags = SSC_FLAGS_UNKNOWN;
12243 return;
12244 }
12245
12246 /*
12247 * Only handle an issued command which is waiting for assessment.
12248 * A command which is not issued will not have
12249 * SSC_FLAGS_INVALID_DATA set, so it'ok we just return here.
12250 */
12251 if (!(ssc->ssc_flags & SSC_FLAGS_CMD_ISSUED)) {
12252 sd_ssc_print(ssc, SCSI_ERR_INFO);
12253 return;
12254 } else {
12255 /*
12256 * For an issued command, we should clear this flag in
12257 * order to make the sd_ssc_t structure be used off
12258 * multiple uscsi commands.
12259 */
12260 ssc->ssc_flags &= ~SSC_FLAGS_CMD_ISSUED;
12261 }
12262
12263 /*
12264 * We will not deal with non-retryable(flag USCSI_DIAGNOSE set)
12265 * commands here. And we should clear the ssc_flags before return.
12266 */
12267 if (ucmdp->uscsi_flags & USCSI_DIAGNOSE) {
12268 ssc->ssc_flags = SSC_FLAGS_UNKNOWN;
12269 return;
12270 }
12271
12272 switch (tp_assess) {
12273 case SD_FMT_IGNORE:
12274 case SD_FMT_IGNORE_COMPROMISE:
12275 break;
12276 case SD_FMT_STATUS_CHECK:
12277 /*
12278 * For a failed command(including the succeeded command
12279 * with invalid data sent back).
12280 */
12281 sd_ssc_post(ssc, SD_FM_DRV_FATAL);
12282 break;
12283 case SD_FMT_STANDARD:
12284 /*
12285 * Always for the succeeded commands probably with sense
12286 * data sent back.
12287 * Limitation:
12288 * We can only handle a succeeded command with sense
12289 * data sent back when auto-request-sense is enabled.
12290 */
12291 senlen = ssc->ssc_uscsi_cmd->uscsi_rqlen -
12292 ssc->ssc_uscsi_cmd->uscsi_rqresid;
12293 if ((ssc->ssc_uscsi_info->ui_pkt_state & STATE_ARQ_DONE) &&
12294 (un->un_f_arq_enabled == TRUE) &&
12295 senlen > 0 &&
12296 ssc->ssc_uscsi_cmd->uscsi_rqbuf != NULL) {
12297 sd_ssc_post(ssc, SD_FM_DRV_NOTICE);
12298 }
12299 break;
12300 default:
12301 /*
12302 * Should not have other type of assessment.
12303 */
12304 scsi_log(SD_DEVINFO(un), sd_label, CE_CONT,
12305 "sd_ssc_assessment got wrong "
12306 "sd_type_assessment %d.\n", tp_assess);
12307 break;
12308 }
12309 /*
12310 * Clear up the ssc_flags before return.
12311 */
12312 ssc->ssc_flags = SSC_FLAGS_UNKNOWN;
12313 }
12314
12315 /*
12316 * Function: sd_ssc_post
12317 *
12318 * Description: 1. read the driver property to get fm-scsi-log flag.
12319 * 2. print log if fm_log_capable is non-zero.
12320 * 3. call sd_ssc_ereport_post to post ereport if possible.
12321 *
12322 * Context: May be called from kernel thread or interrupt context.
12323 */
12324 static void
12325 sd_ssc_post(sd_ssc_t *ssc, enum sd_driver_assessment sd_assess)
12326 {
12327 struct sd_lun *un;
12328 int sd_severity;
12329
12330 ASSERT(ssc != NULL);
12331 un = ssc->ssc_un;
12332 ASSERT(un != NULL);
12333
12334 /*
12335 * We may enter here from sd_ssc_assessment(for USCSI command) or
12336 * by directly called from sdintr context.
12337 * We don't handle a non-disk drive(CD-ROM, removable media).
12338 * Clear the ssc_flags before return in case we've set
12339 * SSC_FLAGS_INVALID_XXX which should be skipped for a non-disk
12340 * driver.
12341 */
12342 if (ISCD(un) || un->un_f_has_removable_media) {
12343 ssc->ssc_flags = SSC_FLAGS_UNKNOWN;
12344 return;
12345 }
12346
12347 switch (sd_assess) {
12348 case SD_FM_DRV_FATAL:
12349 sd_severity = SCSI_ERR_FATAL;
12350 break;
12351 case SD_FM_DRV_RECOVERY:
12352 sd_severity = SCSI_ERR_RECOVERED;
12353 break;
12354 case SD_FM_DRV_RETRY:
12355 sd_severity = SCSI_ERR_RETRYABLE;
12356 break;
12357 case SD_FM_DRV_NOTICE:
12358 sd_severity = SCSI_ERR_INFO;
12359 break;
12360 default:
12361 sd_severity = SCSI_ERR_UNKNOWN;
12362 }
12363 /* print log */
12364 sd_ssc_print(ssc, sd_severity);
12365
12366 /* always post ereport */
12367 sd_ssc_ereport_post(ssc, sd_assess);
12368 }
12369
12370 /*
12371 * Function: sd_ssc_set_info
12372 *
12373 * Description: Mark ssc_flags and set ssc_info which would be the
12374 * payload of uderr ereport. This function will cause
12375 * sd_ssc_ereport_post to post uderr ereport only.
12376 * Besides, when ssc_flags == SSC_FLAGS_INVALID_DATA(USCSI),
12377 * the function will also call SD_ERROR or scsi_log for a
12378 * CDROM/removable-media/DDI_FM_NOT_CAPABLE device.
12379 *
12380 * Arguments: ssc - the struct of sd_ssc_t will bring uscsi_cmd and
12381 * sd_uscsi_info in.
12382 * ssc_flags - indicate the sub-category of a uderr.
12383 * comp - this argument is meaningful only when
12384 * ssc_flags == SSC_FLAGS_INVALID_DATA, and its possible
12385 * values include:
12386 * > 0, SD_ERROR is used with comp as the driver logging
12387 * component;
12388 * = 0, scsi-log is used to log error telemetries;
12389 * < 0, no log available for this telemetry.
12390 *
12391 * Context: Kernel thread or interrupt context
12392 */
12393 static void
12394 sd_ssc_set_info(sd_ssc_t *ssc, int ssc_flags, uint_t comp, const char *fmt, ...)
12395 {
12396 va_list ap;
12397
12398 ASSERT(ssc != NULL);
12399 ASSERT(ssc->ssc_un != NULL);
12400
12401 ssc->ssc_flags |= ssc_flags;
12402 va_start(ap, fmt);
12403 (void) vsnprintf(ssc->ssc_info, sizeof (ssc->ssc_info), fmt, ap);
12404 va_end(ap);
12405
12406 /*
12407 * If SSC_FLAGS_INVALID_DATA is set, it should be a uscsi command
12408 * with invalid data sent back. For non-uscsi command, the
12409 * following code will be bypassed.
12410 */
12411 if (ssc_flags & SSC_FLAGS_INVALID_DATA) {
12412 if (SD_FM_LOG(ssc->ssc_un) == SD_FM_LOG_NSUP) {
12413 /*
12414 * If the error belong to certain component and we
12415 * do not want it to show up on the console, we
12416 * will use SD_ERROR, otherwise scsi_log is
12417 * preferred.
12418 */
12419 if (comp > 0) {
12420 SD_ERROR(comp, ssc->ssc_un, ssc->ssc_info);
12421 } else if (comp == 0) {
12422 scsi_log(SD_DEVINFO(ssc->ssc_un), sd_label,
12423 CE_WARN, ssc->ssc_info);
12424 }
12425 }
12426 }
12427 }
12428
12429 /*
12430 * Function: sd_buf_iodone
12431 *
12432 * Description: Frees the sd_xbuf & returns the buf to its originator.
12433 *
12434 * Context: May be called from interrupt context.
12435 */
12436 /* ARGSUSED */
12437 static void
12438 sd_buf_iodone(int index, struct sd_lun *un, struct buf *bp)
12439 {
12440 struct sd_xbuf *xp;
12441
12442 ASSERT(un != NULL);
12443 ASSERT(bp != NULL);
12444 ASSERT(!mutex_owned(SD_MUTEX(un)));
12445
12446 SD_TRACE(SD_LOG_IO_CORE, un, "sd_buf_iodone: entry.\n");
12447
12448 xp = SD_GET_XBUF(bp);
12449 ASSERT(xp != NULL);
12450
12451 /* xbuf is gone after this */
12452 if (ddi_xbuf_done(bp, un->un_xbuf_attr)) {
12453 mutex_enter(SD_MUTEX(un));
12454
12455 /*
12456 * Grab time when the cmd completed.
12457 * This is used for determining if the system has been
12458 * idle long enough to make it idle to the PM framework.
12459 * This is for lowering the overhead, and therefore improving
12460 * performance per I/O operation.
12461 */
12462 un->un_pm_idle_time = gethrtime();
12463
12464 un->un_ncmds_in_driver--;
12465 ASSERT(un->un_ncmds_in_driver >= 0);
12466 SD_INFO(SD_LOG_IO, un,
12467 "sd_buf_iodone: un_ncmds_in_driver = %ld\n",
12468 un->un_ncmds_in_driver);
12469
12470 mutex_exit(SD_MUTEX(un));
12471 }
12472
12473 biodone(bp); /* bp is gone after this */
12474
12475 SD_TRACE(SD_LOG_IO_CORE, un, "sd_buf_iodone: exit.\n");
12476 }
12477
12478
12479 /*
12480 * Function: sd_uscsi_iodone
12481 *
12482 * Description: Frees the sd_xbuf & returns the buf to its originator.
12483 *
12484 * Context: May be called from interrupt context.
12485 */
12486 /* ARGSUSED */
12487 static void
12488 sd_uscsi_iodone(int index, struct sd_lun *un, struct buf *bp)
12489 {
12490 struct sd_xbuf *xp;
12491
12492 ASSERT(un != NULL);
12493 ASSERT(bp != NULL);
12494
12495 xp = SD_GET_XBUF(bp);
12496 ASSERT(xp != NULL);
12497 ASSERT(!mutex_owned(SD_MUTEX(un)));
12498
12499 SD_INFO(SD_LOG_IO, un, "sd_uscsi_iodone: entry.\n");
12500
12501 bp->b_private = xp->xb_private;
12502
12503 mutex_enter(SD_MUTEX(un));
12504
12505 /*
12506 * Grab time when the cmd completed.
12507 * This is used for determining if the system has been
12508 * idle long enough to make it idle to the PM framework.
12509 * This is for lowering the overhead, and therefore improving
12510 * performance per I/O operation.
12511 */
12512 un->un_pm_idle_time = gethrtime();
12513
12514 un->un_ncmds_in_driver--;
12515 ASSERT(un->un_ncmds_in_driver >= 0);
12516 SD_INFO(SD_LOG_IO, un, "sd_uscsi_iodone: un_ncmds_in_driver = %ld\n",
12517 un->un_ncmds_in_driver);
12518
12519 mutex_exit(SD_MUTEX(un));
12520
12521 if (((struct uscsi_cmd *)(xp->xb_pktinfo))->uscsi_rqlen >
12522 SENSE_LENGTH) {
12523 kmem_free(xp, sizeof (struct sd_xbuf) - SENSE_LENGTH +
12524 MAX_SENSE_LENGTH);
12525 } else {
12526 kmem_free(xp, sizeof (struct sd_xbuf));
12527 }
12528
12529 biodone(bp);
12530
12531 SD_INFO(SD_LOG_IO, un, "sd_uscsi_iodone: exit.\n");
12532 }
12533
12534
12535 /*
12536 * Function: sd_mapblockaddr_iostart
12537 *
12538 * Description: Verify request lies within the partition limits for
12539 * the indicated minor device. Issue "overrun" buf if
12540 * request would exceed partition range. Converts
12541 * partition-relative block address to absolute.
12542 *
12543 * Upon exit of this function:
12544 * 1.I/O is aligned
12545 * xp->xb_blkno represents the absolute sector address
12546 * 2.I/O is misaligned
12547 * xp->xb_blkno represents the absolute logical block address
12548 * based on DEV_BSIZE. The logical block address will be
12549 * converted to physical sector address in sd_mapblocksize_\
12550 * iostart.
12551 * 3.I/O is misaligned but is aligned in "overrun" buf
12552 * xp->xb_blkno represents the absolute logical block address
12553 * based on DEV_BSIZE. The logical block address will be
12554 * converted to physical sector address in sd_mapblocksize_\
12555 * iostart. But no RMW will be issued in this case.
12556 *
12557 * Context: Can sleep
12558 *
12559 * Issues: This follows what the old code did, in terms of accessing
12560 * some of the partition info in the unit struct without holding
12561 * the mutext. This is a general issue, if the partition info
12562 * can be altered while IO is in progress... as soon as we send
12563 * a buf, its partitioning can be invalid before it gets to the
12564 * device. Probably the right fix is to move partitioning out
12565 * of the driver entirely.
12566 */
12567
12568 static void
12569 sd_mapblockaddr_iostart(int index, struct sd_lun *un, struct buf *bp)
12570 {
12571 diskaddr_t nblocks; /* #blocks in the given partition */
12572 daddr_t blocknum; /* Block number specified by the buf */
12573 size_t requested_nblocks;
12574 size_t available_nblocks;
12575 int partition;
12576 diskaddr_t partition_offset;
12577 struct sd_xbuf *xp;
12578 int secmask = 0, blknomask = 0;
12579 ushort_t is_aligned = TRUE;
12580
12581 ASSERT(un != NULL);
12582 ASSERT(bp != NULL);
12583 ASSERT(!mutex_owned(SD_MUTEX(un)));
12584
12585 SD_TRACE(SD_LOG_IO_PARTITION, un,
12586 "sd_mapblockaddr_iostart: entry: buf:0x%p\n", bp);
12587
12588 xp = SD_GET_XBUF(bp);
12589 ASSERT(xp != NULL);
12590
12591 /*
12592 * If the geometry is not indicated as valid, attempt to access
12593 * the unit & verify the geometry/label. This can be the case for
12594 * removable-media devices, of if the device was opened in
12595 * NDELAY/NONBLOCK mode.
12596 */
12597 partition = SDPART(bp->b_edev);
12598
12599 if (!SD_IS_VALID_LABEL(un)) {
12600 sd_ssc_t *ssc;
12601 /*
12602 * Initialize sd_ssc_t for internal uscsi commands
12603 * In case of potential porformance issue, we need
12604 * to alloc memory only if there is invalid label
12605 */
12606 ssc = sd_ssc_init(un);
12607
12608 if (sd_ready_and_valid(ssc, partition) != SD_READY_VALID) {
12609 /*
12610 * For removable devices it is possible to start an
12611 * I/O without a media by opening the device in nodelay
12612 * mode. Also for writable CDs there can be many
12613 * scenarios where there is no geometry yet but volume
12614 * manager is trying to issue a read() just because
12615 * it can see TOC on the CD. So do not print a message
12616 * for removables.
12617 */
12618 if (!un->un_f_has_removable_media) {
12619 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
12620 "i/o to invalid geometry\n");
12621 }
12622 bioerror(bp, EIO);
12623 bp->b_resid = bp->b_bcount;
12624 SD_BEGIN_IODONE(index, un, bp);
12625
12626 sd_ssc_fini(ssc);
12627 return;
12628 }
12629 sd_ssc_fini(ssc);
12630 }
12631
12632 nblocks = 0;
12633 (void) cmlb_partinfo(un->un_cmlbhandle, partition,
12634 &nblocks, &partition_offset, NULL, NULL, (void *)SD_PATH_DIRECT);
12635
12636 if (un->un_f_enable_rmw) {
12637 blknomask = (un->un_phy_blocksize / DEV_BSIZE) - 1;
12638 secmask = un->un_phy_blocksize - 1;
12639 } else {
12640 blknomask = (un->un_tgt_blocksize / DEV_BSIZE) - 1;
12641 secmask = un->un_tgt_blocksize - 1;
12642 }
12643
12644 if ((bp->b_lblkno & (blknomask)) || (bp->b_bcount & (secmask))) {
12645 is_aligned = FALSE;
12646 }
12647
12648 if (!(NOT_DEVBSIZE(un)) || un->un_f_enable_rmw) {
12649 /*
12650 * If I/O is aligned, no need to involve RMW(Read Modify Write)
12651 * Convert the logical block number to target's physical sector
12652 * number.
12653 */
12654 if (is_aligned) {
12655 xp->xb_blkno = SD_SYS2TGTBLOCK(un, xp->xb_blkno);
12656 } else {
12657 /*
12658 * There is no RMW if we're just reading, so don't
12659 * warn or error out because of it.
12660 */
12661 if (bp->b_flags & B_READ) {
12662 /*EMPTY*/
12663 } else if (!un->un_f_enable_rmw &&
12664 un->un_f_rmw_type == SD_RMW_TYPE_RETURN_ERROR) {
12665 bp->b_flags |= B_ERROR;
12666 goto error_exit;
12667 } else if (un->un_f_rmw_type == SD_RMW_TYPE_DEFAULT) {
12668 mutex_enter(SD_MUTEX(un));
12669 if (!un->un_f_enable_rmw &&
12670 un->un_rmw_msg_timeid == NULL) {
12671 scsi_log(SD_DEVINFO(un), sd_label,
12672 CE_WARN, "I/O request is not "
12673 "aligned with %d disk sector size. "
12674 "It is handled through Read Modify "
12675 "Write but the performance is "
12676 "very low.\n",
12677 un->un_tgt_blocksize);
12678 un->un_rmw_msg_timeid =
12679 timeout(sd_rmw_msg_print_handler,
12680 un, SD_RMW_MSG_PRINT_TIMEOUT);
12681 } else {
12682 un->un_rmw_incre_count ++;
12683 }
12684 mutex_exit(SD_MUTEX(un));
12685 }
12686
12687 nblocks = SD_TGT2SYSBLOCK(un, nblocks);
12688 partition_offset = SD_TGT2SYSBLOCK(un,
12689 partition_offset);
12690 }
12691 }
12692
12693 /*
12694 * blocknum is the starting block number of the request. At this
12695 * point it is still relative to the start of the minor device.
12696 */
12697 blocknum = xp->xb_blkno;
12698
12699 /*
12700 * Legacy: If the starting block number is one past the last block
12701 * in the partition, do not set B_ERROR in the buf.
12702 */
12703 if (blocknum == nblocks) {
12704 goto error_exit;
12705 }
12706
12707 /*
12708 * Confirm that the first block of the request lies within the
12709 * partition limits. Also the requested number of bytes must be
12710 * a multiple of the system block size.
12711 */
12712 if ((blocknum < 0) || (blocknum >= nblocks) ||
12713 ((bp->b_bcount & (DEV_BSIZE - 1)) != 0)) {
12714 bp->b_flags |= B_ERROR;
12715 goto error_exit;
12716 }
12717
12718 /*
12719 * If the requsted # blocks exceeds the available # blocks, that
12720 * is an overrun of the partition.
12721 */
12722 if ((!NOT_DEVBSIZE(un)) && is_aligned) {
12723 requested_nblocks = SD_BYTES2TGTBLOCKS(un, bp->b_bcount);
12724 } else {
12725 requested_nblocks = SD_BYTES2SYSBLOCKS(bp->b_bcount);
12726 }
12727
12728 available_nblocks = (size_t)(nblocks - blocknum);
12729 ASSERT(nblocks >= blocknum);
12730
12731 if (requested_nblocks > available_nblocks) {
12732 size_t resid;
12733
12734 /*
12735 * Allocate an "overrun" buf to allow the request to proceed
12736 * for the amount of space available in the partition. The
12737 * amount not transferred will be added into the b_resid
12738 * when the operation is complete. The overrun buf
12739 * replaces the original buf here, and the original buf
12740 * is saved inside the overrun buf, for later use.
12741 */
12742 if ((!NOT_DEVBSIZE(un)) && is_aligned) {
12743 resid = SD_TGTBLOCKS2BYTES(un,
12744 (offset_t)(requested_nblocks - available_nblocks));
12745 } else {
12746 resid = SD_SYSBLOCKS2BYTES(
12747 (offset_t)(requested_nblocks - available_nblocks));
12748 }
12749
12750 size_t count = bp->b_bcount - resid;
12751 /*
12752 * Note: count is an unsigned entity thus it'll NEVER
12753 * be less than 0 so ASSERT the original values are
12754 * correct.
12755 */
12756 ASSERT(bp->b_bcount >= resid);
12757
12758 bp = sd_bioclone_alloc(bp, count, blocknum,
12759 (int (*)(struct buf *)) sd_mapblockaddr_iodone);
12760 xp = SD_GET_XBUF(bp); /* Update for 'new' bp! */
12761 ASSERT(xp != NULL);
12762 }
12763
12764 /* At this point there should be no residual for this buf. */
12765 ASSERT(bp->b_resid == 0);
12766
12767 /* Convert the block number to an absolute address. */
12768 xp->xb_blkno += partition_offset;
12769
12770 SD_NEXT_IOSTART(index, un, bp);
12771
12772 SD_TRACE(SD_LOG_IO_PARTITION, un,
12773 "sd_mapblockaddr_iostart: exit 0: buf:0x%p\n", bp);
12774
12775 return;
12776
12777 error_exit:
12778 bp->b_resid = bp->b_bcount;
12779 SD_BEGIN_IODONE(index, un, bp);
12780 SD_TRACE(SD_LOG_IO_PARTITION, un,
12781 "sd_mapblockaddr_iostart: exit 1: buf:0x%p\n", bp);
12782 }
12783
12784
12785 /*
12786 * Function: sd_mapblockaddr_iodone
12787 *
12788 * Description: Completion-side processing for partition management.
12789 *
12790 * Context: May be called under interrupt context
12791 */
12792
12793 static void
12794 sd_mapblockaddr_iodone(int index, struct sd_lun *un, struct buf *bp)
12795 {
12796 /* int partition; */ /* Not used, see below. */
12797 ASSERT(un != NULL);
12798 ASSERT(bp != NULL);
12799 ASSERT(!mutex_owned(SD_MUTEX(un)));
12800
12801 SD_TRACE(SD_LOG_IO_PARTITION, un,
12802 "sd_mapblockaddr_iodone: entry: buf:0x%p\n", bp);
12803
12804 if (bp->b_iodone == (int (*)(struct buf *)) sd_mapblockaddr_iodone) {
12805 /*
12806 * We have an "overrun" buf to deal with...
12807 */
12808 struct sd_xbuf *xp;
12809 struct buf *obp; /* ptr to the original buf */
12810
12811 xp = SD_GET_XBUF(bp);
12812 ASSERT(xp != NULL);
12813
12814 /* Retrieve the pointer to the original buf */
12815 obp = (struct buf *)xp->xb_private;
12816 ASSERT(obp != NULL);
12817
12818 obp->b_resid = obp->b_bcount - (bp->b_bcount - bp->b_resid);
12819 bioerror(obp, bp->b_error);
12820
12821 sd_bioclone_free(bp);
12822
12823 /*
12824 * Get back the original buf.
12825 * Note that since the restoration of xb_blkno below
12826 * was removed, the sd_xbuf is not needed.
12827 */
12828 bp = obp;
12829 /*
12830 * xp = SD_GET_XBUF(bp);
12831 * ASSERT(xp != NULL);
12832 */
12833 }
12834
12835 /*
12836 * Convert sd->xb_blkno back to a minor-device relative value.
12837 * Note: this has been commented out, as it is not needed in the
12838 * current implementation of the driver (ie, since this function
12839 * is at the top of the layering chains, so the info will be
12840 * discarded) and it is in the "hot" IO path.
12841 *
12842 * partition = getminor(bp->b_edev) & SDPART_MASK;
12843 * xp->xb_blkno -= un->un_offset[partition];
12844 */
12845
12846 SD_NEXT_IODONE(index, un, bp);
12847
12848 SD_TRACE(SD_LOG_IO_PARTITION, un,
12849 "sd_mapblockaddr_iodone: exit: buf:0x%p\n", bp);
12850 }
12851
12852
12853 /*
12854 * Function: sd_mapblocksize_iostart
12855 *
12856 * Description: Convert between system block size (un->un_sys_blocksize)
12857 * and target block size (un->un_tgt_blocksize).
12858 *
12859 * Context: Can sleep to allocate resources.
12860 *
12861 * Assumptions: A higher layer has already performed any partition validation,
12862 * and converted the xp->xb_blkno to an absolute value relative
12863 * to the start of the device.
12864 *
12865 * It is also assumed that the higher layer has implemented
12866 * an "overrun" mechanism for the case where the request would
12867 * read/write beyond the end of a partition. In this case we
12868 * assume (and ASSERT) that bp->b_resid == 0.
12869 *
12870 * Note: The implementation for this routine assumes the target
12871 * block size remains constant between allocation and transport.
12872 */
12873
12874 static void
12875 sd_mapblocksize_iostart(int index, struct sd_lun *un, struct buf *bp)
12876 {
12877 struct sd_mapblocksize_info *bsp;
12878 struct sd_xbuf *xp;
12879 offset_t first_byte;
12880 daddr_t start_block, end_block;
12881 daddr_t request_bytes;
12882 ushort_t is_aligned = FALSE;
12883
12884 ASSERT(un != NULL);
12885 ASSERT(bp != NULL);
12886 ASSERT(!mutex_owned(SD_MUTEX(un)));
12887 ASSERT(bp->b_resid == 0);
12888
12889 SD_TRACE(SD_LOG_IO_RMMEDIA, un,
12890 "sd_mapblocksize_iostart: entry: buf:0x%p\n", bp);
12891
12892 /*
12893 * For a non-writable CD, a write request is an error
12894 */
12895 if (ISCD(un) && ((bp->b_flags & B_READ) == 0) &&
12896 (un->un_f_mmc_writable_media == FALSE)) {
12897 bioerror(bp, EIO);
12898 bp->b_resid = bp->b_bcount;
12899 SD_BEGIN_IODONE(index, un, bp);
12900 return;
12901 }
12902
12903 /*
12904 * We do not need a shadow buf if the device is using
12905 * un->un_sys_blocksize as its block size or if bcount == 0.
12906 * In this case there is no layer-private data block allocated.
12907 */
12908 if ((un->un_tgt_blocksize == DEV_BSIZE && !un->un_f_enable_rmw) ||
12909 (bp->b_bcount == 0)) {
12910 goto done;
12911 }
12912
12913 #if defined(__i386) || defined(__amd64)
12914 /* We do not support non-block-aligned transfers for ROD devices */
12915 ASSERT(!ISROD(un));
12916 #endif
12917
12918 xp = SD_GET_XBUF(bp);
12919 ASSERT(xp != NULL);
12920
12921 SD_INFO(SD_LOG_IO_RMMEDIA, un, "sd_mapblocksize_iostart: "
12922 "tgt_blocksize:0x%x sys_blocksize: 0x%x\n",
12923 un->un_tgt_blocksize, DEV_BSIZE);
12924 SD_INFO(SD_LOG_IO_RMMEDIA, un, "sd_mapblocksize_iostart: "
12925 "request start block:0x%x\n", xp->xb_blkno);
12926 SD_INFO(SD_LOG_IO_RMMEDIA, un, "sd_mapblocksize_iostart: "
12927 "request len:0x%x\n", bp->b_bcount);
12928
12929 /*
12930 * Allocate the layer-private data area for the mapblocksize layer.
12931 * Layers are allowed to use the xp_private member of the sd_xbuf
12932 * struct to store the pointer to their layer-private data block, but
12933 * each layer also has the responsibility of restoring the prior
12934 * contents of xb_private before returning the buf/xbuf to the
12935 * higher layer that sent it.
12936 *
12937 * Here we save the prior contents of xp->xb_private into the
12938 * bsp->mbs_oprivate field of our layer-private data area. This value
12939 * is restored by sd_mapblocksize_iodone() just prior to freeing up
12940 * the layer-private area and returning the buf/xbuf to the layer
12941 * that sent it.
12942 *
12943 * Note that here we use kmem_zalloc for the allocation as there are
12944 * parts of the mapblocksize code that expect certain fields to be
12945 * zero unless explicitly set to a required value.
12946 */
12947 bsp = kmem_zalloc(sizeof (struct sd_mapblocksize_info), KM_SLEEP);
12948 bsp->mbs_oprivate = xp->xb_private;
12949 xp->xb_private = bsp;
12950
12951 /*
12952 * This treats the data on the disk (target) as an array of bytes.
12953 * first_byte is the byte offset, from the beginning of the device,
12954 * to the location of the request. This is converted from a
12955 * un->un_sys_blocksize block address to a byte offset, and then back
12956 * to a block address based upon a un->un_tgt_blocksize block size.
12957 *
12958 * xp->xb_blkno should be absolute upon entry into this function,
12959 * but, but it is based upon partitions that use the "system"
12960 * block size. It must be adjusted to reflect the block size of
12961 * the target.
12962 *
12963 * Note that end_block is actually the block that follows the last
12964 * block of the request, but that's what is needed for the computation.
12965 */
12966 first_byte = SD_SYSBLOCKS2BYTES((offset_t)xp->xb_blkno);
12967 if (un->un_f_enable_rmw) {
12968 start_block = xp->xb_blkno =
12969 (first_byte / un->un_phy_blocksize) *
12970 (un->un_phy_blocksize / DEV_BSIZE);
12971 end_block = ((first_byte + bp->b_bcount +
12972 un->un_phy_blocksize - 1) / un->un_phy_blocksize) *
12973 (un->un_phy_blocksize / DEV_BSIZE);
12974 } else {
12975 start_block = xp->xb_blkno = first_byte / un->un_tgt_blocksize;
12976 end_block = (first_byte + bp->b_bcount +
12977 un->un_tgt_blocksize - 1) / un->un_tgt_blocksize;
12978 }
12979
12980 /* request_bytes is rounded up to a multiple of the target block size */
12981 request_bytes = (end_block - start_block) * un->un_tgt_blocksize;
12982
12983 /*
12984 * See if the starting address of the request and the request
12985 * length are aligned on a un->un_tgt_blocksize boundary. If aligned
12986 * then we do not need to allocate a shadow buf to handle the request.
12987 */
12988 if (un->un_f_enable_rmw) {
12989 if (((first_byte % un->un_phy_blocksize) == 0) &&
12990 ((bp->b_bcount % un->un_phy_blocksize) == 0)) {
12991 is_aligned = TRUE;
12992 }
12993 } else {
12994 if (((first_byte % un->un_tgt_blocksize) == 0) &&
12995 ((bp->b_bcount % un->un_tgt_blocksize) == 0)) {
12996 is_aligned = TRUE;
12997 }
12998 }
12999
13000 if ((bp->b_flags & B_READ) == 0) {
13001 /*
13002 * Lock the range for a write operation. An aligned request is
13003 * considered a simple write; otherwise the request must be a
13004 * read-modify-write.
13005 */
13006 bsp->mbs_wmp = sd_range_lock(un, start_block, end_block - 1,
13007 (is_aligned == TRUE) ? SD_WTYPE_SIMPLE : SD_WTYPE_RMW);
13008 }
13009
13010 /*
13011 * Alloc a shadow buf if the request is not aligned. Also, this is
13012 * where the READ command is generated for a read-modify-write. (The
13013 * write phase is deferred until after the read completes.)
13014 */
13015 if (is_aligned == FALSE) {
13016
13017 struct sd_mapblocksize_info *shadow_bsp;
13018 struct sd_xbuf *shadow_xp;
13019 struct buf *shadow_bp;
13020
13021 /*
13022 * Allocate the shadow buf and it associated xbuf. Note that
13023 * after this call the xb_blkno value in both the original
13024 * buf's sd_xbuf _and_ the shadow buf's sd_xbuf will be the
13025 * same: absolute relative to the start of the device, and
13026 * adjusted for the target block size. The b_blkno in the
13027 * shadow buf will also be set to this value. We should never
13028 * change b_blkno in the original bp however.
13029 *
13030 * Note also that the shadow buf will always need to be a
13031 * READ command, regardless of whether the incoming command
13032 * is a READ or a WRITE.
13033 */
13034 shadow_bp = sd_shadow_buf_alloc(bp, request_bytes, B_READ,
13035 xp->xb_blkno,
13036 (int (*)(struct buf *)) sd_mapblocksize_iodone);
13037
13038 shadow_xp = SD_GET_XBUF(shadow_bp);
13039
13040 /*
13041 * Allocate the layer-private data for the shadow buf.
13042 * (No need to preserve xb_private in the shadow xbuf.)
13043 */
13044 shadow_xp->xb_private = shadow_bsp =
13045 kmem_zalloc(sizeof (struct sd_mapblocksize_info), KM_SLEEP);
13046
13047 /*
13048 * bsp->mbs_copy_offset is used later by sd_mapblocksize_iodone
13049 * to figure out where the start of the user data is (based upon
13050 * the system block size) in the data returned by the READ
13051 * command (which will be based upon the target blocksize). Note
13052 * that this is only really used if the request is unaligned.
13053 */
13054 if (un->un_f_enable_rmw) {
13055 bsp->mbs_copy_offset = (ssize_t)(first_byte -
13056 ((offset_t)xp->xb_blkno * un->un_sys_blocksize));
13057 ASSERT((bsp->mbs_copy_offset >= 0) &&
13058 (bsp->mbs_copy_offset < un->un_phy_blocksize));
13059 } else {
13060 bsp->mbs_copy_offset = (ssize_t)(first_byte -
13061 ((offset_t)xp->xb_blkno * un->un_tgt_blocksize));
13062 ASSERT((bsp->mbs_copy_offset >= 0) &&
13063 (bsp->mbs_copy_offset < un->un_tgt_blocksize));
13064 }
13065
13066 shadow_bsp->mbs_copy_offset = bsp->mbs_copy_offset;
13067
13068 shadow_bsp->mbs_layer_index = bsp->mbs_layer_index = index;
13069
13070 /* Transfer the wmap (if any) to the shadow buf */
13071 shadow_bsp->mbs_wmp = bsp->mbs_wmp;
13072 bsp->mbs_wmp = NULL;
13073
13074 /*
13075 * The shadow buf goes on from here in place of the
13076 * original buf.
13077 */
13078 shadow_bsp->mbs_orig_bp = bp;
13079 bp = shadow_bp;
13080 }
13081
13082 SD_INFO(SD_LOG_IO_RMMEDIA, un,
13083 "sd_mapblocksize_iostart: tgt start block:0x%x\n", xp->xb_blkno);
13084 SD_INFO(SD_LOG_IO_RMMEDIA, un,
13085 "sd_mapblocksize_iostart: tgt request len:0x%x\n",
13086 request_bytes);
13087 SD_INFO(SD_LOG_IO_RMMEDIA, un,
13088 "sd_mapblocksize_iostart: shadow buf:0x%x\n", bp);
13089
13090 done:
13091 SD_NEXT_IOSTART(index, un, bp);
13092
13093 SD_TRACE(SD_LOG_IO_RMMEDIA, un,
13094 "sd_mapblocksize_iostart: exit: buf:0x%p\n", bp);
13095 }
13096
13097
13098 /*
13099 * Function: sd_mapblocksize_iodone
13100 *
13101 * Description: Completion side processing for block-size mapping.
13102 *
13103 * Context: May be called under interrupt context
13104 */
13105
13106 static void
13107 sd_mapblocksize_iodone(int index, struct sd_lun *un, struct buf *bp)
13108 {
13109 struct sd_mapblocksize_info *bsp;
13110 struct sd_xbuf *xp;
13111 struct sd_xbuf *orig_xp; /* sd_xbuf for the original buf */
13112 struct buf *orig_bp; /* ptr to the original buf */
13113 offset_t shadow_end;
13114 offset_t request_end;
13115 offset_t shadow_start;
13116 ssize_t copy_offset;
13117 size_t copy_length;
13118 size_t shortfall;
13119 uint_t is_write; /* TRUE if this bp is a WRITE */
13120 uint_t has_wmap; /* TRUE is this bp has a wmap */
13121
13122 ASSERT(un != NULL);
13123 ASSERT(bp != NULL);
13124
13125 SD_TRACE(SD_LOG_IO_RMMEDIA, un,
13126 "sd_mapblocksize_iodone: entry: buf:0x%p\n", bp);
13127
13128 /*
13129 * There is no shadow buf or layer-private data if the target is
13130 * using un->un_sys_blocksize as its block size or if bcount == 0.
13131 */
13132 if ((un->un_tgt_blocksize == DEV_BSIZE && !un->un_f_enable_rmw) ||
13133 (bp->b_bcount == 0)) {
13134 goto exit;
13135 }
13136
13137 xp = SD_GET_XBUF(bp);
13138 ASSERT(xp != NULL);
13139
13140 /* Retrieve the pointer to the layer-private data area from the xbuf. */
13141 bsp = xp->xb_private;
13142
13143 is_write = ((bp->b_flags & B_READ) == 0) ? TRUE : FALSE;
13144 has_wmap = (bsp->mbs_wmp != NULL) ? TRUE : FALSE;
13145
13146 if (is_write) {
13147 /*
13148 * For a WRITE request we must free up the block range that
13149 * we have locked up. This holds regardless of whether this is
13150 * an aligned write request or a read-modify-write request.
13151 */
13152 sd_range_unlock(un, bsp->mbs_wmp);
13153 bsp->mbs_wmp = NULL;
13154 }
13155
13156 if ((bp->b_iodone != (int(*)(struct buf *))sd_mapblocksize_iodone)) {
13157 /*
13158 * An aligned read or write command will have no shadow buf;
13159 * there is not much else to do with it.
13160 */
13161 goto done;
13162 }
13163
13164 orig_bp = bsp->mbs_orig_bp;
13165 ASSERT(orig_bp != NULL);
13166 orig_xp = SD_GET_XBUF(orig_bp);
13167 ASSERT(orig_xp != NULL);
13168 ASSERT(!mutex_owned(SD_MUTEX(un)));
13169
13170 if (!is_write && has_wmap) {
13171 /*
13172 * A READ with a wmap means this is the READ phase of a
13173 * read-modify-write. If an error occurred on the READ then
13174 * we do not proceed with the WRITE phase or copy any data.
13175 * Just release the write maps and return with an error.
13176 */
13177 if ((bp->b_resid != 0) || (bp->b_error != 0)) {
13178 orig_bp->b_resid = orig_bp->b_bcount;
13179 bioerror(orig_bp, bp->b_error);
13180 sd_range_unlock(un, bsp->mbs_wmp);
13181 goto freebuf_done;
13182 }
13183 }
13184
13185 /*
13186 * Here is where we set up to copy the data from the shadow buf
13187 * into the space associated with the original buf.
13188 *
13189 * To deal with the conversion between block sizes, these
13190 * computations treat the data as an array of bytes, with the
13191 * first byte (byte 0) corresponding to the first byte in the
13192 * first block on the disk.
13193 */
13194
13195 /*
13196 * shadow_start and shadow_len indicate the location and size of
13197 * the data returned with the shadow IO request.
13198 */
13199 if (un->un_f_enable_rmw) {
13200 shadow_start = SD_SYSBLOCKS2BYTES((offset_t)xp->xb_blkno);
13201 } else {
13202 shadow_start = SD_TGTBLOCKS2BYTES(un, (offset_t)xp->xb_blkno);
13203 }
13204 shadow_end = shadow_start + bp->b_bcount - bp->b_resid;
13205
13206 /*
13207 * copy_offset gives the offset (in bytes) from the start of the first
13208 * block of the READ request to the beginning of the data. We retrieve
13209 * this value from xb_pktp in the ORIGINAL xbuf, as it has been saved
13210 * there by sd_mapblockize_iostart(). copy_length gives the amount of
13211 * data to be copied (in bytes).
13212 */
13213 copy_offset = bsp->mbs_copy_offset;
13214 if (un->un_f_enable_rmw) {
13215 ASSERT((copy_offset >= 0) &&
13216 (copy_offset < un->un_phy_blocksize));
13217 } else {
13218 ASSERT((copy_offset >= 0) &&
13219 (copy_offset < un->un_tgt_blocksize));
13220 }
13221
13222 copy_length = orig_bp->b_bcount;
13223 request_end = shadow_start + copy_offset + orig_bp->b_bcount;
13224
13225 /*
13226 * Set up the resid and error fields of orig_bp as appropriate.
13227 */
13228 if (shadow_end >= request_end) {
13229 /* We got all the requested data; set resid to zero */
13230 orig_bp->b_resid = 0;
13231 } else {
13232 /*
13233 * We failed to get enough data to fully satisfy the original
13234 * request. Just copy back whatever data we got and set
13235 * up the residual and error code as required.
13236 *
13237 * 'shortfall' is the amount by which the data received with the
13238 * shadow buf has "fallen short" of the requested amount.
13239 */
13240 shortfall = (size_t)(request_end - shadow_end);
13241
13242 if (shortfall > orig_bp->b_bcount) {
13243 /*
13244 * We did not get enough data to even partially
13245 * fulfill the original request. The residual is
13246 * equal to the amount requested.
13247 */
13248 orig_bp->b_resid = orig_bp->b_bcount;
13249 } else {
13250 /*
13251 * We did not get all the data that we requested
13252 * from the device, but we will try to return what
13253 * portion we did get.
13254 */
13255 orig_bp->b_resid = shortfall;
13256 }
13257 ASSERT(copy_length >= orig_bp->b_resid);
13258 copy_length -= orig_bp->b_resid;
13259 }
13260
13261 /* Propagate the error code from the shadow buf to the original buf */
13262 bioerror(orig_bp, bp->b_error);
13263
13264 if (is_write) {
13265 goto freebuf_done; /* No data copying for a WRITE */
13266 }
13267
13268 if (has_wmap) {
13269 /*
13270 * This is a READ command from the READ phase of a
13271 * read-modify-write request. We have to copy the data given
13272 * by the user OVER the data returned by the READ command,
13273 * then convert the command from a READ to a WRITE and send
13274 * it back to the target.
13275 */
13276 bcopy(orig_bp->b_un.b_addr, bp->b_un.b_addr + copy_offset,
13277 copy_length);
13278
13279 bp->b_flags &= ~((int)B_READ); /* Convert to a WRITE */
13280
13281 /*
13282 * Dispatch the WRITE command to the taskq thread, which
13283 * will in turn send the command to the target. When the
13284 * WRITE command completes, we (sd_mapblocksize_iodone())
13285 * will get called again as part of the iodone chain
13286 * processing for it. Note that we will still be dealing
13287 * with the shadow buf at that point.
13288 */
13289 if (taskq_dispatch(sd_wmr_tq, sd_read_modify_write_task, bp,
13290 KM_NOSLEEP) != 0) {
13291 /*
13292 * Dispatch was successful so we are done. Return
13293 * without going any higher up the iodone chain. Do
13294 * not free up any layer-private data until after the
13295 * WRITE completes.
13296 */
13297 return;
13298 }
13299
13300 /*
13301 * Dispatch of the WRITE command failed; set up the error
13302 * condition and send this IO back up the iodone chain.
13303 */
13304 bioerror(orig_bp, EIO);
13305 orig_bp->b_resid = orig_bp->b_bcount;
13306
13307 } else {
13308 /*
13309 * This is a regular READ request (ie, not a RMW). Copy the
13310 * data from the shadow buf into the original buf. The
13311 * copy_offset compensates for any "misalignment" between the
13312 * shadow buf (with its un->un_tgt_blocksize blocks) and the
13313 * original buf (with its un->un_sys_blocksize blocks).
13314 */
13315 bcopy(bp->b_un.b_addr + copy_offset, orig_bp->b_un.b_addr,
13316 copy_length);
13317 }
13318
13319 freebuf_done:
13320
13321 /*
13322 * At this point we still have both the shadow buf AND the original
13323 * buf to deal with, as well as the layer-private data area in each.
13324 * Local variables are as follows:
13325 *
13326 * bp -- points to shadow buf
13327 * xp -- points to xbuf of shadow buf
13328 * bsp -- points to layer-private data area of shadow buf
13329 * orig_bp -- points to original buf
13330 *
13331 * First free the shadow buf and its associated xbuf, then free the
13332 * layer-private data area from the shadow buf. There is no need to
13333 * restore xb_private in the shadow xbuf.
13334 */
13335 sd_shadow_buf_free(bp);
13336 kmem_free(bsp, sizeof (struct sd_mapblocksize_info));
13337
13338 /*
13339 * Now update the local variables to point to the original buf, xbuf,
13340 * and layer-private area.
13341 */
13342 bp = orig_bp;
13343 xp = SD_GET_XBUF(bp);
13344 ASSERT(xp != NULL);
13345 ASSERT(xp == orig_xp);
13346 bsp = xp->xb_private;
13347 ASSERT(bsp != NULL);
13348
13349 done:
13350 /*
13351 * Restore xb_private to whatever it was set to by the next higher
13352 * layer in the chain, then free the layer-private data area.
13353 */
13354 xp->xb_private = bsp->mbs_oprivate;
13355 kmem_free(bsp, sizeof (struct sd_mapblocksize_info));
13356
13357 exit:
13358 SD_TRACE(SD_LOG_IO_RMMEDIA, SD_GET_UN(bp),
13359 "sd_mapblocksize_iodone: calling SD_NEXT_IODONE: buf:0x%p\n", bp);
13360
13361 SD_NEXT_IODONE(index, un, bp);
13362 }
13363
13364
13365 /*
13366 * Function: sd_checksum_iostart
13367 *
13368 * Description: A stub function for a layer that's currently not used.
13369 * For now just a placeholder.
13370 *
13371 * Context: Kernel thread context
13372 */
13373
13374 static void
13375 sd_checksum_iostart(int index, struct sd_lun *un, struct buf *bp)
13376 {
13377 ASSERT(un != NULL);
13378 ASSERT(bp != NULL);
13379 ASSERT(!mutex_owned(SD_MUTEX(un)));
13380 SD_NEXT_IOSTART(index, un, bp);
13381 }
13382
13383
13384 /*
13385 * Function: sd_checksum_iodone
13386 *
13387 * Description: A stub function for a layer that's currently not used.
13388 * For now just a placeholder.
13389 *
13390 * Context: May be called under interrupt context
13391 */
13392
13393 static void
13394 sd_checksum_iodone(int index, struct sd_lun *un, struct buf *bp)
13395 {
13396 ASSERT(un != NULL);
13397 ASSERT(bp != NULL);
13398 ASSERT(!mutex_owned(SD_MUTEX(un)));
13399 SD_NEXT_IODONE(index, un, bp);
13400 }
13401
13402
13403 /*
13404 * Function: sd_checksum_uscsi_iostart
13405 *
13406 * Description: A stub function for a layer that's currently not used.
13407 * For now just a placeholder.
13408 *
13409 * Context: Kernel thread context
13410 */
13411
13412 static void
13413 sd_checksum_uscsi_iostart(int index, struct sd_lun *un, struct buf *bp)
13414 {
13415 ASSERT(un != NULL);
13416 ASSERT(bp != NULL);
13417 ASSERT(!mutex_owned(SD_MUTEX(un)));
13418 SD_NEXT_IOSTART(index, un, bp);
13419 }
13420
13421
13422 /*
13423 * Function: sd_checksum_uscsi_iodone
13424 *
13425 * Description: A stub function for a layer that's currently not used.
13426 * For now just a placeholder.
13427 *
13428 * Context: May be called under interrupt context
13429 */
13430
13431 static void
13432 sd_checksum_uscsi_iodone(int index, struct sd_lun *un, struct buf *bp)
13433 {
13434 ASSERT(un != NULL);
13435 ASSERT(bp != NULL);
13436 ASSERT(!mutex_owned(SD_MUTEX(un)));
13437 SD_NEXT_IODONE(index, un, bp);
13438 }
13439
13440
13441 /*
13442 * Function: sd_pm_iostart
13443 *
13444 * Description: iostart-side routine for Power mangement.
13445 *
13446 * Context: Kernel thread context
13447 */
13448
13449 static void
13450 sd_pm_iostart(int index, struct sd_lun *un, struct buf *bp)
13451 {
13452 ASSERT(un != NULL);
13453 ASSERT(bp != NULL);
13454 ASSERT(!mutex_owned(SD_MUTEX(un)));
13455 ASSERT(!mutex_owned(&un->un_pm_mutex));
13456
13457 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_iostart: entry\n");
13458
13459 if (sd_pm_entry(un) != DDI_SUCCESS) {
13460 /*
13461 * Set up to return the failed buf back up the 'iodone'
13462 * side of the calling chain.
13463 */
13464 bioerror(bp, EIO);
13465 bp->b_resid = bp->b_bcount;
13466
13467 SD_BEGIN_IODONE(index, un, bp);
13468
13469 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_iostart: exit\n");
13470 return;
13471 }
13472
13473 SD_NEXT_IOSTART(index, un, bp);
13474
13475 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_iostart: exit\n");
13476 }
13477
13478
13479 /*
13480 * Function: sd_pm_iodone
13481 *
13482 * Description: iodone-side routine for power mangement.
13483 *
13484 * Context: may be called from interrupt context
13485 */
13486
13487 static void
13488 sd_pm_iodone(int index, struct sd_lun *un, struct buf *bp)
13489 {
13490 ASSERT(un != NULL);
13491 ASSERT(bp != NULL);
13492 ASSERT(!mutex_owned(&un->un_pm_mutex));
13493
13494 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_iodone: entry\n");
13495
13496 /*
13497 * After attach the following flag is only read, so don't
13498 * take the penalty of acquiring a mutex for it.
13499 */
13500 if (un->un_f_pm_is_enabled == TRUE) {
13501 sd_pm_exit(un);
13502 }
13503
13504 SD_NEXT_IODONE(index, un, bp);
13505
13506 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_iodone: exit\n");
13507 }
13508
13509
13510 /*
13511 * Function: sd_core_iostart
13512 *
13513 * Description: Primary driver function for enqueuing buf(9S) structs from
13514 * the system and initiating IO to the target device
13515 *
13516 * Context: Kernel thread context. Can sleep.
13517 *
13518 * Assumptions: - The given xp->xb_blkno is absolute
13519 * (ie, relative to the start of the device).
13520 * - The IO is to be done using the native blocksize of
13521 * the device, as specified in un->un_tgt_blocksize.
13522 */
13523 /* ARGSUSED */
13524 static void
13525 sd_core_iostart(int index, struct sd_lun *un, struct buf *bp)
13526 {
13527 struct sd_xbuf *xp;
13528
13529 ASSERT(un != NULL);
13530 ASSERT(bp != NULL);
13531 ASSERT(!mutex_owned(SD_MUTEX(un)));
13532 ASSERT(bp->b_resid == 0);
13533
13534 SD_TRACE(SD_LOG_IO_CORE, un, "sd_core_iostart: entry: bp:0x%p\n", bp);
13535
13536 xp = SD_GET_XBUF(bp);
13537 ASSERT(xp != NULL);
13538
13539 mutex_enter(SD_MUTEX(un));
13540
13541 /*
13542 * If we are currently in the failfast state, fail any new IO
13543 * that has B_FAILFAST set, then return.
13544 */
13545 if ((bp->b_flags & B_FAILFAST) &&
13546 (un->un_failfast_state == SD_FAILFAST_ACTIVE)) {
13547 mutex_exit(SD_MUTEX(un));
13548 bioerror(bp, EIO);
13549 bp->b_resid = bp->b_bcount;
13550 SD_BEGIN_IODONE(index, un, bp);
13551 return;
13552 }
13553
13554 if (SD_IS_DIRECT_PRIORITY(xp)) {
13555 /*
13556 * Priority command -- transport it immediately.
13557 *
13558 * Note: We may want to assert that USCSI_DIAGNOSE is set,
13559 * because all direct priority commands should be associated
13560 * with error recovery actions which we don't want to retry.
13561 */
13562 sd_start_cmds(un, bp);
13563 } else {
13564 /*
13565 * Normal command -- add it to the wait queue, then start
13566 * transporting commands from the wait queue.
13567 */
13568 sd_add_buf_to_waitq(un, bp);
13569 SD_UPDATE_KSTATS(un, kstat_waitq_enter, bp);
13570 sd_start_cmds(un, NULL);
13571 }
13572
13573 mutex_exit(SD_MUTEX(un));
13574
13575 SD_TRACE(SD_LOG_IO_CORE, un, "sd_core_iostart: exit: bp:0x%p\n", bp);
13576 }
13577
13578
13579 /*
13580 * Function: sd_init_cdb_limits
13581 *
13582 * Description: This is to handle scsi_pkt initialization differences
13583 * between the driver platforms.
13584 *
13585 * Legacy behaviors:
13586 *
13587 * If the block number or the sector count exceeds the
13588 * capabilities of a Group 0 command, shift over to a
13589 * Group 1 command. We don't blindly use Group 1
13590 * commands because a) some drives (CDC Wren IVs) get a
13591 * bit confused, and b) there is probably a fair amount
13592 * of speed difference for a target to receive and decode
13593 * a 10 byte command instead of a 6 byte command.
13594 *
13595 * The xfer time difference of 6 vs 10 byte CDBs is
13596 * still significant so this code is still worthwhile.
13597 * 10 byte CDBs are very inefficient with the fas HBA driver
13598 * and older disks. Each CDB byte took 1 usec with some
13599 * popular disks.
13600 *
13601 * Context: Must be called at attach time
13602 */
13603
13604 static void
13605 sd_init_cdb_limits(struct sd_lun *un)
13606 {
13607 int hba_cdb_limit;
13608
13609 /*
13610 * Use CDB_GROUP1 commands for most devices except for
13611 * parallel SCSI fixed drives in which case we get better
13612 * performance using CDB_GROUP0 commands (where applicable).
13613 */
13614 un->un_mincdb = SD_CDB_GROUP1;
13615 #if !defined(__fibre)
13616 if (!un->un_f_is_fibre && !un->un_f_cfg_is_atapi && !ISROD(un) &&
13617 !un->un_f_has_removable_media) {
13618 un->un_mincdb = SD_CDB_GROUP0;
13619 }
13620 #endif
13621
13622 /*
13623 * Try to read the max-cdb-length supported by HBA.
13624 */
13625 un->un_max_hba_cdb = scsi_ifgetcap(SD_ADDRESS(un), "max-cdb-length", 1);
13626 if (0 >= un->un_max_hba_cdb) {
13627 un->un_max_hba_cdb = CDB_GROUP4;
13628 hba_cdb_limit = SD_CDB_GROUP4;
13629 } else if (0 < un->un_max_hba_cdb &&
13630 un->un_max_hba_cdb < CDB_GROUP1) {
13631 hba_cdb_limit = SD_CDB_GROUP0;
13632 } else if (CDB_GROUP1 <= un->un_max_hba_cdb &&
13633 un->un_max_hba_cdb < CDB_GROUP5) {
13634 hba_cdb_limit = SD_CDB_GROUP1;
13635 } else if (CDB_GROUP5 <= un->un_max_hba_cdb &&
13636 un->un_max_hba_cdb < CDB_GROUP4) {
13637 hba_cdb_limit = SD_CDB_GROUP5;
13638 } else {
13639 hba_cdb_limit = SD_CDB_GROUP4;
13640 }
13641
13642 /*
13643 * Use CDB_GROUP5 commands for removable devices. Use CDB_GROUP4
13644 * commands for fixed disks unless we are building for a 32 bit
13645 * kernel.
13646 */
13647 #ifdef _LP64
13648 un->un_maxcdb = (un->un_f_has_removable_media) ? SD_CDB_GROUP5 :
13649 min(hba_cdb_limit, SD_CDB_GROUP4);
13650 #else
13651 un->un_maxcdb = (un->un_f_has_removable_media) ? SD_CDB_GROUP5 :
13652 min(hba_cdb_limit, SD_CDB_GROUP1);
13653 #endif
13654
13655 un->un_status_len = (int)((un->un_f_arq_enabled == TRUE)
13656 ? sizeof (struct scsi_arq_status) : 1);
13657 if (!ISCD(un))
13658 un->un_cmd_timeout = (ushort_t)sd_io_time;
13659 un->un_uscsi_timeout = ((ISCD(un)) ? 2 : 1) * un->un_cmd_timeout;
13660 }
13661
13662
13663 /*
13664 * Function: sd_initpkt_for_buf
13665 *
13666 * Description: Allocate and initialize for transport a scsi_pkt struct,
13667 * based upon the info specified in the given buf struct.
13668 *
13669 * Assumes the xb_blkno in the request is absolute (ie,
13670 * relative to the start of the device (NOT partition!).
13671 * Also assumes that the request is using the native block
13672 * size of the device (as returned by the READ CAPACITY
13673 * command).
13674 *
13675 * Return Code: SD_PKT_ALLOC_SUCCESS
13676 * SD_PKT_ALLOC_FAILURE
13677 * SD_PKT_ALLOC_FAILURE_NO_DMA
13678 * SD_PKT_ALLOC_FAILURE_CDB_TOO_SMALL
13679 *
13680 * Context: Kernel thread and may be called from software interrupt context
13681 * as part of a sdrunout callback. This function may not block or
13682 * call routines that block
13683 */
13684
13685 static int
13686 sd_initpkt_for_buf(struct buf *bp, struct scsi_pkt **pktpp)
13687 {
13688 struct sd_xbuf *xp;
13689 struct scsi_pkt *pktp = NULL;
13690 struct sd_lun *un;
13691 size_t blockcount;
13692 daddr_t startblock;
13693 int rval;
13694 int cmd_flags;
13695
13696 ASSERT(bp != NULL);
13697 ASSERT(pktpp != NULL);
13698 xp = SD_GET_XBUF(bp);
13699 ASSERT(xp != NULL);
13700 un = SD_GET_UN(bp);
13701 ASSERT(un != NULL);
13702 ASSERT(mutex_owned(SD_MUTEX(un)));
13703 ASSERT(bp->b_resid == 0);
13704
13705 SD_TRACE(SD_LOG_IO_CORE, un,
13706 "sd_initpkt_for_buf: entry: buf:0x%p\n", bp);
13707
13708 mutex_exit(SD_MUTEX(un));
13709
13710 #if defined(__i386) || defined(__amd64) /* DMAFREE for x86 only */
13711 if (xp->xb_pkt_flags & SD_XB_DMA_FREED) {
13712 /*
13713 * Already have a scsi_pkt -- just need DMA resources.
13714 * We must recompute the CDB in case the mapping returns
13715 * a nonzero pkt_resid.
13716 * Note: if this is a portion of a PKT_DMA_PARTIAL transfer
13717 * that is being retried, the unmap/remap of the DMA resouces
13718 * will result in the entire transfer starting over again
13719 * from the very first block.
13720 */
13721 ASSERT(xp->xb_pktp != NULL);
13722 pktp = xp->xb_pktp;
13723 } else {
13724 pktp = NULL;
13725 }
13726 #endif /* __i386 || __amd64 */
13727
13728 startblock = xp->xb_blkno; /* Absolute block num. */
13729 blockcount = SD_BYTES2TGTBLOCKS(un, bp->b_bcount);
13730
13731 cmd_flags = un->un_pkt_flags | (xp->xb_pkt_flags & SD_XB_INITPKT_MASK);
13732
13733 /*
13734 * sd_setup_rw_pkt will determine the appropriate CDB group to use,
13735 * call scsi_init_pkt, and build the CDB.
13736 */
13737 rval = sd_setup_rw_pkt(un, &pktp, bp,
13738 cmd_flags, sdrunout, (caddr_t)un,
13739 startblock, blockcount);
13740
13741 if (rval == 0) {
13742 /*
13743 * Success.
13744 *
13745 * If partial DMA is being used and required for this transfer.
13746 * set it up here.
13747 */
13748 if ((un->un_pkt_flags & PKT_DMA_PARTIAL) != 0 &&
13749 (pktp->pkt_resid != 0)) {
13750
13751 /*
13752 * Save the CDB length and pkt_resid for the
13753 * next xfer
13754 */
13755 xp->xb_dma_resid = pktp->pkt_resid;
13756
13757 /* rezero resid */
13758 pktp->pkt_resid = 0;
13759
13760 } else {
13761 xp->xb_dma_resid = 0;
13762 }
13763
13764 pktp->pkt_flags = un->un_tagflags;
13765 pktp->pkt_time = un->un_cmd_timeout;
13766 pktp->pkt_comp = sdintr;
13767
13768 pktp->pkt_private = bp;
13769 *pktpp = pktp;
13770
13771 SD_TRACE(SD_LOG_IO_CORE, un,
13772 "sd_initpkt_for_buf: exit: buf:0x%p\n", bp);
13773
13774 #if defined(__i386) || defined(__amd64) /* DMAFREE for x86 only */
13775 xp->xb_pkt_flags &= ~SD_XB_DMA_FREED;
13776 #endif
13777
13778 mutex_enter(SD_MUTEX(un));
13779 return (SD_PKT_ALLOC_SUCCESS);
13780
13781 }
13782
13783 /*
13784 * SD_PKT_ALLOC_FAILURE is the only expected failure code
13785 * from sd_setup_rw_pkt.
13786 */
13787 ASSERT(rval == SD_PKT_ALLOC_FAILURE);
13788
13789 if (rval == SD_PKT_ALLOC_FAILURE) {
13790 *pktpp = NULL;
13791 /*
13792 * Set the driver state to RWAIT to indicate the driver
13793 * is waiting on resource allocations. The driver will not
13794 * suspend, pm_suspend, or detatch while the state is RWAIT.
13795 */
13796 mutex_enter(SD_MUTEX(un));
13797 New_state(un, SD_STATE_RWAIT);
13798
13799 SD_ERROR(SD_LOG_IO_CORE, un,
13800 "sd_initpkt_for_buf: No pktp. exit bp:0x%p\n", bp);
13801
13802 if ((bp->b_flags & B_ERROR) != 0) {
13803 return (SD_PKT_ALLOC_FAILURE_NO_DMA);
13804 }
13805 return (SD_PKT_ALLOC_FAILURE);
13806 } else {
13807 /*
13808 * PKT_ALLOC_FAILURE_CDB_TOO_SMALL
13809 *
13810 * This should never happen. Maybe someone messed with the
13811 * kernel's minphys?
13812 */
13813 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
13814 "Request rejected: too large for CDB: "
13815 "lba:0x%08lx len:0x%08lx\n", startblock, blockcount);
13816 SD_ERROR(SD_LOG_IO_CORE, un,
13817 "sd_initpkt_for_buf: No cp. exit bp:0x%p\n", bp);
13818 mutex_enter(SD_MUTEX(un));
13819 return (SD_PKT_ALLOC_FAILURE_CDB_TOO_SMALL);
13820
13821 }
13822 }
13823
13824
13825 /*
13826 * Function: sd_destroypkt_for_buf
13827 *
13828 * Description: Free the scsi_pkt(9S) for the given bp (buf IO processing).
13829 *
13830 * Context: Kernel thread or interrupt context
13831 */
13832
13833 static void
13834 sd_destroypkt_for_buf(struct buf *bp)
13835 {
13836 ASSERT(bp != NULL);
13837 ASSERT(SD_GET_UN(bp) != NULL);
13838
13839 SD_TRACE(SD_LOG_IO_CORE, SD_GET_UN(bp),
13840 "sd_destroypkt_for_buf: entry: buf:0x%p\n", bp);
13841
13842 ASSERT(SD_GET_PKTP(bp) != NULL);
13843 scsi_destroy_pkt(SD_GET_PKTP(bp));
13844
13845 SD_TRACE(SD_LOG_IO_CORE, SD_GET_UN(bp),
13846 "sd_destroypkt_for_buf: exit: buf:0x%p\n", bp);
13847 }
13848
13849 /*
13850 * Function: sd_setup_rw_pkt
13851 *
13852 * Description: Determines appropriate CDB group for the requested LBA
13853 * and transfer length, calls scsi_init_pkt, and builds
13854 * the CDB. Do not use for partial DMA transfers except
13855 * for the initial transfer since the CDB size must
13856 * remain constant.
13857 *
13858 * Context: Kernel thread and may be called from software interrupt
13859 * context as part of a sdrunout callback. This function may not
13860 * block or call routines that block
13861 */
13862
13863
13864 int
13865 sd_setup_rw_pkt(struct sd_lun *un,
13866 struct scsi_pkt **pktpp, struct buf *bp, int flags,
13867 int (*callback)(caddr_t), caddr_t callback_arg,
13868 diskaddr_t lba, uint32_t blockcount)
13869 {
13870 struct scsi_pkt *return_pktp;
13871 union scsi_cdb *cdbp;
13872 struct sd_cdbinfo *cp = NULL;
13873 int i;
13874
13875 /*
13876 * See which size CDB to use, based upon the request.
13877 */
13878 for (i = un->un_mincdb; i <= un->un_maxcdb; i++) {
13879
13880 /*
13881 * Check lba and block count against sd_cdbtab limits.
13882 * In the partial DMA case, we have to use the same size
13883 * CDB for all the transfers. Check lba + blockcount
13884 * against the max LBA so we know that segment of the
13885 * transfer can use the CDB we select.
13886 */
13887 if ((lba + blockcount - 1 <= sd_cdbtab[i].sc_maxlba) &&
13888 (blockcount <= sd_cdbtab[i].sc_maxlen)) {
13889
13890 /*
13891 * The command will fit into the CDB type
13892 * specified by sd_cdbtab[i].
13893 */
13894 cp = sd_cdbtab + i;
13895
13896 /*
13897 * Call scsi_init_pkt so we can fill in the
13898 * CDB.
13899 */
13900 return_pktp = scsi_init_pkt(SD_ADDRESS(un), *pktpp,
13901 bp, cp->sc_grpcode, un->un_status_len, 0,
13902 flags, callback, callback_arg);
13903
13904 if (return_pktp != NULL) {
13905
13906 /*
13907 * Return new value of pkt
13908 */
13909 *pktpp = return_pktp;
13910
13911 /*
13912 * To be safe, zero the CDB insuring there is
13913 * no leftover data from a previous command.
13914 */
13915 bzero(return_pktp->pkt_cdbp, cp->sc_grpcode);
13916
13917 /*
13918 * Handle partial DMA mapping
13919 */
13920 if (return_pktp->pkt_resid != 0) {
13921
13922 /*
13923 * Not going to xfer as many blocks as
13924 * originally expected
13925 */
13926 blockcount -=
13927 SD_BYTES2TGTBLOCKS(un,
13928 return_pktp->pkt_resid);
13929 }
13930
13931 cdbp = (union scsi_cdb *)return_pktp->pkt_cdbp;
13932
13933 /*
13934 * Set command byte based on the CDB
13935 * type we matched.
13936 */
13937 cdbp->scc_cmd = cp->sc_grpmask |
13938 ((bp->b_flags & B_READ) ?
13939 SCMD_READ : SCMD_WRITE);
13940
13941 SD_FILL_SCSI1_LUN(un, return_pktp);
13942
13943 /*
13944 * Fill in LBA and length
13945 */
13946 ASSERT((cp->sc_grpcode == CDB_GROUP1) ||
13947 (cp->sc_grpcode == CDB_GROUP4) ||
13948 (cp->sc_grpcode == CDB_GROUP0) ||
13949 (cp->sc_grpcode == CDB_GROUP5));
13950
13951 if (cp->sc_grpcode == CDB_GROUP1) {
13952 FORMG1ADDR(cdbp, lba);
13953 FORMG1COUNT(cdbp, blockcount);
13954 return (0);
13955 } else if (cp->sc_grpcode == CDB_GROUP4) {
13956 FORMG4LONGADDR(cdbp, lba);
13957 FORMG4COUNT(cdbp, blockcount);
13958 return (0);
13959 } else if (cp->sc_grpcode == CDB_GROUP0) {
13960 FORMG0ADDR(cdbp, lba);
13961 FORMG0COUNT(cdbp, blockcount);
13962 return (0);
13963 } else if (cp->sc_grpcode == CDB_GROUP5) {
13964 FORMG5ADDR(cdbp, lba);
13965 FORMG5COUNT(cdbp, blockcount);
13966 return (0);
13967 }
13968
13969 /*
13970 * It should be impossible to not match one
13971 * of the CDB types above, so we should never
13972 * reach this point. Set the CDB command byte
13973 * to test-unit-ready to avoid writing
13974 * to somewhere we don't intend.
13975 */
13976 cdbp->scc_cmd = SCMD_TEST_UNIT_READY;
13977 return (SD_PKT_ALLOC_FAILURE_CDB_TOO_SMALL);
13978 } else {
13979 /*
13980 * Couldn't get scsi_pkt
13981 */
13982 return (SD_PKT_ALLOC_FAILURE);
13983 }
13984 }
13985 }
13986
13987 /*
13988 * None of the available CDB types were suitable. This really
13989 * should never happen: on a 64 bit system we support
13990 * READ16/WRITE16 which will hold an entire 64 bit disk address
13991 * and on a 32 bit system we will refuse to bind to a device
13992 * larger than 2TB so addresses will never be larger than 32 bits.
13993 */
13994 return (SD_PKT_ALLOC_FAILURE_CDB_TOO_SMALL);
13995 }
13996
13997 /*
13998 * Function: sd_setup_next_rw_pkt
13999 *
14000 * Description: Setup packet for partial DMA transfers, except for the
14001 * initial transfer. sd_setup_rw_pkt should be used for
14002 * the initial transfer.
14003 *
14004 * Context: Kernel thread and may be called from interrupt context.
14005 */
14006
14007 int
14008 sd_setup_next_rw_pkt(struct sd_lun *un,
14009 struct scsi_pkt *pktp, struct buf *bp,
14010 diskaddr_t lba, uint32_t blockcount)
14011 {
14012 uchar_t com;
14013 union scsi_cdb *cdbp;
14014 uchar_t cdb_group_id;
14015
14016 ASSERT(pktp != NULL);
14017 ASSERT(pktp->pkt_cdbp != NULL);
14018
14019 cdbp = (union scsi_cdb *)pktp->pkt_cdbp;
14020 com = cdbp->scc_cmd;
14021 cdb_group_id = CDB_GROUPID(com);
14022
14023 ASSERT((cdb_group_id == CDB_GROUPID_0) ||
14024 (cdb_group_id == CDB_GROUPID_1) ||
14025 (cdb_group_id == CDB_GROUPID_4) ||
14026 (cdb_group_id == CDB_GROUPID_5));
14027
14028 /*
14029 * Move pkt to the next portion of the xfer.
14030 * func is NULL_FUNC so we do not have to release
14031 * the disk mutex here.
14032 */
14033 if (scsi_init_pkt(SD_ADDRESS(un), pktp, bp, 0, 0, 0, 0,
14034 NULL_FUNC, NULL) == pktp) {
14035 /* Success. Handle partial DMA */
14036 if (pktp->pkt_resid != 0) {
14037 blockcount -=
14038 SD_BYTES2TGTBLOCKS(un, pktp->pkt_resid);
14039 }
14040
14041 cdbp->scc_cmd = com;
14042 SD_FILL_SCSI1_LUN(un, pktp);
14043 if (cdb_group_id == CDB_GROUPID_1) {
14044 FORMG1ADDR(cdbp, lba);
14045 FORMG1COUNT(cdbp, blockcount);
14046 return (0);
14047 } else if (cdb_group_id == CDB_GROUPID_4) {
14048 FORMG4LONGADDR(cdbp, lba);
14049 FORMG4COUNT(cdbp, blockcount);
14050 return (0);
14051 } else if (cdb_group_id == CDB_GROUPID_0) {
14052 FORMG0ADDR(cdbp, lba);
14053 FORMG0COUNT(cdbp, blockcount);
14054 return (0);
14055 } else if (cdb_group_id == CDB_GROUPID_5) {
14056 FORMG5ADDR(cdbp, lba);
14057 FORMG5COUNT(cdbp, blockcount);
14058 return (0);
14059 }
14060
14061 /* Unreachable */
14062 return (SD_PKT_ALLOC_FAILURE_CDB_TOO_SMALL);
14063 }
14064
14065 /*
14066 * Error setting up next portion of cmd transfer.
14067 * Something is definitely very wrong and this
14068 * should not happen.
14069 */
14070 return (SD_PKT_ALLOC_FAILURE);
14071 }
14072
14073 /*
14074 * Function: sd_initpkt_for_uscsi
14075 *
14076 * Description: Allocate and initialize for transport a scsi_pkt struct,
14077 * based upon the info specified in the given uscsi_cmd struct.
14078 *
14079 * Return Code: SD_PKT_ALLOC_SUCCESS
14080 * SD_PKT_ALLOC_FAILURE
14081 * SD_PKT_ALLOC_FAILURE_NO_DMA
14082 * SD_PKT_ALLOC_FAILURE_CDB_TOO_SMALL
14083 *
14084 * Context: Kernel thread and may be called from software interrupt context
14085 * as part of a sdrunout callback. This function may not block or
14086 * call routines that block
14087 */
14088
14089 static int
14090 sd_initpkt_for_uscsi(struct buf *bp, struct scsi_pkt **pktpp)
14091 {
14092 struct uscsi_cmd *uscmd;
14093 struct sd_xbuf *xp;
14094 struct scsi_pkt *pktp;
14095 struct sd_lun *un;
14096 uint32_t flags = 0;
14097
14098 ASSERT(bp != NULL);
14099 ASSERT(pktpp != NULL);
14100 xp = SD_GET_XBUF(bp);
14101 ASSERT(xp != NULL);
14102 un = SD_GET_UN(bp);
14103 ASSERT(un != NULL);
14104 ASSERT(mutex_owned(SD_MUTEX(un)));
14105
14106 /* The pointer to the uscsi_cmd struct is expected in xb_pktinfo */
14107 uscmd = (struct uscsi_cmd *)xp->xb_pktinfo;
14108 ASSERT(uscmd != NULL);
14109
14110 SD_TRACE(SD_LOG_IO_CORE, un,
14111 "sd_initpkt_for_uscsi: entry: buf:0x%p\n", bp);
14112
14113 /*
14114 * Allocate the scsi_pkt for the command.
14115 * Note: If PKT_DMA_PARTIAL flag is set, scsi_vhci binds a path
14116 * during scsi_init_pkt time and will continue to use the
14117 * same path as long as the same scsi_pkt is used without
14118 * intervening scsi_dma_free(). Since uscsi command does
14119 * not call scsi_dmafree() before retry failed command, it
14120 * is necessary to make sure PKT_DMA_PARTIAL flag is NOT
14121 * set such that scsi_vhci can use other available path for
14122 * retry. Besides, ucsci command does not allow DMA breakup,
14123 * so there is no need to set PKT_DMA_PARTIAL flag.
14124 */
14125 if (uscmd->uscsi_rqlen > SENSE_LENGTH) {
14126 pktp = scsi_init_pkt(SD_ADDRESS(un), NULL,
14127 ((bp->b_bcount != 0) ? bp : NULL), uscmd->uscsi_cdblen,
14128 ((int)(uscmd->uscsi_rqlen) + sizeof (struct scsi_arq_status)
14129 - sizeof (struct scsi_extended_sense)), 0,
14130 (un->un_pkt_flags & ~PKT_DMA_PARTIAL) | PKT_XARQ,
14131 sdrunout, (caddr_t)un);
14132 } else {
14133 pktp = scsi_init_pkt(SD_ADDRESS(un), NULL,
14134 ((bp->b_bcount != 0) ? bp : NULL), uscmd->uscsi_cdblen,
14135 sizeof (struct scsi_arq_status), 0,
14136 (un->un_pkt_flags & ~PKT_DMA_PARTIAL),
14137 sdrunout, (caddr_t)un);
14138 }
14139
14140 if (pktp == NULL) {
14141 *pktpp = NULL;
14142 /*
14143 * Set the driver state to RWAIT to indicate the driver
14144 * is waiting on resource allocations. The driver will not
14145 * suspend, pm_suspend, or detatch while the state is RWAIT.
14146 */
14147 New_state(un, SD_STATE_RWAIT);
14148
14149 SD_ERROR(SD_LOG_IO_CORE, un,
14150 "sd_initpkt_for_uscsi: No pktp. exit bp:0x%p\n", bp);
14151
14152 if ((bp->b_flags & B_ERROR) != 0) {
14153 return (SD_PKT_ALLOC_FAILURE_NO_DMA);
14154 }
14155 return (SD_PKT_ALLOC_FAILURE);
14156 }
14157
14158 /*
14159 * We do not do DMA breakup for USCSI commands, so return failure
14160 * here if all the needed DMA resources were not allocated.
14161 */
14162 if ((un->un_pkt_flags & PKT_DMA_PARTIAL) &&
14163 (bp->b_bcount != 0) && (pktp->pkt_resid != 0)) {
14164 scsi_destroy_pkt(pktp);
14165 SD_ERROR(SD_LOG_IO_CORE, un, "sd_initpkt_for_uscsi: "
14166 "No partial DMA for USCSI. exit: buf:0x%p\n", bp);
14167 return (SD_PKT_ALLOC_FAILURE_PKT_TOO_SMALL);
14168 }
14169
14170 /* Init the cdb from the given uscsi struct */
14171 (void) scsi_setup_cdb((union scsi_cdb *)pktp->pkt_cdbp,
14172 uscmd->uscsi_cdb[0], 0, 0, 0);
14173
14174 SD_FILL_SCSI1_LUN(un, pktp);
14175
14176 /*
14177 * Set up the optional USCSI flags. See the uscsi (7I) man page
14178 * for listing of the supported flags.
14179 */
14180
14181 if (uscmd->uscsi_flags & USCSI_SILENT) {
14182 flags |= FLAG_SILENT;
14183 }
14184
14185 if (uscmd->uscsi_flags & USCSI_DIAGNOSE) {
14186 flags |= FLAG_DIAGNOSE;
14187 }
14188
14189 if (uscmd->uscsi_flags & USCSI_ISOLATE) {
14190 flags |= FLAG_ISOLATE;
14191 }
14192
14193 if (un->un_f_is_fibre == FALSE) {
14194 if (uscmd->uscsi_flags & USCSI_RENEGOT) {
14195 flags |= FLAG_RENEGOTIATE_WIDE_SYNC;
14196 }
14197 }
14198
14199 /*
14200 * Set the pkt flags here so we save time later.
14201 * Note: These flags are NOT in the uscsi man page!!!
14202 */
14203 if (uscmd->uscsi_flags & USCSI_HEAD) {
14204 flags |= FLAG_HEAD;
14205 }
14206
14207 if (uscmd->uscsi_flags & USCSI_NOINTR) {
14208 flags |= FLAG_NOINTR;
14209 }
14210
14211 /*
14212 * For tagged queueing, things get a bit complicated.
14213 * Check first for head of queue and last for ordered queue.
14214 * If neither head nor order, use the default driver tag flags.
14215 */
14216 if ((uscmd->uscsi_flags & USCSI_NOTAG) == 0) {
14217 if (uscmd->uscsi_flags & USCSI_HTAG) {
14218 flags |= FLAG_HTAG;
14219 } else if (uscmd->uscsi_flags & USCSI_OTAG) {
14220 flags |= FLAG_OTAG;
14221 } else {
14222 flags |= un->un_tagflags & FLAG_TAGMASK;
14223 }
14224 }
14225
14226 if (uscmd->uscsi_flags & USCSI_NODISCON) {
14227 flags = (flags & ~FLAG_TAGMASK) | FLAG_NODISCON;
14228 }
14229
14230 pktp->pkt_flags = flags;
14231
14232 /* Transfer uscsi information to scsi_pkt */
14233 (void) scsi_uscsi_pktinit(uscmd, pktp);
14234
14235 /* Copy the caller's CDB into the pkt... */
14236 bcopy(uscmd->uscsi_cdb, pktp->pkt_cdbp, uscmd->uscsi_cdblen);
14237
14238 if (uscmd->uscsi_timeout == 0) {
14239 pktp->pkt_time = un->un_uscsi_timeout;
14240 } else {
14241 pktp->pkt_time = uscmd->uscsi_timeout;
14242 }
14243
14244 /* need it later to identify USCSI request in sdintr */
14245 xp->xb_pkt_flags |= SD_XB_USCSICMD;
14246
14247 xp->xb_sense_resid = uscmd->uscsi_rqresid;
14248
14249 pktp->pkt_private = bp;
14250 pktp->pkt_comp = sdintr;
14251 *pktpp = pktp;
14252
14253 SD_TRACE(SD_LOG_IO_CORE, un,
14254 "sd_initpkt_for_uscsi: exit: buf:0x%p\n", bp);
14255
14256 return (SD_PKT_ALLOC_SUCCESS);
14257 }
14258
14259
14260 /*
14261 * Function: sd_destroypkt_for_uscsi
14262 *
14263 * Description: Free the scsi_pkt(9S) struct for the given bp, for uscsi
14264 * IOs.. Also saves relevant info into the associated uscsi_cmd
14265 * struct.
14266 *
14267 * Context: May be called under interrupt context
14268 */
14269
14270 static void
14271 sd_destroypkt_for_uscsi(struct buf *bp)
14272 {
14273 struct uscsi_cmd *uscmd;
14274 struct sd_xbuf *xp;
14275 struct scsi_pkt *pktp;
14276 struct sd_lun *un;
14277 struct sd_uscsi_info *suip;
14278
14279 ASSERT(bp != NULL);
14280 xp = SD_GET_XBUF(bp);
14281 ASSERT(xp != NULL);
14282 un = SD_GET_UN(bp);
14283 ASSERT(un != NULL);
14284 ASSERT(!mutex_owned(SD_MUTEX(un)));
14285 pktp = SD_GET_PKTP(bp);
14286 ASSERT(pktp != NULL);
14287
14288 SD_TRACE(SD_LOG_IO_CORE, un,
14289 "sd_destroypkt_for_uscsi: entry: buf:0x%p\n", bp);
14290
14291 /* The pointer to the uscsi_cmd struct is expected in xb_pktinfo */
14292 uscmd = (struct uscsi_cmd *)xp->xb_pktinfo;
14293 ASSERT(uscmd != NULL);
14294
14295 /* Save the status and the residual into the uscsi_cmd struct */
14296 uscmd->uscsi_status = ((*(pktp)->pkt_scbp) & STATUS_MASK);
14297 uscmd->uscsi_resid = bp->b_resid;
14298
14299 /* Transfer scsi_pkt information to uscsi */
14300 (void) scsi_uscsi_pktfini(pktp, uscmd);
14301
14302 /*
14303 * If enabled, copy any saved sense data into the area specified
14304 * by the uscsi command.
14305 */
14306 if (((uscmd->uscsi_flags & USCSI_RQENABLE) != 0) &&
14307 (uscmd->uscsi_rqlen != 0) && (uscmd->uscsi_rqbuf != NULL)) {
14308 /*
14309 * Note: uscmd->uscsi_rqbuf should always point to a buffer
14310 * at least SENSE_LENGTH bytes in size (see sd_send_scsi_cmd())
14311 */
14312 uscmd->uscsi_rqstatus = xp->xb_sense_status;
14313 uscmd->uscsi_rqresid = xp->xb_sense_resid;
14314 if (uscmd->uscsi_rqlen > SENSE_LENGTH) {
14315 bcopy(xp->xb_sense_data, uscmd->uscsi_rqbuf,
14316 MAX_SENSE_LENGTH);
14317 } else {
14318 bcopy(xp->xb_sense_data, uscmd->uscsi_rqbuf,
14319 SENSE_LENGTH);
14320 }
14321 }
14322 /*
14323 * The following assignments are for SCSI FMA.
14324 */
14325 ASSERT(xp->xb_private != NULL);
14326 suip = (struct sd_uscsi_info *)xp->xb_private;
14327 suip->ui_pkt_reason = pktp->pkt_reason;
14328 suip->ui_pkt_state = pktp->pkt_state;
14329 suip->ui_pkt_statistics = pktp->pkt_statistics;
14330 suip->ui_lba = (uint64_t)SD_GET_BLKNO(bp);
14331
14332 /* We are done with the scsi_pkt; free it now */
14333 ASSERT(SD_GET_PKTP(bp) != NULL);
14334 scsi_destroy_pkt(SD_GET_PKTP(bp));
14335
14336 SD_TRACE(SD_LOG_IO_CORE, un,
14337 "sd_destroypkt_for_uscsi: exit: buf:0x%p\n", bp);
14338 }
14339
14340
14341 /*
14342 * Function: sd_bioclone_alloc
14343 *
14344 * Description: Allocate a buf(9S) and init it as per the given buf
14345 * and the various arguments. The associated sd_xbuf
14346 * struct is (nearly) duplicated. The struct buf *bp
14347 * argument is saved in new_xp->xb_private.
14348 *
14349 * Arguments: bp - ptr the the buf(9S) to be "shadowed"
14350 * datalen - size of data area for the shadow bp
14351 * blkno - starting LBA
14352 * func - function pointer for b_iodone in the shadow buf. (May
14353 * be NULL if none.)
14354 *
14355 * Return Code: Pointer to allocates buf(9S) struct
14356 *
14357 * Context: Can sleep.
14358 */
14359
14360 static struct buf *
14361 sd_bioclone_alloc(struct buf *bp, size_t datalen,
14362 daddr_t blkno, int (*func)(struct buf *))
14363 {
14364 struct sd_lun *un;
14365 struct sd_xbuf *xp;
14366 struct sd_xbuf *new_xp;
14367 struct buf *new_bp;
14368
14369 ASSERT(bp != NULL);
14370 xp = SD_GET_XBUF(bp);
14371 ASSERT(xp != NULL);
14372 un = SD_GET_UN(bp);
14373 ASSERT(un != NULL);
14374 ASSERT(!mutex_owned(SD_MUTEX(un)));
14375
14376 new_bp = bioclone(bp, 0, datalen, SD_GET_DEV(un), blkno, func,
14377 NULL, KM_SLEEP);
14378
14379 new_bp->b_lblkno = blkno;
14380
14381 /*
14382 * Allocate an xbuf for the shadow bp and copy the contents of the
14383 * original xbuf into it.
14384 */
14385 new_xp = kmem_alloc(sizeof (struct sd_xbuf), KM_SLEEP);
14386 bcopy(xp, new_xp, sizeof (struct sd_xbuf));
14387
14388 /*
14389 * The given bp is automatically saved in the xb_private member
14390 * of the new xbuf. Callers are allowed to depend on this.
14391 */
14392 new_xp->xb_private = bp;
14393
14394 new_bp->b_private = new_xp;
14395
14396 return (new_bp);
14397 }
14398
14399 /*
14400 * Function: sd_shadow_buf_alloc
14401 *
14402 * Description: Allocate a buf(9S) and init it as per the given buf
14403 * and the various arguments. The associated sd_xbuf
14404 * struct is (nearly) duplicated. The struct buf *bp
14405 * argument is saved in new_xp->xb_private.
14406 *
14407 * Arguments: bp - ptr the the buf(9S) to be "shadowed"
14408 * datalen - size of data area for the shadow bp
14409 * bflags - B_READ or B_WRITE (pseudo flag)
14410 * blkno - starting LBA
14411 * func - function pointer for b_iodone in the shadow buf. (May
14412 * be NULL if none.)
14413 *
14414 * Return Code: Pointer to allocates buf(9S) struct
14415 *
14416 * Context: Can sleep.
14417 */
14418
14419 static struct buf *
14420 sd_shadow_buf_alloc(struct buf *bp, size_t datalen, uint_t bflags,
14421 daddr_t blkno, int (*func)(struct buf *))
14422 {
14423 struct sd_lun *un;
14424 struct sd_xbuf *xp;
14425 struct sd_xbuf *new_xp;
14426 struct buf *new_bp;
14427
14428 ASSERT(bp != NULL);
14429 xp = SD_GET_XBUF(bp);
14430 ASSERT(xp != NULL);
14431 un = SD_GET_UN(bp);
14432 ASSERT(un != NULL);
14433 ASSERT(!mutex_owned(SD_MUTEX(un)));
14434
14435 if (bp->b_flags & (B_PAGEIO | B_PHYS)) {
14436 bp_mapin(bp);
14437 }
14438
14439 bflags &= (B_READ | B_WRITE);
14440 #if defined(__i386) || defined(__amd64)
14441 new_bp = getrbuf(KM_SLEEP);
14442 new_bp->b_un.b_addr = kmem_zalloc(datalen, KM_SLEEP);
14443 new_bp->b_bcount = datalen;
14444 new_bp->b_flags = bflags |
14445 (bp->b_flags & ~(B_PAGEIO | B_PHYS | B_REMAPPED | B_SHADOW));
14446 #else
14447 new_bp = scsi_alloc_consistent_buf(SD_ADDRESS(un), NULL,
14448 datalen, bflags, SLEEP_FUNC, NULL);
14449 #endif
14450 new_bp->av_forw = NULL;
14451 new_bp->av_back = NULL;
14452 new_bp->b_dev = bp->b_dev;
14453 new_bp->b_blkno = blkno;
14454 new_bp->b_iodone = func;
14455 new_bp->b_edev = bp->b_edev;
14456 new_bp->b_resid = 0;
14457
14458 /* We need to preserve the B_FAILFAST flag */
14459 if (bp->b_flags & B_FAILFAST) {
14460 new_bp->b_flags |= B_FAILFAST;
14461 }
14462
14463 /*
14464 * Allocate an xbuf for the shadow bp and copy the contents of the
14465 * original xbuf into it.
14466 */
14467 new_xp = kmem_alloc(sizeof (struct sd_xbuf), KM_SLEEP);
14468 bcopy(xp, new_xp, sizeof (struct sd_xbuf));
14469
14470 /* Need later to copy data between the shadow buf & original buf! */
14471 new_xp->xb_pkt_flags |= PKT_CONSISTENT;
14472
14473 /*
14474 * The given bp is automatically saved in the xb_private member
14475 * of the new xbuf. Callers are allowed to depend on this.
14476 */
14477 new_xp->xb_private = bp;
14478
14479 new_bp->b_private = new_xp;
14480
14481 return (new_bp);
14482 }
14483
14484 /*
14485 * Function: sd_bioclone_free
14486 *
14487 * Description: Deallocate a buf(9S) that was used for 'shadow' IO operations
14488 * in the larger than partition operation.
14489 *
14490 * Context: May be called under interrupt context
14491 */
14492
14493 static void
14494 sd_bioclone_free(struct buf *bp)
14495 {
14496 struct sd_xbuf *xp;
14497
14498 ASSERT(bp != NULL);
14499 xp = SD_GET_XBUF(bp);
14500 ASSERT(xp != NULL);
14501
14502 /*
14503 * Call bp_mapout() before freeing the buf, in case a lower
14504 * layer or HBA had done a bp_mapin(). we must do this here
14505 * as we are the "originator" of the shadow buf.
14506 */
14507 bp_mapout(bp);
14508
14509 /*
14510 * Null out b_iodone before freeing the bp, to ensure that the driver
14511 * never gets confused by a stale value in this field. (Just a little
14512 * extra defensiveness here.)
14513 */
14514 bp->b_iodone = NULL;
14515
14516 freerbuf(bp);
14517
14518 kmem_free(xp, sizeof (struct sd_xbuf));
14519 }
14520
14521 /*
14522 * Function: sd_shadow_buf_free
14523 *
14524 * Description: Deallocate a buf(9S) that was used for 'shadow' IO operations.
14525 *
14526 * Context: May be called under interrupt context
14527 */
14528
14529 static void
14530 sd_shadow_buf_free(struct buf *bp)
14531 {
14532 struct sd_xbuf *xp;
14533
14534 ASSERT(bp != NULL);
14535 xp = SD_GET_XBUF(bp);
14536 ASSERT(xp != NULL);
14537
14538 #if defined(__sparc)
14539 /*
14540 * Call bp_mapout() before freeing the buf, in case a lower
14541 * layer or HBA had done a bp_mapin(). we must do this here
14542 * as we are the "originator" of the shadow buf.
14543 */
14544 bp_mapout(bp);
14545 #endif
14546
14547 /*
14548 * Null out b_iodone before freeing the bp, to ensure that the driver
14549 * never gets confused by a stale value in this field. (Just a little
14550 * extra defensiveness here.)
14551 */
14552 bp->b_iodone = NULL;
14553
14554 #if defined(__i386) || defined(__amd64)
14555 kmem_free(bp->b_un.b_addr, bp->b_bcount);
14556 freerbuf(bp);
14557 #else
14558 scsi_free_consistent_buf(bp);
14559 #endif
14560
14561 kmem_free(xp, sizeof (struct sd_xbuf));
14562 }
14563
14564
14565 /*
14566 * Function: sd_print_transport_rejected_message
14567 *
14568 * Description: This implements the ludicrously complex rules for printing
14569 * a "transport rejected" message. This is to address the
14570 * specific problem of having a flood of this error message
14571 * produced when a failover occurs.
14572 *
14573 * Context: Any.
14574 */
14575
14576 static void
14577 sd_print_transport_rejected_message(struct sd_lun *un, struct sd_xbuf *xp,
14578 int code)
14579 {
14580 ASSERT(un != NULL);
14581 ASSERT(mutex_owned(SD_MUTEX(un)));
14582 ASSERT(xp != NULL);
14583
14584 /*
14585 * Print the "transport rejected" message under the following
14586 * conditions:
14587 *
14588 * - Whenever the SD_LOGMASK_DIAG bit of sd_level_mask is set
14589 * - The error code from scsi_transport() is NOT a TRAN_FATAL_ERROR.
14590 * - If the error code IS a TRAN_FATAL_ERROR, then the message is
14591 * printed the FIRST time a TRAN_FATAL_ERROR is returned from
14592 * scsi_transport(9F) (which indicates that the target might have
14593 * gone off-line). This uses the un->un_tran_fatal_count
14594 * count, which is incremented whenever a TRAN_FATAL_ERROR is
14595 * received, and reset to zero whenver a TRAN_ACCEPT is returned
14596 * from scsi_transport().
14597 *
14598 * The FLAG_SILENT in the scsi_pkt must be CLEARED in ALL of
14599 * the preceeding cases in order for the message to be printed.
14600 */
14601 if (((xp->xb_pktp->pkt_flags & FLAG_SILENT) == 0) &&
14602 (SD_FM_LOG(un) == SD_FM_LOG_NSUP)) {
14603 if ((sd_level_mask & SD_LOGMASK_DIAG) ||
14604 (code != TRAN_FATAL_ERROR) ||
14605 (un->un_tran_fatal_count == 1)) {
14606 switch (code) {
14607 case TRAN_BADPKT:
14608 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
14609 "transport rejected bad packet\n");
14610 break;
14611 case TRAN_FATAL_ERROR:
14612 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
14613 "transport rejected fatal error\n");
14614 break;
14615 default:
14616 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
14617 "transport rejected (%d)\n", code);
14618 break;
14619 }
14620 }
14621 }
14622 }
14623
14624
14625 /*
14626 * Function: sd_add_buf_to_waitq
14627 *
14628 * Description: Add the given buf(9S) struct to the wait queue for the
14629 * instance. If sorting is enabled, then the buf is added
14630 * to the queue via an elevator sort algorithm (a la
14631 * disksort(9F)). The SD_GET_BLKNO(bp) is used as the sort key.
14632 * If sorting is not enabled, then the buf is just added
14633 * to the end of the wait queue.
14634 *
14635 * Return Code: void
14636 *
14637 * Context: Does not sleep/block, therefore technically can be called
14638 * from any context. However if sorting is enabled then the
14639 * execution time is indeterminate, and may take long if
14640 * the wait queue grows large.
14641 */
14642
14643 static void
14644 sd_add_buf_to_waitq(struct sd_lun *un, struct buf *bp)
14645 {
14646 struct buf *ap;
14647
14648 ASSERT(bp != NULL);
14649 ASSERT(un != NULL);
14650 ASSERT(mutex_owned(SD_MUTEX(un)));
14651
14652 /* If the queue is empty, add the buf as the only entry & return. */
14653 if (un->un_waitq_headp == NULL) {
14654 ASSERT(un->un_waitq_tailp == NULL);
14655 un->un_waitq_headp = un->un_waitq_tailp = bp;
14656 bp->av_forw = NULL;
14657 return;
14658 }
14659
14660 ASSERT(un->un_waitq_tailp != NULL);
14661
14662 /*
14663 * If sorting is disabled, just add the buf to the tail end of
14664 * the wait queue and return.
14665 */
14666 if (un->un_f_disksort_disabled || un->un_f_enable_rmw) {
14667 un->un_waitq_tailp->av_forw = bp;
14668 un->un_waitq_tailp = bp;
14669 bp->av_forw = NULL;
14670 return;
14671 }
14672
14673 /*
14674 * Sort thru the list of requests currently on the wait queue
14675 * and add the new buf request at the appropriate position.
14676 *
14677 * The un->un_waitq_headp is an activity chain pointer on which
14678 * we keep two queues, sorted in ascending SD_GET_BLKNO() order. The
14679 * first queue holds those requests which are positioned after
14680 * the current SD_GET_BLKNO() (in the first request); the second holds
14681 * requests which came in after their SD_GET_BLKNO() number was passed.
14682 * Thus we implement a one way scan, retracting after reaching
14683 * the end of the drive to the first request on the second
14684 * queue, at which time it becomes the first queue.
14685 * A one-way scan is natural because of the way UNIX read-ahead
14686 * blocks are allocated.
14687 *
14688 * If we lie after the first request, then we must locate the
14689 * second request list and add ourselves to it.
14690 */
14691 ap = un->un_waitq_headp;
14692 if (SD_GET_BLKNO(bp) < SD_GET_BLKNO(ap)) {
14693 while (ap->av_forw != NULL) {
14694 /*
14695 * Look for an "inversion" in the (normally
14696 * ascending) block numbers. This indicates
14697 * the start of the second request list.
14698 */
14699 if (SD_GET_BLKNO(ap->av_forw) < SD_GET_BLKNO(ap)) {
14700 /*
14701 * Search the second request list for the
14702 * first request at a larger block number.
14703 * We go before that; however if there is
14704 * no such request, we go at the end.
14705 */
14706 do {
14707 if (SD_GET_BLKNO(bp) <
14708 SD_GET_BLKNO(ap->av_forw)) {
14709 goto insert;
14710 }
14711 ap = ap->av_forw;
14712 } while (ap->av_forw != NULL);
14713 goto insert; /* after last */
14714 }
14715 ap = ap->av_forw;
14716 }
14717
14718 /*
14719 * No inversions... we will go after the last, and
14720 * be the first request in the second request list.
14721 */
14722 goto insert;
14723 }
14724
14725 /*
14726 * Request is at/after the current request...
14727 * sort in the first request list.
14728 */
14729 while (ap->av_forw != NULL) {
14730 /*
14731 * We want to go after the current request (1) if
14732 * there is an inversion after it (i.e. it is the end
14733 * of the first request list), or (2) if the next
14734 * request is a larger block no. than our request.
14735 */
14736 if ((SD_GET_BLKNO(ap->av_forw) < SD_GET_BLKNO(ap)) ||
14737 (SD_GET_BLKNO(bp) < SD_GET_BLKNO(ap->av_forw))) {
14738 goto insert;
14739 }
14740 ap = ap->av_forw;
14741 }
14742
14743 /*
14744 * Neither a second list nor a larger request, therefore
14745 * we go at the end of the first list (which is the same
14746 * as the end of the whole schebang).
14747 */
14748 insert:
14749 bp->av_forw = ap->av_forw;
14750 ap->av_forw = bp;
14751
14752 /*
14753 * If we inserted onto the tail end of the waitq, make sure the
14754 * tail pointer is updated.
14755 */
14756 if (ap == un->un_waitq_tailp) {
14757 un->un_waitq_tailp = bp;
14758 }
14759 }
14760
14761
14762 /*
14763 * Function: sd_start_cmds
14764 *
14765 * Description: Remove and transport cmds from the driver queues.
14766 *
14767 * Arguments: un - pointer to the unit (soft state) struct for the target.
14768 *
14769 * immed_bp - ptr to a buf to be transported immediately. Only
14770 * the immed_bp is transported; bufs on the waitq are not
14771 * processed and the un_retry_bp is not checked. If immed_bp is
14772 * NULL, then normal queue processing is performed.
14773 *
14774 * Context: May be called from kernel thread context, interrupt context,
14775 * or runout callback context. This function may not block or
14776 * call routines that block.
14777 */
14778
14779 static void
14780 sd_start_cmds(struct sd_lun *un, struct buf *immed_bp)
14781 {
14782 struct sd_xbuf *xp;
14783 struct buf *bp;
14784 void (*statp)(kstat_io_t *);
14785 #if defined(__i386) || defined(__amd64) /* DMAFREE for x86 only */
14786 void (*saved_statp)(kstat_io_t *);
14787 #endif
14788 int rval;
14789 struct sd_fm_internal *sfip = NULL;
14790
14791 ASSERT(un != NULL);
14792 ASSERT(mutex_owned(SD_MUTEX(un)));
14793 ASSERT(un->un_ncmds_in_transport >= 0);
14794 ASSERT(un->un_throttle >= 0);
14795
14796 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_start_cmds: entry\n");
14797
14798 do {
14799 #if defined(__i386) || defined(__amd64) /* DMAFREE for x86 only */
14800 saved_statp = NULL;
14801 #endif
14802
14803 /*
14804 * If we are syncing or dumping, fail the command to
14805 * avoid recursively calling back into scsi_transport().
14806 * The dump I/O itself uses a separate code path so this
14807 * only prevents non-dump I/O from being sent while dumping.
14808 * File system sync takes place before dumping begins.
14809 * During panic, filesystem I/O is allowed provided
14810 * un_in_callback is <= 1. This is to prevent recursion
14811 * such as sd_start_cmds -> scsi_transport -> sdintr ->
14812 * sd_start_cmds and so on. See panic.c for more information
14813 * about the states the system can be in during panic.
14814 */
14815 if ((un->un_state == SD_STATE_DUMPING) ||
14816 (ddi_in_panic() && (un->un_in_callback > 1))) {
14817 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
14818 "sd_start_cmds: panicking\n");
14819 goto exit;
14820 }
14821
14822 if ((bp = immed_bp) != NULL) {
14823 /*
14824 * We have a bp that must be transported immediately.
14825 * It's OK to transport the immed_bp here without doing
14826 * the throttle limit check because the immed_bp is
14827 * always used in a retry/recovery case. This means
14828 * that we know we are not at the throttle limit by
14829 * virtue of the fact that to get here we must have
14830 * already gotten a command back via sdintr(). This also
14831 * relies on (1) the command on un_retry_bp preventing
14832 * further commands from the waitq from being issued;
14833 * and (2) the code in sd_retry_command checking the
14834 * throttle limit before issuing a delayed or immediate
14835 * retry. This holds even if the throttle limit is
14836 * currently ratcheted down from its maximum value.
14837 */
14838 statp = kstat_runq_enter;
14839 if (bp == un->un_retry_bp) {
14840 ASSERT((un->un_retry_statp == NULL) ||
14841 (un->un_retry_statp == kstat_waitq_enter) ||
14842 (un->un_retry_statp ==
14843 kstat_runq_back_to_waitq));
14844 /*
14845 * If the waitq kstat was incremented when
14846 * sd_set_retry_bp() queued this bp for a retry,
14847 * then we must set up statp so that the waitq
14848 * count will get decremented correctly below.
14849 * Also we must clear un->un_retry_statp to
14850 * ensure that we do not act on a stale value
14851 * in this field.
14852 */
14853 if ((un->un_retry_statp == kstat_waitq_enter) ||
14854 (un->un_retry_statp ==
14855 kstat_runq_back_to_waitq)) {
14856 statp = kstat_waitq_to_runq;
14857 }
14858 #if defined(__i386) || defined(__amd64) /* DMAFREE for x86 only */
14859 saved_statp = un->un_retry_statp;
14860 #endif
14861 un->un_retry_statp = NULL;
14862
14863 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un,
14864 "sd_start_cmds: un:0x%p: GOT retry_bp:0x%p "
14865 "un_throttle:%d un_ncmds_in_transport:%d\n",
14866 un, un->un_retry_bp, un->un_throttle,
14867 un->un_ncmds_in_transport);
14868 } else {
14869 SD_TRACE(SD_LOG_IO_CORE, un, "sd_start_cmds: "
14870 "processing priority bp:0x%p\n", bp);
14871 }
14872
14873 } else if ((bp = un->un_waitq_headp) != NULL) {
14874 /*
14875 * A command on the waitq is ready to go, but do not
14876 * send it if:
14877 *
14878 * (1) the throttle limit has been reached, or
14879 * (2) a retry is pending, or
14880 * (3) a START_STOP_UNIT callback pending, or
14881 * (4) a callback for a SD_PATH_DIRECT_PRIORITY
14882 * command is pending.
14883 *
14884 * For all of these conditions, IO processing will
14885 * restart after the condition is cleared.
14886 */
14887 if (un->un_ncmds_in_transport >= un->un_throttle) {
14888 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
14889 "sd_start_cmds: exiting, "
14890 "throttle limit reached!\n");
14891 goto exit;
14892 }
14893 if (un->un_retry_bp != NULL) {
14894 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
14895 "sd_start_cmds: exiting, retry pending!\n");
14896 goto exit;
14897 }
14898 if (un->un_startstop_timeid != NULL) {
14899 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
14900 "sd_start_cmds: exiting, "
14901 "START_STOP pending!\n");
14902 goto exit;
14903 }
14904 if (un->un_direct_priority_timeid != NULL) {
14905 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
14906 "sd_start_cmds: exiting, "
14907 "SD_PATH_DIRECT_PRIORITY cmd. pending!\n");
14908 goto exit;
14909 }
14910
14911 /* Dequeue the command */
14912 un->un_waitq_headp = bp->av_forw;
14913 if (un->un_waitq_headp == NULL) {
14914 un->un_waitq_tailp = NULL;
14915 }
14916 bp->av_forw = NULL;
14917 statp = kstat_waitq_to_runq;
14918 SD_TRACE(SD_LOG_IO_CORE, un,
14919 "sd_start_cmds: processing waitq bp:0x%p\n", bp);
14920
14921 } else {
14922 /* No work to do so bail out now */
14923 SD_TRACE(SD_LOG_IO_CORE, un,
14924 "sd_start_cmds: no more work, exiting!\n");
14925 goto exit;
14926 }
14927
14928 /*
14929 * Reset the state to normal. This is the mechanism by which
14930 * the state transitions from either SD_STATE_RWAIT or
14931 * SD_STATE_OFFLINE to SD_STATE_NORMAL.
14932 * If state is SD_STATE_PM_CHANGING then this command is
14933 * part of the device power control and the state must
14934 * not be put back to normal. Doing so would would
14935 * allow new commands to proceed when they shouldn't,
14936 * the device may be going off.
14937 */
14938 if ((un->un_state != SD_STATE_SUSPENDED) &&
14939 (un->un_state != SD_STATE_PM_CHANGING)) {
14940 New_state(un, SD_STATE_NORMAL);
14941 }
14942
14943 xp = SD_GET_XBUF(bp);
14944 ASSERT(xp != NULL);
14945
14946 #if defined(__i386) || defined(__amd64) /* DMAFREE for x86 only */
14947 /*
14948 * Allocate the scsi_pkt if we need one, or attach DMA
14949 * resources if we have a scsi_pkt that needs them. The
14950 * latter should only occur for commands that are being
14951 * retried.
14952 */
14953 if ((xp->xb_pktp == NULL) ||
14954 ((xp->xb_pkt_flags & SD_XB_DMA_FREED) != 0)) {
14955 #else
14956 if (xp->xb_pktp == NULL) {
14957 #endif
14958 /*
14959 * There is no scsi_pkt allocated for this buf. Call
14960 * the initpkt function to allocate & init one.
14961 *
14962 * The scsi_init_pkt runout callback functionality is
14963 * implemented as follows:
14964 *
14965 * 1) The initpkt function always calls
14966 * scsi_init_pkt(9F) with sdrunout specified as the
14967 * callback routine.
14968 * 2) A successful packet allocation is initialized and
14969 * the I/O is transported.
14970 * 3) The I/O associated with an allocation resource
14971 * failure is left on its queue to be retried via
14972 * runout or the next I/O.
14973 * 4) The I/O associated with a DMA error is removed
14974 * from the queue and failed with EIO. Processing of
14975 * the transport queues is also halted to be
14976 * restarted via runout or the next I/O.
14977 * 5) The I/O associated with a CDB size or packet
14978 * size error is removed from the queue and failed
14979 * with EIO. Processing of the transport queues is
14980 * continued.
14981 *
14982 * Note: there is no interface for canceling a runout
14983 * callback. To prevent the driver from detaching or
14984 * suspending while a runout is pending the driver
14985 * state is set to SD_STATE_RWAIT
14986 *
14987 * Note: using the scsi_init_pkt callback facility can
14988 * result in an I/O request persisting at the head of
14989 * the list which cannot be satisfied even after
14990 * multiple retries. In the future the driver may
14991 * implement some kind of maximum runout count before
14992 * failing an I/O.
14993 *
14994 * Note: the use of funcp below may seem superfluous,
14995 * but it helps warlock figure out the correct
14996 * initpkt function calls (see [s]sd.wlcmd).
14997 */
14998 struct scsi_pkt *pktp;
14999 int (*funcp)(struct buf *bp, struct scsi_pkt **pktp);
15000
15001 ASSERT(bp != un->un_rqs_bp);
15002
15003 funcp = sd_initpkt_map[xp->xb_chain_iostart];
15004 switch ((*funcp)(bp, &pktp)) {
15005 case SD_PKT_ALLOC_SUCCESS:
15006 xp->xb_pktp = pktp;
15007 SD_TRACE(SD_LOG_IO_CORE, un,
15008 "sd_start_cmd: SD_PKT_ALLOC_SUCCESS 0x%p\n",
15009 pktp);
15010 goto got_pkt;
15011
15012 case SD_PKT_ALLOC_FAILURE:
15013 /*
15014 * Temporary (hopefully) resource depletion.
15015 * Since retries and RQS commands always have a
15016 * scsi_pkt allocated, these cases should never
15017 * get here. So the only cases this needs to
15018 * handle is a bp from the waitq (which we put
15019 * back onto the waitq for sdrunout), or a bp
15020 * sent as an immed_bp (which we just fail).
15021 */
15022 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15023 "sd_start_cmds: SD_PKT_ALLOC_FAILURE\n");
15024
15025 #if defined(__i386) || defined(__amd64) /* DMAFREE for x86 only */
15026
15027 if (bp == immed_bp) {
15028 /*
15029 * If SD_XB_DMA_FREED is clear, then
15030 * this is a failure to allocate a
15031 * scsi_pkt, and we must fail the
15032 * command.
15033 */
15034 if ((xp->xb_pkt_flags &
15035 SD_XB_DMA_FREED) == 0) {
15036 break;
15037 }
15038
15039 /*
15040 * If this immediate command is NOT our
15041 * un_retry_bp, then we must fail it.
15042 */
15043 if (bp != un->un_retry_bp) {
15044 break;
15045 }
15046
15047 /*
15048 * We get here if this cmd is our
15049 * un_retry_bp that was DMAFREED, but
15050 * scsi_init_pkt() failed to reallocate
15051 * DMA resources when we attempted to
15052 * retry it. This can happen when an
15053 * mpxio failover is in progress, but
15054 * we don't want to just fail the
15055 * command in this case.
15056 *
15057 * Use timeout(9F) to restart it after
15058 * a 100ms delay. We don't want to
15059 * let sdrunout() restart it, because
15060 * sdrunout() is just supposed to start
15061 * commands that are sitting on the
15062 * wait queue. The un_retry_bp stays
15063 * set until the command completes, but
15064 * sdrunout can be called many times
15065 * before that happens. Since sdrunout
15066 * cannot tell if the un_retry_bp is
15067 * already in the transport, it could
15068 * end up calling scsi_transport() for
15069 * the un_retry_bp multiple times.
15070 *
15071 * Also: don't schedule the callback
15072 * if some other callback is already
15073 * pending.
15074 */
15075 if (un->un_retry_statp == NULL) {
15076 /*
15077 * restore the kstat pointer to
15078 * keep kstat counts coherent
15079 * when we do retry the command.
15080 */
15081 un->un_retry_statp =
15082 saved_statp;
15083 }
15084
15085 if ((un->un_startstop_timeid == NULL) &&
15086 (un->un_retry_timeid == NULL) &&
15087 (un->un_direct_priority_timeid ==
15088 NULL)) {
15089
15090 un->un_retry_timeid =
15091 timeout(
15092 sd_start_retry_command,
15093 un, SD_RESTART_TIMEOUT);
15094 }
15095 goto exit;
15096 }
15097
15098 #else
15099 if (bp == immed_bp) {
15100 break; /* Just fail the command */
15101 }
15102 #endif
15103
15104 /* Add the buf back to the head of the waitq */
15105 bp->av_forw = un->un_waitq_headp;
15106 un->un_waitq_headp = bp;
15107 if (un->un_waitq_tailp == NULL) {
15108 un->un_waitq_tailp = bp;
15109 }
15110 goto exit;
15111
15112 case SD_PKT_ALLOC_FAILURE_NO_DMA:
15113 /*
15114 * HBA DMA resource failure. Fail the command
15115 * and continue processing of the queues.
15116 */
15117 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15118 "sd_start_cmds: "
15119 "SD_PKT_ALLOC_FAILURE_NO_DMA\n");
15120 break;
15121
15122 case SD_PKT_ALLOC_FAILURE_PKT_TOO_SMALL:
15123 /*
15124 * Note:x86: Partial DMA mapping not supported
15125 * for USCSI commands, and all the needed DMA
15126 * resources were not allocated.
15127 */
15128 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15129 "sd_start_cmds: "
15130 "SD_PKT_ALLOC_FAILURE_PKT_TOO_SMALL\n");
15131 break;
15132
15133 case SD_PKT_ALLOC_FAILURE_CDB_TOO_SMALL:
15134 /*
15135 * Note:x86: Request cannot fit into CDB based
15136 * on lba and len.
15137 */
15138 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15139 "sd_start_cmds: "
15140 "SD_PKT_ALLOC_FAILURE_CDB_TOO_SMALL\n");
15141 break;
15142
15143 default:
15144 /* Should NEVER get here! */
15145 panic("scsi_initpkt error");
15146 /*NOTREACHED*/
15147 }
15148
15149 /*
15150 * Fatal error in allocating a scsi_pkt for this buf.
15151 * Update kstats & return the buf with an error code.
15152 * We must use sd_return_failed_command_no_restart() to
15153 * avoid a recursive call back into sd_start_cmds().
15154 * However this also means that we must keep processing
15155 * the waitq here in order to avoid stalling.
15156 */
15157 if (statp == kstat_waitq_to_runq) {
15158 SD_UPDATE_KSTATS(un, kstat_waitq_exit, bp);
15159 }
15160 sd_return_failed_command_no_restart(un, bp, EIO);
15161 if (bp == immed_bp) {
15162 /* immed_bp is gone by now, so clear this */
15163 immed_bp = NULL;
15164 }
15165 continue;
15166 }
15167 got_pkt:
15168 if (bp == immed_bp) {
15169 /* goto the head of the class.... */
15170 xp->xb_pktp->pkt_flags |= FLAG_HEAD;
15171 }
15172
15173 un->un_ncmds_in_transport++;
15174 SD_UPDATE_KSTATS(un, statp, bp);
15175
15176 /*
15177 * Call scsi_transport() to send the command to the target.
15178 * According to SCSA architecture, we must drop the mutex here
15179 * before calling scsi_transport() in order to avoid deadlock.
15180 * Note that the scsi_pkt's completion routine can be executed
15181 * (from interrupt context) even before the call to
15182 * scsi_transport() returns.
15183 */
15184 SD_TRACE(SD_LOG_IO_CORE, un,
15185 "sd_start_cmds: calling scsi_transport()\n");
15186 DTRACE_PROBE1(scsi__transport__dispatch, struct buf *, bp);
15187
15188 mutex_exit(SD_MUTEX(un));
15189 rval = scsi_transport(xp->xb_pktp);
15190 mutex_enter(SD_MUTEX(un));
15191
15192 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15193 "sd_start_cmds: scsi_transport() returned %d\n", rval);
15194
15195 switch (rval) {
15196 case TRAN_ACCEPT:
15197 /* Clear this with every pkt accepted by the HBA */
15198 un->un_tran_fatal_count = 0;
15199 break; /* Success; try the next cmd (if any) */
15200
15201 case TRAN_BUSY:
15202 un->un_ncmds_in_transport--;
15203 ASSERT(un->un_ncmds_in_transport >= 0);
15204
15205 /*
15206 * Don't retry request sense, the sense data
15207 * is lost when another request is sent.
15208 * Free up the rqs buf and retry
15209 * the original failed cmd. Update kstat.
15210 */
15211 if (bp == un->un_rqs_bp) {
15212 SD_UPDATE_KSTATS(un, kstat_runq_exit, bp);
15213 bp = sd_mark_rqs_idle(un, xp);
15214 sd_retry_command(un, bp, SD_RETRIES_STANDARD,
15215 NULL, NULL, EIO, un->un_busy_timeout / 500,
15216 kstat_waitq_enter);
15217 goto exit;
15218 }
15219
15220 #if defined(__i386) || defined(__amd64) /* DMAFREE for x86 only */
15221 /*
15222 * Free the DMA resources for the scsi_pkt. This will
15223 * allow mpxio to select another path the next time
15224 * we call scsi_transport() with this scsi_pkt.
15225 * See sdintr() for the rationalization behind this.
15226 */
15227 if ((un->un_f_is_fibre == TRUE) &&
15228 ((xp->xb_pkt_flags & SD_XB_USCSICMD) == 0) &&
15229 ((xp->xb_pktp->pkt_flags & FLAG_SENSING) == 0)) {
15230 scsi_dmafree(xp->xb_pktp);
15231 xp->xb_pkt_flags |= SD_XB_DMA_FREED;
15232 }
15233 #endif
15234
15235 if (SD_IS_DIRECT_PRIORITY(SD_GET_XBUF(bp))) {
15236 /*
15237 * Commands that are SD_PATH_DIRECT_PRIORITY
15238 * are for error recovery situations. These do
15239 * not use the normal command waitq, so if they
15240 * get a TRAN_BUSY we cannot put them back onto
15241 * the waitq for later retry. One possible
15242 * problem is that there could already be some
15243 * other command on un_retry_bp that is waiting
15244 * for this one to complete, so we would be
15245 * deadlocked if we put this command back onto
15246 * the waitq for later retry (since un_retry_bp
15247 * must complete before the driver gets back to
15248 * commands on the waitq).
15249 *
15250 * To avoid deadlock we must schedule a callback
15251 * that will restart this command after a set
15252 * interval. This should keep retrying for as
15253 * long as the underlying transport keeps
15254 * returning TRAN_BUSY (just like for other
15255 * commands). Use the same timeout interval as
15256 * for the ordinary TRAN_BUSY retry.
15257 */
15258 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15259 "sd_start_cmds: scsi_transport() returned "
15260 "TRAN_BUSY for DIRECT_PRIORITY cmd!\n");
15261
15262 SD_UPDATE_KSTATS(un, kstat_runq_exit, bp);
15263 un->un_direct_priority_timeid =
15264 timeout(sd_start_direct_priority_command,
15265 bp, un->un_busy_timeout / 500);
15266
15267 goto exit;
15268 }
15269
15270 /*
15271 * For TRAN_BUSY, we want to reduce the throttle value,
15272 * unless we are retrying a command.
15273 */
15274 if (bp != un->un_retry_bp) {
15275 sd_reduce_throttle(un, SD_THROTTLE_TRAN_BUSY);
15276 }
15277
15278 /*
15279 * Set up the bp to be tried again 10 ms later.
15280 * Note:x86: Is there a timeout value in the sd_lun
15281 * for this condition?
15282 */
15283 sd_set_retry_bp(un, bp, un->un_busy_timeout / 500,
15284 kstat_runq_back_to_waitq);
15285 goto exit;
15286
15287 case TRAN_FATAL_ERROR:
15288 un->un_tran_fatal_count++;
15289 /* FALLTHRU */
15290
15291 case TRAN_BADPKT:
15292 default:
15293 un->un_ncmds_in_transport--;
15294 ASSERT(un->un_ncmds_in_transport >= 0);
15295
15296 /*
15297 * If this is our REQUEST SENSE command with a
15298 * transport error, we must get back the pointers
15299 * to the original buf, and mark the REQUEST
15300 * SENSE command as "available".
15301 */
15302 if (bp == un->un_rqs_bp) {
15303 bp = sd_mark_rqs_idle(un, xp);
15304 xp = SD_GET_XBUF(bp);
15305 } else {
15306 /*
15307 * Legacy behavior: do not update transport
15308 * error count for request sense commands.
15309 */
15310 SD_UPDATE_ERRSTATS(un, sd_transerrs);
15311 }
15312
15313 SD_UPDATE_KSTATS(un, kstat_runq_exit, bp);
15314 sd_print_transport_rejected_message(un, xp, rval);
15315
15316 /*
15317 * This command will be terminated by SD driver due
15318 * to a fatal transport error. We should post
15319 * ereport.io.scsi.cmd.disk.tran with driver-assessment
15320 * of "fail" for any command to indicate this
15321 * situation.
15322 */
15323 if (xp->xb_ena > 0) {
15324 ASSERT(un->un_fm_private != NULL);
15325 sfip = un->un_fm_private;
15326 sfip->fm_ssc.ssc_flags |= SSC_FLAGS_TRAN_ABORT;
15327 sd_ssc_extract_info(&sfip->fm_ssc, un,
15328 xp->xb_pktp, bp, xp);
15329 sd_ssc_post(&sfip->fm_ssc, SD_FM_DRV_FATAL);
15330 }
15331
15332 /*
15333 * We must use sd_return_failed_command_no_restart() to
15334 * avoid a recursive call back into sd_start_cmds().
15335 * However this also means that we must keep processing
15336 * the waitq here in order to avoid stalling.
15337 */
15338 sd_return_failed_command_no_restart(un, bp, EIO);
15339
15340 /*
15341 * Notify any threads waiting in sd_ddi_suspend() that
15342 * a command completion has occurred.
15343 */
15344 if (un->un_state == SD_STATE_SUSPENDED) {
15345 cv_broadcast(&un->un_disk_busy_cv);
15346 }
15347
15348 if (bp == immed_bp) {
15349 /* immed_bp is gone by now, so clear this */
15350 immed_bp = NULL;
15351 }
15352 break;
15353 }
15354
15355 } while (immed_bp == NULL);
15356
15357 exit:
15358 ASSERT(mutex_owned(SD_MUTEX(un)));
15359 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_start_cmds: exit\n");
15360 }
15361
15362
15363 /*
15364 * Function: sd_return_command
15365 *
15366 * Description: Returns a command to its originator (with or without an
15367 * error). Also starts commands waiting to be transported
15368 * to the target.
15369 *
15370 * Context: May be called from interrupt, kernel, or timeout context
15371 */
15372
15373 static void
15374 sd_return_command(struct sd_lun *un, struct buf *bp)
15375 {
15376 struct sd_xbuf *xp;
15377 struct scsi_pkt *pktp;
15378 struct sd_fm_internal *sfip;
15379
15380 ASSERT(bp != NULL);
15381 ASSERT(un != NULL);
15382 ASSERT(mutex_owned(SD_MUTEX(un)));
15383 ASSERT(bp != un->un_rqs_bp);
15384 xp = SD_GET_XBUF(bp);
15385 ASSERT(xp != NULL);
15386
15387 pktp = SD_GET_PKTP(bp);
15388 sfip = (struct sd_fm_internal *)un->un_fm_private;
15389 ASSERT(sfip != NULL);
15390
15391 SD_TRACE(SD_LOG_IO_CORE, un, "sd_return_command: entry\n");
15392
15393 /*
15394 * Note: check for the "sdrestart failed" case.
15395 */
15396 if ((un->un_partial_dma_supported == 1) &&
15397 ((xp->xb_pkt_flags & SD_XB_USCSICMD) != SD_XB_USCSICMD) &&
15398 (geterror(bp) == 0) && (xp->xb_dma_resid != 0) &&
15399 (xp->xb_pktp->pkt_resid == 0)) {
15400
15401 if (sd_setup_next_xfer(un, bp, pktp, xp) != 0) {
15402 /*
15403 * Successfully set up next portion of cmd
15404 * transfer, try sending it
15405 */
15406 sd_retry_command(un, bp, SD_RETRIES_NOCHECK,
15407 NULL, NULL, 0, (clock_t)0, NULL);
15408 sd_start_cmds(un, NULL);
15409 return; /* Note:x86: need a return here? */
15410 }
15411 }
15412
15413 /*
15414 * If this is the failfast bp, clear it from un_failfast_bp. This
15415 * can happen if upon being re-tried the failfast bp either
15416 * succeeded or encountered another error (possibly even a different
15417 * error than the one that precipitated the failfast state, but in
15418 * that case it would have had to exhaust retries as well). Regardless,
15419 * this should not occur whenever the instance is in the active
15420 * failfast state.
15421 */
15422 if (bp == un->un_failfast_bp) {
15423 ASSERT(un->un_failfast_state == SD_FAILFAST_INACTIVE);
15424 un->un_failfast_bp = NULL;
15425 }
15426
15427 /*
15428 * Clear the failfast state upon successful completion of ANY cmd.
15429 */
15430 if (bp->b_error == 0) {
15431 un->un_failfast_state = SD_FAILFAST_INACTIVE;
15432 /*
15433 * If this is a successful command, but used to be retried,
15434 * we will take it as a recovered command and post an
15435 * ereport with driver-assessment of "recovered".
15436 */
15437 if (xp->xb_ena > 0) {
15438 sd_ssc_extract_info(&sfip->fm_ssc, un, pktp, bp, xp);
15439 sd_ssc_post(&sfip->fm_ssc, SD_FM_DRV_RECOVERY);
15440 }
15441 } else {
15442 /*
15443 * If this is a failed non-USCSI command we will post an
15444 * ereport with driver-assessment set accordingly("fail" or
15445 * "fatal").
15446 */
15447 if (!(xp->xb_pkt_flags & SD_XB_USCSICMD)) {
15448 sd_ssc_extract_info(&sfip->fm_ssc, un, pktp, bp, xp);
15449 sd_ssc_post(&sfip->fm_ssc, SD_FM_DRV_FATAL);
15450 }
15451 }
15452
15453 /*
15454 * This is used if the command was retried one or more times. Show that
15455 * we are done with it, and allow processing of the waitq to resume.
15456 */
15457 if (bp == un->un_retry_bp) {
15458 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15459 "sd_return_command: un:0x%p: "
15460 "RETURNING retry_bp:0x%p\n", un, un->un_retry_bp);
15461 un->un_retry_bp = NULL;
15462 un->un_retry_statp = NULL;
15463 }
15464
15465 SD_UPDATE_RDWR_STATS(un, bp);
15466 SD_UPDATE_PARTITION_STATS(un, bp);
15467
15468 switch (un->un_state) {
15469 case SD_STATE_SUSPENDED:
15470 /*
15471 * Notify any threads waiting in sd_ddi_suspend() that
15472 * a command completion has occurred.
15473 */
15474 cv_broadcast(&un->un_disk_busy_cv);
15475 break;
15476 default:
15477 sd_start_cmds(un, NULL);
15478 break;
15479 }
15480
15481 /* Return this command up the iodone chain to its originator. */
15482 mutex_exit(SD_MUTEX(un));
15483
15484 (*(sd_destroypkt_map[xp->xb_chain_iodone]))(bp);
15485 xp->xb_pktp = NULL;
15486
15487 SD_BEGIN_IODONE(xp->xb_chain_iodone, un, bp);
15488
15489 ASSERT(!mutex_owned(SD_MUTEX(un)));
15490 mutex_enter(SD_MUTEX(un));
15491
15492 SD_TRACE(SD_LOG_IO_CORE, un, "sd_return_command: exit\n");
15493 }
15494
15495
15496 /*
15497 * Function: sd_return_failed_command
15498 *
15499 * Description: Command completion when an error occurred.
15500 *
15501 * Context: May be called from interrupt context
15502 */
15503
15504 static void
15505 sd_return_failed_command(struct sd_lun *un, struct buf *bp, int errcode)
15506 {
15507 ASSERT(bp != NULL);
15508 ASSERT(un != NULL);
15509 ASSERT(mutex_owned(SD_MUTEX(un)));
15510
15511 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15512 "sd_return_failed_command: entry\n");
15513
15514 /*
15515 * b_resid could already be nonzero due to a partial data
15516 * transfer, so do not change it here.
15517 */
15518 SD_BIOERROR(bp, errcode);
15519
15520 sd_return_command(un, bp);
15521 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15522 "sd_return_failed_command: exit\n");
15523 }
15524
15525
15526 /*
15527 * Function: sd_return_failed_command_no_restart
15528 *
15529 * Description: Same as sd_return_failed_command, but ensures that no
15530 * call back into sd_start_cmds will be issued.
15531 *
15532 * Context: May be called from interrupt context
15533 */
15534
15535 static void
15536 sd_return_failed_command_no_restart(struct sd_lun *un, struct buf *bp,
15537 int errcode)
15538 {
15539 struct sd_xbuf *xp;
15540
15541 ASSERT(bp != NULL);
15542 ASSERT(un != NULL);
15543 ASSERT(mutex_owned(SD_MUTEX(un)));
15544 xp = SD_GET_XBUF(bp);
15545 ASSERT(xp != NULL);
15546 ASSERT(errcode != 0);
15547
15548 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15549 "sd_return_failed_command_no_restart: entry\n");
15550
15551 /*
15552 * b_resid could already be nonzero due to a partial data
15553 * transfer, so do not change it here.
15554 */
15555 SD_BIOERROR(bp, errcode);
15556
15557 /*
15558 * If this is the failfast bp, clear it. This can happen if the
15559 * failfast bp encounterd a fatal error when we attempted to
15560 * re-try it (such as a scsi_transport(9F) failure). However
15561 * we should NOT be in an active failfast state if the failfast
15562 * bp is not NULL.
15563 */
15564 if (bp == un->un_failfast_bp) {
15565 ASSERT(un->un_failfast_state == SD_FAILFAST_INACTIVE);
15566 un->un_failfast_bp = NULL;
15567 }
15568
15569 if (bp == un->un_retry_bp) {
15570 /*
15571 * This command was retried one or more times. Show that we are
15572 * done with it, and allow processing of the waitq to resume.
15573 */
15574 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15575 "sd_return_failed_command_no_restart: "
15576 " un:0x%p: RETURNING retry_bp:0x%p\n", un, un->un_retry_bp);
15577 un->un_retry_bp = NULL;
15578 un->un_retry_statp = NULL;
15579 }
15580
15581 SD_UPDATE_RDWR_STATS(un, bp);
15582 SD_UPDATE_PARTITION_STATS(un, bp);
15583
15584 mutex_exit(SD_MUTEX(un));
15585
15586 if (xp->xb_pktp != NULL) {
15587 (*(sd_destroypkt_map[xp->xb_chain_iodone]))(bp);
15588 xp->xb_pktp = NULL;
15589 }
15590
15591 SD_BEGIN_IODONE(xp->xb_chain_iodone, un, bp);
15592
15593 mutex_enter(SD_MUTEX(un));
15594
15595 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15596 "sd_return_failed_command_no_restart: exit\n");
15597 }
15598
15599
15600 /*
15601 * Function: sd_retry_command
15602 *
15603 * Description: queue up a command for retry, or (optionally) fail it
15604 * if retry counts are exhausted.
15605 *
15606 * Arguments: un - Pointer to the sd_lun struct for the target.
15607 *
15608 * bp - Pointer to the buf for the command to be retried.
15609 *
15610 * retry_check_flag - Flag to see which (if any) of the retry
15611 * counts should be decremented/checked. If the indicated
15612 * retry count is exhausted, then the command will not be
15613 * retried; it will be failed instead. This should use a
15614 * value equal to one of the following:
15615 *
15616 * SD_RETRIES_NOCHECK
15617 * SD_RESD_RETRIES_STANDARD
15618 * SD_RETRIES_VICTIM
15619 *
15620 * Optionally may be bitwise-OR'ed with SD_RETRIES_ISOLATE
15621 * if the check should be made to see of FLAG_ISOLATE is set
15622 * in the pkt. If FLAG_ISOLATE is set, then the command is
15623 * not retried, it is simply failed.
15624 *
15625 * user_funcp - Ptr to function to call before dispatching the
15626 * command. May be NULL if no action needs to be performed.
15627 * (Primarily intended for printing messages.)
15628 *
15629 * user_arg - Optional argument to be passed along to
15630 * the user_funcp call.
15631 *
15632 * failure_code - errno return code to set in the bp if the
15633 * command is going to be failed.
15634 *
15635 * retry_delay - Retry delay interval in (clock_t) units. May
15636 * be zero which indicates that the retry should be retried
15637 * immediately (ie, without an intervening delay).
15638 *
15639 * statp - Ptr to kstat function to be updated if the command
15640 * is queued for a delayed retry. May be NULL if no kstat
15641 * update is desired.
15642 *
15643 * Context: May be called from interrupt context.
15644 */
15645
15646 static void
15647 sd_retry_command(struct sd_lun *un, struct buf *bp, int retry_check_flag,
15648 void (*user_funcp)(struct sd_lun *un, struct buf *bp, void *argp, int
15649 code), void *user_arg, int failure_code, clock_t retry_delay,
15650 void (*statp)(kstat_io_t *))
15651 {
15652 struct sd_xbuf *xp;
15653 struct scsi_pkt *pktp;
15654 struct sd_fm_internal *sfip;
15655
15656 ASSERT(un != NULL);
15657 ASSERT(mutex_owned(SD_MUTEX(un)));
15658 ASSERT(bp != NULL);
15659 xp = SD_GET_XBUF(bp);
15660 ASSERT(xp != NULL);
15661 pktp = SD_GET_PKTP(bp);
15662 ASSERT(pktp != NULL);
15663
15664 sfip = (struct sd_fm_internal *)un->un_fm_private;
15665 ASSERT(sfip != NULL);
15666
15667 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un,
15668 "sd_retry_command: entry: bp:0x%p xp:0x%p\n", bp, xp);
15669
15670 /*
15671 * If we are syncing or dumping, fail the command to avoid
15672 * recursively calling back into scsi_transport().
15673 */
15674 if (ddi_in_panic()) {
15675 goto fail_command_no_log;
15676 }
15677
15678 /*
15679 * We should never be be retrying a command with FLAG_DIAGNOSE set, so
15680 * log an error and fail the command.
15681 */
15682 if ((pktp->pkt_flags & FLAG_DIAGNOSE) != 0) {
15683 scsi_log(SD_DEVINFO(un), sd_label, CE_NOTE,
15684 "ERROR, retrying FLAG_DIAGNOSE command.\n");
15685 sd_dump_memory(un, SD_LOG_IO, "CDB",
15686 (uchar_t *)pktp->pkt_cdbp, CDB_SIZE, SD_LOG_HEX);
15687 sd_dump_memory(un, SD_LOG_IO, "Sense Data",
15688 (uchar_t *)xp->xb_sense_data, SENSE_LENGTH, SD_LOG_HEX);
15689 goto fail_command;
15690 }
15691
15692 /*
15693 * If we are suspended, then put the command onto head of the
15694 * wait queue since we don't want to start more commands, and
15695 * clear the un_retry_bp. Next time when we are resumed, will
15696 * handle the command in the wait queue.
15697 */
15698 switch (un->un_state) {
15699 case SD_STATE_SUSPENDED:
15700 case SD_STATE_DUMPING:
15701 bp->av_forw = un->un_waitq_headp;
15702 un->un_waitq_headp = bp;
15703 if (un->un_waitq_tailp == NULL) {
15704 un->un_waitq_tailp = bp;
15705 }
15706 if (bp == un->un_retry_bp) {
15707 un->un_retry_bp = NULL;
15708 un->un_retry_statp = NULL;
15709 }
15710 SD_UPDATE_KSTATS(un, kstat_waitq_enter, bp);
15711 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_retry_command: "
15712 "exiting; cmd bp:0x%p requeued for SUSPEND/DUMP\n", bp);
15713 return;
15714 default:
15715 break;
15716 }
15717
15718 /*
15719 * If the caller wants us to check FLAG_ISOLATE, then see if that
15720 * is set; if it is then we do not want to retry the command.
15721 * Normally, FLAG_ISOLATE is only used with USCSI cmds.
15722 */
15723 if ((retry_check_flag & SD_RETRIES_ISOLATE) != 0) {
15724 if ((pktp->pkt_flags & FLAG_ISOLATE) != 0) {
15725 goto fail_command;
15726 }
15727 }
15728
15729
15730 /*
15731 * If SD_RETRIES_FAILFAST is set, it indicates that either a
15732 * command timeout or a selection timeout has occurred. This means
15733 * that we were unable to establish an kind of communication with
15734 * the target, and subsequent retries and/or commands are likely
15735 * to encounter similar results and take a long time to complete.
15736 *
15737 * If this is a failfast error condition, we need to update the
15738 * failfast state, even if this bp does not have B_FAILFAST set.
15739 */
15740 if (retry_check_flag & SD_RETRIES_FAILFAST) {
15741 if (un->un_failfast_state == SD_FAILFAST_ACTIVE) {
15742 ASSERT(un->un_failfast_bp == NULL);
15743 /*
15744 * If we are already in the active failfast state, and
15745 * another failfast error condition has been detected,
15746 * then fail this command if it has B_FAILFAST set.
15747 * If B_FAILFAST is clear, then maintain the legacy
15748 * behavior of retrying heroically, even tho this will
15749 * take a lot more time to fail the command.
15750 */
15751 if (bp->b_flags & B_FAILFAST) {
15752 goto fail_command;
15753 }
15754 } else {
15755 /*
15756 * We're not in the active failfast state, but we
15757 * have a failfast error condition, so we must begin
15758 * transition to the next state. We do this regardless
15759 * of whether or not this bp has B_FAILFAST set.
15760 */
15761 if (un->un_failfast_bp == NULL) {
15762 /*
15763 * This is the first bp to meet a failfast
15764 * condition so save it on un_failfast_bp &
15765 * do normal retry processing. Do not enter
15766 * active failfast state yet. This marks
15767 * entry into the "failfast pending" state.
15768 */
15769 un->un_failfast_bp = bp;
15770
15771 } else if (un->un_failfast_bp == bp) {
15772 /*
15773 * This is the second time *this* bp has
15774 * encountered a failfast error condition,
15775 * so enter active failfast state & flush
15776 * queues as appropriate.
15777 */
15778 un->un_failfast_state = SD_FAILFAST_ACTIVE;
15779 un->un_failfast_bp = NULL;
15780 sd_failfast_flushq(un);
15781
15782 /*
15783 * Fail this bp now if B_FAILFAST set;
15784 * otherwise continue with retries. (It would
15785 * be pretty ironic if this bp succeeded on a
15786 * subsequent retry after we just flushed all
15787 * the queues).
15788 */
15789 if (bp->b_flags & B_FAILFAST) {
15790 goto fail_command;
15791 }
15792
15793 #if !defined(lint) && !defined(__lint)
15794 } else {
15795 /*
15796 * If neither of the preceeding conditionals
15797 * was true, it means that there is some
15798 * *other* bp that has met an inital failfast
15799 * condition and is currently either being
15800 * retried or is waiting to be retried. In
15801 * that case we should perform normal retry
15802 * processing on *this* bp, since there is a
15803 * chance that the current failfast condition
15804 * is transient and recoverable. If that does
15805 * not turn out to be the case, then retries
15806 * will be cleared when the wait queue is
15807 * flushed anyway.
15808 */
15809 #endif
15810 }
15811 }
15812 } else {
15813 /*
15814 * SD_RETRIES_FAILFAST is clear, which indicates that we
15815 * likely were able to at least establish some level of
15816 * communication with the target and subsequent commands
15817 * and/or retries are likely to get through to the target,
15818 * In this case we want to be aggressive about clearing
15819 * the failfast state. Note that this does not affect
15820 * the "failfast pending" condition.
15821 */
15822 un->un_failfast_state = SD_FAILFAST_INACTIVE;
15823 }
15824
15825
15826 /*
15827 * Check the specified retry count to see if we can still do
15828 * any retries with this pkt before we should fail it.
15829 */
15830 switch (retry_check_flag & SD_RETRIES_MASK) {
15831 case SD_RETRIES_VICTIM:
15832 /*
15833 * Check the victim retry count. If exhausted, then fall
15834 * thru & check against the standard retry count.
15835 */
15836 if (xp->xb_victim_retry_count < un->un_victim_retry_count) {
15837 /* Increment count & proceed with the retry */
15838 xp->xb_victim_retry_count++;
15839 break;
15840 }
15841 /* Victim retries exhausted, fall back to std. retries... */
15842 /* FALLTHRU */
15843
15844 case SD_RETRIES_STANDARD:
15845 if (xp->xb_retry_count >= un->un_retry_count) {
15846 /* Retries exhausted, fail the command */
15847 SD_TRACE(SD_LOG_IO_CORE, un,
15848 "sd_retry_command: retries exhausted!\n");
15849 /*
15850 * update b_resid for failed SCMD_READ & SCMD_WRITE
15851 * commands with nonzero pkt_resid.
15852 */
15853 if ((pktp->pkt_reason == CMD_CMPLT) &&
15854 (SD_GET_PKT_STATUS(pktp) == STATUS_GOOD) &&
15855 (pktp->pkt_resid != 0)) {
15856 uchar_t op = SD_GET_PKT_OPCODE(pktp) & 0x1F;
15857 if ((op == SCMD_READ) || (op == SCMD_WRITE)) {
15858 SD_UPDATE_B_RESID(bp, pktp);
15859 }
15860 }
15861 goto fail_command;
15862 }
15863 xp->xb_retry_count++;
15864 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15865 "sd_retry_command: retry count:%d\n", xp->xb_retry_count);
15866 break;
15867
15868 case SD_RETRIES_UA:
15869 if (xp->xb_ua_retry_count >= sd_ua_retry_count) {
15870 /* Retries exhausted, fail the command */
15871 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
15872 "Unit Attention retries exhausted. "
15873 "Check the target.\n");
15874 goto fail_command;
15875 }
15876 xp->xb_ua_retry_count++;
15877 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15878 "sd_retry_command: retry count:%d\n",
15879 xp->xb_ua_retry_count);
15880 break;
15881
15882 case SD_RETRIES_BUSY:
15883 if (xp->xb_retry_count >= un->un_busy_retry_count) {
15884 /* Retries exhausted, fail the command */
15885 SD_TRACE(SD_LOG_IO_CORE, un,
15886 "sd_retry_command: retries exhausted!\n");
15887 goto fail_command;
15888 }
15889 xp->xb_retry_count++;
15890 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15891 "sd_retry_command: retry count:%d\n", xp->xb_retry_count);
15892 break;
15893
15894 case SD_RETRIES_NOCHECK:
15895 default:
15896 /* No retry count to check. Just proceed with the retry */
15897 break;
15898 }
15899
15900 xp->xb_pktp->pkt_flags |= FLAG_HEAD;
15901
15902 /*
15903 * If this is a non-USCSI command being retried
15904 * during execution last time, we should post an ereport with
15905 * driver-assessment of the value "retry".
15906 * For partial DMA, request sense and STATUS_QFULL, there are no
15907 * hardware errors, we bypass ereport posting.
15908 */
15909 if (failure_code != 0) {
15910 if (!(xp->xb_pkt_flags & SD_XB_USCSICMD)) {
15911 sd_ssc_extract_info(&sfip->fm_ssc, un, pktp, bp, xp);
15912 sd_ssc_post(&sfip->fm_ssc, SD_FM_DRV_RETRY);
15913 }
15914 }
15915
15916 /*
15917 * If we were given a zero timeout, we must attempt to retry the
15918 * command immediately (ie, without a delay).
15919 */
15920 if (retry_delay == 0) {
15921 /*
15922 * Check some limiting conditions to see if we can actually
15923 * do the immediate retry. If we cannot, then we must
15924 * fall back to queueing up a delayed retry.
15925 */
15926 if (un->un_ncmds_in_transport >= un->un_throttle) {
15927 /*
15928 * We are at the throttle limit for the target,
15929 * fall back to delayed retry.
15930 */
15931 retry_delay = un->un_busy_timeout;
15932 statp = kstat_waitq_enter;
15933 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15934 "sd_retry_command: immed. retry hit "
15935 "throttle!\n");
15936 } else {
15937 /*
15938 * We're clear to proceed with the immediate retry.
15939 * First call the user-provided function (if any)
15940 */
15941 if (user_funcp != NULL) {
15942 (*user_funcp)(un, bp, user_arg,
15943 SD_IMMEDIATE_RETRY_ISSUED);
15944 #ifdef __lock_lint
15945 sd_print_incomplete_msg(un, bp, user_arg,
15946 SD_IMMEDIATE_RETRY_ISSUED);
15947 sd_print_cmd_incomplete_msg(un, bp, user_arg,
15948 SD_IMMEDIATE_RETRY_ISSUED);
15949 sd_print_sense_failed_msg(un, bp, user_arg,
15950 SD_IMMEDIATE_RETRY_ISSUED);
15951 #endif
15952 }
15953
15954 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15955 "sd_retry_command: issuing immediate retry\n");
15956
15957 /*
15958 * Call sd_start_cmds() to transport the command to
15959 * the target.
15960 */
15961 sd_start_cmds(un, bp);
15962
15963 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15964 "sd_retry_command exit\n");
15965 return;
15966 }
15967 }
15968
15969 /*
15970 * Set up to retry the command after a delay.
15971 * First call the user-provided function (if any)
15972 */
15973 if (user_funcp != NULL) {
15974 (*user_funcp)(un, bp, user_arg, SD_DELAYED_RETRY_ISSUED);
15975 }
15976
15977 sd_set_retry_bp(un, bp, retry_delay, statp);
15978
15979 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_retry_command: exit\n");
15980 return;
15981
15982 fail_command:
15983
15984 if (user_funcp != NULL) {
15985 (*user_funcp)(un, bp, user_arg, SD_NO_RETRY_ISSUED);
15986 }
15987
15988 fail_command_no_log:
15989
15990 SD_INFO(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15991 "sd_retry_command: returning failed command\n");
15992
15993 sd_return_failed_command(un, bp, failure_code);
15994
15995 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_retry_command: exit\n");
15996 }
15997
15998
15999 /*
16000 * Function: sd_set_retry_bp
16001 *
16002 * Description: Set up the given bp for retry.
16003 *
16004 * Arguments: un - ptr to associated softstate
16005 * bp - ptr to buf(9S) for the command
16006 * retry_delay - time interval before issuing retry (may be 0)
16007 * statp - optional pointer to kstat function
16008 *
16009 * Context: May be called under interrupt context
16010 */
16011
16012 static void
16013 sd_set_retry_bp(struct sd_lun *un, struct buf *bp, clock_t retry_delay,
16014 void (*statp)(kstat_io_t *))
16015 {
16016 ASSERT(un != NULL);
16017 ASSERT(mutex_owned(SD_MUTEX(un)));
16018 ASSERT(bp != NULL);
16019
16020 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un,
16021 "sd_set_retry_bp: entry: un:0x%p bp:0x%p\n", un, bp);
16022
16023 /*
16024 * Indicate that the command is being retried. This will not allow any
16025 * other commands on the wait queue to be transported to the target
16026 * until this command has been completed (success or failure). The
16027 * "retry command" is not transported to the target until the given
16028 * time delay expires, unless the user specified a 0 retry_delay.
16029 *
16030 * Note: the timeout(9F) callback routine is what actually calls
16031 * sd_start_cmds() to transport the command, with the exception of a
16032 * zero retry_delay. The only current implementor of a zero retry delay
16033 * is the case where a START_STOP_UNIT is sent to spin-up a device.
16034 */
16035 if (un->un_retry_bp == NULL) {
16036 ASSERT(un->un_retry_statp == NULL);
16037 un->un_retry_bp = bp;
16038
16039 /*
16040 * If the user has not specified a delay the command should
16041 * be queued and no timeout should be scheduled.
16042 */
16043 if (retry_delay == 0) {
16044 /*
16045 * Save the kstat pointer that will be used in the
16046 * call to SD_UPDATE_KSTATS() below, so that
16047 * sd_start_cmds() can correctly decrement the waitq
16048 * count when it is time to transport this command.
16049 */
16050 un->un_retry_statp = statp;
16051 goto done;
16052 }
16053 }
16054
16055 if (un->un_retry_bp == bp) {
16056 /*
16057 * Save the kstat pointer that will be used in the call to
16058 * SD_UPDATE_KSTATS() below, so that sd_start_cmds() can
16059 * correctly decrement the waitq count when it is time to
16060 * transport this command.
16061 */
16062 un->un_retry_statp = statp;
16063
16064 /*
16065 * Schedule a timeout if:
16066 * 1) The user has specified a delay.
16067 * 2) There is not a START_STOP_UNIT callback pending.
16068 *
16069 * If no delay has been specified, then it is up to the caller
16070 * to ensure that IO processing continues without stalling.
16071 * Effectively, this means that the caller will issue the
16072 * required call to sd_start_cmds(). The START_STOP_UNIT
16073 * callback does this after the START STOP UNIT command has
16074 * completed. In either of these cases we should not schedule
16075 * a timeout callback here. Also don't schedule the timeout if
16076 * an SD_PATH_DIRECT_PRIORITY command is waiting to restart.
16077 */
16078 if ((retry_delay != 0) && (un->un_startstop_timeid == NULL) &&
16079 (un->un_direct_priority_timeid == NULL)) {
16080 un->un_retry_timeid =
16081 timeout(sd_start_retry_command, un, retry_delay);
16082 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16083 "sd_set_retry_bp: setting timeout: un: 0x%p"
16084 " bp:0x%p un_retry_timeid:0x%p\n",
16085 un, bp, un->un_retry_timeid);
16086 }
16087 } else {
16088 /*
16089 * We only get in here if there is already another command
16090 * waiting to be retried. In this case, we just put the
16091 * given command onto the wait queue, so it can be transported
16092 * after the current retry command has completed.
16093 *
16094 * Also we have to make sure that if the command at the head
16095 * of the wait queue is the un_failfast_bp, that we do not
16096 * put ahead of it any other commands that are to be retried.
16097 */
16098 if ((un->un_failfast_bp != NULL) &&
16099 (un->un_failfast_bp == un->un_waitq_headp)) {
16100 /*
16101 * Enqueue this command AFTER the first command on
16102 * the wait queue (which is also un_failfast_bp).
16103 */
16104 bp->av_forw = un->un_waitq_headp->av_forw;
16105 un->un_waitq_headp->av_forw = bp;
16106 if (un->un_waitq_headp == un->un_waitq_tailp) {
16107 un->un_waitq_tailp = bp;
16108 }
16109 } else {
16110 /* Enqueue this command at the head of the waitq. */
16111 bp->av_forw = un->un_waitq_headp;
16112 un->un_waitq_headp = bp;
16113 if (un->un_waitq_tailp == NULL) {
16114 un->un_waitq_tailp = bp;
16115 }
16116 }
16117
16118 if (statp == NULL) {
16119 statp = kstat_waitq_enter;
16120 }
16121 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16122 "sd_set_retry_bp: un:0x%p already delayed retry\n", un);
16123 }
16124
16125 done:
16126 if (statp != NULL) {
16127 SD_UPDATE_KSTATS(un, statp, bp);
16128 }
16129
16130 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16131 "sd_set_retry_bp: exit un:0x%p\n", un);
16132 }
16133
16134
16135 /*
16136 * Function: sd_start_retry_command
16137 *
16138 * Description: Start the command that has been waiting on the target's
16139 * retry queue. Called from timeout(9F) context after the
16140 * retry delay interval has expired.
16141 *
16142 * Arguments: arg - pointer to associated softstate for the device.
16143 *
16144 * Context: timeout(9F) thread context. May not sleep.
16145 */
16146
16147 static void
16148 sd_start_retry_command(void *arg)
16149 {
16150 struct sd_lun *un = arg;
16151
16152 ASSERT(un != NULL);
16153 ASSERT(!mutex_owned(SD_MUTEX(un)));
16154
16155 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16156 "sd_start_retry_command: entry\n");
16157
16158 mutex_enter(SD_MUTEX(un));
16159
16160 un->un_retry_timeid = NULL;
16161
16162 if (un->un_retry_bp != NULL) {
16163 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16164 "sd_start_retry_command: un:0x%p STARTING bp:0x%p\n",
16165 un, un->un_retry_bp);
16166 sd_start_cmds(un, un->un_retry_bp);
16167 }
16168
16169 mutex_exit(SD_MUTEX(un));
16170
16171 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16172 "sd_start_retry_command: exit\n");
16173 }
16174
16175 /*
16176 * Function: sd_rmw_msg_print_handler
16177 *
16178 * Description: If RMW mode is enabled and warning message is triggered
16179 * print I/O count during a fixed interval.
16180 *
16181 * Arguments: arg - pointer to associated softstate for the device.
16182 *
16183 * Context: timeout(9F) thread context. May not sleep.
16184 */
16185 static void
16186 sd_rmw_msg_print_handler(void *arg)
16187 {
16188 struct sd_lun *un = arg;
16189
16190 ASSERT(un != NULL);
16191 ASSERT(!mutex_owned(SD_MUTEX(un)));
16192
16193 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16194 "sd_rmw_msg_print_handler: entry\n");
16195
16196 mutex_enter(SD_MUTEX(un));
16197
16198 if (un->un_rmw_incre_count > 0) {
16199 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
16200 "%"PRIu64" I/O requests are not aligned with %d disk "
16201 "sector size in %ld seconds. They are handled through "
16202 "Read Modify Write but the performance is very low!\n",
16203 un->un_rmw_incre_count, un->un_tgt_blocksize,
16204 drv_hztousec(SD_RMW_MSG_PRINT_TIMEOUT) / 1000000);
16205 un->un_rmw_incre_count = 0;
16206 un->un_rmw_msg_timeid = timeout(sd_rmw_msg_print_handler,
16207 un, SD_RMW_MSG_PRINT_TIMEOUT);
16208 } else {
16209 un->un_rmw_msg_timeid = NULL;
16210 }
16211
16212 mutex_exit(SD_MUTEX(un));
16213
16214 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16215 "sd_rmw_msg_print_handler: exit\n");
16216 }
16217
16218 /*
16219 * Function: sd_start_direct_priority_command
16220 *
16221 * Description: Used to re-start an SD_PATH_DIRECT_PRIORITY command that had
16222 * received TRAN_BUSY when we called scsi_transport() to send it
16223 * to the underlying HBA. This function is called from timeout(9F)
16224 * context after the delay interval has expired.
16225 *
16226 * Arguments: arg - pointer to associated buf(9S) to be restarted.
16227 *
16228 * Context: timeout(9F) thread context. May not sleep.
16229 */
16230
16231 static void
16232 sd_start_direct_priority_command(void *arg)
16233 {
16234 struct buf *priority_bp = arg;
16235 struct sd_lun *un;
16236
16237 ASSERT(priority_bp != NULL);
16238 un = SD_GET_UN(priority_bp);
16239 ASSERT(un != NULL);
16240 ASSERT(!mutex_owned(SD_MUTEX(un)));
16241
16242 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16243 "sd_start_direct_priority_command: entry\n");
16244
16245 mutex_enter(SD_MUTEX(un));
16246 un->un_direct_priority_timeid = NULL;
16247 sd_start_cmds(un, priority_bp);
16248 mutex_exit(SD_MUTEX(un));
16249
16250 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16251 "sd_start_direct_priority_command: exit\n");
16252 }
16253
16254
16255 /*
16256 * Function: sd_send_request_sense_command
16257 *
16258 * Description: Sends a REQUEST SENSE command to the target
16259 *
16260 * Context: May be called from interrupt context.
16261 */
16262
16263 static void
16264 sd_send_request_sense_command(struct sd_lun *un, struct buf *bp,
16265 struct scsi_pkt *pktp)
16266 {
16267 ASSERT(bp != NULL);
16268 ASSERT(un != NULL);
16269 ASSERT(mutex_owned(SD_MUTEX(un)));
16270
16271 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un, "sd_send_request_sense_command: "
16272 "entry: buf:0x%p\n", bp);
16273
16274 /*
16275 * If we are syncing or dumping, then fail the command to avoid a
16276 * recursive callback into scsi_transport(). Also fail the command
16277 * if we are suspended (legacy behavior).
16278 */
16279 if (ddi_in_panic() || (un->un_state == SD_STATE_SUSPENDED) ||
16280 (un->un_state == SD_STATE_DUMPING)) {
16281 sd_return_failed_command(un, bp, EIO);
16282 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16283 "sd_send_request_sense_command: syncing/dumping, exit\n");
16284 return;
16285 }
16286
16287 /*
16288 * Retry the failed command and don't issue the request sense if:
16289 * 1) the sense buf is busy
16290 * 2) we have 1 or more outstanding commands on the target
16291 * (the sense data will be cleared or invalidated any way)
16292 *
16293 * Note: There could be an issue with not checking a retry limit here,
16294 * the problem is determining which retry limit to check.
16295 */
16296 if ((un->un_sense_isbusy != 0) || (un->un_ncmds_in_transport > 0)) {
16297 /* Don't retry if the command is flagged as non-retryable */
16298 if ((pktp->pkt_flags & FLAG_DIAGNOSE) == 0) {
16299 sd_retry_command(un, bp, SD_RETRIES_NOCHECK,
16300 NULL, NULL, 0, un->un_busy_timeout,
16301 kstat_waitq_enter);
16302 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16303 "sd_send_request_sense_command: "
16304 "at full throttle, retrying exit\n");
16305 } else {
16306 sd_return_failed_command(un, bp, EIO);
16307 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16308 "sd_send_request_sense_command: "
16309 "at full throttle, non-retryable exit\n");
16310 }
16311 return;
16312 }
16313
16314 sd_mark_rqs_busy(un, bp);
16315 sd_start_cmds(un, un->un_rqs_bp);
16316
16317 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16318 "sd_send_request_sense_command: exit\n");
16319 }
16320
16321
16322 /*
16323 * Function: sd_mark_rqs_busy
16324 *
16325 * Description: Indicate that the request sense bp for this instance is
16326 * in use.
16327 *
16328 * Context: May be called under interrupt context
16329 */
16330
16331 static void
16332 sd_mark_rqs_busy(struct sd_lun *un, struct buf *bp)
16333 {
16334 struct sd_xbuf *sense_xp;
16335
16336 ASSERT(un != NULL);
16337 ASSERT(bp != NULL);
16338 ASSERT(mutex_owned(SD_MUTEX(un)));
16339 ASSERT(un->un_sense_isbusy == 0);
16340
16341 SD_TRACE(SD_LOG_IO_CORE, un, "sd_mark_rqs_busy: entry: "
16342 "buf:0x%p xp:0x%p un:0x%p\n", bp, SD_GET_XBUF(bp), un);
16343
16344 sense_xp = SD_GET_XBUF(un->un_rqs_bp);
16345 ASSERT(sense_xp != NULL);
16346
16347 SD_INFO(SD_LOG_IO, un,
16348 "sd_mark_rqs_busy: entry: sense_xp:0x%p\n", sense_xp);
16349
16350 ASSERT(sense_xp->xb_pktp != NULL);
16351 ASSERT((sense_xp->xb_pktp->pkt_flags & (FLAG_SENSING | FLAG_HEAD))
16352 == (FLAG_SENSING | FLAG_HEAD));
16353
16354 un->un_sense_isbusy = 1;
16355 un->un_rqs_bp->b_resid = 0;
16356 sense_xp->xb_pktp->pkt_resid = 0;
16357 sense_xp->xb_pktp->pkt_reason = 0;
16358
16359 /* So we can get back the bp at interrupt time! */
16360 sense_xp->xb_sense_bp = bp;
16361
16362 bzero(un->un_rqs_bp->b_un.b_addr, SENSE_LENGTH);
16363
16364 /*
16365 * Mark this buf as awaiting sense data. (This is already set in
16366 * the pkt_flags for the RQS packet.)
16367 */
16368 ((SD_GET_XBUF(bp))->xb_pktp)->pkt_flags |= FLAG_SENSING;
16369
16370 /* Request sense down same path */
16371 if (scsi_pkt_allocated_correctly((SD_GET_XBUF(bp))->xb_pktp) &&
16372 ((SD_GET_XBUF(bp))->xb_pktp)->pkt_path_instance)
16373 sense_xp->xb_pktp->pkt_path_instance =
16374 ((SD_GET_XBUF(bp))->xb_pktp)->pkt_path_instance;
16375
16376 sense_xp->xb_retry_count = 0;
16377 sense_xp->xb_victim_retry_count = 0;
16378 sense_xp->xb_ua_retry_count = 0;
16379 sense_xp->xb_nr_retry_count = 0;
16380 sense_xp->xb_dma_resid = 0;
16381
16382 /* Clean up the fields for auto-request sense */
16383 sense_xp->xb_sense_status = 0;
16384 sense_xp->xb_sense_state = 0;
16385 sense_xp->xb_sense_resid = 0;
16386 bzero(sense_xp->xb_sense_data, sizeof (sense_xp->xb_sense_data));
16387
16388 SD_TRACE(SD_LOG_IO_CORE, un, "sd_mark_rqs_busy: exit\n");
16389 }
16390
16391
16392 /*
16393 * Function: sd_mark_rqs_idle
16394 *
16395 * Description: SD_MUTEX must be held continuously through this routine
16396 * to prevent reuse of the rqs struct before the caller can
16397 * complete it's processing.
16398 *
16399 * Return Code: Pointer to the RQS buf
16400 *
16401 * Context: May be called under interrupt context
16402 */
16403
16404 static struct buf *
16405 sd_mark_rqs_idle(struct sd_lun *un, struct sd_xbuf *sense_xp)
16406 {
16407 struct buf *bp;
16408 ASSERT(un != NULL);
16409 ASSERT(sense_xp != NULL);
16410 ASSERT(mutex_owned(SD_MUTEX(un)));
16411 ASSERT(un->un_sense_isbusy != 0);
16412
16413 un->un_sense_isbusy = 0;
16414 bp = sense_xp->xb_sense_bp;
16415 sense_xp->xb_sense_bp = NULL;
16416
16417 /* This pkt is no longer interested in getting sense data */
16418 ((SD_GET_XBUF(bp))->xb_pktp)->pkt_flags &= ~FLAG_SENSING;
16419
16420 return (bp);
16421 }
16422
16423
16424
16425 /*
16426 * Function: sd_alloc_rqs
16427 *
16428 * Description: Set up the unit to receive auto request sense data
16429 *
16430 * Return Code: DDI_SUCCESS or DDI_FAILURE
16431 *
16432 * Context: Called under attach(9E) context
16433 */
16434
16435 static int
16436 sd_alloc_rqs(struct scsi_device *devp, struct sd_lun *un)
16437 {
16438 struct sd_xbuf *xp;
16439
16440 ASSERT(un != NULL);
16441 ASSERT(!mutex_owned(SD_MUTEX(un)));
16442 ASSERT(un->un_rqs_bp == NULL);
16443 ASSERT(un->un_rqs_pktp == NULL);
16444
16445 /*
16446 * First allocate the required buf and scsi_pkt structs, then set up
16447 * the CDB in the scsi_pkt for a REQUEST SENSE command.
16448 */
16449 un->un_rqs_bp = scsi_alloc_consistent_buf(&devp->sd_address, NULL,
16450 MAX_SENSE_LENGTH, B_READ, SLEEP_FUNC, NULL);
16451 if (un->un_rqs_bp == NULL) {
16452 return (DDI_FAILURE);
16453 }
16454
16455 un->un_rqs_pktp = scsi_init_pkt(&devp->sd_address, NULL, un->un_rqs_bp,
16456 CDB_GROUP0, 1, 0, PKT_CONSISTENT, SLEEP_FUNC, NULL);
16457
16458 if (un->un_rqs_pktp == NULL) {
16459 sd_free_rqs(un);
16460 return (DDI_FAILURE);
16461 }
16462
16463 /* Set up the CDB in the scsi_pkt for a REQUEST SENSE command. */
16464 (void) scsi_setup_cdb((union scsi_cdb *)un->un_rqs_pktp->pkt_cdbp,
16465 SCMD_REQUEST_SENSE, 0, MAX_SENSE_LENGTH, 0);
16466
16467 SD_FILL_SCSI1_LUN(un, un->un_rqs_pktp);
16468
16469 /* Set up the other needed members in the ARQ scsi_pkt. */
16470 un->un_rqs_pktp->pkt_comp = sdintr;
16471 un->un_rqs_pktp->pkt_time = sd_io_time;
16472 un->un_rqs_pktp->pkt_flags |=
16473 (FLAG_SENSING | FLAG_HEAD); /* (1222170) */
16474
16475 /*
16476 * Allocate & init the sd_xbuf struct for the RQS command. Do not
16477 * provide any intpkt, destroypkt routines as we take care of
16478 * scsi_pkt allocation/freeing here and in sd_free_rqs().
16479 */
16480 xp = kmem_alloc(sizeof (struct sd_xbuf), KM_SLEEP);
16481 sd_xbuf_init(un, un->un_rqs_bp, xp, SD_CHAIN_NULL, NULL);
16482 xp->xb_pktp = un->un_rqs_pktp;
16483 SD_INFO(SD_LOG_ATTACH_DETACH, un,
16484 "sd_alloc_rqs: un 0x%p, rqs xp 0x%p, pkt 0x%p, buf 0x%p\n",
16485 un, xp, un->un_rqs_pktp, un->un_rqs_bp);
16486
16487 /*
16488 * Save the pointer to the request sense private bp so it can
16489 * be retrieved in sdintr.
16490 */
16491 un->un_rqs_pktp->pkt_private = un->un_rqs_bp;
16492 ASSERT(un->un_rqs_bp->b_private == xp);
16493
16494 /*
16495 * See if the HBA supports auto-request sense for the specified
16496 * target/lun. If it does, then try to enable it (if not already
16497 * enabled).
16498 *
16499 * Note: For some HBAs (ifp & sf), scsi_ifsetcap will always return
16500 * failure, while for other HBAs (pln) scsi_ifsetcap will always
16501 * return success. However, in both of these cases ARQ is always
16502 * enabled and scsi_ifgetcap will always return true. The best approach
16503 * is to issue the scsi_ifgetcap() first, then try the scsi_ifsetcap().
16504 *
16505 * The 3rd case is the HBA (adp) always return enabled on
16506 * scsi_ifgetgetcap even when it's not enable, the best approach
16507 * is issue a scsi_ifsetcap then a scsi_ifgetcap
16508 * Note: this case is to circumvent the Adaptec bug. (x86 only)
16509 */
16510
16511 if (un->un_f_is_fibre == TRUE) {
16512 un->un_f_arq_enabled = TRUE;
16513 } else {
16514 #if defined(__i386) || defined(__amd64)
16515 /*
16516 * Circumvent the Adaptec bug, remove this code when
16517 * the bug is fixed
16518 */
16519 (void) scsi_ifsetcap(SD_ADDRESS(un), "auto-rqsense", 1, 1);
16520 #endif
16521 switch (scsi_ifgetcap(SD_ADDRESS(un), "auto-rqsense", 1)) {
16522 case 0:
16523 SD_INFO(SD_LOG_ATTACH_DETACH, un,
16524 "sd_alloc_rqs: HBA supports ARQ\n");
16525 /*
16526 * ARQ is supported by this HBA but currently is not
16527 * enabled. Attempt to enable it and if successful then
16528 * mark this instance as ARQ enabled.
16529 */
16530 if (scsi_ifsetcap(SD_ADDRESS(un), "auto-rqsense", 1, 1)
16531 == 1) {
16532 /* Successfully enabled ARQ in the HBA */
16533 SD_INFO(SD_LOG_ATTACH_DETACH, un,
16534 "sd_alloc_rqs: ARQ enabled\n");
16535 un->un_f_arq_enabled = TRUE;
16536 } else {
16537 /* Could not enable ARQ in the HBA */
16538 SD_INFO(SD_LOG_ATTACH_DETACH, un,
16539 "sd_alloc_rqs: failed ARQ enable\n");
16540 un->un_f_arq_enabled = FALSE;
16541 }
16542 break;
16543 case 1:
16544 /*
16545 * ARQ is supported by this HBA and is already enabled.
16546 * Just mark ARQ as enabled for this instance.
16547 */
16548 SD_INFO(SD_LOG_ATTACH_DETACH, un,
16549 "sd_alloc_rqs: ARQ already enabled\n");
16550 un->un_f_arq_enabled = TRUE;
16551 break;
16552 default:
16553 /*
16554 * ARQ is not supported by this HBA; disable it for this
16555 * instance.
16556 */
16557 SD_INFO(SD_LOG_ATTACH_DETACH, un,
16558 "sd_alloc_rqs: HBA does not support ARQ\n");
16559 un->un_f_arq_enabled = FALSE;
16560 break;
16561 }
16562 }
16563
16564 return (DDI_SUCCESS);
16565 }
16566
16567
16568 /*
16569 * Function: sd_free_rqs
16570 *
16571 * Description: Cleanup for the pre-instance RQS command.
16572 *
16573 * Context: Kernel thread context
16574 */
16575
16576 static void
16577 sd_free_rqs(struct sd_lun *un)
16578 {
16579 ASSERT(un != NULL);
16580
16581 SD_TRACE(SD_LOG_IO_CORE, un, "sd_free_rqs: entry\n");
16582
16583 /*
16584 * If consistent memory is bound to a scsi_pkt, the pkt
16585 * has to be destroyed *before* freeing the consistent memory.
16586 * Don't change the sequence of this operations.
16587 * scsi_destroy_pkt() might access memory, which isn't allowed,
16588 * after it was freed in scsi_free_consistent_buf().
16589 */
16590 if (un->un_rqs_pktp != NULL) {
16591 scsi_destroy_pkt(un->un_rqs_pktp);
16592 un->un_rqs_pktp = NULL;
16593 }
16594
16595 if (un->un_rqs_bp != NULL) {
16596 struct sd_xbuf *xp = SD_GET_XBUF(un->un_rqs_bp);
16597 if (xp != NULL) {
16598 kmem_free(xp, sizeof (struct sd_xbuf));
16599 }
16600 scsi_free_consistent_buf(un->un_rqs_bp);
16601 un->un_rqs_bp = NULL;
16602 }
16603 SD_TRACE(SD_LOG_IO_CORE, un, "sd_free_rqs: exit\n");
16604 }
16605
16606
16607
16608 /*
16609 * Function: sd_reduce_throttle
16610 *
16611 * Description: Reduces the maximum # of outstanding commands on a
16612 * target to the current number of outstanding commands.
16613 * Queues a tiemout(9F) callback to restore the limit
16614 * after a specified interval has elapsed.
16615 * Typically used when we get a TRAN_BUSY return code
16616 * back from scsi_transport().
16617 *
16618 * Arguments: un - ptr to the sd_lun softstate struct
16619 * throttle_type: SD_THROTTLE_TRAN_BUSY or SD_THROTTLE_QFULL
16620 *
16621 * Context: May be called from interrupt context
16622 */
16623
16624 static void
16625 sd_reduce_throttle(struct sd_lun *un, int throttle_type)
16626 {
16627 ASSERT(un != NULL);
16628 ASSERT(mutex_owned(SD_MUTEX(un)));
16629 ASSERT(un->un_ncmds_in_transport >= 0);
16630
16631 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_reduce_throttle: "
16632 "entry: un:0x%p un_throttle:%d un_ncmds_in_transport:%d\n",
16633 un, un->un_throttle, un->un_ncmds_in_transport);
16634
16635 if (un->un_throttle > 1) {
16636 if (un->un_f_use_adaptive_throttle == TRUE) {
16637 switch (throttle_type) {
16638 case SD_THROTTLE_TRAN_BUSY:
16639 if (un->un_busy_throttle == 0) {
16640 un->un_busy_throttle = un->un_throttle;
16641 }
16642 break;
16643 case SD_THROTTLE_QFULL:
16644 un->un_busy_throttle = 0;
16645 break;
16646 default:
16647 ASSERT(FALSE);
16648 }
16649
16650 if (un->un_ncmds_in_transport > 0) {
16651 un->un_throttle = un->un_ncmds_in_transport;
16652 }
16653
16654 } else {
16655 if (un->un_ncmds_in_transport == 0) {
16656 un->un_throttle = 1;
16657 } else {
16658 un->un_throttle = un->un_ncmds_in_transport;
16659 }
16660 }
16661 }
16662
16663 /* Reschedule the timeout if none is currently active */
16664 if (un->un_reset_throttle_timeid == NULL) {
16665 un->un_reset_throttle_timeid = timeout(sd_restore_throttle,
16666 un, SD_THROTTLE_RESET_INTERVAL);
16667 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16668 "sd_reduce_throttle: timeout scheduled!\n");
16669 }
16670
16671 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_reduce_throttle: "
16672 "exit: un:0x%p un_throttle:%d\n", un, un->un_throttle);
16673 }
16674
16675
16676
16677 /*
16678 * Function: sd_restore_throttle
16679 *
16680 * Description: Callback function for timeout(9F). Resets the current
16681 * value of un->un_throttle to its default.
16682 *
16683 * Arguments: arg - pointer to associated softstate for the device.
16684 *
16685 * Context: May be called from interrupt context
16686 */
16687
16688 static void
16689 sd_restore_throttle(void *arg)
16690 {
16691 struct sd_lun *un = arg;
16692
16693 ASSERT(un != NULL);
16694 ASSERT(!mutex_owned(SD_MUTEX(un)));
16695
16696 mutex_enter(SD_MUTEX(un));
16697
16698 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un, "sd_restore_throttle: "
16699 "entry: un:0x%p un_throttle:%d\n", un, un->un_throttle);
16700
16701 un->un_reset_throttle_timeid = NULL;
16702
16703 if (un->un_f_use_adaptive_throttle == TRUE) {
16704 /*
16705 * If un_busy_throttle is nonzero, then it contains the
16706 * value that un_throttle was when we got a TRAN_BUSY back
16707 * from scsi_transport(). We want to revert back to this
16708 * value.
16709 *
16710 * In the QFULL case, the throttle limit will incrementally
16711 * increase until it reaches max throttle.
16712 */
16713 if (un->un_busy_throttle > 0) {
16714 un->un_throttle = un->un_busy_throttle;
16715 un->un_busy_throttle = 0;
16716 } else {
16717 /*
16718 * increase throttle by 10% open gate slowly, schedule
16719 * another restore if saved throttle has not been
16720 * reached
16721 */
16722 short throttle;
16723 if (sd_qfull_throttle_enable) {
16724 throttle = un->un_throttle +
16725 max((un->un_throttle / 10), 1);
16726 un->un_throttle =
16727 (throttle < un->un_saved_throttle) ?
16728 throttle : un->un_saved_throttle;
16729 if (un->un_throttle < un->un_saved_throttle) {
16730 un->un_reset_throttle_timeid =
16731 timeout(sd_restore_throttle,
16732 un,
16733 SD_QFULL_THROTTLE_RESET_INTERVAL);
16734 }
16735 }
16736 }
16737
16738 /*
16739 * If un_throttle has fallen below the low-water mark, we
16740 * restore the maximum value here (and allow it to ratchet
16741 * down again if necessary).
16742 */
16743 if (un->un_throttle < un->un_min_throttle) {
16744 un->un_throttle = un->un_saved_throttle;
16745 }
16746 } else {
16747 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un, "sd_restore_throttle: "
16748 "restoring limit from 0x%x to 0x%x\n",
16749 un->un_throttle, un->un_saved_throttle);
16750 un->un_throttle = un->un_saved_throttle;
16751 }
16752
16753 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un,
16754 "sd_restore_throttle: calling sd_start_cmds!\n");
16755
16756 sd_start_cmds(un, NULL);
16757
16758 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un,
16759 "sd_restore_throttle: exit: un:0x%p un_throttle:%d\n",
16760 un, un->un_throttle);
16761
16762 mutex_exit(SD_MUTEX(un));
16763
16764 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un, "sd_restore_throttle: exit\n");
16765 }
16766
16767 /*
16768 * Function: sdrunout
16769 *
16770 * Description: Callback routine for scsi_init_pkt when a resource allocation
16771 * fails.
16772 *
16773 * Arguments: arg - a pointer to the sd_lun unit struct for the particular
16774 * soft state instance.
16775 *
16776 * Return Code: The scsi_init_pkt routine allows for the callback function to
16777 * return a 0 indicating the callback should be rescheduled or a 1
16778 * indicating not to reschedule. This routine always returns 1
16779 * because the driver always provides a callback function to
16780 * scsi_init_pkt. This results in a callback always being scheduled
16781 * (via the scsi_init_pkt callback implementation) if a resource
16782 * failure occurs.
16783 *
16784 * Context: This callback function may not block or call routines that block
16785 *
16786 * Note: Using the scsi_init_pkt callback facility can result in an I/O
16787 * request persisting at the head of the list which cannot be
16788 * satisfied even after multiple retries. In the future the driver
16789 * may implement some time of maximum runout count before failing
16790 * an I/O.
16791 */
16792
16793 static int
16794 sdrunout(caddr_t arg)
16795 {
16796 struct sd_lun *un = (struct sd_lun *)arg;
16797
16798 ASSERT(un != NULL);
16799 ASSERT(!mutex_owned(SD_MUTEX(un)));
16800
16801 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sdrunout: entry\n");
16802
16803 mutex_enter(SD_MUTEX(un));
16804 sd_start_cmds(un, NULL);
16805 mutex_exit(SD_MUTEX(un));
16806 /*
16807 * This callback routine always returns 1 (i.e. do not reschedule)
16808 * because we always specify sdrunout as the callback handler for
16809 * scsi_init_pkt inside the call to sd_start_cmds.
16810 */
16811 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sdrunout: exit\n");
16812 return (1);
16813 }
16814
16815
16816 /*
16817 * Function: sdintr
16818 *
16819 * Description: Completion callback routine for scsi_pkt(9S) structs
16820 * sent to the HBA driver via scsi_transport(9F).
16821 *
16822 * Context: Interrupt context
16823 */
16824
16825 static void
16826 sdintr(struct scsi_pkt *pktp)
16827 {
16828 struct buf *bp;
16829 struct sd_xbuf *xp;
16830 struct sd_lun *un;
16831 size_t actual_len;
16832 sd_ssc_t *sscp;
16833
16834 ASSERT(pktp != NULL);
16835 bp = (struct buf *)pktp->pkt_private;
16836 ASSERT(bp != NULL);
16837 xp = SD_GET_XBUF(bp);
16838 ASSERT(xp != NULL);
16839 ASSERT(xp->xb_pktp != NULL);
16840 un = SD_GET_UN(bp);
16841 ASSERT(un != NULL);
16842 ASSERT(!mutex_owned(SD_MUTEX(un)));
16843
16844 #ifdef SD_FAULT_INJECTION
16845
16846 SD_INFO(SD_LOG_IOERR, un, "sdintr: sdintr calling Fault injection\n");
16847 /* SD FaultInjection */
16848 sd_faultinjection(pktp);
16849
16850 #endif /* SD_FAULT_INJECTION */
16851
16852 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sdintr: entry: buf:0x%p,"
16853 " xp:0x%p, un:0x%p\n", bp, xp, un);
16854
16855 mutex_enter(SD_MUTEX(un));
16856
16857 ASSERT(un->un_fm_private != NULL);
16858 sscp = &((struct sd_fm_internal *)(un->un_fm_private))->fm_ssc;
16859 ASSERT(sscp != NULL);
16860
16861 /* Reduce the count of the #commands currently in transport */
16862 un->un_ncmds_in_transport--;
16863 ASSERT(un->un_ncmds_in_transport >= 0);
16864
16865 /* Increment counter to indicate that the callback routine is active */
16866 un->un_in_callback++;
16867
16868 SD_UPDATE_KSTATS(un, kstat_runq_exit, bp);
16869
16870 #ifdef SDDEBUG
16871 if (bp == un->un_retry_bp) {
16872 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un, "sdintr: "
16873 "un:0x%p: GOT retry_bp:0x%p un_ncmds_in_transport:%d\n",
16874 un, un->un_retry_bp, un->un_ncmds_in_transport);
16875 }
16876 #endif
16877
16878 /*
16879 * If pkt_reason is CMD_DEV_GONE, fail the command, and update the media
16880 * state if needed.
16881 */
16882 if (pktp->pkt_reason == CMD_DEV_GONE) {
16883 /* Prevent multiple console messages for the same failure. */
16884 if (un->un_last_pkt_reason != CMD_DEV_GONE) {
16885 un->un_last_pkt_reason = CMD_DEV_GONE;
16886 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
16887 "Command failed to complete...Device is gone\n");
16888 }
16889 if (un->un_mediastate != DKIO_DEV_GONE) {
16890 un->un_mediastate = DKIO_DEV_GONE;
16891 cv_broadcast(&un->un_state_cv);
16892 }
16893 /*
16894 * If the command happens to be the REQUEST SENSE command,
16895 * free up the rqs buf and fail the original command.
16896 */
16897 if (bp == un->un_rqs_bp) {
16898 bp = sd_mark_rqs_idle(un, xp);
16899 }
16900 sd_return_failed_command(un, bp, EIO);
16901 goto exit;
16902 }
16903
16904 if (pktp->pkt_state & STATE_XARQ_DONE) {
16905 SD_TRACE(SD_LOG_COMMON, un,
16906 "sdintr: extra sense data received. pkt=%p\n", pktp);
16907 }
16908
16909 /*
16910 * First see if the pkt has auto-request sense data with it....
16911 * Look at the packet state first so we don't take a performance
16912 * hit looking at the arq enabled flag unless absolutely necessary.
16913 */
16914 if ((pktp->pkt_state & STATE_ARQ_DONE) &&
16915 (un->un_f_arq_enabled == TRUE)) {
16916 /*
16917 * The HBA did an auto request sense for this command so check
16918 * for FLAG_DIAGNOSE. If set this indicates a uscsi or internal
16919 * driver command that should not be retried.
16920 */
16921 if ((pktp->pkt_flags & FLAG_DIAGNOSE) != 0) {
16922 /*
16923 * Save the relevant sense info into the xp for the
16924 * original cmd.
16925 */
16926 struct scsi_arq_status *asp;
16927 asp = (struct scsi_arq_status *)(pktp->pkt_scbp);
16928 xp->xb_sense_status =
16929 *((uchar_t *)(&(asp->sts_rqpkt_status)));
16930 xp->xb_sense_state = asp->sts_rqpkt_state;
16931 xp->xb_sense_resid = asp->sts_rqpkt_resid;
16932 if (pktp->pkt_state & STATE_XARQ_DONE) {
16933 actual_len = MAX_SENSE_LENGTH -
16934 xp->xb_sense_resid;
16935 bcopy(&asp->sts_sensedata, xp->xb_sense_data,
16936 MAX_SENSE_LENGTH);
16937 } else {
16938 if (xp->xb_sense_resid > SENSE_LENGTH) {
16939 actual_len = MAX_SENSE_LENGTH -
16940 xp->xb_sense_resid;
16941 } else {
16942 actual_len = SENSE_LENGTH -
16943 xp->xb_sense_resid;
16944 }
16945 if (xp->xb_pkt_flags & SD_XB_USCSICMD) {
16946 if ((((struct uscsi_cmd *)
16947 (xp->xb_pktinfo))->uscsi_rqlen) >
16948 actual_len) {
16949 xp->xb_sense_resid =
16950 (((struct uscsi_cmd *)
16951 (xp->xb_pktinfo))->
16952 uscsi_rqlen) - actual_len;
16953 } else {
16954 xp->xb_sense_resid = 0;
16955 }
16956 }
16957 bcopy(&asp->sts_sensedata, xp->xb_sense_data,
16958 SENSE_LENGTH);
16959 }
16960
16961 /* fail the command */
16962 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16963 "sdintr: arq done and FLAG_DIAGNOSE set\n");
16964 sd_return_failed_command(un, bp, EIO);
16965 goto exit;
16966 }
16967
16968 #if (defined(__i386) || defined(__amd64)) /* DMAFREE for x86 only */
16969 /*
16970 * We want to either retry or fail this command, so free
16971 * the DMA resources here. If we retry the command then
16972 * the DMA resources will be reallocated in sd_start_cmds().
16973 * Note that when PKT_DMA_PARTIAL is used, this reallocation
16974 * causes the *entire* transfer to start over again from the
16975 * beginning of the request, even for PARTIAL chunks that
16976 * have already transferred successfully.
16977 */
16978 if ((un->un_f_is_fibre == TRUE) &&
16979 ((xp->xb_pkt_flags & SD_XB_USCSICMD) == 0) &&
16980 ((pktp->pkt_flags & FLAG_SENSING) == 0)) {
16981 scsi_dmafree(pktp);
16982 xp->xb_pkt_flags |= SD_XB_DMA_FREED;
16983 }
16984 #endif
16985
16986 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16987 "sdintr: arq done, sd_handle_auto_request_sense\n");
16988
16989 sd_handle_auto_request_sense(un, bp, xp, pktp);
16990 goto exit;
16991 }
16992
16993 /* Next see if this is the REQUEST SENSE pkt for the instance */
16994 if (pktp->pkt_flags & FLAG_SENSING) {
16995 /* This pktp is from the unit's REQUEST_SENSE command */
16996 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16997 "sdintr: sd_handle_request_sense\n");
16998 sd_handle_request_sense(un, bp, xp, pktp);
16999 goto exit;
17000 }
17001
17002 /*
17003 * Check to see if the command successfully completed as requested;
17004 * this is the most common case (and also the hot performance path).
17005 *
17006 * Requirements for successful completion are:
17007 * pkt_reason is CMD_CMPLT and packet status is status good.
17008 * In addition:
17009 * - A residual of zero indicates successful completion no matter what
17010 * the command is.
17011 * - If the residual is not zero and the command is not a read or
17012 * write, then it's still defined as successful completion. In other
17013 * words, if the command is a read or write the residual must be
17014 * zero for successful completion.
17015 * - If the residual is not zero and the command is a read or
17016 * write, and it's a USCSICMD, then it's still defined as
17017 * successful completion.
17018 */
17019 if ((pktp->pkt_reason == CMD_CMPLT) &&
17020 (SD_GET_PKT_STATUS(pktp) == STATUS_GOOD)) {
17021
17022 /*
17023 * Since this command is returned with a good status, we
17024 * can reset the count for Sonoma failover.
17025 */
17026 un->un_sonoma_failure_count = 0;
17027
17028 /*
17029 * Return all USCSI commands on good status
17030 */
17031 if (pktp->pkt_resid == 0) {
17032 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17033 "sdintr: returning command for resid == 0\n");
17034 } else if (((SD_GET_PKT_OPCODE(pktp) & 0x1F) != SCMD_READ) &&
17035 ((SD_GET_PKT_OPCODE(pktp) & 0x1F) != SCMD_WRITE)) {
17036 SD_UPDATE_B_RESID(bp, pktp);
17037 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17038 "sdintr: returning command for resid != 0\n");
17039 } else if (xp->xb_pkt_flags & SD_XB_USCSICMD) {
17040 SD_UPDATE_B_RESID(bp, pktp);
17041 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17042 "sdintr: returning uscsi command\n");
17043 } else {
17044 goto not_successful;
17045 }
17046 sd_return_command(un, bp);
17047
17048 /*
17049 * Decrement counter to indicate that the callback routine
17050 * is done.
17051 */
17052 un->un_in_callback--;
17053 ASSERT(un->un_in_callback >= 0);
17054 mutex_exit(SD_MUTEX(un));
17055
17056 return;
17057 }
17058
17059 not_successful:
17060
17061 #if (defined(__i386) || defined(__amd64)) /* DMAFREE for x86 only */
17062 /*
17063 * The following is based upon knowledge of the underlying transport
17064 * and its use of DMA resources. This code should be removed when
17065 * PKT_DMA_PARTIAL support is taken out of the disk driver in favor
17066 * of the new PKT_CMD_BREAKUP protocol. See also sd_initpkt_for_buf()
17067 * and sd_start_cmds().
17068 *
17069 * Free any DMA resources associated with this command if there
17070 * is a chance it could be retried or enqueued for later retry.
17071 * If we keep the DMA binding then mpxio cannot reissue the
17072 * command on another path whenever a path failure occurs.
17073 *
17074 * Note that when PKT_DMA_PARTIAL is used, free/reallocation
17075 * causes the *entire* transfer to start over again from the
17076 * beginning of the request, even for PARTIAL chunks that
17077 * have already transferred successfully.
17078 *
17079 * This is only done for non-uscsi commands (and also skipped for the
17080 * driver's internal RQS command). Also just do this for Fibre Channel
17081 * devices as these are the only ones that support mpxio.
17082 */
17083 if ((un->un_f_is_fibre == TRUE) &&
17084 ((xp->xb_pkt_flags & SD_XB_USCSICMD) == 0) &&
17085 ((pktp->pkt_flags & FLAG_SENSING) == 0)) {
17086 scsi_dmafree(pktp);
17087 xp->xb_pkt_flags |= SD_XB_DMA_FREED;
17088 }
17089 #endif
17090
17091 /*
17092 * The command did not successfully complete as requested so check
17093 * for FLAG_DIAGNOSE. If set this indicates a uscsi or internal
17094 * driver command that should not be retried so just return. If
17095 * FLAG_DIAGNOSE is not set the error will be processed below.
17096 */
17097 if ((pktp->pkt_flags & FLAG_DIAGNOSE) != 0) {
17098 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17099 "sdintr: FLAG_DIAGNOSE: sd_return_failed_command\n");
17100 /*
17101 * Issue a request sense if a check condition caused the error
17102 * (we handle the auto request sense case above), otherwise
17103 * just fail the command.
17104 */
17105 if ((pktp->pkt_reason == CMD_CMPLT) &&
17106 (SD_GET_PKT_STATUS(pktp) == STATUS_CHECK)) {
17107 sd_send_request_sense_command(un, bp, pktp);
17108 } else {
17109 sd_return_failed_command(un, bp, EIO);
17110 }
17111 goto exit;
17112 }
17113
17114 /*
17115 * The command did not successfully complete as requested so process
17116 * the error, retry, and/or attempt recovery.
17117 */
17118 switch (pktp->pkt_reason) {
17119 case CMD_CMPLT:
17120 switch (SD_GET_PKT_STATUS(pktp)) {
17121 case STATUS_GOOD:
17122 /*
17123 * The command completed successfully with a non-zero
17124 * residual
17125 */
17126 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17127 "sdintr: STATUS_GOOD \n");
17128 sd_pkt_status_good(un, bp, xp, pktp);
17129 break;
17130
17131 case STATUS_CHECK:
17132 case STATUS_TERMINATED:
17133 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17134 "sdintr: STATUS_TERMINATED | STATUS_CHECK\n");
17135 sd_pkt_status_check_condition(un, bp, xp, pktp);
17136 break;
17137
17138 case STATUS_BUSY:
17139 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17140 "sdintr: STATUS_BUSY\n");
17141 sd_pkt_status_busy(un, bp, xp, pktp);
17142 break;
17143
17144 case STATUS_RESERVATION_CONFLICT:
17145 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17146 "sdintr: STATUS_RESERVATION_CONFLICT\n");
17147 sd_pkt_status_reservation_conflict(un, bp, xp, pktp);
17148 break;
17149
17150 case STATUS_QFULL:
17151 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17152 "sdintr: STATUS_QFULL\n");
17153 sd_pkt_status_qfull(un, bp, xp, pktp);
17154 break;
17155
17156 case STATUS_MET:
17157 case STATUS_INTERMEDIATE:
17158 case STATUS_SCSI2:
17159 case STATUS_INTERMEDIATE_MET:
17160 case STATUS_ACA_ACTIVE:
17161 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
17162 "Unexpected SCSI status received: 0x%x\n",
17163 SD_GET_PKT_STATUS(pktp));
17164 /*
17165 * Mark the ssc_flags when detected invalid status
17166 * code for non-USCSI command.
17167 */
17168 if (!(xp->xb_pkt_flags & SD_XB_USCSICMD)) {
17169 sd_ssc_set_info(sscp, SSC_FLAGS_INVALID_STATUS,
17170 0, "stat-code");
17171 }
17172 sd_return_failed_command(un, bp, EIO);
17173 break;
17174
17175 default:
17176 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
17177 "Invalid SCSI status received: 0x%x\n",
17178 SD_GET_PKT_STATUS(pktp));
17179 if (!(xp->xb_pkt_flags & SD_XB_USCSICMD)) {
17180 sd_ssc_set_info(sscp, SSC_FLAGS_INVALID_STATUS,
17181 0, "stat-code");
17182 }
17183 sd_return_failed_command(un, bp, EIO);
17184 break;
17185
17186 }
17187 break;
17188
17189 case CMD_INCOMPLETE:
17190 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17191 "sdintr: CMD_INCOMPLETE\n");
17192 sd_pkt_reason_cmd_incomplete(un, bp, xp, pktp);
17193 break;
17194 case CMD_TRAN_ERR:
17195 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17196 "sdintr: CMD_TRAN_ERR\n");
17197 sd_pkt_reason_cmd_tran_err(un, bp, xp, pktp);
17198 break;
17199 case CMD_RESET:
17200 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17201 "sdintr: CMD_RESET \n");
17202 sd_pkt_reason_cmd_reset(un, bp, xp, pktp);
17203 break;
17204 case CMD_ABORTED:
17205 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17206 "sdintr: CMD_ABORTED \n");
17207 sd_pkt_reason_cmd_aborted(un, bp, xp, pktp);
17208 break;
17209 case CMD_TIMEOUT:
17210 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17211 "sdintr: CMD_TIMEOUT\n");
17212 sd_pkt_reason_cmd_timeout(un, bp, xp, pktp);
17213 break;
17214 case CMD_UNX_BUS_FREE:
17215 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17216 "sdintr: CMD_UNX_BUS_FREE \n");
17217 sd_pkt_reason_cmd_unx_bus_free(un, bp, xp, pktp);
17218 break;
17219 case CMD_TAG_REJECT:
17220 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17221 "sdintr: CMD_TAG_REJECT\n");
17222 sd_pkt_reason_cmd_tag_reject(un, bp, xp, pktp);
17223 break;
17224 default:
17225 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17226 "sdintr: default\n");
17227 /*
17228 * Mark the ssc_flags for detecting invliad pkt_reason.
17229 */
17230 if (!(xp->xb_pkt_flags & SD_XB_USCSICMD)) {
17231 sd_ssc_set_info(sscp, SSC_FLAGS_INVALID_PKT_REASON,
17232 0, "pkt-reason");
17233 }
17234 sd_pkt_reason_default(un, bp, xp, pktp);
17235 break;
17236 }
17237
17238 exit:
17239 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sdintr: exit\n");
17240
17241 /* Decrement counter to indicate that the callback routine is done. */
17242 un->un_in_callback--;
17243 ASSERT(un->un_in_callback >= 0);
17244
17245 /*
17246 * At this point, the pkt has been dispatched, ie, it is either
17247 * being re-tried or has been returned to its caller and should
17248 * not be referenced.
17249 */
17250
17251 mutex_exit(SD_MUTEX(un));
17252 }
17253
17254
17255 /*
17256 * Function: sd_print_incomplete_msg
17257 *
17258 * Description: Prints the error message for a CMD_INCOMPLETE error.
17259 *
17260 * Arguments: un - ptr to associated softstate for the device.
17261 * bp - ptr to the buf(9S) for the command.
17262 * arg - message string ptr
17263 * code - SD_DELAYED_RETRY_ISSUED, SD_IMMEDIATE_RETRY_ISSUED,
17264 * or SD_NO_RETRY_ISSUED.
17265 *
17266 * Context: May be called under interrupt context
17267 */
17268
17269 static void
17270 sd_print_incomplete_msg(struct sd_lun *un, struct buf *bp, void *arg, int code)
17271 {
17272 struct scsi_pkt *pktp;
17273 char *msgp;
17274 char *cmdp = arg;
17275
17276 ASSERT(un != NULL);
17277 ASSERT(mutex_owned(SD_MUTEX(un)));
17278 ASSERT(bp != NULL);
17279 ASSERT(arg != NULL);
17280 pktp = SD_GET_PKTP(bp);
17281 ASSERT(pktp != NULL);
17282
17283 switch (code) {
17284 case SD_DELAYED_RETRY_ISSUED:
17285 case SD_IMMEDIATE_RETRY_ISSUED:
17286 msgp = "retrying";
17287 break;
17288 case SD_NO_RETRY_ISSUED:
17289 default:
17290 msgp = "giving up";
17291 break;
17292 }
17293
17294 if ((pktp->pkt_flags & FLAG_SILENT) == 0) {
17295 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
17296 "incomplete %s- %s\n", cmdp, msgp);
17297 }
17298 }
17299
17300
17301
17302 /*
17303 * Function: sd_pkt_status_good
17304 *
17305 * Description: Processing for a STATUS_GOOD code in pkt_status.
17306 *
17307 * Context: May be called under interrupt context
17308 */
17309
17310 static void
17311 sd_pkt_status_good(struct sd_lun *un, struct buf *bp,
17312 struct sd_xbuf *xp, struct scsi_pkt *pktp)
17313 {
17314 char *cmdp;
17315
17316 ASSERT(un != NULL);
17317 ASSERT(mutex_owned(SD_MUTEX(un)));
17318 ASSERT(bp != NULL);
17319 ASSERT(xp != NULL);
17320 ASSERT(pktp != NULL);
17321 ASSERT(pktp->pkt_reason == CMD_CMPLT);
17322 ASSERT(SD_GET_PKT_STATUS(pktp) == STATUS_GOOD);
17323 ASSERT(pktp->pkt_resid != 0);
17324
17325 SD_TRACE(SD_LOG_IO_CORE, un, "sd_pkt_status_good: entry\n");
17326
17327 SD_UPDATE_ERRSTATS(un, sd_harderrs);
17328 switch (SD_GET_PKT_OPCODE(pktp) & 0x1F) {
17329 case SCMD_READ:
17330 cmdp = "read";
17331 break;
17332 case SCMD_WRITE:
17333 cmdp = "write";
17334 break;
17335 default:
17336 SD_UPDATE_B_RESID(bp, pktp);
17337 sd_return_command(un, bp);
17338 SD_TRACE(SD_LOG_IO_CORE, un, "sd_pkt_status_good: exit\n");
17339 return;
17340 }
17341
17342 /*
17343 * See if we can retry the read/write, preferrably immediately.
17344 * If retries are exhaused, then sd_retry_command() will update
17345 * the b_resid count.
17346 */
17347 sd_retry_command(un, bp, SD_RETRIES_STANDARD, sd_print_incomplete_msg,
17348 cmdp, EIO, (clock_t)0, NULL);
17349
17350 SD_TRACE(SD_LOG_IO_CORE, un, "sd_pkt_status_good: exit\n");
17351 }
17352
17353
17354
17355
17356
17357 /*
17358 * Function: sd_handle_request_sense
17359 *
17360 * Description: Processing for non-auto Request Sense command.
17361 *
17362 * Arguments: un - ptr to associated softstate
17363 * sense_bp - ptr to buf(9S) for the RQS command
17364 * sense_xp - ptr to the sd_xbuf for the RQS command
17365 * sense_pktp - ptr to the scsi_pkt(9S) for the RQS command
17366 *
17367 * Context: May be called under interrupt context
17368 */
17369
17370 static void
17371 sd_handle_request_sense(struct sd_lun *un, struct buf *sense_bp,
17372 struct sd_xbuf *sense_xp, struct scsi_pkt *sense_pktp)
17373 {
17374 struct buf *cmd_bp; /* buf for the original command */
17375 struct sd_xbuf *cmd_xp; /* sd_xbuf for the original command */
17376 struct scsi_pkt *cmd_pktp; /* pkt for the original command */
17377 size_t actual_len; /* actual sense data length */
17378
17379 ASSERT(un != NULL);
17380 ASSERT(mutex_owned(SD_MUTEX(un)));
17381 ASSERT(sense_bp != NULL);
17382 ASSERT(sense_xp != NULL);
17383 ASSERT(sense_pktp != NULL);
17384
17385 /*
17386 * Note the sense_bp, sense_xp, and sense_pktp here are for the
17387 * RQS command and not the original command.
17388 */
17389 ASSERT(sense_pktp == un->un_rqs_pktp);
17390 ASSERT(sense_bp == un->un_rqs_bp);
17391 ASSERT((sense_pktp->pkt_flags & (FLAG_SENSING | FLAG_HEAD)) ==
17392 (FLAG_SENSING | FLAG_HEAD));
17393 ASSERT((((SD_GET_XBUF(sense_xp->xb_sense_bp))->xb_pktp->pkt_flags) &
17394 FLAG_SENSING) == FLAG_SENSING);
17395
17396 /* These are the bp, xp, and pktp for the original command */
17397 cmd_bp = sense_xp->xb_sense_bp;
17398 cmd_xp = SD_GET_XBUF(cmd_bp);
17399 cmd_pktp = SD_GET_PKTP(cmd_bp);
17400
17401 if (sense_pktp->pkt_reason != CMD_CMPLT) {
17402 /*
17403 * The REQUEST SENSE command failed. Release the REQUEST
17404 * SENSE command for re-use, get back the bp for the original
17405 * command, and attempt to re-try the original command if
17406 * FLAG_DIAGNOSE is not set in the original packet.
17407 */
17408 SD_UPDATE_ERRSTATS(un, sd_harderrs);
17409 if ((cmd_pktp->pkt_flags & FLAG_DIAGNOSE) == 0) {
17410 cmd_bp = sd_mark_rqs_idle(un, sense_xp);
17411 sd_retry_command(un, cmd_bp, SD_RETRIES_STANDARD,
17412 NULL, NULL, EIO, (clock_t)0, NULL);
17413 return;
17414 }
17415 }
17416
17417 /*
17418 * Save the relevant sense info into the xp for the original cmd.
17419 *
17420 * Note: if the request sense failed the state info will be zero
17421 * as set in sd_mark_rqs_busy()
17422 */
17423 cmd_xp->xb_sense_status = *(sense_pktp->pkt_scbp);
17424 cmd_xp->xb_sense_state = sense_pktp->pkt_state;
17425 actual_len = MAX_SENSE_LENGTH - sense_pktp->pkt_resid;
17426 if ((cmd_xp->xb_pkt_flags & SD_XB_USCSICMD) &&
17427 (((struct uscsi_cmd *)cmd_xp->xb_pktinfo)->uscsi_rqlen >
17428 SENSE_LENGTH)) {
17429 bcopy(sense_bp->b_un.b_addr, cmd_xp->xb_sense_data,
17430 MAX_SENSE_LENGTH);
17431 cmd_xp->xb_sense_resid = sense_pktp->pkt_resid;
17432 } else {
17433 bcopy(sense_bp->b_un.b_addr, cmd_xp->xb_sense_data,
17434 SENSE_LENGTH);
17435 if (actual_len < SENSE_LENGTH) {
17436 cmd_xp->xb_sense_resid = SENSE_LENGTH - actual_len;
17437 } else {
17438 cmd_xp->xb_sense_resid = 0;
17439 }
17440 }
17441
17442 /*
17443 * Free up the RQS command....
17444 * NOTE:
17445 * Must do this BEFORE calling sd_validate_sense_data!
17446 * sd_validate_sense_data may return the original command in
17447 * which case the pkt will be freed and the flags can no
17448 * longer be touched.
17449 * SD_MUTEX is held through this process until the command
17450 * is dispatched based upon the sense data, so there are
17451 * no race conditions.
17452 */
17453 (void) sd_mark_rqs_idle(un, sense_xp);
17454
17455 /*
17456 * For a retryable command see if we have valid sense data, if so then
17457 * turn it over to sd_decode_sense() to figure out the right course of
17458 * action. Just fail a non-retryable command.
17459 */
17460 if ((cmd_pktp->pkt_flags & FLAG_DIAGNOSE) == 0) {
17461 if (sd_validate_sense_data(un, cmd_bp, cmd_xp, actual_len) ==
17462 SD_SENSE_DATA_IS_VALID) {
17463 sd_decode_sense(un, cmd_bp, cmd_xp, cmd_pktp);
17464 }
17465 } else {
17466 SD_DUMP_MEMORY(un, SD_LOG_IO_CORE, "Failed CDB",
17467 (uchar_t *)cmd_pktp->pkt_cdbp, CDB_SIZE, SD_LOG_HEX);
17468 SD_DUMP_MEMORY(un, SD_LOG_IO_CORE, "Sense Data",
17469 (uchar_t *)cmd_xp->xb_sense_data, SENSE_LENGTH, SD_LOG_HEX);
17470 sd_return_failed_command(un, cmd_bp, EIO);
17471 }
17472 }
17473
17474
17475
17476
17477 /*
17478 * Function: sd_handle_auto_request_sense
17479 *
17480 * Description: Processing for auto-request sense information.
17481 *
17482 * Arguments: un - ptr to associated softstate
17483 * bp - ptr to buf(9S) for the command
17484 * xp - ptr to the sd_xbuf for the command
17485 * pktp - ptr to the scsi_pkt(9S) for the command
17486 *
17487 * Context: May be called under interrupt context
17488 */
17489
17490 static void
17491 sd_handle_auto_request_sense(struct sd_lun *un, struct buf *bp,
17492 struct sd_xbuf *xp, struct scsi_pkt *pktp)
17493 {
17494 struct scsi_arq_status *asp;
17495 size_t actual_len;
17496
17497 ASSERT(un != NULL);
17498 ASSERT(mutex_owned(SD_MUTEX(un)));
17499 ASSERT(bp != NULL);
17500 ASSERT(xp != NULL);
17501 ASSERT(pktp != NULL);
17502 ASSERT(pktp != un->un_rqs_pktp);
17503 ASSERT(bp != un->un_rqs_bp);
17504
17505 /*
17506 * For auto-request sense, we get a scsi_arq_status back from
17507 * the HBA, with the sense data in the sts_sensedata member.
17508 * The pkt_scbp of the packet points to this scsi_arq_status.
17509 */
17510 asp = (struct scsi_arq_status *)(pktp->pkt_scbp);
17511
17512 if (asp->sts_rqpkt_reason != CMD_CMPLT) {
17513 /*
17514 * The auto REQUEST SENSE failed; see if we can re-try
17515 * the original command.
17516 */
17517 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
17518 "auto request sense failed (reason=%s)\n",
17519 scsi_rname(asp->sts_rqpkt_reason));
17520
17521 sd_reset_target(un, pktp);
17522
17523 sd_retry_command(un, bp, SD_RETRIES_STANDARD,
17524 NULL, NULL, EIO, (clock_t)0, NULL);
17525 return;
17526 }
17527
17528 /* Save the relevant sense info into the xp for the original cmd. */
17529 xp->xb_sense_status = *((uchar_t *)(&(asp->sts_rqpkt_status)));
17530 xp->xb_sense_state = asp->sts_rqpkt_state;
17531 xp->xb_sense_resid = asp->sts_rqpkt_resid;
17532 if (xp->xb_sense_state & STATE_XARQ_DONE) {
17533 actual_len = MAX_SENSE_LENGTH - xp->xb_sense_resid;
17534 bcopy(&asp->sts_sensedata, xp->xb_sense_data,
17535 MAX_SENSE_LENGTH);
17536 } else {
17537 if (xp->xb_sense_resid > SENSE_LENGTH) {
17538 actual_len = MAX_SENSE_LENGTH - xp->xb_sense_resid;
17539 } else {
17540 actual_len = SENSE_LENGTH - xp->xb_sense_resid;
17541 }
17542 if (xp->xb_pkt_flags & SD_XB_USCSICMD) {
17543 if ((((struct uscsi_cmd *)
17544 (xp->xb_pktinfo))->uscsi_rqlen) > actual_len) {
17545 xp->xb_sense_resid = (((struct uscsi_cmd *)
17546 (xp->xb_pktinfo))->uscsi_rqlen) -
17547 actual_len;
17548 } else {
17549 xp->xb_sense_resid = 0;
17550 }
17551 }
17552 bcopy(&asp->sts_sensedata, xp->xb_sense_data, SENSE_LENGTH);
17553 }
17554
17555 /*
17556 * See if we have valid sense data, if so then turn it over to
17557 * sd_decode_sense() to figure out the right course of action.
17558 */
17559 if (sd_validate_sense_data(un, bp, xp, actual_len) ==
17560 SD_SENSE_DATA_IS_VALID) {
17561 sd_decode_sense(un, bp, xp, pktp);
17562 }
17563 }
17564
17565
17566 /*
17567 * Function: sd_print_sense_failed_msg
17568 *
17569 * Description: Print log message when RQS has failed.
17570 *
17571 * Arguments: un - ptr to associated softstate
17572 * bp - ptr to buf(9S) for the command
17573 * arg - generic message string ptr
17574 * code - SD_IMMEDIATE_RETRY_ISSUED, SD_DELAYED_RETRY_ISSUED,
17575 * or SD_NO_RETRY_ISSUED
17576 *
17577 * Context: May be called from interrupt context
17578 */
17579
17580 static void
17581 sd_print_sense_failed_msg(struct sd_lun *un, struct buf *bp, void *arg,
17582 int code)
17583 {
17584 char *msgp = arg;
17585
17586 ASSERT(un != NULL);
17587 ASSERT(mutex_owned(SD_MUTEX(un)));
17588 ASSERT(bp != NULL);
17589
17590 if ((code == SD_NO_RETRY_ISSUED) && (msgp != NULL)) {
17591 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, msgp);
17592 }
17593 }
17594
17595
17596 /*
17597 * Function: sd_validate_sense_data
17598 *
17599 * Description: Check the given sense data for validity.
17600 * If the sense data is not valid, the command will
17601 * be either failed or retried!
17602 *
17603 * Return Code: SD_SENSE_DATA_IS_INVALID
17604 * SD_SENSE_DATA_IS_VALID
17605 *
17606 * Context: May be called from interrupt context
17607 */
17608
17609 static int
17610 sd_validate_sense_data(struct sd_lun *un, struct buf *bp, struct sd_xbuf *xp,
17611 size_t actual_len)
17612 {
17613 struct scsi_extended_sense *esp;
17614 struct scsi_pkt *pktp;
17615 char *msgp = NULL;
17616 sd_ssc_t *sscp;
17617
17618 ASSERT(un != NULL);
17619 ASSERT(mutex_owned(SD_MUTEX(un)));
17620 ASSERT(bp != NULL);
17621 ASSERT(bp != un->un_rqs_bp);
17622 ASSERT(xp != NULL);
17623 ASSERT(un->un_fm_private != NULL);
17624
17625 pktp = SD_GET_PKTP(bp);
17626 ASSERT(pktp != NULL);
17627
17628 sscp = &((struct sd_fm_internal *)(un->un_fm_private))->fm_ssc;
17629 ASSERT(sscp != NULL);
17630
17631 /*
17632 * Check the status of the RQS command (auto or manual).
17633 */
17634 switch (xp->xb_sense_status & STATUS_MASK) {
17635 case STATUS_GOOD:
17636 break;
17637
17638 case STATUS_RESERVATION_CONFLICT:
17639 sd_pkt_status_reservation_conflict(un, bp, xp, pktp);
17640 return (SD_SENSE_DATA_IS_INVALID);
17641
17642 case STATUS_BUSY:
17643 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
17644 "Busy Status on REQUEST SENSE\n");
17645 sd_retry_command(un, bp, SD_RETRIES_BUSY, NULL,
17646 NULL, EIO, un->un_busy_timeout / 500, kstat_waitq_enter);
17647 return (SD_SENSE_DATA_IS_INVALID);
17648
17649 case STATUS_QFULL:
17650 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
17651 "QFULL Status on REQUEST SENSE\n");
17652 sd_retry_command(un, bp, SD_RETRIES_STANDARD, NULL,
17653 NULL, EIO, un->un_busy_timeout / 500, kstat_waitq_enter);
17654 return (SD_SENSE_DATA_IS_INVALID);
17655
17656 case STATUS_CHECK:
17657 case STATUS_TERMINATED:
17658 msgp = "Check Condition on REQUEST SENSE\n";
17659 goto sense_failed;
17660
17661 default:
17662 msgp = "Not STATUS_GOOD on REQUEST_SENSE\n";
17663 goto sense_failed;
17664 }
17665
17666 /*
17667 * See if we got the minimum required amount of sense data.
17668 * Note: We are assuming the returned sense data is SENSE_LENGTH bytes
17669 * or less.
17670 */
17671 if (((xp->xb_sense_state & STATE_XFERRED_DATA) == 0) ||
17672 (actual_len == 0)) {
17673 msgp = "Request Sense couldn't get sense data\n";
17674 goto sense_failed;
17675 }
17676
17677 if (actual_len < SUN_MIN_SENSE_LENGTH) {
17678 msgp = "Not enough sense information\n";
17679 /* Mark the ssc_flags for detecting invalid sense data */
17680 if (!(xp->xb_pkt_flags & SD_XB_USCSICMD)) {
17681 sd_ssc_set_info(sscp, SSC_FLAGS_INVALID_SENSE, 0,
17682 "sense-data");
17683 }
17684 goto sense_failed;
17685 }
17686
17687 /*
17688 * We require the extended sense data
17689 */
17690 esp = (struct scsi_extended_sense *)xp->xb_sense_data;
17691 if (esp->es_class != CLASS_EXTENDED_SENSE) {
17692 if ((pktp->pkt_flags & FLAG_SILENT) == 0) {
17693 static char tmp[8];
17694 static char buf[148];
17695 char *p = (char *)(xp->xb_sense_data);
17696 int i;
17697
17698 mutex_enter(&sd_sense_mutex);
17699 (void) strcpy(buf, "undecodable sense information:");
17700 for (i = 0; i < actual_len; i++) {
17701 (void) sprintf(tmp, " 0x%x", *(p++)&0xff);
17702 (void) strcpy(&buf[strlen(buf)], tmp);
17703 }
17704 i = strlen(buf);
17705 (void) strcpy(&buf[i], "-(assumed fatal)\n");
17706
17707 if (SD_FM_LOG(un) == SD_FM_LOG_NSUP) {
17708 scsi_log(SD_DEVINFO(un), sd_label,
17709 CE_WARN, buf);
17710 }
17711 mutex_exit(&sd_sense_mutex);
17712 }
17713
17714 /* Mark the ssc_flags for detecting invalid sense data */
17715 if (!(xp->xb_pkt_flags & SD_XB_USCSICMD)) {
17716 sd_ssc_set_info(sscp, SSC_FLAGS_INVALID_SENSE, 0,
17717 "sense-data");
17718 }
17719
17720 /* Note: Legacy behavior, fail the command with no retry */
17721 sd_return_failed_command(un, bp, EIO);
17722 return (SD_SENSE_DATA_IS_INVALID);
17723 }
17724
17725 /*
17726 * Check that es_code is valid (es_class concatenated with es_code
17727 * make up the "response code" field. es_class will always be 7, so
17728 * make sure es_code is 0, 1, 2, 3 or 0xf. es_code will indicate the
17729 * format.
17730 */
17731 if ((esp->es_code != CODE_FMT_FIXED_CURRENT) &&
17732 (esp->es_code != CODE_FMT_FIXED_DEFERRED) &&
17733 (esp->es_code != CODE_FMT_DESCR_CURRENT) &&
17734 (esp->es_code != CODE_FMT_DESCR_DEFERRED) &&
17735 (esp->es_code != CODE_FMT_VENDOR_SPECIFIC)) {
17736 /* Mark the ssc_flags for detecting invalid sense data */
17737 if (!(xp->xb_pkt_flags & SD_XB_USCSICMD)) {
17738 sd_ssc_set_info(sscp, SSC_FLAGS_INVALID_SENSE, 0,
17739 "sense-data");
17740 }
17741 goto sense_failed;
17742 }
17743
17744 return (SD_SENSE_DATA_IS_VALID);
17745
17746 sense_failed:
17747 /*
17748 * If the request sense failed (for whatever reason), attempt
17749 * to retry the original command.
17750 */
17751 #if defined(__i386) || defined(__amd64)
17752 /*
17753 * SD_RETRY_DELAY is conditionally compile (#if fibre) in
17754 * sddef.h for Sparc platform, and x86 uses 1 binary
17755 * for both SCSI/FC.
17756 * The SD_RETRY_DELAY value need to be adjusted here
17757 * when SD_RETRY_DELAY change in sddef.h
17758 */
17759 sd_retry_command(un, bp, SD_RETRIES_STANDARD,
17760 sd_print_sense_failed_msg, msgp, EIO,
17761 un->un_f_is_fibre?drv_usectohz(100000):(clock_t)0, NULL);
17762 #else
17763 sd_retry_command(un, bp, SD_RETRIES_STANDARD,
17764 sd_print_sense_failed_msg, msgp, EIO, SD_RETRY_DELAY, NULL);
17765 #endif
17766
17767 return (SD_SENSE_DATA_IS_INVALID);
17768 }
17769
17770 /*
17771 * Function: sd_decode_sense
17772 *
17773 * Description: Take recovery action(s) when SCSI Sense Data is received.
17774 *
17775 * Context: Interrupt context.
17776 */
17777
17778 static void
17779 sd_decode_sense(struct sd_lun *un, struct buf *bp, struct sd_xbuf *xp,
17780 struct scsi_pkt *pktp)
17781 {
17782 uint8_t sense_key;
17783
17784 ASSERT(un != NULL);
17785 ASSERT(mutex_owned(SD_MUTEX(un)));
17786 ASSERT(bp != NULL);
17787 ASSERT(bp != un->un_rqs_bp);
17788 ASSERT(xp != NULL);
17789 ASSERT(pktp != NULL);
17790
17791 sense_key = scsi_sense_key(xp->xb_sense_data);
17792
17793 switch (sense_key) {
17794 case KEY_NO_SENSE:
17795 sd_sense_key_no_sense(un, bp, xp, pktp);
17796 break;
17797 case KEY_RECOVERABLE_ERROR:
17798 sd_sense_key_recoverable_error(un, xp->xb_sense_data,
17799 bp, xp, pktp);
17800 break;
17801 case KEY_NOT_READY:
17802 sd_sense_key_not_ready(un, xp->xb_sense_data,
17803 bp, xp, pktp);
17804 break;
17805 case KEY_MEDIUM_ERROR:
17806 case KEY_HARDWARE_ERROR:
17807 sd_sense_key_medium_or_hardware_error(un,
17808 xp->xb_sense_data, bp, xp, pktp);
17809 break;
17810 case KEY_ILLEGAL_REQUEST:
17811 sd_sense_key_illegal_request(un, bp, xp, pktp);
17812 break;
17813 case KEY_UNIT_ATTENTION:
17814 sd_sense_key_unit_attention(un, xp->xb_sense_data,
17815 bp, xp, pktp);
17816 break;
17817 case KEY_WRITE_PROTECT:
17818 case KEY_VOLUME_OVERFLOW:
17819 case KEY_MISCOMPARE:
17820 sd_sense_key_fail_command(un, bp, xp, pktp);
17821 break;
17822 case KEY_BLANK_CHECK:
17823 sd_sense_key_blank_check(un, bp, xp, pktp);
17824 break;
17825 case KEY_ABORTED_COMMAND:
17826 sd_sense_key_aborted_command(un, bp, xp, pktp);
17827 break;
17828 case KEY_VENDOR_UNIQUE:
17829 case KEY_COPY_ABORTED:
17830 case KEY_EQUAL:
17831 case KEY_RESERVED:
17832 default:
17833 sd_sense_key_default(un, xp->xb_sense_data,
17834 bp, xp, pktp);
17835 break;
17836 }
17837 }
17838
17839
17840 /*
17841 * Function: sd_dump_memory
17842 *
17843 * Description: Debug logging routine to print the contents of a user provided
17844 * buffer. The output of the buffer is broken up into 256 byte
17845 * segments due to a size constraint of the scsi_log.
17846 * implementation.
17847 *
17848 * Arguments: un - ptr to softstate
17849 * comp - component mask
17850 * title - "title" string to preceed data when printed
17851 * data - ptr to data block to be printed
17852 * len - size of data block to be printed
17853 * fmt - SD_LOG_HEX (use 0x%02x format) or SD_LOG_CHAR (use %c)
17854 *
17855 * Context: May be called from interrupt context
17856 */
17857
17858 #define SD_DUMP_MEMORY_BUF_SIZE 256
17859
17860 static char *sd_dump_format_string[] = {
17861 " 0x%02x",
17862 " %c"
17863 };
17864
17865 static void
17866 sd_dump_memory(struct sd_lun *un, uint_t comp, char *title, uchar_t *data,
17867 int len, int fmt)
17868 {
17869 int i, j;
17870 int avail_count;
17871 int start_offset;
17872 int end_offset;
17873 size_t entry_len;
17874 char *bufp;
17875 char *local_buf;
17876 char *format_string;
17877
17878 ASSERT((fmt == SD_LOG_HEX) || (fmt == SD_LOG_CHAR));
17879
17880 /*
17881 * In the debug version of the driver, this function is called from a
17882 * number of places which are NOPs in the release driver.
17883 * The debug driver therefore has additional methods of filtering
17884 * debug output.
17885 */
17886 #ifdef SDDEBUG
17887 /*
17888 * In the debug version of the driver we can reduce the amount of debug
17889 * messages by setting sd_error_level to something other than
17890 * SCSI_ERR_ALL and clearing bits in sd_level_mask and
17891 * sd_component_mask.
17892 */
17893 if (((sd_level_mask & (SD_LOGMASK_DUMP_MEM | SD_LOGMASK_DIAG)) == 0) ||
17894 (sd_error_level != SCSI_ERR_ALL)) {
17895 return;
17896 }
17897 if (((sd_component_mask & comp) == 0) ||
17898 (sd_error_level != SCSI_ERR_ALL)) {
17899 return;
17900 }
17901 #else
17902 if (sd_error_level != SCSI_ERR_ALL) {
17903 return;
17904 }
17905 #endif
17906
17907 local_buf = kmem_zalloc(SD_DUMP_MEMORY_BUF_SIZE, KM_SLEEP);
17908 bufp = local_buf;
17909 /*
17910 * Available length is the length of local_buf[], minus the
17911 * length of the title string, minus one for the ":", minus
17912 * one for the newline, minus one for the NULL terminator.
17913 * This gives the #bytes available for holding the printed
17914 * values from the given data buffer.
17915 */
17916 if (fmt == SD_LOG_HEX) {
17917 format_string = sd_dump_format_string[0];
17918 } else /* SD_LOG_CHAR */ {
17919 format_string = sd_dump_format_string[1];
17920 }
17921 /*
17922 * Available count is the number of elements from the given
17923 * data buffer that we can fit into the available length.
17924 * This is based upon the size of the format string used.
17925 * Make one entry and find it's size.
17926 */
17927 (void) sprintf(bufp, format_string, data[0]);
17928 entry_len = strlen(bufp);
17929 avail_count = (SD_DUMP_MEMORY_BUF_SIZE - strlen(title) - 3) / entry_len;
17930
17931 j = 0;
17932 while (j < len) {
17933 bufp = local_buf;
17934 bzero(bufp, SD_DUMP_MEMORY_BUF_SIZE);
17935 start_offset = j;
17936
17937 end_offset = start_offset + avail_count;
17938
17939 (void) sprintf(bufp, "%s:", title);
17940 bufp += strlen(bufp);
17941 for (i = start_offset; ((i < end_offset) && (j < len));
17942 i++, j++) {
17943 (void) sprintf(bufp, format_string, data[i]);
17944 bufp += entry_len;
17945 }
17946 (void) sprintf(bufp, "\n");
17947
17948 scsi_log(SD_DEVINFO(un), sd_label, CE_NOTE, "%s", local_buf);
17949 }
17950 kmem_free(local_buf, SD_DUMP_MEMORY_BUF_SIZE);
17951 }
17952
17953 /*
17954 * Function: sd_print_sense_msg
17955 *
17956 * Description: Log a message based upon the given sense data.
17957 *
17958 * Arguments: un - ptr to associated softstate
17959 * bp - ptr to buf(9S) for the command
17960 * arg - ptr to associate sd_sense_info struct
17961 * code - SD_IMMEDIATE_RETRY_ISSUED, SD_DELAYED_RETRY_ISSUED,
17962 * or SD_NO_RETRY_ISSUED
17963 *
17964 * Context: May be called from interrupt context
17965 */
17966
17967 static void
17968 sd_print_sense_msg(struct sd_lun *un, struct buf *bp, void *arg, int code)
17969 {
17970 struct sd_xbuf *xp;
17971 struct scsi_pkt *pktp;
17972 uint8_t *sensep;
17973 daddr_t request_blkno;
17974 diskaddr_t err_blkno;
17975 int severity;
17976 int pfa_flag;
17977 extern struct scsi_key_strings scsi_cmds[];
17978
17979 ASSERT(un != NULL);
17980 ASSERT(mutex_owned(SD_MUTEX(un)));
17981 ASSERT(bp != NULL);
17982 xp = SD_GET_XBUF(bp);
17983 ASSERT(xp != NULL);
17984 pktp = SD_GET_PKTP(bp);
17985 ASSERT(pktp != NULL);
17986 ASSERT(arg != NULL);
17987
17988 severity = ((struct sd_sense_info *)(arg))->ssi_severity;
17989 pfa_flag = ((struct sd_sense_info *)(arg))->ssi_pfa_flag;
17990
17991 if ((code == SD_DELAYED_RETRY_ISSUED) ||
17992 (code == SD_IMMEDIATE_RETRY_ISSUED)) {
17993 severity = SCSI_ERR_RETRYABLE;
17994 }
17995
17996 /* Use absolute block number for the request block number */
17997 request_blkno = xp->xb_blkno;
17998
17999 /*
18000 * Now try to get the error block number from the sense data
18001 */
18002 sensep = xp->xb_sense_data;
18003
18004 if (scsi_sense_info_uint64(sensep, SENSE_LENGTH,
18005 (uint64_t *)&err_blkno)) {
18006 /*
18007 * We retrieved the error block number from the information
18008 * portion of the sense data.
18009 *
18010 * For USCSI commands we are better off using the error
18011 * block no. as the requested block no. (This is the best
18012 * we can estimate.)
18013 */
18014 if ((SD_IS_BUFIO(xp) == FALSE) &&
18015 ((pktp->pkt_flags & FLAG_SILENT) == 0)) {
18016 request_blkno = err_blkno;
18017 }
18018 } else {
18019 /*
18020 * Without the es_valid bit set (for fixed format) or an
18021 * information descriptor (for descriptor format) we cannot
18022 * be certain of the error blkno, so just use the
18023 * request_blkno.
18024 */
18025 err_blkno = (diskaddr_t)request_blkno;
18026 }
18027
18028 /*
18029 * The following will log the buffer contents for the release driver
18030 * if the SD_LOGMASK_DIAG bit of sd_level_mask is set, or the error
18031 * level is set to verbose.
18032 */
18033 sd_dump_memory(un, SD_LOG_IO, "Failed CDB",
18034 (uchar_t *)pktp->pkt_cdbp, CDB_SIZE, SD_LOG_HEX);
18035 sd_dump_memory(un, SD_LOG_IO, "Sense Data",
18036 (uchar_t *)sensep, SENSE_LENGTH, SD_LOG_HEX);
18037
18038 if (pfa_flag == FALSE) {
18039 /* This is normally only set for USCSI */
18040 if ((pktp->pkt_flags & FLAG_SILENT) != 0) {
18041 return;
18042 }
18043
18044 if ((SD_IS_BUFIO(xp) == TRUE) &&
18045 (((sd_level_mask & SD_LOGMASK_DIAG) == 0) &&
18046 (severity < sd_error_level))) {
18047 return;
18048 }
18049 }
18050 /*
18051 * Check for Sonoma Failover and keep a count of how many failed I/O's
18052 */
18053 if ((SD_IS_LSI(un)) &&
18054 (scsi_sense_key(sensep) == KEY_ILLEGAL_REQUEST) &&
18055 (scsi_sense_asc(sensep) == 0x94) &&
18056 (scsi_sense_ascq(sensep) == 0x01)) {
18057 un->un_sonoma_failure_count++;
18058 if (un->un_sonoma_failure_count > 1) {
18059 return;
18060 }
18061 }
18062
18063 if (SD_FM_LOG(un) == SD_FM_LOG_NSUP ||
18064 ((scsi_sense_key(sensep) == KEY_RECOVERABLE_ERROR) &&
18065 (pktp->pkt_resid == 0))) {
18066 scsi_vu_errmsg(SD_SCSI_DEVP(un), pktp, sd_label, severity,
18067 request_blkno, err_blkno, scsi_cmds,
18068 (struct scsi_extended_sense *)sensep,
18069 un->un_additional_codes, NULL);
18070 }
18071 }
18072
18073 /*
18074 * Function: sd_sense_key_no_sense
18075 *
18076 * Description: Recovery action when sense data was not received.
18077 *
18078 * Context: May be called from interrupt context
18079 */
18080
18081 static void
18082 sd_sense_key_no_sense(struct sd_lun *un, struct buf *bp,
18083 struct sd_xbuf *xp, struct scsi_pkt *pktp)
18084 {
18085 struct sd_sense_info si;
18086
18087 ASSERT(un != NULL);
18088 ASSERT(mutex_owned(SD_MUTEX(un)));
18089 ASSERT(bp != NULL);
18090 ASSERT(xp != NULL);
18091 ASSERT(pktp != NULL);
18092
18093 si.ssi_severity = SCSI_ERR_FATAL;
18094 si.ssi_pfa_flag = FALSE;
18095
18096 SD_UPDATE_ERRSTATS(un, sd_softerrs);
18097
18098 sd_retry_command(un, bp, SD_RETRIES_STANDARD, sd_print_sense_msg,
18099 &si, EIO, (clock_t)0, NULL);
18100 }
18101
18102
18103 /*
18104 * Function: sd_sense_key_recoverable_error
18105 *
18106 * Description: Recovery actions for a SCSI "Recovered Error" sense key.
18107 *
18108 * Context: May be called from interrupt context
18109 */
18110
18111 static void
18112 sd_sense_key_recoverable_error(struct sd_lun *un,
18113 uint8_t *sense_datap,
18114 struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp)
18115 {
18116 struct sd_sense_info si;
18117 uint8_t asc = scsi_sense_asc(sense_datap);
18118 uint8_t ascq = scsi_sense_ascq(sense_datap);
18119
18120 ASSERT(un != NULL);
18121 ASSERT(mutex_owned(SD_MUTEX(un)));
18122 ASSERT(bp != NULL);
18123 ASSERT(xp != NULL);
18124 ASSERT(pktp != NULL);
18125
18126 /*
18127 * 0x00, 0x1D: ATA PASSTHROUGH INFORMATION AVAILABLE
18128 */
18129 if (asc == 0x00 && ascq == 0x1D) {
18130 sd_return_command(un, bp);
18131 return;
18132 }
18133
18134 /*
18135 * 0x5D: FAILURE PREDICTION THRESHOLD EXCEEDED
18136 */
18137 if ((asc == 0x5D) && (sd_report_pfa != 0)) {
18138 SD_UPDATE_ERRSTATS(un, sd_rq_pfa_err);
18139 si.ssi_severity = SCSI_ERR_INFO;
18140 si.ssi_pfa_flag = TRUE;
18141 } else {
18142 SD_UPDATE_ERRSTATS(un, sd_softerrs);
18143 SD_UPDATE_ERRSTATS(un, sd_rq_recov_err);
18144 si.ssi_severity = SCSI_ERR_RECOVERED;
18145 si.ssi_pfa_flag = FALSE;
18146 }
18147
18148 if (pktp->pkt_resid == 0) {
18149 sd_print_sense_msg(un, bp, &si, SD_NO_RETRY_ISSUED);
18150 sd_return_command(un, bp);
18151 return;
18152 }
18153
18154 sd_retry_command(un, bp, SD_RETRIES_STANDARD, sd_print_sense_msg,
18155 &si, EIO, (clock_t)0, NULL);
18156 }
18157
18158
18159
18160
18161 /*
18162 * Function: sd_sense_key_not_ready
18163 *
18164 * Description: Recovery actions for a SCSI "Not Ready" sense key.
18165 *
18166 * Context: May be called from interrupt context
18167 */
18168
18169 static void
18170 sd_sense_key_not_ready(struct sd_lun *un,
18171 uint8_t *sense_datap,
18172 struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp)
18173 {
18174 struct sd_sense_info si;
18175 uint8_t asc = scsi_sense_asc(sense_datap);
18176 uint8_t ascq = scsi_sense_ascq(sense_datap);
18177
18178 ASSERT(un != NULL);
18179 ASSERT(mutex_owned(SD_MUTEX(un)));
18180 ASSERT(bp != NULL);
18181 ASSERT(xp != NULL);
18182 ASSERT(pktp != NULL);
18183
18184 si.ssi_severity = SCSI_ERR_FATAL;
18185 si.ssi_pfa_flag = FALSE;
18186
18187 /*
18188 * Update error stats after first NOT READY error. Disks may have
18189 * been powered down and may need to be restarted. For CDROMs,
18190 * report NOT READY errors only if media is present.
18191 */
18192 if ((ISCD(un) && (asc == 0x3A)) ||
18193 (xp->xb_nr_retry_count > 0)) {
18194 SD_UPDATE_ERRSTATS(un, sd_harderrs);
18195 SD_UPDATE_ERRSTATS(un, sd_rq_ntrdy_err);
18196 }
18197
18198 /*
18199 * Just fail if the "not ready" retry limit has been reached.
18200 */
18201 if (xp->xb_nr_retry_count >= un->un_notready_retry_count) {
18202 /* Special check for error message printing for removables. */
18203 if (un->un_f_has_removable_media && (asc == 0x04) &&
18204 (ascq >= 0x04)) {
18205 si.ssi_severity = SCSI_ERR_ALL;
18206 }
18207 goto fail_command;
18208 }
18209
18210 /*
18211 * Check the ASC and ASCQ in the sense data as needed, to determine
18212 * what to do.
18213 */
18214 switch (asc) {
18215 case 0x04: /* LOGICAL UNIT NOT READY */
18216 /*
18217 * disk drives that don't spin up result in a very long delay
18218 * in format without warning messages. We will log a message
18219 * if the error level is set to verbose.
18220 */
18221 if (sd_error_level < SCSI_ERR_RETRYABLE) {
18222 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
18223 "logical unit not ready, resetting disk\n");
18224 }
18225
18226 /*
18227 * There are different requirements for CDROMs and disks for
18228 * the number of retries. If a CD-ROM is giving this, it is
18229 * probably reading TOC and is in the process of getting
18230 * ready, so we should keep on trying for a long time to make
18231 * sure that all types of media are taken in account (for
18232 * some media the drive takes a long time to read TOC). For
18233 * disks we do not want to retry this too many times as this
18234 * can cause a long hang in format when the drive refuses to
18235 * spin up (a very common failure).
18236 */
18237 switch (ascq) {
18238 case 0x00: /* LUN NOT READY, CAUSE NOT REPORTABLE */
18239 /*
18240 * Disk drives frequently refuse to spin up which
18241 * results in a very long hang in format without
18242 * warning messages.
18243 *
18244 * Note: This code preserves the legacy behavior of
18245 * comparing xb_nr_retry_count against zero for fibre
18246 * channel targets instead of comparing against the
18247 * un_reset_retry_count value. The reason for this
18248 * discrepancy has been so utterly lost beneath the
18249 * Sands of Time that even Indiana Jones could not
18250 * find it.
18251 */
18252 if (un->un_f_is_fibre == TRUE) {
18253 if (((sd_level_mask & SD_LOGMASK_DIAG) ||
18254 (xp->xb_nr_retry_count > 0)) &&
18255 (un->un_startstop_timeid == NULL)) {
18256 scsi_log(SD_DEVINFO(un), sd_label,
18257 CE_WARN, "logical unit not ready, "
18258 "resetting disk\n");
18259 sd_reset_target(un, pktp);
18260 }
18261 } else {
18262 if (((sd_level_mask & SD_LOGMASK_DIAG) ||
18263 (xp->xb_nr_retry_count >
18264 un->un_reset_retry_count)) &&
18265 (un->un_startstop_timeid == NULL)) {
18266 scsi_log(SD_DEVINFO(un), sd_label,
18267 CE_WARN, "logical unit not ready, "
18268 "resetting disk\n");
18269 sd_reset_target(un, pktp);
18270 }
18271 }
18272 break;
18273
18274 case 0x01: /* LUN IS IN PROCESS OF BECOMING READY */
18275 /*
18276 * If the target is in the process of becoming
18277 * ready, just proceed with the retry. This can
18278 * happen with CD-ROMs that take a long time to
18279 * read TOC after a power cycle or reset.
18280 */
18281 goto do_retry;
18282
18283 case 0x02: /* LUN NOT READY, INITITIALIZING CMD REQUIRED */
18284 break;
18285
18286 case 0x03: /* LUN NOT READY, MANUAL INTERVENTION REQUIRED */
18287 /*
18288 * Retries cannot help here so just fail right away.
18289 */
18290 goto fail_command;
18291
18292 case 0x88:
18293 /*
18294 * Vendor-unique code for T3/T4: it indicates a
18295 * path problem in a mutipathed config, but as far as
18296 * the target driver is concerned it equates to a fatal
18297 * error, so we should just fail the command right away
18298 * (without printing anything to the console). If this
18299 * is not a T3/T4, fall thru to the default recovery
18300 * action.
18301 * T3/T4 is FC only, don't need to check is_fibre
18302 */
18303 if (SD_IS_T3(un) || SD_IS_T4(un)) {
18304 sd_return_failed_command(un, bp, EIO);
18305 return;
18306 }
18307 /* FALLTHRU */
18308
18309 case 0x04: /* LUN NOT READY, FORMAT IN PROGRESS */
18310 case 0x05: /* LUN NOT READY, REBUILD IN PROGRESS */
18311 case 0x06: /* LUN NOT READY, RECALCULATION IN PROGRESS */
18312 case 0x07: /* LUN NOT READY, OPERATION IN PROGRESS */
18313 case 0x08: /* LUN NOT READY, LONG WRITE IN PROGRESS */
18314 default: /* Possible future codes in SCSI spec? */
18315 /*
18316 * For removable-media devices, do not retry if
18317 * ASCQ > 2 as these result mostly from USCSI commands
18318 * on MMC devices issued to check status of an
18319 * operation initiated in immediate mode. Also for
18320 * ASCQ >= 4 do not print console messages as these
18321 * mainly represent a user-initiated operation
18322 * instead of a system failure.
18323 */
18324 if (un->un_f_has_removable_media) {
18325 si.ssi_severity = SCSI_ERR_ALL;
18326 goto fail_command;
18327 }
18328 break;
18329 }
18330
18331 /*
18332 * As part of our recovery attempt for the NOT READY
18333 * condition, we issue a START STOP UNIT command. However
18334 * we want to wait for a short delay before attempting this
18335 * as there may still be more commands coming back from the
18336 * target with the check condition. To do this we use
18337 * timeout(9F) to call sd_start_stop_unit_callback() after
18338 * the delay interval expires. (sd_start_stop_unit_callback()
18339 * dispatches sd_start_stop_unit_task(), which will issue
18340 * the actual START STOP UNIT command. The delay interval
18341 * is one-half of the delay that we will use to retry the
18342 * command that generated the NOT READY condition.
18343 *
18344 * Note that we could just dispatch sd_start_stop_unit_task()
18345 * from here and allow it to sleep for the delay interval,
18346 * but then we would be tying up the taskq thread
18347 * uncesessarily for the duration of the delay.
18348 *
18349 * Do not issue the START STOP UNIT if the current command
18350 * is already a START STOP UNIT.
18351 */
18352 if (pktp->pkt_cdbp[0] == SCMD_START_STOP) {
18353 break;
18354 }
18355
18356 /*
18357 * Do not schedule the timeout if one is already pending.
18358 */
18359 if (un->un_startstop_timeid != NULL) {
18360 SD_INFO(SD_LOG_ERROR, un,
18361 "sd_sense_key_not_ready: restart already issued to"
18362 " %s%d\n", ddi_driver_name(SD_DEVINFO(un)),
18363 ddi_get_instance(SD_DEVINFO(un)));
18364 break;
18365 }
18366
18367 /*
18368 * Schedule the START STOP UNIT command, then queue the command
18369 * for a retry.
18370 *
18371 * Note: A timeout is not scheduled for this retry because we
18372 * want the retry to be serial with the START_STOP_UNIT. The
18373 * retry will be started when the START_STOP_UNIT is completed
18374 * in sd_start_stop_unit_task.
18375 */
18376 un->un_startstop_timeid = timeout(sd_start_stop_unit_callback,
18377 un, un->un_busy_timeout / 2);
18378 xp->xb_nr_retry_count++;
18379 sd_set_retry_bp(un, bp, 0, kstat_waitq_enter);
18380 return;
18381
18382 case 0x05: /* LOGICAL UNIT DOES NOT RESPOND TO SELECTION */
18383 if (sd_error_level < SCSI_ERR_RETRYABLE) {
18384 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
18385 "unit does not respond to selection\n");
18386 }
18387 break;
18388
18389 case 0x3A: /* MEDIUM NOT PRESENT */
18390 if (sd_error_level >= SCSI_ERR_FATAL) {
18391 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
18392 "Caddy not inserted in drive\n");
18393 }
18394
18395 sr_ejected(un);
18396 un->un_mediastate = DKIO_EJECTED;
18397 /* The state has changed, inform the media watch routines */
18398 cv_broadcast(&un->un_state_cv);
18399 /* Just fail if no media is present in the drive. */
18400 goto fail_command;
18401
18402 default:
18403 if (sd_error_level < SCSI_ERR_RETRYABLE) {
18404 scsi_log(SD_DEVINFO(un), sd_label, CE_NOTE,
18405 "Unit not Ready. Additional sense code 0x%x\n",
18406 asc);
18407 }
18408 break;
18409 }
18410
18411 do_retry:
18412
18413 /*
18414 * Retry the command, as some targets may report NOT READY for
18415 * several seconds after being reset.
18416 */
18417 xp->xb_nr_retry_count++;
18418 si.ssi_severity = SCSI_ERR_RETRYABLE;
18419 sd_retry_command(un, bp, SD_RETRIES_NOCHECK, sd_print_sense_msg,
18420 &si, EIO, un->un_busy_timeout, NULL);
18421
18422 return;
18423
18424 fail_command:
18425 sd_print_sense_msg(un, bp, &si, SD_NO_RETRY_ISSUED);
18426 sd_return_failed_command(un, bp, EIO);
18427 }
18428
18429
18430
18431 /*
18432 * Function: sd_sense_key_medium_or_hardware_error
18433 *
18434 * Description: Recovery actions for a SCSI "Medium Error" or "Hardware Error"
18435 * sense key.
18436 *
18437 * Context: May be called from interrupt context
18438 */
18439
18440 static void
18441 sd_sense_key_medium_or_hardware_error(struct sd_lun *un,
18442 uint8_t *sense_datap,
18443 struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp)
18444 {
18445 struct sd_sense_info si;
18446 uint8_t sense_key = scsi_sense_key(sense_datap);
18447 uint8_t asc = scsi_sense_asc(sense_datap);
18448
18449 ASSERT(un != NULL);
18450 ASSERT(mutex_owned(SD_MUTEX(un)));
18451 ASSERT(bp != NULL);
18452 ASSERT(xp != NULL);
18453 ASSERT(pktp != NULL);
18454
18455 si.ssi_severity = SCSI_ERR_FATAL;
18456 si.ssi_pfa_flag = FALSE;
18457
18458 if (sense_key == KEY_MEDIUM_ERROR) {
18459 SD_UPDATE_ERRSTATS(un, sd_rq_media_err);
18460 }
18461
18462 SD_UPDATE_ERRSTATS(un, sd_harderrs);
18463
18464 if ((un->un_reset_retry_count != 0) &&
18465 (xp->xb_retry_count == un->un_reset_retry_count)) {
18466 mutex_exit(SD_MUTEX(un));
18467 /* Do NOT do a RESET_ALL here: too intrusive. (4112858) */
18468 if (un->un_f_allow_bus_device_reset == TRUE) {
18469
18470 boolean_t try_resetting_target = B_TRUE;
18471
18472 /*
18473 * We need to be able to handle specific ASC when we are
18474 * handling a KEY_HARDWARE_ERROR. In particular
18475 * taking the default action of resetting the target may
18476 * not be the appropriate way to attempt recovery.
18477 * Resetting a target because of a single LUN failure
18478 * victimizes all LUNs on that target.
18479 *
18480 * This is true for the LSI arrays, if an LSI
18481 * array controller returns an ASC of 0x84 (LUN Dead) we
18482 * should trust it.
18483 */
18484
18485 if (sense_key == KEY_HARDWARE_ERROR) {
18486 switch (asc) {
18487 case 0x84:
18488 if (SD_IS_LSI(un)) {
18489 try_resetting_target = B_FALSE;
18490 }
18491 break;
18492 default:
18493 break;
18494 }
18495 }
18496
18497 if (try_resetting_target == B_TRUE) {
18498 int reset_retval = 0;
18499 if (un->un_f_lun_reset_enabled == TRUE) {
18500 SD_TRACE(SD_LOG_IO_CORE, un,
18501 "sd_sense_key_medium_or_hardware_"
18502 "error: issuing RESET_LUN\n");
18503 reset_retval =
18504 scsi_reset(SD_ADDRESS(un),
18505 RESET_LUN);
18506 }
18507 if (reset_retval == 0) {
18508 SD_TRACE(SD_LOG_IO_CORE, un,
18509 "sd_sense_key_medium_or_hardware_"
18510 "error: issuing RESET_TARGET\n");
18511 (void) scsi_reset(SD_ADDRESS(un),
18512 RESET_TARGET);
18513 }
18514 }
18515 }
18516 mutex_enter(SD_MUTEX(un));
18517 }
18518
18519 /*
18520 * This really ought to be a fatal error, but we will retry anyway
18521 * as some drives report this as a spurious error.
18522 */
18523 sd_retry_command(un, bp, SD_RETRIES_STANDARD, sd_print_sense_msg,
18524 &si, EIO, (clock_t)0, NULL);
18525 }
18526
18527
18528
18529 /*
18530 * Function: sd_sense_key_illegal_request
18531 *
18532 * Description: Recovery actions for a SCSI "Illegal Request" sense key.
18533 *
18534 * Context: May be called from interrupt context
18535 */
18536
18537 static void
18538 sd_sense_key_illegal_request(struct sd_lun *un, struct buf *bp,
18539 struct sd_xbuf *xp, struct scsi_pkt *pktp)
18540 {
18541 struct sd_sense_info si;
18542
18543 ASSERT(un != NULL);
18544 ASSERT(mutex_owned(SD_MUTEX(un)));
18545 ASSERT(bp != NULL);
18546 ASSERT(xp != NULL);
18547 ASSERT(pktp != NULL);
18548
18549 SD_UPDATE_ERRSTATS(un, sd_rq_illrq_err);
18550
18551 si.ssi_severity = SCSI_ERR_INFO;
18552 si.ssi_pfa_flag = FALSE;
18553
18554 /* Pointless to retry if the target thinks it's an illegal request */
18555 sd_print_sense_msg(un, bp, &si, SD_NO_RETRY_ISSUED);
18556 sd_return_failed_command(un, bp, EIO);
18557 }
18558
18559
18560
18561
18562 /*
18563 * Function: sd_sense_key_unit_attention
18564 *
18565 * Description: Recovery actions for a SCSI "Unit Attention" sense key.
18566 *
18567 * Context: May be called from interrupt context
18568 */
18569
18570 static void
18571 sd_sense_key_unit_attention(struct sd_lun *un,
18572 uint8_t *sense_datap,
18573 struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp)
18574 {
18575 /*
18576 * For UNIT ATTENTION we allow retries for one minute. Devices
18577 * like Sonoma can return UNIT ATTENTION close to a minute
18578 * under certain conditions.
18579 */
18580 int retry_check_flag = SD_RETRIES_UA;
18581 boolean_t kstat_updated = B_FALSE;
18582 struct sd_sense_info si;
18583 uint8_t asc = scsi_sense_asc(sense_datap);
18584 uint8_t ascq = scsi_sense_ascq(sense_datap);
18585
18586 ASSERT(un != NULL);
18587 ASSERT(mutex_owned(SD_MUTEX(un)));
18588 ASSERT(bp != NULL);
18589 ASSERT(xp != NULL);
18590 ASSERT(pktp != NULL);
18591
18592 si.ssi_severity = SCSI_ERR_INFO;
18593 si.ssi_pfa_flag = FALSE;
18594
18595
18596 switch (asc) {
18597 case 0x5D: /* FAILURE PREDICTION THRESHOLD EXCEEDED */
18598 if (sd_report_pfa != 0) {
18599 SD_UPDATE_ERRSTATS(un, sd_rq_pfa_err);
18600 si.ssi_pfa_flag = TRUE;
18601 retry_check_flag = SD_RETRIES_STANDARD;
18602 goto do_retry;
18603 }
18604
18605 break;
18606
18607 case 0x29: /* POWER ON, RESET, OR BUS DEVICE RESET OCCURRED */
18608 if ((un->un_resvd_status & SD_RESERVE) == SD_RESERVE) {
18609 un->un_resvd_status |=
18610 (SD_LOST_RESERVE | SD_WANT_RESERVE);
18611 }
18612 #ifdef _LP64
18613 if (un->un_blockcount + 1 > SD_GROUP1_MAX_ADDRESS) {
18614 if (taskq_dispatch(sd_tq, sd_reenable_dsense_task,
18615 un, KM_NOSLEEP) == 0) {
18616 /*
18617 * If we can't dispatch the task we'll just
18618 * live without descriptor sense. We can
18619 * try again on the next "unit attention"
18620 */
18621 SD_ERROR(SD_LOG_ERROR, un,
18622 "sd_sense_key_unit_attention: "
18623 "Could not dispatch "
18624 "sd_reenable_dsense_task\n");
18625 }
18626 }
18627 #endif /* _LP64 */
18628 /* FALLTHRU */
18629
18630 case 0x28: /* NOT READY TO READY CHANGE, MEDIUM MAY HAVE CHANGED */
18631 if (!un->un_f_has_removable_media) {
18632 break;
18633 }
18634
18635 /*
18636 * When we get a unit attention from a removable-media device,
18637 * it may be in a state that will take a long time to recover
18638 * (e.g., from a reset). Since we are executing in interrupt
18639 * context here, we cannot wait around for the device to come
18640 * back. So hand this command off to sd_media_change_task()
18641 * for deferred processing under taskq thread context. (Note
18642 * that the command still may be failed if a problem is
18643 * encountered at a later time.)
18644 */
18645 if (taskq_dispatch(sd_tq, sd_media_change_task, pktp,
18646 KM_NOSLEEP) == 0) {
18647 /*
18648 * Cannot dispatch the request so fail the command.
18649 */
18650 SD_UPDATE_ERRSTATS(un, sd_harderrs);
18651 SD_UPDATE_ERRSTATS(un, sd_rq_nodev_err);
18652 si.ssi_severity = SCSI_ERR_FATAL;
18653 sd_print_sense_msg(un, bp, &si, SD_NO_RETRY_ISSUED);
18654 sd_return_failed_command(un, bp, EIO);
18655 }
18656
18657 /*
18658 * If failed to dispatch sd_media_change_task(), we already
18659 * updated kstat. If succeed to dispatch sd_media_change_task(),
18660 * we should update kstat later if it encounters an error. So,
18661 * we update kstat_updated flag here.
18662 */
18663 kstat_updated = B_TRUE;
18664
18665 /*
18666 * Either the command has been successfully dispatched to a
18667 * task Q for retrying, or the dispatch failed. In either case
18668 * do NOT retry again by calling sd_retry_command. This sets up
18669 * two retries of the same command and when one completes and
18670 * frees the resources the other will access freed memory,
18671 * a bad thing.
18672 */
18673 return;
18674
18675 default:
18676 break;
18677 }
18678
18679 /*
18680 * ASC ASCQ
18681 * 2A 09 Capacity data has changed
18682 * 2A 01 Mode parameters changed
18683 * 3F 0E Reported luns data has changed
18684 * Arrays that support logical unit expansion should report
18685 * capacity changes(2Ah/09). Mode parameters changed and
18686 * reported luns data has changed are the approximation.
18687 */
18688 if (((asc == 0x2a) && (ascq == 0x09)) ||
18689 ((asc == 0x2a) && (ascq == 0x01)) ||
18690 ((asc == 0x3f) && (ascq == 0x0e))) {
18691 if (taskq_dispatch(sd_tq, sd_target_change_task, un,
18692 KM_NOSLEEP) == 0) {
18693 SD_ERROR(SD_LOG_ERROR, un,
18694 "sd_sense_key_unit_attention: "
18695 "Could not dispatch sd_target_change_task\n");
18696 }
18697 }
18698
18699 /*
18700 * Update kstat if we haven't done that.
18701 */
18702 if (!kstat_updated) {
18703 SD_UPDATE_ERRSTATS(un, sd_harderrs);
18704 SD_UPDATE_ERRSTATS(un, sd_rq_nodev_err);
18705 }
18706
18707 do_retry:
18708 sd_retry_command(un, bp, retry_check_flag, sd_print_sense_msg, &si,
18709 EIO, SD_UA_RETRY_DELAY, NULL);
18710 }
18711
18712
18713
18714 /*
18715 * Function: sd_sense_key_fail_command
18716 *
18717 * Description: Use to fail a command when we don't like the sense key that
18718 * was returned.
18719 *
18720 * Context: May be called from interrupt context
18721 */
18722
18723 static void
18724 sd_sense_key_fail_command(struct sd_lun *un, struct buf *bp,
18725 struct sd_xbuf *xp, struct scsi_pkt *pktp)
18726 {
18727 struct sd_sense_info si;
18728
18729 ASSERT(un != NULL);
18730 ASSERT(mutex_owned(SD_MUTEX(un)));
18731 ASSERT(bp != NULL);
18732 ASSERT(xp != NULL);
18733 ASSERT(pktp != NULL);
18734
18735 si.ssi_severity = SCSI_ERR_FATAL;
18736 si.ssi_pfa_flag = FALSE;
18737
18738 sd_print_sense_msg(un, bp, &si, SD_NO_RETRY_ISSUED);
18739 sd_return_failed_command(un, bp, EIO);
18740 }
18741
18742
18743
18744 /*
18745 * Function: sd_sense_key_blank_check
18746 *
18747 * Description: Recovery actions for a SCSI "Blank Check" sense key.
18748 * Has no monetary connotation.
18749 *
18750 * Context: May be called from interrupt context
18751 */
18752
18753 static void
18754 sd_sense_key_blank_check(struct sd_lun *un, struct buf *bp,
18755 struct sd_xbuf *xp, struct scsi_pkt *pktp)
18756 {
18757 struct sd_sense_info si;
18758
18759 ASSERT(un != NULL);
18760 ASSERT(mutex_owned(SD_MUTEX(un)));
18761 ASSERT(bp != NULL);
18762 ASSERT(xp != NULL);
18763 ASSERT(pktp != NULL);
18764
18765 /*
18766 * Blank check is not fatal for removable devices, therefore
18767 * it does not require a console message.
18768 */
18769 si.ssi_severity = (un->un_f_has_removable_media) ? SCSI_ERR_ALL :
18770 SCSI_ERR_FATAL;
18771 si.ssi_pfa_flag = FALSE;
18772
18773 sd_print_sense_msg(un, bp, &si, SD_NO_RETRY_ISSUED);
18774 sd_return_failed_command(un, bp, EIO);
18775 }
18776
18777
18778
18779
18780 /*
18781 * Function: sd_sense_key_aborted_command
18782 *
18783 * Description: Recovery actions for a SCSI "Aborted Command" sense key.
18784 *
18785 * Context: May be called from interrupt context
18786 */
18787
18788 static void
18789 sd_sense_key_aborted_command(struct sd_lun *un, struct buf *bp,
18790 struct sd_xbuf *xp, struct scsi_pkt *pktp)
18791 {
18792 struct sd_sense_info si;
18793
18794 ASSERT(un != NULL);
18795 ASSERT(mutex_owned(SD_MUTEX(un)));
18796 ASSERT(bp != NULL);
18797 ASSERT(xp != NULL);
18798 ASSERT(pktp != NULL);
18799
18800 si.ssi_severity = SCSI_ERR_FATAL;
18801 si.ssi_pfa_flag = FALSE;
18802
18803 SD_UPDATE_ERRSTATS(un, sd_harderrs);
18804
18805 /*
18806 * This really ought to be a fatal error, but we will retry anyway
18807 * as some drives report this as a spurious error.
18808 */
18809 sd_retry_command(un, bp, SD_RETRIES_STANDARD, sd_print_sense_msg,
18810 &si, EIO, drv_usectohz(100000), NULL);
18811 }
18812
18813
18814
18815 /*
18816 * Function: sd_sense_key_default
18817 *
18818 * Description: Default recovery action for several SCSI sense keys (basically
18819 * attempts a retry).
18820 *
18821 * Context: May be called from interrupt context
18822 */
18823
18824 static void
18825 sd_sense_key_default(struct sd_lun *un,
18826 uint8_t *sense_datap,
18827 struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp)
18828 {
18829 struct sd_sense_info si;
18830 uint8_t sense_key = scsi_sense_key(sense_datap);
18831
18832 ASSERT(un != NULL);
18833 ASSERT(mutex_owned(SD_MUTEX(un)));
18834 ASSERT(bp != NULL);
18835 ASSERT(xp != NULL);
18836 ASSERT(pktp != NULL);
18837
18838 SD_UPDATE_ERRSTATS(un, sd_harderrs);
18839
18840 /*
18841 * Undecoded sense key. Attempt retries and hope that will fix
18842 * the problem. Otherwise, we're dead.
18843 */
18844 if ((pktp->pkt_flags & FLAG_SILENT) == 0) {
18845 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
18846 "Unhandled Sense Key '%s'\n", sense_keys[sense_key]);
18847 }
18848
18849 si.ssi_severity = SCSI_ERR_FATAL;
18850 si.ssi_pfa_flag = FALSE;
18851
18852 sd_retry_command(un, bp, SD_RETRIES_STANDARD, sd_print_sense_msg,
18853 &si, EIO, (clock_t)0, NULL);
18854 }
18855
18856
18857
18858 /*
18859 * Function: sd_print_retry_msg
18860 *
18861 * Description: Print a message indicating the retry action being taken.
18862 *
18863 * Arguments: un - ptr to associated softstate
18864 * bp - ptr to buf(9S) for the command
18865 * arg - not used.
18866 * flag - SD_IMMEDIATE_RETRY_ISSUED, SD_DELAYED_RETRY_ISSUED,
18867 * or SD_NO_RETRY_ISSUED
18868 *
18869 * Context: May be called from interrupt context
18870 */
18871 /* ARGSUSED */
18872 static void
18873 sd_print_retry_msg(struct sd_lun *un, struct buf *bp, void *arg, int flag)
18874 {
18875 struct sd_xbuf *xp;
18876 struct scsi_pkt *pktp;
18877 char *reasonp;
18878 char *msgp;
18879
18880 ASSERT(un != NULL);
18881 ASSERT(mutex_owned(SD_MUTEX(un)));
18882 ASSERT(bp != NULL);
18883 pktp = SD_GET_PKTP(bp);
18884 ASSERT(pktp != NULL);
18885 xp = SD_GET_XBUF(bp);
18886 ASSERT(xp != NULL);
18887
18888 ASSERT(!mutex_owned(&un->un_pm_mutex));
18889 mutex_enter(&un->un_pm_mutex);
18890 if ((un->un_state == SD_STATE_SUSPENDED) ||
18891 (SD_DEVICE_IS_IN_LOW_POWER(un)) ||
18892 (pktp->pkt_flags & FLAG_SILENT)) {
18893 mutex_exit(&un->un_pm_mutex);
18894 goto update_pkt_reason;
18895 }
18896 mutex_exit(&un->un_pm_mutex);
18897
18898 /*
18899 * Suppress messages if they are all the same pkt_reason; with
18900 * TQ, many (up to 256) are returned with the same pkt_reason.
18901 * If we are in panic, then suppress the retry messages.
18902 */
18903 switch (flag) {
18904 case SD_NO_RETRY_ISSUED:
18905 msgp = "giving up";
18906 break;
18907 case SD_IMMEDIATE_RETRY_ISSUED:
18908 case SD_DELAYED_RETRY_ISSUED:
18909 if (ddi_in_panic() || (un->un_state == SD_STATE_OFFLINE) ||
18910 ((pktp->pkt_reason == un->un_last_pkt_reason) &&
18911 (sd_error_level != SCSI_ERR_ALL))) {
18912 return;
18913 }
18914 msgp = "retrying command";
18915 break;
18916 default:
18917 goto update_pkt_reason;
18918 }
18919
18920 reasonp = (((pktp->pkt_statistics & STAT_PERR) != 0) ? "parity error" :
18921 scsi_rname(pktp->pkt_reason));
18922
18923 if (SD_FM_LOG(un) == SD_FM_LOG_NSUP) {
18924 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
18925 "SCSI transport failed: reason '%s': %s\n", reasonp, msgp);
18926 }
18927
18928 update_pkt_reason:
18929 /*
18930 * Update un->un_last_pkt_reason with the value in pktp->pkt_reason.
18931 * This is to prevent multiple console messages for the same failure
18932 * condition. Note that un->un_last_pkt_reason is NOT restored if &
18933 * when the command is retried successfully because there still may be
18934 * more commands coming back with the same value of pktp->pkt_reason.
18935 */
18936 if ((pktp->pkt_reason != CMD_CMPLT) || (xp->xb_retry_count == 0)) {
18937 un->un_last_pkt_reason = pktp->pkt_reason;
18938 }
18939 }
18940
18941
18942 /*
18943 * Function: sd_print_cmd_incomplete_msg
18944 *
18945 * Description: Message logging fn. for a SCSA "CMD_INCOMPLETE" pkt_reason.
18946 *
18947 * Arguments: un - ptr to associated softstate
18948 * bp - ptr to buf(9S) for the command
18949 * arg - passed to sd_print_retry_msg()
18950 * code - SD_IMMEDIATE_RETRY_ISSUED, SD_DELAYED_RETRY_ISSUED,
18951 * or SD_NO_RETRY_ISSUED
18952 *
18953 * Context: May be called from interrupt context
18954 */
18955
18956 static void
18957 sd_print_cmd_incomplete_msg(struct sd_lun *un, struct buf *bp, void *arg,
18958 int code)
18959 {
18960 dev_info_t *dip;
18961
18962 ASSERT(un != NULL);
18963 ASSERT(mutex_owned(SD_MUTEX(un)));
18964 ASSERT(bp != NULL);
18965
18966 switch (code) {
18967 case SD_NO_RETRY_ISSUED:
18968 /* Command was failed. Someone turned off this target? */
18969 if (un->un_state != SD_STATE_OFFLINE) {
18970 /*
18971 * Suppress message if we are detaching and
18972 * device has been disconnected
18973 * Note that DEVI_IS_DEVICE_REMOVED is a consolidation
18974 * private interface and not part of the DDI
18975 */
18976 dip = un->un_sd->sd_dev;
18977 if (!(DEVI_IS_DETACHING(dip) &&
18978 DEVI_IS_DEVICE_REMOVED(dip))) {
18979 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
18980 "disk not responding to selection\n");
18981 }
18982 New_state(un, SD_STATE_OFFLINE);
18983 }
18984 break;
18985
18986 case SD_DELAYED_RETRY_ISSUED:
18987 case SD_IMMEDIATE_RETRY_ISSUED:
18988 default:
18989 /* Command was successfully queued for retry */
18990 sd_print_retry_msg(un, bp, arg, code);
18991 break;
18992 }
18993 }
18994
18995
18996 /*
18997 * Function: sd_pkt_reason_cmd_incomplete
18998 *
18999 * Description: Recovery actions for a SCSA "CMD_INCOMPLETE" pkt_reason.
19000 *
19001 * Context: May be called from interrupt context
19002 */
19003
19004 static void
19005 sd_pkt_reason_cmd_incomplete(struct sd_lun *un, struct buf *bp,
19006 struct sd_xbuf *xp, struct scsi_pkt *pktp)
19007 {
19008 int flag = SD_RETRIES_STANDARD | SD_RETRIES_ISOLATE;
19009
19010 ASSERT(un != NULL);
19011 ASSERT(mutex_owned(SD_MUTEX(un)));
19012 ASSERT(bp != NULL);
19013 ASSERT(xp != NULL);
19014 ASSERT(pktp != NULL);
19015
19016 /* Do not do a reset if selection did not complete */
19017 /* Note: Should this not just check the bit? */
19018 if (pktp->pkt_state != STATE_GOT_BUS) {
19019 SD_UPDATE_ERRSTATS(un, sd_transerrs);
19020 sd_reset_target(un, pktp);
19021 }
19022
19023 /*
19024 * If the target was not successfully selected, then set
19025 * SD_RETRIES_FAILFAST to indicate that we lost communication
19026 * with the target, and further retries and/or commands are
19027 * likely to take a long time.
19028 */
19029 if ((pktp->pkt_state & STATE_GOT_TARGET) == 0) {
19030 flag |= SD_RETRIES_FAILFAST;
19031 }
19032
19033 SD_UPDATE_RESERVATION_STATUS(un, pktp);
19034
19035 sd_retry_command(un, bp, flag,
19036 sd_print_cmd_incomplete_msg, NULL, EIO, SD_RESTART_TIMEOUT, NULL);
19037 }
19038
19039
19040
19041 /*
19042 * Function: sd_pkt_reason_cmd_tran_err
19043 *
19044 * Description: Recovery actions for a SCSA "CMD_TRAN_ERR" pkt_reason.
19045 *
19046 * Context: May be called from interrupt context
19047 */
19048
19049 static void
19050 sd_pkt_reason_cmd_tran_err(struct sd_lun *un, struct buf *bp,
19051 struct sd_xbuf *xp, struct scsi_pkt *pktp)
19052 {
19053 ASSERT(un != NULL);
19054 ASSERT(mutex_owned(SD_MUTEX(un)));
19055 ASSERT(bp != NULL);
19056 ASSERT(xp != NULL);
19057 ASSERT(pktp != NULL);
19058
19059 /*
19060 * Do not reset if we got a parity error, or if
19061 * selection did not complete.
19062 */
19063 SD_UPDATE_ERRSTATS(un, sd_harderrs);
19064 /* Note: Should this not just check the bit for pkt_state? */
19065 if (((pktp->pkt_statistics & STAT_PERR) == 0) &&
19066 (pktp->pkt_state != STATE_GOT_BUS)) {
19067 SD_UPDATE_ERRSTATS(un, sd_transerrs);
19068 sd_reset_target(un, pktp);
19069 }
19070
19071 SD_UPDATE_RESERVATION_STATUS(un, pktp);
19072
19073 sd_retry_command(un, bp, (SD_RETRIES_STANDARD | SD_RETRIES_ISOLATE),
19074 sd_print_retry_msg, NULL, EIO, SD_RESTART_TIMEOUT, NULL);
19075 }
19076
19077
19078
19079 /*
19080 * Function: sd_pkt_reason_cmd_reset
19081 *
19082 * Description: Recovery actions for a SCSA "CMD_RESET" pkt_reason.
19083 *
19084 * Context: May be called from interrupt context
19085 */
19086
19087 static void
19088 sd_pkt_reason_cmd_reset(struct sd_lun *un, struct buf *bp,
19089 struct sd_xbuf *xp, struct scsi_pkt *pktp)
19090 {
19091 ASSERT(un != NULL);
19092 ASSERT(mutex_owned(SD_MUTEX(un)));
19093 ASSERT(bp != NULL);
19094 ASSERT(xp != NULL);
19095 ASSERT(pktp != NULL);
19096
19097 /* The target may still be running the command, so try to reset. */
19098 SD_UPDATE_ERRSTATS(un, sd_transerrs);
19099 sd_reset_target(un, pktp);
19100
19101 SD_UPDATE_RESERVATION_STATUS(un, pktp);
19102
19103 /*
19104 * If pkt_reason is CMD_RESET chances are that this pkt got
19105 * reset because another target on this bus caused it. The target
19106 * that caused it should get CMD_TIMEOUT with pkt_statistics
19107 * of STAT_TIMEOUT/STAT_DEV_RESET.
19108 */
19109
19110 sd_retry_command(un, bp, (SD_RETRIES_VICTIM | SD_RETRIES_ISOLATE),
19111 sd_print_retry_msg, NULL, EIO, SD_RESTART_TIMEOUT, NULL);
19112 }
19113
19114
19115
19116
19117 /*
19118 * Function: sd_pkt_reason_cmd_aborted
19119 *
19120 * Description: Recovery actions for a SCSA "CMD_ABORTED" pkt_reason.
19121 *
19122 * Context: May be called from interrupt context
19123 */
19124
19125 static void
19126 sd_pkt_reason_cmd_aborted(struct sd_lun *un, struct buf *bp,
19127 struct sd_xbuf *xp, struct scsi_pkt *pktp)
19128 {
19129 ASSERT(un != NULL);
19130 ASSERT(mutex_owned(SD_MUTEX(un)));
19131 ASSERT(bp != NULL);
19132 ASSERT(xp != NULL);
19133 ASSERT(pktp != NULL);
19134
19135 /* The target may still be running the command, so try to reset. */
19136 SD_UPDATE_ERRSTATS(un, sd_transerrs);
19137 sd_reset_target(un, pktp);
19138
19139 SD_UPDATE_RESERVATION_STATUS(un, pktp);
19140
19141 /*
19142 * If pkt_reason is CMD_ABORTED chances are that this pkt got
19143 * aborted because another target on this bus caused it. The target
19144 * that caused it should get CMD_TIMEOUT with pkt_statistics
19145 * of STAT_TIMEOUT/STAT_DEV_RESET.
19146 */
19147
19148 sd_retry_command(un, bp, (SD_RETRIES_VICTIM | SD_RETRIES_ISOLATE),
19149 sd_print_retry_msg, NULL, EIO, SD_RESTART_TIMEOUT, NULL);
19150 }
19151
19152
19153
19154 /*
19155 * Function: sd_pkt_reason_cmd_timeout
19156 *
19157 * Description: Recovery actions for a SCSA "CMD_TIMEOUT" pkt_reason.
19158 *
19159 * Context: May be called from interrupt context
19160 */
19161
19162 static void
19163 sd_pkt_reason_cmd_timeout(struct sd_lun *un, struct buf *bp,
19164 struct sd_xbuf *xp, struct scsi_pkt *pktp)
19165 {
19166 ASSERT(un != NULL);
19167 ASSERT(mutex_owned(SD_MUTEX(un)));
19168 ASSERT(bp != NULL);
19169 ASSERT(xp != NULL);
19170 ASSERT(pktp != NULL);
19171
19172
19173 SD_UPDATE_ERRSTATS(un, sd_transerrs);
19174 sd_reset_target(un, pktp);
19175
19176 SD_UPDATE_RESERVATION_STATUS(un, pktp);
19177
19178 /*
19179 * A command timeout indicates that we could not establish
19180 * communication with the target, so set SD_RETRIES_FAILFAST
19181 * as further retries/commands are likely to take a long time.
19182 */
19183 sd_retry_command(un, bp,
19184 (SD_RETRIES_STANDARD | SD_RETRIES_ISOLATE | SD_RETRIES_FAILFAST),
19185 sd_print_retry_msg, NULL, EIO, SD_RESTART_TIMEOUT, NULL);
19186 }
19187
19188
19189
19190 /*
19191 * Function: sd_pkt_reason_cmd_unx_bus_free
19192 *
19193 * Description: Recovery actions for a SCSA "CMD_UNX_BUS_FREE" pkt_reason.
19194 *
19195 * Context: May be called from interrupt context
19196 */
19197
19198 static void
19199 sd_pkt_reason_cmd_unx_bus_free(struct sd_lun *un, struct buf *bp,
19200 struct sd_xbuf *xp, struct scsi_pkt *pktp)
19201 {
19202 void (*funcp)(struct sd_lun *un, struct buf *bp, void *arg, int code);
19203
19204 ASSERT(un != NULL);
19205 ASSERT(mutex_owned(SD_MUTEX(un)));
19206 ASSERT(bp != NULL);
19207 ASSERT(xp != NULL);
19208 ASSERT(pktp != NULL);
19209
19210 SD_UPDATE_ERRSTATS(un, sd_harderrs);
19211 SD_UPDATE_RESERVATION_STATUS(un, pktp);
19212
19213 funcp = ((pktp->pkt_statistics & STAT_PERR) == 0) ?
19214 sd_print_retry_msg : NULL;
19215
19216 sd_retry_command(un, bp, (SD_RETRIES_STANDARD | SD_RETRIES_ISOLATE),
19217 funcp, NULL, EIO, SD_RESTART_TIMEOUT, NULL);
19218 }
19219
19220
19221 /*
19222 * Function: sd_pkt_reason_cmd_tag_reject
19223 *
19224 * Description: Recovery actions for a SCSA "CMD_TAG_REJECT" pkt_reason.
19225 *
19226 * Context: May be called from interrupt context
19227 */
19228
19229 static void
19230 sd_pkt_reason_cmd_tag_reject(struct sd_lun *un, struct buf *bp,
19231 struct sd_xbuf *xp, struct scsi_pkt *pktp)
19232 {
19233 ASSERT(un != NULL);
19234 ASSERT(mutex_owned(SD_MUTEX(un)));
19235 ASSERT(bp != NULL);
19236 ASSERT(xp != NULL);
19237 ASSERT(pktp != NULL);
19238
19239 SD_UPDATE_ERRSTATS(un, sd_harderrs);
19240 pktp->pkt_flags = 0;
19241 un->un_tagflags = 0;
19242 if (un->un_f_opt_queueing == TRUE) {
19243 un->un_throttle = min(un->un_throttle, 3);
19244 } else {
19245 un->un_throttle = 1;
19246 }
19247 mutex_exit(SD_MUTEX(un));
19248 (void) scsi_ifsetcap(SD_ADDRESS(un), "tagged-qing", 0, 1);
19249 mutex_enter(SD_MUTEX(un));
19250
19251 SD_UPDATE_RESERVATION_STATUS(un, pktp);
19252
19253 /* Legacy behavior not to check retry counts here. */
19254 sd_retry_command(un, bp, (SD_RETRIES_NOCHECK | SD_RETRIES_ISOLATE),
19255 sd_print_retry_msg, NULL, EIO, SD_RESTART_TIMEOUT, NULL);
19256 }
19257
19258
19259 /*
19260 * Function: sd_pkt_reason_default
19261 *
19262 * Description: Default recovery actions for SCSA pkt_reason values that
19263 * do not have more explicit recovery actions.
19264 *
19265 * Context: May be called from interrupt context
19266 */
19267
19268 static void
19269 sd_pkt_reason_default(struct sd_lun *un, struct buf *bp,
19270 struct sd_xbuf *xp, struct scsi_pkt *pktp)
19271 {
19272 ASSERT(un != NULL);
19273 ASSERT(mutex_owned(SD_MUTEX(un)));
19274 ASSERT(bp != NULL);
19275 ASSERT(xp != NULL);
19276 ASSERT(pktp != NULL);
19277
19278 SD_UPDATE_ERRSTATS(un, sd_transerrs);
19279 sd_reset_target(un, pktp);
19280
19281 SD_UPDATE_RESERVATION_STATUS(un, pktp);
19282
19283 sd_retry_command(un, bp, (SD_RETRIES_STANDARD | SD_RETRIES_ISOLATE),
19284 sd_print_retry_msg, NULL, EIO, SD_RESTART_TIMEOUT, NULL);
19285 }
19286
19287
19288
19289 /*
19290 * Function: sd_pkt_status_check_condition
19291 *
19292 * Description: Recovery actions for a "STATUS_CHECK" SCSI command status.
19293 *
19294 * Context: May be called from interrupt context
19295 */
19296
19297 static void
19298 sd_pkt_status_check_condition(struct sd_lun *un, struct buf *bp,
19299 struct sd_xbuf *xp, struct scsi_pkt *pktp)
19300 {
19301 ASSERT(un != NULL);
19302 ASSERT(mutex_owned(SD_MUTEX(un)));
19303 ASSERT(bp != NULL);
19304 ASSERT(xp != NULL);
19305 ASSERT(pktp != NULL);
19306
19307 SD_TRACE(SD_LOG_IO, un, "sd_pkt_status_check_condition: "
19308 "entry: buf:0x%p xp:0x%p\n", bp, xp);
19309
19310 /*
19311 * If ARQ is NOT enabled, then issue a REQUEST SENSE command (the
19312 * command will be retried after the request sense). Otherwise, retry
19313 * the command. Note: we are issuing the request sense even though the
19314 * retry limit may have been reached for the failed command.
19315 */
19316 if (un->un_f_arq_enabled == FALSE) {
19317 SD_INFO(SD_LOG_IO_CORE, un, "sd_pkt_status_check_condition: "
19318 "no ARQ, sending request sense command\n");
19319 sd_send_request_sense_command(un, bp, pktp);
19320 } else {
19321 SD_INFO(SD_LOG_IO_CORE, un, "sd_pkt_status_check_condition: "
19322 "ARQ,retrying request sense command\n");
19323 #if defined(__i386) || defined(__amd64)
19324 /*
19325 * The SD_RETRY_DELAY value need to be adjusted here
19326 * when SD_RETRY_DELAY change in sddef.h
19327 */
19328 sd_retry_command(un, bp, SD_RETRIES_STANDARD, NULL, NULL, EIO,
19329 un->un_f_is_fibre?drv_usectohz(100000):(clock_t)0,
19330 NULL);
19331 #else
19332 sd_retry_command(un, bp, SD_RETRIES_STANDARD, NULL, NULL,
19333 EIO, SD_RETRY_DELAY, NULL);
19334 #endif
19335 }
19336
19337 SD_TRACE(SD_LOG_IO_CORE, un, "sd_pkt_status_check_condition: exit\n");
19338 }
19339
19340
19341 /*
19342 * Function: sd_pkt_status_busy
19343 *
19344 * Description: Recovery actions for a "STATUS_BUSY" SCSI command status.
19345 *
19346 * Context: May be called from interrupt context
19347 */
19348
19349 static void
19350 sd_pkt_status_busy(struct sd_lun *un, struct buf *bp, struct sd_xbuf *xp,
19351 struct scsi_pkt *pktp)
19352 {
19353 ASSERT(un != NULL);
19354 ASSERT(mutex_owned(SD_MUTEX(un)));
19355 ASSERT(bp != NULL);
19356 ASSERT(xp != NULL);
19357 ASSERT(pktp != NULL);
19358
19359 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19360 "sd_pkt_status_busy: entry\n");
19361
19362 /* If retries are exhausted, just fail the command. */
19363 if (xp->xb_retry_count >= un->un_busy_retry_count) {
19364 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
19365 "device busy too long\n");
19366 sd_return_failed_command(un, bp, EIO);
19367 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19368 "sd_pkt_status_busy: exit\n");
19369 return;
19370 }
19371 xp->xb_retry_count++;
19372
19373 /*
19374 * Try to reset the target. However, we do not want to perform
19375 * more than one reset if the device continues to fail. The reset
19376 * will be performed when the retry count reaches the reset
19377 * threshold. This threshold should be set such that at least
19378 * one retry is issued before the reset is performed.
19379 */
19380 if (xp->xb_retry_count ==
19381 ((un->un_reset_retry_count < 2) ? 2 : un->un_reset_retry_count)) {
19382 int rval = 0;
19383 mutex_exit(SD_MUTEX(un));
19384 if (un->un_f_allow_bus_device_reset == TRUE) {
19385 /*
19386 * First try to reset the LUN; if we cannot then
19387 * try to reset the target.
19388 */
19389 if (un->un_f_lun_reset_enabled == TRUE) {
19390 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19391 "sd_pkt_status_busy: RESET_LUN\n");
19392 rval = scsi_reset(SD_ADDRESS(un), RESET_LUN);
19393 }
19394 if (rval == 0) {
19395 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19396 "sd_pkt_status_busy: RESET_TARGET\n");
19397 rval = scsi_reset(SD_ADDRESS(un), RESET_TARGET);
19398 }
19399 }
19400 if (rval == 0) {
19401 /*
19402 * If the RESET_LUN and/or RESET_TARGET failed,
19403 * try RESET_ALL
19404 */
19405 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19406 "sd_pkt_status_busy: RESET_ALL\n");
19407 rval = scsi_reset(SD_ADDRESS(un), RESET_ALL);
19408 }
19409 mutex_enter(SD_MUTEX(un));
19410 if (rval == 0) {
19411 /*
19412 * The RESET_LUN, RESET_TARGET, and/or RESET_ALL failed.
19413 * At this point we give up & fail the command.
19414 */
19415 sd_return_failed_command(un, bp, EIO);
19416 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19417 "sd_pkt_status_busy: exit (failed cmd)\n");
19418 return;
19419 }
19420 }
19421
19422 /*
19423 * Retry the command. Be sure to specify SD_RETRIES_NOCHECK as
19424 * we have already checked the retry counts above.
19425 */
19426 sd_retry_command(un, bp, SD_RETRIES_NOCHECK, NULL, NULL,
19427 EIO, un->un_busy_timeout, NULL);
19428
19429 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19430 "sd_pkt_status_busy: exit\n");
19431 }
19432
19433
19434 /*
19435 * Function: sd_pkt_status_reservation_conflict
19436 *
19437 * Description: Recovery actions for a "STATUS_RESERVATION_CONFLICT" SCSI
19438 * command status.
19439 *
19440 * Context: May be called from interrupt context
19441 */
19442
19443 static void
19444 sd_pkt_status_reservation_conflict(struct sd_lun *un, struct buf *bp,
19445 struct sd_xbuf *xp, struct scsi_pkt *pktp)
19446 {
19447 ASSERT(un != NULL);
19448 ASSERT(mutex_owned(SD_MUTEX(un)));
19449 ASSERT(bp != NULL);
19450 ASSERT(xp != NULL);
19451 ASSERT(pktp != NULL);
19452
19453 /*
19454 * If the command was PERSISTENT_RESERVATION_[IN|OUT] then reservation
19455 * conflict could be due to various reasons like incorrect keys, not
19456 * registered or not reserved etc. So, we return EACCES to the caller.
19457 */
19458 if (un->un_reservation_type == SD_SCSI3_RESERVATION) {
19459 int cmd = SD_GET_PKT_OPCODE(pktp);
19460 if ((cmd == SCMD_PERSISTENT_RESERVE_IN) ||
19461 (cmd == SCMD_PERSISTENT_RESERVE_OUT)) {
19462 sd_return_failed_command(un, bp, EACCES);
19463 return;
19464 }
19465 }
19466
19467 un->un_resvd_status |= SD_RESERVATION_CONFLICT;
19468
19469 if ((un->un_resvd_status & SD_FAILFAST) != 0) {
19470 if (sd_failfast_enable != 0) {
19471 /* By definition, we must panic here.... */
19472 sd_panic_for_res_conflict(un);
19473 /*NOTREACHED*/
19474 }
19475 SD_ERROR(SD_LOG_IO, un,
19476 "sd_handle_resv_conflict: Disk Reserved\n");
19477 sd_return_failed_command(un, bp, EACCES);
19478 return;
19479 }
19480
19481 /*
19482 * 1147670: retry only if sd_retry_on_reservation_conflict
19483 * property is set (default is 1). Retries will not succeed
19484 * on a disk reserved by another initiator. HA systems
19485 * may reset this via sd.conf to avoid these retries.
19486 *
19487 * Note: The legacy return code for this failure is EIO, however EACCES
19488 * seems more appropriate for a reservation conflict.
19489 */
19490 if (sd_retry_on_reservation_conflict == 0) {
19491 SD_ERROR(SD_LOG_IO, un,
19492 "sd_handle_resv_conflict: Device Reserved\n");
19493 sd_return_failed_command(un, bp, EIO);
19494 return;
19495 }
19496
19497 /*
19498 * Retry the command if we can.
19499 *
19500 * Note: The legacy return code for this failure is EIO, however EACCES
19501 * seems more appropriate for a reservation conflict.
19502 */
19503 sd_retry_command(un, bp, SD_RETRIES_STANDARD, NULL, NULL, EIO,
19504 (clock_t)2, NULL);
19505 }
19506
19507
19508
19509 /*
19510 * Function: sd_pkt_status_qfull
19511 *
19512 * Description: Handle a QUEUE FULL condition from the target. This can
19513 * occur if the HBA does not handle the queue full condition.
19514 * (Basically this means third-party HBAs as Sun HBAs will
19515 * handle the queue full condition.) Note that if there are
19516 * some commands already in the transport, then the queue full
19517 * has occurred because the queue for this nexus is actually
19518 * full. If there are no commands in the transport, then the
19519 * queue full is resulting from some other initiator or lun
19520 * consuming all the resources at the target.
19521 *
19522 * Context: May be called from interrupt context
19523 */
19524
19525 static void
19526 sd_pkt_status_qfull(struct sd_lun *un, struct buf *bp,
19527 struct sd_xbuf *xp, struct scsi_pkt *pktp)
19528 {
19529 ASSERT(un != NULL);
19530 ASSERT(mutex_owned(SD_MUTEX(un)));
19531 ASSERT(bp != NULL);
19532 ASSERT(xp != NULL);
19533 ASSERT(pktp != NULL);
19534
19535 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19536 "sd_pkt_status_qfull: entry\n");
19537
19538 /*
19539 * Just lower the QFULL throttle and retry the command. Note that
19540 * we do not limit the number of retries here.
19541 */
19542 sd_reduce_throttle(un, SD_THROTTLE_QFULL);
19543 sd_retry_command(un, bp, SD_RETRIES_NOCHECK, NULL, NULL, 0,
19544 SD_RESTART_TIMEOUT, NULL);
19545
19546 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19547 "sd_pkt_status_qfull: exit\n");
19548 }
19549
19550
19551 /*
19552 * Function: sd_reset_target
19553 *
19554 * Description: Issue a scsi_reset(9F), with either RESET_LUN,
19555 * RESET_TARGET, or RESET_ALL.
19556 *
19557 * Context: May be called under interrupt context.
19558 */
19559
19560 static void
19561 sd_reset_target(struct sd_lun *un, struct scsi_pkt *pktp)
19562 {
19563 int rval = 0;
19564
19565 ASSERT(un != NULL);
19566 ASSERT(mutex_owned(SD_MUTEX(un)));
19567 ASSERT(pktp != NULL);
19568
19569 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_reset_target: entry\n");
19570
19571 /*
19572 * No need to reset if the transport layer has already done so.
19573 */
19574 if ((pktp->pkt_statistics &
19575 (STAT_BUS_RESET | STAT_DEV_RESET | STAT_ABORTED)) != 0) {
19576 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19577 "sd_reset_target: no reset\n");
19578 return;
19579 }
19580
19581 mutex_exit(SD_MUTEX(un));
19582
19583 if (un->un_f_allow_bus_device_reset == TRUE) {
19584 if (un->un_f_lun_reset_enabled == TRUE) {
19585 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19586 "sd_reset_target: RESET_LUN\n");
19587 rval = scsi_reset(SD_ADDRESS(un), RESET_LUN);
19588 }
19589 if (rval == 0) {
19590 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19591 "sd_reset_target: RESET_TARGET\n");
19592 rval = scsi_reset(SD_ADDRESS(un), RESET_TARGET);
19593 }
19594 }
19595
19596 if (rval == 0) {
19597 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19598 "sd_reset_target: RESET_ALL\n");
19599 (void) scsi_reset(SD_ADDRESS(un), RESET_ALL);
19600 }
19601
19602 mutex_enter(SD_MUTEX(un));
19603
19604 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_reset_target: exit\n");
19605 }
19606
19607 /*
19608 * Function: sd_target_change_task
19609 *
19610 * Description: Handle dynamic target change
19611 *
19612 * Context: Executes in a taskq() thread context
19613 */
19614 static void
19615 sd_target_change_task(void *arg)
19616 {
19617 struct sd_lun *un = arg;
19618 uint64_t capacity;
19619 diskaddr_t label_cap;
19620 uint_t lbasize;
19621 sd_ssc_t *ssc;
19622
19623 ASSERT(un != NULL);
19624 ASSERT(!mutex_owned(SD_MUTEX(un)));
19625
19626 if ((un->un_f_blockcount_is_valid == FALSE) ||
19627 (un->un_f_tgt_blocksize_is_valid == FALSE)) {
19628 return;
19629 }
19630
19631 ssc = sd_ssc_init(un);
19632
19633 if (sd_send_scsi_READ_CAPACITY(ssc, &capacity,
19634 &lbasize, SD_PATH_DIRECT) != 0) {
19635 SD_ERROR(SD_LOG_ERROR, un,
19636 "sd_target_change_task: fail to read capacity\n");
19637 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
19638 goto task_exit;
19639 }
19640
19641 mutex_enter(SD_MUTEX(un));
19642 if (capacity <= un->un_blockcount) {
19643 mutex_exit(SD_MUTEX(un));
19644 goto task_exit;
19645 }
19646
19647 sd_update_block_info(un, lbasize, capacity);
19648 mutex_exit(SD_MUTEX(un));
19649
19650 /*
19651 * If lun is EFI labeled and lun capacity is greater than the
19652 * capacity contained in the label, log a sys event.
19653 */
19654 if (cmlb_efi_label_capacity(un->un_cmlbhandle, &label_cap,
19655 (void*)SD_PATH_DIRECT) == 0) {
19656 mutex_enter(SD_MUTEX(un));
19657 if (un->un_f_blockcount_is_valid &&
19658 un->un_blockcount > label_cap) {
19659 mutex_exit(SD_MUTEX(un));
19660 sd_log_lun_expansion_event(un, KM_SLEEP);
19661 } else {
19662 mutex_exit(SD_MUTEX(un));
19663 }
19664 }
19665
19666 task_exit:
19667 sd_ssc_fini(ssc);
19668 }
19669
19670
19671 /*
19672 * Function: sd_log_dev_status_event
19673 *
19674 * Description: Log EC_dev_status sysevent
19675 *
19676 * Context: Never called from interrupt context
19677 */
19678 static void
19679 sd_log_dev_status_event(struct sd_lun *un, char *esc, int km_flag)
19680 {
19681 int err;
19682 char *path;
19683 nvlist_t *attr_list;
19684
19685 /* Allocate and build sysevent attribute list */
19686 err = nvlist_alloc(&attr_list, NV_UNIQUE_NAME_TYPE, km_flag);
19687 if (err != 0) {
19688 SD_ERROR(SD_LOG_ERROR, un,
19689 "sd_log_dev_status_event: fail to allocate space\n");
19690 return;
19691 }
19692
19693 path = kmem_alloc(MAXPATHLEN, km_flag);
19694 if (path == NULL) {
19695 nvlist_free(attr_list);
19696 SD_ERROR(SD_LOG_ERROR, un,
19697 "sd_log_dev_status_event: fail to allocate space\n");
19698 return;
19699 }
19700 /*
19701 * Add path attribute to identify the lun.
19702 * We are using minor node 'a' as the sysevent attribute.
19703 */
19704 (void) snprintf(path, MAXPATHLEN, "/devices");
19705 (void) ddi_pathname(SD_DEVINFO(un), path + strlen(path));
19706 (void) snprintf(path + strlen(path), MAXPATHLEN - strlen(path),
19707 ":a");
19708
19709 err = nvlist_add_string(attr_list, DEV_PHYS_PATH, path);
19710 if (err != 0) {
19711 nvlist_free(attr_list);
19712 kmem_free(path, MAXPATHLEN);
19713 SD_ERROR(SD_LOG_ERROR, un,
19714 "sd_log_dev_status_event: fail to add attribute\n");
19715 return;
19716 }
19717
19718 /* Log dynamic lun expansion sysevent */
19719 err = ddi_log_sysevent(SD_DEVINFO(un), SUNW_VENDOR, EC_DEV_STATUS,
19720 esc, attr_list, NULL, km_flag);
19721 if (err != DDI_SUCCESS) {
19722 SD_ERROR(SD_LOG_ERROR, un,
19723 "sd_log_dev_status_event: fail to log sysevent\n");
19724 }
19725
19726 nvlist_free(attr_list);
19727 kmem_free(path, MAXPATHLEN);
19728 }
19729
19730
19731 /*
19732 * Function: sd_log_lun_expansion_event
19733 *
19734 * Description: Log lun expansion sys event
19735 *
19736 * Context: Never called from interrupt context
19737 */
19738 static void
19739 sd_log_lun_expansion_event(struct sd_lun *un, int km_flag)
19740 {
19741 sd_log_dev_status_event(un, ESC_DEV_DLE, km_flag);
19742 }
19743
19744
19745 /*
19746 * Function: sd_log_eject_request_event
19747 *
19748 * Description: Log eject request sysevent
19749 *
19750 * Context: Never called from interrupt context
19751 */
19752 static void
19753 sd_log_eject_request_event(struct sd_lun *un, int km_flag)
19754 {
19755 sd_log_dev_status_event(un, ESC_DEV_EJECT_REQUEST, km_flag);
19756 }
19757
19758
19759 /*
19760 * Function: sd_media_change_task
19761 *
19762 * Description: Recovery action for CDROM to become available.
19763 *
19764 * Context: Executes in a taskq() thread context
19765 */
19766
19767 static void
19768 sd_media_change_task(void *arg)
19769 {
19770 struct scsi_pkt *pktp = arg;
19771 struct sd_lun *un;
19772 struct buf *bp;
19773 struct sd_xbuf *xp;
19774 int err = 0;
19775 int retry_count = 0;
19776 int retry_limit = SD_UNIT_ATTENTION_RETRY/10;
19777 struct sd_sense_info si;
19778
19779 ASSERT(pktp != NULL);
19780 bp = (struct buf *)pktp->pkt_private;
19781 ASSERT(bp != NULL);
19782 xp = SD_GET_XBUF(bp);
19783 ASSERT(xp != NULL);
19784 un = SD_GET_UN(bp);
19785 ASSERT(un != NULL);
19786 ASSERT(!mutex_owned(SD_MUTEX(un)));
19787 ASSERT(un->un_f_monitor_media_state);
19788
19789 si.ssi_severity = SCSI_ERR_INFO;
19790 si.ssi_pfa_flag = FALSE;
19791
19792 /*
19793 * When a reset is issued on a CDROM, it takes a long time to
19794 * recover. First few attempts to read capacity and other things
19795 * related to handling unit attention fail (with a ASC 0x4 and
19796 * ASCQ 0x1). In that case we want to do enough retries and we want
19797 * to limit the retries in other cases of genuine failures like
19798 * no media in drive.
19799 */
19800 while (retry_count++ < retry_limit) {
19801 if ((err = sd_handle_mchange(un)) == 0) {
19802 break;
19803 }
19804 if (err == EAGAIN) {
19805 retry_limit = SD_UNIT_ATTENTION_RETRY;
19806 }
19807 /* Sleep for 0.5 sec. & try again */
19808 delay(drv_usectohz(500000));
19809 }
19810
19811 /*
19812 * Dispatch (retry or fail) the original command here,
19813 * along with appropriate console messages....
19814 *
19815 * Must grab the mutex before calling sd_retry_command,
19816 * sd_print_sense_msg and sd_return_failed_command.
19817 */
19818 mutex_enter(SD_MUTEX(un));
19819 if (err != SD_CMD_SUCCESS) {
19820 SD_UPDATE_ERRSTATS(un, sd_harderrs);
19821 SD_UPDATE_ERRSTATS(un, sd_rq_nodev_err);
19822 si.ssi_severity = SCSI_ERR_FATAL;
19823 sd_print_sense_msg(un, bp, &si, SD_NO_RETRY_ISSUED);
19824 sd_return_failed_command(un, bp, EIO);
19825 } else {
19826 sd_retry_command(un, bp, SD_RETRIES_UA, sd_print_sense_msg,
19827 &si, EIO, (clock_t)0, NULL);
19828 }
19829 mutex_exit(SD_MUTEX(un));
19830 }
19831
19832
19833
19834 /*
19835 * Function: sd_handle_mchange
19836 *
19837 * Description: Perform geometry validation & other recovery when CDROM
19838 * has been removed from drive.
19839 *
19840 * Return Code: 0 for success
19841 * errno-type return code of either sd_send_scsi_DOORLOCK() or
19842 * sd_send_scsi_READ_CAPACITY()
19843 *
19844 * Context: Executes in a taskq() thread context
19845 */
19846
19847 static int
19848 sd_handle_mchange(struct sd_lun *un)
19849 {
19850 uint64_t capacity;
19851 uint32_t lbasize;
19852 int rval;
19853 sd_ssc_t *ssc;
19854
19855 ASSERT(!mutex_owned(SD_MUTEX(un)));
19856 ASSERT(un->un_f_monitor_media_state);
19857
19858 ssc = sd_ssc_init(un);
19859 rval = sd_send_scsi_READ_CAPACITY(ssc, &capacity, &lbasize,
19860 SD_PATH_DIRECT_PRIORITY);
19861
19862 if (rval != 0)
19863 goto failed;
19864
19865 mutex_enter(SD_MUTEX(un));
19866 sd_update_block_info(un, lbasize, capacity);
19867
19868 if (un->un_errstats != NULL) {
19869 struct sd_errstats *stp =
19870 (struct sd_errstats *)un->un_errstats->ks_data;
19871 stp->sd_capacity.value.ui64 = (uint64_t)
19872 ((uint64_t)un->un_blockcount *
19873 (uint64_t)un->un_tgt_blocksize);
19874 }
19875
19876 /*
19877 * Check if the media in the device is writable or not
19878 */
19879 if (ISCD(un)) {
19880 sd_check_for_writable_cd(ssc, SD_PATH_DIRECT_PRIORITY);
19881 }
19882
19883 /*
19884 * Note: Maybe let the strategy/partitioning chain worry about getting
19885 * valid geometry.
19886 */
19887 mutex_exit(SD_MUTEX(un));
19888 cmlb_invalidate(un->un_cmlbhandle, (void *)SD_PATH_DIRECT_PRIORITY);
19889
19890
19891 if (cmlb_validate(un->un_cmlbhandle, 0,
19892 (void *)SD_PATH_DIRECT_PRIORITY) != 0) {
19893 sd_ssc_fini(ssc);
19894 return (EIO);
19895 } else {
19896 if (un->un_f_pkstats_enabled) {
19897 sd_set_pstats(un);
19898 SD_TRACE(SD_LOG_IO_PARTITION, un,
19899 "sd_handle_mchange: un:0x%p pstats created and "
19900 "set\n", un);
19901 }
19902 }
19903
19904 /*
19905 * Try to lock the door
19906 */
19907 rval = sd_send_scsi_DOORLOCK(ssc, SD_REMOVAL_PREVENT,
19908 SD_PATH_DIRECT_PRIORITY);
19909 failed:
19910 if (rval != 0)
19911 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
19912 sd_ssc_fini(ssc);
19913 return (rval);
19914 }
19915
19916
19917 /*
19918 * Function: sd_send_scsi_DOORLOCK
19919 *
19920 * Description: Issue the scsi DOOR LOCK command
19921 *
19922 * Arguments: ssc - ssc contains pointer to driver soft state (unit)
19923 * structure for this target.
19924 * flag - SD_REMOVAL_ALLOW
19925 * SD_REMOVAL_PREVENT
19926 * path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and
19927 * the normal command waitq, or SD_PATH_DIRECT_PRIORITY
19928 * to use the USCSI "direct" chain and bypass the normal
19929 * command waitq. SD_PATH_DIRECT_PRIORITY is used when this
19930 * command is issued as part of an error recovery action.
19931 *
19932 * Return Code: 0 - Success
19933 * errno return code from sd_ssc_send()
19934 *
19935 * Context: Can sleep.
19936 */
19937
19938 static int
19939 sd_send_scsi_DOORLOCK(sd_ssc_t *ssc, int flag, int path_flag)
19940 {
19941 struct scsi_extended_sense sense_buf;
19942 union scsi_cdb cdb;
19943 struct uscsi_cmd ucmd_buf;
19944 int status;
19945 struct sd_lun *un;
19946
19947 ASSERT(ssc != NULL);
19948 un = ssc->ssc_un;
19949 ASSERT(un != NULL);
19950 ASSERT(!mutex_owned(SD_MUTEX(un)));
19951
19952 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_DOORLOCK: entry: un:0x%p\n", un);
19953
19954 /* already determined doorlock is not supported, fake success */
19955 if (un->un_f_doorlock_supported == FALSE) {
19956 return (0);
19957 }
19958
19959 /*
19960 * If we are ejecting and see an SD_REMOVAL_PREVENT
19961 * ignore the command so we can complete the eject
19962 * operation.
19963 */
19964 if (flag == SD_REMOVAL_PREVENT) {
19965 mutex_enter(SD_MUTEX(un));
19966 if (un->un_f_ejecting == TRUE) {
19967 mutex_exit(SD_MUTEX(un));
19968 return (EAGAIN);
19969 }
19970 mutex_exit(SD_MUTEX(un));
19971 }
19972
19973 bzero(&cdb, sizeof (cdb));
19974 bzero(&ucmd_buf, sizeof (ucmd_buf));
19975
19976 cdb.scc_cmd = SCMD_DOORLOCK;
19977 cdb.cdb_opaque[4] = (uchar_t)flag;
19978
19979 ucmd_buf.uscsi_cdb = (char *)&cdb;
19980 ucmd_buf.uscsi_cdblen = CDB_GROUP0;
19981 ucmd_buf.uscsi_bufaddr = NULL;
19982 ucmd_buf.uscsi_buflen = 0;
19983 ucmd_buf.uscsi_rqbuf = (caddr_t)&sense_buf;
19984 ucmd_buf.uscsi_rqlen = sizeof (sense_buf);
19985 ucmd_buf.uscsi_flags = USCSI_RQENABLE | USCSI_SILENT;
19986 ucmd_buf.uscsi_timeout = 15;
19987
19988 SD_TRACE(SD_LOG_IO, un,
19989 "sd_send_scsi_DOORLOCK: returning sd_ssc_send\n");
19990
19991 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
19992 UIO_SYSSPACE, path_flag);
19993
19994 if (status == 0)
19995 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
19996
19997 if ((status == EIO) && (ucmd_buf.uscsi_status == STATUS_CHECK) &&
19998 (ucmd_buf.uscsi_rqstatus == STATUS_GOOD) &&
19999 (scsi_sense_key((uint8_t *)&sense_buf) == KEY_ILLEGAL_REQUEST)) {
20000 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
20001
20002 /* fake success and skip subsequent doorlock commands */
20003 un->un_f_doorlock_supported = FALSE;
20004 return (0);
20005 }
20006
20007 return (status);
20008 }
20009
20010 /*
20011 * Function: sd_send_scsi_READ_CAPACITY
20012 *
20013 * Description: This routine uses the scsi READ CAPACITY command to determine
20014 * the device capacity in number of blocks and the device native
20015 * block size. If this function returns a failure, then the
20016 * values in *capp and *lbap are undefined. If the capacity
20017 * returned is 0xffffffff then the lun is too large for a
20018 * normal READ CAPACITY command and the results of a
20019 * READ CAPACITY 16 will be used instead.
20020 *
20021 * Arguments: ssc - ssc contains ptr to soft state struct for the target
20022 * capp - ptr to unsigned 64-bit variable to receive the
20023 * capacity value from the command.
20024 * lbap - ptr to unsigned 32-bit varaible to receive the
20025 * block size value from the command
20026 * path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and
20027 * the normal command waitq, or SD_PATH_DIRECT_PRIORITY
20028 * to use the USCSI "direct" chain and bypass the normal
20029 * command waitq. SD_PATH_DIRECT_PRIORITY is used when this
20030 * command is issued as part of an error recovery action.
20031 *
20032 * Return Code: 0 - Success
20033 * EIO - IO error
20034 * EACCES - Reservation conflict detected
20035 * EAGAIN - Device is becoming ready
20036 * errno return code from sd_ssc_send()
20037 *
20038 * Context: Can sleep. Blocks until command completes.
20039 */
20040
20041 #define SD_CAPACITY_SIZE sizeof (struct scsi_capacity)
20042
20043 static int
20044 sd_send_scsi_READ_CAPACITY(sd_ssc_t *ssc, uint64_t *capp, uint32_t *lbap,
20045 int path_flag)
20046 {
20047 struct scsi_extended_sense sense_buf;
20048 struct uscsi_cmd ucmd_buf;
20049 union scsi_cdb cdb;
20050 uint32_t *capacity_buf;
20051 uint64_t capacity;
20052 uint32_t lbasize;
20053 uint32_t pbsize;
20054 int status;
20055 struct sd_lun *un;
20056
20057 ASSERT(ssc != NULL);
20058
20059 un = ssc->ssc_un;
20060 ASSERT(un != NULL);
20061 ASSERT(!mutex_owned(SD_MUTEX(un)));
20062 ASSERT(capp != NULL);
20063 ASSERT(lbap != NULL);
20064
20065 SD_TRACE(SD_LOG_IO, un,
20066 "sd_send_scsi_READ_CAPACITY: entry: un:0x%p\n", un);
20067
20068 /*
20069 * First send a READ_CAPACITY command to the target.
20070 * (This command is mandatory under SCSI-2.)
20071 *
20072 * Set up the CDB for the READ_CAPACITY command. The Partial
20073 * Medium Indicator bit is cleared. The address field must be
20074 * zero if the PMI bit is zero.
20075 */
20076 bzero(&cdb, sizeof (cdb));
20077 bzero(&ucmd_buf, sizeof (ucmd_buf));
20078
20079 capacity_buf = kmem_zalloc(SD_CAPACITY_SIZE, KM_SLEEP);
20080
20081 cdb.scc_cmd = SCMD_READ_CAPACITY;
20082
20083 ucmd_buf.uscsi_cdb = (char *)&cdb;
20084 ucmd_buf.uscsi_cdblen = CDB_GROUP1;
20085 ucmd_buf.uscsi_bufaddr = (caddr_t)capacity_buf;
20086 ucmd_buf.uscsi_buflen = SD_CAPACITY_SIZE;
20087 ucmd_buf.uscsi_rqbuf = (caddr_t)&sense_buf;
20088 ucmd_buf.uscsi_rqlen = sizeof (sense_buf);
20089 ucmd_buf.uscsi_flags = USCSI_RQENABLE | USCSI_READ | USCSI_SILENT;
20090 ucmd_buf.uscsi_timeout = 60;
20091
20092 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
20093 UIO_SYSSPACE, path_flag);
20094
20095 switch (status) {
20096 case 0:
20097 /* Return failure if we did not get valid capacity data. */
20098 if (ucmd_buf.uscsi_resid != 0) {
20099 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, -1,
20100 "sd_send_scsi_READ_CAPACITY received invalid "
20101 "capacity data");
20102 kmem_free(capacity_buf, SD_CAPACITY_SIZE);
20103 return (EIO);
20104 }
20105 /*
20106 * Read capacity and block size from the READ CAPACITY 10 data.
20107 * This data may be adjusted later due to device specific
20108 * issues.
20109 *
20110 * According to the SCSI spec, the READ CAPACITY 10
20111 * command returns the following:
20112 *
20113 * bytes 0-3: Maximum logical block address available.
20114 * (MSB in byte:0 & LSB in byte:3)
20115 *
20116 * bytes 4-7: Block length in bytes
20117 * (MSB in byte:4 & LSB in byte:7)
20118 *
20119 */
20120 capacity = BE_32(capacity_buf[0]);
20121 lbasize = BE_32(capacity_buf[1]);
20122
20123 /*
20124 * Done with capacity_buf
20125 */
20126 kmem_free(capacity_buf, SD_CAPACITY_SIZE);
20127
20128 /*
20129 * if the reported capacity is set to all 0xf's, then
20130 * this disk is too large and requires SBC-2 commands.
20131 * Reissue the request using READ CAPACITY 16.
20132 */
20133 if (capacity == 0xffffffff) {
20134 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
20135 status = sd_send_scsi_READ_CAPACITY_16(ssc, &capacity,
20136 &lbasize, &pbsize, path_flag);
20137 if (status != 0) {
20138 return (status);
20139 } else {
20140 goto rc16_done;
20141 }
20142 }
20143 break; /* Success! */
20144 case EIO:
20145 switch (ucmd_buf.uscsi_status) {
20146 case STATUS_RESERVATION_CONFLICT:
20147 status = EACCES;
20148 break;
20149 case STATUS_CHECK:
20150 /*
20151 * Check condition; look for ASC/ASCQ of 0x04/0x01
20152 * (LOGICAL UNIT IS IN PROCESS OF BECOMING READY)
20153 */
20154 if ((ucmd_buf.uscsi_rqstatus == STATUS_GOOD) &&
20155 (scsi_sense_asc((uint8_t *)&sense_buf) == 0x04) &&
20156 (scsi_sense_ascq((uint8_t *)&sense_buf) == 0x01)) {
20157 kmem_free(capacity_buf, SD_CAPACITY_SIZE);
20158 return (EAGAIN);
20159 }
20160 break;
20161 default:
20162 break;
20163 }
20164 /* FALLTHRU */
20165 default:
20166 kmem_free(capacity_buf, SD_CAPACITY_SIZE);
20167 return (status);
20168 }
20169
20170 /*
20171 * Some ATAPI CD-ROM drives report inaccurate LBA size values
20172 * (2352 and 0 are common) so for these devices always force the value
20173 * to 2048 as required by the ATAPI specs.
20174 */
20175 if ((un->un_f_cfg_is_atapi == TRUE) && (ISCD(un))) {
20176 lbasize = 2048;
20177 }
20178
20179 /*
20180 * Get the maximum LBA value from the READ CAPACITY data.
20181 * Here we assume that the Partial Medium Indicator (PMI) bit
20182 * was cleared when issuing the command. This means that the LBA
20183 * returned from the device is the LBA of the last logical block
20184 * on the logical unit. The actual logical block count will be
20185 * this value plus one.
20186 */
20187 capacity += 1;
20188
20189 /*
20190 * Currently, for removable media, the capacity is saved in terms
20191 * of un->un_sys_blocksize, so scale the capacity value to reflect this.
20192 */
20193 if (un->un_f_has_removable_media)
20194 capacity *= (lbasize / un->un_sys_blocksize);
20195
20196 rc16_done:
20197
20198 /*
20199 * Copy the values from the READ CAPACITY command into the space
20200 * provided by the caller.
20201 */
20202 *capp = capacity;
20203 *lbap = lbasize;
20204
20205 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_READ_CAPACITY: "
20206 "capacity:0x%llx lbasize:0x%x\n", capacity, lbasize);
20207
20208 /*
20209 * Both the lbasize and capacity from the device must be nonzero,
20210 * otherwise we assume that the values are not valid and return
20211 * failure to the caller. (4203735)
20212 */
20213 if ((capacity == 0) || (lbasize == 0)) {
20214 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, -1,
20215 "sd_send_scsi_READ_CAPACITY received invalid value "
20216 "capacity %llu lbasize %d", capacity, lbasize);
20217 return (EIO);
20218 }
20219 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
20220 return (0);
20221 }
20222
20223 /*
20224 * Function: sd_send_scsi_READ_CAPACITY_16
20225 *
20226 * Description: This routine uses the scsi READ CAPACITY 16 command to
20227 * determine the device capacity in number of blocks and the
20228 * device native block size. If this function returns a failure,
20229 * then the values in *capp and *lbap are undefined.
20230 * This routine should be called by sd_send_scsi_READ_CAPACITY
20231 * which will apply any device specific adjustments to capacity
20232 * and lbasize. One exception is it is also called by
20233 * sd_get_media_info_ext. In that function, there is no need to
20234 * adjust the capacity and lbasize.
20235 *
20236 * Arguments: ssc - ssc contains ptr to soft state struct for the target
20237 * capp - ptr to unsigned 64-bit variable to receive the
20238 * capacity value from the command.
20239 * lbap - ptr to unsigned 32-bit varaible to receive the
20240 * block size value from the command
20241 * psp - ptr to unsigned 32-bit variable to receive the
20242 * physical block size value from the command
20243 * path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and
20244 * the normal command waitq, or SD_PATH_DIRECT_PRIORITY
20245 * to use the USCSI "direct" chain and bypass the normal
20246 * command waitq. SD_PATH_DIRECT_PRIORITY is used when
20247 * this command is issued as part of an error recovery
20248 * action.
20249 *
20250 * Return Code: 0 - Success
20251 * EIO - IO error
20252 * EACCES - Reservation conflict detected
20253 * EAGAIN - Device is becoming ready
20254 * errno return code from sd_ssc_send()
20255 *
20256 * Context: Can sleep. Blocks until command completes.
20257 */
20258
20259 #define SD_CAPACITY_16_SIZE sizeof (struct scsi_capacity_16)
20260
20261 static int
20262 sd_send_scsi_READ_CAPACITY_16(sd_ssc_t *ssc, uint64_t *capp,
20263 uint32_t *lbap, uint32_t *psp, int path_flag)
20264 {
20265 struct scsi_extended_sense sense_buf;
20266 struct uscsi_cmd ucmd_buf;
20267 union scsi_cdb cdb;
20268 uint64_t *capacity16_buf;
20269 uint64_t capacity;
20270 uint32_t lbasize;
20271 uint32_t pbsize;
20272 uint32_t lbpb_exp;
20273 int status;
20274 struct sd_lun *un;
20275
20276 ASSERT(ssc != NULL);
20277
20278 un = ssc->ssc_un;
20279 ASSERT(un != NULL);
20280 ASSERT(!mutex_owned(SD_MUTEX(un)));
20281 ASSERT(capp != NULL);
20282 ASSERT(lbap != NULL);
20283
20284 SD_TRACE(SD_LOG_IO, un,
20285 "sd_send_scsi_READ_CAPACITY: entry: un:0x%p\n", un);
20286
20287 /*
20288 * First send a READ_CAPACITY_16 command to the target.
20289 *
20290 * Set up the CDB for the READ_CAPACITY_16 command. The Partial
20291 * Medium Indicator bit is cleared. The address field must be
20292 * zero if the PMI bit is zero.
20293 */
20294 bzero(&cdb, sizeof (cdb));
20295 bzero(&ucmd_buf, sizeof (ucmd_buf));
20296
20297 capacity16_buf = kmem_zalloc(SD_CAPACITY_16_SIZE, KM_SLEEP);
20298
20299 ucmd_buf.uscsi_cdb = (char *)&cdb;
20300 ucmd_buf.uscsi_cdblen = CDB_GROUP4;
20301 ucmd_buf.uscsi_bufaddr = (caddr_t)capacity16_buf;
20302 ucmd_buf.uscsi_buflen = SD_CAPACITY_16_SIZE;
20303 ucmd_buf.uscsi_rqbuf = (caddr_t)&sense_buf;
20304 ucmd_buf.uscsi_rqlen = sizeof (sense_buf);
20305 ucmd_buf.uscsi_flags = USCSI_RQENABLE | USCSI_READ | USCSI_SILENT;
20306 ucmd_buf.uscsi_timeout = 60;
20307
20308 /*
20309 * Read Capacity (16) is a Service Action In command. One
20310 * command byte (0x9E) is overloaded for multiple operations,
20311 * with the second CDB byte specifying the desired operation
20312 */
20313 cdb.scc_cmd = SCMD_SVC_ACTION_IN_G4;
20314 cdb.cdb_opaque[1] = SSVC_ACTION_READ_CAPACITY_G4;
20315
20316 /*
20317 * Fill in allocation length field
20318 */
20319 FORMG4COUNT(&cdb, ucmd_buf.uscsi_buflen);
20320
20321 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
20322 UIO_SYSSPACE, path_flag);
20323
20324 switch (status) {
20325 case 0:
20326 /* Return failure if we did not get valid capacity data. */
20327 if (ucmd_buf.uscsi_resid > 20) {
20328 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, -1,
20329 "sd_send_scsi_READ_CAPACITY_16 received invalid "
20330 "capacity data");
20331 kmem_free(capacity16_buf, SD_CAPACITY_16_SIZE);
20332 return (EIO);
20333 }
20334
20335 /*
20336 * Read capacity and block size from the READ CAPACITY 16 data.
20337 * This data may be adjusted later due to device specific
20338 * issues.
20339 *
20340 * According to the SCSI spec, the READ CAPACITY 16
20341 * command returns the following:
20342 *
20343 * bytes 0-7: Maximum logical block address available.
20344 * (MSB in byte:0 & LSB in byte:7)
20345 *
20346 * bytes 8-11: Block length in bytes
20347 * (MSB in byte:8 & LSB in byte:11)
20348 *
20349 * byte 13: LOGICAL BLOCKS PER PHYSICAL BLOCK EXPONENT
20350 */
20351 capacity = BE_64(capacity16_buf[0]);
20352 lbasize = BE_32(*(uint32_t *)&capacity16_buf[1]);
20353 lbpb_exp = (BE_64(capacity16_buf[1]) >> 16) & 0x0f;
20354
20355 pbsize = lbasize << lbpb_exp;
20356
20357 /*
20358 * Done with capacity16_buf
20359 */
20360 kmem_free(capacity16_buf, SD_CAPACITY_16_SIZE);
20361
20362 /*
20363 * if the reported capacity is set to all 0xf's, then
20364 * this disk is too large. This could only happen with
20365 * a device that supports LBAs larger than 64 bits which
20366 * are not defined by any current T10 standards.
20367 */
20368 if (capacity == 0xffffffffffffffff) {
20369 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, -1,
20370 "disk is too large");
20371 return (EIO);
20372 }
20373 break; /* Success! */
20374 case EIO:
20375 switch (ucmd_buf.uscsi_status) {
20376 case STATUS_RESERVATION_CONFLICT:
20377 status = EACCES;
20378 break;
20379 case STATUS_CHECK:
20380 /*
20381 * Check condition; look for ASC/ASCQ of 0x04/0x01
20382 * (LOGICAL UNIT IS IN PROCESS OF BECOMING READY)
20383 */
20384 if ((ucmd_buf.uscsi_rqstatus == STATUS_GOOD) &&
20385 (scsi_sense_asc((uint8_t *)&sense_buf) == 0x04) &&
20386 (scsi_sense_ascq((uint8_t *)&sense_buf) == 0x01)) {
20387 kmem_free(capacity16_buf, SD_CAPACITY_16_SIZE);
20388 return (EAGAIN);
20389 }
20390 break;
20391 default:
20392 break;
20393 }
20394 /* FALLTHRU */
20395 default:
20396 kmem_free(capacity16_buf, SD_CAPACITY_16_SIZE);
20397 return (status);
20398 }
20399
20400 /*
20401 * Some ATAPI CD-ROM drives report inaccurate LBA size values
20402 * (2352 and 0 are common) so for these devices always force the value
20403 * to 2048 as required by the ATAPI specs.
20404 */
20405 if ((un->un_f_cfg_is_atapi == TRUE) && (ISCD(un))) {
20406 lbasize = 2048;
20407 }
20408
20409 /*
20410 * Get the maximum LBA value from the READ CAPACITY 16 data.
20411 * Here we assume that the Partial Medium Indicator (PMI) bit
20412 * was cleared when issuing the command. This means that the LBA
20413 * returned from the device is the LBA of the last logical block
20414 * on the logical unit. The actual logical block count will be
20415 * this value plus one.
20416 */
20417 capacity += 1;
20418
20419 /*
20420 * Currently, for removable media, the capacity is saved in terms
20421 * of un->un_sys_blocksize, so scale the capacity value to reflect this.
20422 */
20423 if (un->un_f_has_removable_media)
20424 capacity *= (lbasize / un->un_sys_blocksize);
20425
20426 *capp = capacity;
20427 *lbap = lbasize;
20428 *psp = pbsize;
20429
20430 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_READ_CAPACITY_16: "
20431 "capacity:0x%llx lbasize:0x%x, pbsize: 0x%x\n",
20432 capacity, lbasize, pbsize);
20433
20434 if ((capacity == 0) || (lbasize == 0) || (pbsize == 0)) {
20435 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, -1,
20436 "sd_send_scsi_READ_CAPACITY_16 received invalid value "
20437 "capacity %llu lbasize %d pbsize %d", capacity, lbasize);
20438 return (EIO);
20439 }
20440
20441 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
20442 return (0);
20443 }
20444
20445
20446 /*
20447 * Function: sd_send_scsi_START_STOP_UNIT
20448 *
20449 * Description: Issue a scsi START STOP UNIT command to the target.
20450 *
20451 * Arguments: ssc - ssc contatins pointer to driver soft state (unit)
20452 * structure for this target.
20453 * pc_flag - SD_POWER_CONDITION
20454 * SD_START_STOP
20455 * flag - SD_TARGET_START
20456 * SD_TARGET_STOP
20457 * SD_TARGET_EJECT
20458 * SD_TARGET_CLOSE
20459 * path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and
20460 * the normal command waitq, or SD_PATH_DIRECT_PRIORITY
20461 * to use the USCSI "direct" chain and bypass the normal
20462 * command waitq. SD_PATH_DIRECT_PRIORITY is used when this
20463 * command is issued as part of an error recovery action.
20464 *
20465 * Return Code: 0 - Success
20466 * EIO - IO error
20467 * EACCES - Reservation conflict detected
20468 * ENXIO - Not Ready, medium not present
20469 * errno return code from sd_ssc_send()
20470 *
20471 * Context: Can sleep.
20472 */
20473
20474 static int
20475 sd_send_scsi_START_STOP_UNIT(sd_ssc_t *ssc, int pc_flag, int flag,
20476 int path_flag)
20477 {
20478 struct scsi_extended_sense sense_buf;
20479 union scsi_cdb cdb;
20480 struct uscsi_cmd ucmd_buf;
20481 int status;
20482 struct sd_lun *un;
20483
20484 ASSERT(ssc != NULL);
20485 un = ssc->ssc_un;
20486 ASSERT(un != NULL);
20487 ASSERT(!mutex_owned(SD_MUTEX(un)));
20488
20489 SD_TRACE(SD_LOG_IO, un,
20490 "sd_send_scsi_START_STOP_UNIT: entry: un:0x%p\n", un);
20491
20492 if (un->un_f_check_start_stop &&
20493 (pc_flag == SD_START_STOP) &&
20494 ((flag == SD_TARGET_START) || (flag == SD_TARGET_STOP)) &&
20495 (un->un_f_start_stop_supported != TRUE)) {
20496 return (0);
20497 }
20498
20499 /*
20500 * If we are performing an eject operation and
20501 * we receive any command other than SD_TARGET_EJECT
20502 * we should immediately return.
20503 */
20504 if (flag != SD_TARGET_EJECT) {
20505 mutex_enter(SD_MUTEX(un));
20506 if (un->un_f_ejecting == TRUE) {
20507 mutex_exit(SD_MUTEX(un));
20508 return (EAGAIN);
20509 }
20510 mutex_exit(SD_MUTEX(un));
20511 }
20512
20513 bzero(&cdb, sizeof (cdb));
20514 bzero(&ucmd_buf, sizeof (ucmd_buf));
20515 bzero(&sense_buf, sizeof (struct scsi_extended_sense));
20516
20517 cdb.scc_cmd = SCMD_START_STOP;
20518 cdb.cdb_opaque[4] = (pc_flag == SD_POWER_CONDITION) ?
20519 (uchar_t)(flag << 4) : (uchar_t)flag;
20520
20521 ucmd_buf.uscsi_cdb = (char *)&cdb;
20522 ucmd_buf.uscsi_cdblen = CDB_GROUP0;
20523 ucmd_buf.uscsi_bufaddr = NULL;
20524 ucmd_buf.uscsi_buflen = 0;
20525 ucmd_buf.uscsi_rqbuf = (caddr_t)&sense_buf;
20526 ucmd_buf.uscsi_rqlen = sizeof (struct scsi_extended_sense);
20527 ucmd_buf.uscsi_flags = USCSI_RQENABLE | USCSI_SILENT;
20528 ucmd_buf.uscsi_timeout = 200;
20529
20530 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
20531 UIO_SYSSPACE, path_flag);
20532
20533 switch (status) {
20534 case 0:
20535 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
20536 break; /* Success! */
20537 case EIO:
20538 switch (ucmd_buf.uscsi_status) {
20539 case STATUS_RESERVATION_CONFLICT:
20540 status = EACCES;
20541 break;
20542 case STATUS_CHECK:
20543 if (ucmd_buf.uscsi_rqstatus == STATUS_GOOD) {
20544 switch (scsi_sense_key(
20545 (uint8_t *)&sense_buf)) {
20546 case KEY_ILLEGAL_REQUEST:
20547 status = ENOTSUP;
20548 break;
20549 case KEY_NOT_READY:
20550 if (scsi_sense_asc(
20551 (uint8_t *)&sense_buf)
20552 == 0x3A) {
20553 status = ENXIO;
20554 }
20555 break;
20556 default:
20557 break;
20558 }
20559 }
20560 break;
20561 default:
20562 break;
20563 }
20564 break;
20565 default:
20566 break;
20567 }
20568
20569 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_START_STOP_UNIT: exit\n");
20570
20571 return (status);
20572 }
20573
20574
20575 /*
20576 * Function: sd_start_stop_unit_callback
20577 *
20578 * Description: timeout(9F) callback to begin recovery process for a
20579 * device that has spun down.
20580 *
20581 * Arguments: arg - pointer to associated softstate struct.
20582 *
20583 * Context: Executes in a timeout(9F) thread context
20584 */
20585
20586 static void
20587 sd_start_stop_unit_callback(void *arg)
20588 {
20589 struct sd_lun *un = arg;
20590 ASSERT(un != NULL);
20591 ASSERT(!mutex_owned(SD_MUTEX(un)));
20592
20593 SD_TRACE(SD_LOG_IO, un, "sd_start_stop_unit_callback: entry\n");
20594
20595 (void) taskq_dispatch(sd_tq, sd_start_stop_unit_task, un, KM_NOSLEEP);
20596 }
20597
20598
20599 /*
20600 * Function: sd_start_stop_unit_task
20601 *
20602 * Description: Recovery procedure when a drive is spun down.
20603 *
20604 * Arguments: arg - pointer to associated softstate struct.
20605 *
20606 * Context: Executes in a taskq() thread context
20607 */
20608
20609 static void
20610 sd_start_stop_unit_task(void *arg)
20611 {
20612 struct sd_lun *un = arg;
20613 sd_ssc_t *ssc;
20614 int power_level;
20615 int rval;
20616
20617 ASSERT(un != NULL);
20618 ASSERT(!mutex_owned(SD_MUTEX(un)));
20619
20620 SD_TRACE(SD_LOG_IO, un, "sd_start_stop_unit_task: entry\n");
20621
20622 /*
20623 * Some unformatted drives report not ready error, no need to
20624 * restart if format has been initiated.
20625 */
20626 mutex_enter(SD_MUTEX(un));
20627 if (un->un_f_format_in_progress == TRUE) {
20628 mutex_exit(SD_MUTEX(un));
20629 return;
20630 }
20631 mutex_exit(SD_MUTEX(un));
20632
20633 ssc = sd_ssc_init(un);
20634 /*
20635 * When a START STOP command is issued from here, it is part of a
20636 * failure recovery operation and must be issued before any other
20637 * commands, including any pending retries. Thus it must be sent
20638 * using SD_PATH_DIRECT_PRIORITY. It doesn't matter if the spin up
20639 * succeeds or not, we will start I/O after the attempt.
20640 * If power condition is supported and the current power level
20641 * is capable of performing I/O, we should set the power condition
20642 * to that level. Otherwise, set the power condition to ACTIVE.
20643 */
20644 if (un->un_f_power_condition_supported) {
20645 mutex_enter(SD_MUTEX(un));
20646 ASSERT(SD_PM_IS_LEVEL_VALID(un, un->un_power_level));
20647 power_level = sd_pwr_pc.ran_perf[un->un_power_level]
20648 > 0 ? un->un_power_level : SD_SPINDLE_ACTIVE;
20649 mutex_exit(SD_MUTEX(un));
20650 rval = sd_send_scsi_START_STOP_UNIT(ssc, SD_POWER_CONDITION,
20651 sd_pl2pc[power_level], SD_PATH_DIRECT_PRIORITY);
20652 } else {
20653 rval = sd_send_scsi_START_STOP_UNIT(ssc, SD_START_STOP,
20654 SD_TARGET_START, SD_PATH_DIRECT_PRIORITY);
20655 }
20656
20657 if (rval != 0)
20658 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
20659 sd_ssc_fini(ssc);
20660 /*
20661 * The above call blocks until the START_STOP_UNIT command completes.
20662 * Now that it has completed, we must re-try the original IO that
20663 * received the NOT READY condition in the first place. There are
20664 * three possible conditions here:
20665 *
20666 * (1) The original IO is on un_retry_bp.
20667 * (2) The original IO is on the regular wait queue, and un_retry_bp
20668 * is NULL.
20669 * (3) The original IO is on the regular wait queue, and un_retry_bp
20670 * points to some other, unrelated bp.
20671 *
20672 * For each case, we must call sd_start_cmds() with un_retry_bp
20673 * as the argument. If un_retry_bp is NULL, this will initiate
20674 * processing of the regular wait queue. If un_retry_bp is not NULL,
20675 * then this will process the bp on un_retry_bp. That may or may not
20676 * be the original IO, but that does not matter: the important thing
20677 * is to keep the IO processing going at this point.
20678 *
20679 * Note: This is a very specific error recovery sequence associated
20680 * with a drive that is not spun up. We attempt a START_STOP_UNIT and
20681 * serialize the I/O with completion of the spin-up.
20682 */
20683 mutex_enter(SD_MUTEX(un));
20684 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
20685 "sd_start_stop_unit_task: un:0x%p starting bp:0x%p\n",
20686 un, un->un_retry_bp);
20687 un->un_startstop_timeid = NULL; /* Timeout is no longer pending */
20688 sd_start_cmds(un, un->un_retry_bp);
20689 mutex_exit(SD_MUTEX(un));
20690
20691 SD_TRACE(SD_LOG_IO, un, "sd_start_stop_unit_task: exit\n");
20692 }
20693
20694
20695 /*
20696 * Function: sd_send_scsi_INQUIRY
20697 *
20698 * Description: Issue the scsi INQUIRY command.
20699 *
20700 * Arguments: ssc - ssc contains pointer to driver soft state (unit)
20701 * structure for this target.
20702 * bufaddr
20703 * buflen
20704 * evpd
20705 * page_code
20706 * page_length
20707 *
20708 * Return Code: 0 - Success
20709 * errno return code from sd_ssc_send()
20710 *
20711 * Context: Can sleep. Does not return until command is completed.
20712 */
20713
20714 static int
20715 sd_send_scsi_INQUIRY(sd_ssc_t *ssc, uchar_t *bufaddr, size_t buflen,
20716 uchar_t evpd, uchar_t page_code, size_t *residp)
20717 {
20718 union scsi_cdb cdb;
20719 struct uscsi_cmd ucmd_buf;
20720 int status;
20721 struct sd_lun *un;
20722
20723 ASSERT(ssc != NULL);
20724 un = ssc->ssc_un;
20725 ASSERT(un != NULL);
20726 ASSERT(!mutex_owned(SD_MUTEX(un)));
20727 ASSERT(bufaddr != NULL);
20728
20729 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_INQUIRY: entry: un:0x%p\n", un);
20730
20731 bzero(&cdb, sizeof (cdb));
20732 bzero(&ucmd_buf, sizeof (ucmd_buf));
20733 bzero(bufaddr, buflen);
20734
20735 cdb.scc_cmd = SCMD_INQUIRY;
20736 cdb.cdb_opaque[1] = evpd;
20737 cdb.cdb_opaque[2] = page_code;
20738 FORMG0COUNT(&cdb, buflen);
20739
20740 ucmd_buf.uscsi_cdb = (char *)&cdb;
20741 ucmd_buf.uscsi_cdblen = CDB_GROUP0;
20742 ucmd_buf.uscsi_bufaddr = (caddr_t)bufaddr;
20743 ucmd_buf.uscsi_buflen = buflen;
20744 ucmd_buf.uscsi_rqbuf = NULL;
20745 ucmd_buf.uscsi_rqlen = 0;
20746 ucmd_buf.uscsi_flags = USCSI_READ | USCSI_SILENT;
20747 ucmd_buf.uscsi_timeout = 200; /* Excessive legacy value */
20748
20749 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
20750 UIO_SYSSPACE, SD_PATH_DIRECT);
20751
20752 /*
20753 * Only handle status == 0, the upper-level caller
20754 * will put different assessment based on the context.
20755 */
20756 if (status == 0)
20757 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
20758
20759 if ((status == 0) && (residp != NULL)) {
20760 *residp = ucmd_buf.uscsi_resid;
20761 }
20762
20763 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_INQUIRY: exit\n");
20764
20765 return (status);
20766 }
20767
20768
20769 /*
20770 * Function: sd_send_scsi_TEST_UNIT_READY
20771 *
20772 * Description: Issue the scsi TEST UNIT READY command.
20773 * This routine can be told to set the flag USCSI_DIAGNOSE to
20774 * prevent retrying failed commands. Use this when the intent
20775 * is either to check for device readiness, to clear a Unit
20776 * Attention, or to clear any outstanding sense data.
20777 * However under specific conditions the expected behavior
20778 * is for retries to bring a device ready, so use the flag
20779 * with caution.
20780 *
20781 * Arguments: ssc - ssc contains pointer to driver soft state (unit)
20782 * structure for this target.
20783 * flag: SD_CHECK_FOR_MEDIA: return ENXIO if no media present
20784 * SD_DONT_RETRY_TUR: include uscsi flag USCSI_DIAGNOSE.
20785 * 0: dont check for media present, do retries on cmd.
20786 *
20787 * Return Code: 0 - Success
20788 * EIO - IO error
20789 * EACCES - Reservation conflict detected
20790 * ENXIO - Not Ready, medium not present
20791 * errno return code from sd_ssc_send()
20792 *
20793 * Context: Can sleep. Does not return until command is completed.
20794 */
20795
20796 static int
20797 sd_send_scsi_TEST_UNIT_READY(sd_ssc_t *ssc, int flag)
20798 {
20799 struct scsi_extended_sense sense_buf;
20800 union scsi_cdb cdb;
20801 struct uscsi_cmd ucmd_buf;
20802 int status;
20803 struct sd_lun *un;
20804
20805 ASSERT(ssc != NULL);
20806 un = ssc->ssc_un;
20807 ASSERT(un != NULL);
20808 ASSERT(!mutex_owned(SD_MUTEX(un)));
20809
20810 SD_TRACE(SD_LOG_IO, un,
20811 "sd_send_scsi_TEST_UNIT_READY: entry: un:0x%p\n", un);
20812
20813 /*
20814 * Some Seagate elite1 TQ devices get hung with disconnect/reconnect
20815 * timeouts when they receive a TUR and the queue is not empty. Check
20816 * the configuration flag set during attach (indicating the drive has
20817 * this firmware bug) and un_ncmds_in_transport before issuing the
20818 * TUR. If there are
20819 * pending commands return success, this is a bit arbitrary but is ok
20820 * for non-removables (i.e. the eliteI disks) and non-clustering
20821 * configurations.
20822 */
20823 if (un->un_f_cfg_tur_check == TRUE) {
20824 mutex_enter(SD_MUTEX(un));
20825 if (un->un_ncmds_in_transport != 0) {
20826 mutex_exit(SD_MUTEX(un));
20827 return (0);
20828 }
20829 mutex_exit(SD_MUTEX(un));
20830 }
20831
20832 bzero(&cdb, sizeof (cdb));
20833 bzero(&ucmd_buf, sizeof (ucmd_buf));
20834 bzero(&sense_buf, sizeof (struct scsi_extended_sense));
20835
20836 cdb.scc_cmd = SCMD_TEST_UNIT_READY;
20837
20838 ucmd_buf.uscsi_cdb = (char *)&cdb;
20839 ucmd_buf.uscsi_cdblen = CDB_GROUP0;
20840 ucmd_buf.uscsi_bufaddr = NULL;
20841 ucmd_buf.uscsi_buflen = 0;
20842 ucmd_buf.uscsi_rqbuf = (caddr_t)&sense_buf;
20843 ucmd_buf.uscsi_rqlen = sizeof (struct scsi_extended_sense);
20844 ucmd_buf.uscsi_flags = USCSI_RQENABLE | USCSI_SILENT;
20845
20846 /* Use flag USCSI_DIAGNOSE to prevent retries if it fails. */
20847 if ((flag & SD_DONT_RETRY_TUR) != 0) {
20848 ucmd_buf.uscsi_flags |= USCSI_DIAGNOSE;
20849 }
20850 ucmd_buf.uscsi_timeout = 60;
20851
20852 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
20853 UIO_SYSSPACE, ((flag & SD_BYPASS_PM) ? SD_PATH_DIRECT :
20854 SD_PATH_STANDARD));
20855
20856 switch (status) {
20857 case 0:
20858 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
20859 break; /* Success! */
20860 case EIO:
20861 switch (ucmd_buf.uscsi_status) {
20862 case STATUS_RESERVATION_CONFLICT:
20863 status = EACCES;
20864 break;
20865 case STATUS_CHECK:
20866 if ((flag & SD_CHECK_FOR_MEDIA) == 0) {
20867 break;
20868 }
20869 if ((ucmd_buf.uscsi_rqstatus == STATUS_GOOD) &&
20870 (scsi_sense_key((uint8_t *)&sense_buf) ==
20871 KEY_NOT_READY) &&
20872 (scsi_sense_asc((uint8_t *)&sense_buf) == 0x3A)) {
20873 status = ENXIO;
20874 }
20875 break;
20876 default:
20877 break;
20878 }
20879 break;
20880 default:
20881 break;
20882 }
20883
20884 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_TEST_UNIT_READY: exit\n");
20885
20886 return (status);
20887 }
20888
20889 /*
20890 * Function: sd_send_scsi_PERSISTENT_RESERVE_IN
20891 *
20892 * Description: Issue the scsi PERSISTENT RESERVE IN command.
20893 *
20894 * Arguments: ssc - ssc contains pointer to driver soft state (unit)
20895 * structure for this target.
20896 *
20897 * Return Code: 0 - Success
20898 * EACCES
20899 * ENOTSUP
20900 * errno return code from sd_ssc_send()
20901 *
20902 * Context: Can sleep. Does not return until command is completed.
20903 */
20904
20905 static int
20906 sd_send_scsi_PERSISTENT_RESERVE_IN(sd_ssc_t *ssc, uchar_t usr_cmd,
20907 uint16_t data_len, uchar_t *data_bufp)
20908 {
20909 struct scsi_extended_sense sense_buf;
20910 union scsi_cdb cdb;
20911 struct uscsi_cmd ucmd_buf;
20912 int status;
20913 int no_caller_buf = FALSE;
20914 struct sd_lun *un;
20915
20916 ASSERT(ssc != NULL);
20917 un = ssc->ssc_un;
20918 ASSERT(un != NULL);
20919 ASSERT(!mutex_owned(SD_MUTEX(un)));
20920 ASSERT((usr_cmd == SD_READ_KEYS) || (usr_cmd == SD_READ_RESV));
20921
20922 SD_TRACE(SD_LOG_IO, un,
20923 "sd_send_scsi_PERSISTENT_RESERVE_IN: entry: un:0x%p\n", un);
20924
20925 bzero(&cdb, sizeof (cdb));
20926 bzero(&ucmd_buf, sizeof (ucmd_buf));
20927 bzero(&sense_buf, sizeof (struct scsi_extended_sense));
20928 if (data_bufp == NULL) {
20929 /* Allocate a default buf if the caller did not give one */
20930 ASSERT(data_len == 0);
20931 data_len = MHIOC_RESV_KEY_SIZE;
20932 data_bufp = kmem_zalloc(MHIOC_RESV_KEY_SIZE, KM_SLEEP);
20933 no_caller_buf = TRUE;
20934 }
20935
20936 cdb.scc_cmd = SCMD_PERSISTENT_RESERVE_IN;
20937 cdb.cdb_opaque[1] = usr_cmd;
20938 FORMG1COUNT(&cdb, data_len);
20939
20940 ucmd_buf.uscsi_cdb = (char *)&cdb;
20941 ucmd_buf.uscsi_cdblen = CDB_GROUP1;
20942 ucmd_buf.uscsi_bufaddr = (caddr_t)data_bufp;
20943 ucmd_buf.uscsi_buflen = data_len;
20944 ucmd_buf.uscsi_rqbuf = (caddr_t)&sense_buf;
20945 ucmd_buf.uscsi_rqlen = sizeof (struct scsi_extended_sense);
20946 ucmd_buf.uscsi_flags = USCSI_RQENABLE | USCSI_READ | USCSI_SILENT;
20947 ucmd_buf.uscsi_timeout = 60;
20948
20949 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
20950 UIO_SYSSPACE, SD_PATH_STANDARD);
20951
20952 switch (status) {
20953 case 0:
20954 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
20955
20956 break; /* Success! */
20957 case EIO:
20958 switch (ucmd_buf.uscsi_status) {
20959 case STATUS_RESERVATION_CONFLICT:
20960 status = EACCES;
20961 break;
20962 case STATUS_CHECK:
20963 if ((ucmd_buf.uscsi_rqstatus == STATUS_GOOD) &&
20964 (scsi_sense_key((uint8_t *)&sense_buf) ==
20965 KEY_ILLEGAL_REQUEST)) {
20966 status = ENOTSUP;
20967 }
20968 break;
20969 default:
20970 break;
20971 }
20972 break;
20973 default:
20974 break;
20975 }
20976
20977 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_PERSISTENT_RESERVE_IN: exit\n");
20978
20979 if (no_caller_buf == TRUE) {
20980 kmem_free(data_bufp, data_len);
20981 }
20982
20983 return (status);
20984 }
20985
20986
20987 /*
20988 * Function: sd_send_scsi_PERSISTENT_RESERVE_OUT
20989 *
20990 * Description: This routine is the driver entry point for handling CD-ROM
20991 * multi-host persistent reservation requests (MHIOCGRP_INKEYS,
20992 * MHIOCGRP_INRESV) by sending the SCSI-3 PROUT commands to the
20993 * device.
20994 *
20995 * Arguments: ssc - ssc contains un - pointer to soft state struct
20996 * for the target.
20997 * usr_cmd SCSI-3 reservation facility command (one of
20998 * SD_SCSI3_REGISTER, SD_SCSI3_RESERVE, SD_SCSI3_RELEASE,
20999 * SD_SCSI3_PREEMPTANDABORT, SD_SCSI3_CLEAR)
21000 * usr_bufp - user provided pointer register, reserve descriptor or
21001 * preempt and abort structure (mhioc_register_t,
21002 * mhioc_resv_desc_t, mhioc_preemptandabort_t)
21003 *
21004 * Return Code: 0 - Success
21005 * EACCES
21006 * ENOTSUP
21007 * errno return code from sd_ssc_send()
21008 *
21009 * Context: Can sleep. Does not return until command is completed.
21010 */
21011
21012 static int
21013 sd_send_scsi_PERSISTENT_RESERVE_OUT(sd_ssc_t *ssc, uchar_t usr_cmd,
21014 uchar_t *usr_bufp)
21015 {
21016 struct scsi_extended_sense sense_buf;
21017 union scsi_cdb cdb;
21018 struct uscsi_cmd ucmd_buf;
21019 int status;
21020 uchar_t data_len = sizeof (sd_prout_t);
21021 sd_prout_t *prp;
21022 struct sd_lun *un;
21023
21024 ASSERT(ssc != NULL);
21025 un = ssc->ssc_un;
21026 ASSERT(un != NULL);
21027 ASSERT(!mutex_owned(SD_MUTEX(un)));
21028 ASSERT(data_len == 24); /* required by scsi spec */
21029
21030 SD_TRACE(SD_LOG_IO, un,
21031 "sd_send_scsi_PERSISTENT_RESERVE_OUT: entry: un:0x%p\n", un);
21032
21033 if (usr_bufp == NULL) {
21034 return (EINVAL);
21035 }
21036
21037 bzero(&cdb, sizeof (cdb));
21038 bzero(&ucmd_buf, sizeof (ucmd_buf));
21039 bzero(&sense_buf, sizeof (struct scsi_extended_sense));
21040 prp = kmem_zalloc(data_len, KM_SLEEP);
21041
21042 cdb.scc_cmd = SCMD_PERSISTENT_RESERVE_OUT;
21043 cdb.cdb_opaque[1] = usr_cmd;
21044 FORMG1COUNT(&cdb, data_len);
21045
21046 ucmd_buf.uscsi_cdb = (char *)&cdb;
21047 ucmd_buf.uscsi_cdblen = CDB_GROUP1;
21048 ucmd_buf.uscsi_bufaddr = (caddr_t)prp;
21049 ucmd_buf.uscsi_buflen = data_len;
21050 ucmd_buf.uscsi_rqbuf = (caddr_t)&sense_buf;
21051 ucmd_buf.uscsi_rqlen = sizeof (struct scsi_extended_sense);
21052 ucmd_buf.uscsi_flags = USCSI_RQENABLE | USCSI_WRITE | USCSI_SILENT;
21053 ucmd_buf.uscsi_timeout = 60;
21054
21055 switch (usr_cmd) {
21056 case SD_SCSI3_REGISTER: {
21057 mhioc_register_t *ptr = (mhioc_register_t *)usr_bufp;
21058
21059 bcopy(ptr->oldkey.key, prp->res_key, MHIOC_RESV_KEY_SIZE);
21060 bcopy(ptr->newkey.key, prp->service_key,
21061 MHIOC_RESV_KEY_SIZE);
21062 prp->aptpl = ptr->aptpl;
21063 break;
21064 }
21065 case SD_SCSI3_CLEAR: {
21066 mhioc_resv_desc_t *ptr = (mhioc_resv_desc_t *)usr_bufp;
21067
21068 bcopy(ptr->key.key, prp->res_key, MHIOC_RESV_KEY_SIZE);
21069 break;
21070 }
21071 case SD_SCSI3_RESERVE:
21072 case SD_SCSI3_RELEASE: {
21073 mhioc_resv_desc_t *ptr = (mhioc_resv_desc_t *)usr_bufp;
21074
21075 bcopy(ptr->key.key, prp->res_key, MHIOC_RESV_KEY_SIZE);
21076 prp->scope_address = BE_32(ptr->scope_specific_addr);
21077 cdb.cdb_opaque[2] = ptr->type;
21078 break;
21079 }
21080 case SD_SCSI3_PREEMPTANDABORT: {
21081 mhioc_preemptandabort_t *ptr =
21082 (mhioc_preemptandabort_t *)usr_bufp;
21083
21084 bcopy(ptr->resvdesc.key.key, prp->res_key, MHIOC_RESV_KEY_SIZE);
21085 bcopy(ptr->victim_key.key, prp->service_key,
21086 MHIOC_RESV_KEY_SIZE);
21087 prp->scope_address = BE_32(ptr->resvdesc.scope_specific_addr);
21088 cdb.cdb_opaque[2] = ptr->resvdesc.type;
21089 ucmd_buf.uscsi_flags |= USCSI_HEAD;
21090 break;
21091 }
21092 case SD_SCSI3_REGISTERANDIGNOREKEY:
21093 {
21094 mhioc_registerandignorekey_t *ptr;
21095 ptr = (mhioc_registerandignorekey_t *)usr_bufp;
21096 bcopy(ptr->newkey.key,
21097 prp->service_key, MHIOC_RESV_KEY_SIZE);
21098 prp->aptpl = ptr->aptpl;
21099 break;
21100 }
21101 default:
21102 ASSERT(FALSE);
21103 break;
21104 }
21105
21106 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
21107 UIO_SYSSPACE, SD_PATH_STANDARD);
21108
21109 switch (status) {
21110 case 0:
21111 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
21112 break; /* Success! */
21113 case EIO:
21114 switch (ucmd_buf.uscsi_status) {
21115 case STATUS_RESERVATION_CONFLICT:
21116 status = EACCES;
21117 break;
21118 case STATUS_CHECK:
21119 if ((ucmd_buf.uscsi_rqstatus == STATUS_GOOD) &&
21120 (scsi_sense_key((uint8_t *)&sense_buf) ==
21121 KEY_ILLEGAL_REQUEST)) {
21122 status = ENOTSUP;
21123 }
21124 break;
21125 default:
21126 break;
21127 }
21128 break;
21129 default:
21130 break;
21131 }
21132
21133 kmem_free(prp, data_len);
21134 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_PERSISTENT_RESERVE_OUT: exit\n");
21135 return (status);
21136 }
21137
21138
21139 /*
21140 * Function: sd_send_scsi_SYNCHRONIZE_CACHE
21141 *
21142 * Description: Issues a scsi SYNCHRONIZE CACHE command to the target
21143 *
21144 * Arguments: un - pointer to the target's soft state struct
21145 * dkc - pointer to the callback structure
21146 *
21147 * Return Code: 0 - success
21148 * errno-type error code
21149 *
21150 * Context: kernel thread context only.
21151 *
21152 * _______________________________________________________________
21153 * | dkc_flag & | dkc_callback | DKIOCFLUSHWRITECACHE |
21154 * |FLUSH_VOLATILE| | operation |
21155 * |______________|______________|_________________________________|
21156 * | 0 | NULL | Synchronous flush on both |
21157 * | | | volatile and non-volatile cache |
21158 * |______________|______________|_________________________________|
21159 * | 1 | NULL | Synchronous flush on volatile |
21160 * | | | cache; disk drivers may suppress|
21161 * | | | flush if disk table indicates |
21162 * | | | non-volatile cache |
21163 * |______________|______________|_________________________________|
21164 * | 0 | !NULL | Asynchronous flush on both |
21165 * | | | volatile and non-volatile cache;|
21166 * |______________|______________|_________________________________|
21167 * | 1 | !NULL | Asynchronous flush on volatile |
21168 * | | | cache; disk drivers may suppress|
21169 * | | | flush if disk table indicates |
21170 * | | | non-volatile cache |
21171 * |______________|______________|_________________________________|
21172 *
21173 */
21174
21175 static int
21176 sd_send_scsi_SYNCHRONIZE_CACHE(struct sd_lun *un, struct dk_callback *dkc)
21177 {
21178 struct sd_uscsi_info *uip;
21179 struct uscsi_cmd *uscmd;
21180 union scsi_cdb *cdb;
21181 struct buf *bp;
21182 int rval = 0;
21183 int is_async;
21184
21185 SD_TRACE(SD_LOG_IO, un,
21186 "sd_send_scsi_SYNCHRONIZE_CACHE: entry: un:0x%p\n", un);
21187
21188 ASSERT(un != NULL);
21189 ASSERT(!mutex_owned(SD_MUTEX(un)));
21190
21191 if (dkc == NULL || dkc->dkc_callback == NULL) {
21192 is_async = FALSE;
21193 } else {
21194 is_async = TRUE;
21195 }
21196
21197 mutex_enter(SD_MUTEX(un));
21198 /* check whether cache flush should be suppressed */
21199 if (un->un_f_suppress_cache_flush == TRUE) {
21200 mutex_exit(SD_MUTEX(un));
21201 /*
21202 * suppress the cache flush if the device is told to do
21203 * so by sd.conf or disk table
21204 */
21205 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_SYNCHRONIZE_CACHE: \
21206 skip the cache flush since suppress_cache_flush is %d!\n",
21207 un->un_f_suppress_cache_flush);
21208
21209 if (is_async == TRUE) {
21210 /* invoke callback for asynchronous flush */
21211 (*dkc->dkc_callback)(dkc->dkc_cookie, 0);
21212 }
21213 return (rval);
21214 }
21215 mutex_exit(SD_MUTEX(un));
21216
21217 /*
21218 * check dkc_flag & FLUSH_VOLATILE so SYNC_NV bit can be
21219 * set properly
21220 */
21221 cdb = kmem_zalloc(CDB_GROUP1, KM_SLEEP);
21222 cdb->scc_cmd = SCMD_SYNCHRONIZE_CACHE;
21223
21224 mutex_enter(SD_MUTEX(un));
21225 if (dkc != NULL && un->un_f_sync_nv_supported &&
21226 (dkc->dkc_flag & FLUSH_VOLATILE)) {
21227 /*
21228 * if the device supports SYNC_NV bit, turn on
21229 * the SYNC_NV bit to only flush volatile cache
21230 */
21231 cdb->cdb_un.tag |= SD_SYNC_NV_BIT;
21232 }
21233 mutex_exit(SD_MUTEX(un));
21234
21235 /*
21236 * First get some memory for the uscsi_cmd struct and cdb
21237 * and initialize for SYNCHRONIZE_CACHE cmd.
21238 */
21239 uscmd = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP);
21240 uscmd->uscsi_cdblen = CDB_GROUP1;
21241 uscmd->uscsi_cdb = (caddr_t)cdb;
21242 uscmd->uscsi_bufaddr = NULL;
21243 uscmd->uscsi_buflen = 0;
21244 uscmd->uscsi_rqbuf = kmem_zalloc(SENSE_LENGTH, KM_SLEEP);
21245 uscmd->uscsi_rqlen = SENSE_LENGTH;
21246 uscmd->uscsi_rqresid = SENSE_LENGTH;
21247 uscmd->uscsi_flags = USCSI_RQENABLE | USCSI_SILENT;
21248 uscmd->uscsi_timeout = sd_io_time;
21249
21250 /*
21251 * Allocate an sd_uscsi_info struct and fill it with the info
21252 * needed by sd_initpkt_for_uscsi(). Then put the pointer into
21253 * b_private in the buf for sd_initpkt_for_uscsi(). Note that
21254 * since we allocate the buf here in this function, we do not
21255 * need to preserve the prior contents of b_private.
21256 * The sd_uscsi_info struct is also used by sd_uscsi_strategy()
21257 */
21258 uip = kmem_zalloc(sizeof (struct sd_uscsi_info), KM_SLEEP);
21259 uip->ui_flags = SD_PATH_DIRECT;
21260 uip->ui_cmdp = uscmd;
21261
21262 bp = getrbuf(KM_SLEEP);
21263 bp->b_private = uip;
21264
21265 /*
21266 * Setup buffer to carry uscsi request.
21267 */
21268 bp->b_flags = B_BUSY;
21269 bp->b_bcount = 0;
21270 bp->b_blkno = 0;
21271
21272 if (is_async == TRUE) {
21273 bp->b_iodone = sd_send_scsi_SYNCHRONIZE_CACHE_biodone;
21274 uip->ui_dkc = *dkc;
21275 }
21276
21277 bp->b_edev = SD_GET_DEV(un);
21278 bp->b_dev = cmpdev(bp->b_edev); /* maybe unnecessary? */
21279
21280 /*
21281 * Unset un_f_sync_cache_required flag
21282 */
21283 mutex_enter(SD_MUTEX(un));
21284 un->un_f_sync_cache_required = FALSE;
21285 mutex_exit(SD_MUTEX(un));
21286
21287 (void) sd_uscsi_strategy(bp);
21288
21289 /*
21290 * If synchronous request, wait for completion
21291 * If async just return and let b_iodone callback
21292 * cleanup.
21293 * NOTE: On return, u_ncmds_in_driver will be decremented,
21294 * but it was also incremented in sd_uscsi_strategy(), so
21295 * we should be ok.
21296 */
21297 if (is_async == FALSE) {
21298 (void) biowait(bp);
21299 rval = sd_send_scsi_SYNCHRONIZE_CACHE_biodone(bp);
21300 }
21301
21302 return (rval);
21303 }
21304
21305
21306 static int
21307 sd_send_scsi_SYNCHRONIZE_CACHE_biodone(struct buf *bp)
21308 {
21309 struct sd_uscsi_info *uip;
21310 struct uscsi_cmd *uscmd;
21311 uint8_t *sense_buf;
21312 struct sd_lun *un;
21313 int status;
21314 union scsi_cdb *cdb;
21315
21316 uip = (struct sd_uscsi_info *)(bp->b_private);
21317 ASSERT(uip != NULL);
21318
21319 uscmd = uip->ui_cmdp;
21320 ASSERT(uscmd != NULL);
21321
21322 sense_buf = (uint8_t *)uscmd->uscsi_rqbuf;
21323 ASSERT(sense_buf != NULL);
21324
21325 un = ddi_get_soft_state(sd_state, SD_GET_INSTANCE_FROM_BUF(bp));
21326 ASSERT(un != NULL);
21327
21328 cdb = (union scsi_cdb *)uscmd->uscsi_cdb;
21329
21330 status = geterror(bp);
21331 switch (status) {
21332 case 0:
21333 break; /* Success! */
21334 case EIO:
21335 switch (uscmd->uscsi_status) {
21336 case STATUS_RESERVATION_CONFLICT:
21337 /* Ignore reservation conflict */
21338 status = 0;
21339 goto done;
21340
21341 case STATUS_CHECK:
21342 if ((uscmd->uscsi_rqstatus == STATUS_GOOD) &&
21343 (scsi_sense_key(sense_buf) ==
21344 KEY_ILLEGAL_REQUEST)) {
21345 /* Ignore Illegal Request error */
21346 if (cdb->cdb_un.tag&SD_SYNC_NV_BIT) {
21347 mutex_enter(SD_MUTEX(un));
21348 un->un_f_sync_nv_supported = FALSE;
21349 mutex_exit(SD_MUTEX(un));
21350 status = 0;
21351 SD_TRACE(SD_LOG_IO, un,
21352 "un_f_sync_nv_supported \
21353 is set to false.\n");
21354 goto done;
21355 }
21356
21357 mutex_enter(SD_MUTEX(un));
21358 un->un_f_sync_cache_supported = FALSE;
21359 mutex_exit(SD_MUTEX(un));
21360 SD_TRACE(SD_LOG_IO, un,
21361 "sd_send_scsi_SYNCHRONIZE_CACHE_biodone: \
21362 un_f_sync_cache_supported set to false \
21363 with asc = %x, ascq = %x\n",
21364 scsi_sense_asc(sense_buf),
21365 scsi_sense_ascq(sense_buf));
21366 status = ENOTSUP;
21367 goto done;
21368 }
21369 break;
21370 default:
21371 break;
21372 }
21373 /* FALLTHRU */
21374 default:
21375 /*
21376 * Turn on the un_f_sync_cache_required flag
21377 * since the SYNC CACHE command failed
21378 */
21379 mutex_enter(SD_MUTEX(un));
21380 un->un_f_sync_cache_required = TRUE;
21381 mutex_exit(SD_MUTEX(un));
21382
21383 /*
21384 * Don't log an error message if this device
21385 * has removable media.
21386 */
21387 if (!un->un_f_has_removable_media) {
21388 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
21389 "SYNCHRONIZE CACHE command failed (%d)\n", status);
21390 }
21391 break;
21392 }
21393
21394 done:
21395 if (uip->ui_dkc.dkc_callback != NULL) {
21396 (*uip->ui_dkc.dkc_callback)(uip->ui_dkc.dkc_cookie, status);
21397 }
21398
21399 ASSERT((bp->b_flags & B_REMAPPED) == 0);
21400 freerbuf(bp);
21401 kmem_free(uip, sizeof (struct sd_uscsi_info));
21402 kmem_free(uscmd->uscsi_rqbuf, SENSE_LENGTH);
21403 kmem_free(uscmd->uscsi_cdb, (size_t)uscmd->uscsi_cdblen);
21404 kmem_free(uscmd, sizeof (struct uscsi_cmd));
21405
21406 return (status);
21407 }
21408
21409
21410 /*
21411 * Function: sd_send_scsi_GET_CONFIGURATION
21412 *
21413 * Description: Issues the get configuration command to the device.
21414 * Called from sd_check_for_writable_cd & sd_get_media_info
21415 * caller needs to ensure that buflen = SD_PROFILE_HEADER_LEN
21416 * Arguments: ssc
21417 * ucmdbuf
21418 * rqbuf
21419 * rqbuflen
21420 * bufaddr
21421 * buflen
21422 * path_flag
21423 *
21424 * Return Code: 0 - Success
21425 * errno return code from sd_ssc_send()
21426 *
21427 * Context: Can sleep. Does not return until command is completed.
21428 *
21429 */
21430
21431 static int
21432 sd_send_scsi_GET_CONFIGURATION(sd_ssc_t *ssc, struct uscsi_cmd *ucmdbuf,
21433 uchar_t *rqbuf, uint_t rqbuflen, uchar_t *bufaddr, uint_t buflen,
21434 int path_flag)
21435 {
21436 char cdb[CDB_GROUP1];
21437 int status;
21438 struct sd_lun *un;
21439
21440 ASSERT(ssc != NULL);
21441 un = ssc->ssc_un;
21442 ASSERT(un != NULL);
21443 ASSERT(!mutex_owned(SD_MUTEX(un)));
21444 ASSERT(bufaddr != NULL);
21445 ASSERT(ucmdbuf != NULL);
21446 ASSERT(rqbuf != NULL);
21447
21448 SD_TRACE(SD_LOG_IO, un,
21449 "sd_send_scsi_GET_CONFIGURATION: entry: un:0x%p\n", un);
21450
21451 bzero(cdb, sizeof (cdb));
21452 bzero(ucmdbuf, sizeof (struct uscsi_cmd));
21453 bzero(rqbuf, rqbuflen);
21454 bzero(bufaddr, buflen);
21455
21456 /*
21457 * Set up cdb field for the get configuration command.
21458 */
21459 cdb[0] = SCMD_GET_CONFIGURATION;
21460 cdb[1] = 0x02; /* Requested Type */
21461 cdb[8] = SD_PROFILE_HEADER_LEN;
21462 ucmdbuf->uscsi_cdb = cdb;
21463 ucmdbuf->uscsi_cdblen = CDB_GROUP1;
21464 ucmdbuf->uscsi_bufaddr = (caddr_t)bufaddr;
21465 ucmdbuf->uscsi_buflen = buflen;
21466 ucmdbuf->uscsi_timeout = sd_io_time;
21467 ucmdbuf->uscsi_rqbuf = (caddr_t)rqbuf;
21468 ucmdbuf->uscsi_rqlen = rqbuflen;
21469 ucmdbuf->uscsi_flags = USCSI_RQENABLE|USCSI_SILENT|USCSI_READ;
21470
21471 status = sd_ssc_send(ssc, ucmdbuf, FKIOCTL,
21472 UIO_SYSSPACE, path_flag);
21473
21474 switch (status) {
21475 case 0:
21476 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
21477 break; /* Success! */
21478 case EIO:
21479 switch (ucmdbuf->uscsi_status) {
21480 case STATUS_RESERVATION_CONFLICT:
21481 status = EACCES;
21482 break;
21483 default:
21484 break;
21485 }
21486 break;
21487 default:
21488 break;
21489 }
21490
21491 if (status == 0) {
21492 SD_DUMP_MEMORY(un, SD_LOG_IO,
21493 "sd_send_scsi_GET_CONFIGURATION: data",
21494 (uchar_t *)bufaddr, SD_PROFILE_HEADER_LEN, SD_LOG_HEX);
21495 }
21496
21497 SD_TRACE(SD_LOG_IO, un,
21498 "sd_send_scsi_GET_CONFIGURATION: exit\n");
21499
21500 return (status);
21501 }
21502
21503 /*
21504 * Function: sd_send_scsi_feature_GET_CONFIGURATION
21505 *
21506 * Description: Issues the get configuration command to the device to
21507 * retrieve a specific feature. Called from
21508 * sd_check_for_writable_cd & sd_set_mmc_caps.
21509 * Arguments: ssc
21510 * ucmdbuf
21511 * rqbuf
21512 * rqbuflen
21513 * bufaddr
21514 * buflen
21515 * feature
21516 *
21517 * Return Code: 0 - Success
21518 * errno return code from sd_ssc_send()
21519 *
21520 * Context: Can sleep. Does not return until command is completed.
21521 *
21522 */
21523 static int
21524 sd_send_scsi_feature_GET_CONFIGURATION(sd_ssc_t *ssc,
21525 struct uscsi_cmd *ucmdbuf, uchar_t *rqbuf, uint_t rqbuflen,
21526 uchar_t *bufaddr, uint_t buflen, char feature, int path_flag)
21527 {
21528 char cdb[CDB_GROUP1];
21529 int status;
21530 struct sd_lun *un;
21531
21532 ASSERT(ssc != NULL);
21533 un = ssc->ssc_un;
21534 ASSERT(un != NULL);
21535 ASSERT(!mutex_owned(SD_MUTEX(un)));
21536 ASSERT(bufaddr != NULL);
21537 ASSERT(ucmdbuf != NULL);
21538 ASSERT(rqbuf != NULL);
21539
21540 SD_TRACE(SD_LOG_IO, un,
21541 "sd_send_scsi_feature_GET_CONFIGURATION: entry: un:0x%p\n", un);
21542
21543 bzero(cdb, sizeof (cdb));
21544 bzero(ucmdbuf, sizeof (struct uscsi_cmd));
21545 bzero(rqbuf, rqbuflen);
21546 bzero(bufaddr, buflen);
21547
21548 /*
21549 * Set up cdb field for the get configuration command.
21550 */
21551 cdb[0] = SCMD_GET_CONFIGURATION;
21552 cdb[1] = 0x02; /* Requested Type */
21553 cdb[3] = feature;
21554 cdb[8] = buflen;
21555 ucmdbuf->uscsi_cdb = cdb;
21556 ucmdbuf->uscsi_cdblen = CDB_GROUP1;
21557 ucmdbuf->uscsi_bufaddr = (caddr_t)bufaddr;
21558 ucmdbuf->uscsi_buflen = buflen;
21559 ucmdbuf->uscsi_timeout = sd_io_time;
21560 ucmdbuf->uscsi_rqbuf = (caddr_t)rqbuf;
21561 ucmdbuf->uscsi_rqlen = rqbuflen;
21562 ucmdbuf->uscsi_flags = USCSI_RQENABLE|USCSI_SILENT|USCSI_READ;
21563
21564 status = sd_ssc_send(ssc, ucmdbuf, FKIOCTL,
21565 UIO_SYSSPACE, path_flag);
21566
21567 switch (status) {
21568 case 0:
21569
21570 break; /* Success! */
21571 case EIO:
21572 switch (ucmdbuf->uscsi_status) {
21573 case STATUS_RESERVATION_CONFLICT:
21574 status = EACCES;
21575 break;
21576 default:
21577 break;
21578 }
21579 break;
21580 default:
21581 break;
21582 }
21583
21584 if (status == 0) {
21585 SD_DUMP_MEMORY(un, SD_LOG_IO,
21586 "sd_send_scsi_feature_GET_CONFIGURATION: data",
21587 (uchar_t *)bufaddr, SD_PROFILE_HEADER_LEN, SD_LOG_HEX);
21588 }
21589
21590 SD_TRACE(SD_LOG_IO, un,
21591 "sd_send_scsi_feature_GET_CONFIGURATION: exit\n");
21592
21593 return (status);
21594 }
21595
21596
21597 /*
21598 * Function: sd_send_scsi_MODE_SENSE
21599 *
21600 * Description: Utility function for issuing a scsi MODE SENSE command.
21601 * Note: This routine uses a consistent implementation for Group0,
21602 * Group1, and Group2 commands across all platforms. ATAPI devices
21603 * use Group 1 Read/Write commands and Group 2 Mode Sense/Select
21604 *
21605 * Arguments: ssc - ssc contains pointer to driver soft state (unit)
21606 * structure for this target.
21607 * cdbsize - size CDB to be used (CDB_GROUP0 (6 byte), or
21608 * CDB_GROUP[1|2] (10 byte).
21609 * bufaddr - buffer for page data retrieved from the target.
21610 * buflen - size of page to be retrieved.
21611 * page_code - page code of data to be retrieved from the target.
21612 * path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and
21613 * the normal command waitq, or SD_PATH_DIRECT_PRIORITY
21614 * to use the USCSI "direct" chain and bypass the normal
21615 * command waitq.
21616 *
21617 * Return Code: 0 - Success
21618 * errno return code from sd_ssc_send()
21619 *
21620 * Context: Can sleep. Does not return until command is completed.
21621 */
21622
21623 static int
21624 sd_send_scsi_MODE_SENSE(sd_ssc_t *ssc, int cdbsize, uchar_t *bufaddr,
21625 size_t buflen, uchar_t page_code, int path_flag)
21626 {
21627 struct scsi_extended_sense sense_buf;
21628 union scsi_cdb cdb;
21629 struct uscsi_cmd ucmd_buf;
21630 int status;
21631 int headlen;
21632 struct sd_lun *un;
21633
21634 ASSERT(ssc != NULL);
21635 un = ssc->ssc_un;
21636 ASSERT(un != NULL);
21637 ASSERT(!mutex_owned(SD_MUTEX(un)));
21638 ASSERT(bufaddr != NULL);
21639 ASSERT((cdbsize == CDB_GROUP0) || (cdbsize == CDB_GROUP1) ||
21640 (cdbsize == CDB_GROUP2));
21641
21642 SD_TRACE(SD_LOG_IO, un,
21643 "sd_send_scsi_MODE_SENSE: entry: un:0x%p\n", un);
21644
21645 bzero(&cdb, sizeof (cdb));
21646 bzero(&ucmd_buf, sizeof (ucmd_buf));
21647 bzero(&sense_buf, sizeof (struct scsi_extended_sense));
21648 bzero(bufaddr, buflen);
21649
21650 if (cdbsize == CDB_GROUP0) {
21651 cdb.scc_cmd = SCMD_MODE_SENSE;
21652 cdb.cdb_opaque[2] = page_code;
21653 FORMG0COUNT(&cdb, buflen);
21654 headlen = MODE_HEADER_LENGTH;
21655 } else {
21656 cdb.scc_cmd = SCMD_MODE_SENSE_G1;
21657 cdb.cdb_opaque[2] = page_code;
21658 FORMG1COUNT(&cdb, buflen);
21659 headlen = MODE_HEADER_LENGTH_GRP2;
21660 }
21661
21662 ASSERT(headlen <= buflen);
21663 SD_FILL_SCSI1_LUN_CDB(un, &cdb);
21664
21665 ucmd_buf.uscsi_cdb = (char *)&cdb;
21666 ucmd_buf.uscsi_cdblen = (uchar_t)cdbsize;
21667 ucmd_buf.uscsi_bufaddr = (caddr_t)bufaddr;
21668 ucmd_buf.uscsi_buflen = buflen;
21669 ucmd_buf.uscsi_rqbuf = (caddr_t)&sense_buf;
21670 ucmd_buf.uscsi_rqlen = sizeof (struct scsi_extended_sense);
21671 ucmd_buf.uscsi_flags = USCSI_RQENABLE | USCSI_READ | USCSI_SILENT;
21672 ucmd_buf.uscsi_timeout = 60;
21673
21674 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
21675 UIO_SYSSPACE, path_flag);
21676
21677 switch (status) {
21678 case 0:
21679 /*
21680 * sr_check_wp() uses 0x3f page code and check the header of
21681 * mode page to determine if target device is write-protected.
21682 * But some USB devices return 0 bytes for 0x3f page code. For
21683 * this case, make sure that mode page header is returned at
21684 * least.
21685 */
21686 if (buflen - ucmd_buf.uscsi_resid < headlen) {
21687 status = EIO;
21688 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, -1,
21689 "mode page header is not returned");
21690 }
21691 break; /* Success! */
21692 case EIO:
21693 switch (ucmd_buf.uscsi_status) {
21694 case STATUS_RESERVATION_CONFLICT:
21695 status = EACCES;
21696 break;
21697 default:
21698 break;
21699 }
21700 break;
21701 default:
21702 break;
21703 }
21704
21705 if (status == 0) {
21706 SD_DUMP_MEMORY(un, SD_LOG_IO, "sd_send_scsi_MODE_SENSE: data",
21707 (uchar_t *)bufaddr, buflen, SD_LOG_HEX);
21708 }
21709 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_MODE_SENSE: exit\n");
21710
21711 return (status);
21712 }
21713
21714
21715 /*
21716 * Function: sd_send_scsi_MODE_SELECT
21717 *
21718 * Description: Utility function for issuing a scsi MODE SELECT command.
21719 * Note: This routine uses a consistent implementation for Group0,
21720 * Group1, and Group2 commands across all platforms. ATAPI devices
21721 * use Group 1 Read/Write commands and Group 2 Mode Sense/Select
21722 *
21723 * Arguments: ssc - ssc contains pointer to driver soft state (unit)
21724 * structure for this target.
21725 * cdbsize - size CDB to be used (CDB_GROUP0 (6 byte), or
21726 * CDB_GROUP[1|2] (10 byte).
21727 * bufaddr - buffer for page data retrieved from the target.
21728 * buflen - size of page to be retrieved.
21729 * save_page - boolean to determin if SP bit should be set.
21730 * path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and
21731 * the normal command waitq, or SD_PATH_DIRECT_PRIORITY
21732 * to use the USCSI "direct" chain and bypass the normal
21733 * command waitq.
21734 *
21735 * Return Code: 0 - Success
21736 * errno return code from sd_ssc_send()
21737 *
21738 * Context: Can sleep. Does not return until command is completed.
21739 */
21740
21741 static int
21742 sd_send_scsi_MODE_SELECT(sd_ssc_t *ssc, int cdbsize, uchar_t *bufaddr,
21743 size_t buflen, uchar_t save_page, int path_flag)
21744 {
21745 struct scsi_extended_sense sense_buf;
21746 union scsi_cdb cdb;
21747 struct uscsi_cmd ucmd_buf;
21748 int status;
21749 struct sd_lun *un;
21750
21751 ASSERT(ssc != NULL);
21752 un = ssc->ssc_un;
21753 ASSERT(un != NULL);
21754 ASSERT(!mutex_owned(SD_MUTEX(un)));
21755 ASSERT(bufaddr != NULL);
21756 ASSERT((cdbsize == CDB_GROUP0) || (cdbsize == CDB_GROUP1) ||
21757 (cdbsize == CDB_GROUP2));
21758
21759 SD_TRACE(SD_LOG_IO, un,
21760 "sd_send_scsi_MODE_SELECT: entry: un:0x%p\n", un);
21761
21762 bzero(&cdb, sizeof (cdb));
21763 bzero(&ucmd_buf, sizeof (ucmd_buf));
21764 bzero(&sense_buf, sizeof (struct scsi_extended_sense));
21765
21766 /* Set the PF bit for many third party drives */
21767 cdb.cdb_opaque[1] = 0x10;
21768
21769 /* Set the savepage(SP) bit if given */
21770 if (save_page == SD_SAVE_PAGE) {
21771 cdb.cdb_opaque[1] |= 0x01;
21772 }
21773
21774 if (cdbsize == CDB_GROUP0) {
21775 cdb.scc_cmd = SCMD_MODE_SELECT;
21776 FORMG0COUNT(&cdb, buflen);
21777 } else {
21778 cdb.scc_cmd = SCMD_MODE_SELECT_G1;
21779 FORMG1COUNT(&cdb, buflen);
21780 }
21781
21782 SD_FILL_SCSI1_LUN_CDB(un, &cdb);
21783
21784 ucmd_buf.uscsi_cdb = (char *)&cdb;
21785 ucmd_buf.uscsi_cdblen = (uchar_t)cdbsize;
21786 ucmd_buf.uscsi_bufaddr = (caddr_t)bufaddr;
21787 ucmd_buf.uscsi_buflen = buflen;
21788 ucmd_buf.uscsi_rqbuf = (caddr_t)&sense_buf;
21789 ucmd_buf.uscsi_rqlen = sizeof (struct scsi_extended_sense);
21790 ucmd_buf.uscsi_flags = USCSI_RQENABLE | USCSI_WRITE | USCSI_SILENT;
21791 ucmd_buf.uscsi_timeout = 60;
21792
21793 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
21794 UIO_SYSSPACE, path_flag);
21795
21796 switch (status) {
21797 case 0:
21798 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
21799 break; /* Success! */
21800 case EIO:
21801 switch (ucmd_buf.uscsi_status) {
21802 case STATUS_RESERVATION_CONFLICT:
21803 status = EACCES;
21804 break;
21805 default:
21806 break;
21807 }
21808 break;
21809 default:
21810 break;
21811 }
21812
21813 if (status == 0) {
21814 SD_DUMP_MEMORY(un, SD_LOG_IO, "sd_send_scsi_MODE_SELECT: data",
21815 (uchar_t *)bufaddr, buflen, SD_LOG_HEX);
21816 }
21817 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_MODE_SELECT: exit\n");
21818
21819 return (status);
21820 }
21821
21822
21823 /*
21824 * Function: sd_send_scsi_RDWR
21825 *
21826 * Description: Issue a scsi READ or WRITE command with the given parameters.
21827 *
21828 * Arguments: ssc - ssc contains pointer to driver soft state (unit)
21829 * structure for this target.
21830 * cmd: SCMD_READ or SCMD_WRITE
21831 * bufaddr: Address of caller's buffer to receive the RDWR data
21832 * buflen: Length of caller's buffer receive the RDWR data.
21833 * start_block: Block number for the start of the RDWR operation.
21834 * (Assumes target-native block size.)
21835 * residp: Pointer to variable to receive the redisual of the
21836 * RDWR operation (may be NULL of no residual requested).
21837 * path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and
21838 * the normal command waitq, or SD_PATH_DIRECT_PRIORITY
21839 * to use the USCSI "direct" chain and bypass the normal
21840 * command waitq.
21841 *
21842 * Return Code: 0 - Success
21843 * errno return code from sd_ssc_send()
21844 *
21845 * Context: Can sleep. Does not return until command is completed.
21846 */
21847
21848 static int
21849 sd_send_scsi_RDWR(sd_ssc_t *ssc, uchar_t cmd, void *bufaddr,
21850 size_t buflen, daddr_t start_block, int path_flag)
21851 {
21852 struct scsi_extended_sense sense_buf;
21853 union scsi_cdb cdb;
21854 struct uscsi_cmd ucmd_buf;
21855 uint32_t block_count;
21856 int status;
21857 int cdbsize;
21858 uchar_t flag;
21859 struct sd_lun *un;
21860
21861 ASSERT(ssc != NULL);
21862 un = ssc->ssc_un;
21863 ASSERT(un != NULL);
21864 ASSERT(!mutex_owned(SD_MUTEX(un)));
21865 ASSERT(bufaddr != NULL);
21866 ASSERT((cmd == SCMD_READ) || (cmd == SCMD_WRITE));
21867
21868 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_RDWR: entry: un:0x%p\n", un);
21869
21870 if (un->un_f_tgt_blocksize_is_valid != TRUE) {
21871 return (EINVAL);
21872 }
21873
21874 mutex_enter(SD_MUTEX(un));
21875 block_count = SD_BYTES2TGTBLOCKS(un, buflen);
21876 mutex_exit(SD_MUTEX(un));
21877
21878 flag = (cmd == SCMD_READ) ? USCSI_READ : USCSI_WRITE;
21879
21880 SD_INFO(SD_LOG_IO, un, "sd_send_scsi_RDWR: "
21881 "bufaddr:0x%p buflen:0x%x start_block:0x%p block_count:0x%x\n",
21882 bufaddr, buflen, start_block, block_count);
21883
21884 bzero(&cdb, sizeof (cdb));
21885 bzero(&ucmd_buf, sizeof (ucmd_buf));
21886 bzero(&sense_buf, sizeof (struct scsi_extended_sense));
21887
21888 /* Compute CDB size to use */
21889 if (start_block > 0xffffffff)
21890 cdbsize = CDB_GROUP4;
21891 else if ((start_block & 0xFFE00000) ||
21892 (un->un_f_cfg_is_atapi == TRUE))
21893 cdbsize = CDB_GROUP1;
21894 else
21895 cdbsize = CDB_GROUP0;
21896
21897 switch (cdbsize) {
21898 case CDB_GROUP0: /* 6-byte CDBs */
21899 cdb.scc_cmd = cmd;
21900 FORMG0ADDR(&cdb, start_block);
21901 FORMG0COUNT(&cdb, block_count);
21902 break;
21903 case CDB_GROUP1: /* 10-byte CDBs */
21904 cdb.scc_cmd = cmd | SCMD_GROUP1;
21905 FORMG1ADDR(&cdb, start_block);
21906 FORMG1COUNT(&cdb, block_count);
21907 break;
21908 case CDB_GROUP4: /* 16-byte CDBs */
21909 cdb.scc_cmd = cmd | SCMD_GROUP4;
21910 FORMG4LONGADDR(&cdb, (uint64_t)start_block);
21911 FORMG4COUNT(&cdb, block_count);
21912 break;
21913 case CDB_GROUP5: /* 12-byte CDBs (currently unsupported) */
21914 default:
21915 /* All others reserved */
21916 return (EINVAL);
21917 }
21918
21919 /* Set LUN bit(s) in CDB if this is a SCSI-1 device */
21920 SD_FILL_SCSI1_LUN_CDB(un, &cdb);
21921
21922 ucmd_buf.uscsi_cdb = (char *)&cdb;
21923 ucmd_buf.uscsi_cdblen = (uchar_t)cdbsize;
21924 ucmd_buf.uscsi_bufaddr = bufaddr;
21925 ucmd_buf.uscsi_buflen = buflen;
21926 ucmd_buf.uscsi_rqbuf = (caddr_t)&sense_buf;
21927 ucmd_buf.uscsi_rqlen = sizeof (struct scsi_extended_sense);
21928 ucmd_buf.uscsi_flags = flag | USCSI_RQENABLE | USCSI_SILENT;
21929 ucmd_buf.uscsi_timeout = 60;
21930 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
21931 UIO_SYSSPACE, path_flag);
21932
21933 switch (status) {
21934 case 0:
21935 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
21936 break; /* Success! */
21937 case EIO:
21938 switch (ucmd_buf.uscsi_status) {
21939 case STATUS_RESERVATION_CONFLICT:
21940 status = EACCES;
21941 break;
21942 default:
21943 break;
21944 }
21945 break;
21946 default:
21947 break;
21948 }
21949
21950 if (status == 0) {
21951 SD_DUMP_MEMORY(un, SD_LOG_IO, "sd_send_scsi_RDWR: data",
21952 (uchar_t *)bufaddr, buflen, SD_LOG_HEX);
21953 }
21954
21955 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_RDWR: exit\n");
21956
21957 return (status);
21958 }
21959
21960
21961 /*
21962 * Function: sd_send_scsi_LOG_SENSE
21963 *
21964 * Description: Issue a scsi LOG_SENSE command with the given parameters.
21965 *
21966 * Arguments: ssc - ssc contains pointer to driver soft state (unit)
21967 * structure for this target.
21968 *
21969 * Return Code: 0 - Success
21970 * errno return code from sd_ssc_send()
21971 *
21972 * Context: Can sleep. Does not return until command is completed.
21973 */
21974
21975 static int
21976 sd_send_scsi_LOG_SENSE(sd_ssc_t *ssc, uchar_t *bufaddr, uint16_t buflen,
21977 uchar_t page_code, uchar_t page_control, uint16_t param_ptr,
21978 int path_flag)
21979
21980 {
21981 struct scsi_extended_sense sense_buf;
21982 union scsi_cdb cdb;
21983 struct uscsi_cmd ucmd_buf;
21984 int status;
21985 struct sd_lun *un;
21986
21987 ASSERT(ssc != NULL);
21988 un = ssc->ssc_un;
21989 ASSERT(un != NULL);
21990 ASSERT(!mutex_owned(SD_MUTEX(un)));
21991
21992 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_LOG_SENSE: entry: un:0x%p\n", un);
21993
21994 bzero(&cdb, sizeof (cdb));
21995 bzero(&ucmd_buf, sizeof (ucmd_buf));
21996 bzero(&sense_buf, sizeof (struct scsi_extended_sense));
21997
21998 cdb.scc_cmd = SCMD_LOG_SENSE_G1;
21999 cdb.cdb_opaque[2] = (page_control << 6) | page_code;
22000 cdb.cdb_opaque[5] = (uchar_t)((param_ptr & 0xFF00) >> 8);
22001 cdb.cdb_opaque[6] = (uchar_t)(param_ptr & 0x00FF);
22002 FORMG1COUNT(&cdb, buflen);
22003
22004 ucmd_buf.uscsi_cdb = (char *)&cdb;
22005 ucmd_buf.uscsi_cdblen = CDB_GROUP1;
22006 ucmd_buf.uscsi_bufaddr = (caddr_t)bufaddr;
22007 ucmd_buf.uscsi_buflen = buflen;
22008 ucmd_buf.uscsi_rqbuf = (caddr_t)&sense_buf;
22009 ucmd_buf.uscsi_rqlen = sizeof (struct scsi_extended_sense);
22010 ucmd_buf.uscsi_flags = USCSI_RQENABLE | USCSI_READ | USCSI_SILENT;
22011 ucmd_buf.uscsi_timeout = 60;
22012
22013 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
22014 UIO_SYSSPACE, path_flag);
22015
22016 switch (status) {
22017 case 0:
22018 break;
22019 case EIO:
22020 switch (ucmd_buf.uscsi_status) {
22021 case STATUS_RESERVATION_CONFLICT:
22022 status = EACCES;
22023 break;
22024 case STATUS_CHECK:
22025 if ((ucmd_buf.uscsi_rqstatus == STATUS_GOOD) &&
22026 (scsi_sense_key((uint8_t *)&sense_buf) ==
22027 KEY_ILLEGAL_REQUEST) &&
22028 (scsi_sense_asc((uint8_t *)&sense_buf) == 0x24)) {
22029 /*
22030 * ASC 0x24: INVALID FIELD IN CDB
22031 */
22032 switch (page_code) {
22033 case START_STOP_CYCLE_PAGE:
22034 /*
22035 * The start stop cycle counter is
22036 * implemented as page 0x31 in earlier
22037 * generation disks. In new generation
22038 * disks the start stop cycle counter is
22039 * implemented as page 0xE. To properly
22040 * handle this case if an attempt for
22041 * log page 0xE is made and fails we
22042 * will try again using page 0x31.
22043 *
22044 * Network storage BU committed to
22045 * maintain the page 0x31 for this
22046 * purpose and will not have any other
22047 * page implemented with page code 0x31
22048 * until all disks transition to the
22049 * standard page.
22050 */
22051 mutex_enter(SD_MUTEX(un));
22052 un->un_start_stop_cycle_page =
22053 START_STOP_CYCLE_VU_PAGE;
22054 cdb.cdb_opaque[2] =
22055 (char)(page_control << 6) |
22056 un->un_start_stop_cycle_page;
22057 mutex_exit(SD_MUTEX(un));
22058 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
22059 status = sd_ssc_send(
22060 ssc, &ucmd_buf, FKIOCTL,
22061 UIO_SYSSPACE, path_flag);
22062
22063 break;
22064 case TEMPERATURE_PAGE:
22065 status = ENOTTY;
22066 break;
22067 default:
22068 break;
22069 }
22070 }
22071 break;
22072 default:
22073 break;
22074 }
22075 break;
22076 default:
22077 break;
22078 }
22079
22080 if (status == 0) {
22081 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
22082 SD_DUMP_MEMORY(un, SD_LOG_IO, "sd_send_scsi_LOG_SENSE: data",
22083 (uchar_t *)bufaddr, buflen, SD_LOG_HEX);
22084 }
22085
22086 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_LOG_SENSE: exit\n");
22087
22088 return (status);
22089 }
22090
22091
22092 /*
22093 * Function: sd_send_scsi_GET_EVENT_STATUS_NOTIFICATION
22094 *
22095 * Description: Issue the scsi GET EVENT STATUS NOTIFICATION command.
22096 *
22097 * Arguments: ssc - ssc contains pointer to driver soft state (unit)
22098 * structure for this target.
22099 * bufaddr
22100 * buflen
22101 * class_req
22102 *
22103 * Return Code: 0 - Success
22104 * errno return code from sd_ssc_send()
22105 *
22106 * Context: Can sleep. Does not return until command is completed.
22107 */
22108
22109 static int
22110 sd_send_scsi_GET_EVENT_STATUS_NOTIFICATION(sd_ssc_t *ssc, uchar_t *bufaddr,
22111 size_t buflen, uchar_t class_req)
22112 {
22113 union scsi_cdb cdb;
22114 struct uscsi_cmd ucmd_buf;
22115 int status;
22116 struct sd_lun *un;
22117
22118 ASSERT(ssc != NULL);
22119 un = ssc->ssc_un;
22120 ASSERT(un != NULL);
22121 ASSERT(!mutex_owned(SD_MUTEX(un)));
22122 ASSERT(bufaddr != NULL);
22123
22124 SD_TRACE(SD_LOG_IO, un,
22125 "sd_send_scsi_GET_EVENT_STATUS_NOTIFICATION: entry: un:0x%p\n", un);
22126
22127 bzero(&cdb, sizeof (cdb));
22128 bzero(&ucmd_buf, sizeof (ucmd_buf));
22129 bzero(bufaddr, buflen);
22130
22131 cdb.scc_cmd = SCMD_GET_EVENT_STATUS_NOTIFICATION;
22132 cdb.cdb_opaque[1] = 1; /* polled */
22133 cdb.cdb_opaque[4] = class_req;
22134 FORMG1COUNT(&cdb, buflen);
22135
22136 ucmd_buf.uscsi_cdb = (char *)&cdb;
22137 ucmd_buf.uscsi_cdblen = CDB_GROUP1;
22138 ucmd_buf.uscsi_bufaddr = (caddr_t)bufaddr;
22139 ucmd_buf.uscsi_buflen = buflen;
22140 ucmd_buf.uscsi_rqbuf = NULL;
22141 ucmd_buf.uscsi_rqlen = 0;
22142 ucmd_buf.uscsi_flags = USCSI_READ | USCSI_SILENT;
22143 ucmd_buf.uscsi_timeout = 60;
22144
22145 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
22146 UIO_SYSSPACE, SD_PATH_DIRECT);
22147
22148 /*
22149 * Only handle status == 0, the upper-level caller
22150 * will put different assessment based on the context.
22151 */
22152 if (status == 0) {
22153 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
22154
22155 if (ucmd_buf.uscsi_resid != 0) {
22156 status = EIO;
22157 }
22158 }
22159
22160 SD_TRACE(SD_LOG_IO, un,
22161 "sd_send_scsi_GET_EVENT_STATUS_NOTIFICATION: exit\n");
22162
22163 return (status);
22164 }
22165
22166
22167 static boolean_t
22168 sd_gesn_media_data_valid(uchar_t *data)
22169 {
22170 uint16_t len;
22171
22172 len = (data[1] << 8) | data[0];
22173 return ((len >= 6) &&
22174 ((data[2] & SD_GESN_HEADER_NEA) == 0) &&
22175 ((data[2] & SD_GESN_HEADER_CLASS) == SD_GESN_MEDIA_CLASS) &&
22176 ((data[3] & (1 << SD_GESN_MEDIA_CLASS)) != 0));
22177 }
22178
22179
22180 /*
22181 * Function: sdioctl
22182 *
22183 * Description: Driver's ioctl(9e) entry point function.
22184 *
22185 * Arguments: dev - device number
22186 * cmd - ioctl operation to be performed
22187 * arg - user argument, contains data to be set or reference
22188 * parameter for get
22189 * flag - bit flag, indicating open settings, 32/64 bit type
22190 * cred_p - user credential pointer
22191 * rval_p - calling process return value (OPT)
22192 *
22193 * Return Code: EINVAL
22194 * ENOTTY
22195 * ENXIO
22196 * EIO
22197 * EFAULT
22198 * ENOTSUP
22199 * EPERM
22200 *
22201 * Context: Called from the device switch at normal priority.
22202 */
22203
22204 static int
22205 sdioctl(dev_t dev, int cmd, intptr_t arg, int flag, cred_t *cred_p, int *rval_p)
22206 {
22207 struct sd_lun *un = NULL;
22208 int err = 0;
22209 int i = 0;
22210 cred_t *cr;
22211 int tmprval = EINVAL;
22212 boolean_t is_valid;
22213 sd_ssc_t *ssc;
22214
22215 /*
22216 * All device accesses go thru sdstrategy where we check on suspend
22217 * status
22218 */
22219 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
22220 return (ENXIO);
22221 }
22222
22223 ASSERT(!mutex_owned(SD_MUTEX(un)));
22224
22225 /* Initialize sd_ssc_t for internal uscsi commands */
22226 ssc = sd_ssc_init(un);
22227
22228 is_valid = SD_IS_VALID_LABEL(un);
22229
22230 /*
22231 * Moved this wait from sd_uscsi_strategy to here for
22232 * reasons of deadlock prevention. Internal driver commands,
22233 * specifically those to change a devices power level, result
22234 * in a call to sd_uscsi_strategy.
22235 */
22236 mutex_enter(SD_MUTEX(un));
22237 while ((un->un_state == SD_STATE_SUSPENDED) ||
22238 (un->un_state == SD_STATE_PM_CHANGING)) {
22239 cv_wait(&un->un_suspend_cv, SD_MUTEX(un));
22240 }
22241 /*
22242 * Twiddling the counter here protects commands from now
22243 * through to the top of sd_uscsi_strategy. Without the
22244 * counter inc. a power down, for example, could get in
22245 * after the above check for state is made and before
22246 * execution gets to the top of sd_uscsi_strategy.
22247 * That would cause problems.
22248 */
22249 un->un_ncmds_in_driver++;
22250
22251 if (!is_valid &&
22252 (flag & (FNDELAY | FNONBLOCK))) {
22253 switch (cmd) {
22254 case DKIOCGGEOM: /* SD_PATH_DIRECT */
22255 case DKIOCGVTOC:
22256 case DKIOCGEXTVTOC:
22257 case DKIOCGAPART:
22258 case DKIOCPARTINFO:
22259 case DKIOCEXTPARTINFO:
22260 case DKIOCSGEOM:
22261 case DKIOCSAPART:
22262 case DKIOCGETEFI:
22263 case DKIOCPARTITION:
22264 case DKIOCSVTOC:
22265 case DKIOCSEXTVTOC:
22266 case DKIOCSETEFI:
22267 case DKIOCGMBOOT:
22268 case DKIOCSMBOOT:
22269 case DKIOCG_PHYGEOM:
22270 case DKIOCG_VIRTGEOM:
22271 #if defined(__i386) || defined(__amd64)
22272 case DKIOCSETEXTPART:
22273 #endif
22274 /* let cmlb handle it */
22275 goto skip_ready_valid;
22276
22277 case CDROMPAUSE:
22278 case CDROMRESUME:
22279 case CDROMPLAYMSF:
22280 case CDROMPLAYTRKIND:
22281 case CDROMREADTOCHDR:
22282 case CDROMREADTOCENTRY:
22283 case CDROMSTOP:
22284 case CDROMSTART:
22285 case CDROMVOLCTRL:
22286 case CDROMSUBCHNL:
22287 case CDROMREADMODE2:
22288 case CDROMREADMODE1:
22289 case CDROMREADOFFSET:
22290 case CDROMSBLKMODE:
22291 case CDROMGBLKMODE:
22292 case CDROMGDRVSPEED:
22293 case CDROMSDRVSPEED:
22294 case CDROMCDDA:
22295 case CDROMCDXA:
22296 case CDROMSUBCODE:
22297 if (!ISCD(un)) {
22298 un->un_ncmds_in_driver--;
22299 ASSERT(un->un_ncmds_in_driver >= 0);
22300 mutex_exit(SD_MUTEX(un));
22301 err = ENOTTY;
22302 goto done_without_assess;
22303 }
22304 break;
22305 case FDEJECT:
22306 case DKIOCEJECT:
22307 case CDROMEJECT:
22308 if (!un->un_f_eject_media_supported) {
22309 un->un_ncmds_in_driver--;
22310 ASSERT(un->un_ncmds_in_driver >= 0);
22311 mutex_exit(SD_MUTEX(un));
22312 err = ENOTTY;
22313 goto done_without_assess;
22314 }
22315 break;
22316 case DKIOCFLUSHWRITECACHE:
22317 mutex_exit(SD_MUTEX(un));
22318 err = sd_send_scsi_TEST_UNIT_READY(ssc, 0);
22319 if (err != 0) {
22320 mutex_enter(SD_MUTEX(un));
22321 un->un_ncmds_in_driver--;
22322 ASSERT(un->un_ncmds_in_driver >= 0);
22323 mutex_exit(SD_MUTEX(un));
22324 err = EIO;
22325 goto done_quick_assess;
22326 }
22327 mutex_enter(SD_MUTEX(un));
22328 /* FALLTHROUGH */
22329 case DKIOCREMOVABLE:
22330 case DKIOCHOTPLUGGABLE:
22331 case DKIOCINFO:
22332 case DKIOCGMEDIAINFO:
22333 case DKIOCGMEDIAINFOEXT:
22334 case DKIOCSOLIDSTATE:
22335 case MHIOCENFAILFAST:
22336 case MHIOCSTATUS:
22337 case MHIOCTKOWN:
22338 case MHIOCRELEASE:
22339 case MHIOCGRP_INKEYS:
22340 case MHIOCGRP_INRESV:
22341 case MHIOCGRP_REGISTER:
22342 case MHIOCGRP_CLEAR:
22343 case MHIOCGRP_RESERVE:
22344 case MHIOCGRP_PREEMPTANDABORT:
22345 case MHIOCGRP_REGISTERANDIGNOREKEY:
22346 case CDROMCLOSETRAY:
22347 case USCSICMD:
22348 goto skip_ready_valid;
22349 default:
22350 break;
22351 }
22352
22353 mutex_exit(SD_MUTEX(un));
22354 err = sd_ready_and_valid(ssc, SDPART(dev));
22355 mutex_enter(SD_MUTEX(un));
22356
22357 if (err != SD_READY_VALID) {
22358 switch (cmd) {
22359 case DKIOCSTATE:
22360 case CDROMGDRVSPEED:
22361 case CDROMSDRVSPEED:
22362 case FDEJECT: /* for eject command */
22363 case DKIOCEJECT:
22364 case CDROMEJECT:
22365 case DKIOCREMOVABLE:
22366 case DKIOCHOTPLUGGABLE:
22367 break;
22368 default:
22369 if (un->un_f_has_removable_media) {
22370 err = ENXIO;
22371 } else {
22372 /* Do not map SD_RESERVED_BY_OTHERS to EIO */
22373 if (err == SD_RESERVED_BY_OTHERS) {
22374 err = EACCES;
22375 } else {
22376 err = EIO;
22377 }
22378 }
22379 un->un_ncmds_in_driver--;
22380 ASSERT(un->un_ncmds_in_driver >= 0);
22381 mutex_exit(SD_MUTEX(un));
22382
22383 goto done_without_assess;
22384 }
22385 }
22386 }
22387
22388 skip_ready_valid:
22389 mutex_exit(SD_MUTEX(un));
22390
22391 switch (cmd) {
22392 case DKIOCINFO:
22393 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCINFO\n");
22394 err = sd_dkio_ctrl_info(dev, (caddr_t)arg, flag);
22395 break;
22396
22397 case DKIOCGMEDIAINFO:
22398 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCGMEDIAINFO\n");
22399 err = sd_get_media_info(dev, (caddr_t)arg, flag);
22400 break;
22401
22402 case DKIOCGMEDIAINFOEXT:
22403 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCGMEDIAINFOEXT\n");
22404 err = sd_get_media_info_ext(dev, (caddr_t)arg, flag);
22405 break;
22406
22407 case DKIOCGGEOM:
22408 case DKIOCGVTOC:
22409 case DKIOCGEXTVTOC:
22410 case DKIOCGAPART:
22411 case DKIOCPARTINFO:
22412 case DKIOCEXTPARTINFO:
22413 case DKIOCSGEOM:
22414 case DKIOCSAPART:
22415 case DKIOCGETEFI:
22416 case DKIOCPARTITION:
22417 case DKIOCSVTOC:
22418 case DKIOCSEXTVTOC:
22419 case DKIOCSETEFI:
22420 case DKIOCGMBOOT:
22421 case DKIOCSMBOOT:
22422 case DKIOCG_PHYGEOM:
22423 case DKIOCG_VIRTGEOM:
22424 #if defined(__i386) || defined(__amd64)
22425 case DKIOCSETEXTPART:
22426 #endif
22427 SD_TRACE(SD_LOG_IOCTL, un, "DKIOC %d\n", cmd);
22428
22429 /* TUR should spin up */
22430
22431 if (un->un_f_has_removable_media)
22432 err = sd_send_scsi_TEST_UNIT_READY(ssc,
22433 SD_CHECK_FOR_MEDIA);
22434
22435 else
22436 err = sd_send_scsi_TEST_UNIT_READY(ssc, 0);
22437
22438 if (err != 0)
22439 goto done_with_assess;
22440
22441 err = cmlb_ioctl(un->un_cmlbhandle, dev,
22442 cmd, arg, flag, cred_p, rval_p, (void *)SD_PATH_DIRECT);
22443
22444 if ((err == 0) &&
22445 ((cmd == DKIOCSETEFI) ||
22446 (un->un_f_pkstats_enabled) &&
22447 (cmd == DKIOCSAPART || cmd == DKIOCSVTOC ||
22448 cmd == DKIOCSEXTVTOC))) {
22449
22450 tmprval = cmlb_validate(un->un_cmlbhandle, CMLB_SILENT,
22451 (void *)SD_PATH_DIRECT);
22452 if ((tmprval == 0) && un->un_f_pkstats_enabled) {
22453 sd_set_pstats(un);
22454 SD_TRACE(SD_LOG_IO_PARTITION, un,
22455 "sd_ioctl: un:0x%p pstats created and "
22456 "set\n", un);
22457 }
22458 }
22459
22460 if ((cmd == DKIOCSVTOC || cmd == DKIOCSEXTVTOC) ||
22461 ((cmd == DKIOCSETEFI) && (tmprval == 0))) {
22462
22463 mutex_enter(SD_MUTEX(un));
22464 if (un->un_f_devid_supported &&
22465 (un->un_f_opt_fab_devid == TRUE)) {
22466 if (un->un_devid == NULL) {
22467 sd_register_devid(ssc, SD_DEVINFO(un),
22468 SD_TARGET_IS_UNRESERVED);
22469 } else {
22470 /*
22471 * The device id for this disk
22472 * has been fabricated. The
22473 * device id must be preserved
22474 * by writing it back out to
22475 * disk.
22476 */
22477 if (sd_write_deviceid(ssc) != 0) {
22478 ddi_devid_free(un->un_devid);
22479 un->un_devid = NULL;
22480 }
22481 }
22482 }
22483 mutex_exit(SD_MUTEX(un));
22484 }
22485
22486 break;
22487
22488 case DKIOCLOCK:
22489 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCLOCK\n");
22490 err = sd_send_scsi_DOORLOCK(ssc, SD_REMOVAL_PREVENT,
22491 SD_PATH_STANDARD);
22492 goto done_with_assess;
22493
22494 case DKIOCUNLOCK:
22495 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCUNLOCK\n");
22496 err = sd_send_scsi_DOORLOCK(ssc, SD_REMOVAL_ALLOW,
22497 SD_PATH_STANDARD);
22498 goto done_with_assess;
22499
22500 case DKIOCSTATE: {
22501 enum dkio_state state;
22502 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCSTATE\n");
22503
22504 if (ddi_copyin((void *)arg, &state, sizeof (int), flag) != 0) {
22505 err = EFAULT;
22506 } else {
22507 err = sd_check_media(dev, state);
22508 if (err == 0) {
22509 if (ddi_copyout(&un->un_mediastate, (void *)arg,
22510 sizeof (int), flag) != 0)
22511 err = EFAULT;
22512 }
22513 }
22514 break;
22515 }
22516
22517 case DKIOCREMOVABLE:
22518 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCREMOVABLE\n");
22519 i = un->un_f_has_removable_media ? 1 : 0;
22520 if (ddi_copyout(&i, (void *)arg, sizeof (int), flag) != 0) {
22521 err = EFAULT;
22522 } else {
22523 err = 0;
22524 }
22525 break;
22526
22527 case DKIOCSOLIDSTATE:
22528 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCSOLIDSTATE\n");
22529 i = un->un_f_is_solid_state ? 1 : 0;
22530 if (ddi_copyout(&i, (void *)arg, sizeof (int), flag) != 0) {
22531 err = EFAULT;
22532 } else {
22533 err = 0;
22534 }
22535 break;
22536
22537 case DKIOCHOTPLUGGABLE:
22538 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCHOTPLUGGABLE\n");
22539 i = un->un_f_is_hotpluggable ? 1 : 0;
22540 if (ddi_copyout(&i, (void *)arg, sizeof (int), flag) != 0) {
22541 err = EFAULT;
22542 } else {
22543 err = 0;
22544 }
22545 break;
22546
22547 case DKIOCREADONLY:
22548 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCREADONLY\n");
22549 i = 0;
22550 if ((ISCD(un) && !un->un_f_mmc_writable_media) ||
22551 (sr_check_wp(dev) != 0)) {
22552 i = 1;
22553 }
22554 if (ddi_copyout(&i, (void *)arg, sizeof (int), flag) != 0) {
22555 err = EFAULT;
22556 } else {
22557 err = 0;
22558 }
22559 break;
22560
22561 case DKIOCGTEMPERATURE:
22562 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCGTEMPERATURE\n");
22563 err = sd_dkio_get_temp(dev, (caddr_t)arg, flag);
22564 break;
22565
22566 case MHIOCENFAILFAST:
22567 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCENFAILFAST\n");
22568 if ((err = drv_priv(cred_p)) == 0) {
22569 err = sd_mhdioc_failfast(dev, (caddr_t)arg, flag);
22570 }
22571 break;
22572
22573 case MHIOCTKOWN:
22574 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCTKOWN\n");
22575 if ((err = drv_priv(cred_p)) == 0) {
22576 err = sd_mhdioc_takeown(dev, (caddr_t)arg, flag);
22577 }
22578 break;
22579
22580 case MHIOCRELEASE:
22581 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCRELEASE\n");
22582 if ((err = drv_priv(cred_p)) == 0) {
22583 err = sd_mhdioc_release(dev);
22584 }
22585 break;
22586
22587 case MHIOCSTATUS:
22588 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCSTATUS\n");
22589 if ((err = drv_priv(cred_p)) == 0) {
22590 switch (sd_send_scsi_TEST_UNIT_READY(ssc, 0)) {
22591 case 0:
22592 err = 0;
22593 break;
22594 case EACCES:
22595 *rval_p = 1;
22596 err = 0;
22597 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
22598 break;
22599 default:
22600 err = EIO;
22601 goto done_with_assess;
22602 }
22603 }
22604 break;
22605
22606 case MHIOCQRESERVE:
22607 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCQRESERVE\n");
22608 if ((err = drv_priv(cred_p)) == 0) {
22609 err = sd_reserve_release(dev, SD_RESERVE);
22610 }
22611 break;
22612
22613 case MHIOCREREGISTERDEVID:
22614 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCREREGISTERDEVID\n");
22615 if (drv_priv(cred_p) == EPERM) {
22616 err = EPERM;
22617 } else if (!un->un_f_devid_supported) {
22618 err = ENOTTY;
22619 } else {
22620 err = sd_mhdioc_register_devid(dev);
22621 }
22622 break;
22623
22624 case MHIOCGRP_INKEYS:
22625 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCGRP_INKEYS\n");
22626 if (((err = drv_priv(cred_p)) != EPERM) && arg != NULL) {
22627 if (un->un_reservation_type == SD_SCSI2_RESERVATION) {
22628 err = ENOTSUP;
22629 } else {
22630 err = sd_mhdioc_inkeys(dev, (caddr_t)arg,
22631 flag);
22632 }
22633 }
22634 break;
22635
22636 case MHIOCGRP_INRESV:
22637 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCGRP_INRESV\n");
22638 if (((err = drv_priv(cred_p)) != EPERM) && arg != NULL) {
22639 if (un->un_reservation_type == SD_SCSI2_RESERVATION) {
22640 err = ENOTSUP;
22641 } else {
22642 err = sd_mhdioc_inresv(dev, (caddr_t)arg, flag);
22643 }
22644 }
22645 break;
22646
22647 case MHIOCGRP_REGISTER:
22648 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCGRP_REGISTER\n");
22649 if ((err = drv_priv(cred_p)) != EPERM) {
22650 if (un->un_reservation_type == SD_SCSI2_RESERVATION) {
22651 err = ENOTSUP;
22652 } else if (arg != NULL) {
22653 mhioc_register_t reg;
22654 if (ddi_copyin((void *)arg, ®,
22655 sizeof (mhioc_register_t), flag) != 0) {
22656 err = EFAULT;
22657 } else {
22658 err =
22659 sd_send_scsi_PERSISTENT_RESERVE_OUT(
22660 ssc, SD_SCSI3_REGISTER,
22661 (uchar_t *)®);
22662 if (err != 0)
22663 goto done_with_assess;
22664 }
22665 }
22666 }
22667 break;
22668
22669 case MHIOCGRP_CLEAR:
22670 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCGRP_CLEAR\n");
22671 if ((err = drv_priv(cred_p)) != EPERM) {
22672 if (un->un_reservation_type == SD_SCSI2_RESERVATION) {
22673 err = ENOTSUP;
22674 } else if (arg != NULL) {
22675 mhioc_register_t reg;
22676 if (ddi_copyin((void *)arg, ®,
22677 sizeof (mhioc_register_t), flag) != 0) {
22678 err = EFAULT;
22679 } else {
22680 err =
22681 sd_send_scsi_PERSISTENT_RESERVE_OUT(
22682 ssc, SD_SCSI3_CLEAR,
22683 (uchar_t *)®);
22684 if (err != 0)
22685 goto done_with_assess;
22686 }
22687 }
22688 }
22689 break;
22690
22691 case MHIOCGRP_RESERVE:
22692 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCGRP_RESERVE\n");
22693 if ((err = drv_priv(cred_p)) != EPERM) {
22694 if (un->un_reservation_type == SD_SCSI2_RESERVATION) {
22695 err = ENOTSUP;
22696 } else if (arg != NULL) {
22697 mhioc_resv_desc_t resv_desc;
22698 if (ddi_copyin((void *)arg, &resv_desc,
22699 sizeof (mhioc_resv_desc_t), flag) != 0) {
22700 err = EFAULT;
22701 } else {
22702 err =
22703 sd_send_scsi_PERSISTENT_RESERVE_OUT(
22704 ssc, SD_SCSI3_RESERVE,
22705 (uchar_t *)&resv_desc);
22706 if (err != 0)
22707 goto done_with_assess;
22708 }
22709 }
22710 }
22711 break;
22712
22713 case MHIOCGRP_PREEMPTANDABORT:
22714 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCGRP_PREEMPTANDABORT\n");
22715 if ((err = drv_priv(cred_p)) != EPERM) {
22716 if (un->un_reservation_type == SD_SCSI2_RESERVATION) {
22717 err = ENOTSUP;
22718 } else if (arg != NULL) {
22719 mhioc_preemptandabort_t preempt_abort;
22720 if (ddi_copyin((void *)arg, &preempt_abort,
22721 sizeof (mhioc_preemptandabort_t),
22722 flag) != 0) {
22723 err = EFAULT;
22724 } else {
22725 err =
22726 sd_send_scsi_PERSISTENT_RESERVE_OUT(
22727 ssc, SD_SCSI3_PREEMPTANDABORT,
22728 (uchar_t *)&preempt_abort);
22729 if (err != 0)
22730 goto done_with_assess;
22731 }
22732 }
22733 }
22734 break;
22735
22736 case MHIOCGRP_REGISTERANDIGNOREKEY:
22737 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCGRP_REGISTERANDIGNOREKEY\n");
22738 if ((err = drv_priv(cred_p)) != EPERM) {
22739 if (un->un_reservation_type == SD_SCSI2_RESERVATION) {
22740 err = ENOTSUP;
22741 } else if (arg != NULL) {
22742 mhioc_registerandignorekey_t r_and_i;
22743 if (ddi_copyin((void *)arg, (void *)&r_and_i,
22744 sizeof (mhioc_registerandignorekey_t),
22745 flag) != 0) {
22746 err = EFAULT;
22747 } else {
22748 err =
22749 sd_send_scsi_PERSISTENT_RESERVE_OUT(
22750 ssc, SD_SCSI3_REGISTERANDIGNOREKEY,
22751 (uchar_t *)&r_and_i);
22752 if (err != 0)
22753 goto done_with_assess;
22754 }
22755 }
22756 }
22757 break;
22758
22759 case USCSICMD:
22760 SD_TRACE(SD_LOG_IOCTL, un, "USCSICMD\n");
22761 cr = ddi_get_cred();
22762 if ((drv_priv(cred_p) != 0) && (drv_priv(cr) != 0)) {
22763 err = EPERM;
22764 } else {
22765 enum uio_seg uioseg;
22766
22767 uioseg = (flag & FKIOCTL) ? UIO_SYSSPACE :
22768 UIO_USERSPACE;
22769 if (un->un_f_format_in_progress == TRUE) {
22770 err = EAGAIN;
22771 break;
22772 }
22773
22774 err = sd_ssc_send(ssc,
22775 (struct uscsi_cmd *)arg,
22776 flag, uioseg, SD_PATH_STANDARD);
22777 if (err != 0)
22778 goto done_with_assess;
22779 else
22780 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
22781 }
22782 break;
22783
22784 case CDROMPAUSE:
22785 case CDROMRESUME:
22786 SD_TRACE(SD_LOG_IOCTL, un, "PAUSE-RESUME\n");
22787 if (!ISCD(un)) {
22788 err = ENOTTY;
22789 } else {
22790 err = sr_pause_resume(dev, cmd);
22791 }
22792 break;
22793
22794 case CDROMPLAYMSF:
22795 SD_TRACE(SD_LOG_IOCTL, un, "CDROMPLAYMSF\n");
22796 if (!ISCD(un)) {
22797 err = ENOTTY;
22798 } else {
22799 err = sr_play_msf(dev, (caddr_t)arg, flag);
22800 }
22801 break;
22802
22803 case CDROMPLAYTRKIND:
22804 SD_TRACE(SD_LOG_IOCTL, un, "CDROMPLAYTRKIND\n");
22805 #if defined(__i386) || defined(__amd64)
22806 /*
22807 * not supported on ATAPI CD drives, use CDROMPLAYMSF instead
22808 */
22809 if (!ISCD(un) || (un->un_f_cfg_is_atapi == TRUE)) {
22810 #else
22811 if (!ISCD(un)) {
22812 #endif
22813 err = ENOTTY;
22814 } else {
22815 err = sr_play_trkind(dev, (caddr_t)arg, flag);
22816 }
22817 break;
22818
22819 case CDROMREADTOCHDR:
22820 SD_TRACE(SD_LOG_IOCTL, un, "CDROMREADTOCHDR\n");
22821 if (!ISCD(un)) {
22822 err = ENOTTY;
22823 } else {
22824 err = sr_read_tochdr(dev, (caddr_t)arg, flag);
22825 }
22826 break;
22827
22828 case CDROMREADTOCENTRY:
22829 SD_TRACE(SD_LOG_IOCTL, un, "CDROMREADTOCENTRY\n");
22830 if (!ISCD(un)) {
22831 err = ENOTTY;
22832 } else {
22833 err = sr_read_tocentry(dev, (caddr_t)arg, flag);
22834 }
22835 break;
22836
22837 case CDROMSTOP:
22838 SD_TRACE(SD_LOG_IOCTL, un, "CDROMSTOP\n");
22839 if (!ISCD(un)) {
22840 err = ENOTTY;
22841 } else {
22842 err = sd_send_scsi_START_STOP_UNIT(ssc, SD_START_STOP,
22843 SD_TARGET_STOP, SD_PATH_STANDARD);
22844 goto done_with_assess;
22845 }
22846 break;
22847
22848 case CDROMSTART:
22849 SD_TRACE(SD_LOG_IOCTL, un, "CDROMSTART\n");
22850 if (!ISCD(un)) {
22851 err = ENOTTY;
22852 } else {
22853 err = sd_send_scsi_START_STOP_UNIT(ssc, SD_START_STOP,
22854 SD_TARGET_START, SD_PATH_STANDARD);
22855 goto done_with_assess;
22856 }
22857 break;
22858
22859 case CDROMCLOSETRAY:
22860 SD_TRACE(SD_LOG_IOCTL, un, "CDROMCLOSETRAY\n");
22861 if (!ISCD(un)) {
22862 err = ENOTTY;
22863 } else {
22864 err = sd_send_scsi_START_STOP_UNIT(ssc, SD_START_STOP,
22865 SD_TARGET_CLOSE, SD_PATH_STANDARD);
22866 goto done_with_assess;
22867 }
22868 break;
22869
22870 case FDEJECT: /* for eject command */
22871 case DKIOCEJECT:
22872 case CDROMEJECT:
22873 SD_TRACE(SD_LOG_IOCTL, un, "EJECT\n");
22874 if (!un->un_f_eject_media_supported) {
22875 err = ENOTTY;
22876 } else {
22877 err = sr_eject(dev);
22878 }
22879 break;
22880
22881 case CDROMVOLCTRL:
22882 SD_TRACE(SD_LOG_IOCTL, un, "CDROMVOLCTRL\n");
22883 if (!ISCD(un)) {
22884 err = ENOTTY;
22885 } else {
22886 err = sr_volume_ctrl(dev, (caddr_t)arg, flag);
22887 }
22888 break;
22889
22890 case CDROMSUBCHNL:
22891 SD_TRACE(SD_LOG_IOCTL, un, "CDROMSUBCHNL\n");
22892 if (!ISCD(un)) {
22893 err = ENOTTY;
22894 } else {
22895 err = sr_read_subchannel(dev, (caddr_t)arg, flag);
22896 }
22897 break;
22898
22899 case CDROMREADMODE2:
22900 SD_TRACE(SD_LOG_IOCTL, un, "CDROMREADMODE2\n");
22901 if (!ISCD(un)) {
22902 err = ENOTTY;
22903 } else if (un->un_f_cfg_is_atapi == TRUE) {
22904 /*
22905 * If the drive supports READ CD, use that instead of
22906 * switching the LBA size via a MODE SELECT
22907 * Block Descriptor
22908 */
22909 err = sr_read_cd_mode2(dev, (caddr_t)arg, flag);
22910 } else {
22911 err = sr_read_mode2(dev, (caddr_t)arg, flag);
22912 }
22913 break;
22914
22915 case CDROMREADMODE1:
22916 SD_TRACE(SD_LOG_IOCTL, un, "CDROMREADMODE1\n");
22917 if (!ISCD(un)) {
22918 err = ENOTTY;
22919 } else {
22920 err = sr_read_mode1(dev, (caddr_t)arg, flag);
22921 }
22922 break;
22923
22924 case CDROMREADOFFSET:
22925 SD_TRACE(SD_LOG_IOCTL, un, "CDROMREADOFFSET\n");
22926 if (!ISCD(un)) {
22927 err = ENOTTY;
22928 } else {
22929 err = sr_read_sony_session_offset(dev, (caddr_t)arg,
22930 flag);
22931 }
22932 break;
22933
22934 case CDROMSBLKMODE:
22935 SD_TRACE(SD_LOG_IOCTL, un, "CDROMSBLKMODE\n");
22936 /*
22937 * There is no means of changing block size in case of atapi
22938 * drives, thus return ENOTTY if drive type is atapi
22939 */
22940 if (!ISCD(un) || (un->un_f_cfg_is_atapi == TRUE)) {
22941 err = ENOTTY;
22942 } else if (un->un_f_mmc_cap == TRUE) {
22943
22944 /*
22945 * MMC Devices do not support changing the
22946 * logical block size
22947 *
22948 * Note: EINVAL is being returned instead of ENOTTY to
22949 * maintain consistancy with the original mmc
22950 * driver update.
22951 */
22952 err = EINVAL;
22953 } else {
22954 mutex_enter(SD_MUTEX(un));
22955 if ((!(un->un_exclopen & (1<<SDPART(dev)))) ||
22956 (un->un_ncmds_in_transport > 0)) {
22957 mutex_exit(SD_MUTEX(un));
22958 err = EINVAL;
22959 } else {
22960 mutex_exit(SD_MUTEX(un));
22961 err = sr_change_blkmode(dev, cmd, arg, flag);
22962 }
22963 }
22964 break;
22965
22966 case CDROMGBLKMODE:
22967 SD_TRACE(SD_LOG_IOCTL, un, "CDROMGBLKMODE\n");
22968 if (!ISCD(un)) {
22969 err = ENOTTY;
22970 } else if ((un->un_f_cfg_is_atapi != FALSE) &&
22971 (un->un_f_blockcount_is_valid != FALSE)) {
22972 /*
22973 * Drive is an ATAPI drive so return target block
22974 * size for ATAPI drives since we cannot change the
22975 * blocksize on ATAPI drives. Used primarily to detect
22976 * if an ATAPI cdrom is present.
22977 */
22978 if (ddi_copyout(&un->un_tgt_blocksize, (void *)arg,
22979 sizeof (int), flag) != 0) {
22980 err = EFAULT;
22981 } else {
22982 err = 0;
22983 }
22984
22985 } else {
22986 /*
22987 * Drive supports changing block sizes via a Mode
22988 * Select.
22989 */
22990 err = sr_change_blkmode(dev, cmd, arg, flag);
22991 }
22992 break;
22993
22994 case CDROMGDRVSPEED:
22995 case CDROMSDRVSPEED:
22996 SD_TRACE(SD_LOG_IOCTL, un, "CDROMXDRVSPEED\n");
22997 if (!ISCD(un)) {
22998 err = ENOTTY;
22999 } else if (un->un_f_mmc_cap == TRUE) {
23000 /*
23001 * Note: In the future the driver implementation
23002 * for getting and
23003 * setting cd speed should entail:
23004 * 1) If non-mmc try the Toshiba mode page
23005 * (sr_change_speed)
23006 * 2) If mmc but no support for Real Time Streaming try
23007 * the SET CD SPEED (0xBB) command
23008 * (sr_atapi_change_speed)
23009 * 3) If mmc and support for Real Time Streaming
23010 * try the GET PERFORMANCE and SET STREAMING
23011 * commands (not yet implemented, 4380808)
23012 */
23013 /*
23014 * As per recent MMC spec, CD-ROM speed is variable
23015 * and changes with LBA. Since there is no such
23016 * things as drive speed now, fail this ioctl.
23017 *
23018 * Note: EINVAL is returned for consistancy of original
23019 * implementation which included support for getting
23020 * the drive speed of mmc devices but not setting
23021 * the drive speed. Thus EINVAL would be returned
23022 * if a set request was made for an mmc device.
23023 * We no longer support get or set speed for
23024 * mmc but need to remain consistent with regard
23025 * to the error code returned.
23026 */
23027 err = EINVAL;
23028 } else if (un->un_f_cfg_is_atapi == TRUE) {
23029 err = sr_atapi_change_speed(dev, cmd, arg, flag);
23030 } else {
23031 err = sr_change_speed(dev, cmd, arg, flag);
23032 }
23033 break;
23034
23035 case CDROMCDDA:
23036 SD_TRACE(SD_LOG_IOCTL, un, "CDROMCDDA\n");
23037 if (!ISCD(un)) {
23038 err = ENOTTY;
23039 } else {
23040 err = sr_read_cdda(dev, (void *)arg, flag);
23041 }
23042 break;
23043
23044 case CDROMCDXA:
23045 SD_TRACE(SD_LOG_IOCTL, un, "CDROMCDXA\n");
23046 if (!ISCD(un)) {
23047 err = ENOTTY;
23048 } else {
23049 err = sr_read_cdxa(dev, (caddr_t)arg, flag);
23050 }
23051 break;
23052
23053 case CDROMSUBCODE:
23054 SD_TRACE(SD_LOG_IOCTL, un, "CDROMSUBCODE\n");
23055 if (!ISCD(un)) {
23056 err = ENOTTY;
23057 } else {
23058 err = sr_read_all_subcodes(dev, (caddr_t)arg, flag);
23059 }
23060 break;
23061
23062
23063 #ifdef SDDEBUG
23064 /* RESET/ABORTS testing ioctls */
23065 case DKIOCRESET: {
23066 int reset_level;
23067
23068 if (ddi_copyin((void *)arg, &reset_level, sizeof (int), flag)) {
23069 err = EFAULT;
23070 } else {
23071 SD_INFO(SD_LOG_IOCTL, un, "sdioctl: DKIOCRESET: "
23072 "reset_level = 0x%lx\n", reset_level);
23073 if (scsi_reset(SD_ADDRESS(un), reset_level)) {
23074 err = 0;
23075 } else {
23076 err = EIO;
23077 }
23078 }
23079 break;
23080 }
23081
23082 case DKIOCABORT:
23083 SD_INFO(SD_LOG_IOCTL, un, "sdioctl: DKIOCABORT:\n");
23084 if (scsi_abort(SD_ADDRESS(un), NULL)) {
23085 err = 0;
23086 } else {
23087 err = EIO;
23088 }
23089 break;
23090 #endif
23091
23092 #ifdef SD_FAULT_INJECTION
23093 /* SDIOC FaultInjection testing ioctls */
23094 case SDIOCSTART:
23095 case SDIOCSTOP:
23096 case SDIOCINSERTPKT:
23097 case SDIOCINSERTXB:
23098 case SDIOCINSERTUN:
23099 case SDIOCINSERTARQ:
23100 case SDIOCPUSH:
23101 case SDIOCRETRIEVE:
23102 case SDIOCRUN:
23103 SD_INFO(SD_LOG_SDTEST, un, "sdioctl:"
23104 "SDIOC detected cmd:0x%X:\n", cmd);
23105 /* call error generator */
23106 sd_faultinjection_ioctl(cmd, arg, un);
23107 err = 0;
23108 break;
23109
23110 #endif /* SD_FAULT_INJECTION */
23111
23112 case DKIOCFLUSHWRITECACHE:
23113 {
23114 struct dk_callback *dkc = (struct dk_callback *)arg;
23115
23116 mutex_enter(SD_MUTEX(un));
23117 if (!un->un_f_sync_cache_supported ||
23118 !un->un_f_write_cache_enabled) {
23119 err = un->un_f_sync_cache_supported ?
23120 0 : ENOTSUP;
23121 mutex_exit(SD_MUTEX(un));
23122 if ((flag & FKIOCTL) && dkc != NULL &&
23123 dkc->dkc_callback != NULL) {
23124 (*dkc->dkc_callback)(dkc->dkc_cookie,
23125 err);
23126 /*
23127 * Did callback and reported error.
23128 * Since we did a callback, ioctl
23129 * should return 0.
23130 */
23131 err = 0;
23132 }
23133 break;
23134 }
23135 mutex_exit(SD_MUTEX(un));
23136
23137 if ((flag & FKIOCTL) && dkc != NULL &&
23138 dkc->dkc_callback != NULL) {
23139 /* async SYNC CACHE request */
23140 err = sd_send_scsi_SYNCHRONIZE_CACHE(un, dkc);
23141 } else {
23142 /* synchronous SYNC CACHE request */
23143 err = sd_send_scsi_SYNCHRONIZE_CACHE(un, NULL);
23144 }
23145 }
23146 break;
23147
23148 case DKIOCGETWCE: {
23149
23150 int wce;
23151
23152 if ((err = sd_get_write_cache_enabled(ssc, &wce)) != 0) {
23153 break;
23154 }
23155
23156 if (ddi_copyout(&wce, (void *)arg, sizeof (wce), flag)) {
23157 err = EFAULT;
23158 }
23159 break;
23160 }
23161
23162 case DKIOCSETWCE: {
23163
23164 int wce, sync_supported;
23165 int cur_wce = 0;
23166
23167 if (ddi_copyin((void *)arg, &wce, sizeof (wce), flag)) {
23168 err = EFAULT;
23169 break;
23170 }
23171
23172 /*
23173 * Synchronize multiple threads trying to enable
23174 * or disable the cache via the un_f_wcc_cv
23175 * condition variable.
23176 */
23177 mutex_enter(SD_MUTEX(un));
23178
23179 /*
23180 * Don't allow the cache to be enabled if the
23181 * config file has it disabled.
23182 */
23183 if (un->un_f_opt_disable_cache && wce) {
23184 mutex_exit(SD_MUTEX(un));
23185 err = EINVAL;
23186 break;
23187 }
23188
23189 /*
23190 * Wait for write cache change in progress
23191 * bit to be clear before proceeding.
23192 */
23193 while (un->un_f_wcc_inprog)
23194 cv_wait(&un->un_wcc_cv, SD_MUTEX(un));
23195
23196 un->un_f_wcc_inprog = 1;
23197
23198 mutex_exit(SD_MUTEX(un));
23199
23200 /*
23201 * Get the current write cache state
23202 */
23203 if ((err = sd_get_write_cache_enabled(ssc, &cur_wce)) != 0) {
23204 mutex_enter(SD_MUTEX(un));
23205 un->un_f_wcc_inprog = 0;
23206 cv_broadcast(&un->un_wcc_cv);
23207 mutex_exit(SD_MUTEX(un));
23208 break;
23209 }
23210
23211 mutex_enter(SD_MUTEX(un));
23212 un->un_f_write_cache_enabled = (cur_wce != 0);
23213
23214 if (un->un_f_write_cache_enabled && wce == 0) {
23215 /*
23216 * Disable the write cache. Don't clear
23217 * un_f_write_cache_enabled until after
23218 * the mode select and flush are complete.
23219 */
23220 sync_supported = un->un_f_sync_cache_supported;
23221
23222 /*
23223 * If cache flush is suppressed, we assume that the
23224 * controller firmware will take care of managing the
23225 * write cache for us: no need to explicitly
23226 * disable it.
23227 */
23228 if (!un->un_f_suppress_cache_flush) {
23229 mutex_exit(SD_MUTEX(un));
23230 if ((err = sd_cache_control(ssc,
23231 SD_CACHE_NOCHANGE,
23232 SD_CACHE_DISABLE)) == 0 &&
23233 sync_supported) {
23234 err = sd_send_scsi_SYNCHRONIZE_CACHE(un,
23235 NULL);
23236 }
23237 } else {
23238 mutex_exit(SD_MUTEX(un));
23239 }
23240
23241 mutex_enter(SD_MUTEX(un));
23242 if (err == 0) {
23243 un->un_f_write_cache_enabled = 0;
23244 }
23245
23246 } else if (!un->un_f_write_cache_enabled && wce != 0) {
23247 /*
23248 * Set un_f_write_cache_enabled first, so there is
23249 * no window where the cache is enabled, but the
23250 * bit says it isn't.
23251 */
23252 un->un_f_write_cache_enabled = 1;
23253
23254 /*
23255 * If cache flush is suppressed, we assume that the
23256 * controller firmware will take care of managing the
23257 * write cache for us: no need to explicitly
23258 * enable it.
23259 */
23260 if (!un->un_f_suppress_cache_flush) {
23261 mutex_exit(SD_MUTEX(un));
23262 err = sd_cache_control(ssc, SD_CACHE_NOCHANGE,
23263 SD_CACHE_ENABLE);
23264 } else {
23265 mutex_exit(SD_MUTEX(un));
23266 }
23267
23268 mutex_enter(SD_MUTEX(un));
23269
23270 if (err) {
23271 un->un_f_write_cache_enabled = 0;
23272 }
23273 }
23274
23275 un->un_f_wcc_inprog = 0;
23276 cv_broadcast(&un->un_wcc_cv);
23277 mutex_exit(SD_MUTEX(un));
23278 break;
23279 }
23280
23281 default:
23282 err = ENOTTY;
23283 break;
23284 }
23285 mutex_enter(SD_MUTEX(un));
23286 un->un_ncmds_in_driver--;
23287 ASSERT(un->un_ncmds_in_driver >= 0);
23288 mutex_exit(SD_MUTEX(un));
23289
23290
23291 done_without_assess:
23292 sd_ssc_fini(ssc);
23293
23294 SD_TRACE(SD_LOG_IOCTL, un, "sdioctl: exit: %d\n", err);
23295 return (err);
23296
23297 done_with_assess:
23298 mutex_enter(SD_MUTEX(un));
23299 un->un_ncmds_in_driver--;
23300 ASSERT(un->un_ncmds_in_driver >= 0);
23301 mutex_exit(SD_MUTEX(un));
23302
23303 done_quick_assess:
23304 if (err != 0)
23305 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
23306 /* Uninitialize sd_ssc_t pointer */
23307 sd_ssc_fini(ssc);
23308
23309 SD_TRACE(SD_LOG_IOCTL, un, "sdioctl: exit: %d\n", err);
23310 return (err);
23311 }
23312
23313
23314 /*
23315 * Function: sd_dkio_ctrl_info
23316 *
23317 * Description: This routine is the driver entry point for handling controller
23318 * information ioctl requests (DKIOCINFO).
23319 *
23320 * Arguments: dev - the device number
23321 * arg - pointer to user provided dk_cinfo structure
23322 * specifying the controller type and attributes.
23323 * flag - this argument is a pass through to ddi_copyxxx()
23324 * directly from the mode argument of ioctl().
23325 *
23326 * Return Code: 0
23327 * EFAULT
23328 * ENXIO
23329 */
23330
23331 static int
23332 sd_dkio_ctrl_info(dev_t dev, caddr_t arg, int flag)
23333 {
23334 struct sd_lun *un = NULL;
23335 struct dk_cinfo *info;
23336 dev_info_t *pdip;
23337 int lun, tgt;
23338
23339 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
23340 return (ENXIO);
23341 }
23342
23343 info = (struct dk_cinfo *)
23344 kmem_zalloc(sizeof (struct dk_cinfo), KM_SLEEP);
23345
23346 switch (un->un_ctype) {
23347 case CTYPE_CDROM:
23348 info->dki_ctype = DKC_CDROM;
23349 break;
23350 default:
23351 info->dki_ctype = DKC_SCSI_CCS;
23352 break;
23353 }
23354 pdip = ddi_get_parent(SD_DEVINFO(un));
23355 info->dki_cnum = ddi_get_instance(pdip);
23356 if (strlen(ddi_get_name(pdip)) < DK_DEVLEN) {
23357 (void) strcpy(info->dki_cname, ddi_get_name(pdip));
23358 } else {
23359 (void) strncpy(info->dki_cname, ddi_node_name(pdip),
23360 DK_DEVLEN - 1);
23361 }
23362
23363 lun = ddi_prop_get_int(DDI_DEV_T_ANY, SD_DEVINFO(un),
23364 DDI_PROP_DONTPASS, SCSI_ADDR_PROP_LUN, 0);
23365 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, SD_DEVINFO(un),
23366 DDI_PROP_DONTPASS, SCSI_ADDR_PROP_TARGET, 0);
23367
23368 /* Unit Information */
23369 info->dki_unit = ddi_get_instance(SD_DEVINFO(un));
23370 info->dki_slave = ((tgt << 3) | lun);
23371 (void) strncpy(info->dki_dname, ddi_driver_name(SD_DEVINFO(un)),
23372 DK_DEVLEN - 1);
23373 info->dki_flags = DKI_FMTVOL;
23374 info->dki_partition = SDPART(dev);
23375
23376 /* Max Transfer size of this device in blocks */
23377 info->dki_maxtransfer = un->un_max_xfer_size / un->un_sys_blocksize;
23378 info->dki_addr = 0;
23379 info->dki_space = 0;
23380 info->dki_prio = 0;
23381 info->dki_vec = 0;
23382
23383 if (ddi_copyout(info, arg, sizeof (struct dk_cinfo), flag) != 0) {
23384 kmem_free(info, sizeof (struct dk_cinfo));
23385 return (EFAULT);
23386 } else {
23387 kmem_free(info, sizeof (struct dk_cinfo));
23388 return (0);
23389 }
23390 }
23391
23392 /*
23393 * Function: sd_get_media_info_com
23394 *
23395 * Description: This routine returns the information required to populate
23396 * the fields for the dk_minfo/dk_minfo_ext structures.
23397 *
23398 * Arguments: dev - the device number
23399 * dki_media_type - media_type
23400 * dki_lbsize - logical block size
23401 * dki_capacity - capacity in blocks
23402 * dki_pbsize - physical block size (if requested)
23403 *
23404 * Return Code: 0
23405 * EACCESS
23406 * EFAULT
23407 * ENXIO
23408 * EIO
23409 */
23410 static int
23411 sd_get_media_info_com(dev_t dev, uint_t *dki_media_type, uint_t *dki_lbsize,
23412 diskaddr_t *dki_capacity, uint_t *dki_pbsize)
23413 {
23414 struct sd_lun *un = NULL;
23415 struct uscsi_cmd com;
23416 struct scsi_inquiry *sinq;
23417 u_longlong_t media_capacity;
23418 uint64_t capacity;
23419 uint_t lbasize;
23420 uint_t pbsize;
23421 uchar_t *out_data;
23422 uchar_t *rqbuf;
23423 int rval = 0;
23424 int rtn;
23425 sd_ssc_t *ssc;
23426
23427 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
23428 (un->un_state == SD_STATE_OFFLINE)) {
23429 return (ENXIO);
23430 }
23431
23432 SD_TRACE(SD_LOG_IOCTL_DKIO, un, "sd_get_media_info_com: entry\n");
23433
23434 out_data = kmem_zalloc(SD_PROFILE_HEADER_LEN, KM_SLEEP);
23435 rqbuf = kmem_zalloc(SENSE_LENGTH, KM_SLEEP);
23436 ssc = sd_ssc_init(un);
23437
23438 /* Issue a TUR to determine if the drive is ready with media present */
23439 rval = sd_send_scsi_TEST_UNIT_READY(ssc, SD_CHECK_FOR_MEDIA);
23440 if (rval == ENXIO) {
23441 goto done;
23442 } else if (rval != 0) {
23443 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
23444 }
23445
23446 /* Now get configuration data */
23447 if (ISCD(un)) {
23448 *dki_media_type = DK_CDROM;
23449
23450 /* Allow SCMD_GET_CONFIGURATION to MMC devices only */
23451 if (un->un_f_mmc_cap == TRUE) {
23452 rtn = sd_send_scsi_GET_CONFIGURATION(ssc, &com, rqbuf,
23453 SENSE_LENGTH, out_data, SD_PROFILE_HEADER_LEN,
23454 SD_PATH_STANDARD);
23455
23456 if (rtn) {
23457 /*
23458 * We ignore all failures for CD and need to
23459 * put the assessment before processing code
23460 * to avoid missing assessment for FMA.
23461 */
23462 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
23463 /*
23464 * Failed for other than an illegal request
23465 * or command not supported
23466 */
23467 if ((com.uscsi_status == STATUS_CHECK) &&
23468 (com.uscsi_rqstatus == STATUS_GOOD)) {
23469 if ((rqbuf[2] != KEY_ILLEGAL_REQUEST) ||
23470 (rqbuf[12] != 0x20)) {
23471 rval = EIO;
23472 goto no_assessment;
23473 }
23474 }
23475 } else {
23476 /*
23477 * The GET CONFIGURATION command succeeded
23478 * so set the media type according to the
23479 * returned data
23480 */
23481 *dki_media_type = out_data[6];
23482 *dki_media_type <<= 8;
23483 *dki_media_type |= out_data[7];
23484 }
23485 }
23486 } else {
23487 /*
23488 * The profile list is not available, so we attempt to identify
23489 * the media type based on the inquiry data
23490 */
23491 sinq = un->un_sd->sd_inq;
23492 if ((sinq->inq_dtype == DTYPE_DIRECT) ||
23493 (sinq->inq_dtype == DTYPE_OPTICAL)) {
23494 /* This is a direct access device or optical disk */
23495 *dki_media_type = DK_FIXED_DISK;
23496
23497 if ((bcmp(sinq->inq_vid, "IOMEGA", 6) == 0) ||
23498 (bcmp(sinq->inq_vid, "iomega", 6) == 0)) {
23499 if ((bcmp(sinq->inq_pid, "ZIP", 3) == 0)) {
23500 *dki_media_type = DK_ZIP;
23501 } else if (
23502 (bcmp(sinq->inq_pid, "jaz", 3) == 0)) {
23503 *dki_media_type = DK_JAZ;
23504 }
23505 }
23506 } else {
23507 /*
23508 * Not a CD, direct access or optical disk so return
23509 * unknown media
23510 */
23511 *dki_media_type = DK_UNKNOWN;
23512 }
23513 }
23514
23515 /*
23516 * Now read the capacity so we can provide the lbasize,
23517 * pbsize and capacity.
23518 */
23519 if (dki_pbsize && un->un_f_descr_format_supported) {
23520 rval = sd_send_scsi_READ_CAPACITY_16(ssc, &capacity, &lbasize,
23521 &pbsize, SD_PATH_DIRECT);
23522
23523 /*
23524 * Override the physical blocksize if the instance already
23525 * has a larger value.
23526 */
23527 pbsize = MAX(pbsize, un->un_phy_blocksize);
23528 }
23529
23530 if (dki_pbsize == NULL || rval != 0 ||
23531 !un->un_f_descr_format_supported) {
23532 rval = sd_send_scsi_READ_CAPACITY(ssc, &capacity, &lbasize,
23533 SD_PATH_DIRECT);
23534
23535 switch (rval) {
23536 case 0:
23537 if (un->un_f_enable_rmw &&
23538 un->un_phy_blocksize != 0) {
23539 pbsize = un->un_phy_blocksize;
23540 } else {
23541 pbsize = lbasize;
23542 }
23543 media_capacity = capacity;
23544
23545 /*
23546 * sd_send_scsi_READ_CAPACITY() reports capacity in
23547 * un->un_sys_blocksize chunks. So we need to convert
23548 * it into cap.lbsize chunks.
23549 */
23550 if (un->un_f_has_removable_media) {
23551 media_capacity *= un->un_sys_blocksize;
23552 media_capacity /= lbasize;
23553 }
23554 break;
23555 case EACCES:
23556 rval = EACCES;
23557 goto done;
23558 default:
23559 rval = EIO;
23560 goto done;
23561 }
23562 } else {
23563 if (un->un_f_enable_rmw &&
23564 !ISP2(pbsize % DEV_BSIZE)) {
23565 pbsize = SSD_SECSIZE;
23566 } else if (!ISP2(lbasize % DEV_BSIZE) ||
23567 !ISP2(pbsize % DEV_BSIZE)) {
23568 pbsize = lbasize = DEV_BSIZE;
23569 }
23570 media_capacity = capacity;
23571 }
23572
23573 /*
23574 * If lun is expanded dynamically, update the un structure.
23575 */
23576 mutex_enter(SD_MUTEX(un));
23577 if ((un->un_f_blockcount_is_valid == TRUE) &&
23578 (un->un_f_tgt_blocksize_is_valid == TRUE) &&
23579 (capacity > un->un_blockcount)) {
23580 un->un_f_expnevent = B_FALSE;
23581 sd_update_block_info(un, lbasize, capacity);
23582 }
23583 mutex_exit(SD_MUTEX(un));
23584
23585 *dki_lbsize = lbasize;
23586 *dki_capacity = media_capacity;
23587 if (dki_pbsize)
23588 *dki_pbsize = pbsize;
23589
23590 done:
23591 if (rval != 0) {
23592 if (rval == EIO)
23593 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
23594 else
23595 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
23596 }
23597 no_assessment:
23598 sd_ssc_fini(ssc);
23599 kmem_free(out_data, SD_PROFILE_HEADER_LEN);
23600 kmem_free(rqbuf, SENSE_LENGTH);
23601 return (rval);
23602 }
23603
23604 /*
23605 * Function: sd_get_media_info
23606 *
23607 * Description: This routine is the driver entry point for handling ioctl
23608 * requests for the media type or command set profile used by the
23609 * drive to operate on the media (DKIOCGMEDIAINFO).
23610 *
23611 * Arguments: dev - the device number
23612 * arg - pointer to user provided dk_minfo structure
23613 * specifying the media type, logical block size and
23614 * drive capacity.
23615 * flag - this argument is a pass through to ddi_copyxxx()
23616 * directly from the mode argument of ioctl().
23617 *
23618 * Return Code: returns the value from sd_get_media_info_com
23619 */
23620 static int
23621 sd_get_media_info(dev_t dev, caddr_t arg, int flag)
23622 {
23623 struct dk_minfo mi;
23624 int rval;
23625
23626 rval = sd_get_media_info_com(dev, &mi.dki_media_type,
23627 &mi.dki_lbsize, &mi.dki_capacity, NULL);
23628
23629 if (rval)
23630 return (rval);
23631 if (ddi_copyout(&mi, arg, sizeof (struct dk_minfo), flag))
23632 rval = EFAULT;
23633 return (rval);
23634 }
23635
23636 /*
23637 * Function: sd_get_media_info_ext
23638 *
23639 * Description: This routine is the driver entry point for handling ioctl
23640 * requests for the media type or command set profile used by the
23641 * drive to operate on the media (DKIOCGMEDIAINFOEXT). The
23642 * difference this ioctl and DKIOCGMEDIAINFO is the return value
23643 * of this ioctl contains both logical block size and physical
23644 * block size.
23645 *
23646 *
23647 * Arguments: dev - the device number
23648 * arg - pointer to user provided dk_minfo_ext structure
23649 * specifying the media type, logical block size,
23650 * physical block size and disk capacity.
23651 * flag - this argument is a pass through to ddi_copyxxx()
23652 * directly from the mode argument of ioctl().
23653 *
23654 * Return Code: returns the value from sd_get_media_info_com
23655 */
23656 static int
23657 sd_get_media_info_ext(dev_t dev, caddr_t arg, int flag)
23658 {
23659 struct dk_minfo_ext mie;
23660 int rval = 0;
23661
23662 rval = sd_get_media_info_com(dev, &mie.dki_media_type,
23663 &mie.dki_lbsize, &mie.dki_capacity, &mie.dki_pbsize);
23664
23665 if (rval)
23666 return (rval);
23667 if (ddi_copyout(&mie, arg, sizeof (struct dk_minfo_ext), flag))
23668 rval = EFAULT;
23669 return (rval);
23670
23671 }
23672
23673 /*
23674 * Function: sd_watch_request_submit
23675 *
23676 * Description: Call scsi_watch_request_submit or scsi_mmc_watch_request_submit
23677 * depending on which is supported by device.
23678 */
23679 static opaque_t
23680 sd_watch_request_submit(struct sd_lun *un)
23681 {
23682 dev_t dev;
23683
23684 /* All submissions are unified to use same device number */
23685 dev = sd_make_device(SD_DEVINFO(un));
23686
23687 if (un->un_f_mmc_cap && un->un_f_mmc_gesn_polling) {
23688 return (scsi_mmc_watch_request_submit(SD_SCSI_DEVP(un),
23689 sd_check_media_time, SENSE_LENGTH, sd_media_watch_cb,
23690 (caddr_t)dev));
23691 } else {
23692 return (scsi_watch_request_submit(SD_SCSI_DEVP(un),
23693 sd_check_media_time, SENSE_LENGTH, sd_media_watch_cb,
23694 (caddr_t)dev));
23695 }
23696 }
23697
23698
23699 /*
23700 * Function: sd_check_media
23701 *
23702 * Description: This utility routine implements the functionality for the
23703 * DKIOCSTATE ioctl. This ioctl blocks the user thread until the
23704 * driver state changes from that specified by the user
23705 * (inserted or ejected). For example, if the user specifies
23706 * DKIO_EJECTED and the current media state is inserted this
23707 * routine will immediately return DKIO_INSERTED. However, if the
23708 * current media state is not inserted the user thread will be
23709 * blocked until the drive state changes. If DKIO_NONE is specified
23710 * the user thread will block until a drive state change occurs.
23711 *
23712 * Arguments: dev - the device number
23713 * state - user pointer to a dkio_state, updated with the current
23714 * drive state at return.
23715 *
23716 * Return Code: ENXIO
23717 * EIO
23718 * EAGAIN
23719 * EINTR
23720 */
23721
23722 static int
23723 sd_check_media(dev_t dev, enum dkio_state state)
23724 {
23725 struct sd_lun *un = NULL;
23726 enum dkio_state prev_state;
23727 opaque_t token = NULL;
23728 int rval = 0;
23729 sd_ssc_t *ssc;
23730
23731 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
23732 return (ENXIO);
23733 }
23734
23735 SD_TRACE(SD_LOG_COMMON, un, "sd_check_media: entry\n");
23736
23737 ssc = sd_ssc_init(un);
23738
23739 mutex_enter(SD_MUTEX(un));
23740
23741 SD_TRACE(SD_LOG_COMMON, un, "sd_check_media: "
23742 "state=%x, mediastate=%x\n", state, un->un_mediastate);
23743
23744 prev_state = un->un_mediastate;
23745
23746 /* is there anything to do? */
23747 if (state == un->un_mediastate || un->un_mediastate == DKIO_NONE) {
23748 /*
23749 * submit the request to the scsi_watch service;
23750 * scsi_media_watch_cb() does the real work
23751 */
23752 mutex_exit(SD_MUTEX(un));
23753
23754 /*
23755 * This change handles the case where a scsi watch request is
23756 * added to a device that is powered down. To accomplish this
23757 * we power up the device before adding the scsi watch request,
23758 * since the scsi watch sends a TUR directly to the device
23759 * which the device cannot handle if it is powered down.
23760 */
23761 if (sd_pm_entry(un) != DDI_SUCCESS) {
23762 mutex_enter(SD_MUTEX(un));
23763 goto done;
23764 }
23765
23766 token = sd_watch_request_submit(un);
23767
23768 sd_pm_exit(un);
23769
23770 mutex_enter(SD_MUTEX(un));
23771 if (token == NULL) {
23772 rval = EAGAIN;
23773 goto done;
23774 }
23775
23776 /*
23777 * This is a special case IOCTL that doesn't return
23778 * until the media state changes. Routine sdpower
23779 * knows about and handles this so don't count it
23780 * as an active cmd in the driver, which would
23781 * keep the device busy to the pm framework.
23782 * If the count isn't decremented the device can't
23783 * be powered down.
23784 */
23785 un->un_ncmds_in_driver--;
23786 ASSERT(un->un_ncmds_in_driver >= 0);
23787
23788 /*
23789 * if a prior request had been made, this will be the same
23790 * token, as scsi_watch was designed that way.
23791 */
23792 un->un_swr_token = token;
23793 un->un_specified_mediastate = state;
23794
23795 /*
23796 * now wait for media change
23797 * we will not be signalled unless mediastate == state but it is
23798 * still better to test for this condition, since there is a
23799 * 2 sec cv_broadcast delay when mediastate == DKIO_INSERTED
23800 */
23801 SD_TRACE(SD_LOG_COMMON, un,
23802 "sd_check_media: waiting for media state change\n");
23803 while (un->un_mediastate == state) {
23804 if (cv_wait_sig(&un->un_state_cv, SD_MUTEX(un)) == 0) {
23805 SD_TRACE(SD_LOG_COMMON, un,
23806 "sd_check_media: waiting for media state "
23807 "was interrupted\n");
23808 un->un_ncmds_in_driver++;
23809 rval = EINTR;
23810 goto done;
23811 }
23812 SD_TRACE(SD_LOG_COMMON, un,
23813 "sd_check_media: received signal, state=%x\n",
23814 un->un_mediastate);
23815 }
23816 /*
23817 * Inc the counter to indicate the device once again
23818 * has an active outstanding cmd.
23819 */
23820 un->un_ncmds_in_driver++;
23821 }
23822
23823 /* invalidate geometry */
23824 if (prev_state == DKIO_INSERTED && un->un_mediastate == DKIO_EJECTED) {
23825 sr_ejected(un);
23826 }
23827
23828 if (un->un_mediastate == DKIO_INSERTED && prev_state != DKIO_INSERTED) {
23829 uint64_t capacity;
23830 uint_t lbasize;
23831
23832 SD_TRACE(SD_LOG_COMMON, un, "sd_check_media: media inserted\n");
23833 mutex_exit(SD_MUTEX(un));
23834 /*
23835 * Since the following routines use SD_PATH_DIRECT, we must
23836 * call PM directly before the upcoming disk accesses. This
23837 * may cause the disk to be power/spin up.
23838 */
23839
23840 if (sd_pm_entry(un) == DDI_SUCCESS) {
23841 rval = sd_send_scsi_READ_CAPACITY(ssc,
23842 &capacity, &lbasize, SD_PATH_DIRECT);
23843 if (rval != 0) {
23844 sd_pm_exit(un);
23845 if (rval == EIO)
23846 sd_ssc_assessment(ssc,
23847 SD_FMT_STATUS_CHECK);
23848 else
23849 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
23850 mutex_enter(SD_MUTEX(un));
23851 goto done;
23852 }
23853 } else {
23854 rval = EIO;
23855 mutex_enter(SD_MUTEX(un));
23856 goto done;
23857 }
23858 mutex_enter(SD_MUTEX(un));
23859
23860 sd_update_block_info(un, lbasize, capacity);
23861
23862 /*
23863 * Check if the media in the device is writable or not
23864 */
23865 if (ISCD(un)) {
23866 sd_check_for_writable_cd(ssc, SD_PATH_DIRECT);
23867 }
23868
23869 mutex_exit(SD_MUTEX(un));
23870 cmlb_invalidate(un->un_cmlbhandle, (void *)SD_PATH_DIRECT);
23871 if ((cmlb_validate(un->un_cmlbhandle, 0,
23872 (void *)SD_PATH_DIRECT) == 0) && un->un_f_pkstats_enabled) {
23873 sd_set_pstats(un);
23874 SD_TRACE(SD_LOG_IO_PARTITION, un,
23875 "sd_check_media: un:0x%p pstats created and "
23876 "set\n", un);
23877 }
23878
23879 rval = sd_send_scsi_DOORLOCK(ssc, SD_REMOVAL_PREVENT,
23880 SD_PATH_DIRECT);
23881
23882 sd_pm_exit(un);
23883
23884 if (rval != 0) {
23885 if (rval == EIO)
23886 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
23887 else
23888 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
23889 }
23890
23891 mutex_enter(SD_MUTEX(un));
23892 }
23893 done:
23894 sd_ssc_fini(ssc);
23895 un->un_f_watcht_stopped = FALSE;
23896 if (token != NULL && un->un_swr_token != NULL) {
23897 /*
23898 * Use of this local token and the mutex ensures that we avoid
23899 * some race conditions associated with terminating the
23900 * scsi watch.
23901 */
23902 token = un->un_swr_token;
23903 mutex_exit(SD_MUTEX(un));
23904 (void) scsi_watch_request_terminate(token,
23905 SCSI_WATCH_TERMINATE_WAIT);
23906 if (scsi_watch_get_ref_count(token) == 0) {
23907 mutex_enter(SD_MUTEX(un));
23908 un->un_swr_token = (opaque_t)NULL;
23909 } else {
23910 mutex_enter(SD_MUTEX(un));
23911 }
23912 }
23913
23914 /*
23915 * Update the capacity kstat value, if no media previously
23916 * (capacity kstat is 0) and a media has been inserted
23917 * (un_f_blockcount_is_valid == TRUE)
23918 */
23919 if (un->un_errstats) {
23920 struct sd_errstats *stp = NULL;
23921
23922 stp = (struct sd_errstats *)un->un_errstats->ks_data;
23923 if ((stp->sd_capacity.value.ui64 == 0) &&
23924 (un->un_f_blockcount_is_valid == TRUE)) {
23925 stp->sd_capacity.value.ui64 =
23926 (uint64_t)((uint64_t)un->un_blockcount *
23927 un->un_sys_blocksize);
23928 }
23929 }
23930 mutex_exit(SD_MUTEX(un));
23931 SD_TRACE(SD_LOG_COMMON, un, "sd_check_media: done\n");
23932 return (rval);
23933 }
23934
23935
23936 /*
23937 * Function: sd_delayed_cv_broadcast
23938 *
23939 * Description: Delayed cv_broadcast to allow for target to recover from media
23940 * insertion.
23941 *
23942 * Arguments: arg - driver soft state (unit) structure
23943 */
23944
23945 static void
23946 sd_delayed_cv_broadcast(void *arg)
23947 {
23948 struct sd_lun *un = arg;
23949
23950 SD_TRACE(SD_LOG_COMMON, un, "sd_delayed_cv_broadcast\n");
23951
23952 mutex_enter(SD_MUTEX(un));
23953 un->un_dcvb_timeid = NULL;
23954 cv_broadcast(&un->un_state_cv);
23955 mutex_exit(SD_MUTEX(un));
23956 }
23957
23958
23959 /*
23960 * Function: sd_media_watch_cb
23961 *
23962 * Description: Callback routine used for support of the DKIOCSTATE ioctl. This
23963 * routine processes the TUR sense data and updates the driver
23964 * state if a transition has occurred. The user thread
23965 * (sd_check_media) is then signalled.
23966 *
23967 * Arguments: arg - the device 'dev_t' is used for context to discriminate
23968 * among multiple watches that share this callback function
23969 * resultp - scsi watch facility result packet containing scsi
23970 * packet, status byte and sense data
23971 *
23972 * Return Code: 0 for success, -1 for failure
23973 */
23974
23975 static int
23976 sd_media_watch_cb(caddr_t arg, struct scsi_watch_result *resultp)
23977 {
23978 struct sd_lun *un;
23979 struct scsi_status *statusp = resultp->statusp;
23980 uint8_t *sensep = (uint8_t *)resultp->sensep;
23981 enum dkio_state state = DKIO_NONE;
23982 dev_t dev = (dev_t)arg;
23983 uchar_t actual_sense_length;
23984 uint8_t skey, asc, ascq;
23985
23986 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
23987 return (-1);
23988 }
23989 actual_sense_length = resultp->actual_sense_length;
23990
23991 mutex_enter(SD_MUTEX(un));
23992 SD_TRACE(SD_LOG_COMMON, un,
23993 "sd_media_watch_cb: status=%x, sensep=%p, len=%x\n",
23994 *((char *)statusp), (void *)sensep, actual_sense_length);
23995
23996 if (resultp->pkt->pkt_reason == CMD_DEV_GONE) {
23997 un->un_mediastate = DKIO_DEV_GONE;
23998 cv_broadcast(&un->un_state_cv);
23999 mutex_exit(SD_MUTEX(un));
24000
24001 return (0);
24002 }
24003
24004 if (un->un_f_mmc_cap && un->un_f_mmc_gesn_polling) {
24005 if (sd_gesn_media_data_valid(resultp->mmc_data)) {
24006 if ((resultp->mmc_data[5] &
24007 SD_GESN_MEDIA_EVENT_STATUS_PRESENT) != 0) {
24008 state = DKIO_INSERTED;
24009 } else {
24010 state = DKIO_EJECTED;
24011 }
24012 if ((resultp->mmc_data[4] & SD_GESN_MEDIA_EVENT_CODE) ==
24013 SD_GESN_MEDIA_EVENT_EJECTREQUEST) {
24014 sd_log_eject_request_event(un, KM_NOSLEEP);
24015 }
24016 }
24017 } else if (sensep != NULL) {
24018 /*
24019 * If there was a check condition then sensep points to valid
24020 * sense data. If status was not a check condition but a
24021 * reservation or busy status then the new state is DKIO_NONE.
24022 */
24023 skey = scsi_sense_key(sensep);
24024 asc = scsi_sense_asc(sensep);
24025 ascq = scsi_sense_ascq(sensep);
24026
24027 SD_INFO(SD_LOG_COMMON, un,
24028 "sd_media_watch_cb: sense KEY=%x, ASC=%x, ASCQ=%x\n",
24029 skey, asc, ascq);
24030 /* This routine only uses up to 13 bytes of sense data. */
24031 if (actual_sense_length >= 13) {
24032 if (skey == KEY_UNIT_ATTENTION) {
24033 if (asc == 0x28) {
24034 state = DKIO_INSERTED;
24035 }
24036 } else if (skey == KEY_NOT_READY) {
24037 /*
24038 * Sense data of 02/06/00 means that the
24039 * drive could not read the media (No
24040 * reference position found). In this case
24041 * to prevent a hang on the DKIOCSTATE IOCTL
24042 * we set the media state to DKIO_INSERTED.
24043 */
24044 if (asc == 0x06 && ascq == 0x00)
24045 state = DKIO_INSERTED;
24046
24047 /*
24048 * if 02/04/02 means that the host
24049 * should send start command. Explicitly
24050 * leave the media state as is
24051 * (inserted) as the media is inserted
24052 * and host has stopped device for PM
24053 * reasons. Upon next true read/write
24054 * to this media will bring the
24055 * device to the right state good for
24056 * media access.
24057 */
24058 if (asc == 0x3a) {
24059 state = DKIO_EJECTED;
24060 } else {
24061 /*
24062 * If the drive is busy with an
24063 * operation or long write, keep the
24064 * media in an inserted state.
24065 */
24066
24067 if ((asc == 0x04) &&
24068 ((ascq == 0x02) ||
24069 (ascq == 0x07) ||
24070 (ascq == 0x08))) {
24071 state = DKIO_INSERTED;
24072 }
24073 }
24074 } else if (skey == KEY_NO_SENSE) {
24075 if ((asc == 0x00) && (ascq == 0x00)) {
24076 /*
24077 * Sense Data 00/00/00 does not provide
24078 * any information about the state of
24079 * the media. Ignore it.
24080 */
24081 mutex_exit(SD_MUTEX(un));
24082 return (0);
24083 }
24084 }
24085 }
24086 } else if ((*((char *)statusp) == STATUS_GOOD) &&
24087 (resultp->pkt->pkt_reason == CMD_CMPLT)) {
24088 state = DKIO_INSERTED;
24089 }
24090
24091 SD_TRACE(SD_LOG_COMMON, un,
24092 "sd_media_watch_cb: state=%x, specified=%x\n",
24093 state, un->un_specified_mediastate);
24094
24095 /*
24096 * now signal the waiting thread if this is *not* the specified state;
24097 * delay the signal if the state is DKIO_INSERTED to allow the target
24098 * to recover
24099 */
24100 if (state != un->un_specified_mediastate) {
24101 un->un_mediastate = state;
24102 if (state == DKIO_INSERTED) {
24103 /*
24104 * delay the signal to give the drive a chance
24105 * to do what it apparently needs to do
24106 */
24107 SD_TRACE(SD_LOG_COMMON, un,
24108 "sd_media_watch_cb: delayed cv_broadcast\n");
24109 if (un->un_dcvb_timeid == NULL) {
24110 un->un_dcvb_timeid =
24111 timeout(sd_delayed_cv_broadcast, un,
24112 drv_usectohz((clock_t)MEDIA_ACCESS_DELAY));
24113 }
24114 } else {
24115 SD_TRACE(SD_LOG_COMMON, un,
24116 "sd_media_watch_cb: immediate cv_broadcast\n");
24117 cv_broadcast(&un->un_state_cv);
24118 }
24119 }
24120 mutex_exit(SD_MUTEX(un));
24121 return (0);
24122 }
24123
24124
24125 /*
24126 * Function: sd_dkio_get_temp
24127 *
24128 * Description: This routine is the driver entry point for handling ioctl
24129 * requests to get the disk temperature.
24130 *
24131 * Arguments: dev - the device number
24132 * arg - pointer to user provided dk_temperature structure.
24133 * flag - this argument is a pass through to ddi_copyxxx()
24134 * directly from the mode argument of ioctl().
24135 *
24136 * Return Code: 0
24137 * EFAULT
24138 * ENXIO
24139 * EAGAIN
24140 */
24141
24142 static int
24143 sd_dkio_get_temp(dev_t dev, caddr_t arg, int flag)
24144 {
24145 struct sd_lun *un = NULL;
24146 struct dk_temperature *dktemp = NULL;
24147 uchar_t *temperature_page;
24148 int rval = 0;
24149 int path_flag = SD_PATH_STANDARD;
24150 sd_ssc_t *ssc;
24151
24152 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
24153 return (ENXIO);
24154 }
24155
24156 ssc = sd_ssc_init(un);
24157 dktemp = kmem_zalloc(sizeof (struct dk_temperature), KM_SLEEP);
24158
24159 /* copyin the disk temp argument to get the user flags */
24160 if (ddi_copyin((void *)arg, dktemp,
24161 sizeof (struct dk_temperature), flag) != 0) {
24162 rval = EFAULT;
24163 goto done;
24164 }
24165
24166 /* Initialize the temperature to invalid. */
24167 dktemp->dkt_cur_temp = (short)DKT_INVALID_TEMP;
24168 dktemp->dkt_ref_temp = (short)DKT_INVALID_TEMP;
24169
24170 /*
24171 * Note: Investigate removing the "bypass pm" semantic.
24172 * Can we just bypass PM always?
24173 */
24174 if (dktemp->dkt_flags & DKT_BYPASS_PM) {
24175 path_flag = SD_PATH_DIRECT;
24176 ASSERT(!mutex_owned(&un->un_pm_mutex));
24177 mutex_enter(&un->un_pm_mutex);
24178 if (SD_DEVICE_IS_IN_LOW_POWER(un)) {
24179 /*
24180 * If DKT_BYPASS_PM is set, and the drive happens to be
24181 * in low power mode, we can not wake it up, Need to
24182 * return EAGAIN.
24183 */
24184 mutex_exit(&un->un_pm_mutex);
24185 rval = EAGAIN;
24186 goto done;
24187 } else {
24188 /*
24189 * Indicate to PM the device is busy. This is required
24190 * to avoid a race - i.e. the ioctl is issuing a
24191 * command and the pm framework brings down the device
24192 * to low power mode (possible power cut-off on some
24193 * platforms).
24194 */
24195 mutex_exit(&un->un_pm_mutex);
24196 if (sd_pm_entry(un) != DDI_SUCCESS) {
24197 rval = EAGAIN;
24198 goto done;
24199 }
24200 }
24201 }
24202
24203 temperature_page = kmem_zalloc(TEMPERATURE_PAGE_SIZE, KM_SLEEP);
24204
24205 rval = sd_send_scsi_LOG_SENSE(ssc, temperature_page,
24206 TEMPERATURE_PAGE_SIZE, TEMPERATURE_PAGE, 1, 0, path_flag);
24207 if (rval != 0)
24208 goto done2;
24209
24210 /*
24211 * For the current temperature verify that the parameter length is 0x02
24212 * and the parameter code is 0x00
24213 */
24214 if ((temperature_page[7] == 0x02) && (temperature_page[4] == 0x00) &&
24215 (temperature_page[5] == 0x00)) {
24216 if (temperature_page[9] == 0xFF) {
24217 dktemp->dkt_cur_temp = (short)DKT_INVALID_TEMP;
24218 } else {
24219 dktemp->dkt_cur_temp = (short)(temperature_page[9]);
24220 }
24221 }
24222
24223 /*
24224 * For the reference temperature verify that the parameter
24225 * length is 0x02 and the parameter code is 0x01
24226 */
24227 if ((temperature_page[13] == 0x02) && (temperature_page[10] == 0x00) &&
24228 (temperature_page[11] == 0x01)) {
24229 if (temperature_page[15] == 0xFF) {
24230 dktemp->dkt_ref_temp = (short)DKT_INVALID_TEMP;
24231 } else {
24232 dktemp->dkt_ref_temp = (short)(temperature_page[15]);
24233 }
24234 }
24235
24236 /* Do the copyout regardless of the temperature commands status. */
24237 if (ddi_copyout(dktemp, (void *)arg, sizeof (struct dk_temperature),
24238 flag) != 0) {
24239 rval = EFAULT;
24240 goto done1;
24241 }
24242
24243 done2:
24244 if (rval != 0) {
24245 if (rval == EIO)
24246 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
24247 else
24248 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
24249 }
24250 done1:
24251 if (path_flag == SD_PATH_DIRECT) {
24252 sd_pm_exit(un);
24253 }
24254
24255 kmem_free(temperature_page, TEMPERATURE_PAGE_SIZE);
24256 done:
24257 sd_ssc_fini(ssc);
24258 if (dktemp != NULL) {
24259 kmem_free(dktemp, sizeof (struct dk_temperature));
24260 }
24261
24262 return (rval);
24263 }
24264
24265
24266 /*
24267 * Function: sd_log_page_supported
24268 *
24269 * Description: This routine uses sd_send_scsi_LOG_SENSE to find the list of
24270 * supported log pages.
24271 *
24272 * Arguments: ssc - ssc contains pointer to driver soft state (unit)
24273 * structure for this target.
24274 * log_page -
24275 *
24276 * Return Code: -1 - on error (log sense is optional and may not be supported).
24277 * 0 - log page not found.
24278 * 1 - log page found.
24279 */
24280
24281 static int
24282 sd_log_page_supported(sd_ssc_t *ssc, int log_page)
24283 {
24284 uchar_t *log_page_data;
24285 int i;
24286 int match = 0;
24287 int log_size;
24288 int status = 0;
24289 struct sd_lun *un;
24290
24291 ASSERT(ssc != NULL);
24292 un = ssc->ssc_un;
24293 ASSERT(un != NULL);
24294
24295 log_page_data = kmem_zalloc(0xFF, KM_SLEEP);
24296
24297 status = sd_send_scsi_LOG_SENSE(ssc, log_page_data, 0xFF, 0, 0x01, 0,
24298 SD_PATH_DIRECT);
24299
24300 if (status != 0) {
24301 if (status == EIO) {
24302 /*
24303 * Some disks do not support log sense, we
24304 * should ignore this kind of error(sense key is
24305 * 0x5 - illegal request).
24306 */
24307 uint8_t *sensep;
24308 int senlen;
24309
24310 sensep = (uint8_t *)ssc->ssc_uscsi_cmd->uscsi_rqbuf;
24311 senlen = (int)(ssc->ssc_uscsi_cmd->uscsi_rqlen -
24312 ssc->ssc_uscsi_cmd->uscsi_rqresid);
24313
24314 if (senlen > 0 &&
24315 scsi_sense_key(sensep) == KEY_ILLEGAL_REQUEST) {
24316 sd_ssc_assessment(ssc,
24317 SD_FMT_IGNORE_COMPROMISE);
24318 } else {
24319 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
24320 }
24321 } else {
24322 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
24323 }
24324
24325 SD_ERROR(SD_LOG_COMMON, un,
24326 "sd_log_page_supported: failed log page retrieval\n");
24327 kmem_free(log_page_data, 0xFF);
24328 return (-1);
24329 }
24330
24331 log_size = log_page_data[3];
24332
24333 /*
24334 * The list of supported log pages start from the fourth byte. Check
24335 * until we run out of log pages or a match is found.
24336 */
24337 for (i = 4; (i < (log_size + 4)) && !match; i++) {
24338 if (log_page_data[i] == log_page) {
24339 match++;
24340 }
24341 }
24342 kmem_free(log_page_data, 0xFF);
24343 return (match);
24344 }
24345
24346
24347 /*
24348 * Function: sd_mhdioc_failfast
24349 *
24350 * Description: This routine is the driver entry point for handling ioctl
24351 * requests to enable/disable the multihost failfast option.
24352 * (MHIOCENFAILFAST)
24353 *
24354 * Arguments: dev - the device number
24355 * arg - user specified probing interval.
24356 * flag - this argument is a pass through to ddi_copyxxx()
24357 * directly from the mode argument of ioctl().
24358 *
24359 * Return Code: 0
24360 * EFAULT
24361 * ENXIO
24362 */
24363
24364 static int
24365 sd_mhdioc_failfast(dev_t dev, caddr_t arg, int flag)
24366 {
24367 struct sd_lun *un = NULL;
24368 int mh_time;
24369 int rval = 0;
24370
24371 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
24372 return (ENXIO);
24373 }
24374
24375 if (ddi_copyin((void *)arg, &mh_time, sizeof (int), flag))
24376 return (EFAULT);
24377
24378 if (mh_time) {
24379 mutex_enter(SD_MUTEX(un));
24380 un->un_resvd_status |= SD_FAILFAST;
24381 mutex_exit(SD_MUTEX(un));
24382 /*
24383 * If mh_time is INT_MAX, then this ioctl is being used for
24384 * SCSI-3 PGR purposes, and we don't need to spawn watch thread.
24385 */
24386 if (mh_time != INT_MAX) {
24387 rval = sd_check_mhd(dev, mh_time);
24388 }
24389 } else {
24390 (void) sd_check_mhd(dev, 0);
24391 mutex_enter(SD_MUTEX(un));
24392 un->un_resvd_status &= ~SD_FAILFAST;
24393 mutex_exit(SD_MUTEX(un));
24394 }
24395 return (rval);
24396 }
24397
24398
24399 /*
24400 * Function: sd_mhdioc_takeown
24401 *
24402 * Description: This routine is the driver entry point for handling ioctl
24403 * requests to forcefully acquire exclusive access rights to the
24404 * multihost disk (MHIOCTKOWN).
24405 *
24406 * Arguments: dev - the device number
24407 * arg - user provided structure specifying the delay
24408 * parameters in milliseconds
24409 * flag - this argument is a pass through to ddi_copyxxx()
24410 * directly from the mode argument of ioctl().
24411 *
24412 * Return Code: 0
24413 * EFAULT
24414 * ENXIO
24415 */
24416
24417 static int
24418 sd_mhdioc_takeown(dev_t dev, caddr_t arg, int flag)
24419 {
24420 struct sd_lun *un = NULL;
24421 struct mhioctkown *tkown = NULL;
24422 int rval = 0;
24423
24424 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
24425 return (ENXIO);
24426 }
24427
24428 if (arg != NULL) {
24429 tkown = (struct mhioctkown *)
24430 kmem_zalloc(sizeof (struct mhioctkown), KM_SLEEP);
24431 rval = ddi_copyin(arg, tkown, sizeof (struct mhioctkown), flag);
24432 if (rval != 0) {
24433 rval = EFAULT;
24434 goto error;
24435 }
24436 }
24437
24438 rval = sd_take_ownership(dev, tkown);
24439 mutex_enter(SD_MUTEX(un));
24440 if (rval == 0) {
24441 un->un_resvd_status |= SD_RESERVE;
24442 if (tkown != NULL && tkown->reinstate_resv_delay != 0) {
24443 sd_reinstate_resv_delay =
24444 tkown->reinstate_resv_delay * 1000;
24445 } else {
24446 sd_reinstate_resv_delay = SD_REINSTATE_RESV_DELAY;
24447 }
24448 /*
24449 * Give the scsi_watch routine interval set by
24450 * the MHIOCENFAILFAST ioctl precedence here.
24451 */
24452 if ((un->un_resvd_status & SD_FAILFAST) == 0) {
24453 mutex_exit(SD_MUTEX(un));
24454 (void) sd_check_mhd(dev, sd_reinstate_resv_delay/1000);
24455 SD_TRACE(SD_LOG_IOCTL_MHD, un,
24456 "sd_mhdioc_takeown : %d\n",
24457 sd_reinstate_resv_delay);
24458 } else {
24459 mutex_exit(SD_MUTEX(un));
24460 }
24461 (void) scsi_reset_notify(SD_ADDRESS(un), SCSI_RESET_NOTIFY,
24462 sd_mhd_reset_notify_cb, (caddr_t)un);
24463 } else {
24464 un->un_resvd_status &= ~SD_RESERVE;
24465 mutex_exit(SD_MUTEX(un));
24466 }
24467
24468 error:
24469 if (tkown != NULL) {
24470 kmem_free(tkown, sizeof (struct mhioctkown));
24471 }
24472 return (rval);
24473 }
24474
24475
24476 /*
24477 * Function: sd_mhdioc_release
24478 *
24479 * Description: This routine is the driver entry point for handling ioctl
24480 * requests to release exclusive access rights to the multihost
24481 * disk (MHIOCRELEASE).
24482 *
24483 * Arguments: dev - the device number
24484 *
24485 * Return Code: 0
24486 * ENXIO
24487 */
24488
24489 static int
24490 sd_mhdioc_release(dev_t dev)
24491 {
24492 struct sd_lun *un = NULL;
24493 timeout_id_t resvd_timeid_save;
24494 int resvd_status_save;
24495 int rval = 0;
24496
24497 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
24498 return (ENXIO);
24499 }
24500
24501 mutex_enter(SD_MUTEX(un));
24502 resvd_status_save = un->un_resvd_status;
24503 un->un_resvd_status &=
24504 ~(SD_RESERVE | SD_LOST_RESERVE | SD_WANT_RESERVE);
24505 if (un->un_resvd_timeid) {
24506 resvd_timeid_save = un->un_resvd_timeid;
24507 un->un_resvd_timeid = NULL;
24508 mutex_exit(SD_MUTEX(un));
24509 (void) untimeout(resvd_timeid_save);
24510 } else {
24511 mutex_exit(SD_MUTEX(un));
24512 }
24513
24514 /*
24515 * destroy any pending timeout thread that may be attempting to
24516 * reinstate reservation on this device.
24517 */
24518 sd_rmv_resv_reclaim_req(dev);
24519
24520 if ((rval = sd_reserve_release(dev, SD_RELEASE)) == 0) {
24521 mutex_enter(SD_MUTEX(un));
24522 if ((un->un_mhd_token) &&
24523 ((un->un_resvd_status & SD_FAILFAST) == 0)) {
24524 mutex_exit(SD_MUTEX(un));
24525 (void) sd_check_mhd(dev, 0);
24526 } else {
24527 mutex_exit(SD_MUTEX(un));
24528 }
24529 (void) scsi_reset_notify(SD_ADDRESS(un), SCSI_RESET_CANCEL,
24530 sd_mhd_reset_notify_cb, (caddr_t)un);
24531 } else {
24532 /*
24533 * sd_mhd_watch_cb will restart the resvd recover timeout thread
24534 */
24535 mutex_enter(SD_MUTEX(un));
24536 un->un_resvd_status = resvd_status_save;
24537 mutex_exit(SD_MUTEX(un));
24538 }
24539 return (rval);
24540 }
24541
24542
24543 /*
24544 * Function: sd_mhdioc_register_devid
24545 *
24546 * Description: This routine is the driver entry point for handling ioctl
24547 * requests to register the device id (MHIOCREREGISTERDEVID).
24548 *
24549 * Note: The implementation for this ioctl has been updated to
24550 * be consistent with the original PSARC case (1999/357)
24551 * (4375899, 4241671, 4220005)
24552 *
24553 * Arguments: dev - the device number
24554 *
24555 * Return Code: 0
24556 * ENXIO
24557 */
24558
24559 static int
24560 sd_mhdioc_register_devid(dev_t dev)
24561 {
24562 struct sd_lun *un = NULL;
24563 int rval = 0;
24564 sd_ssc_t *ssc;
24565
24566 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
24567 return (ENXIO);
24568 }
24569
24570 ASSERT(!mutex_owned(SD_MUTEX(un)));
24571
24572 mutex_enter(SD_MUTEX(un));
24573
24574 /* If a devid already exists, de-register it */
24575 if (un->un_devid != NULL) {
24576 ddi_devid_unregister(SD_DEVINFO(un));
24577 /*
24578 * After unregister devid, needs to free devid memory
24579 */
24580 ddi_devid_free(un->un_devid);
24581 un->un_devid = NULL;
24582 }
24583
24584 /* Check for reservation conflict */
24585 mutex_exit(SD_MUTEX(un));
24586 ssc = sd_ssc_init(un);
24587 rval = sd_send_scsi_TEST_UNIT_READY(ssc, 0);
24588 mutex_enter(SD_MUTEX(un));
24589
24590 switch (rval) {
24591 case 0:
24592 sd_register_devid(ssc, SD_DEVINFO(un), SD_TARGET_IS_UNRESERVED);
24593 break;
24594 case EACCES:
24595 break;
24596 default:
24597 rval = EIO;
24598 }
24599
24600 mutex_exit(SD_MUTEX(un));
24601 if (rval != 0) {
24602 if (rval == EIO)
24603 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
24604 else
24605 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
24606 }
24607 sd_ssc_fini(ssc);
24608 return (rval);
24609 }
24610
24611
24612 /*
24613 * Function: sd_mhdioc_inkeys
24614 *
24615 * Description: This routine is the driver entry point for handling ioctl
24616 * requests to issue the SCSI-3 Persistent In Read Keys command
24617 * to the device (MHIOCGRP_INKEYS).
24618 *
24619 * Arguments: dev - the device number
24620 * arg - user provided in_keys structure
24621 * flag - this argument is a pass through to ddi_copyxxx()
24622 * directly from the mode argument of ioctl().
24623 *
24624 * Return Code: code returned by sd_persistent_reservation_in_read_keys()
24625 * ENXIO
24626 * EFAULT
24627 */
24628
24629 static int
24630 sd_mhdioc_inkeys(dev_t dev, caddr_t arg, int flag)
24631 {
24632 struct sd_lun *un;
24633 mhioc_inkeys_t inkeys;
24634 int rval = 0;
24635
24636 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
24637 return (ENXIO);
24638 }
24639
24640 #ifdef _MULTI_DATAMODEL
24641 switch (ddi_model_convert_from(flag & FMODELS)) {
24642 case DDI_MODEL_ILP32: {
24643 struct mhioc_inkeys32 inkeys32;
24644
24645 if (ddi_copyin(arg, &inkeys32,
24646 sizeof (struct mhioc_inkeys32), flag) != 0) {
24647 return (EFAULT);
24648 }
24649 inkeys.li = (mhioc_key_list_t *)(uintptr_t)inkeys32.li;
24650 if ((rval = sd_persistent_reservation_in_read_keys(un,
24651 &inkeys, flag)) != 0) {
24652 return (rval);
24653 }
24654 inkeys32.generation = inkeys.generation;
24655 if (ddi_copyout(&inkeys32, arg, sizeof (struct mhioc_inkeys32),
24656 flag) != 0) {
24657 return (EFAULT);
24658 }
24659 break;
24660 }
24661 case DDI_MODEL_NONE:
24662 if (ddi_copyin(arg, &inkeys, sizeof (mhioc_inkeys_t),
24663 flag) != 0) {
24664 return (EFAULT);
24665 }
24666 if ((rval = sd_persistent_reservation_in_read_keys(un,
24667 &inkeys, flag)) != 0) {
24668 return (rval);
24669 }
24670 if (ddi_copyout(&inkeys, arg, sizeof (mhioc_inkeys_t),
24671 flag) != 0) {
24672 return (EFAULT);
24673 }
24674 break;
24675 }
24676
24677 #else /* ! _MULTI_DATAMODEL */
24678
24679 if (ddi_copyin(arg, &inkeys, sizeof (mhioc_inkeys_t), flag) != 0) {
24680 return (EFAULT);
24681 }
24682 rval = sd_persistent_reservation_in_read_keys(un, &inkeys, flag);
24683 if (rval != 0) {
24684 return (rval);
24685 }
24686 if (ddi_copyout(&inkeys, arg, sizeof (mhioc_inkeys_t), flag) != 0) {
24687 return (EFAULT);
24688 }
24689
24690 #endif /* _MULTI_DATAMODEL */
24691
24692 return (rval);
24693 }
24694
24695
24696 /*
24697 * Function: sd_mhdioc_inresv
24698 *
24699 * Description: This routine is the driver entry point for handling ioctl
24700 * requests to issue the SCSI-3 Persistent In Read Reservations
24701 * command to the device (MHIOCGRP_INKEYS).
24702 *
24703 * Arguments: dev - the device number
24704 * arg - user provided in_resv structure
24705 * flag - this argument is a pass through to ddi_copyxxx()
24706 * directly from the mode argument of ioctl().
24707 *
24708 * Return Code: code returned by sd_persistent_reservation_in_read_resv()
24709 * ENXIO
24710 * EFAULT
24711 */
24712
24713 static int
24714 sd_mhdioc_inresv(dev_t dev, caddr_t arg, int flag)
24715 {
24716 struct sd_lun *un;
24717 mhioc_inresvs_t inresvs;
24718 int rval = 0;
24719
24720 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
24721 return (ENXIO);
24722 }
24723
24724 #ifdef _MULTI_DATAMODEL
24725
24726 switch (ddi_model_convert_from(flag & FMODELS)) {
24727 case DDI_MODEL_ILP32: {
24728 struct mhioc_inresvs32 inresvs32;
24729
24730 if (ddi_copyin(arg, &inresvs32,
24731 sizeof (struct mhioc_inresvs32), flag) != 0) {
24732 return (EFAULT);
24733 }
24734 inresvs.li = (mhioc_resv_desc_list_t *)(uintptr_t)inresvs32.li;
24735 if ((rval = sd_persistent_reservation_in_read_resv(un,
24736 &inresvs, flag)) != 0) {
24737 return (rval);
24738 }
24739 inresvs32.generation = inresvs.generation;
24740 if (ddi_copyout(&inresvs32, arg,
24741 sizeof (struct mhioc_inresvs32), flag) != 0) {
24742 return (EFAULT);
24743 }
24744 break;
24745 }
24746 case DDI_MODEL_NONE:
24747 if (ddi_copyin(arg, &inresvs,
24748 sizeof (mhioc_inresvs_t), flag) != 0) {
24749 return (EFAULT);
24750 }
24751 if ((rval = sd_persistent_reservation_in_read_resv(un,
24752 &inresvs, flag)) != 0) {
24753 return (rval);
24754 }
24755 if (ddi_copyout(&inresvs, arg,
24756 sizeof (mhioc_inresvs_t), flag) != 0) {
24757 return (EFAULT);
24758 }
24759 break;
24760 }
24761
24762 #else /* ! _MULTI_DATAMODEL */
24763
24764 if (ddi_copyin(arg, &inresvs, sizeof (mhioc_inresvs_t), flag) != 0) {
24765 return (EFAULT);
24766 }
24767 rval = sd_persistent_reservation_in_read_resv(un, &inresvs, flag);
24768 if (rval != 0) {
24769 return (rval);
24770 }
24771 if (ddi_copyout(&inresvs, arg, sizeof (mhioc_inresvs_t), flag)) {
24772 return (EFAULT);
24773 }
24774
24775 #endif /* ! _MULTI_DATAMODEL */
24776
24777 return (rval);
24778 }
24779
24780
24781 /*
24782 * The following routines support the clustering functionality described below
24783 * and implement lost reservation reclaim functionality.
24784 *
24785 * Clustering
24786 * ----------
24787 * The clustering code uses two different, independent forms of SCSI
24788 * reservation. Traditional SCSI-2 Reserve/Release and the newer SCSI-3
24789 * Persistent Group Reservations. For any particular disk, it will use either
24790 * SCSI-2 or SCSI-3 PGR but never both at the same time for the same disk.
24791 *
24792 * SCSI-2
24793 * The cluster software takes ownership of a multi-hosted disk by issuing the
24794 * MHIOCTKOWN ioctl to the disk driver. It releases ownership by issuing the
24795 * MHIOCRELEASE ioctl. Closely related is the MHIOCENFAILFAST ioctl -- a
24796 * cluster, just after taking ownership of the disk with the MHIOCTKOWN ioctl
24797 * then issues the MHIOCENFAILFAST ioctl. This ioctl "enables failfast" in the
24798 * driver. The meaning of failfast is that if the driver (on this host) ever
24799 * encounters the scsi error return code RESERVATION_CONFLICT from the device,
24800 * it should immediately panic the host. The motivation for this ioctl is that
24801 * if this host does encounter reservation conflict, the underlying cause is
24802 * that some other host of the cluster has decided that this host is no longer
24803 * in the cluster and has seized control of the disks for itself. Since this
24804 * host is no longer in the cluster, it ought to panic itself. The
24805 * MHIOCENFAILFAST ioctl does two things:
24806 * (a) it sets a flag that will cause any returned RESERVATION_CONFLICT
24807 * error to panic the host
24808 * (b) it sets up a periodic timer to test whether this host still has
24809 * "access" (in that no other host has reserved the device): if the
24810 * periodic timer gets RESERVATION_CONFLICT, the host is panicked. The
24811 * purpose of that periodic timer is to handle scenarios where the host is
24812 * otherwise temporarily quiescent, temporarily doing no real i/o.
24813 * The MHIOCTKOWN ioctl will "break" a reservation that is held by another host,
24814 * by issuing a SCSI Bus Device Reset. It will then issue a SCSI Reserve for
24815 * the device itself.
24816 *
24817 * SCSI-3 PGR
24818 * A direct semantic implementation of the SCSI-3 Persistent Reservation
24819 * facility is supported through the shared multihost disk ioctls
24820 * (MHIOCGRP_INKEYS, MHIOCGRP_INRESV, MHIOCGRP_REGISTER, MHIOCGRP_RESERVE,
24821 * MHIOCGRP_PREEMPTANDABORT, MHIOCGRP_CLEAR)
24822 *
24823 * Reservation Reclaim:
24824 * --------------------
24825 * To support the lost reservation reclaim operations this driver creates a
24826 * single thread to handle reinstating reservations on all devices that have
24827 * lost reservations sd_resv_reclaim_requests are logged for all devices that
24828 * have LOST RESERVATIONS when the scsi watch facility callsback sd_mhd_watch_cb
24829 * and the reservation reclaim thread loops through the requests to regain the
24830 * lost reservations.
24831 */
24832
24833 /*
24834 * Function: sd_check_mhd()
24835 *
24836 * Description: This function sets up and submits a scsi watch request or
24837 * terminates an existing watch request. This routine is used in
24838 * support of reservation reclaim.
24839 *
24840 * Arguments: dev - the device 'dev_t' is used for context to discriminate
24841 * among multiple watches that share the callback function
24842 * interval - the number of microseconds specifying the watch
24843 * interval for issuing TEST UNIT READY commands. If
24844 * set to 0 the watch should be terminated. If the
24845 * interval is set to 0 and if the device is required
24846 * to hold reservation while disabling failfast, the
24847 * watch is restarted with an interval of
24848 * reinstate_resv_delay.
24849 *
24850 * Return Code: 0 - Successful submit/terminate of scsi watch request
24851 * ENXIO - Indicates an invalid device was specified
24852 * EAGAIN - Unable to submit the scsi watch request
24853 */
24854
24855 static int
24856 sd_check_mhd(dev_t dev, int interval)
24857 {
24858 struct sd_lun *un;
24859 opaque_t token;
24860
24861 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
24862 return (ENXIO);
24863 }
24864
24865 /* is this a watch termination request? */
24866 if (interval == 0) {
24867 mutex_enter(SD_MUTEX(un));
24868 /* if there is an existing watch task then terminate it */
24869 if (un->un_mhd_token) {
24870 token = un->un_mhd_token;
24871 un->un_mhd_token = NULL;
24872 mutex_exit(SD_MUTEX(un));
24873 (void) scsi_watch_request_terminate(token,
24874 SCSI_WATCH_TERMINATE_ALL_WAIT);
24875 mutex_enter(SD_MUTEX(un));
24876 } else {
24877 mutex_exit(SD_MUTEX(un));
24878 /*
24879 * Note: If we return here we don't check for the
24880 * failfast case. This is the original legacy
24881 * implementation but perhaps we should be checking
24882 * the failfast case.
24883 */
24884 return (0);
24885 }
24886 /*
24887 * If the device is required to hold reservation while
24888 * disabling failfast, we need to restart the scsi_watch
24889 * routine with an interval of reinstate_resv_delay.
24890 */
24891 if (un->un_resvd_status & SD_RESERVE) {
24892 interval = sd_reinstate_resv_delay/1000;
24893 } else {
24894 /* no failfast so bail */
24895 mutex_exit(SD_MUTEX(un));
24896 return (0);
24897 }
24898 mutex_exit(SD_MUTEX(un));
24899 }
24900
24901 /*
24902 * adjust minimum time interval to 1 second,
24903 * and convert from msecs to usecs
24904 */
24905 if (interval > 0 && interval < 1000) {
24906 interval = 1000;
24907 }
24908 interval *= 1000;
24909
24910 /*
24911 * submit the request to the scsi_watch service
24912 */
24913 token = scsi_watch_request_submit(SD_SCSI_DEVP(un), interval,
24914 SENSE_LENGTH, sd_mhd_watch_cb, (caddr_t)dev);
24915 if (token == NULL) {
24916 return (EAGAIN);
24917 }
24918
24919 /*
24920 * save token for termination later on
24921 */
24922 mutex_enter(SD_MUTEX(un));
24923 un->un_mhd_token = token;
24924 mutex_exit(SD_MUTEX(un));
24925 return (0);
24926 }
24927
24928
24929 /*
24930 * Function: sd_mhd_watch_cb()
24931 *
24932 * Description: This function is the call back function used by the scsi watch
24933 * facility. The scsi watch facility sends the "Test Unit Ready"
24934 * and processes the status. If applicable (i.e. a "Unit Attention"
24935 * status and automatic "Request Sense" not used) the scsi watch
24936 * facility will send a "Request Sense" and retrieve the sense data
24937 * to be passed to this callback function. In either case the
24938 * automatic "Request Sense" or the facility submitting one, this
24939 * callback is passed the status and sense data.
24940 *
24941 * Arguments: arg - the device 'dev_t' is used for context to discriminate
24942 * among multiple watches that share this callback function
24943 * resultp - scsi watch facility result packet containing scsi
24944 * packet, status byte and sense data
24945 *
24946 * Return Code: 0 - continue the watch task
24947 * non-zero - terminate the watch task
24948 */
24949
24950 static int
24951 sd_mhd_watch_cb(caddr_t arg, struct scsi_watch_result *resultp)
24952 {
24953 struct sd_lun *un;
24954 struct scsi_status *statusp;
24955 uint8_t *sensep;
24956 struct scsi_pkt *pkt;
24957 uchar_t actual_sense_length;
24958 dev_t dev = (dev_t)arg;
24959
24960 ASSERT(resultp != NULL);
24961 statusp = resultp->statusp;
24962 sensep = (uint8_t *)resultp->sensep;
24963 pkt = resultp->pkt;
24964 actual_sense_length = resultp->actual_sense_length;
24965
24966 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
24967 return (ENXIO);
24968 }
24969
24970 SD_TRACE(SD_LOG_IOCTL_MHD, un,
24971 "sd_mhd_watch_cb: reason '%s', status '%s'\n",
24972 scsi_rname(pkt->pkt_reason), sd_sname(*((unsigned char *)statusp)));
24973
24974 /* Begin processing of the status and/or sense data */
24975 if (pkt->pkt_reason != CMD_CMPLT) {
24976 /* Handle the incomplete packet */
24977 sd_mhd_watch_incomplete(un, pkt);
24978 return (0);
24979 } else if (*((unsigned char *)statusp) != STATUS_GOOD) {
24980 if (*((unsigned char *)statusp)
24981 == STATUS_RESERVATION_CONFLICT) {
24982 /*
24983 * Handle a reservation conflict by panicking if
24984 * configured for failfast or by logging the conflict
24985 * and updating the reservation status
24986 */
24987 mutex_enter(SD_MUTEX(un));
24988 if ((un->un_resvd_status & SD_FAILFAST) &&
24989 (sd_failfast_enable)) {
24990 sd_panic_for_res_conflict(un);
24991 /*NOTREACHED*/
24992 }
24993 SD_INFO(SD_LOG_IOCTL_MHD, un,
24994 "sd_mhd_watch_cb: Reservation Conflict\n");
24995 un->un_resvd_status |= SD_RESERVATION_CONFLICT;
24996 mutex_exit(SD_MUTEX(un));
24997 }
24998 }
24999
25000 if (sensep != NULL) {
25001 if (actual_sense_length >= (SENSE_LENGTH - 2)) {
25002 mutex_enter(SD_MUTEX(un));
25003 if ((scsi_sense_asc(sensep) ==
25004 SD_SCSI_RESET_SENSE_CODE) &&
25005 (un->un_resvd_status & SD_RESERVE)) {
25006 /*
25007 * The additional sense code indicates a power
25008 * on or bus device reset has occurred; update
25009 * the reservation status.
25010 */
25011 un->un_resvd_status |=
25012 (SD_LOST_RESERVE | SD_WANT_RESERVE);
25013 SD_INFO(SD_LOG_IOCTL_MHD, un,
25014 "sd_mhd_watch_cb: Lost Reservation\n");
25015 }
25016 } else {
25017 return (0);
25018 }
25019 } else {
25020 mutex_enter(SD_MUTEX(un));
25021 }
25022
25023 if ((un->un_resvd_status & SD_RESERVE) &&
25024 (un->un_resvd_status & SD_LOST_RESERVE)) {
25025 if (un->un_resvd_status & SD_WANT_RESERVE) {
25026 /*
25027 * A reset occurred in between the last probe and this
25028 * one so if a timeout is pending cancel it.
25029 */
25030 if (un->un_resvd_timeid) {
25031 timeout_id_t temp_id = un->un_resvd_timeid;
25032 un->un_resvd_timeid = NULL;
25033 mutex_exit(SD_MUTEX(un));
25034 (void) untimeout(temp_id);
25035 mutex_enter(SD_MUTEX(un));
25036 }
25037 un->un_resvd_status &= ~SD_WANT_RESERVE;
25038 }
25039 if (un->un_resvd_timeid == 0) {
25040 /* Schedule a timeout to handle the lost reservation */
25041 un->un_resvd_timeid = timeout(sd_mhd_resvd_recover,
25042 (void *)dev,
25043 drv_usectohz(sd_reinstate_resv_delay));
25044 }
25045 }
25046 mutex_exit(SD_MUTEX(un));
25047 return (0);
25048 }
25049
25050
25051 /*
25052 * Function: sd_mhd_watch_incomplete()
25053 *
25054 * Description: This function is used to find out why a scsi pkt sent by the
25055 * scsi watch facility was not completed. Under some scenarios this
25056 * routine will return. Otherwise it will send a bus reset to see
25057 * if the drive is still online.
25058 *
25059 * Arguments: un - driver soft state (unit) structure
25060 * pkt - incomplete scsi pkt
25061 */
25062
25063 static void
25064 sd_mhd_watch_incomplete(struct sd_lun *un, struct scsi_pkt *pkt)
25065 {
25066 int be_chatty;
25067 int perr;
25068
25069 ASSERT(pkt != NULL);
25070 ASSERT(un != NULL);
25071 be_chatty = (!(pkt->pkt_flags & FLAG_SILENT));
25072 perr = (pkt->pkt_statistics & STAT_PERR);
25073
25074 mutex_enter(SD_MUTEX(un));
25075 if (un->un_state == SD_STATE_DUMPING) {
25076 mutex_exit(SD_MUTEX(un));
25077 return;
25078 }
25079
25080 switch (pkt->pkt_reason) {
25081 case CMD_UNX_BUS_FREE:
25082 /*
25083 * If we had a parity error that caused the target to drop BSY*,
25084 * don't be chatty about it.
25085 */
25086 if (perr && be_chatty) {
25087 be_chatty = 0;
25088 }
25089 break;
25090 case CMD_TAG_REJECT:
25091 /*
25092 * The SCSI-2 spec states that a tag reject will be sent by the
25093 * target if tagged queuing is not supported. A tag reject may
25094 * also be sent during certain initialization periods or to
25095 * control internal resources. For the latter case the target
25096 * may also return Queue Full.
25097 *
25098 * If this driver receives a tag reject from a target that is
25099 * going through an init period or controlling internal
25100 * resources tagged queuing will be disabled. This is a less
25101 * than optimal behavior but the driver is unable to determine
25102 * the target state and assumes tagged queueing is not supported
25103 */
25104 pkt->pkt_flags = 0;
25105 un->un_tagflags = 0;
25106
25107 if (un->un_f_opt_queueing == TRUE) {
25108 un->un_throttle = min(un->un_throttle, 3);
25109 } else {
25110 un->un_throttle = 1;
25111 }
25112 mutex_exit(SD_MUTEX(un));
25113 (void) scsi_ifsetcap(SD_ADDRESS(un), "tagged-qing", 0, 1);
25114 mutex_enter(SD_MUTEX(un));
25115 break;
25116 case CMD_INCOMPLETE:
25117 /*
25118 * The transport stopped with an abnormal state, fallthrough and
25119 * reset the target and/or bus unless selection did not complete
25120 * (indicated by STATE_GOT_BUS) in which case we don't want to
25121 * go through a target/bus reset
25122 */
25123 if (pkt->pkt_state == STATE_GOT_BUS) {
25124 break;
25125 }
25126 /*FALLTHROUGH*/
25127
25128 case CMD_TIMEOUT:
25129 default:
25130 /*
25131 * The lun may still be running the command, so a lun reset
25132 * should be attempted. If the lun reset fails or cannot be
25133 * issued, than try a target reset. Lastly try a bus reset.
25134 */
25135 if ((pkt->pkt_statistics &
25136 (STAT_BUS_RESET|STAT_DEV_RESET|STAT_ABORTED)) == 0) {
25137 int reset_retval = 0;
25138 mutex_exit(SD_MUTEX(un));
25139 if (un->un_f_allow_bus_device_reset == TRUE) {
25140 if (un->un_f_lun_reset_enabled == TRUE) {
25141 reset_retval =
25142 scsi_reset(SD_ADDRESS(un),
25143 RESET_LUN);
25144 }
25145 if (reset_retval == 0) {
25146 reset_retval =
25147 scsi_reset(SD_ADDRESS(un),
25148 RESET_TARGET);
25149 }
25150 }
25151 if (reset_retval == 0) {
25152 (void) scsi_reset(SD_ADDRESS(un), RESET_ALL);
25153 }
25154 mutex_enter(SD_MUTEX(un));
25155 }
25156 break;
25157 }
25158
25159 /* A device/bus reset has occurred; update the reservation status. */
25160 if ((pkt->pkt_reason == CMD_RESET) || (pkt->pkt_statistics &
25161 (STAT_BUS_RESET | STAT_DEV_RESET))) {
25162 if ((un->un_resvd_status & SD_RESERVE) == SD_RESERVE) {
25163 un->un_resvd_status |=
25164 (SD_LOST_RESERVE | SD_WANT_RESERVE);
25165 SD_INFO(SD_LOG_IOCTL_MHD, un,
25166 "sd_mhd_watch_incomplete: Lost Reservation\n");
25167 }
25168 }
25169
25170 /*
25171 * The disk has been turned off; Update the device state.
25172 *
25173 * Note: Should we be offlining the disk here?
25174 */
25175 if (pkt->pkt_state == STATE_GOT_BUS) {
25176 SD_INFO(SD_LOG_IOCTL_MHD, un, "sd_mhd_watch_incomplete: "
25177 "Disk not responding to selection\n");
25178 if (un->un_state != SD_STATE_OFFLINE) {
25179 New_state(un, SD_STATE_OFFLINE);
25180 }
25181 } else if (be_chatty) {
25182 /*
25183 * suppress messages if they are all the same pkt reason;
25184 * with TQ, many (up to 256) are returned with the same
25185 * pkt_reason
25186 */
25187 if (pkt->pkt_reason != un->un_last_pkt_reason) {
25188 SD_ERROR(SD_LOG_IOCTL_MHD, un,
25189 "sd_mhd_watch_incomplete: "
25190 "SCSI transport failed: reason '%s'\n",
25191 scsi_rname(pkt->pkt_reason));
25192 }
25193 }
25194 un->un_last_pkt_reason = pkt->pkt_reason;
25195 mutex_exit(SD_MUTEX(un));
25196 }
25197
25198
25199 /*
25200 * Function: sd_sname()
25201 *
25202 * Description: This is a simple little routine to return a string containing
25203 * a printable description of command status byte for use in
25204 * logging.
25205 *
25206 * Arguments: status - pointer to a status byte
25207 *
25208 * Return Code: char * - string containing status description.
25209 */
25210
25211 static char *
25212 sd_sname(uchar_t status)
25213 {
25214 switch (status & STATUS_MASK) {
25215 case STATUS_GOOD:
25216 return ("good status");
25217 case STATUS_CHECK:
25218 return ("check condition");
25219 case STATUS_MET:
25220 return ("condition met");
25221 case STATUS_BUSY:
25222 return ("busy");
25223 case STATUS_INTERMEDIATE:
25224 return ("intermediate");
25225 case STATUS_INTERMEDIATE_MET:
25226 return ("intermediate - condition met");
25227 case STATUS_RESERVATION_CONFLICT:
25228 return ("reservation_conflict");
25229 case STATUS_TERMINATED:
25230 return ("command terminated");
25231 case STATUS_QFULL:
25232 return ("queue full");
25233 default:
25234 return ("<unknown status>");
25235 }
25236 }
25237
25238
25239 /*
25240 * Function: sd_mhd_resvd_recover()
25241 *
25242 * Description: This function adds a reservation entry to the
25243 * sd_resv_reclaim_request list and signals the reservation
25244 * reclaim thread that there is work pending. If the reservation
25245 * reclaim thread has not been previously created this function
25246 * will kick it off.
25247 *
25248 * Arguments: arg - the device 'dev_t' is used for context to discriminate
25249 * among multiple watches that share this callback function
25250 *
25251 * Context: This routine is called by timeout() and is run in interrupt
25252 * context. It must not sleep or call other functions which may
25253 * sleep.
25254 */
25255
25256 static void
25257 sd_mhd_resvd_recover(void *arg)
25258 {
25259 dev_t dev = (dev_t)arg;
25260 struct sd_lun *un;
25261 struct sd_thr_request *sd_treq = NULL;
25262 struct sd_thr_request *sd_cur = NULL;
25263 struct sd_thr_request *sd_prev = NULL;
25264 int already_there = 0;
25265
25266 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
25267 return;
25268 }
25269
25270 mutex_enter(SD_MUTEX(un));
25271 un->un_resvd_timeid = NULL;
25272 if (un->un_resvd_status & SD_WANT_RESERVE) {
25273 /*
25274 * There was a reset so don't issue the reserve, allow the
25275 * sd_mhd_watch_cb callback function to notice this and
25276 * reschedule the timeout for reservation.
25277 */
25278 mutex_exit(SD_MUTEX(un));
25279 return;
25280 }
25281 mutex_exit(SD_MUTEX(un));
25282
25283 /*
25284 * Add this device to the sd_resv_reclaim_request list and the
25285 * sd_resv_reclaim_thread should take care of the rest.
25286 *
25287 * Note: We can't sleep in this context so if the memory allocation
25288 * fails allow the sd_mhd_watch_cb callback function to notice this and
25289 * reschedule the timeout for reservation. (4378460)
25290 */
25291 sd_treq = (struct sd_thr_request *)
25292 kmem_zalloc(sizeof (struct sd_thr_request), KM_NOSLEEP);
25293 if (sd_treq == NULL) {
25294 return;
25295 }
25296
25297 sd_treq->sd_thr_req_next = NULL;
25298 sd_treq->dev = dev;
25299 mutex_enter(&sd_tr.srq_resv_reclaim_mutex);
25300 if (sd_tr.srq_thr_req_head == NULL) {
25301 sd_tr.srq_thr_req_head = sd_treq;
25302 } else {
25303 sd_cur = sd_prev = sd_tr.srq_thr_req_head;
25304 for (; sd_cur != NULL; sd_cur = sd_cur->sd_thr_req_next) {
25305 if (sd_cur->dev == dev) {
25306 /*
25307 * already in Queue so don't log
25308 * another request for the device
25309 */
25310 already_there = 1;
25311 break;
25312 }
25313 sd_prev = sd_cur;
25314 }
25315 if (!already_there) {
25316 SD_INFO(SD_LOG_IOCTL_MHD, un, "sd_mhd_resvd_recover: "
25317 "logging request for %lx\n", dev);
25318 sd_prev->sd_thr_req_next = sd_treq;
25319 } else {
25320 kmem_free(sd_treq, sizeof (struct sd_thr_request));
25321 }
25322 }
25323
25324 /*
25325 * Create a kernel thread to do the reservation reclaim and free up this
25326 * thread. We cannot block this thread while we go away to do the
25327 * reservation reclaim
25328 */
25329 if (sd_tr.srq_resv_reclaim_thread == NULL)
25330 sd_tr.srq_resv_reclaim_thread = thread_create(NULL, 0,
25331 sd_resv_reclaim_thread, NULL,
25332 0, &p0, TS_RUN, v.v_maxsyspri - 2);
25333
25334 /* Tell the reservation reclaim thread that it has work to do */
25335 cv_signal(&sd_tr.srq_resv_reclaim_cv);
25336 mutex_exit(&sd_tr.srq_resv_reclaim_mutex);
25337 }
25338
25339 /*
25340 * Function: sd_resv_reclaim_thread()
25341 *
25342 * Description: This function implements the reservation reclaim operations
25343 *
25344 * Arguments: arg - the device 'dev_t' is used for context to discriminate
25345 * among multiple watches that share this callback function
25346 */
25347
25348 static void
25349 sd_resv_reclaim_thread()
25350 {
25351 struct sd_lun *un;
25352 struct sd_thr_request *sd_mhreq;
25353
25354 /* Wait for work */
25355 mutex_enter(&sd_tr.srq_resv_reclaim_mutex);
25356 if (sd_tr.srq_thr_req_head == NULL) {
25357 cv_wait(&sd_tr.srq_resv_reclaim_cv,
25358 &sd_tr.srq_resv_reclaim_mutex);
25359 }
25360
25361 /* Loop while we have work */
25362 while ((sd_tr.srq_thr_cur_req = sd_tr.srq_thr_req_head) != NULL) {
25363 un = ddi_get_soft_state(sd_state,
25364 SDUNIT(sd_tr.srq_thr_cur_req->dev));
25365 if (un == NULL) {
25366 /*
25367 * softstate structure is NULL so just
25368 * dequeue the request and continue
25369 */
25370 sd_tr.srq_thr_req_head =
25371 sd_tr.srq_thr_cur_req->sd_thr_req_next;
25372 kmem_free(sd_tr.srq_thr_cur_req,
25373 sizeof (struct sd_thr_request));
25374 continue;
25375 }
25376
25377 /* dequeue the request */
25378 sd_mhreq = sd_tr.srq_thr_cur_req;
25379 sd_tr.srq_thr_req_head =
25380 sd_tr.srq_thr_cur_req->sd_thr_req_next;
25381 mutex_exit(&sd_tr.srq_resv_reclaim_mutex);
25382
25383 /*
25384 * Reclaim reservation only if SD_RESERVE is still set. There
25385 * may have been a call to MHIOCRELEASE before we got here.
25386 */
25387 mutex_enter(SD_MUTEX(un));
25388 if ((un->un_resvd_status & SD_RESERVE) == SD_RESERVE) {
25389 /*
25390 * Note: The SD_LOST_RESERVE flag is cleared before
25391 * reclaiming the reservation. If this is done after the
25392 * call to sd_reserve_release a reservation loss in the
25393 * window between pkt completion of reserve cmd and
25394 * mutex_enter below may not be recognized
25395 */
25396 un->un_resvd_status &= ~SD_LOST_RESERVE;
25397 mutex_exit(SD_MUTEX(un));
25398
25399 if (sd_reserve_release(sd_mhreq->dev,
25400 SD_RESERVE) == 0) {
25401 mutex_enter(SD_MUTEX(un));
25402 un->un_resvd_status |= SD_RESERVE;
25403 mutex_exit(SD_MUTEX(un));
25404 SD_INFO(SD_LOG_IOCTL_MHD, un,
25405 "sd_resv_reclaim_thread: "
25406 "Reservation Recovered\n");
25407 } else {
25408 mutex_enter(SD_MUTEX(un));
25409 un->un_resvd_status |= SD_LOST_RESERVE;
25410 mutex_exit(SD_MUTEX(un));
25411 SD_INFO(SD_LOG_IOCTL_MHD, un,
25412 "sd_resv_reclaim_thread: Failed "
25413 "Reservation Recovery\n");
25414 }
25415 } else {
25416 mutex_exit(SD_MUTEX(un));
25417 }
25418 mutex_enter(&sd_tr.srq_resv_reclaim_mutex);
25419 ASSERT(sd_mhreq == sd_tr.srq_thr_cur_req);
25420 kmem_free(sd_mhreq, sizeof (struct sd_thr_request));
25421 sd_mhreq = sd_tr.srq_thr_cur_req = NULL;
25422 /*
25423 * wakeup the destroy thread if anyone is waiting on
25424 * us to complete.
25425 */
25426 cv_signal(&sd_tr.srq_inprocess_cv);
25427 SD_TRACE(SD_LOG_IOCTL_MHD, un,
25428 "sd_resv_reclaim_thread: cv_signalling current request \n");
25429 }
25430
25431 /*
25432 * cleanup the sd_tr structure now that this thread will not exist
25433 */
25434 ASSERT(sd_tr.srq_thr_req_head == NULL);
25435 ASSERT(sd_tr.srq_thr_cur_req == NULL);
25436 sd_tr.srq_resv_reclaim_thread = NULL;
25437 mutex_exit(&sd_tr.srq_resv_reclaim_mutex);
25438 thread_exit();
25439 }
25440
25441
25442 /*
25443 * Function: sd_rmv_resv_reclaim_req()
25444 *
25445 * Description: This function removes any pending reservation reclaim requests
25446 * for the specified device.
25447 *
25448 * Arguments: dev - the device 'dev_t'
25449 */
25450
25451 static void
25452 sd_rmv_resv_reclaim_req(dev_t dev)
25453 {
25454 struct sd_thr_request *sd_mhreq;
25455 struct sd_thr_request *sd_prev;
25456
25457 /* Remove a reservation reclaim request from the list */
25458 mutex_enter(&sd_tr.srq_resv_reclaim_mutex);
25459 if (sd_tr.srq_thr_cur_req && sd_tr.srq_thr_cur_req->dev == dev) {
25460 /*
25461 * We are attempting to reinstate reservation for
25462 * this device. We wait for sd_reserve_release()
25463 * to return before we return.
25464 */
25465 cv_wait(&sd_tr.srq_inprocess_cv,
25466 &sd_tr.srq_resv_reclaim_mutex);
25467 } else {
25468 sd_prev = sd_mhreq = sd_tr.srq_thr_req_head;
25469 if (sd_mhreq && sd_mhreq->dev == dev) {
25470 sd_tr.srq_thr_req_head = sd_mhreq->sd_thr_req_next;
25471 kmem_free(sd_mhreq, sizeof (struct sd_thr_request));
25472 mutex_exit(&sd_tr.srq_resv_reclaim_mutex);
25473 return;
25474 }
25475 for (; sd_mhreq != NULL; sd_mhreq = sd_mhreq->sd_thr_req_next) {
25476 if (sd_mhreq && sd_mhreq->dev == dev) {
25477 break;
25478 }
25479 sd_prev = sd_mhreq;
25480 }
25481 if (sd_mhreq != NULL) {
25482 sd_prev->sd_thr_req_next = sd_mhreq->sd_thr_req_next;
25483 kmem_free(sd_mhreq, sizeof (struct sd_thr_request));
25484 }
25485 }
25486 mutex_exit(&sd_tr.srq_resv_reclaim_mutex);
25487 }
25488
25489
25490 /*
25491 * Function: sd_mhd_reset_notify_cb()
25492 *
25493 * Description: This is a call back function for scsi_reset_notify. This
25494 * function updates the softstate reserved status and logs the
25495 * reset. The driver scsi watch facility callback function
25496 * (sd_mhd_watch_cb) and reservation reclaim thread functionality
25497 * will reclaim the reservation.
25498 *
25499 * Arguments: arg - driver soft state (unit) structure
25500 */
25501
25502 static void
25503 sd_mhd_reset_notify_cb(caddr_t arg)
25504 {
25505 struct sd_lun *un = (struct sd_lun *)arg;
25506
25507 mutex_enter(SD_MUTEX(un));
25508 if ((un->un_resvd_status & SD_RESERVE) == SD_RESERVE) {
25509 un->un_resvd_status |= (SD_LOST_RESERVE | SD_WANT_RESERVE);
25510 SD_INFO(SD_LOG_IOCTL_MHD, un,
25511 "sd_mhd_reset_notify_cb: Lost Reservation\n");
25512 }
25513 mutex_exit(SD_MUTEX(un));
25514 }
25515
25516
25517 /*
25518 * Function: sd_take_ownership()
25519 *
25520 * Description: This routine implements an algorithm to achieve a stable
25521 * reservation on disks which don't implement priority reserve,
25522 * and makes sure that other host lose re-reservation attempts.
25523 * This algorithm contains of a loop that keeps issuing the RESERVE
25524 * for some period of time (min_ownership_delay, default 6 seconds)
25525 * During that loop, it looks to see if there has been a bus device
25526 * reset or bus reset (both of which cause an existing reservation
25527 * to be lost). If the reservation is lost issue RESERVE until a
25528 * period of min_ownership_delay with no resets has gone by, or
25529 * until max_ownership_delay has expired. This loop ensures that
25530 * the host really did manage to reserve the device, in spite of
25531 * resets. The looping for min_ownership_delay (default six
25532 * seconds) is important to early generation clustering products,
25533 * Solstice HA 1.x and Sun Cluster 2.x. Those products use an
25534 * MHIOCENFAILFAST periodic timer of two seconds. By having
25535 * MHIOCTKOWN issue Reserves in a loop for six seconds, and having
25536 * MHIOCENFAILFAST poll every two seconds, the idea is that by the
25537 * time the MHIOCTKOWN ioctl returns, the other host (if any) will
25538 * have already noticed, via the MHIOCENFAILFAST polling, that it
25539 * no longer "owns" the disk and will have panicked itself. Thus,
25540 * the host issuing the MHIOCTKOWN is assured (with timing
25541 * dependencies) that by the time it actually starts to use the
25542 * disk for real work, the old owner is no longer accessing it.
25543 *
25544 * min_ownership_delay is the minimum amount of time for which the
25545 * disk must be reserved continuously devoid of resets before the
25546 * MHIOCTKOWN ioctl will return success.
25547 *
25548 * max_ownership_delay indicates the amount of time by which the
25549 * take ownership should succeed or timeout with an error.
25550 *
25551 * Arguments: dev - the device 'dev_t'
25552 * *p - struct containing timing info.
25553 *
25554 * Return Code: 0 for success or error code
25555 */
25556
25557 static int
25558 sd_take_ownership(dev_t dev, struct mhioctkown *p)
25559 {
25560 struct sd_lun *un;
25561 int rval;
25562 int err;
25563 int reservation_count = 0;
25564 int min_ownership_delay = 6000000; /* in usec */
25565 int max_ownership_delay = 30000000; /* in usec */
25566 clock_t start_time; /* starting time of this algorithm */
25567 clock_t end_time; /* time limit for giving up */
25568 clock_t ownership_time; /* time limit for stable ownership */
25569 clock_t current_time;
25570 clock_t previous_current_time;
25571
25572 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
25573 return (ENXIO);
25574 }
25575
25576 /*
25577 * Attempt a device reservation. A priority reservation is requested.
25578 */
25579 if ((rval = sd_reserve_release(dev, SD_PRIORITY_RESERVE))
25580 != SD_SUCCESS) {
25581 SD_ERROR(SD_LOG_IOCTL_MHD, un,
25582 "sd_take_ownership: return(1)=%d\n", rval);
25583 return (rval);
25584 }
25585
25586 /* Update the softstate reserved status to indicate the reservation */
25587 mutex_enter(SD_MUTEX(un));
25588 un->un_resvd_status |= SD_RESERVE;
25589 un->un_resvd_status &=
25590 ~(SD_LOST_RESERVE | SD_WANT_RESERVE | SD_RESERVATION_CONFLICT);
25591 mutex_exit(SD_MUTEX(un));
25592
25593 if (p != NULL) {
25594 if (p->min_ownership_delay != 0) {
25595 min_ownership_delay = p->min_ownership_delay * 1000;
25596 }
25597 if (p->max_ownership_delay != 0) {
25598 max_ownership_delay = p->max_ownership_delay * 1000;
25599 }
25600 }
25601 SD_INFO(SD_LOG_IOCTL_MHD, un,
25602 "sd_take_ownership: min, max delays: %d, %d\n",
25603 min_ownership_delay, max_ownership_delay);
25604
25605 start_time = ddi_get_lbolt();
25606 current_time = start_time;
25607 ownership_time = current_time + drv_usectohz(min_ownership_delay);
25608 end_time = start_time + drv_usectohz(max_ownership_delay);
25609
25610 while (current_time - end_time < 0) {
25611 delay(drv_usectohz(500000));
25612
25613 if ((err = sd_reserve_release(dev, SD_RESERVE)) != 0) {
25614 if ((sd_reserve_release(dev, SD_RESERVE)) != 0) {
25615 mutex_enter(SD_MUTEX(un));
25616 rval = (un->un_resvd_status &
25617 SD_RESERVATION_CONFLICT) ? EACCES : EIO;
25618 mutex_exit(SD_MUTEX(un));
25619 break;
25620 }
25621 }
25622 previous_current_time = current_time;
25623 current_time = ddi_get_lbolt();
25624 mutex_enter(SD_MUTEX(un));
25625 if (err || (un->un_resvd_status & SD_LOST_RESERVE)) {
25626 ownership_time = ddi_get_lbolt() +
25627 drv_usectohz(min_ownership_delay);
25628 reservation_count = 0;
25629 } else {
25630 reservation_count++;
25631 }
25632 un->un_resvd_status |= SD_RESERVE;
25633 un->un_resvd_status &= ~(SD_LOST_RESERVE | SD_WANT_RESERVE);
25634 mutex_exit(SD_MUTEX(un));
25635
25636 SD_INFO(SD_LOG_IOCTL_MHD, un,
25637 "sd_take_ownership: ticks for loop iteration=%ld, "
25638 "reservation=%s\n", (current_time - previous_current_time),
25639 reservation_count ? "ok" : "reclaimed");
25640
25641 if (current_time - ownership_time >= 0 &&
25642 reservation_count >= 4) {
25643 rval = 0; /* Achieved a stable ownership */
25644 break;
25645 }
25646 if (current_time - end_time >= 0) {
25647 rval = EACCES; /* No ownership in max possible time */
25648 break;
25649 }
25650 }
25651 SD_TRACE(SD_LOG_IOCTL_MHD, un,
25652 "sd_take_ownership: return(2)=%d\n", rval);
25653 return (rval);
25654 }
25655
25656
25657 /*
25658 * Function: sd_reserve_release()
25659 *
25660 * Description: This function builds and sends scsi RESERVE, RELEASE, and
25661 * PRIORITY RESERVE commands based on a user specified command type
25662 *
25663 * Arguments: dev - the device 'dev_t'
25664 * cmd - user specified command type; one of SD_PRIORITY_RESERVE,
25665 * SD_RESERVE, SD_RELEASE
25666 *
25667 * Return Code: 0 or Error Code
25668 */
25669
25670 static int
25671 sd_reserve_release(dev_t dev, int cmd)
25672 {
25673 struct uscsi_cmd *com = NULL;
25674 struct sd_lun *un = NULL;
25675 char cdb[CDB_GROUP0];
25676 int rval;
25677
25678 ASSERT((cmd == SD_RELEASE) || (cmd == SD_RESERVE) ||
25679 (cmd == SD_PRIORITY_RESERVE));
25680
25681 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
25682 return (ENXIO);
25683 }
25684
25685 /* instantiate and initialize the command and cdb */
25686 com = kmem_zalloc(sizeof (*com), KM_SLEEP);
25687 bzero(cdb, CDB_GROUP0);
25688 com->uscsi_flags = USCSI_SILENT;
25689 com->uscsi_timeout = un->un_reserve_release_time;
25690 com->uscsi_cdblen = CDB_GROUP0;
25691 com->uscsi_cdb = cdb;
25692 if (cmd == SD_RELEASE) {
25693 cdb[0] = SCMD_RELEASE;
25694 } else {
25695 cdb[0] = SCMD_RESERVE;
25696 }
25697
25698 /* Send the command. */
25699 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_SYSSPACE,
25700 SD_PATH_STANDARD);
25701
25702 /*
25703 * "break" a reservation that is held by another host, by issuing a
25704 * reset if priority reserve is desired, and we could not get the
25705 * device.
25706 */
25707 if ((cmd == SD_PRIORITY_RESERVE) &&
25708 (rval != 0) && (com->uscsi_status == STATUS_RESERVATION_CONFLICT)) {
25709 /*
25710 * First try to reset the LUN. If we cannot, then try a target
25711 * reset, followed by a bus reset if the target reset fails.
25712 */
25713 int reset_retval = 0;
25714 if (un->un_f_lun_reset_enabled == TRUE) {
25715 reset_retval = scsi_reset(SD_ADDRESS(un), RESET_LUN);
25716 }
25717 if (reset_retval == 0) {
25718 /* The LUN reset either failed or was not issued */
25719 reset_retval = scsi_reset(SD_ADDRESS(un), RESET_TARGET);
25720 }
25721 if ((reset_retval == 0) &&
25722 (scsi_reset(SD_ADDRESS(un), RESET_ALL) == 0)) {
25723 rval = EIO;
25724 kmem_free(com, sizeof (*com));
25725 return (rval);
25726 }
25727
25728 bzero(com, sizeof (struct uscsi_cmd));
25729 com->uscsi_flags = USCSI_SILENT;
25730 com->uscsi_cdb = cdb;
25731 com->uscsi_cdblen = CDB_GROUP0;
25732 com->uscsi_timeout = 5;
25733
25734 /*
25735 * Reissue the last reserve command, this time without request
25736 * sense. Assume that it is just a regular reserve command.
25737 */
25738 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_SYSSPACE,
25739 SD_PATH_STANDARD);
25740 }
25741
25742 /* Return an error if still getting a reservation conflict. */
25743 if ((rval != 0) && (com->uscsi_status == STATUS_RESERVATION_CONFLICT)) {
25744 rval = EACCES;
25745 }
25746
25747 kmem_free(com, sizeof (*com));
25748 return (rval);
25749 }
25750
25751
25752 #define SD_NDUMP_RETRIES 12
25753 /*
25754 * System Crash Dump routine
25755 */
25756
25757 static int
25758 sddump(dev_t dev, caddr_t addr, daddr_t blkno, int nblk)
25759 {
25760 int instance;
25761 int partition;
25762 int i;
25763 int err;
25764 struct sd_lun *un;
25765 struct scsi_pkt *wr_pktp;
25766 struct buf *wr_bp;
25767 struct buf wr_buf;
25768 daddr_t tgt_byte_offset; /* rmw - byte offset for target */
25769 daddr_t tgt_blkno; /* rmw - blkno for target */
25770 size_t tgt_byte_count; /* rmw - # of bytes to xfer */
25771 size_t tgt_nblk; /* rmw - # of tgt blks to xfer */
25772 size_t io_start_offset;
25773 int doing_rmw = FALSE;
25774 int rval;
25775 ssize_t dma_resid;
25776 daddr_t oblkno;
25777 diskaddr_t nblks = 0;
25778 diskaddr_t start_block;
25779
25780 instance = SDUNIT(dev);
25781 if (((un = ddi_get_soft_state(sd_state, instance)) == NULL) ||
25782 !SD_IS_VALID_LABEL(un) || ISCD(un)) {
25783 return (ENXIO);
25784 }
25785
25786 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*un))
25787
25788 SD_TRACE(SD_LOG_DUMP, un, "sddump: entry\n");
25789
25790 partition = SDPART(dev);
25791 SD_INFO(SD_LOG_DUMP, un, "sddump: partition = %d\n", partition);
25792
25793 if (!(NOT_DEVBSIZE(un))) {
25794 int secmask = 0;
25795 int blknomask = 0;
25796
25797 blknomask = (un->un_tgt_blocksize / DEV_BSIZE) - 1;
25798 secmask = un->un_tgt_blocksize - 1;
25799
25800 if (blkno & blknomask) {
25801 SD_TRACE(SD_LOG_DUMP, un,
25802 "sddump: dump start block not modulo %d\n",
25803 un->un_tgt_blocksize);
25804 return (EINVAL);
25805 }
25806
25807 if ((nblk * DEV_BSIZE) & secmask) {
25808 SD_TRACE(SD_LOG_DUMP, un,
25809 "sddump: dump length not modulo %d\n",
25810 un->un_tgt_blocksize);
25811 return (EINVAL);
25812 }
25813
25814 }
25815
25816 /* Validate blocks to dump at against partition size. */
25817
25818 (void) cmlb_partinfo(un->un_cmlbhandle, partition,
25819 &nblks, &start_block, NULL, NULL, (void *)SD_PATH_DIRECT);
25820
25821 if (NOT_DEVBSIZE(un)) {
25822 if ((blkno + nblk) > nblks) {
25823 SD_TRACE(SD_LOG_DUMP, un,
25824 "sddump: dump range larger than partition: "
25825 "blkno = 0x%x, nblk = 0x%x, dkl_nblk = 0x%x\n",
25826 blkno, nblk, nblks);
25827 return (EINVAL);
25828 }
25829 } else {
25830 if (((blkno / (un->un_tgt_blocksize / DEV_BSIZE)) +
25831 (nblk / (un->un_tgt_blocksize / DEV_BSIZE))) > nblks) {
25832 SD_TRACE(SD_LOG_DUMP, un,
25833 "sddump: dump range larger than partition: "
25834 "blkno = 0x%x, nblk = 0x%x, dkl_nblk = 0x%x\n",
25835 blkno, nblk, nblks);
25836 return (EINVAL);
25837 }
25838 }
25839
25840 mutex_enter(&un->un_pm_mutex);
25841 if (SD_DEVICE_IS_IN_LOW_POWER(un)) {
25842 struct scsi_pkt *start_pktp;
25843
25844 mutex_exit(&un->un_pm_mutex);
25845
25846 /*
25847 * use pm framework to power on HBA 1st
25848 */
25849 (void) pm_raise_power(SD_DEVINFO(un), 0,
25850 SD_PM_STATE_ACTIVE(un));
25851
25852 /*
25853 * Dump no long uses sdpower to power on a device, it's
25854 * in-line here so it can be done in polled mode.
25855 */
25856
25857 SD_INFO(SD_LOG_DUMP, un, "sddump: starting device\n");
25858
25859 start_pktp = scsi_init_pkt(SD_ADDRESS(un), NULL, NULL,
25860 CDB_GROUP0, un->un_status_len, 0, 0, NULL_FUNC, NULL);
25861
25862 if (start_pktp == NULL) {
25863 /* We were not given a SCSI packet, fail. */
25864 return (EIO);
25865 }
25866 bzero(start_pktp->pkt_cdbp, CDB_GROUP0);
25867 start_pktp->pkt_cdbp[0] = SCMD_START_STOP;
25868 start_pktp->pkt_cdbp[4] = SD_TARGET_START;
25869 start_pktp->pkt_flags = FLAG_NOINTR;
25870
25871 mutex_enter(SD_MUTEX(un));
25872 SD_FILL_SCSI1_LUN(un, start_pktp);
25873 mutex_exit(SD_MUTEX(un));
25874 /*
25875 * Scsi_poll returns 0 (success) if the command completes and
25876 * the status block is STATUS_GOOD.
25877 */
25878 if (sd_scsi_poll(un, start_pktp) != 0) {
25879 scsi_destroy_pkt(start_pktp);
25880 return (EIO);
25881 }
25882 scsi_destroy_pkt(start_pktp);
25883 (void) sd_pm_state_change(un, SD_PM_STATE_ACTIVE(un),
25884 SD_PM_STATE_CHANGE);
25885 } else {
25886 mutex_exit(&un->un_pm_mutex);
25887 }
25888
25889 mutex_enter(SD_MUTEX(un));
25890 un->un_throttle = 0;
25891
25892 /*
25893 * The first time through, reset the specific target device.
25894 * However, when cpr calls sddump we know that sd is in a
25895 * a good state so no bus reset is required.
25896 * Clear sense data via Request Sense cmd.
25897 * In sddump we don't care about allow_bus_device_reset anymore
25898 */
25899
25900 if ((un->un_state != SD_STATE_SUSPENDED) &&
25901 (un->un_state != SD_STATE_DUMPING)) {
25902
25903 New_state(un, SD_STATE_DUMPING);
25904
25905 if (un->un_f_is_fibre == FALSE) {
25906 mutex_exit(SD_MUTEX(un));
25907 /*
25908 * Attempt a bus reset for parallel scsi.
25909 *
25910 * Note: A bus reset is required because on some host
25911 * systems (i.e. E420R) a bus device reset is
25912 * insufficient to reset the state of the target.
25913 *
25914 * Note: Don't issue the reset for fibre-channel,
25915 * because this tends to hang the bus (loop) for
25916 * too long while everyone is logging out and in
25917 * and the deadman timer for dumping will fire
25918 * before the dump is complete.
25919 */
25920 if (scsi_reset(SD_ADDRESS(un), RESET_ALL) == 0) {
25921 mutex_enter(SD_MUTEX(un));
25922 Restore_state(un);
25923 mutex_exit(SD_MUTEX(un));
25924 return (EIO);
25925 }
25926
25927 /* Delay to give the device some recovery time. */
25928 drv_usecwait(10000);
25929
25930 if (sd_send_polled_RQS(un) == SD_FAILURE) {
25931 SD_INFO(SD_LOG_DUMP, un,
25932 "sddump: sd_send_polled_RQS failed\n");
25933 }
25934 mutex_enter(SD_MUTEX(un));
25935 }
25936 }
25937
25938 /*
25939 * Convert the partition-relative block number to a
25940 * disk physical block number.
25941 */
25942 if (NOT_DEVBSIZE(un)) {
25943 blkno += start_block;
25944 } else {
25945 blkno = blkno / (un->un_tgt_blocksize / DEV_BSIZE);
25946 blkno += start_block;
25947 }
25948
25949 SD_INFO(SD_LOG_DUMP, un, "sddump: disk blkno = 0x%x\n", blkno);
25950
25951
25952 /*
25953 * Check if the device has a non-512 block size.
25954 */
25955 wr_bp = NULL;
25956 if (NOT_DEVBSIZE(un)) {
25957 tgt_byte_offset = blkno * un->un_sys_blocksize;
25958 tgt_byte_count = nblk * un->un_sys_blocksize;
25959 if ((tgt_byte_offset % un->un_tgt_blocksize) ||
25960 (tgt_byte_count % un->un_tgt_blocksize)) {
25961 doing_rmw = TRUE;
25962 /*
25963 * Calculate the block number and number of block
25964 * in terms of the media block size.
25965 */
25966 tgt_blkno = tgt_byte_offset / un->un_tgt_blocksize;
25967 tgt_nblk =
25968 ((tgt_byte_offset + tgt_byte_count +
25969 (un->un_tgt_blocksize - 1)) /
25970 un->un_tgt_blocksize) - tgt_blkno;
25971
25972 /*
25973 * Invoke the routine which is going to do read part
25974 * of read-modify-write.
25975 * Note that this routine returns a pointer to
25976 * a valid bp in wr_bp.
25977 */
25978 err = sddump_do_read_of_rmw(un, tgt_blkno, tgt_nblk,
25979 &wr_bp);
25980 if (err) {
25981 mutex_exit(SD_MUTEX(un));
25982 return (err);
25983 }
25984 /*
25985 * Offset is being calculated as -
25986 * (original block # * system block size) -
25987 * (new block # * target block size)
25988 */
25989 io_start_offset =
25990 ((uint64_t)(blkno * un->un_sys_blocksize)) -
25991 ((uint64_t)(tgt_blkno * un->un_tgt_blocksize));
25992
25993 ASSERT((io_start_offset >= 0) &&
25994 (io_start_offset < un->un_tgt_blocksize));
25995 /*
25996 * Do the modify portion of read modify write.
25997 */
25998 bcopy(addr, &wr_bp->b_un.b_addr[io_start_offset],
25999 (size_t)nblk * un->un_sys_blocksize);
26000 } else {
26001 doing_rmw = FALSE;
26002 tgt_blkno = tgt_byte_offset / un->un_tgt_blocksize;
26003 tgt_nblk = tgt_byte_count / un->un_tgt_blocksize;
26004 }
26005
26006 /* Convert blkno and nblk to target blocks */
26007 blkno = tgt_blkno;
26008 nblk = tgt_nblk;
26009 } else {
26010 wr_bp = &wr_buf;
26011 bzero(wr_bp, sizeof (struct buf));
26012 wr_bp->b_flags = B_BUSY;
26013 wr_bp->b_un.b_addr = addr;
26014 wr_bp->b_bcount = nblk << DEV_BSHIFT;
26015 wr_bp->b_resid = 0;
26016 }
26017
26018 mutex_exit(SD_MUTEX(un));
26019
26020 /*
26021 * Obtain a SCSI packet for the write command.
26022 * It should be safe to call the allocator here without
26023 * worrying about being locked for DVMA mapping because
26024 * the address we're passed is already a DVMA mapping
26025 *
26026 * We are also not going to worry about semaphore ownership
26027 * in the dump buffer. Dumping is single threaded at present.
26028 */
26029
26030 wr_pktp = NULL;
26031
26032 dma_resid = wr_bp->b_bcount;
26033 oblkno = blkno;
26034
26035 if (!(NOT_DEVBSIZE(un))) {
26036 nblk = nblk / (un->un_tgt_blocksize / DEV_BSIZE);
26037 }
26038
26039 while (dma_resid != 0) {
26040
26041 for (i = 0; i < SD_NDUMP_RETRIES; i++) {
26042 wr_bp->b_flags &= ~B_ERROR;
26043
26044 if (un->un_partial_dma_supported == 1) {
26045 blkno = oblkno +
26046 ((wr_bp->b_bcount - dma_resid) /
26047 un->un_tgt_blocksize);
26048 nblk = dma_resid / un->un_tgt_blocksize;
26049
26050 if (wr_pktp) {
26051 /*
26052 * Partial DMA transfers after initial transfer
26053 */
26054 rval = sd_setup_next_rw_pkt(un, wr_pktp, wr_bp,
26055 blkno, nblk);
26056 } else {
26057 /* Initial transfer */
26058 rval = sd_setup_rw_pkt(un, &wr_pktp, wr_bp,
26059 un->un_pkt_flags, NULL_FUNC, NULL,
26060 blkno, nblk);
26061 }
26062 } else {
26063 rval = sd_setup_rw_pkt(un, &wr_pktp, wr_bp,
26064 0, NULL_FUNC, NULL, blkno, nblk);
26065 }
26066
26067 if (rval == 0) {
26068 /* We were given a SCSI packet, continue. */
26069 break;
26070 }
26071
26072 if (i == 0) {
26073 if (wr_bp->b_flags & B_ERROR) {
26074 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
26075 "no resources for dumping; "
26076 "error code: 0x%x, retrying",
26077 geterror(wr_bp));
26078 } else {
26079 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
26080 "no resources for dumping; retrying");
26081 }
26082 } else if (i != (SD_NDUMP_RETRIES - 1)) {
26083 if (wr_bp->b_flags & B_ERROR) {
26084 scsi_log(SD_DEVINFO(un), sd_label, CE_CONT,
26085 "no resources for dumping; error code: "
26086 "0x%x, retrying\n", geterror(wr_bp));
26087 }
26088 } else {
26089 if (wr_bp->b_flags & B_ERROR) {
26090 scsi_log(SD_DEVINFO(un), sd_label, CE_CONT,
26091 "no resources for dumping; "
26092 "error code: 0x%x, retries failed, "
26093 "giving up.\n", geterror(wr_bp));
26094 } else {
26095 scsi_log(SD_DEVINFO(un), sd_label, CE_CONT,
26096 "no resources for dumping; "
26097 "retries failed, giving up.\n");
26098 }
26099 mutex_enter(SD_MUTEX(un));
26100 Restore_state(un);
26101 if (NOT_DEVBSIZE(un) && (doing_rmw == TRUE)) {
26102 mutex_exit(SD_MUTEX(un));
26103 scsi_free_consistent_buf(wr_bp);
26104 } else {
26105 mutex_exit(SD_MUTEX(un));
26106 }
26107 return (EIO);
26108 }
26109 drv_usecwait(10000);
26110 }
26111
26112 if (un->un_partial_dma_supported == 1) {
26113 /*
26114 * save the resid from PARTIAL_DMA
26115 */
26116 dma_resid = wr_pktp->pkt_resid;
26117 if (dma_resid != 0)
26118 nblk -= SD_BYTES2TGTBLOCKS(un, dma_resid);
26119 wr_pktp->pkt_resid = 0;
26120 } else {
26121 dma_resid = 0;
26122 }
26123
26124 /* SunBug 1222170 */
26125 wr_pktp->pkt_flags = FLAG_NOINTR;
26126
26127 err = EIO;
26128 for (i = 0; i < SD_NDUMP_RETRIES; i++) {
26129
26130 /*
26131 * Scsi_poll returns 0 (success) if the command completes and
26132 * the status block is STATUS_GOOD. We should only check
26133 * errors if this condition is not true. Even then we should
26134 * send our own request sense packet only if we have a check
26135 * condition and auto request sense has not been performed by
26136 * the hba.
26137 */
26138 SD_TRACE(SD_LOG_DUMP, un, "sddump: sending write\n");
26139
26140 if ((sd_scsi_poll(un, wr_pktp) == 0) &&
26141 (wr_pktp->pkt_resid == 0)) {
26142 err = SD_SUCCESS;
26143 break;
26144 }
26145
26146 /*
26147 * Check CMD_DEV_GONE 1st, give up if device is gone.
26148 */
26149 if (wr_pktp->pkt_reason == CMD_DEV_GONE) {
26150 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
26151 "Error while dumping state...Device is gone\n");
26152 break;
26153 }
26154
26155 if (SD_GET_PKT_STATUS(wr_pktp) == STATUS_CHECK) {
26156 SD_INFO(SD_LOG_DUMP, un,
26157 "sddump: write failed with CHECK, try # %d\n", i);
26158 if (((wr_pktp->pkt_state & STATE_ARQ_DONE) == 0)) {
26159 (void) sd_send_polled_RQS(un);
26160 }
26161
26162 continue;
26163 }
26164
26165 if (SD_GET_PKT_STATUS(wr_pktp) == STATUS_BUSY) {
26166 int reset_retval = 0;
26167
26168 SD_INFO(SD_LOG_DUMP, un,
26169 "sddump: write failed with BUSY, try # %d\n", i);
26170
26171 if (un->un_f_lun_reset_enabled == TRUE) {
26172 reset_retval = scsi_reset(SD_ADDRESS(un),
26173 RESET_LUN);
26174 }
26175 if (reset_retval == 0) {
26176 (void) scsi_reset(SD_ADDRESS(un), RESET_TARGET);
26177 }
26178 (void) sd_send_polled_RQS(un);
26179
26180 } else {
26181 SD_INFO(SD_LOG_DUMP, un,
26182 "sddump: write failed with 0x%x, try # %d\n",
26183 SD_GET_PKT_STATUS(wr_pktp), i);
26184 mutex_enter(SD_MUTEX(un));
26185 sd_reset_target(un, wr_pktp);
26186 mutex_exit(SD_MUTEX(un));
26187 }
26188
26189 /*
26190 * If we are not getting anywhere with lun/target resets,
26191 * let's reset the bus.
26192 */
26193 if (i == SD_NDUMP_RETRIES/2) {
26194 (void) scsi_reset(SD_ADDRESS(un), RESET_ALL);
26195 (void) sd_send_polled_RQS(un);
26196 }
26197 }
26198 }
26199
26200 scsi_destroy_pkt(wr_pktp);
26201 mutex_enter(SD_MUTEX(un));
26202 if ((NOT_DEVBSIZE(un)) && (doing_rmw == TRUE)) {
26203 mutex_exit(SD_MUTEX(un));
26204 scsi_free_consistent_buf(wr_bp);
26205 } else {
26206 mutex_exit(SD_MUTEX(un));
26207 }
26208 SD_TRACE(SD_LOG_DUMP, un, "sddump: exit: err = %d\n", err);
26209 return (err);
26210 }
26211
26212 /*
26213 * Function: sd_scsi_poll()
26214 *
26215 * Description: This is a wrapper for the scsi_poll call.
26216 *
26217 * Arguments: sd_lun - The unit structure
26218 * scsi_pkt - The scsi packet being sent to the device.
26219 *
26220 * Return Code: 0 - Command completed successfully with good status
26221 * -1 - Command failed. This could indicate a check condition
26222 * or other status value requiring recovery action.
26223 *
26224 * NOTE: This code is only called off sddump().
26225 */
26226
26227 static int
26228 sd_scsi_poll(struct sd_lun *un, struct scsi_pkt *pktp)
26229 {
26230 int status;
26231
26232 ASSERT(un != NULL);
26233 ASSERT(!mutex_owned(SD_MUTEX(un)));
26234 ASSERT(pktp != NULL);
26235
26236 status = SD_SUCCESS;
26237
26238 if (scsi_ifgetcap(&pktp->pkt_address, "tagged-qing", 1) == 1) {
26239 pktp->pkt_flags |= un->un_tagflags;
26240 pktp->pkt_flags &= ~FLAG_NODISCON;
26241 }
26242
26243 status = sd_ddi_scsi_poll(pktp);
26244 /*
26245 * Scsi_poll returns 0 (success) if the command completes and the
26246 * status block is STATUS_GOOD. We should only check errors if this
26247 * condition is not true. Even then we should send our own request
26248 * sense packet only if we have a check condition and auto
26249 * request sense has not been performed by the hba.
26250 * Don't get RQS data if pkt_reason is CMD_DEV_GONE.
26251 */
26252 if ((status != SD_SUCCESS) &&
26253 (SD_GET_PKT_STATUS(pktp) == STATUS_CHECK) &&
26254 (pktp->pkt_state & STATE_ARQ_DONE) == 0 &&
26255 (pktp->pkt_reason != CMD_DEV_GONE))
26256 (void) sd_send_polled_RQS(un);
26257
26258 return (status);
26259 }
26260
26261 /*
26262 * Function: sd_send_polled_RQS()
26263 *
26264 * Description: This sends the request sense command to a device.
26265 *
26266 * Arguments: sd_lun - The unit structure
26267 *
26268 * Return Code: 0 - Command completed successfully with good status
26269 * -1 - Command failed.
26270 *
26271 */
26272
26273 static int
26274 sd_send_polled_RQS(struct sd_lun *un)
26275 {
26276 int ret_val;
26277 struct scsi_pkt *rqs_pktp;
26278 struct buf *rqs_bp;
26279
26280 ASSERT(un != NULL);
26281 ASSERT(!mutex_owned(SD_MUTEX(un)));
26282
26283 ret_val = SD_SUCCESS;
26284
26285 rqs_pktp = un->un_rqs_pktp;
26286 rqs_bp = un->un_rqs_bp;
26287
26288 mutex_enter(SD_MUTEX(un));
26289
26290 if (un->un_sense_isbusy) {
26291 ret_val = SD_FAILURE;
26292 mutex_exit(SD_MUTEX(un));
26293 return (ret_val);
26294 }
26295
26296 /*
26297 * If the request sense buffer (and packet) is not in use,
26298 * let's set the un_sense_isbusy and send our packet
26299 */
26300 un->un_sense_isbusy = 1;
26301 rqs_pktp->pkt_resid = 0;
26302 rqs_pktp->pkt_reason = 0;
26303 rqs_pktp->pkt_flags |= FLAG_NOINTR;
26304 bzero(rqs_bp->b_un.b_addr, SENSE_LENGTH);
26305
26306 mutex_exit(SD_MUTEX(un));
26307
26308 SD_INFO(SD_LOG_COMMON, un, "sd_send_polled_RQS: req sense buf at"
26309 " 0x%p\n", rqs_bp->b_un.b_addr);
26310
26311 /*
26312 * Can't send this to sd_scsi_poll, we wrap ourselves around the
26313 * axle - it has a call into us!
26314 */
26315 if ((ret_val = sd_ddi_scsi_poll(rqs_pktp)) != 0) {
26316 SD_INFO(SD_LOG_COMMON, un,
26317 "sd_send_polled_RQS: RQS failed\n");
26318 }
26319
26320 SD_DUMP_MEMORY(un, SD_LOG_COMMON, "sd_send_polled_RQS:",
26321 (uchar_t *)rqs_bp->b_un.b_addr, SENSE_LENGTH, SD_LOG_HEX);
26322
26323 mutex_enter(SD_MUTEX(un));
26324 un->un_sense_isbusy = 0;
26325 mutex_exit(SD_MUTEX(un));
26326
26327 return (ret_val);
26328 }
26329
26330 /*
26331 * Defines needed for localized version of the scsi_poll routine.
26332 */
26333 #define CSEC 10000 /* usecs */
26334 #define SEC_TO_CSEC (1000000/CSEC)
26335
26336 /*
26337 * Function: sd_ddi_scsi_poll()
26338 *
26339 * Description: Localized version of the scsi_poll routine. The purpose is to
26340 * send a scsi_pkt to a device as a polled command. This version
26341 * is to ensure more robust handling of transport errors.
26342 * Specifically this routine cures not ready, coming ready
26343 * transition for power up and reset of sonoma's. This can take
26344 * up to 45 seconds for power-on and 20 seconds for reset of a
26345 * sonoma lun.
26346 *
26347 * Arguments: scsi_pkt - The scsi_pkt being sent to a device
26348 *
26349 * Return Code: 0 - Command completed successfully with good status
26350 * -1 - Command failed.
26351 *
26352 * NOTE: This code is almost identical to scsi_poll, however before 6668774 can
26353 * be fixed (removing this code), we need to determine how to handle the
26354 * KEY_UNIT_ATTENTION condition below in conditions not as limited as sddump().
26355 *
26356 * NOTE: This code is only called off sddump().
26357 */
26358 static int
26359 sd_ddi_scsi_poll(struct scsi_pkt *pkt)
26360 {
26361 int rval = -1;
26362 int savef;
26363 long savet;
26364 void (*savec)();
26365 int timeout;
26366 int busy_count;
26367 int poll_delay;
26368 int rc;
26369 uint8_t *sensep;
26370 struct scsi_arq_status *arqstat;
26371 extern int do_polled_io;
26372
26373 ASSERT(pkt->pkt_scbp);
26374
26375 /*
26376 * save old flags..
26377 */
26378 savef = pkt->pkt_flags;
26379 savec = pkt->pkt_comp;
26380 savet = pkt->pkt_time;
26381
26382 pkt->pkt_flags |= FLAG_NOINTR;
26383
26384 /*
26385 * XXX there is nothing in the SCSA spec that states that we should not
26386 * do a callback for polled cmds; however, removing this will break sd
26387 * and probably other target drivers
26388 */
26389 pkt->pkt_comp = NULL;
26390
26391 /*
26392 * we don't like a polled command without timeout.
26393 * 60 seconds seems long enough.
26394 */
26395 if (pkt->pkt_time == 0)
26396 pkt->pkt_time = SCSI_POLL_TIMEOUT;
26397
26398 /*
26399 * Send polled cmd.
26400 *
26401 * We do some error recovery for various errors. Tran_busy,
26402 * queue full, and non-dispatched commands are retried every 10 msec.
26403 * as they are typically transient failures. Busy status and Not
26404 * Ready are retried every second as this status takes a while to
26405 * change.
26406 */
26407 timeout = pkt->pkt_time * SEC_TO_CSEC;
26408
26409 for (busy_count = 0; busy_count < timeout; busy_count++) {
26410 /*
26411 * Initialize pkt status variables.
26412 */
26413 *pkt->pkt_scbp = pkt->pkt_reason = pkt->pkt_state = 0;
26414
26415 if ((rc = scsi_transport(pkt)) != TRAN_ACCEPT) {
26416 if (rc != TRAN_BUSY) {
26417 /* Transport failed - give up. */
26418 break;
26419 } else {
26420 /* Transport busy - try again. */
26421 poll_delay = 1 * CSEC; /* 10 msec. */
26422 }
26423 } else {
26424 /*
26425 * Transport accepted - check pkt status.
26426 */
26427 rc = (*pkt->pkt_scbp) & STATUS_MASK;
26428 if ((pkt->pkt_reason == CMD_CMPLT) &&
26429 (rc == STATUS_CHECK) &&
26430 (pkt->pkt_state & STATE_ARQ_DONE)) {
26431 arqstat =
26432 (struct scsi_arq_status *)(pkt->pkt_scbp);
26433 sensep = (uint8_t *)&arqstat->sts_sensedata;
26434 } else {
26435 sensep = NULL;
26436 }
26437
26438 if ((pkt->pkt_reason == CMD_CMPLT) &&
26439 (rc == STATUS_GOOD)) {
26440 /* No error - we're done */
26441 rval = 0;
26442 break;
26443
26444 } else if (pkt->pkt_reason == CMD_DEV_GONE) {
26445 /* Lost connection - give up */
26446 break;
26447
26448 } else if ((pkt->pkt_reason == CMD_INCOMPLETE) &&
26449 (pkt->pkt_state == 0)) {
26450 /* Pkt not dispatched - try again. */
26451 poll_delay = 1 * CSEC; /* 10 msec. */
26452
26453 } else if ((pkt->pkt_reason == CMD_CMPLT) &&
26454 (rc == STATUS_QFULL)) {
26455 /* Queue full - try again. */
26456 poll_delay = 1 * CSEC; /* 10 msec. */
26457
26458 } else if ((pkt->pkt_reason == CMD_CMPLT) &&
26459 (rc == STATUS_BUSY)) {
26460 /* Busy - try again. */
26461 poll_delay = 100 * CSEC; /* 1 sec. */
26462 busy_count += (SEC_TO_CSEC - 1);
26463
26464 } else if ((sensep != NULL) &&
26465 (scsi_sense_key(sensep) == KEY_UNIT_ATTENTION)) {
26466 /*
26467 * Unit Attention - try again.
26468 * Pretend it took 1 sec.
26469 * NOTE: 'continue' avoids poll_delay
26470 */
26471 busy_count += (SEC_TO_CSEC - 1);
26472 continue;
26473
26474 } else if ((sensep != NULL) &&
26475 (scsi_sense_key(sensep) == KEY_NOT_READY) &&
26476 (scsi_sense_asc(sensep) == 0x04) &&
26477 (scsi_sense_ascq(sensep) == 0x01)) {
26478 /*
26479 * Not ready -> ready - try again.
26480 * 04h/01h: LUN IS IN PROCESS OF BECOMING READY
26481 * ...same as STATUS_BUSY
26482 */
26483 poll_delay = 100 * CSEC; /* 1 sec. */
26484 busy_count += (SEC_TO_CSEC - 1);
26485
26486 } else {
26487 /* BAD status - give up. */
26488 break;
26489 }
26490 }
26491
26492 if (((curthread->t_flag & T_INTR_THREAD) == 0) &&
26493 !do_polled_io) {
26494 delay(drv_usectohz(poll_delay));
26495 } else {
26496 /* we busy wait during cpr_dump or interrupt threads */
26497 drv_usecwait(poll_delay);
26498 }
26499 }
26500
26501 pkt->pkt_flags = savef;
26502 pkt->pkt_comp = savec;
26503 pkt->pkt_time = savet;
26504
26505 /* return on error */
26506 if (rval)
26507 return (rval);
26508
26509 /*
26510 * This is not a performance critical code path.
26511 *
26512 * As an accommodation for scsi_poll callers, to avoid ddi_dma_sync()
26513 * issues associated with looking at DMA memory prior to
26514 * scsi_pkt_destroy(), we scsi_sync_pkt() prior to return.
26515 */
26516 scsi_sync_pkt(pkt);
26517 return (0);
26518 }
26519
26520
26521
26522 /*
26523 * Function: sd_persistent_reservation_in_read_keys
26524 *
26525 * Description: This routine is the driver entry point for handling CD-ROM
26526 * multi-host persistent reservation requests (MHIOCGRP_INKEYS)
26527 * by sending the SCSI-3 PRIN commands to the device.
26528 * Processes the read keys command response by copying the
26529 * reservation key information into the user provided buffer.
26530 * Support for the 32/64 bit _MULTI_DATAMODEL is implemented.
26531 *
26532 * Arguments: un - Pointer to soft state struct for the target.
26533 * usrp - user provided pointer to multihost Persistent In Read
26534 * Keys structure (mhioc_inkeys_t)
26535 * flag - this argument is a pass through to ddi_copyxxx()
26536 * directly from the mode argument of ioctl().
26537 *
26538 * Return Code: 0 - Success
26539 * EACCES
26540 * ENOTSUP
26541 * errno return code from sd_send_scsi_cmd()
26542 *
26543 * Context: Can sleep. Does not return until command is completed.
26544 */
26545
26546 static int
26547 sd_persistent_reservation_in_read_keys(struct sd_lun *un,
26548 mhioc_inkeys_t *usrp, int flag)
26549 {
26550 #ifdef _MULTI_DATAMODEL
26551 struct mhioc_key_list32 li32;
26552 #endif
26553 sd_prin_readkeys_t *in;
26554 mhioc_inkeys_t *ptr;
26555 mhioc_key_list_t li;
26556 uchar_t *data_bufp;
26557 int data_len;
26558 int rval = 0;
26559 size_t copysz;
26560 sd_ssc_t *ssc;
26561
26562 if ((ptr = (mhioc_inkeys_t *)usrp) == NULL) {
26563 return (EINVAL);
26564 }
26565 bzero(&li, sizeof (mhioc_key_list_t));
26566
26567 ssc = sd_ssc_init(un);
26568
26569 /*
26570 * Get the listsize from user
26571 */
26572 #ifdef _MULTI_DATAMODEL
26573
26574 switch (ddi_model_convert_from(flag & FMODELS)) {
26575 case DDI_MODEL_ILP32:
26576 copysz = sizeof (struct mhioc_key_list32);
26577 if (ddi_copyin(ptr->li, &li32, copysz, flag)) {
26578 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26579 "sd_persistent_reservation_in_read_keys: "
26580 "failed ddi_copyin: mhioc_key_list32_t\n");
26581 rval = EFAULT;
26582 goto done;
26583 }
26584 li.listsize = li32.listsize;
26585 li.list = (mhioc_resv_key_t *)(uintptr_t)li32.list;
26586 break;
26587
26588 case DDI_MODEL_NONE:
26589 copysz = sizeof (mhioc_key_list_t);
26590 if (ddi_copyin(ptr->li, &li, copysz, flag)) {
26591 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26592 "sd_persistent_reservation_in_read_keys: "
26593 "failed ddi_copyin: mhioc_key_list_t\n");
26594 rval = EFAULT;
26595 goto done;
26596 }
26597 break;
26598 }
26599
26600 #else /* ! _MULTI_DATAMODEL */
26601 copysz = sizeof (mhioc_key_list_t);
26602 if (ddi_copyin(ptr->li, &li, copysz, flag)) {
26603 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26604 "sd_persistent_reservation_in_read_keys: "
26605 "failed ddi_copyin: mhioc_key_list_t\n");
26606 rval = EFAULT;
26607 goto done;
26608 }
26609 #endif
26610
26611 data_len = li.listsize * MHIOC_RESV_KEY_SIZE;
26612 data_len += (sizeof (sd_prin_readkeys_t) - sizeof (caddr_t));
26613 data_bufp = kmem_zalloc(data_len, KM_SLEEP);
26614
26615 rval = sd_send_scsi_PERSISTENT_RESERVE_IN(ssc, SD_READ_KEYS,
26616 data_len, data_bufp);
26617 if (rval != 0) {
26618 if (rval == EIO)
26619 sd_ssc_assessment(ssc, SD_FMT_IGNORE_COMPROMISE);
26620 else
26621 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
26622 goto done;
26623 }
26624 in = (sd_prin_readkeys_t *)data_bufp;
26625 ptr->generation = BE_32(in->generation);
26626 li.listlen = BE_32(in->len) / MHIOC_RESV_KEY_SIZE;
26627
26628 /*
26629 * Return the min(listsize, listlen) keys
26630 */
26631 #ifdef _MULTI_DATAMODEL
26632
26633 switch (ddi_model_convert_from(flag & FMODELS)) {
26634 case DDI_MODEL_ILP32:
26635 li32.listlen = li.listlen;
26636 if (ddi_copyout(&li32, ptr->li, copysz, flag)) {
26637 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26638 "sd_persistent_reservation_in_read_keys: "
26639 "failed ddi_copyout: mhioc_key_list32_t\n");
26640 rval = EFAULT;
26641 goto done;
26642 }
26643 break;
26644
26645 case DDI_MODEL_NONE:
26646 if (ddi_copyout(&li, ptr->li, copysz, flag)) {
26647 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26648 "sd_persistent_reservation_in_read_keys: "
26649 "failed ddi_copyout: mhioc_key_list_t\n");
26650 rval = EFAULT;
26651 goto done;
26652 }
26653 break;
26654 }
26655
26656 #else /* ! _MULTI_DATAMODEL */
26657
26658 if (ddi_copyout(&li, ptr->li, copysz, flag)) {
26659 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26660 "sd_persistent_reservation_in_read_keys: "
26661 "failed ddi_copyout: mhioc_key_list_t\n");
26662 rval = EFAULT;
26663 goto done;
26664 }
26665
26666 #endif /* _MULTI_DATAMODEL */
26667
26668 copysz = min(li.listlen * MHIOC_RESV_KEY_SIZE,
26669 li.listsize * MHIOC_RESV_KEY_SIZE);
26670 if (ddi_copyout(&in->keylist, li.list, copysz, flag)) {
26671 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26672 "sd_persistent_reservation_in_read_keys: "
26673 "failed ddi_copyout: keylist\n");
26674 rval = EFAULT;
26675 }
26676 done:
26677 sd_ssc_fini(ssc);
26678 kmem_free(data_bufp, data_len);
26679 return (rval);
26680 }
26681
26682
26683 /*
26684 * Function: sd_persistent_reservation_in_read_resv
26685 *
26686 * Description: This routine is the driver entry point for handling CD-ROM
26687 * multi-host persistent reservation requests (MHIOCGRP_INRESV)
26688 * by sending the SCSI-3 PRIN commands to the device.
26689 * Process the read persistent reservations command response by
26690 * copying the reservation information into the user provided
26691 * buffer. Support for the 32/64 _MULTI_DATAMODEL is implemented.
26692 *
26693 * Arguments: un - Pointer to soft state struct for the target.
26694 * usrp - user provided pointer to multihost Persistent In Read
26695 * Keys structure (mhioc_inkeys_t)
26696 * flag - this argument is a pass through to ddi_copyxxx()
26697 * directly from the mode argument of ioctl().
26698 *
26699 * Return Code: 0 - Success
26700 * EACCES
26701 * ENOTSUP
26702 * errno return code from sd_send_scsi_cmd()
26703 *
26704 * Context: Can sleep. Does not return until command is completed.
26705 */
26706
26707 static int
26708 sd_persistent_reservation_in_read_resv(struct sd_lun *un,
26709 mhioc_inresvs_t *usrp, int flag)
26710 {
26711 #ifdef _MULTI_DATAMODEL
26712 struct mhioc_resv_desc_list32 resvlist32;
26713 #endif
26714 sd_prin_readresv_t *in;
26715 mhioc_inresvs_t *ptr;
26716 sd_readresv_desc_t *readresv_ptr;
26717 mhioc_resv_desc_list_t resvlist;
26718 mhioc_resv_desc_t resvdesc;
26719 uchar_t *data_bufp = NULL;
26720 int data_len;
26721 int rval = 0;
26722 int i;
26723 size_t copysz;
26724 mhioc_resv_desc_t *bufp;
26725 sd_ssc_t *ssc;
26726
26727 if ((ptr = usrp) == NULL) {
26728 return (EINVAL);
26729 }
26730
26731 ssc = sd_ssc_init(un);
26732
26733 /*
26734 * Get the listsize from user
26735 */
26736 #ifdef _MULTI_DATAMODEL
26737 switch (ddi_model_convert_from(flag & FMODELS)) {
26738 case DDI_MODEL_ILP32:
26739 copysz = sizeof (struct mhioc_resv_desc_list32);
26740 if (ddi_copyin(ptr->li, &resvlist32, copysz, flag)) {
26741 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26742 "sd_persistent_reservation_in_read_resv: "
26743 "failed ddi_copyin: mhioc_resv_desc_list_t\n");
26744 rval = EFAULT;
26745 goto done;
26746 }
26747 resvlist.listsize = resvlist32.listsize;
26748 resvlist.list = (mhioc_resv_desc_t *)(uintptr_t)resvlist32.list;
26749 break;
26750
26751 case DDI_MODEL_NONE:
26752 copysz = sizeof (mhioc_resv_desc_list_t);
26753 if (ddi_copyin(ptr->li, &resvlist, copysz, flag)) {
26754 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26755 "sd_persistent_reservation_in_read_resv: "
26756 "failed ddi_copyin: mhioc_resv_desc_list_t\n");
26757 rval = EFAULT;
26758 goto done;
26759 }
26760 break;
26761 }
26762 #else /* ! _MULTI_DATAMODEL */
26763 copysz = sizeof (mhioc_resv_desc_list_t);
26764 if (ddi_copyin(ptr->li, &resvlist, copysz, flag)) {
26765 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26766 "sd_persistent_reservation_in_read_resv: "
26767 "failed ddi_copyin: mhioc_resv_desc_list_t\n");
26768 rval = EFAULT;
26769 goto done;
26770 }
26771 #endif /* ! _MULTI_DATAMODEL */
26772
26773 data_len = resvlist.listsize * SCSI3_RESV_DESC_LEN;
26774 data_len += (sizeof (sd_prin_readresv_t) - sizeof (caddr_t));
26775 data_bufp = kmem_zalloc(data_len, KM_SLEEP);
26776
26777 rval = sd_send_scsi_PERSISTENT_RESERVE_IN(ssc, SD_READ_RESV,
26778 data_len, data_bufp);
26779 if (rval != 0) {
26780 if (rval == EIO)
26781 sd_ssc_assessment(ssc, SD_FMT_IGNORE_COMPROMISE);
26782 else
26783 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
26784 goto done;
26785 }
26786 in = (sd_prin_readresv_t *)data_bufp;
26787 ptr->generation = BE_32(in->generation);
26788 resvlist.listlen = BE_32(in->len) / SCSI3_RESV_DESC_LEN;
26789
26790 /*
26791 * Return the min(listsize, listlen( keys
26792 */
26793 #ifdef _MULTI_DATAMODEL
26794
26795 switch (ddi_model_convert_from(flag & FMODELS)) {
26796 case DDI_MODEL_ILP32:
26797 resvlist32.listlen = resvlist.listlen;
26798 if (ddi_copyout(&resvlist32, ptr->li, copysz, flag)) {
26799 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26800 "sd_persistent_reservation_in_read_resv: "
26801 "failed ddi_copyout: mhioc_resv_desc_list_t\n");
26802 rval = EFAULT;
26803 goto done;
26804 }
26805 break;
26806
26807 case DDI_MODEL_NONE:
26808 if (ddi_copyout(&resvlist, ptr->li, copysz, flag)) {
26809 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26810 "sd_persistent_reservation_in_read_resv: "
26811 "failed ddi_copyout: mhioc_resv_desc_list_t\n");
26812 rval = EFAULT;
26813 goto done;
26814 }
26815 break;
26816 }
26817
26818 #else /* ! _MULTI_DATAMODEL */
26819
26820 if (ddi_copyout(&resvlist, ptr->li, copysz, flag)) {
26821 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26822 "sd_persistent_reservation_in_read_resv: "
26823 "failed ddi_copyout: mhioc_resv_desc_list_t\n");
26824 rval = EFAULT;
26825 goto done;
26826 }
26827
26828 #endif /* ! _MULTI_DATAMODEL */
26829
26830 readresv_ptr = (sd_readresv_desc_t *)&in->readresv_desc;
26831 bufp = resvlist.list;
26832 copysz = sizeof (mhioc_resv_desc_t);
26833 for (i = 0; i < min(resvlist.listlen, resvlist.listsize);
26834 i++, readresv_ptr++, bufp++) {
26835
26836 bcopy(&readresv_ptr->resvkey, &resvdesc.key,
26837 MHIOC_RESV_KEY_SIZE);
26838 resvdesc.type = readresv_ptr->type;
26839 resvdesc.scope = readresv_ptr->scope;
26840 resvdesc.scope_specific_addr =
26841 BE_32(readresv_ptr->scope_specific_addr);
26842
26843 if (ddi_copyout(&resvdesc, bufp, copysz, flag)) {
26844 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26845 "sd_persistent_reservation_in_read_resv: "
26846 "failed ddi_copyout: resvlist\n");
26847 rval = EFAULT;
26848 goto done;
26849 }
26850 }
26851 done:
26852 sd_ssc_fini(ssc);
26853 /* only if data_bufp is allocated, we need to free it */
26854 if (data_bufp) {
26855 kmem_free(data_bufp, data_len);
26856 }
26857 return (rval);
26858 }
26859
26860
26861 /*
26862 * Function: sr_change_blkmode()
26863 *
26864 * Description: This routine is the driver entry point for handling CD-ROM
26865 * block mode ioctl requests. Support for returning and changing
26866 * the current block size in use by the device is implemented. The
26867 * LBA size is changed via a MODE SELECT Block Descriptor.
26868 *
26869 * This routine issues a mode sense with an allocation length of
26870 * 12 bytes for the mode page header and a single block descriptor.
26871 *
26872 * Arguments: dev - the device 'dev_t'
26873 * cmd - the request type; one of CDROMGBLKMODE (get) or
26874 * CDROMSBLKMODE (set)
26875 * data - current block size or requested block size
26876 * flag - this argument is a pass through to ddi_copyxxx() directly
26877 * from the mode argument of ioctl().
26878 *
26879 * Return Code: the code returned by sd_send_scsi_cmd()
26880 * EINVAL if invalid arguments are provided
26881 * EFAULT if ddi_copyxxx() fails
26882 * ENXIO if fail ddi_get_soft_state
26883 * EIO if invalid mode sense block descriptor length
26884 *
26885 */
26886
26887 static int
26888 sr_change_blkmode(dev_t dev, int cmd, intptr_t data, int flag)
26889 {
26890 struct sd_lun *un = NULL;
26891 struct mode_header *sense_mhp, *select_mhp;
26892 struct block_descriptor *sense_desc, *select_desc;
26893 int current_bsize;
26894 int rval = EINVAL;
26895 uchar_t *sense = NULL;
26896 uchar_t *select = NULL;
26897 sd_ssc_t *ssc;
26898
26899 ASSERT((cmd == CDROMGBLKMODE) || (cmd == CDROMSBLKMODE));
26900
26901 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
26902 return (ENXIO);
26903 }
26904
26905 /*
26906 * The block length is changed via the Mode Select block descriptor, the
26907 * "Read/Write Error Recovery" mode page (0x1) contents are not actually
26908 * required as part of this routine. Therefore the mode sense allocation
26909 * length is specified to be the length of a mode page header and a
26910 * block descriptor.
26911 */
26912 sense = kmem_zalloc(BUFLEN_CHG_BLK_MODE, KM_SLEEP);
26913
26914 ssc = sd_ssc_init(un);
26915 rval = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP0, sense,
26916 BUFLEN_CHG_BLK_MODE, MODEPAGE_ERR_RECOV, SD_PATH_STANDARD);
26917 sd_ssc_fini(ssc);
26918 if (rval != 0) {
26919 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
26920 "sr_change_blkmode: Mode Sense Failed\n");
26921 kmem_free(sense, BUFLEN_CHG_BLK_MODE);
26922 return (rval);
26923 }
26924
26925 /* Check the block descriptor len to handle only 1 block descriptor */
26926 sense_mhp = (struct mode_header *)sense;
26927 if ((sense_mhp->bdesc_length == 0) ||
26928 (sense_mhp->bdesc_length > MODE_BLK_DESC_LENGTH)) {
26929 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
26930 "sr_change_blkmode: Mode Sense returned invalid block"
26931 " descriptor length\n");
26932 kmem_free(sense, BUFLEN_CHG_BLK_MODE);
26933 return (EIO);
26934 }
26935 sense_desc = (struct block_descriptor *)(sense + MODE_HEADER_LENGTH);
26936 current_bsize = ((sense_desc->blksize_hi << 16) |
26937 (sense_desc->blksize_mid << 8) | sense_desc->blksize_lo);
26938
26939 /* Process command */
26940 switch (cmd) {
26941 case CDROMGBLKMODE:
26942 /* Return the block size obtained during the mode sense */
26943 if (ddi_copyout(¤t_bsize, (void *)data,
26944 sizeof (int), flag) != 0)
26945 rval = EFAULT;
26946 break;
26947 case CDROMSBLKMODE:
26948 /* Validate the requested block size */
26949 switch (data) {
26950 case CDROM_BLK_512:
26951 case CDROM_BLK_1024:
26952 case CDROM_BLK_2048:
26953 case CDROM_BLK_2056:
26954 case CDROM_BLK_2336:
26955 case CDROM_BLK_2340:
26956 case CDROM_BLK_2352:
26957 case CDROM_BLK_2368:
26958 case CDROM_BLK_2448:
26959 case CDROM_BLK_2646:
26960 case CDROM_BLK_2647:
26961 break;
26962 default:
26963 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
26964 "sr_change_blkmode: "
26965 "Block Size '%ld' Not Supported\n", data);
26966 kmem_free(sense, BUFLEN_CHG_BLK_MODE);
26967 return (EINVAL);
26968 }
26969
26970 /*
26971 * The current block size matches the requested block size so
26972 * there is no need to send the mode select to change the size
26973 */
26974 if (current_bsize == data) {
26975 break;
26976 }
26977
26978 /* Build the select data for the requested block size */
26979 select = kmem_zalloc(BUFLEN_CHG_BLK_MODE, KM_SLEEP);
26980 select_mhp = (struct mode_header *)select;
26981 select_desc =
26982 (struct block_descriptor *)(select + MODE_HEADER_LENGTH);
26983 /*
26984 * The LBA size is changed via the block descriptor, so the
26985 * descriptor is built according to the user data
26986 */
26987 select_mhp->bdesc_length = MODE_BLK_DESC_LENGTH;
26988 select_desc->blksize_hi = (char)(((data) & 0x00ff0000) >> 16);
26989 select_desc->blksize_mid = (char)(((data) & 0x0000ff00) >> 8);
26990 select_desc->blksize_lo = (char)((data) & 0x000000ff);
26991
26992 /* Send the mode select for the requested block size */
26993 ssc = sd_ssc_init(un);
26994 rval = sd_send_scsi_MODE_SELECT(ssc, CDB_GROUP0,
26995 select, BUFLEN_CHG_BLK_MODE, SD_DONTSAVE_PAGE,
26996 SD_PATH_STANDARD);
26997 sd_ssc_fini(ssc);
26998 if (rval != 0) {
26999 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27000 "sr_change_blkmode: Mode Select Failed\n");
27001 /*
27002 * The mode select failed for the requested block size,
27003 * so reset the data for the original block size and
27004 * send it to the target. The error is indicated by the
27005 * return value for the failed mode select.
27006 */
27007 select_desc->blksize_hi = sense_desc->blksize_hi;
27008 select_desc->blksize_mid = sense_desc->blksize_mid;
27009 select_desc->blksize_lo = sense_desc->blksize_lo;
27010 ssc = sd_ssc_init(un);
27011 (void) sd_send_scsi_MODE_SELECT(ssc, CDB_GROUP0,
27012 select, BUFLEN_CHG_BLK_MODE, SD_DONTSAVE_PAGE,
27013 SD_PATH_STANDARD);
27014 sd_ssc_fini(ssc);
27015 } else {
27016 ASSERT(!mutex_owned(SD_MUTEX(un)));
27017 mutex_enter(SD_MUTEX(un));
27018 sd_update_block_info(un, (uint32_t)data, 0);
27019 mutex_exit(SD_MUTEX(un));
27020 }
27021 break;
27022 default:
27023 /* should not reach here, but check anyway */
27024 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27025 "sr_change_blkmode: Command '%x' Not Supported\n", cmd);
27026 rval = EINVAL;
27027 break;
27028 }
27029
27030 if (select) {
27031 kmem_free(select, BUFLEN_CHG_BLK_MODE);
27032 }
27033 if (sense) {
27034 kmem_free(sense, BUFLEN_CHG_BLK_MODE);
27035 }
27036 return (rval);
27037 }
27038
27039
27040 /*
27041 * Note: The following sr_change_speed() and sr_atapi_change_speed() routines
27042 * implement driver support for getting and setting the CD speed. The command
27043 * set used will be based on the device type. If the device has not been
27044 * identified as MMC the Toshiba vendor specific mode page will be used. If
27045 * the device is MMC but does not support the Real Time Streaming feature
27046 * the SET CD SPEED command will be used to set speed and mode page 0x2A will
27047 * be used to read the speed.
27048 */
27049
27050 /*
27051 * Function: sr_change_speed()
27052 *
27053 * Description: This routine is the driver entry point for handling CD-ROM
27054 * drive speed ioctl requests for devices supporting the Toshiba
27055 * vendor specific drive speed mode page. Support for returning
27056 * and changing the current drive speed in use by the device is
27057 * implemented.
27058 *
27059 * Arguments: dev - the device 'dev_t'
27060 * cmd - the request type; one of CDROMGDRVSPEED (get) or
27061 * CDROMSDRVSPEED (set)
27062 * data - current drive speed or requested drive speed
27063 * flag - this argument is a pass through to ddi_copyxxx() directly
27064 * from the mode argument of ioctl().
27065 *
27066 * Return Code: the code returned by sd_send_scsi_cmd()
27067 * EINVAL if invalid arguments are provided
27068 * EFAULT if ddi_copyxxx() fails
27069 * ENXIO if fail ddi_get_soft_state
27070 * EIO if invalid mode sense block descriptor length
27071 */
27072
27073 static int
27074 sr_change_speed(dev_t dev, int cmd, intptr_t data, int flag)
27075 {
27076 struct sd_lun *un = NULL;
27077 struct mode_header *sense_mhp, *select_mhp;
27078 struct mode_speed *sense_page, *select_page;
27079 int current_speed;
27080 int rval = EINVAL;
27081 int bd_len;
27082 uchar_t *sense = NULL;
27083 uchar_t *select = NULL;
27084 sd_ssc_t *ssc;
27085
27086 ASSERT((cmd == CDROMGDRVSPEED) || (cmd == CDROMSDRVSPEED));
27087 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
27088 return (ENXIO);
27089 }
27090
27091 /*
27092 * Note: The drive speed is being modified here according to a Toshiba
27093 * vendor specific mode page (0x31).
27094 */
27095 sense = kmem_zalloc(BUFLEN_MODE_CDROM_SPEED, KM_SLEEP);
27096
27097 ssc = sd_ssc_init(un);
27098 rval = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP0, sense,
27099 BUFLEN_MODE_CDROM_SPEED, CDROM_MODE_SPEED,
27100 SD_PATH_STANDARD);
27101 sd_ssc_fini(ssc);
27102 if (rval != 0) {
27103 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27104 "sr_change_speed: Mode Sense Failed\n");
27105 kmem_free(sense, BUFLEN_MODE_CDROM_SPEED);
27106 return (rval);
27107 }
27108 sense_mhp = (struct mode_header *)sense;
27109
27110 /* Check the block descriptor len to handle only 1 block descriptor */
27111 bd_len = sense_mhp->bdesc_length;
27112 if (bd_len > MODE_BLK_DESC_LENGTH) {
27113 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27114 "sr_change_speed: Mode Sense returned invalid block "
27115 "descriptor length\n");
27116 kmem_free(sense, BUFLEN_MODE_CDROM_SPEED);
27117 return (EIO);
27118 }
27119
27120 sense_page = (struct mode_speed *)
27121 (sense + MODE_HEADER_LENGTH + sense_mhp->bdesc_length);
27122 current_speed = sense_page->speed;
27123
27124 /* Process command */
27125 switch (cmd) {
27126 case CDROMGDRVSPEED:
27127 /* Return the drive speed obtained during the mode sense */
27128 if (current_speed == 0x2) {
27129 current_speed = CDROM_TWELVE_SPEED;
27130 }
27131 if (ddi_copyout(¤t_speed, (void *)data,
27132 sizeof (int), flag) != 0) {
27133 rval = EFAULT;
27134 }
27135 break;
27136 case CDROMSDRVSPEED:
27137 /* Validate the requested drive speed */
27138 switch ((uchar_t)data) {
27139 case CDROM_TWELVE_SPEED:
27140 data = 0x2;
27141 /*FALLTHROUGH*/
27142 case CDROM_NORMAL_SPEED:
27143 case CDROM_DOUBLE_SPEED:
27144 case CDROM_QUAD_SPEED:
27145 case CDROM_MAXIMUM_SPEED:
27146 break;
27147 default:
27148 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27149 "sr_change_speed: "
27150 "Drive Speed '%d' Not Supported\n", (uchar_t)data);
27151 kmem_free(sense, BUFLEN_MODE_CDROM_SPEED);
27152 return (EINVAL);
27153 }
27154
27155 /*
27156 * The current drive speed matches the requested drive speed so
27157 * there is no need to send the mode select to change the speed
27158 */
27159 if (current_speed == data) {
27160 break;
27161 }
27162
27163 /* Build the select data for the requested drive speed */
27164 select = kmem_zalloc(BUFLEN_MODE_CDROM_SPEED, KM_SLEEP);
27165 select_mhp = (struct mode_header *)select;
27166 select_mhp->bdesc_length = 0;
27167 select_page =
27168 (struct mode_speed *)(select + MODE_HEADER_LENGTH);
27169 select_page =
27170 (struct mode_speed *)(select + MODE_HEADER_LENGTH);
27171 select_page->mode_page.code = CDROM_MODE_SPEED;
27172 select_page->mode_page.length = 2;
27173 select_page->speed = (uchar_t)data;
27174
27175 /* Send the mode select for the requested block size */
27176 ssc = sd_ssc_init(un);
27177 rval = sd_send_scsi_MODE_SELECT(ssc, CDB_GROUP0, select,
27178 MODEPAGE_CDROM_SPEED_LEN + MODE_HEADER_LENGTH,
27179 SD_DONTSAVE_PAGE, SD_PATH_STANDARD);
27180 sd_ssc_fini(ssc);
27181 if (rval != 0) {
27182 /*
27183 * The mode select failed for the requested drive speed,
27184 * so reset the data for the original drive speed and
27185 * send it to the target. The error is indicated by the
27186 * return value for the failed mode select.
27187 */
27188 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27189 "sr_drive_speed: Mode Select Failed\n");
27190 select_page->speed = sense_page->speed;
27191 ssc = sd_ssc_init(un);
27192 (void) sd_send_scsi_MODE_SELECT(ssc, CDB_GROUP0, select,
27193 MODEPAGE_CDROM_SPEED_LEN + MODE_HEADER_LENGTH,
27194 SD_DONTSAVE_PAGE, SD_PATH_STANDARD);
27195 sd_ssc_fini(ssc);
27196 }
27197 break;
27198 default:
27199 /* should not reach here, but check anyway */
27200 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27201 "sr_change_speed: Command '%x' Not Supported\n", cmd);
27202 rval = EINVAL;
27203 break;
27204 }
27205
27206 if (select) {
27207 kmem_free(select, BUFLEN_MODE_CDROM_SPEED);
27208 }
27209 if (sense) {
27210 kmem_free(sense, BUFLEN_MODE_CDROM_SPEED);
27211 }
27212
27213 return (rval);
27214 }
27215
27216
27217 /*
27218 * Function: sr_atapi_change_speed()
27219 *
27220 * Description: This routine is the driver entry point for handling CD-ROM
27221 * drive speed ioctl requests for MMC devices that do not support
27222 * the Real Time Streaming feature (0x107).
27223 *
27224 * Note: This routine will use the SET SPEED command which may not
27225 * be supported by all devices.
27226 *
27227 * Arguments: dev- the device 'dev_t'
27228 * cmd- the request type; one of CDROMGDRVSPEED (get) or
27229 * CDROMSDRVSPEED (set)
27230 * data- current drive speed or requested drive speed
27231 * flag- this argument is a pass through to ddi_copyxxx() directly
27232 * from the mode argument of ioctl().
27233 *
27234 * Return Code: the code returned by sd_send_scsi_cmd()
27235 * EINVAL if invalid arguments are provided
27236 * EFAULT if ddi_copyxxx() fails
27237 * ENXIO if fail ddi_get_soft_state
27238 * EIO if invalid mode sense block descriptor length
27239 */
27240
27241 static int
27242 sr_atapi_change_speed(dev_t dev, int cmd, intptr_t data, int flag)
27243 {
27244 struct sd_lun *un;
27245 struct uscsi_cmd *com = NULL;
27246 struct mode_header_grp2 *sense_mhp;
27247 uchar_t *sense_page;
27248 uchar_t *sense = NULL;
27249 char cdb[CDB_GROUP5];
27250 int bd_len;
27251 int current_speed = 0;
27252 int max_speed = 0;
27253 int rval;
27254 sd_ssc_t *ssc;
27255
27256 ASSERT((cmd == CDROMGDRVSPEED) || (cmd == CDROMSDRVSPEED));
27257
27258 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
27259 return (ENXIO);
27260 }
27261
27262 sense = kmem_zalloc(BUFLEN_MODE_CDROM_CAP, KM_SLEEP);
27263
27264 ssc = sd_ssc_init(un);
27265 rval = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP1, sense,
27266 BUFLEN_MODE_CDROM_CAP, MODEPAGE_CDROM_CAP,
27267 SD_PATH_STANDARD);
27268 sd_ssc_fini(ssc);
27269 if (rval != 0) {
27270 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27271 "sr_atapi_change_speed: Mode Sense Failed\n");
27272 kmem_free(sense, BUFLEN_MODE_CDROM_CAP);
27273 return (rval);
27274 }
27275
27276 /* Check the block descriptor len to handle only 1 block descriptor */
27277 sense_mhp = (struct mode_header_grp2 *)sense;
27278 bd_len = (sense_mhp->bdesc_length_hi << 8) | sense_mhp->bdesc_length_lo;
27279 if (bd_len > MODE_BLK_DESC_LENGTH) {
27280 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27281 "sr_atapi_change_speed: Mode Sense returned invalid "
27282 "block descriptor length\n");
27283 kmem_free(sense, BUFLEN_MODE_CDROM_CAP);
27284 return (EIO);
27285 }
27286
27287 /* Calculate the current and maximum drive speeds */
27288 sense_page = (uchar_t *)(sense + MODE_HEADER_LENGTH_GRP2 + bd_len);
27289 current_speed = (sense_page[14] << 8) | sense_page[15];
27290 max_speed = (sense_page[8] << 8) | sense_page[9];
27291
27292 /* Process the command */
27293 switch (cmd) {
27294 case CDROMGDRVSPEED:
27295 current_speed /= SD_SPEED_1X;
27296 if (ddi_copyout(¤t_speed, (void *)data,
27297 sizeof (int), flag) != 0)
27298 rval = EFAULT;
27299 break;
27300 case CDROMSDRVSPEED:
27301 /* Convert the speed code to KB/sec */
27302 switch ((uchar_t)data) {
27303 case CDROM_NORMAL_SPEED:
27304 current_speed = SD_SPEED_1X;
27305 break;
27306 case CDROM_DOUBLE_SPEED:
27307 current_speed = 2 * SD_SPEED_1X;
27308 break;
27309 case CDROM_QUAD_SPEED:
27310 current_speed = 4 * SD_SPEED_1X;
27311 break;
27312 case CDROM_TWELVE_SPEED:
27313 current_speed = 12 * SD_SPEED_1X;
27314 break;
27315 case CDROM_MAXIMUM_SPEED:
27316 current_speed = 0xffff;
27317 break;
27318 default:
27319 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27320 "sr_atapi_change_speed: invalid drive speed %d\n",
27321 (uchar_t)data);
27322 kmem_free(sense, BUFLEN_MODE_CDROM_CAP);
27323 return (EINVAL);
27324 }
27325
27326 /* Check the request against the drive's max speed. */
27327 if (current_speed != 0xffff) {
27328 if (current_speed > max_speed) {
27329 kmem_free(sense, BUFLEN_MODE_CDROM_CAP);
27330 return (EINVAL);
27331 }
27332 }
27333
27334 /*
27335 * Build and send the SET SPEED command
27336 *
27337 * Note: The SET SPEED (0xBB) command used in this routine is
27338 * obsolete per the SCSI MMC spec but still supported in the
27339 * MT FUJI vendor spec. Most equipment is adhereing to MT FUJI
27340 * therefore the command is still implemented in this routine.
27341 */
27342 bzero(cdb, sizeof (cdb));
27343 cdb[0] = (char)SCMD_SET_CDROM_SPEED;
27344 cdb[2] = (uchar_t)(current_speed >> 8);
27345 cdb[3] = (uchar_t)current_speed;
27346 com = kmem_zalloc(sizeof (*com), KM_SLEEP);
27347 com->uscsi_cdb = (caddr_t)cdb;
27348 com->uscsi_cdblen = CDB_GROUP5;
27349 com->uscsi_bufaddr = NULL;
27350 com->uscsi_buflen = 0;
27351 com->uscsi_flags = USCSI_DIAGNOSE|USCSI_SILENT;
27352 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, 0, SD_PATH_STANDARD);
27353 break;
27354 default:
27355 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27356 "sr_atapi_change_speed: Command '%x' Not Supported\n", cmd);
27357 rval = EINVAL;
27358 }
27359
27360 if (sense) {
27361 kmem_free(sense, BUFLEN_MODE_CDROM_CAP);
27362 }
27363 if (com) {
27364 kmem_free(com, sizeof (*com));
27365 }
27366 return (rval);
27367 }
27368
27369
27370 /*
27371 * Function: sr_pause_resume()
27372 *
27373 * Description: This routine is the driver entry point for handling CD-ROM
27374 * pause/resume ioctl requests. This only affects the audio play
27375 * operation.
27376 *
27377 * Arguments: dev - the device 'dev_t'
27378 * cmd - the request type; one of CDROMPAUSE or CDROMRESUME, used
27379 * for setting the resume bit of the cdb.
27380 *
27381 * Return Code: the code returned by sd_send_scsi_cmd()
27382 * EINVAL if invalid mode specified
27383 *
27384 */
27385
27386 static int
27387 sr_pause_resume(dev_t dev, int cmd)
27388 {
27389 struct sd_lun *un;
27390 struct uscsi_cmd *com;
27391 char cdb[CDB_GROUP1];
27392 int rval;
27393
27394 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
27395 return (ENXIO);
27396 }
27397
27398 com = kmem_zalloc(sizeof (*com), KM_SLEEP);
27399 bzero(cdb, CDB_GROUP1);
27400 cdb[0] = SCMD_PAUSE_RESUME;
27401 switch (cmd) {
27402 case CDROMRESUME:
27403 cdb[8] = 1;
27404 break;
27405 case CDROMPAUSE:
27406 cdb[8] = 0;
27407 break;
27408 default:
27409 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, "sr_pause_resume:"
27410 " Command '%x' Not Supported\n", cmd);
27411 rval = EINVAL;
27412 goto done;
27413 }
27414
27415 com->uscsi_cdb = cdb;
27416 com->uscsi_cdblen = CDB_GROUP1;
27417 com->uscsi_flags = USCSI_DIAGNOSE|USCSI_SILENT;
27418
27419 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_SYSSPACE,
27420 SD_PATH_STANDARD);
27421
27422 done:
27423 kmem_free(com, sizeof (*com));
27424 return (rval);
27425 }
27426
27427
27428 /*
27429 * Function: sr_play_msf()
27430 *
27431 * Description: This routine is the driver entry point for handling CD-ROM
27432 * ioctl requests to output the audio signals at the specified
27433 * starting address and continue the audio play until the specified
27434 * ending address (CDROMPLAYMSF) The address is in Minute Second
27435 * Frame (MSF) format.
27436 *
27437 * Arguments: dev - the device 'dev_t'
27438 * data - pointer to user provided audio msf structure,
27439 * specifying start/end addresses.
27440 * flag - this argument is a pass through to ddi_copyxxx()
27441 * directly from the mode argument of ioctl().
27442 *
27443 * Return Code: the code returned by sd_send_scsi_cmd()
27444 * EFAULT if ddi_copyxxx() fails
27445 * ENXIO if fail ddi_get_soft_state
27446 * EINVAL if data pointer is NULL
27447 */
27448
27449 static int
27450 sr_play_msf(dev_t dev, caddr_t data, int flag)
27451 {
27452 struct sd_lun *un;
27453 struct uscsi_cmd *com;
27454 struct cdrom_msf msf_struct;
27455 struct cdrom_msf *msf = &msf_struct;
27456 char cdb[CDB_GROUP1];
27457 int rval;
27458
27459 if (data == NULL) {
27460 return (EINVAL);
27461 }
27462
27463 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
27464 return (ENXIO);
27465 }
27466
27467 if (ddi_copyin(data, msf, sizeof (struct cdrom_msf), flag)) {
27468 return (EFAULT);
27469 }
27470
27471 com = kmem_zalloc(sizeof (*com), KM_SLEEP);
27472 bzero(cdb, CDB_GROUP1);
27473 cdb[0] = SCMD_PLAYAUDIO_MSF;
27474 if (un->un_f_cfg_playmsf_bcd == TRUE) {
27475 cdb[3] = BYTE_TO_BCD(msf->cdmsf_min0);
27476 cdb[4] = BYTE_TO_BCD(msf->cdmsf_sec0);
27477 cdb[5] = BYTE_TO_BCD(msf->cdmsf_frame0);
27478 cdb[6] = BYTE_TO_BCD(msf->cdmsf_min1);
27479 cdb[7] = BYTE_TO_BCD(msf->cdmsf_sec1);
27480 cdb[8] = BYTE_TO_BCD(msf->cdmsf_frame1);
27481 } else {
27482 cdb[3] = msf->cdmsf_min0;
27483 cdb[4] = msf->cdmsf_sec0;
27484 cdb[5] = msf->cdmsf_frame0;
27485 cdb[6] = msf->cdmsf_min1;
27486 cdb[7] = msf->cdmsf_sec1;
27487 cdb[8] = msf->cdmsf_frame1;
27488 }
27489 com->uscsi_cdb = cdb;
27490 com->uscsi_cdblen = CDB_GROUP1;
27491 com->uscsi_flags = USCSI_DIAGNOSE|USCSI_SILENT;
27492 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_SYSSPACE,
27493 SD_PATH_STANDARD);
27494 kmem_free(com, sizeof (*com));
27495 return (rval);
27496 }
27497
27498
27499 /*
27500 * Function: sr_play_trkind()
27501 *
27502 * Description: This routine is the driver entry point for handling CD-ROM
27503 * ioctl requests to output the audio signals at the specified
27504 * starting address and continue the audio play until the specified
27505 * ending address (CDROMPLAYTRKIND). The address is in Track Index
27506 * format.
27507 *
27508 * Arguments: dev - the device 'dev_t'
27509 * data - pointer to user provided audio track/index structure,
27510 * specifying start/end addresses.
27511 * flag - this argument is a pass through to ddi_copyxxx()
27512 * directly from the mode argument of ioctl().
27513 *
27514 * Return Code: the code returned by sd_send_scsi_cmd()
27515 * EFAULT if ddi_copyxxx() fails
27516 * ENXIO if fail ddi_get_soft_state
27517 * EINVAL if data pointer is NULL
27518 */
27519
27520 static int
27521 sr_play_trkind(dev_t dev, caddr_t data, int flag)
27522 {
27523 struct cdrom_ti ti_struct;
27524 struct cdrom_ti *ti = &ti_struct;
27525 struct uscsi_cmd *com = NULL;
27526 char cdb[CDB_GROUP1];
27527 int rval;
27528
27529 if (data == NULL) {
27530 return (EINVAL);
27531 }
27532
27533 if (ddi_copyin(data, ti, sizeof (struct cdrom_ti), flag)) {
27534 return (EFAULT);
27535 }
27536
27537 com = kmem_zalloc(sizeof (*com), KM_SLEEP);
27538 bzero(cdb, CDB_GROUP1);
27539 cdb[0] = SCMD_PLAYAUDIO_TI;
27540 cdb[4] = ti->cdti_trk0;
27541 cdb[5] = ti->cdti_ind0;
27542 cdb[7] = ti->cdti_trk1;
27543 cdb[8] = ti->cdti_ind1;
27544 com->uscsi_cdb = cdb;
27545 com->uscsi_cdblen = CDB_GROUP1;
27546 com->uscsi_flags = USCSI_DIAGNOSE|USCSI_SILENT;
27547 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_SYSSPACE,
27548 SD_PATH_STANDARD);
27549 kmem_free(com, sizeof (*com));
27550 return (rval);
27551 }
27552
27553
27554 /*
27555 * Function: sr_read_all_subcodes()
27556 *
27557 * Description: This routine is the driver entry point for handling CD-ROM
27558 * ioctl requests to return raw subcode data while the target is
27559 * playing audio (CDROMSUBCODE).
27560 *
27561 * Arguments: dev - the device 'dev_t'
27562 * data - pointer to user provided cdrom subcode structure,
27563 * specifying the transfer length and address.
27564 * flag - this argument is a pass through to ddi_copyxxx()
27565 * directly from the mode argument of ioctl().
27566 *
27567 * Return Code: the code returned by sd_send_scsi_cmd()
27568 * EFAULT if ddi_copyxxx() fails
27569 * ENXIO if fail ddi_get_soft_state
27570 * EINVAL if data pointer is NULL
27571 */
27572
27573 static int
27574 sr_read_all_subcodes(dev_t dev, caddr_t data, int flag)
27575 {
27576 struct sd_lun *un = NULL;
27577 struct uscsi_cmd *com = NULL;
27578 struct cdrom_subcode *subcode = NULL;
27579 int rval;
27580 size_t buflen;
27581 char cdb[CDB_GROUP5];
27582
27583 #ifdef _MULTI_DATAMODEL
27584 /* To support ILP32 applications in an LP64 world */
27585 struct cdrom_subcode32 cdrom_subcode32;
27586 struct cdrom_subcode32 *cdsc32 = &cdrom_subcode32;
27587 #endif
27588 if (data == NULL) {
27589 return (EINVAL);
27590 }
27591
27592 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
27593 return (ENXIO);
27594 }
27595
27596 subcode = kmem_zalloc(sizeof (struct cdrom_subcode), KM_SLEEP);
27597
27598 #ifdef _MULTI_DATAMODEL
27599 switch (ddi_model_convert_from(flag & FMODELS)) {
27600 case DDI_MODEL_ILP32:
27601 if (ddi_copyin(data, cdsc32, sizeof (*cdsc32), flag)) {
27602 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27603 "sr_read_all_subcodes: ddi_copyin Failed\n");
27604 kmem_free(subcode, sizeof (struct cdrom_subcode));
27605 return (EFAULT);
27606 }
27607 /* Convert the ILP32 uscsi data from the application to LP64 */
27608 cdrom_subcode32tocdrom_subcode(cdsc32, subcode);
27609 break;
27610 case DDI_MODEL_NONE:
27611 if (ddi_copyin(data, subcode,
27612 sizeof (struct cdrom_subcode), flag)) {
27613 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27614 "sr_read_all_subcodes: ddi_copyin Failed\n");
27615 kmem_free(subcode, sizeof (struct cdrom_subcode));
27616 return (EFAULT);
27617 }
27618 break;
27619 }
27620 #else /* ! _MULTI_DATAMODEL */
27621 if (ddi_copyin(data, subcode, sizeof (struct cdrom_subcode), flag)) {
27622 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27623 "sr_read_all_subcodes: ddi_copyin Failed\n");
27624 kmem_free(subcode, sizeof (struct cdrom_subcode));
27625 return (EFAULT);
27626 }
27627 #endif /* _MULTI_DATAMODEL */
27628
27629 /*
27630 * Since MMC-2 expects max 3 bytes for length, check if the
27631 * length input is greater than 3 bytes
27632 */
27633 if ((subcode->cdsc_length & 0xFF000000) != 0) {
27634 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27635 "sr_read_all_subcodes: "
27636 "cdrom transfer length too large: %d (limit %d)\n",
27637 subcode->cdsc_length, 0xFFFFFF);
27638 kmem_free(subcode, sizeof (struct cdrom_subcode));
27639 return (EINVAL);
27640 }
27641
27642 buflen = CDROM_BLK_SUBCODE * subcode->cdsc_length;
27643 com = kmem_zalloc(sizeof (*com), KM_SLEEP);
27644 bzero(cdb, CDB_GROUP5);
27645
27646 if (un->un_f_mmc_cap == TRUE) {
27647 cdb[0] = (char)SCMD_READ_CD;
27648 cdb[2] = (char)0xff;
27649 cdb[3] = (char)0xff;
27650 cdb[4] = (char)0xff;
27651 cdb[5] = (char)0xff;
27652 cdb[6] = (((subcode->cdsc_length) & 0x00ff0000) >> 16);
27653 cdb[7] = (((subcode->cdsc_length) & 0x0000ff00) >> 8);
27654 cdb[8] = ((subcode->cdsc_length) & 0x000000ff);
27655 cdb[10] = 1;
27656 } else {
27657 /*
27658 * Note: A vendor specific command (0xDF) is being used her to
27659 * request a read of all subcodes.
27660 */
27661 cdb[0] = (char)SCMD_READ_ALL_SUBCODES;
27662 cdb[6] = (((subcode->cdsc_length) & 0xff000000) >> 24);
27663 cdb[7] = (((subcode->cdsc_length) & 0x00ff0000) >> 16);
27664 cdb[8] = (((subcode->cdsc_length) & 0x0000ff00) >> 8);
27665 cdb[9] = ((subcode->cdsc_length) & 0x000000ff);
27666 }
27667 com->uscsi_cdb = cdb;
27668 com->uscsi_cdblen = CDB_GROUP5;
27669 com->uscsi_bufaddr = (caddr_t)subcode->cdsc_addr;
27670 com->uscsi_buflen = buflen;
27671 com->uscsi_flags = USCSI_DIAGNOSE|USCSI_SILENT|USCSI_READ;
27672 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_USERSPACE,
27673 SD_PATH_STANDARD);
27674 kmem_free(subcode, sizeof (struct cdrom_subcode));
27675 kmem_free(com, sizeof (*com));
27676 return (rval);
27677 }
27678
27679
27680 /*
27681 * Function: sr_read_subchannel()
27682 *
27683 * Description: This routine is the driver entry point for handling CD-ROM
27684 * ioctl requests to return the Q sub-channel data of the CD
27685 * current position block. (CDROMSUBCHNL) The data includes the
27686 * track number, index number, absolute CD-ROM address (LBA or MSF
27687 * format per the user) , track relative CD-ROM address (LBA or MSF
27688 * format per the user), control data and audio status.
27689 *
27690 * Arguments: dev - the device 'dev_t'
27691 * data - pointer to user provided cdrom sub-channel structure
27692 * flag - this argument is a pass through to ddi_copyxxx()
27693 * directly from the mode argument of ioctl().
27694 *
27695 * Return Code: the code returned by sd_send_scsi_cmd()
27696 * EFAULT if ddi_copyxxx() fails
27697 * ENXIO if fail ddi_get_soft_state
27698 * EINVAL if data pointer is NULL
27699 */
27700
27701 static int
27702 sr_read_subchannel(dev_t dev, caddr_t data, int flag)
27703 {
27704 struct sd_lun *un;
27705 struct uscsi_cmd *com;
27706 struct cdrom_subchnl subchanel;
27707 struct cdrom_subchnl *subchnl = &subchanel;
27708 char cdb[CDB_GROUP1];
27709 caddr_t buffer;
27710 int rval;
27711
27712 if (data == NULL) {
27713 return (EINVAL);
27714 }
27715
27716 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
27717 (un->un_state == SD_STATE_OFFLINE)) {
27718 return (ENXIO);
27719 }
27720
27721 if (ddi_copyin(data, subchnl, sizeof (struct cdrom_subchnl), flag)) {
27722 return (EFAULT);
27723 }
27724
27725 buffer = kmem_zalloc((size_t)16, KM_SLEEP);
27726 bzero(cdb, CDB_GROUP1);
27727 cdb[0] = SCMD_READ_SUBCHANNEL;
27728 /* Set the MSF bit based on the user requested address format */
27729 cdb[1] = (subchnl->cdsc_format & CDROM_LBA) ? 0 : 0x02;
27730 /*
27731 * Set the Q bit in byte 2 to indicate that Q sub-channel data be
27732 * returned
27733 */
27734 cdb[2] = 0x40;
27735 /*
27736 * Set byte 3 to specify the return data format. A value of 0x01
27737 * indicates that the CD-ROM current position should be returned.
27738 */
27739 cdb[3] = 0x01;
27740 cdb[8] = 0x10;
27741 com = kmem_zalloc(sizeof (*com), KM_SLEEP);
27742 com->uscsi_cdb = cdb;
27743 com->uscsi_cdblen = CDB_GROUP1;
27744 com->uscsi_bufaddr = buffer;
27745 com->uscsi_buflen = 16;
27746 com->uscsi_flags = USCSI_DIAGNOSE|USCSI_SILENT|USCSI_READ;
27747 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_SYSSPACE,
27748 SD_PATH_STANDARD);
27749 if (rval != 0) {
27750 kmem_free(buffer, 16);
27751 kmem_free(com, sizeof (*com));
27752 return (rval);
27753 }
27754
27755 /* Process the returned Q sub-channel data */
27756 subchnl->cdsc_audiostatus = buffer[1];
27757 subchnl->cdsc_adr = (buffer[5] & 0xF0) >> 4;
27758 subchnl->cdsc_ctrl = (buffer[5] & 0x0F);
27759 subchnl->cdsc_trk = buffer[6];
27760 subchnl->cdsc_ind = buffer[7];
27761 if (subchnl->cdsc_format & CDROM_LBA) {
27762 subchnl->cdsc_absaddr.lba =
27763 ((uchar_t)buffer[8] << 24) + ((uchar_t)buffer[9] << 16) +
27764 ((uchar_t)buffer[10] << 8) + ((uchar_t)buffer[11]);
27765 subchnl->cdsc_reladdr.lba =
27766 ((uchar_t)buffer[12] << 24) + ((uchar_t)buffer[13] << 16) +
27767 ((uchar_t)buffer[14] << 8) + ((uchar_t)buffer[15]);
27768 } else if (un->un_f_cfg_readsub_bcd == TRUE) {
27769 subchnl->cdsc_absaddr.msf.minute = BCD_TO_BYTE(buffer[9]);
27770 subchnl->cdsc_absaddr.msf.second = BCD_TO_BYTE(buffer[10]);
27771 subchnl->cdsc_absaddr.msf.frame = BCD_TO_BYTE(buffer[11]);
27772 subchnl->cdsc_reladdr.msf.minute = BCD_TO_BYTE(buffer[13]);
27773 subchnl->cdsc_reladdr.msf.second = BCD_TO_BYTE(buffer[14]);
27774 subchnl->cdsc_reladdr.msf.frame = BCD_TO_BYTE(buffer[15]);
27775 } else {
27776 subchnl->cdsc_absaddr.msf.minute = buffer[9];
27777 subchnl->cdsc_absaddr.msf.second = buffer[10];
27778 subchnl->cdsc_absaddr.msf.frame = buffer[11];
27779 subchnl->cdsc_reladdr.msf.minute = buffer[13];
27780 subchnl->cdsc_reladdr.msf.second = buffer[14];
27781 subchnl->cdsc_reladdr.msf.frame = buffer[15];
27782 }
27783 kmem_free(buffer, 16);
27784 kmem_free(com, sizeof (*com));
27785 if (ddi_copyout(subchnl, data, sizeof (struct cdrom_subchnl), flag)
27786 != 0) {
27787 return (EFAULT);
27788 }
27789 return (rval);
27790 }
27791
27792
27793 /*
27794 * Function: sr_read_tocentry()
27795 *
27796 * Description: This routine is the driver entry point for handling CD-ROM
27797 * ioctl requests to read from the Table of Contents (TOC)
27798 * (CDROMREADTOCENTRY). This routine provides the ADR and CTRL
27799 * fields, the starting address (LBA or MSF format per the user)
27800 * and the data mode if the user specified track is a data track.
27801 *
27802 * Note: The READ HEADER (0x44) command used in this routine is
27803 * obsolete per the SCSI MMC spec but still supported in the
27804 * MT FUJI vendor spec. Most equipment is adhereing to MT FUJI
27805 * therefore the command is still implemented in this routine.
27806 *
27807 * Arguments: dev - the device 'dev_t'
27808 * data - pointer to user provided toc entry structure,
27809 * specifying the track # and the address format
27810 * (LBA or MSF).
27811 * flag - this argument is a pass through to ddi_copyxxx()
27812 * directly from the mode argument of ioctl().
27813 *
27814 * Return Code: the code returned by sd_send_scsi_cmd()
27815 * EFAULT if ddi_copyxxx() fails
27816 * ENXIO if fail ddi_get_soft_state
27817 * EINVAL if data pointer is NULL
27818 */
27819
27820 static int
27821 sr_read_tocentry(dev_t dev, caddr_t data, int flag)
27822 {
27823 struct sd_lun *un = NULL;
27824 struct uscsi_cmd *com;
27825 struct cdrom_tocentry toc_entry;
27826 struct cdrom_tocentry *entry = &toc_entry;
27827 caddr_t buffer;
27828 int rval;
27829 char cdb[CDB_GROUP1];
27830
27831 if (data == NULL) {
27832 return (EINVAL);
27833 }
27834
27835 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
27836 (un->un_state == SD_STATE_OFFLINE)) {
27837 return (ENXIO);
27838 }
27839
27840 if (ddi_copyin(data, entry, sizeof (struct cdrom_tocentry), flag)) {
27841 return (EFAULT);
27842 }
27843
27844 /* Validate the requested track and address format */
27845 if (!(entry->cdte_format & (CDROM_LBA | CDROM_MSF))) {
27846 return (EINVAL);
27847 }
27848
27849 if (entry->cdte_track == 0) {
27850 return (EINVAL);
27851 }
27852
27853 buffer = kmem_zalloc((size_t)12, KM_SLEEP);
27854 com = kmem_zalloc(sizeof (*com), KM_SLEEP);
27855 bzero(cdb, CDB_GROUP1);
27856
27857 cdb[0] = SCMD_READ_TOC;
27858 /* Set the MSF bit based on the user requested address format */
27859 cdb[1] = ((entry->cdte_format & CDROM_LBA) ? 0 : 2);
27860 if (un->un_f_cfg_read_toc_trk_bcd == TRUE) {
27861 cdb[6] = BYTE_TO_BCD(entry->cdte_track);
27862 } else {
27863 cdb[6] = entry->cdte_track;
27864 }
27865
27866 /*
27867 * Bytes 7 & 8 are the 12 byte allocation length for a single entry.
27868 * (4 byte TOC response header + 8 byte track descriptor)
27869 */
27870 cdb[8] = 12;
27871 com->uscsi_cdb = cdb;
27872 com->uscsi_cdblen = CDB_GROUP1;
27873 com->uscsi_bufaddr = buffer;
27874 com->uscsi_buflen = 0x0C;
27875 com->uscsi_flags = (USCSI_DIAGNOSE | USCSI_SILENT | USCSI_READ);
27876 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_SYSSPACE,
27877 SD_PATH_STANDARD);
27878 if (rval != 0) {
27879 kmem_free(buffer, 12);
27880 kmem_free(com, sizeof (*com));
27881 return (rval);
27882 }
27883
27884 /* Process the toc entry */
27885 entry->cdte_adr = (buffer[5] & 0xF0) >> 4;
27886 entry->cdte_ctrl = (buffer[5] & 0x0F);
27887 if (entry->cdte_format & CDROM_LBA) {
27888 entry->cdte_addr.lba =
27889 ((uchar_t)buffer[8] << 24) + ((uchar_t)buffer[9] << 16) +
27890 ((uchar_t)buffer[10] << 8) + ((uchar_t)buffer[11]);
27891 } else if (un->un_f_cfg_read_toc_addr_bcd == TRUE) {
27892 entry->cdte_addr.msf.minute = BCD_TO_BYTE(buffer[9]);
27893 entry->cdte_addr.msf.second = BCD_TO_BYTE(buffer[10]);
27894 entry->cdte_addr.msf.frame = BCD_TO_BYTE(buffer[11]);
27895 /*
27896 * Send a READ TOC command using the LBA address format to get
27897 * the LBA for the track requested so it can be used in the
27898 * READ HEADER request
27899 *
27900 * Note: The MSF bit of the READ HEADER command specifies the
27901 * output format. The block address specified in that command
27902 * must be in LBA format.
27903 */
27904 cdb[1] = 0;
27905 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_SYSSPACE,
27906 SD_PATH_STANDARD);
27907 if (rval != 0) {
27908 kmem_free(buffer, 12);
27909 kmem_free(com, sizeof (*com));
27910 return (rval);
27911 }
27912 } else {
27913 entry->cdte_addr.msf.minute = buffer[9];
27914 entry->cdte_addr.msf.second = buffer[10];
27915 entry->cdte_addr.msf.frame = buffer[11];
27916 /*
27917 * Send a READ TOC command using the LBA address format to get
27918 * the LBA for the track requested so it can be used in the
27919 * READ HEADER request
27920 *
27921 * Note: The MSF bit of the READ HEADER command specifies the
27922 * output format. The block address specified in that command
27923 * must be in LBA format.
27924 */
27925 cdb[1] = 0;
27926 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_SYSSPACE,
27927 SD_PATH_STANDARD);
27928 if (rval != 0) {
27929 kmem_free(buffer, 12);
27930 kmem_free(com, sizeof (*com));
27931 return (rval);
27932 }
27933 }
27934
27935 /*
27936 * Build and send the READ HEADER command to determine the data mode of
27937 * the user specified track.
27938 */
27939 if ((entry->cdte_ctrl & CDROM_DATA_TRACK) &&
27940 (entry->cdte_track != CDROM_LEADOUT)) {
27941 bzero(cdb, CDB_GROUP1);
27942 cdb[0] = SCMD_READ_HEADER;
27943 cdb[2] = buffer[8];
27944 cdb[3] = buffer[9];
27945 cdb[4] = buffer[10];
27946 cdb[5] = buffer[11];
27947 cdb[8] = 0x08;
27948 com->uscsi_buflen = 0x08;
27949 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_SYSSPACE,
27950 SD_PATH_STANDARD);
27951 if (rval == 0) {
27952 entry->cdte_datamode = buffer[0];
27953 } else {
27954 /*
27955 * READ HEADER command failed, since this is
27956 * obsoleted in one spec, its better to return
27957 * -1 for an invlid track so that we can still
27958 * receive the rest of the TOC data.
27959 */
27960 entry->cdte_datamode = (uchar_t)-1;
27961 }
27962 } else {
27963 entry->cdte_datamode = (uchar_t)-1;
27964 }
27965
27966 kmem_free(buffer, 12);
27967 kmem_free(com, sizeof (*com));
27968 if (ddi_copyout(entry, data, sizeof (struct cdrom_tocentry), flag) != 0)
27969 return (EFAULT);
27970
27971 return (rval);
27972 }
27973
27974
27975 /*
27976 * Function: sr_read_tochdr()
27977 *
27978 * Description: This routine is the driver entry point for handling CD-ROM
27979 * ioctl requests to read the Table of Contents (TOC) header
27980 * (CDROMREADTOHDR). The TOC header consists of the disk starting
27981 * and ending track numbers
27982 *
27983 * Arguments: dev - the device 'dev_t'
27984 * data - pointer to user provided toc header structure,
27985 * specifying the starting and ending track numbers.
27986 * flag - this argument is a pass through to ddi_copyxxx()
27987 * directly from the mode argument of ioctl().
27988 *
27989 * Return Code: the code returned by sd_send_scsi_cmd()
27990 * EFAULT if ddi_copyxxx() fails
27991 * ENXIO if fail ddi_get_soft_state
27992 * EINVAL if data pointer is NULL
27993 */
27994
27995 static int
27996 sr_read_tochdr(dev_t dev, caddr_t data, int flag)
27997 {
27998 struct sd_lun *un;
27999 struct uscsi_cmd *com;
28000 struct cdrom_tochdr toc_header;
28001 struct cdrom_tochdr *hdr = &toc_header;
28002 char cdb[CDB_GROUP1];
28003 int rval;
28004 caddr_t buffer;
28005
28006 if (data == NULL) {
28007 return (EINVAL);
28008 }
28009
28010 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
28011 (un->un_state == SD_STATE_OFFLINE)) {
28012 return (ENXIO);
28013 }
28014
28015 buffer = kmem_zalloc(4, KM_SLEEP);
28016 bzero(cdb, CDB_GROUP1);
28017 cdb[0] = SCMD_READ_TOC;
28018 /*
28019 * Specifying a track number of 0x00 in the READ TOC command indicates
28020 * that the TOC header should be returned
28021 */
28022 cdb[6] = 0x00;
28023 /*
28024 * Bytes 7 & 8 are the 4 byte allocation length for TOC header.
28025 * (2 byte data len + 1 byte starting track # + 1 byte ending track #)
28026 */
28027 cdb[8] = 0x04;
28028 com = kmem_zalloc(sizeof (*com), KM_SLEEP);
28029 com->uscsi_cdb = cdb;
28030 com->uscsi_cdblen = CDB_GROUP1;
28031 com->uscsi_bufaddr = buffer;
28032 com->uscsi_buflen = 0x04;
28033 com->uscsi_timeout = 300;
28034 com->uscsi_flags = USCSI_DIAGNOSE|USCSI_SILENT|USCSI_READ;
28035
28036 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_SYSSPACE,
28037 SD_PATH_STANDARD);
28038 if (un->un_f_cfg_read_toc_trk_bcd == TRUE) {
28039 hdr->cdth_trk0 = BCD_TO_BYTE(buffer[2]);
28040 hdr->cdth_trk1 = BCD_TO_BYTE(buffer[3]);
28041 } else {
28042 hdr->cdth_trk0 = buffer[2];
28043 hdr->cdth_trk1 = buffer[3];
28044 }
28045 kmem_free(buffer, 4);
28046 kmem_free(com, sizeof (*com));
28047 if (ddi_copyout(hdr, data, sizeof (struct cdrom_tochdr), flag) != 0) {
28048 return (EFAULT);
28049 }
28050 return (rval);
28051 }
28052
28053
28054 /*
28055 * Note: The following sr_read_mode1(), sr_read_cd_mode2(), sr_read_mode2(),
28056 * sr_read_cdda(), sr_read_cdxa(), routines implement driver support for
28057 * handling CDROMREAD ioctl requests for mode 1 user data, mode 2 user data,
28058 * digital audio and extended architecture digital audio. These modes are
28059 * defined in the IEC908 (Red Book), ISO10149 (Yellow Book), and the SCSI3
28060 * MMC specs.
28061 *
28062 * In addition to support for the various data formats these routines also
28063 * include support for devices that implement only the direct access READ
28064 * commands (0x08, 0x28), devices that implement the READ_CD commands
28065 * (0xBE, 0xD4), and devices that implement the vendor unique READ CDDA and
28066 * READ CDXA commands (0xD8, 0xDB)
28067 */
28068
28069 /*
28070 * Function: sr_read_mode1()
28071 *
28072 * Description: This routine is the driver entry point for handling CD-ROM
28073 * ioctl read mode1 requests (CDROMREADMODE1).
28074 *
28075 * Arguments: dev - the device 'dev_t'
28076 * data - pointer to user provided cd read structure specifying
28077 * the lba buffer address and length.
28078 * flag - this argument is a pass through to ddi_copyxxx()
28079 * directly from the mode argument of ioctl().
28080 *
28081 * Return Code: the code returned by sd_send_scsi_cmd()
28082 * EFAULT if ddi_copyxxx() fails
28083 * ENXIO if fail ddi_get_soft_state
28084 * EINVAL if data pointer is NULL
28085 */
28086
28087 static int
28088 sr_read_mode1(dev_t dev, caddr_t data, int flag)
28089 {
28090 struct sd_lun *un;
28091 struct cdrom_read mode1_struct;
28092 struct cdrom_read *mode1 = &mode1_struct;
28093 int rval;
28094 sd_ssc_t *ssc;
28095
28096 #ifdef _MULTI_DATAMODEL
28097 /* To support ILP32 applications in an LP64 world */
28098 struct cdrom_read32 cdrom_read32;
28099 struct cdrom_read32 *cdrd32 = &cdrom_read32;
28100 #endif /* _MULTI_DATAMODEL */
28101
28102 if (data == NULL) {
28103 return (EINVAL);
28104 }
28105
28106 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
28107 (un->un_state == SD_STATE_OFFLINE)) {
28108 return (ENXIO);
28109 }
28110
28111 SD_TRACE(SD_LOG_ATTACH_DETACH, un,
28112 "sd_read_mode1: entry: un:0x%p\n", un);
28113
28114 #ifdef _MULTI_DATAMODEL
28115 switch (ddi_model_convert_from(flag & FMODELS)) {
28116 case DDI_MODEL_ILP32:
28117 if (ddi_copyin(data, cdrd32, sizeof (*cdrd32), flag) != 0) {
28118 return (EFAULT);
28119 }
28120 /* Convert the ILP32 uscsi data from the application to LP64 */
28121 cdrom_read32tocdrom_read(cdrd32, mode1);
28122 break;
28123 case DDI_MODEL_NONE:
28124 if (ddi_copyin(data, mode1, sizeof (struct cdrom_read), flag)) {
28125 return (EFAULT);
28126 }
28127 }
28128 #else /* ! _MULTI_DATAMODEL */
28129 if (ddi_copyin(data, mode1, sizeof (struct cdrom_read), flag)) {
28130 return (EFAULT);
28131 }
28132 #endif /* _MULTI_DATAMODEL */
28133
28134 ssc = sd_ssc_init(un);
28135 rval = sd_send_scsi_READ(ssc, mode1->cdread_bufaddr,
28136 mode1->cdread_buflen, mode1->cdread_lba, SD_PATH_STANDARD);
28137 sd_ssc_fini(ssc);
28138
28139 SD_TRACE(SD_LOG_ATTACH_DETACH, un,
28140 "sd_read_mode1: exit: un:0x%p\n", un);
28141
28142 return (rval);
28143 }
28144
28145
28146 /*
28147 * Function: sr_read_cd_mode2()
28148 *
28149 * Description: This routine is the driver entry point for handling CD-ROM
28150 * ioctl read mode2 requests (CDROMREADMODE2) for devices that
28151 * support the READ CD (0xBE) command or the 1st generation
28152 * READ CD (0xD4) command.
28153 *
28154 * Arguments: dev - the device 'dev_t'
28155 * data - pointer to user provided cd read structure specifying
28156 * the lba buffer address and length.
28157 * flag - this argument is a pass through to ddi_copyxxx()
28158 * directly from the mode argument of ioctl().
28159 *
28160 * Return Code: the code returned by sd_send_scsi_cmd()
28161 * EFAULT if ddi_copyxxx() fails
28162 * ENXIO if fail ddi_get_soft_state
28163 * EINVAL if data pointer is NULL
28164 */
28165
28166 static int
28167 sr_read_cd_mode2(dev_t dev, caddr_t data, int flag)
28168 {
28169 struct sd_lun *un;
28170 struct uscsi_cmd *com;
28171 struct cdrom_read mode2_struct;
28172 struct cdrom_read *mode2 = &mode2_struct;
28173 uchar_t cdb[CDB_GROUP5];
28174 int nblocks;
28175 int rval;
28176 #ifdef _MULTI_DATAMODEL
28177 /* To support ILP32 applications in an LP64 world */
28178 struct cdrom_read32 cdrom_read32;
28179 struct cdrom_read32 *cdrd32 = &cdrom_read32;
28180 #endif /* _MULTI_DATAMODEL */
28181
28182 if (data == NULL) {
28183 return (EINVAL);
28184 }
28185
28186 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
28187 (un->un_state == SD_STATE_OFFLINE)) {
28188 return (ENXIO);
28189 }
28190
28191 #ifdef _MULTI_DATAMODEL
28192 switch (ddi_model_convert_from(flag & FMODELS)) {
28193 case DDI_MODEL_ILP32:
28194 if (ddi_copyin(data, cdrd32, sizeof (*cdrd32), flag) != 0) {
28195 return (EFAULT);
28196 }
28197 /* Convert the ILP32 uscsi data from the application to LP64 */
28198 cdrom_read32tocdrom_read(cdrd32, mode2);
28199 break;
28200 case DDI_MODEL_NONE:
28201 if (ddi_copyin(data, mode2, sizeof (*mode2), flag) != 0) {
28202 return (EFAULT);
28203 }
28204 break;
28205 }
28206
28207 #else /* ! _MULTI_DATAMODEL */
28208 if (ddi_copyin(data, mode2, sizeof (*mode2), flag) != 0) {
28209 return (EFAULT);
28210 }
28211 #endif /* _MULTI_DATAMODEL */
28212
28213 bzero(cdb, sizeof (cdb));
28214 if (un->un_f_cfg_read_cd_xd4 == TRUE) {
28215 /* Read command supported by 1st generation atapi drives */
28216 cdb[0] = SCMD_READ_CDD4;
28217 } else {
28218 /* Universal CD Access Command */
28219 cdb[0] = SCMD_READ_CD;
28220 }
28221
28222 /*
28223 * Set expected sector type to: 2336s byte, Mode 2 Yellow Book
28224 */
28225 cdb[1] = CDROM_SECTOR_TYPE_MODE2;
28226
28227 /* set the start address */
28228 cdb[2] = (uchar_t)((mode2->cdread_lba >> 24) & 0XFF);
28229 cdb[3] = (uchar_t)((mode2->cdread_lba >> 16) & 0XFF);
28230 cdb[4] = (uchar_t)((mode2->cdread_lba >> 8) & 0xFF);
28231 cdb[5] = (uchar_t)(mode2->cdread_lba & 0xFF);
28232
28233 /* set the transfer length */
28234 nblocks = mode2->cdread_buflen / 2336;
28235 cdb[6] = (uchar_t)(nblocks >> 16);
28236 cdb[7] = (uchar_t)(nblocks >> 8);
28237 cdb[8] = (uchar_t)nblocks;
28238
28239 /* set the filter bits */
28240 cdb[9] = CDROM_READ_CD_USERDATA;
28241
28242 com = kmem_zalloc(sizeof (*com), KM_SLEEP);
28243 com->uscsi_cdb = (caddr_t)cdb;
28244 com->uscsi_cdblen = sizeof (cdb);
28245 com->uscsi_bufaddr = mode2->cdread_bufaddr;
28246 com->uscsi_buflen = mode2->cdread_buflen;
28247 com->uscsi_flags = USCSI_DIAGNOSE|USCSI_SILENT|USCSI_READ;
28248
28249 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_USERSPACE,
28250 SD_PATH_STANDARD);
28251 kmem_free(com, sizeof (*com));
28252 return (rval);
28253 }
28254
28255
28256 /*
28257 * Function: sr_read_mode2()
28258 *
28259 * Description: This routine is the driver entry point for handling CD-ROM
28260 * ioctl read mode2 requests (CDROMREADMODE2) for devices that
28261 * do not support the READ CD (0xBE) command.
28262 *
28263 * Arguments: dev - the device 'dev_t'
28264 * data - pointer to user provided cd read structure specifying
28265 * the lba buffer address and length.
28266 * flag - this argument is a pass through to ddi_copyxxx()
28267 * directly from the mode argument of ioctl().
28268 *
28269 * Return Code: the code returned by sd_send_scsi_cmd()
28270 * EFAULT if ddi_copyxxx() fails
28271 * ENXIO if fail ddi_get_soft_state
28272 * EINVAL if data pointer is NULL
28273 * EIO if fail to reset block size
28274 * EAGAIN if commands are in progress in the driver
28275 */
28276
28277 static int
28278 sr_read_mode2(dev_t dev, caddr_t data, int flag)
28279 {
28280 struct sd_lun *un;
28281 struct cdrom_read mode2_struct;
28282 struct cdrom_read *mode2 = &mode2_struct;
28283 int rval;
28284 uint32_t restore_blksize;
28285 struct uscsi_cmd *com;
28286 uchar_t cdb[CDB_GROUP0];
28287 int nblocks;
28288
28289 #ifdef _MULTI_DATAMODEL
28290 /* To support ILP32 applications in an LP64 world */
28291 struct cdrom_read32 cdrom_read32;
28292 struct cdrom_read32 *cdrd32 = &cdrom_read32;
28293 #endif /* _MULTI_DATAMODEL */
28294
28295 if (data == NULL) {
28296 return (EINVAL);
28297 }
28298
28299 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
28300 (un->un_state == SD_STATE_OFFLINE)) {
28301 return (ENXIO);
28302 }
28303
28304 /*
28305 * Because this routine will update the device and driver block size
28306 * being used we want to make sure there are no commands in progress.
28307 * If commands are in progress the user will have to try again.
28308 *
28309 * We check for 1 instead of 0 because we increment un_ncmds_in_driver
28310 * in sdioctl to protect commands from sdioctl through to the top of
28311 * sd_uscsi_strategy. See sdioctl for details.
28312 */
28313 mutex_enter(SD_MUTEX(un));
28314 if (un->un_ncmds_in_driver != 1) {
28315 mutex_exit(SD_MUTEX(un));
28316 return (EAGAIN);
28317 }
28318 mutex_exit(SD_MUTEX(un));
28319
28320 SD_TRACE(SD_LOG_ATTACH_DETACH, un,
28321 "sd_read_mode2: entry: un:0x%p\n", un);
28322
28323 #ifdef _MULTI_DATAMODEL
28324 switch (ddi_model_convert_from(flag & FMODELS)) {
28325 case DDI_MODEL_ILP32:
28326 if (ddi_copyin(data, cdrd32, sizeof (*cdrd32), flag) != 0) {
28327 return (EFAULT);
28328 }
28329 /* Convert the ILP32 uscsi data from the application to LP64 */
28330 cdrom_read32tocdrom_read(cdrd32, mode2);
28331 break;
28332 case DDI_MODEL_NONE:
28333 if (ddi_copyin(data, mode2, sizeof (*mode2), flag) != 0) {
28334 return (EFAULT);
28335 }
28336 break;
28337 }
28338 #else /* ! _MULTI_DATAMODEL */
28339 if (ddi_copyin(data, mode2, sizeof (*mode2), flag)) {
28340 return (EFAULT);
28341 }
28342 #endif /* _MULTI_DATAMODEL */
28343
28344 /* Store the current target block size for restoration later */
28345 restore_blksize = un->un_tgt_blocksize;
28346
28347 /* Change the device and soft state target block size to 2336 */
28348 if (sr_sector_mode(dev, SD_MODE2_BLKSIZE) != 0) {
28349 rval = EIO;
28350 goto done;
28351 }
28352
28353
28354 bzero(cdb, sizeof (cdb));
28355
28356 /* set READ operation */
28357 cdb[0] = SCMD_READ;
28358
28359 /* adjust lba for 2kbyte blocks from 512 byte blocks */
28360 mode2->cdread_lba >>= 2;
28361
28362 /* set the start address */
28363 cdb[1] = (uchar_t)((mode2->cdread_lba >> 16) & 0X1F);
28364 cdb[2] = (uchar_t)((mode2->cdread_lba >> 8) & 0xFF);
28365 cdb[3] = (uchar_t)(mode2->cdread_lba & 0xFF);
28366
28367 /* set the transfer length */
28368 nblocks = mode2->cdread_buflen / 2336;
28369 cdb[4] = (uchar_t)nblocks & 0xFF;
28370
28371 /* build command */
28372 com = kmem_zalloc(sizeof (*com), KM_SLEEP);
28373 com->uscsi_cdb = (caddr_t)cdb;
28374 com->uscsi_cdblen = sizeof (cdb);
28375 com->uscsi_bufaddr = mode2->cdread_bufaddr;
28376 com->uscsi_buflen = mode2->cdread_buflen;
28377 com->uscsi_flags = USCSI_DIAGNOSE|USCSI_SILENT|USCSI_READ;
28378
28379 /*
28380 * Issue SCSI command with user space address for read buffer.
28381 *
28382 * This sends the command through main channel in the driver.
28383 *
28384 * Since this is accessed via an IOCTL call, we go through the
28385 * standard path, so that if the device was powered down, then
28386 * it would be 'awakened' to handle the command.
28387 */
28388 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_USERSPACE,
28389 SD_PATH_STANDARD);
28390
28391 kmem_free(com, sizeof (*com));
28392
28393 /* Restore the device and soft state target block size */
28394 if (sr_sector_mode(dev, restore_blksize) != 0) {
28395 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
28396 "can't do switch back to mode 1\n");
28397 /*
28398 * If sd_send_scsi_READ succeeded we still need to report
28399 * an error because we failed to reset the block size
28400 */
28401 if (rval == 0) {
28402 rval = EIO;
28403 }
28404 }
28405
28406 done:
28407 SD_TRACE(SD_LOG_ATTACH_DETACH, un,
28408 "sd_read_mode2: exit: un:0x%p\n", un);
28409
28410 return (rval);
28411 }
28412
28413
28414 /*
28415 * Function: sr_sector_mode()
28416 *
28417 * Description: This utility function is used by sr_read_mode2 to set the target
28418 * block size based on the user specified size. This is a legacy
28419 * implementation based upon a vendor specific mode page
28420 *
28421 * Arguments: dev - the device 'dev_t'
28422 * data - flag indicating if block size is being set to 2336 or
28423 * 512.
28424 *
28425 * Return Code: the code returned by sd_send_scsi_cmd()
28426 * EFAULT if ddi_copyxxx() fails
28427 * ENXIO if fail ddi_get_soft_state
28428 * EINVAL if data pointer is NULL
28429 */
28430
28431 static int
28432 sr_sector_mode(dev_t dev, uint32_t blksize)
28433 {
28434 struct sd_lun *un;
28435 uchar_t *sense;
28436 uchar_t *select;
28437 int rval;
28438 sd_ssc_t *ssc;
28439
28440 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
28441 (un->un_state == SD_STATE_OFFLINE)) {
28442 return (ENXIO);
28443 }
28444
28445 sense = kmem_zalloc(20, KM_SLEEP);
28446
28447 /* Note: This is a vendor specific mode page (0x81) */
28448 ssc = sd_ssc_init(un);
28449 rval = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP0, sense, 20, 0x81,
28450 SD_PATH_STANDARD);
28451 sd_ssc_fini(ssc);
28452 if (rval != 0) {
28453 SD_ERROR(SD_LOG_IOCTL_RMMEDIA, un,
28454 "sr_sector_mode: Mode Sense failed\n");
28455 kmem_free(sense, 20);
28456 return (rval);
28457 }
28458 select = kmem_zalloc(20, KM_SLEEP);
28459 select[3] = 0x08;
28460 select[10] = ((blksize >> 8) & 0xff);
28461 select[11] = (blksize & 0xff);
28462 select[12] = 0x01;
28463 select[13] = 0x06;
28464 select[14] = sense[14];
28465 select[15] = sense[15];
28466 if (blksize == SD_MODE2_BLKSIZE) {
28467 select[14] |= 0x01;
28468 }
28469
28470 ssc = sd_ssc_init(un);
28471 rval = sd_send_scsi_MODE_SELECT(ssc, CDB_GROUP0, select, 20,
28472 SD_DONTSAVE_PAGE, SD_PATH_STANDARD);
28473 sd_ssc_fini(ssc);
28474 if (rval != 0) {
28475 SD_ERROR(SD_LOG_IOCTL_RMMEDIA, un,
28476 "sr_sector_mode: Mode Select failed\n");
28477 } else {
28478 /*
28479 * Only update the softstate block size if we successfully
28480 * changed the device block mode.
28481 */
28482 mutex_enter(SD_MUTEX(un));
28483 sd_update_block_info(un, blksize, 0);
28484 mutex_exit(SD_MUTEX(un));
28485 }
28486 kmem_free(sense, 20);
28487 kmem_free(select, 20);
28488 return (rval);
28489 }
28490
28491
28492 /*
28493 * Function: sr_read_cdda()
28494 *
28495 * Description: This routine is the driver entry point for handling CD-ROM
28496 * ioctl requests to return CD-DA or subcode data. (CDROMCDDA) If
28497 * the target supports CDDA these requests are handled via a vendor
28498 * specific command (0xD8) If the target does not support CDDA
28499 * these requests are handled via the READ CD command (0xBE).
28500 *
28501 * Arguments: dev - the device 'dev_t'
28502 * data - pointer to user provided CD-DA structure specifying
28503 * the track starting address, transfer length, and
28504 * subcode options.
28505 * flag - this argument is a pass through to ddi_copyxxx()
28506 * directly from the mode argument of ioctl().
28507 *
28508 * Return Code: the code returned by sd_send_scsi_cmd()
28509 * EFAULT if ddi_copyxxx() fails
28510 * ENXIO if fail ddi_get_soft_state
28511 * EINVAL if invalid arguments are provided
28512 * ENOTTY
28513 */
28514
28515 static int
28516 sr_read_cdda(dev_t dev, caddr_t data, int flag)
28517 {
28518 struct sd_lun *un;
28519 struct uscsi_cmd *com;
28520 struct cdrom_cdda *cdda;
28521 int rval;
28522 size_t buflen;
28523 char cdb[CDB_GROUP5];
28524
28525 #ifdef _MULTI_DATAMODEL
28526 /* To support ILP32 applications in an LP64 world */
28527 struct cdrom_cdda32 cdrom_cdda32;
28528 struct cdrom_cdda32 *cdda32 = &cdrom_cdda32;
28529 #endif /* _MULTI_DATAMODEL */
28530
28531 if (data == NULL) {
28532 return (EINVAL);
28533 }
28534
28535 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
28536 return (ENXIO);
28537 }
28538
28539 cdda = kmem_zalloc(sizeof (struct cdrom_cdda), KM_SLEEP);
28540
28541 #ifdef _MULTI_DATAMODEL
28542 switch (ddi_model_convert_from(flag & FMODELS)) {
28543 case DDI_MODEL_ILP32:
28544 if (ddi_copyin(data, cdda32, sizeof (*cdda32), flag)) {
28545 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
28546 "sr_read_cdda: ddi_copyin Failed\n");
28547 kmem_free(cdda, sizeof (struct cdrom_cdda));
28548 return (EFAULT);
28549 }
28550 /* Convert the ILP32 uscsi data from the application to LP64 */
28551 cdrom_cdda32tocdrom_cdda(cdda32, cdda);
28552 break;
28553 case DDI_MODEL_NONE:
28554 if (ddi_copyin(data, cdda, sizeof (struct cdrom_cdda), flag)) {
28555 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
28556 "sr_read_cdda: ddi_copyin Failed\n");
28557 kmem_free(cdda, sizeof (struct cdrom_cdda));
28558 return (EFAULT);
28559 }
28560 break;
28561 }
28562 #else /* ! _MULTI_DATAMODEL */
28563 if (ddi_copyin(data, cdda, sizeof (struct cdrom_cdda), flag)) {
28564 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
28565 "sr_read_cdda: ddi_copyin Failed\n");
28566 kmem_free(cdda, sizeof (struct cdrom_cdda));
28567 return (EFAULT);
28568 }
28569 #endif /* _MULTI_DATAMODEL */
28570
28571 /*
28572 * Since MMC-2 expects max 3 bytes for length, check if the
28573 * length input is greater than 3 bytes
28574 */
28575 if ((cdda->cdda_length & 0xFF000000) != 0) {
28576 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, "sr_read_cdda: "
28577 "cdrom transfer length too large: %d (limit %d)\n",
28578 cdda->cdda_length, 0xFFFFFF);
28579 kmem_free(cdda, sizeof (struct cdrom_cdda));
28580 return (EINVAL);
28581 }
28582
28583 switch (cdda->cdda_subcode) {
28584 case CDROM_DA_NO_SUBCODE:
28585 buflen = CDROM_BLK_2352 * cdda->cdda_length;
28586 break;
28587 case CDROM_DA_SUBQ:
28588 buflen = CDROM_BLK_2368 * cdda->cdda_length;
28589 break;
28590 case CDROM_DA_ALL_SUBCODE:
28591 buflen = CDROM_BLK_2448 * cdda->cdda_length;
28592 break;
28593 case CDROM_DA_SUBCODE_ONLY:
28594 buflen = CDROM_BLK_SUBCODE * cdda->cdda_length;
28595 break;
28596 default:
28597 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
28598 "sr_read_cdda: Subcode '0x%x' Not Supported\n",
28599 cdda->cdda_subcode);
28600 kmem_free(cdda, sizeof (struct cdrom_cdda));
28601 return (EINVAL);
28602 }
28603
28604 /* Build and send the command */
28605 com = kmem_zalloc(sizeof (*com), KM_SLEEP);
28606 bzero(cdb, CDB_GROUP5);
28607
28608 if (un->un_f_cfg_cdda == TRUE) {
28609 cdb[0] = (char)SCMD_READ_CD;
28610 cdb[1] = 0x04;
28611 cdb[2] = (((cdda->cdda_addr) & 0xff000000) >> 24);
28612 cdb[3] = (((cdda->cdda_addr) & 0x00ff0000) >> 16);
28613 cdb[4] = (((cdda->cdda_addr) & 0x0000ff00) >> 8);
28614 cdb[5] = ((cdda->cdda_addr) & 0x000000ff);
28615 cdb[6] = (((cdda->cdda_length) & 0x00ff0000) >> 16);
28616 cdb[7] = (((cdda->cdda_length) & 0x0000ff00) >> 8);
28617 cdb[8] = ((cdda->cdda_length) & 0x000000ff);
28618 cdb[9] = 0x10;
28619 switch (cdda->cdda_subcode) {
28620 case CDROM_DA_NO_SUBCODE :
28621 cdb[10] = 0x0;
28622 break;
28623 case CDROM_DA_SUBQ :
28624 cdb[10] = 0x2;
28625 break;
28626 case CDROM_DA_ALL_SUBCODE :
28627 cdb[10] = 0x1;
28628 break;
28629 case CDROM_DA_SUBCODE_ONLY :
28630 /* FALLTHROUGH */
28631 default :
28632 kmem_free(cdda, sizeof (struct cdrom_cdda));
28633 kmem_free(com, sizeof (*com));
28634 return (ENOTTY);
28635 }
28636 } else {
28637 cdb[0] = (char)SCMD_READ_CDDA;
28638 cdb[2] = (((cdda->cdda_addr) & 0xff000000) >> 24);
28639 cdb[3] = (((cdda->cdda_addr) & 0x00ff0000) >> 16);
28640 cdb[4] = (((cdda->cdda_addr) & 0x0000ff00) >> 8);
28641 cdb[5] = ((cdda->cdda_addr) & 0x000000ff);
28642 cdb[6] = (((cdda->cdda_length) & 0xff000000) >> 24);
28643 cdb[7] = (((cdda->cdda_length) & 0x00ff0000) >> 16);
28644 cdb[8] = (((cdda->cdda_length) & 0x0000ff00) >> 8);
28645 cdb[9] = ((cdda->cdda_length) & 0x000000ff);
28646 cdb[10] = cdda->cdda_subcode;
28647 }
28648
28649 com->uscsi_cdb = cdb;
28650 com->uscsi_cdblen = CDB_GROUP5;
28651 com->uscsi_bufaddr = (caddr_t)cdda->cdda_data;
28652 com->uscsi_buflen = buflen;
28653 com->uscsi_flags = USCSI_DIAGNOSE|USCSI_SILENT|USCSI_READ;
28654
28655 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_USERSPACE,
28656 SD_PATH_STANDARD);
28657
28658 kmem_free(cdda, sizeof (struct cdrom_cdda));
28659 kmem_free(com, sizeof (*com));
28660 return (rval);
28661 }
28662
28663
28664 /*
28665 * Function: sr_read_cdxa()
28666 *
28667 * Description: This routine is the driver entry point for handling CD-ROM
28668 * ioctl requests to return CD-XA (Extended Architecture) data.
28669 * (CDROMCDXA).
28670 *
28671 * Arguments: dev - the device 'dev_t'
28672 * data - pointer to user provided CD-XA structure specifying
28673 * the data starting address, transfer length, and format
28674 * flag - this argument is a pass through to ddi_copyxxx()
28675 * directly from the mode argument of ioctl().
28676 *
28677 * Return Code: the code returned by sd_send_scsi_cmd()
28678 * EFAULT if ddi_copyxxx() fails
28679 * ENXIO if fail ddi_get_soft_state
28680 * EINVAL if data pointer is NULL
28681 */
28682
28683 static int
28684 sr_read_cdxa(dev_t dev, caddr_t data, int flag)
28685 {
28686 struct sd_lun *un;
28687 struct uscsi_cmd *com;
28688 struct cdrom_cdxa *cdxa;
28689 int rval;
28690 size_t buflen;
28691 char cdb[CDB_GROUP5];
28692 uchar_t read_flags;
28693
28694 #ifdef _MULTI_DATAMODEL
28695 /* To support ILP32 applications in an LP64 world */
28696 struct cdrom_cdxa32 cdrom_cdxa32;
28697 struct cdrom_cdxa32 *cdxa32 = &cdrom_cdxa32;
28698 #endif /* _MULTI_DATAMODEL */
28699
28700 if (data == NULL) {
28701 return (EINVAL);
28702 }
28703
28704 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
28705 return (ENXIO);
28706 }
28707
28708 cdxa = kmem_zalloc(sizeof (struct cdrom_cdxa), KM_SLEEP);
28709
28710 #ifdef _MULTI_DATAMODEL
28711 switch (ddi_model_convert_from(flag & FMODELS)) {
28712 case DDI_MODEL_ILP32:
28713 if (ddi_copyin(data, cdxa32, sizeof (*cdxa32), flag)) {
28714 kmem_free(cdxa, sizeof (struct cdrom_cdxa));
28715 return (EFAULT);
28716 }
28717 /*
28718 * Convert the ILP32 uscsi data from the
28719 * application to LP64 for internal use.
28720 */
28721 cdrom_cdxa32tocdrom_cdxa(cdxa32, cdxa);
28722 break;
28723 case DDI_MODEL_NONE:
28724 if (ddi_copyin(data, cdxa, sizeof (struct cdrom_cdxa), flag)) {
28725 kmem_free(cdxa, sizeof (struct cdrom_cdxa));
28726 return (EFAULT);
28727 }
28728 break;
28729 }
28730 #else /* ! _MULTI_DATAMODEL */
28731 if (ddi_copyin(data, cdxa, sizeof (struct cdrom_cdxa), flag)) {
28732 kmem_free(cdxa, sizeof (struct cdrom_cdxa));
28733 return (EFAULT);
28734 }
28735 #endif /* _MULTI_DATAMODEL */
28736
28737 /*
28738 * Since MMC-2 expects max 3 bytes for length, check if the
28739 * length input is greater than 3 bytes
28740 */
28741 if ((cdxa->cdxa_length & 0xFF000000) != 0) {
28742 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, "sr_read_cdxa: "
28743 "cdrom transfer length too large: %d (limit %d)\n",
28744 cdxa->cdxa_length, 0xFFFFFF);
28745 kmem_free(cdxa, sizeof (struct cdrom_cdxa));
28746 return (EINVAL);
28747 }
28748
28749 switch (cdxa->cdxa_format) {
28750 case CDROM_XA_DATA:
28751 buflen = CDROM_BLK_2048 * cdxa->cdxa_length;
28752 read_flags = 0x10;
28753 break;
28754 case CDROM_XA_SECTOR_DATA:
28755 buflen = CDROM_BLK_2352 * cdxa->cdxa_length;
28756 read_flags = 0xf8;
28757 break;
28758 case CDROM_XA_DATA_W_ERROR:
28759 buflen = CDROM_BLK_2646 * cdxa->cdxa_length;
28760 read_flags = 0xfc;
28761 break;
28762 default:
28763 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
28764 "sr_read_cdxa: Format '0x%x' Not Supported\n",
28765 cdxa->cdxa_format);
28766 kmem_free(cdxa, sizeof (struct cdrom_cdxa));
28767 return (EINVAL);
28768 }
28769
28770 com = kmem_zalloc(sizeof (*com), KM_SLEEP);
28771 bzero(cdb, CDB_GROUP5);
28772 if (un->un_f_mmc_cap == TRUE) {
28773 cdb[0] = (char)SCMD_READ_CD;
28774 cdb[2] = (((cdxa->cdxa_addr) & 0xff000000) >> 24);
28775 cdb[3] = (((cdxa->cdxa_addr) & 0x00ff0000) >> 16);
28776 cdb[4] = (((cdxa->cdxa_addr) & 0x0000ff00) >> 8);
28777 cdb[5] = ((cdxa->cdxa_addr) & 0x000000ff);
28778 cdb[6] = (((cdxa->cdxa_length) & 0x00ff0000) >> 16);
28779 cdb[7] = (((cdxa->cdxa_length) & 0x0000ff00) >> 8);
28780 cdb[8] = ((cdxa->cdxa_length) & 0x000000ff);
28781 cdb[9] = (char)read_flags;
28782 } else {
28783 /*
28784 * Note: A vendor specific command (0xDB) is being used her to
28785 * request a read of all subcodes.
28786 */
28787 cdb[0] = (char)SCMD_READ_CDXA;
28788 cdb[2] = (((cdxa->cdxa_addr) & 0xff000000) >> 24);
28789 cdb[3] = (((cdxa->cdxa_addr) & 0x00ff0000) >> 16);
28790 cdb[4] = (((cdxa->cdxa_addr) & 0x0000ff00) >> 8);
28791 cdb[5] = ((cdxa->cdxa_addr) & 0x000000ff);
28792 cdb[6] = (((cdxa->cdxa_length) & 0xff000000) >> 24);
28793 cdb[7] = (((cdxa->cdxa_length) & 0x00ff0000) >> 16);
28794 cdb[8] = (((cdxa->cdxa_length) & 0x0000ff00) >> 8);
28795 cdb[9] = ((cdxa->cdxa_length) & 0x000000ff);
28796 cdb[10] = cdxa->cdxa_format;
28797 }
28798 com->uscsi_cdb = cdb;
28799 com->uscsi_cdblen = CDB_GROUP5;
28800 com->uscsi_bufaddr = (caddr_t)cdxa->cdxa_data;
28801 com->uscsi_buflen = buflen;
28802 com->uscsi_flags = USCSI_DIAGNOSE|USCSI_SILENT|USCSI_READ;
28803 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_USERSPACE,
28804 SD_PATH_STANDARD);
28805 kmem_free(cdxa, sizeof (struct cdrom_cdxa));
28806 kmem_free(com, sizeof (*com));
28807 return (rval);
28808 }
28809
28810
28811 /*
28812 * Function: sr_eject()
28813 *
28814 * Description: This routine is the driver entry point for handling CD-ROM
28815 * eject ioctl requests (FDEJECT, DKIOCEJECT, CDROMEJECT)
28816 *
28817 * Arguments: dev - the device 'dev_t'
28818 *
28819 * Return Code: the code returned by sd_send_scsi_cmd()
28820 */
28821
28822 static int
28823 sr_eject(dev_t dev)
28824 {
28825 struct sd_lun *un;
28826 int rval;
28827 sd_ssc_t *ssc;
28828
28829 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
28830 (un->un_state == SD_STATE_OFFLINE)) {
28831 return (ENXIO);
28832 }
28833
28834 /*
28835 * To prevent race conditions with the eject
28836 * command, keep track of an eject command as
28837 * it progresses. If we are already handling
28838 * an eject command in the driver for the given
28839 * unit and another request to eject is received
28840 * immediately return EAGAIN so we don't lose
28841 * the command if the current eject command fails.
28842 */
28843 mutex_enter(SD_MUTEX(un));
28844 if (un->un_f_ejecting == TRUE) {
28845 mutex_exit(SD_MUTEX(un));
28846 return (EAGAIN);
28847 }
28848 un->un_f_ejecting = TRUE;
28849 mutex_exit(SD_MUTEX(un));
28850
28851 ssc = sd_ssc_init(un);
28852 rval = sd_send_scsi_DOORLOCK(ssc, SD_REMOVAL_ALLOW,
28853 SD_PATH_STANDARD);
28854 sd_ssc_fini(ssc);
28855
28856 if (rval != 0) {
28857 mutex_enter(SD_MUTEX(un));
28858 un->un_f_ejecting = FALSE;
28859 mutex_exit(SD_MUTEX(un));
28860 return (rval);
28861 }
28862
28863 ssc = sd_ssc_init(un);
28864 rval = sd_send_scsi_START_STOP_UNIT(ssc, SD_START_STOP,
28865 SD_TARGET_EJECT, SD_PATH_STANDARD);
28866 sd_ssc_fini(ssc);
28867
28868 if (rval == 0) {
28869 mutex_enter(SD_MUTEX(un));
28870 sr_ejected(un);
28871 un->un_mediastate = DKIO_EJECTED;
28872 un->un_f_ejecting = FALSE;
28873 cv_broadcast(&un->un_state_cv);
28874 mutex_exit(SD_MUTEX(un));
28875 } else {
28876 mutex_enter(SD_MUTEX(un));
28877 un->un_f_ejecting = FALSE;
28878 mutex_exit(SD_MUTEX(un));
28879 }
28880 return (rval);
28881 }
28882
28883
28884 /*
28885 * Function: sr_ejected()
28886 *
28887 * Description: This routine updates the soft state structure to invalidate the
28888 * geometry information after the media has been ejected or a
28889 * media eject has been detected.
28890 *
28891 * Arguments: un - driver soft state (unit) structure
28892 */
28893
28894 static void
28895 sr_ejected(struct sd_lun *un)
28896 {
28897 struct sd_errstats *stp;
28898
28899 ASSERT(un != NULL);
28900 ASSERT(mutex_owned(SD_MUTEX(un)));
28901
28902 un->un_f_blockcount_is_valid = FALSE;
28903 un->un_f_tgt_blocksize_is_valid = FALSE;
28904 mutex_exit(SD_MUTEX(un));
28905 cmlb_invalidate(un->un_cmlbhandle, (void *)SD_PATH_DIRECT_PRIORITY);
28906 mutex_enter(SD_MUTEX(un));
28907
28908 if (un->un_errstats != NULL) {
28909 stp = (struct sd_errstats *)un->un_errstats->ks_data;
28910 stp->sd_capacity.value.ui64 = 0;
28911 }
28912 }
28913
28914
28915 /*
28916 * Function: sr_check_wp()
28917 *
28918 * Description: This routine checks the write protection of a removable
28919 * media disk and hotpluggable devices via the write protect bit of
28920 * the Mode Page Header device specific field. Some devices choke
28921 * on unsupported mode page. In order to workaround this issue,
28922 * this routine has been implemented to use 0x3f mode page(request
28923 * for all pages) for all device types.
28924 *
28925 * Arguments: dev - the device 'dev_t'
28926 *
28927 * Return Code: int indicating if the device is write protected (1) or not (0)
28928 *
28929 * Context: Kernel thread.
28930 *
28931 */
28932
28933 static int
28934 sr_check_wp(dev_t dev)
28935 {
28936 struct sd_lun *un;
28937 uchar_t device_specific;
28938 uchar_t *sense;
28939 int hdrlen;
28940 int rval = FALSE;
28941 int status;
28942 sd_ssc_t *ssc;
28943
28944 /*
28945 * Note: The return codes for this routine should be reworked to
28946 * properly handle the case of a NULL softstate.
28947 */
28948 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
28949 return (FALSE);
28950 }
28951
28952 if (un->un_f_cfg_is_atapi == TRUE) {
28953 /*
28954 * The mode page contents are not required; set the allocation
28955 * length for the mode page header only
28956 */
28957 hdrlen = MODE_HEADER_LENGTH_GRP2;
28958 sense = kmem_zalloc(hdrlen, KM_SLEEP);
28959 ssc = sd_ssc_init(un);
28960 status = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP1, sense, hdrlen,
28961 MODEPAGE_ALLPAGES, SD_PATH_STANDARD);
28962 sd_ssc_fini(ssc);
28963 if (status != 0)
28964 goto err_exit;
28965 device_specific =
28966 ((struct mode_header_grp2 *)sense)->device_specific;
28967 } else {
28968 hdrlen = MODE_HEADER_LENGTH;
28969 sense = kmem_zalloc(hdrlen, KM_SLEEP);
28970 ssc = sd_ssc_init(un);
28971 status = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP0, sense, hdrlen,
28972 MODEPAGE_ALLPAGES, SD_PATH_STANDARD);
28973 sd_ssc_fini(ssc);
28974 if (status != 0)
28975 goto err_exit;
28976 device_specific =
28977 ((struct mode_header *)sense)->device_specific;
28978 }
28979
28980
28981 /*
28982 * Write protect mode sense failed; not all disks
28983 * understand this query. Return FALSE assuming that
28984 * these devices are not writable.
28985 */
28986 if (device_specific & WRITE_PROTECT) {
28987 rval = TRUE;
28988 }
28989
28990 err_exit:
28991 kmem_free(sense, hdrlen);
28992 return (rval);
28993 }
28994
28995 /*
28996 * Function: sr_volume_ctrl()
28997 *
28998 * Description: This routine is the driver entry point for handling CD-ROM
28999 * audio output volume ioctl requests. (CDROMVOLCTRL)
29000 *
29001 * Arguments: dev - the device 'dev_t'
29002 * data - pointer to user audio volume control structure
29003 * flag - this argument is a pass through to ddi_copyxxx()
29004 * directly from the mode argument of ioctl().
29005 *
29006 * Return Code: the code returned by sd_send_scsi_cmd()
29007 * EFAULT if ddi_copyxxx() fails
29008 * ENXIO if fail ddi_get_soft_state
29009 * EINVAL if data pointer is NULL
29010 *
29011 */
29012
29013 static int
29014 sr_volume_ctrl(dev_t dev, caddr_t data, int flag)
29015 {
29016 struct sd_lun *un;
29017 struct cdrom_volctrl volume;
29018 struct cdrom_volctrl *vol = &volume;
29019 uchar_t *sense_page;
29020 uchar_t *select_page;
29021 uchar_t *sense;
29022 uchar_t *select;
29023 int sense_buflen;
29024 int select_buflen;
29025 int rval;
29026 sd_ssc_t *ssc;
29027
29028 if (data == NULL) {
29029 return (EINVAL);
29030 }
29031
29032 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
29033 (un->un_state == SD_STATE_OFFLINE)) {
29034 return (ENXIO);
29035 }
29036
29037 if (ddi_copyin(data, vol, sizeof (struct cdrom_volctrl), flag)) {
29038 return (EFAULT);
29039 }
29040
29041 if ((un->un_f_cfg_is_atapi == TRUE) || (un->un_f_mmc_cap == TRUE)) {
29042 struct mode_header_grp2 *sense_mhp;
29043 struct mode_header_grp2 *select_mhp;
29044 int bd_len;
29045
29046 sense_buflen = MODE_PARAM_LENGTH_GRP2 + MODEPAGE_AUDIO_CTRL_LEN;
29047 select_buflen = MODE_HEADER_LENGTH_GRP2 +
29048 MODEPAGE_AUDIO_CTRL_LEN;
29049 sense = kmem_zalloc(sense_buflen, KM_SLEEP);
29050 select = kmem_zalloc(select_buflen, KM_SLEEP);
29051 ssc = sd_ssc_init(un);
29052 rval = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP1, sense,
29053 sense_buflen, MODEPAGE_AUDIO_CTRL,
29054 SD_PATH_STANDARD);
29055 sd_ssc_fini(ssc);
29056
29057 if (rval != 0) {
29058 SD_ERROR(SD_LOG_IOCTL_RMMEDIA, un,
29059 "sr_volume_ctrl: Mode Sense Failed\n");
29060 kmem_free(sense, sense_buflen);
29061 kmem_free(select, select_buflen);
29062 return (rval);
29063 }
29064 sense_mhp = (struct mode_header_grp2 *)sense;
29065 select_mhp = (struct mode_header_grp2 *)select;
29066 bd_len = (sense_mhp->bdesc_length_hi << 8) |
29067 sense_mhp->bdesc_length_lo;
29068 if (bd_len > MODE_BLK_DESC_LENGTH) {
29069 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
29070 "sr_volume_ctrl: Mode Sense returned invalid "
29071 "block descriptor length\n");
29072 kmem_free(sense, sense_buflen);
29073 kmem_free(select, select_buflen);
29074 return (EIO);
29075 }
29076 sense_page = (uchar_t *)
29077 (sense + MODE_HEADER_LENGTH_GRP2 + bd_len);
29078 select_page = (uchar_t *)(select + MODE_HEADER_LENGTH_GRP2);
29079 select_mhp->length_msb = 0;
29080 select_mhp->length_lsb = 0;
29081 select_mhp->bdesc_length_hi = 0;
29082 select_mhp->bdesc_length_lo = 0;
29083 } else {
29084 struct mode_header *sense_mhp, *select_mhp;
29085
29086 sense_buflen = MODE_PARAM_LENGTH + MODEPAGE_AUDIO_CTRL_LEN;
29087 select_buflen = MODE_HEADER_LENGTH + MODEPAGE_AUDIO_CTRL_LEN;
29088 sense = kmem_zalloc(sense_buflen, KM_SLEEP);
29089 select = kmem_zalloc(select_buflen, KM_SLEEP);
29090 ssc = sd_ssc_init(un);
29091 rval = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP0, sense,
29092 sense_buflen, MODEPAGE_AUDIO_CTRL,
29093 SD_PATH_STANDARD);
29094 sd_ssc_fini(ssc);
29095
29096 if (rval != 0) {
29097 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
29098 "sr_volume_ctrl: Mode Sense Failed\n");
29099 kmem_free(sense, sense_buflen);
29100 kmem_free(select, select_buflen);
29101 return (rval);
29102 }
29103 sense_mhp = (struct mode_header *)sense;
29104 select_mhp = (struct mode_header *)select;
29105 if (sense_mhp->bdesc_length > MODE_BLK_DESC_LENGTH) {
29106 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
29107 "sr_volume_ctrl: Mode Sense returned invalid "
29108 "block descriptor length\n");
29109 kmem_free(sense, sense_buflen);
29110 kmem_free(select, select_buflen);
29111 return (EIO);
29112 }
29113 sense_page = (uchar_t *)
29114 (sense + MODE_HEADER_LENGTH + sense_mhp->bdesc_length);
29115 select_page = (uchar_t *)(select + MODE_HEADER_LENGTH);
29116 select_mhp->length = 0;
29117 select_mhp->bdesc_length = 0;
29118 }
29119 /*
29120 * Note: An audio control data structure could be created and overlayed
29121 * on the following in place of the array indexing method implemented.
29122 */
29123
29124 /* Build the select data for the user volume data */
29125 select_page[0] = MODEPAGE_AUDIO_CTRL;
29126 select_page[1] = 0xE;
29127 /* Set the immediate bit */
29128 select_page[2] = 0x04;
29129 /* Zero out reserved fields */
29130 select_page[3] = 0x00;
29131 select_page[4] = 0x00;
29132 /* Return sense data for fields not to be modified */
29133 select_page[5] = sense_page[5];
29134 select_page[6] = sense_page[6];
29135 select_page[7] = sense_page[7];
29136 /* Set the user specified volume levels for channel 0 and 1 */
29137 select_page[8] = 0x01;
29138 select_page[9] = vol->channel0;
29139 select_page[10] = 0x02;
29140 select_page[11] = vol->channel1;
29141 /* Channel 2 and 3 are currently unsupported so return the sense data */
29142 select_page[12] = sense_page[12];
29143 select_page[13] = sense_page[13];
29144 select_page[14] = sense_page[14];
29145 select_page[15] = sense_page[15];
29146
29147 ssc = sd_ssc_init(un);
29148 if ((un->un_f_cfg_is_atapi == TRUE) || (un->un_f_mmc_cap == TRUE)) {
29149 rval = sd_send_scsi_MODE_SELECT(ssc, CDB_GROUP1, select,
29150 select_buflen, SD_DONTSAVE_PAGE, SD_PATH_STANDARD);
29151 } else {
29152 rval = sd_send_scsi_MODE_SELECT(ssc, CDB_GROUP0, select,
29153 select_buflen, SD_DONTSAVE_PAGE, SD_PATH_STANDARD);
29154 }
29155 sd_ssc_fini(ssc);
29156
29157 kmem_free(sense, sense_buflen);
29158 kmem_free(select, select_buflen);
29159 return (rval);
29160 }
29161
29162
29163 /*
29164 * Function: sr_read_sony_session_offset()
29165 *
29166 * Description: This routine is the driver entry point for handling CD-ROM
29167 * ioctl requests for session offset information. (CDROMREADOFFSET)
29168 * The address of the first track in the last session of a
29169 * multi-session CD-ROM is returned
29170 *
29171 * Note: This routine uses a vendor specific key value in the
29172 * command control field without implementing any vendor check here
29173 * or in the ioctl routine.
29174 *
29175 * Arguments: dev - the device 'dev_t'
29176 * data - pointer to an int to hold the requested address
29177 * flag - this argument is a pass through to ddi_copyxxx()
29178 * directly from the mode argument of ioctl().
29179 *
29180 * Return Code: the code returned by sd_send_scsi_cmd()
29181 * EFAULT if ddi_copyxxx() fails
29182 * ENXIO if fail ddi_get_soft_state
29183 * EINVAL if data pointer is NULL
29184 */
29185
29186 static int
29187 sr_read_sony_session_offset(dev_t dev, caddr_t data, int flag)
29188 {
29189 struct sd_lun *un;
29190 struct uscsi_cmd *com;
29191 caddr_t buffer;
29192 char cdb[CDB_GROUP1];
29193 int session_offset = 0;
29194 int rval;
29195
29196 if (data == NULL) {
29197 return (EINVAL);
29198 }
29199
29200 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
29201 (un->un_state == SD_STATE_OFFLINE)) {
29202 return (ENXIO);
29203 }
29204
29205 buffer = kmem_zalloc((size_t)SONY_SESSION_OFFSET_LEN, KM_SLEEP);
29206 bzero(cdb, CDB_GROUP1);
29207 cdb[0] = SCMD_READ_TOC;
29208 /*
29209 * Bytes 7 & 8 are the 12 byte allocation length for a single entry.
29210 * (4 byte TOC response header + 8 byte response data)
29211 */
29212 cdb[8] = SONY_SESSION_OFFSET_LEN;
29213 /* Byte 9 is the control byte. A vendor specific value is used */
29214 cdb[9] = SONY_SESSION_OFFSET_KEY;
29215 com = kmem_zalloc(sizeof (*com), KM_SLEEP);
29216 com->uscsi_cdb = cdb;
29217 com->uscsi_cdblen = CDB_GROUP1;
29218 com->uscsi_bufaddr = buffer;
29219 com->uscsi_buflen = SONY_SESSION_OFFSET_LEN;
29220 com->uscsi_flags = USCSI_DIAGNOSE|USCSI_SILENT|USCSI_READ;
29221
29222 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_SYSSPACE,
29223 SD_PATH_STANDARD);
29224 if (rval != 0) {
29225 kmem_free(buffer, SONY_SESSION_OFFSET_LEN);
29226 kmem_free(com, sizeof (*com));
29227 return (rval);
29228 }
29229 if (buffer[1] == SONY_SESSION_OFFSET_VALID) {
29230 session_offset =
29231 ((uchar_t)buffer[8] << 24) + ((uchar_t)buffer[9] << 16) +
29232 ((uchar_t)buffer[10] << 8) + ((uchar_t)buffer[11]);
29233 /*
29234 * Offset returned offset in current lbasize block's. Convert to
29235 * 2k block's to return to the user
29236 */
29237 if (un->un_tgt_blocksize == CDROM_BLK_512) {
29238 session_offset >>= 2;
29239 } else if (un->un_tgt_blocksize == CDROM_BLK_1024) {
29240 session_offset >>= 1;
29241 }
29242 }
29243
29244 if (ddi_copyout(&session_offset, data, sizeof (int), flag) != 0) {
29245 rval = EFAULT;
29246 }
29247
29248 kmem_free(buffer, SONY_SESSION_OFFSET_LEN);
29249 kmem_free(com, sizeof (*com));
29250 return (rval);
29251 }
29252
29253
29254 /*
29255 * Function: sd_wm_cache_constructor()
29256 *
29257 * Description: Cache Constructor for the wmap cache for the read/modify/write
29258 * devices.
29259 *
29260 * Arguments: wm - A pointer to the sd_w_map to be initialized.
29261 * un - sd_lun structure for the device.
29262 * flag - the km flags passed to constructor
29263 *
29264 * Return Code: 0 on success.
29265 * -1 on failure.
29266 */
29267
29268 /*ARGSUSED*/
29269 static int
29270 sd_wm_cache_constructor(void *wm, void *un, int flags)
29271 {
29272 bzero(wm, sizeof (struct sd_w_map));
29273 cv_init(&((struct sd_w_map *)wm)->wm_avail, NULL, CV_DRIVER, NULL);
29274 return (0);
29275 }
29276
29277
29278 /*
29279 * Function: sd_wm_cache_destructor()
29280 *
29281 * Description: Cache destructor for the wmap cache for the read/modify/write
29282 * devices.
29283 *
29284 * Arguments: wm - A pointer to the sd_w_map to be initialized.
29285 * un - sd_lun structure for the device.
29286 */
29287 /*ARGSUSED*/
29288 static void
29289 sd_wm_cache_destructor(void *wm, void *un)
29290 {
29291 cv_destroy(&((struct sd_w_map *)wm)->wm_avail);
29292 }
29293
29294
29295 /*
29296 * Function: sd_range_lock()
29297 *
29298 * Description: Lock the range of blocks specified as parameter to ensure
29299 * that read, modify write is atomic and no other i/o writes
29300 * to the same location. The range is specified in terms
29301 * of start and end blocks. Block numbers are the actual
29302 * media block numbers and not system.
29303 *
29304 * Arguments: un - sd_lun structure for the device.
29305 * startb - The starting block number
29306 * endb - The end block number
29307 * typ - type of i/o - simple/read_modify_write
29308 *
29309 * Return Code: wm - pointer to the wmap structure.
29310 *
29311 * Context: This routine can sleep.
29312 */
29313
29314 static struct sd_w_map *
29315 sd_range_lock(struct sd_lun *un, daddr_t startb, daddr_t endb, ushort_t typ)
29316 {
29317 struct sd_w_map *wmp = NULL;
29318 struct sd_w_map *sl_wmp = NULL;
29319 struct sd_w_map *tmp_wmp;
29320 wm_state state = SD_WM_CHK_LIST;
29321
29322
29323 ASSERT(un != NULL);
29324 ASSERT(!mutex_owned(SD_MUTEX(un)));
29325
29326 mutex_enter(SD_MUTEX(un));
29327
29328 while (state != SD_WM_DONE) {
29329
29330 switch (state) {
29331 case SD_WM_CHK_LIST:
29332 /*
29333 * This is the starting state. Check the wmap list
29334 * to see if the range is currently available.
29335 */
29336 if (!(typ & SD_WTYPE_RMW) && !(un->un_rmw_count)) {
29337 /*
29338 * If this is a simple write and no rmw
29339 * i/o is pending then try to lock the
29340 * range as the range should be available.
29341 */
29342 state = SD_WM_LOCK_RANGE;
29343 } else {
29344 tmp_wmp = sd_get_range(un, startb, endb);
29345 if (tmp_wmp != NULL) {
29346 if ((wmp != NULL) && ONLIST(un, wmp)) {
29347 /*
29348 * Should not keep onlist wmps
29349 * while waiting this macro
29350 * will also do wmp = NULL;
29351 */
29352 FREE_ONLIST_WMAP(un, wmp);
29353 }
29354 /*
29355 * sl_wmp is the wmap on which wait
29356 * is done, since the tmp_wmp points
29357 * to the inuse wmap, set sl_wmp to
29358 * tmp_wmp and change the state to sleep
29359 */
29360 sl_wmp = tmp_wmp;
29361 state = SD_WM_WAIT_MAP;
29362 } else {
29363 state = SD_WM_LOCK_RANGE;
29364 }
29365
29366 }
29367 break;
29368
29369 case SD_WM_LOCK_RANGE:
29370 ASSERT(un->un_wm_cache);
29371 /*
29372 * The range need to be locked, try to get a wmap.
29373 * First attempt it with NO_SLEEP, want to avoid a sleep
29374 * if possible as we will have to release the sd mutex
29375 * if we have to sleep.
29376 */
29377 if (wmp == NULL)
29378 wmp = kmem_cache_alloc(un->un_wm_cache,
29379 KM_NOSLEEP);
29380 if (wmp == NULL) {
29381 mutex_exit(SD_MUTEX(un));
29382 _NOTE(DATA_READABLE_WITHOUT_LOCK
29383 (sd_lun::un_wm_cache))
29384 wmp = kmem_cache_alloc(un->un_wm_cache,
29385 KM_SLEEP);
29386 mutex_enter(SD_MUTEX(un));
29387 /*
29388 * we released the mutex so recheck and go to
29389 * check list state.
29390 */
29391 state = SD_WM_CHK_LIST;
29392 } else {
29393 /*
29394 * We exit out of state machine since we
29395 * have the wmap. Do the housekeeping first.
29396 * place the wmap on the wmap list if it is not
29397 * on it already and then set the state to done.
29398 */
29399 wmp->wm_start = startb;
29400 wmp->wm_end = endb;
29401 wmp->wm_flags = typ | SD_WM_BUSY;
29402 if (typ & SD_WTYPE_RMW) {
29403 un->un_rmw_count++;
29404 }
29405 /*
29406 * If not already on the list then link
29407 */
29408 if (!ONLIST(un, wmp)) {
29409 wmp->wm_next = un->un_wm;
29410 wmp->wm_prev = NULL;
29411 if (wmp->wm_next)
29412 wmp->wm_next->wm_prev = wmp;
29413 un->un_wm = wmp;
29414 }
29415 state = SD_WM_DONE;
29416 }
29417 break;
29418
29419 case SD_WM_WAIT_MAP:
29420 ASSERT(sl_wmp->wm_flags & SD_WM_BUSY);
29421 /*
29422 * Wait is done on sl_wmp, which is set in the
29423 * check_list state.
29424 */
29425 sl_wmp->wm_wanted_count++;
29426 cv_wait(&sl_wmp->wm_avail, SD_MUTEX(un));
29427 sl_wmp->wm_wanted_count--;
29428 /*
29429 * We can reuse the memory from the completed sl_wmp
29430 * lock range for our new lock, but only if noone is
29431 * waiting for it.
29432 */
29433 ASSERT(!(sl_wmp->wm_flags & SD_WM_BUSY));
29434 if (sl_wmp->wm_wanted_count == 0) {
29435 if (wmp != NULL)
29436 CHK_N_FREEWMP(un, wmp);
29437 wmp = sl_wmp;
29438 }
29439 sl_wmp = NULL;
29440 /*
29441 * After waking up, need to recheck for availability of
29442 * range.
29443 */
29444 state = SD_WM_CHK_LIST;
29445 break;
29446
29447 default:
29448 panic("sd_range_lock: "
29449 "Unknown state %d in sd_range_lock", state);
29450 /*NOTREACHED*/
29451 } /* switch(state) */
29452
29453 } /* while(state != SD_WM_DONE) */
29454
29455 mutex_exit(SD_MUTEX(un));
29456
29457 ASSERT(wmp != NULL);
29458
29459 return (wmp);
29460 }
29461
29462
29463 /*
29464 * Function: sd_get_range()
29465 *
29466 * Description: Find if there any overlapping I/O to this one
29467 * Returns the write-map of 1st such I/O, NULL otherwise.
29468 *
29469 * Arguments: un - sd_lun structure for the device.
29470 * startb - The starting block number
29471 * endb - The end block number
29472 *
29473 * Return Code: wm - pointer to the wmap structure.
29474 */
29475
29476 static struct sd_w_map *
29477 sd_get_range(struct sd_lun *un, daddr_t startb, daddr_t endb)
29478 {
29479 struct sd_w_map *wmp;
29480
29481 ASSERT(un != NULL);
29482
29483 for (wmp = un->un_wm; wmp != NULL; wmp = wmp->wm_next) {
29484 if (!(wmp->wm_flags & SD_WM_BUSY)) {
29485 continue;
29486 }
29487 if ((startb >= wmp->wm_start) && (startb <= wmp->wm_end)) {
29488 break;
29489 }
29490 if ((endb >= wmp->wm_start) && (endb <= wmp->wm_end)) {
29491 break;
29492 }
29493 }
29494
29495 return (wmp);
29496 }
29497
29498
29499 /*
29500 * Function: sd_free_inlist_wmap()
29501 *
29502 * Description: Unlink and free a write map struct.
29503 *
29504 * Arguments: un - sd_lun structure for the device.
29505 * wmp - sd_w_map which needs to be unlinked.
29506 */
29507
29508 static void
29509 sd_free_inlist_wmap(struct sd_lun *un, struct sd_w_map *wmp)
29510 {
29511 ASSERT(un != NULL);
29512
29513 if (un->un_wm == wmp) {
29514 un->un_wm = wmp->wm_next;
29515 } else {
29516 wmp->wm_prev->wm_next = wmp->wm_next;
29517 }
29518
29519 if (wmp->wm_next) {
29520 wmp->wm_next->wm_prev = wmp->wm_prev;
29521 }
29522
29523 wmp->wm_next = wmp->wm_prev = NULL;
29524
29525 kmem_cache_free(un->un_wm_cache, wmp);
29526 }
29527
29528
29529 /*
29530 * Function: sd_range_unlock()
29531 *
29532 * Description: Unlock the range locked by wm.
29533 * Free write map if nobody else is waiting on it.
29534 *
29535 * Arguments: un - sd_lun structure for the device.
29536 * wmp - sd_w_map which needs to be unlinked.
29537 */
29538
29539 static void
29540 sd_range_unlock(struct sd_lun *un, struct sd_w_map *wm)
29541 {
29542 ASSERT(un != NULL);
29543 ASSERT(wm != NULL);
29544 ASSERT(!mutex_owned(SD_MUTEX(un)));
29545
29546 mutex_enter(SD_MUTEX(un));
29547
29548 if (wm->wm_flags & SD_WTYPE_RMW) {
29549 un->un_rmw_count--;
29550 }
29551
29552 if (wm->wm_wanted_count) {
29553 wm->wm_flags = 0;
29554 /*
29555 * Broadcast that the wmap is available now.
29556 */
29557 cv_broadcast(&wm->wm_avail);
29558 } else {
29559 /*
29560 * If no one is waiting on the map, it should be free'ed.
29561 */
29562 sd_free_inlist_wmap(un, wm);
29563 }
29564
29565 mutex_exit(SD_MUTEX(un));
29566 }
29567
29568
29569 /*
29570 * Function: sd_read_modify_write_task
29571 *
29572 * Description: Called from a taskq thread to initiate the write phase of
29573 * a read-modify-write request. This is used for targets where
29574 * un->un_sys_blocksize != un->un_tgt_blocksize.
29575 *
29576 * Arguments: arg - a pointer to the buf(9S) struct for the write command.
29577 *
29578 * Context: Called under taskq thread context.
29579 */
29580
29581 static void
29582 sd_read_modify_write_task(void *arg)
29583 {
29584 struct sd_mapblocksize_info *bsp;
29585 struct buf *bp;
29586 struct sd_xbuf *xp;
29587 struct sd_lun *un;
29588
29589 bp = arg; /* The bp is given in arg */
29590 ASSERT(bp != NULL);
29591
29592 /* Get the pointer to the layer-private data struct */
29593 xp = SD_GET_XBUF(bp);
29594 ASSERT(xp != NULL);
29595 bsp = xp->xb_private;
29596 ASSERT(bsp != NULL);
29597
29598 un = SD_GET_UN(bp);
29599 ASSERT(un != NULL);
29600 ASSERT(!mutex_owned(SD_MUTEX(un)));
29601
29602 SD_TRACE(SD_LOG_IO_RMMEDIA, un,
29603 "sd_read_modify_write_task: entry: buf:0x%p\n", bp);
29604
29605 /*
29606 * This is the write phase of a read-modify-write request, called
29607 * under the context of a taskq thread in response to the completion
29608 * of the read portion of the rmw request completing under interrupt
29609 * context. The write request must be sent from here down the iostart
29610 * chain as if it were being sent from sd_mapblocksize_iostart(), so
29611 * we use the layer index saved in the layer-private data area.
29612 */
29613 SD_NEXT_IOSTART(bsp->mbs_layer_index, un, bp);
29614
29615 SD_TRACE(SD_LOG_IO_RMMEDIA, un,
29616 "sd_read_modify_write_task: exit: buf:0x%p\n", bp);
29617 }
29618
29619
29620 /*
29621 * Function: sddump_do_read_of_rmw()
29622 *
29623 * Description: This routine will be called from sddump, If sddump is called
29624 * with an I/O which not aligned on device blocksize boundary
29625 * then the write has to be converted to read-modify-write.
29626 * Do the read part here in order to keep sddump simple.
29627 * Note - That the sd_mutex is held across the call to this
29628 * routine.
29629 *
29630 * Arguments: un - sd_lun
29631 * blkno - block number in terms of media block size.
29632 * nblk - number of blocks.
29633 * bpp - pointer to pointer to the buf structure. On return
29634 * from this function, *bpp points to the valid buffer
29635 * to which the write has to be done.
29636 *
29637 * Return Code: 0 for success or errno-type return code
29638 */
29639
29640 static int
29641 sddump_do_read_of_rmw(struct sd_lun *un, uint64_t blkno, uint64_t nblk,
29642 struct buf **bpp)
29643 {
29644 int err;
29645 int i;
29646 int rval;
29647 struct buf *bp;
29648 struct scsi_pkt *pkt = NULL;
29649 uint32_t target_blocksize;
29650
29651 ASSERT(un != NULL);
29652 ASSERT(mutex_owned(SD_MUTEX(un)));
29653
29654 target_blocksize = un->un_tgt_blocksize;
29655
29656 mutex_exit(SD_MUTEX(un));
29657
29658 bp = scsi_alloc_consistent_buf(SD_ADDRESS(un), (struct buf *)NULL,
29659 (size_t)(nblk * target_blocksize), B_READ, NULL_FUNC, NULL);
29660 if (bp == NULL) {
29661 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
29662 "no resources for dumping; giving up");
29663 err = ENOMEM;
29664 goto done;
29665 }
29666
29667 rval = sd_setup_rw_pkt(un, &pkt, bp, 0, NULL_FUNC, NULL,
29668 blkno, nblk);
29669 if (rval != 0) {
29670 scsi_free_consistent_buf(bp);
29671 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
29672 "no resources for dumping; giving up");
29673 err = ENOMEM;
29674 goto done;
29675 }
29676
29677 pkt->pkt_flags |= FLAG_NOINTR;
29678
29679 err = EIO;
29680 for (i = 0; i < SD_NDUMP_RETRIES; i++) {
29681
29682 /*
29683 * Scsi_poll returns 0 (success) if the command completes and
29684 * the status block is STATUS_GOOD. We should only check
29685 * errors if this condition is not true. Even then we should
29686 * send our own request sense packet only if we have a check
29687 * condition and auto request sense has not been performed by
29688 * the hba.
29689 */
29690 SD_TRACE(SD_LOG_DUMP, un, "sddump: sending read\n");
29691
29692 if ((sd_scsi_poll(un, pkt) == 0) && (pkt->pkt_resid == 0)) {
29693 err = 0;
29694 break;
29695 }
29696
29697 /*
29698 * Check CMD_DEV_GONE 1st, give up if device is gone,
29699 * no need to read RQS data.
29700 */
29701 if (pkt->pkt_reason == CMD_DEV_GONE) {
29702 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
29703 "Error while dumping state with rmw..."
29704 "Device is gone\n");
29705 break;
29706 }
29707
29708 if (SD_GET_PKT_STATUS(pkt) == STATUS_CHECK) {
29709 SD_INFO(SD_LOG_DUMP, un,
29710 "sddump: read failed with CHECK, try # %d\n", i);
29711 if (((pkt->pkt_state & STATE_ARQ_DONE) == 0)) {
29712 (void) sd_send_polled_RQS(un);
29713 }
29714
29715 continue;
29716 }
29717
29718 if (SD_GET_PKT_STATUS(pkt) == STATUS_BUSY) {
29719 int reset_retval = 0;
29720
29721 SD_INFO(SD_LOG_DUMP, un,
29722 "sddump: read failed with BUSY, try # %d\n", i);
29723
29724 if (un->un_f_lun_reset_enabled == TRUE) {
29725 reset_retval = scsi_reset(SD_ADDRESS(un),
29726 RESET_LUN);
29727 }
29728 if (reset_retval == 0) {
29729 (void) scsi_reset(SD_ADDRESS(un), RESET_TARGET);
29730 }
29731 (void) sd_send_polled_RQS(un);
29732
29733 } else {
29734 SD_INFO(SD_LOG_DUMP, un,
29735 "sddump: read failed with 0x%x, try # %d\n",
29736 SD_GET_PKT_STATUS(pkt), i);
29737 mutex_enter(SD_MUTEX(un));
29738 sd_reset_target(un, pkt);
29739 mutex_exit(SD_MUTEX(un));
29740 }
29741
29742 /*
29743 * If we are not getting anywhere with lun/target resets,
29744 * let's reset the bus.
29745 */
29746 if (i > SD_NDUMP_RETRIES/2) {
29747 (void) scsi_reset(SD_ADDRESS(un), RESET_ALL);
29748 (void) sd_send_polled_RQS(un);
29749 }
29750
29751 }
29752 scsi_destroy_pkt(pkt);
29753
29754 if (err != 0) {
29755 scsi_free_consistent_buf(bp);
29756 *bpp = NULL;
29757 } else {
29758 *bpp = bp;
29759 }
29760
29761 done:
29762 mutex_enter(SD_MUTEX(un));
29763 return (err);
29764 }
29765
29766
29767 /*
29768 * Function: sd_failfast_flushq
29769 *
29770 * Description: Take all bp's on the wait queue that have B_FAILFAST set
29771 * in b_flags and move them onto the failfast queue, then kick
29772 * off a thread to return all bp's on the failfast queue to
29773 * their owners with an error set.
29774 *
29775 * Arguments: un - pointer to the soft state struct for the instance.
29776 *
29777 * Context: may execute in interrupt context.
29778 */
29779
29780 static void
29781 sd_failfast_flushq(struct sd_lun *un)
29782 {
29783 struct buf *bp;
29784 struct buf *next_waitq_bp;
29785 struct buf *prev_waitq_bp = NULL;
29786
29787 ASSERT(un != NULL);
29788 ASSERT(mutex_owned(SD_MUTEX(un)));
29789 ASSERT(un->un_failfast_state == SD_FAILFAST_ACTIVE);
29790 ASSERT(un->un_failfast_bp == NULL);
29791
29792 SD_TRACE(SD_LOG_IO_FAILFAST, un,
29793 "sd_failfast_flushq: entry: un:0x%p\n", un);
29794
29795 /*
29796 * Check if we should flush all bufs when entering failfast state, or
29797 * just those with B_FAILFAST set.
29798 */
29799 if (sd_failfast_flushctl & SD_FAILFAST_FLUSH_ALL_BUFS) {
29800 /*
29801 * Move *all* bp's on the wait queue to the failfast flush
29802 * queue, including those that do NOT have B_FAILFAST set.
29803 */
29804 if (un->un_failfast_headp == NULL) {
29805 ASSERT(un->un_failfast_tailp == NULL);
29806 un->un_failfast_headp = un->un_waitq_headp;
29807 } else {
29808 ASSERT(un->un_failfast_tailp != NULL);
29809 un->un_failfast_tailp->av_forw = un->un_waitq_headp;
29810 }
29811
29812 un->un_failfast_tailp = un->un_waitq_tailp;
29813
29814 /* update kstat for each bp moved out of the waitq */
29815 for (bp = un->un_waitq_headp; bp != NULL; bp = bp->av_forw) {
29816 SD_UPDATE_KSTATS(un, kstat_waitq_exit, bp);
29817 }
29818
29819 /* empty the waitq */
29820 un->un_waitq_headp = un->un_waitq_tailp = NULL;
29821
29822 } else {
29823 /*
29824 * Go thru the wait queue, pick off all entries with
29825 * B_FAILFAST set, and move these onto the failfast queue.
29826 */
29827 for (bp = un->un_waitq_headp; bp != NULL; bp = next_waitq_bp) {
29828 /*
29829 * Save the pointer to the next bp on the wait queue,
29830 * so we get to it on the next iteration of this loop.
29831 */
29832 next_waitq_bp = bp->av_forw;
29833
29834 /*
29835 * If this bp from the wait queue does NOT have
29836 * B_FAILFAST set, just move on to the next element
29837 * in the wait queue. Note, this is the only place
29838 * where it is correct to set prev_waitq_bp.
29839 */
29840 if ((bp->b_flags & B_FAILFAST) == 0) {
29841 prev_waitq_bp = bp;
29842 continue;
29843 }
29844
29845 /*
29846 * Remove the bp from the wait queue.
29847 */
29848 if (bp == un->un_waitq_headp) {
29849 /* The bp is the first element of the waitq. */
29850 un->un_waitq_headp = next_waitq_bp;
29851 if (un->un_waitq_headp == NULL) {
29852 /* The wait queue is now empty */
29853 un->un_waitq_tailp = NULL;
29854 }
29855 } else {
29856 /*
29857 * The bp is either somewhere in the middle
29858 * or at the end of the wait queue.
29859 */
29860 ASSERT(un->un_waitq_headp != NULL);
29861 ASSERT(prev_waitq_bp != NULL);
29862 ASSERT((prev_waitq_bp->b_flags & B_FAILFAST)
29863 == 0);
29864 if (bp == un->un_waitq_tailp) {
29865 /* bp is the last entry on the waitq. */
29866 ASSERT(next_waitq_bp == NULL);
29867 un->un_waitq_tailp = prev_waitq_bp;
29868 }
29869 prev_waitq_bp->av_forw = next_waitq_bp;
29870 }
29871 bp->av_forw = NULL;
29872
29873 /*
29874 * update kstat since the bp is moved out of
29875 * the waitq
29876 */
29877 SD_UPDATE_KSTATS(un, kstat_waitq_exit, bp);
29878
29879 /*
29880 * Now put the bp onto the failfast queue.
29881 */
29882 if (un->un_failfast_headp == NULL) {
29883 /* failfast queue is currently empty */
29884 ASSERT(un->un_failfast_tailp == NULL);
29885 un->un_failfast_headp =
29886 un->un_failfast_tailp = bp;
29887 } else {
29888 /* Add the bp to the end of the failfast q */
29889 ASSERT(un->un_failfast_tailp != NULL);
29890 ASSERT(un->un_failfast_tailp->b_flags &
29891 B_FAILFAST);
29892 un->un_failfast_tailp->av_forw = bp;
29893 un->un_failfast_tailp = bp;
29894 }
29895 }
29896 }
29897
29898 /*
29899 * Now return all bp's on the failfast queue to their owners.
29900 */
29901 while ((bp = un->un_failfast_headp) != NULL) {
29902
29903 un->un_failfast_headp = bp->av_forw;
29904 if (un->un_failfast_headp == NULL) {
29905 un->un_failfast_tailp = NULL;
29906 }
29907
29908 /*
29909 * We want to return the bp with a failure error code, but
29910 * we do not want a call to sd_start_cmds() to occur here,
29911 * so use sd_return_failed_command_no_restart() instead of
29912 * sd_return_failed_command().
29913 */
29914 sd_return_failed_command_no_restart(un, bp, EIO);
29915 }
29916
29917 /* Flush the xbuf queues if required. */
29918 if (sd_failfast_flushctl & SD_FAILFAST_FLUSH_ALL_QUEUES) {
29919 ddi_xbuf_flushq(un->un_xbuf_attr, sd_failfast_flushq_callback);
29920 }
29921
29922 SD_TRACE(SD_LOG_IO_FAILFAST, un,
29923 "sd_failfast_flushq: exit: un:0x%p\n", un);
29924 }
29925
29926
29927 /*
29928 * Function: sd_failfast_flushq_callback
29929 *
29930 * Description: Return TRUE if the given bp meets the criteria for failfast
29931 * flushing. Used with ddi_xbuf_flushq(9F).
29932 *
29933 * Arguments: bp - ptr to buf struct to be examined.
29934 *
29935 * Context: Any
29936 */
29937
29938 static int
29939 sd_failfast_flushq_callback(struct buf *bp)
29940 {
29941 /*
29942 * Return TRUE if (1) we want to flush ALL bufs when the failfast
29943 * state is entered; OR (2) the given bp has B_FAILFAST set.
29944 */
29945 return (((sd_failfast_flushctl & SD_FAILFAST_FLUSH_ALL_BUFS) ||
29946 (bp->b_flags & B_FAILFAST)) ? TRUE : FALSE);
29947 }
29948
29949
29950
29951 /*
29952 * Function: sd_setup_next_xfer
29953 *
29954 * Description: Prepare next I/O operation using DMA_PARTIAL
29955 *
29956 */
29957
29958 static int
29959 sd_setup_next_xfer(struct sd_lun *un, struct buf *bp,
29960 struct scsi_pkt *pkt, struct sd_xbuf *xp)
29961 {
29962 ssize_t num_blks_not_xfered;
29963 daddr_t strt_blk_num;
29964 ssize_t bytes_not_xfered;
29965 int rval;
29966
29967 ASSERT(pkt->pkt_resid == 0);
29968
29969 /*
29970 * Calculate next block number and amount to be transferred.
29971 *
29972 * How much data NOT transfered to the HBA yet.
29973 */
29974 bytes_not_xfered = xp->xb_dma_resid;
29975
29976 /*
29977 * figure how many blocks NOT transfered to the HBA yet.
29978 */
29979 num_blks_not_xfered = SD_BYTES2TGTBLOCKS(un, bytes_not_xfered);
29980
29981 /*
29982 * set starting block number to the end of what WAS transfered.
29983 */
29984 strt_blk_num = xp->xb_blkno +
29985 SD_BYTES2TGTBLOCKS(un, bp->b_bcount - bytes_not_xfered);
29986
29987 /*
29988 * Move pkt to the next portion of the xfer. sd_setup_next_rw_pkt
29989 * will call scsi_initpkt with NULL_FUNC so we do not have to release
29990 * the disk mutex here.
29991 */
29992 rval = sd_setup_next_rw_pkt(un, pkt, bp,
29993 strt_blk_num, num_blks_not_xfered);
29994
29995 if (rval == 0) {
29996
29997 /*
29998 * Success.
29999 *
30000 * Adjust things if there are still more blocks to be
30001 * transfered.
30002 */
30003 xp->xb_dma_resid = pkt->pkt_resid;
30004 pkt->pkt_resid = 0;
30005
30006 return (1);
30007 }
30008
30009 /*
30010 * There's really only one possible return value from
30011 * sd_setup_next_rw_pkt which occurs when scsi_init_pkt
30012 * returns NULL.
30013 */
30014 ASSERT(rval == SD_PKT_ALLOC_FAILURE);
30015
30016 bp->b_resid = bp->b_bcount;
30017 bp->b_flags |= B_ERROR;
30018
30019 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
30020 "Error setting up next portion of DMA transfer\n");
30021
30022 return (0);
30023 }
30024
30025 /*
30026 * Function: sd_panic_for_res_conflict
30027 *
30028 * Description: Call panic with a string formatted with "Reservation Conflict"
30029 * and a human readable identifier indicating the SD instance
30030 * that experienced the reservation conflict.
30031 *
30032 * Arguments: un - pointer to the soft state struct for the instance.
30033 *
30034 * Context: may execute in interrupt context.
30035 */
30036
30037 #define SD_RESV_CONFLICT_FMT_LEN 40
30038 void
30039 sd_panic_for_res_conflict(struct sd_lun *un)
30040 {
30041 char panic_str[SD_RESV_CONFLICT_FMT_LEN+MAXPATHLEN];
30042 char path_str[MAXPATHLEN];
30043
30044 (void) snprintf(panic_str, sizeof (panic_str),
30045 "Reservation Conflict\nDisk: %s",
30046 ddi_pathname(SD_DEVINFO(un), path_str));
30047
30048 panic(panic_str);
30049 }
30050
30051 /*
30052 * Note: The following sd_faultinjection_ioctl( ) routines implement
30053 * driver support for handling fault injection for error analysis
30054 * causing faults in multiple layers of the driver.
30055 *
30056 */
30057
30058 #ifdef SD_FAULT_INJECTION
30059 static uint_t sd_fault_injection_on = 0;
30060
30061 /*
30062 * Function: sd_faultinjection_ioctl()
30063 *
30064 * Description: This routine is the driver entry point for handling
30065 * faultinjection ioctls to inject errors into the
30066 * layer model
30067 *
30068 * Arguments: cmd - the ioctl cmd received
30069 * arg - the arguments from user and returns
30070 */
30071
30072 static void
30073 sd_faultinjection_ioctl(int cmd, intptr_t arg, struct sd_lun *un) {
30074
30075 uint_t i = 0;
30076 uint_t rval;
30077
30078 SD_TRACE(SD_LOG_IOERR, un, "sd_faultinjection_ioctl: entry\n");
30079
30080 mutex_enter(SD_MUTEX(un));
30081
30082 switch (cmd) {
30083 case SDIOCRUN:
30084 /* Allow pushed faults to be injected */
30085 SD_INFO(SD_LOG_SDTEST, un,
30086 "sd_faultinjection_ioctl: Injecting Fault Run\n");
30087
30088 sd_fault_injection_on = 1;
30089
30090 SD_INFO(SD_LOG_IOERR, un,
30091 "sd_faultinjection_ioctl: run finished\n");
30092 break;
30093
30094 case SDIOCSTART:
30095 /* Start Injection Session */
30096 SD_INFO(SD_LOG_SDTEST, un,
30097 "sd_faultinjection_ioctl: Injecting Fault Start\n");
30098
30099 sd_fault_injection_on = 0;
30100 un->sd_injection_mask = 0xFFFFFFFF;
30101 for (i = 0; i < SD_FI_MAX_ERROR; i++) {
30102 un->sd_fi_fifo_pkt[i] = NULL;
30103 un->sd_fi_fifo_xb[i] = NULL;
30104 un->sd_fi_fifo_un[i] = NULL;
30105 un->sd_fi_fifo_arq[i] = NULL;
30106 }
30107 un->sd_fi_fifo_start = 0;
30108 un->sd_fi_fifo_end = 0;
30109
30110 mutex_enter(&(un->un_fi_mutex));
30111 un->sd_fi_log[0] = '\0';
30112 un->sd_fi_buf_len = 0;
30113 mutex_exit(&(un->un_fi_mutex));
30114
30115 SD_INFO(SD_LOG_IOERR, un,
30116 "sd_faultinjection_ioctl: start finished\n");
30117 break;
30118
30119 case SDIOCSTOP:
30120 /* Stop Injection Session */
30121 SD_INFO(SD_LOG_SDTEST, un,
30122 "sd_faultinjection_ioctl: Injecting Fault Stop\n");
30123 sd_fault_injection_on = 0;
30124 un->sd_injection_mask = 0x0;
30125
30126 /* Empty stray or unuseds structs from fifo */
30127 for (i = 0; i < SD_FI_MAX_ERROR; i++) {
30128 if (un->sd_fi_fifo_pkt[i] != NULL) {
30129 kmem_free(un->sd_fi_fifo_pkt[i],
30130 sizeof (struct sd_fi_pkt));
30131 }
30132 if (un->sd_fi_fifo_xb[i] != NULL) {
30133 kmem_free(un->sd_fi_fifo_xb[i],
30134 sizeof (struct sd_fi_xb));
30135 }
30136 if (un->sd_fi_fifo_un[i] != NULL) {
30137 kmem_free(un->sd_fi_fifo_un[i],
30138 sizeof (struct sd_fi_un));
30139 }
30140 if (un->sd_fi_fifo_arq[i] != NULL) {
30141 kmem_free(un->sd_fi_fifo_arq[i],
30142 sizeof (struct sd_fi_arq));
30143 }
30144 un->sd_fi_fifo_pkt[i] = NULL;
30145 un->sd_fi_fifo_un[i] = NULL;
30146 un->sd_fi_fifo_xb[i] = NULL;
30147 un->sd_fi_fifo_arq[i] = NULL;
30148 }
30149 un->sd_fi_fifo_start = 0;
30150 un->sd_fi_fifo_end = 0;
30151
30152 SD_INFO(SD_LOG_IOERR, un,
30153 "sd_faultinjection_ioctl: stop finished\n");
30154 break;
30155
30156 case SDIOCINSERTPKT:
30157 /* Store a packet struct to be pushed onto fifo */
30158 SD_INFO(SD_LOG_SDTEST, un,
30159 "sd_faultinjection_ioctl: Injecting Fault Insert Pkt\n");
30160
30161 i = un->sd_fi_fifo_end % SD_FI_MAX_ERROR;
30162
30163 sd_fault_injection_on = 0;
30164
30165 /* No more that SD_FI_MAX_ERROR allowed in Queue */
30166 if (un->sd_fi_fifo_pkt[i] != NULL) {
30167 kmem_free(un->sd_fi_fifo_pkt[i],
30168 sizeof (struct sd_fi_pkt));
30169 }
30170 if (arg != NULL) {
30171 un->sd_fi_fifo_pkt[i] =
30172 kmem_alloc(sizeof (struct sd_fi_pkt), KM_NOSLEEP);
30173 if (un->sd_fi_fifo_pkt[i] == NULL) {
30174 /* Alloc failed don't store anything */
30175 break;
30176 }
30177 rval = ddi_copyin((void *)arg, un->sd_fi_fifo_pkt[i],
30178 sizeof (struct sd_fi_pkt), 0);
30179 if (rval == -1) {
30180 kmem_free(un->sd_fi_fifo_pkt[i],
30181 sizeof (struct sd_fi_pkt));
30182 un->sd_fi_fifo_pkt[i] = NULL;
30183 }
30184 } else {
30185 SD_INFO(SD_LOG_IOERR, un,
30186 "sd_faultinjection_ioctl: pkt null\n");
30187 }
30188 break;
30189
30190 case SDIOCINSERTXB:
30191 /* Store a xb struct to be pushed onto fifo */
30192 SD_INFO(SD_LOG_SDTEST, un,
30193 "sd_faultinjection_ioctl: Injecting Fault Insert XB\n");
30194
30195 i = un->sd_fi_fifo_end % SD_FI_MAX_ERROR;
30196
30197 sd_fault_injection_on = 0;
30198
30199 if (un->sd_fi_fifo_xb[i] != NULL) {
30200 kmem_free(un->sd_fi_fifo_xb[i],
30201 sizeof (struct sd_fi_xb));
30202 un->sd_fi_fifo_xb[i] = NULL;
30203 }
30204 if (arg != NULL) {
30205 un->sd_fi_fifo_xb[i] =
30206 kmem_alloc(sizeof (struct sd_fi_xb), KM_NOSLEEP);
30207 if (un->sd_fi_fifo_xb[i] == NULL) {
30208 /* Alloc failed don't store anything */
30209 break;
30210 }
30211 rval = ddi_copyin((void *)arg, un->sd_fi_fifo_xb[i],
30212 sizeof (struct sd_fi_xb), 0);
30213
30214 if (rval == -1) {
30215 kmem_free(un->sd_fi_fifo_xb[i],
30216 sizeof (struct sd_fi_xb));
30217 un->sd_fi_fifo_xb[i] = NULL;
30218 }
30219 } else {
30220 SD_INFO(SD_LOG_IOERR, un,
30221 "sd_faultinjection_ioctl: xb null\n");
30222 }
30223 break;
30224
30225 case SDIOCINSERTUN:
30226 /* Store a un struct to be pushed onto fifo */
30227 SD_INFO(SD_LOG_SDTEST, un,
30228 "sd_faultinjection_ioctl: Injecting Fault Insert UN\n");
30229
30230 i = un->sd_fi_fifo_end % SD_FI_MAX_ERROR;
30231
30232 sd_fault_injection_on = 0;
30233
30234 if (un->sd_fi_fifo_un[i] != NULL) {
30235 kmem_free(un->sd_fi_fifo_un[i],
30236 sizeof (struct sd_fi_un));
30237 un->sd_fi_fifo_un[i] = NULL;
30238 }
30239 if (arg != NULL) {
30240 un->sd_fi_fifo_un[i] =
30241 kmem_alloc(sizeof (struct sd_fi_un), KM_NOSLEEP);
30242 if (un->sd_fi_fifo_un[i] == NULL) {
30243 /* Alloc failed don't store anything */
30244 break;
30245 }
30246 rval = ddi_copyin((void *)arg, un->sd_fi_fifo_un[i],
30247 sizeof (struct sd_fi_un), 0);
30248 if (rval == -1) {
30249 kmem_free(un->sd_fi_fifo_un[i],
30250 sizeof (struct sd_fi_un));
30251 un->sd_fi_fifo_un[i] = NULL;
30252 }
30253
30254 } else {
30255 SD_INFO(SD_LOG_IOERR, un,
30256 "sd_faultinjection_ioctl: un null\n");
30257 }
30258
30259 break;
30260
30261 case SDIOCINSERTARQ:
30262 /* Store a arq struct to be pushed onto fifo */
30263 SD_INFO(SD_LOG_SDTEST, un,
30264 "sd_faultinjection_ioctl: Injecting Fault Insert ARQ\n");
30265 i = un->sd_fi_fifo_end % SD_FI_MAX_ERROR;
30266
30267 sd_fault_injection_on = 0;
30268
30269 if (un->sd_fi_fifo_arq[i] != NULL) {
30270 kmem_free(un->sd_fi_fifo_arq[i],
30271 sizeof (struct sd_fi_arq));
30272 un->sd_fi_fifo_arq[i] = NULL;
30273 }
30274 if (arg != NULL) {
30275 un->sd_fi_fifo_arq[i] =
30276 kmem_alloc(sizeof (struct sd_fi_arq), KM_NOSLEEP);
30277 if (un->sd_fi_fifo_arq[i] == NULL) {
30278 /* Alloc failed don't store anything */
30279 break;
30280 }
30281 rval = ddi_copyin((void *)arg, un->sd_fi_fifo_arq[i],
30282 sizeof (struct sd_fi_arq), 0);
30283 if (rval == -1) {
30284 kmem_free(un->sd_fi_fifo_arq[i],
30285 sizeof (struct sd_fi_arq));
30286 un->sd_fi_fifo_arq[i] = NULL;
30287 }
30288
30289 } else {
30290 SD_INFO(SD_LOG_IOERR, un,
30291 "sd_faultinjection_ioctl: arq null\n");
30292 }
30293
30294 break;
30295
30296 case SDIOCPUSH:
30297 /* Push stored xb, pkt, un, and arq onto fifo */
30298 sd_fault_injection_on = 0;
30299
30300 if (arg != NULL) {
30301 rval = ddi_copyin((void *)arg, &i, sizeof (uint_t), 0);
30302 if (rval != -1 &&
30303 un->sd_fi_fifo_end + i < SD_FI_MAX_ERROR) {
30304 un->sd_fi_fifo_end += i;
30305 }
30306 } else {
30307 SD_INFO(SD_LOG_IOERR, un,
30308 "sd_faultinjection_ioctl: push arg null\n");
30309 if (un->sd_fi_fifo_end + i < SD_FI_MAX_ERROR) {
30310 un->sd_fi_fifo_end++;
30311 }
30312 }
30313 SD_INFO(SD_LOG_IOERR, un,
30314 "sd_faultinjection_ioctl: push to end=%d\n",
30315 un->sd_fi_fifo_end);
30316 break;
30317
30318 case SDIOCRETRIEVE:
30319 /* Return buffer of log from Injection session */
30320 SD_INFO(SD_LOG_SDTEST, un,
30321 "sd_faultinjection_ioctl: Injecting Fault Retreive");
30322
30323 sd_fault_injection_on = 0;
30324
30325 mutex_enter(&(un->un_fi_mutex));
30326 rval = ddi_copyout(un->sd_fi_log, (void *)arg,
30327 un->sd_fi_buf_len+1, 0);
30328 mutex_exit(&(un->un_fi_mutex));
30329
30330 if (rval == -1) {
30331 /*
30332 * arg is possibly invalid setting
30333 * it to NULL for return
30334 */
30335 arg = NULL;
30336 }
30337 break;
30338 }
30339
30340 mutex_exit(SD_MUTEX(un));
30341 SD_TRACE(SD_LOG_IOERR, un, "sd_faultinjection_ioctl:"
30342 " exit\n");
30343 }
30344
30345
30346 /*
30347 * Function: sd_injection_log()
30348 *
30349 * Description: This routine adds buff to the already existing injection log
30350 * for retrieval via faultinjection_ioctl for use in fault
30351 * detection and recovery
30352 *
30353 * Arguments: buf - the string to add to the log
30354 */
30355
30356 static void
30357 sd_injection_log(char *buf, struct sd_lun *un)
30358 {
30359 uint_t len;
30360
30361 ASSERT(un != NULL);
30362 ASSERT(buf != NULL);
30363
30364 mutex_enter(&(un->un_fi_mutex));
30365
30366 len = min(strlen(buf), 255);
30367 /* Add logged value to Injection log to be returned later */
30368 if (len + un->sd_fi_buf_len < SD_FI_MAX_BUF) {
30369 uint_t offset = strlen((char *)un->sd_fi_log);
30370 char *destp = (char *)un->sd_fi_log + offset;
30371 int i;
30372 for (i = 0; i < len; i++) {
30373 *destp++ = *buf++;
30374 }
30375 un->sd_fi_buf_len += len;
30376 un->sd_fi_log[un->sd_fi_buf_len] = '\0';
30377 }
30378
30379 mutex_exit(&(un->un_fi_mutex));
30380 }
30381
30382
30383 /*
30384 * Function: sd_faultinjection()
30385 *
30386 * Description: This routine takes the pkt and changes its
30387 * content based on error injection scenerio.
30388 *
30389 * Arguments: pktp - packet to be changed
30390 */
30391
30392 static void
30393 sd_faultinjection(struct scsi_pkt *pktp)
30394 {
30395 uint_t i;
30396 struct sd_fi_pkt *fi_pkt;
30397 struct sd_fi_xb *fi_xb;
30398 struct sd_fi_un *fi_un;
30399 struct sd_fi_arq *fi_arq;
30400 struct buf *bp;
30401 struct sd_xbuf *xb;
30402 struct sd_lun *un;
30403
30404 ASSERT(pktp != NULL);
30405
30406 /* pull bp xb and un from pktp */
30407 bp = (struct buf *)pktp->pkt_private;
30408 xb = SD_GET_XBUF(bp);
30409 un = SD_GET_UN(bp);
30410
30411 ASSERT(un != NULL);
30412
30413 mutex_enter(SD_MUTEX(un));
30414
30415 SD_TRACE(SD_LOG_SDTEST, un,
30416 "sd_faultinjection: entry Injection from sdintr\n");
30417
30418 /* if injection is off return */
30419 if (sd_fault_injection_on == 0 ||
30420 un->sd_fi_fifo_start == un->sd_fi_fifo_end) {
30421 mutex_exit(SD_MUTEX(un));
30422 return;
30423 }
30424
30425 SD_INFO(SD_LOG_SDTEST, un,
30426 "sd_faultinjection: is working for copying\n");
30427
30428 /* take next set off fifo */
30429 i = un->sd_fi_fifo_start % SD_FI_MAX_ERROR;
30430
30431 fi_pkt = un->sd_fi_fifo_pkt[i];
30432 fi_xb = un->sd_fi_fifo_xb[i];
30433 fi_un = un->sd_fi_fifo_un[i];
30434 fi_arq = un->sd_fi_fifo_arq[i];
30435
30436
30437 /* set variables accordingly */
30438 /* set pkt if it was on fifo */
30439 if (fi_pkt != NULL) {
30440 SD_CONDSET(pktp, pkt, pkt_flags, "pkt_flags");
30441 SD_CONDSET(*pktp, pkt, pkt_scbp, "pkt_scbp");
30442 if (fi_pkt->pkt_cdbp != 0xff)
30443 SD_CONDSET(*pktp, pkt, pkt_cdbp, "pkt_cdbp");
30444 SD_CONDSET(pktp, pkt, pkt_state, "pkt_state");
30445 SD_CONDSET(pktp, pkt, pkt_statistics, "pkt_statistics");
30446 SD_CONDSET(pktp, pkt, pkt_reason, "pkt_reason");
30447
30448 }
30449 /* set xb if it was on fifo */
30450 if (fi_xb != NULL) {
30451 SD_CONDSET(xb, xb, xb_blkno, "xb_blkno");
30452 SD_CONDSET(xb, xb, xb_dma_resid, "xb_dma_resid");
30453 if (fi_xb->xb_retry_count != 0)
30454 SD_CONDSET(xb, xb, xb_retry_count, "xb_retry_count");
30455 SD_CONDSET(xb, xb, xb_victim_retry_count,
30456 "xb_victim_retry_count");
30457 SD_CONDSET(xb, xb, xb_sense_status, "xb_sense_status");
30458 SD_CONDSET(xb, xb, xb_sense_state, "xb_sense_state");
30459 SD_CONDSET(xb, xb, xb_sense_resid, "xb_sense_resid");
30460
30461 /* copy in block data from sense */
30462 /*
30463 * if (fi_xb->xb_sense_data[0] != -1) {
30464 * bcopy(fi_xb->xb_sense_data, xb->xb_sense_data,
30465 * SENSE_LENGTH);
30466 * }
30467 */
30468 bcopy(fi_xb->xb_sense_data, xb->xb_sense_data, SENSE_LENGTH);
30469
30470 /* copy in extended sense codes */
30471 SD_CONDSET(((struct scsi_extended_sense *)xb->xb_sense_data),
30472 xb, es_code, "es_code");
30473 SD_CONDSET(((struct scsi_extended_sense *)xb->xb_sense_data),
30474 xb, es_key, "es_key");
30475 SD_CONDSET(((struct scsi_extended_sense *)xb->xb_sense_data),
30476 xb, es_add_code, "es_add_code");
30477 SD_CONDSET(((struct scsi_extended_sense *)xb->xb_sense_data),
30478 xb, es_qual_code, "es_qual_code");
30479 struct scsi_extended_sense *esp;
30480 esp = (struct scsi_extended_sense *)xb->xb_sense_data;
30481 esp->es_class = CLASS_EXTENDED_SENSE;
30482 }
30483
30484 /* set un if it was on fifo */
30485 if (fi_un != NULL) {
30486 SD_CONDSET(un->un_sd->sd_inq, un, inq_rmb, "inq_rmb");
30487 SD_CONDSET(un, un, un_ctype, "un_ctype");
30488 SD_CONDSET(un, un, un_reset_retry_count,
30489 "un_reset_retry_count");
30490 SD_CONDSET(un, un, un_reservation_type, "un_reservation_type");
30491 SD_CONDSET(un, un, un_resvd_status, "un_resvd_status");
30492 SD_CONDSET(un, un, un_f_arq_enabled, "un_f_arq_enabled");
30493 SD_CONDSET(un, un, un_f_allow_bus_device_reset,
30494 "un_f_allow_bus_device_reset");
30495 SD_CONDSET(un, un, un_f_opt_queueing, "un_f_opt_queueing");
30496
30497 }
30498
30499 /* copy in auto request sense if it was on fifo */
30500 if (fi_arq != NULL) {
30501 bcopy(fi_arq, pktp->pkt_scbp, sizeof (struct sd_fi_arq));
30502 }
30503
30504 /* free structs */
30505 if (un->sd_fi_fifo_pkt[i] != NULL) {
30506 kmem_free(un->sd_fi_fifo_pkt[i], sizeof (struct sd_fi_pkt));
30507 }
30508 if (un->sd_fi_fifo_xb[i] != NULL) {
30509 kmem_free(un->sd_fi_fifo_xb[i], sizeof (struct sd_fi_xb));
30510 }
30511 if (un->sd_fi_fifo_un[i] != NULL) {
30512 kmem_free(un->sd_fi_fifo_un[i], sizeof (struct sd_fi_un));
30513 }
30514 if (un->sd_fi_fifo_arq[i] != NULL) {
30515 kmem_free(un->sd_fi_fifo_arq[i], sizeof (struct sd_fi_arq));
30516 }
30517
30518 /*
30519 * kmem_free does not gurantee to set to NULL
30520 * since we uses these to determine if we set
30521 * values or not lets confirm they are always
30522 * NULL after free
30523 */
30524 un->sd_fi_fifo_pkt[i] = NULL;
30525 un->sd_fi_fifo_un[i] = NULL;
30526 un->sd_fi_fifo_xb[i] = NULL;
30527 un->sd_fi_fifo_arq[i] = NULL;
30528
30529 un->sd_fi_fifo_start++;
30530
30531 mutex_exit(SD_MUTEX(un));
30532
30533 SD_INFO(SD_LOG_SDTEST, un, "sd_faultinjection: exit\n");
30534 }
30535
30536 #endif /* SD_FAULT_INJECTION */
30537
30538 /*
30539 * This routine is invoked in sd_unit_attach(). Before calling it, the
30540 * properties in conf file should be processed already, and "hotpluggable"
30541 * property was processed also.
30542 *
30543 * The sd driver distinguishes 3 different type of devices: removable media,
30544 * non-removable media, and hotpluggable. Below the differences are defined:
30545 *
30546 * 1. Device ID
30547 *
30548 * The device ID of a device is used to identify this device. Refer to
30549 * ddi_devid_register(9F).
30550 *
30551 * For a non-removable media disk device which can provide 0x80 or 0x83
30552 * VPD page (refer to INQUIRY command of SCSI SPC specification), a unique
30553 * device ID is created to identify this device. For other non-removable
30554 * media devices, a default device ID is created only if this device has
30555 * at least 2 alter cylinders. Otherwise, this device has no devid.
30556 *
30557 * -------------------------------------------------------
30558 * removable media hotpluggable | Can Have Device ID
30559 * -------------------------------------------------------
30560 * false false | Yes
30561 * false true | Yes
30562 * true x | No
30563 * ------------------------------------------------------
30564 *
30565 *
30566 * 2. SCSI group 4 commands
30567 *
30568 * In SCSI specs, only some commands in group 4 command set can use
30569 * 8-byte addresses that can be used to access >2TB storage spaces.
30570 * Other commands have no such capability. Without supporting group4,
30571 * it is impossible to make full use of storage spaces of a disk with
30572 * capacity larger than 2TB.
30573 *
30574 * -----------------------------------------------
30575 * removable media hotpluggable LP64 | Group
30576 * -----------------------------------------------
30577 * false false false | 1
30578 * false false true | 4
30579 * false true false | 1
30580 * false true true | 4
30581 * true x x | 5
30582 * -----------------------------------------------
30583 *
30584 *
30585 * 3. Check for VTOC Label
30586 *
30587 * If a direct-access disk has no EFI label, sd will check if it has a
30588 * valid VTOC label. Now, sd also does that check for removable media
30589 * and hotpluggable devices.
30590 *
30591 * --------------------------------------------------------------
30592 * Direct-Access removable media hotpluggable | Check Label
30593 * -------------------------------------------------------------
30594 * false false false | No
30595 * false false true | No
30596 * false true false | Yes
30597 * false true true | Yes
30598 * true x x | Yes
30599 * --------------------------------------------------------------
30600 *
30601 *
30602 * 4. Building default VTOC label
30603 *
30604 * As section 3 says, sd checks if some kinds of devices have VTOC label.
30605 * If those devices have no valid VTOC label, sd(7d) will attempt to
30606 * create default VTOC for them. Currently sd creates default VTOC label
30607 * for all devices on x86 platform (VTOC_16), but only for removable
30608 * media devices on SPARC (VTOC_8).
30609 *
30610 * -----------------------------------------------------------
30611 * removable media hotpluggable platform | Default Label
30612 * -----------------------------------------------------------
30613 * false false sparc | No
30614 * false true x86 | Yes
30615 * false true sparc | Yes
30616 * true x x | Yes
30617 * ----------------------------------------------------------
30618 *
30619 *
30620 * 5. Supported blocksizes of target devices
30621 *
30622 * Sd supports non-512-byte blocksize for removable media devices only.
30623 * For other devices, only 512-byte blocksize is supported. This may be
30624 * changed in near future because some RAID devices require non-512-byte
30625 * blocksize
30626 *
30627 * -----------------------------------------------------------
30628 * removable media hotpluggable | non-512-byte blocksize
30629 * -----------------------------------------------------------
30630 * false false | No
30631 * false true | No
30632 * true x | Yes
30633 * -----------------------------------------------------------
30634 *
30635 *
30636 * 6. Automatic mount & unmount
30637 *
30638 * Sd(7d) driver provides DKIOCREMOVABLE ioctl. This ioctl is used to query
30639 * if a device is removable media device. It return 1 for removable media
30640 * devices, and 0 for others.
30641 *
30642 * The automatic mounting subsystem should distinguish between the types
30643 * of devices and apply automounting policies to each.
30644 *
30645 *
30646 * 7. fdisk partition management
30647 *
30648 * Fdisk is traditional partition method on x86 platform. Sd(7d) driver
30649 * just supports fdisk partitions on x86 platform. On sparc platform, sd
30650 * doesn't support fdisk partitions at all. Note: pcfs(7fs) can recognize
30651 * fdisk partitions on both x86 and SPARC platform.
30652 *
30653 * -----------------------------------------------------------
30654 * platform removable media USB/1394 | fdisk supported
30655 * -----------------------------------------------------------
30656 * x86 X X | true
30657 * ------------------------------------------------------------
30658 * sparc X X | false
30659 * ------------------------------------------------------------
30660 *
30661 *
30662 * 8. MBOOT/MBR
30663 *
30664 * Although sd(7d) doesn't support fdisk on SPARC platform, it does support
30665 * read/write mboot for removable media devices on sparc platform.
30666 *
30667 * -----------------------------------------------------------
30668 * platform removable media USB/1394 | mboot supported
30669 * -----------------------------------------------------------
30670 * x86 X X | true
30671 * ------------------------------------------------------------
30672 * sparc false false | false
30673 * sparc false true | true
30674 * sparc true false | true
30675 * sparc true true | true
30676 * ------------------------------------------------------------
30677 *
30678 *
30679 * 9. error handling during opening device
30680 *
30681 * If failed to open a disk device, an errno is returned. For some kinds
30682 * of errors, different errno is returned depending on if this device is
30683 * a removable media device. This brings USB/1394 hard disks in line with
30684 * expected hard disk behavior. It is not expected that this breaks any
30685 * application.
30686 *
30687 * ------------------------------------------------------
30688 * removable media hotpluggable | errno
30689 * ------------------------------------------------------
30690 * false false | EIO
30691 * false true | EIO
30692 * true x | ENXIO
30693 * ------------------------------------------------------
30694 *
30695 *
30696 * 11. ioctls: DKIOCEJECT, CDROMEJECT
30697 *
30698 * These IOCTLs are applicable only to removable media devices.
30699 *
30700 * -----------------------------------------------------------
30701 * removable media hotpluggable |DKIOCEJECT, CDROMEJECT
30702 * -----------------------------------------------------------
30703 * false false | No
30704 * false true | No
30705 * true x | Yes
30706 * -----------------------------------------------------------
30707 *
30708 *
30709 * 12. Kstats for partitions
30710 *
30711 * sd creates partition kstat for non-removable media devices. USB and
30712 * Firewire hard disks now have partition kstats
30713 *
30714 * ------------------------------------------------------
30715 * removable media hotpluggable | kstat
30716 * ------------------------------------------------------
30717 * false false | Yes
30718 * false true | Yes
30719 * true x | No
30720 * ------------------------------------------------------
30721 *
30722 *
30723 * 13. Removable media & hotpluggable properties
30724 *
30725 * Sd driver creates a "removable-media" property for removable media
30726 * devices. Parent nexus drivers create a "hotpluggable" property if
30727 * it supports hotplugging.
30728 *
30729 * ---------------------------------------------------------------------
30730 * removable media hotpluggable | "removable-media" " hotpluggable"
30731 * ---------------------------------------------------------------------
30732 * false false | No No
30733 * false true | No Yes
30734 * true false | Yes No
30735 * true true | Yes Yes
30736 * ---------------------------------------------------------------------
30737 *
30738 *
30739 * 14. Power Management
30740 *
30741 * sd only power manages removable media devices or devices that support
30742 * LOG_SENSE or have a "pm-capable" property (PSARC/2002/250)
30743 *
30744 * A parent nexus that supports hotplugging can also set "pm-capable"
30745 * if the disk can be power managed.
30746 *
30747 * ------------------------------------------------------------
30748 * removable media hotpluggable pm-capable | power manage
30749 * ------------------------------------------------------------
30750 * false false false | No
30751 * false false true | Yes
30752 * false true false | No
30753 * false true true | Yes
30754 * true x x | Yes
30755 * ------------------------------------------------------------
30756 *
30757 * USB and firewire hard disks can now be power managed independently
30758 * of the framebuffer
30759 *
30760 *
30761 * 15. Support for USB disks with capacity larger than 1TB
30762 *
30763 * Currently, sd doesn't permit a fixed disk device with capacity
30764 * larger than 1TB to be used in a 32-bit operating system environment.
30765 * However, sd doesn't do that for removable media devices. Instead, it
30766 * assumes that removable media devices cannot have a capacity larger
30767 * than 1TB. Therefore, using those devices on 32-bit system is partially
30768 * supported, which can cause some unexpected results.
30769 *
30770 * ---------------------------------------------------------------------
30771 * removable media USB/1394 | Capacity > 1TB | Used in 32-bit env
30772 * ---------------------------------------------------------------------
30773 * false false | true | no
30774 * false true | true | no
30775 * true false | true | Yes
30776 * true true | true | Yes
30777 * ---------------------------------------------------------------------
30778 *
30779 *
30780 * 16. Check write-protection at open time
30781 *
30782 * When a removable media device is being opened for writing without NDELAY
30783 * flag, sd will check if this device is writable. If attempting to open
30784 * without NDELAY flag a write-protected device, this operation will abort.
30785 *
30786 * ------------------------------------------------------------
30787 * removable media USB/1394 | WP Check
30788 * ------------------------------------------------------------
30789 * false false | No
30790 * false true | No
30791 * true false | Yes
30792 * true true | Yes
30793 * ------------------------------------------------------------
30794 *
30795 *
30796 * 17. syslog when corrupted VTOC is encountered
30797 *
30798 * Currently, if an invalid VTOC is encountered, sd only print syslog
30799 * for fixed SCSI disks.
30800 * ------------------------------------------------------------
30801 * removable media USB/1394 | print syslog
30802 * ------------------------------------------------------------
30803 * false false | Yes
30804 * false true | No
30805 * true false | No
30806 * true true | No
30807 * ------------------------------------------------------------
30808 */
30809 static void
30810 sd_set_unit_attributes(struct sd_lun *un, dev_info_t *devi)
30811 {
30812 int pm_cap;
30813
30814 ASSERT(un->un_sd);
30815 ASSERT(un->un_sd->sd_inq);
30816
30817 /*
30818 * Enable SYNC CACHE support for all devices.
30819 */
30820 un->un_f_sync_cache_supported = TRUE;
30821
30822 /*
30823 * Set the sync cache required flag to false.
30824 * This would ensure that there is no SYNC CACHE
30825 * sent when there are no writes
30826 */
30827 un->un_f_sync_cache_required = FALSE;
30828
30829 if (un->un_sd->sd_inq->inq_rmb) {
30830 /*
30831 * The media of this device is removable. And for this kind
30832 * of devices, it is possible to change medium after opening
30833 * devices. Thus we should support this operation.
30834 */
30835 un->un_f_has_removable_media = TRUE;
30836
30837 /*
30838 * support non-512-byte blocksize of removable media devices
30839 */
30840 un->un_f_non_devbsize_supported = TRUE;
30841
30842 /*
30843 * Assume that all removable media devices support DOOR_LOCK
30844 */
30845 un->un_f_doorlock_supported = TRUE;
30846
30847 /*
30848 * For a removable media device, it is possible to be opened
30849 * with NDELAY flag when there is no media in drive, in this
30850 * case we don't care if device is writable. But if without
30851 * NDELAY flag, we need to check if media is write-protected.
30852 */
30853 un->un_f_chk_wp_open = TRUE;
30854
30855 /*
30856 * need to start a SCSI watch thread to monitor media state,
30857 * when media is being inserted or ejected, notify syseventd.
30858 */
30859 un->un_f_monitor_media_state = TRUE;
30860
30861 /*
30862 * Some devices don't support START_STOP_UNIT command.
30863 * Therefore, we'd better check if a device supports it
30864 * before sending it.
30865 */
30866 un->un_f_check_start_stop = TRUE;
30867
30868 /*
30869 * support eject media ioctl:
30870 * FDEJECT, DKIOCEJECT, CDROMEJECT
30871 */
30872 un->un_f_eject_media_supported = TRUE;
30873
30874 /*
30875 * Because many removable-media devices don't support
30876 * LOG_SENSE, we couldn't use this command to check if
30877 * a removable media device support power-management.
30878 * We assume that they support power-management via
30879 * START_STOP_UNIT command and can be spun up and down
30880 * without limitations.
30881 */
30882 un->un_f_pm_supported = TRUE;
30883
30884 /*
30885 * Need to create a zero length (Boolean) property
30886 * removable-media for the removable media devices.
30887 * Note that the return value of the property is not being
30888 * checked, since if unable to create the property
30889 * then do not want the attach to fail altogether. Consistent
30890 * with other property creation in attach.
30891 */
30892 (void) ddi_prop_create(DDI_DEV_T_NONE, devi,
30893 DDI_PROP_CANSLEEP, "removable-media", NULL, 0);
30894
30895 } else {
30896 /*
30897 * create device ID for device
30898 */
30899 un->un_f_devid_supported = TRUE;
30900
30901 /*
30902 * Spin up non-removable-media devices once it is attached
30903 */
30904 un->un_f_attach_spinup = TRUE;
30905
30906 /*
30907 * According to SCSI specification, Sense data has two kinds of
30908 * format: fixed format, and descriptor format. At present, we
30909 * don't support descriptor format sense data for removable
30910 * media.
30911 */
30912 if (SD_INQUIRY(un)->inq_dtype == DTYPE_DIRECT) {
30913 un->un_f_descr_format_supported = TRUE;
30914 }
30915
30916 /*
30917 * kstats are created only for non-removable media devices.
30918 *
30919 * Set this in sd.conf to 0 in order to disable kstats. The
30920 * default is 1, so they are enabled by default.
30921 */
30922 un->un_f_pkstats_enabled = (ddi_prop_get_int(DDI_DEV_T_ANY,
30923 SD_DEVINFO(un), DDI_PROP_DONTPASS,
30924 "enable-partition-kstats", 1));
30925
30926 /*
30927 * Check if HBA has set the "pm-capable" property.
30928 * If "pm-capable" exists and is non-zero then we can
30929 * power manage the device without checking the start/stop
30930 * cycle count log sense page.
30931 *
30932 * If "pm-capable" exists and is set to be false (0),
30933 * then we should not power manage the device.
30934 *
30935 * If "pm-capable" doesn't exist then pm_cap will
30936 * be set to SD_PM_CAPABLE_UNDEFINED (-1). In this case,
30937 * sd will check the start/stop cycle count log sense page
30938 * and power manage the device if the cycle count limit has
30939 * not been exceeded.
30940 */
30941 pm_cap = ddi_prop_get_int(DDI_DEV_T_ANY, devi,
30942 DDI_PROP_DONTPASS, "pm-capable", SD_PM_CAPABLE_UNDEFINED);
30943 if (SD_PM_CAPABLE_IS_UNDEFINED(pm_cap)) {
30944 un->un_f_log_sense_supported = TRUE;
30945 if (!un->un_f_power_condition_disabled &&
30946 SD_INQUIRY(un)->inq_ansi == 6) {
30947 un->un_f_power_condition_supported = TRUE;
30948 }
30949 } else {
30950 /*
30951 * pm-capable property exists.
30952 *
30953 * Convert "TRUE" values for pm_cap to
30954 * SD_PM_CAPABLE_IS_TRUE to make it easier to check
30955 * later. "TRUE" values are any values defined in
30956 * inquiry.h.
30957 */
30958 if (SD_PM_CAPABLE_IS_FALSE(pm_cap)) {
30959 un->un_f_log_sense_supported = FALSE;
30960 } else {
30961 /* SD_PM_CAPABLE_IS_TRUE case */
30962 un->un_f_pm_supported = TRUE;
30963 if (!un->un_f_power_condition_disabled &&
30964 SD_PM_CAPABLE_IS_SPC_4(pm_cap)) {
30965 un->un_f_power_condition_supported =
30966 TRUE;
30967 }
30968 if (SD_PM_CAP_LOG_SUPPORTED(pm_cap)) {
30969 un->un_f_log_sense_supported = TRUE;
30970 un->un_f_pm_log_sense_smart =
30971 SD_PM_CAP_SMART_LOG(pm_cap);
30972 }
30973 }
30974
30975 SD_INFO(SD_LOG_ATTACH_DETACH, un,
30976 "sd_unit_attach: un:0x%p pm-capable "
30977 "property set to %d.\n", un, un->un_f_pm_supported);
30978 }
30979 }
30980
30981 if (un->un_f_is_hotpluggable) {
30982
30983 /*
30984 * Have to watch hotpluggable devices as well, since
30985 * that's the only way for userland applications to
30986 * detect hot removal while device is busy/mounted.
30987 */
30988 un->un_f_monitor_media_state = TRUE;
30989
30990 un->un_f_check_start_stop = TRUE;
30991
30992 }
30993 }
30994
30995 /*
30996 * sd_tg_rdwr:
30997 * Provides rdwr access for cmlb via sd_tgops. The start_block is
30998 * in sys block size, req_length in bytes.
30999 *
31000 */
31001 static int
31002 sd_tg_rdwr(dev_info_t *devi, uchar_t cmd, void *bufaddr,
31003 diskaddr_t start_block, size_t reqlength, void *tg_cookie)
31004 {
31005 struct sd_lun *un;
31006 int path_flag = (int)(uintptr_t)tg_cookie;
31007 char *dkl = NULL;
31008 diskaddr_t real_addr = start_block;
31009 diskaddr_t first_byte, end_block;
31010
31011 size_t buffer_size = reqlength;
31012 int rval = 0;
31013 diskaddr_t cap;
31014 uint32_t lbasize;
31015 sd_ssc_t *ssc;
31016
31017 un = ddi_get_soft_state(sd_state, ddi_get_instance(devi));
31018 if (un == NULL)
31019 return (ENXIO);
31020
31021 if (cmd != TG_READ && cmd != TG_WRITE)
31022 return (EINVAL);
31023
31024 ssc = sd_ssc_init(un);
31025 mutex_enter(SD_MUTEX(un));
31026 if (un->un_f_tgt_blocksize_is_valid == FALSE) {
31027 mutex_exit(SD_MUTEX(un));
31028 rval = sd_send_scsi_READ_CAPACITY(ssc, (uint64_t *)&cap,
31029 &lbasize, path_flag);
31030 if (rval != 0)
31031 goto done1;
31032 mutex_enter(SD_MUTEX(un));
31033 sd_update_block_info(un, lbasize, cap);
31034 if ((un->un_f_tgt_blocksize_is_valid == FALSE)) {
31035 mutex_exit(SD_MUTEX(un));
31036 rval = EIO;
31037 goto done;
31038 }
31039 }
31040
31041 if (NOT_DEVBSIZE(un)) {
31042 /*
31043 * sys_blocksize != tgt_blocksize, need to re-adjust
31044 * blkno and save the index to beginning of dk_label
31045 */
31046 first_byte = SD_SYSBLOCKS2BYTES(start_block);
31047 real_addr = first_byte / un->un_tgt_blocksize;
31048
31049 end_block = (first_byte + reqlength +
31050 un->un_tgt_blocksize - 1) / un->un_tgt_blocksize;
31051
31052 /* round up buffer size to multiple of target block size */
31053 buffer_size = (end_block - real_addr) * un->un_tgt_blocksize;
31054
31055 SD_TRACE(SD_LOG_IO_PARTITION, un, "sd_tg_rdwr",
31056 "label_addr: 0x%x allocation size: 0x%x\n",
31057 real_addr, buffer_size);
31058
31059 if (((first_byte % un->un_tgt_blocksize) != 0) ||
31060 (reqlength % un->un_tgt_blocksize) != 0)
31061 /* the request is not aligned */
31062 dkl = kmem_zalloc(buffer_size, KM_SLEEP);
31063 }
31064
31065 /*
31066 * The MMC standard allows READ CAPACITY to be
31067 * inaccurate by a bounded amount (in the interest of
31068 * response latency). As a result, failed READs are
31069 * commonplace (due to the reading of metadata and not
31070 * data). Depending on the per-Vendor/drive Sense data,
31071 * the failed READ can cause many (unnecessary) retries.
31072 */
31073
31074 if (ISCD(un) && (cmd == TG_READ) &&
31075 (un->un_f_blockcount_is_valid == TRUE) &&
31076 ((start_block == (un->un_blockcount - 1))||
31077 (start_block == (un->un_blockcount - 2)))) {
31078 path_flag = SD_PATH_DIRECT_PRIORITY;
31079 }
31080
31081 mutex_exit(SD_MUTEX(un));
31082 if (cmd == TG_READ) {
31083 rval = sd_send_scsi_READ(ssc, (dkl != NULL)? dkl: bufaddr,
31084 buffer_size, real_addr, path_flag);
31085 if (dkl != NULL)
31086 bcopy(dkl + SD_TGTBYTEOFFSET(un, start_block,
31087 real_addr), bufaddr, reqlength);
31088 } else {
31089 if (dkl) {
31090 rval = sd_send_scsi_READ(ssc, dkl, buffer_size,
31091 real_addr, path_flag);
31092 if (rval) {
31093 goto done1;
31094 }
31095 bcopy(bufaddr, dkl + SD_TGTBYTEOFFSET(un, start_block,
31096 real_addr), reqlength);
31097 }
31098 rval = sd_send_scsi_WRITE(ssc, (dkl != NULL)? dkl: bufaddr,
31099 buffer_size, real_addr, path_flag);
31100 }
31101
31102 done1:
31103 if (dkl != NULL)
31104 kmem_free(dkl, buffer_size);
31105
31106 if (rval != 0) {
31107 if (rval == EIO)
31108 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
31109 else
31110 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
31111 }
31112 done:
31113 sd_ssc_fini(ssc);
31114 return (rval);
31115 }
31116
31117
31118 static int
31119 sd_tg_getinfo(dev_info_t *devi, int cmd, void *arg, void *tg_cookie)
31120 {
31121
31122 struct sd_lun *un;
31123 diskaddr_t cap;
31124 uint32_t lbasize;
31125 int path_flag = (int)(uintptr_t)tg_cookie;
31126 int ret = 0;
31127
31128 un = ddi_get_soft_state(sd_state, ddi_get_instance(devi));
31129 if (un == NULL)
31130 return (ENXIO);
31131
31132 switch (cmd) {
31133 case TG_GETPHYGEOM:
31134 case TG_GETVIRTGEOM:
31135 case TG_GETCAPACITY:
31136 case TG_GETBLOCKSIZE:
31137 mutex_enter(SD_MUTEX(un));
31138
31139 if ((un->un_f_blockcount_is_valid == TRUE) &&
31140 (un->un_f_tgt_blocksize_is_valid == TRUE)) {
31141 cap = un->un_blockcount;
31142 lbasize = un->un_tgt_blocksize;
31143 mutex_exit(SD_MUTEX(un));
31144 } else {
31145 sd_ssc_t *ssc;
31146 mutex_exit(SD_MUTEX(un));
31147 ssc = sd_ssc_init(un);
31148 ret = sd_send_scsi_READ_CAPACITY(ssc, (uint64_t *)&cap,
31149 &lbasize, path_flag);
31150 if (ret != 0) {
31151 if (ret == EIO)
31152 sd_ssc_assessment(ssc,
31153 SD_FMT_STATUS_CHECK);
31154 else
31155 sd_ssc_assessment(ssc,
31156 SD_FMT_IGNORE);
31157 sd_ssc_fini(ssc);
31158 return (ret);
31159 }
31160 sd_ssc_fini(ssc);
31161 mutex_enter(SD_MUTEX(un));
31162 sd_update_block_info(un, lbasize, cap);
31163 if ((un->un_f_blockcount_is_valid == FALSE) ||
31164 (un->un_f_tgt_blocksize_is_valid == FALSE)) {
31165 mutex_exit(SD_MUTEX(un));
31166 return (EIO);
31167 }
31168 mutex_exit(SD_MUTEX(un));
31169 }
31170
31171 if (cmd == TG_GETCAPACITY) {
31172 *(diskaddr_t *)arg = cap;
31173 return (0);
31174 }
31175
31176 if (cmd == TG_GETBLOCKSIZE) {
31177 *(uint32_t *)arg = lbasize;
31178 return (0);
31179 }
31180
31181 if (cmd == TG_GETPHYGEOM)
31182 ret = sd_get_physical_geometry(un, (cmlb_geom_t *)arg,
31183 cap, lbasize, path_flag);
31184 else
31185 /* TG_GETVIRTGEOM */
31186 ret = sd_get_virtual_geometry(un,
31187 (cmlb_geom_t *)arg, cap, lbasize);
31188
31189 return (ret);
31190
31191 case TG_GETATTR:
31192 mutex_enter(SD_MUTEX(un));
31193 ((tg_attribute_t *)arg)->media_is_writable =
31194 un->un_f_mmc_writable_media;
31195 ((tg_attribute_t *)arg)->media_is_solid_state =
31196 un->un_f_is_solid_state;
31197 mutex_exit(SD_MUTEX(un));
31198 return (0);
31199 default:
31200 return (ENOTTY);
31201
31202 }
31203 }
31204
31205 /*
31206 * Function: sd_ssc_ereport_post
31207 *
31208 * Description: Will be called when SD driver need to post an ereport.
31209 *
31210 * Context: Kernel thread or interrupt context.
31211 */
31212
31213 #define DEVID_IF_KNOWN(d) "devid", DATA_TYPE_STRING, (d) ? (d) : "unknown"
31214
31215 static void
31216 sd_ssc_ereport_post(sd_ssc_t *ssc, enum sd_driver_assessment drv_assess)
31217 {
31218 int uscsi_path_instance = 0;
31219 uchar_t uscsi_pkt_reason;
31220 uint32_t uscsi_pkt_state;
31221 uint32_t uscsi_pkt_statistics;
31222 uint64_t uscsi_ena;
31223 uchar_t op_code;
31224 uint8_t *sensep;
31225 union scsi_cdb *cdbp;
31226 uint_t cdblen = 0;
31227 uint_t senlen = 0;
31228 struct sd_lun *un;
31229 dev_info_t *dip;
31230 char *devid;
31231 int ssc_invalid_flags = SSC_FLAGS_INVALID_PKT_REASON |
31232 SSC_FLAGS_INVALID_STATUS |
31233 SSC_FLAGS_INVALID_SENSE |
31234 SSC_FLAGS_INVALID_DATA;
31235 char assessment[16];
31236
31237 ASSERT(ssc != NULL);
31238 ASSERT(ssc->ssc_uscsi_cmd != NULL);
31239 ASSERT(ssc->ssc_uscsi_info != NULL);
31240
31241 un = ssc->ssc_un;
31242 ASSERT(un != NULL);
31243
31244 dip = un->un_sd->sd_dev;
31245
31246 /*
31247 * Get the devid:
31248 * devid will only be passed to non-transport error reports.
31249 */
31250 devid = DEVI(dip)->devi_devid_str;
31251
31252 /*
31253 * If we are syncing or dumping, the command will not be executed
31254 * so we bypass this situation.
31255 */
31256 if (ddi_in_panic() || (un->un_state == SD_STATE_SUSPENDED) ||
31257 (un->un_state == SD_STATE_DUMPING))
31258 return;
31259
31260 uscsi_pkt_reason = ssc->ssc_uscsi_info->ui_pkt_reason;
31261 uscsi_path_instance = ssc->ssc_uscsi_cmd->uscsi_path_instance;
31262 uscsi_pkt_state = ssc->ssc_uscsi_info->ui_pkt_state;
31263 uscsi_pkt_statistics = ssc->ssc_uscsi_info->ui_pkt_statistics;
31264 uscsi_ena = ssc->ssc_uscsi_info->ui_ena;
31265
31266 sensep = (uint8_t *)ssc->ssc_uscsi_cmd->uscsi_rqbuf;
31267 cdbp = (union scsi_cdb *)ssc->ssc_uscsi_cmd->uscsi_cdb;
31268
31269 /* In rare cases, EG:DOORLOCK, the cdb could be NULL */
31270 if (cdbp == NULL) {
31271 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
31272 "sd_ssc_ereport_post meet empty cdb\n");
31273 return;
31274 }
31275
31276 op_code = cdbp->scc_cmd;
31277
31278 cdblen = (int)ssc->ssc_uscsi_cmd->uscsi_cdblen;
31279 senlen = (int)(ssc->ssc_uscsi_cmd->uscsi_rqlen -
31280 ssc->ssc_uscsi_cmd->uscsi_rqresid);
31281
31282 if (senlen > 0)
31283 ASSERT(sensep != NULL);
31284
31285 /*
31286 * Initialize drv_assess to corresponding values.
31287 * SD_FM_DRV_FATAL will be mapped to "fail" or "fatal" depending
31288 * on the sense-key returned back.
31289 */
31290 switch (drv_assess) {
31291 case SD_FM_DRV_RECOVERY:
31292 (void) sprintf(assessment, "%s", "recovered");
31293 break;
31294 case SD_FM_DRV_RETRY:
31295 (void) sprintf(assessment, "%s", "retry");
31296 break;
31297 case SD_FM_DRV_NOTICE:
31298 (void) sprintf(assessment, "%s", "info");
31299 break;
31300 case SD_FM_DRV_FATAL:
31301 default:
31302 (void) sprintf(assessment, "%s", "unknown");
31303 }
31304 /*
31305 * If drv_assess == SD_FM_DRV_RECOVERY, this should be a recovered
31306 * command, we will post ereport.io.scsi.cmd.disk.recovered.
31307 * driver-assessment will always be "recovered" here.
31308 */
31309 if (drv_assess == SD_FM_DRV_RECOVERY) {
31310 scsi_fm_ereport_post(un->un_sd, uscsi_path_instance, NULL,
31311 "cmd.disk.recovered", uscsi_ena, devid, NULL,
31312 DDI_NOSLEEP, NULL,
31313 FM_VERSION, DATA_TYPE_UINT8, FM_EREPORT_VERS0,
31314 DEVID_IF_KNOWN(devid),
31315 "driver-assessment", DATA_TYPE_STRING, assessment,
31316 "op-code", DATA_TYPE_UINT8, op_code,
31317 "cdb", DATA_TYPE_UINT8_ARRAY,
31318 cdblen, ssc->ssc_uscsi_cmd->uscsi_cdb,
31319 "pkt-reason", DATA_TYPE_UINT8, uscsi_pkt_reason,
31320 "pkt-state", DATA_TYPE_UINT32, uscsi_pkt_state,
31321 "pkt-stats", DATA_TYPE_UINT32, uscsi_pkt_statistics,
31322 NULL);
31323 return;
31324 }
31325
31326 /*
31327 * If there is un-expected/un-decodable data, we should post
31328 * ereport.io.scsi.cmd.disk.dev.uderr.
31329 * driver-assessment will be set based on parameter drv_assess.
31330 * SSC_FLAGS_INVALID_SENSE - invalid sense data sent back.
31331 * SSC_FLAGS_INVALID_PKT_REASON - invalid pkt-reason encountered.
31332 * SSC_FLAGS_INVALID_STATUS - invalid stat-code encountered.
31333 * SSC_FLAGS_INVALID_DATA - invalid data sent back.
31334 */
31335 if (ssc->ssc_flags & ssc_invalid_flags) {
31336 if (ssc->ssc_flags & SSC_FLAGS_INVALID_SENSE) {
31337 scsi_fm_ereport_post(un->un_sd, uscsi_path_instance,
31338 NULL, "cmd.disk.dev.uderr", uscsi_ena, devid,
31339 NULL, DDI_NOSLEEP, NULL,
31340 FM_VERSION, DATA_TYPE_UINT8, FM_EREPORT_VERS0,
31341 DEVID_IF_KNOWN(devid),
31342 "driver-assessment", DATA_TYPE_STRING,
31343 drv_assess == SD_FM_DRV_FATAL ?
31344 "fail" : assessment,
31345 "op-code", DATA_TYPE_UINT8, op_code,
31346 "cdb", DATA_TYPE_UINT8_ARRAY,
31347 cdblen, ssc->ssc_uscsi_cmd->uscsi_cdb,
31348 "pkt-reason", DATA_TYPE_UINT8, uscsi_pkt_reason,
31349 "pkt-state", DATA_TYPE_UINT32, uscsi_pkt_state,
31350 "pkt-stats", DATA_TYPE_UINT32,
31351 uscsi_pkt_statistics,
31352 "stat-code", DATA_TYPE_UINT8,
31353 ssc->ssc_uscsi_cmd->uscsi_status,
31354 "un-decode-info", DATA_TYPE_STRING,
31355 ssc->ssc_info,
31356 "un-decode-value", DATA_TYPE_UINT8_ARRAY,
31357 senlen, sensep,
31358 NULL);
31359 } else {
31360 /*
31361 * For other type of invalid data, the
31362 * un-decode-value field would be empty because the
31363 * un-decodable content could be seen from upper
31364 * level payload or inside un-decode-info.
31365 */
31366 scsi_fm_ereport_post(un->un_sd, uscsi_path_instance,
31367 NULL,
31368 "cmd.disk.dev.uderr", uscsi_ena, devid,
31369 NULL, DDI_NOSLEEP, NULL,
31370 FM_VERSION, DATA_TYPE_UINT8, FM_EREPORT_VERS0,
31371 DEVID_IF_KNOWN(devid),
31372 "driver-assessment", DATA_TYPE_STRING,
31373 drv_assess == SD_FM_DRV_FATAL ?
31374 "fail" : assessment,
31375 "op-code", DATA_TYPE_UINT8, op_code,
31376 "cdb", DATA_TYPE_UINT8_ARRAY,
31377 cdblen, ssc->ssc_uscsi_cmd->uscsi_cdb,
31378 "pkt-reason", DATA_TYPE_UINT8, uscsi_pkt_reason,
31379 "pkt-state", DATA_TYPE_UINT32, uscsi_pkt_state,
31380 "pkt-stats", DATA_TYPE_UINT32,
31381 uscsi_pkt_statistics,
31382 "stat-code", DATA_TYPE_UINT8,
31383 ssc->ssc_uscsi_cmd->uscsi_status,
31384 "un-decode-info", DATA_TYPE_STRING,
31385 ssc->ssc_info,
31386 "un-decode-value", DATA_TYPE_UINT8_ARRAY,
31387 0, NULL,
31388 NULL);
31389 }
31390 ssc->ssc_flags &= ~ssc_invalid_flags;
31391 return;
31392 }
31393
31394 if (uscsi_pkt_reason != CMD_CMPLT ||
31395 (ssc->ssc_flags & SSC_FLAGS_TRAN_ABORT)) {
31396 /*
31397 * pkt-reason != CMD_CMPLT or SSC_FLAGS_TRAN_ABORT was
31398 * set inside sd_start_cmds due to errors(bad packet or
31399 * fatal transport error), we should take it as a
31400 * transport error, so we post ereport.io.scsi.cmd.disk.tran.
31401 * driver-assessment will be set based on drv_assess.
31402 * We will set devid to NULL because it is a transport
31403 * error.
31404 */
31405 if (ssc->ssc_flags & SSC_FLAGS_TRAN_ABORT)
31406 ssc->ssc_flags &= ~SSC_FLAGS_TRAN_ABORT;
31407
31408 scsi_fm_ereport_post(un->un_sd, uscsi_path_instance, NULL,
31409 "cmd.disk.tran", uscsi_ena, NULL, NULL, DDI_NOSLEEP, NULL,
31410 FM_VERSION, DATA_TYPE_UINT8, FM_EREPORT_VERS0,
31411 DEVID_IF_KNOWN(devid),
31412 "driver-assessment", DATA_TYPE_STRING,
31413 drv_assess == SD_FM_DRV_FATAL ? "fail" : assessment,
31414 "op-code", DATA_TYPE_UINT8, op_code,
31415 "cdb", DATA_TYPE_UINT8_ARRAY,
31416 cdblen, ssc->ssc_uscsi_cmd->uscsi_cdb,
31417 "pkt-reason", DATA_TYPE_UINT8, uscsi_pkt_reason,
31418 "pkt-state", DATA_TYPE_UINT8, uscsi_pkt_state,
31419 "pkt-stats", DATA_TYPE_UINT32, uscsi_pkt_statistics,
31420 NULL);
31421 } else {
31422 /*
31423 * If we got here, we have a completed command, and we need
31424 * to further investigate the sense data to see what kind
31425 * of ereport we should post.
31426 * No ereport is needed if sense-key is KEY_RECOVERABLE_ERROR
31427 * and asc/ascq is "ATA PASS-THROUGH INFORMATION AVAILABLE".
31428 * Post ereport.io.scsi.cmd.disk.dev.rqs.merr if sense-key is
31429 * KEY_MEDIUM_ERROR.
31430 * Post ereport.io.scsi.cmd.disk.dev.rqs.derr otherwise.
31431 * driver-assessment will be set based on the parameter
31432 * drv_assess.
31433 */
31434 if (senlen > 0) {
31435 /*
31436 * Here we have sense data available.
31437 */
31438 uint8_t sense_key = scsi_sense_key(sensep);
31439 uint8_t sense_asc = scsi_sense_asc(sensep);
31440 uint8_t sense_ascq = scsi_sense_ascq(sensep);
31441
31442 if (sense_key == KEY_RECOVERABLE_ERROR &&
31443 sense_asc == 0x00 && sense_ascq == 0x1d)
31444 return;
31445
31446 if (sense_key == KEY_MEDIUM_ERROR) {
31447 /*
31448 * driver-assessment should be "fatal" if
31449 * drv_assess is SD_FM_DRV_FATAL.
31450 */
31451 scsi_fm_ereport_post(un->un_sd,
31452 uscsi_path_instance, NULL,
31453 "cmd.disk.dev.rqs.merr",
31454 uscsi_ena, devid, NULL, DDI_NOSLEEP, NULL,
31455 FM_VERSION, DATA_TYPE_UINT8,
31456 FM_EREPORT_VERS0,
31457 DEVID_IF_KNOWN(devid),
31458 "driver-assessment",
31459 DATA_TYPE_STRING,
31460 drv_assess == SD_FM_DRV_FATAL ?
31461 "fatal" : assessment,
31462 "op-code",
31463 DATA_TYPE_UINT8, op_code,
31464 "cdb",
31465 DATA_TYPE_UINT8_ARRAY, cdblen,
31466 ssc->ssc_uscsi_cmd->uscsi_cdb,
31467 "pkt-reason",
31468 DATA_TYPE_UINT8, uscsi_pkt_reason,
31469 "pkt-state",
31470 DATA_TYPE_UINT8, uscsi_pkt_state,
31471 "pkt-stats",
31472 DATA_TYPE_UINT32,
31473 uscsi_pkt_statistics,
31474 "stat-code",
31475 DATA_TYPE_UINT8,
31476 ssc->ssc_uscsi_cmd->uscsi_status,
31477 "key",
31478 DATA_TYPE_UINT8,
31479 scsi_sense_key(sensep),
31480 "asc",
31481 DATA_TYPE_UINT8,
31482 scsi_sense_asc(sensep),
31483 "ascq",
31484 DATA_TYPE_UINT8,
31485 scsi_sense_ascq(sensep),
31486 "sense-data",
31487 DATA_TYPE_UINT8_ARRAY,
31488 senlen, sensep,
31489 "lba",
31490 DATA_TYPE_UINT64,
31491 ssc->ssc_uscsi_info->ui_lba,
31492 NULL);
31493 } else {
31494 /*
31495 * if sense-key == 0x4(hardware
31496 * error), driver-assessment should
31497 * be "fatal" if drv_assess is
31498 * SD_FM_DRV_FATAL.
31499 */
31500 scsi_fm_ereport_post(un->un_sd,
31501 uscsi_path_instance, NULL,
31502 "cmd.disk.dev.rqs.derr",
31503 uscsi_ena, devid,
31504 NULL, DDI_NOSLEEP, NULL,
31505 FM_VERSION,
31506 DATA_TYPE_UINT8, FM_EREPORT_VERS0,
31507 DEVID_IF_KNOWN(devid),
31508 "driver-assessment",
31509 DATA_TYPE_STRING,
31510 drv_assess == SD_FM_DRV_FATAL ?
31511 (sense_key == 0x4 ?
31512 "fatal" : "fail") : assessment,
31513 "op-code",
31514 DATA_TYPE_UINT8, op_code,
31515 "cdb",
31516 DATA_TYPE_UINT8_ARRAY, cdblen,
31517 ssc->ssc_uscsi_cmd->uscsi_cdb,
31518 "pkt-reason",
31519 DATA_TYPE_UINT8, uscsi_pkt_reason,
31520 "pkt-state",
31521 DATA_TYPE_UINT8, uscsi_pkt_state,
31522 "pkt-stats",
31523 DATA_TYPE_UINT32,
31524 uscsi_pkt_statistics,
31525 "stat-code",
31526 DATA_TYPE_UINT8,
31527 ssc->ssc_uscsi_cmd->uscsi_status,
31528 "key",
31529 DATA_TYPE_UINT8,
31530 scsi_sense_key(sensep),
31531 "asc",
31532 DATA_TYPE_UINT8,
31533 scsi_sense_asc(sensep),
31534 "ascq",
31535 DATA_TYPE_UINT8,
31536 scsi_sense_ascq(sensep),
31537 "sense-data",
31538 DATA_TYPE_UINT8_ARRAY,
31539 senlen, sensep,
31540 NULL);
31541 }
31542 } else {
31543 /*
31544 * For stat_code == STATUS_GOOD, this is not a
31545 * hardware error.
31546 */
31547 if (ssc->ssc_uscsi_cmd->uscsi_status == STATUS_GOOD)
31548 return;
31549
31550 /*
31551 * Post ereport.io.scsi.cmd.disk.dev.serr if we got the
31552 * stat-code but with sense data unavailable.
31553 * driver-assessment will be set based on parameter
31554 * drv_assess.
31555 */
31556 scsi_fm_ereport_post(un->un_sd, uscsi_path_instance,
31557 NULL,
31558 "cmd.disk.dev.serr", uscsi_ena,
31559 devid, NULL, DDI_NOSLEEP, NULL,
31560 FM_VERSION, DATA_TYPE_UINT8, FM_EREPORT_VERS0,
31561 DEVID_IF_KNOWN(devid),
31562 "driver-assessment", DATA_TYPE_STRING,
31563 drv_assess == SD_FM_DRV_FATAL ? "fail" : assessment,
31564 "op-code", DATA_TYPE_UINT8, op_code,
31565 "cdb",
31566 DATA_TYPE_UINT8_ARRAY,
31567 cdblen, ssc->ssc_uscsi_cmd->uscsi_cdb,
31568 "pkt-reason",
31569 DATA_TYPE_UINT8, uscsi_pkt_reason,
31570 "pkt-state",
31571 DATA_TYPE_UINT8, uscsi_pkt_state,
31572 "pkt-stats",
31573 DATA_TYPE_UINT32, uscsi_pkt_statistics,
31574 "stat-code",
31575 DATA_TYPE_UINT8,
31576 ssc->ssc_uscsi_cmd->uscsi_status,
31577 NULL);
31578 }
31579 }
31580 }
31581
31582 /*
31583 * Function: sd_ssc_extract_info
31584 *
31585 * Description: Extract information available to help generate ereport.
31586 *
31587 * Context: Kernel thread or interrupt context.
31588 */
31589 static void
31590 sd_ssc_extract_info(sd_ssc_t *ssc, struct sd_lun *un, struct scsi_pkt *pktp,
31591 struct buf *bp, struct sd_xbuf *xp)
31592 {
31593 size_t senlen = 0;
31594 union scsi_cdb *cdbp;
31595 int path_instance;
31596 /*
31597 * Need scsi_cdb_size array to determine the cdb length.
31598 */
31599 extern uchar_t scsi_cdb_size[];
31600
31601 ASSERT(un != NULL);
31602 ASSERT(pktp != NULL);
31603 ASSERT(bp != NULL);
31604 ASSERT(xp != NULL);
31605 ASSERT(ssc != NULL);
31606 ASSERT(mutex_owned(SD_MUTEX(un)));
31607
31608 /*
31609 * Transfer the cdb buffer pointer here.
31610 */
31611 cdbp = (union scsi_cdb *)pktp->pkt_cdbp;
31612
31613 ssc->ssc_uscsi_cmd->uscsi_cdblen = scsi_cdb_size[GETGROUP(cdbp)];
31614 ssc->ssc_uscsi_cmd->uscsi_cdb = (caddr_t)cdbp;
31615
31616 /*
31617 * Transfer the sense data buffer pointer if sense data is available,
31618 * calculate the sense data length first.
31619 */
31620 if ((xp->xb_sense_state & STATE_XARQ_DONE) ||
31621 (xp->xb_sense_state & STATE_ARQ_DONE)) {
31622 /*
31623 * For arq case, we will enter here.
31624 */
31625 if (xp->xb_sense_state & STATE_XARQ_DONE) {
31626 senlen = MAX_SENSE_LENGTH - xp->xb_sense_resid;
31627 } else {
31628 senlen = SENSE_LENGTH;
31629 }
31630 } else {
31631 /*
31632 * For non-arq case, we will enter this branch.
31633 */
31634 if (SD_GET_PKT_STATUS(pktp) == STATUS_CHECK &&
31635 (xp->xb_sense_state & STATE_XFERRED_DATA)) {
31636 senlen = SENSE_LENGTH - xp->xb_sense_resid;
31637 }
31638
31639 }
31640
31641 ssc->ssc_uscsi_cmd->uscsi_rqlen = (senlen & 0xff);
31642 ssc->ssc_uscsi_cmd->uscsi_rqresid = 0;
31643 ssc->ssc_uscsi_cmd->uscsi_rqbuf = (caddr_t)xp->xb_sense_data;
31644
31645 ssc->ssc_uscsi_cmd->uscsi_status = ((*(pktp)->pkt_scbp) & STATUS_MASK);
31646
31647 /*
31648 * Only transfer path_instance when scsi_pkt was properly allocated.
31649 */
31650 path_instance = pktp->pkt_path_instance;
31651 if (scsi_pkt_allocated_correctly(pktp) && path_instance)
31652 ssc->ssc_uscsi_cmd->uscsi_path_instance = path_instance;
31653 else
31654 ssc->ssc_uscsi_cmd->uscsi_path_instance = 0;
31655
31656 /*
31657 * Copy in the other fields we may need when posting ereport.
31658 */
31659 ssc->ssc_uscsi_info->ui_pkt_reason = pktp->pkt_reason;
31660 ssc->ssc_uscsi_info->ui_pkt_state = pktp->pkt_state;
31661 ssc->ssc_uscsi_info->ui_pkt_statistics = pktp->pkt_statistics;
31662 ssc->ssc_uscsi_info->ui_lba = (uint64_t)SD_GET_BLKNO(bp);
31663
31664 /*
31665 * For partially read/write command, we will not create ena
31666 * in case of a successful command be reconized as recovered.
31667 */
31668 if ((pktp->pkt_reason == CMD_CMPLT) &&
31669 (ssc->ssc_uscsi_cmd->uscsi_status == STATUS_GOOD) &&
31670 (senlen == 0)) {
31671 return;
31672 }
31673
31674 /*
31675 * To associate ereports of a single command execution flow, we
31676 * need a shared ena for a specific command.
31677 */
31678 if (xp->xb_ena == 0)
31679 xp->xb_ena = fm_ena_generate(0, FM_ENA_FMT1);
31680 ssc->ssc_uscsi_info->ui_ena = xp->xb_ena;
31681 }
31682
31683
31684 /*
31685 * Function: sd_check_solid_state
31686 *
31687 * Description: Query the optional INQUIRY VPD page 0xb1. If the device
31688 * supports VPD page 0xb1, sd examines the MEDIUM ROTATION
31689 * RATE. If the MEDIUM ROTATION RATE is 1, sd assumes the
31690 * device is a solid state drive.
31691 *
31692 * Context: Kernel thread or interrupt context.
31693 */
31694
31695 static void
31696 sd_check_solid_state(sd_ssc_t *ssc)
31697 {
31698 int rval = 0;
31699 uchar_t *inqb1 = NULL;
31700 size_t inqb1_len = MAX_INQUIRY_SIZE;
31701 size_t inqb1_resid = 0;
31702 struct sd_lun *un;
31703
31704 ASSERT(ssc != NULL);
31705 un = ssc->ssc_un;
31706 ASSERT(un != NULL);
31707 ASSERT(!mutex_owned(SD_MUTEX(un)));
31708
31709 mutex_enter(SD_MUTEX(un));
31710 un->un_f_is_solid_state = FALSE;
31711
31712 if (ISCD(un)) {
31713 mutex_exit(SD_MUTEX(un));
31714 return;
31715 }
31716
31717 if (sd_check_vpd_page_support(ssc) == 0 &&
31718 un->un_vpd_page_mask & SD_VPD_DEV_CHARACTER_PG) {
31719 mutex_exit(SD_MUTEX(un));
31720 /* collect page b1 data */
31721 inqb1 = kmem_zalloc(inqb1_len, KM_SLEEP);
31722
31723 rval = sd_send_scsi_INQUIRY(ssc, inqb1, inqb1_len,
31724 0x01, 0xB1, &inqb1_resid);
31725
31726 if (rval == 0 && (inqb1_len - inqb1_resid > 5)) {
31727 SD_TRACE(SD_LOG_COMMON, un,
31728 "sd_check_solid_state: \
31729 successfully get VPD page: %x \
31730 PAGE LENGTH: %x BYTE 4: %x \
31731 BYTE 5: %x", inqb1[1], inqb1[3], inqb1[4],
31732 inqb1[5]);
31733
31734 mutex_enter(SD_MUTEX(un));
31735 /*
31736 * Check the MEDIUM ROTATION RATE. If it is set
31737 * to 1, the device is a solid state drive.
31738 */
31739 if (inqb1[4] == 0 && inqb1[5] == 1) {
31740 un->un_f_is_solid_state = TRUE;
31741 /* solid state drives don't need disksort */
31742 un->un_f_disksort_disabled = TRUE;
31743 }
31744 mutex_exit(SD_MUTEX(un));
31745 } else if (rval != 0) {
31746 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
31747 }
31748
31749 kmem_free(inqb1, inqb1_len);
31750 } else {
31751 mutex_exit(SD_MUTEX(un));
31752 }
31753 }
31754
31755 /*
31756 * Function: sd_check_emulation_mode
31757 *
31758 * Description: Check whether the SSD is at emulation mode
31759 * by issuing READ_CAPACITY_16 to see whether
31760 * we can get physical block size of the drive.
31761 *
31762 * Context: Kernel thread or interrupt context.
31763 */
31764
31765 static void
31766 sd_check_emulation_mode(sd_ssc_t *ssc)
31767 {
31768 int rval = 0;
31769 uint64_t capacity;
31770 uint_t lbasize;
31771 uint_t pbsize;
31772 int i;
31773 int devid_len;
31774 struct sd_lun *un;
31775
31776 ASSERT(ssc != NULL);
31777 un = ssc->ssc_un;
31778 ASSERT(un != NULL);
31779 ASSERT(!mutex_owned(SD_MUTEX(un)));
31780
31781 mutex_enter(SD_MUTEX(un));
31782 if (ISCD(un)) {
31783 mutex_exit(SD_MUTEX(un));
31784 return;
31785 }
31786
31787 if (un->un_f_descr_format_supported) {
31788 mutex_exit(SD_MUTEX(un));
31789 rval = sd_send_scsi_READ_CAPACITY_16(ssc, &capacity, &lbasize,
31790 &pbsize, SD_PATH_DIRECT);
31791 mutex_enter(SD_MUTEX(un));
31792
31793 if (rval != 0) {
31794 un->un_phy_blocksize = DEV_BSIZE;
31795 } else {
31796 if (!ISP2(pbsize % DEV_BSIZE) || pbsize == 0) {
31797 un->un_phy_blocksize = DEV_BSIZE;
31798 } else if (pbsize > un->un_phy_blocksize) {
31799 /*
31800 * Don't reset the physical blocksize
31801 * unless we've detected a larger value.
31802 */
31803 un->un_phy_blocksize = pbsize;
31804 }
31805 }
31806 }
31807
31808 for (i = 0; i < sd_flash_dev_table_size; i++) {
31809 devid_len = (int)strlen(sd_flash_dev_table[i]);
31810 if (sd_sdconf_id_match(un, sd_flash_dev_table[i], devid_len)
31811 == SD_SUCCESS) {
31812 un->un_phy_blocksize = SSD_SECSIZE;
31813 if (un->un_f_is_solid_state &&
31814 un->un_phy_blocksize != un->un_tgt_blocksize)
31815 un->un_f_enable_rmw = TRUE;
31816 }
31817 }
31818
31819 mutex_exit(SD_MUTEX(un));
31820 }