Commit | Line | Data |
---|---|---|
8a36e453 | 1 | /* |
553448f6 | 2 | * zfcp device driver |
8a36e453 | 3 | * |
553448f6 | 4 | * Debug traces for zfcp. |
8a36e453 | 5 | * |
bf3ea3ae | 6 | * Copyright IBM Corp. 2002, 2013 |
8a36e453 MS |
7 | */ |
8 | ||
ecf39d42 CS |
9 | #define KMSG_COMPONENT "zfcp" |
10 | #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt | |
11 | ||
3a4c5d59 | 12 | #include <linux/module.h> |
8a36e453 | 13 | #include <linux/ctype.h> |
5a0e3ad6 | 14 | #include <linux/slab.h> |
364c8558 | 15 | #include <asm/debug.h> |
d46f384a | 16 | #include "zfcp_dbf.h" |
8a36e453 | 17 | #include "zfcp_ext.h" |
bd0072ec | 18 | #include "zfcp_fc.h" |
8a36e453 MS |
19 | |
20 | static u32 dbfsize = 4; | |
21 | ||
22 | module_param(dbfsize, uint, 0400); | |
23 | MODULE_PARM_DESC(dbfsize, | |
24 | "number of pages for each debug feature area (default 4)"); | |
25 | ||
bf3ea3ae SM |
26 | static u32 dbflevel = 3; |
27 | ||
28 | module_param(dbflevel, uint, 0400); | |
29 | MODULE_PARM_DESC(dbflevel, | |
30 | "log level for each debug feature area " | |
31 | "(default 3, range 0..6)"); | |
32 | ||
a54ca0f6 | 33 | static inline unsigned int zfcp_dbf_plen(unsigned int offset) |
c15450e3 | 34 | { |
a54ca0f6 SS |
35 | return sizeof(struct zfcp_dbf_pay) + offset - ZFCP_DBF_PAY_MAX_REC; |
36 | } | |
37 | ||
38 | static inline | |
39 | void zfcp_dbf_pl_write(struct zfcp_dbf *dbf, void *data, u16 length, char *area, | |
40 | u64 req_id) | |
41 | { | |
42 | struct zfcp_dbf_pay *pl = &dbf->pay_buf; | |
43 | u16 offset = 0, rec_length; | |
44 | ||
45 | spin_lock(&dbf->pay_lock); | |
46 | memset(pl, 0, sizeof(*pl)); | |
47 | pl->fsf_req_id = req_id; | |
48 | memcpy(pl->area, area, ZFCP_DBF_TAG_LEN); | |
49 | ||
50 | while (offset < length) { | |
51 | rec_length = min((u16) ZFCP_DBF_PAY_MAX_REC, | |
52 | (u16) (length - offset)); | |
53 | memcpy(pl->data, data + offset, rec_length); | |
54 | debug_event(dbf->pay, 1, pl, zfcp_dbf_plen(rec_length)); | |
55 | ||
56 | offset += rec_length; | |
57 | pl->counter++; | |
c15450e3 | 58 | } |
a54ca0f6 SS |
59 | |
60 | spin_unlock(&dbf->pay_lock); | |
c15450e3 MP |
61 | } |
62 | ||
a54ca0f6 SS |
63 | /** |
64 | * zfcp_dbf_hba_fsf_res - trace event for fsf responses | |
65 | * @tag: tag indicating which kind of unsolicited status has been received | |
66 | * @req: request for which a response was received | |
67 | */ | |
68 | void zfcp_dbf_hba_fsf_res(char *tag, struct zfcp_fsf_req *req) | |
8a36e453 | 69 | { |
a54ca0f6 SS |
70 | struct zfcp_dbf *dbf = req->adapter->dbf; |
71 | struct fsf_qtcb_prefix *q_pref = &req->qtcb->prefix; | |
72 | struct fsf_qtcb_header *q_head = &req->qtcb->header; | |
73 | struct zfcp_dbf_hba *rec = &dbf->hba_buf; | |
8a36e453 MS |
74 | unsigned long flags; |
75 | ||
5771710b | 76 | spin_lock_irqsave(&dbf->hba_lock, flags); |
6bc473dd | 77 | memset(rec, 0, sizeof(*rec)); |
8a36e453 | 78 | |
a54ca0f6 SS |
79 | memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN); |
80 | rec->id = ZFCP_DBF_HBA_RES; | |
81 | rec->fsf_req_id = req->req_id; | |
82 | rec->fsf_req_status = req->status; | |
83 | rec->fsf_cmd = req->fsf_command; | |
84 | rec->fsf_seq_no = req->seq_no; | |
85 | rec->u.res.req_issued = req->issued; | |
86 | rec->u.res.prot_status = q_pref->prot_status; | |
87 | rec->u.res.fsf_status = q_head->fsf_status; | |
88 | ||
89 | memcpy(rec->u.res.prot_status_qual, &q_pref->prot_status_qual, | |
90 | FSF_PROT_STATUS_QUAL_SIZE); | |
91 | memcpy(rec->u.res.fsf_status_qual, &q_head->fsf_status_qual, | |
92 | FSF_STATUS_QUALIFIER_SIZE); | |
93 | ||
94 | if (req->fsf_command != FSF_QTCB_FCP_CMND) { | |
95 | rec->pl_len = q_head->log_length; | |
96 | zfcp_dbf_pl_write(dbf, (char *)q_pref + q_head->log_start, | |
97 | rec->pl_len, "fsf_res", req->req_id); | |
8a36e453 MS |
98 | } |
99 | ||
a54ca0f6 | 100 | debug_event(dbf->hba, 1, rec, sizeof(*rec)); |
5771710b | 101 | spin_unlock_irqrestore(&dbf->hba_lock, flags); |
8a36e453 MS |
102 | } |
103 | ||
bfab1637 | 104 | /** |
a54ca0f6 SS |
105 | * zfcp_dbf_hba_fsf_uss - trace event for an unsolicited status buffer |
106 | * @tag: tag indicating which kind of unsolicited status has been received | |
107 | * @req: request providing the unsolicited status | |
bfab1637 | 108 | */ |
a54ca0f6 | 109 | void zfcp_dbf_hba_fsf_uss(char *tag, struct zfcp_fsf_req *req) |
8a36e453 | 110 | { |
a54ca0f6 SS |
111 | struct zfcp_dbf *dbf = req->adapter->dbf; |
112 | struct fsf_status_read_buffer *srb = req->data; | |
113 | struct zfcp_dbf_hba *rec = &dbf->hba_buf; | |
8a36e453 MS |
114 | unsigned long flags; |
115 | ||
5771710b | 116 | spin_lock_irqsave(&dbf->hba_lock, flags); |
a54ca0f6 SS |
117 | memset(rec, 0, sizeof(*rec)); |
118 | ||
119 | memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN); | |
120 | rec->id = ZFCP_DBF_HBA_USS; | |
121 | rec->fsf_req_id = req->req_id; | |
122 | rec->fsf_req_status = req->status; | |
123 | rec->fsf_cmd = req->fsf_command; | |
124 | ||
125 | if (!srb) | |
126 | goto log; | |
127 | ||
128 | rec->u.uss.status_type = srb->status_type; | |
129 | rec->u.uss.status_subtype = srb->status_subtype; | |
130 | rec->u.uss.d_id = ntoh24(srb->d_id); | |
131 | rec->u.uss.lun = srb->fcp_lun; | |
132 | memcpy(&rec->u.uss.queue_designator, &srb->queue_designator, | |
133 | sizeof(rec->u.uss.queue_designator)); | |
134 | ||
135 | /* status read buffer payload length */ | |
136 | rec->pl_len = (!srb->length) ? 0 : srb->length - | |
137 | offsetof(struct fsf_status_read_buffer, payload); | |
138 | ||
139 | if (rec->pl_len) | |
140 | zfcp_dbf_pl_write(dbf, srb->payload.data, rec->pl_len, | |
141 | "fsf_uss", req->req_id); | |
142 | log: | |
143 | debug_event(dbf->hba, 2, rec, sizeof(*rec)); | |
5771710b | 144 | spin_unlock_irqrestore(&dbf->hba_lock, flags); |
8a36e453 MS |
145 | } |
146 | ||
57069386 | 147 | /** |
a54ca0f6 SS |
148 | * zfcp_dbf_hba_bit_err - trace event for bit error conditions |
149 | * @tag: tag indicating which kind of unsolicited status has been received | |
150 | * @req: request which caused the bit_error condition | |
57069386 | 151 | */ |
a54ca0f6 | 152 | void zfcp_dbf_hba_bit_err(char *tag, struct zfcp_fsf_req *req) |
57069386 | 153 | { |
a54ca0f6 SS |
154 | struct zfcp_dbf *dbf = req->adapter->dbf; |
155 | struct zfcp_dbf_hba *rec = &dbf->hba_buf; | |
57069386 | 156 | struct fsf_status_read_buffer *sr_buf = req->data; |
57069386 SS |
157 | unsigned long flags; |
158 | ||
5771710b | 159 | spin_lock_irqsave(&dbf->hba_lock, flags); |
a54ca0f6 | 160 | memset(rec, 0, sizeof(*rec)); |
8a36e453 | 161 | |
a54ca0f6 SS |
162 | memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN); |
163 | rec->id = ZFCP_DBF_HBA_BIT; | |
164 | rec->fsf_req_id = req->req_id; | |
165 | rec->fsf_req_status = req->status; | |
166 | rec->fsf_cmd = req->fsf_command; | |
167 | memcpy(&rec->u.be, &sr_buf->payload.bit_error, | |
168 | sizeof(struct fsf_bit_error_payload)); | |
169 | ||
170 | debug_event(dbf->hba, 1, rec, sizeof(*rec)); | |
171 | spin_unlock_irqrestore(&dbf->hba_lock, flags); | |
8a36e453 MS |
172 | } |
173 | ||
86a9668a SS |
174 | /** |
175 | * zfcp_dbf_hba_def_err - trace event for deferred error messages | |
176 | * @adapter: pointer to struct zfcp_adapter | |
177 | * @req_id: request id which caused the deferred error message | |
178 | * @scount: number of sbals incl. the signaling sbal | |
179 | * @pl: array of all involved sbals | |
180 | */ | |
181 | void zfcp_dbf_hba_def_err(struct zfcp_adapter *adapter, u64 req_id, u16 scount, | |
182 | void **pl) | |
183 | { | |
184 | struct zfcp_dbf *dbf = adapter->dbf; | |
185 | struct zfcp_dbf_pay *payload = &dbf->pay_buf; | |
186 | unsigned long flags; | |
187 | u16 length; | |
188 | ||
189 | if (!pl) | |
190 | return; | |
191 | ||
192 | spin_lock_irqsave(&dbf->pay_lock, flags); | |
193 | memset(payload, 0, sizeof(*payload)); | |
194 | ||
195 | memcpy(payload->area, "def_err", 7); | |
196 | payload->fsf_req_id = req_id; | |
197 | payload->counter = 0; | |
198 | length = min((u16)sizeof(struct qdio_buffer), | |
199 | (u16)ZFCP_DBF_PAY_MAX_REC); | |
200 | ||
01e60527 | 201 | while (payload->counter < scount && (char *)pl[payload->counter]) { |
86a9668a SS |
202 | memcpy(payload->data, (char *)pl[payload->counter], length); |
203 | debug_event(dbf->pay, 1, payload, zfcp_dbf_plen(length)); | |
204 | payload->counter++; | |
205 | } | |
206 | ||
207 | spin_unlock_irqrestore(&dbf->pay_lock, flags); | |
208 | } | |
209 | ||
cb452149 SM |
210 | /** |
211 | * zfcp_dbf_hba_basic - trace event for basic adapter events | |
212 | * @adapter: pointer to struct zfcp_adapter | |
213 | */ | |
214 | void zfcp_dbf_hba_basic(char *tag, struct zfcp_adapter *adapter) | |
215 | { | |
216 | struct zfcp_dbf *dbf = adapter->dbf; | |
217 | struct zfcp_dbf_hba *rec = &dbf->hba_buf; | |
218 | unsigned long flags; | |
219 | ||
220 | spin_lock_irqsave(&dbf->hba_lock, flags); | |
221 | memset(rec, 0, sizeof(*rec)); | |
222 | ||
223 | memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN); | |
224 | rec->id = ZFCP_DBF_HBA_BASIC; | |
225 | ||
226 | debug_event(dbf->hba, 1, rec, sizeof(*rec)); | |
227 | spin_unlock_irqrestore(&dbf->hba_lock, flags); | |
228 | } | |
229 | ||
ae0904f6 SS |
230 | static void zfcp_dbf_set_common(struct zfcp_dbf_rec *rec, |
231 | struct zfcp_adapter *adapter, | |
232 | struct zfcp_port *port, | |
233 | struct scsi_device *sdev) | |
d79a83db | 234 | { |
ae0904f6 SS |
235 | rec->adapter_status = atomic_read(&adapter->status); |
236 | if (port) { | |
237 | rec->port_status = atomic_read(&port->status); | |
238 | rec->wwpn = port->wwpn; | |
239 | rec->d_id = port->d_id; | |
240 | } | |
241 | if (sdev) { | |
242 | rec->lun_status = atomic_read(&sdev_to_zfcp(sdev)->status); | |
243 | rec->lun = zfcp_scsi_dev_lun(sdev); | |
d79a83db | 244 | } |
d79a83db MP |
245 | } |
246 | ||
348447e8 | 247 | /** |
ae0904f6 SS |
248 | * zfcp_dbf_rec_trig - trace event related to triggered recovery |
249 | * @tag: identifier for event | |
250 | * @adapter: adapter on which the erp_action should run | |
251 | * @port: remote port involved in the erp_action | |
252 | * @sdev: scsi device involved in the erp_action | |
253 | * @want: wanted erp_action | |
254 | * @need: required erp_action | |
255 | * | |
256 | * The adapter->erp_lock has to be held. | |
348447e8 | 257 | */ |
ae0904f6 SS |
258 | void zfcp_dbf_rec_trig(char *tag, struct zfcp_adapter *adapter, |
259 | struct zfcp_port *port, struct scsi_device *sdev, | |
260 | u8 want, u8 need) | |
348447e8 | 261 | { |
ae0904f6 SS |
262 | struct zfcp_dbf *dbf = adapter->dbf; |
263 | struct zfcp_dbf_rec *rec = &dbf->rec_buf; | |
348447e8 | 264 | struct list_head *entry; |
698ec016 MP |
265 | unsigned long flags; |
266 | ||
5771710b | 267 | spin_lock_irqsave(&dbf->rec_lock, flags); |
ae0904f6 | 268 | memset(rec, 0, sizeof(*rec)); |
5771710b | 269 | |
ae0904f6 SS |
270 | rec->id = ZFCP_DBF_REC_TRIG; |
271 | memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN); | |
272 | zfcp_dbf_set_common(rec, adapter, port, sdev); | |
698ec016 | 273 | |
ae0904f6 SS |
274 | list_for_each(entry, &adapter->erp_ready_head) |
275 | rec->u.trig.ready++; | |
698ec016 | 276 | |
ae0904f6 SS |
277 | list_for_each(entry, &adapter->erp_running_head) |
278 | rec->u.trig.running++; | |
698ec016 | 279 | |
ae0904f6 SS |
280 | rec->u.trig.want = want; |
281 | rec->u.trig.need = need; | |
698ec016 | 282 | |
ae0904f6 SS |
283 | debug_event(dbf->rec, 1, rec, sizeof(*rec)); |
284 | spin_unlock_irqrestore(&dbf->rec_lock, flags); | |
698ec016 MP |
285 | } |
286 | ||
ae0904f6 | 287 | |
9467a9b3 | 288 | /** |
ae0904f6 SS |
289 | * zfcp_dbf_rec_run - trace event related to running recovery |
290 | * @tag: identifier for event | |
291 | * @erp: erp_action running | |
9467a9b3 | 292 | */ |
ae0904f6 | 293 | void zfcp_dbf_rec_run(char *tag, struct zfcp_erp_action *erp) |
9467a9b3 | 294 | { |
ae0904f6 SS |
295 | struct zfcp_dbf *dbf = erp->adapter->dbf; |
296 | struct zfcp_dbf_rec *rec = &dbf->rec_buf; | |
9467a9b3 MP |
297 | unsigned long flags; |
298 | ||
5771710b | 299 | spin_lock_irqsave(&dbf->rec_lock, flags); |
ae0904f6 | 300 | memset(rec, 0, sizeof(*rec)); |
9467a9b3 | 301 | |
ae0904f6 SS |
302 | rec->id = ZFCP_DBF_REC_RUN; |
303 | memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN); | |
304 | zfcp_dbf_set_common(rec, erp->adapter, erp->port, erp->sdev); | |
6f4f365e | 305 | |
ae0904f6 SS |
306 | rec->u.run.fsf_req_id = erp->fsf_req_id; |
307 | rec->u.run.rec_status = erp->status; | |
308 | rec->u.run.rec_step = erp->step; | |
309 | rec->u.run.rec_action = erp->action; | |
310 | ||
311 | if (erp->sdev) | |
312 | rec->u.run.rec_count = | |
313 | atomic_read(&sdev_to_zfcp(erp->sdev)->erp_counter); | |
314 | else if (erp->port) | |
315 | rec->u.run.rec_count = atomic_read(&erp->port->erp_counter); | |
316 | else | |
317 | rec->u.run.rec_count = atomic_read(&erp->adapter->erp_counter); | |
318 | ||
319 | debug_event(dbf->rec, 1, rec, sizeof(*rec)); | |
5771710b | 320 | spin_unlock_irqrestore(&dbf->rec_lock, flags); |
6f4f365e MP |
321 | } |
322 | ||
2c55b750 SS |
323 | static inline |
324 | void zfcp_dbf_san(char *tag, struct zfcp_dbf *dbf, void *data, u8 id, u16 len, | |
325 | u64 req_id, u32 d_id) | |
8a36e453 | 326 | { |
2c55b750 SS |
327 | struct zfcp_dbf_san *rec = &dbf->san_buf; |
328 | u16 rec_len; | |
6bc473dd | 329 | unsigned long flags; |
8a36e453 | 330 | |
5771710b | 331 | spin_lock_irqsave(&dbf->san_lock, flags); |
2c55b750 | 332 | memset(rec, 0, sizeof(*rec)); |
8a36e453 | 333 | |
2c55b750 SS |
334 | rec->id = id; |
335 | rec->fsf_req_id = req_id; | |
336 | rec->d_id = d_id; | |
337 | rec_len = min(len, (u16)ZFCP_DBF_SAN_MAX_PAYLOAD); | |
338 | memcpy(rec->payload, data, rec_len); | |
339 | memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN); | |
8a36e453 | 340 | |
2c55b750 | 341 | debug_event(dbf->san, 1, rec, sizeof(*rec)); |
5771710b | 342 | spin_unlock_irqrestore(&dbf->san_lock, flags); |
8a36e453 MS |
343 | } |
344 | ||
bfab1637 | 345 | /** |
2c55b750 | 346 | * zfcp_dbf_san_req - trace event for issued SAN request |
3f79410c | 347 | * @tag: identifier for event |
2c55b750 SS |
348 | * @fsf_req: request containing issued CT data |
349 | * d_id: destination ID | |
bfab1637 | 350 | */ |
2c55b750 | 351 | void zfcp_dbf_san_req(char *tag, struct zfcp_fsf_req *fsf, u32 d_id) |
8a36e453 | 352 | { |
2c55b750 SS |
353 | struct zfcp_dbf *dbf = fsf->adapter->dbf; |
354 | struct zfcp_fsf_ct_els *ct_els = fsf->data; | |
355 | u16 length; | |
8a36e453 | 356 | |
2c55b750 SS |
357 | length = (u16)(ct_els->req->length + FC_CT_HDR_LEN); |
358 | zfcp_dbf_san(tag, dbf, sg_virt(ct_els->req), ZFCP_DBF_SAN_REQ, length, | |
359 | fsf->req_id, d_id); | |
8a36e453 MS |
360 | } |
361 | ||
bfab1637 | 362 | /** |
2c55b750 | 363 | * zfcp_dbf_san_res - trace event for received SAN request |
3f79410c | 364 | * @tag: identifier for event |
2c55b750 | 365 | * @fsf_req: request containing issued CT data |
bfab1637 | 366 | */ |
2c55b750 | 367 | void zfcp_dbf_san_res(char *tag, struct zfcp_fsf_req *fsf) |
8a36e453 | 368 | { |
2c55b750 SS |
369 | struct zfcp_dbf *dbf = fsf->adapter->dbf; |
370 | struct zfcp_fsf_ct_els *ct_els = fsf->data; | |
371 | u16 length; | |
8a36e453 | 372 | |
2c55b750 SS |
373 | length = (u16)(ct_els->resp->length + FC_CT_HDR_LEN); |
374 | zfcp_dbf_san(tag, dbf, sg_virt(ct_els->resp), ZFCP_DBF_SAN_RES, length, | |
375 | fsf->req_id, 0); | |
8a36e453 MS |
376 | } |
377 | ||
bfab1637 | 378 | /** |
2c55b750 | 379 | * zfcp_dbf_san_in_els - trace event for incoming ELS |
3f79410c | 380 | * @tag: identifier for event |
2c55b750 | 381 | * @fsf_req: request containing issued CT data |
bfab1637 | 382 | */ |
2c55b750 | 383 | void zfcp_dbf_san_in_els(char *tag, struct zfcp_fsf_req *fsf) |
8a36e453 | 384 | { |
2c55b750 SS |
385 | struct zfcp_dbf *dbf = fsf->adapter->dbf; |
386 | struct fsf_status_read_buffer *srb = | |
387 | (struct fsf_status_read_buffer *) fsf->data; | |
388 | u16 length; | |
389 | ||
390 | length = (u16)(srb->length - | |
391 | offsetof(struct fsf_status_read_buffer, payload)); | |
392 | zfcp_dbf_san(tag, dbf, srb->payload.data, ZFCP_DBF_SAN_ELS, length, | |
393 | fsf->req_id, ntoh24(srb->d_id)); | |
8a36e453 MS |
394 | } |
395 | ||
250a1352 SS |
396 | /** |
397 | * zfcp_dbf_scsi - trace event for scsi commands | |
398 | * @tag: identifier for event | |
399 | * @sc: pointer to struct scsi_cmnd | |
400 | * @fsf: pointer to struct zfcp_fsf_req | |
401 | */ | |
402 | void zfcp_dbf_scsi(char *tag, struct scsi_cmnd *sc, struct zfcp_fsf_req *fsf) | |
8a36e453 | 403 | { |
250a1352 SS |
404 | struct zfcp_adapter *adapter = |
405 | (struct zfcp_adapter *) sc->device->host->hostdata[0]; | |
406 | struct zfcp_dbf *dbf = adapter->dbf; | |
407 | struct zfcp_dbf_scsi *rec = &dbf->scsi_buf; | |
4318e08c | 408 | struct fcp_resp_with_ext *fcp_rsp; |
250a1352 SS |
409 | struct fcp_resp_rsp_info *fcp_rsp_info; |
410 | unsigned long flags; | |
8a36e453 | 411 | |
5771710b | 412 | spin_lock_irqsave(&dbf->scsi_lock, flags); |
250a1352 | 413 | memset(rec, 0, sizeof(*rec)); |
8a36e453 | 414 | |
250a1352 SS |
415 | memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN); |
416 | rec->id = ZFCP_DBF_SCSI_CMND; | |
417 | rec->scsi_result = sc->result; | |
418 | rec->scsi_retries = sc->retries; | |
419 | rec->scsi_allowed = sc->allowed; | |
420 | rec->scsi_id = sc->device->id; | |
9cb78c16 HR |
421 | /* struct zfcp_dbf_scsi needs to be updated to handle 64bit LUNs */ |
422 | rec->scsi_lun = (u32)sc->device->lun; | |
250a1352 SS |
423 | rec->host_scribble = (unsigned long)sc->host_scribble; |
424 | ||
425 | memcpy(rec->scsi_opcode, sc->cmnd, | |
426 | min((int)sc->cmd_len, ZFCP_DBF_SCSI_OPCODE)); | |
427 | ||
428 | if (fsf) { | |
429 | rec->fsf_req_id = fsf->req_id; | |
430 | fcp_rsp = (struct fcp_resp_with_ext *) | |
431 | &(fsf->qtcb->bottom.io.fcp_rsp); | |
432 | memcpy(&rec->fcp_rsp, fcp_rsp, FCP_RESP_WITH_EXT); | |
433 | if (fcp_rsp->resp.fr_flags & FCP_RSP_LEN_VAL) { | |
434 | fcp_rsp_info = (struct fcp_resp_rsp_info *) &fcp_rsp[1]; | |
435 | rec->fcp_rsp_info = fcp_rsp_info->rsp_code; | |
436 | } | |
437 | if (fcp_rsp->resp.fr_flags & FCP_SNS_LEN_VAL) { | |
438 | rec->pl_len = min((u16)SCSI_SENSE_BUFFERSIZE, | |
439 | (u16)ZFCP_DBF_PAY_MAX_REC); | |
440 | zfcp_dbf_pl_write(dbf, sc->sense_buffer, rec->pl_len, | |
441 | "fcp_sns", fsf->req_id); | |
442 | } | |
8a36e453 | 443 | } |
8a36e453 | 444 | |
ea4a3a6a | 445 | debug_event(dbf->scsi, 1, rec, sizeof(*rec)); |
250a1352 SS |
446 | spin_unlock_irqrestore(&dbf->scsi_lock, flags); |
447 | } | |
8a36e453 | 448 | |
ea4a3a6a | 449 | static debug_info_t *zfcp_dbf_reg(const char *name, int size, int rec_size) |
d46f384a CS |
450 | { |
451 | struct debug_info *d; | |
452 | ||
ea4a3a6a | 453 | d = debug_register(name, size, 1, rec_size); |
d46f384a CS |
454 | if (!d) |
455 | return NULL; | |
456 | ||
457 | debug_register_view(d, &debug_hex_ascii_view); | |
bf3ea3ae | 458 | debug_set_level(d, dbflevel); |
d46f384a CS |
459 | |
460 | return d; | |
461 | } | |
462 | ||
ea4a3a6a SS |
463 | static void zfcp_dbf_unregister(struct zfcp_dbf *dbf) |
464 | { | |
465 | if (!dbf) | |
466 | return; | |
467 | ||
468 | debug_unregister(dbf->scsi); | |
469 | debug_unregister(dbf->san); | |
470 | debug_unregister(dbf->hba); | |
471 | debug_unregister(dbf->pay); | |
472 | debug_unregister(dbf->rec); | |
473 | kfree(dbf); | |
474 | } | |
475 | ||
8a36e453 MS |
476 | /** |
477 | * zfcp_adapter_debug_register - registers debug feature for an adapter | |
478 | * @adapter: pointer to adapter for which debug features should be registered | |
479 | * return: -ENOMEM on error, 0 otherwise | |
480 | */ | |
5771710b | 481 | int zfcp_dbf_adapter_register(struct zfcp_adapter *adapter) |
8a36e453 | 482 | { |
ea4a3a6a | 483 | char name[DEBUG_MAX_NAME_LEN]; |
d46f384a CS |
484 | struct zfcp_dbf *dbf; |
485 | ||
d23948ea | 486 | dbf = kzalloc(sizeof(struct zfcp_dbf), GFP_KERNEL); |
d46f384a CS |
487 | if (!dbf) |
488 | return -ENOMEM; | |
489 | ||
a54ca0f6 | 490 | spin_lock_init(&dbf->pay_lock); |
5771710b SS |
491 | spin_lock_init(&dbf->hba_lock); |
492 | spin_lock_init(&dbf->san_lock); | |
493 | spin_lock_init(&dbf->scsi_lock); | |
494 | spin_lock_init(&dbf->rec_lock); | |
8a36e453 | 495 | |
d79a83db | 496 | /* debug feature area which records recovery activity */ |
ea4a3a6a SS |
497 | sprintf(name, "zfcp_%s_rec", dev_name(&adapter->ccw_device->dev)); |
498 | dbf->rec = zfcp_dbf_reg(name, dbfsize, sizeof(struct zfcp_dbf_rec)); | |
5771710b SS |
499 | if (!dbf->rec) |
500 | goto err_out; | |
d79a83db | 501 | |
8a36e453 | 502 | /* debug feature area which records HBA (FSF and QDIO) conditions */ |
ea4a3a6a SS |
503 | sprintf(name, "zfcp_%s_hba", dev_name(&adapter->ccw_device->dev)); |
504 | dbf->hba = zfcp_dbf_reg(name, dbfsize, sizeof(struct zfcp_dbf_hba)); | |
5771710b SS |
505 | if (!dbf->hba) |
506 | goto err_out; | |
8a36e453 | 507 | |
a54ca0f6 | 508 | /* debug feature area which records payload info */ |
ea4a3a6a SS |
509 | sprintf(name, "zfcp_%s_pay", dev_name(&adapter->ccw_device->dev)); |
510 | dbf->pay = zfcp_dbf_reg(name, dbfsize * 2, sizeof(struct zfcp_dbf_pay)); | |
a54ca0f6 SS |
511 | if (!dbf->pay) |
512 | goto err_out; | |
513 | ||
8a36e453 | 514 | /* debug feature area which records SAN command failures and recovery */ |
ea4a3a6a SS |
515 | sprintf(name, "zfcp_%s_san", dev_name(&adapter->ccw_device->dev)); |
516 | dbf->san = zfcp_dbf_reg(name, dbfsize, sizeof(struct zfcp_dbf_san)); | |
5771710b SS |
517 | if (!dbf->san) |
518 | goto err_out; | |
8a36e453 MS |
519 | |
520 | /* debug feature area which records SCSI command failures and recovery */ | |
ea4a3a6a SS |
521 | sprintf(name, "zfcp_%s_scsi", dev_name(&adapter->ccw_device->dev)); |
522 | dbf->scsi = zfcp_dbf_reg(name, dbfsize, sizeof(struct zfcp_dbf_scsi)); | |
5771710b SS |
523 | if (!dbf->scsi) |
524 | goto err_out; | |
8a36e453 | 525 | |
d46f384a | 526 | adapter->dbf = dbf; |
8a36e453 | 527 | |
ea4a3a6a | 528 | return 0; |
5771710b | 529 | err_out: |
ea4a3a6a | 530 | zfcp_dbf_unregister(dbf); |
8a36e453 MS |
531 | return -ENOMEM; |
532 | } | |
533 | ||
534 | /** | |
535 | * zfcp_adapter_debug_unregister - unregisters debug feature for an adapter | |
ea4a3a6a | 536 | * @adapter: pointer to adapter for which debug features should be unregistered |
8a36e453 | 537 | */ |
ea4a3a6a | 538 | void zfcp_dbf_adapter_unregister(struct zfcp_adapter *adapter) |
8a36e453 | 539 | { |
ea4a3a6a SS |
540 | struct zfcp_dbf *dbf = adapter->dbf; |
541 | ||
542 | adapter->dbf = NULL; | |
543 | zfcp_dbf_unregister(dbf); | |
8a36e453 | 544 | } |
5771710b | 545 |