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: Tomasz Zawadzki <tomasz.zawadzki@intel.com>
Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/16840
Reviewed-by: Shuhei Matsumoto <smatsumoto@nvidia.com>
Tested-by: SPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: Jim Harris <james.r.harris@intel.com>

module/bdev/delay/vbdev_delay.c

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

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

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

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

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