nvme-trace: Add support for fabrics command
Subsystems (3)
v5 cover nvme-trace: Add support for fabrics command
Hi all,
Here's a fifth patchset to support fabrics command tracing. The first patch updated host/trace module to a outside of it to provide common interfaces for host and target both. The second one adds support for tracing fabrics command from host-side. The third is a trivial clean-up for providing a helper function to figure out given command structure is for fabrics or not.
The fourth and fifth are the major change points of this patchset. 4th patch adds request tracing from the target-side. 5th updated, of course, completion of given request.
Tihs series has been reviewed by V3, but I didn't like the additional argument frmo the caller side like NVME_TRACE_[HOST|TARGET]. V4 introduces it without additional argument, but it has an work-around not to make them have additional arguments in caller level.
Please review.
Thanks,
Changes to V4:
- Add Reviewed-by: tag from Sagi. (Thanks to Sagi)
- Consider endianness for cqe->status when assigning the value in trace
- Add more descriptions about the variable arguments in events.
Changes to V3:
- Remove additional argument from the caller level.
Changes to V2:
- Provide a common code for both host and target. (Chaitanya)
- Add support for tracing requests in target-side (Chaitanya)
- Make it simple in trace.h without branch out from nvme core module (Christoph)
Changes to V1:
- fabrics commands should also be decoded, not just showing that it's a fabrics command. (Christoph)
- do not make it within nvme admin commands (Chaitanya)
Minwoo Im (5):
nvme: Make trace common for host and target both
nvme-trace: Support tracing fabrics commands from host-side
nvme: Introduce nvme_is_fabrics to check fabrics cmd
nvme-trace: Add tracing for req_init in target
nvme-trace: Add tracing for req_comp in target
MAINTAINERS | 2 +
drivers/nvme/Makefile | 3 +
drivers/nvme/host/Makefile | 1 -
drivers/nvme/host/core.c | 3 +-
drivers/nvme/host/fabrics.c | 2 +-
drivers/nvme/host/pci.c | 2 +-
drivers/nvme/target/core.c | 8 +-
drivers/nvme/target/fabrics-cmd.c | 2 +-
drivers/nvme/target/fc.c | 2 +-
drivers/nvme/target/nvmet.h | 9 ++
drivers/nvme/{host => }/trace.c | 75 +++++++++++++++
drivers/nvme/{host => }/trace.h | 154 +++++++++++++++++++++++++-----
include/linux/nvme.h | 7 +-
13 files changed, 237 insertions(+), 33 deletions(-)
rename drivers/nvme/{host => }/trace.c (65%)
rename drivers/nvme/{host => }/trace.h (57%)Signature · 1 line
2.21.0
PATCH v5 1/5 nvme: Make trace common for host and target both
To support target-side trace, nvme-trace should be commonized for host and target both. Of course, not every single tracepoints are necessary by both of them, but we don't need to have more than one trace module for host and target.
---
MAINTAINERS | 2 ++
drivers/nvme/Makefile | 3 +++
drivers/nvme/host/Makefile | 1 -
drivers/nvme/host/core.c | 3 +--
drivers/nvme/host/pci.c | 2 +-
drivers/nvme/{host => }/trace.c | 5 +++++
drivers/nvme/{host => }/trace.h | 2 +-
7 files changed, 13 insertions(+), 5 deletions(-)
rename drivers/nvme/{host => }/trace.c (95%)
rename drivers/nvme/{host => }/trace.h (99%)MAINTAINERS +2 -0
@@ -11235,6 +11235,7 @@ L: linux-nvme at lists.infradead.org T: git://git.infradead.org/nvme.git W: http://git.infradead.org/nvme.git S: Supported +F: drivers/nvme/ F: drivers/nvme/host/ F: include/linux/nvme.h F: include/uapi/linux/nvme_ioctl.h
@@ -11256,6 +11257,7 @@ L: linux-nvme at lists.infradead.org T: git://git.infradead.org/nvme.git W: http://git.infradead.org/nvme.git S: Supported +F: drivers/nvme/ F: drivers/nvme/target/ NVMEM FRAMEWORK
drivers/nvme/Makefile +3 -0
@@ -1,3 +1,6 @@ +ccflags-y += -I$(src) +obj-$(CONFIG_TRACING) += trace.o + obj-y += host/ obj-y += target/
drivers/nvme/host/Makefile +0 -1
@@ -10,7 +10,6 @@ obj-$(CONFIG_NVME_FC) += nvme-fc.o obj-$(CONFIG_NVME_TCP) += nvme-tcp.o nvme-core-y := core.o -nvme-core-$(CONFIG_TRACING) += trace.o nvme-core-$(CONFIG_NVME_MULTIPATH) += multipath.o nvme-core-$(CONFIG_NVM) += lightnvm.o nvme-core-$(CONFIG_FAULT_INJECTION_DEBUG_FS) += fault_inject.o
drivers/nvme/host/core.c +1 -2
@@ -21,8 +21,7 @@#include <linux/pm_qos.h> #include <asm/unaligned.h> -#define CREATE_TRACE_POINTS -#include "trace.h" +#include "../trace.h" #include "nvme.h" #include "fabrics.h"
drivers/nvme/host/pci.c +1 -1
@@ -24,7 +24,7 @@#include <linux/sed-opal.h> #include <linux/pci-p2pdma.h> -#include "trace.h" +#include "../trace.h" #include "nvme.h" #define SQ_SIZE (depth) (depth * sizeof(struct nvme_command))
drivers/nvme/trace.c renamed from drivers/nvme/host/trace.c +5 -0
@@ -5,6 +5,8 @@*/ #include <asm/unaligned.h> + +#define CREATE_TRACE_POINTS #include "trace.h" static const char *nvme_trace_create_sq (struct trace_seq *p,u8 *cdw10)
@@ -147,4 +149,7 @@ const char *nvme_trace_disk_name(struct trace_seq *p, char *name) }EXPORT_SYMBOL_GPL (nvme_trace_disk_name); +EXPORT_TRACEPOINT_SYMBOL_GPL (nvme_setup_cmd); +EXPORT_TRACEPOINT_SYMBOL_GPL (nvme_complete_rq); +EXPORT_TRACEPOINT_SYMBOL_GPL (nvme_async_event);EXPORT_TRACEPOINT_SYMBOL_GPL (nvme_sq);
drivers/nvme/trace.h renamed from drivers/nvme/host/trace.h +1 -1
@@ -14,7 +14,7 @@#include <linux/tracepoint.h> #include <linux/trace_seq.h> -#include "nvme.h" +#include "host/nvme.h" #define nvme_admin_opcode_name (opcode) { opcode, #opcode }#define show_admin_opcode_name (val) \
Signature · 1 line
2.21.0
Christoph Hellwig
maintainerPATCH v5 1/5 nvme: Make trace common for host and target both
drivers/nvme/Makefile line 3
Quoted 8 lines
drivers/nvme/Makefile +2
-0@@ -1,3 +1,6 @@ +ccflags-y += -I$(src) +obj-$(CONFIG_TRACING) += trace.o
this will always build the file into the kernel if CONFIG_TRACING, even if no nvme code is enabled.
And looking at the later patches I don't even think this sharing is worth it, as the actual trace points are pretty different.
I'd much prefer to have different implementations for host vs target for now instead of introducing a common library. Maybe we could revisit that later if we end up having a lot of shared code.
PATCH v5 1/5 nvme: Make trace common for host and target both
Quoted 11 lines · Christoph Hellwig
drivers/nvme/Makefile line 3
Quoted 8 lines
drivers/nvme/Makefile +2
-0@@ -1,3 +1,6 @@ +ccflags-y += -I$(src) +obj-$(CONFIG_TRACING) += trace.othis will always build the file into the kernel if
CONFIG_TRACING, even if no nvme code is enabled.
Oh, thanks to point it out.
Quoted 2 lines
And looking at the later patches I don't even think this sharing is worth it, as the actual trace points are pretty different.
That's why this patch series introduces DECLARE_EVENT_CLASS as a template, and gives different events for it by DEFINE_EVENT.
Quoted 4 lines
I'd much prefer to have different implementations for host vs target for now instead of introducing a common library. Maybe we could revisit that later if we end up having a lot of shared code.
As you know, nvmet handles not only nvme fabrics commands, but normal commands in nvmet_req_init() and nvmet_req_complete(). Which means that we already have a lot of shared codes in parsing point of view.
The host/trace.c provides parsing admin commands which can be used by nvmet also. I guess it's enough to be shared for host and target both.
I hope you can correct me if I missed someting here.
Thanks, Christoph.
Christoph Hellwig
maintainerPATCH v5 1/5 nvme: Make trace common for host and target both
Quoted 4 lines · Minwoo Im
Quoted 3 lines
I'd much prefer to have different implementations for host vs target for now instead of introducing a common library. Maybe we could revisit that later if we end up having a lot of shared code.
Quoted 8 lines
As you know, nvmet handles not only nvme fabrics commands, but normal commands in
nvmet_req_init()andnvmet_req_complete(). Which means that we already have a lot of shared codes in parsing point of view.The
host/trace.cprovides parsing admin commands which can be used by nvmet also. I guess it's enough to be shared for host and target both.I hope you can correct me if I missed someting here.
I'm not against sharing per se, but I'm really worried about either building that code in the core kernel, or even just a new module, as that'll waste at least 8k and will cause more cache misses when tracing. So for now my preference would be to just duplicate the code at least at the binary level.
PATCH v5 1/5 nvme: Make trace common for host and target both
Quoted 12 lines · Christoph Hellwig
Quoted 11 lines · Minwoo Im
Quoted 3 lines
I'd much prefer to have different implementations for host vs target for now instead of introducing a common library. Maybe we could revisit that later if we end up having a lot of shared code.
As you know, nvmet handles not only nvme fabrics commands, but normal commands in
nvmet_req_init()andnvmet_req_complete(). Which means that we already have a lot of shared codes in parsing point of view.The
host/trace.cprovides parsing admin commands which can be used by nvmet also. I guess it's enough to be shared for host and target both.
Quoted 7 lines
Quoted 1 line
I hope you can correct me if I missed someting here.
I'm not against sharing per se, but I'm really worried about either building that code in the core kernel, or even just a new module, as that'll waste at least 8k and will cause more cache misses when tracing. So for now my preference would be to just duplicate the code at least at the binary level.
If that factor that you mentioned is much more important than the code duplications, I can make them duplicated.
I'll prepare the next version based on your suggestion. Once it gets done, Please give some comments on that.
Thanks, again for letting me think of this point of view.
Sagi Grimberg
maintainerPATCH v5 1/5 nvme: Make trace common for host and target both
Quoted 20 lines
Quoted 12 lines
Quoted 12 lines
Quoted 4 lines
I'd much prefer to have different implementations for host vs target for now instead of introducing a common library. Maybe we could revisit that later if we end up having a lot of shared code.
As you know, nvmet handles not only nvme fabrics commands, but normal commands in
nvmet_req_init()andnvmet_req_complete(). Which means that we already have a lot of shared codes in parsing point of view.The
host/trace.cprovides parsing admin commands which can be used by nvmet also. I guess it's enough to be shared for host and target both.Quoted 7 lines
Quoted 1 line
I hope you can correct me if I missed someting here.
I'm not against sharing per se, but I'm really worried about either building that code in the core kernel, or even just a new module, as that'll waste at least 8k and will cause more cache misses when tracing. So for now my preference would be to just duplicate the code at least at the binary level.
Quoted 4 lines
If that factor that you mentioned is much more important than the code duplications, I can make them duplicated.
I'll prepare the next version based on your suggestion.
Makes sense to me
PATCH v5 2/5 nvme-trace: Support tracing fabrics commands from host-side
In reply to Minwoo ImThis patch adds support for tracing fabrics commands detected from host-side. We can have trace_nvme_setup_cmd for nvme and nvme fabrics both even fabrics submission queue entry does not have valid fields in where nvme's fields are valid.
This patch modifies existing parse_nvme_cmd to have fctype as an argument to support fabrics command which will be ignored in case of nvme common case.
--- drivers/nvme/trace.c | 67 ++++++++++++++++++++++++++++++++++++++++++++ drivers/nvme/trace.h | 41 +++++++++++++++++++++------ 2 files changed, 100 insertions(+), 8 deletions(-)
drivers/nvme/trace.c +67 -0
@@ -137,6 +137,73 @@ const char *nvme_trace_parse_nvm_cmd(struct trace_seq *p, } } +static const char *nvme_trace_fabrics_property_set (struct trace_seq *p,u8 *spc) +{ +const char *ret =trace_seq_buffer_ptr (p); +u8 attrib = spc[0 ]; +u32 ofst =get_unaligned_le32 (spc +4 ); +u64 value =get_unaligned_le64 (spc +8 ); + +trace_seq_printf (p,"attrib=%u, ofst=0x%x, value=0x%llx" , + attrib, ofst, value); +trace_seq_putc (p,0 ); + +return ret; +} + +static const char *nvme_trace_fabrics_connect (struct trace_seq *p,u8 *spc) +{ +const char *ret =trace_seq_buffer_ptr (p); +u16 recfmt =get_unaligned_le16 (spc); +u16 qid =get_unaligned_le16 (spc +2 ); +u16 sqsize =get_unaligned_le16 (spc +4 ); +u8 cattr = spc[6 ]; +u32 kato =get_unaligned_le32 (spc +8 ); + +trace_seq_printf (p,"recfmt=%u, qid=%u, sqsize=%u, cattr=%u, kato=%u" , + recfmt, qid, sqsize, cattr, kato); +trace_seq_putc (p,0 ); + +return ret; +} + +static const char *nvme_trace_fabrics_property_get (struct trace_seq *p,u8 *spc) +{ +const char *ret =trace_seq_buffer_ptr (p); +u8 attrib = spc[0 ]; +u32 ofst =get_unaligned_le32 (spc +4 ); + +trace_seq_printf (p,"attrib=%u, ofst=0x%x" , attrib, ofst); +trace_seq_putc (p,0 ); + +return ret; +} + +static const char *nvme_trace_fabrics_common (struct trace_seq *p,u8 *spc) +{ +const char *ret =trace_seq_buffer_ptr (p); + +trace_seq_printf (p,"spcecific=%*ph" ,24 , spc); +trace_seq_putc (p,0 ); + +return ret; +} + +const char *nvme_trace_parse_fabrics_cmd (struct trace_seq *p, +u8 fctype,u8 *spc) +{ +switch (fctype) { +case nvme_fabrics_type_property_set: +return nvme_trace_fabrics_property_set (p, spc); +case nvme_fabrics_type_connect: +return nvme_trace_fabrics_connect (p, spc); +case nvme_fabrics_type_property_get: +return nvme_trace_fabrics_property_get (p, spc); +default : +return nvme_trace_fabrics_common (p, spc); + } +} +const char *nvme_trace_disk_name (struct trace_seq *p,char *name) {const char *ret =trace_seq_buffer_ptr (p);
drivers/nvme/trace.h +33 -8
71 lines not on this page · raw message
Signature · 1 line
2.21.0
PATCH v5 3/5 nvme: Introduce nvme_is_fabrics to check fabrics cmd
In reply to Minwoo ImThis patch introduce a nvme_is_fabrics() inline function to check whether or not the given command structure is for fabrics.
--- drivers/nvme/host/fabrics.c | 2 +- drivers/nvme/target/core.c | 2 +- drivers/nvme/target/fabrics-cmd.c | 2 +- drivers/nvme/target/fc.c | 2 +- include/linux/nvme.h | 7 ++++++- 5 files changed, 10 insertions(+), 5 deletions(-)
drivers/nvme/host/fabrics.c +1 -1
@@ -578,7 +578,7 @@ bool __nvmf_check_ready(struct nvme_ctrl *ctrl, struct request *rq,switch (ctrl->state) {case NVME_CTRL_NEW :case NVME_CTRL_CONNECTING : -if (req->cmd->common.opcode == nvme_fabrics_command && +if (nvme_is_fabrics (req->cmd) && req->cmd->fabrics.fctype == nvme_fabrics_type_connect)return true;break ;
drivers/nvme/target/core.c +1 -1
@@ -871,7 +871,7 @@ bool nvmet_req_init(struct nvmet_req *req, struct nvmet_cq *cq, status =nvmet_parse_connect_cmd (req); else if (likely(req->sq->qid != 0)) status =nvmet_parse_io_cmd (req); - else if (req->cmd->common.opcode == nvme_fabrics_command) + else if (nvme_is_fabrics(req->cmd)) status =nvmet_parse_fabrics_cmd (req); else if (req->sq->ctrl->subsys->type == NVME_NQN_DISC) status =nvmet_parse_discovery_cmd (req);
drivers/nvme/target/fabrics-cmd.c +1 -1
@@ -268,7 +268,7 @@ u16 nvmet_parse_connect_cmd(struct nvmet_req *req) {struct nvme_command *cmd = req->cmd; -if (cmd->common.opcode != nvme_fabrics_command) { +if (!nvme_is_fabrics (cmd)) {pr_err ("invalid command 0x%x on unconnected queue.\n" , cmd->fabrics.opcode); req->error_loc = offsetof(struct nvme_common_command , opcode);
drivers/nvme/target/fc.c +1 -1
@@ -1806,7 +1806,7 @@ nvmet_fc_prep_fcp_rsp(struct nvmet_fc_tgtport *tgtport,*/ rspcnt =atomic_inc_return (&fod->queue->zrspcnt); if (!(rspcnt % fod->queue->ersp_ratio) || - sqe->opcode == nvme_fabrics_command || + nvme_is_fabrics((struct nvme_command *) sqe) || xfr_length != fod->req.transfer_len || (le16_to_cpu(cqe->status) & 0xFFFE) || cqewd[0] || cqewd[1] || (sqe->flags & (NVME_CMD_FUSE_FIRST | NVME_CMD_FUSE_SECOND)) ||
include/linux/nvme.h +6 -1
@@ -1165,6 +1165,11 @@ struct nvme_command { }; }; +static inline bool nvme_is_fabrics (struct nvme_command *cmd) +{ +return cmd->common.opcode == nvme_fabrics_command; +} +struct nvme_error_slot {__le64 error_count;__le16 sqid;
@@ -1186,7 +1191,7 @@ static inline bool nvme_is_write(struct nvme_command *cmd)* * Why can't we simply have a Fabrics In and Fabrics out command? */ -if (unlikely (cmd->common.opcode == nvme_fabrics_command)) +if (unlikely (nvme_is_fabrics (cmd)))return cmd->fabrics.fctype &1 ;return cmd->common.opcode &1 ; }
Signature · 1 line
2.21.0
PATCH v5 4/5 nvme-trace: Add tracing for req_init in target
In reply to Minwoo ImWe can have the common tracing code with different event entries.
- nvme_setup_cmd
- nvmet_req_init
This patch updates existing TRACE_EVENT to a template to provide a common tracing interface. More than that, nvme_setup_cmd entry point has been defined as an event referring template made.
It also introduces tracing at the point of request creation for the target system. This might be useful to figure out what kind of request has been received in the target.
The DEFINE_EVENT has a prototype with variable arguments "...". It's because I don't want to add an additional argument to the caller side. We need the type of the trace events between host and target to reuse the common side code which is trace.h.
Here's the example of target tracing introduced with RDMA:
kworker/0:1H-1043 [000] .... 276.785946: nvmet_req_init: nvme0: qid=0, cmdid=0, nsid=1, flags=0x40, meta=0x0, cmd=(nvme_fabrics_type_connect recfmt=0, qid=0, sqsize=31, cattr=0, kato=0) kworker/0:1H-1043 [000] .... 276.789893: nvmet_req_init: nvme1: qid=0, cmdid=10, nsid=4, flags=0x40, meta=0x0, cmd=(nvme_fabrics_type_property_get attrib=1, ofst=0x0) kworker/0:1H-1043 [000] .... 276.791781: nvmet_req_init: nvme1: qid=0, cmdid=11, nsid=0, flags=0x40, meta=0x0, cmd=(nvme_fabrics_type_property_set attrib=0, ofst=0x14, value=0x460001) kworker/0:1H-1043 [000] .... 276.794799: nvmet_req_init: nvme1: qid=0, cmdid=12, nsid=4, flags=0x40, meta=0x0, cmd=(nvme_fabrics_type_property_get attrib=0, ofst=0x1c) kworker/0:1H-1043 [000] .... 276.796804: nvmet_req_init: nvme1: qid=0, cmdid=13, nsid=4, flags=0x40, meta=0x0, cmd=(nvme_fabrics_type_property_get attrib=0, ofst=0x8) kworker/0:1H-1043 [000] .... 276.799163: nvmet_req_init: nvme1: qid=0, cmdid=10, nsid=4, flags=0x40, meta=0x0, cmd=(nvme_fabrics_type_property_get attrib=1, ofst=0x0) kworker/0:1H-1043 [000] .... 276.801070: nvmet_req_init: nvme1: qid=0, cmdid=11, nsid=0, flags=0x40, meta=0x0, cmd=(nvme_admin_identify cns=1, ctrlid=0) kworker/0:1H-1043 [000] .... 276.817592: nvmet_req_init: nvme1: qid=0, cmdid=12, nsid=0, flags=0x40, meta=0x0, cmd=(nvme_admin_get_log_page cdw10=70 00 03 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00) kworker/0:1H-1043 [000] .... 276.822963: nvmet_req_init: nvme1: qid=0, cmdid=13, nsid=0, flags=0x40, meta=0x0, cmd=(nvme_admin_get_log_page cdw10=70 00 ff 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00) kworker/0:1H-1043 [000] .... 276.831908: nvmet_req_init: nvme1: qid=0, cmdid=10, nsid=0, flags=0x40, meta=0x0, cmd=(nvme_admin_get_log_page cdw10=70 00 03 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00)
--- drivers/nvme/target/core.c | 3 ++ drivers/nvme/target/nvmet.h | 9 ++++++ drivers/nvme/trace.c | 2 ++ drivers/nvme/trace.h | 60 +++++++++++++++++++++++++++++++++---- 4 files changed, 69 insertions(+), 5 deletions(-)
drivers/nvme/target/core.c +3 -0
@@ -10,6 +10,7 @@#include <linux/pci-p2pdma.h> #include <linux/scatterlist.h> +#include "../trace.h" #include "nvmet.h" struct workqueue_struct *buffered_io_wq;
@@ -848,6 +849,8 @@ bool nvmet_req_init(struct nvmet_req *req, struct nvmet_cq *cq, req->error_loc =NVMET_NO_ERROR_LOC ; req->error_slba =0 ; +trace_nvmet_req_init (req, req->cmd); +/* no support for fused commands yet */ if (unlikely (flags & (NVME_CMD_FUSE_FIRST |NVME_CMD_FUSE_SECOND ))) { req->error_loc = offsetof(struct nvme_common_command , flags);
drivers/nvme/target/nvmet.h +9 -0
@@ -318,6 +318,15 @@ struct nvmet_req {u64 error_slba; }; +static inline struct nvmet_ctrl *nvmet_req_to_ctrl (struct nvmet_req *req) +{ +struct nvmet_sq *sq = req->sq; + +if (sq) +return sq->ctrl; +return NULL ; +} +extern struct workqueue_struct *buffered_io_wq;static inline void nvmet_set_result (struct nvmet_req *req,u32 result)
drivers/nvme/trace.c +2 -0
@@ -220,3 +220,5 @@ EXPORT_TRACEPOINT_SYMBOL_GPL(nvme_setup_cmd);EXPORT_TRACEPOINT_SYMBOL_GPL (nvme_complete_rq);EXPORT_TRACEPOINT_SYMBOL_GPL (nvme_async_event);EXPORT_TRACEPOINT_SYMBOL_GPL (nvme_sq); + +EXPORT_TRACEPOINT_SYMBOL_GPL (nvmet_req_init);
drivers/nvme/trace.h +55 -5
94 lines not on this page · raw message
Signature · 1 line
2.21.0
PATCH v5 5/5 nvme-trace: Add tracing for req_comp in target
In reply to Minwoo ImWe can have the common tracing code with different event entries.
- nvme_complete_rq
- nvmet_req_complete
This patch updates existing TRACE_EVENT to a template to provide a common tracing interface.
We can have it as a common code because most of the fields need to be printed out for both host and target system.
--- drivers/nvme/target/core.c | 3 +++ drivers/nvme/trace.c | 1 + drivers/nvme/trace.h | 51 ++++++++++++++++++++++++++++++-------- 3 files changed, 45 insertions(+), 10 deletions(-)
drivers/nvme/target/core.c +3 -0
@@ -690,6 +690,9 @@ static void __nvmet_req_complete(struct nvmet_req *req, u16 status)if (unlikely (status))nvmet_set_error (req, status); + +trace_nvmet_req_complete (req); +if (req->ns)nvmet_put_namespace (req->ns); req->ops->queue_response (req);
drivers/nvme/trace.c +1 -0
@@ -222,3 +222,4 @@ EXPORT_TRACEPOINT_SYMBOL_GPL(nvme_async_event);EXPORT_TRACEPOINT_SYMBOL_GPL (nvme_sq);EXPORT_TRACEPOINT_SYMBOL_GPL (nvmet_req_init); +EXPORT_TRACEPOINT_SYMBOL_GPL (nvmet_req_complete);
drivers/nvme/trace.h +41 -10
71 lines not on this page · raw message
Signature · 1 line
2.21.0