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_read_write(struct trace_seq *p, u8 *cdw10) 37 { 38 const char *ret = trace_seq_buffer_ptr(p); 39 u64 slba = get_unaligned_le64(cdw10); 40 u16 length = get_unaligned_le16(cdw10 + 8); 41 u16 control = get_unaligned_le16(cdw10 + 10); 42 u32 dsmgmt = get_unaligned_le32(cdw10 + 12); 43 u32 reftag = get_unaligned_le32(cdw10 + 16); 44 45 trace_seq_printf(p, 46 "slba=%llu, len=%u, ctrl=0x%x, dsmgmt=%u, reftag=%u", 47 slba, length, control, dsmgmt, reftag); 48 trace_seq_putc(p, 0); 49 50 return ret; 51 } 52 53 static const char *nvmet_trace_dsm(struct trace_seq *p, u8 *cdw10) 54 { 55 const char *ret = trace_seq_buffer_ptr(p); 56 57 trace_seq_printf(p, "nr=%u, attributes=%u", 58 get_unaligned_le32(cdw10), 59 get_unaligned_le32(cdw10 + 4)); 60 trace_seq_putc(p, 0); 61 62 return ret; 63 } 64 65 static const char *nvmet_trace_common(struct trace_seq *p, u8 *cdw10) 66 { 67 const char *ret = trace_seq_buffer_ptr(p); 68 69 trace_seq_printf(p, "cdw10=%*ph", 24, cdw10); 70 trace_seq_putc(p, 0); 71 72 return ret; 73 } 74 75 const char *nvmet_trace_parse_admin_cmd(struct trace_seq *p, 76 u8 opcode, u8 *cdw10) 77 { 78 switch (opcode) { 79 case nvme_admin_identify: 80 return nvmet_trace_admin_identify(p, cdw10); 81 case nvme_admin_get_features: 82 return nvmet_trace_admin_get_features(p, cdw10); 83 default: 84 return nvmet_trace_common(p, cdw10); 85 } 86 } 87 88 const char *nvmet_trace_parse_nvm_cmd(struct trace_seq *p, 89 u8 opcode, u8 *cdw10) 90 { 91 switch (opcode) { 92 case nvme_cmd_read: 93 case nvme_cmd_write: 94 case nvme_cmd_write_zeroes: 95 return nvmet_trace_read_write(p, cdw10); 96 case nvme_cmd_dsm: 97 return nvmet_trace_dsm(p, cdw10); 98 default: 99 return nvmet_trace_common(p, cdw10); 100 } 101 } 102 103 static const char *nvmet_trace_fabrics_property_set(struct trace_seq *p, 104 u8 *spc) 105 { 106 const char *ret = trace_seq_buffer_ptr(p); 107 u8 attrib = spc[0]; 108 u32 ofst = get_unaligned_le32(spc + 4); 109 u64 value = get_unaligned_le64(spc + 8); 110 111 trace_seq_printf(p, "attrib=%u, ofst=0x%x, value=0x%llx", 112 attrib, ofst, value); 113 trace_seq_putc(p, 0); 114 return ret; 115 } 116 117 static const char *nvmet_trace_fabrics_connect(struct trace_seq *p, 118 u8 *spc) 119 { 120 const char *ret = trace_seq_buffer_ptr(p); 121 u16 recfmt = get_unaligned_le16(spc); 122 u16 qid = get_unaligned_le16(spc + 2); 123 u16 sqsize = get_unaligned_le16(spc + 4); 124 u8 cattr = spc[6]; 125 u32 kato = get_unaligned_le32(spc + 8); 126 127 trace_seq_printf(p, "recfmt=%u, qid=%u, sqsize=%u, cattr=%u, kato=%u", 128 recfmt, qid, sqsize, cattr, kato); 129 trace_seq_putc(p, 0); 130 return ret; 131 } 132 133 static const char *nvmet_trace_fabrics_property_get(struct trace_seq *p, 134 u8 *spc) 135 { 136 const char *ret = trace_seq_buffer_ptr(p); 137 u8 attrib = spc[0]; 138 u32 ofst = get_unaligned_le32(spc + 4); 139 140 trace_seq_printf(p, "attrib=%u, ofst=0x%x", attrib, ofst); 141 trace_seq_putc(p, 0); 142 return ret; 143 } 144 145 static const char *nvmet_trace_fabrics_common(struct trace_seq *p, u8 *spc) 146 { 147 const char *ret = trace_seq_buffer_ptr(p); 148 149 trace_seq_printf(p, "specific=%*ph", 24, spc); 150 trace_seq_putc(p, 0); 151 return ret; 152 } 153 154 const char *nvmet_trace_parse_fabrics_cmd(struct trace_seq *p, 155 u8 fctype, u8 *spc) 156 { 157 switch (fctype) { 158 case nvme_fabrics_type_property_set: 159 return nvmet_trace_fabrics_property_set(p, spc); 160 case nvme_fabrics_type_connect: 161 return nvmet_trace_fabrics_connect(p, spc); 162 case nvme_fabrics_type_property_get: 163 return nvmet_trace_fabrics_property_get(p, spc); 164 default: 165 return nvmet_trace_fabrics_common(p, spc); 166 } 167 } 168 169 const char *nvmet_trace_disk_name(struct trace_seq *p, char *name) 170 { 171 const char *ret = trace_seq_buffer_ptr(p); 172 173 if (*name) 174 trace_seq_printf(p, "disk=%s, ", name); 175 trace_seq_putc(p, 0); 176 177 return ret; 178 } 179 180 const char *nvmet_trace_ctrl_name(struct trace_seq *p, struct nvmet_ctrl *ctrl) 181 { 182 const char *ret = trace_seq_buffer_ptr(p); 183 184 /* 185 * XXX: We don't know the controller instance before executing the 186 * connect command itself because the connect command for the admin 187 * queue will not provide the cntlid which will be allocated in this 188 * command. In case of io queues, the controller instance will be 189 * mapped by the extra data of the connect command. 190 * If we can know the extra data of the connect command in this stage, 191 * we can update this print statement later. 192 */ 193 if (ctrl) 194 trace_seq_printf(p, "%d", ctrl->cntlid); 195 else 196 trace_seq_printf(p, "_"); 197 trace_seq_putc(p, 0); 198 199 return ret; 200 } 201 202