static pthread_mutex_t g_lvol_stores_mutex = PTHREAD_MUTEX_INITIALIZER;
static int
-_spdk_add_lvs_to_list(struct spdk_lvol_store *lvs)
+add_lvs_to_list(struct spdk_lvol_store *lvs)
{
struct spdk_lvol_store *tmp;
bool name_conflict = false;
}
static void
-_spdk_lvs_free(struct spdk_lvol_store *lvs)
+lvs_free(struct spdk_lvol_store *lvs)
{
pthread_mutex_lock(&g_lvol_stores_mutex);
if (lvs->on_list) {
}
static void
-_spdk_lvol_free(struct spdk_lvol *lvol)
+lvol_free(struct spdk_lvol *lvol)
{
free(lvol);
}
static void
-_spdk_lvol_open_cb(void *cb_arg, struct spdk_blob *blob, int lvolerrno)
+lvol_open_cb(void *cb_arg, struct spdk_blob *blob, int lvolerrno)
{
struct spdk_lvol_with_handle_req *req = cb_arg;
struct spdk_lvol *lvol = req->lvol;
spdk_blob_open_opts_init(&opts);
opts.clear_method = lvol->clear_method;
- spdk_bs_open_blob_ext(lvol->lvol_store->blobstore, lvol->blob_id, &opts, _spdk_lvol_open_cb, req);
+ spdk_bs_open_blob_ext(lvol->lvol_store->blobstore, lvol->blob_id, &opts, lvol_open_cb, req);
}
static void
-_spdk_bs_unload_with_error_cb(void *cb_arg, int lvolerrno)
+bs_unload_with_error_cb(void *cb_arg, int lvolerrno)
{
struct spdk_lvs_with_handle_req *req = (struct spdk_lvs_with_handle_req *)cb_arg;
}
static void
-_spdk_load_next_lvol(void *cb_arg, struct spdk_blob *blob, int lvolerrno)
+load_next_lvol(void *cb_arg, struct spdk_blob *blob, int lvolerrno)
{
struct spdk_lvs_with_handle_req *req = cb_arg;
struct spdk_lvol_store *lvs = req->lvol_store;
struct spdk_lvol *lvol, *tmp;
spdk_blob_id blob_id;
const char *attr;
- const enum blob_clear_method *clear_method;
size_t value_len;
int rc;
if (blob_id == lvs->super_blob_id) {
SPDK_INFOLOG(SPDK_LOG_LVOL, "found superblob %"PRIu64"\n", (uint64_t)blob_id);
- spdk_bs_iter_next(bs, blob, _spdk_load_next_lvol, req);
+ spdk_bs_iter_next(bs, blob, load_next_lvol, req);
return;
}
lvol->blob = blob;
lvol->blob_id = blob_id;
lvol->lvol_store = lvs;
+ lvol->thin_provision = spdk_blob_is_thin_provisioned(blob);
rc = spdk_blob_get_xattr_value(blob, "uuid", (const void **)&attr, &value_len);
if (rc != 0 || value_len != SPDK_UUID_STRING_LEN || attr[SPDK_UUID_STRING_LEN - 1] != '\0' ||
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");
- _spdk_lvol_free(lvol);
+ lvol_free(lvol);
req->lvserrno = -EINVAL;
goto invalid;
}
- rc = spdk_blob_get_xattr_value(blob, "clear_method", (const void **)&clear_method, &value_len);
- if (rc != 0) {
- lvol->clear_method = BLOB_CLEAR_WITH_DEFAULT;
- } else {
- lvol->clear_method = *clear_method;
- }
-
snprintf(lvol->name, sizeof(lvol->name), "%s", attr);
TAILQ_INSERT_TAIL(&lvs->lvols, lvol, link);
SPDK_INFOLOG(SPDK_LOG_LVOL, "added lvol %s (%s)\n", lvol->unique_id, lvol->uuid_str);
- spdk_bs_iter_next(bs, blob, _spdk_load_next_lvol, req);
+ spdk_bs_iter_next(bs, blob, load_next_lvol, req);
return;
free(lvol);
}
- _spdk_lvs_free(lvs);
- spdk_bs_unload(bs, _spdk_bs_unload_with_error_cb, req);
+ lvs_free(lvs);
+ spdk_bs_unload(bs, bs_unload_with_error_cb, req);
}
static void
-_spdk_close_super_cb(void *cb_arg, int lvolerrno)
+close_super_cb(void *cb_arg, int lvolerrno)
{
struct spdk_lvs_with_handle_req *req = (struct spdk_lvs_with_handle_req *)cb_arg;
struct spdk_lvol_store *lvs = req->lvol_store;
if (lvolerrno != 0) {
SPDK_INFOLOG(SPDK_LOG_LVOL, "Could not close super blob\n");
- _spdk_lvs_free(lvs);
+ lvs_free(lvs);
req->lvserrno = -ENODEV;
- spdk_bs_unload(bs, _spdk_bs_unload_with_error_cb, req);
+ spdk_bs_unload(bs, bs_unload_with_error_cb, req);
return;
}
/* Start loading lvols */
- spdk_bs_iter_first(lvs->blobstore, _spdk_load_next_lvol, req);
+ spdk_bs_iter_first(lvs->blobstore, load_next_lvol, req);
}
static void
-_spdk_close_super_blob_with_error_cb(void *cb_arg, int lvolerrno)
+close_super_blob_with_error_cb(void *cb_arg, int lvolerrno)
{
struct spdk_lvs_with_handle_req *req = (struct spdk_lvs_with_handle_req *)cb_arg;
struct spdk_lvol_store *lvs = req->lvol_store;
struct spdk_blob_store *bs = lvs->blobstore;
- _spdk_lvs_free(lvs);
+ lvs_free(lvs);
- spdk_bs_unload(bs, _spdk_bs_unload_with_error_cb, req);
+ spdk_bs_unload(bs, bs_unload_with_error_cb, req);
}
static void
-_spdk_lvs_read_uuid(void *cb_arg, struct spdk_blob *blob, int lvolerrno)
+lvs_read_uuid(void *cb_arg, struct spdk_blob *blob, int lvolerrno)
{
struct spdk_lvs_with_handle_req *req = (struct spdk_lvs_with_handle_req *)cb_arg;
struct spdk_lvol_store *lvs = req->lvol_store;
if (lvolerrno != 0) {
SPDK_INFOLOG(SPDK_LOG_LVOL, "Could not open super blob\n");
- _spdk_lvs_free(lvs);
+ lvs_free(lvs);
req->lvserrno = -ENODEV;
- spdk_bs_unload(bs, _spdk_bs_unload_with_error_cb, req);
+ spdk_bs_unload(bs, bs_unload_with_error_cb, req);
return;
}
if (rc != 0 || value_len != SPDK_UUID_STRING_LEN || attr[SPDK_UUID_STRING_LEN - 1] != '\0') {
SPDK_INFOLOG(SPDK_LOG_LVOL, "missing or incorrect UUID\n");
req->lvserrno = -EINVAL;
- spdk_blob_close(blob, _spdk_close_super_blob_with_error_cb, req);
+ spdk_blob_close(blob, close_super_blob_with_error_cb, req);
return;
}
if (spdk_uuid_parse(&lvs->uuid, attr)) {
SPDK_INFOLOG(SPDK_LOG_LVOL, "incorrect UUID '%s'\n", attr);
req->lvserrno = -EINVAL;
- spdk_blob_close(blob, _spdk_close_super_blob_with_error_cb, req);
+ spdk_blob_close(blob, close_super_blob_with_error_cb, req);
return;
}
if (rc != 0 || value_len > SPDK_LVS_NAME_MAX) {
SPDK_INFOLOG(SPDK_LOG_LVOL, "missing or invalid name\n");
req->lvserrno = -EINVAL;
- spdk_blob_close(blob, _spdk_close_super_blob_with_error_cb, req);
+ spdk_blob_close(blob, close_super_blob_with_error_cb, req);
return;
}
snprintf(lvs->name, sizeof(lvs->name), "%s", attr);
- rc = _spdk_add_lvs_to_list(lvs);
+ rc = add_lvs_to_list(lvs);
if (rc) {
SPDK_INFOLOG(SPDK_LOG_LVOL, "lvolstore with name %s already exists\n", lvs->name);
req->lvserrno = -EEXIST;
- spdk_blob_close(blob, _spdk_close_super_blob_with_error_cb, req);
+ spdk_blob_close(blob, close_super_blob_with_error_cb, req);
return;
}
lvs->super_blob_id = spdk_blob_get_id(blob);
- spdk_blob_close(blob, _spdk_close_super_cb, req);
+ spdk_blob_close(blob, close_super_cb, req);
}
static void
-_spdk_lvs_open_super(void *cb_arg, spdk_blob_id blobid, int lvolerrno)
+lvs_open_super(void *cb_arg, spdk_blob_id blobid, int lvolerrno)
{
struct spdk_lvs_with_handle_req *req = (struct spdk_lvs_with_handle_req *)cb_arg;
struct spdk_lvol_store *lvs = req->lvol_store;
if (lvolerrno != 0) {
SPDK_INFOLOG(SPDK_LOG_LVOL, "Super blob not found\n");
- _spdk_lvs_free(lvs);
+ lvs_free(lvs);
req->lvserrno = -ENODEV;
- spdk_bs_unload(bs, _spdk_bs_unload_with_error_cb, req);
+ spdk_bs_unload(bs, bs_unload_with_error_cb, req);
return;
}
- spdk_bs_open_blob(bs, blobid, _spdk_lvs_read_uuid, req);
+ spdk_bs_open_blob(bs, blobid, lvs_read_uuid, req);
}
static void
-_spdk_lvs_load_cb(void *cb_arg, struct spdk_blob_store *bs, int lvolerrno)
+lvs_load_cb(void *cb_arg, struct spdk_blob_store *bs, int lvolerrno)
{
struct spdk_lvs_with_handle_req *req = (struct spdk_lvs_with_handle_req *)cb_arg;
struct spdk_lvol_store *lvs;
lvs = calloc(1, sizeof(*lvs));
if (lvs == NULL) {
SPDK_ERRLOG("Cannot alloc memory for lvol store\n");
- spdk_bs_unload(bs, _spdk_bs_unload_with_error_cb, req);
+ spdk_bs_unload(bs, bs_unload_with_error_cb, req);
return;
}
req->lvol_store = lvs;
- spdk_bs_get_super(bs, _spdk_lvs_open_super, req);
+ spdk_bs_get_super(bs, lvs_open_super, req);
}
static void
-spdk_lvs_bs_opts_init(struct spdk_bs_opts *opts)
+lvs_bs_opts_init(struct spdk_bs_opts *opts)
{
spdk_bs_opts_init(opts);
opts->max_channel_ops = SPDK_LVOL_BLOB_OPTS_CHANNEL_OPS;
req->cb_arg = cb_arg;
req->bs_dev = bs_dev;
- spdk_lvs_bs_opts_init(&opts);
+ lvs_bs_opts_init(&opts);
snprintf(opts.bstype.bstype, sizeof(opts.bstype.bstype), "LVOLSTORE");
- spdk_bs_load(bs_dev, &opts, _spdk_lvs_load_cb, req);
+ spdk_bs_load(bs_dev, &opts, lvs_load_cb, req);
+}
+
+static void
+remove_bs_on_error_cb(void *cb_arg, int bserrno)
+{
}
static void
-_spdk_super_create_close_cb(void *cb_arg, int lvolerrno)
+super_create_close_cb(void *cb_arg, int lvolerrno)
{
struct spdk_lvs_with_handle_req *req = cb_arg;
struct spdk_lvol_store *lvs = req->lvol_store;
if (lvolerrno < 0) {
SPDK_ERRLOG("Lvol store init failed: could not close super blob\n");
req->cb_fn(req->cb_arg, NULL, lvolerrno);
- _spdk_lvs_free(lvs);
+ spdk_bs_destroy(lvs->blobstore, remove_bs_on_error_cb, NULL);
+ lvs_free(lvs);
free(req);
return;
}
}
static void
-_spdk_super_blob_set_cb(void *cb_arg, int lvolerrno)
+super_blob_set_cb(void *cb_arg, int lvolerrno)
{
struct spdk_lvs_with_handle_req *req = cb_arg;
struct spdk_lvol_store *lvs = req->lvol_store;
if (lvolerrno < 0) {
req->cb_fn(req->cb_arg, NULL, lvolerrno);
SPDK_ERRLOG("Lvol store init failed: could not set uuid for super blob\n");
- _spdk_lvs_free(lvs);
+ spdk_bs_destroy(lvs->blobstore, remove_bs_on_error_cb, NULL);
+ lvs_free(lvs);
free(req);
return;
}
- spdk_blob_close(blob, _spdk_super_create_close_cb, req);
+ spdk_blob_close(blob, super_create_close_cb, req);
}
static void
-_spdk_super_blob_init_cb(void *cb_arg, int lvolerrno)
+super_blob_init_cb(void *cb_arg, int lvolerrno)
{
struct spdk_lvs_with_handle_req *req = cb_arg;
struct spdk_lvol_store *lvs = req->lvol_store;
if (lvolerrno < 0) {
req->cb_fn(req->cb_arg, NULL, lvolerrno);
SPDK_ERRLOG("Lvol store init failed: could not set super blob\n");
- _spdk_lvs_free(lvs);
+ spdk_bs_destroy(lvs->blobstore, remove_bs_on_error_cb, NULL);
+ lvs_free(lvs);
free(req);
return;
}
spdk_blob_set_xattr(blob, "uuid", uuid, sizeof(uuid));
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);
+ spdk_blob_sync_md(blob, super_blob_set_cb, req);
}
static void
-_spdk_super_blob_create_open_cb(void *cb_arg, struct spdk_blob *blob, int lvolerrno)
+super_blob_create_open_cb(void *cb_arg, struct spdk_blob *blob, int lvolerrno)
{
struct spdk_lvs_with_handle_req *req = cb_arg;
struct spdk_lvol_store *lvs = req->lvol_store;
if (lvolerrno < 0) {
req->cb_fn(req->cb_arg, NULL, lvolerrno);
SPDK_ERRLOG("Lvol store init failed: could not open super blob\n");
- _spdk_lvs_free(lvs);
+ spdk_bs_destroy(lvs->blobstore, remove_bs_on_error_cb, NULL);
+ lvs_free(lvs);
free(req);
return;
}
lvs->super_blob = blob;
lvs->super_blob_id = spdk_blob_get_id(blob);
- spdk_bs_set_super(lvs->blobstore, lvs->super_blob_id, _spdk_super_blob_init_cb, req);
+ spdk_bs_set_super(lvs->blobstore, lvs->super_blob_id, super_blob_init_cb, req);
}
static void
-_spdk_super_blob_create_cb(void *cb_arg, spdk_blob_id blobid, int lvolerrno)
+super_blob_create_cb(void *cb_arg, spdk_blob_id blobid, int lvolerrno)
{
struct spdk_lvs_with_handle_req *req = cb_arg;
struct spdk_lvol_store *lvs = req->lvol_store;
if (lvolerrno < 0) {
req->cb_fn(req->cb_arg, NULL, lvolerrno);
SPDK_ERRLOG("Lvol store init failed: could not create super blob\n");
- _spdk_lvs_free(lvs);
+ spdk_bs_destroy(lvs->blobstore, remove_bs_on_error_cb, NULL);
+ lvs_free(lvs);
free(req);
return;
}
bs = req->lvol_store->blobstore;
- spdk_bs_open_blob(bs, blobid, _spdk_super_blob_create_open_cb, req);
+ spdk_bs_open_blob(bs, blobid, super_blob_create_open_cb, req);
}
static void
-_spdk_lvs_init_cb(void *cb_arg, struct spdk_blob_store *bs, int lvserrno)
+lvs_init_cb(void *cb_arg, struct spdk_blob_store *bs, int lvserrno)
{
struct spdk_lvs_with_handle_req *lvs_req = cb_arg;
struct spdk_lvol_store *lvs = lvs_req->lvol_store;
assert(bs == NULL);
lvs_req->cb_fn(lvs_req->cb_arg, NULL, lvserrno);
SPDK_ERRLOG("Lvol store init failed: could not initialize blobstore\n");
- _spdk_lvs_free(lvs);
+ lvs_free(lvs);
free(lvs_req);
return;
}
SPDK_INFOLOG(SPDK_LOG_LVOL, "Lvol store initialized\n");
/* create super blob */
- spdk_bs_create_blob(lvs->blobstore, _spdk_super_blob_create_cb, lvs_req);
+ spdk_bs_create_blob(lvs->blobstore, super_blob_create_cb, lvs_req);
}
void
}
static void
-_spdk_setup_lvs_opts(struct spdk_bs_opts *bs_opts, struct spdk_lvs_opts *o)
+setup_lvs_opts(struct spdk_bs_opts *bs_opts, struct spdk_lvs_opts *o)
{
assert(o != NULL);
- spdk_lvs_bs_opts_init(bs_opts);
+ lvs_bs_opts_init(bs_opts);
bs_opts->cluster_sz = o->cluster_sz;
bs_opts->clear_method = (enum bs_clear_method)o->clear_method;
}
return -EINVAL;
}
- _spdk_setup_lvs_opts(&opts, o);
+ setup_lvs_opts(&opts, o);
if (strnlen(o->name, SPDK_LVS_NAME_MAX) == SPDK_LVS_NAME_MAX) {
SPDK_ERRLOG("Name has no null terminator.\n");
spdk_uuid_generate(&lvs->uuid);
snprintf(lvs->name, sizeof(lvs->name), "%s", o->name);
- rc = _spdk_add_lvs_to_list(lvs);
+ rc = add_lvs_to_list(lvs);
if (rc) {
SPDK_ERRLOG("lvolstore with name %s already exists\n", lvs->name);
- _spdk_lvs_free(lvs);
+ lvs_free(lvs);
return -EEXIST;
}
lvs_req = calloc(1, sizeof(*lvs_req));
if (!lvs_req) {
- _spdk_lvs_free(lvs);
+ lvs_free(lvs);
SPDK_ERRLOG("Cannot alloc memory for lvol store request pointer\n");
return -ENOMEM;
}
snprintf(opts.bstype.bstype, sizeof(opts.bstype.bstype), "LVOLSTORE");
SPDK_INFOLOG(SPDK_LOG_LVOL, "Initializing lvol store\n");
- spdk_bs_init(bs_dev, &opts, _spdk_lvs_init_cb, lvs_req);
+ spdk_bs_init(bs_dev, &opts, lvs_init_cb, lvs_req);
return 0;
}
static void
-_spdk_lvs_rename_cb(void *cb_arg, int lvolerrno)
+lvs_rename_cb(void *cb_arg, int lvolerrno)
{
struct spdk_lvs_req *req = cb_arg;
}
static void
-_spdk_lvs_rename_sync_cb(void *cb_arg, int lvolerrno)
+lvs_rename_sync_cb(void *cb_arg, int lvolerrno)
{
struct spdk_lvs_req *req = cb_arg;
struct spdk_blob *blob = req->lvol_store->super_blob;
req->lvserrno = lvolerrno;
}
- spdk_blob_close(blob, _spdk_lvs_rename_cb, req);
+ spdk_blob_close(blob, lvs_rename_cb, req);
}
static void
-_spdk_lvs_rename_open_cb(void *cb_arg, struct spdk_blob *blob, int lvolerrno)
+lvs_rename_open_cb(void *cb_arg, struct spdk_blob *blob, int lvolerrno)
{
struct spdk_lvs_req *req = cb_arg;
int rc;
if (lvolerrno < 0) {
- _spdk_lvs_rename_cb(cb_arg, lvolerrno);
+ lvs_rename_cb(cb_arg, lvolerrno);
return;
}
strlen(req->lvol_store->new_name) + 1);
if (rc < 0) {
req->lvserrno = rc;
- _spdk_lvs_rename_sync_cb(req, rc);
+ lvs_rename_sync_cb(req, rc);
return;
}
req->lvol_store->super_blob = blob;
- spdk_blob_sync_md(blob, _spdk_lvs_rename_sync_cb, req);
+ spdk_blob_sync_md(blob, lvs_rename_sync_cb, req);
}
void
req->cb_fn = cb_fn;
req->cb_arg = cb_arg;
- spdk_bs_open_blob(lvs->blobstore, lvs->super_blob_id, _spdk_lvs_rename_open_cb, req);
+ spdk_bs_open_blob(lvs->blobstore, lvs->super_blob_id, lvs_rename_open_cb, req);
}
static void
TAILQ_FOREACH_SAFE(lvol, &lvs->lvols, link, tmp) {
TAILQ_REMOVE(&lvs->lvols, lvol, link);
- _spdk_lvol_free(lvol);
+ lvol_free(lvol);
}
lvs_req = calloc(1, sizeof(*lvs_req));
SPDK_INFOLOG(SPDK_LOG_LVOL, "Unloading lvol store\n");
spdk_bs_unload(lvs->blobstore, _lvs_unload_cb, lvs_req);
- _spdk_lvs_free(lvs);
+ lvs_free(lvs);
return 0;
}
SPDK_INFOLOG(SPDK_LOG_LVOL, "Destroying lvol store\n");
spdk_bs_destroy(lvs->blobstore, _lvs_destroy_cb, lvs_req);
- _spdk_lvs_free(lvs);
+ lvs_free(lvs);
}
int
}
static void
-_spdk_lvol_close_blob_cb(void *cb_arg, int lvolerrno)
+lvol_close_blob_cb(void *cb_arg, int lvolerrno)
{
struct spdk_lvol_req *req = cb_arg;
struct spdk_lvol *lvol = req->lvol;
if (lvolerrno < 0) {
SPDK_ERRLOG("Could not close blob on lvol\n");
- _spdk_lvol_free(lvol);
+ lvol_free(lvol);
goto end;
}
bool
spdk_lvol_deletable(struct spdk_lvol *lvol)
{
- size_t count;
+ size_t count = 0;
spdk_blob_get_clones(lvol->lvol_store->blobstore, lvol->blob_id, NULL, &count);
return (count == 0);
}
static void
-_spdk_lvol_delete_blob_cb(void *cb_arg, int lvolerrno)
+lvol_delete_blob_cb(void *cb_arg, int lvolerrno)
{
struct spdk_lvol_req *req = cb_arg;
struct spdk_lvol *lvol = req->lvol;
}
TAILQ_REMOVE(&lvol->lvol_store->lvols, lvol, link);
- _spdk_lvol_free(lvol);
+ lvol_free(lvol);
req->cb_fn(req->cb_arg, lvolerrno);
free(req);
}
static void
-_spdk_lvol_create_open_cb(void *cb_arg, struct spdk_blob *blob, int lvolerrno)
+lvol_create_open_cb(void *cb_arg, struct spdk_blob *blob, int lvolerrno)
{
struct spdk_lvol_with_handle_req *req = cb_arg;
- spdk_blob_id blob_id = spdk_blob_get_id(blob);
struct spdk_lvol *lvol = req->lvol;
TAILQ_REMOVE(&req->lvol->lvol_store->pending_lvols, req->lvol, link);
}
lvol->blob = blob;
- lvol->blob_id = blob_id;
+ lvol->blob_id = spdk_blob_get_id(blob);
TAILQ_INSERT_TAIL(&lvol->lvol_store->lvols, lvol, link);
}
static void
-_spdk_lvol_create_cb(void *cb_arg, spdk_blob_id blobid, int lvolerrno)
+lvol_create_cb(void *cb_arg, spdk_blob_id blobid, int lvolerrno)
{
struct spdk_lvol_with_handle_req *req = cb_arg;
struct spdk_blob_store *bs;
opts.clear_method = req->lvol->clear_method;
bs = req->lvol->lvol_store->blobstore;
- spdk_bs_open_blob_ext(bs, blobid, &opts, _spdk_lvol_create_open_cb, req);
+ spdk_bs_open_blob_ext(bs, blobid, &opts, lvol_create_open_cb, req);
}
static void
-spdk_lvol_get_xattr_value(void *xattr_ctx, const char *name,
- const void **value, size_t *value_len)
+lvol_get_xattr_value(void *xattr_ctx, const char *name,
+ const void **value, size_t *value_len)
{
struct spdk_lvol *lvol = xattr_ctx;
} else if (!strcmp("uuid", name)) {
*value = lvol->uuid_str;
*value_len = sizeof(lvol->uuid_str);
- } else if (!strcmp("clear_method", name)) {
- *value = &lvol->clear_method;
- *value_len = sizeof(int);
}
}
static int
-_spdk_lvs_verify_lvol_name(struct spdk_lvol_store *lvs, const char *name)
+lvs_verify_lvol_name(struct spdk_lvol_store *lvs, const char *name)
{
struct spdk_lvol *tmp;
struct spdk_lvol *lvol;
struct spdk_blob_opts opts;
uint64_t num_clusters;
- char *xattr_names[] = {LVOL_NAME, "uuid", "clear_method"};
+ char *xattr_names[] = {LVOL_NAME, "uuid"};
int rc;
if (lvs == NULL) {
return -EINVAL;
}
- rc = _spdk_lvs_verify_lvol_name(lvs, name);
+ rc = lvs_verify_lvol_name(lvs, name);
if (rc < 0) {
return rc;
}
spdk_blob_opts_init(&opts);
opts.thin_provision = thin_provision;
opts.num_clusters = num_clusters;
+ opts.clear_method = lvol->clear_method;
opts.xattrs.count = SPDK_COUNTOF(xattr_names);
opts.xattrs.names = xattr_names;
opts.xattrs.ctx = lvol;
- opts.xattrs.get_value = spdk_lvol_get_xattr_value;
+ opts.xattrs.get_value = lvol_get_xattr_value;
- spdk_bs_create_blob_ext(lvs->blobstore, &opts, _spdk_lvol_create_cb, req);
+ spdk_bs_create_blob_ext(lvs->blobstore, &opts, lvol_create_cb, req);
return 0;
}
return;
}
- rc = _spdk_lvs_verify_lvol_name(lvs, snapshot_name);
+ rc = lvs_verify_lvol_name(lvs, snapshot_name);
if (rc < 0) {
cb_fn(cb_arg, NULL, rc);
return;
snapshot_xattrs.count = SPDK_COUNTOF(xattr_names);
snapshot_xattrs.ctx = newlvol;
snapshot_xattrs.names = xattr_names;
- snapshot_xattrs.get_value = spdk_lvol_get_xattr_value;
+ snapshot_xattrs.get_value = lvol_get_xattr_value;
req->lvol = newlvol;
req->cb_fn = cb_fn;
req->cb_arg = cb_arg;
spdk_bs_create_snapshot(lvs->blobstore, spdk_blob_get_id(origblob), &snapshot_xattrs,
- _spdk_lvol_create_cb, req);
+ lvol_create_cb, req);
}
void
return;
}
- rc = _spdk_lvs_verify_lvol_name(lvs, clone_name);
+ rc = lvs_verify_lvol_name(lvs, clone_name);
if (rc < 0) {
cb_fn(cb_arg, NULL, rc);
return;
clone_xattrs.count = SPDK_COUNTOF(xattr_names);
clone_xattrs.ctx = newlvol;
clone_xattrs.names = xattr_names;
- clone_xattrs.get_value = spdk_lvol_get_xattr_value;
+ clone_xattrs.get_value = lvol_get_xattr_value;
req->lvol = newlvol;
req->cb_fn = cb_fn;
req->cb_arg = cb_arg;
spdk_bs_create_clone(lvs->blobstore, spdk_blob_get_id(origblob), &clone_xattrs,
- _spdk_lvol_create_cb,
+ lvol_create_cb,
req);
}
static void
-_spdk_lvol_resize_done(void *cb_arg, int lvolerrno)
+lvol_resize_done(void *cb_arg, int lvolerrno)
{
struct spdk_lvol_req *req = cb_arg;
}
static void
-_spdk_lvol_blob_resize_cb(void *cb_arg, int bserrno)
+lvol_blob_resize_cb(void *cb_arg, int bserrno)
{
struct spdk_lvol_req *req = cb_arg;
struct spdk_lvol *lvol = req->lvol;
return;
}
- spdk_blob_sync_md(lvol->blob, _spdk_lvol_resize_done, req);
+ spdk_blob_sync_md(lvol->blob, lvol_resize_done, req);
}
void
req->cb_arg = cb_arg;
req->lvol = lvol;
- spdk_blob_resize(blob, new_clusters, _spdk_lvol_blob_resize_cb, req);
+ spdk_blob_resize(blob, new_clusters, lvol_blob_resize_cb, req);
}
static void
-_spdk_lvol_set_read_only_cb(void *cb_arg, int lvolerrno)
+lvol_set_read_only_cb(void *cb_arg, int lvolerrno)
{
struct spdk_lvol_req *req = cb_arg;
req->cb_arg = cb_arg;
spdk_blob_set_read_only(lvol->blob);
- spdk_blob_sync_md(lvol->blob, _spdk_lvol_set_read_only_cb, req);
+ spdk_blob_sync_md(lvol->blob, lvol_set_read_only_cb, req);
}
static void
-_spdk_lvol_rename_cb(void *cb_arg, int lvolerrno)
+lvol_rename_cb(void *cb_arg, int lvolerrno)
{
struct spdk_lvol_req *req = cb_arg;
return;
}
- spdk_blob_sync_md(blob, _spdk_lvol_rename_cb, req);
+ spdk_blob_sync_md(blob, lvol_rename_cb, req);
}
void
req->lvol = lvol;
bs = lvol->lvol_store->blobstore;
- spdk_bs_delete_blob(bs, lvol->blob_id, _spdk_lvol_delete_blob_cb, req);
+ spdk_bs_delete_blob(bs, lvol->blob_id, lvol_delete_blob_cb, req);
}
void
req->cb_arg = cb_arg;
req->lvol = lvol;
- spdk_blob_close(lvol->blob, _spdk_lvol_close_blob_cb, req);
+ spdk_blob_close(lvol->blob, lvol_close_blob_cb, req);
}
struct spdk_io_channel *
}
static void
-_spdk_lvol_inflate_cb(void *cb_arg, int lvolerrno)
+lvol_inflate_cb(void *cb_arg, int lvolerrno)
{
struct spdk_lvol_req *req = cb_arg;
}
blob_id = spdk_blob_get_id(lvol->blob);
- spdk_bs_inflate_blob(lvol->lvol_store->blobstore, req->channel, blob_id, _spdk_lvol_inflate_cb,
+ spdk_bs_inflate_blob(lvol->lvol_store->blobstore, req->channel, blob_id, lvol_inflate_cb,
req);
}
blob_id = spdk_blob_get_id(lvol->blob);
spdk_bs_blob_decouple_parent(lvol->lvol_store->blobstore, req->channel, blob_id,
- _spdk_lvol_inflate_cb, req);
+ lvol_inflate_cb, req);
}
projects / ceph.git / blobdiff