4 * Interface to Linux SCSI midlayer.
6 * Copyright IBM Corporation 2002, 2010
9 #define KMSG_COMPONENT "zfcp"
10 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
12 #include <linux/types.h>
13 #include <linux/slab.h>
14 #include <scsi/fc/fc_fcp.h>
15 #include <asm/atomic.h>
19 #include "zfcp_reqlist.h"
21 static unsigned int default_depth
= 32;
22 module_param_named(queue_depth
, default_depth
, uint
, 0600);
23 MODULE_PARM_DESC(queue_depth
, "Default queue depth for new SCSI devices");
25 static int zfcp_scsi_change_queue_depth(struct scsi_device
*sdev
, int depth
,
29 case SCSI_QDEPTH_DEFAULT
:
30 scsi_adjust_queue_depth(sdev
, scsi_get_tag_type(sdev
), depth
);
32 case SCSI_QDEPTH_QFULL
:
33 scsi_track_queue_full(sdev
, depth
);
35 case SCSI_QDEPTH_RAMP_UP
:
36 scsi_adjust_queue_depth(sdev
, scsi_get_tag_type(sdev
), depth
);
41 return sdev
->queue_depth
;
44 static void zfcp_scsi_slave_destroy(struct scsi_device
*sdpnt
)
46 struct zfcp_unit
*unit
= (struct zfcp_unit
*) sdpnt
->hostdata
;
48 put_device(&unit
->dev
);
51 static int zfcp_scsi_slave_configure(struct scsi_device
*sdp
)
53 if (sdp
->tagged_supported
)
54 scsi_adjust_queue_depth(sdp
, MSG_SIMPLE_TAG
, default_depth
);
56 scsi_adjust_queue_depth(sdp
, 0, 1);
60 static void zfcp_scsi_command_fail(struct scsi_cmnd
*scpnt
, int result
)
62 struct zfcp_adapter
*adapter
=
63 (struct zfcp_adapter
*) scpnt
->device
->host
->hostdata
[0];
65 set_host_byte(scpnt
, result
);
66 zfcp_dbf_scsi_fail_send(adapter
->dbf
, scpnt
);
67 scpnt
->scsi_done(scpnt
);
70 static int zfcp_scsi_queuecommand(struct scsi_cmnd
*scpnt
,
71 void (*done
) (struct scsi_cmnd
*))
73 struct zfcp_unit
*unit
;
74 struct zfcp_adapter
*adapter
;
75 int status
, scsi_result
, ret
;
76 struct fc_rport
*rport
= starget_to_rport(scsi_target(scpnt
->device
));
78 /* reset the status for this request */
80 scpnt
->host_scribble
= NULL
;
81 scpnt
->scsi_done
= done
;
84 * figure out adapter and target device
85 * (stored there by zfcp_scsi_slave_alloc)
87 adapter
= (struct zfcp_adapter
*) scpnt
->device
->host
->hostdata
[0];
88 unit
= scpnt
->device
->hostdata
;
90 scsi_result
= fc_remote_port_chkready(rport
);
91 if (unlikely(scsi_result
)) {
92 scpnt
->result
= scsi_result
;
93 zfcp_dbf_scsi_fail_send(adapter
->dbf
, scpnt
);
94 scpnt
->scsi_done(scpnt
);
98 status
= atomic_read(&unit
->status
);
99 if (unlikely(status
& ZFCP_STATUS_COMMON_ERP_FAILED
) &&
100 !(atomic_read(&unit
->port
->status
) &
101 ZFCP_STATUS_COMMON_ERP_FAILED
)) {
102 /* only unit access denied, but port is good
103 * not covered by FC transport, have to fail here */
104 zfcp_scsi_command_fail(scpnt
, DID_ERROR
);
108 if (unlikely(!(status
& ZFCP_STATUS_COMMON_UNBLOCKED
))) {
109 /* This could be either
110 * open unit pending: this is temporary, will result in
111 * open unit or ERP_FAILED, so retry command
112 * call to rport_delete pending: mimic retry from
113 * fc_remote_port_chkready until rport is BLOCKED
115 zfcp_scsi_command_fail(scpnt
, DID_IMM_RETRY
);
119 ret
= zfcp_fsf_send_fcp_command_task(unit
, scpnt
);
120 if (unlikely(ret
== -EBUSY
))
121 return SCSI_MLQUEUE_DEVICE_BUSY
;
122 else if (unlikely(ret
< 0))
123 return SCSI_MLQUEUE_HOST_BUSY
;
128 static struct zfcp_unit
*zfcp_unit_lookup(struct zfcp_adapter
*adapter
,
129 unsigned int id
, u64 lun
)
132 struct zfcp_port
*port
;
133 struct zfcp_unit
*unit
= NULL
;
135 read_lock_irqsave(&adapter
->port_list_lock
, flags
);
136 list_for_each_entry(port
, &adapter
->port_list
, list
) {
137 if (!port
->rport
|| (id
!= port
->rport
->scsi_target_id
))
139 unit
= zfcp_get_unit_by_lun(port
, lun
);
143 read_unlock_irqrestore(&adapter
->port_list_lock
, flags
);
148 static int zfcp_scsi_slave_alloc(struct scsi_device
*sdp
)
150 struct zfcp_adapter
*adapter
;
151 struct zfcp_unit
*unit
;
154 adapter
= (struct zfcp_adapter
*) sdp
->host
->hostdata
[0];
158 int_to_scsilun(sdp
->lun
, (struct scsi_lun
*)&lun
);
159 unit
= zfcp_unit_lookup(adapter
, sdp
->id
, lun
);
161 sdp
->hostdata
= unit
;
169 static int zfcp_scsi_eh_abort_handler(struct scsi_cmnd
*scpnt
)
171 struct Scsi_Host
*scsi_host
= scpnt
->device
->host
;
172 struct zfcp_adapter
*adapter
=
173 (struct zfcp_adapter
*) scsi_host
->hostdata
[0];
174 struct zfcp_unit
*unit
= scpnt
->device
->hostdata
;
175 struct zfcp_fsf_req
*old_req
, *abrt_req
;
177 unsigned long old_reqid
= (unsigned long) scpnt
->host_scribble
;
178 int retval
= SUCCESS
;
182 /* avoid race condition between late normal completion and abort */
183 write_lock_irqsave(&adapter
->abort_lock
, flags
);
185 old_req
= zfcp_reqlist_find(adapter
->req_list
, old_reqid
);
187 write_unlock_irqrestore(&adapter
->abort_lock
, flags
);
188 zfcp_dbf_scsi_abort("lte1", adapter
->dbf
, scpnt
, NULL
,
190 return FAILED
; /* completion could be in progress */
192 old_req
->data
= NULL
;
194 /* don't access old fsf_req after releasing the abort_lock */
195 write_unlock_irqrestore(&adapter
->abort_lock
, flags
);
198 abrt_req
= zfcp_fsf_abort_fcp_command(old_reqid
, unit
);
202 zfcp_erp_wait(adapter
);
203 fc_block_scsi_eh(scpnt
);
204 if (!(atomic_read(&adapter
->status
) &
205 ZFCP_STATUS_COMMON_RUNNING
)) {
206 zfcp_dbf_scsi_abort("nres", adapter
->dbf
, scpnt
, NULL
,
214 wait_for_completion(&abrt_req
->completion
);
216 if (abrt_req
->status
& ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED
)
218 else if (abrt_req
->status
& ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED
)
224 zfcp_dbf_scsi_abort(dbf_tag
, adapter
->dbf
, scpnt
, abrt_req
, old_reqid
);
225 zfcp_fsf_req_free(abrt_req
);
229 static int zfcp_task_mgmt_function(struct scsi_cmnd
*scpnt
, u8 tm_flags
)
231 struct zfcp_unit
*unit
= scpnt
->device
->hostdata
;
232 struct zfcp_adapter
*adapter
= unit
->port
->adapter
;
233 struct zfcp_fsf_req
*fsf_req
= NULL
;
234 int retval
= SUCCESS
;
238 fsf_req
= zfcp_fsf_send_fcp_ctm(unit
, tm_flags
);
242 zfcp_erp_wait(adapter
);
243 fc_block_scsi_eh(scpnt
);
244 if (!(atomic_read(&adapter
->status
) &
245 ZFCP_STATUS_COMMON_RUNNING
)) {
246 zfcp_dbf_scsi_devreset("nres", tm_flags
, unit
, scpnt
);
253 wait_for_completion(&fsf_req
->completion
);
255 if (fsf_req
->status
& ZFCP_STATUS_FSFREQ_TMFUNCFAILED
) {
256 zfcp_dbf_scsi_devreset("fail", tm_flags
, unit
, scpnt
);
259 zfcp_dbf_scsi_devreset("okay", tm_flags
, unit
, scpnt
);
261 zfcp_fsf_req_free(fsf_req
);
265 static int zfcp_scsi_eh_device_reset_handler(struct scsi_cmnd
*scpnt
)
267 return zfcp_task_mgmt_function(scpnt
, FCP_TMF_LUN_RESET
);
270 static int zfcp_scsi_eh_target_reset_handler(struct scsi_cmnd
*scpnt
)
272 return zfcp_task_mgmt_function(scpnt
, FCP_TMF_TGT_RESET
);
275 static int zfcp_scsi_eh_host_reset_handler(struct scsi_cmnd
*scpnt
)
277 struct zfcp_unit
*unit
= scpnt
->device
->hostdata
;
278 struct zfcp_adapter
*adapter
= unit
->port
->adapter
;
280 zfcp_erp_adapter_reopen(adapter
, 0, "schrh_1", scpnt
);
281 zfcp_erp_wait(adapter
);
282 fc_block_scsi_eh(scpnt
);
287 int zfcp_adapter_scsi_register(struct zfcp_adapter
*adapter
)
289 struct ccw_dev_id dev_id
;
291 if (adapter
->scsi_host
)
294 ccw_device_get_id(adapter
->ccw_device
, &dev_id
);
295 /* register adapter as SCSI host with mid layer of SCSI stack */
296 adapter
->scsi_host
= scsi_host_alloc(&zfcp_data
.scsi_host_template
,
297 sizeof (struct zfcp_adapter
*));
298 if (!adapter
->scsi_host
) {
299 dev_err(&adapter
->ccw_device
->dev
,
300 "Registering the FCP device with the "
301 "SCSI stack failed\n");
305 /* tell the SCSI stack some characteristics of this adapter */
306 adapter
->scsi_host
->max_id
= 1;
307 adapter
->scsi_host
->max_lun
= 1;
308 adapter
->scsi_host
->max_channel
= 0;
309 adapter
->scsi_host
->unique_id
= dev_id
.devno
;
310 adapter
->scsi_host
->max_cmd_len
= 16; /* in struct fcp_cmnd */
311 adapter
->scsi_host
->transportt
= zfcp_data
.scsi_transport_template
;
313 adapter
->scsi_host
->hostdata
[0] = (unsigned long) adapter
;
315 if (scsi_add_host(adapter
->scsi_host
, &adapter
->ccw_device
->dev
)) {
316 scsi_host_put(adapter
->scsi_host
);
323 void zfcp_adapter_scsi_unregister(struct zfcp_adapter
*adapter
)
325 struct Scsi_Host
*shost
;
326 struct zfcp_port
*port
;
328 shost
= adapter
->scsi_host
;
332 read_lock_irq(&adapter
->port_list_lock
);
333 list_for_each_entry(port
, &adapter
->port_list
, list
)
335 read_unlock_irq(&adapter
->port_list_lock
);
337 fc_remove_host(shost
);
338 scsi_remove_host(shost
);
339 scsi_host_put(shost
);
340 adapter
->scsi_host
= NULL
;
345 static struct fc_host_statistics
*
346 zfcp_init_fc_host_stats(struct zfcp_adapter
*adapter
)
348 struct fc_host_statistics
*fc_stats
;
350 if (!adapter
->fc_stats
) {
351 fc_stats
= kmalloc(sizeof(*fc_stats
), GFP_KERNEL
);
354 adapter
->fc_stats
= fc_stats
; /* freed in adapter_release */
356 memset(adapter
->fc_stats
, 0, sizeof(*adapter
->fc_stats
));
357 return adapter
->fc_stats
;
360 static void zfcp_adjust_fc_host_stats(struct fc_host_statistics
*fc_stats
,
361 struct fsf_qtcb_bottom_port
*data
,
362 struct fsf_qtcb_bottom_port
*old
)
364 fc_stats
->seconds_since_last_reset
=
365 data
->seconds_since_last_reset
- old
->seconds_since_last_reset
;
366 fc_stats
->tx_frames
= data
->tx_frames
- old
->tx_frames
;
367 fc_stats
->tx_words
= data
->tx_words
- old
->tx_words
;
368 fc_stats
->rx_frames
= data
->rx_frames
- old
->rx_frames
;
369 fc_stats
->rx_words
= data
->rx_words
- old
->rx_words
;
370 fc_stats
->lip_count
= data
->lip
- old
->lip
;
371 fc_stats
->nos_count
= data
->nos
- old
->nos
;
372 fc_stats
->error_frames
= data
->error_frames
- old
->error_frames
;
373 fc_stats
->dumped_frames
= data
->dumped_frames
- old
->dumped_frames
;
374 fc_stats
->link_failure_count
= data
->link_failure
- old
->link_failure
;
375 fc_stats
->loss_of_sync_count
= data
->loss_of_sync
- old
->loss_of_sync
;
376 fc_stats
->loss_of_signal_count
=
377 data
->loss_of_signal
- old
->loss_of_signal
;
378 fc_stats
->prim_seq_protocol_err_count
=
379 data
->psp_error_counts
- old
->psp_error_counts
;
380 fc_stats
->invalid_tx_word_count
=
381 data
->invalid_tx_words
- old
->invalid_tx_words
;
382 fc_stats
->invalid_crc_count
= data
->invalid_crcs
- old
->invalid_crcs
;
383 fc_stats
->fcp_input_requests
=
384 data
->input_requests
- old
->input_requests
;
385 fc_stats
->fcp_output_requests
=
386 data
->output_requests
- old
->output_requests
;
387 fc_stats
->fcp_control_requests
=
388 data
->control_requests
- old
->control_requests
;
389 fc_stats
->fcp_input_megabytes
= data
->input_mb
- old
->input_mb
;
390 fc_stats
->fcp_output_megabytes
= data
->output_mb
- old
->output_mb
;
393 static void zfcp_set_fc_host_stats(struct fc_host_statistics
*fc_stats
,
394 struct fsf_qtcb_bottom_port
*data
)
396 fc_stats
->seconds_since_last_reset
= data
->seconds_since_last_reset
;
397 fc_stats
->tx_frames
= data
->tx_frames
;
398 fc_stats
->tx_words
= data
->tx_words
;
399 fc_stats
->rx_frames
= data
->rx_frames
;
400 fc_stats
->rx_words
= data
->rx_words
;
401 fc_stats
->lip_count
= data
->lip
;
402 fc_stats
->nos_count
= data
->nos
;
403 fc_stats
->error_frames
= data
->error_frames
;
404 fc_stats
->dumped_frames
= data
->dumped_frames
;
405 fc_stats
->link_failure_count
= data
->link_failure
;
406 fc_stats
->loss_of_sync_count
= data
->loss_of_sync
;
407 fc_stats
->loss_of_signal_count
= data
->loss_of_signal
;
408 fc_stats
->prim_seq_protocol_err_count
= data
->psp_error_counts
;
409 fc_stats
->invalid_tx_word_count
= data
->invalid_tx_words
;
410 fc_stats
->invalid_crc_count
= data
->invalid_crcs
;
411 fc_stats
->fcp_input_requests
= data
->input_requests
;
412 fc_stats
->fcp_output_requests
= data
->output_requests
;
413 fc_stats
->fcp_control_requests
= data
->control_requests
;
414 fc_stats
->fcp_input_megabytes
= data
->input_mb
;
415 fc_stats
->fcp_output_megabytes
= data
->output_mb
;
418 static struct fc_host_statistics
*zfcp_get_fc_host_stats(struct Scsi_Host
*host
)
420 struct zfcp_adapter
*adapter
;
421 struct fc_host_statistics
*fc_stats
;
422 struct fsf_qtcb_bottom_port
*data
;
425 adapter
= (struct zfcp_adapter
*)host
->hostdata
[0];
426 fc_stats
= zfcp_init_fc_host_stats(adapter
);
430 data
= kzalloc(sizeof(*data
), GFP_KERNEL
);
434 ret
= zfcp_fsf_exchange_port_data_sync(adapter
->qdio
, data
);
440 if (adapter
->stats_reset
&&
441 ((jiffies
/HZ
- adapter
->stats_reset
) <
442 data
->seconds_since_last_reset
))
443 zfcp_adjust_fc_host_stats(fc_stats
, data
,
444 adapter
->stats_reset_data
);
446 zfcp_set_fc_host_stats(fc_stats
, data
);
452 static void zfcp_reset_fc_host_stats(struct Scsi_Host
*shost
)
454 struct zfcp_adapter
*adapter
;
455 struct fsf_qtcb_bottom_port
*data
;
458 adapter
= (struct zfcp_adapter
*)shost
->hostdata
[0];
459 data
= kzalloc(sizeof(*data
), GFP_KERNEL
);
463 ret
= zfcp_fsf_exchange_port_data_sync(adapter
->qdio
, data
);
467 adapter
->stats_reset
= jiffies
/HZ
;
468 kfree(adapter
->stats_reset_data
);
469 adapter
->stats_reset_data
= data
; /* finally freed in
474 static void zfcp_get_host_port_state(struct Scsi_Host
*shost
)
476 struct zfcp_adapter
*adapter
=
477 (struct zfcp_adapter
*)shost
->hostdata
[0];
478 int status
= atomic_read(&adapter
->status
);
480 if ((status
& ZFCP_STATUS_COMMON_RUNNING
) &&
481 !(status
& ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED
))
482 fc_host_port_state(shost
) = FC_PORTSTATE_ONLINE
;
483 else if (status
& ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED
)
484 fc_host_port_state(shost
) = FC_PORTSTATE_LINKDOWN
;
485 else if (status
& ZFCP_STATUS_COMMON_ERP_FAILED
)
486 fc_host_port_state(shost
) = FC_PORTSTATE_ERROR
;
488 fc_host_port_state(shost
) = FC_PORTSTATE_UNKNOWN
;
491 static void zfcp_set_rport_dev_loss_tmo(struct fc_rport
*rport
, u32 timeout
)
493 rport
->dev_loss_tmo
= timeout
;
497 * zfcp_scsi_terminate_rport_io - Terminate all I/O on a rport
498 * @rport: The FC rport where to teminate I/O
500 * Abort all pending SCSI commands for a port by closing the
501 * port. Using a reopen avoiding a conflict with a shutdown
502 * overwriting a reopen.
504 static void zfcp_scsi_terminate_rport_io(struct fc_rport
*rport
)
506 struct zfcp_port
*port
;
507 struct Scsi_Host
*shost
= rport_to_shost(rport
);
508 struct zfcp_adapter
*adapter
=
509 (struct zfcp_adapter
*)shost
->hostdata
[0];
511 port
= zfcp_get_port_by_wwpn(adapter
, rport
->port_name
);
514 zfcp_erp_port_reopen(port
, 0, "sctrpi1", NULL
);
515 put_device(&port
->dev
);
519 static void zfcp_scsi_rport_register(struct zfcp_port
*port
)
521 struct fc_rport_identifiers ids
;
522 struct fc_rport
*rport
;
527 ids
.node_name
= port
->wwnn
;
528 ids
.port_name
= port
->wwpn
;
529 ids
.port_id
= port
->d_id
;
530 ids
.roles
= FC_RPORT_ROLE_FCP_TARGET
;
532 rport
= fc_remote_port_add(port
->adapter
->scsi_host
, 0, &ids
);
534 dev_err(&port
->adapter
->ccw_device
->dev
,
535 "Registering port 0x%016Lx failed\n",
536 (unsigned long long)port
->wwpn
);
540 rport
->maxframe_size
= port
->maxframe_size
;
541 rport
->supported_classes
= port
->supported_classes
;
545 static void zfcp_scsi_rport_block(struct zfcp_port
*port
)
547 struct fc_rport
*rport
= port
->rport
;
550 fc_remote_port_delete(rport
);
555 void zfcp_scsi_schedule_rport_register(struct zfcp_port
*port
)
557 get_device(&port
->dev
);
558 port
->rport_task
= RPORT_ADD
;
560 if (!queue_work(port
->adapter
->work_queue
, &port
->rport_work
))
561 put_device(&port
->dev
);
564 void zfcp_scsi_schedule_rport_block(struct zfcp_port
*port
)
566 get_device(&port
->dev
);
567 port
->rport_task
= RPORT_DEL
;
569 if (port
->rport
&& queue_work(port
->adapter
->work_queue
,
573 put_device(&port
->dev
);
576 void zfcp_scsi_schedule_rports_block(struct zfcp_adapter
*adapter
)
579 struct zfcp_port
*port
;
581 read_lock_irqsave(&adapter
->port_list_lock
, flags
);
582 list_for_each_entry(port
, &adapter
->port_list
, list
)
583 zfcp_scsi_schedule_rport_block(port
);
584 read_unlock_irqrestore(&adapter
->port_list_lock
, flags
);
587 void zfcp_scsi_rport_work(struct work_struct
*work
)
589 struct zfcp_port
*port
= container_of(work
, struct zfcp_port
,
592 while (port
->rport_task
) {
593 if (port
->rport_task
== RPORT_ADD
) {
594 port
->rport_task
= RPORT_NONE
;
595 zfcp_scsi_rport_register(port
);
597 port
->rport_task
= RPORT_NONE
;
598 zfcp_scsi_rport_block(port
);
602 put_device(&port
->dev
);
606 void zfcp_scsi_scan(struct work_struct
*work
)
608 struct zfcp_unit
*unit
= container_of(work
, struct zfcp_unit
,
610 struct fc_rport
*rport
;
612 flush_work(&unit
->port
->rport_work
);
613 rport
= unit
->port
->rport
;
615 if (rport
&& rport
->port_state
== FC_PORTSTATE_ONLINE
)
616 scsi_scan_target(&rport
->dev
, 0, rport
->scsi_target_id
,
617 scsilun_to_int((struct scsi_lun
*)
620 put_device(&unit
->dev
);
623 struct fc_function_template zfcp_transport_functions
= {
624 .show_starget_port_id
= 1,
625 .show_starget_port_name
= 1,
626 .show_starget_node_name
= 1,
627 .show_rport_supported_classes
= 1,
628 .show_rport_maxframe_size
= 1,
629 .show_rport_dev_loss_tmo
= 1,
630 .show_host_node_name
= 1,
631 .show_host_port_name
= 1,
632 .show_host_permanent_port_name
= 1,
633 .show_host_supported_classes
= 1,
634 .show_host_supported_fc4s
= 1,
635 .show_host_supported_speeds
= 1,
636 .show_host_maxframe_size
= 1,
637 .show_host_serial_number
= 1,
638 .get_fc_host_stats
= zfcp_get_fc_host_stats
,
639 .reset_fc_host_stats
= zfcp_reset_fc_host_stats
,
640 .set_rport_dev_loss_tmo
= zfcp_set_rport_dev_loss_tmo
,
641 .get_host_port_state
= zfcp_get_host_port_state
,
642 .terminate_rport_io
= zfcp_scsi_terminate_rport_io
,
643 .show_host_port_state
= 1,
644 .show_host_active_fc4s
= 1,
645 .bsg_request
= zfcp_fc_exec_bsg_job
,
646 .bsg_timeout
= zfcp_fc_timeout_bsg_job
,
647 /* no functions registered for following dynamic attributes but
648 directly set by LLDD */
649 .show_host_port_type
= 1,
650 .show_host_speed
= 1,
651 .show_host_port_id
= 1,
652 .disable_target_scan
= 1,
653 .dd_bsg_size
= sizeof(struct zfcp_fsf_ct_els
),
656 struct zfcp_data zfcp_data
= {
657 .scsi_host_template
= {
659 .module
= THIS_MODULE
,
661 .change_queue_depth
= zfcp_scsi_change_queue_depth
,
662 .slave_alloc
= zfcp_scsi_slave_alloc
,
663 .slave_configure
= zfcp_scsi_slave_configure
,
664 .slave_destroy
= zfcp_scsi_slave_destroy
,
665 .queuecommand
= zfcp_scsi_queuecommand
,
666 .eh_abort_handler
= zfcp_scsi_eh_abort_handler
,
667 .eh_device_reset_handler
= zfcp_scsi_eh_device_reset_handler
,
668 .eh_target_reset_handler
= zfcp_scsi_eh_target_reset_handler
,
669 .eh_host_reset_handler
= zfcp_scsi_eh_host_reset_handler
,
672 .sg_tablesize
= ZFCP_MAX_SBALES_PER_REQ
,
675 .sdev_attrs
= zfcp_sysfs_sdev_attrs
,
676 .max_sectors
= (ZFCP_MAX_SBALES_PER_REQ
* 8),
677 .shost_attrs
= zfcp_sysfs_shost_attrs
,