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

lib/blob: remove spdk_ from non-public APIs

Browse Source 
We have an unofficial naming convention that the
spdk_ namespace is reserved for public API functions only.
This patch is attempting to bring the blob library into compliance
with that naming convention.

Signed-off-by: Seth Howell <seth.howell@intel.com>
Change-Id: Ie298e41d1b741dae01744826c208378ee60f9d0a
Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/1700
Tested-by: SPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: Tomasz Zawadzki <tomasz.zawadzki@intel.com>
Reviewed-by: Shuhei Matsumoto <shuhei.matsumoto.xt@hitachi.com>
Reviewed-by: Jim Harris <james.r.harris@intel.com>
Reviewed-by: Ben Walker <benjamin.walker@intel.com>
Community-CI: Broadcom CI
This commit is contained in:
Seth Howell 2020-04-06 17:03:39 -07:00 committed by Jim Harris
parent 75365cfa60
commit ad7fdd12b1
6 changed files with 261 additions and 261 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib/blob/blob_bs_dev.c
View File

@ -123,7 +123,7 @@ blob_bs_dev_destroy(struct spdk_bs_dev *bs_dev)
struct spdk_bs_dev * struct spdk_bs_dev *
spdk_bs_create_blob_bs_dev(struct spdk_blob *blob) bs_create_blob_bs_dev(struct spdk_blob *blob)
{ {
struct spdk_blob_bs_dev *b; struct spdk_blob_bs_dev *b;

330
lib/blob/blobstore.c
View File

@ -315,7 +315,7 @@ _spdk_blob_execute_queued_io(struct spdk_io_channel_iter *i)
if (args->blob == ctx->blob) { if (args->blob == ctx->blob) {
TAILQ_REMOVE(&ch->queued_io, op, link); TAILQ_REMOVE(&ch->queued_io, op, link);
spdk_bs_user_op_execute(op); bs_user_op_execute(op);
} }
} }
@ -1261,7 +1261,7 @@ _spdk_blob_load_snapshot_cpl(void *cb_arg, struct spdk_blob *snapshot, int bserr
struct spdk_blob *blob = ctx->blob; struct spdk_blob *blob = ctx->blob;
if (bserrno == 0) { if (bserrno == 0) {
blob->back_bs_dev = spdk_bs_create_blob_bs_dev(snapshot); blob->back_bs_dev = bs_create_blob_bs_dev(snapshot);
if (blob->back_bs_dev == NULL) { if (blob->back_bs_dev == NULL) {
bserrno = -ENOMEM; bserrno = -ENOMEM;
} }
@ -1298,7 +1298,7 @@ _spdk_blob_load_backing_dev(void *cb_arg)
return; return;
} else { } else {
/* add zeroes_dev for thin provisioned blob */ /* add zeroes_dev for thin provisioned blob */
blob->back_bs_dev = spdk_bs_create_zeroes_dev(); blob->back_bs_dev = bs_create_zeroes_dev();
} }
} else { } else {
/* standard blob */ /* standard blob */
@ -1361,9 +1361,9 @@ _spdk_blob_load_cpl_extents_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserr
lba = _spdk_bs_md_page_to_lba(blob->bs, blob->active.extent_pages[i]); lba = _spdk_bs_md_page_to_lba(blob->bs, blob->active.extent_pages[i]);
ctx->next_extent_page = i + 1; ctx->next_extent_page = i + 1;
spdk_bs_sequence_read_dev(seq, &ctx->pages[0], lba, bs_sequence_read_dev(seq, &ctx->pages[0], lba,
_spdk_bs_byte_to_lba(blob->bs, SPDK_BS_PAGE_SIZE), _spdk_bs_byte_to_lba(blob->bs, SPDK_BS_PAGE_SIZE),
_spdk_blob_load_cpl_extents_cpl, ctx); _spdk_blob_load_cpl_extents_cpl, ctx);
return; return;
} else { } else {
/* Thin provisioned blobs can point to unallocated extent pages. /* Thin provisioned blobs can point to unallocated extent pages.
@ -1427,10 +1427,10 @@ _spdk_blob_load_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
return; return;
} }
spdk_bs_sequence_read_dev(seq, &ctx->pages[ctx->num_pages - 1], bs_sequence_read_dev(seq, &ctx->pages[ctx->num_pages - 1],
next_lba, next_lba,
_spdk_bs_byte_to_lba(blob->bs, sizeof(*page)), _spdk_bs_byte_to_lba(blob->bs, sizeof(*page)),
_spdk_blob_load_cpl, ctx); _spdk_blob_load_cpl, ctx);
return; return;
} }
@ -1505,9 +1505,9 @@ _spdk_blob_load(spdk_bs_sequence_t *seq, struct spdk_blob *blob,
blob->state = SPDK_BLOB_STATE_LOADING; blob->state = SPDK_BLOB_STATE_LOADING;
spdk_bs_sequence_read_dev(seq, &ctx->pages[0], lba, bs_sequence_read_dev(seq, &ctx->pages[0], lba,
_spdk_bs_byte_to_lba(bs, SPDK_BS_PAGE_SIZE), _spdk_bs_byte_to_lba(bs, SPDK_BS_PAGE_SIZE),
_spdk_blob_load_cpl, ctx); _spdk_blob_load_cpl, ctx);
} }
struct spdk_blob_persist_ctx { struct spdk_blob_persist_ctx {
@ -1532,10 +1532,10 @@ spdk_bs_batch_clear_dev(struct spdk_blob_persist_ctx *ctx, spdk_bs_batch_t *batc
switch (ctx->blob->clear_method) { switch (ctx->blob->clear_method) {
case BLOB_CLEAR_WITH_DEFAULT: case BLOB_CLEAR_WITH_DEFAULT:
case BLOB_CLEAR_WITH_UNMAP: case BLOB_CLEAR_WITH_UNMAP:
spdk_bs_batch_unmap_dev(batch, lba, lba_count); bs_batch_unmap_dev(batch, lba, lba_count);
break; break;
case BLOB_CLEAR_WITH_WRITE_ZEROES: case BLOB_CLEAR_WITH_WRITE_ZEROES:
spdk_bs_batch_write_zeroes_dev(batch, lba, lba_count); bs_batch_write_zeroes_dev(batch, lba, lba_count);
break; break;
case BLOB_CLEAR_WITH_NONE: case BLOB_CLEAR_WITH_NONE:
default: default:
@ -1641,7 +1641,7 @@ _spdk_blob_persist_clear_clusters(spdk_bs_sequence_t *seq, void *cb_arg, int bse
* at the end, but no changes ever occur in the middle of the list. * at the end, but no changes ever occur in the middle of the list.
*/ */
batch = spdk_bs_sequence_to_batch(seq, _spdk_blob_persist_clear_clusters_cpl, ctx); batch = bs_sequence_to_batch(seq, _spdk_blob_persist_clear_clusters_cpl, ctx);
/* Clear all clusters that were truncated */ /* Clear all clusters that were truncated */
lba = 0; lba = 0;
@ -1677,7 +1677,7 @@ _spdk_blob_persist_clear_clusters(spdk_bs_sequence_t *seq, void *cb_arg, int bse
spdk_bs_batch_clear_dev(ctx, batch, lba, lba_count); spdk_bs_batch_clear_dev(ctx, batch, lba, lba_count);
} }
spdk_bs_batch_close(batch); bs_batch_close(batch);
} }
static void static void
@ -1728,7 +1728,7 @@ _spdk_blob_persist_zero_pages(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno
return; return;
} }
batch = spdk_bs_sequence_to_batch(seq, _spdk_blob_persist_zero_pages_cpl, ctx); batch = bs_sequence_to_batch(seq, _spdk_blob_persist_zero_pages_cpl, ctx);
lba_count = _spdk_bs_byte_to_lba(bs, SPDK_BS_PAGE_SIZE); lba_count = _spdk_bs_byte_to_lba(bs, SPDK_BS_PAGE_SIZE);
@ -1739,7 +1739,7 @@ _spdk_blob_persist_zero_pages(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno
for (i = 1; i < blob->clean.num_pages; i++) { for (i = 1; i < blob->clean.num_pages; i++) {
lba = _spdk_bs_md_page_to_lba(bs, blob->clean.pages[i]); lba = _spdk_bs_md_page_to_lba(bs, blob->clean.pages[i]);
spdk_bs_batch_write_zeroes_dev(batch, lba, lba_count); bs_batch_write_zeroes_dev(batch, lba, lba_count);
} }
/* The first page will only be zeroed if this is a delete. */ /* The first page will only be zeroed if this is a delete. */
@ -1750,10 +1750,10 @@ _spdk_blob_persist_zero_pages(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno
page_num = _spdk_bs_blobid_to_page(blob->id); page_num = _spdk_bs_blobid_to_page(blob->id);
lba = _spdk_bs_md_page_to_lba(bs, page_num); lba = _spdk_bs_md_page_to_lba(bs, page_num);
spdk_bs_batch_write_zeroes_dev(batch, lba, lba_count); bs_batch_write_zeroes_dev(batch, lba, lba_count);
} }
spdk_bs_batch_close(batch); bs_batch_close(batch);
} }
static void static void
@ -1783,8 +1783,8 @@ _spdk_blob_persist_write_page_root(spdk_bs_sequence_t *seq, void *cb_arg, int bs
/* The first page in the metadata goes where the blobid indicates */ /* The first page in the metadata goes where the blobid indicates */
lba = _spdk_bs_md_page_to_lba(bs, _spdk_bs_blobid_to_page(blob->id)); lba = _spdk_bs_md_page_to_lba(bs, _spdk_bs_blobid_to_page(blob->id));
spdk_bs_sequence_write_dev(seq, page, lba, lba_count, bs_sequence_write_dev(seq, page, lba, lba_count,
_spdk_blob_persist_zero_pages, ctx); _spdk_blob_persist_zero_pages, ctx);
} }
static void static void
@ -1810,7 +1810,7 @@ _spdk_blob_persist_write_page_chain(spdk_bs_sequence_t *seq, void *cb_arg, int b
lba_count = _spdk_bs_byte_to_lba(bs, sizeof(*page)); lba_count = _spdk_bs_byte_to_lba(bs, sizeof(*page));
batch = spdk_bs_sequence_to_batch(seq, _spdk_blob_persist_write_page_root, ctx); batch = bs_sequence_to_batch(seq, _spdk_blob_persist_write_page_root, ctx);
/* This starts at 1. The root page is not written until /* This starts at 1. The root page is not written until
* all of the others are finished * all of the others are finished
@ -1821,10 +1821,10 @@ _spdk_blob_persist_write_page_chain(spdk_bs_sequence_t *seq, void *cb_arg, int b
lba = _spdk_bs_md_page_to_lba(bs, blob->active.pages[i]); lba = _spdk_bs_md_page_to_lba(bs, blob->active.pages[i]);
spdk_bs_batch_write_dev(batch, page, lba, lba_count); bs_batch_write_dev(batch, page, lba, lba_count);
} }
spdk_bs_batch_close(batch); bs_batch_close(batch);
} }
static int static int
@ -2037,9 +2037,9 @@ _spdk_blob_persist_write_extent_pages(spdk_bs_sequence_t *seq, void *cb_arg, int
ctx->extent_page->crc = _spdk_blob_md_page_calc_crc(ctx->extent_page); ctx->extent_page->crc = _spdk_blob_md_page_calc_crc(ctx->extent_page);
spdk_bs_sequence_write_dev(seq, ctx->extent_page, _spdk_bs_md_page_to_lba(blob->bs, extent_page_id), bs_sequence_write_dev(seq, ctx->extent_page, _spdk_bs_md_page_to_lba(blob->bs, extent_page_id),
_spdk_bs_byte_to_lba(blob->bs, SPDK_BS_PAGE_SIZE), _spdk_bs_byte_to_lba(blob->bs, SPDK_BS_PAGE_SIZE),
_spdk_blob_persist_write_extent_pages, ctx); _spdk_blob_persist_write_extent_pages, ctx);
return; return;
} }
assert(blob->clean.extent_pages[i] != 0); assert(blob->clean.extent_pages[i] != 0);
@ -2119,9 +2119,9 @@ _spdk_blob_persist_check_dirty(struct spdk_blob_persist_ctx *ctx)
return; return;
} }
spdk_bs_sequence_read_dev(ctx->seq, ctx->super, _spdk_bs_page_to_lba(ctx->blob->bs, 0), bs_sequence_read_dev(ctx->seq, ctx->super, _spdk_bs_page_to_lba(ctx->blob->bs, 0),
_spdk_bs_byte_to_lba(ctx->blob->bs, sizeof(*ctx->super)), _spdk_bs_byte_to_lba(ctx->blob->bs, sizeof(*ctx->super)),
_spdk_blob_persist_dirty, ctx); _spdk_blob_persist_dirty, ctx);
} else { } else {
_spdk_blob_persist_start(ctx); _spdk_blob_persist_start(ctx);
} }
@ -2187,9 +2187,9 @@ _spdk_blob_allocate_and_copy_cluster_cpl(void *cb_arg, int bserrno)
op = TAILQ_FIRST(&requests); op = TAILQ_FIRST(&requests);
TAILQ_REMOVE(&requests, op, link); TAILQ_REMOVE(&requests, op, link);
if (bserrno == 0) { if (bserrno == 0) {
spdk_bs_user_op_execute(op); bs_user_op_execute(op);
} else { } else {
spdk_bs_user_op_abort(op); bs_user_op_abort(op);
} }
} }
@ -2215,7 +2215,7 @@ _spdk_blob_insert_cluster_cpl(void *cb_arg, int bserrno)
} }
} }
spdk_bs_sequence_finish(ctx->seq, bserrno); bs_sequence_finish(ctx->seq, bserrno);
} }
static void static void
@ -2226,7 +2226,7 @@ _spdk_blob_write_copy_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
if (bserrno) { if (bserrno) {
/* The write failed, so jump to the final completion handler */ /* The write failed, so jump to the final completion handler */
spdk_bs_sequence_finish(seq, bserrno); bs_sequence_finish(seq, bserrno);
return; return;
} }
@ -2243,15 +2243,15 @@ _spdk_blob_write_copy(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
if (bserrno != 0) { if (bserrno != 0) {
/* The read failed, so jump to the final completion handler */ /* The read failed, so jump to the final completion handler */
spdk_bs_sequence_finish(seq, bserrno); bs_sequence_finish(seq, bserrno);
return; return;
} }
/* Write whole cluster */ /* Write whole cluster */
spdk_bs_sequence_write_dev(seq, ctx->buf, bs_sequence_write_dev(seq, ctx->buf,
_spdk_bs_cluster_to_lba(ctx->blob->bs, ctx->new_cluster), _spdk_bs_cluster_to_lba(ctx->blob->bs, ctx->new_cluster),
_spdk_bs_cluster_to_lba(ctx->blob->bs, 1), _spdk_bs_cluster_to_lba(ctx->blob->bs, 1),
_spdk_blob_write_copy_cpl, ctx); _spdk_blob_write_copy_cpl, ctx);
} }
static void static void
@ -2285,7 +2285,7 @@ _spdk_bs_allocate_and_copy_cluster(struct spdk_blob *blob,
ctx = calloc(1, sizeof(*ctx)); ctx = calloc(1, sizeof(*ctx));
if (!ctx) { if (!ctx) {
spdk_bs_user_op_abort(op); bs_user_op_abort(op);
return; return;
} }
@ -2301,7 +2301,7 @@ _spdk_bs_allocate_and_copy_cluster(struct spdk_blob *blob,
SPDK_ERRLOG("DMA allocation for cluster of size = %" PRIu32 " failed.\n", SPDK_ERRLOG("DMA allocation for cluster of size = %" PRIu32 " failed.\n",
blob->bs->cluster_sz); blob->bs->cluster_sz);
free(ctx); free(ctx);
spdk_bs_user_op_abort(op); bs_user_op_abort(op);
return; return;
} }
} }
@ -2311,7 +2311,7 @@ _spdk_bs_allocate_and_copy_cluster(struct spdk_blob *blob,
if (rc != 0) { if (rc != 0) {
spdk_free(ctx->buf); spdk_free(ctx->buf);
free(ctx); free(ctx);
spdk_bs_user_op_abort(op); bs_user_op_abort(op);
return; return;
} }
@ -2319,12 +2319,12 @@ _spdk_bs_allocate_and_copy_cluster(struct spdk_blob *blob,
cpl.u.blob_basic.cb_fn = _spdk_blob_allocate_and_copy_cluster_cpl; cpl.u.blob_basic.cb_fn = _spdk_blob_allocate_and_copy_cluster_cpl;
cpl.u.blob_basic.cb_arg = ctx; cpl.u.blob_basic.cb_arg = ctx;
ctx->seq = spdk_bs_sequence_start(_ch, &cpl); ctx->seq = bs_sequence_start(_ch, &cpl);
if (!ctx->seq) { if (!ctx->seq) {
_spdk_bs_release_cluster(blob->bs, ctx->new_cluster); _spdk_bs_release_cluster(blob->bs, ctx->new_cluster);
spdk_free(ctx->buf); spdk_free(ctx->buf);
free(ctx); free(ctx);
spdk_bs_user_op_abort(op); bs_user_op_abort(op);
return; return;
} }
@ -2333,10 +2333,10 @@ _spdk_bs_allocate_and_copy_cluster(struct spdk_blob *blob,
if (blob->parent_id != SPDK_BLOBID_INVALID) { if (blob->parent_id != SPDK_BLOBID_INVALID) {
/* Read cluster from backing device */ /* Read cluster from backing device */
spdk_bs_sequence_read_bs_dev(ctx->seq, blob->back_bs_dev, ctx->buf, bs_sequence_read_bs_dev(ctx->seq, blob->back_bs_dev, ctx->buf,
_spdk_bs_dev_page_to_lba(blob->back_bs_dev, cluster_start_page), _spdk_bs_dev_page_to_lba(blob->back_bs_dev, cluster_start_page),
_spdk_bs_dev_byte_to_lba(blob->back_bs_dev, blob->bs->cluster_sz), _spdk_bs_dev_byte_to_lba(blob->back_bs_dev, blob->bs->cluster_sz),
_spdk_blob_write_copy, ctx); _spdk_blob_write_copy, ctx);
} else { } else {
_spdk_blob_insert_cluster_on_md_thread(ctx->blob, cluster_number, ctx->new_cluster, _spdk_blob_insert_cluster_on_md_thread(ctx->blob, cluster_number, ctx->new_cluster,
ctx->new_extent_page, _spdk_blob_insert_cluster_cpl, ctx); ctx->new_extent_page, _spdk_blob_insert_cluster_cpl, ctx);
@ -2381,7 +2381,7 @@ _spdk_blob_request_submit_op_split_next(void *cb_arg, int bserrno)
uint64_t op_length; uint64_t op_length;
if (bserrno != 0 || ctx->io_units_remaining == 0) { if (bserrno != 0 || ctx->io_units_remaining == 0) {
spdk_bs_sequence_finish(ctx->seq, bserrno); bs_sequence_finish(ctx->seq, bserrno);
free(ctx); free(ctx);
return; return;
} }
@ -2416,7 +2416,7 @@ _spdk_blob_request_submit_op_split_next(void *cb_arg, int bserrno)
case SPDK_BLOB_READV: case SPDK_BLOB_READV:
case SPDK_BLOB_WRITEV: case SPDK_BLOB_WRITEV:
SPDK_ERRLOG("readv/write not valid\n"); SPDK_ERRLOG("readv/write not valid\n");
spdk_bs_sequence_finish(ctx->seq, -EINVAL); bs_sequence_finish(ctx->seq, -EINVAL);
free(ctx); free(ctx);
break; break;
} }
@ -2443,7 +2443,7 @@ _spdk_blob_request_submit_op_split(struct spdk_io_channel *ch, struct spdk_blob
cpl.u.blob_basic.cb_fn = cb_fn; cpl.u.blob_basic.cb_fn = cb_fn;
cpl.u.blob_basic.cb_arg = cb_arg; cpl.u.blob_basic.cb_arg = cb_arg;
seq = spdk_bs_sequence_start(ch, &cpl); seq = bs_sequence_start(ch, &cpl);
if (!seq) { if (!seq) {
free(ctx); free(ctx);
cb_fn(cb_arg, -ENOMEM); cb_fn(cb_arg, -ENOMEM);
@ -2483,7 +2483,7 @@ _spdk_blob_request_submit_op_single(struct spdk_io_channel *_ch, struct spdk_blo
spdk_bs_user_op_t *op; spdk_bs_user_op_t *op;
struct spdk_bs_channel *bs_channel = spdk_io_channel_get_ctx(_ch); struct spdk_bs_channel *bs_channel = spdk_io_channel_get_ctx(_ch);
op = spdk_bs_user_op_alloc(_ch, &cpl, op_type, blob, payload, 0, offset, length); op = bs_user_op_alloc(_ch, &cpl, op_type, blob, payload, 0, offset, length);
if (!op) { if (!op) {
cb_fn(cb_arg, -ENOMEM); cb_fn(cb_arg, -ENOMEM);
return; return;
@ -2498,7 +2498,7 @@ _spdk_blob_request_submit_op_single(struct spdk_io_channel *_ch, struct spdk_blo
case SPDK_BLOB_READ: { case SPDK_BLOB_READ: {
spdk_bs_batch_t *batch; spdk_bs_batch_t *batch;
batch = spdk_bs_batch_open(_ch, &cpl); batch = bs_batch_open(_ch, &cpl);
if (!batch) { if (!batch) {
cb_fn(cb_arg, -ENOMEM); cb_fn(cb_arg, -ENOMEM);
return; return;
@ -2506,13 +2506,13 @@ _spdk_blob_request_submit_op_single(struct spdk_io_channel *_ch, struct spdk_blo
if (_spdk_bs_io_unit_is_allocated(blob, offset)) { if (_spdk_bs_io_unit_is_allocated(blob, offset)) {
/* Read from the blob */ /* Read from the blob */
spdk_bs_batch_read_dev(batch, payload, lba, lba_count); bs_batch_read_dev(batch, payload, lba, lba_count);
} else { } else {
/* Read from the backing block device */ /* Read from the backing block device */
spdk_bs_batch_read_bs_dev(batch, blob->back_bs_dev, payload, lba, lba_count); spdk_bs_batch_read_bs_dev(batch, blob->back_bs_dev, payload, lba, lba_count);
} }
spdk_bs_batch_close(batch); bs_batch_close(batch);
break; break;
} }
case SPDK_BLOB_WRITE: case SPDK_BLOB_WRITE:
@ -2526,24 +2526,24 @@ _spdk_blob_request_submit_op_single(struct spdk_io_channel *_ch, struct spdk_blo
return; return;
} }
batch = spdk_bs_batch_open(_ch, &cpl); batch = bs_batch_open(_ch, &cpl);
if (!batch) { if (!batch) {
cb_fn(cb_arg, -ENOMEM); cb_fn(cb_arg, -ENOMEM);
return; return;
} }
if (op_type == SPDK_BLOB_WRITE) { if (op_type == SPDK_BLOB_WRITE) {
spdk_bs_batch_write_dev(batch, payload, lba, lba_count); bs_batch_write_dev(batch, payload, lba, lba_count);
} else { } else {
spdk_bs_batch_write_zeroes_dev(batch, lba, lba_count); bs_batch_write_zeroes_dev(batch, lba, lba_count);
} }
spdk_bs_batch_close(batch); bs_batch_close(batch);
} else { } else {
/* Queue this operation and allocate the cluster */ /* Queue this operation and allocate the cluster */
spdk_bs_user_op_t *op; spdk_bs_user_op_t *op;
op = spdk_bs_user_op_alloc(_ch, &cpl, op_type, blob, payload, 0, offset, length); op = bs_user_op_alloc(_ch, &cpl, op_type, blob, payload, 0, offset, length);
if (!op) { if (!op) {
cb_fn(cb_arg, -ENOMEM); cb_fn(cb_arg, -ENOMEM);
return; return;
@ -2556,17 +2556,17 @@ _spdk_blob_request_submit_op_single(struct spdk_io_channel *_ch, struct spdk_blo
case SPDK_BLOB_UNMAP: { case SPDK_BLOB_UNMAP: {
spdk_bs_batch_t *batch; spdk_bs_batch_t *batch;
batch = spdk_bs_batch_open(_ch, &cpl); batch = bs_batch_open(_ch, &cpl);
if (!batch) { if (!batch) {
cb_fn(cb_arg, -ENOMEM); cb_fn(cb_arg, -ENOMEM);
return; return;
} }
if (_spdk_bs_io_unit_is_allocated(blob, offset)) { if (_spdk_bs_io_unit_is_allocated(blob, offset)) {
spdk_bs_batch_unmap_dev(batch, lba, lba_count); bs_batch_unmap_dev(batch, lba, lba_count);
} }
spdk_bs_batch_close(batch); bs_batch_close(batch);
break; break;
} }
case SPDK_BLOB_READV: case SPDK_BLOB_READV:
@ -2620,7 +2620,7 @@ static void
_spdk_rw_iov_done(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno) _spdk_rw_iov_done(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
{ {
assert(cb_arg == NULL); assert(cb_arg == NULL);
spdk_bs_sequence_finish(seq, bserrno); bs_sequence_finish(seq, bserrno);
} }
static void static void
@ -2746,7 +2746,7 @@ _spdk_blob_request_submit_rw_iov(struct spdk_blob *blob, struct spdk_io_channel
struct spdk_bs_channel *bs_channel = spdk_io_channel_get_ctx(_channel); struct spdk_bs_channel *bs_channel = spdk_io_channel_get_ctx(_channel);
op_type = read ? SPDK_BLOB_READV : SPDK_BLOB_WRITEV; op_type = read ? SPDK_BLOB_READV : SPDK_BLOB_WRITEV;
op = spdk_bs_user_op_alloc(_channel, &cpl, op_type, blob, iov, iovcnt, offset, length); op = bs_user_op_alloc(_channel, &cpl, op_type, blob, iov, iovcnt, offset, length);
if (!op) { if (!op) {
cb_fn(cb_arg, -ENOMEM); cb_fn(cb_arg, -ENOMEM);
return; return;
@ -2762,35 +2762,35 @@ _spdk_blob_request_submit_rw_iov(struct spdk_blob *blob, struct spdk_io_channel
if (read) { if (read) {
spdk_bs_sequence_t *seq; spdk_bs_sequence_t *seq;
seq = spdk_bs_sequence_start(_channel, &cpl); seq = bs_sequence_start(_channel, &cpl);
if (!seq) { if (!seq) {
cb_fn(cb_arg, -ENOMEM); cb_fn(cb_arg, -ENOMEM);
return; return;
} }
if (_spdk_bs_io_unit_is_allocated(blob, offset)) { if (_spdk_bs_io_unit_is_allocated(blob, offset)) {
spdk_bs_sequence_readv_dev(seq, iov, iovcnt, lba, lba_count, _spdk_rw_iov_done, NULL); bs_sequence_readv_dev(seq, iov, iovcnt, lba, lba_count, _spdk_rw_iov_done, NULL);
} else { } else {
spdk_bs_sequence_readv_bs_dev(seq, blob->back_bs_dev, iov, iovcnt, lba, lba_count, bs_sequence_readv_bs_dev(seq, blob->back_bs_dev, iov, iovcnt, lba, lba_count,
_spdk_rw_iov_done, NULL); _spdk_rw_iov_done, NULL);
} }
} else { } else {
if (_spdk_bs_io_unit_is_allocated(blob, offset)) { if (_spdk_bs_io_unit_is_allocated(blob, offset)) {
spdk_bs_sequence_t *seq; spdk_bs_sequence_t *seq;
seq = spdk_bs_sequence_start(_channel, &cpl); seq = bs_sequence_start(_channel, &cpl);
if (!seq) { if (!seq) {
cb_fn(cb_arg, -ENOMEM); cb_fn(cb_arg, -ENOMEM);
return; return;
} }
spdk_bs_sequence_writev_dev(seq, iov, iovcnt, lba, lba_count, _spdk_rw_iov_done, NULL); bs_sequence_writev_dev(seq, iov, iovcnt, lba, lba_count, _spdk_rw_iov_done, NULL);
} else { } else {
/* Queue this operation and allocate the cluster */ /* Queue this operation and allocate the cluster */
spdk_bs_user_op_t *op; spdk_bs_user_op_t *op;
op = spdk_bs_user_op_alloc(_channel, &cpl, SPDK_BLOB_WRITEV, blob, iov, iovcnt, offset, op = bs_user_op_alloc(_channel, &cpl, SPDK_BLOB_WRITEV, blob, iov, iovcnt, offset,
length); length);
if (!op) { if (!op) {
cb_fn(cb_arg, -ENOMEM); cb_fn(cb_arg, -ENOMEM);
return; return;
@ -2913,13 +2913,13 @@ _spdk_bs_channel_destroy(void *io_device, void *ctx_buf)
while (!TAILQ_EMPTY(&channel->need_cluster_alloc)) { while (!TAILQ_EMPTY(&channel->need_cluster_alloc)) {
op = TAILQ_FIRST(&channel->need_cluster_alloc); op = TAILQ_FIRST(&channel->need_cluster_alloc);
TAILQ_REMOVE(&channel->need_cluster_alloc, op, link); TAILQ_REMOVE(&channel->need_cluster_alloc, op, link);
spdk_bs_user_op_abort(op); bs_user_op_abort(op);
} }
while (!TAILQ_EMPTY(&channel->queued_io)) { while (!TAILQ_EMPTY(&channel->queued_io)) {
op = TAILQ_FIRST(&channel->queued_io); op = TAILQ_FIRST(&channel->queued_io);
TAILQ_REMOVE(&channel->queued_io, op, link); TAILQ_REMOVE(&channel->queued_io, op, link);
spdk_bs_user_op_abort(op); bs_user_op_abort(op);
} }
free(channel->req_mem); free(channel->req_mem);
@ -2948,7 +2948,7 @@ _spdk_bs_dev_destroy(void *io_device)
* If this function is called for any reason except a successful unload, * If this function is called for any reason except a successful unload,
* the unload_cpl type will be NONE and this will be a nop. * the unload_cpl type will be NONE and this will be a nop.
*/ */
spdk_bs_call_cpl(&bs->unload_cpl, bs->unload_err); bs_call_cpl(&bs->unload_cpl, bs->unload_err);
free(bs); free(bs);
} }
@ -3176,7 +3176,7 @@ _spdk_bs_load_ctx_fail(struct spdk_bs_load_ctx *ctx, int bserrno)
assert(bserrno != 0); assert(bserrno != 0);
spdk_free(ctx->super); spdk_free(ctx->super);
spdk_bs_sequence_finish(ctx->seq, bserrno); bs_sequence_finish(ctx->seq, bserrno);
_spdk_bs_free(ctx->bs); _spdk_bs_free(ctx->bs);
free(ctx); free(ctx);
} }
@ -3224,9 +3224,9 @@ _spdk_bs_write_super(spdk_bs_sequence_t *seq, struct spdk_blob_store *bs,
super->super_blob = bs->super_blob; super->super_blob = bs->super_blob;
memcpy(&super->bstype, &bs->bstype, sizeof(bs->bstype)); memcpy(&super->bstype, &bs->bstype, sizeof(bs->bstype));
super->crc = _spdk_blob_md_page_calc_crc(super); super->crc = _spdk_blob_md_page_calc_crc(super);
spdk_bs_sequence_write_dev(seq, super, _spdk_bs_page_to_lba(bs, 0), bs_sequence_write_dev(seq, super, _spdk_bs_page_to_lba(bs, 0),
_spdk_bs_byte_to_lba(bs, sizeof(*super)), _spdk_bs_byte_to_lba(bs, sizeof(*super)),
cb_fn, cb_arg); cb_fn, cb_arg);
} }
static void static void
@ -3251,7 +3251,7 @@ _spdk_bs_write_used_clusters(spdk_bs_sequence_t *seq, void *arg, spdk_bs_sequenc
_spdk_bs_set_mask(ctx->bs->used_clusters, ctx->mask); _spdk_bs_set_mask(ctx->bs->used_clusters, ctx->mask);
lba = _spdk_bs_page_to_lba(ctx->bs, ctx->super->used_cluster_mask_start); lba = _spdk_bs_page_to_lba(ctx->bs, ctx->super->used_cluster_mask_start);
lba_count = _spdk_bs_page_to_lba(ctx->bs, ctx->super->used_cluster_mask_len); lba_count = _spdk_bs_page_to_lba(ctx->bs, ctx->super->used_cluster_mask_len);
spdk_bs_sequence_write_dev(seq, ctx->mask, lba, lba_count, cb_fn, arg); bs_sequence_write_dev(seq, ctx->mask, lba, lba_count, cb_fn, arg);
} }
static void static void
@ -3275,7 +3275,7 @@ _spdk_bs_write_used_md(spdk_bs_sequence_t *seq, void *arg, spdk_bs_sequence_cpl
_spdk_bs_set_mask(ctx->bs->used_md_pages, ctx->mask); _spdk_bs_set_mask(ctx->bs->used_md_pages, ctx->mask);
lba = _spdk_bs_page_to_lba(ctx->bs, ctx->super->used_page_mask_start); lba = _spdk_bs_page_to_lba(ctx->bs, ctx->super->used_page_mask_start);
lba_count = _spdk_bs_page_to_lba(ctx->bs, ctx->super->used_page_mask_len); lba_count = _spdk_bs_page_to_lba(ctx->bs, ctx->super->used_page_mask_len);
spdk_bs_sequence_write_dev(seq, ctx->mask, lba, lba_count, cb_fn, arg); bs_sequence_write_dev(seq, ctx->mask, lba, lba_count, cb_fn, arg);
} }
static void static void
@ -3308,7 +3308,7 @@ _spdk_bs_write_used_blobids(spdk_bs_sequence_t *seq, void *arg, spdk_bs_sequence
_spdk_bs_set_mask(ctx->bs->used_blobids, ctx->mask); _spdk_bs_set_mask(ctx->bs->used_blobids, ctx->mask);
lba = _spdk_bs_page_to_lba(ctx->bs, ctx->super->used_blobid_mask_start); lba = _spdk_bs_page_to_lba(ctx->bs, ctx->super->used_blobid_mask_start);
lba_count = _spdk_bs_page_to_lba(ctx->bs, ctx->super->used_blobid_mask_len); lba_count = _spdk_bs_page_to_lba(ctx->bs, ctx->super->used_blobid_mask_len);
spdk_bs_sequence_write_dev(seq, ctx->mask, lba, lba_count, cb_fn, arg); bs_sequence_write_dev(seq, ctx->mask, lba, lba_count, cb_fn, arg);
} }
static void static void
@ -3494,7 +3494,7 @@ _spdk_bs_load_iter(void *arg, struct spdk_blob *blob, int bserrno)
spdk_free(ctx->super); spdk_free(ctx->super);
spdk_free(ctx->mask); spdk_free(ctx->mask);
spdk_bs_sequence_finish(ctx->seq, bserrno); bs_sequence_finish(ctx->seq, bserrno);
free(ctx); free(ctx);
} }
@ -3573,8 +3573,8 @@ _spdk_bs_load_used_clusters_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserr
} }
lba = _spdk_bs_page_to_lba(ctx->bs, ctx->super->used_blobid_mask_start); lba = _spdk_bs_page_to_lba(ctx->bs, ctx->super->used_blobid_mask_start);
lba_count = _spdk_bs_page_to_lba(ctx->bs, ctx->super->used_blobid_mask_len); lba_count = _spdk_bs_page_to_lba(ctx->bs, ctx->super->used_blobid_mask_len);
spdk_bs_sequence_read_dev(seq, ctx->mask, lba, lba_count, bs_sequence_read_dev(seq, ctx->mask, lba, lba_count,
_spdk_bs_load_used_blobids_cpl, ctx); _spdk_bs_load_used_blobids_cpl, ctx);
} }
static void static void
@ -3616,8 +3616,8 @@ _spdk_bs_load_used_pages_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
} }
lba = _spdk_bs_page_to_lba(ctx->bs, ctx->super->used_cluster_mask_start); lba = _spdk_bs_page_to_lba(ctx->bs, ctx->super->used_cluster_mask_start);
lba_count = _spdk_bs_page_to_lba(ctx->bs, ctx->super->used_cluster_mask_len); lba_count = _spdk_bs_page_to_lba(ctx->bs, ctx->super->used_cluster_mask_len);
spdk_bs_sequence_read_dev(seq, ctx->mask, lba, lba_count, bs_sequence_read_dev(seq, ctx->mask, lba, lba_count,
_spdk_bs_load_used_clusters_cpl, ctx); _spdk_bs_load_used_clusters_cpl, ctx);
} }
static void static void
@ -3636,8 +3636,8 @@ _spdk_bs_load_read_used_pages(struct spdk_bs_load_ctx *ctx)
lba = _spdk_bs_page_to_lba(ctx->bs, ctx->super->used_page_mask_start); lba = _spdk_bs_page_to_lba(ctx->bs, ctx->super->used_page_mask_start);
lba_count = _spdk_bs_page_to_lba(ctx->bs, ctx->super->used_page_mask_len); lba_count = _spdk_bs_page_to_lba(ctx->bs, ctx->super->used_page_mask_len);
spdk_bs_sequence_read_dev(ctx->seq, ctx->mask, lba, lba_count, bs_sequence_read_dev(ctx->seq, ctx->mask, lba, lba_count,
_spdk_bs_load_used_pages_cpl, ctx); _spdk_bs_load_used_pages_cpl, ctx);
} }
static int static int
@ -3973,17 +3973,17 @@ _spdk_bs_load_replay_extent_pages(struct spdk_bs_load_ctx *ctx)
return; return;
} }
batch = spdk_bs_sequence_to_batch(ctx->seq, _spdk_bs_load_replay_extent_page_cpl, ctx); batch = bs_sequence_to_batch(ctx->seq, _spdk_bs_load_replay_extent_page_cpl, ctx);
for (i = 0; i < ctx->num_extent_pages; i++) { for (i = 0; i < ctx->num_extent_pages; i++) {
page = ctx->extent_page_num[i]; page = ctx->extent_page_num[i];
assert(page < ctx->super->md_len); assert(page < ctx->super->md_len);
lba = _spdk_bs_md_page_to_lba(ctx->bs, page); lba = _spdk_bs_md_page_to_lba(ctx->bs, page);
spdk_bs_batch_read_dev(batch, &ctx->extent_pages[i], lba, bs_batch_read_dev(batch, &ctx->extent_pages[i], lba,
_spdk_bs_byte_to_lba(ctx->bs, SPDK_BS_PAGE_SIZE)); _spdk_bs_byte_to_lba(ctx->bs, SPDK_BS_PAGE_SIZE));
} }
spdk_bs_batch_close(batch); bs_batch_close(batch);
} }
static void static void
@ -4032,9 +4032,9 @@ _spdk_bs_load_replay_cur_md_page(struct spdk_bs_load_ctx *ctx)
assert(ctx->cur_page < ctx->super->md_len); assert(ctx->cur_page < ctx->super->md_len);
lba = _spdk_bs_md_page_to_lba(ctx->bs, ctx->cur_page); lba = _spdk_bs_md_page_to_lba(ctx->bs, ctx->cur_page);
spdk_bs_sequence_read_dev(ctx->seq, ctx->page, lba, bs_sequence_read_dev(ctx->seq, ctx->page, lba,
_spdk_bs_byte_to_lba(ctx->bs, SPDK_BS_PAGE_SIZE), _spdk_bs_byte_to_lba(ctx->bs, SPDK_BS_PAGE_SIZE),
_spdk_bs_load_replay_md_cpl, ctx); _spdk_bs_load_replay_md_cpl, ctx);
} }
static void static void
@ -4220,7 +4220,7 @@ spdk_bs_load(struct spdk_bs_dev *dev, struct spdk_bs_opts *o,
cpl.u.bs_handle.cb_arg = cb_arg; cpl.u.bs_handle.cb_arg = cb_arg;
cpl.u.bs_handle.bs = bs; cpl.u.bs_handle.bs = bs;
ctx->seq = spdk_bs_sequence_start(bs->md_channel, &cpl); ctx->seq = bs_sequence_start(bs->md_channel, &cpl);
if (!ctx->seq) { if (!ctx->seq) {
spdk_free(ctx->super); spdk_free(ctx->super);
free(ctx); free(ctx);
@ -4230,9 +4230,9 @@ spdk_bs_load(struct spdk_bs_dev *dev, struct spdk_bs_opts *o,
} }
/* Read the super block */ /* Read the super block */
spdk_bs_sequence_read_dev(ctx->seq, ctx->super, _spdk_bs_page_to_lba(bs, 0), bs_sequence_read_dev(ctx->seq, ctx->super, _spdk_bs_page_to_lba(bs, 0),
_spdk_bs_byte_to_lba(bs, sizeof(*ctx->super)), _spdk_bs_byte_to_lba(bs, sizeof(*ctx->super)),
_spdk_bs_load_super_cpl, ctx); _spdk_bs_load_super_cpl, ctx);
} }
/* END spdk_bs_load */ /* END spdk_bs_load */
@ -4256,14 +4256,14 @@ _spdk_bs_dump_finish(spdk_bs_sequence_t *seq, struct spdk_bs_dump_ctx *ctx, int
spdk_free(ctx->super); spdk_free(ctx->super);
/* /*
* We need to defer calling spdk_bs_call_cpl() until after * We need to defer calling bs_call_cpl() until after
* dev destruction, so tuck these away for later use. * dev destruction, so tuck these away for later use.
*/ */
ctx->bs->unload_err = bserrno; ctx->bs->unload_err = bserrno;
memcpy(&ctx->bs->unload_cpl, &seq->cpl, sizeof(struct spdk_bs_cpl)); memcpy(&ctx->bs->unload_cpl, &seq->cpl, sizeof(struct spdk_bs_cpl));
seq->cpl.type = SPDK_BS_CPL_TYPE_NONE; seq->cpl.type = SPDK_BS_CPL_TYPE_NONE;
spdk_bs_sequence_finish(seq, 0); bs_sequence_finish(seq, 0);
_spdk_bs_free(ctx->bs); _spdk_bs_free(ctx->bs);
free(ctx); free(ctx);
} }
@ -4403,9 +4403,9 @@ _spdk_bs_dump_read_md_page(spdk_bs_sequence_t *seq, void *cb_arg)
assert(ctx->cur_page < ctx->super->md_len); assert(ctx->cur_page < ctx->super->md_len);
lba = _spdk_bs_page_to_lba(ctx->bs, ctx->super->md_start + ctx->cur_page); lba = _spdk_bs_page_to_lba(ctx->bs, ctx->super->md_start + ctx->cur_page);
spdk_bs_sequence_read_dev(seq, ctx->page, lba, bs_sequence_read_dev(seq, ctx->page, lba,
_spdk_bs_byte_to_lba(ctx->bs, SPDK_BS_PAGE_SIZE), _spdk_bs_byte_to_lba(ctx->bs, SPDK_BS_PAGE_SIZE),
_spdk_bs_dump_read_md_page_cpl, ctx); _spdk_bs_dump_read_md_page_cpl, ctx);
} }
static void static void
@ -4500,7 +4500,7 @@ spdk_bs_dump(struct spdk_bs_dev *dev, FILE *fp, spdk_bs_dump_print_xattr print_x
cpl.u.bs_basic.cb_fn = cb_fn; cpl.u.bs_basic.cb_fn = cb_fn;
cpl.u.bs_basic.cb_arg = cb_arg; cpl.u.bs_basic.cb_arg = cb_arg;
seq = spdk_bs_sequence_start(bs->md_channel, &cpl); seq = bs_sequence_start(bs->md_channel, &cpl);
if (!seq) { if (!seq) {
spdk_free(ctx->super); spdk_free(ctx->super);
free(ctx); free(ctx);
@ -4510,9 +4510,9 @@ spdk_bs_dump(struct spdk_bs_dev *dev, FILE *fp, spdk_bs_dump_print_xattr print_x
} }
/* Read the super block */ /* Read the super block */
spdk_bs_sequence_read_dev(seq, ctx->super, _spdk_bs_page_to_lba(bs, 0), bs_sequence_read_dev(seq, ctx->super, _spdk_bs_page_to_lba(bs, 0),
_spdk_bs_byte_to_lba(bs, sizeof(*ctx->super)), _spdk_bs_byte_to_lba(bs, sizeof(*ctx->super)),
_spdk_bs_dump_super_cpl, ctx); _spdk_bs_dump_super_cpl, ctx);
} }
/* END spdk_bs_dump */ /* END spdk_bs_dump */
@ -4532,7 +4532,7 @@ _spdk_bs_init_persist_super_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserr
spdk_free(ctx->super); spdk_free(ctx->super);
free(ctx); free(ctx);
spdk_bs_sequence_finish(seq, bserrno); bs_sequence_finish(seq, bserrno);
} }
static void static void
@ -4541,9 +4541,9 @@ _spdk_bs_init_trim_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
struct spdk_bs_init_ctx *ctx = cb_arg; struct spdk_bs_init_ctx *ctx = cb_arg;
/* Write super block */ /* Write super block */
spdk_bs_sequence_write_dev(seq, ctx->super, _spdk_bs_page_to_lba(ctx->bs, 0), bs_sequence_write_dev(seq, ctx->super, _spdk_bs_page_to_lba(ctx->bs, 0),
_spdk_bs_byte_to_lba(ctx->bs, sizeof(*ctx->super)), _spdk_bs_byte_to_lba(ctx->bs, sizeof(*ctx->super)),
_spdk_bs_init_persist_super_cpl, ctx); _spdk_bs_init_persist_super_cpl, ctx);
} }
void void
@ -4712,7 +4712,7 @@ spdk_bs_init(struct spdk_bs_dev *dev, struct spdk_bs_opts *o,
cpl.u.bs_handle.cb_arg = cb_arg; cpl.u.bs_handle.cb_arg = cb_arg;
cpl.u.bs_handle.bs = bs; cpl.u.bs_handle.bs = bs;
seq = spdk_bs_sequence_start(bs->md_channel, &cpl); seq = bs_sequence_start(bs->md_channel, &cpl);
if (!seq) { if (!seq) {
spdk_free(ctx->super); spdk_free(ctx->super);
free(ctx); free(ctx);
@ -4721,26 +4721,26 @@ spdk_bs_init(struct spdk_bs_dev *dev, struct spdk_bs_opts *o,
return; return;
} }
batch = spdk_bs_sequence_to_batch(seq, _spdk_bs_init_trim_cpl, ctx); batch = bs_sequence_to_batch(seq, _spdk_bs_init_trim_cpl, ctx);
/* Clear metadata space */ /* Clear metadata space */
spdk_bs_batch_write_zeroes_dev(batch, 0, num_md_lba); bs_batch_write_zeroes_dev(batch, 0, num_md_lba);
switch (opts.clear_method) { switch (opts.clear_method) {
case BS_CLEAR_WITH_UNMAP: case BS_CLEAR_WITH_UNMAP:
/* Trim data clusters */ /* Trim data clusters */
spdk_bs_batch_unmap_dev(batch, num_md_lba, ctx->bs->dev->blockcnt - num_md_lba); bs_batch_unmap_dev(batch, num_md_lba, ctx->bs->dev->blockcnt - num_md_lba);
break; break;
case BS_CLEAR_WITH_WRITE_ZEROES: case BS_CLEAR_WITH_WRITE_ZEROES:
/* Write_zeroes to data clusters */ /* Write_zeroes to data clusters */
spdk_bs_batch_write_zeroes_dev(batch, num_md_lba, ctx->bs->dev->blockcnt - num_md_lba); bs_batch_write_zeroes_dev(batch, num_md_lba, ctx->bs->dev->blockcnt - num_md_lba);
break; break;
case BS_CLEAR_WITH_NONE: case BS_CLEAR_WITH_NONE:
default: default:
break; break;
} }
spdk_bs_batch_close(batch); bs_batch_close(batch);
} }
/* END spdk_bs_init */ /* END spdk_bs_init */
@ -4754,14 +4754,14 @@ _spdk_bs_destroy_trim_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
struct spdk_blob_store *bs = ctx->bs; struct spdk_blob_store *bs = ctx->bs;
/* /*
* We need to defer calling spdk_bs_call_cpl() until after * We need to defer calling bs_call_cpl() until after
* dev destruction, so tuck these away for later use. * dev destruction, so tuck these away for later use.
*/ */
bs->unload_err = bserrno; bs->unload_err = bserrno;
memcpy(&bs->unload_cpl, &seq->cpl, sizeof(struct spdk_bs_cpl)); memcpy(&bs->unload_cpl, &seq->cpl, sizeof(struct spdk_bs_cpl));
seq->cpl.type = SPDK_BS_CPL_TYPE_NONE; seq->cpl.type = SPDK_BS_CPL_TYPE_NONE;
spdk_bs_sequence_finish(seq, bserrno); bs_sequence_finish(seq, bserrno);
_spdk_bs_free(bs); _spdk_bs_free(bs);
free(ctx); free(ctx);
@ -4795,7 +4795,7 @@ spdk_bs_destroy(struct spdk_blob_store *bs, spdk_bs_op_complete cb_fn,
ctx->bs = bs; ctx->bs = bs;
seq = spdk_bs_sequence_start(bs->md_channel, &cpl); seq = bs_sequence_start(bs->md_channel, &cpl);
if (!seq) { if (!seq) {
free(ctx); free(ctx);
cb_fn(cb_arg, -ENOMEM); cb_fn(cb_arg, -ENOMEM);
@ -4803,10 +4803,10 @@ spdk_bs_destroy(struct spdk_blob_store *bs, spdk_bs_op_complete cb_fn,
} }
/* Write zeroes to the super block */ /* Write zeroes to the super block */
spdk_bs_sequence_write_zeroes_dev(seq, bs_sequence_write_zeroes_dev(seq,
_spdk_bs_page_to_lba(bs, 0), _spdk_bs_page_to_lba(bs, 0),
_spdk_bs_byte_to_lba(bs, sizeof(struct spdk_bs_super_block)), _spdk_bs_byte_to_lba(bs, sizeof(struct spdk_bs_super_block)),
_spdk_bs_destroy_trim_cpl, ctx); _spdk_bs_destroy_trim_cpl, ctx);
} }
/* END spdk_bs_destroy */ /* END spdk_bs_destroy */
@ -4821,14 +4821,14 @@ _spdk_bs_unload_finish(struct spdk_bs_load_ctx *ctx, int bserrno)
spdk_free(ctx->super); spdk_free(ctx->super);
/* /*
* We need to defer calling spdk_bs_call_cpl() until after * We need to defer calling bs_call_cpl() until after
* dev destruction, so tuck these away for later use. * dev destruction, so tuck these away for later use.
*/ */
ctx->bs->unload_err = bserrno; ctx->bs->unload_err = bserrno;
memcpy(&ctx->bs->unload_cpl, &seq->cpl, sizeof(struct spdk_bs_cpl)); memcpy(&ctx->bs->unload_cpl, &seq->cpl, sizeof(struct spdk_bs_cpl));
seq->cpl.type = SPDK_BS_CPL_TYPE_NONE; seq->cpl.type = SPDK_BS_CPL_TYPE_NONE;
spdk_bs_sequence_finish(seq, bserrno); bs_sequence_finish(seq, bserrno);
_spdk_bs_free(ctx->bs); _spdk_bs_free(ctx->bs);
free(ctx); free(ctx);
@ -4938,7 +4938,7 @@ spdk_bs_unload(struct spdk_blob_store *bs, spdk_bs_op_complete cb_fn, void *cb_a
cpl.u.bs_basic.cb_fn = cb_fn; cpl.u.bs_basic.cb_fn = cb_fn;
cpl.u.bs_basic.cb_arg = cb_arg; cpl.u.bs_basic.cb_arg = cb_arg;
ctx->seq = spdk_bs_sequence_start(bs->md_channel, &cpl); ctx->seq = bs_sequence_start(bs->md_channel, &cpl);
if (!ctx->seq) { if (!ctx->seq) {
spdk_free(ctx->super); spdk_free(ctx->super);
free(ctx); free(ctx);
@ -4947,9 +4947,9 @@ spdk_bs_unload(struct spdk_blob_store *bs, spdk_bs_op_complete cb_fn, void *cb_a
} }
/* Read super block */ /* Read super block */
spdk_bs_sequence_read_dev(ctx->seq, ctx->super, _spdk_bs_page_to_lba(bs, 0), bs_sequence_read_dev(ctx->seq, ctx->super, _spdk_bs_page_to_lba(bs, 0),
_spdk_bs_byte_to_lba(bs, sizeof(*ctx->super)), _spdk_bs_byte_to_lba(bs, sizeof(*ctx->super)),
_spdk_bs_unload_read_super_cpl, ctx); _spdk_bs_unload_read_super_cpl, ctx);
} }
/* END spdk_bs_unload */ /* END spdk_bs_unload */
@ -4972,7 +4972,7 @@ _spdk_bs_set_super_write_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
spdk_free(ctx->super); spdk_free(ctx->super);
spdk_bs_sequence_finish(seq, bserrno); bs_sequence_finish(seq, bserrno);
free(ctx); free(ctx);
} }
@ -4985,7 +4985,7 @@ _spdk_bs_set_super_read_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
if (bserrno != 0) { if (bserrno != 0) {
SPDK_ERRLOG("Unable to read super block of blobstore\n"); SPDK_ERRLOG("Unable to read super block of blobstore\n");
spdk_free(ctx->super); spdk_free(ctx->super);
spdk_bs_sequence_finish(seq, bserrno); bs_sequence_finish(seq, bserrno);
free(ctx); free(ctx);
return; return;
} }
@ -5023,7 +5023,7 @@ spdk_bs_set_super(struct spdk_blob_store *bs, spdk_blob_id blobid,
cpl.u.bs_basic.cb_fn = cb_fn; cpl.u.bs_basic.cb_fn = cb_fn;
cpl.u.bs_basic.cb_arg = cb_arg; cpl.u.bs_basic.cb_arg = cb_arg;
seq = spdk_bs_sequence_start(bs->md_channel, &cpl); seq = bs_sequence_start(bs->md_channel, &cpl);
if (!seq) { if (!seq) {
spdk_free(ctx->super); spdk_free(ctx->super);
free(ctx); free(ctx);
@ -5034,9 +5034,9 @@ spdk_bs_set_super(struct spdk_blob_store *bs, spdk_blob_id blobid,
bs->super_blob = blobid; bs->super_blob = blobid;
/* Read super block */ /* Read super block */
spdk_bs_sequence_read_dev(seq, ctx->super, _spdk_bs_page_to_lba(bs, 0), bs_sequence_read_dev(seq, ctx->super, _spdk_bs_page_to_lba(bs, 0),
_spdk_bs_byte_to_lba(bs, sizeof(*ctx->super)), _spdk_bs_byte_to_lba(bs, sizeof(*ctx->super)),
_spdk_bs_set_super_read_cpl, ctx); _spdk_bs_set_super_read_cpl, ctx);
} }
/* END spdk_bs_set_super */ /* END spdk_bs_set_super */
@ -5139,7 +5139,7 @@ _spdk_bs_create_blob_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
_spdk_blob_free(blob); _spdk_blob_free(blob);
spdk_bs_sequence_finish(seq, bserrno); bs_sequence_finish(seq, bserrno);
} }
static int static int
@ -5247,7 +5247,7 @@ _spdk_bs_create_blob(struct spdk_blob_store *bs,
cpl.u.blobid.cb_arg = cb_arg; cpl.u.blobid.cb_arg = cb_arg;
cpl.u.blobid.blobid = blob->id; cpl.u.blobid.blobid = blob->id;
seq = spdk_bs_sequence_start(bs->md_channel, &cpl); seq = bs_sequence_start(bs->md_channel, &cpl);
if (!seq) { if (!seq) {
_spdk_blob_free(blob); _spdk_blob_free(blob);
cb_fn(cb_arg, 0, -ENOMEM); cb_fn(cb_arg, 0, -ENOMEM);
@ -5475,7 +5475,7 @@ _spdk_bs_snapshot_newblob_sync_cpl(void *cb_arg, int bserrno)
origblob->parent_id = newblob->id; origblob->parent_id = newblob->id;
/* Create new back_bs_dev for snapshot */ /* Create new back_bs_dev for snapshot */
origblob->back_bs_dev = spdk_bs_create_blob_bs_dev(newblob); origblob->back_bs_dev = bs_create_blob_bs_dev(newblob);
if (origblob->back_bs_dev == NULL) { if (origblob->back_bs_dev == NULL) {
/* return cluster map back to original */ /* return cluster map back to original */
_spdk_bs_snapshot_swap_cluster_maps(newblob, origblob); _spdk_bs_snapshot_swap_cluster_maps(newblob, origblob);
@ -5793,7 +5793,7 @@ _spdk_bs_inflate_blob_set_parent_cpl(void *cb_arg, struct spdk_blob *_parent, in
sizeof(spdk_blob_id), true); sizeof(spdk_blob_id), true);
_blob->back_bs_dev->destroy(_blob->back_bs_dev); _blob->back_bs_dev->destroy(_blob->back_bs_dev);
_blob->back_bs_dev = spdk_bs_create_blob_bs_dev(_parent); _blob->back_bs_dev = bs_create_blob_bs_dev(_parent);
_spdk_bs_blob_list_add(_blob); _spdk_bs_blob_list_add(_blob);
spdk_blob_sync_md(_blob, _spdk_bs_clone_snapshot_origblob_cleanup, ctx); spdk_blob_sync_md(_blob, _spdk_bs_clone_snapshot_origblob_cleanup, ctx);
@ -5832,7 +5832,7 @@ _spdk_bs_inflate_blob_done(void *cb_arg, int bserrno)
_spdk_blob_remove_xattr(_blob, BLOB_SNAPSHOT, true); _spdk_blob_remove_xattr(_blob, BLOB_SNAPSHOT, true);
_blob->parent_id = SPDK_BLOBID_INVALID; _blob->parent_id = SPDK_BLOBID_INVALID;
_blob->back_bs_dev->destroy(_blob->back_bs_dev); _blob->back_bs_dev->destroy(_blob->back_bs_dev);
_blob->back_bs_dev = spdk_bs_create_zeroes_dev(); _blob->back_bs_dev = bs_create_zeroes_dev();
} }
_blob->state = SPDK_BLOB_STATE_DIRTY; _blob->state = SPDK_BLOB_STATE_DIRTY;
@ -6079,7 +6079,7 @@ _spdk_bs_delete_close_cpl(void *cb_arg, int bserrno)
{ {
spdk_bs_sequence_t *seq = cb_arg; spdk_bs_sequence_t *seq = cb_arg;
spdk_bs_sequence_finish(seq, bserrno); bs_sequence_finish(seq, bserrno);
} }
static void static void
@ -6329,7 +6329,7 @@ _spdk_delete_snapshot_sync_snapshot_xattr_cpl(void *cb_arg, int bserrno)
} else { } else {
/* ...to blobid invalid and zeroes dev */ /* ...to blobid invalid and zeroes dev */
ctx->clone->parent_id = SPDK_BLOBID_INVALID; ctx->clone->parent_id = SPDK_BLOBID_INVALID;
ctx->clone->back_bs_dev = spdk_bs_create_zeroes_dev(); ctx->clone->back_bs_dev = bs_create_zeroes_dev();
_spdk_blob_remove_xattr(ctx->clone, BLOB_SNAPSHOT, true); _spdk_blob_remove_xattr(ctx->clone, BLOB_SNAPSHOT, true);
} }
@ -6423,7 +6423,7 @@ _spdk_bs_delete_blob_finish(void *cb_arg, struct spdk_blob *blob, int bserrno)
if (bserrno) { if (bserrno) {
SPDK_ERRLOG("Failed to remove blob\n"); SPDK_ERRLOG("Failed to remove blob\n");
spdk_bs_sequence_finish(seq, bserrno); bs_sequence_finish(seq, bserrno);
return; return;
} }
@ -6496,7 +6496,7 @@ _spdk_bs_delete_enomem_close_cpl(void *cb_arg, int bserrno)
{ {
spdk_bs_sequence_t *seq = cb_arg; spdk_bs_sequence_t *seq = cb_arg;
spdk_bs_sequence_finish(seq, -ENOMEM); bs_sequence_finish(seq, -ENOMEM);
} }
static void static void
@ -6507,7 +6507,7 @@ _spdk_bs_delete_open_cpl(void *cb_arg, struct spdk_blob *blob, int bserrno)
bool update_clone = false; bool update_clone = false;
if (bserrno != 0) { if (bserrno != 0) {
spdk_bs_sequence_finish(seq, bserrno); bs_sequence_finish(seq, bserrno);
return; return;
} }
@ -6571,7 +6571,7 @@ spdk_bs_delete_blob(struct spdk_blob_store *bs, spdk_blob_id blobid,
cpl.u.blob_basic.cb_fn = cb_fn; cpl.u.blob_basic.cb_fn = cb_fn;
cpl.u.blob_basic.cb_arg = cb_arg; cpl.u.blob_basic.cb_arg = cb_arg;
seq = spdk_bs_sequence_start(bs->md_channel, &cpl); seq = bs_sequence_start(bs->md_channel, &cpl);
if (!seq) { if (!seq) {
cb_fn(cb_arg, -ENOMEM); cb_fn(cb_arg, -ENOMEM);
return; return;
@ -6592,7 +6592,7 @@ _spdk_bs_open_blob_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
if (bserrno != 0) { if (bserrno != 0) {
_spdk_blob_free(blob); _spdk_blob_free(blob);
seq->cpl.u.blob_handle.blob = NULL; seq->cpl.u.blob_handle.blob = NULL;
spdk_bs_sequence_finish(seq, bserrno); bs_sequence_finish(seq, bserrno);
return; return;
} }
@ -6600,7 +6600,7 @@ _spdk_bs_open_blob_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
TAILQ_INSERT_HEAD(&blob->bs->blobs, blob, link); TAILQ_INSERT_HEAD(&blob->bs->blobs, blob, link);
spdk_bs_sequence_finish(seq, bserrno); bs_sequence_finish(seq, bserrno);
} }
static void _spdk_bs_open_blob(struct spdk_blob_store *bs, spdk_blob_id blobid, static void _spdk_bs_open_blob(struct spdk_blob_store *bs, spdk_blob_id blobid,
@ -6647,7 +6647,7 @@ static void _spdk_bs_open_blob(struct spdk_blob_store *bs, spdk_blob_id blobid,
cpl.u.blob_handle.cb_arg = cb_arg; cpl.u.blob_handle.cb_arg = cb_arg;
cpl.u.blob_handle.blob = blob; cpl.u.blob_handle.blob = blob;
seq = spdk_bs_sequence_start(bs->md_channel, &cpl); seq = bs_sequence_start(bs->md_channel, &cpl);
if (!seq) { if (!seq) {
_spdk_blob_free(blob); _spdk_blob_free(blob);
cb_fn(cb_arg, NULL, -ENOMEM); cb_fn(cb_arg, NULL, -ENOMEM);
@ -6695,7 +6695,7 @@ _spdk_blob_sync_md_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
blob->md_ro = true; blob->md_ro = true;
} }
spdk_bs_sequence_finish(seq, bserrno); bs_sequence_finish(seq, bserrno);
} }
static void static void
@ -6708,7 +6708,7 @@ _spdk_blob_sync_md(struct spdk_blob *blob, spdk_blob_op_complete cb_fn, void *cb
cpl.u.blob_basic.cb_fn = cb_fn; cpl.u.blob_basic.cb_fn = cb_fn;
cpl.u.blob_basic.cb_arg = cb_arg; cpl.u.blob_basic.cb_arg = cb_arg;
seq = spdk_bs_sequence_start(blob->bs->md_channel, &cpl); seq = bs_sequence_start(blob->bs->md_channel, &cpl);
if (!seq) { if (!seq) {
cb_fn(cb_arg, -ENOMEM); cb_fn(cb_arg, -ENOMEM);
return; return;
@ -6769,7 +6769,7 @@ _spdk_blob_persist_extent_page_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bs
{ {
struct spdk_blob_md_page *page = cb_arg; struct spdk_blob_md_page *page = cb_arg;
spdk_bs_sequence_finish(seq, bserrno); bs_sequence_finish(seq, bserrno);
spdk_free(page); spdk_free(page);
} }
@ -6787,14 +6787,14 @@ _spdk_blob_insert_extent(struct spdk_blob *blob, uint32_t extent, uint64_t clust
cpl.u.blob_basic.cb_fn = cb_fn; cpl.u.blob_basic.cb_fn = cb_fn;
cpl.u.blob_basic.cb_arg = cb_arg; cpl.u.blob_basic.cb_arg = cb_arg;
seq = spdk_bs_sequence_start(blob->bs->md_channel, &cpl); seq = bs_sequence_start(blob->bs->md_channel, &cpl);
if (!seq) { if (!seq) {
cb_fn(cb_arg, -ENOMEM); cb_fn(cb_arg, -ENOMEM);
return; return;
} }
rc = _spdk_blob_serialize_add_page(blob, &page, &page_count, &page); rc = _spdk_blob_serialize_add_page(blob, &page, &page_count, &page);
if (rc < 0) { if (rc < 0) {
spdk_bs_sequence_finish(seq, rc); bs_sequence_finish(seq, rc);
return; return;
} }
@ -6804,9 +6804,9 @@ _spdk_blob_insert_extent(struct spdk_blob *blob, uint32_t extent, uint64_t clust
assert(spdk_bit_array_get(blob->bs->used_md_pages, extent) == true); assert(spdk_bit_array_get(blob->bs->used_md_pages, extent) == true);
spdk_bs_sequence_write_dev(seq, page, _spdk_bs_md_page_to_lba(blob->bs, extent), bs_sequence_write_dev(seq, page, _spdk_bs_md_page_to_lba(blob->bs, extent),
_spdk_bs_byte_to_lba(blob->bs, SPDK_BS_PAGE_SIZE), _spdk_bs_byte_to_lba(blob->bs, SPDK_BS_PAGE_SIZE),
_spdk_blob_persist_extent_page_cpl, page); _spdk_blob_persist_extent_page_cpl, page);
} }
static void static void
@ -6899,7 +6899,7 @@ _spdk_blob_close_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
} }
} }
spdk_bs_sequence_finish(seq, bserrno); bs_sequence_finish(seq, bserrno);
} }
void spdk_blob_close(struct spdk_blob *blob, spdk_blob_op_complete cb_fn, void *cb_arg) void spdk_blob_close(struct spdk_blob *blob, spdk_blob_op_complete cb_fn, void *cb_arg)
@ -6920,7 +6920,7 @@ void spdk_blob_close(struct spdk_blob *blob, spdk_blob_op_complete cb_fn, void *
cpl.u.blob_basic.cb_fn = cb_fn; cpl.u.blob_basic.cb_fn = cb_fn;
cpl.u.blob_basic.cb_arg = cb_arg; cpl.u.blob_basic.cb_arg = cb_arg;
seq = spdk_bs_sequence_start(blob->bs->md_channel, &cpl); seq = bs_sequence_start(blob->bs->md_channel, &cpl);
if (!seq) { if (!seq) {
cb_fn(cb_arg, -ENOMEM); cb_fn(cb_arg, -ENOMEM);
return; return;

4
lib/blob/blobstore.h
View File

@ -431,8 +431,8 @@ SPDK_STATIC_ASSERT(sizeof(struct spdk_bs_super_block) == 0x1000, "Invalid super
#pragma pack(pop) #pragma pack(pop)
struct spdk_bs_dev *spdk_bs_create_zeroes_dev(void); struct spdk_bs_dev *bs_create_zeroes_dev(void);
struct spdk_bs_dev *spdk_bs_create_blob_bs_dev(struct spdk_blob *blob); struct spdk_bs_dev *bs_create_blob_bs_dev(struct spdk_blob *blob);
/* Unit Conversions /* Unit Conversions
* *

92
lib/blob/request.c
View File

@ -42,7 +42,7 @@
#include "spdk_internal/log.h" #include "spdk_internal/log.h"
void void
spdk_bs_call_cpl(struct spdk_bs_cpl *cpl, int bserrno) bs_call_cpl(struct spdk_bs_cpl *cpl, int bserrno)
{ {
switch (cpl->type) { switch (cpl->type) {
case SPDK_BS_CPL_TYPE_BS_BASIC: case SPDK_BS_CPL_TYPE_BS_BASIC:
@ -87,7 +87,7 @@ spdk_bs_request_set_complete(struct spdk_bs_request_set *set)
TAILQ_INSERT_TAIL(&set->channel->reqs, set, link); TAILQ_INSERT_TAIL(&set->channel->reqs, set, link);
spdk_bs_call_cpl(&cpl, bserrno); bs_call_cpl(&cpl, bserrno);
} }
static void static void
@ -100,8 +100,8 @@ spdk_bs_sequence_completion(struct spdk_io_channel *channel, void *cb_arg, int b
} }
spdk_bs_sequence_t * spdk_bs_sequence_t *
spdk_bs_sequence_start(struct spdk_io_channel *_channel, bs_sequence_start(struct spdk_io_channel *_channel,
struct spdk_bs_cpl *cpl) struct spdk_bs_cpl *cpl)
{ {
struct spdk_bs_channel *channel; struct spdk_bs_channel *channel;
struct spdk_bs_request_set *set; struct spdk_bs_request_set *set;
@ -126,9 +126,9 @@ spdk_bs_sequence_start(struct spdk_io_channel *_channel,
} }
void void
spdk_bs_sequence_read_bs_dev(spdk_bs_sequence_t *seq, struct spdk_bs_dev *bs_dev, bs_sequence_read_bs_dev(spdk_bs_sequence_t *seq, struct spdk_bs_dev *bs_dev,
void *payload, uint64_t lba, uint32_t lba_count, void *payload, uint64_t lba, uint32_t lba_count,
spdk_bs_sequence_cpl cb_fn, void *cb_arg) spdk_bs_sequence_cpl cb_fn, void *cb_arg)
{ {
struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)seq; struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)seq;
struct spdk_bs_channel *channel = set->channel; struct spdk_bs_channel *channel = set->channel;
@ -143,9 +143,9 @@ spdk_bs_sequence_read_bs_dev(spdk_bs_sequence_t *seq, struct spdk_bs_dev *bs_dev
} }
void void
spdk_bs_sequence_read_dev(spdk_bs_sequence_t *seq, void *payload, bs_sequence_read_dev(spdk_bs_sequence_t *seq, void *payload,
uint64_t lba, uint32_t lba_count, uint64_t lba, uint32_t lba_count,
spdk_bs_sequence_cpl cb_fn, void *cb_arg) spdk_bs_sequence_cpl cb_fn, void *cb_arg)
{ {
struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)seq; struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)seq;
struct spdk_bs_channel *channel = set->channel; struct spdk_bs_channel *channel = set->channel;
@ -160,9 +160,9 @@ spdk_bs_sequence_read_dev(spdk_bs_sequence_t *seq, void *payload,
} }
void void
spdk_bs_sequence_write_dev(spdk_bs_sequence_t *seq, void *payload, bs_sequence_write_dev(spdk_bs_sequence_t *seq, void *payload,
uint64_t lba, uint32_t lba_count, uint64_t lba, uint32_t lba_count,
spdk_bs_sequence_cpl cb_fn, void *cb_arg) spdk_bs_sequence_cpl cb_fn, void *cb_arg)
{ {
struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)seq; struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)seq;
struct spdk_bs_channel *channel = set->channel; struct spdk_bs_channel *channel = set->channel;
@ -178,9 +178,9 @@ spdk_bs_sequence_write_dev(spdk_bs_sequence_t *seq, void *payload,
} }
void void
spdk_bs_sequence_readv_bs_dev(spdk_bs_sequence_t *seq, struct spdk_bs_dev *bs_dev, bs_sequence_readv_bs_dev(spdk_bs_sequence_t *seq, struct spdk_bs_dev *bs_dev,
struct iovec *iov, int iovcnt, uint64_t lba, uint32_t lba_count, struct iovec *iov, int iovcnt, uint64_t lba, uint32_t lba_count,
spdk_bs_sequence_cpl cb_fn, void *cb_arg) spdk_bs_sequence_cpl cb_fn, void *cb_arg)
{ {
struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)seq; struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)seq;
struct spdk_bs_channel *channel = set->channel; struct spdk_bs_channel *channel = set->channel;
@ -196,8 +196,8 @@ spdk_bs_sequence_readv_bs_dev(spdk_bs_sequence_t *seq, struct spdk_bs_dev *bs_de
} }
void void
spdk_bs_sequence_readv_dev(spdk_bs_sequence_t *seq, struct iovec *iov, int iovcnt, bs_sequence_readv_dev(spdk_bs_sequence_t *seq, struct iovec *iov, int iovcnt,
uint64_t lba, uint32_t lba_count, spdk_bs_sequence_cpl cb_fn, void *cb_arg) uint64_t lba, uint32_t lba_count, spdk_bs_sequence_cpl cb_fn, void *cb_arg)
{ {
struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)seq; struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)seq;
struct spdk_bs_channel *channel = set->channel; struct spdk_bs_channel *channel = set->channel;
@ -212,9 +212,9 @@ spdk_bs_sequence_readv_dev(spdk_bs_sequence_t *seq, struct iovec *iov, int iovcn
} }
void void
spdk_bs_sequence_writev_dev(spdk_bs_sequence_t *seq, struct iovec *iov, int iovcnt, bs_sequence_writev_dev(spdk_bs_sequence_t *seq, struct iovec *iov, int iovcnt,
uint64_t lba, uint32_t lba_count, uint64_t lba, uint32_t lba_count,
spdk_bs_sequence_cpl cb_fn, void *cb_arg) spdk_bs_sequence_cpl cb_fn, void *cb_arg)
{ {
struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)seq; struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)seq;
struct spdk_bs_channel *channel = set->channel; struct spdk_bs_channel *channel = set->channel;
@ -248,9 +248,9 @@ spdk_bs_sequence_unmap_dev(spdk_bs_sequence_t *seq,
} }
void void
spdk_bs_sequence_write_zeroes_dev(spdk_bs_sequence_t *seq, bs_sequence_write_zeroes_dev(spdk_bs_sequence_t *seq,
uint64_t lba, uint32_t lba_count, uint64_t lba, uint32_t lba_count,
spdk_bs_sequence_cpl cb_fn, void *cb_arg) spdk_bs_sequence_cpl cb_fn, void *cb_arg)
{ {
struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)seq; struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)seq;
struct spdk_bs_channel *channel = set->channel; struct spdk_bs_channel *channel = set->channel;
@ -266,7 +266,7 @@ spdk_bs_sequence_write_zeroes_dev(spdk_bs_sequence_t *seq,
} }
void void
spdk_bs_sequence_finish(spdk_bs_sequence_t *seq, int bserrno) bs_sequence_finish(spdk_bs_sequence_t *seq, int bserrno)
{ {
if (bserrno != 0) { if (bserrno != 0) {
seq->bserrno = bserrno; seq->bserrno = bserrno;
@ -275,11 +275,11 @@ spdk_bs_sequence_finish(spdk_bs_sequence_t *seq, int bserrno)
} }
void void
spdk_bs_user_op_sequence_finish(void *cb_arg, int bserrno) bs_user_op_sequence_finish(void *cb_arg, int bserrno)
{ {
spdk_bs_sequence_t *seq = cb_arg; spdk_bs_sequence_t *seq = cb_arg;
spdk_bs_sequence_finish(seq, bserrno); bs_sequence_finish(seq, bserrno);
} }
static void static void
@ -304,8 +304,8 @@ spdk_bs_batch_completion(struct spdk_io_channel *_channel,
} }
spdk_bs_batch_t * spdk_bs_batch_t *
spdk_bs_batch_open(struct spdk_io_channel *_channel, bs_batch_open(struct spdk_io_channel *_channel,
struct spdk_bs_cpl *cpl) struct spdk_bs_cpl *cpl)
{ {
struct spdk_bs_channel *channel; struct spdk_bs_channel *channel;
struct spdk_bs_request_set *set; struct spdk_bs_request_set *set;
@ -349,8 +349,8 @@ spdk_bs_batch_read_bs_dev(spdk_bs_batch_t *batch, struct spdk_bs_dev *bs_dev,
} }
void void
spdk_bs_batch_read_dev(spdk_bs_batch_t *batch, void *payload, bs_batch_read_dev(spdk_bs_batch_t *batch, void *payload,
uint64_t lba, uint32_t lba_count) uint64_t lba, uint32_t lba_count)
{ {
struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)batch; struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)batch;
struct spdk_bs_channel *channel = set->channel; struct spdk_bs_channel *channel = set->channel;
@ -363,8 +363,8 @@ spdk_bs_batch_read_dev(spdk_bs_batch_t *batch, void *payload,
} }
void void
spdk_bs_batch_write_dev(spdk_bs_batch_t *batch, void *payload, bs_batch_write_dev(spdk_bs_batch_t *batch, void *payload,
uint64_t lba, uint32_t lba_count) uint64_t lba, uint32_t lba_count)
{ {
struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)batch; struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)batch;
struct spdk_bs_channel *channel = set->channel; struct spdk_bs_channel *channel = set->channel;
@ -377,8 +377,8 @@ spdk_bs_batch_write_dev(spdk_bs_batch_t *batch, void *payload,
} }
void void
spdk_bs_batch_unmap_dev(spdk_bs_batch_t *batch, bs_batch_unmap_dev(spdk_bs_batch_t *batch,
uint64_t lba, uint32_t lba_count) uint64_t lba, uint32_t lba_count)
{ {
struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)batch; struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)batch;
struct spdk_bs_channel *channel = set->channel; struct spdk_bs_channel *channel = set->channel;
@ -392,8 +392,8 @@ spdk_bs_batch_unmap_dev(spdk_bs_batch_t *batch,
} }
void void
spdk_bs_batch_write_zeroes_dev(spdk_bs_batch_t *batch, bs_batch_write_zeroes_dev(spdk_bs_batch_t *batch,
uint64_t lba, uint32_t lba_count) uint64_t lba, uint32_t lba_count)
{ {
struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)batch; struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)batch;
struct spdk_bs_channel *channel = set->channel; struct spdk_bs_channel *channel = set->channel;
@ -406,7 +406,7 @@ spdk_bs_batch_write_zeroes_dev(spdk_bs_batch_t *batch,
} }
void void
spdk_bs_batch_close(spdk_bs_batch_t *batch) bs_batch_close(spdk_bs_batch_t *batch)
{ {
struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)batch; struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)batch;
@ -423,7 +423,7 @@ spdk_bs_batch_close(spdk_bs_batch_t *batch)
} }
spdk_bs_batch_t * spdk_bs_batch_t *
spdk_bs_sequence_to_batch(spdk_bs_sequence_t *seq, spdk_bs_sequence_cpl cb_fn, void *cb_arg) bs_sequence_to_batch(spdk_bs_sequence_t *seq, spdk_bs_sequence_cpl cb_fn, void *cb_arg)
{ {
struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)seq; struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)seq;
@ -445,7 +445,7 @@ spdk_bs_batch_to_sequence(spdk_bs_batch_t *batch)
set->u.batch.outstanding_ops++; set->u.batch.outstanding_ops++;
set->cpl.type = SPDK_BS_CPL_TYPE_BLOB_BASIC; set->cpl.type = SPDK_BS_CPL_TYPE_BLOB_BASIC;
set->cpl.u.blob_basic.cb_fn = spdk_bs_sequence_to_batch_completion; set->cpl.u.blob_basic.cb_fn = bs_sequence_to_batch_completion;
set->cpl.u.blob_basic.cb_arg = set; set->cpl.u.blob_basic.cb_arg = set;
set->bserrno = 0; set->bserrno = 0;
@ -457,9 +457,9 @@ spdk_bs_batch_to_sequence(spdk_bs_batch_t *batch)
} }
spdk_bs_user_op_t * spdk_bs_user_op_t *
spdk_bs_user_op_alloc(struct spdk_io_channel *_channel, struct spdk_bs_cpl *cpl, bs_user_op_alloc(struct spdk_io_channel *_channel, struct spdk_bs_cpl *cpl,
enum spdk_blob_op_type op_type, struct spdk_blob *blob, enum spdk_blob_op_type op_type, struct spdk_blob *blob,
void *payload, int iovcnt, uint64_t offset, uint64_t length) void *payload, int iovcnt, uint64_t offset, uint64_t length)
{ {
struct spdk_bs_channel *channel; struct spdk_bs_channel *channel;
struct spdk_bs_request_set *set; struct spdk_bs_request_set *set;
@ -489,7 +489,7 @@ spdk_bs_user_op_alloc(struct spdk_io_channel *_channel, struct spdk_bs_cpl *cpl,
} }
void void
spdk_bs_user_op_execute(spdk_bs_user_op_t *op) bs_user_op_execute(spdk_bs_user_op_t *op)
{ {
struct spdk_bs_request_set *set; struct spdk_bs_request_set *set;
struct spdk_bs_user_op_args *args; struct spdk_bs_user_op_args *args;
@ -531,7 +531,7 @@ spdk_bs_user_op_execute(spdk_bs_user_op_t *op)
} }
void void
spdk_bs_user_op_abort(spdk_bs_user_op_t *op) bs_user_op_abort(spdk_bs_user_op_t *op)
{ {
struct spdk_bs_request_set *set; struct spdk_bs_request_set *set;
@ -542,7 +542,7 @@ spdk_bs_user_op_abort(spdk_bs_user_op_t *op)
} }
void void
spdk_bs_sequence_to_batch_completion(void *cb_arg, int bserrno) bs_sequence_to_batch_completion(void *cb_arg, int bserrno)
{ {
struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)cb_arg; struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)cb_arg;

92
lib/blob/request.h
View File

@ -143,81 +143,81 @@ struct spdk_bs_request_set {
TAILQ_ENTRY(spdk_bs_request_set) link; TAILQ_ENTRY(spdk_bs_request_set) link;
}; };
void spdk_bs_call_cpl(struct spdk_bs_cpl *cpl, int bserrno); void bs_call_cpl(struct spdk_bs_cpl *cpl, int bserrno);
spdk_bs_sequence_t *spdk_bs_sequence_start(struct spdk_io_channel *channel, spdk_bs_sequence_t *bs_sequence_start(struct spdk_io_channel *channel,
struct spdk_bs_cpl *cpl); struct spdk_bs_cpl *cpl);
void spdk_bs_sequence_read_bs_dev(spdk_bs_sequence_t *seq, struct spdk_bs_dev *bs_dev, void bs_sequence_read_bs_dev(spdk_bs_sequence_t *seq, struct spdk_bs_dev *bs_dev,
void *payload, uint64_t lba, uint32_t lba_count, void *payload, uint64_t lba, uint32_t lba_count,
spdk_bs_sequence_cpl cb_fn, void *cb_arg); spdk_bs_sequence_cpl cb_fn, void *cb_arg);
void spdk_bs_sequence_read_dev(spdk_bs_sequence_t *seq, void *payload, void bs_sequence_read_dev(spdk_bs_sequence_t *seq, void *payload,
uint64_t lba, uint32_t lba_count, uint64_t lba, uint32_t lba_count,
spdk_bs_sequence_cpl cb_fn, void *cb_arg); spdk_bs_sequence_cpl cb_fn, void *cb_arg);
void spdk_bs_sequence_write_dev(spdk_bs_sequence_t *seq, void *payload, void bs_sequence_write_dev(spdk_bs_sequence_t *seq, void *payload,
uint64_t lba, uint32_t lba_count, uint64_t lba, uint32_t lba_count,
spdk_bs_sequence_cpl cb_fn, void *cb_arg); spdk_bs_sequence_cpl cb_fn, void *cb_arg);
void spdk_bs_sequence_readv_bs_dev(spdk_bs_batch_t *batch, struct spdk_bs_dev *bs_dev, void bs_sequence_readv_bs_dev(spdk_bs_batch_t *batch, struct spdk_bs_dev *bs_dev,
struct iovec *iov, int iovcnt, uint64_t lba, uint32_t lba_count, struct iovec *iov, int iovcnt, uint64_t lba, uint32_t lba_count,
spdk_bs_sequence_cpl cb_fn, void *cb_arg); spdk_bs_sequence_cpl cb_fn, void *cb_arg);
void spdk_bs_sequence_readv_dev(spdk_bs_batch_t *batch, struct iovec *iov, int iovcnt, void bs_sequence_readv_dev(spdk_bs_batch_t *batch, struct iovec *iov, int iovcnt,
uint64_t lba, uint32_t lba_count, uint64_t lba, uint32_t lba_count,
spdk_bs_sequence_cpl cb_fn, void *cb_arg); spdk_bs_sequence_cpl cb_fn, void *cb_arg);
void spdk_bs_sequence_writev_dev(spdk_bs_batch_t *batch, struct iovec *iov, int iovcnt, void bs_sequence_writev_dev(spdk_bs_batch_t *batch, struct iovec *iov, int iovcnt,
uint64_t lba, uint32_t lba_count, uint64_t lba, uint32_t lba_count,
spdk_bs_sequence_cpl cb_fn, void *cb_arg); spdk_bs_sequence_cpl cb_fn, void *cb_arg);
void spdk_bs_sequence_unmap_dev(spdk_bs_sequence_t *seq, void spdk_bs_sequence_unmap_dev(spdk_bs_sequence_t *seq,
uint64_t lba, uint32_t lba_count, uint64_t lba, uint32_t lba_count,
spdk_bs_sequence_cpl cb_fn, void *cb_arg); spdk_bs_sequence_cpl cb_fn, void *cb_arg);
void spdk_bs_sequence_write_zeroes_dev(spdk_bs_sequence_t *seq, void bs_sequence_write_zeroes_dev(spdk_bs_sequence_t *seq,
uint64_t lba, uint32_t lba_count, uint64_t lba, uint32_t lba_count,
spdk_bs_sequence_cpl cb_fn, void *cb_arg); spdk_bs_sequence_cpl cb_fn, void *cb_arg);
void spdk_bs_sequence_finish(spdk_bs_sequence_t *seq, int bserrno); void bs_sequence_finish(spdk_bs_sequence_t *seq, int bserrno);
void spdk_bs_user_op_sequence_finish(void *cb_arg, int bserrno); void bs_user_op_sequence_finish(void *cb_arg, int bserrno);
spdk_bs_batch_t *spdk_bs_batch_open(struct spdk_io_channel *channel, spdk_bs_batch_t *bs_batch_open(struct spdk_io_channel *channel,
struct spdk_bs_cpl *cpl); struct spdk_bs_cpl *cpl);
void spdk_bs_batch_read_bs_dev(spdk_bs_batch_t *batch, struct spdk_bs_dev *bs_dev, void spdk_bs_batch_read_bs_dev(spdk_bs_batch_t *batch, struct spdk_bs_dev *bs_dev,
void *payload, uint64_t lba, uint32_t lba_count); void *payload, uint64_t lba, uint32_t lba_count);
void spdk_bs_batch_read_dev(spdk_bs_batch_t *batch, void *payload, void bs_batch_read_dev(spdk_bs_batch_t *batch, void *payload,
uint64_t lba, uint32_t lba_count); uint64_t lba, uint32_t lba_count);
void spdk_bs_batch_write_dev(spdk_bs_batch_t *batch, void *payload, void bs_batch_write_dev(spdk_bs_batch_t *batch, void *payload,
uint64_t lba, uint32_t lba_count); uint64_t lba, uint32_t lba_count);
void spdk_bs_batch_unmap_dev(spdk_bs_batch_t *batch, void bs_batch_unmap_dev(spdk_bs_batch_t *batch,
uint64_t lba, uint32_t lba_count); uint64_t lba, uint32_t lba_count);
void spdk_bs_batch_write_zeroes_dev(spdk_bs_batch_t *batch, void bs_batch_write_zeroes_dev(spdk_bs_batch_t *batch,
uint64_t lba, uint32_t lba_count); uint64_t lba, uint32_t lba_count);
void spdk_bs_batch_close(spdk_bs_batch_t *batch); void bs_batch_close(spdk_bs_batch_t *batch);
spdk_bs_batch_t *spdk_bs_sequence_to_batch(spdk_bs_sequence_t *seq, spdk_bs_batch_t *bs_sequence_to_batch(spdk_bs_sequence_t *seq,
spdk_bs_sequence_cpl cb_fn, spdk_bs_sequence_cpl cb_fn,
void *cb_arg); void *cb_arg);
spdk_bs_sequence_t *spdk_bs_batch_to_sequence(spdk_bs_batch_t *batch); spdk_bs_sequence_t *spdk_bs_batch_to_sequence(spdk_bs_batch_t *batch);
spdk_bs_user_op_t *spdk_bs_user_op_alloc(struct spdk_io_channel *channel, struct spdk_bs_cpl *cpl, spdk_bs_user_op_t *bs_user_op_alloc(struct spdk_io_channel *channel, struct spdk_bs_cpl *cpl,
enum spdk_blob_op_type op_type, struct spdk_blob *blob, enum spdk_blob_op_type op_type, struct spdk_blob *blob,
void *payload, int iovcnt, uint64_t offset, uint64_t length); void *payload, int iovcnt, uint64_t offset, uint64_t length);
void spdk_bs_user_op_execute(spdk_bs_user_op_t *op); void bs_user_op_execute(spdk_bs_user_op_t *op);
void spdk_bs_user_op_abort(spdk_bs_user_op_t *op); void bs_user_op_abort(spdk_bs_user_op_t *op);
void spdk_bs_sequence_to_batch_completion(void *cb_arg, int bserrno); void bs_sequence_to_batch_completion(void *cb_arg, int bserrno);
#endif #endif

2
lib/blob/zeroes.c
View File

@ -116,7 +116,7 @@ static struct spdk_bs_dev g_zeroes_bs_dev = {
}; };
struct spdk_bs_dev * struct spdk_bs_dev *
spdk_bs_create_zeroes_dev(void) bs_create_zeroes_dev(void)
{ {
return &g_zeroes_bs_dev; return &g_zeroes_bs_dev;
} }