drivers/scsi/scsi_trace.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2010 FUJITSU LIMITED
   4  * Copyright (C) 2010 Tomohiro Kusumi <kusumi.tomohiro@jp.fujitsu.com>
   5  */
   6 #include <linux/kernel.h>
   7 #include <linux/trace_seq.h>
   8 #include <linux/unaligned.h>
   9 #include <trace/events/scsi.h>
  10
  11 #define SERVICE_ACTION16(cdb) (cdb[1] & 0x1f)
  12 #define SERVICE_ACTION32(cdb) (get_unaligned_be16(&cdb[8]))
  13
  14 static const char *
  15 scsi_trace_misc(struct trace_seq *, unsigned char *, int);
  16
  17 static const char *
  18 scsi_trace_rw6(struct trace_seq *p, unsigned char *cdb, int len)
  19 {
  20         const char *ret = trace_seq_buffer_ptr(p);
  21         u32 lba, txlen;
  22
  23         lba = get_unaligned_be24(&cdb[1]) & 0x1fffff;
  24         /*
  25          * From SBC-2: a TRANSFER LENGTH field set to zero specifies that 256
  26          * logical blocks shall be read (READ(6)) or written (WRITE(6)).
  27          */
  28         txlen = cdb[4] ? cdb[4] : 256;
  29
  30         trace_seq_printf(p, "lba=%u txlen=%u", lba, txlen);
  31         trace_seq_putc(p, 0);
  32
  33         return ret;
  34 }
  35
  36 static const char *
  37 scsi_trace_rw10(struct trace_seq *p, unsigned char *cdb, int len)
  38 {
  39         const char *ret = trace_seq_buffer_ptr(p);
  40         u32 lba, txlen;
  41
  42         lba = get_unaligned_be32(&cdb[2]);
  43         txlen = get_unaligned_be16(&cdb[7]);
  44
  45         trace_seq_printf(p, "lba=%u txlen=%u protect=%u", lba, txlen,
  46                          cdb[1] >> 5);
  47
  48         if (cdb[0] == WRITE_SAME)
  49                 trace_seq_printf(p, " unmap=%u", cdb[1] >> 3 & 1);
  50
  51         trace_seq_putc(p, 0);
  52
  53         return ret;
  54 }
  55
  56 static const char *
  57 scsi_trace_rw12(struct trace_seq *p, unsigned char *cdb, int len)
  58 {
  59         const char *ret = trace_seq_buffer_ptr(p);
  60         u32 lba, txlen;
  61
  62         lba = get_unaligned_be32(&cdb[2]);
  63         txlen = get_unaligned_be32(&cdb[6]);
  64
  65         trace_seq_printf(p, "lba=%u txlen=%u protect=%u", lba, txlen,
  66                          cdb[1] >> 5);
  67         trace_seq_putc(p, 0);
  68
  69         return ret;
  70 }
  71
  72 static const char *
  73 scsi_trace_rw16(struct trace_seq *p, unsigned char *cdb, int len)
  74 {
  75         const char *ret = trace_seq_buffer_ptr(p);
  76         u64 lba;
  77         u32 txlen;
  78
  79         lba = get_unaligned_be64(&cdb[2]);
  80         txlen = get_unaligned_be32(&cdb[10]);
  81
  82         trace_seq_printf(p, "lba=%llu txlen=%u protect=%u", lba, txlen,
  83                          cdb[1] >> 5);
  84
  85         if (cdb[0] == WRITE_SAME_16)
  86                 trace_seq_printf(p, " unmap=%u", cdb[1] >> 3 & 1);
  87
  88         trace_seq_putc(p, 0);
  89
  90         return ret;
  91 }
  92
  93 static const char *
  94 scsi_trace_rw32(struct trace_seq *p, unsigned char *cdb, int len)
  95 {
  96         const char *ret = trace_seq_buffer_ptr(p), *cmd;
  97         u64 lba;
  98         u32 ei_lbrt, txlen;
  99
 100         switch (SERVICE_ACTION32(cdb)) {
 101         case READ_32:
 102                 cmd = "READ";
 103                 break;
 104         case VERIFY_32:
 105                 cmd = "VERIFY";
 106                 break;
 107         case WRITE_32:
 108                 cmd = "WRITE";
 109                 break;
 110         case WRITE_SAME_32:
 111                 cmd = "WRITE_SAME";
 112                 break;
 113         default:
 114                 trace_seq_puts(p, "UNKNOWN");
 115                 goto out;
 116         }
 117
 118         lba = get_unaligned_be64(&cdb[12]);
 119         ei_lbrt = get_unaligned_be32(&cdb[20]);
 120         txlen = get_unaligned_be32(&cdb[28]);
 121
 122         trace_seq_printf(p, "%s_32 lba=%llu txlen=%u protect=%u ei_lbrt=%u",
 123                          cmd, lba, txlen, cdb[10] >> 5, ei_lbrt);
 124
 125         if (SERVICE_ACTION32(cdb) == WRITE_SAME_32)
 126                 trace_seq_printf(p, " unmap=%u", cdb[10] >> 3 & 1);
 127
 128 out:
 129         trace_seq_putc(p, 0);
 130
 131         return ret;
 132 }
 133
 134 static const char *
 135 scsi_trace_unmap(struct trace_seq *p, unsigned char *cdb, int len)
 136 {
 137         const char *ret = trace_seq_buffer_ptr(p);
 138         unsigned int regions = get_unaligned_be16(&cdb[7]);
 139
 140         trace_seq_printf(p, "regions=%u", (regions - 8) / 16);
 141         trace_seq_putc(p, 0);
 142
 143         return ret;
 144 }
 145
 146 static const char *
 147 scsi_trace_service_action_in(struct trace_seq *p, unsigned char *cdb, int len)
 148 {
 149         const char *ret = trace_seq_buffer_ptr(p), *cmd;
 150         u64 lba;
 151         u32 alloc_len;
 152
 153         switch (SERVICE_ACTION16(cdb)) {
 154         case SAI_READ_CAPACITY_16:
 155                 cmd = "READ_CAPACITY_16";
 156                 break;
 157         case SAI_GET_LBA_STATUS:
 158                 cmd = "GET_LBA_STATUS";
 159                 break;
 160         default:
 161                 trace_seq_puts(p, "UNKNOWN");
 162                 goto out;
 163         }
 164
 165         lba = get_unaligned_be64(&cdb[2]);
 166         alloc_len = get_unaligned_be32(&cdb[10]);
 167
 168         trace_seq_printf(p, "%s lba=%llu alloc_len=%u", cmd, lba, alloc_len);
 169
 170 out:
 171         trace_seq_putc(p, 0);
 172
 173         return ret;
 174 }
 175
 176 static const char *
 177 scsi_trace_maintenance_in(struct trace_seq *p, unsigned char *cdb, int len)
 178 {
 179         const char *ret = trace_seq_buffer_ptr(p), *cmd;
 180         u32 alloc_len;
 181
 182         switch (SERVICE_ACTION16(cdb)) {
 183         case MI_REPORT_IDENTIFYING_INFORMATION:
 184                 cmd = "REPORT_IDENTIFYING_INFORMATION";
 185                 break;
 186         case MI_REPORT_TARGET_PGS:
 187                 cmd = "REPORT_TARGET_PORT_GROUPS";
 188                 break;
 189         case MI_REPORT_ALIASES:
 190                 cmd = "REPORT_ALIASES";
 191                 break;
 192         case MI_REPORT_SUPPORTED_OPERATION_CODES:
 193                 cmd = "REPORT_SUPPORTED_OPERATION_CODES";
 194                 break;
 195         case MI_REPORT_SUPPORTED_TASK_MANAGEMENT_FUNCTIONS:
 196                 cmd = "REPORT_SUPPORTED_TASK_MANAGEMENT_FUNCTIONS";
 197                 break;
 198         case MI_REPORT_PRIORITY:
 199                 cmd = "REPORT_PRIORITY";
 200                 break;
 201         case MI_REPORT_TIMESTAMP:
 202                 cmd = "REPORT_TIMESTAMP";
 203                 break;
 204         case MI_MANAGEMENT_PROTOCOL_IN:
 205                 cmd = "MANAGEMENT_PROTOCOL_IN";
 206                 break;
 207         default:
 208                 trace_seq_puts(p, "UNKNOWN");
 209                 goto out;
 210         }
 211
 212         alloc_len = get_unaligned_be32(&cdb[6]);
 213
 214         trace_seq_printf(p, "%s alloc_len=%u", cmd, alloc_len);
 215
 216 out:
 217         trace_seq_putc(p, 0);
 218
 219         return ret;
 220 }
 221
 222 static const char *
 223 scsi_trace_maintenance_out(struct trace_seq *p, unsigned char *cdb, int len)
 224 {
 225         const char *ret = trace_seq_buffer_ptr(p), *cmd;
 226         u32 alloc_len;
 227
 228         switch (SERVICE_ACTION16(cdb)) {
 229         case MO_SET_IDENTIFYING_INFORMATION:
 230                 cmd = "SET_IDENTIFYING_INFORMATION";
 231                 break;
 232         case MO_SET_TARGET_PGS:
 233                 cmd = "SET_TARGET_PORT_GROUPS";
 234                 break;
 235         case MO_CHANGE_ALIASES:
 236                 cmd = "CHANGE_ALIASES";
 237                 break;
 238         case MO_SET_PRIORITY:
 239                 cmd = "SET_PRIORITY";
 240                 break;
 241         case MO_SET_TIMESTAMP:
 242                 cmd = "SET_TIMESTAMP";
 243                 break;
 244         case MO_MANAGEMENT_PROTOCOL_OUT:
 245                 cmd = "MANAGEMENT_PROTOCOL_OUT";
 246                 break;
 247         default:
 248                 trace_seq_puts(p, "UNKNOWN");
 249                 goto out;
 250         }
 251
 252         alloc_len = get_unaligned_be32(&cdb[6]);
 253
 254         trace_seq_printf(p, "%s alloc_len=%u", cmd, alloc_len);
 255
 256 out:
 257         trace_seq_putc(p, 0);
 258
 259         return ret;
 260 }
 261
 262 static const char *
 263 scsi_trace_zbc_in(struct trace_seq *p, unsigned char *cdb, int len)
 264 {
 265         const char *ret = trace_seq_buffer_ptr(p), *cmd;
 266         u64 zone_id;
 267         u32 alloc_len;
 268         u8 options;
 269
 270         switch (SERVICE_ACTION16(cdb)) {
 271         case ZI_REPORT_ZONES:
 272                 cmd = "REPORT_ZONES";
 273                 break;
 274         default:
 275                 trace_seq_puts(p, "UNKNOWN");
 276                 goto out;
 277         }
 278
 279         zone_id = get_unaligned_be64(&cdb[2]);
 280         alloc_len = get_unaligned_be32(&cdb[10]);
 281         options = cdb[14] & 0x3f;
 282
 283         trace_seq_printf(p, "%s zone=%llu alloc_len=%u options=%u partial=%u",
 284                          cmd, (unsigned long long)zone_id, alloc_len,
 285                          options, (cdb[14] >> 7) & 1);
 286
 287 out:
 288         trace_seq_putc(p, 0);
 289
 290         return ret;
 291 }
 292
 293 static const char *
 294 scsi_trace_zbc_out(struct trace_seq *p, unsigned char *cdb, int len)
 295 {
 296         const char *ret = trace_seq_buffer_ptr(p), *cmd;
 297         u64 zone_id;
 298
 299         switch (SERVICE_ACTION16(cdb)) {
 300         case ZO_CLOSE_ZONE:
 301                 cmd = "CLOSE_ZONE";
 302                 break;
 303         case ZO_FINISH_ZONE:
 304                 cmd = "FINISH_ZONE";
 305                 break;
 306         case ZO_OPEN_ZONE:
 307                 cmd = "OPEN_ZONE";
 308                 break;
 309         case ZO_RESET_WRITE_POINTER:
 310                 cmd = "RESET_WRITE_POINTER";
 311                 break;
 312         default:
 313                 trace_seq_puts(p, "UNKNOWN");
 314                 goto out;
 315         }
 316
 317         zone_id = get_unaligned_be64(&cdb[2]);
 318
 319         trace_seq_printf(p, "%s zone=%llu all=%u", cmd,
 320                          (unsigned long long)zone_id, cdb[14] & 1);
 321
 322 out:
 323         trace_seq_putc(p, 0);
 324
 325         return ret;
 326 }
 327
 328 static const char *
 329 scsi_trace_atomic_write16_out(struct trace_seq *p, unsigned char *cdb, int len)
 330 {
 331         const char *ret = trace_seq_buffer_ptr(p);
 332         unsigned int boundary_size;
 333         unsigned int nr_blocks;
 334         sector_t lba;
 335
 336         lba = get_unaligned_be64(&cdb[2]);
 337         boundary_size = get_unaligned_be16(&cdb[10]);
 338         nr_blocks = get_unaligned_be16(&cdb[12]);
 339
 340         trace_seq_printf(p, "lba=%llu txlen=%u boundary_size=%u",
 341                           lba, nr_blocks, boundary_size);
 342
 343         trace_seq_putc(p, 0);
 344
 345         return ret;
 346 }
 347
 348 static const char *
 349 scsi_trace_varlen(struct trace_seq *p, unsigned char *cdb, int len)
 350 {
 351         switch (SERVICE_ACTION32(cdb)) {
 352         case READ_32:
 353         case VERIFY_32:
 354         case WRITE_32:
 355         case WRITE_SAME_32:
 356                 return scsi_trace_rw32(p, cdb, len);
 357         default:
 358                 return scsi_trace_misc(p, cdb, len);
 359         }
 360 }
 361
 362 static const char *
 363 scsi_trace_misc(struct trace_seq *p, unsigned char *cdb, int len)
 364 {
 365         const char *ret = trace_seq_buffer_ptr(p);
 366
 367         trace_seq_putc(p, '-');
 368         trace_seq_putc(p, 0);
 369
 370         return ret;
 371 }
 372
 373 const char *
 374 scsi_trace_parse_cdb(struct trace_seq *p, unsigned char *cdb, int len)
 375 {
 376         switch (cdb[0]) {
 377         case READ_6:
 378         case WRITE_6:
 379                 return scsi_trace_rw6(p, cdb, len);
 380         case READ_10:
 381         case VERIFY:
 382         case WRITE_10:
 383         case WRITE_SAME:
 384                 return scsi_trace_rw10(p, cdb, len);
 385         case READ_12:
 386         case VERIFY_12:
 387         case WRITE_12:
 388                 return scsi_trace_rw12(p, cdb, len);
 389         case READ_16:
 390         case VERIFY_16:
 391         case WRITE_16:
 392         case WRITE_SAME_16:
 393                 return scsi_trace_rw16(p, cdb, len);
 394         case UNMAP:
 395                 return scsi_trace_unmap(p, cdb, len);
 396         case SERVICE_ACTION_IN_16:
 397                 return scsi_trace_service_action_in(p, cdb, len);
 398         case VARIABLE_LENGTH_CMD:
 399                 return scsi_trace_varlen(p, cdb, len);
 400         case MAINTENANCE_IN:
 401                 return scsi_trace_maintenance_in(p, cdb, len);
 402         case MAINTENANCE_OUT:
 403                 return scsi_trace_maintenance_out(p, cdb, len);
 404         case ZBC_IN:
 405                 return scsi_trace_zbc_in(p, cdb, len);
 406         case ZBC_OUT:
 407                 return scsi_trace_zbc_out(p, cdb, len);
 408         case WRITE_ATOMIC_16:
 409                 return scsi_trace_atomic_write16_out(p, cdb, len);
 410         default:
 411                 return scsi_trace_misc(p, cdb, len);
 412         }
 413 }