ceph/src/spdk/lib/bdev/rbd/bdev_rbd_rpc.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright (c) Intel Corporation.
   5  *   All rights reserved.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following conditions
   9  *   are met:
  10  *
  11  *     * Redistributions of source code must retain the above copyright
  12  *       notice, this list of conditions and the following disclaimer.
  13  *     * Redistributions in binary form must reproduce the above copyright
  14  *       notice, this list of conditions and the following disclaimer in
  15  *       the documentation and/or other materials provided with the
  16  *       distribution.
  17  *     * Neither the name of Intel Corporation nor the names of its
  18  *       contributors may be used to endorse or promote products derived
  19  *       from this software without specific prior written permission.
  20  *
  21  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 #include "bdev_rbd.h"
  35 #include "spdk/rpc.h"
  36 #include "spdk/util.h"
  37 #include "spdk/string.h"
  38 #include "spdk_internal/log.h"
  39
  40 struct rpc_construct_rbd {
  41         char *name;
  42         char *pool_name;
  43         char *rbd_name;
  44         uint32_t block_size;
  45 };
  46
  47 static void
  48 free_rpc_construct_rbd(struct rpc_construct_rbd *req)
  49 {
  50         free(req->name);
  51         free(req->pool_name);
  52         free(req->rbd_name);
  53 }
  54
  55 static const struct spdk_json_object_decoder rpc_construct_rbd_decoders[] = {
  56         {"name", offsetof(struct rpc_construct_rbd, name), spdk_json_decode_string, true},
  57         {"pool_name", offsetof(struct rpc_construct_rbd, pool_name), spdk_json_decode_string},
  58         {"rbd_name", offsetof(struct rpc_construct_rbd, rbd_name), spdk_json_decode_string},
  59         {"block_size", offsetof(struct rpc_construct_rbd, block_size), spdk_json_decode_uint32},
  60 };
  61
  62 static void
  63 spdk_rpc_construct_rbd_bdev(struct spdk_jsonrpc_request *request,
  64                             const struct spdk_json_val *params)
  65 {
  66         struct rpc_construct_rbd req = {};
  67         struct spdk_json_write_ctx *w;
  68         struct spdk_bdev *bdev;
  69
  70         if (spdk_json_decode_object(params, rpc_construct_rbd_decoders,
  71                                     SPDK_COUNTOF(rpc_construct_rbd_decoders),
  72                                     &req)) {
  73                 SPDK_DEBUGLOG(SPDK_LOG_BDEV_RBD, "spdk_json_decode_object failed\n");
  74                 goto invalid;
  75         }
  76
  77         bdev = spdk_bdev_rbd_create(req.name, req.pool_name, req.rbd_name, req.block_size);
  78         if (bdev == NULL) {
  79                 goto invalid;
  80         }
  81
  82         free_rpc_construct_rbd(&req);
  83
  84         w = spdk_jsonrpc_begin_result(request);
  85         if (w == NULL) {
  86                 return;
  87         }
  88
  89         spdk_json_write_string(w, spdk_bdev_get_name(bdev));
  90         spdk_jsonrpc_end_result(request, w);
  91         return;
  92
  93 invalid:
  94         spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters");
  95         free_rpc_construct_rbd(&req);
  96 }
  97 SPDK_RPC_REGISTER("construct_rbd_bdev", spdk_rpc_construct_rbd_bdev, SPDK_RPC_RUNTIME)
  98
  99 struct rpc_delete_rbd {
 100         char *name;
 101 };
 102
 103 static void
 104 free_rpc_delete_rbd(struct rpc_delete_rbd *req)
 105 {
 106         free(req->name);
 107 }
 108
 109 static const struct spdk_json_object_decoder rpc_delete_rbd_decoders[] = {
 110         {"name", offsetof(struct rpc_delete_rbd, name), spdk_json_decode_string},
 111 };
 112
 113 static void
 114 _spdk_rpc_delete_rbd_bdev_cb(void *cb_arg, int bdeverrno)
 115 {
 116         struct spdk_jsonrpc_request *request = cb_arg;
 117         struct spdk_json_write_ctx *w;
 118
 119         w = spdk_jsonrpc_begin_result(request);
 120         if (w == NULL) {
 121                 return;
 122         }
 123
 124         spdk_json_write_bool(w, bdeverrno == 0);
 125         spdk_jsonrpc_end_result(request, w);
 126 }
 127
 128 static void
 129 spdk_rpc_delete_rbd_bdev(struct spdk_jsonrpc_request *request,
 130                          const struct spdk_json_val *params)
 131 {
 132         struct rpc_delete_rbd req = {NULL};
 133         struct spdk_bdev *bdev;
 134         int rc;
 135
 136         if (spdk_json_decode_object(params, rpc_delete_rbd_decoders,
 137                                     SPDK_COUNTOF(rpc_delete_rbd_decoders),
 138                                     &req)) {
 139                 rc = -EINVAL;
 140                 goto invalid;
 141         }
 142
 143         bdev = spdk_bdev_get_by_name(req.name);
 144         if (bdev == NULL) {
 145                 rc = -ENODEV;
 146                 goto invalid;
 147         }
 148
 149         spdk_bdev_rbd_delete(bdev, _spdk_rpc_delete_rbd_bdev_cb, request);
 150         free_rpc_delete_rbd(&req);
 151         return;
 152
 153 invalid:
 154         free_rpc_delete_rbd(&req);
 155         spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, spdk_strerror(-rc));
 156 }
 157 SPDK_RPC_REGISTER("delete_rbd_bdev", spdk_rpc_delete_rbd_bdev, SPDK_RPC_RUNTIME)