/** * zfcp_dbf_rec_run_wka - trace wka port event with info like running recovery * @tag: identifier for event * @wka_port: well known address port * @req_id: request ID to correlate with potential HBA trace record */ void zfcp_dbf_rec_run_wka(char *tag, struct zfcp_fc_wka_port *wka_port, u64 req_id) { struct zfcp_dbf *dbf = wka_port->adapter->dbf; struct zfcp_dbf_rec *rec = &dbf->rec_buf; static int const level = 1; unsigned long flags; if (unlikely(!debug_level_enabled(dbf->rec, level))) return; spin_lock_irqsave(&dbf->rec_lock, flags); memset(rec, 0, sizeof(*rec)); rec->id = ZFCP_DBF_REC_RUN; memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN); rec->port_status = wka_port->status; rec->d_id = wka_port->d_id; rec->lun = ZFCP_DBF_INVALID_LUN; rec->u.run.fsf_req_id = req_id; rec->u.run.rec_status = ~0; rec->u.run.rec_step = ~0; rec->u.run.rec_action = ~0; rec->u.run.rec_count = ~0; debug_event(dbf->rec, level, rec, sizeof(*rec)); spin_unlock_irqrestore(&dbf->rec_lock, flags); }
/** * zfcp_dbf_rec_trig - trace event related to triggered recovery * @tag: identifier for event * @adapter: adapter on which the erp_action should run * @port: remote port involved in the erp_action * @sdev: scsi device involved in the erp_action * @want: wanted erp_action * @need: required erp_action * * The adapter->erp_lock has to be held. */ void zfcp_dbf_rec_trig(char *tag, struct zfcp_adapter *adapter, struct zfcp_port *port, struct scsi_device *sdev, u8 want, u8 need) { struct zfcp_dbf *dbf = adapter->dbf; struct zfcp_dbf_rec *rec = &dbf->rec_buf; static int const level = 1; struct list_head *entry; unsigned long flags; if (unlikely(!debug_level_enabled(dbf->rec, level))) return; spin_lock_irqsave(&dbf->rec_lock, flags); memset(rec, 0, sizeof(*rec)); rec->id = ZFCP_DBF_REC_TRIG; memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN); zfcp_dbf_set_common(rec, adapter, port, sdev); list_for_each(entry, &adapter->erp_ready_head) rec->u.trig.ready++; list_for_each(entry, &adapter->erp_running_head) rec->u.trig.running++; rec->u.trig.want = want; rec->u.trig.need = need; debug_event(dbf->rec, level, rec, sizeof(*rec)); spin_unlock_irqrestore(&dbf->rec_lock, flags); }
/** * zfcp_dbf_rec_run_lvl - trace event related to running recovery * @level: trace level to be used for event * @tag: identifier for event * @erp: erp_action running */ void zfcp_dbf_rec_run_lvl(int level, char *tag, struct zfcp_erp_action *erp) { struct zfcp_dbf *dbf = erp->adapter->dbf; struct zfcp_dbf_rec *rec = &dbf->rec_buf; unsigned long flags; if (!debug_level_enabled(dbf->rec, level)) return; spin_lock_irqsave(&dbf->rec_lock, flags); memset(rec, 0, sizeof(*rec)); rec->id = ZFCP_DBF_REC_RUN; memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN); zfcp_dbf_set_common(rec, erp->adapter, erp->port, erp->sdev); rec->u.run.fsf_req_id = erp->fsf_req_id; rec->u.run.rec_status = erp->status; rec->u.run.rec_step = erp->step; rec->u.run.rec_action = erp->action; if (erp->sdev) rec->u.run.rec_count = atomic_read(&sdev_to_zfcp(erp->sdev)->erp_counter); else if (erp->port) rec->u.run.rec_count = atomic_read(&erp->port->erp_counter); else rec->u.run.rec_count = atomic_read(&erp->adapter->erp_counter); debug_event(dbf->rec, level, rec, sizeof(*rec)); spin_unlock_irqrestore(&dbf->rec_lock, flags); }
/** * zfcp_dbf_hba_def_err - trace event for deferred error messages * @adapter: pointer to struct zfcp_adapter * @req_id: request id which caused the deferred error message * @scount: number of sbals incl. the signaling sbal * @pl: array of all involved sbals */ void zfcp_dbf_hba_def_err(struct zfcp_adapter *adapter, u64 req_id, u16 scount, void **pl) { struct zfcp_dbf *dbf = adapter->dbf; struct zfcp_dbf_pay *payload = &dbf->pay_buf; unsigned long flags; static int const level = 1; u16 length; if (unlikely(!debug_level_enabled(dbf->pay, level))) return; if (!pl) return; spin_lock_irqsave(&dbf->pay_lock, flags); memset(payload, 0, sizeof(*payload)); memcpy(payload->area, "def_err", 7); payload->fsf_req_id = req_id; payload->counter = 0; length = min((u16)sizeof(struct qdio_buffer), (u16)ZFCP_DBF_PAY_MAX_REC); while (payload->counter < scount && (char *)pl[payload->counter]) { memcpy(payload->data, (char *)pl[payload->counter], length); debug_event(dbf->pay, level, payload, zfcp_dbf_plen(length)); payload->counter++; } spin_unlock_irqrestore(&dbf->pay_lock, flags); }
/** * zfcp_dbf_hba_bit_err - trace event for bit error conditions * @tag: tag indicating which kind of unsolicited status has been received * @req: request which caused the bit_error condition */ void zfcp_dbf_hba_bit_err(char *tag, struct zfcp_fsf_req *req) { struct zfcp_dbf *dbf = req->adapter->dbf; struct zfcp_dbf_hba *rec = &dbf->hba_buf; struct fsf_status_read_buffer *sr_buf = req->data; static int const level = 1; unsigned long flags; if (unlikely(!debug_level_enabled(dbf->hba, level))) return; spin_lock_irqsave(&dbf->hba_lock, flags); memset(rec, 0, sizeof(*rec)); memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN); rec->id = ZFCP_DBF_HBA_BIT; rec->fsf_req_id = req->req_id; rec->fsf_req_status = req->status; rec->fsf_cmd = req->fsf_command; memcpy(&rec->u.be, &sr_buf->payload.bit_error, sizeof(struct fsf_bit_error_payload)); debug_event(dbf->hba, level, rec, sizeof(*rec)); spin_unlock_irqrestore(&dbf->hba_lock, flags); }
/** * zfcp_dbf_san_req - trace event for issued SAN request * @tag: identifier for event * @fsf_req: request containing issued CT data * d_id: destination ID */ void zfcp_dbf_san_req(char *tag, struct zfcp_fsf_req *fsf, u32 d_id) { struct zfcp_dbf *dbf = fsf->adapter->dbf; struct zfcp_fsf_ct_els *ct_els = fsf->data; u16 length; if (unlikely(!debug_level_enabled(dbf->san, ZFCP_DBF_SAN_LEVEL))) return; length = (u16)zfcp_qdio_real_bytes(ct_els->req); zfcp_dbf_san(tag, dbf, "san_req", ct_els->req, ZFCP_DBF_SAN_REQ, length, fsf->req_id, d_id, length); }
void ctcm_dbf_longtext(enum ctcm_dbf_names dbf_nix, int level, char *fmt, ...) { char dbf_txt_buf[64]; va_list args; if (!debug_level_enabled(ctcm_dbf[dbf_nix].id, level)) return; va_start(args, fmt); vsnprintf(dbf_txt_buf, sizeof(dbf_txt_buf), fmt, args); va_end(args); debug_text_event(ctcm_dbf[dbf_nix].id, level, dbf_txt_buf); }
/** * zfcp_dbf_san_res - trace event for received SAN request * @tag: identifier for event * @fsf_req: request containing issued CT data */ void zfcp_dbf_san_res(char *tag, struct zfcp_fsf_req *fsf) { struct zfcp_dbf *dbf = fsf->adapter->dbf; struct zfcp_fsf_ct_els *ct_els = fsf->data; u16 length; if (unlikely(!debug_level_enabled(dbf->san, ZFCP_DBF_SAN_LEVEL))) return; length = (u16)zfcp_qdio_real_bytes(ct_els->resp); zfcp_dbf_san(tag, dbf, "san_res", ct_els->resp, ZFCP_DBF_SAN_RES, length, fsf->req_id, ct_els->d_id, zfcp_dbf_san_res_cap_len_if_gpn_ft(tag, fsf, length)); }
/** * zfcp_dbf_san_in_els - trace event for incoming ELS * @tag: identifier for event * @fsf_req: request containing issued CT data */ void zfcp_dbf_san_in_els(char *tag, struct zfcp_fsf_req *fsf) { struct zfcp_dbf *dbf = fsf->adapter->dbf; struct fsf_status_read_buffer *srb = (struct fsf_status_read_buffer *) fsf->data; u16 length; struct scatterlist sg; if (unlikely(!debug_level_enabled(dbf->san, ZFCP_DBF_SAN_LEVEL))) return; length = (u16)(srb->length - offsetof(struct fsf_status_read_buffer, payload)); sg_init_one(&sg, srb->payload.data, length); zfcp_dbf_san(tag, dbf, "san_els", &sg, ZFCP_DBF_SAN_ELS, length, fsf->req_id, ntoh24(srb->d_id), length); }
/** * zfcp_dbf_hba_basic - trace event for basic adapter events * @adapter: pointer to struct zfcp_adapter */ void zfcp_dbf_hba_basic(char *tag, struct zfcp_adapter *adapter) { struct zfcp_dbf *dbf = adapter->dbf; struct zfcp_dbf_hba *rec = &dbf->hba_buf; static int const level = 1; unsigned long flags; if (unlikely(!debug_level_enabled(dbf->hba, level))) return; spin_lock_irqsave(&dbf->hba_lock, flags); memset(rec, 0, sizeof(*rec)); memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN); rec->id = ZFCP_DBF_HBA_BASIC; debug_event(dbf->hba, level, rec, sizeof(*rec)); spin_unlock_irqrestore(&dbf->hba_lock, flags); }
/** * zfcp_dbf_hba_fsf_uss - trace event for an unsolicited status buffer * @tag: tag indicating which kind of unsolicited status has been received * @req: request providing the unsolicited status */ void zfcp_dbf_hba_fsf_uss(char *tag, struct zfcp_fsf_req *req) { struct zfcp_dbf *dbf = req->adapter->dbf; struct fsf_status_read_buffer *srb = req->data; struct zfcp_dbf_hba *rec = &dbf->hba_buf; static int const level = 2; unsigned long flags; if (unlikely(!debug_level_enabled(dbf->hba, level))) return; spin_lock_irqsave(&dbf->hba_lock, flags); memset(rec, 0, sizeof(*rec)); memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN); rec->id = ZFCP_DBF_HBA_USS; rec->fsf_req_id = req->req_id; rec->fsf_req_status = req->status; rec->fsf_cmd = req->fsf_command; if (!srb) goto log; rec->u.uss.status_type = srb->status_type; rec->u.uss.status_subtype = srb->status_subtype; rec->u.uss.d_id = ntoh24(srb->d_id); rec->u.uss.lun = srb->fcp_lun; memcpy(&rec->u.uss.queue_designator, &srb->queue_designator, sizeof(rec->u.uss.queue_designator)); /* status read buffer payload length */ rec->pl_len = (!srb->length) ? 0 : srb->length - offsetof(struct fsf_status_read_buffer, payload); if (rec->pl_len) zfcp_dbf_pl_write(dbf, srb->payload.data, rec->pl_len, "fsf_uss", req->req_id); log: debug_event(dbf->hba, level, rec, sizeof(*rec)); spin_unlock_irqrestore(&dbf->hba_lock, flags); }