From 2c3591f183d697f06a39026fa4d436d54400a294 Mon Sep 17 00:00:00 2001 From: Jim Harris Date: Fri, 8 Dec 2017 09:38:33 -0700 Subject: [PATCH] blob: rename spdk blob metadata functions spdk_bs_md_resize_blob => spdk_blob_resize spdk_bs_md_sync_blob => spdk_blob_sync_md spdk_bs_md_get_xattr_value => spdk_blob_get_xattr_value spdK_bs_md_get_xattr_names => spdk_blob_get_xattr_names spdk_blob_md_set_xattr => spdk_blob_set_xattr spdk_blob_md_remove_xattr => spdk_blob_remove_xattr spdk_bs_md_close_blob => spdk_blob_close Signed-off-by: Jim Harris Change-Id: I99b593c03bc61354ba6aa5a446b0fc82df1e9ce2 Reviewed-on: https://review.gerrithub.io/391006 Reviewed-by: Ben Walker Tested-by: SPDK Automated Test System Reviewed-by: Daniel Verkamp --- CHANGELOG.md | 12 ++ examples/blob/cli/blobcli.c | 42 ++--- examples/blob/hello_world/hello_blob.c | 8 +- include/spdk/blob.h | 27 ++- lib/bdev/lvol/vbdev_lvol.c | 2 +- lib/blob/blobstore.c | 40 +++-- lib/blobfs/blobfs.c | 40 ++--- lib/lvol/lvol.c | 48 +++--- .../lib/bdev/vbdev_lvol.c/vbdev_lvol_ut.c | 2 +- test/unit/lib/blob/blob.c/blob_ut.c | 158 +++++++++--------- test/unit/lib/lvol/lvol.c/lvol_ut.c | 52 +++--- 11 files changed, 212 insertions(+), 219 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 1419c5f32..2b1cfa009 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -35,6 +35,18 @@ vfio-pci driver should trigger one "remove" uevent at the very beginning of the of pci driver, this will make sure the SPDK could detect the event and release the vfio-attached device Fd and related resource when the device removed. +### Blobstore + +A number of functions have been renamed: + +spdk_bs_md_resize_blob => spdk_blob_resize +spdk_bs_md_sync_blob => spdk_blob_sync_md +spdk_bs_md_close_blob => spdk_blob_close +spdk_bs_md_get_xattr_names => spdk_blob_get_xattr_names +spdk_bs_md_get_xattr_value => spdk_blob_get_xattr_value +spdk_blob_md_set_xattr => spdk_blob_set_xattr +spdk_blob_md_remove_xattr => spdk_blob_remove_xattr + ## v17.10: Logical Volumes ### New dependencies diff --git a/examples/blob/cli/blobcli.c b/examples/blob/cli/blobcli.c index 24f88af7d..986ce1b8d 100644 --- a/examples/blob/cli/blobcli.c +++ b/examples/blob/cli/blobcli.c @@ -286,8 +286,7 @@ sync_cb(void *arg1, int bserrno) return; } - spdk_bs_md_close_blob(&cli_context->blob, close_cb, - cli_context); + spdk_blob_close(&cli_context->blob, close_cb, cli_context); } /* @@ -307,8 +306,7 @@ open_now_resize_cb(void *cb_arg, struct spdk_blob *blob, int bserrno) } cli_context->blob = blob; - rc = spdk_bs_md_resize_blob(cli_context->blob, - cli_context->num_clusters); + rc = spdk_blob_resize(cli_context->blob, cli_context->num_clusters); if (rc) { unload_bs(cli_context, "Error in blob resize", bserrno); @@ -323,8 +321,7 @@ open_now_resize_cb(void *cb_arg, struct spdk_blob *blob, int bserrno) * Always a good idea to sync after MD changes or the changes * may be lost if things aren't closed cleanly. */ - spdk_bs_md_sync_blob(cli_context->blob, sync_cb, - cli_context); + spdk_blob_sync_md(cli_context->blob, sync_cb, cli_context); } /* @@ -440,14 +437,14 @@ show_blob(struct cli_context_t *cli_context) val = spdk_blob_get_num_pages(cli_context->blob); printf("# of pages: %" PRIu64 "\n", val); - spdk_bs_md_get_xattr_names(cli_context->blob, &names); + spdk_blob_get_xattr_names(cli_context->blob, &names); printf("# of xattrs: %d\n", spdk_xattr_names_get_count(names)); printf("xattrs:\n"); for (i = 0; i < spdk_xattr_names_get_count(names); i++) { - spdk_bs_md_get_xattr_value(cli_context->blob, - spdk_xattr_names_get_name(names, i), - &value, &value_len); + spdk_blob_get_xattr_value(cli_context->blob, + spdk_xattr_names_get_name(names, i), + &value, &value_len); if ((value_len + 1) > sizeof(data)) { printf("FYI: adjusting size of xattr due to CLI limits.\n"); value_len = sizeof(data) - 1; @@ -560,18 +557,15 @@ set_xattr_cb(void *cb_arg, struct spdk_blob *blob, int bserrno) cli_context->blob = blob; if (cli_context->action == CLI_SET_XATTR) { - spdk_blob_md_set_xattr(cli_context->blob, - cli_context->key, - cli_context->value, - strlen(cli_context->value) + 1); + spdk_blob_set_xattr(cli_context->blob, cli_context->key, + cli_context->value, strlen(cli_context->value) + 1); printf("Xattr has been set.\n"); } else { - spdk_blob_md_remove_xattr(cli_context->blob, - cli_context->key); + spdk_blob_remove_xattr(cli_context->blob, cli_context->key); printf("Xattr has been removed.\n"); } - spdk_bs_md_sync_blob(cli_context->blob, sync_cb, cli_context); + spdk_blob_sync_md(cli_context->blob, sync_cb, cli_context); } /* @@ -609,8 +603,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_bs_md_close_blob(&cli_context->blob, close_cb, - cli_context); + spdk_blob_close(&cli_context->blob, close_cb, cli_context); } } @@ -658,7 +651,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_bs_md_close_blob(&cli_context->blob, close_cb, cli_context); + spdk_blob_close(&cli_context->blob, close_cb, cli_context); } } @@ -688,7 +681,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_bs_md_close_blob(&cli_context->blob, close_cb, cli_context); + spdk_blob_close(&cli_context->blob, close_cb, cli_context); return; } printf("Working"); @@ -698,7 +691,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_bs_md_close_blob(&cli_context->blob, close_cb, cli_context); + spdk_blob_close(&cli_context->blob, close_cb, cli_context); return; } @@ -710,7 +703,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_bs_md_close_blob(&cli_context->blob, close_cb, cli_context); + spdk_blob_close(&cli_context->blob, close_cb, cli_context); return; } @@ -758,8 +751,7 @@ write_cb(void *arg1, int bserrno) } else { /* done writing */ printf("\nBlob fill complete (with 0x%x).\n", cli_context->fill_value); - spdk_bs_md_close_blob(&cli_context->blob, close_cb, - cli_context); + spdk_blob_close(&cli_context->blob, close_cb, cli_context); } } diff --git a/examples/blob/hello_world/hello_blob.c b/examples/blob/hello_world/hello_blob.c index 32bcbddbb..ad5723f58 100644 --- a/examples/blob/hello_world/hello_blob.c +++ b/examples/blob/hello_world/hello_blob.c @@ -168,8 +168,7 @@ read_complete(void *arg1, int bserrno) } /* Now let's close it and delete the blob in the callback. */ - spdk_bs_md_close_blob(&hello_context->blob, delete_blob, - hello_context); + spdk_blob_close(&hello_context->blob, delete_blob, hello_context); } /* @@ -298,7 +297,7 @@ open_complete(void *cb_arg, struct spdk_blob *blob, int bserrno) * there'd usually be many blobs of various sizes. The resize * unit is a cluster. */ - rc = spdk_bs_md_resize_blob(hello_context->blob, free); + rc = spdk_blob_resize(hello_context->blob, free); if (rc) { unload_bs(hello_context, "Error in blob resize", bserrno); @@ -318,8 +317,7 @@ open_complete(void *cb_arg, struct spdk_blob *blob, int bserrno) * good idea to sync after making metadata changes unless * it has an unacceptable impact on application performance. */ - spdk_bs_md_sync_blob(hello_context->blob, sync_complete, - hello_context); + spdk_blob_sync_md(hello_context->blob, sync_complete, hello_context); } /* diff --git a/include/spdk/blob.h b/include/spdk/blob.h index b4800c2c9..2113137e8 100644 --- a/include/spdk/blob.h +++ b/include/spdk/blob.h @@ -235,22 +235,18 @@ void spdk_bs_md_open_blob(struct spdk_blob_store *bs, spdk_blob_id blobid, /* Resize a blob to 'sz' clusters. * * These changes are not persisted to disk until - * spdk_bs_md_sync_blob() is called. */ -int spdk_bs_md_resize_blob(struct spdk_blob *blob, size_t sz); + * spdk_blob_sync_md() is called. */ +int spdk_blob_resize(struct spdk_blob *blob, size_t sz); /* Sync a blob */ -/* Make a blob persistent. This applies to open, resize, set xattr, +/* Make a blob persistent. This applies to resize, set xattr, * and remove xattr. These operations will not be persistent until * the blob has been synced. - * - * I/O operations (read/write) are synced independently. See - * spdk_bs_io_flush_channel(). */ -void spdk_bs_md_sync_blob(struct spdk_blob *blob, - spdk_blob_op_complete cb_fn, void *cb_arg); +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_bs_md_close_blob(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); @@ -294,13 +290,12 @@ void spdk_bs_md_iter_first(struct spdk_blob_store *bs, void spdk_bs_md_iter_next(struct spdk_blob_store *bs, struct spdk_blob **blob, spdk_blob_op_with_handle_complete cb_fn, void *cb_arg); -int spdk_blob_md_set_xattr(struct spdk_blob *blob, const char *name, const void *value, - uint16_t value_len); -int spdk_blob_md_remove_xattr(struct spdk_blob *blob, const char *name); -int spdk_bs_md_get_xattr_value(struct spdk_blob *blob, const char *name, - const void **value, size_t *value_len); -int spdk_bs_md_get_xattr_names(struct spdk_blob *blob, - struct spdk_xattr_names **names); +int spdk_blob_set_xattr(struct spdk_blob *blob, const char *name, const void *value, + uint16_t value_len); +int spdk_blob_remove_xattr(struct spdk_blob *blob, const char *name); +int spdk_blob_get_xattr_value(struct spdk_blob *blob, const char *name, + const void **value, size_t *value_len); +int spdk_blob_get_xattr_names(struct spdk_blob *blob, struct spdk_xattr_names **names); uint32_t spdk_xattr_names_get_count(struct spdk_xattr_names *names); const char *spdk_xattr_names_get_name(struct spdk_xattr_names *names, uint32_t index); diff --git a/lib/bdev/lvol/vbdev_lvol.c b/lib/bdev/lvol/vbdev_lvol.c index be5694653..e5dafb5b3 100644 --- a/lib/bdev/lvol/vbdev_lvol.c +++ b/lib/bdev/lvol/vbdev_lvol.c @@ -855,7 +855,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_bs_md_close_blob(&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); diff --git a/lib/blob/blobstore.c b/lib/blob/blobstore.c index 3b69fac09..801311099 100644 --- a/lib/blob/blobstore.c +++ b/lib/blob/blobstore.c @@ -2632,9 +2632,9 @@ void spdk_bs_md_create_blob(struct spdk_blob_store *bs, /* END spdk_bs_md_create_blob */ -/* START spdk_bs_md_resize_blob */ +/* START spdk_blob_resize */ int -spdk_bs_md_resize_blob(struct spdk_blob *_blob, uint64_t sz) +spdk_blob_resize(struct spdk_blob *_blob, uint64_t sz) { struct spdk_blob_data *blob = __blob_to_data(_blob); int rc; @@ -2659,7 +2659,7 @@ spdk_bs_md_resize_blob(struct spdk_blob *_blob, uint64_t sz) return 0; } -/* END spdk_bs_md_resize_blob */ +/* END spdk_blob_resize */ /* START spdk_bs_md_delete_blob */ @@ -2796,15 +2796,15 @@ void spdk_bs_md_open_blob(struct spdk_blob_store *bs, spdk_blob_id blobid, _spdk_blob_load(seq, blob, _spdk_bs_md_open_blob_cpl, blob); } -/* START spdk_bs_md_sync_blob */ +/* START spdk_blob_sync_md */ static void -_spdk_blob_sync_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno) +_spdk_blob_sync_md_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno) { spdk_bs_sequence_finish(seq, bserrno); } -void spdk_bs_md_sync_blob(struct spdk_blob *_blob, - spdk_blob_op_complete cb_fn, void *cb_arg) +void +spdk_blob_sync_md(struct spdk_blob *_blob, spdk_blob_op_complete cb_fn, void *cb_arg) { struct spdk_blob_data *blob = __blob_to_data(_blob); struct spdk_bs_cpl cpl; @@ -2837,12 +2837,12 @@ void spdk_bs_md_sync_blob(struct spdk_blob *_blob, return; } - _spdk_blob_persist(seq, blob, _spdk_blob_sync_cpl, blob); + _spdk_blob_persist(seq, blob, _spdk_blob_sync_md_cpl, blob); } -/* END spdk_bs_md_sync_blob */ +/* END spdk_blob_sync_md */ -/* START spdk_bs_md_close_blob */ +/* START spdk_blob_close */ static void _spdk_blob_close_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno) @@ -2859,8 +2859,7 @@ _spdk_blob_close_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno) spdk_bs_sequence_finish(seq, bserrno); } -void spdk_bs_md_close_blob(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; @@ -2901,7 +2900,7 @@ void spdk_bs_md_close_blob(struct spdk_blob **b, _spdk_blob_persist(seq, blob, _spdk_blob_close_cpl, b); } -/* END spdk_bs_md_close_blob */ +/* END spdk_blob_close */ struct spdk_io_channel *spdk_bs_alloc_io_channel(struct spdk_blob_store *bs) { @@ -3058,12 +3057,12 @@ spdk_bs_md_iter_next(struct spdk_blob_store *bs, struct spdk_blob **b, ctx->cb_arg = cb_arg; /* Close the existing blob */ - spdk_bs_md_close_blob(b, _spdk_bs_iter_close_cpl, ctx); + spdk_blob_close(b, _spdk_bs_iter_close_cpl, ctx); } int -spdk_blob_md_set_xattr(struct spdk_blob *_blob, const char *name, const void *value, - uint16_t value_len) +spdk_blob_set_xattr(struct spdk_blob *_blob, const char *name, const void *value, + uint16_t value_len) { struct spdk_blob_data *blob = __blob_to_data(_blob); struct spdk_xattr *xattr; @@ -3106,7 +3105,7 @@ spdk_blob_md_set_xattr(struct spdk_blob *_blob, const char *name, const void *va } int -spdk_blob_md_remove_xattr(struct spdk_blob *_blob, const char *name) +spdk_blob_remove_xattr(struct spdk_blob *_blob, const char *name) { struct spdk_blob_data *blob = __blob_to_data(_blob); struct spdk_xattr *xattr; @@ -3137,8 +3136,8 @@ spdk_blob_md_remove_xattr(struct spdk_blob *_blob, const char *name) } int -spdk_bs_md_get_xattr_value(struct spdk_blob *_blob, const char *name, - const void **value, size_t *value_len) +spdk_blob_get_xattr_value(struct spdk_blob *_blob, const char *name, + const void **value, size_t *value_len) { struct spdk_blob_data *blob = __blob_to_data(_blob); struct spdk_xattr *xattr; @@ -3160,8 +3159,7 @@ struct spdk_xattr_names { }; int -spdk_bs_md_get_xattr_names(struct spdk_blob *_blob, - struct spdk_xattr_names **names) +spdk_blob_get_xattr_names(struct spdk_blob *_blob, struct spdk_xattr_names **names) { struct spdk_blob_data *blob = __blob_to_data(_blob); struct spdk_xattr *xattr; diff --git a/lib/blobfs/blobfs.c b/lib/blobfs/blobfs.c index eeb6bd0d8..608dad1e6 100644 --- a/lib/blobfs/blobfs.c +++ b/lib/blobfs/blobfs.c @@ -579,14 +579,14 @@ iter_cb(void *ctx, struct spdk_blob *blob, int rc) return; } - rc = spdk_bs_md_get_xattr_value(blob, "name", (const void **)&name, &value_len); + rc = spdk_blob_get_xattr_value(blob, "name", (const void **)&name, &value_len); if (rc < 0) { args->fn.fs_op_with_handle(args->arg, fs, rc); free_fs_request(req); return; } - rc = spdk_bs_md_get_xattr_value(blob, "length", (const void **)&length, &value_len); + rc = spdk_blob_get_xattr_value(blob, "length", (const void **)&length, &value_len); if (rc < 0) { args->fn.fs_op_with_handle(args->arg, fs, rc); free_fs_request(req); @@ -596,7 +596,7 @@ iter_cb(void *ctx, struct spdk_blob *blob, int rc) assert(value_len == 8); /* This file could be deleted last time without close it, then app crashed, so we delete it now */ - rc = spdk_bs_md_get_xattr_value(blob, "is_deleted", (const void **)&is_deleted, &value_len); + rc = spdk_blob_get_xattr_value(blob, "is_deleted", (const void **)&is_deleted, &value_len); if (rc < 0) { struct spdk_file *f; @@ -858,11 +858,11 @@ fs_create_blob_open_cb(void *ctx, struct spdk_blob *blob, int bserrno) uint64_t length = 0; f->blob = blob; - spdk_bs_md_resize_blob(blob, 1); - spdk_blob_md_set_xattr(blob, "name", f->name, strlen(f->name) + 1); - spdk_blob_md_set_xattr(blob, "length", &length, sizeof(length)); + 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_bs_md_close_blob(&f->blob, fs_create_blob_close_cb, args); + spdk_blob_close(&f->blob, fs_create_blob_close_cb, args); } static void @@ -1132,8 +1132,8 @@ fs_rename_blob_open_cb(void *ctx, struct spdk_blob *blob, int bserrno) const char *new_name = args->op.rename.new_name; f->blob = blob; - spdk_blob_md_set_xattr(blob, "name", new_name, strlen(new_name) + 1); - spdk_bs_md_close_blob(&f->blob, fs_rename_blob_close_cb, req); + spdk_blob_set_xattr(blob, "name", new_name, strlen(new_name) + 1); + spdk_blob_close(&f->blob, fs_rename_blob_close_cb, req); } static void @@ -1292,8 +1292,8 @@ spdk_fs_delete_file_async(struct spdk_filesystem *fs, const char *name, if (f->ref_count > 0) { /* If the ref > 0, we mark the file as deleted and delete it when we close it. */ f->is_deleted = true; - spdk_blob_md_set_xattr(f->blob, "is_deleted", &f->is_deleted, sizeof(bool)); - spdk_bs_md_sync_blob(f->blob, blob_delete_cb, args); + spdk_blob_set_xattr(f->blob, "is_deleted", &f->is_deleted, sizeof(bool)); + spdk_blob_sync_md(f->blob, blob_delete_cb, args); return; } @@ -1434,15 +1434,15 @@ spdk_file_truncate_async(struct spdk_file *file, uint64_t length, num_clusters = __bytes_to_clusters(length, fs->bs_opts.cluster_sz); - spdk_bs_md_resize_blob(file->blob, num_clusters); - spdk_blob_md_set_xattr(file->blob, "length", &length, sizeof(length)); + spdk_blob_resize(file->blob, num_clusters); + spdk_blob_set_xattr(file->blob, "length", &length, sizeof(length)); file->length = length; if (file->append_pos > file->length) { file->append_pos = file->length; } - spdk_bs_md_sync_blob(file->blob, fs_truncate_complete_cb, args); + spdk_blob_sync_md(file->blob, fs_truncate_complete_cb, args); } static void @@ -1839,11 +1839,11 @@ __check_sync_reqs(struct spdk_file *file) if (sync_req != NULL && !sync_req->args.op.sync.xattr_in_progress) { BLOBFS_TRACE(file, "set xattr length 0x%jx\n", file->length_flushed); sync_req->args.op.sync.xattr_in_progress = true; - spdk_blob_md_set_xattr(file->blob, "length", &file->length_flushed, - sizeof(file->length_flushed)); + spdk_blob_set_xattr(file->blob, "length", &file->length_flushed, + sizeof(file->length_flushed)); pthread_spin_unlock(&file->lock); - spdk_bs_md_sync_blob(file->blob, __file_cache_finish_sync_bs_cb, file); + spdk_blob_sync_md(file->blob, __file_cache_finish_sync_bs_cb, file); } else { pthread_spin_unlock(&file->lock); } @@ -1942,9 +1942,9 @@ __file_extend_blob(void *_args) struct spdk_fs_cb_args *args = _args; struct spdk_file *file = args->file; - spdk_bs_md_resize_blob(file->blob, args->op.resize.num_clusters); + spdk_blob_resize(file->blob, args->op.resize.num_clusters); - spdk_bs_md_sync_blob(file->blob, __file_extend_done, args); + spdk_blob_sync_md(file->blob, __file_extend_done, args); } static void @@ -2369,7 +2369,7 @@ __file_close_async(struct spdk_file *file, struct spdk_fs_request *req) pthread_spin_unlock(&file->lock); - spdk_bs_md_close_blob(&file->blob, __file_close_async_done, req); + spdk_blob_close(&file->blob, __file_close_async_done, req); } static void diff --git a/lib/lvol/lvol.c b/lib/lvol/lvol.c index 704f503ed..5dc52a904 100644 --- a/lib/lvol/lvol.c +++ b/lib/lvol/lvol.c @@ -200,7 +200,7 @@ _spdk_load_next_lvol(void *cb_arg, struct spdk_blob *blob, int lvolerrno) goto invalid; } - rc = spdk_bs_md_get_xattr_value(blob, "name", (const void **)&attr, &value_len); + rc = spdk_blob_get_xattr_value(blob, "name", (const void **)&attr, &value_len); if (rc != 0 || value_len > SPDK_LVOL_NAME_MAX) { SPDK_ERRLOG("Cannot assign lvol name\n"); free(lvol->old_name); @@ -281,26 +281,26 @@ _spdk_lvs_read_uuid(void *cb_arg, struct spdk_blob *blob, int lvolerrno) return; } - rc = spdk_bs_md_get_xattr_value(blob, "uuid", (const void **)&attr, &value_len); + rc = spdk_blob_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_LOG_LVOL, "missing or incorrect UUID\n"); req->lvserrno = -EINVAL; - spdk_bs_md_close_blob(&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_bs_md_close_blob(&blob, _spdk_close_super_blob_with_error_cb, req); + spdk_blob_close(&blob, _spdk_close_super_blob_with_error_cb, req); return; } - rc = spdk_bs_md_get_xattr_value(blob, "name", (const void **)&attr, &value_len); + rc = spdk_blob_get_xattr_value(blob, "name", (const void **)&attr, &value_len); if (rc != 0 || value_len > SPDK_LVS_NAME_MAX) { 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); + 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_bs_md_close_blob(&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_bs_md_close_blob(&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_bs_md_close_blob(&blob, _spdk_super_create_close_cb, req); + spdk_blob_close(&blob, _spdk_super_create_close_cb, req); } static void @@ -450,9 +450,9 @@ _spdk_super_blob_init_cb(void *cb_arg, int lvolerrno) uuid_unparse(lvs->uuid, uuid); - spdk_blob_md_set_xattr(blob, "uuid", uuid, UUID_STRING_LEN); - spdk_blob_md_set_xattr(blob, "name", lvs->name, strnlen(lvs->name, SPDK_LVS_NAME_MAX) + 1); - spdk_bs_md_sync_blob(blob, _spdk_super_blob_set_cb, req); + spdk_blob_set_xattr(blob, "uuid", uuid, UUID_STRING_LEN); + spdk_blob_set_xattr(blob, "name", lvs->name, strnlen(lvs->name, SPDK_LVS_NAME_MAX) + 1); + spdk_blob_sync_md(blob, _spdk_super_blob_set_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_bs_md_close_blob(&lvol->blob, _spdk_lvol_delete_blob_cb, lvol); + spdk_blob_close(&lvol->blob, _spdk_lvol_delete_blob_cb, lvol); } else { lvol->ref_count++; } @@ -873,29 +873,29 @@ _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_bs_md_close_blob(&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); goto invalid; } - lvolerrno = spdk_bs_md_resize_blob(blob, lvol->num_clusters); + lvolerrno = spdk_blob_resize(blob, lvol->num_clusters); if (lvolerrno < 0) { - spdk_bs_md_close_blob(&blob, _spdk_lvol_destroy_cb, lvol); + spdk_blob_close(&blob, _spdk_lvol_destroy_cb, lvol); goto invalid; } - lvolerrno = spdk_blob_md_set_xattr(blob, "name", lvol->name, - strnlen(lvol->name, SPDK_LVOL_NAME_MAX) + 1); + lvolerrno = spdk_blob_set_xattr(blob, "name", lvol->name, + strnlen(lvol->name, SPDK_LVOL_NAME_MAX) + 1); if (lvolerrno < 0) { - spdk_bs_md_close_blob(&blob, _spdk_lvol_destroy_cb, lvol); + spdk_blob_close(&blob, _spdk_lvol_destroy_cb, lvol); goto invalid; } TAILQ_INSERT_TAIL(&lvol->lvol_store->lvols, lvol, link); - spdk_bs_md_sync_blob(blob, _spdk_lvol_sync_cb, req); + spdk_blob_sync_md(blob, _spdk_lvol_sync_cb, req); return; @@ -1029,16 +1029,16 @@ spdk_lvol_resize(struct spdk_lvol *lvol, uint64_t sz, req->cb_fn = cb_fn; req->cb_arg = cb_arg; - rc = spdk_bs_md_resize_blob(blob, sz); + rc = spdk_blob_resize(blob, sz); if (rc < 0) { goto invalid; } lvol->num_clusters = new_clusters; - spdk_blob_md_set_xattr(blob, "length", &sz, sizeof(sz)); + spdk_blob_set_xattr(blob, "length", &sz, sizeof(sz)); - spdk_bs_md_sync_blob(blob, _spdk_lvol_resize_cb, req); + spdk_blob_sync_md(blob, _spdk_lvol_resize_cb, req); return rc; @@ -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_bs_md_close_blob(&(lvol->blob), _spdk_lvol_close_blob_cb, req); + spdk_blob_close(&(lvol->blob), _spdk_lvol_close_blob_cb, req); } struct spdk_io_channel * diff --git a/test/unit/lib/bdev/vbdev_lvol.c/vbdev_lvol_ut.c b/test/unit/lib/bdev/vbdev_lvol.c/vbdev_lvol_ut.c index 4da114cb6..d1fb032fa 100644 --- a/test/unit/lib/bdev/vbdev_lvol.c/vbdev_lvol_ut.c +++ b/test/unit/lib/bdev/vbdev_lvol.c/vbdev_lvol_ut.c @@ -71,7 +71,7 @@ spdk_lvol_open(struct spdk_lvol *lvol, spdk_lvol_op_with_handle_complete cb_fn, } void -spdk_bs_md_close_blob(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) { } diff --git a/test/unit/lib/blob/blob.c/blob_ut.c b/test/unit/lib/blob/blob.c/blob_ut.c index 9e44de8a7..8e0135521 100644 --- a/test/unit/lib/blob/blob.c/blob_ut.c +++ b/test/unit/lib/blob/blob.c/blob_ut.c @@ -238,7 +238,7 @@ blob_open(void) CU_ASSERT(g_bserrno == 0); CU_ASSERT(blob == g_blob); - spdk_bs_md_close_blob(&blob, blob_op_complete, NULL); + spdk_blob_close(&blob, blob_op_complete, NULL); CU_ASSERT(g_bserrno == 0); CU_ASSERT(blob == NULL); @@ -247,7 +247,7 @@ blob_open(void) * should succeed. */ blob = g_blob; - spdk_bs_md_close_blob(&blob, blob_op_complete, NULL); + spdk_blob_close(&blob, blob_op_complete, NULL); CU_ASSERT(g_bserrno == 0); /* @@ -259,7 +259,7 @@ blob_open(void) CU_ASSERT(g_blob != NULL); blob = g_blob; - spdk_bs_md_close_blob(&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); @@ -330,34 +330,34 @@ blob_resize(void) /* Confirm that resize fails if blob is marked read-only. */ __blob_to_data(blob)->md_ro = true; - rc = spdk_bs_md_resize_blob(blob, 5); + rc = spdk_blob_resize(blob, 5); CU_ASSERT(rc == -EPERM); __blob_to_data(blob)->md_ro = false; /* The blob started at 0 clusters. Resize it to be 5. */ - rc = spdk_bs_md_resize_blob(blob, 5); + rc = spdk_blob_resize(blob, 5); CU_ASSERT(rc == 0); CU_ASSERT((free_clusters - 5) == spdk_bs_free_cluster_count(bs)); /* Shrink the blob to 3 clusters. This will not actually release * the old clusters until the blob is synced. */ - rc = spdk_bs_md_resize_blob(blob, 3); + rc = spdk_blob_resize(blob, 3); CU_ASSERT(rc == 0); /* Verify there are still 5 clusters in use */ CU_ASSERT((free_clusters - 5) == spdk_bs_free_cluster_count(bs)); - spdk_bs_md_sync_blob(blob, blob_op_complete, NULL); + spdk_blob_sync_md(blob, blob_op_complete, NULL); CU_ASSERT(g_bserrno == 0); /* Now there are only 3 clusters in use */ CU_ASSERT((free_clusters - 3) == spdk_bs_free_cluster_count(bs)); /* Resize the blob to be 10 clusters. Growth takes effect immediately. */ - rc = spdk_bs_md_resize_blob(blob, 10); + rc = spdk_blob_resize(blob, 10); CU_ASSERT(rc == 0); CU_ASSERT((free_clusters - 10) == spdk_bs_free_cluster_count(bs)); - spdk_bs_md_close_blob(&blob, blob_op_complete, NULL); + spdk_blob_close(&blob, blob_op_complete, NULL); CU_ASSERT(g_bserrno == 0); spdk_bs_md_delete_blob(bs, blobid, blob_op_complete, NULL); @@ -431,7 +431,7 @@ blob_write(void) CU_ASSERT(g_bserrno == -EINVAL); /* Resize the blob */ - rc = spdk_bs_md_resize_blob(blob, 5); + rc = spdk_blob_resize(blob, 5); CU_ASSERT(rc == 0); /* Confirm that write fails if blob is marked read-only. */ @@ -454,7 +454,7 @@ blob_write(void) blob_op_complete, NULL); CU_ASSERT(g_bserrno == -EINVAL); - spdk_bs_md_close_blob(&blob, blob_op_complete, NULL); + spdk_blob_close(&blob, blob_op_complete, NULL); CU_ASSERT(g_bserrno == 0); spdk_bs_free_io_channel(channel); @@ -503,7 +503,7 @@ blob_read(void) CU_ASSERT(g_bserrno == -EINVAL); /* Resize the blob */ - rc = spdk_bs_md_resize_blob(blob, 5); + rc = spdk_blob_resize(blob, 5); CU_ASSERT(rc == 0); /* Confirm that read passes if blob is marked read-only. */ @@ -526,7 +526,7 @@ blob_read(void) blob_op_complete, NULL); CU_ASSERT(g_bserrno == -EINVAL); - spdk_bs_md_close_blob(&blob, blob_op_complete, NULL); + spdk_blob_close(&blob, blob_op_complete, NULL); CU_ASSERT(g_bserrno == 0); spdk_bs_free_io_channel(channel); @@ -568,7 +568,7 @@ blob_rw_verify(void) CU_ASSERT(g_blob != NULL); blob = g_blob; - rc = spdk_bs_md_resize_blob(blob, 32); + rc = spdk_blob_resize(blob, 32); CU_ASSERT(rc == 0); memset(payload_write, 0xE5, sizeof(payload_write)); @@ -580,7 +580,7 @@ blob_rw_verify(void) CU_ASSERT(g_bserrno == 0); CU_ASSERT(memcmp(payload_write, payload_read, 4 * 4096) == 0); - spdk_bs_md_close_blob(&blob, blob_op_complete, NULL); + spdk_blob_close(&blob, blob_op_complete, NULL); CU_ASSERT(g_bserrno == 0); spdk_bs_free_io_channel(channel); @@ -626,7 +626,7 @@ blob_rw_verify_iov(void) SPDK_CU_ASSERT_FATAL(g_blob != NULL); blob = g_blob; - rc = spdk_bs_md_resize_blob(blob, 2); + rc = spdk_blob_resize(blob, 2); CU_ASSERT(rc == 0); /* @@ -670,7 +670,7 @@ blob_rw_verify_iov(void) CU_ASSERT(memcmp(buf, &g_dev_buffer[512 * 4096], 256 * 4096) == 0); free(buf); - spdk_bs_md_close_blob(&blob, blob_op_complete, NULL); + spdk_blob_close(&blob, blob_op_complete, NULL); CU_ASSERT(g_bserrno == 0); spdk_bs_free_io_channel(channel); @@ -728,7 +728,7 @@ blob_rw_verify_iov_nomem(void) CU_ASSERT(g_blob != NULL); blob = g_blob; - rc = spdk_bs_md_resize_blob(blob, 2); + rc = spdk_blob_resize(blob, 2); CU_ASSERT(rc == 0); /* @@ -748,7 +748,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_bs_md_close_blob(&blob, blob_op_complete, NULL); + spdk_blob_close(&blob, blob_op_complete, NULL); CU_ASSERT(g_bserrno == 0); spdk_bs_free_io_channel(channel); @@ -793,7 +793,7 @@ blob_rw_iov_read_only(void) SPDK_CU_ASSERT_FATAL(g_blob != NULL); blob = g_blob; - rc = spdk_bs_md_resize_blob(blob, 2); + rc = spdk_blob_resize(blob, 2); CU_ASSERT(rc == 0); /* Verify that writev failed if read_only flag is set. */ @@ -809,7 +809,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_bs_md_close_blob(&blob, blob_op_complete, NULL); + spdk_blob_close(&blob, blob_op_complete, NULL); CU_ASSERT(g_bserrno == 0); spdk_bs_free_io_channel(channel); @@ -891,37 +891,37 @@ blob_xattr(void) /* Test that set_xattr fails if md_ro flag is set. */ __blob_to_data(blob)->md_ro = true; - rc = spdk_blob_md_set_xattr(blob, "name", "log.txt", strlen("log.txt") + 1); + rc = spdk_blob_set_xattr(blob, "name", "log.txt", strlen("log.txt") + 1); CU_ASSERT(rc == -EPERM); __blob_to_data(blob)->md_ro = false; - rc = spdk_blob_md_set_xattr(blob, "name", "log.txt", strlen("log.txt") + 1); + rc = spdk_blob_set_xattr(blob, "name", "log.txt", strlen("log.txt") + 1); CU_ASSERT(rc == 0); length = 2345; - rc = spdk_blob_md_set_xattr(blob, "length", &length, sizeof(length)); + rc = spdk_blob_set_xattr(blob, "length", &length, sizeof(length)); CU_ASSERT(rc == 0); /* Overwrite "length" xattr. */ length = 3456; - rc = spdk_blob_md_set_xattr(blob, "length", &length, sizeof(length)); + rc = spdk_blob_set_xattr(blob, "length", &length, sizeof(length)); CU_ASSERT(rc == 0); /* get_xattr should still work even if md_ro flag is set. */ value = NULL; __blob_to_data(blob)->md_ro = true; - rc = spdk_bs_md_get_xattr_value(blob, "length", &value, &value_len); + rc = spdk_blob_get_xattr_value(blob, "length", &value, &value_len); CU_ASSERT(rc == 0); SPDK_CU_ASSERT_FATAL(value != NULL); CU_ASSERT(*(uint64_t *)value == length); CU_ASSERT(value_len == 8); __blob_to_data(blob)->md_ro = false; - rc = spdk_bs_md_get_xattr_value(blob, "foobar", &value, &value_len); + rc = spdk_blob_get_xattr_value(blob, "foobar", &value, &value_len); CU_ASSERT(rc == -ENOENT); names = NULL; - rc = spdk_bs_md_get_xattr_names(blob, &names); + rc = spdk_blob_get_xattr_names(blob, &names); CU_ASSERT(rc == 0); SPDK_CU_ASSERT_FATAL(names != NULL); CU_ASSERT(spdk_xattr_names_get_count(names) == 2); @@ -936,17 +936,17 @@ blob_xattr(void) /* Confirm that remove_xattr fails if md_ro is set to true. */ __blob_to_data(blob)->md_ro = true; - rc = spdk_blob_md_remove_xattr(blob, "name"); + rc = spdk_blob_remove_xattr(blob, "name"); CU_ASSERT(rc == -EPERM); __blob_to_data(blob)->md_ro = false; - rc = spdk_blob_md_remove_xattr(blob, "name"); + rc = spdk_blob_remove_xattr(blob, "name"); CU_ASSERT(rc == 0); - rc = spdk_blob_md_remove_xattr(blob, "foobar"); + rc = spdk_blob_remove_xattr(blob, "foobar"); CU_ASSERT(rc == -ENOENT); - spdk_bs_md_close_blob(&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); @@ -999,18 +999,18 @@ bs_load(void) CU_ASSERT(g_blob == NULL); /* Set some xattrs */ - rc = spdk_blob_md_set_xattr(blob, "name", "log.txt", strlen("log.txt") + 1); + rc = spdk_blob_set_xattr(blob, "name", "log.txt", strlen("log.txt") + 1); CU_ASSERT(rc == 0); length = 2345; - rc = spdk_blob_md_set_xattr(blob, "length", &length, sizeof(length)); + rc = spdk_blob_set_xattr(blob, "length", &length, sizeof(length)); CU_ASSERT(rc == 0); /* Resize the blob */ - rc = spdk_bs_md_resize_blob(blob, 10); + rc = spdk_blob_resize(blob, 10); CU_ASSERT(rc == 0); - spdk_bs_md_close_blob(&blob, blob_op_complete, NULL); + spdk_blob_close(&blob, blob_op_complete, NULL); CU_ASSERT(g_bserrno == 0); blob = NULL; g_blob = NULL; @@ -1044,18 +1044,18 @@ bs_load(void) /* Get the xattrs */ value = NULL; - rc = spdk_bs_md_get_xattr_value(blob, "length", &value, &value_len); + rc = spdk_blob_get_xattr_value(blob, "length", &value, &value_len); CU_ASSERT(rc == 0); SPDK_CU_ASSERT_FATAL(value != NULL); CU_ASSERT(*(uint64_t *)value == length); CU_ASSERT(value_len == 8); - rc = spdk_bs_md_get_xattr_value(blob, "foobar", &value, &value_len); + rc = spdk_blob_get_xattr_value(blob, "foobar", &value, &value_len); CU_ASSERT(rc == -ENOENT); CU_ASSERT(spdk_blob_get_num_clusters(blob) == 10); - spdk_bs_md_close_blob(&blob, blob_op_complete, NULL); + spdk_blob_close(&blob, blob_op_complete, NULL); CU_ASSERT(g_bserrno == 0); blob = NULL; g_blob = NULL; @@ -1238,7 +1238,7 @@ bs_unload(void) /* Close the blob, then successfully unload blobstore */ g_bserrno = -1; - spdk_bs_md_close_blob(&blob, blob_op_complete, NULL); + spdk_blob_close(&blob, blob_op_complete, NULL); CU_ASSERT(g_bserrno == 0); CU_ASSERT(blob == NULL); @@ -1377,11 +1377,11 @@ bs_usable_clusters(void) CU_ASSERT(g_bserrno == 0); CU_ASSERT(g_blob != NULL); - rc = spdk_bs_md_resize_blob(g_blob, 10); + rc = spdk_blob_resize(g_blob, 10); CU_ASSERT(rc == 0); g_bserrno = -1; - spdk_bs_md_close_blob(&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); @@ -1466,7 +1466,7 @@ bs_resize_md(void) CU_ASSERT(g_bserrno == 0); CU_ASSERT(g_blob != NULL); g_bserrno = -1; - spdk_bs_md_close_blob(&g_blob, blob_op_complete, NULL); + spdk_blob_close(&g_blob, blob_op_complete, NULL); CU_ASSERT(g_bserrno == 0); } @@ -1555,7 +1555,7 @@ blob_serialize(void) value = calloc(dev->blocklen - 64, sizeof(char)); SPDK_CU_ASSERT_FATAL(value != NULL); memset(value, i, dev->blocklen / 2); - rc = spdk_blob_md_set_xattr(blob[i], "name", value, dev->blocklen - 64); + rc = spdk_blob_set_xattr(blob[i], "name", value, dev->blocklen - 64); CU_ASSERT(rc == 0); free(value); } @@ -1565,18 +1565,18 @@ blob_serialize(void) * over of the extents. */ for (i = 0; i < 6; i++) { - rc = spdk_bs_md_resize_blob(blob[i % 2], (i / 2) + 1); + rc = spdk_blob_resize(blob[i % 2], (i / 2) + 1); CU_ASSERT(rc == 0); } for (i = 0; i < 2; i++) { - spdk_bs_md_sync_blob(blob[i], blob_op_complete, NULL); + spdk_blob_sync_md(blob[i], blob_op_complete, NULL); CU_ASSERT(g_bserrno == 0); } /* Close the blobs */ for (i = 0; i < 2; i++) { - spdk_bs_md_close_blob(&blob[i], blob_op_complete, NULL); + spdk_blob_close(&blob[i], blob_op_complete, NULL); CU_ASSERT(g_bserrno == 0); } @@ -1605,7 +1605,7 @@ blob_serialize(void) CU_ASSERT(spdk_blob_get_num_clusters(blob[i]) == 3); - spdk_bs_md_close_blob(&blob[i], blob_op_complete, NULL); + spdk_blob_close(&blob[i], blob_op_complete, NULL); CU_ASSERT(g_bserrno == 0); } @@ -1642,7 +1642,7 @@ blob_crc(void) CU_ASSERT(g_blob != NULL); blob = g_blob; - spdk_bs_md_close_blob(&blob, blob_op_complete, NULL); + spdk_blob_close(&blob, blob_op_complete, NULL); CU_ASSERT(g_bserrno == 0); CU_ASSERT(blob == NULL); @@ -1745,18 +1745,18 @@ blob_dirty_shutdown(void) blob = g_blob; /* Set some xattrs */ - rc = spdk_blob_md_set_xattr(blob, "name", "log.txt", strlen("log.txt") + 1); + rc = spdk_blob_set_xattr(blob, "name", "log.txt", strlen("log.txt") + 1); CU_ASSERT(rc == 0); length = 2345; - rc = spdk_blob_md_set_xattr(blob, "length", &length, sizeof(length)); + rc = spdk_blob_set_xattr(blob, "length", &length, sizeof(length)); CU_ASSERT(rc == 0); /* Resize the blob */ - rc = spdk_bs_md_resize_blob(blob, 10); + rc = spdk_blob_resize(blob, 10); CU_ASSERT(rc == 0); - spdk_bs_md_close_blob(&blob, blob_op_complete, NULL); + spdk_blob_close(&blob, blob_op_complete, NULL); blob = NULL; g_blob = NULL; g_blobid = SPDK_BLOBID_INVALID; @@ -1777,7 +1777,7 @@ blob_dirty_shutdown(void) /* Get the xattrs */ value = NULL; - rc = spdk_bs_md_get_xattr_value(blob, "length", &value, &value_len); + rc = spdk_blob_get_xattr_value(blob, "length", &value, &value_len); CU_ASSERT(rc == 0); SPDK_CU_ASSERT_FATAL(value != NULL); CU_ASSERT(*(uint64_t *)value == length); @@ -1785,10 +1785,10 @@ blob_dirty_shutdown(void) CU_ASSERT(spdk_blob_get_num_clusters(blob) == 10); /* Resize the blob */ - rc = spdk_bs_md_resize_blob(blob, 20); + rc = spdk_blob_resize(blob, 20); CU_ASSERT(rc == 0); - spdk_bs_md_close_blob(&blob, blob_op_complete, NULL); + spdk_blob_close(&blob, blob_op_complete, NULL); CU_ASSERT(g_bserrno == 0); blob = NULL; g_blob = NULL; @@ -1810,7 +1810,7 @@ blob_dirty_shutdown(void) blob = g_blob; CU_ASSERT(spdk_blob_get_num_clusters(blob) == 20); - spdk_bs_md_close_blob(&blob, blob_op_complete, NULL); + spdk_blob_close(&blob, blob_op_complete, NULL); CU_ASSERT(g_bserrno == 0); blob = NULL; g_blob = NULL; @@ -1828,18 +1828,18 @@ blob_dirty_shutdown(void) blob = g_blob; /* Set some xattrs */ - rc = spdk_blob_md_set_xattr(blob, "name", "log1.txt", strlen("log1.txt") + 1); + rc = spdk_blob_set_xattr(blob, "name", "log1.txt", strlen("log1.txt") + 1); CU_ASSERT(rc == 0); length = 5432; - rc = spdk_blob_md_set_xattr(blob, "length", &length, sizeof(length)); + rc = spdk_blob_set_xattr(blob, "length", &length, sizeof(length)); CU_ASSERT(rc == 0); /* Resize the blob */ - rc = spdk_bs_md_resize_blob(blob, 10); + rc = spdk_blob_resize(blob, 10); CU_ASSERT(rc == 0); - spdk_bs_md_close_blob(&blob, blob_op_complete, NULL); + spdk_blob_close(&blob, blob_op_complete, NULL); blob = NULL; g_blob = NULL; g_blobid = SPDK_BLOBID_INVALID; @@ -1860,14 +1860,14 @@ blob_dirty_shutdown(void) /* Get the xattrs */ value = NULL; - rc = spdk_bs_md_get_xattr_value(blob, "length", &value, &value_len); + rc = spdk_blob_get_xattr_value(blob, "length", &value, &value_len); CU_ASSERT(rc == 0); SPDK_CU_ASSERT_FATAL(value != NULL); CU_ASSERT(*(uint64_t *)value == length); CU_ASSERT(value_len == 8); CU_ASSERT(spdk_blob_get_num_clusters(blob) == 10); - spdk_bs_md_close_blob(&blob, blob_op_complete, NULL); + spdk_blob_close(&blob, blob_op_complete, NULL); CU_ASSERT(g_bserrno == 0); spdk_bs_md_delete_blob(g_bs, blobid2, blob_op_complete, NULL); CU_ASSERT(g_bserrno == 0); @@ -1887,7 +1887,7 @@ blob_dirty_shutdown(void) spdk_bs_md_open_blob(g_bs, blobid1, blob_op_with_handle_complete, NULL); CU_ASSERT(g_bserrno == 0); CU_ASSERT(g_blob != NULL); - spdk_bs_md_close_blob(&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); @@ -1918,14 +1918,14 @@ blob_dirty_shutdown(void) blob = g_blob; /* Set some xattrs for second blob */ - rc = spdk_blob_md_set_xattr(blob, "name", "log1.txt", strlen("log1.txt") + 1); + rc = spdk_blob_set_xattr(blob, "name", "log1.txt", strlen("log1.txt") + 1); CU_ASSERT(rc == 0); length = 5432; - rc = spdk_blob_md_set_xattr(blob, "length", &length, sizeof(length)); + rc = spdk_blob_set_xattr(blob, "length", &length, sizeof(length)); CU_ASSERT(rc == 0); - spdk_bs_md_close_blob(&blob, blob_op_complete, NULL); + spdk_blob_close(&blob, blob_op_complete, NULL); blob = NULL; g_blob = NULL; g_blobid = SPDK_BLOBID_INVALID; @@ -1936,14 +1936,14 @@ blob_dirty_shutdown(void) blob = g_blob; /* Set some xattrs for third blob */ - rc = spdk_blob_md_set_xattr(blob, "name", "log2.txt", strlen("log2.txt") + 1); + rc = spdk_blob_set_xattr(blob, "name", "log2.txt", strlen("log2.txt") + 1); CU_ASSERT(rc == 0); length = 5432; - rc = spdk_blob_md_set_xattr(blob, "length", &length, sizeof(length)); + rc = spdk_blob_set_xattr(blob, "length", &length, sizeof(length)); CU_ASSERT(rc == 0); - spdk_bs_md_close_blob(&blob, blob_op_complete, NULL); + spdk_blob_close(&blob, blob_op_complete, NULL); blob = NULL; g_blob = NULL; g_blobid = SPDK_BLOBID_INVALID; @@ -1973,7 +1973,7 @@ blob_dirty_shutdown(void) CU_ASSERT(g_blob != NULL); blob = g_blob; - spdk_bs_md_close_blob(&blob, blob_op_complete, NULL); + spdk_blob_close(&blob, blob_op_complete, NULL); blob = NULL; g_blob = NULL; g_blobid = SPDK_BLOBID_INVALID; @@ -2038,25 +2038,25 @@ blob_flags(void) __blob_to_data(blob_md_ro)->state = SPDK_BLOB_STATE_DIRTY; g_bserrno = -1; - spdk_bs_md_sync_blob(blob_invalid, blob_op_complete, NULL); + spdk_blob_sync_md(blob_invalid, blob_op_complete, NULL); CU_ASSERT(g_bserrno == 0); g_bserrno = -1; - spdk_bs_md_sync_blob(blob_data_ro, blob_op_complete, NULL); + spdk_blob_sync_md(blob_data_ro, blob_op_complete, NULL); CU_ASSERT(g_bserrno == 0); g_bserrno = -1; - spdk_bs_md_sync_blob(blob_md_ro, blob_op_complete, NULL); + spdk_blob_sync_md(blob_md_ro, blob_op_complete, NULL); CU_ASSERT(g_bserrno == 0); g_bserrno = -1; - spdk_bs_md_close_blob(&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_bs_md_close_blob(&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_bs_md_close_blob(&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; @@ -2099,9 +2099,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_bs_md_close_blob(&blob_data_ro, blob_op_complete, NULL); + spdk_blob_close(&blob_data_ro, blob_op_complete, NULL); CU_ASSERT(g_bserrno == 0); - spdk_bs_md_close_blob(&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); diff --git a/test/unit/lib/lvol/lvol.c/lvol_ut.c b/test/unit/lib/lvol/lvol.c/lvol_ut.c index 6a4e9eccb..97f00fd39 100644 --- a/test/unit/lib/lvol/lvol.c/lvol_ut.c +++ b/test/unit/lib/lvol/lvol.c/lvol_ut.c @@ -165,8 +165,8 @@ struct spdk_io_channel *spdk_bs_alloc_io_channel(struct spdk_blob_store *bs) } int -spdk_blob_md_set_xattr(struct spdk_blob *blob, const char *name, const void *value, - uint16_t value_len) +spdk_blob_set_xattr(struct spdk_blob *blob, const char *name, const void *value, + uint16_t value_len) { if (!strcmp(name, "uuid")) { CU_ASSERT(value_len == UUID_STRING_LEN); @@ -180,8 +180,8 @@ spdk_blob_md_set_xattr(struct spdk_blob *blob, const char *name, const void *val } int -spdk_bs_md_get_xattr_value(struct spdk_blob *blob, const char *name, - const void **value, size_t *value_len) +spdk_blob_get_xattr_value(struct spdk_blob *blob, const char *name, + const void **value, size_t *value_len) { if (!strcmp(name, "uuid") && strnlen(blob->uuid, UUID_STRING_LEN) != 0) { CU_ASSERT(strnlen(blob->uuid, UUID_STRING_LEN) == (UUID_STRING_LEN - 1)); @@ -303,8 +303,7 @@ spdk_bs_get_cluster_size(struct spdk_blob_store *bs) return BS_CLUSTER_SIZE; } -void spdk_bs_md_close_blob(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--; @@ -312,14 +311,13 @@ void spdk_bs_md_close_blob(struct spdk_blob **b, } int -spdk_bs_md_resize_blob(struct spdk_blob *blob, uint64_t sz) +spdk_blob_resize(struct spdk_blob *blob, uint64_t sz) { return g_resize_rc; } void -spdk_bs_md_sync_blob(struct spdk_blob *blob, - spdk_blob_op_complete cb_fn, void *cb_arg) +spdk_blob_sync_md(struct spdk_blob *blob, spdk_blob_op_complete cb_fn, void *cb_arg) { cb_fn(cb_arg, 0); } @@ -995,7 +993,7 @@ lvs_load(void) /* Fail on getting name */ g_lvserrno = 0; - spdk_blob_md_set_xattr(super_blob, "uuid", uuid, UUID_STRING_LEN); + spdk_blob_set_xattr(super_blob, "uuid", uuid, UUID_STRING_LEN); spdk_lvs_load(&dev.bs_dev, lvol_store_op_with_handle_complete, req); CU_ASSERT(g_lvserrno == -EINVAL); CU_ASSERT(g_lvol_store == NULL); @@ -1003,7 +1001,7 @@ lvs_load(void) /* Fail on closing super blob */ g_lvserrno = 0; - spdk_blob_md_set_xattr(super_blob, "name", "lvs", strnlen("lvs", SPDK_LVS_NAME_MAX) + 1); + spdk_blob_set_xattr(super_blob, "name", "lvs", strnlen("lvs", SPDK_LVS_NAME_MAX) + 1); super_blob->close_status = -1; spdk_lvs_load(&dev.bs_dev, lvol_store_op_with_handle_complete, req); CU_ASSERT(g_lvserrno == -ENODEV); @@ -1049,8 +1047,8 @@ lvols_load(void) super_blob = calloc(1, sizeof(*super_blob)); SPDK_CU_ASSERT_FATAL(super_blob != NULL); super_blob->id = 0x100; - spdk_blob_md_set_xattr(super_blob, "uuid", uuid, UUID_STRING_LEN); - spdk_blob_md_set_xattr(super_blob, "name", "lvs", strnlen("lvs", SPDK_LVS_NAME_MAX) + 1); + spdk_blob_set_xattr(super_blob, "uuid", uuid, UUID_STRING_LEN); + spdk_blob_set_xattr(super_blob, "name", "lvs", strnlen("lvs", SPDK_LVS_NAME_MAX) + 1); TAILQ_INSERT_TAIL(&dev.bs->blobs, super_blob, link); dev.bs->super_blobid = 0x100; @@ -1061,22 +1059,22 @@ lvols_load(void) blob1 = calloc(1, sizeof(*blob1)); SPDK_CU_ASSERT_FATAL(blob1 != NULL); blob1->id = 0x1; - spdk_blob_md_set_xattr(blob1, "uuid", uuid, UUID_STRING_LEN); - spdk_blob_md_set_xattr(blob1, "name", "lvol1", strnlen("lvol1", SPDK_LVOL_NAME_MAX) + 1); + spdk_blob_set_xattr(blob1, "uuid", uuid, UUID_STRING_LEN); + spdk_blob_set_xattr(blob1, "name", "lvol1", strnlen("lvol1", SPDK_LVOL_NAME_MAX) + 1); blob1->uuid[UUID_STRING_LEN - 2] = '1'; blob2 = calloc(1, sizeof(*blob2)); SPDK_CU_ASSERT_FATAL(blob2 != NULL); blob2->id = 0x2; - spdk_blob_md_set_xattr(blob2, "uuid", uuid, UUID_STRING_LEN); - spdk_blob_md_set_xattr(blob2, "name", "lvol2", strnlen("lvol2", SPDK_LVOL_NAME_MAX) + 1); + spdk_blob_set_xattr(blob2, "uuid", uuid, UUID_STRING_LEN); + spdk_blob_set_xattr(blob2, "name", "lvol2", strnlen("lvol2", SPDK_LVOL_NAME_MAX) + 1); blob2->uuid[UUID_STRING_LEN - 2] = '2'; blob3 = calloc(1, sizeof(*blob3)); SPDK_CU_ASSERT_FATAL(blob3 != NULL); blob3->id = 0x2; - spdk_blob_md_set_xattr(blob3, "uuid", uuid, UUID_STRING_LEN); - spdk_blob_md_set_xattr(blob3, "name", "lvol3", strnlen("lvol3", SPDK_LVOL_NAME_MAX) + 1); + spdk_blob_set_xattr(blob3, "uuid", uuid, UUID_STRING_LEN); + spdk_blob_set_xattr(blob3, "name", "lvol3", strnlen("lvol3", SPDK_LVOL_NAME_MAX) + 1); blob3->uuid[UUID_STRING_LEN - 2] = '3'; spdk_allocate_thread(_lvol_send_msg, NULL, NULL, NULL, NULL); @@ -1160,8 +1158,8 @@ lvol_open(void) super_blob = calloc(1, sizeof(*super_blob)); SPDK_CU_ASSERT_FATAL(super_blob != NULL); super_blob->id = 0x100; - spdk_blob_md_set_xattr(super_blob, "uuid", uuid, UUID_STRING_LEN); - spdk_blob_md_set_xattr(super_blob, "name", "lvs", strnlen("lvs", SPDK_LVS_NAME_MAX) + 1); + spdk_blob_set_xattr(super_blob, "uuid", uuid, UUID_STRING_LEN); + spdk_blob_set_xattr(super_blob, "name", "lvs", strnlen("lvs", SPDK_LVS_NAME_MAX) + 1); TAILQ_INSERT_TAIL(&dev.bs->blobs, super_blob, link); dev.bs->super_blobid = 0x100; @@ -1172,22 +1170,22 @@ lvol_open(void) blob1 = calloc(1, sizeof(*blob1)); SPDK_CU_ASSERT_FATAL(blob1 != NULL); blob1->id = 0x1; - spdk_blob_md_set_xattr(blob1, "uuid", uuid, UUID_STRING_LEN); - spdk_blob_md_set_xattr(blob1, "name", "lvol1", strnlen("lvol1", SPDK_LVOL_NAME_MAX) + 1); + spdk_blob_set_xattr(blob1, "uuid", uuid, UUID_STRING_LEN); + spdk_blob_set_xattr(blob1, "name", "lvol1", strnlen("lvol1", SPDK_LVOL_NAME_MAX) + 1); blob1->uuid[UUID_STRING_LEN - 2] = '1'; blob2 = calloc(1, sizeof(*blob2)); SPDK_CU_ASSERT_FATAL(blob2 != NULL); blob2->id = 0x2; - spdk_blob_md_set_xattr(blob2, "uuid", uuid, UUID_STRING_LEN); - spdk_blob_md_set_xattr(blob2, "name", "lvol2", strnlen("lvol2", SPDK_LVOL_NAME_MAX) + 1); + spdk_blob_set_xattr(blob2, "uuid", uuid, UUID_STRING_LEN); + spdk_blob_set_xattr(blob2, "name", "lvol2", strnlen("lvol2", SPDK_LVOL_NAME_MAX) + 1); blob2->uuid[UUID_STRING_LEN - 2] = '2'; blob3 = calloc(1, sizeof(*blob3)); SPDK_CU_ASSERT_FATAL(blob3 != NULL); blob3->id = 0x2; - spdk_blob_md_set_xattr(blob3, "uuid", uuid, UUID_STRING_LEN); - spdk_blob_md_set_xattr(blob3, "name", "lvol3", strnlen("lvol3", SPDK_LVOL_NAME_MAX) + 1); + spdk_blob_set_xattr(blob3, "uuid", uuid, UUID_STRING_LEN); + spdk_blob_set_xattr(blob3, "name", "lvol3", strnlen("lvol3", SPDK_LVOL_NAME_MAX) + 1); blob3->uuid[UUID_STRING_LEN - 2] = '3'; spdk_allocate_thread(_lvol_send_msg, NULL, NULL, NULL, NULL);