ceph/src/spdk/lib/bdev/error/vbdev_error_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 "spdk/stdinc.h"
  35 #include "spdk/string.h"
  36 #include "spdk/rpc.h"
  37 #include "spdk/util.h"
  38 #include "spdk/string.h"
  39 #include "spdk_internal/log.h"
  40 #include "vbdev_error.h"
  41
  42 #define ERROR_BDEV_IO_TYPE_INVALID (SPDK_BDEV_IO_TYPE_RESET + 1)
  43 #define ERROR_BDEV_ERROR_TYPE_INVALID (VBDEV_IO_PENDING + 1)
  44
  45 static uint32_t
  46 spdk_rpc_error_bdev_io_type_parse(char *name)
  47 {
  48         if (strcmp(name, "read") == 0) {
  49                 return SPDK_BDEV_IO_TYPE_READ;
  50         } else if (strcmp(name, "write") == 0) {
  51                 return SPDK_BDEV_IO_TYPE_WRITE;
  52         } else if (strcmp(name, "flush") == 0) {
  53                 return SPDK_BDEV_IO_TYPE_FLUSH;
  54         } else if (strcmp(name, "unmap") == 0) {
  55                 return SPDK_BDEV_IO_TYPE_UNMAP;
  56         } else if (strcmp(name, "all") == 0) {
  57                 return 0xffffffff;
  58         } else if (strcmp(name, "clear") == 0) {
  59                 return 0;
  60         }
  61         return ERROR_BDEV_IO_TYPE_INVALID;
  62 }
  63
  64 static uint32_t
  65 spdk_rpc_error_bdev_error_type_parse(char *name)
  66 {
  67         if (strcmp(name, "failure") == 0) {
  68                 return VBDEV_IO_FAILURE;
  69         } else if (strcmp(name, "pending") == 0) {
  70                 return VBDEV_IO_PENDING;
  71         }
  72         return ERROR_BDEV_ERROR_TYPE_INVALID;
  73 }
  74
  75 struct rpc_construct_error_bdev {
  76         char *base_name;
  77 };
  78
  79 static void
  80 free_rpc_construct_error_bdev(struct rpc_construct_error_bdev *req)
  81 {
  82         free(req->base_name);
  83 }
  84
  85 static const struct spdk_json_object_decoder rpc_construct_error_bdev_decoders[] = {
  86         {"base_name", offsetof(struct rpc_construct_error_bdev, base_name), spdk_json_decode_string},
  87 };
  88
  89 static void
  90 spdk_rpc_construct_error_bdev(struct spdk_jsonrpc_request *request,
  91                               const struct spdk_json_val *params)
  92 {
  93         struct rpc_construct_error_bdev req = {};
  94         struct spdk_json_write_ctx *w;
  95
  96         if (spdk_json_decode_object(params, rpc_construct_error_bdev_decoders,
  97                                     SPDK_COUNTOF(rpc_construct_error_bdev_decoders),
  98                                     &req)) {
  99                 SPDK_ERRLOG("spdk_json_decode_object failed\n");
 100                 goto invalid;
 101         }
 102
 103         if (spdk_vbdev_error_create(req.base_name)) {
 104                 SPDK_ERRLOG("Could not create ErrorInjection bdev %s\n", req.base_name);
 105                 goto invalid;
 106         }
 107
 108         w = spdk_jsonrpc_begin_result(request);
 109         if (w == NULL) {
 110                 free_rpc_construct_error_bdev(&req);
 111                 return;
 112         }
 113
 114         spdk_json_write_bool(w, true);
 115         spdk_jsonrpc_end_result(request, w);
 116
 117         free_rpc_construct_error_bdev(&req);
 118
 119         return;
 120
 121 invalid:
 122         spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters");
 123         free_rpc_construct_error_bdev(&req);
 124 }
 125 SPDK_RPC_REGISTER("construct_error_bdev", spdk_rpc_construct_error_bdev, SPDK_RPC_RUNTIME)
 126
 127 struct rpc_delete_error {
 128         char *name;
 129 };
 130
 131 static void
 132 free_rpc_delete_error(struct rpc_delete_error *r)
 133 {
 134         free(r->name);
 135 }
 136
 137 static const struct spdk_json_object_decoder rpc_delete_error_decoders[] = {
 138         {"name", offsetof(struct rpc_delete_error, name), spdk_json_decode_string},
 139 };
 140
 141 static void
 142 _spdk_rpc_delete_error_bdev_cb(void *cb_arg, int bdeverrno)
 143 {
 144         struct spdk_jsonrpc_request *request = cb_arg;
 145         struct spdk_json_write_ctx *w;
 146
 147         w = spdk_jsonrpc_begin_result(request);
 148         if (w == NULL) {
 149                 return;
 150         }
 151
 152         spdk_json_write_bool(w, bdeverrno == 0);
 153         spdk_jsonrpc_end_result(request, w);
 154 }
 155
 156 static void
 157 spdk_rpc_delete_error_bdev(struct spdk_jsonrpc_request *request,
 158                            const struct spdk_json_val *params)
 159 {
 160         struct rpc_delete_error req = {NULL};
 161         struct spdk_bdev *vbdev;
 162         int rc;
 163
 164         if (spdk_json_decode_object(params, rpc_delete_error_decoders,
 165                                     SPDK_COUNTOF(rpc_delete_error_decoders),
 166                                     &req)) {
 167                 rc = -EINVAL;
 168                 goto invalid;
 169         }
 170
 171         vbdev = spdk_bdev_get_by_name(req.name);
 172         if (vbdev == NULL) {
 173                 rc = -ENODEV;
 174                 goto invalid;
 175         }
 176
 177         spdk_vbdev_error_delete(vbdev, _spdk_rpc_delete_error_bdev_cb, request);
 178
 179         free_rpc_delete_error(&req);
 180
 181         return;
 182
 183 invalid:
 184         free_rpc_delete_error(&req);
 185         spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, spdk_strerror(-rc));
 186 }
 187 SPDK_RPC_REGISTER("delete_error_bdev", spdk_rpc_delete_error_bdev, SPDK_RPC_RUNTIME)
 188
 189 struct rpc_error_information {
 190         char *name;
 191         char *io_type;
 192         char *error_type;
 193         uint32_t num;
 194 };
 195
 196 static const struct spdk_json_object_decoder rpc_error_information_decoders[] = {
 197         {"name", offsetof(struct rpc_error_information, name), spdk_json_decode_string},
 198         {"io_type", offsetof(struct rpc_error_information, io_type), spdk_json_decode_string},
 199         {"error_type", offsetof(struct rpc_error_information, error_type), spdk_json_decode_string},
 200         {"num", offsetof(struct rpc_error_information, num), spdk_json_decode_uint32, true},
 201 };
 202
 203 static void
 204 free_rpc_error_information(struct rpc_error_information *p)
 205 {
 206         free(p->name);
 207         free(p->io_type);
 208         free(p->error_type);
 209 }
 210
 211 static void
 212 spdk_rpc_bdev_inject_error(struct spdk_jsonrpc_request *request,
 213                            const struct spdk_json_val *params)
 214 {
 215         struct rpc_error_information req = {};
 216         struct spdk_json_write_ctx *w;
 217         uint32_t io_type;
 218         uint32_t error_type;
 219         int ret;
 220
 221         if (spdk_json_decode_object(params, rpc_error_information_decoders,
 222                                     SPDK_COUNTOF(rpc_error_information_decoders),
 223                                     &req)) {
 224                 SPDK_ERRLOG("spdk_json_decode_object failed\n");
 225                 goto invalid;
 226         }
 227
 228         io_type = spdk_rpc_error_bdev_io_type_parse(req.io_type);
 229         if (io_type == ERROR_BDEV_IO_TYPE_INVALID) {
 230                 goto invalid;
 231         }
 232
 233         error_type = spdk_rpc_error_bdev_error_type_parse(req.error_type);
 234         if (error_type == ERROR_BDEV_ERROR_TYPE_INVALID) {
 235                 goto invalid;
 236         }
 237
 238         ret = spdk_vbdev_inject_error(req.name, io_type, error_type, req.num);
 239         if (ret) {
 240                 goto invalid;
 241         }
 242
 243         free_rpc_error_information(&req);
 244
 245         w = spdk_jsonrpc_begin_result(request);
 246         if (w == NULL) {
 247                 return;
 248         }
 249
 250         spdk_json_write_bool(w, true);
 251         spdk_jsonrpc_end_result(request, w);
 252         return;
 253
 254 invalid:
 255         spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters");
 256         free_rpc_error_information(&req);
 257 }
 258 SPDK_RPC_REGISTER("bdev_inject_error", spdk_rpc_bdev_inject_error, SPDK_RPC_RUNTIME)