drivers/s390/scsi/zfcp_dbf.c

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