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

log: rename SPDK_TRACE_* to SPDK_LOG_*

Browse Source 
Disambiguate the log components from the trace functionality
(include/spdk/trace.h).

The internal spdk_trace_flag structure and related functions will be
renamed in a later commit - this is just a find and replace on
SPDK_TRACE_* and SPDK_LOG_REGISTER_TRACE_FLAG().

Change-Id: I617bd5a9fbe35ffb44ae6020b292658c094a0ad6
Signed-off-by: Daniel Verkamp <daniel.verkamp@intel.com>
Reviewed-on: https://review.gerrithub.io/376421
Tested-by: SPDK Automated Test System <sys_sgsw@intel.com>
Reviewed-by: Jim Harris <james.r.harris@intel.com>
Reviewed-by: Ben Walker <benjamin.walker@intel.com>
This commit is contained in:
Daniel Verkamp 2017-08-30 11:06:33 -07:00 committed by Jim Harris
parent e6fea425c9
commit ea1c15791f
72 changed files with 614 additions and 614 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/spdk_internal/log.h
View File

@ -56,7 +56,7 @@ void spdk_log_register_trace_flag(const char *name, struct spdk_trace_flag *flag
struct spdk_trace_flag *spdk_log_get_first_trace_flag(void);
struct spdk_trace_flag *spdk_log_get_next_trace_flag(struct spdk_trace_flag *flag);
#define SPDK_LOG_REGISTER_TRACE_FLAG(str, flag) \
#define SPDK_LOG_REGISTER_COMPONENT(str, flag) \
struct spdk_trace_flag flag = { \
.enabled = false, \
.name = str, \

6
lib/bdev/aio/bdev_aio.c
View File

@ -115,7 +115,7 @@ bdev_aio_readv(struct file_disk *fdisk, struct spdk_io_channel *ch,
iocb->data = aio_task;
aio_task->len = nbytes;
SPDK_DEBUGLOG(SPDK_TRACE_AIO, "read %d iovs size %lu to off: %#lx\n",
SPDK_DEBUGLOG(SPDK_LOG_AIO, "read %d iovs size %lu to off: %#lx\n",
iovcnt, nbytes, offset);
rc = io_submit(aio_ch->io_ctx, 1, &iocb);
@ -145,7 +145,7 @@ bdev_aio_writev(struct file_disk *fdisk, struct spdk_io_channel *ch,
iocb->data = aio_task;
aio_task->len = len;
SPDK_DEBUGLOG(SPDK_TRACE_AIO, "write %d iovs size %lu from off: %#lx\n",
SPDK_DEBUGLOG(SPDK_LOG_AIO, "write %d iovs size %lu from off: %#lx\n",
iovcnt, len, offset);
rc = io_submit(aio_ch->io_ctx, 1, &iocb);
@ -547,4 +547,4 @@ bdev_aio_get_spdk_running_config(FILE *fp)
fprintf(fp, "\n");
}
SPDK_LOG_REGISTER_TRACE_FLAG("aio", SPDK_TRACE_AIO)
SPDK_LOG_REGISTER_COMPONENT("aio", SPDK_LOG_AIO)

16
lib/bdev/bdev.c
View File

@ -162,7 +162,7 @@ spdk_bdev_first(void)
bdev = TAILQ_FIRST(&g_bdev_mgr.bdevs);
if (bdev) {
SPDK_DEBUGLOG(SPDK_TRACE_BDEV, "Starting bdev iteration at %s\n", bdev->name);
SPDK_DEBUGLOG(SPDK_LOG_BDEV, "Starting bdev iteration at %s\n", bdev->name);
}
return bdev;
@ -175,7 +175,7 @@ spdk_bdev_next(struct spdk_bdev *prev)
bdev = TAILQ_NEXT(prev, link);
if (bdev) {
SPDK_DEBUGLOG(SPDK_TRACE_BDEV, "Continuing bdev iteration at %s\n", bdev->name);
SPDK_DEBUGLOG(SPDK_LOG_BDEV, "Continuing bdev iteration at %s\n", bdev->name);
}
return bdev;
@ -203,7 +203,7 @@ spdk_bdev_first_leaf(void)
bdev = _bdev_next_leaf(TAILQ_FIRST(&g_bdev_mgr.bdevs));
if (bdev) {
SPDK_DEBUGLOG(SPDK_TRACE_BDEV, "Starting bdev iteration at %s\n", bdev->name);
SPDK_DEBUGLOG(SPDK_LOG_BDEV, "Starting bdev iteration at %s\n", bdev->name);
}
return bdev;
@ -217,7 +217,7 @@ spdk_bdev_next_leaf(struct spdk_bdev *prev)
bdev = _bdev_next_leaf(TAILQ_NEXT(prev, link));
if (bdev) {
SPDK_DEBUGLOG(SPDK_TRACE_BDEV, "Continuing bdev iteration at %s\n", bdev->name);
SPDK_DEBUGLOG(SPDK_LOG_BDEV, "Continuing bdev iteration at %s\n", bdev->name);
}
return bdev;
@ -1803,7 +1803,7 @@ _spdk_bdev_register(struct spdk_bdev *bdev)
sizeof(struct spdk_bdev_channel));
pthread_mutex_init(&bdev->mutex, NULL);
SPDK_DEBUGLOG(SPDK_TRACE_BDEV, "Inserting bdev %s into list\n", bdev->name);
SPDK_DEBUGLOG(SPDK_LOG_BDEV, "Inserting bdev %s into list\n", bdev->name);
TAILQ_INSERT_TAIL(&g_bdev_mgr.bdevs, bdev, link);
TAILQ_FOREACH(module, &g_bdev_mgr.bdev_modules, tailq) {
@ -1856,7 +1856,7 @@ spdk_bdev_unregister(struct spdk_bdev *bdev, spdk_bdev_unregister_cb cb_fn, void
int rc;
bool do_destruct = true;
SPDK_DEBUGLOG(SPDK_TRACE_BDEV, "Removing bdev %s from list\n", bdev->name);
SPDK_DEBUGLOG(SPDK_LOG_BDEV, "Removing bdev %s from list\n", bdev->name);
pthread_mutex_lock(&bdev->mutex);
@ -1921,7 +1921,7 @@ spdk_bdev_open(struct spdk_bdev *bdev, bool write, spdk_bdev_remove_cb_t remove_
pthread_mutex_lock(&bdev->mutex);
if (write && bdev->claim_module) {
SPDK_INFOLOG(SPDK_TRACE_BDEV, "Could not open %s - already claimed\n", bdev->name);
SPDK_INFOLOG(SPDK_LOG_BDEV, "Could not open %s - already claimed\n", bdev->name);
free(desc);
pthread_mutex_unlock(&bdev->mutex);
return -EPERM;
@ -2309,4 +2309,4 @@ spdk_bdev_part_construct(struct spdk_bdev_part *part, struct spdk_bdev_part_base
return 0;
}
SPDK_LOG_REGISTER_TRACE_FLAG("bdev", SPDK_TRACE_BDEV)
SPDK_LOG_REGISTER_COMPONENT("bdev", SPDK_LOG_BDEV)

10
lib/bdev/gpt/gpt.c
View File

@ -167,7 +167,7 @@ spdk_gpt_check_mbr(struct spdk_gpt *gpt)
mbr = (struct spdk_mbr *)gpt->buf;
if (from_le16(&mbr->mbr_signature) != SPDK_MBR_SIGNATURE) {
SPDK_DEBUGLOG(SPDK_TRACE_GPT_PARSE, "Signature mismatch, provided=%x,"
SPDK_DEBUGLOG(SPDK_LOG_GPT_PARSE, "Signature mismatch, provided=%x,"
"expected=%x\n", from_le16(&mbr->disk_signature),
SPDK_MBR_SIGNATURE);
return -1;
@ -184,7 +184,7 @@ spdk_gpt_check_mbr(struct spdk_gpt *gpt)
if (ret == GPT_PROTECTIVE_MBR) {
expected_start_lba = GPT_PRIMARY_PARTITION_TABLE_LBA;
if (from_le32(&mbr->partitions[primary_partition].start_lba) != expected_start_lba) {
SPDK_DEBUGLOG(SPDK_TRACE_GPT_PARSE, "start lba mismatch, provided=%u, expected=%u\n",
SPDK_DEBUGLOG(SPDK_LOG_GPT_PARSE, "start lba mismatch, provided=%u, expected=%u\n",
from_le32(&mbr->partitions[primary_partition].start_lba),
expected_start_lba);
return -1;
@ -198,7 +198,7 @@ spdk_gpt_check_mbr(struct spdk_gpt *gpt)
return -1;
}
} else {
SPDK_DEBUGLOG(SPDK_TRACE_GPT_PARSE, "Currently only support GPT Protective MBR format\n");
SPDK_DEBUGLOG(SPDK_LOG_GPT_PARSE, "Currently only support GPT Protective MBR format\n");
return -1;
}
@ -217,7 +217,7 @@ spdk_gpt_parse(struct spdk_gpt *gpt)
rc = spdk_gpt_check_mbr(gpt);
if (rc) {
SPDK_DEBUGLOG(SPDK_TRACE_GPT_PARSE, "Failed to detect gpt in MBR\n");
SPDK_DEBUGLOG(SPDK_LOG_GPT_PARSE, "Failed to detect gpt in MBR\n");
return rc;
}
@ -236,4 +236,4 @@ spdk_gpt_parse(struct spdk_gpt *gpt)
return 0;
}
SPDK_LOG_REGISTER_TRACE_FLAG("gpt_parse", SPDK_TRACE_GPT_PARSE)
SPDK_LOG_REGISTER_COMPONENT("gpt_parse", SPDK_LOG_GPT_PARSE)

6
lib/bdev/gpt/vbdev_gpt.c
View File

@ -291,13 +291,13 @@ spdk_gpt_bdev_complete(struct spdk_bdev_io *bdev_io, bool status, void *arg)
rc = spdk_gpt_parse(&gpt_base->gpt);
if (rc) {
SPDK_DEBUGLOG(SPDK_TRACE_VBDEV_GPT, "Failed to parse gpt\n");
SPDK_DEBUGLOG(SPDK_LOG_VBDEV_GPT, "Failed to parse gpt\n");
goto end;
}
rc = vbdev_gpt_create_bdevs(gpt_base);
if (rc < 0) {
SPDK_DEBUGLOG(SPDK_TRACE_VBDEV_GPT, "Failed to split dev=%s by gpt table\n",
SPDK_DEBUGLOG(SPDK_LOG_VBDEV_GPT, "Failed to split dev=%s by gpt table\n",
spdk_bdev_get_name(bdev));
}
@ -383,4 +383,4 @@ vbdev_gpt_examine(struct spdk_bdev *bdev)
SPDK_BDEV_MODULE_REGISTER(gpt, vbdev_gpt_init, vbdev_gpt_fini, NULL,
NULL, vbdev_gpt_examine)
SPDK_LOG_REGISTER_TRACE_FLAG("vbdev_gpt", SPDK_TRACE_VBDEV_GPT)
SPDK_LOG_REGISTER_COMPONENT("vbdev_gpt", SPDK_LOG_VBDEV_GPT)

54
lib/bdev/lvol/vbdev_lvol.c
View File

@ -90,13 +90,13 @@ _vbdev_lvs_create_cb(void *cb_arg, struct spdk_lvol_store *lvs, int lvserrno)
if (lvserrno != 0) {
assert(lvs == NULL);
SPDK_INFOLOG(SPDK_TRACE_VBDEV_LVOL, "Cannot create lvol store bdev\n");
SPDK_INFOLOG(SPDK_LOG_VBDEV_LVOL, "Cannot create lvol store bdev\n");
goto end;
}
lvserrno = spdk_bs_bdev_claim(bs_dev, SPDK_GET_BDEV_MODULE(lvol));
if (lvserrno != 0) {
SPDK_INFOLOG(SPDK_TRACE_VBDEV_LVOL, "Lvol store base bdev already claimed by another bdev\n");
SPDK_INFOLOG(SPDK_LOG_VBDEV_LVOL, "Lvol store base bdev already claimed by another bdev\n");
req->bs_dev->destroy(req->bs_dev);
goto end;
}
@ -113,7 +113,7 @@ _vbdev_lvs_create_cb(void *cb_arg, struct spdk_lvol_store *lvs, int lvserrno)
lvs_bdev->req = NULL;
TAILQ_INSERT_TAIL(&g_spdk_lvol_pairs, lvs_bdev, lvol_stores);
SPDK_INFOLOG(SPDK_TRACE_VBDEV_LVOL, "Lvol store bdev inserted\n");
SPDK_INFOLOG(SPDK_LOG_VBDEV_LVOL, "Lvol store bdev inserted\n");
end:
req->cb_fn(req->cb_arg, lvs, lvserrno);
@ -190,7 +190,7 @@ _vbdev_lvs_remove_cb(void *cb_arg, int lvserrno)
struct spdk_lvs_req *req = lvs_bdev->req;
if (lvserrno != 0) {
SPDK_INFOLOG(SPDK_TRACE_VBDEV_LVOL, "Could not remove lvol store bdev\n");
SPDK_INFOLOG(SPDK_LOG_VBDEV_LVOL, "Could not remove lvol store bdev\n");
} else {
TAILQ_REMOVE(&g_spdk_lvol_pairs, lvs_bdev, lvol_stores);
free(lvs_bdev);
@ -278,7 +278,7 @@ vbdev_lvol_store_first(void)
lvs_bdev = TAILQ_FIRST(&g_spdk_lvol_pairs);
if (lvs_bdev) {
SPDK_INFOLOG(SPDK_TRACE_VBDEV_LVOL, "Starting lvolstore iteration at %p\n", lvs_bdev->lvs);
SPDK_INFOLOG(SPDK_LOG_VBDEV_LVOL, "Starting lvolstore iteration at %p\n", lvs_bdev->lvs);
}
return lvs_bdev;
@ -296,7 +296,7 @@ vbdev_lvol_store_next(struct lvol_store_bdev *prev)
lvs_bdev = TAILQ_NEXT(prev, lvol_stores);
if (lvs_bdev) {
SPDK_INFOLOG(SPDK_TRACE_VBDEV_LVOL, "Continuing lvolstore iteration at %p\n", lvs_bdev->lvs);
SPDK_INFOLOG(SPDK_LOG_VBDEV_LVOL, "Continuing lvolstore iteration at %p\n", lvs_bdev->lvs);
}
return lvs_bdev;
@ -382,7 +382,7 @@ _vbdev_lvol_close_cb(void *cb_arg, int lvserrno)
lvs = cb_arg;
if (lvs->lvols_opened >= lvs->lvol_count) {
SPDK_INFOLOG(SPDK_TRACE_VBDEV_LVOL, "Opening lvols finished\n");
SPDK_INFOLOG(SPDK_LOG_VBDEV_LVOL, "Opening lvols finished\n");
spdk_bdev_module_examine_done(SPDK_GET_BDEV_MODULE(lvol));
}
}
@ -392,7 +392,7 @@ _vbdev_lvol_destroy_cb(void *cb_arg, int lvserrno)
{
struct spdk_bdev *bdev = cb_arg;
SPDK_INFOLOG(SPDK_TRACE_VBDEV_LVOL, "Lvol destroyed\n");
SPDK_INFOLOG(SPDK_LOG_VBDEV_LVOL, "Lvol destroyed\n");
spdk_bdev_unregister_done(bdev, lvserrno);
free(bdev->name);
@ -406,14 +406,14 @@ _vbdev_lvol_destroy_after_close_cb(void *cb_arg, int lvserrno)
struct spdk_bdev *bdev = lvol->bdev;
if (lvserrno != 0) {
SPDK_INFOLOG(SPDK_TRACE_VBDEV_LVOL, "Could not close Lvol %s\n", lvol->old_name);
SPDK_INFOLOG(SPDK_LOG_VBDEV_LVOL, "Could not close Lvol %s\n", lvol->old_name);
spdk_bdev_unregister_done(bdev, lvserrno);
free(bdev->name);
free(bdev);
return;
}
SPDK_INFOLOG(SPDK_TRACE_VBDEV_LVOL, "Lvol %s closed, begin destroying\n", lvol->old_name);
SPDK_INFOLOG(SPDK_LOG_VBDEV_LVOL, "Lvol %s closed, begin destroying\n", lvol->old_name);
spdk_lvol_destroy(lvol, _vbdev_lvol_destroy_cb, bdev);
}
@ -498,7 +498,7 @@ lvol_op_comp(void *cb_arg, int bserrno)
task->status = SPDK_BDEV_IO_STATUS_FAILED;
}
SPDK_INFOLOG(SPDK_TRACE_VBDEV_LVOL, "Vbdev processing callback on device %s with type %d\n",
SPDK_INFOLOG(SPDK_LOG_VBDEV_LVOL, "Vbdev processing callback on device %s with type %d\n",
bdev_io->bdev->name, bdev_io->type);
spdk_bdev_io_complete(bdev_io, task->status);
}
@ -515,7 +515,7 @@ lvol_unmap(struct spdk_lvol *lvol, struct spdk_io_channel *ch, struct spdk_bdev_
task->status = SPDK_BDEV_IO_STATUS_SUCCESS;
SPDK_INFOLOG(SPDK_TRACE_VBDEV_LVOL,
SPDK_INFOLOG(SPDK_LOG_VBDEV_LVOL,
"Vbdev doing unmap at offset %" PRIu64 " using %" PRIu64 " pages on device %s\n", start_page,
num_pages, bdev_io->bdev->name);
spdk_bs_io_unmap_blob(blob, ch, start_page, num_pages, lvol_op_comp, task);
@ -533,7 +533,7 @@ lvol_write_zeroes(struct spdk_lvol *lvol, struct spdk_io_channel *ch, struct spd
task->status = SPDK_BDEV_IO_STATUS_SUCCESS;
SPDK_INFOLOG(SPDK_TRACE_VBDEV_LVOL,
SPDK_INFOLOG(SPDK_LOG_VBDEV_LVOL,
"Vbdev doing write zeros at offset %" PRIu64 " using %" PRIu64 " pages on device %s\n", start_page,
num_pages, bdev_io->bdev->name);
spdk_bs_io_write_zeroes_blob(blob, ch, start_page, num_pages, lvol_op_comp, task);
@ -552,7 +552,7 @@ lvol_read(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io)
task->status = SPDK_BDEV_IO_STATUS_SUCCESS;
SPDK_INFOLOG(SPDK_TRACE_VBDEV_LVOL,
SPDK_INFOLOG(SPDK_LOG_VBDEV_LVOL,
"Vbdev doing read at offset %" PRIu64 " using %" PRIu64 " pages on device %s\n", start_page,
num_pages, bdev_io->bdev->name);
spdk_bs_io_readv_blob(blob, ch, bdev_io->u.bdev.iovs, bdev_io->u.bdev.iovcnt, start_page,
@ -572,7 +572,7 @@ lvol_write(struct spdk_lvol *lvol, struct spdk_io_channel *ch, struct spdk_bdev_
task->status = SPDK_BDEV_IO_STATUS_SUCCESS;
SPDK_INFOLOG(SPDK_TRACE_VBDEV_LVOL,
SPDK_INFOLOG(SPDK_LOG_VBDEV_LVOL,
"Vbdev doing write at offset %" PRIu64 " using %" PRIu64 " pages on device %s\n", start_page,
num_pages, bdev_io->bdev->name);
spdk_bs_io_writev_blob(blob, ch, bdev_io->u.bdev.iovs, bdev_io->u.bdev.iovcnt, start_page,
@ -602,7 +602,7 @@ vbdev_lvol_submit_request(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_
{
struct spdk_lvol *lvol = bdev_io->bdev->ctxt;
SPDK_INFOLOG(SPDK_TRACE_VBDEV_LVOL, "Vbdev request type %d submitted\n", bdev_io->type);
SPDK_INFOLOG(SPDK_LOG_VBDEV_LVOL, "Vbdev request type %d submitted\n", bdev_io->type);
switch (bdev_io->type) {
case SPDK_BDEV_IO_TYPE_READ:
@ -625,7 +625,7 @@ vbdev_lvol_submit_request(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_
lvol_write_zeroes(lvol, ch, bdev_io);
break;
default:
SPDK_INFOLOG(SPDK_TRACE_VBDEV_LVOL, "lvol: unsupported I/O type %d\n", bdev_io->type);
SPDK_INFOLOG(SPDK_LOG_VBDEV_LVOL, "lvol: unsupported I/O type %d\n", bdev_io->type);
spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED);
return;
}
@ -840,7 +840,7 @@ _vbdev_lvs_examine_finish(void *cb_arg, struct spdk_lvol *lvol, int lvolerrno)
TAILQ_REMOVE(&lvs->lvols, lvol, link);
lvs->lvol_count--;
spdk_bs_md_close_blob(&lvol->blob, _vbdev_lvol_close_cb, lvs);
SPDK_INFOLOG(SPDK_TRACE_VBDEV_LVOL, "Opening lvol %s failed\n", lvol->old_name);
SPDK_INFOLOG(SPDK_LOG_VBDEV_LVOL, "Opening lvol %s failed\n", lvol->old_name);
free(lvol->old_name);
free(lvol);
return;
@ -848,12 +848,12 @@ _vbdev_lvs_examine_finish(void *cb_arg, struct spdk_lvol *lvol, int lvolerrno)
lvol->bdev = bdev;
lvs->lvols_opened++;
SPDK_INFOLOG(SPDK_TRACE_VBDEV_LVOL, "Opening lvol %s succeeded\n", lvol->old_name);
SPDK_INFOLOG(SPDK_LOG_VBDEV_LVOL, "Opening lvol %s succeeded\n", lvol->old_name);
end:
if (lvs->lvols_opened >= lvs->lvol_count) {
SPDK_INFOLOG(SPDK_TRACE_VBDEV_LVOL, "Opening lvols finished\n");
SPDK_INFOLOG(SPDK_LOG_VBDEV_LVOL, "Opening lvols finished\n");
spdk_bdev_module_examine_done(SPDK_GET_BDEV_MODULE(lvol));
}
}
@ -866,20 +866,20 @@ _vbdev_lvs_examine_cb(void *arg, struct spdk_lvol_store *lvol_store, int lvserrn
struct spdk_lvol *lvol, *tmp;
if (lvserrno == -EEXIST) {
SPDK_INFOLOG(SPDK_TRACE_VBDEV_LVOL,
SPDK_INFOLOG(SPDK_LOG_VBDEV_LVOL,
"Name for lvolstore on device %s conflicts with name for already loaded lvs\n",
req->base_bdev->name);
spdk_bdev_module_examine_done(SPDK_GET_BDEV_MODULE(lvol));
goto end;
} else if (lvserrno != 0) {
SPDK_INFOLOG(SPDK_TRACE_VBDEV_LVOL, "Lvol store not found on %s\n", req->base_bdev->name);
SPDK_INFOLOG(SPDK_LOG_VBDEV_LVOL, "Lvol store not found on %s\n", req->base_bdev->name);
spdk_bdev_module_examine_done(SPDK_GET_BDEV_MODULE(lvol));
goto end;
}
lvserrno = spdk_bs_bdev_claim(lvol_store->bs_dev, SPDK_GET_BDEV_MODULE(lvol));
if (lvserrno != 0) {
SPDK_INFOLOG(SPDK_TRACE_VBDEV_LVOL, "Lvol store base bdev already claimed by another bdev\n");
SPDK_INFOLOG(SPDK_LOG_VBDEV_LVOL, "Lvol store base bdev already claimed by another bdev\n");
lvol_store->bs_dev->destroy(lvol_store->bs_dev);
spdk_bdev_module_examine_done(SPDK_GET_BDEV_MODULE(lvol));
goto end;
@ -897,13 +897,13 @@ _vbdev_lvs_examine_cb(void *arg, struct spdk_lvol_store *lvol_store, int lvserrn
TAILQ_INSERT_TAIL(&g_spdk_lvol_pairs, lvs_bdev, lvol_stores);
SPDK_INFOLOG(SPDK_TRACE_VBDEV_LVOL, "Lvol store found on %s - begin parsing\n",
SPDK_INFOLOG(SPDK_LOG_VBDEV_LVOL, "Lvol store found on %s - begin parsing\n",
req->base_bdev->name);
lvol_store->lvols_opened = 0;
if (TAILQ_EMPTY(&lvol_store->lvols)) {
SPDK_INFOLOG(SPDK_TRACE_VBDEV_LVOL, "Lvol store examination done\n");
SPDK_INFOLOG(SPDK_LOG_VBDEV_LVOL, "Lvol store examination done\n");
spdk_bdev_module_examine_done(SPDK_GET_BDEV_MODULE(lvol));
} else {
/* Open all lvols */
@ -931,7 +931,7 @@ vbdev_lvs_examine(struct spdk_bdev *bdev)
bs_dev = spdk_bdev_create_bs_dev(bdev, vbdev_lvs_hotremove_cb, bdev);
if (!bs_dev) {
SPDK_INFOLOG(SPDK_TRACE_VBDEV_LVOL, "Cannot create bs dev on %s\n", bdev->name);
SPDK_INFOLOG(SPDK_LOG_VBDEV_LVOL, "Cannot create bs dev on %s\n", bdev->name);
spdk_bdev_module_examine_done(SPDK_GET_BDEV_MODULE(lvol));
free(req);
return;
@ -944,4 +944,4 @@ vbdev_lvs_examine(struct spdk_bdev *bdev)
SPDK_BDEV_MODULE_REGISTER(lvol, vbdev_lvs_init, vbdev_lvs_fini, NULL, vbdev_lvs_get_ctx_size,
vbdev_lvs_examine)
SPDK_BDEV_MODULE_ASYNC_FINI(lvol);
SPDK_LOG_REGISTER_TRACE_FLAG("vbdev_lvol", SPDK_TRACE_VBDEV_LVOL);
SPDK_LOG_REGISTER_COMPONENT("vbdev_lvol", SPDK_LOG_VBDEV_LVOL);

24
lib/bdev/lvol/vbdev_lvol_rpc.c
View File

@ -38,7 +38,7 @@
#include "spdk/string.h"
#include "spdk_internal/log.h"
SPDK_LOG_REGISTER_TRACE_FLAG("lvolrpc", SPDK_TRACE_LVOL_RPC)
SPDK_LOG_REGISTER_COMPONENT("lvolrpc", SPDK_LOG_LVOL_RPC)
struct rpc_construct_lvol_store {
char *lvs_name;
@ -51,17 +51,17 @@ vbdev_get_lvol_store_by_uuid_xor_name(const char *uuid, const char *lvs_name,
struct spdk_lvol_store **lvs)
{
if ((uuid == NULL && lvs_name == NULL)) {
SPDK_INFOLOG(SPDK_TRACE_VBDEV_LVOL, "lvs UUID nor lvs name specified\n");
SPDK_INFOLOG(SPDK_LOG_LVOL_RPC, "lvs UUID nor lvs name specified\n");
return -EINVAL;
} else if ((uuid && lvs_name)) {
SPDK_INFOLOG(SPDK_TRACE_VBDEV_LVOL, "both lvs UUID '%s' and lvs name '%s' specified\n", uuid,
SPDK_INFOLOG(SPDK_LOG_LVOL_RPC, "both lvs UUID '%s' and lvs name '%s' specified\n", uuid,
lvs_name);
return -EINVAL;
} else if (uuid) {
*lvs = vbdev_get_lvol_store_by_uuid(uuid);
if (*lvs == NULL) {
SPDK_INFOLOG(SPDK_TRACE_VBDEV_LVOL, "blobstore with UUID '%s' not found\n", uuid);
SPDK_INFOLOG(SPDK_LOG_LVOL_RPC, "blobstore with UUID '%s' not found\n", uuid);
return -ENODEV;
}
} else if (lvs_name) {
@ -69,7 +69,7 @@ vbdev_get_lvol_store_by_uuid_xor_name(const char *uuid, const char *lvs_name,
*lvs = vbdev_get_lvol_store_by_name(lvs_name);
if (*lvs == NULL) {
SPDK_INFOLOG(SPDK_TRACE_VBDEV_LVOL, "blobstore with name '%s' not found\n", lvs_name);
SPDK_INFOLOG(SPDK_LOG_LVOL_RPC, "blobstore with name '%s' not found\n", lvs_name);
return -ENODEV;
}
}
@ -131,7 +131,7 @@ spdk_rpc_construct_lvol_store(struct spdk_jsonrpc_request *request,
if (spdk_json_decode_object(params, rpc_construct_lvol_store_decoders,
SPDK_COUNTOF(rpc_construct_lvol_store_decoders),
&req)) {
SPDK_INFOLOG(SPDK_TRACE_LVOL_RPC, "spdk_json_decode_object failed\n");
SPDK_INFOLOG(SPDK_LOG_LVOL_RPC, "spdk_json_decode_object failed\n");
rc = -EINVAL;
goto invalid;
}
@ -224,7 +224,7 @@ spdk_rpc_destroy_lvol_store(struct spdk_jsonrpc_request *request,
if (spdk_json_decode_object(params, rpc_destroy_lvol_store_decoders,
SPDK_COUNTOF(rpc_destroy_lvol_store_decoders),
&req)) {
SPDK_INFOLOG(SPDK_TRACE_LVOL_RPC, "spdk_json_decode_object failed\n");
SPDK_INFOLOG(SPDK_LOG_LVOL_RPC, "spdk_json_decode_object failed\n");
rc = -EINVAL;
goto invalid;
}
@ -306,12 +306,12 @@ spdk_rpc_construct_lvol_bdev(struct spdk_jsonrpc_request *request,
char buf[64];
struct spdk_lvol_store *lvs = NULL;
SPDK_INFOLOG(SPDK_TRACE_LVOL_RPC, "Creating blob\n");
SPDK_INFOLOG(SPDK_LOG_LVOL_RPC, "Creating blob\n");
if (spdk_json_decode_object(params, rpc_construct_lvol_bdev_decoders,
SPDK_COUNTOF(rpc_construct_lvol_bdev_decoders),
&req)) {
SPDK_INFOLOG(SPDK_TRACE_LVOL_RPC, "spdk_json_decode_object failed\n");
SPDK_INFOLOG(SPDK_LOG_LVOL_RPC, "spdk_json_decode_object failed\n");
rc = -EINVAL;
goto invalid;
}
@ -322,7 +322,7 @@ spdk_rpc_construct_lvol_bdev(struct spdk_jsonrpc_request *request,
}
if (req.lvol_name == NULL) {
SPDK_INFOLOG(SPDK_TRACE_LVOL_RPC, "no bdev name\n");
SPDK_INFOLOG(SPDK_LOG_LVOL_RPC, "no bdev name\n");
rc = -EINVAL;
goto invalid;
}
@ -394,12 +394,12 @@ spdk_rpc_resize_lvol_bdev(struct spdk_jsonrpc_request *request,
int rc = 0;
char buf[64];
SPDK_INFOLOG(SPDK_TRACE_LVOL_RPC, "Resizing lvol\n");
SPDK_INFOLOG(SPDK_LOG_LVOL_RPC, "Resizing lvol\n");
if (spdk_json_decode_object(params, rpc_resize_lvol_bdev_decoders,
SPDK_COUNTOF(rpc_resize_lvol_bdev_decoders),
&req)) {
SPDK_INFOLOG(SPDK_TRACE_LVOL_RPC, "spdk_json_decode_object failed\n");
SPDK_INFOLOG(SPDK_LOG_LVOL_RPC, "spdk_json_decode_object failed\n");
rc = -EINVAL;
goto invalid;
}

6
lib/bdev/malloc/bdev_malloc.c
View File

@ -157,7 +157,7 @@ bdev_malloc_readv(struct malloc_disk *mdisk, struct spdk_io_channel *ch,
return;
}
SPDK_DEBUGLOG(SPDK_TRACE_BDEV_MALLOC, "read %lu bytes from offset %#lx\n",
SPDK_DEBUGLOG(SPDK_LOG_BDEV_MALLOC, "read %lu bytes from offset %#lx\n",
len, offset);
task->status = SPDK_BDEV_IO_STATUS_SUCCESS;
@ -192,7 +192,7 @@ bdev_malloc_writev(struct malloc_disk *mdisk, struct spdk_io_channel *ch,
return;
}
SPDK_DEBUGLOG(SPDK_TRACE_BDEV_MALLOC, "wrote %lu bytes to offset %#lx\n",
SPDK_DEBUGLOG(SPDK_LOG_BDEV_MALLOC, "wrote %lu bytes to offset %#lx\n",
len, offset);
task->status = SPDK_BDEV_IO_STATUS_SUCCESS;
@ -490,4 +490,4 @@ bdev_malloc_get_spdk_running_config(FILE *fp)
}
}
SPDK_LOG_REGISTER_TRACE_FLAG("bdev_malloc", SPDK_TRACE_BDEV_MALLOC)
SPDK_LOG_REGISTER_COMPONENT("bdev_malloc", SPDK_LOG_BDEV_MALLOC)

2
lib/bdev/malloc/bdev_malloc_rpc.c
View File

@ -66,7 +66,7 @@ spdk_rpc_construct_malloc_bdev(struct spdk_jsonrpc_request *request,
if (spdk_json_decode_object(params, rpc_construct_malloc_decoders,
SPDK_COUNTOF(rpc_construct_malloc_decoders),
&req)) {
SPDK_DEBUGLOG(SPDK_TRACE_BDEV_MALLOC, "spdk_json_decode_object failed\n");
SPDK_DEBUGLOG(SPDK_LOG_BDEV_MALLOC, "spdk_json_decode_object failed\n");
goto invalid;
}

2
lib/bdev/null/bdev_null.c
View File

@ -290,4 +290,4 @@ bdev_null_get_spdk_running_config(FILE *fp)
SPDK_BDEV_MODULE_REGISTER(null, bdev_null_initialize, bdev_null_finish,
bdev_null_get_spdk_running_config, NULL, NULL)
SPDK_LOG_REGISTER_TRACE_FLAG("bdev_null", SPDK_TRACE_BDEV_NULL)
SPDK_LOG_REGISTER_COMPONENT("bdev_null", SPDK_LOG_BDEV_NULL)

2
lib/bdev/null/bdev_null_rpc.c
View File

@ -62,7 +62,7 @@ spdk_rpc_construct_null_bdev(struct spdk_jsonrpc_request *request,
if (spdk_json_decode_object(params, rpc_construct_null_decoders,
SPDK_COUNTOF(rpc_construct_null_decoders),
&req)) {
SPDK_DEBUGLOG(SPDK_TRACE_BDEV_NULL, "spdk_json_decode_object failed\n");
SPDK_DEBUGLOG(SPDK_LOG_BDEV_NULL, "spdk_json_decode_object failed\n");
goto invalid;
}

18
lib/bdev/nvme/bdev_nvme.c
View File

@ -169,7 +169,7 @@ bdev_nvme_readv(struct nvme_bdev *nbdev, struct spdk_io_channel *ch,
{
struct nvme_io_channel *nvme_ch = spdk_io_channel_get_ctx(ch);
SPDK_DEBUGLOG(SPDK_TRACE_BDEV_NVME, "read %lu blocks with offset %#lx\n",
SPDK_DEBUGLOG(SPDK_LOG_BDEV_NVME, "read %lu blocks with offset %#lx\n",
lba_count, lba);
return bdev_nvme_queue_cmd(nbdev, nvme_ch->qpair, bio, BDEV_DISK_READ,
@ -183,7 +183,7 @@ bdev_nvme_writev(struct nvme_bdev *nbdev, struct spdk_io_channel *ch,
{
struct nvme_io_channel *nvme_ch = spdk_io_channel_get_ctx(ch);
SPDK_DEBUGLOG(SPDK_TRACE_BDEV_NVME, "write %lu blocks with offset %#lx\n",
SPDK_DEBUGLOG(SPDK_LOG_BDEV_NVME, "write %lu blocks with offset %#lx\n",
lba_count, lba);
return bdev_nvme_queue_cmd(nbdev, nvme_ch->qpair, bio, BDEV_DISK_WRITE,
@ -723,7 +723,7 @@ static bool
hotplug_probe_cb(void *cb_ctx, const struct spdk_nvme_transport_id *trid,
struct spdk_nvme_ctrlr_opts *opts)
{
SPDK_DEBUGLOG(SPDK_TRACE_BDEV_NVME, "Attaching to %s\n", trid->traddr);
SPDK_DEBUGLOG(SPDK_LOG_BDEV_NVME, "Attaching to %s\n", trid->traddr);
return true;
}
@ -747,7 +747,7 @@ probe_cb(void *cb_ctx, const struct spdk_nvme_transport_id *trid,
struct spdk_nvme_ctrlr_opts *opts)
{
SPDK_DEBUGLOG(SPDK_TRACE_BDEV_NVME, "Probing device %s\n", trid->traddr);
SPDK_DEBUGLOG(SPDK_LOG_BDEV_NVME, "Probing device %s\n", trid->traddr);
if (nvme_ctrlr_get(trid)) {
SPDK_ERRLOG("A controller with the provided trid (traddr: %s) already exists.\n",
@ -768,7 +768,7 @@ probe_cb(void *cb_ctx, const struct spdk_nvme_transport_id *trid,
}
if (!claim_device) {
SPDK_DEBUGLOG(SPDK_TRACE_BDEV_NVME, "Not claiming device at %s\n", trid->traddr);
SPDK_DEBUGLOG(SPDK_LOG_BDEV_NVME, "Not claiming device at %s\n", trid->traddr);
return false;
}
}
@ -847,7 +847,7 @@ attach_cb(void *cb_ctx, const struct spdk_nvme_transport_id *trid,
return;
}
SPDK_DEBUGLOG(SPDK_TRACE_BDEV_NVME, "Attached to %s (%s)\n", trid->traddr, name);
SPDK_DEBUGLOG(SPDK_LOG_BDEV_NVME, "Attached to %s (%s)\n", trid->traddr, name);
nvme_ctrlr = calloc(1, sizeof(*nvme_ctrlr));
if (nvme_ctrlr == NULL) {
@ -1134,12 +1134,12 @@ nvme_ctrlr_create_bdevs(struct nvme_ctrlr *nvme_ctrlr)
for (ns_id = 1; ns_id <= num_ns; ns_id++) {
ns = spdk_nvme_ctrlr_get_ns(ctrlr, ns_id);
if (!ns) {
SPDK_DEBUGLOG(SPDK_TRACE_BDEV_NVME, "Skipping invalid NS %d\n", ns_id);
SPDK_DEBUGLOG(SPDK_LOG_BDEV_NVME, "Skipping invalid NS %d\n", ns_id);
continue;
}
if (!spdk_nvme_ns_is_active(ns)) {
SPDK_DEBUGLOG(SPDK_TRACE_BDEV_NVME, "Skipping inactive NS %d\n", ns_id);
SPDK_DEBUGLOG(SPDK_LOG_BDEV_NVME, "Skipping inactive NS %d\n", ns_id);
continue;
}
@ -1417,4 +1417,4 @@ spdk_bdev_nvme_get_ctrlr(struct spdk_bdev *bdev)
return SPDK_CONTAINEROF(bdev, struct nvme_bdev, disk)->nvme_ctrlr->ctrlr;
}
SPDK_LOG_REGISTER_TRACE_FLAG("bdev_nvme", SPDK_TRACE_BDEV_NVME)
SPDK_LOG_REGISTER_COMPONENT("bdev_nvme", SPDK_LOG_BDEV_NVME)

4
lib/bdev/pmem/bdev_pmem.c
View File

@ -128,7 +128,7 @@ bdev_pmem_submit_io(struct spdk_bdev_io *bdev_io, struct pmem_disk *pdisk,
goto end;
}
SPDK_DEBUGLOG(SPDK_TRACE_BDEV_PMEM, "io %lu bytes from offset %#lx\n",
SPDK_DEBUGLOG(SPDK_LOG_BDEV_PMEM, "io %lu bytes from offset %#lx\n",
num_blocks, offset_blocks);
for (nbytes = num_blocks * block_size; nbytes > 0; iov++) {
@ -398,4 +398,4 @@ bdev_pmem_finish(void)
spdk_io_device_unregister(&g_pmem_disks, bdev_pmem_finish_done);
}
SPDK_LOG_REGISTER_TRACE_FLAG("bdev_pmem", SPDK_TRACE_BDEV_PMEM)
SPDK_LOG_REGISTER_COMPONENT("bdev_pmem", SPDK_LOG_BDEV_PMEM)

8
lib/bdev/pmem/bdev_pmem_rpc.c
View File

@ -69,7 +69,7 @@ spdk_rpc_construct_pmem_bdev(struct spdk_jsonrpc_request *request,
if (spdk_json_decode_object(params, rpc_construct_pmem_decoders,
SPDK_COUNTOF(rpc_construct_pmem_decoders),
&req)) {
SPDK_DEBUGLOG(SPDK_TRACE_BDEV_PMEM, "spdk_json_decode_object failed\n");
SPDK_DEBUGLOG(SPDK_LOG_BDEV_PMEM, "spdk_json_decode_object failed\n");
rc = EINVAL;
goto invalid;
}
@ -133,7 +133,7 @@ spdk_rpc_create_pmem_pool(struct spdk_jsonrpc_request *request,
if (spdk_json_decode_object(params, rpc_create_pmem_pool_decoders,
SPDK_COUNTOF(rpc_create_pmem_pool_decoders),
&req)) {
SPDK_DEBUGLOG(SPDK_TRACE_BDEV_PMEM, "spdk_json_decode_object failed\n");
SPDK_DEBUGLOG(SPDK_LOG_BDEV_PMEM, "spdk_json_decode_object failed\n");
goto invalid;
}
@ -197,7 +197,7 @@ spdk_rpc_pmem_pool_info(struct spdk_jsonrpc_request *request,
if (spdk_json_decode_object(params, rpc_pmem_pool_info_decoders,
SPDK_COUNTOF(rpc_pmem_pool_info_decoders),
&req)) {
SPDK_DEBUGLOG(SPDK_TRACE_BDEV_PMEM, "spdk_json_decode_object failed\n");
SPDK_DEBUGLOG(SPDK_LOG_BDEV_PMEM, "spdk_json_decode_object failed\n");
goto invalid;
}
@ -265,7 +265,7 @@ spdk_rpc_delete_pmem_pool(struct spdk_jsonrpc_request *request,
if (spdk_json_decode_object(params, rpc_delete_pmem_pool_decoders,
SPDK_COUNTOF(rpc_delete_pmem_pool_decoders),
&req)) {
SPDK_DEBUGLOG(SPDK_TRACE_BDEV_PMEM, "spdk_json_decode_object failed\n");
SPDK_DEBUGLOG(SPDK_LOG_BDEV_PMEM, "spdk_json_decode_object failed\n");
goto invalid;
}

2
lib/bdev/rbd/bdev_rbd.c
View File

@ -608,4 +608,4 @@ end:
return rc;
}
SPDK_LOG_REGISTER_TRACE_FLAG("bdev_rbd", SPDK_TRACE_BDEV_RBD)
SPDK_LOG_REGISTER_COMPONENT("bdev_rbd", SPDK_LOG_BDEV_RBD)

2
lib/bdev/rbd/bdev_rbd_rpc.c
View File

@ -67,7 +67,7 @@ spdk_rpc_construct_rbd_bdev(struct spdk_jsonrpc_request *request,
if (spdk_json_decode_object(params, rpc_construct_rbd_decoders,
SPDK_COUNTOF(rpc_construct_rbd_decoders),
&req)) {
SPDK_DEBUGLOG(SPDK_TRACE_BDEV_RBD, "spdk_json_decode_object failed\n");
SPDK_DEBUGLOG(SPDK_LOG_BDEV_RBD, "spdk_json_decode_object failed\n");
goto invalid;
}

8
lib/bdev/split/vbdev_split.c
View File

@ -130,11 +130,11 @@ vbdev_split_create(struct spdk_bdev *base_bdev, uint64_t split_count, uint64_t s
return -1;
}
split_size_blocks = (split_size_mb * mb) / base_bdev->blocklen;
SPDK_DEBUGLOG(SPDK_TRACE_VBDEV_SPLIT, "Split size %" PRIu64 " MB specified by user\n",
SPDK_DEBUGLOG(SPDK_LOG_VBDEV_SPLIT, "Split size %" PRIu64 " MB specified by user\n",
split_size_mb);
} else {
split_size_blocks = base_bdev->blockcnt / split_count;
SPDK_DEBUGLOG(SPDK_TRACE_VBDEV_SPLIT, "Split size not specified by user\n");
SPDK_DEBUGLOG(SPDK_LOG_VBDEV_SPLIT, "Split size not specified by user\n");
}
max_split_count = base_bdev->blockcnt / split_size_blocks;
@ -144,7 +144,7 @@ vbdev_split_create(struct spdk_bdev *base_bdev, uint64_t split_count, uint64_t s
split_count = max_split_count;
}
SPDK_DEBUGLOG(SPDK_TRACE_VBDEV_SPLIT, "base_bdev: %s split_count: %" PRIu64
SPDK_DEBUGLOG(SPDK_LOG_VBDEV_SPLIT, "base_bdev: %s split_count: %" PRIu64
" split_size_blocks: %" PRIu64 "\n",
spdk_bdev_get_name(base_bdev), split_count, split_size_blocks);
@ -272,4 +272,4 @@ vbdev_split_fini(void)
SPDK_BDEV_MODULE_REGISTER(split, vbdev_split_init, vbdev_split_fini, NULL,
NULL, vbdev_split_examine)
SPDK_LOG_REGISTER_TRACE_FLAG("vbdev_split", SPDK_TRACE_VBDEV_SPLIT)
SPDK_LOG_REGISTER_COMPONENT("vbdev_split", SPDK_LOG_VBDEV_SPLIT)

10
lib/bdev/virtio/bdev_virtio.c
View File

@ -938,7 +938,7 @@ process_scan_inquiry_vpd_block_thin_provision(struct virtio_scsi_scan_base *base
base->info.unmap_supported = !!(vpd_data[5] & SPDK_SCSI_UNMAP_LBPU);
}
SPDK_INFOLOG(SPDK_TRACE_VIRTIO, "Target %u: unmap supported = %d\n",
SPDK_INFOLOG(SPDK_LOG_VIRTIO, "Target %u: unmap supported = %d\n",
base->info.target, (int)base->info.unmap_supported);
target_id = req->lun[1];
@ -962,7 +962,7 @@ process_scan_inquiry(struct virtio_scsi_scan_base *base, struct virtio_req *vreq
case SPDK_SPC_VPD_BLOCK_THIN_PROVISION:
return process_scan_inquiry_vpd_block_thin_provision(base, vreq);
default:
SPDK_DEBUGLOG(SPDK_TRACE_VIRTIO, "Unexpected VPD page 0x%02x\n", inquiry_cdb->page_code);
SPDK_DEBUGLOG(SPDK_LOG_VIRTIO, "Unexpected VPD page 0x%02x\n", inquiry_cdb->page_code);
return -1;
}
}
@ -1074,8 +1074,8 @@ process_scan_resp(struct virtio_scsi_scan_base *base, struct virtio_req *vreq)
base->retries--;
if (base->retries == 0) {
SPDK_NOTICELOG("Target %"PRIu8" is present, but unavailable.\n", target_id);
SPDK_TRACEDUMP(SPDK_TRACE_VIRTIO, "CDB", req->cdb, sizeof(req->cdb));
SPDK_TRACEDUMP(SPDK_TRACE_VIRTIO, "SENSE DATA", resp->sense, sizeof(resp->sense));
SPDK_TRACEDUMP(SPDK_LOG_VIRTIO, "CDB", req->cdb, sizeof(req->cdb));
SPDK_TRACEDUMP(SPDK_LOG_VIRTIO, "SENSE DATA", resp->sense, sizeof(resp->sense));
scan_target_finish(base);
return;
}
@ -1455,4 +1455,4 @@ bdev_virtio_scsi_dev_create(const char *base_name, const char *path, unsigned nu
}
SPDK_LOG_REGISTER_TRACE_FLAG("virtio", SPDK_TRACE_VIRTIO)
SPDK_LOG_REGISTER_COMPONENT("virtio", SPDK_LOG_VIRTIO)

26
lib/bdev/virtio/rte_virtio/virtio.c
View File

@ -157,14 +157,14 @@ virtio_init_queue(struct virtio_dev *dev, uint16_t vtpci_queue_idx)
struct virtqueue *vq;
int ret;
SPDK_DEBUGLOG(SPDK_TRACE_VIRTIO_DEV, "setting up queue: %"PRIu16"\n", vtpci_queue_idx);
SPDK_DEBUGLOG(SPDK_LOG_VIRTIO_DEV, "setting up queue: %"PRIu16"\n", vtpci_queue_idx);
/*
* Read the virtqueue size from the Queue Size field
* Always power of 2 and if 0 virtqueue does not exist
*/
vq_size = virtio_dev_backend_ops(dev)->get_queue_num(dev, vtpci_queue_idx);
SPDK_DEBUGLOG(SPDK_TRACE_VIRTIO_DEV, "vq_size: %u\n", vq_size);
SPDK_DEBUGLOG(SPDK_LOG_VIRTIO_DEV, "vq_size: %u\n", vq_size);
if (vq_size == 0) {
SPDK_ERRLOG("virtqueue %"PRIu16" does not exist\n", vtpci_queue_idx);
return -EINVAL;
@ -196,7 +196,7 @@ virtio_init_queue(struct virtio_dev *dev, uint16_t vtpci_queue_idx)
*/
size = vring_size(vq_size, VIRTIO_PCI_VRING_ALIGN);
vq->vq_ring_size = RTE_ALIGN_CEIL(size, VIRTIO_PCI_VRING_ALIGN);
SPDK_DEBUGLOG(SPDK_TRACE_VIRTIO_DEV, "vring_size: %u, rounded_vring_size: %u\n",
SPDK_DEBUGLOG(SPDK_LOG_VIRTIO_DEV, "vring_size: %u, rounded_vring_size: %u\n",
size, vq->vq_ring_size);
queue_mem = spdk_dma_zmalloc(vq->vq_ring_size, VIRTIO_PCI_VRING_ALIGN, &queue_mem_phys_addr);
@ -207,9 +207,9 @@ virtio_init_queue(struct virtio_dev *dev, uint16_t vtpci_queue_idx)
vq->vq_ring_mem = queue_mem_phys_addr;
vq->vq_ring_virt_mem = queue_mem;
SPDK_DEBUGLOG(SPDK_TRACE_VIRTIO_DEV, "vq->vq_ring_mem: 0x%" PRIx64 "\n",
SPDK_DEBUGLOG(SPDK_LOG_VIRTIO_DEV, "vq->vq_ring_mem: 0x%" PRIx64 "\n",
vq->vq_ring_mem);
SPDK_DEBUGLOG(SPDK_TRACE_VIRTIO_DEV, "vq->vq_ring_virt_mem: 0x%" PRIx64 "\n",
SPDK_DEBUGLOG(SPDK_LOG_VIRTIO_DEV, "vq->vq_ring_virt_mem: 0x%" PRIx64 "\n",
(uint64_t)(uintptr_t)vq->vq_ring_virt_mem);
virtio_init_vring(vq);
@ -293,8 +293,8 @@ virtio_negotiate_features(struct virtio_dev *dev, uint64_t req_features)
uint64_t host_features = virtio_dev_backend_ops(dev)->get_features(dev);
int rc;
SPDK_DEBUGLOG(SPDK_TRACE_VIRTIO_DEV, "guest features = %" PRIx64 "\n", req_features);
SPDK_DEBUGLOG(SPDK_TRACE_VIRTIO_DEV, "device features = %" PRIx64 "\n", host_features);
SPDK_DEBUGLOG(SPDK_LOG_VIRTIO_DEV, "guest features = %" PRIx64 "\n", req_features);
SPDK_DEBUGLOG(SPDK_LOG_VIRTIO_DEV, "device features = %" PRIx64 "\n", host_features);
rc = virtio_dev_backend_ops(dev)->set_features(dev, req_features & host_features);
if (rc != 0) {
@ -302,7 +302,7 @@ virtio_negotiate_features(struct virtio_dev *dev, uint64_t req_features)
return -1;
}
SPDK_DEBUGLOG(SPDK_TRACE_VIRTIO_DEV, "negotiated features = %" PRIx64 "\n",
SPDK_DEBUGLOG(SPDK_LOG_VIRTIO_DEV, "negotiated features = %" PRIx64 "\n",
dev->negotiated_features);
virtio_dev_set_status(dev, VIRTIO_CONFIG_S_FEATURES_OK);
@ -446,7 +446,7 @@ virtqueue_enqueue_xmit(struct virtqueue *vq, struct virtio_req *req)
struct iovec *iov = req->iov;
if (total_iovs > vq->vq_free_cnt) {
SPDK_DEBUGLOG(SPDK_TRACE_VIRTIO_DEV,
SPDK_DEBUGLOG(SPDK_LOG_VIRTIO_DEV,
"not enough free descriptors. requested %"PRIu32", got %"PRIu16"\n",
total_iovs, vq->vq_free_cnt);
return -ENOMEM;
@ -521,12 +521,12 @@ virtio_recv_pkts(struct virtqueue *vq, struct virtio_req **reqs, uint16_t nb_pkt
num = num - ((vq->vq_used_cons_idx + num) % DESC_PER_CACHELINE);
num = virtqueue_dequeue_burst_rx(vq, rcv_pkts, len, num);
SPDK_DEBUGLOG(SPDK_TRACE_VIRTIO_DEV, "used:%"PRIu16" dequeue:%"PRIu16"\n", nb_used, num);
SPDK_DEBUGLOG(SPDK_LOG_VIRTIO_DEV, "used:%"PRIu16" dequeue:%"PRIu16"\n", nb_used, num);
for (i = 0; i < num ; i++) {
rxm = rcv_pkts[i];
SPDK_DEBUGLOG(SPDK_TRACE_VIRTIO_DEV, "packet len:%"PRIu32"\n", len[i]);
SPDK_DEBUGLOG(SPDK_LOG_VIRTIO_DEV, "packet len:%"PRIu32"\n", len[i]);
rxm->data_transferred = (uint16_t)(len[i]);
@ -554,7 +554,7 @@ virtio_xmit_pkt(struct virtqueue *vq, struct virtio_req *req)
if (spdk_unlikely(virtqueue_kick_prepare(vq))) {
virtio_dev_backend_ops(vdev)->notify_queue(vdev, vq);
SPDK_DEBUGLOG(SPDK_TRACE_VIRTIO_DEV, "Notified backend after xmit\n");
SPDK_DEBUGLOG(SPDK_LOG_VIRTIO_DEV, "Notified backend after xmit\n");
}
return 0;
@ -723,4 +723,4 @@ virtio_dev_dump_json_config(struct virtio_dev *hw, struct spdk_json_write_ctx *w
spdk_json_write_object_end(w);
}
SPDK_LOG_REGISTER_TRACE_FLAG("virtio_dev", SPDK_TRACE_VIRTIO_DEV)
SPDK_LOG_REGISTER_COMPONENT("virtio_dev", SPDK_LOG_VIRTIO_DEV)

30
lib/bdev/virtio/rte_virtio/virtio_pci.c
View File

@ -260,11 +260,11 @@ modern_setup_queue(struct virtio_dev *dev, struct virtqueue *vq)
spdk_mmio_write_2(&hw->common_cfg->queue_enable, 1);
SPDK_DEBUGLOG(SPDK_TRACE_VIRTIO_PCI, "queue %"PRIu16" addresses:\n", vq->vq_queue_index);
SPDK_DEBUGLOG(SPDK_TRACE_VIRTIO_PCI, "\t desc_addr: %" PRIx64 "\n", desc_addr);
SPDK_DEBUGLOG(SPDK_TRACE_VIRTIO_PCI, "\t aval_addr: %" PRIx64 "\n", avail_addr);
SPDK_DEBUGLOG(SPDK_TRACE_VIRTIO_PCI, "\t used_addr: %" PRIx64 "\n", used_addr);
SPDK_DEBUGLOG(SPDK_TRACE_VIRTIO_PCI, "\t notify addr: %p (notify offset: %"PRIu16")\n",
SPDK_DEBUGLOG(SPDK_LOG_VIRTIO_PCI, "queue %"PRIu16" addresses:\n", vq->vq_queue_index);
SPDK_DEBUGLOG(SPDK_LOG_VIRTIO_PCI, "\t desc_addr: %" PRIx64 "\n", desc_addr);
SPDK_DEBUGLOG(SPDK_LOG_VIRTIO_PCI, "\t aval_addr: %" PRIx64 "\n", avail_addr);
SPDK_DEBUGLOG(SPDK_LOG_VIRTIO_PCI, "\t used_addr: %" PRIx64 "\n", used_addr);
SPDK_DEBUGLOG(SPDK_LOG_VIRTIO_PCI, "\t notify addr: %p (notify offset: %"PRIu16")\n",
vq->notify_addr, notify_off);
return 0;
@ -349,7 +349,7 @@ virtio_read_caps(struct virtio_hw *hw)
ret = spdk_pci_device_cfg_read(hw->pci_dev, &pos, 1, PCI_CAPABILITY_LIST);
if (ret < 0) {
SPDK_DEBUGLOG(SPDK_TRACE_VIRTIO_PCI, "failed to read pci capability list\n");
SPDK_DEBUGLOG(SPDK_LOG_VIRTIO_PCI, "failed to read pci capability list\n");
return -1;
}
@ -364,13 +364,13 @@ virtio_read_caps(struct virtio_hw *hw)
hw->use_msix = 1;
if (cap.cap_vndr != PCI_CAP_ID_VNDR) {
SPDK_DEBUGLOG(SPDK_TRACE_VIRTIO_PCI,
SPDK_DEBUGLOG(SPDK_LOG_VIRTIO_PCI,
"[%2"PRIx8"] skipping non VNDR cap id: %02"PRIx8"\n",
pos, cap.cap_vndr);
goto next;
}
SPDK_DEBUGLOG(SPDK_TRACE_VIRTIO_PCI,
SPDK_DEBUGLOG(SPDK_LOG_VIRTIO_PCI,
"[%2"PRIx8"] cfg type: %"PRIu8", bar: %"PRIu8", offset: %04"PRIx32", len: %"PRIu32"\n",
pos, cap.cfg_type, cap.bar, cap.offset, cap.length);
@ -397,16 +397,16 @@ next:
if (hw->common_cfg == NULL || hw->notify_base == NULL ||
hw->dev_cfg == NULL || hw->isr == NULL) {
SPDK_DEBUGLOG(SPDK_TRACE_VIRTIO_PCI, "no modern virtio pci device found.\n");
SPDK_DEBUGLOG(SPDK_LOG_VIRTIO_PCI, "no modern virtio pci device found.\n");
return -1;
}
SPDK_DEBUGLOG(SPDK_TRACE_VIRTIO_PCI, "found modern virtio pci device.\n");
SPDK_DEBUGLOG(SPDK_LOG_VIRTIO_PCI, "found modern virtio pci device.\n");
SPDK_DEBUGLOG(SPDK_TRACE_VIRTIO_PCI, "common cfg mapped at: %p\n", hw->common_cfg);
SPDK_DEBUGLOG(SPDK_TRACE_VIRTIO_PCI, "device cfg mapped at: %p\n", hw->dev_cfg);
SPDK_DEBUGLOG(SPDK_TRACE_VIRTIO_PCI, "isr cfg mapped at: %p\n", hw->isr);
SPDK_DEBUGLOG(SPDK_TRACE_VIRTIO_PCI, "notify base: %p, notify off multiplier: %u\n",
SPDK_DEBUGLOG(SPDK_LOG_VIRTIO_PCI, "common cfg mapped at: %p\n", hw->common_cfg);
SPDK_DEBUGLOG(SPDK_LOG_VIRTIO_PCI, "device cfg mapped at: %p\n", hw->dev_cfg);
SPDK_DEBUGLOG(SPDK_LOG_VIRTIO_PCI, "isr cfg mapped at: %p\n", hw->isr);
SPDK_DEBUGLOG(SPDK_LOG_VIRTIO_PCI, "notify base: %p, notify off multiplier: %u\n",
hw->notify_base, hw->notify_off_multiplier);
return 0;
@ -510,4 +510,4 @@ virtio_pci_dev_init(struct virtio_dev *vdev, const char *name,
return 0;
}
SPDK_LOG_REGISTER_TRACE_FLAG("virtio_pci", SPDK_TRACE_VIRTIO_PCI)
SPDK_LOG_REGISTER_COMPONENT("virtio_pci", SPDK_LOG_VIRTIO_PCI)

4
lib/bdev/virtio/rte_virtio/virtio_user/vhost_user.c
View File

@ -291,7 +291,7 @@ vhost_user_sock(struct virtio_user_dev *dev,
int i, len;
int vhostfd = dev->vhostfd;
SPDK_DEBUGLOG(SPDK_TRACE_VIRTIO_USER, "sent message %d = %s\n", req, vhost_msg_strings[req]);
SPDK_DEBUGLOG(SPDK_LOG_VIRTIO_USER, "sent message %d = %s\n", req, vhost_msg_strings[req]);
msg.request = req;
msg.flags = VHOST_USER_VERSION;
@ -464,4 +464,4 @@ struct virtio_user_backend_ops ops_user = {
.send_request = vhost_user_sock,
};
SPDK_LOG_REGISTER_TRACE_FLAG("virtio_user", SPDK_TRACE_VIRTIO_USER)
SPDK_LOG_REGISTER_COMPONENT("virtio_user", SPDK_LOG_VIRTIO_USER)

40
lib/blob/blobstore.c
View File

@ -60,7 +60,7 @@ _spdk_bs_claim_cluster(struct spdk_blob_store *bs, uint32_t cluster_num)
assert(spdk_bit_array_get(bs->used_clusters, cluster_num) == false);
assert(bs->num_free_clusters > 0);
SPDK_DEBUGLOG(SPDK_TRACE_BLOB, "Claiming cluster %u\n", cluster_num);
SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Claiming cluster %u\n", cluster_num);
spdk_bit_array_set(bs->used_clusters, cluster_num);
bs->num_free_clusters--;
@ -73,7 +73,7 @@ _spdk_bs_release_cluster(struct spdk_blob_store *bs, uint32_t cluster_num)
assert(spdk_bit_array_get(bs->used_clusters, cluster_num) == true);
assert(bs->num_free_clusters < bs->total_clusters);
SPDK_DEBUGLOG(SPDK_TRACE_BLOB, "Releasing cluster %u\n", cluster_num);
SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Releasing cluster %u\n", cluster_num);
spdk_bit_array_clear(bs->used_clusters, cluster_num);
bs->num_free_clusters++;
@ -1029,7 +1029,7 @@ _spdk_resize_blob(struct spdk_blob *blob, uint64_t sz)
lfc = 0;
for (i = blob->active.num_clusters; i < sz; i++) {
lfc = spdk_bit_array_find_first_clear(bs->used_clusters, lfc);
SPDK_DEBUGLOG(SPDK_TRACE_BLOB, "Claiming cluster %lu for blob %lu\n", lfc, blob->id);
SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Claiming cluster %lu for blob %lu\n", lfc, blob->id);
_spdk_bs_claim_cluster(bs, lfc);
blob->active.clusters[i] = _spdk_bs_cluster_to_lba(bs, lfc);
lfc++;
@ -1128,7 +1128,7 @@ _spdk_blob_persist(spdk_bs_sequence_t *seq, struct spdk_blob *blob,
ctx->pages[i - 1].crc = _spdk_blob_md_page_calc_crc(&ctx->pages[i - 1]);
blob->active.pages[i] = page_num;
spdk_bit_array_set(bs->used_md_pages, page_num);
SPDK_DEBUGLOG(SPDK_TRACE_BLOB, "Claiming page %u for blob %lu\n", page_num, blob->id);
SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Claiming page %u for blob %lu\n", page_num, blob->id);
page_num++;
}
ctx->pages[i - 1].crc = _spdk_blob_md_page_calc_crc(&ctx->pages[i - 1]);
@ -2020,13 +2020,13 @@ _spdk_bs_load_super_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
}
if (memcmp(&ctx->bs->bstype, &ctx->super->bstype, SPDK_BLOBSTORE_TYPE_LENGTH) == 0) {
SPDK_DEBUGLOG(SPDK_TRACE_BLOB, "Bstype matched - loading blobstore\n");
SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Bstype matched - loading blobstore\n");
} else if (memcmp(&ctx->bs->bstype, zeros, SPDK_BLOBSTORE_TYPE_LENGTH) == 0) {
SPDK_DEBUGLOG(SPDK_TRACE_BLOB, "Bstype wildcard used - loading blobstore regardless bstype\n");
SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Bstype wildcard used - loading blobstore regardless bstype\n");
} else {
SPDK_DEBUGLOG(SPDK_TRACE_BLOB, "Unexpected bstype\n");
SPDK_TRACEDUMP(SPDK_TRACE_BLOB, "Expected:", ctx->bs->bstype.bstype, SPDK_BLOBSTORE_TYPE_LENGTH);
SPDK_TRACEDUMP(SPDK_TRACE_BLOB, "Found:", ctx->super->bstype.bstype, SPDK_BLOBSTORE_TYPE_LENGTH);
SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Unexpected bstype\n");
SPDK_TRACEDUMP(SPDK_LOG_BLOB, "Expected:", ctx->bs->bstype.bstype, SPDK_BLOBSTORE_TYPE_LENGTH);
SPDK_TRACEDUMP(SPDK_LOG_BLOB, "Found:", ctx->super->bstype.bstype, SPDK_BLOBSTORE_TYPE_LENGTH);
spdk_dma_free(ctx->super);
_spdk_bs_free(ctx->bs);
free(ctx);
@ -2063,7 +2063,7 @@ spdk_bs_load(struct spdk_bs_dev *dev, struct spdk_bs_opts *o,
struct spdk_bs_load_ctx *ctx;
struct spdk_bs_opts opts = {};
SPDK_DEBUGLOG(SPDK_TRACE_BLOB, "Loading blobstore from dev %p\n", dev);
SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Loading blobstore from dev %p\n", dev);
if (o) {
opts = *o;
@ -2166,7 +2166,7 @@ spdk_bs_init(struct spdk_bs_dev *dev, struct spdk_bs_opts *o,
struct spdk_bs_opts opts = {};
int rc;
SPDK_DEBUGLOG(SPDK_TRACE_BLOB, "Initializing blobstore on dev %p\n", dev);
SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Initializing blobstore on dev %p\n", dev);
if ((SPDK_BS_PAGE_SIZE % dev->blocklen) != 0) {
SPDK_ERRLOG("unsupported dev block length of %d\n",
@ -2346,7 +2346,7 @@ spdk_bs_destroy(struct spdk_blob_store *bs, spdk_bs_op_complete cb_fn,
spdk_bs_sequence_t *seq;
struct spdk_bs_init_ctx *ctx;
SPDK_DEBUGLOG(SPDK_TRACE_BLOB, "Destroying blobstore\n");
SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Destroying blobstore\n");
if (!TAILQ_EMPTY(&bs->blobs)) {
SPDK_ERRLOG("Blobstore still has open blobs\n");
@ -2439,7 +2439,7 @@ spdk_bs_unload(struct spdk_blob_store *bs, spdk_bs_op_complete cb_fn, void *cb_a
spdk_bs_sequence_t *seq;
struct spdk_bs_load_ctx *ctx;
SPDK_DEBUGLOG(SPDK_TRACE_BLOB, "Syncing blobstore\n");
SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Syncing blobstore\n");
if (!TAILQ_EMPTY(&bs->blobs)) {
SPDK_ERRLOG("Blobstore still has open blobs\n");
@ -2594,7 +2594,7 @@ void spdk_bs_md_create_blob(struct spdk_blob_store *bs,
id = _spdk_bs_page_to_blobid(page_idx);
SPDK_DEBUGLOG(SPDK_TRACE_BLOB, "Creating blob with id %lu at page %u\n", id, page_idx);
SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Creating blob with id %lu at page %u\n", id, page_idx);
blob = _spdk_blob_alloc(bs, id);
if (!blob) {
@ -2627,7 +2627,7 @@ spdk_bs_md_resize_blob(struct spdk_blob *blob, uint64_t sz)
assert(blob != NULL);
SPDK_DEBUGLOG(SPDK_TRACE_BLOB, "Resizing blob %lu to %lu clusters\n", blob->id, sz);
SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Resizing blob %lu to %lu clusters\n", blob->id, sz);
if (blob->md_ro) {
return -EPERM;
@ -2685,7 +2685,7 @@ spdk_bs_md_delete_blob(struct spdk_blob_store *bs, spdk_blob_id blobid,
struct spdk_bs_cpl cpl;
spdk_bs_sequence_t *seq;
SPDK_DEBUGLOG(SPDK_TRACE_BLOB, "Deleting blob %lu\n", blobid);
SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Deleting blob %lu\n", blobid);
blob = _spdk_blob_lookup(bs, blobid);
if (blob) {
@ -2745,7 +2745,7 @@ void spdk_bs_md_open_blob(struct spdk_blob_store *bs, spdk_blob_id blobid,
spdk_bs_sequence_t *seq;
uint32_t page_num;
SPDK_DEBUGLOG(SPDK_TRACE_BLOB, "Opening blob %lu\n", blobid);
SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Opening blob %lu\n", blobid);
blob = _spdk_blob_lookup(bs, blobid);
if (blob) {
@ -2797,7 +2797,7 @@ void spdk_bs_md_sync_blob(struct spdk_blob *blob,
assert(blob != NULL);
SPDK_DEBUGLOG(SPDK_TRACE_BLOB, "Syncing blob %lu\n", blob->id);
SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Syncing blob %lu\n", blob->id);
assert(blob->state != SPDK_BLOB_STATE_LOADING &&
blob->state != SPDK_BLOB_STATE_SYNCING);
@ -2855,7 +2855,7 @@ void spdk_bs_md_close_blob(struct spdk_blob **b,
blob = *b;
assert(blob != NULL);
SPDK_DEBUGLOG(SPDK_TRACE_BLOB, "Closing blob %lu\n", blob->id);
SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Closing blob %lu\n", blob->id);
assert(blob->state != SPDK_BLOB_STATE_LOADING &&
blob->state != SPDK_BLOB_STATE_SYNCING);
@ -3203,4 +3203,4 @@ spdk_bs_set_bstype(struct spdk_blob_store *bs, struct spdk_bs_type bstype)
memcpy(&bs->bstype, &bstype, sizeof(bstype));
}
SPDK_LOG_REGISTER_TRACE_FLAG("blob", SPDK_TRACE_BLOB);
SPDK_LOG_REGISTER_COMPONENT("blob", SPDK_LOG_BLOB)

26
lib/blob/request.c
View File

@ -133,7 +133,7 @@ spdk_bs_sequence_read(spdk_bs_sequence_t *seq, void *payload,
struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)seq;
struct spdk_bs_channel *channel = set->channel;
SPDK_DEBUGLOG(SPDK_TRACE_BLOB_RW, "Reading %u blocks from LBA %lu\n", lba_count, lba);
SPDK_DEBUGLOG(SPDK_LOG_BLOB_RW, "Reading %u blocks from LBA %lu\n", lba_count, lba);
set->u.sequence.cb_fn = cb_fn;
set->u.sequence.cb_arg = cb_arg;
@ -150,7 +150,7 @@ spdk_bs_sequence_write(spdk_bs_sequence_t *seq, void *payload,
struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)seq;
struct spdk_bs_channel *channel = set->channel;
SPDK_DEBUGLOG(SPDK_TRACE_BLOB_RW, "Writing %u blocks to LBA %lu\n", lba_count, lba);
SPDK_DEBUGLOG(SPDK_LOG_BLOB_RW, "Writing %u blocks to LBA %lu\n", lba_count, lba);
set->u.sequence.cb_fn = cb_fn;
set->u.sequence.cb_arg = cb_arg;
@ -167,7 +167,7 @@ spdk_bs_sequence_readv(spdk_bs_sequence_t *seq, struct iovec *iov, int iovcnt,
struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)seq;
struct spdk_bs_channel *channel = set->channel;
SPDK_DEBUGLOG(SPDK_TRACE_BLOB_RW, "Reading %u blocks from LBA %lu\n", lba_count, lba);
SPDK_DEBUGLOG(SPDK_LOG_BLOB_RW, "Reading %u blocks from LBA %lu\n", lba_count, lba);
set->u.sequence.cb_fn = cb_fn;
set->u.sequence.cb_arg = cb_arg;
@ -184,7 +184,7 @@ spdk_bs_sequence_writev(spdk_bs_sequence_t *seq, struct iovec *iov, int iovcnt,
struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)seq;
struct spdk_bs_channel *channel = set->channel;
SPDK_DEBUGLOG(SPDK_TRACE_BLOB_RW, "Writing %u blocks to LBA %lu\n", lba_count, lba);
SPDK_DEBUGLOG(SPDK_LOG_BLOB_RW, "Writing %u blocks to LBA %lu\n", lba_count, lba);
set->u.sequence.cb_fn = cb_fn;
set->u.sequence.cb_arg = cb_arg;
@ -200,7 +200,7 @@ spdk_bs_sequence_flush(spdk_bs_sequence_t *seq,
struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)seq;
struct spdk_bs_channel *channel = set->channel;
SPDK_DEBUGLOG(SPDK_TRACE_BLOB_RW, "Flushing\n");
SPDK_DEBUGLOG(SPDK_LOG_BLOB_RW, "Flushing\n");
set->u.sequence.cb_fn = cb_fn;
set->u.sequence.cb_arg = cb_arg;
@ -217,7 +217,7 @@ spdk_bs_sequence_unmap(spdk_bs_sequence_t *seq,
struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)seq;
struct spdk_bs_channel *channel = set->channel;
SPDK_DEBUGLOG(SPDK_TRACE_BLOB_RW, "Unmapping %u blocks at LBA %lu\n", lba_count, lba);
SPDK_DEBUGLOG(SPDK_LOG_BLOB_RW, "Unmapping %u blocks at LBA %lu\n", lba_count, lba);
set->u.sequence.cb_fn = cb_fn;
set->u.sequence.cb_arg = cb_arg;
@ -234,7 +234,7 @@ spdk_bs_sequence_write_zeroes(spdk_bs_sequence_t *seq,
struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)seq;
struct spdk_bs_channel *channel = set->channel;
SPDK_DEBUGLOG(SPDK_TRACE_BLOB_RW, "writing zeroes to %u blocks at LBA %lu\n", lba_count, lba);
SPDK_DEBUGLOG(SPDK_LOG_BLOB_RW, "writing zeroes to %u blocks at LBA %lu\n", lba_count, lba);
set->u.sequence.cb_fn = cb_fn;
set->u.sequence.cb_arg = cb_arg;
@ -311,7 +311,7 @@ spdk_bs_batch_read(spdk_bs_batch_t *batch, void *payload,
struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)batch;
struct spdk_bs_channel *channel = set->channel;
SPDK_DEBUGLOG(SPDK_TRACE_BLOB_RW, "Reading %u blocks from LBA %lu\n", lba_count, lba);
SPDK_DEBUGLOG(SPDK_LOG_BLOB_RW, "Reading %u blocks from LBA %lu\n", lba_count, lba);
set->u.batch.outstanding_ops++;
channel->dev->read(channel->dev, channel->dev_channel, payload, lba, lba_count,
@ -325,7 +325,7 @@ spdk_bs_batch_write(spdk_bs_batch_t *batch, void *payload,
struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)batch;
struct spdk_bs_channel *channel = set->channel;
SPDK_DEBUGLOG(SPDK_TRACE_BLOB_RW, "Writing %u blocks to LBA %lu\n", lba_count, lba);
SPDK_DEBUGLOG(SPDK_LOG_BLOB_RW, "Writing %u blocks to LBA %lu\n", lba_count, lba);
set->u.batch.outstanding_ops++;
channel->dev->write(channel->dev, channel->dev_channel, payload, lba, lba_count,
@ -338,7 +338,7 @@ spdk_bs_batch_flush(spdk_bs_batch_t *batch)
struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)batch;
struct spdk_bs_channel *channel = set->channel;
SPDK_DEBUGLOG(SPDK_TRACE_BLOB_RW, "Flushing\n");
SPDK_DEBUGLOG(SPDK_LOG_BLOB_RW, "Flushing\n");
set->u.batch.outstanding_ops++;
channel->dev->flush(channel->dev, channel->dev_channel,
@ -352,7 +352,7 @@ spdk_bs_batch_unmap(spdk_bs_batch_t *batch,
struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)batch;
struct spdk_bs_channel *channel = set->channel;
SPDK_DEBUGLOG(SPDK_TRACE_BLOB_RW, "Unmapping %u blocks at LBA %lu\n", lba_count, lba);
SPDK_DEBUGLOG(SPDK_LOG_BLOB_RW, "Unmapping %u blocks at LBA %lu\n", lba_count, lba);
set->u.batch.outstanding_ops++;
channel->dev->unmap(channel->dev, channel->dev_channel, lba, lba_count,
@ -366,7 +366,7 @@ spdk_bs_batch_write_zeroes(spdk_bs_batch_t *batch,
struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)batch;
struct spdk_bs_channel *channel = set->channel;
SPDK_DEBUGLOG(SPDK_TRACE_BLOB_RW, "Zeroing %u blocks at LBA %lu\n", lba_count, lba);
SPDK_DEBUGLOG(SPDK_LOG_BLOB_RW, "Zeroing %u blocks at LBA %lu\n", lba_count, lba);
set->u.batch.outstanding_ops++;
channel->dev->write_zeroes(channel->dev, channel->dev_channel, lba, lba_count,
@ -405,4 +405,4 @@ spdk_bs_sequence_to_batch(spdk_bs_sequence_t *seq, spdk_bs_sequence_cpl cb_fn, v
return set;
}
SPDK_LOG_REGISTER_TRACE_FLAG("blob_rw", SPDK_TRACE_BLOB_RW);
SPDK_LOG_REGISTER_COMPONENT("blob_rw", SPDK_LOG_BLOB_RW)

42
lib/blobfs/blobfs.c
View File

@ -45,10 +45,10 @@
#include "spdk_internal/log.h"
#define BLOBFS_TRACE(file, str, args...) \
SPDK_DEBUGLOG(SPDK_TRACE_BLOBFS, "file=%s " str, file->name, ##args)
SPDK_DEBUGLOG(SPDK_LOG_BLOBFS, "file=%s " str, file->name, ##args)
#define BLOBFS_TRACE_RW(file, str, args...) \
SPDK_DEBUGLOG(SPDK_TRACE_BLOBFS_RW, "file=%s " str, file->name, ##args)
SPDK_DEBUGLOG(SPDK_LOG_BLOBFS_RW, "file=%s " str, file->name, ##args)
#define BLOBFS_CACHE_SIZE (4ULL * 1024 * 1024 * 1024)
@ -610,7 +610,7 @@ iter_cb(void *ctx, struct spdk_blob *blob, int rc)
f->length = *length;
f->length_flushed = *length;
f->append_pos = *length;
SPDK_DEBUGLOG(SPDK_TRACE_BLOBFS, "added file %s length=%ju\n", f->name, f->length);
SPDK_DEBUGLOG(SPDK_LOG_BLOBFS, "added file %s length=%ju\n", f->name, f->length);
} else {
struct spdk_deleted_file *deleted_file;
@ -647,11 +647,11 @@ load_cb(void *ctx, struct spdk_blob_store *bs, int bserrno)
bstype = spdk_bs_get_bstype(bs);
if (!memcmp(&bstype, &zeros, sizeof(bstype))) {
SPDK_DEBUGLOG(SPDK_TRACE_BLOB, "assigning bstype\n");
SPDK_DEBUGLOG(SPDK_LOG_BLOB, "assigning bstype\n");
spdk_bs_set_bstype(bs, blobfs_type);
} else if (memcmp(&bstype, &blobfs_type, sizeof(bstype))) {
SPDK_DEBUGLOG(SPDK_TRACE_BLOB, "not blobfs\n");
SPDK_TRACEDUMP(SPDK_TRACE_BLOB, "bstype", &bstype, sizeof(bstype));
SPDK_DEBUGLOG(SPDK_LOG_BLOB, "not blobfs\n");
SPDK_TRACEDUMP(SPDK_LOG_BLOB, "bstype", &bstype, sizeof(bstype));
args->fn.fs_op_with_handle(args->arg, NULL, bserrno);
free_fs_request(req);
free(fs);
@ -922,7 +922,7 @@ __fs_create_file_done(void *arg, int fserrno)
args->rc = fserrno;
sem_post(args->sem);
SPDK_DEBUGLOG(SPDK_TRACE_BLOBFS, "file=%s\n", args->op.create.name);
SPDK_DEBUGLOG(SPDK_LOG_BLOBFS, "file=%s\n", args->op.create.name);
}
static void
@ -931,7 +931,7 @@ __fs_create_file(void *arg)
struct spdk_fs_request *req = arg;
struct spdk_fs_cb_args *args = &req->args;
SPDK_DEBUGLOG(SPDK_TRACE_BLOBFS, "file=%s\n", args->op.create.name);
SPDK_DEBUGLOG(SPDK_LOG_BLOBFS, "file=%s\n", args->op.create.name);
spdk_fs_create_file_async(args->fs, args->op.create.name, __fs_create_file_done, req);
}
@ -943,7 +943,7 @@ spdk_fs_create_file(struct spdk_filesystem *fs, struct spdk_io_channel *_channel
struct spdk_fs_cb_args *args;
int rc;
SPDK_DEBUGLOG(SPDK_TRACE_BLOBFS, "file=%s\n", name);
SPDK_DEBUGLOG(SPDK_LOG_BLOBFS, "file=%s\n", name);
req = alloc_fs_request(channel);
assert(req != NULL);
@ -1065,7 +1065,7 @@ __fs_open_file_done(void *arg, struct spdk_file *file, int bserrno)
args->file = file;
args->rc = bserrno;
sem_post(args->sem);
SPDK_DEBUGLOG(SPDK_TRACE_BLOBFS, "file=%s\n", args->op.open.name);
SPDK_DEBUGLOG(SPDK_LOG_BLOBFS, "file=%s\n", args->op.open.name);
}
static void
@ -1074,7 +1074,7 @@ __fs_open_file(void *arg)
struct spdk_fs_request *req = arg;
struct spdk_fs_cb_args *args = &req->args;
SPDK_DEBUGLOG(SPDK_TRACE_BLOBFS, "file=%s\n", args->op.open.name);
SPDK_DEBUGLOG(SPDK_LOG_BLOBFS, "file=%s\n", args->op.open.name);
spdk_fs_open_file_async(args->fs, args->op.open.name, args->op.open.flags,
__fs_open_file_done, req);
}
@ -1088,7 +1088,7 @@ spdk_fs_open_file(struct spdk_filesystem *fs, struct spdk_io_channel *_channel,
struct spdk_fs_cb_args *args;
int rc;
SPDK_DEBUGLOG(SPDK_TRACE_BLOBFS, "file=%s\n", name);
SPDK_DEBUGLOG(SPDK_LOG_BLOBFS, "file=%s\n", name);
req = alloc_fs_request(channel);
assert(req != NULL);
@ -1168,7 +1168,7 @@ spdk_fs_rename_file_async(struct spdk_filesystem *fs,
struct spdk_fs_request *req;
struct spdk_fs_cb_args *args;
SPDK_DEBUGLOG(SPDK_TRACE_BLOBFS, "old=%s new=%s\n", old_name, new_name);
SPDK_DEBUGLOG(SPDK_LOG_BLOBFS, "old=%s new=%s\n", old_name, new_name);
if (strnlen(new_name, SPDK_FILE_NAME_MAX + 1) == SPDK_FILE_NAME_MAX + 1) {
cb_fn(cb_arg, -ENAMETOOLONG);
return;
@ -1264,7 +1264,7 @@ spdk_fs_delete_file_async(struct spdk_filesystem *fs, const char *name,
struct spdk_fs_request *req;
struct spdk_fs_cb_args *args;
SPDK_DEBUGLOG(SPDK_TRACE_BLOBFS, "file=%s\n", name);
SPDK_DEBUGLOG(SPDK_LOG_BLOBFS, "file=%s\n", name);
if (strnlen(name, SPDK_FILE_NAME_MAX + 1) == SPDK_FILE_NAME_MAX + 1) {
cb_fn(cb_arg, -ENAMETOOLONG);
@ -1383,7 +1383,7 @@ uint64_t
spdk_file_get_length(struct spdk_file *file)
{
assert(file != NULL);
SPDK_DEBUGLOG(SPDK_TRACE_BLOBFS, "file=%s length=0x%jx\n", file->name, file->length);
SPDK_DEBUGLOG(SPDK_LOG_BLOBFS, "file=%s length=0x%jx\n", file->name, file->length);
return file->length;
}
@ -1412,7 +1412,7 @@ spdk_file_truncate_async(struct spdk_file *file, uint64_t length,
struct spdk_fs_request *req;
struct spdk_fs_cb_args *args;
SPDK_DEBUGLOG(SPDK_TRACE_BLOBFS, "file=%s old=0x%jx new=0x%jx\n", file->name, file->length, length);
SPDK_DEBUGLOG(SPDK_LOG_BLOBFS, "file=%s old=0x%jx new=0x%jx\n", file->name, file->length, length);
if (length == file->length) {
cb_fn(cb_arg, 0);
return;
@ -1592,7 +1592,7 @@ spdk_file_read_async(struct spdk_file *file, struct spdk_io_channel *channel,
void *payload, uint64_t offset, uint64_t length,
spdk_file_op_complete cb_fn, void *cb_arg)
{
SPDK_DEBUGLOG(SPDK_TRACE_BLOBFS, "file=%s offset=%jx length=%jx\n",
SPDK_DEBUGLOG(SPDK_LOG_BLOBFS, "file=%s offset=%jx length=%jx\n",
file->name, offset, length);
__readwrite(file, channel, payload, offset, length, cb_fn, cb_arg, 1);
}
@ -1715,7 +1715,7 @@ cache_insert_buffer(struct spdk_file *file, uint64_t offset)
buf = calloc(1, sizeof(*buf));
if (buf == NULL) {
SPDK_DEBUGLOG(SPDK_TRACE_BLOBFS, "calloc failed\n");
SPDK_DEBUGLOG(SPDK_LOG_BLOBFS, "calloc failed\n");
return NULL;
}
@ -1760,7 +1760,7 @@ cache_append_buffer(struct spdk_file *file)
last = cache_insert_buffer(file, file->append_pos);
if (last == NULL) {
SPDK_DEBUGLOG(SPDK_TRACE_BLOBFS, "cache_insert_buffer failed\n");
SPDK_DEBUGLOG(SPDK_LOG_BLOBFS, "cache_insert_buffer failed\n");
return NULL;
}
@ -2465,5 +2465,5 @@ cache_free_buffers(struct spdk_file *file)
pthread_spin_unlock(&file->lock);
}
SPDK_LOG_REGISTER_TRACE_FLAG("blobfs", SPDK_TRACE_BLOBFS);
SPDK_LOG_REGISTER_TRACE_FLAG("blobfs_rw", SPDK_TRACE_BLOBFS_RW);
SPDK_LOG_REGISTER_COMPONENT("blobfs", SPDK_LOG_BLOBFS)
SPDK_LOG_REGISTER_COMPONENT("blobfs_rw", SPDK_LOG_BLOBFS_RW)

4
lib/event/reactor.c
View File

@ -319,7 +319,7 @@ get_rusage(void *arg)
}
if (rusage.ru_nvcsw != reactor->rusage.ru_nvcsw || rusage.ru_nivcsw != reactor->rusage.ru_nivcsw) {
SPDK_INFOLOG(SPDK_TRACE_REACTOR,
SPDK_INFOLOG(SPDK_LOG_REACTOR,
"Reactor %d: %ld voluntary context switches and %ld involuntary context switches in the last second.\n",
reactor->lcore, rusage.ru_nvcsw - reactor->rusage.ru_nvcsw,
rusage.ru_nivcsw - reactor->rusage.ru_nivcsw);
@ -739,4 +739,4 @@ spdk_reactors_fini(void)
}
}
SPDK_LOG_REGISTER_TRACE_FLAG("reactor", SPDK_TRACE_REACTOR)
SPDK_LOG_REGISTER_COMPONENT("reactor", SPDK_LOG_REACTOR)

6
lib/event/rpc/app_rpc.c
View File

@ -75,7 +75,7 @@ spdk_rpc_kill_instance(struct spdk_jsonrpc_request *request,
if (spdk_json_decode_object(params, rpc_kill_instance_decoders,
SPDK_COUNTOF(rpc_kill_instance_decoders),
&req)) {
SPDK_DEBUGLOG(SPDK_TRACE_REACTOR, "spdk_json_decode_object failed\n");
SPDK_DEBUGLOG(SPDK_LOG_REACTOR, "spdk_json_decode_object failed\n");
goto invalid;
}
@ -92,7 +92,7 @@ spdk_rpc_kill_instance(struct spdk_jsonrpc_request *request,
goto invalid;
}
SPDK_DEBUGLOG(SPDK_TRACE_REACTOR, "sending signal %d\n", signals[i].signal);
SPDK_DEBUGLOG(SPDK_LOG_REACTOR, "sending signal %d\n", signals[i].signal);
kill(getpid(), signals[i].signal);
free_rpc_kill_instance(&req);
@ -130,7 +130,7 @@ spdk_rpc_context_switch_monitor(struct spdk_jsonrpc_request *request,
if (spdk_json_decode_object(params, rpc_context_switch_monitor_decoders,
SPDK_COUNTOF(rpc_context_switch_monitor_decoders),
&req)) {
SPDK_DEBUGLOG(SPDK_TRACE_REACTOR, "spdk_json_decode_object failed\n");
SPDK_DEBUGLOG(SPDK_LOG_REACTOR, "spdk_json_decode_object failed\n");
spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters");
return;
}

2
lib/ioat/ioat.c
View File

@ -717,4 +717,4 @@ spdk_ioat_process_events(struct spdk_ioat_chan *ioat)
return ioat_process_channel_events(ioat);
}
SPDK_LOG_REGISTER_TRACE_FLAG("ioat", SPDK_TRACE_IOAT)
SPDK_LOG_REGISTER_COMPONENT("ioat", SPDK_LOG_IOAT)

20
lib/iscsi/conn.c
View File

@ -348,7 +348,7 @@ int spdk_initialize_iscsi_conns(void)
int conns_array_fd;
int i, rc;
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "spdk_iscsi_init\n");
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "spdk_iscsi_init\n");
rc = pthread_mutex_init(&g_conns_mutex, NULL);
if (rc != 0) {
@ -643,13 +643,13 @@ static void spdk_iscsi_remove_conn(struct spdk_iscsi_conn *conn)
if (sess->connections == 0) {
/* cleanup last connection */
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI,
SPDK_DEBUGLOG(SPDK_LOG_ISCSI,
"cleanup last conn free sess\n");
spdk_free_sess(sess);
}
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "cleanup free conn\n");
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "cleanup free conn\n");
spdk_iscsi_conn_free(conn);
}
@ -871,7 +871,7 @@ spdk_iscsi_drop_conns(struct spdk_iscsi_conn *conn, const char *conn_match,
const char *xconn_match;
int i, num;
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "spdk_iscsi_drop_conns\n");
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "spdk_iscsi_drop_conns\n");
num = 0;
pthread_mutex_lock(&g_conns_mutex);
@ -905,12 +905,12 @@ spdk_iscsi_drop_conns(struct spdk_iscsi_conn *conn, const char *conn_match,
SPDK_ERRLOG("exiting conn by %s (%s)\n",
xconn_match, xconn->initiator_addr);
if (xconn->sess != NULL) {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "TSIH=%u\n", xconn->sess->tsih);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "TSIH=%u\n", xconn->sess->tsih);
} else {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "TSIH=xx\n");
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "TSIH=xx\n");
}
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "CID=%u\n", xconn->cid);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "CID=%u\n", xconn->cid);
xconn->state = ISCSI_CONN_STATE_EXITING;
num++;
}
@ -1242,7 +1242,7 @@ spdk_iscsi_conn_flush_pdus_internal(struct spdk_iscsi_conn *conn)
if ((conn->full_feature) &&
(conn->sess->ErrorRecoveryLevel >= 1) &&
spdk_iscsi_is_deferred_free_pdu(pdu)) {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "stat_sn=%d\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "stat_sn=%d\n",
from_be32(&pdu->bhs.stat_sn));
TAILQ_INSERT_TAIL(&conn->snack_pdu_list, pdu,
tailq);
@ -1522,7 +1522,7 @@ void spdk_iscsi_conn_idle_do_work(void *arg)
spdk_net_framework_clear_socket_association(tconn->sock);
spdk_event_call(spdk_iscsi_conn_get_migrate_event(tconn, &lcore));
__sync_fetch_and_add(&g_num_connections[lcore], 1);
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "add conn id = %d, cid = %d poller = %p to lcore = %d active\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "add conn id = %d, cid = %d poller = %p to lcore = %d active\n",
tconn->id, tconn->cid, &tconn->poller, lcore);
}
} /* for each conn in idle list */
@ -1547,7 +1547,7 @@ __add_idle_conn(void *arg1, void *arg2)
rc = add_idle_conn(conn);
if (rc == 0) {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "add conn id = %d, cid = %d poller = %p to idle\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "add conn id = %d, cid = %d poller = %p to idle\n",
conn->id, conn->cid, conn->poller);
conn->is_idle = 1;
STAILQ_INSERT_TAIL(&g_idle_conn_list_head, conn, link);

16
lib/iscsi/init_grp.c
View File

@ -117,7 +117,7 @@ spdk_iscsi_init_grp_add_initiator(struct spdk_iscsi_init_grp *ig, char *name)
TAILQ_INSERT_TAIL(&ig->initiator_head, iname, tailq);
ig->ninitiators++;
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "InitiatorName %s\n", name);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "InitiatorName %s\n", name);
return 0;
}
@ -223,7 +223,7 @@ spdk_iscsi_init_grp_add_netmask(struct spdk_iscsi_init_grp *ig, char *mask)
TAILQ_INSERT_TAIL(&ig->netmask_head, imask, tailq);
ig->nnetmasks++;
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "Netmask %s\n", mask);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "Netmask %s\n", mask);
return 0;
}
@ -290,11 +290,11 @@ spdk_iscsi_init_grp_create_from_configfile(struct spdk_conf_section *sp)
char **initiators = NULL, **netmasks = NULL;
int tag = spdk_conf_section_get_num(sp);
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "add initiator group %d\n", tag);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "add initiator group %d\n", tag);
val = spdk_conf_section_get_val(sp, "Comment");
if (val != NULL) {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "Comment %s\n", val);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "Comment %s\n", val);
}
/* counts number of definitions */
@ -339,7 +339,7 @@ spdk_iscsi_init_grp_create_from_configfile(struct spdk_conf_section *sp)
rc = -EINVAL;
goto cleanup;
}
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "InitiatorName %s\n", val);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "InitiatorName %s\n", val);
initiators[i] = strdup(val);
if (!initiators[i]) {
perror("initiator name copy");
@ -360,7 +360,7 @@ spdk_iscsi_init_grp_create_from_configfile(struct spdk_conf_section *sp)
rc = -EINVAL;
goto cleanup;
}
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "Netmask %s\n", val);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "Netmask %s\n", val);
netmasks[i] = strdup(val);
if (!netmasks[i]) {
perror("initiator netmask copy");
@ -407,7 +407,7 @@ spdk_iscsi_init_grp_create_from_initiator_list(int tag,
int rc = -1;
struct spdk_iscsi_init_grp *ig = NULL;
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI,
SPDK_DEBUGLOG(SPDK_LOG_ISCSI,
"add initiator group (from initiator list) tag=%d, #initiators=%d, #masks=%d\n",
tag, num_initiator_names, num_initiator_masks);
@ -506,7 +506,7 @@ spdk_iscsi_init_grp_array_destroy(void)
{
struct spdk_iscsi_init_grp *ig, *tmp;
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "spdk_iscsi_init_grp_array_destroy\n");
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "spdk_iscsi_init_grp_array_destroy\n");
pthread_mutex_lock(&g_spdk_iscsi.mutex);
TAILQ_FOREACH_SAFE(ig, &g_spdk_iscsi.ig_head, tailq, tmp) {
TAILQ_REMOVE(&g_spdk_iscsi.ig_head, ig, tailq);

128
lib/iscsi/iscsi.c
View File

@ -671,7 +671,7 @@ spdk_iscsi_append_param(struct spdk_iscsi_conn *conn, const char *key,
if (param == NULL) {
param = spdk_iscsi_param_find(conn->sess->params, key);
if (param == NULL) {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "no key %.64s\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "no key %.64s\n",
key);
return data_len;
}
@ -732,7 +732,7 @@ spdk_iscsi_chap_get_authinfo(struct iscsi_chap_auth *auth, const char *authfile,
val = spdk_conf_section_get_val(sp, "Comment");
if (val != NULL) {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI,
SPDK_DEBUGLOG(SPDK_LOG_ISCSI,
"Comment %s\n", val);
}
for (i = 0; ; i++) {
@ -784,7 +784,7 @@ spdk_iscsi_get_authinfo(struct spdk_iscsi_conn *conn, const char *authuser)
ag_tag = g_spdk_iscsi.discovery_auth_group;
pthread_mutex_unlock(&g_spdk_iscsi.mutex);
}
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "ag_tag=%d\n", ag_tag);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "ag_tag=%d\n", ag_tag);
pthread_mutex_lock(&g_spdk_iscsi.mutex);
authfile = strdup(g_spdk_iscsi.authfile);
@ -870,7 +870,7 @@ spdk_iscsi_auth_params(struct spdk_iscsi_conn *conn,
goto error_return;
}
/* selected algorithm is 5 (MD5) */
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "got CHAP_A=%s\n", new_val);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "got CHAP_A=%s\n", new_val);
total = spdk_iscsi_append_text(conn, "CHAP_A", new_val,
data, alloc_len, total);
@ -914,7 +914,7 @@ spdk_iscsi_auth_params(struct spdk_iscsi_conn *conn,
SPDK_ERRLOG("response format error\n");
goto error_return;
}
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "got CHAP_N/CHAP_R\n");
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "got CHAP_N/CHAP_R\n");
rc = spdk_iscsi_get_authinfo(conn, val);
if (rc < 0) {
@ -944,7 +944,7 @@ spdk_iscsi_auth_params(struct spdk_iscsi_conn *conn,
tgtmd5, SPDK_MD5DIGEST_LEN);
#if 0
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "tgtmd5=%s, resmd5=%s\n", in_val, response);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "tgtmd5=%s, resmd5=%s\n", in_val, response);
spdk_dump("tgtmd5", tgtmd5, SPDK_MD5DIGEST_LEN);
spdk_dump("resmd5", resmd5, SPDK_MD5DIGEST_LEN);
#endif
@ -980,7 +980,7 @@ spdk_iscsi_auth_params(struct spdk_iscsi_conn *conn,
spdk_dump("MChallenge", conn->auth.chap_mchallenge,
conn->auth.chap_mchallenge_len);
#endif
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI,
SPDK_DEBUGLOG(SPDK_LOG_ISCSI,
"got CHAP_I/CHAP_C\n");
if (conn->auth.muser == NULL || conn->auth.msecret == NULL) {
@ -1019,7 +1019,7 @@ spdk_iscsi_auth_params(struct spdk_iscsi_conn *conn,
conn->auth.chap_phase = ISCSI_CHAP_PHASE_END;
} else {
/* not found CHAP keys */
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "start CHAP\n");
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "start CHAP\n");
conn->auth.chap_phase = ISCSI_CHAP_PHASE_WAIT_A;
}
@ -1058,15 +1058,15 @@ spdk_iscsi_reject(struct spdk_iscsi_conn *conn, struct spdk_iscsi_pdu *pdu,
memset(data, 0, alloc_len);
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "Reject PDU reason=%d\n", reason);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "Reject PDU reason=%d\n", reason);
if (conn->sess != NULL) {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI,
SPDK_DEBUGLOG(SPDK_LOG_ISCSI,
"StatSN=%u, ExpCmdSN=%u, MaxCmdSN=%u\n",
conn->StatSN, conn->sess->ExpCmdSN,
conn->sess->MaxCmdSN);
} else {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "StatSN=%u\n", conn->StatSN);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "StatSN=%u\n", conn->StatSN);
}
memcpy(data, &pdu->bhs, ISCSI_BHS_LEN);
@ -1102,7 +1102,7 @@ spdk_iscsi_reject(struct spdk_iscsi_conn *conn, struct spdk_iscsi_pdu *pdu,
to_be32(&rsph->max_cmd_sn, 1);
}
SPDK_TRACEDUMP(SPDK_TRACE_ISCSI, "PDU", (void *)&rsp_pdu->bhs, ISCSI_BHS_LEN);
SPDK_TRACEDUMP(SPDK_LOG_ISCSI, "PDU", (void *)&rsp_pdu->bhs, ISCSI_BHS_LEN);
spdk_iscsi_write_pdu(conn, rsp_pdu);
@ -1172,8 +1172,8 @@ spdk_iscsi_op_login_response(struct spdk_iscsi_conn *conn,
to_be32(&rsph->max_cmd_sn, rsp_pdu->cmd_sn);
}
SPDK_TRACEDUMP(SPDK_TRACE_ISCSI, "PDU", (uint8_t *)rsph, ISCSI_BHS_LEN);
SPDK_TRACEDUMP(SPDK_TRACE_ISCSI, "DATA", rsp_pdu->data, rsp_pdu->data_segment_len);
SPDK_TRACEDUMP(SPDK_LOG_ISCSI, "PDU", (uint8_t *)rsph, ISCSI_BHS_LEN);
SPDK_TRACEDUMP(SPDK_LOG_ISCSI, "DATA", rsp_pdu->data, rsp_pdu->data_segment_len);
/* Set T/CSG/NSG to reserved if login error. */
if (rsph->status_class != 0) {
@ -1353,7 +1353,7 @@ spdk_iscsi_op_login_check_session(struct spdk_iscsi_conn *conn,
rsph = (struct iscsi_bhs_login_rsp *)&rsp_pdu->bhs;
/* check existing session */
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "isid=%"PRIx64", tsih=%u, cid=%u\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "isid=%"PRIx64", tsih=%u, cid=%u\n",
spdk_iscsi_get_isid(rsph->isid), from_be16(&rsph->tsih), cid);
if (rsph->tsih != 0) {
/* multiple connections */
@ -1527,7 +1527,7 @@ spdk_iscsi_op_login_session_type(struct spdk_iscsi_conn *conn,
return SPDK_ISCSI_LOGIN_ERROR_RESPONSE;
}
}
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "Session Type: %s\n", session_type_str);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "Session Type: %s\n", session_type_str);
return 0;
}
@ -1563,9 +1563,9 @@ spdk_iscsi_op_login_initialize_port(struct spdk_iscsi_conn *conn,
"%s,i,0x%12.12" PRIx64, val, spdk_iscsi_get_isid(rsph->isid));
spdk_strlwr(conn->initiator_name);
spdk_strlwr(initiator_port_name);
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "Initiator name: %s\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "Initiator name: %s\n",
conn->initiator_name);
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "Initiator port: %s\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "Initiator port: %s\n",
initiator_port_name);
return 0;
@ -1850,9 +1850,9 @@ spdk_iscsi_op_login_rsp_init(struct spdk_iscsi_conn *conn,
if (rsph->tsih)
rsph->stat_sn = reqh->exp_stat_sn;
SPDK_TRACEDUMP(SPDK_TRACE_ISCSI, "PDU", (uint8_t *)&pdu->bhs, ISCSI_BHS_LEN);
SPDK_TRACEDUMP(SPDK_LOG_ISCSI, "PDU", (uint8_t *)&pdu->bhs, ISCSI_BHS_LEN);
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI,
SPDK_DEBUGLOG(SPDK_LOG_ISCSI,
"T=%d, C=%d, CSG=%d, NSG=%d, Min=%d, Max=%d, ITT=%x\n",
ISCSI_BHS_LOGIN_GET_TBIT(rsph->flags),
ISCSI_BHS_LOGIN_GET_CBIT(rsph->flags),
@ -1861,14 +1861,14 @@ spdk_iscsi_op_login_rsp_init(struct spdk_iscsi_conn *conn,
reqh->version_min, reqh->version_max, from_be32(&rsph->itt));
if (conn->sess != NULL) {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI,
SPDK_DEBUGLOG(SPDK_LOG_ISCSI,
"CmdSN=%u, ExpStatSN=%u, StatSN=%u, ExpCmdSN=%u,"
"MaxCmdSN=%u\n", rsp_pdu->cmd_sn,
from_be32(&rsph->stat_sn), conn->StatSN,
conn->sess->ExpCmdSN,
conn->sess->MaxCmdSN);
} else {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI,
SPDK_DEBUGLOG(SPDK_LOG_ISCSI,
"CmdSN=%u, ExpStatSN=%u, StatSN=%u\n",
rsp_pdu->cmd_sn, from_be32(&rsph->stat_sn),
conn->StatSN);
@ -1965,13 +1965,13 @@ spdk_iscsi_op_login_rsp_handle_csg_bit(struct spdk_iscsi_conn *conn,
} else {
if (conn->auth.chap_phase !=
ISCSI_CHAP_PHASE_END) {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI,
SPDK_DEBUGLOG(SPDK_LOG_ISCSI,
"CHAP phase not "
"complete");
}
}
SPDK_TRACEDUMP(SPDK_TRACE_ISCSI, "Negotiated Auth Params",
SPDK_TRACEDUMP(SPDK_LOG_ISCSI, "Negotiated Auth Params",
rsp_pdu->data, rsp_pdu->data_segment_len);
}
break;
@ -2150,7 +2150,7 @@ spdk_iscsi_op_login_rsp_handle(struct spdk_iscsi_conn *conn,
}
rsp_pdu->data_segment_len = rc;
SPDK_TRACEDUMP(SPDK_TRACE_ISCSI, "Negotiated Params", rsp_pdu->data, rc);
SPDK_TRACEDUMP(SPDK_LOG_ISCSI, "Negotiated Params", rsp_pdu->data, rc);
/* handle the CSG bit case */
rc = spdk_iscsi_op_login_rsp_handle_csg_bit(conn, rsp_pdu, *params,
@ -2255,10 +2255,10 @@ spdk_iscsi_op_text(struct spdk_iscsi_conn *conn, struct spdk_iscsi_pdu *pdu)
pdu->cmd_sn = CmdSN;
ExpStatSN = from_be32(&reqh->exp_stat_sn);
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "I=%d, F=%d, C=%d, ITT=%x, TTT=%x\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "I=%d, F=%d, C=%d, ITT=%x, TTT=%x\n",
reqh->immediate, F_bit, C_bit, task_tag, from_be32(&reqh->ttt));
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI,
SPDK_DEBUGLOG(SPDK_LOG_ISCSI,
"CmdSN=%u, ExpStatSN=%u, StatSN=%u, ExpCmdSN=%u, MaxCmdSN=%u\n",
CmdSN, ExpStatSN, conn->StatSN, conn->sess->ExpCmdSN,
conn->sess->MaxCmdSN);
@ -2269,7 +2269,7 @@ spdk_iscsi_op_text(struct spdk_iscsi_conn *conn, struct spdk_iscsi_pdu *pdu)
return -1;
#else
/* StarPort have a bug */
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "StatSN(%u) rewound\n", ExpStatSN);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "StatSN(%u) rewound\n", ExpStatSN);
conn->StatSN = ExpStatSN;
#endif
}
@ -2361,7 +2361,7 @@ spdk_iscsi_op_text(struct spdk_iscsi_conn *conn, struct spdk_iscsi_pdu *pdu)
}
}
SPDK_TRACEDUMP(SPDK_TRACE_ISCSI, "Negotiated Params", data, data_len);
SPDK_TRACEDUMP(SPDK_LOG_ISCSI, "Negotiated Params", data, data_len);
/* response PDU */
rsp_pdu = spdk_get_pdu();
@ -2440,7 +2440,7 @@ spdk_iscsi_op_logout(struct spdk_iscsi_conn *conn, struct spdk_iscsi_pdu *pdu)
pdu->cmd_sn = CmdSN;
ExpStatSN = from_be32(&reqh->exp_stat_sn);
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "reason=%d, ITT=%x, cid=%d\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "reason=%d, ITT=%x, cid=%d\n",
reqh->reason, task_tag, cid);
if (reqh->reason != 0 && conn->sess->session_type == SESSION_TYPE_DISCOVERY) {
@ -2451,23 +2451,23 @@ spdk_iscsi_op_logout(struct spdk_iscsi_conn *conn, struct spdk_iscsi_pdu *pdu)
if (conn->sess != NULL) {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI,
SPDK_DEBUGLOG(SPDK_LOG_ISCSI,
"CmdSN=%u, ExpStatSN=%u, StatSN=%u, ExpCmdSN=%u, MaxCmdSN=%u\n",
CmdSN, ExpStatSN, conn->StatSN,
conn->sess->ExpCmdSN, conn->sess->MaxCmdSN);
if (CmdSN != conn->sess->ExpCmdSN) {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "CmdSN(%u) might have dropped\n", CmdSN);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "CmdSN(%u) might have dropped\n", CmdSN);
/* ignore error */
}
} else {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI,
SPDK_DEBUGLOG(SPDK_LOG_ISCSI,
"CmdSN=%u, ExpStatSN=%u, StatSN=%u\n",
CmdSN, ExpStatSN, conn->StatSN);
}
if (ExpStatSN != conn->StatSN) {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "StatSN(%u/%u) might have dropped\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "StatSN(%u/%u) might have dropped\n",
ExpStatSN, conn->StatSN);
/* ignore error */
}
@ -2729,19 +2729,19 @@ spdk_iscsi_transfer_in(struct spdk_iscsi_conn *conn,
if (data_len < transfer_len) {
/* underflow */
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "Underflow %u/%u\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "Underflow %u/%u\n",
data_len, transfer_len);
residual_len = transfer_len - data_len;
transfer_len = data_len;
datain_flag |= ISCSI_DATAIN_UNDERFLOW;
} else if (data_len > transfer_len) {
/* overflow */
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "Overflow %u/%u\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "Overflow %u/%u\n",
data_len, transfer_len);
residual_len = data_len - transfer_len;
datain_flag |= ISCSI_DATAIN_OVERFLOW;
} else {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "Transfer %u\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "Transfer %u\n",
transfer_len);
residual_len = 0;
}
@ -2786,10 +2786,10 @@ spdk_iscsi_transfer_in(struct spdk_iscsi_conn *conn,
datain_flag &= ~ISCSI_DATAIN_STATUS;
}
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI,
SPDK_DEBUGLOG(SPDK_LOG_ISCSI,
"Transfer=%d, Offset=%d, Len=%d\n",
sequence_end, offset, len);
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI,
SPDK_DEBUGLOG(SPDK_LOG_ISCSI,
"StatSN=%u, DataSN=%u, Offset=%u, Len=%d\n",
conn->StatSN, DataSN, offset, len);
@ -2956,7 +2956,7 @@ spdk_iscsi_op_scsi(struct spdk_iscsi_conn *conn, struct spdk_iscsi_pdu *pdu)
transfer_len = from_be32(&reqh->expected_data_xfer_len);
cdb = reqh->cdb;
SPDK_TRACEDUMP(SPDK_TRACE_ISCSI, "CDB", cdb, 16);
SPDK_TRACEDUMP(SPDK_LOG_ISCSI, "CDB", cdb, 16);
task = spdk_iscsi_task_get(conn, NULL, spdk_iscsi_task_cpl);
if (!task) {
@ -3157,18 +3157,18 @@ void spdk_iscsi_task_response(struct spdk_iscsi_conn *conn,
(task->scsi.status == SPDK_SCSI_STATUS_GOOD)) {
if (data_len < transfer_len) {
/* underflow */
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "Underflow %zu/%u\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "Underflow %zu/%u\n",
data_len, transfer_len);
residual_len = transfer_len - data_len;
U_bit = 1;
} else if (data_len > transfer_len) {
/* overflow */
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "Overflow %zu/%u\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "Overflow %zu/%u\n",
data_len, transfer_len);
residual_len = data_len - transfer_len;
O_bit = 1;
} else {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "Transfer %u\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "Transfer %u\n",
transfer_len);
}
}
@ -3263,11 +3263,11 @@ spdk_iscsi_op_task(struct spdk_iscsi_conn *conn, struct spdk_iscsi_pdu *pdu)
task_tag = from_be32(&reqh->itt);
ref_task_tag = from_be32(&reqh->ref_task_tag);
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI,
SPDK_DEBUGLOG(SPDK_LOG_ISCSI,
"I=%d, func=%d, ITT=%x, ref TT=%x, LUN=0x%16.16"PRIx64"\n",
reqh->immediate, function, task_tag, ref_task_tag, lun);
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI,
SPDK_DEBUGLOG(SPDK_LOG_ISCSI,
"StatSN=%u, ExpCmdSN=%u, MaxCmdSN=%u\n",
conn->StatSN, conn->sess->ExpCmdSN,
conn->sess->MaxCmdSN);
@ -3403,10 +3403,10 @@ spdk_iscsi_op_nopout(struct spdk_iscsi_conn *conn, struct spdk_iscsi_pdu *pdu)
CmdSN = from_be32(&reqh->cmd_sn);
pdu->cmd_sn = CmdSN;
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "I=%d, ITT=%x, TTT=%x\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "I=%d, ITT=%x, TTT=%x\n",
I_bit, task_tag, transfer_tag);
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI,
SPDK_DEBUGLOG(SPDK_LOG_ISCSI,
"CmdSN=%u, StatSN=%u, ExpCmdSN=%u, MaxCmdSN=%u\n",
CmdSN, conn->StatSN, conn->sess->ExpCmdSN,
conn->sess->MaxCmdSN);
@ -3429,7 +3429,7 @@ spdk_iscsi_op_nopout(struct spdk_iscsi_conn *conn, struct spdk_iscsi_pdu *pdu)
if (task_tag == 0xffffffffU) {
if (I_bit == 1) {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI,
SPDK_DEBUGLOG(SPDK_LOG_ISCSI,
"got NOPOUT ITT=0xffffffff\n");
return SPDK_SUCCESS;
} else {
@ -3688,7 +3688,7 @@ spdk_iscsi_handle_recovery_datain(struct spdk_iscsi_conn *conn,
task = spdk_iscsi_task_get_primary(task);
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "spdk_iscsi_handle_recovery_datain\n");
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "spdk_iscsi_handle_recovery_datain\n");
if (beg_run < task->acked_data_sn) {
SPDK_ERRLOG("ITT: 0x%08x, DATA IN SNACK requests retransmission of"
@ -3746,7 +3746,7 @@ spdk_iscsi_handle_status_snack(struct spdk_iscsi_conn *conn,
beg_run = from_be32(&reqh->beg_run);
run_length = from_be32(&reqh->run_len);
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "beg_run=%d, run_length=%d, conn->StatSN="
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "beg_run=%d, run_length=%d, conn->StatSN="
"%d, conn->exp_statsn=%d\n", beg_run, run_length,
conn->StatSN, conn->exp_statsn);
@ -3809,7 +3809,7 @@ spdk_iscsi_handle_data_ack(struct spdk_iscsi_conn *conn,
task = NULL;
datain_header = NULL;
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "beg_run=%d,transfer_tag=%d,run_len=%d\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "beg_run=%d,transfer_tag=%d,run_len=%d\n",
beg_run, transfer_tag, run_length);
task = spdk_get_scsi_task_from_ttt(conn, transfer_tag);
@ -3845,7 +3845,7 @@ spdk_iscsi_handle_data_ack(struct spdk_iscsi_conn *conn,
}
}
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "Received Data ACK SNACK for TTT: 0x%08x,"
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "Received Data ACK SNACK for TTT: 0x%08x,"
" updated acked DataSN to 0x%08x.\n", transfer_tag,
(task->acked_data_sn - 1));
@ -3905,7 +3905,7 @@ spdk_iscsi_send_r2t_recovery(struct spdk_iscsi_conn *conn,
/* remove the r2t pdu from the snack_list */
pdu = spdk_iscsi_remove_r2t_pdu_from_snack_list(conn, task, r2t_sn);
if (!pdu) {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "No pdu is found\n");
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "No pdu is found\n");
return -1;
}
@ -3967,7 +3967,7 @@ spdk_iscsi_op_snack(struct spdk_iscsi_conn *conn, struct spdk_iscsi_pdu *pdu)
}
type = reqh->flags & ISCSI_FLAG_SNACK_TYPE_MASK;
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "The value of type is %d\n", type);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "The value of type is %d\n", type);
switch (type) {
case 0:
@ -3976,7 +3976,7 @@ spdk_iscsi_op_snack(struct spdk_iscsi_conn *conn, struct spdk_iscsi_pdu *pdu)
beg_run = from_be32(&reqh->beg_run);
run_length = from_be32(&reqh->run_len);
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "beg_run=%d, run_length=%d, "
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "beg_run=%d, run_length=%d, "
"task_tag=%x, transfer_tag=%u\n", beg_run,
run_length, task_tag, from_be32(&reqh->ttt));
@ -4143,7 +4143,7 @@ static int spdk_iscsi_op_data(struct spdk_iscsi_conn *conn,
}
if (lun_dev == NULL) {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "LUN %d is removed, complete the task immediately\n", lun_i);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "LUN %d is removed, complete the task immediately\n", lun_i);
subtask->scsi.transfer_len = subtask->scsi.length;
spdk_scsi_task_process_null_lun(&subtask->scsi);
spdk_iscsi_task_cpl(&subtask->scsi);
@ -4222,10 +4222,10 @@ int spdk_iscsi_send_nopin(struct spdk_iscsi_conn *conn)
return SPDK_SUCCESS;
}
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI,
SPDK_DEBUGLOG(SPDK_LOG_ISCSI,
"send NOPIN isid=%"PRIx64", tsih=%u, cid=%u\n",
conn->sess->isid, conn->sess->tsih, conn->cid);
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI,
SPDK_DEBUGLOG(SPDK_LOG_ISCSI,
"StatSN=%u, ExpCmdSN=%u, MaxCmdSN=%u\n",
conn->StatSN, conn->sess->ExpCmdSN,
conn->sess->MaxCmdSN);
@ -4290,7 +4290,7 @@ spdk_iscsi_execute(struct spdk_iscsi_conn *conn, struct spdk_iscsi_pdu *pdu)
reqh = (struct iscsi_bhs_scsi_req *)&pdu->bhs;
pdu->cmd_sn = from_be32(&reqh->cmd_sn);
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "opcode %x\n", opcode);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "opcode %x\n", opcode);
if (opcode == ISCSI_OP_LOGIN) {
rc = spdk_iscsi_op_login(conn, pdu);
@ -4329,7 +4329,7 @@ spdk_iscsi_execute(struct spdk_iscsi_conn *conn, struct spdk_iscsi_pdu *pdu)
pdu->cmd_sn, sess->ExpCmdSN, sess->MaxCmdSN);
if (sess->ErrorRecoveryLevel >= 1)
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "Skip the error in"
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "Skip the error in"
" ERL 1 and 2\n");
else
return SPDK_PDU_FATAL;
@ -4339,7 +4339,7 @@ spdk_iscsi_execute(struct spdk_iscsi_conn *conn, struct spdk_iscsi_pdu *pdu)
SPDK_ERRLOG("CmdSN(%u) error ExpCmdSN=%u\n", pdu->cmd_sn, sess->ExpCmdSN);
if (sess->ErrorRecoveryLevel >= 1) {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "Skip the error in"
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "Skip the error in"
" ERL 1 and 2\n");
} else if (opcode != ISCSI_OP_NOPOUT) {
/*
@ -4353,7 +4353,7 @@ spdk_iscsi_execute(struct spdk_iscsi_conn *conn, struct spdk_iscsi_pdu *pdu)
ExpStatSN = from_be32(&reqh->exp_stat_sn);
if (SN32_GT(ExpStatSN, conn->StatSN)) {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "StatSN(%u) advanced\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "StatSN(%u) advanced\n",
ExpStatSN);
ExpStatSN = conn->StatSN;
}
@ -4639,7 +4639,7 @@ spdk_append_iscsi_sess(struct spdk_iscsi_conn *conn,
{
struct spdk_iscsi_sess *sess;
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI,
SPDK_DEBUGLOG(SPDK_LOG_ISCSI,
"append session: init port name=%s, tsih=%u, cid=%u\n",
initiator_port_name, tsih, cid);
@ -4664,7 +4664,7 @@ spdk_append_iscsi_sess(struct spdk_iscsi_conn *conn,
return -1;
}
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "Connections (tsih %d): %d\n", sess->tsih, sess->connections);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "Connections (tsih %d): %d\n", sess->tsih, sess->connections);
conn->sess = sess;
/*

42
lib/iscsi/iscsi_subsystem.c
View File

@ -531,44 +531,44 @@ struct spdk_iscsi_pdu *spdk_get_pdu(void)
static void
spdk_iscsi_log_globals(void)
{
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "AuthFile %s\n", g_spdk_iscsi.authfile);
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "NodeBase %s\n", g_spdk_iscsi.nodebase);
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "MaxSessions %d\n", g_spdk_iscsi.MaxSessions);
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "MaxConnectionsPerSession %d\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "AuthFile %s\n", g_spdk_iscsi.authfile);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "NodeBase %s\n", g_spdk_iscsi.nodebase);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "MaxSessions %d\n", g_spdk_iscsi.MaxSessions);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "MaxConnectionsPerSession %d\n",
g_spdk_iscsi.MaxConnectionsPerSession);
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "MaxQueueDepth %d\n", g_spdk_iscsi.MaxQueueDepth);
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "DefaultTime2Wait %d\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "MaxQueueDepth %d\n", g_spdk_iscsi.MaxQueueDepth);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "DefaultTime2Wait %d\n",
g_spdk_iscsi.DefaultTime2Wait);
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "DefaultTime2Retain %d\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "DefaultTime2Retain %d\n",
g_spdk_iscsi.DefaultTime2Retain);
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "ImmediateData %s\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "ImmediateData %s\n",
g_spdk_iscsi.ImmediateData ? "Yes" : "No");
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "AllowDuplicateIsid %s\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "AllowDuplicateIsid %s\n",
g_spdk_iscsi.AllowDuplicateIsid ? "Yes" : "No");
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "ErrorRecoveryLevel %d\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "ErrorRecoveryLevel %d\n",
g_spdk_iscsi.ErrorRecoveryLevel);
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "Timeout %d\n", g_spdk_iscsi.timeout);
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "FlushTimeout %"PRIu64"\n", g_spdk_iscsi.flush_timeout);
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "NopInInterval %d\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "Timeout %d\n", g_spdk_iscsi.timeout);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "FlushTimeout %"PRIu64"\n", g_spdk_iscsi.flush_timeout);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "NopInInterval %d\n",
g_spdk_iscsi.nopininterval);
if (g_spdk_iscsi.no_discovery_auth != 0) {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI,
SPDK_DEBUGLOG(SPDK_LOG_ISCSI,
"DiscoveryAuthMethod None\n");
} else if (g_spdk_iscsi.req_discovery_auth == 0) {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI,
SPDK_DEBUGLOG(SPDK_LOG_ISCSI,
"DiscoveryAuthMethod Auto\n");
} else {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI,
SPDK_DEBUGLOG(SPDK_LOG_ISCSI,
"DiscoveryAuthMethod %s %s\n",
g_spdk_iscsi.req_discovery_auth ? "CHAP" : "",
g_spdk_iscsi.req_discovery_auth_mutual ? "Mutual" : "");
}
if (g_spdk_iscsi.discovery_auth_group == 0) {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI,
SPDK_DEBUGLOG(SPDK_LOG_ISCSI,
"DiscoveryAuthGroup None\n");
} else {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI,
SPDK_DEBUGLOG(SPDK_LOG_ISCSI,
"DiscoveryAuthGroup AuthGroup%d\n",
g_spdk_iscsi.discovery_auth_group);
}
@ -595,7 +595,7 @@ spdk_iscsi_read_parameters_from_config_file(struct spdk_conf_section *sp)
val = spdk_conf_section_get_val(sp, "Comment");
if (val != NULL) {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "Comment %s\n", val);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "Comment %s\n", val);
}
val = spdk_conf_section_get_val(sp, "AuthFile");
@ -787,7 +787,7 @@ spdk_iscsi_app_read_parameters(void)
}
/* Process parameters */
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "spdk_iscsi_app_read_parameters\n");
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "spdk_iscsi_app_read_parameters\n");
sp = spdk_conf_find_section(NULL, "iSCSI");
if (sp != NULL) {
spdk_iscsi_read_parameters_from_config_file(sp);
@ -919,4 +919,4 @@ spdk_iscsi_config_text(FILE *fp)
spdk_iscsi_config_dump_target_nodes(fp);
}
SPDK_LOG_REGISTER_TRACE_FLAG("iscsi", SPDK_TRACE_ISCSI)
SPDK_LOG_REGISTER_COMPONENT("iscsi", SPDK_LOG_ISCSI)

44
lib/iscsi/param.c
View File

@ -101,7 +101,7 @@ spdk_iscsi_param_del(struct iscsi_param **params, const char *key)
{
struct iscsi_param *param, *prev_param = NULL;
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "del %s\n", key);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "del %s\n", key);
if (params == NULL || key == NULL)
return 0;
for (param = *params; param != NULL; param = param->next) {
@ -127,7 +127,7 @@ spdk_iscsi_param_add(struct iscsi_param **params, const char *key,
{
struct iscsi_param *param, *last_param;
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "add %s=%s, list=[%s], type=%d\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "add %s=%s, list=[%s], type=%d\n",
key, val, list, type);
if (key == NULL)
return -1;
@ -168,7 +168,7 @@ spdk_iscsi_param_set(struct iscsi_param *params, const char *key,
{
struct iscsi_param *param;
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "set %s=%s\n", key, val);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "set %s=%s\n", key, val);
param = spdk_iscsi_param_find(params, key);
if (param == NULL) {
SPDK_ERRLOG("no key %s\n", key);
@ -188,7 +188,7 @@ spdk_iscsi_param_set_int(struct iscsi_param *params, const char *key, uint32_t v
char buf[MAX_TMPBUF];
struct iscsi_param *param;
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "set %s=%d\n", key, val);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "set %s=%d\n", key, val);
param = spdk_iscsi_param_find(params, key);
if (param == NULL) {
SPDK_ERRLOG("no key %s\n", key);
@ -532,7 +532,7 @@ spdk_iscsi_special_param_construction(struct spdk_iscsi_conn *conn,
return -1;
}
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI,
SPDK_DEBUGLOG(SPDK_LOG_ISCSI,
"returning MaxRecvDataSegmentLength=%d\n",
SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH);
len = snprintf((char *)data + total, alloc_len - total,
@ -602,7 +602,7 @@ spdk_iscsi_construct_data_from_param(struct iscsi_param *param, char *new_val,
return -1;
}
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "negotiated %s=%s\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "negotiated %s=%s\n",
param->key, new_val);
len = snprintf((char *)data + total, alloc_len - total, "%s=%s",
param->key, new_val);
@ -640,7 +640,7 @@ static char *spdk_iscsi_negotiate_param_list(int *add_param_value,
*val_end = '\0';
}
if (strcasecmp(in_start, val_start) == 0) {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "match %s\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "match %s\n",
val_start);
flag = 1;
break;
@ -692,7 +692,7 @@ static char *spdk_iscsi_negotiate_param_numerical(int *add_param_value,
min_i = (min_val != NULL) ? (int)strtol(min_val, NULL, 10) : 0;
max_i = (max_val != NULL) ? (int)strtol(max_val, NULL, 10) : 0;
if (val_i < min_i || val_i > max_i) {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "key %.64s reject\n", param->key);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "key %.64s reject\n", param->key);
new_val = NULL;
} else {
switch (param->type) {
@ -822,7 +822,7 @@ spdk_iscsi_negotiate_param_init(struct spdk_iscsi_conn *conn,
if ((strncasecmp(param->key, "X-", 2) == 0) ||
(strncasecmp(param->key, "X#", 2) == 0)) {
/* Extension Key */
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI,
SPDK_DEBUGLOG(SPDK_LOG_ISCSI,
"extension key %.64s\n",
param->key);
} else {
@ -1073,7 +1073,7 @@ spdk_iscsi_copy_param2var(struct spdk_iscsi_conn *conn)
SPDK_ERRLOG("Getval MaxRecvDataSegmentLength failed\n");
return -1;
}
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI,
SPDK_DEBUGLOG(SPDK_LOG_ISCSI,
"copy MaxRecvDataSegmentLength=%s\n", val);
conn->MaxRecvDataSegmentLength = (int)strtol(val, NULL, 10);
if (conn->MaxRecvDataSegmentLength > SPDK_ISCSI_MAX_SEND_DATA_SEGMENT_LENGTH) {
@ -1086,10 +1086,10 @@ spdk_iscsi_copy_param2var(struct spdk_iscsi_conn *conn)
return -1;
}
if (strcasecmp(val, "CRC32C") == 0) {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "set HeaderDigest=1\n");
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "set HeaderDigest=1\n");
conn->header_digest = 1;
} else {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "set HeaderDigest=0\n");
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "set HeaderDigest=0\n");
conn->header_digest = 0;
}
val = spdk_iscsi_param_get_val(conn->params, "DataDigest");
@ -1098,10 +1098,10 @@ spdk_iscsi_copy_param2var(struct spdk_iscsi_conn *conn)
return -1;
}
if (strcasecmp(val, "CRC32C") == 0) {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "set DataDigest=1\n");
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "set DataDigest=1\n");
conn->data_digest = 1;
} else {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "set DataDigest=0\n");
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "set DataDigest=0\n");
conn->data_digest = 0;
}
@ -1110,28 +1110,28 @@ spdk_iscsi_copy_param2var(struct spdk_iscsi_conn *conn)
SPDK_ERRLOG("Getval MaxConnections failed\n");
return -1;
}
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "copy MaxConnections=%s\n", val);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "copy MaxConnections=%s\n", val);
conn->sess->MaxConnections = (uint32_t) strtol(val, NULL, 10);
val = spdk_iscsi_param_get_val(conn->sess->params, "MaxOutstandingR2T");
if (val == NULL) {
SPDK_ERRLOG("Getval MaxOutstandingR2T failed\n");
return -1;
}
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "copy MaxOutstandingR2T=%s\n", val);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "copy MaxOutstandingR2T=%s\n", val);
conn->sess->MaxOutstandingR2T = (uint32_t) strtol(val, NULL, 10);
val = spdk_iscsi_param_get_val(conn->sess->params, "FirstBurstLength");
if (val == NULL) {
SPDK_ERRLOG("Getval FirstBurstLength failed\n");
return -1;
}
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "copy FirstBurstLength=%s\n", val);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "copy FirstBurstLength=%s\n", val);
conn->sess->FirstBurstLength = (uint32_t) strtol(val, NULL, 10);
val = spdk_iscsi_param_get_val(conn->sess->params, "MaxBurstLength");
if (val == NULL) {
SPDK_ERRLOG("Getval MaxBurstLength failed\n");
return -1;
}
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "copy MaxBurstLength=%s\n", val);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "copy MaxBurstLength=%s\n", val);
conn->sess->MaxBurstLength = (uint32_t) strtol(val, NULL, 10);
val = spdk_iscsi_param_get_val(conn->sess->params, "InitialR2T");
if (val == NULL) {
@ -1139,10 +1139,10 @@ spdk_iscsi_copy_param2var(struct spdk_iscsi_conn *conn)
return -1;
}
if (strcasecmp(val, "Yes") == 0) {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "set InitialR2T=1\n");
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "set InitialR2T=1\n");
conn->sess->InitialR2T = 1;
} else {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "set InitialR2T=0\n");
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "set InitialR2T=0\n");
conn->sess->InitialR2T = 0;
}
val = spdk_iscsi_param_get_val(conn->sess->params, "ImmediateData");
@ -1151,10 +1151,10 @@ spdk_iscsi_copy_param2var(struct spdk_iscsi_conn *conn)
return -1;
}
if (strcasecmp(val, "Yes") == 0) {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "set ImmediateData=1\n");
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "set ImmediateData=1\n");
conn->sess->ImmediateData = 1;
} else {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "set ImmediateData=0\n");
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "set ImmediateData=0\n");
conn->sess->ImmediateData = 0;
}
return 0;

22
lib/iscsi/portal_grp.c
View File

@ -116,7 +116,7 @@ spdk_iscsi_portal_destroy(struct spdk_iscsi_portal *p)
{
assert(p != NULL);
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "spdk_iscsi_portal_destroy\n");
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "spdk_iscsi_portal_destroy\n");
TAILQ_REMOVE(&g_spdk_iscsi.portal_head, p, g_tailq);
free(p->host);
free(p->port);
@ -152,7 +152,7 @@ static void
spdk_iscsi_portal_close(struct spdk_iscsi_portal *p)
{
if (p->sock >= 0) {
SPDK_DEBUGLOG(SPDK_TRACE_NET, "close portal (%s, %s)\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "close portal (%s, %s)\n",
p->host, p->port);
spdk_iscsi_acceptor_stop(p);
spdk_sock_close(p->sock);
@ -343,7 +343,7 @@ spdk_iscsi_portal_grp_destroy(struct spdk_iscsi_portal_grp *pg)
assert(pg != NULL);
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "spdk_iscsi_portal_grp_destroy\n");
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "spdk_iscsi_portal_grp_destroy\n");
while (!TAILQ_EMPTY(&pg->head)) {
p = TAILQ_FIRST(&pg->head);
TAILQ_REMOVE(&pg->head, p, per_pg_tailq);
@ -374,7 +374,7 @@ spdk_iscsi_portal_grp_create_from_portal_list(int tag,
int i = 0, rc = 0;
struct spdk_iscsi_portal_grp *pg;
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "add portal group (from portal list) %d\n", tag);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "add portal group (from portal list) %d\n", tag);
if (num_portals > MAX_PORTAL) {
SPDK_ERRLOG("%d > MAX_PORTAL\n", num_portals);
@ -390,7 +390,7 @@ spdk_iscsi_portal_grp_create_from_portal_list(int tag,
for (i = 0; i < num_portals; i++) {
struct spdk_iscsi_portal *p = portal_list[i];
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI,
SPDK_DEBUGLOG(SPDK_LOG_ISCSI,
"RIndex=%d, Host=%s, Port=%s, Tag=%d\n",
i, p->host, p->port, tag);
rc = spdk_iscsi_portal_open(p);
@ -429,12 +429,12 @@ spdk_iscsi_portal_grp_create_from_configfile(struct spdk_conf_section *sp)
char *label, *portal;
int portals = 0, i = 0, rc = 0;
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "add portal group (from config file) %d\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "add portal group (from config file) %d\n",
spdk_conf_section_get_num(sp));
val = spdk_conf_section_get_val(sp, "Comment");
if (val != NULL) {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "Comment %s\n", val);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "Comment %s\n", val);
}
/* counts number of definitions */
@ -483,7 +483,7 @@ spdk_iscsi_portal_grp_create_from_configfile(struct spdk_conf_section *sp)
goto error_out;
}
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI,
SPDK_DEBUGLOG(SPDK_LOG_ISCSI,
"RIndex=%d, Host=%s, Port=%s, Tag=%d\n",
i, p->host, p->port, spdk_conf_section_get_num(sp));
@ -557,7 +557,7 @@ spdk_iscsi_portal_grp_array_destroy(void)
{
struct spdk_iscsi_portal_grp *pg, *tmp;
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "spdk_iscsi_portal_grp_array_destroy\n");
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "spdk_iscsi_portal_grp_array_destroy\n");
pthread_mutex_lock(&g_spdk_iscsi.mutex);
TAILQ_FOREACH_SAFE(pg, &g_spdk_iscsi.pg_head, tailq, tmp) {
TAILQ_REMOVE(&g_spdk_iscsi.pg_head, pg, tailq);
@ -587,7 +587,7 @@ spdk_iscsi_portal_grp_open_all(void)
struct spdk_iscsi_portal_grp *pg;
int rc;
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "spdk_iscsi_portal_grp_open_all\n");
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "spdk_iscsi_portal_grp_open_all\n");
pthread_mutex_lock(&g_spdk_iscsi.mutex);
TAILQ_FOREACH(pg, &g_spdk_iscsi.pg_head, tailq) {
rc = spdk_iscsi_portal_grp_open(pg);
@ -615,7 +615,7 @@ spdk_iscsi_portal_grp_close_all(void)
{
struct spdk_iscsi_portal_grp *pg;
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "spdk_iscsi_portal_grp_close_all\n");
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "spdk_iscsi_portal_grp_close_all\n");
pthread_mutex_lock(&g_spdk_iscsi.mutex);
TAILQ_FOREACH(pg, &g_spdk_iscsi.pg_head, tailq) {
spdk_iscsi_portal_grp_close(pg);

34
lib/iscsi/tgt_node.c
View File

@ -85,8 +85,8 @@ spdk_iscsi_ipv6_netmask_allow_addr(const char *netmask, const char *addr)
}
#if 0
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "input %s\n", addr);
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "mask %s / %d\n", mask, bits);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "input %s\n", addr);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "mask %s / %d\n", mask, bits);
#endif
/* presentation to network order binary */
@ -181,7 +181,7 @@ spdk_iscsi_init_grp_allow_addr(struct spdk_iscsi_init_grp *igp,
struct spdk_iscsi_initiator_netmask *imask;
TAILQ_FOREACH(imask, &igp->netmask_head, tailq) {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "netmask=%s, addr=%s\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "netmask=%s, addr=%s\n",
imask->mask, addr);
if (spdk_iscsi_netmask_allow_addr(imask->mask, addr)) {
return true;
@ -232,7 +232,7 @@ spdk_iscsi_tgt_node_access(struct spdk_iscsi_conn *conn,
return false;
pg = conn->portal->group;
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "pg=%d, iqn=%s, addr=%s\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "pg=%d, iqn=%s, addr=%s\n",
pg->tag, iqn, addr);
pg_map = spdk_iscsi_tgt_node_find_pg_map(target, pg);
if (pg_map == NULL) {
@ -254,7 +254,7 @@ spdk_iscsi_tgt_node_access(struct spdk_iscsi_conn *conn,
}
denied:
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "access denied from %s (%s) to %s (%s:%s,%d)\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "access denied from %s (%s) to %s (%s:%s,%d)\n",
iqn, addr, target->name, conn->portal->host,
conn->portal->port, conn->portal->group->tag);
return false;
@ -358,7 +358,7 @@ spdk_iscsi_send_tgts(struct spdk_iscsi_conn *conn, const char *iiqn,
continue;
}
}
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI,
SPDK_DEBUGLOG(SPDK_LOG_ISCSI,
"TargetAddress=%s:%s,%d\n",
host, p->port, pg->tag);
len = snprintf((char *) data + total,
@ -393,7 +393,7 @@ spdk_iscsi_find_tgt_node(const char *target_name)
return target;
}
}
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "can't find target %s\n", target_name);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "can't find target %s\n", target_name);
return NULL;
}
@ -832,7 +832,7 @@ spdk_iscsi_tgt_node_construct(int target_index,
if (queue_depth > 0 && ((uint32_t)queue_depth <= g_spdk_iscsi.MaxQueueDepth)) {
target->queue_depth = queue_depth;
} else {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "QueueDepth %d is invalid and %d is used instead.\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "QueueDepth %d is invalid and %d is used instead.\n",
queue_depth, g_spdk_iscsi.MaxQueueDepth);
target->queue_depth = g_spdk_iscsi.MaxQueueDepth;
}
@ -868,7 +868,7 @@ spdk_cf_add_iscsi_tgt_node(struct spdk_conf_section *sp)
target_num = spdk_conf_section_get_num(sp);
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "add unit %d\n", target_num);
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "add unit %d\n", target_num);
data_digest = 0;
header_digest = 0;
@ -955,11 +955,11 @@ spdk_cf_add_iscsi_tgt_node(struct spdk_conf_section *sp)
}
}
if (auth_chap_disabled == 1) {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "AuthMethod None\n");
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "AuthMethod None\n");
} else if (auth_chap_required == 0) {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "AuthMethod Auto\n");
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "AuthMethod Auto\n");
} else {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "AuthMethod CHAP %s\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "AuthMethod CHAP %s\n",
auth_chap_mutual ? "Mutual" : "");
}
@ -984,9 +984,9 @@ spdk_cf_add_iscsi_tgt_node(struct spdk_conf_section *sp)
}
}
if (auth_group == 0) {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "AuthGroup None\n");
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "AuthGroup None\n");
} else {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "AuthGroup AuthGroup%d\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "AuthGroup AuthGroup%d\n",
auth_group);
}
@ -1010,9 +1010,9 @@ spdk_cf_add_iscsi_tgt_node(struct spdk_conf_section *sp)
}
}
if (header_digest == 0 && data_digest == 0) {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "UseDigest Auto\n");
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "UseDigest Auto\n");
} else {
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "UseDigest %s %s\n",
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "UseDigest %s %s\n",
header_digest ? "Header" : "",
data_digest ? "Data" : "");
}
@ -1065,7 +1065,7 @@ int spdk_iscsi_init_tgt_nodes(void)
struct spdk_conf_section *sp;
int rc;
SPDK_DEBUGLOG(SPDK_TRACE_ISCSI, "spdk_iscsi_init_tgt_nodes\n");
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "spdk_iscsi_init_tgt_nodes\n");
spdk_iscsi_tgt_node_list_init();

14
lib/jsonrpc/jsonrpc_server.c
View File

@ -90,7 +90,7 @@ parse_single_request(struct spdk_jsonrpc_request *request, struct spdk_json_val
request->id.len = req.id->len;
memcpy(request->id.start, req.id->start, req.id->len);
} else {
SPDK_DEBUGLOG(SPDK_TRACE_RPC, "JSON-RPC request id too long (%u)\n",
SPDK_DEBUGLOG(SPDK_LOG_RPC, "JSON-RPC request id too long (%u)\n",
req.id->len);
invalid = true;
}
@ -132,7 +132,7 @@ spdk_jsonrpc_parse_request(struct spdk_jsonrpc_server_conn *conn, void *json, si
request = calloc(1, sizeof(*request));
if (request == NULL) {
SPDK_DEBUGLOG(SPDK_TRACE_RPC, "Out of memory allocating request\n");
SPDK_DEBUGLOG(SPDK_LOG_RPC, "Out of memory allocating request\n");
return -1;
}
@ -146,7 +146,7 @@ spdk_jsonrpc_parse_request(struct spdk_jsonrpc_server_conn *conn, void *json, si
request->send_len = 0;
if (rc < 0 || rc > SPDK_JSONRPC_MAX_VALUES) {
SPDK_DEBUGLOG(SPDK_TRACE_RPC, "JSON parse error\n");
SPDK_DEBUGLOG(SPDK_LOG_RPC, "JSON parse error\n");
spdk_jsonrpc_server_handle_error(request, SPDK_JSONRPC_ERROR_PARSE_ERROR);
/*
@ -160,7 +160,7 @@ spdk_jsonrpc_parse_request(struct spdk_jsonrpc_server_conn *conn, void *json, si
rc = spdk_json_parse(json, size, conn->values, SPDK_JSONRPC_MAX_VALUES, &end,
SPDK_JSON_PARSE_FLAG_DECODE_IN_PLACE);
if (rc < 0 || rc > SPDK_JSONRPC_MAX_VALUES) {
SPDK_DEBUGLOG(SPDK_TRACE_RPC, "JSON parse error on second pass\n");
SPDK_DEBUGLOG(SPDK_LOG_RPC, "JSON parse error on second pass\n");
spdk_jsonrpc_server_handle_error(request, SPDK_JSONRPC_ERROR_PARSE_ERROR);
return -1;
}
@ -170,10 +170,10 @@ spdk_jsonrpc_parse_request(struct spdk_jsonrpc_server_conn *conn, void *json, si
if (conn->values[0].type == SPDK_JSON_VAL_OBJECT_BEGIN) {
parse_single_request(request, conn->values);
} else if (conn->values[0].type == SPDK_JSON_VAL_ARRAY_BEGIN) {
SPDK_DEBUGLOG(SPDK_TRACE_RPC, "Got batch array (not currently supported)\n");
SPDK_DEBUGLOG(SPDK_LOG_RPC, "Got batch array (not currently supported)\n");
spdk_jsonrpc_server_handle_error(request, SPDK_JSONRPC_ERROR_INVALID_REQUEST);
} else {
SPDK_DEBUGLOG(SPDK_TRACE_RPC, "top-level JSON value was not array or object\n");
SPDK_DEBUGLOG(SPDK_LOG_RPC, "top-level JSON value was not array or object\n");
spdk_jsonrpc_server_handle_error(request, SPDK_JSONRPC_ERROR_INVALID_REQUEST);
}
@ -290,4 +290,4 @@ spdk_jsonrpc_send_error_response(struct spdk_jsonrpc_request *request,
end_response(request, w);
}
SPDK_LOG_REGISTER_TRACE_FLAG("rpc", SPDK_TRACE_RPC)
SPDK_LOG_REGISTER_COMPONENT("rpc", SPDK_LOG_RPC)

8
lib/jsonrpc/jsonrpc_server_tcp.c
View File

@ -231,12 +231,12 @@ spdk_jsonrpc_server_conn_recv(struct spdk_jsonrpc_server_conn *conn)
return 0;
}
spdk_strerror_r(errno, buf, sizeof(buf));
SPDK_DEBUGLOG(SPDK_TRACE_RPC, "recv() failed: %s\n", buf);
SPDK_DEBUGLOG(SPDK_LOG_RPC, "recv() failed: %s\n", buf);
return -1;
}
if (rc == 0) {
SPDK_DEBUGLOG(SPDK_TRACE_RPC, "remote closed connection\n");
SPDK_DEBUGLOG(SPDK_LOG_RPC, "remote closed connection\n");
return -1;
}
@ -301,7 +301,7 @@ more:
}
spdk_strerror_r(errno, buf, sizeof(buf));
SPDK_DEBUGLOG(SPDK_TRACE_RPC, "send() failed: %s\n", buf);
SPDK_DEBUGLOG(SPDK_LOG_RPC, "send() failed: %s\n", buf);
return -1;
}
@ -350,7 +350,7 @@ spdk_jsonrpc_server_poll(struct spdk_jsonrpc_server *server)
}
if (conn->outstanding_requests == 0) {
SPDK_DEBUGLOG(SPDK_TRACE_RPC, "all outstanding requests completed\n");
SPDK_DEBUGLOG(SPDK_LOG_RPC, "all outstanding requests completed\n");
spdk_jsonrpc_server_conn_remove(conn);
}
}

2
lib/log/log_flags.c
View File

@ -40,7 +40,7 @@ static TAILQ_HEAD(, spdk_trace_flag) g_trace_flags = TAILQ_HEAD_INITIALIZER(g_tr
enum spdk_log_level g_spdk_log_level = SPDK_LOG_NOTICE;
enum spdk_log_level g_spdk_log_print_level = SPDK_LOG_NOTICE;
SPDK_LOG_REGISTER_TRACE_FLAG("log", SPDK_TRACE_LOG)
SPDK_LOG_REGISTER_COMPONENT("log", SPDK_LOG_LOG)
#define MAX_TMPBUF 1024

16
lib/log/rpc/log_rpc.c
View File

@ -108,13 +108,13 @@ spdk_rpc_set_log_print_level(struct spdk_jsonrpc_request *request,
if (spdk_json_decode_object(params, rpc_log_level_decoders,
SPDK_COUNTOF(rpc_log_level_decoders), &req)) {
SPDK_DEBUGLOG(SPDK_TRACE_LOG, "spdk_json_decode_object failed\n");
SPDK_DEBUGLOG(SPDK_LOG_LOG, "spdk_json_decode_object failed\n");
goto invalid;
}
level = _parse_log_level(req.level);
if (level == -1) {
SPDK_DEBUGLOG(SPDK_TRACE_LOG, "try to set invalid log level\n");
SPDK_DEBUGLOG(SPDK_LOG_LOG, "try to set invalid log level\n");
goto invalid;
}
@ -174,13 +174,13 @@ spdk_rpc_set_log_level(struct spdk_jsonrpc_request *request,
if (spdk_json_decode_object(params, rpc_log_level_decoders,
SPDK_COUNTOF(rpc_log_level_decoders), &req)) {
SPDK_DEBUGLOG(SPDK_TRACE_LOG, "spdk_json_decode_object failed\n");
SPDK_DEBUGLOG(SPDK_LOG_LOG, "spdk_json_decode_object failed\n");
goto invalid;
}
level = _parse_log_level(req.level);
if (level == -1) {
SPDK_DEBUGLOG(SPDK_TRACE_LOG, "try to set invalid log level\n");
SPDK_DEBUGLOG(SPDK_LOG_LOG, "try to set invalid log level\n");
goto invalid;
}
@ -239,12 +239,12 @@ spdk_rpc_set_trace_flag(struct spdk_jsonrpc_request *request,
if (spdk_json_decode_object(params, rpc_trace_flag_decoders,
SPDK_COUNTOF(rpc_trace_flag_decoders), &req)) {
SPDK_DEBUGLOG(SPDK_TRACE_LOG, "spdk_json_decode_object failed\n");
SPDK_DEBUGLOG(SPDK_LOG_LOG, "spdk_json_decode_object failed\n");
goto invalid;
}
if (req.flag == 0) {
SPDK_DEBUGLOG(SPDK_TRACE_LOG, "flag was 0\n");
SPDK_DEBUGLOG(SPDK_LOG_LOG, "flag was 0\n");
goto invalid;
}
@ -275,12 +275,12 @@ spdk_rpc_clear_trace_flag(struct spdk_jsonrpc_request *request,
if (spdk_json_decode_object(params, rpc_trace_flag_decoders,
SPDK_COUNTOF(rpc_trace_flag_decoders), &req)) {
SPDK_DEBUGLOG(SPDK_TRACE_LOG, "spdk_json_decode_object failed\n");
SPDK_DEBUGLOG(SPDK_LOG_LOG, "spdk_json_decode_object failed\n");
goto invalid;
}
if (req.flag == 0) {
SPDK_DEBUGLOG(SPDK_TRACE_LOG, "flag was 0\n");
SPDK_DEBUGLOG(SPDK_LOG_LOG, "flag was 0\n");
goto invalid;
}

44
lib/lvol/lvol.c
View File

@ -40,7 +40,7 @@
/* Length of string returned from uuid_unparse() */
#define UUID_STRING_LEN 37
SPDK_LOG_REGISTER_TRACE_FLAG("lvol", SPDK_TRACE_LVOL)
SPDK_LOG_REGISTER_COMPONENT("lvol", SPDK_LOG_LVOL)
static TAILQ_HEAD(, spdk_lvol_store) g_lvol_stores = TAILQ_HEAD_INITIALIZER(g_lvol_stores);
static pthread_mutex_t g_lvol_stores_mutex = PTHREAD_MUTEX_INITIALIZER;
@ -88,7 +88,7 @@ _spdk_lvol_open_cb(void *cb_arg, struct spdk_blob *blob, int lvolerrno)
struct spdk_lvol *lvol = req->lvol;
if (lvolerrno != 0) {
SPDK_INFOLOG(SPDK_TRACE_LVOL, "Failed to open lvol %s\n", lvol->old_name);
SPDK_INFOLOG(SPDK_LOG_LVOL, "Failed to open lvol %s\n", lvol->old_name);
goto end;
}
@ -174,7 +174,7 @@ _spdk_load_next_lvol(void *cb_arg, struct spdk_blob *blob, int lvolerrno)
blob_id = spdk_blob_get_id(blob);
if (blob_id == lvs->super_blob_id) {
SPDK_INFOLOG(SPDK_TRACE_LVOL, "found superblob %"PRIu64"\n", (uint64_t)blob_id);
SPDK_INFOLOG(SPDK_LOG_LVOL, "found superblob %"PRIu64"\n", (uint64_t)blob_id);
spdk_bs_md_iter_next(bs, &blob, _spdk_load_next_lvol, req);
return;
}
@ -215,7 +215,7 @@ _spdk_load_next_lvol(void *cb_arg, struct spdk_blob *blob, int lvolerrno)
lvs->lvol_count++;
SPDK_INFOLOG(SPDK_TRACE_LVOL, "added lvol %s\n", lvol->old_name);
SPDK_INFOLOG(SPDK_LOG_LVOL, "added lvol %s\n", lvol->old_name);
spdk_bs_md_iter_next(bs, &blob, _spdk_load_next_lvol, req);
@ -240,7 +240,7 @@ _spdk_close_super_cb(void *cb_arg, int lvolerrno)
struct spdk_blob_store *bs = lvs->blobstore;
if (lvolerrno != 0) {
SPDK_INFOLOG(SPDK_TRACE_LVOL, "Could not close super blob\n");
SPDK_INFOLOG(SPDK_LOG_LVOL, "Could not close super blob\n");
_spdk_lvs_free(lvs);
req->lvserrno = -ENODEV;
spdk_bs_unload(bs, _spdk_bs_unload_with_error_cb, req);
@ -274,7 +274,7 @@ _spdk_lvs_read_uuid(void *cb_arg, struct spdk_blob *blob, int lvolerrno)
int rc;
if (lvolerrno != 0) {
SPDK_INFOLOG(SPDK_TRACE_LVOL, "Could not open super blob\n");
SPDK_INFOLOG(SPDK_LOG_LVOL, "Could not open super blob\n");
_spdk_lvs_free(lvs);
req->lvserrno = -ENODEV;
spdk_bs_unload(bs, _spdk_bs_unload_with_error_cb, req);
@ -283,14 +283,14 @@ _spdk_lvs_read_uuid(void *cb_arg, struct spdk_blob *blob, int lvolerrno)
rc = spdk_bs_md_get_xattr_value(blob, "uuid", (const void **)&attr, &value_len);
if (rc != 0 || value_len != UUID_STRING_LEN || attr[UUID_STRING_LEN - 1] != '\0') {
SPDK_INFOLOG(SPDK_TRACE_LVOL, "missing or incorrect UUID\n");
SPDK_INFOLOG(SPDK_LOG_LVOL, "missing or incorrect UUID\n");
req->lvserrno = -EINVAL;
spdk_bs_md_close_blob(&blob, _spdk_close_super_blob_with_error_cb, req);
return;
}
if (uuid_parse(attr, lvs->uuid)) {
SPDK_INFOLOG(SPDK_TRACE_LVOL, "incorrect UUID '%s'\n", attr);
SPDK_INFOLOG(SPDK_LOG_LVOL, "incorrect UUID '%s'\n", attr);
req->lvserrno = -EINVAL;
spdk_bs_md_close_blob(&blob, _spdk_close_super_blob_with_error_cb, req);
return;
@ -298,7 +298,7 @@ _spdk_lvs_read_uuid(void *cb_arg, struct spdk_blob *blob, int lvolerrno)
rc = spdk_bs_md_get_xattr_value(blob, "name", (const void **)&attr, &value_len);
if (rc != 0 || value_len > SPDK_LVS_NAME_MAX) {
SPDK_INFOLOG(SPDK_TRACE_LVOL, "missing or invalid name\n");
SPDK_INFOLOG(SPDK_LOG_LVOL, "missing or invalid name\n");
req->lvserrno = -EINVAL;
spdk_bs_md_close_blob(&blob, _spdk_close_super_blob_with_error_cb, req);
return;
@ -308,7 +308,7 @@ _spdk_lvs_read_uuid(void *cb_arg, struct spdk_blob *blob, int lvolerrno)
rc = _spdk_add_lvs_to_list(lvs);
if (rc) {
SPDK_INFOLOG(SPDK_TRACE_LVOL, "lvolstore with name %s already exists\n", lvs->name);
SPDK_INFOLOG(SPDK_LOG_LVOL, "lvolstore with name %s already exists\n", lvs->name);
req->lvserrno = -EEXIST;
spdk_bs_md_close_blob(&blob, _spdk_close_super_blob_with_error_cb, req);
return;
@ -327,7 +327,7 @@ _spdk_lvs_open_super(void *cb_arg, spdk_blob_id blobid, int lvolerrno)
struct spdk_blob_store *bs = lvs->blobstore;
if (lvolerrno != 0) {
SPDK_INFOLOG(SPDK_TRACE_LVOL, "Super blob not found\n");
SPDK_INFOLOG(SPDK_LOG_LVOL, "Super blob not found\n");
_spdk_lvs_free(lvs);
req->lvserrno = -ENODEV;
spdk_bs_unload(bs, _spdk_bs_unload_with_error_cb, req);
@ -514,7 +514,7 @@ _spdk_lvs_init_cb(void *cb_arg, struct spdk_blob_store *bs, int lvserrno)
lvs->blobstore = bs;
TAILQ_INIT(&lvs->lvols);
SPDK_INFOLOG(SPDK_TRACE_LVOL, "Lvol store initialized\n");
SPDK_INFOLOG(SPDK_LOG_LVOL, "Lvol store initialized\n");
/* create super blob */
spdk_bs_md_create_blob(lvs->blobstore, _spdk_super_blob_create_cb, lvs_req);
@ -598,7 +598,7 @@ spdk_lvs_init(struct spdk_bs_dev *bs_dev, struct spdk_lvs_opts *o,
strncpy(opts.bstype.bstype, "LVOLSTORE", SPDK_BLOBSTORE_TYPE_LENGTH);
SPDK_INFOLOG(SPDK_TRACE_LVOL, "Initializing lvol store\n");
SPDK_INFOLOG(SPDK_LOG_LVOL, "Initializing lvol store\n");
spdk_bs_init(bs_dev, &opts, _spdk_lvs_init_cb, lvs_req);
return 0;
@ -609,7 +609,7 @@ _lvs_unload_cb(void *cb_arg, int lvserrno)
{
struct spdk_lvs_req *lvs_req = cb_arg;
SPDK_INFOLOG(SPDK_TRACE_LVOL, "Lvol store unloaded\n");
SPDK_INFOLOG(SPDK_LOG_LVOL, "Lvol store unloaded\n");
assert(lvs_req->cb_fn != NULL);
lvs_req->cb_fn(lvs_req->cb_arg, lvserrno);
free(lvs_req);
@ -654,7 +654,7 @@ spdk_lvs_unload(struct spdk_lvol_store *lvs, spdk_lvs_op_complete cb_fn,
lvs_req->cb_fn = cb_fn;
lvs_req->cb_arg = cb_arg;
SPDK_INFOLOG(SPDK_TRACE_LVOL, "Unloading lvol store\n");
SPDK_INFOLOG(SPDK_LOG_LVOL, "Unloading lvol store\n");
spdk_bs_unload(lvs->blobstore, _lvs_unload_cb, lvs_req);
_spdk_lvs_free(lvs);
@ -666,7 +666,7 @@ _spdk_lvs_destruct_cb(void *cb_arg, int lvserrno)
{
struct spdk_lvs_req *req = cb_arg;
SPDK_INFOLOG(SPDK_TRACE_LVOL, "Lvol store bdev deleted\n");
SPDK_INFOLOG(SPDK_LOG_LVOL, "Lvol store bdev deleted\n");
if (req->cb_fn != NULL)
req->cb_fn(req->cb_arg, lvserrno);
@ -678,7 +678,7 @@ _lvs_destroy_cb(void *cb_arg, int lvserrno)
{
struct spdk_lvs_destroy_req *lvs_req = cb_arg;
SPDK_INFOLOG(SPDK_TRACE_LVOL, "Lvol store destroyed\n");
SPDK_INFOLOG(SPDK_LOG_LVOL, "Lvol store destroyed\n");
assert(lvs_req->cb_fn != NULL);
lvs_req->cb_fn(lvs_req->cb_arg, lvserrno);
free(lvs_req);
@ -692,7 +692,7 @@ _lvs_destroy_super_cb(void *cb_arg, int bserrno)
assert(lvs != NULL);
SPDK_INFOLOG(SPDK_TRACE_LVOL, "Destroying lvol store\n");
SPDK_INFOLOG(SPDK_LOG_LVOL, "Destroying lvol store\n");
spdk_bs_destroy(lvs->blobstore, _lvs_destroy_cb, lvs_req);
_spdk_lvs_free(lvs);
}
@ -736,7 +736,7 @@ spdk_lvs_destroy(struct spdk_lvol_store *lvs, spdk_lvs_op_complete cb_fn,
lvs_req->cb_arg = cb_arg;
lvs_req->lvs = lvs;
SPDK_INFOLOG(SPDK_TRACE_LVOL, "Deleting super blob\n");
SPDK_INFOLOG(SPDK_LOG_LVOL, "Deleting super blob\n");
spdk_bs_md_delete_blob(lvs->blobstore, lvs->super_blob_id, _lvs_destroy_super_cb, lvs_req);
return 0;
@ -767,7 +767,7 @@ _spdk_lvol_close_blob_cb(void *cb_arg, int lvolerrno)
lvol->action_in_progress = false;
SPDK_INFOLOG(SPDK_TRACE_LVOL, "Lvol %s closed\n", lvol->old_name);
SPDK_INFOLOG(SPDK_LOG_LVOL, "Lvol %s closed\n", lvol->old_name);
if (lvol->lvol_store->destruct_req && all_lvols_closed == true) {
if (!lvol->lvol_store->destruct) {
@ -801,7 +801,7 @@ _spdk_lvol_delete_blob_cb(void *cb_arg, int lvolerrno)
spdk_lvs_destroy(lvol->lvol_store, _spdk_lvs_destruct_cb, lvol->lvol_store->destruct_req);
}
SPDK_INFOLOG(SPDK_TRACE_LVOL, "Lvol %s deleted\n", lvol->old_name);
SPDK_INFOLOG(SPDK_LOG_LVOL, "Lvol %s deleted\n", lvol->old_name);
free(lvol->old_name);
free(lvol);
@ -829,7 +829,7 @@ _spdk_lvol_destroy_cb(void *cb_arg, int lvolerrno)
free(req);
return;
}
SPDK_INFOLOG(SPDK_TRACE_LVOL, "Blob closed on lvol %s\n", lvol->old_name);
SPDK_INFOLOG(SPDK_LOG_LVOL, "Blob closed on lvol %s\n", lvol->old_name);
spdk_bs_md_delete_blob(bs, lvol->blob_id, _spdk_lvol_delete_blob_cb, req);
}

6
lib/net/net_rpc.c
View File

@ -65,7 +65,7 @@ spdk_rpc_add_ip_address(struct spdk_jsonrpc_request *request,
if (spdk_json_decode_object(params, rpc_ip_address_decoders,
SPDK_COUNTOF(rpc_ip_address_decoders),
&req)) {
SPDK_DEBUGLOG(SPDK_TRACE_NET, "spdk_json_decode_object failed\n");
SPDK_DEBUGLOG(SPDK_LOG_NET, "spdk_json_decode_object failed\n");
goto invalid;
}
@ -100,7 +100,7 @@ spdk_rpc_delete_ip_address(struct spdk_jsonrpc_request *request,
if (spdk_json_decode_object(params, rpc_ip_address_decoders,
SPDK_COUNTOF(rpc_ip_address_decoders),
&req)) {
SPDK_DEBUGLOG(SPDK_TRACE_NET, "spdk_json_decode_object failed\n");
SPDK_DEBUGLOG(SPDK_LOG_NET, "spdk_json_decode_object failed\n");
goto invalid;
}
@ -175,4 +175,4 @@ spdk_rpc_get_interfaces(struct spdk_jsonrpc_request *request,
}
SPDK_RPC_REGISTER("get_interfaces", spdk_rpc_get_interfaces)
SPDK_LOG_REGISTER_TRACE_FLAG("net", SPDK_TRACE_NET)
SPDK_LOG_REGISTER_COMPONENT("net", SPDK_LOG_NET)

2
lib/nvme/nvme.c
View File

@ -816,4 +816,4 @@ spdk_nvme_transport_id_compare(const struct spdk_nvme_transport_id *trid1,
return 0;
}
SPDK_LOG_REGISTER_TRACE_FLAG("nvme", SPDK_TRACE_NVME)
SPDK_LOG_REGISTER_COMPONENT("nvme", SPDK_LOG_NVME)

56
lib/nvme/nvme_ctrlr.c
View File

@ -509,10 +509,10 @@ nvme_ctrlr_shutdown(struct spdk_nvme_ctrlr *ctrlr)
* 10 seconds as a reasonable amount of time to
* wait before proceeding.
*/
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "RTD3E = %" PRIu32 " us\n", ctrlr->cdata.rtd3e);
SPDK_DEBUGLOG(SPDK_LOG_NVME, "RTD3E = %" PRIu32 " us\n", ctrlr->cdata.rtd3e);
shutdown_timeout_ms = (ctrlr->cdata.rtd3e + 999) / 1000;
shutdown_timeout_ms = spdk_max(shutdown_timeout_ms, 10000);
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "shutdown timeout = %" PRIu32 " ms\n", shutdown_timeout_ms);
SPDK_DEBUGLOG(SPDK_LOG_NVME, "shutdown timeout = %" PRIu32 " ms\n", shutdown_timeout_ms);
do {
if (nvme_ctrlr_get_csts(ctrlr, &csts)) {
@ -521,7 +521,7 @@ nvme_ctrlr_shutdown(struct spdk_nvme_ctrlr *ctrlr)
}
if (csts.bits.shst == SPDK_NVME_SHST_COMPLETE) {
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "shutdown complete in %u milliseconds\n",
SPDK_DEBUGLOG(SPDK_LOG_NVME, "shutdown complete in %u milliseconds\n",
ms_waited);
return;
}
@ -619,11 +619,11 @@ nvme_ctrlr_set_state(struct spdk_nvme_ctrlr *ctrlr, enum nvme_ctrlr_state state,
{
ctrlr->state = state;
if (timeout_in_ms == NVME_TIMEOUT_INFINITE) {
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "setting state to %s (no timeout)\n",
SPDK_DEBUGLOG(SPDK_LOG_NVME, "setting state to %s (no timeout)\n",
nvme_ctrlr_state_string(ctrlr->state));
ctrlr->state_timeout_tsc = NVME_TIMEOUT_INFINITE;
} else {
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "setting state to %s (timeout %" PRIu64 " ms)\n",
SPDK_DEBUGLOG(SPDK_LOG_NVME, "setting state to %s (timeout %" PRIu64 " ms)\n",
nvme_ctrlr_state_string(ctrlr->state), timeout_in_ms);
ctrlr->state_timeout_tsc = spdk_get_ticks() + (timeout_in_ms * spdk_get_ticks_hz()) / 1000;
}
@ -680,7 +680,7 @@ nvme_ctrlr_set_doorbell_buffer_config(struct spdk_nvme_ctrlr *ctrlr)
goto error;
}
SPDK_INFOLOG(SPDK_TRACE_NVME, "NVMe controller: %s doorbell buffer config enabled\n",
SPDK_INFOLOG(SPDK_LOG_NVME, "NVMe controller: %s doorbell buffer config enabled\n",
ctrlr->trid.traddr);
return 0;
@ -784,11 +784,11 @@ nvme_ctrlr_identify(struct spdk_nvme_ctrlr *ctrlr)
* controller supports.
*/
ctrlr->max_xfer_size = nvme_transport_ctrlr_get_max_xfer_size(ctrlr);
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "transport max_xfer_size %u\n", ctrlr->max_xfer_size);
SPDK_DEBUGLOG(SPDK_LOG_NVME, "transport max_xfer_size %u\n", ctrlr->max_xfer_size);
if (ctrlr->cdata.mdts > 0) {
ctrlr->max_xfer_size = spdk_min(ctrlr->max_xfer_size,
ctrlr->min_page_size * (1 << (ctrlr->cdata.mdts)));
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "MDTS max_xfer_size %u\n", ctrlr->max_xfer_size);
SPDK_DEBUGLOG(SPDK_LOG_NVME, "MDTS max_xfer_size %u\n", ctrlr->max_xfer_size);
}
return 0;
@ -884,7 +884,7 @@ nvme_ctrlr_set_keep_alive_timeout(struct spdk_nvme_ctrlr *ctrlr)
}
if (ctrlr->cdata.kas == 0) {
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "Controller KAS is 0 - not enabling Keep Alive\n");
SPDK_DEBUGLOG(SPDK_LOG_NVME, "Controller KAS is 0 - not enabling Keep Alive\n");
ctrlr->opts.keep_alive_timeout_ms = 0;
return 0;
}
@ -910,7 +910,7 @@ nvme_ctrlr_set_keep_alive_timeout(struct spdk_nvme_ctrlr *ctrlr)
}
if (ctrlr->opts.keep_alive_timeout_ms != status.cpl.cdw0) {
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "Controller adjusted keep alive timeout to %u ms\n",
SPDK_DEBUGLOG(SPDK_LOG_NVME, "Controller adjusted keep alive timeout to %u ms\n",
status.cpl.cdw0);
}
@ -920,7 +920,7 @@ nvme_ctrlr_set_keep_alive_timeout(struct spdk_nvme_ctrlr *ctrlr)
if (keep_alive_interval_ms == 0) {
keep_alive_interval_ms = 1;
}
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "Sending keep alive every %u ms\n", keep_alive_interval_ms);
SPDK_DEBUGLOG(SPDK_LOG_NVME, "Sending keep alive every %u ms\n", keep_alive_interval_ms);
ctrlr->keep_alive_interval_ticks = (keep_alive_interval_ms * spdk_get_ticks_hz()) / UINT64_C(1000);
@ -945,16 +945,16 @@ nvme_ctrlr_set_host_id(struct spdk_nvme_ctrlr *ctrlr)
* NVMe-oF sends the host ID during Connect and doesn't allow
* Set Features - Host Identifier after Connect, so we don't need to do anything here.
*/
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "NVMe-oF transport - not sending Set Features - Host ID\n");
SPDK_DEBUGLOG(SPDK_LOG_NVME, "NVMe-oF transport - not sending Set Features - Host ID\n");
return 0;
}
if (ctrlr->cdata.ctratt.host_id_exhid_supported) {
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "Using 128-bit extended host identifier\n");
SPDK_DEBUGLOG(SPDK_LOG_NVME, "Using 128-bit extended host identifier\n");
host_id = ctrlr->opts.extended_host_id;
host_id_size = sizeof(ctrlr->opts.extended_host_id);
} else {
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "Using 64-bit host identifier\n");
SPDK_DEBUGLOG(SPDK_LOG_NVME, "Using 64-bit host identifier\n");
host_id = ctrlr->opts.host_id;
host_id_size = sizeof(ctrlr->opts.host_id);
}
@ -969,12 +969,12 @@ nvme_ctrlr_set_host_id(struct spdk_nvme_ctrlr *ctrlr)
}
if (all_zeroes) {
SPDK_DEBUGLOG(SPDK_TRACE_NVME,
SPDK_DEBUGLOG(SPDK_LOG_NVME,
"User did not specify host ID - not sending Set Features - Host ID\n");
return 0;
}
SPDK_TRACEDUMP(SPDK_TRACE_NVME, "host_id", host_id, host_id_size);
SPDK_TRACEDUMP(SPDK_LOG_NVME, "host_id", host_id, host_id_size);
status.done = false;
rc = nvme_ctrlr_cmd_set_host_id(ctrlr, host_id, host_id_size, nvme_completion_poll_cb, &status);
@ -996,7 +996,7 @@ nvme_ctrlr_set_host_id(struct spdk_nvme_ctrlr *ctrlr)
return 0;
}
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "Set Features - Host ID was successful\n");
SPDK_DEBUGLOG(SPDK_LOG_NVME, "Set Features - Host ID was successful\n");
return 0;
}
@ -1443,7 +1443,7 @@ nvme_ctrlr_process_init(struct spdk_nvme_ctrlr *ctrlr)
case NVME_CTRLR_STATE_INIT:
/* Begin the hardware initialization by making sure the controller is disabled. */
if (cc.bits.en) {
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "CC.EN = 1\n");
SPDK_DEBUGLOG(SPDK_LOG_NVME, "CC.EN = 1\n");
/*
* Controller is currently enabled. We need to disable it to cause a reset.
*
@ -1451,13 +1451,13 @@ nvme_ctrlr_process_init(struct spdk_nvme_ctrlr *ctrlr)
* Wait for the ready bit to be 1 before disabling the controller.
*/
if (csts.bits.rdy == 0) {
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "CC.EN = 1 && CSTS.RDY = 0 - waiting for reset to complete\n");
SPDK_DEBUGLOG(SPDK_LOG_NVME, "CC.EN = 1 && CSTS.RDY = 0 - waiting for reset to complete\n");
nvme_ctrlr_set_state(ctrlr, NVME_CTRLR_STATE_DISABLE_WAIT_FOR_READY_1, ready_timeout_in_ms);
return 0;
}
/* CC.EN = 1 && CSTS.RDY == 1, so we can immediately disable the controller. */
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "Setting CC.EN = 0\n");
SPDK_DEBUGLOG(SPDK_LOG_NVME, "Setting CC.EN = 0\n");
cc.bits.en = 0;
if (nvme_ctrlr_set_cc(ctrlr, &cc)) {
SPDK_ERRLOG("set_cc() failed\n");
@ -1471,13 +1471,13 @@ nvme_ctrlr_process_init(struct spdk_nvme_ctrlr *ctrlr)
* Not using sleep() to avoid blocking other controller's initialization.
*/
if (ctrlr->quirks & NVME_QUIRK_DELAY_BEFORE_CHK_RDY) {
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "Applying quirk: delay 2 seconds before reading registers\n");
SPDK_DEBUGLOG(SPDK_LOG_NVME, "Applying quirk: delay 2 seconds before reading registers\n");
ctrlr->sleep_timeout_tsc = spdk_get_ticks() + 2 * spdk_get_ticks_hz();
}
return 0;
} else {
if (csts.bits.rdy == 1) {
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "CC.EN = 0 && CSTS.RDY = 1 - waiting for shutdown to complete\n");
SPDK_DEBUGLOG(SPDK_LOG_NVME, "CC.EN = 0 && CSTS.RDY = 1 - waiting for shutdown to complete\n");
}
nvme_ctrlr_set_state(ctrlr, NVME_CTRLR_STATE_DISABLE_WAIT_FOR_READY_0, ready_timeout_in_ms);
@ -1487,9 +1487,9 @@ nvme_ctrlr_process_init(struct spdk_nvme_ctrlr *ctrlr)
case NVME_CTRLR_STATE_DISABLE_WAIT_FOR_READY_1:
if (csts.bits.rdy == 1) {
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "CC.EN = 1 && CSTS.RDY = 1 - disabling controller\n");
SPDK_DEBUGLOG(SPDK_LOG_NVME, "CC.EN = 1 && CSTS.RDY = 1 - disabling controller\n");
/* CC.EN = 1 && CSTS.RDY = 1, so we can set CC.EN = 0 now. */
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "Setting CC.EN = 0\n");
SPDK_DEBUGLOG(SPDK_LOG_NVME, "Setting CC.EN = 0\n");
cc.bits.en = 0;
if (nvme_ctrlr_set_cc(ctrlr, &cc)) {
SPDK_ERRLOG("set_cc() failed\n");
@ -1503,7 +1503,7 @@ nvme_ctrlr_process_init(struct spdk_nvme_ctrlr *ctrlr)
case NVME_CTRLR_STATE_DISABLE_WAIT_FOR_READY_0:
if (csts.bits.rdy == 0) {
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "CC.EN = 0 && CSTS.RDY = 0\n");
SPDK_DEBUGLOG(SPDK_LOG_NVME, "CC.EN = 0 && CSTS.RDY = 0\n");
nvme_ctrlr_set_state(ctrlr, NVME_CTRLR_STATE_ENABLE, ready_timeout_in_ms);
/*
* Delay 100us before setting CC.EN = 1. Some NVMe SSDs miss CC.EN getting
@ -1515,14 +1515,14 @@ nvme_ctrlr_process_init(struct spdk_nvme_ctrlr *ctrlr)
break;
case NVME_CTRLR_STATE_ENABLE:
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "Setting CC.EN = 1\n");
SPDK_DEBUGLOG(SPDK_LOG_NVME, "Setting CC.EN = 1\n");
rc = nvme_ctrlr_enable(ctrlr);
nvme_ctrlr_set_state(ctrlr, NVME_CTRLR_STATE_ENABLE_WAIT_FOR_READY_1, ready_timeout_in_ms);
return rc;
case NVME_CTRLR_STATE_ENABLE_WAIT_FOR_READY_1:
if (csts.bits.rdy == 1) {
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "CC.EN = 1 && CSTS.RDY = 1 - controller is ready\n");
SPDK_DEBUGLOG(SPDK_LOG_NVME, "CC.EN = 1 && CSTS.RDY = 1 - controller is ready\n");
/*
* The controller has been enabled.
* Perform the rest of initialization in nvme_ctrlr_start() serially.
@ -1534,7 +1534,7 @@ nvme_ctrlr_process_init(struct spdk_nvme_ctrlr *ctrlr)
break;
case NVME_CTRLR_STATE_READY:
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "Ctrlr already in ready state\n");
SPDK_DEBUGLOG(SPDK_LOG_NVME, "Ctrlr already in ready state\n");
return 0;
default:

4
lib/nvme/nvme_ns.c
View File

@ -88,13 +88,13 @@ int nvme_ns_identify_update(struct spdk_nvme_ns *ns)
if (nsdata->noiob) {
ns->sectors_per_stripe = nsdata->noiob;
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "ns %u optimal IO boundary %" PRIu32 " blocks\n",
SPDK_DEBUGLOG(SPDK_LOG_NVME, "ns %u optimal IO boundary %" PRIu32 " blocks\n",
ns->id, ns->sectors_per_stripe);
} else if (ns->ctrlr->quirks & NVME_INTEL_QUIRK_STRIPING &&
ns->ctrlr->cdata.vs[3] != 0) {
ns->sectors_per_stripe = (1ULL << ns->ctrlr->cdata.vs[3]) * ns->ctrlr->min_page_size /
ns->sector_size;
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "ns %u stripe size quirk %" PRIu32 " blocks\n",
SPDK_DEBUGLOG(SPDK_LOG_NVME, "ns %u stripe size quirk %" PRIu32 " blocks\n",
ns->id, ns->sectors_per_stripe);
} else {
ns->sectors_per_stripe = 0;

16
lib/nvme/nvme_pcie.c
View File

@ -243,7 +243,7 @@ _nvme_pcie_hotplug_monitor(void *cb_ctx, spdk_nvme_probe_cb probe_cb,
if (event.subsystem == SPDK_NVME_UEVENT_SUBSYSTEM_UIO ||
event.subsystem == SPDK_NVME_UEVENT_SUBSYSTEM_VFIO) {
if (event.action == SPDK_NVME_UEVENT_ADD) {
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "add nvme address: %s\n",
SPDK_DEBUGLOG(SPDK_LOG_NVME, "add nvme address: %s\n",
event.traddr);
if (spdk_process_is_primary()) {
if (!spdk_pci_addr_parse(&pci_addr, event.traddr)) {
@ -261,7 +261,7 @@ _nvme_pcie_hotplug_monitor(void *cb_ctx, spdk_nvme_probe_cb probe_cb,
if (ctrlr == NULL) {
return 0;
}
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "remove nvme address: %s\n",
SPDK_DEBUGLOG(SPDK_LOG_NVME, "remove nvme address: %s\n",
event.traddr);
nvme_ctrlr_fail(ctrlr, true);
@ -640,7 +640,7 @@ nvme_pcie_ctrlr_scan(const struct spdk_nvme_transport_id *trid,
if (hotplug_fd < 0) {
hotplug_fd = spdk_uevent_connect();
if (hotplug_fd < 0) {
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "Failed to open uevent netlink socket\n");
SPDK_DEBUGLOG(SPDK_LOG_NVME, "Failed to open uevent netlink socket\n");
}
} else {
_nvme_pcie_hotplug_monitor(cb_ctx, probe_cb, remove_cb);
@ -1585,7 +1585,7 @@ nvme_pcie_prp_list_append(struct nvme_tracker *tr, uint32_t *prp_index, void *vi
uint64_t phys_addr;
uint32_t i;
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "prp_index:%u virt_addr:%p len:%u\n",
SPDK_DEBUGLOG(SPDK_LOG_NVME, "prp_index:%u virt_addr:%p len:%u\n",
*prp_index, virt_addr, (uint32_t)len);
if (spdk_unlikely(((uintptr_t)virt_addr & 3) != 0)) {
@ -1613,7 +1613,7 @@ nvme_pcie_prp_list_append(struct nvme_tracker *tr, uint32_t *prp_index, void *vi
}
if (i == 0) {
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "prp1 = %p\n", (void *)phys_addr);
SPDK_DEBUGLOG(SPDK_LOG_NVME, "prp1 = %p\n", (void *)phys_addr);
cmd->dptr.prp.prp1 = phys_addr;
seg_len = page_size - ((uintptr_t)virt_addr & page_mask);
} else {
@ -1622,7 +1622,7 @@ nvme_pcie_prp_list_append(struct nvme_tracker *tr, uint32_t *prp_index, void *vi
return -EINVAL;
}
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "prp[%u] = %p\n", i - 1, (void *)phys_addr);
SPDK_DEBUGLOG(SPDK_LOG_NVME, "prp[%u] = %p\n", i - 1, (void *)phys_addr);
tr->u.prp[i - 1] = phys_addr;
seg_len = page_size;
}
@ -1638,10 +1638,10 @@ nvme_pcie_prp_list_append(struct nvme_tracker *tr, uint32_t *prp_index, void *vi
cmd->dptr.prp.prp2 = 0;
} else if (i == 2) {
cmd->dptr.prp.prp2 = tr->u.prp[0];
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "prp2 = %p\n", (void *)cmd->dptr.prp.prp2);
SPDK_DEBUGLOG(SPDK_LOG_NVME, "prp2 = %p\n", (void *)cmd->dptr.prp.prp2);
} else {
cmd->dptr.prp.prp2 = tr->prp_sgl_bus_addr;
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "prp2 = %p (PRP list)\n", (void *)cmd->dptr.prp.prp2);
SPDK_DEBUGLOG(SPDK_LOG_NVME, "prp2 = %p (PRP list)\n", (void *)cmd->dptr.prp.prp2);
}
*prp_index = i;

28
lib/nvme/nvme_rdma.c
View File

@ -225,7 +225,7 @@ nvme_rdma_qpair_init(struct nvme_rdma_qpair *rqpair)
#define nvme_rdma_trace_ibv_sge(sg_list) \
if (sg_list) { \
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "local addr %p length 0x%x lkey 0x%x\n", \
SPDK_DEBUGLOG(SPDK_LOG_NVME, "local addr %p length 0x%x lkey 0x%x\n", \
(void *)(sg_list)->addr, (sg_list)->length, (sg_list)->lkey); \
}
@ -521,7 +521,7 @@ nvme_rdma_connect(struct nvme_rdma_qpair *rqpair)
return -1;
}
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "Requested queue depth %d. Actually got queue depth %d.\n",
SPDK_DEBUGLOG(SPDK_LOG_NVME, "Requested queue depth %d. Actually got queue depth %d.\n",
rqpair->num_entries, accept_data->crqsize);
rqpair->num_entries = spdk_min(rqpair->num_entries, accept_data->crqsize);
@ -726,11 +726,11 @@ nvme_rdma_qpair_connect(struct nvme_rdma_qpair *rqpair)
return -1;
}
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "adrfam %d ai_family %d\n", ctrlr->trid.adrfam, family);
SPDK_DEBUGLOG(SPDK_LOG_NVME, "adrfam %d ai_family %d\n", ctrlr->trid.adrfam, family);
memset(&dst_addr, 0, sizeof(dst_addr));
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "trsvcid is %s\n", ctrlr->trid.trsvcid);
SPDK_DEBUGLOG(SPDK_LOG_NVME, "trsvcid is %s\n", ctrlr->trid.trsvcid);
rc = nvme_rdma_parse_addr(&dst_addr, family, ctrlr->trid.traddr, ctrlr->trid.trsvcid);
if (rc != 0) {
SPDK_ERRLOG("dst_addr nvme_rdma_parse_addr() failed\n");
@ -776,20 +776,20 @@ nvme_rdma_qpair_connect(struct nvme_rdma_qpair *rqpair)
}
rc = nvme_rdma_alloc_reqs(rqpair);
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "rc =%d\n", rc);
SPDK_DEBUGLOG(SPDK_LOG_NVME, "rc =%d\n", rc);
if (rc) {
SPDK_ERRLOG("Unable to allocate rqpair RDMA requests\n");
return -1;
}
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "RDMA requests allocated\n");
SPDK_DEBUGLOG(SPDK_LOG_NVME, "RDMA requests allocated\n");
rc = nvme_rdma_alloc_rsps(rqpair);
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "rc =%d\n", rc);
SPDK_DEBUGLOG(SPDK_LOG_NVME, "rc =%d\n", rc);
if (rc < 0) {
SPDK_ERRLOG("Unable to allocate rqpair RDMA responses\n");
return -1;
}
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "RDMA responses allocated\n");
SPDK_DEBUGLOG(SPDK_LOG_NVME, "RDMA responses allocated\n");
rc = nvme_rdma_register_mem(rqpair);
if (rc < 0) {
@ -1151,17 +1151,17 @@ nvme_rdma_discovery_probe(struct spdk_nvmf_discovery_log_page_entry *entry,
len = spdk_strlen_pad(entry->traddr, sizeof(entry->traddr), ' ');
memcpy(trid.traddr, entry->traddr, len);
if (spdk_str_chomp(trid.traddr) != 0) {
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "Trailing newlines removed from discovery TRADDR\n");
SPDK_DEBUGLOG(SPDK_LOG_NVME, "Trailing newlines removed from discovery TRADDR\n");
}
/* Convert trsvcid to a null terminated string. */
len = spdk_strlen_pad(entry->trsvcid, sizeof(entry->trsvcid), ' ');
memcpy(trid.trsvcid, entry->trsvcid, len);
if (spdk_str_chomp(trid.trsvcid) != 0) {
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "Trailing newlines removed from discovery TRSVCID\n");
SPDK_DEBUGLOG(SPDK_LOG_NVME, "Trailing newlines removed from discovery TRSVCID\n");
}
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "subnqn=%s, trtype=%u, traddr=%s, trsvcid=%s\n",
SPDK_DEBUGLOG(SPDK_LOG_NVME, "subnqn=%s, trtype=%u, traddr=%s, trsvcid=%s\n",
trid.subnqn, trid.trtype,
trid.traddr, trid.trsvcid);
@ -1250,7 +1250,7 @@ nvme_rdma_ctrlr_scan(const struct spdk_nvme_transport_id *discovery_trid,
do {
rc = nvme_fabrics_get_log_discovery_page(discovery_ctrlr, buffer, sizeof(buffer), log_page_offset);
if (rc < 0) {
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "nvme_fabrics_get_log_discovery_page error\n");
SPDK_DEBUGLOG(SPDK_LOG_NVME, "nvme_fabrics_get_log_discovery_page error\n");
nvme_ctrlr_destruct(discovery_ctrlr);
return rc;
}
@ -1323,7 +1323,7 @@ struct spdk_nvme_ctrlr *nvme_rdma_ctrlr_construct(const struct spdk_nvme_transpo
nvme_ctrlr_init_cap(&rctrlr->ctrlr, &cap);
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "succesully initialized the nvmf ctrlr\n");
SPDK_DEBUGLOG(SPDK_LOG_NVME, "succesully initialized the nvmf ctrlr\n");
return &rctrlr->ctrlr;
}
@ -1499,7 +1499,7 @@ nvme_rdma_qpair_process_completions(struct spdk_nvme_qpair *qpair,
switch (wc[i].opcode) {
case IBV_WC_RECV:
SPDK_DEBUGLOG(SPDK_TRACE_NVME, "CQ recv completion\n");
SPDK_DEBUGLOG(SPDK_LOG_NVME, "CQ recv completion\n");
reaped++;

104
lib/nvmf/ctrlr.c
View File

@ -116,10 +116,10 @@ spdk_nvmf_ctrlr_create(struct spdk_nvmf_subsystem *subsystem,
ctrlr->vcprop.csts.raw = 0;
ctrlr->vcprop.csts.bits.rdy = 0; /* Init controller as not ready */
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "cap 0x%" PRIx64 "\n", ctrlr->vcprop.cap.raw);
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "vs 0x%x\n", ctrlr->vcprop.vs.raw);
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "cc 0x%x\n", ctrlr->vcprop.cc.raw);
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "csts 0x%x\n", ctrlr->vcprop.csts.raw);
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "cap 0x%" PRIx64 "\n", ctrlr->vcprop.cap.raw);
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "vs 0x%x\n", ctrlr->vcprop.vs.raw);
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "cc 0x%x\n", ctrlr->vcprop.cc.raw);
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "csts 0x%x\n", ctrlr->vcprop.csts.raw);
if (spdk_nvmf_subsystem_add_ctrlr(subsystem, ctrlr)) {
SPDK_ERRLOG("Unable to add controller to subsystem\n");
@ -186,12 +186,12 @@ spdk_nvmf_ctrlr_connect(struct spdk_nvmf_request *req)
return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;
}
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "recfmt 0x%x qid %u sqsize %u\n",
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "recfmt 0x%x qid %u sqsize %u\n",
cmd->recfmt, cmd->qid, cmd->sqsize);
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "Connect data:\n");
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, " cntlid: 0x%04x\n", data->cntlid);
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, " hostid: %08x-%04x-%04x-%02x%02x-%04x%08x ***\n",
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "Connect data:\n");
SPDK_DEBUGLOG(SPDK_LOG_NVMF, " cntlid: 0x%04x\n", data->cntlid);
SPDK_DEBUGLOG(SPDK_LOG_NVMF, " hostid: %08x-%04x-%04x-%02x%02x-%04x%08x ***\n",
ntohl(*(uint32_t *)&data->hostid[0]),
ntohs(*(uint16_t *)&data->hostid[4]),
ntohs(*(uint16_t *)&data->hostid[6]),
@ -215,7 +215,7 @@ spdk_nvmf_ctrlr_connect(struct spdk_nvmf_request *req)
return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;
}
subnqn = data->subnqn;
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, " subnqn: \"%s\"\n", subnqn);
SPDK_DEBUGLOG(SPDK_LOG_NVMF, " subnqn: \"%s\"\n", subnqn);
subsystem = spdk_nvmf_tgt_find_subsystem(tgt, subnqn);
if (subsystem == NULL) {
@ -232,7 +232,7 @@ spdk_nvmf_ctrlr_connect(struct spdk_nvmf_request *req)
return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;
}
hostnqn = data->hostnqn;
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, " hostnqn: \"%s\"\n", hostnqn);
SPDK_DEBUGLOG(SPDK_LOG_NVMF, " hostnqn: \"%s\"\n", hostnqn);
if (!spdk_nvmf_subsystem_host_allowed(subsystem, hostnqn)) {
SPDK_ERRLOG("Subsystem '%s' does not allow host '%s'\n", subnqn, hostnqn);
@ -257,7 +257,7 @@ spdk_nvmf_ctrlr_connect(struct spdk_nvmf_request *req)
if (cmd->qid == 0) {
qpair->type = QPAIR_TYPE_AQ;
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "Connect Admin Queue for controller ID 0x%x\n", data->cntlid);
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "Connect Admin Queue for controller ID 0x%x\n", data->cntlid);
if (data->cntlid != 0xFFFF) {
/* This NVMf target only supports dynamic mode. */
@ -275,7 +275,7 @@ spdk_nvmf_ctrlr_connect(struct spdk_nvmf_request *req)
}
} else {
qpair->type = QPAIR_TYPE_IOQ;
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "Connect I/O Queue for controller id 0x%x\n", data->cntlid);
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "Connect I/O Queue for controller id 0x%x\n", data->cntlid);
ctrlr = spdk_nvmf_subsystem_get_ctrlr(subsystem, data->cntlid);
if (ctrlr == NULL) {
@ -330,7 +330,7 @@ spdk_nvmf_ctrlr_connect(struct spdk_nvmf_request *req)
rsp->status.sc = SPDK_NVME_SC_SUCCESS;
rsp->status_code_specific.success.cntlid = ctrlr->cntlid;
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "connect capsule response: cntlid = 0x%04x\n",
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "connect capsule response: cntlid = 0x%04x\n",
rsp->status_code_specific.success.cntlid);
return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;
}
@ -397,8 +397,8 @@ nvmf_prop_set_cc(struct spdk_nvmf_ctrlr *ctrlr, uint64_t value)
cc.raw = (uint32_t)value;
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "cur CC: 0x%08x\n", ctrlr->vcprop.cc.raw);
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "new CC: 0x%08x\n", cc.raw);
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "cur CC: 0x%08x\n", ctrlr->vcprop.cc.raw);
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "new CC: 0x%08x\n", cc.raw);
/*
* Calculate which bits changed between the current and new CC.
@ -408,7 +408,7 @@ nvmf_prop_set_cc(struct spdk_nvmf_ctrlr *ctrlr, uint64_t value)
if (diff.bits.en) {
if (cc.bits.en) {
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "Property Set CC Enable!\n");
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "Property Set CC Enable!\n");
ctrlr->vcprop.cc.bits.en = 1;
ctrlr->vcprop.csts.bits.rdy = 1;
} else {
@ -421,7 +421,7 @@ nvmf_prop_set_cc(struct spdk_nvmf_ctrlr *ctrlr, uint64_t value)
if (diff.bits.shn) {
if (cc.bits.shn == SPDK_NVME_SHN_NORMAL ||
cc.bits.shn == SPDK_NVME_SHN_ABRUPT) {
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "Property Set CC Shutdown %u%ub!\n",
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "Property Set CC Shutdown %u%ub!\n",
cc.bits.shn >> 1, cc.bits.shn & 1);
ctrlr->vcprop.cc.bits.shn = cc.bits.shn;
ctrlr->vcprop.cc.bits.en = 0;
@ -438,14 +438,14 @@ nvmf_prop_set_cc(struct spdk_nvmf_ctrlr *ctrlr, uint64_t value)
}
if (diff.bits.iosqes) {
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "Prop Set IOSQES = %u (%u bytes)\n",
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "Prop Set IOSQES = %u (%u bytes)\n",
cc.bits.iosqes, 1u << cc.bits.iosqes);
ctrlr->vcprop.cc.bits.iosqes = cc.bits.iosqes;
diff.bits.iosqes = 0;
}
if (diff.bits.iocqes) {
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "Prop Set IOCQES = %u (%u bytes)\n",
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "Prop Set IOCQES = %u (%u bytes)\n",
cc.bits.iocqes, 1u << cc.bits.iocqes);
ctrlr->vcprop.cc.bits.iocqes = cc.bits.iocqes;
diff.bits.iocqes = 0;
@ -515,7 +515,7 @@ spdk_nvmf_property_get(struct spdk_nvmf_request *req)
response->status.sc = 0;
response->value.u64 = 0;
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "size %d, offset 0x%x\n",
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "size %d, offset 0x%x\n",
cmd->attrib.size, cmd->ofst);
if (cmd->attrib.size != SPDK_NVMF_PROP_SIZE_4 &&
@ -531,7 +531,7 @@ spdk_nvmf_property_get(struct spdk_nvmf_request *req)
return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;
}
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "name: %s\n", prop->name);
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "name: %s\n", prop->name);
if (cmd->attrib.size != prop->size) {
SPDK_ERRLOG("offset 0x%x size mismatch: cmd %u, prop %u\n",
cmd->ofst, cmd->attrib.size, prop->size);
@ -540,7 +540,7 @@ spdk_nvmf_property_get(struct spdk_nvmf_request *req)
}
response->value.u64 = prop->get_cb(ctrlr);
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "response value: 0x%" PRIx64 "\n", response->value.u64);
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "response value: 0x%" PRIx64 "\n", response->value.u64);
return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;
}
@ -554,7 +554,7 @@ spdk_nvmf_property_set(struct spdk_nvmf_request *req)
const struct nvmf_prop *prop;
uint64_t value;
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "size %d, offset 0x%x, value 0x%" PRIx64 "\n",
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "size %d, offset 0x%x, value 0x%" PRIx64 "\n",
cmd->attrib.size, cmd->ofst, cmd->value.u64);
prop = find_prop(cmd->ofst);
@ -564,7 +564,7 @@ spdk_nvmf_property_set(struct spdk_nvmf_request *req)
return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;
}
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "name: %s\n", prop->name);
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "name: %s\n", prop->name);
if (cmd->attrib.size != prop->size) {
SPDK_ERRLOG("offset 0x%x size mismatch: cmd %u, prop %u\n",
cmd->ofst, cmd->attrib.size, prop->size);
@ -603,7 +603,7 @@ spdk_nvmf_ctrlr_get_features_host_identifier(struct spdk_nvmf_request *req)
struct spdk_nvme_cmd *cmd = &req->cmd->nvme_cmd;
struct spdk_nvme_cpl *response = &req->rsp->nvme_cpl;
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "Get Features - Host Identifier\n");
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "Get Features - Host Identifier\n");
if (!(cmd->cdw11 & 1)) {
/* NVMe over Fabrics requires EXHID=1 (128-bit/16-byte host ID) */
SPDK_ERRLOG("Get Features - Host Identifier with EXHID=0 not allowed\n");
@ -628,7 +628,7 @@ spdk_nvmf_ctrlr_set_features_keep_alive_timer(struct spdk_nvmf_request *req)
struct spdk_nvme_cmd *cmd = &req->cmd->nvme_cmd;
struct spdk_nvme_cpl *rsp = &req->rsp->nvme_cpl;
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "Set Features - Keep Alive Timer (%u ms)\n", cmd->cdw11);
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "Set Features - Keep Alive Timer (%u ms)\n", cmd->cdw11);
if (cmd->cdw11 == 0) {
rsp->status.sc = SPDK_NVME_SC_KEEP_ALIVE_INVALID;
@ -638,7 +638,7 @@ spdk_nvmf_ctrlr_set_features_keep_alive_timer(struct spdk_nvmf_request *req)
ctrlr->kato = cmd->cdw11;
}
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "Set Features - Keep Alive Timer set to %u ms\n", ctrlr->kato);
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "Set Features - Keep Alive Timer set to %u ms\n", ctrlr->kato);
return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;
}
@ -649,7 +649,7 @@ spdk_nvmf_ctrlr_get_features_keep_alive_timer(struct spdk_nvmf_request *req)
struct spdk_nvmf_ctrlr *ctrlr = req->qpair->ctrlr;
struct spdk_nvme_cpl *rsp = &req->rsp->nvme_cpl;
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "Get Features - Keep Alive Timer\n");
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "Get Features - Keep Alive Timer\n");
rsp->cdw0 = ctrlr->kato;
return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;
}
@ -661,7 +661,7 @@ spdk_nvmf_ctrlr_set_features_number_of_queues(struct spdk_nvmf_request *req)
struct spdk_nvme_cpl *rsp = &req->rsp->nvme_cpl;
uint32_t nr_io_queues;
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "Set Features - Number of Queues, cdw11 0x%x\n",
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "Set Features - Number of Queues, cdw11 0x%x\n",
req->cmd->nvme_cmd.cdw11);
/* Extra 1 connection for Admin queue */
@ -669,7 +669,7 @@ spdk_nvmf_ctrlr_set_features_number_of_queues(struct spdk_nvmf_request *req)
/* verify that the contoller is ready to process commands */
if (ctrlr->num_qpairs > 1) {
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "Queue pairs already active!\n");
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "Queue pairs already active!\n");
rsp->status.sc = SPDK_NVME_SC_COMMAND_SEQUENCE_ERROR;
} else {
/* Number of IO queues has a zero based value */
@ -687,7 +687,7 @@ spdk_nvmf_ctrlr_get_features_number_of_queues(struct spdk_nvmf_request *req)
struct spdk_nvme_cpl *rsp = &req->rsp->nvme_cpl;
uint32_t nr_io_queues;
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "Get Features - Number of Queues\n");
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "Get Features - Number of Queues\n");
nr_io_queues = ctrlr->max_qpairs_allowed - 1;
@ -703,7 +703,7 @@ spdk_nvmf_ctrlr_get_features_write_cache(struct spdk_nvmf_request *req)
{
struct spdk_nvme_cpl *rsp = &req->rsp->nvme_cpl;
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "Get Features - Write Cache\n");
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "Get Features - Write Cache\n");
rsp->cdw0 = 1;
return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;
}
@ -714,7 +714,7 @@ spdk_nvmf_ctrlr_set_features_async_event_configuration(struct spdk_nvmf_request
struct spdk_nvmf_ctrlr *ctrlr = req->qpair->ctrlr;
struct spdk_nvme_cmd *cmd = &req->cmd->nvme_cmd;
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "Set Features - Async Event Configuration, cdw11 0x%08x\n",
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "Set Features - Async Event Configuration, cdw11 0x%08x\n",
cmd->cdw11);
ctrlr->async_event_config.raw = cmd->cdw11;
return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;
@ -726,7 +726,7 @@ spdk_nvmf_ctrlr_get_features_async_event_configuration(struct spdk_nvmf_request
struct spdk_nvmf_ctrlr *ctrlr = req->qpair->ctrlr;
struct spdk_nvme_cpl *rsp = &req->rsp->nvme_cpl;
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "Get Features - Async Event Configuration\n");
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "Get Features - Async Event Configuration\n");
rsp->cdw0 = ctrlr->async_event_config.raw;
return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;
}
@ -737,11 +737,11 @@ spdk_nvmf_ctrlr_async_event_request(struct spdk_nvmf_request *req)
struct spdk_nvmf_ctrlr *ctrlr = req->qpair->ctrlr;
struct spdk_nvme_cpl *rsp = &req->rsp->nvme_cpl;
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "Async Event Request\n");
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "Async Event Request\n");
/* Only one asynchronous event is supported for now */
if (ctrlr->aer_req != NULL) {
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "AERL exceeded\n");
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "AERL exceeded\n");
rsp->status.sct = SPDK_NVME_SCT_COMMAND_SPECIFIC;
rsp->status.sc = SPDK_NVME_SC_ASYNC_EVENT_REQUEST_LIMIT_EXCEEDED;
return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;
@ -788,7 +788,7 @@ spdk_nvmf_ctrlr_get_log_page(struct spdk_nvmf_request *req)
}
lid = cmd->cdw10 & 0xFF;
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "Get log page: LID=0x%02X offset=0x%" PRIx64 " len=0x%" PRIx64 "\n",
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "Get log page: LID=0x%02X offset=0x%" PRIx64 " len=0x%" PRIx64 "\n",
lid, offset, len);
if (subsystem->subtype == SPDK_NVMF_SUBTYPE_DISCOVERY) {
@ -858,8 +858,8 @@ spdk_nvmf_ctrlr_identify_ctrlr(struct spdk_nvmf_ctrlr *ctrlr, struct spdk_nvme_c
cdata->sgls.sgl_offset = 1;
spdk_strcpy_pad(cdata->subnqn, subsystem->subnqn, sizeof(cdata->subnqn), '\0');
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "ctrlr data: maxcmd 0x%x\n", cdata->maxcmd);
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "sgls data: 0x%x\n", from_le32(&cdata->sgls));
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "ctrlr data: maxcmd 0x%x\n", cdata->maxcmd);
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "sgls data: 0x%x\n", from_le32(&cdata->sgls));
/*
* NVM subsystem fields (reserved for discovery subsystems)
@ -895,15 +895,15 @@ spdk_nvmf_ctrlr_identify_ctrlr(struct spdk_nvmf_ctrlr *ctrlr, struct spdk_nvme_c
cdata->oncs.dsm = spdk_nvmf_ctrlr_dsm_supported(ctrlr);
cdata->oncs.write_zeroes = spdk_nvmf_ctrlr_write_zeroes_supported(ctrlr);
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "ext ctrlr data: ioccsz 0x%x\n",
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "ext ctrlr data: ioccsz 0x%x\n",
cdata->nvmf_specific.ioccsz);
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "ext ctrlr data: iorcsz 0x%x\n",
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "ext ctrlr data: iorcsz 0x%x\n",
cdata->nvmf_specific.iorcsz);
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "ext ctrlr data: icdoff 0x%x\n",
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "ext ctrlr data: icdoff 0x%x\n",
cdata->nvmf_specific.icdoff);
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "ext ctrlr data: ctrattr 0x%x\n",
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "ext ctrlr data: ctrattr 0x%x\n",
*(uint8_t *)&cdata->nvmf_specific.ctrattr);
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "ext ctrlr data: msdbd 0x%x\n",
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "ext ctrlr data: msdbd 0x%x\n",
cdata->nvmf_specific.msdbd);
}
@ -994,13 +994,13 @@ spdk_nvmf_ctrlr_abort(struct spdk_nvmf_request *req)
struct spdk_nvmf_qpair *qpair;
struct spdk_nvmf_request *req_to_abort;
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "abort sqid=%u cid=%u\n", sqid, cid);
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "abort sqid=%u cid=%u\n", sqid, cid);
rsp->cdw0 = 1; /* Command not aborted */
qpair = spdk_nvmf_ctrlr_get_qpair(ctrlr, sqid);
if (qpair == NULL) {
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "sqid %u not found\n", sqid);
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "sqid %u not found\n", sqid);
rsp->status.sct = SPDK_NVME_SCT_GENERIC;
rsp->status.sc = SPDK_NVME_SC_INVALID_FIELD;
return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;
@ -1013,14 +1013,14 @@ spdk_nvmf_ctrlr_abort(struct spdk_nvmf_request *req)
*/
req_to_abort = spdk_nvmf_qpair_get_request(qpair, cid);
if (req_to_abort == NULL) {
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "cid %u not found\n", cid);
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "cid %u not found\n", cid);
rsp->status.sct = SPDK_NVME_SCT_GENERIC;
rsp->status.sc = SPDK_NVME_SC_INVALID_FIELD;
return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;
}
if (spdk_nvmf_request_abort(req_to_abort) == 0) {
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "abort ctrlr=%p req=%p sqid=%u cid=%u successful\n",
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "abort ctrlr=%p req=%p sqid=%u cid=%u successful\n",
ctrlr, req_to_abort, sqid, cid);
rsp->cdw0 = 0; /* Command successfully aborted */
}
@ -1082,7 +1082,7 @@ spdk_nvmf_ctrlr_set_features(struct spdk_nvmf_request *req)
static int
spdk_nvmf_ctrlr_keep_alive(struct spdk_nvmf_request *req)
{
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "Keep Alive\n");
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "Keep Alive\n");
/*
* To handle keep alive just clear or reset the
* ctrlr based keep alive duration counter.
@ -1163,7 +1163,7 @@ spdk_nvmf_ctrlr_process_fabrics_cmd(struct spdk_nvmf_request *req)
if (cap_hdr->fctype == SPDK_NVMF_FABRIC_COMMAND_CONNECT) {
return spdk_nvmf_ctrlr_connect(req);
} else {
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "Got fctype 0x%x, expected Connect\n",
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "Got fctype 0x%x, expected Connect\n",
cap_hdr->fctype);
req->rsp->nvme_cpl.status.sct = SPDK_NVME_SCT_GENERIC;
req->rsp->nvme_cpl.status.sc = SPDK_NVME_SC_COMMAND_SEQUENCE_ERROR;
@ -1180,7 +1180,7 @@ spdk_nvmf_ctrlr_process_fabrics_cmd(struct spdk_nvmf_request *req)
case SPDK_NVMF_FABRIC_COMMAND_PROPERTY_GET:
return spdk_nvmf_property_get(req);
default:
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "unknown fctype 0x%02x\n",
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "unknown fctype 0x%02x\n",
cap_hdr->fctype);
req->rsp->nvme_cpl.status.sct = SPDK_NVME_SCT_GENERIC;
req->rsp->nvme_cpl.status.sc = SPDK_NVME_SC_INVALID_OPCODE;
@ -1189,7 +1189,7 @@ spdk_nvmf_ctrlr_process_fabrics_cmd(struct spdk_nvmf_request *req)
} else {
/* Controller session is established, and this is an I/O queue */
/* For now, no I/O-specific Fabrics commands are implemented (other than Connect) */
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "Unexpected I/O fctype 0x%x\n", cap_hdr->fctype);
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "Unexpected I/O fctype 0x%x\n", cap_hdr->fctype);
req->rsp->nvme_cpl.status.sct = SPDK_NVME_SCT_GENERIC;
req->rsp->nvme_cpl.status.sc = SPDK_NVME_SC_INVALID_OPCODE;
return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;

4
lib/nvmf/ctrlr_bdev.c
View File

@ -61,7 +61,7 @@ spdk_nvmf_subsystem_bdev_io_type_supported(struct spdk_nvmf_subsystem *subsystem
}
if (!spdk_bdev_io_type_supported(ns->bdev, io_type)) {
SPDK_DEBUGLOG(SPDK_TRACE_NVMF,
SPDK_DEBUGLOG(SPDK_LOG_NVMF,
"Subsystem %s namespace %u (%s) does not support io_type %d\n",
spdk_nvmf_subsystem_get_nqn(subsystem),
ns->id, spdk_bdev_get_name(ns->bdev), (int)io_type);
@ -69,7 +69,7 @@ spdk_nvmf_subsystem_bdev_io_type_supported(struct spdk_nvmf_subsystem *subsystem
}
}
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "All devices in Subsystem %s support io_type %d\n",
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "All devices in Subsystem %s support io_type %d\n",
spdk_nvmf_subsystem_get_nqn(subsystem), (int)io_type);
return true;
}

2
lib/nvmf/ctrlr_discovery.c
View File

@ -58,7 +58,7 @@ nvmf_update_discovery_log(struct spdk_nvmf_tgt *tgt)
size_t cur_size;
uint32_t sid;
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "Generating log page for genctr %" PRIu64 "\n",
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "Generating log page for genctr %" PRIu64 "\n",
tgt->discovery_genctr);
cur_size = sizeof(struct spdk_nvmf_discovery_log_page);

10
lib/nvmf/nvmf.c
View File

@ -44,7 +44,7 @@
#include "nvmf_internal.h"
#include "transport.h"
SPDK_LOG_REGISTER_TRACE_FLAG("nvmf", SPDK_TRACE_NVMF)
SPDK_LOG_REGISTER_COMPONENT("nvmf", SPDK_LOG_NVMF)
#define MAX_SUBSYSTEMS 4
@ -179,12 +179,12 @@ spdk_nvmf_tgt_create(struct spdk_nvmf_tgt_opts *opts)
spdk_nvmf_tgt_destroy_poll_group,
sizeof(struct spdk_nvmf_poll_group));
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "Max Queue Pairs Per Controller: %d\n",
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "Max Queue Pairs Per Controller: %d\n",
tgt->opts.max_qpairs_per_ctrlr);
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "Max Queue Depth: %d\n", tgt->opts.max_queue_depth);
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "Max In Capsule Data: %d bytes\n",
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "Max Queue Depth: %d\n", tgt->opts.max_queue_depth);
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "Max In Capsule Data: %d bytes\n",
tgt->opts.in_capsule_data_size);
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "Max I/O Size: %d bytes\n", tgt->opts.max_io_size);
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "Max I/O Size: %d bytes\n", tgt->opts.max_io_size);
return tgt;
}

50
lib/nvmf/rdma.c
View File

@ -381,7 +381,7 @@ spdk_nvmf_rdma_qpair_initialize(struct spdk_nvmf_qpair *qpair)
return -1;
}
SPDK_DEBUGLOG(SPDK_TRACE_RDMA, "New RDMA Connection: %p\n", qpair);
SPDK_DEBUGLOG(SPDK_LOG_RDMA, "New RDMA Connection: %p\n", qpair);
rqpair->reqs = calloc(rqpair->max_queue_depth, sizeof(*rqpair->reqs));
rqpair->recvs = calloc(rqpair->max_queue_depth, sizeof(*rqpair->recvs));
@ -413,11 +413,11 @@ spdk_nvmf_rdma_qpair_initialize(struct spdk_nvmf_qpair *qpair)
spdk_nvmf_rdma_qpair_destroy(rqpair);
return -1;
}
SPDK_DEBUGLOG(SPDK_TRACE_RDMA, "Command Array: %p Length: %lx LKey: %x\n",
SPDK_DEBUGLOG(SPDK_LOG_RDMA, "Command Array: %p Length: %lx LKey: %x\n",
rqpair->cmds, rqpair->max_queue_depth * sizeof(*rqpair->cmds), rqpair->cmds_mr->lkey);
SPDK_DEBUGLOG(SPDK_TRACE_RDMA, "Completion Array: %p Length: %lx LKey: %x\n",
SPDK_DEBUGLOG(SPDK_LOG_RDMA, "Completion Array: %p Length: %lx LKey: %x\n",
rqpair->cpls, rqpair->max_queue_depth * sizeof(*rqpair->cpls), rqpair->cpls_mr->lkey);
SPDK_DEBUGLOG(SPDK_TRACE_RDMA, "In Capsule Data Array: %p Length: %x LKey: %x\n",
SPDK_DEBUGLOG(SPDK_LOG_RDMA, "In Capsule Data Array: %p Length: %x LKey: %x\n",
rqpair->bufs, rqpair->max_queue_depth * rtransport->in_capsule_data_size, rqpair->bufs_mr->lkey);
for (i = 0; i < rqpair->max_queue_depth; i++) {
@ -498,7 +498,7 @@ request_transfer_in(struct spdk_nvmf_request *req)
rqpair->cur_rdma_rw_depth++;
SPDK_DEBUGLOG(SPDK_TRACE_RDMA, "RDMA READ POSTED. Request: %p Connection: %p\n", req, qpair);
SPDK_DEBUGLOG(SPDK_LOG_RDMA, "RDMA READ POSTED. Request: %p Connection: %p\n", req, qpair);
spdk_trace_record(TRACE_RDMA_READ_START, 0, 0, (uintptr_t)req, 0);
rdma_req->data.wr.opcode = IBV_WR_RDMA_READ;
@ -538,7 +538,7 @@ request_transfer_out(struct spdk_nvmf_request *req)
/* Post the capsule to the recv buffer */
assert(rdma_req->recv != NULL);
SPDK_DEBUGLOG(SPDK_TRACE_RDMA, "RDMA RECV POSTED. Recv: %p Connection: %p\n", rdma_req->recv,
SPDK_DEBUGLOG(SPDK_LOG_RDMA, "RDMA RECV POSTED. Recv: %p Connection: %p\n", rdma_req->recv,
rqpair);
rc = ibv_post_recv(rqpair->cm_id->qp, &rdma_req->recv->wr, &bad_recv_wr);
if (rc) {
@ -555,7 +555,7 @@ request_transfer_out(struct spdk_nvmf_request *req)
if (rsp->status.sc == SPDK_NVME_SC_SUCCESS &&
req->xfer == SPDK_NVME_DATA_CONTROLLER_TO_HOST) {
SPDK_DEBUGLOG(SPDK_TRACE_RDMA, "RDMA WRITE POSTED. Request: %p Connection: %p\n", req, qpair);
SPDK_DEBUGLOG(SPDK_LOG_RDMA, "RDMA WRITE POSTED. Request: %p Connection: %p\n", req, qpair);
spdk_trace_record(TRACE_RDMA_WRITE_START, 0, 0, (uintptr_t)req, 0);
rqpair->cur_rdma_rw_depth++;
@ -565,7 +565,7 @@ request_transfer_out(struct spdk_nvmf_request *req)
send_wr = &rdma_req->data.wr;
}
SPDK_DEBUGLOG(SPDK_TRACE_RDMA, "RDMA SEND POSTED. Request: %p Connection: %p\n", req, qpair);
SPDK_DEBUGLOG(SPDK_LOG_RDMA, "RDMA SEND POSTED. Request: %p Connection: %p\n", req, qpair);
spdk_trace_record(TRACE_NVMF_IO_COMPLETE, 0, 0, (uintptr_t)req, 0);
/* Send the completion */
@ -598,7 +598,7 @@ spdk_nvmf_rdma_event_accept(struct rdma_cm_id *id, struct spdk_nvmf_rdma_qpair *
if (rc) {
SPDK_ERRLOG("Error %d on rdma_accept\n", errno);
} else {
SPDK_DEBUGLOG(SPDK_TRACE_RDMA, "Sent back the accept\n");
SPDK_DEBUGLOG(SPDK_LOG_RDMA, "Sent back the accept\n");
}
return rc;
@ -647,33 +647,33 @@ nvmf_rdma_connect(struct spdk_nvmf_transport *transport, struct rdma_cm_event *e
return -1;
}
SPDK_DEBUGLOG(SPDK_TRACE_RDMA, "Connect Recv on fabric intf name %s, dev_name %s\n",
SPDK_DEBUGLOG(SPDK_LOG_RDMA, "Connect Recv on fabric intf name %s, dev_name %s\n",
event->id->verbs->device->name, event->id->verbs->device->dev_name);
port = event->listen_id->context;
SPDK_DEBUGLOG(SPDK_TRACE_RDMA, "Listen Id was %p with verbs %p. ListenAddr: %p\n",
SPDK_DEBUGLOG(SPDK_LOG_RDMA, "Listen Id was %p with verbs %p. ListenAddr: %p\n",
event->listen_id, event->listen_id->verbs, port);
/* Figure out the supported queue depth. This is a multi-step process
* that takes into account hardware maximums, host provided values,
* and our target's internal memory limits */
SPDK_DEBUGLOG(SPDK_TRACE_RDMA, "Calculating Queue Depth\n");
SPDK_DEBUGLOG(SPDK_LOG_RDMA, "Calculating Queue Depth\n");
/* Start with the maximum queue depth allowed by the target */
max_queue_depth = rtransport->max_queue_depth;
max_rw_depth = rtransport->max_queue_depth;
SPDK_DEBUGLOG(SPDK_TRACE_RDMA, "Target Max Queue Depth: %d\n", rtransport->max_queue_depth);
SPDK_DEBUGLOG(SPDK_LOG_RDMA, "Target Max Queue Depth: %d\n", rtransport->max_queue_depth);
/* Next check the local NIC's hardware limitations */
SPDK_DEBUGLOG(SPDK_TRACE_RDMA,
SPDK_DEBUGLOG(SPDK_LOG_RDMA,
"Local NIC Max Send/Recv Queue Depth: %d Max Read/Write Queue Depth: %d\n",
port->device->attr.max_qp_wr, port->device->attr.max_qp_rd_atom);
max_queue_depth = spdk_min(max_queue_depth, port->device->attr.max_qp_wr);
max_rw_depth = spdk_min(max_rw_depth, port->device->attr.max_qp_rd_atom);
/* Next check the remote NIC's hardware limitations */
SPDK_DEBUGLOG(SPDK_TRACE_RDMA,
SPDK_DEBUGLOG(SPDK_LOG_RDMA,
"Host (Initiator) NIC Max Incoming RDMA R/W operations: %d Max Outgoing RDMA R/W operations: %d\n",
rdma_param->initiator_depth, rdma_param->responder_resources);
if (rdma_param->initiator_depth > 0) {
@ -684,13 +684,13 @@ nvmf_rdma_connect(struct spdk_nvmf_transport *transport, struct rdma_cm_event *e
* optional. */
if (rdma_param->private_data != NULL &&
rdma_param->private_data_len >= sizeof(struct spdk_nvmf_rdma_request_private_data)) {
SPDK_DEBUGLOG(SPDK_TRACE_RDMA, "Host Receive Queue Size: %d\n", private_data->hrqsize);
SPDK_DEBUGLOG(SPDK_TRACE_RDMA, "Host Send Queue Size: %d\n", private_data->hsqsize);
SPDK_DEBUGLOG(SPDK_LOG_RDMA, "Host Receive Queue Size: %d\n", private_data->hrqsize);
SPDK_DEBUGLOG(SPDK_LOG_RDMA, "Host Send Queue Size: %d\n", private_data->hsqsize);
max_queue_depth = spdk_min(max_queue_depth, private_data->hrqsize);
max_queue_depth = spdk_min(max_queue_depth, private_data->hsqsize + 1);
}
SPDK_DEBUGLOG(SPDK_TRACE_RDMA, "Final Negotiated Queue Depth: %d R/W Depth: %d\n",
SPDK_DEBUGLOG(SPDK_LOG_RDMA, "Final Negotiated Queue Depth: %d R/W Depth: %d\n",
max_queue_depth, max_rw_depth);
rqpair = calloc(1, sizeof(struct spdk_nvmf_rdma_qpair));
@ -772,7 +772,7 @@ nvmf_rdma_disconnect(struct rdma_cm_event *evt)
*/
TAILQ_FOREACH_SAFE(r, &g_pending_conns, pending_link, t) {
if (r == rqpair) {
SPDK_DEBUGLOG(SPDK_TRACE_RDMA, "Received disconnect for qpair %p before first SEND ack\n",
SPDK_DEBUGLOG(SPDK_LOG_RDMA, "Received disconnect for qpair %p before first SEND ack\n",
rqpair);
TAILQ_REMOVE(&g_pending_conns, rqpair, pending_link);
break;
@ -932,7 +932,7 @@ spdk_nvmf_rdma_request_parse_sgl(struct spdk_nvmf_rdma_transport *rtransport,
rdma_req->data_from_pool = spdk_mempool_get(rtransport->data_buf_pool);
if (!rdma_req->data_from_pool) {
/* No available buffers. Queue this request up. */
SPDK_DEBUGLOG(SPDK_TRACE_RDMA, "No available large data buffers. Queueing request %p\n", rdma_req);
SPDK_DEBUGLOG(SPDK_LOG_RDMA, "No available large data buffers. Queueing request %p\n", rdma_req);
return 0;
}
/* AIO backend requires block size aligned data buffers,
@ -947,7 +947,7 @@ spdk_nvmf_rdma_request_parse_sgl(struct spdk_nvmf_rdma_transport *rtransport,
rdma_req->data.wr.wr.rdma.rkey = sgl->keyed.key;
rdma_req->data.wr.wr.rdma.remote_addr = sgl->address;
SPDK_DEBUGLOG(SPDK_TRACE_RDMA, "Request %p took buffer from central pool\n", rdma_req);
SPDK_DEBUGLOG(SPDK_LOG_RDMA, "Request %p took buffer from central pool\n", rdma_req);
return 0;
} else if (sgl->generic.type == SPDK_NVME_SGL_TYPE_DATA_BLOCK &&
@ -955,7 +955,7 @@ spdk_nvmf_rdma_request_parse_sgl(struct spdk_nvmf_rdma_transport *rtransport,
uint64_t offset = sgl->address;
uint32_t max_len = rtransport->in_capsule_data_size;
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "In-capsule data: offset 0x%" PRIx64 ", length 0x%x\n",
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "In-capsule data: offset 0x%" PRIx64 ", length 0x%x\n",
offset, sgl->unkeyed.length);
if (offset > max_len) {
@ -1006,7 +1006,7 @@ spdk_nvmf_rdma_request_process(struct spdk_nvmf_rdma_transport *rtransport,
do {
prev_state = rdma_req->state;
SPDK_DEBUGLOG(SPDK_TRACE_RDMA, "Request %p entering state %d\n", rdma_req, prev_state);
SPDK_DEBUGLOG(SPDK_LOG_RDMA, "Request %p entering state %d\n", rdma_req, prev_state);
switch (rdma_req->state) {
case RDMA_REQUEST_STATE_FREE:
@ -1476,7 +1476,7 @@ spdk_nvmf_rdma_accept(struct spdk_nvmf_transport *transport)
while (1) {
rc = rdma_get_cm_event(rtransport->event_channel, &event);
if (rc == 0) {
SPDK_DEBUGLOG(SPDK_TRACE_RDMA, "Acceptor Event: %s\n", CM_EVENT_STR[event->event]);
SPDK_DEBUGLOG(SPDK_LOG_RDMA, "Acceptor Event: %s\n", CM_EVENT_STR[event->event]);
switch (event->event) {
case RDMA_CM_EVENT_CONNECT_REQUEST:
@ -1920,4 +1920,4 @@ const struct spdk_nvmf_transport_ops spdk_nvmf_transport_rdma = {
};
SPDK_LOG_REGISTER_TRACE_FLAG("rdma", SPDK_TRACE_RDMA)
SPDK_LOG_REGISTER_COMPONENT("rdma", SPDK_LOG_RDMA)

16
lib/nvmf/request.c
View File

@ -54,7 +54,7 @@ spdk_nvmf_request_complete_on_qpair(void *ctx)
rsp->status.p = 0;
rsp->cid = req->cmd->nvme_cmd.cid;
SPDK_DEBUGLOG(SPDK_TRACE_NVMF,
SPDK_DEBUGLOG(SPDK_LOG_NVMF,
"cpl: cid=%u cdw0=0x%08x rsvd1=%u status=0x%04x\n",
rsp->cid, rsp->cdw0, rsp->rsvd1,
*(uint16_t *)&rsp->status);
@ -96,35 +96,35 @@ nvmf_trace_command(union nvmf_h2c_msg *h2c_msg, enum spdk_nvmf_qpair_type qpair_
if (cmd->opc == SPDK_NVME_OPC_FABRIC) {
opc = cap_hdr->fctype;
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "%s Fabrics cmd: fctype 0x%02x cid %u\n",
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "%s Fabrics cmd: fctype 0x%02x cid %u\n",
qpair_type == QPAIR_TYPE_AQ ? "Admin" : "I/O",
cap_hdr->fctype, cap_hdr->cid);
} else {
opc = cmd->opc;
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "%s cmd: opc 0x%02x fuse %u cid %u nsid %u cdw10 0x%08x\n",
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "%s cmd: opc 0x%02x fuse %u cid %u nsid %u cdw10 0x%08x\n",
qpair_type == QPAIR_TYPE_AQ ? "Admin" : "I/O",
cmd->opc, cmd->fuse, cmd->cid, cmd->nsid, cmd->cdw10);
if (cmd->mptr) {
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "mptr 0x%" PRIx64 "\n", cmd->mptr);
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "mptr 0x%" PRIx64 "\n", cmd->mptr);
}
if (cmd->psdt != SPDK_NVME_PSDT_SGL_MPTR_CONTIG &&
cmd->psdt != SPDK_NVME_PSDT_SGL_MPTR_SGL) {
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "psdt %u\n", cmd->psdt);
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "psdt %u\n", cmd->psdt);
}
}
if (spdk_nvme_opc_get_data_transfer(opc) != SPDK_NVME_DATA_NONE) {
if (sgl->generic.type == SPDK_NVME_SGL_TYPE_KEYED_DATA_BLOCK) {
SPDK_DEBUGLOG(SPDK_TRACE_NVMF,
SPDK_DEBUGLOG(SPDK_LOG_NVMF,
"SGL: Keyed%s: addr 0x%" PRIx64 " key 0x%x len 0x%x\n",
sgl->generic.subtype == SPDK_NVME_SGL_SUBTYPE_INVALIDATE_KEY ? " (Inv)" : "",
sgl->address, sgl->keyed.key, sgl->keyed.length);
} else if (sgl->generic.type == SPDK_NVME_SGL_TYPE_DATA_BLOCK) {
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "SGL: Data block: %s 0x%" PRIx64 " len 0x%x\n",
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "SGL: Data block: %s 0x%" PRIx64 " len 0x%x\n",
sgl->unkeyed.subtype == SPDK_NVME_SGL_SUBTYPE_OFFSET ? "offs" : "addr",
sgl->address, sgl->unkeyed.length);
} else {
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "SGL type 0x%x subtype 0x%x\n",
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "SGL type 0x%x subtype 0x%x\n",
sgl->generic.type, sgl->generic.subtype);
}
}

6
lib/nvmf/subsystem.c
View File

@ -204,7 +204,7 @@ spdk_nvmf_delete_subsystem(struct spdk_nvmf_subsystem *subsystem)
return;
}
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "subsystem is %p\n", subsystem);
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "subsystem is %p\n", subsystem);
TAILQ_FOREACH_SAFE(listener, &subsystem->listeners, link, listener_tmp) {
TAILQ_REMOVE(&subsystem->listeners, listener, link);
@ -479,7 +479,7 @@ spdk_nvmf_subsystem_add_ns(struct spdk_nvmf_subsystem *subsystem, struct spdk_bd
}
ns->allocated = true;
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "Subsystem %s: bdev %s assigned nsid %" PRIu32 "\n",
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "Subsystem %s: bdev %s assigned nsid %" PRIu32 "\n",
spdk_nvmf_subsystem_get_nqn(subsystem),
spdk_bdev_get_name(bdev),
nsid);
@ -578,7 +578,7 @@ spdk_nvmf_subsystem_set_sn(struct spdk_nvmf_subsystem *subsystem, const char *sn
max_len = sizeof(subsystem->sn) - 1;
len = strlen(sn);
if (len > max_len) {
SPDK_DEBUGLOG(SPDK_TRACE_NVMF, "Invalid sn \"%s\": length %zu > max %zu\n",
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "Invalid sn \"%s\": length %zu > max %zu\n",
sn, len, max_len);
return -1;
}

2
lib/scsi/scsi.c
View File

@ -66,4 +66,4 @@ SPDK_TRACE_REGISTER_FN(scsi_trace)
OWNER_SCSI_DEV, OBJECT_SCSI_TASK, 0, 0, 0, "");
}
SPDK_LOG_REGISTER_TRACE_FLAG("scsi", SPDK_TRACE_SCSI)
SPDK_LOG_REGISTER_COMPONENT("scsi", SPDK_LOG_SCSI)

48
lib/scsi/scsi_bdev.c
View File

@ -656,7 +656,7 @@ spdk_bdev_scsi_inquiry(struct spdk_bdev *bdev, struct spdk_scsi_task *task,
default:
if (pc >= 0xc0 && pc <= 0xff) {
SPDK_DEBUGLOG(SPDK_TRACE_SCSI, "Vendor specific INQUIRY VPD page 0x%x\n", pc);
SPDK_DEBUGLOG(SPDK_LOG_SCSI, "Vendor specific INQUIRY VPD page 0x%x\n", pc);
} else {
SPDK_ERRLOG("unsupported INQUIRY VPD page 0x%x\n", pc);
}
@ -830,7 +830,7 @@ spdk_bdev_scsi_mode_sense_page(struct spdk_bdev *bdev,
break;
case 0x01:
/* Read-Write Error Recovery */
SPDK_DEBUGLOG(SPDK_TRACE_SCSI,
SPDK_DEBUGLOG(SPDK_LOG_SCSI,
"MODE_SENSE Read-Write Error Recovery\n");
if (subpage != 0x00)
break;
@ -840,7 +840,7 @@ spdk_bdev_scsi_mode_sense_page(struct spdk_bdev *bdev,
break;
case 0x02:
/* Disconnect-Reconnect */
SPDK_DEBUGLOG(SPDK_TRACE_SCSI,
SPDK_DEBUGLOG(SPDK_LOG_SCSI,
"MODE_SENSE Disconnect-Reconnect\n");
if (subpage != 0x00)
break;
@ -862,7 +862,7 @@ spdk_bdev_scsi_mode_sense_page(struct spdk_bdev *bdev,
break;
case 0x07:
/* Verify Error Recovery */
SPDK_DEBUGLOG(SPDK_TRACE_SCSI,
SPDK_DEBUGLOG(SPDK_LOG_SCSI,
"MODE_SENSE Verify Error Recovery\n");
if (subpage != 0x00)
@ -874,7 +874,7 @@ spdk_bdev_scsi_mode_sense_page(struct spdk_bdev *bdev,
break;
case 0x08: {
/* Caching */
SPDK_DEBUGLOG(SPDK_TRACE_SCSI, "MODE_SENSE Caching\n");
SPDK_DEBUGLOG(SPDK_LOG_SCSI, "MODE_SENSE Caching\n");
if (subpage != 0x00)
break;
@ -898,7 +898,7 @@ spdk_bdev_scsi_mode_sense_page(struct spdk_bdev *bdev,
switch (subpage) {
case 0x00:
/* Control */
SPDK_DEBUGLOG(SPDK_TRACE_SCSI,
SPDK_DEBUGLOG(SPDK_LOG_SCSI,
"MODE_SENSE Control\n");
plen = 0x0a + 2;
mode_sense_page_init(cp, plen, page, subpage);
@ -906,7 +906,7 @@ spdk_bdev_scsi_mode_sense_page(struct spdk_bdev *bdev,
break;
case 0x01:
/* Control Extension */
SPDK_DEBUGLOG(SPDK_TRACE_SCSI,
SPDK_DEBUGLOG(SPDK_LOG_SCSI,
"MODE_SENSE Control Extension\n");
plen = 0x1c + 4;
mode_sense_page_init(cp, plen, page, subpage);
@ -943,7 +943,7 @@ spdk_bdev_scsi_mode_sense_page(struct spdk_bdev *bdev,
break;
case 0x10:
/* XOR Control */
SPDK_DEBUGLOG(SPDK_TRACE_SCSI, "MODE_SENSE XOR Control\n");
SPDK_DEBUGLOG(SPDK_LOG_SCSI, "MODE_SENSE XOR Control\n");
if (subpage != 0x00)
break;
plen = 0x16 + 2;
@ -971,7 +971,7 @@ spdk_bdev_scsi_mode_sense_page(struct spdk_bdev *bdev,
break;
case 0x1a:
/* Power Condition */
SPDK_DEBUGLOG(SPDK_TRACE_SCSI,
SPDK_DEBUGLOG(SPDK_LOG_SCSI,
"MODE_SENSE Power Condition\n");
if (subpage != 0x00)
break;
@ -984,7 +984,7 @@ spdk_bdev_scsi_mode_sense_page(struct spdk_bdev *bdev,
break;
case 0x1c:
/* Informational Exceptions Control */
SPDK_DEBUGLOG(SPDK_TRACE_SCSI,
SPDK_DEBUGLOG(SPDK_LOG_SCSI,
"MODE_SENSE Informational Exceptions Control\n");
if (subpage != 0x00)
break;
@ -1184,7 +1184,7 @@ spdk_bdev_scsi_mode_select_page(struct spdk_bdev *bdev,
case 0x08: { /* Caching */
//int wce;
SPDK_DEBUGLOG(SPDK_TRACE_SCSI, "MODE_SELECT Caching\n");
SPDK_DEBUGLOG(SPDK_LOG_SCSI, "MODE_SELECT Caching\n");
if (subpage != 0x00)
break;
@ -1201,7 +1201,7 @@ spdk_bdev_scsi_mode_select_page(struct spdk_bdev *bdev,
//rc = fcntl(fd, F_GETFL, 0);
//if (rc != -1) {
// if (wce) {
// SPDK_DEBUGLOG(SPDK_TRACE_SCSI, "MODE_SELECT Writeback cache enable\n");
// SPDK_DEBUGLOG(SPDK_LOG_SCSI, "MODE_SELECT Writeback cache enable\n");
// rc = fcntl(fd, F_SETFL, (rc & ~O_FSYNC));
// bdev->write_cache = 1;
// } else {
@ -1269,7 +1269,7 @@ spdk_bdev_scsi_read_write_lba_check(struct spdk_scsi_task *primary,
*/
if (lba >= bdev_num_blocks || cmd_num_blocks > bdev_num_blocks ||
lba > (bdev_num_blocks - cmd_num_blocks)) {
SPDK_DEBUGLOG(SPDK_TRACE_SCSI, "end of media\n");
SPDK_DEBUGLOG(SPDK_LOG_SCSI, "end of media\n");
spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION,
SPDK_SCSI_SENSE_ILLEGAL_REQUEST,
SPDK_SCSI_ASC_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE,
@ -1309,7 +1309,7 @@ spdk_bdev_scsi_read(struct spdk_bdev *bdev,
offset = lba * blen;
nbytes = task->length;
SPDK_DEBUGLOG(SPDK_TRACE_SCSI,
SPDK_DEBUGLOG(SPDK_LOG_SCSI,
"Read: lba=%"PRIu64", len=%"PRIu64"\n",
lba, (uint64_t)task->length / blen);
@ -1345,7 +1345,7 @@ spdk_bdev_scsi_write(struct spdk_bdev *bdev,
offset = lba * blen;
nbytes = ((uint64_t)len) * blen;
SPDK_DEBUGLOG(SPDK_TRACE_SCSI,
SPDK_DEBUGLOG(SPDK_LOG_SCSI,
"Write: lba=%"PRIu64", len=%u\n",
lba, len);
@ -1380,7 +1380,7 @@ spdk_bdev_scsi_write(struct spdk_bdev *bdev,
}
}
SPDK_DEBUGLOG(SPDK_TRACE_SCSI, "Wrote %"PRIu64"/%"PRIu64" bytes\n",
SPDK_DEBUGLOG(SPDK_LOG_SCSI, "Wrote %"PRIu64"/%"PRIu64" bytes\n",
(uint64_t)task->length, nbytes);
task->status = SPDK_SCSI_STATUS_GOOD;
@ -1794,14 +1794,14 @@ spdk_bdev_scsi_process_primary(struct spdk_bdev *bdev,
break;
}
SPDK_TRACEDUMP(SPDK_TRACE_SCSI, "INQUIRY", data, data_len);
SPDK_TRACEDUMP(SPDK_LOG_SCSI, "INQUIRY", data, data_len);
break;
case SPDK_SPC_REPORT_LUNS: {
int sel;
sel = cdb[2];
SPDK_DEBUGLOG(SPDK_TRACE_SCSI, "sel=%x\n", sel);
SPDK_DEBUGLOG(SPDK_LOG_SCSI, "sel=%x\n", sel);
alloc_len = from_be32(&cdb[6]);
rc = spdk_bdev_scsi_check_len(task, alloc_len, 16);
@ -1822,7 +1822,7 @@ spdk_bdev_scsi_process_primary(struct spdk_bdev *bdev,
break;
}
SPDK_TRACEDUMP(SPDK_TRACE_SCSI, "REPORT LUNS", data, data_len);
SPDK_TRACEDUMP(SPDK_LOG_SCSI, "REPORT LUNS", data, data_len);
break;
}
@ -1967,12 +1967,12 @@ spdk_bdev_scsi_process_primary(struct spdk_bdev *bdev,
}
case SPDK_SPC_LOG_SELECT:
SPDK_DEBUGLOG(SPDK_TRACE_SCSI, "LOG_SELECT\n");
SPDK_DEBUGLOG(SPDK_LOG_SCSI, "LOG_SELECT\n");
cmd_parsed = 1;
/* FALLTHROUGH */
case SPDK_SPC_LOG_SENSE:
if (!cmd_parsed) {
SPDK_DEBUGLOG(SPDK_TRACE_SCSI, "LOG_SENSE\n");
SPDK_DEBUGLOG(SPDK_LOG_SCSI, "LOG_SENSE\n");
}
/* INVALID COMMAND OPERATION CODE */
@ -1984,12 +1984,12 @@ spdk_bdev_scsi_process_primary(struct spdk_bdev *bdev,
break;
case SPDK_SPC_TEST_UNIT_READY:
SPDK_DEBUGLOG(SPDK_TRACE_SCSI, "TEST_UNIT_READY\n");
SPDK_DEBUGLOG(SPDK_LOG_SCSI, "TEST_UNIT_READY\n");
cmd_parsed = 1;
/* FALLTHROUGH */
case SPDK_SBC_START_STOP_UNIT:
if (!cmd_parsed) {
SPDK_DEBUGLOG(SPDK_TRACE_SCSI, "START_STOP_UNIT\n");
SPDK_DEBUGLOG(SPDK_LOG_SCSI, "START_STOP_UNIT\n");
}
rc = 0;
@ -2023,7 +2023,7 @@ spdk_bdev_scsi_execute(struct spdk_bdev *bdev, struct spdk_scsi_task *task)
if ((rc = spdk_bdev_scsi_process_block(bdev, task)) == SPDK_SCSI_TASK_UNKNOWN) {
if ((rc = spdk_bdev_scsi_process_primary(bdev, task)) == SPDK_SCSI_TASK_UNKNOWN) {
SPDK_DEBUGLOG(SPDK_TRACE_SCSI, "unsupported SCSI OP=0x%x\n", task->cdb[0]);
SPDK_DEBUGLOG(SPDK_LOG_SCSI, "unsupported SCSI OP=0x%x\n", task->cdb[0]);
/* INVALID COMMAND OPERATION CODE */
spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION,
SPDK_SCSI_SENSE_ILLEGAL_REQUEST,

8
lib/vhost/vhost.c
View File

@ -109,7 +109,7 @@ spdk_vhost_vq_avail_ring_get(struct spdk_vhost_virtqueue *virtqueue, uint16_t *r
reqs[i] = vring->avail->ring[(last_idx + i) & size_mask];
}
SPDK_DEBUGLOG(SPDK_TRACE_VHOST_RING,
SPDK_DEBUGLOG(SPDK_LOG_VHOST_RING,
"AVAIL: last_idx=%"PRIu16" avail_idx=%"PRIu16" count=%"PRIu16"\n",
last_idx, avail_idx, count);
@ -161,7 +161,7 @@ spdk_vhost_vq_used_signal(struct spdk_vhost_dev *vdev, struct spdk_vhost_virtque
virtqueue->req_cnt += virtqueue->used_req_cnt;
virtqueue->used_req_cnt = 0;
SPDK_DEBUGLOG(SPDK_TRACE_VHOST_RING,
SPDK_DEBUGLOG(SPDK_LOG_VHOST_RING,
"Queue %td - USED RING: sending IRQ: last used %"PRIu16"\n",
virtqueue - vdev->virtqueue, virtqueue->vring.last_used_idx);
@ -273,7 +273,7 @@ spdk_vhost_vq_used_ring_enqueue(struct spdk_vhost_dev *vdev, struct spdk_vhost_v
struct vring_used *used = vring->used;
uint16_t last_idx = vring->last_used_idx & (vring->size - 1);
SPDK_DEBUGLOG(SPDK_TRACE_VHOST_RING,
SPDK_DEBUGLOG(SPDK_LOG_VHOST_RING,
"Queue %td - USED RING: last_idx=%"PRIu16" req id=%"PRIu16" len=%"PRIu32"\n",
virtqueue - vdev->virtqueue, vring->last_used_idx, id, len);
@ -1177,4 +1177,4 @@ spdk_vhost_fini(void)
{
}
SPDK_LOG_REGISTER_TRACE_FLAG("vhost_ring", SPDK_TRACE_VHOST_RING)
SPDK_LOG_REGISTER_COMPONENT("vhost_ring", SPDK_LOG_VHOST_RING)

30
lib/vhost/vhost_blk.c
View File

@ -87,7 +87,7 @@ invalid_blk_request(struct spdk_vhost_blk_task *task, uint8_t status)
spdk_vhost_vq_used_ring_enqueue(&task->bvdev->vdev, task->vq, task->req_idx, 0);
blk_task_finish(task);
SPDK_DEBUGLOG(SPDK_TRACE_VHOST_BLK_DATA, "Invalid request (status=%" PRIu8")\n", status);
SPDK_DEBUGLOG(SPDK_LOG_VHOST_BLK_DATA, "Invalid request (status=%" PRIu8")\n", status);
}
/*
@ -118,13 +118,13 @@ blk_iovs_setup(struct spdk_vhost_dev *vdev, struct spdk_vhost_virtqueue *vq, uin
* Should not happen if request is well formatted, otherwise this is a BUG.
*/
if (spdk_unlikely(cnt == *iovs_cnt)) {
SPDK_DEBUGLOG(SPDK_TRACE_VHOST_BLK, "Max IOVs in request reached (req_idx = %"PRIu16").\n",
SPDK_DEBUGLOG(SPDK_LOG_VHOST_BLK, "Max IOVs in request reached (req_idx = %"PRIu16").\n",
req_idx);
return -1;
}
if (spdk_unlikely(spdk_vhost_vring_desc_to_iov(vdev, iovs, &cnt, desc))) {
SPDK_DEBUGLOG(SPDK_TRACE_VHOST_BLK, "Invalid descriptor %" PRIu16" (req_idx = %"PRIu16").\n",
SPDK_DEBUGLOG(SPDK_LOG_VHOST_BLK, "Invalid descriptor %" PRIu16" (req_idx = %"PRIu16").\n",
req_idx, cnt);
return -1;
}
@ -163,7 +163,7 @@ blk_request_finish(bool success, struct spdk_vhost_blk_task *task)
*task->status = success ? VIRTIO_BLK_S_OK : VIRTIO_BLK_S_IOERR;
spdk_vhost_vq_used_ring_enqueue(&task->bvdev->vdev, task->vq, task->req_idx,
task->length);
SPDK_DEBUGLOG(SPDK_TRACE_VHOST_BLK, "Finished task (%p) req_idx=%d\n status: %s\n", task,
SPDK_DEBUGLOG(SPDK_LOG_VHOST_BLK, "Finished task (%p) req_idx=%d\n status: %s\n", task,
task->req_idx, success ? "OK" : "FAIL");
blk_task_finish(task);
}
@ -187,7 +187,7 @@ process_blk_request(struct spdk_vhost_blk_task *task, struct spdk_vhost_blk_dev
int rc;
if (blk_iovs_setup(&bvdev->vdev, vq, task->req_idx, task->iovs, &task->iovcnt, &task->length)) {
SPDK_DEBUGLOG(SPDK_TRACE_VHOST_BLK, "Invalid request (req_idx = %"PRIu16").\n", task->req_idx);
SPDK_DEBUGLOG(SPDK_LOG_VHOST_BLK, "Invalid request (req_idx = %"PRIu16").\n", task->req_idx);
/* Only READ and WRITE are supported for now. */
invalid_blk_request(task, VIRTIO_BLK_S_UNSUPP);
return -1;
@ -195,7 +195,7 @@ process_blk_request(struct spdk_vhost_blk_task *task, struct spdk_vhost_blk_dev
iov = &task->iovs[0];
if (spdk_unlikely(iov->iov_len != sizeof(*req))) {
SPDK_DEBUGLOG(SPDK_TRACE_VHOST_BLK,
SPDK_DEBUGLOG(SPDK_LOG_VHOST_BLK,
"First descriptor size is %zu but expected %zu (req_idx = %"PRIu16").\n",
iov->iov_len, sizeof(*req), task->req_idx);
invalid_blk_request(task, VIRTIO_BLK_S_UNSUPP);
@ -206,7 +206,7 @@ process_blk_request(struct spdk_vhost_blk_task *task, struct spdk_vhost_blk_dev
iov = &task->iovs[task->iovcnt - 1];
if (spdk_unlikely(iov->iov_len != 1)) {
SPDK_DEBUGLOG(SPDK_TRACE_VHOST_BLK,
SPDK_DEBUGLOG(SPDK_LOG_VHOST_BLK,
"Last descriptor size is %zu but expected %d (req_idx = %"PRIu16").\n",
iov->iov_len, 1, task->req_idx);
invalid_blk_request(task, VIRTIO_BLK_S_UNSUPP);
@ -242,7 +242,7 @@ process_blk_request(struct spdk_vhost_blk_task *task, struct spdk_vhost_blk_dev
&task->iovs[1], task->iovcnt, req->sector * 512,
task->length, blk_request_complete_cb, task);
} else {
SPDK_DEBUGLOG(SPDK_TRACE_VHOST_BLK, "Device is in read-only mode!\n");
SPDK_DEBUGLOG(SPDK_LOG_VHOST_BLK, "Device is in read-only mode!\n");
rc = -1;
}
@ -261,7 +261,7 @@ process_blk_request(struct spdk_vhost_blk_task *task, struct spdk_vhost_blk_dev
blk_request_finish(true, task);
break;
default:
SPDK_DEBUGLOG(SPDK_TRACE_VHOST_BLK, "Not supported request type '%"PRIu32"'.\n", type);
SPDK_DEBUGLOG(SPDK_LOG_VHOST_BLK, "Not supported request type '%"PRIu32"'.\n", type);
invalid_blk_request(task, VIRTIO_BLK_S_UNSUPP);
return -1;
}
@ -283,7 +283,7 @@ process_vq(struct spdk_vhost_blk_dev *bvdev, struct spdk_vhost_virtqueue *vq)
}
for (i = 0; i < reqs_cnt; i++) {
SPDK_DEBUGLOG(SPDK_TRACE_VHOST_BLK, "====== Starting processing request idx %"PRIu16"======\n",
SPDK_DEBUGLOG(SPDK_LOG_VHOST_BLK, "====== Starting processing request idx %"PRIu16"======\n",
reqs[i]);
if (spdk_unlikely(reqs[i] >= vq->vring.size)) {
@ -309,10 +309,10 @@ process_vq(struct spdk_vhost_blk_dev *bvdev, struct spdk_vhost_virtqueue *vq)
rc = process_blk_request(task, bvdev, vq);
if (rc == 0) {
SPDK_DEBUGLOG(SPDK_TRACE_VHOST_BLK, "====== Task %p req_idx %d submitted ======\n", task,
SPDK_DEBUGLOG(SPDK_LOG_VHOST_BLK, "====== Task %p req_idx %d submitted ======\n", task,
reqs[i]);
} else {
SPDK_DEBUGLOG(SPDK_TRACE_VHOST_BLK, "====== Task %p req_idx %d failed ======\n", task, reqs[i]);
SPDK_DEBUGLOG(SPDK_LOG_VHOST_BLK, "====== Task %p req_idx %d failed ======\n", task, reqs[i]);
}
}
}
@ -344,7 +344,7 @@ no_bdev_process_vq(struct spdk_vhost_blk_dev *bvdev, struct spdk_vhost_virtqueue
iovcnt = SPDK_COUNTOF(iovs);
if (blk_iovs_setup(&bvdev->vdev, vq, req_idx, iovs, &iovcnt, &length) == 0) {
*(volatile uint8_t *)iovs[iovcnt - 1].iov_base = VIRTIO_BLK_S_IOERR;
SPDK_DEBUGLOG(SPDK_TRACE_VHOST_BLK_DATA, "Aborting request %" PRIu16"\n", req_idx);
SPDK_DEBUGLOG(SPDK_LOG_VHOST_BLK_DATA, "Aborting request %" PRIu16"\n", req_idx);
}
spdk_vhost_vq_used_ring_enqueue(&bvdev->vdev, vq, req_idx, 0);
@ -745,5 +745,5 @@ spdk_vhost_blk_destroy(struct spdk_vhost_dev *vdev)
return 0;
}
SPDK_LOG_REGISTER_TRACE_FLAG("vhost_blk", SPDK_TRACE_VHOST_BLK)
SPDK_LOG_REGISTER_TRACE_FLAG("vhost_blk_data", SPDK_TRACE_VHOST_BLK_DATA)
SPDK_LOG_REGISTER_COMPONENT("vhost_blk", SPDK_LOG_VHOST_BLK)
SPDK_LOG_REGISTER_COMPONENT("vhost_blk_data", SPDK_LOG_VHOST_BLK_DATA)

14
lib/vhost/vhost_rpc.c
View File

@ -73,7 +73,7 @@ spdk_rpc_construct_vhost_scsi_controller(struct spdk_jsonrpc_request *request,
if (spdk_json_decode_object(params, rpc_construct_vhost_ctrlr,
SPDK_COUNTOF(rpc_construct_vhost_ctrlr),
&req)) {
SPDK_DEBUGLOG(SPDK_TRACE_VHOST_RPC, "spdk_json_decode_object failed\n");
SPDK_DEBUGLOG(SPDK_LOG_VHOST_RPC, "spdk_json_decode_object failed\n");
rc = -EINVAL;
goto invalid;
}
@ -178,7 +178,7 @@ spdk_rpc_add_vhost_scsi_lun(struct spdk_jsonrpc_request *request,
if (spdk_json_decode_object(params, rpc_vhost_add_lun,
SPDK_COUNTOF(rpc_vhost_add_lun),
req)) {
SPDK_DEBUGLOG(SPDK_TRACE_VHOST_RPC, "spdk_json_decode_object failed\n");
SPDK_DEBUGLOG(SPDK_LOG_VHOST_RPC, "spdk_json_decode_object failed\n");
rc = -EINVAL;
goto invalid;
}
@ -286,7 +286,7 @@ spdk_rpc_remove_vhost_scsi_dev(struct spdk_jsonrpc_request *request,
if (spdk_json_decode_object(params, rpc_vhost_remove_dev,
SPDK_COUNTOF(rpc_vhost_remove_dev),
req)) {
SPDK_DEBUGLOG(SPDK_TRACE_VHOST_RPC, "spdk_json_decode_object failed\n");
SPDK_DEBUGLOG(SPDK_LOG_VHOST_RPC, "spdk_json_decode_object failed\n");
rc = -EINVAL;
goto invalid;
}
@ -339,7 +339,7 @@ spdk_rpc_construct_vhost_blk_controller(struct spdk_jsonrpc_request *request,
if (spdk_json_decode_object(params, rpc_construct_vhost_blk_ctrlr,
SPDK_COUNTOF(rpc_construct_vhost_blk_ctrlr),
&req)) {
SPDK_DEBUGLOG(SPDK_TRACE_VHOST_RPC, "spdk_json_decode_object failed\n");
SPDK_DEBUGLOG(SPDK_LOG_VHOST_RPC, "spdk_json_decode_object failed\n");
rc = -EINVAL;
goto invalid;
}
@ -441,7 +441,7 @@ spdk_rpc_remove_vhost_controller(struct spdk_jsonrpc_request *request,
req->request = request;
if (spdk_json_decode_object(params, rpc_remove_vhost_ctrlr,
SPDK_COUNTOF(rpc_remove_vhost_ctrlr), req)) {
SPDK_DEBUGLOG(SPDK_TRACE_VHOST_RPC, "spdk_json_decode_object failed\n");
SPDK_DEBUGLOG(SPDK_LOG_VHOST_RPC, "spdk_json_decode_object failed\n");
rc = -EINVAL;
goto invalid;
}
@ -606,7 +606,7 @@ spdk_rpc_set_vhost_controller_coalescing(struct spdk_jsonrpc_request *request,
if (spdk_json_decode_object(params, rpc_set_vhost_ctrlr_coalescing,
SPDK_COUNTOF(rpc_set_vhost_ctrlr_coalescing), req)) {
SPDK_DEBUGLOG(SPDK_TRACE_VHOST_RPC, "spdk_json_decode_object failed\n");
SPDK_DEBUGLOG(SPDK_LOG_VHOST_RPC, "spdk_json_decode_object failed\n");
rc = -EINVAL;
goto invalid;
}
@ -623,4 +623,4 @@ invalid:
SPDK_RPC_REGISTER("set_vhost_controller_coalescing", spdk_rpc_set_vhost_controller_coalescing)
SPDK_LOG_REGISTER_TRACE_FLAG("vhost_rpc", SPDK_TRACE_VHOST_RPC)
SPDK_LOG_REGISTER_COMPONENT("vhost_rpc", SPDK_LOG_VHOST_RPC)

40
lib/vhost/vhost_scsi.c
View File

@ -213,7 +213,7 @@ submit_completion(struct spdk_vhost_scsi_task *task)
{
spdk_vhost_vq_used_ring_enqueue(&task->svdev->vdev, task->vq, task->req_idx,
task->scsi.data_transferred);
SPDK_DEBUGLOG(SPDK_TRACE_VHOST_SCSI, "Finished task (%p) req_idx=%d\n", task, task->req_idx);
SPDK_DEBUGLOG(SPDK_LOG_VHOST_SCSI, "Finished task (%p) req_idx=%d\n", task, task->req_idx);
spdk_vhost_scsi_task_put(task);
}
@ -265,7 +265,7 @@ invalid_request(struct spdk_vhost_scsi_task *task)
spdk_vhost_vq_used_ring_enqueue(&task->svdev->vdev, task->vq, task->req_idx, 0);
spdk_vhost_scsi_task_put(task);
SPDK_DEBUGLOG(SPDK_TRACE_VHOST_SCSI, "Invalid request (status=%" PRIu8")\n",
SPDK_DEBUGLOG(SPDK_LOG_VHOST_SCSI, "Invalid request (status=%" PRIu8")\n",
task->resp ? task->resp->response : -1);
}
@ -275,7 +275,7 @@ spdk_vhost_scsi_task_init_target(struct spdk_vhost_scsi_task *task, const __u8 *
struct spdk_scsi_dev *dev;
uint16_t lun_id = (((uint16_t)lun[2] << 8) | lun[3]) & 0x3FFF;
SPDK_TRACEDUMP(SPDK_TRACE_VHOST_SCSI_QUEUE, "LUN", lun, 8);
SPDK_TRACEDUMP(SPDK_LOG_VHOST_SCSI_QUEUE, "LUN", lun, 8);
/* First byte must be 1 and second is target */
if (lun[0] != 1 || lun[1] >= SPDK_VHOST_SCSI_CTRLR_MAX_DEVS)
@ -316,11 +316,11 @@ process_ctrl_request(struct spdk_vhost_scsi_task *task)
ctrl_req = spdk_vhost_gpa_to_vva(vdev, desc->addr);
SPDK_DEBUGLOG(SPDK_TRACE_VHOST_SCSI_QUEUE,
SPDK_DEBUGLOG(SPDK_LOG_VHOST_SCSI_QUEUE,
"Processing controlq descriptor: desc %d/%p, desc_addr %p, len %d, flags %d, last_used_idx %d; kickfd %d; size %d\n",
task->req_idx, desc, (void *)desc->addr, desc->len, desc->flags, task->vq->vring.last_used_idx,
task->vq->vring.kickfd, task->vq->vring.size);
SPDK_TRACEDUMP(SPDK_TRACE_VHOST_SCSI_QUEUE, "Request descriptor", (uint8_t *)ctrl_req,
SPDK_TRACEDUMP(SPDK_LOG_VHOST_SCSI_QUEUE, "Request descriptor", (uint8_t *)ctrl_req,
desc->len);
spdk_vhost_scsi_task_init_target(task, ctrl_req->lun);
@ -351,14 +351,14 @@ process_ctrl_request(struct spdk_vhost_scsi_task *task)
switch (ctrl_req->subtype) {
case VIRTIO_SCSI_T_TMF_LOGICAL_UNIT_RESET:
/* Handle LUN reset */
SPDK_DEBUGLOG(SPDK_TRACE_VHOST_SCSI_QUEUE, "LUN reset\n");
SPDK_DEBUGLOG(SPDK_LOG_VHOST_SCSI_QUEUE, "LUN reset\n");
mgmt_task_submit(task, SPDK_SCSI_TASK_FUNC_LUN_RESET);
return;
default:
task->tmf_resp->response = VIRTIO_SCSI_S_ABORTED;
/* Unsupported command */
SPDK_DEBUGLOG(SPDK_TRACE_VHOST_SCSI_QUEUE, "Unsupported TMF command %x\n", ctrl_req->subtype);
SPDK_DEBUGLOG(SPDK_LOG_VHOST_SCSI_QUEUE, "Unsupported TMF command %x\n", ctrl_req->subtype);
break;
}
break;
@ -375,7 +375,7 @@ process_ctrl_request(struct spdk_vhost_scsi_task *task)
break;
}
default:
SPDK_DEBUGLOG(SPDK_TRACE_VHOST_SCSI_QUEUE, "Unsupported control command %x\n", ctrl_req->type);
SPDK_DEBUGLOG(SPDK_LOG_VHOST_SCSI_QUEUE, "Unsupported control command %x\n", ctrl_req->type);
break;
}
@ -451,9 +451,9 @@ task_data_setup(struct spdk_vhost_scsi_task *task,
/*
* TEST UNIT READY command and some others might not contain any payload and this is not an error.
*/
SPDK_DEBUGLOG(SPDK_TRACE_VHOST_SCSI_DATA,
SPDK_DEBUGLOG(SPDK_LOG_VHOST_SCSI_DATA,
"No payload descriptors for FROM DEV command req_idx=%"PRIu16".\n", task->req_idx);
SPDK_TRACEDUMP(SPDK_TRACE_VHOST_SCSI_DATA, "CDB=", (*req)->cdb, VIRTIO_SCSI_CDB_SIZE);
SPDK_TRACEDUMP(SPDK_LOG_VHOST_SCSI_DATA, "CDB=", (*req)->cdb, VIRTIO_SCSI_CDB_SIZE);
task->scsi.iovcnt = 1;
task->scsi.iovs[0].iov_len = 0;
task->scsi.length = 0;
@ -481,7 +481,7 @@ task_data_setup(struct spdk_vhost_scsi_task *task,
}
}
} else {
SPDK_DEBUGLOG(SPDK_TRACE_VHOST_SCSI_DATA, "TO DEV");
SPDK_DEBUGLOG(SPDK_LOG_VHOST_SCSI_DATA, "TO DEV");
/*
* TO_DEV (WRITE):[RD_req][RD_buf0]...[RD_bufN][WR_resp]
* No need to check descriptor WR flag as this is done while setting scsi.dxfer_dir.
@ -521,7 +521,7 @@ task_data_setup(struct spdk_vhost_scsi_task *task,
return 0;
invalid_task:
SPDK_DEBUGLOG(SPDK_TRACE_VHOST_SCSI_DATA, "%s: Invalid task at index %"PRIu16".\n",
SPDK_DEBUGLOG(SPDK_LOG_VHOST_SCSI_DATA, "%s: Invalid task at index %"PRIu16".\n",
vdev->name, task->req_idx);
return -1;
}
@ -544,7 +544,7 @@ process_request(struct spdk_vhost_scsi_task *task)
}
task->scsi.cdb = req->cdb;
SPDK_TRACEDUMP(SPDK_TRACE_VHOST_SCSI_DATA, "request CDB", req->cdb, VIRTIO_SCSI_CDB_SIZE);
SPDK_TRACEDUMP(SPDK_LOG_VHOST_SCSI_DATA, "request CDB", req->cdb, VIRTIO_SCSI_CDB_SIZE);
if (spdk_unlikely(task->scsi.lun == NULL)) {
spdk_scsi_task_process_null_lun(&task->scsi);
@ -599,7 +599,7 @@ process_requestq(struct spdk_vhost_scsi_dev *svdev, struct spdk_vhost_virtqueue
assert(reqs_cnt <= 32);
for (i = 0; i < reqs_cnt; i++) {
SPDK_DEBUGLOG(SPDK_TRACE_VHOST_SCSI, "====== Starting processing request idx %"PRIu16"======\n",
SPDK_DEBUGLOG(SPDK_LOG_VHOST_SCSI, "====== Starting processing request idx %"PRIu16"======\n",
reqs[i]);
if (spdk_unlikely(reqs[i] >= vq->vring.size)) {
@ -624,15 +624,15 @@ process_requestq(struct spdk_vhost_scsi_dev *svdev, struct spdk_vhost_virtqueue
result = process_request(task);
if (likely(result == 0)) {
task_submit(task);
SPDK_DEBUGLOG(SPDK_TRACE_VHOST_SCSI, "====== Task %p req_idx %d submitted ======\n", task,
SPDK_DEBUGLOG(SPDK_LOG_VHOST_SCSI, "====== Task %p req_idx %d submitted ======\n", task,
task->req_idx);
} else if (result > 0) {
spdk_vhost_scsi_task_cpl(&task->scsi);
SPDK_DEBUGLOG(SPDK_TRACE_VHOST_SCSI, "====== Task %p req_idx %d finished early ======\n", task,
SPDK_DEBUGLOG(SPDK_LOG_VHOST_SCSI, "====== Task %p req_idx %d finished early ======\n", task,
task->req_idx);
} else {
invalid_request(task);
SPDK_DEBUGLOG(SPDK_TRACE_VHOST_SCSI, "====== Task %p req_idx %d failed ======\n", task,
SPDK_DEBUGLOG(SPDK_LOG_VHOST_SCSI, "====== Task %p req_idx %d failed ======\n", task,
task->req_idx);
}
}
@ -1179,6 +1179,6 @@ spdk_vhost_scsi_config_json(struct spdk_vhost_dev *vdev, struct spdk_json_write_
spdk_json_write_object_end(w);
}
SPDK_LOG_REGISTER_TRACE_FLAG("vhost_scsi", SPDK_TRACE_VHOST_SCSI)
SPDK_LOG_REGISTER_TRACE_FLAG("vhost_scsi_queue", SPDK_TRACE_VHOST_SCSI_QUEUE)
SPDK_LOG_REGISTER_TRACE_FLAG("vhost_scsi_data", SPDK_TRACE_VHOST_SCSI_DATA)
SPDK_LOG_REGISTER_COMPONENT("vhost_scsi", SPDK_LOG_VHOST_SCSI)
SPDK_LOG_REGISTER_COMPONENT("vhost_scsi_queue", SPDK_LOG_VHOST_SCSI_QUEUE)
SPDK_LOG_REGISTER_COMPONENT("vhost_scsi_data", SPDK_LOG_VHOST_SCSI_DATA)

2
test/unit/lib/iscsi/common.c
View File

@ -9,7 +9,7 @@
#include "scsi/scsi_internal.h"
SPDK_LOG_REGISTER_TRACE_FLAG("iscsi", SPDK_TRACE_ISCSI)
SPDK_LOG_REGISTER_COMPONENT("iscsi", SPDK_LOG_ISCSI)
struct spdk_iscsi_task *
spdk_iscsi_task_get(struct spdk_iscsi_conn *conn,

2
test/unit/lib/iscsi/init_grp.c/init_grp_ut.c
View File

@ -36,7 +36,7 @@
#include "iscsi/init_grp.c"
SPDK_LOG_REGISTER_TRACE_FLAG("iscsi", SPDK_TRACE_ISCSI)
SPDK_LOG_REGISTER_COMPONENT("iscsi", SPDK_LOG_ISCSI)
struct spdk_iscsi_globals g_spdk_iscsi;

4
test/unit/lib/log/log.c/log_ut.c
View File

@ -66,8 +66,8 @@ log_test(void)
spdk_log_open();
spdk_log_set_trace_flag("debug");
SPDK_WARNLOG("log warning unit test\n");
SPDK_DEBUGLOG(SPDK_TRACE_LOG, "log trace test\n");
SPDK_TRACEDUMP(SPDK_TRACE_LOG, "log trace dump test:", "trace dump", 10);
SPDK_DEBUGLOG(SPDK_LOG_LOG, "log trace test\n");
SPDK_TRACEDUMP(SPDK_LOG_LOG, "log trace dump test:", "trace dump", 10);
spdk_trace_dump(stderr, "spdk dump test:", "spdk dump", 9);
spdk_log_close();

2
test/unit/lib/nvme/nvme_ctrlr.c/nvme_ctrlr_ut.c
View File

@ -39,7 +39,7 @@
#include "lib/test_env.c"
struct spdk_trace_flag SPDK_TRACE_NVME = {
struct spdk_trace_flag SPDK_LOG_NVME = {
.name = "nvme",
.enabled = false,
};

2
test/unit/lib/nvme/nvme_ns.c/nvme_ns_ut.c
View File

@ -39,7 +39,7 @@
#include "lib/test_env.c"
SPDK_LOG_REGISTER_TRACE_FLAG("nvme", SPDK_TRACE_NVME)
SPDK_LOG_REGISTER_COMPONENT("nvme", SPDK_LOG_NVME)
int
nvme_ctrlr_cmd_identify_namespace(struct spdk_nvme_ctrlr *ctrlr, uint16_t nsid, void *payload,

2
test/unit/lib/nvme/nvme_pcie.c/nvme_pcie_ut.c
View File

@ -39,7 +39,7 @@
#include "nvme/nvme_pcie.c"
struct spdk_trace_flag SPDK_TRACE_NVME = {
struct spdk_trace_flag SPDK_LOG_NVME = {
.name = "nvme",
.enabled = false,
};

2
test/unit/lib/nvme/nvme_qpair.c/nvme_qpair_ut.c
View File

@ -38,7 +38,7 @@
#include "lib/test_env.c"
bool trace_flag = false;
#define SPDK_TRACE_NVME trace_flag
#define SPDK_LOG_NVME trace_flag
#include "nvme/nvme_qpair.c"

2
test/unit/lib/nvmf/ctrlr.c/ctrlr_ut.c
View File

@ -37,7 +37,7 @@
#include "ctrlr.c"
SPDK_LOG_REGISTER_TRACE_FLAG("nvmf", SPDK_TRACE_NVMF)
SPDK_LOG_REGISTER_COMPONENT("nvmf", SPDK_LOG_NVMF)
struct spdk_nvmf_subsystem *
spdk_nvmf_tgt_find_subsystem(struct spdk_nvmf_tgt *tgt, const char *subnqn)

2
test/unit/lib/nvmf/ctrlr_bdev.c/ctrlr_bdev_ut.c
View File

@ -38,7 +38,7 @@
#include "ctrlr_bdev.c"
SPDK_LOG_REGISTER_TRACE_FLAG("nvmf", SPDK_TRACE_NVMF)
SPDK_LOG_REGISTER_COMPONENT("nvmf", SPDK_LOG_NVMF)
struct spdk_nvmf_qpair *
spdk_nvmf_ctrlr_get_qpair(struct spdk_nvmf_ctrlr *ctrlr, uint16_t qid)

2
test/unit/lib/nvmf/ctrlr_discovery.c/ctrlr_discovery_ut.c
View File

@ -37,7 +37,7 @@
#include "ctrlr_discovery.c"
SPDK_LOG_REGISTER_TRACE_FLAG("nvmf", SPDK_TRACE_NVMF)
SPDK_LOG_REGISTER_COMPONENT("nvmf", SPDK_LOG_NVMF)
int
spdk_bdev_open(struct spdk_bdev *bdev, bool write, spdk_bdev_remove_cb_t remove_cb,

2
test/unit/lib/nvmf/request.c/request_ut.c
View File

@ -37,7 +37,7 @@
#include "request.c"
SPDK_LOG_REGISTER_TRACE_FLAG("nvmf", SPDK_TRACE_NVMF)
SPDK_LOG_REGISTER_COMPONENT("nvmf", SPDK_LOG_NVMF)
void spdk_trace_record(uint16_t tpoint_id, uint16_t poller_id, uint32_t size,
uint64_t object_id, uint64_t arg1)

2
test/unit/lib/nvmf/subsystem.c/subsystem_ut.c
View File

@ -37,7 +37,7 @@
#include "subsystem.c"
SPDK_LOG_REGISTER_TRACE_FLAG("nvmf", SPDK_TRACE_NVMF)
SPDK_LOG_REGISTER_COMPONENT("nvmf", SPDK_LOG_NVMF)
int
spdk_nvmf_transport_listen(struct spdk_nvmf_transport *transport,

2
test/unit/lib/scsi/lun.c/lun_ut.c
View File

@ -46,7 +46,7 @@ struct spdk_bdev {
int x;
};
SPDK_LOG_REGISTER_TRACE_FLAG("scsi", SPDK_TRACE_SCSI)
SPDK_LOG_REGISTER_COMPONENT("scsi", SPDK_LOG_SCSI)
struct spdk_scsi_globals g_spdk_scsi;

2
test/unit/lib/scsi/scsi_bdev.c/scsi_bdev_ut.c
View File

@ -38,7 +38,7 @@
#include "spdk_cunit.h"
SPDK_LOG_REGISTER_TRACE_FLAG("scsi", SPDK_TRACE_SCSI)
SPDK_LOG_REGISTER_COMPONENT("scsi", SPDK_LOG_SCSI)
struct spdk_scsi_globals g_spdk_scsi;