]>
Commit | Line | Data |
---|---|---|
798bfe00 | 1 | /* |
216ee365 | 2 | * Copyright (C) 2016-2018 Red Hat, Inc. |
798bfe00 FZ |
3 | * Copyright (C) 2005 Anthony Liguori <anthony@codemonkey.ws> |
4 | * | |
5 | * Network Block Device Client Side | |
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 | |
17 | * along with this program; if not, see <http://www.gnu.org/licenses/>. | |
18 | */ | |
19 | ||
d38ea87a | 20 | #include "qemu/osdep.h" |
da34e65c | 21 | #include "qapi/error.h" |
dc5e9ac7 | 22 | #include "qemu/queue.h" |
9588463e | 23 | #include "trace.h" |
798bfe00 | 24 | #include "nbd-internal.h" |
7c6f5ddc | 25 | #include "qemu/cutils.h" |
798bfe00 | 26 | |
798bfe00 FZ |
27 | /* Definitions for opaque data types */ |
28 | ||
29 | static QTAILQ_HEAD(, NBDExport) exports = QTAILQ_HEAD_INITIALIZER(exports); | |
30 | ||
31 | /* That's all folks */ | |
32 | ||
33 | /* Basic flow for negotiation | |
34 | ||
35 | Server Client | |
36 | Negotiate | |
37 | ||
38 | or | |
39 | ||
40 | Server Client | |
41 | Negotiate #1 | |
42 | Option | |
43 | Negotiate #2 | |
44 | ||
45 | ---- | |
46 | ||
47 | followed by | |
48 | ||
49 | Server Client | |
50 | Request | |
51 | Response | |
52 | Request | |
53 | Response | |
54 | ... | |
55 | ... | |
56 | Request (type == 2) | |
57 | ||
58 | */ | |
59 | ||
c8a3a1b6 EB |
60 | /* Send an option request. |
61 | * | |
62 | * The request is for option @opt, with @data containing @len bytes of | |
63 | * additional payload for the request (@len may be -1 to treat @data as | |
64 | * a C string; and @data may be NULL if @len is 0). | |
65 | * Return 0 if successful, -1 with errp set if it is impossible to | |
66 | * continue. */ | |
67 | static int nbd_send_option_request(QIOChannel *ioc, uint32_t opt, | |
68 | uint32_t len, const char *data, | |
69 | Error **errp) | |
70 | { | |
420a4e95 | 71 | NBDOption req; |
c8a3a1b6 EB |
72 | QEMU_BUILD_BUG_ON(sizeof(req) != 16); |
73 | ||
74 | if (len == -1) { | |
75 | req.length = len = strlen(data); | |
76 | } | |
3736cc5b | 77 | trace_nbd_send_option_request(opt, nbd_opt_lookup(opt), len); |
c8a3a1b6 EB |
78 | |
79 | stq_be_p(&req.magic, NBD_OPTS_MAGIC); | |
80 | stl_be_p(&req.option, opt); | |
81 | stl_be_p(&req.length, len); | |
82 | ||
d1fdf257 | 83 | if (nbd_write(ioc, &req, sizeof(req), errp) < 0) { |
cb6b1a3f | 84 | error_prepend(errp, "Failed to send option request header: "); |
c8a3a1b6 EB |
85 | return -1; |
86 | } | |
87 | ||
d1fdf257 | 88 | if (len && nbd_write(ioc, (char *) data, len, errp) < 0) { |
cb6b1a3f | 89 | error_prepend(errp, "Failed to send option request data: "); |
c8a3a1b6 EB |
90 | return -1; |
91 | } | |
92 | ||
93 | return 0; | |
94 | } | |
95 | ||
2cdbf413 EB |
96 | /* Send NBD_OPT_ABORT as a courtesy to let the server know that we are |
97 | * not going to attempt further negotiation. */ | |
98 | static void nbd_send_opt_abort(QIOChannel *ioc) | |
99 | { | |
100 | /* Technically, a compliant server is supposed to reply to us; but | |
101 | * older servers disconnected instead. At any rate, we're allowed | |
102 | * to disconnect without waiting for the server reply, so we don't | |
103 | * even care if the request makes it to the server, let alone | |
104 | * waiting around for whether the server replies. */ | |
105 | nbd_send_option_request(ioc, NBD_OPT_ABORT, 0, NULL, NULL); | |
106 | } | |
107 | ||
108 | ||
c8a3a1b6 EB |
109 | /* Receive the header of an option reply, which should match the given |
110 | * opt. Read through the length field, but NOT the length bytes of | |
111 | * payload. Return 0 if successful, -1 with errp set if it is | |
112 | * impossible to continue. */ | |
113 | static int nbd_receive_option_reply(QIOChannel *ioc, uint32_t opt, | |
420a4e95 | 114 | NBDOptionReply *reply, Error **errp) |
c8a3a1b6 EB |
115 | { |
116 | QEMU_BUILD_BUG_ON(sizeof(*reply) != 20); | |
e6798f06 | 117 | if (nbd_read(ioc, reply, sizeof(*reply), "option reply", errp) < 0) { |
2cdbf413 | 118 | nbd_send_opt_abort(ioc); |
c8a3a1b6 EB |
119 | return -1; |
120 | } | |
80c7c2b0 PM |
121 | reply->magic = be64_to_cpu(reply->magic); |
122 | reply->option = be32_to_cpu(reply->option); | |
123 | reply->type = be32_to_cpu(reply->type); | |
124 | reply->length = be32_to_cpu(reply->length); | |
c8a3a1b6 | 125 | |
3736cc5b EB |
126 | trace_nbd_receive_option_reply(reply->option, nbd_opt_lookup(reply->option), |
127 | reply->type, nbd_rep_lookup(reply->type), | |
128 | reply->length); | |
9344e5f5 | 129 | |
c8a3a1b6 EB |
130 | if (reply->magic != NBD_REP_MAGIC) { |
131 | error_setg(errp, "Unexpected option reply magic"); | |
2cdbf413 | 132 | nbd_send_opt_abort(ioc); |
c8a3a1b6 EB |
133 | return -1; |
134 | } | |
135 | if (reply->option != opt) { | |
6c5c0351 EB |
136 | error_setg(errp, "Unexpected option type %u (%s), expected %u (%s)", |
137 | reply->option, nbd_opt_lookup(reply->option), | |
138 | opt, nbd_opt_lookup(opt)); | |
2cdbf413 | 139 | nbd_send_opt_abort(ioc); |
c8a3a1b6 EB |
140 | return -1; |
141 | } | |
142 | return 0; | |
143 | } | |
144 | ||
145 | /* If reply represents success, return 1 without further action. | |
146 | * If reply represents an error, consume the optional payload of | |
147 | * the packet on ioc. Then return 0 for unsupported (so the client | |
148 | * can fall back to other approaches), or -1 with errp set for other | |
149 | * errors. | |
6ff58164 | 150 | */ |
420a4e95 | 151 | static int nbd_handle_reply_err(QIOChannel *ioc, NBDOptionReply *reply, |
6ff58164 | 152 | Error **errp) |
9344e5f5 | 153 | { |
6ff58164 AB |
154 | char *msg = NULL; |
155 | int result = -1; | |
156 | ||
c8a3a1b6 | 157 | if (!(reply->type & (1 << 31))) { |
6ff58164 AB |
158 | return 1; |
159 | } | |
160 | ||
c8a3a1b6 EB |
161 | if (reply->length) { |
162 | if (reply->length > NBD_MAX_BUFFER_SIZE) { | |
28fb494f | 163 | error_setg(errp, "server error %" PRIu32 |
3736cc5b EB |
164 | " (%s) message is too long", |
165 | reply->type, nbd_rep_lookup(reply->type)); | |
6ff58164 AB |
166 | goto cleanup; |
167 | } | |
c8a3a1b6 | 168 | msg = g_malloc(reply->length + 1); |
e6798f06 VSO |
169 | if (nbd_read(ioc, msg, reply->length, NULL, errp) < 0) { |
170 | error_prepend(errp, "Failed to read option error %" PRIu32 | |
cb6b1a3f | 171 | " (%s) message: ", |
3736cc5b | 172 | reply->type, nbd_rep_lookup(reply->type)); |
6ff58164 AB |
173 | goto cleanup; |
174 | } | |
c8a3a1b6 | 175 | msg[reply->length] = '\0'; |
bee21ef0 EB |
176 | trace_nbd_server_error_msg(reply->type, |
177 | nbd_reply_type_lookup(reply->type), msg); | |
9344e5f5 DB |
178 | } |
179 | ||
c8a3a1b6 | 180 | switch (reply->type) { |
9344e5f5 | 181 | case NBD_REP_ERR_UNSUP: |
3736cc5b | 182 | trace_nbd_reply_err_unsup(reply->option, nbd_opt_lookup(reply->option)); |
6ff58164 AB |
183 | result = 0; |
184 | goto cleanup; | |
9344e5f5 | 185 | |
f95910fe | 186 | case NBD_REP_ERR_POLICY: |
28fb494f | 187 | error_setg(errp, "Denied by server for option %" PRIu32 " (%s)", |
3736cc5b | 188 | reply->option, nbd_opt_lookup(reply->option)); |
f95910fe DB |
189 | break; |
190 | ||
9344e5f5 | 191 | case NBD_REP_ERR_INVALID: |
28fb494f | 192 | error_setg(errp, "Invalid parameters for option %" PRIu32 " (%s)", |
3736cc5b | 193 | reply->option, nbd_opt_lookup(reply->option)); |
9344e5f5 DB |
194 | break; |
195 | ||
b6f5d3b5 | 196 | case NBD_REP_ERR_PLATFORM: |
28fb494f | 197 | error_setg(errp, "Server lacks support for option %" PRIu32 " (%s)", |
3736cc5b | 198 | reply->option, nbd_opt_lookup(reply->option)); |
b6f5d3b5 EB |
199 | break; |
200 | ||
f95910fe | 201 | case NBD_REP_ERR_TLS_REQD: |
28fb494f | 202 | error_setg(errp, "TLS negotiation required before option %" PRIu32 |
3736cc5b EB |
203 | " (%s)", reply->option, nbd_opt_lookup(reply->option)); |
204 | break; | |
205 | ||
206 | case NBD_REP_ERR_UNKNOWN: | |
9a76bd78 | 207 | error_setg(errp, "Requested export not available"); |
f95910fe DB |
208 | break; |
209 | ||
b6f5d3b5 | 210 | case NBD_REP_ERR_SHUTDOWN: |
28fb494f | 211 | error_setg(errp, "Server shutting down before option %" PRIu32 " (%s)", |
3736cc5b EB |
212 | reply->option, nbd_opt_lookup(reply->option)); |
213 | break; | |
214 | ||
215 | case NBD_REP_ERR_BLOCK_SIZE_REQD: | |
28fb494f | 216 | error_setg(errp, "Server requires INFO_BLOCK_SIZE for option %" PRIu32 |
3736cc5b | 217 | " (%s)", reply->option, nbd_opt_lookup(reply->option)); |
b6f5d3b5 EB |
218 | break; |
219 | ||
9344e5f5 | 220 | default: |
28fb494f | 221 | error_setg(errp, "Unknown error code when asking for option %" PRIu32 |
3736cc5b | 222 | " (%s)", reply->option, nbd_opt_lookup(reply->option)); |
9344e5f5 DB |
223 | break; |
224 | } | |
225 | ||
6ff58164 | 226 | if (msg) { |
9a76bd78 | 227 | error_append_hint(errp, "server reported: %s\n", msg); |
6ff58164 AB |
228 | } |
229 | ||
230 | cleanup: | |
231 | g_free(msg); | |
2cdbf413 EB |
232 | if (result < 0) { |
233 | nbd_send_opt_abort(ioc); | |
234 | } | |
6ff58164 | 235 | return result; |
9344e5f5 DB |
236 | } |
237 | ||
091d0bf3 EB |
238 | /* nbd_receive_list: |
239 | * Process another portion of the NBD_OPT_LIST reply, populating any | |
240 | * name received into *@name. If @description is non-NULL, and the | |
241 | * server provided a description, that is also populated. The caller | |
242 | * must eventually call g_free() on success. | |
243 | * Returns 1 if name and description were set and iteration must continue, | |
244 | * 0 if iteration is complete (including if OPT_LIST unsupported), | |
245 | * -1 with @errp set if an unrecoverable error occurred. | |
246 | */ | |
247 | static int nbd_receive_list(QIOChannel *ioc, char **name, char **description, | |
75368aab | 248 | Error **errp) |
9344e5f5 | 249 | { |
420a4e95 | 250 | NBDOptionReply reply; |
9344e5f5 DB |
251 | uint32_t len; |
252 | uint32_t namelen; | |
df18c04e EB |
253 | g_autofree char *local_name = NULL; |
254 | g_autofree char *local_desc = NULL; | |
6ff58164 | 255 | int error; |
9344e5f5 | 256 | |
c8a3a1b6 | 257 | if (nbd_receive_option_reply(ioc, NBD_OPT_LIST, &reply, errp) < 0) { |
9344e5f5 DB |
258 | return -1; |
259 | } | |
c8a3a1b6 | 260 | error = nbd_handle_reply_err(ioc, &reply, errp); |
6ff58164 AB |
261 | if (error <= 0) { |
262 | return error; | |
9344e5f5 | 263 | } |
c8a3a1b6 | 264 | len = reply.length; |
9344e5f5 | 265 | |
c8a3a1b6 | 266 | if (reply.type == NBD_REP_ACK) { |
9344e5f5 DB |
267 | if (len != 0) { |
268 | error_setg(errp, "length too long for option end"); | |
2cdbf413 | 269 | nbd_send_opt_abort(ioc); |
9344e5f5 DB |
270 | return -1; |
271 | } | |
75368aab EB |
272 | return 0; |
273 | } else if (reply.type != NBD_REP_SERVER) { | |
6c5c0351 EB |
274 | error_setg(errp, "Unexpected reply type %u (%s), expected %u (%s)", |
275 | reply.type, nbd_rep_lookup(reply.type), | |
276 | NBD_REP_SERVER, nbd_rep_lookup(NBD_REP_SERVER)); | |
75368aab EB |
277 | nbd_send_opt_abort(ioc); |
278 | return -1; | |
279 | } | |
9344e5f5 | 280 | |
75368aab EB |
281 | if (len < sizeof(namelen) || len > NBD_MAX_BUFFER_SIZE) { |
282 | error_setg(errp, "incorrect option length %" PRIu32, len); | |
283 | nbd_send_opt_abort(ioc); | |
284 | return -1; | |
285 | } | |
e6798f06 | 286 | if (nbd_read32(ioc, &namelen, "option name length", errp) < 0) { |
75368aab EB |
287 | nbd_send_opt_abort(ioc); |
288 | return -1; | |
289 | } | |
75368aab EB |
290 | len -= sizeof(namelen); |
291 | if (len < namelen) { | |
292 | error_setg(errp, "incorrect option name length"); | |
293 | nbd_send_opt_abort(ioc); | |
294 | return -1; | |
295 | } | |
75368aab | 296 | |
091d0bf3 | 297 | local_name = g_malloc(namelen + 1); |
e6798f06 | 298 | if (nbd_read(ioc, local_name, namelen, "export name", errp) < 0) { |
75368aab | 299 | nbd_send_opt_abort(ioc); |
df18c04e | 300 | return -1; |
75368aab | 301 | } |
091d0bf3 | 302 | local_name[namelen] = '\0'; |
75368aab | 303 | len -= namelen; |
091d0bf3 EB |
304 | if (len) { |
305 | local_desc = g_malloc(len + 1); | |
e6798f06 | 306 | if (nbd_read(ioc, local_desc, len, "export description", errp) < 0) { |
091d0bf3 | 307 | nbd_send_opt_abort(ioc); |
df18c04e | 308 | return -1; |
091d0bf3 EB |
309 | } |
310 | local_desc[len] = '\0'; | |
9344e5f5 | 311 | } |
091d0bf3 EB |
312 | |
313 | trace_nbd_receive_list(local_name, local_desc ?: ""); | |
df18c04e | 314 | *name = g_steal_pointer(&local_name); |
091d0bf3 | 315 | if (description) { |
df18c04e | 316 | *description = g_steal_pointer(&local_desc); |
75368aab | 317 | } |
df18c04e | 318 | return 1; |
9344e5f5 DB |
319 | } |
320 | ||
321 | ||
138796d0 EB |
322 | /* |
323 | * nbd_opt_info_or_go: | |
324 | * Send option for NBD_OPT_INFO or NBD_OPT_GO and parse the reply. | |
325 | * Returns -1 if the option proves the export @info->name cannot be | |
326 | * used, 0 if the option is unsupported (fall back to NBD_OPT_LIST and | |
8ecaeae8 | 327 | * NBD_OPT_EXPORT_NAME in that case), and > 0 if the export is good to |
138796d0 EB |
328 | * go (with the rest of @info populated). |
329 | */ | |
330 | static int nbd_opt_info_or_go(QIOChannel *ioc, uint32_t opt, | |
331 | NBDExportInfo *info, Error **errp) | |
8ecaeae8 | 332 | { |
420a4e95 | 333 | NBDOptionReply reply; |
6dc1667d | 334 | uint32_t len = strlen(info->name); |
8ecaeae8 EB |
335 | uint16_t type; |
336 | int error; | |
337 | char *buf; | |
338 | ||
339 | /* The protocol requires that the server send NBD_INFO_EXPORT with | |
340 | * a non-zero flags (at least NBD_FLAG_HAS_FLAGS must be set); so | |
341 | * flags still 0 is a witness of a broken server. */ | |
342 | info->flags = 0; | |
343 | ||
138796d0 EB |
344 | assert(opt == NBD_OPT_GO || opt == NBD_OPT_INFO); |
345 | trace_nbd_opt_info_go_start(nbd_opt_lookup(opt), info->name); | |
081dd1fe | 346 | buf = g_malloc(4 + len + 2 + 2 * info->request_sizes + 1); |
8ecaeae8 | 347 | stl_be_p(buf, len); |
6dc1667d | 348 | memcpy(buf + 4, info->name, len); |
081dd1fe EB |
349 | /* At most one request, everything else up to server */ |
350 | stw_be_p(buf + 4 + len, info->request_sizes); | |
351 | if (info->request_sizes) { | |
352 | stw_be_p(buf + 4 + len + 2, NBD_INFO_BLOCK_SIZE); | |
353 | } | |
138796d0 | 354 | error = nbd_send_option_request(ioc, opt, |
158b9aa5 PMD |
355 | 4 + len + 2 + 2 * info->request_sizes, |
356 | buf, errp); | |
357 | g_free(buf); | |
358 | if (error < 0) { | |
8ecaeae8 EB |
359 | return -1; |
360 | } | |
361 | ||
362 | while (1) { | |
138796d0 | 363 | if (nbd_receive_option_reply(ioc, opt, &reply, errp) < 0) { |
8ecaeae8 EB |
364 | return -1; |
365 | } | |
366 | error = nbd_handle_reply_err(ioc, &reply, errp); | |
367 | if (error <= 0) { | |
368 | return error; | |
369 | } | |
370 | len = reply.length; | |
371 | ||
372 | if (reply.type == NBD_REP_ACK) { | |
138796d0 EB |
373 | /* |
374 | * Server is done sending info, and moved into transmission | |
375 | * phase for NBD_OPT_GO, but make sure it sent flags | |
376 | */ | |
8ecaeae8 EB |
377 | if (len) { |
378 | error_setg(errp, "server sent invalid NBD_REP_ACK"); | |
8ecaeae8 EB |
379 | return -1; |
380 | } | |
381 | if (!info->flags) { | |
382 | error_setg(errp, "broken server omitted NBD_INFO_EXPORT"); | |
8ecaeae8 EB |
383 | return -1; |
384 | } | |
138796d0 | 385 | trace_nbd_opt_info_go_success(nbd_opt_lookup(opt)); |
8ecaeae8 EB |
386 | return 1; |
387 | } | |
388 | if (reply.type != NBD_REP_INFO) { | |
6c5c0351 EB |
389 | error_setg(errp, "unexpected reply type %u (%s), expected %u (%s)", |
390 | reply.type, nbd_rep_lookup(reply.type), | |
391 | NBD_REP_INFO, nbd_rep_lookup(NBD_REP_INFO)); | |
8ecaeae8 EB |
392 | nbd_send_opt_abort(ioc); |
393 | return -1; | |
394 | } | |
395 | if (len < sizeof(type)) { | |
396 | error_setg(errp, "NBD_REP_INFO length %" PRIu32 " is too short", | |
397 | len); | |
398 | nbd_send_opt_abort(ioc); | |
399 | return -1; | |
400 | } | |
e6798f06 | 401 | if (nbd_read16(ioc, &type, "info type", errp) < 0) { |
8ecaeae8 EB |
402 | nbd_send_opt_abort(ioc); |
403 | return -1; | |
404 | } | |
405 | len -= sizeof(type); | |
8ecaeae8 EB |
406 | switch (type) { |
407 | case NBD_INFO_EXPORT: | |
408 | if (len != sizeof(info->size) + sizeof(info->flags)) { | |
409 | error_setg(errp, "remaining export info len %" PRIu32 | |
410 | " is unexpected size", len); | |
411 | nbd_send_opt_abort(ioc); | |
412 | return -1; | |
413 | } | |
e6798f06 | 414 | if (nbd_read64(ioc, &info->size, "info size", errp) < 0) { |
8ecaeae8 EB |
415 | nbd_send_opt_abort(ioc); |
416 | return -1; | |
417 | } | |
e6798f06 | 418 | if (nbd_read16(ioc, &info->flags, "info flags", errp) < 0) { |
8ecaeae8 EB |
419 | nbd_send_opt_abort(ioc); |
420 | return -1; | |
421 | } | |
3add3ab7 EB |
422 | if (info->min_block && |
423 | !QEMU_IS_ALIGNED(info->size, info->min_block)) { | |
e53f88df | 424 | error_setg(errp, "export size %" PRIu64 " is not multiple of " |
3add3ab7 EB |
425 | "minimum block size %" PRIu32, info->size, |
426 | info->min_block); | |
427 | nbd_send_opt_abort(ioc); | |
428 | return -1; | |
429 | } | |
8ecaeae8 EB |
430 | trace_nbd_receive_negotiate_size_flags(info->size, info->flags); |
431 | break; | |
432 | ||
081dd1fe EB |
433 | case NBD_INFO_BLOCK_SIZE: |
434 | if (len != sizeof(info->min_block) * 3) { | |
435 | error_setg(errp, "remaining export info len %" PRIu32 | |
436 | " is unexpected size", len); | |
437 | nbd_send_opt_abort(ioc); | |
438 | return -1; | |
439 | } | |
e6798f06 VSO |
440 | if (nbd_read32(ioc, &info->min_block, "info minimum block size", |
441 | errp) < 0) { | |
081dd1fe EB |
442 | nbd_send_opt_abort(ioc); |
443 | return -1; | |
444 | } | |
081dd1fe | 445 | if (!is_power_of_2(info->min_block)) { |
e475d108 EB |
446 | error_setg(errp, "server minimum block size %" PRIu32 |
447 | " is not a power of two", info->min_block); | |
081dd1fe EB |
448 | nbd_send_opt_abort(ioc); |
449 | return -1; | |
450 | } | |
e6798f06 VSO |
451 | if (nbd_read32(ioc, &info->opt_block, "info preferred block size", |
452 | errp) < 0) | |
453 | { | |
081dd1fe EB |
454 | nbd_send_opt_abort(ioc); |
455 | return -1; | |
456 | } | |
081dd1fe EB |
457 | if (!is_power_of_2(info->opt_block) || |
458 | info->opt_block < info->min_block) { | |
e475d108 EB |
459 | error_setg(errp, "server preferred block size %" PRIu32 |
460 | " is not valid", info->opt_block); | |
081dd1fe EB |
461 | nbd_send_opt_abort(ioc); |
462 | return -1; | |
463 | } | |
e6798f06 VSO |
464 | if (nbd_read32(ioc, &info->max_block, "info maximum block size", |
465 | errp) < 0) | |
466 | { | |
081dd1fe EB |
467 | nbd_send_opt_abort(ioc); |
468 | return -1; | |
469 | } | |
e475d108 EB |
470 | if (info->max_block < info->min_block) { |
471 | error_setg(errp, "server maximum block size %" PRIu32 | |
472 | " is not valid", info->max_block); | |
473 | nbd_send_opt_abort(ioc); | |
474 | return -1; | |
475 | } | |
138796d0 EB |
476 | trace_nbd_opt_info_block_size(info->min_block, info->opt_block, |
477 | info->max_block); | |
081dd1fe EB |
478 | break; |
479 | ||
8ecaeae8 | 480 | default: |
138796d0 | 481 | trace_nbd_opt_info_unknown(type, nbd_info_lookup(type)); |
8ecaeae8 | 482 | if (nbd_drop(ioc, len, errp) < 0) { |
cb6b1a3f | 483 | error_prepend(errp, "Failed to read info payload: "); |
8ecaeae8 EB |
484 | nbd_send_opt_abort(ioc); |
485 | return -1; | |
486 | } | |
487 | break; | |
488 | } | |
489 | } | |
490 | } | |
491 | ||
75368aab | 492 | /* Return -1 on failure, 0 if wantname is an available export. */ |
9344e5f5 DB |
493 | static int nbd_receive_query_exports(QIOChannel *ioc, |
494 | const char *wantname, | |
495 | Error **errp) | |
496 | { | |
091d0bf3 EB |
497 | bool list_empty = true; |
498 | bool found_export = false; | |
9344e5f5 | 499 | |
9588463e | 500 | trace_nbd_receive_query_exports_start(wantname); |
c8a3a1b6 | 501 | if (nbd_send_option_request(ioc, NBD_OPT_LIST, 0, NULL, errp) < 0) { |
9344e5f5 DB |
502 | return -1; |
503 | } | |
504 | ||
9344e5f5 | 505 | while (1) { |
091d0bf3 EB |
506 | char *name; |
507 | int ret = nbd_receive_list(ioc, &name, NULL, errp); | |
9344e5f5 DB |
508 | |
509 | if (ret < 0) { | |
75368aab | 510 | /* Server gave unexpected reply */ |
9344e5f5 | 511 | return -1; |
75368aab EB |
512 | } else if (ret == 0) { |
513 | /* Done iterating. */ | |
091d0bf3 EB |
514 | if (list_empty) { |
515 | /* | |
516 | * We don't have enough context to tell a server that | |
517 | * sent an empty list apart from a server that does | |
518 | * not support the list command; but as this function | |
519 | * is just used to trigger a nicer error message | |
520 | * before trying NBD_OPT_EXPORT_NAME, assume the | |
521 | * export is available. | |
522 | */ | |
523 | return 0; | |
524 | } else if (!found_export) { | |
75368aab EB |
525 | error_setg(errp, "No export with name '%s' available", |
526 | wantname); | |
527 | nbd_send_opt_abort(ioc); | |
528 | return -1; | |
529 | } | |
9588463e | 530 | trace_nbd_receive_query_exports_success(wantname); |
75368aab | 531 | return 0; |
9344e5f5 | 532 | } |
091d0bf3 EB |
533 | list_empty = false; |
534 | if (!strcmp(name, wantname)) { | |
535 | found_export = true; | |
536 | } | |
537 | g_free(name); | |
9344e5f5 | 538 | } |
9344e5f5 DB |
539 | } |
540 | ||
d795299b VSO |
541 | /* nbd_request_simple_option: Send an option request, and parse the reply |
542 | * return 1 for successful negotiation, | |
543 | * 0 if operation is unsupported, | |
544 | * -1 with errp set for any other error | |
545 | */ | |
546 | static int nbd_request_simple_option(QIOChannel *ioc, int opt, Error **errp) | |
f95910fe | 547 | { |
420a4e95 | 548 | NBDOptionReply reply; |
d795299b | 549 | int error; |
f95910fe | 550 | |
d795299b VSO |
551 | if (nbd_send_option_request(ioc, opt, 0, NULL, errp) < 0) { |
552 | return -1; | |
f95910fe DB |
553 | } |
554 | ||
d795299b VSO |
555 | if (nbd_receive_option_reply(ioc, opt, &reply, errp) < 0) { |
556 | return -1; | |
557 | } | |
558 | error = nbd_handle_reply_err(ioc, &reply, errp); | |
559 | if (error <= 0) { | |
560 | return error; | |
f95910fe | 561 | } |
c8a3a1b6 EB |
562 | |
563 | if (reply.type != NBD_REP_ACK) { | |
d795299b | 564 | error_setg(errp, "Server answered option %d (%s) with unexpected " |
28fb494f | 565 | "reply %" PRIu32 " (%s)", opt, nbd_opt_lookup(opt), |
d795299b | 566 | reply.type, nbd_rep_lookup(reply.type)); |
2cdbf413 | 567 | nbd_send_opt_abort(ioc); |
d795299b | 568 | return -1; |
f95910fe DB |
569 | } |
570 | ||
c8a3a1b6 | 571 | if (reply.length != 0) { |
d795299b VSO |
572 | error_setg(errp, "Option %d ('%s') response length is %" PRIu32 |
573 | " (it should be zero)", opt, nbd_opt_lookup(opt), | |
c8a3a1b6 | 574 | reply.length); |
2cdbf413 | 575 | nbd_send_opt_abort(ioc); |
d795299b VSO |
576 | return -1; |
577 | } | |
578 | ||
579 | return 1; | |
580 | } | |
581 | ||
582 | static QIOChannel *nbd_receive_starttls(QIOChannel *ioc, | |
583 | QCryptoTLSCreds *tlscreds, | |
584 | const char *hostname, Error **errp) | |
585 | { | |
586 | int ret; | |
587 | QIOChannelTLS *tioc; | |
588 | struct NBDTLSHandshakeData data = { 0 }; | |
589 | ||
590 | ret = nbd_request_simple_option(ioc, NBD_OPT_STARTTLS, errp); | |
591 | if (ret <= 0) { | |
592 | if (ret == 0) { | |
593 | error_setg(errp, "Server don't support STARTTLS option"); | |
594 | nbd_send_opt_abort(ioc); | |
595 | } | |
f95910fe DB |
596 | return NULL; |
597 | } | |
598 | ||
9588463e | 599 | trace_nbd_receive_starttls_new_client(); |
f95910fe DB |
600 | tioc = qio_channel_tls_new_client(ioc, tlscreds, hostname, errp); |
601 | if (!tioc) { | |
602 | return NULL; | |
603 | } | |
0d73f725 | 604 | qio_channel_set_name(QIO_CHANNEL(tioc), "nbd-client-tls"); |
f95910fe | 605 | data.loop = g_main_loop_new(g_main_context_default(), FALSE); |
9588463e | 606 | trace_nbd_receive_starttls_tls_handshake(); |
f95910fe DB |
607 | qio_channel_tls_handshake(tioc, |
608 | nbd_tls_handshake, | |
609 | &data, | |
1939ccda | 610 | NULL, |
f95910fe DB |
611 | NULL); |
612 | ||
613 | if (!data.complete) { | |
614 | g_main_loop_run(data.loop); | |
615 | } | |
616 | g_main_loop_unref(data.loop); | |
617 | if (data.error) { | |
618 | error_propagate(errp, data.error); | |
619 | object_unref(OBJECT(tioc)); | |
620 | return NULL; | |
621 | } | |
622 | ||
623 | return QIO_CHANNEL(tioc); | |
624 | } | |
625 | ||
757b3ab9 EB |
626 | /* |
627 | * nbd_send_meta_query: | |
628 | * Send 0 or 1 set/list meta context queries. | |
629 | * Return 0 on success, -1 with errp set for any error | |
630 | */ | |
631 | static int nbd_send_meta_query(QIOChannel *ioc, uint32_t opt, | |
632 | const char *export, const char *query, | |
633 | Error **errp) | |
634 | { | |
635 | int ret; | |
636 | uint32_t export_len = strlen(export); | |
637 | uint32_t queries = !!query; | |
638 | uint32_t query_len = 0; | |
639 | uint32_t data_len; | |
640 | char *data; | |
641 | char *p; | |
642 | ||
643 | data_len = sizeof(export_len) + export_len + sizeof(queries); | |
644 | if (query) { | |
645 | query_len = strlen(query); | |
646 | data_len += sizeof(query_len) + query_len; | |
647 | } else { | |
648 | assert(opt == NBD_OPT_LIST_META_CONTEXT); | |
649 | } | |
650 | p = data = g_malloc(data_len); | |
651 | ||
652 | trace_nbd_opt_meta_request(nbd_opt_lookup(opt), query ?: "(all)", export); | |
653 | stl_be_p(p, export_len); | |
654 | memcpy(p += sizeof(export_len), export, export_len); | |
655 | stl_be_p(p += export_len, queries); | |
656 | if (query) { | |
657 | stl_be_p(p += sizeof(queries), query_len); | |
658 | memcpy(p += sizeof(query_len), query, query_len); | |
659 | } | |
660 | ||
661 | ret = nbd_send_option_request(ioc, opt, data_len, data, errp); | |
662 | g_free(data); | |
663 | return ret; | |
664 | } | |
665 | ||
0182c1ae EB |
666 | /* |
667 | * nbd_receive_one_meta_context: | |
668 | * Called in a loop to receive and trace one set/list meta context reply. | |
669 | * Pass non-NULL @name or @id to collect results back to the caller, which | |
670 | * must eventually call g_free(). | |
671 | * return 1 if name is set and iteration must continue, | |
672 | * 0 if iteration is complete (including if option is unsupported), | |
673 | * -1 with errp set for any error | |
674 | */ | |
675 | static int nbd_receive_one_meta_context(QIOChannel *ioc, | |
676 | uint32_t opt, | |
677 | char **name, | |
678 | uint32_t *id, | |
679 | Error **errp) | |
680 | { | |
681 | int ret; | |
682 | NBDOptionReply reply; | |
683 | char *local_name = NULL; | |
684 | uint32_t local_id; | |
685 | ||
686 | if (nbd_receive_option_reply(ioc, opt, &reply, errp) < 0) { | |
687 | return -1; | |
688 | } | |
689 | ||
690 | ret = nbd_handle_reply_err(ioc, &reply, errp); | |
691 | if (ret <= 0) { | |
692 | return ret; | |
693 | } | |
694 | ||
695 | if (reply.type == NBD_REP_ACK) { | |
696 | if (reply.length != 0) { | |
697 | error_setg(errp, "Unexpected length to ACK response"); | |
698 | nbd_send_opt_abort(ioc); | |
699 | return -1; | |
700 | } | |
701 | return 0; | |
702 | } else if (reply.type != NBD_REP_META_CONTEXT) { | |
703 | error_setg(errp, "Unexpected reply type %u (%s), expected %u (%s)", | |
704 | reply.type, nbd_rep_lookup(reply.type), | |
705 | NBD_REP_META_CONTEXT, nbd_rep_lookup(NBD_REP_META_CONTEXT)); | |
706 | nbd_send_opt_abort(ioc); | |
707 | return -1; | |
708 | } | |
709 | ||
710 | if (reply.length <= sizeof(local_id) || | |
711 | reply.length > NBD_MAX_BUFFER_SIZE) { | |
712 | error_setg(errp, "Failed to negotiate meta context, server " | |
713 | "answered with unexpected length %" PRIu32, | |
714 | reply.length); | |
715 | nbd_send_opt_abort(ioc); | |
716 | return -1; | |
717 | } | |
718 | ||
e6798f06 | 719 | if (nbd_read32(ioc, &local_id, "context id", errp) < 0) { |
0182c1ae EB |
720 | return -1; |
721 | } | |
0182c1ae EB |
722 | |
723 | reply.length -= sizeof(local_id); | |
724 | local_name = g_malloc(reply.length + 1); | |
e6798f06 | 725 | if (nbd_read(ioc, local_name, reply.length, "context name", errp) < 0) { |
0182c1ae EB |
726 | g_free(local_name); |
727 | return -1; | |
728 | } | |
729 | local_name[reply.length] = '\0'; | |
730 | trace_nbd_opt_meta_reply(nbd_opt_lookup(opt), local_name, local_id); | |
731 | ||
732 | if (name) { | |
733 | *name = local_name; | |
734 | } else { | |
735 | g_free(local_name); | |
736 | } | |
737 | if (id) { | |
738 | *id = local_id; | |
739 | } | |
740 | return 1; | |
741 | } | |
742 | ||
743 | /* | |
744 | * nbd_negotiate_simple_meta_context: | |
2df94eb5 EB |
745 | * Request the server to set the meta context for export @info->name |
746 | * using @info->x_dirty_bitmap with a fallback to "base:allocation", | |
747 | * setting @info->context_id to the resulting id. Fail if the server | |
748 | * responds with more than one context or with a context different | |
749 | * than the query. | |
750 | * return 1 for successful negotiation, | |
78a33ab5 VSO |
751 | * 0 if operation is unsupported, |
752 | * -1 with errp set for any other error | |
753 | */ | |
754 | static int nbd_negotiate_simple_meta_context(QIOChannel *ioc, | |
2df94eb5 | 755 | NBDExportInfo *info, |
78a33ab5 VSO |
756 | Error **errp) |
757 | { | |
2df94eb5 EB |
758 | /* |
759 | * TODO: Removing the x_dirty_bitmap hack will mean refactoring | |
760 | * this function to request and store ids for multiple contexts | |
761 | * (both base:allocation and a dirty bitmap), at which point this | |
762 | * function should lose the term _simple. | |
763 | */ | |
78a33ab5 | 764 | int ret; |
2df94eb5 | 765 | const char *context = info->x_dirty_bitmap ?: "base:allocation"; |
89aa0d87 | 766 | bool received = false; |
0182c1ae | 767 | char *name = NULL; |
78a33ab5 | 768 | |
757b3ab9 EB |
769 | if (nbd_send_meta_query(ioc, NBD_OPT_SET_META_CONTEXT, |
770 | info->name, context, errp) < 0) { | |
771 | return -1; | |
78a33ab5 VSO |
772 | } |
773 | ||
0182c1ae EB |
774 | ret = nbd_receive_one_meta_context(ioc, NBD_OPT_SET_META_CONTEXT, |
775 | &name, &info->context_id, errp); | |
776 | if (ret < 0) { | |
78a33ab5 VSO |
777 | return -1; |
778 | } | |
0182c1ae | 779 | if (ret == 1) { |
78a33ab5 VSO |
780 | if (strcmp(context, name)) { |
781 | error_setg(errp, "Failed to negotiate meta context '%s', server " | |
782 | "answered with different context '%s'", context, | |
783 | name); | |
784 | g_free(name); | |
260e34db | 785 | nbd_send_opt_abort(ioc); |
78a33ab5 VSO |
786 | return -1; |
787 | } | |
788 | g_free(name); | |
78a33ab5 VSO |
789 | received = true; |
790 | ||
0182c1ae EB |
791 | ret = nbd_receive_one_meta_context(ioc, NBD_OPT_SET_META_CONTEXT, |
792 | NULL, NULL, errp); | |
793 | if (ret < 0) { | |
78a33ab5 VSO |
794 | return -1; |
795 | } | |
78a33ab5 | 796 | } |
0182c1ae EB |
797 | if (ret != 0) { |
798 | error_setg(errp, "Server answered with more than one context"); | |
260e34db EB |
799 | nbd_send_opt_abort(ioc); |
800 | return -1; | |
801 | } | |
2df94eb5 | 802 | return received; |
78a33ab5 | 803 | } |
f95910fe | 804 | |
0b576b6b EB |
805 | /* |
806 | * nbd_list_meta_contexts: | |
807 | * Request the server to list all meta contexts for export @info->name. | |
808 | * return 0 if list is complete (even if empty), | |
809 | * -1 with errp set for any error | |
810 | */ | |
811 | static int nbd_list_meta_contexts(QIOChannel *ioc, | |
812 | NBDExportInfo *info, | |
813 | Error **errp) | |
814 | { | |
815 | int ret; | |
7c6f5ddc EB |
816 | int seen_any = false; |
817 | int seen_qemu = false; | |
0b576b6b EB |
818 | |
819 | if (nbd_send_meta_query(ioc, NBD_OPT_LIST_META_CONTEXT, | |
820 | info->name, NULL, errp) < 0) { | |
821 | return -1; | |
822 | } | |
823 | ||
824 | while (1) { | |
825 | char *context; | |
826 | ||
827 | ret = nbd_receive_one_meta_context(ioc, NBD_OPT_LIST_META_CONTEXT, | |
828 | &context, NULL, errp); | |
7c6f5ddc EB |
829 | if (ret == 0 && seen_any && !seen_qemu) { |
830 | /* | |
831 | * Work around qemu 3.0 bug: the server forgot to send | |
832 | * "qemu:" replies to 0 queries. If we saw at least one | |
833 | * reply (probably base:allocation), but none of them were | |
834 | * qemu:, then run a more specific query to make sure. | |
835 | */ | |
836 | seen_qemu = true; | |
837 | if (nbd_send_meta_query(ioc, NBD_OPT_LIST_META_CONTEXT, | |
838 | info->name, "qemu:", errp) < 0) { | |
839 | return -1; | |
840 | } | |
841 | continue; | |
842 | } | |
0b576b6b EB |
843 | if (ret <= 0) { |
844 | return ret; | |
845 | } | |
7c6f5ddc EB |
846 | seen_any = true; |
847 | seen_qemu |= strstart(context, "qemu:", NULL); | |
0b576b6b EB |
848 | info->contexts = g_renew(char *, info->contexts, ++info->n_contexts); |
849 | info->contexts[info->n_contexts - 1] = context; | |
850 | } | |
851 | } | |
852 | ||
10b89988 EB |
853 | /* |
854 | * nbd_start_negotiate: | |
855 | * Start the handshake to the server. After a positive return, the server | |
856 | * is ready to accept additional NBD_OPT requests. | |
857 | * Returns: negative errno: failure talking to server | |
b3c9d33b | 858 | * 0: server is oldstyle, must call nbd_negotiate_finish_oldstyle |
10b89988 EB |
859 | * 1: server is newstyle, but can only accept EXPORT_NAME |
860 | * 2: server is newstyle, but lacks structured replies | |
861 | * 3: server is newstyle and set up for structured replies | |
862 | */ | |
a8e2bb6a VSO |
863 | static int nbd_start_negotiate(AioContext *aio_context, QIOChannel *ioc, |
864 | QCryptoTLSCreds *tlscreds, | |
10b89988 EB |
865 | const char *hostname, QIOChannel **outioc, |
866 | bool structured_reply, bool *zeroes, | |
867 | Error **errp) | |
798bfe00 | 868 | { |
004a89fc | 869 | uint64_t magic; |
798bfe00 | 870 | |
10b89988 | 871 | trace_nbd_start_negotiate(tlscreds, hostname ? hostname : "<null>"); |
798bfe00 | 872 | |
d21a2d34 EB |
873 | if (zeroes) { |
874 | *zeroes = true; | |
875 | } | |
f95910fe DB |
876 | if (outioc) { |
877 | *outioc = NULL; | |
878 | } | |
879 | if (tlscreds && !outioc) { | |
880 | error_setg(errp, "Output I/O channel required for TLS"); | |
2b8d0954 | 881 | return -EINVAL; |
f95910fe DB |
882 | } |
883 | ||
e6798f06 | 884 | if (nbd_read64(ioc, &magic, "initial magic", errp) < 0) { |
2b8d0954 | 885 | return -EINVAL; |
798bfe00 | 886 | } |
9588463e | 887 | trace_nbd_receive_negotiate_magic(magic); |
798bfe00 | 888 | |
ef2e35fc EB |
889 | if (magic != NBD_INIT_MAGIC) { |
890 | error_setg(errp, "Bad initial magic received: 0x%" PRIx64, magic); | |
2b8d0954 | 891 | return -EINVAL; |
798bfe00 FZ |
892 | } |
893 | ||
e6798f06 | 894 | if (nbd_read64(ioc, &magic, "server magic", errp) < 0) { |
2b8d0954 | 895 | return -EINVAL; |
798bfe00 | 896 | } |
9588463e | 897 | trace_nbd_receive_negotiate_magic(magic); |
798bfe00 | 898 | |
f72d705f | 899 | if (magic == NBD_OPTS_MAGIC) { |
e2a9d9a3 | 900 | uint32_t clientflags = 0; |
e2a9d9a3 | 901 | uint16_t globalflags; |
9344e5f5 | 902 | bool fixedNewStyle = false; |
798bfe00 | 903 | |
e6798f06 | 904 | if (nbd_read16(ioc, &globalflags, "server flags", errp) < 0) { |
2b8d0954 | 905 | return -EINVAL; |
798bfe00 | 906 | } |
9588463e | 907 | trace_nbd_receive_negotiate_server_flags(globalflags); |
e2a9d9a3 | 908 | if (globalflags & NBD_FLAG_FIXED_NEWSTYLE) { |
9344e5f5 | 909 | fixedNewStyle = true; |
e2a9d9a3 DB |
910 | clientflags |= NBD_FLAG_C_FIXED_NEWSTYLE; |
911 | } | |
c203c59a | 912 | if (globalflags & NBD_FLAG_NO_ZEROES) { |
d21a2d34 EB |
913 | if (zeroes) { |
914 | *zeroes = false; | |
915 | } | |
c203c59a EB |
916 | clientflags |= NBD_FLAG_C_NO_ZEROES; |
917 | } | |
e2a9d9a3 | 918 | /* client requested flags */ |
9344e5f5 | 919 | clientflags = cpu_to_be32(clientflags); |
d1fdf257 | 920 | if (nbd_write(ioc, &clientflags, sizeof(clientflags), errp) < 0) { |
cb6b1a3f | 921 | error_prepend(errp, "Failed to send clientflags field: "); |
2b8d0954 | 922 | return -EINVAL; |
798bfe00 | 923 | } |
f95910fe DB |
924 | if (tlscreds) { |
925 | if (fixedNewStyle) { | |
926 | *outioc = nbd_receive_starttls(ioc, tlscreds, hostname, errp); | |
927 | if (!*outioc) { | |
2b8d0954 | 928 | return -EINVAL; |
f95910fe DB |
929 | } |
930 | ioc = *outioc; | |
a8e2bb6a VSO |
931 | if (aio_context) { |
932 | qio_channel_set_blocking(ioc, false, NULL); | |
933 | qio_channel_attach_aio_context(ioc, aio_context); | |
934 | } | |
f95910fe DB |
935 | } else { |
936 | error_setg(errp, "Server does not support STARTTLS"); | |
2b8d0954 | 937 | return -EINVAL; |
f95910fe DB |
938 | } |
939 | } | |
9344e5f5 | 940 | if (fixedNewStyle) { |
10b89988 | 941 | int result = 0; |
8ecaeae8 | 942 | |
f140e300 VSO |
943 | if (structured_reply) { |
944 | result = nbd_request_simple_option(ioc, | |
945 | NBD_OPT_STRUCTURED_REPLY, | |
946 | errp); | |
947 | if (result < 0) { | |
2b8d0954 | 948 | return -EINVAL; |
f140e300 | 949 | } |
f140e300 | 950 | } |
10b89988 EB |
951 | return 2 + result; |
952 | } else { | |
953 | return 1; | |
954 | } | |
955 | } else if (magic == NBD_CLIENT_MAGIC) { | |
956 | if (tlscreds) { | |
957 | error_setg(errp, "Server does not support STARTTLS"); | |
958 | return -EINVAL; | |
959 | } | |
960 | return 0; | |
961 | } else { | |
962 | error_setg(errp, "Bad server magic received: 0x%" PRIx64, magic); | |
963 | return -EINVAL; | |
964 | } | |
965 | } | |
f140e300 | 966 | |
b3c9d33b EB |
967 | /* |
968 | * nbd_negotiate_finish_oldstyle: | |
969 | * Populate @info with the size and export flags from an oldstyle server, | |
970 | * but does not consume 124 bytes of reserved zero padding. | |
971 | * Returns 0 on success, -1 with @errp set on failure | |
972 | */ | |
973 | static int nbd_negotiate_finish_oldstyle(QIOChannel *ioc, NBDExportInfo *info, | |
974 | Error **errp) | |
975 | { | |
976 | uint32_t oldflags; | |
977 | ||
e6798f06 | 978 | if (nbd_read64(ioc, &info->size, "export length", errp) < 0) { |
b3c9d33b EB |
979 | return -EINVAL; |
980 | } | |
b3c9d33b | 981 | |
e6798f06 | 982 | if (nbd_read32(ioc, &oldflags, "export flags", errp) < 0) { |
b3c9d33b EB |
983 | return -EINVAL; |
984 | } | |
b3c9d33b EB |
985 | if (oldflags & ~0xffff) { |
986 | error_setg(errp, "Unexpected export flags %0x" PRIx32, oldflags); | |
987 | return -EINVAL; | |
988 | } | |
989 | info->flags = oldflags; | |
990 | return 0; | |
991 | } | |
992 | ||
10b89988 EB |
993 | /* |
994 | * nbd_receive_negotiate: | |
995 | * Connect to server, complete negotiation, and move into transmission phase. | |
996 | * Returns: negative errno: failure talking to server | |
997 | * 0: server is connected | |
998 | */ | |
a8e2bb6a VSO |
999 | int nbd_receive_negotiate(AioContext *aio_context, QIOChannel *ioc, |
1000 | QCryptoTLSCreds *tlscreds, | |
10b89988 EB |
1001 | const char *hostname, QIOChannel **outioc, |
1002 | NBDExportInfo *info, Error **errp) | |
1003 | { | |
1004 | int result; | |
1005 | bool zeroes; | |
1006 | bool base_allocation = info->base_allocation; | |
78a33ab5 | 1007 | |
10b89988 EB |
1008 | assert(info->name); |
1009 | trace_nbd_receive_negotiate_name(info->name); | |
1010 | ||
a8e2bb6a | 1011 | result = nbd_start_negotiate(aio_context, ioc, tlscreds, hostname, outioc, |
10b89988 EB |
1012 | info->structured_reply, &zeroes, errp); |
1013 | ||
1014 | info->structured_reply = false; | |
1015 | info->base_allocation = false; | |
1016 | if (tlscreds && *outioc) { | |
1017 | ioc = *outioc; | |
1018 | } | |
1019 | ||
1020 | switch (result) { | |
1021 | case 3: /* newstyle, with structured replies */ | |
1022 | info->structured_reply = true; | |
1023 | if (base_allocation) { | |
1024 | result = nbd_negotiate_simple_meta_context(ioc, info, errp); | |
8ecaeae8 | 1025 | if (result < 0) { |
2b8d0954 | 1026 | return -EINVAL; |
8ecaeae8 | 1027 | } |
10b89988 EB |
1028 | info->base_allocation = result == 1; |
1029 | } | |
1030 | /* fall through */ | |
1031 | case 2: /* newstyle, try OPT_GO */ | |
1032 | /* Try NBD_OPT_GO first - if it works, we are done (it | |
1033 | * also gives us a good message if the server requires | |
1034 | * TLS). If it is not available, fall back to | |
1035 | * NBD_OPT_LIST for nicer error messages about a missing | |
1036 | * export, then use NBD_OPT_EXPORT_NAME. */ | |
138796d0 | 1037 | result = nbd_opt_info_or_go(ioc, NBD_OPT_GO, info, errp); |
10b89988 EB |
1038 | if (result < 0) { |
1039 | return -EINVAL; | |
9344e5f5 | 1040 | } |
10b89988 EB |
1041 | if (result > 0) { |
1042 | return 0; | |
1043 | } | |
1044 | /* Check our desired export is present in the | |
1045 | * server export list. Since NBD_OPT_EXPORT_NAME | |
1046 | * cannot return an error message, running this | |
1047 | * query gives us better error reporting if the | |
1048 | * export name is not available. | |
1049 | */ | |
1050 | if (nbd_receive_query_exports(ioc, info->name, errp) < 0) { | |
1051 | return -EINVAL; | |
1052 | } | |
1053 | /* fall through */ | |
1054 | case 1: /* newstyle, but limited to EXPORT_NAME */ | |
c8a3a1b6 | 1055 | /* write the export name request */ |
6dc1667d | 1056 | if (nbd_send_option_request(ioc, NBD_OPT_EXPORT_NAME, -1, info->name, |
c8a3a1b6 | 1057 | errp) < 0) { |
2b8d0954 | 1058 | return -EINVAL; |
798bfe00 | 1059 | } |
f72d705f | 1060 | |
c8a3a1b6 | 1061 | /* Read the response */ |
e6798f06 | 1062 | if (nbd_read64(ioc, &info->size, "export length", errp) < 0) { |
2b8d0954 | 1063 | return -EINVAL; |
798bfe00 | 1064 | } |
798bfe00 | 1065 | |
e6798f06 | 1066 | if (nbd_read16(ioc, &info->flags, "export flags", errp) < 0) { |
2b8d0954 | 1067 | return -EINVAL; |
f72d705f | 1068 | } |
10b89988 EB |
1069 | break; |
1070 | case 0: /* oldstyle, parse length and flags */ | |
6dc1667d EB |
1071 | if (*info->name) { |
1072 | error_setg(errp, "Server does not support non-empty export names"); | |
2b8d0954 | 1073 | return -EINVAL; |
f72d705f | 1074 | } |
b3c9d33b | 1075 | if (nbd_negotiate_finish_oldstyle(ioc, info, errp) < 0) { |
2b8d0954 | 1076 | return -EINVAL; |
7423f417 | 1077 | } |
10b89988 EB |
1078 | break; |
1079 | default: | |
1080 | return result; | |
798bfe00 | 1081 | } |
f72d705f | 1082 | |
004a89fc | 1083 | trace_nbd_receive_negotiate_size_flags(info->size, info->flags); |
d1fdf257 | 1084 | if (zeroes && nbd_drop(ioc, 124, errp) < 0) { |
cb6b1a3f | 1085 | error_prepend(errp, "Failed to read reserved block: "); |
2b8d0954 | 1086 | return -EINVAL; |
798bfe00 | 1087 | } |
2b8d0954 | 1088 | return 0; |
798bfe00 FZ |
1089 | } |
1090 | ||
d21a2d34 EB |
1091 | /* Clean up result of nbd_receive_export_list */ |
1092 | void nbd_free_export_list(NBDExportInfo *info, int count) | |
1093 | { | |
0b576b6b | 1094 | int i, j; |
d21a2d34 EB |
1095 | |
1096 | if (!info) { | |
1097 | return; | |
1098 | } | |
1099 | ||
1100 | for (i = 0; i < count; i++) { | |
1101 | g_free(info[i].name); | |
1102 | g_free(info[i].description); | |
0b576b6b EB |
1103 | for (j = 0; j < info[i].n_contexts; j++) { |
1104 | g_free(info[i].contexts[j]); | |
1105 | } | |
1106 | g_free(info[i].contexts); | |
d21a2d34 EB |
1107 | } |
1108 | g_free(info); | |
1109 | } | |
1110 | ||
1111 | /* | |
1112 | * nbd_receive_export_list: | |
1113 | * Query details about a server's exports, then disconnect without | |
1114 | * going into transmission phase. Return a count of the exports listed | |
1115 | * in @info by the server, or -1 on error. Caller must free @info using | |
1116 | * nbd_free_export_list(). | |
1117 | */ | |
1118 | int nbd_receive_export_list(QIOChannel *ioc, QCryptoTLSCreds *tlscreds, | |
1119 | const char *hostname, NBDExportInfo **info, | |
1120 | Error **errp) | |
1121 | { | |
1122 | int result; | |
1123 | int count = 0; | |
1124 | int i; | |
1125 | int rc; | |
1126 | int ret = -1; | |
1127 | NBDExportInfo *array = NULL; | |
1128 | QIOChannel *sioc = NULL; | |
1129 | ||
1130 | *info = NULL; | |
a8e2bb6a VSO |
1131 | result = nbd_start_negotiate(NULL, ioc, tlscreds, hostname, &sioc, true, |
1132 | NULL, errp); | |
d21a2d34 EB |
1133 | if (tlscreds && sioc) { |
1134 | ioc = sioc; | |
1135 | } | |
1136 | ||
1137 | switch (result) { | |
1138 | case 2: | |
1139 | case 3: | |
1140 | /* newstyle - use NBD_OPT_LIST to populate array, then try | |
1141 | * NBD_OPT_INFO on each array member. If structured replies | |
1142 | * are enabled, also try NBD_OPT_LIST_META_CONTEXT. */ | |
1143 | if (nbd_send_option_request(ioc, NBD_OPT_LIST, 0, NULL, errp) < 0) { | |
1144 | goto out; | |
1145 | } | |
1146 | while (1) { | |
1147 | char *name; | |
1148 | char *desc; | |
1149 | ||
1150 | rc = nbd_receive_list(ioc, &name, &desc, errp); | |
1151 | if (rc < 0) { | |
1152 | goto out; | |
1153 | } else if (rc == 0) { | |
1154 | break; | |
1155 | } | |
1156 | array = g_renew(NBDExportInfo, array, ++count); | |
1157 | memset(&array[count - 1], 0, sizeof(*array)); | |
1158 | array[count - 1].name = name; | |
1159 | array[count - 1].description = desc; | |
1160 | array[count - 1].structured_reply = result == 3; | |
1161 | } | |
1162 | ||
1163 | for (i = 0; i < count; i++) { | |
1164 | array[i].request_sizes = true; | |
1165 | rc = nbd_opt_info_or_go(ioc, NBD_OPT_INFO, &array[i], errp); | |
1166 | if (rc < 0) { | |
1167 | goto out; | |
1168 | } else if (rc == 0) { | |
1169 | /* | |
1170 | * Pointless to try rest of loop. If OPT_INFO doesn't work, | |
1171 | * it's unlikely that meta contexts work either | |
1172 | */ | |
1173 | break; | |
1174 | } | |
1175 | ||
0b576b6b EB |
1176 | if (result == 3 && |
1177 | nbd_list_meta_contexts(ioc, &array[i], errp) < 0) { | |
1178 | goto out; | |
1179 | } | |
d21a2d34 EB |
1180 | } |
1181 | ||
1182 | /* Send NBD_OPT_ABORT as a courtesy before hanging up */ | |
1183 | nbd_send_opt_abort(ioc); | |
1184 | break; | |
1185 | case 1: /* newstyle, but limited to EXPORT_NAME */ | |
1186 | error_setg(errp, "Server does not support export lists"); | |
1187 | /* We can't even send NBD_OPT_ABORT, so merely hang up */ | |
1188 | goto out; | |
1189 | case 0: /* oldstyle, parse length and flags */ | |
1190 | array = g_new0(NBDExportInfo, 1); | |
1191 | array->name = g_strdup(""); | |
1192 | count = 1; | |
1193 | ||
1194 | if (nbd_negotiate_finish_oldstyle(ioc, array, errp) < 0) { | |
1195 | goto out; | |
1196 | } | |
1197 | ||
1198 | /* Send NBD_CMD_DISC as a courtesy to the server, but ignore all | |
1199 | * errors now that we have the information we wanted. */ | |
1200 | if (nbd_drop(ioc, 124, NULL) == 0) { | |
1201 | NBDRequest request = { .type = NBD_CMD_DISC }; | |
1202 | ||
1203 | nbd_send_request(ioc, &request); | |
1204 | } | |
1205 | break; | |
1206 | default: | |
1207 | goto out; | |
1208 | } | |
1209 | ||
1210 | *info = array; | |
1211 | array = NULL; | |
1212 | ret = count; | |
1213 | ||
1214 | out: | |
1215 | qio_channel_shutdown(ioc, QIO_CHANNEL_SHUTDOWN_BOTH, NULL); | |
1216 | qio_channel_close(ioc, NULL); | |
1217 | object_unref(OBJECT(sioc)); | |
1218 | nbd_free_export_list(array, count); | |
1219 | return ret; | |
1220 | } | |
1221 | ||
798bfe00 | 1222 | #ifdef __linux__ |
004a89fc | 1223 | int nbd_init(int fd, QIOChannelSocket *sioc, NBDExportInfo *info, |
be41c100 | 1224 | Error **errp) |
798bfe00 | 1225 | { |
081dd1fe EB |
1226 | unsigned long sector_size = MAX(BDRV_SECTOR_SIZE, info->min_block); |
1227 | unsigned long sectors = info->size / sector_size; | |
1228 | ||
1229 | /* FIXME: Once the kernel module is patched to honor block sizes, | |
1230 | * and to advertise that fact to user space, we should update the | |
1231 | * hand-off to the kernel to use any block sizes we learned. */ | |
1232 | assert(!info->request_sizes); | |
1233 | if (info->size / sector_size != sectors) { | |
004a89fc EB |
1234 | error_setg(errp, "Export size %" PRIu64 " too large for 32-bit kernel", |
1235 | info->size); | |
f57e2416 EB |
1236 | return -E2BIG; |
1237 | } | |
1238 | ||
9588463e | 1239 | trace_nbd_init_set_socket(); |
798bfe00 | 1240 | |
f57e2416 | 1241 | if (ioctl(fd, NBD_SET_SOCK, (unsigned long) sioc->fd) < 0) { |
798bfe00 | 1242 | int serrno = errno; |
be41c100 | 1243 | error_setg(errp, "Failed to set NBD socket"); |
798bfe00 FZ |
1244 | return -serrno; |
1245 | } | |
1246 | ||
081dd1fe | 1247 | trace_nbd_init_set_block_size(sector_size); |
798bfe00 | 1248 | |
081dd1fe | 1249 | if (ioctl(fd, NBD_SET_BLKSIZE, sector_size) < 0) { |
798bfe00 | 1250 | int serrno = errno; |
be41c100 | 1251 | error_setg(errp, "Failed setting NBD block size"); |
798bfe00 FZ |
1252 | return -serrno; |
1253 | } | |
1254 | ||
9588463e | 1255 | trace_nbd_init_set_size(sectors); |
081dd1fe EB |
1256 | if (info->size % sector_size) { |
1257 | trace_nbd_init_trailing_bytes(info->size % sector_size); | |
f57e2416 | 1258 | } |
798bfe00 | 1259 | |
f57e2416 | 1260 | if (ioctl(fd, NBD_SET_SIZE_BLOCKS, sectors) < 0) { |
798bfe00 | 1261 | int serrno = errno; |
be41c100 | 1262 | error_setg(errp, "Failed setting size (in blocks)"); |
798bfe00 FZ |
1263 | return -serrno; |
1264 | } | |
1265 | ||
004a89fc | 1266 | if (ioctl(fd, NBD_SET_FLAGS, (unsigned long) info->flags) < 0) { |
798bfe00 | 1267 | if (errno == ENOTTY) { |
004a89fc | 1268 | int read_only = (info->flags & NBD_FLAG_READ_ONLY) != 0; |
9588463e | 1269 | trace_nbd_init_set_readonly(); |
798bfe00 FZ |
1270 | |
1271 | if (ioctl(fd, BLKROSET, (unsigned long) &read_only) < 0) { | |
1272 | int serrno = errno; | |
be41c100 | 1273 | error_setg(errp, "Failed setting read-only attribute"); |
798bfe00 FZ |
1274 | return -serrno; |
1275 | } | |
1276 | } else { | |
1277 | int serrno = errno; | |
be41c100 | 1278 | error_setg(errp, "Failed setting flags"); |
798bfe00 FZ |
1279 | return -serrno; |
1280 | } | |
1281 | } | |
1282 | ||
9588463e | 1283 | trace_nbd_init_finish(); |
798bfe00 FZ |
1284 | |
1285 | return 0; | |
1286 | } | |
1287 | ||
1288 | int nbd_client(int fd) | |
1289 | { | |
1290 | int ret; | |
1291 | int serrno; | |
1292 | ||
9588463e | 1293 | trace_nbd_client_loop(); |
798bfe00 FZ |
1294 | |
1295 | ret = ioctl(fd, NBD_DO_IT); | |
1296 | if (ret < 0 && errno == EPIPE) { | |
1297 | /* NBD_DO_IT normally returns EPIPE when someone has disconnected | |
1298 | * the socket via NBD_DISCONNECT. We do not want to return 1 in | |
1299 | * that case. | |
1300 | */ | |
1301 | ret = 0; | |
1302 | } | |
1303 | serrno = errno; | |
1304 | ||
9588463e | 1305 | trace_nbd_client_loop_ret(ret, strerror(serrno)); |
798bfe00 | 1306 | |
9588463e | 1307 | trace_nbd_client_clear_queue(); |
798bfe00 FZ |
1308 | ioctl(fd, NBD_CLEAR_QUE); |
1309 | ||
9588463e | 1310 | trace_nbd_client_clear_socket(); |
798bfe00 FZ |
1311 | ioctl(fd, NBD_CLEAR_SOCK); |
1312 | ||
1313 | errno = serrno; | |
1314 | return ret; | |
1315 | } | |
98494e3b EB |
1316 | |
1317 | int nbd_disconnect(int fd) | |
1318 | { | |
1319 | ioctl(fd, NBD_CLEAR_QUE); | |
1320 | ioctl(fd, NBD_DISCONNECT); | |
1321 | ioctl(fd, NBD_CLEAR_SOCK); | |
1322 | return 0; | |
1323 | } | |
1324 | ||
3c1fa35d | 1325 | #endif /* __linux__ */ |
798bfe00 | 1326 | |
490dc5ed | 1327 | int nbd_send_request(QIOChannel *ioc, NBDRequest *request) |
798bfe00 FZ |
1328 | { |
1329 | uint8_t buf[NBD_REQUEST_SIZE]; | |
798bfe00 | 1330 | |
9588463e | 1331 | trace_nbd_send_request(request->from, request->len, request->handle, |
48000eb3 EB |
1332 | request->flags, request->type, |
1333 | nbd_cmd_lookup(request->type)); | |
7548fe31 | 1334 | |
f6be6720 | 1335 | stl_be_p(buf, NBD_REQUEST_MAGIC); |
b626b51a EB |
1336 | stw_be_p(buf + 4, request->flags); |
1337 | stw_be_p(buf + 6, request->type); | |
f6be6720 PM |
1338 | stq_be_p(buf + 8, request->handle); |
1339 | stq_be_p(buf + 16, request->from); | |
1340 | stl_be_p(buf + 24, request->len); | |
798bfe00 | 1341 | |
d1fdf257 | 1342 | return nbd_write(ioc, buf, sizeof(buf), NULL); |
798bfe00 FZ |
1343 | } |
1344 | ||
d2febedb VSO |
1345 | /* nbd_receive_simple_reply |
1346 | * Read simple reply except magic field (which should be already read). | |
1347 | * Payload is not read (payload is possible for CMD_READ, but here we even | |
1348 | * don't know whether it take place or not). | |
1349 | */ | |
1350 | static int nbd_receive_simple_reply(QIOChannel *ioc, NBDSimpleReply *reply, | |
1351 | Error **errp) | |
1352 | { | |
1353 | int ret; | |
1354 | ||
1355 | assert(reply->magic == NBD_SIMPLE_REPLY_MAGIC); | |
1356 | ||
1357 | ret = nbd_read(ioc, (uint8_t *)reply + sizeof(reply->magic), | |
e6798f06 | 1358 | sizeof(*reply) - sizeof(reply->magic), "reply", errp); |
d2febedb VSO |
1359 | if (ret < 0) { |
1360 | return ret; | |
1361 | } | |
1362 | ||
80c7c2b0 PM |
1363 | reply->error = be32_to_cpu(reply->error); |
1364 | reply->handle = be64_to_cpu(reply->handle); | |
d2febedb VSO |
1365 | |
1366 | return 0; | |
1367 | } | |
1368 | ||
1369 | /* nbd_receive_structured_reply_chunk | |
1370 | * Read structured reply chunk except magic field (which should be already | |
1371 | * read). | |
1372 | * Payload is not read. | |
1373 | */ | |
1374 | static int nbd_receive_structured_reply_chunk(QIOChannel *ioc, | |
1375 | NBDStructuredReplyChunk *chunk, | |
1376 | Error **errp) | |
1377 | { | |
1378 | int ret; | |
1379 | ||
1380 | assert(chunk->magic == NBD_STRUCTURED_REPLY_MAGIC); | |
1381 | ||
1382 | ret = nbd_read(ioc, (uint8_t *)chunk + sizeof(chunk->magic), | |
e6798f06 VSO |
1383 | sizeof(*chunk) - sizeof(chunk->magic), "structured chunk", |
1384 | errp); | |
d2febedb VSO |
1385 | if (ret < 0) { |
1386 | return ret; | |
1387 | } | |
1388 | ||
80c7c2b0 PM |
1389 | chunk->flags = be16_to_cpu(chunk->flags); |
1390 | chunk->type = be16_to_cpu(chunk->type); | |
1391 | chunk->handle = be64_to_cpu(chunk->handle); | |
1392 | chunk->length = be32_to_cpu(chunk->length); | |
d2febedb VSO |
1393 | |
1394 | return 0; | |
1395 | } | |
1396 | ||
a7b78fc9 KW |
1397 | /* nbd_read_eof |
1398 | * Tries to read @size bytes from @ioc. | |
1399 | * Returns 1 on success | |
1400 | * 0 on eof, when no data was read (errp is not set) | |
1401 | * negative errno on failure (errp is set) | |
1402 | */ | |
1403 | static inline int coroutine_fn | |
d3bd5b90 KW |
1404 | nbd_read_eof(BlockDriverState *bs, QIOChannel *ioc, void *buffer, size_t size, |
1405 | Error **errp) | |
a7b78fc9 | 1406 | { |
d3bd5b90 | 1407 | bool partial = false; |
a7b78fc9 KW |
1408 | |
1409 | assert(size); | |
d3bd5b90 KW |
1410 | while (size > 0) { |
1411 | struct iovec iov = { .iov_base = buffer, .iov_len = size }; | |
1412 | ssize_t len; | |
1413 | ||
1414 | len = qio_channel_readv(ioc, &iov, 1, errp); | |
1415 | if (len == QIO_CHANNEL_ERR_BLOCK) { | |
1416 | bdrv_dec_in_flight(bs); | |
1417 | qio_channel_yield(ioc, G_IO_IN); | |
1418 | bdrv_inc_in_flight(bs); | |
1419 | continue; | |
1420 | } else if (len < 0) { | |
1421 | return -EIO; | |
1422 | } else if (len == 0) { | |
1423 | if (partial) { | |
1424 | error_setg(errp, | |
1425 | "Unexpected end-of-file before all bytes were read"); | |
1426 | return -EIO; | |
1427 | } else { | |
1428 | return 0; | |
1429 | } | |
1430 | } | |
1431 | ||
1432 | partial = true; | |
1433 | size -= len; | |
1434 | buffer = (uint8_t*) buffer + len; | |
a7b78fc9 | 1435 | } |
d3bd5b90 | 1436 | return 1; |
a7b78fc9 KW |
1437 | } |
1438 | ||
ba845644 | 1439 | /* nbd_receive_reply |
d3bd5b90 KW |
1440 | * |
1441 | * Decreases bs->in_flight while waiting for a new reply. This yield is where | |
1442 | * we wait indefinitely and the coroutine must be able to be safely reentered | |
1443 | * for nbd_client_attach_aio_context(). | |
1444 | * | |
ba845644 VSO |
1445 | * Returns 1 on success |
1446 | * 0 on eof, when no data was read (errp is not set) | |
1447 | * negative errno on failure (errp is set) | |
1448 | */ | |
d3bd5b90 KW |
1449 | int coroutine_fn nbd_receive_reply(BlockDriverState *bs, QIOChannel *ioc, |
1450 | NBDReply *reply, Error **errp) | |
798bfe00 | 1451 | { |
ba845644 | 1452 | int ret; |
079d3266 | 1453 | const char *type; |
798bfe00 | 1454 | |
d3bd5b90 | 1455 | ret = nbd_read_eof(bs, ioc, &reply->magic, sizeof(reply->magic), errp); |
ff82911c | 1456 | if (ret <= 0) { |
798bfe00 FZ |
1457 | return ret; |
1458 | } | |
1459 | ||
80c7c2b0 | 1460 | reply->magic = be32_to_cpu(reply->magic); |
798bfe00 | 1461 | |
d2febedb VSO |
1462 | switch (reply->magic) { |
1463 | case NBD_SIMPLE_REPLY_MAGIC: | |
1464 | ret = nbd_receive_simple_reply(ioc, &reply->simple, errp); | |
1465 | if (ret < 0) { | |
1466 | break; | |
1467 | } | |
d2febedb VSO |
1468 | trace_nbd_receive_simple_reply(reply->simple.error, |
1469 | nbd_err_lookup(reply->simple.error), | |
1470 | reply->handle); | |
d2febedb VSO |
1471 | break; |
1472 | case NBD_STRUCTURED_REPLY_MAGIC: | |
1473 | ret = nbd_receive_structured_reply_chunk(ioc, &reply->structured, errp); | |
1474 | if (ret < 0) { | |
1475 | break; | |
1476 | } | |
079d3266 | 1477 | type = nbd_reply_type_lookup(reply->structured.type); |
d2febedb | 1478 | trace_nbd_receive_structured_reply_chunk(reply->structured.flags, |
079d3266 | 1479 | reply->structured.type, type, |
d2febedb VSO |
1480 | reply->structured.handle, |
1481 | reply->structured.length); | |
1482 | break; | |
1483 | default: | |
1484 | error_setg(errp, "invalid magic (got 0x%" PRIx32 ")", reply->magic); | |
b6f5d3b5 EB |
1485 | return -EINVAL; |
1486 | } | |
d2febedb VSO |
1487 | if (ret < 0) { |
1488 | return ret; | |
798bfe00 | 1489 | } |
ba845644 VSO |
1490 | |
1491 | return 1; | |
798bfe00 FZ |
1492 | } |
1493 |