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