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