Commit | Line | Data |
---|---|---|
8a36e453 | 1 | /* |
553448f6 | 2 | * zfcp device driver |
8a36e453 | 3 | * |
553448f6 | 4 | * Debug traces for zfcp. |
8a36e453 | 5 | * |
d46f384a | 6 | * Copyright IBM Corporation 2002, 2009 |
8a36e453 MS |
7 | */ |
8 | ||
ecf39d42 CS |
9 | #define KMSG_COMPONENT "zfcp" |
10 | #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt | |
11 | ||
8a36e453 | 12 | #include <linux/ctype.h> |
5a0e3ad6 | 13 | #include <linux/slab.h> |
364c8558 | 14 | #include <asm/debug.h> |
d46f384a | 15 | #include "zfcp_dbf.h" |
8a36e453 | 16 | #include "zfcp_ext.h" |
bd0072ec | 17 | #include "zfcp_fc.h" |
8a36e453 MS |
18 | |
19 | static u32 dbfsize = 4; | |
20 | ||
21 | module_param(dbfsize, uint, 0400); | |
22 | MODULE_PARM_DESC(dbfsize, | |
23 | "number of pages for each debug feature area (default 4)"); | |
24 | ||
c15450e3 MP |
25 | static void zfcp_dbf_hexdump(debug_info_t *dbf, void *to, int to_len, |
26 | int level, char *from, int from_len) | |
27 | { | |
28 | int offset; | |
29 | struct zfcp_dbf_dump *dump = to; | |
30 | int room = to_len - sizeof(*dump); | |
31 | ||
32 | for (offset = 0; offset < from_len; offset += dump->size) { | |
33 | memset(to, 0, to_len); | |
34 | strncpy(dump->tag, "dump", ZFCP_DBF_TAG_SIZE); | |
35 | dump->total_size = from_len; | |
36 | dump->offset = offset; | |
37 | dump->size = min(from_len - offset, room); | |
38 | memcpy(dump->data, from + offset, dump->size); | |
d94ce6c6 | 39 | debug_event(dbf, level, dump, dump->size + sizeof(*dump)); |
c15450e3 MP |
40 | } |
41 | } | |
42 | ||
a9c85775 | 43 | static void zfcp_dbf_tag(char **p, const char *label, const char *tag) |
8a36e453 | 44 | { |
a9c85775 | 45 | int i; |
8a36e453 | 46 | |
a9c85775 | 47 | *p += sprintf(*p, "%-24s", label); |
8a36e453 | 48 | for (i = 0; i < ZFCP_DBF_TAG_SIZE; i++) |
a9c85775 MP |
49 | *p += sprintf(*p, "%c", tag[i]); |
50 | *p += sprintf(*p, "\n"); | |
8a36e453 MS |
51 | } |
52 | ||
10223c60 MP |
53 | static void zfcp_dbf_outs(char **buf, const char *s1, const char *s2) |
54 | { | |
55 | *buf += sprintf(*buf, "%-24s%s\n", s1, s2); | |
56 | } | |
57 | ||
58 | static void zfcp_dbf_out(char **buf, const char *s, const char *format, ...) | |
59 | { | |
60 | va_list arg; | |
61 | ||
62 | *buf += sprintf(*buf, "%-24s", s); | |
63 | va_start(arg, format); | |
64 | *buf += vsprintf(*buf, format, arg); | |
65 | va_end(arg); | |
66 | *buf += sprintf(*buf, "\n"); | |
67 | } | |
68 | ||
df29f4ac MP |
69 | static void zfcp_dbf_outd(char **p, const char *label, char *buffer, |
70 | int buflen, int offset, int total_size) | |
8a36e453 | 71 | { |
df29f4ac MP |
72 | if (!offset) |
73 | *p += sprintf(*p, "%-24s ", label); | |
8a36e453 MS |
74 | while (buflen--) { |
75 | if (offset > 0) { | |
76 | if ((offset % 32) == 0) | |
df29f4ac | 77 | *p += sprintf(*p, "\n%-24c ", ' '); |
8a36e453 | 78 | else if ((offset % 4) == 0) |
df29f4ac | 79 | *p += sprintf(*p, " "); |
8a36e453 | 80 | } |
df29f4ac | 81 | *p += sprintf(*p, "%02x", *buffer++); |
8a36e453 | 82 | if (++offset == total_size) { |
df29f4ac | 83 | *p += sprintf(*p, "\n"); |
8a36e453 MS |
84 | break; |
85 | } | |
86 | } | |
df29f4ac MP |
87 | if (!total_size) |
88 | *p += sprintf(*p, "\n"); | |
8a36e453 MS |
89 | } |
90 | ||
92c7a83f MP |
91 | static int zfcp_dbf_view_header(debug_info_t *id, struct debug_view *view, |
92 | int area, debug_entry_t *entry, char *out_buf) | |
8a36e453 MS |
93 | { |
94 | struct zfcp_dbf_dump *dump = (struct zfcp_dbf_dump *)DEBUG_DATA(entry); | |
8fc5af16 | 95 | struct timespec t; |
b634fff7 | 96 | char *p = out_buf; |
8a36e453 MS |
97 | |
98 | if (strncmp(dump->tag, "dump", ZFCP_DBF_TAG_SIZE) != 0) { | |
b592e89a | 99 | stck_to_timespec(entry->id.stck, &t); |
b634fff7 MP |
100 | zfcp_dbf_out(&p, "timestamp", "%011lu:%06lu", |
101 | t.tv_sec, t.tv_nsec); | |
102 | zfcp_dbf_out(&p, "cpu", "%02i", entry->id.fields.cpuid); | |
103 | } else { | |
d94ce6c6 | 104 | zfcp_dbf_outd(&p, "", dump->data, dump->size, dump->offset, |
df29f4ac | 105 | dump->total_size); |
8a36e453 | 106 | if ((dump->offset + dump->size) == dump->total_size) |
b634fff7 | 107 | p += sprintf(p, "\n"); |
8a36e453 | 108 | } |
b634fff7 | 109 | return p - out_buf; |
8a36e453 MS |
110 | } |
111 | ||
5771710b SS |
112 | void _zfcp_dbf_hba_fsf_response(const char *tag2, int level, |
113 | struct zfcp_fsf_req *fsf_req, | |
114 | struct zfcp_dbf *dbf) | |
8a36e453 | 115 | { |
8a36e453 MS |
116 | struct fsf_qtcb *qtcb = fsf_req->qtcb; |
117 | union fsf_prot_status_qual *prot_status_qual = | |
92c7a83f | 118 | &qtcb->prefix.prot_status_qual; |
8a36e453 MS |
119 | union fsf_status_qual *fsf_status_qual = &qtcb->header.fsf_status_qual; |
120 | struct scsi_cmnd *scsi_cmnd; | |
121 | struct zfcp_port *port; | |
122 | struct zfcp_unit *unit; | |
123 | struct zfcp_send_els *send_els; | |
5771710b SS |
124 | struct zfcp_dbf_hba_record *rec = &dbf->hba_buf; |
125 | struct zfcp_dbf_hba_record_response *response = &rec->u.response; | |
8a36e453 MS |
126 | unsigned long flags; |
127 | ||
5771710b | 128 | spin_lock_irqsave(&dbf->hba_lock, flags); |
6bc473dd | 129 | memset(rec, 0, sizeof(*rec)); |
8a36e453 | 130 | strncpy(rec->tag, "resp", ZFCP_DBF_TAG_SIZE); |
2e261af8 | 131 | strncpy(rec->tag2, tag2, ZFCP_DBF_TAG_SIZE); |
8a36e453 MS |
132 | |
133 | response->fsf_command = fsf_req->fsf_command; | |
f0216ae9 | 134 | response->fsf_reqid = fsf_req->req_id; |
8a36e453 MS |
135 | response->fsf_seqno = fsf_req->seq_no; |
136 | response->fsf_issued = fsf_req->issued; | |
137 | response->fsf_prot_status = qtcb->prefix.prot_status; | |
138 | response->fsf_status = qtcb->header.fsf_status; | |
139 | memcpy(response->fsf_prot_status_qual, | |
140 | prot_status_qual, FSF_PROT_STATUS_QUAL_SIZE); | |
141 | memcpy(response->fsf_status_qual, | |
142 | fsf_status_qual, FSF_STATUS_QUALIFIER_SIZE); | |
143 | response->fsf_req_status = fsf_req->status; | |
34c2b712 CS |
144 | response->sbal_first = fsf_req->qdio_req.sbal_first; |
145 | response->sbal_last = fsf_req->qdio_req.sbal_last; | |
146 | response->sbal_response = fsf_req->qdio_req.sbal_response; | |
8a36e453 MS |
147 | response->pool = fsf_req->pool != NULL; |
148 | response->erp_action = (unsigned long)fsf_req->erp_action; | |
149 | ||
150 | switch (fsf_req->fsf_command) { | |
151 | case FSF_QTCB_FCP_CMND: | |
152 | if (fsf_req->status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT) | |
153 | break; | |
154 | scsi_cmnd = (struct scsi_cmnd *)fsf_req->data; | |
6bc473dd MP |
155 | if (scsi_cmnd) { |
156 | response->u.fcp.cmnd = (unsigned long)scsi_cmnd; | |
ef3eb71d FB |
157 | response->u.fcp.data_dir = |
158 | qtcb->bottom.io.data_direction; | |
8a36e453 MS |
159 | } |
160 | break; | |
161 | ||
162 | case FSF_QTCB_OPEN_PORT_WITH_DID: | |
163 | case FSF_QTCB_CLOSE_PORT: | |
164 | case FSF_QTCB_CLOSE_PHYSICAL_PORT: | |
165 | port = (struct zfcp_port *)fsf_req->data; | |
6bc473dd MP |
166 | response->u.port.wwpn = port->wwpn; |
167 | response->u.port.d_id = port->d_id; | |
168 | response->u.port.port_handle = qtcb->header.port_handle; | |
8a36e453 MS |
169 | break; |
170 | ||
171 | case FSF_QTCB_OPEN_LUN: | |
172 | case FSF_QTCB_CLOSE_LUN: | |
173 | unit = (struct zfcp_unit *)fsf_req->data; | |
174 | port = unit->port; | |
6bc473dd MP |
175 | response->u.unit.wwpn = port->wwpn; |
176 | response->u.unit.fcp_lun = unit->fcp_lun; | |
177 | response->u.unit.port_handle = qtcb->header.port_handle; | |
178 | response->u.unit.lun_handle = qtcb->header.lun_handle; | |
8a36e453 MS |
179 | break; |
180 | ||
181 | case FSF_QTCB_SEND_ELS: | |
182 | send_els = (struct zfcp_send_els *)fsf_req->data; | |
800c0cad | 183 | response->u.els.d_id = ntoh24(qtcb->bottom.support.d_id); |
8a36e453 MS |
184 | break; |
185 | ||
186 | case FSF_QTCB_ABORT_FCP_CMND: | |
187 | case FSF_QTCB_SEND_GENERIC: | |
188 | case FSF_QTCB_EXCHANGE_CONFIG_DATA: | |
189 | case FSF_QTCB_EXCHANGE_PORT_DATA: | |
190 | case FSF_QTCB_DOWNLOAD_CONTROL_FILE: | |
191 | case FSF_QTCB_UPLOAD_CONTROL_FILE: | |
192 | break; | |
193 | } | |
194 | ||
5771710b | 195 | debug_event(dbf->hba, level, rec, sizeof(*rec)); |
b75db731 MP |
196 | |
197 | /* have fcp channel microcode fixed to use as little as possible */ | |
198 | if (fsf_req->fsf_command != FSF_QTCB_FCP_CMND) { | |
199 | /* adjust length skipping trailing zeros */ | |
200 | char *buf = (char *)qtcb + qtcb->header.log_start; | |
201 | int len = qtcb->header.log_length; | |
202 | for (; len && !buf[len - 1]; len--); | |
5771710b | 203 | zfcp_dbf_hexdump(dbf->hba, rec, sizeof(*rec), level, buf, |
d46f384a | 204 | len); |
b75db731 MP |
205 | } |
206 | ||
5771710b | 207 | spin_unlock_irqrestore(&dbf->hba_lock, flags); |
8a36e453 MS |
208 | } |
209 | ||
5771710b SS |
210 | void _zfcp_dbf_hba_fsf_unsol(const char *tag, int level, struct zfcp_dbf *dbf, |
211 | struct fsf_status_read_buffer *status_buffer) | |
8a36e453 | 212 | { |
5771710b | 213 | struct zfcp_dbf_hba_record *rec = &dbf->hba_buf; |
8a36e453 MS |
214 | unsigned long flags; |
215 | ||
5771710b | 216 | spin_lock_irqsave(&dbf->hba_lock, flags); |
6bc473dd | 217 | memset(rec, 0, sizeof(*rec)); |
8a36e453 MS |
218 | strncpy(rec->tag, "stat", ZFCP_DBF_TAG_SIZE); |
219 | strncpy(rec->tag2, tag, ZFCP_DBF_TAG_SIZE); | |
220 | ||
5771710b | 221 | rec->u.status.failed = atomic_read(&dbf->adapter->stat_miss); |
8a36e453 | 222 | if (status_buffer != NULL) { |
6bc473dd MP |
223 | rec->u.status.status_type = status_buffer->status_type; |
224 | rec->u.status.status_subtype = status_buffer->status_subtype; | |
225 | memcpy(&rec->u.status.queue_designator, | |
8a36e453 MS |
226 | &status_buffer->queue_designator, |
227 | sizeof(struct fsf_queue_designator)); | |
228 | ||
229 | switch (status_buffer->status_type) { | |
230 | case FSF_STATUS_READ_SENSE_DATA_AVAIL: | |
6bc473dd | 231 | rec->u.status.payload_size = |
8a36e453 MS |
232 | ZFCP_DBF_UNSOL_PAYLOAD_SENSE_DATA_AVAIL; |
233 | break; | |
234 | ||
235 | case FSF_STATUS_READ_BIT_ERROR_THRESHOLD: | |
6bc473dd | 236 | rec->u.status.payload_size = |
8a36e453 MS |
237 | ZFCP_DBF_UNSOL_PAYLOAD_BIT_ERROR_THRESHOLD; |
238 | break; | |
239 | ||
240 | case FSF_STATUS_READ_LINK_DOWN: | |
aef4a983 MS |
241 | switch (status_buffer->status_subtype) { |
242 | case FSF_STATUS_READ_SUB_NO_PHYSICAL_LINK: | |
243 | case FSF_STATUS_READ_SUB_FDISC_FAILED: | |
6bc473dd | 244 | rec->u.status.payload_size = |
aef4a983 MS |
245 | sizeof(struct fsf_link_down_info); |
246 | } | |
8a36e453 MS |
247 | break; |
248 | ||
aef4a983 | 249 | case FSF_STATUS_READ_FEATURE_UPDATE_ALERT: |
6bc473dd | 250 | rec->u.status.payload_size = |
aef4a983 MS |
251 | ZFCP_DBF_UNSOL_PAYLOAD_FEATURE_UPDATE_ALERT; |
252 | break; | |
8a36e453 | 253 | } |
6bc473dd MP |
254 | memcpy(&rec->u.status.payload, |
255 | &status_buffer->payload, rec->u.status.payload_size); | |
8a36e453 MS |
256 | } |
257 | ||
5771710b SS |
258 | debug_event(dbf->hba, level, rec, sizeof(*rec)); |
259 | spin_unlock_irqrestore(&dbf->hba_lock, flags); | |
8a36e453 MS |
260 | } |
261 | ||
bfab1637 | 262 | /** |
5771710b | 263 | * zfcp_dbf_hba_qdio - trace event for QDIO related failure |
564e1c86 | 264 | * @qdio: qdio structure affected by this QDIO related event |
bfab1637 | 265 | * @qdio_error: as passed by qdio module |
bfab1637 MP |
266 | * @sbal_index: first buffer with error condition, as passed by qdio module |
267 | * @sbal_count: number of buffers affected, as passed by qdio module | |
268 | */ | |
5771710b SS |
269 | void zfcp_dbf_hba_qdio(struct zfcp_dbf *dbf, unsigned int qdio_error, |
270 | int sbal_index, int sbal_count) | |
8a36e453 | 271 | { |
5771710b | 272 | struct zfcp_dbf_hba_record *r = &dbf->hba_buf; |
8a36e453 MS |
273 | unsigned long flags; |
274 | ||
5771710b | 275 | spin_lock_irqsave(&dbf->hba_lock, flags); |
6bc473dd MP |
276 | memset(r, 0, sizeof(*r)); |
277 | strncpy(r->tag, "qdio", ZFCP_DBF_TAG_SIZE); | |
6bc473dd | 278 | r->u.qdio.qdio_error = qdio_error; |
6bc473dd MP |
279 | r->u.qdio.sbal_index = sbal_index; |
280 | r->u.qdio.sbal_count = sbal_count; | |
5771710b SS |
281 | debug_event(dbf->hba, 0, r, sizeof(*r)); |
282 | spin_unlock_irqrestore(&dbf->hba_lock, flags); | |
8a36e453 MS |
283 | } |
284 | ||
57069386 | 285 | /** |
5771710b SS |
286 | * zfcp_dbf_hba_berr - trace event for bit error threshold |
287 | * @dbf: dbf structure affected by this QDIO related event | |
57069386 SS |
288 | * @req: fsf request |
289 | */ | |
5771710b | 290 | void zfcp_dbf_hba_berr(struct zfcp_dbf *dbf, struct zfcp_fsf_req *req) |
57069386 | 291 | { |
5771710b | 292 | struct zfcp_dbf_hba_record *r = &dbf->hba_buf; |
57069386 SS |
293 | struct fsf_status_read_buffer *sr_buf = req->data; |
294 | struct fsf_bit_error_payload *err = &sr_buf->payload.bit_error; | |
295 | unsigned long flags; | |
296 | ||
5771710b | 297 | spin_lock_irqsave(&dbf->hba_lock, flags); |
57069386 SS |
298 | memset(r, 0, sizeof(*r)); |
299 | strncpy(r->tag, "berr", ZFCP_DBF_TAG_SIZE); | |
300 | memcpy(&r->u.berr, err, sizeof(struct fsf_bit_error_payload)); | |
5771710b SS |
301 | debug_event(dbf->hba, 0, r, sizeof(*r)); |
302 | spin_unlock_irqrestore(&dbf->hba_lock, flags); | |
57069386 | 303 | } |
5771710b SS |
304 | static void zfcp_dbf_hba_view_response(char **p, |
305 | struct zfcp_dbf_hba_record_response *r) | |
8a36e453 | 306 | { |
8fc5af16 | 307 | struct timespec t; |
8a36e453 | 308 | |
a9c85775 MP |
309 | zfcp_dbf_out(p, "fsf_command", "0x%08x", r->fsf_command); |
310 | zfcp_dbf_out(p, "fsf_reqid", "0x%0Lx", r->fsf_reqid); | |
311 | zfcp_dbf_out(p, "fsf_seqno", "0x%08x", r->fsf_seqno); | |
b592e89a | 312 | stck_to_timespec(r->fsf_issued, &t); |
a9c85775 MP |
313 | zfcp_dbf_out(p, "fsf_issued", "%011lu:%06lu", t.tv_sec, t.tv_nsec); |
314 | zfcp_dbf_out(p, "fsf_prot_status", "0x%08x", r->fsf_prot_status); | |
315 | zfcp_dbf_out(p, "fsf_status", "0x%08x", r->fsf_status); | |
316 | zfcp_dbf_outd(p, "fsf_prot_status_qual", r->fsf_prot_status_qual, | |
df29f4ac | 317 | FSF_PROT_STATUS_QUAL_SIZE, 0, FSF_PROT_STATUS_QUAL_SIZE); |
a9c85775 | 318 | zfcp_dbf_outd(p, "fsf_status_qual", r->fsf_status_qual, |
df29f4ac | 319 | FSF_STATUS_QUALIFIER_SIZE, 0, FSF_STATUS_QUALIFIER_SIZE); |
a9c85775 MP |
320 | zfcp_dbf_out(p, "fsf_req_status", "0x%08x", r->fsf_req_status); |
321 | zfcp_dbf_out(p, "sbal_first", "0x%02x", r->sbal_first); | |
e891bffe | 322 | zfcp_dbf_out(p, "sbal_last", "0x%02x", r->sbal_last); |
c3baa9a2 | 323 | zfcp_dbf_out(p, "sbal_response", "0x%02x", r->sbal_response); |
a9c85775 | 324 | zfcp_dbf_out(p, "pool", "0x%02x", r->pool); |
b634fff7 MP |
325 | |
326 | switch (r->fsf_command) { | |
8a36e453 | 327 | case FSF_QTCB_FCP_CMND: |
b634fff7 | 328 | if (r->fsf_req_status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT) |
8a36e453 | 329 | break; |
ef3eb71d | 330 | zfcp_dbf_out(p, "data_direction", "0x%04x", r->u.fcp.data_dir); |
6bc473dd | 331 | zfcp_dbf_out(p, "scsi_cmnd", "0x%0Lx", r->u.fcp.cmnd); |
5a3fb308 | 332 | *p += sprintf(*p, "\n"); |
8a36e453 MS |
333 | break; |
334 | ||
335 | case FSF_QTCB_OPEN_PORT_WITH_DID: | |
336 | case FSF_QTCB_CLOSE_PORT: | |
337 | case FSF_QTCB_CLOSE_PHYSICAL_PORT: | |
6bc473dd MP |
338 | zfcp_dbf_out(p, "wwpn", "0x%016Lx", r->u.port.wwpn); |
339 | zfcp_dbf_out(p, "d_id", "0x%06x", r->u.port.d_id); | |
340 | zfcp_dbf_out(p, "port_handle", "0x%08x", r->u.port.port_handle); | |
8a36e453 MS |
341 | break; |
342 | ||
343 | case FSF_QTCB_OPEN_LUN: | |
344 | case FSF_QTCB_CLOSE_LUN: | |
6bc473dd MP |
345 | zfcp_dbf_out(p, "wwpn", "0x%016Lx", r->u.unit.wwpn); |
346 | zfcp_dbf_out(p, "fcp_lun", "0x%016Lx", r->u.unit.fcp_lun); | |
347 | zfcp_dbf_out(p, "port_handle", "0x%08x", r->u.unit.port_handle); | |
348 | zfcp_dbf_out(p, "lun_handle", "0x%08x", r->u.unit.lun_handle); | |
8a36e453 MS |
349 | break; |
350 | ||
351 | case FSF_QTCB_SEND_ELS: | |
6bc473dd | 352 | zfcp_dbf_out(p, "d_id", "0x%06x", r->u.els.d_id); |
8a36e453 MS |
353 | break; |
354 | ||
355 | case FSF_QTCB_ABORT_FCP_CMND: | |
356 | case FSF_QTCB_SEND_GENERIC: | |
357 | case FSF_QTCB_EXCHANGE_CONFIG_DATA: | |
358 | case FSF_QTCB_EXCHANGE_PORT_DATA: | |
359 | case FSF_QTCB_DOWNLOAD_CONTROL_FILE: | |
360 | case FSF_QTCB_UPLOAD_CONTROL_FILE: | |
361 | break; | |
362 | } | |
8a36e453 MS |
363 | } |
364 | ||
5771710b SS |
365 | static void zfcp_dbf_hba_view_status(char **p, |
366 | struct zfcp_dbf_hba_record_status *r) | |
8a36e453 | 367 | { |
a9c85775 MP |
368 | zfcp_dbf_out(p, "failed", "0x%02x", r->failed); |
369 | zfcp_dbf_out(p, "status_type", "0x%08x", r->status_type); | |
370 | zfcp_dbf_out(p, "status_subtype", "0x%08x", r->status_subtype); | |
371 | zfcp_dbf_outd(p, "queue_designator", (char *)&r->queue_designator, | |
df29f4ac MP |
372 | sizeof(struct fsf_queue_designator), 0, |
373 | sizeof(struct fsf_queue_designator)); | |
a9c85775 | 374 | zfcp_dbf_outd(p, "payload", (char *)&r->payload, r->payload_size, 0, |
df29f4ac | 375 | r->payload_size); |
8a36e453 MS |
376 | } |
377 | ||
5771710b | 378 | static void zfcp_dbf_hba_view_qdio(char **p, struct zfcp_dbf_hba_record_qdio *r) |
8a36e453 | 379 | { |
a9c85775 | 380 | zfcp_dbf_out(p, "qdio_error", "0x%08x", r->qdio_error); |
a9c85775 MP |
381 | zfcp_dbf_out(p, "sbal_index", "0x%02x", r->sbal_index); |
382 | zfcp_dbf_out(p, "sbal_count", "0x%02x", r->sbal_count); | |
8a36e453 MS |
383 | } |
384 | ||
5771710b | 385 | static void zfcp_dbf_hba_view_berr(char **p, struct fsf_bit_error_payload *r) |
57069386 SS |
386 | { |
387 | zfcp_dbf_out(p, "link_failures", "%d", r->link_failure_error_count); | |
388 | zfcp_dbf_out(p, "loss_of_sync_err", "%d", r->loss_of_sync_error_count); | |
389 | zfcp_dbf_out(p, "loss_of_sig_err", "%d", r->loss_of_signal_error_count); | |
390 | zfcp_dbf_out(p, "prim_seq_err", "%d", | |
391 | r->primitive_sequence_error_count); | |
392 | zfcp_dbf_out(p, "inval_trans_word_err", "%d", | |
393 | r->invalid_transmission_word_error_count); | |
394 | zfcp_dbf_out(p, "CRC_errors", "%d", r->crc_error_count); | |
395 | zfcp_dbf_out(p, "prim_seq_event_to", "%d", | |
396 | r->primitive_sequence_event_timeout_count); | |
397 | zfcp_dbf_out(p, "elast_buf_overrun_err", "%d", | |
398 | r->elastic_buffer_overrun_error_count); | |
399 | zfcp_dbf_out(p, "adv_rec_buf2buf_cred", "%d", | |
400 | r->advertised_receive_b2b_credit); | |
401 | zfcp_dbf_out(p, "curr_rec_buf2buf_cred", "%d", | |
402 | r->current_receive_b2b_credit); | |
403 | zfcp_dbf_out(p, "adv_trans_buf2buf_cred", "%d", | |
404 | r->advertised_transmit_b2b_credit); | |
405 | zfcp_dbf_out(p, "curr_trans_buf2buf_cred", "%d", | |
406 | r->current_transmit_b2b_credit); | |
407 | } | |
408 | ||
5771710b | 409 | static int zfcp_dbf_hba_view_format(debug_info_t *id, struct debug_view *view, |
a9c85775 | 410 | char *out_buf, const char *in_buf) |
8a36e453 | 411 | { |
5771710b | 412 | struct zfcp_dbf_hba_record *r = (struct zfcp_dbf_hba_record *)in_buf; |
a9c85775 | 413 | char *p = out_buf; |
8a36e453 | 414 | |
a9c85775 | 415 | if (strncmp(r->tag, "dump", ZFCP_DBF_TAG_SIZE) == 0) |
8a36e453 MS |
416 | return 0; |
417 | ||
a9c85775 MP |
418 | zfcp_dbf_tag(&p, "tag", r->tag); |
419 | if (isalpha(r->tag2[0])) | |
420 | zfcp_dbf_tag(&p, "tag2", r->tag2); | |
421 | ||
422 | if (strncmp(r->tag, "resp", ZFCP_DBF_TAG_SIZE) == 0) | |
5771710b | 423 | zfcp_dbf_hba_view_response(&p, &r->u.response); |
a9c85775 | 424 | else if (strncmp(r->tag, "stat", ZFCP_DBF_TAG_SIZE) == 0) |
5771710b | 425 | zfcp_dbf_hba_view_status(&p, &r->u.status); |
a9c85775 | 426 | else if (strncmp(r->tag, "qdio", ZFCP_DBF_TAG_SIZE) == 0) |
5771710b | 427 | zfcp_dbf_hba_view_qdio(&p, &r->u.qdio); |
57069386 | 428 | else if (strncmp(r->tag, "berr", ZFCP_DBF_TAG_SIZE) == 0) |
5771710b | 429 | zfcp_dbf_hba_view_berr(&p, &r->u.berr); |
a9c85775 | 430 | |
d94ce6c6 CS |
431 | if (strncmp(r->tag, "resp", ZFCP_DBF_TAG_SIZE) != 0) |
432 | p += sprintf(p, "\n"); | |
a9c85775 | 433 | return p - out_buf; |
8a36e453 MS |
434 | } |
435 | ||
5771710b SS |
436 | static struct debug_view zfcp_dbf_hba_view = { |
437 | .name = "structured", | |
438 | .header_proc = zfcp_dbf_view_header, | |
439 | .format_proc = zfcp_dbf_hba_view_format, | |
8a36e453 MS |
440 | }; |
441 | ||
5771710b | 442 | static const char *zfcp_dbf_rec_tags[] = { |
348447e8 | 443 | [ZFCP_REC_DBF_ID_THREAD] = "thread", |
698ec016 | 444 | [ZFCP_REC_DBF_ID_TARGET] = "target", |
9467a9b3 | 445 | [ZFCP_REC_DBF_ID_TRIGGER] = "trigger", |
6f4f365e | 446 | [ZFCP_REC_DBF_ID_ACTION] = "action", |
d79a83db MP |
447 | }; |
448 | ||
5771710b | 449 | static int zfcp_dbf_rec_view_format(debug_info_t *id, struct debug_view *view, |
d79a83db MP |
450 | char *buf, const char *_rec) |
451 | { | |
5771710b | 452 | struct zfcp_dbf_rec_record *r = (struct zfcp_dbf_rec_record *)_rec; |
d79a83db | 453 | char *p = buf; |
5ffd51a5 | 454 | char hint[ZFCP_DBF_ID_SIZE + 1]; |
d79a83db | 455 | |
5ffd51a5 SS |
456 | memcpy(hint, r->id2, ZFCP_DBF_ID_SIZE); |
457 | hint[ZFCP_DBF_ID_SIZE] = 0; | |
5771710b | 458 | zfcp_dbf_outs(&p, "tag", zfcp_dbf_rec_tags[r->id]); |
5ffd51a5 | 459 | zfcp_dbf_outs(&p, "hint", hint); |
d79a83db | 460 | switch (r->id) { |
348447e8 | 461 | case ZFCP_REC_DBF_ID_THREAD: |
348447e8 MP |
462 | zfcp_dbf_out(&p, "total", "%d", r->u.thread.total); |
463 | zfcp_dbf_out(&p, "ready", "%d", r->u.thread.ready); | |
464 | zfcp_dbf_out(&p, "running", "%d", r->u.thread.running); | |
465 | break; | |
698ec016 MP |
466 | case ZFCP_REC_DBF_ID_TARGET: |
467 | zfcp_dbf_out(&p, "reference", "0x%016Lx", r->u.target.ref); | |
468 | zfcp_dbf_out(&p, "status", "0x%08x", r->u.target.status); | |
469 | zfcp_dbf_out(&p, "erp_count", "%d", r->u.target.erp_count); | |
470 | zfcp_dbf_out(&p, "d_id", "0x%06x", r->u.target.d_id); | |
471 | zfcp_dbf_out(&p, "wwpn", "0x%016Lx", r->u.target.wwpn); | |
472 | zfcp_dbf_out(&p, "fcp_lun", "0x%016Lx", r->u.target.fcp_lun); | |
473 | break; | |
9467a9b3 MP |
474 | case ZFCP_REC_DBF_ID_TRIGGER: |
475 | zfcp_dbf_out(&p, "reference", "0x%016Lx", r->u.trigger.ref); | |
476 | zfcp_dbf_out(&p, "erp_action", "0x%016Lx", r->u.trigger.action); | |
477 | zfcp_dbf_out(&p, "requested", "%d", r->u.trigger.want); | |
478 | zfcp_dbf_out(&p, "executed", "%d", r->u.trigger.need); | |
479 | zfcp_dbf_out(&p, "wwpn", "0x%016Lx", r->u.trigger.wwpn); | |
480 | zfcp_dbf_out(&p, "fcp_lun", "0x%016Lx", r->u.trigger.fcp_lun); | |
481 | zfcp_dbf_out(&p, "adapter_status", "0x%08x", r->u.trigger.as); | |
482 | zfcp_dbf_out(&p, "port_status", "0x%08x", r->u.trigger.ps); | |
b62a8d9b | 483 | zfcp_dbf_out(&p, "lun_status", "0x%08x", r->u.trigger.ls); |
9467a9b3 | 484 | break; |
6f4f365e MP |
485 | case ZFCP_REC_DBF_ID_ACTION: |
486 | zfcp_dbf_out(&p, "erp_action", "0x%016Lx", r->u.action.action); | |
487 | zfcp_dbf_out(&p, "fsf_req", "0x%016Lx", r->u.action.fsf_req); | |
488 | zfcp_dbf_out(&p, "status", "0x%08Lx", r->u.action.status); | |
489 | zfcp_dbf_out(&p, "step", "0x%08Lx", r->u.action.step); | |
490 | break; | |
d79a83db | 491 | } |
b634fff7 MP |
492 | p += sprintf(p, "\n"); |
493 | return p - buf; | |
d79a83db MP |
494 | } |
495 | ||
5771710b SS |
496 | static struct debug_view zfcp_dbf_rec_view = { |
497 | .name = "structured", | |
498 | .header_proc = zfcp_dbf_view_header, | |
499 | .format_proc = zfcp_dbf_rec_view_format, | |
d79a83db MP |
500 | }; |
501 | ||
348447e8 | 502 | /** |
5771710b | 503 | * zfcp_dbf_rec_thread - trace event related to recovery thread operation |
348447e8 | 504 | * @id2: identifier for event |
5771710b | 505 | * @dbf: reference to dbf structure |
aa0fec62 | 506 | * This function assumes that the caller is holding erp_lock. |
348447e8 | 507 | */ |
5771710b | 508 | void zfcp_dbf_rec_thread(char *id2, struct zfcp_dbf *dbf) |
348447e8 | 509 | { |
5771710b SS |
510 | struct zfcp_adapter *adapter = dbf->adapter; |
511 | struct zfcp_dbf_rec_record *r = &dbf->rec_buf; | |
348447e8 MP |
512 | unsigned long flags = 0; |
513 | struct list_head *entry; | |
514 | unsigned ready = 0, running = 0, total; | |
515 | ||
348447e8 MP |
516 | list_for_each(entry, &adapter->erp_ready_head) |
517 | ready++; | |
518 | list_for_each(entry, &adapter->erp_running_head) | |
519 | running++; | |
520 | total = adapter->erp_total_count; | |
348447e8 | 521 | |
5771710b | 522 | spin_lock_irqsave(&dbf->rec_lock, flags); |
348447e8 MP |
523 | memset(r, 0, sizeof(*r)); |
524 | r->id = ZFCP_REC_DBF_ID_THREAD; | |
5ffd51a5 | 525 | memcpy(r->id2, id2, ZFCP_DBF_ID_SIZE); |
348447e8 MP |
526 | r->u.thread.total = total; |
527 | r->u.thread.ready = ready; | |
528 | r->u.thread.running = running; | |
5771710b SS |
529 | debug_event(dbf->rec, 6, r, sizeof(*r)); |
530 | spin_unlock_irqrestore(&dbf->rec_lock, flags); | |
348447e8 MP |
531 | } |
532 | ||
aa0fec62 | 533 | /** |
5771710b | 534 | * zfcp_dbf_rec_thread - trace event related to recovery thread operation |
aa0fec62 CS |
535 | * @id2: identifier for event |
536 | * @adapter: adapter | |
537 | * This function assumes that the caller does not hold erp_lock. | |
538 | */ | |
5771710b | 539 | void zfcp_dbf_rec_thread_lock(char *id2, struct zfcp_dbf *dbf) |
aa0fec62 | 540 | { |
5771710b | 541 | struct zfcp_adapter *adapter = dbf->adapter; |
aa0fec62 CS |
542 | unsigned long flags; |
543 | ||
544 | read_lock_irqsave(&adapter->erp_lock, flags); | |
5771710b | 545 | zfcp_dbf_rec_thread(id2, dbf); |
aa0fec62 CS |
546 | read_unlock_irqrestore(&adapter->erp_lock, flags); |
547 | } | |
548 | ||
5771710b SS |
549 | static void zfcp_dbf_rec_target(char *id2, void *ref, struct zfcp_dbf *dbf, |
550 | atomic_t *status, atomic_t *erp_count, u64 wwpn, | |
551 | u32 d_id, u64 fcp_lun) | |
698ec016 | 552 | { |
5771710b | 553 | struct zfcp_dbf_rec_record *r = &dbf->rec_buf; |
698ec016 MP |
554 | unsigned long flags; |
555 | ||
5771710b | 556 | spin_lock_irqsave(&dbf->rec_lock, flags); |
698ec016 MP |
557 | memset(r, 0, sizeof(*r)); |
558 | r->id = ZFCP_REC_DBF_ID_TARGET; | |
5ffd51a5 | 559 | memcpy(r->id2, id2, ZFCP_DBF_ID_SIZE); |
1f6f7129 | 560 | r->u.target.ref = (unsigned long)ref; |
698ec016 MP |
561 | r->u.target.status = atomic_read(status); |
562 | r->u.target.wwpn = wwpn; | |
563 | r->u.target.d_id = d_id; | |
564 | r->u.target.fcp_lun = fcp_lun; | |
565 | r->u.target.erp_count = atomic_read(erp_count); | |
5771710b SS |
566 | debug_event(dbf->rec, 3, r, sizeof(*r)); |
567 | spin_unlock_irqrestore(&dbf->rec_lock, flags); | |
698ec016 MP |
568 | } |
569 | ||
570 | /** | |
5771710b | 571 | * zfcp_dbf_rec_adapter - trace event for adapter state change |
698ec016 MP |
572 | * @id: identifier for trigger of state change |
573 | * @ref: additional reference (e.g. request) | |
5771710b | 574 | * @dbf: reference to dbf structure |
698ec016 | 575 | */ |
5771710b | 576 | void zfcp_dbf_rec_adapter(char *id, void *ref, struct zfcp_dbf *dbf) |
698ec016 | 577 | { |
5771710b SS |
578 | struct zfcp_adapter *adapter = dbf->adapter; |
579 | ||
580 | zfcp_dbf_rec_target(id, ref, dbf, &adapter->status, | |
d21e9daa CS |
581 | &adapter->erp_counter, 0, 0, |
582 | ZFCP_DBF_INVALID_LUN); | |
698ec016 MP |
583 | } |
584 | ||
585 | /** | |
5771710b | 586 | * zfcp_dbf_rec_port - trace event for port state change |
698ec016 MP |
587 | * @id: identifier for trigger of state change |
588 | * @ref: additional reference (e.g. request) | |
589 | * @port: port | |
590 | */ | |
5771710b | 591 | void zfcp_dbf_rec_port(char *id, void *ref, struct zfcp_port *port) |
698ec016 | 592 | { |
5771710b | 593 | struct zfcp_dbf *dbf = port->adapter->dbf; |
698ec016 | 594 | |
5771710b | 595 | zfcp_dbf_rec_target(id, ref, dbf, &port->status, |
d21e9daa CS |
596 | &port->erp_counter, port->wwpn, port->d_id, |
597 | ZFCP_DBF_INVALID_LUN); | |
698ec016 MP |
598 | } |
599 | ||
600 | /** | |
b62a8d9b | 601 | * zfcp_dbf_rec_lun - trace event for LUN state change |
698ec016 MP |
602 | * @id: identifier for trigger of state change |
603 | * @ref: additional reference (e.g. request) | |
b62a8d9b | 604 | * @sdev: SCSI device |
698ec016 | 605 | */ |
b62a8d9b | 606 | void zfcp_dbf_rec_lun(char *id, void *ref, struct scsi_device *sdev) |
698ec016 | 607 | { |
b62a8d9b CS |
608 | struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev); |
609 | struct zfcp_port *port = zfcp_sdev->port; | |
5771710b | 610 | struct zfcp_dbf *dbf = port->adapter->dbf; |
698ec016 | 611 | |
b62a8d9b CS |
612 | zfcp_dbf_rec_target(id, ref, dbf, &zfcp_sdev->status, |
613 | &zfcp_sdev->erp_counter, port->wwpn, port->d_id, | |
614 | zfcp_scsi_dev_lun(sdev)); | |
698ec016 MP |
615 | } |
616 | ||
9467a9b3 | 617 | /** |
5771710b | 618 | * zfcp_dbf_rec_trigger - trace event for triggered error recovery |
9467a9b3 MP |
619 | * @id2: identifier for error recovery trigger |
620 | * @ref: additional reference (e.g. request) | |
621 | * @want: originally requested error recovery action | |
622 | * @need: error recovery action actually initiated | |
623 | * @action: address of error recovery action struct | |
624 | * @adapter: adapter | |
625 | * @port: port | |
b62a8d9b | 626 | * @sdev: SCSI device |
9467a9b3 | 627 | */ |
5771710b SS |
628 | void zfcp_dbf_rec_trigger(char *id2, void *ref, u8 want, u8 need, void *action, |
629 | struct zfcp_adapter *adapter, struct zfcp_port *port, | |
b62a8d9b | 630 | struct scsi_device *sdev) |
9467a9b3 | 631 | { |
d46f384a | 632 | struct zfcp_dbf *dbf = adapter->dbf; |
5771710b | 633 | struct zfcp_dbf_rec_record *r = &dbf->rec_buf; |
9467a9b3 MP |
634 | unsigned long flags; |
635 | ||
5771710b | 636 | spin_lock_irqsave(&dbf->rec_lock, flags); |
9467a9b3 MP |
637 | memset(r, 0, sizeof(*r)); |
638 | r->id = ZFCP_REC_DBF_ID_TRIGGER; | |
5ffd51a5 | 639 | memcpy(r->id2, id2, ZFCP_DBF_ID_SIZE); |
1f6f7129 | 640 | r->u.trigger.ref = (unsigned long)ref; |
9467a9b3 MP |
641 | r->u.trigger.want = want; |
642 | r->u.trigger.need = need; | |
1f6f7129 | 643 | r->u.trigger.action = (unsigned long)action; |
9467a9b3 MP |
644 | r->u.trigger.as = atomic_read(&adapter->status); |
645 | if (port) { | |
646 | r->u.trigger.ps = atomic_read(&port->status); | |
647 | r->u.trigger.wwpn = port->wwpn; | |
648 | } | |
b62a8d9b CS |
649 | if (sdev) |
650 | r->u.trigger.ls = atomic_read(&sdev_to_zfcp(sdev)->status); | |
651 | r->u.trigger.fcp_lun = sdev ? zfcp_scsi_dev_lun(sdev) : | |
652 | ZFCP_DBF_INVALID_LUN; | |
5771710b SS |
653 | debug_event(dbf->rec, action ? 1 : 4, r, sizeof(*r)); |
654 | spin_unlock_irqrestore(&dbf->rec_lock, flags); | |
9467a9b3 MP |
655 | } |
656 | ||
6f4f365e | 657 | /** |
5771710b | 658 | * zfcp_dbf_rec_action - trace event showing progress of recovery action |
6f4f365e MP |
659 | * @id2: identifier |
660 | * @erp_action: error recovery action struct pointer | |
661 | */ | |
5771710b | 662 | void zfcp_dbf_rec_action(char *id2, struct zfcp_erp_action *erp_action) |
6f4f365e | 663 | { |
5771710b SS |
664 | struct zfcp_dbf *dbf = erp_action->adapter->dbf; |
665 | struct zfcp_dbf_rec_record *r = &dbf->rec_buf; | |
6f4f365e MP |
666 | unsigned long flags; |
667 | ||
5771710b | 668 | spin_lock_irqsave(&dbf->rec_lock, flags); |
6f4f365e MP |
669 | memset(r, 0, sizeof(*r)); |
670 | r->id = ZFCP_REC_DBF_ID_ACTION; | |
5ffd51a5 | 671 | memcpy(r->id2, id2, ZFCP_DBF_ID_SIZE); |
1f6f7129 | 672 | r->u.action.action = (unsigned long)erp_action; |
6f4f365e MP |
673 | r->u.action.status = erp_action->status; |
674 | r->u.action.step = erp_action->step; | |
e60a6d69 | 675 | r->u.action.fsf_req = erp_action->fsf_req_id; |
5771710b SS |
676 | debug_event(dbf->rec, 5, r, sizeof(*r)); |
677 | spin_unlock_irqrestore(&dbf->rec_lock, flags); | |
6f4f365e MP |
678 | } |
679 | ||
bfab1637 | 680 | /** |
5771710b | 681 | * zfcp_dbf_san_ct_request - trace event for issued CT request |
bfab1637 | 682 | * @fsf_req: request containing issued CT data |
7c7dc196 | 683 | * @d_id: destination id where ct request is sent to |
bfab1637 | 684 | */ |
7c7dc196 | 685 | void zfcp_dbf_san_ct_request(struct zfcp_fsf_req *fsf_req, u32 d_id) |
8a36e453 | 686 | { |
7c7dc196 CS |
687 | struct zfcp_fsf_ct_els *ct = (struct zfcp_fsf_ct_els *)fsf_req->data; |
688 | struct zfcp_adapter *adapter = fsf_req->adapter; | |
d46f384a | 689 | struct zfcp_dbf *dbf = adapter->dbf; |
dbf5dfe9 | 690 | struct fc_ct_hdr *hdr = sg_virt(ct->req); |
5771710b SS |
691 | struct zfcp_dbf_san_record *r = &dbf->san_buf; |
692 | struct zfcp_dbf_san_record_ct_request *oct = &r->u.ct_req; | |
d94ce6c6 | 693 | int level = 3; |
6bc473dd | 694 | unsigned long flags; |
8a36e453 | 695 | |
5771710b | 696 | spin_lock_irqsave(&dbf->san_lock, flags); |
6bc473dd MP |
697 | memset(r, 0, sizeof(*r)); |
698 | strncpy(r->tag, "octc", ZFCP_DBF_TAG_SIZE); | |
f0216ae9 | 699 | r->fsf_reqid = fsf_req->req_id; |
6bc473dd | 700 | r->fsf_seqno = fsf_req->seq_no; |
7c7dc196 | 701 | oct->d_id = d_id; |
dbf5dfe9 CS |
702 | oct->cmd_req_code = hdr->ct_cmd; |
703 | oct->revision = hdr->ct_rev; | |
704 | oct->gs_type = hdr->ct_fs_type; | |
705 | oct->gs_subtype = hdr->ct_fs_subtype; | |
706 | oct->options = hdr->ct_options; | |
707 | oct->max_res_size = hdr->ct_mr_size; | |
708 | oct->len = min((int)ct->req->length - (int)sizeof(struct fc_ct_hdr), | |
d94ce6c6 | 709 | ZFCP_DBF_SAN_MAX_PAYLOAD); |
5771710b SS |
710 | debug_event(dbf->san, level, r, sizeof(*r)); |
711 | zfcp_dbf_hexdump(dbf->san, r, sizeof(*r), level, | |
dbf5dfe9 | 712 | (void *)hdr + sizeof(struct fc_ct_hdr), oct->len); |
5771710b | 713 | spin_unlock_irqrestore(&dbf->san_lock, flags); |
8a36e453 MS |
714 | } |
715 | ||
bfab1637 | 716 | /** |
5771710b | 717 | * zfcp_dbf_san_ct_response - trace event for completion of CT request |
bfab1637 MP |
718 | * @fsf_req: request containing CT response |
719 | */ | |
5771710b | 720 | void zfcp_dbf_san_ct_response(struct zfcp_fsf_req *fsf_req) |
8a36e453 | 721 | { |
7c7dc196 CS |
722 | struct zfcp_fsf_ct_els *ct = (struct zfcp_fsf_ct_els *)fsf_req->data; |
723 | struct zfcp_adapter *adapter = fsf_req->adapter; | |
dbf5dfe9 | 724 | struct fc_ct_hdr *hdr = sg_virt(ct->resp); |
d46f384a | 725 | struct zfcp_dbf *dbf = adapter->dbf; |
5771710b SS |
726 | struct zfcp_dbf_san_record *r = &dbf->san_buf; |
727 | struct zfcp_dbf_san_record_ct_response *rct = &r->u.ct_resp; | |
d94ce6c6 | 728 | int level = 3; |
6bc473dd | 729 | unsigned long flags; |
8a36e453 | 730 | |
5771710b | 731 | spin_lock_irqsave(&dbf->san_lock, flags); |
6bc473dd MP |
732 | memset(r, 0, sizeof(*r)); |
733 | strncpy(r->tag, "rctc", ZFCP_DBF_TAG_SIZE); | |
f0216ae9 | 734 | r->fsf_reqid = fsf_req->req_id; |
6bc473dd | 735 | r->fsf_seqno = fsf_req->seq_no; |
dbf5dfe9 CS |
736 | rct->cmd_rsp_code = hdr->ct_cmd; |
737 | rct->revision = hdr->ct_rev; | |
738 | rct->reason_code = hdr->ct_reason; | |
739 | rct->expl = hdr->ct_explan; | |
740 | rct->vendor_unique = hdr->ct_vendor; | |
741 | rct->max_res_size = hdr->ct_mr_size; | |
742 | rct->len = min((int)ct->resp->length - (int)sizeof(struct fc_ct_hdr), | |
d94ce6c6 | 743 | ZFCP_DBF_SAN_MAX_PAYLOAD); |
5771710b SS |
744 | debug_event(dbf->san, level, r, sizeof(*r)); |
745 | zfcp_dbf_hexdump(dbf->san, r, sizeof(*r), level, | |
dbf5dfe9 | 746 | (void *)hdr + sizeof(struct fc_ct_hdr), rct->len); |
5771710b | 747 | spin_unlock_irqrestore(&dbf->san_lock, flags); |
8a36e453 MS |
748 | } |
749 | ||
5771710b | 750 | static void zfcp_dbf_san_els(const char *tag, int level, |
7c7dc196 CS |
751 | struct zfcp_fsf_req *fsf_req, u32 d_id, |
752 | void *buffer, int buflen) | |
8a36e453 MS |
753 | { |
754 | struct zfcp_adapter *adapter = fsf_req->adapter; | |
d46f384a | 755 | struct zfcp_dbf *dbf = adapter->dbf; |
5771710b | 756 | struct zfcp_dbf_san_record *rec = &dbf->san_buf; |
8a36e453 | 757 | unsigned long flags; |
8a36e453 | 758 | |
5771710b | 759 | spin_lock_irqsave(&dbf->san_lock, flags); |
6bc473dd | 760 | memset(rec, 0, sizeof(*rec)); |
0f65e951 | 761 | strncpy(rec->tag, tag, ZFCP_DBF_TAG_SIZE); |
f0216ae9 | 762 | rec->fsf_reqid = fsf_req->req_id; |
0f65e951 | 763 | rec->fsf_seqno = fsf_req->seq_no; |
7c7dc196 | 764 | rec->u.els.d_id = d_id; |
5771710b SS |
765 | debug_event(dbf->san, level, rec, sizeof(*rec)); |
766 | zfcp_dbf_hexdump(dbf->san, rec, sizeof(*rec), level, | |
d94ce6c6 | 767 | buffer, min(buflen, ZFCP_DBF_SAN_MAX_PAYLOAD)); |
5771710b | 768 | spin_unlock_irqrestore(&dbf->san_lock, flags); |
8a36e453 MS |
769 | } |
770 | ||
bfab1637 | 771 | /** |
5771710b | 772 | * zfcp_dbf_san_els_request - trace event for issued ELS |
bfab1637 MP |
773 | * @fsf_req: request containing issued ELS |
774 | */ | |
5771710b | 775 | void zfcp_dbf_san_els_request(struct zfcp_fsf_req *fsf_req) |
8a36e453 | 776 | { |
7c7dc196 CS |
777 | struct zfcp_fsf_ct_els *els = (struct zfcp_fsf_ct_els *)fsf_req->data; |
778 | u32 d_id = ntoh24(fsf_req->qtcb->bottom.support.d_id); | |
8a36e453 | 779 | |
7c7dc196 CS |
780 | zfcp_dbf_san_els("oels", 2, fsf_req, d_id, |
781 | sg_virt(els->req), els->req->length); | |
8a36e453 MS |
782 | } |
783 | ||
bfab1637 | 784 | /** |
5771710b | 785 | * zfcp_dbf_san_els_response - trace event for completed ELS |
bfab1637 MP |
786 | * @fsf_req: request containing ELS response |
787 | */ | |
5771710b | 788 | void zfcp_dbf_san_els_response(struct zfcp_fsf_req *fsf_req) |
8a36e453 | 789 | { |
7c7dc196 CS |
790 | struct zfcp_fsf_ct_els *els = (struct zfcp_fsf_ct_els *)fsf_req->data; |
791 | u32 d_id = ntoh24(fsf_req->qtcb->bottom.support.d_id); | |
8a36e453 | 792 | |
7c7dc196 CS |
793 | zfcp_dbf_san_els("rels", 2, fsf_req, d_id, |
794 | sg_virt(els->resp), els->resp->length); | |
8a36e453 MS |
795 | } |
796 | ||
bfab1637 | 797 | /** |
5771710b | 798 | * zfcp_dbf_san_incoming_els - trace event for incomig ELS |
bfab1637 MP |
799 | * @fsf_req: request containing unsolicited status buffer with incoming ELS |
800 | */ | |
5771710b | 801 | void zfcp_dbf_san_incoming_els(struct zfcp_fsf_req *fsf_req) |
8a36e453 | 802 | { |
92c7a83f MP |
803 | struct fsf_status_read_buffer *buf = |
804 | (struct fsf_status_read_buffer *)fsf_req->data; | |
805 | int length = (int)buf->length - | |
806 | (int)((void *)&buf->payload - (void *)buf); | |
807 | ||
800c0cad | 808 | zfcp_dbf_san_els("iels", 1, fsf_req, ntoh24(buf->d_id), |
7c7dc196 | 809 | (void *)buf->payload.data, length); |
8a36e453 MS |
810 | } |
811 | ||
5771710b | 812 | static int zfcp_dbf_san_view_format(debug_info_t *id, struct debug_view *view, |
92c7a83f | 813 | char *out_buf, const char *in_buf) |
8a36e453 | 814 | { |
5771710b | 815 | struct zfcp_dbf_san_record *r = (struct zfcp_dbf_san_record *)in_buf; |
b634fff7 | 816 | char *p = out_buf; |
8a36e453 | 817 | |
b634fff7 | 818 | if (strncmp(r->tag, "dump", ZFCP_DBF_TAG_SIZE) == 0) |
8a36e453 MS |
819 | return 0; |
820 | ||
a9c85775 | 821 | zfcp_dbf_tag(&p, "tag", r->tag); |
b634fff7 MP |
822 | zfcp_dbf_out(&p, "fsf_reqid", "0x%0Lx", r->fsf_reqid); |
823 | zfcp_dbf_out(&p, "fsf_seqno", "0x%08x", r->fsf_seqno); | |
b634fff7 MP |
824 | |
825 | if (strncmp(r->tag, "octc", ZFCP_DBF_TAG_SIZE) == 0) { | |
5771710b | 826 | struct zfcp_dbf_san_record_ct_request *ct = &r->u.ct_req; |
7c7dc196 | 827 | zfcp_dbf_out(&p, "d_id", "0x%06x", ct->d_id); |
6bc473dd MP |
828 | zfcp_dbf_out(&p, "cmd_req_code", "0x%04x", ct->cmd_req_code); |
829 | zfcp_dbf_out(&p, "revision", "0x%02x", ct->revision); | |
830 | zfcp_dbf_out(&p, "gs_type", "0x%02x", ct->gs_type); | |
831 | zfcp_dbf_out(&p, "gs_subtype", "0x%02x", ct->gs_subtype); | |
832 | zfcp_dbf_out(&p, "options", "0x%02x", ct->options); | |
833 | zfcp_dbf_out(&p, "max_res_size", "0x%04x", ct->max_res_size); | |
b634fff7 | 834 | } else if (strncmp(r->tag, "rctc", ZFCP_DBF_TAG_SIZE) == 0) { |
5771710b | 835 | struct zfcp_dbf_san_record_ct_response *ct = &r->u.ct_resp; |
6bc473dd MP |
836 | zfcp_dbf_out(&p, "cmd_rsp_code", "0x%04x", ct->cmd_rsp_code); |
837 | zfcp_dbf_out(&p, "revision", "0x%02x", ct->revision); | |
838 | zfcp_dbf_out(&p, "reason_code", "0x%02x", ct->reason_code); | |
839 | zfcp_dbf_out(&p, "reason_code_expl", "0x%02x", ct->expl); | |
840 | zfcp_dbf_out(&p, "vendor_unique", "0x%02x", ct->vendor_unique); | |
39eb7e9a | 841 | zfcp_dbf_out(&p, "max_res_size", "0x%04x", ct->max_res_size); |
b634fff7 MP |
842 | } else if (strncmp(r->tag, "oels", ZFCP_DBF_TAG_SIZE) == 0 || |
843 | strncmp(r->tag, "rels", ZFCP_DBF_TAG_SIZE) == 0 || | |
844 | strncmp(r->tag, "iels", ZFCP_DBF_TAG_SIZE) == 0) { | |
5771710b | 845 | struct zfcp_dbf_san_record_els *els = &r->u.els; |
7c7dc196 | 846 | zfcp_dbf_out(&p, "d_id", "0x%06x", els->d_id); |
8a36e453 | 847 | } |
b634fff7 | 848 | return p - out_buf; |
8a36e453 MS |
849 | } |
850 | ||
5771710b SS |
851 | static struct debug_view zfcp_dbf_san_view = { |
852 | .name = "structured", | |
853 | .header_proc = zfcp_dbf_view_header, | |
854 | .format_proc = zfcp_dbf_san_view_format, | |
8a36e453 MS |
855 | }; |
856 | ||
5771710b SS |
857 | void _zfcp_dbf_scsi(const char *tag, const char *tag2, int level, |
858 | struct zfcp_dbf *dbf, struct scsi_cmnd *scsi_cmnd, | |
859 | struct zfcp_fsf_req *fsf_req, unsigned long old_req_id) | |
8a36e453 | 860 | { |
5771710b | 861 | struct zfcp_dbf_scsi_record *rec = &dbf->scsi_buf; |
8a36e453 MS |
862 | struct zfcp_dbf_dump *dump = (struct zfcp_dbf_dump *)rec; |
863 | unsigned long flags; | |
4318e08c CS |
864 | struct fcp_resp_with_ext *fcp_rsp; |
865 | struct fcp_resp_rsp_info *fcp_rsp_info = NULL; | |
866 | char *fcp_sns_info = NULL; | |
8a36e453 MS |
867 | int offset = 0, buflen = 0; |
868 | ||
5771710b | 869 | spin_lock_irqsave(&dbf->scsi_lock, flags); |
8a36e453 | 870 | do { |
6bc473dd | 871 | memset(rec, 0, sizeof(*rec)); |
8a36e453 MS |
872 | if (offset == 0) { |
873 | strncpy(rec->tag, tag, ZFCP_DBF_TAG_SIZE); | |
874 | strncpy(rec->tag2, tag2, ZFCP_DBF_TAG_SIZE); | |
ed829ad6 MS |
875 | if (scsi_cmnd != NULL) { |
876 | if (scsi_cmnd->device) { | |
877 | rec->scsi_id = scsi_cmnd->device->id; | |
878 | rec->scsi_lun = scsi_cmnd->device->lun; | |
879 | } | |
880 | rec->scsi_result = scsi_cmnd->result; | |
881 | rec->scsi_cmnd = (unsigned long)scsi_cmnd; | |
64a87b24 | 882 | memcpy(rec->scsi_opcode, scsi_cmnd->cmnd, |
ed829ad6 MS |
883 | min((int)scsi_cmnd->cmd_len, |
884 | ZFCP_DBF_SCSI_OPCODE)); | |
885 | rec->scsi_retries = scsi_cmnd->retries; | |
886 | rec->scsi_allowed = scsi_cmnd->allowed; | |
8a36e453 | 887 | } |
8a36e453 | 888 | if (fsf_req != NULL) { |
4318e08c CS |
889 | fcp_rsp = (struct fcp_resp_with_ext *) |
890 | &(fsf_req->qtcb->bottom.io.fcp_rsp); | |
891 | fcp_rsp_info = (struct fcp_resp_rsp_info *) | |
892 | &fcp_rsp[1]; | |
893 | fcp_sns_info = (char *) &fcp_rsp[1]; | |
894 | if (fcp_rsp->resp.fr_flags & FCP_RSP_LEN_VAL) | |
895 | fcp_sns_info += fcp_rsp->ext.fr_sns_len; | |
896 | ||
897 | rec->rsp_validity = fcp_rsp->resp.fr_flags; | |
898 | rec->rsp_scsi_status = fcp_rsp->resp.fr_status; | |
899 | rec->rsp_resid = fcp_rsp->ext.fr_resid; | |
900 | if (fcp_rsp->resp.fr_flags & FCP_RSP_LEN_VAL) | |
901 | rec->rsp_code = fcp_rsp_info->rsp_code; | |
902 | if (fcp_rsp->resp.fr_flags & FCP_SNS_LEN_VAL) { | |
903 | buflen = min(fcp_rsp->ext.fr_sns_len, | |
904 | (u32)ZFCP_DBF_SCSI_MAX_FCP_SNS_INFO); | |
6bc473dd MP |
905 | rec->sns_info_len = buflen; |
906 | memcpy(rec->sns_info, fcp_sns_info, | |
8a36e453 MS |
907 | min(buflen, |
908 | ZFCP_DBF_SCSI_FCP_SNS_INFO)); | |
909 | offset += min(buflen, | |
910 | ZFCP_DBF_SCSI_FCP_SNS_INFO); | |
911 | } | |
912 | ||
f0216ae9 | 913 | rec->fsf_reqid = fsf_req->req_id; |
8a36e453 MS |
914 | rec->fsf_seqno = fsf_req->seq_no; |
915 | rec->fsf_issued = fsf_req->issued; | |
916 | } | |
6bc473dd | 917 | rec->old_fsf_reqid = old_req_id; |
8a36e453 MS |
918 | } else { |
919 | strncpy(dump->tag, "dump", ZFCP_DBF_TAG_SIZE); | |
920 | dump->total_size = buflen; | |
921 | dump->offset = offset; | |
922 | dump->size = min(buflen - offset, | |
923 | (int)sizeof(struct | |
5771710b | 924 | zfcp_dbf_scsi_record) - |
8a36e453 MS |
925 | (int)sizeof(struct zfcp_dbf_dump)); |
926 | memcpy(dump->data, fcp_sns_info + offset, dump->size); | |
927 | offset += dump->size; | |
928 | } | |
5771710b | 929 | debug_event(dbf->scsi, level, rec, sizeof(*rec)); |
8a36e453 | 930 | } while (offset < buflen); |
5771710b | 931 | spin_unlock_irqrestore(&dbf->scsi_lock, flags); |
8a36e453 MS |
932 | } |
933 | ||
5771710b | 934 | static int zfcp_dbf_scsi_view_format(debug_info_t *id, struct debug_view *view, |
92c7a83f | 935 | char *out_buf, const char *in_buf) |
8a36e453 | 936 | { |
5771710b | 937 | struct zfcp_dbf_scsi_record *r = (struct zfcp_dbf_scsi_record *)in_buf; |
8fc5af16 | 938 | struct timespec t; |
b634fff7 | 939 | char *p = out_buf; |
8a36e453 | 940 | |
b634fff7 | 941 | if (strncmp(r->tag, "dump", ZFCP_DBF_TAG_SIZE) == 0) |
8a36e453 MS |
942 | return 0; |
943 | ||
a9c85775 MP |
944 | zfcp_dbf_tag(&p, "tag", r->tag); |
945 | zfcp_dbf_tag(&p, "tag2", r->tag2); | |
b634fff7 MP |
946 | zfcp_dbf_out(&p, "scsi_id", "0x%08x", r->scsi_id); |
947 | zfcp_dbf_out(&p, "scsi_lun", "0x%08x", r->scsi_lun); | |
948 | zfcp_dbf_out(&p, "scsi_result", "0x%08x", r->scsi_result); | |
949 | zfcp_dbf_out(&p, "scsi_cmnd", "0x%0Lx", r->scsi_cmnd); | |
df29f4ac MP |
950 | zfcp_dbf_outd(&p, "scsi_opcode", r->scsi_opcode, ZFCP_DBF_SCSI_OPCODE, |
951 | 0, ZFCP_DBF_SCSI_OPCODE); | |
b634fff7 MP |
952 | zfcp_dbf_out(&p, "scsi_retries", "0x%02x", r->scsi_retries); |
953 | zfcp_dbf_out(&p, "scsi_allowed", "0x%02x", r->scsi_allowed); | |
954 | if (strncmp(r->tag, "abrt", ZFCP_DBF_TAG_SIZE) == 0) | |
6bc473dd | 955 | zfcp_dbf_out(&p, "old_fsf_reqid", "0x%0Lx", r->old_fsf_reqid); |
b634fff7 MP |
956 | zfcp_dbf_out(&p, "fsf_reqid", "0x%0Lx", r->fsf_reqid); |
957 | zfcp_dbf_out(&p, "fsf_seqno", "0x%08x", r->fsf_seqno); | |
b592e89a | 958 | stck_to_timespec(r->fsf_issued, &t); |
b634fff7 MP |
959 | zfcp_dbf_out(&p, "fsf_issued", "%011lu:%06lu", t.tv_sec, t.tv_nsec); |
960 | ||
961 | if (strncmp(r->tag, "rslt", ZFCP_DBF_TAG_SIZE) == 0) { | |
6bc473dd MP |
962 | zfcp_dbf_out(&p, "fcp_rsp_validity", "0x%02x", r->rsp_validity); |
963 | zfcp_dbf_out(&p, "fcp_rsp_scsi_status", "0x%02x", | |
964 | r->rsp_scsi_status); | |
965 | zfcp_dbf_out(&p, "fcp_rsp_resid", "0x%08x", r->rsp_resid); | |
966 | zfcp_dbf_out(&p, "fcp_rsp_code", "0x%08x", r->rsp_code); | |
967 | zfcp_dbf_out(&p, "fcp_sns_info_len", "0x%08x", r->sns_info_len); | |
968 | zfcp_dbf_outd(&p, "fcp_sns_info", r->sns_info, | |
969 | min((int)r->sns_info_len, | |
df29f4ac | 970 | ZFCP_DBF_SCSI_FCP_SNS_INFO), 0, |
6bc473dd | 971 | r->sns_info_len); |
8a36e453 | 972 | } |
b634fff7 MP |
973 | p += sprintf(p, "\n"); |
974 | return p - out_buf; | |
8a36e453 MS |
975 | } |
976 | ||
5771710b SS |
977 | static struct debug_view zfcp_dbf_scsi_view = { |
978 | .name = "structured", | |
979 | .header_proc = zfcp_dbf_view_header, | |
980 | .format_proc = zfcp_dbf_scsi_view_format, | |
8a36e453 MS |
981 | }; |
982 | ||
d46f384a CS |
983 | static debug_info_t *zfcp_dbf_reg(const char *name, int level, |
984 | struct debug_view *view, int size) | |
985 | { | |
986 | struct debug_info *d; | |
987 | ||
988 | d = debug_register(name, dbfsize, level, size); | |
989 | if (!d) | |
990 | return NULL; | |
991 | ||
992 | debug_register_view(d, &debug_hex_ascii_view); | |
993 | debug_register_view(d, view); | |
994 | debug_set_level(d, level); | |
995 | ||
996 | return d; | |
997 | } | |
998 | ||
8a36e453 MS |
999 | /** |
1000 | * zfcp_adapter_debug_register - registers debug feature for an adapter | |
1001 | * @adapter: pointer to adapter for which debug features should be registered | |
1002 | * return: -ENOMEM on error, 0 otherwise | |
1003 | */ | |
5771710b | 1004 | int zfcp_dbf_adapter_register(struct zfcp_adapter *adapter) |
8a36e453 MS |
1005 | { |
1006 | char dbf_name[DEBUG_MAX_NAME_LEN]; | |
d46f384a CS |
1007 | struct zfcp_dbf *dbf; |
1008 | ||
d23948ea | 1009 | dbf = kzalloc(sizeof(struct zfcp_dbf), GFP_KERNEL); |
d46f384a CS |
1010 | if (!dbf) |
1011 | return -ENOMEM; | |
1012 | ||
5771710b SS |
1013 | dbf->adapter = adapter; |
1014 | ||
1015 | spin_lock_init(&dbf->hba_lock); | |
1016 | spin_lock_init(&dbf->san_lock); | |
1017 | spin_lock_init(&dbf->scsi_lock); | |
1018 | spin_lock_init(&dbf->rec_lock); | |
8a36e453 | 1019 | |
d79a83db | 1020 | /* debug feature area which records recovery activity */ |
b225cf9b | 1021 | sprintf(dbf_name, "zfcp_%s_rec", dev_name(&adapter->ccw_device->dev)); |
5771710b SS |
1022 | dbf->rec = zfcp_dbf_reg(dbf_name, 3, &zfcp_dbf_rec_view, |
1023 | sizeof(struct zfcp_dbf_rec_record)); | |
1024 | if (!dbf->rec) | |
1025 | goto err_out; | |
d79a83db | 1026 | |
8a36e453 | 1027 | /* debug feature area which records HBA (FSF and QDIO) conditions */ |
b225cf9b | 1028 | sprintf(dbf_name, "zfcp_%s_hba", dev_name(&adapter->ccw_device->dev)); |
5771710b SS |
1029 | dbf->hba = zfcp_dbf_reg(dbf_name, 3, &zfcp_dbf_hba_view, |
1030 | sizeof(struct zfcp_dbf_hba_record)); | |
1031 | if (!dbf->hba) | |
1032 | goto err_out; | |
8a36e453 MS |
1033 | |
1034 | /* debug feature area which records SAN command failures and recovery */ | |
b225cf9b | 1035 | sprintf(dbf_name, "zfcp_%s_san", dev_name(&adapter->ccw_device->dev)); |
5771710b SS |
1036 | dbf->san = zfcp_dbf_reg(dbf_name, 6, &zfcp_dbf_san_view, |
1037 | sizeof(struct zfcp_dbf_san_record)); | |
1038 | if (!dbf->san) | |
1039 | goto err_out; | |
8a36e453 MS |
1040 | |
1041 | /* debug feature area which records SCSI command failures and recovery */ | |
b225cf9b | 1042 | sprintf(dbf_name, "zfcp_%s_scsi", dev_name(&adapter->ccw_device->dev)); |
5771710b SS |
1043 | dbf->scsi = zfcp_dbf_reg(dbf_name, 3, &zfcp_dbf_scsi_view, |
1044 | sizeof(struct zfcp_dbf_scsi_record)); | |
1045 | if (!dbf->scsi) | |
1046 | goto err_out; | |
8a36e453 | 1047 | |
d46f384a | 1048 | adapter->dbf = dbf; |
8a36e453 MS |
1049 | return 0; |
1050 | ||
5771710b SS |
1051 | err_out: |
1052 | zfcp_dbf_adapter_unregister(dbf); | |
8a36e453 MS |
1053 | return -ENOMEM; |
1054 | } | |
1055 | ||
1056 | /** | |
1057 | * zfcp_adapter_debug_unregister - unregisters debug feature for an adapter | |
5771710b | 1058 | * @dbf: pointer to dbf for which debug features should be unregistered |
8a36e453 | 1059 | */ |
5771710b | 1060 | void zfcp_dbf_adapter_unregister(struct zfcp_dbf *dbf) |
8a36e453 | 1061 | { |
f3450c7b SS |
1062 | if (!dbf) |
1063 | return; | |
5771710b SS |
1064 | debug_unregister(dbf->scsi); |
1065 | debug_unregister(dbf->san); | |
1066 | debug_unregister(dbf->hba); | |
1067 | debug_unregister(dbf->rec); | |
1068 | dbf->adapter->dbf = NULL; | |
1069 | kfree(dbf); | |
8a36e453 | 1070 | } |
5771710b | 1071 |