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

blob: change spdk_blob_close parameter to spdk_blob *

Browse Source 
Using the ** paradigm is a bit problematic for asynchronous
routines that could fail.  Currently we were inconsistent in
that some error paths would zero the pointer while others
did not.  So make this just a plain pointer, which simplifies
the API and its implementation.

Signed-off-by: Jim Harris <james.r.harris@intel.com>
Change-Id: I67147931c6e8350896a4505022a6a314655de3d3

Reviewed-on: https://review.gerrithub.io/391482
Tested-by: SPDK Automated Test System <sys_sgsw@intel.com>
Reviewed-by: Ben Walker <benjamin.walker@intel.com>
Reviewed-by: Daniel Verkamp <daniel.verkamp@intel.com>
This commit is contained in:
Jim Harris 2017-12-12 13:42:56 -07:00
parent 40af6d6fd1
commit e734bb9f9f
11 changed files with 77 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGELOG.md
View File

@ -56,6 +56,9 @@ spdk_bs_md_delete_blob => spdk_bs_delete_blob
spdk_bs_md_iter_first => spdk_bs_iter_first
spdk_bs_md_iter_next => spdk_bs_iter_next
The function signature of spdk_blob_close has changed. It now takes a struct spdk_blob * argument
rather than struct spdk_blob **.
## v17.10: Logical Volumes
### New dependencies

14
examples/blob/cli/blobcli.c
View File

@ -286,7 +286,7 @@ sync_cb(void *arg1, int bserrno)
return;
}
spdk_blob_close(&cli_context->blob, close_cb, cli_context);
spdk_blob_close(cli_context->blob, close_cb, cli_context);
}
/*
@ -602,7 +602,7 @@ read_dump_cb(void *arg1, int bserrno)
/* done reading */
printf("\nFile write complete (to %s).\n", cli_context->file);
fclose(cli_context->fp);
spdk_blob_close(&cli_context->blob, close_cb, cli_context);
spdk_blob_close(cli_context->blob, close_cb, cli_context);
}
}
@ -650,7 +650,7 @@ write_imp_cb(void *arg1, int bserrno)
/* done writing */
printf("\nBlob import complete (from %s).\n", cli_context->file);
fclose(cli_context->fp);
spdk_blob_close(&cli_context->blob, close_cb, cli_context);
spdk_blob_close(cli_context->blob, close_cb, cli_context);
}
}
@ -680,7 +680,7 @@ dump_imp_open_cb(void *cb_arg, struct spdk_blob *blob, int bserrno)
ALIGN_4K, NULL);
if (cli_context->buff == NULL) {
printf("Error in allocating memory\n");
spdk_blob_close(&cli_context->blob, close_cb, cli_context);
spdk_blob_close(cli_context->blob, close_cb, cli_context);
return;
}
printf("Working");
@ -690,7 +690,7 @@ dump_imp_open_cb(void *cb_arg, struct spdk_blob *blob, int bserrno)
cli_context->fp = fopen(cli_context->file, "w");
if (cli_context->fp == NULL) {
printf("Error in opening file\n");
spdk_blob_close(&cli_context->blob, close_cb, cli_context);
spdk_blob_close(cli_context->blob, close_cb, cli_context);
return;
}
@ -702,7 +702,7 @@ dump_imp_open_cb(void *cb_arg, struct spdk_blob *blob, int bserrno)
cli_context->fp = fopen(cli_context->file, "r");
if (cli_context->fp == NULL) {
printf("Error in opening file\n");
spdk_blob_close(&cli_context->blob, close_cb, cli_context);
spdk_blob_close(cli_context->blob, close_cb, cli_context);
return;
}
@ -750,7 +750,7 @@ write_cb(void *arg1, int bserrno)
} else {
/* done writing */
printf("\nBlob fill complete (with 0x%x).\n", cli_context->fill_value);
spdk_blob_close(&cli_context->blob, close_cb, cli_context);
spdk_blob_close(cli_context->blob, close_cb, cli_context);
}
}

2
examples/blob/hello_world/hello_blob.c
View File

@ -168,7 +168,7 @@ read_complete(void *arg1, int bserrno)
}
/* Now let's close it and delete the blob in the callback. */
spdk_blob_close(&hello_context->blob, delete_blob, hello_context);
spdk_blob_close(hello_context->blob, delete_blob, hello_context);
}
/*

2
include/spdk/blob.h
View File

@ -232,7 +232,7 @@ int spdk_blob_resize(struct spdk_blob *blob, size_t sz);
void spdk_blob_sync_md(struct spdk_blob *blob, spdk_blob_op_complete cb_fn, void *cb_arg);
/* Close a blob. This will automatically sync. */
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);
struct spdk_io_channel *spdk_bs_alloc_io_channel(struct spdk_blob_store *bs);

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

@ -840,7 +840,7 @@ _vbdev_lvs_examine_finish(void *cb_arg, struct spdk_lvol *lvol, int lvolerrno)
SPDK_ERRLOG("Cannot create bdev for lvol %s\n", lvol->old_name);
TAILQ_REMOVE(&lvs->lvols, lvol, link);
lvs->lvol_count--;
spdk_blob_close(&lvol->blob, _vbdev_lvol_close_cb, lvs);
spdk_blob_close(lvol->blob, _vbdev_lvol_close_cb, lvs);
SPDK_INFOLOG(SPDK_LOG_VBDEV_LVOL, "Opening lvol %s failed\n", lvol->old_name);
free(lvol->old_name);
free(lvol);

20
lib/blob/blobstore.c
View File

@ -2828,26 +2828,24 @@ spdk_blob_sync_md(struct spdk_blob *_blob, spdk_blob_op_complete cb_fn, void *cb
static void
_spdk_blob_close_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
{
struct spdk_blob_data **blob = cb_arg;
struct spdk_blob_data *blob = cb_arg;
if ((*blob)->open_ref == 0) {
TAILQ_REMOVE(&(*blob)->bs->blobs, (*blob), link);
_spdk_blob_free((*blob));
if (blob->open_ref == 0) {
TAILQ_REMOVE(&blob->bs->blobs, blob, link);
_spdk_blob_free(blob);
}
*blob = NULL;
spdk_bs_sequence_finish(seq, bserrno);
}
void spdk_blob_close(struct spdk_blob **b, spdk_blob_op_complete cb_fn, void *cb_arg)
void spdk_blob_close(struct spdk_blob *b, spdk_blob_op_complete cb_fn, void *cb_arg)
{
struct spdk_bs_cpl cpl;
struct spdk_blob_data *blob;
spdk_bs_sequence_t *seq;
assert(b != NULL);
blob = __blob_to_data(*b);
blob = __blob_to_data(b);
assert(blob != NULL);
SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Closing blob %lu\n", blob->id);
@ -2873,12 +2871,12 @@ void spdk_blob_close(struct spdk_blob **b, spdk_blob_op_complete cb_fn, void *cb
}
if (blob->state == SPDK_BLOB_STATE_CLEAN) {
_spdk_blob_close_cpl(seq, b, 0);
_spdk_blob_close_cpl(seq, blob, 0);
return;
}
/* Sync metadata */
_spdk_blob_persist(seq, blob, _spdk_blob_close_cpl, b);
_spdk_blob_persist(seq, blob, _spdk_blob_close_cpl, blob);
}
/* END spdk_blob_close */
@ -3022,7 +3020,7 @@ spdk_bs_iter_next(struct spdk_blob_store *bs, struct spdk_blob **b,
ctx->cb_arg = cb_arg;
/* Close the existing blob */
spdk_blob_close(b, _spdk_bs_iter_close_cpl, ctx);
spdk_blob_close(*b, _spdk_bs_iter_close_cpl, ctx);
}
int

13
lib/blobfs/blobfs.c
View File

@ -857,12 +857,11 @@ fs_create_blob_open_cb(void *ctx, struct spdk_blob *blob, int bserrno)
struct spdk_file *f = args->file;
uint64_t length = 0;
f->blob = blob;
spdk_blob_resize(blob, 1);
spdk_blob_set_xattr(blob, "name", f->name, strlen(f->name) + 1);
spdk_blob_set_xattr(blob, "length", &length, sizeof(length));
spdk_blob_close(&f->blob, fs_create_blob_close_cb, args);
spdk_blob_close(blob, fs_create_blob_close_cb, args);
}
static void
@ -1128,12 +1127,10 @@ fs_rename_blob_open_cb(void *ctx, struct spdk_blob *blob, int bserrno)
{
struct spdk_fs_request *req = ctx;
struct spdk_fs_cb_args *args = &req->args;
struct spdk_file *f = args->file;
const char *new_name = args->op.rename.new_name;
f->blob = blob;
spdk_blob_set_xattr(blob, "name", new_name, strlen(new_name) + 1);
spdk_blob_close(&f->blob, fs_rename_blob_close_cb, req);
spdk_blob_close(blob, fs_rename_blob_close_cb, req);
}
static void
@ -2353,6 +2350,8 @@ __file_close_async_done(void *ctx, int bserrno)
static void
__file_close_async(struct spdk_file *file, struct spdk_fs_request *req)
{
struct spdk_blob *blob;
pthread_spin_lock(&file->lock);
if (file->ref_count == 0) {
pthread_spin_unlock(&file->lock);
@ -2369,7 +2368,9 @@ __file_close_async(struct spdk_file *file, struct spdk_fs_request *req)
pthread_spin_unlock(&file->lock);
spdk_blob_close(&file->blob, __file_close_async_done, req);
blob = file->blob;
file->blob = NULL;
spdk_blob_close(blob, __file_close_async_done, req);
}
static void

22
lib/lvol/lvol.c
View File

@ -285,14 +285,14 @@ _spdk_lvs_read_uuid(void *cb_arg, struct spdk_blob *blob, int lvolerrno)
if (rc != 0 || value_len != UUID_STRING_LEN || attr[UUID_STRING_LEN - 1] != '\0') {
SPDK_INFOLOG(SPDK_LOG_LVOL, "missing or incorrect UUID\n");
req->lvserrno = -EINVAL;
spdk_blob_close(&blob, _spdk_close_super_blob_with_error_cb, req);
spdk_blob_close(blob, _spdk_close_super_blob_with_error_cb, req);
return;
}
if (uuid_parse(attr, lvs->uuid)) {
SPDK_INFOLOG(SPDK_LOG_LVOL, "incorrect UUID '%s'\n", attr);
req->lvserrno = -EINVAL;
spdk_blob_close(&blob, _spdk_close_super_blob_with_error_cb, req);
spdk_blob_close(blob, _spdk_close_super_blob_with_error_cb, req);
return;
}
@ -300,7 +300,7 @@ _spdk_lvs_read_uuid(void *cb_arg, struct spdk_blob *blob, int lvolerrno)
if (rc != 0 || value_len > SPDK_LVS_NAME_MAX) {
SPDK_INFOLOG(SPDK_LOG_LVOL, "missing or invalid name\n");
req->lvserrno = -EINVAL;
spdk_blob_close(&blob, _spdk_close_super_blob_with_error_cb, req);
spdk_blob_close(blob, _spdk_close_super_blob_with_error_cb, req);
return;
}
@ -310,13 +310,13 @@ _spdk_lvs_read_uuid(void *cb_arg, struct spdk_blob *blob, int lvolerrno)
if (rc) {
SPDK_INFOLOG(SPDK_LOG_LVOL, "lvolstore with name %s already exists\n", lvs->name);
req->lvserrno = -EEXIST;
spdk_blob_close(&blob, _spdk_close_super_blob_with_error_cb, req);
spdk_blob_close(blob, _spdk_close_super_blob_with_error_cb, req);
return;
}
lvs->super_blob_id = spdk_blob_get_id(blob);
spdk_blob_close(&blob, _spdk_close_super_cb, req);
spdk_blob_close(blob, _spdk_close_super_cb, req);
}
static void
@ -429,7 +429,7 @@ _spdk_super_blob_set_cb(void *cb_arg, int lvolerrno)
return;
}
spdk_blob_close(&blob, _spdk_super_create_close_cb, req);
spdk_blob_close(blob, _spdk_super_create_close_cb, req);
}
static void
@ -844,7 +844,7 @@ _spdk_lvol_sync_cb(void *cb_arg, int lvolerrno)
struct spdk_lvol *lvol = req->lvol;
if (lvolerrno != 0) {
spdk_blob_close(&lvol->blob, _spdk_lvol_delete_blob_cb, lvol);
spdk_blob_close(lvol->blob, _spdk_lvol_delete_blob_cb, lvol);
} else {
lvol->ref_count++;
}
@ -873,7 +873,7 @@ _spdk_lvol_create_open_cb(void *cb_arg, struct spdk_blob *blob, int lvolerrno)
uuid_unparse(lvol->lvol_store->uuid, uuid);
lvol->old_name = spdk_sprintf_alloc("%s_%"PRIu64, uuid, (uint64_t)blob_id);
if (!lvol->old_name) {
spdk_blob_close(&blob, _spdk_lvol_delete_blob_cb, lvol);
spdk_blob_close(blob, _spdk_lvol_delete_blob_cb, lvol);
SPDK_ERRLOG("Cannot alloc memory for lvol name\n");
lvolerrno = -ENOMEM;
free(lvol);
@ -882,14 +882,14 @@ _spdk_lvol_create_open_cb(void *cb_arg, struct spdk_blob *blob, int lvolerrno)
lvolerrno = spdk_blob_resize(blob, lvol->num_clusters);
if (lvolerrno < 0) {
spdk_blob_close(&blob, _spdk_lvol_destroy_cb, lvol);
spdk_blob_close(blob, _spdk_lvol_destroy_cb, lvol);
goto invalid;
}
lvolerrno = spdk_blob_set_xattr(blob, "name", lvol->name,
strnlen(lvol->name, SPDK_LVOL_NAME_MAX) + 1);
if (lvolerrno < 0) {
spdk_blob_close(&blob, _spdk_lvol_destroy_cb, lvol);
spdk_blob_close(blob, _spdk_lvol_destroy_cb, lvol);
goto invalid;
}
@ -1129,7 +1129,7 @@ spdk_lvol_close(struct spdk_lvol *lvol, spdk_lvol_op_complete cb_fn, void *cb_ar
req->cb_arg = cb_arg;
req->lvol = lvol;
spdk_blob_close(&(lvol->blob), _spdk_lvol_close_blob_cb, req);
spdk_blob_close(lvol->blob, _spdk_lvol_close_blob_cb, req);
}
struct spdk_io_channel *

2
test/unit/lib/bdev/vbdev_lvol.c/vbdev_lvol_ut.c
View File

@ -71,7 +71,7 @@ spdk_lvol_open(struct spdk_lvol *lvol, spdk_lvol_op_with_handle_complete cb_fn,
}
void
spdk_blob_close(struct spdk_blob **b, spdk_blob_op_complete cb_fn, void *cb_arg)
spdk_blob_close(struct spdk_blob *b, spdk_blob_op_complete cb_fn, void *cb_arg)
{
}

69
test/unit/lib/blob/blob.c/blob_ut.c
View File

@ -237,16 +237,15 @@ blob_open(void)
CU_ASSERT(g_bserrno == 0);
CU_ASSERT(blob == g_blob);
spdk_blob_close(&blob, blob_op_complete, NULL);
spdk_blob_close(blob, blob_op_complete, NULL);
CU_ASSERT(g_bserrno == 0);
CU_ASSERT(blob == NULL);
/*
* Close the file a second time, releasing the second reference. This
* should succeed.
*/
blob = g_blob;
spdk_blob_close(&blob, blob_op_complete, NULL);
spdk_blob_close(blob, blob_op_complete, NULL);
CU_ASSERT(g_bserrno == 0);
/*
@ -258,7 +257,7 @@ blob_open(void)
CU_ASSERT(g_blob != NULL);
blob = g_blob;
spdk_blob_close(&blob, blob_op_complete, NULL);
spdk_blob_close(blob, blob_op_complete, NULL);
CU_ASSERT(g_bserrno == 0);
spdk_bs_unload(g_bs, bs_op_complete, NULL);
@ -356,7 +355,7 @@ blob_resize(void)
CU_ASSERT(rc == 0);
CU_ASSERT((free_clusters - 10) == spdk_bs_free_cluster_count(bs));
spdk_blob_close(&blob, blob_op_complete, NULL);
spdk_blob_close(blob, blob_op_complete, NULL);
CU_ASSERT(g_bserrno == 0);
spdk_bs_delete_blob(bs, blobid, blob_op_complete, NULL);
@ -453,7 +452,7 @@ blob_write(void)
blob_op_complete, NULL);
CU_ASSERT(g_bserrno == -EINVAL);
spdk_blob_close(&blob, blob_op_complete, NULL);
spdk_blob_close(blob, blob_op_complete, NULL);
CU_ASSERT(g_bserrno == 0);
spdk_bs_free_io_channel(channel);
@ -525,7 +524,7 @@ blob_read(void)
blob_op_complete, NULL);
CU_ASSERT(g_bserrno == -EINVAL);
spdk_blob_close(&blob, blob_op_complete, NULL);
spdk_blob_close(blob, blob_op_complete, NULL);
CU_ASSERT(g_bserrno == 0);
spdk_bs_free_io_channel(channel);
@ -579,7 +578,7 @@ blob_rw_verify(void)
CU_ASSERT(g_bserrno == 0);
CU_ASSERT(memcmp(payload_write, payload_read, 4 * 4096) == 0);
spdk_blob_close(&blob, blob_op_complete, NULL);
spdk_blob_close(blob, blob_op_complete, NULL);
CU_ASSERT(g_bserrno == 0);
spdk_bs_free_io_channel(channel);
@ -669,7 +668,7 @@ blob_rw_verify_iov(void)
CU_ASSERT(memcmp(buf, &g_dev_buffer[512 * 4096], 256 * 4096) == 0);
free(buf);
spdk_blob_close(&blob, blob_op_complete, NULL);
spdk_blob_close(blob, blob_op_complete, NULL);
CU_ASSERT(g_bserrno == 0);
spdk_bs_free_io_channel(channel);
@ -747,7 +746,7 @@ blob_rw_verify_iov_nomem(void)
CU_ASSERT(req_count == bs_channel_get_req_count(channel));
MOCK_SET(calloc, void *, (void *)MOCK_PASS_THRU);
spdk_blob_close(&blob, blob_op_complete, NULL);
spdk_blob_close(blob, blob_op_complete, NULL);
CU_ASSERT(g_bserrno == 0);
spdk_bs_free_io_channel(channel);
@ -808,7 +807,7 @@ blob_rw_iov_read_only(void)
spdk_bs_io_readv_blob(blob, channel, &iov_read, 1, 0, 1, blob_op_complete, NULL);
CU_ASSERT(g_bserrno == 0);
spdk_blob_close(&blob, blob_op_complete, NULL);
spdk_blob_close(blob, blob_op_complete, NULL);
CU_ASSERT(g_bserrno == 0);
spdk_bs_free_io_channel(channel);
@ -945,7 +944,7 @@ blob_xattr(void)
rc = spdk_blob_remove_xattr(blob, "foobar");
CU_ASSERT(rc == -ENOENT);
spdk_blob_close(&blob, blob_op_complete, NULL);
spdk_blob_close(blob, blob_op_complete, NULL);
spdk_bs_unload(g_bs, bs_op_complete, NULL);
CU_ASSERT(g_bserrno == 0);
@ -1009,7 +1008,7 @@ bs_load(void)
rc = spdk_blob_resize(blob, 10);
CU_ASSERT(rc == 0);
spdk_blob_close(&blob, blob_op_complete, NULL);
spdk_blob_close(blob, blob_op_complete, NULL);
CU_ASSERT(g_bserrno == 0);
blob = NULL;
g_blob = NULL;
@ -1054,7 +1053,7 @@ bs_load(void)
CU_ASSERT(spdk_blob_get_num_clusters(blob) == 10);
spdk_blob_close(&blob, blob_op_complete, NULL);
spdk_blob_close(blob, blob_op_complete, NULL);
CU_ASSERT(g_bserrno == 0);
blob = NULL;
g_blob = NULL;
@ -1237,9 +1236,8 @@ bs_unload(void)
/* Close the blob, then successfully unload blobstore */
g_bserrno = -1;
spdk_blob_close(&blob, blob_op_complete, NULL);
spdk_blob_close(blob, blob_op_complete, NULL);
CU_ASSERT(g_bserrno == 0);
CU_ASSERT(blob == NULL);
g_bserrno = -1;
spdk_bs_unload(g_bs, bs_op_complete, NULL);
@ -1380,7 +1378,7 @@ bs_usable_clusters(void)
CU_ASSERT(rc == 0);
g_bserrno = -1;
spdk_blob_close(&g_blob, blob_op_complete, NULL);
spdk_blob_close(g_blob, blob_op_complete, NULL);
CU_ASSERT(g_bserrno == 0);
CU_ASSERT(spdk_bs_total_data_cluster_count(g_bs) == clusters);
@ -1464,7 +1462,7 @@ bs_resize_md(void)
CU_ASSERT(g_bserrno == 0);
CU_ASSERT(g_blob != NULL);
g_bserrno = -1;
spdk_blob_close(&g_blob, blob_op_complete, NULL);
spdk_blob_close(g_blob, blob_op_complete, NULL);
CU_ASSERT(g_bserrno == 0);
}
@ -1574,7 +1572,7 @@ blob_serialize(void)
/* Close the blobs */
for (i = 0; i < 2; i++) {
spdk_blob_close(&blob[i], blob_op_complete, NULL);
spdk_blob_close(blob[i], blob_op_complete, NULL);
CU_ASSERT(g_bserrno == 0);
}
@ -1603,7 +1601,7 @@ blob_serialize(void)
CU_ASSERT(spdk_blob_get_num_clusters(blob[i]) == 3);
spdk_blob_close(&blob[i], blob_op_complete, NULL);
spdk_blob_close(blob[i], blob_op_complete, NULL);
CU_ASSERT(g_bserrno == 0);
}
@ -1640,9 +1638,8 @@ blob_crc(void)
CU_ASSERT(g_blob != NULL);
blob = g_blob;
spdk_blob_close(&blob, blob_op_complete, NULL);
spdk_blob_close(blob, blob_op_complete, NULL);
CU_ASSERT(g_bserrno == 0);
CU_ASSERT(blob == NULL);
page_num = _spdk_bs_blobid_to_page(blobid);
index = DEV_BUFFER_BLOCKLEN * (bs->md_start + page_num);
@ -1754,7 +1751,7 @@ blob_dirty_shutdown(void)
rc = spdk_blob_resize(blob, 10);
CU_ASSERT(rc == 0);
spdk_blob_close(&blob, blob_op_complete, NULL);
spdk_blob_close(blob, blob_op_complete, NULL);
blob = NULL;
g_blob = NULL;
g_blobid = SPDK_BLOBID_INVALID;
@ -1786,7 +1783,7 @@ blob_dirty_shutdown(void)
rc = spdk_blob_resize(blob, 20);
CU_ASSERT(rc == 0);
spdk_blob_close(&blob, blob_op_complete, NULL);
spdk_blob_close(blob, blob_op_complete, NULL);
CU_ASSERT(g_bserrno == 0);
blob = NULL;
g_blob = NULL;
@ -1808,7 +1805,7 @@ blob_dirty_shutdown(void)
blob = g_blob;
CU_ASSERT(spdk_blob_get_num_clusters(blob) == 20);
spdk_blob_close(&blob, blob_op_complete, NULL);
spdk_blob_close(blob, blob_op_complete, NULL);
CU_ASSERT(g_bserrno == 0);
blob = NULL;
g_blob = NULL;
@ -1837,7 +1834,7 @@ blob_dirty_shutdown(void)
rc = spdk_blob_resize(blob, 10);
CU_ASSERT(rc == 0);
spdk_blob_close(&blob, blob_op_complete, NULL);
spdk_blob_close(blob, blob_op_complete, NULL);
blob = NULL;
g_blob = NULL;
g_blobid = SPDK_BLOBID_INVALID;
@ -1865,7 +1862,7 @@ blob_dirty_shutdown(void)
CU_ASSERT(value_len == 8);
CU_ASSERT(spdk_blob_get_num_clusters(blob) == 10);
spdk_blob_close(&blob, blob_op_complete, NULL);
spdk_blob_close(blob, blob_op_complete, NULL);
CU_ASSERT(g_bserrno == 0);
spdk_bs_delete_blob(g_bs, blobid2, blob_op_complete, NULL);
CU_ASSERT(g_bserrno == 0);
@ -1885,7 +1882,7 @@ blob_dirty_shutdown(void)
spdk_bs_open_blob(g_bs, blobid1, blob_op_with_handle_complete, NULL);
CU_ASSERT(g_bserrno == 0);
CU_ASSERT(g_blob != NULL);
spdk_blob_close(&g_blob, blob_op_complete, NULL);
spdk_blob_close(g_blob, blob_op_complete, NULL);
CU_ASSERT(g_bserrno == 0);
spdk_bs_unload(g_bs, bs_op_complete, NULL);
@ -1923,7 +1920,7 @@ blob_dirty_shutdown(void)
rc = spdk_blob_set_xattr(blob, "length", &length, sizeof(length));
CU_ASSERT(rc == 0);
spdk_blob_close(&blob, blob_op_complete, NULL);
spdk_blob_close(blob, blob_op_complete, NULL);
blob = NULL;
g_blob = NULL;
g_blobid = SPDK_BLOBID_INVALID;
@ -1941,7 +1938,7 @@ blob_dirty_shutdown(void)
rc = spdk_blob_set_xattr(blob, "length", &length, sizeof(length));
CU_ASSERT(rc == 0);
spdk_blob_close(&blob, blob_op_complete, NULL);
spdk_blob_close(blob, blob_op_complete, NULL);
blob = NULL;
g_blob = NULL;
g_blobid = SPDK_BLOBID_INVALID;
@ -1971,7 +1968,7 @@ blob_dirty_shutdown(void)
CU_ASSERT(g_blob != NULL);
blob = g_blob;
spdk_blob_close(&blob, blob_op_complete, NULL);
spdk_blob_close(blob, blob_op_complete, NULL);
blob = NULL;
g_blob = NULL;
g_blobid = SPDK_BLOBID_INVALID;
@ -2046,15 +2043,15 @@ blob_flags(void)
CU_ASSERT(g_bserrno == 0);
g_bserrno = -1;
spdk_blob_close(&blob_invalid, blob_op_complete, NULL);
spdk_blob_close(blob_invalid, blob_op_complete, NULL);
CU_ASSERT(g_bserrno == 0);
blob_invalid = NULL;
g_bserrno = -1;
spdk_blob_close(&blob_data_ro, blob_op_complete, NULL);
spdk_blob_close(blob_data_ro, blob_op_complete, NULL);
CU_ASSERT(g_bserrno == 0);
blob_data_ro = NULL;
g_bserrno = -1;
spdk_blob_close(&blob_md_ro, blob_op_complete, NULL);
spdk_blob_close(blob_md_ro, blob_op_complete, NULL);
CU_ASSERT(g_bserrno == 0);
blob_md_ro = NULL;
@ -2097,9 +2094,9 @@ blob_flags(void)
CU_ASSERT(__blob_to_data(blob_md_ro)->data_ro == false);
CU_ASSERT(__blob_to_data(blob_md_ro)->md_ro == true);
spdk_blob_close(&blob_data_ro, blob_op_complete, NULL);
spdk_blob_close(blob_data_ro, blob_op_complete, NULL);
CU_ASSERT(g_bserrno == 0);
spdk_blob_close(&blob_md_ro, blob_op_complete, NULL);
spdk_blob_close(blob_md_ro, blob_op_complete, NULL);
CU_ASSERT(g_bserrno == 0);
spdk_bs_unload(g_bs, bs_op_complete, NULL);

6
test/unit/lib/lvol/lvol.c/lvol_ut.c
View File

@ -303,11 +303,11 @@ spdk_bs_get_cluster_size(struct spdk_blob_store *bs)
return BS_CLUSTER_SIZE;
}
void spdk_blob_close(struct spdk_blob **b, spdk_blob_op_complete cb_fn, void *cb_arg)
void spdk_blob_close(struct spdk_blob *b, spdk_blob_op_complete cb_fn, void *cb_arg)
{
(*b)->ref--;
b->ref--;
cb_fn(cb_arg, (*b)->close_status);
cb_fn(cb_arg, b->close_status);
}
int