Lines Matching refs:ctx
187 rpc_bdev_nvme_set_hotplug_done(void *ctx)
189 struct spdk_jsonrpc_request *request = ctx;
354 free_rpc_bdev_nvme_attach_controller_ctx(struct rpc_bdev_nvme_attach_controller_ctx *ctx)
356 free_rpc_bdev_nvme_attach_controller(&ctx->req);
357 free(ctx->names);
358 free(ctx);
364 struct rpc_bdev_nvme_attach_controller_ctx *ctx = cb_ctx;
365 struct spdk_jsonrpc_request *request = ctx->request;
371 for (i = 0; i < ctx->bdev_count; i++) {
372 spdk_json_write_string(w, ctx->names[i]);
377 free_rpc_bdev_nvme_attach_controller_ctx(ctx);
383 struct rpc_bdev_nvme_attach_controller_ctx *ctx = cb_ctx;
384 struct spdk_jsonrpc_request *request = ctx->request;
388 free_rpc_bdev_nvme_attach_controller_ctx(ctx);
392 ctx->bdev_count = bdev_count;
393 spdk_bdev_wait_for_examine(rpc_bdev_nvme_attach_controller_examined, ctx);
400 struct rpc_bdev_nvme_attach_controller_ctx *ctx;
408 ctx = calloc(1, sizeof(*ctx));
409 if (!ctx) {
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 *));
434 if (ctx->names == NULL) {
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) {
611 ctx->request = request;
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);
628 free_rpc_bdev_nvme_attach_controller_ctx(ctx);
634 rpc_dump_nvme_bdev_controller_info(struct nvme_bdev_ctrlr *nbdev_ctrlr, void *ctx)
636 struct spdk_json_write_ctx *w = ctx;
926 _apply_firmware_complete_reset(void *ctx)
929 struct firmware_update_info *firm_ctx = ctx;
968 _apply_firmware_complete(void *ctx)
974 struct firmware_update_info *firm_ctx = ctx;
1220 struct rpc_bdev_nvme_transport_stat_ctx *ctx;
1228 ctx = spdk_io_channel_iter_get_ctx(i);
1238 spdk_json_write_object_begin(ctx->w);
1239 spdk_json_write_named_string(ctx->w, "thread", spdk_thread_get_name(spdk_get_thread()));
1240 spdk_json_write_named_array_begin(ctx->w, "transports");
1244 spdk_json_write_object_begin(ctx->w);
1245 spdk_json_write_named_string(ctx->w, "trname", spdk_nvme_transport_id_trtype_str(tr_stat->trtype));
1249 rpc_bdev_nvme_rdma_stats(ctx->w, tr_stat);
1253 rpc_bdev_nvme_pcie_stats(ctx->w, tr_stat);
1256 rpc_bdev_nvme_tcp_stats(ctx->w, tr_stat);
1262 spdk_json_write_object_end(ctx->w);
1265 spdk_json_write_array_end(ctx->w);
1266 spdk_json_write_object_end(ctx->w);
1275 struct rpc_bdev_nvme_transport_stat_ctx *ctx = spdk_io_channel_iter_get_ctx(i);
1277 spdk_json_write_array_end(ctx->w);
1278 spdk_json_write_object_end(ctx->w);
1279 spdk_jsonrpc_end_result(ctx->request, ctx->w);
1280 free(ctx);
1287 struct rpc_bdev_nvme_transport_stat_ctx *ctx;
1295 ctx = calloc(1, sizeof(*ctx));
1296 if (!ctx) {
1301 ctx->request = request;
1302 ctx->w = spdk_jsonrpc_begin_result(ctx->request);
1303 spdk_json_write_object_begin(ctx->w);
1304 spdk_json_write_named_array_begin(ctx->w, "poll_groups");
1308 ctx,
1667 rpc_bdev_nvme_start_discovery_done(void *ctx, int status)
1669 struct spdk_jsonrpc_request *request = ctx;
1682 struct rpc_bdev_nvme_start_discovery_ctx *ctx;
1689 ctx = calloc(1, sizeof(*ctx));
1690 if (!ctx) {
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;
1761 ctx->request = request;
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);
1774 free(ctx);
1795 struct rpc_bdev_nvme_stop_discovery_ctx *ctx = cb_ctx;
1797 spdk_jsonrpc_send_bool_response(ctx->request, true);
1798 free(ctx->req.name);
1799 free(ctx);
1806 struct rpc_bdev_nvme_stop_discovery_ctx *ctx;
1809 ctx = calloc(1, sizeof(*ctx));
1810 if (!ctx) {
1817 &ctx->req)) {
1824 ctx->request = request;
1825 rc = bdev_nvme_stop_discovery(ctx->req.name, rpc_bdev_nvme_stop_discovery_done, ctx);
1834 free(ctx->req.name);
1835 free(ctx);
1911 struct rpc_add_error_injection_ctx *ctx = _ctx;
1914 spdk_jsonrpc_send_error_response(ctx->request, status,
1917 spdk_jsonrpc_send_bool_response(ctx->request, true);
1920 free_rpc_add_error_injection(&ctx->rpc);
1921 free(ctx);
1930 struct rpc_add_error_injection_ctx *ctx = _ctx;
1936 rc = spdk_nvme_qpair_add_cmd_error_injection(ctrlr, qpair, ctx->rpc.opc,
1937 ctx->rpc.do_not_submit, ctx->rpc.timeout_in_us, ctx->rpc.err_count,
1938 ctx->rpc.sct, ctx->rpc.sc);
1949 struct rpc_add_error_injection_ctx *ctx;
1953 ctx = calloc(1, sizeof(*ctx));
1954 if (!ctx) {
1958 ctx->rpc.err_count = 1;
1959 ctx->request = request;
1964 &ctx->rpc)) {
1970 nvme_ctrlr = nvme_ctrlr_get_by_name(ctx->rpc.name);
1977 if (ctx->rpc.cmd_type == NVME_IO_CMD) {
1980 ctx,
1985 rc = spdk_nvme_qpair_add_cmd_error_injection(nvme_ctrlr->ctrlr, NULL, ctx->rpc.opc,
1986 ctx->rpc.do_not_submit, ctx->rpc.timeout_in_us, ctx->rpc.err_count,
1987 ctx->rpc.sct, ctx->rpc.sc);
1992 spdk_jsonrpc_send_bool_response(ctx->request, true);
1997 free_rpc_add_error_injection(&ctx->rpc);
1998 free(ctx);
2029 struct rpc_remove_error_injection_ctx *ctx = _ctx;
2032 spdk_jsonrpc_send_error_response(ctx->request, status,
2035 spdk_jsonrpc_send_bool_response(ctx->request, true);
2038 free_rpc_remove_error_injection(&ctx->rpc);
2039 free(ctx);
2048 struct rpc_remove_error_injection_ctx *ctx = _ctx;
2053 spdk_nvme_qpair_remove_cmd_error_injection(ctrlr, qpair, ctx->rpc.opc);
2063 struct rpc_remove_error_injection_ctx *ctx;
2066 ctx = calloc(1, sizeof(*ctx));
2067 if (!ctx) {
2071 ctx->request = request;
2076 &ctx->rpc)) {
2082 nvme_ctrlr = nvme_ctrlr_get_by_name(ctx->rpc.name);
2089 if (ctx->rpc.cmd_type == NVME_IO_CMD) {
2092 ctx,
2096 spdk_nvme_qpair_remove_cmd_error_injection(nvme_ctrlr->ctrlr, NULL, ctx->rpc.opc);
2097 spdk_jsonrpc_send_bool_response(ctx->request, true);
2101 free_rpc_remove_error_injection(&ctx->rpc);
2102 free(ctx);
2130 struct rpc_get_io_paths_ctx *ctx = spdk_io_channel_iter_get_ctx(i);
2132 spdk_json_write_array_end(ctx->w);
2134 spdk_json_write_object_end(ctx->w);
2136 spdk_jsonrpc_end_result(ctx->request, ctx->w);
2138 free_rpc_get_io_paths(&ctx->req);
2139 free(ctx);
2147 struct rpc_get_io_paths_ctx *ctx = spdk_io_channel_iter_get_ctx(i);
2152 spdk_json_write_object_begin(ctx->w);
2154 spdk_json_write_named_string(ctx->w, "thread", spdk_thread_get_name(spdk_get_thread()));
2156 spdk_json_write_named_array_begin(ctx->w, "io_paths");
2162 if (ctx->req.name != NULL &&
2163 strcmp(ctx->req.name, nbdev->disk.name) != 0) {
2167 nvme_io_path_info_json(ctx->w, io_path);
2171 spdk_json_write_array_end(ctx->w);
2173 spdk_json_write_object_end(ctx->w);
2182 struct rpc_get_io_paths_ctx *ctx;
2184 ctx = calloc(1, sizeof(*ctx));
2185 if (ctx == NULL) {
2193 &ctx->req)) {
2197 free_rpc_get_io_paths(&ctx->req);
2198 free(ctx);
2202 ctx->request = request;
2203 ctx->w = spdk_jsonrpc_begin_result(request);
2205 spdk_json_write_object_begin(ctx->w);
2207 spdk_json_write_named_array_begin(ctx->w, "poll_groups");
2211 ctx,
2240 struct rpc_bdev_nvme_set_preferred_path_ctx *ctx = cb_arg;
2243 spdk_jsonrpc_send_bool_response(ctx->request, true);
2245 spdk_jsonrpc_send_error_response(ctx->request, rc, spdk_strerror(-rc));
2248 free_rpc_bdev_nvme_set_preferred_path(&ctx->req);
2249 free(ctx);
2256 struct rpc_bdev_nvme_set_preferred_path_ctx *ctx;
2258 ctx = calloc(1, sizeof(*ctx));
2259 if (ctx == NULL) {
2266 &ctx->req)) {
2273 ctx->request = request;
2275 bdev_nvme_set_preferred_path(ctx->req.name, ctx->req.cntlid,
2276 rpc_bdev_nvme_set_preferred_path_done, ctx);
2280 free_rpc_bdev_nvme_set_preferred_path(&ctx->req);
2281 free(ctx);
2348 struct rpc_set_multipath_policy_ctx *ctx = cb_arg;
2351 spdk_jsonrpc_send_bool_response(ctx->request, true);
2353 spdk_jsonrpc_send_error_response(ctx->request, rc, spdk_strerror(-rc));
2356 free_rpc_set_multipath_policy(&ctx->req);
2357 free(ctx);
2364 struct rpc_set_multipath_policy_ctx *ctx;
2366 ctx = calloc(1, sizeof(*ctx));
2367 if (ctx == NULL) {
2372 ctx->req.rr_min_io = UINT32_MAX;
2373 ctx->req.selector = UINT32_MAX;
2377 &ctx->req)) {
2384 ctx->request = request;
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,
2402 rpc_bdev_nvme_set_multipath_policy_done, ctx);
2406 free_rpc_set_multipath_policy(&ctx->req);
2407 free(ctx);
2443 struct rpc_bdev_nvme_start_mdns_discovery_ctx *ctx;
2446 ctx = calloc(1, sizeof(*ctx));
2447 if (!ctx) {
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);
2467 ctx->request = request;
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);
2478 free(ctx);
2500 struct rpc_bdev_nvme_stop_mdns_discovery_ctx *ctx;
2503 ctx = calloc(1, sizeof(*ctx));
2504 if (!ctx) {
2511 &ctx->req)) {
2518 ctx->request = request;
2519 rc = bdev_nvme_stop_mdns_discovery(ctx->req.name);
2525 spdk_jsonrpc_send_bool_response(ctx->request, true);
2528 free(ctx->req.name);
2529 free(ctx);
2572 dummy_bdev_event_cb(enum spdk_bdev_event_type type, struct spdk_bdev *bdev, void *ctx)
2582 struct rpc_bdev_nvme_path_stat_ctx *ctx = _ctx;
2587 assert(ctx->num_paths != 0);
2589 for (j = 0; j < ctx->num_paths; j++) {
2590 path_stat = &ctx->path_stat[j];
2606 struct rpc_bdev_nvme_path_stat_ctx *ctx = _ctx;
2611 assert(ctx->num_paths != 0);
2613 w = spdk_jsonrpc_begin_result(ctx->request);
2618 for (j = 0; j < ctx->num_paths; j++) {
2619 path_stat = &ctx->path_stat[j];
2635 spdk_jsonrpc_end_result(ctx->request, w);
2637 spdk_bdev_close(ctx->desc);
2638 free(ctx->path_stat);
2639 free(ctx);
2652 struct rpc_bdev_nvme_path_stat_ctx *ctx;
2685 ctx = calloc(1, sizeof(struct rpc_bdev_nvme_path_stat_ctx));
2686 if (ctx == NULL) {
2722 ctx->request = request;
2723 ctx->desc = desc;
2724 ctx->path_stat = path_stat;
2725 ctx->num_paths = num_paths;
2729 ctx,
2737 free(ctx);
2763 rpc_bdev_nvme_set_keys_done(void *ctx, int status)
2765 struct spdk_jsonrpc_request *request = ctx;