1 /* 2 * GlusterFS backend for QEMU 3 * 4 * Copyright (C) 2012 Bharata B Rao <bharata@linux.vnet.ibm.com> 5 * 6 * This work is licensed under the terms of the GNU GPL, version 2 or later. 7 * See the COPYING file in the top-level directory. 8 * 9 */ 10 11 #include "qemu/osdep.h" 12 #include <glusterfs/api/glfs.h> 13 #include "block/block_int.h" 14 #include "block/qdict.h" 15 #include "qapi/error.h" 16 #include "qapi/qmp/qdict.h" 17 #include "qapi/qmp/qerror.h" 18 #include "qemu/uri.h" 19 #include "qemu/error-report.h" 20 #include "qemu/option.h" 21 #include "qemu/cutils.h" 22 23 #define GLUSTER_OPT_FILENAME "filename" 24 #define GLUSTER_OPT_VOLUME "volume" 25 #define GLUSTER_OPT_PATH "path" 26 #define GLUSTER_OPT_TYPE "type" 27 #define GLUSTER_OPT_SERVER_PATTERN "server." 28 #define GLUSTER_OPT_HOST "host" 29 #define GLUSTER_OPT_PORT "port" 30 #define GLUSTER_OPT_TO "to" 31 #define GLUSTER_OPT_IPV4 "ipv4" 32 #define GLUSTER_OPT_IPV6 "ipv6" 33 #define GLUSTER_OPT_SOCKET "socket" 34 #define GLUSTER_OPT_DEBUG "debug" 35 #define GLUSTER_DEFAULT_PORT 24007 36 #define GLUSTER_DEBUG_DEFAULT 4 37 #define GLUSTER_DEBUG_MAX 9 38 #define GLUSTER_OPT_LOGFILE "logfile" 39 #define GLUSTER_LOGFILE_DEFAULT "-" /* handled in libgfapi as /dev/stderr */ 40 41 #define GERR_INDEX_HINT "hint: check in 'server' array index '%d'\n" 42 43 typedef struct GlusterAIOCB { 44 int64_t size; 45 int ret; 46 Coroutine *coroutine; 47 AioContext *aio_context; 48 } GlusterAIOCB; 49 50 typedef struct BDRVGlusterState { 51 struct glfs *glfs; 52 struct glfs_fd *fd; 53 char *logfile; 54 bool supports_seek_data; 55 int debug; 56 } BDRVGlusterState; 57 58 typedef struct BDRVGlusterReopenState { 59 struct glfs *glfs; 60 struct glfs_fd *fd; 61 } BDRVGlusterReopenState; 62 63 64 typedef struct GlfsPreopened { 65 char *volume; 66 glfs_t *fs; 67 int ref; 68 } GlfsPreopened; 69 70 typedef struct ListElement { 71 QLIST_ENTRY(ListElement) list; 72 GlfsPreopened saved; 73 } ListElement; 74 75 static QLIST_HEAD(glfs_list, ListElement) glfs_list; 76 77 static QemuOptsList qemu_gluster_create_opts = { 78 .name = "qemu-gluster-create-opts", 79 .head = QTAILQ_HEAD_INITIALIZER(qemu_gluster_create_opts.head), 80 .desc = { 81 { 82 .name = BLOCK_OPT_SIZE, 83 .type = QEMU_OPT_SIZE, 84 .help = "Virtual disk size" 85 }, 86 { 87 .name = BLOCK_OPT_PREALLOC, 88 .type = QEMU_OPT_STRING, 89 .help = "Preallocation mode (allowed values: off, full)" 90 }, 91 { 92 .name = GLUSTER_OPT_DEBUG, 93 .type = QEMU_OPT_NUMBER, 94 .help = "Gluster log level, valid range is 0-9", 95 }, 96 { 97 .name = GLUSTER_OPT_LOGFILE, 98 .type = QEMU_OPT_STRING, 99 .help = "Logfile path of libgfapi", 100 }, 101 { /* end of list */ } 102 } 103 }; 104 105 static QemuOptsList runtime_opts = { 106 .name = "gluster", 107 .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head), 108 .desc = { 109 { 110 .name = GLUSTER_OPT_FILENAME, 111 .type = QEMU_OPT_STRING, 112 .help = "URL to the gluster image", 113 }, 114 { 115 .name = GLUSTER_OPT_DEBUG, 116 .type = QEMU_OPT_NUMBER, 117 .help = "Gluster log level, valid range is 0-9", 118 }, 119 { 120 .name = GLUSTER_OPT_LOGFILE, 121 .type = QEMU_OPT_STRING, 122 .help = "Logfile path of libgfapi", 123 }, 124 { /* end of list */ } 125 }, 126 }; 127 128 static QemuOptsList runtime_json_opts = { 129 .name = "gluster_json", 130 .head = QTAILQ_HEAD_INITIALIZER(runtime_json_opts.head), 131 .desc = { 132 { 133 .name = GLUSTER_OPT_VOLUME, 134 .type = QEMU_OPT_STRING, 135 .help = "name of gluster volume where VM image resides", 136 }, 137 { 138 .name = GLUSTER_OPT_PATH, 139 .type = QEMU_OPT_STRING, 140 .help = "absolute path to image file in gluster volume", 141 }, 142 { 143 .name = GLUSTER_OPT_DEBUG, 144 .type = QEMU_OPT_NUMBER, 145 .help = "Gluster log level, valid range is 0-9", 146 }, 147 { /* end of list */ } 148 }, 149 }; 150 151 static QemuOptsList runtime_type_opts = { 152 .name = "gluster_type", 153 .head = QTAILQ_HEAD_INITIALIZER(runtime_type_opts.head), 154 .desc = { 155 { 156 .name = GLUSTER_OPT_TYPE, 157 .type = QEMU_OPT_STRING, 158 .help = "inet|unix", 159 }, 160 { /* end of list */ } 161 }, 162 }; 163 164 static QemuOptsList runtime_unix_opts = { 165 .name = "gluster_unix", 166 .head = QTAILQ_HEAD_INITIALIZER(runtime_unix_opts.head), 167 .desc = { 168 { 169 .name = GLUSTER_OPT_SOCKET, 170 .type = QEMU_OPT_STRING, 171 .help = "socket file path (legacy)", 172 }, 173 { 174 .name = GLUSTER_OPT_PATH, 175 .type = QEMU_OPT_STRING, 176 .help = "socket file path (QAPI)", 177 }, 178 { /* end of list */ } 179 }, 180 }; 181 182 static QemuOptsList runtime_inet_opts = { 183 .name = "gluster_inet", 184 .head = QTAILQ_HEAD_INITIALIZER(runtime_inet_opts.head), 185 .desc = { 186 { 187 .name = GLUSTER_OPT_TYPE, 188 .type = QEMU_OPT_STRING, 189 .help = "inet|unix", 190 }, 191 { 192 .name = GLUSTER_OPT_HOST, 193 .type = QEMU_OPT_STRING, 194 .help = "host address (hostname/ipv4/ipv6 addresses)", 195 }, 196 { 197 .name = GLUSTER_OPT_PORT, 198 .type = QEMU_OPT_STRING, 199 .help = "port number on which glusterd is listening (default 24007)", 200 }, 201 { 202 .name = "to", 203 .type = QEMU_OPT_NUMBER, 204 .help = "max port number, not supported by gluster", 205 }, 206 { 207 .name = "ipv4", 208 .type = QEMU_OPT_BOOL, 209 .help = "ipv4 bool value, not supported by gluster", 210 }, 211 { 212 .name = "ipv6", 213 .type = QEMU_OPT_BOOL, 214 .help = "ipv6 bool value, not supported by gluster", 215 }, 216 { /* end of list */ } 217 }, 218 }; 219 220 static void glfs_set_preopened(const char *volume, glfs_t *fs) 221 { 222 ListElement *entry = NULL; 223 224 entry = g_new(ListElement, 1); 225 226 entry->saved.volume = g_strdup(volume); 227 228 entry->saved.fs = fs; 229 entry->saved.ref = 1; 230 231 QLIST_INSERT_HEAD(&glfs_list, entry, list); 232 } 233 234 static glfs_t *glfs_find_preopened(const char *volume) 235 { 236 ListElement *entry = NULL; 237 238 QLIST_FOREACH(entry, &glfs_list, list) { 239 if (strcmp(entry->saved.volume, volume) == 0) { 240 entry->saved.ref++; 241 return entry->saved.fs; 242 } 243 } 244 245 return NULL; 246 } 247 248 static void glfs_clear_preopened(glfs_t *fs) 249 { 250 ListElement *entry = NULL; 251 ListElement *next; 252 253 if (fs == NULL) { 254 return; 255 } 256 257 QLIST_FOREACH_SAFE(entry, &glfs_list, list, next) { 258 if (entry->saved.fs == fs) { 259 if (--entry->saved.ref) { 260 return; 261 } 262 263 QLIST_REMOVE(entry, list); 264 265 glfs_fini(entry->saved.fs); 266 g_free(entry->saved.volume); 267 g_free(entry); 268 } 269 } 270 } 271 272 static int parse_volume_options(BlockdevOptionsGluster *gconf, char *path) 273 { 274 char *p, *q; 275 276 if (!path) { 277 return -EINVAL; 278 } 279 280 /* volume */ 281 p = q = path + strspn(path, "/"); 282 p += strcspn(p, "/"); 283 if (*p == '\0') { 284 return -EINVAL; 285 } 286 gconf->volume = g_strndup(q, p - q); 287 288 /* path */ 289 p += strspn(p, "/"); 290 if (*p == '\0') { 291 return -EINVAL; 292 } 293 gconf->path = g_strdup(p); 294 return 0; 295 } 296 297 /* 298 * file=gluster[+transport]://[host[:port]]/volume/path[?socket=...] 299 * 300 * 'gluster' is the protocol. 301 * 302 * 'transport' specifies the transport type used to connect to gluster 303 * management daemon (glusterd). Valid transport types are 304 * tcp or unix. If a transport type isn't specified, then tcp type is assumed. 305 * 306 * 'host' specifies the host where the volume file specification for 307 * the given volume resides. This can be either hostname or ipv4 address. 308 * If transport type is 'unix', then 'host' field should not be specified. 309 * The 'socket' field needs to be populated with the path to unix domain 310 * socket. 311 * 312 * 'port' is the port number on which glusterd is listening. This is optional 313 * and if not specified, QEMU will send 0 which will make gluster to use the 314 * default port. If the transport type is unix, then 'port' should not be 315 * specified. 316 * 317 * 'volume' is the name of the gluster volume which contains the VM image. 318 * 319 * 'path' is the path to the actual VM image that resides on gluster volume. 320 * 321 * Examples: 322 * 323 * file=gluster://1.2.3.4/testvol/a.img 324 * file=gluster+tcp://1.2.3.4/testvol/a.img 325 * file=gluster+tcp://1.2.3.4:24007/testvol/dir/a.img 326 * file=gluster+tcp://host.domain.com:24007/testvol/dir/a.img 327 * file=gluster+unix:///testvol/dir/a.img?socket=/tmp/glusterd.socket 328 */ 329 static int qemu_gluster_parse_uri(BlockdevOptionsGluster *gconf, 330 const char *filename) 331 { 332 SocketAddress *gsconf; 333 URI *uri; 334 QueryParams *qp = NULL; 335 bool is_unix = false; 336 int ret = 0; 337 338 uri = uri_parse(filename); 339 if (!uri) { 340 return -EINVAL; 341 } 342 343 gconf->server = g_new0(SocketAddressList, 1); 344 gconf->server->value = gsconf = g_new0(SocketAddress, 1); 345 346 /* transport */ 347 if (!uri->scheme || !strcmp(uri->scheme, "gluster")) { 348 gsconf->type = SOCKET_ADDRESS_TYPE_INET; 349 } else if (!strcmp(uri->scheme, "gluster+tcp")) { 350 gsconf->type = SOCKET_ADDRESS_TYPE_INET; 351 } else if (!strcmp(uri->scheme, "gluster+unix")) { 352 gsconf->type = SOCKET_ADDRESS_TYPE_UNIX; 353 is_unix = true; 354 } else if (!strcmp(uri->scheme, "gluster+rdma")) { 355 gsconf->type = SOCKET_ADDRESS_TYPE_INET; 356 warn_report("rdma feature is not supported, falling back to tcp"); 357 } else { 358 ret = -EINVAL; 359 goto out; 360 } 361 362 ret = parse_volume_options(gconf, uri->path); 363 if (ret < 0) { 364 goto out; 365 } 366 367 qp = query_params_parse(uri->query); 368 if (qp->n > 1 || (is_unix && !qp->n) || (!is_unix && qp->n)) { 369 ret = -EINVAL; 370 goto out; 371 } 372 373 if (is_unix) { 374 if (uri->server || uri->port) { 375 ret = -EINVAL; 376 goto out; 377 } 378 if (strcmp(qp->p[0].name, "socket")) { 379 ret = -EINVAL; 380 goto out; 381 } 382 gsconf->u.q_unix.path = g_strdup(qp->p[0].value); 383 } else { 384 gsconf->u.inet.host = g_strdup(uri->server ? uri->server : "localhost"); 385 if (uri->port) { 386 gsconf->u.inet.port = g_strdup_printf("%d", uri->port); 387 } else { 388 gsconf->u.inet.port = g_strdup_printf("%d", GLUSTER_DEFAULT_PORT); 389 } 390 } 391 392 out: 393 if (qp) { 394 query_params_free(qp); 395 } 396 uri_free(uri); 397 return ret; 398 } 399 400 static struct glfs *qemu_gluster_glfs_init(BlockdevOptionsGluster *gconf, 401 Error **errp) 402 { 403 struct glfs *glfs; 404 int ret; 405 int old_errno; 406 SocketAddressList *server; 407 unsigned long long port; 408 409 glfs = glfs_find_preopened(gconf->volume); 410 if (glfs) { 411 return glfs; 412 } 413 414 glfs = glfs_new(gconf->volume); 415 if (!glfs) { 416 goto out; 417 } 418 419 glfs_set_preopened(gconf->volume, glfs); 420 421 for (server = gconf->server; server; server = server->next) { 422 switch (server->value->type) { 423 case SOCKET_ADDRESS_TYPE_UNIX: 424 ret = glfs_set_volfile_server(glfs, "unix", 425 server->value->u.q_unix.path, 0); 426 break; 427 case SOCKET_ADDRESS_TYPE_INET: 428 if (parse_uint_full(server->value->u.inet.port, &port, 10) < 0 || 429 port > 65535) { 430 error_setg(errp, "'%s' is not a valid port number", 431 server->value->u.inet.port); 432 errno = EINVAL; 433 goto out; 434 } 435 ret = glfs_set_volfile_server(glfs, "tcp", 436 server->value->u.inet.host, 437 (int)port); 438 break; 439 case SOCKET_ADDRESS_TYPE_VSOCK: 440 case SOCKET_ADDRESS_TYPE_FD: 441 default: 442 abort(); 443 } 444 445 if (ret < 0) { 446 goto out; 447 } 448 } 449 450 ret = glfs_set_logging(glfs, gconf->logfile, gconf->debug); 451 if (ret < 0) { 452 goto out; 453 } 454 455 ret = glfs_init(glfs); 456 if (ret) { 457 error_setg(errp, "Gluster connection for volume %s, path %s failed" 458 " to connect", gconf->volume, gconf->path); 459 for (server = gconf->server; server; server = server->next) { 460 if (server->value->type == SOCKET_ADDRESS_TYPE_UNIX) { 461 error_append_hint(errp, "hint: failed on socket %s ", 462 server->value->u.q_unix.path); 463 } else { 464 error_append_hint(errp, "hint: failed on host %s and port %s ", 465 server->value->u.inet.host, 466 server->value->u.inet.port); 467 } 468 } 469 470 error_append_hint(errp, "Please refer to gluster logs for more info\n"); 471 472 /* glfs_init sometimes doesn't set errno although docs suggest that */ 473 if (errno == 0) { 474 errno = EINVAL; 475 } 476 477 goto out; 478 } 479 return glfs; 480 481 out: 482 if (glfs) { 483 old_errno = errno; 484 glfs_clear_preopened(glfs); 485 errno = old_errno; 486 } 487 return NULL; 488 } 489 490 /* 491 * Convert the json formatted command line into qapi. 492 */ 493 static int qemu_gluster_parse_json(BlockdevOptionsGluster *gconf, 494 QDict *options, Error **errp) 495 { 496 QemuOpts *opts; 497 SocketAddress *gsconf = NULL; 498 SocketAddressList *curr = NULL; 499 QDict *backing_options = NULL; 500 Error *local_err = NULL; 501 char *str = NULL; 502 const char *ptr; 503 int i, type, num_servers; 504 505 /* create opts info from runtime_json_opts list */ 506 opts = qemu_opts_create(&runtime_json_opts, NULL, 0, &error_abort); 507 qemu_opts_absorb_qdict(opts, options, &local_err); 508 if (local_err) { 509 goto out; 510 } 511 512 num_servers = qdict_array_entries(options, GLUSTER_OPT_SERVER_PATTERN); 513 if (num_servers < 1) { 514 error_setg(&local_err, QERR_MISSING_PARAMETER, "server"); 515 goto out; 516 } 517 518 ptr = qemu_opt_get(opts, GLUSTER_OPT_VOLUME); 519 if (!ptr) { 520 error_setg(&local_err, QERR_MISSING_PARAMETER, GLUSTER_OPT_VOLUME); 521 goto out; 522 } 523 gconf->volume = g_strdup(ptr); 524 525 ptr = qemu_opt_get(opts, GLUSTER_OPT_PATH); 526 if (!ptr) { 527 error_setg(&local_err, QERR_MISSING_PARAMETER, GLUSTER_OPT_PATH); 528 goto out; 529 } 530 gconf->path = g_strdup(ptr); 531 qemu_opts_del(opts); 532 533 for (i = 0; i < num_servers; i++) { 534 str = g_strdup_printf(GLUSTER_OPT_SERVER_PATTERN"%d.", i); 535 qdict_extract_subqdict(options, &backing_options, str); 536 537 /* create opts info from runtime_type_opts list */ 538 opts = qemu_opts_create(&runtime_type_opts, NULL, 0, &error_abort); 539 qemu_opts_absorb_qdict(opts, backing_options, &local_err); 540 if (local_err) { 541 goto out; 542 } 543 544 ptr = qemu_opt_get(opts, GLUSTER_OPT_TYPE); 545 if (!ptr) { 546 error_setg(&local_err, QERR_MISSING_PARAMETER, GLUSTER_OPT_TYPE); 547 error_append_hint(&local_err, GERR_INDEX_HINT, i); 548 goto out; 549 550 } 551 gsconf = g_new0(SocketAddress, 1); 552 if (!strcmp(ptr, "tcp")) { 553 ptr = "inet"; /* accept legacy "tcp" */ 554 } 555 type = qapi_enum_parse(&SocketAddressType_lookup, ptr, -1, NULL); 556 if (type != SOCKET_ADDRESS_TYPE_INET 557 && type != SOCKET_ADDRESS_TYPE_UNIX) { 558 error_setg(&local_err, 559 "Parameter '%s' may be 'inet' or 'unix'", 560 GLUSTER_OPT_TYPE); 561 error_append_hint(&local_err, GERR_INDEX_HINT, i); 562 goto out; 563 } 564 gsconf->type = type; 565 qemu_opts_del(opts); 566 567 if (gsconf->type == SOCKET_ADDRESS_TYPE_INET) { 568 /* create opts info from runtime_inet_opts list */ 569 opts = qemu_opts_create(&runtime_inet_opts, NULL, 0, &error_abort); 570 qemu_opts_absorb_qdict(opts, backing_options, &local_err); 571 if (local_err) { 572 goto out; 573 } 574 575 ptr = qemu_opt_get(opts, GLUSTER_OPT_HOST); 576 if (!ptr) { 577 error_setg(&local_err, QERR_MISSING_PARAMETER, 578 GLUSTER_OPT_HOST); 579 error_append_hint(&local_err, GERR_INDEX_HINT, i); 580 goto out; 581 } 582 gsconf->u.inet.host = g_strdup(ptr); 583 ptr = qemu_opt_get(opts, GLUSTER_OPT_PORT); 584 if (!ptr) { 585 error_setg(&local_err, QERR_MISSING_PARAMETER, 586 GLUSTER_OPT_PORT); 587 error_append_hint(&local_err, GERR_INDEX_HINT, i); 588 goto out; 589 } 590 gsconf->u.inet.port = g_strdup(ptr); 591 592 /* defend for unsupported fields in InetSocketAddress, 593 * i.e. @ipv4, @ipv6 and @to 594 */ 595 ptr = qemu_opt_get(opts, GLUSTER_OPT_TO); 596 if (ptr) { 597 gsconf->u.inet.has_to = true; 598 } 599 ptr = qemu_opt_get(opts, GLUSTER_OPT_IPV4); 600 if (ptr) { 601 gsconf->u.inet.has_ipv4 = true; 602 } 603 ptr = qemu_opt_get(opts, GLUSTER_OPT_IPV6); 604 if (ptr) { 605 gsconf->u.inet.has_ipv6 = true; 606 } 607 if (gsconf->u.inet.has_to) { 608 error_setg(&local_err, "Parameter 'to' not supported"); 609 goto out; 610 } 611 if (gsconf->u.inet.has_ipv4 || gsconf->u.inet.has_ipv6) { 612 error_setg(&local_err, "Parameters 'ipv4/ipv6' not supported"); 613 goto out; 614 } 615 qemu_opts_del(opts); 616 } else { 617 /* create opts info from runtime_unix_opts list */ 618 opts = qemu_opts_create(&runtime_unix_opts, NULL, 0, &error_abort); 619 qemu_opts_absorb_qdict(opts, backing_options, &local_err); 620 if (local_err) { 621 goto out; 622 } 623 624 ptr = qemu_opt_get(opts, GLUSTER_OPT_PATH); 625 if (!ptr) { 626 ptr = qemu_opt_get(opts, GLUSTER_OPT_SOCKET); 627 } else if (qemu_opt_get(opts, GLUSTER_OPT_SOCKET)) { 628 error_setg(&local_err, 629 "Conflicting parameters 'path' and 'socket'"); 630 error_append_hint(&local_err, GERR_INDEX_HINT, i); 631 goto out; 632 } 633 if (!ptr) { 634 error_setg(&local_err, QERR_MISSING_PARAMETER, 635 GLUSTER_OPT_PATH); 636 error_append_hint(&local_err, GERR_INDEX_HINT, i); 637 goto out; 638 } 639 gsconf->u.q_unix.path = g_strdup(ptr); 640 qemu_opts_del(opts); 641 } 642 643 if (gconf->server == NULL) { 644 gconf->server = g_new0(SocketAddressList, 1); 645 gconf->server->value = gsconf; 646 curr = gconf->server; 647 } else { 648 curr->next = g_new0(SocketAddressList, 1); 649 curr->next->value = gsconf; 650 curr = curr->next; 651 } 652 gsconf = NULL; 653 654 qobject_unref(backing_options); 655 backing_options = NULL; 656 g_free(str); 657 str = NULL; 658 } 659 660 return 0; 661 662 out: 663 error_propagate(errp, local_err); 664 qapi_free_SocketAddress(gsconf); 665 qemu_opts_del(opts); 666 g_free(str); 667 qobject_unref(backing_options); 668 errno = EINVAL; 669 return -errno; 670 } 671 672 /* Converts options given in @filename and the @options QDict into the QAPI 673 * object @gconf. */ 674 static int qemu_gluster_parse(BlockdevOptionsGluster *gconf, 675 const char *filename, 676 QDict *options, Error **errp) 677 { 678 int ret; 679 if (filename) { 680 ret = qemu_gluster_parse_uri(gconf, filename); 681 if (ret < 0) { 682 error_setg(errp, "invalid URI %s", filename); 683 error_append_hint(errp, "Usage: file=gluster[+transport]://" 684 "[host[:port]]volume/path[?socket=...]" 685 "[,file.debug=N]" 686 "[,file.logfile=/path/filename.log]\n"); 687 return ret; 688 } 689 } else { 690 ret = qemu_gluster_parse_json(gconf, options, errp); 691 if (ret < 0) { 692 error_append_hint(errp, "Usage: " 693 "-drive driver=qcow2,file.driver=gluster," 694 "file.volume=testvol,file.path=/path/a.qcow2" 695 "[,file.debug=9]" 696 "[,file.logfile=/path/filename.log]," 697 "file.server.0.type=inet," 698 "file.server.0.host=1.2.3.4," 699 "file.server.0.port=24007," 700 "file.server.1.transport=unix," 701 "file.server.1.path=/var/run/glusterd.socket ..." 702 "\n"); 703 return ret; 704 } 705 } 706 707 return 0; 708 } 709 710 static struct glfs *qemu_gluster_init(BlockdevOptionsGluster *gconf, 711 const char *filename, 712 QDict *options, Error **errp) 713 { 714 int ret; 715 716 ret = qemu_gluster_parse(gconf, filename, options, errp); 717 if (ret < 0) { 718 errno = -ret; 719 return NULL; 720 } 721 722 return qemu_gluster_glfs_init(gconf, errp); 723 } 724 725 /* 726 * AIO callback routine called from GlusterFS thread. 727 */ 728 static void gluster_finish_aiocb(struct glfs_fd *fd, ssize_t ret, void *arg) 729 { 730 GlusterAIOCB *acb = (GlusterAIOCB *)arg; 731 732 if (!ret || ret == acb->size) { 733 acb->ret = 0; /* Success */ 734 } else if (ret < 0) { 735 acb->ret = -errno; /* Read/Write failed */ 736 } else { 737 acb->ret = -EIO; /* Partial read/write - fail it */ 738 } 739 740 aio_co_schedule(acb->aio_context, acb->coroutine); 741 } 742 743 static void qemu_gluster_parse_flags(int bdrv_flags, int *open_flags) 744 { 745 assert(open_flags != NULL); 746 747 *open_flags |= O_BINARY; 748 749 if (bdrv_flags & BDRV_O_RDWR) { 750 *open_flags |= O_RDWR; 751 } else { 752 *open_flags |= O_RDONLY; 753 } 754 755 if ((bdrv_flags & BDRV_O_NOCACHE)) { 756 *open_flags |= O_DIRECT; 757 } 758 } 759 760 /* 761 * Do SEEK_DATA/HOLE to detect if it is functional. Older broken versions of 762 * gfapi incorrectly return the current offset when SEEK_DATA/HOLE is used. 763 * - Corrected versions return -1 and set errno to EINVAL. 764 * - Versions that support SEEK_DATA/HOLE correctly, will return -1 and set 765 * errno to ENXIO when SEEK_DATA is called with a position of EOF. 766 */ 767 static bool qemu_gluster_test_seek(struct glfs_fd *fd) 768 { 769 off_t ret = 0; 770 771 #if defined SEEK_HOLE && defined SEEK_DATA 772 off_t eof; 773 774 eof = glfs_lseek(fd, 0, SEEK_END); 775 if (eof < 0) { 776 /* this should never occur */ 777 return false; 778 } 779 780 /* this should always fail with ENXIO if SEEK_DATA is supported */ 781 ret = glfs_lseek(fd, eof, SEEK_DATA); 782 #endif 783 784 return (ret < 0) && (errno == ENXIO); 785 } 786 787 static int qemu_gluster_open(BlockDriverState *bs, QDict *options, 788 int bdrv_flags, Error **errp) 789 { 790 BDRVGlusterState *s = bs->opaque; 791 int open_flags = 0; 792 int ret = 0; 793 BlockdevOptionsGluster *gconf = NULL; 794 QemuOpts *opts; 795 Error *local_err = NULL; 796 const char *filename, *logfile; 797 798 opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort); 799 qemu_opts_absorb_qdict(opts, options, &local_err); 800 if (local_err) { 801 error_propagate(errp, local_err); 802 ret = -EINVAL; 803 goto out; 804 } 805 806 filename = qemu_opt_get(opts, GLUSTER_OPT_FILENAME); 807 808 s->debug = qemu_opt_get_number(opts, GLUSTER_OPT_DEBUG, 809 GLUSTER_DEBUG_DEFAULT); 810 if (s->debug < 0) { 811 s->debug = 0; 812 } else if (s->debug > GLUSTER_DEBUG_MAX) { 813 s->debug = GLUSTER_DEBUG_MAX; 814 } 815 816 gconf = g_new0(BlockdevOptionsGluster, 1); 817 gconf->debug = s->debug; 818 gconf->has_debug = true; 819 820 logfile = qemu_opt_get(opts, GLUSTER_OPT_LOGFILE); 821 s->logfile = g_strdup(logfile ? logfile : GLUSTER_LOGFILE_DEFAULT); 822 823 gconf->logfile = g_strdup(s->logfile); 824 gconf->has_logfile = true; 825 826 s->glfs = qemu_gluster_init(gconf, filename, options, errp); 827 if (!s->glfs) { 828 ret = -errno; 829 goto out; 830 } 831 832 #ifdef CONFIG_GLUSTERFS_XLATOR_OPT 833 /* Without this, if fsync fails for a recoverable reason (for instance, 834 * ENOSPC), gluster will dump its cache, preventing retries. This means 835 * almost certain data loss. Not all gluster versions support the 836 * 'resync-failed-syncs-after-fsync' key value, but there is no way to 837 * discover during runtime if it is supported (this api returns success for 838 * unknown key/value pairs) */ 839 ret = glfs_set_xlator_option(s->glfs, "*-write-behind", 840 "resync-failed-syncs-after-fsync", 841 "on"); 842 if (ret < 0) { 843 error_setg_errno(errp, errno, "Unable to set xlator key/value pair"); 844 ret = -errno; 845 goto out; 846 } 847 #endif 848 849 qemu_gluster_parse_flags(bdrv_flags, &open_flags); 850 851 s->fd = glfs_open(s->glfs, gconf->path, open_flags); 852 if (!s->fd) { 853 ret = -errno; 854 } 855 856 s->supports_seek_data = qemu_gluster_test_seek(s->fd); 857 858 out: 859 qemu_opts_del(opts); 860 qapi_free_BlockdevOptionsGluster(gconf); 861 if (!ret) { 862 return ret; 863 } 864 g_free(s->logfile); 865 if (s->fd) { 866 glfs_close(s->fd); 867 } 868 869 glfs_clear_preopened(s->glfs); 870 871 return ret; 872 } 873 874 static int qemu_gluster_reopen_prepare(BDRVReopenState *state, 875 BlockReopenQueue *queue, Error **errp) 876 { 877 int ret = 0; 878 BDRVGlusterState *s; 879 BDRVGlusterReopenState *reop_s; 880 BlockdevOptionsGluster *gconf; 881 int open_flags = 0; 882 883 assert(state != NULL); 884 assert(state->bs != NULL); 885 886 s = state->bs->opaque; 887 888 state->opaque = g_new0(BDRVGlusterReopenState, 1); 889 reop_s = state->opaque; 890 891 qemu_gluster_parse_flags(state->flags, &open_flags); 892 893 gconf = g_new0(BlockdevOptionsGluster, 1); 894 gconf->debug = s->debug; 895 gconf->has_debug = true; 896 gconf->logfile = g_strdup(s->logfile); 897 gconf->has_logfile = true; 898 reop_s->glfs = qemu_gluster_init(gconf, state->bs->filename, NULL, errp); 899 if (reop_s->glfs == NULL) { 900 ret = -errno; 901 goto exit; 902 } 903 904 #ifdef CONFIG_GLUSTERFS_XLATOR_OPT 905 ret = glfs_set_xlator_option(reop_s->glfs, "*-write-behind", 906 "resync-failed-syncs-after-fsync", "on"); 907 if (ret < 0) { 908 error_setg_errno(errp, errno, "Unable to set xlator key/value pair"); 909 ret = -errno; 910 goto exit; 911 } 912 #endif 913 914 reop_s->fd = glfs_open(reop_s->glfs, gconf->path, open_flags); 915 if (reop_s->fd == NULL) { 916 /* reops->glfs will be cleaned up in _abort */ 917 ret = -errno; 918 goto exit; 919 } 920 921 exit: 922 /* state->opaque will be freed in either the _abort or _commit */ 923 qapi_free_BlockdevOptionsGluster(gconf); 924 return ret; 925 } 926 927 static void qemu_gluster_reopen_commit(BDRVReopenState *state) 928 { 929 BDRVGlusterReopenState *reop_s = state->opaque; 930 BDRVGlusterState *s = state->bs->opaque; 931 932 933 /* close the old */ 934 if (s->fd) { 935 glfs_close(s->fd); 936 } 937 938 glfs_clear_preopened(s->glfs); 939 940 /* use the newly opened image / connection */ 941 s->fd = reop_s->fd; 942 s->glfs = reop_s->glfs; 943 944 g_free(state->opaque); 945 state->opaque = NULL; 946 947 return; 948 } 949 950 951 static void qemu_gluster_reopen_abort(BDRVReopenState *state) 952 { 953 BDRVGlusterReopenState *reop_s = state->opaque; 954 955 if (reop_s == NULL) { 956 return; 957 } 958 959 if (reop_s->fd) { 960 glfs_close(reop_s->fd); 961 } 962 963 glfs_clear_preopened(reop_s->glfs); 964 965 g_free(state->opaque); 966 state->opaque = NULL; 967 968 return; 969 } 970 971 #ifdef CONFIG_GLUSTERFS_ZEROFILL 972 static coroutine_fn int qemu_gluster_co_pwrite_zeroes(BlockDriverState *bs, 973 int64_t offset, 974 int size, 975 BdrvRequestFlags flags) 976 { 977 int ret; 978 GlusterAIOCB acb; 979 BDRVGlusterState *s = bs->opaque; 980 981 acb.size = size; 982 acb.ret = 0; 983 acb.coroutine = qemu_coroutine_self(); 984 acb.aio_context = bdrv_get_aio_context(bs); 985 986 ret = glfs_zerofill_async(s->fd, offset, size, gluster_finish_aiocb, &acb); 987 if (ret < 0) { 988 return -errno; 989 } 990 991 qemu_coroutine_yield(); 992 return acb.ret; 993 } 994 #endif 995 996 static int qemu_gluster_do_truncate(struct glfs_fd *fd, int64_t offset, 997 PreallocMode prealloc, Error **errp) 998 { 999 int64_t current_length; 1000 1001 current_length = glfs_lseek(fd, 0, SEEK_END); 1002 if (current_length < 0) { 1003 error_setg_errno(errp, errno, "Failed to determine current size"); 1004 return -errno; 1005 } 1006 1007 if (current_length > offset && prealloc != PREALLOC_MODE_OFF) { 1008 error_setg(errp, "Cannot use preallocation for shrinking files"); 1009 return -ENOTSUP; 1010 } 1011 1012 if (current_length == offset) { 1013 return 0; 1014 } 1015 1016 switch (prealloc) { 1017 #ifdef CONFIG_GLUSTERFS_FALLOCATE 1018 case PREALLOC_MODE_FALLOC: 1019 if (glfs_fallocate(fd, 0, current_length, offset - current_length)) { 1020 error_setg_errno(errp, errno, "Could not preallocate data"); 1021 return -errno; 1022 } 1023 break; 1024 #endif /* CONFIG_GLUSTERFS_FALLOCATE */ 1025 #ifdef CONFIG_GLUSTERFS_ZEROFILL 1026 case PREALLOC_MODE_FULL: 1027 if (glfs_ftruncate(fd, offset)) { 1028 error_setg_errno(errp, errno, "Could not resize file"); 1029 return -errno; 1030 } 1031 if (glfs_zerofill(fd, current_length, offset - current_length)) { 1032 error_setg_errno(errp, errno, "Could not zerofill the new area"); 1033 return -errno; 1034 } 1035 break; 1036 #endif /* CONFIG_GLUSTERFS_ZEROFILL */ 1037 case PREALLOC_MODE_OFF: 1038 if (glfs_ftruncate(fd, offset)) { 1039 error_setg_errno(errp, errno, "Could not resize file"); 1040 return -errno; 1041 } 1042 break; 1043 default: 1044 error_setg(errp, "Unsupported preallocation mode: %s", 1045 PreallocMode_str(prealloc)); 1046 return -EINVAL; 1047 } 1048 1049 return 0; 1050 } 1051 1052 static int qemu_gluster_co_create(BlockdevCreateOptions *options, 1053 Error **errp) 1054 { 1055 BlockdevCreateOptionsGluster *opts = &options->u.gluster; 1056 struct glfs *glfs; 1057 struct glfs_fd *fd = NULL; 1058 int ret = 0; 1059 1060 assert(options->driver == BLOCKDEV_DRIVER_GLUSTER); 1061 1062 glfs = qemu_gluster_glfs_init(opts->location, errp); 1063 if (!glfs) { 1064 ret = -errno; 1065 goto out; 1066 } 1067 1068 fd = glfs_creat(glfs, opts->location->path, 1069 O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, S_IRUSR | S_IWUSR); 1070 if (!fd) { 1071 ret = -errno; 1072 goto out; 1073 } 1074 1075 ret = qemu_gluster_do_truncate(fd, opts->size, opts->preallocation, errp); 1076 1077 out: 1078 if (fd) { 1079 if (glfs_close(fd) != 0 && ret == 0) { 1080 ret = -errno; 1081 } 1082 } 1083 glfs_clear_preopened(glfs); 1084 return ret; 1085 } 1086 1087 static int coroutine_fn qemu_gluster_co_create_opts(const char *filename, 1088 QemuOpts *opts, 1089 Error **errp) 1090 { 1091 BlockdevCreateOptions *options; 1092 BlockdevCreateOptionsGluster *gopts; 1093 BlockdevOptionsGluster *gconf; 1094 char *tmp = NULL; 1095 Error *local_err = NULL; 1096 int ret; 1097 1098 options = g_new0(BlockdevCreateOptions, 1); 1099 options->driver = BLOCKDEV_DRIVER_GLUSTER; 1100 gopts = &options->u.gluster; 1101 1102 gconf = g_new0(BlockdevOptionsGluster, 1); 1103 gopts->location = gconf; 1104 1105 gopts->size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0), 1106 BDRV_SECTOR_SIZE); 1107 1108 tmp = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC); 1109 gopts->preallocation = qapi_enum_parse(&PreallocMode_lookup, tmp, 1110 PREALLOC_MODE_OFF, &local_err); 1111 g_free(tmp); 1112 if (local_err) { 1113 error_propagate(errp, local_err); 1114 ret = -EINVAL; 1115 goto fail; 1116 } 1117 1118 gconf->debug = qemu_opt_get_number_del(opts, GLUSTER_OPT_DEBUG, 1119 GLUSTER_DEBUG_DEFAULT); 1120 if (gconf->debug < 0) { 1121 gconf->debug = 0; 1122 } else if (gconf->debug > GLUSTER_DEBUG_MAX) { 1123 gconf->debug = GLUSTER_DEBUG_MAX; 1124 } 1125 gconf->has_debug = true; 1126 1127 gconf->logfile = qemu_opt_get_del(opts, GLUSTER_OPT_LOGFILE); 1128 if (!gconf->logfile) { 1129 gconf->logfile = g_strdup(GLUSTER_LOGFILE_DEFAULT); 1130 } 1131 gconf->has_logfile = true; 1132 1133 ret = qemu_gluster_parse(gconf, filename, NULL, errp); 1134 if (ret < 0) { 1135 goto fail; 1136 } 1137 1138 ret = qemu_gluster_co_create(options, errp); 1139 if (ret < 0) { 1140 goto fail; 1141 } 1142 1143 ret = 0; 1144 fail: 1145 qapi_free_BlockdevCreateOptions(options); 1146 return ret; 1147 } 1148 1149 static coroutine_fn int qemu_gluster_co_rw(BlockDriverState *bs, 1150 int64_t sector_num, int nb_sectors, 1151 QEMUIOVector *qiov, int write) 1152 { 1153 int ret; 1154 GlusterAIOCB acb; 1155 BDRVGlusterState *s = bs->opaque; 1156 size_t size = nb_sectors * BDRV_SECTOR_SIZE; 1157 off_t offset = sector_num * BDRV_SECTOR_SIZE; 1158 1159 acb.size = size; 1160 acb.ret = 0; 1161 acb.coroutine = qemu_coroutine_self(); 1162 acb.aio_context = bdrv_get_aio_context(bs); 1163 1164 if (write) { 1165 ret = glfs_pwritev_async(s->fd, qiov->iov, qiov->niov, offset, 0, 1166 gluster_finish_aiocb, &acb); 1167 } else { 1168 ret = glfs_preadv_async(s->fd, qiov->iov, qiov->niov, offset, 0, 1169 gluster_finish_aiocb, &acb); 1170 } 1171 1172 if (ret < 0) { 1173 return -errno; 1174 } 1175 1176 qemu_coroutine_yield(); 1177 return acb.ret; 1178 } 1179 1180 static int qemu_gluster_truncate(BlockDriverState *bs, int64_t offset, 1181 PreallocMode prealloc, Error **errp) 1182 { 1183 BDRVGlusterState *s = bs->opaque; 1184 return qemu_gluster_do_truncate(s->fd, offset, prealloc, errp); 1185 } 1186 1187 static coroutine_fn int qemu_gluster_co_readv(BlockDriverState *bs, 1188 int64_t sector_num, 1189 int nb_sectors, 1190 QEMUIOVector *qiov) 1191 { 1192 return qemu_gluster_co_rw(bs, sector_num, nb_sectors, qiov, 0); 1193 } 1194 1195 static coroutine_fn int qemu_gluster_co_writev(BlockDriverState *bs, 1196 int64_t sector_num, 1197 int nb_sectors, 1198 QEMUIOVector *qiov, 1199 int flags) 1200 { 1201 assert(!flags); 1202 return qemu_gluster_co_rw(bs, sector_num, nb_sectors, qiov, 1); 1203 } 1204 1205 static void qemu_gluster_close(BlockDriverState *bs) 1206 { 1207 BDRVGlusterState *s = bs->opaque; 1208 1209 g_free(s->logfile); 1210 if (s->fd) { 1211 glfs_close(s->fd); 1212 s->fd = NULL; 1213 } 1214 glfs_clear_preopened(s->glfs); 1215 } 1216 1217 static coroutine_fn int qemu_gluster_co_flush_to_disk(BlockDriverState *bs) 1218 { 1219 int ret; 1220 GlusterAIOCB acb; 1221 BDRVGlusterState *s = bs->opaque; 1222 1223 acb.size = 0; 1224 acb.ret = 0; 1225 acb.coroutine = qemu_coroutine_self(); 1226 acb.aio_context = bdrv_get_aio_context(bs); 1227 1228 ret = glfs_fsync_async(s->fd, gluster_finish_aiocb, &acb); 1229 if (ret < 0) { 1230 ret = -errno; 1231 goto error; 1232 } 1233 1234 qemu_coroutine_yield(); 1235 if (acb.ret < 0) { 1236 ret = acb.ret; 1237 goto error; 1238 } 1239 1240 return acb.ret; 1241 1242 error: 1243 /* Some versions of Gluster (3.5.6 -> 3.5.8?) will not retain its cache 1244 * after a fsync failure, so we have no way of allowing the guest to safely 1245 * continue. Gluster versions prior to 3.5.6 don't retain the cache 1246 * either, but will invalidate the fd on error, so this is again our only 1247 * option. 1248 * 1249 * The 'resync-failed-syncs-after-fsync' xlator option for the 1250 * write-behind cache will cause later gluster versions to retain its 1251 * cache after error, so long as the fd remains open. However, we 1252 * currently have no way of knowing if this option is supported. 1253 * 1254 * TODO: Once gluster provides a way for us to determine if the option 1255 * is supported, bypass the closure and setting drv to NULL. */ 1256 qemu_gluster_close(bs); 1257 bs->drv = NULL; 1258 return ret; 1259 } 1260 1261 #ifdef CONFIG_GLUSTERFS_DISCARD 1262 static coroutine_fn int qemu_gluster_co_pdiscard(BlockDriverState *bs, 1263 int64_t offset, int size) 1264 { 1265 int ret; 1266 GlusterAIOCB acb; 1267 BDRVGlusterState *s = bs->opaque; 1268 1269 acb.size = 0; 1270 acb.ret = 0; 1271 acb.coroutine = qemu_coroutine_self(); 1272 acb.aio_context = bdrv_get_aio_context(bs); 1273 1274 ret = glfs_discard_async(s->fd, offset, size, gluster_finish_aiocb, &acb); 1275 if (ret < 0) { 1276 return -errno; 1277 } 1278 1279 qemu_coroutine_yield(); 1280 return acb.ret; 1281 } 1282 #endif 1283 1284 static int64_t qemu_gluster_getlength(BlockDriverState *bs) 1285 { 1286 BDRVGlusterState *s = bs->opaque; 1287 int64_t ret; 1288 1289 ret = glfs_lseek(s->fd, 0, SEEK_END); 1290 if (ret < 0) { 1291 return -errno; 1292 } else { 1293 return ret; 1294 } 1295 } 1296 1297 static int64_t qemu_gluster_allocated_file_size(BlockDriverState *bs) 1298 { 1299 BDRVGlusterState *s = bs->opaque; 1300 struct stat st; 1301 int ret; 1302 1303 ret = glfs_fstat(s->fd, &st); 1304 if (ret < 0) { 1305 return -errno; 1306 } else { 1307 return st.st_blocks * 512; 1308 } 1309 } 1310 1311 static int qemu_gluster_has_zero_init(BlockDriverState *bs) 1312 { 1313 /* GlusterFS volume could be backed by a block device */ 1314 return 0; 1315 } 1316 1317 /* 1318 * Find allocation range in @bs around offset @start. 1319 * May change underlying file descriptor's file offset. 1320 * If @start is not in a hole, store @start in @data, and the 1321 * beginning of the next hole in @hole, and return 0. 1322 * If @start is in a non-trailing hole, store @start in @hole and the 1323 * beginning of the next non-hole in @data, and return 0. 1324 * If @start is in a trailing hole or beyond EOF, return -ENXIO. 1325 * If we can't find out, return a negative errno other than -ENXIO. 1326 * 1327 * (Shamefully copied from file-posix.c, only miniscule adaptions.) 1328 */ 1329 static int find_allocation(BlockDriverState *bs, off_t start, 1330 off_t *data, off_t *hole) 1331 { 1332 BDRVGlusterState *s = bs->opaque; 1333 1334 if (!s->supports_seek_data) { 1335 goto exit; 1336 } 1337 1338 #if defined SEEK_HOLE && defined SEEK_DATA 1339 off_t offs; 1340 1341 /* 1342 * SEEK_DATA cases: 1343 * D1. offs == start: start is in data 1344 * D2. offs > start: start is in a hole, next data at offs 1345 * D3. offs < 0, errno = ENXIO: either start is in a trailing hole 1346 * or start is beyond EOF 1347 * If the latter happens, the file has been truncated behind 1348 * our back since we opened it. All bets are off then. 1349 * Treating like a trailing hole is simplest. 1350 * D4. offs < 0, errno != ENXIO: we learned nothing 1351 */ 1352 offs = glfs_lseek(s->fd, start, SEEK_DATA); 1353 if (offs < 0) { 1354 return -errno; /* D3 or D4 */ 1355 } 1356 1357 if (offs < start) { 1358 /* This is not a valid return by lseek(). We are safe to just return 1359 * -EIO in this case, and we'll treat it like D4. Unfortunately some 1360 * versions of gluster server will return offs < start, so an assert 1361 * here will unnecessarily abort QEMU. */ 1362 return -EIO; 1363 } 1364 1365 if (offs > start) { 1366 /* D2: in hole, next data at offs */ 1367 *hole = start; 1368 *data = offs; 1369 return 0; 1370 } 1371 1372 /* D1: in data, end not yet known */ 1373 1374 /* 1375 * SEEK_HOLE cases: 1376 * H1. offs == start: start is in a hole 1377 * If this happens here, a hole has been dug behind our back 1378 * since the previous lseek(). 1379 * H2. offs > start: either start is in data, next hole at offs, 1380 * or start is in trailing hole, EOF at offs 1381 * Linux treats trailing holes like any other hole: offs == 1382 * start. Solaris seeks to EOF instead: offs > start (blech). 1383 * If that happens here, a hole has been dug behind our back 1384 * since the previous lseek(). 1385 * H3. offs < 0, errno = ENXIO: start is beyond EOF 1386 * If this happens, the file has been truncated behind our 1387 * back since we opened it. Treat it like a trailing hole. 1388 * H4. offs < 0, errno != ENXIO: we learned nothing 1389 * Pretend we know nothing at all, i.e. "forget" about D1. 1390 */ 1391 offs = glfs_lseek(s->fd, start, SEEK_HOLE); 1392 if (offs < 0) { 1393 return -errno; /* D1 and (H3 or H4) */ 1394 } 1395 1396 if (offs < start) { 1397 /* This is not a valid return by lseek(). We are safe to just return 1398 * -EIO in this case, and we'll treat it like H4. Unfortunately some 1399 * versions of gluster server will return offs < start, so an assert 1400 * here will unnecessarily abort QEMU. */ 1401 return -EIO; 1402 } 1403 1404 if (offs > start) { 1405 /* 1406 * D1 and H2: either in data, next hole at offs, or it was in 1407 * data but is now in a trailing hole. In the latter case, 1408 * all bets are off. Treating it as if it there was data all 1409 * the way to EOF is safe, so simply do that. 1410 */ 1411 *data = start; 1412 *hole = offs; 1413 return 0; 1414 } 1415 1416 /* D1 and H1 */ 1417 return -EBUSY; 1418 #endif 1419 1420 exit: 1421 return -ENOTSUP; 1422 } 1423 1424 /* 1425 * Returns the allocation status of the specified offset. 1426 * 1427 * The block layer guarantees 'offset' and 'bytes' are within bounds. 1428 * 1429 * 'pnum' is set to the number of bytes (including and immediately following 1430 * the specified offset) that are known to be in the same 1431 * allocated/unallocated state. 1432 * 1433 * 'bytes' is the max value 'pnum' should be set to. 1434 * 1435 * (Based on raw_co_block_status() from file-posix.c.) 1436 */ 1437 static int coroutine_fn qemu_gluster_co_block_status(BlockDriverState *bs, 1438 bool want_zero, 1439 int64_t offset, 1440 int64_t bytes, 1441 int64_t *pnum, 1442 int64_t *map, 1443 BlockDriverState **file) 1444 { 1445 BDRVGlusterState *s = bs->opaque; 1446 off_t data = 0, hole = 0; 1447 int ret = -EINVAL; 1448 1449 if (!s->fd) { 1450 return ret; 1451 } 1452 1453 if (!want_zero) { 1454 *pnum = bytes; 1455 *map = offset; 1456 *file = bs; 1457 return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID; 1458 } 1459 1460 ret = find_allocation(bs, offset, &data, &hole); 1461 if (ret == -ENXIO) { 1462 /* Trailing hole */ 1463 *pnum = bytes; 1464 ret = BDRV_BLOCK_ZERO; 1465 } else if (ret < 0) { 1466 /* No info available, so pretend there are no holes */ 1467 *pnum = bytes; 1468 ret = BDRV_BLOCK_DATA; 1469 } else if (data == offset) { 1470 /* On a data extent, compute bytes to the end of the extent, 1471 * possibly including a partial sector at EOF. */ 1472 *pnum = MIN(bytes, hole - offset); 1473 ret = BDRV_BLOCK_DATA; 1474 } else { 1475 /* On a hole, compute bytes to the beginning of the next extent. */ 1476 assert(hole == offset); 1477 *pnum = MIN(bytes, data - offset); 1478 ret = BDRV_BLOCK_ZERO; 1479 } 1480 1481 *map = offset; 1482 *file = bs; 1483 1484 return ret | BDRV_BLOCK_OFFSET_VALID; 1485 } 1486 1487 1488 static BlockDriver bdrv_gluster = { 1489 .format_name = "gluster", 1490 .protocol_name = "gluster", 1491 .instance_size = sizeof(BDRVGlusterState), 1492 .bdrv_needs_filename = false, 1493 .bdrv_file_open = qemu_gluster_open, 1494 .bdrv_reopen_prepare = qemu_gluster_reopen_prepare, 1495 .bdrv_reopen_commit = qemu_gluster_reopen_commit, 1496 .bdrv_reopen_abort = qemu_gluster_reopen_abort, 1497 .bdrv_close = qemu_gluster_close, 1498 .bdrv_co_create = qemu_gluster_co_create, 1499 .bdrv_co_create_opts = qemu_gluster_co_create_opts, 1500 .bdrv_getlength = qemu_gluster_getlength, 1501 .bdrv_get_allocated_file_size = qemu_gluster_allocated_file_size, 1502 .bdrv_truncate = qemu_gluster_truncate, 1503 .bdrv_co_readv = qemu_gluster_co_readv, 1504 .bdrv_co_writev = qemu_gluster_co_writev, 1505 .bdrv_co_flush_to_disk = qemu_gluster_co_flush_to_disk, 1506 .bdrv_has_zero_init = qemu_gluster_has_zero_init, 1507 #ifdef CONFIG_GLUSTERFS_DISCARD 1508 .bdrv_co_pdiscard = qemu_gluster_co_pdiscard, 1509 #endif 1510 #ifdef CONFIG_GLUSTERFS_ZEROFILL 1511 .bdrv_co_pwrite_zeroes = qemu_gluster_co_pwrite_zeroes, 1512 #endif 1513 .bdrv_co_block_status = qemu_gluster_co_block_status, 1514 .create_opts = &qemu_gluster_create_opts, 1515 }; 1516 1517 static BlockDriver bdrv_gluster_tcp = { 1518 .format_name = "gluster", 1519 .protocol_name = "gluster+tcp", 1520 .instance_size = sizeof(BDRVGlusterState), 1521 .bdrv_needs_filename = false, 1522 .bdrv_file_open = qemu_gluster_open, 1523 .bdrv_reopen_prepare = qemu_gluster_reopen_prepare, 1524 .bdrv_reopen_commit = qemu_gluster_reopen_commit, 1525 .bdrv_reopen_abort = qemu_gluster_reopen_abort, 1526 .bdrv_close = qemu_gluster_close, 1527 .bdrv_co_create = qemu_gluster_co_create, 1528 .bdrv_co_create_opts = qemu_gluster_co_create_opts, 1529 .bdrv_getlength = qemu_gluster_getlength, 1530 .bdrv_get_allocated_file_size = qemu_gluster_allocated_file_size, 1531 .bdrv_truncate = qemu_gluster_truncate, 1532 .bdrv_co_readv = qemu_gluster_co_readv, 1533 .bdrv_co_writev = qemu_gluster_co_writev, 1534 .bdrv_co_flush_to_disk = qemu_gluster_co_flush_to_disk, 1535 .bdrv_has_zero_init = qemu_gluster_has_zero_init, 1536 #ifdef CONFIG_GLUSTERFS_DISCARD 1537 .bdrv_co_pdiscard = qemu_gluster_co_pdiscard, 1538 #endif 1539 #ifdef CONFIG_GLUSTERFS_ZEROFILL 1540 .bdrv_co_pwrite_zeroes = qemu_gluster_co_pwrite_zeroes, 1541 #endif 1542 .bdrv_co_block_status = qemu_gluster_co_block_status, 1543 .create_opts = &qemu_gluster_create_opts, 1544 }; 1545 1546 static BlockDriver bdrv_gluster_unix = { 1547 .format_name = "gluster", 1548 .protocol_name = "gluster+unix", 1549 .instance_size = sizeof(BDRVGlusterState), 1550 .bdrv_needs_filename = true, 1551 .bdrv_file_open = qemu_gluster_open, 1552 .bdrv_reopen_prepare = qemu_gluster_reopen_prepare, 1553 .bdrv_reopen_commit = qemu_gluster_reopen_commit, 1554 .bdrv_reopen_abort = qemu_gluster_reopen_abort, 1555 .bdrv_close = qemu_gluster_close, 1556 .bdrv_co_create = qemu_gluster_co_create, 1557 .bdrv_co_create_opts = qemu_gluster_co_create_opts, 1558 .bdrv_getlength = qemu_gluster_getlength, 1559 .bdrv_get_allocated_file_size = qemu_gluster_allocated_file_size, 1560 .bdrv_truncate = qemu_gluster_truncate, 1561 .bdrv_co_readv = qemu_gluster_co_readv, 1562 .bdrv_co_writev = qemu_gluster_co_writev, 1563 .bdrv_co_flush_to_disk = qemu_gluster_co_flush_to_disk, 1564 .bdrv_has_zero_init = qemu_gluster_has_zero_init, 1565 #ifdef CONFIG_GLUSTERFS_DISCARD 1566 .bdrv_co_pdiscard = qemu_gluster_co_pdiscard, 1567 #endif 1568 #ifdef CONFIG_GLUSTERFS_ZEROFILL 1569 .bdrv_co_pwrite_zeroes = qemu_gluster_co_pwrite_zeroes, 1570 #endif 1571 .bdrv_co_block_status = qemu_gluster_co_block_status, 1572 .create_opts = &qemu_gluster_create_opts, 1573 }; 1574 1575 /* rdma is deprecated (actually never supported for volfile fetch). 1576 * Let's maintain it for the protocol compatibility, to make sure things 1577 * won't break immediately. For now, gluster+rdma will fall back to gluster+tcp 1578 * protocol with a warning. 1579 * TODO: remove gluster+rdma interface support 1580 */ 1581 static BlockDriver bdrv_gluster_rdma = { 1582 .format_name = "gluster", 1583 .protocol_name = "gluster+rdma", 1584 .instance_size = sizeof(BDRVGlusterState), 1585 .bdrv_needs_filename = true, 1586 .bdrv_file_open = qemu_gluster_open, 1587 .bdrv_reopen_prepare = qemu_gluster_reopen_prepare, 1588 .bdrv_reopen_commit = qemu_gluster_reopen_commit, 1589 .bdrv_reopen_abort = qemu_gluster_reopen_abort, 1590 .bdrv_close = qemu_gluster_close, 1591 .bdrv_co_create = qemu_gluster_co_create, 1592 .bdrv_co_create_opts = qemu_gluster_co_create_opts, 1593 .bdrv_getlength = qemu_gluster_getlength, 1594 .bdrv_get_allocated_file_size = qemu_gluster_allocated_file_size, 1595 .bdrv_truncate = qemu_gluster_truncate, 1596 .bdrv_co_readv = qemu_gluster_co_readv, 1597 .bdrv_co_writev = qemu_gluster_co_writev, 1598 .bdrv_co_flush_to_disk = qemu_gluster_co_flush_to_disk, 1599 .bdrv_has_zero_init = qemu_gluster_has_zero_init, 1600 #ifdef CONFIG_GLUSTERFS_DISCARD 1601 .bdrv_co_pdiscard = qemu_gluster_co_pdiscard, 1602 #endif 1603 #ifdef CONFIG_GLUSTERFS_ZEROFILL 1604 .bdrv_co_pwrite_zeroes = qemu_gluster_co_pwrite_zeroes, 1605 #endif 1606 .bdrv_co_block_status = qemu_gluster_co_block_status, 1607 .create_opts = &qemu_gluster_create_opts, 1608 }; 1609 1610 static void bdrv_gluster_init(void) 1611 { 1612 bdrv_register(&bdrv_gluster_rdma); 1613 bdrv_register(&bdrv_gluster_unix); 1614 bdrv_register(&bdrv_gluster_tcp); 1615 bdrv_register(&bdrv_gluster); 1616 } 1617 1618 block_init(bdrv_gluster_init); 1619