projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[S390] convert zfcp printks to pr_xxx macros.
[deliverable/linux.git] / drivers / s390 / scsi / zfcp_dbf.c
1 /*
2 * zfcp device driver
3 *
4 * Debug traces for zfcp.
5 *
6 * Copyright IBM Corporation 2002, 2008
7 */
8
9 #define KMSG_COMPONENT "zfcp"
10 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
11
12 #include <linux/ctype.h>
13 #include <asm/debug.h>
14 #include "zfcp_ext.h"
15
16 static u32 dbfsize = 4;
17
18 module_param(dbfsize, uint, 0400);
19 MODULE_PARM_DESC(dbfsize,
20 "number of pages for each debug feature area (default 4)");
21
22 static void zfcp_dbf_hexdump(debug_info_t *dbf, void *to, int to_len,
23 int level, char *from, int from_len)
24 {
25 int offset;
26 struct zfcp_dbf_dump *dump = to;
27 int room = to_len - sizeof(*dump);
28
29 for (offset = 0; offset < from_len; offset += dump->size) {
30 memset(to, 0, to_len);
31 strncpy(dump->tag, "dump", ZFCP_DBF_TAG_SIZE);
32 dump->total_size = from_len;
33 dump->offset = offset;
34 dump->size = min(from_len - offset, room);
35 memcpy(dump->data, from + offset, dump->size);
36 debug_event(dbf, level, dump, dump->size + sizeof(*dump));
37 }
38 }
39
40 /* FIXME: this duplicate this code in s390 debug feature */
41 static void zfcp_dbf_timestamp(unsigned long long stck, struct timespec *time)
42 {
43 unsigned long long sec;
44
45 stck -= 0x8126d60e46000000LL - (0x3c26700LL * 1000000 * 4096);
46 sec = stck >> 12;
47 do_div(sec, 1000000);
48 time->tv_sec = sec;
49 stck -= (sec * 1000000) << 12;
50 time->tv_nsec = ((stck * 1000) >> 12);
51 }
52
53 static void zfcp_dbf_tag(char **p, const char *label, const char *tag)
54 {
55 int i;
56
57 *p += sprintf(*p, "%-24s", label);
58 for (i = 0; i < ZFCP_DBF_TAG_SIZE; i++)
59 *p += sprintf(*p, "%c", tag[i]);
60 *p += sprintf(*p, "\n");
61 }
62
63 static void zfcp_dbf_outs(char **buf, const char *s1, const char *s2)
64 {
65 *buf += sprintf(*buf, "%-24s%s\n", s1, s2);
66 }
67
68 static void zfcp_dbf_out(char **buf, const char *s, const char *format, ...)
69 {
70 va_list arg;
71
72 *buf += sprintf(*buf, "%-24s", s);
73 va_start(arg, format);
74 *buf += vsprintf(*buf, format, arg);
75 va_end(arg);
76 *buf += sprintf(*buf, "\n");
77 }
78
79 static void zfcp_dbf_outd(char **p, const char *label, char *buffer,
80 int buflen, int offset, int total_size)
81 {
82 if (!offset)
83 *p += sprintf(*p, "%-24s ", label);
84 while (buflen--) {
85 if (offset > 0) {
86 if ((offset % 32) == 0)
87 *p += sprintf(*p, "\n%-24c ", ' ');
88 else if ((offset % 4) == 0)
89 *p += sprintf(*p, " ");
90 }
91 *p += sprintf(*p, "%02x", *buffer++);
92 if (++offset == total_size) {
93 *p += sprintf(*p, "\n");
94 break;
95 }
96 }
97 if (!total_size)
98 *p += sprintf(*p, "\n");
99 }
100
101 static int zfcp_dbf_view_header(debug_info_t *id, struct debug_view *view,
102 int area, debug_entry_t *entry, char *out_buf)
103 {
104 struct zfcp_dbf_dump *dump = (struct zfcp_dbf_dump *)DEBUG_DATA(entry);
105 struct timespec t;
106 char *p = out_buf;
107
108 if (strncmp(dump->tag, "dump", ZFCP_DBF_TAG_SIZE) != 0) {
109 zfcp_dbf_timestamp(entry->id.stck, &t);
110 zfcp_dbf_out(&p, "timestamp", "%011lu:%06lu",
111 t.tv_sec, t.tv_nsec);
112 zfcp_dbf_out(&p, "cpu", "%02i", entry->id.fields.cpuid);
113 } else {
114 zfcp_dbf_outd(&p, "", dump->data, dump->size, dump->offset,
115 dump->total_size);
116 if ((dump->offset + dump->size) == dump->total_size)
117 p += sprintf(p, "\n");
118 }
119 return p - out_buf;
120 }
121
122 /**
123 * zfcp_hba_dbf_event_fsf_response - trace event for request completion
124 * @fsf_req: request that has been completed
125 */
126 void zfcp_hba_dbf_event_fsf_response(struct zfcp_fsf_req *fsf_req)
127 {
128 struct zfcp_adapter *adapter = fsf_req->adapter;
129 struct fsf_qtcb *qtcb = fsf_req->qtcb;
130 union fsf_prot_status_qual *prot_status_qual =
131 &qtcb->prefix.prot_status_qual;
132 union fsf_status_qual *fsf_status_qual = &qtcb->header.fsf_status_qual;
133 struct scsi_cmnd *scsi_cmnd;
134 struct zfcp_port *port;
135 struct zfcp_unit *unit;
136 struct zfcp_send_els *send_els;
137 struct zfcp_hba_dbf_record *rec = &adapter->hba_dbf_buf;
138 struct zfcp_hba_dbf_record_response *response = &rec->u.response;
139 int level;
140 unsigned long flags;
141
142 spin_lock_irqsave(&adapter->hba_dbf_lock, flags);
143 memset(rec, 0, sizeof(*rec));
144 strncpy(rec->tag, "resp", ZFCP_DBF_TAG_SIZE);
145
146 if ((qtcb->prefix.prot_status != FSF_PROT_GOOD) &&
147 (qtcb->prefix.prot_status != FSF_PROT_FSF_STATUS_PRESENTED)) {
148 strncpy(rec->tag2, "perr", ZFCP_DBF_TAG_SIZE);
149 level = 1;
150 } else if (qtcb->header.fsf_status != FSF_GOOD) {
151 strncpy(rec->tag2, "ferr", ZFCP_DBF_TAG_SIZE);
152 level = 1;
153 } else if ((fsf_req->fsf_command == FSF_QTCB_OPEN_PORT_WITH_DID) ||
154 (fsf_req->fsf_command == FSF_QTCB_OPEN_LUN)) {
155 strncpy(rec->tag2, "open", ZFCP_DBF_TAG_SIZE);
156 level = 4;
157 } else if (qtcb->header.log_length) {
158 strncpy(rec->tag2, "qtcb", ZFCP_DBF_TAG_SIZE);
159 level = 5;
160 } else {
161 strncpy(rec->tag2, "norm", ZFCP_DBF_TAG_SIZE);
162 level = 6;
163 }
164
165 response->fsf_command = fsf_req->fsf_command;
166 response->fsf_reqid = (unsigned long)fsf_req;
167 response->fsf_seqno = fsf_req->seq_no;
168 response->fsf_issued = fsf_req->issued;
169 response->fsf_prot_status = qtcb->prefix.prot_status;
170 response->fsf_status = qtcb->header.fsf_status;
171 memcpy(response->fsf_prot_status_qual,
172 prot_status_qual, FSF_PROT_STATUS_QUAL_SIZE);
173 memcpy(response->fsf_status_qual,
174 fsf_status_qual, FSF_STATUS_QUALIFIER_SIZE);
175 response->fsf_req_status = fsf_req->status;
176 response->sbal_first = fsf_req->sbal_first;
177 response->sbal_last = fsf_req->sbal_last;
178 response->sbal_response = fsf_req->sbal_response;
179 response->pool = fsf_req->pool != NULL;
180 response->erp_action = (unsigned long)fsf_req->erp_action;
181
182 switch (fsf_req->fsf_command) {
183 case FSF_QTCB_FCP_CMND:
184 if (fsf_req->status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT)
185 break;
186 scsi_cmnd = (struct scsi_cmnd *)fsf_req->data;
187 if (scsi_cmnd) {
188 response->u.fcp.cmnd = (unsigned long)scsi_cmnd;
189 response->u.fcp.serial = scsi_cmnd->serial_number;
190 }
191 break;
192
193 case FSF_QTCB_OPEN_PORT_WITH_DID:
194 case FSF_QTCB_CLOSE_PORT:
195 case FSF_QTCB_CLOSE_PHYSICAL_PORT:
196 port = (struct zfcp_port *)fsf_req->data;
197 response->u.port.wwpn = port->wwpn;
198 response->u.port.d_id = port->d_id;
199 response->u.port.port_handle = qtcb->header.port_handle;
200 break;
201
202 case FSF_QTCB_OPEN_LUN:
203 case FSF_QTCB_CLOSE_LUN:
204 unit = (struct zfcp_unit *)fsf_req->data;
205 port = unit->port;
206 response->u.unit.wwpn = port->wwpn;
207 response->u.unit.fcp_lun = unit->fcp_lun;
208 response->u.unit.port_handle = qtcb->header.port_handle;
209 response->u.unit.lun_handle = qtcb->header.lun_handle;
210 break;
211
212 case FSF_QTCB_SEND_ELS:
213 send_els = (struct zfcp_send_els *)fsf_req->data;
214 response->u.els.d_id = qtcb->bottom.support.d_id;
215 response->u.els.ls_code = send_els->ls_code >> 24;
216 break;
217
218 case FSF_QTCB_ABORT_FCP_CMND:
219 case FSF_QTCB_SEND_GENERIC:
220 case FSF_QTCB_EXCHANGE_CONFIG_DATA:
221 case FSF_QTCB_EXCHANGE_PORT_DATA:
222 case FSF_QTCB_DOWNLOAD_CONTROL_FILE:
223 case FSF_QTCB_UPLOAD_CONTROL_FILE:
224 break;
225 }
226
227 debug_event(adapter->hba_dbf, level, rec, sizeof(*rec));
228
229 /* have fcp channel microcode fixed to use as little as possible */
230 if (fsf_req->fsf_command != FSF_QTCB_FCP_CMND) {
231 /* adjust length skipping trailing zeros */
232 char *buf = (char *)qtcb + qtcb->header.log_start;
233 int len = qtcb->header.log_length;
234 for (; len && !buf[len - 1]; len--);
235 zfcp_dbf_hexdump(adapter->hba_dbf, rec, sizeof(*rec), level,
236 buf, len);
237 }
238
239 spin_unlock_irqrestore(&adapter->hba_dbf_lock, flags);
240 }
241
242 /**
243 * zfcp_hba_dbf_event_fsf_unsol - trace event for an unsolicited status buffer
244 * @tag: tag indicating which kind of unsolicited status has been received
245 * @adapter: adapter that has issued the unsolicited status buffer
246 * @status_buffer: buffer containing payload of unsolicited status
247 */
248 void zfcp_hba_dbf_event_fsf_unsol(const char *tag, struct zfcp_adapter *adapter,
249 struct fsf_status_read_buffer *status_buffer)
250 {
251 struct zfcp_hba_dbf_record *rec = &adapter->hba_dbf_buf;
252 unsigned long flags;
253
254 spin_lock_irqsave(&adapter->hba_dbf_lock, flags);
255 memset(rec, 0, sizeof(*rec));
256 strncpy(rec->tag, "stat", ZFCP_DBF_TAG_SIZE);
257 strncpy(rec->tag2, tag, ZFCP_DBF_TAG_SIZE);
258
259 rec->u.status.failed = atomic_read(&adapter->stat_miss);
260 if (status_buffer != NULL) {
261 rec->u.status.status_type = status_buffer->status_type;
262 rec->u.status.status_subtype = status_buffer->status_subtype;
263 memcpy(&rec->u.status.queue_designator,
264 &status_buffer->queue_designator,
265 sizeof(struct fsf_queue_designator));
266
267 switch (status_buffer->status_type) {
268 case FSF_STATUS_READ_SENSE_DATA_AVAIL:
269 rec->u.status.payload_size =
270 ZFCP_DBF_UNSOL_PAYLOAD_SENSE_DATA_AVAIL;
271 break;
272
273 case FSF_STATUS_READ_BIT_ERROR_THRESHOLD:
274 rec->u.status.payload_size =
275 ZFCP_DBF_UNSOL_PAYLOAD_BIT_ERROR_THRESHOLD;
276 break;
277
278 case FSF_STATUS_READ_LINK_DOWN:
279 switch (status_buffer->status_subtype) {
280 case FSF_STATUS_READ_SUB_NO_PHYSICAL_LINK:
281 case FSF_STATUS_READ_SUB_FDISC_FAILED:
282 rec->u.status.payload_size =
283 sizeof(struct fsf_link_down_info);
284 }
285 break;
286
287 case FSF_STATUS_READ_FEATURE_UPDATE_ALERT:
288 rec->u.status.payload_size =
289 ZFCP_DBF_UNSOL_PAYLOAD_FEATURE_UPDATE_ALERT;
290 break;
291 }
292 memcpy(&rec->u.status.payload,
293 &status_buffer->payload, rec->u.status.payload_size);
294 }
295
296 debug_event(adapter->hba_dbf, 2, rec, sizeof(*rec));
297 spin_unlock_irqrestore(&adapter->hba_dbf_lock, flags);
298 }
299
300 /**
301 * zfcp_hba_dbf_event_qdio - trace event for QDIO related failure
302 * @adapter: adapter affected by this QDIO related event
303 * @qdio_error: as passed by qdio module
304 * @sbal_index: first buffer with error condition, as passed by qdio module
305 * @sbal_count: number of buffers affected, as passed by qdio module
306 */
307 void zfcp_hba_dbf_event_qdio(struct zfcp_adapter *adapter,
308 unsigned int qdio_error, int sbal_index,
309 int sbal_count)
310 {
311 struct zfcp_hba_dbf_record *r = &adapter->hba_dbf_buf;
312 unsigned long flags;
313
314 spin_lock_irqsave(&adapter->hba_dbf_lock, flags);
315 memset(r, 0, sizeof(*r));
316 strncpy(r->tag, "qdio", ZFCP_DBF_TAG_SIZE);
317 r->u.qdio.qdio_error = qdio_error;
318 r->u.qdio.sbal_index = sbal_index;
319 r->u.qdio.sbal_count = sbal_count;
320 debug_event(adapter->hba_dbf, 0, r, sizeof(*r));
321 spin_unlock_irqrestore(&adapter->hba_dbf_lock, flags);
322 }
323
324 /**
325 * zfcp_hba_dbf_event_berr - trace event for bit error threshold
326 * @adapter: adapter affected by this QDIO related event
327 * @req: fsf request
328 */
329 void zfcp_hba_dbf_event_berr(struct zfcp_adapter *adapter,
330 struct zfcp_fsf_req *req)
331 {
332 struct zfcp_hba_dbf_record *r = &adapter->hba_dbf_buf;
333 struct fsf_status_read_buffer *sr_buf = req->data;
334 struct fsf_bit_error_payload *err = &sr_buf->payload.bit_error;
335 unsigned long flags;
336
337 spin_lock_irqsave(&adapter->hba_dbf_lock, flags);
338 memset(r, 0, sizeof(*r));
339 strncpy(r->tag, "berr", ZFCP_DBF_TAG_SIZE);
340 memcpy(&r->u.berr, err, sizeof(struct fsf_bit_error_payload));
341 debug_event(adapter->hba_dbf, 0, r, sizeof(*r));
342 spin_unlock_irqrestore(&adapter->hba_dbf_lock, flags);
343 }
344 static void zfcp_hba_dbf_view_response(char **p,
345 struct zfcp_hba_dbf_record_response *r)
346 {
347 struct timespec t;
348
349 zfcp_dbf_out(p, "fsf_command", "0x%08x", r->fsf_command);
350 zfcp_dbf_out(p, "fsf_reqid", "0x%0Lx", r->fsf_reqid);
351 zfcp_dbf_out(p, "fsf_seqno", "0x%08x", r->fsf_seqno);
352 zfcp_dbf_timestamp(r->fsf_issued, &t);
353 zfcp_dbf_out(p, "fsf_issued", "%011lu:%06lu", t.tv_sec, t.tv_nsec);
354 zfcp_dbf_out(p, "fsf_prot_status", "0x%08x", r->fsf_prot_status);
355 zfcp_dbf_out(p, "fsf_status", "0x%08x", r->fsf_status);
356 zfcp_dbf_outd(p, "fsf_prot_status_qual", r->fsf_prot_status_qual,
357 FSF_PROT_STATUS_QUAL_SIZE, 0, FSF_PROT_STATUS_QUAL_SIZE);
358 zfcp_dbf_outd(p, "fsf_status_qual", r->fsf_status_qual,
359 FSF_STATUS_QUALIFIER_SIZE, 0, FSF_STATUS_QUALIFIER_SIZE);
360 zfcp_dbf_out(p, "fsf_req_status", "0x%08x", r->fsf_req_status);
361 zfcp_dbf_out(p, "sbal_first", "0x%02x", r->sbal_first);
362 zfcp_dbf_out(p, "sbal_last", "0x%02x", r->sbal_last);
363 zfcp_dbf_out(p, "sbal_response", "0x%02x", r->sbal_response);
364 zfcp_dbf_out(p, "pool", "0x%02x", r->pool);
365
366 switch (r->fsf_command) {
367 case FSF_QTCB_FCP_CMND:
368 if (r->fsf_req_status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT)
369 break;
370 zfcp_dbf_out(p, "scsi_cmnd", "0x%0Lx", r->u.fcp.cmnd);
371 zfcp_dbf_out(p, "scsi_serial", "0x%016Lx", r->u.fcp.serial);
372 p += sprintf(*p, "\n");
373 break;
374
375 case FSF_QTCB_OPEN_PORT_WITH_DID:
376 case FSF_QTCB_CLOSE_PORT:
377 case FSF_QTCB_CLOSE_PHYSICAL_PORT:
378 zfcp_dbf_out(p, "wwpn", "0x%016Lx", r->u.port.wwpn);
379 zfcp_dbf_out(p, "d_id", "0x%06x", r->u.port.d_id);
380 zfcp_dbf_out(p, "port_handle", "0x%08x", r->u.port.port_handle);
381 break;
382
383 case FSF_QTCB_OPEN_LUN:
384 case FSF_QTCB_CLOSE_LUN:
385 zfcp_dbf_out(p, "wwpn", "0x%016Lx", r->u.unit.wwpn);
386 zfcp_dbf_out(p, "fcp_lun", "0x%016Lx", r->u.unit.fcp_lun);
387 zfcp_dbf_out(p, "port_handle", "0x%08x", r->u.unit.port_handle);
388 zfcp_dbf_out(p, "lun_handle", "0x%08x", r->u.unit.lun_handle);
389 break;
390
391 case FSF_QTCB_SEND_ELS:
392 zfcp_dbf_out(p, "d_id", "0x%06x", r->u.els.d_id);
393 zfcp_dbf_out(p, "ls_code", "0x%02x", r->u.els.ls_code);
394 break;
395
396 case FSF_QTCB_ABORT_FCP_CMND:
397 case FSF_QTCB_SEND_GENERIC:
398 case FSF_QTCB_EXCHANGE_CONFIG_DATA:
399 case FSF_QTCB_EXCHANGE_PORT_DATA:
400 case FSF_QTCB_DOWNLOAD_CONTROL_FILE:
401 case FSF_QTCB_UPLOAD_CONTROL_FILE:
402 break;
403 }
404 }
405
406 static void zfcp_hba_dbf_view_status(char **p,
407 struct zfcp_hba_dbf_record_status *r)
408 {
409 zfcp_dbf_out(p, "failed", "0x%02x", r->failed);
410 zfcp_dbf_out(p, "status_type", "0x%08x", r->status_type);
411 zfcp_dbf_out(p, "status_subtype", "0x%08x", r->status_subtype);
412 zfcp_dbf_outd(p, "queue_designator", (char *)&r->queue_designator,
413 sizeof(struct fsf_queue_designator), 0,
414 sizeof(struct fsf_queue_designator));
415 zfcp_dbf_outd(p, "payload", (char *)&r->payload, r->payload_size, 0,
416 r->payload_size);
417 }
418
419 static void zfcp_hba_dbf_view_qdio(char **p, struct zfcp_hba_dbf_record_qdio *r)
420 {
421 zfcp_dbf_out(p, "qdio_error", "0x%08x", r->qdio_error);
422 zfcp_dbf_out(p, "sbal_index", "0x%02x", r->sbal_index);
423 zfcp_dbf_out(p, "sbal_count", "0x%02x", r->sbal_count);
424 }
425
426 static void zfcp_hba_dbf_view_berr(char **p, struct fsf_bit_error_payload *r)
427 {
428 zfcp_dbf_out(p, "link_failures", "%d", r->link_failure_error_count);
429 zfcp_dbf_out(p, "loss_of_sync_err", "%d", r->loss_of_sync_error_count);
430 zfcp_dbf_out(p, "loss_of_sig_err", "%d", r->loss_of_signal_error_count);
431 zfcp_dbf_out(p, "prim_seq_err", "%d",
432 r->primitive_sequence_error_count);
433 zfcp_dbf_out(p, "inval_trans_word_err", "%d",
434 r->invalid_transmission_word_error_count);
435 zfcp_dbf_out(p, "CRC_errors", "%d", r->crc_error_count);
436 zfcp_dbf_out(p, "prim_seq_event_to", "%d",
437 r->primitive_sequence_event_timeout_count);
438 zfcp_dbf_out(p, "elast_buf_overrun_err", "%d",
439 r->elastic_buffer_overrun_error_count);
440 zfcp_dbf_out(p, "adv_rec_buf2buf_cred", "%d",
441 r->advertised_receive_b2b_credit);
442 zfcp_dbf_out(p, "curr_rec_buf2buf_cred", "%d",
443 r->current_receive_b2b_credit);
444 zfcp_dbf_out(p, "adv_trans_buf2buf_cred", "%d",
445 r->advertised_transmit_b2b_credit);
446 zfcp_dbf_out(p, "curr_trans_buf2buf_cred", "%d",
447 r->current_transmit_b2b_credit);
448 }
449
450 static int zfcp_hba_dbf_view_format(debug_info_t *id, struct debug_view *view,
451 char *out_buf, const char *in_buf)
452 {
453 struct zfcp_hba_dbf_record *r = (struct zfcp_hba_dbf_record *)in_buf;
454 char *p = out_buf;
455
456 if (strncmp(r->tag, "dump", ZFCP_DBF_TAG_SIZE) == 0)
457 return 0;
458
459 zfcp_dbf_tag(&p, "tag", r->tag);
460 if (isalpha(r->tag2[0]))
461 zfcp_dbf_tag(&p, "tag2", r->tag2);
462
463 if (strncmp(r->tag, "resp", ZFCP_DBF_TAG_SIZE) == 0)
464 zfcp_hba_dbf_view_response(&p, &r->u.response);
465 else if (strncmp(r->tag, "stat", ZFCP_DBF_TAG_SIZE) == 0)
466 zfcp_hba_dbf_view_status(&p, &r->u.status);
467 else if (strncmp(r->tag, "qdio", ZFCP_DBF_TAG_SIZE) == 0)
468 zfcp_hba_dbf_view_qdio(&p, &r->u.qdio);
469 else if (strncmp(r->tag, "berr", ZFCP_DBF_TAG_SIZE) == 0)
470 zfcp_hba_dbf_view_berr(&p, &r->u.berr);
471
472 if (strncmp(r->tag, "resp", ZFCP_DBF_TAG_SIZE) != 0)
473 p += sprintf(p, "\n");
474 return p - out_buf;
475 }
476
477 static struct debug_view zfcp_hba_dbf_view = {
478 "structured",
479 NULL,
480 &zfcp_dbf_view_header,
481 &zfcp_hba_dbf_view_format,
482 NULL,
483 NULL
484 };
485
486 static const char *zfcp_rec_dbf_tags[] = {
487 [ZFCP_REC_DBF_ID_THREAD] = "thread",
488 [ZFCP_REC_DBF_ID_TARGET] = "target",
489 [ZFCP_REC_DBF_ID_TRIGGER] = "trigger",
490 [ZFCP_REC_DBF_ID_ACTION] = "action",
491 };
492
493 static const char *zfcp_rec_dbf_ids[] = {
494 [1] = "new",
495 [2] = "ready",
496 [3] = "kill",
497 [4] = "down sleep",
498 [5] = "down wakeup",
499 [6] = "down sleep ecd",
500 [7] = "down wakeup ecd",
501 [8] = "down sleep epd",
502 [9] = "down wakeup epd",
503 [10] = "online",
504 [11] = "operational",
505 [12] = "scsi slave destroy",
506 [13] = "propagate failed adapter",
507 [14] = "propagate failed port",
508 [15] = "block adapter",
509 [16] = "unblock adapter",
510 [17] = "block port",
511 [18] = "unblock port",
512 [19] = "block unit",
513 [20] = "unblock unit",
514 [21] = "unit recovery failed",
515 [22] = "port recovery failed",
516 [23] = "adapter recovery failed",
517 [24] = "qdio queues down",
518 [25] = "p2p failed",
519 [26] = "nameserver lookup failed",
520 [27] = "nameserver port failed",
521 [28] = "link up",
522 [29] = "link down",
523 [30] = "link up status read",
524 [31] = "open port failed",
525 [32] = "open port failed",
526 [33] = "close port",
527 [34] = "open unit failed",
528 [35] = "exclusive open unit failed",
529 [36] = "shared open unit failed",
530 [37] = "link down",
531 [38] = "link down status read no link",
532 [39] = "link down status read fdisc login",
533 [40] = "link down status read firmware update",
534 [41] = "link down status read unknown reason",
535 [42] = "link down ecd incomplete",
536 [43] = "link down epd incomplete",
537 [44] = "sysfs adapter recovery",
538 [45] = "sysfs port recovery",
539 [46] = "sysfs unit recovery",
540 [47] = "port boxed abort",
541 [48] = "unit boxed abort",
542 [49] = "port boxed ct",
543 [50] = "port boxed close physical",
544 [51] = "port boxed open unit",
545 [52] = "port boxed close unit",
546 [53] = "port boxed fcp",
547 [54] = "unit boxed fcp",
548 [55] = "port access denied",
549 [56] = "",
550 [57] = "",
551 [58] = "",
552 [59] = "unit access denied",
553 [60] = "shared unit access denied open unit",
554 [61] = "",
555 [62] = "request timeout",
556 [63] = "adisc link test reject or timeout",
557 [64] = "adisc link test d_id changed",
558 [65] = "adisc link test failed",
559 [66] = "recovery out of memory",
560 [67] = "adapter recovery repeated after state change",
561 [68] = "port recovery repeated after state change",
562 [69] = "unit recovery repeated after state change",
563 [70] = "port recovery follow-up after successful adapter recovery",
564 [71] = "adapter recovery escalation after failed adapter recovery",
565 [72] = "port recovery follow-up after successful physical port "
566 "recovery",
567 [73] = "adapter recovery escalation after failed physical port "
568 "recovery",
569 [74] = "unit recovery follow-up after successful port recovery",
570 [75] = "physical port recovery escalation after failed port "
571 "recovery",
572 [76] = "port recovery escalation after failed unit recovery",
573 [77] = "",
574 [78] = "duplicate request id",
575 [79] = "link down",
576 [80] = "exclusive read-only unit access unsupported",
577 [81] = "shared read-write unit access unsupported",
578 [82] = "incoming rscn",
579 [83] = "incoming wwpn",
580 [84] = "wka port handle not valid close port",
581 [85] = "online",
582 [86] = "offline",
583 [87] = "ccw device gone",
584 [88] = "ccw device no path",
585 [89] = "ccw device operational",
586 [90] = "ccw device shutdown",
587 [91] = "sysfs port addition",
588 [92] = "sysfs port removal",
589 [93] = "sysfs adapter recovery",
590 [94] = "sysfs unit addition",
591 [95] = "sysfs unit removal",
592 [96] = "sysfs port recovery",
593 [97] = "sysfs unit recovery",
594 [98] = "sequence number mismatch",
595 [99] = "link up",
596 [100] = "error state",
597 [101] = "status read physical port closed",
598 [102] = "link up status read",
599 [103] = "too many failed status read buffers",
600 [104] = "port handle not valid abort",
601 [105] = "lun handle not valid abort",
602 [106] = "port handle not valid ct",
603 [107] = "port handle not valid close port",
604 [108] = "port handle not valid close physical port",
605 [109] = "port handle not valid open unit",
606 [110] = "port handle not valid close unit",
607 [111] = "lun handle not valid close unit",
608 [112] = "port handle not valid fcp",
609 [113] = "lun handle not valid fcp",
610 [114] = "handle mismatch fcp",
611 [115] = "lun not valid fcp",
612 [116] = "qdio send failed",
613 [117] = "version mismatch",
614 [118] = "incompatible qtcb type",
615 [119] = "unknown protocol status",
616 [120] = "unknown fsf command",
617 [121] = "no recommendation for status qualifier",
618 [122] = "status read physical port closed in error",
619 [123] = "fc service class not supported",
620 [124] = "",
621 [125] = "need newer zfcp",
622 [126] = "need newer microcode",
623 [127] = "arbitrated loop not supported",
624 [128] = "",
625 [129] = "qtcb size mismatch",
626 [130] = "unknown fsf status ecd",
627 [131] = "fcp request too big",
628 [132] = "",
629 [133] = "data direction not valid fcp",
630 [134] = "command length not valid fcp",
631 [135] = "status read act update",
632 [136] = "status read cfdc update",
633 [137] = "hbaapi port open",
634 [138] = "hbaapi unit open",
635 [139] = "hbaapi unit shutdown",
636 [140] = "qdio error outbound",
637 [141] = "scsi host reset",
638 [142] = "dismissing fsf request for recovery action",
639 [143] = "recovery action timed out",
640 [144] = "recovery action gone",
641 [145] = "recovery action being processed",
642 [146] = "recovery action ready for next step",
643 [147] = "qdio error inbound",
644 [148] = "nameserver needed for port scan",
645 [149] = "port scan",
646 [150] = "ptp attach",
647 [151] = "port validation failed",
648 };
649
650 static int zfcp_rec_dbf_view_format(debug_info_t *id, struct debug_view *view,
651 char *buf, const char *_rec)
652 {
653 struct zfcp_rec_dbf_record *r = (struct zfcp_rec_dbf_record *)_rec;
654 char *p = buf;
655
656 zfcp_dbf_outs(&p, "tag", zfcp_rec_dbf_tags[r->id]);
657 zfcp_dbf_outs(&p, "hint", zfcp_rec_dbf_ids[r->id2]);
658 zfcp_dbf_out(&p, "id", "%d", r->id2);
659 switch (r->id) {
660 case ZFCP_REC_DBF_ID_THREAD:
661 zfcp_dbf_out(&p, "total", "%d", r->u.thread.total);
662 zfcp_dbf_out(&p, "ready", "%d", r->u.thread.ready);
663 zfcp_dbf_out(&p, "running", "%d", r->u.thread.running);
664 break;
665 case ZFCP_REC_DBF_ID_TARGET:
666 zfcp_dbf_out(&p, "reference", "0x%016Lx", r->u.target.ref);
667 zfcp_dbf_out(&p, "status", "0x%08x", r->u.target.status);
668 zfcp_dbf_out(&p, "erp_count", "%d", r->u.target.erp_count);
669 zfcp_dbf_out(&p, "d_id", "0x%06x", r->u.target.d_id);
670 zfcp_dbf_out(&p, "wwpn", "0x%016Lx", r->u.target.wwpn);
671 zfcp_dbf_out(&p, "fcp_lun", "0x%016Lx", r->u.target.fcp_lun);
672 break;
673 case ZFCP_REC_DBF_ID_TRIGGER:
674 zfcp_dbf_out(&p, "reference", "0x%016Lx", r->u.trigger.ref);
675 zfcp_dbf_out(&p, "erp_action", "0x%016Lx", r->u.trigger.action);
676 zfcp_dbf_out(&p, "requested", "%d", r->u.trigger.want);
677 zfcp_dbf_out(&p, "executed", "%d", r->u.trigger.need);
678 zfcp_dbf_out(&p, "wwpn", "0x%016Lx", r->u.trigger.wwpn);
679 zfcp_dbf_out(&p, "fcp_lun", "0x%016Lx", r->u.trigger.fcp_lun);
680 zfcp_dbf_out(&p, "adapter_status", "0x%08x", r->u.trigger.as);
681 zfcp_dbf_out(&p, "port_status", "0x%08x", r->u.trigger.ps);
682 zfcp_dbf_out(&p, "unit_status", "0x%08x", r->u.trigger.us);
683 break;
684 case ZFCP_REC_DBF_ID_ACTION:
685 zfcp_dbf_out(&p, "erp_action", "0x%016Lx", r->u.action.action);
686 zfcp_dbf_out(&p, "fsf_req", "0x%016Lx", r->u.action.fsf_req);
687 zfcp_dbf_out(&p, "status", "0x%08Lx", r->u.action.status);
688 zfcp_dbf_out(&p, "step", "0x%08Lx", r->u.action.step);
689 break;
690 }
691 p += sprintf(p, "\n");
692 return p - buf;
693 }
694
695 static struct debug_view zfcp_rec_dbf_view = {
696 "structured",
697 NULL,
698 &zfcp_dbf_view_header,
699 &zfcp_rec_dbf_view_format,
700 NULL,
701 NULL
702 };
703
704 /**
705 * zfcp_rec_dbf_event_thread - trace event related to recovery thread operation
706 * @id2: identifier for event
707 * @adapter: adapter
708 * This function assumes that the caller is holding erp_lock.
709 */
710 void zfcp_rec_dbf_event_thread(u8 id2, struct zfcp_adapter *adapter)
711 {
712 struct zfcp_rec_dbf_record *r = &adapter->rec_dbf_buf;
713 unsigned long flags = 0;
714 struct list_head *entry;
715 unsigned ready = 0, running = 0, total;
716
717 list_for_each(entry, &adapter->erp_ready_head)
718 ready++;
719 list_for_each(entry, &adapter->erp_running_head)
720 running++;
721 total = adapter->erp_total_count;
722
723 spin_lock_irqsave(&adapter->rec_dbf_lock, flags);
724 memset(r, 0, sizeof(*r));
725 r->id = ZFCP_REC_DBF_ID_THREAD;
726 r->id2 = id2;
727 r->u.thread.total = total;
728 r->u.thread.ready = ready;
729 r->u.thread.running = running;
730 debug_event(adapter->rec_dbf, 6, r, sizeof(*r));
731 spin_unlock_irqrestore(&adapter->rec_dbf_lock, flags);
732 }
733
734 /**
735 * zfcp_rec_dbf_event_thread - trace event related to recovery thread operation
736 * @id2: identifier for event
737 * @adapter: adapter
738 * This function assumes that the caller does not hold erp_lock.
739 */
740 void zfcp_rec_dbf_event_thread_lock(u8 id2, struct zfcp_adapter *adapter)
741 {
742 unsigned long flags;
743
744 read_lock_irqsave(&adapter->erp_lock, flags);
745 zfcp_rec_dbf_event_thread(id2, adapter);
746 read_unlock_irqrestore(&adapter->erp_lock, flags);
747 }
748
749 static void zfcp_rec_dbf_event_target(u8 id2, void *ref,
750 struct zfcp_adapter *adapter,
751 atomic_t *status, atomic_t *erp_count,
752 u64 wwpn, u32 d_id, u64 fcp_lun)
753 {
754 struct zfcp_rec_dbf_record *r = &adapter->rec_dbf_buf;
755 unsigned long flags;
756
757 spin_lock_irqsave(&adapter->rec_dbf_lock, flags);
758 memset(r, 0, sizeof(*r));
759 r->id = ZFCP_REC_DBF_ID_TARGET;
760 r->id2 = id2;
761 r->u.target.ref = (unsigned long)ref;
762 r->u.target.status = atomic_read(status);
763 r->u.target.wwpn = wwpn;
764 r->u.target.d_id = d_id;
765 r->u.target.fcp_lun = fcp_lun;
766 r->u.target.erp_count = atomic_read(erp_count);
767 debug_event(adapter->rec_dbf, 3, r, sizeof(*r));
768 spin_unlock_irqrestore(&adapter->rec_dbf_lock, flags);
769 }
770
771 /**
772 * zfcp_rec_dbf_event_adapter - trace event for adapter state change
773 * @id: identifier for trigger of state change
774 * @ref: additional reference (e.g. request)
775 * @adapter: adapter
776 */
777 void zfcp_rec_dbf_event_adapter(u8 id, void *ref, struct zfcp_adapter *adapter)
778 {
779 zfcp_rec_dbf_event_target(id, ref, adapter, &adapter->status,
780 &adapter->erp_counter, 0, 0, 0);
781 }
782
783 /**
784 * zfcp_rec_dbf_event_port - trace event for port state change
785 * @id: identifier for trigger of state change
786 * @ref: additional reference (e.g. request)
787 * @port: port
788 */
789 void zfcp_rec_dbf_event_port(u8 id, void *ref, struct zfcp_port *port)
790 {
791 struct zfcp_adapter *adapter = port->adapter;
792
793 zfcp_rec_dbf_event_target(id, ref, adapter, &port->status,
794 &port->erp_counter, port->wwpn, port->d_id,
795 0);
796 }
797
798 /**
799 * zfcp_rec_dbf_event_unit - trace event for unit state change
800 * @id: identifier for trigger of state change
801 * @ref: additional reference (e.g. request)
802 * @unit: unit
803 */
804 void zfcp_rec_dbf_event_unit(u8 id, void *ref, struct zfcp_unit *unit)
805 {
806 struct zfcp_port *port = unit->port;
807 struct zfcp_adapter *adapter = port->adapter;
808
809 zfcp_rec_dbf_event_target(id, ref, adapter, &unit->status,
810 &unit->erp_counter, port->wwpn, port->d_id,
811 unit->fcp_lun);
812 }
813
814 /**
815 * zfcp_rec_dbf_event_trigger - trace event for triggered error recovery
816 * @id2: identifier for error recovery trigger
817 * @ref: additional reference (e.g. request)
818 * @want: originally requested error recovery action
819 * @need: error recovery action actually initiated
820 * @action: address of error recovery action struct
821 * @adapter: adapter
822 * @port: port
823 * @unit: unit
824 */
825 void zfcp_rec_dbf_event_trigger(u8 id2, void *ref, u8 want, u8 need,
826 void *action, struct zfcp_adapter *adapter,
827 struct zfcp_port *port, struct zfcp_unit *unit)
828 {
829 struct zfcp_rec_dbf_record *r = &adapter->rec_dbf_buf;
830 unsigned long flags;
831
832 spin_lock_irqsave(&adapter->rec_dbf_lock, flags);
833 memset(r, 0, sizeof(*r));
834 r->id = ZFCP_REC_DBF_ID_TRIGGER;
835 r->id2 = id2;
836 r->u.trigger.ref = (unsigned long)ref;
837 r->u.trigger.want = want;
838 r->u.trigger.need = need;
839 r->u.trigger.action = (unsigned long)action;
840 r->u.trigger.as = atomic_read(&adapter->status);
841 if (port) {
842 r->u.trigger.ps = atomic_read(&port->status);
843 r->u.trigger.wwpn = port->wwpn;
844 }
845 if (unit) {
846 r->u.trigger.us = atomic_read(&unit->status);
847 r->u.trigger.fcp_lun = unit->fcp_lun;
848 }
849 debug_event(adapter->rec_dbf, action ? 1 : 4, r, sizeof(*r));
850 spin_unlock_irqrestore(&adapter->rec_dbf_lock, flags);
851 }
852
853 /**
854 * zfcp_rec_dbf_event_action - trace event showing progress of recovery action
855 * @id2: identifier
856 * @erp_action: error recovery action struct pointer
857 */
858 void zfcp_rec_dbf_event_action(u8 id2, struct zfcp_erp_action *erp_action)
859 {
860 struct zfcp_adapter *adapter = erp_action->adapter;
861 struct zfcp_rec_dbf_record *r = &adapter->rec_dbf_buf;
862 unsigned long flags;
863
864 spin_lock_irqsave(&adapter->rec_dbf_lock, flags);
865 memset(r, 0, sizeof(*r));
866 r->id = ZFCP_REC_DBF_ID_ACTION;
867 r->id2 = id2;
868 r->u.action.action = (unsigned long)erp_action;
869 r->u.action.status = erp_action->status;
870 r->u.action.step = erp_action->step;
871 r->u.action.fsf_req = (unsigned long)erp_action->fsf_req;
872 debug_event(adapter->rec_dbf, 5, r, sizeof(*r));
873 spin_unlock_irqrestore(&adapter->rec_dbf_lock, flags);
874 }
875
876 /**
877 * zfcp_san_dbf_event_ct_request - trace event for issued CT request
878 * @fsf_req: request containing issued CT data
879 */
880 void zfcp_san_dbf_event_ct_request(struct zfcp_fsf_req *fsf_req)
881 {
882 struct zfcp_send_ct *ct = (struct zfcp_send_ct *)fsf_req->data;
883 struct zfcp_wka_port *wka_port = ct->wka_port;
884 struct zfcp_adapter *adapter = wka_port->adapter;
885 struct ct_hdr *hdr = sg_virt(ct->req);
886 struct zfcp_san_dbf_record *r = &adapter->san_dbf_buf;
887 struct zfcp_san_dbf_record_ct_request *oct = &r->u.ct_req;
888 int level = 3;
889 unsigned long flags;
890
891 spin_lock_irqsave(&adapter->san_dbf_lock, flags);
892 memset(r, 0, sizeof(*r));
893 strncpy(r->tag, "octc", ZFCP_DBF_TAG_SIZE);
894 r->fsf_reqid = (unsigned long)fsf_req;
895 r->fsf_seqno = fsf_req->seq_no;
896 r->s_id = fc_host_port_id(adapter->scsi_host);
897 r->d_id = wka_port->d_id;
898 oct->cmd_req_code = hdr->cmd_rsp_code;
899 oct->revision = hdr->revision;
900 oct->gs_type = hdr->gs_type;
901 oct->gs_subtype = hdr->gs_subtype;
902 oct->options = hdr->options;
903 oct->max_res_size = hdr->max_res_size;
904 oct->len = min((int)ct->req->length - (int)sizeof(struct ct_hdr),
905 ZFCP_DBF_SAN_MAX_PAYLOAD);
906 debug_event(adapter->san_dbf, level, r, sizeof(*r));
907 zfcp_dbf_hexdump(adapter->san_dbf, r, sizeof(*r), level,
908 (void *)hdr + sizeof(struct ct_hdr), oct->len);
909 spin_unlock_irqrestore(&adapter->san_dbf_lock, flags);
910 }
911
912 /**
913 * zfcp_san_dbf_event_ct_response - trace event for completion of CT request
914 * @fsf_req: request containing CT response
915 */
916 void zfcp_san_dbf_event_ct_response(struct zfcp_fsf_req *fsf_req)
917 {
918 struct zfcp_send_ct *ct = (struct zfcp_send_ct *)fsf_req->data;
919 struct zfcp_wka_port *wka_port = ct->wka_port;
920 struct zfcp_adapter *adapter = wka_port->adapter;
921 struct ct_hdr *hdr = sg_virt(ct->resp);
922 struct zfcp_san_dbf_record *r = &adapter->san_dbf_buf;
923 struct zfcp_san_dbf_record_ct_response *rct = &r->u.ct_resp;
924 int level = 3;
925 unsigned long flags;
926
927 spin_lock_irqsave(&adapter->san_dbf_lock, flags);
928 memset(r, 0, sizeof(*r));
929 strncpy(r->tag, "rctc", ZFCP_DBF_TAG_SIZE);
930 r->fsf_reqid = (unsigned long)fsf_req;
931 r->fsf_seqno = fsf_req->seq_no;
932 r->s_id = wka_port->d_id;
933 r->d_id = fc_host_port_id(adapter->scsi_host);
934 rct->cmd_rsp_code = hdr->cmd_rsp_code;
935 rct->revision = hdr->revision;
936 rct->reason_code = hdr->reason_code;
937 rct->expl = hdr->reason_code_expl;
938 rct->vendor_unique = hdr->vendor_unique;
939 rct->len = min((int)ct->resp->length - (int)sizeof(struct ct_hdr),
940 ZFCP_DBF_SAN_MAX_PAYLOAD);
941 debug_event(adapter->san_dbf, level, r, sizeof(*r));
942 zfcp_dbf_hexdump(adapter->san_dbf, r, sizeof(*r), level,
943 (void *)hdr + sizeof(struct ct_hdr), rct->len);
944 spin_unlock_irqrestore(&adapter->san_dbf_lock, flags);
945 }
946
947 static void zfcp_san_dbf_event_els(const char *tag, int level,
948 struct zfcp_fsf_req *fsf_req, u32 s_id,
949 u32 d_id, u8 ls_code, void *buffer,
950 int buflen)
951 {
952 struct zfcp_adapter *adapter = fsf_req->adapter;
953 struct zfcp_san_dbf_record *rec = &adapter->san_dbf_buf;
954 unsigned long flags;
955
956 spin_lock_irqsave(&adapter->san_dbf_lock, flags);
957 memset(rec, 0, sizeof(*rec));
958 strncpy(rec->tag, tag, ZFCP_DBF_TAG_SIZE);
959 rec->fsf_reqid = (unsigned long)fsf_req;
960 rec->fsf_seqno = fsf_req->seq_no;
961 rec->s_id = s_id;
962 rec->d_id = d_id;
963 rec->u.els.ls_code = ls_code;
964 debug_event(adapter->san_dbf, level, rec, sizeof(*rec));
965 zfcp_dbf_hexdump(adapter->san_dbf, rec, sizeof(*rec), level,
966 buffer, min(buflen, ZFCP_DBF_SAN_MAX_PAYLOAD));
967 spin_unlock_irqrestore(&adapter->san_dbf_lock, flags);
968 }
969
970 /**
971 * zfcp_san_dbf_event_els_request - trace event for issued ELS
972 * @fsf_req: request containing issued ELS
973 */
974 void zfcp_san_dbf_event_els_request(struct zfcp_fsf_req *fsf_req)
975 {
976 struct zfcp_send_els *els = (struct zfcp_send_els *)fsf_req->data;
977
978 zfcp_san_dbf_event_els("oels", 2, fsf_req,
979 fc_host_port_id(els->adapter->scsi_host),
980 els->d_id, *(u8 *) sg_virt(els->req),
981 sg_virt(els->req), els->req->length);
982 }
983
984 /**
985 * zfcp_san_dbf_event_els_response - trace event for completed ELS
986 * @fsf_req: request containing ELS response
987 */
988 void zfcp_san_dbf_event_els_response(struct zfcp_fsf_req *fsf_req)
989 {
990 struct zfcp_send_els *els = (struct zfcp_send_els *)fsf_req->data;
991
992 zfcp_san_dbf_event_els("rels", 2, fsf_req, els->d_id,
993 fc_host_port_id(els->adapter->scsi_host),
994 *(u8 *)sg_virt(els->req), sg_virt(els->resp),
995 els->resp->length);
996 }
997
998 /**
999 * zfcp_san_dbf_event_incoming_els - trace event for incomig ELS
1000 * @fsf_req: request containing unsolicited status buffer with incoming ELS
1001 */
1002 void zfcp_san_dbf_event_incoming_els(struct zfcp_fsf_req *fsf_req)
1003 {
1004 struct zfcp_adapter *adapter = fsf_req->adapter;
1005 struct fsf_status_read_buffer *buf =
1006 (struct fsf_status_read_buffer *)fsf_req->data;
1007 int length = (int)buf->length -
1008 (int)((void *)&buf->payload - (void *)buf);
1009
1010 zfcp_san_dbf_event_els("iels", 1, fsf_req, buf->d_id,
1011 fc_host_port_id(adapter->scsi_host),
1012 buf->payload.data[0], (void *)buf->payload.data,
1013 length);
1014 }
1015
1016 static int zfcp_san_dbf_view_format(debug_info_t *id, struct debug_view *view,
1017 char *out_buf, const char *in_buf)
1018 {
1019 struct zfcp_san_dbf_record *r = (struct zfcp_san_dbf_record *)in_buf;
1020 char *p = out_buf;
1021
1022 if (strncmp(r->tag, "dump", ZFCP_DBF_TAG_SIZE) == 0)
1023 return 0;
1024
1025 zfcp_dbf_tag(&p, "tag", r->tag);
1026 zfcp_dbf_out(&p, "fsf_reqid", "0x%0Lx", r->fsf_reqid);
1027 zfcp_dbf_out(&p, "fsf_seqno", "0x%08x", r->fsf_seqno);
1028 zfcp_dbf_out(&p, "s_id", "0x%06x", r->s_id);
1029 zfcp_dbf_out(&p, "d_id", "0x%06x", r->d_id);
1030
1031 if (strncmp(r->tag, "octc", ZFCP_DBF_TAG_SIZE) == 0) {
1032 struct zfcp_san_dbf_record_ct_request *ct = &r->u.ct_req;
1033 zfcp_dbf_out(&p, "cmd_req_code", "0x%04x", ct->cmd_req_code);
1034 zfcp_dbf_out(&p, "revision", "0x%02x", ct->revision);
1035 zfcp_dbf_out(&p, "gs_type", "0x%02x", ct->gs_type);
1036 zfcp_dbf_out(&p, "gs_subtype", "0x%02x", ct->gs_subtype);
1037 zfcp_dbf_out(&p, "options", "0x%02x", ct->options);
1038 zfcp_dbf_out(&p, "max_res_size", "0x%04x", ct->max_res_size);
1039 } else if (strncmp(r->tag, "rctc", ZFCP_DBF_TAG_SIZE) == 0) {
1040 struct zfcp_san_dbf_record_ct_response *ct = &r->u.ct_resp;
1041 zfcp_dbf_out(&p, "cmd_rsp_code", "0x%04x", ct->cmd_rsp_code);
1042 zfcp_dbf_out(&p, "revision", "0x%02x", ct->revision);
1043 zfcp_dbf_out(&p, "reason_code", "0x%02x", ct->reason_code);
1044 zfcp_dbf_out(&p, "reason_code_expl", "0x%02x", ct->expl);
1045 zfcp_dbf_out(&p, "vendor_unique", "0x%02x", ct->vendor_unique);
1046 } else if (strncmp(r->tag, "oels", ZFCP_DBF_TAG_SIZE) == 0 ||
1047 strncmp(r->tag, "rels", ZFCP_DBF_TAG_SIZE) == 0 ||
1048 strncmp(r->tag, "iels", ZFCP_DBF_TAG_SIZE) == 0) {
1049 struct zfcp_san_dbf_record_els *els = &r->u.els;
1050 zfcp_dbf_out(&p, "ls_code", "0x%02x", els->ls_code);
1051 }
1052 return p - out_buf;
1053 }
1054
1055 static struct debug_view zfcp_san_dbf_view = {
1056 "structured",
1057 NULL,
1058 &zfcp_dbf_view_header,
1059 &zfcp_san_dbf_view_format,
1060 NULL,
1061 NULL
1062 };
1063
1064 static void zfcp_scsi_dbf_event(const char *tag, const char *tag2, int level,
1065 struct zfcp_adapter *adapter,
1066 struct scsi_cmnd *scsi_cmnd,
1067 struct zfcp_fsf_req *fsf_req,
1068 unsigned long old_req_id)
1069 {
1070 struct zfcp_scsi_dbf_record *rec = &adapter->scsi_dbf_buf;
1071 struct zfcp_dbf_dump *dump = (struct zfcp_dbf_dump *)rec;
1072 unsigned long flags;
1073 struct fcp_rsp_iu *fcp_rsp;
1074 char *fcp_rsp_info = NULL, *fcp_sns_info = NULL;
1075 int offset = 0, buflen = 0;
1076
1077 spin_lock_irqsave(&adapter->scsi_dbf_lock, flags);
1078 do {
1079 memset(rec, 0, sizeof(*rec));
1080 if (offset == 0) {
1081 strncpy(rec->tag, tag, ZFCP_DBF_TAG_SIZE);
1082 strncpy(rec->tag2, tag2, ZFCP_DBF_TAG_SIZE);
1083 if (scsi_cmnd != NULL) {
1084 if (scsi_cmnd->device) {
1085 rec->scsi_id = scsi_cmnd->device->id;
1086 rec->scsi_lun = scsi_cmnd->device->lun;
1087 }
1088 rec->scsi_result = scsi_cmnd->result;
1089 rec->scsi_cmnd = (unsigned long)scsi_cmnd;
1090 rec->scsi_serial = scsi_cmnd->serial_number;
1091 memcpy(rec->scsi_opcode, scsi_cmnd->cmnd,
1092 min((int)scsi_cmnd->cmd_len,
1093 ZFCP_DBF_SCSI_OPCODE));
1094 rec->scsi_retries = scsi_cmnd->retries;
1095 rec->scsi_allowed = scsi_cmnd->allowed;
1096 }
1097 if (fsf_req != NULL) {
1098 fcp_rsp = (struct fcp_rsp_iu *)
1099 &(fsf_req->qtcb->bottom.io.fcp_rsp);
1100 fcp_rsp_info = (unsigned char *) &fcp_rsp[1];
1101 fcp_sns_info =
1102 zfcp_get_fcp_sns_info_ptr(fcp_rsp);
1103
1104 rec->rsp_validity = fcp_rsp->validity.value;
1105 rec->rsp_scsi_status = fcp_rsp->scsi_status;
1106 rec->rsp_resid = fcp_rsp->fcp_resid;
1107 if (fcp_rsp->validity.bits.fcp_rsp_len_valid)
1108 rec->rsp_code = *(fcp_rsp_info + 3);
1109 if (fcp_rsp->validity.bits.fcp_sns_len_valid) {
1110 buflen = min((int)fcp_rsp->fcp_sns_len,
1111 ZFCP_DBF_SCSI_MAX_FCP_SNS_INFO);
1112 rec->sns_info_len = buflen;
1113 memcpy(rec->sns_info, fcp_sns_info,
1114 min(buflen,
1115 ZFCP_DBF_SCSI_FCP_SNS_INFO));
1116 offset += min(buflen,
1117 ZFCP_DBF_SCSI_FCP_SNS_INFO);
1118 }
1119
1120 rec->fsf_reqid = (unsigned long)fsf_req;
1121 rec->fsf_seqno = fsf_req->seq_no;
1122 rec->fsf_issued = fsf_req->issued;
1123 }
1124 rec->old_fsf_reqid = old_req_id;
1125 } else {
1126 strncpy(dump->tag, "dump", ZFCP_DBF_TAG_SIZE);
1127 dump->total_size = buflen;
1128 dump->offset = offset;
1129 dump->size = min(buflen - offset,
1130 (int)sizeof(struct
1131 zfcp_scsi_dbf_record) -
1132 (int)sizeof(struct zfcp_dbf_dump));
1133 memcpy(dump->data, fcp_sns_info + offset, dump->size);
1134 offset += dump->size;
1135 }
1136 debug_event(adapter->scsi_dbf, level, rec, sizeof(*rec));
1137 } while (offset < buflen);
1138 spin_unlock_irqrestore(&adapter->scsi_dbf_lock, flags);
1139 }
1140
1141 /**
1142 * zfcp_scsi_dbf_event_result - trace event for SCSI command completion
1143 * @tag: tag indicating success or failure of SCSI command
1144 * @level: trace level applicable for this event
1145 * @adapter: adapter that has been used to issue the SCSI command
1146 * @scsi_cmnd: SCSI command pointer
1147 * @fsf_req: request used to issue SCSI command (might be NULL)
1148 */
1149 void zfcp_scsi_dbf_event_result(const char *tag, int level,
1150 struct zfcp_adapter *adapter,
1151 struct scsi_cmnd *scsi_cmnd,
1152 struct zfcp_fsf_req *fsf_req)
1153 {
1154 zfcp_scsi_dbf_event("rslt", tag, level, adapter, scsi_cmnd, fsf_req, 0);
1155 }
1156
1157 /**
1158 * zfcp_scsi_dbf_event_abort - trace event for SCSI command abort
1159 * @tag: tag indicating success or failure of abort operation
1160 * @adapter: adapter thas has been used to issue SCSI command to be aborted
1161 * @scsi_cmnd: SCSI command to be aborted
1162 * @new_fsf_req: request containing abort (might be NULL)
1163 * @old_req_id: identifier of request containg SCSI command to be aborted
1164 */
1165 void zfcp_scsi_dbf_event_abort(const char *tag, struct zfcp_adapter *adapter,
1166 struct scsi_cmnd *scsi_cmnd,
1167 struct zfcp_fsf_req *new_fsf_req,
1168 unsigned long old_req_id)
1169 {
1170 zfcp_scsi_dbf_event("abrt", tag, 1, adapter, scsi_cmnd, new_fsf_req,
1171 old_req_id);
1172 }
1173
1174 /**
1175 * zfcp_scsi_dbf_event_devreset - trace event for Logical Unit or Target Reset
1176 * @tag: tag indicating success or failure of reset operation
1177 * @flag: indicates type of reset (Target Reset, Logical Unit Reset)
1178 * @unit: unit that needs reset
1179 * @scsi_cmnd: SCSI command which caused this error recovery
1180 */
1181 void zfcp_scsi_dbf_event_devreset(const char *tag, u8 flag,
1182 struct zfcp_unit *unit,
1183 struct scsi_cmnd *scsi_cmnd)
1184 {
1185 zfcp_scsi_dbf_event(flag == FCP_TARGET_RESET ? "trst" : "lrst", tag, 1,
1186 unit->port->adapter, scsi_cmnd, NULL, 0);
1187 }
1188
1189 static int zfcp_scsi_dbf_view_format(debug_info_t *id, struct debug_view *view,
1190 char *out_buf, const char *in_buf)
1191 {
1192 struct zfcp_scsi_dbf_record *r = (struct zfcp_scsi_dbf_record *)in_buf;
1193 struct timespec t;
1194 char *p = out_buf;
1195
1196 if (strncmp(r->tag, "dump", ZFCP_DBF_TAG_SIZE) == 0)
1197 return 0;
1198
1199 zfcp_dbf_tag(&p, "tag", r->tag);
1200 zfcp_dbf_tag(&p, "tag2", r->tag2);
1201 zfcp_dbf_out(&p, "scsi_id", "0x%08x", r->scsi_id);
1202 zfcp_dbf_out(&p, "scsi_lun", "0x%08x", r->scsi_lun);
1203 zfcp_dbf_out(&p, "scsi_result", "0x%08x", r->scsi_result);
1204 zfcp_dbf_out(&p, "scsi_cmnd", "0x%0Lx", r->scsi_cmnd);
1205 zfcp_dbf_out(&p, "scsi_serial", "0x%016Lx", r->scsi_serial);
1206 zfcp_dbf_outd(&p, "scsi_opcode", r->scsi_opcode, ZFCP_DBF_SCSI_OPCODE,
1207 0, ZFCP_DBF_SCSI_OPCODE);
1208 zfcp_dbf_out(&p, "scsi_retries", "0x%02x", r->scsi_retries);
1209 zfcp_dbf_out(&p, "scsi_allowed", "0x%02x", r->scsi_allowed);
1210 if (strncmp(r->tag, "abrt", ZFCP_DBF_TAG_SIZE) == 0)
1211 zfcp_dbf_out(&p, "old_fsf_reqid", "0x%0Lx", r->old_fsf_reqid);
1212 zfcp_dbf_out(&p, "fsf_reqid", "0x%0Lx", r->fsf_reqid);
1213 zfcp_dbf_out(&p, "fsf_seqno", "0x%08x", r->fsf_seqno);
1214 zfcp_dbf_timestamp(r->fsf_issued, &t);
1215 zfcp_dbf_out(&p, "fsf_issued", "%011lu:%06lu", t.tv_sec, t.tv_nsec);
1216
1217 if (strncmp(r->tag, "rslt", ZFCP_DBF_TAG_SIZE) == 0) {
1218 zfcp_dbf_out(&p, "fcp_rsp_validity", "0x%02x", r->rsp_validity);
1219 zfcp_dbf_out(&p, "fcp_rsp_scsi_status", "0x%02x",
1220 r->rsp_scsi_status);
1221 zfcp_dbf_out(&p, "fcp_rsp_resid", "0x%08x", r->rsp_resid);
1222 zfcp_dbf_out(&p, "fcp_rsp_code", "0x%08x", r->rsp_code);
1223 zfcp_dbf_out(&p, "fcp_sns_info_len", "0x%08x", r->sns_info_len);
1224 zfcp_dbf_outd(&p, "fcp_sns_info", r->sns_info,
1225 min((int)r->sns_info_len,
1226 ZFCP_DBF_SCSI_FCP_SNS_INFO), 0,
1227 r->sns_info_len);
1228 }
1229 p += sprintf(p, "\n");
1230 return p - out_buf;
1231 }
1232
1233 static struct debug_view zfcp_scsi_dbf_view = {
1234 "structured",
1235 NULL,
1236 &zfcp_dbf_view_header,
1237 &zfcp_scsi_dbf_view_format,
1238 NULL,
1239 NULL
1240 };
1241
1242 /**
1243 * zfcp_adapter_debug_register - registers debug feature for an adapter
1244 * @adapter: pointer to adapter for which debug features should be registered
1245 * return: -ENOMEM on error, 0 otherwise
1246 */
1247 int zfcp_adapter_debug_register(struct zfcp_adapter *adapter)
1248 {
1249 char dbf_name[DEBUG_MAX_NAME_LEN];
1250
1251 /* debug feature area which records recovery activity */
1252 sprintf(dbf_name, "zfcp_%s_rec", zfcp_get_busid_by_adapter(adapter));
1253 adapter->rec_dbf = debug_register(dbf_name, dbfsize, 1,
1254 sizeof(struct zfcp_rec_dbf_record));
1255 if (!adapter->rec_dbf)
1256 goto failed;
1257 debug_register_view(adapter->rec_dbf, &debug_hex_ascii_view);
1258 debug_register_view(adapter->rec_dbf, &zfcp_rec_dbf_view);
1259 debug_set_level(adapter->rec_dbf, 3);
1260
1261 /* debug feature area which records HBA (FSF and QDIO) conditions */
1262 sprintf(dbf_name, "zfcp_%s_hba", zfcp_get_busid_by_adapter(adapter));
1263 adapter->hba_dbf = debug_register(dbf_name, dbfsize, 1,
1264 sizeof(struct zfcp_hba_dbf_record));
1265 if (!adapter->hba_dbf)
1266 goto failed;
1267 debug_register_view(adapter->hba_dbf, &debug_hex_ascii_view);
1268 debug_register_view(adapter->hba_dbf, &zfcp_hba_dbf_view);
1269 debug_set_level(adapter->hba_dbf, 3);
1270
1271 /* debug feature area which records SAN command failures and recovery */
1272 sprintf(dbf_name, "zfcp_%s_san", zfcp_get_busid_by_adapter(adapter));
1273 adapter->san_dbf = debug_register(dbf_name, dbfsize, 1,
1274 sizeof(struct zfcp_san_dbf_record));
1275 if (!adapter->san_dbf)
1276 goto failed;
1277 debug_register_view(adapter->san_dbf, &debug_hex_ascii_view);
1278 debug_register_view(adapter->san_dbf, &zfcp_san_dbf_view);
1279 debug_set_level(adapter->san_dbf, 6);
1280
1281 /* debug feature area which records SCSI command failures and recovery */
1282 sprintf(dbf_name, "zfcp_%s_scsi", zfcp_get_busid_by_adapter(adapter));
1283 adapter->scsi_dbf = debug_register(dbf_name, dbfsize, 1,
1284 sizeof(struct zfcp_scsi_dbf_record));
1285 if (!adapter->scsi_dbf)
1286 goto failed;
1287 debug_register_view(adapter->scsi_dbf, &debug_hex_ascii_view);
1288 debug_register_view(adapter->scsi_dbf, &zfcp_scsi_dbf_view);
1289 debug_set_level(adapter->scsi_dbf, 3);
1290
1291 return 0;
1292
1293 failed:
1294 zfcp_adapter_debug_unregister(adapter);
1295
1296 return -ENOMEM;
1297 }
1298
1299 /**
1300 * zfcp_adapter_debug_unregister - unregisters debug feature for an adapter
1301 * @adapter: pointer to adapter for which debug features should be unregistered
1302 */
1303 void zfcp_adapter_debug_unregister(struct zfcp_adapter *adapter)
1304 {
1305 debug_unregister(adapter->scsi_dbf);
1306 debug_unregister(adapter->san_dbf);
1307 debug_unregister(adapter->hba_dbf);
1308 debug_unregister(adapter->rec_dbf);
1309 adapter->scsi_dbf = NULL;
1310 adapter->san_dbf = NULL;
1311 adapter->hba_dbf = NULL;
1312 adapter->rec_dbf = NULL;
1313 }
Linux kernel - Deliverables
This page took 0.093514 seconds and 5 git commands to generate.