1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright (C) 2019 Intel Corporation. 3 * All rights reserved. 4 */ 5 6 #include "vbdev_delay.h" 7 #include "spdk/rpc.h" 8 #include "spdk/util.h" 9 #include "spdk/string.h" 10 #include "spdk/log.h" 11 #include "spdk_internal/assert.h" 12 13 struct rpc_update_latency { 14 char *delay_bdev_name; 15 char *latency_type; 16 uint64_t latency_us; 17 }; 18 19 static const struct spdk_json_object_decoder rpc_update_latency_decoders[] = { 20 {"delay_bdev_name", offsetof(struct rpc_update_latency, delay_bdev_name), spdk_json_decode_string}, 21 {"latency_type", offsetof(struct rpc_update_latency, latency_type), spdk_json_decode_string}, 22 {"latency_us", offsetof(struct rpc_update_latency, latency_us), spdk_json_decode_uint64} 23 }; 24 25 static void 26 free_rpc_update_latency(struct rpc_update_latency *req) 27 { 28 free(req->delay_bdev_name); 29 free(req->latency_type); 30 } 31 32 static void 33 rpc_bdev_delay_update_latency(struct spdk_jsonrpc_request *request, 34 const struct spdk_json_val *params) 35 { 36 struct rpc_update_latency req = {NULL}; 37 enum delay_io_type latency_type; 38 int rc = 0; 39 40 if (spdk_json_decode_object(params, rpc_update_latency_decoders, 41 SPDK_COUNTOF(rpc_update_latency_decoders), 42 &req)) { 43 SPDK_DEBUGLOG(vbdev_delay, "spdk_json_decode_object failed\n"); 44 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 45 "spdk_json_decode_object failed"); 46 goto cleanup; 47 } 48 49 if (!strncmp(req.latency_type, "avg_read", 9)) { 50 latency_type = DELAY_AVG_READ; 51 } else if (!strncmp(req.latency_type, "p99_read", 9)) { 52 latency_type = DELAY_P99_READ; 53 } else if (!strncmp(req.latency_type, "avg_write", 10)) { 54 latency_type = DELAY_AVG_WRITE; 55 } else if (!strncmp(req.latency_type, "p99_write", 10)) { 56 latency_type = DELAY_P99_WRITE; 57 } else { 58 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 59 "Please specify a valid latency type."); 60 goto cleanup; 61 } 62 63 rc = vbdev_delay_update_latency_value(req.delay_bdev_name, req.latency_us, latency_type); 64 65 if (rc == -ENODEV) { 66 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, 67 "The requested bdev does not exist."); 68 goto cleanup; 69 } else if (rc == -EINVAL) { 70 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_REQUEST, 71 "The requested bdev is not a delay bdev."); 72 goto cleanup; 73 } else if (rc) { 74 SPDK_UNREACHABLE(); 75 } 76 77 spdk_jsonrpc_send_bool_response(request, true); 78 79 cleanup: 80 free_rpc_update_latency(&req); 81 } 82 SPDK_RPC_REGISTER("bdev_delay_update_latency", rpc_bdev_delay_update_latency, SPDK_RPC_RUNTIME) 83 84 struct rpc_construct_delay { 85 char *base_bdev_name; 86 char *name; 87 char *uuid; 88 uint64_t avg_read_latency; 89 uint64_t p99_read_latency; 90 uint64_t avg_write_latency; 91 uint64_t p99_write_latency; 92 }; 93 94 static void 95 free_rpc_construct_delay(struct rpc_construct_delay *r) 96 { 97 free(r->base_bdev_name); 98 free(r->name); 99 free(r->uuid); 100 } 101 102 static const struct spdk_json_object_decoder rpc_construct_delay_decoders[] = { 103 {"base_bdev_name", offsetof(struct rpc_construct_delay, base_bdev_name), spdk_json_decode_string}, 104 {"name", offsetof(struct rpc_construct_delay, name), spdk_json_decode_string}, 105 {"uuid", offsetof(struct rpc_construct_delay, uuid), spdk_json_decode_string, true}, 106 {"avg_read_latency", offsetof(struct rpc_construct_delay, avg_read_latency), spdk_json_decode_uint64}, 107 {"p99_read_latency", offsetof(struct rpc_construct_delay, p99_read_latency), spdk_json_decode_uint64}, 108 {"avg_write_latency", offsetof(struct rpc_construct_delay, avg_write_latency), spdk_json_decode_uint64}, 109 {"p99_write_latency", offsetof(struct rpc_construct_delay, p99_write_latency), spdk_json_decode_uint64}, 110 }; 111 112 static void 113 rpc_bdev_delay_create(struct spdk_jsonrpc_request *request, 114 const struct spdk_json_val *params) 115 { 116 struct rpc_construct_delay req = {NULL}; 117 struct spdk_json_write_ctx *w; 118 struct spdk_uuid *uuid = NULL; 119 struct spdk_uuid decoded_uuid; 120 int rc; 121 122 if (spdk_json_decode_object(params, rpc_construct_delay_decoders, 123 SPDK_COUNTOF(rpc_construct_delay_decoders), 124 &req)) { 125 SPDK_DEBUGLOG(vbdev_delay, "spdk_json_decode_object failed\n"); 126 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 127 "spdk_json_decode_object failed"); 128 goto cleanup; 129 } 130 131 if (req.uuid) { 132 if (spdk_uuid_parse(&decoded_uuid, req.uuid)) { 133 spdk_jsonrpc_send_error_response(request, -EINVAL, 134 "Failed to parse bdev UUID"); 135 goto cleanup; 136 } 137 uuid = &decoded_uuid; 138 } 139 140 rc = create_delay_disk(req.base_bdev_name, req.name, uuid, req.avg_read_latency, 141 req.p99_read_latency, 142 req.avg_write_latency, req.p99_write_latency); 143 if (rc != 0) { 144 spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc)); 145 goto cleanup; 146 } 147 148 w = spdk_jsonrpc_begin_result(request); 149 spdk_json_write_string(w, req.name); 150 spdk_jsonrpc_end_result(request, w); 151 152 cleanup: 153 free_rpc_construct_delay(&req); 154 } 155 SPDK_RPC_REGISTER("bdev_delay_create", rpc_bdev_delay_create, SPDK_RPC_RUNTIME) 156 157 struct rpc_delete_delay { 158 char *name; 159 }; 160 161 static void 162 free_rpc_delete_delay(struct rpc_delete_delay *req) 163 { 164 free(req->name); 165 } 166 167 static const struct spdk_json_object_decoder rpc_delete_delay_decoders[] = { 168 {"name", offsetof(struct rpc_delete_delay, name), spdk_json_decode_string}, 169 }; 170 171 static void 172 rpc_bdev_delay_delete_cb(void *cb_arg, int bdeverrno) 173 { 174 struct spdk_jsonrpc_request *request = cb_arg; 175 176 if (bdeverrno == 0) { 177 spdk_jsonrpc_send_bool_response(request, true); 178 } else { 179 spdk_jsonrpc_send_error_response(request, bdeverrno, spdk_strerror(-bdeverrno)); 180 } 181 } 182 183 static void 184 rpc_bdev_delay_delete(struct spdk_jsonrpc_request *request, 185 const struct spdk_json_val *params) 186 { 187 struct rpc_delete_delay req = {NULL}; 188 189 if (spdk_json_decode_object(params, rpc_delete_delay_decoders, 190 SPDK_COUNTOF(rpc_delete_delay_decoders), 191 &req)) { 192 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 193 "spdk_json_decode_object failed"); 194 goto cleanup; 195 } 196 197 delete_delay_disk(req.name, rpc_bdev_delay_delete_cb, request); 198 199 cleanup: 200 free_rpc_delete_delay(&req); 201 } 202 SPDK_RPC_REGISTER("bdev_delay_delete", rpc_bdev_delay_delete, SPDK_RPC_RUNTIME) 203