drivers/scsi/scsi_trace.c

   1 /*
   2  * Copyright (C) 2010 FUJITSU LIMITED
   3  * Copyright (C) 2010 Tomohiro Kusumi <kusumi.tomohiro@jp.fujitsu.com>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2 as
   7  * published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17  */
  18 #include <linux/kernel.h>
  19 #include <linux/trace_seq.h>
  20 #include <asm/unaligned.h>
  21 #include <trace/events/scsi.h>
  22
  23 #define SERVICE_ACTION16(cdb) (cdb[1] & 0x1f)
  24 #define SERVICE_ACTION32(cdb) (get_unaligned_be16(&cdb[8]))
  25
  26 static const char *
  27 scsi_trace_misc(struct trace_seq *, unsigned char *, int);
  28
  29 static const char *
  30 scsi_trace_rw6(struct trace_seq *p, unsigned char *cdb, int len)
  31 {
  32         const char *ret = trace_seq_buffer_ptr(p);
  33         u32 lba = 0, txlen;
  34
  35         lba |= ((cdb[1] & 0x1F) << 16);
  36         lba |=  (cdb[2] << 8);
  37         lba |=   cdb[3];
  38         /*
  39          * From SBC-2: a TRANSFER LENGTH field set to zero specifies that 256
  40          * logical blocks shall be read (READ(6)) or written (WRITE(6)).
  41          */
  42         txlen = cdb[4] ? cdb[4] : 256;
  43
  44         trace_seq_printf(p, "lba=%u txlen=%u", lba, txlen);
  45         trace_seq_putc(p, 0);
  46
  47         return ret;
  48 }
  49
  50 static const char *
  51 scsi_trace_rw10(struct trace_seq *p, unsigned char *cdb, int len)
  52 {
  53         const char *ret = trace_seq_buffer_ptr(p);
  54         u32 lba, txlen;
  55
  56         lba = get_unaligned_be32(&cdb[2]);
  57         txlen = get_unaligned_be16(&cdb[7]);
  58
  59         trace_seq_printf(p, "lba=%u txlen=%u protect=%u", lba, txlen,
  60                          cdb[1] >> 5);
  61
  62         if (cdb[0] == WRITE_SAME)
  63                 trace_seq_printf(p, " unmap=%u", cdb[1] >> 3 & 1);
  64
  65         trace_seq_putc(p, 0);
  66
  67         return ret;
  68 }
  69
  70 static const char *
  71 scsi_trace_rw12(struct trace_seq *p, unsigned char *cdb, int len)
  72 {
  73         const char *ret = trace_seq_buffer_ptr(p);
  74         u32 lba, txlen;
  75
  76         lba = get_unaligned_be32(&cdb[2]);
  77         txlen = get_unaligned_be32(&cdb[6]);
  78
  79         trace_seq_printf(p, "lba=%u txlen=%u protect=%u", lba, txlen,
  80                          cdb[1] >> 5);
  81         trace_seq_putc(p, 0);
  82
  83         return ret;
  84 }
  85
  86 static const char *
  87 scsi_trace_rw16(struct trace_seq *p, unsigned char *cdb, int len)
  88 {
  89         const char *ret = trace_seq_buffer_ptr(p);
  90         u64 lba;
  91         u32 txlen;
  92
  93         lba = get_unaligned_be64(&cdb[2]);
  94         txlen = get_unaligned_be32(&cdb[10]);
  95
  96         trace_seq_printf(p, "lba=%llu txlen=%u protect=%u", lba, txlen,
  97                          cdb[1] >> 5);
  98
  99         if (cdb[0] == WRITE_SAME_16)
 100                 trace_seq_printf(p, " unmap=%u", cdb[1] >> 3 & 1);
 101
 102         trace_seq_putc(p, 0);
 103
 104         return ret;
 105 }
 106
 107 static const char *
 108 scsi_trace_rw32(struct trace_seq *p, unsigned char *cdb, int len)
 109 {
 110         const char *ret = trace_seq_buffer_ptr(p), *cmd;
 111         u64 lba;
 112         u32 ei_lbrt, txlen;
 113
 114         switch (SERVICE_ACTION32(cdb)) {
 115         case READ_32:
 116                 cmd = "READ";
 117                 break;
 118         case VERIFY_32:
 119                 cmd = "VERIFY";
 120                 break;
 121         case WRITE_32:
 122                 cmd = "WRITE";
 123                 break;
 124         case WRITE_SAME_32:
 125                 cmd = "WRITE_SAME";
 126                 break;
 127         default:
 128                 trace_seq_puts(p, "UNKNOWN");
 129                 goto out;
 130         }
 131
 132         lba = get_unaligned_be64(&cdb[12]);
 133         ei_lbrt = get_unaligned_be32(&cdb[20]);
 134         txlen = get_unaligned_be32(&cdb[28]);
 135
 136         trace_seq_printf(p, "%s_32 lba=%llu txlen=%u protect=%u ei_lbrt=%u",
 137                          cmd, lba, txlen, cdb[10] >> 5, ei_lbrt);
 138
 139         if (SERVICE_ACTION32(cdb) == WRITE_SAME_32)
 140                 trace_seq_printf(p, " unmap=%u", cdb[10] >> 3 & 1);
 141
 142 out:
 143         trace_seq_putc(p, 0);
 144
 145         return ret;
 146 }
 147
 148 static const char *
 149 scsi_trace_unmap(struct trace_seq *p, unsigned char *cdb, int len)
 150 {
 151         const char *ret = trace_seq_buffer_ptr(p);
 152         unsigned int regions = get_unaligned_be16(&cdb[7]);
 153
 154         trace_seq_printf(p, "regions=%u", (regions - 8) / 16);
 155         trace_seq_putc(p, 0);
 156
 157         return ret;
 158 }
 159
 160 static const char *
 161 scsi_trace_service_action_in(struct trace_seq *p, unsigned char *cdb, int len)
 162 {
 163         const char *ret = trace_seq_buffer_ptr(p), *cmd;
 164         u64 lba;
 165         u32 alloc_len;
 166
 167         switch (SERVICE_ACTION16(cdb)) {
 168         case SAI_READ_CAPACITY_16:
 169                 cmd = "READ_CAPACITY_16";
 170                 break;
 171         case SAI_GET_LBA_STATUS:
 172                 cmd = "GET_LBA_STATUS";
 173                 break;
 174         default:
 175                 trace_seq_puts(p, "UNKNOWN");
 176                 goto out;
 177         }
 178
 179         lba = get_unaligned_be64(&cdb[2]);
 180         alloc_len = get_unaligned_be32(&cdb[10]);
 181
 182         trace_seq_printf(p, "%s lba=%llu alloc_len=%u", cmd, lba, alloc_len);
 183
 184 out:
 185         trace_seq_putc(p, 0);
 186
 187         return ret;
 188 }
 189
 190 static const char *
 191 scsi_trace_varlen(struct trace_seq *p, unsigned char *cdb, int len)
 192 {
 193         switch (SERVICE_ACTION32(cdb)) {
 194         case READ_32:
 195         case VERIFY_32:
 196         case WRITE_32:
 197         case WRITE_SAME_32:
 198                 return scsi_trace_rw32(p, cdb, len);
 199         default:
 200                 return scsi_trace_misc(p, cdb, len);
 201         }
 202 }
 203
 204 static const char *
 205 scsi_trace_misc(struct trace_seq *p, unsigned char *cdb, int len)
 206 {
 207         const char *ret = trace_seq_buffer_ptr(p);
 208
 209         trace_seq_putc(p, '-');
 210         trace_seq_putc(p, 0);
 211
 212         return ret;
 213 }
 214
 215 const char *
 216 scsi_trace_parse_cdb(struct trace_seq *p, unsigned char *cdb, int len)
 217 {
 218         switch (cdb[0]) {
 219         case READ_6:
 220         case WRITE_6:
 221                 return scsi_trace_rw6(p, cdb, len);
 222         case READ_10:
 223         case VERIFY:
 224         case WRITE_10:
 225         case WRITE_SAME:
 226                 return scsi_trace_rw10(p, cdb, len);
 227         case READ_12:
 228         case VERIFY_12:
 229         case WRITE_12:
 230                 return scsi_trace_rw12(p, cdb, len);
 231         case READ_16:
 232         case VERIFY_16:
 233         case WRITE_16:
 234         case WRITE_SAME_16:
 235                 return scsi_trace_rw16(p, cdb, len);
 236         case UNMAP:
 237                 return scsi_trace_unmap(p, cdb, len);
 238         case SERVICE_ACTION_IN_16:
 239                 return scsi_trace_service_action_in(p, cdb, len);
 240         case VARIABLE_LENGTH_CMD:
 241                 return scsi_trace_varlen(p, cdb, len);
 242         default:
 243                 return scsi_trace_misc(p, cdb, len);
 244         }
 245 }