1 /* 2 * zfcp device driver 3 * 4 * Debug traces for zfcp. 5 * 6 * Copyright IBM Corporation 2002, 2009 7 */ 8 9 #define KMSG_COMPONENT "zfcp" 10 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 11 12 #include <linux/ctype.h> 13 #include <linux/slab.h> 14 #include <asm/debug.h> 15 #include "zfcp_dbf.h" 16 #include "zfcp_ext.h" 17 #include "zfcp_fc.h" 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 25 static void zfcp_dbf_hexdump(debug_info_t *dbf, void *to, int to_len, 26 int level, char *from, int from_len) 27 { 28 int offset; 29 struct zfcp_dbf_dump *dump = to; 30 int room = to_len - sizeof(*dump); 31 32 for (offset = 0; offset < from_len; offset += dump->size) { 33 memset(to, 0, to_len); 34 strncpy(dump->tag, "dump", ZFCP_DBF_TAG_SIZE); 35 dump->total_size = from_len; 36 dump->offset = offset; 37 dump->size = min(from_len - offset, room); 38 memcpy(dump->data, from + offset, dump->size); 39 debug_event(dbf, level, dump, dump->size + sizeof(*dump)); 40 } 41 } 42 43 static void zfcp_dbf_tag(char **p, const char *label, const char *tag) 44 { 45 int i; 46 47 *p += sprintf(*p, "%-24s", label); 48 for (i = 0; i < ZFCP_DBF_TAG_SIZE; i++) 49 *p += sprintf(*p, "%c", tag[i]); 50 *p += sprintf(*p, "\n"); 51 } 52 53 static void zfcp_dbf_outs(char **buf, const char *s1, const char *s2) 54 { 55 *buf += sprintf(*buf, "%-24s%s\n", s1, s2); 56 } 57 58 static void zfcp_dbf_out(char **buf, const char *s, const char *format, ...) 59 { 60 va_list arg; 61 62 *buf += sprintf(*buf, "%-24s", s); 63 va_start(arg, format); 64 *buf += vsprintf(*buf, format, arg); 65 va_end(arg); 66 *buf += sprintf(*buf, "\n"); 67 } 68 69 static void zfcp_dbf_outd(char **p, const char *label, char *buffer, 70 int buflen, int offset, int total_size) 71 { 72 if (!offset) 73 *p += sprintf(*p, "%-24s ", label); 74 while (buflen--) { 75 if (offset > 0) { 76 if ((offset % 32) == 0) 77 *p += sprintf(*p, "\n%-24c ", ' '); 78 else if ((offset % 4) == 0) 79 *p += sprintf(*p, " "); 80 } 81 *p += sprintf(*p, "%02x", *buffer++); 82 if (++offset == total_size) { 83 *p += sprintf(*p, "\n"); 84 break; 85 } 86 } 87 if (!total_size) 88 *p += sprintf(*p, "\n"); 89 } 90 91 static int zfcp_dbf_view_header(debug_info_t *id, struct debug_view *view, 92 int area, debug_entry_t *entry, char *out_buf) 93 { 94 struct zfcp_dbf_dump *dump = (struct zfcp_dbf_dump *)DEBUG_DATA(entry); 95 struct timespec t; 96 char *p = out_buf; 97 98 if (strncmp(dump->tag, "dump", ZFCP_DBF_TAG_SIZE) != 0) { 99 stck_to_timespec(entry->id.stck, &t); 100 zfcp_dbf_out(&p, "timestamp", "%011lu:%06lu", 101 t.tv_sec, t.tv_nsec); 102 zfcp_dbf_out(&p, "cpu", "%02i", entry->id.fields.cpuid); 103 } else { 104 zfcp_dbf_outd(&p, "", dump->data, dump->size, dump->offset, 105 dump->total_size); 106 if ((dump->offset + dump->size) == dump->total_size) 107 p += sprintf(p, "\n"); 108 } 109 return p - out_buf; 110 } 111 112 void _zfcp_dbf_hba_fsf_response(const char *tag2, int level, 113 struct zfcp_fsf_req *fsf_req, 114 struct zfcp_dbf *dbf) 115 { 116 struct fsf_qtcb *qtcb = fsf_req->qtcb; 117 union fsf_prot_status_qual *prot_status_qual = 118 &qtcb->prefix.prot_status_qual; 119 union fsf_status_qual *fsf_status_qual = &qtcb->header.fsf_status_qual; 120 struct scsi_cmnd *scsi_cmnd; 121 struct zfcp_port *port; 122 struct zfcp_unit *unit; 123 struct zfcp_send_els *send_els; 124 struct zfcp_dbf_hba_record *rec = &dbf->hba_buf; 125 struct zfcp_dbf_hba_record_response *response = &rec->u.response; 126 unsigned long flags; 127 128 spin_lock_irqsave(&dbf->hba_lock, flags); 129 memset(rec, 0, sizeof(*rec)); 130 strncpy(rec->tag, "resp", ZFCP_DBF_TAG_SIZE); 131 strncpy(rec->tag2, tag2, ZFCP_DBF_TAG_SIZE); 132 133 response->fsf_command = fsf_req->fsf_command; 134 response->fsf_reqid = fsf_req->req_id; 135 response->fsf_seqno = fsf_req->seq_no; 136 response->fsf_issued = fsf_req->issued; 137 response->fsf_prot_status = qtcb->prefix.prot_status; 138 response->fsf_status = qtcb->header.fsf_status; 139 memcpy(response->fsf_prot_status_qual, 140 prot_status_qual, FSF_PROT_STATUS_QUAL_SIZE); 141 memcpy(response->fsf_status_qual, 142 fsf_status_qual, FSF_STATUS_QUALIFIER_SIZE); 143 response->fsf_req_status = fsf_req->status; 144 response->sbal_first = fsf_req->qdio_req.sbal_first; 145 response->sbal_last = fsf_req->qdio_req.sbal_last; 146 response->sbal_response = fsf_req->qdio_req.sbal_response; 147 response->pool = fsf_req->pool != NULL; 148 response->erp_action = (unsigned long)fsf_req->erp_action; 149 150 switch (fsf_req->fsf_command) { 151 case FSF_QTCB_FCP_CMND: 152 if (fsf_req->status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT) 153 break; 154 scsi_cmnd = (struct scsi_cmnd *)fsf_req->data; 155 if (scsi_cmnd) { 156 response->u.fcp.cmnd = (unsigned long)scsi_cmnd; 157 response->u.fcp.data_dir = 158 qtcb->bottom.io.data_direction; 159 } 160 break; 161 162 case FSF_QTCB_OPEN_PORT_WITH_DID: 163 case FSF_QTCB_CLOSE_PORT: 164 case FSF_QTCB_CLOSE_PHYSICAL_PORT: 165 port = (struct zfcp_port *)fsf_req->data; 166 response->u.port.wwpn = port->wwpn; 167 response->u.port.d_id = port->d_id; 168 response->u.port.port_handle = qtcb->header.port_handle; 169 break; 170 171 case FSF_QTCB_OPEN_LUN: 172 case FSF_QTCB_CLOSE_LUN: 173 unit = (struct zfcp_unit *)fsf_req->data; 174 port = unit->port; 175 response->u.unit.wwpn = port->wwpn; 176 response->u.unit.fcp_lun = unit->fcp_lun; 177 response->u.unit.port_handle = qtcb->header.port_handle; 178 response->u.unit.lun_handle = qtcb->header.lun_handle; 179 break; 180 181 case FSF_QTCB_SEND_ELS: 182 send_els = (struct zfcp_send_els *)fsf_req->data; 183 response->u.els.d_id = ntoh24(qtcb->bottom.support.d_id); 184 break; 185 186 case FSF_QTCB_ABORT_FCP_CMND: 187 case FSF_QTCB_SEND_GENERIC: 188 case FSF_QTCB_EXCHANGE_CONFIG_DATA: 189 case FSF_QTCB_EXCHANGE_PORT_DATA: 190 case FSF_QTCB_DOWNLOAD_CONTROL_FILE: 191 case FSF_QTCB_UPLOAD_CONTROL_FILE: 192 break; 193 } 194 195 debug_event(dbf->hba, level, rec, sizeof(*rec)); 196 197 /* have fcp channel microcode fixed to use as little as possible */ 198 if (fsf_req->fsf_command != FSF_QTCB_FCP_CMND) { 199 /* adjust length skipping trailing zeros */ 200 char *buf = (char *)qtcb + qtcb->header.log_start; 201 int len = qtcb->header.log_length; 202 for (; len && !buf[len - 1]; len--); 203 zfcp_dbf_hexdump(dbf->hba, rec, sizeof(*rec), level, buf, 204 len); 205 } 206 207 spin_unlock_irqrestore(&dbf->hba_lock, flags); 208 } 209 210 void _zfcp_dbf_hba_fsf_unsol(const char *tag, int level, struct zfcp_dbf *dbf, 211 struct fsf_status_read_buffer *status_buffer) 212 { 213 struct zfcp_dbf_hba_record *rec = &dbf->hba_buf; 214 unsigned long flags; 215 216 spin_lock_irqsave(&dbf->hba_lock, flags); 217 memset(rec, 0, sizeof(*rec)); 218 strncpy(rec->tag, "stat", ZFCP_DBF_TAG_SIZE); 219 strncpy(rec->tag2, tag, ZFCP_DBF_TAG_SIZE); 220 221 rec->u.status.failed = atomic_read(&dbf->adapter->stat_miss); 222 if (status_buffer != NULL) { 223 rec->u.status.status_type = status_buffer->status_type; 224 rec->u.status.status_subtype = status_buffer->status_subtype; 225 memcpy(&rec->u.status.queue_designator, 226 &status_buffer->queue_designator, 227 sizeof(struct fsf_queue_designator)); 228 229 switch (status_buffer->status_type) { 230 case FSF_STATUS_READ_SENSE_DATA_AVAIL: 231 rec->u.status.payload_size = 232 ZFCP_DBF_UNSOL_PAYLOAD_SENSE_DATA_AVAIL; 233 break; 234 235 case FSF_STATUS_READ_BIT_ERROR_THRESHOLD: 236 rec->u.status.payload_size = 237 ZFCP_DBF_UNSOL_PAYLOAD_BIT_ERROR_THRESHOLD; 238 break; 239 240 case FSF_STATUS_READ_LINK_DOWN: 241 switch (status_buffer->status_subtype) { 242 case FSF_STATUS_READ_SUB_NO_PHYSICAL_LINK: 243 case FSF_STATUS_READ_SUB_FDISC_FAILED: 244 rec->u.status.payload_size = 245 sizeof(struct fsf_link_down_info); 246 } 247 break; 248 249 case FSF_STATUS_READ_FEATURE_UPDATE_ALERT: 250 rec->u.status.payload_size = 251 ZFCP_DBF_UNSOL_PAYLOAD_FEATURE_UPDATE_ALERT; 252 break; 253 } 254 memcpy(&rec->u.status.payload, 255 &status_buffer->payload, rec->u.status.payload_size); 256 } 257 258 debug_event(dbf->hba, level, rec, sizeof(*rec)); 259 spin_unlock_irqrestore(&dbf->hba_lock, flags); 260 } 261 262 /** 263 * zfcp_dbf_hba_qdio - trace event for QDIO related failure 264 * @qdio: qdio structure affected by this QDIO related event 265 * @qdio_error: as passed by qdio module 266 * @sbal_index: first buffer with error condition, as passed by qdio module 267 * @sbal_count: number of buffers affected, as passed by qdio module 268 */ 269 void zfcp_dbf_hba_qdio(struct zfcp_dbf *dbf, unsigned int qdio_error, 270 int sbal_index, int sbal_count) 271 { 272 struct zfcp_dbf_hba_record *r = &dbf->hba_buf; 273 unsigned long flags; 274 275 spin_lock_irqsave(&dbf->hba_lock, flags); 276 memset(r, 0, sizeof(*r)); 277 strncpy(r->tag, "qdio", ZFCP_DBF_TAG_SIZE); 278 r->u.qdio.qdio_error = qdio_error; 279 r->u.qdio.sbal_index = sbal_index; 280 r->u.qdio.sbal_count = sbal_count; 281 debug_event(dbf->hba, 0, r, sizeof(*r)); 282 spin_unlock_irqrestore(&dbf->hba_lock, flags); 283 } 284 285 /** 286 * zfcp_dbf_hba_berr - trace event for bit error threshold 287 * @dbf: dbf structure affected by this QDIO related event 288 * @req: fsf request 289 */ 290 void zfcp_dbf_hba_berr(struct zfcp_dbf *dbf, struct zfcp_fsf_req *req) 291 { 292 struct zfcp_dbf_hba_record *r = &dbf->hba_buf; 293 struct fsf_status_read_buffer *sr_buf = req->data; 294 struct fsf_bit_error_payload *err = &sr_buf->payload.bit_error; 295 unsigned long flags; 296 297 spin_lock_irqsave(&dbf->hba_lock, flags); 298 memset(r, 0, sizeof(*r)); 299 strncpy(r->tag, "berr", ZFCP_DBF_TAG_SIZE); 300 memcpy(&r->u.berr, err, sizeof(struct fsf_bit_error_payload)); 301 debug_event(dbf->hba, 0, r, sizeof(*r)); 302 spin_unlock_irqrestore(&dbf->hba_lock, flags); 303 } 304 static void zfcp_dbf_hba_view_response(char **p, 305 struct zfcp_dbf_hba_record_response *r) 306 { 307 struct timespec t; 308 309 zfcp_dbf_out(p, "fsf_command", "0x%08x", r->fsf_command); 310 zfcp_dbf_out(p, "fsf_reqid", "0x%0Lx", r->fsf_reqid); 311 zfcp_dbf_out(p, "fsf_seqno", "0x%08x", r->fsf_seqno); 312 stck_to_timespec(r->fsf_issued, &t); 313 zfcp_dbf_out(p, "fsf_issued", "%011lu:%06lu", t.tv_sec, t.tv_nsec); 314 zfcp_dbf_out(p, "fsf_prot_status", "0x%08x", r->fsf_prot_status); 315 zfcp_dbf_out(p, "fsf_status", "0x%08x", r->fsf_status); 316 zfcp_dbf_outd(p, "fsf_prot_status_qual", r->fsf_prot_status_qual, 317 FSF_PROT_STATUS_QUAL_SIZE, 0, FSF_PROT_STATUS_QUAL_SIZE); 318 zfcp_dbf_outd(p, "fsf_status_qual", r->fsf_status_qual, 319 FSF_STATUS_QUALIFIER_SIZE, 0, FSF_STATUS_QUALIFIER_SIZE); 320 zfcp_dbf_out(p, "fsf_req_status", "0x%08x", r->fsf_req_status); 321 zfcp_dbf_out(p, "sbal_first", "0x%02x", r->sbal_first); 322 zfcp_dbf_out(p, "sbal_last", "0x%02x", r->sbal_last); 323 zfcp_dbf_out(p, "sbal_response", "0x%02x", r->sbal_response); 324 zfcp_dbf_out(p, "pool", "0x%02x", r->pool); 325 326 switch (r->fsf_command) { 327 case FSF_QTCB_FCP_CMND: 328 if (r->fsf_req_status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT) 329 break; 330 zfcp_dbf_out(p, "data_direction", "0x%04x", r->u.fcp.data_dir); 331 zfcp_dbf_out(p, "scsi_cmnd", "0x%0Lx", r->u.fcp.cmnd); 332 *p += sprintf(*p, "\n"); 333 break; 334 335 case FSF_QTCB_OPEN_PORT_WITH_DID: 336 case FSF_QTCB_CLOSE_PORT: 337 case FSF_QTCB_CLOSE_PHYSICAL_PORT: 338 zfcp_dbf_out(p, "wwpn", "0x%016Lx", r->u.port.wwpn); 339 zfcp_dbf_out(p, "d_id", "0x%06x", r->u.port.d_id); 340 zfcp_dbf_out(p, "port_handle", "0x%08x", r->u.port.port_handle); 341 break; 342 343 case FSF_QTCB_OPEN_LUN: 344 case FSF_QTCB_CLOSE_LUN: 345 zfcp_dbf_out(p, "wwpn", "0x%016Lx", r->u.unit.wwpn); 346 zfcp_dbf_out(p, "fcp_lun", "0x%016Lx", r->u.unit.fcp_lun); 347 zfcp_dbf_out(p, "port_handle", "0x%08x", r->u.unit.port_handle); 348 zfcp_dbf_out(p, "lun_handle", "0x%08x", r->u.unit.lun_handle); 349 break; 350 351 case FSF_QTCB_SEND_ELS: 352 zfcp_dbf_out(p, "d_id", "0x%06x", r->u.els.d_id); 353 break; 354 355 case FSF_QTCB_ABORT_FCP_CMND: 356 case FSF_QTCB_SEND_GENERIC: 357 case FSF_QTCB_EXCHANGE_CONFIG_DATA: 358 case FSF_QTCB_EXCHANGE_PORT_DATA: 359 case FSF_QTCB_DOWNLOAD_CONTROL_FILE: 360 case FSF_QTCB_UPLOAD_CONTROL_FILE: 361 break; 362 } 363 } 364 365 static void zfcp_dbf_hba_view_status(char **p, 366 struct zfcp_dbf_hba_record_status *r) 367 { 368 zfcp_dbf_out(p, "failed", "0x%02x", r->failed); 369 zfcp_dbf_out(p, "status_type", "0x%08x", r->status_type); 370 zfcp_dbf_out(p, "status_subtype", "0x%08x", r->status_subtype); 371 zfcp_dbf_outd(p, "queue_designator", (char *)&r->queue_designator, 372 sizeof(struct fsf_queue_designator), 0, 373 sizeof(struct fsf_queue_designator)); 374 zfcp_dbf_outd(p, "payload", (char *)&r->payload, r->payload_size, 0, 375 r->payload_size); 376 } 377 378 static void zfcp_dbf_hba_view_qdio(char **p, struct zfcp_dbf_hba_record_qdio *r) 379 { 380 zfcp_dbf_out(p, "qdio_error", "0x%08x", r->qdio_error); 381 zfcp_dbf_out(p, "sbal_index", "0x%02x", r->sbal_index); 382 zfcp_dbf_out(p, "sbal_count", "0x%02x", r->sbal_count); 383 } 384 385 static void zfcp_dbf_hba_view_berr(char **p, struct fsf_bit_error_payload *r) 386 { 387 zfcp_dbf_out(p, "link_failures", "%d", r->link_failure_error_count); 388 zfcp_dbf_out(p, "loss_of_sync_err", "%d", r->loss_of_sync_error_count); 389 zfcp_dbf_out(p, "loss_of_sig_err", "%d", r->loss_of_signal_error_count); 390 zfcp_dbf_out(p, "prim_seq_err", "%d", 391 r->primitive_sequence_error_count); 392 zfcp_dbf_out(p, "inval_trans_word_err", "%d", 393 r->invalid_transmission_word_error_count); 394 zfcp_dbf_out(p, "CRC_errors", "%d", r->crc_error_count); 395 zfcp_dbf_out(p, "prim_seq_event_to", "%d", 396 r->primitive_sequence_event_timeout_count); 397 zfcp_dbf_out(p, "elast_buf_overrun_err", "%d", 398 r->elastic_buffer_overrun_error_count); 399 zfcp_dbf_out(p, "adv_rec_buf2buf_cred", "%d", 400 r->advertised_receive_b2b_credit); 401 zfcp_dbf_out(p, "curr_rec_buf2buf_cred", "%d", 402 r->current_receive_b2b_credit); 403 zfcp_dbf_out(p, "adv_trans_buf2buf_cred", "%d", 404 r->advertised_transmit_b2b_credit); 405 zfcp_dbf_out(p, "curr_trans_buf2buf_cred", "%d", 406 r->current_transmit_b2b_credit); 407 } 408 409 static int zfcp_dbf_hba_view_format(debug_info_t *id, struct debug_view *view, 410 char *out_buf, const char *in_buf) 411 { 412 struct zfcp_dbf_hba_record *r = (struct zfcp_dbf_hba_record *)in_buf; 413 char *p = out_buf; 414 415 if (strncmp(r->tag, "dump", ZFCP_DBF_TAG_SIZE) == 0) 416 return 0; 417 418 zfcp_dbf_tag(&p, "tag", r->tag); 419 if (isalpha(r->tag2[0])) 420 zfcp_dbf_tag(&p, "tag2", r->tag2); 421 422 if (strncmp(r->tag, "resp", ZFCP_DBF_TAG_SIZE) == 0) 423 zfcp_dbf_hba_view_response(&p, &r->u.response); 424 else if (strncmp(r->tag, "stat", ZFCP_DBF_TAG_SIZE) == 0) 425 zfcp_dbf_hba_view_status(&p, &r->u.status); 426 else if (strncmp(r->tag, "qdio", ZFCP_DBF_TAG_SIZE) == 0) 427 zfcp_dbf_hba_view_qdio(&p, &r->u.qdio); 428 else if (strncmp(r->tag, "berr", ZFCP_DBF_TAG_SIZE) == 0) 429 zfcp_dbf_hba_view_berr(&p, &r->u.berr); 430 431 if (strncmp(r->tag, "resp", ZFCP_DBF_TAG_SIZE) != 0) 432 p += sprintf(p, "\n"); 433 return p - out_buf; 434 } 435 436 static struct debug_view zfcp_dbf_hba_view = { 437 .name = "structured", 438 .header_proc = zfcp_dbf_view_header, 439 .format_proc = zfcp_dbf_hba_view_format, 440 }; 441 442 static const char *zfcp_dbf_rec_tags[] = { 443 [ZFCP_REC_DBF_ID_THREAD] = "thread", 444 [ZFCP_REC_DBF_ID_TARGET] = "target", 445 [ZFCP_REC_DBF_ID_TRIGGER] = "trigger", 446 [ZFCP_REC_DBF_ID_ACTION] = "action", 447 }; 448 449 static int zfcp_dbf_rec_view_format(debug_info_t *id, struct debug_view *view, 450 char *buf, const char *_rec) 451 { 452 struct zfcp_dbf_rec_record *r = (struct zfcp_dbf_rec_record *)_rec; 453 char *p = buf; 454 char hint[ZFCP_DBF_ID_SIZE + 1]; 455 456 memcpy(hint, r->id2, ZFCP_DBF_ID_SIZE); 457 hint[ZFCP_DBF_ID_SIZE] = 0; 458 zfcp_dbf_outs(&p, "tag", zfcp_dbf_rec_tags[r->id]); 459 zfcp_dbf_outs(&p, "hint", hint); 460 switch (r->id) { 461 case ZFCP_REC_DBF_ID_THREAD: 462 zfcp_dbf_out(&p, "total", "%d", r->u.thread.total); 463 zfcp_dbf_out(&p, "ready", "%d", r->u.thread.ready); 464 zfcp_dbf_out(&p, "running", "%d", r->u.thread.running); 465 break; 466 case ZFCP_REC_DBF_ID_TARGET: 467 zfcp_dbf_out(&p, "reference", "0x%016Lx", r->u.target.ref); 468 zfcp_dbf_out(&p, "status", "0x%08x", r->u.target.status); 469 zfcp_dbf_out(&p, "erp_count", "%d", r->u.target.erp_count); 470 zfcp_dbf_out(&p, "d_id", "0x%06x", r->u.target.d_id); 471 zfcp_dbf_out(&p, "wwpn", "0x%016Lx", r->u.target.wwpn); 472 zfcp_dbf_out(&p, "fcp_lun", "0x%016Lx", r->u.target.fcp_lun); 473 break; 474 case ZFCP_REC_DBF_ID_TRIGGER: 475 zfcp_dbf_out(&p, "reference", "0x%016Lx", r->u.trigger.ref); 476 zfcp_dbf_out(&p, "erp_action", "0x%016Lx", r->u.trigger.action); 477 zfcp_dbf_out(&p, "requested", "%d", r->u.trigger.want); 478 zfcp_dbf_out(&p, "executed", "%d", r->u.trigger.need); 479 zfcp_dbf_out(&p, "wwpn", "0x%016Lx", r->u.trigger.wwpn); 480 zfcp_dbf_out(&p, "fcp_lun", "0x%016Lx", r->u.trigger.fcp_lun); 481 zfcp_dbf_out(&p, "adapter_status", "0x%08x", r->u.trigger.as); 482 zfcp_dbf_out(&p, "port_status", "0x%08x", r->u.trigger.ps); 483 zfcp_dbf_out(&p, "lun_status", "0x%08x", r->u.trigger.ls); 484 break; 485 case ZFCP_REC_DBF_ID_ACTION: 486 zfcp_dbf_out(&p, "erp_action", "0x%016Lx", r->u.action.action); 487 zfcp_dbf_out(&p, "fsf_req", "0x%016Lx", r->u.action.fsf_req); 488 zfcp_dbf_out(&p, "status", "0x%08Lx", r->u.action.status); 489 zfcp_dbf_out(&p, "step", "0x%08Lx", r->u.action.step); 490 break; 491 } 492 p += sprintf(p, "\n"); 493 return p - buf; 494 } 495 496 static struct debug_view zfcp_dbf_rec_view = { 497 .name = "structured", 498 .header_proc = zfcp_dbf_view_header, 499 .format_proc = zfcp_dbf_rec_view_format, 500 }; 501 502 /** 503 * zfcp_dbf_rec_thread - trace event related to recovery thread operation 504 * @id2: identifier for event 505 * @dbf: reference to dbf structure 506 * This function assumes that the caller is holding erp_lock. 507 */ 508 void zfcp_dbf_rec_thread(char *id2, struct zfcp_dbf *dbf) 509 { 510 struct zfcp_adapter *adapter = dbf->adapter; 511 struct zfcp_dbf_rec_record *r = &dbf->rec_buf; 512 unsigned long flags = 0; 513 struct list_head *entry; 514 unsigned ready = 0, running = 0, total; 515 516 list_for_each(entry, &adapter->erp_ready_head) 517 ready++; 518 list_for_each(entry, &adapter->erp_running_head) 519 running++; 520 total = adapter->erp_total_count; 521 522 spin_lock_irqsave(&dbf->rec_lock, flags); 523 memset(r, 0, sizeof(*r)); 524 r->id = ZFCP_REC_DBF_ID_THREAD; 525 memcpy(r->id2, id2, ZFCP_DBF_ID_SIZE); 526 r->u.thread.total = total; 527 r->u.thread.ready = ready; 528 r->u.thread.running = running; 529 debug_event(dbf->rec, 6, r, sizeof(*r)); 530 spin_unlock_irqrestore(&dbf->rec_lock, flags); 531 } 532 533 /** 534 * zfcp_dbf_rec_thread - trace event related to recovery thread operation 535 * @id2: identifier for event 536 * @adapter: adapter 537 * This function assumes that the caller does not hold erp_lock. 538 */ 539 void zfcp_dbf_rec_thread_lock(char *id2, struct zfcp_dbf *dbf) 540 { 541 struct zfcp_adapter *adapter = dbf->adapter; 542 unsigned long flags; 543 544 read_lock_irqsave(&adapter->erp_lock, flags); 545 zfcp_dbf_rec_thread(id2, dbf); 546 read_unlock_irqrestore(&adapter->erp_lock, flags); 547 } 548 549 static void zfcp_dbf_rec_target(char *id2, void *ref, struct zfcp_dbf *dbf, 550 atomic_t *status, atomic_t *erp_count, u64 wwpn, 551 u32 d_id, u64 fcp_lun) 552 { 553 struct zfcp_dbf_rec_record *r = &dbf->rec_buf; 554 unsigned long flags; 555 556 spin_lock_irqsave(&dbf->rec_lock, flags); 557 memset(r, 0, sizeof(*r)); 558 r->id = ZFCP_REC_DBF_ID_TARGET; 559 memcpy(r->id2, id2, ZFCP_DBF_ID_SIZE); 560 r->u.target.ref = (unsigned long)ref; 561 r->u.target.status = atomic_read(status); 562 r->u.target.wwpn = wwpn; 563 r->u.target.d_id = d_id; 564 r->u.target.fcp_lun = fcp_lun; 565 r->u.target.erp_count = atomic_read(erp_count); 566 debug_event(dbf->rec, 3, r, sizeof(*r)); 567 spin_unlock_irqrestore(&dbf->rec_lock, flags); 568 } 569 570 /** 571 * zfcp_dbf_rec_adapter - trace event for adapter state change 572 * @id: identifier for trigger of state change 573 * @ref: additional reference (e.g. request) 574 * @dbf: reference to dbf structure 575 */ 576 void zfcp_dbf_rec_adapter(char *id, void *ref, struct zfcp_dbf *dbf) 577 { 578 struct zfcp_adapter *adapter = dbf->adapter; 579 580 zfcp_dbf_rec_target(id, ref, dbf, &adapter->status, 581 &adapter->erp_counter, 0, 0, 582 ZFCP_DBF_INVALID_LUN); 583 } 584 585 /** 586 * zfcp_dbf_rec_port - trace event for port state change 587 * @id: identifier for trigger of state change 588 * @ref: additional reference (e.g. request) 589 * @port: port 590 */ 591 void zfcp_dbf_rec_port(char *id, void *ref, struct zfcp_port *port) 592 { 593 struct zfcp_dbf *dbf = port->adapter->dbf; 594 595 zfcp_dbf_rec_target(id, ref, dbf, &port->status, 596 &port->erp_counter, port->wwpn, port->d_id, 597 ZFCP_DBF_INVALID_LUN); 598 } 599 600 /** 601 * zfcp_dbf_rec_lun - trace event for LUN state change 602 * @id: identifier for trigger of state change 603 * @ref: additional reference (e.g. request) 604 * @sdev: SCSI device 605 */ 606 void zfcp_dbf_rec_lun(char *id, void *ref, struct scsi_device *sdev) 607 { 608 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev); 609 struct zfcp_port *port = zfcp_sdev->port; 610 struct zfcp_dbf *dbf = port->adapter->dbf; 611 612 zfcp_dbf_rec_target(id, ref, dbf, &zfcp_sdev->status, 613 &zfcp_sdev->erp_counter, port->wwpn, port->d_id, 614 zfcp_scsi_dev_lun(sdev)); 615 } 616 617 /** 618 * zfcp_dbf_rec_trigger - trace event for triggered error recovery 619 * @id2: identifier for error recovery trigger 620 * @ref: additional reference (e.g. request) 621 * @want: originally requested error recovery action 622 * @need: error recovery action actually initiated 623 * @action: address of error recovery action struct 624 * @adapter: adapter 625 * @port: port 626 * @sdev: SCSI device 627 */ 628 void zfcp_dbf_rec_trigger(char *id2, void *ref, u8 want, u8 need, void *action, 629 struct zfcp_adapter *adapter, struct zfcp_port *port, 630 struct scsi_device *sdev) 631 { 632 struct zfcp_dbf *dbf = adapter->dbf; 633 struct zfcp_dbf_rec_record *r = &dbf->rec_buf; 634 unsigned long flags; 635 636 spin_lock_irqsave(&dbf->rec_lock, flags); 637 memset(r, 0, sizeof(*r)); 638 r->id = ZFCP_REC_DBF_ID_TRIGGER; 639 memcpy(r->id2, id2, ZFCP_DBF_ID_SIZE); 640 r->u.trigger.ref = (unsigned long)ref; 641 r->u.trigger.want = want; 642 r->u.trigger.need = need; 643 r->u.trigger.action = (unsigned long)action; 644 r->u.trigger.as = atomic_read(&adapter->status); 645 if (port) { 646 r->u.trigger.ps = atomic_read(&port->status); 647 r->u.trigger.wwpn = port->wwpn; 648 } 649 if (sdev) 650 r->u.trigger.ls = atomic_read(&sdev_to_zfcp(sdev)->status); 651 r->u.trigger.fcp_lun = sdev ? zfcp_scsi_dev_lun(sdev) : 652 ZFCP_DBF_INVALID_LUN; 653 debug_event(dbf->rec, action ? 1 : 4, r, sizeof(*r)); 654 spin_unlock_irqrestore(&dbf->rec_lock, flags); 655 } 656 657 /** 658 * zfcp_dbf_rec_action - trace event showing progress of recovery action 659 * @id2: identifier 660 * @erp_action: error recovery action struct pointer 661 */ 662 void zfcp_dbf_rec_action(char *id2, struct zfcp_erp_action *erp_action) 663 { 664 struct zfcp_dbf *dbf = erp_action->adapter->dbf; 665 struct zfcp_dbf_rec_record *r = &dbf->rec_buf; 666 unsigned long flags; 667 668 spin_lock_irqsave(&dbf->rec_lock, flags); 669 memset(r, 0, sizeof(*r)); 670 r->id = ZFCP_REC_DBF_ID_ACTION; 671 memcpy(r->id2, id2, ZFCP_DBF_ID_SIZE); 672 r->u.action.action = (unsigned long)erp_action; 673 r->u.action.status = erp_action->status; 674 r->u.action.step = erp_action->step; 675 r->u.action.fsf_req = erp_action->fsf_req_id; 676 debug_event(dbf->rec, 5, r, sizeof(*r)); 677 spin_unlock_irqrestore(&dbf->rec_lock, flags); 678 } 679 680 /** 681 * zfcp_dbf_san_ct_request - trace event for issued CT request 682 * @fsf_req: request containing issued CT data 683 * @d_id: destination id where ct request is sent to 684 */ 685 void zfcp_dbf_san_ct_request(struct zfcp_fsf_req *fsf_req, u32 d_id) 686 { 687 struct zfcp_fsf_ct_els *ct = (struct zfcp_fsf_ct_els *)fsf_req->data; 688 struct zfcp_adapter *adapter = fsf_req->adapter; 689 struct zfcp_dbf *dbf = adapter->dbf; 690 struct fc_ct_hdr *hdr = sg_virt(ct->req); 691 struct zfcp_dbf_san_record *r = &dbf->san_buf; 692 struct zfcp_dbf_san_record_ct_request *oct = &r->u.ct_req; 693 int level = 3; 694 unsigned long flags; 695 696 spin_lock_irqsave(&dbf->san_lock, flags); 697 memset(r, 0, sizeof(*r)); 698 strncpy(r->tag, "octc", ZFCP_DBF_TAG_SIZE); 699 r->fsf_reqid = fsf_req->req_id; 700 r->fsf_seqno = fsf_req->seq_no; 701 oct->d_id = d_id; 702 oct->cmd_req_code = hdr->ct_cmd; 703 oct->revision = hdr->ct_rev; 704 oct->gs_type = hdr->ct_fs_type; 705 oct->gs_subtype = hdr->ct_fs_subtype; 706 oct->options = hdr->ct_options; 707 oct->max_res_size = hdr->ct_mr_size; 708 oct->len = min((int)ct->req->length - (int)sizeof(struct fc_ct_hdr), 709 ZFCP_DBF_SAN_MAX_PAYLOAD); 710 debug_event(dbf->san, level, r, sizeof(*r)); 711 zfcp_dbf_hexdump(dbf->san, r, sizeof(*r), level, 712 (void *)hdr + sizeof(struct fc_ct_hdr), oct->len); 713 spin_unlock_irqrestore(&dbf->san_lock, flags); 714 } 715 716 /** 717 * zfcp_dbf_san_ct_response - trace event for completion of CT request 718 * @fsf_req: request containing CT response 719 */ 720 void zfcp_dbf_san_ct_response(struct zfcp_fsf_req *fsf_req) 721 { 722 struct zfcp_fsf_ct_els *ct = (struct zfcp_fsf_ct_els *)fsf_req->data; 723 struct zfcp_adapter *adapter = fsf_req->adapter; 724 struct fc_ct_hdr *hdr = sg_virt(ct->resp); 725 struct zfcp_dbf *dbf = adapter->dbf; 726 struct zfcp_dbf_san_record *r = &dbf->san_buf; 727 struct zfcp_dbf_san_record_ct_response *rct = &r->u.ct_resp; 728 int level = 3; 729 unsigned long flags; 730 731 spin_lock_irqsave(&dbf->san_lock, flags); 732 memset(r, 0, sizeof(*r)); 733 strncpy(r->tag, "rctc", ZFCP_DBF_TAG_SIZE); 734 r->fsf_reqid = fsf_req->req_id; 735 r->fsf_seqno = fsf_req->seq_no; 736 rct->cmd_rsp_code = hdr->ct_cmd; 737 rct->revision = hdr->ct_rev; 738 rct->reason_code = hdr->ct_reason; 739 rct->expl = hdr->ct_explan; 740 rct->vendor_unique = hdr->ct_vendor; 741 rct->max_res_size = hdr->ct_mr_size; 742 rct->len = min((int)ct->resp->length - (int)sizeof(struct fc_ct_hdr), 743 ZFCP_DBF_SAN_MAX_PAYLOAD); 744 debug_event(dbf->san, level, r, sizeof(*r)); 745 zfcp_dbf_hexdump(dbf->san, r, sizeof(*r), level, 746 (void *)hdr + sizeof(struct fc_ct_hdr), rct->len); 747 spin_unlock_irqrestore(&dbf->san_lock, flags); 748 } 749 750 static void zfcp_dbf_san_els(const char *tag, int level, 751 struct zfcp_fsf_req *fsf_req, u32 d_id, 752 void *buffer, int buflen) 753 { 754 struct zfcp_adapter *adapter = fsf_req->adapter; 755 struct zfcp_dbf *dbf = adapter->dbf; 756 struct zfcp_dbf_san_record *rec = &dbf->san_buf; 757 unsigned long flags; 758 759 spin_lock_irqsave(&dbf->san_lock, flags); 760 memset(rec, 0, sizeof(*rec)); 761 strncpy(rec->tag, tag, ZFCP_DBF_TAG_SIZE); 762 rec->fsf_reqid = fsf_req->req_id; 763 rec->fsf_seqno = fsf_req->seq_no; 764 rec->u.els.d_id = d_id; 765 debug_event(dbf->san, level, rec, sizeof(*rec)); 766 zfcp_dbf_hexdump(dbf->san, rec, sizeof(*rec), level, 767 buffer, min(buflen, ZFCP_DBF_SAN_MAX_PAYLOAD)); 768 spin_unlock_irqrestore(&dbf->san_lock, flags); 769 } 770 771 /** 772 * zfcp_dbf_san_els_request - trace event for issued ELS 773 * @fsf_req: request containing issued ELS 774 */ 775 void zfcp_dbf_san_els_request(struct zfcp_fsf_req *fsf_req) 776 { 777 struct zfcp_fsf_ct_els *els = (struct zfcp_fsf_ct_els *)fsf_req->data; 778 u32 d_id = ntoh24(fsf_req->qtcb->bottom.support.d_id); 779 780 zfcp_dbf_san_els("oels", 2, fsf_req, d_id, 781 sg_virt(els->req), els->req->length); 782 } 783 784 /** 785 * zfcp_dbf_san_els_response - trace event for completed ELS 786 * @fsf_req: request containing ELS response 787 */ 788 void zfcp_dbf_san_els_response(struct zfcp_fsf_req *fsf_req) 789 { 790 struct zfcp_fsf_ct_els *els = (struct zfcp_fsf_ct_els *)fsf_req->data; 791 u32 d_id = ntoh24(fsf_req->qtcb->bottom.support.d_id); 792 793 zfcp_dbf_san_els("rels", 2, fsf_req, d_id, 794 sg_virt(els->resp), els->resp->length); 795 } 796 797 /** 798 * zfcp_dbf_san_incoming_els - trace event for incomig ELS 799 * @fsf_req: request containing unsolicited status buffer with incoming ELS 800 */ 801 void zfcp_dbf_san_incoming_els(struct zfcp_fsf_req *fsf_req) 802 { 803 struct fsf_status_read_buffer *buf = 804 (struct fsf_status_read_buffer *)fsf_req->data; 805 int length = (int)buf->length - 806 (int)((void *)&buf->payload - (void *)buf); 807 808 zfcp_dbf_san_els("iels", 1, fsf_req, ntoh24(buf->d_id), 809 (void *)buf->payload.data, length); 810 } 811 812 static int zfcp_dbf_san_view_format(debug_info_t *id, struct debug_view *view, 813 char *out_buf, const char *in_buf) 814 { 815 struct zfcp_dbf_san_record *r = (struct zfcp_dbf_san_record *)in_buf; 816 char *p = out_buf; 817 818 if (strncmp(r->tag, "dump", ZFCP_DBF_TAG_SIZE) == 0) 819 return 0; 820 821 zfcp_dbf_tag(&p, "tag", r->tag); 822 zfcp_dbf_out(&p, "fsf_reqid", "0x%0Lx", r->fsf_reqid); 823 zfcp_dbf_out(&p, "fsf_seqno", "0x%08x", r->fsf_seqno); 824 825 if (strncmp(r->tag, "octc", ZFCP_DBF_TAG_SIZE) == 0) { 826 struct zfcp_dbf_san_record_ct_request *ct = &r->u.ct_req; 827 zfcp_dbf_out(&p, "d_id", "0x%06x", ct->d_id); 828 zfcp_dbf_out(&p, "cmd_req_code", "0x%04x", ct->cmd_req_code); 829 zfcp_dbf_out(&p, "revision", "0x%02x", ct->revision); 830 zfcp_dbf_out(&p, "gs_type", "0x%02x", ct->gs_type); 831 zfcp_dbf_out(&p, "gs_subtype", "0x%02x", ct->gs_subtype); 832 zfcp_dbf_out(&p, "options", "0x%02x", ct->options); 833 zfcp_dbf_out(&p, "max_res_size", "0x%04x", ct->max_res_size); 834 } else if (strncmp(r->tag, "rctc", ZFCP_DBF_TAG_SIZE) == 0) { 835 struct zfcp_dbf_san_record_ct_response *ct = &r->u.ct_resp; 836 zfcp_dbf_out(&p, "cmd_rsp_code", "0x%04x", ct->cmd_rsp_code); 837 zfcp_dbf_out(&p, "revision", "0x%02x", ct->revision); 838 zfcp_dbf_out(&p, "reason_code", "0x%02x", ct->reason_code); 839 zfcp_dbf_out(&p, "reason_code_expl", "0x%02x", ct->expl); 840 zfcp_dbf_out(&p, "vendor_unique", "0x%02x", ct->vendor_unique); 841 zfcp_dbf_out(&p, "max_res_size", "0x%04x", ct->max_res_size); 842 } else if (strncmp(r->tag, "oels", ZFCP_DBF_TAG_SIZE) == 0 || 843 strncmp(r->tag, "rels", ZFCP_DBF_TAG_SIZE) == 0 || 844 strncmp(r->tag, "iels", ZFCP_DBF_TAG_SIZE) == 0) { 845 struct zfcp_dbf_san_record_els *els = &r->u.els; 846 zfcp_dbf_out(&p, "d_id", "0x%06x", els->d_id); 847 } 848 return p - out_buf; 849 } 850 851 static struct debug_view zfcp_dbf_san_view = { 852 .name = "structured", 853 .header_proc = zfcp_dbf_view_header, 854 .format_proc = zfcp_dbf_san_view_format, 855 }; 856 857 void _zfcp_dbf_scsi(const char *tag, const char *tag2, int level, 858 struct zfcp_dbf *dbf, struct scsi_cmnd *scsi_cmnd, 859 struct zfcp_fsf_req *fsf_req, unsigned long old_req_id) 860 { 861 struct zfcp_dbf_scsi_record *rec = &dbf->scsi_buf; 862 struct zfcp_dbf_dump *dump = (struct zfcp_dbf_dump *)rec; 863 unsigned long flags; 864 struct fcp_resp_with_ext *fcp_rsp; 865 struct fcp_resp_rsp_info *fcp_rsp_info = NULL; 866 char *fcp_sns_info = NULL; 867 int offset = 0, buflen = 0; 868 869 spin_lock_irqsave(&dbf->scsi_lock, flags); 870 do { 871 memset(rec, 0, sizeof(*rec)); 872 if (offset == 0) { 873 strncpy(rec->tag, tag, ZFCP_DBF_TAG_SIZE); 874 strncpy(rec->tag2, tag2, ZFCP_DBF_TAG_SIZE); 875 if (scsi_cmnd != NULL) { 876 if (scsi_cmnd->device) { 877 rec->scsi_id = scsi_cmnd->device->id; 878 rec->scsi_lun = scsi_cmnd->device->lun; 879 } 880 rec->scsi_result = scsi_cmnd->result; 881 rec->scsi_cmnd = (unsigned long)scsi_cmnd; 882 memcpy(rec->scsi_opcode, scsi_cmnd->cmnd, 883 min((int)scsi_cmnd->cmd_len, 884 ZFCP_DBF_SCSI_OPCODE)); 885 rec->scsi_retries = scsi_cmnd->retries; 886 rec->scsi_allowed = scsi_cmnd->allowed; 887 } 888 if (fsf_req != NULL) { 889 fcp_rsp = (struct fcp_resp_with_ext *) 890 &(fsf_req->qtcb->bottom.io.fcp_rsp); 891 fcp_rsp_info = (struct fcp_resp_rsp_info *) 892 &fcp_rsp[1]; 893 fcp_sns_info = (char *) &fcp_rsp[1]; 894 if (fcp_rsp->resp.fr_flags & FCP_RSP_LEN_VAL) 895 fcp_sns_info += fcp_rsp->ext.fr_sns_len; 896 897 rec->rsp_validity = fcp_rsp->resp.fr_flags; 898 rec->rsp_scsi_status = fcp_rsp->resp.fr_status; 899 rec->rsp_resid = fcp_rsp->ext.fr_resid; 900 if (fcp_rsp->resp.fr_flags & FCP_RSP_LEN_VAL) 901 rec->rsp_code = fcp_rsp_info->rsp_code; 902 if (fcp_rsp->resp.fr_flags & FCP_SNS_LEN_VAL) { 903 buflen = min(fcp_rsp->ext.fr_sns_len, 904 (u32)ZFCP_DBF_SCSI_MAX_FCP_SNS_INFO); 905 rec->sns_info_len = buflen; 906 memcpy(rec->sns_info, fcp_sns_info, 907 min(buflen, 908 ZFCP_DBF_SCSI_FCP_SNS_INFO)); 909 offset += min(buflen, 910 ZFCP_DBF_SCSI_FCP_SNS_INFO); 911 } 912 913 rec->fsf_reqid = fsf_req->req_id; 914 rec->fsf_seqno = fsf_req->seq_no; 915 rec->fsf_issued = fsf_req->issued; 916 } 917 rec->old_fsf_reqid = old_req_id; 918 } else { 919 strncpy(dump->tag, "dump", ZFCP_DBF_TAG_SIZE); 920 dump->total_size = buflen; 921 dump->offset = offset; 922 dump->size = min(buflen - offset, 923 (int)sizeof(struct 924 zfcp_dbf_scsi_record) - 925 (int)sizeof(struct zfcp_dbf_dump)); 926 memcpy(dump->data, fcp_sns_info + offset, dump->size); 927 offset += dump->size; 928 } 929 debug_event(dbf->scsi, level, rec, sizeof(*rec)); 930 } while (offset < buflen); 931 spin_unlock_irqrestore(&dbf->scsi_lock, flags); 932 } 933 934 static int zfcp_dbf_scsi_view_format(debug_info_t *id, struct debug_view *view, 935 char *out_buf, const char *in_buf) 936 { 937 struct zfcp_dbf_scsi_record *r = (struct zfcp_dbf_scsi_record *)in_buf; 938 struct timespec t; 939 char *p = out_buf; 940 941 if (strncmp(r->tag, "dump", ZFCP_DBF_TAG_SIZE) == 0) 942 return 0; 943 944 zfcp_dbf_tag(&p, "tag", r->tag); 945 zfcp_dbf_tag(&p, "tag2", r->tag2); 946 zfcp_dbf_out(&p, "scsi_id", "0x%08x", r->scsi_id); 947 zfcp_dbf_out(&p, "scsi_lun", "0x%08x", r->scsi_lun); 948 zfcp_dbf_out(&p, "scsi_result", "0x%08x", r->scsi_result); 949 zfcp_dbf_out(&p, "scsi_cmnd", "0x%0Lx", r->scsi_cmnd); 950 zfcp_dbf_outd(&p, "scsi_opcode", r->scsi_opcode, ZFCP_DBF_SCSI_OPCODE, 951 0, ZFCP_DBF_SCSI_OPCODE); 952 zfcp_dbf_out(&p, "scsi_retries", "0x%02x", r->scsi_retries); 953 zfcp_dbf_out(&p, "scsi_allowed", "0x%02x", r->scsi_allowed); 954 if (strncmp(r->tag, "abrt", ZFCP_DBF_TAG_SIZE) == 0) 955 zfcp_dbf_out(&p, "old_fsf_reqid", "0x%0Lx", r->old_fsf_reqid); 956 zfcp_dbf_out(&p, "fsf_reqid", "0x%0Lx", r->fsf_reqid); 957 zfcp_dbf_out(&p, "fsf_seqno", "0x%08x", r->fsf_seqno); 958 stck_to_timespec(r->fsf_issued, &t); 959 zfcp_dbf_out(&p, "fsf_issued", "%011lu:%06lu", t.tv_sec, t.tv_nsec); 960 961 if (strncmp(r->tag, "rslt", ZFCP_DBF_TAG_SIZE) == 0) { 962 zfcp_dbf_out(&p, "fcp_rsp_validity", "0x%02x", r->rsp_validity); 963 zfcp_dbf_out(&p, "fcp_rsp_scsi_status", "0x%02x", 964 r->rsp_scsi_status); 965 zfcp_dbf_out(&p, "fcp_rsp_resid", "0x%08x", r->rsp_resid); 966 zfcp_dbf_out(&p, "fcp_rsp_code", "0x%08x", r->rsp_code); 967 zfcp_dbf_out(&p, "fcp_sns_info_len", "0x%08x", r->sns_info_len); 968 zfcp_dbf_outd(&p, "fcp_sns_info", r->sns_info, 969 min((int)r->sns_info_len, 970 ZFCP_DBF_SCSI_FCP_SNS_INFO), 0, 971 r->sns_info_len); 972 } 973 p += sprintf(p, "\n"); 974 return p - out_buf; 975 } 976 977 static struct debug_view zfcp_dbf_scsi_view = { 978 .name = "structured", 979 .header_proc = zfcp_dbf_view_header, 980 .format_proc = zfcp_dbf_scsi_view_format, 981 }; 982 983 static debug_info_t *zfcp_dbf_reg(const char *name, int level, 984 struct debug_view *view, int size) 985 { 986 struct debug_info *d; 987 988 d = debug_register(name, dbfsize, level, size); 989 if (!d) 990 return NULL; 991 992 debug_register_view(d, &debug_hex_ascii_view); 993 debug_register_view(d, view); 994 debug_set_level(d, level); 995 996 return d; 997 } 998 999 /** 1000 * zfcp_adapter_debug_register - registers debug feature for an adapter 1001 * @adapter: pointer to adapter for which debug features should be registered 1002 * return: -ENOMEM on error, 0 otherwise 1003 */ 1004 int zfcp_dbf_adapter_register(struct zfcp_adapter *adapter) 1005 { 1006 char dbf_name[DEBUG_MAX_NAME_LEN]; 1007 struct zfcp_dbf *dbf; 1008 1009 dbf = kzalloc(sizeof(struct zfcp_dbf), GFP_KERNEL); 1010 if (!dbf) 1011 return -ENOMEM; 1012 1013 dbf->adapter = adapter; 1014 1015 spin_lock_init(&dbf->hba_lock); 1016 spin_lock_init(&dbf->san_lock); 1017 spin_lock_init(&dbf->scsi_lock); 1018 spin_lock_init(&dbf->rec_lock); 1019 1020 /* debug feature area which records recovery activity */ 1021 sprintf(dbf_name, "zfcp_%s_rec", dev_name(&adapter->ccw_device->dev)); 1022 dbf->rec = zfcp_dbf_reg(dbf_name, 3, &zfcp_dbf_rec_view, 1023 sizeof(struct zfcp_dbf_rec_record)); 1024 if (!dbf->rec) 1025 goto err_out; 1026 1027 /* debug feature area which records HBA (FSF and QDIO) conditions */ 1028 sprintf(dbf_name, "zfcp_%s_hba", dev_name(&adapter->ccw_device->dev)); 1029 dbf->hba = zfcp_dbf_reg(dbf_name, 3, &zfcp_dbf_hba_view, 1030 sizeof(struct zfcp_dbf_hba_record)); 1031 if (!dbf->hba) 1032 goto err_out; 1033 1034 /* debug feature area which records SAN command failures and recovery */ 1035 sprintf(dbf_name, "zfcp_%s_san", dev_name(&adapter->ccw_device->dev)); 1036 dbf->san = zfcp_dbf_reg(dbf_name, 6, &zfcp_dbf_san_view, 1037 sizeof(struct zfcp_dbf_san_record)); 1038 if (!dbf->san) 1039 goto err_out; 1040 1041 /* debug feature area which records SCSI command failures and recovery */ 1042 sprintf(dbf_name, "zfcp_%s_scsi", dev_name(&adapter->ccw_device->dev)); 1043 dbf->scsi = zfcp_dbf_reg(dbf_name, 3, &zfcp_dbf_scsi_view, 1044 sizeof(struct zfcp_dbf_scsi_record)); 1045 if (!dbf->scsi) 1046 goto err_out; 1047 1048 adapter->dbf = dbf; 1049 return 0; 1050 1051 err_out: 1052 zfcp_dbf_adapter_unregister(dbf); 1053 return -ENOMEM; 1054 } 1055 1056 /** 1057 * zfcp_adapter_debug_unregister - unregisters debug feature for an adapter 1058 * @dbf: pointer to dbf for which debug features should be unregistered 1059 */ 1060 void zfcp_dbf_adapter_unregister(struct zfcp_dbf *dbf) 1061 { 1062 if (!dbf) 1063 return; 1064 debug_unregister(dbf->scsi); 1065 debug_unregister(dbf->san); 1066 debug_unregister(dbf->hba); 1067 debug_unregister(dbf->rec); 1068 dbf->adapter->dbf = NULL; 1069 kfree(dbf); 1070 } 1071 1072