Commit 1a6dac40 authored by Pawel Wodkowski's avatar Pawel Wodkowski Committed by Daniel Verkamp
Browse files

bdev/virito: add JSON config dump and generic create RPC 



The new construct_virtio_dev allow creating virtio SCSI and blk for both
PCI and user transports.

Change-Id: Ibd79c4fb75e3cbd993b46227d86e915c1b740a18
Signed-off-by: default avatarPawel Wodkowski <pawelx.wodkowski@intel.com>
Reviewed-on: https://review.gerrithub.io/405419


Tested-by: default avatarSPDK Automated Test System <sys_sgsw@intel.com>
Reviewed-by: default avatarDaniel Verkamp <daniel.verkamp@intel.com>
Reviewed-by: default avatarShuhei Matsumoto <shuhei.matsumoto.xt@hitachi.com>
Reviewed-by: default avatarBen Walker <benjamin.walker@intel.com>
parent 8ebaed2e

include/spdk_internal/virtio.h

+3 −2
Original line number Diff line number Diff line
@@ -122,7 +122,8 @@ struct virtio_dev_ops { 
	void (*del_queue)(struct virtio_dev *hw, struct virtqueue *vq);

	void (*notify_queue)(struct virtio_dev *hw, struct virtqueue *vq);



	void (*dump_json_config)(struct virtio_dev *hw, struct spdk_json_write_ctx *w);

	void (*dump_json_info)(struct virtio_dev *hw, struct spdk_json_write_ctx *w);

	void (*write_json_config)(struct virtio_dev *hw, struct spdk_json_write_ctx *w);

};



struct vq_desc_extra {
@@ -424,7 +425,7 @@ virtio_dev_has_feature(struct virtio_dev *vdev, uint64_t bit) 
 * \param vdev virtio device

 * \param w json stream

 */

void virtio_dev_dump_json_config(struct virtio_dev *vdev, struct spdk_json_write_ctx *w);

void virtio_dev_dump_json_info(struct virtio_dev *vdev, struct spdk_json_write_ctx *w);



/**

 * Enumerate all PCI Virtio devices of given type on the system.

lib/bdev/virtio/bdev_virtio_blk.c

+23 −1
Original line number Diff line number Diff line
@@ -244,16 +244,38 @@ bdev_virtio_dump_json_config(void *ctx, struct spdk_json_write_ctx *w) 
{

	struct virtio_blk_dev *bvdev = ctx;



	virtio_dev_dump_json_config(&bvdev->vdev, w);

	virtio_dev_dump_json_info(&bvdev->vdev, w);

	return 0;

}



static void

bdev_virtio_write_config_json(struct spdk_bdev *bdev, struct spdk_json_write_ctx *w)

{

	struct virtio_blk_dev *bvdev = bdev->ctxt;



	spdk_json_write_object_begin(w);



	spdk_json_write_named_string(w, "method", "construct_virtio_dev");



	spdk_json_write_named_object_begin(w, "params");

	spdk_json_write_named_string(w, "name", bvdev->vdev.name);

	spdk_json_write_named_string(w, "dev_type", "blk");



	/* Write transport specific parameters. */

	bvdev->vdev.backend_ops->write_json_config(&bvdev->vdev, w);



	spdk_json_write_object_end(w);



	spdk_json_write_object_end(w);

}



static const struct spdk_bdev_fn_table virtio_fn_table = {

	.destruct		= bdev_virtio_disk_destruct,

	.submit_request		= bdev_virtio_submit_request,

	.io_type_supported	= bdev_virtio_io_type_supported,

	.get_io_channel		= bdev_virtio_get_io_channel,

	.dump_info_json		= bdev_virtio_dump_json_config,

	.write_config_json	= bdev_virtio_write_config_json,

};



static void

lib/bdev/virtio/bdev_virtio_rpc.c

+152 −4
Original line number Diff line number Diff line
@@ -40,6 +40,9 @@ 


#include "bdev_virtio.h"



#define SPDK_VIRTIO_USER_DEFAULT_VQ_COUNT		1

#define SPDK_VIRTIO_USER_DEFAULT_QUEUE_SIZE		512



struct rpc_construct_virtio_scsi_dev {

	char *path;

	char *pci_address;
@@ -113,8 +116,8 @@ spdk_rpc_create_virtio_user_scsi_bdev(struct spdk_jsonrpc_request *request, 
	}



	req->pci_address = NULL;

	req->vq_count = 1;

	req->vq_size = 512;

	req->vq_count = SPDK_VIRTIO_USER_DEFAULT_VQ_COUNT;

	req->vq_size = SPDK_VIRTIO_USER_DEFAULT_QUEUE_SIZE;



	if (spdk_json_decode_object(params, rpc_construct_virtio_user_scsi_dev,

				    SPDK_COUNTOF(rpc_construct_virtio_user_scsi_dev),
@@ -320,8 +323,8 @@ spdk_rpc_create_virtio_user_blk_bdev(struct spdk_jsonrpc_request *request, 
	int rc;



	req.pci_address = NULL;

	req.vq_count = 1;

	req.vq_size = 512;

	req.vq_count = SPDK_VIRTIO_USER_DEFAULT_VQ_COUNT;

	req.vq_size = SPDK_VIRTIO_USER_DEFAULT_QUEUE_SIZE;



	if (spdk_json_decode_object(params, rpc_construct_virtio_user_blk_dev,

				    SPDK_COUNTOF(rpc_construct_virtio_user_blk_dev),
@@ -407,3 +410,148 @@ invalid: 
	free_rpc_construct_virtio_blk_dev(&req);

}

SPDK_RPC_REGISTER("construct_virtio_pci_blk_bdev", spdk_rpc_create_virtio_pci_blk_bdev);



struct rpc_construct_virtio_dev {

	char *name;

	char *trtype;

	char *traddr;

	char *dev_type;

	uint32_t vq_count;

	uint32_t vq_size;

	struct spdk_jsonrpc_request *request;

};



static const struct spdk_json_object_decoder rpc_construct_virtio_dev[] = {

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

	{"trtype", offsetof(struct rpc_construct_virtio_dev, trtype), spdk_json_decode_string },

	{"traddr", offsetof(struct rpc_construct_virtio_dev, traddr), spdk_json_decode_string },

	{"dev_type", offsetof(struct rpc_construct_virtio_dev, dev_type), spdk_json_decode_string },

	{"vq_count", offsetof(struct rpc_construct_virtio_dev, vq_count), spdk_json_decode_uint32, true },

	{"vq_size", offsetof(struct rpc_construct_virtio_dev, vq_size), spdk_json_decode_uint32, true },

};



static void

free_rpc_construct_virtio_dev(struct rpc_construct_virtio_dev *req)

{

	free(req->name);

	free(req->trtype);

	free(req->traddr);

	free(req->dev_type);

	free(req);

}



static void

spdk_rpc_create_virtio_dev_cb(void *ctx, int result, struct spdk_bdev **bdevs, size_t cnt)

{

	struct rpc_construct_virtio_dev *req = ctx;

	struct spdk_json_write_ctx *w;

	size_t i;



	if (result) {

		spdk_jsonrpc_send_error_response(req->request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,

						 spdk_strerror(-result));

		free_rpc_construct_virtio_dev(req);

		return;

	}



	w = spdk_jsonrpc_begin_result(req->request);

	if (w) {

		spdk_json_write_array_begin(w);



		for (i = 0; i < cnt; i++) {

			spdk_json_write_string(w, spdk_bdev_get_name(bdevs[i]));

		}



		spdk_json_write_array_end(w);

		spdk_jsonrpc_end_result(req->request, w);

	}



	free_rpc_construct_virtio_dev(ctx);

}



static void

spdk_rpc_create_virtio_dev(struct spdk_jsonrpc_request *request,

			   const struct spdk_json_val *params)

{

	struct rpc_construct_virtio_dev *req;

	struct spdk_bdev *bdev;

	struct spdk_pci_addr pci_addr;

	bool pci;

	int rc;



	req = calloc(1, sizeof(*req));

	if (!req) {

		SPDK_ERRLOG("calloc() failed\n");

		spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, spdk_strerror(ENOMEM));

		return;

	}



	if (spdk_json_decode_object(params, rpc_construct_virtio_dev,

				    SPDK_COUNTOF(rpc_construct_virtio_dev),

				    req)) {

		spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, spdk_strerror(EINVAL));

		goto invalid;

	}



	if (strcmp(req->trtype, "pci") == 0) {

		if (req->vq_count != 0 || req->vq_size != 0) {

			SPDK_ERRLOG("VQ count or size is not allowed for PCI transport type\n");

			spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,

							 "vq_count or vq_size is not allowed for PCI transport type.");

			goto invalid;

		}



		if (spdk_pci_addr_parse(&pci_addr, req->traddr) != 0) {

			SPDK_ERRLOG("Invalid PCI address '%s'\n", req->traddr);

			spdk_jsonrpc_send_error_response_fmt(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,

							     "Invalid PCI address '%s'", req->traddr);

			goto invalid;

		}



		pci = true;

	} else if (strcmp(req->trtype, "user") == 0) {

		req->vq_count = req->vq_count == 0 ? SPDK_VIRTIO_USER_DEFAULT_VQ_COUNT : req->vq_count;

		req->vq_size = req->vq_size == 0 ? SPDK_VIRTIO_USER_DEFAULT_QUEUE_SIZE : req->vq_size;

		pci = false;

	} else {

		SPDK_ERRLOG("Invalid trtype '%s'\n", req->trtype);

		spdk_jsonrpc_send_error_response_fmt(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,

						     "Invalid trtype '%s'", req->trtype);

		goto invalid;

	}



	req->request = request;

	if (strcmp(req->dev_type, "blk") == 0) {

		if (pci) {

			bdev = bdev_virtio_pci_blk_dev_create(req->name, &pci_addr);

		} else {

			bdev = bdev_virtio_user_blk_dev_create(req->name, req->traddr, req->vq_count, req->vq_size);

		}



		/* Virtio blk doesn't use callback so call it manually to send result. */

		rc = bdev ? 0 : -EINVAL;

		spdk_rpc_create_virtio_dev_cb(req, rc, &bdev, bdev ? 1 : 0);

	} else if (strcmp(req->dev_type, "scsi") == 0) {

		if (pci) {

			rc = bdev_virtio_pci_scsi_dev_create(req->name, &pci_addr, spdk_rpc_create_virtio_dev_cb, req);

		} else {

			rc = bdev_virtio_user_scsi_dev_create(req->name, req->traddr, req->vq_count, req->vq_size,

							      spdk_rpc_create_virtio_dev_cb, req);

		}



		if (rc < 0) {

			/* In case of error callback is not called so do it manually to send result. */

			spdk_rpc_create_virtio_dev_cb(req, rc, NULL, 0);

		}

	} else {

		SPDK_ERRLOG("Invalid dev_type '%s'\n", req->dev_type);

		spdk_jsonrpc_send_error_response_fmt(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,

						     "Invalid dev_type '%s'", req->dev_type);

		goto invalid;

	}



	return;

invalid:

	free_rpc_construct_virtio_dev(req);

}

SPDK_RPC_REGISTER("construct_virtio_dev", spdk_rpc_create_virtio_dev);

lib/bdev/virtio/bdev_virtio_scsi.c

+43 −4
Original line number Diff line number Diff line
@@ -408,11 +408,41 @@ bdev_virtio_get_ctx_size(void) 
	return sizeof(struct virtio_scsi_io_ctx);

}



static int

bdev_virtio_scsi_config_json(struct spdk_json_write_ctx *w)

{

	struct virtio_scsi_dev *svdev;



	pthread_mutex_lock(&g_virtio_scsi_mutex);

	TAILQ_FOREACH(svdev, &g_virtio_scsi_devs, tailq) {

		spdk_json_write_object_begin(w);



		spdk_json_write_named_string(w, "method", "construct_virtio_dev");



		spdk_json_write_named_object_begin(w, "params");

		spdk_json_write_named_string(w, "name", svdev->vdev.name);

		spdk_json_write_named_string(w, "dev_type", "scsi");



		/* Write transport specific parameters. */

		svdev->vdev.backend_ops->write_json_config(&svdev->vdev, w);



		spdk_json_write_object_end(w);



		spdk_json_write_object_end(w);



	}

	pthread_mutex_unlock(&g_virtio_scsi_mutex);



	return 0;

}





static struct spdk_bdev_module virtio_scsi_if = {

	.name = "virtio_scsi",

	.module_init = bdev_virtio_initialize,

	.module_fini = bdev_virtio_finish,

	.get_ctx_size = bdev_virtio_get_ctx_size,

	.config_json = bdev_virtio_scsi_config_json,

	.async_init = true,

	.async_fini = true,

};
@@ -675,20 +705,29 @@ bdev_virtio_disk_destruct(void *ctx) 
}



static int

bdev_virtio_dump_info_config(void *ctx, struct spdk_json_write_ctx *w)

bdev_virtio_dump_info_json(void *ctx, struct spdk_json_write_ctx *w)

{

	struct virtio_scsi_disk *disk = ctx;



	virtio_dev_dump_json_config(&disk->svdev->vdev, w);

	virtio_dev_dump_json_info(&disk->svdev->vdev, w);

	return 0;

}



static void

bdev_virtio_write_config_json(struct spdk_bdev *bdev, struct spdk_json_write_ctx *w)

{

	/* SCSI targets and LUNS are discovered during scan process so nothing

	 * to save here.

	 */

}



static const struct spdk_bdev_fn_table virtio_fn_table = {

	.destruct		= bdev_virtio_disk_destruct,

	.submit_request		= bdev_virtio_submit_request,

	.io_type_supported	= bdev_virtio_io_type_supported,

	.get_io_channel		= bdev_virtio_get_io_channel,

	.dump_info_json		= bdev_virtio_dump_info_config,

	.dump_info_json		= bdev_virtio_dump_info_json,

	.write_config_json	= bdev_virtio_write_config_json,

};



static void
@@ -1948,7 +1987,7 @@ bdev_virtio_scsi_dev_list(struct spdk_json_write_ctx *w) 
		spdk_json_write_name(w, "name");

		spdk_json_write_string(w, svdev->vdev.name);



		virtio_dev_dump_json_config(&svdev->vdev, w);

		virtio_dev_dump_json_info(&svdev->vdev, w);



		spdk_json_write_object_end(w);

	}

lib/virtio/virtio.c

+2 −2
Original line number Diff line number Diff line
@@ -708,7 +708,7 @@ virtio_dev_backend_ops(struct virtio_dev *dev) 
}



void

virtio_dev_dump_json_config(struct virtio_dev *hw, struct spdk_json_write_ctx *w)

virtio_dev_dump_json_info(struct virtio_dev *hw, struct spdk_json_write_ctx *w)

{

	spdk_json_write_name(w, "virtio");

	spdk_json_write_object_begin(w);
@@ -719,7 +719,7 @@ virtio_dev_dump_json_config(struct virtio_dev *hw, struct spdk_json_write_ctx *w 
	spdk_json_write_name(w, "vq_size");

	spdk_json_write_uint32(w, virtio_dev_backend_ops(hw)->get_queue_num(hw, 0));



	virtio_dev_backend_ops(hw)->dump_json_config(hw, w);

	virtio_dev_backend_ops(hw)->dump_json_info(hw, w);



	spdk_json_write_object_end(w);

}