Lines Matching refs:un
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))
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); }
1159 static void sd_log_trace(uint_t comp, struct sd_lun *un, const char *fmt, ...);
1161 static void sd_log_info(uint_t comp, struct sd_lun *un, const char *fmt, ...);
1163 static void sd_log_err(uint_t comp, struct sd_lun *un, const char *fmt, ...);
1194 static sd_ssc_t *sd_ssc_init(struct sd_lun *un);
1214 * Using sd_ssc_set_info to mark an un-decodable-data error.
1220 static void sd_ssc_extract_info(sd_ssc_t *ssc, struct sd_lun *un,
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);
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,
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,
1245 static void sd_set_vers1_properties(struct sd_lun *un, int flags,
1253 static int sd_get_devid_page(struct sd_lun *un, uchar_t *wwn, int *len);
1257 static void sd_create_pm_components(dev_info_t *devi, struct sd_lun *un);
1261 static int sd_pm_state_change(struct sd_lun *un, int level, int flag);
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);
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);
1283 static void sd_init_event_callbacks(struct sd_lun *un);
1301 static void sd_update_block_info(struct sd_lun *un, uint32_t lbasize,
1323 static void sd_mapblockaddr_iostart(int index, struct sd_lun *un,
1325 static void sd_mapblocksize_iostart(int index, struct sd_lun *un,
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,
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);
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,
1340 static void sd_mapblocksize_iodone(int index, struct sd_lun *un,
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,
1345 static void sd_pm_iodone(int index, struct sd_lun *un, struct buf *bp);
1353 static int sd_setup_rw_pkt(struct sd_lun *un, struct scsi_pkt **pktpp,
1357 static int sd_setup_next_rw_pkt(struct sd_lun *un, struct scsi_pkt *pktp,
1367 static void sd_xbuf_init(struct sd_lun *un, struct buf *bp, struct sd_xbuf *xp,
1370 static int sd_pm_entry(struct sd_lun *un);
1371 static void sd_pm_exit(struct sd_lun *un);
1378 static void sd_add_buf_to_waitq(struct sd_lun *un, struct buf *bp);
1380 static void sd_start_cmds(struct sd_lun *un, struct buf *immed_bp);
1392 static void sd_print_transport_rejected_message(struct sd_lun *un,
1394 static void sd_print_incomplete_msg(struct sd_lun *un, struct buf *bp,
1396 static void sd_print_sense_failed_msg(struct sd_lun *un, struct buf *bp,
1398 static void sd_print_cmd_incomplete_msg(struct sd_lun *un, struct buf *bp,
1401 static void sd_retry_command(struct sd_lun *un, struct buf *bp,
1403 void (*user_funcp)(struct sd_lun *un, struct buf *bp, void *argp,
1408 static void sd_set_retry_bp(struct sd_lun *un, struct buf *bp,
1411 static void sd_send_request_sense_command(struct sd_lun *un, struct buf *bp,
1415 static void sd_return_failed_command(struct sd_lun *un, struct buf *bp,
1417 static void sd_return_failed_command_no_restart(struct sd_lun *un,
1419 static void sd_return_command(struct sd_lun *un, struct buf *bp);
1420 static void sd_sync_with_callback(struct sd_lun *un);
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);
1426 static void sd_reduce_throttle(struct sd_lun *un, int throttle_type);
1429 static void sd_init_cdb_limits(struct sd_lun *un);
1431 static void sd_pkt_status_good(struct sd_lun *un, struct buf *bp,
1437 static void sd_pkt_status_check_condition(struct sd_lun *un, struct buf *bp,
1439 static void sd_pkt_status_busy(struct sd_lun *un, struct buf *bp,
1441 static void sd_pkt_status_reservation_conflict(struct sd_lun *un,
1443 static void sd_pkt_status_qfull(struct sd_lun *un, struct buf *bp,
1446 static void sd_handle_request_sense(struct sd_lun *un, struct buf *bp,
1448 static void sd_handle_auto_request_sense(struct sd_lun *un, struct buf *bp,
1450 static int sd_validate_sense_data(struct sd_lun *un, struct buf *bp,
1452 static void sd_decode_sense(struct sd_lun *un, struct buf *bp,
1455 static void sd_print_sense_msg(struct sd_lun *un, struct buf *bp,
1458 static void sd_sense_key_no_sense(struct sd_lun *un, struct buf *bp,
1460 static void sd_sense_key_recoverable_error(struct sd_lun *un,
1463 static void sd_sense_key_not_ready(struct sd_lun *un,
1466 static void sd_sense_key_medium_or_hardware_error(struct sd_lun *un,
1469 static void sd_sense_key_illegal_request(struct sd_lun *un, struct buf *bp,
1471 static void sd_sense_key_unit_attention(struct sd_lun *un,
1474 static void sd_sense_key_fail_command(struct sd_lun *un, struct buf *bp,
1476 static void sd_sense_key_blank_check(struct sd_lun *un, struct buf *bp,
1478 static void sd_sense_key_aborted_command(struct sd_lun *un, struct buf *bp,
1480 static void sd_sense_key_default(struct sd_lun *un,
1484 static void sd_print_retry_msg(struct sd_lun *un, struct buf *bp,
1487 static void sd_pkt_reason_cmd_incomplete(struct sd_lun *un, struct buf *bp,
1489 static void sd_pkt_reason_cmd_tran_err(struct sd_lun *un, struct buf *bp,
1491 static void sd_pkt_reason_cmd_reset(struct sd_lun *un, struct buf *bp,
1493 static void sd_pkt_reason_cmd_aborted(struct sd_lun *un, struct buf *bp,
1495 static void sd_pkt_reason_cmd_timeout(struct sd_lun *un, struct buf *bp,
1497 static void sd_pkt_reason_cmd_unx_bus_free(struct sd_lun *un, struct buf *bp,
1499 static void sd_pkt_reason_cmd_tag_reject(struct sd_lun *un, struct buf *bp,
1501 static void sd_pkt_reason_default(struct sd_lun *un, struct buf *bp,
1504 static void sd_reset_target(struct sd_lun *un, struct scsi_pkt *pktp);
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);
1517 static int sd_handle_mchange(struct sd_lun *un);
1532 static int sd_send_scsi_SYNCHRONIZE_CACHE(struct sd_lun *un,
1561 static int sd_alloc_rqs(struct scsi_device *devp, struct sd_lun *un);
1562 static void sd_free_rqs(struct sd_lun *un);
1564 static void sd_dump_memory(struct sd_lun *un, uint_t comp, char *title,
1566 static void sd_panic_for_res_conflict(struct sd_lun *un);
1581 static void sd_mhd_watch_incomplete(struct sd_lun *un, struct scsi_pkt *pkt);
1589 static int sd_persistent_reservation_in_read_keys(struct sd_lun *un,
1591 static int sd_persistent_reservation_in_read_resv(struct sd_lun *un,
1620 static void sr_ejected(register struct sd_lun *un);
1622 static opaque_t sd_watch_request_submit(struct sd_lun *un);
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,
1639 static struct sd_w_map *sd_get_range(struct sd_lun *un, daddr_t startb,
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);
1645 sddump_do_read_of_rmw(struct sd_lun *un, uint64_t blkno, uint64_t nblk,
1652 static void sd_failfast_flushq(struct sd_lun *un);
1658 static void sd_is_lsi(struct sd_lun *un);
1663 static int sd_setup_next_xfer(struct sd_lun *un, struct buf *bp,
1717 static void sd_faultinjection_ioctl(int cmd, intptr_t arg, struct sd_lun *un);
1719 static void sd_injection_log(char *buf, struct sd_lun *un);
1836 typedef void (*sd_chain_t)(int index, struct sd_lun *un, struct buf *bp);
2357 /* un->un_buf_chain_type must be set to one of these */
2369 /* un->un_uscsi_chain_type must be set to one of these */
2375 /* un->un_direct_chain_type must be set to one of these */
2378 /* un->un_priority_chain_type must be set to one of these */
2392 #define SD_BEGIN_IOSTART(index, un, bp) \
2393 ((*(sd_iostart_chain[index]))(index, un, bp))
2395 #define SD_BEGIN_IODONE(index, un, bp) \
2396 ((*(sd_iodone_chain[index]))(index, un, bp))
2398 #define SD_NEXT_IOSTART(index, un, bp) \
2399 ((*(sd_iostart_chain[(index) + 1]))((index) + 1, un, bp))
2401 #define SD_NEXT_IODONE(index, un, bp) \
2402 ((*(sd_iodone_chain[(index) - 1]))((index) - 1, un, bp))
2570 sd_log_err(uint_t comp, struct sd_lun *un, const char *fmt, ...)
2575 ASSERT(un != NULL);
2576 dev = SD_DEVINFO(un);
2581 * Also print if un matches the value of sd_debug_un, or if
2585 ((sd_debug_un == NULL) || (sd_debug_un == un))) {
2595 if (un->sd_injection_mask & comp) {
2600 sd_injection_log(sd_log_buf, un);
2619 sd_log_info(uint_t component, struct sd_lun *un, const char *fmt, ...)
2624 ASSERT(un != NULL);
2625 dev = SD_DEVINFO(un);
2630 * Also print if un matches the value of sd_debug_un, or if
2635 ((sd_debug_un == NULL) || (sd_debug_un == un))) {
2645 if (un->sd_injection_mask & component) {
2650 sd_injection_log(sd_log_buf, un);
2669 sd_log_trace(uint_t component, struct sd_lun *un, const char *fmt, ...)
2674 ASSERT(un != NULL);
2675 dev = SD_DEVINFO(un);
2680 * Also print if un matches the value of sd_debug_un, or if
2685 ((sd_debug_un == NULL) || (sd_debug_un == un))) {
2695 if (un->sd_injection_mask & component) {
2700 sd_injection_log(sd_log_buf, un);
2834 struct sd_lun *un;
2843 if ((un = ddi_get_soft_state(sd_state, instance)) == NULL) {
2846 *result = (void *) SD_DEVINFO(un);
2887 struct sd_lun *un;
2889 if ((un = ddi_get_soft_state(sd_state, ddi_get_instance(dip))) == NULL)
2893 return (cmlb_prop_op(un->un_cmlbhandle,
3223 struct sd_lun *un;
3226 un = ssc->ssc_un;
3227 ASSERT(un != NULL);
3272 bcopy(bufaddr, SD_INQUIRY(un), SUN_INQSIZE);
3314 struct sd_lun *un;
3317 un = ssc->ssc_un;
3318 ASSERT(un != NULL);
3331 SD_ERROR(SD_LOG_COMMON, un,
3355 SD_ERROR(SD_LOG_COMMON, un,
3379 SD_INFO(SD_LOG_COMMON, un,
3401 struct sd_lun *un = arg;
3404 ASSERT(un != NULL);
3406 ssc = sd_ssc_init(un);
3440 struct sd_lun *un;
3443 un = ssc->ssc_un;
3444 ASSERT(un != NULL);
3451 un->un_f_mmc_cap = FALSE;
3452 un->un_f_dvdram_writable_device = FALSE;
3453 un->un_f_cfg_cdda = FALSE;
3470 un->un_f_mmc_cap = TRUE;
3473 if (un->un_f_mmc_gesn_polling) {
3483 un->un_f_mmc_gesn_polling = FALSE;
3484 SD_INFO(SD_LOG_ATTACH_DETACH, un,
3506 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
3516 un->un_f_cfg_cdda = (sense_page[5] & 0x01) ? TRUE : FALSE;
3519 un->un_f_dvdram_writable_device = (sense_page[3] & 0x20) ? TRUE : FALSE;
3520 if (un->un_f_dvdram_writable_device == TRUE) {
3537 * If un->un_f_dvdram_writable_device is still FALSE,
3573 un->un_f_dvdram_writable_device = TRUE;
3590 * Arguments: un - driver soft state (unit) structure
3614 struct sd_lun *un;
3617 un = ssc->ssc_un;
3618 ASSERT(un != NULL);
3619 ASSERT(mutex_owned(SD_MUTEX(un)));
3625 un->un_f_mmc_writable_media = FALSE;
3626 mutex_exit(SD_MUTEX(un));
3637 mutex_enter(SD_MUTEX(un));
3643 un->un_f_mmc_writable_media = TRUE;
3656 mutex_exit(SD_MUTEX(un));
3663 mutex_enter(SD_MUTEX(un));
3678 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
3698 * If un->un_f_mmc_writable_media is still FALSE,
3702 mutex_exit(SD_MUTEX(un));
3714 mutex_enter(SD_MUTEX(un));
3726 mutex_enter(SD_MUTEX(un));
3736 un->un_f_mmc_writable_media = TRUE;
3757 * Arguments: un - driver soft state (unit) structure
3761 sd_read_unit_properties(struct sd_lun *un)
3770 ASSERT(un != NULL);
3771 if (sd_process_sdconf_file(un) == SD_FAILURE) {
3772 sd_process_sdconf_table(un);
3776 sd_is_lsi(un);
3789 * Arguments: un - driver soft state (unit) structure
3846 sd_process_sdconf_file(struct sd_lun *un)
3860 ASSERT(un != NULL);
3863 if (ddi_prop_lookup_string_array(DDI_DEV_T_ANY, SD_DEVINFO(un),
3878 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
3892 if (sd_sdconf_id_match(un, vidptr, vidlen) != SD_SUCCESS) {
3906 sd_nvpair_str_decode(un, dnlist_ptr);
3920 SD_INFO(SD_LOG_ATTACH_DETACH, un,
3926 SD_DEVINFO(un), 0, dataname_ptr, &data_list,
3928 SD_INFO(SD_LOG_ATTACH_DETACH, un,
3941 if (sd_chk_vers1_data(un, data_list[1],
3944 sd_get_tunables_from_conf(un,
3947 sd_set_vers1_properties(un,
3954 scsi_log(SD_DEVINFO(un), sd_label,
3981 * Arguments: un - driver soft state (unit) structure
3985 sd_nvpair_str_decode(struct sd_lun *un, char *nvpair_str)
3997 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4001 sd_set_properties(un, name, value);
4047 * Arguments: un - driver soft state (unit) structure
4052 sd_set_properties(struct sd_lun *un, char *name, char *value)
4059 un->un_f_suppress_cache_flush = TRUE;
4061 un->un_f_suppress_cache_flush = FALSE;
4065 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4067 un->un_f_suppress_cache_flush);
4073 un->un_ctype = val;
4077 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4078 "ctype set to %d\n", un->un_ctype);
4084 un->un_busy_timeout = drv_usectohz(val / 1000);
4088 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4089 "busy_timeout set to %d\n", un->un_busy_timeout);
4095 un->un_f_disksort_disabled = FALSE;
4097 un->un_f_disksort_disabled = TRUE;
4101 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4103 un->un_f_disksort_disabled);
4109 un->un_f_power_condition_disabled = FALSE;
4111 un->un_f_power_condition_disabled = TRUE;
4115 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4117 un->un_f_power_condition_disabled);
4123 un->un_reserve_release_time = val;
4127 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4129 un->un_reserve_release_time);
4135 un->un_f_lun_reset_enabled = TRUE;
4137 un->un_f_lun_reset_enabled = FALSE;
4141 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4143 un->un_f_lun_reset_enabled);
4149 un->un_busy_retry_count = val;
4153 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4154 "busy retry count set to %d\n", un->un_busy_retry_count);
4160 un->un_retry_count = val;
4164 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4165 "timeout retry count set to %d\n", un->un_retry_count);
4171 un->un_notready_retry_count = val;
4175 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4177 un->un_notready_retry_count);
4183 un->un_reset_retry_count = val;
4187 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4189 un->un_reset_retry_count);
4195 un->un_saved_throttle = un->un_throttle = val;
4199 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4200 "throttle set to %d\n", un->un_throttle);
4205 un->un_min_throttle = val;
4209 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4210 "min throttle set to %d\n", un->un_min_throttle);
4215 un->un_f_rmw_type = val;
4219 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4220 "RMW type set to %d\n", un->un_f_rmw_type);
4225 ISP2(val) && val >= un->un_tgt_blocksize &&
4226 val >= un->un_sys_blocksize) {
4227 un->un_phy_blocksize = val;
4231 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4232 "physical block size set to %d\n", un->un_phy_blocksize);
4237 un->un_victim_retry_count = val;
4241 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4243 un->un_victim_retry_count);
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;
4260 un->un_f_mmc_gesn_polling = TRUE;
4262 un->un_f_mmc_gesn_polling = FALSE;
4266 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4268 un->un_f_mmc_gesn_polling);
4274 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4291 sd_get_tunables_from_conf(struct sd_lun *un, int flags, int *data_list,
4311 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4317 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4323 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4329 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4335 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4341 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4347 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4353 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4359 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4365 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4372 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4392 * Arguments: un - driver soft state (unit) structure
4396 sd_process_sdconf_table(struct sd_lun *un)
4402 ASSERT(un != NULL);
4414 if (sd_sdconf_id_match(un, id, idlen) == SD_SUCCESS) {
4415 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4417 sd_set_vers1_properties(un,
4440 * Arguments: un - driver soft state (unit) structure
4449 sd_sdconf_id_match(struct sd_lun *un, char *id, int idlen)
4454 ASSERT(un != NULL);
4455 sd_inq = un->un_sd->sd_inq;
4470 rval = sd_blank_cmp(un, id, idlen);
4485 j = sizeof (SD_INQUIRY(un)->inq_pid) -
4492 if (bcmp(&SD_INQUIRY(un)->inq_pid[i],
4522 * Arguments: un - driver soft state (unit) structure
4531 sd_blank_cmp(struct sd_lun *un, char *id, int idlen)
4536 cnt = sizeof (SD_INQUIRY(un)->inq_vid) +
4537 sizeof (SD_INQUIRY(un)->inq_pid);
4539 ASSERT(un != NULL);
4540 p2 = un->un_sd->sd_inq->inq_vid;
4584 * Arguments: un - driver soft state (unit) structure
4594 sd_chk_vers1_data(struct sd_lun *un, int flags, int *prop_list,
4601 ASSERT(un != NULL);
4605 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
4610 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
4618 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
4637 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
4641 scsi_log(SD_DEVINFO(un), sd_label, CE_CONT, "Size expected: "
4661 * Arguments: un - driver soft state (unit) structure
4667 sd_set_vers1_properties(struct sd_lun *un, int flags, sd_tunables *prop_list)
4669 ASSERT(un != NULL);
4677 un->un_f_opt_disable_cache = TRUE;
4678 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4684 un->un_f_cfg_playmsf_bcd = TRUE;
4685 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4689 un->un_f_cfg_readsub_bcd = TRUE;
4690 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4694 un->un_f_cfg_read_toc_trk_bcd = TRUE;
4695 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4699 un->un_f_cfg_read_toc_addr_bcd = TRUE;
4700 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4704 un->un_f_cfg_no_read_header = TRUE;
4705 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4709 un->un_f_cfg_read_cd_xd4 = TRUE;
4710 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4716 un->un_f_opt_fab_devid = TRUE;
4717 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4724 un->un_saved_throttle = un->un_throttle =
4726 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4735 un->un_notready_retry_count =
4737 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4739 " set to %d\n", un->un_notready_retry_count);
4748 un->un_ctype = prop_list->sdt_ctype;
4749 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4754 un->un_ctype = prop_list->sdt_ctype;
4755 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4760 un->un_ctype = prop_list->sdt_ctype;
4761 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4766 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
4776 un->un_busy_retry_count =
4778 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4781 un->un_busy_retry_count);
4787 un->un_reset_retry_count =
4789 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4792 un->un_reset_retry_count);
4798 un->un_reserve_release_time =
4800 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4803 un->un_reserve_release_time);
4812 un->un_f_cfg_tur_check = TRUE;
4813 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4818 un->un_min_throttle = prop_list->sdt_min_throttle;
4819 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4821 un->un_min_throttle);
4825 un->un_f_disksort_disabled =
4828 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4835 un->un_f_lun_reset_enabled =
4838 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4845 un->un_f_suppress_cache_flush =
4848 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4855 un->un_f_power_condition_disabled =
4858 SD_INFO(SD_LOG_ATTACH_DETACH, un,
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;
4882 * Args: un - ptr to sd_lun
4888 sd_is_lsi(struct sd_lun *un)
4895 ASSERT(un != NULL);
4904 if (sd_sdconf_id_match(un, id, idlen) == SD_SUCCESS) {
4910 un->un_f_cfg_is_lsi = TRUE;
4931 * This requires that un->un_blockcount and un->un_tgt_blocksize
4938 * Arguments: un - driver soft state (unit) structure
4948 sd_get_physical_geometry(struct sd_lun *un, cmlb_geom_t *pgeom_p,
4971 ASSERT(un != NULL);
4974 if (ISCD(un)) {
4977 lbasize = un->un_sys_blocksize;
4988 if (ISCD(un))
4991 cdbsize = (un->un_f_cfg_is_atapi == TRUE) ? CDB_GROUP2 : CDB_GROUP0;
4997 ssc = sd_ssc_init(un);
5001 SD_ERROR(SD_LOG_COMMON, un,
5012 if (un->un_f_cfg_is_atapi == TRUE) {
5052 sector_size = un->un_sys_blocksize;
5054 sector_size &= ~(un->un_sys_blocksize - 1);
5060 SD_INFO(SD_LOG_COMMON, un,
5062 SD_INFO(SD_LOG_COMMON, un,
5065 SD_INFO(SD_LOG_COMMON, un,
5079 SD_ERROR(SD_LOG_COMMON, un,
5090 if (un->un_f_cfg_is_atapi == TRUE) {
5129 SD_INFO(SD_LOG_COMMON, un,
5131 SD_INFO(SD_LOG_COMMON, un,
5133 SD_INFO(SD_LOG_COMMON, un,
5135 SD_INFO(SD_LOG_COMMON, un, " pgeom_p: %p; read cap: %d\n",
5145 SD_INFO(SD_LOG_COMMON, un,
5165 SD_INFO(SD_LOG_COMMON, un,
5167 SD_INFO(SD_LOG_COMMON, un,
5170 SD_INFO(SD_LOG_COMMON, un,
5173 SD_INFO(SD_LOG_COMMON, un,
5175 SD_INFO(SD_LOG_COMMON, un,
5179 SD_INFO(SD_LOG_COMMON, un,
5225 * Arguments: un - pointer to softstate
5233 sd_get_virtual_geometry(struct sd_lun *un, cmlb_geom_t *lgeom_p,
5239 ASSERT(un != NULL);
5242 (void) scsi_ifsetcap(SD_ADDRESS(un), "sector-size", lbasize, 1);
5243 (void) scsi_ifsetcap(SD_ADDRESS(un), "total-sectors", capacity, 1);
5246 geombuf = (uint_t)scsi_ifgetcap(SD_ADDRESS(un), "geometry", 1);
5256 lgeom_p->g_secsize = un->un_sys_blocksize;
5281 SD_INFO(SD_LOG_COMMON, un, "sd_get_virtual_geometry: (cached)\n");
5291 * Arguments: un: unit struct.
5299 sd_update_block_info(struct sd_lun *un, uint32_t lbasize, uint64_t capacity)
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;
5310 un->un_blockcount = capacity;
5311 un->un_f_blockcount_is_valid = TRUE;
5316 if (un->un_errstats != NULL) {
5319 capacity *= un->un_sys_blocksize;
5320 stp = (struct sd_errstats *)un->un_errstats->ks_data;
5336 * un - driver soft state (unit) structure
5354 struct sd_lun *un;
5357 un = ssc->ssc_un;
5358 ASSERT(un != NULL);
5359 ASSERT(mutex_owned(SD_MUTEX(un)));
5360 ASSERT((SD_DEVINFO(un)) == devi);
5374 if (un->un_vpd_page_mask & SD_VPD_UNIT_SERIAL_PG) {
5376 mutex_exit(SD_MUTEX(un));
5388 DDI_DEV_T_NONE, SD_DEVINFO(un),
5411 SD_DEVINFO(un),
5416 mutex_enter(SD_MUTEX(un));
5420 if (un->un_vpd_page_mask & SD_VPD_DEVID_WWN_PG) {
5421 mutex_exit(SD_MUTEX(un));
5433 mutex_enter(SD_MUTEX(un));
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;
5459 if (un->un_f_opt_fab_devid == TRUE) {
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,
5486 (char *)ddi_driver_name(SD_DEVINFO(un)),
5487 (uchar_t *)SD_INQUIRY(un), sizeof (*SD_INQUIRY(un)),
5489 inq83_resid, &un->un_devid) == DDI_SUCCESS) {
5492 (void) ddi_devid_register(SD_DEVINFO(un), un->un_devid);
5512 un->un_f_opt_fab_devid = TRUE;
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,
5544 * Arguments: un - driver soft state (unit) structure
5563 struct sd_lun *un;
5566 un = ssc->ssc_un;
5567 ASSERT(un != NULL);
5568 ASSERT(mutex_owned(SD_MUTEX(un)));
5570 SD_TRACE(SD_LOG_ATTACH_DETACH, un, "sd_get_devid: entry: un: 0x%p\n",
5571 un);
5573 if (un->un_devid != NULL) {
5577 mutex_exit(SD_MUTEX(un));
5578 if (cmlb_get_devid_block(un->un_cmlbhandle, &blk,
5580 mutex_enter(SD_MUTEX(un));
5590 mutex_enter(SD_MUTEX(un));
5591 buffer_size = SD_REQBYTES2TGTBYTES(un, sizeof (struct dk_devid));
5592 mutex_exit(SD_MUTEX(un));
5635 mutex_enter(SD_MUTEX(un));
5637 un->un_devid = tmpid;
5638 bcopy(&dkdevid->dkd_devid, un->un_devid, sz);
5642 SD_TRACE(SD_LOG_ATTACH_DETACH, un, "sd_get_devid: exit: un:0x%p\n", un);
5646 mutex_enter(SD_MUTEX(un));
5658 * Arguments: un - driver soft state (unit) structure
5668 struct sd_lun *un;
5671 un = ssc->ssc_un;
5672 ASSERT(un != NULL);
5675 if (ddi_devid_init(SD_DEVINFO(un), DEVID_FAB, 0, NULL, &un->un_devid)
5682 ddi_devid_free(un->un_devid);
5683 un->un_devid = NULL;
5686 return (un->un_devid);
5696 * Arguments: un - driver soft state (unit) structure
5713 struct sd_lun *un;
5716 un = ssc->ssc_un;
5717 ASSERT(un != NULL);
5718 ASSERT(mutex_owned(SD_MUTEX(un)));
5720 mutex_exit(SD_MUTEX(un));
5721 if (cmlb_get_devid_block(un->un_cmlbhandle, &blk,
5723 mutex_enter(SD_MUTEX(un));
5729 buf = kmem_zalloc(un->un_sys_blocksize, KM_SLEEP);
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));
5754 status = sd_send_scsi_WRITE(ssc, buf, un->un_sys_blocksize, blk,
5759 kmem_free(buf, un->un_sys_blocksize);
5761 mutex_enter(SD_MUTEX(un));
5775 * Arguments: un - driver soft state (unit) structure
5792 struct sd_lun *un;
5795 un = ssc->ssc_un;
5796 ASSERT(un != NULL);
5797 ASSERT(mutex_owned(SD_MUTEX(un)));
5799 mutex_exit(SD_MUTEX(un));
5813 mutex_enter(SD_MUTEX(un));
5839 un->un_vpd_page_mask |= SD_VPD_SUPPORTED_PG;
5842 un->un_vpd_page_mask |= SD_VPD_UNIT_SERIAL_PG;
5845 un->un_vpd_page_mask |= SD_VPD_OPERATING_PG;
5848 un->un_vpd_page_mask |= SD_VPD_ASCII_OP_PG;
5851 un->un_vpd_page_mask |= SD_VPD_DEVID_WWN_PG;
5854 un->un_vpd_page_mask |= SD_VPD_EXTENDED_DATA_PG;
5857 un->un_vpd_page_mask |= SD_VPD_DEV_CHARACTER_PG;
5866 SD_INFO(SD_LOG_ATTACH_DETACH, un,
5891 struct sd_lun *un;
5894 un = ssc->ssc_un;
5895 ASSERT(un != NULL);
5899 * un is unnecessary. Because some of the routines called
5903 ASSERT(!mutex_owned(SD_MUTEX(un)));
5921 if (un->un_f_pm_supported) {
5929 un->un_f_start_stop_supported = TRUE;
5931 if (un->un_f_power_condition_supported) {
5936 un->un_f_power_condition_supported = FALSE;
5939 if (!un->un_f_power_condition_supported) {
5945 un->un_f_start_stop_supported = FALSE;
5952 un->un_f_pm_is_enabled = TRUE;
5953 (void) sd_create_pm_components(devi, un);
5958 if (un->un_f_log_sense_supported) {
5963 un->un_start_stop_cycle_page =
5973 un->un_f_log_sense_supported = FALSE;
5974 un->un_f_pm_log_sense_smart = FALSE;
5985 if (!un->un_f_log_sense_supported) {
5986 un->un_power_level = SD_SPINDLE_ON;
5987 un->un_f_pm_is_enabled = FALSE;
6012 un->un_power_level = SD_SPINDLE_ON;
6013 un->un_f_pm_is_enabled = FALSE;
6026 un->un_start_stop_cycle_page = START_STOP_CYCLE_VU_PAGE;
6027 un->un_f_pm_is_enabled = TRUE;
6033 un->un_power_level = SD_SPINDLE_ON;
6034 un->un_f_pm_is_enabled = FALSE;
6040 un->un_start_stop_cycle_page = START_STOP_CYCLE_PAGE;
6041 un->un_f_pm_is_enabled = TRUE;
6045 if (un->un_f_pm_is_enabled == TRUE) {
6050 log_page_size, un->un_start_stop_cycle_page,
6070 (void) sd_create_pm_components(devi, un);
6072 un->un_power_level = SD_SPINDLE_ON;
6073 un->un_f_pm_is_enabled = FALSE;
6090 sd_create_pm_components(dev_info_t *devi, struct sd_lun *un)
6092 ASSERT(!mutex_owned(SD_MUTEX(un)));
6094 if (un->un_f_power_condition_supported) {
6098 un->un_power_level = SD_SPINDLE_ACTIVE;
6099 un->un_f_pm_is_enabled = FALSE;
6106 un->un_power_level = SD_SPINDLE_ON;
6107 un->un_f_pm_is_enabled = FALSE;
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);
6129 un->un_pm_count = 0;
6131 mutex_enter(SD_MUTEX(un));
6132 un->un_power_level = SD_PM_STATE_STOPPED(un);
6133 mutex_enter(&un->un_pm_mutex);
6135 un->un_pm_count = -1;
6137 mutex_exit(&un->un_pm_mutex);
6138 mutex_exit(SD_MUTEX(un));
6159 struct sd_lun *un;
6162 un = ddi_get_soft_state(sd_state, ddi_get_instance(devi));
6163 if (un == NULL) {
6167 SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_suspend: entry\n");
6169 mutex_enter(SD_MUTEX(un));
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: "
6180 if (un->un_resvd_status &
6182 mutex_exit(SD_MUTEX(un));
6183 SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_suspend: "
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: "
6201 un->un_save_state = un->un_last_state;
6202 New_state(un, SD_STATE_SUSPENDED);
6219 while (un->un_ncmds_in_transport != 0) {
6223 if (cv_timedwait(&un->un_disk_busy_cv, SD_MUTEX(un),
6229 Restore_state(un);
6230 un->un_last_state = un->un_save_state;
6232 cv_broadcast(&un->un_suspend_cv);
6233 mutex_exit(SD_MUTEX(un));
6234 SD_ERROR(SD_LOG_IO_PM, un,
6236 SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_suspend: exiting\n");
6245 if (SD_OK_TO_SUSPEND_SCSI_WATCHER(un)) {
6246 opaque_t temp_token = un->un_swr_token;
6247 mutex_exit(SD_MUTEX(un));
6249 mutex_enter(SD_MUTEX(un));
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));
6257 mutex_enter(SD_MUTEX(un));
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));
6265 mutex_enter(SD_MUTEX(un));
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));
6275 mutex_enter(SD_MUTEX(un));
6277 mutex_exit(&un->un_pm_mutex);
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));
6285 mutex_enter(SD_MUTEX(un));
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));
6293 mutex_enter(SD_MUTEX(un));
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;
6301 un->un_retry_bp = NULL;
6302 un->un_retry_statp = NULL;
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));
6311 mutex_enter(SD_MUTEX(un));
6314 if (un->un_f_is_fibre == TRUE) {
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;
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;
6333 mutex_exit(SD_MUTEX(un));
6335 SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_suspend: exit\n");
6355 struct sd_lun *un;
6357 un = ddi_get_soft_state(sd_state, ddi_get_instance(devi));
6358 if (un == NULL) {
6362 SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_resume: entry\n");
6364 mutex_enter(SD_MUTEX(un));
6365 Restore_state(un);
6371 un->un_last_state = un->un_save_state;
6384 un->un_throttle = un->un_saved_throttle;
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));
6406 cv_broadcast(&un->un_suspend_cv);
6407 cv_broadcast(&un->un_state_cv);
6410 if (SD_OK_TO_RESUME_SCSI_WATCHER(un)) {
6411 scsi_watch_resume(un->un_swr_token);
6415 if (un->un_f_is_fibre == TRUE) {
6419 if (strcmp(un->un_node_type, DDI_NT_BLOCK_CHAN)) {
6420 sd_init_event_callbacks(un);
6436 ddi_xbuf_dispatch(un->un_xbuf_attr);
6438 sd_start_cmds(un, NULL);
6439 mutex_exit(SD_MUTEX(un));
6441 SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_resume: exit\n");
6454 * Arguments: un - driver soft state (unit) structure
6463 sd_pm_state_change(struct sd_lun *un, int level, int flag)
6465 ASSERT(un != NULL);
6466 SD_TRACE(SD_LOG_POWER, un, "sd_pm_state_change: entry\n");
6468 ASSERT(!mutex_owned(SD_MUTEX(un)));
6469 mutex_enter(SD_MUTEX(un));
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);
6479 mutex_exit(&un->un_pm_mutex);
6485 if ((un->un_f_pm_is_enabled == FALSE) || (un->un_resvd_status &
6487 mutex_exit(SD_MUTEX(un));
6488 SD_TRACE(SD_LOG_POWER, un,
6493 SD_INFO(SD_LOG_POWER, un, "sd_pm_state_change: "
6494 "un_ncmds_in_driver=%ld\n", un->un_ncmds_in_driver);
6501 if ((un->un_ncmds_in_driver == 0) &&
6502 (un->un_state != SD_STATE_RWAIT)) {
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;
6515 mutex_exit(SD_MUTEX(un));
6517 SD_TRACE(SD_LOG_POWER, un, "sd_pm_state_change: exit\n");
6545 struct sd_lun *un = arg;
6548 if (un->un_detach_count != 0) {
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)) {
6567 if (un->un_f_non_devbsize_supported) {
6568 un->un_buf_chain_type = SD_CHAIN_INFO_RMMEDIA;
6570 un->un_buf_chain_type = SD_CHAIN_INFO_DISK;
6572 un->un_uscsi_chain_type = SD_CHAIN_INFO_USCSI_CMD;
6574 SD_TRACE(SD_LOG_IO_PM, un,
6576 (void) pm_idle_component(SD_DEVINFO(un), 0);
6577 un->un_pm_idle_timeid = NULL;
6579 un->un_pm_idle_timeid =
6580 timeout(sd_pm_idletimeout_handler, un,
6583 mutex_exit(&un->un_pm_mutex);
6584 mutex_exit(SD_MUTEX(un));
6599 struct sd_lun *un = arg;
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);
6622 struct sd_lun *un;
6640 if (((un = ddi_get_soft_state(sd_state, instance)) == NULL) ||
6641 !SD_PM_IS_LEVEL_VALID(un, level) || component != 0) {
6645 ssc = sd_ssc_init(un);
6647 SD_TRACE(SD_LOG_IO_PM, un, "sdpower: entry, level = %d\n", level);
6660 got_semaphore_here = sema_tryp(&un->un_semoclose);
6662 mutex_enter(SD_MUTEX(un));
6664 SD_INFO(SD_LOG_POWER, un, "sdpower: un_ncmds_in_driver = %ld\n",
6665 un->un_ncmds_in_driver);
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));
6680 sema_v(&un->un_semoclose);
6682 SD_TRACE(SD_LOG_IO_PM, un,
6696 if ((un->un_state == SD_STATE_OFFLINE) ||
6697 (un->un_state == SD_STATE_SUSPENDED)) {
6698 mutex_exit(SD_MUTEX(un));
6701 sema_v(&un->un_semoclose);
6703 SD_TRACE(SD_LOG_IO_PM, un,
6715 state_before_pm = un->un_state;
6716 un->un_state = SD_STATE_PM_CHANGING;
6718 mutex_exit(SD_MUTEX(un));
6725 if (SD_PM_STOP_MOTOR_NEEDED(un, level) &&
6726 un->un_f_log_sense_supported) {
6734 mutex_enter(SD_MUTEX(un));
6735 log_sense_page = un->un_start_stop_cycle_page;
6736 mutex_exit(SD_MUTEX(un));
6755 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
6762 sema_v(&un->un_semoclose);
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,
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;
6797 sd_pm_tran_data.un.scsi_cycles.lifemax = maxcycles;
6798 sd_pm_tran_data.un.scsi_cycles.ncycles = ncycles;
6800 sd_pm_tran_data.un.scsi_cycles.svc_date[i] =
6803 sd_pm_tran_data.un.scsi_cycles.flag = 0;
6846 mutex_enter(&un->un_pm_mutex);
6847 if (un->un_pm_timeid == NULL) {
6848 un->un_pm_timeid =
6850 un, intvlp * drv_usectohz(1000000));
6851 mutex_exit(&un->un_pm_mutex);
6852 (void) pm_busy_component(SD_DEVINFO(un), 0);
6854 mutex_exit(&un->un_pm_mutex);
6857 sema_v(&un->un_semoclose);
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));
6869 SD_TRACE(SD_LOG_IO_PM, un, "sdpower: exit, "
6875 sema_v(&un->un_semoclose);
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,
6893 if (!SD_PM_IS_IO_CAPABLE(un, level)) {
6898 mutex_enter(SD_MUTEX(un));
6899 save_state = un->un_last_state;
6900 last_power_level = un->un_power_level;
6906 ASSERT(un->un_ncmds_in_driver == 0);
6907 mutex_exit(SD_MUTEX(un));
6913 if ((rval = sd_pm_state_change(un, level, SD_PM_STATE_CHANGE))
6916 sema_v(&un->un_semoclose);
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,
6948 if (SD_PM_IS_IO_CAPABLE(un, level)) {
6955 if (un->un_f_power_condition_supported) {
6958 SD_TRACE(SD_LOG_IO_PM, un,
6964 SD_TRACE(SD_LOG_IO_PM, un, "sdpower: sending \'%s\' unit\n",
6978 if ((sval == ENXIO) && un->un_f_has_removable_media) {
6991 if (!SD_PM_IS_IO_CAPABLE(un, level)) {
7001 (void) sd_pm_state_change(un, last_power_level,
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) {
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));
7025 mutex_exit(SD_MUTEX(un));
7044 (void) sd_pm_state_change(un, level,
7051 if (un->un_f_monitor_media_state) {
7052 mutex_enter(SD_MUTEX(un));
7053 if (un->un_f_watcht_stopped == TRUE) {
7056 un->un_f_watcht_stopped = FALSE;
7057 mutex_exit(SD_MUTEX(un));
7059 sd_watch_request_submit(un);
7060 mutex_enter(SD_MUTEX(un));
7061 un->un_swr_token = temp_token;
7063 mutex_exit(SD_MUTEX(un));
7069 sema_v(&un->un_semoclose);
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));
7081 SD_TRACE(SD_LOG_IO_PM, un, "sdpower: exit, status = 0x%x\n", rval);
7158 * Arguments: un: softstate structure for the instance
7164 sd_sync_with_callback(struct sd_lun *un)
7166 ASSERT(un != NULL);
7168 mutex_enter(SD_MUTEX(un));
7170 ASSERT(un->un_in_callback >= 0);
7172 while (un->un_in_callback > 0) {
7173 mutex_exit(SD_MUTEX(un));
7175 mutex_enter(SD_MUTEX(un));
7178 mutex_exit(SD_MUTEX(un));
7201 struct sd_lun *un;
7314 if ((un = ddi_get_soft_state(sd_state, instance)) == NULL) {
7326 * we first set un->un_sd below.
7328 un->un_sd = devp;
7329 devp->sd_private = (opaque_t)un;
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);
7348 un->un_node_type = DDI_NT_CD_CHAN;
7349 un->un_ctype = CTYPE_CDROM;
7352 un->un_node_type = DDI_NT_BLOCK_CHAN;
7353 un->un_ctype = CTYPE_ROD;
7356 un->un_node_type = DDI_NT_BLOCK_CHAN;
7357 un->un_ctype = CTYPE_CCS;
7374 un->un_f_is_fibre = TRUE;
7375 switch (scsi_ifgetcap(SD_ADDRESS(un), "interconnect-type", -1)) {
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);
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);
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);
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);
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);
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);
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);
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;
7444 un->un_interconnect_type = SD_INTERCONNECT_PARALLEL;
7445 un->un_f_is_fibre = FALSE;
7450 if (un->un_f_is_fibre == TRUE) {
7451 if (scsi_ifgetcap(SD_ADDRESS(un), "scsi-version", 1) ==
7453 switch (un->un_interconnect_type) {
7456 un->un_node_type = DDI_NT_BLOCK_WWN;
7467 if (sd_alloc_rqs(devp, un) != DDI_SUCCESS) {
7483 un->un_retry_count = un->un_f_is_fibre ? 3 : 5;
7485 un->un_retry_count = SD_RETRY_COUNT;
7493 un->un_notready_retry_count =
7494 ISCD(un) ? CD_NOT_READY_RETRY_COUNT(un)
7495 : DISK_NOT_READY_RETRY_COUNT(un);
7502 un->un_busy_retry_count = un->un_retry_count;
7510 un->un_reset_retry_count = (un->un_retry_count / 2);
7515 un->un_victim_retry_count = (2 * un->un_retry_count);
7522 un->un_reserve_release_time = 5;
7530 un->un_max_xfer_size = (uint_t)SD_DEFAULT_MAX_XFER_SIZE;
7531 un->un_partial_dma_supported = 1;
7533 un->un_max_xfer_size = (uint_t)maxphys;
7543 if (un->un_f_is_fibre == TRUE) {
7544 un->un_f_allow_bus_device_reset = TRUE;
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);
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);
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);
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);
7586 un->un_cmd_timeout = SD_IO_TIME;
7588 un->un_busy_timeout = SD_BSY_TIMEOUT;
7591 un->un_state = SD_STATE_NORMAL;
7592 un->un_last_state = SD_STATE_NORMAL;
7595 un->un_throttle = sd_max_throttle;
7596 un->un_saved_throttle = sd_max_throttle;
7597 un->un_min_throttle = sd_min_throttle;
7599 if (un->un_f_is_fibre == TRUE) {
7600 un->un_f_use_adaptive_throttle = TRUE;
7602 un->un_f_use_adaptive_throttle = FALSE;
7606 cv_init(&un->un_state_cv, NULL, CV_DRIVER, NULL);
7607 un->un_mediastate = DKIO_NONE;
7608 un->un_specified_mediastate = DKIO_NONE;
7611 cv_init(&un->un_suspend_cv, NULL, CV_DRIVER, NULL);
7612 cv_init(&un->un_disk_busy_cv, NULL, CV_DRIVER, NULL);
7615 un->un_power_level = SD_SPINDLE_UNINIT;
7617 cv_init(&un->un_wcc_cv, NULL, CV_DRIVER, NULL);
7618 un->un_f_wcc_inprog = 0;
7625 (void) sema_init(&un->un_semoclose, 1, NULL, SEMA_DRIVER, NULL);
7631 un->un_f_disksort_disabled = FALSE;
7632 un->un_f_rmw_type = SD_RMW_TYPE_DEFAULT;
7633 un->un_f_enable_rmw = FALSE;
7639 un->un_f_mmc_gesn_polling = TRUE;
7646 un->un_phy_blocksize = DEV_BSIZE;
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);
7667 un->un_f_is_hotpluggable = TRUE;
7674 sd_set_unit_attributes(un, devi);
7682 un->un_f_blockcount_is_valid = FALSE;
7683 un->un_f_tgt_blocksize_is_valid = FALSE;
7689 un->un_tgt_blocksize = un->un_sys_blocksize = DEV_BSIZE;
7690 un->un_blockcount = 0;
7696 sd_init_cdb_limits(un);
7701 if (un->un_f_non_devbsize_supported) {
7702 un->un_buf_chain_type = SD_CHAIN_INFO_RMMEDIA;
7704 un->un_buf_chain_type = SD_CHAIN_INFO_DISK;
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;
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,
7713 ddi_xbuf_attr_register_devinfo(un->un_xbuf_attr, devi);
7716 if (ISCD(un)) {
7717 un->un_additional_codes = sd_additional_codes;
7719 un->un_additional_codes = NULL;
7737 un->un_stats = kstat_create(sd_label, instance,
7739 if (un->un_stats != NULL) {
7740 un->un_stats->ks_lock = SD_MUTEX(un);
7741 kstat_install(un->un_stats);
7743 SD_TRACE(SD_LOG_ATTACH_DETACH, un,
7744 "sd_unit_attach: un:0x%p un_stats created\n", un);
7746 sd_create_errstats(un, instance);
7747 if (un->un_errstats == NULL) {
7750 SD_TRACE(SD_LOG_ATTACH_DETACH, un,
7751 "sd_unit_attach: un:0x%p errstats created\n", un);
7759 if (SD_IS_PARALLEL_SCSI(un) || SD_IS_SERIAL(un)) {
7768 un->un_tagflags = 0;
7770 (un->un_f_arq_enabled == TRUE)) {
7771 if (scsi_ifsetcap(SD_ADDRESS(un), "tagged-qing",
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),
7779 un->un_f_opt_queueing = TRUE;
7780 un->un_saved_throttle = un->un_throttle =
7781 min(un->un_throttle, 3);
7783 un->un_f_opt_queueing = FALSE;
7784 un->un_saved_throttle = un->un_throttle = 1;
7786 } else if ((scsi_ifgetcap(SD_ADDRESS(un), "untagged-qing", 0)
7787 == 1) && (un->un_f_arq_enabled == TRUE)) {
7789 un->un_f_opt_queueing = TRUE;
7790 un->un_saved_throttle = un->un_throttle =
7791 min(un->un_throttle, 3);
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);
7802 if (SD_IS_SERIAL(un)) {
7803 un->un_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);
7821 if (SD_IS_PARALLEL_SCSI(un) &&
7824 if (scsi_ifsetcap(SD_ADDRESS(un), "wide-xfer",
7826 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7827 "sd_unit_attach: un:0x%p Wide Transfer "
7828 "enabled\n", un);
7835 if (un->un_saved_throttle == sd_max_throttle) {
7836 un->un_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);
7844 if (scsi_ifsetcap(SD_ADDRESS(un), "wide-xfer",
7846 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7847 "sd_unit_attach: un:0x%p "
7848 "Wide Transfer disabled\n", un);
7852 un->un_tagflags = FLAG_STAG;
7853 un->un_max_xfer_size = ddi_getprop(DDI_DEV_T_ANY,
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);
7865 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_unit_attach: "
7866 "un:0x%p lun-reset capability not set\n", un);
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)) {
7881 un->un_max_xfer_size = max_xfer_size;
7882 if (un->un_partial_dma_supported == 0)
7883 un->un_partial_dma_supported = 1;
7885 if (ddi_prop_get_int(DDI_DEV_T_ANY, SD_DEVINFO(un),
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);
7898 if (un->un_partial_dma_supported == 1) {
7899 un->un_pkt_flags = PKT_DMA_PARTIAL;
7901 un->un_pkt_flags = 0;
7905 ssc = sd_ssc_init(un);
7911 un->un_fm_private =
7913 sfip = (struct sd_fm_internal *)un->un_fm_private;
7916 sfip->fm_ssc.ssc_un = un;
7918 if (ISCD(un) ||
7919 un->un_f_has_removable_media ||
7935 fm_scsi_log = ddi_prop_get_int(DDI_DEV_T_ANY, SD_DEVINFO(un),
7979 if (un->un_f_descr_format_supported) {
7988 SD_TRACE(SD_LOG_ATTACH_DETACH, un,
7989 "sd_unit_attach: un:0x%p spin-up successful\n", un);
8010 scsi_log(SD_DEVINFO(un),
8048 sd_update_block_info(un, lbasize, capacity);
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);
8064 scsi_log(SD_DEVINFO(un),
8077 SD_INFO(SD_LOG_ATTACH_DETACH, un,
8078 "sd_unit_attach: un:0x%p "
8080 "returned reservation conflict\n", un);
8105 SD_INFO(SD_LOG_ATTACH_DETACH, un,
8106 "sd_unit_attach: un:0x%p spin-up reservation "
8107 "conflict.\n", un);
8112 SD_INFO(SD_LOG_ATTACH_DETACH, un,
8113 "sd_unit_attach: un:0x%p spin-up failed.", un);
8122 if (ISCD(un)) {
8143 mutex_init(&un->un_pm_mutex, NULL, MUTEX_DRIVER, NULL);
8144 cv_init(&un->un_pm_busy_cv, NULL, CV_DRIVER, NULL);
8146 if (un->un_f_pm_is_enabled == FALSE) {
8158 if (un->un_f_non_devbsize_supported) {
8159 un->un_buf_chain_type = SD_CHAIN_INFO_RMMEDIA_NO_PM;
8161 un->un_buf_chain_type = SD_CHAIN_INFO_DISK_NO_PM;
8163 un->un_uscsi_chain_type = SD_CHAIN_INFO_USCSI_CMD_NO_PM;
8187 (void) scsi_ifsetcap(SD_ADDRESS(un), "qfull-retries",
8192 (void) scsi_ifsetcap(SD_ADDRESS(un), "qfull-retry-interval",
8204 un->un_mediastate = DKIO_NONE;
8216 cmlb_alloc_handle(&un->un_cmlbhandle);
8222 if (!un->un_f_has_removable_media && !un->un_f_is_hotpluggable &&
8223 (lbasize == un->un_sys_blocksize))
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,
8242 geom_label_valid = (cmlb_validate(un->un_cmlbhandle, 0,
8245 mutex_enter(SD_MUTEX(un));
8250 if (un->un_f_devid_supported) {
8253 mutex_exit(SD_MUTEX(un));
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);
8272 if (un->un_f_opt_disable_cache == TRUE) {
8279 SD_ERROR(SD_LOG_ATTACH_DETACH, un,
8280 "sd_unit_attach: un:0x%p Could not disable "
8281 "caching", un);
8291 mutex_enter(SD_MUTEX(un));
8292 un->un_f_write_cache_enabled = (wc_enabled != 0);
8293 mutex_exit(SD_MUTEX(un));
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)) {
8301 ddi_driver_name(SD_DEVINFO(un)),
8302 ddi_get_instance(SD_DEVINFO(un)));
8303 un->un_wm_cache = kmem_cache_create(
8307 (void *)un, NULL, 0);
8308 if (!(un->un_wm_cache)) {
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);
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;
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;
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);
8376 sd_set_errstats(un);
8377 SD_TRACE(SD_LOG_ATTACH_DETACH, un,
8378 "sd_unit_attach: un:0x%p errstats set\n", un);
8387 if (SD_IS_PARALLEL_SCSI(un) && (tgt >= 0) && (tgt < NTARGETS_WIDE)) {
8391 SD_TRACE(SD_LOG_ATTACH_DETACH, un,
8392 "sd_unit_attach: un:0x%p exit success\n", un);
8412 (void) scsi_ifsetcap(SD_ADDRESS(un), "lun-reset", 0, 1);
8413 (void) scsi_ifsetcap(SD_ADDRESS(un), "wide-xfer", 0, 1);
8421 (void) scsi_ifsetcap(SD_ADDRESS(un), "tagged-qing", 0, 1);
8424 if (un->un_f_is_fibre == FALSE) {
8425 (void) scsi_ifsetcap(SD_ADDRESS(un), "auto-rqsense", 0, 1);
8433 mutex_enter(SD_MUTEX(un));
8436 kmem_free(un->un_fm_private, sizeof (struct sd_fm_internal));
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));
8444 mutex_enter(SD_MUTEX(un));
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));
8453 mutex_enter(SD_MUTEX(un));
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));
8462 mutex_enter(SD_MUTEX(un));
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));
8471 mutex_enter(SD_MUTEX(un));
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));
8480 mutex_enter(SD_MUTEX(un));
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));
8489 mutex_enter(SD_MUTEX(un));
8492 mutex_exit(SD_MUTEX(un));
8495 ASSERT(un->un_ncmds_in_transport == 0);
8496 ASSERT(un->un_ncmds_in_driver == 0);
8499 sd_sync_with_callback(un);
8505 if (un->un_errstats != NULL) {
8506 kstat_delete(un->un_errstats);
8507 un->un_errstats = NULL;
8512 if (un->un_stats != NULL) {
8513 kstat_delete(un->un_stats);
8514 un->un_stats = NULL;
8517 ddi_xbuf_attr_unregister_devinfo(un->un_xbuf_attr, devi);
8518 ddi_xbuf_attr_destroy(un->un_xbuf_attr);
8521 sema_destroy(&un->un_semoclose);
8522 cv_destroy(&un->un_state_cv);
8526 sd_free_rqs(un);
8531 bzero(un, sizeof (struct sd_lun)); /* Clear any stale data! */
8567 struct sd_lun *un;
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)) {
8594 SD_TRACE(SD_LOG_ATTACH_DETACH, un, "sd_unit_detach: entry 0x%p\n", un);
8600 un->un_detach_count++;
8606 dev = sd_make_device(SD_DEVINFO(un));
8612 mutex_enter(SD_MUTEX(un));
8619 if (un->un_ocmap.lyropen[i] != 0) {
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,
8642 if ((un->un_resvd_status & SD_RESERVE) &&
8643 !(un->un_resvd_status & SD_LOST_RESERVE)) {
8644 mutex_exit(SD_MUTEX(un));
8650 SD_ERROR(SD_LOG_ATTACH_DETACH, un,
8654 mutex_exit(SD_MUTEX(un));
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));
8668 mutex_enter(SD_MUTEX(un));
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));
8676 mutex_enter(SD_MUTEX(un));
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));
8684 mutex_enter(SD_MUTEX(un));
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));
8692 mutex_enter(SD_MUTEX(un));
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));
8701 mutex_exit(SD_MUTEX(un));
8707 mutex_enter(SD_MUTEX(un));
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));
8715 mutex_enter(SD_MUTEX(un));
8719 if (un->un_mhd_token != NULL) {
8720 mutex_exit(SD_MUTEX(un));
8722 if (scsi_watch_request_terminate(un->un_mhd_token,
8724 SD_ERROR(SD_LOG_ATTACH_DETACH, un,
8734 mutex_enter(SD_MUTEX(un));
8735 un->un_mhd_token = NULL;
8738 if (un->un_swr_token != NULL) {
8739 mutex_exit(SD_MUTEX(un));
8741 if (scsi_watch_request_terminate(un->un_swr_token,
8743 SD_ERROR(SD_LOG_ATTACH_DETACH, un,
8753 mutex_enter(SD_MUTEX(un));
8754 un->un_swr_token = NULL;
8757 mutex_exit(SD_MUTEX(un));
8764 (void) scsi_reset_notify(SD_ADDRESS(un), SCSI_RESET_CANCEL,
8765 sd_mhd_reset_notify_cb, (caddr_t)un);
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);
8787 (void) pm_idle_component(SD_DEVINFO(un), 0);
8788 mutex_enter(&un->un_pm_mutex);
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);
8807 (void) pm_idle_component(SD_DEVINFO(un), 0);
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))
8814 SD_ERROR(SD_LOG_ATTACH_DETACH, un,
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);
8833 (void) pm_idle_component(SD_DEVINFO(un), 0);
8835 mutex_exit(&un->un_pm_mutex);
8845 (void) scsi_ifsetcap(SD_ADDRESS(un), "lun-reset", 0, 1);
8846 (void) scsi_ifsetcap(SD_ADDRESS(un), "wide-xfer", 0, 1);
8859 (void) scsi_ifsetcap(SD_ADDRESS(un), "tagged-qing", 0, 1);
8862 if (un->un_f_is_fibre == FALSE) {
8863 (void) scsi_ifsetcap(SD_ADDRESS(un), "auto-rqsense", 0, 1);
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) !=
8879 SD_ERROR(SD_LOG_ATTACH_DETACH, un,
8883 un->un_insert_event = NULL;
8885 if ((un->un_remove_event != NULL) &&
8886 (ddi_remove_event_handler(un->un_remove_cb_id) !=
8894 SD_ERROR(SD_LOG_ATTACH_DETACH, un,
8898 un->un_remove_event = NULL;
8902 sd_sync_with_callback(un);
8904 cmlb_detach(un->un_cmlbhandle, (void *)SD_PATH_DIRECT);
8905 cmlb_free_handle(&un->un_cmlbhandle);
8924 kmem_free(un->un_fm_private, sizeof (struct sd_fm_internal));
8930 if (un->un_f_devid_transport_defined == FALSE)
8937 if (un->un_devid) {
8938 ddi_devid_free(un->un_devid);
8939 un->un_devid = NULL;
8945 if (un->un_wm_cache != NULL) {
8946 kmem_cache_destroy(un->un_wm_cache);
8947 un->un_wm_cache = NULL;
8956 if (un->un_stats != NULL) {
8957 kstat_delete(un->un_stats);
8958 un->un_stats = NULL;
8960 if (un->un_errstats != NULL) {
8961 kstat_delete(un->un_errstats);
8962 un->un_errstats = NULL;
8966 if (un->un_f_pkstats_enabled) {
8968 if (un->un_pstats[i] != NULL) {
8969 kstat_delete(un->un_pstats[i]);
8970 un->un_pstats[i] = NULL;
8976 ddi_xbuf_attr_unregister_devinfo(un->un_xbuf_attr, devi);
8977 ddi_xbuf_attr_destroy(un->un_xbuf_attr);
8982 mutex_destroy(&un->un_pm_mutex);
8983 cv_destroy(&un->un_pm_busy_cv);
8985 cv_destroy(&un->un_wcc_cv);
8988 sema_destroy(&un->un_semoclose);
8991 cv_destroy(&un->un_state_cv);
8994 cv_destroy(&un->un_suspend_cv);
8995 cv_destroy(&un->un_disk_busy_cv);
8997 sd_free_rqs(un);
9002 bzero(un, sizeof (struct sd_lun));
9017 * Since un has been released, we can't use SD_IS_PARALLEL_SCSI(un) to
9029 mutex_exit(SD_MUTEX(un));
9036 un->un_detach_count--;
9039 SD_TRACE(SD_LOG_ATTACH_DETACH, un, "sd_unit_detach: exit failure\n");
9055 * Arguments: un - driver soft state (unit) structure
9062 sd_create_errstats(struct sd_lun *un, int instance)
9069 ASSERT(un != NULL);
9071 if (un->un_errstats != NULL) {
9080 un->un_errstats = kstat_create(kstatmodule_err, instance, kstatname,
9083 if (un->un_errstats == NULL) {
9084 SD_ERROR(SD_LOG_ATTACH_DETACH, un,
9089 stp = (struct sd_errstats *)un->un_errstats->ks_data;
9119 un->un_errstats->ks_private = un;
9120 un->un_errstats->ks_update = nulldev;
9122 kstat_install(un->un_errstats);
9138 * Arguments: un - driver soft state (unit) structure
9144 sd_set_errstats(struct sd_lun *un)
9149 ASSERT(un != NULL);
9150 ASSERT(un->un_errstats != NULL);
9151 stp = (struct sd_errstats *)un->un_errstats->ks_data;
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);
9156 un->un_sd->sd_inq->inq_revision, 4);
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)) {
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));
9190 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, SD_DEVINFO(un),
9199 if (un->un_f_blockcount_is_valid != TRUE) {
9208 * Multiply un_blockcount by un->un_sys_blocksize to get
9213 * (un_tgt_blocksize / un->un_sys_blocksize).
9216 ((uint64_t)un->un_blockcount * un->un_sys_blocksize);
9228 * Arguments: un - driver soft state (unit) structure
9234 sd_set_pstats(struct sd_lun *un)
9242 ASSERT(un != NULL);
9244 instance = ddi_get_instance(SD_DEVINFO(un));
9249 if (cmlb_partinfo(un->un_cmlbhandle, i,
9252 mutex_enter(SD_MUTEX(un));
9254 if ((un->un_pstats[i] == NULL) &&
9261 un->un_pstats[i] = kstat_create(sd_label,
9264 if (un->un_pstats[i] != NULL) {
9265 un->un_pstats[i]->ks_lock = SD_MUTEX(un);
9266 kstat_install(un->un_pstats[i]);
9269 mutex_exit(SD_MUTEX(un));
9281 * Arguments: un - driver soft state (unit) structure
9287 sd_init_event_callbacks(struct sd_lun *un)
9289 ASSERT(un != NULL);
9291 if ((un->un_insert_event == NULL) &&
9292 (ddi_get_eventcookie(SD_DEVINFO(un), FCAL_INSERT_EVENT,
9293 &un->un_insert_event) == DDI_SUCCESS)) {
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));
9302 if ((un->un_remove_event == NULL) &&
9303 (ddi_get_eventcookie(SD_DEVINFO(un), FCAL_REMOVE_EVENT,
9304 &un->un_remove_event) == DDI_SUCCESS)) {
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));
9322 * Arguments: un - driver soft state (unit) structure
9331 struct sd_lun *un = (struct sd_lun *)arg;
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;
9345 un->un_state = un->un_save_state;
9348 mutex_exit(SD_MUTEX(un));
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));
9358 if (un->un_state != SD_STATE_OFFLINE) {
9359 if (un->un_state != SD_STATE_SUSPENDED) {
9360 New_state(un, SD_STATE_OFFLINE);
9362 un->un_last_state = SD_STATE_OFFLINE;
9365 mutex_exit(SD_MUTEX(un));
9367 scsi_log(SD_DEVINFO(un), sd_label, CE_NOTE,
9404 struct sd_lun *un;
9408 un = ssc->ssc_un;
9409 ASSERT(un != NULL);
9419 if (un->un_f_cfg_is_atapi == TRUE) {
9437 if (un->un_f_cfg_is_atapi == TRUE) {
9446 SD_ERROR(SD_LOG_IOCTL_RMMEDIA, un,
9456 if (un->un_f_cfg_is_atapi == TRUE) {
9526 if (un->un_f_cfg_is_atapi == TRUE) {
9537 if (un->un_f_cfg_is_atapi == TRUE) {
9582 * un->un_f_write_cache_enabled:
9585 * set un->un_f_write_cache_enabled = FALSE
9589 * set un->un_f_write_cache_enabled = TRUE
9602 struct sd_lun *un;
9606 un = ssc->ssc_un;
9607 ASSERT(un != NULL);
9622 if (un->un_f_cfg_is_atapi == TRUE) {
9636 if (un->un_f_cfg_is_atapi == TRUE) {
9645 SD_ERROR(SD_LOG_IOCTL_RMMEDIA, un,
9655 if (un->un_f_cfg_is_atapi == TRUE) {
9739 * Arguments: un - driver soft state (unit) structure
9754 struct sd_lun *un;
9757 un = ssc->ssc_un;
9758 ASSERT(un != NULL);
9760 mutex_enter(SD_MUTEX(un));
9767 un->un_f_sync_nv_supported = FALSE;
9774 if (un->un_f_suppress_cache_flush == TRUE) {
9775 mutex_exit(SD_MUTEX(un));
9780 un->un_vpd_page_mask & SD_VPD_EXTENDED_DATA_PG) {
9781 mutex_exit(SD_MUTEX(un));
9789 SD_TRACE(SD_LOG_COMMON, un,
9795 mutex_enter(SD_MUTEX(un));
9802 un->un_f_sync_nv_supported = TRUE;
9804 mutex_exit(SD_MUTEX(un));
9811 mutex_exit(SD_MUTEX(un));
9819 mutex_enter(SD_MUTEX(un));
9820 if (un->un_f_sync_nv_supported) {
9821 mutex_exit(SD_MUTEX(un));
9824 (void) sd_send_scsi_SYNCHRONIZE_CACHE(un, dkc);
9836 mutex_exit(SD_MUTEX(un));
9839 SD_TRACE(SD_LOG_COMMON, un, "sd_get_nv_sup: \
9841 un->un_f_suppress_cache_flush);
9887 sd_pm_entry(struct sd_lun *un)
9891 ASSERT(!mutex_owned(SD_MUTEX(un)));
9892 ASSERT(!mutex_owned(&un->un_pm_mutex));
9894 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_entry: entry\n");
9896 if (un->un_f_pm_is_enabled == FALSE) {
9897 SD_TRACE(SD_LOG_IO_PM, un,
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);
9922 un->un_pm_busy = TRUE;
9924 if (un->un_pm_count < 1) {
9926 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_entry: busy component\n");
9934 mutex_exit(&un->un_pm_mutex);
9935 return_status = pm_busy_component(SD_DEVINFO(un), 0);
9938 mutex_enter(&un->un_pm_mutex);
9940 if (un->un_pm_count < 0) {
9941 mutex_exit(&un->un_pm_mutex);
9943 SD_TRACE(SD_LOG_IO_PM, un,
9952 return_status = pm_raise_power(SD_DEVINFO(un), 0,
9953 SD_PM_STATE_ACTIVE(un));
9955 mutex_enter(&un->un_pm_mutex);
9964 SD_TRACE(SD_LOG_IO_PM, un,
9968 (void) pm_idle_component(SD_DEVINFO(un), 0);
9969 un->un_pm_count--;
9976 ASSERT(un->un_pm_count == 0);
9989 mutex_exit(&un->un_pm_mutex);
9990 mutex_enter(SD_MUTEX(un));
9991 SD_TRACE(SD_LOG_IO_PM, un,
9993 un->un_uscsi_chain_type);
9995 if (un->un_f_non_devbsize_supported) {
9996 un->un_buf_chain_type =
9999 un->un_buf_chain_type =
10002 un->un_uscsi_chain_type = SD_CHAIN_INFO_USCSI_CMD_NO_PM;
10004 SD_TRACE(SD_LOG_IO_PM, un,
10006 un->un_uscsi_chain_type);
10007 mutex_exit(SD_MUTEX(un));
10008 mutex_enter(&un->un_pm_mutex);
10010 if (un->un_pm_idle_timeid == NULL) {
10012 un->un_pm_idle_timeid =
10013 timeout(sd_pm_idletimeout_handler, un,
10021 (void) pm_busy_component(SD_DEVINFO(un), 0);
10025 un->un_pm_busy = FALSE;
10027 cv_signal(&un->un_pm_busy_cv);
10029 un->un_pm_count++;
10031 SD_TRACE(SD_LOG_IO_PM, un,
10032 "sd_pm_entry: exiting, un_pm_count = %d\n", un->un_pm_count);
10034 mutex_exit(&un->un_pm_mutex);
10051 sd_pm_exit(struct sd_lun *un)
10053 ASSERT(!mutex_owned(SD_MUTEX(un)));
10054 ASSERT(!mutex_owned(&un->un_pm_mutex));
10056 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_exit: entry\n");
10062 if (un->un_f_pm_is_enabled == TRUE) {
10064 mutex_enter(&un->un_pm_mutex);
10065 un->un_pm_count--;
10067 SD_TRACE(SD_LOG_IO_PM, un,
10068 "sd_pm_exit: un_pm_count = %d\n", un->un_pm_count);
10070 ASSERT(un->un_pm_count >= 0);
10071 if (un->un_pm_count == 0) {
10072 mutex_exit(&un->un_pm_mutex);
10074 SD_TRACE(SD_LOG_IO_PM, un,
10077 (void) pm_idle_component(SD_DEVINFO(un), 0);
10080 mutex_exit(&un->un_pm_mutex);
10084 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_exit: exiting\n");
10110 struct sd_lun *un;
10133 if (((un = ddi_get_soft_state(sd_state, instance)) == NULL) ||
10134 (un->un_detach_count != 0)) {
10141 * un-conditionally clearing probe cache is ok with
10162 un->un_layer_count++;
10172 un->un_opens_in_progress++;
10183 sema_p(&un->un_semoclose);
10185 mutex_enter(SD_MUTEX(un));
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));
10200 mutex_exit(SD_MUTEX(un));
10201 if (sd_pm_entry(un) != DDI_SUCCESS) {
10203 SD_ERROR(SD_LOG_OPEN_CLOSE, un,
10207 mutex_enter(SD_MUTEX(un));
10211 SD_TRACE(SD_LOG_OPEN_CLOSE, un, "sdopen: un=%p\n", (void *)un);
10212 SD_TRACE(SD_LOG_OPEN_CLOSE, un,
10214 un->un_exclopen, flag, un->un_ocmap.regopen[otyp]);
10216 if (un->un_exclopen & (partmask)) {
10222 if (un->un_ocmap.lyropen[part]) {
10226 if (un->un_ocmap.regopen[i] & (partmask)) {
10241 if (un->un_f_chk_wp_open) {
10243 mutex_exit(SD_MUTEX(un));
10251 if (un->un_f_dvdram_writable_device == FALSE) {
10252 if (ISCD(un) || sr_check_wp(dev)) {
10254 mutex_enter(SD_MUTEX(un));
10255 SD_ERROR(SD_LOG_OPEN_CLOSE, un, "sdopen: "
10260 mutex_enter(SD_MUTEX(un));
10271 mutex_exit(SD_MUTEX(un));
10272 ssc = sd_ssc_init(un);
10275 mutex_enter(SD_MUTEX(un));
10283 if (rval == SD_READY_VALID && (!ISCD(un))) {
10285 mutex_exit(SD_MUTEX(un));
10286 (void) cmlb_partinfo(un->un_cmlbhandle, part, &nblks,
10288 mutex_enter(SD_MUTEX(un));
10292 (!ISCD(un) && nblks <= 0)) {
10293 rval = un->un_f_has_removable_media ? ENXIO : EIO;
10294 SD_ERROR(SD_LOG_OPEN_CLOSE, un, "sdopen: "
10306 cp = &un->un_ocmap.chkd[0];
10307 while (cp < &un->un_ocmap.chkd[OCSIZE]) {
10313 if (cp == &un->un_ocmap.chkd[OCSIZE]) {
10314 mutex_exit(SD_MUTEX(un));
10315 cmlb_invalidate(un->un_cmlbhandle,
10317 mutex_enter(SD_MUTEX(un));
10324 un->un_ocmap.lyropen[part]++;
10326 un->un_ocmap.regopen[otyp] |= partmask;
10331 un->un_exclopen |= (partmask);
10343 mutex_exit(SD_MUTEX(un));
10344 if (cmlb_efi_label_capacity(un->un_cmlbhandle, &label_cap,
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,
10354 mutex_enter(SD_MUTEX(un));
10357 mutex_enter(SD_MUTEX(un));
10361 SD_TRACE(SD_LOG_OPEN_CLOSE, un, "sdopen: "
10364 mutex_exit(SD_MUTEX(un));
10366 sd_pm_exit(un);
10369 sema_v(&un->un_semoclose);
10372 un->un_opens_in_progress--;
10375 SD_TRACE(SD_LOG_OPEN_CLOSE, un, "sdopen: exit success\n");
10379 SD_ERROR(SD_LOG_OPEN_CLOSE, un, "sdopen: fail exclusive open\n");
10383 mutex_exit(SD_MUTEX(un));
10389 sd_pm_exit(un);
10392 sema_v(&un->un_semoclose);
10395 un->un_opens_in_progress--;
10397 un->un_layer_count--;
10423 struct sd_lun *un;
10434 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
10441 SD_TRACE(SD_LOG_OPEN_CLOSE, un,
10448 sema_p(&un->un_semoclose);
10450 mutex_enter(SD_MUTEX(un));
10453 while (un->un_state == SD_STATE_PM_CHANGING) {
10454 cv_wait(&un->un_suspend_cv, SD_MUTEX(un));
10457 if (un->un_exclopen & (1 << part)) {
10458 un->un_exclopen &= ~(1 << part);
10463 un->un_ocmap.lyropen[part] -= 1;
10465 un->un_ocmap.regopen[otyp] &= ~(1 << part);
10468 cp = &un->un_ocmap.chkd[0];
10469 while (cp < &un->un_ocmap.chkd[OCSIZE]) {
10476 if (cp == &un->un_ocmap.chkd[OCSIZE]) {
10477 SD_TRACE(SD_LOG_OPEN_CLOSE, un, "sdclose: last close\n");
10483 un->un_throttle = un->un_saved_throttle;
10485 if (un->un_state == SD_STATE_OFFLINE) {
10486 if (un->un_f_is_fibre == FALSE) {
10487 scsi_log(SD_DEVINFO(un), sd_label,
10490 mutex_exit(SD_MUTEX(un));
10491 cmlb_invalidate(un->un_cmlbhandle,
10493 mutex_enter(SD_MUTEX(un));
10515 if ((un->un_f_sync_cache_supported &&
10516 un->un_f_sync_cache_required) ||
10517 un->un_f_dvdram_writable_device == TRUE) {
10519 if (un->un_f_dvdram_writable_device == TRUE) {
10521 mutex_exit(SD_MUTEX(un));
10522 if (sd_pm_entry(un) == DDI_SUCCESS) {
10524 sd_send_scsi_SYNCHRONIZE_CACHE(un,
10532 sd_pm_exit(un);
10536 mutex_enter(SD_MUTEX(un));
10545 if (un->un_f_doorlock_supported) {
10546 mutex_exit(SD_MUTEX(un));
10547 if (sd_pm_entry(un) == DDI_SUCCESS) {
10550 ssc = sd_ssc_init(un);
10558 sd_pm_exit(un);
10559 if (ISCD(un) && (rval != 0) &&
10566 mutex_enter(SD_MUTEX(un));
10574 if (un->un_f_has_removable_media) {
10575 sr_ejected(un);
10583 if (un->un_wm_cache) {
10589 if (un->un_ncmds_in_driver > 0) {
10590 scsi_log(SD_DEVINFO(un),
10596 un->un_wm_cache);
10597 un->un_wm_cache = NULL;
10603 mutex_exit(SD_MUTEX(un));
10604 sema_v(&un->un_semoclose);
10612 un->un_layer_count--;
10625 * Arguments: ssc - sd_ssc_t will contain un
10626 * un - driver soft state (unit) structure
10644 struct sd_lun *un;
10648 un = ssc->ssc_un;
10649 ASSERT(un != NULL);
10650 ASSERT(!mutex_owned(SD_MUTEX(un)));
10652 mutex_enter(SD_MUTEX(un));
10657 if (un->un_f_has_removable_media) {
10658 mutex_exit(SD_MUTEX(un));
10663 mutex_enter(SD_MUTEX(un));
10671 is_valid = SD_IS_VALID_LABEL(un);
10672 mutex_enter(SD_MUTEX(un));
10674 (un->un_f_blockcount_is_valid == FALSE) ||
10675 (un->un_f_tgt_blocksize_is_valid == FALSE)) {
10678 mutex_exit(SD_MUTEX(un));
10685 cmlb_invalidate(un->un_cmlbhandle,
10687 mutex_enter(SD_MUTEX(un));
10692 mutex_enter(SD_MUTEX(un));
10693 sd_update_block_info(un, lbasize, capacity);
10700 if (!is_valid && ISCD(un)) {
10709 mutex_exit(SD_MUTEX(un));
10716 mutex_enter(SD_MUTEX(un));
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)) {
10733 ddi_driver_name(SD_DEVINFO(un)),
10734 ddi_get_instance(SD_DEVINFO(un)));
10735 un->un_wm_cache = kmem_cache_create(
10739 (void *)un, NULL, 0);
10740 if (!(un->un_wm_cache)) {
10747 if (un->un_state == SD_STATE_NORMAL) {
10761 mutex_exit(SD_MUTEX(un));
10763 mutex_enter(SD_MUTEX(un));
10766 mutex_exit(SD_MUTEX(un));
10767 cmlb_invalidate(un->un_cmlbhandle,
10769 mutex_enter(SD_MUTEX(un));
10771 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
10776 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
10785 if (un->un_f_format_in_progress == FALSE) {
10786 mutex_exit(SD_MUTEX(un));
10788 (void) cmlb_validate(un->un_cmlbhandle, 0,
10790 if (cmlb_partinfo(un->un_cmlbhandle, part, NULL, NULL, NULL,
10793 mutex_enter(SD_MUTEX(un));
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);
10803 mutex_enter(SD_MUTEX(un));
10811 if (un->un_f_doorlock_supported) {
10812 mutex_exit(SD_MUTEX(un));
10816 if ((status != 0) && ISCD(un)) {
10818 mutex_enter(SD_MUTEX(un));
10825 mutex_enter(SD_MUTEX(un));
10829 un->un_mediastate = DKIO_INSERTED;
10830 cv_broadcast(&un->un_state_cv);
10840 if (un->un_errstats != NULL) {
10841 stp = (struct sd_errstats *)un->un_errstats->ks_data;
10843 (un->un_f_blockcount_is_valid == TRUE)) {
10845 (uint64_t)((uint64_t)un->un_blockcount *
10846 un->un_sys_blocksize);
10850 mutex_exit(SD_MUTEX(un));
10869 struct sd_lun *un;
10874 un = ddi_get_soft_state(sd_state, instance);
10875 ASSERT(un != NULL);
10881 if (un->un_buf_breakup_supported) {
10885 if (bp->b_bcount > un->un_max_xfer_size) {
10886 bp->b_bcount = un->un_max_xfer_size;
10912 struct sd_lun *un = NULL;
10917 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
10921 ASSERT(!mutex_owned(SD_MUTEX(un)));
10924 if (!SD_IS_VALID_LABEL(un) && !ISCD(un)) {
10925 mutex_enter(SD_MUTEX(un));
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));
10935 un->un_ncmds_in_driver++;
10936 mutex_exit(SD_MUTEX(un));
10939 ssc = sd_ssc_init(un);
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));
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;
10965 SD_ERROR(SD_LOG_READ_WRITE, un,
10970 SD_ERROR(SD_LOG_READ_WRITE, un,
11003 struct sd_lun *un = NULL;
11008 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
11012 ASSERT(!mutex_owned(SD_MUTEX(un)));
11014 if (!SD_IS_VALID_LABEL(un) && !ISCD(un)) {
11015 mutex_enter(SD_MUTEX(un));
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));
11025 un->un_ncmds_in_driver++;
11026 mutex_exit(SD_MUTEX(un));
11029 ssc = sd_ssc_init(un);
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));
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;
11055 SD_ERROR(SD_LOG_READ_WRITE, un,
11060 SD_ERROR(SD_LOG_READ_WRITE, un,
11092 struct sd_lun *un = NULL;
11098 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
11102 ASSERT(!mutex_owned(SD_MUTEX(un)));
11104 if (!SD_IS_VALID_LABEL(un) && !ISCD(un)) {
11105 mutex_enter(SD_MUTEX(un));
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));
11115 un->un_ncmds_in_driver++;
11116 mutex_exit(SD_MUTEX(un));
11119 ssc = sd_ssc_init(un);
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));
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;
11145 SD_ERROR(SD_LOG_READ_WRITE, un,
11150 SD_ERROR(SD_LOG_READ_WRITE, un,
11182 struct sd_lun *un = NULL;
11188 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
11192 ASSERT(!mutex_owned(SD_MUTEX(un)));
11194 if (!SD_IS_VALID_LABEL(un) && !ISCD(un)) {
11195 mutex_enter(SD_MUTEX(un));
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));
11205 un->un_ncmds_in_driver++;
11206 mutex_exit(SD_MUTEX(un));
11209 ssc = sd_ssc_init(un);
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));
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;
11235 SD_ERROR(SD_LOG_READ_WRITE, un,
11240 SD_ERROR(SD_LOG_READ_WRITE, un,
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.
11459 struct sd_lun *un;
11461 un = ddi_get_soft_state(sd_state, SD_GET_INSTANCE_FROM_BUF(bp));
11462 if (un == NULL) {
11470 if (un->un_state == SD_STATE_DUMPING) {
11477 ASSERT(!mutex_owned(SD_MUTEX(un)));
11485 mutex_enter(SD_MUTEX(un));
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));
11495 un->un_ncmds_in_driver++;
11502 if (un->un_f_cfg_is_atapi == TRUE) {
11503 mutex_exit(SD_MUTEX(un));
11505 mutex_enter(SD_MUTEX(un));
11507 SD_INFO(SD_LOG_IO, un, "sdstrategy: un_ncmds_in_driver = %ld\n",
11508 un->un_ncmds_in_driver);
11511 un->un_f_sync_cache_required = TRUE;
11513 mutex_exit(SD_MUTEX(un));
11521 return (ddi_xbuf_qstrategy(bp, un->un_xbuf_attr));
11537 struct sd_lun *un = arg;
11541 ASSERT(un != NULL);
11542 ASSERT(!mutex_owned(SD_MUTEX(un)));
11548 sd_xbuf_init(un, bp, xp, SD_CHAIN_BUFIO, NULL);
11551 SD_BEGIN_IOSTART(((struct sd_xbuf *)xp)->xb_chain_iostart, un, bp);
11560 * Arguments: un - ptr to softstate
11576 sd_xbuf_init(struct sd_lun *un, struct buf *bp, struct sd_xbuf *xp,
11581 ASSERT(un != NULL);
11585 SD_INFO(SD_LOG_IO, un, "sd_xbuf_init: buf:0x%p chain type:0x%x\n",
11588 xp->xb_un = un;
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)) {
11612 if (un->un_f_enable_rmw) {
11614 (un->un_phy_blocksize / DEV_BSIZE) - 1;
11615 secmask = un->un_phy_blocksize - 1;
11618 (un->un_tgt_blocksize / DEV_BSIZE) - 1;
11619 secmask = un->un_tgt_blocksize - 1;
11624 if ((un->un_f_rmw_type !=
11626 un->un_f_enable_rmw) {
11627 if (un->un_f_pm_is_enabled == FALSE)
11638 index = un->un_uscsi_chain_type;
11641 index = un->un_direct_chain_type;
11644 index = un->un_priority_chain_type;
11679 SD_INFO(SD_LOG_IO, un, "sd_xbuf_init: done.\n");
11698 struct sd_lun *un;
11706 un = ddi_get_soft_state(sd_state, SD_GET_INSTANCE_FROM_BUF(bp));
11707 if (un == NULL) {
11714 ASSERT(!mutex_owned(SD_MUTEX(un)));
11716 SD_TRACE(SD_LOG_IO, un, "sd_uscsi_strategy: entry: buf:0x%p\n", bp);
11725 mutex_enter(SD_MUTEX(un));
11731 if (un->un_f_cfg_is_atapi == TRUE) {
11732 mutex_exit(SD_MUTEX(un));
11734 mutex_enter(SD_MUTEX(un));
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);
11742 un->un_f_sync_cache_required = TRUE;
11744 mutex_exit(SD_MUTEX(un));
11771 sd_xbuf_init(un, bp, xp, chain_type, uip->ui_cmdp);
11774 SD_BEGIN_IOSTART(xp->xb_chain_iostart, un, bp);
11776 SD_TRACE(SD_LOG_IO, un, "sd_uscsi_strategy: exit: buf:0x%p\n", bp);
11813 struct sd_lun *un;
11817 un = ddi_get_soft_state(sd_state, SDUNIT(dev));
11818 if (un == NULL) {
11825 ssc = sd_ssc_init(un);
11887 * Arguments: un - pointer to driver soft state (unit) structure for this
11897 sd_ssc_init(struct sd_lun *un)
11903 ASSERT(un != NULL);
11904 ASSERT(!mutex_owned(SD_MUTEX(un)));
11923 ssc->ssc_un = un;
11985 struct sd_lun *un;
11992 un = ssc->ssc_un;
11993 ASSERT(un != NULL);
11996 ASSERT(!mutex_owned(SD_MUTEX(un)));
12006 SD_INFO(SD_LOG_SDTEST, un,
12025 * if USCSI_PMFAILFAST is set and un is in low power, fail the
12028 mutex_enter(SD_MUTEX(un));
12029 mutex_enter(&un->un_pm_mutex);
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));
12038 mutex_exit(&un->un_pm_mutex);
12039 mutex_exit(SD_MUTEX(un));
12044 SD_TRACE(SD_LOG_IO, un,
12045 "sd_ssc_send: entry: un:0x%p UIO_USERSPACE\n", un);
12048 SD_TRACE(SD_LOG_IO, un,
12049 "sd_ssc_send: entry: un:0x%p UIO_SYSSPACE\n", un);
12052 SD_TRACE(SD_LOG_IO, un,
12053 "sd_ssc_send: entry: un:0x%p UNEXPECTED SPACE\n", un);
12059 SD_ADDRESS(un), &uscmd);
12061 SD_TRACE(SD_LOG_IO, un, "sd_sense_scsi_cmd: "
12062 "scsi_uscsi_alloc_and_copyin failed\n", un);
12068 mutex_enter(SD_MUTEX(un));
12069 un->un_f_format_in_progress = TRUE;
12070 mutex_exit(SD_MUTEX(un));
12095 dev = SD_GET_DEV(un);
12106 SD_INFO(SD_LOG_IO, un, "sd_ssc_send: "
12110 SD_INFO(SD_LOG_IO, un, "sd_ssc_send: "
12114 SD_DUMP_MEMORY(un, SD_LOG_IO,
12122 mutex_enter(SD_MUTEX(un));
12123 un->un_f_format_in_progress = FALSE;
12124 mutex_exit(SD_MUTEX(un));
12213 struct sd_lun *un;
12216 un = ssc->ssc_un;
12217 ASSERT(un != NULL);
12231 SD_INFO(SD_LOG_SDTEST, un,
12294 (un->un_f_arq_enabled == TRUE) &&
12304 scsi_log(SD_DEVINFO(un), sd_label, CE_CONT,
12327 struct sd_lun *un;
12331 un = ssc->ssc_un;
12332 ASSERT(un != NULL);
12342 if (ISCD(un) || un->un_f_has_removable_media) {
12438 sd_buf_iodone(int index, struct sd_lun *un, struct buf *bp)
12442 ASSERT(un != NULL);
12444 ASSERT(!mutex_owned(SD_MUTEX(un)));
12446 SD_TRACE(SD_LOG_IO_CORE, un, "sd_buf_iodone: entry.\n");
12452 if (ddi_xbuf_done(bp, un->un_xbuf_attr)) {
12453 mutex_enter(SD_MUTEX(un));
12462 un->un_pm_idle_time = gethrtime();
12464 un->un_ncmds_in_driver--;
12465 ASSERT(un->un_ncmds_in_driver >= 0);
12466 SD_INFO(SD_LOG_IO, un,
12468 un->un_ncmds_in_driver);
12470 mutex_exit(SD_MUTEX(un));
12475 SD_TRACE(SD_LOG_IO_CORE, un, "sd_buf_iodone: exit.\n");
12488 sd_uscsi_iodone(int index, struct sd_lun *un, struct buf *bp)
12492 ASSERT(un != NULL);
12497 ASSERT(!mutex_owned(SD_MUTEX(un)));
12499 SD_INFO(SD_LOG_IO, un, "sd_uscsi_iodone: entry.\n");
12503 mutex_enter(SD_MUTEX(un));
12512 un->un_pm_idle_time = gethrtime();
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);
12519 mutex_exit(SD_MUTEX(un));
12531 SD_INFO(SD_LOG_IO, un, "sd_uscsi_iodone: exit.\n");
12569 sd_mapblockaddr_iostart(int index, struct sd_lun *un, struct buf *bp)
12581 ASSERT(un != NULL);
12583 ASSERT(!mutex_owned(SD_MUTEX(un)));
12585 SD_TRACE(SD_LOG_IO_PARTITION, un,
12599 if (!SD_IS_VALID_LABEL(un)) {
12606 ssc = sd_ssc_init(un);
12618 if (!un->un_f_has_removable_media) {
12619 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
12624 SD_BEGIN_IODONE(index, un, bp);
12633 (void) cmlb_partinfo(un->un_cmlbhandle, partition,
12636 if (un->un_f_enable_rmw) {
12637 blknomask = (un->un_phy_blocksize / DEV_BSIZE) - 1;
12638 secmask = un->un_phy_blocksize - 1;
12640 blknomask = (un->un_tgt_blocksize / DEV_BSIZE) - 1;
12641 secmask = un->un_tgt_blocksize - 1;
12648 if (!(NOT_DEVBSIZE(un)) || un->un_f_enable_rmw) {
12655 xp->xb_blkno = SD_SYS2TGTBLOCK(un, xp->xb_blkno);
12663 } else if (!un->un_f_enable_rmw &&
12664 un->un_f_rmw_type == SD_RMW_TYPE_RETURN_ERROR) {
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,
12677 un->un_tgt_blocksize);
12678 un->un_rmw_msg_timeid =
12680 un, SD_RMW_MSG_PRINT_TIMEOUT);
12682 un->un_rmw_incre_count ++;
12684 mutex_exit(SD_MUTEX(un));
12687 nblocks = SD_TGT2SYSBLOCK(un, nblocks);
12688 partition_offset = SD_TGT2SYSBLOCK(un,
12722 if ((!NOT_DEVBSIZE(un)) && is_aligned) {
12723 requested_nblocks = SD_BYTES2TGTBLOCKS(un, bp->b_bcount);
12742 if ((!NOT_DEVBSIZE(un)) && is_aligned) {
12743 resid = SD_TGTBLOCKS2BYTES(un,
12770 SD_NEXT_IOSTART(index, un, bp);
12772 SD_TRACE(SD_LOG_IO_PARTITION, un,
12779 SD_BEGIN_IODONE(index, un, bp);
12780 SD_TRACE(SD_LOG_IO_PARTITION, un,
12794 sd_mapblockaddr_iodone(int index, struct sd_lun *un, struct buf *bp)
12797 ASSERT(un != NULL);
12799 ASSERT(!mutex_owned(SD_MUTEX(un)));
12801 SD_TRACE(SD_LOG_IO_PARTITION, un,
12843 * xp->xb_blkno -= un->un_offset[partition];
12846 SD_NEXT_IODONE(index, un, bp);
12848 SD_TRACE(SD_LOG_IO_PARTITION, un,
12856 * Description: Convert between system block size (un->un_sys_blocksize)
12857 * and target block size (un->un_tgt_blocksize).
12875 sd_mapblocksize_iostart(int index, struct sd_lun *un, struct buf *bp)
12884 ASSERT(un != NULL);
12886 ASSERT(!mutex_owned(SD_MUTEX(un)));
12889 SD_TRACE(SD_LOG_IO_RMMEDIA, un,
12895 if (ISCD(un) && ((bp->b_flags & B_READ) == 0) &&
12896 (un->un_f_mmc_writable_media == FALSE)) {
12899 SD_BEGIN_IODONE(index, un, bp);
12905 * un->un_sys_blocksize as its block size or if bcount == 0.
12908 if ((un->un_tgt_blocksize == DEV_BSIZE && !un->un_f_enable_rmw) ||
12915 ASSERT(!ISROD(un));
12921 SD_INFO(SD_LOG_IO_RMMEDIA, un, "sd_mapblocksize_iostart: "
12923 un->un_tgt_blocksize, DEV_BSIZE);
12924 SD_INFO(SD_LOG_IO_RMMEDIA, un, "sd_mapblocksize_iostart: "
12926 SD_INFO(SD_LOG_IO_RMMEDIA, un, "sd_mapblocksize_iostart: "
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.
12967 if (un->un_f_enable_rmw) {
12969 (first_byte / un->un_phy_blocksize) *
12970 (un->un_phy_blocksize / DEV_BSIZE);
12972 un->un_phy_blocksize - 1) / un->un_phy_blocksize) *
12973 (un->un_phy_blocksize / DEV_BSIZE);
12975 start_block = xp->xb_blkno = first_byte / un->un_tgt_blocksize;
12977 un->un_tgt_blocksize - 1) / un->un_tgt_blocksize;
12981 request_bytes = (end_block - start_block) * un->un_tgt_blocksize;
12985 * length are aligned on a un->un_tgt_blocksize boundary. If aligned
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)) {
12994 if (((first_byte % un->un_tgt_blocksize) == 0) &&
12995 ((bp->b_bcount % un->un_tgt_blocksize) == 0)) {
13006 bsp->mbs_wmp = sd_range_lock(un, start_block, end_block - 1,
13054 if (un->un_f_enable_rmw) {
13056 ((offset_t)xp->xb_blkno * un->un_sys_blocksize));
13058 (bsp->mbs_copy_offset < un->un_phy_blocksize));
13061 ((offset_t)xp->xb_blkno * un->un_tgt_blocksize));
13063 (bsp->mbs_copy_offset < un->un_tgt_blocksize));
13082 SD_INFO(SD_LOG_IO_RMMEDIA, un,
13084 SD_INFO(SD_LOG_IO_RMMEDIA, un,
13087 SD_INFO(SD_LOG_IO_RMMEDIA, un,
13091 SD_NEXT_IOSTART(index, un, bp);
13093 SD_TRACE(SD_LOG_IO_RMMEDIA, un,
13107 sd_mapblocksize_iodone(int index, struct sd_lun *un, struct buf *bp)
13122 ASSERT(un != NULL);
13125 SD_TRACE(SD_LOG_IO_RMMEDIA, un,
13130 * using un->un_sys_blocksize as its block size or if bcount == 0.
13132 if ((un->un_tgt_blocksize == DEV_BSIZE && !un->un_f_enable_rmw) ||
13152 sd_range_unlock(un, bsp->mbs_wmp);
13168 ASSERT(!mutex_owned(SD_MUTEX(un)));
13180 sd_range_unlock(un, bsp->mbs_wmp);
13199 if (un->un_f_enable_rmw) {
13202 shadow_start = SD_TGTBLOCKS2BYTES(un, (offset_t)xp->xb_blkno);
13214 if (un->un_f_enable_rmw) {
13216 (copy_offset < un->un_phy_blocksize));
13219 (copy_offset < un->un_tgt_blocksize));
13312 * shadow buf (with its un->un_tgt_blocksize blocks) and the
13313 * original buf (with its un->un_sys_blocksize blocks).
13361 SD_NEXT_IODONE(index, un, bp);
13375 sd_checksum_iostart(int index, struct sd_lun *un, struct buf *bp)
13377 ASSERT(un != NULL);
13379 ASSERT(!mutex_owned(SD_MUTEX(un)));
13380 SD_NEXT_IOSTART(index, un, bp);
13394 sd_checksum_iodone(int index, struct sd_lun *un, struct buf *bp)
13396 ASSERT(un != NULL);
13398 ASSERT(!mutex_owned(SD_MUTEX(un)));
13399 SD_NEXT_IODONE(index, un, bp);
13413 sd_checksum_uscsi_iostart(int index, struct sd_lun *un, struct buf *bp)
13415 ASSERT(un != NULL);
13417 ASSERT(!mutex_owned(SD_MUTEX(un)));
13418 SD_NEXT_IOSTART(index, un, bp);
13432 sd_checksum_uscsi_iodone(int index, struct sd_lun *un, struct buf *bp)
13434 ASSERT(un != NULL);
13436 ASSERT(!mutex_owned(SD_MUTEX(un)));
13437 SD_NEXT_IODONE(index, un, bp);
13450 sd_pm_iostart(int index, struct sd_lun *un, struct buf *bp)
13452 ASSERT(un != NULL);
13454 ASSERT(!mutex_owned(SD_MUTEX(un)));
13455 ASSERT(!mutex_owned(&un->un_pm_mutex));
13457 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_iostart: entry\n");
13459 if (sd_pm_entry(un) != DDI_SUCCESS) {
13467 SD_BEGIN_IODONE(index, un, bp);
13469 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_iostart: exit\n");
13473 SD_NEXT_IOSTART(index, un, bp);
13475 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_iostart: exit\n");
13488 sd_pm_iodone(int index, struct sd_lun *un, struct buf *bp)
13490 ASSERT(un != NULL);
13492 ASSERT(!mutex_owned(&un->un_pm_mutex));
13494 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_iodone: entry\n");
13500 if (un->un_f_pm_is_enabled == TRUE) {
13501 sd_pm_exit(un);
13504 SD_NEXT_IODONE(index, un, bp);
13506 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_iodone: exit\n");
13521 * the device, as specified in un->un_tgt_blocksize.
13525 sd_core_iostart(int index, struct sd_lun *un, struct buf *bp)
13529 ASSERT(un != NULL);
13531 ASSERT(!mutex_owned(SD_MUTEX(un)));
13534 SD_TRACE(SD_LOG_IO_CORE, un, "sd_core_iostart: entry: bp:0x%p\n", bp);
13539 mutex_enter(SD_MUTEX(un));
13546 (un->un_failfast_state == SD_FAILFAST_ACTIVE)) {
13547 mutex_exit(SD_MUTEX(un));
13550 SD_BEGIN_IODONE(index, un, bp);
13562 sd_start_cmds(un, bp);
13568 sd_add_buf_to_waitq(un, bp);
13569 SD_UPDATE_KSTATS(un, kstat_waitq_enter, bp);
13570 sd_start_cmds(un, NULL);
13573 mutex_exit(SD_MUTEX(un));
13575 SD_TRACE(SD_LOG_IO_CORE, un, "sd_core_iostart: exit: bp:0x%p\n", bp);
13605 sd_init_cdb_limits(struct sd_lun *un)
13614 un->un_mincdb = SD_CDB_GROUP1;
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;
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;
13629 } else if (0 < un->un_max_hba_cdb &&
13630 un->un_max_hba_cdb < CDB_GROUP1) {
13632 } else if (CDB_GROUP1 <= un->un_max_hba_cdb &&
13633 un->un_max_hba_cdb < CDB_GROUP5) {
13635 } else if (CDB_GROUP5 <= un->un_max_hba_cdb &&
13636 un->un_max_hba_cdb < CDB_GROUP4) {
13648 un->un_maxcdb = (un->un_f_has_removable_media) ? SD_CDB_GROUP5 :
13651 un->un_maxcdb = (un->un_f_has_removable_media) ? SD_CDB_GROUP5 :
13655 un->un_status_len = (int)((un->un_f_arq_enabled == TRUE)
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;
13690 struct sd_lun *un;
13700 un = SD_GET_UN(bp);
13701 ASSERT(un != NULL);
13702 ASSERT(mutex_owned(SD_MUTEX(un)));
13705 SD_TRACE(SD_LOG_IO_CORE, un,
13708 mutex_exit(SD_MUTEX(un));
13729 blockcount = SD_BYTES2TGTBLOCKS(un, bp->b_bcount);
13731 cmd_flags = un->un_pkt_flags | (xp->xb_pkt_flags & SD_XB_INITPKT_MASK);
13737 rval = sd_setup_rw_pkt(un, &pktp, bp,
13738 cmd_flags, sdrunout, (caddr_t)un,
13748 if ((un->un_pkt_flags & PKT_DMA_PARTIAL) != 0 &&
13764 pktp->pkt_flags = un->un_tagflags;
13765 pktp->pkt_time = un->un_cmd_timeout;
13771 SD_TRACE(SD_LOG_IO_CORE, un,
13778 mutex_enter(SD_MUTEX(un));
13796 mutex_enter(SD_MUTEX(un));
13797 New_state(un, SD_STATE_RWAIT);
13799 SD_ERROR(SD_LOG_IO_CORE, un,
13813 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
13816 SD_ERROR(SD_LOG_IO_CORE, un,
13818 mutex_enter(SD_MUTEX(un));
13865 sd_setup_rw_pkt(struct sd_lun *un,
13878 for (i = un->un_mincdb; i <= un->un_maxcdb; i++) {
13900 return_pktp = scsi_init_pkt(SD_ADDRESS(un), *pktpp,
13901 bp, cp->sc_grpcode, un->un_status_len, 0,
13927 SD_BYTES2TGTBLOCKS(un,
13941 SD_FILL_SCSI1_LUN(un, return_pktp);
14008 sd_setup_next_rw_pkt(struct sd_lun *un,
14033 if (scsi_init_pkt(SD_ADDRESS(un), pktp, bp, 0, 0, 0, 0,
14038 SD_BYTES2TGTBLOCKS(un, pktp->pkt_resid);
14042 SD_FILL_SCSI1_LUN(un, pktp);
14095 struct sd_lun *un;
14102 un = SD_GET_UN(bp);
14103 ASSERT(un != NULL);
14104 ASSERT(mutex_owned(SD_MUTEX(un)));
14110 SD_TRACE(SD_LOG_IO_CORE, un,
14126 pktp = scsi_init_pkt(SD_ADDRESS(un), NULL,
14130 (un->un_pkt_flags & ~PKT_DMA_PARTIAL) | PKT_XARQ,
14131 sdrunout, (caddr_t)un);
14133 pktp = scsi_init_pkt(SD_ADDRESS(un), NULL,
14136 (un->un_pkt_flags & ~PKT_DMA_PARTIAL),
14137 sdrunout, (caddr_t)un);
14147 New_state(un, SD_STATE_RWAIT);
14149 SD_ERROR(SD_LOG_IO_CORE, un,
14162 if ((un->un_pkt_flags & PKT_DMA_PARTIAL) &&
14165 SD_ERROR(SD_LOG_IO_CORE, un, "sd_initpkt_for_uscsi: "
14174 SD_FILL_SCSI1_LUN(un, pktp);
14193 if (un->un_f_is_fibre == FALSE) {
14222 flags |= un->un_tagflags & FLAG_TAGMASK;
14239 pktp->pkt_time = un->un_uscsi_timeout;
14253 SD_TRACE(SD_LOG_IO_CORE, un,
14276 struct sd_lun *un;
14282 un = SD_GET_UN(bp);
14283 ASSERT(un != NULL);
14284 ASSERT(!mutex_owned(SD_MUTEX(un)));
14288 SD_TRACE(SD_LOG_IO_CORE, un,
14336 SD_TRACE(SD_LOG_IO_CORE, un,
14364 struct sd_lun *un;
14372 un = SD_GET_UN(bp);
14373 ASSERT(un != NULL);
14374 ASSERT(!mutex_owned(SD_MUTEX(un)));
14376 new_bp = bioclone(bp, 0, datalen, SD_GET_DEV(un), blkno, func,
14423 struct sd_lun *un;
14431 un = SD_GET_UN(bp);
14432 ASSERT(un != NULL);
14433 ASSERT(!mutex_owned(SD_MUTEX(un)));
14447 new_bp = scsi_alloc_consistent_buf(SD_ADDRESS(un), NULL,
14577 sd_print_transport_rejected_message(struct sd_lun *un, struct sd_xbuf *xp,
14580 ASSERT(un != NULL);
14581 ASSERT(mutex_owned(SD_MUTEX(un)));
14593 * gone off-line). This uses the un->un_tran_fatal_count
14602 (SD_FM_LOG(un) == SD_FM_LOG_NSUP)) {
14605 (un->un_tran_fatal_count == 1)) {
14608 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
14612 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
14616 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
14644 sd_add_buf_to_waitq(struct sd_lun *un, struct buf *bp)
14649 ASSERT(un != NULL);
14650 ASSERT(mutex_owned(SD_MUTEX(un)));
14653 if (un->un_waitq_headp == NULL) {
14654 ASSERT(un->un_waitq_tailp == NULL);
14655 un->un_waitq_headp = un->un_waitq_tailp = bp;
14660 ASSERT(un->un_waitq_tailp != NULL);
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;
14677 * The un->un_waitq_headp is an activity chain pointer on which
14691 ap = un->un_waitq_headp;
14756 if (ap == un->un_waitq_tailp) {
14757 un->un_waitq_tailp = bp;
14767 * Arguments: un - pointer to the unit (soft state) struct for the target.
14780 sd_start_cmds(struct sd_lun *un, struct buf *immed_bp)
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);
14796 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_start_cmds: entry\n");
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,
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 ==
14849 * Also we must clear un->un_retry_statp to
14853 if ((un->un_retry_statp == kstat_waitq_enter) ||
14854 (un->un_retry_statp ==
14859 saved_statp = un->un_retry_statp;
14861 un->un_retry_statp = NULL;
14863 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un,
14864 "sd_start_cmds: un:0x%p: GOT retry_bp:0x%p "
14866 un, un->un_retry_bp, un->un_throttle,
14867 un->un_ncmds_in_transport);
14869 SD_TRACE(SD_LOG_IO_CORE, un, "sd_start_cmds: "
14873 } else if ((bp = un->un_waitq_headp) != NULL) {
14887 if (un->un_ncmds_in_transport >= un->un_throttle) {
14888 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
14893 if (un->un_retry_bp != NULL) {
14894 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
14898 if (un->un_startstop_timeid != NULL) {
14899 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
14904 if (un->un_direct_priority_timeid != NULL) {
14905 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
14912 un->un_waitq_headp = bp->av_forw;
14913 if (un->un_waitq_headp == NULL) {
14914 un->un_waitq_tailp = NULL;
14918 SD_TRACE(SD_LOG_IO_CORE, un,
14923 SD_TRACE(SD_LOG_IO_CORE, un,
14938 if ((un->un_state != SD_STATE_SUSPENDED) &&
14939 (un->un_state != SD_STATE_PM_CHANGING)) {
14940 New_state(un, SD_STATE_NORMAL);
15001 ASSERT(bp != un->un_rqs_bp);
15007 SD_TRACE(SD_LOG_IO_CORE, un,
15022 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15043 if (bp != un->un_retry_bp) {
15075 if (un->un_retry_statp == NULL) {
15081 un->un_retry_statp =
15085 if ((un->un_startstop_timeid == NULL) &&
15086 (un->un_retry_timeid == NULL) &&
15087 (un->un_direct_priority_timeid ==
15090 un->un_retry_timeid =
15093 un, SD_RESTART_TIMEOUT);
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;
15117 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15128 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15138 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15158 SD_UPDATE_KSTATS(un, kstat_waitq_exit, bp);
15160 sd_return_failed_command_no_restart(un, bp, EIO);
15173 un->un_ncmds_in_transport++;
15174 SD_UPDATE_KSTATS(un, statp, bp);
15184 SD_TRACE(SD_LOG_IO_CORE, un,
15188 mutex_exit(SD_MUTEX(un));
15190 mutex_enter(SD_MUTEX(un));
15192 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15198 un->un_tran_fatal_count = 0;
15202 un->un_ncmds_in_transport--;
15203 ASSERT(un->un_ncmds_in_transport >= 0);
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,
15227 if ((un->un_f_is_fibre == TRUE) &&
15258 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15262 SD_UPDATE_KSTATS(un, kstat_runq_exit, bp);
15263 un->un_direct_priority_timeid =
15265 bp, un->un_busy_timeout / 500);
15274 if (bp != un->un_retry_bp) {
15275 sd_reduce_throttle(un, SD_THROTTLE_TRAN_BUSY);
15283 sd_set_retry_bp(un, bp, un->un_busy_timeout / 500,
15288 un->un_tran_fatal_count++;
15293 un->un_ncmds_in_transport--;
15294 ASSERT(un->un_ncmds_in_transport >= 0);
15302 if (bp == un->un_rqs_bp) {
15303 bp = sd_mark_rqs_idle(un, xp);
15310 SD_UPDATE_ERRSTATS(un, sd_transerrs);
15313 SD_UPDATE_KSTATS(un, kstat_runq_exit, bp);
15314 sd_print_transport_rejected_message(un, xp, rval);
15324 ASSERT(un->un_fm_private != NULL);
15325 sfip = un->un_fm_private;
15327 sd_ssc_extract_info(&sfip->fm_ssc, un,
15338 sd_return_failed_command_no_restart(un, bp, EIO);
15344 if (un->un_state == SD_STATE_SUSPENDED) {
15345 cv_broadcast(&un->un_disk_busy_cv);
15358 ASSERT(mutex_owned(SD_MUTEX(un)));
15359 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_start_cmds: exit\n");
15374 sd_return_command(struct sd_lun *un, struct buf *bp)
15381 ASSERT(un != NULL);
15382 ASSERT(mutex_owned(SD_MUTEX(un)));
15383 ASSERT(bp != un->un_rqs_bp);
15388 sfip = (struct sd_fm_internal *)un->un_fm_private;
15391 SD_TRACE(SD_LOG_IO_CORE, un, "sd_return_command: entry\n");
15396 if ((un->un_partial_dma_supported == 1) &&
15401 if (sd_setup_next_xfer(un, bp, pktp, xp) != 0) {
15406 sd_retry_command(un, bp, SD_RETRIES_NOCHECK,
15408 sd_start_cmds(un, NULL);
15422 if (bp == un->un_failfast_bp) {
15423 ASSERT(un->un_failfast_state == SD_FAILFAST_INACTIVE);
15424 un->un_failfast_bp = NULL;
15431 un->un_failfast_state = SD_FAILFAST_INACTIVE;
15438 sd_ssc_extract_info(&sfip->fm_ssc, un, pktp, bp, xp);
15448 sd_ssc_extract_info(&sfip->fm_ssc, un, pktp, bp, xp);
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;
15465 SD_UPDATE_RDWR_STATS(un, bp);
15466 SD_UPDATE_PARTITION_STATS(un, bp);
15468 switch (un->un_state) {
15474 cv_broadcast(&un->un_disk_busy_cv);
15477 sd_start_cmds(un, NULL);
15482 mutex_exit(SD_MUTEX(un));
15487 SD_BEGIN_IODONE(xp->xb_chain_iodone, un, bp);
15489 ASSERT(!mutex_owned(SD_MUTEX(un)));
15490 mutex_enter(SD_MUTEX(un));
15492 SD_TRACE(SD_LOG_IO_CORE, un, "sd_return_command: exit\n");
15505 sd_return_failed_command(struct sd_lun *un, struct buf *bp, int errcode)
15508 ASSERT(un != NULL);
15509 ASSERT(mutex_owned(SD_MUTEX(un)));
15511 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15520 sd_return_command(un, bp);
15521 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15536 sd_return_failed_command_no_restart(struct sd_lun *un, struct buf *bp,
15542 ASSERT(un != NULL);
15543 ASSERT(mutex_owned(SD_MUTEX(un)));
15548 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15564 if (bp == un->un_failfast_bp) {
15565 ASSERT(un->un_failfast_state == SD_FAILFAST_INACTIVE);
15566 un->un_failfast_bp = NULL;
15569 if (bp == un->un_retry_bp) {
15574 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
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;
15581 SD_UPDATE_RDWR_STATS(un, bp);
15582 SD_UPDATE_PARTITION_STATS(un, bp);
15584 mutex_exit(SD_MUTEX(un));
15591 SD_BEGIN_IODONE(xp->xb_chain_iodone, un, bp);
15593 mutex_enter(SD_MUTEX(un));
15595 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15606 * Arguments: un - Pointer to the sd_lun struct for the target.
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
15656 ASSERT(un != NULL);
15657 ASSERT(mutex_owned(SD_MUTEX(un)));
15664 sfip = (struct sd_fm_internal *)un->un_fm_private;
15667 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un,
15683 scsi_log(SD_DEVINFO(un), sd_label, CE_NOTE,
15685 sd_dump_memory(un, SD_LOG_IO, "CDB",
15687 sd_dump_memory(un, SD_LOG_IO, "Sense Data",
15698 switch (un->un_state) {
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;
15706 if (bp == un->un_retry_bp) {
15707 un->un_retry_bp = NULL;
15708 un->un_retry_statp = NULL;
15710 SD_UPDATE_KSTATS(un, kstat_waitq_enter, bp);
15711 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_retry_command: "
15741 if (un->un_failfast_state == SD_FAILFAST_ACTIVE) {
15742 ASSERT(un->un_failfast_bp == NULL);
15761 if (un->un_failfast_bp == NULL) {
15769 un->un_failfast_bp = bp;
15771 } else if (un->un_failfast_bp == bp) {
15778 un->un_failfast_state = SD_FAILFAST_ACTIVE;
15779 un->un_failfast_bp = NULL;
15780 sd_failfast_flushq(un);
15822 un->un_failfast_state = SD_FAILFAST_INACTIVE;
15836 if (xp->xb_victim_retry_count < un->un_victim_retry_count) {
15845 if (xp->xb_retry_count >= un->un_retry_count) {
15847 SD_TRACE(SD_LOG_IO_CORE, un,
15864 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15871 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
15877 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15883 if (xp->xb_retry_count >= un->un_busy_retry_count) {
15885 SD_TRACE(SD_LOG_IO_CORE, un,
15890 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15911 sd_ssc_extract_info(&sfip->fm_ssc, un, pktp, bp, xp);
15926 if (un->un_ncmds_in_transport >= un->un_throttle) {
15931 retry_delay = un->un_busy_timeout;
15933 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15942 (*user_funcp)(un, bp, user_arg,
15945 sd_print_incomplete_msg(un, bp, user_arg,
15947 sd_print_cmd_incomplete_msg(un, bp, user_arg,
15949 sd_print_sense_failed_msg(un, bp, user_arg,
15954 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15961 sd_start_cmds(un, bp);
15963 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15974 (*user_funcp)(un, bp, user_arg, SD_DELAYED_RETRY_ISSUED);
15977 sd_set_retry_bp(un, bp, retry_delay, statp);
15979 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_retry_command: exit\n");
15985 (*user_funcp)(un, bp, user_arg, SD_NO_RETRY_ISSUED);
15990 SD_INFO(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15993 sd_return_failed_command(un, bp, failure_code);
15995 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_retry_command: exit\n");
16004 * Arguments: un - ptr to associated softstate
16013 sd_set_retry_bp(struct sd_lun *un, struct buf *bp, clock_t retry_delay,
16016 ASSERT(un != NULL);
16017 ASSERT(mutex_owned(SD_MUTEX(un)));
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);
16035 if (un->un_retry_bp == NULL) {
16036 ASSERT(un->un_retry_statp == NULL);
16037 un->un_retry_bp = bp;
16050 un->un_retry_statp = statp;
16055 if (un->un_retry_bp == bp) {
16062 un->un_retry_statp = statp;
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"
16085 un, bp, un->un_retry_timeid);
16098 if ((un->un_failfast_bp != NULL) &&
16099 (un->un_failfast_bp == un->un_waitq_headp)) {
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;
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;
16121 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16122 "sd_set_retry_bp: un:0x%p already delayed retry\n", un);
16127 SD_UPDATE_KSTATS(un, statp, bp);
16130 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16131 "sd_set_retry_bp: exit un:0x%p\n", un);
16150 struct sd_lun *un = arg;
16152 ASSERT(un != NULL);
16153 ASSERT(!mutex_owned(SD_MUTEX(un)));
16155 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16158 mutex_enter(SD_MUTEX(un));
16160 un->un_retry_timeid = NULL;
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);
16169 mutex_exit(SD_MUTEX(un));
16171 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16188 struct sd_lun *un = arg;
16190 ASSERT(un != NULL);
16191 ASSERT(!mutex_owned(SD_MUTEX(un)));
16193 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16196 mutex_enter(SD_MUTEX(un));
16198 if (un->un_rmw_incre_count > 0) {
16199 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
16203 un->un_rmw_incre_count, un->un_tgt_blocksize,
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);
16209 un->un_rmw_msg_timeid = NULL;
16212 mutex_exit(SD_MUTEX(un));
16214 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16235 struct sd_lun *un;
16238 un = SD_GET_UN(priority_bp);
16239 ASSERT(un != NULL);
16240 ASSERT(!mutex_owned(SD_MUTEX(un)));
16242 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
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));
16250 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16264 sd_send_request_sense_command(struct sd_lun *un, struct buf *bp,
16268 ASSERT(un != NULL);
16269 ASSERT(mutex_owned(SD_MUTEX(un)));
16271 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un, "sd_send_request_sense_command: "
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,
16296 if ((un->un_sense_isbusy != 0) || (un->un_ncmds_in_transport > 0)) {
16299 sd_retry_command(un, bp, SD_RETRIES_NOCHECK,
16300 NULL, NULL, 0, un->un_busy_timeout,
16302 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16306 sd_return_failed_command(un, bp, EIO);
16307 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16314 sd_mark_rqs_busy(un, bp);
16315 sd_start_cmds(un, un->un_rqs_bp);
16317 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16332 sd_mark_rqs_busy(struct sd_lun *un, struct buf *bp)
16336 ASSERT(un != NULL);
16338 ASSERT(mutex_owned(SD_MUTEX(un)));
16339 ASSERT(un->un_sense_isbusy == 0);
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);
16344 sense_xp = SD_GET_XBUF(un->un_rqs_bp);
16347 SD_INFO(SD_LOG_IO, un,
16354 un->un_sense_isbusy = 1;
16355 un->un_rqs_bp->b_resid = 0;
16362 bzero(un->un_rqs_bp->b_un.b_addr, SENSE_LENGTH);
16388 SD_TRACE(SD_LOG_IO_CORE, un, "sd_mark_rqs_busy: exit\n");
16405 sd_mark_rqs_idle(struct sd_lun *un, struct sd_xbuf *sense_xp)
16408 ASSERT(un != NULL);
16410 ASSERT(mutex_owned(SD_MUTEX(un)));
16411 ASSERT(un->un_sense_isbusy != 0);
16413 un->un_sense_isbusy = 0;
16436 sd_alloc_rqs(struct scsi_device *devp, struct sd_lun *un)
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);
16449 un->un_rqs_bp = scsi_alloc_consistent_buf(&devp->sd_address, NULL,
16451 if (un->un_rqs_bp == NULL) {
16455 un->un_rqs_pktp = scsi_init_pkt(&devp->sd_address, NULL, un->un_rqs_bp,
16458 if (un->un_rqs_pktp == NULL) {
16459 sd_free_rqs(un);
16464 (void) scsi_setup_cdb((union scsi_cdb *)un->un_rqs_pktp->pkt_cdbp,
16467 SD_FILL_SCSI1_LUN(un, un->un_rqs_pktp);
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 |=
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);
16491 un->un_rqs_pktp->pkt_private = un->un_rqs_bp;
16492 ASSERT(un->un_rqs_bp->b_private == xp);
16511 if (un->un_f_is_fibre == TRUE) {
16512 un->un_f_arq_enabled = TRUE;
16519 (void) scsi_ifsetcap(SD_ADDRESS(un), "auto-rqsense", 1, 1);
16521 switch (scsi_ifgetcap(SD_ADDRESS(un), "auto-rqsense", 1)) {
16523 SD_INFO(SD_LOG_ATTACH_DETACH, un,
16530 if (scsi_ifsetcap(SD_ADDRESS(un), "auto-rqsense", 1, 1)
16533 SD_INFO(SD_LOG_ATTACH_DETACH, un,
16535 un->un_f_arq_enabled = TRUE;
16538 SD_INFO(SD_LOG_ATTACH_DETACH, un,
16540 un->un_f_arq_enabled = FALSE;
16548 SD_INFO(SD_LOG_ATTACH_DETACH, un,
16550 un->un_f_arq_enabled = TRUE;
16557 SD_INFO(SD_LOG_ATTACH_DETACH, un,
16559 un->un_f_arq_enabled = FALSE;
16577 sd_free_rqs(struct sd_lun *un)
16579 ASSERT(un != NULL);
16581 SD_TRACE(SD_LOG_IO_CORE, un, "sd_free_rqs: entry\n");
16590 if (un->un_rqs_pktp != NULL) {
16591 scsi_destroy_pkt(un->un_rqs_pktp);
16592 un->un_rqs_pktp = NULL;
16595 if (un->un_rqs_bp != NULL) {
16596 struct sd_xbuf *xp = SD_GET_XBUF(un->un_rqs_bp);
16600 scsi_free_consistent_buf(un->un_rqs_bp);
16601 un->un_rqs_bp = NULL;
16603 SD_TRACE(SD_LOG_IO_CORE, un, "sd_free_rqs: exit\n");
16618 * Arguments: un - ptr to the sd_lun softstate struct
16625 sd_reduce_throttle(struct sd_lun *un, int throttle_type)
16627 ASSERT(un != NULL);
16628 ASSERT(mutex_owned(SD_MUTEX(un)));
16629 ASSERT(un->un_ncmds_in_transport >= 0);
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);
16635 if (un->un_throttle > 1) {
16636 if (un->un_f_use_adaptive_throttle == TRUE) {
16639 if (un->un_busy_throttle == 0) {
16640 un->un_busy_throttle = un->un_throttle;
16644 un->un_busy_throttle = 0;
16650 if (un->un_ncmds_in_transport > 0) {
16651 un->un_throttle = un->un_ncmds_in_transport;
16655 if (un->un_ncmds_in_transport == 0) {
16656 un->un_throttle = 1;
16658 un->un_throttle = un->un_ncmds_in_transport;
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,
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);
16681 * value of un->un_throttle to its default.
16691 struct sd_lun *un = arg;
16693 ASSERT(un != NULL);
16694 ASSERT(!mutex_owned(SD_MUTEX(un)));
16696 mutex_enter(SD_MUTEX(un));
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);
16701 un->un_reset_throttle_timeid = NULL;
16703 if (un->un_f_use_adaptive_throttle == TRUE) {
16713 if (un->un_busy_throttle > 0) {
16714 un->un_throttle = un->un_busy_throttle;
16715 un->un_busy_throttle = 0;
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 =
16732 un,
16743 if (un->un_throttle < un->un_min_throttle) {
16744 un->un_throttle = un->un_saved_throttle;
16747 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un, "sd_restore_throttle: "
16749 un->un_throttle, un->un_saved_throttle);
16750 un->un_throttle = un->un_saved_throttle;
16753 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un,
16756 sd_start_cmds(un, NULL);
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);
16762 mutex_exit(SD_MUTEX(un));
16764 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un, "sd_restore_throttle: exit\n");
16796 struct sd_lun *un = (struct sd_lun *)arg;
16798 ASSERT(un != NULL);
16799 ASSERT(!mutex_owned(SD_MUTEX(un)));
16801 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sdrunout: entry\n");
16803 mutex_enter(SD_MUTEX(un));
16804 sd_start_cmds(un, NULL);
16805 mutex_exit(SD_MUTEX(un));
16811 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sdrunout: exit\n");
16830 struct sd_lun *un;
16840 un = SD_GET_UN(bp);
16841 ASSERT(un != NULL);
16842 ASSERT(!mutex_owned(SD_MUTEX(un)));
16846 SD_INFO(SD_LOG_IOERR, un, "sdintr: sdintr calling Fault injection\n");
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);
16855 mutex_enter(SD_MUTEX(un));
16857 ASSERT(un->un_fm_private != NULL);
16858 sscp = &((struct sd_fm_internal *)(un->un_fm_private))->fm_ssc;
16862 un->un_ncmds_in_transport--;
16863 ASSERT(un->un_ncmds_in_transport >= 0);
16866 un->un_in_callback++;
16868 SD_UPDATE_KSTATS(un, kstat_runq_exit, bp);
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);
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,
16889 if (un->un_mediastate != DKIO_DEV_GONE) {
16890 un->un_mediastate = DKIO_DEV_GONE;
16891 cv_broadcast(&un->un_state_cv);
16897 if (bp == un->un_rqs_bp) {
16898 bp = sd_mark_rqs_idle(un, xp);
16900 sd_return_failed_command(un, bp, EIO);
16905 SD_TRACE(SD_LOG_COMMON, un,
16915 (un->un_f_arq_enabled == TRUE)) {
16962 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16964 sd_return_failed_command(un, bp, EIO);
16978 if ((un->un_f_is_fibre == TRUE) &&
16986 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16989 sd_handle_auto_request_sense(un, bp, xp, pktp);
16996 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16998 sd_handle_request_sense(un, bp, xp, pktp);
17026 un->un_sonoma_failure_count = 0;
17032 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17037 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17041 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17046 sd_return_command(un, bp);
17052 un->un_in_callback--;
17053 ASSERT(un->un_in_callback >= 0);
17054 mutex_exit(SD_MUTEX(un));
17083 if ((un->un_f_is_fibre == TRUE) &&
17098 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17107 sd_send_request_sense_command(un, bp, pktp);
17109 sd_return_failed_command(un, bp, EIO);
17126 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17128 sd_pkt_status_good(un, bp, xp, pktp);
17133 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17135 sd_pkt_status_check_condition(un, bp, xp, pktp);
17139 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17141 sd_pkt_status_busy(un, bp, xp, pktp);
17145 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17147 sd_pkt_status_reservation_conflict(un, bp, xp, pktp);
17151 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17153 sd_pkt_status_qfull(un, bp, xp, pktp);
17161 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
17172 sd_return_failed_command(un, bp, EIO);
17176 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
17183 sd_return_failed_command(un, bp, EIO);
17190 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17192 sd_pkt_reason_cmd_incomplete(un, bp, xp, pktp);
17195 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17197 sd_pkt_reason_cmd_tran_err(un, bp, xp, pktp);
17200 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17202 sd_pkt_reason_cmd_reset(un, bp, xp, pktp);
17205 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17207 sd_pkt_reason_cmd_aborted(un, bp, xp, pktp);
17210 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17212 sd_pkt_reason_cmd_timeout(un, bp, xp, pktp);
17215 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17217 sd_pkt_reason_cmd_unx_bus_free(un, bp, xp, pktp);
17220 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17222 sd_pkt_reason_cmd_tag_reject(un, bp, xp, pktp);
17225 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17234 sd_pkt_reason_default(un, bp, xp, pktp);
17239 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sdintr: exit\n");
17242 un->un_in_callback--;
17243 ASSERT(un->un_in_callback >= 0);
17251 mutex_exit(SD_MUTEX(un));
17260 * Arguments: un - ptr to associated softstate for the device.
17270 sd_print_incomplete_msg(struct sd_lun *un, struct buf *bp, void *arg, int code)
17276 ASSERT(un != NULL);
17277 ASSERT(mutex_owned(SD_MUTEX(un)));
17295 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
17311 sd_pkt_status_good(struct sd_lun *un, struct buf *bp,
17316 ASSERT(un != NULL);
17317 ASSERT(mutex_owned(SD_MUTEX(un)));
17325 SD_TRACE(SD_LOG_IO_CORE, un, "sd_pkt_status_good: entry\n");
17327 SD_UPDATE_ERRSTATS(un, sd_harderrs);
17337 sd_return_command(un, bp);
17338 SD_TRACE(SD_LOG_IO_CORE, un, "sd_pkt_status_good: exit\n");
17347 sd_retry_command(un, bp, SD_RETRIES_STANDARD, sd_print_incomplete_msg,
17350 SD_TRACE(SD_LOG_IO_CORE, un, "sd_pkt_status_good: exit\n");
17362 * Arguments: un - ptr to associated softstate
17371 sd_handle_request_sense(struct sd_lun *un, struct buf *sense_bp,
17379 ASSERT(un != NULL);
17380 ASSERT(mutex_owned(SD_MUTEX(un)));
17389 ASSERT(sense_pktp == un->un_rqs_pktp);
17390 ASSERT(sense_bp == un->un_rqs_bp);
17408 SD_UPDATE_ERRSTATS(un, sd_harderrs);
17410 cmd_bp = sd_mark_rqs_idle(un, sense_xp);
17411 sd_retry_command(un, cmd_bp, SD_RETRIES_STANDARD,
17453 (void) sd_mark_rqs_idle(un, sense_xp);
17461 if (sd_validate_sense_data(un, cmd_bp, cmd_xp, actual_len) ==
17463 sd_decode_sense(un, cmd_bp, cmd_xp, cmd_pktp);
17466 SD_DUMP_MEMORY(un, SD_LOG_IO_CORE, "Failed CDB",
17468 SD_DUMP_MEMORY(un, SD_LOG_IO_CORE, "Sense Data",
17470 sd_return_failed_command(un, cmd_bp, EIO);
17482 * Arguments: un - ptr to associated softstate
17491 sd_handle_auto_request_sense(struct sd_lun *un, struct buf *bp,
17497 ASSERT(un != NULL);
17498 ASSERT(mutex_owned(SD_MUTEX(un)));
17502 ASSERT(pktp != un->un_rqs_pktp);
17503 ASSERT(bp != un->un_rqs_bp);
17517 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
17521 sd_reset_target(un, pktp);
17523 sd_retry_command(un, bp, SD_RETRIES_STANDARD,
17559 if (sd_validate_sense_data(un, bp, xp, actual_len) ==
17561 sd_decode_sense(un, bp, xp, pktp);
17571 * Arguments: un - ptr to associated softstate
17581 sd_print_sense_failed_msg(struct sd_lun *un, struct buf *bp, void *arg,
17586 ASSERT(un != NULL);
17587 ASSERT(mutex_owned(SD_MUTEX(un)));
17591 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, msgp);
17610 sd_validate_sense_data(struct sd_lun *un, struct buf *bp, struct sd_xbuf *xp,
17618 ASSERT(un != NULL);
17619 ASSERT(mutex_owned(SD_MUTEX(un)));
17621 ASSERT(bp != un->un_rqs_bp);
17623 ASSERT(un->un_fm_private != NULL);
17628 sscp = &((struct sd_fm_internal *)(un->un_fm_private))->fm_ssc;
17639 sd_pkt_status_reservation_conflict(un, bp, xp, pktp);
17643 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
17645 sd_retry_command(un, bp, SD_RETRIES_BUSY, NULL,
17646 NULL, EIO, un->un_busy_timeout / 500, kstat_waitq_enter);
17650 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
17652 sd_retry_command(un, bp, SD_RETRIES_STANDARD, NULL,
17653 NULL, EIO, un->un_busy_timeout / 500, kstat_waitq_enter);
17707 if (SD_FM_LOG(un) == SD_FM_LOG_NSUP) {
17708 scsi_log(SD_DEVINFO(un), sd_label,
17721 sd_return_failed_command(un, bp, EIO);
17759 sd_retry_command(un, bp, SD_RETRIES_STANDARD,
17761 un->un_f_is_fibre?drv_usectohz(100000):(clock_t)0, NULL);
17763 sd_retry_command(un, bp, SD_RETRIES_STANDARD,
17779 sd_decode_sense(struct sd_lun *un, struct buf *bp, struct sd_xbuf *xp,
17784 ASSERT(un != NULL);
17785 ASSERT(mutex_owned(SD_MUTEX(un)));
17787 ASSERT(bp != un->un_rqs_bp);
17795 sd_sense_key_no_sense(un, bp, xp, pktp);
17798 sd_sense_key_recoverable_error(un, xp->xb_sense_data,
17802 sd_sense_key_not_ready(un, xp->xb_sense_data,
17807 sd_sense_key_medium_or_hardware_error(un,
17811 sd_sense_key_illegal_request(un, bp, xp, pktp);
17814 sd_sense_key_unit_attention(un, xp->xb_sense_data,
17820 sd_sense_key_fail_command(un, bp, xp, pktp);
17823 sd_sense_key_blank_check(un, bp, xp, pktp);
17826 sd_sense_key_aborted_command(un, bp, xp, pktp);
17833 sd_sense_key_default(un, xp->xb_sense_data,
17848 * Arguments: un - ptr to softstate
17866 sd_dump_memory(struct sd_lun *un, uint_t comp, char *title, uchar_t *data,
17948 scsi_log(SD_DEVINFO(un), sd_label, CE_NOTE, "%s", local_buf);
17958 * Arguments: un - ptr to associated softstate
17968 sd_print_sense_msg(struct sd_lun *un, struct buf *bp, void *arg, int code)
17979 ASSERT(un != NULL);
17980 ASSERT(mutex_owned(SD_MUTEX(un)));
18033 sd_dump_memory(un, SD_LOG_IO, "Failed CDB",
18035 sd_dump_memory(un, SD_LOG_IO, "Sense Data",
18053 if ((SD_IS_LSI(un)) &&
18057 un->un_sonoma_failure_count++;
18058 if (un->un_sonoma_failure_count > 1) {
18063 if (SD_FM_LOG(un) == SD_FM_LOG_NSUP ||
18066 scsi_vu_errmsg(SD_SCSI_DEVP(un), pktp, sd_label, severity,
18069 un->un_additional_codes, NULL);
18082 sd_sense_key_no_sense(struct sd_lun *un, struct buf *bp,
18087 ASSERT(un != NULL);
18088 ASSERT(mutex_owned(SD_MUTEX(un)));
18096 SD_UPDATE_ERRSTATS(un, sd_softerrs);
18098 sd_retry_command(un, bp, SD_RETRIES_STANDARD, sd_print_sense_msg,
18112 sd_sense_key_recoverable_error(struct sd_lun *un,
18120 ASSERT(un != NULL);
18121 ASSERT(mutex_owned(SD_MUTEX(un)));
18130 sd_return_command(un, bp);
18138 SD_UPDATE_ERRSTATS(un, sd_rq_pfa_err);
18142 SD_UPDATE_ERRSTATS(un, sd_softerrs);
18143 SD_UPDATE_ERRSTATS(un, sd_rq_recov_err);
18149 sd_print_sense_msg(un, bp, &si, SD_NO_RETRY_ISSUED);
18150 sd_return_command(un, bp);
18154 sd_retry_command(un, bp, SD_RETRIES_STANDARD, sd_print_sense_msg,
18170 sd_sense_key_not_ready(struct sd_lun *un,
18178 ASSERT(un != NULL);
18179 ASSERT(mutex_owned(SD_MUTEX(un)));
18192 if ((ISCD(un) && (asc == 0x3A)) ||
18194 SD_UPDATE_ERRSTATS(un, sd_harderrs);
18195 SD_UPDATE_ERRSTATS(un, sd_rq_ntrdy_err);
18201 if (xp->xb_nr_retry_count >= un->un_notready_retry_count) {
18203 if (un->un_f_has_removable_media && (asc == 0x04) &&
18222 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
18252 if (un->un_f_is_fibre == TRUE) {
18255 (un->un_startstop_timeid == NULL)) {
18256 scsi_log(SD_DEVINFO(un), sd_label,
18259 sd_reset_target(un, pktp);
18264 un->un_reset_retry_count)) &&
18265 (un->un_startstop_timeid == NULL)) {
18266 scsi_log(SD_DEVINFO(un), sd_label,
18269 sd_reset_target(un, pktp);
18303 if (SD_IS_T3(un) || SD_IS_T4(un)) {
18304 sd_return_failed_command(un, bp, EIO);
18324 if (un->un_f_has_removable_media) {
18359 if (un->un_startstop_timeid != NULL) {
18360 SD_INFO(SD_LOG_ERROR, un,
18362 " %s%d\n", ddi_driver_name(SD_DEVINFO(un)),
18363 ddi_get_instance(SD_DEVINFO(un)));
18376 un->un_startstop_timeid = timeout(sd_start_stop_unit_callback,
18377 un, un->un_busy_timeout / 2);
18379 sd_set_retry_bp(un, bp, 0, kstat_waitq_enter);
18384 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
18391 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
18395 sr_ejected(un);
18396 un->un_mediastate = DKIO_EJECTED;
18398 cv_broadcast(&un->un_state_cv);
18404 scsi_log(SD_DEVINFO(un), sd_label, CE_NOTE,
18419 sd_retry_command(un, bp, SD_RETRIES_NOCHECK, sd_print_sense_msg,
18420 &si, EIO, un->un_busy_timeout, NULL);
18425 sd_print_sense_msg(un, bp, &si, SD_NO_RETRY_ISSUED);
18426 sd_return_failed_command(un, bp, EIO);
18441 sd_sense_key_medium_or_hardware_error(struct sd_lun *un,
18449 ASSERT(un != NULL);
18450 ASSERT(mutex_owned(SD_MUTEX(un)));
18459 SD_UPDATE_ERRSTATS(un, sd_rq_media_err);
18462 SD_UPDATE_ERRSTATS(un, sd_harderrs);
18464 if ((un->un_reset_retry_count != 0) &&
18465 (xp->xb_retry_count == un->un_reset_retry_count)) {
18466 mutex_exit(SD_MUTEX(un));
18468 if (un->un_f_allow_bus_device_reset == TRUE) {
18488 if (SD_IS_LSI(un)) {
18499 if (un->un_f_lun_reset_enabled == TRUE) {
18500 SD_TRACE(SD_LOG_IO_CORE, un,
18504 scsi_reset(SD_ADDRESS(un),
18508 SD_TRACE(SD_LOG_IO_CORE, un,
18511 (void) scsi_reset(SD_ADDRESS(un),
18516 mutex_enter(SD_MUTEX(un));
18523 sd_retry_command(un, bp, SD_RETRIES_STANDARD, sd_print_sense_msg,
18538 sd_sense_key_illegal_request(struct sd_lun *un, struct buf *bp,
18543 ASSERT(un != NULL);
18544 ASSERT(mutex_owned(SD_MUTEX(un)));
18549 SD_UPDATE_ERRSTATS(un, sd_rq_illrq_err);
18555 sd_print_sense_msg(un, bp, &si, SD_NO_RETRY_ISSUED);
18556 sd_return_failed_command(un, bp, EIO);
18571 sd_sense_key_unit_attention(struct sd_lun *un,
18586 ASSERT(un != NULL);
18587 ASSERT(mutex_owned(SD_MUTEX(un)));
18599 SD_UPDATE_ERRSTATS(un, sd_rq_pfa_err);
18608 if ((un->un_resvd_status & SD_RESERVE) == SD_RESERVE) {
18609 un->un_resvd_status |=
18613 if (un->un_blockcount + 1 > SD_GROUP1_MAX_ADDRESS) {
18615 un, KM_NOSLEEP) == 0) {
18621 SD_ERROR(SD_LOG_ERROR, un,
18631 if (!un->un_f_has_removable_media) {
18650 SD_UPDATE_ERRSTATS(un, sd_harderrs);
18651 SD_UPDATE_ERRSTATS(un, sd_rq_nodev_err);
18653 sd_print_sense_msg(un, bp, &si, SD_NO_RETRY_ISSUED);
18654 sd_return_failed_command(un, bp, EIO);
18691 if (taskq_dispatch(sd_tq, sd_target_change_task, un,
18693 SD_ERROR(SD_LOG_ERROR, un,
18703 SD_UPDATE_ERRSTATS(un, sd_harderrs);
18704 SD_UPDATE_ERRSTATS(un, sd_rq_nodev_err);
18708 sd_retry_command(un, bp, retry_check_flag, sd_print_sense_msg, &si,
18724 sd_sense_key_fail_command(struct sd_lun *un, struct buf *bp,
18729 ASSERT(un != NULL);
18730 ASSERT(mutex_owned(SD_MUTEX(un)));
18738 sd_print_sense_msg(un, bp, &si, SD_NO_RETRY_ISSUED);
18739 sd_return_failed_command(un, bp, EIO);
18754 sd_sense_key_blank_check(struct sd_lun *un, struct buf *bp,
18759 ASSERT(un != NULL);
18760 ASSERT(mutex_owned(SD_MUTEX(un)));
18769 si.ssi_severity = (un->un_f_has_removable_media) ? SCSI_ERR_ALL :
18773 sd_print_sense_msg(un, bp, &si, SD_NO_RETRY_ISSUED);
18774 sd_return_failed_command(un, bp, EIO);
18789 sd_sense_key_aborted_command(struct sd_lun *un, struct buf *bp,
18794 ASSERT(un != NULL);
18795 ASSERT(mutex_owned(SD_MUTEX(un)));
18803 SD_UPDATE_ERRSTATS(un, sd_harderrs);
18809 sd_retry_command(un, bp, SD_RETRIES_STANDARD, sd_print_sense_msg,
18825 sd_sense_key_default(struct sd_lun *un,
18832 ASSERT(un != NULL);
18833 ASSERT(mutex_owned(SD_MUTEX(un)));
18838 SD_UPDATE_ERRSTATS(un, sd_harderrs);
18845 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
18852 sd_retry_command(un, bp, SD_RETRIES_STANDARD, sd_print_sense_msg,
18863 * Arguments: un - ptr to associated softstate
18873 sd_print_retry_msg(struct sd_lun *un, struct buf *bp, void *arg, int flag)
18880 ASSERT(un != NULL);
18881 ASSERT(mutex_owned(SD_MUTEX(un)));
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)) ||
18893 mutex_exit(&un->un_pm_mutex);
18896 mutex_exit(&un->un_pm_mutex);
18909 if (ddi_in_panic() || (un->un_state == SD_STATE_OFFLINE) ||
18910 ((pktp->pkt_reason == un->un_last_pkt_reason) &&
18923 if (SD_FM_LOG(un) == SD_FM_LOG_NSUP) {
18924 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
18930 * Update un->un_last_pkt_reason with the value in pktp->pkt_reason.
18932 * condition. Note that un->un_last_pkt_reason is NOT restored if &
18937 un->un_last_pkt_reason = pktp->pkt_reason;
18947 * Arguments: un - ptr to associated softstate
18957 sd_print_cmd_incomplete_msg(struct sd_lun *un, struct buf *bp, void *arg,
18962 ASSERT(un != NULL);
18963 ASSERT(mutex_owned(SD_MUTEX(un)));
18969 if (un->un_state != SD_STATE_OFFLINE) {
18976 dip = un->un_sd->sd_dev;
18979 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
18982 New_state(un, SD_STATE_OFFLINE);
18990 sd_print_retry_msg(un, bp, arg, code);
19005 sd_pkt_reason_cmd_incomplete(struct sd_lun *un, struct buf *bp,
19010 ASSERT(un != NULL);
19011 ASSERT(mutex_owned(SD_MUTEX(un)));
19019 SD_UPDATE_ERRSTATS(un, sd_transerrs);
19020 sd_reset_target(un, pktp);
19033 SD_UPDATE_RESERVATION_STATUS(un, pktp);
19035 sd_retry_command(un, bp, flag,
19050 sd_pkt_reason_cmd_tran_err(struct sd_lun *un, struct buf *bp,
19053 ASSERT(un != NULL);
19054 ASSERT(mutex_owned(SD_MUTEX(un)));
19063 SD_UPDATE_ERRSTATS(un, sd_harderrs);
19067 SD_UPDATE_ERRSTATS(un, sd_transerrs);
19068 sd_reset_target(un, pktp);
19071 SD_UPDATE_RESERVATION_STATUS(un, pktp);
19073 sd_retry_command(un, bp, (SD_RETRIES_STANDARD | SD_RETRIES_ISOLATE),
19088 sd_pkt_reason_cmd_reset(struct sd_lun *un, struct buf *bp,
19091 ASSERT(un != NULL);
19092 ASSERT(mutex_owned(SD_MUTEX(un)));
19098 SD_UPDATE_ERRSTATS(un, sd_transerrs);
19099 sd_reset_target(un, pktp);
19101 SD_UPDATE_RESERVATION_STATUS(un, pktp);
19110 sd_retry_command(un, bp, (SD_RETRIES_VICTIM | SD_RETRIES_ISOLATE),
19126 sd_pkt_reason_cmd_aborted(struct sd_lun *un, struct buf *bp,
19129 ASSERT(un != NULL);
19130 ASSERT(mutex_owned(SD_MUTEX(un)));
19136 SD_UPDATE_ERRSTATS(un, sd_transerrs);
19137 sd_reset_target(un, pktp);
19139 SD_UPDATE_RESERVATION_STATUS(un, pktp);
19148 sd_retry_command(un, bp, (SD_RETRIES_VICTIM | SD_RETRIES_ISOLATE),
19163 sd_pkt_reason_cmd_timeout(struct sd_lun *un, struct buf *bp,
19166 ASSERT(un != NULL);
19167 ASSERT(mutex_owned(SD_MUTEX(un)));
19173 SD_UPDATE_ERRSTATS(un, sd_transerrs);
19174 sd_reset_target(un, pktp);
19176 SD_UPDATE_RESERVATION_STATUS(un, pktp);
19183 sd_retry_command(un, bp,
19199 sd_pkt_reason_cmd_unx_bus_free(struct sd_lun *un, struct buf *bp,
19202 void (*funcp)(struct sd_lun *un, struct buf *bp, void *arg, int code);
19204 ASSERT(un != NULL);
19205 ASSERT(mutex_owned(SD_MUTEX(un)));
19210 SD_UPDATE_ERRSTATS(un, sd_harderrs);
19211 SD_UPDATE_RESERVATION_STATUS(un, pktp);
19216 sd_retry_command(un, bp, (SD_RETRIES_STANDARD | SD_RETRIES_ISOLATE),
19230 sd_pkt_reason_cmd_tag_reject(struct sd_lun *un, struct buf *bp,
19233 ASSERT(un != NULL);
19234 ASSERT(mutex_owned(SD_MUTEX(un)));
19239 SD_UPDATE_ERRSTATS(un, sd_harderrs);
19241 un->un_tagflags = 0;
19242 if (un->un_f_opt_queueing == TRUE) {
19243 un->un_throttle = min(un->un_throttle, 3);
19245 un->un_throttle = 1;
19247 mutex_exit(SD_MUTEX(un));
19248 (void) scsi_ifsetcap(SD_ADDRESS(un), "tagged-qing", 0, 1);
19249 mutex_enter(SD_MUTEX(un));
19251 SD_UPDATE_RESERVATION_STATUS(un, pktp);
19254 sd_retry_command(un, bp, (SD_RETRIES_NOCHECK | SD_RETRIES_ISOLATE),
19269 sd_pkt_reason_default(struct sd_lun *un, struct buf *bp,
19272 ASSERT(un != NULL);
19273 ASSERT(mutex_owned(SD_MUTEX(un)));
19278 SD_UPDATE_ERRSTATS(un, sd_transerrs);
19279 sd_reset_target(un, pktp);
19281 SD_UPDATE_RESERVATION_STATUS(un, pktp);
19283 sd_retry_command(un, bp, (SD_RETRIES_STANDARD | SD_RETRIES_ISOLATE),
19298 sd_pkt_status_check_condition(struct sd_lun *un, struct buf *bp,
19301 ASSERT(un != NULL);
19302 ASSERT(mutex_owned(SD_MUTEX(un)));
19307 SD_TRACE(SD_LOG_IO, un, "sd_pkt_status_check_condition: "
19316 if (un->un_f_arq_enabled == FALSE) {
19317 SD_INFO(SD_LOG_IO_CORE, un, "sd_pkt_status_check_condition: "
19319 sd_send_request_sense_command(un, bp, pktp);
19321 SD_INFO(SD_LOG_IO_CORE, un, "sd_pkt_status_check_condition: "
19328 sd_retry_command(un, bp, SD_RETRIES_STANDARD, NULL, NULL, EIO,
19329 un->un_f_is_fibre?drv_usectohz(100000):(clock_t)0,
19332 sd_retry_command(un, bp, SD_RETRIES_STANDARD, NULL, NULL,
19337 SD_TRACE(SD_LOG_IO_CORE, un, "sd_pkt_status_check_condition: exit\n");
19350 sd_pkt_status_busy(struct sd_lun *un, struct buf *bp, struct sd_xbuf *xp,
19353 ASSERT(un != NULL);
19354 ASSERT(mutex_owned(SD_MUTEX(un)));
19359 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19363 if (xp->xb_retry_count >= un->un_busy_retry_count) {
19364 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
19366 sd_return_failed_command(un, bp, EIO);
19367 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19381 ((un->un_reset_retry_count < 2) ? 2 : un->un_reset_retry_count)) {
19383 mutex_exit(SD_MUTEX(un));
19384 if (un->un_f_allow_bus_device_reset == TRUE) {
19389 if (un->un_f_lun_reset_enabled == TRUE) {
19390 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19392 rval = scsi_reset(SD_ADDRESS(un), RESET_LUN);
19395 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19397 rval = scsi_reset(SD_ADDRESS(un), RESET_TARGET);
19405 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19407 rval = scsi_reset(SD_ADDRESS(un), RESET_ALL);
19409 mutex_enter(SD_MUTEX(un));
19415 sd_return_failed_command(un, bp, EIO);
19416 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19426 sd_retry_command(un, bp, SD_RETRIES_NOCHECK, NULL, NULL,
19427 EIO, un->un_busy_timeout, NULL);
19429 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19444 sd_pkt_status_reservation_conflict(struct sd_lun *un, struct buf *bp,
19447 ASSERT(un != NULL);
19448 ASSERT(mutex_owned(SD_MUTEX(un)));
19458 if (un->un_reservation_type == SD_SCSI3_RESERVATION) {
19462 sd_return_failed_command(un, bp, EACCES);
19467 un->un_resvd_status |= SD_RESERVATION_CONFLICT;
19469 if ((un->un_resvd_status & SD_FAILFAST) != 0) {
19472 sd_panic_for_res_conflict(un);
19475 SD_ERROR(SD_LOG_IO, un,
19477 sd_return_failed_command(un, bp, EACCES);
19491 SD_ERROR(SD_LOG_IO, un,
19493 sd_return_failed_command(un, bp, EIO);
19503 sd_retry_command(un, bp, SD_RETRIES_STANDARD, NULL, NULL, EIO,
19526 sd_pkt_status_qfull(struct sd_lun *un, struct buf *bp,
19529 ASSERT(un != NULL);
19530 ASSERT(mutex_owned(SD_MUTEX(un)));
19535 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19542 sd_reduce_throttle(un, SD_THROTTLE_QFULL);
19543 sd_retry_command(un, bp, SD_RETRIES_NOCHECK, NULL, NULL, 0,
19546 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19561 sd_reset_target(struct sd_lun *un, struct scsi_pkt *pktp)
19565 ASSERT(un != NULL);
19566 ASSERT(mutex_owned(SD_MUTEX(un)));
19569 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_reset_target: entry\n");
19576 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19581 mutex_exit(SD_MUTEX(un));
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,
19587 rval = scsi_reset(SD_ADDRESS(un), RESET_LUN);
19590 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19592 rval = scsi_reset(SD_ADDRESS(un), RESET_TARGET);
19597 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19599 (void) scsi_reset(SD_ADDRESS(un), RESET_ALL);
19602 mutex_enter(SD_MUTEX(un));
19604 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_reset_target: exit\n");
19617 struct sd_lun *un = arg;
19623 ASSERT(un != NULL);
19624 ASSERT(!mutex_owned(SD_MUTEX(un)));
19626 if ((un->un_f_blockcount_is_valid == FALSE) ||
19627 (un->un_f_tgt_blocksize_is_valid == FALSE)) {
19631 ssc = sd_ssc_init(un);
19635 SD_ERROR(SD_LOG_ERROR, un,
19641 mutex_enter(SD_MUTEX(un));
19642 if (capacity <= un->un_blockcount) {
19643 mutex_exit(SD_MUTEX(un));
19647 sd_update_block_info(un, lbasize, capacity);
19648 mutex_exit(SD_MUTEX(un));
19654 if (cmlb_efi_label_capacity(un->un_cmlbhandle, &label_cap,
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);
19662 mutex_exit(SD_MUTEX(un));
19679 sd_log_dev_status_event(struct sd_lun *un, char *esc, int km_flag)
19688 SD_ERROR(SD_LOG_ERROR, un,
19696 SD_ERROR(SD_LOG_ERROR, un,
19705 (void) ddi_pathname(SD_DEVINFO(un), path + strlen(path));
19713 SD_ERROR(SD_LOG_ERROR, un,
19719 err = ddi_log_sysevent(SD_DEVINFO(un), SUNW_VENDOR, EC_DEV_STATUS,
19722 SD_ERROR(SD_LOG_ERROR, un,
19739 sd_log_lun_expansion_event(struct sd_lun *un, int km_flag)
19741 sd_log_dev_status_event(un, ESC_DEV_DLE, km_flag);
19753 sd_log_eject_request_event(struct sd_lun *un, int km_flag)
19755 sd_log_dev_status_event(un, ESC_DEV_EJECT_REQUEST, km_flag);
19771 struct sd_lun *un;
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);
19801 if ((err = sd_handle_mchange(un)) == 0) {
19818 mutex_enter(SD_MUTEX(un));
19820 SD_UPDATE_ERRSTATS(un, sd_harderrs);
19821 SD_UPDATE_ERRSTATS(un, sd_rq_nodev_err);
19823 sd_print_sense_msg(un, bp, &si, SD_NO_RETRY_ISSUED);
19824 sd_return_failed_command(un, bp, EIO);
19826 sd_retry_command(un, bp, SD_RETRIES_UA, sd_print_sense_msg,
19829 mutex_exit(SD_MUTEX(un));
19848 sd_handle_mchange(struct sd_lun *un)
19855 ASSERT(!mutex_owned(SD_MUTEX(un)));
19856 ASSERT(un->un_f_monitor_media_state);
19858 ssc = sd_ssc_init(un);
19865 mutex_enter(SD_MUTEX(un));
19866 sd_update_block_info(un, lbasize, capacity);
19868 if (un->un_errstats != NULL) {
19870 (struct sd_errstats *)un->un_errstats->ks_data;
19872 ((uint64_t)un->un_blockcount *
19873 (uint64_t)un->un_tgt_blocksize);
19879 if (ISCD(un)) {
19887 mutex_exit(SD_MUTEX(un));
19888 cmlb_invalidate(un->un_cmlbhandle, (void *)SD_PATH_DIRECT_PRIORITY);
19891 if (cmlb_validate(un->un_cmlbhandle, 0,
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);
19945 struct sd_lun *un;
19948 un = ssc->ssc_un;
19949 ASSERT(un != NULL);
19950 ASSERT(!mutex_owned(SD_MUTEX(un)));
19952 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_DOORLOCK: entry: un:0x%p\n", un);
19955 if (un->un_f_doorlock_supported == FALSE) {
19965 mutex_enter(SD_MUTEX(un));
19966 if (un->un_f_ejecting == TRUE) {
19967 mutex_exit(SD_MUTEX(un));
19970 mutex_exit(SD_MUTEX(un));
19988 SD_TRACE(SD_LOG_IO, un,
20003 un->un_f_doorlock_supported = FALSE;
20055 struct sd_lun *un;
20059 un = ssc->ssc_un;
20060 ASSERT(un != NULL);
20061 ASSERT(!mutex_owned(SD_MUTEX(un)));
20065 SD_TRACE(SD_LOG_IO, un,
20066 "sd_send_scsi_READ_CAPACITY: entry: un:0x%p\n", un);
20175 if ((un->un_f_cfg_is_atapi == TRUE) && (ISCD(un))) {
20191 * of un->un_sys_blocksize, so scale the capacity value to reflect this.
20193 if (un->un_f_has_removable_media)
20194 capacity *= (lbasize / un->un_sys_blocksize);
20205 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_READ_CAPACITY: "
20274 struct sd_lun *un;
20278 un = ssc->ssc_un;
20279 ASSERT(un != NULL);
20280 ASSERT(!mutex_owned(SD_MUTEX(un)));
20284 SD_TRACE(SD_LOG_IO, un,
20285 "sd_send_scsi_READ_CAPACITY: entry: un:0x%p\n", un);
20405 if ((un->un_f_cfg_is_atapi == TRUE) && (ISCD(un))) {
20421 * of un->un_sys_blocksize, so scale the capacity value to reflect this.
20423 if (un->un_f_has_removable_media)
20424 capacity *= (lbasize / un->un_sys_blocksize);
20430 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_READ_CAPACITY_16: "
20482 struct sd_lun *un;
20485 un = ssc->ssc_un;
20486 ASSERT(un != NULL);
20487 ASSERT(!mutex_owned(SD_MUTEX(un)));
20489 SD_TRACE(SD_LOG_IO, un,
20490 "sd_send_scsi_START_STOP_UNIT: entry: un:0x%p\n", un);
20492 if (un->un_f_check_start_stop &&
20495 (un->un_f_start_stop_supported != TRUE)) {
20505 mutex_enter(SD_MUTEX(un));
20506 if (un->un_f_ejecting == TRUE) {
20507 mutex_exit(SD_MUTEX(un));
20510 mutex_exit(SD_MUTEX(un));
20569 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_START_STOP_UNIT: exit\n");
20589 struct sd_lun *un = arg;
20590 ASSERT(un != NULL);
20591 ASSERT(!mutex_owned(SD_MUTEX(un)));
20593 SD_TRACE(SD_LOG_IO, un, "sd_start_stop_unit_callback: entry\n");
20595 (void) taskq_dispatch(sd_tq, sd_start_stop_unit_task, un, KM_NOSLEEP);
20612 struct sd_lun *un = arg;
20617 ASSERT(un != NULL);
20618 ASSERT(!mutex_owned(SD_MUTEX(un)));
20620 SD_TRACE(SD_LOG_IO, un, "sd_start_stop_unit_task: entry\n");
20626 mutex_enter(SD_MUTEX(un));
20627 if (un->un_f_format_in_progress == TRUE) {
20628 mutex_exit(SD_MUTEX(un));
20631 mutex_exit(SD_MUTEX(un));
20633 ssc = sd_ssc_init(un);
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));
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));
20691 SD_TRACE(SD_LOG_IO, un, "sd_start_stop_unit_task: exit\n");
20721 struct sd_lun *un;
20724 un = ssc->ssc_un;
20725 ASSERT(un != NULL);
20726 ASSERT(!mutex_owned(SD_MUTEX(un)));
20729 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_INQUIRY: entry: un:0x%p\n", un);
20763 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_INQUIRY: exit\n");
20803 struct sd_lun *un;
20806 un = ssc->ssc_un;
20807 ASSERT(un != NULL);
20808 ASSERT(!mutex_owned(SD_MUTEX(un)));
20810 SD_TRACE(SD_LOG_IO, un,
20811 "sd_send_scsi_TEST_UNIT_READY: entry: un:0x%p\n", un);
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));
20829 mutex_exit(SD_MUTEX(un));
20884 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_TEST_UNIT_READY: exit\n");
20914 struct sd_lun *un;
20917 un = ssc->ssc_un;
20918 ASSERT(un != NULL);
20919 ASSERT(!mutex_owned(SD_MUTEX(un)));
20922 SD_TRACE(SD_LOG_IO, un,
20923 "sd_send_scsi_PERSISTENT_RESERVE_IN: entry: un:0x%p\n", un);
20977 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_PERSISTENT_RESERVE_IN: exit\n");
20995 * Arguments: ssc - ssc contains un - pointer to soft state struct
21022 struct sd_lun *un;
21025 un = ssc->ssc_un;
21026 ASSERT(un != NULL);
21027 ASSERT(!mutex_owned(SD_MUTEX(un)));
21030 SD_TRACE(SD_LOG_IO, un,
21031 "sd_send_scsi_PERSISTENT_RESERVE_OUT: entry: un:0x%p\n", un);
21134 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_PERSISTENT_RESERVE_OUT: exit\n");
21144 * Arguments: un - pointer to the target's soft state struct
21176 sd_send_scsi_SYNCHRONIZE_CACHE(struct sd_lun *un, struct dk_callback *dkc)
21185 SD_TRACE(SD_LOG_IO, un,
21186 "sd_send_scsi_SYNCHRONIZE_CACHE: entry: un:0x%p\n", un);
21188 ASSERT(un != NULL);
21189 ASSERT(!mutex_owned(SD_MUTEX(un)));
21197 mutex_enter(SD_MUTEX(un));
21199 if (un->un_f_suppress_cache_flush == TRUE) {
21200 mutex_exit(SD_MUTEX(un));
21205 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_SYNCHRONIZE_CACHE: \
21207 un->un_f_suppress_cache_flush);
21215 mutex_exit(SD_MUTEX(un));
21224 mutex_enter(SD_MUTEX(un));
21225 if (dkc != NULL && un->un_f_sync_nv_supported &&
21233 mutex_exit(SD_MUTEX(un));
21277 bp->b_edev = SD_GET_DEV(un);
21283 mutex_enter(SD_MUTEX(un));
21284 un->un_f_sync_cache_required = FALSE;
21285 mutex_exit(SD_MUTEX(un));
21312 struct sd_lun *un;
21325 un = ddi_get_soft_state(sd_state, SD_GET_INSTANCE_FROM_BUF(bp));
21326 ASSERT(un != NULL);
21347 mutex_enter(SD_MUTEX(un));
21348 un->un_f_sync_nv_supported = FALSE;
21349 mutex_exit(SD_MUTEX(un));
21351 SD_TRACE(SD_LOG_IO, un,
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,
21379 mutex_enter(SD_MUTEX(un));
21380 un->un_f_sync_cache_required = TRUE;
21381 mutex_exit(SD_MUTEX(un));
21387 if (!un->un_f_has_removable_media) {
21388 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
21438 struct sd_lun *un;
21441 un = ssc->ssc_un;
21442 ASSERT(un != NULL);
21443 ASSERT(!mutex_owned(SD_MUTEX(un)));
21448 SD_TRACE(SD_LOG_IO, un,
21449 "sd_send_scsi_GET_CONFIGURATION: entry: un:0x%p\n", un);
21492 SD_DUMP_MEMORY(un, SD_LOG_IO,
21497 SD_TRACE(SD_LOG_IO, un,
21530 struct sd_lun *un;
21533 un = ssc->ssc_un;
21534 ASSERT(un != NULL);
21535 ASSERT(!mutex_owned(SD_MUTEX(un)));
21540 SD_TRACE(SD_LOG_IO, un,
21541 "sd_send_scsi_feature_GET_CONFIGURATION: entry: un:0x%p\n", un);
21585 SD_DUMP_MEMORY(un, SD_LOG_IO,
21590 SD_TRACE(SD_LOG_IO, un,
21632 struct sd_lun *un;
21635 un = ssc->ssc_un;
21636 ASSERT(un != NULL);
21637 ASSERT(!mutex_owned(SD_MUTEX(un)));
21642 SD_TRACE(SD_LOG_IO, un,
21643 "sd_send_scsi_MODE_SENSE: entry: un:0x%p\n", un);
21663 SD_FILL_SCSI1_LUN_CDB(un, &cdb);
21706 SD_DUMP_MEMORY(un, SD_LOG_IO, "sd_send_scsi_MODE_SENSE: data",
21709 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_MODE_SENSE: exit\n");
21749 struct sd_lun *un;
21752 un = ssc->ssc_un;
21753 ASSERT(un != NULL);
21754 ASSERT(!mutex_owned(SD_MUTEX(un)));
21759 SD_TRACE(SD_LOG_IO, un,
21760 "sd_send_scsi_MODE_SELECT: entry: un:0x%p\n", un);
21782 SD_FILL_SCSI1_LUN_CDB(un, &cdb);
21814 SD_DUMP_MEMORY(un, SD_LOG_IO, "sd_send_scsi_MODE_SELECT: data",
21817 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_MODE_SELECT: exit\n");
21859 struct sd_lun *un;
21862 un = ssc->ssc_un;
21863 ASSERT(un != NULL);
21864 ASSERT(!mutex_owned(SD_MUTEX(un)));
21868 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_RDWR: entry: un:0x%p\n", un);
21870 if (un->un_f_tgt_blocksize_is_valid != TRUE) {
21874 mutex_enter(SD_MUTEX(un));
21875 block_count = SD_BYTES2TGTBLOCKS(un, buflen);
21876 mutex_exit(SD_MUTEX(un));
21880 SD_INFO(SD_LOG_IO, un, "sd_send_scsi_RDWR: "
21892 (un->un_f_cfg_is_atapi == TRUE))
21920 SD_FILL_SCSI1_LUN_CDB(un, &cdb);
21951 SD_DUMP_MEMORY(un, SD_LOG_IO, "sd_send_scsi_RDWR: data",
21955 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_RDWR: exit\n");
21985 struct sd_lun *un;
21988 un = ssc->ssc_un;
21989 ASSERT(un != NULL);
21990 ASSERT(!mutex_owned(SD_MUTEX(un)));
21992 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_LOG_SENSE: entry: un:0x%p\n", un);
22051 mutex_enter(SD_MUTEX(un));
22052 un->un_start_stop_cycle_page =
22056 un->un_start_stop_cycle_page;
22057 mutex_exit(SD_MUTEX(un));
22082 SD_DUMP_MEMORY(un, SD_LOG_IO, "sd_send_scsi_LOG_SENSE: data",
22086 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_LOG_SENSE: exit\n");
22116 struct sd_lun *un;
22119 un = ssc->ssc_un;
22120 ASSERT(un != NULL);
22121 ASSERT(!mutex_owned(SD_MUTEX(un)));
22124 SD_TRACE(SD_LOG_IO, un,
22125 "sd_send_scsi_GET_EVENT_STATUS_NOTIFICATION: entry: un:0x%p\n", un);
22160 SD_TRACE(SD_LOG_IO, un,
22207 struct sd_lun *un = NULL;
22219 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
22223 ASSERT(!mutex_owned(SD_MUTEX(un)));
22226 ssc = sd_ssc_init(un);
22228 is_valid = SD_IS_VALID_LABEL(un);
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));
22249 un->un_ncmds_in_driver++;
22297 if (!ISCD(un)) {
22298 un->un_ncmds_in_driver--;
22299 ASSERT(un->un_ncmds_in_driver >= 0);
22300 mutex_exit(SD_MUTEX(un));
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));
22317 mutex_exit(SD_MUTEX(un));
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));
22327 mutex_enter(SD_MUTEX(un));
22353 mutex_exit(SD_MUTEX(un));
22355 mutex_enter(SD_MUTEX(un));
22369 if (un->un_f_has_removable_media) {
22379 un->un_ncmds_in_driver--;
22380 ASSERT(un->un_ncmds_in_driver >= 0);
22381 mutex_exit(SD_MUTEX(un));
22389 mutex_exit(SD_MUTEX(un));
22393 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCINFO\n");
22398 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCGMEDIAINFO\n");
22403 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCGMEDIAINFOEXT\n");
22427 SD_TRACE(SD_LOG_IOCTL, un, "DKIOC %d\n", cmd);
22431 if (un->un_f_has_removable_media)
22441 err = cmlb_ioctl(un->un_cmlbhandle, dev,
22446 (un->un_f_pkstats_enabled) &&
22450 tmprval = cmlb_validate(un->un_cmlbhandle, CMLB_SILENT,
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);
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),
22478 ddi_devid_free(un->un_devid);
22479 un->un_devid = NULL;
22483 mutex_exit(SD_MUTEX(un));
22489 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCLOCK\n");
22495 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCUNLOCK\n");
22502 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCSTATE\n");
22509 if (ddi_copyout(&un->un_mediastate, (void *)arg,
22518 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCREMOVABLE\n");
22519 i = un->un_f_has_removable_media ? 1 : 0;
22528 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCSOLIDSTATE\n");
22529 i = un->un_f_is_solid_state ? 1 : 0;
22538 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCHOTPLUGGABLE\n");
22539 i = un->un_f_is_hotpluggable ? 1 : 0;
22548 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCREADONLY\n");
22550 if ((ISCD(un) && !un->un_f_mmc_writable_media) ||
22562 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCGTEMPERATURE\n");
22567 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCENFAILFAST\n");
22574 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCTKOWN\n");
22581 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCRELEASE\n");
22588 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCSTATUS\n");
22607 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCQRESERVE\n");
22614 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCREREGISTERDEVID\n");
22617 } else if (!un->un_f_devid_supported) {
22625 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCGRP_INKEYS\n");
22627 if (un->un_reservation_type == SD_SCSI2_RESERVATION) {
22637 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCGRP_INRESV\n");
22639 if (un->un_reservation_type == SD_SCSI2_RESERVATION) {
22648 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCGRP_REGISTER\n");
22650 if (un->un_reservation_type == SD_SCSI2_RESERVATION) {
22670 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCGRP_CLEAR\n");
22672 if (un->un_reservation_type == SD_SCSI2_RESERVATION) {
22692 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCGRP_RESERVE\n");
22694 if (un->un_reservation_type == SD_SCSI2_RESERVATION) {
22714 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCGRP_PREEMPTANDABORT\n");
22716 if (un->un_reservation_type == SD_SCSI2_RESERVATION) {
22737 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCGRP_REGISTERANDIGNOREKEY\n");
22739 if (un->un_reservation_type == SD_SCSI2_RESERVATION) {
22760 SD_TRACE(SD_LOG_IOCTL, un, "USCSICMD\n");
22769 if (un->un_f_format_in_progress == TRUE) {
22786 SD_TRACE(SD_LOG_IOCTL, un, "PAUSE-RESUME\n");
22787 if (!ISCD(un)) {
22795 SD_TRACE(SD_LOG_IOCTL, un, "CDROMPLAYMSF\n");
22796 if (!ISCD(un)) {
22804 SD_TRACE(SD_LOG_IOCTL, un, "CDROMPLAYTRKIND\n");
22809 if (!ISCD(un) || (un->un_f_cfg_is_atapi == TRUE)) {
22811 if (!ISCD(un)) {
22820 SD_TRACE(SD_LOG_IOCTL, un, "CDROMREADTOCHDR\n");
22821 if (!ISCD(un)) {
22829 SD_TRACE(SD_LOG_IOCTL, un, "CDROMREADTOCENTRY\n");
22830 if (!ISCD(un)) {
22838 SD_TRACE(SD_LOG_IOCTL, un, "CDROMSTOP\n");
22839 if (!ISCD(un)) {
22849 SD_TRACE(SD_LOG_IOCTL, un, "CDROMSTART\n");
22850 if (!ISCD(un)) {
22860 SD_TRACE(SD_LOG_IOCTL, un, "CDROMCLOSETRAY\n");
22861 if (!ISCD(un)) {
22873 SD_TRACE(SD_LOG_IOCTL, un, "EJECT\n");
22874 if (!un->un_f_eject_media_supported) {
22882 SD_TRACE(SD_LOG_IOCTL, un, "CDROMVOLCTRL\n");
22883 if (!ISCD(un)) {
22891 SD_TRACE(SD_LOG_IOCTL, un, "CDROMSUBCHNL\n");
22892 if (!ISCD(un)) {
22900 SD_TRACE(SD_LOG_IOCTL, un, "CDROMREADMODE2\n");
22901 if (!ISCD(un)) {
22903 } else if (un->un_f_cfg_is_atapi == TRUE) {
22916 SD_TRACE(SD_LOG_IOCTL, un, "CDROMREADMODE1\n");
22917 if (!ISCD(un)) {
22925 SD_TRACE(SD_LOG_IOCTL, un, "CDROMREADOFFSET\n");
22926 if (!ISCD(un)) {
22935 SD_TRACE(SD_LOG_IOCTL, un, "CDROMSBLKMODE\n");
22940 if (!ISCD(un) || (un->un_f_cfg_is_atapi == TRUE)) {
22942 } else if (un->un_f_mmc_cap == TRUE) {
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));
22960 mutex_exit(SD_MUTEX(un));
22967 SD_TRACE(SD_LOG_IOCTL, un, "CDROMGBLKMODE\n");
22968 if (!ISCD(un)) {
22970 } else if ((un->un_f_cfg_is_atapi != FALSE) &&
22971 (un->un_f_blockcount_is_valid != FALSE)) {
22978 if (ddi_copyout(&un->un_tgt_blocksize, (void *)arg,
22996 SD_TRACE(SD_LOG_IOCTL, un, "CDROMXDRVSPEED\n");
22997 if (!ISCD(un)) {
22999 } else if (un->un_f_mmc_cap == TRUE) {
23028 } else if (un->un_f_cfg_is_atapi == TRUE) {
23036 SD_TRACE(SD_LOG_IOCTL, un, "CDROMCDDA\n");
23037 if (!ISCD(un)) {
23045 SD_TRACE(SD_LOG_IOCTL, un, "CDROMCDXA\n");
23046 if (!ISCD(un)) {
23054 SD_TRACE(SD_LOG_IOCTL, un, "CDROMSUBCODE\n");
23055 if (!ISCD(un)) {
23071 SD_INFO(SD_LOG_IOCTL, un, "sdioctl: DKIOCRESET: "
23073 if (scsi_reset(SD_ADDRESS(un), reset_level)) {
23083 SD_INFO(SD_LOG_IOCTL, un, "sdioctl: DKIOCABORT:\n");
23084 if (scsi_abort(SD_ADDRESS(un), NULL)) {
23103 SD_INFO(SD_LOG_SDTEST, un, "sdioctl:"
23106 sd_faultinjection_ioctl(cmd, arg, un);
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 ?
23121 mutex_exit(SD_MUTEX(un));
23135 mutex_exit(SD_MUTEX(un));
23140 err = sd_send_scsi_SYNCHRONIZE_CACHE(un, dkc);
23143 err = sd_send_scsi_SYNCHRONIZE_CACHE(un, NULL);
23177 mutex_enter(SD_MUTEX(un));
23183 if (un->un_f_opt_disable_cache && wce) {
23184 mutex_exit(SD_MUTEX(un));
23193 while (un->un_f_wcc_inprog)
23194 cv_wait(&un->un_wcc_cv, SD_MUTEX(un));
23196 un->un_f_wcc_inprog = 1;
23198 mutex_exit(SD_MUTEX(un));
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));
23211 mutex_enter(SD_MUTEX(un));
23212 un->un_f_write_cache_enabled = (cur_wce != 0);
23214 if (un->un_f_write_cache_enabled && wce == 0) {
23220 sync_supported = un->un_f_sync_cache_supported;
23228 if (!un->un_f_suppress_cache_flush) {
23229 mutex_exit(SD_MUTEX(un));
23234 err = sd_send_scsi_SYNCHRONIZE_CACHE(un,
23238 mutex_exit(SD_MUTEX(un));
23241 mutex_enter(SD_MUTEX(un));
23243 un->un_f_write_cache_enabled = 0;
23246 } else if (!un->un_f_write_cache_enabled && wce != 0) {
23252 un->un_f_write_cache_enabled = 1;
23260 if (!un->un_f_suppress_cache_flush) {
23261 mutex_exit(SD_MUTEX(un));
23265 mutex_exit(SD_MUTEX(un));
23268 mutex_enter(SD_MUTEX(un));
23271 un->un_f_write_cache_enabled = 0;
23275 un->un_f_wcc_inprog = 0;
23276 cv_broadcast(&un->un_wcc_cv);
23277 mutex_exit(SD_MUTEX(un));
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));
23294 SD_TRACE(SD_LOG_IOCTL, un, "sdioctl: exit: %d\n", err);
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));
23309 SD_TRACE(SD_LOG_IOCTL, un, "sdioctl: exit: %d\n", err);
23334 struct sd_lun *un = NULL;
23339 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
23346 switch (un->un_ctype) {
23354 pdip = ddi_get_parent(SD_DEVINFO(un));
23363 lun = ddi_prop_get_int(DDI_DEV_T_ANY, SD_DEVINFO(un),
23365 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, SD_DEVINFO(un),
23369 info->dki_unit = ddi_get_instance(SD_DEVINFO(un));
23371 (void) strncpy(info->dki_dname, ddi_driver_name(SD_DEVINFO(un)),
23377 info->dki_maxtransfer = un->un_max_xfer_size / un->un_sys_blocksize;
23414 struct sd_lun *un = NULL;
23427 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
23428 (un->un_state == SD_STATE_OFFLINE)) {
23432 SD_TRACE(SD_LOG_IOCTL_DKIO, un, "sd_get_media_info_com: entry\n");
23436 ssc = sd_ssc_init(un);
23447 if (ISCD(un)) {
23451 if (un->un_f_mmc_cap == TRUE) {
23491 sinq = un->un_sd->sd_inq;
23519 if (dki_pbsize && un->un_f_descr_format_supported) {
23527 pbsize = MAX(pbsize, un->un_phy_blocksize);
23531 !un->un_f_descr_format_supported) {
23537 if (un->un_f_enable_rmw &&
23538 un->un_phy_blocksize != 0) {
23539 pbsize = un->un_phy_blocksize;
23547 * un->un_sys_blocksize chunks. So we need to convert
23550 if (un->un_f_has_removable_media) {
23551 media_capacity *= un->un_sys_blocksize;
23563 if (un->un_f_enable_rmw &&
23574 * If lun is expanded dynamically, update the un structure.
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);
23583 mutex_exit(SD_MUTEX(un));
23680 sd_watch_request_submit(struct sd_lun *un)
23685 dev = sd_make_device(SD_DEVINFO(un));
23687 if (un->un_f_mmc_cap && un->un_f_mmc_gesn_polling) {
23688 return (scsi_mmc_watch_request_submit(SD_SCSI_DEVP(un),
23692 return (scsi_watch_request_submit(SD_SCSI_DEVP(un),
23725 struct sd_lun *un = NULL;
23731 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
23735 SD_TRACE(SD_LOG_COMMON, un, "sd_check_media: entry\n");
23737 ssc = sd_ssc_init(un);
23739 mutex_enter(SD_MUTEX(un));
23741 SD_TRACE(SD_LOG_COMMON, un, "sd_check_media: "
23742 "state=%x, mediastate=%x\n", state, un->un_mediastate);
23744 prev_state = un->un_mediastate;
23747 if (state == un->un_mediastate || un->un_mediastate == DKIO_NONE) {
23752 mutex_exit(SD_MUTEX(un));
23761 if (sd_pm_entry(un) != DDI_SUCCESS) {
23762 mutex_enter(SD_MUTEX(un));
23766 token = sd_watch_request_submit(un);
23768 sd_pm_exit(un);
23770 mutex_enter(SD_MUTEX(un));
23785 un->un_ncmds_in_driver--;
23786 ASSERT(un->un_ncmds_in_driver >= 0);
23792 un->un_swr_token = token;
23793 un->un_specified_mediastate = state;
23801 SD_TRACE(SD_LOG_COMMON, un,
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,
23808 un->un_ncmds_in_driver++;
23812 SD_TRACE(SD_LOG_COMMON, un,
23814 un->un_mediastate);
23820 un->un_ncmds_in_driver++;
23824 if (prev_state == DKIO_INSERTED && un->un_mediastate == DKIO_EJECTED) {
23825 sr_ejected(un);
23828 if (un->un_mediastate == DKIO_INSERTED && prev_state != DKIO_INSERTED) {
23832 SD_TRACE(SD_LOG_COMMON, un, "sd_check_media: media inserted\n");
23833 mutex_exit(SD_MUTEX(un));
23840 if (sd_pm_entry(un) == DDI_SUCCESS) {
23844 sd_pm_exit(un);
23850 mutex_enter(SD_MUTEX(un));
23855 mutex_enter(SD_MUTEX(un));
23858 mutex_enter(SD_MUTEX(un));
23860 sd_update_block_info(un, lbasize, capacity);
23865 if (ISCD(un)) {
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);
23882 sd_pm_exit(un);
23891 mutex_enter(SD_MUTEX(un));
23895 un->un_f_watcht_stopped = FALSE;
23896 if (token != NULL && un->un_swr_token != NULL) {
23902 token = un->un_swr_token;
23903 mutex_exit(SD_MUTEX(un));
23907 mutex_enter(SD_MUTEX(un));
23908 un->un_swr_token = (opaque_t)NULL;
23910 mutex_enter(SD_MUTEX(un));
23919 if (un->un_errstats) {
23922 stp = (struct sd_errstats *)un->un_errstats->ks_data;
23924 (un->un_f_blockcount_is_valid == TRUE)) {
23926 (uint64_t)((uint64_t)un->un_blockcount *
23927 un->un_sys_blocksize);
23930 mutex_exit(SD_MUTEX(un));
23931 SD_TRACE(SD_LOG_COMMON, un, "sd_check_media: done\n");
23948 struct sd_lun *un = arg;
23950 SD_TRACE(SD_LOG_COMMON, un, "sd_delayed_cv_broadcast\n");
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));
23978 struct sd_lun *un;
23986 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
23991 mutex_enter(SD_MUTEX(un));
23992 SD_TRACE(SD_LOG_COMMON, un,
23997 un->un_mediastate = DKIO_DEV_GONE;
23998 cv_broadcast(&un->un_state_cv);
23999 mutex_exit(SD_MUTEX(un));
24004 if (un->un_f_mmc_cap && un->un_f_mmc_gesn_polling) {
24014 sd_log_eject_request_event(un, KM_NOSLEEP);
24027 SD_INFO(SD_LOG_COMMON, un,
24081 mutex_exit(SD_MUTEX(un));
24091 SD_TRACE(SD_LOG_COMMON, un,
24093 state, un->un_specified_mediastate);
24100 if (state != un->un_specified_mediastate) {
24101 un->un_mediastate = state;
24107 SD_TRACE(SD_LOG_COMMON, un,
24109 if (un->un_dcvb_timeid == NULL) {
24110 un->un_dcvb_timeid =
24111 timeout(sd_delayed_cv_broadcast, un,
24115 SD_TRACE(SD_LOG_COMMON, un,
24117 cv_broadcast(&un->un_state_cv);
24120 mutex_exit(SD_MUTEX(un));
24145 struct sd_lun *un = NULL;
24152 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
24156 ssc = sd_ssc_init(un);
24176 ASSERT(!mutex_owned(&un->un_pm_mutex));
24177 mutex_enter(&un->un_pm_mutex);
24178 if (SD_DEVICE_IS_IN_LOW_POWER(un)) {
24184 mutex_exit(&un->un_pm_mutex);
24195 mutex_exit(&un->un_pm_mutex);
24196 if (sd_pm_entry(un) != DDI_SUCCESS) {
24252 sd_pm_exit(un);
24289 struct sd_lun *un;
24292 un = ssc->ssc_un;
24293 ASSERT(un != NULL);
24325 SD_ERROR(SD_LOG_COMMON, un,
24367 struct sd_lun *un = NULL;
24371 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
24379 mutex_enter(SD_MUTEX(un));
24380 un->un_resvd_status |= SD_FAILFAST;
24381 mutex_exit(SD_MUTEX(un));
24391 mutex_enter(SD_MUTEX(un));
24392 un->un_resvd_status &= ~SD_FAILFAST;
24393 mutex_exit(SD_MUTEX(un));
24420 struct sd_lun *un = NULL;
24424 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
24439 mutex_enter(SD_MUTEX(un));
24441 un->un_resvd_status |= SD_RESERVE;
24452 if ((un->un_resvd_status & SD_FAILFAST) == 0) {
24453 mutex_exit(SD_MUTEX(un));
24455 SD_TRACE(SD_LOG_IOCTL_MHD, un,
24459 mutex_exit(SD_MUTEX(un));
24461 (void) scsi_reset_notify(SD_ADDRESS(un), SCSI_RESET_NOTIFY,
24462 sd_mhd_reset_notify_cb, (caddr_t)un);
24464 un->un_resvd_status &= ~SD_RESERVE;
24465 mutex_exit(SD_MUTEX(un));
24492 struct sd_lun *un = NULL;
24497 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
24501 mutex_enter(SD_MUTEX(un));
24502 resvd_status_save = un->un_resvd_status;
24503 un->un_resvd_status &=
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));
24511 mutex_exit(SD_MUTEX(un));
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));
24527 mutex_exit(SD_MUTEX(un));
24529 (void) scsi_reset_notify(SD_ADDRESS(un), SCSI_RESET_CANCEL,
24530 sd_mhd_reset_notify_cb, (caddr_t)un);
24535 mutex_enter(SD_MUTEX(un));
24536 un->un_resvd_status = resvd_status_save;
24537 mutex_exit(SD_MUTEX(un));
24562 struct sd_lun *un = NULL;
24566 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
24570 ASSERT(!mutex_owned(SD_MUTEX(un)));
24572 mutex_enter(SD_MUTEX(un));
24575 if (un->un_devid != NULL) {
24576 ddi_devid_unregister(SD_DEVINFO(un));
24580 ddi_devid_free(un->un_devid);
24581 un->un_devid = NULL;
24585 mutex_exit(SD_MUTEX(un));
24586 ssc = sd_ssc_init(un);
24588 mutex_enter(SD_MUTEX(un));
24592 sd_register_devid(ssc, SD_DEVINFO(un), SD_TARGET_IS_UNRESERVED);
24600 mutex_exit(SD_MUTEX(un));
24632 struct sd_lun *un;
24636 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
24650 if ((rval = sd_persistent_reservation_in_read_keys(un,
24666 if ((rval = sd_persistent_reservation_in_read_keys(un,
24682 rval = sd_persistent_reservation_in_read_keys(un, &inkeys, flag);
24716 struct sd_lun *un;
24720 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
24735 if ((rval = sd_persistent_reservation_in_read_resv(un,
24751 if ((rval = sd_persistent_reservation_in_read_resv(un,
24767 rval = sd_persistent_reservation_in_read_resv(un, &inresvs, flag);
24858 struct sd_lun *un;
24861 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
24867 mutex_enter(SD_MUTEX(un));
24869 if (un->un_mhd_token) {
24870 token = un->un_mhd_token;
24871 un->un_mhd_token = NULL;
24872 mutex_exit(SD_MUTEX(un));
24875 mutex_enter(SD_MUTEX(un));
24877 mutex_exit(SD_MUTEX(un));
24891 if (un->un_resvd_status & SD_RESERVE) {
24895 mutex_exit(SD_MUTEX(un));
24898 mutex_exit(SD_MUTEX(un));
24913 token = scsi_watch_request_submit(SD_SCSI_DEVP(un), interval,
24922 mutex_enter(SD_MUTEX(un));
24923 un->un_mhd_token = token;
24924 mutex_exit(SD_MUTEX(un));
24953 struct sd_lun *un;
24966 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
24970 SD_TRACE(SD_LOG_IOCTL_MHD, un,
24977 sd_mhd_watch_incomplete(un, pkt);
24987 mutex_enter(SD_MUTEX(un));
24988 if ((un->un_resvd_status & SD_FAILFAST) &&
24990 sd_panic_for_res_conflict(un);
24993 SD_INFO(SD_LOG_IOCTL_MHD, un,
24995 un->un_resvd_status |= SD_RESERVATION_CONFLICT;
24996 mutex_exit(SD_MUTEX(un));
25002 mutex_enter(SD_MUTEX(un));
25005 (un->un_resvd_status & SD_RESERVE)) {
25011 un->un_resvd_status |=
25013 SD_INFO(SD_LOG_IOCTL_MHD, un,
25020 mutex_enter(SD_MUTEX(un));
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) {
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));
25035 mutex_enter(SD_MUTEX(un));
25037 un->un_resvd_status &= ~SD_WANT_RESERVE;
25039 if (un->un_resvd_timeid == 0) {
25041 un->un_resvd_timeid = timeout(sd_mhd_resvd_recover,
25046 mutex_exit(SD_MUTEX(un));
25059 * Arguments: un - driver soft state (unit) structure
25064 sd_mhd_watch_incomplete(struct sd_lun *un, struct scsi_pkt *pkt)
25070 ASSERT(un != NULL);
25074 mutex_enter(SD_MUTEX(un));
25075 if (un->un_state == SD_STATE_DUMPING) {
25076 mutex_exit(SD_MUTEX(un));
25105 un->un_tagflags = 0;
25107 if (un->un_f_opt_queueing == TRUE) {
25108 un->un_throttle = min(un->un_throttle, 3);
25110 un->un_throttle = 1;
25112 mutex_exit(SD_MUTEX(un));
25113 (void) scsi_ifsetcap(SD_ADDRESS(un), "tagged-qing", 0, 1);
25114 mutex_enter(SD_MUTEX(un));
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) {
25142 scsi_reset(SD_ADDRESS(un),
25147 scsi_reset(SD_ADDRESS(un),
25152 (void) scsi_reset(SD_ADDRESS(un), RESET_ALL);
25154 mutex_enter(SD_MUTEX(un));
25162 if ((un->un_resvd_status & SD_RESERVE) == SD_RESERVE) {
25163 un->un_resvd_status |=
25165 SD_INFO(SD_LOG_IOCTL_MHD, un,
25176 SD_INFO(SD_LOG_IOCTL_MHD, un, "sd_mhd_watch_incomplete: "
25178 if (un->un_state != SD_STATE_OFFLINE) {
25179 New_state(un, SD_STATE_OFFLINE);
25187 if (pkt->pkt_reason != un->un_last_pkt_reason) {
25188 SD_ERROR(SD_LOG_IOCTL_MHD, un,
25194 un->un_last_pkt_reason = pkt->pkt_reason;
25195 mutex_exit(SD_MUTEX(un));
25260 struct sd_lun *un;
25266 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
25270 mutex_enter(SD_MUTEX(un));
25271 un->un_resvd_timeid = NULL;
25272 if (un->un_resvd_status & SD_WANT_RESERVE) {
25278 mutex_exit(SD_MUTEX(un));
25281 mutex_exit(SD_MUTEX(un));
25316 SD_INFO(SD_LOG_IOCTL_MHD, un, "sd_mhd_resvd_recover: "
25351 struct sd_lun *un;
25363 un = ddi_get_soft_state(sd_state,
25365 if (un == NULL) {
25387 mutex_enter(SD_MUTEX(un));
25388 if ((un->un_resvd_status & SD_RESERVE) == SD_RESERVE) {
25396 un->un_resvd_status &= ~SD_LOST_RESERVE;
25397 mutex_exit(SD_MUTEX(un));
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,
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,
25416 mutex_exit(SD_MUTEX(un));
25427 SD_TRACE(SD_LOG_IOCTL_MHD, un,
25505 struct sd_lun *un = (struct sd_lun *)arg;
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,
25513 mutex_exit(SD_MUTEX(un));
25560 struct sd_lun *un;
25572 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
25581 SD_ERROR(SD_LOG_IOCTL_MHD, un,
25587 mutex_enter(SD_MUTEX(un));
25588 un->un_resvd_status |= SD_RESERVE;
25589 un->un_resvd_status &=
25591 mutex_exit(SD_MUTEX(un));
25601 SD_INFO(SD_LOG_IOCTL_MHD, un,
25615 mutex_enter(SD_MUTEX(un));
25616 rval = (un->un_resvd_status &
25618 mutex_exit(SD_MUTEX(un));
25624 mutex_enter(SD_MUTEX(un));
25625 if (err || (un->un_resvd_status & SD_LOST_RESERVE)) {
25632 un->un_resvd_status |= SD_RESERVE;
25633 un->un_resvd_status &= ~(SD_LOST_RESERVE | SD_WANT_RESERVE);
25634 mutex_exit(SD_MUTEX(un));
25636 SD_INFO(SD_LOG_IOCTL_MHD, un,
25651 SD_TRACE(SD_LOG_IOCTL_MHD, un,
25674 struct sd_lun *un = NULL;
25681 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
25689 com->uscsi_timeout = un->un_reserve_release_time;
25714 if (un->un_f_lun_reset_enabled == TRUE) {
25715 reset_retval = scsi_reset(SD_ADDRESS(un), RESET_LUN);
25719 reset_retval = scsi_reset(SD_ADDRESS(un), RESET_TARGET);
25722 (scsi_reset(SD_ADDRESS(un), RESET_ALL) == 0)) {
25764 struct sd_lun *un;
25781 if (((un = ddi_get_soft_state(sd_state, instance)) == NULL) ||
25782 !SD_IS_VALID_LABEL(un) || ISCD(un)) {
25786 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*un))
25788 SD_TRACE(SD_LOG_DUMP, un, "sddump: entry\n");
25791 SD_INFO(SD_LOG_DUMP, un, "sddump: partition = %d\n", partition);
25793 if (!(NOT_DEVBSIZE(un))) {
25797 blknomask = (un->un_tgt_blocksize / DEV_BSIZE) - 1;
25798 secmask = un->un_tgt_blocksize - 1;
25801 SD_TRACE(SD_LOG_DUMP, un,
25803 un->un_tgt_blocksize);
25808 SD_TRACE(SD_LOG_DUMP, un,
25810 un->un_tgt_blocksize);
25818 (void) cmlb_partinfo(un->un_cmlbhandle, partition,
25821 if (NOT_DEVBSIZE(un)) {
25823 SD_TRACE(SD_LOG_DUMP, un,
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,
25840 mutex_enter(&un->un_pm_mutex);
25841 if (SD_DEVICE_IS_IN_LOW_POWER(un)) {
25844 mutex_exit(&un->un_pm_mutex);
25849 (void) pm_raise_power(SD_DEVINFO(un), 0,
25850 SD_PM_STATE_ACTIVE(un));
25857 SD_INFO(SD_LOG_DUMP, un, "sddump: starting device\n");
25859 start_pktp = scsi_init_pkt(SD_ADDRESS(un), NULL, NULL,
25860 CDB_GROUP0, un->un_status_len, 0, 0, NULL_FUNC, NULL);
25871 mutex_enter(SD_MUTEX(un));
25872 SD_FILL_SCSI1_LUN(un, start_pktp);
25873 mutex_exit(SD_MUTEX(un));
25878 if (sd_scsi_poll(un, start_pktp) != 0) {
25883 (void) sd_pm_state_change(un, SD_PM_STATE_ACTIVE(un),
25886 mutex_exit(&un->un_pm_mutex);
25889 mutex_enter(SD_MUTEX(un));
25890 un->un_throttle = 0;
25900 if ((un->un_state != SD_STATE_SUSPENDED) &&
25901 (un->un_state != SD_STATE_DUMPING)) {
25903 New_state(un, SD_STATE_DUMPING);
25905 if (un->un_f_is_fibre == FALSE) {
25906 mutex_exit(SD_MUTEX(un));
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));
25930 if (sd_send_polled_RQS(un) == SD_FAILURE) {
25931 SD_INFO(SD_LOG_DUMP, un,
25934 mutex_enter(SD_MUTEX(un));
25942 if (NOT_DEVBSIZE(un)) {
25945 blkno = blkno / (un->un_tgt_blocksize / DEV_BSIZE);
25949 SD_INFO(SD_LOG_DUMP, un, "sddump: disk blkno = 0x%x\n", blkno);
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)) {
25966 tgt_blkno = tgt_byte_offset / un->un_tgt_blocksize;
25969 (un->un_tgt_blocksize - 1)) /
25970 un->un_tgt_blocksize) - tgt_blkno;
25978 err = sddump_do_read_of_rmw(un, tgt_blkno, tgt_nblk,
25981 mutex_exit(SD_MUTEX(un));
25990 ((uint64_t)(blkno * un->un_sys_blocksize)) -
25991 ((uint64_t)(tgt_blkno * un->un_tgt_blocksize));
25994 (io_start_offset < un->un_tgt_blocksize));
25999 (size_t)nblk * un->un_sys_blocksize);
26002 tgt_blkno = tgt_byte_offset / un->un_tgt_blocksize;
26003 tgt_nblk = tgt_byte_count / un->un_tgt_blocksize;
26018 mutex_exit(SD_MUTEX(un));
26035 if (!(NOT_DEVBSIZE(un))) {
26036 nblk = nblk / (un->un_tgt_blocksize / DEV_BSIZE);
26044 if (un->un_partial_dma_supported == 1) {
26047 un->un_tgt_blocksize);
26048 nblk = dma_resid / un->un_tgt_blocksize;
26054 rval = sd_setup_next_rw_pkt(un, wr_pktp, wr_bp,
26058 rval = sd_setup_rw_pkt(un, &wr_pktp, wr_bp,
26059 un->un_pkt_flags, NULL_FUNC, NULL,
26063 rval = sd_setup_rw_pkt(un, &wr_pktp, wr_bp,
26074 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
26079 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
26084 scsi_log(SD_DEVINFO(un), sd_label, CE_CONT,
26090 scsi_log(SD_DEVINFO(un), sd_label, CE_CONT,
26095 scsi_log(SD_DEVINFO(un), sd_label, CE_CONT,
26099 mutex_enter(SD_MUTEX(un));
26100 Restore_state(un);
26101 if (NOT_DEVBSIZE(un) && (doing_rmw == TRUE)) {
26102 mutex_exit(SD_MUTEX(un));
26105 mutex_exit(SD_MUTEX(un));
26112 if (un->un_partial_dma_supported == 1) {
26118 nblk -= SD_BYTES2TGTBLOCKS(un, dma_resid);
26138 SD_TRACE(SD_LOG_DUMP, un, "sddump: sending write\n");
26140 if ((sd_scsi_poll(un, wr_pktp) == 0) &&
26150 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
26156 SD_INFO(SD_LOG_DUMP, un,
26159 (void) sd_send_polled_RQS(un);
26168 SD_INFO(SD_LOG_DUMP, un,
26171 if (un->un_f_lun_reset_enabled == TRUE) {
26172 reset_retval = scsi_reset(SD_ADDRESS(un),
26176 (void) scsi_reset(SD_ADDRESS(un), RESET_TARGET);
26178 (void) sd_send_polled_RQS(un);
26181 SD_INFO(SD_LOG_DUMP, un,
26184 mutex_enter(SD_MUTEX(un));
26185 sd_reset_target(un, wr_pktp);
26186 mutex_exit(SD_MUTEX(un));
26194 (void) scsi_reset(SD_ADDRESS(un), RESET_ALL);
26195 (void) sd_send_polled_RQS(un);
26201 mutex_enter(SD_MUTEX(un));
26202 if ((NOT_DEVBSIZE(un)) && (doing_rmw == TRUE)) {
26203 mutex_exit(SD_MUTEX(un));
26206 mutex_exit(SD_MUTEX(un));
26208 SD_TRACE(SD_LOG_DUMP, un, "sddump: exit: err = %d\n", err);
26228 sd_scsi_poll(struct sd_lun *un, struct scsi_pkt *pktp)
26232 ASSERT(un != NULL);
26233 ASSERT(!mutex_owned(SD_MUTEX(un)));
26239 pktp->pkt_flags |= un->un_tagflags;
26256 (void) sd_send_polled_RQS(un);
26274 sd_send_polled_RQS(struct sd_lun *un)
26280 ASSERT(un != NULL);
26281 ASSERT(!mutex_owned(SD_MUTEX(un)));
26285 rqs_pktp = un->un_rqs_pktp;
26286 rqs_bp = un->un_rqs_bp;
26288 mutex_enter(SD_MUTEX(un));
26290 if (un->un_sense_isbusy) {
26292 mutex_exit(SD_MUTEX(un));
26300 un->un_sense_isbusy = 1;
26306 mutex_exit(SD_MUTEX(un));
26308 SD_INFO(SD_LOG_COMMON, un, "sd_send_polled_RQS: req sense buf at"
26316 SD_INFO(SD_LOG_COMMON, un,
26320 SD_DUMP_MEMORY(un, SD_LOG_COMMON, "sd_send_polled_RQS:",
26323 mutex_enter(SD_MUTEX(un));
26324 un->un_sense_isbusy = 0;
26325 mutex_exit(SD_MUTEX(un));
26532 * Arguments: un - Pointer to soft state struct for the target.
26547 sd_persistent_reservation_in_read_keys(struct sd_lun *un,
26567 ssc = sd_ssc_init(un);
26578 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26591 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26603 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26637 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26647 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26659 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26671 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26693 * Arguments: un - Pointer to soft state struct for the target.
26708 sd_persistent_reservation_in_read_resv(struct sd_lun *un,
26731 ssc = sd_ssc_init(un);
26741 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26754 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26765 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26799 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26809 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26821 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26844 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26890 struct sd_lun *un = NULL;
26901 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
26914 ssc = sd_ssc_init(un);
26919 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
26929 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
26963 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
26993 ssc = sd_ssc_init(un);
26999 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27010 ssc = sd_ssc_init(un);
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));
27024 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27076 struct sd_lun *un = NULL;
27087 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
27097 ssc = sd_ssc_init(un);
27103 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27113 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27148 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27176 ssc = sd_ssc_init(un);
27188 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27191 ssc = sd_ssc_init(un);
27200 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27244 struct sd_lun *un;
27258 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
27264 ssc = sd_ssc_init(un);
27270 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27280 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27319 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27355 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27389 struct sd_lun *un;
27394 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
27409 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, "sr_pause_resume:"
27452 struct sd_lun *un;
27463 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
27474 if (un->un_f_cfg_playmsf_bcd == TRUE) {
27576 struct sd_lun *un = NULL;
27592 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
27602 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27613 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27622 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27634 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27646 if (un->un_f_mmc_cap == TRUE) {
27704 struct sd_lun *un;
27716 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
27717 (un->un_state == SD_STATE_OFFLINE)) {
27768 } else if (un->un_f_cfg_readsub_bcd == TRUE) {
27823 struct sd_lun *un = NULL;
27835 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
27836 (un->un_state == SD_STATE_OFFLINE)) {
27860 if (un->un_f_cfg_read_toc_trk_bcd == TRUE) {
27891 } else if (un->un_f_cfg_read_toc_addr_bcd == TRUE) {
27998 struct sd_lun *un;
28010 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
28011 (un->un_state == SD_STATE_OFFLINE)) {
28038 if (un->un_f_cfg_read_toc_trk_bcd == TRUE) {
28090 struct sd_lun *un;
28106 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
28107 (un->un_state == SD_STATE_OFFLINE)) {
28111 SD_TRACE(SD_LOG_ATTACH_DETACH, un,
28112 "sd_read_mode1: entry: un:0x%p\n", un);
28134 ssc = sd_ssc_init(un);
28139 SD_TRACE(SD_LOG_ATTACH_DETACH, un,
28140 "sd_read_mode1: exit: un:0x%p\n", un);
28169 struct sd_lun *un;
28186 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
28187 (un->un_state == SD_STATE_OFFLINE)) {
28214 if (un->un_f_cfg_read_cd_xd4 == TRUE) {
28280 struct sd_lun *un;
28299 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
28300 (un->un_state == SD_STATE_OFFLINE)) {
28313 mutex_enter(SD_MUTEX(un));
28314 if (un->un_ncmds_in_driver != 1) {
28315 mutex_exit(SD_MUTEX(un));
28318 mutex_exit(SD_MUTEX(un));
28320 SD_TRACE(SD_LOG_ATTACH_DETACH, un,
28321 "sd_read_mode2: entry: un:0x%p\n", un);
28345 restore_blksize = un->un_tgt_blocksize;
28395 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
28407 SD_TRACE(SD_LOG_ATTACH_DETACH, un,
28408 "sd_read_mode2: exit: un:0x%p\n", un);
28434 struct sd_lun *un;
28440 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
28441 (un->un_state == SD_STATE_OFFLINE)) {
28448 ssc = sd_ssc_init(un);
28453 SD_ERROR(SD_LOG_IOCTL_RMMEDIA, un,
28470 ssc = sd_ssc_init(un);
28475 SD_ERROR(SD_LOG_IOCTL_RMMEDIA, un,
28482 mutex_enter(SD_MUTEX(un));
28483 sd_update_block_info(un, blksize, 0);
28484 mutex_exit(SD_MUTEX(un));
28518 struct sd_lun *un;
28535 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
28545 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
28555 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
28564 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
28576 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, "sr_read_cdda: "
28597 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
28608 if (un->un_f_cfg_cdda == TRUE) {
28686 struct sd_lun *un;
28704 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
28742 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, "sr_read_cdxa: "
28763 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
28772 if (un->un_f_mmc_cap == TRUE) {
28825 struct sd_lun *un;
28829 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
28830 (un->un_state == SD_STATE_OFFLINE)) {
28843 mutex_enter(SD_MUTEX(un));
28844 if (un->un_f_ejecting == TRUE) {
28845 mutex_exit(SD_MUTEX(un));
28848 un->un_f_ejecting = TRUE;
28849 mutex_exit(SD_MUTEX(un));
28851 ssc = sd_ssc_init(un);
28857 mutex_enter(SD_MUTEX(un));
28858 un->un_f_ejecting = FALSE;
28859 mutex_exit(SD_MUTEX(un));
28863 ssc = sd_ssc_init(un);
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));
28876 mutex_enter(SD_MUTEX(un));
28877 un->un_f_ejecting = FALSE;
28878 mutex_exit(SD_MUTEX(un));
28891 * Arguments: un - driver soft state (unit) structure
28895 sr_ejected(struct sd_lun *un)
28899 ASSERT(un != NULL);
28900 ASSERT(mutex_owned(SD_MUTEX(un)));
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));
28908 if (un->un_errstats != NULL) {
28909 stp = (struct sd_errstats *)un->un_errstats->ks_data;
28936 struct sd_lun *un;
28948 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
28952 if (un->un_f_cfg_is_atapi == TRUE) {
28959 ssc = sd_ssc_init(un);
28970 ssc = sd_ssc_init(un);
29016 struct sd_lun *un;
29032 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
29033 (un->un_state == SD_STATE_OFFLINE)) {
29041 if ((un->un_f_cfg_is_atapi == TRUE) || (un->un_f_mmc_cap == TRUE)) {
29051 ssc = sd_ssc_init(un);
29058 SD_ERROR(SD_LOG_IOCTL_RMMEDIA, un,
29069 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
29090 ssc = sd_ssc_init(un);
29097 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
29106 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
29147 ssc = sd_ssc_init(un);
29148 if ((un->un_f_cfg_is_atapi == TRUE) || (un->un_f_mmc_cap == TRUE)) {
29189 struct sd_lun *un;
29200 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
29201 (un->un_state == SD_STATE_OFFLINE)) {
29237 if (un->un_tgt_blocksize == CDROM_BLK_512) {
29239 } else if (un->un_tgt_blocksize == CDROM_BLK_1024) {
29261 * un - sd_lun structure for the device.
29270 sd_wm_cache_constructor(void *wm, void *un, int flags)
29285 * un - sd_lun structure for the device.
29289 sd_wm_cache_destructor(void *wm, void *un)
29304 * Arguments: un - sd_lun structure for the device.
29315 sd_range_lock(struct sd_lun *un, daddr_t startb, daddr_t endb, ushort_t typ)
29323 ASSERT(un != NULL);
29324 ASSERT(!mutex_owned(SD_MUTEX(un)));
29326 mutex_enter(SD_MUTEX(un));
29336 if (!(typ & SD_WTYPE_RMW) && !(un->un_rmw_count)) {
29344 tmp_wmp = sd_get_range(un, startb, endb);
29346 if ((wmp != NULL) && ONLIST(un, wmp)) {
29352 FREE_ONLIST_WMAP(un, wmp);
29370 ASSERT(un->un_wm_cache);
29378 wmp = kmem_cache_alloc(un->un_wm_cache,
29381 mutex_exit(SD_MUTEX(un));
29384 wmp = kmem_cache_alloc(un->un_wm_cache,
29386 mutex_enter(SD_MUTEX(un));
29403 un->un_rmw_count++;
29408 if (!ONLIST(un, wmp)) {
29409 wmp->wm_next = un->un_wm;
29413 un->un_wm = wmp;
29426 cv_wait(&sl_wmp->wm_avail, SD_MUTEX(un));
29436 CHK_N_FREEWMP(un, wmp);
29455 mutex_exit(SD_MUTEX(un));
29469 * Arguments: un - sd_lun structure for the device.
29477 sd_get_range(struct sd_lun *un, daddr_t startb, daddr_t endb)
29481 ASSERT(un != NULL);
29483 for (wmp = un->un_wm; wmp != NULL; wmp = wmp->wm_next) {
29504 * Arguments: un - sd_lun structure for the device.
29509 sd_free_inlist_wmap(struct sd_lun *un, struct sd_w_map *wmp)
29511 ASSERT(un != NULL);
29513 if (un->un_wm == wmp) {
29514 un->un_wm = wmp->wm_next;
29525 kmem_cache_free(un->un_wm_cache, wmp);
29535 * Arguments: un - sd_lun structure for the device.
29540 sd_range_unlock(struct sd_lun *un, struct sd_w_map *wm)
29542 ASSERT(un != NULL);
29544 ASSERT(!mutex_owned(SD_MUTEX(un)));
29546 mutex_enter(SD_MUTEX(un));
29549 un->un_rmw_count--;
29562 sd_free_inlist_wmap(un, wm);
29565 mutex_exit(SD_MUTEX(un));
29574 * un->un_sys_blocksize != un->un_tgt_blocksize.
29587 struct sd_lun *un;
29598 un = SD_GET_UN(bp);
29599 ASSERT(un != NULL);
29600 ASSERT(!mutex_owned(SD_MUTEX(un)));
29602 SD_TRACE(SD_LOG_IO_RMMEDIA, un,
29613 SD_NEXT_IOSTART(bsp->mbs_layer_index, un, bp);
29615 SD_TRACE(SD_LOG_IO_RMMEDIA, un,
29630 * Arguments: un - sd_lun
29641 sddump_do_read_of_rmw(struct sd_lun *un, uint64_t blkno, uint64_t nblk,
29651 ASSERT(un != NULL);
29652 ASSERT(mutex_owned(SD_MUTEX(un)));
29654 target_blocksize = un->un_tgt_blocksize;
29656 mutex_exit(SD_MUTEX(un));
29658 bp = scsi_alloc_consistent_buf(SD_ADDRESS(un), (struct buf *)NULL,
29661 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
29667 rval = sd_setup_rw_pkt(un, &pkt, bp, 0, NULL_FUNC, NULL,
29671 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
29690 SD_TRACE(SD_LOG_DUMP, un, "sddump: sending read\n");
29692 if ((sd_scsi_poll(un, pkt) == 0) && (pkt->pkt_resid == 0)) {
29702 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
29709 SD_INFO(SD_LOG_DUMP, un,
29712 (void) sd_send_polled_RQS(un);
29721 SD_INFO(SD_LOG_DUMP, un,
29724 if (un->un_f_lun_reset_enabled == TRUE) {
29725 reset_retval = scsi_reset(SD_ADDRESS(un),
29729 (void) scsi_reset(SD_ADDRESS(un), RESET_TARGET);
29731 (void) sd_send_polled_RQS(un);
29734 SD_INFO(SD_LOG_DUMP, un,
29737 mutex_enter(SD_MUTEX(un));
29738 sd_reset_target(un, pkt);
29739 mutex_exit(SD_MUTEX(un));
29747 (void) scsi_reset(SD_ADDRESS(un), RESET_ALL);
29748 (void) sd_send_polled_RQS(un);
29762 mutex_enter(SD_MUTEX(un));
29775 * Arguments: un - pointer to the soft state struct for the instance.
29781 sd_failfast_flushq(struct sd_lun *un)
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);
29792 SD_TRACE(SD_LOG_IO_FAILFAST, un,
29793 "sd_failfast_flushq: entry: un:0x%p\n", un);
29804 if (un->un_failfast_headp == NULL) {
29805 ASSERT(un->un_failfast_tailp == NULL);
29806 un->un_failfast_headp = un->un_waitq_headp;
29808 ASSERT(un->un_failfast_tailp != NULL);
29809 un->un_failfast_tailp->av_forw = un->un_waitq_headp;
29812 un->un_failfast_tailp = un->un_waitq_tailp;
29815 for (bp = un->un_waitq_headp; bp != NULL; bp = bp->av_forw) {
29816 SD_UPDATE_KSTATS(un, kstat_waitq_exit, bp);
29820 un->un_waitq_headp = un->un_waitq_tailp = NULL;
29827 for (bp = un->un_waitq_headp; bp != NULL; bp = next_waitq_bp) {
29848 if (bp == un->un_waitq_headp) {
29850 un->un_waitq_headp = next_waitq_bp;
29851 if (un->un_waitq_headp == NULL) {
29853 un->un_waitq_tailp = NULL;
29860 ASSERT(un->un_waitq_headp != NULL);
29864 if (bp == un->un_waitq_tailp) {
29867 un->un_waitq_tailp = prev_waitq_bp;
29877 SD_UPDATE_KSTATS(un, kstat_waitq_exit, bp);
29882 if (un->un_failfast_headp == NULL) {
29884 ASSERT(un->un_failfast_tailp == NULL);
29885 un->un_failfast_headp =
29886 un->un_failfast_tailp = bp;
29889 ASSERT(un->un_failfast_tailp != NULL);
29890 ASSERT(un->un_failfast_tailp->b_flags &
29892 un->un_failfast_tailp->av_forw = bp;
29893 un->un_failfast_tailp = bp;
29901 while ((bp = un->un_failfast_headp) != NULL) {
29903 un->un_failfast_headp = bp->av_forw;
29904 if (un->un_failfast_headp == NULL) {
29905 un->un_failfast_tailp = NULL;
29914 sd_return_failed_command_no_restart(un, bp, EIO);
29919 ddi_xbuf_flushq(un->un_xbuf_attr, sd_failfast_flushq_callback);
29922 SD_TRACE(SD_LOG_IO_FAILFAST, un,
29923 "sd_failfast_flushq: exit: un:0x%p\n", un);
29959 sd_setup_next_xfer(struct sd_lun *un, struct buf *bp,
29979 num_blks_not_xfered = SD_BYTES2TGTBLOCKS(un, bytes_not_xfered);
29985 SD_BYTES2TGTBLOCKS(un, bp->b_bcount - bytes_not_xfered);
29992 rval = sd_setup_next_rw_pkt(un, pkt, bp,
30019 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
30032 * Arguments: un - pointer to the soft state struct for the instance.
30039 sd_panic_for_res_conflict(struct sd_lun *un)
30046 ddi_pathname(SD_DEVINFO(un), path_str));
30073 sd_faultinjection_ioctl(int cmd, intptr_t arg, struct sd_lun *un) {
30078 SD_TRACE(SD_LOG_IOERR, un, "sd_faultinjection_ioctl: entry\n");
30080 mutex_enter(SD_MUTEX(un));
30085 SD_INFO(SD_LOG_SDTEST, un,
30090 SD_INFO(SD_LOG_IOERR, un,
30096 SD_INFO(SD_LOG_SDTEST, un,
30100 un->sd_injection_mask = 0xFFFFFFFF;
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;
30107 un->sd_fi_fifo_start = 0;
30108 un->sd_fi_fifo_end = 0;
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));
30115 SD_INFO(SD_LOG_IOERR, un,
30121 SD_INFO(SD_LOG_SDTEST, un,
30124 un->sd_injection_mask = 0x0;
30128 if (un->sd_fi_fifo_pkt[i] != NULL) {
30129 kmem_free(un->sd_fi_fifo_pkt[i],
30132 if (un->sd_fi_fifo_xb[i] != NULL) {
30133 kmem_free(un->sd_fi_fifo_xb[i],
30136 if (un->sd_fi_fifo_un[i] != NULL) {
30137 kmem_free(un->sd_fi_fifo_un[i],
30140 if (un->sd_fi_fifo_arq[i] != NULL) {
30141 kmem_free(un->sd_fi_fifo_arq[i],
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;
30149 un->sd_fi_fifo_start = 0;
30150 un->sd_fi_fifo_end = 0;
30152 SD_INFO(SD_LOG_IOERR, un,
30158 SD_INFO(SD_LOG_SDTEST, un,
30161 i = un->sd_fi_fifo_end % SD_FI_MAX_ERROR;
30166 if (un->sd_fi_fifo_pkt[i] != NULL) {
30167 kmem_free(un->sd_fi_fifo_pkt[i],
30171 un->sd_fi_fifo_pkt[i] =
30173 if (un->sd_fi_fifo_pkt[i] == NULL) {
30177 rval = ddi_copyin((void *)arg, un->sd_fi_fifo_pkt[i],
30180 kmem_free(un->sd_fi_fifo_pkt[i],
30182 un->sd_fi_fifo_pkt[i] = NULL;
30185 SD_INFO(SD_LOG_IOERR, un,
30192 SD_INFO(SD_LOG_SDTEST, un,
30195 i = un->sd_fi_fifo_end % SD_FI_MAX_ERROR;
30199 if (un->sd_fi_fifo_xb[i] != NULL) {
30200 kmem_free(un->sd_fi_fifo_xb[i],
30202 un->sd_fi_fifo_xb[i] = NULL;
30205 un->sd_fi_fifo_xb[i] =
30207 if (un->sd_fi_fifo_xb[i] == NULL) {
30211 rval = ddi_copyin((void *)arg, un->sd_fi_fifo_xb[i],
30215 kmem_free(un->sd_fi_fifo_xb[i],
30217 un->sd_fi_fifo_xb[i] = NULL;
30220 SD_INFO(SD_LOG_IOERR, un,
30226 /* Store a un struct to be pushed onto fifo */
30227 SD_INFO(SD_LOG_SDTEST, un,
30230 i = un->sd_fi_fifo_end % SD_FI_MAX_ERROR;
30234 if (un->sd_fi_fifo_un[i] != NULL) {
30235 kmem_free(un->sd_fi_fifo_un[i],
30237 un->sd_fi_fifo_un[i] = NULL;
30240 un->sd_fi_fifo_un[i] =
30242 if (un->sd_fi_fifo_un[i] == NULL) {
30246 rval = ddi_copyin((void *)arg, un->sd_fi_fifo_un[i],
30249 kmem_free(un->sd_fi_fifo_un[i],
30251 un->sd_fi_fifo_un[i] = NULL;
30255 SD_INFO(SD_LOG_IOERR, un,
30256 "sd_faultinjection_ioctl: un null\n");
30263 SD_INFO(SD_LOG_SDTEST, un,
30265 i = un->sd_fi_fifo_end % SD_FI_MAX_ERROR;
30269 if (un->sd_fi_fifo_arq[i] != NULL) {
30270 kmem_free(un->sd_fi_fifo_arq[i],
30272 un->sd_fi_fifo_arq[i] = NULL;
30275 un->sd_fi_fifo_arq[i] =
30277 if (un->sd_fi_fifo_arq[i] == NULL) {
30281 rval = ddi_copyin((void *)arg, un->sd_fi_fifo_arq[i],
30284 kmem_free(un->sd_fi_fifo_arq[i],
30286 un->sd_fi_fifo_arq[i] = NULL;
30290 SD_INFO(SD_LOG_IOERR, un,
30297 /* Push stored xb, pkt, un, and arq onto fifo */
30303 un->sd_fi_fifo_end + i < SD_FI_MAX_ERROR) {
30304 un->sd_fi_fifo_end += i;
30307 SD_INFO(SD_LOG_IOERR, un,
30309 if (un->sd_fi_fifo_end + i < SD_FI_MAX_ERROR) {
30310 un->sd_fi_fifo_end++;
30313 SD_INFO(SD_LOG_IOERR, un,
30315 un->sd_fi_fifo_end);
30320 SD_INFO(SD_LOG_SDTEST, un,
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));
30340 mutex_exit(SD_MUTEX(un));
30341 SD_TRACE(SD_LOG_IOERR, un, "sd_faultinjection_ioctl:"
30357 sd_injection_log(char *buf, struct sd_lun *un)
30361 ASSERT(un != NULL);
30364 mutex_enter(&(un->un_fi_mutex));
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;
30375 un->sd_fi_buf_len += len;
30376 un->sd_fi_log[un->sd_fi_buf_len] = '\0';
30379 mutex_exit(&(un->un_fi_mutex));
30402 struct sd_lun *un;
30406 /* pull bp xb and un from pktp */
30409 un = SD_GET_UN(bp);
30411 ASSERT(un != NULL);
30413 mutex_enter(SD_MUTEX(un));
30415 SD_TRACE(SD_LOG_SDTEST, un,
30420 un->sd_fi_fifo_start == un->sd_fi_fifo_end) {
30421 mutex_exit(SD_MUTEX(un));
30425 SD_INFO(SD_LOG_SDTEST, un,
30429 i = un->sd_fi_fifo_start % SD_FI_MAX_ERROR;
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];
30484 /* set un if it was on fifo */
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,
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,
30495 SD_CONDSET(un, un, un_f_opt_queueing, "un_f_opt_queueing");
30505 if (un->sd_fi_fifo_pkt[i] != NULL) {
30506 kmem_free(un->sd_fi_fifo_pkt[i], sizeof (struct sd_fi_pkt));
30508 if (un->sd_fi_fifo_xb[i] != NULL) {
30509 kmem_free(un->sd_fi_fifo_xb[i], sizeof (struct sd_fi_xb));
30511 if (un->sd_fi_fifo_un[i] != NULL) {
30512 kmem_free(un->sd_fi_fifo_un[i], sizeof (struct sd_fi_un));
30514 if (un->sd_fi_fifo_arq[i] != NULL) {
30515 kmem_free(un->sd_fi_fifo_arq[i], sizeof (struct sd_fi_arq));
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;
30529 un->sd_fi_fifo_start++;
30531 mutex_exit(SD_MUTEX(un));
30533 SD_INFO(SD_LOG_SDTEST, un, "sd_faultinjection: exit\n");
30810 sd_set_unit_attributes(struct sd_lun *un, dev_info_t *devi)
30814 ASSERT(un->un_sd);
30815 ASSERT(un->un_sd->sd_inq);
30820 un->un_f_sync_cache_supported = TRUE;
30827 un->un_f_sync_cache_required = FALSE;
30829 if (un->un_sd->sd_inq->inq_rmb) {
30835 un->un_f_has_removable_media = TRUE;
30840 un->un_f_non_devbsize_supported = TRUE;
30845 un->un_f_doorlock_supported = TRUE;
30853 un->un_f_chk_wp_open = TRUE;
30859 un->un_f_monitor_media_state = TRUE;
30866 un->un_f_check_start_stop = TRUE;
30872 un->un_f_eject_media_supported = TRUE;
30882 un->un_f_pm_supported = TRUE;
30899 un->un_f_devid_supported = TRUE;
30904 un->un_f_attach_spinup = TRUE;
30912 if (SD_INQUIRY(un)->inq_dtype == DTYPE_DIRECT) {
30913 un->un_f_descr_format_supported = TRUE;
30922 un->un_f_pkstats_enabled = (ddi_prop_get_int(DDI_DEV_T_ANY,
30923 SD_DEVINFO(un), DDI_PROP_DONTPASS,
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;
30959 un->un_f_log_sense_supported = FALSE;
30962 un->un_f_pm_supported = TRUE;
30963 if (!un->un_f_power_condition_disabled &&
30965 un->un_f_power_condition_supported =
30969 un->un_f_log_sense_supported = TRUE;
30970 un->un_f_pm_log_sense_smart =
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);
30981 if (un->un_f_is_hotpluggable) {
30988 un->un_f_monitor_media_state = TRUE;
30990 un->un_f_check_start_stop = TRUE;
31005 struct sd_lun *un;
31017 un = ddi_get_soft_state(sd_state, ddi_get_instance(devi));
31018 if (un == NULL)
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));
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));
31041 if (NOT_DEVBSIZE(un)) {
31047 real_addr = first_byte / un->un_tgt_blocksize;
31050 un->un_tgt_blocksize - 1) / un->un_tgt_blocksize;
31053 buffer_size = (end_block - real_addr) * un->un_tgt_blocksize;
31055 SD_TRACE(SD_LOG_IO_PARTITION, un, "sd_tg_rdwr",
31059 if (((first_byte % un->un_tgt_blocksize) != 0) ||
31060 (reqlength % un->un_tgt_blocksize) != 0)
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)))) {
31081 mutex_exit(SD_MUTEX(un));
31086 bcopy(dkl + SD_TGTBYTEOFFSET(un, start_block,
31095 bcopy(bufaddr, dkl + SD_TGTBYTEOFFSET(un, start_block,
31122 struct sd_lun *un;
31128 un = ddi_get_soft_state(sd_state, ddi_get_instance(devi));
31129 if (un == NULL)
31137 mutex_enter(SD_MUTEX(un));
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));
31146 mutex_exit(SD_MUTEX(un));
31147 ssc = sd_ssc_init(un);
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));
31168 mutex_exit(SD_MUTEX(un));
31182 ret = sd_get_physical_geometry(un, (cmlb_geom_t *)arg,
31186 ret = sd_get_virtual_geometry(un,
31192 mutex_enter(SD_MUTEX(un));
31194 un->un_f_mmc_writable_media;
31196 un->un_f_is_solid_state;
31197 mutex_exit(SD_MUTEX(un));
31228 struct sd_lun *un;
31241 un = ssc->ssc_un;
31242 ASSERT(un != NULL);
31244 dip = un->un_sd->sd_dev;
31256 if (ddi_in_panic() || (un->un_state == SD_STATE_SUSPENDED) ||
31257 (un->un_state == SD_STATE_DUMPING))
31271 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
31310 scsi_fm_ereport_post(un->un_sd, uscsi_path_instance, NULL,
31327 * If there is un-expected/un-decodable data, we should post
31337 scsi_fm_ereport_post(un->un_sd, uscsi_path_instance,
31354 "un-decode-info", DATA_TYPE_STRING,
31356 "un-decode-value", DATA_TYPE_UINT8_ARRAY,
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.
31366 scsi_fm_ereport_post(un->un_sd, uscsi_path_instance,
31384 "un-decode-info", DATA_TYPE_STRING,
31386 "un-decode-value", DATA_TYPE_UINT8_ARRAY,
31408 scsi_fm_ereport_post(un->un_sd, uscsi_path_instance, NULL,
31451 scsi_fm_ereport_post(un->un_sd,
31500 scsi_fm_ereport_post(un->un_sd,
31556 scsi_fm_ereport_post(un->un_sd, uscsi_path_instance,
31590 sd_ssc_extract_info(sd_ssc_t *ssc, struct sd_lun *un, struct scsi_pkt *pktp,
31601 ASSERT(un != NULL);
31606 ASSERT(mutex_owned(SD_MUTEX(un)));
31702 struct sd_lun *un;
31705 un = ssc->ssc_un;
31706 ASSERT(un != NULL);
31707 ASSERT(!mutex_owned(SD_MUTEX(un)));
31709 mutex_enter(SD_MUTEX(un));
31710 un->un_f_is_solid_state = FALSE;
31712 if (ISCD(un)) {
31713 mutex_exit(SD_MUTEX(un));
31718 un->un_vpd_page_mask & SD_VPD_DEV_CHARACTER_PG) {
31719 mutex_exit(SD_MUTEX(un));
31727 SD_TRACE(SD_LOG_COMMON, un,
31734 mutex_enter(SD_MUTEX(un));
31740 un->un_f_is_solid_state = TRUE;
31742 un->un_f_disksort_disabled = TRUE;
31744 mutex_exit(SD_MUTEX(un));
31751 mutex_exit(SD_MUTEX(un));
31774 struct sd_lun *un;
31777 un = ssc->ssc_un;
31778 ASSERT(un != NULL);
31779 ASSERT(!mutex_owned(SD_MUTEX(un)));
31781 mutex_enter(SD_MUTEX(un));
31782 if (ISCD(un)) {
31783 mutex_exit(SD_MUTEX(un));
31787 if (un->un_f_descr_format_supported) {
31788 mutex_exit(SD_MUTEX(un));
31791 mutex_enter(SD_MUTEX(un));
31794 un->un_phy_blocksize = DEV_BSIZE;
31797 un->un_phy_blocksize = DEV_BSIZE;
31798 } else if (pbsize > un->un_phy_blocksize) {
31803 un->un_phy_blocksize = pbsize;
31810 if (sd_sdconf_id_match(un, sd_flash_dev_table[i], devid_len)
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;
31819 mutex_exit(SD_MUTEX(un));