blob: 0c2db4bcba9f7a501e29a67bdae2dceb04d3b32e [file] [log] [blame]
Fam Zheng798bfe02016-01-14 16:41:02 +08001/*
Eric Blake5de47732019-08-24 12:28:13 -05002 * Copyright (C) 2016-2019 Red Hat, Inc.
Fam Zheng798bfe02016-01-14 16:41:02 +08003 * 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
Peter Maydelld38ea872016-01-29 17:50:05 +000020#include "qemu/osdep.h"
Markus Armbrusterda34e652016-03-14 09:01:28 +010021#include "qapi/error.h"
Markus Armbrusterdc5e9ac2019-08-12 07:23:49 +020022#include "qemu/queue.h"
Vladimir Sementsov-Ogievskiy95884632017-07-07 18:29:18 +030023#include "trace.h"
Fam Zheng798bfe02016-01-14 16:41:02 +080024#include "nbd-internal.h"
Eric Blake7c6f5dd2019-01-17 13:36:57 -060025#include "qemu/cutils.h"
Fam Zheng798bfe02016-01-14 16:41:02 +080026
Fam Zheng798bfe02016-01-14 16:41:02 +080027/* Definitions for opaque data types */
28
29static 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
Eric Blakec8a3a1b2016-10-14 13:33:10 -050060/* 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. */
67static int nbd_send_option_request(QIOChannel *ioc, uint32_t opt,
68 uint32_t len, const char *data,
69 Error **errp)
70{
Vladimir Sementsov-Ogievskiy795d9462020-07-07 18:50:36 +020071 ERRP_GUARD();
Vladimir Sementsov-Ogievskiy420a4e92017-11-22 13:19:57 +030072 NBDOption req;
Eric Blakec8a3a1b2016-10-14 13:33:10 -050073 QEMU_BUILD_BUG_ON(sizeof(req) != 16);
Daniel P. Berrange9344e5f2016-02-10 18:41:09 +000074
Eric Blakec8a3a1b2016-10-14 13:33:10 -050075 if (len == -1) {
76 req.length = len = strlen(data);
77 }
Eric Blake3736cc52017-07-07 15:30:43 -050078 trace_nbd_send_option_request(opt, nbd_opt_lookup(opt), len);
Eric Blakec8a3a1b2016-10-14 13:33:10 -050079
80 stq_be_p(&req.magic, NBD_OPTS_MAGIC);
81 stl_be_p(&req.option, opt);
82 stl_be_p(&req.length, len);
83
Vladimir Sementsov-Ogievskiyd1fdf252017-06-02 18:01:39 +030084 if (nbd_write(ioc, &req, sizeof(req), errp) < 0) {
Eric Blakecb6b1a32017-11-13 09:24:24 -060085 error_prepend(errp, "Failed to send option request header: ");
Eric Blakec8a3a1b2016-10-14 13:33:10 -050086 return -1;
87 }
88
Vladimir Sementsov-Ogievskiyd1fdf252017-06-02 18:01:39 +030089 if (len && nbd_write(ioc, (char *) data, len, errp) < 0) {
Eric Blakecb6b1a32017-11-13 09:24:24 -060090 error_prepend(errp, "Failed to send option request data: ");
Eric Blakec8a3a1b2016-10-14 13:33:10 -050091 return -1;
92 }
93
94 return 0;
95}
96
Eric Blake2cdbf412016-10-14 13:33:11 -050097/* Send NBD_OPT_ABORT as a courtesy to let the server know that we are
98 * not going to attempt further negotiation. */
99static void nbd_send_opt_abort(QIOChannel *ioc)
100{
101 /* Technically, a compliant server is supposed to reply to us; but
102 * older servers disconnected instead. At any rate, we're allowed
103 * to disconnect without waiting for the server reply, so we don't
104 * even care if the request makes it to the server, let alone
105 * waiting around for whether the server replies. */
106 nbd_send_option_request(ioc, NBD_OPT_ABORT, 0, NULL, NULL);
107}
108
109
Eric Blakec8a3a1b2016-10-14 13:33:10 -0500110/* Receive the header of an option reply, which should match the given
111 * opt. Read through the length field, but NOT the length bytes of
112 * payload. Return 0 if successful, -1 with errp set if it is
113 * impossible to continue. */
114static int nbd_receive_option_reply(QIOChannel *ioc, uint32_t opt,
Vladimir Sementsov-Ogievskiy420a4e92017-11-22 13:19:57 +0300115 NBDOptionReply *reply, Error **errp)
Eric Blakec8a3a1b2016-10-14 13:33:10 -0500116{
117 QEMU_BUILD_BUG_ON(sizeof(*reply) != 20);
Vladimir Sementsov-Ogievskiye6798f02019-01-28 19:58:30 +0300118 if (nbd_read(ioc, reply, sizeof(*reply), "option reply", errp) < 0) {
Eric Blake2cdbf412016-10-14 13:33:11 -0500119 nbd_send_opt_abort(ioc);
Eric Blakec8a3a1b2016-10-14 13:33:10 -0500120 return -1;
121 }
Peter Maydell80c7c2b2018-09-27 17:42:00 +0100122 reply->magic = be64_to_cpu(reply->magic);
123 reply->option = be32_to_cpu(reply->option);
124 reply->type = be32_to_cpu(reply->type);
125 reply->length = be32_to_cpu(reply->length);
Eric Blakec8a3a1b2016-10-14 13:33:10 -0500126
Eric Blake3736cc52017-07-07 15:30:43 -0500127 trace_nbd_receive_option_reply(reply->option, nbd_opt_lookup(reply->option),
128 reply->type, nbd_rep_lookup(reply->type),
129 reply->length);
Eric Blakec8a3a1b2016-10-14 13:33:10 -0500130
131 if (reply->magic != NBD_REP_MAGIC) {
132 error_setg(errp, "Unexpected option reply magic");
Eric Blake2cdbf412016-10-14 13:33:11 -0500133 nbd_send_opt_abort(ioc);
Eric Blakec8a3a1b2016-10-14 13:33:10 -0500134 return -1;
135 }
136 if (reply->option != opt) {
Eric Blake6c5c0352018-12-15 07:53:07 -0600137 error_setg(errp, "Unexpected option type %u (%s), expected %u (%s)",
138 reply->option, nbd_opt_lookup(reply->option),
139 opt, nbd_opt_lookup(opt));
Eric Blake2cdbf412016-10-14 13:33:11 -0500140 nbd_send_opt_abort(ioc);
Eric Blakec8a3a1b2016-10-14 13:33:10 -0500141 return -1;
142 }
143 return 0;
144}
145
Eric Blake5de47732019-08-24 12:28:13 -0500146/*
147 * If reply represents success, return 1 without further action. If
148 * reply represents an error, consume the optional payload of the
149 * packet on ioc. Then return 0 for unsupported (so the client can
150 * fall back to other approaches), where @strict determines if only
151 * ERR_UNSUP or all errors fit that category, or -1 with errp set for
152 * other errors.
Alex Bligh6ff58162016-04-06 10:59:22 -0600153 */
Vladimir Sementsov-Ogievskiy420a4e92017-11-22 13:19:57 +0300154static int nbd_handle_reply_err(QIOChannel *ioc, NBDOptionReply *reply,
Eric Blake5de47732019-08-24 12:28:13 -0500155 bool strict, Error **errp)
Daniel P. Berrange9344e5f2016-02-10 18:41:09 +0000156{
Vladimir Sementsov-Ogievskiy795d9462020-07-07 18:50:36 +0200157 ERRP_GUARD();
Eric Blake5de47732019-08-24 12:28:13 -0500158 g_autofree char *msg = NULL;
Alex Bligh6ff58162016-04-06 10:59:22 -0600159
Eric Blakec8a3a1b2016-10-14 13:33:10 -0500160 if (!(reply->type & (1 << 31))) {
Alex Bligh6ff58162016-04-06 10:59:22 -0600161 return 1;
162 }
163
Eric Blakec8a3a1b2016-10-14 13:33:10 -0500164 if (reply->length) {
165 if (reply->length > NBD_MAX_BUFFER_SIZE) {
Vladimir Sementsov-Ogievskiy28fb4942018-02-15 16:51:43 +0300166 error_setg(errp, "server error %" PRIu32
Eric Blake3736cc52017-07-07 15:30:43 -0500167 " (%s) message is too long",
168 reply->type, nbd_rep_lookup(reply->type));
Eric Blake5de47732019-08-24 12:28:13 -0500169 goto err;
Alex Bligh6ff58162016-04-06 10:59:22 -0600170 }
Eric Blakec8a3a1b2016-10-14 13:33:10 -0500171 msg = g_malloc(reply->length + 1);
Vladimir Sementsov-Ogievskiye6798f02019-01-28 19:58:30 +0300172 if (nbd_read(ioc, msg, reply->length, NULL, errp) < 0) {
173 error_prepend(errp, "Failed to read option error %" PRIu32
Eric Blakecb6b1a32017-11-13 09:24:24 -0600174 " (%s) message: ",
Eric Blake3736cc52017-07-07 15:30:43 -0500175 reply->type, nbd_rep_lookup(reply->type));
Eric Blake5de47732019-08-24 12:28:13 -0500176 goto err;
Alex Bligh6ff58162016-04-06 10:59:22 -0600177 }
Eric Blakec8a3a1b2016-10-14 13:33:10 -0500178 msg[reply->length] = '\0';
Eric Blakebee21ef2018-12-18 16:57:13 -0600179 trace_nbd_server_error_msg(reply->type,
180 nbd_reply_type_lookup(reply->type), msg);
Daniel P. Berrange9344e5f2016-02-10 18:41:09 +0000181 }
182
Eric Blake5de47732019-08-24 12:28:13 -0500183 if (reply->type == NBD_REP_ERR_UNSUP || !strict) {
184 trace_nbd_reply_err_ignored(reply->option,
185 nbd_opt_lookup(reply->option),
186 reply->type, nbd_rep_lookup(reply->type));
187 return 0;
188 }
Daniel P. Berrange9344e5f2016-02-10 18:41:09 +0000189
Eric Blake5de47732019-08-24 12:28:13 -0500190 switch (reply->type) {
Daniel P. Berrangef95910f2016-02-10 18:41:11 +0000191 case NBD_REP_ERR_POLICY:
Vladimir Sementsov-Ogievskiy28fb4942018-02-15 16:51:43 +0300192 error_setg(errp, "Denied by server for option %" PRIu32 " (%s)",
Eric Blake3736cc52017-07-07 15:30:43 -0500193 reply->option, nbd_opt_lookup(reply->option));
Daniel P. Berrangef95910f2016-02-10 18:41:11 +0000194 break;
195
Daniel P. Berrange9344e5f2016-02-10 18:41:09 +0000196 case NBD_REP_ERR_INVALID:
Vladimir Sementsov-Ogievskiy28fb4942018-02-15 16:51:43 +0300197 error_setg(errp, "Invalid parameters for option %" PRIu32 " (%s)",
Eric Blake3736cc52017-07-07 15:30:43 -0500198 reply->option, nbd_opt_lookup(reply->option));
Daniel P. Berrange9344e5f2016-02-10 18:41:09 +0000199 break;
200
Eric Blakeb6f5d3b2016-10-14 13:33:16 -0500201 case NBD_REP_ERR_PLATFORM:
Vladimir Sementsov-Ogievskiy28fb4942018-02-15 16:51:43 +0300202 error_setg(errp, "Server lacks support for option %" PRIu32 " (%s)",
Eric Blake3736cc52017-07-07 15:30:43 -0500203 reply->option, nbd_opt_lookup(reply->option));
Eric Blakeb6f5d3b2016-10-14 13:33:16 -0500204 break;
205
Daniel P. Berrangef95910f2016-02-10 18:41:11 +0000206 case NBD_REP_ERR_TLS_REQD:
Vladimir Sementsov-Ogievskiy28fb4942018-02-15 16:51:43 +0300207 error_setg(errp, "TLS negotiation required before option %" PRIu32
Eric Blake3736cc52017-07-07 15:30:43 -0500208 " (%s)", reply->option, nbd_opt_lookup(reply->option));
Eric Blake1b5c15c2019-09-07 12:20:55 -0500209 error_append_hint(errp, "Did you forget a valid tls-creds?\n");
Eric Blake3736cc52017-07-07 15:30:43 -0500210 break;
211
212 case NBD_REP_ERR_UNKNOWN:
Eric Blake9a76bd72017-07-17 09:23:10 -0500213 error_setg(errp, "Requested export not available");
Daniel P. Berrangef95910f2016-02-10 18:41:11 +0000214 break;
215
Eric Blakeb6f5d3b2016-10-14 13:33:16 -0500216 case NBD_REP_ERR_SHUTDOWN:
Vladimir Sementsov-Ogievskiy28fb4942018-02-15 16:51:43 +0300217 error_setg(errp, "Server shutting down before option %" PRIu32 " (%s)",
Eric Blake3736cc52017-07-07 15:30:43 -0500218 reply->option, nbd_opt_lookup(reply->option));
219 break;
220
221 case NBD_REP_ERR_BLOCK_SIZE_REQD:
Vladimir Sementsov-Ogievskiy28fb4942018-02-15 16:51:43 +0300222 error_setg(errp, "Server requires INFO_BLOCK_SIZE for option %" PRIu32
Eric Blake3736cc52017-07-07 15:30:43 -0500223 " (%s)", reply->option, nbd_opt_lookup(reply->option));
Eric Blakeb6f5d3b2016-10-14 13:33:16 -0500224 break;
225
Daniel P. Berrange9344e5f2016-02-10 18:41:09 +0000226 default:
Vladimir Sementsov-Ogievskiy28fb4942018-02-15 16:51:43 +0300227 error_setg(errp, "Unknown error code when asking for option %" PRIu32
Eric Blake3736cc52017-07-07 15:30:43 -0500228 " (%s)", reply->option, nbd_opt_lookup(reply->option));
Daniel P. Berrange9344e5f2016-02-10 18:41:09 +0000229 break;
230 }
231
Alex Bligh6ff58162016-04-06 10:59:22 -0600232 if (msg) {
Eric Blake9a76bd72017-07-17 09:23:10 -0500233 error_append_hint(errp, "server reported: %s\n", msg);
Alex Bligh6ff58162016-04-06 10:59:22 -0600234 }
235
Eric Blake5de47732019-08-24 12:28:13 -0500236 err:
237 nbd_send_opt_abort(ioc);
238 return -1;
Daniel P. Berrange9344e5f2016-02-10 18:41:09 +0000239}
240
Eric Blake091d0bf2019-01-17 13:36:45 -0600241/* nbd_receive_list:
242 * Process another portion of the NBD_OPT_LIST reply, populating any
243 * name received into *@name. If @description is non-NULL, and the
244 * server provided a description, that is also populated. The caller
245 * must eventually call g_free() on success.
246 * Returns 1 if name and description were set and iteration must continue,
247 * 0 if iteration is complete (including if OPT_LIST unsupported),
248 * -1 with @errp set if an unrecoverable error occurred.
249 */
250static int nbd_receive_list(QIOChannel *ioc, char **name, char **description,
Eric Blake75368aa2016-10-14 13:33:13 -0500251 Error **errp)
Daniel P. Berrange9344e5f2016-02-10 18:41:09 +0000252{
Vladimir Sementsov-Ogievskiy420a4e92017-11-22 13:19:57 +0300253 NBDOptionReply reply;
Daniel P. Berrange9344e5f2016-02-10 18:41:09 +0000254 uint32_t len;
255 uint32_t namelen;
Eric Blakedf18c042019-08-24 12:28:12 -0500256 g_autofree char *local_name = NULL;
257 g_autofree char *local_desc = NULL;
Alex Bligh6ff58162016-04-06 10:59:22 -0600258 int error;
Daniel P. Berrange9344e5f2016-02-10 18:41:09 +0000259
Eric Blakec8a3a1b2016-10-14 13:33:10 -0500260 if (nbd_receive_option_reply(ioc, NBD_OPT_LIST, &reply, errp) < 0) {
Daniel P. Berrange9344e5f2016-02-10 18:41:09 +0000261 return -1;
262 }
Eric Blake5de47732019-08-24 12:28:13 -0500263 error = nbd_handle_reply_err(ioc, &reply, true, errp);
Alex Bligh6ff58162016-04-06 10:59:22 -0600264 if (error <= 0) {
265 return error;
Daniel P. Berrange9344e5f2016-02-10 18:41:09 +0000266 }
Eric Blakec8a3a1b2016-10-14 13:33:10 -0500267 len = reply.length;
Daniel P. Berrange9344e5f2016-02-10 18:41:09 +0000268
Eric Blakec8a3a1b2016-10-14 13:33:10 -0500269 if (reply.type == NBD_REP_ACK) {
Daniel P. Berrange9344e5f2016-02-10 18:41:09 +0000270 if (len != 0) {
271 error_setg(errp, "length too long for option end");
Eric Blake2cdbf412016-10-14 13:33:11 -0500272 nbd_send_opt_abort(ioc);
Daniel P. Berrange9344e5f2016-02-10 18:41:09 +0000273 return -1;
274 }
Eric Blake75368aa2016-10-14 13:33:13 -0500275 return 0;
276 } else if (reply.type != NBD_REP_SERVER) {
Eric Blake6c5c0352018-12-15 07:53:07 -0600277 error_setg(errp, "Unexpected reply type %u (%s), expected %u (%s)",
278 reply.type, nbd_rep_lookup(reply.type),
279 NBD_REP_SERVER, nbd_rep_lookup(NBD_REP_SERVER));
Eric Blake2cdbf412016-10-14 13:33:11 -0500280 nbd_send_opt_abort(ioc);
Daniel P. Berrange9344e5f2016-02-10 18:41:09 +0000281 return -1;
282 }
Eric Blake75368aa2016-10-14 13:33:13 -0500283
284 if (len < sizeof(namelen) || len > NBD_MAX_BUFFER_SIZE) {
285 error_setg(errp, "incorrect option length %" PRIu32, len);
286 nbd_send_opt_abort(ioc);
287 return -1;
288 }
Vladimir Sementsov-Ogievskiye6798f02019-01-28 19:58:30 +0300289 if (nbd_read32(ioc, &namelen, "option name length", errp) < 0) {
Eric Blake75368aa2016-10-14 13:33:13 -0500290 nbd_send_opt_abort(ioc);
291 return -1;
292 }
Eric Blake75368aa2016-10-14 13:33:13 -0500293 len -= sizeof(namelen);
Eric Blake93676c82019-11-13 20:46:34 -0600294 if (len < namelen || namelen > NBD_MAX_STRING_SIZE) {
295 error_setg(errp, "incorrect name length in server's list response");
Eric Blake75368aa2016-10-14 13:33:13 -0500296 nbd_send_opt_abort(ioc);
297 return -1;
298 }
Eric Blake75368aa2016-10-14 13:33:13 -0500299
Eric Blake091d0bf2019-01-17 13:36:45 -0600300 local_name = g_malloc(namelen + 1);
Vladimir Sementsov-Ogievskiye6798f02019-01-28 19:58:30 +0300301 if (nbd_read(ioc, local_name, namelen, "export name", errp) < 0) {
Eric Blake75368aa2016-10-14 13:33:13 -0500302 nbd_send_opt_abort(ioc);
Eric Blakedf18c042019-08-24 12:28:12 -0500303 return -1;
Eric Blake75368aa2016-10-14 13:33:13 -0500304 }
Eric Blake091d0bf2019-01-17 13:36:45 -0600305 local_name[namelen] = '\0';
Eric Blake75368aa2016-10-14 13:33:13 -0500306 len -= namelen;
Eric Blake091d0bf2019-01-17 13:36:45 -0600307 if (len) {
Eric Blake93676c82019-11-13 20:46:34 -0600308 if (len > NBD_MAX_STRING_SIZE) {
309 error_setg(errp, "incorrect description length in server's "
310 "list response");
311 nbd_send_opt_abort(ioc);
312 return -1;
313 }
Eric Blake091d0bf2019-01-17 13:36:45 -0600314 local_desc = g_malloc(len + 1);
Vladimir Sementsov-Ogievskiye6798f02019-01-28 19:58:30 +0300315 if (nbd_read(ioc, local_desc, len, "export description", errp) < 0) {
Eric Blake091d0bf2019-01-17 13:36:45 -0600316 nbd_send_opt_abort(ioc);
Eric Blakedf18c042019-08-24 12:28:12 -0500317 return -1;
Eric Blake091d0bf2019-01-17 13:36:45 -0600318 }
319 local_desc[len] = '\0';
Eric Blake75368aa2016-10-14 13:33:13 -0500320 }
Eric Blake091d0bf2019-01-17 13:36:45 -0600321
322 trace_nbd_receive_list(local_name, local_desc ?: "");
Eric Blakedf18c042019-08-24 12:28:12 -0500323 *name = g_steal_pointer(&local_name);
Eric Blake091d0bf2019-01-17 13:36:45 -0600324 if (description) {
Eric Blakedf18c042019-08-24 12:28:12 -0500325 *description = g_steal_pointer(&local_desc);
Eric Blake75368aa2016-10-14 13:33:13 -0500326 }
Eric Blakedf18c042019-08-24 12:28:12 -0500327 return 1;
Daniel P. Berrange9344e5f2016-02-10 18:41:09 +0000328}
329
330
Eric Blake138796d2019-01-17 13:36:53 -0600331/*
332 * nbd_opt_info_or_go:
333 * Send option for NBD_OPT_INFO or NBD_OPT_GO and parse the reply.
334 * Returns -1 if the option proves the export @info->name cannot be
335 * used, 0 if the option is unsupported (fall back to NBD_OPT_LIST and
Eric Blake8ecaeae2017-07-07 15:30:47 -0500336 * NBD_OPT_EXPORT_NAME in that case), and > 0 if the export is good to
Eric Blake138796d2019-01-17 13:36:53 -0600337 * go (with the rest of @info populated).
338 */
339static int nbd_opt_info_or_go(QIOChannel *ioc, uint32_t opt,
340 NBDExportInfo *info, Error **errp)
Eric Blake8ecaeae2017-07-07 15:30:47 -0500341{
Vladimir Sementsov-Ogievskiy795d9462020-07-07 18:50:36 +0200342 ERRP_GUARD();
Vladimir Sementsov-Ogievskiy420a4e92017-11-22 13:19:57 +0300343 NBDOptionReply reply;
Eric Blake6dc16672019-01-17 13:36:46 -0600344 uint32_t len = strlen(info->name);
Eric Blake8ecaeae2017-07-07 15:30:47 -0500345 uint16_t type;
346 int error;
347 char *buf;
348
349 /* The protocol requires that the server send NBD_INFO_EXPORT with
350 * a non-zero flags (at least NBD_FLAG_HAS_FLAGS must be set); so
351 * flags still 0 is a witness of a broken server. */
352 info->flags = 0;
353
Eric Blake138796d2019-01-17 13:36:53 -0600354 assert(opt == NBD_OPT_GO || opt == NBD_OPT_INFO);
355 trace_nbd_opt_info_go_start(nbd_opt_lookup(opt), info->name);
Eric Blake081dd1f2017-07-07 15:30:49 -0500356 buf = g_malloc(4 + len + 2 + 2 * info->request_sizes + 1);
Eric Blake8ecaeae2017-07-07 15:30:47 -0500357 stl_be_p(buf, len);
Eric Blake6dc16672019-01-17 13:36:46 -0600358 memcpy(buf + 4, info->name, len);
Eric Blake081dd1f2017-07-07 15:30:49 -0500359 /* At most one request, everything else up to server */
360 stw_be_p(buf + 4 + len, info->request_sizes);
361 if (info->request_sizes) {
362 stw_be_p(buf + 4 + len + 2, NBD_INFO_BLOCK_SIZE);
363 }
Eric Blake138796d2019-01-17 13:36:53 -0600364 error = nbd_send_option_request(ioc, opt,
Philippe Mathieu-Daudé158b9aa2017-07-26 23:42:09 -0300365 4 + len + 2 + 2 * info->request_sizes,
366 buf, errp);
367 g_free(buf);
368 if (error < 0) {
Eric Blake8ecaeae2017-07-07 15:30:47 -0500369 return -1;
370 }
371
372 while (1) {
Eric Blake138796d2019-01-17 13:36:53 -0600373 if (nbd_receive_option_reply(ioc, opt, &reply, errp) < 0) {
Eric Blake8ecaeae2017-07-07 15:30:47 -0500374 return -1;
375 }
Eric Blake5de47732019-08-24 12:28:13 -0500376 error = nbd_handle_reply_err(ioc, &reply, true, errp);
Eric Blake8ecaeae2017-07-07 15:30:47 -0500377 if (error <= 0) {
378 return error;
379 }
380 len = reply.length;
381
382 if (reply.type == NBD_REP_ACK) {
Eric Blake138796d2019-01-17 13:36:53 -0600383 /*
384 * Server is done sending info, and moved into transmission
385 * phase for NBD_OPT_GO, but make sure it sent flags
386 */
Eric Blake8ecaeae2017-07-07 15:30:47 -0500387 if (len) {
388 error_setg(errp, "server sent invalid NBD_REP_ACK");
Eric Blake8ecaeae2017-07-07 15:30:47 -0500389 return -1;
390 }
391 if (!info->flags) {
392 error_setg(errp, "broken server omitted NBD_INFO_EXPORT");
Eric Blake8ecaeae2017-07-07 15:30:47 -0500393 return -1;
394 }
Eric Blake138796d2019-01-17 13:36:53 -0600395 trace_nbd_opt_info_go_success(nbd_opt_lookup(opt));
Eric Blake8ecaeae2017-07-07 15:30:47 -0500396 return 1;
397 }
398 if (reply.type != NBD_REP_INFO) {
Eric Blake6c5c0352018-12-15 07:53:07 -0600399 error_setg(errp, "unexpected reply type %u (%s), expected %u (%s)",
400 reply.type, nbd_rep_lookup(reply.type),
401 NBD_REP_INFO, nbd_rep_lookup(NBD_REP_INFO));
Eric Blake8ecaeae2017-07-07 15:30:47 -0500402 nbd_send_opt_abort(ioc);
403 return -1;
404 }
405 if (len < sizeof(type)) {
406 error_setg(errp, "NBD_REP_INFO length %" PRIu32 " is too short",
407 len);
408 nbd_send_opt_abort(ioc);
409 return -1;
410 }
Vladimir Sementsov-Ogievskiye6798f02019-01-28 19:58:30 +0300411 if (nbd_read16(ioc, &type, "info type", errp) < 0) {
Eric Blake8ecaeae2017-07-07 15:30:47 -0500412 nbd_send_opt_abort(ioc);
413 return -1;
414 }
415 len -= sizeof(type);
Eric Blake8ecaeae2017-07-07 15:30:47 -0500416 switch (type) {
417 case NBD_INFO_EXPORT:
418 if (len != sizeof(info->size) + sizeof(info->flags)) {
419 error_setg(errp, "remaining export info len %" PRIu32
420 " is unexpected size", len);
421 nbd_send_opt_abort(ioc);
422 return -1;
423 }
Vladimir Sementsov-Ogievskiye6798f02019-01-28 19:58:30 +0300424 if (nbd_read64(ioc, &info->size, "info size", errp) < 0) {
Eric Blake8ecaeae2017-07-07 15:30:47 -0500425 nbd_send_opt_abort(ioc);
426 return -1;
427 }
Vladimir Sementsov-Ogievskiye6798f02019-01-28 19:58:30 +0300428 if (nbd_read16(ioc, &info->flags, "info flags", errp) < 0) {
Eric Blake8ecaeae2017-07-07 15:30:47 -0500429 nbd_send_opt_abort(ioc);
430 return -1;
431 }
Eric Blake3add3ab2019-03-30 10:57:04 -0500432 if (info->min_block &&
433 !QEMU_IS_ALIGNED(info->size, info->min_block)) {
Eric Blakee53f88d2019-04-04 09:52:26 -0500434 error_setg(errp, "export size %" PRIu64 " is not multiple of "
Eric Blake3add3ab2019-03-30 10:57:04 -0500435 "minimum block size %" PRIu32, info->size,
436 info->min_block);
437 nbd_send_opt_abort(ioc);
438 return -1;
439 }
Eric Blake8ecaeae2017-07-07 15:30:47 -0500440 trace_nbd_receive_negotiate_size_flags(info->size, info->flags);
441 break;
442
Eric Blake081dd1f2017-07-07 15:30:49 -0500443 case NBD_INFO_BLOCK_SIZE:
444 if (len != sizeof(info->min_block) * 3) {
445 error_setg(errp, "remaining export info len %" PRIu32
446 " is unexpected size", len);
447 nbd_send_opt_abort(ioc);
448 return -1;
449 }
Vladimir Sementsov-Ogievskiye6798f02019-01-28 19:58:30 +0300450 if (nbd_read32(ioc, &info->min_block, "info minimum block size",
451 errp) < 0) {
Eric Blake081dd1f2017-07-07 15:30:49 -0500452 nbd_send_opt_abort(ioc);
453 return -1;
454 }
Eric Blake081dd1f2017-07-07 15:30:49 -0500455 if (!is_power_of_2(info->min_block)) {
Eric Blakee475d102018-05-01 10:46:53 -0500456 error_setg(errp, "server minimum block size %" PRIu32
457 " is not a power of two", info->min_block);
Eric Blake081dd1f2017-07-07 15:30:49 -0500458 nbd_send_opt_abort(ioc);
459 return -1;
460 }
Vladimir Sementsov-Ogievskiye6798f02019-01-28 19:58:30 +0300461 if (nbd_read32(ioc, &info->opt_block, "info preferred block size",
462 errp) < 0)
463 {
Eric Blake081dd1f2017-07-07 15:30:49 -0500464 nbd_send_opt_abort(ioc);
465 return -1;
466 }
Eric Blake081dd1f2017-07-07 15:30:49 -0500467 if (!is_power_of_2(info->opt_block) ||
468 info->opt_block < info->min_block) {
Eric Blakee475d102018-05-01 10:46:53 -0500469 error_setg(errp, "server preferred block size %" PRIu32
470 " is not valid", info->opt_block);
Eric Blake081dd1f2017-07-07 15:30:49 -0500471 nbd_send_opt_abort(ioc);
472 return -1;
473 }
Vladimir Sementsov-Ogievskiye6798f02019-01-28 19:58:30 +0300474 if (nbd_read32(ioc, &info->max_block, "info maximum block size",
475 errp) < 0)
476 {
Eric Blake081dd1f2017-07-07 15:30:49 -0500477 nbd_send_opt_abort(ioc);
478 return -1;
479 }
Eric Blakee475d102018-05-01 10:46:53 -0500480 if (info->max_block < info->min_block) {
481 error_setg(errp, "server maximum block size %" PRIu32
482 " is not valid", info->max_block);
483 nbd_send_opt_abort(ioc);
484 return -1;
485 }
Eric Blake138796d2019-01-17 13:36:53 -0600486 trace_nbd_opt_info_block_size(info->min_block, info->opt_block,
487 info->max_block);
Eric Blake081dd1f2017-07-07 15:30:49 -0500488 break;
489
Eric Blake8ecaeae2017-07-07 15:30:47 -0500490 default:
Eric Blake93676c82019-11-13 20:46:34 -0600491 /*
492 * Not worth the bother to check if NBD_INFO_NAME or
493 * NBD_INFO_DESCRIPTION exceed NBD_MAX_STRING_SIZE.
494 */
Eric Blake138796d2019-01-17 13:36:53 -0600495 trace_nbd_opt_info_unknown(type, nbd_info_lookup(type));
Eric Blake8ecaeae2017-07-07 15:30:47 -0500496 if (nbd_drop(ioc, len, errp) < 0) {
Eric Blakecb6b1a32017-11-13 09:24:24 -0600497 error_prepend(errp, "Failed to read info payload: ");
Eric Blake8ecaeae2017-07-07 15:30:47 -0500498 nbd_send_opt_abort(ioc);
499 return -1;
500 }
501 break;
502 }
503 }
504}
505
Eric Blake75368aa2016-10-14 13:33:13 -0500506/* Return -1 on failure, 0 if wantname is an available export. */
Daniel P. Berrange9344e5f2016-02-10 18:41:09 +0000507static int nbd_receive_query_exports(QIOChannel *ioc,
508 const char *wantname,
509 Error **errp)
510{
Eric Blake091d0bf2019-01-17 13:36:45 -0600511 bool list_empty = true;
512 bool found_export = false;
Daniel P. Berrange9344e5f2016-02-10 18:41:09 +0000513
Vladimir Sementsov-Ogievskiy95884632017-07-07 18:29:18 +0300514 trace_nbd_receive_query_exports_start(wantname);
Eric Blakec8a3a1b2016-10-14 13:33:10 -0500515 if (nbd_send_option_request(ioc, NBD_OPT_LIST, 0, NULL, errp) < 0) {
Daniel P. Berrange9344e5f2016-02-10 18:41:09 +0000516 return -1;
517 }
518
Daniel P. Berrange9344e5f2016-02-10 18:41:09 +0000519 while (1) {
Eric Blake091d0bf2019-01-17 13:36:45 -0600520 char *name;
521 int ret = nbd_receive_list(ioc, &name, NULL, errp);
Daniel P. Berrange9344e5f2016-02-10 18:41:09 +0000522
523 if (ret < 0) {
Eric Blake75368aa2016-10-14 13:33:13 -0500524 /* Server gave unexpected reply */
Daniel P. Berrange9344e5f2016-02-10 18:41:09 +0000525 return -1;
Eric Blake75368aa2016-10-14 13:33:13 -0500526 } else if (ret == 0) {
527 /* Done iterating. */
Eric Blake091d0bf2019-01-17 13:36:45 -0600528 if (list_empty) {
529 /*
530 * We don't have enough context to tell a server that
531 * sent an empty list apart from a server that does
532 * not support the list command; but as this function
533 * is just used to trigger a nicer error message
534 * before trying NBD_OPT_EXPORT_NAME, assume the
535 * export is available.
536 */
537 return 0;
538 } else if (!found_export) {
Eric Blake75368aa2016-10-14 13:33:13 -0500539 error_setg(errp, "No export with name '%s' available",
540 wantname);
541 nbd_send_opt_abort(ioc);
542 return -1;
543 }
Vladimir Sementsov-Ogievskiy95884632017-07-07 18:29:18 +0300544 trace_nbd_receive_query_exports_success(wantname);
Eric Blake75368aa2016-10-14 13:33:13 -0500545 return 0;
Daniel P. Berrange9344e5f2016-02-10 18:41:09 +0000546 }
Eric Blake091d0bf2019-01-17 13:36:45 -0600547 list_empty = false;
548 if (!strcmp(name, wantname)) {
549 found_export = true;
550 }
551 g_free(name);
Daniel P. Berrange9344e5f2016-02-10 18:41:09 +0000552 }
Daniel P. Berrange9344e5f2016-02-10 18:41:09 +0000553}
554
Eric Blake5de47732019-08-24 12:28:13 -0500555/*
556 * nbd_request_simple_option: Send an option request, and parse the reply.
557 * @strict controls whether ERR_UNSUP or all errors produce 0 status.
Vladimir Sementsov-Ogievskiyd7952992017-10-27 12:40:34 +0200558 * return 1 for successful negotiation,
559 * 0 if operation is unsupported,
560 * -1 with errp set for any other error
561 */
Eric Blake5de47732019-08-24 12:28:13 -0500562static int nbd_request_simple_option(QIOChannel *ioc, int opt, bool strict,
563 Error **errp)
Vladimir Sementsov-Ogievskiyd7952992017-10-27 12:40:34 +0200564{
Vladimir Sementsov-Ogievskiy420a4e92017-11-22 13:19:57 +0300565 NBDOptionReply reply;
Vladimir Sementsov-Ogievskiyd7952992017-10-27 12:40:34 +0200566 int error;
567
568 if (nbd_send_option_request(ioc, opt, 0, NULL, errp) < 0) {
569 return -1;
570 }
571
572 if (nbd_receive_option_reply(ioc, opt, &reply, errp) < 0) {
573 return -1;
574 }
Eric Blake5de47732019-08-24 12:28:13 -0500575 error = nbd_handle_reply_err(ioc, &reply, strict, errp);
Vladimir Sementsov-Ogievskiyd7952992017-10-27 12:40:34 +0200576 if (error <= 0) {
577 return error;
578 }
579
580 if (reply.type != NBD_REP_ACK) {
581 error_setg(errp, "Server answered option %d (%s) with unexpected "
Vladimir Sementsov-Ogievskiy28fb4942018-02-15 16:51:43 +0300582 "reply %" PRIu32 " (%s)", opt, nbd_opt_lookup(opt),
Vladimir Sementsov-Ogievskiyd7952992017-10-27 12:40:34 +0200583 reply.type, nbd_rep_lookup(reply.type));
584 nbd_send_opt_abort(ioc);
585 return -1;
586 }
587
588 if (reply.length != 0) {
589 error_setg(errp, "Option %d ('%s') response length is %" PRIu32
590 " (it should be zero)", opt, nbd_opt_lookup(opt),
591 reply.length);
592 nbd_send_opt_abort(ioc);
593 return -1;
594 }
595
596 return 1;
597}
598
Daniel P. Berrangef95910f2016-02-10 18:41:11 +0000599static QIOChannel *nbd_receive_starttls(QIOChannel *ioc,
600 QCryptoTLSCreds *tlscreds,
601 const char *hostname, Error **errp)
602{
Vladimir Sementsov-Ogievskiyd7952992017-10-27 12:40:34 +0200603 int ret;
Daniel P. Berrangef95910f2016-02-10 18:41:11 +0000604 QIOChannelTLS *tioc;
605 struct NBDTLSHandshakeData data = { 0 };
606
Eric Blake5de47732019-08-24 12:28:13 -0500607 ret = nbd_request_simple_option(ioc, NBD_OPT_STARTTLS, true, errp);
Vladimir Sementsov-Ogievskiyd7952992017-10-27 12:40:34 +0200608 if (ret <= 0) {
609 if (ret == 0) {
610 error_setg(errp, "Server don't support STARTTLS option");
611 nbd_send_opt_abort(ioc);
612 }
Daniel P. Berrangef95910f2016-02-10 18:41:11 +0000613 return NULL;
614 }
615
Vladimir Sementsov-Ogievskiy95884632017-07-07 18:29:18 +0300616 trace_nbd_receive_starttls_new_client();
Daniel P. Berrangef95910f2016-02-10 18:41:11 +0000617 tioc = qio_channel_tls_new_client(ioc, tlscreds, hostname, errp);
618 if (!tioc) {
619 return NULL;
620 }
Daniel P. Berrange0d73f722016-09-30 11:57:14 +0100621 qio_channel_set_name(QIO_CHANNEL(tioc), "nbd-client-tls");
Daniel P. Berrangef95910f2016-02-10 18:41:11 +0000622 data.loop = g_main_loop_new(g_main_context_default(), FALSE);
Vladimir Sementsov-Ogievskiy95884632017-07-07 18:29:18 +0300623 trace_nbd_receive_starttls_tls_handshake();
Daniel P. Berrangef95910f2016-02-10 18:41:11 +0000624 qio_channel_tls_handshake(tioc,
625 nbd_tls_handshake,
626 &data,
Peter Xu1939ccd2018-03-05 14:43:24 +0800627 NULL,
Daniel P. Berrangef95910f2016-02-10 18:41:11 +0000628 NULL);
629
630 if (!data.complete) {
631 g_main_loop_run(data.loop);
632 }
633 g_main_loop_unref(data.loop);
634 if (data.error) {
635 error_propagate(errp, data.error);
636 object_unref(OBJECT(tioc));
637 return NULL;
638 }
639
640 return QIO_CHANNEL(tioc);
641}
642
Eric Blake757b3ab2019-01-17 13:36:48 -0600643/*
644 * nbd_send_meta_query:
645 * Send 0 or 1 set/list meta context queries.
646 * Return 0 on success, -1 with errp set for any error
647 */
648static int nbd_send_meta_query(QIOChannel *ioc, uint32_t opt,
649 const char *export, const char *query,
650 Error **errp)
651{
652 int ret;
653 uint32_t export_len = strlen(export);
654 uint32_t queries = !!query;
655 uint32_t query_len = 0;
656 uint32_t data_len;
657 char *data;
658 char *p;
659
660 data_len = sizeof(export_len) + export_len + sizeof(queries);
Eric Blake93676c82019-11-13 20:46:34 -0600661 assert(export_len <= NBD_MAX_STRING_SIZE);
Eric Blake757b3ab2019-01-17 13:36:48 -0600662 if (query) {
663 query_len = strlen(query);
664 data_len += sizeof(query_len) + query_len;
Eric Blake93676c82019-11-13 20:46:34 -0600665 assert(query_len <= NBD_MAX_STRING_SIZE);
Eric Blake757b3ab2019-01-17 13:36:48 -0600666 } else {
667 assert(opt == NBD_OPT_LIST_META_CONTEXT);
668 }
669 p = data = g_malloc(data_len);
670
671 trace_nbd_opt_meta_request(nbd_opt_lookup(opt), query ?: "(all)", export);
672 stl_be_p(p, export_len);
673 memcpy(p += sizeof(export_len), export, export_len);
674 stl_be_p(p += export_len, queries);
675 if (query) {
676 stl_be_p(p += sizeof(queries), query_len);
677 memcpy(p += sizeof(query_len), query, query_len);
678 }
679
680 ret = nbd_send_option_request(ioc, opt, data_len, data, errp);
681 g_free(data);
682 return ret;
683}
684
Eric Blake0182c1a2019-01-17 13:36:49 -0600685/*
686 * nbd_receive_one_meta_context:
687 * Called in a loop to receive and trace one set/list meta context reply.
688 * Pass non-NULL @name or @id to collect results back to the caller, which
689 * must eventually call g_free().
690 * return 1 if name is set and iteration must continue,
691 * 0 if iteration is complete (including if option is unsupported),
692 * -1 with errp set for any error
693 */
694static int nbd_receive_one_meta_context(QIOChannel *ioc,
695 uint32_t opt,
696 char **name,
697 uint32_t *id,
698 Error **errp)
699{
700 int ret;
701 NBDOptionReply reply;
702 char *local_name = NULL;
703 uint32_t local_id;
704
705 if (nbd_receive_option_reply(ioc, opt, &reply, errp) < 0) {
706 return -1;
707 }
708
Eric Blake5de47732019-08-24 12:28:13 -0500709 ret = nbd_handle_reply_err(ioc, &reply, false, errp);
Eric Blake0182c1a2019-01-17 13:36:49 -0600710 if (ret <= 0) {
711 return ret;
712 }
713
714 if (reply.type == NBD_REP_ACK) {
715 if (reply.length != 0) {
716 error_setg(errp, "Unexpected length to ACK response");
717 nbd_send_opt_abort(ioc);
718 return -1;
719 }
720 return 0;
721 } else if (reply.type != NBD_REP_META_CONTEXT) {
722 error_setg(errp, "Unexpected reply type %u (%s), expected %u (%s)",
723 reply.type, nbd_rep_lookup(reply.type),
724 NBD_REP_META_CONTEXT, nbd_rep_lookup(NBD_REP_META_CONTEXT));
725 nbd_send_opt_abort(ioc);
726 return -1;
727 }
728
729 if (reply.length <= sizeof(local_id) ||
730 reply.length > NBD_MAX_BUFFER_SIZE) {
731 error_setg(errp, "Failed to negotiate meta context, server "
732 "answered with unexpected length %" PRIu32,
733 reply.length);
734 nbd_send_opt_abort(ioc);
735 return -1;
736 }
737
Vladimir Sementsov-Ogievskiye6798f02019-01-28 19:58:30 +0300738 if (nbd_read32(ioc, &local_id, "context id", errp) < 0) {
Eric Blake0182c1a2019-01-17 13:36:49 -0600739 return -1;
740 }
Eric Blake0182c1a2019-01-17 13:36:49 -0600741
742 reply.length -= sizeof(local_id);
743 local_name = g_malloc(reply.length + 1);
Vladimir Sementsov-Ogievskiye6798f02019-01-28 19:58:30 +0300744 if (nbd_read(ioc, local_name, reply.length, "context name", errp) < 0) {
Eric Blake0182c1a2019-01-17 13:36:49 -0600745 g_free(local_name);
746 return -1;
747 }
748 local_name[reply.length] = '\0';
749 trace_nbd_opt_meta_reply(nbd_opt_lookup(opt), local_name, local_id);
750
751 if (name) {
752 *name = local_name;
753 } else {
754 g_free(local_name);
755 }
756 if (id) {
757 *id = local_id;
758 }
759 return 1;
760}
761
762/*
763 * nbd_negotiate_simple_meta_context:
Eric Blake2df94eb2019-01-17 13:36:47 -0600764 * Request the server to set the meta context for export @info->name
765 * using @info->x_dirty_bitmap with a fallback to "base:allocation",
766 * setting @info->context_id to the resulting id. Fail if the server
767 * responds with more than one context or with a context different
768 * than the query.
769 * return 1 for successful negotiation,
Vladimir Sementsov-Ogievskiy78a33ab2018-03-12 18:21:23 +0300770 * 0 if operation is unsupported,
771 * -1 with errp set for any other error
772 */
773static int nbd_negotiate_simple_meta_context(QIOChannel *ioc,
Eric Blake2df94eb2019-01-17 13:36:47 -0600774 NBDExportInfo *info,
Vladimir Sementsov-Ogievskiy78a33ab2018-03-12 18:21:23 +0300775 Error **errp)
776{
Eric Blake2df94eb2019-01-17 13:36:47 -0600777 /*
778 * TODO: Removing the x_dirty_bitmap hack will mean refactoring
779 * this function to request and store ids for multiple contexts
780 * (both base:allocation and a dirty bitmap), at which point this
781 * function should lose the term _simple.
782 */
Vladimir Sementsov-Ogievskiy78a33ab2018-03-12 18:21:23 +0300783 int ret;
Eric Blake2df94eb2019-01-17 13:36:47 -0600784 const char *context = info->x_dirty_bitmap ?: "base:allocation";
Vladimir Sementsov-Ogievskiy89aa0d82018-04-27 17:20:01 +0300785 bool received = false;
Eric Blake0182c1a2019-01-17 13:36:49 -0600786 char *name = NULL;
Vladimir Sementsov-Ogievskiy78a33ab2018-03-12 18:21:23 +0300787
Eric Blake757b3ab2019-01-17 13:36:48 -0600788 if (nbd_send_meta_query(ioc, NBD_OPT_SET_META_CONTEXT,
789 info->name, context, errp) < 0) {
790 return -1;
Vladimir Sementsov-Ogievskiy78a33ab2018-03-12 18:21:23 +0300791 }
792
Eric Blake0182c1a2019-01-17 13:36:49 -0600793 ret = nbd_receive_one_meta_context(ioc, NBD_OPT_SET_META_CONTEXT,
794 &name, &info->context_id, errp);
795 if (ret < 0) {
Vladimir Sementsov-Ogievskiy78a33ab2018-03-12 18:21:23 +0300796 return -1;
797 }
Eric Blake0182c1a2019-01-17 13:36:49 -0600798 if (ret == 1) {
Vladimir Sementsov-Ogievskiy78a33ab2018-03-12 18:21:23 +0300799 if (strcmp(context, name)) {
800 error_setg(errp, "Failed to negotiate meta context '%s', server "
801 "answered with different context '%s'", context,
802 name);
803 g_free(name);
Eric Blake260e34d2018-03-29 18:18:37 -0500804 nbd_send_opt_abort(ioc);
Vladimir Sementsov-Ogievskiy78a33ab2018-03-12 18:21:23 +0300805 return -1;
806 }
807 g_free(name);
Vladimir Sementsov-Ogievskiy78a33ab2018-03-12 18:21:23 +0300808 received = true;
809
Eric Blake0182c1a2019-01-17 13:36:49 -0600810 ret = nbd_receive_one_meta_context(ioc, NBD_OPT_SET_META_CONTEXT,
811 NULL, NULL, errp);
812 if (ret < 0) {
Vladimir Sementsov-Ogievskiy78a33ab2018-03-12 18:21:23 +0300813 return -1;
814 }
Vladimir Sementsov-Ogievskiy78a33ab2018-03-12 18:21:23 +0300815 }
Eric Blake0182c1a2019-01-17 13:36:49 -0600816 if (ret != 0) {
817 error_setg(errp, "Server answered with more than one context");
Eric Blake260e34d2018-03-29 18:18:37 -0500818 nbd_send_opt_abort(ioc);
819 return -1;
820 }
Eric Blake2df94eb2019-01-17 13:36:47 -0600821 return received;
Vladimir Sementsov-Ogievskiy78a33ab2018-03-12 18:21:23 +0300822}
Daniel P. Berrangef95910f2016-02-10 18:41:11 +0000823
Eric Blake10b89982019-01-17 13:36:51 -0600824/*
Eric Blake0b576b62019-01-17 13:36:55 -0600825 * nbd_list_meta_contexts:
826 * Request the server to list all meta contexts for export @info->name.
827 * return 0 if list is complete (even if empty),
828 * -1 with errp set for any error
829 */
830static int nbd_list_meta_contexts(QIOChannel *ioc,
831 NBDExportInfo *info,
832 Error **errp)
833{
834 int ret;
Eric Blake7c6f5dd2019-01-17 13:36:57 -0600835 int seen_any = false;
836 int seen_qemu = false;
Eric Blake0b576b62019-01-17 13:36:55 -0600837
838 if (nbd_send_meta_query(ioc, NBD_OPT_LIST_META_CONTEXT,
839 info->name, NULL, errp) < 0) {
840 return -1;
841 }
842
843 while (1) {
844 char *context;
845
846 ret = nbd_receive_one_meta_context(ioc, NBD_OPT_LIST_META_CONTEXT,
847 &context, NULL, errp);
Eric Blake7c6f5dd2019-01-17 13:36:57 -0600848 if (ret == 0 && seen_any && !seen_qemu) {
849 /*
850 * Work around qemu 3.0 bug: the server forgot to send
851 * "qemu:" replies to 0 queries. If we saw at least one
852 * reply (probably base:allocation), but none of them were
853 * qemu:, then run a more specific query to make sure.
854 */
855 seen_qemu = true;
856 if (nbd_send_meta_query(ioc, NBD_OPT_LIST_META_CONTEXT,
857 info->name, "qemu:", errp) < 0) {
858 return -1;
859 }
860 continue;
861 }
Eric Blake0b576b62019-01-17 13:36:55 -0600862 if (ret <= 0) {
863 return ret;
864 }
Eric Blake7c6f5dd2019-01-17 13:36:57 -0600865 seen_any = true;
866 seen_qemu |= strstart(context, "qemu:", NULL);
Eric Blake0b576b62019-01-17 13:36:55 -0600867 info->contexts = g_renew(char *, info->contexts, ++info->n_contexts);
868 info->contexts[info->n_contexts - 1] = context;
869 }
870}
871
872/*
Eric Blake10b89982019-01-17 13:36:51 -0600873 * nbd_start_negotiate:
874 * Start the handshake to the server. After a positive return, the server
875 * is ready to accept additional NBD_OPT requests.
876 * Returns: negative errno: failure talking to server
Eric Blakeb3c9d332019-01-17 13:36:52 -0600877 * 0: server is oldstyle, must call nbd_negotiate_finish_oldstyle
Eric Blake10b89982019-01-17 13:36:51 -0600878 * 1: server is newstyle, but can only accept EXPORT_NAME
879 * 2: server is newstyle, but lacks structured replies
880 * 3: server is newstyle and set up for structured replies
881 */
Vladimir Sementsov-Ogievskiya8e2bb62019-06-18 14:43:21 +0300882static int nbd_start_negotiate(AioContext *aio_context, QIOChannel *ioc,
883 QCryptoTLSCreds *tlscreds,
Eric Blake10b89982019-01-17 13:36:51 -0600884 const char *hostname, QIOChannel **outioc,
885 bool structured_reply, bool *zeroes,
886 Error **errp)
Fam Zheng798bfe02016-01-14 16:41:02 +0800887{
Vladimir Sementsov-Ogievskiy795d9462020-07-07 18:50:36 +0200888 ERRP_GUARD();
Eric Blake004a89f2017-07-07 15:30:41 -0500889 uint64_t magic;
Fam Zheng798bfe02016-01-14 16:41:02 +0800890
Eric Blake10b89982019-01-17 13:36:51 -0600891 trace_nbd_start_negotiate(tlscreds, hostname ? hostname : "<null>");
Fam Zheng798bfe02016-01-14 16:41:02 +0800892
Eric Blaked21a2d32019-01-17 13:36:54 -0600893 if (zeroes) {
894 *zeroes = true;
895 }
Daniel P. Berrangef95910f2016-02-10 18:41:11 +0000896 if (outioc) {
897 *outioc = NULL;
898 }
899 if (tlscreds && !outioc) {
900 error_setg(errp, "Output I/O channel required for TLS");
Eric Blake2b8d0952019-01-17 13:36:50 -0600901 return -EINVAL;
Daniel P. Berrangef95910f2016-02-10 18:41:11 +0000902 }
903
Vladimir Sementsov-Ogievskiye6798f02019-01-28 19:58:30 +0300904 if (nbd_read64(ioc, &magic, "initial magic", errp) < 0) {
Eric Blake2b8d0952019-01-17 13:36:50 -0600905 return -EINVAL;
Fam Zheng798bfe02016-01-14 16:41:02 +0800906 }
Vladimir Sementsov-Ogievskiy95884632017-07-07 18:29:18 +0300907 trace_nbd_receive_negotiate_magic(magic);
Fam Zheng798bfe02016-01-14 16:41:02 +0800908
Eric Blakeef2e35f2018-12-15 07:53:10 -0600909 if (magic != NBD_INIT_MAGIC) {
910 error_setg(errp, "Bad initial magic received: 0x%" PRIx64, magic);
Eric Blake2b8d0952019-01-17 13:36:50 -0600911 return -EINVAL;
Fam Zheng798bfe02016-01-14 16:41:02 +0800912 }
913
Vladimir Sementsov-Ogievskiye6798f02019-01-28 19:58:30 +0300914 if (nbd_read64(ioc, &magic, "server magic", errp) < 0) {
Eric Blake2b8d0952019-01-17 13:36:50 -0600915 return -EINVAL;
Fam Zheng798bfe02016-01-14 16:41:02 +0800916 }
Vladimir Sementsov-Ogievskiy95884632017-07-07 18:29:18 +0300917 trace_nbd_receive_negotiate_magic(magic);
Fam Zheng798bfe02016-01-14 16:41:02 +0800918
Daniel P. Berrangef72d7052016-02-10 18:41:05 +0000919 if (magic == NBD_OPTS_MAGIC) {
Daniel P. Berrangee2a9d9a2016-02-10 18:41:07 +0000920 uint32_t clientflags = 0;
Daniel P. Berrangee2a9d9a2016-02-10 18:41:07 +0000921 uint16_t globalflags;
Daniel P. Berrange9344e5f2016-02-10 18:41:09 +0000922 bool fixedNewStyle = false;
Fam Zheng798bfe02016-01-14 16:41:02 +0800923
Vladimir Sementsov-Ogievskiye6798f02019-01-28 19:58:30 +0300924 if (nbd_read16(ioc, &globalflags, "server flags", errp) < 0) {
Eric Blake2b8d0952019-01-17 13:36:50 -0600925 return -EINVAL;
Fam Zheng798bfe02016-01-14 16:41:02 +0800926 }
Vladimir Sementsov-Ogievskiy95884632017-07-07 18:29:18 +0300927 trace_nbd_receive_negotiate_server_flags(globalflags);
Daniel P. Berrangee2a9d9a2016-02-10 18:41:07 +0000928 if (globalflags & NBD_FLAG_FIXED_NEWSTYLE) {
Daniel P. Berrange9344e5f2016-02-10 18:41:09 +0000929 fixedNewStyle = true;
Daniel P. Berrangee2a9d9a2016-02-10 18:41:07 +0000930 clientflags |= NBD_FLAG_C_FIXED_NEWSTYLE;
931 }
Eric Blakec203c592016-10-14 13:33:14 -0500932 if (globalflags & NBD_FLAG_NO_ZEROES) {
Eric Blaked21a2d32019-01-17 13:36:54 -0600933 if (zeroes) {
934 *zeroes = false;
935 }
Eric Blakec203c592016-10-14 13:33:14 -0500936 clientflags |= NBD_FLAG_C_NO_ZEROES;
937 }
Daniel P. Berrangee2a9d9a2016-02-10 18:41:07 +0000938 /* client requested flags */
Daniel P. Berrange9344e5f2016-02-10 18:41:09 +0000939 clientflags = cpu_to_be32(clientflags);
Vladimir Sementsov-Ogievskiyd1fdf252017-06-02 18:01:39 +0300940 if (nbd_write(ioc, &clientflags, sizeof(clientflags), errp) < 0) {
Eric Blakecb6b1a32017-11-13 09:24:24 -0600941 error_prepend(errp, "Failed to send clientflags field: ");
Eric Blake2b8d0952019-01-17 13:36:50 -0600942 return -EINVAL;
Fam Zheng798bfe02016-01-14 16:41:02 +0800943 }
Daniel P. Berrangef95910f2016-02-10 18:41:11 +0000944 if (tlscreds) {
945 if (fixedNewStyle) {
946 *outioc = nbd_receive_starttls(ioc, tlscreds, hostname, errp);
947 if (!*outioc) {
Eric Blake2b8d0952019-01-17 13:36:50 -0600948 return -EINVAL;
Daniel P. Berrangef95910f2016-02-10 18:41:11 +0000949 }
950 ioc = *outioc;
Vladimir Sementsov-Ogievskiya8e2bb62019-06-18 14:43:21 +0300951 if (aio_context) {
952 qio_channel_set_blocking(ioc, false, NULL);
953 qio_channel_attach_aio_context(ioc, aio_context);
954 }
Daniel P. Berrangef95910f2016-02-10 18:41:11 +0000955 } else {
956 error_setg(errp, "Server does not support STARTTLS");
Eric Blake2b8d0952019-01-17 13:36:50 -0600957 return -EINVAL;
Daniel P. Berrangef95910f2016-02-10 18:41:11 +0000958 }
959 }
Daniel P. Berrange9344e5f2016-02-10 18:41:09 +0000960 if (fixedNewStyle) {
Eric Blake10b89982019-01-17 13:36:51 -0600961 int result = 0;
Eric Blake8ecaeae2017-07-07 15:30:47 -0500962
Vladimir Sementsov-Ogievskiyf140e302017-10-27 12:40:37 +0200963 if (structured_reply) {
964 result = nbd_request_simple_option(ioc,
965 NBD_OPT_STRUCTURED_REPLY,
Eric Blake5de47732019-08-24 12:28:13 -0500966 false, errp);
Vladimir Sementsov-Ogievskiyf140e302017-10-27 12:40:37 +0200967 if (result < 0) {
Eric Blake2b8d0952019-01-17 13:36:50 -0600968 return -EINVAL;
Vladimir Sementsov-Ogievskiyf140e302017-10-27 12:40:37 +0200969 }
Vladimir Sementsov-Ogievskiyf140e302017-10-27 12:40:37 +0200970 }
Eric Blake10b89982019-01-17 13:36:51 -0600971 return 2 + result;
972 } else {
973 return 1;
974 }
975 } else if (magic == NBD_CLIENT_MAGIC) {
976 if (tlscreds) {
977 error_setg(errp, "Server does not support STARTTLS");
978 return -EINVAL;
979 }
980 return 0;
981 } else {
982 error_setg(errp, "Bad server magic received: 0x%" PRIx64, magic);
983 return -EINVAL;
984 }
985}
Vladimir Sementsov-Ogievskiyf140e302017-10-27 12:40:37 +0200986
Eric Blake10b89982019-01-17 13:36:51 -0600987/*
Eric Blakeb3c9d332019-01-17 13:36:52 -0600988 * nbd_negotiate_finish_oldstyle:
989 * Populate @info with the size and export flags from an oldstyle server,
990 * but does not consume 124 bytes of reserved zero padding.
991 * Returns 0 on success, -1 with @errp set on failure
992 */
993static int nbd_negotiate_finish_oldstyle(QIOChannel *ioc, NBDExportInfo *info,
994 Error **errp)
995{
996 uint32_t oldflags;
997
Vladimir Sementsov-Ogievskiye6798f02019-01-28 19:58:30 +0300998 if (nbd_read64(ioc, &info->size, "export length", errp) < 0) {
Eric Blakeb3c9d332019-01-17 13:36:52 -0600999 return -EINVAL;
1000 }
Eric Blakeb3c9d332019-01-17 13:36:52 -06001001
Vladimir Sementsov-Ogievskiye6798f02019-01-28 19:58:30 +03001002 if (nbd_read32(ioc, &oldflags, "export flags", errp) < 0) {
Eric Blakeb3c9d332019-01-17 13:36:52 -06001003 return -EINVAL;
1004 }
Eric Blakeb3c9d332019-01-17 13:36:52 -06001005 if (oldflags & ~0xffff) {
1006 error_setg(errp, "Unexpected export flags %0x" PRIx32, oldflags);
1007 return -EINVAL;
1008 }
1009 info->flags = oldflags;
1010 return 0;
1011}
1012
1013/*
Eric Blake10b89982019-01-17 13:36:51 -06001014 * nbd_receive_negotiate:
1015 * Connect to server, complete negotiation, and move into transmission phase.
1016 * Returns: negative errno: failure talking to server
1017 * 0: server is connected
1018 */
Vladimir Sementsov-Ogievskiya8e2bb62019-06-18 14:43:21 +03001019int nbd_receive_negotiate(AioContext *aio_context, QIOChannel *ioc,
1020 QCryptoTLSCreds *tlscreds,
Eric Blake10b89982019-01-17 13:36:51 -06001021 const char *hostname, QIOChannel **outioc,
1022 NBDExportInfo *info, Error **errp)
1023{
Vladimir Sementsov-Ogievskiy795d9462020-07-07 18:50:36 +02001024 ERRP_GUARD();
Eric Blake10b89982019-01-17 13:36:51 -06001025 int result;
1026 bool zeroes;
1027 bool base_allocation = info->base_allocation;
Vladimir Sementsov-Ogievskiy78a33ab2018-03-12 18:21:23 +03001028
Eric Blake93676c82019-11-13 20:46:34 -06001029 assert(info->name && strlen(info->name) <= NBD_MAX_STRING_SIZE);
Eric Blake10b89982019-01-17 13:36:51 -06001030 trace_nbd_receive_negotiate_name(info->name);
1031
Vladimir Sementsov-Ogievskiya8e2bb62019-06-18 14:43:21 +03001032 result = nbd_start_negotiate(aio_context, ioc, tlscreds, hostname, outioc,
Eric Blake10b89982019-01-17 13:36:51 -06001033 info->structured_reply, &zeroes, errp);
1034
1035 info->structured_reply = false;
1036 info->base_allocation = false;
1037 if (tlscreds && *outioc) {
1038 ioc = *outioc;
1039 }
1040
1041 switch (result) {
1042 case 3: /* newstyle, with structured replies */
1043 info->structured_reply = true;
1044 if (base_allocation) {
1045 result = nbd_negotiate_simple_meta_context(ioc, info, errp);
Eric Blake8ecaeae2017-07-07 15:30:47 -05001046 if (result < 0) {
Eric Blake2b8d0952019-01-17 13:36:50 -06001047 return -EINVAL;
Eric Blake8ecaeae2017-07-07 15:30:47 -05001048 }
Eric Blake10b89982019-01-17 13:36:51 -06001049 info->base_allocation = result == 1;
Daniel P. Berrange9344e5f2016-02-10 18:41:09 +00001050 }
Eric Blake10b89982019-01-17 13:36:51 -06001051 /* fall through */
1052 case 2: /* newstyle, try OPT_GO */
1053 /* Try NBD_OPT_GO first - if it works, we are done (it
1054 * also gives us a good message if the server requires
1055 * TLS). If it is not available, fall back to
1056 * NBD_OPT_LIST for nicer error messages about a missing
1057 * export, then use NBD_OPT_EXPORT_NAME. */
Eric Blake138796d2019-01-17 13:36:53 -06001058 result = nbd_opt_info_or_go(ioc, NBD_OPT_GO, info, errp);
Eric Blake10b89982019-01-17 13:36:51 -06001059 if (result < 0) {
1060 return -EINVAL;
1061 }
1062 if (result > 0) {
1063 return 0;
1064 }
1065 /* Check our desired export is present in the
1066 * server export list. Since NBD_OPT_EXPORT_NAME
1067 * cannot return an error message, running this
1068 * query gives us better error reporting if the
1069 * export name is not available.
1070 */
1071 if (nbd_receive_query_exports(ioc, info->name, errp) < 0) {
1072 return -EINVAL;
1073 }
1074 /* fall through */
1075 case 1: /* newstyle, but limited to EXPORT_NAME */
Eric Blakec8a3a1b2016-10-14 13:33:10 -05001076 /* write the export name request */
Eric Blake6dc16672019-01-17 13:36:46 -06001077 if (nbd_send_option_request(ioc, NBD_OPT_EXPORT_NAME, -1, info->name,
Eric Blakec8a3a1b2016-10-14 13:33:10 -05001078 errp) < 0) {
Eric Blake2b8d0952019-01-17 13:36:50 -06001079 return -EINVAL;
Fam Zheng798bfe02016-01-14 16:41:02 +08001080 }
Fam Zheng798bfe02016-01-14 16:41:02 +08001081
Eric Blakec8a3a1b2016-10-14 13:33:10 -05001082 /* Read the response */
Vladimir Sementsov-Ogievskiye6798f02019-01-28 19:58:30 +03001083 if (nbd_read64(ioc, &info->size, "export length", errp) < 0) {
Eric Blake2b8d0952019-01-17 13:36:50 -06001084 return -EINVAL;
Fam Zheng798bfe02016-01-14 16:41:02 +08001085 }
Fam Zheng798bfe02016-01-14 16:41:02 +08001086
Vladimir Sementsov-Ogievskiye6798f02019-01-28 19:58:30 +03001087 if (nbd_read16(ioc, &info->flags, "export flags", errp) < 0) {
Eric Blake2b8d0952019-01-17 13:36:50 -06001088 return -EINVAL;
Daniel P. Berrangef72d7052016-02-10 18:41:05 +00001089 }
Eric Blake10b89982019-01-17 13:36:51 -06001090 break;
1091 case 0: /* oldstyle, parse length and flags */
Eric Blake6dc16672019-01-17 13:36:46 -06001092 if (*info->name) {
1093 error_setg(errp, "Server does not support non-empty export names");
Eric Blake2b8d0952019-01-17 13:36:50 -06001094 return -EINVAL;
Daniel P. Berrangef72d7052016-02-10 18:41:05 +00001095 }
Eric Blakeb3c9d332019-01-17 13:36:52 -06001096 if (nbd_negotiate_finish_oldstyle(ioc, info, errp) < 0) {
Eric Blake2b8d0952019-01-17 13:36:50 -06001097 return -EINVAL;
Daniel P. Berrangef72d7052016-02-10 18:41:05 +00001098 }
Eric Blake10b89982019-01-17 13:36:51 -06001099 break;
1100 default:
1101 return result;
Fam Zheng798bfe02016-01-14 16:41:02 +08001102 }
Daniel P. Berrangef72d7052016-02-10 18:41:05 +00001103
Eric Blake004a89f2017-07-07 15:30:41 -05001104 trace_nbd_receive_negotiate_size_flags(info->size, info->flags);
Vladimir Sementsov-Ogievskiyd1fdf252017-06-02 18:01:39 +03001105 if (zeroes && nbd_drop(ioc, 124, errp) < 0) {
Eric Blakecb6b1a32017-11-13 09:24:24 -06001106 error_prepend(errp, "Failed to read reserved block: ");
Eric Blake2b8d0952019-01-17 13:36:50 -06001107 return -EINVAL;
Fam Zheng798bfe02016-01-14 16:41:02 +08001108 }
Eric Blake2b8d0952019-01-17 13:36:50 -06001109 return 0;
Fam Zheng798bfe02016-01-14 16:41:02 +08001110}
1111
Eric Blaked21a2d32019-01-17 13:36:54 -06001112/* Clean up result of nbd_receive_export_list */
1113void nbd_free_export_list(NBDExportInfo *info, int count)
1114{
Eric Blake0b576b62019-01-17 13:36:55 -06001115 int i, j;
Eric Blaked21a2d32019-01-17 13:36:54 -06001116
1117 if (!info) {
1118 return;
1119 }
1120
1121 for (i = 0; i < count; i++) {
1122 g_free(info[i].name);
1123 g_free(info[i].description);
Eric Blake0b576b62019-01-17 13:36:55 -06001124 for (j = 0; j < info[i].n_contexts; j++) {
1125 g_free(info[i].contexts[j]);
1126 }
1127 g_free(info[i].contexts);
Eric Blaked21a2d32019-01-17 13:36:54 -06001128 }
1129 g_free(info);
1130}
1131
1132/*
1133 * nbd_receive_export_list:
1134 * Query details about a server's exports, then disconnect without
1135 * going into transmission phase. Return a count of the exports listed
1136 * in @info by the server, or -1 on error. Caller must free @info using
1137 * nbd_free_export_list().
1138 */
1139int nbd_receive_export_list(QIOChannel *ioc, QCryptoTLSCreds *tlscreds,
1140 const char *hostname, NBDExportInfo **info,
1141 Error **errp)
1142{
1143 int result;
1144 int count = 0;
1145 int i;
1146 int rc;
1147 int ret = -1;
1148 NBDExportInfo *array = NULL;
1149 QIOChannel *sioc = NULL;
1150
1151 *info = NULL;
Vladimir Sementsov-Ogievskiya8e2bb62019-06-18 14:43:21 +03001152 result = nbd_start_negotiate(NULL, ioc, tlscreds, hostname, &sioc, true,
1153 NULL, errp);
Eric Blaked21a2d32019-01-17 13:36:54 -06001154 if (tlscreds && sioc) {
1155 ioc = sioc;
1156 }
1157
1158 switch (result) {
1159 case 2:
1160 case 3:
1161 /* newstyle - use NBD_OPT_LIST to populate array, then try
1162 * NBD_OPT_INFO on each array member. If structured replies
1163 * are enabled, also try NBD_OPT_LIST_META_CONTEXT. */
1164 if (nbd_send_option_request(ioc, NBD_OPT_LIST, 0, NULL, errp) < 0) {
1165 goto out;
1166 }
1167 while (1) {
1168 char *name;
1169 char *desc;
1170
1171 rc = nbd_receive_list(ioc, &name, &desc, errp);
1172 if (rc < 0) {
1173 goto out;
1174 } else if (rc == 0) {
1175 break;
1176 }
1177 array = g_renew(NBDExportInfo, array, ++count);
1178 memset(&array[count - 1], 0, sizeof(*array));
1179 array[count - 1].name = name;
1180 array[count - 1].description = desc;
1181 array[count - 1].structured_reply = result == 3;
1182 }
1183
1184 for (i = 0; i < count; i++) {
1185 array[i].request_sizes = true;
1186 rc = nbd_opt_info_or_go(ioc, NBD_OPT_INFO, &array[i], errp);
1187 if (rc < 0) {
1188 goto out;
1189 } else if (rc == 0) {
1190 /*
1191 * Pointless to try rest of loop. If OPT_INFO doesn't work,
1192 * it's unlikely that meta contexts work either
1193 */
1194 break;
1195 }
1196
Eric Blake0b576b62019-01-17 13:36:55 -06001197 if (result == 3 &&
1198 nbd_list_meta_contexts(ioc, &array[i], errp) < 0) {
1199 goto out;
1200 }
Eric Blaked21a2d32019-01-17 13:36:54 -06001201 }
1202
1203 /* Send NBD_OPT_ABORT as a courtesy before hanging up */
1204 nbd_send_opt_abort(ioc);
1205 break;
1206 case 1: /* newstyle, but limited to EXPORT_NAME */
1207 error_setg(errp, "Server does not support export lists");
1208 /* We can't even send NBD_OPT_ABORT, so merely hang up */
1209 goto out;
1210 case 0: /* oldstyle, parse length and flags */
1211 array = g_new0(NBDExportInfo, 1);
1212 array->name = g_strdup("");
1213 count = 1;
1214
1215 if (nbd_negotiate_finish_oldstyle(ioc, array, errp) < 0) {
1216 goto out;
1217 }
1218
1219 /* Send NBD_CMD_DISC as a courtesy to the server, but ignore all
1220 * errors now that we have the information we wanted. */
1221 if (nbd_drop(ioc, 124, NULL) == 0) {
1222 NBDRequest request = { .type = NBD_CMD_DISC };
1223
1224 nbd_send_request(ioc, &request);
1225 }
1226 break;
1227 default:
1228 goto out;
1229 }
1230
1231 *info = array;
1232 array = NULL;
1233 ret = count;
1234
1235 out:
1236 qio_channel_shutdown(ioc, QIO_CHANNEL_SHUTDOWN_BOTH, NULL);
1237 qio_channel_close(ioc, NULL);
1238 object_unref(OBJECT(sioc));
1239 nbd_free_export_list(array, count);
1240 return ret;
1241}
1242
Fam Zheng798bfe02016-01-14 16:41:02 +08001243#ifdef __linux__
Eric Blake004a89f2017-07-07 15:30:41 -05001244int nbd_init(int fd, QIOChannelSocket *sioc, NBDExportInfo *info,
Vladimir Sementsov-Ogievskiybe41c102017-05-26 14:09:13 +03001245 Error **errp)
Fam Zheng798bfe02016-01-14 16:41:02 +08001246{
Eric Blake081dd1f2017-07-07 15:30:49 -05001247 unsigned long sector_size = MAX(BDRV_SECTOR_SIZE, info->min_block);
1248 unsigned long sectors = info->size / sector_size;
1249
1250 /* FIXME: Once the kernel module is patched to honor block sizes,
1251 * and to advertise that fact to user space, we should update the
1252 * hand-off to the kernel to use any block sizes we learned. */
1253 assert(!info->request_sizes);
1254 if (info->size / sector_size != sectors) {
Eric Blake004a89f2017-07-07 15:30:41 -05001255 error_setg(errp, "Export size %" PRIu64 " too large for 32-bit kernel",
1256 info->size);
Eric Blakef57e2412016-05-11 16:39:40 -06001257 return -E2BIG;
1258 }
1259
Vladimir Sementsov-Ogievskiy95884632017-07-07 18:29:18 +03001260 trace_nbd_init_set_socket();
Fam Zheng798bfe02016-01-14 16:41:02 +08001261
Eric Blakef57e2412016-05-11 16:39:40 -06001262 if (ioctl(fd, NBD_SET_SOCK, (unsigned long) sioc->fd) < 0) {
Fam Zheng798bfe02016-01-14 16:41:02 +08001263 int serrno = errno;
Vladimir Sementsov-Ogievskiybe41c102017-05-26 14:09:13 +03001264 error_setg(errp, "Failed to set NBD socket");
Fam Zheng798bfe02016-01-14 16:41:02 +08001265 return -serrno;
1266 }
1267
Eric Blake081dd1f2017-07-07 15:30:49 -05001268 trace_nbd_init_set_block_size(sector_size);
Fam Zheng798bfe02016-01-14 16:41:02 +08001269
Eric Blake081dd1f2017-07-07 15:30:49 -05001270 if (ioctl(fd, NBD_SET_BLKSIZE, sector_size) < 0) {
Fam Zheng798bfe02016-01-14 16:41:02 +08001271 int serrno = errno;
Vladimir Sementsov-Ogievskiybe41c102017-05-26 14:09:13 +03001272 error_setg(errp, "Failed setting NBD block size");
Fam Zheng798bfe02016-01-14 16:41:02 +08001273 return -serrno;
1274 }
1275
Vladimir Sementsov-Ogievskiy95884632017-07-07 18:29:18 +03001276 trace_nbd_init_set_size(sectors);
Eric Blake081dd1f2017-07-07 15:30:49 -05001277 if (info->size % sector_size) {
1278 trace_nbd_init_trailing_bytes(info->size % sector_size);
Eric Blakef57e2412016-05-11 16:39:40 -06001279 }
Fam Zheng798bfe02016-01-14 16:41:02 +08001280
Eric Blakef57e2412016-05-11 16:39:40 -06001281 if (ioctl(fd, NBD_SET_SIZE_BLOCKS, sectors) < 0) {
Fam Zheng798bfe02016-01-14 16:41:02 +08001282 int serrno = errno;
Vladimir Sementsov-Ogievskiybe41c102017-05-26 14:09:13 +03001283 error_setg(errp, "Failed setting size (in blocks)");
Fam Zheng798bfe02016-01-14 16:41:02 +08001284 return -serrno;
1285 }
1286
Eric Blake004a89f2017-07-07 15:30:41 -05001287 if (ioctl(fd, NBD_SET_FLAGS, (unsigned long) info->flags) < 0) {
Fam Zheng798bfe02016-01-14 16:41:02 +08001288 if (errno == ENOTTY) {
Eric Blake004a89f2017-07-07 15:30:41 -05001289 int read_only = (info->flags & NBD_FLAG_READ_ONLY) != 0;
Vladimir Sementsov-Ogievskiy95884632017-07-07 18:29:18 +03001290 trace_nbd_init_set_readonly();
Fam Zheng798bfe02016-01-14 16:41:02 +08001291
1292 if (ioctl(fd, BLKROSET, (unsigned long) &read_only) < 0) {
1293 int serrno = errno;
Vladimir Sementsov-Ogievskiybe41c102017-05-26 14:09:13 +03001294 error_setg(errp, "Failed setting read-only attribute");
Fam Zheng798bfe02016-01-14 16:41:02 +08001295 return -serrno;
1296 }
1297 } else {
1298 int serrno = errno;
Vladimir Sementsov-Ogievskiybe41c102017-05-26 14:09:13 +03001299 error_setg(errp, "Failed setting flags");
Fam Zheng798bfe02016-01-14 16:41:02 +08001300 return -serrno;
1301 }
1302 }
1303
Vladimir Sementsov-Ogievskiy95884632017-07-07 18:29:18 +03001304 trace_nbd_init_finish();
Fam Zheng798bfe02016-01-14 16:41:02 +08001305
1306 return 0;
1307}
1308
1309int nbd_client(int fd)
1310{
1311 int ret;
1312 int serrno;
1313
Vladimir Sementsov-Ogievskiy95884632017-07-07 18:29:18 +03001314 trace_nbd_client_loop();
Fam Zheng798bfe02016-01-14 16:41:02 +08001315
1316 ret = ioctl(fd, NBD_DO_IT);
1317 if (ret < 0 && errno == EPIPE) {
1318 /* NBD_DO_IT normally returns EPIPE when someone has disconnected
1319 * the socket via NBD_DISCONNECT. We do not want to return 1 in
1320 * that case.
1321 */
1322 ret = 0;
1323 }
1324 serrno = errno;
1325
Vladimir Sementsov-Ogievskiy95884632017-07-07 18:29:18 +03001326 trace_nbd_client_loop_ret(ret, strerror(serrno));
Fam Zheng798bfe02016-01-14 16:41:02 +08001327
Vladimir Sementsov-Ogievskiy95884632017-07-07 18:29:18 +03001328 trace_nbd_client_clear_queue();
Fam Zheng798bfe02016-01-14 16:41:02 +08001329 ioctl(fd, NBD_CLEAR_QUE);
1330
Vladimir Sementsov-Ogievskiy95884632017-07-07 18:29:18 +03001331 trace_nbd_client_clear_socket();
Fam Zheng798bfe02016-01-14 16:41:02 +08001332 ioctl(fd, NBD_CLEAR_SOCK);
1333
1334 errno = serrno;
1335 return ret;
1336}
Eric Blake98494e32016-05-11 16:39:39 -06001337
1338int nbd_disconnect(int fd)
1339{
1340 ioctl(fd, NBD_CLEAR_QUE);
1341 ioctl(fd, NBD_DISCONNECT);
1342 ioctl(fd, NBD_CLEAR_SOCK);
1343 return 0;
1344}
1345
Eric Blake3c1fa352018-12-15 07:53:08 -06001346#endif /* __linux__ */
Fam Zheng798bfe02016-01-14 16:41:02 +08001347
Vladimir Sementsov-Ogievskiy490dc5e2017-08-04 18:14:27 +03001348int nbd_send_request(QIOChannel *ioc, NBDRequest *request)
Fam Zheng798bfe02016-01-14 16:41:02 +08001349{
1350 uint8_t buf[NBD_REQUEST_SIZE];
Fam Zheng798bfe02016-01-14 16:41:02 +08001351
Vladimir Sementsov-Ogievskiy95884632017-07-07 18:29:18 +03001352 trace_nbd_send_request(request->from, request->len, request->handle,
Eric Blake48000eb2017-07-17 14:26:34 -05001353 request->flags, request->type,
1354 nbd_cmd_lookup(request->type));
Eric Blake7548fe32016-04-05 21:35:04 -06001355
Peter Maydellf6be6722016-06-10 17:15:42 +01001356 stl_be_p(buf, NBD_REQUEST_MAGIC);
Eric Blakeb626b512016-10-14 13:33:04 -05001357 stw_be_p(buf + 4, request->flags);
1358 stw_be_p(buf + 6, request->type);
Peter Maydellf6be6722016-06-10 17:15:42 +01001359 stq_be_p(buf + 8, request->handle);
1360 stq_be_p(buf + 16, request->from);
1361 stl_be_p(buf + 24, request->len);
Fam Zheng798bfe02016-01-14 16:41:02 +08001362
Vladimir Sementsov-Ogievskiyd1fdf252017-06-02 18:01:39 +03001363 return nbd_write(ioc, buf, sizeof(buf), NULL);
Fam Zheng798bfe02016-01-14 16:41:02 +08001364}
1365
Vladimir Sementsov-Ogievskiyd2febed2017-10-27 12:40:35 +02001366/* nbd_receive_simple_reply
1367 * Read simple reply except magic field (which should be already read).
1368 * Payload is not read (payload is possible for CMD_READ, but here we even
1369 * don't know whether it take place or not).
1370 */
1371static int nbd_receive_simple_reply(QIOChannel *ioc, NBDSimpleReply *reply,
1372 Error **errp)
1373{
1374 int ret;
1375
1376 assert(reply->magic == NBD_SIMPLE_REPLY_MAGIC);
1377
1378 ret = nbd_read(ioc, (uint8_t *)reply + sizeof(reply->magic),
Vladimir Sementsov-Ogievskiye6798f02019-01-28 19:58:30 +03001379 sizeof(*reply) - sizeof(reply->magic), "reply", errp);
Vladimir Sementsov-Ogievskiyd2febed2017-10-27 12:40:35 +02001380 if (ret < 0) {
1381 return ret;
1382 }
1383
Peter Maydell80c7c2b2018-09-27 17:42:00 +01001384 reply->error = be32_to_cpu(reply->error);
1385 reply->handle = be64_to_cpu(reply->handle);
Vladimir Sementsov-Ogievskiyd2febed2017-10-27 12:40:35 +02001386
1387 return 0;
1388}
1389
1390/* nbd_receive_structured_reply_chunk
1391 * Read structured reply chunk except magic field (which should be already
1392 * read).
1393 * Payload is not read.
1394 */
1395static int nbd_receive_structured_reply_chunk(QIOChannel *ioc,
1396 NBDStructuredReplyChunk *chunk,
1397 Error **errp)
1398{
1399 int ret;
1400
1401 assert(chunk->magic == NBD_STRUCTURED_REPLY_MAGIC);
1402
1403 ret = nbd_read(ioc, (uint8_t *)chunk + sizeof(chunk->magic),
Vladimir Sementsov-Ogievskiye6798f02019-01-28 19:58:30 +03001404 sizeof(*chunk) - sizeof(chunk->magic), "structured chunk",
1405 errp);
Vladimir Sementsov-Ogievskiyd2febed2017-10-27 12:40:35 +02001406 if (ret < 0) {
1407 return ret;
1408 }
1409
Peter Maydell80c7c2b2018-09-27 17:42:00 +01001410 chunk->flags = be16_to_cpu(chunk->flags);
1411 chunk->type = be16_to_cpu(chunk->type);
1412 chunk->handle = be64_to_cpu(chunk->handle);
1413 chunk->length = be32_to_cpu(chunk->length);
Vladimir Sementsov-Ogievskiyd2febed2017-10-27 12:40:35 +02001414
1415 return 0;
1416}
1417
Kevin Wolfa7b78fc2019-02-18 14:38:15 +01001418/* nbd_read_eof
1419 * Tries to read @size bytes from @ioc.
1420 * Returns 1 on success
1421 * 0 on eof, when no data was read (errp is not set)
1422 * negative errno on failure (errp is set)
1423 */
1424static inline int coroutine_fn
Kevin Wolfd3bd5b92019-02-18 14:56:01 +01001425nbd_read_eof(BlockDriverState *bs, QIOChannel *ioc, void *buffer, size_t size,
1426 Error **errp)
Kevin Wolfa7b78fc2019-02-18 14:38:15 +01001427{
Kevin Wolfd3bd5b92019-02-18 14:56:01 +01001428 bool partial = false;
Kevin Wolfa7b78fc2019-02-18 14:38:15 +01001429
1430 assert(size);
Kevin Wolfd3bd5b92019-02-18 14:56:01 +01001431 while (size > 0) {
1432 struct iovec iov = { .iov_base = buffer, .iov_len = size };
1433 ssize_t len;
1434
1435 len = qio_channel_readv(ioc, &iov, 1, errp);
1436 if (len == QIO_CHANNEL_ERR_BLOCK) {
1437 bdrv_dec_in_flight(bs);
1438 qio_channel_yield(ioc, G_IO_IN);
1439 bdrv_inc_in_flight(bs);
1440 continue;
1441 } else if (len < 0) {
1442 return -EIO;
1443 } else if (len == 0) {
1444 if (partial) {
1445 error_setg(errp,
1446 "Unexpected end-of-file before all bytes were read");
1447 return -EIO;
1448 } else {
1449 return 0;
1450 }
1451 }
1452
1453 partial = true;
1454 size -= len;
1455 buffer = (uint8_t*) buffer + len;
Kevin Wolfa7b78fc2019-02-18 14:38:15 +01001456 }
Kevin Wolfd3bd5b92019-02-18 14:56:01 +01001457 return 1;
Kevin Wolfa7b78fc2019-02-18 14:38:15 +01001458}
1459
Vladimir Sementsov-Ogievskiyba845642017-08-04 18:14:26 +03001460/* nbd_receive_reply
Kevin Wolfd3bd5b92019-02-18 14:56:01 +01001461 *
1462 * Decreases bs->in_flight while waiting for a new reply. This yield is where
1463 * we wait indefinitely and the coroutine must be able to be safely reentered
1464 * for nbd_client_attach_aio_context().
1465 *
Vladimir Sementsov-Ogievskiyba845642017-08-04 18:14:26 +03001466 * Returns 1 on success
1467 * 0 on eof, when no data was read (errp is not set)
1468 * negative errno on failure (errp is set)
1469 */
Kevin Wolfd3bd5b92019-02-18 14:56:01 +01001470int coroutine_fn nbd_receive_reply(BlockDriverState *bs, QIOChannel *ioc,
1471 NBDReply *reply, Error **errp)
Fam Zheng798bfe02016-01-14 16:41:02 +08001472{
Vladimir Sementsov-Ogievskiyba845642017-08-04 18:14:26 +03001473 int ret;
Eric Blake079d3262017-11-08 15:56:59 -06001474 const char *type;
Fam Zheng798bfe02016-01-14 16:41:02 +08001475
Kevin Wolfd3bd5b92019-02-18 14:56:01 +01001476 ret = nbd_read_eof(bs, ioc, &reply->magic, sizeof(reply->magic), errp);
Paolo Bonziniff829112017-02-13 14:52:24 +01001477 if (ret <= 0) {
Fam Zheng798bfe02016-01-14 16:41:02 +08001478 return ret;
1479 }
1480
Peter Maydell80c7c2b2018-09-27 17:42:00 +01001481 reply->magic = be32_to_cpu(reply->magic);
Fam Zheng798bfe02016-01-14 16:41:02 +08001482
Vladimir Sementsov-Ogievskiyd2febed2017-10-27 12:40:35 +02001483 switch (reply->magic) {
1484 case NBD_SIMPLE_REPLY_MAGIC:
1485 ret = nbd_receive_simple_reply(ioc, &reply->simple, errp);
1486 if (ret < 0) {
1487 break;
1488 }
Vladimir Sementsov-Ogievskiyd2febed2017-10-27 12:40:35 +02001489 trace_nbd_receive_simple_reply(reply->simple.error,
1490 nbd_err_lookup(reply->simple.error),
1491 reply->handle);
Vladimir Sementsov-Ogievskiyd2febed2017-10-27 12:40:35 +02001492 break;
1493 case NBD_STRUCTURED_REPLY_MAGIC:
1494 ret = nbd_receive_structured_reply_chunk(ioc, &reply->structured, errp);
1495 if (ret < 0) {
1496 break;
1497 }
Eric Blake079d3262017-11-08 15:56:59 -06001498 type = nbd_reply_type_lookup(reply->structured.type);
Vladimir Sementsov-Ogievskiyd2febed2017-10-27 12:40:35 +02001499 trace_nbd_receive_structured_reply_chunk(reply->structured.flags,
Eric Blake079d3262017-11-08 15:56:59 -06001500 reply->structured.type, type,
Vladimir Sementsov-Ogievskiyd2febed2017-10-27 12:40:35 +02001501 reply->structured.handle,
1502 reply->structured.length);
1503 break;
1504 default:
1505 error_setg(errp, "invalid magic (got 0x%" PRIx32 ")", reply->magic);
Eric Blakeb6f5d3b2016-10-14 13:33:16 -05001506 return -EINVAL;
1507 }
Vladimir Sementsov-Ogievskiyd2febed2017-10-27 12:40:35 +02001508 if (ret < 0) {
1509 return ret;
Fam Zheng798bfe02016-01-14 16:41:02 +08001510 }
Vladimir Sementsov-Ogievskiyba845642017-08-04 18:14:26 +03001511
1512 return 1;
Fam Zheng798bfe02016-01-14 16:41:02 +08001513}
1514