2 * This file is part of the zfcp device driver for
3 * FCP adapters for IBM System z9 and zSeries.
5 * (C) Copyright IBM Corp. 2002, 2006
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2, or (at your option)
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 #define ZFCP_LOG_AREA ZFCP_LOG_AREA_SCSI
26 static void zfcp_scsi_slave_destroy(struct scsi_device
*sdp
);
27 static int zfcp_scsi_slave_alloc(struct scsi_device
*sdp
);
28 static int zfcp_scsi_slave_configure(struct scsi_device
*sdp
);
29 static int zfcp_scsi_queuecommand(struct scsi_cmnd
*,
30 void (*done
) (struct scsi_cmnd
*));
31 static int zfcp_scsi_eh_abort_handler(struct scsi_cmnd
*);
32 static int zfcp_scsi_eh_device_reset_handler(struct scsi_cmnd
*);
33 static int zfcp_scsi_eh_host_reset_handler(struct scsi_cmnd
*);
34 static int zfcp_task_management_function(struct zfcp_unit
*, u8
,
37 static struct zfcp_unit
*zfcp_unit_lookup(struct zfcp_adapter
*, int,
38 unsigned int, unsigned int);
40 static struct device_attribute
*zfcp_sysfs_sdev_attrs
[];
42 struct zfcp_data zfcp_data
= {
43 .scsi_host_template
= {
45 .module
= THIS_MODULE
,
47 .slave_alloc
= zfcp_scsi_slave_alloc
,
48 .slave_configure
= zfcp_scsi_slave_configure
,
49 .slave_destroy
= zfcp_scsi_slave_destroy
,
50 .queuecommand
= zfcp_scsi_queuecommand
,
51 .eh_abort_handler
= zfcp_scsi_eh_abort_handler
,
52 .eh_device_reset_handler
= zfcp_scsi_eh_device_reset_handler
,
53 .eh_bus_reset_handler
= zfcp_scsi_eh_host_reset_handler
,
54 .eh_host_reset_handler
= zfcp_scsi_eh_host_reset_handler
,
57 .sg_tablesize
= ZFCP_MAX_SBALES_PER_REQ
,
60 .sdev_attrs
= zfcp_sysfs_sdev_attrs
,
62 .driver_version
= ZFCP_VERSION
,
65 /* Find start of Response Information in FCP response unit*/
67 zfcp_get_fcp_rsp_info_ptr(struct fcp_rsp_iu
*fcp_rsp_iu
)
69 char *fcp_rsp_info_ptr
;
72 (unsigned char *) fcp_rsp_iu
+ (sizeof (struct fcp_rsp_iu
));
74 return fcp_rsp_info_ptr
;
77 /* Find start of Sense Information in FCP response unit*/
79 zfcp_get_fcp_sns_info_ptr(struct fcp_rsp_iu
*fcp_rsp_iu
)
81 char *fcp_sns_info_ptr
;
84 (unsigned char *) fcp_rsp_iu
+ (sizeof (struct fcp_rsp_iu
));
85 if (fcp_rsp_iu
->validity
.bits
.fcp_rsp_len_valid
)
86 fcp_sns_info_ptr
= (char *) fcp_sns_info_ptr
+
87 fcp_rsp_iu
->fcp_rsp_len
;
89 return fcp_sns_info_ptr
;
93 zfcp_get_fcp_dl_ptr(struct fcp_cmnd_iu
* fcp_cmd
)
95 int additional_length
= fcp_cmd
->add_fcp_cdb_length
<< 2;
96 fcp_dl_t
*fcp_dl_addr
;
98 fcp_dl_addr
= (fcp_dl_t
*)
99 ((unsigned char *) fcp_cmd
+
100 sizeof (struct fcp_cmnd_iu
) + additional_length
);
102 * fcp_dl_addr = start address of fcp_cmnd structure +
103 * size of fixed part + size of dynamically sized add_dcp_cdb field
104 * SEE FCP-2 documentation
110 zfcp_get_fcp_dl(struct fcp_cmnd_iu
* fcp_cmd
)
112 return *zfcp_get_fcp_dl_ptr(fcp_cmd
);
116 zfcp_set_fcp_dl(struct fcp_cmnd_iu
*fcp_cmd
, fcp_dl_t fcp_dl
)
118 *zfcp_get_fcp_dl_ptr(fcp_cmd
) = fcp_dl
;
122 * note: it's a bit-or operation not an assignment
123 * regarding the specified byte
126 set_byte(u32
* result
, char status
, char pos
)
128 *result
|= status
<< (pos
* 8);
132 set_host_byte(u32
* result
, char status
)
134 set_byte(result
, status
, 2);
138 set_driver_byte(u32
* result
, char status
)
140 set_byte(result
, status
, 3);
144 zfcp_scsi_slave_alloc(struct scsi_device
*sdp
)
146 struct zfcp_adapter
*adapter
;
147 struct zfcp_unit
*unit
;
151 adapter
= (struct zfcp_adapter
*) sdp
->host
->hostdata
[0];
155 read_lock_irqsave(&zfcp_data
.config_lock
, flags
);
156 unit
= zfcp_unit_lookup(adapter
, sdp
->channel
, sdp
->id
, sdp
->lun
);
157 if (unit
&& atomic_test_mask(ZFCP_STATUS_UNIT_REGISTERED
,
159 sdp
->hostdata
= unit
;
164 read_unlock_irqrestore(&zfcp_data
.config_lock
, flags
);
170 * zfcp_scsi_slave_destroy - called when scsi device is removed
172 * Remove reference to associated scsi device for an zfcp_unit.
173 * Mark zfcp_unit as failed. The scsi device might be deleted via sysfs
174 * or a scan for this device might have failed.
176 static void zfcp_scsi_slave_destroy(struct scsi_device
*sdpnt
)
178 struct zfcp_unit
*unit
= (struct zfcp_unit
*) sdpnt
->hostdata
;
181 atomic_clear_mask(ZFCP_STATUS_UNIT_REGISTERED
, &unit
->status
);
182 sdpnt
->hostdata
= NULL
;
184 zfcp_erp_unit_failed(unit
);
187 ZFCP_LOG_NORMAL("bug: no unit associated with SCSI device at "
188 "address %p\n", sdpnt
);
193 * called from scsi midlayer to allow finetuning of a device.
196 zfcp_scsi_slave_configure(struct scsi_device
*sdp
)
198 if (sdp
->tagged_supported
)
199 scsi_adjust_queue_depth(sdp
, MSG_SIMPLE_TAG
, ZFCP_CMND_PER_LUN
);
201 scsi_adjust_queue_depth(sdp
, 0, 1);
206 * zfcp_scsi_command_fail - set result in scsi_cmnd and call scsi_done function
207 * @scpnt: pointer to struct scsi_cmnd where result is set
208 * @result: result to be set in scpnt (e.g. DID_ERROR)
211 zfcp_scsi_command_fail(struct scsi_cmnd
*scpnt
, int result
)
213 set_host_byte(&scpnt
->result
, result
);
214 if ((scpnt
->device
!= NULL
) && (scpnt
->device
->host
!= NULL
))
215 zfcp_scsi_dbf_event_result("fail", 4,
216 (struct zfcp_adapter
*) scpnt
->device
->host
->hostdata
[0],
218 /* return directly */
219 scpnt
->scsi_done(scpnt
);
223 * zfcp_scsi_command_async - worker for zfcp_scsi_queuecommand and
224 * zfcp_scsi_command_sync
225 * @adapter: adapter where scsi command is issued
226 * @unit: unit to which scsi command is sent
227 * @scpnt: scsi command to be sent
228 * @timer: timer to be started if request is successfully initiated
230 * Note: In scsi_done function must be set in scpnt.
233 zfcp_scsi_command_async(struct zfcp_adapter
*adapter
, struct zfcp_unit
*unit
,
234 struct scsi_cmnd
*scpnt
, int use_timer
)
241 BUG_ON((adapter
== NULL
) || (adapter
!= unit
->port
->adapter
));
242 BUG_ON(scpnt
->scsi_done
== NULL
);
244 if (unlikely(NULL
== unit
)) {
245 zfcp_scsi_command_fail(scpnt
, DID_NO_CONNECT
);
250 atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED
, &unit
->status
) ||
251 !atomic_test_mask(ZFCP_STATUS_COMMON_RUNNING
, &unit
->status
))) {
252 ZFCP_LOG_DEBUG("stopping SCSI I/O on unit 0x%016Lx on port "
253 "0x%016Lx on adapter %s\n",
254 unit
->fcp_lun
, unit
->port
->wwpn
,
255 zfcp_get_busid_by_adapter(adapter
));
256 zfcp_scsi_command_fail(scpnt
, DID_ERROR
);
261 !atomic_test_mask(ZFCP_STATUS_COMMON_UNBLOCKED
, &unit
->status
))) {
262 ZFCP_LOG_DEBUG("adapter %s not ready or unit 0x%016Lx "
263 "on port 0x%016Lx in recovery\n",
264 zfcp_get_busid_by_unit(unit
),
265 unit
->fcp_lun
, unit
->port
->wwpn
);
266 zfcp_scsi_command_fail(scpnt
, DID_NO_CONNECT
);
270 tmp
= zfcp_fsf_send_fcp_command_task(adapter
, unit
, scpnt
, use_timer
,
271 ZFCP_REQ_AUTO_CLEANUP
);
273 if (unlikely(tmp
< 0)) {
274 ZFCP_LOG_DEBUG("error: initiation of Send FCP Cmnd failed\n");
275 retval
= SCSI_MLQUEUE_HOST_BUSY
;
283 zfcp_scsi_command_sync_handler(struct scsi_cmnd
*scpnt
)
285 struct completion
*wait
= (struct completion
*) scpnt
->SCp
.ptr
;
291 * zfcp_scsi_command_sync - send a SCSI command and wait for completion
292 * @unit: unit where command is sent to
293 * @scpnt: scsi command to be sent
294 * @use_timer: indicates whether timer should be setup or not
297 * Errors are indicated in scpnt->result
300 zfcp_scsi_command_sync(struct zfcp_unit
*unit
, struct scsi_cmnd
*scpnt
,
304 DECLARE_COMPLETION(wait
);
306 scpnt
->SCp
.ptr
= (void *) &wait
; /* silent re-use */
307 scpnt
->scsi_done
= zfcp_scsi_command_sync_handler
;
308 ret
= zfcp_scsi_command_async(unit
->port
->adapter
, unit
, scpnt
,
311 wait_for_completion(&wait
);
313 scpnt
->SCp
.ptr
= NULL
;
319 * function: zfcp_scsi_queuecommand
321 * purpose: enqueues a SCSI command to the specified target device
323 * returns: 0 - success, SCSI command enqueued
327 zfcp_scsi_queuecommand(struct scsi_cmnd
*scpnt
,
328 void (*done
) (struct scsi_cmnd
*))
330 struct zfcp_unit
*unit
;
331 struct zfcp_adapter
*adapter
;
333 /* reset the status for this request */
335 scpnt
->host_scribble
= NULL
;
336 scpnt
->scsi_done
= done
;
339 * figure out adapter and target device
340 * (stored there by zfcp_scsi_slave_alloc)
342 adapter
= (struct zfcp_adapter
*) scpnt
->device
->host
->hostdata
[0];
343 unit
= (struct zfcp_unit
*) scpnt
->device
->hostdata
;
345 return zfcp_scsi_command_async(adapter
, unit
, scpnt
, 0);
348 static struct zfcp_unit
*
349 zfcp_unit_lookup(struct zfcp_adapter
*adapter
, int channel
, unsigned int id
,
352 struct zfcp_port
*port
;
353 struct zfcp_unit
*unit
, *retval
= NULL
;
355 list_for_each_entry(port
, &adapter
->port_list_head
, list
) {
356 if (!port
->rport
|| (id
!= port
->rport
->scsi_target_id
))
358 list_for_each_entry(unit
, &port
->unit_list_head
, list
) {
359 if (lun
== unit
->scsi_lun
) {
370 * zfcp_scsi_eh_abort_handler - abort the specified SCSI command
371 * @scpnt: pointer to scsi_cmnd to be aborted
372 * Return: SUCCESS - command has been aborted and cleaned up in internal
373 * bookkeeping, SCSI stack won't be called for aborted command
376 * We do not need to care for a SCSI command which completes normally
377 * but late during this abort routine runs. We are allowed to return
378 * late commands to the SCSI stack. It tracks the state of commands and
379 * will handle late commands. (Usually, the normal completion of late
380 * commands is ignored with respect to the running abort operation.)
382 int zfcp_scsi_eh_abort_handler(struct scsi_cmnd
*scpnt
)
384 struct Scsi_Host
*scsi_host
;
385 struct zfcp_adapter
*adapter
;
386 struct zfcp_unit
*unit
;
387 struct zfcp_fsf_req
*fsf_req
;
389 unsigned long old_req_id
;
390 int retval
= SUCCESS
;
392 scsi_host
= scpnt
->device
->host
;
393 adapter
= (struct zfcp_adapter
*) scsi_host
->hostdata
[0];
394 unit
= (struct zfcp_unit
*) scpnt
->device
->hostdata
;
396 ZFCP_LOG_INFO("aborting scsi_cmnd=%p on adapter %s\n",
397 scpnt
, zfcp_get_busid_by_adapter(adapter
));
399 /* avoid race condition between late normal completion and abort */
400 write_lock_irqsave(&adapter
->abort_lock
, flags
);
402 /* Check whether corresponding fsf_req is still pending */
403 spin_lock(&adapter
->req_list_lock
);
404 fsf_req
= zfcp_reqlist_ismember(adapter
, (unsigned long)
405 scpnt
->host_scribble
);
406 spin_unlock(&adapter
->req_list_lock
);
408 write_unlock_irqrestore(&adapter
->abort_lock
, flags
);
409 zfcp_scsi_dbf_event_abort("lte1", adapter
, scpnt
, NULL
, 0);
414 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ABORTING
;
415 old_req_id
= fsf_req
->req_id
;
417 /* don't access old fsf_req after releasing the abort_lock */
418 write_unlock_irqrestore(&adapter
->abort_lock
, flags
);
420 fsf_req
= zfcp_fsf_abort_fcp_command(old_req_id
, adapter
, unit
, 0);
422 ZFCP_LOG_INFO("error: initiation of Abort FCP Cmnd failed\n");
423 zfcp_scsi_dbf_event_abort("nres", adapter
, scpnt
, NULL
,
429 __wait_event(fsf_req
->completion_wq
,
430 fsf_req
->status
& ZFCP_STATUS_FSFREQ_COMPLETED
);
432 if (fsf_req
->status
& ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED
) {
433 zfcp_scsi_dbf_event_abort("okay", adapter
, scpnt
, fsf_req
, 0);
435 } else if (fsf_req
->status
& ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED
) {
436 zfcp_scsi_dbf_event_abort("lte2", adapter
, scpnt
, fsf_req
, 0);
439 zfcp_scsi_dbf_event_abort("fail", adapter
, scpnt
, fsf_req
, 0);
442 zfcp_fsf_req_free(fsf_req
);
448 zfcp_scsi_eh_device_reset_handler(struct scsi_cmnd
*scpnt
)
451 struct zfcp_unit
*unit
= (struct zfcp_unit
*) scpnt
->device
->hostdata
;
454 ZFCP_LOG_NORMAL("bug: Tried reset for nonexistent unit\n");
458 ZFCP_LOG_NORMAL("resetting unit 0x%016Lx\n", unit
->fcp_lun
);
461 * If we do not know whether the unit supports 'logical unit reset'
462 * then try 'logical unit reset' and proceed with 'target reset'
463 * if 'logical unit reset' fails.
464 * If the unit is known not to support 'logical unit reset' then
465 * skip 'logical unit reset' and try 'target reset' immediately.
467 if (!atomic_test_mask(ZFCP_STATUS_UNIT_NOTSUPPUNITRESET
,
469 retval
= zfcp_task_management_function(unit
,
470 FCP_LOGICAL_UNIT_RESET
,
473 ZFCP_LOG_DEBUG("unit reset failed (unit=%p)\n", unit
);
474 if (retval
== -ENOTSUPP
)
476 (ZFCP_STATUS_UNIT_NOTSUPPUNITRESET
,
478 /* fall through and try 'target reset' next */
480 ZFCP_LOG_DEBUG("unit reset succeeded (unit=%p)\n",
482 /* avoid 'target reset' */
487 retval
= zfcp_task_management_function(unit
, FCP_TARGET_RESET
, scpnt
);
489 ZFCP_LOG_DEBUG("target reset failed (unit=%p)\n", unit
);
492 ZFCP_LOG_DEBUG("target reset succeeded (unit=%p)\n", unit
);
500 zfcp_task_management_function(struct zfcp_unit
*unit
, u8 tm_flags
,
501 struct scsi_cmnd
*scpnt
)
503 struct zfcp_adapter
*adapter
= unit
->port
->adapter
;
504 struct zfcp_fsf_req
*fsf_req
;
507 /* issue task management function */
508 fsf_req
= zfcp_fsf_send_fcp_command_task_management
509 (adapter
, unit
, tm_flags
, 0);
511 ZFCP_LOG_INFO("error: creation of task management request "
512 "failed for unit 0x%016Lx on port 0x%016Lx on "
513 "adapter %s\n", unit
->fcp_lun
, unit
->port
->wwpn
,
514 zfcp_get_busid_by_adapter(adapter
));
515 zfcp_scsi_dbf_event_devreset("nres", tm_flags
, unit
, scpnt
);
520 __wait_event(fsf_req
->completion_wq
,
521 fsf_req
->status
& ZFCP_STATUS_FSFREQ_COMPLETED
);
524 * check completion status of task management function
526 if (fsf_req
->status
& ZFCP_STATUS_FSFREQ_TMFUNCFAILED
) {
527 zfcp_scsi_dbf_event_devreset("fail", tm_flags
, unit
, scpnt
);
529 } else if (fsf_req
->status
& ZFCP_STATUS_FSFREQ_TMFUNCNOTSUPP
) {
530 zfcp_scsi_dbf_event_devreset("nsup", tm_flags
, unit
, scpnt
);
533 zfcp_scsi_dbf_event_devreset("okay", tm_flags
, unit
, scpnt
);
535 zfcp_fsf_req_free(fsf_req
);
541 * zfcp_scsi_eh_host_reset_handler - handler for host and bus reset
543 int zfcp_scsi_eh_host_reset_handler(struct scsi_cmnd
*scpnt
)
545 struct zfcp_unit
*unit
;
546 struct zfcp_adapter
*adapter
;
548 unit
= (struct zfcp_unit
*) scpnt
->device
->hostdata
;
549 adapter
= unit
->port
->adapter
;
551 ZFCP_LOG_NORMAL("host/bus reset because of problems with "
552 "unit 0x%016Lx\n", unit
->fcp_lun
);
554 zfcp_erp_adapter_reopen(adapter
, 0);
555 zfcp_erp_wait(adapter
);
561 zfcp_adapter_scsi_register(struct zfcp_adapter
*adapter
)
564 static unsigned int unique_id
= 0;
566 /* register adapter as SCSI host with mid layer of SCSI stack */
567 adapter
->scsi_host
= scsi_host_alloc(&zfcp_data
.scsi_host_template
,
568 sizeof (struct zfcp_adapter
*));
569 if (!adapter
->scsi_host
) {
570 ZFCP_LOG_NORMAL("error: registration with SCSI stack failed "
572 zfcp_get_busid_by_adapter(adapter
));
576 ZFCP_LOG_DEBUG("host registered, scsi_host=%p\n", adapter
->scsi_host
);
578 /* tell the SCSI stack some characteristics of this adapter */
579 adapter
->scsi_host
->max_id
= 1;
580 adapter
->scsi_host
->max_lun
= 1;
581 adapter
->scsi_host
->max_channel
= 0;
582 adapter
->scsi_host
->unique_id
= unique_id
++; /* FIXME */
583 adapter
->scsi_host
->max_cmd_len
= ZFCP_MAX_SCSI_CMND_LENGTH
;
584 adapter
->scsi_host
->transportt
= zfcp_data
.scsi_transport_template
;
587 * save a pointer to our own adapter data structure within
588 * hostdata field of SCSI host data structure
590 adapter
->scsi_host
->hostdata
[0] = (unsigned long) adapter
;
592 if (scsi_add_host(adapter
->scsi_host
, &adapter
->ccw_device
->dev
)) {
593 scsi_host_put(adapter
->scsi_host
);
597 atomic_set_mask(ZFCP_STATUS_ADAPTER_REGISTERED
, &adapter
->status
);
603 zfcp_adapter_scsi_unregister(struct zfcp_adapter
*adapter
)
605 struct Scsi_Host
*shost
;
606 struct zfcp_port
*port
;
608 shost
= adapter
->scsi_host
;
611 read_lock_irq(&zfcp_data
.config_lock
);
612 list_for_each_entry(port
, &adapter
->port_list_head
, list
)
615 read_unlock_irq(&zfcp_data
.config_lock
);
616 fc_remove_host(shost
);
617 scsi_remove_host(shost
);
618 scsi_host_put(shost
);
619 adapter
->scsi_host
= NULL
;
620 atomic_clear_mask(ZFCP_STATUS_ADAPTER_REGISTERED
, &adapter
->status
);
626 * Support functions for FC transport class
628 static struct fc_host_statistics
*
629 zfcp_init_fc_host_stats(struct zfcp_adapter
*adapter
)
631 struct fc_host_statistics
*fc_stats
;
633 if (!adapter
->fc_stats
) {
634 fc_stats
= kmalloc(sizeof(*fc_stats
), GFP_KERNEL
);
637 adapter
->fc_stats
= fc_stats
; /* freed in adater_dequeue */
639 memset(adapter
->fc_stats
, 0, sizeof(*adapter
->fc_stats
));
640 return adapter
->fc_stats
;
644 zfcp_adjust_fc_host_stats(struct fc_host_statistics
*fc_stats
,
645 struct fsf_qtcb_bottom_port
*data
,
646 struct fsf_qtcb_bottom_port
*old
)
648 fc_stats
->seconds_since_last_reset
= data
->seconds_since_last_reset
-
649 old
->seconds_since_last_reset
;
650 fc_stats
->tx_frames
= data
->tx_frames
- old
->tx_frames
;
651 fc_stats
->tx_words
= data
->tx_words
- old
->tx_words
;
652 fc_stats
->rx_frames
= data
->rx_frames
- old
->rx_frames
;
653 fc_stats
->rx_words
= data
->rx_words
- old
->rx_words
;
654 fc_stats
->lip_count
= data
->lip
- old
->lip
;
655 fc_stats
->nos_count
= data
->nos
- old
->nos
;
656 fc_stats
->error_frames
= data
->error_frames
- old
->error_frames
;
657 fc_stats
->dumped_frames
= data
->dumped_frames
- old
->dumped_frames
;
658 fc_stats
->link_failure_count
= data
->link_failure
- old
->link_failure
;
659 fc_stats
->loss_of_sync_count
= data
->loss_of_sync
- old
->loss_of_sync
;
660 fc_stats
->loss_of_signal_count
= data
->loss_of_signal
-
662 fc_stats
->prim_seq_protocol_err_count
= data
->psp_error_counts
-
663 old
->psp_error_counts
;
664 fc_stats
->invalid_tx_word_count
= data
->invalid_tx_words
-
665 old
->invalid_tx_words
;
666 fc_stats
->invalid_crc_count
= data
->invalid_crcs
- old
->invalid_crcs
;
667 fc_stats
->fcp_input_requests
= data
->input_requests
-
669 fc_stats
->fcp_output_requests
= data
->output_requests
-
670 old
->output_requests
;
671 fc_stats
->fcp_control_requests
= data
->control_requests
-
672 old
->control_requests
;
673 fc_stats
->fcp_input_megabytes
= data
->input_mb
- old
->input_mb
;
674 fc_stats
->fcp_output_megabytes
= data
->output_mb
- old
->output_mb
;
678 zfcp_set_fc_host_stats(struct fc_host_statistics
*fc_stats
,
679 struct fsf_qtcb_bottom_port
*data
)
681 fc_stats
->seconds_since_last_reset
= data
->seconds_since_last_reset
;
682 fc_stats
->tx_frames
= data
->tx_frames
;
683 fc_stats
->tx_words
= data
->tx_words
;
684 fc_stats
->rx_frames
= data
->rx_frames
;
685 fc_stats
->rx_words
= data
->rx_words
;
686 fc_stats
->lip_count
= data
->lip
;
687 fc_stats
->nos_count
= data
->nos
;
688 fc_stats
->error_frames
= data
->error_frames
;
689 fc_stats
->dumped_frames
= data
->dumped_frames
;
690 fc_stats
->link_failure_count
= data
->link_failure
;
691 fc_stats
->loss_of_sync_count
= data
->loss_of_sync
;
692 fc_stats
->loss_of_signal_count
= data
->loss_of_signal
;
693 fc_stats
->prim_seq_protocol_err_count
= data
->psp_error_counts
;
694 fc_stats
->invalid_tx_word_count
= data
->invalid_tx_words
;
695 fc_stats
->invalid_crc_count
= data
->invalid_crcs
;
696 fc_stats
->fcp_input_requests
= data
->input_requests
;
697 fc_stats
->fcp_output_requests
= data
->output_requests
;
698 fc_stats
->fcp_control_requests
= data
->control_requests
;
699 fc_stats
->fcp_input_megabytes
= data
->input_mb
;
700 fc_stats
->fcp_output_megabytes
= data
->output_mb
;
704 * zfcp_get_fc_host_stats - provide fc_host_statistics for scsi_transport_fc
706 * assumption: scsi_transport_fc synchronizes calls of
707 * get_fc_host_stats and reset_fc_host_stats
708 * (XXX to be checked otherwise introduce locking)
710 static struct fc_host_statistics
*
711 zfcp_get_fc_host_stats(struct Scsi_Host
*shost
)
713 struct zfcp_adapter
*adapter
;
714 struct fc_host_statistics
*fc_stats
;
715 struct fsf_qtcb_bottom_port
*data
;
718 adapter
= (struct zfcp_adapter
*)shost
->hostdata
[0];
719 fc_stats
= zfcp_init_fc_host_stats(adapter
);
723 data
= kzalloc(sizeof(*data
), GFP_KERNEL
);
727 ret
= zfcp_fsf_exchange_port_data(NULL
, adapter
, data
);
730 return NULL
; /* XXX return zeroed fc_stats? */
733 if (adapter
->stats_reset
&&
734 ((jiffies
/HZ
- adapter
->stats_reset
) <
735 data
->seconds_since_last_reset
)) {
736 zfcp_adjust_fc_host_stats(fc_stats
, data
,
737 adapter
->stats_reset_data
);
739 zfcp_set_fc_host_stats(fc_stats
, data
);
746 zfcp_reset_fc_host_stats(struct Scsi_Host
*shost
)
748 struct zfcp_adapter
*adapter
;
749 struct fsf_qtcb_bottom_port
*data
, *old_data
;
752 adapter
= (struct zfcp_adapter
*)shost
->hostdata
[0];
753 data
= kzalloc(sizeof(*data
), GFP_KERNEL
);
757 ret
= zfcp_fsf_exchange_port_data(NULL
, adapter
, data
);
759 adapter
->stats_reset
= jiffies
/HZ
;
760 old_data
= adapter
->stats_reset_data
;
761 adapter
->stats_reset_data
= data
; /* finally freed in
767 static void zfcp_set_rport_dev_loss_tmo(struct fc_rport
*rport
, u32 timeout
)
769 rport
->dev_loss_tmo
= timeout
;
772 struct fc_function_template zfcp_transport_functions
= {
773 .show_starget_port_id
= 1,
774 .show_starget_port_name
= 1,
775 .show_starget_node_name
= 1,
776 .show_rport_supported_classes
= 1,
777 .show_rport_maxframe_size
= 1,
778 .show_rport_dev_loss_tmo
= 1,
779 .show_host_node_name
= 1,
780 .show_host_port_name
= 1,
781 .show_host_permanent_port_name
= 1,
782 .show_host_supported_classes
= 1,
783 .show_host_supported_speeds
= 1,
784 .show_host_maxframe_size
= 1,
785 .show_host_serial_number
= 1,
786 .get_fc_host_stats
= zfcp_get_fc_host_stats
,
787 .reset_fc_host_stats
= zfcp_reset_fc_host_stats
,
788 .set_rport_dev_loss_tmo
= zfcp_set_rport_dev_loss_tmo
,
789 /* no functions registered for following dynamic attributes but
790 directly set by LLDD */
791 .show_host_port_type
= 1,
792 .show_host_speed
= 1,
793 .show_host_port_id
= 1,
797 * ZFCP_DEFINE_SCSI_ATTR
798 * @_name: name of show attribute
799 * @_format: format string
800 * @_value: value to print
802 * Generates attribute for a unit.
804 #define ZFCP_DEFINE_SCSI_ATTR(_name, _format, _value) \
805 static ssize_t zfcp_sysfs_scsi_##_name##_show(struct device *dev, struct device_attribute *attr, \
808 struct scsi_device *sdev; \
809 struct zfcp_unit *unit; \
811 sdev = to_scsi_device(dev); \
812 unit = sdev->hostdata; \
813 return sprintf(buf, _format, _value); \
816 static DEVICE_ATTR(_name, S_IRUGO, zfcp_sysfs_scsi_##_name##_show, NULL);
818 ZFCP_DEFINE_SCSI_ATTR(hba_id
, "%s\n", zfcp_get_busid_by_unit(unit
));
819 ZFCP_DEFINE_SCSI_ATTR(wwpn
, "0x%016llx\n", unit
->port
->wwpn
);
820 ZFCP_DEFINE_SCSI_ATTR(fcp_lun
, "0x%016llx\n", unit
->fcp_lun
);
822 static struct device_attribute
*zfcp_sysfs_sdev_attrs
[] = {