Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (C) 2018 Intel Corporation.
3 : : * All rights reserved.
4 : : */
5 : :
6 : : #include "vbdev_ocf.h"
7 : : #include "stats.h"
8 : : #include "utils.h"
9 : : #include "spdk/log.h"
10 : : #include "spdk/rpc.h"
11 : : #include "spdk/string.h"
12 : :
13 : : /* Common structure to hold the name parameter for RPC methods using bdev name only. */
14 : : struct rpc_bdev_ocf_name {
15 : : char *name; /* main vbdev name */
16 : : };
17 : :
18 : : /* Common free function for RPC methods using bdev name only. */
19 : : static void
20 : 30 : free_rpc_bdev_ocf_name(struct rpc_bdev_ocf_name *r)
21 : : {
22 : 30 : free(r->name);
23 : 30 : }
24 : :
25 : : /* Common function to decode the name input parameter for RPC methods using bdev name only. */
26 : : static const struct spdk_json_object_decoder rpc_bdev_ocf_name_decoders[] = {
27 : : {"name", offsetof(struct rpc_bdev_ocf_name, name), spdk_json_decode_string},
28 : : };
29 : :
30 : :
31 : : /* Structure to hold the parameters for this RPC method. */
32 : : struct rpc_bdev_ocf_create {
33 : : char *name; /* main vbdev */
34 : : char *mode; /* OCF mode (choose one) */
35 : : uint64_t cache_line_size; /* OCF cache line size */
36 : : char *cache_bdev_name; /* sub bdev */
37 : : char *core_bdev_name; /* sub bdev */
38 : : };
39 : :
40 : : static void
41 : 30 : free_rpc_bdev_ocf_create(struct rpc_bdev_ocf_create *r)
42 : : {
43 : 30 : free(r->name);
44 : 30 : free(r->core_bdev_name);
45 : 30 : free(r->cache_bdev_name);
46 : 30 : free(r->mode);
47 : 30 : }
48 : :
49 : : /* Structure to decode the input parameters for this RPC method. */
50 : : static const struct spdk_json_object_decoder rpc_bdev_ocf_create_decoders[] = {
51 : : {"name", offsetof(struct rpc_bdev_ocf_create, name), spdk_json_decode_string},
52 : : {"mode", offsetof(struct rpc_bdev_ocf_create, mode), spdk_json_decode_string},
53 : : {"cache_line_size", offsetof(struct rpc_bdev_ocf_create, cache_line_size), spdk_json_decode_uint64, true},
54 : : {"cache_bdev_name", offsetof(struct rpc_bdev_ocf_create, cache_bdev_name), spdk_json_decode_string},
55 : : {"core_bdev_name", offsetof(struct rpc_bdev_ocf_create, core_bdev_name), spdk_json_decode_string},
56 : : };
57 : :
58 : : static void
59 : 30 : construct_cb(int status, struct vbdev_ocf *vbdev, void *cb_arg)
60 : : {
61 : 30 : struct spdk_jsonrpc_request *request = cb_arg;
62 : : struct spdk_json_write_ctx *w;
63 : :
64 [ - + ]: 30 : if (status) {
65 : 0 : spdk_jsonrpc_send_error_response_fmt(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
66 : : "Could not create OCF vbdev: %d",
67 : : status);
68 : : } else {
69 : 30 : w = spdk_jsonrpc_begin_result(request);
70 : 30 : spdk_json_write_string(w, vbdev->name);
71 : 30 : spdk_jsonrpc_end_result(request, w);
72 : : }
73 : 30 : }
74 : :
75 : : static void
76 : 30 : rpc_bdev_ocf_create(struct spdk_jsonrpc_request *request,
77 : : const struct spdk_json_val *params)
78 : : {
79 : 30 : struct rpc_bdev_ocf_create req = {NULL};
80 : : int ret;
81 : :
82 : 30 : ret = spdk_json_decode_object(params, rpc_bdev_ocf_create_decoders,
83 : : SPDK_COUNTOF(rpc_bdev_ocf_create_decoders),
84 : : &req);
85 [ - + ]: 30 : if (ret) {
86 : 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
87 : : "Invalid parameters");
88 : 0 : free_rpc_bdev_ocf_create(&req);
89 : 0 : return;
90 : : }
91 : :
92 : 30 : vbdev_ocf_construct(req.name, req.mode, req.cache_line_size, req.cache_bdev_name,
93 : 30 : req.core_bdev_name, false, construct_cb, request);
94 : 30 : free_rpc_bdev_ocf_create(&req);
95 : : }
96 : 65 : SPDK_RPC_REGISTER("bdev_ocf_create", rpc_bdev_ocf_create, SPDK_RPC_RUNTIME)
97 : :
98 : : static void
99 : 9 : delete_cb(void *cb_arg, int status)
100 : : {
101 : 9 : struct spdk_jsonrpc_request *request = cb_arg;
102 : :
103 [ - + ]: 9 : if (status) {
104 : 0 : spdk_jsonrpc_send_error_response_fmt(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
105 : : "Could not delete OCF vbdev: %d",
106 : : status);
107 : : } else {
108 : 9 : spdk_jsonrpc_send_bool_response(request, true);
109 : : }
110 : 9 : }
111 : :
112 : : static void
113 : 9 : rpc_bdev_ocf_delete(struct spdk_jsonrpc_request *request,
114 : : const struct spdk_json_val *params)
115 : : {
116 : 9 : struct rpc_bdev_ocf_name req = {NULL};
117 : : struct vbdev_ocf *vbdev;
118 : : int status;
119 : :
120 : 9 : status = spdk_json_decode_object(params, rpc_bdev_ocf_name_decoders,
121 : : SPDK_COUNTOF(rpc_bdev_ocf_name_decoders),
122 : : &req);
123 [ - + ]: 9 : if (status) {
124 : 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
125 : : "Invalid parameters");
126 : 0 : goto end;
127 : : }
128 : :
129 : 9 : vbdev = vbdev_ocf_get_by_name(req.name);
130 [ - + ]: 9 : if (vbdev == NULL) {
131 : 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
132 : : spdk_strerror(ENODEV));
133 : 0 : goto end;
134 : : }
135 : :
136 : 9 : status = vbdev_ocf_delete_clean(vbdev, delete_cb, request);
137 [ + - ]: 9 : if (status) {
138 : 0 : spdk_jsonrpc_send_error_response_fmt(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
139 : : "Could not delete OCF vbdev: %s",
140 : : spdk_strerror(-status));
141 : 0 : goto end;
142 : : }
143 : :
144 : 9 : end:
145 : 9 : free_rpc_bdev_ocf_name(&req);
146 : 9 : }
147 : 65 : SPDK_RPC_REGISTER("bdev_ocf_delete", rpc_bdev_ocf_delete, SPDK_RPC_RUNTIME)
148 : :
149 : : struct get_ocf_stats_ctx {
150 : : struct spdk_jsonrpc_request *request;
151 : : char *core_name;
152 : : };
153 : :
154 : : static void
155 : 0 : rpc_bdev_ocf_get_stats_cmpl(ocf_cache_t cache, void *priv, int error)
156 : : {
157 : 0 : struct get_ocf_stats_ctx *ctx = (struct get_ocf_stats_ctx *) priv;
158 : : struct spdk_json_write_ctx *w;
159 : : struct vbdev_ocf_stats stats;
160 : :
161 [ # # ]: 0 : if (error) {
162 : 0 : goto end;
163 : : }
164 : :
165 : 0 : error = vbdev_ocf_stats_get(cache, ctx->core_name, &stats);
166 : :
167 : 0 : ocf_mngt_cache_read_unlock(cache);
168 : :
169 [ # # ]: 0 : if (error) {
170 : 0 : goto end;
171 : : }
172 : :
173 : 0 : w = spdk_jsonrpc_begin_result(ctx->request);
174 : 0 : vbdev_ocf_stats_write_json(w, &stats);
175 : 0 : spdk_jsonrpc_end_result(ctx->request, w);
176 : :
177 : 0 : end:
178 [ # # ]: 0 : if (error) {
179 : 0 : spdk_jsonrpc_send_error_response_fmt(ctx->request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
180 : : "Could not get stats: %s",
181 : : spdk_strerror(-error));
182 : : }
183 : 0 : free(ctx);
184 : 0 : }
185 : :
186 : : static void
187 : 0 : rpc_bdev_ocf_get_stats(struct spdk_jsonrpc_request *request,
188 : : const struct spdk_json_val *params)
189 : : {
190 : 0 : struct rpc_bdev_ocf_name req = {NULL};
191 : : struct vbdev_ocf *vbdev;
192 : : struct get_ocf_stats_ctx *ctx;
193 : :
194 : 0 : ctx = calloc(1, sizeof(*ctx));
195 [ # # ]: 0 : if (!ctx) {
196 : 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
197 : : "Not enough memory to process request");
198 : 0 : goto end;
199 : : }
200 : :
201 [ # # ]: 0 : if (spdk_json_decode_object(params, rpc_bdev_ocf_name_decoders,
202 : : SPDK_COUNTOF(rpc_bdev_ocf_name_decoders),
203 : : &req)) {
204 : 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
205 : : "Invalid parameters");
206 : 0 : free(ctx);
207 : 0 : goto end;
208 : : }
209 : :
210 : 0 : vbdev = vbdev_ocf_get_by_name(req.name);
211 [ # # ]: 0 : if (vbdev == NULL) {
212 : 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
213 : : spdk_strerror(ENODEV));
214 : 0 : free(ctx);
215 : 0 : goto end;
216 : : }
217 : :
218 : 0 : ctx->core_name = vbdev->core.name;
219 : 0 : ctx->request = request;
220 : 0 : ocf_mngt_cache_read_lock(vbdev->ocf_cache, rpc_bdev_ocf_get_stats_cmpl, ctx);
221 : :
222 : 0 : end:
223 : 0 : free_rpc_bdev_ocf_name(&req);
224 : 0 : }
225 : 65 : SPDK_RPC_REGISTER("bdev_ocf_get_stats", rpc_bdev_ocf_get_stats, SPDK_RPC_RUNTIME)
226 : :
227 : : static void
228 : 0 : rpc_bdev_ocf_reset_stats_cmpl(ocf_cache_t cache, void *priv, int error)
229 : : {
230 : 0 : struct get_ocf_stats_ctx *ctx = (struct get_ocf_stats_ctx *) priv;
231 : :
232 [ # # ]: 0 : if (error) {
233 : 0 : goto end;
234 : : }
235 : :
236 : 0 : error = vbdev_ocf_stats_reset(cache, ctx->core_name);
237 : :
238 : 0 : ocf_mngt_cache_read_unlock(cache);
239 : :
240 : 0 : end:
241 [ # # ]: 0 : if (error) {
242 : 0 : spdk_jsonrpc_send_error_response_fmt(ctx->request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
243 : : "Could not reset stats: %s",
244 : : spdk_strerror(-error));
245 : : } else {
246 : 0 : spdk_jsonrpc_send_bool_response(ctx->request, true);
247 : : }
248 : 0 : free(ctx);
249 : 0 : }
250 : :
251 : : static void
252 : 0 : rpc_bdev_ocf_reset_stats(struct spdk_jsonrpc_request *request,
253 : : const struct spdk_json_val *params)
254 : : {
255 : 0 : struct rpc_bdev_ocf_name req = {NULL};
256 : : struct vbdev_ocf *vbdev;
257 : : struct get_ocf_stats_ctx *ctx;
258 : :
259 : 0 : ctx = calloc(1, sizeof(*ctx));
260 [ # # ]: 0 : if (!ctx) {
261 : 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
262 : : "Not enough memory to process request");
263 : 0 : goto end;
264 : : }
265 : :
266 [ # # ]: 0 : if (spdk_json_decode_object(params, rpc_bdev_ocf_name_decoders,
267 : : SPDK_COUNTOF(rpc_bdev_ocf_name_decoders),
268 : : &req)) {
269 : 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
270 : : "Invalid parameters");
271 : 0 : free(ctx);
272 : 0 : goto end;
273 : : }
274 : :
275 : 0 : vbdev = vbdev_ocf_get_by_name(req.name);
276 [ # # ]: 0 : if (vbdev == NULL) {
277 : 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
278 : : spdk_strerror(ENODEV));
279 : 0 : free(ctx);
280 : 0 : goto end;
281 : : }
282 : :
283 : 0 : ctx->core_name = vbdev->core.name;
284 : 0 : ctx->request = request;
285 : 0 : ocf_mngt_cache_read_lock(vbdev->ocf_cache, rpc_bdev_ocf_reset_stats_cmpl, ctx);
286 : :
287 : 0 : end:
288 : 0 : free_rpc_bdev_ocf_name(&req);
289 : 0 : }
290 : 65 : SPDK_RPC_REGISTER("bdev_ocf_reset_stats", rpc_bdev_ocf_reset_stats, SPDK_RPC_RUNTIME)
291 : :
292 : : /* Structure to decode the input parameters for this RPC method. */
293 : : static const struct spdk_json_object_decoder rpc_bdev_ocf_get_bdevs_decoders[] = {
294 : : {"name", offsetof(struct rpc_bdev_ocf_name, name), spdk_json_decode_string, true},
295 : : };
296 : :
297 : : struct bdev_get_bdevs_ctx {
298 : : char *name;
299 : : struct spdk_json_write_ctx *w;
300 : : };
301 : :
302 : : static void
303 : 19 : bdev_get_bdevs_fn(struct vbdev_ocf *vbdev, void *ctx)
304 : : {
305 : 19 : struct bdev_get_bdevs_ctx *cctx = ctx;
306 : 19 : struct spdk_json_write_ctx *w = cctx->w;
307 : :
308 [ + + ]: 19 : if (cctx->name != NULL &&
309 [ - + - + : 8 : strcmp(vbdev->name, cctx->name) &&
+ + ]
310 [ - + - + : 4 : strcmp(vbdev->cache.name, cctx->name) &&
+ + ]
311 [ - + - + : 2 : strcmp(vbdev->core.name, cctx->name)) {
+ + ]
312 : 1 : return;
313 : : }
314 : :
315 : 18 : spdk_json_write_object_begin(w);
316 : 18 : spdk_json_write_named_string(w, "name", vbdev->name);
317 [ - + ]: 18 : spdk_json_write_named_bool(w, "started", vbdev->state.started);
318 : :
319 : 18 : spdk_json_write_named_object_begin(w, "cache");
320 : 18 : spdk_json_write_named_string(w, "name", vbdev->cache.name);
321 [ - + ]: 18 : spdk_json_write_named_bool(w, "attached", vbdev->cache.attached);
322 : 18 : spdk_json_write_object_end(w);
323 : :
324 : 18 : spdk_json_write_named_object_begin(w, "core");
325 : 18 : spdk_json_write_named_string(w, "name", vbdev->core.name);
326 [ - + ]: 18 : spdk_json_write_named_bool(w, "attached", vbdev->core.attached);
327 : 18 : spdk_json_write_object_end(w);
328 : :
329 : 18 : spdk_json_write_object_end(w);
330 : : }
331 : :
332 : : static void
333 : 18 : rpc_bdev_ocf_get_bdevs(struct spdk_jsonrpc_request *request,
334 : : const struct spdk_json_val *params)
335 : : {
336 : : struct spdk_json_write_ctx *w;
337 : 18 : struct rpc_bdev_ocf_name req = {NULL};
338 : : struct bdev_get_bdevs_ctx cctx;
339 : :
340 [ + + - + ]: 18 : if (params && spdk_json_decode_object(params, rpc_bdev_ocf_get_bdevs_decoders,
341 : : SPDK_COUNTOF(rpc_bdev_ocf_get_bdevs_decoders),
342 : : &req)) {
343 : 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
344 : : "Invalid parameters");
345 : 0 : goto end;
346 : : }
347 : :
348 [ + + ]: 18 : if (req.name) {
349 [ + + - + ]: 6 : if (!(vbdev_ocf_get_by_name(req.name) || vbdev_ocf_get_base_by_name(req.name))) {
350 : 0 : spdk_jsonrpc_send_error_response(request,
351 : : SPDK_JSONRPC_ERROR_INVALID_PARAMS,
352 : : spdk_strerror(ENODEV));
353 : 0 : goto end;
354 : : }
355 : : }
356 : :
357 : 18 : w = spdk_jsonrpc_begin_result(request);
358 : :
359 : 18 : cctx.name = req.name;
360 : 18 : cctx.w = w;
361 : :
362 : 18 : spdk_json_write_array_begin(w);
363 : 18 : vbdev_ocf_foreach(bdev_get_bdevs_fn, &cctx);
364 : 18 : spdk_json_write_array_end(w);
365 : 18 : spdk_jsonrpc_end_result(request, w);
366 : :
367 : 18 : end:
368 : 18 : free_rpc_bdev_ocf_name(&req);
369 : 18 : }
370 : 65 : SPDK_RPC_REGISTER("bdev_ocf_get_bdevs", rpc_bdev_ocf_get_bdevs, SPDK_RPC_RUNTIME)
371 : :
372 : : /* Structure to hold the parameters for this RPC method. */
373 : : struct rpc_bdev_ocf_set_cache_mode {
374 : : char *name; /* main vbdev name */
375 : : char *mode; /* OCF cache mode to switch to */
376 : : };
377 : :
378 : : static void
379 : 6 : free_rpc_bdev_ocf_set_cache_mode(struct rpc_bdev_ocf_set_cache_mode *r)
380 : : {
381 : 6 : free(r->name);
382 : 6 : free(r->mode);
383 : 6 : }
384 : :
385 : : /* Structure to decode the input parameters for this RPC method. */
386 : : static const struct spdk_json_object_decoder rpc_bdev_ocf_set_cache_mode_decoders[] = {
387 : : {"name", offsetof(struct rpc_bdev_ocf_set_cache_mode, name), spdk_json_decode_string},
388 : : {"mode", offsetof(struct rpc_bdev_ocf_set_cache_mode, mode), spdk_json_decode_string},
389 : : };
390 : :
391 : : static void
392 : 6 : cache_mode_cb(int status, struct vbdev_ocf *vbdev, void *cb_arg)
393 : : {
394 : 6 : struct spdk_jsonrpc_request *request = cb_arg;
395 : : struct spdk_json_write_ctx *w;
396 : :
397 [ - + ]: 6 : if (status) {
398 : 0 : spdk_jsonrpc_send_error_response_fmt(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
399 : : "Could not change OCF vbdev cache mode: %d",
400 : : status);
401 : : } else {
402 : 6 : w = spdk_jsonrpc_begin_result(request);
403 : 6 : spdk_json_write_string(w, ocf_get_cache_modename(
404 : : ocf_cache_get_mode(vbdev->ocf_cache)));
405 : 6 : spdk_jsonrpc_end_result(request, w);
406 : : }
407 : 6 : }
408 : :
409 : : static void
410 : 6 : rpc_bdev_ocf_set_cache_mode(struct spdk_jsonrpc_request *request,
411 : : const struct spdk_json_val *params)
412 : : {
413 : 6 : struct rpc_bdev_ocf_set_cache_mode req = {NULL};
414 : : struct vbdev_ocf *vbdev;
415 : : int status;
416 : :
417 : 6 : status = spdk_json_decode_object(params, rpc_bdev_ocf_set_cache_mode_decoders,
418 : : SPDK_COUNTOF(rpc_bdev_ocf_set_cache_mode_decoders),
419 : : &req);
420 [ - + ]: 6 : if (status) {
421 : 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
422 : : "Invalid parameters");
423 : 0 : goto end;
424 : : }
425 : :
426 : 6 : vbdev = vbdev_ocf_get_by_name(req.name);
427 [ - + ]: 6 : if (vbdev == NULL) {
428 : 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
429 : : spdk_strerror(ENODEV));
430 : 0 : goto end;
431 : : }
432 : :
433 : 6 : vbdev_ocf_set_cache_mode(vbdev, req.mode, cache_mode_cb, request);
434 : :
435 : 6 : end:
436 : 6 : free_rpc_bdev_ocf_set_cache_mode(&req);
437 : 6 : }
438 : 65 : SPDK_RPC_REGISTER("bdev_ocf_set_cache_mode", rpc_bdev_ocf_set_cache_mode, SPDK_RPC_RUNTIME)
439 : :
440 : : static void
441 : 2 : seqcutoff_cb(int status, void *cb_arg)
442 : : {
443 : 2 : struct spdk_jsonrpc_request *request = cb_arg;
444 : :
445 [ - + ]: 2 : if (status) {
446 : 0 : spdk_jsonrpc_send_error_response_fmt(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
447 : : "OCF could not set sequential cutoff parameters: %d", status);
448 : : } else {
449 : 2 : spdk_jsonrpc_send_bool_response(request, true);
450 : : }
451 : 2 : }
452 : :
453 : : /* Structure to hold the parameters for this RPC method. */
454 : : struct rpc_bdev_ocf_set_seqcutoff {
455 : : char *name; /* main vbdev name */
456 : : char *policy;
457 : : uint32_t threshold;
458 : : uint32_t promotion_count;
459 : : };
460 : :
461 : : static void
462 : 2 : free_rpc_bdev_ocf_set_seqcutoff(struct rpc_bdev_ocf_set_seqcutoff *r)
463 : : {
464 : 2 : free(r->name);
465 : 2 : free(r->policy);
466 : 2 : }
467 : :
468 : : /* Structure to decode the input parameters for this RPC method. */
469 : : static const struct spdk_json_object_decoder rpc_bdev_ocf_set_seqcutoff_decoders[] = {
470 : : {"name", offsetof(struct rpc_bdev_ocf_set_seqcutoff, name), spdk_json_decode_string},
471 : : {"policy", offsetof(struct rpc_bdev_ocf_set_seqcutoff, policy), spdk_json_decode_string},
472 : : {"threshold", offsetof(struct rpc_bdev_ocf_set_seqcutoff, threshold), spdk_json_decode_uint32, true},
473 : : {"promotion_count", offsetof(struct rpc_bdev_ocf_set_seqcutoff, promotion_count), spdk_json_decode_uint32, true},
474 : : };
475 : :
476 : : static void
477 : 2 : rpc_bdev_ocf_set_seqcutoff(struct spdk_jsonrpc_request *request,
478 : : const struct spdk_json_val *params)
479 : : {
480 : 2 : struct rpc_bdev_ocf_set_seqcutoff req = {NULL};
481 : : struct vbdev_ocf *vbdev;
482 : : int ret;
483 : :
484 : 2 : ret = spdk_json_decode_object(params, rpc_bdev_ocf_set_seqcutoff_decoders,
485 : : SPDK_COUNTOF(rpc_bdev_ocf_set_seqcutoff_decoders), &req);
486 [ - + ]: 2 : if (ret) {
487 : 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
488 : : "Invalid parameters");
489 : 0 : goto end;
490 : : }
491 : :
492 : 2 : vbdev = vbdev_ocf_get_by_name(req.name);
493 [ - + ]: 2 : if (vbdev == NULL) {
494 : 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
495 : : spdk_strerror(ENODEV));
496 : 0 : goto end;
497 : : }
498 : :
499 : 2 : vbdev_ocf_set_seqcutoff(vbdev, req.policy, req.threshold, req.promotion_count, seqcutoff_cb,
500 : : request);
501 : :
502 : 2 : end:
503 : 2 : free_rpc_bdev_ocf_set_seqcutoff(&req);
504 : 2 : }
505 : 65 : SPDK_RPC_REGISTER("bdev_ocf_set_seqcutoff", rpc_bdev_ocf_set_seqcutoff, SPDK_RPC_RUNTIME)
506 : :
507 : : struct get_ocf_flush_start_ctx {
508 : : struct spdk_jsonrpc_request *request;
509 : : struct vbdev_ocf *vbdev;
510 : : };
511 : :
512 : : static void
513 : 1 : rpc_bdev_ocf_flush_start_cmpl(ocf_cache_t cache, void *priv, int error)
514 : : {
515 : 1 : struct get_ocf_flush_start_ctx *ctx = priv;
516 : :
517 : 1 : ctx->vbdev->flush.in_progress = false;
518 : 1 : ctx->vbdev->flush.status = error;
519 : :
520 : 1 : ocf_mngt_cache_read_unlock(cache);
521 : :
522 : 1 : free(ctx);
523 : 1 : }
524 : :
525 : : static void
526 : 1 : rpc_bdev_ocf_flush_start_lock_cmpl(ocf_cache_t cache, void *priv, int error)
527 : : {
528 : 1 : struct get_ocf_flush_start_ctx *ctx = priv;
529 : :
530 [ - + ]: 1 : if (error) {
531 : 0 : spdk_jsonrpc_send_error_response_fmt(ctx->request,
532 : : SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
533 : : "Could not lock cache: %d", error);
534 : 0 : free(ctx);
535 : 0 : return;
536 : : }
537 : :
538 : 1 : ctx->vbdev->flush.in_progress = true;
539 : 1 : ocf_mngt_cache_flush(cache, rpc_bdev_ocf_flush_start_cmpl, ctx);
540 : :
541 : 1 : spdk_jsonrpc_send_bool_response(ctx->request, true);
542 : : }
543 : :
544 : : static void
545 : 1 : rpc_bdev_ocf_flush_start(struct spdk_jsonrpc_request *request,
546 : : const struct spdk_json_val *params)
547 : : {
548 : 1 : struct rpc_bdev_ocf_name req = {NULL};
549 : : struct get_ocf_flush_start_ctx *ctx;
550 : : int status;
551 : :
552 : 1 : ctx = calloc(1, sizeof(*ctx));
553 [ - + ]: 1 : if (!ctx) {
554 : 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
555 : : "Not enough memory to process request");
556 : 0 : goto end;
557 : : }
558 : :
559 : 1 : status = spdk_json_decode_object(params, rpc_bdev_ocf_name_decoders,
560 : : SPDK_COUNTOF(rpc_bdev_ocf_name_decoders),
561 : : &req);
562 [ - + ]: 1 : if (status) {
563 : 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
564 : : "Invalid parameters");
565 : 0 : free(ctx);
566 : 0 : goto end;
567 : : }
568 : :
569 : 1 : ctx->vbdev = vbdev_ocf_get_by_name(req.name);
570 [ - + ]: 1 : if (ctx->vbdev == NULL) {
571 : 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
572 : : spdk_strerror(ENODEV));
573 : 0 : free(ctx);
574 : 0 : goto end;
575 : : }
576 : :
577 [ - + ]: 1 : if (!ctx->vbdev->ocf_cache) {
578 : 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
579 : : "Couldn't flush cache: device not attached");
580 : 0 : free(ctx);
581 : 0 : goto end;
582 : : }
583 : :
584 : 1 : ctx->request = request;
585 : 1 : ocf_mngt_cache_read_lock(ctx->vbdev->ocf_cache, rpc_bdev_ocf_flush_start_lock_cmpl, ctx);
586 : :
587 : 1 : end:
588 : 1 : free_rpc_bdev_ocf_name(&req);
589 : 1 : }
590 : 65 : SPDK_RPC_REGISTER("bdev_ocf_flush_start", rpc_bdev_ocf_flush_start, SPDK_RPC_RUNTIME)
591 : :
592 : : static void
593 : 2 : rpc_bdev_ocf_flush_status(struct spdk_jsonrpc_request *request,
594 : : const struct spdk_json_val *params)
595 : : {
596 : 2 : struct rpc_bdev_ocf_name req = {NULL};
597 : : struct spdk_json_write_ctx *w;
598 : : struct vbdev_ocf *vbdev;
599 : : int status;
600 : :
601 : 2 : status = spdk_json_decode_object(params, rpc_bdev_ocf_name_decoders,
602 : : SPDK_COUNTOF(rpc_bdev_ocf_name_decoders),
603 : : &req);
604 [ - + ]: 2 : if (status) {
605 : 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
606 : : "Invalid parameters");
607 : 0 : goto end;
608 : : }
609 : :
610 : 2 : vbdev = vbdev_ocf_get_by_name(req.name);
611 [ - + ]: 2 : if (vbdev == NULL) {
612 : 0 : spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
613 : : spdk_strerror(ENODEV));
614 : 0 : goto end;
615 : : }
616 : :
617 : 2 : w = spdk_jsonrpc_begin_result(request);
618 : :
619 : 2 : spdk_json_write_object_begin(w);
620 [ - + ]: 2 : spdk_json_write_named_bool(w, "in_progress", vbdev->flush.in_progress);
621 [ - + + - ]: 2 : if (!vbdev->flush.in_progress) {
622 : 2 : spdk_json_write_named_int32(w, "status", vbdev->flush.status);
623 : : }
624 : 2 : spdk_json_write_object_end(w);
625 : :
626 : 2 : spdk_jsonrpc_end_result(request, w);
627 : :
628 : 2 : end:
629 : 2 : free_rpc_bdev_ocf_name(&req);
630 : 2 : }
631 : 65 : SPDK_RPC_REGISTER("bdev_ocf_flush_status", rpc_bdev_ocf_flush_status, SPDK_RPC_RUNTIME)
|