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

null/rpc: Add more descriptive error messages for null bdevs

Browse Source 
Improve error messages where possible.

Change-Id: I9d1e4dee106712ecd7a40cfd1eeaf74ccf6d0d1d
Signed-off-by: Karol Latecki <karol.latecki@intel.com>
Reviewed-on: https://review.gerrithub.io/c/spdk/spdk/+/460121
Reviewed-by: Vitaliy Mysak <vitaliy.mysak@intel.com>
Reviewed-by: Tomasz Zawadzki <tomasz.zawadzki@intel.com>
Reviewed-by: Paul Luse <paul.e.luse@intel.com>
Reviewed-by: Darek Stojaczyk <dariusz.stojaczyk@intel.com>
Reviewed-by: Changpeng Liu <changpeng.liu@intel.com>
Tested-by: SPDK CI Jenkins <sys_sgci@intel.com>
This commit is contained in:
Karol Latecki 2019-07-02 10:47:37 +02:00 committed by Changpeng Liu
parent 5e28673bc5
commit f155fedcdb
3 changed files with 63 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

61
lib/bdev/null/bdev_null.c
View File

@ -171,59 +171,61 @@ static const struct spdk_bdev_fn_table null_fn_table = {
.write_config_json = bdev_null_write_config_json, .write_config_json = bdev_null_write_config_json,
}; };
struct spdk_bdev * int
create_null_bdev(const char *name, const struct spdk_uuid *uuid, create_null_bdev(struct spdk_bdev **bdev, const char *name, const struct spdk_uuid *uuid,
uint64_t num_blocks, uint32_t block_size) uint64_t num_blocks, uint32_t block_size)
{ {
struct null_bdev *bdev; struct null_bdev *null_disk;
int rc; int rc;
if (block_size % 512 != 0) { if (block_size % 512 != 0) {
SPDK_ERRLOG("Block size %u is not a multiple of 512.\n", block_size); SPDK_ERRLOG("Block size %u is not a multiple of 512.\n", block_size);
return NULL; return -EINVAL;
} }
if (num_blocks == 0) { if (num_blocks == 0) {
SPDK_ERRLOG("Disk must be more than 0 blocks\n"); SPDK_ERRLOG("Disk must be more than 0 blocks\n");
return NULL; return -EINVAL;
} }
bdev = calloc(1, sizeof(*bdev)); null_disk = calloc(1, sizeof(*null_disk));
if (!bdev) { if (!null_disk) {
SPDK_ERRLOG("could not allocate null_bdev\n"); SPDK_ERRLOG("could not allocate null_bdev\n");
return NULL; return -ENOMEM;
} }
bdev->bdev.name = strdup(name); null_disk->bdev.name = strdup(name);
if (!bdev->bdev.name) { if (!null_disk->bdev.name) {
free(bdev); free(null_disk);
return NULL; return -ENOMEM;
} }
bdev->bdev.product_name = "Null disk"; null_disk->bdev.product_name = "Null disk";
bdev->bdev.write_cache = 0; null_disk->bdev.write_cache = 0;
bdev->bdev.blocklen = block_size; null_disk->bdev.blocklen = block_size;
bdev->bdev.blockcnt = num_blocks; null_disk->bdev.blockcnt = num_blocks;
if (uuid) { if (uuid) {
bdev->bdev.uuid = *uuid; null_disk->bdev.uuid = *uuid;
} else { } else {
spdk_uuid_generate(&bdev->bdev.uuid); spdk_uuid_generate(&null_disk->bdev.uuid);
} }
bdev->bdev.ctxt = bdev; null_disk->bdev.ctxt = null_disk;
bdev->bdev.fn_table = &null_fn_table; null_disk->bdev.fn_table = &null_fn_table;
bdev->bdev.module = &null_if; null_disk->bdev.module = &null_if;
rc = spdk_bdev_register(&bdev->bdev); rc = spdk_bdev_register(&null_disk->bdev);
if (rc) { if (rc) {
free(bdev->bdev.name); free(null_disk->bdev.name);
free(bdev); free(null_disk);
return NULL; return rc;
} }
TAILQ_INSERT_TAIL(&g_null_bdev_head, bdev, tailq); *bdev = &(null_disk->bdev);
return &bdev->bdev; TAILQ_INSERT_TAIL(&g_null_bdev_head, null_disk, tailq);
return rc;
} }
void void
@ -355,10 +357,9 @@ bdev_null_initialize(void)
num_blocks = size_in_mb * (1024 * 1024) / block_size; num_blocks = size_in_mb * (1024 * 1024) / block_size;
bdev = create_null_bdev(name, NULL, num_blocks, block_size); rc = create_null_bdev(&bdev, name, NULL, num_blocks, block_size);
if (bdev == NULL) { if (rc) {
SPDK_ERRLOG("Could not create null bdev\n"); SPDK_ERRLOG("Could not create null bdev\n");
rc = EINVAL;
goto end; goto end;
} }

2
lib/bdev/null/bdev_null.h
View File

@ -41,7 +41,7 @@ typedef void (*spdk_delete_null_complete)(void *cb_arg, int bdeverrno);
struct spdk_bdev; struct spdk_bdev;
struct spdk_uuid; struct spdk_uuid;
struct spdk_bdev *create_null_bdev(const char *name, const struct spdk_uuid *uuid, int create_null_bdev(struct spdk_bdev **bdev, const char *name, const struct spdk_uuid *uuid,
uint64_t num_blocks, uint32_t block_size); uint64_t num_blocks, uint32_t block_size);
/** /**

44
lib/bdev/null/bdev_null_rpc.c
View File

@ -69,24 +69,42 @@ spdk_rpc_construct_null_bdev(struct spdk_jsonrpc_request *request,
struct spdk_uuid *uuid = NULL; struct spdk_uuid *uuid = NULL;
struct spdk_uuid decoded_uuid; struct spdk_uuid decoded_uuid;
struct spdk_bdev *bdev; struct spdk_bdev *bdev;
int rc = 0;
if (spdk_json_decode_object(params, rpc_construct_null_decoders, if (spdk_json_decode_object(params, rpc_construct_null_decoders,
SPDK_COUNTOF(rpc_construct_null_decoders), SPDK_COUNTOF(rpc_construct_null_decoders),
&req)) { &req)) {
SPDK_DEBUGLOG(SPDK_LOG_BDEV_NULL, "spdk_json_decode_object failed\n"); SPDK_DEBUGLOG(SPDK_LOG_BDEV_NULL, "spdk_json_decode_object failed\n");
goto invalid; spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
"spdk_json_decode_object failed");
goto cleanup;
}
if (req.block_size % 512 != 0) {
spdk_jsonrpc_send_error_response_fmt(request, -EINVAL,
"Block size %u is not a multiple of 512", req.block_size);
goto cleanup;
}
if (req.num_blocks == 0) {
spdk_jsonrpc_send_error_response(request, -EINVAL,
"Disk num_blocks must be greater than 0");
goto cleanup;
} }
if (req.uuid) { if (req.uuid) {
if (spdk_uuid_parse(&decoded_uuid, req.uuid)) { if (spdk_uuid_parse(&decoded_uuid, req.uuid)) {
goto invalid; spdk_jsonrpc_send_error_response(request, -EINVAL,
"Failed to parse bdev UUID");
goto cleanup;
} }
uuid = &decoded_uuid; uuid = &decoded_uuid;
} }
bdev = create_null_bdev(req.name, uuid, req.num_blocks, req.block_size); rc = create_null_bdev(&bdev, req.name, uuid, req.num_blocks, req.block_size);
if (bdev == NULL) { if (rc) {
goto invalid; spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc));
goto cleanup;
} }
w = spdk_jsonrpc_begin_result(request); w = spdk_jsonrpc_begin_result(request);
@ -100,8 +118,7 @@ spdk_rpc_construct_null_bdev(struct spdk_jsonrpc_request *request,
free_rpc_construct_null(&req); free_rpc_construct_null(&req);
return; return;
invalid: cleanup:
spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters");
free_rpc_construct_null(&req); free_rpc_construct_null(&req);
} }
SPDK_RPC_REGISTER("construct_null_bdev", spdk_rpc_construct_null_bdev, SPDK_RPC_RUNTIME) SPDK_RPC_REGISTER("construct_null_bdev", spdk_rpc_construct_null_bdev, SPDK_RPC_RUNTIME)
@ -141,19 +158,19 @@ spdk_rpc_delete_null_bdev(struct spdk_jsonrpc_request *request,
{ {
struct rpc_delete_null req = {NULL}; struct rpc_delete_null req = {NULL};
struct spdk_bdev *bdev; struct spdk_bdev *bdev;
int rc;
if (spdk_json_decode_object(params, rpc_delete_null_decoders, if (spdk_json_decode_object(params, rpc_delete_null_decoders,
SPDK_COUNTOF(rpc_delete_null_decoders), SPDK_COUNTOF(rpc_delete_null_decoders),
&req)) { &req)) {
rc = -EINVAL; spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
goto invalid; "spdk_json_decode_object failed");
goto cleanup;
} }
bdev = spdk_bdev_get_by_name(req.name); bdev = spdk_bdev_get_by_name(req.name);
if (bdev == NULL) { if (bdev == NULL) {
rc = -ENODEV; spdk_jsonrpc_send_error_response(request, -ENODEV, spdk_strerror(ENODEV));
goto invalid; goto cleanup;
} }
delete_null_bdev(bdev, _spdk_rpc_delete_null_bdev_cb, request); delete_null_bdev(bdev, _spdk_rpc_delete_null_bdev_cb, request);
@ -162,8 +179,7 @@ spdk_rpc_delete_null_bdev(struct spdk_jsonrpc_request *request,
return; return;
invalid: cleanup:
free_rpc_delete_null(&req); free_rpc_delete_null(&req);
spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, spdk_strerror(-rc));
} }
SPDK_RPC_REGISTER("delete_null_bdev", spdk_rpc_delete_null_bdev, SPDK_RPC_RUNTIME) SPDK_RPC_REGISTER("delete_null_bdev", spdk_rpc_delete_null_bdev, SPDK_RPC_RUNTIME)