1 /* 2 * zfcp device driver 3 * 4 * Interface to Linux SCSI midlayer. 5 * 6 * Copyright IBM Corporation 2002, 2008 7 */ 8 9 #include "zfcp_ext.h" 10 #include <asm/atomic.h> 11 12 /* Find start of Sense Information in FCP response unit*/ 13 char *zfcp_get_fcp_sns_info_ptr(struct fcp_rsp_iu *fcp_rsp_iu) 14 { 15 char *fcp_sns_info_ptr; 16 17 fcp_sns_info_ptr = (unsigned char *) &fcp_rsp_iu[1]; 18 if (fcp_rsp_iu->validity.bits.fcp_rsp_len_valid) 19 fcp_sns_info_ptr += fcp_rsp_iu->fcp_rsp_len; 20 21 return fcp_sns_info_ptr; 22 } 23 24 static void zfcp_scsi_slave_destroy(struct scsi_device *sdpnt) 25 { 26 struct zfcp_unit *unit = (struct zfcp_unit *) sdpnt->hostdata; 27 WARN_ON(!unit); 28 if (unit) { 29 atomic_clear_mask(ZFCP_STATUS_UNIT_REGISTERED, &unit->status); 30 sdpnt->hostdata = NULL; 31 unit->device = NULL; 32 zfcp_erp_unit_failed(unit, 12, NULL); 33 zfcp_unit_put(unit); 34 } 35 } 36 37 static int zfcp_scsi_slave_configure(struct scsi_device *sdp) 38 { 39 if (sdp->tagged_supported) 40 scsi_adjust_queue_depth(sdp, MSG_SIMPLE_TAG, 32); 41 else 42 scsi_adjust_queue_depth(sdp, 0, 1); 43 return 0; 44 } 45 46 static void zfcp_scsi_command_fail(struct scsi_cmnd *scpnt, int result) 47 { 48 set_host_byte(scpnt, result); 49 if ((scpnt->device != NULL) && (scpnt->device->host != NULL)) 50 zfcp_scsi_dbf_event_result("fail", 4, 51 (struct zfcp_adapter*) scpnt->device->host->hostdata[0], 52 scpnt, NULL); 53 /* return directly */ 54 scpnt->scsi_done(scpnt); 55 } 56 57 static int zfcp_scsi_queuecommand(struct scsi_cmnd *scpnt, 58 void (*done) (struct scsi_cmnd *)) 59 { 60 struct zfcp_unit *unit; 61 struct zfcp_adapter *adapter; 62 int status; 63 int ret; 64 65 /* reset the status for this request */ 66 scpnt->result = 0; 67 scpnt->host_scribble = NULL; 68 scpnt->scsi_done = done; 69 70 /* 71 * figure out adapter and target device 72 * (stored there by zfcp_scsi_slave_alloc) 73 */ 74 adapter = (struct zfcp_adapter *) scpnt->device->host->hostdata[0]; 75 unit = scpnt->device->hostdata; 76 77 BUG_ON(!adapter || (adapter != unit->port->adapter)); 78 BUG_ON(!scpnt->scsi_done); 79 80 if (unlikely(!unit)) { 81 zfcp_scsi_command_fail(scpnt, DID_NO_CONNECT); 82 return 0; 83 } 84 85 status = atomic_read(&unit->status); 86 if (unlikely((status & ZFCP_STATUS_COMMON_ERP_FAILED) || 87 !(status & ZFCP_STATUS_COMMON_RUNNING))) { 88 zfcp_scsi_command_fail(scpnt, DID_ERROR); 89 return 0;; 90 } 91 92 ret = zfcp_fsf_send_fcp_command_task(adapter, unit, scpnt, 0, 93 ZFCP_REQ_AUTO_CLEANUP); 94 if (unlikely(ret == -EBUSY)) 95 zfcp_scsi_command_fail(scpnt, DID_NO_CONNECT); 96 else if (unlikely(ret < 0)) 97 return SCSI_MLQUEUE_HOST_BUSY; 98 99 return ret; 100 } 101 102 static struct zfcp_unit *zfcp_unit_lookup(struct zfcp_adapter *adapter, 103 int channel, unsigned int id, 104 unsigned int lun) 105 { 106 struct zfcp_port *port; 107 struct zfcp_unit *unit; 108 int scsi_lun; 109 110 list_for_each_entry(port, &adapter->port_list_head, list) { 111 if (!port->rport || (id != port->rport->scsi_target_id)) 112 continue; 113 list_for_each_entry(unit, &port->unit_list_head, list) { 114 scsi_lun = scsilun_to_int( 115 (struct scsi_lun *)&unit->fcp_lun); 116 if (lun == scsi_lun) 117 return unit; 118 } 119 } 120 121 return NULL; 122 } 123 124 static int zfcp_scsi_slave_alloc(struct scsi_device *sdp) 125 { 126 struct zfcp_adapter *adapter; 127 struct zfcp_unit *unit; 128 unsigned long flags; 129 int retval = -ENXIO; 130 131 adapter = (struct zfcp_adapter *) sdp->host->hostdata[0]; 132 if (!adapter) 133 goto out; 134 135 read_lock_irqsave(&zfcp_data.config_lock, flags); 136 unit = zfcp_unit_lookup(adapter, sdp->channel, sdp->id, sdp->lun); 137 if (unit && 138 (atomic_read(&unit->status) & ZFCP_STATUS_UNIT_REGISTERED)) { 139 sdp->hostdata = unit; 140 unit->device = sdp; 141 zfcp_unit_get(unit); 142 retval = 0; 143 } 144 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 145 out: 146 return retval; 147 } 148 149 static int zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt) 150 { 151 struct Scsi_Host *scsi_host; 152 struct zfcp_adapter *adapter; 153 struct zfcp_unit *unit; 154 struct zfcp_fsf_req *fsf_req; 155 unsigned long flags; 156 unsigned long old_req_id = (unsigned long) scpnt->host_scribble; 157 int retval = SUCCESS; 158 159 scsi_host = scpnt->device->host; 160 adapter = (struct zfcp_adapter *) scsi_host->hostdata[0]; 161 unit = scpnt->device->hostdata; 162 163 /* avoid race condition between late normal completion and abort */ 164 write_lock_irqsave(&adapter->abort_lock, flags); 165 166 /* Check whether corresponding fsf_req is still pending */ 167 spin_lock(&adapter->req_list_lock); 168 fsf_req = zfcp_reqlist_find(adapter, old_req_id); 169 spin_unlock(&adapter->req_list_lock); 170 if (!fsf_req) { 171 write_unlock_irqrestore(&adapter->abort_lock, flags); 172 zfcp_scsi_dbf_event_abort("lte1", adapter, scpnt, NULL, 0); 173 return retval; 174 } 175 fsf_req->data = NULL; 176 177 /* don't access old fsf_req after releasing the abort_lock */ 178 write_unlock_irqrestore(&adapter->abort_lock, flags); 179 180 fsf_req = zfcp_fsf_abort_fcp_command(old_req_id, adapter, unit, 0); 181 if (!fsf_req) { 182 zfcp_scsi_dbf_event_abort("nres", adapter, scpnt, NULL, 183 old_req_id); 184 retval = FAILED; 185 return retval; 186 } 187 188 __wait_event(fsf_req->completion_wq, 189 fsf_req->status & ZFCP_STATUS_FSFREQ_COMPLETED); 190 191 if (fsf_req->status & ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED) { 192 zfcp_scsi_dbf_event_abort("okay", adapter, scpnt, fsf_req, 0); 193 } else if (fsf_req->status & ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED) { 194 zfcp_scsi_dbf_event_abort("lte2", adapter, scpnt, fsf_req, 0); 195 } else { 196 zfcp_scsi_dbf_event_abort("fail", adapter, scpnt, fsf_req, 0); 197 retval = FAILED; 198 } 199 zfcp_fsf_req_free(fsf_req); 200 201 return retval; 202 } 203 204 static int zfcp_task_mgmt_function(struct zfcp_unit *unit, u8 tm_flags, 205 struct scsi_cmnd *scpnt) 206 { 207 struct zfcp_adapter *adapter = unit->port->adapter; 208 struct zfcp_fsf_req *fsf_req; 209 int retval = SUCCESS; 210 211 /* issue task management function */ 212 fsf_req = zfcp_fsf_send_fcp_ctm(adapter, unit, tm_flags, 0); 213 if (!fsf_req) { 214 zfcp_scsi_dbf_event_devreset("nres", tm_flags, unit, scpnt); 215 return FAILED; 216 } 217 218 __wait_event(fsf_req->completion_wq, 219 fsf_req->status & ZFCP_STATUS_FSFREQ_COMPLETED); 220 221 /* 222 * check completion status of task management function 223 */ 224 if (fsf_req->status & ZFCP_STATUS_FSFREQ_TMFUNCFAILED) { 225 zfcp_scsi_dbf_event_devreset("fail", tm_flags, unit, scpnt); 226 retval = FAILED; 227 } else if (fsf_req->status & ZFCP_STATUS_FSFREQ_TMFUNCNOTSUPP) { 228 zfcp_scsi_dbf_event_devreset("nsup", tm_flags, unit, scpnt); 229 retval = FAILED; 230 } else 231 zfcp_scsi_dbf_event_devreset("okay", tm_flags, unit, scpnt); 232 233 zfcp_fsf_req_free(fsf_req); 234 235 return retval; 236 } 237 238 static int zfcp_scsi_eh_device_reset_handler(struct scsi_cmnd *scpnt) 239 { 240 struct zfcp_unit *unit = scpnt->device->hostdata; 241 242 if (!unit) { 243 WARN_ON(1); 244 return SUCCESS; 245 } 246 return zfcp_task_mgmt_function(unit, FCP_LOGICAL_UNIT_RESET, scpnt); 247 } 248 249 static int zfcp_scsi_eh_target_reset_handler(struct scsi_cmnd *scpnt) 250 { 251 struct zfcp_unit *unit = scpnt->device->hostdata; 252 253 if (!unit) { 254 WARN_ON(1); 255 return SUCCESS; 256 } 257 return zfcp_task_mgmt_function(unit, FCP_TARGET_RESET, scpnt); 258 } 259 260 static int zfcp_scsi_eh_host_reset_handler(struct scsi_cmnd *scpnt) 261 { 262 struct zfcp_unit *unit; 263 struct zfcp_adapter *adapter; 264 265 unit = scpnt->device->hostdata; 266 adapter = unit->port->adapter; 267 zfcp_erp_adapter_reopen(adapter, 0, 141, scpnt); 268 zfcp_erp_wait(adapter); 269 270 return SUCCESS; 271 } 272 273 int zfcp_adapter_scsi_register(struct zfcp_adapter *adapter) 274 { 275 struct ccw_dev_id dev_id; 276 277 if (adapter->scsi_host) 278 return 0; 279 280 ccw_device_get_id(adapter->ccw_device, &dev_id); 281 /* register adapter as SCSI host with mid layer of SCSI stack */ 282 adapter->scsi_host = scsi_host_alloc(&zfcp_data.scsi_host_template, 283 sizeof (struct zfcp_adapter *)); 284 if (!adapter->scsi_host) { 285 dev_err(&adapter->ccw_device->dev, 286 "Registering the FCP device with the " 287 "SCSI stack failed\n"); 288 return -EIO; 289 } 290 291 /* tell the SCSI stack some characteristics of this adapter */ 292 adapter->scsi_host->max_id = 1; 293 adapter->scsi_host->max_lun = 1; 294 adapter->scsi_host->max_channel = 0; 295 adapter->scsi_host->unique_id = dev_id.devno; 296 adapter->scsi_host->max_cmd_len = 255; 297 adapter->scsi_host->transportt = zfcp_data.scsi_transport_template; 298 299 adapter->scsi_host->hostdata[0] = (unsigned long) adapter; 300 301 if (scsi_add_host(adapter->scsi_host, &adapter->ccw_device->dev)) { 302 scsi_host_put(adapter->scsi_host); 303 return -EIO; 304 } 305 306 return 0; 307 } 308 309 void zfcp_adapter_scsi_unregister(struct zfcp_adapter *adapter) 310 { 311 struct Scsi_Host *shost; 312 struct zfcp_port *port; 313 314 shost = adapter->scsi_host; 315 if (!shost) 316 return; 317 318 read_lock_irq(&zfcp_data.config_lock); 319 list_for_each_entry(port, &adapter->port_list_head, list) 320 if (port->rport) 321 port->rport = NULL; 322 323 read_unlock_irq(&zfcp_data.config_lock); 324 fc_remove_host(shost); 325 scsi_remove_host(shost); 326 scsi_host_put(shost); 327 adapter->scsi_host = NULL; 328 329 return; 330 } 331 332 static struct fc_host_statistics* 333 zfcp_init_fc_host_stats(struct zfcp_adapter *adapter) 334 { 335 struct fc_host_statistics *fc_stats; 336 337 if (!adapter->fc_stats) { 338 fc_stats = kmalloc(sizeof(*fc_stats), GFP_KERNEL); 339 if (!fc_stats) 340 return NULL; 341 adapter->fc_stats = fc_stats; /* freed in adater_dequeue */ 342 } 343 memset(adapter->fc_stats, 0, sizeof(*adapter->fc_stats)); 344 return adapter->fc_stats; 345 } 346 347 static void zfcp_adjust_fc_host_stats(struct fc_host_statistics *fc_stats, 348 struct fsf_qtcb_bottom_port *data, 349 struct fsf_qtcb_bottom_port *old) 350 { 351 fc_stats->seconds_since_last_reset = 352 data->seconds_since_last_reset - old->seconds_since_last_reset; 353 fc_stats->tx_frames = data->tx_frames - old->tx_frames; 354 fc_stats->tx_words = data->tx_words - old->tx_words; 355 fc_stats->rx_frames = data->rx_frames - old->rx_frames; 356 fc_stats->rx_words = data->rx_words - old->rx_words; 357 fc_stats->lip_count = data->lip - old->lip; 358 fc_stats->nos_count = data->nos - old->nos; 359 fc_stats->error_frames = data->error_frames - old->error_frames; 360 fc_stats->dumped_frames = data->dumped_frames - old->dumped_frames; 361 fc_stats->link_failure_count = data->link_failure - old->link_failure; 362 fc_stats->loss_of_sync_count = data->loss_of_sync - old->loss_of_sync; 363 fc_stats->loss_of_signal_count = 364 data->loss_of_signal - old->loss_of_signal; 365 fc_stats->prim_seq_protocol_err_count = 366 data->psp_error_counts - old->psp_error_counts; 367 fc_stats->invalid_tx_word_count = 368 data->invalid_tx_words - old->invalid_tx_words; 369 fc_stats->invalid_crc_count = data->invalid_crcs - old->invalid_crcs; 370 fc_stats->fcp_input_requests = 371 data->input_requests - old->input_requests; 372 fc_stats->fcp_output_requests = 373 data->output_requests - old->output_requests; 374 fc_stats->fcp_control_requests = 375 data->control_requests - old->control_requests; 376 fc_stats->fcp_input_megabytes = data->input_mb - old->input_mb; 377 fc_stats->fcp_output_megabytes = data->output_mb - old->output_mb; 378 } 379 380 static void zfcp_set_fc_host_stats(struct fc_host_statistics *fc_stats, 381 struct fsf_qtcb_bottom_port *data) 382 { 383 fc_stats->seconds_since_last_reset = data->seconds_since_last_reset; 384 fc_stats->tx_frames = data->tx_frames; 385 fc_stats->tx_words = data->tx_words; 386 fc_stats->rx_frames = data->rx_frames; 387 fc_stats->rx_words = data->rx_words; 388 fc_stats->lip_count = data->lip; 389 fc_stats->nos_count = data->nos; 390 fc_stats->error_frames = data->error_frames; 391 fc_stats->dumped_frames = data->dumped_frames; 392 fc_stats->link_failure_count = data->link_failure; 393 fc_stats->loss_of_sync_count = data->loss_of_sync; 394 fc_stats->loss_of_signal_count = data->loss_of_signal; 395 fc_stats->prim_seq_protocol_err_count = data->psp_error_counts; 396 fc_stats->invalid_tx_word_count = data->invalid_tx_words; 397 fc_stats->invalid_crc_count = data->invalid_crcs; 398 fc_stats->fcp_input_requests = data->input_requests; 399 fc_stats->fcp_output_requests = data->output_requests; 400 fc_stats->fcp_control_requests = data->control_requests; 401 fc_stats->fcp_input_megabytes = data->input_mb; 402 fc_stats->fcp_output_megabytes = data->output_mb; 403 } 404 405 static struct fc_host_statistics *zfcp_get_fc_host_stats(struct Scsi_Host *host) 406 { 407 struct zfcp_adapter *adapter; 408 struct fc_host_statistics *fc_stats; 409 struct fsf_qtcb_bottom_port *data; 410 int ret; 411 412 adapter = (struct zfcp_adapter *)host->hostdata[0]; 413 fc_stats = zfcp_init_fc_host_stats(adapter); 414 if (!fc_stats) 415 return NULL; 416 417 data = kzalloc(sizeof(*data), GFP_KERNEL); 418 if (!data) 419 return NULL; 420 421 ret = zfcp_fsf_exchange_port_data_sync(adapter, data); 422 if (ret) { 423 kfree(data); 424 return NULL; 425 } 426 427 if (adapter->stats_reset && 428 ((jiffies/HZ - adapter->stats_reset) < 429 data->seconds_since_last_reset)) 430 zfcp_adjust_fc_host_stats(fc_stats, data, 431 adapter->stats_reset_data); 432 else 433 zfcp_set_fc_host_stats(fc_stats, data); 434 435 kfree(data); 436 return fc_stats; 437 } 438 439 static void zfcp_reset_fc_host_stats(struct Scsi_Host *shost) 440 { 441 struct zfcp_adapter *adapter; 442 struct fsf_qtcb_bottom_port *data; 443 int ret; 444 445 adapter = (struct zfcp_adapter *)shost->hostdata[0]; 446 data = kzalloc(sizeof(*data), GFP_KERNEL); 447 if (!data) 448 return; 449 450 ret = zfcp_fsf_exchange_port_data_sync(adapter, data); 451 if (ret) 452 kfree(data); 453 else { 454 adapter->stats_reset = jiffies/HZ; 455 kfree(adapter->stats_reset_data); 456 adapter->stats_reset_data = data; /* finally freed in 457 adapter_dequeue */ 458 } 459 } 460 461 static void zfcp_get_host_port_state(struct Scsi_Host *shost) 462 { 463 struct zfcp_adapter *adapter = 464 (struct zfcp_adapter *)shost->hostdata[0]; 465 int status = atomic_read(&adapter->status); 466 467 if ((status & ZFCP_STATUS_COMMON_RUNNING) && 468 !(status & ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED)) 469 fc_host_port_state(shost) = FC_PORTSTATE_ONLINE; 470 else if (status & ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED) 471 fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN; 472 else if (status & ZFCP_STATUS_COMMON_ERP_FAILED) 473 fc_host_port_state(shost) = FC_PORTSTATE_ERROR; 474 else 475 fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN; 476 } 477 478 static void zfcp_set_rport_dev_loss_tmo(struct fc_rport *rport, u32 timeout) 479 { 480 rport->dev_loss_tmo = timeout; 481 } 482 483 struct fc_function_template zfcp_transport_functions = { 484 .show_starget_port_id = 1, 485 .show_starget_port_name = 1, 486 .show_starget_node_name = 1, 487 .show_rport_supported_classes = 1, 488 .show_rport_maxframe_size = 1, 489 .show_rport_dev_loss_tmo = 1, 490 .show_host_node_name = 1, 491 .show_host_port_name = 1, 492 .show_host_permanent_port_name = 1, 493 .show_host_supported_classes = 1, 494 .show_host_supported_speeds = 1, 495 .show_host_maxframe_size = 1, 496 .show_host_serial_number = 1, 497 .get_fc_host_stats = zfcp_get_fc_host_stats, 498 .reset_fc_host_stats = zfcp_reset_fc_host_stats, 499 .set_rport_dev_loss_tmo = zfcp_set_rport_dev_loss_tmo, 500 .get_host_port_state = zfcp_get_host_port_state, 501 .show_host_port_state = 1, 502 /* no functions registered for following dynamic attributes but 503 directly set by LLDD */ 504 .show_host_port_type = 1, 505 .show_host_speed = 1, 506 .show_host_port_id = 1, 507 .disable_target_scan = 1, 508 }; 509 510 struct zfcp_data zfcp_data = { 511 .scsi_host_template = { 512 .name = "zfcp", 513 .module = THIS_MODULE, 514 .proc_name = "zfcp", 515 .slave_alloc = zfcp_scsi_slave_alloc, 516 .slave_configure = zfcp_scsi_slave_configure, 517 .slave_destroy = zfcp_scsi_slave_destroy, 518 .queuecommand = zfcp_scsi_queuecommand, 519 .eh_abort_handler = zfcp_scsi_eh_abort_handler, 520 .eh_device_reset_handler = zfcp_scsi_eh_device_reset_handler, 521 .eh_target_reset_handler = zfcp_scsi_eh_target_reset_handler, 522 .eh_host_reset_handler = zfcp_scsi_eh_host_reset_handler, 523 .can_queue = 4096, 524 .this_id = -1, 525 .sg_tablesize = ZFCP_MAX_SBALES_PER_REQ, 526 .cmd_per_lun = 1, 527 .use_clustering = 1, 528 .sdev_attrs = zfcp_sysfs_sdev_attrs, 529 .max_sectors = (ZFCP_MAX_SBALES_PER_REQ * 8), 530 .shost_attrs = zfcp_sysfs_shost_attrs, 531 }, 532 }; 533