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 | ||
bfab1637 MP |
123 | /** |
124 | * zfcp_hba_dbf_event_fsf_response - trace event for request completion | |
125 | * @fsf_req: request that has been completed | |
126 | */ | |
4d284cac | 127 | void zfcp_hba_dbf_event_fsf_response(struct zfcp_fsf_req *fsf_req) |
8a36e453 MS |
128 | { |
129 | struct zfcp_adapter *adapter = fsf_req->adapter; | |
d46f384a | 130 | struct zfcp_dbf *dbf = adapter->dbf; |
8a36e453 MS |
131 | struct fsf_qtcb *qtcb = fsf_req->qtcb; |
132 | union fsf_prot_status_qual *prot_status_qual = | |
92c7a83f | 133 | &qtcb->prefix.prot_status_qual; |
8a36e453 MS |
134 | union fsf_status_qual *fsf_status_qual = &qtcb->header.fsf_status_qual; |
135 | struct scsi_cmnd *scsi_cmnd; | |
136 | struct zfcp_port *port; | |
137 | struct zfcp_unit *unit; | |
138 | struct zfcp_send_els *send_els; | |
d46f384a | 139 | struct zfcp_hba_dbf_record *rec = &dbf->hba_dbf_buf; |
6bc473dd | 140 | struct zfcp_hba_dbf_record_response *response = &rec->u.response; |
8a36e453 MS |
141 | int level; |
142 | unsigned long flags; | |
143 | ||
d46f384a | 144 | spin_lock_irqsave(&dbf->hba_dbf_lock, flags); |
6bc473dd | 145 | memset(rec, 0, sizeof(*rec)); |
8a36e453 MS |
146 | strncpy(rec->tag, "resp", ZFCP_DBF_TAG_SIZE); |
147 | ||
148 | if ((qtcb->prefix.prot_status != FSF_PROT_GOOD) && | |
149 | (qtcb->prefix.prot_status != FSF_PROT_FSF_STATUS_PRESENTED)) { | |
150 | strncpy(rec->tag2, "perr", ZFCP_DBF_TAG_SIZE); | |
151 | level = 1; | |
152 | } else if (qtcb->header.fsf_status != FSF_GOOD) { | |
153 | strncpy(rec->tag2, "ferr", ZFCP_DBF_TAG_SIZE); | |
154 | level = 1; | |
155 | } else if ((fsf_req->fsf_command == FSF_QTCB_OPEN_PORT_WITH_DID) || | |
156 | (fsf_req->fsf_command == FSF_QTCB_OPEN_LUN)) { | |
157 | strncpy(rec->tag2, "open", ZFCP_DBF_TAG_SIZE); | |
158 | level = 4; | |
b75db731 MP |
159 | } else if (qtcb->header.log_length) { |
160 | strncpy(rec->tag2, "qtcb", ZFCP_DBF_TAG_SIZE); | |
161 | level = 5; | |
8a36e453 MS |
162 | } else { |
163 | strncpy(rec->tag2, "norm", ZFCP_DBF_TAG_SIZE); | |
164 | level = 6; | |
165 | } | |
166 | ||
167 | response->fsf_command = fsf_req->fsf_command; | |
f0216ae9 | 168 | response->fsf_reqid = fsf_req->req_id; |
8a36e453 MS |
169 | response->fsf_seqno = fsf_req->seq_no; |
170 | response->fsf_issued = fsf_req->issued; | |
171 | response->fsf_prot_status = qtcb->prefix.prot_status; | |
172 | response->fsf_status = qtcb->header.fsf_status; | |
173 | memcpy(response->fsf_prot_status_qual, | |
174 | prot_status_qual, FSF_PROT_STATUS_QUAL_SIZE); | |
175 | memcpy(response->fsf_status_qual, | |
176 | fsf_status_qual, FSF_STATUS_QUALIFIER_SIZE); | |
177 | response->fsf_req_status = fsf_req->status; | |
178 | response->sbal_first = fsf_req->sbal_first; | |
e891bffe | 179 | response->sbal_last = fsf_req->sbal_last; |
c3baa9a2 | 180 | response->sbal_response = fsf_req->sbal_response; |
8a36e453 MS |
181 | response->pool = fsf_req->pool != NULL; |
182 | response->erp_action = (unsigned long)fsf_req->erp_action; | |
183 | ||
184 | switch (fsf_req->fsf_command) { | |
185 | case FSF_QTCB_FCP_CMND: | |
186 | if (fsf_req->status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT) | |
187 | break; | |
188 | scsi_cmnd = (struct scsi_cmnd *)fsf_req->data; | |
6bc473dd MP |
189 | if (scsi_cmnd) { |
190 | response->u.fcp.cmnd = (unsigned long)scsi_cmnd; | |
191 | response->u.fcp.serial = scsi_cmnd->serial_number; | |
8a36e453 MS |
192 | } |
193 | break; | |
194 | ||
195 | case FSF_QTCB_OPEN_PORT_WITH_DID: | |
196 | case FSF_QTCB_CLOSE_PORT: | |
197 | case FSF_QTCB_CLOSE_PHYSICAL_PORT: | |
198 | port = (struct zfcp_port *)fsf_req->data; | |
6bc473dd MP |
199 | response->u.port.wwpn = port->wwpn; |
200 | response->u.port.d_id = port->d_id; | |
201 | response->u.port.port_handle = qtcb->header.port_handle; | |
8a36e453 MS |
202 | break; |
203 | ||
204 | case FSF_QTCB_OPEN_LUN: | |
205 | case FSF_QTCB_CLOSE_LUN: | |
206 | unit = (struct zfcp_unit *)fsf_req->data; | |
207 | port = unit->port; | |
6bc473dd MP |
208 | response->u.unit.wwpn = port->wwpn; |
209 | response->u.unit.fcp_lun = unit->fcp_lun; | |
210 | response->u.unit.port_handle = qtcb->header.port_handle; | |
211 | response->u.unit.lun_handle = qtcb->header.lun_handle; | |
8a36e453 MS |
212 | break; |
213 | ||
214 | case FSF_QTCB_SEND_ELS: | |
215 | send_els = (struct zfcp_send_els *)fsf_req->data; | |
6bc473dd MP |
216 | response->u.els.d_id = qtcb->bottom.support.d_id; |
217 | response->u.els.ls_code = send_els->ls_code >> 24; | |
8a36e453 MS |
218 | break; |
219 | ||
220 | case FSF_QTCB_ABORT_FCP_CMND: | |
221 | case FSF_QTCB_SEND_GENERIC: | |
222 | case FSF_QTCB_EXCHANGE_CONFIG_DATA: | |
223 | case FSF_QTCB_EXCHANGE_PORT_DATA: | |
224 | case FSF_QTCB_DOWNLOAD_CONTROL_FILE: | |
225 | case FSF_QTCB_UPLOAD_CONTROL_FILE: | |
226 | break; | |
227 | } | |
228 | ||
d46f384a | 229 | debug_event(dbf->hba_dbf, level, rec, sizeof(*rec)); |
b75db731 MP |
230 | |
231 | /* have fcp channel microcode fixed to use as little as possible */ | |
232 | if (fsf_req->fsf_command != FSF_QTCB_FCP_CMND) { | |
233 | /* adjust length skipping trailing zeros */ | |
234 | char *buf = (char *)qtcb + qtcb->header.log_start; | |
235 | int len = qtcb->header.log_length; | |
236 | for (; len && !buf[len - 1]; len--); | |
d46f384a CS |
237 | zfcp_dbf_hexdump(dbf->hba_dbf, rec, sizeof(*rec), level, buf, |
238 | len); | |
b75db731 MP |
239 | } |
240 | ||
d46f384a | 241 | spin_unlock_irqrestore(&dbf->hba_dbf_lock, flags); |
8a36e453 MS |
242 | } |
243 | ||
bfab1637 MP |
244 | /** |
245 | * zfcp_hba_dbf_event_fsf_unsol - trace event for an unsolicited status buffer | |
246 | * @tag: tag indicating which kind of unsolicited status has been received | |
247 | * @adapter: adapter that has issued the unsolicited status buffer | |
248 | * @status_buffer: buffer containing payload of unsolicited status | |
249 | */ | |
92c7a83f MP |
250 | void zfcp_hba_dbf_event_fsf_unsol(const char *tag, struct zfcp_adapter *adapter, |
251 | struct fsf_status_read_buffer *status_buffer) | |
8a36e453 | 252 | { |
d46f384a CS |
253 | struct zfcp_dbf *dbf = adapter->dbf; |
254 | struct zfcp_hba_dbf_record *rec = &dbf->hba_dbf_buf; | |
8a36e453 MS |
255 | unsigned long flags; |
256 | ||
d46f384a | 257 | spin_lock_irqsave(&dbf->hba_dbf_lock, flags); |
6bc473dd | 258 | memset(rec, 0, sizeof(*rec)); |
8a36e453 MS |
259 | strncpy(rec->tag, "stat", ZFCP_DBF_TAG_SIZE); |
260 | strncpy(rec->tag2, tag, ZFCP_DBF_TAG_SIZE); | |
261 | ||
d26ab06e | 262 | rec->u.status.failed = atomic_read(&adapter->stat_miss); |
8a36e453 | 263 | if (status_buffer != NULL) { |
6bc473dd MP |
264 | rec->u.status.status_type = status_buffer->status_type; |
265 | rec->u.status.status_subtype = status_buffer->status_subtype; | |
266 | memcpy(&rec->u.status.queue_designator, | |
8a36e453 MS |
267 | &status_buffer->queue_designator, |
268 | sizeof(struct fsf_queue_designator)); | |
269 | ||
270 | switch (status_buffer->status_type) { | |
271 | case FSF_STATUS_READ_SENSE_DATA_AVAIL: | |
6bc473dd | 272 | rec->u.status.payload_size = |
8a36e453 MS |
273 | ZFCP_DBF_UNSOL_PAYLOAD_SENSE_DATA_AVAIL; |
274 | break; | |
275 | ||
276 | case FSF_STATUS_READ_BIT_ERROR_THRESHOLD: | |
6bc473dd | 277 | rec->u.status.payload_size = |
8a36e453 MS |
278 | ZFCP_DBF_UNSOL_PAYLOAD_BIT_ERROR_THRESHOLD; |
279 | break; | |
280 | ||
281 | case FSF_STATUS_READ_LINK_DOWN: | |
aef4a983 MS |
282 | switch (status_buffer->status_subtype) { |
283 | case FSF_STATUS_READ_SUB_NO_PHYSICAL_LINK: | |
284 | case FSF_STATUS_READ_SUB_FDISC_FAILED: | |
6bc473dd | 285 | rec->u.status.payload_size = |
aef4a983 MS |
286 | sizeof(struct fsf_link_down_info); |
287 | } | |
8a36e453 MS |
288 | break; |
289 | ||
aef4a983 | 290 | case FSF_STATUS_READ_FEATURE_UPDATE_ALERT: |
6bc473dd | 291 | rec->u.status.payload_size = |
aef4a983 MS |
292 | ZFCP_DBF_UNSOL_PAYLOAD_FEATURE_UPDATE_ALERT; |
293 | break; | |
8a36e453 | 294 | } |
6bc473dd MP |
295 | memcpy(&rec->u.status.payload, |
296 | &status_buffer->payload, rec->u.status.payload_size); | |
8a36e453 MS |
297 | } |
298 | ||
d46f384a CS |
299 | debug_event(dbf->hba_dbf, 2, rec, sizeof(*rec)); |
300 | spin_unlock_irqrestore(&dbf->hba_dbf_lock, flags); | |
8a36e453 MS |
301 | } |
302 | ||
bfab1637 MP |
303 | /** |
304 | * zfcp_hba_dbf_event_qdio - trace event for QDIO related failure | |
305 | * @adapter: adapter affected by this QDIO related event | |
bfab1637 | 306 | * @qdio_error: as passed by qdio module |
bfab1637 MP |
307 | * @sbal_index: first buffer with error condition, as passed by qdio module |
308 | * @sbal_count: number of buffers affected, as passed by qdio module | |
309 | */ | |
779e6e1c JG |
310 | void zfcp_hba_dbf_event_qdio(struct zfcp_adapter *adapter, |
311 | unsigned int qdio_error, int sbal_index, | |
312 | int sbal_count) | |
8a36e453 | 313 | { |
d46f384a CS |
314 | struct zfcp_dbf *dbf = adapter->dbf; |
315 | struct zfcp_hba_dbf_record *r = &dbf->hba_dbf_buf; | |
8a36e453 MS |
316 | unsigned long flags; |
317 | ||
d46f384a | 318 | spin_lock_irqsave(&dbf->hba_dbf_lock, flags); |
6bc473dd MP |
319 | memset(r, 0, sizeof(*r)); |
320 | strncpy(r->tag, "qdio", ZFCP_DBF_TAG_SIZE); | |
6bc473dd | 321 | r->u.qdio.qdio_error = qdio_error; |
6bc473dd MP |
322 | r->u.qdio.sbal_index = sbal_index; |
323 | r->u.qdio.sbal_count = sbal_count; | |
d46f384a CS |
324 | debug_event(dbf->hba_dbf, 0, r, sizeof(*r)); |
325 | spin_unlock_irqrestore(&dbf->hba_dbf_lock, flags); | |
8a36e453 MS |
326 | } |
327 | ||
57069386 SS |
328 | /** |
329 | * zfcp_hba_dbf_event_berr - trace event for bit error threshold | |
330 | * @adapter: adapter affected by this QDIO related event | |
331 | * @req: fsf request | |
332 | */ | |
333 | void zfcp_hba_dbf_event_berr(struct zfcp_adapter *adapter, | |
334 | struct zfcp_fsf_req *req) | |
335 | { | |
d46f384a CS |
336 | struct zfcp_dbf *dbf = adapter->dbf; |
337 | struct zfcp_hba_dbf_record *r = &dbf->hba_dbf_buf; | |
57069386 SS |
338 | struct fsf_status_read_buffer *sr_buf = req->data; |
339 | struct fsf_bit_error_payload *err = &sr_buf->payload.bit_error; | |
340 | unsigned long flags; | |
341 | ||
d46f384a | 342 | spin_lock_irqsave(&dbf->hba_dbf_lock, flags); |
57069386 SS |
343 | memset(r, 0, sizeof(*r)); |
344 | strncpy(r->tag, "berr", ZFCP_DBF_TAG_SIZE); | |
345 | memcpy(&r->u.berr, err, sizeof(struct fsf_bit_error_payload)); | |
d46f384a CS |
346 | debug_event(dbf->hba_dbf, 0, r, sizeof(*r)); |
347 | spin_unlock_irqrestore(&dbf->hba_dbf_lock, flags); | |
57069386 | 348 | } |
a9c85775 MP |
349 | static void zfcp_hba_dbf_view_response(char **p, |
350 | struct zfcp_hba_dbf_record_response *r) | |
8a36e453 | 351 | { |
8fc5af16 | 352 | struct timespec t; |
8a36e453 | 353 | |
a9c85775 MP |
354 | zfcp_dbf_out(p, "fsf_command", "0x%08x", r->fsf_command); |
355 | zfcp_dbf_out(p, "fsf_reqid", "0x%0Lx", r->fsf_reqid); | |
356 | zfcp_dbf_out(p, "fsf_seqno", "0x%08x", r->fsf_seqno); | |
b634fff7 | 357 | zfcp_dbf_timestamp(r->fsf_issued, &t); |
a9c85775 MP |
358 | zfcp_dbf_out(p, "fsf_issued", "%011lu:%06lu", t.tv_sec, t.tv_nsec); |
359 | zfcp_dbf_out(p, "fsf_prot_status", "0x%08x", r->fsf_prot_status); | |
360 | zfcp_dbf_out(p, "fsf_status", "0x%08x", r->fsf_status); | |
361 | zfcp_dbf_outd(p, "fsf_prot_status_qual", r->fsf_prot_status_qual, | |
df29f4ac | 362 | FSF_PROT_STATUS_QUAL_SIZE, 0, FSF_PROT_STATUS_QUAL_SIZE); |
a9c85775 | 363 | zfcp_dbf_outd(p, "fsf_status_qual", r->fsf_status_qual, |
df29f4ac | 364 | FSF_STATUS_QUALIFIER_SIZE, 0, FSF_STATUS_QUALIFIER_SIZE); |
a9c85775 MP |
365 | zfcp_dbf_out(p, "fsf_req_status", "0x%08x", r->fsf_req_status); |
366 | zfcp_dbf_out(p, "sbal_first", "0x%02x", r->sbal_first); | |
e891bffe | 367 | zfcp_dbf_out(p, "sbal_last", "0x%02x", r->sbal_last); |
c3baa9a2 | 368 | zfcp_dbf_out(p, "sbal_response", "0x%02x", r->sbal_response); |
a9c85775 | 369 | zfcp_dbf_out(p, "pool", "0x%02x", r->pool); |
b634fff7 MP |
370 | |
371 | switch (r->fsf_command) { | |
8a36e453 | 372 | case FSF_QTCB_FCP_CMND: |
b634fff7 | 373 | if (r->fsf_req_status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT) |
8a36e453 | 374 | break; |
6bc473dd MP |
375 | zfcp_dbf_out(p, "scsi_cmnd", "0x%0Lx", r->u.fcp.cmnd); |
376 | zfcp_dbf_out(p, "scsi_serial", "0x%016Lx", r->u.fcp.serial); | |
d94ce6c6 | 377 | p += sprintf(*p, "\n"); |
8a36e453 MS |
378 | break; |
379 | ||
380 | case FSF_QTCB_OPEN_PORT_WITH_DID: | |
381 | case FSF_QTCB_CLOSE_PORT: | |
382 | case FSF_QTCB_CLOSE_PHYSICAL_PORT: | |
6bc473dd MP |
383 | zfcp_dbf_out(p, "wwpn", "0x%016Lx", r->u.port.wwpn); |
384 | zfcp_dbf_out(p, "d_id", "0x%06x", r->u.port.d_id); | |
385 | zfcp_dbf_out(p, "port_handle", "0x%08x", r->u.port.port_handle); | |
8a36e453 MS |
386 | break; |
387 | ||
388 | case FSF_QTCB_OPEN_LUN: | |
389 | case FSF_QTCB_CLOSE_LUN: | |
6bc473dd MP |
390 | zfcp_dbf_out(p, "wwpn", "0x%016Lx", r->u.unit.wwpn); |
391 | zfcp_dbf_out(p, "fcp_lun", "0x%016Lx", r->u.unit.fcp_lun); | |
392 | zfcp_dbf_out(p, "port_handle", "0x%08x", r->u.unit.port_handle); | |
393 | zfcp_dbf_out(p, "lun_handle", "0x%08x", r->u.unit.lun_handle); | |
8a36e453 MS |
394 | break; |
395 | ||
396 | case FSF_QTCB_SEND_ELS: | |
6bc473dd MP |
397 | zfcp_dbf_out(p, "d_id", "0x%06x", r->u.els.d_id); |
398 | zfcp_dbf_out(p, "ls_code", "0x%02x", r->u.els.ls_code); | |
8a36e453 MS |
399 | break; |
400 | ||
401 | case FSF_QTCB_ABORT_FCP_CMND: | |
402 | case FSF_QTCB_SEND_GENERIC: | |
403 | case FSF_QTCB_EXCHANGE_CONFIG_DATA: | |
404 | case FSF_QTCB_EXCHANGE_PORT_DATA: | |
405 | case FSF_QTCB_DOWNLOAD_CONTROL_FILE: | |
406 | case FSF_QTCB_UPLOAD_CONTROL_FILE: | |
407 | break; | |
408 | } | |
8a36e453 MS |
409 | } |
410 | ||
a9c85775 MP |
411 | static void zfcp_hba_dbf_view_status(char **p, |
412 | struct zfcp_hba_dbf_record_status *r) | |
8a36e453 | 413 | { |
a9c85775 MP |
414 | zfcp_dbf_out(p, "failed", "0x%02x", r->failed); |
415 | zfcp_dbf_out(p, "status_type", "0x%08x", r->status_type); | |
416 | zfcp_dbf_out(p, "status_subtype", "0x%08x", r->status_subtype); | |
417 | zfcp_dbf_outd(p, "queue_designator", (char *)&r->queue_designator, | |
df29f4ac MP |
418 | sizeof(struct fsf_queue_designator), 0, |
419 | sizeof(struct fsf_queue_designator)); | |
a9c85775 | 420 | zfcp_dbf_outd(p, "payload", (char *)&r->payload, r->payload_size, 0, |
df29f4ac | 421 | r->payload_size); |
8a36e453 MS |
422 | } |
423 | ||
a9c85775 | 424 | static void zfcp_hba_dbf_view_qdio(char **p, struct zfcp_hba_dbf_record_qdio *r) |
8a36e453 | 425 | { |
a9c85775 | 426 | zfcp_dbf_out(p, "qdio_error", "0x%08x", r->qdio_error); |
a9c85775 MP |
427 | zfcp_dbf_out(p, "sbal_index", "0x%02x", r->sbal_index); |
428 | zfcp_dbf_out(p, "sbal_count", "0x%02x", r->sbal_count); | |
8a36e453 MS |
429 | } |
430 | ||
57069386 SS |
431 | static void zfcp_hba_dbf_view_berr(char **p, struct fsf_bit_error_payload *r) |
432 | { | |
433 | zfcp_dbf_out(p, "link_failures", "%d", r->link_failure_error_count); | |
434 | zfcp_dbf_out(p, "loss_of_sync_err", "%d", r->loss_of_sync_error_count); | |
435 | zfcp_dbf_out(p, "loss_of_sig_err", "%d", r->loss_of_signal_error_count); | |
436 | zfcp_dbf_out(p, "prim_seq_err", "%d", | |
437 | r->primitive_sequence_error_count); | |
438 | zfcp_dbf_out(p, "inval_trans_word_err", "%d", | |
439 | r->invalid_transmission_word_error_count); | |
440 | zfcp_dbf_out(p, "CRC_errors", "%d", r->crc_error_count); | |
441 | zfcp_dbf_out(p, "prim_seq_event_to", "%d", | |
442 | r->primitive_sequence_event_timeout_count); | |
443 | zfcp_dbf_out(p, "elast_buf_overrun_err", "%d", | |
444 | r->elastic_buffer_overrun_error_count); | |
445 | zfcp_dbf_out(p, "adv_rec_buf2buf_cred", "%d", | |
446 | r->advertised_receive_b2b_credit); | |
447 | zfcp_dbf_out(p, "curr_rec_buf2buf_cred", "%d", | |
448 | r->current_receive_b2b_credit); | |
449 | zfcp_dbf_out(p, "adv_trans_buf2buf_cred", "%d", | |
450 | r->advertised_transmit_b2b_credit); | |
451 | zfcp_dbf_out(p, "curr_trans_buf2buf_cred", "%d", | |
452 | r->current_transmit_b2b_credit); | |
453 | } | |
454 | ||
a9c85775 MP |
455 | static int zfcp_hba_dbf_view_format(debug_info_t *id, struct debug_view *view, |
456 | char *out_buf, const char *in_buf) | |
8a36e453 | 457 | { |
a9c85775 MP |
458 | struct zfcp_hba_dbf_record *r = (struct zfcp_hba_dbf_record *)in_buf; |
459 | char *p = out_buf; | |
8a36e453 | 460 | |
a9c85775 | 461 | if (strncmp(r->tag, "dump", ZFCP_DBF_TAG_SIZE) == 0) |
8a36e453 MS |
462 | return 0; |
463 | ||
a9c85775 MP |
464 | zfcp_dbf_tag(&p, "tag", r->tag); |
465 | if (isalpha(r->tag2[0])) | |
466 | zfcp_dbf_tag(&p, "tag2", r->tag2); | |
467 | ||
468 | if (strncmp(r->tag, "resp", ZFCP_DBF_TAG_SIZE) == 0) | |
6bc473dd | 469 | zfcp_hba_dbf_view_response(&p, &r->u.response); |
a9c85775 | 470 | else if (strncmp(r->tag, "stat", ZFCP_DBF_TAG_SIZE) == 0) |
6bc473dd | 471 | zfcp_hba_dbf_view_status(&p, &r->u.status); |
a9c85775 | 472 | else if (strncmp(r->tag, "qdio", ZFCP_DBF_TAG_SIZE) == 0) |
6bc473dd | 473 | zfcp_hba_dbf_view_qdio(&p, &r->u.qdio); |
57069386 SS |
474 | else if (strncmp(r->tag, "berr", ZFCP_DBF_TAG_SIZE) == 0) |
475 | zfcp_hba_dbf_view_berr(&p, &r->u.berr); | |
a9c85775 | 476 | |
d94ce6c6 CS |
477 | if (strncmp(r->tag, "resp", ZFCP_DBF_TAG_SIZE) != 0) |
478 | p += sprintf(p, "\n"); | |
a9c85775 | 479 | return p - out_buf; |
8a36e453 MS |
480 | } |
481 | ||
2b67fc46 | 482 | static struct debug_view zfcp_hba_dbf_view = { |
8a36e453 MS |
483 | "structured", |
484 | NULL, | |
485 | &zfcp_dbf_view_header, | |
486 | &zfcp_hba_dbf_view_format, | |
487 | NULL, | |
488 | NULL | |
489 | }; | |
490 | ||
d79a83db | 491 | static const char *zfcp_rec_dbf_tags[] = { |
348447e8 | 492 | [ZFCP_REC_DBF_ID_THREAD] = "thread", |
698ec016 | 493 | [ZFCP_REC_DBF_ID_TARGET] = "target", |
9467a9b3 | 494 | [ZFCP_REC_DBF_ID_TRIGGER] = "trigger", |
6f4f365e | 495 | [ZFCP_REC_DBF_ID_ACTION] = "action", |
d79a83db MP |
496 | }; |
497 | ||
d79a83db MP |
498 | static int zfcp_rec_dbf_view_format(debug_info_t *id, struct debug_view *view, |
499 | char *buf, const char *_rec) | |
500 | { | |
501 | struct zfcp_rec_dbf_record *r = (struct zfcp_rec_dbf_record *)_rec; | |
502 | char *p = buf; | |
5ffd51a5 | 503 | char hint[ZFCP_DBF_ID_SIZE + 1]; |
d79a83db | 504 | |
5ffd51a5 SS |
505 | memcpy(hint, r->id2, ZFCP_DBF_ID_SIZE); |
506 | hint[ZFCP_DBF_ID_SIZE] = 0; | |
d79a83db | 507 | zfcp_dbf_outs(&p, "tag", zfcp_rec_dbf_tags[r->id]); |
5ffd51a5 | 508 | zfcp_dbf_outs(&p, "hint", hint); |
d79a83db | 509 | switch (r->id) { |
348447e8 | 510 | case ZFCP_REC_DBF_ID_THREAD: |
348447e8 MP |
511 | zfcp_dbf_out(&p, "total", "%d", r->u.thread.total); |
512 | zfcp_dbf_out(&p, "ready", "%d", r->u.thread.ready); | |
513 | zfcp_dbf_out(&p, "running", "%d", r->u.thread.running); | |
514 | break; | |
698ec016 MP |
515 | case ZFCP_REC_DBF_ID_TARGET: |
516 | zfcp_dbf_out(&p, "reference", "0x%016Lx", r->u.target.ref); | |
517 | zfcp_dbf_out(&p, "status", "0x%08x", r->u.target.status); | |
518 | zfcp_dbf_out(&p, "erp_count", "%d", r->u.target.erp_count); | |
519 | zfcp_dbf_out(&p, "d_id", "0x%06x", r->u.target.d_id); | |
520 | zfcp_dbf_out(&p, "wwpn", "0x%016Lx", r->u.target.wwpn); | |
521 | zfcp_dbf_out(&p, "fcp_lun", "0x%016Lx", r->u.target.fcp_lun); | |
522 | break; | |
9467a9b3 MP |
523 | case ZFCP_REC_DBF_ID_TRIGGER: |
524 | zfcp_dbf_out(&p, "reference", "0x%016Lx", r->u.trigger.ref); | |
525 | zfcp_dbf_out(&p, "erp_action", "0x%016Lx", r->u.trigger.action); | |
526 | zfcp_dbf_out(&p, "requested", "%d", r->u.trigger.want); | |
527 | zfcp_dbf_out(&p, "executed", "%d", r->u.trigger.need); | |
528 | zfcp_dbf_out(&p, "wwpn", "0x%016Lx", r->u.trigger.wwpn); | |
529 | zfcp_dbf_out(&p, "fcp_lun", "0x%016Lx", r->u.trigger.fcp_lun); | |
530 | zfcp_dbf_out(&p, "adapter_status", "0x%08x", r->u.trigger.as); | |
531 | zfcp_dbf_out(&p, "port_status", "0x%08x", r->u.trigger.ps); | |
532 | zfcp_dbf_out(&p, "unit_status", "0x%08x", r->u.trigger.us); | |
533 | break; | |
6f4f365e MP |
534 | case ZFCP_REC_DBF_ID_ACTION: |
535 | zfcp_dbf_out(&p, "erp_action", "0x%016Lx", r->u.action.action); | |
536 | zfcp_dbf_out(&p, "fsf_req", "0x%016Lx", r->u.action.fsf_req); | |
537 | zfcp_dbf_out(&p, "status", "0x%08Lx", r->u.action.status); | |
538 | zfcp_dbf_out(&p, "step", "0x%08Lx", r->u.action.step); | |
539 | break; | |
d79a83db | 540 | } |
b634fff7 MP |
541 | p += sprintf(p, "\n"); |
542 | return p - buf; | |
d79a83db MP |
543 | } |
544 | ||
545 | static struct debug_view zfcp_rec_dbf_view = { | |
546 | "structured", | |
547 | NULL, | |
548 | &zfcp_dbf_view_header, | |
549 | &zfcp_rec_dbf_view_format, | |
550 | NULL, | |
551 | NULL | |
552 | }; | |
553 | ||
348447e8 MP |
554 | /** |
555 | * zfcp_rec_dbf_event_thread - trace event related to recovery thread operation | |
556 | * @id2: identifier for event | |
557 | * @adapter: adapter | |
aa0fec62 | 558 | * This function assumes that the caller is holding erp_lock. |
348447e8 | 559 | */ |
5ffd51a5 | 560 | void zfcp_rec_dbf_event_thread(char *id2, struct zfcp_adapter *adapter) |
348447e8 | 561 | { |
d46f384a CS |
562 | struct zfcp_dbf *dbf = adapter->dbf; |
563 | struct zfcp_rec_dbf_record *r = &dbf->rec_dbf_buf; | |
348447e8 MP |
564 | unsigned long flags = 0; |
565 | struct list_head *entry; | |
566 | unsigned ready = 0, running = 0, total; | |
567 | ||
348447e8 MP |
568 | list_for_each(entry, &adapter->erp_ready_head) |
569 | ready++; | |
570 | list_for_each(entry, &adapter->erp_running_head) | |
571 | running++; | |
572 | total = adapter->erp_total_count; | |
348447e8 | 573 | |
d46f384a | 574 | spin_lock_irqsave(&dbf->rec_dbf_lock, flags); |
348447e8 MP |
575 | memset(r, 0, sizeof(*r)); |
576 | r->id = ZFCP_REC_DBF_ID_THREAD; | |
5ffd51a5 | 577 | memcpy(r->id2, id2, ZFCP_DBF_ID_SIZE); |
348447e8 MP |
578 | r->u.thread.total = total; |
579 | r->u.thread.ready = ready; | |
580 | r->u.thread.running = running; | |
d46f384a CS |
581 | debug_event(dbf->rec_dbf, 6, r, sizeof(*r)); |
582 | spin_unlock_irqrestore(&dbf->rec_dbf_lock, flags); | |
348447e8 MP |
583 | } |
584 | ||
aa0fec62 CS |
585 | /** |
586 | * zfcp_rec_dbf_event_thread - trace event related to recovery thread operation | |
587 | * @id2: identifier for event | |
588 | * @adapter: adapter | |
589 | * This function assumes that the caller does not hold erp_lock. | |
590 | */ | |
5ffd51a5 | 591 | void zfcp_rec_dbf_event_thread_lock(char *id2, struct zfcp_adapter *adapter) |
aa0fec62 CS |
592 | { |
593 | unsigned long flags; | |
594 | ||
595 | read_lock_irqsave(&adapter->erp_lock, flags); | |
596 | zfcp_rec_dbf_event_thread(id2, adapter); | |
597 | read_unlock_irqrestore(&adapter->erp_lock, flags); | |
598 | } | |
599 | ||
5ffd51a5 | 600 | static void zfcp_rec_dbf_event_target(char *id2, void *ref, |
698ec016 MP |
601 | struct zfcp_adapter *adapter, |
602 | atomic_t *status, atomic_t *erp_count, | |
603 | u64 wwpn, u32 d_id, u64 fcp_lun) | |
604 | { | |
d46f384a CS |
605 | struct zfcp_dbf *dbf = adapter->dbf; |
606 | struct zfcp_rec_dbf_record *r = &dbf->rec_dbf_buf; | |
698ec016 MP |
607 | unsigned long flags; |
608 | ||
d46f384a | 609 | spin_lock_irqsave(&dbf->rec_dbf_lock, flags); |
698ec016 MP |
610 | memset(r, 0, sizeof(*r)); |
611 | r->id = ZFCP_REC_DBF_ID_TARGET; | |
5ffd51a5 | 612 | memcpy(r->id2, id2, ZFCP_DBF_ID_SIZE); |
1f6f7129 | 613 | r->u.target.ref = (unsigned long)ref; |
698ec016 MP |
614 | r->u.target.status = atomic_read(status); |
615 | r->u.target.wwpn = wwpn; | |
616 | r->u.target.d_id = d_id; | |
617 | r->u.target.fcp_lun = fcp_lun; | |
618 | r->u.target.erp_count = atomic_read(erp_count); | |
d46f384a CS |
619 | debug_event(dbf->rec_dbf, 3, r, sizeof(*r)); |
620 | spin_unlock_irqrestore(&dbf->rec_dbf_lock, flags); | |
698ec016 MP |
621 | } |
622 | ||
623 | /** | |
624 | * zfcp_rec_dbf_event_adapter - trace event for adapter state change | |
625 | * @id: identifier for trigger of state change | |
626 | * @ref: additional reference (e.g. request) | |
627 | * @adapter: adapter | |
628 | */ | |
5ffd51a5 SS |
629 | void zfcp_rec_dbf_event_adapter(char *id, void *ref, |
630 | struct zfcp_adapter *adapter) | |
698ec016 MP |
631 | { |
632 | zfcp_rec_dbf_event_target(id, ref, adapter, &adapter->status, | |
633 | &adapter->erp_counter, 0, 0, 0); | |
634 | } | |
635 | ||
636 | /** | |
637 | * zfcp_rec_dbf_event_port - trace event for port state change | |
638 | * @id: identifier for trigger of state change | |
639 | * @ref: additional reference (e.g. request) | |
640 | * @port: port | |
641 | */ | |
5ffd51a5 | 642 | void zfcp_rec_dbf_event_port(char *id, void *ref, struct zfcp_port *port) |
698ec016 MP |
643 | { |
644 | struct zfcp_adapter *adapter = port->adapter; | |
645 | ||
646 | zfcp_rec_dbf_event_target(id, ref, adapter, &port->status, | |
647 | &port->erp_counter, port->wwpn, port->d_id, | |
648 | 0); | |
649 | } | |
650 | ||
651 | /** | |
652 | * zfcp_rec_dbf_event_unit - trace event for unit state change | |
653 | * @id: identifier for trigger of state change | |
654 | * @ref: additional reference (e.g. request) | |
655 | * @unit: unit | |
656 | */ | |
5ffd51a5 | 657 | void zfcp_rec_dbf_event_unit(char *id, void *ref, struct zfcp_unit *unit) |
698ec016 MP |
658 | { |
659 | struct zfcp_port *port = unit->port; | |
660 | struct zfcp_adapter *adapter = port->adapter; | |
661 | ||
662 | zfcp_rec_dbf_event_target(id, ref, adapter, &unit->status, | |
663 | &unit->erp_counter, port->wwpn, port->d_id, | |
664 | unit->fcp_lun); | |
665 | } | |
666 | ||
9467a9b3 MP |
667 | /** |
668 | * zfcp_rec_dbf_event_trigger - trace event for triggered error recovery | |
669 | * @id2: identifier for error recovery trigger | |
670 | * @ref: additional reference (e.g. request) | |
671 | * @want: originally requested error recovery action | |
672 | * @need: error recovery action actually initiated | |
673 | * @action: address of error recovery action struct | |
674 | * @adapter: adapter | |
675 | * @port: port | |
676 | * @unit: unit | |
677 | */ | |
5ffd51a5 | 678 | void zfcp_rec_dbf_event_trigger(char *id2, void *ref, u8 want, u8 need, |
1f6f7129 | 679 | void *action, struct zfcp_adapter *adapter, |
9467a9b3 MP |
680 | struct zfcp_port *port, struct zfcp_unit *unit) |
681 | { | |
d46f384a CS |
682 | struct zfcp_dbf *dbf = adapter->dbf; |
683 | struct zfcp_rec_dbf_record *r = &dbf->rec_dbf_buf; | |
9467a9b3 MP |
684 | unsigned long flags; |
685 | ||
d46f384a | 686 | spin_lock_irqsave(&dbf->rec_dbf_lock, flags); |
9467a9b3 MP |
687 | memset(r, 0, sizeof(*r)); |
688 | r->id = ZFCP_REC_DBF_ID_TRIGGER; | |
5ffd51a5 | 689 | memcpy(r->id2, id2, ZFCP_DBF_ID_SIZE); |
1f6f7129 | 690 | r->u.trigger.ref = (unsigned long)ref; |
9467a9b3 MP |
691 | r->u.trigger.want = want; |
692 | r->u.trigger.need = need; | |
1f6f7129 | 693 | r->u.trigger.action = (unsigned long)action; |
9467a9b3 MP |
694 | r->u.trigger.as = atomic_read(&adapter->status); |
695 | if (port) { | |
696 | r->u.trigger.ps = atomic_read(&port->status); | |
697 | r->u.trigger.wwpn = port->wwpn; | |
698 | } | |
699 | if (unit) { | |
700 | r->u.trigger.us = atomic_read(&unit->status); | |
701 | r->u.trigger.fcp_lun = unit->fcp_lun; | |
702 | } | |
d46f384a CS |
703 | debug_event(dbf->rec_dbf, action ? 1 : 4, r, sizeof(*r)); |
704 | spin_unlock_irqrestore(&dbf->rec_dbf_lock, flags); | |
9467a9b3 MP |
705 | } |
706 | ||
6f4f365e MP |
707 | /** |
708 | * zfcp_rec_dbf_event_action - trace event showing progress of recovery action | |
709 | * @id2: identifier | |
710 | * @erp_action: error recovery action struct pointer | |
711 | */ | |
5ffd51a5 | 712 | void zfcp_rec_dbf_event_action(char *id2, struct zfcp_erp_action *erp_action) |
6f4f365e MP |
713 | { |
714 | struct zfcp_adapter *adapter = erp_action->adapter; | |
d46f384a CS |
715 | struct zfcp_dbf *dbf = adapter->dbf; |
716 | struct zfcp_rec_dbf_record *r = &dbf->rec_dbf_buf; | |
6f4f365e MP |
717 | unsigned long flags; |
718 | ||
d46f384a | 719 | spin_lock_irqsave(&dbf->rec_dbf_lock, flags); |
6f4f365e MP |
720 | memset(r, 0, sizeof(*r)); |
721 | r->id = ZFCP_REC_DBF_ID_ACTION; | |
5ffd51a5 | 722 | memcpy(r->id2, id2, ZFCP_DBF_ID_SIZE); |
1f6f7129 | 723 | r->u.action.action = (unsigned long)erp_action; |
6f4f365e MP |
724 | r->u.action.status = erp_action->status; |
725 | r->u.action.step = erp_action->step; | |
1f6f7129 | 726 | r->u.action.fsf_req = (unsigned long)erp_action->fsf_req; |
d46f384a CS |
727 | debug_event(dbf->rec_dbf, 5, r, sizeof(*r)); |
728 | spin_unlock_irqrestore(&dbf->rec_dbf_lock, flags); | |
6f4f365e MP |
729 | } |
730 | ||
bfab1637 MP |
731 | /** |
732 | * zfcp_san_dbf_event_ct_request - trace event for issued CT request | |
733 | * @fsf_req: request containing issued CT data | |
734 | */ | |
4d284cac | 735 | void zfcp_san_dbf_event_ct_request(struct zfcp_fsf_req *fsf_req) |
8a36e453 MS |
736 | { |
737 | struct zfcp_send_ct *ct = (struct zfcp_send_ct *)fsf_req->data; | |
5ab944f9 SS |
738 | struct zfcp_wka_port *wka_port = ct->wka_port; |
739 | struct zfcp_adapter *adapter = wka_port->adapter; | |
d46f384a | 740 | struct zfcp_dbf *dbf = adapter->dbf; |
44cc76f2 | 741 | struct ct_hdr *hdr = sg_virt(ct->req); |
d46f384a | 742 | struct zfcp_san_dbf_record *r = &dbf->san_dbf_buf; |
6bc473dd | 743 | struct zfcp_san_dbf_record_ct_request *oct = &r->u.ct_req; |
d94ce6c6 | 744 | int level = 3; |
6bc473dd | 745 | unsigned long flags; |
8a36e453 | 746 | |
d46f384a | 747 | spin_lock_irqsave(&dbf->san_dbf_lock, flags); |
6bc473dd MP |
748 | memset(r, 0, sizeof(*r)); |
749 | strncpy(r->tag, "octc", ZFCP_DBF_TAG_SIZE); | |
f0216ae9 | 750 | r->fsf_reqid = fsf_req->req_id; |
6bc473dd MP |
751 | r->fsf_seqno = fsf_req->seq_no; |
752 | r->s_id = fc_host_port_id(adapter->scsi_host); | |
5ab944f9 | 753 | r->d_id = wka_port->d_id; |
6bc473dd MP |
754 | oct->cmd_req_code = hdr->cmd_rsp_code; |
755 | oct->revision = hdr->revision; | |
756 | oct->gs_type = hdr->gs_type; | |
757 | oct->gs_subtype = hdr->gs_subtype; | |
758 | oct->options = hdr->options; | |
759 | oct->max_res_size = hdr->max_res_size; | |
760 | oct->len = min((int)ct->req->length - (int)sizeof(struct ct_hdr), | |
d94ce6c6 | 761 | ZFCP_DBF_SAN_MAX_PAYLOAD); |
d46f384a CS |
762 | debug_event(dbf->san_dbf, level, r, sizeof(*r)); |
763 | zfcp_dbf_hexdump(dbf->san_dbf, r, sizeof(*r), level, | |
d94ce6c6 | 764 | (void *)hdr + sizeof(struct ct_hdr), oct->len); |
d46f384a | 765 | spin_unlock_irqrestore(&dbf->san_dbf_lock, flags); |
8a36e453 MS |
766 | } |
767 | ||
bfab1637 MP |
768 | /** |
769 | * zfcp_san_dbf_event_ct_response - trace event for completion of CT request | |
770 | * @fsf_req: request containing CT response | |
771 | */ | |
4d284cac | 772 | void zfcp_san_dbf_event_ct_response(struct zfcp_fsf_req *fsf_req) |
8a36e453 MS |
773 | { |
774 | struct zfcp_send_ct *ct = (struct zfcp_send_ct *)fsf_req->data; | |
5ab944f9 SS |
775 | struct zfcp_wka_port *wka_port = ct->wka_port; |
776 | struct zfcp_adapter *adapter = wka_port->adapter; | |
44cc76f2 | 777 | struct ct_hdr *hdr = sg_virt(ct->resp); |
d46f384a CS |
778 | struct zfcp_dbf *dbf = adapter->dbf; |
779 | struct zfcp_san_dbf_record *r = &dbf->san_dbf_buf; | |
6bc473dd | 780 | struct zfcp_san_dbf_record_ct_response *rct = &r->u.ct_resp; |
d94ce6c6 | 781 | int level = 3; |
6bc473dd | 782 | unsigned long flags; |
8a36e453 | 783 | |
d46f384a | 784 | spin_lock_irqsave(&dbf->san_dbf_lock, flags); |
6bc473dd MP |
785 | memset(r, 0, sizeof(*r)); |
786 | strncpy(r->tag, "rctc", ZFCP_DBF_TAG_SIZE); | |
f0216ae9 | 787 | r->fsf_reqid = fsf_req->req_id; |
6bc473dd | 788 | r->fsf_seqno = fsf_req->seq_no; |
5ab944f9 | 789 | r->s_id = wka_port->d_id; |
6bc473dd MP |
790 | r->d_id = fc_host_port_id(adapter->scsi_host); |
791 | rct->cmd_rsp_code = hdr->cmd_rsp_code; | |
792 | rct->revision = hdr->revision; | |
793 | rct->reason_code = hdr->reason_code; | |
794 | rct->expl = hdr->reason_code_expl; | |
795 | rct->vendor_unique = hdr->vendor_unique; | |
39eb7e9a | 796 | rct->max_res_size = hdr->max_res_size; |
6bc473dd | 797 | rct->len = min((int)ct->resp->length - (int)sizeof(struct ct_hdr), |
d94ce6c6 | 798 | ZFCP_DBF_SAN_MAX_PAYLOAD); |
d46f384a CS |
799 | debug_event(dbf->san_dbf, level, r, sizeof(*r)); |
800 | zfcp_dbf_hexdump(dbf->san_dbf, r, sizeof(*r), level, | |
d94ce6c6 | 801 | (void *)hdr + sizeof(struct ct_hdr), rct->len); |
d46f384a | 802 | spin_unlock_irqrestore(&dbf->san_dbf_lock, flags); |
8a36e453 MS |
803 | } |
804 | ||
92c7a83f MP |
805 | static void zfcp_san_dbf_event_els(const char *tag, int level, |
806 | struct zfcp_fsf_req *fsf_req, u32 s_id, | |
807 | u32 d_id, u8 ls_code, void *buffer, | |
808 | int buflen) | |
8a36e453 MS |
809 | { |
810 | struct zfcp_adapter *adapter = fsf_req->adapter; | |
d46f384a CS |
811 | struct zfcp_dbf *dbf = adapter->dbf; |
812 | struct zfcp_san_dbf_record *rec = &dbf->san_dbf_buf; | |
8a36e453 | 813 | unsigned long flags; |
8a36e453 | 814 | |
d46f384a | 815 | spin_lock_irqsave(&dbf->san_dbf_lock, flags); |
6bc473dd | 816 | memset(rec, 0, sizeof(*rec)); |
0f65e951 | 817 | strncpy(rec->tag, tag, ZFCP_DBF_TAG_SIZE); |
f0216ae9 | 818 | rec->fsf_reqid = fsf_req->req_id; |
0f65e951 MP |
819 | rec->fsf_seqno = fsf_req->seq_no; |
820 | rec->s_id = s_id; | |
821 | rec->d_id = d_id; | |
6bc473dd | 822 | rec->u.els.ls_code = ls_code; |
d46f384a CS |
823 | debug_event(dbf->san_dbf, level, rec, sizeof(*rec)); |
824 | zfcp_dbf_hexdump(dbf->san_dbf, rec, sizeof(*rec), level, | |
d94ce6c6 | 825 | buffer, min(buflen, ZFCP_DBF_SAN_MAX_PAYLOAD)); |
d46f384a | 826 | spin_unlock_irqrestore(&dbf->san_dbf_lock, flags); |
8a36e453 MS |
827 | } |
828 | ||
bfab1637 MP |
829 | /** |
830 | * zfcp_san_dbf_event_els_request - trace event for issued ELS | |
831 | * @fsf_req: request containing issued ELS | |
832 | */ | |
4d284cac | 833 | void zfcp_san_dbf_event_els_request(struct zfcp_fsf_req *fsf_req) |
8a36e453 MS |
834 | { |
835 | struct zfcp_send_els *els = (struct zfcp_send_els *)fsf_req->data; | |
836 | ||
92c7a83f MP |
837 | zfcp_san_dbf_event_els("oels", 2, fsf_req, |
838 | fc_host_port_id(els->adapter->scsi_host), | |
44cc76f2 SS |
839 | els->d_id, *(u8 *) sg_virt(els->req), |
840 | sg_virt(els->req), els->req->length); | |
8a36e453 MS |
841 | } |
842 | ||
bfab1637 MP |
843 | /** |
844 | * zfcp_san_dbf_event_els_response - trace event for completed ELS | |
845 | * @fsf_req: request containing ELS response | |
846 | */ | |
4d284cac | 847 | void zfcp_san_dbf_event_els_response(struct zfcp_fsf_req *fsf_req) |
8a36e453 MS |
848 | { |
849 | struct zfcp_send_els *els = (struct zfcp_send_els *)fsf_req->data; | |
850 | ||
92c7a83f MP |
851 | zfcp_san_dbf_event_els("rels", 2, fsf_req, els->d_id, |
852 | fc_host_port_id(els->adapter->scsi_host), | |
44cc76f2 | 853 | *(u8 *)sg_virt(els->req), sg_virt(els->resp), |
92c7a83f | 854 | els->resp->length); |
8a36e453 MS |
855 | } |
856 | ||
bfab1637 MP |
857 | /** |
858 | * zfcp_san_dbf_event_incoming_els - trace event for incomig ELS | |
859 | * @fsf_req: request containing unsolicited status buffer with incoming ELS | |
860 | */ | |
4d284cac | 861 | void zfcp_san_dbf_event_incoming_els(struct zfcp_fsf_req *fsf_req) |
8a36e453 MS |
862 | { |
863 | struct zfcp_adapter *adapter = fsf_req->adapter; | |
92c7a83f MP |
864 | struct fsf_status_read_buffer *buf = |
865 | (struct fsf_status_read_buffer *)fsf_req->data; | |
866 | int length = (int)buf->length - | |
867 | (int)((void *)&buf->payload - (void *)buf); | |
868 | ||
869 | zfcp_san_dbf_event_els("iels", 1, fsf_req, buf->d_id, | |
870 | fc_host_port_id(adapter->scsi_host), | |
c41f8cbd | 871 | buf->payload.data[0], (void *)buf->payload.data, |
92c7a83f | 872 | length); |
8a36e453 MS |
873 | } |
874 | ||
92c7a83f MP |
875 | static int zfcp_san_dbf_view_format(debug_info_t *id, struct debug_view *view, |
876 | char *out_buf, const char *in_buf) | |
8a36e453 | 877 | { |
b634fff7 | 878 | struct zfcp_san_dbf_record *r = (struct zfcp_san_dbf_record *)in_buf; |
b634fff7 | 879 | char *p = out_buf; |
8a36e453 | 880 | |
b634fff7 | 881 | if (strncmp(r->tag, "dump", ZFCP_DBF_TAG_SIZE) == 0) |
8a36e453 MS |
882 | return 0; |
883 | ||
a9c85775 | 884 | zfcp_dbf_tag(&p, "tag", r->tag); |
b634fff7 MP |
885 | zfcp_dbf_out(&p, "fsf_reqid", "0x%0Lx", r->fsf_reqid); |
886 | zfcp_dbf_out(&p, "fsf_seqno", "0x%08x", r->fsf_seqno); | |
887 | zfcp_dbf_out(&p, "s_id", "0x%06x", r->s_id); | |
888 | zfcp_dbf_out(&p, "d_id", "0x%06x", r->d_id); | |
889 | ||
890 | if (strncmp(r->tag, "octc", ZFCP_DBF_TAG_SIZE) == 0) { | |
6bc473dd MP |
891 | struct zfcp_san_dbf_record_ct_request *ct = &r->u.ct_req; |
892 | zfcp_dbf_out(&p, "cmd_req_code", "0x%04x", ct->cmd_req_code); | |
893 | zfcp_dbf_out(&p, "revision", "0x%02x", ct->revision); | |
894 | zfcp_dbf_out(&p, "gs_type", "0x%02x", ct->gs_type); | |
895 | zfcp_dbf_out(&p, "gs_subtype", "0x%02x", ct->gs_subtype); | |
896 | zfcp_dbf_out(&p, "options", "0x%02x", ct->options); | |
897 | zfcp_dbf_out(&p, "max_res_size", "0x%04x", ct->max_res_size); | |
b634fff7 | 898 | } else if (strncmp(r->tag, "rctc", ZFCP_DBF_TAG_SIZE) == 0) { |
6bc473dd MP |
899 | struct zfcp_san_dbf_record_ct_response *ct = &r->u.ct_resp; |
900 | zfcp_dbf_out(&p, "cmd_rsp_code", "0x%04x", ct->cmd_rsp_code); | |
901 | zfcp_dbf_out(&p, "revision", "0x%02x", ct->revision); | |
902 | zfcp_dbf_out(&p, "reason_code", "0x%02x", ct->reason_code); | |
903 | zfcp_dbf_out(&p, "reason_code_expl", "0x%02x", ct->expl); | |
904 | zfcp_dbf_out(&p, "vendor_unique", "0x%02x", ct->vendor_unique); | |
39eb7e9a | 905 | zfcp_dbf_out(&p, "max_res_size", "0x%04x", ct->max_res_size); |
b634fff7 MP |
906 | } else if (strncmp(r->tag, "oels", ZFCP_DBF_TAG_SIZE) == 0 || |
907 | strncmp(r->tag, "rels", ZFCP_DBF_TAG_SIZE) == 0 || | |
908 | strncmp(r->tag, "iels", ZFCP_DBF_TAG_SIZE) == 0) { | |
6bc473dd MP |
909 | struct zfcp_san_dbf_record_els *els = &r->u.els; |
910 | zfcp_dbf_out(&p, "ls_code", "0x%02x", els->ls_code); | |
8a36e453 | 911 | } |
b634fff7 | 912 | return p - out_buf; |
8a36e453 MS |
913 | } |
914 | ||
2b67fc46 | 915 | static struct debug_view zfcp_san_dbf_view = { |
8a36e453 MS |
916 | "structured", |
917 | NULL, | |
918 | &zfcp_dbf_view_header, | |
919 | &zfcp_san_dbf_view_format, | |
920 | NULL, | |
921 | NULL | |
922 | }; | |
923 | ||
92c7a83f MP |
924 | static void zfcp_scsi_dbf_event(const char *tag, const char *tag2, int level, |
925 | struct zfcp_adapter *adapter, | |
926 | struct scsi_cmnd *scsi_cmnd, | |
927 | struct zfcp_fsf_req *fsf_req, | |
928 | unsigned long old_req_id) | |
8a36e453 | 929 | { |
d46f384a CS |
930 | struct zfcp_dbf *dbf = adapter->dbf; |
931 | struct zfcp_scsi_dbf_record *rec = &dbf->scsi_dbf_buf; | |
8a36e453 MS |
932 | struct zfcp_dbf_dump *dump = (struct zfcp_dbf_dump *)rec; |
933 | unsigned long flags; | |
934 | struct fcp_rsp_iu *fcp_rsp; | |
935 | char *fcp_rsp_info = NULL, *fcp_sns_info = NULL; | |
936 | int offset = 0, buflen = 0; | |
937 | ||
d46f384a | 938 | spin_lock_irqsave(&dbf->scsi_dbf_lock, flags); |
8a36e453 | 939 | do { |
6bc473dd | 940 | memset(rec, 0, sizeof(*rec)); |
8a36e453 MS |
941 | if (offset == 0) { |
942 | strncpy(rec->tag, tag, ZFCP_DBF_TAG_SIZE); | |
943 | strncpy(rec->tag2, tag2, ZFCP_DBF_TAG_SIZE); | |
ed829ad6 MS |
944 | if (scsi_cmnd != NULL) { |
945 | if (scsi_cmnd->device) { | |
946 | rec->scsi_id = scsi_cmnd->device->id; | |
947 | rec->scsi_lun = scsi_cmnd->device->lun; | |
948 | } | |
949 | rec->scsi_result = scsi_cmnd->result; | |
950 | rec->scsi_cmnd = (unsigned long)scsi_cmnd; | |
951 | rec->scsi_serial = scsi_cmnd->serial_number; | |
64a87b24 | 952 | memcpy(rec->scsi_opcode, scsi_cmnd->cmnd, |
ed829ad6 MS |
953 | min((int)scsi_cmnd->cmd_len, |
954 | ZFCP_DBF_SCSI_OPCODE)); | |
955 | rec->scsi_retries = scsi_cmnd->retries; | |
956 | rec->scsi_allowed = scsi_cmnd->allowed; | |
8a36e453 | 957 | } |
8a36e453 MS |
958 | if (fsf_req != NULL) { |
959 | fcp_rsp = (struct fcp_rsp_iu *) | |
960 | &(fsf_req->qtcb->bottom.io.fcp_rsp); | |
f76af7d7 | 961 | fcp_rsp_info = (unsigned char *) &fcp_rsp[1]; |
8a36e453 MS |
962 | fcp_sns_info = |
963 | zfcp_get_fcp_sns_info_ptr(fcp_rsp); | |
964 | ||
6bc473dd MP |
965 | rec->rsp_validity = fcp_rsp->validity.value; |
966 | rec->rsp_scsi_status = fcp_rsp->scsi_status; | |
967 | rec->rsp_resid = fcp_rsp->fcp_resid; | |
8a36e453 | 968 | if (fcp_rsp->validity.bits.fcp_rsp_len_valid) |
6bc473dd | 969 | rec->rsp_code = *(fcp_rsp_info + 3); |
8a36e453 MS |
970 | if (fcp_rsp->validity.bits.fcp_sns_len_valid) { |
971 | buflen = min((int)fcp_rsp->fcp_sns_len, | |
972 | ZFCP_DBF_SCSI_MAX_FCP_SNS_INFO); | |
6bc473dd MP |
973 | rec->sns_info_len = buflen; |
974 | memcpy(rec->sns_info, fcp_sns_info, | |
8a36e453 MS |
975 | min(buflen, |
976 | ZFCP_DBF_SCSI_FCP_SNS_INFO)); | |
977 | offset += min(buflen, | |
978 | ZFCP_DBF_SCSI_FCP_SNS_INFO); | |
979 | } | |
980 | ||
f0216ae9 | 981 | rec->fsf_reqid = fsf_req->req_id; |
8a36e453 MS |
982 | rec->fsf_seqno = fsf_req->seq_no; |
983 | rec->fsf_issued = fsf_req->issued; | |
984 | } | |
6bc473dd | 985 | rec->old_fsf_reqid = old_req_id; |
8a36e453 MS |
986 | } else { |
987 | strncpy(dump->tag, "dump", ZFCP_DBF_TAG_SIZE); | |
988 | dump->total_size = buflen; | |
989 | dump->offset = offset; | |
990 | dump->size = min(buflen - offset, | |
991 | (int)sizeof(struct | |
992 | zfcp_scsi_dbf_record) - | |
993 | (int)sizeof(struct zfcp_dbf_dump)); | |
994 | memcpy(dump->data, fcp_sns_info + offset, dump->size); | |
995 | offset += dump->size; | |
996 | } | |
d46f384a | 997 | debug_event(dbf->scsi_dbf, level, rec, sizeof(*rec)); |
8a36e453 | 998 | } while (offset < buflen); |
d46f384a | 999 | spin_unlock_irqrestore(&dbf->scsi_dbf_lock, flags); |
8a36e453 MS |
1000 | } |
1001 | ||
bfab1637 MP |
1002 | /** |
1003 | * zfcp_scsi_dbf_event_result - trace event for SCSI command completion | |
1004 | * @tag: tag indicating success or failure of SCSI command | |
1005 | * @level: trace level applicable for this event | |
1006 | * @adapter: adapter that has been used to issue the SCSI command | |
1007 | * @scsi_cmnd: SCSI command pointer | |
1008 | * @fsf_req: request used to issue SCSI command (might be NULL) | |
1009 | */ | |
92c7a83f MP |
1010 | void zfcp_scsi_dbf_event_result(const char *tag, int level, |
1011 | struct zfcp_adapter *adapter, | |
1012 | struct scsi_cmnd *scsi_cmnd, | |
1013 | struct zfcp_fsf_req *fsf_req) | |
8a36e453 | 1014 | { |
92c7a83f | 1015 | zfcp_scsi_dbf_event("rslt", tag, level, adapter, scsi_cmnd, fsf_req, 0); |
8a36e453 MS |
1016 | } |
1017 | ||
bfab1637 MP |
1018 | /** |
1019 | * zfcp_scsi_dbf_event_abort - trace event for SCSI command abort | |
1020 | * @tag: tag indicating success or failure of abort operation | |
1021 | * @adapter: adapter thas has been used to issue SCSI command to be aborted | |
1022 | * @scsi_cmnd: SCSI command to be aborted | |
1023 | * @new_fsf_req: request containing abort (might be NULL) | |
1024 | * @old_req_id: identifier of request containg SCSI command to be aborted | |
1025 | */ | |
92c7a83f MP |
1026 | void zfcp_scsi_dbf_event_abort(const char *tag, struct zfcp_adapter *adapter, |
1027 | struct scsi_cmnd *scsi_cmnd, | |
1028 | struct zfcp_fsf_req *new_fsf_req, | |
1029 | unsigned long old_req_id) | |
8a36e453 | 1030 | { |
92c7a83f MP |
1031 | zfcp_scsi_dbf_event("abrt", tag, 1, adapter, scsi_cmnd, new_fsf_req, |
1032 | old_req_id); | |
8a36e453 MS |
1033 | } |
1034 | ||
bfab1637 MP |
1035 | /** |
1036 | * zfcp_scsi_dbf_event_devreset - trace event for Logical Unit or Target Reset | |
1037 | * @tag: tag indicating success or failure of reset operation | |
1038 | * @flag: indicates type of reset (Target Reset, Logical Unit Reset) | |
1039 | * @unit: unit that needs reset | |
1040 | * @scsi_cmnd: SCSI command which caused this error recovery | |
1041 | */ | |
92c7a83f MP |
1042 | void zfcp_scsi_dbf_event_devreset(const char *tag, u8 flag, |
1043 | struct zfcp_unit *unit, | |
1044 | struct scsi_cmnd *scsi_cmnd) | |
8a36e453 | 1045 | { |
92c7a83f MP |
1046 | zfcp_scsi_dbf_event(flag == FCP_TARGET_RESET ? "trst" : "lrst", tag, 1, |
1047 | unit->port->adapter, scsi_cmnd, NULL, 0); | |
8a36e453 MS |
1048 | } |
1049 | ||
92c7a83f MP |
1050 | static int zfcp_scsi_dbf_view_format(debug_info_t *id, struct debug_view *view, |
1051 | char *out_buf, const char *in_buf) | |
8a36e453 | 1052 | { |
b634fff7 | 1053 | struct zfcp_scsi_dbf_record *r = (struct zfcp_scsi_dbf_record *)in_buf; |
8fc5af16 | 1054 | struct timespec t; |
b634fff7 | 1055 | char *p = out_buf; |
8a36e453 | 1056 | |
b634fff7 | 1057 | if (strncmp(r->tag, "dump", ZFCP_DBF_TAG_SIZE) == 0) |
8a36e453 MS |
1058 | return 0; |
1059 | ||
a9c85775 MP |
1060 | zfcp_dbf_tag(&p, "tag", r->tag); |
1061 | zfcp_dbf_tag(&p, "tag2", r->tag2); | |
b634fff7 MP |
1062 | zfcp_dbf_out(&p, "scsi_id", "0x%08x", r->scsi_id); |
1063 | zfcp_dbf_out(&p, "scsi_lun", "0x%08x", r->scsi_lun); | |
1064 | zfcp_dbf_out(&p, "scsi_result", "0x%08x", r->scsi_result); | |
1065 | zfcp_dbf_out(&p, "scsi_cmnd", "0x%0Lx", r->scsi_cmnd); | |
1066 | zfcp_dbf_out(&p, "scsi_serial", "0x%016Lx", r->scsi_serial); | |
df29f4ac MP |
1067 | zfcp_dbf_outd(&p, "scsi_opcode", r->scsi_opcode, ZFCP_DBF_SCSI_OPCODE, |
1068 | 0, ZFCP_DBF_SCSI_OPCODE); | |
b634fff7 MP |
1069 | zfcp_dbf_out(&p, "scsi_retries", "0x%02x", r->scsi_retries); |
1070 | zfcp_dbf_out(&p, "scsi_allowed", "0x%02x", r->scsi_allowed); | |
1071 | if (strncmp(r->tag, "abrt", ZFCP_DBF_TAG_SIZE) == 0) | |
6bc473dd | 1072 | zfcp_dbf_out(&p, "old_fsf_reqid", "0x%0Lx", r->old_fsf_reqid); |
b634fff7 MP |
1073 | zfcp_dbf_out(&p, "fsf_reqid", "0x%0Lx", r->fsf_reqid); |
1074 | zfcp_dbf_out(&p, "fsf_seqno", "0x%08x", r->fsf_seqno); | |
1075 | zfcp_dbf_timestamp(r->fsf_issued, &t); | |
1076 | zfcp_dbf_out(&p, "fsf_issued", "%011lu:%06lu", t.tv_sec, t.tv_nsec); | |
1077 | ||
1078 | if (strncmp(r->tag, "rslt", ZFCP_DBF_TAG_SIZE) == 0) { | |
6bc473dd MP |
1079 | zfcp_dbf_out(&p, "fcp_rsp_validity", "0x%02x", r->rsp_validity); |
1080 | zfcp_dbf_out(&p, "fcp_rsp_scsi_status", "0x%02x", | |
1081 | r->rsp_scsi_status); | |
1082 | zfcp_dbf_out(&p, "fcp_rsp_resid", "0x%08x", r->rsp_resid); | |
1083 | zfcp_dbf_out(&p, "fcp_rsp_code", "0x%08x", r->rsp_code); | |
1084 | zfcp_dbf_out(&p, "fcp_sns_info_len", "0x%08x", r->sns_info_len); | |
1085 | zfcp_dbf_outd(&p, "fcp_sns_info", r->sns_info, | |
1086 | min((int)r->sns_info_len, | |
df29f4ac | 1087 | ZFCP_DBF_SCSI_FCP_SNS_INFO), 0, |
6bc473dd | 1088 | r->sns_info_len); |
8a36e453 | 1089 | } |
b634fff7 MP |
1090 | p += sprintf(p, "\n"); |
1091 | return p - out_buf; | |
8a36e453 MS |
1092 | } |
1093 | ||
2b67fc46 | 1094 | static struct debug_view zfcp_scsi_dbf_view = { |
8a36e453 MS |
1095 | "structured", |
1096 | NULL, | |
1097 | &zfcp_dbf_view_header, | |
1098 | &zfcp_scsi_dbf_view_format, | |
1099 | NULL, | |
1100 | NULL | |
1101 | }; | |
1102 | ||
d46f384a CS |
1103 | static debug_info_t *zfcp_dbf_reg(const char *name, int level, |
1104 | struct debug_view *view, int size) | |
1105 | { | |
1106 | struct debug_info *d; | |
1107 | ||
1108 | d = debug_register(name, dbfsize, level, size); | |
1109 | if (!d) | |
1110 | return NULL; | |
1111 | ||
1112 | debug_register_view(d, &debug_hex_ascii_view); | |
1113 | debug_register_view(d, view); | |
1114 | debug_set_level(d, level); | |
1115 | ||
1116 | return d; | |
1117 | } | |
1118 | ||
8a36e453 MS |
1119 | /** |
1120 | * zfcp_adapter_debug_register - registers debug feature for an adapter | |
1121 | * @adapter: pointer to adapter for which debug features should be registered | |
1122 | * return: -ENOMEM on error, 0 otherwise | |
1123 | */ | |
1124 | int zfcp_adapter_debug_register(struct zfcp_adapter *adapter) | |
1125 | { | |
1126 | char dbf_name[DEBUG_MAX_NAME_LEN]; | |
d46f384a CS |
1127 | struct zfcp_dbf *dbf; |
1128 | ||
1129 | dbf = kmalloc(sizeof(struct zfcp_dbf), GFP_KERNEL); | |
1130 | if (!dbf) | |
1131 | return -ENOMEM; | |
1132 | ||
1133 | spin_lock_init(&dbf->hba_dbf_lock); | |
1134 | spin_lock_init(&dbf->san_dbf_lock); | |
1135 | spin_lock_init(&dbf->scsi_dbf_lock); | |
1136 | spin_lock_init(&dbf->rec_dbf_lock); | |
8a36e453 | 1137 | |
d79a83db | 1138 | /* debug feature area which records recovery activity */ |
b225cf9b | 1139 | sprintf(dbf_name, "zfcp_%s_rec", dev_name(&adapter->ccw_device->dev)); |
d46f384a CS |
1140 | dbf->rec_dbf = zfcp_dbf_reg(dbf_name, 3, &zfcp_rec_dbf_view, |
1141 | sizeof(struct zfcp_rec_dbf_record)); | |
1142 | if (!dbf->rec_dbf) | |
1143 | goto fail_rec; | |
d79a83db | 1144 | |
8a36e453 | 1145 | /* debug feature area which records HBA (FSF and QDIO) conditions */ |
b225cf9b | 1146 | sprintf(dbf_name, "zfcp_%s_hba", dev_name(&adapter->ccw_device->dev)); |
d46f384a CS |
1147 | dbf->hba_dbf = zfcp_dbf_reg(dbf_name, 3, &zfcp_hba_dbf_view, |
1148 | sizeof(struct zfcp_hba_dbf_record)); | |
1149 | if (!dbf->hba_dbf) | |
1150 | goto fail_hba; | |
8a36e453 MS |
1151 | |
1152 | /* debug feature area which records SAN command failures and recovery */ | |
b225cf9b | 1153 | sprintf(dbf_name, "zfcp_%s_san", dev_name(&adapter->ccw_device->dev)); |
d46f384a CS |
1154 | dbf->san_dbf = zfcp_dbf_reg(dbf_name, 6, &zfcp_san_dbf_view, |
1155 | sizeof(struct zfcp_san_dbf_record)); | |
1156 | if (!dbf->san_dbf) | |
1157 | goto fail_san; | |
8a36e453 MS |
1158 | |
1159 | /* debug feature area which records SCSI command failures and recovery */ | |
b225cf9b | 1160 | sprintf(dbf_name, "zfcp_%s_scsi", dev_name(&adapter->ccw_device->dev)); |
d46f384a CS |
1161 | dbf->scsi_dbf = zfcp_dbf_reg(dbf_name, 3, &zfcp_scsi_dbf_view, |
1162 | sizeof(struct zfcp_scsi_dbf_record)); | |
1163 | if (!dbf->scsi_dbf) | |
1164 | goto fail_scsi; | |
8a36e453 | 1165 | |
d46f384a | 1166 | adapter->dbf = dbf; |
8a36e453 MS |
1167 | return 0; |
1168 | ||
d46f384a CS |
1169 | fail_scsi: |
1170 | debug_unregister(dbf->san_dbf); | |
1171 | fail_san: | |
1172 | debug_unregister(dbf->hba_dbf); | |
1173 | fail_hba: | |
1174 | debug_unregister(dbf->rec_dbf); | |
1175 | fail_rec: | |
1176 | kfree(dbf); | |
8a36e453 MS |
1177 | return -ENOMEM; |
1178 | } | |
1179 | ||
1180 | /** | |
1181 | * zfcp_adapter_debug_unregister - unregisters debug feature for an adapter | |
1182 | * @adapter: pointer to adapter for which debug features should be unregistered | |
1183 | */ | |
1184 | void zfcp_adapter_debug_unregister(struct zfcp_adapter *adapter) | |
1185 | { | |
d46f384a CS |
1186 | debug_unregister(adapter->dbf->scsi_dbf); |
1187 | debug_unregister(adapter->dbf->san_dbf); | |
1188 | debug_unregister(adapter->dbf->hba_dbf); | |
1189 | debug_unregister(adapter->dbf->rec_dbf); | |
1190 | kfree(adapter->dbf); | |
1191 | adapter->dbf = NULL; | |
8a36e453 | 1192 | } |