1
2
3
4
5
6
7
8
9#define KMSG_COMPONENT "zfcp"
10#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
11
12#include <linux/module.h>
13#include <linux/ctype.h>
14#include <linux/slab.h>
15#include <asm/debug.h>
16#include "zfcp_dbf.h"
17#include "zfcp_ext.h"
18#include "zfcp_fc.h"
19
20static u32 dbfsize = 4;
21
22module_param(dbfsize, uint, 0400);
23MODULE_PARM_DESC(dbfsize,
24 "number of pages for each debug feature area (default 4)");
25
26static u32 dbflevel = 3;
27
28module_param(dbflevel, uint, 0400);
29MODULE_PARM_DESC(dbflevel,
30 "log level for each debug feature area "
31 "(default 3, range 0..6)");
32
33static inline unsigned int zfcp_dbf_plen(unsigned int offset)
34{
35 return sizeof(struct zfcp_dbf_pay) + offset - ZFCP_DBF_PAY_MAX_REC;
36}
37
38static inline
39void 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++;
58 }
59
60 spin_unlock(&dbf->pay_lock);
61}
62
63
64
65
66
67
68void zfcp_dbf_hba_fsf_res(char *tag, struct zfcp_fsf_req *req)
69{
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;
74 unsigned long flags;
75
76 spin_lock_irqsave(&dbf->hba_lock, flags);
77 memset(rec, 0, sizeof(*rec));
78
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);
98 }
99
100 debug_event(dbf->hba, 1, rec, sizeof(*rec));
101 spin_unlock_irqrestore(&dbf->hba_lock, flags);
102}
103
104
105
106
107
108
109void zfcp_dbf_hba_fsf_uss(char *tag, struct zfcp_fsf_req *req)
110{
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;
114 unsigned long flags;
115
116 spin_lock_irqsave(&dbf->hba_lock, flags);
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
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);
142log:
143 debug_event(dbf->hba, 2, rec, sizeof(*rec));
144 spin_unlock_irqrestore(&dbf->hba_lock, flags);
145}
146
147
148
149
150
151
152void zfcp_dbf_hba_bit_err(char *tag, struct zfcp_fsf_req *req)
153{
154 struct zfcp_dbf *dbf = req->adapter->dbf;
155 struct zfcp_dbf_hba *rec = &dbf->hba_buf;
156 struct fsf_status_read_buffer *sr_buf = req->data;
157 unsigned long flags;
158
159 spin_lock_irqsave(&dbf->hba_lock, flags);
160 memset(rec, 0, sizeof(*rec));
161
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);
172}
173
174
175
176
177
178
179
180
181void 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
201 while (payload->counter < scount && (char *)pl[payload->counter]) {
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
210
211
212
213
214void 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
230static 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)
234{
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);
244 }
245}
246
247
248
249
250
251
252
253
254
255
256
257
258void zfcp_dbf_rec_trig(char *tag, struct zfcp_adapter *adapter,
259 struct zfcp_port *port, struct scsi_device *sdev,
260 u8 want, u8 need)
261{
262 struct zfcp_dbf *dbf = adapter->dbf;
263 struct zfcp_dbf_rec *rec = &dbf->rec_buf;
264 struct list_head *entry;
265 unsigned long flags;
266
267 spin_lock_irqsave(&dbf->rec_lock, flags);
268 memset(rec, 0, sizeof(*rec));
269
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);
273
274 list_for_each(entry, &adapter->erp_ready_head)
275 rec->u.trig.ready++;
276
277 list_for_each(entry, &adapter->erp_running_head)
278 rec->u.trig.running++;
279
280 rec->u.trig.want = want;
281 rec->u.trig.need = need;
282
283 debug_event(dbf->rec, 1, rec, sizeof(*rec));
284 spin_unlock_irqrestore(&dbf->rec_lock, flags);
285}
286
287
288
289
290
291
292
293void zfcp_dbf_rec_run(char *tag, struct zfcp_erp_action *erp)
294{
295 struct zfcp_dbf *dbf = erp->adapter->dbf;
296 struct zfcp_dbf_rec *rec = &dbf->rec_buf;
297 unsigned long flags;
298
299 spin_lock_irqsave(&dbf->rec_lock, flags);
300 memset(rec, 0, sizeof(*rec));
301
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);
305
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));
320 spin_unlock_irqrestore(&dbf->rec_lock, flags);
321}
322
323static inline
324void zfcp_dbf_san(char *tag, struct zfcp_dbf *dbf, void *data, u8 id, u16 len,
325 u64 req_id, u32 d_id)
326{
327 struct zfcp_dbf_san *rec = &dbf->san_buf;
328 u16 rec_len;
329 unsigned long flags;
330
331 spin_lock_irqsave(&dbf->san_lock, flags);
332 memset(rec, 0, sizeof(*rec));
333
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);
340
341 debug_event(dbf->san, 1, rec, sizeof(*rec));
342 spin_unlock_irqrestore(&dbf->san_lock, flags);
343}
344
345
346
347
348
349
350
351void zfcp_dbf_san_req(char *tag, struct zfcp_fsf_req *fsf, u32 d_id)
352{
353 struct zfcp_dbf *dbf = fsf->adapter->dbf;
354 struct zfcp_fsf_ct_els *ct_els = fsf->data;
355 u16 length;
356
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);
360}
361
362
363
364
365
366
367void zfcp_dbf_san_res(char *tag, struct zfcp_fsf_req *fsf)
368{
369 struct zfcp_dbf *dbf = fsf->adapter->dbf;
370 struct zfcp_fsf_ct_els *ct_els = fsf->data;
371 u16 length;
372
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);
376}
377
378
379
380
381
382
383void zfcp_dbf_san_in_els(char *tag, struct zfcp_fsf_req *fsf)
384{
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));
394}
395
396
397
398
399
400
401
402void zfcp_dbf_scsi(char *tag, struct scsi_cmnd *sc, struct zfcp_fsf_req *fsf)
403{
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;
408 struct fcp_resp_with_ext *fcp_rsp;
409 struct fcp_resp_rsp_info *fcp_rsp_info;
410 unsigned long flags;
411
412 spin_lock_irqsave(&dbf->scsi_lock, flags);
413 memset(rec, 0, sizeof(*rec));
414
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;
421
422 rec->scsi_lun = (u32)sc->device->lun;
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 }
443 }
444
445 debug_event(dbf->scsi, 1, rec, sizeof(*rec));
446 spin_unlock_irqrestore(&dbf->scsi_lock, flags);
447}
448
449static debug_info_t *zfcp_dbf_reg(const char *name, int size, int rec_size)
450{
451 struct debug_info *d;
452
453 d = debug_register(name, size, 1, rec_size);
454 if (!d)
455 return NULL;
456
457 debug_register_view(d, &debug_hex_ascii_view);
458 debug_set_level(d, dbflevel);
459
460 return d;
461}
462
463static 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
476
477
478
479
480
481int zfcp_dbf_adapter_register(struct zfcp_adapter *adapter)
482{
483 char name[DEBUG_MAX_NAME_LEN];
484 struct zfcp_dbf *dbf;
485
486 dbf = kzalloc(sizeof(struct zfcp_dbf), GFP_KERNEL);
487 if (!dbf)
488 return -ENOMEM;
489
490 spin_lock_init(&dbf->pay_lock);
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);
495
496
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));
499 if (!dbf->rec)
500 goto err_out;
501
502
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));
505 if (!dbf->hba)
506 goto err_out;
507
508
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));
511 if (!dbf->pay)
512 goto err_out;
513
514
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));
517 if (!dbf->san)
518 goto err_out;
519
520
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));
523 if (!dbf->scsi)
524 goto err_out;
525
526 adapter->dbf = dbf;
527
528 return 0;
529err_out:
530 zfcp_dbf_unregister(dbf);
531 return -ENOMEM;
532}
533
534
535
536
537
538void zfcp_dbf_adapter_unregister(struct zfcp_adapter *adapter)
539{
540 struct zfcp_dbf *dbf = adapter->dbf;
541
542 adapter->dbf = NULL;
543 zfcp_dbf_unregister(dbf);
544}
545
546