trace.c 5.5 KB

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