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