1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright (C) 2018 Intel Corporation. 3 * Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 * All rights reserved. 5 */ 6 7 #include "vbdev_compress.h" 8 #include "spdk/rpc.h" 9 #include "spdk/util.h" 10 #include "spdk/string.h" 11 #include "spdk/log.h" 12 13 struct rpc_bdev_compress_get_orphans { 14 char *name; 15 }; 16 17 static void 18 free_rpc_bdev_compress_get_orphans(struct rpc_bdev_compress_get_orphans *r) 19 { 20 free(r->name); 21 } 22 23 static const struct spdk_json_object_decoder rpc_bdev_compress_get_orphans_decoders[] = { 24 {"name", offsetof(struct rpc_bdev_compress_get_orphans, name), spdk_json_decode_string, true}, 25 }; 26 27 static void 28 rpc_bdev_compress_get_orphans(struct spdk_jsonrpc_request *request, 29 const struct spdk_json_val *params) 30 { 31 struct rpc_bdev_compress_get_orphans req = {}; 32 struct spdk_json_write_ctx *w; 33 struct vbdev_compress *comp_bdev; 34 bool found = false; 35 36 37 if (params && spdk_json_decode_object(params, rpc_bdev_compress_get_orphans_decoders, 38 SPDK_COUNTOF(rpc_bdev_compress_get_orphans_decoders), 39 &req)) { 40 SPDK_ERRLOG("spdk_json_decode_object failed\n"); 41 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 42 "spdk_json_decode_object failed"); 43 free_rpc_bdev_compress_get_orphans(&req); 44 return; 45 } 46 47 if (req.name) { 48 if (compress_has_orphan(req.name) == false) { 49 spdk_jsonrpc_send_error_response(request, -ENODEV, spdk_strerror(ENODEV)); 50 free_rpc_bdev_compress_get_orphans(&req); 51 return; 52 } 53 found = true; 54 } 55 56 w = spdk_jsonrpc_begin_result(request); 57 spdk_json_write_array_begin(w); 58 if (found) { 59 spdk_json_write_string(w, req.name); 60 } else { 61 for (comp_bdev = compress_bdev_first(); comp_bdev != NULL; 62 comp_bdev = compress_bdev_next(comp_bdev)) { 63 if (compress_has_orphan(compress_get_name(comp_bdev))) { 64 spdk_json_write_string(w, compress_get_name(comp_bdev)); 65 } 66 } 67 } 68 spdk_json_write_array_end(w); 69 spdk_jsonrpc_end_result(request, w); 70 free_rpc_bdev_compress_get_orphans(&req); 71 } 72 SPDK_RPC_REGISTER("bdev_compress_get_orphans", rpc_bdev_compress_get_orphans, SPDK_RPC_RUNTIME) 73 74 /* Structure to hold the parameters for this RPC method. */ 75 struct rpc_construct_compress { 76 char *base_bdev_name; 77 char *pm_path; 78 uint32_t lb_size; 79 }; 80 81 /* Free the allocated memory resource after the RPC handling. */ 82 static void 83 free_rpc_construct_compress(struct rpc_construct_compress *r) 84 { 85 free(r->base_bdev_name); 86 free(r->pm_path); 87 } 88 89 /* Structure to decode the input parameters for this RPC method. */ 90 static const struct spdk_json_object_decoder rpc_construct_compress_decoders[] = { 91 {"base_bdev_name", offsetof(struct rpc_construct_compress, base_bdev_name), spdk_json_decode_string}, 92 {"pm_path", offsetof(struct rpc_construct_compress, pm_path), spdk_json_decode_string}, 93 {"lb_size", offsetof(struct rpc_construct_compress, lb_size), spdk_json_decode_uint32, true}, 94 }; 95 96 /* Decode the parameters for this RPC method and properly construct the compress 97 * device. Error status returned in the failed cases. 98 */ 99 static void 100 rpc_bdev_compress_create(struct spdk_jsonrpc_request *request, 101 const struct spdk_json_val *params) 102 { 103 struct rpc_construct_compress req = {NULL}; 104 struct spdk_json_write_ctx *w; 105 char *name; 106 int rc; 107 108 if (spdk_json_decode_object(params, rpc_construct_compress_decoders, 109 SPDK_COUNTOF(rpc_construct_compress_decoders), 110 &req)) { 111 SPDK_DEBUGLOG(vbdev_compress, "spdk_json_decode_object failed\n"); 112 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_PARSE_ERROR, 113 "spdk_json_decode_object failed"); 114 goto cleanup; 115 } 116 117 rc = create_compress_bdev(req.base_bdev_name, req.pm_path, req.lb_size); 118 if (rc != 0) { 119 if (rc == -EBUSY) { 120 spdk_jsonrpc_send_error_response(request, rc, "Base bdev already in use for compression."); 121 } else { 122 spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc)); 123 } 124 goto cleanup; 125 } 126 127 w = spdk_jsonrpc_begin_result(request); 128 name = spdk_sprintf_alloc("COMP_%s", req.base_bdev_name); 129 spdk_json_write_string(w, name); 130 spdk_jsonrpc_end_result(request, w); 131 free(name); 132 133 cleanup: 134 free_rpc_construct_compress(&req); 135 } 136 SPDK_RPC_REGISTER("bdev_compress_create", rpc_bdev_compress_create, SPDK_RPC_RUNTIME) 137 138 struct rpc_delete_compress { 139 char *name; 140 }; 141 142 static void 143 free_rpc_delete_compress(struct rpc_delete_compress *req) 144 { 145 free(req->name); 146 } 147 148 static const struct spdk_json_object_decoder rpc_delete_compress_decoders[] = { 149 {"name", offsetof(struct rpc_delete_compress, name), spdk_json_decode_string}, 150 }; 151 152 static void 153 _rpc_bdev_compress_delete_cb(void *cb_arg, int bdeverrno) 154 { 155 struct spdk_jsonrpc_request *request = cb_arg; 156 157 if (bdeverrno == 0) { 158 spdk_jsonrpc_send_bool_response(request, true); 159 } else { 160 spdk_jsonrpc_send_error_response(request, bdeverrno, spdk_strerror(-bdeverrno)); 161 } 162 } 163 164 static void 165 rpc_bdev_compress_delete(struct spdk_jsonrpc_request *request, 166 const struct spdk_json_val *params) 167 { 168 struct rpc_delete_compress req = {NULL}; 169 170 if (spdk_json_decode_object(params, rpc_delete_compress_decoders, 171 SPDK_COUNTOF(rpc_delete_compress_decoders), 172 &req)) { 173 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, 174 "spdk_json_decode_object failed"); 175 } else { 176 bdev_compress_delete(req.name, _rpc_bdev_compress_delete_cb, request); 177 } 178 179 free_rpc_delete_compress(&req); 180 } 181 SPDK_RPC_REGISTER("bdev_compress_delete", rpc_bdev_compress_delete, SPDK_RPC_RUNTIME) 182