1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright (C) 2018 Intel Corporation. 3 * All rights reserved. 4 */ 5 6 #include "spdk/stdinc.h" 7 #include "spdk/string.h" 8 #include "spdk/rpc.h" 9 #include "spdk/util.h" 10 #include "spdk/bdev_module.h" 11 #include "spdk/log.h" 12 13 #include "bdev_nvme.h" 14 #include "spdk/base64.h" 15 16 enum spdk_nvme_rpc_type { 17 NVME_ADMIN_CMD = 1, 18 NVME_IO_CMD, 19 }; 20 21 struct rpc_bdev_nvme_send_cmd_req { 22 char *name; 23 int cmd_type; 24 int data_direction; 25 uint32_t timeout_ms; 26 uint32_t data_len; 27 uint32_t md_len; 28 29 struct spdk_nvme_cmd *cmdbuf; 30 char *data; 31 char *md; 32 }; 33 34 struct rpc_bdev_nvme_send_cmd_resp { 35 char *cpl_text; 36 char *data_text; 37 char *md_text; 38 }; 39 40 struct rpc_bdev_nvme_send_cmd_ctx { 41 struct spdk_jsonrpc_request *jsonrpc_request; 42 struct rpc_bdev_nvme_send_cmd_req req; 43 struct rpc_bdev_nvme_send_cmd_resp resp; 44 struct nvme_ctrlr *nvme_ctrlr; 45 struct spdk_io_channel *ctrlr_io_ch; 46 }; 47 48 static void 49 free_rpc_bdev_nvme_send_cmd_ctx(struct rpc_bdev_nvme_send_cmd_ctx *ctx) 50 { 51 assert(ctx != NULL); 52 53 free(ctx->req.name); 54 free(ctx->req.cmdbuf); 55 spdk_free(ctx->req.data); 56 spdk_free(ctx->req.md); 57 free(ctx->resp.cpl_text); 58 free(ctx->resp.data_text); 59 free(ctx->resp.md_text); 60 free(ctx); 61 } 62 63 static int 64 rpc_bdev_nvme_send_cmd_resp_construct(struct rpc_bdev_nvme_send_cmd_resp *resp, 65 struct rpc_bdev_nvme_send_cmd_req *req, 66 const struct spdk_nvme_cpl *cpl) 67 { 68 resp->cpl_text = malloc(spdk_base64_get_encoded_strlen(sizeof(*cpl)) + 1); 69 if (!resp->cpl_text) { 70 return -ENOMEM; 71 } 72 spdk_base64_urlsafe_encode(resp->cpl_text, cpl, sizeof(*cpl)); 73 74 if (req->data_direction == SPDK_NVME_DATA_CONTROLLER_TO_HOST) { 75 if (req->data_len) { 76 resp->data_text = malloc(spdk_base64_get_encoded_strlen(req->data_len) + 1); 77 if (!resp->data_text) { 78 return -ENOMEM; 79 } 80 spdk_base64_urlsafe_encode(resp->data_text, req->data, req->data_len); 81 } 82 if (req->md_len) { 83 resp->md_text = malloc(spdk_base64_get_encoded_strlen(req->md_len) + 1); 84 if (!resp->md_text) { 85 return -ENOMEM; 86 } 87 spdk_base64_urlsafe_encode(resp->md_text, req->md, req->md_len); 88 } 89 } 90 91 return 0; 92 } 93 94 static void 95 rpc_bdev_nvme_send_cmd_complete(struct rpc_bdev_nvme_send_cmd_ctx *ctx, 96 const struct spdk_nvme_cpl *cpl) 97 { 98 struct spdk_jsonrpc_request *request = ctx->jsonrpc_request; 99 struct spdk_json_write_ctx *w; 100 int ret; 101 102 ret = rpc_bdev_nvme_send_cmd_resp_construct(&ctx->resp, &ctx->req, cpl); 103 if (ret) { 104 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 105 spdk_strerror(-ret)); 106 goto out; 107 } 108 109 w = spdk_jsonrpc_begin_result(request); 110 spdk_json_write_object_begin(w); 111 spdk_json_write_named_string(w, "cpl", ctx->resp.cpl_text); 112 113 if (ctx->resp.data_text) { 114 spdk_json_write_named_string(w, "data", ctx->resp.data_text); 115 } 116 117 if (ctx->resp.md_text) { 118 spdk_json_write_named_string(w, "metadata", ctx->resp.md_text); 119 } 120 121 spdk_json_write_object_end(w); 122 spdk_jsonrpc_end_result(request, w); 123 124 out: 125 free_rpc_bdev_nvme_send_cmd_ctx(ctx); 126 return; 127 } 128 129 static void 130 nvme_rpc_bdev_nvme_cb(void *ref, const struct spdk_nvme_cpl *cpl) 131 { 132 struct rpc_bdev_nvme_send_cmd_ctx *ctx = (struct rpc_bdev_nvme_send_cmd_ctx *)ref; 133 134 if (ctx->ctrlr_io_ch) { 135 spdk_put_io_channel(ctx->ctrlr_io_ch); 136 ctx->ctrlr_io_ch = NULL; 137 } 138 139 rpc_bdev_nvme_send_cmd_complete(ctx, cpl); 140 } 141 142 static int 143 nvme_rpc_admin_cmd_bdev_nvme(struct rpc_bdev_nvme_send_cmd_ctx *ctx, struct spdk_nvme_cmd *cmd, 144 void *buf, uint32_t nbytes, uint32_t timeout_ms) 145 { 146 struct nvme_ctrlr *_nvme_ctrlr = ctx->nvme_ctrlr; 147 int ret; 148 149 ret = spdk_nvme_ctrlr_cmd_admin_raw(_nvme_ctrlr->ctrlr, cmd, buf, 150 nbytes, nvme_rpc_bdev_nvme_cb, ctx); 151 152 return ret; 153 } 154 155 static int 156 nvme_rpc_io_cmd_bdev_nvme(struct rpc_bdev_nvme_send_cmd_ctx *ctx, struct spdk_nvme_cmd *cmd, 157 void *buf, uint32_t nbytes, void *md_buf, uint32_t md_len, 158 uint32_t timeout_ms) 159 { 160 struct nvme_ctrlr *_nvme_ctrlr = ctx->nvme_ctrlr; 161 struct spdk_nvme_qpair *io_qpair; 162 int ret; 163 164 ctx->ctrlr_io_ch = spdk_get_io_channel(_nvme_ctrlr); 165 io_qpair = bdev_nvme_get_io_qpair(ctx->ctrlr_io_ch); 166 167 ret = spdk_nvme_ctrlr_cmd_io_raw_with_md(_nvme_ctrlr->ctrlr, io_qpair, 168 cmd, buf, nbytes, md_buf, nvme_rpc_bdev_nvme_cb, ctx); 169 if (ret) { 170 spdk_put_io_channel(ctx->ctrlr_io_ch); 171 } 172 173 return ret; 174 175 } 176 177 static int 178 rpc_bdev_nvme_send_cmd_exec(struct rpc_bdev_nvme_send_cmd_ctx *ctx) 179 { 180 struct rpc_bdev_nvme_send_cmd_req *req = &ctx->req; 181 int ret = -EINVAL; 182 183 switch (req->cmd_type) { 184 case NVME_ADMIN_CMD: 185 ret = nvme_rpc_admin_cmd_bdev_nvme(ctx, req->cmdbuf, req->data, 186 req->data_len, req->timeout_ms); 187 break; 188 case NVME_IO_CMD: 189 ret = nvme_rpc_io_cmd_bdev_nvme(ctx, req->cmdbuf, req->data, 190 req->data_len, req->md, req->md_len, req->timeout_ms); 191 break; 192 } 193 194 return ret; 195 } 196 197 static int 198 rpc_decode_cmd_type(const struct spdk_json_val *val, void *out) 199 { 200 int *cmd_type = out; 201 202 if (spdk_json_strequal(val, "admin") == true) { 203 *cmd_type = NVME_ADMIN_CMD; 204 } else if (spdk_json_strequal(val, "io") == true) { 205 *cmd_type = NVME_IO_CMD; 206 } else { 207 SPDK_NOTICELOG("Invalid parameter value: cmd_type\n"); 208 return -EINVAL; 209 } 210 211 return 0; 212 } 213 214 static int 215 rpc_decode_data_direction(const struct spdk_json_val *val, void *out) 216 { 217 int *data_direction = out; 218 219 if (spdk_json_strequal(val, "h2c") == true) { 220 *data_direction = SPDK_NVME_DATA_HOST_TO_CONTROLLER; 221 } else if (spdk_json_strequal(val, "c2h") == true) { 222 *data_direction = SPDK_NVME_DATA_CONTROLLER_TO_HOST; 223 } else { 224 SPDK_NOTICELOG("Invalid parameter value: data_direction\n"); 225 return -EINVAL; 226 } 227 228 return 0; 229 } 230 231 static int 232 rpc_decode_cmdbuf(const struct spdk_json_val *val, void *out) 233 { 234 char *text = NULL; 235 size_t text_strlen, raw_len; 236 struct spdk_nvme_cmd *cmdbuf, **_cmdbuf = out; 237 int rc; 238 239 rc = spdk_json_decode_string(val, &text); 240 if (rc) { 241 return val->type == SPDK_JSON_VAL_STRING ? -ENOMEM : -EINVAL; 242 } 243 244 text_strlen = strlen(text); 245 raw_len = spdk_base64_get_decoded_len(text_strlen); 246 cmdbuf = malloc(raw_len); 247 if (!cmdbuf) { 248 rc = -ENOMEM; 249 goto out; 250 } 251 252 rc = spdk_base64_urlsafe_decode(cmdbuf, &raw_len, text); 253 if (rc) { 254 free(cmdbuf); 255 goto out; 256 } 257 if (raw_len != sizeof(*cmdbuf)) { 258 rc = -EINVAL; 259 free(cmdbuf); 260 goto out; 261 } 262 263 *_cmdbuf = cmdbuf; 264 265 out: 266 free(text); 267 return rc; 268 } 269 270 static int 271 rpc_decode_data(const struct spdk_json_val *val, void *out) 272 { 273 struct rpc_bdev_nvme_send_cmd_req *req = (struct rpc_bdev_nvme_send_cmd_req *)out; 274 char *text = NULL; 275 size_t text_strlen; 276 int rc; 277 278 rc = spdk_json_decode_string(val, &text); 279 if (rc) { 280 return val->type == SPDK_JSON_VAL_STRING ? -ENOMEM : -EINVAL; 281 } 282 text_strlen = strlen(text); 283 284 if (req->data_len) { 285 /* data_len is decoded by param "data_len" */ 286 if (req->data_len != spdk_base64_get_decoded_len(text_strlen)) { 287 rc = -EINVAL; 288 goto out; 289 } 290 } else { 291 req->data_len = spdk_base64_get_decoded_len(text_strlen); 292 req->data = spdk_malloc(req->data_len > 0x1000 ? req->data_len : 0x1000, 0x1000, 293 NULL, SPDK_ENV_LCORE_ID_ANY, SPDK_MALLOC_DMA); 294 if (!req->data) { 295 rc = -ENOMEM; 296 goto out; 297 } 298 } 299 300 rc = spdk_base64_urlsafe_decode(req->data, (size_t *)&req->data_len, text); 301 302 out: 303 free(text); 304 return rc; 305 } 306 307 static int 308 rpc_decode_data_len(const struct spdk_json_val *val, void *out) 309 { 310 struct rpc_bdev_nvme_send_cmd_req *req = (struct rpc_bdev_nvme_send_cmd_req *)out; 311 uint32_t data_len; 312 int rc; 313 314 rc = spdk_json_decode_uint32(val, &data_len); 315 if (rc) { 316 return rc; 317 } 318 319 if (req->data_len) { 320 /* data_len is decoded by param "data" */ 321 if (req->data_len != data_len) { 322 rc = -EINVAL; 323 } 324 } else { 325 req->data_len = data_len; 326 req->data = spdk_malloc(req->data_len > 0x1000 ? req->data_len : 0x1000, 0x1000, 327 NULL, SPDK_ENV_LCORE_ID_ANY, SPDK_MALLOC_DMA); 328 if (!req->data) { 329 rc = -ENOMEM; 330 } 331 } 332 333 return rc; 334 } 335 336 static int 337 rpc_decode_metadata(const struct spdk_json_val *val, void *out) 338 { 339 struct rpc_bdev_nvme_send_cmd_req *req = (struct rpc_bdev_nvme_send_cmd_req *)out; 340 char *text = NULL; 341 size_t text_strlen; 342 int rc; 343 344 rc = spdk_json_decode_string(val, &text); 345 if (rc) { 346 return val->type == SPDK_JSON_VAL_STRING ? -ENOMEM : -EINVAL; 347 } 348 text_strlen = strlen(text); 349 350 if (req->md_len) { 351 /* md_len is decoded by param "metadata_len" */ 352 if (req->md_len != spdk_base64_get_decoded_len(text_strlen)) { 353 rc = -EINVAL; 354 goto out; 355 } 356 } else { 357 req->md_len = spdk_base64_get_decoded_len(text_strlen); 358 req->md = spdk_malloc(req->md_len, 0x1000, NULL, 359 SPDK_ENV_LCORE_ID_ANY, SPDK_MALLOC_DMA); 360 if (!req->md) { 361 rc = -ENOMEM; 362 goto out; 363 } 364 } 365 366 rc = spdk_base64_urlsafe_decode(req->md, (size_t *)&req->md_len, text); 367 368 out: 369 free(text); 370 return rc; 371 } 372 373 static int 374 rpc_decode_metadata_len(const struct spdk_json_val *val, void *out) 375 { 376 struct rpc_bdev_nvme_send_cmd_req *req = (struct rpc_bdev_nvme_send_cmd_req *)out; 377 uint32_t md_len; 378 int rc; 379 380 rc = spdk_json_decode_uint32(val, &md_len); 381 if (rc) { 382 return rc; 383 } 384 385 if (req->md_len) { 386 /* md_len is decoded by param "metadata" */ 387 if (req->md_len != md_len) { 388 rc = -EINVAL; 389 } 390 } else { 391 req->md_len = md_len; 392 req->md = spdk_malloc(req->md_len, 0x1000, NULL, 393 SPDK_ENV_LCORE_ID_ANY, SPDK_MALLOC_DMA); 394 if (!req->md) { 395 rc = -ENOMEM; 396 } 397 } 398 399 return rc; 400 } 401 402 static const struct spdk_json_object_decoder rpc_bdev_nvme_send_cmd_req_decoders[] = { 403 {"name", offsetof(struct rpc_bdev_nvme_send_cmd_req, name), spdk_json_decode_string}, 404 {"cmd_type", offsetof(struct rpc_bdev_nvme_send_cmd_req, cmd_type), rpc_decode_cmd_type}, 405 {"data_direction", offsetof(struct rpc_bdev_nvme_send_cmd_req, data_direction), rpc_decode_data_direction}, 406 {"cmdbuf", offsetof(struct rpc_bdev_nvme_send_cmd_req, cmdbuf), rpc_decode_cmdbuf}, 407 {"timeout_ms", offsetof(struct rpc_bdev_nvme_send_cmd_req, timeout_ms), spdk_json_decode_uint32, true}, 408 {"data_len", 0, rpc_decode_data_len, true}, 409 {"metadata_len", 0, rpc_decode_metadata_len, true}, 410 {"data", 0, rpc_decode_data, true}, 411 {"metadata", 0, rpc_decode_metadata, true}, 412 }; 413 414 static void 415 rpc_bdev_nvme_send_cmd(struct spdk_jsonrpc_request *request, 416 const struct spdk_json_val *params) 417 { 418 struct rpc_bdev_nvme_send_cmd_ctx *ctx; 419 int ret, error_code; 420 421 ctx = calloc(1, sizeof(*ctx)); 422 if (!ctx) { 423 SPDK_ERRLOG("Failed at Malloc ctx\n"); 424 error_code = SPDK_JSONRPC_ERROR_INTERNAL_ERROR; 425 ret = -ENOMEM; 426 goto invalid; 427 } 428 429 if (spdk_json_decode_object(params, rpc_bdev_nvme_send_cmd_req_decoders, 430 SPDK_COUNTOF(rpc_bdev_nvme_send_cmd_req_decoders), 431 &ctx->req)) { 432 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 433 error_code = SPDK_JSONRPC_ERROR_INVALID_PARAMS; 434 ret = -EINVAL; 435 goto invalid; 436 } 437 438 ctx->nvme_ctrlr = nvme_ctrlr_get_by_name(ctx->req.name); 439 if (ctx->nvme_ctrlr == NULL) { 440 SPDK_ERRLOG("Failed at device lookup\n"); 441 error_code = SPDK_JSONRPC_ERROR_INVALID_PARAMS; 442 ret = -EINVAL; 443 goto invalid; 444 } 445 446 ctx->jsonrpc_request = request; 447 448 ret = rpc_bdev_nvme_send_cmd_exec(ctx); 449 if (ret < 0) { 450 SPDK_NOTICELOG("Failed at rpc_bdev_nvme_send_cmd_exec\n"); 451 error_code = SPDK_JSONRPC_ERROR_INTERNAL_ERROR; 452 goto invalid; 453 } 454 455 return; 456 457 invalid: 458 if (ctx != NULL) { 459 free_rpc_bdev_nvme_send_cmd_ctx(ctx); 460 } 461 spdk_jsonrpc_send_error_response(request, error_code, spdk_strerror(-ret)); 462 } 463 SPDK_RPC_REGISTER("bdev_nvme_send_cmd", rpc_bdev_nvme_send_cmd, SPDK_RPC_RUNTIME) 464