]>
Commit | Line | Data |
---|---|---|
11fdf7f2 TL |
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/rpc.h" | |
35 | #include "spdk/util.h" | |
36 | #include "spdk/string.h" | |
37 | #include "spdk/bdev_module.h" | |
38 | #include "spdk_internal/log.h" | |
39 | ||
40 | #include "bdev_null.h" | |
41 | ||
42 | struct rpc_construct_null { | |
43 | char *name; | |
44 | char *uuid; | |
45 | uint64_t num_blocks; | |
46 | uint32_t block_size; | |
47 | }; | |
48 | ||
49 | static void | |
50 | free_rpc_construct_null(struct rpc_construct_null *req) | |
51 | { | |
52 | free(req->name); | |
53 | free(req->uuid); | |
54 | } | |
55 | ||
56 | static const struct spdk_json_object_decoder rpc_construct_null_decoders[] = { | |
57 | {"name", offsetof(struct rpc_construct_null, name), spdk_json_decode_string}, | |
58 | {"uuid", offsetof(struct rpc_construct_null, uuid), spdk_json_decode_string, true}, | |
59 | {"num_blocks", offsetof(struct rpc_construct_null, num_blocks), spdk_json_decode_uint64}, | |
60 | {"block_size", offsetof(struct rpc_construct_null, block_size), spdk_json_decode_uint32}, | |
61 | }; | |
62 | ||
63 | static void | |
64 | spdk_rpc_construct_null_bdev(struct spdk_jsonrpc_request *request, | |
65 | const struct spdk_json_val *params) | |
66 | { | |
67 | struct rpc_construct_null req = {}; | |
68 | struct spdk_json_write_ctx *w; | |
69 | struct spdk_uuid *uuid = NULL; | |
70 | struct spdk_uuid decoded_uuid; | |
71 | struct spdk_bdev *bdev; | |
72 | ||
73 | if (spdk_json_decode_object(params, rpc_construct_null_decoders, | |
74 | SPDK_COUNTOF(rpc_construct_null_decoders), | |
75 | &req)) { | |
76 | SPDK_DEBUGLOG(SPDK_LOG_BDEV_NULL, "spdk_json_decode_object failed\n"); | |
77 | goto invalid; | |
78 | } | |
79 | ||
80 | if (req.uuid) { | |
81 | if (spdk_uuid_parse(&decoded_uuid, req.uuid)) { | |
82 | goto invalid; | |
83 | } | |
84 | uuid = &decoded_uuid; | |
85 | } | |
86 | ||
87 | bdev = create_null_bdev(req.name, uuid, req.num_blocks, req.block_size); | |
88 | if (bdev == NULL) { | |
89 | goto invalid; | |
90 | } | |
91 | ||
92 | w = spdk_jsonrpc_begin_result(request); | |
93 | if (w == NULL) { | |
94 | free_rpc_construct_null(&req); | |
95 | return; | |
96 | } | |
97 | ||
98 | spdk_json_write_string(w, bdev->name); | |
99 | spdk_jsonrpc_end_result(request, w); | |
100 | free_rpc_construct_null(&req); | |
101 | return; | |
102 | ||
103 | invalid: | |
104 | spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters"); | |
105 | free_rpc_construct_null(&req); | |
106 | } | |
107 | SPDK_RPC_REGISTER("construct_null_bdev", spdk_rpc_construct_null_bdev, SPDK_RPC_RUNTIME) | |
108 | ||
109 | struct rpc_delete_null { | |
110 | char *name; | |
111 | }; | |
112 | ||
113 | static void | |
114 | free_rpc_delete_null(struct rpc_delete_null *req) | |
115 | { | |
116 | free(req->name); | |
117 | } | |
118 | ||
119 | static const struct spdk_json_object_decoder rpc_delete_null_decoders[] = { | |
120 | {"name", offsetof(struct rpc_delete_null, name), spdk_json_decode_string}, | |
121 | }; | |
122 | ||
123 | static void | |
124 | _spdk_rpc_delete_null_bdev_cb(void *cb_arg, int bdeverrno) | |
125 | { | |
126 | struct spdk_jsonrpc_request *request = cb_arg; | |
127 | struct spdk_json_write_ctx *w; | |
128 | ||
129 | w = spdk_jsonrpc_begin_result(request); | |
130 | if (w == NULL) { | |
131 | return; | |
132 | } | |
133 | ||
134 | spdk_json_write_bool(w, bdeverrno == 0); | |
135 | spdk_jsonrpc_end_result(request, w); | |
136 | } | |
137 | ||
138 | static void | |
139 | spdk_rpc_delete_null_bdev(struct spdk_jsonrpc_request *request, | |
140 | const struct spdk_json_val *params) | |
141 | { | |
142 | struct rpc_delete_null req = {NULL}; | |
143 | struct spdk_bdev *bdev; | |
144 | int rc; | |
145 | ||
146 | if (spdk_json_decode_object(params, rpc_delete_null_decoders, | |
147 | SPDK_COUNTOF(rpc_delete_null_decoders), | |
148 | &req)) { | |
149 | rc = -EINVAL; | |
150 | goto invalid; | |
151 | } | |
152 | ||
153 | bdev = spdk_bdev_get_by_name(req.name); | |
154 | if (bdev == NULL) { | |
155 | rc = -ENODEV; | |
156 | goto invalid; | |
157 | } | |
158 | ||
159 | delete_null_bdev(bdev, _spdk_rpc_delete_null_bdev_cb, request); | |
160 | ||
161 | free_rpc_delete_null(&req); | |
162 | ||
163 | return; | |
164 | ||
165 | invalid: | |
166 | free_rpc_delete_null(&req); | |
167 | spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, spdk_strerror(-rc)); | |
168 | } | |
169 | SPDK_RPC_REGISTER("delete_null_bdev", spdk_rpc_delete_null_bdev, SPDK_RPC_RUNTIME) |