Commit dd4f161b authored by Darek Stojaczyk's avatar Darek Stojaczyk Committed by Jim Harris
Browse files

vhost/rpc: remove any usages of the external events 



Replaced them with inline code that performs exactly
the same but is shorter and easier to follow. External
events were replaced by spdk_vhost_lock() and
spdk_vhost_dev_find().

Change-Id: Id46a619c592c20a573664b54efc097489e9bb893
Signed-off-by: default avatarDarek Stojaczyk <dariusz.stojaczyk@intel.com>
Reviewed-on: https://review.gerrithub.io/c/440378


Tested-by: default avatarSPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: default avatarPawel Wodkowski <pawelx.wodkowski@intel.com>
Reviewed-by: default avatarShuhei Matsumoto <shuhei.matsumoto.xt@hitachi.com>
Reviewed-by: default avatarJim Harris <james.r.harris@intel.com>
Reviewed-by: default avatarBen Walker <benjamin.walker@intel.com>
parent 4b6621d0

lib/vhost/vhost_rpc.c

+167 −244
Original line number Diff line number Diff line
@@ -105,8 +105,6 @@ struct rpc_add_vhost_scsi_ctrlr_lun { 
	char *ctrlr;

	int32_t scsi_target_num;

	char *bdev_name;



	struct spdk_jsonrpc_request *request;

};



static void
@@ -123,47 +121,13 @@ static const struct spdk_json_object_decoder rpc_vhost_add_lun[] = { 
	{"bdev_name", offsetof(struct rpc_add_vhost_scsi_ctrlr_lun, bdev_name), spdk_json_decode_string },

};



static int

spdk_rpc_add_vhost_scsi_lun_cb(struct spdk_vhost_dev *vdev, void *arg)

{

	struct rpc_add_vhost_scsi_ctrlr_lun *rpc = arg;

	struct spdk_jsonrpc_request *request = rpc->request;

	struct spdk_json_write_ctx *w;

	int rc;



	if (vdev == NULL) {

		rc = -ENODEV;

		goto invalid;

	}



	rc = spdk_vhost_scsi_dev_add_tgt(vdev, rpc->scsi_target_num, rpc->bdev_name);

	if (rc < 0) {

		goto invalid;

	}



	free_rpc_add_vhost_scsi_ctrlr_lun(rpc);



	w = spdk_jsonrpc_begin_result(request);

	if (w == NULL) {

		return -1;

	}



	spdk_json_write_int32(w, rc);

	spdk_jsonrpc_end_result(request, w);

	return 0;



invalid:

	free_rpc_add_vhost_scsi_ctrlr_lun(rpc);

	spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,

					 spdk_strerror(-rc));

	return rc;

}



static void

spdk_rpc_add_vhost_scsi_lun(struct spdk_jsonrpc_request *request,

			    const struct spdk_json_val *params)

{

	struct rpc_add_vhost_scsi_ctrlr_lun *req;

	struct spdk_json_write_ctx *w;

	struct spdk_vhost_dev *vdev;

	int rc;



	req = calloc(1, sizeof(*req));
@@ -172,7 +136,6 @@ spdk_rpc_add_vhost_scsi_lun(struct spdk_jsonrpc_request *request, 
		goto invalid;

	}



	req->request = request;

	if (spdk_json_decode_object(params, rpc_vhost_add_lun,

				    SPDK_COUNTOF(rpc_vhost_add_lun),

				    req)) {
@@ -187,8 +150,29 @@ spdk_rpc_add_vhost_scsi_lun(struct spdk_jsonrpc_request *request, 
		goto invalid;

	}



	spdk_vhost_call_external_event(req->ctrlr, spdk_rpc_add_vhost_scsi_lun_cb, req);

	spdk_vhost_lock();

	vdev = spdk_vhost_dev_find(req->ctrlr);

	if (vdev == NULL) {

		spdk_vhost_unlock();

		rc = -ENODEV;

		goto invalid;

	}



	rc = spdk_vhost_scsi_dev_add_tgt(vdev, req->scsi_target_num, req->bdev_name);

	spdk_vhost_unlock();

	if (rc < 0) {

		goto invalid;

	}



	free_rpc_add_vhost_scsi_ctrlr_lun(req);



	w = spdk_jsonrpc_begin_result(request);

	if (w == NULL) {

		return;

	}



	spdk_json_write_int32(w, rc);

	spdk_jsonrpc_end_result(request, w);

	return;



invalid:
@@ -238,37 +222,12 @@ spdk_rpc_remove_vhost_scsi_target_finish_cb(struct spdk_vhost_dev *vdev, void *a 
	return 0;

}



static int

spdk_rpc_remove_vhost_scsi_target_cb(struct spdk_vhost_dev *vdev, void *arg)

{

	struct rpc_remove_vhost_scsi_ctrlr_target *rpc = arg;

	struct spdk_jsonrpc_request *request = rpc->request;

	int rc;



	if (vdev == NULL) {

		rc = -ENODEV;

		goto invalid;

	}



	rc = spdk_vhost_scsi_dev_remove_tgt(vdev, rpc->scsi_target_num,

					    spdk_rpc_remove_vhost_scsi_target_finish_cb, rpc);

	if (rc < 0) {

		goto invalid;

	}



	return 0;



invalid:

	free_rpc_remove_vhost_scsi_ctrlr_target(rpc);

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

	return rc;

}



static void

spdk_rpc_remove_vhost_scsi_target(struct spdk_jsonrpc_request *request,

				  const struct spdk_json_val *params)

{

	struct rpc_remove_vhost_scsi_ctrlr_target *req;

	struct spdk_vhost_dev *vdev;

	int rc;



	req = calloc(1, sizeof(*req));
@@ -286,8 +245,20 @@ spdk_rpc_remove_vhost_scsi_target(struct spdk_jsonrpc_request *request, 
		goto invalid;

	}



	spdk_vhost_call_external_event(req->ctrlr, spdk_rpc_remove_vhost_scsi_target_cb, req);

	spdk_vhost_lock();

	vdev = spdk_vhost_dev_find(req->ctrlr);

	if (vdev == NULL) {

		spdk_vhost_unlock();

		rc = -ENODEV;

		goto invalid;

	}



	rc = spdk_vhost_scsi_dev_remove_tgt(vdev, req->scsi_target_num,

					    spdk_rpc_remove_vhost_scsi_target_finish_cb, req);

	spdk_vhost_unlock();

	if (rc < 0) {

		goto invalid;

	}

	return;



invalid:
@@ -365,8 +336,6 @@ SPDK_RPC_REGISTER("construct_vhost_blk_controller", spdk_rpc_construct_vhost_blk 


struct rpc_remove_vhost_ctrlr {

	char *ctrlr;



	struct spdk_jsonrpc_request *request;

};



static const struct spdk_json_object_decoder rpc_remove_vhost_ctrlr[] = {
@@ -380,64 +349,52 @@ free_rpc_remove_vhost_ctrlr(struct rpc_remove_vhost_ctrlr *req) 
	free(req);

}



static int

spdk_rpc_remove_vhost_controller_cb(struct spdk_vhost_dev *vdev, void *arg)

static void

spdk_rpc_remove_vhost_controller(struct spdk_jsonrpc_request *request,

				 const struct spdk_json_val *params)

{

	struct rpc_remove_vhost_ctrlr *ctx = arg;

	struct spdk_jsonrpc_request *request = ctx->request;

	struct rpc_remove_vhost_ctrlr *req;

	struct spdk_json_write_ctx *w;

	struct spdk_vhost_dev *vdev;

	int rc;



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

	if (req == NULL) {

		rc = -ENOMEM;

		goto invalid;

	}



	if (spdk_json_decode_object(params, rpc_remove_vhost_ctrlr,

				    SPDK_COUNTOF(rpc_remove_vhost_ctrlr), req)) {

		SPDK_DEBUGLOG(SPDK_LOG_VHOST_RPC, "spdk_json_decode_object failed\n");

		rc = -EINVAL;

		goto invalid;

	}



	spdk_vhost_lock();

	vdev = spdk_vhost_dev_find(req->ctrlr);

	if (vdev == NULL) {

		spdk_vhost_unlock();

		rc = -ENODEV;

		goto invalid;

	}



	rc = spdk_vhost_dev_remove(vdev);

	spdk_vhost_unlock();

	if (rc < 0) {

		goto invalid;

	}



	free_rpc_remove_vhost_ctrlr(ctx);

	free_rpc_remove_vhost_ctrlr(req);



	w = spdk_jsonrpc_begin_result(request);

	if (w == NULL) {

		return 0;

		return;

	}



	spdk_json_write_bool(w, true);

	spdk_jsonrpc_end_result(request, w);

	return 0;



invalid:

	free_rpc_remove_vhost_ctrlr(ctx);

	spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,

					 spdk_strerror(-rc));

	return -1;

}



static void

spdk_rpc_remove_vhost_controller(struct spdk_jsonrpc_request *request,

				 const struct spdk_json_val *params)

{

	struct rpc_remove_vhost_ctrlr *req;

	int rc;



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

	if (req == NULL) {

		rc = -ENOMEM;

		goto invalid;

	}



	req->request = request;

	if (spdk_json_decode_object(params, rpc_remove_vhost_ctrlr,

				    SPDK_COUNTOF(rpc_remove_vhost_ctrlr), req)) {

		SPDK_DEBUGLOG(SPDK_LOG_VHOST_RPC, "spdk_json_decode_object failed\n");

		rc = -EINVAL;

		goto invalid;

	}



	spdk_vhost_call_external_event(req->ctrlr, spdk_rpc_remove_vhost_controller_cb, req);

	return;



invalid:
@@ -452,8 +409,6 @@ SPDK_RPC_REGISTER("remove_vhost_controller", spdk_rpc_remove_vhost_controller, S 


struct rpc_get_vhost_ctrlrs {

	char *name;

	struct spdk_json_write_ctx *w;

	struct spdk_jsonrpc_request *request;

};



static void
@@ -478,98 +433,92 @@ _spdk_rpc_get_vhost_controller(struct spdk_json_write_ctx *w, struct spdk_vhost_ 
	spdk_json_write_object_end(w);

}



static int

spdk_rpc_get_vhost_controllers_cb(struct spdk_vhost_dev *vdev, void *arg)

{

	struct rpc_get_vhost_ctrlrs *ctx = arg;



	assert(ctx->name == NULL);



	if (vdev == NULL) {

		spdk_json_write_array_end(ctx->w);

		spdk_jsonrpc_end_result(ctx->request, ctx->w);

		free(ctx);

		return 0;

	}



	_spdk_rpc_get_vhost_controller(ctx->w, vdev);

	return 0;

}



static int

spdk_rpc_get_vhost_controller_cb(struct spdk_vhost_dev *vdev, void *arg)

{

	struct rpc_get_vhost_ctrlrs *ctx = arg;



	assert(ctx->name != NULL);



	if (vdev == NULL) {

		spdk_jsonrpc_send_error_response(ctx->request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,

						 spdk_strerror(ENODEV));

		goto free_name_ctx;

	}



	ctx->w = spdk_jsonrpc_begin_result(ctx->request);

	if (ctx->w == NULL) {

		goto free_name_ctx;

	}



	spdk_json_write_array_begin(ctx->w);

	_spdk_rpc_get_vhost_controller(ctx->w, vdev);

	spdk_json_write_array_end(ctx->w);



	spdk_jsonrpc_end_result(ctx->request, ctx->w);



free_name_ctx:

	free(ctx->name);

	free(ctx);

	return 0;

}



static const struct spdk_json_object_decoder rpc_get_vhost_ctrlrs_decoders[] = {

	{"name", offsetof(struct rpc_get_vhost_ctrlrs, name), spdk_json_decode_string, true},

};



static void

free_rpc_get_vhost_ctrlrs(struct rpc_get_vhost_ctrlrs *req)

{

	free(req->name);

	free(req);

}



static void

spdk_rpc_get_vhost_controllers(struct spdk_jsonrpc_request *request,

			       const struct spdk_json_val *params)

{

	struct rpc_get_vhost_ctrlrs *ctx;

	struct spdk_json_write_ctx *w;

	struct spdk_vhost_dev *vdev;

	int rc;



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

	if (ctx == NULL) {

		spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,

						 spdk_strerror(ENOMEM));

		return;

		rc = -ENOMEM;

		goto invalid;

	}



	if (params && spdk_json_decode_object(params, rpc_get_vhost_ctrlrs_decoders,

					      SPDK_COUNTOF(rpc_get_vhost_ctrlrs_decoders), ctx)) {

		SPDK_ERRLOG("spdk_json_decode_object failed\n");

		free(ctx);

		spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,

						 "Invalid parameters");

		rc = -EINVAL;

		goto invalid;

	}



	spdk_vhost_lock();

	if (ctx->name != NULL) {

		vdev = spdk_vhost_dev_find(ctx->name);

		if (vdev == NULL) {

			spdk_vhost_unlock();

			rc = -ENODEV;

			goto invalid;

		}



		free_rpc_get_vhost_ctrlrs(ctx);



		w = spdk_jsonrpc_begin_result(request);

		if (w == NULL) {

			spdk_vhost_unlock();

			return;

		}



	if (ctx->name) {

		ctx->request = request;

		spdk_vhost_call_external_event(ctx->name, spdk_rpc_get_vhost_controller_cb, ctx);

		spdk_json_write_array_begin(w);



		_spdk_rpc_get_vhost_controller(w, vdev);

		spdk_vhost_unlock();



		spdk_json_write_array_end(w);

		spdk_jsonrpc_end_result(request, w);

		return;

	}



	free_rpc_get_vhost_ctrlrs(ctx);



	w = spdk_jsonrpc_begin_result(request);

	if (w == NULL) {

		free(ctx);

		spdk_vhost_unlock();

		return;

	}



	spdk_json_write_array_begin(w);



	ctx->w = w;

	ctx->request = request;

	spdk_vhost_call_external_event_foreach(spdk_rpc_get_vhost_controllers_cb, ctx);

	vdev = spdk_vhost_dev_next(NULL);

	while (vdev != NULL) {

		_spdk_rpc_get_vhost_controller(w, vdev);

		vdev = spdk_vhost_dev_next(vdev);

	}

	spdk_vhost_unlock();



	spdk_json_write_array_end(w);

	spdk_jsonrpc_end_result(request, w);

	return;



invalid:

	if (ctx) {

		free_rpc_get_vhost_ctrlrs(ctx);

	}

	spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,

					 spdk_strerror(-rc));

}

SPDK_RPC_REGISTER("get_vhost_controllers", spdk_rpc_get_vhost_controllers, SPDK_RPC_RUNTIME)
@@ -578,7 +527,6 @@ struct rpc_vhost_ctrlr_coalescing { 
	char *ctrlr;

	uint32_t delay_base_us;

	uint32_t iops_threshold;

	struct spdk_jsonrpc_request *request;

};



static const struct spdk_json_object_decoder rpc_set_vhost_ctrlr_coalescing[] = {
@@ -598,44 +546,13 @@ free_rpc_set_vhost_controllers_event_coalescing(struct rpc_vhost_ctrlr_coalescin 
	free(req);

}



static int

spdk_rpc_set_vhost_controller_coalescing_cb(struct spdk_vhost_dev *vdev, void *arg)

{

	struct rpc_vhost_ctrlr_coalescing *req = arg;

	struct spdk_json_write_ctx *w;

	int rc;



	if (vdev == NULL) {

		rc = -ENODEV;

		goto invalid;

	}



	rc = spdk_vhost_set_coalescing(vdev, req->delay_base_us, req->iops_threshold);

	if (rc) {

		goto invalid;

	}



	w = spdk_jsonrpc_begin_result(req->request);

	if (w != NULL) {

		spdk_json_write_bool(w, true);

		spdk_jsonrpc_end_result(req->request, w);

	}



	free_rpc_set_vhost_controllers_event_coalescing(req);

	return 0;



invalid:

	spdk_jsonrpc_send_error_response(req->request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,

					 spdk_strerror(-rc));

	free_rpc_set_vhost_controllers_event_coalescing(req);

	return 0;

}



static void

spdk_rpc_set_vhost_controller_coalescing(struct spdk_jsonrpc_request *request,

		const struct spdk_json_val *params)

{

	struct rpc_vhost_ctrlr_coalescing *req;

	struct spdk_json_write_ctx *w;

	struct spdk_vhost_dev *vdev;

	int rc;



	req = calloc(1, sizeof(struct rpc_vhost_ctrlr_coalescing));
@@ -651,8 +568,28 @@ spdk_rpc_set_vhost_controller_coalescing(struct spdk_jsonrpc_request *request, 
		goto invalid;

	}



	req->request = request;

	spdk_vhost_call_external_event(req->ctrlr, spdk_rpc_set_vhost_controller_coalescing_cb, req);

	spdk_vhost_lock();

	vdev = spdk_vhost_dev_find(req->ctrlr);

	if (vdev == NULL) {

		spdk_vhost_unlock();

		rc = -ENODEV;

		goto invalid;

	}



	rc = spdk_vhost_set_coalescing(vdev, req->delay_base_us, req->iops_threshold);

	spdk_vhost_unlock();

	if (rc) {

		goto invalid;

	}



	free_rpc_set_vhost_controllers_event_coalescing(req);



	w = spdk_jsonrpc_begin_result(request);

	if (w != NULL) {

		spdk_json_write_bool(w, true);

		spdk_jsonrpc_end_result(request, w);

	}



	return;



invalid:
@@ -725,7 +662,6 @@ SPDK_RPC_REGISTER("construct_vhost_nvme_controller", spdk_rpc_construct_vhost_nv 
struct rpc_add_vhost_nvme_ctrlr_ns {

	char *ctrlr;

	char *bdev_name;

	struct spdk_jsonrpc_request *request;

};



static void
@@ -741,46 +677,13 @@ static const struct spdk_json_object_decoder rpc_vhost_nvme_add_ns[] = { 
	{"bdev_name", offsetof(struct rpc_add_vhost_nvme_ctrlr_ns, bdev_name), spdk_json_decode_string },

};



static int

spdk_rpc_add_vhost_nvme_ns_cb(struct spdk_vhost_dev *vdev, void *arg)

{

	struct rpc_add_vhost_nvme_ctrlr_ns *rpc = arg;

	struct spdk_jsonrpc_request *request = rpc->request;

	struct spdk_json_write_ctx *w;

	int rc;



	if (vdev == NULL) {

		rc = -ENODEV;

		goto invalid;

	}



	rc = spdk_vhost_nvme_dev_add_ns(vdev, rpc->bdev_name);

	if (rc < 0) {

		goto invalid;

	}

	free_rpc_add_vhost_nvme_ctrlr_ns(rpc);



	w = spdk_jsonrpc_begin_result(request);

	if (w == NULL) {

		return -1;

	}



	spdk_json_write_bool(w, true);

	spdk_jsonrpc_end_result(request, w);

	return 0;



invalid:

	free_rpc_add_vhost_nvme_ctrlr_ns(rpc);

	spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,

					 spdk_strerror(-rc));

	return rc;

}



static void

spdk_rpc_add_vhost_nvme_ns(struct spdk_jsonrpc_request *request,

			   const struct spdk_json_val *params)

{

	struct rpc_add_vhost_nvme_ctrlr_ns *req;

	struct spdk_json_write_ctx *w;

	struct spdk_vhost_dev *vdev;

	int rc;



	req = calloc(1, sizeof(*req));
@@ -789,7 +692,6 @@ spdk_rpc_add_vhost_nvme_ns(struct spdk_jsonrpc_request *request, 
		goto invalid;

	}



	req->request = request;

	if (spdk_json_decode_object(params, rpc_vhost_nvme_add_ns,

				    SPDK_COUNTOF(rpc_vhost_nvme_add_ns),

				    req)) {
@@ -798,7 +700,28 @@ spdk_rpc_add_vhost_nvme_ns(struct spdk_jsonrpc_request *request, 
		goto invalid;

	}



	spdk_vhost_call_external_event(req->ctrlr, spdk_rpc_add_vhost_nvme_ns_cb, req);

	spdk_vhost_lock();

	vdev = spdk_vhost_dev_find(req->ctrlr);

	if (vdev == NULL) {

		spdk_vhost_unlock();

		rc = -ENODEV;

		goto invalid;

	}



	rc = spdk_vhost_nvme_dev_add_ns(vdev, req->bdev_name);

	spdk_vhost_unlock();

	if (rc < 0) {

		goto invalid;

	}

	free_rpc_add_vhost_nvme_ctrlr_ns(req);



	w = spdk_jsonrpc_begin_result(request);

	if (w == NULL) {

		return;

	}



	spdk_json_write_bool(w, true);

	spdk_jsonrpc_end_result(request, w);

	return;



invalid: