Lines Matching refs:req
198 struct rpc_bdev_nvme_hotplug req = {false, 0};
202 SPDK_COUNTOF(rpc_bdev_nvme_hotplug_decoders), &req)) {
208 rc = bdev_nvme_set_hotplug(req.enabled, req.period_us, rpc_bdev_nvme_set_hotplug_done,
247 free_rpc_bdev_nvme_attach_controller(struct rpc_bdev_nvme_attach_controller *req)
249 free(req->name);
250 free(req->trtype);
251 free(req->adrfam);
252 free(req->traddr);
253 free(req->trsvcid);
254 free(req->priority);
255 free(req->subnqn);
256 free(req->hostnqn);
257 free(req->hostaddr);
258 free(req->hostsvcid);
259 free(req->psk);
260 free(req->dhchap_key);
261 free(req->dhchap_ctrlr_key);
347 struct rpc_bdev_nvme_attach_controller req;
356 free_rpc_bdev_nvme_attach_controller(&ctx->req);
414 spdk_nvme_ctrlr_get_default_ctrlr_opts(&ctx->req.drv_opts, sizeof(ctx->req.drv_opts));
415 spdk_bdev_nvme_get_default_ctrlr_opts(&ctx->req.bdev_opts);
416 ctx->req.multipath = BDEV_NVME_MP_MODE_MULTIPATH;
417 ctx->req.max_bdevs = DEFAULT_MAX_BDEVS_PER_RPC;
421 &ctx->req)) {
428 if (ctx->req.max_bdevs == 0) {
433 ctx->names = calloc(ctx->req.max_bdevs, sizeof(char *));
440 rc = spdk_nvme_transport_id_populate_trstring(&trid, ctx->req.trtype);
442 SPDK_ERRLOG("Failed to parse trtype: %s\n", ctx->req.trtype);
444 ctx->req.trtype);
449 rc = spdk_nvme_transport_id_parse_trtype(&trid.trtype, ctx->req.trtype);
454 len = strnlen(ctx->req.traddr, maxlen);
457 ctx->req.traddr);
460 memcpy(trid.traddr, ctx->req.traddr, len + 1);
463 if (ctx->req.adrfam) {
464 rc = spdk_nvme_transport_id_parse_adrfam(&trid.adrfam, ctx->req.adrfam);
466 SPDK_ERRLOG("Failed to parse adrfam: %s\n", ctx->req.adrfam);
468 ctx->req.adrfam);
474 if (ctx->req.trsvcid) {
476 len = strnlen(ctx->req.trsvcid, maxlen);
479 ctx->req.trsvcid);
482 memcpy(trid.trsvcid, ctx->req.trsvcid, len + 1);
486 if (ctx->req.priority) {
487 trid.priority = spdk_strtol(ctx->req.priority, 10);
491 if (ctx->req.subnqn) {
493 len = strnlen(ctx->req.subnqn, maxlen);
496 ctx->req.subnqn);
499 memcpy(trid.subnqn, ctx->req.subnqn, len + 1);
502 if (ctx->req.hostnqn) {
503 maxlen = sizeof(ctx->req.drv_opts.hostnqn);
504 len = strnlen(ctx->req.hostnqn, maxlen);
507 ctx->req.hostnqn);
510 memcpy(ctx->req.drv_opts.hostnqn, ctx->req.hostnqn, len + 1);
513 if (ctx->req.psk) {
520 if (ctx->req.hostaddr) {
521 maxlen = sizeof(ctx->req.drv_opts.src_addr);
522 len = strnlen(ctx->req.hostaddr, maxlen);
525 ctx->req.hostaddr);
528 snprintf(ctx->req.drv_opts.src_addr, maxlen, "%s", ctx->req.hostaddr);
531 if (ctx->req.hostsvcid) {
532 maxlen = sizeof(ctx->req.drv_opts.src_svcid);
533 len = strnlen(ctx->req.hostsvcid, maxlen);
536 ctx->req.hostsvcid);
539 snprintf(ctx->req.drv_opts.src_svcid, maxlen, "%s", ctx->req.hostsvcid);
542 ctrlr = nvme_ctrlr_get_by_name(ctx->req.name);
546 if (ctx->req.multipath == BDEV_NVME_MP_MODE_DISABLE) {
550 ctx->req.name);
554 assert(ctx->req.multipath == BDEV_NVME_MP_MODE_FAILOVER ||
555 ctx->req.multipath == BDEV_NVME_MP_MODE_MULTIPATH);
563 strncmp(ctx->req.drv_opts.src_addr, drv_opts->src_addr, sizeof(drv_opts->src_addr)) == 0 &&
564 strncmp(ctx->req.drv_opts.src_svcid, drv_opts->src_svcid, sizeof(drv_opts->src_svcid)) == 0) {
568 ctx->req.name);
578 ctx->req.name, ctrlr_trid->subnqn);
582 if (strncmp(ctx->req.drv_opts.hostnqn, drv_opts->hostnqn, SPDK_NVMF_NQN_MAX_LEN) != 0) {
586 ctx->req.name, drv_opts->hostnqn);
590 if (ctx->req.bdev_opts.prchk_flags) {
593 ctx->req.name);
597 ctx->req.bdev_opts.prchk_flags = ctrlr->opts.prchk_flags;
600 if (ctx->req.multipath != BDEV_NVME_MP_MODE_MULTIPATH) {
601 ctx->req.bdev_opts.multipath = false;
604 if (ctx->req.drv_opts.num_io_queues == 0 || ctx->req.drv_opts.num_io_queues > UINT16_MAX + 1) {
613 ctx->req.bdev_opts.from_discovery_service = false;
614 ctx->req.bdev_opts.psk = ctx->req.psk;
615 ctx->req.bdev_opts.dhchap_key = ctx->req.dhchap_key;
616 ctx->req.bdev_opts.dhchap_ctrlr_key = ctx->req.dhchap_ctrlr_key;
617 rc = spdk_bdev_nvme_create(&trid, ctx->req.name, ctx->names, ctx->req.max_bdevs,
618 rpc_bdev_nvme_attach_controller_done, ctx, &ctx->req.drv_opts,
619 &ctx->req.bdev_opts);
668 struct rpc_bdev_nvme_get_controllers req = {};
674 &req)) {
681 if (req.name) {
682 nbdev_ctrlr = nvme_bdev_ctrlr_get_by_name(req.name);
684 SPDK_ERRLOG("ctrlr '%s' does not exist\n", req.name);
685 spdk_jsonrpc_send_error_response_fmt(request, EINVAL, "Controller %s does not exist", req.name);
704 free_rpc_bdev_nvme_get_controllers(&req);
720 free_rpc_bdev_nvme_detach_controller(struct rpc_bdev_nvme_detach_controller *req)
722 free(req->name);
723 free(req->trtype);
724 free(req->adrfam);
725 free(req->traddr);
726 free(req->trsvcid);
727 free(req->subnqn);
728 free(req->hostaddr);
729 free(req->hostsvcid);
759 struct rpc_bdev_nvme_detach_controller req = {NULL};
766 &req)) {
772 if (req.trtype != NULL) {
773 rc = spdk_nvme_transport_id_populate_trstring(&path.trid, req.trtype);
775 SPDK_ERRLOG("Failed to parse trtype: %s\n", req.trtype);
777 req.trtype);
781 rc = spdk_nvme_transport_id_parse_trtype(&path.trid.trtype, req.trtype);
783 SPDK_ERRLOG("Failed to parse trtype: %s\n", req.trtype);
785 req.trtype);
790 if (req.traddr != NULL) {
792 len = strnlen(req.traddr, maxlen);
795 req.traddr);
798 memcpy(path.trid.traddr, req.traddr, len + 1);
801 if (req.adrfam != NULL) {
802 rc = spdk_nvme_transport_id_parse_adrfam(&path.trid.adrfam, req.adrfam);
804 SPDK_ERRLOG("Failed to parse adrfam: %s\n", req.adrfam);
806 req.adrfam);
811 if (req.trsvcid != NULL) {
813 len = strnlen(req.trsvcid, maxlen);
816 req.trsvcid);
819 memcpy(path.trid.trsvcid, req.trsvcid, len + 1);
823 if (req.subnqn != NULL) {
825 len = strnlen(req.subnqn, maxlen);
828 req.subnqn);
831 memcpy(path.trid.subnqn, req.subnqn, len + 1);
834 if (req.hostaddr) {
836 len = strnlen(req.hostaddr, maxlen);
839 req.hostaddr);
842 snprintf(path.hostid.hostaddr, maxlen, "%s", req.hostaddr);
845 if (req.hostsvcid) {
847 len = strnlen(req.hostsvcid, maxlen);
850 req.hostsvcid);
853 snprintf(path.hostid.hostsvcid, maxlen, "%s", req.hostsvcid);
856 rc = bdev_nvme_delete(req.name, &path, rpc_bdev_nvme_detach_controller_done, request);
863 free_rpc_bdev_nvme_detach_controller(&req);
874 free_rpc_apply_firmware(struct rpc_apply_firmware *req)
876 free(req->filename);
877 free(req->bdev_name);
899 struct rpc_apply_firmware req;
912 free_rpc_apply_firmware(&firm_ctx->req);
1065 SPDK_COUNTOF(rpc_apply_firmware_decoders), &firm_ctx->req)) {
1071 if (spdk_bdev_open_ext(firm_ctx->req.bdev_name, true, apply_firmware_open_cb, NULL,
1075 firm_ctx->req.bdev_name);
1083 firm_ctx->req.bdev_name);
1094 fd = open(firm_ctx->req.filename, O_RDONLY);
1347 struct rpc_bdev_nvme_controller_op_req req = {NULL};
1353 &req)) {
1359 nbdev_ctrlr = nvme_bdev_ctrlr_get_by_name(req.name);
1366 if (req.cntlid == 0) {
1369 nvme_ctrlr = nvme_bdev_ctrlr_get_ctrlr_by_id(nbdev_ctrlr, req.cntlid);
1379 free_rpc_bdev_nvme_controller_op_req(&req);
1586 struct rpc_get_controller_health_info req = {};
1596 SPDK_COUNTOF(rpc_get_controller_health_info_decoders), &req)) {
1598 free_rpc_get_controller_health_info(&req);
1605 nvme_ctrlr = nvme_ctrlr_get_by_name(req.name);
1608 SPDK_ERRLOG("nvme ctrlr name '%s' does not exist\n", req.name);
1609 free_rpc_get_controller_health_info(&req);
1616 free_rpc_get_controller_health_info(&req);
1637 free_rpc_bdev_nvme_start_discovery(struct rpc_bdev_nvme_start_discovery *req)
1639 free(req->name);
1640 free(req->trtype);
1641 free(req->adrfam);
1642 free(req->traddr);
1643 free(req->trsvcid);
1644 free(req->hostnqn);
1662 struct rpc_bdev_nvme_start_discovery req;
1695 spdk_nvme_ctrlr_get_default_ctrlr_opts(&ctx->req.opts, sizeof(ctx->req.opts));
1699 &ctx->req)) {
1707 rc = spdk_nvme_transport_id_populate_trstring(&trid, ctx->req.trtype);
1709 SPDK_ERRLOG("Failed to parse trtype: %s\n", ctx->req.trtype);
1711 ctx->req.trtype);
1716 rc = spdk_nvme_transport_id_parse_trtype(&trid.trtype, ctx->req.trtype);
1721 len = strnlen(ctx->req.traddr, maxlen);
1724 ctx->req.traddr);
1727 memcpy(trid.traddr, ctx->req.traddr, len + 1);
1730 if (ctx->req.adrfam) {
1731 rc = spdk_nvme_transport_id_parse_adrfam(&trid.adrfam, ctx->req.adrfam);
1733 SPDK_ERRLOG("Failed to parse adrfam: %s\n", ctx->req.adrfam);
1735 ctx->req.adrfam);
1741 if (ctx->req.trsvcid) {
1743 len = strnlen(ctx->req.trsvcid, maxlen);
1746 ctx->req.trsvcid);
1749 memcpy(trid.trsvcid, ctx->req.trsvcid, len + 1);
1752 if (ctx->req.hostnqn) {
1753 snprintf(ctx->req.opts.hostnqn, sizeof(ctx->req.opts.hostnqn), "%s",
1754 ctx->req.hostnqn);
1757 if (ctx->req.attach_timeout_ms != 0) {
1758 ctx->req.wait_for_attach = true;
1762 cb_fn = ctx->req.wait_for_attach ? rpc_bdev_nvme_start_discovery_done : NULL;
1763 cb_ctx = ctx->req.wait_for_attach ? request : NULL;
1764 rc = bdev_nvme_start_discovery(&trid, ctx->req.name, &ctx->req.opts, &ctx->req.bdev_opts,
1765 ctx->req.attach_timeout_ms, false, cb_fn, cb_ctx);
1768 } else if (!ctx->req.wait_for_attach) {
1773 free_rpc_bdev_nvme_start_discovery(&ctx->req);
1788 struct rpc_bdev_nvme_stop_discovery req;
1798 free(ctx->req.name);
1817 &ctx->req)) {
1825 rc = bdev_nvme_stop_discovery(ctx->req.name, rpc_bdev_nvme_stop_discovery_done, ctx);
1834 free(ctx->req.name);
1870 free_rpc_add_error_injection(struct rpc_add_error_injection *req)
1872 free(req->name);
2010 free_rpc_remove_error_injection(struct rpc_remove_error_injection *req)
2012 free(req->name);
2122 struct rpc_get_io_paths req;
2138 free_rpc_get_io_paths(&ctx->req);
2162 if (ctx->req.name != NULL &&
2163 strcmp(ctx->req.name, nbdev->disk.name) != 0) {
2193 &ctx->req)) {
2197 free_rpc_get_io_paths(&ctx->req);
2222 free_rpc_bdev_nvme_set_preferred_path(struct rpc_bdev_nvme_set_preferred_path *req)
2224 free(req->name);
2233 struct rpc_bdev_nvme_set_preferred_path req;
2248 free_rpc_bdev_nvme_set_preferred_path(&ctx->req);
2266 &ctx->req)) {
2275 bdev_nvme_set_preferred_path(ctx->req.name, ctx->req.cntlid,
2280 free_rpc_bdev_nvme_set_preferred_path(&ctx->req);
2294 free_rpc_set_multipath_policy(struct rpc_set_multipath_policy *req)
2296 free(req->name);
2341 struct rpc_set_multipath_policy req;
2356 free_rpc_set_multipath_policy(&ctx->req);
2372 ctx->req.rr_min_io = UINT32_MAX;
2373 ctx->req.selector = UINT32_MAX;
2377 &ctx->req)) {
2385 if (ctx->req.selector == UINT32_MAX) {
2386 if (ctx->req.policy == BDEV_NVME_MP_POLICY_ACTIVE_ACTIVE) {
2387 ctx->req.selector = BDEV_NVME_MP_SELECTOR_ROUND_ROBIN;
2389 ctx->req.selector = 0;
2393 if (ctx->req.policy != BDEV_NVME_MP_POLICY_ACTIVE_ACTIVE && ctx->req.selector > 0) {
2400 spdk_bdev_nvme_set_multipath_policy(ctx->req.name, ctx->req.policy, ctx->req.selector,
2401 ctx->req.rr_min_io,
2406 free_rpc_set_multipath_policy(&ctx->req);
2421 free_rpc_bdev_nvme_start_mdns_discovery(struct rpc_bdev_nvme_start_mdns_discovery *req)
2423 free(req->name);
2424 free(req->svcname);
2425 free(req->hostnqn);
2435 struct rpc_bdev_nvme_start_mdns_discovery req;
2452 spdk_nvme_ctrlr_get_default_ctrlr_opts(&ctx->req.opts, sizeof(ctx->req.opts));
2456 &ctx->req)) {
2463 if (ctx->req.hostnqn) {
2464 snprintf(ctx->req.opts.hostnqn, sizeof(ctx->req.opts.hostnqn), "%s",
2465 ctx->req.hostnqn);
2468 rc = bdev_nvme_start_mdns_discovery(ctx->req.name, ctx->req.svcname, &ctx->req.opts,
2469 &ctx->req.bdev_opts);
2477 free_rpc_bdev_nvme_start_mdns_discovery(&ctx->req);
2492 struct rpc_bdev_nvme_stop_mdns_discovery req;
2511 &ctx->req)) {
2519 rc = bdev_nvme_stop_mdns_discovery(ctx->req.name);
2528 free(ctx->req.name);
2562 free_rpc_get_path_stat(struct rpc_get_path_stat *req)
2564 free(req->name);
2646 struct rpc_get_path_stat req = {};
2667 &req)) {
2671 free_rpc_get_path_stat(&req);
2675 rc = spdk_bdev_open_ext(req.name, false, dummy_bdev_event_cb, NULL, &desc);
2677 SPDK_ERRLOG("Failed to open bdev '%s': %d\n", req.name, rc);
2679 free_rpc_get_path_stat(&req);
2683 free_rpc_get_path_stat(&req);
2755 free_rpc_bdev_nvme_set_keys(struct rpc_bdev_nvme_set_keys *req)
2757 free(req->name);
2758 free(req->dhchap_key);
2759 free(req->dhchap_ctrlr_key);
2777 struct rpc_bdev_nvme_set_keys req = {};
2781 SPDK_COUNTOF(rpc_bdev_nvme_set_keys_decoders), &req)) {
2787 rc = bdev_nvme_set_keys(req.name, req.dhchap_key, req.dhchap_ctrlr_key,
2792 free_rpc_bdev_nvme_set_keys(&req);