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> |
364c8558 | 13 | #include <asm/debug.h> |
d46f384a | 14 | #include "zfcp_dbf.h" |
8a36e453 MS |
15 | #include "zfcp_ext.h" |
16 | ||
17 | static u32 dbfsize = 4; | |
18 | ||
19 | module_param(dbfsize, uint, 0400); | |
20 | MODULE_PARM_DESC(dbfsize, | |
21 | "number of pages for each debug feature area (default 4)"); | |
22 | ||
c15450e3 MP |
23 | static void zfcp_dbf_hexdump(debug_info_t *dbf, void *to, int to_len, |
24 | int level, char *from, int from_len) | |
25 | { | |
26 | int offset; | |
27 | struct zfcp_dbf_dump *dump = to; | |
28 | int room = to_len - sizeof(*dump); | |
29 | ||
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); | |
d94ce6c6 | 37 | debug_event(dbf, level, dump, dump->size + sizeof(*dump)); |
c15450e3 MP |
38 | } |
39 | } | |
40 | ||
8fc5af16 MP |
41 | /* FIXME: this duplicate this code in s390 debug feature */ |
42 | static void zfcp_dbf_timestamp(unsigned long long stck, struct timespec *time) | |
8a36e453 MS |
43 | { |
44 | unsigned long long sec; | |
8a36e453 MS |
45 | |
46 | stck -= 0x8126d60e46000000LL - (0x3c26700LL * 1000000 * 4096); | |
47 | sec = stck >> 12; | |
48 | do_div(sec, 1000000); | |
8fc5af16 | 49 | time->tv_sec = sec; |
8a36e453 | 50 | stck -= (sec * 1000000) << 12; |
8fc5af16 | 51 | time->tv_nsec = ((stck * 1000) >> 12); |
8a36e453 MS |
52 | } |
53 | ||
a9c85775 | 54 | static void zfcp_dbf_tag(char **p, const char *label, const char *tag) |
8a36e453 | 55 | { |
a9c85775 | 56 | int i; |
8a36e453 | 57 | |
a9c85775 | 58 | *p += sprintf(*p, "%-24s", label); |
8a36e453 | 59 | for (i = 0; i < ZFCP_DBF_TAG_SIZE; i++) |
a9c85775 MP |
60 | *p += sprintf(*p, "%c", tag[i]); |
61 | *p += sprintf(*p, "\n"); | |
8a36e453 MS |
62 | } |
63 | ||
10223c60 MP |
64 | static void zfcp_dbf_outs(char **buf, const char *s1, const char *s2) |
65 | { | |
66 | *buf += sprintf(*buf, "%-24s%s\n", s1, s2); | |
67 | } | |
68 | ||
69 | static void zfcp_dbf_out(char **buf, const char *s, const char *format, ...) | |
70 | { | |
71 | va_list arg; | |
72 | ||
73 | *buf += sprintf(*buf, "%-24s", s); | |
74 | va_start(arg, format); | |
75 | *buf += vsprintf(*buf, format, arg); | |
76 | va_end(arg); | |
77 | *buf += sprintf(*buf, "\n"); | |
78 | } | |
79 | ||
df29f4ac MP |
80 | static void zfcp_dbf_outd(char **p, const char *label, char *buffer, |
81 | int buflen, int offset, int total_size) | |
8a36e453 | 82 | { |
df29f4ac MP |
83 | if (!offset) |
84 | *p += sprintf(*p, "%-24s ", label); | |
8a36e453 MS |
85 | while (buflen--) { |
86 | if (offset > 0) { | |
87 | if ((offset % 32) == 0) | |
df29f4ac | 88 | *p += sprintf(*p, "\n%-24c ", ' '); |
8a36e453 | 89 | else if ((offset % 4) == 0) |
df29f4ac | 90 | *p += sprintf(*p, " "); |
8a36e453 | 91 | } |
df29f4ac | 92 | *p += sprintf(*p, "%02x", *buffer++); |
8a36e453 | 93 | if (++offset == total_size) { |
df29f4ac | 94 | *p += sprintf(*p, "\n"); |
8a36e453 MS |
95 | break; |
96 | } | |
97 | } | |
df29f4ac MP |
98 | if (!total_size) |
99 | *p += sprintf(*p, "\n"); | |
8a36e453 MS |
100 | } |
101 | ||
92c7a83f MP |
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) | |
8a36e453 MS |
104 | { |
105 | struct zfcp_dbf_dump *dump = (struct zfcp_dbf_dump *)DEBUG_DATA(entry); | |
8fc5af16 | 106 | struct timespec t; |
b634fff7 | 107 | char *p = out_buf; |
8a36e453 MS |
108 | |
109 | if (strncmp(dump->tag, "dump", ZFCP_DBF_TAG_SIZE) != 0) { | |
8fc5af16 | 110 | zfcp_dbf_timestamp(entry->id.stck, &t); |
b634fff7 MP |
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); | |
114 | } else { | |
d94ce6c6 | 115 | zfcp_dbf_outd(&p, "", dump->data, dump->size, dump->offset, |
df29f4ac | 116 | dump->total_size); |
8a36e453 | 117 | if ((dump->offset + dump->size) == dump->total_size) |
b634fff7 | 118 | p += sprintf(p, "\n"); |
8a36e453 | 119 | } |
b634fff7 | 120 | return p - out_buf; |
8a36e453 MS |
121 | } |
122 | ||
2e261af8 CS |
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) | |
8a36e453 | 126 | { |
8a36e453 MS |
127 | struct fsf_qtcb *qtcb = fsf_req->qtcb; |
128 | union fsf_prot_status_qual *prot_status_qual = | |
92c7a83f | 129 | &qtcb->prefix.prot_status_qual; |
8a36e453 MS |
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; | |
d46f384a | 135 | struct zfcp_hba_dbf_record *rec = &dbf->hba_dbf_buf; |
6bc473dd | 136 | struct zfcp_hba_dbf_record_response *response = &rec->u.response; |
8a36e453 MS |
137 | unsigned long flags; |
138 | ||
d46f384a | 139 | spin_lock_irqsave(&dbf->hba_dbf_lock, flags); |
6bc473dd | 140 | memset(rec, 0, sizeof(*rec)); |
8a36e453 | 141 | strncpy(rec->tag, "resp", ZFCP_DBF_TAG_SIZE); |
2e261af8 | 142 | strncpy(rec->tag2, tag2, ZFCP_DBF_TAG_SIZE); |
8a36e453 MS |
143 | |
144 | response->fsf_command = fsf_req->fsf_command; | |
f0216ae9 | 145 | response->fsf_reqid = fsf_req->req_id; |
8a36e453 MS |
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; | |
42428f74 SS |
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; | |
8a36e453 MS |
158 | response->pool = fsf_req->pool != NULL; |
159 | response->erp_action = (unsigned long)fsf_req->erp_action; | |
160 | ||
161 | switch (fsf_req->fsf_command) { | |
162 | case FSF_QTCB_FCP_CMND: | |
163 | if (fsf_req->status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT) | |
164 | break; | |
165 | scsi_cmnd = (struct scsi_cmnd *)fsf_req->data; | |
6bc473dd MP |
166 | if (scsi_cmnd) { |
167 | response->u.fcp.cmnd = (unsigned long)scsi_cmnd; | |
168 | response->u.fcp.serial = scsi_cmnd->serial_number; | |
8a36e453 MS |
169 | } |
170 | break; | |
171 | ||
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; | |
6bc473dd MP |
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; | |
8a36e453 MS |
179 | break; |
180 | ||
181 | case FSF_QTCB_OPEN_LUN: | |
182 | case FSF_QTCB_CLOSE_LUN: | |
183 | unit = (struct zfcp_unit *)fsf_req->data; | |
184 | port = unit->port; | |
6bc473dd MP |
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; | |
8a36e453 MS |
189 | break; |
190 | ||
191 | case FSF_QTCB_SEND_ELS: | |
192 | send_els = (struct zfcp_send_els *)fsf_req->data; | |
6bc473dd MP |
193 | response->u.els.d_id = qtcb->bottom.support.d_id; |
194 | response->u.els.ls_code = send_els->ls_code >> 24; | |
8a36e453 MS |
195 | break; |
196 | ||
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: | |
203 | break; | |
204 | } | |
205 | ||
d46f384a | 206 | debug_event(dbf->hba_dbf, level, rec, sizeof(*rec)); |
b75db731 MP |
207 | |
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--); | |
d46f384a CS |
214 | zfcp_dbf_hexdump(dbf->hba_dbf, rec, sizeof(*rec), level, buf, |
215 | len); | |
b75db731 MP |
216 | } |
217 | ||
d46f384a | 218 | spin_unlock_irqrestore(&dbf->hba_dbf_lock, flags); |
8a36e453 MS |
219 | } |
220 | ||
2e261af8 CS |
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) | |
8a36e453 | 224 | { |
d46f384a CS |
225 | struct zfcp_dbf *dbf = adapter->dbf; |
226 | struct zfcp_hba_dbf_record *rec = &dbf->hba_dbf_buf; | |
8a36e453 MS |
227 | unsigned long flags; |
228 | ||
d46f384a | 229 | spin_lock_irqsave(&dbf->hba_dbf_lock, flags); |
6bc473dd | 230 | memset(rec, 0, sizeof(*rec)); |
8a36e453 MS |
231 | strncpy(rec->tag, "stat", ZFCP_DBF_TAG_SIZE); |
232 | strncpy(rec->tag2, tag, ZFCP_DBF_TAG_SIZE); | |
233 | ||
d26ab06e | 234 | rec->u.status.failed = atomic_read(&adapter->stat_miss); |
8a36e453 | 235 | if (status_buffer != NULL) { |
6bc473dd MP |
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, | |
8a36e453 MS |
239 | &status_buffer->queue_designator, |
240 | sizeof(struct fsf_queue_designator)); | |
241 | ||
242 | switch (status_buffer->status_type) { | |
243 | case FSF_STATUS_READ_SENSE_DATA_AVAIL: | |
6bc473dd | 244 | rec->u.status.payload_size = |
8a36e453 MS |
245 | ZFCP_DBF_UNSOL_PAYLOAD_SENSE_DATA_AVAIL; |
246 | break; | |
247 | ||
248 | case FSF_STATUS_READ_BIT_ERROR_THRESHOLD: | |
6bc473dd | 249 | rec->u.status.payload_size = |
8a36e453 MS |
250 | ZFCP_DBF_UNSOL_PAYLOAD_BIT_ERROR_THRESHOLD; |
251 | break; | |
252 | ||
253 | case FSF_STATUS_READ_LINK_DOWN: | |
aef4a983 MS |
254 | switch (status_buffer->status_subtype) { |
255 | case FSF_STATUS_READ_SUB_NO_PHYSICAL_LINK: | |
256 | case FSF_STATUS_READ_SUB_FDISC_FAILED: | |
6bc473dd | 257 | rec->u.status.payload_size = |
aef4a983 MS |
258 | sizeof(struct fsf_link_down_info); |
259 | } | |
8a36e453 MS |
260 | break; |
261 | ||
aef4a983 | 262 | case FSF_STATUS_READ_FEATURE_UPDATE_ALERT: |
6bc473dd | 263 | rec->u.status.payload_size = |
aef4a983 MS |
264 | ZFCP_DBF_UNSOL_PAYLOAD_FEATURE_UPDATE_ALERT; |
265 | break; | |
8a36e453 | 266 | } |
6bc473dd MP |
267 | memcpy(&rec->u.status.payload, |
268 | &status_buffer->payload, rec->u.status.payload_size); | |
8a36e453 MS |
269 | } |
270 | ||
2e261af8 | 271 | debug_event(dbf->hba_dbf, level, rec, sizeof(*rec)); |
d46f384a | 272 | spin_unlock_irqrestore(&dbf->hba_dbf_lock, flags); |
8a36e453 MS |
273 | } |
274 | ||
bfab1637 MP |
275 | /** |
276 | * zfcp_hba_dbf_event_qdio - trace event for QDIO related failure | |
564e1c86 | 277 | * @qdio: qdio structure affected by this QDIO related event |
bfab1637 | 278 | * @qdio_error: as passed by qdio module |
bfab1637 MP |
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 | |
281 | */ | |
564e1c86 | 282 | void zfcp_hba_dbf_event_qdio(struct zfcp_qdio *qdio, |
779e6e1c JG |
283 | unsigned int qdio_error, int sbal_index, |
284 | int sbal_count) | |
8a36e453 | 285 | { |
564e1c86 | 286 | struct zfcp_dbf *dbf = qdio->adapter->dbf; |
d46f384a | 287 | struct zfcp_hba_dbf_record *r = &dbf->hba_dbf_buf; |
8a36e453 MS |
288 | unsigned long flags; |
289 | ||
d46f384a | 290 | spin_lock_irqsave(&dbf->hba_dbf_lock, flags); |
6bc473dd MP |
291 | memset(r, 0, sizeof(*r)); |
292 | strncpy(r->tag, "qdio", ZFCP_DBF_TAG_SIZE); | |
6bc473dd | 293 | r->u.qdio.qdio_error = qdio_error; |
6bc473dd MP |
294 | r->u.qdio.sbal_index = sbal_index; |
295 | r->u.qdio.sbal_count = sbal_count; | |
d46f384a CS |
296 | debug_event(dbf->hba_dbf, 0, r, sizeof(*r)); |
297 | spin_unlock_irqrestore(&dbf->hba_dbf_lock, flags); | |
8a36e453 MS |
298 | } |
299 | ||
57069386 SS |
300 | /** |
301 | * zfcp_hba_dbf_event_berr - trace event for bit error threshold | |
302 | * @adapter: adapter affected by this QDIO related event | |
303 | * @req: fsf request | |
304 | */ | |
305 | void zfcp_hba_dbf_event_berr(struct zfcp_adapter *adapter, | |
306 | struct zfcp_fsf_req *req) | |
307 | { | |
d46f384a CS |
308 | struct zfcp_dbf *dbf = adapter->dbf; |
309 | struct zfcp_hba_dbf_record *r = &dbf->hba_dbf_buf; | |
57069386 SS |
310 | struct fsf_status_read_buffer *sr_buf = req->data; |
311 | struct fsf_bit_error_payload *err = &sr_buf->payload.bit_error; | |
312 | unsigned long flags; | |
313 | ||
d46f384a | 314 | spin_lock_irqsave(&dbf->hba_dbf_lock, flags); |
57069386 SS |
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)); | |
d46f384a CS |
318 | debug_event(dbf->hba_dbf, 0, r, sizeof(*r)); |
319 | spin_unlock_irqrestore(&dbf->hba_dbf_lock, flags); | |
57069386 | 320 | } |
a9c85775 MP |
321 | static void zfcp_hba_dbf_view_response(char **p, |
322 | struct zfcp_hba_dbf_record_response *r) | |
8a36e453 | 323 | { |
8fc5af16 | 324 | struct timespec t; |
8a36e453 | 325 | |
a9c85775 MP |
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); | |
b634fff7 | 329 | zfcp_dbf_timestamp(r->fsf_issued, &t); |
a9c85775 MP |
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, | |
df29f4ac | 334 | FSF_PROT_STATUS_QUAL_SIZE, 0, FSF_PROT_STATUS_QUAL_SIZE); |
a9c85775 | 335 | zfcp_dbf_outd(p, "fsf_status_qual", r->fsf_status_qual, |
df29f4ac | 336 | FSF_STATUS_QUALIFIER_SIZE, 0, FSF_STATUS_QUALIFIER_SIZE); |
a9c85775 MP |
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); | |
e891bffe | 339 | zfcp_dbf_out(p, "sbal_last", "0x%02x", r->sbal_last); |
c3baa9a2 | 340 | zfcp_dbf_out(p, "sbal_response", "0x%02x", r->sbal_response); |
a9c85775 | 341 | zfcp_dbf_out(p, "pool", "0x%02x", r->pool); |
b634fff7 MP |
342 | |
343 | switch (r->fsf_command) { | |
8a36e453 | 344 | case FSF_QTCB_FCP_CMND: |
b634fff7 | 345 | if (r->fsf_req_status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT) |
8a36e453 | 346 | break; |
6bc473dd MP |
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); | |
d94ce6c6 | 349 | p += sprintf(*p, "\n"); |
8a36e453 MS |
350 | break; |
351 | ||
352 | case FSF_QTCB_OPEN_PORT_WITH_DID: | |
353 | case FSF_QTCB_CLOSE_PORT: | |
354 | case FSF_QTCB_CLOSE_PHYSICAL_PORT: | |
6bc473dd MP |
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); | |
8a36e453 MS |
358 | break; |
359 | ||
360 | case FSF_QTCB_OPEN_LUN: | |
361 | case FSF_QTCB_CLOSE_LUN: | |
6bc473dd MP |
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); | |
8a36e453 MS |
366 | break; |
367 | ||
368 | case FSF_QTCB_SEND_ELS: | |
6bc473dd MP |
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); | |
8a36e453 MS |
371 | break; |
372 | ||
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: | |
379 | break; | |
380 | } | |
8a36e453 MS |
381 | } |
382 | ||
a9c85775 MP |
383 | static void zfcp_hba_dbf_view_status(char **p, |
384 | struct zfcp_hba_dbf_record_status *r) | |
8a36e453 | 385 | { |
a9c85775 MP |
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, | |
df29f4ac MP |
390 | sizeof(struct fsf_queue_designator), 0, |
391 | sizeof(struct fsf_queue_designator)); | |
a9c85775 | 392 | zfcp_dbf_outd(p, "payload", (char *)&r->payload, r->payload_size, 0, |
df29f4ac | 393 | r->payload_size); |
8a36e453 MS |
394 | } |
395 | ||
a9c85775 | 396 | static void zfcp_hba_dbf_view_qdio(char **p, struct zfcp_hba_dbf_record_qdio *r) |
8a36e453 | 397 | { |
a9c85775 | 398 | zfcp_dbf_out(p, "qdio_error", "0x%08x", r->qdio_error); |
a9c85775 MP |
399 | zfcp_dbf_out(p, "sbal_index", "0x%02x", r->sbal_index); |
400 | zfcp_dbf_out(p, "sbal_count", "0x%02x", r->sbal_count); | |
8a36e453 MS |
401 | } |
402 | ||
57069386 SS |
403 | static void zfcp_hba_dbf_view_berr(char **p, struct fsf_bit_error_payload *r) |
404 | { | |
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); | |
425 | } | |
426 | ||
a9c85775 MP |
427 | static int zfcp_hba_dbf_view_format(debug_info_t *id, struct debug_view *view, |
428 | char *out_buf, const char *in_buf) | |
8a36e453 | 429 | { |
a9c85775 MP |
430 | struct zfcp_hba_dbf_record *r = (struct zfcp_hba_dbf_record *)in_buf; |
431 | char *p = out_buf; | |
8a36e453 | 432 | |
a9c85775 | 433 | if (strncmp(r->tag, "dump", ZFCP_DBF_TAG_SIZE) == 0) |
8a36e453 MS |
434 | return 0; |
435 | ||
a9c85775 MP |
436 | zfcp_dbf_tag(&p, "tag", r->tag); |
437 | if (isalpha(r->tag2[0])) | |
438 | zfcp_dbf_tag(&p, "tag2", r->tag2); | |
439 | ||
440 | if (strncmp(r->tag, "resp", ZFCP_DBF_TAG_SIZE) == 0) | |
6bc473dd | 441 | zfcp_hba_dbf_view_response(&p, &r->u.response); |
a9c85775 | 442 | else if (strncmp(r->tag, "stat", ZFCP_DBF_TAG_SIZE) == 0) |
6bc473dd | 443 | zfcp_hba_dbf_view_status(&p, &r->u.status); |
a9c85775 | 444 | else if (strncmp(r->tag, "qdio", ZFCP_DBF_TAG_SIZE) == 0) |
6bc473dd | 445 | zfcp_hba_dbf_view_qdio(&p, &r->u.qdio); |
57069386 SS |
446 | else if (strncmp(r->tag, "berr", ZFCP_DBF_TAG_SIZE) == 0) |
447 | zfcp_hba_dbf_view_berr(&p, &r->u.berr); | |
a9c85775 | 448 | |
d94ce6c6 CS |
449 | if (strncmp(r->tag, "resp", ZFCP_DBF_TAG_SIZE) != 0) |
450 | p += sprintf(p, "\n"); | |
a9c85775 | 451 | return p - out_buf; |
8a36e453 MS |
452 | } |
453 | ||
2b67fc46 | 454 | static struct debug_view zfcp_hba_dbf_view = { |
8a36e453 MS |
455 | "structured", |
456 | NULL, | |
457 | &zfcp_dbf_view_header, | |
458 | &zfcp_hba_dbf_view_format, | |
459 | NULL, | |
460 | NULL | |
461 | }; | |
462 | ||
d79a83db | 463 | static const char *zfcp_rec_dbf_tags[] = { |
348447e8 | 464 | [ZFCP_REC_DBF_ID_THREAD] = "thread", |
698ec016 | 465 | [ZFCP_REC_DBF_ID_TARGET] = "target", |
9467a9b3 | 466 | [ZFCP_REC_DBF_ID_TRIGGER] = "trigger", |
6f4f365e | 467 | [ZFCP_REC_DBF_ID_ACTION] = "action", |
d79a83db MP |
468 | }; |
469 | ||
d79a83db MP |
470 | static int zfcp_rec_dbf_view_format(debug_info_t *id, struct debug_view *view, |
471 | char *buf, const char *_rec) | |
472 | { | |
473 | struct zfcp_rec_dbf_record *r = (struct zfcp_rec_dbf_record *)_rec; | |
474 | char *p = buf; | |
5ffd51a5 | 475 | char hint[ZFCP_DBF_ID_SIZE + 1]; |
d79a83db | 476 | |
5ffd51a5 SS |
477 | memcpy(hint, r->id2, ZFCP_DBF_ID_SIZE); |
478 | hint[ZFCP_DBF_ID_SIZE] = 0; | |
d79a83db | 479 | zfcp_dbf_outs(&p, "tag", zfcp_rec_dbf_tags[r->id]); |
5ffd51a5 | 480 | zfcp_dbf_outs(&p, "hint", hint); |
d79a83db | 481 | switch (r->id) { |
348447e8 | 482 | case ZFCP_REC_DBF_ID_THREAD: |
348447e8 MP |
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); | |
486 | break; | |
698ec016 MP |
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); | |
494 | break; | |
9467a9b3 MP |
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); | |
505 | break; | |
6f4f365e MP |
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); | |
511 | break; | |
d79a83db | 512 | } |
b634fff7 MP |
513 | p += sprintf(p, "\n"); |
514 | return p - buf; | |
d79a83db MP |
515 | } |
516 | ||
517 | static struct debug_view zfcp_rec_dbf_view = { | |
518 | "structured", | |
519 | NULL, | |
520 | &zfcp_dbf_view_header, | |
521 | &zfcp_rec_dbf_view_format, | |
522 | NULL, | |
523 | NULL | |
524 | }; | |
525 | ||
348447e8 MP |
526 | /** |
527 | * zfcp_rec_dbf_event_thread - trace event related to recovery thread operation | |
528 | * @id2: identifier for event | |
529 | * @adapter: adapter | |
aa0fec62 | 530 | * This function assumes that the caller is holding erp_lock. |
348447e8 | 531 | */ |
5ffd51a5 | 532 | void zfcp_rec_dbf_event_thread(char *id2, struct zfcp_adapter *adapter) |
348447e8 | 533 | { |
d46f384a CS |
534 | struct zfcp_dbf *dbf = adapter->dbf; |
535 | struct zfcp_rec_dbf_record *r = &dbf->rec_dbf_buf; | |
348447e8 MP |
536 | unsigned long flags = 0; |
537 | struct list_head *entry; | |
538 | unsigned ready = 0, running = 0, total; | |
539 | ||
348447e8 MP |
540 | list_for_each(entry, &adapter->erp_ready_head) |
541 | ready++; | |
542 | list_for_each(entry, &adapter->erp_running_head) | |
543 | running++; | |
544 | total = adapter->erp_total_count; | |
348447e8 | 545 | |
d46f384a | 546 | spin_lock_irqsave(&dbf->rec_dbf_lock, flags); |
348447e8 MP |
547 | memset(r, 0, sizeof(*r)); |
548 | r->id = ZFCP_REC_DBF_ID_THREAD; | |
5ffd51a5 | 549 | memcpy(r->id2, id2, ZFCP_DBF_ID_SIZE); |
348447e8 MP |
550 | r->u.thread.total = total; |
551 | r->u.thread.ready = ready; | |
552 | r->u.thread.running = running; | |
d46f384a CS |
553 | debug_event(dbf->rec_dbf, 6, r, sizeof(*r)); |
554 | spin_unlock_irqrestore(&dbf->rec_dbf_lock, flags); | |
348447e8 MP |
555 | } |
556 | ||
aa0fec62 CS |
557 | /** |
558 | * zfcp_rec_dbf_event_thread - trace event related to recovery thread operation | |
559 | * @id2: identifier for event | |
560 | * @adapter: adapter | |
561 | * This function assumes that the caller does not hold erp_lock. | |
562 | */ | |
5ffd51a5 | 563 | void zfcp_rec_dbf_event_thread_lock(char *id2, struct zfcp_adapter *adapter) |
aa0fec62 CS |
564 | { |
565 | unsigned long flags; | |
566 | ||
567 | read_lock_irqsave(&adapter->erp_lock, flags); | |
568 | zfcp_rec_dbf_event_thread(id2, adapter); | |
569 | read_unlock_irqrestore(&adapter->erp_lock, flags); | |
570 | } | |
571 | ||
5ffd51a5 | 572 | static void zfcp_rec_dbf_event_target(char *id2, void *ref, |
698ec016 MP |
573 | struct zfcp_adapter *adapter, |
574 | atomic_t *status, atomic_t *erp_count, | |
575 | u64 wwpn, u32 d_id, u64 fcp_lun) | |
576 | { | |
d46f384a CS |
577 | struct zfcp_dbf *dbf = adapter->dbf; |
578 | struct zfcp_rec_dbf_record *r = &dbf->rec_dbf_buf; | |
698ec016 MP |
579 | unsigned long flags; |
580 | ||
d46f384a | 581 | spin_lock_irqsave(&dbf->rec_dbf_lock, flags); |
698ec016 MP |
582 | memset(r, 0, sizeof(*r)); |
583 | r->id = ZFCP_REC_DBF_ID_TARGET; | |
5ffd51a5 | 584 | memcpy(r->id2, id2, ZFCP_DBF_ID_SIZE); |
1f6f7129 | 585 | r->u.target.ref = (unsigned long)ref; |
698ec016 MP |
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); | |
d46f384a CS |
591 | debug_event(dbf->rec_dbf, 3, r, sizeof(*r)); |
592 | spin_unlock_irqrestore(&dbf->rec_dbf_lock, flags); | |
698ec016 MP |
593 | } |
594 | ||
595 | /** | |
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) | |
599 | * @adapter: adapter | |
600 | */ | |
5ffd51a5 SS |
601 | void zfcp_rec_dbf_event_adapter(char *id, void *ref, |
602 | struct zfcp_adapter *adapter) | |
698ec016 MP |
603 | { |
604 | zfcp_rec_dbf_event_target(id, ref, adapter, &adapter->status, | |
605 | &adapter->erp_counter, 0, 0, 0); | |
606 | } | |
607 | ||
608 | /** | |
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) | |
612 | * @port: port | |
613 | */ | |
5ffd51a5 | 614 | void zfcp_rec_dbf_event_port(char *id, void *ref, struct zfcp_port *port) |
698ec016 MP |
615 | { |
616 | struct zfcp_adapter *adapter = port->adapter; | |
617 | ||
618 | zfcp_rec_dbf_event_target(id, ref, adapter, &port->status, | |
619 | &port->erp_counter, port->wwpn, port->d_id, | |
620 | 0); | |
621 | } | |
622 | ||
623 | /** | |
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) | |
627 | * @unit: unit | |
628 | */ | |
5ffd51a5 | 629 | void zfcp_rec_dbf_event_unit(char *id, void *ref, struct zfcp_unit *unit) |
698ec016 MP |
630 | { |
631 | struct zfcp_port *port = unit->port; | |
632 | struct zfcp_adapter *adapter = port->adapter; | |
633 | ||
634 | zfcp_rec_dbf_event_target(id, ref, adapter, &unit->status, | |
635 | &unit->erp_counter, port->wwpn, port->d_id, | |
636 | unit->fcp_lun); | |
637 | } | |
638 | ||
9467a9b3 MP |
639 | /** |
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 | |
646 | * @adapter: adapter | |
647 | * @port: port | |
648 | * @unit: unit | |
649 | */ | |
5ffd51a5 | 650 | void zfcp_rec_dbf_event_trigger(char *id2, void *ref, u8 want, u8 need, |
1f6f7129 | 651 | void *action, struct zfcp_adapter *adapter, |
9467a9b3 MP |
652 | struct zfcp_port *port, struct zfcp_unit *unit) |
653 | { | |
d46f384a CS |
654 | struct zfcp_dbf *dbf = adapter->dbf; |
655 | struct zfcp_rec_dbf_record *r = &dbf->rec_dbf_buf; | |
9467a9b3 MP |
656 | unsigned long flags; |
657 | ||
d46f384a | 658 | spin_lock_irqsave(&dbf->rec_dbf_lock, flags); |
9467a9b3 MP |
659 | memset(r, 0, sizeof(*r)); |
660 | r->id = ZFCP_REC_DBF_ID_TRIGGER; | |
5ffd51a5 | 661 | memcpy(r->id2, id2, ZFCP_DBF_ID_SIZE); |
1f6f7129 | 662 | r->u.trigger.ref = (unsigned long)ref; |
9467a9b3 MP |
663 | r->u.trigger.want = want; |
664 | r->u.trigger.need = need; | |
1f6f7129 | 665 | r->u.trigger.action = (unsigned long)action; |
9467a9b3 MP |
666 | r->u.trigger.as = atomic_read(&adapter->status); |
667 | if (port) { | |
668 | r->u.trigger.ps = atomic_read(&port->status); | |
669 | r->u.trigger.wwpn = port->wwpn; | |
670 | } | |
671 | if (unit) { | |
672 | r->u.trigger.us = atomic_read(&unit->status); | |
673 | r->u.trigger.fcp_lun = unit->fcp_lun; | |
674 | } | |
d46f384a CS |
675 | debug_event(dbf->rec_dbf, action ? 1 : 4, r, sizeof(*r)); |
676 | spin_unlock_irqrestore(&dbf->rec_dbf_lock, flags); | |
9467a9b3 MP |
677 | } |
678 | ||
6f4f365e MP |
679 | /** |
680 | * zfcp_rec_dbf_event_action - trace event showing progress of recovery action | |
681 | * @id2: identifier | |
682 | * @erp_action: error recovery action struct pointer | |
683 | */ | |
5ffd51a5 | 684 | void zfcp_rec_dbf_event_action(char *id2, struct zfcp_erp_action *erp_action) |
6f4f365e MP |
685 | { |
686 | struct zfcp_adapter *adapter = erp_action->adapter; | |
d46f384a CS |
687 | struct zfcp_dbf *dbf = adapter->dbf; |
688 | struct zfcp_rec_dbf_record *r = &dbf->rec_dbf_buf; | |
6f4f365e MP |
689 | unsigned long flags; |
690 | ||
d46f384a | 691 | spin_lock_irqsave(&dbf->rec_dbf_lock, flags); |
6f4f365e MP |
692 | memset(r, 0, sizeof(*r)); |
693 | r->id = ZFCP_REC_DBF_ID_ACTION; | |
5ffd51a5 | 694 | memcpy(r->id2, id2, ZFCP_DBF_ID_SIZE); |
1f6f7129 | 695 | r->u.action.action = (unsigned long)erp_action; |
6f4f365e MP |
696 | r->u.action.status = erp_action->status; |
697 | r->u.action.step = erp_action->step; | |
1f6f7129 | 698 | r->u.action.fsf_req = (unsigned long)erp_action->fsf_req; |
d46f384a CS |
699 | debug_event(dbf->rec_dbf, 5, r, sizeof(*r)); |
700 | spin_unlock_irqrestore(&dbf->rec_dbf_lock, flags); | |
6f4f365e MP |
701 | } |
702 | ||
bfab1637 MP |
703 | /** |
704 | * zfcp_san_dbf_event_ct_request - trace event for issued CT request | |
705 | * @fsf_req: request containing issued CT data | |
706 | */ | |
4d284cac | 707 | void zfcp_san_dbf_event_ct_request(struct zfcp_fsf_req *fsf_req) |
8a36e453 MS |
708 | { |
709 | struct zfcp_send_ct *ct = (struct zfcp_send_ct *)fsf_req->data; | |
5ab944f9 SS |
710 | struct zfcp_wka_port *wka_port = ct->wka_port; |
711 | struct zfcp_adapter *adapter = wka_port->adapter; | |
d46f384a | 712 | struct zfcp_dbf *dbf = adapter->dbf; |
44cc76f2 | 713 | struct ct_hdr *hdr = sg_virt(ct->req); |
d46f384a | 714 | struct zfcp_san_dbf_record *r = &dbf->san_dbf_buf; |
6bc473dd | 715 | struct zfcp_san_dbf_record_ct_request *oct = &r->u.ct_req; |
d94ce6c6 | 716 | int level = 3; |
6bc473dd | 717 | unsigned long flags; |
8a36e453 | 718 | |
d46f384a | 719 | spin_lock_irqsave(&dbf->san_dbf_lock, flags); |
6bc473dd MP |
720 | memset(r, 0, sizeof(*r)); |
721 | strncpy(r->tag, "octc", ZFCP_DBF_TAG_SIZE); | |
f0216ae9 | 722 | r->fsf_reqid = fsf_req->req_id; |
6bc473dd MP |
723 | r->fsf_seqno = fsf_req->seq_no; |
724 | r->s_id = fc_host_port_id(adapter->scsi_host); | |
5ab944f9 | 725 | r->d_id = wka_port->d_id; |
6bc473dd MP |
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), | |
d94ce6c6 | 733 | ZFCP_DBF_SAN_MAX_PAYLOAD); |
d46f384a CS |
734 | debug_event(dbf->san_dbf, level, r, sizeof(*r)); |
735 | zfcp_dbf_hexdump(dbf->san_dbf, r, sizeof(*r), level, | |
d94ce6c6 | 736 | (void *)hdr + sizeof(struct ct_hdr), oct->len); |
d46f384a | 737 | spin_unlock_irqrestore(&dbf->san_dbf_lock, flags); |
8a36e453 MS |
738 | } |
739 | ||
bfab1637 MP |
740 | /** |
741 | * zfcp_san_dbf_event_ct_response - trace event for completion of CT request | |
742 | * @fsf_req: request containing CT response | |
743 | */ | |
4d284cac | 744 | void zfcp_san_dbf_event_ct_response(struct zfcp_fsf_req *fsf_req) |
8a36e453 MS |
745 | { |
746 | struct zfcp_send_ct *ct = (struct zfcp_send_ct *)fsf_req->data; | |
5ab944f9 SS |
747 | struct zfcp_wka_port *wka_port = ct->wka_port; |
748 | struct zfcp_adapter *adapter = wka_port->adapter; | |
44cc76f2 | 749 | struct ct_hdr *hdr = sg_virt(ct->resp); |
d46f384a CS |
750 | struct zfcp_dbf *dbf = adapter->dbf; |
751 | struct zfcp_san_dbf_record *r = &dbf->san_dbf_buf; | |
6bc473dd | 752 | struct zfcp_san_dbf_record_ct_response *rct = &r->u.ct_resp; |
d94ce6c6 | 753 | int level = 3; |
6bc473dd | 754 | unsigned long flags; |
8a36e453 | 755 | |
d46f384a | 756 | spin_lock_irqsave(&dbf->san_dbf_lock, flags); |
6bc473dd MP |
757 | memset(r, 0, sizeof(*r)); |
758 | strncpy(r->tag, "rctc", ZFCP_DBF_TAG_SIZE); | |
f0216ae9 | 759 | r->fsf_reqid = fsf_req->req_id; |
6bc473dd | 760 | r->fsf_seqno = fsf_req->seq_no; |
5ab944f9 | 761 | r->s_id = wka_port->d_id; |
6bc473dd MP |
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; | |
39eb7e9a | 768 | rct->max_res_size = hdr->max_res_size; |
6bc473dd | 769 | rct->len = min((int)ct->resp->length - (int)sizeof(struct ct_hdr), |
d94ce6c6 | 770 | ZFCP_DBF_SAN_MAX_PAYLOAD); |
d46f384a CS |
771 | debug_event(dbf->san_dbf, level, r, sizeof(*r)); |
772 | zfcp_dbf_hexdump(dbf->san_dbf, r, sizeof(*r), level, | |
d94ce6c6 | 773 | (void *)hdr + sizeof(struct ct_hdr), rct->len); |
d46f384a | 774 | spin_unlock_irqrestore(&dbf->san_dbf_lock, flags); |
8a36e453 MS |
775 | } |
776 | ||
92c7a83f MP |
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, | |
780 | int buflen) | |
8a36e453 MS |
781 | { |
782 | struct zfcp_adapter *adapter = fsf_req->adapter; | |
d46f384a CS |
783 | struct zfcp_dbf *dbf = adapter->dbf; |
784 | struct zfcp_san_dbf_record *rec = &dbf->san_dbf_buf; | |
8a36e453 | 785 | unsigned long flags; |
8a36e453 | 786 | |
d46f384a | 787 | spin_lock_irqsave(&dbf->san_dbf_lock, flags); |
6bc473dd | 788 | memset(rec, 0, sizeof(*rec)); |
0f65e951 | 789 | strncpy(rec->tag, tag, ZFCP_DBF_TAG_SIZE); |
f0216ae9 | 790 | rec->fsf_reqid = fsf_req->req_id; |
0f65e951 MP |
791 | rec->fsf_seqno = fsf_req->seq_no; |
792 | rec->s_id = s_id; | |
793 | rec->d_id = d_id; | |
6bc473dd | 794 | rec->u.els.ls_code = ls_code; |
d46f384a CS |
795 | debug_event(dbf->san_dbf, level, rec, sizeof(*rec)); |
796 | zfcp_dbf_hexdump(dbf->san_dbf, rec, sizeof(*rec), level, | |
d94ce6c6 | 797 | buffer, min(buflen, ZFCP_DBF_SAN_MAX_PAYLOAD)); |
d46f384a | 798 | spin_unlock_irqrestore(&dbf->san_dbf_lock, flags); |
8a36e453 MS |
799 | } |
800 | ||
bfab1637 MP |
801 | /** |
802 | * zfcp_san_dbf_event_els_request - trace event for issued ELS | |
803 | * @fsf_req: request containing issued ELS | |
804 | */ | |
4d284cac | 805 | void zfcp_san_dbf_event_els_request(struct zfcp_fsf_req *fsf_req) |
8a36e453 MS |
806 | { |
807 | struct zfcp_send_els *els = (struct zfcp_send_els *)fsf_req->data; | |
808 | ||
92c7a83f MP |
809 | zfcp_san_dbf_event_els("oels", 2, fsf_req, |
810 | fc_host_port_id(els->adapter->scsi_host), | |
44cc76f2 SS |
811 | els->d_id, *(u8 *) sg_virt(els->req), |
812 | sg_virt(els->req), els->req->length); | |
8a36e453 MS |
813 | } |
814 | ||
bfab1637 MP |
815 | /** |
816 | * zfcp_san_dbf_event_els_response - trace event for completed ELS | |
817 | * @fsf_req: request containing ELS response | |
818 | */ | |
4d284cac | 819 | void zfcp_san_dbf_event_els_response(struct zfcp_fsf_req *fsf_req) |
8a36e453 MS |
820 | { |
821 | struct zfcp_send_els *els = (struct zfcp_send_els *)fsf_req->data; | |
822 | ||
92c7a83f MP |
823 | zfcp_san_dbf_event_els("rels", 2, fsf_req, els->d_id, |
824 | fc_host_port_id(els->adapter->scsi_host), | |
44cc76f2 | 825 | *(u8 *)sg_virt(els->req), sg_virt(els->resp), |
92c7a83f | 826 | els->resp->length); |
8a36e453 MS |
827 | } |
828 | ||
bfab1637 MP |
829 | /** |
830 | * zfcp_san_dbf_event_incoming_els - trace event for incomig ELS | |
831 | * @fsf_req: request containing unsolicited status buffer with incoming ELS | |
832 | */ | |
4d284cac | 833 | void zfcp_san_dbf_event_incoming_els(struct zfcp_fsf_req *fsf_req) |
8a36e453 MS |
834 | { |
835 | struct zfcp_adapter *adapter = fsf_req->adapter; | |
92c7a83f MP |
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); | |
840 | ||
841 | zfcp_san_dbf_event_els("iels", 1, fsf_req, buf->d_id, | |
842 | fc_host_port_id(adapter->scsi_host), | |
c41f8cbd | 843 | buf->payload.data[0], (void *)buf->payload.data, |
92c7a83f | 844 | length); |
8a36e453 MS |
845 | } |
846 | ||
92c7a83f MP |
847 | static int zfcp_san_dbf_view_format(debug_info_t *id, struct debug_view *view, |
848 | char *out_buf, const char *in_buf) | |
8a36e453 | 849 | { |
b634fff7 | 850 | struct zfcp_san_dbf_record *r = (struct zfcp_san_dbf_record *)in_buf; |
b634fff7 | 851 | char *p = out_buf; |
8a36e453 | 852 | |
b634fff7 | 853 | if (strncmp(r->tag, "dump", ZFCP_DBF_TAG_SIZE) == 0) |
8a36e453 MS |
854 | return 0; |
855 | ||
a9c85775 | 856 | zfcp_dbf_tag(&p, "tag", r->tag); |
b634fff7 MP |
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); | |
861 | ||
862 | if (strncmp(r->tag, "octc", ZFCP_DBF_TAG_SIZE) == 0) { | |
6bc473dd MP |
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); | |
b634fff7 | 870 | } else if (strncmp(r->tag, "rctc", ZFCP_DBF_TAG_SIZE) == 0) { |
6bc473dd MP |
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); | |
39eb7e9a | 877 | zfcp_dbf_out(&p, "max_res_size", "0x%04x", ct->max_res_size); |
b634fff7 MP |
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) { | |
6bc473dd MP |
881 | struct zfcp_san_dbf_record_els *els = &r->u.els; |
882 | zfcp_dbf_out(&p, "ls_code", "0x%02x", els->ls_code); | |
8a36e453 | 883 | } |
b634fff7 | 884 | return p - out_buf; |
8a36e453 MS |
885 | } |
886 | ||
2b67fc46 | 887 | static struct debug_view zfcp_san_dbf_view = { |
8a36e453 MS |
888 | "structured", |
889 | NULL, | |
890 | &zfcp_dbf_view_header, | |
891 | &zfcp_san_dbf_view_format, | |
892 | NULL, | |
893 | NULL | |
894 | }; | |
895 | ||
dcd20e23 CS |
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) | |
8a36e453 | 900 | { |
d46f384a | 901 | struct zfcp_scsi_dbf_record *rec = &dbf->scsi_dbf_buf; |
8a36e453 MS |
902 | struct zfcp_dbf_dump *dump = (struct zfcp_dbf_dump *)rec; |
903 | unsigned long flags; | |
904 | struct fcp_rsp_iu *fcp_rsp; | |
905 | char *fcp_rsp_info = NULL, *fcp_sns_info = NULL; | |
906 | int offset = 0, buflen = 0; | |
907 | ||
d46f384a | 908 | spin_lock_irqsave(&dbf->scsi_dbf_lock, flags); |
8a36e453 | 909 | do { |
6bc473dd | 910 | memset(rec, 0, sizeof(*rec)); |
8a36e453 MS |
911 | if (offset == 0) { |
912 | strncpy(rec->tag, tag, ZFCP_DBF_TAG_SIZE); | |
913 | strncpy(rec->tag2, tag2, ZFCP_DBF_TAG_SIZE); | |
ed829ad6 MS |
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; | |
918 | } | |
919 | rec->scsi_result = scsi_cmnd->result; | |
920 | rec->scsi_cmnd = (unsigned long)scsi_cmnd; | |
921 | rec->scsi_serial = scsi_cmnd->serial_number; | |
64a87b24 | 922 | memcpy(rec->scsi_opcode, scsi_cmnd->cmnd, |
ed829ad6 MS |
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; | |
8a36e453 | 927 | } |
8a36e453 MS |
928 | if (fsf_req != NULL) { |
929 | fcp_rsp = (struct fcp_rsp_iu *) | |
930 | &(fsf_req->qtcb->bottom.io.fcp_rsp); | |
f76af7d7 | 931 | fcp_rsp_info = (unsigned char *) &fcp_rsp[1]; |
8a36e453 MS |
932 | fcp_sns_info = |
933 | zfcp_get_fcp_sns_info_ptr(fcp_rsp); | |
934 | ||
6bc473dd MP |
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; | |
8a36e453 | 938 | if (fcp_rsp->validity.bits.fcp_rsp_len_valid) |
6bc473dd | 939 | rec->rsp_code = *(fcp_rsp_info + 3); |
8a36e453 MS |
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); | |
6bc473dd MP |
943 | rec->sns_info_len = buflen; |
944 | memcpy(rec->sns_info, fcp_sns_info, | |
8a36e453 MS |
945 | min(buflen, |
946 | ZFCP_DBF_SCSI_FCP_SNS_INFO)); | |
947 | offset += min(buflen, | |
948 | ZFCP_DBF_SCSI_FCP_SNS_INFO); | |
949 | } | |
950 | ||
f0216ae9 | 951 | rec->fsf_reqid = fsf_req->req_id; |
8a36e453 MS |
952 | rec->fsf_seqno = fsf_req->seq_no; |
953 | rec->fsf_issued = fsf_req->issued; | |
954 | } | |
6bc473dd | 955 | rec->old_fsf_reqid = old_req_id; |
8a36e453 MS |
956 | } else { |
957 | strncpy(dump->tag, "dump", ZFCP_DBF_TAG_SIZE); | |
958 | dump->total_size = buflen; | |
959 | dump->offset = offset; | |
960 | dump->size = min(buflen - offset, | |
961 | (int)sizeof(struct | |
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; | |
966 | } | |
d46f384a | 967 | debug_event(dbf->scsi_dbf, level, rec, sizeof(*rec)); |
8a36e453 | 968 | } while (offset < buflen); |
d46f384a | 969 | spin_unlock_irqrestore(&dbf->scsi_dbf_lock, flags); |
8a36e453 MS |
970 | } |
971 | ||
92c7a83f MP |
972 | static int zfcp_scsi_dbf_view_format(debug_info_t *id, struct debug_view *view, |
973 | char *out_buf, const char *in_buf) | |
8a36e453 | 974 | { |
b634fff7 | 975 | struct zfcp_scsi_dbf_record *r = (struct zfcp_scsi_dbf_record *)in_buf; |
8fc5af16 | 976 | struct timespec t; |
b634fff7 | 977 | char *p = out_buf; |
8a36e453 | 978 | |
b634fff7 | 979 | if (strncmp(r->tag, "dump", ZFCP_DBF_TAG_SIZE) == 0) |
8a36e453 MS |
980 | return 0; |
981 | ||
a9c85775 MP |
982 | zfcp_dbf_tag(&p, "tag", r->tag); |
983 | zfcp_dbf_tag(&p, "tag2", r->tag2); | |
b634fff7 MP |
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); | |
df29f4ac MP |
989 | zfcp_dbf_outd(&p, "scsi_opcode", r->scsi_opcode, ZFCP_DBF_SCSI_OPCODE, |
990 | 0, ZFCP_DBF_SCSI_OPCODE); | |
b634fff7 MP |
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) | |
6bc473dd | 994 | zfcp_dbf_out(&p, "old_fsf_reqid", "0x%0Lx", r->old_fsf_reqid); |
b634fff7 MP |
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); | |
999 | ||
1000 | if (strncmp(r->tag, "rslt", ZFCP_DBF_TAG_SIZE) == 0) { | |
6bc473dd MP |
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, | |
df29f4ac | 1009 | ZFCP_DBF_SCSI_FCP_SNS_INFO), 0, |
6bc473dd | 1010 | r->sns_info_len); |
8a36e453 | 1011 | } |
b634fff7 MP |
1012 | p += sprintf(p, "\n"); |
1013 | return p - out_buf; | |
8a36e453 MS |
1014 | } |
1015 | ||
2b67fc46 | 1016 | static struct debug_view zfcp_scsi_dbf_view = { |
8a36e453 MS |
1017 | "structured", |
1018 | NULL, | |
1019 | &zfcp_dbf_view_header, | |
1020 | &zfcp_scsi_dbf_view_format, | |
1021 | NULL, | |
1022 | NULL | |
1023 | }; | |
1024 | ||
d46f384a CS |
1025 | static debug_info_t *zfcp_dbf_reg(const char *name, int level, |
1026 | struct debug_view *view, int size) | |
1027 | { | |
1028 | struct debug_info *d; | |
1029 | ||
1030 | d = debug_register(name, dbfsize, level, size); | |
1031 | if (!d) | |
1032 | return NULL; | |
1033 | ||
1034 | debug_register_view(d, &debug_hex_ascii_view); | |
1035 | debug_register_view(d, view); | |
1036 | debug_set_level(d, level); | |
1037 | ||
1038 | return d; | |
1039 | } | |
1040 | ||
8a36e453 MS |
1041 | /** |
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 | |
1045 | */ | |
1046 | int zfcp_adapter_debug_register(struct zfcp_adapter *adapter) | |
1047 | { | |
1048 | char dbf_name[DEBUG_MAX_NAME_LEN]; | |
d46f384a CS |
1049 | struct zfcp_dbf *dbf; |
1050 | ||
1051 | dbf = kmalloc(sizeof(struct zfcp_dbf), GFP_KERNEL); | |
1052 | if (!dbf) | |
1053 | return -ENOMEM; | |
1054 | ||
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); | |
8a36e453 | 1059 | |
d79a83db | 1060 | /* debug feature area which records recovery activity */ |
b225cf9b | 1061 | sprintf(dbf_name, "zfcp_%s_rec", dev_name(&adapter->ccw_device->dev)); |
d46f384a CS |
1062 | dbf->rec_dbf = zfcp_dbf_reg(dbf_name, 3, &zfcp_rec_dbf_view, |
1063 | sizeof(struct zfcp_rec_dbf_record)); | |
1064 | if (!dbf->rec_dbf) | |
1065 | goto fail_rec; | |
d79a83db | 1066 | |
8a36e453 | 1067 | /* debug feature area which records HBA (FSF and QDIO) conditions */ |
b225cf9b | 1068 | sprintf(dbf_name, "zfcp_%s_hba", dev_name(&adapter->ccw_device->dev)); |
d46f384a CS |
1069 | dbf->hba_dbf = zfcp_dbf_reg(dbf_name, 3, &zfcp_hba_dbf_view, |
1070 | sizeof(struct zfcp_hba_dbf_record)); | |
1071 | if (!dbf->hba_dbf) | |
1072 | goto fail_hba; | |
8a36e453 MS |
1073 | |
1074 | /* debug feature area which records SAN command failures and recovery */ | |
b225cf9b | 1075 | sprintf(dbf_name, "zfcp_%s_san", dev_name(&adapter->ccw_device->dev)); |
d46f384a CS |
1076 | dbf->san_dbf = zfcp_dbf_reg(dbf_name, 6, &zfcp_san_dbf_view, |
1077 | sizeof(struct zfcp_san_dbf_record)); | |
1078 | if (!dbf->san_dbf) | |
1079 | goto fail_san; | |
8a36e453 MS |
1080 | |
1081 | /* debug feature area which records SCSI command failures and recovery */ | |
b225cf9b | 1082 | sprintf(dbf_name, "zfcp_%s_scsi", dev_name(&adapter->ccw_device->dev)); |
d46f384a CS |
1083 | dbf->scsi_dbf = zfcp_dbf_reg(dbf_name, 3, &zfcp_scsi_dbf_view, |
1084 | sizeof(struct zfcp_scsi_dbf_record)); | |
1085 | if (!dbf->scsi_dbf) | |
1086 | goto fail_scsi; | |
8a36e453 | 1087 | |
d46f384a | 1088 | adapter->dbf = dbf; |
8a36e453 MS |
1089 | return 0; |
1090 | ||
d46f384a CS |
1091 | fail_scsi: |
1092 | debug_unregister(dbf->san_dbf); | |
1093 | fail_san: | |
1094 | debug_unregister(dbf->hba_dbf); | |
1095 | fail_hba: | |
1096 | debug_unregister(dbf->rec_dbf); | |
1097 | fail_rec: | |
1098 | kfree(dbf); | |
8a36e453 MS |
1099 | return -ENOMEM; |
1100 | } | |
1101 | ||
1102 | /** | |
1103 | * zfcp_adapter_debug_unregister - unregisters debug feature for an adapter | |
1104 | * @adapter: pointer to adapter for which debug features should be unregistered | |
1105 | */ | |
1106 | void zfcp_adapter_debug_unregister(struct zfcp_adapter *adapter) | |
1107 | { | |
d46f384a CS |
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; | |
8a36e453 | 1114 | } |