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");
124 * zfcp_hba_dbf_event_fsf_response - trace event for request completion
125 * @fsf_req: request that has been completed
127 void zfcp_hba_dbf_event_fsf_response(struct zfcp_fsf_req
*fsf_req
)
129 struct zfcp_adapter
*adapter
= fsf_req
->adapter
;
130 struct zfcp_dbf
*dbf
= adapter
->dbf
;
131 struct fsf_qtcb
*qtcb
= fsf_req
->qtcb
;
132 union fsf_prot_status_qual
*prot_status_qual
=
133 &qtcb
->prefix
.prot_status_qual
;
134 union fsf_status_qual
*fsf_status_qual
= &qtcb
->header
.fsf_status_qual
;
135 struct scsi_cmnd
*scsi_cmnd
;
136 struct zfcp_port
*port
;
137 struct zfcp_unit
*unit
;
138 struct zfcp_send_els
*send_els
;
139 struct zfcp_hba_dbf_record
*rec
= &dbf
->hba_dbf_buf
;
140 struct zfcp_hba_dbf_record_response
*response
= &rec
->u
.response
;
144 spin_lock_irqsave(&dbf
->hba_dbf_lock
, flags
);
145 memset(rec
, 0, sizeof(*rec
));
146 strncpy(rec
->tag
, "resp", ZFCP_DBF_TAG_SIZE
);
148 if ((qtcb
->prefix
.prot_status
!= FSF_PROT_GOOD
) &&
149 (qtcb
->prefix
.prot_status
!= FSF_PROT_FSF_STATUS_PRESENTED
)) {
150 strncpy(rec
->tag2
, "perr", ZFCP_DBF_TAG_SIZE
);
152 } else if (qtcb
->header
.fsf_status
!= FSF_GOOD
) {
153 strncpy(rec
->tag2
, "ferr", ZFCP_DBF_TAG_SIZE
);
155 } else if ((fsf_req
->fsf_command
== FSF_QTCB_OPEN_PORT_WITH_DID
) ||
156 (fsf_req
->fsf_command
== FSF_QTCB_OPEN_LUN
)) {
157 strncpy(rec
->tag2
, "open", ZFCP_DBF_TAG_SIZE
);
159 } else if (qtcb
->header
.log_length
) {
160 strncpy(rec
->tag2
, "qtcb", ZFCP_DBF_TAG_SIZE
);
163 strncpy(rec
->tag2
, "norm", ZFCP_DBF_TAG_SIZE
);
167 response
->fsf_command
= fsf_req
->fsf_command
;
168 response
->fsf_reqid
= fsf_req
->req_id
;
169 response
->fsf_seqno
= fsf_req
->seq_no
;
170 response
->fsf_issued
= fsf_req
->issued
;
171 response
->fsf_prot_status
= qtcb
->prefix
.prot_status
;
172 response
->fsf_status
= qtcb
->header
.fsf_status
;
173 memcpy(response
->fsf_prot_status_qual
,
174 prot_status_qual
, FSF_PROT_STATUS_QUAL_SIZE
);
175 memcpy(response
->fsf_status_qual
,
176 fsf_status_qual
, FSF_STATUS_QUALIFIER_SIZE
);
177 response
->fsf_req_status
= fsf_req
->status
;
178 response
->sbal_first
= fsf_req
->sbal_first
;
179 response
->sbal_last
= fsf_req
->sbal_last
;
180 response
->sbal_response
= fsf_req
->sbal_response
;
181 response
->pool
= fsf_req
->pool
!= NULL
;
182 response
->erp_action
= (unsigned long)fsf_req
->erp_action
;
184 switch (fsf_req
->fsf_command
) {
185 case FSF_QTCB_FCP_CMND
:
186 if (fsf_req
->status
& ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT
)
188 scsi_cmnd
= (struct scsi_cmnd
*)fsf_req
->data
;
190 response
->u
.fcp
.cmnd
= (unsigned long)scsi_cmnd
;
191 response
->u
.fcp
.serial
= scsi_cmnd
->serial_number
;
195 case FSF_QTCB_OPEN_PORT_WITH_DID
:
196 case FSF_QTCB_CLOSE_PORT
:
197 case FSF_QTCB_CLOSE_PHYSICAL_PORT
:
198 port
= (struct zfcp_port
*)fsf_req
->data
;
199 response
->u
.port
.wwpn
= port
->wwpn
;
200 response
->u
.port
.d_id
= port
->d_id
;
201 response
->u
.port
.port_handle
= qtcb
->header
.port_handle
;
204 case FSF_QTCB_OPEN_LUN
:
205 case FSF_QTCB_CLOSE_LUN
:
206 unit
= (struct zfcp_unit
*)fsf_req
->data
;
208 response
->u
.unit
.wwpn
= port
->wwpn
;
209 response
->u
.unit
.fcp_lun
= unit
->fcp_lun
;
210 response
->u
.unit
.port_handle
= qtcb
->header
.port_handle
;
211 response
->u
.unit
.lun_handle
= qtcb
->header
.lun_handle
;
214 case FSF_QTCB_SEND_ELS
:
215 send_els
= (struct zfcp_send_els
*)fsf_req
->data
;
216 response
->u
.els
.d_id
= qtcb
->bottom
.support
.d_id
;
217 response
->u
.els
.ls_code
= send_els
->ls_code
>> 24;
220 case FSF_QTCB_ABORT_FCP_CMND
:
221 case FSF_QTCB_SEND_GENERIC
:
222 case FSF_QTCB_EXCHANGE_CONFIG_DATA
:
223 case FSF_QTCB_EXCHANGE_PORT_DATA
:
224 case FSF_QTCB_DOWNLOAD_CONTROL_FILE
:
225 case FSF_QTCB_UPLOAD_CONTROL_FILE
:
229 debug_event(dbf
->hba_dbf
, level
, rec
, sizeof(*rec
));
231 /* have fcp channel microcode fixed to use as little as possible */
232 if (fsf_req
->fsf_command
!= FSF_QTCB_FCP_CMND
) {
233 /* adjust length skipping trailing zeros */
234 char *buf
= (char *)qtcb
+ qtcb
->header
.log_start
;
235 int len
= qtcb
->header
.log_length
;
236 for (; len
&& !buf
[len
- 1]; len
--);
237 zfcp_dbf_hexdump(dbf
->hba_dbf
, rec
, sizeof(*rec
), level
, buf
,
241 spin_unlock_irqrestore(&dbf
->hba_dbf_lock
, flags
);
245 * zfcp_hba_dbf_event_fsf_unsol - trace event for an unsolicited status buffer
246 * @tag: tag indicating which kind of unsolicited status has been received
247 * @adapter: adapter that has issued the unsolicited status buffer
248 * @status_buffer: buffer containing payload of unsolicited status
250 void zfcp_hba_dbf_event_fsf_unsol(const char *tag
, struct zfcp_adapter
*adapter
,
251 struct fsf_status_read_buffer
*status_buffer
)
253 struct zfcp_dbf
*dbf
= adapter
->dbf
;
254 struct zfcp_hba_dbf_record
*rec
= &dbf
->hba_dbf_buf
;
257 spin_lock_irqsave(&dbf
->hba_dbf_lock
, flags
);
258 memset(rec
, 0, sizeof(*rec
));
259 strncpy(rec
->tag
, "stat", ZFCP_DBF_TAG_SIZE
);
260 strncpy(rec
->tag2
, tag
, ZFCP_DBF_TAG_SIZE
);
262 rec
->u
.status
.failed
= atomic_read(&adapter
->stat_miss
);
263 if (status_buffer
!= NULL
) {
264 rec
->u
.status
.status_type
= status_buffer
->status_type
;
265 rec
->u
.status
.status_subtype
= status_buffer
->status_subtype
;
266 memcpy(&rec
->u
.status
.queue_designator
,
267 &status_buffer
->queue_designator
,
268 sizeof(struct fsf_queue_designator
));
270 switch (status_buffer
->status_type
) {
271 case FSF_STATUS_READ_SENSE_DATA_AVAIL
:
272 rec
->u
.status
.payload_size
=
273 ZFCP_DBF_UNSOL_PAYLOAD_SENSE_DATA_AVAIL
;
276 case FSF_STATUS_READ_BIT_ERROR_THRESHOLD
:
277 rec
->u
.status
.payload_size
=
278 ZFCP_DBF_UNSOL_PAYLOAD_BIT_ERROR_THRESHOLD
;
281 case FSF_STATUS_READ_LINK_DOWN
:
282 switch (status_buffer
->status_subtype
) {
283 case FSF_STATUS_READ_SUB_NO_PHYSICAL_LINK
:
284 case FSF_STATUS_READ_SUB_FDISC_FAILED
:
285 rec
->u
.status
.payload_size
=
286 sizeof(struct fsf_link_down_info
);
290 case FSF_STATUS_READ_FEATURE_UPDATE_ALERT
:
291 rec
->u
.status
.payload_size
=
292 ZFCP_DBF_UNSOL_PAYLOAD_FEATURE_UPDATE_ALERT
;
295 memcpy(&rec
->u
.status
.payload
,
296 &status_buffer
->payload
, rec
->u
.status
.payload_size
);
299 debug_event(dbf
->hba_dbf
, 2, rec
, sizeof(*rec
));
300 spin_unlock_irqrestore(&dbf
->hba_dbf_lock
, flags
);
304 * zfcp_hba_dbf_event_qdio - trace event for QDIO related failure
305 * @adapter: adapter affected by this QDIO related event
306 * @qdio_error: as passed by qdio module
307 * @sbal_index: first buffer with error condition, as passed by qdio module
308 * @sbal_count: number of buffers affected, as passed by qdio module
310 void zfcp_hba_dbf_event_qdio(struct zfcp_adapter
*adapter
,
311 unsigned int qdio_error
, int sbal_index
,
314 struct zfcp_dbf
*dbf
= adapter
->dbf
;
315 struct zfcp_hba_dbf_record
*r
= &dbf
->hba_dbf_buf
;
318 spin_lock_irqsave(&dbf
->hba_dbf_lock
, flags
);
319 memset(r
, 0, sizeof(*r
));
320 strncpy(r
->tag
, "qdio", ZFCP_DBF_TAG_SIZE
);
321 r
->u
.qdio
.qdio_error
= qdio_error
;
322 r
->u
.qdio
.sbal_index
= sbal_index
;
323 r
->u
.qdio
.sbal_count
= sbal_count
;
324 debug_event(dbf
->hba_dbf
, 0, r
, sizeof(*r
));
325 spin_unlock_irqrestore(&dbf
->hba_dbf_lock
, flags
);
329 * zfcp_hba_dbf_event_berr - trace event for bit error threshold
330 * @adapter: adapter affected by this QDIO related event
333 void zfcp_hba_dbf_event_berr(struct zfcp_adapter
*adapter
,
334 struct zfcp_fsf_req
*req
)
336 struct zfcp_dbf
*dbf
= adapter
->dbf
;
337 struct zfcp_hba_dbf_record
*r
= &dbf
->hba_dbf_buf
;
338 struct fsf_status_read_buffer
*sr_buf
= req
->data
;
339 struct fsf_bit_error_payload
*err
= &sr_buf
->payload
.bit_error
;
342 spin_lock_irqsave(&dbf
->hba_dbf_lock
, flags
);
343 memset(r
, 0, sizeof(*r
));
344 strncpy(r
->tag
, "berr", ZFCP_DBF_TAG_SIZE
);
345 memcpy(&r
->u
.berr
, err
, sizeof(struct fsf_bit_error_payload
));
346 debug_event(dbf
->hba_dbf
, 0, r
, sizeof(*r
));
347 spin_unlock_irqrestore(&dbf
->hba_dbf_lock
, flags
);
349 static void zfcp_hba_dbf_view_response(char **p
,
350 struct zfcp_hba_dbf_record_response
*r
)
354 zfcp_dbf_out(p
, "fsf_command", "0x%08x", r
->fsf_command
);
355 zfcp_dbf_out(p
, "fsf_reqid", "0x%0Lx", r
->fsf_reqid
);
356 zfcp_dbf_out(p
, "fsf_seqno", "0x%08x", r
->fsf_seqno
);
357 zfcp_dbf_timestamp(r
->fsf_issued
, &t
);
358 zfcp_dbf_out(p
, "fsf_issued", "%011lu:%06lu", t
.tv_sec
, t
.tv_nsec
);
359 zfcp_dbf_out(p
, "fsf_prot_status", "0x%08x", r
->fsf_prot_status
);
360 zfcp_dbf_out(p
, "fsf_status", "0x%08x", r
->fsf_status
);
361 zfcp_dbf_outd(p
, "fsf_prot_status_qual", r
->fsf_prot_status_qual
,
362 FSF_PROT_STATUS_QUAL_SIZE
, 0, FSF_PROT_STATUS_QUAL_SIZE
);
363 zfcp_dbf_outd(p
, "fsf_status_qual", r
->fsf_status_qual
,
364 FSF_STATUS_QUALIFIER_SIZE
, 0, FSF_STATUS_QUALIFIER_SIZE
);
365 zfcp_dbf_out(p
, "fsf_req_status", "0x%08x", r
->fsf_req_status
);
366 zfcp_dbf_out(p
, "sbal_first", "0x%02x", r
->sbal_first
);
367 zfcp_dbf_out(p
, "sbal_last", "0x%02x", r
->sbal_last
);
368 zfcp_dbf_out(p
, "sbal_response", "0x%02x", r
->sbal_response
);
369 zfcp_dbf_out(p
, "pool", "0x%02x", r
->pool
);
371 switch (r
->fsf_command
) {
372 case FSF_QTCB_FCP_CMND
:
373 if (r
->fsf_req_status
& ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT
)
375 zfcp_dbf_out(p
, "scsi_cmnd", "0x%0Lx", r
->u
.fcp
.cmnd
);
376 zfcp_dbf_out(p
, "scsi_serial", "0x%016Lx", r
->u
.fcp
.serial
);
377 p
+= sprintf(*p
, "\n");
380 case FSF_QTCB_OPEN_PORT_WITH_DID
:
381 case FSF_QTCB_CLOSE_PORT
:
382 case FSF_QTCB_CLOSE_PHYSICAL_PORT
:
383 zfcp_dbf_out(p
, "wwpn", "0x%016Lx", r
->u
.port
.wwpn
);
384 zfcp_dbf_out(p
, "d_id", "0x%06x", r
->u
.port
.d_id
);
385 zfcp_dbf_out(p
, "port_handle", "0x%08x", r
->u
.port
.port_handle
);
388 case FSF_QTCB_OPEN_LUN
:
389 case FSF_QTCB_CLOSE_LUN
:
390 zfcp_dbf_out(p
, "wwpn", "0x%016Lx", r
->u
.unit
.wwpn
);
391 zfcp_dbf_out(p
, "fcp_lun", "0x%016Lx", r
->u
.unit
.fcp_lun
);
392 zfcp_dbf_out(p
, "port_handle", "0x%08x", r
->u
.unit
.port_handle
);
393 zfcp_dbf_out(p
, "lun_handle", "0x%08x", r
->u
.unit
.lun_handle
);
396 case FSF_QTCB_SEND_ELS
:
397 zfcp_dbf_out(p
, "d_id", "0x%06x", r
->u
.els
.d_id
);
398 zfcp_dbf_out(p
, "ls_code", "0x%02x", r
->u
.els
.ls_code
);
401 case FSF_QTCB_ABORT_FCP_CMND
:
402 case FSF_QTCB_SEND_GENERIC
:
403 case FSF_QTCB_EXCHANGE_CONFIG_DATA
:
404 case FSF_QTCB_EXCHANGE_PORT_DATA
:
405 case FSF_QTCB_DOWNLOAD_CONTROL_FILE
:
406 case FSF_QTCB_UPLOAD_CONTROL_FILE
:
411 static void zfcp_hba_dbf_view_status(char **p
,
412 struct zfcp_hba_dbf_record_status
*r
)
414 zfcp_dbf_out(p
, "failed", "0x%02x", r
->failed
);
415 zfcp_dbf_out(p
, "status_type", "0x%08x", r
->status_type
);
416 zfcp_dbf_out(p
, "status_subtype", "0x%08x", r
->status_subtype
);
417 zfcp_dbf_outd(p
, "queue_designator", (char *)&r
->queue_designator
,
418 sizeof(struct fsf_queue_designator
), 0,
419 sizeof(struct fsf_queue_designator
));
420 zfcp_dbf_outd(p
, "payload", (char *)&r
->payload
, r
->payload_size
, 0,
424 static void zfcp_hba_dbf_view_qdio(char **p
, struct zfcp_hba_dbf_record_qdio
*r
)
426 zfcp_dbf_out(p
, "qdio_error", "0x%08x", r
->qdio_error
);
427 zfcp_dbf_out(p
, "sbal_index", "0x%02x", r
->sbal_index
);
428 zfcp_dbf_out(p
, "sbal_count", "0x%02x", r
->sbal_count
);
431 static void zfcp_hba_dbf_view_berr(char **p
, struct fsf_bit_error_payload
*r
)
433 zfcp_dbf_out(p
, "link_failures", "%d", r
->link_failure_error_count
);
434 zfcp_dbf_out(p
, "loss_of_sync_err", "%d", r
->loss_of_sync_error_count
);
435 zfcp_dbf_out(p
, "loss_of_sig_err", "%d", r
->loss_of_signal_error_count
);
436 zfcp_dbf_out(p
, "prim_seq_err", "%d",
437 r
->primitive_sequence_error_count
);
438 zfcp_dbf_out(p
, "inval_trans_word_err", "%d",
439 r
->invalid_transmission_word_error_count
);
440 zfcp_dbf_out(p
, "CRC_errors", "%d", r
->crc_error_count
);
441 zfcp_dbf_out(p
, "prim_seq_event_to", "%d",
442 r
->primitive_sequence_event_timeout_count
);
443 zfcp_dbf_out(p
, "elast_buf_overrun_err", "%d",
444 r
->elastic_buffer_overrun_error_count
);
445 zfcp_dbf_out(p
, "adv_rec_buf2buf_cred", "%d",
446 r
->advertised_receive_b2b_credit
);
447 zfcp_dbf_out(p
, "curr_rec_buf2buf_cred", "%d",
448 r
->current_receive_b2b_credit
);
449 zfcp_dbf_out(p
, "adv_trans_buf2buf_cred", "%d",
450 r
->advertised_transmit_b2b_credit
);
451 zfcp_dbf_out(p
, "curr_trans_buf2buf_cred", "%d",
452 r
->current_transmit_b2b_credit
);
455 static int zfcp_hba_dbf_view_format(debug_info_t
*id
, struct debug_view
*view
,
456 char *out_buf
, const char *in_buf
)
458 struct zfcp_hba_dbf_record
*r
= (struct zfcp_hba_dbf_record
*)in_buf
;
461 if (strncmp(r
->tag
, "dump", ZFCP_DBF_TAG_SIZE
) == 0)
464 zfcp_dbf_tag(&p
, "tag", r
->tag
);
465 if (isalpha(r
->tag2
[0]))
466 zfcp_dbf_tag(&p
, "tag2", r
->tag2
);
468 if (strncmp(r
->tag
, "resp", ZFCP_DBF_TAG_SIZE
) == 0)
469 zfcp_hba_dbf_view_response(&p
, &r
->u
.response
);
470 else if (strncmp(r
->tag
, "stat", ZFCP_DBF_TAG_SIZE
) == 0)
471 zfcp_hba_dbf_view_status(&p
, &r
->u
.status
);
472 else if (strncmp(r
->tag
, "qdio", ZFCP_DBF_TAG_SIZE
) == 0)
473 zfcp_hba_dbf_view_qdio(&p
, &r
->u
.qdio
);
474 else if (strncmp(r
->tag
, "berr", ZFCP_DBF_TAG_SIZE
) == 0)
475 zfcp_hba_dbf_view_berr(&p
, &r
->u
.berr
);
477 if (strncmp(r
->tag
, "resp", ZFCP_DBF_TAG_SIZE
) != 0)
478 p
+= sprintf(p
, "\n");
482 static struct debug_view zfcp_hba_dbf_view
= {
485 &zfcp_dbf_view_header
,
486 &zfcp_hba_dbf_view_format
,
491 static const char *zfcp_rec_dbf_tags
[] = {
492 [ZFCP_REC_DBF_ID_THREAD
] = "thread",
493 [ZFCP_REC_DBF_ID_TARGET
] = "target",
494 [ZFCP_REC_DBF_ID_TRIGGER
] = "trigger",
495 [ZFCP_REC_DBF_ID_ACTION
] = "action",
498 static int zfcp_rec_dbf_view_format(debug_info_t
*id
, struct debug_view
*view
,
499 char *buf
, const char *_rec
)
501 struct zfcp_rec_dbf_record
*r
= (struct zfcp_rec_dbf_record
*)_rec
;
503 char hint
[ZFCP_DBF_ID_SIZE
+ 1];
505 memcpy(hint
, r
->id2
, ZFCP_DBF_ID_SIZE
);
506 hint
[ZFCP_DBF_ID_SIZE
] = 0;
507 zfcp_dbf_outs(&p
, "tag", zfcp_rec_dbf_tags
[r
->id
]);
508 zfcp_dbf_outs(&p
, "hint", hint
);
510 case ZFCP_REC_DBF_ID_THREAD
:
511 zfcp_dbf_out(&p
, "total", "%d", r
->u
.thread
.total
);
512 zfcp_dbf_out(&p
, "ready", "%d", r
->u
.thread
.ready
);
513 zfcp_dbf_out(&p
, "running", "%d", r
->u
.thread
.running
);
515 case ZFCP_REC_DBF_ID_TARGET
:
516 zfcp_dbf_out(&p
, "reference", "0x%016Lx", r
->u
.target
.ref
);
517 zfcp_dbf_out(&p
, "status", "0x%08x", r
->u
.target
.status
);
518 zfcp_dbf_out(&p
, "erp_count", "%d", r
->u
.target
.erp_count
);
519 zfcp_dbf_out(&p
, "d_id", "0x%06x", r
->u
.target
.d_id
);
520 zfcp_dbf_out(&p
, "wwpn", "0x%016Lx", r
->u
.target
.wwpn
);
521 zfcp_dbf_out(&p
, "fcp_lun", "0x%016Lx", r
->u
.target
.fcp_lun
);
523 case ZFCP_REC_DBF_ID_TRIGGER
:
524 zfcp_dbf_out(&p
, "reference", "0x%016Lx", r
->u
.trigger
.ref
);
525 zfcp_dbf_out(&p
, "erp_action", "0x%016Lx", r
->u
.trigger
.action
);
526 zfcp_dbf_out(&p
, "requested", "%d", r
->u
.trigger
.want
);
527 zfcp_dbf_out(&p
, "executed", "%d", r
->u
.trigger
.need
);
528 zfcp_dbf_out(&p
, "wwpn", "0x%016Lx", r
->u
.trigger
.wwpn
);
529 zfcp_dbf_out(&p
, "fcp_lun", "0x%016Lx", r
->u
.trigger
.fcp_lun
);
530 zfcp_dbf_out(&p
, "adapter_status", "0x%08x", r
->u
.trigger
.as
);
531 zfcp_dbf_out(&p
, "port_status", "0x%08x", r
->u
.trigger
.ps
);
532 zfcp_dbf_out(&p
, "unit_status", "0x%08x", r
->u
.trigger
.us
);
534 case ZFCP_REC_DBF_ID_ACTION
:
535 zfcp_dbf_out(&p
, "erp_action", "0x%016Lx", r
->u
.action
.action
);
536 zfcp_dbf_out(&p
, "fsf_req", "0x%016Lx", r
->u
.action
.fsf_req
);
537 zfcp_dbf_out(&p
, "status", "0x%08Lx", r
->u
.action
.status
);
538 zfcp_dbf_out(&p
, "step", "0x%08Lx", r
->u
.action
.step
);
541 p
+= sprintf(p
, "\n");
545 static struct debug_view zfcp_rec_dbf_view
= {
548 &zfcp_dbf_view_header
,
549 &zfcp_rec_dbf_view_format
,
555 * zfcp_rec_dbf_event_thread - trace event related to recovery thread operation
556 * @id2: identifier for event
558 * This function assumes that the caller is holding erp_lock.
560 void zfcp_rec_dbf_event_thread(char *id2
, struct zfcp_adapter
*adapter
)
562 struct zfcp_dbf
*dbf
= adapter
->dbf
;
563 struct zfcp_rec_dbf_record
*r
= &dbf
->rec_dbf_buf
;
564 unsigned long flags
= 0;
565 struct list_head
*entry
;
566 unsigned ready
= 0, running
= 0, total
;
568 list_for_each(entry
, &adapter
->erp_ready_head
)
570 list_for_each(entry
, &adapter
->erp_running_head
)
572 total
= adapter
->erp_total_count
;
574 spin_lock_irqsave(&dbf
->rec_dbf_lock
, flags
);
575 memset(r
, 0, sizeof(*r
));
576 r
->id
= ZFCP_REC_DBF_ID_THREAD
;
577 memcpy(r
->id2
, id2
, ZFCP_DBF_ID_SIZE
);
578 r
->u
.thread
.total
= total
;
579 r
->u
.thread
.ready
= ready
;
580 r
->u
.thread
.running
= running
;
581 debug_event(dbf
->rec_dbf
, 6, r
, sizeof(*r
));
582 spin_unlock_irqrestore(&dbf
->rec_dbf_lock
, flags
);
586 * zfcp_rec_dbf_event_thread - trace event related to recovery thread operation
587 * @id2: identifier for event
589 * This function assumes that the caller does not hold erp_lock.
591 void zfcp_rec_dbf_event_thread_lock(char *id2
, struct zfcp_adapter
*adapter
)
595 read_lock_irqsave(&adapter
->erp_lock
, flags
);
596 zfcp_rec_dbf_event_thread(id2
, adapter
);
597 read_unlock_irqrestore(&adapter
->erp_lock
, flags
);
600 static void zfcp_rec_dbf_event_target(char *id2
, void *ref
,
601 struct zfcp_adapter
*adapter
,
602 atomic_t
*status
, atomic_t
*erp_count
,
603 u64 wwpn
, u32 d_id
, u64 fcp_lun
)
605 struct zfcp_dbf
*dbf
= adapter
->dbf
;
606 struct zfcp_rec_dbf_record
*r
= &dbf
->rec_dbf_buf
;
609 spin_lock_irqsave(&dbf
->rec_dbf_lock
, flags
);
610 memset(r
, 0, sizeof(*r
));
611 r
->id
= ZFCP_REC_DBF_ID_TARGET
;
612 memcpy(r
->id2
, id2
, ZFCP_DBF_ID_SIZE
);
613 r
->u
.target
.ref
= (unsigned long)ref
;
614 r
->u
.target
.status
= atomic_read(status
);
615 r
->u
.target
.wwpn
= wwpn
;
616 r
->u
.target
.d_id
= d_id
;
617 r
->u
.target
.fcp_lun
= fcp_lun
;
618 r
->u
.target
.erp_count
= atomic_read(erp_count
);
619 debug_event(dbf
->rec_dbf
, 3, r
, sizeof(*r
));
620 spin_unlock_irqrestore(&dbf
->rec_dbf_lock
, flags
);
624 * zfcp_rec_dbf_event_adapter - trace event for adapter state change
625 * @id: identifier for trigger of state change
626 * @ref: additional reference (e.g. request)
629 void zfcp_rec_dbf_event_adapter(char *id
, void *ref
,
630 struct zfcp_adapter
*adapter
)
632 zfcp_rec_dbf_event_target(id
, ref
, adapter
, &adapter
->status
,
633 &adapter
->erp_counter
, 0, 0, 0);
637 * zfcp_rec_dbf_event_port - trace event for port state change
638 * @id: identifier for trigger of state change
639 * @ref: additional reference (e.g. request)
642 void zfcp_rec_dbf_event_port(char *id
, void *ref
, struct zfcp_port
*port
)
644 struct zfcp_adapter
*adapter
= port
->adapter
;
646 zfcp_rec_dbf_event_target(id
, ref
, adapter
, &port
->status
,
647 &port
->erp_counter
, port
->wwpn
, port
->d_id
,
652 * zfcp_rec_dbf_event_unit - trace event for unit state change
653 * @id: identifier for trigger of state change
654 * @ref: additional reference (e.g. request)
657 void zfcp_rec_dbf_event_unit(char *id
, void *ref
, struct zfcp_unit
*unit
)
659 struct zfcp_port
*port
= unit
->port
;
660 struct zfcp_adapter
*adapter
= port
->adapter
;
662 zfcp_rec_dbf_event_target(id
, ref
, adapter
, &unit
->status
,
663 &unit
->erp_counter
, port
->wwpn
, port
->d_id
,
668 * zfcp_rec_dbf_event_trigger - trace event for triggered error recovery
669 * @id2: identifier for error recovery trigger
670 * @ref: additional reference (e.g. request)
671 * @want: originally requested error recovery action
672 * @need: error recovery action actually initiated
673 * @action: address of error recovery action struct
678 void zfcp_rec_dbf_event_trigger(char *id2
, void *ref
, u8 want
, u8 need
,
679 void *action
, struct zfcp_adapter
*adapter
,
680 struct zfcp_port
*port
, struct zfcp_unit
*unit
)
682 struct zfcp_dbf
*dbf
= adapter
->dbf
;
683 struct zfcp_rec_dbf_record
*r
= &dbf
->rec_dbf_buf
;
686 spin_lock_irqsave(&dbf
->rec_dbf_lock
, flags
);
687 memset(r
, 0, sizeof(*r
));
688 r
->id
= ZFCP_REC_DBF_ID_TRIGGER
;
689 memcpy(r
->id2
, id2
, ZFCP_DBF_ID_SIZE
);
690 r
->u
.trigger
.ref
= (unsigned long)ref
;
691 r
->u
.trigger
.want
= want
;
692 r
->u
.trigger
.need
= need
;
693 r
->u
.trigger
.action
= (unsigned long)action
;
694 r
->u
.trigger
.as
= atomic_read(&adapter
->status
);
696 r
->u
.trigger
.ps
= atomic_read(&port
->status
);
697 r
->u
.trigger
.wwpn
= port
->wwpn
;
700 r
->u
.trigger
.us
= atomic_read(&unit
->status
);
701 r
->u
.trigger
.fcp_lun
= unit
->fcp_lun
;
703 debug_event(dbf
->rec_dbf
, action
? 1 : 4, r
, sizeof(*r
));
704 spin_unlock_irqrestore(&dbf
->rec_dbf_lock
, flags
);
708 * zfcp_rec_dbf_event_action - trace event showing progress of recovery action
710 * @erp_action: error recovery action struct pointer
712 void zfcp_rec_dbf_event_action(char *id2
, struct zfcp_erp_action
*erp_action
)
714 struct zfcp_adapter
*adapter
= erp_action
->adapter
;
715 struct zfcp_dbf
*dbf
= adapter
->dbf
;
716 struct zfcp_rec_dbf_record
*r
= &dbf
->rec_dbf_buf
;
719 spin_lock_irqsave(&dbf
->rec_dbf_lock
, flags
);
720 memset(r
, 0, sizeof(*r
));
721 r
->id
= ZFCP_REC_DBF_ID_ACTION
;
722 memcpy(r
->id2
, id2
, ZFCP_DBF_ID_SIZE
);
723 r
->u
.action
.action
= (unsigned long)erp_action
;
724 r
->u
.action
.status
= erp_action
->status
;
725 r
->u
.action
.step
= erp_action
->step
;
726 r
->u
.action
.fsf_req
= (unsigned long)erp_action
->fsf_req
;
727 debug_event(dbf
->rec_dbf
, 5, r
, sizeof(*r
));
728 spin_unlock_irqrestore(&dbf
->rec_dbf_lock
, flags
);
732 * zfcp_san_dbf_event_ct_request - trace event for issued CT request
733 * @fsf_req: request containing issued CT data
735 void zfcp_san_dbf_event_ct_request(struct zfcp_fsf_req
*fsf_req
)
737 struct zfcp_send_ct
*ct
= (struct zfcp_send_ct
*)fsf_req
->data
;
738 struct zfcp_wka_port
*wka_port
= ct
->wka_port
;
739 struct zfcp_adapter
*adapter
= wka_port
->adapter
;
740 struct zfcp_dbf
*dbf
= adapter
->dbf
;
741 struct ct_hdr
*hdr
= sg_virt(ct
->req
);
742 struct zfcp_san_dbf_record
*r
= &dbf
->san_dbf_buf
;
743 struct zfcp_san_dbf_record_ct_request
*oct
= &r
->u
.ct_req
;
747 spin_lock_irqsave(&dbf
->san_dbf_lock
, flags
);
748 memset(r
, 0, sizeof(*r
));
749 strncpy(r
->tag
, "octc", ZFCP_DBF_TAG_SIZE
);
750 r
->fsf_reqid
= fsf_req
->req_id
;
751 r
->fsf_seqno
= fsf_req
->seq_no
;
752 r
->s_id
= fc_host_port_id(adapter
->scsi_host
);
753 r
->d_id
= wka_port
->d_id
;
754 oct
->cmd_req_code
= hdr
->cmd_rsp_code
;
755 oct
->revision
= hdr
->revision
;
756 oct
->gs_type
= hdr
->gs_type
;
757 oct
->gs_subtype
= hdr
->gs_subtype
;
758 oct
->options
= hdr
->options
;
759 oct
->max_res_size
= hdr
->max_res_size
;
760 oct
->len
= min((int)ct
->req
->length
- (int)sizeof(struct ct_hdr
),
761 ZFCP_DBF_SAN_MAX_PAYLOAD
);
762 debug_event(dbf
->san_dbf
, level
, r
, sizeof(*r
));
763 zfcp_dbf_hexdump(dbf
->san_dbf
, r
, sizeof(*r
), level
,
764 (void *)hdr
+ sizeof(struct ct_hdr
), oct
->len
);
765 spin_unlock_irqrestore(&dbf
->san_dbf_lock
, flags
);
769 * zfcp_san_dbf_event_ct_response - trace event for completion of CT request
770 * @fsf_req: request containing CT response
772 void zfcp_san_dbf_event_ct_response(struct zfcp_fsf_req
*fsf_req
)
774 struct zfcp_send_ct
*ct
= (struct zfcp_send_ct
*)fsf_req
->data
;
775 struct zfcp_wka_port
*wka_port
= ct
->wka_port
;
776 struct zfcp_adapter
*adapter
= wka_port
->adapter
;
777 struct ct_hdr
*hdr
= sg_virt(ct
->resp
);
778 struct zfcp_dbf
*dbf
= adapter
->dbf
;
779 struct zfcp_san_dbf_record
*r
= &dbf
->san_dbf_buf
;
780 struct zfcp_san_dbf_record_ct_response
*rct
= &r
->u
.ct_resp
;
784 spin_lock_irqsave(&dbf
->san_dbf_lock
, flags
);
785 memset(r
, 0, sizeof(*r
));
786 strncpy(r
->tag
, "rctc", ZFCP_DBF_TAG_SIZE
);
787 r
->fsf_reqid
= fsf_req
->req_id
;
788 r
->fsf_seqno
= fsf_req
->seq_no
;
789 r
->s_id
= wka_port
->d_id
;
790 r
->d_id
= fc_host_port_id(adapter
->scsi_host
);
791 rct
->cmd_rsp_code
= hdr
->cmd_rsp_code
;
792 rct
->revision
= hdr
->revision
;
793 rct
->reason_code
= hdr
->reason_code
;
794 rct
->expl
= hdr
->reason_code_expl
;
795 rct
->vendor_unique
= hdr
->vendor_unique
;
796 rct
->max_res_size
= hdr
->max_res_size
;
797 rct
->len
= min((int)ct
->resp
->length
- (int)sizeof(struct ct_hdr
),
798 ZFCP_DBF_SAN_MAX_PAYLOAD
);
799 debug_event(dbf
->san_dbf
, level
, r
, sizeof(*r
));
800 zfcp_dbf_hexdump(dbf
->san_dbf
, r
, sizeof(*r
), level
,
801 (void *)hdr
+ sizeof(struct ct_hdr
), rct
->len
);
802 spin_unlock_irqrestore(&dbf
->san_dbf_lock
, flags
);
805 static void zfcp_san_dbf_event_els(const char *tag
, int level
,
806 struct zfcp_fsf_req
*fsf_req
, u32 s_id
,
807 u32 d_id
, u8 ls_code
, void *buffer
,
810 struct zfcp_adapter
*adapter
= fsf_req
->adapter
;
811 struct zfcp_dbf
*dbf
= adapter
->dbf
;
812 struct zfcp_san_dbf_record
*rec
= &dbf
->san_dbf_buf
;
815 spin_lock_irqsave(&dbf
->san_dbf_lock
, flags
);
816 memset(rec
, 0, sizeof(*rec
));
817 strncpy(rec
->tag
, tag
, ZFCP_DBF_TAG_SIZE
);
818 rec
->fsf_reqid
= fsf_req
->req_id
;
819 rec
->fsf_seqno
= fsf_req
->seq_no
;
822 rec
->u
.els
.ls_code
= ls_code
;
823 debug_event(dbf
->san_dbf
, level
, rec
, sizeof(*rec
));
824 zfcp_dbf_hexdump(dbf
->san_dbf
, rec
, sizeof(*rec
), level
,
825 buffer
, min(buflen
, ZFCP_DBF_SAN_MAX_PAYLOAD
));
826 spin_unlock_irqrestore(&dbf
->san_dbf_lock
, flags
);
830 * zfcp_san_dbf_event_els_request - trace event for issued ELS
831 * @fsf_req: request containing issued ELS
833 void zfcp_san_dbf_event_els_request(struct zfcp_fsf_req
*fsf_req
)
835 struct zfcp_send_els
*els
= (struct zfcp_send_els
*)fsf_req
->data
;
837 zfcp_san_dbf_event_els("oels", 2, fsf_req
,
838 fc_host_port_id(els
->adapter
->scsi_host
),
839 els
->d_id
, *(u8
*) sg_virt(els
->req
),
840 sg_virt(els
->req
), els
->req
->length
);
844 * zfcp_san_dbf_event_els_response - trace event for completed ELS
845 * @fsf_req: request containing ELS response
847 void zfcp_san_dbf_event_els_response(struct zfcp_fsf_req
*fsf_req
)
849 struct zfcp_send_els
*els
= (struct zfcp_send_els
*)fsf_req
->data
;
851 zfcp_san_dbf_event_els("rels", 2, fsf_req
, els
->d_id
,
852 fc_host_port_id(els
->adapter
->scsi_host
),
853 *(u8
*)sg_virt(els
->req
), sg_virt(els
->resp
),
858 * zfcp_san_dbf_event_incoming_els - trace event for incomig ELS
859 * @fsf_req: request containing unsolicited status buffer with incoming ELS
861 void zfcp_san_dbf_event_incoming_els(struct zfcp_fsf_req
*fsf_req
)
863 struct zfcp_adapter
*adapter
= fsf_req
->adapter
;
864 struct fsf_status_read_buffer
*buf
=
865 (struct fsf_status_read_buffer
*)fsf_req
->data
;
866 int length
= (int)buf
->length
-
867 (int)((void *)&buf
->payload
- (void *)buf
);
869 zfcp_san_dbf_event_els("iels", 1, fsf_req
, buf
->d_id
,
870 fc_host_port_id(adapter
->scsi_host
),
871 buf
->payload
.data
[0], (void *)buf
->payload
.data
,
875 static int zfcp_san_dbf_view_format(debug_info_t
*id
, struct debug_view
*view
,
876 char *out_buf
, const char *in_buf
)
878 struct zfcp_san_dbf_record
*r
= (struct zfcp_san_dbf_record
*)in_buf
;
881 if (strncmp(r
->tag
, "dump", ZFCP_DBF_TAG_SIZE
) == 0)
884 zfcp_dbf_tag(&p
, "tag", r
->tag
);
885 zfcp_dbf_out(&p
, "fsf_reqid", "0x%0Lx", r
->fsf_reqid
);
886 zfcp_dbf_out(&p
, "fsf_seqno", "0x%08x", r
->fsf_seqno
);
887 zfcp_dbf_out(&p
, "s_id", "0x%06x", r
->s_id
);
888 zfcp_dbf_out(&p
, "d_id", "0x%06x", r
->d_id
);
890 if (strncmp(r
->tag
, "octc", ZFCP_DBF_TAG_SIZE
) == 0) {
891 struct zfcp_san_dbf_record_ct_request
*ct
= &r
->u
.ct_req
;
892 zfcp_dbf_out(&p
, "cmd_req_code", "0x%04x", ct
->cmd_req_code
);
893 zfcp_dbf_out(&p
, "revision", "0x%02x", ct
->revision
);
894 zfcp_dbf_out(&p
, "gs_type", "0x%02x", ct
->gs_type
);
895 zfcp_dbf_out(&p
, "gs_subtype", "0x%02x", ct
->gs_subtype
);
896 zfcp_dbf_out(&p
, "options", "0x%02x", ct
->options
);
897 zfcp_dbf_out(&p
, "max_res_size", "0x%04x", ct
->max_res_size
);
898 } else if (strncmp(r
->tag
, "rctc", ZFCP_DBF_TAG_SIZE
) == 0) {
899 struct zfcp_san_dbf_record_ct_response
*ct
= &r
->u
.ct_resp
;
900 zfcp_dbf_out(&p
, "cmd_rsp_code", "0x%04x", ct
->cmd_rsp_code
);
901 zfcp_dbf_out(&p
, "revision", "0x%02x", ct
->revision
);
902 zfcp_dbf_out(&p
, "reason_code", "0x%02x", ct
->reason_code
);
903 zfcp_dbf_out(&p
, "reason_code_expl", "0x%02x", ct
->expl
);
904 zfcp_dbf_out(&p
, "vendor_unique", "0x%02x", ct
->vendor_unique
);
905 zfcp_dbf_out(&p
, "max_res_size", "0x%04x", ct
->max_res_size
);
906 } else if (strncmp(r
->tag
, "oels", ZFCP_DBF_TAG_SIZE
) == 0 ||
907 strncmp(r
->tag
, "rels", ZFCP_DBF_TAG_SIZE
) == 0 ||
908 strncmp(r
->tag
, "iels", ZFCP_DBF_TAG_SIZE
) == 0) {
909 struct zfcp_san_dbf_record_els
*els
= &r
->u
.els
;
910 zfcp_dbf_out(&p
, "ls_code", "0x%02x", els
->ls_code
);
915 static struct debug_view zfcp_san_dbf_view
= {
918 &zfcp_dbf_view_header
,
919 &zfcp_san_dbf_view_format
,
924 void _zfcp_scsi_dbf_event(const char *tag
, const char *tag2
, int level
,
925 struct zfcp_dbf
*dbf
, struct scsi_cmnd
*scsi_cmnd
,
926 struct zfcp_fsf_req
*fsf_req
,
927 unsigned long old_req_id
)
929 struct zfcp_scsi_dbf_record
*rec
= &dbf
->scsi_dbf_buf
;
930 struct zfcp_dbf_dump
*dump
= (struct zfcp_dbf_dump
*)rec
;
932 struct fcp_rsp_iu
*fcp_rsp
;
933 char *fcp_rsp_info
= NULL
, *fcp_sns_info
= NULL
;
934 int offset
= 0, buflen
= 0;
936 spin_lock_irqsave(&dbf
->scsi_dbf_lock
, flags
);
938 memset(rec
, 0, sizeof(*rec
));
940 strncpy(rec
->tag
, tag
, ZFCP_DBF_TAG_SIZE
);
941 strncpy(rec
->tag2
, tag2
, ZFCP_DBF_TAG_SIZE
);
942 if (scsi_cmnd
!= NULL
) {
943 if (scsi_cmnd
->device
) {
944 rec
->scsi_id
= scsi_cmnd
->device
->id
;
945 rec
->scsi_lun
= scsi_cmnd
->device
->lun
;
947 rec
->scsi_result
= scsi_cmnd
->result
;
948 rec
->scsi_cmnd
= (unsigned long)scsi_cmnd
;
949 rec
->scsi_serial
= scsi_cmnd
->serial_number
;
950 memcpy(rec
->scsi_opcode
, scsi_cmnd
->cmnd
,
951 min((int)scsi_cmnd
->cmd_len
,
952 ZFCP_DBF_SCSI_OPCODE
));
953 rec
->scsi_retries
= scsi_cmnd
->retries
;
954 rec
->scsi_allowed
= scsi_cmnd
->allowed
;
956 if (fsf_req
!= NULL
) {
957 fcp_rsp
= (struct fcp_rsp_iu
*)
958 &(fsf_req
->qtcb
->bottom
.io
.fcp_rsp
);
959 fcp_rsp_info
= (unsigned char *) &fcp_rsp
[1];
961 zfcp_get_fcp_sns_info_ptr(fcp_rsp
);
963 rec
->rsp_validity
= fcp_rsp
->validity
.value
;
964 rec
->rsp_scsi_status
= fcp_rsp
->scsi_status
;
965 rec
->rsp_resid
= fcp_rsp
->fcp_resid
;
966 if (fcp_rsp
->validity
.bits
.fcp_rsp_len_valid
)
967 rec
->rsp_code
= *(fcp_rsp_info
+ 3);
968 if (fcp_rsp
->validity
.bits
.fcp_sns_len_valid
) {
969 buflen
= min((int)fcp_rsp
->fcp_sns_len
,
970 ZFCP_DBF_SCSI_MAX_FCP_SNS_INFO
);
971 rec
->sns_info_len
= buflen
;
972 memcpy(rec
->sns_info
, fcp_sns_info
,
974 ZFCP_DBF_SCSI_FCP_SNS_INFO
));
975 offset
+= min(buflen
,
976 ZFCP_DBF_SCSI_FCP_SNS_INFO
);
979 rec
->fsf_reqid
= fsf_req
->req_id
;
980 rec
->fsf_seqno
= fsf_req
->seq_no
;
981 rec
->fsf_issued
= fsf_req
->issued
;
983 rec
->old_fsf_reqid
= old_req_id
;
985 strncpy(dump
->tag
, "dump", ZFCP_DBF_TAG_SIZE
);
986 dump
->total_size
= buflen
;
987 dump
->offset
= offset
;
988 dump
->size
= min(buflen
- offset
,
990 zfcp_scsi_dbf_record
) -
991 (int)sizeof(struct zfcp_dbf_dump
));
992 memcpy(dump
->data
, fcp_sns_info
+ offset
, dump
->size
);
993 offset
+= dump
->size
;
995 debug_event(dbf
->scsi_dbf
, level
, rec
, sizeof(*rec
));
996 } while (offset
< buflen
);
997 spin_unlock_irqrestore(&dbf
->scsi_dbf_lock
, flags
);
1000 static int zfcp_scsi_dbf_view_format(debug_info_t
*id
, struct debug_view
*view
,
1001 char *out_buf
, const char *in_buf
)
1003 struct zfcp_scsi_dbf_record
*r
= (struct zfcp_scsi_dbf_record
*)in_buf
;
1007 if (strncmp(r
->tag
, "dump", ZFCP_DBF_TAG_SIZE
) == 0)
1010 zfcp_dbf_tag(&p
, "tag", r
->tag
);
1011 zfcp_dbf_tag(&p
, "tag2", r
->tag2
);
1012 zfcp_dbf_out(&p
, "scsi_id", "0x%08x", r
->scsi_id
);
1013 zfcp_dbf_out(&p
, "scsi_lun", "0x%08x", r
->scsi_lun
);
1014 zfcp_dbf_out(&p
, "scsi_result", "0x%08x", r
->scsi_result
);
1015 zfcp_dbf_out(&p
, "scsi_cmnd", "0x%0Lx", r
->scsi_cmnd
);
1016 zfcp_dbf_out(&p
, "scsi_serial", "0x%016Lx", r
->scsi_serial
);
1017 zfcp_dbf_outd(&p
, "scsi_opcode", r
->scsi_opcode
, ZFCP_DBF_SCSI_OPCODE
,
1018 0, ZFCP_DBF_SCSI_OPCODE
);
1019 zfcp_dbf_out(&p
, "scsi_retries", "0x%02x", r
->scsi_retries
);
1020 zfcp_dbf_out(&p
, "scsi_allowed", "0x%02x", r
->scsi_allowed
);
1021 if (strncmp(r
->tag
, "abrt", ZFCP_DBF_TAG_SIZE
) == 0)
1022 zfcp_dbf_out(&p
, "old_fsf_reqid", "0x%0Lx", r
->old_fsf_reqid
);
1023 zfcp_dbf_out(&p
, "fsf_reqid", "0x%0Lx", r
->fsf_reqid
);
1024 zfcp_dbf_out(&p
, "fsf_seqno", "0x%08x", r
->fsf_seqno
);
1025 zfcp_dbf_timestamp(r
->fsf_issued
, &t
);
1026 zfcp_dbf_out(&p
, "fsf_issued", "%011lu:%06lu", t
.tv_sec
, t
.tv_nsec
);
1028 if (strncmp(r
->tag
, "rslt", ZFCP_DBF_TAG_SIZE
) == 0) {
1029 zfcp_dbf_out(&p
, "fcp_rsp_validity", "0x%02x", r
->rsp_validity
);
1030 zfcp_dbf_out(&p
, "fcp_rsp_scsi_status", "0x%02x",
1031 r
->rsp_scsi_status
);
1032 zfcp_dbf_out(&p
, "fcp_rsp_resid", "0x%08x", r
->rsp_resid
);
1033 zfcp_dbf_out(&p
, "fcp_rsp_code", "0x%08x", r
->rsp_code
);
1034 zfcp_dbf_out(&p
, "fcp_sns_info_len", "0x%08x", r
->sns_info_len
);
1035 zfcp_dbf_outd(&p
, "fcp_sns_info", r
->sns_info
,
1036 min((int)r
->sns_info_len
,
1037 ZFCP_DBF_SCSI_FCP_SNS_INFO
), 0,
1040 p
+= sprintf(p
, "\n");
1044 static struct debug_view zfcp_scsi_dbf_view
= {
1047 &zfcp_dbf_view_header
,
1048 &zfcp_scsi_dbf_view_format
,
1053 static debug_info_t
*zfcp_dbf_reg(const char *name
, int level
,
1054 struct debug_view
*view
, int size
)
1056 struct debug_info
*d
;
1058 d
= debug_register(name
, dbfsize
, level
, size
);
1062 debug_register_view(d
, &debug_hex_ascii_view
);
1063 debug_register_view(d
, view
);
1064 debug_set_level(d
, level
);
1070 * zfcp_adapter_debug_register - registers debug feature for an adapter
1071 * @adapter: pointer to adapter for which debug features should be registered
1072 * return: -ENOMEM on error, 0 otherwise
1074 int zfcp_adapter_debug_register(struct zfcp_adapter
*adapter
)
1076 char dbf_name
[DEBUG_MAX_NAME_LEN
];
1077 struct zfcp_dbf
*dbf
;
1079 dbf
= kmalloc(sizeof(struct zfcp_dbf
), GFP_KERNEL
);
1083 spin_lock_init(&dbf
->hba_dbf_lock
);
1084 spin_lock_init(&dbf
->san_dbf_lock
);
1085 spin_lock_init(&dbf
->scsi_dbf_lock
);
1086 spin_lock_init(&dbf
->rec_dbf_lock
);
1088 /* debug feature area which records recovery activity */
1089 sprintf(dbf_name
, "zfcp_%s_rec", dev_name(&adapter
->ccw_device
->dev
));
1090 dbf
->rec_dbf
= zfcp_dbf_reg(dbf_name
, 3, &zfcp_rec_dbf_view
,
1091 sizeof(struct zfcp_rec_dbf_record
));
1095 /* debug feature area which records HBA (FSF and QDIO) conditions */
1096 sprintf(dbf_name
, "zfcp_%s_hba", dev_name(&adapter
->ccw_device
->dev
));
1097 dbf
->hba_dbf
= zfcp_dbf_reg(dbf_name
, 3, &zfcp_hba_dbf_view
,
1098 sizeof(struct zfcp_hba_dbf_record
));
1102 /* debug feature area which records SAN command failures and recovery */
1103 sprintf(dbf_name
, "zfcp_%s_san", dev_name(&adapter
->ccw_device
->dev
));
1104 dbf
->san_dbf
= zfcp_dbf_reg(dbf_name
, 6, &zfcp_san_dbf_view
,
1105 sizeof(struct zfcp_san_dbf_record
));
1109 /* debug feature area which records SCSI command failures and recovery */
1110 sprintf(dbf_name
, "zfcp_%s_scsi", dev_name(&adapter
->ccw_device
->dev
));
1111 dbf
->scsi_dbf
= zfcp_dbf_reg(dbf_name
, 3, &zfcp_scsi_dbf_view
,
1112 sizeof(struct zfcp_scsi_dbf_record
));
1120 debug_unregister(dbf
->san_dbf
);
1122 debug_unregister(dbf
->hba_dbf
);
1124 debug_unregister(dbf
->rec_dbf
);
1131 * zfcp_adapter_debug_unregister - unregisters debug feature for an adapter
1132 * @adapter: pointer to adapter for which debug features should be unregistered
1134 void zfcp_adapter_debug_unregister(struct zfcp_adapter
*adapter
)
1136 debug_unregister(adapter
->dbf
->scsi_dbf
);
1137 debug_unregister(adapter
->dbf
->san_dbf
);
1138 debug_unregister(adapter
->dbf
->hba_dbf
);
1139 debug_unregister(adapter
->dbf
->rec_dbf
);
1140 kfree(adapter
->dbf
);
1141 adapter
->dbf
= NULL
;