drivers/nvme/target/trace.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * NVM Express target device driver tracepoints
   4  * Copyright (c) 2018 Johannes Thumshirn, SUSE Linux GmbH
   5  */
   6
   7 #include <asm/unaligned.h>
   8 #include "trace.h"
   9
  10 static const char *nvmet_trace_admin_identify(struct trace_seq *p, u8 *cdw10)
  11 {
  12         const char *ret = trace_seq_buffer_ptr(p);
  13         u8 cns = cdw10[0];
  14         u16 ctrlid = get_unaligned_le16(cdw10 + 2);
  15
  16         trace_seq_printf(p, "cns=%u, ctrlid=%u", cns, ctrlid);
  17         trace_seq_putc(p, 0);
  18
  19         return ret;
  20 }
  21
  22 static const char *nvmet_trace_admin_get_features(struct trace_seq *p,
  23                                                  u8 *cdw10)
  24 {
  25         const char *ret = trace_seq_buffer_ptr(p);
  26         u8 fid = cdw10[0];
  27         u8 sel = cdw10[1] & 0x7;
  28         u32 cdw11 = get_unaligned_le32(cdw10 + 4);
  29
  30         trace_seq_printf(p, "fid=0x%x, sel=0x%x, cdw11=0x%x", fid, sel, cdw11);
  31         trace_seq_putc(p, 0);
  32
  33         return ret;
  34 }
  35
  36 static const char *nvmet_trace_get_lba_status(struct trace_seq *p,
  37                                              u8 *cdw10)
  38 {
  39         const char *ret = trace_seq_buffer_ptr(p);
  40         u64 slba = get_unaligned_le64(cdw10);
  41         u32 mndw = get_unaligned_le32(cdw10 + 8);
  42         u16 rl = get_unaligned_le16(cdw10 + 12);
  43         u8 atype = cdw10[15];
  44
  45         trace_seq_printf(p, "slba=0x%llx, mndw=0x%x, rl=0x%x, atype=%u",
  46                         slba, mndw, rl, atype);
  47         trace_seq_putc(p, 0);
  48
  49         return ret;
  50 }
  51
  52 static const char *nvmet_trace_admin_set_features(struct trace_seq *p,
  53                                                  u8 *cdw10)
  54 {
  55         const char *ret = trace_seq_buffer_ptr(p);
  56         u8 fid = cdw10[0];
  57         u8 sv = cdw10[3] & 0x8;
  58         u32 cdw11 = get_unaligned_le32(cdw10 + 4);
  59
  60         trace_seq_printf(p, "fid=0x%x, sv=0x%x, cdw11=0x%x", fid, sv, cdw11);
  61         trace_seq_putc(p, 0);
  62
  63         return ret;
  64 }
  65
  66 static const char *nvmet_trace_read_write(struct trace_seq *p, u8 *cdw10)
  67 {
  68         const char *ret = trace_seq_buffer_ptr(p);
  69         u64 slba = get_unaligned_le64(cdw10);
  70         u16 length = get_unaligned_le16(cdw10 + 8);
  71         u16 control = get_unaligned_le16(cdw10 + 10);
  72         u32 dsmgmt = get_unaligned_le32(cdw10 + 12);
  73         u32 reftag = get_unaligned_le32(cdw10 +  16);
  74
  75         trace_seq_printf(p,
  76                          "slba=%llu, len=%u, ctrl=0x%x, dsmgmt=%u, reftag=%u",
  77                          slba, length, control, dsmgmt, reftag);
  78         trace_seq_putc(p, 0);
  79
  80         return ret;
  81 }
  82
  83 static const char *nvmet_trace_dsm(struct trace_seq *p, u8 *cdw10)
  84 {
  85         const char *ret = trace_seq_buffer_ptr(p);
  86
  87         trace_seq_printf(p, "nr=%u, attributes=%u",
  88                          get_unaligned_le32(cdw10),
  89                          get_unaligned_le32(cdw10 + 4));
  90         trace_seq_putc(p, 0);
  91
  92         return ret;
  93 }
  94
  95 static const char *nvmet_trace_common(struct trace_seq *p, u8 *cdw10)
  96 {
  97         const char *ret = trace_seq_buffer_ptr(p);
  98
  99         trace_seq_printf(p, "cdw10=%*ph", 24, cdw10);
 100         trace_seq_putc(p, 0);
 101
 102         return ret;
 103 }
 104
 105 const char *nvmet_trace_parse_admin_cmd(struct trace_seq *p,
 106                 u8 opcode, u8 *cdw10)
 107 {
 108         switch (opcode) {
 109         case nvme_admin_identify:
 110                 return nvmet_trace_admin_identify(p, cdw10);
 111         case nvme_admin_set_features:
 112                 return nvmet_trace_admin_set_features(p, cdw10);
 113         case nvme_admin_get_features:
 114                 return nvmet_trace_admin_get_features(p, cdw10);
 115         case nvme_admin_get_lba_status:
 116                 return nvmet_trace_get_lba_status(p, cdw10);
 117         default:
 118                 return nvmet_trace_common(p, cdw10);
 119         }
 120 }
 121
 122 static const char *nvmet_trace_zone_mgmt_send(struct trace_seq *p, u8 *cdw10)
 123 {
 124         static const char * const zsa_strs[] = {
 125                 [0x01] = "close zone",
 126                 [0x02] = "finish zone",
 127                 [0x03] = "open zone",
 128                 [0x04] = "reset zone",
 129                 [0x05] = "offline zone",
 130                 [0x10] = "set zone descriptor extension"
 131         };
 132         const char *ret = trace_seq_buffer_ptr(p);
 133         u64 slba = get_unaligned_le64(cdw10);
 134         const char *zsa_str;
 135         u8 zsa = cdw10[12];
 136         u8 all = cdw10[13];
 137
 138         if (zsa < ARRAY_SIZE(zsa_strs) && zsa_strs[zsa])
 139                 zsa_str = zsa_strs[zsa];
 140         else
 141                 zsa_str = "reserved";
 142
 143         trace_seq_printf(p, "slba=%llu, zsa=%u:%s, all=%u",
 144                 slba, zsa, zsa_str, all);
 145         trace_seq_putc(p, 0);
 146
 147         return ret;
 148 }
 149
 150 static const char *nvmet_trace_zone_mgmt_recv(struct trace_seq *p, u8 *cdw10)
 151 {
 152         static const char * const zrasf_strs[] = {
 153                 [0x00] = "list all zones",
 154                 [0x01] = "list the zones in the ZSE: Empty state",
 155                 [0x02] = "list the zones in the ZSIO: Implicitly Opened state",
 156                 [0x03] = "list the zones in the ZSEO: Explicitly Opened state",
 157                 [0x04] = "list the zones in the ZSC: Closed state",
 158                 [0x05] = "list the zones in the ZSF: Full state",
 159                 [0x06] = "list the zones in the ZSRO: Read Only state",
 160                 [0x07] = "list the zones in the ZSO: Offline state",
 161                 [0x09] = "list the zones that have the zone attribute"
 162         };
 163         const char *ret = trace_seq_buffer_ptr(p);
 164         u64 slba = get_unaligned_le64(cdw10);
 165         u32 numd = get_unaligned_le32(&cdw10[8]);
 166         u8 zra = cdw10[12];
 167         u8 zrasf = cdw10[13];
 168         const char *zrasf_str;
 169         u8 pr = cdw10[14];
 170
 171         if (zrasf < ARRAY_SIZE(zrasf_strs) && zrasf_strs[zrasf])
 172                 zrasf_str = zrasf_strs[zrasf];
 173         else
 174                 zrasf_str = "reserved";
 175
 176         trace_seq_printf(p, "slba=%llu, numd=%u, zra=%u, zrasf=%u:%s, pr=%u",
 177                 slba, numd, zra, zrasf, zrasf_str, pr);
 178         trace_seq_putc(p, 0);
 179
 180         return ret;
 181 }
 182
 183 const char *nvmet_trace_parse_nvm_cmd(struct trace_seq *p,
 184                 u8 opcode, u8 *cdw10)
 185 {
 186         switch (opcode) {
 187         case nvme_cmd_read:
 188         case nvme_cmd_write:
 189         case nvme_cmd_write_zeroes:
 190         case nvme_cmd_zone_append:
 191                 return nvmet_trace_read_write(p, cdw10);
 192         case nvme_cmd_dsm:
 193                 return nvmet_trace_dsm(p, cdw10);
 194         case nvme_cmd_zone_mgmt_send:
 195                 return nvmet_trace_zone_mgmt_send(p, cdw10);
 196         case nvme_cmd_zone_mgmt_recv:
 197                 return nvmet_trace_zone_mgmt_recv(p, cdw10);
 198         default:
 199                 return nvmet_trace_common(p, cdw10);
 200         }
 201 }
 202
 203 static const char *nvmet_trace_fabrics_property_set(struct trace_seq *p,
 204                 u8 *spc)
 205 {
 206         const char *ret = trace_seq_buffer_ptr(p);
 207         u8 attrib = spc[0];
 208         u32 ofst = get_unaligned_le32(spc + 4);
 209         u64 value = get_unaligned_le64(spc + 8);
 210
 211         trace_seq_printf(p, "attrib=%u, ofst=0x%x, value=0x%llx",
 212                          attrib, ofst, value);
 213         trace_seq_putc(p, 0);
 214         return ret;
 215 }
 216
 217 static const char *nvmet_trace_fabrics_connect(struct trace_seq *p,
 218                 u8 *spc)
 219 {
 220         const char *ret = trace_seq_buffer_ptr(p);
 221         u16 recfmt = get_unaligned_le16(spc);
 222         u16 qid = get_unaligned_le16(spc + 2);
 223         u16 sqsize = get_unaligned_le16(spc + 4);
 224         u8 cattr = spc[6];
 225         u32 kato = get_unaligned_le32(spc + 8);
 226
 227         trace_seq_printf(p, "recfmt=%u, qid=%u, sqsize=%u, cattr=%u, kato=%u",
 228                          recfmt, qid, sqsize, cattr, kato);
 229         trace_seq_putc(p, 0);
 230         return ret;
 231 }
 232
 233 static const char *nvmet_trace_fabrics_property_get(struct trace_seq *p,
 234                 u8 *spc)
 235 {
 236         const char *ret = trace_seq_buffer_ptr(p);
 237         u8 attrib = spc[0];
 238         u32 ofst = get_unaligned_le32(spc + 4);
 239
 240         trace_seq_printf(p, "attrib=%u, ofst=0x%x", attrib, ofst);
 241         trace_seq_putc(p, 0);
 242         return ret;
 243 }
 244
 245 static const char *nvmet_trace_fabrics_auth_send(struct trace_seq *p, u8 *spc)
 246 {
 247         const char *ret = trace_seq_buffer_ptr(p);
 248         u8 spsp0 = spc[1];
 249         u8 spsp1 = spc[2];
 250         u8 secp = spc[3];
 251         u32 tl = get_unaligned_le32(spc + 4);
 252
 253         trace_seq_printf(p, "spsp0=%02x, spsp1=%02x, secp=%02x, tl=%u",
 254                          spsp0, spsp1, secp, tl);
 255         trace_seq_putc(p, 0);
 256         return ret;
 257 }
 258
 259 static const char *nvmet_trace_fabrics_auth_receive(struct trace_seq *p, u8 *spc)
 260 {
 261         const char *ret = trace_seq_buffer_ptr(p);
 262         u8 spsp0 = spc[1];
 263         u8 spsp1 = spc[2];
 264         u8 secp = spc[3];
 265         u32 al = get_unaligned_le32(spc + 4);
 266
 267         trace_seq_printf(p, "spsp0=%02x, spsp1=%02x, secp=%02x, al=%u",
 268                          spsp0, spsp1, secp, al);
 269         trace_seq_putc(p, 0);
 270         return ret;
 271 }
 272
 273 static const char *nvmet_trace_fabrics_common(struct trace_seq *p, u8 *spc)
 274 {
 275         const char *ret = trace_seq_buffer_ptr(p);
 276
 277         trace_seq_printf(p, "specific=%*ph", 24, spc);
 278         trace_seq_putc(p, 0);
 279         return ret;
 280 }
 281
 282 const char *nvmet_trace_parse_fabrics_cmd(struct trace_seq *p,
 283                 u8 fctype, u8 *spc)
 284 {
 285         switch (fctype) {
 286         case nvme_fabrics_type_property_set:
 287                 return nvmet_trace_fabrics_property_set(p, spc);
 288         case nvme_fabrics_type_connect:
 289                 return nvmet_trace_fabrics_connect(p, spc);
 290         case nvme_fabrics_type_property_get:
 291                 return nvmet_trace_fabrics_property_get(p, spc);
 292         case nvme_fabrics_type_auth_send:
 293                 return nvmet_trace_fabrics_auth_send(p, spc);
 294         case nvme_fabrics_type_auth_receive:
 295                 return nvmet_trace_fabrics_auth_receive(p, spc);
 296         default:
 297                 return nvmet_trace_fabrics_common(p, spc);
 298         }
 299 }
 300
 301 const char *nvmet_trace_disk_name(struct trace_seq *p, char *name)
 302 {
 303         const char *ret = trace_seq_buffer_ptr(p);
 304
 305         if (*name)
 306                 trace_seq_printf(p, "disk=%s, ", name);
 307         trace_seq_putc(p, 0);
 308
 309         return ret;
 310 }
 311
 312 const char *nvmet_trace_ctrl_id(struct trace_seq *p, u16 ctrl_id)
 313 {
 314         const char *ret = trace_seq_buffer_ptr(p);
 315
 316         /*
 317          * XXX: We don't know the controller instance before executing the
 318          * connect command itself because the connect command for the admin
 319          * queue will not provide the cntlid which will be allocated in this
 320          * command.  In case of io queues, the controller instance will be
 321          * mapped by the extra data of the connect command.
 322          * If we can know the extra data of the connect command in this stage,
 323          * we can update this print statement later.
 324          */
 325         if (ctrl_id)
 326                 trace_seq_printf(p, "%d", ctrl_id);
 327         else
 328                 trace_seq_printf(p, "_");
 329         trace_seq_putc(p, 0);
 330
 331         return ret;
 332 }
 333