1 /* 2 * zfcp device driver 3 * 4 * Debug traces for zfcp. 5 * 6 * Copyright IBM Corporation 2002, 2008 7 */ 8 9 #include <linux/ctype.h> 10 #include <asm/debug.h> 11 #include "zfcp_ext.h" 12 13 static u32 dbfsize = 4; 14 15 module_param(dbfsize, uint, 0400); 16 MODULE_PARM_DESC(dbfsize, 17 "number of pages for each debug feature area (default 4)"); 18 19 static void zfcp_dbf_hexdump(debug_info_t *dbf, void *to, int to_len, 20 int level, char *from, int from_len) 21 { 22 int offset; 23 struct zfcp_dbf_dump *dump = to; 24 int room = to_len - sizeof(*dump); 25 26 for (offset = 0; offset < from_len; offset += dump->size) { 27 memset(to, 0, to_len); 28 strncpy(dump->tag, "dump", ZFCP_DBF_TAG_SIZE); 29 dump->total_size = from_len; 30 dump->offset = offset; 31 dump->size = min(from_len - offset, room); 32 memcpy(dump->data, from + offset, dump->size); 33 debug_event(dbf, level, dump, dump->size); 34 } 35 } 36 37 /* FIXME: this duplicate this code in s390 debug feature */ 38 static void zfcp_dbf_timestamp(unsigned long long stck, struct timespec *time) 39 { 40 unsigned long long sec; 41 42 stck -= 0x8126d60e46000000LL - (0x3c26700LL * 1000000 * 4096); 43 sec = stck >> 12; 44 do_div(sec, 1000000); 45 time->tv_sec = sec; 46 stck -= (sec * 1000000) << 12; 47 time->tv_nsec = ((stck * 1000) >> 12); 48 } 49 50 static void zfcp_dbf_tag(char **p, const char *label, const char *tag) 51 { 52 int i; 53 54 *p += sprintf(*p, "%-24s", label); 55 for (i = 0; i < ZFCP_DBF_TAG_SIZE; i++) 56 *p += sprintf(*p, "%c", tag[i]); 57 *p += sprintf(*p, "\n"); 58 } 59 60 static void zfcp_dbf_outs(char **buf, const char *s1, const char *s2) 61 { 62 *buf += sprintf(*buf, "%-24s%s\n", s1, s2); 63 } 64 65 static void zfcp_dbf_out(char **buf, const char *s, const char *format, ...) 66 { 67 va_list arg; 68 69 *buf += sprintf(*buf, "%-24s", s); 70 va_start(arg, format); 71 *buf += vsprintf(*buf, format, arg); 72 va_end(arg); 73 *buf += sprintf(*buf, "\n"); 74 } 75 76 static void zfcp_dbf_outd(char **p, const char *label, char *buffer, 77 int buflen, int offset, int total_size) 78 { 79 if (!offset) 80 *p += sprintf(*p, "%-24s ", label); 81 while (buflen--) { 82 if (offset > 0) { 83 if ((offset % 32) == 0) 84 *p += sprintf(*p, "\n%-24c ", ' '); 85 else if ((offset % 4) == 0) 86 *p += sprintf(*p, " "); 87 } 88 *p += sprintf(*p, "%02x", *buffer++); 89 if (++offset == total_size) { 90 *p += sprintf(*p, "\n"); 91 break; 92 } 93 } 94 if (!total_size) 95 *p += sprintf(*p, "\n"); 96 } 97 98 static int zfcp_dbf_view_header(debug_info_t *id, struct debug_view *view, 99 int area, debug_entry_t *entry, char *out_buf) 100 { 101 struct zfcp_dbf_dump *dump = (struct zfcp_dbf_dump *)DEBUG_DATA(entry); 102 struct timespec t; 103 char *p = out_buf; 104 105 if (strncmp(dump->tag, "dump", ZFCP_DBF_TAG_SIZE) != 0) { 106 zfcp_dbf_timestamp(entry->id.stck, &t); 107 zfcp_dbf_out(&p, "timestamp", "%011lu:%06lu", 108 t.tv_sec, t.tv_nsec); 109 zfcp_dbf_out(&p, "cpu", "%02i", entry->id.fields.cpuid); 110 } else { 111 zfcp_dbf_outd(&p, NULL, dump->data, dump->size, dump->offset, 112 dump->total_size); 113 if ((dump->offset + dump->size) == dump->total_size) 114 p += sprintf(p, "\n"); 115 } 116 return p - out_buf; 117 } 118 119 /** 120 * zfcp_hba_dbf_event_fsf_response - trace event for request completion 121 * @fsf_req: request that has been completed 122 */ 123 void zfcp_hba_dbf_event_fsf_response(struct zfcp_fsf_req *fsf_req) 124 { 125 struct zfcp_adapter *adapter = fsf_req->adapter; 126 struct fsf_qtcb *qtcb = fsf_req->qtcb; 127 union fsf_prot_status_qual *prot_status_qual = 128 &qtcb->prefix.prot_status_qual; 129 union fsf_status_qual *fsf_status_qual = &qtcb->header.fsf_status_qual; 130 struct scsi_cmnd *scsi_cmnd; 131 struct zfcp_port *port; 132 struct zfcp_unit *unit; 133 struct zfcp_send_els *send_els; 134 struct zfcp_hba_dbf_record *rec = &adapter->hba_dbf_buf; 135 struct zfcp_hba_dbf_record_response *response = &rec->u.response; 136 int level; 137 unsigned long flags; 138 139 spin_lock_irqsave(&adapter->hba_dbf_lock, flags); 140 memset(rec, 0, sizeof(*rec)); 141 strncpy(rec->tag, "resp", ZFCP_DBF_TAG_SIZE); 142 143 if ((qtcb->prefix.prot_status != FSF_PROT_GOOD) && 144 (qtcb->prefix.prot_status != FSF_PROT_FSF_STATUS_PRESENTED)) { 145 strncpy(rec->tag2, "perr", ZFCP_DBF_TAG_SIZE); 146 level = 1; 147 } else if (qtcb->header.fsf_status != FSF_GOOD) { 148 strncpy(rec->tag2, "ferr", ZFCP_DBF_TAG_SIZE); 149 level = 1; 150 } else if ((fsf_req->fsf_command == FSF_QTCB_OPEN_PORT_WITH_DID) || 151 (fsf_req->fsf_command == FSF_QTCB_OPEN_LUN)) { 152 strncpy(rec->tag2, "open", ZFCP_DBF_TAG_SIZE); 153 level = 4; 154 } else if (qtcb->header.log_length) { 155 strncpy(rec->tag2, "qtcb", ZFCP_DBF_TAG_SIZE); 156 level = 5; 157 } else { 158 strncpy(rec->tag2, "norm", ZFCP_DBF_TAG_SIZE); 159 level = 6; 160 } 161 162 response->fsf_command = fsf_req->fsf_command; 163 response->fsf_reqid = (unsigned long)fsf_req; 164 response->fsf_seqno = fsf_req->seq_no; 165 response->fsf_issued = fsf_req->issued; 166 response->fsf_prot_status = qtcb->prefix.prot_status; 167 response->fsf_status = qtcb->header.fsf_status; 168 memcpy(response->fsf_prot_status_qual, 169 prot_status_qual, FSF_PROT_STATUS_QUAL_SIZE); 170 memcpy(response->fsf_status_qual, 171 fsf_status_qual, FSF_STATUS_QUALIFIER_SIZE); 172 response->fsf_req_status = fsf_req->status; 173 response->sbal_first = fsf_req->sbal_first; 174 response->sbal_last = fsf_req->sbal_last; 175 response->sbal_response = fsf_req->sbal_response; 176 response->pool = fsf_req->pool != NULL; 177 response->erp_action = (unsigned long)fsf_req->erp_action; 178 179 switch (fsf_req->fsf_command) { 180 case FSF_QTCB_FCP_CMND: 181 if (fsf_req->status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT) 182 break; 183 scsi_cmnd = (struct scsi_cmnd *)fsf_req->data; 184 if (scsi_cmnd) { 185 response->u.fcp.cmnd = (unsigned long)scsi_cmnd; 186 response->u.fcp.serial = scsi_cmnd->serial_number; 187 } 188 break; 189 190 case FSF_QTCB_OPEN_PORT_WITH_DID: 191 case FSF_QTCB_CLOSE_PORT: 192 case FSF_QTCB_CLOSE_PHYSICAL_PORT: 193 port = (struct zfcp_port *)fsf_req->data; 194 response->u.port.wwpn = port->wwpn; 195 response->u.port.d_id = port->d_id; 196 response->u.port.port_handle = qtcb->header.port_handle; 197 break; 198 199 case FSF_QTCB_OPEN_LUN: 200 case FSF_QTCB_CLOSE_LUN: 201 unit = (struct zfcp_unit *)fsf_req->data; 202 port = unit->port; 203 response->u.unit.wwpn = port->wwpn; 204 response->u.unit.fcp_lun = unit->fcp_lun; 205 response->u.unit.port_handle = qtcb->header.port_handle; 206 response->u.unit.lun_handle = qtcb->header.lun_handle; 207 break; 208 209 case FSF_QTCB_SEND_ELS: 210 send_els = (struct zfcp_send_els *)fsf_req->data; 211 response->u.els.d_id = qtcb->bottom.support.d_id; 212 response->u.els.ls_code = send_els->ls_code >> 24; 213 break; 214 215 case FSF_QTCB_ABORT_FCP_CMND: 216 case FSF_QTCB_SEND_GENERIC: 217 case FSF_QTCB_EXCHANGE_CONFIG_DATA: 218 case FSF_QTCB_EXCHANGE_PORT_DATA: 219 case FSF_QTCB_DOWNLOAD_CONTROL_FILE: 220 case FSF_QTCB_UPLOAD_CONTROL_FILE: 221 break; 222 } 223 224 debug_event(adapter->hba_dbf, level, rec, sizeof(*rec)); 225 226 /* have fcp channel microcode fixed to use as little as possible */ 227 if (fsf_req->fsf_command != FSF_QTCB_FCP_CMND) { 228 /* adjust length skipping trailing zeros */ 229 char *buf = (char *)qtcb + qtcb->header.log_start; 230 int len = qtcb->header.log_length; 231 for (; len && !buf[len - 1]; len--); 232 zfcp_dbf_hexdump(adapter->hba_dbf, rec, sizeof(*rec), level, 233 buf, len); 234 } 235 236 spin_unlock_irqrestore(&adapter->hba_dbf_lock, flags); 237 } 238 239 /** 240 * zfcp_hba_dbf_event_fsf_unsol - trace event for an unsolicited status buffer 241 * @tag: tag indicating which kind of unsolicited status has been received 242 * @adapter: adapter that has issued the unsolicited status buffer 243 * @status_buffer: buffer containing payload of unsolicited status 244 */ 245 void zfcp_hba_dbf_event_fsf_unsol(const char *tag, struct zfcp_adapter *adapter, 246 struct fsf_status_read_buffer *status_buffer) 247 { 248 struct zfcp_hba_dbf_record *rec = &adapter->hba_dbf_buf; 249 unsigned long flags; 250 251 spin_lock_irqsave(&adapter->hba_dbf_lock, flags); 252 memset(rec, 0, sizeof(*rec)); 253 strncpy(rec->tag, "stat", ZFCP_DBF_TAG_SIZE); 254 strncpy(rec->tag2, tag, ZFCP_DBF_TAG_SIZE); 255 256 rec->u.status.failed = atomic_read(&adapter->stat_miss); 257 if (status_buffer != NULL) { 258 rec->u.status.status_type = status_buffer->status_type; 259 rec->u.status.status_subtype = status_buffer->status_subtype; 260 memcpy(&rec->u.status.queue_designator, 261 &status_buffer->queue_designator, 262 sizeof(struct fsf_queue_designator)); 263 264 switch (status_buffer->status_type) { 265 case FSF_STATUS_READ_SENSE_DATA_AVAIL: 266 rec->u.status.payload_size = 267 ZFCP_DBF_UNSOL_PAYLOAD_SENSE_DATA_AVAIL; 268 break; 269 270 case FSF_STATUS_READ_BIT_ERROR_THRESHOLD: 271 rec->u.status.payload_size = 272 ZFCP_DBF_UNSOL_PAYLOAD_BIT_ERROR_THRESHOLD; 273 break; 274 275 case FSF_STATUS_READ_LINK_DOWN: 276 switch (status_buffer->status_subtype) { 277 case FSF_STATUS_READ_SUB_NO_PHYSICAL_LINK: 278 case FSF_STATUS_READ_SUB_FDISC_FAILED: 279 rec->u.status.payload_size = 280 sizeof(struct fsf_link_down_info); 281 } 282 break; 283 284 case FSF_STATUS_READ_FEATURE_UPDATE_ALERT: 285 rec->u.status.payload_size = 286 ZFCP_DBF_UNSOL_PAYLOAD_FEATURE_UPDATE_ALERT; 287 break; 288 } 289 memcpy(&rec->u.status.payload, 290 &status_buffer->payload, rec->u.status.payload_size); 291 } 292 293 debug_event(adapter->hba_dbf, 2, rec, sizeof(*rec)); 294 spin_unlock_irqrestore(&adapter->hba_dbf_lock, flags); 295 } 296 297 /** 298 * zfcp_hba_dbf_event_qdio - trace event for QDIO related failure 299 * @adapter: adapter affected by this QDIO related event 300 * @qdio_error: as passed by qdio module 301 * @sbal_index: first buffer with error condition, as passed by qdio module 302 * @sbal_count: number of buffers affected, as passed by qdio module 303 */ 304 void zfcp_hba_dbf_event_qdio(struct zfcp_adapter *adapter, 305 unsigned int qdio_error, int sbal_index, 306 int sbal_count) 307 { 308 struct zfcp_hba_dbf_record *r = &adapter->hba_dbf_buf; 309 unsigned long flags; 310 311 spin_lock_irqsave(&adapter->hba_dbf_lock, flags); 312 memset(r, 0, sizeof(*r)); 313 strncpy(r->tag, "qdio", ZFCP_DBF_TAG_SIZE); 314 r->u.qdio.qdio_error = qdio_error; 315 r->u.qdio.sbal_index = sbal_index; 316 r->u.qdio.sbal_count = sbal_count; 317 debug_event(adapter->hba_dbf, 0, r, sizeof(*r)); 318 spin_unlock_irqrestore(&adapter->hba_dbf_lock, flags); 319 } 320 321 static void zfcp_hba_dbf_view_response(char **p, 322 struct zfcp_hba_dbf_record_response *r) 323 { 324 struct timespec t; 325 326 zfcp_dbf_out(p, "fsf_command", "0x%08x", r->fsf_command); 327 zfcp_dbf_out(p, "fsf_reqid", "0x%0Lx", r->fsf_reqid); 328 zfcp_dbf_out(p, "fsf_seqno", "0x%08x", r->fsf_seqno); 329 zfcp_dbf_timestamp(r->fsf_issued, &t); 330 zfcp_dbf_out(p, "fsf_issued", "%011lu:%06lu", t.tv_sec, t.tv_nsec); 331 zfcp_dbf_out(p, "fsf_prot_status", "0x%08x", r->fsf_prot_status); 332 zfcp_dbf_out(p, "fsf_status", "0x%08x", r->fsf_status); 333 zfcp_dbf_outd(p, "fsf_prot_status_qual", r->fsf_prot_status_qual, 334 FSF_PROT_STATUS_QUAL_SIZE, 0, FSF_PROT_STATUS_QUAL_SIZE); 335 zfcp_dbf_outd(p, "fsf_status_qual", r->fsf_status_qual, 336 FSF_STATUS_QUALIFIER_SIZE, 0, FSF_STATUS_QUALIFIER_SIZE); 337 zfcp_dbf_out(p, "fsf_req_status", "0x%08x", r->fsf_req_status); 338 zfcp_dbf_out(p, "sbal_first", "0x%02x", r->sbal_first); 339 zfcp_dbf_out(p, "sbal_last", "0x%02x", r->sbal_last); 340 zfcp_dbf_out(p, "sbal_response", "0x%02x", r->sbal_response); 341 zfcp_dbf_out(p, "pool", "0x%02x", r->pool); 342 343 switch (r->fsf_command) { 344 case FSF_QTCB_FCP_CMND: 345 if (r->fsf_req_status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT) 346 break; 347 zfcp_dbf_out(p, "scsi_cmnd", "0x%0Lx", r->u.fcp.cmnd); 348 zfcp_dbf_out(p, "scsi_serial", "0x%016Lx", r->u.fcp.serial); 349 break; 350 351 case FSF_QTCB_OPEN_PORT_WITH_DID: 352 case FSF_QTCB_CLOSE_PORT: 353 case FSF_QTCB_CLOSE_PHYSICAL_PORT: 354 zfcp_dbf_out(p, "wwpn", "0x%016Lx", r->u.port.wwpn); 355 zfcp_dbf_out(p, "d_id", "0x%06x", r->u.port.d_id); 356 zfcp_dbf_out(p, "port_handle", "0x%08x", r->u.port.port_handle); 357 break; 358 359 case FSF_QTCB_OPEN_LUN: 360 case FSF_QTCB_CLOSE_LUN: 361 zfcp_dbf_out(p, "wwpn", "0x%016Lx", r->u.unit.wwpn); 362 zfcp_dbf_out(p, "fcp_lun", "0x%016Lx", r->u.unit.fcp_lun); 363 zfcp_dbf_out(p, "port_handle", "0x%08x", r->u.unit.port_handle); 364 zfcp_dbf_out(p, "lun_handle", "0x%08x", r->u.unit.lun_handle); 365 break; 366 367 case FSF_QTCB_SEND_ELS: 368 zfcp_dbf_out(p, "d_id", "0x%06x", r->u.els.d_id); 369 zfcp_dbf_out(p, "ls_code", "0x%02x", r->u.els.ls_code); 370 break; 371 372 case FSF_QTCB_ABORT_FCP_CMND: 373 case FSF_QTCB_SEND_GENERIC: 374 case FSF_QTCB_EXCHANGE_CONFIG_DATA: 375 case FSF_QTCB_EXCHANGE_PORT_DATA: 376 case FSF_QTCB_DOWNLOAD_CONTROL_FILE: 377 case FSF_QTCB_UPLOAD_CONTROL_FILE: 378 break; 379 } 380 } 381 382 static void zfcp_hba_dbf_view_status(char **p, 383 struct zfcp_hba_dbf_record_status *r) 384 { 385 zfcp_dbf_out(p, "failed", "0x%02x", r->failed); 386 zfcp_dbf_out(p, "status_type", "0x%08x", r->status_type); 387 zfcp_dbf_out(p, "status_subtype", "0x%08x", r->status_subtype); 388 zfcp_dbf_outd(p, "queue_designator", (char *)&r->queue_designator, 389 sizeof(struct fsf_queue_designator), 0, 390 sizeof(struct fsf_queue_designator)); 391 zfcp_dbf_outd(p, "payload", (char *)&r->payload, r->payload_size, 0, 392 r->payload_size); 393 } 394 395 static void zfcp_hba_dbf_view_qdio(char **p, struct zfcp_hba_dbf_record_qdio *r) 396 { 397 zfcp_dbf_out(p, "qdio_error", "0x%08x", r->qdio_error); 398 zfcp_dbf_out(p, "sbal_index", "0x%02x", r->sbal_index); 399 zfcp_dbf_out(p, "sbal_count", "0x%02x", r->sbal_count); 400 } 401 402 static int zfcp_hba_dbf_view_format(debug_info_t *id, struct debug_view *view, 403 char *out_buf, const char *in_buf) 404 { 405 struct zfcp_hba_dbf_record *r = (struct zfcp_hba_dbf_record *)in_buf; 406 char *p = out_buf; 407 408 if (strncmp(r->tag, "dump", ZFCP_DBF_TAG_SIZE) == 0) 409 return 0; 410 411 zfcp_dbf_tag(&p, "tag", r->tag); 412 if (isalpha(r->tag2[0])) 413 zfcp_dbf_tag(&p, "tag2", r->tag2); 414 415 if (strncmp(r->tag, "resp", ZFCP_DBF_TAG_SIZE) == 0) 416 zfcp_hba_dbf_view_response(&p, &r->u.response); 417 else if (strncmp(r->tag, "stat", ZFCP_DBF_TAG_SIZE) == 0) 418 zfcp_hba_dbf_view_status(&p, &r->u.status); 419 else if (strncmp(r->tag, "qdio", ZFCP_DBF_TAG_SIZE) == 0) 420 zfcp_hba_dbf_view_qdio(&p, &r->u.qdio); 421 422 p += sprintf(p, "\n"); 423 return p - out_buf; 424 } 425 426 static struct debug_view zfcp_hba_dbf_view = { 427 "structured", 428 NULL, 429 &zfcp_dbf_view_header, 430 &zfcp_hba_dbf_view_format, 431 NULL, 432 NULL 433 }; 434 435 static const char *zfcp_rec_dbf_tags[] = { 436 [ZFCP_REC_DBF_ID_THREAD] = "thread", 437 [ZFCP_REC_DBF_ID_TARGET] = "target", 438 [ZFCP_REC_DBF_ID_TRIGGER] = "trigger", 439 [ZFCP_REC_DBF_ID_ACTION] = "action", 440 }; 441 442 static const char *zfcp_rec_dbf_ids[] = { 443 [1] = "new", 444 [2] = "ready", 445 [3] = "kill", 446 [4] = "down sleep", 447 [5] = "down wakeup", 448 [6] = "down sleep ecd", 449 [7] = "down wakeup ecd", 450 [8] = "down sleep epd", 451 [9] = "down wakeup epd", 452 [10] = "online", 453 [11] = "operational", 454 [12] = "scsi slave destroy", 455 [13] = "propagate failed adapter", 456 [14] = "propagate failed port", 457 [15] = "block adapter", 458 [16] = "unblock adapter", 459 [17] = "block port", 460 [18] = "unblock port", 461 [19] = "block unit", 462 [20] = "unblock unit", 463 [21] = "unit recovery failed", 464 [22] = "port recovery failed", 465 [23] = "adapter recovery failed", 466 [24] = "qdio queues down", 467 [25] = "p2p failed", 468 [26] = "nameserver lookup failed", 469 [27] = "nameserver port failed", 470 [28] = "link up", 471 [29] = "link down", 472 [30] = "link up status read", 473 [31] = "open port failed", 474 [32] = "open port failed", 475 [33] = "close port", 476 [34] = "open unit failed", 477 [35] = "exclusive open unit failed", 478 [36] = "shared open unit failed", 479 [37] = "link down", 480 [38] = "link down status read no link", 481 [39] = "link down status read fdisc login", 482 [40] = "link down status read firmware update", 483 [41] = "link down status read unknown reason", 484 [42] = "link down ecd incomplete", 485 [43] = "link down epd incomplete", 486 [44] = "sysfs adapter recovery", 487 [45] = "sysfs port recovery", 488 [46] = "sysfs unit recovery", 489 [47] = "port boxed abort", 490 [48] = "unit boxed abort", 491 [49] = "port boxed ct", 492 [50] = "port boxed close physical", 493 [51] = "port boxed open unit", 494 [52] = "port boxed close unit", 495 [53] = "port boxed fcp", 496 [54] = "unit boxed fcp", 497 [55] = "port access denied", 498 [56] = "", 499 [57] = "", 500 [58] = "", 501 [59] = "unit access denied", 502 [60] = "shared unit access denied open unit", 503 [61] = "", 504 [62] = "request timeout", 505 [63] = "adisc link test reject or timeout", 506 [64] = "adisc link test d_id changed", 507 [65] = "adisc link test failed", 508 [66] = "recovery out of memory", 509 [67] = "adapter recovery repeated after state change", 510 [68] = "port recovery repeated after state change", 511 [69] = "unit recovery repeated after state change", 512 [70] = "port recovery follow-up after successful adapter recovery", 513 [71] = "adapter recovery escalation after failed adapter recovery", 514 [72] = "port recovery follow-up after successful physical port " 515 "recovery", 516 [73] = "adapter recovery escalation after failed physical port " 517 "recovery", 518 [74] = "unit recovery follow-up after successful port recovery", 519 [75] = "physical port recovery escalation after failed port " 520 "recovery", 521 [76] = "port recovery escalation after failed unit recovery", 522 [77] = "recovery opening nameserver port", 523 [78] = "duplicate request id", 524 [79] = "link down", 525 [80] = "exclusive read-only unit access unsupported", 526 [81] = "shared read-write unit access unsupported", 527 [82] = "incoming rscn", 528 [83] = "incoming wwpn", 529 [84] = "", 530 [85] = "online", 531 [86] = "offline", 532 [87] = "ccw device gone", 533 [88] = "ccw device no path", 534 [89] = "ccw device operational", 535 [90] = "ccw device shutdown", 536 [91] = "sysfs port addition", 537 [92] = "sysfs port removal", 538 [93] = "sysfs adapter recovery", 539 [94] = "sysfs unit addition", 540 [95] = "sysfs unit removal", 541 [96] = "sysfs port recovery", 542 [97] = "sysfs unit recovery", 543 [98] = "sequence number mismatch", 544 [99] = "link up", 545 [100] = "error state", 546 [101] = "status read physical port closed", 547 [102] = "link up status read", 548 [103] = "too many failed status read buffers", 549 [104] = "port handle not valid abort", 550 [105] = "lun handle not valid abort", 551 [106] = "port handle not valid ct", 552 [107] = "port handle not valid close port", 553 [108] = "port handle not valid close physical port", 554 [109] = "port handle not valid open unit", 555 [110] = "port handle not valid close unit", 556 [111] = "lun handle not valid close unit", 557 [112] = "port handle not valid fcp", 558 [113] = "lun handle not valid fcp", 559 [114] = "handle mismatch fcp", 560 [115] = "lun not valid fcp", 561 [116] = "qdio send failed", 562 [117] = "version mismatch", 563 [118] = "incompatible qtcb type", 564 [119] = "unknown protocol status", 565 [120] = "unknown fsf command", 566 [121] = "no recommendation for status qualifier", 567 [122] = "status read physical port closed in error", 568 [123] = "fc service class not supported", 569 [124] = "", 570 [125] = "need newer zfcp", 571 [126] = "need newer microcode", 572 [127] = "arbitrated loop not supported", 573 [128] = "unknown topology", 574 [129] = "qtcb size mismatch", 575 [130] = "unknown fsf status ecd", 576 [131] = "fcp request too big", 577 [132] = "", 578 [133] = "data direction not valid fcp", 579 [134] = "command length not valid fcp", 580 [135] = "status read act update", 581 [136] = "status read cfdc update", 582 [137] = "hbaapi port open", 583 [138] = "hbaapi unit open", 584 [139] = "hbaapi unit shutdown", 585 [140] = "qdio error outbound", 586 [141] = "scsi host reset", 587 [142] = "dismissing fsf request for recovery action", 588 [143] = "recovery action timed out", 589 [144] = "recovery action gone", 590 [145] = "recovery action being processed", 591 [146] = "recovery action ready for next step", 592 [147] = "qdio error inbound", 593 [148] = "nameserver needed for port scan", 594 [149] = "port scan", 595 [150] = "ptp attach", 596 [151] = "port validation failed", 597 }; 598 599 static int zfcp_rec_dbf_view_format(debug_info_t *id, struct debug_view *view, 600 char *buf, const char *_rec) 601 { 602 struct zfcp_rec_dbf_record *r = (struct zfcp_rec_dbf_record *)_rec; 603 char *p = buf; 604 605 zfcp_dbf_outs(&p, "tag", zfcp_rec_dbf_tags[r->id]); 606 zfcp_dbf_outs(&p, "hint", zfcp_rec_dbf_ids[r->id2]); 607 zfcp_dbf_out(&p, "id", "%d", r->id2); 608 switch (r->id) { 609 case ZFCP_REC_DBF_ID_THREAD: 610 zfcp_dbf_out(&p, "total", "%d", r->u.thread.total); 611 zfcp_dbf_out(&p, "ready", "%d", r->u.thread.ready); 612 zfcp_dbf_out(&p, "running", "%d", r->u.thread.running); 613 break; 614 case ZFCP_REC_DBF_ID_TARGET: 615 zfcp_dbf_out(&p, "reference", "0x%016Lx", r->u.target.ref); 616 zfcp_dbf_out(&p, "status", "0x%08x", r->u.target.status); 617 zfcp_dbf_out(&p, "erp_count", "%d", r->u.target.erp_count); 618 zfcp_dbf_out(&p, "d_id", "0x%06x", r->u.target.d_id); 619 zfcp_dbf_out(&p, "wwpn", "0x%016Lx", r->u.target.wwpn); 620 zfcp_dbf_out(&p, "fcp_lun", "0x%016Lx", r->u.target.fcp_lun); 621 break; 622 case ZFCP_REC_DBF_ID_TRIGGER: 623 zfcp_dbf_out(&p, "reference", "0x%016Lx", r->u.trigger.ref); 624 zfcp_dbf_out(&p, "erp_action", "0x%016Lx", r->u.trigger.action); 625 zfcp_dbf_out(&p, "requested", "%d", r->u.trigger.want); 626 zfcp_dbf_out(&p, "executed", "%d", r->u.trigger.need); 627 zfcp_dbf_out(&p, "wwpn", "0x%016Lx", r->u.trigger.wwpn); 628 zfcp_dbf_out(&p, "fcp_lun", "0x%016Lx", r->u.trigger.fcp_lun); 629 zfcp_dbf_out(&p, "adapter_status", "0x%08x", r->u.trigger.as); 630 zfcp_dbf_out(&p, "port_status", "0x%08x", r->u.trigger.ps); 631 zfcp_dbf_out(&p, "unit_status", "0x%08x", r->u.trigger.us); 632 break; 633 case ZFCP_REC_DBF_ID_ACTION: 634 zfcp_dbf_out(&p, "erp_action", "0x%016Lx", r->u.action.action); 635 zfcp_dbf_out(&p, "fsf_req", "0x%016Lx", r->u.action.fsf_req); 636 zfcp_dbf_out(&p, "status", "0x%08Lx", r->u.action.status); 637 zfcp_dbf_out(&p, "step", "0x%08Lx", r->u.action.step); 638 break; 639 } 640 p += sprintf(p, "\n"); 641 return p - buf; 642 } 643 644 static struct debug_view zfcp_rec_dbf_view = { 645 "structured", 646 NULL, 647 &zfcp_dbf_view_header, 648 &zfcp_rec_dbf_view_format, 649 NULL, 650 NULL 651 }; 652 653 /** 654 * zfcp_rec_dbf_event_thread - trace event related to recovery thread operation 655 * @id2: identifier for event 656 * @adapter: adapter 657 * This function assumes that the caller is holding erp_lock. 658 */ 659 void zfcp_rec_dbf_event_thread(u8 id2, struct zfcp_adapter *adapter) 660 { 661 struct zfcp_rec_dbf_record *r = &adapter->rec_dbf_buf; 662 unsigned long flags = 0; 663 struct list_head *entry; 664 unsigned ready = 0, running = 0, total; 665 666 list_for_each(entry, &adapter->erp_ready_head) 667 ready++; 668 list_for_each(entry, &adapter->erp_running_head) 669 running++; 670 total = adapter->erp_total_count; 671 672 spin_lock_irqsave(&adapter->rec_dbf_lock, flags); 673 memset(r, 0, sizeof(*r)); 674 r->id = ZFCP_REC_DBF_ID_THREAD; 675 r->id2 = id2; 676 r->u.thread.total = total; 677 r->u.thread.ready = ready; 678 r->u.thread.running = running; 679 debug_event(adapter->rec_dbf, 6, r, sizeof(*r)); 680 spin_unlock_irqrestore(&adapter->rec_dbf_lock, flags); 681 } 682 683 /** 684 * zfcp_rec_dbf_event_thread - trace event related to recovery thread operation 685 * @id2: identifier for event 686 * @adapter: adapter 687 * This function assumes that the caller does not hold erp_lock. 688 */ 689 void zfcp_rec_dbf_event_thread_lock(u8 id2, struct zfcp_adapter *adapter) 690 { 691 unsigned long flags; 692 693 read_lock_irqsave(&adapter->erp_lock, flags); 694 zfcp_rec_dbf_event_thread(id2, adapter); 695 read_unlock_irqrestore(&adapter->erp_lock, flags); 696 } 697 698 static void zfcp_rec_dbf_event_target(u8 id2, void *ref, 699 struct zfcp_adapter *adapter, 700 atomic_t *status, atomic_t *erp_count, 701 u64 wwpn, u32 d_id, u64 fcp_lun) 702 { 703 struct zfcp_rec_dbf_record *r = &adapter->rec_dbf_buf; 704 unsigned long flags; 705 706 spin_lock_irqsave(&adapter->rec_dbf_lock, flags); 707 memset(r, 0, sizeof(*r)); 708 r->id = ZFCP_REC_DBF_ID_TARGET; 709 r->id2 = id2; 710 r->u.target.ref = (unsigned long)ref; 711 r->u.target.status = atomic_read(status); 712 r->u.target.wwpn = wwpn; 713 r->u.target.d_id = d_id; 714 r->u.target.fcp_lun = fcp_lun; 715 r->u.target.erp_count = atomic_read(erp_count); 716 debug_event(adapter->rec_dbf, 3, r, sizeof(*r)); 717 spin_unlock_irqrestore(&adapter->rec_dbf_lock, flags); 718 } 719 720 /** 721 * zfcp_rec_dbf_event_adapter - trace event for adapter state change 722 * @id: identifier for trigger of state change 723 * @ref: additional reference (e.g. request) 724 * @adapter: adapter 725 */ 726 void zfcp_rec_dbf_event_adapter(u8 id, void *ref, struct zfcp_adapter *adapter) 727 { 728 zfcp_rec_dbf_event_target(id, ref, adapter, &adapter->status, 729 &adapter->erp_counter, 0, 0, 0); 730 } 731 732 /** 733 * zfcp_rec_dbf_event_port - trace event for port state change 734 * @id: identifier for trigger of state change 735 * @ref: additional reference (e.g. request) 736 * @port: port 737 */ 738 void zfcp_rec_dbf_event_port(u8 id, void *ref, struct zfcp_port *port) 739 { 740 struct zfcp_adapter *adapter = port->adapter; 741 742 zfcp_rec_dbf_event_target(id, ref, adapter, &port->status, 743 &port->erp_counter, port->wwpn, port->d_id, 744 0); 745 } 746 747 /** 748 * zfcp_rec_dbf_event_unit - trace event for unit state change 749 * @id: identifier for trigger of state change 750 * @ref: additional reference (e.g. request) 751 * @unit: unit 752 */ 753 void zfcp_rec_dbf_event_unit(u8 id, void *ref, struct zfcp_unit *unit) 754 { 755 struct zfcp_port *port = unit->port; 756 struct zfcp_adapter *adapter = port->adapter; 757 758 zfcp_rec_dbf_event_target(id, ref, adapter, &unit->status, 759 &unit->erp_counter, port->wwpn, port->d_id, 760 unit->fcp_lun); 761 } 762 763 /** 764 * zfcp_rec_dbf_event_trigger - trace event for triggered error recovery 765 * @id2: identifier for error recovery trigger 766 * @ref: additional reference (e.g. request) 767 * @want: originally requested error recovery action 768 * @need: error recovery action actually initiated 769 * @action: address of error recovery action struct 770 * @adapter: adapter 771 * @port: port 772 * @unit: unit 773 */ 774 void zfcp_rec_dbf_event_trigger(u8 id2, void *ref, u8 want, u8 need, 775 void *action, struct zfcp_adapter *adapter, 776 struct zfcp_port *port, struct zfcp_unit *unit) 777 { 778 struct zfcp_rec_dbf_record *r = &adapter->rec_dbf_buf; 779 unsigned long flags; 780 781 spin_lock_irqsave(&adapter->rec_dbf_lock, flags); 782 memset(r, 0, sizeof(*r)); 783 r->id = ZFCP_REC_DBF_ID_TRIGGER; 784 r->id2 = id2; 785 r->u.trigger.ref = (unsigned long)ref; 786 r->u.trigger.want = want; 787 r->u.trigger.need = need; 788 r->u.trigger.action = (unsigned long)action; 789 r->u.trigger.as = atomic_read(&adapter->status); 790 if (port) { 791 r->u.trigger.ps = atomic_read(&port->status); 792 r->u.trigger.wwpn = port->wwpn; 793 } 794 if (unit) { 795 r->u.trigger.us = atomic_read(&unit->status); 796 r->u.trigger.fcp_lun = unit->fcp_lun; 797 } 798 debug_event(adapter->rec_dbf, action ? 1 : 4, r, sizeof(*r)); 799 spin_unlock_irqrestore(&adapter->rec_dbf_lock, flags); 800 } 801 802 /** 803 * zfcp_rec_dbf_event_action - trace event showing progress of recovery action 804 * @id2: identifier 805 * @erp_action: error recovery action struct pointer 806 */ 807 void zfcp_rec_dbf_event_action(u8 id2, struct zfcp_erp_action *erp_action) 808 { 809 struct zfcp_adapter *adapter = erp_action->adapter; 810 struct zfcp_rec_dbf_record *r = &adapter->rec_dbf_buf; 811 unsigned long flags; 812 813 spin_lock_irqsave(&adapter->rec_dbf_lock, flags); 814 memset(r, 0, sizeof(*r)); 815 r->id = ZFCP_REC_DBF_ID_ACTION; 816 r->id2 = id2; 817 r->u.action.action = (unsigned long)erp_action; 818 r->u.action.status = erp_action->status; 819 r->u.action.step = erp_action->step; 820 r->u.action.fsf_req = (unsigned long)erp_action->fsf_req; 821 debug_event(adapter->rec_dbf, 5, r, sizeof(*r)); 822 spin_unlock_irqrestore(&adapter->rec_dbf_lock, flags); 823 } 824 825 /** 826 * zfcp_san_dbf_event_ct_request - trace event for issued CT request 827 * @fsf_req: request containing issued CT data 828 */ 829 void zfcp_san_dbf_event_ct_request(struct zfcp_fsf_req *fsf_req) 830 { 831 struct zfcp_send_ct *ct = (struct zfcp_send_ct *)fsf_req->data; 832 struct zfcp_port *port = ct->port; 833 struct zfcp_adapter *adapter = port->adapter; 834 struct ct_hdr *hdr = zfcp_sg_to_address(ct->req); 835 struct zfcp_san_dbf_record *r = &adapter->san_dbf_buf; 836 struct zfcp_san_dbf_record_ct_request *oct = &r->u.ct_req; 837 unsigned long flags; 838 839 spin_lock_irqsave(&adapter->san_dbf_lock, flags); 840 memset(r, 0, sizeof(*r)); 841 strncpy(r->tag, "octc", ZFCP_DBF_TAG_SIZE); 842 r->fsf_reqid = (unsigned long)fsf_req; 843 r->fsf_seqno = fsf_req->seq_no; 844 r->s_id = fc_host_port_id(adapter->scsi_host); 845 r->d_id = port->d_id; 846 oct->cmd_req_code = hdr->cmd_rsp_code; 847 oct->revision = hdr->revision; 848 oct->gs_type = hdr->gs_type; 849 oct->gs_subtype = hdr->gs_subtype; 850 oct->options = hdr->options; 851 oct->max_res_size = hdr->max_res_size; 852 oct->len = min((int)ct->req->length - (int)sizeof(struct ct_hdr), 853 ZFCP_DBF_CT_PAYLOAD); 854 memcpy(oct->payload, (void *)hdr + sizeof(struct ct_hdr), oct->len); 855 debug_event(adapter->san_dbf, 3, r, sizeof(*r)); 856 spin_unlock_irqrestore(&adapter->san_dbf_lock, flags); 857 } 858 859 /** 860 * zfcp_san_dbf_event_ct_response - trace event for completion of CT request 861 * @fsf_req: request containing CT response 862 */ 863 void zfcp_san_dbf_event_ct_response(struct zfcp_fsf_req *fsf_req) 864 { 865 struct zfcp_send_ct *ct = (struct zfcp_send_ct *)fsf_req->data; 866 struct zfcp_port *port = ct->port; 867 struct zfcp_adapter *adapter = port->adapter; 868 struct ct_hdr *hdr = zfcp_sg_to_address(ct->resp); 869 struct zfcp_san_dbf_record *r = &adapter->san_dbf_buf; 870 struct zfcp_san_dbf_record_ct_response *rct = &r->u.ct_resp; 871 unsigned long flags; 872 873 spin_lock_irqsave(&adapter->san_dbf_lock, flags); 874 memset(r, 0, sizeof(*r)); 875 strncpy(r->tag, "rctc", ZFCP_DBF_TAG_SIZE); 876 r->fsf_reqid = (unsigned long)fsf_req; 877 r->fsf_seqno = fsf_req->seq_no; 878 r->s_id = port->d_id; 879 r->d_id = fc_host_port_id(adapter->scsi_host); 880 rct->cmd_rsp_code = hdr->cmd_rsp_code; 881 rct->revision = hdr->revision; 882 rct->reason_code = hdr->reason_code; 883 rct->expl = hdr->reason_code_expl; 884 rct->vendor_unique = hdr->vendor_unique; 885 rct->len = min((int)ct->resp->length - (int)sizeof(struct ct_hdr), 886 ZFCP_DBF_CT_PAYLOAD); 887 memcpy(rct->payload, (void *)hdr + sizeof(struct ct_hdr), rct->len); 888 debug_event(adapter->san_dbf, 3, r, sizeof(*r)); 889 spin_unlock_irqrestore(&adapter->san_dbf_lock, flags); 890 } 891 892 static void zfcp_san_dbf_event_els(const char *tag, int level, 893 struct zfcp_fsf_req *fsf_req, u32 s_id, 894 u32 d_id, u8 ls_code, void *buffer, 895 int buflen) 896 { 897 struct zfcp_adapter *adapter = fsf_req->adapter; 898 struct zfcp_san_dbf_record *rec = &adapter->san_dbf_buf; 899 unsigned long flags; 900 901 spin_lock_irqsave(&adapter->san_dbf_lock, flags); 902 memset(rec, 0, sizeof(*rec)); 903 strncpy(rec->tag, tag, ZFCP_DBF_TAG_SIZE); 904 rec->fsf_reqid = (unsigned long)fsf_req; 905 rec->fsf_seqno = fsf_req->seq_no; 906 rec->s_id = s_id; 907 rec->d_id = d_id; 908 rec->u.els.ls_code = ls_code; 909 debug_event(adapter->san_dbf, level, rec, sizeof(*rec)); 910 zfcp_dbf_hexdump(adapter->san_dbf, rec, sizeof(*rec), level, 911 buffer, min(buflen, ZFCP_DBF_ELS_MAX_PAYLOAD)); 912 spin_unlock_irqrestore(&adapter->san_dbf_lock, flags); 913 } 914 915 /** 916 * zfcp_san_dbf_event_els_request - trace event for issued ELS 917 * @fsf_req: request containing issued ELS 918 */ 919 void zfcp_san_dbf_event_els_request(struct zfcp_fsf_req *fsf_req) 920 { 921 struct zfcp_send_els *els = (struct zfcp_send_els *)fsf_req->data; 922 923 zfcp_san_dbf_event_els("oels", 2, fsf_req, 924 fc_host_port_id(els->adapter->scsi_host), 925 els->d_id, *(u8 *) zfcp_sg_to_address(els->req), 926 zfcp_sg_to_address(els->req), els->req->length); 927 } 928 929 /** 930 * zfcp_san_dbf_event_els_response - trace event for completed ELS 931 * @fsf_req: request containing ELS response 932 */ 933 void zfcp_san_dbf_event_els_response(struct zfcp_fsf_req *fsf_req) 934 { 935 struct zfcp_send_els *els = (struct zfcp_send_els *)fsf_req->data; 936 937 zfcp_san_dbf_event_els("rels", 2, fsf_req, els->d_id, 938 fc_host_port_id(els->adapter->scsi_host), 939 *(u8 *)zfcp_sg_to_address(els->req), 940 zfcp_sg_to_address(els->resp), 941 els->resp->length); 942 } 943 944 /** 945 * zfcp_san_dbf_event_incoming_els - trace event for incomig ELS 946 * @fsf_req: request containing unsolicited status buffer with incoming ELS 947 */ 948 void zfcp_san_dbf_event_incoming_els(struct zfcp_fsf_req *fsf_req) 949 { 950 struct zfcp_adapter *adapter = fsf_req->adapter; 951 struct fsf_status_read_buffer *buf = 952 (struct fsf_status_read_buffer *)fsf_req->data; 953 int length = (int)buf->length - 954 (int)((void *)&buf->payload - (void *)buf); 955 956 zfcp_san_dbf_event_els("iels", 1, fsf_req, buf->d_id, 957 fc_host_port_id(adapter->scsi_host), 958 buf->payload.data[0], (void *)buf->payload.data, 959 length); 960 } 961 962 static int zfcp_san_dbf_view_format(debug_info_t *id, struct debug_view *view, 963 char *out_buf, const char *in_buf) 964 { 965 struct zfcp_san_dbf_record *r = (struct zfcp_san_dbf_record *)in_buf; 966 char *buffer = NULL; 967 int buflen = 0, total = 0; 968 char *p = out_buf; 969 970 if (strncmp(r->tag, "dump", ZFCP_DBF_TAG_SIZE) == 0) 971 return 0; 972 973 zfcp_dbf_tag(&p, "tag", r->tag); 974 zfcp_dbf_out(&p, "fsf_reqid", "0x%0Lx", r->fsf_reqid); 975 zfcp_dbf_out(&p, "fsf_seqno", "0x%08x", r->fsf_seqno); 976 zfcp_dbf_out(&p, "s_id", "0x%06x", r->s_id); 977 zfcp_dbf_out(&p, "d_id", "0x%06x", r->d_id); 978 979 if (strncmp(r->tag, "octc", ZFCP_DBF_TAG_SIZE) == 0) { 980 struct zfcp_san_dbf_record_ct_request *ct = &r->u.ct_req; 981 zfcp_dbf_out(&p, "cmd_req_code", "0x%04x", ct->cmd_req_code); 982 zfcp_dbf_out(&p, "revision", "0x%02x", ct->revision); 983 zfcp_dbf_out(&p, "gs_type", "0x%02x", ct->gs_type); 984 zfcp_dbf_out(&p, "gs_subtype", "0x%02x", ct->gs_subtype); 985 zfcp_dbf_out(&p, "options", "0x%02x", ct->options); 986 zfcp_dbf_out(&p, "max_res_size", "0x%04x", ct->max_res_size); 987 total = ct->len; 988 buffer = ct->payload; 989 buflen = min(total, ZFCP_DBF_CT_PAYLOAD); 990 } else if (strncmp(r->tag, "rctc", ZFCP_DBF_TAG_SIZE) == 0) { 991 struct zfcp_san_dbf_record_ct_response *ct = &r->u.ct_resp; 992 zfcp_dbf_out(&p, "cmd_rsp_code", "0x%04x", ct->cmd_rsp_code); 993 zfcp_dbf_out(&p, "revision", "0x%02x", ct->revision); 994 zfcp_dbf_out(&p, "reason_code", "0x%02x", ct->reason_code); 995 zfcp_dbf_out(&p, "reason_code_expl", "0x%02x", ct->expl); 996 zfcp_dbf_out(&p, "vendor_unique", "0x%02x", ct->vendor_unique); 997 total = ct->len; 998 buffer = ct->payload; 999 buflen = min(total, ZFCP_DBF_CT_PAYLOAD); 1000 } else if (strncmp(r->tag, "oels", ZFCP_DBF_TAG_SIZE) == 0 || 1001 strncmp(r->tag, "rels", ZFCP_DBF_TAG_SIZE) == 0 || 1002 strncmp(r->tag, "iels", ZFCP_DBF_TAG_SIZE) == 0) { 1003 struct zfcp_san_dbf_record_els *els = &r->u.els; 1004 zfcp_dbf_out(&p, "ls_code", "0x%02x", els->ls_code); 1005 total = els->len; 1006 buffer = els->payload; 1007 buflen = min(total, ZFCP_DBF_ELS_PAYLOAD); 1008 } 1009 1010 zfcp_dbf_outd(&p, "payload", buffer, buflen, 0, total); 1011 if (buflen == total) 1012 p += sprintf(p, "\n"); 1013 1014 return p - out_buf; 1015 } 1016 1017 static struct debug_view zfcp_san_dbf_view = { 1018 "structured", 1019 NULL, 1020 &zfcp_dbf_view_header, 1021 &zfcp_san_dbf_view_format, 1022 NULL, 1023 NULL 1024 }; 1025 1026 static void zfcp_scsi_dbf_event(const char *tag, const char *tag2, int level, 1027 struct zfcp_adapter *adapter, 1028 struct scsi_cmnd *scsi_cmnd, 1029 struct zfcp_fsf_req *fsf_req, 1030 unsigned long old_req_id) 1031 { 1032 struct zfcp_scsi_dbf_record *rec = &adapter->scsi_dbf_buf; 1033 struct zfcp_dbf_dump *dump = (struct zfcp_dbf_dump *)rec; 1034 unsigned long flags; 1035 struct fcp_rsp_iu *fcp_rsp; 1036 char *fcp_rsp_info = NULL, *fcp_sns_info = NULL; 1037 int offset = 0, buflen = 0; 1038 1039 spin_lock_irqsave(&adapter->scsi_dbf_lock, flags); 1040 do { 1041 memset(rec, 0, sizeof(*rec)); 1042 if (offset == 0) { 1043 strncpy(rec->tag, tag, ZFCP_DBF_TAG_SIZE); 1044 strncpy(rec->tag2, tag2, ZFCP_DBF_TAG_SIZE); 1045 if (scsi_cmnd != NULL) { 1046 if (scsi_cmnd->device) { 1047 rec->scsi_id = scsi_cmnd->device->id; 1048 rec->scsi_lun = scsi_cmnd->device->lun; 1049 } 1050 rec->scsi_result = scsi_cmnd->result; 1051 rec->scsi_cmnd = (unsigned long)scsi_cmnd; 1052 rec->scsi_serial = scsi_cmnd->serial_number; 1053 memcpy(rec->scsi_opcode, scsi_cmnd->cmnd, 1054 min((int)scsi_cmnd->cmd_len, 1055 ZFCP_DBF_SCSI_OPCODE)); 1056 rec->scsi_retries = scsi_cmnd->retries; 1057 rec->scsi_allowed = scsi_cmnd->allowed; 1058 } 1059 if (fsf_req != NULL) { 1060 fcp_rsp = (struct fcp_rsp_iu *) 1061 &(fsf_req->qtcb->bottom.io.fcp_rsp); 1062 fcp_rsp_info = (unsigned char *) &fcp_rsp[1]; 1063 fcp_sns_info = 1064 zfcp_get_fcp_sns_info_ptr(fcp_rsp); 1065 1066 rec->rsp_validity = fcp_rsp->validity.value; 1067 rec->rsp_scsi_status = fcp_rsp->scsi_status; 1068 rec->rsp_resid = fcp_rsp->fcp_resid; 1069 if (fcp_rsp->validity.bits.fcp_rsp_len_valid) 1070 rec->rsp_code = *(fcp_rsp_info + 3); 1071 if (fcp_rsp->validity.bits.fcp_sns_len_valid) { 1072 buflen = min((int)fcp_rsp->fcp_sns_len, 1073 ZFCP_DBF_SCSI_MAX_FCP_SNS_INFO); 1074 rec->sns_info_len = buflen; 1075 memcpy(rec->sns_info, fcp_sns_info, 1076 min(buflen, 1077 ZFCP_DBF_SCSI_FCP_SNS_INFO)); 1078 offset += min(buflen, 1079 ZFCP_DBF_SCSI_FCP_SNS_INFO); 1080 } 1081 1082 rec->fsf_reqid = (unsigned long)fsf_req; 1083 rec->fsf_seqno = fsf_req->seq_no; 1084 rec->fsf_issued = fsf_req->issued; 1085 } 1086 rec->old_fsf_reqid = old_req_id; 1087 } else { 1088 strncpy(dump->tag, "dump", ZFCP_DBF_TAG_SIZE); 1089 dump->total_size = buflen; 1090 dump->offset = offset; 1091 dump->size = min(buflen - offset, 1092 (int)sizeof(struct 1093 zfcp_scsi_dbf_record) - 1094 (int)sizeof(struct zfcp_dbf_dump)); 1095 memcpy(dump->data, fcp_sns_info + offset, dump->size); 1096 offset += dump->size; 1097 } 1098 debug_event(adapter->scsi_dbf, level, rec, sizeof(*rec)); 1099 } while (offset < buflen); 1100 spin_unlock_irqrestore(&adapter->scsi_dbf_lock, flags); 1101 } 1102 1103 /** 1104 * zfcp_scsi_dbf_event_result - trace event for SCSI command completion 1105 * @tag: tag indicating success or failure of SCSI command 1106 * @level: trace level applicable for this event 1107 * @adapter: adapter that has been used to issue the SCSI command 1108 * @scsi_cmnd: SCSI command pointer 1109 * @fsf_req: request used to issue SCSI command (might be NULL) 1110 */ 1111 void zfcp_scsi_dbf_event_result(const char *tag, int level, 1112 struct zfcp_adapter *adapter, 1113 struct scsi_cmnd *scsi_cmnd, 1114 struct zfcp_fsf_req *fsf_req) 1115 { 1116 zfcp_scsi_dbf_event("rslt", tag, level, adapter, scsi_cmnd, fsf_req, 0); 1117 } 1118 1119 /** 1120 * zfcp_scsi_dbf_event_abort - trace event for SCSI command abort 1121 * @tag: tag indicating success or failure of abort operation 1122 * @adapter: adapter thas has been used to issue SCSI command to be aborted 1123 * @scsi_cmnd: SCSI command to be aborted 1124 * @new_fsf_req: request containing abort (might be NULL) 1125 * @old_req_id: identifier of request containg SCSI command to be aborted 1126 */ 1127 void zfcp_scsi_dbf_event_abort(const char *tag, struct zfcp_adapter *adapter, 1128 struct scsi_cmnd *scsi_cmnd, 1129 struct zfcp_fsf_req *new_fsf_req, 1130 unsigned long old_req_id) 1131 { 1132 zfcp_scsi_dbf_event("abrt", tag, 1, adapter, scsi_cmnd, new_fsf_req, 1133 old_req_id); 1134 } 1135 1136 /** 1137 * zfcp_scsi_dbf_event_devreset - trace event for Logical Unit or Target Reset 1138 * @tag: tag indicating success or failure of reset operation 1139 * @flag: indicates type of reset (Target Reset, Logical Unit Reset) 1140 * @unit: unit that needs reset 1141 * @scsi_cmnd: SCSI command which caused this error recovery 1142 */ 1143 void zfcp_scsi_dbf_event_devreset(const char *tag, u8 flag, 1144 struct zfcp_unit *unit, 1145 struct scsi_cmnd *scsi_cmnd) 1146 { 1147 zfcp_scsi_dbf_event(flag == FCP_TARGET_RESET ? "trst" : "lrst", tag, 1, 1148 unit->port->adapter, scsi_cmnd, NULL, 0); 1149 } 1150 1151 static int zfcp_scsi_dbf_view_format(debug_info_t *id, struct debug_view *view, 1152 char *out_buf, const char *in_buf) 1153 { 1154 struct zfcp_scsi_dbf_record *r = (struct zfcp_scsi_dbf_record *)in_buf; 1155 struct timespec t; 1156 char *p = out_buf; 1157 1158 if (strncmp(r->tag, "dump", ZFCP_DBF_TAG_SIZE) == 0) 1159 return 0; 1160 1161 zfcp_dbf_tag(&p, "tag", r->tag); 1162 zfcp_dbf_tag(&p, "tag2", r->tag2); 1163 zfcp_dbf_out(&p, "scsi_id", "0x%08x", r->scsi_id); 1164 zfcp_dbf_out(&p, "scsi_lun", "0x%08x", r->scsi_lun); 1165 zfcp_dbf_out(&p, "scsi_result", "0x%08x", r->scsi_result); 1166 zfcp_dbf_out(&p, "scsi_cmnd", "0x%0Lx", r->scsi_cmnd); 1167 zfcp_dbf_out(&p, "scsi_serial", "0x%016Lx", r->scsi_serial); 1168 zfcp_dbf_outd(&p, "scsi_opcode", r->scsi_opcode, ZFCP_DBF_SCSI_OPCODE, 1169 0, ZFCP_DBF_SCSI_OPCODE); 1170 zfcp_dbf_out(&p, "scsi_retries", "0x%02x", r->scsi_retries); 1171 zfcp_dbf_out(&p, "scsi_allowed", "0x%02x", r->scsi_allowed); 1172 if (strncmp(r->tag, "abrt", ZFCP_DBF_TAG_SIZE) == 0) 1173 zfcp_dbf_out(&p, "old_fsf_reqid", "0x%0Lx", r->old_fsf_reqid); 1174 zfcp_dbf_out(&p, "fsf_reqid", "0x%0Lx", r->fsf_reqid); 1175 zfcp_dbf_out(&p, "fsf_seqno", "0x%08x", r->fsf_seqno); 1176 zfcp_dbf_timestamp(r->fsf_issued, &t); 1177 zfcp_dbf_out(&p, "fsf_issued", "%011lu:%06lu", t.tv_sec, t.tv_nsec); 1178 1179 if (strncmp(r->tag, "rslt", ZFCP_DBF_TAG_SIZE) == 0) { 1180 zfcp_dbf_out(&p, "fcp_rsp_validity", "0x%02x", r->rsp_validity); 1181 zfcp_dbf_out(&p, "fcp_rsp_scsi_status", "0x%02x", 1182 r->rsp_scsi_status); 1183 zfcp_dbf_out(&p, "fcp_rsp_resid", "0x%08x", r->rsp_resid); 1184 zfcp_dbf_out(&p, "fcp_rsp_code", "0x%08x", r->rsp_code); 1185 zfcp_dbf_out(&p, "fcp_sns_info_len", "0x%08x", r->sns_info_len); 1186 zfcp_dbf_outd(&p, "fcp_sns_info", r->sns_info, 1187 min((int)r->sns_info_len, 1188 ZFCP_DBF_SCSI_FCP_SNS_INFO), 0, 1189 r->sns_info_len); 1190 } 1191 p += sprintf(p, "\n"); 1192 return p - out_buf; 1193 } 1194 1195 static struct debug_view zfcp_scsi_dbf_view = { 1196 "structured", 1197 NULL, 1198 &zfcp_dbf_view_header, 1199 &zfcp_scsi_dbf_view_format, 1200 NULL, 1201 NULL 1202 }; 1203 1204 /** 1205 * zfcp_adapter_debug_register - registers debug feature for an adapter 1206 * @adapter: pointer to adapter for which debug features should be registered 1207 * return: -ENOMEM on error, 0 otherwise 1208 */ 1209 int zfcp_adapter_debug_register(struct zfcp_adapter *adapter) 1210 { 1211 char dbf_name[DEBUG_MAX_NAME_LEN]; 1212 1213 /* debug feature area which records recovery activity */ 1214 sprintf(dbf_name, "zfcp_%s_rec", zfcp_get_busid_by_adapter(adapter)); 1215 adapter->rec_dbf = debug_register(dbf_name, dbfsize, 1, 1216 sizeof(struct zfcp_rec_dbf_record)); 1217 if (!adapter->rec_dbf) 1218 goto failed; 1219 debug_register_view(adapter->rec_dbf, &debug_hex_ascii_view); 1220 debug_register_view(adapter->rec_dbf, &zfcp_rec_dbf_view); 1221 debug_set_level(adapter->rec_dbf, 3); 1222 1223 /* debug feature area which records HBA (FSF and QDIO) conditions */ 1224 sprintf(dbf_name, "zfcp_%s_hba", zfcp_get_busid_by_adapter(adapter)); 1225 adapter->hba_dbf = debug_register(dbf_name, dbfsize, 1, 1226 sizeof(struct zfcp_hba_dbf_record)); 1227 if (!adapter->hba_dbf) 1228 goto failed; 1229 debug_register_view(adapter->hba_dbf, &debug_hex_ascii_view); 1230 debug_register_view(adapter->hba_dbf, &zfcp_hba_dbf_view); 1231 debug_set_level(adapter->hba_dbf, 3); 1232 1233 /* debug feature area which records SAN command failures and recovery */ 1234 sprintf(dbf_name, "zfcp_%s_san", zfcp_get_busid_by_adapter(adapter)); 1235 adapter->san_dbf = debug_register(dbf_name, dbfsize, 1, 1236 sizeof(struct zfcp_san_dbf_record)); 1237 if (!adapter->san_dbf) 1238 goto failed; 1239 debug_register_view(adapter->san_dbf, &debug_hex_ascii_view); 1240 debug_register_view(adapter->san_dbf, &zfcp_san_dbf_view); 1241 debug_set_level(adapter->san_dbf, 6); 1242 1243 /* debug feature area which records SCSI command failures and recovery */ 1244 sprintf(dbf_name, "zfcp_%s_scsi", zfcp_get_busid_by_adapter(adapter)); 1245 adapter->scsi_dbf = debug_register(dbf_name, dbfsize, 1, 1246 sizeof(struct zfcp_scsi_dbf_record)); 1247 if (!adapter->scsi_dbf) 1248 goto failed; 1249 debug_register_view(adapter->scsi_dbf, &debug_hex_ascii_view); 1250 debug_register_view(adapter->scsi_dbf, &zfcp_scsi_dbf_view); 1251 debug_set_level(adapter->scsi_dbf, 3); 1252 1253 return 0; 1254 1255 failed: 1256 zfcp_adapter_debug_unregister(adapter); 1257 1258 return -ENOMEM; 1259 } 1260 1261 /** 1262 * zfcp_adapter_debug_unregister - unregisters debug feature for an adapter 1263 * @adapter: pointer to adapter for which debug features should be unregistered 1264 */ 1265 void zfcp_adapter_debug_unregister(struct zfcp_adapter *adapter) 1266 { 1267 debug_unregister(adapter->scsi_dbf); 1268 debug_unregister(adapter->san_dbf); 1269 debug_unregister(adapter->hba_dbf); 1270 debug_unregister(adapter->rec_dbf); 1271 adapter->scsi_dbf = NULL; 1272 adapter->san_dbf = NULL; 1273 adapter->hba_dbf = NULL; 1274 adapter->rec_dbf = NULL; 1275 } 1276