ivampiresp/Spdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ftl: Added trace support

Browse Source 
This patch adds supplementary tracing for OCSSD library to allow
for more efficient debugging and profiling of the user I/O path
as well as the background tasks (maintaining write pointer,
defragmentation, ANM event handling, etc.).

Change-Id: I741f1304f4ee0eba019e31bea7814af475c3296e
Signed-off-by: Konrad Sztyber <konrad.sztyber@intel.com>
Signed-off-by: Wojciech Malikowski <wojciech.malikowski@intel.com>
Signed-off-by: Tomasz Zawadzki <tomasz.zawadzki@intel.com>
Reviewed-on: https://review.gerrithub.io/c/431327
Tested-by: SPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: Jim Harris <james.r.harris@intel.com>
Reviewed-by: Ben Walker <benjamin.walker@intel.com>
This commit is contained in:
Tomasz Zawadzki 2018-11-30 12:33:15 -05:00 committed by Jim Harris
parent 5c3591c72e
commit 8331ebd19c
11 changed files with 255 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
include/spdk/ftl.h
View File

@ -69,9 +69,6 @@ struct spdk_ftl_conf {
/* Threshold for opening new band */
size_t band_thld;
/* Trace enabled flag */
int trace;
/* Maximum IO depth per band relocate */
size_t max_reloc_qdepth;

2
lib/ftl/Makefile
View File

@ -35,7 +35,7 @@ SPDK_ROOT_DIR := $(abspath $(CURDIR)/../..)
include $(SPDK_ROOT_DIR)/mk/spdk.common.mk
C_SRCS = ftl_band.c ftl_core.c ftl_debug.c ftl_io.c ftl_rwb.c ftl_reloc.c \
ftl_anm.c ftl_restore.c ftl_init.c
ftl_anm.c ftl_restore.c ftl_init.c ftl_trace.c
LIBNAME = ftl

24
lib/ftl/ftl_core.c
View File

@ -134,7 +134,7 @@ ftl_io_cmpl_cb(void *arg, const struct spdk_nvme_cpl *status)
ftl_io_process_error(io, status);
}
ftl_trace(completion, ftl_dev_trace(io->dev), io, FTL_TRACE_COMPLETION_DISK);
ftl_trace_completion(io->dev, io, FTL_TRACE_COMPLETION_DISK);
if (!ftl_io_dec_req(io)) {
ftl_io_complete(io);
@ -294,7 +294,7 @@ ftl_submit_erase(struct ftl_io *io)
ftl_io_inc_req(io);
ftl_trace(submission, ftl_dev_trace(dev), io, ppa, 1);
ftl_trace_submission(dev, io, ppa, 1);
rc = spdk_nvme_ocssd_ns_cmd_vector_reset(dev->ns, ftl_get_write_qpair(dev),
&ppa_packed, 1, NULL, ftl_io_cmpl_cb, io);
if (rc) {
@ -302,7 +302,6 @@ ftl_submit_erase(struct ftl_io *io)
ftl_io_dec_req(io);
break;
}
}
if (ftl_io_done(io)) {
@ -428,7 +427,7 @@ ftl_add_wptr(struct spdk_ftl_dev *dev)
LIST_INSERT_HEAD(&dev->wptr_list, wptr, list_entry);
SPDK_DEBUGLOG(SPDK_LOG_FTL_CORE, "wptr: band %u\n", band->id);
ftl_trace(write_band, ftl_dev_trace(dev), band);
ftl_trace_write_band(dev, band);
return 0;
}
@ -651,7 +650,7 @@ ftl_apply_limits(struct spdk_ftl_dev *dev)
/* Clear the limits, since we don't need to apply them anymore */
rwb_limit[FTL_RWB_TYPE_USER] = ftl_rwb_entry_cnt(dev->rwb);
apply:
ftl_trace(limits, ftl_dev_trace(dev), rwb_limit, dev->num_free);
ftl_trace_limits(dev, rwb_limit, dev->num_free);
ftl_rwb_set_limits(dev->rwb, rwb_limit);
}
@ -733,7 +732,7 @@ ftl_submit_read(struct ftl_io *io, ftl_next_ppa_fn next_ppa,
assert(lbk_cnt > 0);
ftl_trace(submission, ftl_dev_trace(dev), io, ppa, lbk_cnt);
ftl_trace_submission(dev, io, ppa, lbk_cnt);
rc = spdk_nvme_ns_cmd_read(dev->ns, ftl_get_read_qpair(dev),
ftl_io_iovec_addr(io),
ftl_ppa_addr_pack(io->dev, ppa), lbk_cnt,
@ -795,15 +794,13 @@ ftl_lba_read_next_ppa(struct ftl_io *io, struct ftl_ppa *ppa,
/* If the PPA is invalid, skip it (the buffer should already be zero'ed) */
if (ftl_ppa_invalid(*ppa)) {
ftl_trace(completion, ftl_dev_trace(io->dev), io,
FTL_TRACE_COMPLETION_INVALID);
ftl_trace_completion(io->dev, io, FTL_TRACE_COMPLETION_INVALID);
return 0;
}
if (ftl_ppa_cached(*ppa)) {
if (!ftl_ppa_cache_read(io, io->lba + lbk, *ppa, ftl_io_iovec_addr(io))) {
ftl_trace(completion, ftl_dev_trace(io->dev), io,
FTL_TRACE_COMPLETION_CACHE);
ftl_trace_completion(io->dev, io, FTL_TRACE_COMPLETION_CACHE);
return 0;
}
@ -989,8 +986,7 @@ ftl_submit_write(struct ftl_wptr *wptr, struct ftl_io *io)
assert(iov[i].iov_len > 0);
assert(iov[i].iov_len / PAGE_SIZE == dev->xfer_size);
ftl_trace(submission, ftl_dev_trace(dev), io, wptr->ppa,
iov[i].iov_len / PAGE_SIZE);
ftl_trace_submission(dev, io, wptr->ppa, iov[i].iov_len / PAGE_SIZE);
rc = spdk_nvme_ns_cmd_write_with_md(dev->ns, ftl_get_write_qpair(dev),
iov[i].iov_base, ftl_io_get_md(io),
ftl_ppa_addr_pack(dev, wptr->ppa),
@ -1082,7 +1078,7 @@ ftl_wptr_process_writes(struct ftl_wptr *wptr)
ftl_rwb_entry_set_valid(entry);
ftl_trace(rwb_pop, ftl_dev_trace(dev), entry);
ftl_trace_rwb_pop(dev, entry);
ftl_update_rwb_stats(dev, entry);
ppa = ftl_band_next_ppa(wptr->band, ppa, 1);
@ -1182,7 +1178,7 @@ ftl_rwb_fill(struct ftl_io *io)
/* write completion callback when it's processed faster than */
/* L2P is set in update_l2p(). */
ftl_rwb_push(entry);
ftl_trace(rwb_fill, ftl_dev_trace(dev), io);
ftl_trace_rwb_fill(dev, io);
}
ftl_io_complete(io);

8
lib/ftl/ftl_core.h
View File

@ -66,7 +66,7 @@ struct ftl_stats {
uint64_t write_total;
/* Traces */
struct ftl_trace *trace;
struct ftl_trace trace;
/* Number of limits applied */
uint64_t limits[SPDK_FTL_LIMIT_MAX];
@ -429,10 +429,4 @@ ftl_vld_map_size(const struct spdk_ftl_dev *dev)
return (size_t)spdk_divide_round_up(ftl_num_band_lbks(dev), CHAR_BIT);
}
static inline struct ftl_trace *
ftl_dev_trace(struct spdk_ftl_dev *dev)
{
return dev->stats.trace;
}
#endif /* FTL_CORE_H */

2
lib/ftl/ftl_init.c
View File

@ -87,8 +87,6 @@ static const struct spdk_ftl_conf g_default_conf = {
.max_active_relocs = 3,
/* IO pool size per user thread (this should be adjusted to thread IO qdepth) */
.user_io_pool_size = 2048,
/* Enable traces */
.trace = 0,
};
static void ftl_dev_free_sync(struct spdk_ftl_dev *dev);

4
lib/ftl/ftl_io.c
View File

@ -178,7 +178,7 @@ ftl_io_init(struct ftl_io *io, struct spdk_ftl_dev *dev,
io->lba = FTL_LBA_INVALID;
io->cb.fn = fn;
io->cb.ctx = ctx;
io->trace = ftl_trace_alloc_group(dev->stats.trace);
io->trace = ftl_trace_alloc_id(dev);
}
struct ftl_io *
@ -280,7 +280,7 @@ ftl_io_user_init(struct spdk_ftl_dev *dev, struct ftl_io *io, uint64_t lba, size
io->iov = *iov;
}
ftl_trace(lba_io_init, ftl_dev_trace(io->dev), io);
ftl_trace_lba_io_init(io->dev, io);
}
void

2
lib/ftl/ftl_io.h
View File

@ -196,7 +196,7 @@ struct ftl_io {
enum ftl_io_type type;
/* Trace group id */
ftl_trace_group_t trace;
uint64_t trace;
};
/* Metadata IO */

2
lib/ftl/ftl_reloc.c
View File

@ -417,7 +417,7 @@ ftl_reloc_io_reinit(struct ftl_io *io, struct ftl_band_reloc *breloc,
io->lbas[i] = breloc->band->md.lba_map[lbkoff];
}
ftl_trace(lba_io_init, ftl_dev_trace(io->dev), io);
ftl_trace_lba_io_init(io->dev, io);
}
static int

2
lib/ftl/ftl_rwb.h
View File

@ -84,7 +84,7 @@ struct ftl_rwb_entry {
bool valid;
/* Trace group id */
ftl_trace_group_t trace;
uint64_t trace;
/* Batch list entry */
LIST_ENTRY(ftl_rwb_entry) list_entry;

220
lib/ftl/ftl_trace.c Normal file
View File

@ -0,0 +1,220 @@
/*-
* BSD LICENSE
*
* Copyright (c) Intel Corporation.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "spdk/trace.h"
#include "ftl_core.h"
#include "ftl_trace.h"
#include "ftl_io.h"
#include "ftl_band.h"
#include "ftl_rwb.h"
#define OBJECT_FTL_IO 0x50
#define OBJECT_RWB_IO 0x51
#define TRACE_GROUP_FTL 0x6
#define FTL_TPOINT_ID(type, source, tpoint) SPDK_TPOINT_ID(TRACE_GROUP_FTL, ((source * 16) + (type * 8) + tpoint))
#define FTL_TRACE_TYPE_BAND_DEFRAG FTL_TPOINT_ID(FTL_TRACE_TYPE_OTHER, FTL_TRACE_SOURCE_INTERNAL, 0x0)
#define FTL_TRACE_TYPE_BAND_WRITE FTL_TPOINT_ID(FTL_TRACE_TYPE_OTHER, FTL_TRACE_SOURCE_INTERNAL, 0x1)
#define FTL_TRACE_TYPE_APPLIED_LIMITS FTL_TPOINT_ID(FTL_TRACE_TYPE_OTHER, FTL_TRACE_SOURCE_INTERNAL, 0x2)
#define FTL_TRACE_POINT_RWB_POP FTL_TPOINT_ID(FTL_TRACE_TYPE_OTHER, FTL_TRACE_SOURCE_INTERNAL, 0x3)
SPDK_TRACE_REGISTER_FN(ftl_trace_func, "ftl", TRACE_GROUP_FTL)
{
enum ftl_trace_type type;
enum ftl_trace_source source;
spdk_trace_register_owner(FTL_TRACE_SOURCE_INTERNAL, 'i');
spdk_trace_register_owner(FTL_TRACE_SOURCE_USER, 'u');
spdk_trace_register_object(OBJECT_FTL_IO, 'f');
spdk_trace_register_description("FTL_TRACE_TYPE_BAND_DEFRAG", "", FTL_TRACE_TYPE_BAND_DEFRAG,
FTL_TRACE_SOURCE_INTERNAL, OBJECT_FTL_IO, 0, 0, "band: ");
spdk_trace_register_description("FTL_TRACE_TYPE_BAND_WRITE", "", FTL_TRACE_TYPE_BAND_WRITE,
FTL_TRACE_SOURCE_INTERNAL, OBJECT_FTL_IO, 0, 0, "band: ");
spdk_trace_register_description("FTL_TRACE_TYPE_APPLIED_LIMITS", "", FTL_TRACE_TYPE_APPLIED_LIMITS,
FTL_TRACE_SOURCE_INTERNAL, OBJECT_FTL_IO, 0, 0, "limits: ");
spdk_trace_register_description("FTL_TRACE_POINT_RWB_POP", "", FTL_TRACE_POINT_RWB_POP,
FTL_TRACE_SOURCE_INTERNAL, OBJECT_RWB_IO, 0, 0, "lba: ");
for (source = FTL_TRACE_SOURCE_INTERNAL; source <= FTL_TRACE_SOURCE_INTERNAL; source++) {
for (type = FTL_TRACE_TYPE_READ; type < FTL_TRACE_TYPE_OTHER; type++) {
/* TODO: Figure out better way to describe each of the traces */
spdk_trace_register_description("FTL_TRACE_POINT_SCHEDULED", "",
FTL_TPOINT_ID(type, source, FTL_TRACE_POINT_SCHEDULED),
source, OBJECT_FTL_IO, 0, 0, "lba: ");
spdk_trace_register_description("FTL_TRACE_POINT_RWB_FILL", "",
FTL_TPOINT_ID(type, source, FTL_TRACE_POINT_RWB_FILL),
source, OBJECT_FTL_IO, 0, 0, "lba: ");
spdk_trace_register_description("FTL_TRACE_POINT_SUBMISSION", "",
FTL_TPOINT_ID(type, source, FTL_TRACE_POINT_SUBMISSION),
source, OBJECT_FTL_IO, 0, 0, "ppa: ");
spdk_trace_register_description("FTL_TRACE_COMPLETION_INVALID", "",
FTL_TPOINT_ID(type, source, FTL_TRACE_COMPLETION_INVALID),
source, OBJECT_FTL_IO, 0, 0, "lba: ");
spdk_trace_register_description("FTL_TRACE_COMPLETION_CACHE", "",
FTL_TPOINT_ID(type, source, FTL_TRACE_COMPLETION_CACHE),
source, OBJECT_FTL_IO, 0, 0, "lba: ");
spdk_trace_register_description("FTL_TRACE_COMPLETION_DISK", "",
FTL_TPOINT_ID(type, source, FTL_TRACE_COMPLETION_DISK),
source, OBJECT_FTL_IO, 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);
}
static uint8_t
ftl_io2trace_source(const struct ftl_io *io)
{
if (io->flags & FTL_IO_INTERNAL) {
return FTL_TRACE_SOURCE_INTERNAL;
} else {
return FTL_TRACE_SOURCE_USER;
}
}
static uint64_t
ftl_io2trace_type(const struct ftl_io *io, enum ftl_trace_point point)
{
uint8_t md_type = 0;
static const enum ftl_trace_type type[][2] = {
[FTL_IO_READ][0] = FTL_TRACE_TYPE_READ,
[FTL_IO_READ][1] = FTL_TRACE_TYPE_MD_READ,
[FTL_IO_WRITE][0] = FTL_TRACE_TYPE_WRITE,
[FTL_IO_WRITE][1] = FTL_TRACE_TYPE_MD_WRITE,
[FTL_IO_ERASE][0] = FTL_TRACE_TYPE_ERASE,
[FTL_IO_ERASE][1] = FTL_TRACE_TYPE_ERASE,
};
if (io->flags & FTL_IO_MD) {
md_type = 1;
}
return FTL_TPOINT_ID(type[io->type][md_type], ftl_io2trace_source(io), point);
}
void
ftl_trace_defrag_band(struct spdk_ftl_dev *dev, const struct ftl_band *band)
{
struct ftl_trace *trace = &dev->stats.trace;
spdk_trace_record(FTL_TRACE_TYPE_BAND_DEFRAG, ftl_trace_next_id(trace), 0, band->id,
band->md.num_vld);
}
void
ftl_trace_write_band(struct spdk_ftl_dev *dev, const struct ftl_band *band)
{
struct ftl_trace *trace = &dev->stats.trace;
spdk_trace_record(FTL_TRACE_TYPE_BAND_WRITE, ftl_trace_next_id(trace), 0, band->id, 0);
}
void
ftl_trace_lba_io_init(struct spdk_ftl_dev *dev, const struct ftl_io *io)
{
uint64_t type;
assert(io->trace != FTL_TRACE_INVALID_ID);
type = ftl_io2trace_type(io, FTL_TRACE_POINT_SCHEDULED);
spdk_trace_record(type, io->trace, io->lbk_cnt, io->lba, 0);
}
void
ftl_trace_rwb_fill(struct spdk_ftl_dev *dev, const struct ftl_io *io)
{
uint64_t type;
assert(io->trace != FTL_TRACE_INVALID_ID);
type = ftl_io2trace_type(io, FTL_TRACE_POINT_RWB_FILL);
spdk_trace_record(type, io->trace, 0, io->lba, 0);
}
void ftl_trace_rwb_pop(struct spdk_ftl_dev *dev, const struct ftl_rwb_entry *entry)
{
assert(entry->trace != FTL_TRACE_INVALID_ID);
spdk_trace_record(FTL_TRACE_POINT_RWB_POP, entry->trace, 0,
entry->lba, (uint64_t)entry->ppa.ppa);
}
void
ftl_trace_completion(struct spdk_ftl_dev *dev, const struct ftl_io *io,
enum ftl_trace_completion completion)
{
uint64_t type;
assert(io->trace != FTL_TRACE_INVALID_ID);
type = ftl_io2trace_type(io, (enum ftl_trace_point)completion);
spdk_trace_record(type, io->trace, 0, io->lba, 0);
}
void
ftl_trace_submission(struct spdk_ftl_dev *dev, const struct ftl_io *io, struct ftl_ppa ppa,
size_t ppa_cnt)
{
uint64_t type;
assert(io->trace != FTL_TRACE_INVALID_ID);
type = ftl_io2trace_type(io, FTL_TRACE_POINT_SUBMISSION);
spdk_trace_record(type, io->trace, ppa_cnt, ppa.ppa, 0);
}
void
ftl_trace_limits(struct spdk_ftl_dev *dev, const size_t *limits, size_t num_free)
{
struct ftl_trace *trace = &dev->stats.trace;
spdk_trace_record(FTL_TRACE_TYPE_APPLIED_LIMITS, ftl_trace_next_id(trace), num_free,
limits[FTL_RWB_TYPE_USER], limits[FTL_RWB_TYPE_INTERNAL]);
}
uint64_t
ftl_trace_alloc_id(struct spdk_ftl_dev *dev)
{
struct ftl_trace *trace = &dev->stats.trace;
return ftl_trace_next_id(trace);
}

43
lib/ftl/ftl_trace.h
View File

@ -38,8 +38,6 @@
#define FTL_TRACE_INVALID_ID ((uint64_t) -1)
typedef uint64_t ftl_trace_group_t;
enum ftl_trace_source {
FTL_TRACE_SOURCE_INTERNAL = 0x20,
FTL_TRACE_SOURCE_USER,
@ -72,42 +70,29 @@ struct ftl_event {
uint64_t id;
} __attribute__((packed));
struct ftl_trace {
/* Monotonically incrementing event id */
uint64_t id;
};
struct spdk_ftl_dev;
struct ftl_trace;
struct ftl_io;
struct ftl_rwb_entry;
struct ftl_band;
#if defined(FTL_TRACE_ENABLED)
#define ftl_trace(fn, trace, ...) \
do { \
if (trace) { \
ftl_trace_##fn(trace, ## __VA_ARGS__); \
} \
} while (0)
struct ftl_trace *ftl_trace_init(void);
void ftl_trace_free(struct ftl_trace *trace);
ftl_trace_group_t ftl_trace_alloc_group(struct ftl_trace *trace);
void ftl_trace_defrag_band(struct ftl_trace *trace, const struct ftl_band *band);
void ftl_trace_write_band(struct ftl_trace *trace, const struct ftl_band *band);
void ftl_trace_lba_io_init(struct ftl_trace *trace, const struct ftl_io *io);
void ftl_trace_rwb_fill(struct ftl_trace *trace, const struct ftl_io *io);
void ftl_trace_rwb_pop(struct ftl_trace *trace, const struct ftl_rwb_entry *entry);
void ftl_trace_submission(struct ftl_trace *trace,
uint64_t ftl_trace_alloc_id(struct spdk_ftl_dev *dev);
void ftl_trace_defrag_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_rwb_fill(struct spdk_ftl_dev *dev, const struct ftl_io *io);
void ftl_trace_rwb_pop(struct spdk_ftl_dev *dev, const struct ftl_rwb_entry *entry);
void ftl_trace_submission(struct spdk_ftl_dev *dev,
const struct ftl_io *io,
struct ftl_ppa ppa, size_t ppa_cnt);
void ftl_trace_completion(struct ftl_trace *trace,
void ftl_trace_completion(struct spdk_ftl_dev *dev,
const struct ftl_io *io,
enum ftl_trace_completion type);
void ftl_trace_limits(struct ftl_trace *trace, const size_t *limits, size_t num_free);
#else
#define ftl_trace(fn, trace, ...)
#define ftl_trace_alloc_group(trace) FTL_TRACE_INVALID_ID
#define ftl_trace_init() NULL
#define ftl_trace_free(t)
#endif
void ftl_trace_limits(struct spdk_ftl_dev *dev, const size_t *limits, size_t num_free);
#endif /* FTL_TRACE_H */