Merge remote-tracking branch 'remotes/kevin/tags/for-upstream' into staging
[qemu.git] / block / nbd.c
1 /*
2 * QEMU Block driver for NBD
3 *
4 * Copyright (C) 2008 Bull S.A.S.
5 * Author: Laurent Vivier <Laurent.Vivier@bull.net>
6 *
7 * Some parts:
8 * Copyright (C) 2007 Anthony Liguori <anthony@codemonkey.ws>
9 *
10 * Permission is hereby granted, free of charge, to any person obtaining a copy
11 * of this software and associated documentation files (the "Software"), to deal
12 * in the Software without restriction, including without limitation the rights
13 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
14 * copies of the Software, and to permit persons to whom the Software is
15 * furnished to do so, subject to the following conditions:
16 *
17 * The above copyright notice and this permission notice shall be included in
18 * all copies or substantial portions of the Software.
19 *
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
23 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
24 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
25 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
26 * THE SOFTWARE.
27 */
28
29 #include "block/nbd-client.h"
30 #include "qemu/uri.h"
31 #include "block/block_int.h"
32 #include "qemu/module.h"
33 #include "qemu/sockets.h"
34 #include "qapi/qmp/qjson.h"
35 #include "qapi/qmp/qint.h"
36
37 #include <sys/types.h>
38 #include <unistd.h>
39
40 #define EN_OPTSTR ":exportname="
41
42 typedef struct BDRVNBDState {
43 NbdClientSession client;
44 QemuOpts *socket_opts;
45 } BDRVNBDState;
46
47 static int nbd_parse_uri(const char *filename, QDict *options)
48 {
49 URI *uri;
50 const char *p;
51 QueryParams *qp = NULL;
52 int ret = 0;
53 bool is_unix;
54
55 uri = uri_parse(filename);
56 if (!uri) {
57 return -EINVAL;
58 }
59
60 /* transport */
61 if (!strcmp(uri->scheme, "nbd")) {
62 is_unix = false;
63 } else if (!strcmp(uri->scheme, "nbd+tcp")) {
64 is_unix = false;
65 } else if (!strcmp(uri->scheme, "nbd+unix")) {
66 is_unix = true;
67 } else {
68 ret = -EINVAL;
69 goto out;
70 }
71
72 p = uri->path ? uri->path : "/";
73 p += strspn(p, "/");
74 if (p[0]) {
75 qdict_put(options, "export", qstring_from_str(p));
76 }
77
78 qp = query_params_parse(uri->query);
79 if (qp->n > 1 || (is_unix && !qp->n) || (!is_unix && qp->n)) {
80 ret = -EINVAL;
81 goto out;
82 }
83
84 if (is_unix) {
85 /* nbd+unix:///export?socket=path */
86 if (uri->server || uri->port || strcmp(qp->p[0].name, "socket")) {
87 ret = -EINVAL;
88 goto out;
89 }
90 qdict_put(options, "path", qstring_from_str(qp->p[0].value));
91 } else {
92 QString *host;
93 /* nbd[+tcp]://host[:port]/export */
94 if (!uri->server) {
95 ret = -EINVAL;
96 goto out;
97 }
98
99 /* strip braces from literal IPv6 address */
100 if (uri->server[0] == '[') {
101 host = qstring_from_substr(uri->server, 1,
102 strlen(uri->server) - 2);
103 } else {
104 host = qstring_from_str(uri->server);
105 }
106
107 qdict_put(options, "host", host);
108 if (uri->port) {
109 char* port_str = g_strdup_printf("%d", uri->port);
110 qdict_put(options, "port", qstring_from_str(port_str));
111 g_free(port_str);
112 }
113 }
114
115 out:
116 if (qp) {
117 query_params_free(qp);
118 }
119 uri_free(uri);
120 return ret;
121 }
122
123 static void nbd_parse_filename(const char *filename, QDict *options,
124 Error **errp)
125 {
126 char *file;
127 char *export_name;
128 const char *host_spec;
129 const char *unixpath;
130
131 if (qdict_haskey(options, "host")
132 || qdict_haskey(options, "port")
133 || qdict_haskey(options, "path"))
134 {
135 error_setg(errp, "host/port/path and a file name may not be specified "
136 "at the same time");
137 return;
138 }
139
140 if (strstr(filename, "://")) {
141 int ret = nbd_parse_uri(filename, options);
142 if (ret < 0) {
143 error_setg(errp, "No valid URL specified");
144 }
145 return;
146 }
147
148 file = g_strdup(filename);
149
150 export_name = strstr(file, EN_OPTSTR);
151 if (export_name) {
152 if (export_name[strlen(EN_OPTSTR)] == 0) {
153 goto out;
154 }
155 export_name[0] = 0; /* truncate 'file' */
156 export_name += strlen(EN_OPTSTR);
157
158 qdict_put(options, "export", qstring_from_str(export_name));
159 }
160
161 /* extract the host_spec - fail if it's not nbd:... */
162 if (!strstart(file, "nbd:", &host_spec)) {
163 error_setg(errp, "File name string for NBD must start with 'nbd:'");
164 goto out;
165 }
166
167 if (!*host_spec) {
168 goto out;
169 }
170
171 /* are we a UNIX or TCP socket? */
172 if (strstart(host_spec, "unix:", &unixpath)) {
173 qdict_put(options, "path", qstring_from_str(unixpath));
174 } else {
175 InetSocketAddress *addr = NULL;
176
177 addr = inet_parse(host_spec, errp);
178 if (error_is_set(errp)) {
179 goto out;
180 }
181
182 qdict_put(options, "host", qstring_from_str(addr->host));
183 qdict_put(options, "port", qstring_from_str(addr->port));
184 qapi_free_InetSocketAddress(addr);
185 }
186
187 out:
188 g_free(file);
189 }
190
191 static void nbd_config(BDRVNBDState *s, QDict *options, char **export,
192 Error **errp)
193 {
194 Error *local_err = NULL;
195
196 if (qdict_haskey(options, "path") == qdict_haskey(options, "host")) {
197 if (qdict_haskey(options, "path")) {
198 error_setg(errp, "path and host may not be used at the same time.");
199 } else {
200 error_setg(errp, "one of path and host must be specified.");
201 }
202 return;
203 }
204
205 s->client.is_unix = qdict_haskey(options, "path");
206 s->socket_opts = qemu_opts_create(&socket_optslist, NULL, 0,
207 &error_abort);
208
209 qemu_opts_absorb_qdict(s->socket_opts, options, &local_err);
210 if (local_err) {
211 error_propagate(errp, local_err);
212 return;
213 }
214
215 if (!qemu_opt_get(s->socket_opts, "port")) {
216 qemu_opt_set_number(s->socket_opts, "port", NBD_DEFAULT_PORT);
217 }
218
219 *export = g_strdup(qdict_get_try_str(options, "export"));
220 if (*export) {
221 qdict_del(options, "export");
222 }
223 }
224
225 static int nbd_establish_connection(BlockDriverState *bs, Error **errp)
226 {
227 BDRVNBDState *s = bs->opaque;
228 int sock;
229
230 if (s->client.is_unix) {
231 sock = unix_connect_opts(s->socket_opts, errp, NULL, NULL);
232 } else {
233 sock = inet_connect_opts(s->socket_opts, errp, NULL, NULL);
234 if (sock >= 0) {
235 socket_set_nodelay(sock);
236 }
237 }
238
239 /* Failed to establish connection */
240 if (sock < 0) {
241 logout("Failed to establish connection to NBD server\n");
242 return -errno;
243 }
244
245 return sock;
246 }
247
248 static int nbd_open(BlockDriverState *bs, QDict *options, int flags,
249 Error **errp)
250 {
251 BDRVNBDState *s = bs->opaque;
252 char *export = NULL;
253 int result, sock;
254 Error *local_err = NULL;
255
256 /* Pop the config into our state object. Exit if invalid. */
257 nbd_config(s, options, &export, &local_err);
258 if (local_err) {
259 error_propagate(errp, local_err);
260 return -EINVAL;
261 }
262
263 /* establish TCP connection, return error if it fails
264 * TODO: Configurable retry-until-timeout behaviour.
265 */
266 sock = nbd_establish_connection(bs, errp);
267 if (sock < 0) {
268 return sock;
269 }
270
271 /* NBD handshake */
272 result = nbd_client_session_init(&s->client, bs, sock, export);
273 g_free(export);
274 return result;
275 }
276
277 static int nbd_co_readv(BlockDriverState *bs, int64_t sector_num,
278 int nb_sectors, QEMUIOVector *qiov)
279 {
280 BDRVNBDState *s = bs->opaque;
281
282 return nbd_client_session_co_readv(&s->client, sector_num,
283 nb_sectors, qiov);
284 }
285
286 static int nbd_co_writev(BlockDriverState *bs, int64_t sector_num,
287 int nb_sectors, QEMUIOVector *qiov)
288 {
289 BDRVNBDState *s = bs->opaque;
290
291 return nbd_client_session_co_writev(&s->client, sector_num,
292 nb_sectors, qiov);
293 }
294
295 static int nbd_co_flush(BlockDriverState *bs)
296 {
297 BDRVNBDState *s = bs->opaque;
298
299 return nbd_client_session_co_flush(&s->client);
300 }
301
302 static int nbd_co_discard(BlockDriverState *bs, int64_t sector_num,
303 int nb_sectors)
304 {
305 BDRVNBDState *s = bs->opaque;
306
307 return nbd_client_session_co_discard(&s->client, sector_num,
308 nb_sectors);
309 }
310
311 static void nbd_close(BlockDriverState *bs)
312 {
313 BDRVNBDState *s = bs->opaque;
314
315 qemu_opts_del(s->socket_opts);
316 nbd_client_session_close(&s->client);
317 }
318
319 static int64_t nbd_getlength(BlockDriverState *bs)
320 {
321 BDRVNBDState *s = bs->opaque;
322
323 return s->client.size;
324 }
325
326 static BlockDriver bdrv_nbd = {
327 .format_name = "nbd",
328 .protocol_name = "nbd",
329 .instance_size = sizeof(BDRVNBDState),
330 .bdrv_parse_filename = nbd_parse_filename,
331 .bdrv_file_open = nbd_open,
332 .bdrv_co_readv = nbd_co_readv,
333 .bdrv_co_writev = nbd_co_writev,
334 .bdrv_close = nbd_close,
335 .bdrv_co_flush_to_os = nbd_co_flush,
336 .bdrv_co_discard = nbd_co_discard,
337 .bdrv_getlength = nbd_getlength,
338 };
339
340 static BlockDriver bdrv_nbd_tcp = {
341 .format_name = "nbd",
342 .protocol_name = "nbd+tcp",
343 .instance_size = sizeof(BDRVNBDState),
344 .bdrv_parse_filename = nbd_parse_filename,
345 .bdrv_file_open = nbd_open,
346 .bdrv_co_readv = nbd_co_readv,
347 .bdrv_co_writev = nbd_co_writev,
348 .bdrv_close = nbd_close,
349 .bdrv_co_flush_to_os = nbd_co_flush,
350 .bdrv_co_discard = nbd_co_discard,
351 .bdrv_getlength = nbd_getlength,
352 };
353
354 static BlockDriver bdrv_nbd_unix = {
355 .format_name = "nbd",
356 .protocol_name = "nbd+unix",
357 .instance_size = sizeof(BDRVNBDState),
358 .bdrv_parse_filename = nbd_parse_filename,
359 .bdrv_file_open = nbd_open,
360 .bdrv_co_readv = nbd_co_readv,
361 .bdrv_co_writev = nbd_co_writev,
362 .bdrv_close = nbd_close,
363 .bdrv_co_flush_to_os = nbd_co_flush,
364 .bdrv_co_discard = nbd_co_discard,
365 .bdrv_getlength = nbd_getlength,
366 };
367
368 static void bdrv_nbd_init(void)
369 {
370 bdrv_register(&bdrv_nbd);
371 bdrv_register(&bdrv_nbd_tcp);
372 bdrv_register(&bdrv_nbd_unix);
373 }
374
375 block_init(bdrv_nbd_init);