1 /* 2 * zfcp device driver 3 * 4 * Interface to Linux SCSI midlayer. 5 * 6 * Copyright IBM Corporation 2002, 2009 7 */ 8 9 #define KMSG_COMPONENT "zfcp" 10 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 11 12 #include <asm/atomic.h> 13 #include "zfcp_ext.h" 14 #include "zfcp_dbf.h" 15 16 static unsigned int default_depth = 32; 17 module_param_named(queue_depth, default_depth, uint, 0600); 18 MODULE_PARM_DESC(queue_depth, "Default queue depth for new SCSI devices"); 19 20 /* Find start of Sense Information in FCP response unit*/ 21 char *zfcp_get_fcp_sns_info_ptr(struct fcp_rsp_iu *fcp_rsp_iu) 22 { 23 char *fcp_sns_info_ptr; 24 25 fcp_sns_info_ptr = (unsigned char *) &fcp_rsp_iu[1]; 26 if (fcp_rsp_iu->validity.bits.fcp_rsp_len_valid) 27 fcp_sns_info_ptr += fcp_rsp_iu->fcp_rsp_len; 28 29 return fcp_sns_info_ptr; 30 } 31 32 static int zfcp_scsi_change_queue_depth(struct scsi_device *sdev, int depth) 33 { 34 scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth); 35 return sdev->queue_depth; 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 unit->device = NULL; 42 zfcp_unit_put(unit); 43 } 44 45 static int zfcp_scsi_slave_configure(struct scsi_device *sdp) 46 { 47 if (sdp->tagged_supported) 48 scsi_adjust_queue_depth(sdp, MSG_SIMPLE_TAG, default_depth); 49 else 50 scsi_adjust_queue_depth(sdp, 0, 1); 51 return 0; 52 } 53 54 static void zfcp_scsi_command_fail(struct scsi_cmnd *scpnt, int result) 55 { 56 struct zfcp_adapter *adapter = 57 (struct zfcp_adapter *) scpnt->device->host->hostdata[0]; 58 set_host_byte(scpnt, result); 59 if ((scpnt->device != NULL) && (scpnt->device->host != NULL)) 60 zfcp_dbf_scsi_result("fail", 4, adapter->dbf, scpnt, NULL); 61 /* return directly */ 62 scpnt->scsi_done(scpnt); 63 } 64 65 static int zfcp_scsi_queuecommand(struct scsi_cmnd *scpnt, 66 void (*done) (struct scsi_cmnd *)) 67 { 68 struct zfcp_unit *unit; 69 struct zfcp_adapter *adapter; 70 int status, scsi_result, ret; 71 struct fc_rport *rport = starget_to_rport(scsi_target(scpnt->device)); 72 73 /* reset the status for this request */ 74 scpnt->result = 0; 75 scpnt->host_scribble = NULL; 76 scpnt->scsi_done = done; 77 78 /* 79 * figure out adapter and target device 80 * (stored there by zfcp_scsi_slave_alloc) 81 */ 82 adapter = (struct zfcp_adapter *) scpnt->device->host->hostdata[0]; 83 unit = scpnt->device->hostdata; 84 85 BUG_ON(!adapter || (adapter != unit->port->adapter)); 86 BUG_ON(!scpnt->scsi_done); 87 88 if (unlikely(!unit)) { 89 zfcp_scsi_command_fail(scpnt, DID_NO_CONNECT); 90 return 0; 91 } 92 93 scsi_result = fc_remote_port_chkready(rport); 94 if (unlikely(scsi_result)) { 95 scpnt->result = scsi_result; 96 zfcp_dbf_scsi_result("fail", 4, adapter->dbf, scpnt, NULL); 97 scpnt->scsi_done(scpnt); 98 return 0; 99 } 100 101 status = atomic_read(&unit->status); 102 if (unlikely((status & ZFCP_STATUS_COMMON_ERP_FAILED) || 103 !(status & ZFCP_STATUS_COMMON_RUNNING))) { 104 zfcp_scsi_command_fail(scpnt, DID_ERROR); 105 return 0;; 106 } 107 108 ret = zfcp_fsf_send_fcp_command_task(unit, scpnt); 109 if (unlikely(ret == -EBUSY)) 110 return SCSI_MLQUEUE_DEVICE_BUSY; 111 else if (unlikely(ret < 0)) 112 return SCSI_MLQUEUE_HOST_BUSY; 113 114 return ret; 115 } 116 117 static struct zfcp_unit *zfcp_unit_lookup(struct zfcp_adapter *adapter, 118 int channel, unsigned int id, 119 unsigned int lun) 120 { 121 struct zfcp_port *port; 122 struct zfcp_unit *unit; 123 int scsi_lun; 124 125 list_for_each_entry(port, &adapter->port_list_head, list) { 126 if (!port->rport || (id != port->rport->scsi_target_id)) 127 continue; 128 list_for_each_entry(unit, &port->unit_list_head, list) { 129 scsi_lun = scsilun_to_int( 130 (struct scsi_lun *)&unit->fcp_lun); 131 if (lun == scsi_lun) 132 return unit; 133 } 134 } 135 136 return NULL; 137 } 138 139 static int zfcp_scsi_slave_alloc(struct scsi_device *sdp) 140 { 141 struct zfcp_adapter *adapter; 142 struct zfcp_unit *unit; 143 unsigned long flags; 144 int retval = -ENXIO; 145 146 adapter = (struct zfcp_adapter *) sdp->host->hostdata[0]; 147 if (!adapter) 148 goto out; 149 150 read_lock_irqsave(&zfcp_data.config_lock, flags); 151 unit = zfcp_unit_lookup(adapter, sdp->channel, sdp->id, sdp->lun); 152 if (unit) { 153 sdp->hostdata = unit; 154 unit->device = sdp; 155 zfcp_unit_get(unit); 156 retval = 0; 157 } 158 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 159 out: 160 return retval; 161 } 162 163 static int zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt) 164 { 165 struct Scsi_Host *scsi_host = scpnt->device->host; 166 struct zfcp_adapter *adapter = 167 (struct zfcp_adapter *) scsi_host->hostdata[0]; 168 struct zfcp_unit *unit = scpnt->device->hostdata; 169 struct zfcp_fsf_req *old_req, *abrt_req; 170 unsigned long flags; 171 unsigned long old_reqid = (unsigned long) scpnt->host_scribble; 172 int retval = SUCCESS; 173 int retry = 3; 174 char *dbf_tag; 175 176 /* avoid race condition between late normal completion and abort */ 177 write_lock_irqsave(&adapter->abort_lock, flags); 178 179 spin_lock(&adapter->req_list_lock); 180 old_req = zfcp_reqlist_find(adapter, old_reqid); 181 spin_unlock(&adapter->req_list_lock); 182 if (!old_req) { 183 write_unlock_irqrestore(&adapter->abort_lock, flags); 184 zfcp_dbf_scsi_abort("lte1", adapter->dbf, scpnt, NULL, 185 old_reqid); 186 return FAILED; /* completion could be in progress */ 187 } 188 old_req->data = NULL; 189 190 /* don't access old fsf_req after releasing the abort_lock */ 191 write_unlock_irqrestore(&adapter->abort_lock, flags); 192 193 while (retry--) { 194 abrt_req = zfcp_fsf_abort_fcp_command(old_reqid, unit); 195 if (abrt_req) 196 break; 197 198 zfcp_erp_wait(adapter); 199 if (!(atomic_read(&adapter->status) & 200 ZFCP_STATUS_COMMON_RUNNING)) { 201 zfcp_dbf_scsi_abort("nres", adapter->dbf, scpnt, NULL, 202 old_reqid); 203 return SUCCESS; 204 } 205 } 206 if (!abrt_req) 207 return FAILED; 208 209 wait_for_completion(&abrt_req->completion); 210 211 if (abrt_req->status & ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED) 212 dbf_tag = "okay"; 213 else if (abrt_req->status & ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED) 214 dbf_tag = "lte2"; 215 else { 216 dbf_tag = "fail"; 217 retval = FAILED; 218 } 219 zfcp_dbf_scsi_abort(dbf_tag, adapter->dbf, scpnt, abrt_req, old_reqid); 220 zfcp_fsf_req_free(abrt_req); 221 return retval; 222 } 223 224 static int zfcp_task_mgmt_function(struct scsi_cmnd *scpnt, u8 tm_flags) 225 { 226 struct zfcp_unit *unit = scpnt->device->hostdata; 227 struct zfcp_adapter *adapter = unit->port->adapter; 228 struct zfcp_fsf_req *fsf_req = NULL; 229 int retval = SUCCESS; 230 int retry = 3; 231 232 while (retry--) { 233 fsf_req = zfcp_fsf_send_fcp_ctm(unit, tm_flags); 234 if (fsf_req) 235 break; 236 237 zfcp_erp_wait(adapter); 238 if (!(atomic_read(&adapter->status) & 239 ZFCP_STATUS_COMMON_RUNNING)) { 240 zfcp_dbf_scsi_devreset("nres", tm_flags, unit, scpnt); 241 return SUCCESS; 242 } 243 } 244 if (!fsf_req) 245 return FAILED; 246 247 wait_for_completion(&fsf_req->completion); 248 249 if (fsf_req->status & ZFCP_STATUS_FSFREQ_TMFUNCFAILED) { 250 zfcp_dbf_scsi_devreset("fail", tm_flags, unit, scpnt); 251 retval = FAILED; 252 } else if (fsf_req->status & ZFCP_STATUS_FSFREQ_TMFUNCNOTSUPP) { 253 zfcp_dbf_scsi_devreset("nsup", tm_flags, unit, scpnt); 254 retval = FAILED; 255 } else 256 zfcp_dbf_scsi_devreset("okay", tm_flags, unit, scpnt); 257 258 zfcp_fsf_req_free(fsf_req); 259 return retval; 260 } 261 262 static int zfcp_scsi_eh_device_reset_handler(struct scsi_cmnd *scpnt) 263 { 264 return zfcp_task_mgmt_function(scpnt, FCP_LOGICAL_UNIT_RESET); 265 } 266 267 static int zfcp_scsi_eh_target_reset_handler(struct scsi_cmnd *scpnt) 268 { 269 return zfcp_task_mgmt_function(scpnt, FCP_TARGET_RESET); 270 } 271 272 static int zfcp_scsi_eh_host_reset_handler(struct scsi_cmnd *scpnt) 273 { 274 struct zfcp_unit *unit = scpnt->device->hostdata; 275 struct zfcp_adapter *adapter = unit->port->adapter; 276 277 zfcp_erp_adapter_reopen(adapter, 0, "schrh_1", scpnt); 278 zfcp_erp_wait(adapter); 279 280 return SUCCESS; 281 } 282 283 int zfcp_adapter_scsi_register(struct zfcp_adapter *adapter) 284 { 285 struct ccw_dev_id dev_id; 286 287 if (adapter->scsi_host) 288 return 0; 289 290 ccw_device_get_id(adapter->ccw_device, &dev_id); 291 /* register adapter as SCSI host with mid layer of SCSI stack */ 292 adapter->scsi_host = scsi_host_alloc(&zfcp_data.scsi_host_template, 293 sizeof (struct zfcp_adapter *)); 294 if (!adapter->scsi_host) { 295 dev_err(&adapter->ccw_device->dev, 296 "Registering the FCP device with the " 297 "SCSI stack failed\n"); 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 316 return 0; 317 } 318 319 void zfcp_adapter_scsi_unregister(struct zfcp_adapter *adapter) 320 { 321 struct Scsi_Host *shost; 322 struct zfcp_port *port; 323 324 shost = adapter->scsi_host; 325 if (!shost) 326 return; 327 328 read_lock_irq(&zfcp_data.config_lock); 329 list_for_each_entry(port, &adapter->port_list_head, list) 330 if (port->rport) 331 port->rport = NULL; 332 333 read_unlock_irq(&zfcp_data.config_lock); 334 fc_remove_host(shost); 335 scsi_remove_host(shost); 336 scsi_host_put(shost); 337 adapter->scsi_host = NULL; 338 339 return; 340 } 341 342 static struct fc_host_statistics* 343 zfcp_init_fc_host_stats(struct zfcp_adapter *adapter) 344 { 345 struct fc_host_statistics *fc_stats; 346 347 if (!adapter->fc_stats) { 348 fc_stats = kmalloc(sizeof(*fc_stats), GFP_KERNEL); 349 if (!fc_stats) 350 return NULL; 351 adapter->fc_stats = fc_stats; /* freed in adater_dequeue */ 352 } 353 memset(adapter->fc_stats, 0, sizeof(*adapter->fc_stats)); 354 return adapter->fc_stats; 355 } 356 357 static void zfcp_adjust_fc_host_stats(struct fc_host_statistics *fc_stats, 358 struct fsf_qtcb_bottom_port *data, 359 struct fsf_qtcb_bottom_port *old) 360 { 361 fc_stats->seconds_since_last_reset = 362 data->seconds_since_last_reset - old->seconds_since_last_reset; 363 fc_stats->tx_frames = data->tx_frames - old->tx_frames; 364 fc_stats->tx_words = data->tx_words - old->tx_words; 365 fc_stats->rx_frames = data->rx_frames - old->rx_frames; 366 fc_stats->rx_words = data->rx_words - old->rx_words; 367 fc_stats->lip_count = data->lip - old->lip; 368 fc_stats->nos_count = data->nos - old->nos; 369 fc_stats->error_frames = data->error_frames - old->error_frames; 370 fc_stats->dumped_frames = data->dumped_frames - old->dumped_frames; 371 fc_stats->link_failure_count = data->link_failure - old->link_failure; 372 fc_stats->loss_of_sync_count = data->loss_of_sync - old->loss_of_sync; 373 fc_stats->loss_of_signal_count = 374 data->loss_of_signal - old->loss_of_signal; 375 fc_stats->prim_seq_protocol_err_count = 376 data->psp_error_counts - old->psp_error_counts; 377 fc_stats->invalid_tx_word_count = 378 data->invalid_tx_words - old->invalid_tx_words; 379 fc_stats->invalid_crc_count = data->invalid_crcs - old->invalid_crcs; 380 fc_stats->fcp_input_requests = 381 data->input_requests - old->input_requests; 382 fc_stats->fcp_output_requests = 383 data->output_requests - old->output_requests; 384 fc_stats->fcp_control_requests = 385 data->control_requests - old->control_requests; 386 fc_stats->fcp_input_megabytes = data->input_mb - old->input_mb; 387 fc_stats->fcp_output_megabytes = data->output_mb - old->output_mb; 388 } 389 390 static void zfcp_set_fc_host_stats(struct fc_host_statistics *fc_stats, 391 struct fsf_qtcb_bottom_port *data) 392 { 393 fc_stats->seconds_since_last_reset = data->seconds_since_last_reset; 394 fc_stats->tx_frames = data->tx_frames; 395 fc_stats->tx_words = data->tx_words; 396 fc_stats->rx_frames = data->rx_frames; 397 fc_stats->rx_words = data->rx_words; 398 fc_stats->lip_count = data->lip; 399 fc_stats->nos_count = data->nos; 400 fc_stats->error_frames = data->error_frames; 401 fc_stats->dumped_frames = data->dumped_frames; 402 fc_stats->link_failure_count = data->link_failure; 403 fc_stats->loss_of_sync_count = data->loss_of_sync; 404 fc_stats->loss_of_signal_count = data->loss_of_signal; 405 fc_stats->prim_seq_protocol_err_count = data->psp_error_counts; 406 fc_stats->invalid_tx_word_count = data->invalid_tx_words; 407 fc_stats->invalid_crc_count = data->invalid_crcs; 408 fc_stats->fcp_input_requests = data->input_requests; 409 fc_stats->fcp_output_requests = data->output_requests; 410 fc_stats->fcp_control_requests = data->control_requests; 411 fc_stats->fcp_input_megabytes = data->input_mb; 412 fc_stats->fcp_output_megabytes = data->output_mb; 413 } 414 415 static struct fc_host_statistics *zfcp_get_fc_host_stats(struct Scsi_Host *host) 416 { 417 struct zfcp_adapter *adapter; 418 struct fc_host_statistics *fc_stats; 419 struct fsf_qtcb_bottom_port *data; 420 int ret; 421 422 adapter = (struct zfcp_adapter *)host->hostdata[0]; 423 fc_stats = zfcp_init_fc_host_stats(adapter); 424 if (!fc_stats) 425 return NULL; 426 427 data = kzalloc(sizeof(*data), GFP_KERNEL); 428 if (!data) 429 return NULL; 430 431 ret = zfcp_fsf_exchange_port_data_sync(adapter->qdio, data); 432 if (ret) { 433 kfree(data); 434 return NULL; 435 } 436 437 if (adapter->stats_reset && 438 ((jiffies/HZ - adapter->stats_reset) < 439 data->seconds_since_last_reset)) 440 zfcp_adjust_fc_host_stats(fc_stats, data, 441 adapter->stats_reset_data); 442 else 443 zfcp_set_fc_host_stats(fc_stats, data); 444 445 kfree(data); 446 return fc_stats; 447 } 448 449 static void zfcp_reset_fc_host_stats(struct Scsi_Host *shost) 450 { 451 struct zfcp_adapter *adapter; 452 struct fsf_qtcb_bottom_port *data; 453 int ret; 454 455 adapter = (struct zfcp_adapter *)shost->hostdata[0]; 456 data = kzalloc(sizeof(*data), GFP_KERNEL); 457 if (!data) 458 return; 459 460 ret = zfcp_fsf_exchange_port_data_sync(adapter->qdio, data); 461 if (ret) 462 kfree(data); 463 else { 464 adapter->stats_reset = jiffies/HZ; 465 kfree(adapter->stats_reset_data); 466 adapter->stats_reset_data = data; /* finally freed in 467 adapter_dequeue */ 468 } 469 } 470 471 static void zfcp_get_host_port_state(struct Scsi_Host *shost) 472 { 473 struct zfcp_adapter *adapter = 474 (struct zfcp_adapter *)shost->hostdata[0]; 475 int status = atomic_read(&adapter->status); 476 477 if ((status & ZFCP_STATUS_COMMON_RUNNING) && 478 !(status & ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED)) 479 fc_host_port_state(shost) = FC_PORTSTATE_ONLINE; 480 else if (status & ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED) 481 fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN; 482 else if (status & ZFCP_STATUS_COMMON_ERP_FAILED) 483 fc_host_port_state(shost) = FC_PORTSTATE_ERROR; 484 else 485 fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN; 486 } 487 488 static void zfcp_set_rport_dev_loss_tmo(struct fc_rport *rport, u32 timeout) 489 { 490 rport->dev_loss_tmo = timeout; 491 } 492 493 /** 494 * zfcp_scsi_terminate_rport_io - Terminate all I/O on a rport 495 * @rport: The FC rport where to teminate I/O 496 * 497 * Abort all pending SCSI commands for a port by closing the 498 * port. Using a reopen for avoids a conflict with a shutdown 499 * overwriting a reopen. 500 */ 501 static void zfcp_scsi_terminate_rport_io(struct fc_rport *rport) 502 { 503 struct zfcp_port *port; 504 struct Scsi_Host *shost = rport_to_shost(rport); 505 struct zfcp_adapter *adapter = 506 (struct zfcp_adapter *)shost->hostdata[0]; 507 508 write_lock_irq(&zfcp_data.config_lock); 509 port = zfcp_get_port_by_wwpn(adapter, rport->port_name); 510 if (port) 511 zfcp_port_get(port); 512 write_unlock_irq(&zfcp_data.config_lock); 513 514 if (port) { 515 zfcp_erp_port_reopen(port, 0, "sctrpi1", NULL); 516 zfcp_port_put(port); 517 } 518 } 519 520 static void zfcp_scsi_rport_register(struct zfcp_port *port) 521 { 522 struct fc_rport_identifiers ids; 523 struct fc_rport *rport; 524 525 if (port->rport) 526 return; 527 528 ids.node_name = port->wwnn; 529 ids.port_name = port->wwpn; 530 ids.port_id = port->d_id; 531 ids.roles = FC_RPORT_ROLE_FCP_TARGET; 532 533 rport = fc_remote_port_add(port->adapter->scsi_host, 0, &ids); 534 if (!rport) { 535 dev_err(&port->adapter->ccw_device->dev, 536 "Registering port 0x%016Lx failed\n", 537 (unsigned long long)port->wwpn); 538 return; 539 } 540 541 rport->maxframe_size = port->maxframe_size; 542 rport->supported_classes = port->supported_classes; 543 port->rport = rport; 544 } 545 546 static void zfcp_scsi_rport_block(struct zfcp_port *port) 547 { 548 struct fc_rport *rport = port->rport; 549 550 if (rport) { 551 fc_remote_port_delete(rport); 552 port->rport = NULL; 553 } 554 } 555 556 void zfcp_scsi_schedule_rport_register(struct zfcp_port *port) 557 { 558 zfcp_port_get(port); 559 port->rport_task = RPORT_ADD; 560 561 if (!queue_work(port->adapter->work_queue, &port->rport_work)) 562 zfcp_port_put(port); 563 } 564 565 void zfcp_scsi_schedule_rport_block(struct zfcp_port *port) 566 { 567 zfcp_port_get(port); 568 port->rport_task = RPORT_DEL; 569 570 if (port->rport && queue_work(port->adapter->work_queue, 571 &port->rport_work)) 572 return; 573 574 zfcp_port_put(port); 575 } 576 577 void zfcp_scsi_schedule_rports_block(struct zfcp_adapter *adapter) 578 { 579 struct zfcp_port *port; 580 581 list_for_each_entry(port, &adapter->port_list_head, list) 582 zfcp_scsi_schedule_rport_block(port); 583 } 584 585 void zfcp_scsi_rport_work(struct work_struct *work) 586 { 587 struct zfcp_port *port = container_of(work, struct zfcp_port, 588 rport_work); 589 590 while (port->rport_task) { 591 if (port->rport_task == RPORT_ADD) { 592 port->rport_task = RPORT_NONE; 593 zfcp_scsi_rport_register(port); 594 } else { 595 port->rport_task = RPORT_NONE; 596 zfcp_scsi_rport_block(port); 597 } 598 } 599 600 zfcp_port_put(port); 601 } 602 603 604 void zfcp_scsi_scan(struct work_struct *work) 605 { 606 struct zfcp_unit *unit = container_of(work, struct zfcp_unit, 607 scsi_work); 608 struct fc_rport *rport; 609 610 flush_work(&unit->port->rport_work); 611 rport = unit->port->rport; 612 613 if (rport && rport->port_state == FC_PORTSTATE_ONLINE) 614 scsi_scan_target(&rport->dev, 0, rport->scsi_target_id, 615 scsilun_to_int((struct scsi_lun *) 616 &unit->fcp_lun), 0); 617 618 zfcp_unit_put(unit); 619 } 620 621 static int zfcp_execute_fc_job(struct fc_bsg_job *job) 622 { 623 switch (job->request->msgcode) { 624 case FC_BSG_RPT_ELS: 625 case FC_BSG_HST_ELS_NOLOGIN: 626 return zfcp_fc_execute_els_fc_job(job); 627 case FC_BSG_RPT_CT: 628 case FC_BSG_HST_CT: 629 return zfcp_fc_execute_ct_fc_job(job); 630 default: 631 return -EINVAL; 632 } 633 } 634 635 struct fc_function_template zfcp_transport_functions = { 636 .show_starget_port_id = 1, 637 .show_starget_port_name = 1, 638 .show_starget_node_name = 1, 639 .show_rport_supported_classes = 1, 640 .show_rport_maxframe_size = 1, 641 .show_rport_dev_loss_tmo = 1, 642 .show_host_node_name = 1, 643 .show_host_port_name = 1, 644 .show_host_permanent_port_name = 1, 645 .show_host_supported_classes = 1, 646 .show_host_supported_speeds = 1, 647 .show_host_maxframe_size = 1, 648 .show_host_serial_number = 1, 649 .get_fc_host_stats = zfcp_get_fc_host_stats, 650 .reset_fc_host_stats = zfcp_reset_fc_host_stats, 651 .set_rport_dev_loss_tmo = zfcp_set_rport_dev_loss_tmo, 652 .get_host_port_state = zfcp_get_host_port_state, 653 .terminate_rport_io = zfcp_scsi_terminate_rport_io, 654 .show_host_port_state = 1, 655 .bsg_request = zfcp_execute_fc_job, 656 /* no functions registered for following dynamic attributes but 657 directly set by LLDD */ 658 .show_host_port_type = 1, 659 .show_host_speed = 1, 660 .show_host_port_id = 1, 661 .disable_target_scan = 1, 662 }; 663 664 struct zfcp_data zfcp_data = { 665 .scsi_host_template = { 666 .name = "zfcp", 667 .module = THIS_MODULE, 668 .proc_name = "zfcp", 669 .change_queue_depth = zfcp_scsi_change_queue_depth, 670 .slave_alloc = zfcp_scsi_slave_alloc, 671 .slave_configure = zfcp_scsi_slave_configure, 672 .slave_destroy = zfcp_scsi_slave_destroy, 673 .queuecommand = zfcp_scsi_queuecommand, 674 .eh_abort_handler = zfcp_scsi_eh_abort_handler, 675 .eh_device_reset_handler = zfcp_scsi_eh_device_reset_handler, 676 .eh_target_reset_handler = zfcp_scsi_eh_target_reset_handler, 677 .eh_host_reset_handler = zfcp_scsi_eh_host_reset_handler, 678 .can_queue = 4096, 679 .this_id = -1, 680 .sg_tablesize = ZFCP_MAX_SBALES_PER_REQ, 681 .cmd_per_lun = 1, 682 .use_clustering = 1, 683 .sdev_attrs = zfcp_sysfs_sdev_attrs, 684 .max_sectors = (ZFCP_MAX_SBALES_PER_REQ * 8), 685 .shost_attrs = zfcp_sysfs_shost_attrs, 686 }, 687 }; 688