d/numam-spdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

blob: rename spdk blob metadata functions

Browse Source 
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 <james.r.harris@intel.com>
Change-Id: I99b593c03bc61354ba6aa5a446b0fc82df1e9ce2

Reviewed-on: https://review.gerrithub.io/391006
Reviewed-by: Ben Walker <benjamin.walker@intel.com>
Tested-by: SPDK Automated Test System <sys_sgsw@intel.com>
Reviewed-by: Daniel Verkamp <daniel.verkamp@intel.com>
This commit is contained in:
Jim Harris 2017-12-08 09:38:33 -07:00
parent c2009e9e85
commit 2c3591f183
11 changed files with 212 additions and 219 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
CHANGELOG.md
View File

@ -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

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

@ -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);
}
}

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

@ -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);
}
/*

27
include/spdk/blob.h
View File

@ -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);

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

@ -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);

40
lib/blob/blobstore.c
View File

@ -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;

40
lib/blobfs/blobfs.c
View File

@ -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

48
lib/lvol/lvol.c
View File

@ -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 *

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_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)
{
}

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

@ -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);

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

@ -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);