Commit 2f08dc7f authored by Tomasz Zawadzki's avatar Tomasz Zawadzki
Browse files

bdev/delay: add uuid option 



This patch aligns delay bdev with other bdev modules
that allow passing specific uuid during their creation.
See malloc or null bdev modules.

Change-Id: Icc5e816dd42b2e55e8d57712f2d4f125e486fdab
Signed-off-by: default avatarTomasz Zawadzki <tomasz.zawadzki@intel.com>
Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/16840


Reviewed-by: default avatarShuhei Matsumoto <smatsumoto@nvidia.com>
Tested-by: default avatarSPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: default avatarJim Harris <james.r.harris@intel.com>
parent 1afb1eff

module/bdev/delay/vbdev_delay.c

+18 −2
Original line number Diff line number Diff line
@@ -39,6 +39,7 @@ SPDK_BDEV_MODULE_REGISTER(delay, &delay_if) 
struct bdev_association {

	char			*vbdev_name;

	char			*bdev_name;

	struct spdk_uuid	uuid;

	uint64_t		avg_read_latency;

	uint64_t		p99_read_latency;

	uint64_t		avg_write_latency;
@@ -502,8 +503,15 @@ vbdev_delay_get_io_channel(void *ctx) 
static void

_delay_write_conf_values(struct vbdev_delay *delay_node, struct spdk_json_write_ctx *w)

{

	struct spdk_uuid *uuid = &delay_node->delay_bdev.uuid;

	char uuid_str[SPDK_UUID_STRING_LEN];



	spdk_json_write_named_string(w, "name", spdk_bdev_get_name(&delay_node->delay_bdev));

	spdk_json_write_named_string(w, "base_bdev_name", spdk_bdev_get_name(delay_node->base_bdev));

	if (!spdk_mem_all_zero(uuid, sizeof(uuid))) {

		spdk_uuid_fmt_lower(uuid_str, sizeof(uuid_str), uuid);

		spdk_json_write_named_string(w, "uuid", uuid_str);

	}

	spdk_json_write_named_int64(w, "avg_read_latency",

				    delay_node->average_read_latency_ticks * SPDK_SEC_TO_USEC / spdk_get_ticks_hz());

	spdk_json_write_named_int64(w, "p99_read_latency",
@@ -585,6 +593,7 @@ delay_bdev_ch_destroy_cb(void *io_device, void *ctx_buf) 
 * on the global list. */

static int

vbdev_delay_insert_association(const char *bdev_name, const char *vbdev_name,

			       struct spdk_uuid *uuid,

			       uint64_t avg_read_latency, uint64_t p99_read_latency,

			       uint64_t avg_write_latency, uint64_t p99_write_latency)

{
@@ -623,6 +632,10 @@ vbdev_delay_insert_association(const char *bdev_name, const char *vbdev_name, 
	assoc->avg_write_latency = avg_write_latency;

	assoc->p99_write_latency = p99_write_latency;



	if (uuid) {

		spdk_uuid_copy(&assoc->uuid, uuid);

	}



	TAILQ_INSERT_TAIL(&g_bdev_associations, assoc, link);



	return 0;
@@ -778,6 +791,8 @@ vbdev_delay_register(const char *bdev_name) 
		}

		delay_node->delay_bdev.product_name = "delay";



		spdk_uuid_copy(&delay_node->delay_bdev.uuid, &assoc->uuid);



		/* The base bdev that we're attaching to. */

		rc = spdk_bdev_open_ext(bdev_name, true, vbdev_delay_base_bdev_event_cb,

					NULL, &delay_node->base_desc);
@@ -843,7 +858,8 @@ error_close: 
}



int

create_delay_disk(const char *bdev_name, const char *vbdev_name, uint64_t avg_read_latency,

create_delay_disk(const char *bdev_name, const char *vbdev_name, struct spdk_uuid *uuid,

		  uint64_t avg_read_latency,

		  uint64_t p99_read_latency, uint64_t avg_write_latency, uint64_t p99_write_latency)

{

	int rc = 0;
@@ -853,7 +869,7 @@ create_delay_disk(const char *bdev_name, const char *vbdev_name, uint64_t avg_re 
		return -EINVAL;

	}



	rc = vbdev_delay_insert_association(bdev_name, vbdev_name, avg_read_latency, p99_read_latency,

	rc = vbdev_delay_insert_association(bdev_name, vbdev_name, uuid, avg_read_latency, p99_read_latency,

					    avg_write_latency, p99_write_latency);

	if (rc) {

		return rc;

module/bdev/delay/vbdev_delay.h

+3 −1
Original line number Diff line number Diff line
@@ -24,13 +24,15 @@ enum delay_io_type { 
 *

 * \param bdev_name Bdev on which delay vbdev will be created.

 * \param vbdev_name Name of the delay bdev.

 * \param uuid UUID of the delay bdev.

 * \param avg_read_latency Desired typical read latency.

 * \param p99_read_latency Desired p99 read latency

 * \param avg_write_latency Desired typical write latency.

 * \param p99_write_latency Desired p99 write latency

 * \return 0 on success, other on failure.

 */

int create_delay_disk(const char *bdev_name, const char *vbdev_name, uint64_t avg_read_latency,

int create_delay_disk(const char *bdev_name, const char *vbdev_name, struct spdk_uuid *uuid,

		      uint64_t avg_read_latency,

		      uint64_t p99_read_latency, uint64_t avg_write_latency, uint64_t p99_write_latency);



/**

module/bdev/delay/vbdev_delay_rpc.c

+16 −1
Original line number Diff line number Diff line
@@ -84,6 +84,7 @@ SPDK_RPC_REGISTER("bdev_delay_update_latency", rpc_bdev_delay_update_latency, SP 
struct rpc_construct_delay {

	char *base_bdev_name;

	char *name;

	char *uuid;

	uint64_t avg_read_latency;

	uint64_t p99_read_latency;

	uint64_t avg_write_latency;
@@ -95,11 +96,13 @@ free_rpc_construct_delay(struct rpc_construct_delay *r) 
{

	free(r->base_bdev_name);

	free(r->name);

	free(r->uuid);

}



static const struct spdk_json_object_decoder rpc_construct_delay_decoders[] = {

	{"base_bdev_name", offsetof(struct rpc_construct_delay, base_bdev_name), spdk_json_decode_string},

	{"name", offsetof(struct rpc_construct_delay, name), spdk_json_decode_string},

	{"uuid", offsetof(struct rpc_construct_delay, uuid), spdk_json_decode_string, true},

	{"avg_read_latency", offsetof(struct rpc_construct_delay, avg_read_latency), spdk_json_decode_uint64},

	{"p99_read_latency", offsetof(struct rpc_construct_delay, p99_read_latency), spdk_json_decode_uint64},

	{"avg_write_latency", offsetof(struct rpc_construct_delay, avg_write_latency), spdk_json_decode_uint64},
@@ -112,6 +115,8 @@ rpc_bdev_delay_create(struct spdk_jsonrpc_request *request, 
{

	struct rpc_construct_delay req = {NULL};

	struct spdk_json_write_ctx *w;

	struct spdk_uuid *uuid = NULL;

	struct spdk_uuid decoded_uuid;

	int rc;



	if (spdk_json_decode_object(params, rpc_construct_delay_decoders,
@@ -123,7 +128,17 @@ rpc_bdev_delay_create(struct spdk_jsonrpc_request *request, 
		goto cleanup;

	}



	rc = create_delay_disk(req.base_bdev_name, req.name, req.avg_read_latency, req.p99_read_latency,

	if (req.uuid) {

		if (spdk_uuid_parse(&decoded_uuid, req.uuid)) {

			spdk_jsonrpc_send_error_response(request, -EINVAL,

							 "Failed to parse bdev UUID");

			goto cleanup;

		}

		uuid = &decoded_uuid;

	}



	rc = create_delay_disk(req.base_bdev_name, req.name, uuid, req.avg_read_latency,

			       req.p99_read_latency,

			       req.avg_write_latency, req.p99_write_latency);

	if (rc != 0) {

		spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc));

python/spdk/rpc/bdev.py

+4 −1
Original line number Diff line number Diff line
@@ -1162,7 +1162,7 @@ def bdev_error_create(client, base_name): 
    return client.call('bdev_error_create', params)





def bdev_delay_create(client, base_bdev_name, name, avg_read_latency, p99_read_latency, avg_write_latency, p99_write_latency):

def bdev_delay_create(client, base_bdev_name, name, avg_read_latency, p99_read_latency, avg_write_latency, p99_write_latency, uuid=None):

    """Construct a delay block device.



    Args:
@@ -1172,6 +1172,7 @@ def bdev_delay_create(client, base_bdev_name, name, avg_read_latency, p99_read_l 
        p99_read_latency: complete 1% of read ops with this delay

        avg_write_latency: complete 99% of write ops with this delay

        p99_write_latency: complete 1% of write ops with this delay

        uuid: UUID of block device (optional)



    Returns:

        Name of created block device.
@@ -1184,6 +1185,8 @@ def bdev_delay_create(client, base_bdev_name, name, avg_read_latency, p99_read_l 
        'avg_write_latency': avg_write_latency,

        'p99_write_latency': p99_write_latency,

    }

    if uuid:

        params['uuid'] = uuid

    return client.call('bdev_delay_create', params)

scripts/rpc.py

+2 −0
Original line number Diff line number Diff line
@@ -1024,6 +1024,7 @@ if __name__ == "__main__": 
        print_json(rpc.bdev.bdev_delay_create(args.client,

                                              base_bdev_name=args.base_bdev_name,

                                              name=args.name,

                                              uuid=args.uuid,

                                              avg_read_latency=args.avg_read_latency,

                                              p99_read_latency=args.nine_nine_read_latency,

                                              avg_write_latency=args.avg_write_latency,
@@ -1033,6 +1034,7 @@ if __name__ == "__main__": 
                              help='Add a delay bdev on existing bdev')

    p.add_argument('-b', '--base-bdev-name', help="Name of the existing bdev", required=True)

    p.add_argument('-d', '--name', help="Name of the delay bdev", required=True)

    p.add_argument('-u', '--uuid', help='UUID of the bdev (optional)')

    p.add_argument('-r', '--avg-read-latency',

                   help="Average latency to apply before completing read ops (in microseconds)", required=True, type=int)

    p.add_argument('-t', '--nine-nine-read-latency',