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