LCOV - code coverage report
Current view: top level - module/bdev/nvme - bdev_nvme_cuse_rpc.c (source / functions) Hit Total Coverage
Test: ut_cov_unit.info Lines: 0 49 0.0 %
Date: 2024-07-15 13:59:48 Functions: 0 6 0.0 %

          Line data    Source code
       1             : /*   SPDX-License-Identifier: BSD-3-Clause
       2             :  *   Copyright (C) 2019 Intel Corporation.
       3             :  *   All rights reserved.
       4             :  */
       5             : 
       6             : #include "spdk/stdinc.h"
       7             : 
       8             : #include "bdev_nvme.h"
       9             : 
      10             : #include "spdk/string.h"
      11             : #include "spdk/rpc.h"
      12             : #include "spdk/util.h"
      13             : #include "spdk/nvme.h"
      14             : 
      15             : #include "spdk/log.h"
      16             : 
      17             : struct rpc_nvme_cuse_register {
      18             :         char *name;
      19             : };
      20             : 
      21             : static void
      22           0 : free_rpc_nvme_cuse_register(struct rpc_nvme_cuse_register *req)
      23             : {
      24           0 :         free(req->name);
      25           0 : }
      26             : 
      27             : static const struct spdk_json_object_decoder rpc_nvme_cuse_register_decoders[] = {
      28             :         {"name", offsetof(struct rpc_nvme_cuse_register, name), spdk_json_decode_string},
      29             : };
      30             : 
      31             : static void
      32           0 : rpc_nvme_cuse_register(struct spdk_jsonrpc_request *request,
      33             :                        const struct spdk_json_val *params)
      34             : {
      35           0 :         struct rpc_nvme_cuse_register req = {};
      36           0 :         struct nvme_ctrlr *bdev_ctrlr = NULL;
      37             :         int rc;
      38             : 
      39           0 :         if (spdk_json_decode_object(params, rpc_nvme_cuse_register_decoders,
      40             :                                     SPDK_COUNTOF(rpc_nvme_cuse_register_decoders),
      41             :                                     &req)) {
      42           0 :                 SPDK_ERRLOG("spdk_json_decode_object failed\n");
      43           0 :                 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
      44             :                                                  "spdk_json_decode_object failed");
      45           0 :                 goto cleanup;
      46             :         }
      47             : 
      48           0 :         bdev_ctrlr = nvme_ctrlr_get_by_name(req.name);
      49           0 :         if (!bdev_ctrlr) {
      50           0 :                 SPDK_ERRLOG("No such controller\n");
      51           0 :                 spdk_jsonrpc_send_error_response(request, -ENODEV, spdk_strerror(ENODEV));
      52           0 :                 goto cleanup;
      53             :         }
      54             : 
      55           0 :         rc = spdk_nvme_cuse_register(bdev_ctrlr->ctrlr);
      56           0 :         if (rc) {
      57           0 :                 SPDK_ERRLOG("Failed to register CUSE devices: %s\n", spdk_strerror(-rc));
      58           0 :                 spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc));
      59           0 :                 goto cleanup;
      60             :         }
      61             : 
      62           0 :         spdk_jsonrpc_send_bool_response(request, true);
      63             : 
      64           0 : cleanup:
      65           0 :         free_rpc_nvme_cuse_register(&req);
      66           0 : }
      67           0 : SPDK_RPC_REGISTER("bdev_nvme_cuse_register", rpc_nvme_cuse_register, SPDK_RPC_RUNTIME)
      68             : 
      69             : struct rpc_nvme_cuse_unregister {
      70             :         char *name;
      71             : };
      72             : 
      73             : static void
      74           0 : free_rpc_nvme_cuse_unregister(struct rpc_nvme_cuse_unregister *req)
      75             : {
      76           0 :         free(req->name);
      77           0 : }
      78             : 
      79             : static const struct spdk_json_object_decoder rpc_nvme_cuse_unregister_decoders[] = {
      80             :         {"name", offsetof(struct rpc_nvme_cuse_unregister, name), spdk_json_decode_string, true},
      81             : };
      82             : 
      83             : static void
      84           0 : rpc_nvme_cuse_unregister(struct spdk_jsonrpc_request *request,
      85             :                          const struct spdk_json_val *params)
      86             : {
      87           0 :         struct rpc_nvme_cuse_unregister req = {};
      88           0 :         struct nvme_ctrlr *bdev_ctrlr = NULL;
      89             :         int rc;
      90             : 
      91           0 :         if (spdk_json_decode_object(params, rpc_nvme_cuse_unregister_decoders,
      92             :                                     SPDK_COUNTOF(rpc_nvme_cuse_unregister_decoders),
      93             :                                     &req)) {
      94           0 :                 SPDK_ERRLOG("spdk_json_decode_object failed\n");
      95           0 :                 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
      96             :                                                  "spdk_json_decode_object failed");
      97           0 :                 goto cleanup;
      98             :         }
      99             : 
     100           0 :         bdev_ctrlr = nvme_ctrlr_get_by_name(req.name);
     101           0 :         if (!bdev_ctrlr) {
     102           0 :                 SPDK_ERRLOG("No such controller\n");
     103           0 :                 spdk_jsonrpc_send_error_response(request, -ENODEV, spdk_strerror(ENODEV));
     104           0 :                 goto cleanup;
     105             :         }
     106             : 
     107           0 :         rc = spdk_nvme_cuse_unregister(bdev_ctrlr->ctrlr);
     108           0 :         if (rc) {
     109           0 :                 spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc));
     110           0 :                 goto cleanup;
     111             :         }
     112             : 
     113           0 :         spdk_jsonrpc_send_bool_response(request, true);
     114             : 
     115           0 : cleanup:
     116           0 :         free_rpc_nvme_cuse_unregister(&req);
     117           0 : }
     118           0 : SPDK_RPC_REGISTER("bdev_nvme_cuse_unregister", rpc_nvme_cuse_unregister, SPDK_RPC_RUNTIME)

Generated by: LCOV version 1.15