]>
Commit | Line | Data |
---|---|---|
cd831bd7 | 1 | /* |
7a5ca864 FB |
2 | * Copyright (C) 2005 Anthony Liguori <anthony@codemonkey.ws> |
3 | * | |
4 | * Network Block Device | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or modify | |
7 | * it under the terms of the GNU General Public License as published by | |
8 | * the Free Software Foundation; under version 2 of the License. | |
9 | * | |
10 | * This program is distributed in the hope that it will be useful, | |
11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 | * GNU General Public License for more details. | |
14 | * | |
15 | * You should have received a copy of the GNU General Public License | |
8167ee88 | 16 | * along with this program; if not, see <http://www.gnu.org/licenses/>. |
7a5ca864 FB |
17 | */ |
18 | ||
d38ea87a | 19 | #include "qemu/osdep.h" |
da34e65c | 20 | #include "qapi/error.h" |
5a61cb60 | 21 | #include "qemu-common.h" |
f348b6d1 | 22 | #include "qemu/cutils.h" |
26f54e9a | 23 | #include "sysemu/block-backend.h" |
b3838a40 | 24 | #include "block/block_int.h" |
737e150e | 25 | #include "block/nbd.h" |
6a1751b7 | 26 | #include "qemu/main-loop.h" |
537b41f5 | 27 | #include "qemu/error-report.h" |
0ab3b337 | 28 | #include "qemu/config-file.h" |
8c116b0e | 29 | #include "block/snapshot.h" |
b3838a40 | 30 | #include "qapi/util.h" |
d49b6836 | 31 | #include "qapi/qmp/qstring.h" |
0ab3b337 | 32 | #include "qom/object_interfaces.h" |
d0d6ff58 | 33 | #include "io/channel-socket.h" |
7a5ca864 | 34 | |
7a5ca864 | 35 | #include <getopt.h> |
2bff4b6f | 36 | #include <libgen.h> |
a517e88b | 37 | #include <pthread.h> |
cd831bd7 | 38 | |
713cc671 | 39 | #define SOCKET_PATH "/var/lock/qemu-nbd-%s" |
fa8b7ce2 DB |
40 | #define QEMU_NBD_OPT_CACHE 256 |
41 | #define QEMU_NBD_OPT_AIO 257 | |
42 | #define QEMU_NBD_OPT_DISCARD 258 | |
43 | #define QEMU_NBD_OPT_DETECT_ZEROES 259 | |
44 | #define QEMU_NBD_OPT_OBJECT 260 | |
45 | #define QEMU_NBD_OPT_TLSCREDS 261 | |
46 | #define QEMU_NBD_OPT_IMAGE_OPTS 262 | |
7a5ca864 | 47 | |
af49bbbe | 48 | static NBDExport *exp; |
3d4b2f9c | 49 | static bool newproto; |
b1d8e52e | 50 | static int verbose; |
a517e88b | 51 | static char *srcpath; |
48bec07e | 52 | static SocketAddress *saddr; |
7860a380 PB |
53 | static int persistent = 0; |
54 | static enum { RUNNING, TERMINATE, TERMINATING, TERMINATED } state; | |
a61c6782 PB |
55 | static int shared = 1; |
56 | static int nb_fds; | |
d0d6ff58 DB |
57 | static QIOChannelSocket *server_ioc; |
58 | static int server_watch = -1; | |
145614a1 | 59 | static QCryptoTLSCreds *tlscreds; |
7a5ca864 FB |
60 | |
61 | static void usage(const char *name) | |
62 | { | |
b033cd86 | 63 | (printf) ( |
7a5ca864 FB |
64 | "Usage: %s [OPTIONS] FILE\n" |
65 | "QEMU Disk Network Block Device Server\n" | |
66 | "\n" | |
713cc671 PL |
67 | " -h, --help display this help and exit\n" |
68 | " -V, --version output version information and exit\n" | |
b033cd86 PB |
69 | "\n" |
70 | "Connection properties:\n" | |
713cc671 PL |
71 | " -p, --port=PORT port to listen on (default `%d')\n" |
72 | " -b, --bind=IFACE interface to bind to (default `0.0.0.0')\n" | |
73 | " -k, --socket=PATH path to the unix socket\n" | |
74 | " (default '"SOCKET_PATH"')\n" | |
75 | " -e, --shared=NUM device can be shared by NUM clients (default '1')\n" | |
76 | " -t, --persistent don't exit on the last connection\n" | |
77 | " -v, --verbose display extra debugging information\n" | |
332a254b | 78 | " -x, --export-name=NAME expose export by name\n" |
7a5ca864 | 79 | "\n" |
b033cd86 | 80 | "Exposing part of the image:\n" |
713cc671 PL |
81 | " -o, --offset=OFFSET offset into the image\n" |
82 | " -P, --partition=NUM only expose partition NUM\n" | |
b033cd86 | 83 | "\n" |
0ab3b337 DB |
84 | "General purpose options:\n" |
85 | " --object type,id=ID,... define an object such as 'secret' for providing\n" | |
86 | " passwords and/or encryption keys\n" | |
b033cd86 PB |
87 | #ifdef __linux__ |
88 | "Kernel NBD client support:\n" | |
713cc671 PL |
89 | " -c, --connect=DEV connect FILE to the local NBD device DEV\n" |
90 | " -d, --disconnect disconnect the specified device\n" | |
b033cd86 PB |
91 | "\n" |
92 | #endif | |
93 | "\n" | |
94 | "Block device options:\n" | |
713cc671 PL |
95 | " -f, --format=FORMAT set image format (raw, qcow2, ...)\n" |
96 | " -r, --read-only export read-only\n" | |
97 | " -s, --snapshot use FILE as an external snapshot, create a temporary\n" | |
98 | " file with backing_file=FILE, redirect the write to\n" | |
99 | " the temporary one\n" | |
8c116b0e | 100 | " -l, --load-snapshot=SNAPSHOT_PARAM\n" |
713cc671 PL |
101 | " load an internal snapshot inside FILE and export it\n" |
102 | " as an read-only device, SNAPSHOT_PARAM format is\n" | |
103 | " 'snapshot.id=[ID],snapshot.name=[NAME]', or\n" | |
104 | " '[ID_OR_NAME]'\n" | |
105 | " -n, --nocache disable host cache\n" | |
106 | " --cache=MODE set cache mode (none, writeback, ...)\n" | |
713cc671 | 107 | " --aio=MODE set AIO mode (native or threads)\n" |
b3838a40 | 108 | " --discard=MODE set discard mode (ignore, unmap)\n" |
6883de6c | 109 | " --detect-zeroes=MODE set detect-zeroes mode (off, on, unmap)\n" |
77c9aaef | 110 | " --image-opts treat FILE as a full set of image options\n" |
b033cd86 PB |
111 | "\n" |
112 | "Report bugs to <qemu-devel@nongnu.org>\n" | |
c2e2872b | 113 | , name, NBD_DEFAULT_PORT, "DEVICE"); |
7a5ca864 FB |
114 | } |
115 | ||
116 | static void version(const char *name) | |
117 | { | |
118 | printf( | |
315bc7aa | 119 | "%s version 0.0.1\n" |
7a5ca864 FB |
120 | "Written by Anthony Liguori.\n" |
121 | "\n" | |
122 | "Copyright (C) 2006 Anthony Liguori <anthony@codemonkey.ws>.\n" | |
123 | "This is free software; see the source for copying conditions. There is NO\n" | |
124 | "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n" | |
315bc7aa | 125 | , name); |
7a5ca864 FB |
126 | } |
127 | ||
128 | struct partition_record | |
129 | { | |
130 | uint8_t bootable; | |
131 | uint8_t start_head; | |
132 | uint32_t start_cylinder; | |
133 | uint8_t start_sector; | |
134 | uint8_t system; | |
135 | uint8_t end_head; | |
136 | uint8_t end_cylinder; | |
137 | uint8_t end_sector; | |
138 | uint32_t start_sector_abs; | |
139 | uint32_t nb_sectors_abs; | |
140 | }; | |
141 | ||
142 | static void read_partition(uint8_t *p, struct partition_record *r) | |
143 | { | |
144 | r->bootable = p[0]; | |
145 | r->start_head = p[1]; | |
146 | r->start_cylinder = p[3] | ((p[2] << 2) & 0x0300); | |
147 | r->start_sector = p[2] & 0x3f; | |
148 | r->system = p[4]; | |
149 | r->end_head = p[5]; | |
150 | r->end_cylinder = p[7] | ((p[6] << 2) & 0x300); | |
151 | r->end_sector = p[6] & 0x3f; | |
ac97393d HR |
152 | |
153 | r->start_sector_abs = le32_to_cpup((uint32_t *)(p + 8)); | |
154 | r->nb_sectors_abs = le32_to_cpup((uint32_t *)(p + 12)); | |
7a5ca864 FB |
155 | } |
156 | ||
4c58e80a | 157 | static int find_partition(BlockBackend *blk, int partition, |
7a5ca864 FB |
158 | off_t *offset, off_t *size) |
159 | { | |
160 | struct partition_record mbr[4]; | |
161 | uint8_t data[512]; | |
162 | int i; | |
163 | int ext_partnum = 4; | |
cb7cf0e3 | 164 | int ret; |
7a5ca864 | 165 | |
4c58e80a | 166 | if ((ret = blk_read(blk, 0, data, 1)) < 0) { |
a4699e55 | 167 | error_report("error while reading: %s", strerror(-ret)); |
85b01e09 | 168 | exit(EXIT_FAILURE); |
cb7cf0e3 | 169 | } |
7a5ca864 FB |
170 | |
171 | if (data[510] != 0x55 || data[511] != 0xaa) { | |
185b4338 | 172 | return -EINVAL; |
7a5ca864 FB |
173 | } |
174 | ||
175 | for (i = 0; i < 4; i++) { | |
176 | read_partition(&data[446 + 16 * i], &mbr[i]); | |
177 | ||
453b07b1 | 178 | if (!mbr[i].system || !mbr[i].nb_sectors_abs) { |
7a5ca864 | 179 | continue; |
453b07b1 | 180 | } |
7a5ca864 FB |
181 | |
182 | if (mbr[i].system == 0xF || mbr[i].system == 0x5) { | |
183 | struct partition_record ext[4]; | |
184 | uint8_t data1[512]; | |
185 | int j; | |
186 | ||
4c58e80a | 187 | if ((ret = blk_read(blk, mbr[i].start_sector_abs, data1, 1)) < 0) { |
a4699e55 | 188 | error_report("error while reading: %s", strerror(-ret)); |
85b01e09 | 189 | exit(EXIT_FAILURE); |
cb7cf0e3 | 190 | } |
7a5ca864 FB |
191 | |
192 | for (j = 0; j < 4; j++) { | |
193 | read_partition(&data1[446 + 16 * j], &ext[j]); | |
453b07b1 | 194 | if (!ext[j].system || !ext[j].nb_sectors_abs) { |
7a5ca864 | 195 | continue; |
453b07b1 | 196 | } |
7a5ca864 FB |
197 | |
198 | if ((ext_partnum + j + 1) == partition) { | |
199 | *offset = (uint64_t)ext[j].start_sector_abs << 9; | |
200 | *size = (uint64_t)ext[j].nb_sectors_abs << 9; | |
201 | return 0; | |
202 | } | |
203 | } | |
204 | ext_partnum += 4; | |
205 | } else if ((i + 1) == partition) { | |
206 | *offset = (uint64_t)mbr[i].start_sector_abs << 9; | |
207 | *size = (uint64_t)mbr[i].nb_sectors_abs << 9; | |
208 | return 0; | |
209 | } | |
210 | } | |
211 | ||
185b4338 | 212 | return -ENOENT; |
7a5ca864 FB |
213 | } |
214 | ||
bb345110 PB |
215 | static void termsig_handler(int signum) |
216 | { | |
7860a380 | 217 | state = TERMINATE; |
a61c6782 | 218 | qemu_notify_event(); |
bb345110 PB |
219 | } |
220 | ||
537b41f5 | 221 | |
a517e88b | 222 | static void *show_parts(void *arg) |
cd831bd7 | 223 | { |
a6ac2313 | 224 | char *device = arg; |
a517e88b PB |
225 | int nbd; |
226 | ||
227 | /* linux just needs an open() to trigger | |
228 | * the partition table update | |
229 | * but remember to load the module with max_part != 0 : | |
230 | * modprobe nbd max_part=63 | |
231 | */ | |
232 | nbd = open(device, O_RDWR); | |
fc19f8a0 | 233 | if (nbd >= 0) { |
a517e88b PB |
234 | close(nbd); |
235 | } | |
236 | return NULL; | |
237 | } | |
cd831bd7 | 238 | |
a517e88b PB |
239 | static void *nbd_client_thread(void *arg) |
240 | { | |
a6ac2313 | 241 | char *device = arg; |
a517e88b | 242 | off_t size; |
a517e88b | 243 | uint32_t nbdflags; |
d0d6ff58 DB |
244 | QIOChannelSocket *sioc; |
245 | int fd; | |
a517e88b PB |
246 | int ret; |
247 | pthread_t show_parts_thread; | |
1ce52846 | 248 | Error *local_error = NULL; |
a517e88b | 249 | |
d0d6ff58 DB |
250 | sioc = qio_channel_socket_new(); |
251 | if (qio_channel_socket_connect_sync(sioc, | |
252 | saddr, | |
253 | &local_error) < 0) { | |
48bec07e | 254 | error_report_err(local_error); |
dc10e8b3 SH |
255 | goto out; |
256 | } | |
a517e88b | 257 | |
1c778ef7 | 258 | ret = nbd_receive_negotiate(QIO_CHANNEL(sioc), NULL, &nbdflags, |
f95910fe | 259 | NULL, NULL, NULL, |
3f472659 | 260 | &size, &local_error); |
fc19f8a0 | 261 | if (ret < 0) { |
1ce52846 | 262 | if (local_error) { |
78288671 | 263 | error_report_err(local_error); |
1ce52846 | 264 | } |
0c544d73 | 265 | goto out_socket; |
a517e88b PB |
266 | } |
267 | ||
a6ac2313 | 268 | fd = open(device, O_RDWR); |
fc19f8a0 | 269 | if (fd < 0) { |
a6ac2313 | 270 | /* Linux-only, we can use %m in printf. */ |
b9884681 | 271 | error_report("Failed to open %s: %m", device); |
0c544d73 | 272 | goto out_socket; |
a6ac2313 PB |
273 | } |
274 | ||
1c778ef7 | 275 | ret = nbd_init(fd, sioc, nbdflags, size); |
fc19f8a0 | 276 | if (ret < 0) { |
0c544d73 | 277 | goto out_fd; |
a517e88b PB |
278 | } |
279 | ||
280 | /* update partition table */ | |
a6ac2313 | 281 | pthread_create(&show_parts_thread, NULL, show_parts, device); |
a517e88b | 282 | |
c1f8fdc3 PB |
283 | if (verbose) { |
284 | fprintf(stderr, "NBD device %s is now connected to %s\n", | |
285 | device, srcpath); | |
286 | } else { | |
287 | /* Close stderr so that the qemu-nbd process exits. */ | |
288 | dup2(STDOUT_FILENO, STDERR_FILENO); | |
289 | } | |
a517e88b PB |
290 | |
291 | ret = nbd_client(fd); | |
292 | if (ret) { | |
0c544d73 | 293 | goto out_fd; |
cd831bd7 | 294 | } |
a517e88b | 295 | close(fd); |
d0d6ff58 | 296 | object_unref(OBJECT(sioc)); |
a517e88b PB |
297 | kill(getpid(), SIGTERM); |
298 | return (void *) EXIT_SUCCESS; | |
299 | ||
0c544d73 PB |
300 | out_fd: |
301 | close(fd); | |
302 | out_socket: | |
d0d6ff58 | 303 | object_unref(OBJECT(sioc)); |
a517e88b PB |
304 | out: |
305 | kill(getpid(), SIGTERM); | |
306 | return (void *) EXIT_FAILURE; | |
cd831bd7 TS |
307 | } |
308 | ||
e4afbf4f | 309 | static int nbd_can_accept(void) |
a61c6782 PB |
310 | { |
311 | return nb_fds < shared; | |
312 | } | |
313 | ||
7860a380 PB |
314 | static void nbd_export_closed(NBDExport *exp) |
315 | { | |
316 | assert(state == TERMINATING); | |
317 | state = TERMINATED; | |
318 | } | |
319 | ||
d0d6ff58 | 320 | static void nbd_update_server_watch(void); |
e4afbf4f | 321 | |
1743b515 | 322 | static void nbd_client_closed(NBDClient *client) |
a61c6782 | 323 | { |
1743b515 | 324 | nb_fds--; |
7860a380 PB |
325 | if (nb_fds == 0 && !persistent && state == RUNNING) { |
326 | state = TERMINATE; | |
327 | } | |
d0d6ff58 | 328 | nbd_update_server_watch(); |
7860a380 | 329 | nbd_client_put(client); |
a61c6782 PB |
330 | } |
331 | ||
d0d6ff58 | 332 | static gboolean nbd_accept(QIOChannel *ioc, GIOCondition cond, gpointer opaque) |
a61c6782 | 333 | { |
d0d6ff58 | 334 | QIOChannelSocket *cioc; |
a61c6782 | 335 | |
d0d6ff58 DB |
336 | cioc = qio_channel_socket_accept(QIO_CHANNEL_SOCKET(ioc), |
337 | NULL); | |
338 | if (!cioc) { | |
339 | return TRUE; | |
0c544d73 PB |
340 | } |
341 | ||
7860a380 | 342 | if (state >= TERMINATE) { |
d0d6ff58 DB |
343 | object_unref(OBJECT(cioc)); |
344 | return TRUE; | |
7860a380 PB |
345 | } |
346 | ||
ee7d7aab | 347 | nb_fds++; |
d0d6ff58 | 348 | nbd_update_server_watch(); |
f95910fe | 349 | nbd_client_new(newproto ? NULL : exp, cioc, |
145614a1 | 350 | tlscreds, NULL, nbd_client_closed); |
d0d6ff58 DB |
351 | object_unref(OBJECT(cioc)); |
352 | ||
353 | return TRUE; | |
a61c6782 PB |
354 | } |
355 | ||
d0d6ff58 | 356 | static void nbd_update_server_watch(void) |
e4afbf4f FZ |
357 | { |
358 | if (nbd_can_accept()) { | |
d0d6ff58 DB |
359 | if (server_watch == -1) { |
360 | server_watch = qio_channel_add_watch(QIO_CHANNEL(server_ioc), | |
361 | G_IO_IN, | |
362 | nbd_accept, | |
363 | NULL, NULL); | |
364 | } | |
e4afbf4f | 365 | } else { |
d0d6ff58 DB |
366 | if (server_watch != -1) { |
367 | g_source_remove(server_watch); | |
368 | server_watch = -1; | |
369 | } | |
e4afbf4f FZ |
370 | } |
371 | } | |
372 | ||
48bec07e DB |
373 | |
374 | static SocketAddress *nbd_build_socket_address(const char *sockpath, | |
375 | const char *bindto, | |
376 | const char *port) | |
377 | { | |
378 | SocketAddress *saddr; | |
379 | ||
380 | saddr = g_new0(SocketAddress, 1); | |
381 | if (sockpath) { | |
2d32adda | 382 | saddr->type = SOCKET_ADDRESS_KIND_UNIX; |
32bafa8f EB |
383 | saddr->u.q_unix.data = g_new0(UnixSocketAddress, 1); |
384 | saddr->u.q_unix.data->path = g_strdup(sockpath); | |
48bec07e | 385 | } else { |
0399293e | 386 | InetSocketAddress *inet; |
2d32adda | 387 | saddr->type = SOCKET_ADDRESS_KIND_INET; |
32bafa8f | 388 | inet = saddr->u.inet.data = g_new0(InetSocketAddress, 1); |
0399293e | 389 | inet->host = g_strdup(bindto); |
48bec07e | 390 | if (port) { |
0399293e | 391 | inet->port = g_strdup(port); |
48bec07e | 392 | } else { |
0399293e | 393 | inet->port = g_strdup_printf("%d", NBD_DEFAULT_PORT); |
48bec07e DB |
394 | } |
395 | } | |
396 | ||
397 | return saddr; | |
398 | } | |
399 | ||
400 | ||
77c9aaef DB |
401 | static QemuOptsList file_opts = { |
402 | .name = "file", | |
403 | .implied_opt_name = "file", | |
404 | .head = QTAILQ_HEAD_INITIALIZER(file_opts.head), | |
405 | .desc = { | |
406 | /* no elements => accept any params */ | |
407 | { /* end of list */ } | |
408 | }, | |
409 | }; | |
410 | ||
0ab3b337 DB |
411 | static QemuOptsList qemu_object_opts = { |
412 | .name = "object", | |
413 | .implied_opt_name = "qom-type", | |
414 | .head = QTAILQ_HEAD_INITIALIZER(qemu_object_opts.head), | |
415 | .desc = { | |
416 | { } | |
417 | }, | |
418 | }; | |
419 | ||
420 | ||
145614a1 DB |
421 | |
422 | static QCryptoTLSCreds *nbd_get_tls_creds(const char *id, Error **errp) | |
423 | { | |
424 | Object *obj; | |
425 | QCryptoTLSCreds *creds; | |
426 | ||
427 | obj = object_resolve_path_component( | |
428 | object_get_objects_root(), id); | |
429 | if (!obj) { | |
430 | error_setg(errp, "No TLS credentials with id '%s'", | |
431 | id); | |
432 | return NULL; | |
433 | } | |
434 | creds = (QCryptoTLSCreds *) | |
435 | object_dynamic_cast(obj, TYPE_QCRYPTO_TLS_CREDS); | |
436 | if (!creds) { | |
437 | error_setg(errp, "Object with id '%s' is not TLS credentials", | |
438 | id); | |
439 | return NULL; | |
440 | } | |
441 | ||
442 | if (creds->endpoint != QCRYPTO_TLS_CREDS_ENDPOINT_SERVER) { | |
443 | error_setg(errp, | |
444 | "Expecting TLS credentials with a server endpoint"); | |
445 | return NULL; | |
446 | } | |
447 | object_ref(obj); | |
448 | return creds; | |
449 | } | |
450 | ||
451 | ||
7a5ca864 FB |
452 | int main(int argc, char **argv) |
453 | { | |
26f54e9a | 454 | BlockBackend *blk; |
7a5ca864 FB |
455 | BlockDriverState *bs; |
456 | off_t dev_offset = 0; | |
b90fb4b8 | 457 | uint32_t nbdflags = 0; |
cd831bd7 | 458 | bool disconnect = false; |
7a5ca864 | 459 | const char *bindto = "0.0.0.0"; |
48bec07e DB |
460 | const char *port = NULL; |
461 | char *sockpath = NULL; | |
a6ac2313 | 462 | char *device = NULL; |
7a5ca864 | 463 | off_t fd_size; |
8c116b0e WX |
464 | QemuOpts *sn_opts = NULL; |
465 | const char *sn_id_or_name = NULL; | |
3d4b2f9c | 466 | const char *sopt = "hVb:o:p:rsnP:c:dvk:e:f:tl:x:"; |
7a5ca864 | 467 | struct option lopt[] = { |
aa6e546c DB |
468 | { "help", no_argument, NULL, 'h' }, |
469 | { "version", no_argument, NULL, 'V' }, | |
470 | { "bind", required_argument, NULL, 'b' }, | |
471 | { "port", required_argument, NULL, 'p' }, | |
472 | { "socket", required_argument, NULL, 'k' }, | |
473 | { "offset", required_argument, NULL, 'o' }, | |
474 | { "read-only", no_argument, NULL, 'r' }, | |
475 | { "partition", required_argument, NULL, 'P' }, | |
476 | { "connect", required_argument, NULL, 'c' }, | |
477 | { "disconnect", no_argument, NULL, 'd' }, | |
478 | { "snapshot", no_argument, NULL, 's' }, | |
479 | { "load-snapshot", required_argument, NULL, 'l' }, | |
480 | { "nocache", no_argument, NULL, 'n' }, | |
481 | { "cache", required_argument, NULL, QEMU_NBD_OPT_CACHE }, | |
482 | { "aio", required_argument, NULL, QEMU_NBD_OPT_AIO }, | |
483 | { "discard", required_argument, NULL, QEMU_NBD_OPT_DISCARD }, | |
484 | { "detect-zeroes", required_argument, NULL, | |
485 | QEMU_NBD_OPT_DETECT_ZEROES }, | |
486 | { "shared", required_argument, NULL, 'e' }, | |
487 | { "format", required_argument, NULL, 'f' }, | |
488 | { "persistent", no_argument, NULL, 't' }, | |
489 | { "verbose", no_argument, NULL, 'v' }, | |
490 | { "object", required_argument, NULL, QEMU_NBD_OPT_OBJECT }, | |
491 | { "export-name", required_argument, NULL, 'x' }, | |
492 | { "tls-creds", required_argument, NULL, QEMU_NBD_OPT_TLSCREDS }, | |
493 | { "image-opts", no_argument, NULL, QEMU_NBD_OPT_IMAGE_OPTS }, | |
660f11be | 494 | { NULL, 0, NULL, 0 } |
7a5ca864 FB |
495 | }; |
496 | int ch; | |
497 | int opt_ind = 0; | |
7a5ca864 | 498 | char *end; |
f5edb014 | 499 | int flags = BDRV_O_RDWR; |
7a5ca864 | 500 | int partition = -1; |
4fbec260 | 501 | int ret = 0; |
39a5235c | 502 | bool seen_cache = false; |
ded9d2d5 | 503 | bool seen_discard = false; |
39a5235c | 504 | bool seen_aio = false; |
a517e88b | 505 | pthread_t client_thread; |
e6b63677 | 506 | const char *fmt = NULL; |
34b5d2c6 | 507 | Error *local_err = NULL; |
b3838a40 | 508 | BlockdevDetectZeroesOptions detect_zeroes = BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF; |
4fbec260 | 509 | QDict *options = NULL; |
3d4b2f9c | 510 | const char *export_name = NULL; |
145614a1 | 511 | const char *tlscredsid = NULL; |
77c9aaef | 512 | bool imageOpts = false; |
6effd5bf | 513 | bool writethrough = true; |
7a5ca864 | 514 | |
a517e88b PB |
515 | /* The client thread uses SIGTERM to interrupt the server. A signal |
516 | * handler ensures that "qemu-nbd -v -c" exits with a nice status code. | |
517 | */ | |
bb345110 | 518 | struct sigaction sa_sigterm; |
bb345110 PB |
519 | memset(&sa_sigterm, 0, sizeof(sa_sigterm)); |
520 | sa_sigterm.sa_handler = termsig_handler; | |
521 | sigaction(SIGTERM, &sa_sigterm, NULL); | |
0ab3b337 DB |
522 | module_call_init(MODULE_INIT_QOM); |
523 | qemu_add_opts(&qemu_object_opts); | |
10f5bff6 | 524 | qemu_init_exec_dir(argv[0]); |
bb345110 | 525 | |
7a5ca864 FB |
526 | while ((ch = getopt_long(argc, argv, sopt, lopt, &opt_ind)) != -1) { |
527 | switch (ch) { | |
528 | case 's': | |
2f726488 TS |
529 | flags |= BDRV_O_SNAPSHOT; |
530 | break; | |
531 | case 'n': | |
39a5235c PB |
532 | optarg = (char *) "none"; |
533 | /* fallthrough */ | |
534 | case QEMU_NBD_OPT_CACHE: | |
535 | if (seen_cache) { | |
85b01e09 MA |
536 | error_report("-n and --cache can only be specified once"); |
537 | exit(EXIT_FAILURE); | |
39a5235c PB |
538 | } |
539 | seen_cache = true; | |
6effd5bf | 540 | if (bdrv_parse_cache_mode(optarg, &flags, &writethrough) == -1) { |
85b01e09 MA |
541 | error_report("Invalid cache mode `%s'", optarg); |
542 | exit(EXIT_FAILURE); | |
39a5235c | 543 | } |
7a5ca864 | 544 | break; |
39a5235c PB |
545 | case QEMU_NBD_OPT_AIO: |
546 | if (seen_aio) { | |
85b01e09 MA |
547 | error_report("--aio can only be specified once"); |
548 | exit(EXIT_FAILURE); | |
39a5235c PB |
549 | } |
550 | seen_aio = true; | |
551 | if (!strcmp(optarg, "native")) { | |
552 | flags |= BDRV_O_NATIVE_AIO; | |
553 | } else if (!strcmp(optarg, "threads")) { | |
554 | /* this is the default */ | |
555 | } else { | |
85b01e09 MA |
556 | error_report("invalid aio mode `%s'", optarg); |
557 | exit(EXIT_FAILURE); | |
39a5235c PB |
558 | } |
559 | break; | |
ded9d2d5 PB |
560 | case QEMU_NBD_OPT_DISCARD: |
561 | if (seen_discard) { | |
85b01e09 MA |
562 | error_report("--discard can only be specified once"); |
563 | exit(EXIT_FAILURE); | |
ded9d2d5 PB |
564 | } |
565 | seen_discard = true; | |
566 | if (bdrv_parse_discard_flags(optarg, &flags) == -1) { | |
85b01e09 MA |
567 | error_report("Invalid discard mode `%s'", optarg); |
568 | exit(EXIT_FAILURE); | |
ded9d2d5 PB |
569 | } |
570 | break; | |
b3838a40 PL |
571 | case QEMU_NBD_OPT_DETECT_ZEROES: |
572 | detect_zeroes = | |
573 | qapi_enum_parse(BlockdevDetectZeroesOptions_lookup, | |
574 | optarg, | |
7fb1cf16 | 575 | BLOCKDEV_DETECT_ZEROES_OPTIONS__MAX, |
b3838a40 PL |
576 | BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF, |
577 | &local_err); | |
578 | if (local_err) { | |
c29b77f9 MA |
579 | error_reportf_err(local_err, |
580 | "Failed to parse detect_zeroes mode: "); | |
85b01e09 | 581 | exit(EXIT_FAILURE); |
b3838a40 PL |
582 | } |
583 | if (detect_zeroes == BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP && | |
584 | !(flags & BDRV_O_UNMAP)) { | |
85b01e09 MA |
585 | error_report("setting detect-zeroes to unmap is not allowed " |
586 | "without setting discard operation to unmap"); | |
587 | exit(EXIT_FAILURE); | |
b3838a40 PL |
588 | } |
589 | break; | |
7a5ca864 FB |
590 | case 'b': |
591 | bindto = optarg; | |
592 | break; | |
593 | case 'p': | |
48bec07e | 594 | port = optarg; |
7a5ca864 FB |
595 | break; |
596 | case 'o': | |
597 | dev_offset = strtoll (optarg, &end, 0); | |
598 | if (*end) { | |
85b01e09 MA |
599 | error_report("Invalid offset `%s'", optarg); |
600 | exit(EXIT_FAILURE); | |
7a5ca864 FB |
601 | } |
602 | if (dev_offset < 0) { | |
85b01e09 MA |
603 | error_report("Offset must be positive `%s'", optarg); |
604 | exit(EXIT_FAILURE); | |
7a5ca864 FB |
605 | } |
606 | break; | |
8c116b0e WX |
607 | case 'l': |
608 | if (strstart(optarg, SNAPSHOT_OPT_BASE, NULL)) { | |
70b94331 MA |
609 | sn_opts = qemu_opts_parse_noisily(&internal_snapshot_opts, |
610 | optarg, false); | |
8c116b0e | 611 | if (!sn_opts) { |
85b01e09 MA |
612 | error_report("Failed in parsing snapshot param `%s'", |
613 | optarg); | |
614 | exit(EXIT_FAILURE); | |
8c116b0e WX |
615 | } |
616 | } else { | |
617 | sn_id_or_name = optarg; | |
618 | } | |
619 | /* fall through */ | |
7a5ca864 | 620 | case 'r': |
b90fb4b8 | 621 | nbdflags |= NBD_FLAG_READ_ONLY; |
07108b29 | 622 | flags &= ~BDRV_O_RDWR; |
7a5ca864 FB |
623 | break; |
624 | case 'P': | |
625 | partition = strtol(optarg, &end, 0); | |
713cc671 | 626 | if (*end) { |
85b01e09 MA |
627 | error_report("Invalid partition `%s'", optarg); |
628 | exit(EXIT_FAILURE); | |
713cc671 PL |
629 | } |
630 | if (partition < 1 || partition > 8) { | |
85b01e09 MA |
631 | error_report("Invalid partition %d", partition); |
632 | exit(EXIT_FAILURE); | |
713cc671 | 633 | } |
7a5ca864 | 634 | break; |
cd831bd7 | 635 | case 'k': |
b32f6c28 | 636 | sockpath = optarg; |
713cc671 | 637 | if (sockpath[0] != '/') { |
9af9e0fe | 638 | error_report("socket path must be absolute"); |
85b01e09 | 639 | exit(EXIT_FAILURE); |
713cc671 | 640 | } |
cd831bd7 TS |
641 | break; |
642 | case 'd': | |
643 | disconnect = true; | |
644 | break; | |
645 | case 'c': | |
646 | device = optarg; | |
647 | break; | |
3b05a8e9 TS |
648 | case 'e': |
649 | shared = strtol(optarg, &end, 0); | |
650 | if (*end) { | |
85b01e09 MA |
651 | error_report("Invalid shared device number '%s'", optarg); |
652 | exit(EXIT_FAILURE); | |
3b05a8e9 TS |
653 | } |
654 | if (shared < 1) { | |
9af9e0fe | 655 | error_report("Shared device number must be greater than 0"); |
85b01e09 | 656 | exit(EXIT_FAILURE); |
3b05a8e9 TS |
657 | } |
658 | break; | |
e6b63677 DB |
659 | case 'f': |
660 | fmt = optarg; | |
661 | break; | |
713cc671 PL |
662 | case 't': |
663 | persistent = 1; | |
664 | break; | |
3d4b2f9c DB |
665 | case 'x': |
666 | export_name = optarg; | |
667 | break; | |
7a5ca864 FB |
668 | case 'v': |
669 | verbose = 1; | |
670 | break; | |
671 | case 'V': | |
672 | version(argv[0]); | |
673 | exit(0); | |
674 | break; | |
675 | case 'h': | |
676 | usage(argv[0]); | |
677 | exit(0); | |
678 | break; | |
679 | case '?': | |
85b01e09 MA |
680 | error_report("Try `%s --help' for more information.", argv[0]); |
681 | exit(EXIT_FAILURE); | |
0ab3b337 DB |
682 | case QEMU_NBD_OPT_OBJECT: { |
683 | QemuOpts *opts; | |
684 | opts = qemu_opts_parse_noisily(&qemu_object_opts, | |
685 | optarg, true); | |
686 | if (!opts) { | |
687 | exit(EXIT_FAILURE); | |
688 | } | |
689 | } break; | |
145614a1 DB |
690 | case QEMU_NBD_OPT_TLSCREDS: |
691 | tlscredsid = optarg; | |
692 | break; | |
77c9aaef DB |
693 | case QEMU_NBD_OPT_IMAGE_OPTS: |
694 | imageOpts = true; | |
695 | break; | |
7a5ca864 FB |
696 | } |
697 | } | |
698 | ||
699 | if ((argc - optind) != 1) { | |
433672b0 MA |
700 | error_report("Invalid number of arguments"); |
701 | error_printf("Try `%s --help' for more information.\n", argv[0]); | |
85b01e09 | 702 | exit(EXIT_FAILURE); |
7a5ca864 FB |
703 | } |
704 | ||
0ab3b337 DB |
705 | if (qemu_opts_foreach(&qemu_object_opts, |
706 | user_creatable_add_opts_foreach, | |
707 | NULL, &local_err)) { | |
708 | error_report_err(local_err); | |
709 | exit(EXIT_FAILURE); | |
710 | } | |
711 | ||
145614a1 DB |
712 | if (tlscredsid) { |
713 | if (sockpath) { | |
714 | error_report("TLS is only supported with IPv4/IPv6"); | |
715 | exit(EXIT_FAILURE); | |
716 | } | |
717 | if (device) { | |
718 | error_report("TLS is not supported with a host device"); | |
719 | exit(EXIT_FAILURE); | |
720 | } | |
721 | if (!export_name) { | |
722 | /* Set the default NBD protocol export name, since | |
723 | * we *must* use new style protocol for TLS */ | |
724 | export_name = ""; | |
725 | } | |
726 | tlscreds = nbd_get_tls_creds(tlscredsid, &local_err); | |
727 | if (local_err) { | |
728 | error_report("Failed to get TLS creds %s", | |
729 | error_get_pretty(local_err)); | |
730 | exit(EXIT_FAILURE); | |
731 | } | |
732 | } | |
733 | ||
cd831bd7 | 734 | if (disconnect) { |
d0d6ff58 DB |
735 | int nbdfd = open(argv[optind], O_RDWR); |
736 | if (nbdfd < 0) { | |
85b01e09 MA |
737 | error_report("Cannot open %s: %s", argv[optind], |
738 | strerror(errno)); | |
739 | exit(EXIT_FAILURE); | |
fc19f8a0 | 740 | } |
d0d6ff58 | 741 | nbd_disconnect(nbdfd); |
cd831bd7 | 742 | |
d0d6ff58 | 743 | close(nbdfd); |
cd831bd7 TS |
744 | |
745 | printf("%s disconnected\n", argv[optind]); | |
746 | ||
713cc671 | 747 | return 0; |
cd831bd7 TS |
748 | } |
749 | ||
c1f8fdc3 PB |
750 | if (device && !verbose) { |
751 | int stderr_fd[2]; | |
752 | pid_t pid; | |
753 | int ret; | |
754 | ||
fc19f8a0 | 755 | if (qemu_pipe(stderr_fd) < 0) { |
85b01e09 MA |
756 | error_report("Error setting up communication pipe: %s", |
757 | strerror(errno)); | |
758 | exit(EXIT_FAILURE); | |
c1f8fdc3 PB |
759 | } |
760 | ||
761 | /* Now daemonize, but keep a communication channel open to | |
762 | * print errors and exit with the proper status code. | |
763 | */ | |
764 | pid = fork(); | |
70d4739e | 765 | if (pid < 0) { |
85b01e09 MA |
766 | error_report("Failed to fork: %s", strerror(errno)); |
767 | exit(EXIT_FAILURE); | |
70d4739e | 768 | } else if (pid == 0) { |
c1f8fdc3 | 769 | close(stderr_fd[0]); |
9faf31b6 | 770 | ret = qemu_daemon(1, 0); |
c1f8fdc3 PB |
771 | |
772 | /* Temporarily redirect stderr to the parent's pipe... */ | |
773 | dup2(stderr_fd[1], STDERR_FILENO); | |
fc19f8a0 | 774 | if (ret < 0) { |
85b01e09 MA |
775 | error_report("Failed to daemonize: %s", strerror(errno)); |
776 | exit(EXIT_FAILURE); | |
c1f8fdc3 PB |
777 | } |
778 | ||
779 | /* ... close the descriptor we inherited and go on. */ | |
780 | close(stderr_fd[1]); | |
781 | } else { | |
782 | bool errors = false; | |
783 | char *buf; | |
784 | ||
785 | /* In the parent. Print error messages from the child until | |
786 | * it closes the pipe. | |
787 | */ | |
788 | close(stderr_fd[1]); | |
789 | buf = g_malloc(1024); | |
790 | while ((ret = read(stderr_fd[0], buf, 1024)) > 0) { | |
791 | errors = true; | |
792 | ret = qemu_write_full(STDERR_FILENO, buf, ret); | |
fc19f8a0 | 793 | if (ret < 0) { |
c1f8fdc3 PB |
794 | exit(EXIT_FAILURE); |
795 | } | |
796 | } | |
fc19f8a0 | 797 | if (ret < 0) { |
85b01e09 MA |
798 | error_report("Cannot read from daemon: %s", |
799 | strerror(errno)); | |
800 | exit(EXIT_FAILURE); | |
c1f8fdc3 PB |
801 | } |
802 | ||
803 | /* Usually the daemon should not print any message. | |
804 | * Exit with zero status in that case. | |
805 | */ | |
806 | exit(errors); | |
807 | } | |
808 | } | |
809 | ||
a6ac2313 PB |
810 | if (device != NULL && sockpath == NULL) { |
811 | sockpath = g_malloc(128); | |
812 | snprintf(sockpath, 128, SOCKET_PATH, basename(device)); | |
cd831bd7 TS |
813 | } |
814 | ||
48bec07e DB |
815 | saddr = nbd_build_socket_address(sockpath, bindto, port); |
816 | ||
2f78e491 | 817 | if (qemu_init_main_loop(&local_err)) { |
565f65d2 | 818 | error_report_err(local_err); |
2f78e491 CN |
819 | exit(EXIT_FAILURE); |
820 | } | |
802ddc37 PB |
821 | bdrv_init(); |
822 | atexit(bdrv_close_all); | |
823 | ||
77c9aaef DB |
824 | srcpath = argv[optind]; |
825 | if (imageOpts) { | |
826 | QemuOpts *opts; | |
827 | if (fmt) { | |
828 | error_report("--image-opts and -f are mutually exclusive"); | |
829 | exit(EXIT_FAILURE); | |
830 | } | |
831 | opts = qemu_opts_parse_noisily(&file_opts, srcpath, true); | |
832 | if (!opts) { | |
833 | qemu_opts_reset(&file_opts); | |
834 | exit(EXIT_FAILURE); | |
835 | } | |
836 | options = qemu_opts_to_qdict(opts, NULL); | |
837 | qemu_opts_reset(&file_opts); | |
efaa7c4e | 838 | blk = blk_new_open(NULL, NULL, options, flags, &local_err); |
77c9aaef DB |
839 | } else { |
840 | if (fmt) { | |
841 | options = qdict_new(); | |
842 | qdict_put(options, "driver", qstring_from_str(fmt)); | |
843 | } | |
efaa7c4e | 844 | blk = blk_new_open(srcpath, NULL, options, flags, &local_err); |
e6b63677 DB |
845 | } |
846 | ||
4fbec260 | 847 | if (!blk) { |
c29b77f9 MA |
848 | error_reportf_err(local_err, "Failed to blk_new_open '%s': ", |
849 | argv[optind]); | |
85b01e09 | 850 | exit(EXIT_FAILURE); |
802ddc37 | 851 | } |
4fbec260 | 852 | bs = blk_bs(blk); |
802ddc37 | 853 | |
6effd5bf KW |
854 | blk_set_enable_write_cache(blk, !writethrough); |
855 | ||
8c116b0e WX |
856 | if (sn_opts) { |
857 | ret = bdrv_snapshot_load_tmp(bs, | |
858 | qemu_opt_get(sn_opts, SNAPSHOT_OPT_ID), | |
859 | qemu_opt_get(sn_opts, SNAPSHOT_OPT_NAME), | |
860 | &local_err); | |
861 | } else if (sn_id_or_name) { | |
862 | ret = bdrv_snapshot_load_tmp_by_id_or_name(bs, sn_id_or_name, | |
863 | &local_err); | |
864 | } | |
865 | if (ret < 0) { | |
c29b77f9 | 866 | error_reportf_err(local_err, "Failed to load snapshot: "); |
85b01e09 | 867 | exit(EXIT_FAILURE); |
8c116b0e WX |
868 | } |
869 | ||
b3838a40 | 870 | bs->detect_zeroes = detect_zeroes; |
4c58e80a | 871 | fd_size = blk_getlength(blk); |
98f44bbe | 872 | if (fd_size < 0) { |
85b01e09 MA |
873 | error_report("Failed to determine the image length: %s", |
874 | strerror(-fd_size)); | |
875 | exit(EXIT_FAILURE); | |
98f44bbe | 876 | } |
802ddc37 | 877 | |
185b4338 | 878 | if (partition != -1) { |
4c58e80a | 879 | ret = find_partition(blk, partition, &dev_offset, &fd_size); |
185b4338 | 880 | if (ret < 0) { |
85b01e09 | 881 | error_report("Could not find partition %d: %s", partition, |
a4699e55 | 882 | strerror(-ret)); |
85b01e09 | 883 | exit(EXIT_FAILURE); |
185b4338 | 884 | } |
802ddc37 PB |
885 | } |
886 | ||
98f44bbe HR |
887 | exp = nbd_export_new(blk, dev_offset, fd_size, nbdflags, nbd_export_closed, |
888 | &local_err); | |
889 | if (!exp) { | |
4fffeb5e | 890 | error_report_err(local_err); |
85b01e09 | 891 | exit(EXIT_FAILURE); |
98f44bbe | 892 | } |
3d4b2f9c DB |
893 | if (export_name) { |
894 | nbd_export_set_name(exp, export_name); | |
895 | newproto = true; | |
896 | } | |
3b05a8e9 | 897 | |
d0d6ff58 DB |
898 | server_ioc = qio_channel_socket_new(); |
899 | if (qio_channel_socket_listen_sync(server_ioc, saddr, &local_err) < 0) { | |
900 | object_unref(OBJECT(server_ioc)); | |
48bec07e | 901 | error_report_err(local_err); |
7a5ca864 | 902 | return 1; |
a61c6782 | 903 | } |
f1ef5555 PB |
904 | |
905 | if (device) { | |
906 | int ret; | |
907 | ||
a6ac2313 | 908 | ret = pthread_create(&client_thread, NULL, nbd_client_thread, device); |
f1ef5555 | 909 | if (ret != 0) { |
85b01e09 MA |
910 | error_report("Failed to create client thread: %s", strerror(ret)); |
911 | exit(EXIT_FAILURE); | |
f1ef5555 PB |
912 | } |
913 | } else { | |
914 | /* Shut up GCC warnings. */ | |
915 | memset(&client_thread, 0, sizeof(client_thread)); | |
916 | } | |
917 | ||
d0d6ff58 | 918 | nbd_update_server_watch(); |
7a5ca864 | 919 | |
9faf31b6 MT |
920 | /* now when the initialization is (almost) complete, chdir("/") |
921 | * to free any busy filesystems */ | |
922 | if (chdir("/") < 0) { | |
85b01e09 MA |
923 | error_report("Could not chdir to root directory: %s", |
924 | strerror(errno)); | |
925 | exit(EXIT_FAILURE); | |
9faf31b6 MT |
926 | } |
927 | ||
7860a380 | 928 | state = RUNNING; |
3b05a8e9 | 929 | do { |
a61c6782 | 930 | main_loop_wait(false); |
7860a380 PB |
931 | if (state == TERMINATE) { |
932 | state = TERMINATING; | |
933 | nbd_export_close(exp); | |
934 | nbd_export_put(exp); | |
935 | exp = NULL; | |
936 | } | |
937 | } while (state != TERMINATED); | |
7a5ca864 | 938 | |
26f54e9a | 939 | blk_unref(blk); |
b32f6c28 PB |
940 | if (sockpath) { |
941 | unlink(sockpath); | |
942 | } | |
7a5ca864 | 943 | |
fbf28a43 | 944 | qemu_opts_del(sn_opts); |
8c116b0e | 945 | |
a517e88b PB |
946 | if (device) { |
947 | void *ret; | |
948 | pthread_join(client_thread, &ret); | |
949 | exit(ret != NULL); | |
950 | } else { | |
951 | exit(EXIT_SUCCESS); | |
952 | } | |
7a5ca864 | 953 | } |