ftl: I/O tracing

Adds tracepoints in FTL.

Signed-off-by: Artur Paszkiewicz <artur.paszkiewicz@intel.com>
Signed-off-by: Kozlowski Mateusz <mateusz.kozlowski@intel.com>
Change-Id: I661703e42b8b531822a2ba74a09cdc716daa1c46
Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/13391
Tested-by: SPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: Ben Walker <benjamin.walker@intel.com>
Reviewed-by: Jim Harris <james.r.harris@intel.com>

lib/ftl/Makefile

@@ -27,7 +27,7 @@ FTL_SUBDIRS := mngt utils upgrade
 
 C_SRCS = ftl_core.c ftl_init.c ftl_layout.c ftl_debug.c ftl_io.c ftl_sb.c ftl_l2p.c ftl_l2p_flat.c
 C_SRCS += ftl_nv_cache.c ftl_band.c ftl_band_ops.c ftl_writer.c ftl_rq.c ftl_reloc.c ftl_l2p_cache.c
-C_SRCS += ftl_p2l.c
+C_SRCS += ftl_p2l.c ftl_trace.c
 C_SRCS += mngt/ftl_mngt.c mngt/ftl_mngt_bdev.c mngt/ftl_mngt_shutdown.c mngt/ftl_mngt_startup.c
 C_SRCS += mngt/ftl_mngt_md.c mngt/ftl_mngt_misc.c mngt/ftl_mngt_ioch.c mngt/ftl_mngt_l2p.c
 C_SRCS += mngt/ftl_mngt_band.c mngt/ftl_mngt_self_test.c mngt/ftl_mngt_p2l.c

lib/ftl/ftl_core.c

@@ -38,6 +38,8 @@ ftl_io_cmpl_cb(struct spdk_bdev_io *bdev_io, bool success, void *cb_arg)
 		io->status = -EIO;
 	}
 
+	ftl_trace_completion(dev, io, FTL_TRACE_COMPLETION_DISK);
+
 	ftl_io_dec_req(io);
 	if (ftl_io_done(io)) {
 		ftl_io_complete(io);
@@ -129,6 +131,8 @@ ftl_apply_limits(struct spdk_ftl_dev *dev)
 			break;
 		}
 	}
+
+	ftl_trace_limits(dev, dev->limit, dev->num_free);
 }
 
 void
@@ -240,6 +244,8 @@ ftl_submit_read(struct ftl_io *io)
 
 		assert(num_blocks > 0);
 
+		ftl_trace_submission(dev, io, addr, num_blocks);
+
 		if (ftl_addr_in_nvc(dev, addr)) {
 			rc = ftl_nv_cache_read(io, addr, num_blocks, ftl_io_cmpl_cb, io);
 		} else {

lib/ftl/ftl_core.h

@@ -17,6 +17,7 @@
 
 #include "ftl_internal.h"
 #include "ftl_io.h"
+#include "ftl_trace.h"
 #include "ftl_nv_cache.h"
 #include "ftl_writer.h"
 #include "ftl_layout.h"
@@ -86,6 +87,9 @@ struct spdk_ftl_dev {
 	/* Band md memory pool */
 	struct ftl_mempool		*band_md_pool;
 
+	/* Traces */
+	struct ftl_trace		trace;
+
 	/* Statistics */
 	struct ftl_stats		stats;
 

lib/ftl/ftl_io.c

@@ -181,7 +181,9 @@ ftl_io_init(struct spdk_io_channel *_ioch, struct ftl_io *io, uint64_t lba, size
 	io->iov = iov;
 	io->iov_cnt = iov_cnt;
 	io->num_blocks = num_blocks;
+	io->trace = ftl_trace_alloc_id(dev);
 
+	ftl_trace_lba_io_init(io->dev, io);
 	return 0;
 }
 

lib/ftl/ftl_io.h

@@ -13,6 +13,7 @@
 #include "spdk/util.h"
 
 #include "ftl_internal.h"
+#include "ftl_trace.h"
 #include "ftl_l2p.h"
 #include "utils/ftl_md.h"
 
@@ -112,6 +113,9 @@ struct ftl_io {
 	/* Done flag */
 	bool				done;
 
+	/* Trace group id */
+	uint64_t			trace;
+
 	/* Used by retry and write completion queues */
 	TAILQ_ENTRY(ftl_io)		queue_entry;
 

lib/ftl/ftl_nv_cache.c

@@ -1061,6 +1061,8 @@ ftl_nv_cache_pin_cb(struct spdk_ftl_dev *dev, int status, struct ftl_l2p_pin_ctx
 
 	assert(io->iov_pos == 0);
 
+	ftl_trace_submission(io->dev, io, io->addr, io->num_blocks);
+
 	nv_cache_write(io);
 }
 

lib/ftl/ftl_trace.c

@@ -0,0 +1,254 @@
+/*   SPDX-License-Identifier: BSD-3-Clause
+ *   Copyright (c) Intel Corporation.
+ *   All rights reserved.
+ */
+
+#include "spdk/trace.h"
+#include "spdk_internal/trace_defs.h"
+
+#include "ftl_core.h"
+#include "ftl_trace.h"
+#include "ftl_io.h"
+#include "ftl_band.h"
+
+#if defined(DEBUG)
+
+enum ftl_trace_source {
+	FTL_TRACE_SOURCE_INTERNAL,
+	FTL_TRACE_SOURCE_USER,
+	FTL_TRACE_SOURCE_MAX,
+};
+
+#define FTL_TPOINT_ID(id, src) SPDK_TPOINT_ID(TRACE_GROUP_FTL, (((id) << 1) | (!!(src))))
+
+#define FTL_TRACE_BAND_RELOC(src)		FTL_TPOINT_ID(0, src)
+#define FTL_TRACE_BAND_WRITE(src)		FTL_TPOINT_ID(1, src)
+#define FTL_TRACE_LIMITS(src)			FTL_TPOINT_ID(2, src)
+#define FTL_TRACE_WBUF_POP(src)			FTL_TPOINT_ID(3, src)
+
+#define FTL_TRACE_READ_SCHEDULE(src)		FTL_TPOINT_ID(4, src)
+#define FTL_TRACE_READ_SUBMISSION(src)		FTL_TPOINT_ID(5, src)
+#define FTL_TRACE_READ_COMPLETION_INVALID(src)	FTL_TPOINT_ID(6, src)
+#define FTL_TRACE_READ_COMPLETION_CACHE(src)	FTL_TPOINT_ID(7, src)
+#define FTL_TRACE_READ_COMPLETION_DISK(src)	FTL_TPOINT_ID(8, src)
+
+#define FTL_TRACE_MD_READ_SCHEDULE(src)		FTL_TPOINT_ID(9,  src)
+#define FTL_TRACE_MD_READ_SUBMISSION(src)	FTL_TPOINT_ID(10, src)
+#define FTL_TRACE_MD_READ_COMPLETION(src)	FTL_TPOINT_ID(11, src)
+
+#define FTL_TRACE_WRITE_SCHEDULE(src)		FTL_TPOINT_ID(12, src)
+#define FTL_TRACE_WRITE_WBUF_FILL(src)		FTL_TPOINT_ID(13, src)
+#define FTL_TRACE_WRITE_SUBMISSION(src)		FTL_TPOINT_ID(14, src)
+#define FTL_TRACE_WRITE_COMPLETION(src)		FTL_TPOINT_ID(15, src)
+
+#define FTL_TRACE_MD_WRITE_SCHEDULE(src)	FTL_TPOINT_ID(16, src)
+#define FTL_TRACE_MD_WRITE_SUBMISSION(src)	FTL_TPOINT_ID(17, src)
+#define FTL_TRACE_MD_WRITE_COMPLETION(src)	FTL_TPOINT_ID(18, src)
+
+#define FTL_TRACE_UNMAP_SCHEDULE(src)		FTL_TPOINT_ID(19, src)
+#define FTL_TRACE_UNMAP_SUBMISSION(src)		FTL_TPOINT_ID(20, src)
+#define FTL_TRACE_UNMAP_COMPLETION(src)		FTL_TPOINT_ID(21, src)
+
+SPDK_TRACE_REGISTER_FN(ftl_trace_func, "ftl", TRACE_GROUP_FTL)
+{
+	const char source[] = { 'i', 'u' };
+	char descbuf[128];
+	int i;
+
+	spdk_trace_register_owner(OWNER_FTL, 'f');
+
+	for (i = 0; i < FTL_TRACE_SOURCE_MAX; ++i) {
+		snprintf(descbuf, sizeof(descbuf), "%c %s", source[i], "band_reloc");
+		spdk_trace_register_description(descbuf, FTL_TRACE_BAND_RELOC(i), OWNER_FTL, OBJECT_NONE, 0, 0,
+						"band: ");
+		snprintf(descbuf, sizeof(descbuf), "%c %s", source[i], "band_write");
+		spdk_trace_register_description(descbuf, FTL_TRACE_BAND_WRITE(i), OWNER_FTL, OBJECT_NONE, 0, 0,
+						"band: ");
+		snprintf(descbuf, sizeof(descbuf), "%c %s", source[i], "limits");
+		spdk_trace_register_description(descbuf, FTL_TRACE_LIMITS(i), OWNER_FTL, OBJECT_NONE, 0, 0,
+						"limits: ");
+		snprintf(descbuf, sizeof(descbuf), "%c %s", source[i], "rwb_pop");
+		spdk_trace_register_description(descbuf, FTL_TRACE_WBUF_POP(i), OWNER_FTL, OBJECT_NONE, 0, 0,
+						"lba: ");
+
+		snprintf(descbuf, sizeof(descbuf), "%c %s", source[i], "md_read_sched");
+		spdk_trace_register_description(descbuf, FTL_TRACE_MD_READ_SCHEDULE(i), OWNER_FTL, OBJECT_NONE, 0,
+						0, "addr: ");
+		snprintf(descbuf, sizeof(descbuf), "%c %s", source[i], "md_read_submit");
+		spdk_trace_register_description(descbuf, FTL_TRACE_MD_READ_SUBMISSION(i), OWNER_FTL, OBJECT_NONE, 0,
+						0, "addr: ");
+		snprintf(descbuf, sizeof(descbuf), "%c %s", source[i], "md_read_cmpl");
+		spdk_trace_register_description(descbuf, FTL_TRACE_MD_READ_COMPLETION(i), OWNER_FTL, OBJECT_NONE, 0,
+						0, "lba: ");
+
+		snprintf(descbuf, sizeof(descbuf), "%c %s", source[i], "md_write_sched");
+		spdk_trace_register_description(descbuf, FTL_TRACE_MD_WRITE_SCHEDULE(i), OWNER_FTL, OBJECT_NONE, 0,
+						0, "addr: ");
+		snprintf(descbuf, sizeof(descbuf), "%c %s", source[i], "md_write_submit");
+		spdk_trace_register_description(descbuf, FTL_TRACE_MD_WRITE_SUBMISSION(i), OWNER_FTL, OBJECT_NONE,
+						0, 0, "addr: ");
+		snprintf(descbuf, sizeof(descbuf), "%c %s", source[i], "md_write_cmpl");
+		spdk_trace_register_description(descbuf, FTL_TRACE_MD_WRITE_COMPLETION(i), OWNER_FTL, OBJECT_NONE,
+						0, 0, "lba: ");
+
+		snprintf(descbuf, sizeof(descbuf), "%c %s", source[i], "read_sched");
+		spdk_trace_register_description(descbuf, FTL_TRACE_READ_SCHEDULE(i), OWNER_FTL, OBJECT_NONE, 0, 0,
+						"lba: ");
+		snprintf(descbuf, sizeof(descbuf), "%c %s", source[i], "read_submit");
+		spdk_trace_register_description(descbuf, FTL_TRACE_READ_SUBMISSION(i), OWNER_FTL, OBJECT_NONE, 0, 0,
+						"addr: ");
+		snprintf(descbuf, sizeof(descbuf), "%c %s", source[i], "read_cmpl_invld");
+		spdk_trace_register_description(descbuf, FTL_TRACE_READ_COMPLETION_INVALID(i), OWNER_FTL,
+						OBJECT_NONE, 0, 0, "lba: ");
+		snprintf(descbuf, sizeof(descbuf), "%c %s", source[i], "read_cmpl_cache");
+		spdk_trace_register_description(descbuf, FTL_TRACE_READ_COMPLETION_CACHE(i), OWNER_FTL, OBJECT_NONE,
+						0, 0, "lba: ");
+		snprintf(descbuf, sizeof(descbuf), "%c %s", source[i], "read_cmpl_ssd");
+		spdk_trace_register_description(descbuf, FTL_TRACE_READ_COMPLETION_DISK(i), OWNER_FTL, OBJECT_NONE,
+						0, 0, "lba: ");
+
+		snprintf(descbuf, sizeof(descbuf), "%c %s", source[i], "write_sched");
+		spdk_trace_register_description(descbuf, FTL_TRACE_WRITE_SCHEDULE(i), OWNER_FTL, OBJECT_NONE, 0, 0,
+						"lba: ");
+		snprintf(descbuf, sizeof(descbuf), "%c %s", source[i], "rwb_fill");
+		spdk_trace_register_description(descbuf, FTL_TRACE_WRITE_WBUF_FILL(i), OWNER_FTL, OBJECT_NONE, 0, 0,
+						"lba: ");
+		snprintf(descbuf, sizeof(descbuf), "%c %s", source[i], "write_submit");
+		spdk_trace_register_description(descbuf, FTL_TRACE_WRITE_SUBMISSION(i), OWNER_FTL, OBJECT_NONE, 0,
+						0, "addr: ");
+		snprintf(descbuf, sizeof(descbuf), "%c %s", source[i], "write_cmpl");
+		spdk_trace_register_description(descbuf, FTL_TRACE_WRITE_COMPLETION(i), OWNER_FTL, OBJECT_NONE, 0,
+						0, "lba: ");
+	}
+}
+
+static uint64_t
+ftl_trace_next_id(struct ftl_trace *trace)
+{
+	assert(trace->id != FTL_TRACE_INVALID_ID);
+	return __atomic_fetch_add(&trace->id, 1, __ATOMIC_SEQ_CST);
+}
+
+void
+ftl_trace_reloc_band(struct spdk_ftl_dev *dev, const struct ftl_band *band)
+{
+	struct ftl_trace *trace = &dev->trace;
+
+	spdk_trace_record(FTL_TRACE_BAND_RELOC(FTL_TRACE_SOURCE_INTERNAL), ftl_trace_next_id(trace), 0,
+			  band->p2l_map.num_valid, band->id);
+}
+
+void
+ftl_trace_write_band(struct spdk_ftl_dev *dev, const struct ftl_band *band)
+{
+	struct ftl_trace *trace = &dev->trace;
+
+	spdk_trace_record(FTL_TRACE_BAND_WRITE(FTL_TRACE_SOURCE_INTERNAL), ftl_trace_next_id(trace), 0, 0,
+			  band->id);
+}
+
+void
+ftl_trace_lba_io_init(struct spdk_ftl_dev *dev, const struct ftl_io *io)
+{
+	uint16_t tpoint_id = 0, source;
+
+	assert(io->trace != FTL_TRACE_INVALID_ID);
+	source = FTL_TRACE_SOURCE_USER;
+
+	switch (io->type) {
+	case FTL_IO_READ:
+		tpoint_id = FTL_TRACE_READ_SCHEDULE(source);
+		break;
+	case FTL_IO_WRITE:
+		tpoint_id = FTL_TRACE_WRITE_SCHEDULE(source);
+		break;
+	case FTL_IO_UNMAP:
+		tpoint_id = FTL_TRACE_UNMAP_SCHEDULE(source);
+		break;
+	default:
+		assert(0);
+	}
+
+	spdk_trace_record(tpoint_id, io->trace, io->num_blocks, 0, ftl_io_get_lba(io, 0));
+}
+
+void
+ftl_trace_completion(struct spdk_ftl_dev *dev, const struct ftl_io *io,
+		     enum ftl_trace_completion completion)
+{
+	uint16_t tpoint_id = 0, source;
+
+	assert(io->trace != FTL_TRACE_INVALID_ID);
+	source = FTL_TRACE_SOURCE_USER;
+
+	switch (io->type) {
+	case FTL_IO_READ:
+		switch (completion) {
+		case FTL_TRACE_COMPLETION_INVALID:
+			tpoint_id = FTL_TRACE_READ_COMPLETION_INVALID(source);
+			break;
+		case FTL_TRACE_COMPLETION_CACHE:
+			tpoint_id = FTL_TRACE_READ_COMPLETION_CACHE(source);
+			break;
+		case FTL_TRACE_COMPLETION_DISK:
+			tpoint_id = FTL_TRACE_READ_COMPLETION_DISK(source);
+			break;
+		}
+		break;
+	case FTL_IO_WRITE:
+		tpoint_id = FTL_TRACE_WRITE_COMPLETION(source);
+		break;
+	case FTL_IO_UNMAP:
+		tpoint_id = FTL_TRACE_UNMAP_COMPLETION(source);
+		break;
+	default:
+		assert(0);
+	}
+
+	spdk_trace_record(tpoint_id, io->trace, 0, 0, ftl_io_get_lba(io, io->pos - 1));
+}
+
+void
+ftl_trace_submission(struct spdk_ftl_dev *dev, const struct ftl_io *io, ftl_addr addr,
+		     size_t addr_cnt)
+{
+	uint16_t tpoint_id = 0, source;
+
+	assert(io->trace != FTL_TRACE_INVALID_ID);
+	source = FTL_TRACE_SOURCE_USER;
+
+	switch (io->type) {
+	case FTL_IO_READ:
+		tpoint_id = FTL_TRACE_READ_SUBMISSION(source);
+		break;
+	case FTL_IO_WRITE:
+		tpoint_id = FTL_TRACE_WRITE_SUBMISSION(source);
+		break;
+	case FTL_IO_UNMAP:
+		tpoint_id = FTL_TRACE_UNMAP_SUBMISSION(source);
+		break;
+	default:
+		assert(0);
+	}
+
+	spdk_trace_record(tpoint_id, io->trace, addr_cnt, 0, addr);
+}
+
+void
+ftl_trace_limits(struct spdk_ftl_dev *dev, int limit, size_t num_free)
+{
+	struct ftl_trace *trace = &dev->trace;
+
+	spdk_trace_record(FTL_TRACE_LIMITS(FTL_TRACE_SOURCE_INTERNAL), ftl_trace_next_id(trace), num_free,
+			  limit, 0);
+}
+
+uint64_t
+ftl_trace_alloc_id(struct spdk_ftl_dev *dev)
+{
+	struct ftl_trace *trace = &dev->trace;
+
+	return ftl_trace_next_id(trace);
+}
+
+#endif /* defined(DEBUG) */

lib/ftl/ftl_trace.h

@@ -0,0 +1,50 @@
+/*   SPDX-License-Identifier: BSD-3-Clause
+ *   Copyright (c) Intel Corporation.
+ *   All rights reserved.
+ */
+
+#ifndef FTL_TRACE_H
+#define FTL_TRACE_H
+
+#include "ftl_internal.h"
+
+#define FTL_TRACE_INVALID_ID ((uint64_t) -1)
+
+enum ftl_trace_completion {
+	FTL_TRACE_COMPLETION_INVALID,
+	FTL_TRACE_COMPLETION_CACHE,
+	FTL_TRACE_COMPLETION_DISK,
+};
+
+struct ftl_trace {
+	/* Monotonically incrementing event id */
+	uint64_t		id;
+};
+
+struct spdk_ftl_dev;
+struct ftl_trace;
+struct ftl_io;
+struct ftl_wbuf_entry;
+struct ftl_band;
+
+#if defined(DEBUG)
+uint64_t ftl_trace_alloc_id(struct spdk_ftl_dev *dev);
+void ftl_trace_reloc_band(struct spdk_ftl_dev *dev, const struct ftl_band *band);
+void ftl_trace_write_band(struct spdk_ftl_dev *dev, const struct ftl_band *band);
+void ftl_trace_lba_io_init(struct spdk_ftl_dev *dev, const struct ftl_io *io);
+void ftl_trace_submission(struct spdk_ftl_dev *dev, const struct ftl_io *io, ftl_addr addr,
+			  size_t addr_cnt);
+void ftl_trace_completion(struct spdk_ftl_dev *dev, const struct ftl_io *io,
+			  enum ftl_trace_completion type);
+void ftl_trace_limits(struct spdk_ftl_dev *dev, int limit, size_t num_free);
+#else /* defined(DEBUG) */
+#define ftl_trace_alloc_id(dev) FTL_TRACE_INVALID_ID
+#define ftl_trace_reloc_band(dev, band)
+#define ftl_trace_write_band(dev, band)
+#define ftl_trace_lba_io_init(dev, io)
+#define ftl_trace_submission(dev, io, addr, addr_cnt)
+#define ftl_trace_completion(dev, io, type)
+#define ftl_trace_limits(dev, limits, num_free)
+#endif
+
+#endif /* FTL_TRACE_H */

mk/spdk.lib_deps.mk

@@ -60,7 +60,7 @@ DEPDIRS-blobfs := log thread blob trace util
 DEPDIRS-event := log util thread $(JSON_LIBS) trace init
 DEPDIRS-init := jsonrpc json log rpc thread util
 
-DEPDIRS-ftl := log util thread bdev
+DEPDIRS-ftl := log util thread bdev trace
 DEPDIRS-nbd := log util thread $(JSON_LIBS) bdev
 DEPDIRS-nvmf := accel log sock util nvme thread $(JSON_LIBS) trace bdev
 ifeq ($(CONFIG_RDMA),y)

test/unit/lib/ftl/ftl_band.c/ftl_band_ut.c

@@ -31,6 +31,15 @@ static struct ftl_band	*g_band;
 #if defined(DEBUG)
 DEFINE_STUB_V(ftl_band_validate_md, (struct ftl_band *band, ftl_band_validate_md_cb cb));
 DEFINE_STUB_V(ftl_p2l_validate_ckpt, (struct ftl_band *band));
+DEFINE_STUB_V(ftl_trace_limits, (struct spdk_ftl_dev *dev, int limit, size_t num_free));
+DEFINE_STUB_V(ftl_trace_completion, (struct spdk_ftl_dev *dev, const struct ftl_io *io,
+				     enum ftl_trace_completion completion));
+DEFINE_STUB_V(ftl_trace_defrag_band, (struct spdk_ftl_dev *dev, const struct ftl_band *band));
+DEFINE_STUB_V(ftl_trace_wbuf_fill, (struct spdk_ftl_dev *dev, const struct ftl_io *io));
+DEFINE_STUB_V(ftl_trace_wbuf_pop, (struct spdk_ftl_dev *dev, const struct ftl_wbuf_entry *entry));
+DEFINE_STUB_V(ftl_trace_write_band, (struct spdk_ftl_dev *dev, const struct ftl_band *band));
+DEFINE_STUB_V(ftl_trace_submission, (struct spdk_ftl_dev *dev, const struct ftl_io *io,
+				     ftl_addr addr, size_t addr_cnt));
 #endif
 DEFINE_STUB_V(spdk_bdev_free_io, (struct spdk_bdev_io *bdev_io));
 DEFINE_STUB(spdk_bdev_get_block_size, uint32_t, (const struct spdk_bdev *bdev), 512);

test/unit/lib/ftl/ftl_io.c/ftl_io_ut.c

@@ -74,6 +74,20 @@ DEFINE_STUB_V(ftl_p2l_ckpt_release, (struct spdk_ftl_dev *dev, struct ftl_p2l_ck
 DEFINE_STUB(ftl_l2p_get, ftl_addr, (struct spdk_ftl_dev *dev, uint64_t lba), 0);
 DEFINE_STUB_V(ftl_mempool_put, (struct ftl_mempool *mpool, void *element));
 
+#if defined(DEBUG)
+DEFINE_STUB_V(ftl_trace_defrag_band, (struct spdk_ftl_dev *dev, const struct ftl_band *band));
+DEFINE_STUB_V(ftl_trace_submission, (struct spdk_ftl_dev *dev, const struct ftl_io *io,
+				     ftl_addr addr, size_t addr_cnt));
+DEFINE_STUB_V(ftl_trace_lba_io_init, (struct spdk_ftl_dev *dev, const struct ftl_io *io));
+DEFINE_STUB_V(ftl_trace_limits, (struct spdk_ftl_dev *dev, int limit, size_t num_free));
+DEFINE_STUB(ftl_trace_alloc_id, uint64_t, (struct spdk_ftl_dev *dev), 0);
+DEFINE_STUB_V(ftl_trace_completion, (struct spdk_ftl_dev *dev, const struct ftl_io *io,
+				     enum ftl_trace_completion type));
+DEFINE_STUB_V(ftl_trace_wbuf_fill, (struct spdk_ftl_dev *dev, const struct ftl_io *io));
+DEFINE_STUB_V(ftl_trace_wbuf_pop, (struct spdk_ftl_dev *dev, const struct ftl_wbuf_entry *entry));
+DEFINE_STUB_V(ftl_trace_write_band, (struct spdk_ftl_dev *dev, const struct ftl_band *band));
+#endif
+
 #if defined(FTL_DUMP_STATS)
 DEFINE_STUB_V(ftl_dev_dump_stats, (const struct spdk_ftl_dev *dev));
 #endif