4 * Debug traces for zfcp.
6 * Copyright IBM Corporation 2002, 2009
9 #define KMSG_COMPONENT "zfcp"
10 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
12 #include <linux/ctype.h>
13 #include <asm/debug.h>
17 static u32 dbfsize
= 4;
19 module_param(dbfsize
, uint
, 0400);
20 MODULE_PARM_DESC(dbfsize
,
21 "number of pages for each debug feature area (default 4)");
23 static void zfcp_dbf_hexdump(debug_info_t
*dbf
, void *to
, int to_len
,
24 int level
, char *from
, int from_len
)
27 struct zfcp_dbf_dump
*dump
= to
;
28 int room
= to_len
- sizeof(*dump
);
30 for (offset
= 0; offset
< from_len
; offset
+= dump
->size
) {
31 memset(to
, 0, to_len
);
32 strncpy(dump
->tag
, "dump", ZFCP_DBF_TAG_SIZE
);
33 dump
->total_size
= from_len
;
34 dump
->offset
= offset
;
35 dump
->size
= min(from_len
- offset
, room
);
36 memcpy(dump
->data
, from
+ offset
, dump
->size
);
37 debug_event(dbf
, level
, dump
, dump
->size
+ sizeof(*dump
));
41 /* FIXME: this duplicate this code in s390 debug feature */
42 static void zfcp_dbf_timestamp(unsigned long long stck
, struct timespec
*time
)
44 unsigned long long sec
;
46 stck
-= 0x8126d60e46000000LL
- (0x3c26700LL
* 1000000 * 4096);
50 stck
-= (sec
* 1000000) << 12;
51 time
->tv_nsec
= ((stck
* 1000) >> 12);
54 static void zfcp_dbf_tag(char **p
, const char *label
, const char *tag
)
58 *p
+= sprintf(*p
, "%-24s", label
);
59 for (i
= 0; i
< ZFCP_DBF_TAG_SIZE
; i
++)
60 *p
+= sprintf(*p
, "%c", tag
[i
]);
61 *p
+= sprintf(*p
, "\n");
64 static void zfcp_dbf_outs(char **buf
, const char *s1
, const char *s2
)
66 *buf
+= sprintf(*buf
, "%-24s%s\n", s1
, s2
);
69 static void zfcp_dbf_out(char **buf
, const char *s
, const char *format
, ...)
73 *buf
+= sprintf(*buf
, "%-24s", s
);
74 va_start(arg
, format
);
75 *buf
+= vsprintf(*buf
, format
, arg
);
77 *buf
+= sprintf(*buf
, "\n");
80 static void zfcp_dbf_outd(char **p
, const char *label
, char *buffer
,
81 int buflen
, int offset
, int total_size
)
84 *p
+= sprintf(*p
, "%-24s ", label
);
87 if ((offset
% 32) == 0)
88 *p
+= sprintf(*p
, "\n%-24c ", ' ');
89 else if ((offset
% 4) == 0)
90 *p
+= sprintf(*p
, " ");
92 *p
+= sprintf(*p
, "%02x", *buffer
++);
93 if (++offset
== total_size
) {
94 *p
+= sprintf(*p
, "\n");
99 *p
+= sprintf(*p
, "\n");
102 static int zfcp_dbf_view_header(debug_info_t
*id
, struct debug_view
*view
,
103 int area
, debug_entry_t
*entry
, char *out_buf
)
105 struct zfcp_dbf_dump
*dump
= (struct zfcp_dbf_dump
*)DEBUG_DATA(entry
);
109 if (strncmp(dump
->tag
, "dump", ZFCP_DBF_TAG_SIZE
) != 0) {
110 zfcp_dbf_timestamp(entry
->id
.stck
, &t
);
111 zfcp_dbf_out(&p
, "timestamp", "%011lu:%06lu",
112 t
.tv_sec
, t
.tv_nsec
);
113 zfcp_dbf_out(&p
, "cpu", "%02i", entry
->id
.fields
.cpuid
);
115 zfcp_dbf_outd(&p
, "", dump
->data
, dump
->size
, dump
->offset
,
117 if ((dump
->offset
+ dump
->size
) == dump
->total_size
)
118 p
+= sprintf(p
, "\n");
123 void _zfcp_hba_dbf_event_fsf_response(const char *tag2
, int level
,
124 struct zfcp_fsf_req
*fsf_req
,
125 struct zfcp_dbf
*dbf
)
127 struct fsf_qtcb
*qtcb
= fsf_req
->qtcb
;
128 union fsf_prot_status_qual
*prot_status_qual
=
129 &qtcb
->prefix
.prot_status_qual
;
130 union fsf_status_qual
*fsf_status_qual
= &qtcb
->header
.fsf_status_qual
;
131 struct scsi_cmnd
*scsi_cmnd
;
132 struct zfcp_port
*port
;
133 struct zfcp_unit
*unit
;
134 struct zfcp_send_els
*send_els
;
135 struct zfcp_hba_dbf_record
*rec
= &dbf
->hba_dbf_buf
;
136 struct zfcp_hba_dbf_record_response
*response
= &rec
->u
.response
;
139 spin_lock_irqsave(&dbf
->hba_dbf_lock
, flags
);
140 memset(rec
, 0, sizeof(*rec
));
141 strncpy(rec
->tag
, "resp", ZFCP_DBF_TAG_SIZE
);
142 strncpy(rec
->tag2
, tag2
, ZFCP_DBF_TAG_SIZE
);
144 response
->fsf_command
= fsf_req
->fsf_command
;
145 response
->fsf_reqid
= fsf_req
->req_id
;
146 response
->fsf_seqno
= fsf_req
->seq_no
;
147 response
->fsf_issued
= fsf_req
->issued
;
148 response
->fsf_prot_status
= qtcb
->prefix
.prot_status
;
149 response
->fsf_status
= qtcb
->header
.fsf_status
;
150 memcpy(response
->fsf_prot_status_qual
,
151 prot_status_qual
, FSF_PROT_STATUS_QUAL_SIZE
);
152 memcpy(response
->fsf_status_qual
,
153 fsf_status_qual
, FSF_STATUS_QUALIFIER_SIZE
);
154 response
->fsf_req_status
= fsf_req
->status
;
155 response
->sbal_first
= fsf_req
->queue_req
.sbal_first
;
156 response
->sbal_last
= fsf_req
->queue_req
.sbal_last
;
157 response
->sbal_response
= fsf_req
->queue_req
.sbal_response
;
158 response
->pool
= fsf_req
->pool
!= NULL
;
159 response
->erp_action
= (unsigned long)fsf_req
->erp_action
;
161 switch (fsf_req
->fsf_command
) {
162 case FSF_QTCB_FCP_CMND
:
163 if (fsf_req
->status
& ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT
)
165 scsi_cmnd
= (struct scsi_cmnd
*)fsf_req
->data
;
167 response
->u
.fcp
.cmnd
= (unsigned long)scsi_cmnd
;
168 response
->u
.fcp
.serial
= scsi_cmnd
->serial_number
;
172 case FSF_QTCB_OPEN_PORT_WITH_DID
:
173 case FSF_QTCB_CLOSE_PORT
:
174 case FSF_QTCB_CLOSE_PHYSICAL_PORT
:
175 port
= (struct zfcp_port
*)fsf_req
->data
;
176 response
->u
.port
.wwpn
= port
->wwpn
;
177 response
->u
.port
.d_id
= port
->d_id
;
178 response
->u
.port
.port_handle
= qtcb
->header
.port_handle
;
181 case FSF_QTCB_OPEN_LUN
:
182 case FSF_QTCB_CLOSE_LUN
:
183 unit
= (struct zfcp_unit
*)fsf_req
->data
;
185 response
->u
.unit
.wwpn
= port
->wwpn
;
186 response
->u
.unit
.fcp_lun
= unit
->fcp_lun
;
187 response
->u
.unit
.port_handle
= qtcb
->header
.port_handle
;
188 response
->u
.unit
.lun_handle
= qtcb
->header
.lun_handle
;
191 case FSF_QTCB_SEND_ELS
:
192 send_els
= (struct zfcp_send_els
*)fsf_req
->data
;
193 response
->u
.els
.d_id
= qtcb
->bottom
.support
.d_id
;
194 response
->u
.els
.ls_code
= send_els
->ls_code
>> 24;
197 case FSF_QTCB_ABORT_FCP_CMND
:
198 case FSF_QTCB_SEND_GENERIC
:
199 case FSF_QTCB_EXCHANGE_CONFIG_DATA
:
200 case FSF_QTCB_EXCHANGE_PORT_DATA
:
201 case FSF_QTCB_DOWNLOAD_CONTROL_FILE
:
202 case FSF_QTCB_UPLOAD_CONTROL_FILE
:
206 debug_event(dbf
->hba_dbf
, level
, rec
, sizeof(*rec
));
208 /* have fcp channel microcode fixed to use as little as possible */
209 if (fsf_req
->fsf_command
!= FSF_QTCB_FCP_CMND
) {
210 /* adjust length skipping trailing zeros */
211 char *buf
= (char *)qtcb
+ qtcb
->header
.log_start
;
212 int len
= qtcb
->header
.log_length
;
213 for (; len
&& !buf
[len
- 1]; len
--);
214 zfcp_dbf_hexdump(dbf
->hba_dbf
, rec
, sizeof(*rec
), level
, buf
,
218 spin_unlock_irqrestore(&dbf
->hba_dbf_lock
, flags
);
221 void _zfcp_hba_dbf_event_fsf_unsol(const char *tag
, int level
,
222 struct zfcp_adapter
*adapter
,
223 struct fsf_status_read_buffer
*status_buffer
)
225 struct zfcp_dbf
*dbf
= adapter
->dbf
;
226 struct zfcp_hba_dbf_record
*rec
= &dbf
->hba_dbf_buf
;
229 spin_lock_irqsave(&dbf
->hba_dbf_lock
, flags
);
230 memset(rec
, 0, sizeof(*rec
));
231 strncpy(rec
->tag
, "stat", ZFCP_DBF_TAG_SIZE
);
232 strncpy(rec
->tag2
, tag
, ZFCP_DBF_TAG_SIZE
);
234 rec
->u
.status
.failed
= atomic_read(&adapter
->stat_miss
);
235 if (status_buffer
!= NULL
) {
236 rec
->u
.status
.status_type
= status_buffer
->status_type
;
237 rec
->u
.status
.status_subtype
= status_buffer
->status_subtype
;
238 memcpy(&rec
->u
.status
.queue_designator
,
239 &status_buffer
->queue_designator
,
240 sizeof(struct fsf_queue_designator
));
242 switch (status_buffer
->status_type
) {
243 case FSF_STATUS_READ_SENSE_DATA_AVAIL
:
244 rec
->u
.status
.payload_size
=
245 ZFCP_DBF_UNSOL_PAYLOAD_SENSE_DATA_AVAIL
;
248 case FSF_STATUS_READ_BIT_ERROR_THRESHOLD
:
249 rec
->u
.status
.payload_size
=
250 ZFCP_DBF_UNSOL_PAYLOAD_BIT_ERROR_THRESHOLD
;
253 case FSF_STATUS_READ_LINK_DOWN
:
254 switch (status_buffer
->status_subtype
) {
255 case FSF_STATUS_READ_SUB_NO_PHYSICAL_LINK
:
256 case FSF_STATUS_READ_SUB_FDISC_FAILED
:
257 rec
->u
.status
.payload_size
=
258 sizeof(struct fsf_link_down_info
);
262 case FSF_STATUS_READ_FEATURE_UPDATE_ALERT
:
263 rec
->u
.status
.payload_size
=
264 ZFCP_DBF_UNSOL_PAYLOAD_FEATURE_UPDATE_ALERT
;
267 memcpy(&rec
->u
.status
.payload
,
268 &status_buffer
->payload
, rec
->u
.status
.payload_size
);
271 debug_event(dbf
->hba_dbf
, level
, rec
, sizeof(*rec
));
272 spin_unlock_irqrestore(&dbf
->hba_dbf_lock
, flags
);
276 * zfcp_hba_dbf_event_qdio - trace event for QDIO related failure
277 * @qdio: qdio structure affected by this QDIO related event
278 * @qdio_error: as passed by qdio module
279 * @sbal_index: first buffer with error condition, as passed by qdio module
280 * @sbal_count: number of buffers affected, as passed by qdio module
282 void zfcp_hba_dbf_event_qdio(struct zfcp_qdio
*qdio
,
283 unsigned int qdio_error
, int sbal_index
,
286 struct zfcp_dbf
*dbf
= qdio
->adapter
->dbf
;
287 struct zfcp_hba_dbf_record
*r
= &dbf
->hba_dbf_buf
;
290 spin_lock_irqsave(&dbf
->hba_dbf_lock
, flags
);
291 memset(r
, 0, sizeof(*r
));
292 strncpy(r
->tag
, "qdio", ZFCP_DBF_TAG_SIZE
);
293 r
->u
.qdio
.qdio_error
= qdio_error
;
294 r
->u
.qdio
.sbal_index
= sbal_index
;
295 r
->u
.qdio
.sbal_count
= sbal_count
;
296 debug_event(dbf
->hba_dbf
, 0, r
, sizeof(*r
));
297 spin_unlock_irqrestore(&dbf
->hba_dbf_lock
, flags
);
301 * zfcp_hba_dbf_event_berr - trace event for bit error threshold
302 * @adapter: adapter affected by this QDIO related event
305 void zfcp_hba_dbf_event_berr(struct zfcp_adapter
*adapter
,
306 struct zfcp_fsf_req
*req
)
308 struct zfcp_dbf
*dbf
= adapter
->dbf
;
309 struct zfcp_hba_dbf_record
*r
= &dbf
->hba_dbf_buf
;
310 struct fsf_status_read_buffer
*sr_buf
= req
->data
;
311 struct fsf_bit_error_payload
*err
= &sr_buf
->payload
.bit_error
;
314 spin_lock_irqsave(&dbf
->hba_dbf_lock
, flags
);
315 memset(r
, 0, sizeof(*r
));
316 strncpy(r
->tag
, "berr", ZFCP_DBF_TAG_SIZE
);
317 memcpy(&r
->u
.berr
, err
, sizeof(struct fsf_bit_error_payload
));
318 debug_event(dbf
->hba_dbf
, 0, r
, sizeof(*r
));
319 spin_unlock_irqrestore(&dbf
->hba_dbf_lock
, flags
);
321 static void zfcp_hba_dbf_view_response(char **p
,
322 struct zfcp_hba_dbf_record_response
*r
)
326 zfcp_dbf_out(p
, "fsf_command", "0x%08x", r
->fsf_command
);
327 zfcp_dbf_out(p
, "fsf_reqid", "0x%0Lx", r
->fsf_reqid
);
328 zfcp_dbf_out(p
, "fsf_seqno", "0x%08x", r
->fsf_seqno
);
329 zfcp_dbf_timestamp(r
->fsf_issued
, &t
);
330 zfcp_dbf_out(p
, "fsf_issued", "%011lu:%06lu", t
.tv_sec
, t
.tv_nsec
);
331 zfcp_dbf_out(p
, "fsf_prot_status", "0x%08x", r
->fsf_prot_status
);
332 zfcp_dbf_out(p
, "fsf_status", "0x%08x", r
->fsf_status
);
333 zfcp_dbf_outd(p
, "fsf_prot_status_qual", r
->fsf_prot_status_qual
,
334 FSF_PROT_STATUS_QUAL_SIZE
, 0, FSF_PROT_STATUS_QUAL_SIZE
);
335 zfcp_dbf_outd(p
, "fsf_status_qual", r
->fsf_status_qual
,
336 FSF_STATUS_QUALIFIER_SIZE
, 0, FSF_STATUS_QUALIFIER_SIZE
);
337 zfcp_dbf_out(p
, "fsf_req_status", "0x%08x", r
->fsf_req_status
);
338 zfcp_dbf_out(p
, "sbal_first", "0x%02x", r
->sbal_first
);
339 zfcp_dbf_out(p
, "sbal_last", "0x%02x", r
->sbal_last
);
340 zfcp_dbf_out(p
, "sbal_response", "0x%02x", r
->sbal_response
);
341 zfcp_dbf_out(p
, "pool", "0x%02x", r
->pool
);
343 switch (r
->fsf_command
) {
344 case FSF_QTCB_FCP_CMND
:
345 if (r
->fsf_req_status
& ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT
)
347 zfcp_dbf_out(p
, "scsi_cmnd", "0x%0Lx", r
->u
.fcp
.cmnd
);
348 zfcp_dbf_out(p
, "scsi_serial", "0x%016Lx", r
->u
.fcp
.serial
);
349 p
+= sprintf(*p
, "\n");
352 case FSF_QTCB_OPEN_PORT_WITH_DID
:
353 case FSF_QTCB_CLOSE_PORT
:
354 case FSF_QTCB_CLOSE_PHYSICAL_PORT
:
355 zfcp_dbf_out(p
, "wwpn", "0x%016Lx", r
->u
.port
.wwpn
);
356 zfcp_dbf_out(p
, "d_id", "0x%06x", r
->u
.port
.d_id
);
357 zfcp_dbf_out(p
, "port_handle", "0x%08x", r
->u
.port
.port_handle
);
360 case FSF_QTCB_OPEN_LUN
:
361 case FSF_QTCB_CLOSE_LUN
:
362 zfcp_dbf_out(p
, "wwpn", "0x%016Lx", r
->u
.unit
.wwpn
);
363 zfcp_dbf_out(p
, "fcp_lun", "0x%016Lx", r
->u
.unit
.fcp_lun
);
364 zfcp_dbf_out(p
, "port_handle", "0x%08x", r
->u
.unit
.port_handle
);
365 zfcp_dbf_out(p
, "lun_handle", "0x%08x", r
->u
.unit
.lun_handle
);
368 case FSF_QTCB_SEND_ELS
:
369 zfcp_dbf_out(p
, "d_id", "0x%06x", r
->u
.els
.d_id
);
370 zfcp_dbf_out(p
, "ls_code", "0x%02x", r
->u
.els
.ls_code
);
373 case FSF_QTCB_ABORT_FCP_CMND
:
374 case FSF_QTCB_SEND_GENERIC
:
375 case FSF_QTCB_EXCHANGE_CONFIG_DATA
:
376 case FSF_QTCB_EXCHANGE_PORT_DATA
:
377 case FSF_QTCB_DOWNLOAD_CONTROL_FILE
:
378 case FSF_QTCB_UPLOAD_CONTROL_FILE
:
383 static void zfcp_hba_dbf_view_status(char **p
,
384 struct zfcp_hba_dbf_record_status
*r
)
386 zfcp_dbf_out(p
, "failed", "0x%02x", r
->failed
);
387 zfcp_dbf_out(p
, "status_type", "0x%08x", r
->status_type
);
388 zfcp_dbf_out(p
, "status_subtype", "0x%08x", r
->status_subtype
);
389 zfcp_dbf_outd(p
, "queue_designator", (char *)&r
->queue_designator
,
390 sizeof(struct fsf_queue_designator
), 0,
391 sizeof(struct fsf_queue_designator
));
392 zfcp_dbf_outd(p
, "payload", (char *)&r
->payload
, r
->payload_size
, 0,
396 static void zfcp_hba_dbf_view_qdio(char **p
, struct zfcp_hba_dbf_record_qdio
*r
)
398 zfcp_dbf_out(p
, "qdio_error", "0x%08x", r
->qdio_error
);
399 zfcp_dbf_out(p
, "sbal_index", "0x%02x", r
->sbal_index
);
400 zfcp_dbf_out(p
, "sbal_count", "0x%02x", r
->sbal_count
);
403 static void zfcp_hba_dbf_view_berr(char **p
, struct fsf_bit_error_payload
*r
)
405 zfcp_dbf_out(p
, "link_failures", "%d", r
->link_failure_error_count
);
406 zfcp_dbf_out(p
, "loss_of_sync_err", "%d", r
->loss_of_sync_error_count
);
407 zfcp_dbf_out(p
, "loss_of_sig_err", "%d", r
->loss_of_signal_error_count
);
408 zfcp_dbf_out(p
, "prim_seq_err", "%d",
409 r
->primitive_sequence_error_count
);
410 zfcp_dbf_out(p
, "inval_trans_word_err", "%d",
411 r
->invalid_transmission_word_error_count
);
412 zfcp_dbf_out(p
, "CRC_errors", "%d", r
->crc_error_count
);
413 zfcp_dbf_out(p
, "prim_seq_event_to", "%d",
414 r
->primitive_sequence_event_timeout_count
);
415 zfcp_dbf_out(p
, "elast_buf_overrun_err", "%d",
416 r
->elastic_buffer_overrun_error_count
);
417 zfcp_dbf_out(p
, "adv_rec_buf2buf_cred", "%d",
418 r
->advertised_receive_b2b_credit
);
419 zfcp_dbf_out(p
, "curr_rec_buf2buf_cred", "%d",
420 r
->current_receive_b2b_credit
);
421 zfcp_dbf_out(p
, "adv_trans_buf2buf_cred", "%d",
422 r
->advertised_transmit_b2b_credit
);
423 zfcp_dbf_out(p
, "curr_trans_buf2buf_cred", "%d",
424 r
->current_transmit_b2b_credit
);
427 static int zfcp_hba_dbf_view_format(debug_info_t
*id
, struct debug_view
*view
,
428 char *out_buf
, const char *in_buf
)
430 struct zfcp_hba_dbf_record
*r
= (struct zfcp_hba_dbf_record
*)in_buf
;
433 if (strncmp(r
->tag
, "dump", ZFCP_DBF_TAG_SIZE
) == 0)
436 zfcp_dbf_tag(&p
, "tag", r
->tag
);
437 if (isalpha(r
->tag2
[0]))
438 zfcp_dbf_tag(&p
, "tag2", r
->tag2
);
440 if (strncmp(r
->tag
, "resp", ZFCP_DBF_TAG_SIZE
) == 0)
441 zfcp_hba_dbf_view_response(&p
, &r
->u
.response
);
442 else if (strncmp(r
->tag
, "stat", ZFCP_DBF_TAG_SIZE
) == 0)
443 zfcp_hba_dbf_view_status(&p
, &r
->u
.status
);
444 else if (strncmp(r
->tag
, "qdio", ZFCP_DBF_TAG_SIZE
) == 0)
445 zfcp_hba_dbf_view_qdio(&p
, &r
->u
.qdio
);
446 else if (strncmp(r
->tag
, "berr", ZFCP_DBF_TAG_SIZE
) == 0)
447 zfcp_hba_dbf_view_berr(&p
, &r
->u
.berr
);
449 if (strncmp(r
->tag
, "resp", ZFCP_DBF_TAG_SIZE
) != 0)
450 p
+= sprintf(p
, "\n");
454 static struct debug_view zfcp_hba_dbf_view
= {
457 &zfcp_dbf_view_header
,
458 &zfcp_hba_dbf_view_format
,
463 static const char *zfcp_rec_dbf_tags
[] = {
464 [ZFCP_REC_DBF_ID_THREAD
] = "thread",
465 [ZFCP_REC_DBF_ID_TARGET
] = "target",
466 [ZFCP_REC_DBF_ID_TRIGGER
] = "trigger",
467 [ZFCP_REC_DBF_ID_ACTION
] = "action",
470 static int zfcp_rec_dbf_view_format(debug_info_t
*id
, struct debug_view
*view
,
471 char *buf
, const char *_rec
)
473 struct zfcp_rec_dbf_record
*r
= (struct zfcp_rec_dbf_record
*)_rec
;
475 char hint
[ZFCP_DBF_ID_SIZE
+ 1];
477 memcpy(hint
, r
->id2
, ZFCP_DBF_ID_SIZE
);
478 hint
[ZFCP_DBF_ID_SIZE
] = 0;
479 zfcp_dbf_outs(&p
, "tag", zfcp_rec_dbf_tags
[r
->id
]);
480 zfcp_dbf_outs(&p
, "hint", hint
);
482 case ZFCP_REC_DBF_ID_THREAD
:
483 zfcp_dbf_out(&p
, "total", "%d", r
->u
.thread
.total
);
484 zfcp_dbf_out(&p
, "ready", "%d", r
->u
.thread
.ready
);
485 zfcp_dbf_out(&p
, "running", "%d", r
->u
.thread
.running
);
487 case ZFCP_REC_DBF_ID_TARGET
:
488 zfcp_dbf_out(&p
, "reference", "0x%016Lx", r
->u
.target
.ref
);
489 zfcp_dbf_out(&p
, "status", "0x%08x", r
->u
.target
.status
);
490 zfcp_dbf_out(&p
, "erp_count", "%d", r
->u
.target
.erp_count
);
491 zfcp_dbf_out(&p
, "d_id", "0x%06x", r
->u
.target
.d_id
);
492 zfcp_dbf_out(&p
, "wwpn", "0x%016Lx", r
->u
.target
.wwpn
);
493 zfcp_dbf_out(&p
, "fcp_lun", "0x%016Lx", r
->u
.target
.fcp_lun
);
495 case ZFCP_REC_DBF_ID_TRIGGER
:
496 zfcp_dbf_out(&p
, "reference", "0x%016Lx", r
->u
.trigger
.ref
);
497 zfcp_dbf_out(&p
, "erp_action", "0x%016Lx", r
->u
.trigger
.action
);
498 zfcp_dbf_out(&p
, "requested", "%d", r
->u
.trigger
.want
);
499 zfcp_dbf_out(&p
, "executed", "%d", r
->u
.trigger
.need
);
500 zfcp_dbf_out(&p
, "wwpn", "0x%016Lx", r
->u
.trigger
.wwpn
);
501 zfcp_dbf_out(&p
, "fcp_lun", "0x%016Lx", r
->u
.trigger
.fcp_lun
);
502 zfcp_dbf_out(&p
, "adapter_status", "0x%08x", r
->u
.trigger
.as
);
503 zfcp_dbf_out(&p
, "port_status", "0x%08x", r
->u
.trigger
.ps
);
504 zfcp_dbf_out(&p
, "unit_status", "0x%08x", r
->u
.trigger
.us
);
506 case ZFCP_REC_DBF_ID_ACTION
:
507 zfcp_dbf_out(&p
, "erp_action", "0x%016Lx", r
->u
.action
.action
);
508 zfcp_dbf_out(&p
, "fsf_req", "0x%016Lx", r
->u
.action
.fsf_req
);
509 zfcp_dbf_out(&p
, "status", "0x%08Lx", r
->u
.action
.status
);
510 zfcp_dbf_out(&p
, "step", "0x%08Lx", r
->u
.action
.step
);
513 p
+= sprintf(p
, "\n");
517 static struct debug_view zfcp_rec_dbf_view
= {
520 &zfcp_dbf_view_header
,
521 &zfcp_rec_dbf_view_format
,
527 * zfcp_rec_dbf_event_thread - trace event related to recovery thread operation
528 * @id2: identifier for event
530 * This function assumes that the caller is holding erp_lock.
532 void zfcp_rec_dbf_event_thread(char *id2
, struct zfcp_adapter
*adapter
)
534 struct zfcp_dbf
*dbf
= adapter
->dbf
;
535 struct zfcp_rec_dbf_record
*r
= &dbf
->rec_dbf_buf
;
536 unsigned long flags
= 0;
537 struct list_head
*entry
;
538 unsigned ready
= 0, running
= 0, total
;
540 list_for_each(entry
, &adapter
->erp_ready_head
)
542 list_for_each(entry
, &adapter
->erp_running_head
)
544 total
= adapter
->erp_total_count
;
546 spin_lock_irqsave(&dbf
->rec_dbf_lock
, flags
);
547 memset(r
, 0, sizeof(*r
));
548 r
->id
= ZFCP_REC_DBF_ID_THREAD
;
549 memcpy(r
->id2
, id2
, ZFCP_DBF_ID_SIZE
);
550 r
->u
.thread
.total
= total
;
551 r
->u
.thread
.ready
= ready
;
552 r
->u
.thread
.running
= running
;
553 debug_event(dbf
->rec_dbf
, 6, r
, sizeof(*r
));
554 spin_unlock_irqrestore(&dbf
->rec_dbf_lock
, flags
);
558 * zfcp_rec_dbf_event_thread - trace event related to recovery thread operation
559 * @id2: identifier for event
561 * This function assumes that the caller does not hold erp_lock.
563 void zfcp_rec_dbf_event_thread_lock(char *id2
, struct zfcp_adapter
*adapter
)
567 read_lock_irqsave(&adapter
->erp_lock
, flags
);
568 zfcp_rec_dbf_event_thread(id2
, adapter
);
569 read_unlock_irqrestore(&adapter
->erp_lock
, flags
);
572 static void zfcp_rec_dbf_event_target(char *id2
, void *ref
,
573 struct zfcp_adapter
*adapter
,
574 atomic_t
*status
, atomic_t
*erp_count
,
575 u64 wwpn
, u32 d_id
, u64 fcp_lun
)
577 struct zfcp_dbf
*dbf
= adapter
->dbf
;
578 struct zfcp_rec_dbf_record
*r
= &dbf
->rec_dbf_buf
;
581 spin_lock_irqsave(&dbf
->rec_dbf_lock
, flags
);
582 memset(r
, 0, sizeof(*r
));
583 r
->id
= ZFCP_REC_DBF_ID_TARGET
;
584 memcpy(r
->id2
, id2
, ZFCP_DBF_ID_SIZE
);
585 r
->u
.target
.ref
= (unsigned long)ref
;
586 r
->u
.target
.status
= atomic_read(status
);
587 r
->u
.target
.wwpn
= wwpn
;
588 r
->u
.target
.d_id
= d_id
;
589 r
->u
.target
.fcp_lun
= fcp_lun
;
590 r
->u
.target
.erp_count
= atomic_read(erp_count
);
591 debug_event(dbf
->rec_dbf
, 3, r
, sizeof(*r
));
592 spin_unlock_irqrestore(&dbf
->rec_dbf_lock
, flags
);
596 * zfcp_rec_dbf_event_adapter - trace event for adapter state change
597 * @id: identifier for trigger of state change
598 * @ref: additional reference (e.g. request)
601 void zfcp_rec_dbf_event_adapter(char *id
, void *ref
,
602 struct zfcp_adapter
*adapter
)
604 zfcp_rec_dbf_event_target(id
, ref
, adapter
, &adapter
->status
,
605 &adapter
->erp_counter
, 0, 0, 0);
609 * zfcp_rec_dbf_event_port - trace event for port state change
610 * @id: identifier for trigger of state change
611 * @ref: additional reference (e.g. request)
614 void zfcp_rec_dbf_event_port(char *id
, void *ref
, struct zfcp_port
*port
)
616 struct zfcp_adapter
*adapter
= port
->adapter
;
618 zfcp_rec_dbf_event_target(id
, ref
, adapter
, &port
->status
,
619 &port
->erp_counter
, port
->wwpn
, port
->d_id
,
624 * zfcp_rec_dbf_event_unit - trace event for unit state change
625 * @id: identifier for trigger of state change
626 * @ref: additional reference (e.g. request)
629 void zfcp_rec_dbf_event_unit(char *id
, void *ref
, struct zfcp_unit
*unit
)
631 struct zfcp_port
*port
= unit
->port
;
632 struct zfcp_adapter
*adapter
= port
->adapter
;
634 zfcp_rec_dbf_event_target(id
, ref
, adapter
, &unit
->status
,
635 &unit
->erp_counter
, port
->wwpn
, port
->d_id
,
640 * zfcp_rec_dbf_event_trigger - trace event for triggered error recovery
641 * @id2: identifier for error recovery trigger
642 * @ref: additional reference (e.g. request)
643 * @want: originally requested error recovery action
644 * @need: error recovery action actually initiated
645 * @action: address of error recovery action struct
650 void zfcp_rec_dbf_event_trigger(char *id2
, void *ref
, u8 want
, u8 need
,
651 void *action
, struct zfcp_adapter
*adapter
,
652 struct zfcp_port
*port
, struct zfcp_unit
*unit
)
654 struct zfcp_dbf
*dbf
= adapter
->dbf
;
655 struct zfcp_rec_dbf_record
*r
= &dbf
->rec_dbf_buf
;
658 spin_lock_irqsave(&dbf
->rec_dbf_lock
, flags
);
659 memset(r
, 0, sizeof(*r
));
660 r
->id
= ZFCP_REC_DBF_ID_TRIGGER
;
661 memcpy(r
->id2
, id2
, ZFCP_DBF_ID_SIZE
);
662 r
->u
.trigger
.ref
= (unsigned long)ref
;
663 r
->u
.trigger
.want
= want
;
664 r
->u
.trigger
.need
= need
;
665 r
->u
.trigger
.action
= (unsigned long)action
;
666 r
->u
.trigger
.as
= atomic_read(&adapter
->status
);
668 r
->u
.trigger
.ps
= atomic_read(&port
->status
);
669 r
->u
.trigger
.wwpn
= port
->wwpn
;
672 r
->u
.trigger
.us
= atomic_read(&unit
->status
);
673 r
->u
.trigger
.fcp_lun
= unit
->fcp_lun
;
675 debug_event(dbf
->rec_dbf
, action
? 1 : 4, r
, sizeof(*r
));
676 spin_unlock_irqrestore(&dbf
->rec_dbf_lock
, flags
);
680 * zfcp_rec_dbf_event_action - trace event showing progress of recovery action
682 * @erp_action: error recovery action struct pointer
684 void zfcp_rec_dbf_event_action(char *id2
, struct zfcp_erp_action
*erp_action
)
686 struct zfcp_adapter
*adapter
= erp_action
->adapter
;
687 struct zfcp_dbf
*dbf
= adapter
->dbf
;
688 struct zfcp_rec_dbf_record
*r
= &dbf
->rec_dbf_buf
;
691 spin_lock_irqsave(&dbf
->rec_dbf_lock
, flags
);
692 memset(r
, 0, sizeof(*r
));
693 r
->id
= ZFCP_REC_DBF_ID_ACTION
;
694 memcpy(r
->id2
, id2
, ZFCP_DBF_ID_SIZE
);
695 r
->u
.action
.action
= (unsigned long)erp_action
;
696 r
->u
.action
.status
= erp_action
->status
;
697 r
->u
.action
.step
= erp_action
->step
;
698 r
->u
.action
.fsf_req
= (unsigned long)erp_action
->fsf_req
;
699 debug_event(dbf
->rec_dbf
, 5, r
, sizeof(*r
));
700 spin_unlock_irqrestore(&dbf
->rec_dbf_lock
, flags
);
704 * zfcp_san_dbf_event_ct_request - trace event for issued CT request
705 * @fsf_req: request containing issued CT data
707 void zfcp_san_dbf_event_ct_request(struct zfcp_fsf_req
*fsf_req
)
709 struct zfcp_send_ct
*ct
= (struct zfcp_send_ct
*)fsf_req
->data
;
710 struct zfcp_wka_port
*wka_port
= ct
->wka_port
;
711 struct zfcp_adapter
*adapter
= wka_port
->adapter
;
712 struct zfcp_dbf
*dbf
= adapter
->dbf
;
713 struct ct_hdr
*hdr
= sg_virt(ct
->req
);
714 struct zfcp_san_dbf_record
*r
= &dbf
->san_dbf_buf
;
715 struct zfcp_san_dbf_record_ct_request
*oct
= &r
->u
.ct_req
;
719 spin_lock_irqsave(&dbf
->san_dbf_lock
, flags
);
720 memset(r
, 0, sizeof(*r
));
721 strncpy(r
->tag
, "octc", ZFCP_DBF_TAG_SIZE
);
722 r
->fsf_reqid
= fsf_req
->req_id
;
723 r
->fsf_seqno
= fsf_req
->seq_no
;
724 r
->s_id
= fc_host_port_id(adapter
->scsi_host
);
725 r
->d_id
= wka_port
->d_id
;
726 oct
->cmd_req_code
= hdr
->cmd_rsp_code
;
727 oct
->revision
= hdr
->revision
;
728 oct
->gs_type
= hdr
->gs_type
;
729 oct
->gs_subtype
= hdr
->gs_subtype
;
730 oct
->options
= hdr
->options
;
731 oct
->max_res_size
= hdr
->max_res_size
;
732 oct
->len
= min((int)ct
->req
->length
- (int)sizeof(struct ct_hdr
),
733 ZFCP_DBF_SAN_MAX_PAYLOAD
);
734 debug_event(dbf
->san_dbf
, level
, r
, sizeof(*r
));
735 zfcp_dbf_hexdump(dbf
->san_dbf
, r
, sizeof(*r
), level
,
736 (void *)hdr
+ sizeof(struct ct_hdr
), oct
->len
);
737 spin_unlock_irqrestore(&dbf
->san_dbf_lock
, flags
);
741 * zfcp_san_dbf_event_ct_response - trace event for completion of CT request
742 * @fsf_req: request containing CT response
744 void zfcp_san_dbf_event_ct_response(struct zfcp_fsf_req
*fsf_req
)
746 struct zfcp_send_ct
*ct
= (struct zfcp_send_ct
*)fsf_req
->data
;
747 struct zfcp_wka_port
*wka_port
= ct
->wka_port
;
748 struct zfcp_adapter
*adapter
= wka_port
->adapter
;
749 struct ct_hdr
*hdr
= sg_virt(ct
->resp
);
750 struct zfcp_dbf
*dbf
= adapter
->dbf
;
751 struct zfcp_san_dbf_record
*r
= &dbf
->san_dbf_buf
;
752 struct zfcp_san_dbf_record_ct_response
*rct
= &r
->u
.ct_resp
;
756 spin_lock_irqsave(&dbf
->san_dbf_lock
, flags
);
757 memset(r
, 0, sizeof(*r
));
758 strncpy(r
->tag
, "rctc", ZFCP_DBF_TAG_SIZE
);
759 r
->fsf_reqid
= fsf_req
->req_id
;
760 r
->fsf_seqno
= fsf_req
->seq_no
;
761 r
->s_id
= wka_port
->d_id
;
762 r
->d_id
= fc_host_port_id(adapter
->scsi_host
);
763 rct
->cmd_rsp_code
= hdr
->cmd_rsp_code
;
764 rct
->revision
= hdr
->revision
;
765 rct
->reason_code
= hdr
->reason_code
;
766 rct
->expl
= hdr
->reason_code_expl
;
767 rct
->vendor_unique
= hdr
->vendor_unique
;
768 rct
->max_res_size
= hdr
->max_res_size
;
769 rct
->len
= min((int)ct
->resp
->length
- (int)sizeof(struct ct_hdr
),
770 ZFCP_DBF_SAN_MAX_PAYLOAD
);
771 debug_event(dbf
->san_dbf
, level
, r
, sizeof(*r
));
772 zfcp_dbf_hexdump(dbf
->san_dbf
, r
, sizeof(*r
), level
,
773 (void *)hdr
+ sizeof(struct ct_hdr
), rct
->len
);
774 spin_unlock_irqrestore(&dbf
->san_dbf_lock
, flags
);
777 static void zfcp_san_dbf_event_els(const char *tag
, int level
,
778 struct zfcp_fsf_req
*fsf_req
, u32 s_id
,
779 u32 d_id
, u8 ls_code
, void *buffer
,
782 struct zfcp_adapter
*adapter
= fsf_req
->adapter
;
783 struct zfcp_dbf
*dbf
= adapter
->dbf
;
784 struct zfcp_san_dbf_record
*rec
= &dbf
->san_dbf_buf
;
787 spin_lock_irqsave(&dbf
->san_dbf_lock
, flags
);
788 memset(rec
, 0, sizeof(*rec
));
789 strncpy(rec
->tag
, tag
, ZFCP_DBF_TAG_SIZE
);
790 rec
->fsf_reqid
= fsf_req
->req_id
;
791 rec
->fsf_seqno
= fsf_req
->seq_no
;
794 rec
->u
.els
.ls_code
= ls_code
;
795 debug_event(dbf
->san_dbf
, level
, rec
, sizeof(*rec
));
796 zfcp_dbf_hexdump(dbf
->san_dbf
, rec
, sizeof(*rec
), level
,
797 buffer
, min(buflen
, ZFCP_DBF_SAN_MAX_PAYLOAD
));
798 spin_unlock_irqrestore(&dbf
->san_dbf_lock
, flags
);
802 * zfcp_san_dbf_event_els_request - trace event for issued ELS
803 * @fsf_req: request containing issued ELS
805 void zfcp_san_dbf_event_els_request(struct zfcp_fsf_req
*fsf_req
)
807 struct zfcp_send_els
*els
= (struct zfcp_send_els
*)fsf_req
->data
;
809 zfcp_san_dbf_event_els("oels", 2, fsf_req
,
810 fc_host_port_id(els
->adapter
->scsi_host
),
811 els
->d_id
, *(u8
*) sg_virt(els
->req
),
812 sg_virt(els
->req
), els
->req
->length
);
816 * zfcp_san_dbf_event_els_response - trace event for completed ELS
817 * @fsf_req: request containing ELS response
819 void zfcp_san_dbf_event_els_response(struct zfcp_fsf_req
*fsf_req
)
821 struct zfcp_send_els
*els
= (struct zfcp_send_els
*)fsf_req
->data
;
823 zfcp_san_dbf_event_els("rels", 2, fsf_req
, els
->d_id
,
824 fc_host_port_id(els
->adapter
->scsi_host
),
825 *(u8
*)sg_virt(els
->req
), sg_virt(els
->resp
),
830 * zfcp_san_dbf_event_incoming_els - trace event for incomig ELS
831 * @fsf_req: request containing unsolicited status buffer with incoming ELS
833 void zfcp_san_dbf_event_incoming_els(struct zfcp_fsf_req
*fsf_req
)
835 struct zfcp_adapter
*adapter
= fsf_req
->adapter
;
836 struct fsf_status_read_buffer
*buf
=
837 (struct fsf_status_read_buffer
*)fsf_req
->data
;
838 int length
= (int)buf
->length
-
839 (int)((void *)&buf
->payload
- (void *)buf
);
841 zfcp_san_dbf_event_els("iels", 1, fsf_req
, buf
->d_id
,
842 fc_host_port_id(adapter
->scsi_host
),
843 buf
->payload
.data
[0], (void *)buf
->payload
.data
,
847 static int zfcp_san_dbf_view_format(debug_info_t
*id
, struct debug_view
*view
,
848 char *out_buf
, const char *in_buf
)
850 struct zfcp_san_dbf_record
*r
= (struct zfcp_san_dbf_record
*)in_buf
;
853 if (strncmp(r
->tag
, "dump", ZFCP_DBF_TAG_SIZE
) == 0)
856 zfcp_dbf_tag(&p
, "tag", r
->tag
);
857 zfcp_dbf_out(&p
, "fsf_reqid", "0x%0Lx", r
->fsf_reqid
);
858 zfcp_dbf_out(&p
, "fsf_seqno", "0x%08x", r
->fsf_seqno
);
859 zfcp_dbf_out(&p
, "s_id", "0x%06x", r
->s_id
);
860 zfcp_dbf_out(&p
, "d_id", "0x%06x", r
->d_id
);
862 if (strncmp(r
->tag
, "octc", ZFCP_DBF_TAG_SIZE
) == 0) {
863 struct zfcp_san_dbf_record_ct_request
*ct
= &r
->u
.ct_req
;
864 zfcp_dbf_out(&p
, "cmd_req_code", "0x%04x", ct
->cmd_req_code
);
865 zfcp_dbf_out(&p
, "revision", "0x%02x", ct
->revision
);
866 zfcp_dbf_out(&p
, "gs_type", "0x%02x", ct
->gs_type
);
867 zfcp_dbf_out(&p
, "gs_subtype", "0x%02x", ct
->gs_subtype
);
868 zfcp_dbf_out(&p
, "options", "0x%02x", ct
->options
);
869 zfcp_dbf_out(&p
, "max_res_size", "0x%04x", ct
->max_res_size
);
870 } else if (strncmp(r
->tag
, "rctc", ZFCP_DBF_TAG_SIZE
) == 0) {
871 struct zfcp_san_dbf_record_ct_response
*ct
= &r
->u
.ct_resp
;
872 zfcp_dbf_out(&p
, "cmd_rsp_code", "0x%04x", ct
->cmd_rsp_code
);
873 zfcp_dbf_out(&p
, "revision", "0x%02x", ct
->revision
);
874 zfcp_dbf_out(&p
, "reason_code", "0x%02x", ct
->reason_code
);
875 zfcp_dbf_out(&p
, "reason_code_expl", "0x%02x", ct
->expl
);
876 zfcp_dbf_out(&p
, "vendor_unique", "0x%02x", ct
->vendor_unique
);
877 zfcp_dbf_out(&p
, "max_res_size", "0x%04x", ct
->max_res_size
);
878 } else if (strncmp(r
->tag
, "oels", ZFCP_DBF_TAG_SIZE
) == 0 ||
879 strncmp(r
->tag
, "rels", ZFCP_DBF_TAG_SIZE
) == 0 ||
880 strncmp(r
->tag
, "iels", ZFCP_DBF_TAG_SIZE
) == 0) {
881 struct zfcp_san_dbf_record_els
*els
= &r
->u
.els
;
882 zfcp_dbf_out(&p
, "ls_code", "0x%02x", els
->ls_code
);
887 static struct debug_view zfcp_san_dbf_view
= {
890 &zfcp_dbf_view_header
,
891 &zfcp_san_dbf_view_format
,
896 void _zfcp_scsi_dbf_event(const char *tag
, const char *tag2
, int level
,
897 struct zfcp_dbf
*dbf
, struct scsi_cmnd
*scsi_cmnd
,
898 struct zfcp_fsf_req
*fsf_req
,
899 unsigned long old_req_id
)
901 struct zfcp_scsi_dbf_record
*rec
= &dbf
->scsi_dbf_buf
;
902 struct zfcp_dbf_dump
*dump
= (struct zfcp_dbf_dump
*)rec
;
904 struct fcp_rsp_iu
*fcp_rsp
;
905 char *fcp_rsp_info
= NULL
, *fcp_sns_info
= NULL
;
906 int offset
= 0, buflen
= 0;
908 spin_lock_irqsave(&dbf
->scsi_dbf_lock
, flags
);
910 memset(rec
, 0, sizeof(*rec
));
912 strncpy(rec
->tag
, tag
, ZFCP_DBF_TAG_SIZE
);
913 strncpy(rec
->tag2
, tag2
, ZFCP_DBF_TAG_SIZE
);
914 if (scsi_cmnd
!= NULL
) {
915 if (scsi_cmnd
->device
) {
916 rec
->scsi_id
= scsi_cmnd
->device
->id
;
917 rec
->scsi_lun
= scsi_cmnd
->device
->lun
;
919 rec
->scsi_result
= scsi_cmnd
->result
;
920 rec
->scsi_cmnd
= (unsigned long)scsi_cmnd
;
921 rec
->scsi_serial
= scsi_cmnd
->serial_number
;
922 memcpy(rec
->scsi_opcode
, scsi_cmnd
->cmnd
,
923 min((int)scsi_cmnd
->cmd_len
,
924 ZFCP_DBF_SCSI_OPCODE
));
925 rec
->scsi_retries
= scsi_cmnd
->retries
;
926 rec
->scsi_allowed
= scsi_cmnd
->allowed
;
928 if (fsf_req
!= NULL
) {
929 fcp_rsp
= (struct fcp_rsp_iu
*)
930 &(fsf_req
->qtcb
->bottom
.io
.fcp_rsp
);
931 fcp_rsp_info
= (unsigned char *) &fcp_rsp
[1];
933 zfcp_get_fcp_sns_info_ptr(fcp_rsp
);
935 rec
->rsp_validity
= fcp_rsp
->validity
.value
;
936 rec
->rsp_scsi_status
= fcp_rsp
->scsi_status
;
937 rec
->rsp_resid
= fcp_rsp
->fcp_resid
;
938 if (fcp_rsp
->validity
.bits
.fcp_rsp_len_valid
)
939 rec
->rsp_code
= *(fcp_rsp_info
+ 3);
940 if (fcp_rsp
->validity
.bits
.fcp_sns_len_valid
) {
941 buflen
= min((int)fcp_rsp
->fcp_sns_len
,
942 ZFCP_DBF_SCSI_MAX_FCP_SNS_INFO
);
943 rec
->sns_info_len
= buflen
;
944 memcpy(rec
->sns_info
, fcp_sns_info
,
946 ZFCP_DBF_SCSI_FCP_SNS_INFO
));
947 offset
+= min(buflen
,
948 ZFCP_DBF_SCSI_FCP_SNS_INFO
);
951 rec
->fsf_reqid
= fsf_req
->req_id
;
952 rec
->fsf_seqno
= fsf_req
->seq_no
;
953 rec
->fsf_issued
= fsf_req
->issued
;
955 rec
->old_fsf_reqid
= old_req_id
;
957 strncpy(dump
->tag
, "dump", ZFCP_DBF_TAG_SIZE
);
958 dump
->total_size
= buflen
;
959 dump
->offset
= offset
;
960 dump
->size
= min(buflen
- offset
,
962 zfcp_scsi_dbf_record
) -
963 (int)sizeof(struct zfcp_dbf_dump
));
964 memcpy(dump
->data
, fcp_sns_info
+ offset
, dump
->size
);
965 offset
+= dump
->size
;
967 debug_event(dbf
->scsi_dbf
, level
, rec
, sizeof(*rec
));
968 } while (offset
< buflen
);
969 spin_unlock_irqrestore(&dbf
->scsi_dbf_lock
, flags
);
972 static int zfcp_scsi_dbf_view_format(debug_info_t
*id
, struct debug_view
*view
,
973 char *out_buf
, const char *in_buf
)
975 struct zfcp_scsi_dbf_record
*r
= (struct zfcp_scsi_dbf_record
*)in_buf
;
979 if (strncmp(r
->tag
, "dump", ZFCP_DBF_TAG_SIZE
) == 0)
982 zfcp_dbf_tag(&p
, "tag", r
->tag
);
983 zfcp_dbf_tag(&p
, "tag2", r
->tag2
);
984 zfcp_dbf_out(&p
, "scsi_id", "0x%08x", r
->scsi_id
);
985 zfcp_dbf_out(&p
, "scsi_lun", "0x%08x", r
->scsi_lun
);
986 zfcp_dbf_out(&p
, "scsi_result", "0x%08x", r
->scsi_result
);
987 zfcp_dbf_out(&p
, "scsi_cmnd", "0x%0Lx", r
->scsi_cmnd
);
988 zfcp_dbf_out(&p
, "scsi_serial", "0x%016Lx", r
->scsi_serial
);
989 zfcp_dbf_outd(&p
, "scsi_opcode", r
->scsi_opcode
, ZFCP_DBF_SCSI_OPCODE
,
990 0, ZFCP_DBF_SCSI_OPCODE
);
991 zfcp_dbf_out(&p
, "scsi_retries", "0x%02x", r
->scsi_retries
);
992 zfcp_dbf_out(&p
, "scsi_allowed", "0x%02x", r
->scsi_allowed
);
993 if (strncmp(r
->tag
, "abrt", ZFCP_DBF_TAG_SIZE
) == 0)
994 zfcp_dbf_out(&p
, "old_fsf_reqid", "0x%0Lx", r
->old_fsf_reqid
);
995 zfcp_dbf_out(&p
, "fsf_reqid", "0x%0Lx", r
->fsf_reqid
);
996 zfcp_dbf_out(&p
, "fsf_seqno", "0x%08x", r
->fsf_seqno
);
997 zfcp_dbf_timestamp(r
->fsf_issued
, &t
);
998 zfcp_dbf_out(&p
, "fsf_issued", "%011lu:%06lu", t
.tv_sec
, t
.tv_nsec
);
1000 if (strncmp(r
->tag
, "rslt", ZFCP_DBF_TAG_SIZE
) == 0) {
1001 zfcp_dbf_out(&p
, "fcp_rsp_validity", "0x%02x", r
->rsp_validity
);
1002 zfcp_dbf_out(&p
, "fcp_rsp_scsi_status", "0x%02x",
1003 r
->rsp_scsi_status
);
1004 zfcp_dbf_out(&p
, "fcp_rsp_resid", "0x%08x", r
->rsp_resid
);
1005 zfcp_dbf_out(&p
, "fcp_rsp_code", "0x%08x", r
->rsp_code
);
1006 zfcp_dbf_out(&p
, "fcp_sns_info_len", "0x%08x", r
->sns_info_len
);
1007 zfcp_dbf_outd(&p
, "fcp_sns_info", r
->sns_info
,
1008 min((int)r
->sns_info_len
,
1009 ZFCP_DBF_SCSI_FCP_SNS_INFO
), 0,
1012 p
+= sprintf(p
, "\n");
1016 static struct debug_view zfcp_scsi_dbf_view
= {
1019 &zfcp_dbf_view_header
,
1020 &zfcp_scsi_dbf_view_format
,
1025 static debug_info_t
*zfcp_dbf_reg(const char *name
, int level
,
1026 struct debug_view
*view
, int size
)
1028 struct debug_info
*d
;
1030 d
= debug_register(name
, dbfsize
, level
, size
);
1034 debug_register_view(d
, &debug_hex_ascii_view
);
1035 debug_register_view(d
, view
);
1036 debug_set_level(d
, level
);
1042 * zfcp_adapter_debug_register - registers debug feature for an adapter
1043 * @adapter: pointer to adapter for which debug features should be registered
1044 * return: -ENOMEM on error, 0 otherwise
1046 int zfcp_adapter_debug_register(struct zfcp_adapter
*adapter
)
1048 char dbf_name
[DEBUG_MAX_NAME_LEN
];
1049 struct zfcp_dbf
*dbf
;
1051 dbf
= kmalloc(sizeof(struct zfcp_dbf
), GFP_KERNEL
);
1055 spin_lock_init(&dbf
->hba_dbf_lock
);
1056 spin_lock_init(&dbf
->san_dbf_lock
);
1057 spin_lock_init(&dbf
->scsi_dbf_lock
);
1058 spin_lock_init(&dbf
->rec_dbf_lock
);
1060 /* debug feature area which records recovery activity */
1061 sprintf(dbf_name
, "zfcp_%s_rec", dev_name(&adapter
->ccw_device
->dev
));
1062 dbf
->rec_dbf
= zfcp_dbf_reg(dbf_name
, 3, &zfcp_rec_dbf_view
,
1063 sizeof(struct zfcp_rec_dbf_record
));
1067 /* debug feature area which records HBA (FSF and QDIO) conditions */
1068 sprintf(dbf_name
, "zfcp_%s_hba", dev_name(&adapter
->ccw_device
->dev
));
1069 dbf
->hba_dbf
= zfcp_dbf_reg(dbf_name
, 3, &zfcp_hba_dbf_view
,
1070 sizeof(struct zfcp_hba_dbf_record
));
1074 /* debug feature area which records SAN command failures and recovery */
1075 sprintf(dbf_name
, "zfcp_%s_san", dev_name(&adapter
->ccw_device
->dev
));
1076 dbf
->san_dbf
= zfcp_dbf_reg(dbf_name
, 6, &zfcp_san_dbf_view
,
1077 sizeof(struct zfcp_san_dbf_record
));
1081 /* debug feature area which records SCSI command failures and recovery */
1082 sprintf(dbf_name
, "zfcp_%s_scsi", dev_name(&adapter
->ccw_device
->dev
));
1083 dbf
->scsi_dbf
= zfcp_dbf_reg(dbf_name
, 3, &zfcp_scsi_dbf_view
,
1084 sizeof(struct zfcp_scsi_dbf_record
));
1092 debug_unregister(dbf
->san_dbf
);
1094 debug_unregister(dbf
->hba_dbf
);
1096 debug_unregister(dbf
->rec_dbf
);
1103 * zfcp_adapter_debug_unregister - unregisters debug feature for an adapter
1104 * @adapter: pointer to adapter for which debug features should be unregistered
1106 void zfcp_adapter_debug_unregister(struct zfcp_adapter
*adapter
)
1108 debug_unregister(adapter
->dbf
->scsi_dbf
);
1109 debug_unregister(adapter
->dbf
->san_dbf
);
1110 debug_unregister(adapter
->dbf
->hba_dbf
);
1111 debug_unregister(adapter
->dbf
->rec_dbf
);
1112 kfree(adapter
->dbf
);
1113 adapter
->dbf
= NULL
;