]>
Commit | Line | Data |
---|---|---|
75818250 | 1 | /* |
3736cc5b | 2 | * Copyright (C) 2016-2017 Red Hat, Inc. |
7a5ca864 FB |
3 | * Copyright (C) 2005 Anthony Liguori <anthony@codemonkey.ws> |
4 | * | |
798bfe00 | 5 | * Network Block Device Server Side |
7a5ca864 FB |
6 | * |
7 | * This program is free software; you can redistribute it and/or modify | |
8 | * it under the terms of the GNU General Public License as published by | |
9 | * the Free Software Foundation; under version 2 of the License. | |
10 | * | |
11 | * This program is distributed in the hope that it will be useful, | |
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | * GNU General Public License for more details. | |
15 | * | |
16 | * You should have received a copy of the GNU General Public License | |
8167ee88 | 17 | * along with this program; if not, see <http://www.gnu.org/licenses/>. |
75818250 | 18 | */ |
7a5ca864 | 19 | |
d38ea87a | 20 | #include "qemu/osdep.h" |
da34e65c | 21 | #include "qapi/error.h" |
9588463e | 22 | #include "trace.h" |
798bfe00 | 23 | #include "nbd-internal.h" |
ca441480 PB |
24 | |
25 | static int system_errno_to_nbd_errno(int err) | |
26 | { | |
27 | switch (err) { | |
28 | case 0: | |
29 | return NBD_SUCCESS; | |
30 | case EPERM: | |
c0301fcc | 31 | case EROFS: |
ca441480 PB |
32 | return NBD_EPERM; |
33 | case EIO: | |
34 | return NBD_EIO; | |
35 | case ENOMEM: | |
36 | return NBD_ENOMEM; | |
37 | #ifdef EDQUOT | |
38 | case EDQUOT: | |
39 | #endif | |
40 | case EFBIG: | |
41 | case ENOSPC: | |
42 | return NBD_ENOSPC; | |
bae245d1 EB |
43 | case EOVERFLOW: |
44 | return NBD_EOVERFLOW; | |
b6f5d3b5 EB |
45 | case ESHUTDOWN: |
46 | return NBD_ESHUTDOWN; | |
ca441480 PB |
47 | case EINVAL: |
48 | default: | |
49 | return NBD_EINVAL; | |
50 | } | |
51 | } | |
52 | ||
9a304d29 PB |
53 | /* Definitions for opaque data types */ |
54 | ||
315f78ab | 55 | typedef struct NBDRequestData NBDRequestData; |
9a304d29 | 56 | |
315f78ab EB |
57 | struct NBDRequestData { |
58 | QSIMPLEQ_ENTRY(NBDRequestData) entry; | |
9a304d29 PB |
59 | NBDClient *client; |
60 | uint8_t *data; | |
29b6c3b3 | 61 | bool complete; |
9a304d29 PB |
62 | }; |
63 | ||
64 | struct NBDExport { | |
2c8d9f06 | 65 | int refcount; |
0ddf08db PB |
66 | void (*close)(NBDExport *exp); |
67 | ||
aadf99a7 | 68 | BlockBackend *blk; |
ee0a19ec | 69 | char *name; |
b1a75b33 | 70 | char *description; |
9a304d29 PB |
71 | off_t dev_offset; |
72 | off_t size; | |
7423f417 | 73 | uint16_t nbdflags; |
4b9441f6 | 74 | QTAILQ_HEAD(, NBDClient) clients; |
ee0a19ec | 75 | QTAILQ_ENTRY(NBDExport) next; |
958c717d HR |
76 | |
77 | AioContext *ctx; | |
741cc431 | 78 | |
cd7fca95 | 79 | BlockBackend *eject_notifier_blk; |
741cc431 | 80 | Notifier eject_notifier; |
9a304d29 PB |
81 | }; |
82 | ||
ee0a19ec PB |
83 | static QTAILQ_HEAD(, NBDExport) exports = QTAILQ_HEAD_INITIALIZER(exports); |
84 | ||
9a304d29 PB |
85 | struct NBDClient { |
86 | int refcount; | |
0c9390d9 | 87 | void (*close_fn)(NBDClient *client, bool negotiated); |
9a304d29 PB |
88 | |
89 | NBDExport *exp; | |
f95910fe DB |
90 | QCryptoTLSCreds *tlscreds; |
91 | char *tlsaclname; | |
1c778ef7 DB |
92 | QIOChannelSocket *sioc; /* The underlying data channel */ |
93 | QIOChannel *ioc; /* The current I/O channel which may differ (eg TLS) */ | |
9a304d29 PB |
94 | |
95 | Coroutine *recv_coroutine; | |
96 | ||
97 | CoMutex send_lock; | |
98 | Coroutine *send_coroutine; | |
99 | ||
4b9441f6 | 100 | QTAILQ_ENTRY(NBDClient) next; |
9a304d29 | 101 | int nb_requests; |
ff2b68aa | 102 | bool closing; |
5c54e7fa VSO |
103 | |
104 | bool structured_reply; | |
9a304d29 PB |
105 | }; |
106 | ||
7a5ca864 FB |
107 | /* That's all folks */ |
108 | ||
ff82911c | 109 | static void nbd_client_receive_next_request(NBDClient *client); |
958c717d | 110 | |
6b8c01e7 | 111 | /* Basic flow for negotiation |
7a5ca864 FB |
112 | |
113 | Server Client | |
7a5ca864 | 114 | Negotiate |
6b8c01e7 PB |
115 | |
116 | or | |
117 | ||
118 | Server Client | |
119 | Negotiate #1 | |
120 | Option | |
121 | Negotiate #2 | |
122 | ||
123 | ---- | |
124 | ||
125 | followed by | |
126 | ||
127 | Server Client | |
7a5ca864 FB |
128 | Request |
129 | Response | |
130 | Request | |
131 | Response | |
132 | ... | |
133 | ... | |
134 | Request (type == 2) | |
6b8c01e7 | 135 | |
7a5ca864 FB |
136 | */ |
137 | ||
526e5c65 EB |
138 | /* Send a reply header, including length, but no payload. |
139 | * Return -errno on error, 0 on success. */ | |
140 | static int nbd_negotiate_send_rep_len(QIOChannel *ioc, uint32_t type, | |
2fd2c840 | 141 | uint32_t opt, uint32_t len, Error **errp) |
6b8c01e7 | 142 | { |
6b8c01e7 | 143 | uint64_t magic; |
6b8c01e7 | 144 | |
3736cc5b EB |
145 | trace_nbd_negotiate_send_rep_len(opt, nbd_opt_lookup(opt), |
146 | type, nbd_rep_lookup(type), len); | |
f95910fe | 147 | |
f37708f6 | 148 | assert(len < NBD_MAX_BUFFER_SIZE); |
f5076b5a | 149 | magic = cpu_to_be64(NBD_REP_MAGIC); |
2fd2c840 VSO |
150 | if (nbd_write(ioc, &magic, sizeof(magic), errp) < 0) { |
151 | error_prepend(errp, "write failed (rep magic): "); | |
f5076b5a | 152 | return -EINVAL; |
6b8c01e7 | 153 | } |
2fd2c840 | 154 | |
f5076b5a | 155 | opt = cpu_to_be32(opt); |
2fd2c840 VSO |
156 | if (nbd_write(ioc, &opt, sizeof(opt), errp) < 0) { |
157 | error_prepend(errp, "write failed (rep opt): "); | |
f5076b5a | 158 | return -EINVAL; |
6b8c01e7 | 159 | } |
2fd2c840 | 160 | |
f5076b5a | 161 | type = cpu_to_be32(type); |
2fd2c840 VSO |
162 | if (nbd_write(ioc, &type, sizeof(type), errp) < 0) { |
163 | error_prepend(errp, "write failed (rep type): "); | |
f5076b5a | 164 | return -EINVAL; |
6b8c01e7 | 165 | } |
2fd2c840 | 166 | |
526e5c65 | 167 | len = cpu_to_be32(len); |
2fd2c840 VSO |
168 | if (nbd_write(ioc, &len, sizeof(len), errp) < 0) { |
169 | error_prepend(errp, "write failed (rep data length): "); | |
f5076b5a | 170 | return -EINVAL; |
6b8c01e7 | 171 | } |
f5076b5a HB |
172 | return 0; |
173 | } | |
6b8c01e7 | 174 | |
526e5c65 EB |
175 | /* Send a reply header with default 0 length. |
176 | * Return -errno on error, 0 on success. */ | |
2fd2c840 VSO |
177 | static int nbd_negotiate_send_rep(QIOChannel *ioc, uint32_t type, uint32_t opt, |
178 | Error **errp) | |
526e5c65 | 179 | { |
2fd2c840 | 180 | return nbd_negotiate_send_rep_len(ioc, type, opt, 0, errp); |
526e5c65 EB |
181 | } |
182 | ||
36683283 EB |
183 | /* Send an error reply. |
184 | * Return -errno on error, 0 on success. */ | |
2fd2c840 | 185 | static int GCC_FMT_ATTR(5, 6) |
36683283 | 186 | nbd_negotiate_send_rep_err(QIOChannel *ioc, uint32_t type, |
2fd2c840 | 187 | uint32_t opt, Error **errp, const char *fmt, ...) |
36683283 EB |
188 | { |
189 | va_list va; | |
190 | char *msg; | |
191 | int ret; | |
192 | size_t len; | |
193 | ||
194 | va_start(va, fmt); | |
195 | msg = g_strdup_vprintf(fmt, va); | |
196 | va_end(va); | |
197 | len = strlen(msg); | |
198 | assert(len < 4096); | |
9588463e | 199 | trace_nbd_negotiate_send_rep_err(msg); |
2fd2c840 | 200 | ret = nbd_negotiate_send_rep_len(ioc, type, opt, len, errp); |
36683283 EB |
201 | if (ret < 0) { |
202 | goto out; | |
203 | } | |
2fd2c840 VSO |
204 | if (nbd_write(ioc, msg, len, errp) < 0) { |
205 | error_prepend(errp, "write failed (error message): "); | |
36683283 EB |
206 | ret = -EIO; |
207 | } else { | |
208 | ret = 0; | |
209 | } | |
2fd2c840 | 210 | |
36683283 EB |
211 | out: |
212 | g_free(msg); | |
213 | return ret; | |
214 | } | |
215 | ||
526e5c65 EB |
216 | /* Send a single NBD_REP_SERVER reply to NBD_OPT_LIST, including payload. |
217 | * Return -errno on error, 0 on success. */ | |
2fd2c840 VSO |
218 | static int nbd_negotiate_send_rep_list(QIOChannel *ioc, NBDExport *exp, |
219 | Error **errp) | |
32d7d2e0 | 220 | { |
b1a75b33 | 221 | size_t name_len, desc_len; |
526e5c65 | 222 | uint32_t len; |
b1a75b33 EB |
223 | const char *name = exp->name ? exp->name : ""; |
224 | const char *desc = exp->description ? exp->description : ""; | |
2e5c9ad6 | 225 | int ret; |
32d7d2e0 | 226 | |
9588463e | 227 | trace_nbd_negotiate_send_rep_list(name, desc); |
b1a75b33 EB |
228 | name_len = strlen(name); |
229 | desc_len = strlen(desc); | |
526e5c65 | 230 | len = name_len + desc_len + sizeof(len); |
2fd2c840 VSO |
231 | ret = nbd_negotiate_send_rep_len(ioc, NBD_REP_SERVER, NBD_OPT_LIST, len, |
232 | errp); | |
2e5c9ad6 VSO |
233 | if (ret < 0) { |
234 | return ret; | |
32d7d2e0 | 235 | } |
526e5c65 | 236 | |
32d7d2e0 | 237 | len = cpu_to_be32(name_len); |
2fd2c840 VSO |
238 | if (nbd_write(ioc, &len, sizeof(len), errp) < 0) { |
239 | error_prepend(errp, "write failed (name length): "); | |
b1a75b33 EB |
240 | return -EINVAL; |
241 | } | |
2fd2c840 VSO |
242 | |
243 | if (nbd_write(ioc, name, name_len, errp) < 0) { | |
244 | error_prepend(errp, "write failed (name buffer): "); | |
32d7d2e0 HB |
245 | return -EINVAL; |
246 | } | |
2fd2c840 VSO |
247 | |
248 | if (nbd_write(ioc, desc, desc_len, errp) < 0) { | |
249 | error_prepend(errp, "write failed (description buffer): "); | |
32d7d2e0 HB |
250 | return -EINVAL; |
251 | } | |
2fd2c840 | 252 | |
32d7d2e0 HB |
253 | return 0; |
254 | } | |
255 | ||
526e5c65 EB |
256 | /* Process the NBD_OPT_LIST command, with a potential series of replies. |
257 | * Return -errno on error, 0 on success. */ | |
e68c35cf | 258 | static int nbd_negotiate_handle_list(NBDClient *client, Error **errp) |
32d7d2e0 | 259 | { |
32d7d2e0 HB |
260 | NBDExport *exp; |
261 | ||
32d7d2e0 HB |
262 | /* For each export, send a NBD_REP_SERVER reply. */ |
263 | QTAILQ_FOREACH(exp, &exports, next) { | |
2fd2c840 | 264 | if (nbd_negotiate_send_rep_list(client->ioc, exp, errp)) { |
32d7d2e0 HB |
265 | return -EINVAL; |
266 | } | |
267 | } | |
268 | /* Finish with a NBD_REP_ACK. */ | |
2fd2c840 | 269 | return nbd_negotiate_send_rep(client->ioc, NBD_REP_ACK, NBD_OPT_LIST, errp); |
32d7d2e0 HB |
270 | } |
271 | ||
f37708f6 EB |
272 | /* Send a reply to NBD_OPT_EXPORT_NAME. |
273 | * Return -errno on error, 0 on success. */ | |
2fd2c840 | 274 | static int nbd_negotiate_handle_export_name(NBDClient *client, uint32_t length, |
23e099c3 | 275 | uint16_t myflags, bool no_zeroes, |
2fd2c840 | 276 | Error **errp) |
f5076b5a | 277 | { |
943cec86 | 278 | char name[NBD_MAX_NAME_SIZE + 1]; |
5f66d060 | 279 | char buf[NBD_REPLY_EXPORT_NAME_SIZE] = ""; |
23e099c3 EB |
280 | size_t len; |
281 | int ret; | |
6b8c01e7 | 282 | |
f5076b5a HB |
283 | /* Client sends: |
284 | [20 .. xx] export name (length bytes) | |
5f66d060 EB |
285 | Server replies: |
286 | [ 0 .. 7] size | |
287 | [ 8 .. 9] export flags | |
288 | [10 .. 133] reserved (0) [unless no_zeroes] | |
f5076b5a | 289 | */ |
9588463e | 290 | trace_nbd_negotiate_handle_export_name(); |
943cec86 | 291 | if (length >= sizeof(name)) { |
2fd2c840 | 292 | error_setg(errp, "Bad length received"); |
d9faeed8 | 293 | return -EINVAL; |
6b8c01e7 | 294 | } |
2fd2c840 VSO |
295 | if (nbd_read(client->ioc, name, length, errp) < 0) { |
296 | error_prepend(errp, "read failed: "); | |
d9faeed8 | 297 | return -EINVAL; |
6b8c01e7 PB |
298 | } |
299 | name[length] = '\0'; | |
300 | ||
9588463e | 301 | trace_nbd_negotiate_handle_export_name_request(name); |
9344e5f5 | 302 | |
6b8c01e7 PB |
303 | client->exp = nbd_export_find(name); |
304 | if (!client->exp) { | |
2fd2c840 | 305 | error_setg(errp, "export not found"); |
d9faeed8 | 306 | return -EINVAL; |
6b8c01e7 PB |
307 | } |
308 | ||
23e099c3 EB |
309 | trace_nbd_negotiate_new_style_size_flags(client->exp->size, |
310 | client->exp->nbdflags | myflags); | |
311 | stq_be_p(buf, client->exp->size); | |
312 | stw_be_p(buf + 8, client->exp->nbdflags | myflags); | |
313 | len = no_zeroes ? 10 : sizeof(buf); | |
314 | ret = nbd_write(client->ioc, buf, len, errp); | |
315 | if (ret < 0) { | |
316 | error_prepend(errp, "write failed: "); | |
317 | return ret; | |
318 | } | |
319 | ||
6b8c01e7 PB |
320 | QTAILQ_INSERT_TAIL(&client->exp->clients, client, next); |
321 | nbd_export_get(client->exp); | |
d9faeed8 VSO |
322 | |
323 | return 0; | |
6b8c01e7 PB |
324 | } |
325 | ||
f37708f6 EB |
326 | /* Send a single NBD_REP_INFO, with a buffer @buf of @length bytes. |
327 | * The buffer does NOT include the info type prefix. | |
328 | * Return -errno on error, 0 if ready to send more. */ | |
329 | static int nbd_negotiate_send_info(NBDClient *client, uint32_t opt, | |
330 | uint16_t info, uint32_t length, void *buf, | |
331 | Error **errp) | |
332 | { | |
333 | int rc; | |
334 | ||
335 | trace_nbd_negotiate_send_info(info, nbd_info_lookup(info), length); | |
336 | rc = nbd_negotiate_send_rep_len(client->ioc, NBD_REP_INFO, opt, | |
337 | sizeof(info) + length, errp); | |
338 | if (rc < 0) { | |
339 | return rc; | |
340 | } | |
341 | cpu_to_be16s(&info); | |
342 | if (nbd_write(client->ioc, &info, sizeof(info), errp) < 0) { | |
343 | return -EIO; | |
344 | } | |
345 | if (nbd_write(client->ioc, buf, length, errp) < 0) { | |
346 | return -EIO; | |
347 | } | |
348 | return 0; | |
349 | } | |
350 | ||
351 | /* Handle NBD_OPT_INFO and NBD_OPT_GO. | |
352 | * Return -errno on error, 0 if ready for next option, and 1 to move | |
353 | * into transmission phase. */ | |
354 | static int nbd_negotiate_handle_info(NBDClient *client, uint32_t length, | |
355 | uint32_t opt, uint16_t myflags, | |
356 | Error **errp) | |
357 | { | |
358 | int rc; | |
359 | char name[NBD_MAX_NAME_SIZE + 1]; | |
360 | NBDExport *exp; | |
361 | uint16_t requests; | |
362 | uint16_t request; | |
363 | uint32_t namelen; | |
364 | bool sendname = false; | |
0c1d50bd EB |
365 | bool blocksize = false; |
366 | uint32_t sizes[3]; | |
f37708f6 EB |
367 | char buf[sizeof(uint64_t) + sizeof(uint16_t)]; |
368 | const char *msg; | |
369 | ||
370 | /* Client sends: | |
371 | 4 bytes: L, name length (can be 0) | |
372 | L bytes: export name | |
373 | 2 bytes: N, number of requests (can be 0) | |
374 | N * 2 bytes: N requests | |
375 | */ | |
376 | if (length < sizeof(namelen) + sizeof(requests)) { | |
377 | msg = "overall request too short"; | |
378 | goto invalid; | |
379 | } | |
380 | if (nbd_read(client->ioc, &namelen, sizeof(namelen), errp) < 0) { | |
381 | return -EIO; | |
382 | } | |
383 | be32_to_cpus(&namelen); | |
384 | length -= sizeof(namelen); | |
385 | if (namelen > length - sizeof(requests) || (length - namelen) % 2) { | |
386 | msg = "name length is incorrect"; | |
387 | goto invalid; | |
388 | } | |
389 | if (nbd_read(client->ioc, name, namelen, errp) < 0) { | |
390 | return -EIO; | |
391 | } | |
392 | name[namelen] = '\0'; | |
393 | length -= namelen; | |
394 | trace_nbd_negotiate_handle_export_name_request(name); | |
395 | ||
396 | if (nbd_read(client->ioc, &requests, sizeof(requests), errp) < 0) { | |
397 | return -EIO; | |
398 | } | |
399 | be16_to_cpus(&requests); | |
400 | length -= sizeof(requests); | |
401 | trace_nbd_negotiate_handle_info_requests(requests); | |
402 | if (requests != length / sizeof(request)) { | |
403 | msg = "incorrect number of requests for overall length"; | |
404 | goto invalid; | |
405 | } | |
406 | while (requests--) { | |
407 | if (nbd_read(client->ioc, &request, sizeof(request), errp) < 0) { | |
408 | return -EIO; | |
409 | } | |
410 | be16_to_cpus(&request); | |
411 | length -= sizeof(request); | |
412 | trace_nbd_negotiate_handle_info_request(request, | |
413 | nbd_info_lookup(request)); | |
0c1d50bd EB |
414 | /* We care about NBD_INFO_NAME and NBD_INFO_BLOCK_SIZE; |
415 | * everything else is either a request we don't know or | |
416 | * something we send regardless of request */ | |
417 | switch (request) { | |
418 | case NBD_INFO_NAME: | |
f37708f6 | 419 | sendname = true; |
0c1d50bd EB |
420 | break; |
421 | case NBD_INFO_BLOCK_SIZE: | |
422 | blocksize = true; | |
423 | break; | |
f37708f6 EB |
424 | } |
425 | } | |
46321d6b | 426 | assert(length == 0); |
f37708f6 EB |
427 | |
428 | exp = nbd_export_find(name); | |
429 | if (!exp) { | |
430 | return nbd_negotiate_send_rep_err(client->ioc, NBD_REP_ERR_UNKNOWN, | |
431 | opt, errp, "export '%s' not present", | |
432 | name); | |
433 | } | |
434 | ||
435 | /* Don't bother sending NBD_INFO_NAME unless client requested it */ | |
436 | if (sendname) { | |
46321d6b | 437 | rc = nbd_negotiate_send_info(client, opt, NBD_INFO_NAME, namelen, name, |
f37708f6 EB |
438 | errp); |
439 | if (rc < 0) { | |
440 | return rc; | |
441 | } | |
442 | } | |
443 | ||
444 | /* Send NBD_INFO_DESCRIPTION only if available, regardless of | |
445 | * client request */ | |
446 | if (exp->description) { | |
447 | size_t len = strlen(exp->description); | |
448 | ||
449 | rc = nbd_negotiate_send_info(client, opt, NBD_INFO_DESCRIPTION, | |
450 | len, exp->description, errp); | |
451 | if (rc < 0) { | |
452 | return rc; | |
453 | } | |
454 | } | |
455 | ||
0c1d50bd EB |
456 | /* Send NBD_INFO_BLOCK_SIZE always, but tweak the minimum size |
457 | * according to whether the client requested it, and according to | |
458 | * whether this is OPT_INFO or OPT_GO. */ | |
459 | /* minimum - 1 for back-compat, or 512 if client is new enough. | |
460 | * TODO: consult blk_bs(blk)->bl.request_alignment? */ | |
461 | sizes[0] = (opt == NBD_OPT_INFO || blocksize) ? BDRV_SECTOR_SIZE : 1; | |
462 | /* preferred - Hard-code to 4096 for now. | |
463 | * TODO: is blk_bs(blk)->bl.opt_transfer appropriate? */ | |
464 | sizes[1] = 4096; | |
465 | /* maximum - At most 32M, but smaller as appropriate. */ | |
466 | sizes[2] = MIN(blk_get_max_transfer(exp->blk), NBD_MAX_BUFFER_SIZE); | |
467 | trace_nbd_negotiate_handle_info_block_size(sizes[0], sizes[1], sizes[2]); | |
468 | cpu_to_be32s(&sizes[0]); | |
469 | cpu_to_be32s(&sizes[1]); | |
470 | cpu_to_be32s(&sizes[2]); | |
471 | rc = nbd_negotiate_send_info(client, opt, NBD_INFO_BLOCK_SIZE, | |
472 | sizeof(sizes), sizes, errp); | |
473 | if (rc < 0) { | |
474 | return rc; | |
475 | } | |
476 | ||
f37708f6 EB |
477 | /* Send NBD_INFO_EXPORT always */ |
478 | trace_nbd_negotiate_new_style_size_flags(exp->size, | |
479 | exp->nbdflags | myflags); | |
480 | stq_be_p(buf, exp->size); | |
481 | stw_be_p(buf + 8, exp->nbdflags | myflags); | |
482 | rc = nbd_negotiate_send_info(client, opt, NBD_INFO_EXPORT, | |
483 | sizeof(buf), buf, errp); | |
484 | if (rc < 0) { | |
485 | return rc; | |
486 | } | |
487 | ||
0c1d50bd EB |
488 | /* If the client is just asking for NBD_OPT_INFO, but forgot to |
489 | * request block sizes, return an error. | |
490 | * TODO: consult blk_bs(blk)->request_align, and only error if it | |
491 | * is not 1? */ | |
492 | if (opt == NBD_OPT_INFO && !blocksize) { | |
493 | return nbd_negotiate_send_rep_err(client->ioc, | |
494 | NBD_REP_ERR_BLOCK_SIZE_REQD, opt, | |
495 | errp, | |
496 | "request NBD_INFO_BLOCK_SIZE to " | |
497 | "use this export"); | |
498 | } | |
499 | ||
f37708f6 EB |
500 | /* Final reply */ |
501 | rc = nbd_negotiate_send_rep(client->ioc, NBD_REP_ACK, opt, errp); | |
502 | if (rc < 0) { | |
503 | return rc; | |
504 | } | |
505 | ||
506 | if (opt == NBD_OPT_GO) { | |
507 | client->exp = exp; | |
508 | QTAILQ_INSERT_TAIL(&client->exp->clients, client, next); | |
509 | nbd_export_get(client->exp); | |
510 | rc = 1; | |
511 | } | |
512 | return rc; | |
513 | ||
514 | invalid: | |
515 | if (nbd_drop(client->ioc, length, errp) < 0) { | |
516 | return -EIO; | |
517 | } | |
518 | return nbd_negotiate_send_rep_err(client->ioc, NBD_REP_ERR_INVALID, opt, | |
519 | errp, "%s", msg); | |
520 | } | |
521 | ||
522 | ||
36683283 EB |
523 | /* Handle NBD_OPT_STARTTLS. Return NULL to drop connection, or else the |
524 | * new channel for all further (now-encrypted) communication. */ | |
f95910fe | 525 | static QIOChannel *nbd_negotiate_handle_starttls(NBDClient *client, |
2fd2c840 | 526 | Error **errp) |
f95910fe DB |
527 | { |
528 | QIOChannel *ioc; | |
529 | QIOChannelTLS *tioc; | |
530 | struct NBDTLSHandshakeData data = { 0 }; | |
531 | ||
9588463e | 532 | trace_nbd_negotiate_handle_starttls(); |
f95910fe | 533 | ioc = client->ioc; |
f95910fe | 534 | |
63d5ef86 | 535 | if (nbd_negotiate_send_rep(client->ioc, NBD_REP_ACK, |
2fd2c840 | 536 | NBD_OPT_STARTTLS, errp) < 0) { |
63d5ef86 EB |
537 | return NULL; |
538 | } | |
f95910fe DB |
539 | |
540 | tioc = qio_channel_tls_new_server(ioc, | |
541 | client->tlscreds, | |
542 | client->tlsaclname, | |
2fd2c840 | 543 | errp); |
f95910fe DB |
544 | if (!tioc) { |
545 | return NULL; | |
546 | } | |
547 | ||
0d73f725 | 548 | qio_channel_set_name(QIO_CHANNEL(tioc), "nbd-server-tls"); |
9588463e | 549 | trace_nbd_negotiate_handle_starttls_handshake(); |
f95910fe DB |
550 | data.loop = g_main_loop_new(g_main_context_default(), FALSE); |
551 | qio_channel_tls_handshake(tioc, | |
552 | nbd_tls_handshake, | |
553 | &data, | |
554 | NULL); | |
555 | ||
556 | if (!data.complete) { | |
557 | g_main_loop_run(data.loop); | |
558 | } | |
559 | g_main_loop_unref(data.loop); | |
560 | if (data.error) { | |
561 | object_unref(OBJECT(tioc)); | |
2fd2c840 | 562 | error_propagate(errp, data.error); |
f95910fe DB |
563 | return NULL; |
564 | } | |
565 | ||
566 | return QIO_CHANNEL(tioc); | |
567 | } | |
568 | ||
e68c35cf EB |
569 | /* nbd_reject_length: Handle any unexpected payload. |
570 | * @fatal requests that we quit talking to the client, even if we are able | |
571 | * to successfully send an error to the guest. | |
572 | * Return: | |
573 | * -errno transmission error occurred or @fatal was requested, errp is set | |
574 | * 0 error message successfully sent to client, errp is not set | |
575 | */ | |
576 | static int nbd_reject_length(NBDClient *client, uint32_t length, | |
577 | uint32_t option, bool fatal, Error **errp) | |
578 | { | |
579 | int ret; | |
580 | ||
581 | assert(length); | |
582 | if (nbd_drop(client->ioc, length, errp) < 0) { | |
583 | return -EIO; | |
584 | } | |
585 | ret = nbd_negotiate_send_rep_err(client->ioc, NBD_REP_ERR_INVALID, | |
586 | option, errp, | |
587 | "option '%s' should have zero length", | |
588 | nbd_opt_lookup(option)); | |
589 | if (fatal && !ret) { | |
590 | error_setg(errp, "option '%s' should have zero length", | |
591 | nbd_opt_lookup(option)); | |
592 | return -EINVAL; | |
593 | } | |
594 | return ret; | |
595 | } | |
596 | ||
1e120ffe | 597 | /* nbd_negotiate_options |
f37708f6 EB |
598 | * Process all NBD_OPT_* client option commands, during fixed newstyle |
599 | * negotiation. | |
1e120ffe | 600 | * Return: |
2fd2c840 VSO |
601 | * -errno on error, errp is set |
602 | * 0 on successful negotiation, errp is not set | |
603 | * 1 if client sent NBD_OPT_ABORT, i.e. on valid disconnect, | |
604 | * errp is not set | |
1e120ffe | 605 | */ |
23e099c3 EB |
606 | static int nbd_negotiate_options(NBDClient *client, uint16_t myflags, |
607 | Error **errp) | |
f5076b5a | 608 | { |
9c122ada | 609 | uint32_t flags; |
26afa868 | 610 | bool fixedNewstyle = false; |
23e099c3 | 611 | bool no_zeroes = false; |
9c122ada HR |
612 | |
613 | /* Client sends: | |
614 | [ 0 .. 3] client flags | |
615 | ||
f37708f6 | 616 | Then we loop until NBD_OPT_EXPORT_NAME or NBD_OPT_GO: |
9c122ada HR |
617 | [ 0 .. 7] NBD_OPTS_MAGIC |
618 | [ 8 .. 11] NBD option | |
619 | [12 .. 15] Data length | |
620 | ... Rest of request | |
621 | ||
622 | [ 0 .. 7] NBD_OPTS_MAGIC | |
623 | [ 8 .. 11] Second NBD option | |
624 | [12 .. 15] Data length | |
625 | ... Rest of request | |
626 | */ | |
627 | ||
2fd2c840 VSO |
628 | if (nbd_read(client->ioc, &flags, sizeof(flags), errp) < 0) { |
629 | error_prepend(errp, "read failed: "); | |
9c122ada HR |
630 | return -EIO; |
631 | } | |
9c122ada | 632 | be32_to_cpus(&flags); |
621c4f4e | 633 | trace_nbd_negotiate_options_flags(flags); |
26afa868 | 634 | if (flags & NBD_FLAG_C_FIXED_NEWSTYLE) { |
26afa868 DB |
635 | fixedNewstyle = true; |
636 | flags &= ~NBD_FLAG_C_FIXED_NEWSTYLE; | |
637 | } | |
c203c59a | 638 | if (flags & NBD_FLAG_C_NO_ZEROES) { |
23e099c3 | 639 | no_zeroes = true; |
c203c59a EB |
640 | flags &= ~NBD_FLAG_C_NO_ZEROES; |
641 | } | |
26afa868 | 642 | if (flags != 0) { |
2fd2c840 | 643 | error_setg(errp, "Unknown client flags 0x%" PRIx32 " received", flags); |
621c4f4e | 644 | return -EINVAL; |
9c122ada HR |
645 | } |
646 | ||
f5076b5a | 647 | while (1) { |
9c122ada | 648 | int ret; |
7f9039cd | 649 | uint32_t option, length; |
f5076b5a HB |
650 | uint64_t magic; |
651 | ||
2fd2c840 VSO |
652 | if (nbd_read(client->ioc, &magic, sizeof(magic), errp) < 0) { |
653 | error_prepend(errp, "read failed: "); | |
f5076b5a HB |
654 | return -EINVAL; |
655 | } | |
9588463e VSO |
656 | magic = be64_to_cpu(magic); |
657 | trace_nbd_negotiate_options_check_magic(magic); | |
658 | if (magic != NBD_OPTS_MAGIC) { | |
2fd2c840 | 659 | error_setg(errp, "Bad magic received"); |
f5076b5a HB |
660 | return -EINVAL; |
661 | } | |
662 | ||
7f9039cd VSO |
663 | if (nbd_read(client->ioc, &option, |
664 | sizeof(option), errp) < 0) { | |
2fd2c840 | 665 | error_prepend(errp, "read failed: "); |
f5076b5a HB |
666 | return -EINVAL; |
667 | } | |
7f9039cd | 668 | option = be32_to_cpu(option); |
f5076b5a | 669 | |
2fd2c840 VSO |
670 | if (nbd_read(client->ioc, &length, sizeof(length), errp) < 0) { |
671 | error_prepend(errp, "read failed: "); | |
f5076b5a HB |
672 | return -EINVAL; |
673 | } | |
674 | length = be32_to_cpu(length); | |
675 | ||
3736cc5b EB |
676 | trace_nbd_negotiate_options_check_option(option, |
677 | nbd_opt_lookup(option)); | |
f95910fe DB |
678 | if (client->tlscreds && |
679 | client->ioc == (QIOChannel *)client->sioc) { | |
680 | QIOChannel *tioc; | |
681 | if (!fixedNewstyle) { | |
7f9039cd | 682 | error_setg(errp, "Unsupported option 0x%" PRIx32, option); |
f95910fe DB |
683 | return -EINVAL; |
684 | } | |
7f9039cd | 685 | switch (option) { |
f95910fe | 686 | case NBD_OPT_STARTTLS: |
e68c35cf EB |
687 | if (length) { |
688 | /* Unconditionally drop the connection if the client | |
689 | * can't start a TLS negotiation correctly */ | |
690 | return nbd_reject_length(client, length, option, true, | |
691 | errp); | |
692 | } | |
693 | tioc = nbd_negotiate_handle_starttls(client, errp); | |
f95910fe DB |
694 | if (!tioc) { |
695 | return -EIO; | |
696 | } | |
8cbee49e | 697 | ret = 0; |
f95910fe DB |
698 | object_unref(OBJECT(client->ioc)); |
699 | client->ioc = QIO_CHANNEL(tioc); | |
700 | break; | |
701 | ||
d1129a8a EB |
702 | case NBD_OPT_EXPORT_NAME: |
703 | /* No way to return an error to client, so drop connection */ | |
2fd2c840 | 704 | error_setg(errp, "Option 0x%x not permitted before TLS", |
7f9039cd | 705 | option); |
d1129a8a EB |
706 | return -EINVAL; |
707 | ||
f95910fe | 708 | default: |
2fd2c840 | 709 | if (nbd_drop(client->ioc, length, errp) < 0) { |
d1129a8a EB |
710 | return -EIO; |
711 | } | |
36683283 EB |
712 | ret = nbd_negotiate_send_rep_err(client->ioc, |
713 | NBD_REP_ERR_TLS_REQD, | |
7f9039cd | 714 | option, errp, |
36683283 EB |
715 | "Option 0x%" PRIx32 |
716 | "not permitted before TLS", | |
7f9039cd | 717 | option); |
37ec36f6 EB |
718 | /* Let the client keep trying, unless they asked to |
719 | * quit. In this mode, we've already sent an error, so | |
720 | * we can't ack the abort. */ | |
7f9039cd | 721 | if (option == NBD_OPT_ABORT) { |
1e120ffe | 722 | return 1; |
b6f5d3b5 | 723 | } |
d1129a8a | 724 | break; |
f95910fe DB |
725 | } |
726 | } else if (fixedNewstyle) { | |
7f9039cd | 727 | switch (option) { |
26afa868 | 728 | case NBD_OPT_LIST: |
e68c35cf EB |
729 | if (length) { |
730 | ret = nbd_reject_length(client, length, option, false, | |
731 | errp); | |
732 | } else { | |
733 | ret = nbd_negotiate_handle_list(client, errp); | |
734 | } | |
26afa868 DB |
735 | break; |
736 | ||
737 | case NBD_OPT_ABORT: | |
b6f5d3b5 EB |
738 | /* NBD spec says we must try to reply before |
739 | * disconnecting, but that we must also tolerate | |
740 | * guests that don't wait for our reply. */ | |
37ec36f6 | 741 | nbd_negotiate_send_rep(client->ioc, NBD_REP_ACK, option, NULL); |
1e120ffe | 742 | return 1; |
26afa868 DB |
743 | |
744 | case NBD_OPT_EXPORT_NAME: | |
23e099c3 EB |
745 | return nbd_negotiate_handle_export_name(client, length, |
746 | myflags, no_zeroes, | |
747 | errp); | |
26afa868 | 748 | |
f37708f6 EB |
749 | case NBD_OPT_INFO: |
750 | case NBD_OPT_GO: | |
751 | ret = nbd_negotiate_handle_info(client, length, option, | |
752 | myflags, errp); | |
753 | if (ret == 1) { | |
754 | assert(option == NBD_OPT_GO); | |
755 | return 0; | |
756 | } | |
f37708f6 EB |
757 | break; |
758 | ||
f95910fe | 759 | case NBD_OPT_STARTTLS: |
e68c35cf EB |
760 | if (length) { |
761 | ret = nbd_reject_length(client, length, option, false, | |
762 | errp); | |
763 | } else if (client->tlscreds) { | |
36683283 EB |
764 | ret = nbd_negotiate_send_rep_err(client->ioc, |
765 | NBD_REP_ERR_INVALID, | |
7f9039cd | 766 | option, errp, |
36683283 | 767 | "TLS already enabled"); |
f95910fe | 768 | } else { |
36683283 EB |
769 | ret = nbd_negotiate_send_rep_err(client->ioc, |
770 | NBD_REP_ERR_POLICY, | |
7f9039cd | 771 | option, errp, |
36683283 | 772 | "TLS not configured"); |
63d5ef86 | 773 | } |
d1129a8a | 774 | break; |
5c54e7fa VSO |
775 | |
776 | case NBD_OPT_STRUCTURED_REPLY: | |
777 | if (length) { | |
778 | ret = nbd_reject_length(client, length, option, false, | |
779 | errp); | |
780 | } else if (client->structured_reply) { | |
781 | ret = nbd_negotiate_send_rep_err( | |
782 | client->ioc, NBD_REP_ERR_INVALID, option, errp, | |
783 | "structured reply already negotiated"); | |
784 | } else { | |
785 | ret = nbd_negotiate_send_rep(client->ioc, NBD_REP_ACK, | |
786 | option, errp); | |
787 | client->structured_reply = true; | |
788 | myflags |= NBD_FLAG_SEND_DF; | |
789 | } | |
790 | break; | |
791 | ||
26afa868 | 792 | default: |
2fd2c840 | 793 | if (nbd_drop(client->ioc, length, errp) < 0) { |
156f6a10 EB |
794 | return -EIO; |
795 | } | |
36683283 EB |
796 | ret = nbd_negotiate_send_rep_err(client->ioc, |
797 | NBD_REP_ERR_UNSUP, | |
7f9039cd | 798 | option, errp, |
36683283 | 799 | "Unsupported option 0x%" |
3736cc5b EB |
800 | PRIx32 " (%s)", option, |
801 | nbd_opt_lookup(option)); | |
156f6a10 | 802 | break; |
26afa868 DB |
803 | } |
804 | } else { | |
805 | /* | |
806 | * If broken new-style we should drop the connection | |
807 | * for anything except NBD_OPT_EXPORT_NAME | |
808 | */ | |
7f9039cd | 809 | switch (option) { |
26afa868 | 810 | case NBD_OPT_EXPORT_NAME: |
23e099c3 EB |
811 | return nbd_negotiate_handle_export_name(client, length, |
812 | myflags, no_zeroes, | |
813 | errp); | |
26afa868 DB |
814 | |
815 | default: | |
3736cc5b EB |
816 | error_setg(errp, "Unsupported option 0x%" PRIx32 " (%s)", |
817 | option, nbd_opt_lookup(option)); | |
26afa868 | 818 | return -EINVAL; |
32d7d2e0 | 819 | } |
f5076b5a | 820 | } |
8cbee49e EB |
821 | if (ret < 0) { |
822 | return ret; | |
823 | } | |
f5076b5a HB |
824 | } |
825 | } | |
826 | ||
1e120ffe VSO |
827 | /* nbd_negotiate |
828 | * Return: | |
2fd2c840 VSO |
829 | * -errno on error, errp is set |
830 | * 0 on successful negotiation, errp is not set | |
831 | * 1 if client sent NBD_OPT_ABORT, i.e. on valid disconnect, | |
832 | * errp is not set | |
1e120ffe | 833 | */ |
2fd2c840 | 834 | static coroutine_fn int nbd_negotiate(NBDClient *client, Error **errp) |
7a5ca864 | 835 | { |
5f66d060 | 836 | char buf[NBD_OLDSTYLE_NEGOTIATE_SIZE] = ""; |
2e5c9ad6 | 837 | int ret; |
7423f417 | 838 | const uint16_t myflags = (NBD_FLAG_HAS_FLAGS | NBD_FLAG_SEND_TRIM | |
1f4d6d18 EB |
839 | NBD_FLAG_SEND_FLUSH | NBD_FLAG_SEND_FUA | |
840 | NBD_FLAG_SEND_WRITE_ZEROES); | |
f95910fe | 841 | bool oldStyle; |
b2e3d87f | 842 | |
5f66d060 | 843 | /* Old style negotiation header, no room for options |
6b8c01e7 PB |
844 | [ 0 .. 7] passwd ("NBDMAGIC") |
845 | [ 8 .. 15] magic (NBD_CLIENT_MAGIC) | |
b2e3d87f | 846 | [16 .. 23] size |
5f66d060 | 847 | [24 .. 27] export flags (zero-extended) |
6b8c01e7 PB |
848 | [28 .. 151] reserved (0) |
849 | ||
5f66d060 | 850 | New style negotiation header, client can send options |
6b8c01e7 PB |
851 | [ 0 .. 7] passwd ("NBDMAGIC") |
852 | [ 8 .. 15] magic (NBD_OPTS_MAGIC) | |
853 | [16 .. 17] server flags (0) | |
f37708f6 | 854 | ....options sent, ending in NBD_OPT_EXPORT_NAME or NBD_OPT_GO.... |
b2e3d87f NT |
855 | */ |
856 | ||
1c778ef7 | 857 | qio_channel_set_blocking(client->ioc, false, NULL); |
185b4338 | 858 | |
9588463e | 859 | trace_nbd_negotiate_begin(); |
b2e3d87f | 860 | memcpy(buf, "NBDMAGIC", 8); |
f95910fe DB |
861 | |
862 | oldStyle = client->exp != NULL && !client->tlscreds; | |
863 | if (oldStyle) { | |
9588463e VSO |
864 | trace_nbd_negotiate_old_style(client->exp->size, |
865 | client->exp->nbdflags | myflags); | |
667ad26f JS |
866 | stq_be_p(buf + 8, NBD_CLIENT_MAGIC); |
867 | stq_be_p(buf + 16, client->exp->size); | |
5f66d060 | 868 | stl_be_p(buf + 24, client->exp->nbdflags | myflags); |
b2e3d87f | 869 | |
2fd2c840 VSO |
870 | if (nbd_write(client->ioc, buf, sizeof(buf), errp) < 0) { |
871 | error_prepend(errp, "write failed: "); | |
d9faeed8 | 872 | return -EINVAL; |
6b8c01e7 PB |
873 | } |
874 | } else { | |
76ff081d VSO |
875 | stq_be_p(buf + 8, NBD_OPTS_MAGIC); |
876 | stw_be_p(buf + 16, NBD_FLAG_FIXED_NEWSTYLE | NBD_FLAG_NO_ZEROES); | |
877 | ||
2fd2c840 VSO |
878 | if (nbd_write(client->ioc, buf, 18, errp) < 0) { |
879 | error_prepend(errp, "write failed: "); | |
d9faeed8 | 880 | return -EINVAL; |
6b8c01e7 | 881 | } |
23e099c3 | 882 | ret = nbd_negotiate_options(client, myflags, errp); |
2e5c9ad6 | 883 | if (ret != 0) { |
2fd2c840 VSO |
884 | if (ret < 0) { |
885 | error_prepend(errp, "option negotiation failed: "); | |
886 | } | |
2e5c9ad6 | 887 | return ret; |
6b8c01e7 | 888 | } |
b2e3d87f NT |
889 | } |
890 | ||
9588463e | 891 | trace_nbd_negotiate_success(); |
d9faeed8 VSO |
892 | |
893 | return 0; | |
7a5ca864 FB |
894 | } |
895 | ||
2fd2c840 VSO |
896 | static int nbd_receive_request(QIOChannel *ioc, NBDRequest *request, |
897 | Error **errp) | |
75818250 | 898 | { |
fa26c26b | 899 | uint8_t buf[NBD_REQUEST_SIZE]; |
b2e3d87f | 900 | uint32_t magic; |
a0dc63a6 | 901 | int ret; |
b2e3d87f | 902 | |
2fd2c840 | 903 | ret = nbd_read(ioc, buf, sizeof(buf), errp); |
185b4338 PB |
904 | if (ret < 0) { |
905 | return ret; | |
906 | } | |
907 | ||
b2e3d87f NT |
908 | /* Request |
909 | [ 0 .. 3] magic (NBD_REQUEST_MAGIC) | |
b626b51a EB |
910 | [ 4 .. 5] flags (NBD_CMD_FLAG_FUA, ...) |
911 | [ 6 .. 7] type (NBD_CMD_READ, ...) | |
b2e3d87f NT |
912 | [ 8 .. 15] handle |
913 | [16 .. 23] from | |
914 | [24 .. 27] len | |
915 | */ | |
916 | ||
773dce3c | 917 | magic = ldl_be_p(buf); |
b626b51a EB |
918 | request->flags = lduw_be_p(buf + 4); |
919 | request->type = lduw_be_p(buf + 6); | |
773dce3c PM |
920 | request->handle = ldq_be_p(buf + 8); |
921 | request->from = ldq_be_p(buf + 16); | |
922 | request->len = ldl_be_p(buf + 24); | |
b2e3d87f | 923 | |
9588463e VSO |
924 | trace_nbd_receive_request(magic, request->flags, request->type, |
925 | request->from, request->len); | |
b2e3d87f NT |
926 | |
927 | if (magic != NBD_REQUEST_MAGIC) { | |
2fd2c840 | 928 | error_setg(errp, "invalid magic (got 0x%" PRIx32 ")", magic); |
185b4338 | 929 | return -EINVAL; |
b2e3d87f NT |
930 | } |
931 | return 0; | |
75818250 TS |
932 | } |
933 | ||
41996e38 PB |
934 | #define MAX_NBD_REQUESTS 16 |
935 | ||
ce33967a | 936 | void nbd_client_get(NBDClient *client) |
1743b515 PB |
937 | { |
938 | client->refcount++; | |
939 | } | |
940 | ||
ce33967a | 941 | void nbd_client_put(NBDClient *client) |
1743b515 PB |
942 | { |
943 | if (--client->refcount == 0) { | |
ff2b68aa | 944 | /* The last reference should be dropped by client->close, |
f53a829b | 945 | * which is called by client_close. |
ff2b68aa PB |
946 | */ |
947 | assert(client->closing); | |
948 | ||
ff82911c | 949 | qio_channel_detach_aio_context(client->ioc); |
1c778ef7 DB |
950 | object_unref(OBJECT(client->sioc)); |
951 | object_unref(OBJECT(client->ioc)); | |
f95910fe DB |
952 | if (client->tlscreds) { |
953 | object_unref(OBJECT(client->tlscreds)); | |
954 | } | |
955 | g_free(client->tlsaclname); | |
6b8c01e7 PB |
956 | if (client->exp) { |
957 | QTAILQ_REMOVE(&client->exp->clients, client, next); | |
958 | nbd_export_put(client->exp); | |
959 | } | |
1743b515 PB |
960 | g_free(client); |
961 | } | |
962 | } | |
963 | ||
0c9390d9 | 964 | static void client_close(NBDClient *client, bool negotiated) |
1743b515 | 965 | { |
ff2b68aa PB |
966 | if (client->closing) { |
967 | return; | |
968 | } | |
969 | ||
970 | client->closing = true; | |
971 | ||
972 | /* Force requests to finish. They will drop their own references, | |
973 | * then we'll close the socket and free the NBDClient. | |
974 | */ | |
1c778ef7 DB |
975 | qio_channel_shutdown(client->ioc, QIO_CHANNEL_SHUTDOWN_BOTH, |
976 | NULL); | |
ff2b68aa PB |
977 | |
978 | /* Also tell the client, so that they release their reference. */ | |
0c9390d9 EB |
979 | if (client->close_fn) { |
980 | client->close_fn(client, negotiated); | |
1743b515 | 981 | } |
1743b515 PB |
982 | } |
983 | ||
315f78ab | 984 | static NBDRequestData *nbd_request_get(NBDClient *client) |
d9a73806 | 985 | { |
315f78ab | 986 | NBDRequestData *req; |
72deddc5 | 987 | |
41996e38 PB |
988 | assert(client->nb_requests <= MAX_NBD_REQUESTS - 1); |
989 | client->nb_requests++; | |
990 | ||
315f78ab | 991 | req = g_new0(NBDRequestData, 1); |
72deddc5 PB |
992 | nbd_client_get(client); |
993 | req->client = client; | |
d9a73806 PB |
994 | return req; |
995 | } | |
996 | ||
315f78ab | 997 | static void nbd_request_put(NBDRequestData *req) |
d9a73806 | 998 | { |
72deddc5 | 999 | NBDClient *client = req->client; |
e1adb27a | 1000 | |
2d821488 SH |
1001 | if (req->data) { |
1002 | qemu_vfree(req->data); | |
1003 | } | |
1729404c | 1004 | g_free(req); |
e1adb27a | 1005 | |
958c717d | 1006 | client->nb_requests--; |
ff82911c PB |
1007 | nbd_client_receive_next_request(client); |
1008 | ||
72deddc5 | 1009 | nbd_client_put(client); |
d9a73806 PB |
1010 | } |
1011 | ||
aadf99a7 | 1012 | static void blk_aio_attached(AioContext *ctx, void *opaque) |
f2149281 HR |
1013 | { |
1014 | NBDExport *exp = opaque; | |
1015 | NBDClient *client; | |
1016 | ||
9588463e | 1017 | trace_nbd_blk_aio_attached(exp->name, ctx); |
f2149281 HR |
1018 | |
1019 | exp->ctx = ctx; | |
1020 | ||
1021 | QTAILQ_FOREACH(client, &exp->clients, next) { | |
ff82911c PB |
1022 | qio_channel_attach_aio_context(client->ioc, ctx); |
1023 | if (client->recv_coroutine) { | |
1024 | aio_co_schedule(ctx, client->recv_coroutine); | |
1025 | } | |
1026 | if (client->send_coroutine) { | |
1027 | aio_co_schedule(ctx, client->send_coroutine); | |
1028 | } | |
f2149281 HR |
1029 | } |
1030 | } | |
1031 | ||
aadf99a7 | 1032 | static void blk_aio_detach(void *opaque) |
f2149281 HR |
1033 | { |
1034 | NBDExport *exp = opaque; | |
1035 | NBDClient *client; | |
1036 | ||
9588463e | 1037 | trace_nbd_blk_aio_detach(exp->name, exp->ctx); |
f2149281 HR |
1038 | |
1039 | QTAILQ_FOREACH(client, &exp->clients, next) { | |
ff82911c | 1040 | qio_channel_detach_aio_context(client->ioc); |
f2149281 HR |
1041 | } |
1042 | ||
1043 | exp->ctx = NULL; | |
1044 | } | |
1045 | ||
741cc431 HR |
1046 | static void nbd_eject_notifier(Notifier *n, void *data) |
1047 | { | |
1048 | NBDExport *exp = container_of(n, NBDExport, eject_notifier); | |
1049 | nbd_export_close(exp); | |
1050 | } | |
1051 | ||
cd7fca95 | 1052 | NBDExport *nbd_export_new(BlockDriverState *bs, off_t dev_offset, off_t size, |
7423f417 | 1053 | uint16_t nbdflags, void (*close)(NBDExport *), |
cd7fca95 | 1054 | bool writethrough, BlockBackend *on_eject_blk, |
98f44bbe | 1055 | Error **errp) |
af49bbbe | 1056 | { |
3dff24f2 | 1057 | AioContext *ctx; |
cd7fca95 | 1058 | BlockBackend *blk; |
e8d3eb74 | 1059 | NBDExport *exp = g_new0(NBDExport, 1); |
8a7ce4f9 | 1060 | uint64_t perm; |
d7086422 | 1061 | int ret; |
cd7fca95 | 1062 | |
3dff24f2 KW |
1063 | /* |
1064 | * NBD exports are used for non-shared storage migration. Make sure | |
1065 | * that BDRV_O_INACTIVE is cleared and the image is ready for write | |
1066 | * access since the export could be available before migration handover. | |
1067 | */ | |
1068 | ctx = bdrv_get_aio_context(bs); | |
1069 | aio_context_acquire(ctx); | |
1070 | bdrv_invalidate_cache(bs, NULL); | |
1071 | aio_context_release(ctx); | |
1072 | ||
8a7ce4f9 KW |
1073 | /* Don't allow resize while the NBD server is running, otherwise we don't |
1074 | * care what happens with the node. */ | |
1075 | perm = BLK_PERM_CONSISTENT_READ; | |
1076 | if ((nbdflags & NBD_FLAG_READ_ONLY) == 0) { | |
1077 | perm |= BLK_PERM_WRITE; | |
1078 | } | |
1079 | blk = blk_new(perm, BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE_UNCHANGED | | |
1080 | BLK_PERM_WRITE | BLK_PERM_GRAPH_MOD); | |
d7086422 KW |
1081 | ret = blk_insert_bs(blk, bs, errp); |
1082 | if (ret < 0) { | |
1083 | goto fail; | |
1084 | } | |
cd7fca95 KW |
1085 | blk_set_enable_write_cache(blk, !writethrough); |
1086 | ||
2c8d9f06 | 1087 | exp->refcount = 1; |
4b9441f6 | 1088 | QTAILQ_INIT(&exp->clients); |
aadf99a7 | 1089 | exp->blk = blk; |
af49bbbe PB |
1090 | exp->dev_offset = dev_offset; |
1091 | exp->nbdflags = nbdflags; | |
98f44bbe HR |
1092 | exp->size = size < 0 ? blk_getlength(blk) : size; |
1093 | if (exp->size < 0) { | |
1094 | error_setg_errno(errp, -exp->size, | |
1095 | "Failed to determine the NBD export's length"); | |
1096 | goto fail; | |
1097 | } | |
1098 | exp->size -= exp->size % BDRV_SECTOR_SIZE; | |
1099 | ||
0ddf08db | 1100 | exp->close = close; |
aadf99a7 | 1101 | exp->ctx = blk_get_aio_context(blk); |
aadf99a7 | 1102 | blk_add_aio_context_notifier(blk, blk_aio_attached, blk_aio_detach, exp); |
741cc431 | 1103 | |
cd7fca95 KW |
1104 | if (on_eject_blk) { |
1105 | blk_ref(on_eject_blk); | |
1106 | exp->eject_notifier_blk = on_eject_blk; | |
1107 | exp->eject_notifier.notify = nbd_eject_notifier; | |
1108 | blk_add_remove_bs_notifier(on_eject_blk, &exp->eject_notifier); | |
1109 | } | |
af49bbbe | 1110 | return exp; |
98f44bbe HR |
1111 | |
1112 | fail: | |
cd7fca95 | 1113 | blk_unref(blk); |
98f44bbe HR |
1114 | g_free(exp); |
1115 | return NULL; | |
af49bbbe PB |
1116 | } |
1117 | ||
ee0a19ec PB |
1118 | NBDExport *nbd_export_find(const char *name) |
1119 | { | |
1120 | NBDExport *exp; | |
1121 | QTAILQ_FOREACH(exp, &exports, next) { | |
1122 | if (strcmp(name, exp->name) == 0) { | |
1123 | return exp; | |
1124 | } | |
1125 | } | |
1126 | ||
1127 | return NULL; | |
1128 | } | |
1129 | ||
1130 | void nbd_export_set_name(NBDExport *exp, const char *name) | |
1131 | { | |
1132 | if (exp->name == name) { | |
1133 | return; | |
1134 | } | |
1135 | ||
1136 | nbd_export_get(exp); | |
1137 | if (exp->name != NULL) { | |
1138 | g_free(exp->name); | |
1139 | exp->name = NULL; | |
1140 | QTAILQ_REMOVE(&exports, exp, next); | |
1141 | nbd_export_put(exp); | |
1142 | } | |
1143 | if (name != NULL) { | |
1144 | nbd_export_get(exp); | |
1145 | exp->name = g_strdup(name); | |
1146 | QTAILQ_INSERT_TAIL(&exports, exp, next); | |
1147 | } | |
1148 | nbd_export_put(exp); | |
1149 | } | |
1150 | ||
b1a75b33 EB |
1151 | void nbd_export_set_description(NBDExport *exp, const char *description) |
1152 | { | |
1153 | g_free(exp->description); | |
1154 | exp->description = g_strdup(description); | |
1155 | } | |
1156 | ||
af49bbbe PB |
1157 | void nbd_export_close(NBDExport *exp) |
1158 | { | |
4b9441f6 | 1159 | NBDClient *client, *next; |
2c8d9f06 | 1160 | |
4b9441f6 PB |
1161 | nbd_export_get(exp); |
1162 | QTAILQ_FOREACH_SAFE(client, &exp->clients, next, next) { | |
0c9390d9 | 1163 | client_close(client, true); |
4b9441f6 | 1164 | } |
125afda8 | 1165 | nbd_export_set_name(exp, NULL); |
b1a75b33 | 1166 | nbd_export_set_description(exp, NULL); |
4b9441f6 | 1167 | nbd_export_put(exp); |
2c8d9f06 PB |
1168 | } |
1169 | ||
1170 | void nbd_export_get(NBDExport *exp) | |
1171 | { | |
1172 | assert(exp->refcount > 0); | |
1173 | exp->refcount++; | |
1174 | } | |
1175 | ||
1176 | void nbd_export_put(NBDExport *exp) | |
1177 | { | |
1178 | assert(exp->refcount > 0); | |
1179 | if (exp->refcount == 1) { | |
1180 | nbd_export_close(exp); | |
d9a73806 PB |
1181 | } |
1182 | ||
2c8d9f06 | 1183 | if (--exp->refcount == 0) { |
ee0a19ec | 1184 | assert(exp->name == NULL); |
b1a75b33 | 1185 | assert(exp->description == NULL); |
ee0a19ec | 1186 | |
0ddf08db PB |
1187 | if (exp->close) { |
1188 | exp->close(exp); | |
1189 | } | |
1190 | ||
d6268348 | 1191 | if (exp->blk) { |
cd7fca95 KW |
1192 | if (exp->eject_notifier_blk) { |
1193 | notifier_remove(&exp->eject_notifier); | |
1194 | blk_unref(exp->eject_notifier_blk); | |
1195 | } | |
d6268348 WC |
1196 | blk_remove_aio_context_notifier(exp->blk, blk_aio_attached, |
1197 | blk_aio_detach, exp); | |
1198 | blk_unref(exp->blk); | |
1199 | exp->blk = NULL; | |
1200 | } | |
1201 | ||
2c8d9f06 PB |
1202 | g_free(exp); |
1203 | } | |
af49bbbe PB |
1204 | } |
1205 | ||
e140177d | 1206 | BlockBackend *nbd_export_get_blockdev(NBDExport *exp) |
125afda8 | 1207 | { |
aadf99a7 | 1208 | return exp->blk; |
125afda8 PB |
1209 | } |
1210 | ||
ee0a19ec PB |
1211 | void nbd_export_close_all(void) |
1212 | { | |
1213 | NBDExport *exp, *next; | |
1214 | ||
1215 | QTAILQ_FOREACH_SAFE(exp, &exports, next, next) { | |
1216 | nbd_export_close(exp); | |
ee0a19ec PB |
1217 | } |
1218 | } | |
1219 | ||
de79bfc3 VSO |
1220 | static int coroutine_fn nbd_co_send_iov(NBDClient *client, struct iovec *iov, |
1221 | unsigned niov, Error **errp) | |
1222 | { | |
1223 | int ret; | |
1224 | ||
1225 | g_assert(qemu_in_coroutine()); | |
1226 | qemu_co_mutex_lock(&client->send_lock); | |
1227 | client->send_coroutine = qemu_coroutine_self(); | |
1228 | ||
1229 | ret = qio_channel_writev_all(client->ioc, iov, niov, errp) < 0 ? -EIO : 0; | |
1230 | ||
1231 | client->send_coroutine = NULL; | |
1232 | qemu_co_mutex_unlock(&client->send_lock); | |
1233 | ||
1234 | return ret; | |
1235 | } | |
1236 | ||
caad5384 VSO |
1237 | static inline void set_be_simple_reply(NBDSimpleReply *reply, uint64_t error, |
1238 | uint64_t handle) | |
1239 | { | |
1240 | stl_be_p(&reply->magic, NBD_SIMPLE_REPLY_MAGIC); | |
1241 | stl_be_p(&reply->error, error); | |
1242 | stq_be_p(&reply->handle, handle); | |
1243 | } | |
1244 | ||
978df1b6 | 1245 | static int nbd_co_send_simple_reply(NBDClient *client, |
14cea41d VSO |
1246 | uint64_t handle, |
1247 | uint32_t error, | |
978df1b6 VSO |
1248 | void *data, |
1249 | size_t len, | |
1250 | Error **errp) | |
22045592 | 1251 | { |
de79bfc3 | 1252 | NBDSimpleReply reply; |
14cea41d | 1253 | int nbd_err = system_errno_to_nbd_errno(error); |
de79bfc3 VSO |
1254 | struct iovec iov[] = { |
1255 | {.iov_base = &reply, .iov_len = sizeof(reply)}, | |
1256 | {.iov_base = data, .iov_len = len} | |
1257 | }; | |
6fb2b972 | 1258 | |
e7a78d0e EB |
1259 | trace_nbd_co_send_simple_reply(handle, nbd_err, nbd_err_lookup(nbd_err), |
1260 | len); | |
de79bfc3 | 1261 | set_be_simple_reply(&reply, nbd_err, handle); |
262db388 | 1262 | |
de79bfc3 | 1263 | return nbd_co_send_iov(client, iov, len ? 2 : 1, errp); |
22045592 PB |
1264 | } |
1265 | ||
5c54e7fa VSO |
1266 | static inline void set_be_chunk(NBDStructuredReplyChunk *chunk, uint16_t flags, |
1267 | uint16_t type, uint64_t handle, uint32_t length) | |
1268 | { | |
1269 | stl_be_p(&chunk->magic, NBD_STRUCTURED_REPLY_MAGIC); | |
1270 | stw_be_p(&chunk->flags, flags); | |
1271 | stw_be_p(&chunk->type, type); | |
1272 | stq_be_p(&chunk->handle, handle); | |
1273 | stl_be_p(&chunk->length, length); | |
1274 | } | |
1275 | ||
ef8c887e EB |
1276 | static int coroutine_fn nbd_co_send_structured_done(NBDClient *client, |
1277 | uint64_t handle, | |
1278 | Error **errp) | |
1279 | { | |
1280 | NBDStructuredReplyChunk chunk; | |
1281 | struct iovec iov[] = { | |
1282 | {.iov_base = &chunk, .iov_len = sizeof(chunk)}, | |
1283 | }; | |
1284 | ||
1285 | trace_nbd_co_send_structured_done(handle); | |
1286 | set_be_chunk(&chunk, NBD_REPLY_FLAG_DONE, NBD_REPLY_TYPE_NONE, handle, 0); | |
1287 | ||
1288 | return nbd_co_send_iov(client, iov, 1, errp); | |
1289 | } | |
1290 | ||
5c54e7fa VSO |
1291 | static int coroutine_fn nbd_co_send_structured_read(NBDClient *client, |
1292 | uint64_t handle, | |
1293 | uint64_t offset, | |
1294 | void *data, | |
1295 | size_t size, | |
1296 | Error **errp) | |
1297 | { | |
efdc0c10 | 1298 | NBDStructuredReadData chunk; |
5c54e7fa VSO |
1299 | struct iovec iov[] = { |
1300 | {.iov_base = &chunk, .iov_len = sizeof(chunk)}, | |
1301 | {.iov_base = data, .iov_len = size} | |
1302 | }; | |
1303 | ||
ef8c887e | 1304 | assert(size); |
5c54e7fa VSO |
1305 | trace_nbd_co_send_structured_read(handle, offset, data, size); |
1306 | set_be_chunk(&chunk.h, NBD_REPLY_FLAG_DONE, NBD_REPLY_TYPE_OFFSET_DATA, | |
1307 | handle, sizeof(chunk) - sizeof(chunk.h) + size); | |
1308 | stq_be_p(&chunk.offset, offset); | |
1309 | ||
1310 | return nbd_co_send_iov(client, iov, 2, errp); | |
1311 | } | |
1312 | ||
1313 | static int coroutine_fn nbd_co_send_structured_error(NBDClient *client, | |
1314 | uint64_t handle, | |
1315 | uint32_t error, | |
a57f6dea | 1316 | const char *msg, |
5c54e7fa VSO |
1317 | Error **errp) |
1318 | { | |
1319 | NBDStructuredError chunk; | |
1320 | int nbd_err = system_errno_to_nbd_errno(error); | |
1321 | struct iovec iov[] = { | |
1322 | {.iov_base = &chunk, .iov_len = sizeof(chunk)}, | |
a57f6dea | 1323 | {.iov_base = (char *)msg, .iov_len = msg ? strlen(msg) : 0}, |
5c54e7fa VSO |
1324 | }; |
1325 | ||
1326 | assert(nbd_err); | |
1327 | trace_nbd_co_send_structured_error(handle, nbd_err, | |
a57f6dea | 1328 | nbd_err_lookup(nbd_err), msg ? msg : ""); |
5c54e7fa | 1329 | set_be_chunk(&chunk.h, NBD_REPLY_FLAG_DONE, NBD_REPLY_TYPE_ERROR, handle, |
a57f6dea | 1330 | sizeof(chunk) - sizeof(chunk.h) + iov[1].iov_len); |
5c54e7fa | 1331 | stl_be_p(&chunk.error, nbd_err); |
a57f6dea | 1332 | stw_be_p(&chunk.message_length, iov[1].iov_len); |
5c54e7fa | 1333 | |
a57f6dea | 1334 | return nbd_co_send_iov(client, iov, 1 + !!iov[1].iov_len, errp); |
5c54e7fa VSO |
1335 | } |
1336 | ||
2a6e128b VSO |
1337 | /* nbd_co_receive_request |
1338 | * Collect a client request. Return 0 if request looks valid, -EIO to drop | |
1339 | * connection right away, and any other negative value to report an error to | |
1340 | * the client (although the caller may still need to disconnect after reporting | |
1341 | * the error). | |
1342 | */ | |
2fd2c840 VSO |
1343 | static int nbd_co_receive_request(NBDRequestData *req, NBDRequest *request, |
1344 | Error **errp) | |
a030b347 | 1345 | { |
72deddc5 | 1346 | NBDClient *client = req->client; |
5c54e7fa | 1347 | int valid_flags; |
a030b347 | 1348 | |
1c778ef7 | 1349 | g_assert(qemu_in_coroutine()); |
ff82911c | 1350 | assert(client->recv_coroutine == qemu_coroutine_self()); |
2fd2c840 | 1351 | if (nbd_receive_request(client->ioc, request, errp) < 0) { |
ee898b87 | 1352 | return -EIO; |
a030b347 PB |
1353 | } |
1354 | ||
3736cc5b EB |
1355 | trace_nbd_co_receive_request_decode_type(request->handle, request->type, |
1356 | nbd_cmd_lookup(request->type)); | |
29b6c3b3 | 1357 | |
b626b51a | 1358 | if (request->type != NBD_CMD_WRITE) { |
29b6c3b3 EB |
1359 | /* No payload, we are ready to read the next request. */ |
1360 | req->complete = true; | |
1361 | } | |
1362 | ||
b626b51a | 1363 | if (request->type == NBD_CMD_DISC) { |
29b6c3b3 EB |
1364 | /* Special case: we're going to disconnect without a reply, |
1365 | * whether or not flags, from, or len are bogus */ | |
ee898b87 | 1366 | return -EIO; |
29b6c3b3 EB |
1367 | } |
1368 | ||
b626b51a | 1369 | if (request->type == NBD_CMD_READ || request->type == NBD_CMD_WRITE) { |
eb38c3b6 | 1370 | if (request->len > NBD_MAX_BUFFER_SIZE) { |
2fd2c840 VSO |
1371 | error_setg(errp, "len (%" PRIu32" ) is larger than max len (%u)", |
1372 | request->len, NBD_MAX_BUFFER_SIZE); | |
ee898b87 | 1373 | return -EINVAL; |
eb38c3b6 PB |
1374 | } |
1375 | ||
f1c17521 PB |
1376 | req->data = blk_try_blockalign(client->exp->blk, request->len); |
1377 | if (req->data == NULL) { | |
2fd2c840 | 1378 | error_setg(errp, "No memory"); |
ee898b87 | 1379 | return -ENOMEM; |
f1c17521 | 1380 | } |
2d821488 | 1381 | } |
b626b51a | 1382 | if (request->type == NBD_CMD_WRITE) { |
2fd2c840 VSO |
1383 | if (nbd_read(client->ioc, req->data, request->len, errp) < 0) { |
1384 | error_prepend(errp, "reading from socket failed: "); | |
ee898b87 | 1385 | return -EIO; |
a030b347 | 1386 | } |
29b6c3b3 | 1387 | req->complete = true; |
6fb2b972 | 1388 | |
9588463e VSO |
1389 | trace_nbd_co_receive_request_payload_received(request->handle, |
1390 | request->len); | |
a030b347 | 1391 | } |
29b6c3b3 | 1392 | |
fed5f8f8 EB |
1393 | /* Sanity checks. */ |
1394 | if (client->exp->nbdflags & NBD_FLAG_READ_ONLY && | |
1395 | (request->type == NBD_CMD_WRITE || | |
1396 | request->type == NBD_CMD_WRITE_ZEROES || | |
1397 | request->type == NBD_CMD_TRIM)) { | |
1398 | error_setg(errp, "Export is read-only"); | |
1399 | return -EROFS; | |
1400 | } | |
1401 | if (request->from > client->exp->size || | |
1402 | request->from + request->len > client->exp->size) { | |
2fd2c840 VSO |
1403 | error_setg(errp, "operation past EOF; From: %" PRIu64 ", Len: %" PRIu32 |
1404 | ", Size: %" PRIu64, request->from, request->len, | |
1405 | (uint64_t)client->exp->size); | |
fed5f8f8 EB |
1406 | return (request->type == NBD_CMD_WRITE || |
1407 | request->type == NBD_CMD_WRITE_ZEROES) ? -ENOSPC : -EINVAL; | |
29b6c3b3 | 1408 | } |
5c54e7fa VSO |
1409 | valid_flags = NBD_CMD_FLAG_FUA; |
1410 | if (request->type == NBD_CMD_READ && client->structured_reply) { | |
1411 | valid_flags |= NBD_CMD_FLAG_DF; | |
1412 | } else if (request->type == NBD_CMD_WRITE_ZEROES) { | |
1413 | valid_flags |= NBD_CMD_FLAG_NO_HOLE; | |
ab7c548e | 1414 | } |
5c54e7fa VSO |
1415 | if (request->flags & ~valid_flags) { |
1416 | error_setg(errp, "unsupported flags for command %s (got 0x%x)", | |
1417 | nbd_cmd_lookup(request->type), request->flags); | |
ee898b87 | 1418 | return -EINVAL; |
1f4d6d18 | 1419 | } |
29b6c3b3 | 1420 | |
ee898b87 | 1421 | return 0; |
a030b347 PB |
1422 | } |
1423 | ||
ff82911c PB |
1424 | /* Owns a reference to the NBDClient passed as opaque. */ |
1425 | static coroutine_fn void nbd_trip(void *opaque) | |
75818250 | 1426 | { |
262db388 | 1427 | NBDClient *client = opaque; |
1743b515 | 1428 | NBDExport *exp = client->exp; |
315f78ab | 1429 | NBDRequestData *req; |
ff82911c | 1430 | NBDRequest request = { 0 }; /* GCC thinks it can be used uninitialized */ |
a0dc63a6 | 1431 | int ret; |
a0c30369 | 1432 | int flags; |
8c372a02 | 1433 | int reply_data_len = 0; |
2fd2c840 | 1434 | Error *local_err = NULL; |
a57f6dea | 1435 | char *msg = NULL; |
b2e3d87f | 1436 | |
9588463e | 1437 | trace_nbd_trip(); |
ff2b68aa | 1438 | if (client->closing) { |
ff82911c | 1439 | nbd_client_put(client); |
ff2b68aa PB |
1440 | return; |
1441 | } | |
b2e3d87f | 1442 | |
ff2b68aa | 1443 | req = nbd_request_get(client); |
2fd2c840 | 1444 | ret = nbd_co_receive_request(req, &request, &local_err); |
ee898b87 VSO |
1445 | client->recv_coroutine = NULL; |
1446 | nbd_client_receive_next_request(client); | |
a030b347 | 1447 | if (ret == -EIO) { |
8c372a02 | 1448 | goto disconnect; |
a030b347 | 1449 | } |
b2e3d87f | 1450 | |
a030b347 | 1451 | if (ret < 0) { |
8c372a02 | 1452 | goto reply; |
b2e3d87f | 1453 | } |
b2e3d87f | 1454 | |
d6268348 WC |
1455 | if (client->closing) { |
1456 | /* | |
1457 | * The client may be closed when we are blocked in | |
1458 | * nbd_co_receive_request() | |
1459 | */ | |
1460 | goto done; | |
1461 | } | |
1462 | ||
b626b51a | 1463 | switch (request.type) { |
b2e3d87f | 1464 | case NBD_CMD_READ: |
b626b51a EB |
1465 | /* XXX: NBD Protocol only documents use of FUA with WRITE */ |
1466 | if (request.flags & NBD_CMD_FLAG_FUA) { | |
aadf99a7 | 1467 | ret = blk_co_flush(exp->blk); |
e25ceb76 | 1468 | if (ret < 0) { |
2fd2c840 | 1469 | error_setg_errno(&local_err, -ret, "flush failed"); |
8c372a02 | 1470 | break; |
e25ceb76 PB |
1471 | } |
1472 | } | |
1473 | ||
df7b97ff EB |
1474 | ret = blk_pread(exp->blk, request.from + exp->dev_offset, |
1475 | req->data, request.len); | |
adcf6302 | 1476 | if (ret < 0) { |
2fd2c840 | 1477 | error_setg_errno(&local_err, -ret, "reading from file failed"); |
8c372a02 | 1478 | break; |
b2e3d87f | 1479 | } |
b2e3d87f | 1480 | |
8c372a02 | 1481 | reply_data_len = request.len; |
8c372a02 | 1482 | |
b2e3d87f NT |
1483 | break; |
1484 | case NBD_CMD_WRITE: | |
a0c30369 | 1485 | flags = 0; |
b626b51a | 1486 | if (request.flags & NBD_CMD_FLAG_FUA) { |
a0c30369 EB |
1487 | flags |= BDRV_REQ_FUA; |
1488 | } | |
df7b97ff | 1489 | ret = blk_pwrite(exp->blk, request.from + exp->dev_offset, |
a0c30369 | 1490 | req->data, request.len, flags); |
fae69416 | 1491 | if (ret < 0) { |
2fd2c840 | 1492 | error_setg_errno(&local_err, -ret, "writing to file failed"); |
fae69416 | 1493 | } |
b2e3d87f | 1494 | |
1f4d6d18 | 1495 | break; |
1f4d6d18 | 1496 | case NBD_CMD_WRITE_ZEROES: |
1f4d6d18 EB |
1497 | flags = 0; |
1498 | if (request.flags & NBD_CMD_FLAG_FUA) { | |
1499 | flags |= BDRV_REQ_FUA; | |
1500 | } | |
1501 | if (!(request.flags & NBD_CMD_FLAG_NO_HOLE)) { | |
1502 | flags |= BDRV_REQ_MAY_UNMAP; | |
1503 | } | |
1504 | ret = blk_pwrite_zeroes(exp->blk, request.from + exp->dev_offset, | |
1505 | request.len, flags); | |
1506 | if (ret < 0) { | |
2fd2c840 | 1507 | error_setg_errno(&local_err, -ret, "writing to file failed"); |
1f4d6d18 EB |
1508 | } |
1509 | ||
b2e3d87f NT |
1510 | break; |
1511 | case NBD_CMD_DISC: | |
29b6c3b3 EB |
1512 | /* unreachable, thanks to special case in nbd_co_receive_request() */ |
1513 | abort(); | |
1514 | ||
1486d04a | 1515 | case NBD_CMD_FLUSH: |
aadf99a7 | 1516 | ret = blk_co_flush(exp->blk); |
1486d04a | 1517 | if (ret < 0) { |
2fd2c840 | 1518 | error_setg_errno(&local_err, -ret, "flush failed"); |
1486d04a | 1519 | } |
8c372a02 | 1520 | |
7a706633 PB |
1521 | break; |
1522 | case NBD_CMD_TRIM: | |
1c6c4bb7 EB |
1523 | ret = blk_co_pdiscard(exp->blk, request.from + exp->dev_offset, |
1524 | request.len); | |
1525 | if (ret < 0) { | |
2fd2c840 | 1526 | error_setg_errno(&local_err, -ret, "discard failed"); |
7a706633 | 1527 | } |
8c372a02 | 1528 | |
1486d04a | 1529 | break; |
b2e3d87f | 1530 | default: |
2fd2c840 VSO |
1531 | error_setg(&local_err, "invalid request type (%" PRIu32 ") received", |
1532 | request.type); | |
14cea41d | 1533 | ret = -EINVAL; |
8c372a02 VSO |
1534 | } |
1535 | ||
1536 | reply: | |
2fd2c840 | 1537 | if (local_err) { |
14cea41d VSO |
1538 | /* If we get here, local_err was not a fatal error, and should be sent |
1539 | * to the client. */ | |
a57f6dea EB |
1540 | assert(ret < 0); |
1541 | msg = g_strdup(error_get_pretty(local_err)); | |
2fd2c840 VSO |
1542 | error_report_err(local_err); |
1543 | local_err = NULL; | |
1544 | } | |
1545 | ||
a57f6dea EB |
1546 | if (client->structured_reply && |
1547 | (ret < 0 || request.type == NBD_CMD_READ)) { | |
5c54e7fa VSO |
1548 | if (ret < 0) { |
1549 | ret = nbd_co_send_structured_error(req->client, request.handle, | |
a57f6dea | 1550 | -ret, msg, &local_err); |
ef8c887e | 1551 | } else if (reply_data_len) { |
5c54e7fa VSO |
1552 | ret = nbd_co_send_structured_read(req->client, request.handle, |
1553 | request.from, req->data, | |
1554 | reply_data_len, &local_err); | |
ef8c887e EB |
1555 | } else { |
1556 | ret = nbd_co_send_structured_done(req->client, request.handle, | |
1557 | &local_err); | |
5c54e7fa VSO |
1558 | } |
1559 | } else { | |
1560 | ret = nbd_co_send_simple_reply(req->client, request.handle, | |
1561 | ret < 0 ? -ret : 0, | |
1562 | req->data, reply_data_len, &local_err); | |
1563 | } | |
a57f6dea | 1564 | g_free(msg); |
5c54e7fa | 1565 | if (ret < 0) { |
c7b97282 | 1566 | error_prepend(&local_err, "Failed to send reply: "); |
2fd2c840 VSO |
1567 | goto disconnect; |
1568 | } | |
1569 | ||
8c372a02 VSO |
1570 | /* We must disconnect after NBD_CMD_WRITE if we did not |
1571 | * read the payload. | |
1572 | */ | |
2fd2c840 VSO |
1573 | if (!req->complete) { |
1574 | error_setg(&local_err, "Request handling failed in intermediate state"); | |
8c372a02 | 1575 | goto disconnect; |
b2e3d87f NT |
1576 | } |
1577 | ||
7fe7b68b | 1578 | done: |
262db388 | 1579 | nbd_request_put(req); |
ff82911c | 1580 | nbd_client_put(client); |
262db388 PB |
1581 | return; |
1582 | ||
8c372a02 | 1583 | disconnect: |
2fd2c840 VSO |
1584 | if (local_err) { |
1585 | error_reportf_err(local_err, "Disconnect client, due to: "); | |
1586 | } | |
72deddc5 | 1587 | nbd_request_put(req); |
0c9390d9 | 1588 | client_close(client, true); |
ff82911c | 1589 | nbd_client_put(client); |
7a5ca864 | 1590 | } |
af49bbbe | 1591 | |
ff82911c | 1592 | static void nbd_client_receive_next_request(NBDClient *client) |
958c717d | 1593 | { |
ff82911c PB |
1594 | if (!client->recv_coroutine && client->nb_requests < MAX_NBD_REQUESTS) { |
1595 | nbd_client_get(client); | |
1596 | client->recv_coroutine = qemu_coroutine_create(nbd_trip, client); | |
1597 | aio_co_schedule(client->exp->ctx, client->recv_coroutine); | |
958c717d HR |
1598 | } |
1599 | } | |
1600 | ||
1a6245a5 FZ |
1601 | static coroutine_fn void nbd_co_client_start(void *opaque) |
1602 | { | |
c84087f2 | 1603 | NBDClient *client = opaque; |
1a6245a5 | 1604 | NBDExport *exp = client->exp; |
2fd2c840 | 1605 | Error *local_err = NULL; |
1a6245a5 FZ |
1606 | |
1607 | if (exp) { | |
1608 | nbd_export_get(exp); | |
df8ad9f1 | 1609 | QTAILQ_INSERT_TAIL(&exp->clients, client, next); |
1a6245a5 | 1610 | } |
df8ad9f1 EB |
1611 | qemu_co_mutex_init(&client->send_lock); |
1612 | ||
2fd2c840 VSO |
1613 | if (nbd_negotiate(client, &local_err)) { |
1614 | if (local_err) { | |
1615 | error_report_err(local_err); | |
1616 | } | |
0c9390d9 | 1617 | client_close(client, false); |
c84087f2 | 1618 | return; |
1a6245a5 | 1619 | } |
ff82911c PB |
1620 | |
1621 | nbd_client_receive_next_request(client); | |
1a6245a5 FZ |
1622 | } |
1623 | ||
0c9390d9 EB |
1624 | /* |
1625 | * Create a new client listener on the given export @exp, using the | |
1626 | * given channel @sioc. Begin servicing it in a coroutine. When the | |
1627 | * connection closes, call @close_fn with an indication of whether the | |
1628 | * client completed negotiation. | |
1629 | */ | |
1c778ef7 DB |
1630 | void nbd_client_new(NBDExport *exp, |
1631 | QIOChannelSocket *sioc, | |
f95910fe DB |
1632 | QCryptoTLSCreds *tlscreds, |
1633 | const char *tlsaclname, | |
0c9390d9 | 1634 | void (*close_fn)(NBDClient *, bool)) |
af49bbbe | 1635 | { |
1743b515 | 1636 | NBDClient *client; |
c84087f2 | 1637 | Coroutine *co; |
1a6245a5 | 1638 | |
e8d3eb74 | 1639 | client = g_new0(NBDClient, 1); |
1743b515 PB |
1640 | client->refcount = 1; |
1641 | client->exp = exp; | |
f95910fe DB |
1642 | client->tlscreds = tlscreds; |
1643 | if (tlscreds) { | |
1644 | object_ref(OBJECT(client->tlscreds)); | |
1645 | } | |
1646 | client->tlsaclname = g_strdup(tlsaclname); | |
1c778ef7 DB |
1647 | client->sioc = sioc; |
1648 | object_ref(OBJECT(client->sioc)); | |
1649 | client->ioc = QIO_CHANNEL(sioc); | |
1650 | object_ref(OBJECT(client->ioc)); | |
0c9390d9 | 1651 | client->close_fn = close_fn; |
2c8d9f06 | 1652 | |
c84087f2 VSO |
1653 | co = qemu_coroutine_create(nbd_co_client_start, client); |
1654 | qemu_coroutine_enter(co); | |
af49bbbe | 1655 | } |