]>
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 | } | |
51ae4f84 EB |
389 | if (namelen >= sizeof(name)) { |
390 | msg = "name too long for qemu"; | |
391 | goto invalid; | |
392 | } | |
f37708f6 EB |
393 | if (nbd_read(client->ioc, name, namelen, errp) < 0) { |
394 | return -EIO; | |
395 | } | |
396 | name[namelen] = '\0'; | |
397 | length -= namelen; | |
398 | trace_nbd_negotiate_handle_export_name_request(name); | |
399 | ||
400 | if (nbd_read(client->ioc, &requests, sizeof(requests), errp) < 0) { | |
401 | return -EIO; | |
402 | } | |
403 | be16_to_cpus(&requests); | |
404 | length -= sizeof(requests); | |
405 | trace_nbd_negotiate_handle_info_requests(requests); | |
406 | if (requests != length / sizeof(request)) { | |
407 | msg = "incorrect number of requests for overall length"; | |
408 | goto invalid; | |
409 | } | |
410 | while (requests--) { | |
411 | if (nbd_read(client->ioc, &request, sizeof(request), errp) < 0) { | |
412 | return -EIO; | |
413 | } | |
414 | be16_to_cpus(&request); | |
415 | length -= sizeof(request); | |
416 | trace_nbd_negotiate_handle_info_request(request, | |
417 | nbd_info_lookup(request)); | |
0c1d50bd EB |
418 | /* We care about NBD_INFO_NAME and NBD_INFO_BLOCK_SIZE; |
419 | * everything else is either a request we don't know or | |
420 | * something we send regardless of request */ | |
421 | switch (request) { | |
422 | case NBD_INFO_NAME: | |
f37708f6 | 423 | sendname = true; |
0c1d50bd EB |
424 | break; |
425 | case NBD_INFO_BLOCK_SIZE: | |
426 | blocksize = true; | |
427 | break; | |
f37708f6 EB |
428 | } |
429 | } | |
46321d6b | 430 | assert(length == 0); |
f37708f6 EB |
431 | |
432 | exp = nbd_export_find(name); | |
433 | if (!exp) { | |
434 | return nbd_negotiate_send_rep_err(client->ioc, NBD_REP_ERR_UNKNOWN, | |
435 | opt, errp, "export '%s' not present", | |
436 | name); | |
437 | } | |
438 | ||
439 | /* Don't bother sending NBD_INFO_NAME unless client requested it */ | |
440 | if (sendname) { | |
46321d6b | 441 | rc = nbd_negotiate_send_info(client, opt, NBD_INFO_NAME, namelen, name, |
f37708f6 EB |
442 | errp); |
443 | if (rc < 0) { | |
444 | return rc; | |
445 | } | |
446 | } | |
447 | ||
448 | /* Send NBD_INFO_DESCRIPTION only if available, regardless of | |
449 | * client request */ | |
450 | if (exp->description) { | |
451 | size_t len = strlen(exp->description); | |
452 | ||
453 | rc = nbd_negotiate_send_info(client, opt, NBD_INFO_DESCRIPTION, | |
454 | len, exp->description, errp); | |
455 | if (rc < 0) { | |
456 | return rc; | |
457 | } | |
458 | } | |
459 | ||
0c1d50bd EB |
460 | /* Send NBD_INFO_BLOCK_SIZE always, but tweak the minimum size |
461 | * according to whether the client requested it, and according to | |
462 | * whether this is OPT_INFO or OPT_GO. */ | |
463 | /* minimum - 1 for back-compat, or 512 if client is new enough. | |
464 | * TODO: consult blk_bs(blk)->bl.request_alignment? */ | |
465 | sizes[0] = (opt == NBD_OPT_INFO || blocksize) ? BDRV_SECTOR_SIZE : 1; | |
466 | /* preferred - Hard-code to 4096 for now. | |
467 | * TODO: is blk_bs(blk)->bl.opt_transfer appropriate? */ | |
468 | sizes[1] = 4096; | |
469 | /* maximum - At most 32M, but smaller as appropriate. */ | |
470 | sizes[2] = MIN(blk_get_max_transfer(exp->blk), NBD_MAX_BUFFER_SIZE); | |
471 | trace_nbd_negotiate_handle_info_block_size(sizes[0], sizes[1], sizes[2]); | |
472 | cpu_to_be32s(&sizes[0]); | |
473 | cpu_to_be32s(&sizes[1]); | |
474 | cpu_to_be32s(&sizes[2]); | |
475 | rc = nbd_negotiate_send_info(client, opt, NBD_INFO_BLOCK_SIZE, | |
476 | sizeof(sizes), sizes, errp); | |
477 | if (rc < 0) { | |
478 | return rc; | |
479 | } | |
480 | ||
f37708f6 EB |
481 | /* Send NBD_INFO_EXPORT always */ |
482 | trace_nbd_negotiate_new_style_size_flags(exp->size, | |
483 | exp->nbdflags | myflags); | |
484 | stq_be_p(buf, exp->size); | |
485 | stw_be_p(buf + 8, exp->nbdflags | myflags); | |
486 | rc = nbd_negotiate_send_info(client, opt, NBD_INFO_EXPORT, | |
487 | sizeof(buf), buf, errp); | |
488 | if (rc < 0) { | |
489 | return rc; | |
490 | } | |
491 | ||
0c1d50bd EB |
492 | /* If the client is just asking for NBD_OPT_INFO, but forgot to |
493 | * request block sizes, return an error. | |
494 | * TODO: consult blk_bs(blk)->request_align, and only error if it | |
495 | * is not 1? */ | |
496 | if (opt == NBD_OPT_INFO && !blocksize) { | |
497 | return nbd_negotiate_send_rep_err(client->ioc, | |
498 | NBD_REP_ERR_BLOCK_SIZE_REQD, opt, | |
499 | errp, | |
500 | "request NBD_INFO_BLOCK_SIZE to " | |
501 | "use this export"); | |
502 | } | |
503 | ||
f37708f6 EB |
504 | /* Final reply */ |
505 | rc = nbd_negotiate_send_rep(client->ioc, NBD_REP_ACK, opt, errp); | |
506 | if (rc < 0) { | |
507 | return rc; | |
508 | } | |
509 | ||
510 | if (opt == NBD_OPT_GO) { | |
511 | client->exp = exp; | |
512 | QTAILQ_INSERT_TAIL(&client->exp->clients, client, next); | |
513 | nbd_export_get(client->exp); | |
514 | rc = 1; | |
515 | } | |
516 | return rc; | |
517 | ||
518 | invalid: | |
519 | if (nbd_drop(client->ioc, length, errp) < 0) { | |
520 | return -EIO; | |
521 | } | |
522 | return nbd_negotiate_send_rep_err(client->ioc, NBD_REP_ERR_INVALID, opt, | |
523 | errp, "%s", msg); | |
524 | } | |
525 | ||
526 | ||
36683283 EB |
527 | /* Handle NBD_OPT_STARTTLS. Return NULL to drop connection, or else the |
528 | * new channel for all further (now-encrypted) communication. */ | |
f95910fe | 529 | static QIOChannel *nbd_negotiate_handle_starttls(NBDClient *client, |
2fd2c840 | 530 | Error **errp) |
f95910fe DB |
531 | { |
532 | QIOChannel *ioc; | |
533 | QIOChannelTLS *tioc; | |
534 | struct NBDTLSHandshakeData data = { 0 }; | |
535 | ||
9588463e | 536 | trace_nbd_negotiate_handle_starttls(); |
f95910fe | 537 | ioc = client->ioc; |
f95910fe | 538 | |
63d5ef86 | 539 | if (nbd_negotiate_send_rep(client->ioc, NBD_REP_ACK, |
2fd2c840 | 540 | NBD_OPT_STARTTLS, errp) < 0) { |
63d5ef86 EB |
541 | return NULL; |
542 | } | |
f95910fe DB |
543 | |
544 | tioc = qio_channel_tls_new_server(ioc, | |
545 | client->tlscreds, | |
546 | client->tlsaclname, | |
2fd2c840 | 547 | errp); |
f95910fe DB |
548 | if (!tioc) { |
549 | return NULL; | |
550 | } | |
551 | ||
0d73f725 | 552 | qio_channel_set_name(QIO_CHANNEL(tioc), "nbd-server-tls"); |
9588463e | 553 | trace_nbd_negotiate_handle_starttls_handshake(); |
f95910fe DB |
554 | data.loop = g_main_loop_new(g_main_context_default(), FALSE); |
555 | qio_channel_tls_handshake(tioc, | |
556 | nbd_tls_handshake, | |
557 | &data, | |
558 | NULL); | |
559 | ||
560 | if (!data.complete) { | |
561 | g_main_loop_run(data.loop); | |
562 | } | |
563 | g_main_loop_unref(data.loop); | |
564 | if (data.error) { | |
565 | object_unref(OBJECT(tioc)); | |
2fd2c840 | 566 | error_propagate(errp, data.error); |
f95910fe DB |
567 | return NULL; |
568 | } | |
569 | ||
570 | return QIO_CHANNEL(tioc); | |
571 | } | |
572 | ||
e68c35cf EB |
573 | /* nbd_reject_length: Handle any unexpected payload. |
574 | * @fatal requests that we quit talking to the client, even if we are able | |
575 | * to successfully send an error to the guest. | |
576 | * Return: | |
577 | * -errno transmission error occurred or @fatal was requested, errp is set | |
578 | * 0 error message successfully sent to client, errp is not set | |
579 | */ | |
580 | static int nbd_reject_length(NBDClient *client, uint32_t length, | |
581 | uint32_t option, bool fatal, Error **errp) | |
582 | { | |
583 | int ret; | |
584 | ||
585 | assert(length); | |
586 | if (nbd_drop(client->ioc, length, errp) < 0) { | |
587 | return -EIO; | |
588 | } | |
589 | ret = nbd_negotiate_send_rep_err(client->ioc, NBD_REP_ERR_INVALID, | |
590 | option, errp, | |
591 | "option '%s' should have zero length", | |
592 | nbd_opt_lookup(option)); | |
593 | if (fatal && !ret) { | |
594 | error_setg(errp, "option '%s' should have zero length", | |
595 | nbd_opt_lookup(option)); | |
596 | return -EINVAL; | |
597 | } | |
598 | return ret; | |
599 | } | |
600 | ||
1e120ffe | 601 | /* nbd_negotiate_options |
f37708f6 EB |
602 | * Process all NBD_OPT_* client option commands, during fixed newstyle |
603 | * negotiation. | |
1e120ffe | 604 | * Return: |
2fd2c840 VSO |
605 | * -errno on error, errp is set |
606 | * 0 on successful negotiation, errp is not set | |
607 | * 1 if client sent NBD_OPT_ABORT, i.e. on valid disconnect, | |
608 | * errp is not set | |
1e120ffe | 609 | */ |
23e099c3 EB |
610 | static int nbd_negotiate_options(NBDClient *client, uint16_t myflags, |
611 | Error **errp) | |
f5076b5a | 612 | { |
9c122ada | 613 | uint32_t flags; |
26afa868 | 614 | bool fixedNewstyle = false; |
23e099c3 | 615 | bool no_zeroes = false; |
9c122ada HR |
616 | |
617 | /* Client sends: | |
618 | [ 0 .. 3] client flags | |
619 | ||
f37708f6 | 620 | Then we loop until NBD_OPT_EXPORT_NAME or NBD_OPT_GO: |
9c122ada HR |
621 | [ 0 .. 7] NBD_OPTS_MAGIC |
622 | [ 8 .. 11] NBD option | |
623 | [12 .. 15] Data length | |
624 | ... Rest of request | |
625 | ||
626 | [ 0 .. 7] NBD_OPTS_MAGIC | |
627 | [ 8 .. 11] Second NBD option | |
628 | [12 .. 15] Data length | |
629 | ... Rest of request | |
630 | */ | |
631 | ||
2fd2c840 VSO |
632 | if (nbd_read(client->ioc, &flags, sizeof(flags), errp) < 0) { |
633 | error_prepend(errp, "read failed: "); | |
9c122ada HR |
634 | return -EIO; |
635 | } | |
9c122ada | 636 | be32_to_cpus(&flags); |
621c4f4e | 637 | trace_nbd_negotiate_options_flags(flags); |
26afa868 | 638 | if (flags & NBD_FLAG_C_FIXED_NEWSTYLE) { |
26afa868 DB |
639 | fixedNewstyle = true; |
640 | flags &= ~NBD_FLAG_C_FIXED_NEWSTYLE; | |
641 | } | |
c203c59a | 642 | if (flags & NBD_FLAG_C_NO_ZEROES) { |
23e099c3 | 643 | no_zeroes = true; |
c203c59a EB |
644 | flags &= ~NBD_FLAG_C_NO_ZEROES; |
645 | } | |
26afa868 | 646 | if (flags != 0) { |
2fd2c840 | 647 | error_setg(errp, "Unknown client flags 0x%" PRIx32 " received", flags); |
621c4f4e | 648 | return -EINVAL; |
9c122ada HR |
649 | } |
650 | ||
f5076b5a | 651 | while (1) { |
9c122ada | 652 | int ret; |
7f9039cd | 653 | uint32_t option, length; |
f5076b5a HB |
654 | uint64_t magic; |
655 | ||
2fd2c840 VSO |
656 | if (nbd_read(client->ioc, &magic, sizeof(magic), errp) < 0) { |
657 | error_prepend(errp, "read failed: "); | |
f5076b5a HB |
658 | return -EINVAL; |
659 | } | |
9588463e VSO |
660 | magic = be64_to_cpu(magic); |
661 | trace_nbd_negotiate_options_check_magic(magic); | |
662 | if (magic != NBD_OPTS_MAGIC) { | |
2fd2c840 | 663 | error_setg(errp, "Bad magic received"); |
f5076b5a HB |
664 | return -EINVAL; |
665 | } | |
666 | ||
7f9039cd VSO |
667 | if (nbd_read(client->ioc, &option, |
668 | sizeof(option), errp) < 0) { | |
2fd2c840 | 669 | error_prepend(errp, "read failed: "); |
f5076b5a HB |
670 | return -EINVAL; |
671 | } | |
7f9039cd | 672 | option = be32_to_cpu(option); |
f5076b5a | 673 | |
2fd2c840 VSO |
674 | if (nbd_read(client->ioc, &length, sizeof(length), errp) < 0) { |
675 | error_prepend(errp, "read failed: "); | |
f5076b5a HB |
676 | return -EINVAL; |
677 | } | |
678 | length = be32_to_cpu(length); | |
679 | ||
fdad35ef EB |
680 | if (length > NBD_MAX_BUFFER_SIZE) { |
681 | error_setg(errp, "len (%" PRIu32" ) is larger than max len (%u)", | |
682 | length, NBD_MAX_BUFFER_SIZE); | |
683 | return -EINVAL; | |
684 | } | |
685 | ||
3736cc5b EB |
686 | trace_nbd_negotiate_options_check_option(option, |
687 | nbd_opt_lookup(option)); | |
f95910fe DB |
688 | if (client->tlscreds && |
689 | client->ioc == (QIOChannel *)client->sioc) { | |
690 | QIOChannel *tioc; | |
691 | if (!fixedNewstyle) { | |
7f9039cd | 692 | error_setg(errp, "Unsupported option 0x%" PRIx32, option); |
f95910fe DB |
693 | return -EINVAL; |
694 | } | |
7f9039cd | 695 | switch (option) { |
f95910fe | 696 | case NBD_OPT_STARTTLS: |
e68c35cf EB |
697 | if (length) { |
698 | /* Unconditionally drop the connection if the client | |
699 | * can't start a TLS negotiation correctly */ | |
700 | return nbd_reject_length(client, length, option, true, | |
701 | errp); | |
702 | } | |
703 | tioc = nbd_negotiate_handle_starttls(client, errp); | |
f95910fe DB |
704 | if (!tioc) { |
705 | return -EIO; | |
706 | } | |
8cbee49e | 707 | ret = 0; |
f95910fe DB |
708 | object_unref(OBJECT(client->ioc)); |
709 | client->ioc = QIO_CHANNEL(tioc); | |
710 | break; | |
711 | ||
d1129a8a EB |
712 | case NBD_OPT_EXPORT_NAME: |
713 | /* No way to return an error to client, so drop connection */ | |
2fd2c840 | 714 | error_setg(errp, "Option 0x%x not permitted before TLS", |
7f9039cd | 715 | option); |
d1129a8a EB |
716 | return -EINVAL; |
717 | ||
f95910fe | 718 | default: |
2fd2c840 | 719 | if (nbd_drop(client->ioc, length, errp) < 0) { |
d1129a8a EB |
720 | return -EIO; |
721 | } | |
36683283 EB |
722 | ret = nbd_negotiate_send_rep_err(client->ioc, |
723 | NBD_REP_ERR_TLS_REQD, | |
7f9039cd | 724 | option, errp, |
36683283 EB |
725 | "Option 0x%" PRIx32 |
726 | "not permitted before TLS", | |
7f9039cd | 727 | option); |
37ec36f6 EB |
728 | /* Let the client keep trying, unless they asked to |
729 | * quit. In this mode, we've already sent an error, so | |
730 | * we can't ack the abort. */ | |
7f9039cd | 731 | if (option == NBD_OPT_ABORT) { |
1e120ffe | 732 | return 1; |
b6f5d3b5 | 733 | } |
d1129a8a | 734 | break; |
f95910fe DB |
735 | } |
736 | } else if (fixedNewstyle) { | |
7f9039cd | 737 | switch (option) { |
26afa868 | 738 | case NBD_OPT_LIST: |
e68c35cf EB |
739 | if (length) { |
740 | ret = nbd_reject_length(client, length, option, false, | |
741 | errp); | |
742 | } else { | |
743 | ret = nbd_negotiate_handle_list(client, errp); | |
744 | } | |
26afa868 DB |
745 | break; |
746 | ||
747 | case NBD_OPT_ABORT: | |
b6f5d3b5 EB |
748 | /* NBD spec says we must try to reply before |
749 | * disconnecting, but that we must also tolerate | |
750 | * guests that don't wait for our reply. */ | |
37ec36f6 | 751 | nbd_negotiate_send_rep(client->ioc, NBD_REP_ACK, option, NULL); |
1e120ffe | 752 | return 1; |
26afa868 DB |
753 | |
754 | case NBD_OPT_EXPORT_NAME: | |
23e099c3 EB |
755 | return nbd_negotiate_handle_export_name(client, length, |
756 | myflags, no_zeroes, | |
757 | errp); | |
26afa868 | 758 | |
f37708f6 EB |
759 | case NBD_OPT_INFO: |
760 | case NBD_OPT_GO: | |
761 | ret = nbd_negotiate_handle_info(client, length, option, | |
762 | myflags, errp); | |
763 | if (ret == 1) { | |
764 | assert(option == NBD_OPT_GO); | |
765 | return 0; | |
766 | } | |
f37708f6 EB |
767 | break; |
768 | ||
f95910fe | 769 | case NBD_OPT_STARTTLS: |
e68c35cf EB |
770 | if (length) { |
771 | ret = nbd_reject_length(client, length, option, false, | |
772 | errp); | |
773 | } else if (client->tlscreds) { | |
36683283 EB |
774 | ret = nbd_negotiate_send_rep_err(client->ioc, |
775 | NBD_REP_ERR_INVALID, | |
7f9039cd | 776 | option, errp, |
36683283 | 777 | "TLS already enabled"); |
f95910fe | 778 | } else { |
36683283 EB |
779 | ret = nbd_negotiate_send_rep_err(client->ioc, |
780 | NBD_REP_ERR_POLICY, | |
7f9039cd | 781 | option, errp, |
36683283 | 782 | "TLS not configured"); |
63d5ef86 | 783 | } |
d1129a8a | 784 | break; |
5c54e7fa VSO |
785 | |
786 | case NBD_OPT_STRUCTURED_REPLY: | |
787 | if (length) { | |
788 | ret = nbd_reject_length(client, length, option, false, | |
789 | errp); | |
790 | } else if (client->structured_reply) { | |
791 | ret = nbd_negotiate_send_rep_err( | |
792 | client->ioc, NBD_REP_ERR_INVALID, option, errp, | |
793 | "structured reply already negotiated"); | |
794 | } else { | |
795 | ret = nbd_negotiate_send_rep(client->ioc, NBD_REP_ACK, | |
796 | option, errp); | |
797 | client->structured_reply = true; | |
798 | myflags |= NBD_FLAG_SEND_DF; | |
799 | } | |
800 | break; | |
801 | ||
26afa868 | 802 | default: |
2fd2c840 | 803 | if (nbd_drop(client->ioc, length, errp) < 0) { |
156f6a10 EB |
804 | return -EIO; |
805 | } | |
36683283 EB |
806 | ret = nbd_negotiate_send_rep_err(client->ioc, |
807 | NBD_REP_ERR_UNSUP, | |
7f9039cd | 808 | option, errp, |
36683283 | 809 | "Unsupported option 0x%" |
3736cc5b EB |
810 | PRIx32 " (%s)", option, |
811 | nbd_opt_lookup(option)); | |
156f6a10 | 812 | break; |
26afa868 DB |
813 | } |
814 | } else { | |
815 | /* | |
816 | * If broken new-style we should drop the connection | |
817 | * for anything except NBD_OPT_EXPORT_NAME | |
818 | */ | |
7f9039cd | 819 | switch (option) { |
26afa868 | 820 | case NBD_OPT_EXPORT_NAME: |
23e099c3 EB |
821 | return nbd_negotiate_handle_export_name(client, length, |
822 | myflags, no_zeroes, | |
823 | errp); | |
26afa868 DB |
824 | |
825 | default: | |
3736cc5b EB |
826 | error_setg(errp, "Unsupported option 0x%" PRIx32 " (%s)", |
827 | option, nbd_opt_lookup(option)); | |
26afa868 | 828 | return -EINVAL; |
32d7d2e0 | 829 | } |
f5076b5a | 830 | } |
8cbee49e EB |
831 | if (ret < 0) { |
832 | return ret; | |
833 | } | |
f5076b5a HB |
834 | } |
835 | } | |
836 | ||
1e120ffe VSO |
837 | /* nbd_negotiate |
838 | * Return: | |
2fd2c840 VSO |
839 | * -errno on error, errp is set |
840 | * 0 on successful negotiation, errp is not set | |
841 | * 1 if client sent NBD_OPT_ABORT, i.e. on valid disconnect, | |
842 | * errp is not set | |
1e120ffe | 843 | */ |
2fd2c840 | 844 | static coroutine_fn int nbd_negotiate(NBDClient *client, Error **errp) |
7a5ca864 | 845 | { |
5f66d060 | 846 | char buf[NBD_OLDSTYLE_NEGOTIATE_SIZE] = ""; |
2e5c9ad6 | 847 | int ret; |
7423f417 | 848 | const uint16_t myflags = (NBD_FLAG_HAS_FLAGS | NBD_FLAG_SEND_TRIM | |
1f4d6d18 EB |
849 | NBD_FLAG_SEND_FLUSH | NBD_FLAG_SEND_FUA | |
850 | NBD_FLAG_SEND_WRITE_ZEROES); | |
f95910fe | 851 | bool oldStyle; |
b2e3d87f | 852 | |
5f66d060 | 853 | /* Old style negotiation header, no room for options |
6b8c01e7 PB |
854 | [ 0 .. 7] passwd ("NBDMAGIC") |
855 | [ 8 .. 15] magic (NBD_CLIENT_MAGIC) | |
b2e3d87f | 856 | [16 .. 23] size |
5f66d060 | 857 | [24 .. 27] export flags (zero-extended) |
6b8c01e7 PB |
858 | [28 .. 151] reserved (0) |
859 | ||
5f66d060 | 860 | New style negotiation header, client can send options |
6b8c01e7 PB |
861 | [ 0 .. 7] passwd ("NBDMAGIC") |
862 | [ 8 .. 15] magic (NBD_OPTS_MAGIC) | |
863 | [16 .. 17] server flags (0) | |
f37708f6 | 864 | ....options sent, ending in NBD_OPT_EXPORT_NAME or NBD_OPT_GO.... |
b2e3d87f NT |
865 | */ |
866 | ||
1c778ef7 | 867 | qio_channel_set_blocking(client->ioc, false, NULL); |
185b4338 | 868 | |
9588463e | 869 | trace_nbd_negotiate_begin(); |
b2e3d87f | 870 | memcpy(buf, "NBDMAGIC", 8); |
f95910fe DB |
871 | |
872 | oldStyle = client->exp != NULL && !client->tlscreds; | |
873 | if (oldStyle) { | |
9588463e VSO |
874 | trace_nbd_negotiate_old_style(client->exp->size, |
875 | client->exp->nbdflags | myflags); | |
667ad26f JS |
876 | stq_be_p(buf + 8, NBD_CLIENT_MAGIC); |
877 | stq_be_p(buf + 16, client->exp->size); | |
5f66d060 | 878 | stl_be_p(buf + 24, client->exp->nbdflags | myflags); |
b2e3d87f | 879 | |
2fd2c840 VSO |
880 | if (nbd_write(client->ioc, buf, sizeof(buf), errp) < 0) { |
881 | error_prepend(errp, "write failed: "); | |
d9faeed8 | 882 | return -EINVAL; |
6b8c01e7 PB |
883 | } |
884 | } else { | |
76ff081d VSO |
885 | stq_be_p(buf + 8, NBD_OPTS_MAGIC); |
886 | stw_be_p(buf + 16, NBD_FLAG_FIXED_NEWSTYLE | NBD_FLAG_NO_ZEROES); | |
887 | ||
2fd2c840 VSO |
888 | if (nbd_write(client->ioc, buf, 18, errp) < 0) { |
889 | error_prepend(errp, "write failed: "); | |
d9faeed8 | 890 | return -EINVAL; |
6b8c01e7 | 891 | } |
23e099c3 | 892 | ret = nbd_negotiate_options(client, myflags, errp); |
2e5c9ad6 | 893 | if (ret != 0) { |
2fd2c840 VSO |
894 | if (ret < 0) { |
895 | error_prepend(errp, "option negotiation failed: "); | |
896 | } | |
2e5c9ad6 | 897 | return ret; |
6b8c01e7 | 898 | } |
b2e3d87f NT |
899 | } |
900 | ||
9588463e | 901 | trace_nbd_negotiate_success(); |
d9faeed8 VSO |
902 | |
903 | return 0; | |
7a5ca864 FB |
904 | } |
905 | ||
2fd2c840 VSO |
906 | static int nbd_receive_request(QIOChannel *ioc, NBDRequest *request, |
907 | Error **errp) | |
75818250 | 908 | { |
fa26c26b | 909 | uint8_t buf[NBD_REQUEST_SIZE]; |
b2e3d87f | 910 | uint32_t magic; |
a0dc63a6 | 911 | int ret; |
b2e3d87f | 912 | |
2fd2c840 | 913 | ret = nbd_read(ioc, buf, sizeof(buf), errp); |
185b4338 PB |
914 | if (ret < 0) { |
915 | return ret; | |
916 | } | |
917 | ||
b2e3d87f NT |
918 | /* Request |
919 | [ 0 .. 3] magic (NBD_REQUEST_MAGIC) | |
b626b51a EB |
920 | [ 4 .. 5] flags (NBD_CMD_FLAG_FUA, ...) |
921 | [ 6 .. 7] type (NBD_CMD_READ, ...) | |
b2e3d87f NT |
922 | [ 8 .. 15] handle |
923 | [16 .. 23] from | |
924 | [24 .. 27] len | |
925 | */ | |
926 | ||
773dce3c | 927 | magic = ldl_be_p(buf); |
b626b51a EB |
928 | request->flags = lduw_be_p(buf + 4); |
929 | request->type = lduw_be_p(buf + 6); | |
773dce3c PM |
930 | request->handle = ldq_be_p(buf + 8); |
931 | request->from = ldq_be_p(buf + 16); | |
932 | request->len = ldl_be_p(buf + 24); | |
b2e3d87f | 933 | |
9588463e VSO |
934 | trace_nbd_receive_request(magic, request->flags, request->type, |
935 | request->from, request->len); | |
b2e3d87f NT |
936 | |
937 | if (magic != NBD_REQUEST_MAGIC) { | |
2fd2c840 | 938 | error_setg(errp, "invalid magic (got 0x%" PRIx32 ")", magic); |
185b4338 | 939 | return -EINVAL; |
b2e3d87f NT |
940 | } |
941 | return 0; | |
75818250 TS |
942 | } |
943 | ||
41996e38 PB |
944 | #define MAX_NBD_REQUESTS 16 |
945 | ||
ce33967a | 946 | void nbd_client_get(NBDClient *client) |
1743b515 PB |
947 | { |
948 | client->refcount++; | |
949 | } | |
950 | ||
ce33967a | 951 | void nbd_client_put(NBDClient *client) |
1743b515 PB |
952 | { |
953 | if (--client->refcount == 0) { | |
ff2b68aa | 954 | /* The last reference should be dropped by client->close, |
f53a829b | 955 | * which is called by client_close. |
ff2b68aa PB |
956 | */ |
957 | assert(client->closing); | |
958 | ||
ff82911c | 959 | qio_channel_detach_aio_context(client->ioc); |
1c778ef7 DB |
960 | object_unref(OBJECT(client->sioc)); |
961 | object_unref(OBJECT(client->ioc)); | |
f95910fe DB |
962 | if (client->tlscreds) { |
963 | object_unref(OBJECT(client->tlscreds)); | |
964 | } | |
965 | g_free(client->tlsaclname); | |
6b8c01e7 PB |
966 | if (client->exp) { |
967 | QTAILQ_REMOVE(&client->exp->clients, client, next); | |
968 | nbd_export_put(client->exp); | |
969 | } | |
1743b515 PB |
970 | g_free(client); |
971 | } | |
972 | } | |
973 | ||
0c9390d9 | 974 | static void client_close(NBDClient *client, bool negotiated) |
1743b515 | 975 | { |
ff2b68aa PB |
976 | if (client->closing) { |
977 | return; | |
978 | } | |
979 | ||
980 | client->closing = true; | |
981 | ||
982 | /* Force requests to finish. They will drop their own references, | |
983 | * then we'll close the socket and free the NBDClient. | |
984 | */ | |
1c778ef7 DB |
985 | qio_channel_shutdown(client->ioc, QIO_CHANNEL_SHUTDOWN_BOTH, |
986 | NULL); | |
ff2b68aa PB |
987 | |
988 | /* Also tell the client, so that they release their reference. */ | |
0c9390d9 EB |
989 | if (client->close_fn) { |
990 | client->close_fn(client, negotiated); | |
1743b515 | 991 | } |
1743b515 PB |
992 | } |
993 | ||
315f78ab | 994 | static NBDRequestData *nbd_request_get(NBDClient *client) |
d9a73806 | 995 | { |
315f78ab | 996 | NBDRequestData *req; |
72deddc5 | 997 | |
41996e38 PB |
998 | assert(client->nb_requests <= MAX_NBD_REQUESTS - 1); |
999 | client->nb_requests++; | |
1000 | ||
315f78ab | 1001 | req = g_new0(NBDRequestData, 1); |
72deddc5 PB |
1002 | nbd_client_get(client); |
1003 | req->client = client; | |
d9a73806 PB |
1004 | return req; |
1005 | } | |
1006 | ||
315f78ab | 1007 | static void nbd_request_put(NBDRequestData *req) |
d9a73806 | 1008 | { |
72deddc5 | 1009 | NBDClient *client = req->client; |
e1adb27a | 1010 | |
2d821488 SH |
1011 | if (req->data) { |
1012 | qemu_vfree(req->data); | |
1013 | } | |
1729404c | 1014 | g_free(req); |
e1adb27a | 1015 | |
958c717d | 1016 | client->nb_requests--; |
ff82911c PB |
1017 | nbd_client_receive_next_request(client); |
1018 | ||
72deddc5 | 1019 | nbd_client_put(client); |
d9a73806 PB |
1020 | } |
1021 | ||
aadf99a7 | 1022 | static void blk_aio_attached(AioContext *ctx, void *opaque) |
f2149281 HR |
1023 | { |
1024 | NBDExport *exp = opaque; | |
1025 | NBDClient *client; | |
1026 | ||
9588463e | 1027 | trace_nbd_blk_aio_attached(exp->name, ctx); |
f2149281 HR |
1028 | |
1029 | exp->ctx = ctx; | |
1030 | ||
1031 | QTAILQ_FOREACH(client, &exp->clients, next) { | |
ff82911c PB |
1032 | qio_channel_attach_aio_context(client->ioc, ctx); |
1033 | if (client->recv_coroutine) { | |
1034 | aio_co_schedule(ctx, client->recv_coroutine); | |
1035 | } | |
1036 | if (client->send_coroutine) { | |
1037 | aio_co_schedule(ctx, client->send_coroutine); | |
1038 | } | |
f2149281 HR |
1039 | } |
1040 | } | |
1041 | ||
aadf99a7 | 1042 | static void blk_aio_detach(void *opaque) |
f2149281 HR |
1043 | { |
1044 | NBDExport *exp = opaque; | |
1045 | NBDClient *client; | |
1046 | ||
9588463e | 1047 | trace_nbd_blk_aio_detach(exp->name, exp->ctx); |
f2149281 HR |
1048 | |
1049 | QTAILQ_FOREACH(client, &exp->clients, next) { | |
ff82911c | 1050 | qio_channel_detach_aio_context(client->ioc); |
f2149281 HR |
1051 | } |
1052 | ||
1053 | exp->ctx = NULL; | |
1054 | } | |
1055 | ||
741cc431 HR |
1056 | static void nbd_eject_notifier(Notifier *n, void *data) |
1057 | { | |
1058 | NBDExport *exp = container_of(n, NBDExport, eject_notifier); | |
1059 | nbd_export_close(exp); | |
1060 | } | |
1061 | ||
cd7fca95 | 1062 | NBDExport *nbd_export_new(BlockDriverState *bs, off_t dev_offset, off_t size, |
7423f417 | 1063 | uint16_t nbdflags, void (*close)(NBDExport *), |
cd7fca95 | 1064 | bool writethrough, BlockBackend *on_eject_blk, |
98f44bbe | 1065 | Error **errp) |
af49bbbe | 1066 | { |
3dff24f2 | 1067 | AioContext *ctx; |
cd7fca95 | 1068 | BlockBackend *blk; |
e8d3eb74 | 1069 | NBDExport *exp = g_new0(NBDExport, 1); |
8a7ce4f9 | 1070 | uint64_t perm; |
d7086422 | 1071 | int ret; |
cd7fca95 | 1072 | |
3dff24f2 KW |
1073 | /* |
1074 | * NBD exports are used for non-shared storage migration. Make sure | |
1075 | * that BDRV_O_INACTIVE is cleared and the image is ready for write | |
1076 | * access since the export could be available before migration handover. | |
1077 | */ | |
1078 | ctx = bdrv_get_aio_context(bs); | |
1079 | aio_context_acquire(ctx); | |
1080 | bdrv_invalidate_cache(bs, NULL); | |
1081 | aio_context_release(ctx); | |
1082 | ||
8a7ce4f9 KW |
1083 | /* Don't allow resize while the NBD server is running, otherwise we don't |
1084 | * care what happens with the node. */ | |
1085 | perm = BLK_PERM_CONSISTENT_READ; | |
1086 | if ((nbdflags & NBD_FLAG_READ_ONLY) == 0) { | |
1087 | perm |= BLK_PERM_WRITE; | |
1088 | } | |
1089 | blk = blk_new(perm, BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE_UNCHANGED | | |
1090 | BLK_PERM_WRITE | BLK_PERM_GRAPH_MOD); | |
d7086422 KW |
1091 | ret = blk_insert_bs(blk, bs, errp); |
1092 | if (ret < 0) { | |
1093 | goto fail; | |
1094 | } | |
cd7fca95 KW |
1095 | blk_set_enable_write_cache(blk, !writethrough); |
1096 | ||
2c8d9f06 | 1097 | exp->refcount = 1; |
4b9441f6 | 1098 | QTAILQ_INIT(&exp->clients); |
aadf99a7 | 1099 | exp->blk = blk; |
af49bbbe PB |
1100 | exp->dev_offset = dev_offset; |
1101 | exp->nbdflags = nbdflags; | |
98f44bbe HR |
1102 | exp->size = size < 0 ? blk_getlength(blk) : size; |
1103 | if (exp->size < 0) { | |
1104 | error_setg_errno(errp, -exp->size, | |
1105 | "Failed to determine the NBD export's length"); | |
1106 | goto fail; | |
1107 | } | |
1108 | exp->size -= exp->size % BDRV_SECTOR_SIZE; | |
1109 | ||
0ddf08db | 1110 | exp->close = close; |
aadf99a7 | 1111 | exp->ctx = blk_get_aio_context(blk); |
aadf99a7 | 1112 | blk_add_aio_context_notifier(blk, blk_aio_attached, blk_aio_detach, exp); |
741cc431 | 1113 | |
cd7fca95 KW |
1114 | if (on_eject_blk) { |
1115 | blk_ref(on_eject_blk); | |
1116 | exp->eject_notifier_blk = on_eject_blk; | |
1117 | exp->eject_notifier.notify = nbd_eject_notifier; | |
1118 | blk_add_remove_bs_notifier(on_eject_blk, &exp->eject_notifier); | |
1119 | } | |
af49bbbe | 1120 | return exp; |
98f44bbe HR |
1121 | |
1122 | fail: | |
cd7fca95 | 1123 | blk_unref(blk); |
98f44bbe HR |
1124 | g_free(exp); |
1125 | return NULL; | |
af49bbbe PB |
1126 | } |
1127 | ||
ee0a19ec PB |
1128 | NBDExport *nbd_export_find(const char *name) |
1129 | { | |
1130 | NBDExport *exp; | |
1131 | QTAILQ_FOREACH(exp, &exports, next) { | |
1132 | if (strcmp(name, exp->name) == 0) { | |
1133 | return exp; | |
1134 | } | |
1135 | } | |
1136 | ||
1137 | return NULL; | |
1138 | } | |
1139 | ||
1140 | void nbd_export_set_name(NBDExport *exp, const char *name) | |
1141 | { | |
1142 | if (exp->name == name) { | |
1143 | return; | |
1144 | } | |
1145 | ||
1146 | nbd_export_get(exp); | |
1147 | if (exp->name != NULL) { | |
1148 | g_free(exp->name); | |
1149 | exp->name = NULL; | |
1150 | QTAILQ_REMOVE(&exports, exp, next); | |
1151 | nbd_export_put(exp); | |
1152 | } | |
1153 | if (name != NULL) { | |
1154 | nbd_export_get(exp); | |
1155 | exp->name = g_strdup(name); | |
1156 | QTAILQ_INSERT_TAIL(&exports, exp, next); | |
1157 | } | |
1158 | nbd_export_put(exp); | |
1159 | } | |
1160 | ||
b1a75b33 EB |
1161 | void nbd_export_set_description(NBDExport *exp, const char *description) |
1162 | { | |
1163 | g_free(exp->description); | |
1164 | exp->description = g_strdup(description); | |
1165 | } | |
1166 | ||
af49bbbe PB |
1167 | void nbd_export_close(NBDExport *exp) |
1168 | { | |
4b9441f6 | 1169 | NBDClient *client, *next; |
2c8d9f06 | 1170 | |
4b9441f6 PB |
1171 | nbd_export_get(exp); |
1172 | QTAILQ_FOREACH_SAFE(client, &exp->clients, next, next) { | |
0c9390d9 | 1173 | client_close(client, true); |
4b9441f6 | 1174 | } |
125afda8 | 1175 | nbd_export_set_name(exp, NULL); |
b1a75b33 | 1176 | nbd_export_set_description(exp, NULL); |
4b9441f6 | 1177 | nbd_export_put(exp); |
2c8d9f06 PB |
1178 | } |
1179 | ||
1180 | void nbd_export_get(NBDExport *exp) | |
1181 | { | |
1182 | assert(exp->refcount > 0); | |
1183 | exp->refcount++; | |
1184 | } | |
1185 | ||
1186 | void nbd_export_put(NBDExport *exp) | |
1187 | { | |
1188 | assert(exp->refcount > 0); | |
1189 | if (exp->refcount == 1) { | |
1190 | nbd_export_close(exp); | |
d9a73806 PB |
1191 | } |
1192 | ||
9156245e VSO |
1193 | /* nbd_export_close() may theoretically reduce refcount to 0. It may happen |
1194 | * if someone calls nbd_export_put() on named export not through | |
1195 | * nbd_export_set_name() when refcount is 1. So, let's assert that | |
1196 | * it is > 0. | |
1197 | */ | |
1198 | assert(exp->refcount > 0); | |
2c8d9f06 | 1199 | if (--exp->refcount == 0) { |
ee0a19ec | 1200 | assert(exp->name == NULL); |
b1a75b33 | 1201 | assert(exp->description == NULL); |
ee0a19ec | 1202 | |
0ddf08db PB |
1203 | if (exp->close) { |
1204 | exp->close(exp); | |
1205 | } | |
1206 | ||
d6268348 | 1207 | if (exp->blk) { |
cd7fca95 KW |
1208 | if (exp->eject_notifier_blk) { |
1209 | notifier_remove(&exp->eject_notifier); | |
1210 | blk_unref(exp->eject_notifier_blk); | |
1211 | } | |
d6268348 WC |
1212 | blk_remove_aio_context_notifier(exp->blk, blk_aio_attached, |
1213 | blk_aio_detach, exp); | |
1214 | blk_unref(exp->blk); | |
1215 | exp->blk = NULL; | |
1216 | } | |
1217 | ||
2c8d9f06 PB |
1218 | g_free(exp); |
1219 | } | |
af49bbbe PB |
1220 | } |
1221 | ||
e140177d | 1222 | BlockBackend *nbd_export_get_blockdev(NBDExport *exp) |
125afda8 | 1223 | { |
aadf99a7 | 1224 | return exp->blk; |
125afda8 PB |
1225 | } |
1226 | ||
ee0a19ec PB |
1227 | void nbd_export_close_all(void) |
1228 | { | |
1229 | NBDExport *exp, *next; | |
1230 | ||
1231 | QTAILQ_FOREACH_SAFE(exp, &exports, next, next) { | |
1232 | nbd_export_close(exp); | |
ee0a19ec PB |
1233 | } |
1234 | } | |
1235 | ||
de79bfc3 VSO |
1236 | static int coroutine_fn nbd_co_send_iov(NBDClient *client, struct iovec *iov, |
1237 | unsigned niov, Error **errp) | |
1238 | { | |
1239 | int ret; | |
1240 | ||
1241 | g_assert(qemu_in_coroutine()); | |
1242 | qemu_co_mutex_lock(&client->send_lock); | |
1243 | client->send_coroutine = qemu_coroutine_self(); | |
1244 | ||
1245 | ret = qio_channel_writev_all(client->ioc, iov, niov, errp) < 0 ? -EIO : 0; | |
1246 | ||
1247 | client->send_coroutine = NULL; | |
1248 | qemu_co_mutex_unlock(&client->send_lock); | |
1249 | ||
1250 | return ret; | |
1251 | } | |
1252 | ||
caad5384 VSO |
1253 | static inline void set_be_simple_reply(NBDSimpleReply *reply, uint64_t error, |
1254 | uint64_t handle) | |
1255 | { | |
1256 | stl_be_p(&reply->magic, NBD_SIMPLE_REPLY_MAGIC); | |
1257 | stl_be_p(&reply->error, error); | |
1258 | stq_be_p(&reply->handle, handle); | |
1259 | } | |
1260 | ||
978df1b6 | 1261 | static int nbd_co_send_simple_reply(NBDClient *client, |
14cea41d VSO |
1262 | uint64_t handle, |
1263 | uint32_t error, | |
978df1b6 VSO |
1264 | void *data, |
1265 | size_t len, | |
1266 | Error **errp) | |
22045592 | 1267 | { |
de79bfc3 | 1268 | NBDSimpleReply reply; |
14cea41d | 1269 | int nbd_err = system_errno_to_nbd_errno(error); |
de79bfc3 VSO |
1270 | struct iovec iov[] = { |
1271 | {.iov_base = &reply, .iov_len = sizeof(reply)}, | |
1272 | {.iov_base = data, .iov_len = len} | |
1273 | }; | |
6fb2b972 | 1274 | |
e7a78d0e EB |
1275 | trace_nbd_co_send_simple_reply(handle, nbd_err, nbd_err_lookup(nbd_err), |
1276 | len); | |
de79bfc3 | 1277 | set_be_simple_reply(&reply, nbd_err, handle); |
262db388 | 1278 | |
de79bfc3 | 1279 | return nbd_co_send_iov(client, iov, len ? 2 : 1, errp); |
22045592 PB |
1280 | } |
1281 | ||
5c54e7fa VSO |
1282 | static inline void set_be_chunk(NBDStructuredReplyChunk *chunk, uint16_t flags, |
1283 | uint16_t type, uint64_t handle, uint32_t length) | |
1284 | { | |
1285 | stl_be_p(&chunk->magic, NBD_STRUCTURED_REPLY_MAGIC); | |
1286 | stw_be_p(&chunk->flags, flags); | |
1287 | stw_be_p(&chunk->type, type); | |
1288 | stq_be_p(&chunk->handle, handle); | |
1289 | stl_be_p(&chunk->length, length); | |
1290 | } | |
1291 | ||
ef8c887e EB |
1292 | static int coroutine_fn nbd_co_send_structured_done(NBDClient *client, |
1293 | uint64_t handle, | |
1294 | Error **errp) | |
1295 | { | |
1296 | NBDStructuredReplyChunk chunk; | |
1297 | struct iovec iov[] = { | |
1298 | {.iov_base = &chunk, .iov_len = sizeof(chunk)}, | |
1299 | }; | |
1300 | ||
1301 | trace_nbd_co_send_structured_done(handle); | |
1302 | set_be_chunk(&chunk, NBD_REPLY_FLAG_DONE, NBD_REPLY_TYPE_NONE, handle, 0); | |
1303 | ||
1304 | return nbd_co_send_iov(client, iov, 1, errp); | |
1305 | } | |
1306 | ||
5c54e7fa VSO |
1307 | static int coroutine_fn nbd_co_send_structured_read(NBDClient *client, |
1308 | uint64_t handle, | |
1309 | uint64_t offset, | |
1310 | void *data, | |
1311 | size_t size, | |
418638d3 | 1312 | bool final, |
5c54e7fa VSO |
1313 | Error **errp) |
1314 | { | |
efdc0c10 | 1315 | NBDStructuredReadData chunk; |
5c54e7fa VSO |
1316 | struct iovec iov[] = { |
1317 | {.iov_base = &chunk, .iov_len = sizeof(chunk)}, | |
1318 | {.iov_base = data, .iov_len = size} | |
1319 | }; | |
1320 | ||
ef8c887e | 1321 | assert(size); |
5c54e7fa | 1322 | trace_nbd_co_send_structured_read(handle, offset, data, size); |
418638d3 EB |
1323 | set_be_chunk(&chunk.h, final ? NBD_REPLY_FLAG_DONE : 0, |
1324 | NBD_REPLY_TYPE_OFFSET_DATA, handle, | |
1325 | sizeof(chunk) - sizeof(chunk.h) + size); | |
5c54e7fa VSO |
1326 | stq_be_p(&chunk.offset, offset); |
1327 | ||
1328 | return nbd_co_send_iov(client, iov, 2, errp); | |
1329 | } | |
1330 | ||
418638d3 EB |
1331 | static int coroutine_fn nbd_co_send_sparse_read(NBDClient *client, |
1332 | uint64_t handle, | |
1333 | uint64_t offset, | |
1334 | uint8_t *data, | |
1335 | size_t size, | |
1336 | Error **errp) | |
1337 | { | |
1338 | int ret = 0; | |
1339 | NBDExport *exp = client->exp; | |
1340 | size_t progress = 0; | |
1341 | ||
1342 | while (progress < size) { | |
1343 | int64_t pnum; | |
1344 | int status = bdrv_block_status_above(blk_bs(exp->blk), NULL, | |
1345 | offset + progress, | |
1346 | size - progress, &pnum, NULL, | |
1347 | NULL); | |
e2de3256 | 1348 | bool final; |
418638d3 EB |
1349 | |
1350 | if (status < 0) { | |
1351 | error_setg_errno(errp, -status, "unable to check for holes"); | |
1352 | return status; | |
1353 | } | |
1354 | assert(pnum && pnum <= size - progress); | |
e2de3256 | 1355 | final = progress + pnum == size; |
418638d3 EB |
1356 | if (status & BDRV_BLOCK_ZERO) { |
1357 | NBDStructuredReadHole chunk; | |
1358 | struct iovec iov[] = { | |
1359 | {.iov_base = &chunk, .iov_len = sizeof(chunk)}, | |
1360 | }; | |
1361 | ||
1362 | trace_nbd_co_send_structured_read_hole(handle, offset + progress, | |
1363 | pnum); | |
e2de3256 EB |
1364 | set_be_chunk(&chunk.h, final ? NBD_REPLY_FLAG_DONE : 0, |
1365 | NBD_REPLY_TYPE_OFFSET_HOLE, | |
418638d3 EB |
1366 | handle, sizeof(chunk) - sizeof(chunk.h)); |
1367 | stq_be_p(&chunk.offset, offset + progress); | |
1368 | stl_be_p(&chunk.length, pnum); | |
1369 | ret = nbd_co_send_iov(client, iov, 1, errp); | |
1370 | } else { | |
1371 | ret = blk_pread(exp->blk, offset + progress + exp->dev_offset, | |
1372 | data + progress, pnum); | |
1373 | if (ret < 0) { | |
1374 | error_setg_errno(errp, -ret, "reading from file failed"); | |
1375 | break; | |
1376 | } | |
1377 | ret = nbd_co_send_structured_read(client, handle, offset + progress, | |
e2de3256 | 1378 | data + progress, pnum, final, |
418638d3 EB |
1379 | errp); |
1380 | } | |
1381 | ||
1382 | if (ret < 0) { | |
1383 | break; | |
1384 | } | |
1385 | progress += pnum; | |
1386 | } | |
418638d3 EB |
1387 | return ret; |
1388 | } | |
1389 | ||
5c54e7fa VSO |
1390 | static int coroutine_fn nbd_co_send_structured_error(NBDClient *client, |
1391 | uint64_t handle, | |
1392 | uint32_t error, | |
a57f6dea | 1393 | const char *msg, |
5c54e7fa VSO |
1394 | Error **errp) |
1395 | { | |
1396 | NBDStructuredError chunk; | |
1397 | int nbd_err = system_errno_to_nbd_errno(error); | |
1398 | struct iovec iov[] = { | |
1399 | {.iov_base = &chunk, .iov_len = sizeof(chunk)}, | |
a57f6dea | 1400 | {.iov_base = (char *)msg, .iov_len = msg ? strlen(msg) : 0}, |
5c54e7fa VSO |
1401 | }; |
1402 | ||
1403 | assert(nbd_err); | |
1404 | trace_nbd_co_send_structured_error(handle, nbd_err, | |
a57f6dea | 1405 | nbd_err_lookup(nbd_err), msg ? msg : ""); |
5c54e7fa | 1406 | set_be_chunk(&chunk.h, NBD_REPLY_FLAG_DONE, NBD_REPLY_TYPE_ERROR, handle, |
a57f6dea | 1407 | sizeof(chunk) - sizeof(chunk.h) + iov[1].iov_len); |
5c54e7fa | 1408 | stl_be_p(&chunk.error, nbd_err); |
a57f6dea | 1409 | stw_be_p(&chunk.message_length, iov[1].iov_len); |
5c54e7fa | 1410 | |
a57f6dea | 1411 | return nbd_co_send_iov(client, iov, 1 + !!iov[1].iov_len, errp); |
5c54e7fa VSO |
1412 | } |
1413 | ||
2a6e128b VSO |
1414 | /* nbd_co_receive_request |
1415 | * Collect a client request. Return 0 if request looks valid, -EIO to drop | |
1416 | * connection right away, and any other negative value to report an error to | |
1417 | * the client (although the caller may still need to disconnect after reporting | |
1418 | * the error). | |
1419 | */ | |
2fd2c840 VSO |
1420 | static int nbd_co_receive_request(NBDRequestData *req, NBDRequest *request, |
1421 | Error **errp) | |
a030b347 | 1422 | { |
72deddc5 | 1423 | NBDClient *client = req->client; |
5c54e7fa | 1424 | int valid_flags; |
a030b347 | 1425 | |
1c778ef7 | 1426 | g_assert(qemu_in_coroutine()); |
ff82911c | 1427 | assert(client->recv_coroutine == qemu_coroutine_self()); |
2fd2c840 | 1428 | if (nbd_receive_request(client->ioc, request, errp) < 0) { |
ee898b87 | 1429 | return -EIO; |
a030b347 PB |
1430 | } |
1431 | ||
3736cc5b EB |
1432 | trace_nbd_co_receive_request_decode_type(request->handle, request->type, |
1433 | nbd_cmd_lookup(request->type)); | |
29b6c3b3 | 1434 | |
b626b51a | 1435 | if (request->type != NBD_CMD_WRITE) { |
29b6c3b3 EB |
1436 | /* No payload, we are ready to read the next request. */ |
1437 | req->complete = true; | |
1438 | } | |
1439 | ||
b626b51a | 1440 | if (request->type == NBD_CMD_DISC) { |
29b6c3b3 EB |
1441 | /* Special case: we're going to disconnect without a reply, |
1442 | * whether or not flags, from, or len are bogus */ | |
ee898b87 | 1443 | return -EIO; |
29b6c3b3 EB |
1444 | } |
1445 | ||
b626b51a | 1446 | if (request->type == NBD_CMD_READ || request->type == NBD_CMD_WRITE) { |
eb38c3b6 | 1447 | if (request->len > NBD_MAX_BUFFER_SIZE) { |
2fd2c840 VSO |
1448 | error_setg(errp, "len (%" PRIu32" ) is larger than max len (%u)", |
1449 | request->len, NBD_MAX_BUFFER_SIZE); | |
ee898b87 | 1450 | return -EINVAL; |
eb38c3b6 PB |
1451 | } |
1452 | ||
f1c17521 PB |
1453 | req->data = blk_try_blockalign(client->exp->blk, request->len); |
1454 | if (req->data == NULL) { | |
2fd2c840 | 1455 | error_setg(errp, "No memory"); |
ee898b87 | 1456 | return -ENOMEM; |
f1c17521 | 1457 | } |
2d821488 | 1458 | } |
b626b51a | 1459 | if (request->type == NBD_CMD_WRITE) { |
2fd2c840 VSO |
1460 | if (nbd_read(client->ioc, req->data, request->len, errp) < 0) { |
1461 | error_prepend(errp, "reading from socket failed: "); | |
ee898b87 | 1462 | return -EIO; |
a030b347 | 1463 | } |
29b6c3b3 | 1464 | req->complete = true; |
6fb2b972 | 1465 | |
9588463e VSO |
1466 | trace_nbd_co_receive_request_payload_received(request->handle, |
1467 | request->len); | |
a030b347 | 1468 | } |
29b6c3b3 | 1469 | |
fed5f8f8 EB |
1470 | /* Sanity checks. */ |
1471 | if (client->exp->nbdflags & NBD_FLAG_READ_ONLY && | |
1472 | (request->type == NBD_CMD_WRITE || | |
1473 | request->type == NBD_CMD_WRITE_ZEROES || | |
1474 | request->type == NBD_CMD_TRIM)) { | |
1475 | error_setg(errp, "Export is read-only"); | |
1476 | return -EROFS; | |
1477 | } | |
1478 | if (request->from > client->exp->size || | |
1479 | request->from + request->len > client->exp->size) { | |
2fd2c840 VSO |
1480 | error_setg(errp, "operation past EOF; From: %" PRIu64 ", Len: %" PRIu32 |
1481 | ", Size: %" PRIu64, request->from, request->len, | |
1482 | (uint64_t)client->exp->size); | |
fed5f8f8 EB |
1483 | return (request->type == NBD_CMD_WRITE || |
1484 | request->type == NBD_CMD_WRITE_ZEROES) ? -ENOSPC : -EINVAL; | |
29b6c3b3 | 1485 | } |
5c54e7fa VSO |
1486 | valid_flags = NBD_CMD_FLAG_FUA; |
1487 | if (request->type == NBD_CMD_READ && client->structured_reply) { | |
1488 | valid_flags |= NBD_CMD_FLAG_DF; | |
1489 | } else if (request->type == NBD_CMD_WRITE_ZEROES) { | |
1490 | valid_flags |= NBD_CMD_FLAG_NO_HOLE; | |
ab7c548e | 1491 | } |
5c54e7fa VSO |
1492 | if (request->flags & ~valid_flags) { |
1493 | error_setg(errp, "unsupported flags for command %s (got 0x%x)", | |
1494 | nbd_cmd_lookup(request->type), request->flags); | |
ee898b87 | 1495 | return -EINVAL; |
1f4d6d18 | 1496 | } |
29b6c3b3 | 1497 | |
ee898b87 | 1498 | return 0; |
a030b347 PB |
1499 | } |
1500 | ||
ff82911c PB |
1501 | /* Owns a reference to the NBDClient passed as opaque. */ |
1502 | static coroutine_fn void nbd_trip(void *opaque) | |
75818250 | 1503 | { |
262db388 | 1504 | NBDClient *client = opaque; |
1743b515 | 1505 | NBDExport *exp = client->exp; |
315f78ab | 1506 | NBDRequestData *req; |
ff82911c | 1507 | NBDRequest request = { 0 }; /* GCC thinks it can be used uninitialized */ |
a0dc63a6 | 1508 | int ret; |
a0c30369 | 1509 | int flags; |
8c372a02 | 1510 | int reply_data_len = 0; |
2fd2c840 | 1511 | Error *local_err = NULL; |
a57f6dea | 1512 | char *msg = NULL; |
b2e3d87f | 1513 | |
9588463e | 1514 | trace_nbd_trip(); |
ff2b68aa | 1515 | if (client->closing) { |
ff82911c | 1516 | nbd_client_put(client); |
ff2b68aa PB |
1517 | return; |
1518 | } | |
b2e3d87f | 1519 | |
ff2b68aa | 1520 | req = nbd_request_get(client); |
2fd2c840 | 1521 | ret = nbd_co_receive_request(req, &request, &local_err); |
ee898b87 VSO |
1522 | client->recv_coroutine = NULL; |
1523 | nbd_client_receive_next_request(client); | |
a030b347 | 1524 | if (ret == -EIO) { |
8c372a02 | 1525 | goto disconnect; |
a030b347 | 1526 | } |
b2e3d87f | 1527 | |
a030b347 | 1528 | if (ret < 0) { |
8c372a02 | 1529 | goto reply; |
b2e3d87f | 1530 | } |
b2e3d87f | 1531 | |
d6268348 WC |
1532 | if (client->closing) { |
1533 | /* | |
1534 | * The client may be closed when we are blocked in | |
1535 | * nbd_co_receive_request() | |
1536 | */ | |
1537 | goto done; | |
1538 | } | |
1539 | ||
b626b51a | 1540 | switch (request.type) { |
b2e3d87f | 1541 | case NBD_CMD_READ: |
b626b51a EB |
1542 | /* XXX: NBD Protocol only documents use of FUA with WRITE */ |
1543 | if (request.flags & NBD_CMD_FLAG_FUA) { | |
aadf99a7 | 1544 | ret = blk_co_flush(exp->blk); |
e25ceb76 | 1545 | if (ret < 0) { |
2fd2c840 | 1546 | error_setg_errno(&local_err, -ret, "flush failed"); |
8c372a02 | 1547 | break; |
e25ceb76 PB |
1548 | } |
1549 | } | |
1550 | ||
e2de3256 EB |
1551 | if (client->structured_reply && !(request.flags & NBD_CMD_FLAG_DF) && |
1552 | request.len) { | |
418638d3 EB |
1553 | ret = nbd_co_send_sparse_read(req->client, request.handle, |
1554 | request.from, req->data, request.len, | |
1555 | &local_err); | |
1556 | if (ret < 0) { | |
1557 | goto reply; | |
1558 | } | |
1559 | goto done; | |
1560 | } | |
1561 | ||
df7b97ff EB |
1562 | ret = blk_pread(exp->blk, request.from + exp->dev_offset, |
1563 | req->data, request.len); | |
adcf6302 | 1564 | if (ret < 0) { |
2fd2c840 | 1565 | error_setg_errno(&local_err, -ret, "reading from file failed"); |
8c372a02 | 1566 | break; |
b2e3d87f | 1567 | } |
b2e3d87f | 1568 | |
8c372a02 | 1569 | reply_data_len = request.len; |
8c372a02 | 1570 | |
b2e3d87f NT |
1571 | break; |
1572 | case NBD_CMD_WRITE: | |
a0c30369 | 1573 | flags = 0; |
b626b51a | 1574 | if (request.flags & NBD_CMD_FLAG_FUA) { |
a0c30369 EB |
1575 | flags |= BDRV_REQ_FUA; |
1576 | } | |
df7b97ff | 1577 | ret = blk_pwrite(exp->blk, request.from + exp->dev_offset, |
a0c30369 | 1578 | req->data, request.len, flags); |
fae69416 | 1579 | if (ret < 0) { |
2fd2c840 | 1580 | error_setg_errno(&local_err, -ret, "writing to file failed"); |
fae69416 | 1581 | } |
b2e3d87f | 1582 | |
1f4d6d18 | 1583 | break; |
1f4d6d18 | 1584 | case NBD_CMD_WRITE_ZEROES: |
1f4d6d18 EB |
1585 | flags = 0; |
1586 | if (request.flags & NBD_CMD_FLAG_FUA) { | |
1587 | flags |= BDRV_REQ_FUA; | |
1588 | } | |
1589 | if (!(request.flags & NBD_CMD_FLAG_NO_HOLE)) { | |
1590 | flags |= BDRV_REQ_MAY_UNMAP; | |
1591 | } | |
1592 | ret = blk_pwrite_zeroes(exp->blk, request.from + exp->dev_offset, | |
1593 | request.len, flags); | |
1594 | if (ret < 0) { | |
2fd2c840 | 1595 | error_setg_errno(&local_err, -ret, "writing to file failed"); |
1f4d6d18 EB |
1596 | } |
1597 | ||
b2e3d87f NT |
1598 | break; |
1599 | case NBD_CMD_DISC: | |
29b6c3b3 EB |
1600 | /* unreachable, thanks to special case in nbd_co_receive_request() */ |
1601 | abort(); | |
1602 | ||
1486d04a | 1603 | case NBD_CMD_FLUSH: |
aadf99a7 | 1604 | ret = blk_co_flush(exp->blk); |
1486d04a | 1605 | if (ret < 0) { |
2fd2c840 | 1606 | error_setg_errno(&local_err, -ret, "flush failed"); |
1486d04a | 1607 | } |
8c372a02 | 1608 | |
7a706633 PB |
1609 | break; |
1610 | case NBD_CMD_TRIM: | |
1c6c4bb7 EB |
1611 | ret = blk_co_pdiscard(exp->blk, request.from + exp->dev_offset, |
1612 | request.len); | |
1613 | if (ret < 0) { | |
2fd2c840 | 1614 | error_setg_errno(&local_err, -ret, "discard failed"); |
7a706633 | 1615 | } |
8c372a02 | 1616 | |
1486d04a | 1617 | break; |
b2e3d87f | 1618 | default: |
2fd2c840 VSO |
1619 | error_setg(&local_err, "invalid request type (%" PRIu32 ") received", |
1620 | request.type); | |
14cea41d | 1621 | ret = -EINVAL; |
8c372a02 VSO |
1622 | } |
1623 | ||
1624 | reply: | |
2fd2c840 | 1625 | if (local_err) { |
14cea41d VSO |
1626 | /* If we get here, local_err was not a fatal error, and should be sent |
1627 | * to the client. */ | |
a57f6dea EB |
1628 | assert(ret < 0); |
1629 | msg = g_strdup(error_get_pretty(local_err)); | |
2fd2c840 VSO |
1630 | error_report_err(local_err); |
1631 | local_err = NULL; | |
1632 | } | |
1633 | ||
a57f6dea EB |
1634 | if (client->structured_reply && |
1635 | (ret < 0 || request.type == NBD_CMD_READ)) { | |
5c54e7fa VSO |
1636 | if (ret < 0) { |
1637 | ret = nbd_co_send_structured_error(req->client, request.handle, | |
a57f6dea | 1638 | -ret, msg, &local_err); |
ef8c887e | 1639 | } else if (reply_data_len) { |
5c54e7fa VSO |
1640 | ret = nbd_co_send_structured_read(req->client, request.handle, |
1641 | request.from, req->data, | |
418638d3 EB |
1642 | reply_data_len, true, |
1643 | &local_err); | |
ef8c887e EB |
1644 | } else { |
1645 | ret = nbd_co_send_structured_done(req->client, request.handle, | |
1646 | &local_err); | |
5c54e7fa VSO |
1647 | } |
1648 | } else { | |
1649 | ret = nbd_co_send_simple_reply(req->client, request.handle, | |
1650 | ret < 0 ? -ret : 0, | |
1651 | req->data, reply_data_len, &local_err); | |
1652 | } | |
a57f6dea | 1653 | g_free(msg); |
5c54e7fa | 1654 | if (ret < 0) { |
c7b97282 | 1655 | error_prepend(&local_err, "Failed to send reply: "); |
2fd2c840 VSO |
1656 | goto disconnect; |
1657 | } | |
1658 | ||
8c372a02 VSO |
1659 | /* We must disconnect after NBD_CMD_WRITE if we did not |
1660 | * read the payload. | |
1661 | */ | |
2fd2c840 VSO |
1662 | if (!req->complete) { |
1663 | error_setg(&local_err, "Request handling failed in intermediate state"); | |
8c372a02 | 1664 | goto disconnect; |
b2e3d87f NT |
1665 | } |
1666 | ||
7fe7b68b | 1667 | done: |
262db388 | 1668 | nbd_request_put(req); |
ff82911c | 1669 | nbd_client_put(client); |
262db388 PB |
1670 | return; |
1671 | ||
8c372a02 | 1672 | disconnect: |
2fd2c840 VSO |
1673 | if (local_err) { |
1674 | error_reportf_err(local_err, "Disconnect client, due to: "); | |
1675 | } | |
72deddc5 | 1676 | nbd_request_put(req); |
0c9390d9 | 1677 | client_close(client, true); |
ff82911c | 1678 | nbd_client_put(client); |
7a5ca864 | 1679 | } |
af49bbbe | 1680 | |
ff82911c | 1681 | static void nbd_client_receive_next_request(NBDClient *client) |
958c717d | 1682 | { |
ff82911c PB |
1683 | if (!client->recv_coroutine && client->nb_requests < MAX_NBD_REQUESTS) { |
1684 | nbd_client_get(client); | |
1685 | client->recv_coroutine = qemu_coroutine_create(nbd_trip, client); | |
1686 | aio_co_schedule(client->exp->ctx, client->recv_coroutine); | |
958c717d HR |
1687 | } |
1688 | } | |
1689 | ||
1a6245a5 FZ |
1690 | static coroutine_fn void nbd_co_client_start(void *opaque) |
1691 | { | |
c84087f2 | 1692 | NBDClient *client = opaque; |
1a6245a5 | 1693 | NBDExport *exp = client->exp; |
2fd2c840 | 1694 | Error *local_err = NULL; |
1a6245a5 FZ |
1695 | |
1696 | if (exp) { | |
1697 | nbd_export_get(exp); | |
df8ad9f1 | 1698 | QTAILQ_INSERT_TAIL(&exp->clients, client, next); |
1a6245a5 | 1699 | } |
df8ad9f1 EB |
1700 | qemu_co_mutex_init(&client->send_lock); |
1701 | ||
2fd2c840 VSO |
1702 | if (nbd_negotiate(client, &local_err)) { |
1703 | if (local_err) { | |
1704 | error_report_err(local_err); | |
1705 | } | |
0c9390d9 | 1706 | client_close(client, false); |
c84087f2 | 1707 | return; |
1a6245a5 | 1708 | } |
ff82911c PB |
1709 | |
1710 | nbd_client_receive_next_request(client); | |
1a6245a5 FZ |
1711 | } |
1712 | ||
0c9390d9 EB |
1713 | /* |
1714 | * Create a new client listener on the given export @exp, using the | |
1715 | * given channel @sioc. Begin servicing it in a coroutine. When the | |
1716 | * connection closes, call @close_fn with an indication of whether the | |
1717 | * client completed negotiation. | |
1718 | */ | |
1c778ef7 DB |
1719 | void nbd_client_new(NBDExport *exp, |
1720 | QIOChannelSocket *sioc, | |
f95910fe DB |
1721 | QCryptoTLSCreds *tlscreds, |
1722 | const char *tlsaclname, | |
0c9390d9 | 1723 | void (*close_fn)(NBDClient *, bool)) |
af49bbbe | 1724 | { |
1743b515 | 1725 | NBDClient *client; |
c84087f2 | 1726 | Coroutine *co; |
1a6245a5 | 1727 | |
e8d3eb74 | 1728 | client = g_new0(NBDClient, 1); |
1743b515 PB |
1729 | client->refcount = 1; |
1730 | client->exp = exp; | |
f95910fe DB |
1731 | client->tlscreds = tlscreds; |
1732 | if (tlscreds) { | |
1733 | object_ref(OBJECT(client->tlscreds)); | |
1734 | } | |
1735 | client->tlsaclname = g_strdup(tlsaclname); | |
1c778ef7 DB |
1736 | client->sioc = sioc; |
1737 | object_ref(OBJECT(client->sioc)); | |
1738 | client->ioc = QIO_CHANNEL(sioc); | |
1739 | object_ref(OBJECT(client->ioc)); | |
0c9390d9 | 1740 | client->close_fn = close_fn; |
2c8d9f06 | 1741 | |
c84087f2 VSO |
1742 | co = qemu_coroutine_create(nbd_co_client_start, client); |
1743 | qemu_coroutine_enter(co); | |
af49bbbe | 1744 | } |