On Mon, Sep 26, 2022 at 05:05:43PM -0500, Eric Blake wrote: Is this an actual rule? I checked some libc functions and it seems like printf(NULL) => errno EINVAL puts(NULL) => segfault Both functions _do_ have nonnull attributes on the parameters, so GCC will warn (if it can statically analyze the situation). I do agree that this is wrong. If I'm following the Python bindings correctly what is happening is that we're calling nbd_connect_command (h, { NULL }); which is causing the first case above. This is definitely an improvement for Python code (which really should never crash). So I'm not sure about the total fix here. Definitely we should be returning an error if a zero length list is passed to nbd_connect_* functions. But one thing I especially don't like about libvirt is that it turns various virFoo (NULL) calls into errors instead of segfaults, which in turn makes it much easier to ignore serious errors in the calling code. While I won't necessarily push too hard against this patch I don't feel it's the right direction unless someone can persuade me otherwise. Rich. -- Richard Jones, Virtualization Group, Red Hat http://people.redhat.com/~rjones Read my programming and virtualization blog: http://rwmj.wordpress.com libguestfs lets you edit virtual machines. Supports shell scripting, bindings from many languages. http://libguestfs.org

Catch the library crashes patched in the previous commit. --- tests/Makefile.am | 5 +++ tests/errors-connect-null.c | 88 +++++++++++++++++++++++++++++++++++++ .gitignore | 1 + 3 files changed, 94 insertions(+) create mode 100644 tests/errors-connect-null.c diff --git a/tests/Makefile.am b/tests/Makefile.am index 7fc7dec3..f6a2c110 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -168,6 +168,7 @@ check_PROGRAMS += \ errors-not-connected \ errors-name-too-long \ errors-poll-no-fd \ + errors-connect-null \ errors-connect-twice \ errors-not-negotiating \ errors-notify-not-blocked \ @@ -233,6 +234,7 @@ TESTS += \ errors-not-connected \ errors-name-too-long \ errors-poll-no-fd \ + errors-connect-null \ errors-connect-twice \ errors-not-negotiating \ errors-notify-not-blocked \ @@ -309,6 +311,9 @@ errors_name_too_long_LDADD = $(top_builddir)/lib/libnbd.la errors_poll_no_fd_SOURCES = errors-poll-no-fd.c errors_poll_no_fd_LDADD = $(top_builddir)/lib/libnbd.la +errors_connect_null_SOURCES = errors-connect-null.c +errors_connect_null_LDADD = $(top_builddir)/lib/libnbd.la + errors_connect_twice_SOURCES = errors-connect-twice.c errors_connect_twice_LDADD = $(top_builddir)/lib/libnbd.la diff --git a/tests/errors-connect-null.c b/tests/errors-connect-null.c new file mode 100644 index 00000000..9cda242e --- /dev/null +++ b/tests/errors-connect-null.c @@ -0,0 +1,88 @@ +/* NBD client library in userspace + * Copyright (C) 2013-2022 Red Hat Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/* Deliberately provoke some errors and check the error messages from + * nbd_get_error etc look reasonable. + */ + +#include <config.h> + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <errno.h> + +#include <libnbd.h> + +static char *progname; + +static void +check (int experr, const char *prefix) +{ + const char *msg = nbd_get_error (); + int errnum = nbd_get_errno (); + + fprintf (stderr, "error: \"%s\"\n", msg); + fprintf (stderr, "errno: %d (%s)\n", errnum, strerror (errnum)); + if (strncmp (msg, prefix, strlen (prefix)) != 0) { + fprintf (stderr, "%s: test failed: missing context prefix: %s\n", + progname, msg); + exit (EXIT_FAILURE); + } + if (errnum != experr) { + fprintf (stderr, "%s: test failed: " + "expected errno = %d (%s), but got %d\n", + progname, experr, strerror (experr), errnum); + exit (EXIT_FAILURE); + } +} + +int +main (int argc, char *argv[]) +{ + struct nbd_handle *nbd; + const char *cmd[] = { NULL }; + + progname = argv[0]; + + nbd = nbd_create (); + if (nbd == NULL) { + fprintf (stderr, "%s\n", nbd_get_error ()); + exit (EXIT_FAILURE); + } + + /* Connect to an invalid command. */ + if (nbd_connect_command (nbd, NULL) != -1) { + fprintf (stderr, "%s: test failed: " + "nbd_connect_command did not reject NULL argv\n", + argv[0]); + exit (EXIT_FAILURE); + } + check (EFAULT, "nbd_connect_command: "); + + if (nbd_connect_command (nbd, (char **) cmd) != -1) { + fprintf (stderr, "%s: test failed: " + "nbd_connect_command did not reject empty argv\n", + argv[0]); + exit (EXIT_FAILURE); + } + check (EINVAL, "nbd_connect_command: "); + + nbd_close (nbd); + exit (EXIT_SUCCESS); +} diff --git a/.gitignore b/.gitignore index 071393fb..bc49860d 100644 --- a/.gitignore +++ b/.gitignore @@ -204,6 +204,7 @@ Makefile.in /tests/errors-client-unaligned /tests/errors-client-unknown-flags /tests/errors-client-zerosize +/tests/errors-connect-null /tests/errors-connect-twice /tests/errors-enum /tests/errors-multiple-disconnects -- 2.37.3

This test proves that an attempt to list meta contexts goes to the server rather than being rejected at the client, even with older nbdkit that fails the attempt[1]; and includes ports to the various languages. Done as a separate commit to allow temporary reordering of the series to prove the test works. [1] nbdkit didn't accept LIST_META_CONTENT before STRUCTURED_REPLY until commit c39cba73 [v1.27.3, backported to 1.26.6]. Similarly, qemu-nbd didn't accept it until commit da24597d [v6.2]. So, I was able to test the graceful skip by adding a build of nbdkit without that support at the front of my PATH. --- python/t/240-opt-list-meta.py | 25 ++++++++++ ocaml/tests/test_240_opt_list_meta.ml | 30 ++++++++++++ tests/opt-list-meta.c | 34 ++++++++++++-- golang/libnbd_240_opt_list_meta_test.go | 61 ++++++++++++++++++++++++- 4 files changed, 144 insertions(+), 6 deletions(-) diff --git a/python/t/240-opt-list-meta.py b/python/t/240-opt-list-meta.py index 2b66eb5d..50fcfd69 100644 --- a/python/t/240-opt-list-meta.py +++ b/python/t/240-opt-list-meta.py @@ -31,6 +31,7 @@ def f(user_data, name): seen = True +# Get into negotiating state. h = nbd.NBD() h.set_opt_mode(True) h.connect_command(["nbdkit", "-s", "--exit-with-parent", "-v", @@ -77,3 +78,27 @@ def f(user_data, name): assert seen is True h.opt_abort() + +# Repeat but this time without structured replies. Deal gracefully +# with older servers that don't allow the attempt. +h = nbd.NBD() +h.set_opt_mode(True) +h.set_request_structured_replies(False) +h.connect_command(["nbdkit", "-s", "--exit-with-parent", "-v", + "memory", "size=1M"]) +bytes = h.stats_bytes_sent() + +try: + count = 0 + seen = False + r = h.opt_list_meta_context(lambda *args: f(42, *args)) + assert r == count + assert r >= 1 + assert seen is True +except nbd.Error as ex: + assert h.stats_bytes_sent() > bytes + print("ignoring failure from old server: %s" % ex.string) + +# FIXME: Once nbd_opt_structured_reply exists, use it here and retry. + +h.opt_abort() diff --git a/ocaml/tests/test_240_opt_list_meta.ml b/ocaml/tests/test_240_opt_list_meta.ml index 639d33c8..64159185 100644 --- a/ocaml/tests/test_240_opt_list_meta.ml +++ b/ocaml/tests/test_240_opt_list_meta.ml @@ -17,6 +17,8 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA *) +open Printf + let count = ref 0 let seen = ref false let f user_data name = @@ -27,6 +29,7 @@ let 0 let () = + (* Get into negotiating state. *) let nbd = NBD.create () in NBD.set_opt_mode nbd true; NBD.connect_command nbd @@ -75,6 +78,33 @@ let assert (r = !count); assert !seen; + NBD.opt_abort nbd; + + (* Repeat but this time without structured replies. Deal gracefully + * with older servers that don't allow the attempt. + *) + let nbd = NBD.create () in + NBD.set_opt_mode nbd true; + NBD.set_request_structured_replies nbd false; + NBD.connect_command nbd + ["nbdkit"; "-s"; "--exit-with-parent"; "-v"; + "memory"; "size=1M"]; + let bytes = NBD.stats_bytes_sent nbd in + (try + count := 0; + seen := false; + let r = NBD.opt_list_meta_context nbd (f 42) in + assert (r = !count); + assert (r >= 1); + assert !seen + with + NBD.Error (errstr, errno) -> + assert (NBD.stats_bytes_sent nbd > bytes); + printf "ignoring failure from old server %s\n" errstr + ); + + (* FIXME: Once nbd_opt_structured_reply exists, use it here and retry. *) + NBD.opt_abort nbd let () = Gc.compact () diff --git a/tests/opt-list-meta.c b/tests/opt-list-meta.c index 9ad8e37e..dc9c6799 100644 --- a/tests/opt-list-meta.c +++ b/tests/opt-list-meta.c @@ -17,6 +17,7 @@ */ /* Test behavior of nbd_opt_list_meta_context. */ +/* See also unit test 240 in the various language ports. */ #include <config.h> @@ -56,6 +57,7 @@ main (int argc, char *argv[]) "memory", "size=1M", NULL }; int max; char *tmp; + uint64_t bytes; /* Get into negotiating state. */ nbd = nbd_create (); @@ -164,7 +166,9 @@ main (int argc, char *argv[]) nbd_opt_abort (nbd); nbd_close (nbd); - /* Repeat but this time without structured replies. */ + /* Repeat but this time without structured replies. Deal gracefully + * with older servers that don't allow the attempt. + */ nbd = nbd_create (); if (nbd == NULL || nbd_set_opt_mode (nbd, true) == -1 || @@ -173,16 +177,36 @@ main (int argc, char *argv[]) fprintf (stderr, "%s\n", nbd_get_error ()); exit (EXIT_FAILURE); } + bytes = nbd_stats_bytes_sent (nbd); - /* FIXME: For now, we reject this client-side, but it is overly strict. */ p = (struct progress) { .count = 0 }; r = nbd_opt_list_meta_context (nbd, (nbd_context_callback) { .callback = check, .user_data = &p}); - if (r != -1) { - fprintf (stderr, "not expecting command to succeed\n"); - exit (EXIT_FAILURE); + if (r == -1) { + if (nbd_stats_bytes_sent (nbd) == bytes) { + fprintf (stderr, "bug: client failed to send request\n"); + exit (EXIT_FAILURE); + } + fprintf (stdout, "ignoring failure from old server: %s\n", + nbd_get_error ()); } + else { + if (r != p.count) { + fprintf (stderr, "inconsistent return value %d, expected %d\n", + r, p.count); + exit (EXIT_FAILURE); + } + if (r < 1 || !p.seen) { + fprintf (stderr, "server did not reply with base:allocation\n"); + exit (EXIT_FAILURE); + } + } + + /* FIXME: Once nbd_opt_structured_reply() exists, use it here and retry. */ + + nbd_opt_abort (nbd); + nbd_close (nbd); exit (EXIT_SUCCESS); } diff --git a/golang/libnbd_240_opt_list_meta_test.go b/golang/libnbd_240_opt_list_meta_test.go index d7322752..2b49c895 100644 --- a/golang/libnbd_240_opt_list_meta_test.go +++ b/golang/libnbd_240_opt_list_meta_test.go @@ -1,5 +1,5 @@ /* libnbd golang tests - * Copyright (C) 2013-2021 Red Hat Inc. + * Copyright (C) 2013-2022 Red Hat Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -19,6 +19,7 @@ package libnbd import ( + "fmt"; "testing" ) @@ -37,6 +38,7 @@ func listmetaf(user_data int, name string) int { } func Test240OptListMeta(t *testing.T) { + /* Get into negotiating state. */ h, err := Create() if err != nil { t.Fatalf("could not create handle: %s", err) @@ -143,4 +145,61 @@ func Test240OptListMeta(t *testing.T) { if err != nil { t.Fatalf("could not request opt_abort: %s", err) } + + /* Repeat but this time without structured replies. Deal gracefully + * with older servers that don't allow the attempt. + */ + h, err = Create() + if err != nil { + t.Fatalf("could not create handle: %s", err) + } + defer h.Close() + + err = h.SetOptMode(true) + if err != nil { + t.Fatalf("could not set opt mode: %s", err) + } + + err = h.SetRequestStructuredReplies(false) + if err != nil { + t.Fatalf("could not set request structured replies: %s", err) + } + + err = h.ConnectCommand([]string{ + "nbdkit", "-s", "--exit-with-parent", "-v", + "memory", "size=1M", + }) + if err != nil { + t.Fatalf("could not connect: %s", err) + } + + bytes, err := h.StatsBytesSent() + if err != nil { + t.Fatalf("could not collect stats: %s", err) + } + + count = 0 + seen = false + r, err = h.OptListMetaContext(func(name string) int { + return listmetaf(42, name) + }) + if err != nil { + bytes2, err2 := h.StatsBytesSent() + if err2 != nil { + t.Fatalf("could not collect stats: %s", err2) + } + if bytes2 <= bytes { + t.Fatalf("unexpected bytes sent after opt_list_meta_context") + } + fmt.Printf("ignoring failure from old server: %s", err) + } else if r < 1 || r != count || !seen { + t.Fatalf("unexpected count after opt_list_meta_context") + } + + /* FIXME: Once nbd_opt_structured_reply exists, use it here and retry. */ + + err = h.OptAbort() + if err != nil { + t.Fatalf("could not request opt_abort: %s", err) + } } -- 2.37.3

Rather than always relying on the implicit global list managed by nbd_add_meta_context() and nbd_clear_meta_contexts(), we can take the user's list of contexts as a direct parameter. This finally makes use of the non-NULL queries parameter of the nbd_internal_set_querylist() added in a previous patch. The C test is added along with this commit (applying the new test independently wouldn't compile), but the language bindings are done separately for ease of review. --- generator/API.ml | 99 ++++++++++++- generator/states-newstyle-opt-meta-context.c | 8 +- lib/opt.c | 25 +++- tests/Makefile.am | 5 + tests/opt-list-meta-queries.c | 145 +++++++++++++++++++ .gitignore | 1 + 6 files changed, 272 insertions(+), 11 deletions(-) create mode 100644 tests/opt-list-meta-queries.c diff --git a/generator/API.ml b/generator/API.ml index 7be870a4..0c72c356 100644 --- a/generator/API.ml +++ b/generator/API.ml @@ -1169,12 +1169,15 @@ "opt_list_meta_context", { default_call with args = [ Closure context_closure ]; ret = RInt; permitted_states = [ Negotiating ]; - shortdesc = "request the server to list available meta contexts"; + shortdesc = "list available meta contexts, using implicit query list"; longdesc = "\ Request that the server list available meta contexts associated with the export previously specified by the most recent -L<nbd_set_export_name(3)> or L<nbd_connect_uri(3)>. This can only be -used if L<nbd_set_opt_mode(3)> enabled option mode. +L<nbd_set_export_name(3)> or L<nbd_connect_uri(3)>, and with a +list of queries from prior calls to L<nbd_add_meta_context(3)> +(see L<nbd_opt_list_meta_context_queries(3)> if you want to supply +an explicit query list instead). This can only be used if +L<nbd_set_opt_mode(3)> enabled option mode. The NBD protocol allows a client to decide how many queries to ask the server. Rather than taking that list of queries as a parameter @@ -1211,10 +1214,61 @@ "opt_list_meta_context", { replies that might be advertised, so client code should be aware that a server may send a lengthy list."; see_also = [Link "set_opt_mode"; Link "aio_opt_list_meta_context"; + Link "opt_list_meta_context_queries"; Link "add_meta_context"; Link "clear_meta_contexts"; Link "opt_go"; Link "set_export_name"]; }; + "opt_list_meta_context_queries", { + default_call with + args = [ StringList "queries"; Closure context_closure ]; ret = RInt; + permitted_states = [ Negotiating ]; + shortdesc = "list available meta contexts, using explicit query list"; + longdesc = "\ +Request that the server list available meta contexts associated with +the export previously specified by the most recent +L<nbd_set_export_name(3)> or L<nbd_connect_uri(3)>, and with an +explicit list of queries provided as a parameter (see +L<nbd_opt_list_meta_context(3)> if you want to reuse an +implicit query list instead). This can only be used if +L<nbd_set_opt_mode(3)> enabled option mode. + +The NBD protocol allows a client to decide how many queries to ask +the server. For this function, the list is explicit in the C<queries> +parameter. When the list is empty, a server will typically reply with all +contexts that it supports; when the list is non-empty, the server +will reply only with supported contexts that match the client's +request. Note that a reply by the server might be encoded to +represent several feasible contexts within one string, rather than +multiple strings per actual context name that would actually succeed +during L<nbd_opt_go(3)>; so it is still necessary to use +L<nbd_can_meta_context(3)> after connecting to see which contexts +are actually supported. + +The C<context> function is called once per server reply, with any +C<user_data> passed to this function, and with C<name> supplied by +the server. Remember that it is not safe to call +L<nbd_add_meta_context(3)> from within the context of the +callback function; rather, your code must copy any C<name> needed for +later use after this function completes. At present, the return value +of the callback is ignored, although a return of -1 should be avoided. + +For convenience, when this function succeeds, it returns the number +of replies returned by the server. + +Not all servers understand this request, and even when it is understood, +the server might intentionally send an empty list because it does not +support the requested context, or may encounter a failure after +delivering partial results. Thus, this function may succeed even when +no contexts are reported, or may fail but have a non-empty list. Likewise, +the NBD protocol does not specify an upper bound for the number of +replies that might be advertised, so client code should be aware that +a server may send a lengthy list."; + see_also = [Link "set_opt_mode"; Link "aio_opt_list_meta_context_queries"; + Link "opt_list_meta_context"; + Link "opt_go"; Link "set_export_name"]; + }; + "add_meta_context", { default_call with args = [ String "name" ]; ret = RErr; @@ -2599,11 +2653,14 @@ "aio_opt_list_meta_context", { args = [ Closure context_closure ]; ret = RInt; optargs = [ OClosure completion_closure ]; permitted_states = [ Negotiating ]; - shortdesc = "request the server to list available meta contexts"; + shortdesc = "request list of available meta contexts, using implicit query"; longdesc = "\ Request that the server list available meta contexts associated with the export previously specified by the most recent -L<nbd_set_export_name(3)> or L<nbd_connect_uri(3)>. This can only be +L<nbd_set_export_name(3)> or L<nbd_connect_uri(3)>, and with a +list of queries from prior calls to L<nbd_add_meta_context(3)> +(see L<nbd_aio_opt_list_meta_context_queries(3)> if you want to +supply an explicit query list instead). This can only be used if L<nbd_set_opt_mode(3)> enabled option mode. To determine when the request completes, wait for @@ -2614,7 +2671,35 @@ "aio_opt_list_meta_context", { server returns an error (as is done by the return value of the synchronous counterpart) is only possible with a completion callback."; - see_also = [Link "set_opt_mode"; Link "opt_list_meta_context"]; + see_also = [Link "set_opt_mode"; Link "opt_list_meta_context"; + Link "aio_opt_list_meta_context_queries"]; + }; + + "aio_opt_list_meta_context_queries", { + default_call with + args = [ StringList "queries"; Closure context_closure ]; ret = RInt; + optargs = [ OClosure completion_closure ]; + permitted_states = [ Negotiating ]; + shortdesc = "request list of available meta contexts, using explicit query"; + longdesc = "\ +Request that the server list available meta contexts associated with +the export previously specified by the most recent +L<nbd_set_export_name(3)> or L<nbd_connect_uri(3)>, and with an +explicit list of queries provided as a parameter (see +L<nbd_aio_opt_list_meta_context(3)> if you want to reuse an +implicit query list instead). This can only be +used if L<nbd_set_opt_mode(3)> enabled option mode. + +To determine when the request completes, wait for +L<nbd_aio_is_connecting(3)> to return false. Or supply the optional +C<completion_callback> which will be invoked as described in +L<libnbd(3)/Completion callbacks>, except that it is automatically +retired regardless of return value. Note that detecting whether the +server returns an error (as is done by the return value of the +synchronous counterpart) is only possible with a completion +callback."; + see_also = [Link "set_opt_mode"; Link "opt_list_meta_context_queries"; + Link "aio_opt_list_meta_context"]; }; "aio_pread", { @@ -3347,6 +3432,8 @@ let first_version = "stats_chunks_sent", (1, 16); "stats_bytes_received", (1, 16); "stats_chunks_received", (1, 16); + "opt_list_meta_context_queries", (1, 16); + "aio_opt_list_meta_context_queries", (1, 16); (* These calls are proposed for a future version of libnbd, but * have not been added to any released version so far. diff --git a/generator/states-newstyle-opt-meta-context.c b/generator/states-newstyle-opt-meta-context.c index 31e84f35..1eb9fbe7 100644 --- a/generator/states-newstyle-opt-meta-context.c +++ b/generator/states-newstyle-opt-meta-context.c @@ -61,14 +61,14 @@ NEWSTYLE.OPT_META_CONTEXT.START: SET_NEXT_STATE (%^OPT_GO.START); return 0; } + if (nbd_internal_set_querylist (h, NULL) == -1) { + SET_NEXT_STATE (%.DEAD); + return 0; + } } assert (!h->meta_valid); - if (nbd_internal_set_querylist (h, NULL) == -1) { - SET_NEXT_STATE (%.DEAD); - return 0; - } /* Calculate the length of the option request data. */ len = 4 /* exportname len */ + strlen (h->export_name) + 4 /* nr queries */; for (i = 0; i < h->querylist.len; ++i) diff --git a/lib/opt.c b/lib/opt.c index d9114f4b..cfdabb9e 100644 --- a/lib/opt.c +++ b/lib/opt.c @@ -197,12 +197,21 @@ context_complete (void *opaque, int *err) int nbd_unlocked_opt_list_meta_context (struct nbd_handle *h, nbd_context_callback *context) +{ + return nbd_unlocked_opt_list_meta_context_queries (h, NULL, context); +} + +/* Issue NBD_OPT_LIST_META_CONTEXT and wait for the reply. */ +int +nbd_unlocked_opt_list_meta_context_queries (struct nbd_handle *h, + char **queries, + nbd_context_callback *context) { struct context_helper s = { .context = *context }; nbd_context_callback l = { .callback = context_visitor, .user_data = &s }; nbd_completion_callback c = { .callback = context_complete, .user_data = &s }; - if (nbd_unlocked_aio_opt_list_meta_context (h, &l, &c) == -1) + if (nbd_unlocked_aio_opt_list_meta_context_queries (h, queries, &l, &c) == -1) return -1; SET_CALLBACK_TO_NULL (*context); @@ -285,12 +294,26 @@ int nbd_unlocked_aio_opt_list_meta_context (struct nbd_handle *h, nbd_context_callback *context, nbd_completion_callback *complete) +{ + return nbd_unlocked_aio_opt_list_meta_context_queries (h, NULL, context, + complete); +} + +/* Issue NBD_OPT_LIST_META_CONTEXT without waiting. */ +int +nbd_unlocked_aio_opt_list_meta_context_queries (struct nbd_handle *h, + char **queries, + nbd_context_callback *context, + nbd_completion_callback *complete) { if ((h->gflags & LIBNBD_HANDSHAKE_FLAG_FIXED_NEWSTYLE) == 0) { set_error (ENOTSUP, "server is not using fixed newstyle protocol"); return -1; } + if (nbd_internal_set_querylist (h, queries) == -1) + return -1; + assert (CALLBACK_IS_NULL (h->opt_cb.fn.context)); h->opt_cb.fn.context = *context; SET_CALLBACK_TO_NULL (*context); diff --git a/tests/Makefile.am b/tests/Makefile.am index f6a2c110..dfb7f8bd 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -214,6 +214,7 @@ check_PROGRAMS += \ opt-list \ opt-info \ opt-list-meta \ + opt-list-meta-queries \ connect-systemd-socket-activation \ connect-unix \ connect-tcp \ @@ -280,6 +281,7 @@ TESTS += \ opt-list \ opt-info \ opt-list-meta \ + opt-list-meta-queries \ connect-systemd-socket-activation \ connect-unix \ connect-tcp \ @@ -538,6 +540,9 @@ opt_info_LDADD = $(top_builddir)/lib/libnbd.la opt_list_meta_SOURCES = opt-list-meta.c opt_list_meta_LDADD = $(top_builddir)/lib/libnbd.la +opt_list_meta_queries_SOURCES = opt-list-meta-queries.c +opt_list_meta_queries_LDADD = $(top_builddir)/lib/libnbd.la + connect_systemd_socket_activation_SOURCES = \ connect-systemd-socket-activation.c \ requires.c \ diff --git a/tests/opt-list-meta-queries.c b/tests/opt-list-meta-queries.c new file mode 100644 index 00000000..8570f967 --- /dev/null +++ b/tests/opt-list-meta-queries.c @@ -0,0 +1,145 @@ +/* NBD client library in userspace + * Copyright (C) 2013-2022 Red Hat Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/* Test behavior of nbd_opt_list_meta_context_queries. */ + +#include <config.h> + +#include <stdio.h> +#include <stdlib.h> +#include <stdint.h> +#include <stdbool.h> +#include <inttypes.h> +#include <string.h> +#include <errno.h> + +#include <libnbd.h> + +struct progress { + int count; + bool seen; +}; + +static int +check (void *user_data, const char *name) +{ + struct progress *p = user_data; + + p->count++; + if (strcmp (name, LIBNBD_CONTEXT_BASE_ALLOCATION) == 0) + p->seen = true; + return 0; +} + +int +main (int argc, char *argv[]) +{ + struct nbd_handle *nbd; + int r; + struct progress p; + char *args[] = { "nbdkit", "-s", "--exit-with-parent", "-v", + "memory", "size=1M", NULL }; + nbd_context_callback ctx = { .callback = check, + .user_data = &p}; + + /* Get into negotiating state. */ + nbd = nbd_create (); + if (nbd == NULL || + nbd_set_opt_mode (nbd, true) == -1 || + nbd_connect_command (nbd, args) == -1) { + fprintf (stderr, "%s\n", nbd_get_error ()); + exit (EXIT_FAILURE); + } + + /* A NULL query is an error (C-only test) */ + p = (struct progress) { .count = 0 }; + r = nbd_opt_list_meta_context_queries (nbd, NULL, ctx); + if (r != -1 || nbd_get_errno () != EFAULT) { + fprintf (stderr, "expected EFAULT for NULL query list\n"); + exit (EXIT_FAILURE); + } + if (p.count != 0 || p.seen) { + fprintf (stderr, "unexpected use of callback on failure\n"); + exit (EXIT_FAILURE); + } + + /* First pass: empty query should give at least "base:allocation". + * The explicit query overrides a non-empty nbd_add_meta_context. + */ + p = (struct progress) { .count = 0 }; + if (nbd_add_meta_context (nbd, "x-nosuch:") == -1) { + fprintf (stderr, "%s\n", nbd_get_error ()); + exit (EXIT_FAILURE); + } + { + char *empty[] = { NULL }; + r = nbd_opt_list_meta_context_queries (nbd, empty, ctx); + } + if (r == -1) { + fprintf (stderr, "%s\n", nbd_get_error ()); + exit (EXIT_FAILURE); + } + if (r != p.count) { + fprintf (stderr, "inconsistent return value %d, expected %d\n", r, p.count); + exit (EXIT_FAILURE); + } + if (r < 1 || !p.seen) { + fprintf (stderr, "server did not reply with base:allocation\n"); + exit (EXIT_FAILURE); + } + + /* Second pass: bogus query has no response. */ + p = (struct progress) { .count = 0 }; + r = nbd_clear_meta_contexts (nbd); + if (r == -1) { + fprintf (stderr, "%s\n", nbd_get_error ()); + exit (EXIT_FAILURE); + } + { + char *nosuch[] = { "x-nosuch:", NULL }; + r = nbd_opt_list_meta_context_queries (nbd, nosuch, ctx); + } + if (r == -1) { + fprintf (stderr, "%s\n", nbd_get_error ()); + exit (EXIT_FAILURE); + } + if (r != 0 || p.count != 0 || p.seen) { + fprintf (stderr, "expecting no contexts, got %d\n", r); + exit (EXIT_FAILURE); + } + + /* Third pass: specific query should have one match. */ + p = (struct progress) { .count = 0 }; + { + char *pair[] = { "x-nosuch:", LIBNBD_CONTEXT_BASE_ALLOCATION, NULL }; + r = nbd_opt_list_meta_context_queries (nbd, pair, ctx); + } + if (r == -1) { + fprintf (stderr, "%s\n", nbd_get_error ()); + exit (EXIT_FAILURE); + } + if (r != 1 || p.count != 1 || !p.seen) { + fprintf (stderr, "expecting exactly one context, got %d\n", r); + exit (EXIT_FAILURE); + } + + nbd_opt_abort (nbd); + nbd_close (nbd); + + exit (EXIT_SUCCESS); +} diff --git a/.gitignore b/.gitignore index bc49860d..272d1ec1 100644 --- a/.gitignore +++ b/.gitignore @@ -233,6 +233,7 @@ Makefile.in /tests/opt-info /tests/opt-list /tests/opt-list-meta +/tests/opt-list-meta-queries /tests/pki/ /tests/pread-initialize /tests/private-data -- 2.37.3

Port the C test of the previous commit over to other language bindings, to prove that we are handling StringList translations correctly. Golang is particularly annoying with all tests sharing the same namespace for globals, requiring some renaming in test 240 in relation to the code added in test 245. --- python/t/245-opt-list-meta-queries.py | 68 +++++++++++ ocaml/tests/Makefile.am | 1 + ocaml/tests/test_245_opt_list_meta_queries.ml | 68 +++++++++++ tests/opt-list-meta-queries.c | 1 + golang/Makefile.am | 1 + golang/libnbd_240_opt_list_meta_test.go | 40 +++--- .../libnbd_245_opt_list_meta_queries_test.go | 115 ++++++++++++++++++ 7 files changed, 274 insertions(+), 20 deletions(-) create mode 100644 python/t/245-opt-list-meta-queries.py create mode 100644 ocaml/tests/test_245_opt_list_meta_queries.ml create mode 100644 golang/libnbd_245_opt_list_meta_queries_test.go diff --git a/python/t/245-opt-list-meta-queries.py b/python/t/245-opt-list-meta-queries.py new file mode 100644 index 00000000..561997ed --- /dev/null +++ b/python/t/245-opt-list-meta-queries.py @@ -0,0 +1,68 @@ +# libnbd Python bindings +# Copyright (C) 2010-2022 Red Hat Inc. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +import nbd + + +count = 0 +seen = False + + +def f(user_data, name): + global count + global seen + assert user_data == 42 + count = count + 1 + if name == nbd.CONTEXT_BASE_ALLOCATION: + seen = True + + +# Get into negotiating state. +h = nbd.NBD() +h.set_opt_mode(True) +h.connect_command(["nbdkit", "-s", "--exit-with-parent", "-v", + "memory", "size=1M"]) + +# First pass: empty query should give at least "base:allocation". +# The explicit query overrides a non-empty nbd_add_meta_context. +count = 0 +seen = False +h.add_meta_context("x-nosuch:") +r = h.opt_list_meta_context_queries([], lambda *args: f(42, *args)) +assert r == count +assert r >= 1 +assert seen is True + +# Second pass: bogus query has no response. +count = 0 +seen = False +h.clear_meta_contexts() +r = h.opt_list_meta_context_queries(["x-nosuch:"], lambda *args: f(42, *args)) +assert r == 0 +assert r == count +assert seen is False + +# Third pass: specific query should have one match. +count = 0 +seen = False +r = h.opt_list_meta_context_queries(["x-nosuch:", nbd.CONTEXT_BASE_ALLOCATION], + lambda *args: f(42, *args)) +assert r == 1 +assert count == 1 +assert seen is True + +h.opt_abort() diff --git a/ocaml/tests/Makefile.am b/ocaml/tests/Makefile.am index c4751ad3..1b4d1135 100644 --- a/ocaml/tests/Makefile.am +++ b/ocaml/tests/Makefile.am @@ -31,6 +31,7 @@ ML_TESTS = \ test_220_opt_list.ml \ test_230_opt_info.ml \ test_240_opt_list_meta.ml \ + test_245_opt_list_meta_queries.ml \ test_300_get_size.ml \ test_400_pread.ml \ test_405_pread_structured.ml \ diff --git a/ocaml/tests/test_245_opt_list_meta_queries.ml b/ocaml/tests/test_245_opt_list_meta_queries.ml new file mode 100644 index 00000000..4c5e01ef --- /dev/null +++ b/ocaml/tests/test_245_opt_list_meta_queries.ml @@ -0,0 +1,68 @@ +(* hey emacs, this is OCaml code: -*- tuareg -*- *) +(* libnbd OCaml test case + * Copyright (C) 2013-2022 Red Hat Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + *) + +open Printf + +let count = ref 0 +let seen = ref false +let f user_data name = + assert (user_data = 42); + count := !count + 1; + if name = NBD.context_base_allocation then + seen := true; + 0 + +let () = + (* Get into negotiating state. *) + let nbd = NBD.create () in + NBD.set_opt_mode nbd true; + NBD.connect_command nbd + ["nbdkit"; "-s"; "--exit-with-parent"; "-v"; + "memory"; "size=1M"]; + + (* First pass: empty query should give at least "base:allocation". *) + count := 0; + seen := false; + NBD.add_meta_context nbd "x-nosuch:"; + let r = NBD.opt_list_meta_context_queries nbd [] (f 42) in + assert (r = !count); + assert (r >= 1); + assert !seen; + + (* Second pass: bogus query has no response. *) + count := 0; + seen := false; + NBD.clear_meta_contexts nbd; + let r = NBD.opt_list_meta_context_queries nbd ["x-nosuch:"] (f 42) in + assert (r = 0); + assert (r = !count); + assert (not !seen); + + (* Third pass: specific query should have one match. *) + count := 0; + seen := false; + let r = NBD.opt_list_meta_context_queries nbd [ + "x-nosuch:"; NBD.context_base_allocation ] (f 42) in + assert (r = 1); + assert (r = !count); + assert !seen; + + NBD.opt_abort nbd + +let () = Gc.compact () diff --git a/tests/opt-list-meta-queries.c b/tests/opt-list-meta-queries.c index 8570f967..3075e905 100644 --- a/tests/opt-list-meta-queries.c +++ b/tests/opt-list-meta-queries.c @@ -17,6 +17,7 @@ */ /* Test behavior of nbd_opt_list_meta_context_queries. */ +/* See also unit test 245 in the various language ports. */ #include <config.h> diff --git a/golang/Makefile.am b/golang/Makefile.am index 4e49a9a1..6adf6ae8 100644 --- a/golang/Makefile.am +++ b/golang/Makefile.am @@ -35,6 +35,7 @@ source_files = \ libnbd_220_opt_list_test.go \ libnbd_230_opt_info_test.go \ libnbd_240_opt_list_meta_test.go \ + libnbd_245_opt_list_meta_queries_test.go \ libnbd_300_get_size_test.go \ libnbd_400_pread_test.go \ libnbd_405_pread_structured_test.go \ diff --git a/golang/libnbd_240_opt_list_meta_test.go b/golang/libnbd_240_opt_list_meta_test.go index 2b49c895..c329aaf6 100644 --- a/golang/libnbd_240_opt_list_meta_test.go +++ b/golang/libnbd_240_opt_list_meta_test.go @@ -23,16 +23,16 @@ "testing" ) -var count uint -var seen bool +var list_count uint +var list_seen bool func listmetaf(user_data int, name string) int { if user_data != 42 { panic("expected user_data == 42") } - count++ + list_count++ if (name == context_base_allocation) { - seen = true + list_seen = true } return 0 } @@ -59,22 +59,22 @@ func Test240OptListMeta(t *testing.T) { } /* First pass: empty query should give at least "base:allocation". */ - count = 0 - seen = false + list_count = 0 + list_seen = false r, err := h.OptListMetaContext(func(name string) int { return listmetaf(42, name) }) if err != nil { t.Fatalf("could not request opt_list_meta_context: %s", err) } - if r != count || r < 1 || !seen { + if r != list_count || r < 1 || !list_seen { t.Fatalf("unexpected count after opt_list_meta_context") } - max := count + max := list_count /* Second pass: bogus query has no response. */ - count = 0 - seen = false + list_count = 0 + list_seen = false err = h.AddMetaContext("x-nosuch:") if err != nil { t.Fatalf("could not request add_meta_context: %s", err) @@ -85,13 +85,13 @@ func Test240OptListMeta(t *testing.T) { if err != nil { t.Fatalf("could not request opt_list_meta_context: %s", err) } - if r != 0 || r != count || seen { + if r != 0 || r != list_count || list_seen { t.Fatalf("unexpected count after opt_list_meta_context") } /* Third pass: specific query should have one match. */ - count = 0 - seen = false + list_count = 0 + list_seen = false err = h.AddMetaContext(context_base_allocation) if err != nil { t.Fatalf("could not request add_meta_context: %s", err) @@ -116,13 +116,13 @@ func Test240OptListMeta(t *testing.T) { if err != nil { t.Fatalf("could not request opt_list_meta_context: %s", err) } - if r != 1 || r != count || !seen { + if r != 1 || r != list_count || !list_seen { t.Fatalf("unexpected count after opt_list_meta_context") } /* Final pass: "base:" query should get at least "base:allocation" */ - count = 0 - seen = false + list_count = 0 + list_seen = false err = h.ClearMetaContexts() if err != nil { t.Fatalf("could not request clear_meta_contexts: %s", err) @@ -137,7 +137,7 @@ func Test240OptListMeta(t *testing.T) { if err != nil { t.Fatalf("could not request opt_list_meta_context: %s", err) } - if r < 1 || r > max || r != count || !seen { + if r < 1 || r > max || r != list_count || !list_seen { t.Fatalf("unexpected count after opt_list_meta_context") } @@ -178,8 +178,8 @@ func Test240OptListMeta(t *testing.T) { t.Fatalf("could not collect stats: %s", err) } - count = 0 - seen = false + list_count = 0 + list_seen = false r, err = h.OptListMetaContext(func(name string) int { return listmetaf(42, name) }) @@ -192,7 +192,7 @@ func Test240OptListMeta(t *testing.T) { t.Fatalf("unexpected bytes sent after opt_list_meta_context") } fmt.Printf("ignoring failure from old server: %s", err) - } else if r < 1 || r != count || !seen { + } else if r < 1 || r != list_count || !list_seen { t.Fatalf("unexpected count after opt_list_meta_context") } diff --git a/golang/libnbd_245_opt_list_meta_queries_test.go b/golang/libnbd_245_opt_list_meta_queries_test.go new file mode 100644 index 00000000..1a1f0bfb --- /dev/null +++ b/golang/libnbd_245_opt_list_meta_queries_test.go @@ -0,0 +1,115 @@ +/* libnbd golang tests + * Copyright (C) 2013-2022 Red Hat Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package libnbd + +import "testing" + +var listq_count uint +var listq_seen bool + +func listmetaqf(user_data int, name string) int { + if user_data != 42 { + panic("expected user_data == 42") + } + listq_count++ + if (name == context_base_allocation) { + listq_seen = true + } + return 0 +} + +func Test245OptListMetaQueries(t *testing.T) { + /* Get into negotiating state. */ + h, err := Create() + if err != nil { + t.Fatalf("could not create handle: %s", err) + } + defer h.Close() + + err = h.SetOptMode(true) + if err != nil { + t.Fatalf("could not set opt mode: %s", err) + } + + err = h.ConnectCommand([]string{ + "nbdkit", "-s", "--exit-with-parent", "-v", + "memory", "size=1M", + }) + if err != nil { + t.Fatalf("could not connect: %s", err) + } + + /* First pass: empty query should give at least "base:allocation". + * The explicit query overrides a non-empty nbd_add_meta_context. + */ + listq_count = 0 + listq_seen = false + err = h.AddMetaContext("x-nosuch:") + if err != nil { + t.Fatalf("could not request add_meta_context: %s", err) + } + r, err := h.OptListMetaContextQueries([]string{ }, + func(name string) int { + return listmetaqf(42, name) + }) + if err != nil { + t.Fatalf("could not request opt_list_meta_context_queries: %s", err) + } + if r != listq_count || r < 1 || !listq_seen { + t.Fatalf("unexpected count after opt_list_meta_context_queries") + } + + /* Second pass: bogus query has no response. */ + listq_count = 0 + listq_seen = false + err = h.ClearMetaContexts() + if err != nil { + t.Fatalf("could not request add_meta_context: %s", err) + } + r, err = h.OptListMetaContextQueries([]string{ "x-nosuch:" }, + func(name string) int { + return listmetaqf(42, name) + }) + if err != nil { + t.Fatalf("could not request opt_list_meta_context_queries: %s", err) + } + if r != 0 || r != listq_count || listq_seen { + t.Fatalf("unexpected count after opt_list_meta_context_queries") + } + + /* Third pass: specific query should have one match. */ + listq_count = 0 + listq_seen = false + r, err = h.OptListMetaContextQueries([]string{ + "x-nosuch:", context_base_allocation }, + func(name string) int { + return listmetaqf(42, name) + }) + if err != nil { + t.Fatalf("could not request opt_list_meta_context_queries: %s", err) + } + if r != 1 || r != listq_count || !listq_seen { + t.Fatalf("unexpected count after opt_list_meta_context_queries") + } + + err = h.OptAbort() + if err != nil { + t.Fatalf("could not request opt_abort: %s", err) + } +} -- 2.37.3

As promised in the previous patch, also test the new nbd_set_request_meta_context() API in Python, OCaml, and Golang. No direct C counterpart in tests/, but it's always good to check that our language bindings are complete. Acked-by: Laszlo Ersek <lersek(a)redhat.com&gt; --- python/t/110-defaults.py | 1 + python/t/120-set-non-defaults.py | 2 + python/t/230-opt-info.py | 25 +++++- ocaml/tests/test_110_defaults.ml | 2 + ocaml/tests/test_120_set_non_defaults.ml | 3 + ocaml/tests/test_230_opt_info.ml | 32 +++++++- golang/libnbd_110_defaults_test.go | 8 ++ golang/libnbd_120_set_non_defaults_test.go | 12 +++ golang/libnbd_230_opt_info_test.go | 88 ++++++++++++++++++++-- 9 files changed, 161 insertions(+), 12 deletions(-) diff --git a/python/t/110-defaults.py b/python/t/110-defaults.py index 749c94f4..6b62c8a4 100644 --- a/python/t/110-defaults.py +++ b/python/t/110-defaults.py @@ -22,6 +22,7 @@ assert h.get_full_info() is False assert h.get_tls() == nbd.TLS_DISABLE assert h.get_request_structured_replies() is True +assert h.get_request_meta_context() is True assert h.get_request_block_size() is True assert h.get_pread_initialize() is True assert h.get_handshake_flags() == nbd.HANDSHAKE_FLAG_MASK diff --git a/python/t/120-set-non-defaults.py b/python/t/120-set-non-defaults.py index 61a4160c..8b48b4ad 100644 --- a/python/t/120-set-non-defaults.py +++ b/python/t/120-set-non-defaults.py @@ -33,6 +33,8 @@ assert h.get_tls() == nbd.TLS_ALLOW h.set_request_structured_replies(False) assert h.get_request_structured_replies() is False +h.set_request_meta_context(False) +assert h.get_request_meta_context() is False h.set_request_block_size(False) assert h.get_request_block_size() is False h.set_pread_initialize(False) diff --git a/python/t/230-opt-info.py b/python/t/230-opt-info.py index 5e571376..c326bc30 100644 --- a/python/t/230-opt-info.py +++ b/python/t/230-opt-info.py @@ -52,12 +52,14 @@ def must_fail(f, *args, **kwds): must_fail(h.is_read_only) must_fail(h.can_meta_context, nbd.CONTEXT_BASE_ALLOCATION) -# info for a different export +# info for a different export, with automatic meta_context disabled h.set_export_name("b") +h.set_request_meta_context(False) h.opt_info() assert h.get_size() == 1 assert h.is_read_only() is False -assert h.can_meta_context(nbd.CONTEXT_BASE_ALLOCATION) is True +must_fail(h.can_meta_context, nbd.CONTEXT_BASE_ALLOCATION) +h.set_request_meta_context(True) # go on something not present h.set_export_name("a") @@ -78,5 +80,24 @@ def must_fail(f, *args, **kwds): assert h.get_export_name() == "good" must_fail(h.opt_info) assert h.get_size() == 4 +assert h.can_meta_context(nbd.CONTEXT_BASE_ALLOCATION) is True + +h.shutdown() + +# Another connection. This time, check that SET_META triggered by opt_info +# persists through nbd_opt_go with set_request_meta_context disabled. +h = nbd.NBD() +h.set_opt_mode(True) +h.connect_command(["nbdkit", "-s", "--exit-with-parent", "-v", "sh", script]) +h.add_meta_context("x-unexpected:bogus") + +must_fail(h.can_meta_context, nbd.CONTEXT_BASE_ALLOCATION) +h.opt_info() +assert h.can_meta_context(nbd.CONTEXT_BASE_ALLOCATION) is False +h.set_request_meta_context(False) +# Adding to the request list now won't matter +h.add_meta_context(nbd.CONTEXT_BASE_ALLOCATION) +h.opt_go() +assert h.can_meta_context(nbd.CONTEXT_BASE_ALLOCATION) is False h.shutdown() diff --git a/ocaml/tests/test_110_defaults.ml b/ocaml/tests/test_110_defaults.ml index ccec9c6d..768ad636 100644 --- a/ocaml/tests/test_110_defaults.ml +++ b/ocaml/tests/test_110_defaults.ml @@ -28,6 +28,8 @@ let assert (tls = NBD.TLS.DISABLE); let sr = NBD.get_request_structured_replies nbd in assert sr; + let meta = NBD.get_request_meta_context nbd in + assert meta; let bs = NBD.get_request_block_size nbd in assert bs; let init = NBD.get_pread_initialize nbd in diff --git a/ocaml/tests/test_120_set_non_defaults.ml b/ocaml/tests/test_120_set_non_defaults.ml index 092287e3..76ff82fb 100644 --- a/ocaml/tests/test_120_set_non_defaults.ml +++ b/ocaml/tests/test_120_set_non_defaults.ml @@ -42,6 +42,9 @@ let NBD.set_request_structured_replies nbd false; let sr = NBD.get_request_structured_replies nbd in assert (not sr); + NBD.set_request_meta_context nbd false; + let meta = NBD.get_request_meta_context nbd in + assert (not meta); NBD.set_request_block_size nbd false; let bs = NBD.get_request_block_size nbd in assert (not bs); diff --git a/ocaml/tests/test_230_opt_info.ml b/ocaml/tests/test_230_opt_info.ml index 693a6630..ec735ff1 100644 --- a/ocaml/tests/test_230_opt_info.ml +++ b/ocaml/tests/test_230_opt_info.ml @@ -69,15 +69,16 @@ let fail_unary NBD.is_read_only nbd; fail_binary NBD.can_meta_context nbd NBD.context_base_allocation; - (* info for a different export *) + (* info for a different export, with automatic meta_context disabled *) NBD.set_export_name nbd "b"; + NBD.set_request_meta_context nbd false; NBD.opt_info nbd; let size = NBD.get_size nbd in assert (size = 1L); let ro = NBD.is_read_only nbd in assert (not ro); - let meta = NBD.can_meta_context nbd NBD.context_base_allocation in - assert meta; + fail_binary NBD.can_meta_context nbd NBD.context_base_allocation; + NBD.set_request_meta_context nbd true; (* go on something not present *) NBD.set_export_name nbd "a"; @@ -103,6 +104,31 @@ let fail_unary NBD.opt_info nbd; let size = NBD.get_size nbd in assert (size = 4L); + let meta = NBD.can_meta_context nbd NBD.context_base_allocation in + assert meta; + + NBD.shutdown nbd; + + (* Another connection. This time, check that SET_META triggered by opt_info + * persists through nbd_opt_go with set_request_meta_context disabled. + *) + let nbd = NBD.create () in + NBD.set_opt_mode nbd true; + NBD.connect_command nbd + ["nbdkit"; "-s"; "--exit-with-parent"; "-v"; + "sh"; script]; + NBD.add_meta_context nbd "x-unexpected:bogus"; + + fail_binary NBD.can_meta_context nbd NBD.context_base_allocation; + NBD.opt_info nbd; + let meta = NBD.can_meta_context nbd NBD.context_base_allocation in + assert (not meta); + NBD.set_request_meta_context nbd false; + (* Adding to the request list now won't matter *) + NBD.add_meta_context nbd NBD.context_base_allocation; + NBD.opt_go nbd; + let meta = NBD.can_meta_context nbd NBD.context_base_allocation in + assert (not meta); NBD.shutdown nbd diff --git a/golang/libnbd_110_defaults_test.go b/golang/libnbd_110_defaults_test.go index f56c9656..d7ad319c 100644 --- a/golang/libnbd_110_defaults_test.go +++ b/golang/libnbd_110_defaults_test.go @@ -59,6 +59,14 @@ func Test110Defaults(t *testing.T) { t.Fatalf("unexpected structured replies state") } + meta, err := h.GetRequestMetaContext() + if err != nil { + t.Fatalf("could not get meta context state: %s", err) + } + if meta != true { + t.Fatalf("unexpected meta context state") + } + bs, err := h.GetRequestBlockSize() if err != nil { t.Fatalf("could not get block size state: %s", err) diff --git a/golang/libnbd_120_set_non_defaults_test.go b/golang/libnbd_120_set_non_defaults_test.go index a4c411d0..06bb29d5 100644 --- a/golang/libnbd_120_set_non_defaults_test.go +++ b/golang/libnbd_120_set_non_defaults_test.go @@ -93,6 +93,18 @@ func Test120SetNonDefaults(t *testing.T) { t.Fatalf("unexpected structured replies state") } + err = h.SetRequestMetaContext(false) + if err != nil { + t.Fatalf("could not set meta context state: %s", err) + } + meta, err := h.GetRequestMetaContext() + if err != nil { + t.Fatalf("could not get meta context state: %s", err) + } + if meta != false { + t.Fatalf("unexpected meta context state") + } + err = h.SetRequestBlockSize(false) if err != nil { t.Fatalf("could not set block size state: %s", err) diff --git a/golang/libnbd_230_opt_info_test.go b/golang/libnbd_230_opt_info_test.go index 3dd231a7..bc4cadfb 100644 --- a/golang/libnbd_230_opt_info_test.go +++ b/golang/libnbd_230_opt_info_test.go @@ -1,5 +1,5 @@ /* libnbd golang tests - * Copyright (C) 2013-2021 Red Hat Inc. + * Copyright (C) 2013-2022 Red Hat Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -113,11 +113,15 @@ func Test230OptInfo(t *testing.T) { t.Fatalf("expected error") } - /* info for a different export */ + /* info for a different export, with automatic meta_context disabled */ err = h.SetExportName("b") if err != nil { t.Fatalf("set export name failed unexpectedly: %s", err) } + err = h.SetRequestMetaContext(false) + if err != nil { + t.Fatalf("set request meta context failed unexpectedly: %s", err) + } err = h.OptInfo() if err != nil { t.Fatalf("opt_info failed unexpectedly: %s", err) @@ -136,12 +140,13 @@ func Test230OptInfo(t *testing.T) { if ro { t.Fatalf("unexpected readonly") } - meta, err = h.CanMetaContext(context_base_allocation) - if err != nil { - t.Fatalf("can_meta failed unexpectedly: %s", err) + _, err = h.CanMetaContext(context_base_allocation) + if err == nil { + t.Fatalf("expected error") } - if !meta { - t.Fatalf("unexpected meta context") + err = h.SetRequestMetaContext(true) + if err != nil { + t.Fatalf("set request meta context failed unexpectedly: %s", err) } /* go on something not present */ @@ -220,6 +225,75 @@ func Test230OptInfo(t *testing.T) { if size != 4 { t.Fatalf("unexpected size") } + meta, err = h.CanMetaContext(context_base_allocation) + if err != nil { + t.Fatalf("can_meta failed unexpectedly: %s", err) + } + if !meta { + t.Fatalf("unexpected meta context") + } + + h.Shutdown(nil) + + /* Another cnonection. This time, check that SET_META triggered by OptInfo + * persists through OptGo with SetRequestMetaContext disabled. + */ + h, err = Create() + if err != nil { + t.Fatalf("could not create handle: %s", err) + } + defer h.Close() + + err = h.SetOptMode(true) + if err != nil { + t.Fatalf("could not set opt mode: %s", err) + } + err = h.ConnectCommand([]string{ + "nbdkit", "-s", "--exit-with-parent", "-v", "sh", script, + }) + if err != nil { + t.Fatalf("could not connect: %s", err) + } + err = h.AddMetaContext("x-unexpected:bogus") + if err != nil { + t.Fatalf("could not add meta context: %s", err) + } + + _, err = h.CanMetaContext(context_base_allocation) + if err == nil { + t.Fatalf("expected error") + } + err = h.OptInfo() + if err != nil { + t.Fatalf("opt_info failed unexpectedly: %s", err) + } + meta, err = h.CanMetaContext(context_base_allocation) + if err != nil { + t.Fatalf("can_meta failed unexpectedly: %s", err) + } + if meta { + t.Fatalf("unexpected meta context") + } + err = h.SetRequestMetaContext(false) + if err != nil { + t.Fatalf("set request meta context failed unexpectedly: %s", err) + } + /* Adding to the request list now won't matter */ + err = h.AddMetaContext(context_base_allocation) + if err != nil { + t.Fatalf("could not add meta context: %s", err) + } + err = h.OptGo() + if err != nil { + t.Fatalf("opt_go failed unexpectedly: %s", err) + } + meta, err = h.CanMetaContext(context_base_allocation) + if err != nil { + t.Fatalf("can_meta failed unexpectedly: %s", err) + } + if meta { + t.Fatalf("unexpected meta context") + } h.Shutdown(nil) } -- 2.37.3

Since NBD_OPT_LIST_META_CONTEXTS is stateless from the server's point of view, there is no reason to make it clear state on the client's side. A previous patch already fixed it to not wipe h->meta_contexts for NBD_OPT_LIST_META_CONTEXTS (since that tracks the server state affected only by NBD_OPT_SET_META_CONTEXTS); but we were still wiping h->exportsize and friends. Better is to wipe size information only if we actually enter NEWSTYLE.OPT_GO.START to attempt NBD_OPT_GO or NBD_OPT_INFO. This change will also help when a future patch adds nbd_opt_set_meta_context() as another API that wants to modify h->meta_contexts but not h->exportsize. Testsuite coverage for this is in the next patch, for ease of review (that is, this is one case where it is easy to swap the patch order to see a failure fixed by this patch). --- generator/states-newstyle-opt-go.c | 1 + generator/states-newstyle-opt-meta-context.c | 5 ++--- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/generator/states-newstyle-opt-go.c b/generator/states-newstyle-opt-go.c index 3c29137d..9881d0f2 100644 --- a/generator/states-newstyle-opt-go.c +++ b/generator/states-newstyle-opt-go.c @@ -22,6 +22,7 @@ STATE_MACHINE { NEWSTYLE.OPT_GO.START: uint16_t nrinfos = 0; + nbd_internal_reset_size_and_flags (h); if (h->request_block_size) nrinfos++; if (h->full_info) diff --git a/generator/states-newstyle-opt-meta-context.c b/generator/states-newstyle-opt-meta-context.c index 5dc7e9ad..e124d06f 100644 --- a/generator/states-newstyle-opt-meta-context.c +++ b/generator/states-newstyle-opt-meta-context.c @@ -35,16 +35,15 @@ NEWSTYLE.OPT_META_CONTEXT.START: * nbd_opt_list_meta_context() * -> unconditionally use LIST, next state NEGOTIATING * - * For now, we start by unconditionally clearing h->exportsize and friends. * If SET is conditional, we skip it if h->request_meta is false, if * structured replies were not negotiated, or if no contexts to request. - * SET then manipulates h->meta_contexts, and sets h->meta_valid on success. + * SET then manipulates h->meta_contexts, and sets h->meta_valid on + * success, while LIST is stateless. * If OPT_GO is later successful, it populates h->exportsize and friends, * and also sets h->meta_valid if h->request_meta but we skipped SET here. * There is a callback if and only if the command is LIST. */ assert (h->gflags & LIBNBD_HANDSHAKE_FLAG_FIXED_NEWSTYLE); - nbd_internal_reset_size_and_flags (h); if (h->opt_current == NBD_OPT_LIST_META_CONTEXT) { assert (h->opt_mode); assert (CALLBACK_IS_NOT_NULL (h->opt_cb.fn.context)); -- 2.37.3

On Mon, Sep 26, 2022 at 05:05:55PM -0500, Eric Blake wrote: Reviewed-by: Richard W.M. Jones <rjones(a)redhat.com&gt; Rich. -- Richard Jones, Virtualization Group, Red Hat http://people.redhat.com/~rjones Read my programming and virtualization blog: http://rwmj.wordpress.com virt-top is 'top' for virtual machines. Tiny program with many powerful monitoring features, net stats, disk stats, logging, etc. http://people.redhat.com/~rjones/virt-top

On Mon, Sep 26, 2022 at 05:05:56PM -0500, Eric Blake wrote: [...] While looking at this, I found this which seems like it may be wrong (lib/opt.c): /* Issue NBD_OPT_INFO and wait for the reply. */ int nbd_unlocked_opt_info (struct nbd_handle *h) ... r = wait_for_option (h); if (r == 0 && err) { assert (nbd_internal_is_state_negotiating (get_next_state (h)) || nbd_internal_is_state_dead (get_next_state (h))); set_error (err, "server replied with error to opt_info request"); I believe that r == 0 && err != 0 => the callback set *err; in which case the error message is wrong? Rich. -- Richard Jones, Virtualization Group, Red Hat http://people.redhat.com/~rjones Read my programming and virtualization blog: http://rwmj.wordpress.com libguestfs lets you edit virtual machines. Supports shell scripting, bindings from many languages. http://libguestfs.org

Make it possible for the client to choose when to manually request meta contexts when using nbd_set_opt_mode(). By itself, this patch allows us to test how a server reacts to NBD_OPT_SET_META_CONTEXT without a previous negotiation of structured headers; then an upcoming patch will also add APIs for choosing when to negotiate OPT_STARTTLS and OPT_STRUCTURED_REPLY for even more fine-grained testing control. Most users won't need this API (the automatic defaults are good enough), but when writing a server, this level of integration testing can be useful. Similar to the existing nbd_opt_list_meta_context API, also offer a variant that takes an explicit query list. As this is a new API, the unit test in C is included in this patch; there is no point in splitting it as reordering the patches would not compile. However, porting the tests to other languages will be done in the next commit. --- generator/API.ml | 207 +++++++++++++++- generator/states-newstyle-opt-meta-context.c | 39 ++-- generator/states-newstyle.c | 1 + lib/opt.c | 70 +++++- tests/Makefile.am | 14 ++ tests/opt-set-meta-queries.c | 149 ++++++++++++ tests/opt-set-meta.c | 234 +++++++++++++++++++ .gitignore | 2 + 8 files changed, 690 insertions(+), 26 deletions(-) create mode 100644 tests/opt-set-meta-queries.c create mode 100644 tests/opt-set-meta.c diff --git a/generator/API.ml b/generator/API.ml index 0f70dcd1..9ffe6516 100644 --- a/generator/API.ml +++ b/generator/API.ml @@ -845,17 +845,20 @@ "set_request_meta_context", { is true; however the extra step of negotiating meta contexts is not always desirable: performing both info and go on the same export works without needing to re-negotiate contexts on the -second call; and even when using just L<nbd_opt_info(3)>, it -can be faster to collect the server's results by relying on the -callback function passed to L<nbd_opt_list_meta_context(3)> than -a series of post-process calls to L<nbd_can_meta_context(3)>. +second call; integration testing of other servers may benefit +from manual invocation of L<nbd_opt_set_meta_context(3)> at +other times in the negotiation sequence; and even when using just +L<nbd_opt_info(3)>, it can be faster to collect the server's +results by relying on the callback function passed to +L<nbd_opt_list_meta_context(3)> than a series of post-process +calls to L<nbd_can_meta_context(3)>. Note that this control has no effect if the server does not negotiate structured replies, or if the client did not request any contexts via L<nbd_add_meta_context(3)>. Setting this control to false may cause L<nbd_block_status(3)> to fail."; see_also = [Link "set_opt_mode"; Link "opt_go"; Link "opt_info"; - Link "opt_list_meta_context"; + Link "opt_list_meta_context"; Link "opt_set_meta_context"; Link "get_structured_replies_negotiated"; Link "get_request_meta_context"; Link "can_meta_context"]; }; @@ -1095,6 +1098,7 @@ "set_opt_mode", { see_also = [Link "get_opt_mode"; Link "aio_is_negotiating"; Link "opt_abort"; Link "opt_go"; Link "opt_list"; Link "opt_info"; Link "opt_list_meta_context"; + Link "opt_set_meta_context"; Link "aio_connect"]; }; @@ -1121,7 +1125,9 @@ "opt_go", { By default, libnbd will automatically request all meta contexts registered by L<nbd_add_meta_context(3)> as part of this call; but -this can be suppressed with L<nbd_set_request_meta_context(3)>. +this can be suppressed with L<nbd_set_request_meta_context(3)>, +particularly if L<nbd_opt_set_meta_context(3)> was used earlier +in the negotiation sequence. If this fails, the server may still be in negotiation, where it is possible to attempt another option such as a different export name; @@ -1129,7 +1135,8 @@ "opt_go", { example = Some "examples/list-exports.c"; see_also = [Link "set_opt_mode"; Link "aio_opt_go"; Link "opt_abort"; Link "set_export_name"; Link "connect_uri"; Link "opt_info"; - Link "add_meta_context"; Link "set_request_meta_context"]; + Link "add_meta_context"; Link "set_request_meta_context"; + Link "opt_set_meta_context"]; }; "opt_abort", { @@ -1268,7 +1275,8 @@ "opt_list_meta_context", { see_also = [Link "set_opt_mode"; Link "aio_opt_list_meta_context"; Link "opt_list_meta_context_queries"; Link "add_meta_context"; Link "clear_meta_contexts"; - Link "opt_go"; Link "set_export_name"]; + Link "opt_go"; Link "set_export_name"; + Link "opt_set_meta_context"]; }; "opt_list_meta_context_queries", { @@ -1321,6 +1329,118 @@ "opt_list_meta_context_queries", { Link "opt_go"; Link "set_export_name"]; }; + "opt_set_meta_context", { + default_call with + args = [ Closure context_closure ]; ret = RInt; + permitted_states = [ Negotiating ]; + shortdesc = "select specific meta contexts, using implicit query list"; + longdesc = "\ +Request that the server supply all recognized meta contexts +registered through prior calls to L<nbd_add_meta_context(3)>, in +conjunction with the export previously specified by the most +recent L<nbd_set_export_name(3)> or L<nbd_connect_uri(3)>. +This can only be used if L<nbd_set_opt_mode(3)> enabled option +mode. Normally, this function is redundant, as L<nbd_opt_go(3)> +automatically does the same task if structured replies have +already been negotiated. But manual control over meta context +requests can be useful for fine-grained testing of how a server +handles unusual negotiation sequences. Often, use of this +function is coupled with L<nbd_set_request_meta_context(3)> to +bypass the automatic context request normally performed by +L<nbd_opt_go(3)>. + +The NBD protocol allows a client to decide how many queries to ask +the server. Rather than taking that list of queries as a parameter +to this function, libnbd reuses the current list of requested meta +contexts as set by L<nbd_add_meta_context(3)>; you can use +L<nbd_clear_meta_contexts(3)> to set up a different list of queries +(see L<nbd_opt_set_meta_context_queries(3)> to pass an explicit +list of contexts instead). Since this function is primarily +designed for testing servers, libnbd does not prevent the use +of this function on an empty list or when +L<nbd_set_request_structured_replies(3)> has disabled structured +replies, in order to see how a server behaves. + +The C<context> function is called once per server reply, with any +C<user_data> passed to this function, and with C<name> supplied by +the server. Additionally, each server name will remain visible through +L<nbd_can_meta_context(3)> until the next attempt at +L<nbd_set_export_name(3)> or L<nbd_opt_set_meta_context(3)>, as +well as L<nbd_opt_go(3)> or L<nbd_opt_info(3)> that trigger an +automatic meta context request. Remember that it is not safe to +call any C<nbd_*> APIs from within the context of the callback +function. At present, the return value of the callback is +ignored, although a return of -1 should be avoided. + +For convenience, when this function succeeds, it returns the number +of replies returned by the server. + +Not all servers understand this request, and even when it is understood, +the server might intentionally send an empty list because it does not +support the requested context, or may encounter a failure after +delivering partial results. Thus, this function may succeed even when +no contexts are reported, or may fail but have a non-empty list."; + see_also = [Link "set_opt_mode"; Link "aio_opt_set_meta_context"; + Link "add_meta_context"; Link "clear_meta_contexts"; + Link "opt_set_meta_context_queries"; + Link "opt_go"; Link "set_export_name"; + Link "opt_list_meta_context"; Link "set_request_meta_context"; + Link "can_meta_context"]; + }; + + "opt_set_meta_context_queries", { + default_call with + args = [ StringList "queries"; Closure context_closure ]; ret = RInt; + permitted_states = [ Negotiating ]; + shortdesc = "select specific meta contexts, using explicit query list"; + longdesc = "\ +Request that the server supply all recognized meta contexts +passed in through C<queries>, in conjunction with the export +previously specified by the most recent L<nbd_set_export_name(3)> +or L<nbd_connect_uri(3)>. This can only be used if +L<nbd_set_opt_mode(3)> enabled option mode. Normally, this +function is redundant, as L<nbd_opt_go(3)> automatically does +the same task if structured replies have already been +negotiated. But manual control over meta context requests can +be useful for fine-grained testing of how a server handles +unusual negotiation sequences. Often, use of this function is +coupled with L<nbd_set_request_meta_context(3)> to bypass the +automatic context request normally performed by L<nbd_opt_go(3)>. + +The NBD protocol allows a client to decide how many queries to ask +the server. This function takes an explicit list of queries; to +instead reuse an implicit list, see L<nbd_opt_set_meta_context(3)>. +Since this function is primarily designed for testing servers, +libnbd does not prevent the use of this function on an empty +list or when L<nbd_set_request_structured_replies(3)> has +disabled structured replies, in order to see how a server behaves. + +The C<context> function is called once per server reply, with any +C<user_data> passed to this function, and with C<name> supplied by +the server. Additionally, each server name will remain visible through +L<nbd_can_meta_context(3)> until the next attempt at +L<nbd_set_export_name(3)> or L<nbd_opt_set_meta_context(3)>, as +well as L<nbd_opt_go(3)> or L<nbd_opt_info(3)> that trigger an +automatic meta context request. Remember that it is not safe to +call any C<nbd_*> APIs from within the context of the callback +function. At present, the return value of the callback is +ignored, although a return of -1 should be avoided. + +For convenience, when this function succeeds, it returns the number +of replies returned by the server. + +Not all servers understand this request, and even when it is understood, +the server might intentionally send an empty list because it does not +support the requested context, or may encounter a failure after +delivering partial results. Thus, this function may succeed even when +no contexts are reported, or may fail but have a non-empty list."; + see_also = [Link "set_opt_mode"; Link "aio_opt_set_meta_context_queries"; + Link "opt_set_meta_context"; + Link "opt_go"; Link "set_export_name"; + Link "opt_list_meta_context_queries"; + Link "set_request_meta_context"; Link "can_meta_context"]; + }; + "add_meta_context", { default_call with args = [ String "name" ]; ret = RErr; @@ -1999,7 +2119,7 @@ "can_meta_context", { see_also = [SectionLink "Flag calls"; Link "opt_info"; Link "add_meta_context"; Link "block_status"; Link "aio_block_status"; - Link "set_request_meta_context"]; + Link "set_request_meta_context"; Link "opt_set_meta_context"]; }; "get_protocol", { @@ -2755,6 +2875,71 @@ "aio_opt_list_meta_context_queries", { Link "aio_opt_list_meta_context"]; }; + "aio_opt_set_meta_context", { + default_call with + args = [ Closure context_closure ]; ret = RInt; + optargs = [ OClosure completion_closure ]; + permitted_states = [ Negotiating ]; + shortdesc = "select specific meta contexts, with implicit query list"; + longdesc = "\ +Request that the server supply all recognized meta contexts +registered through prior calls to L<nbd_add_meta_context(3)>, in +conjunction with the export previously specified by the most +recent L<nbd_set_export_name(3)> or L<nbd_connect_uri(3)>. +This can only be used if L<nbd_set_opt_mode(3)> enabled option +mode. Normally, this function is redundant, as L<nbd_opt_go(3)> +automatically does the same task if structured replies have +already been negotiated. But manual control over meta context +requests can be useful for fine-grained testing of how a server +handles unusual negotiation sequences. Often, use of this +function is coupled with L<nbd_set_request_meta_context(3)> to +bypass the automatic context request normally performed by +L<nbd_opt_go(3)>. + +To determine when the request completes, wait for +L<nbd_aio_is_connecting(3)> to return false. Or supply the optional +C<completion_callback> which will be invoked as described in +L<libnbd(3)/Completion callbacks>, except that it is automatically +retired regardless of return value. Note that detecting whether the +server returns an error (as is done by the return value of the +synchronous counterpart) is only possible with a completion +callback."; + see_also = [Link "set_opt_mode"; Link "opt_set_meta_context"; + Link "aio_opt_set_meta_context_queries"]; + }; + + "aio_opt_set_meta_context_queries", { + default_call with + args = [ StringList "queries"; Closure context_closure ]; ret = RInt; + optargs = [ OClosure completion_closure ]; + permitted_states = [ Negotiating ]; + shortdesc = "select specific meta contexts, with explicit query list"; + longdesc = "\ +Request that the server supply all recognized meta contexts +passed in through C<queries>, in conjunction with the export +previously specified by the most recent L<nbd_set_export_name(3)> +or L<nbd_connect_uri(3)>. This can only be used +if L<nbd_set_opt_mode(3)> enabled option mode. Normally, this +function is redundant, as L<nbd_opt_go(3)> automatically does +the same task if structured replies have already been +negotiated. But manual control over meta context requests can +be useful for fine-grained testing of how a server handles +unusual negotiation sequences. Often, use of this function is +coupled with L<nbd_set_request_meta_context(3)> to bypass the +automatic context request normally performed by L<nbd_opt_go(3)>. + +To determine when the request completes, wait for +L<nbd_aio_is_connecting(3)> to return false. Or supply the optional +C<completion_callback> which will be invoked as described in +L<libnbd(3)/Completion callbacks>, except that it is automatically +retired regardless of return value. Note that detecting whether the +server returns an error (as is done by the return value of the +synchronous counterpart) is only possible with a completion +callback."; + see_also = [Link "set_opt_mode"; Link "opt_set_meta_context_queries"; + Link "aio_opt_set_meta_context"]; + }; + "aio_pread", { default_call with args = [ BytesPersistOut ("buf", "count"); UInt64 "offset" ]; @@ -3489,6 +3674,10 @@ let first_version = "aio_opt_list_meta_context_queries", (1, 16); "set_request_meta_context", (1, 16); "get_request_meta_context", (1, 16); + "opt_set_meta_context", (1, 16); + "opt_set_meta_context_queries", (1, 16); + "aio_opt_set_meta_context", (1, 16); + "aio_opt_set_meta_context_queries", (1, 16); (* These calls are proposed for a future version of libnbd, but * have not been added to any released version so far. diff --git a/generator/states-newstyle-opt-meta-context.c b/generator/states-newstyle-opt-meta-context.c index e124d06f..46fee15b 100644 --- a/generator/states-newstyle-opt-meta-context.c +++ b/generator/states-newstyle-opt-meta-context.c @@ -34,6 +34,8 @@ NEWSTYLE.OPT_META_CONTEXT.START: * -> conditionally use SET, next state OPT_GO for NBD_OPT_GO * nbd_opt_list_meta_context() * -> unconditionally use LIST, next state NEGOTIATING + * nbd_opt_set_meta_context() + * -> unconditionally use SET, next state NEGOTIATING * * If SET is conditional, we skip it if h->request_meta is false, if * structured replies were not negotiated, or if no contexts to request. @@ -41,7 +43,7 @@ NEWSTYLE.OPT_META_CONTEXT.START: * success, while LIST is stateless. * If OPT_GO is later successful, it populates h->exportsize and friends, * and also sets h->meta_valid if h->request_meta but we skipped SET here. - * There is a callback if and only if the command is LIST. + * There is a callback if and only if the command is unconditional. */ assert (h->gflags & LIBNBD_HANDSHAKE_FLAG_FIXED_NEWSTYLE); if (h->opt_current == NBD_OPT_LIST_META_CONTEXT) { @@ -50,9 +52,12 @@ NEWSTYLE.OPT_META_CONTEXT.START: opt = h->opt_current; } else { - assert (CALLBACK_IS_NULL (h->opt_cb.fn.context)); + if (h->opt_current == NBD_OPT_SET_META_CONTEXT) + assert (CALLBACK_IS_NOT_NULL (h->opt_cb.fn.context)); + else + assert (CALLBACK_IS_NULL (h->opt_cb.fn.context)); opt = NBD_OPT_SET_META_CONTEXT; - if (h->request_meta) { + if (h->request_meta || h->opt_current == opt) { for (i = 0; i < h->meta_contexts.len; ++i) free (h->meta_contexts.ptr[i].name); meta_vector_reset (&h->meta_contexts); @@ -215,15 +220,15 @@ NEWSTYLE.OPT_META_CONTEXT.CHECK_REPLY: len = be32toh (h->sbuf.or.option_reply.replylen); switch (reply) { case NBD_REP_ACK: /* End of list of replies. */ - if (opt == NBD_OPT_LIST_META_CONTEXT) { - SET_NEXT_STATE (%.NEGOTIATING); - CALL_CALLBACK (h->opt_cb.completion, &err); - nbd_internal_free_option (h); - } - else { - SET_NEXT_STATE (%^OPT_GO.START); + if (opt == NBD_OPT_SET_META_CONTEXT) h->meta_valid = true; + if (opt == h->opt_current) { + SET_NEXT_STATE (%.NEGOTIATING); + CALL_CALLBACK (h->opt_cb.completion, &err); + nbd_internal_free_option (h); } + else + SET_NEXT_STATE (%^OPT_GO.START); break; case NBD_REP_META_CONTEXT: /* A context. */ if (len > maxpayload) @@ -242,10 +247,10 @@ NEWSTYLE.OPT_META_CONTEXT.CHECK_REPLY: } debug (h, "negotiated %s with context ID %" PRIu32, meta_context.name, meta_context.context_id); - if (opt == NBD_OPT_LIST_META_CONTEXT) { + if (CALLBACK_IS_NOT_NULL (h->opt_cb.fn.context)) CALL_CALLBACK (h->opt_cb.fn.context, meta_context.name); + if (opt == NBD_OPT_LIST_META_CONTEXT) free (meta_context.name); - } else if (meta_vector_append (&h->meta_contexts, meta_context) == -1) { set_error (errno, "realloc"); free (meta_context.name); @@ -256,25 +261,27 @@ NEWSTYLE.OPT_META_CONTEXT.CHECK_REPLY: SET_NEXT_STATE (%PREPARE_FOR_REPLY); break; default: - /* Anything else is an error, ignore it for SET, report it for LIST */ + /* Anything else is an error, report it for explicit LIST/SET, ignore it + * for automatic progress (nbd_connect_*, nbd_opt_info, nbd_opt_go). + */ if (handle_reply_error (h) == -1) { SET_NEXT_STATE (%.DEAD); return 0; } - if (opt == NBD_OPT_LIST_META_CONTEXT) { + if (opt == h->opt_current) { /* XXX Should we decode specific expected errors, like * REP_ERR_UNKNOWN to ENOENT or REP_ERR_TOO_BIG to ERANGE? */ err = ENOTSUP; set_error (err, "unexpected response, possibly the server does not " - "support listing contexts"); + "support meta contexts"); CALL_CALLBACK (h->opt_cb.completion, &err); nbd_internal_free_option (h); SET_NEXT_STATE (%.NEGOTIATING); } else { - debug (h, "handshake: unexpected error from " + debug (h, "handshake: ignoring unexpected error from " "NBD_OPT_SET_META_CONTEXT (%" PRIu32 ")", reply); SET_NEXT_STATE (%^OPT_GO.START); } diff --git a/generator/states-newstyle.c b/generator/states-newstyle.c index e84823e3..60e0bc50 100644 --- a/generator/states-newstyle.c +++ b/generator/states-newstyle.c @@ -140,6 +140,7 @@ NEWSTYLE.START: SET_NEXT_STATE (%PREPARE_OPT_ABORT); return 0; case NBD_OPT_LIST_META_CONTEXT: + case NBD_OPT_SET_META_CONTEXT: SET_NEXT_STATE (%OPT_META_CONTEXT.START); return 0; case 0: diff --git a/lib/opt.c b/lib/opt.c index cfdabb9e..ee036235 100644 --- a/lib/opt.c +++ b/lib/opt.c @@ -32,7 +32,8 @@ nbd_internal_free_option (struct nbd_handle *h) { if (h->opt_current == NBD_OPT_LIST) FREE_CALLBACK (h->opt_cb.fn.list); - else if (h->opt_current == NBD_OPT_LIST_META_CONTEXT) + else if (h->opt_current == NBD_OPT_LIST_META_CONTEXT || + h->opt_current == NBD_OPT_SET_META_CONTEXT) FREE_CALLBACK (h->opt_cb.fn.context); FREE_CALLBACK (h->opt_cb.completion); } @@ -224,6 +225,37 @@ nbd_unlocked_opt_list_meta_context_queries (struct nbd_handle *h, return s.count; } +/* Issue NBD_OPT_SET_META_CONTEXT and wait for the reply. */ +int +nbd_unlocked_opt_set_meta_context (struct nbd_handle *h, + nbd_context_callback *context) +{ + return nbd_unlocked_opt_set_meta_context_queries (h, NULL, context); +} + +/* Issue NBD_OPT_SET_META_CONTEXT and wait for the reply. */ +int +nbd_unlocked_opt_set_meta_context_queries (struct nbd_handle *h, + char **queries, + nbd_context_callback *context) +{ + struct context_helper s = { .context = *context }; + nbd_context_callback l = { .callback = context_visitor, .user_data = &s }; + nbd_completion_callback c = { .callback = context_complete, .user_data = &s }; + + if (nbd_unlocked_aio_opt_set_meta_context_queries (h, queries, &l, &c) == -1) + return -1; + + SET_CALLBACK_TO_NULL (*context); + if (wait_for_option (h) == -1) + return -1; + if (s.err) { + set_error (s.err, "server replied with error to set meta context request"); + return -1; + } + return s.count; +} + /* Issue NBD_OPT_GO (or NBD_OPT_EXPORT_NAME) without waiting. */ int nbd_unlocked_aio_opt_go (struct nbd_handle *h, @@ -324,3 +356,39 @@ nbd_unlocked_aio_opt_list_meta_context_queries (struct nbd_handle *h, debug (h, "option queued, ignoring state machine failure"); return 0; } + +/* Issue NBD_OPT_SET_META_CONTEXT without waiting. */ +int +nbd_unlocked_aio_opt_set_meta_context (struct nbd_handle *h, + nbd_context_callback *context, + nbd_completion_callback *complete) +{ + return nbd_unlocked_aio_opt_set_meta_context_queries (h, NULL, context, + complete); +} + +/* Issue NBD_OPT_SET_META_CONTEXT without waiting. */ +int +nbd_unlocked_aio_opt_set_meta_context_queries (struct nbd_handle *h, + char **queries, + nbd_context_callback *context, + nbd_completion_callback *complete) +{ + if ((h->gflags & LIBNBD_HANDSHAKE_FLAG_FIXED_NEWSTYLE) == 0) { + set_error (ENOTSUP, "server is not using fixed newstyle protocol"); + return -1; + } + + if (nbd_internal_set_querylist (h, queries) == -1) + return -1; + + assert (CALLBACK_IS_NULL (h->opt_cb.fn.context)); + h->opt_cb.fn.context = *context; + SET_CALLBACK_TO_NULL (*context); + h->opt_cb.completion = *complete; + SET_CALLBACK_TO_NULL (*complete); + h->opt_current = NBD_OPT_SET_META_CONTEXT; + if (nbd_internal_run (h, cmd_issue) == -1) + debug (h, "option queued, ignoring state machine failure"); + return 0; +} diff --git a/tests/Makefile.am b/tests/Makefile.am index dfb7f8bd..ec95495e 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -215,6 +215,8 @@ check_PROGRAMS += \ opt-info \ opt-list-meta \ opt-list-meta-queries \ + opt-set-meta \ + opt-set-meta-queries \ connect-systemd-socket-activation \ connect-unix \ connect-tcp \ @@ -282,6 +284,8 @@ TESTS += \ opt-info \ opt-list-meta \ opt-list-meta-queries \ + opt-set-meta \ + opt-set-meta-queries \ connect-systemd-socket-activation \ connect-unix \ connect-tcp \ @@ -543,6 +547,16 @@ opt_list_meta_LDADD = $(top_builddir)/lib/libnbd.la opt_list_meta_queries_SOURCES = opt-list-meta-queries.c opt_list_meta_queries_LDADD = $(top_builddir)/lib/libnbd.la +opt_set_meta_SOURCES = opt-set-meta.c +opt_set_meta_CPPFLAGS = \ + $(AM_CPPFLAGS) \ + -I$(top_srcdir)/common/include \ + $(NULL) +opt_set_meta_LDADD = $(top_builddir)/lib/libnbd.la + +opt_set_meta_queries_SOURCES = opt-set-meta-queries.c +opt_set_meta_queries_LDADD = $(top_builddir)/lib/libnbd.la + connect_systemd_socket_activation_SOURCES = \ connect-systemd-socket-activation.c \ requires.c \ diff --git a/tests/opt-set-meta-queries.c b/tests/opt-set-meta-queries.c new file mode 100644 index 00000000..0b162607 --- /dev/null +++ b/tests/opt-set-meta-queries.c @@ -0,0 +1,149 @@ +/* NBD client library in userspace + * Copyright (C) 2013-2022 Red Hat Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/* Test behavior of nbd_opt_set_meta_context_queries. */ + +#include <config.h> + +#include <stdio.h> +#include <stdlib.h> +#include <stdint.h> +#include <stdbool.h> +#include <inttypes.h> +#include <string.h> +#include <errno.h> + +#include <libnbd.h> + +struct progress { + int count; + bool seen; +}; + +static int +check (void *user_data, const char *name) +{ + struct progress *p = user_data; + + p->count++; + if (strcmp (name, LIBNBD_CONTEXT_BASE_ALLOCATION) == 0) + p->seen = true; + return 0; +} + +int +main (int argc, char *argv[]) +{ + struct nbd_handle *nbd; + int r; + struct progress p; + char *args[] = { "nbdkit", "-s", "--exit-with-parent", "-v", + "memory", "size=1M", NULL }; + nbd_context_callback ctx = { .callback = check, + .user_data = &p}; + + /* Get into negotiating state. */ + nbd = nbd_create (); + if (nbd == NULL || + nbd_set_opt_mode (nbd, true) == -1 || + nbd_connect_command (nbd, args) == -1) { + fprintf (stderr, "%s\n", nbd_get_error ()); + exit (EXIT_FAILURE); + } + + /* nbdkit does not match wildcard for SET, even though it does for LIST */ + p = (struct progress) { .count = 0 }; + { + char *base[] = { "base:", NULL }; + r = nbd_opt_set_meta_context_queries (nbd, base, ctx); + } + if (r == -1) { + fprintf (stderr, "%s\n", nbd_get_error ()); + exit (EXIT_FAILURE); + } + if (r != p.count || r != 0 || p.seen) { + fprintf (stderr, "inconsistent return value %d, expected %d\n", r, p.count); + exit (EXIT_FAILURE); + } + if ((r = nbd_can_meta_context (nbd, LIBNBD_CONTEXT_BASE_ALLOCATION)) != 0) { + fprintf (stderr, "can_meta_context got %d, expected 0\n", r); + exit (EXIT_FAILURE); + } + + /* Negotiating with no contexts is not an error, but selects nothing. + * An explicit empty list overrides a non-empty implicit list. + */ + if (nbd_add_meta_context (nbd, LIBNBD_CONTEXT_BASE_ALLOCATION) == -1) { + fprintf (stderr, "%s\n", nbd_get_error ()); + exit (EXIT_FAILURE); + } + p = (struct progress) { .count = 0 }; + { + char *empty[] = { NULL }; + r = nbd_opt_set_meta_context_queries (nbd, empty, ctx); + } + if (r == -1) { + fprintf (stderr, "%s\n", nbd_get_error ()); + exit (EXIT_FAILURE); + } + if (r != 0 || p.count || p.seen) { + fprintf (stderr, "expecting set_meta to select nothing\n"); + exit (EXIT_FAILURE); + } + if ((r = nbd_can_meta_context (nbd, LIBNBD_CONTEXT_BASE_ALLOCATION)) != 0) { + fprintf (stderr, "can_meta_context got %d, expected 0\n", r); + exit (EXIT_FAILURE); + } + + /* Request 2 with expectation of 1. */ + p = (struct progress) { .count = 0 }; + { + char *pair[] = { "x-nosuch:context", LIBNBD_CONTEXT_BASE_ALLOCATION, NULL }; + r = nbd_opt_set_meta_context_queries (nbd, pair, ctx); + } + if (r == -1) { + fprintf (stderr, "%s\n", nbd_get_error ()); + exit (EXIT_FAILURE); + } + if (r != 1 || p.count != 1 || !p.seen) { + fprintf (stderr, "expecting one context, got %d\n", r); + exit (EXIT_FAILURE); + } + if ((r = nbd_can_meta_context (nbd, LIBNBD_CONTEXT_BASE_ALLOCATION)) != 1) { + fprintf (stderr, "can_meta_context got %d, expected 1\n", r); + exit (EXIT_FAILURE); + } + + /* Transition to transmission phase with with set_request_meta_context off, + * our last set should remain active + */ + if (nbd_set_request_meta_context (nbd, 0) == -1 || + nbd_opt_go (nbd) == -1) { + fprintf (stderr, "%s\n", nbd_get_error ()); + exit (EXIT_FAILURE); + } + if ((r = nbd_can_meta_context (nbd, LIBNBD_CONTEXT_BASE_ALLOCATION)) != 1) { + fprintf (stderr, "can_meta_context got %d, expected 1\n", r); + exit (EXIT_FAILURE); + } + + nbd_shutdown (nbd, 0); + nbd_close (nbd); + + exit (EXIT_SUCCESS); +} diff --git a/tests/opt-set-meta.c b/tests/opt-set-meta.c new file mode 100644 index 00000000..95f5a6d7 --- /dev/null +++ b/tests/opt-set-meta.c @@ -0,0 +1,234 @@ +/* NBD client library in userspace + * Copyright (C) 2013-2022 Red Hat Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/* Test behavior of nbd_opt_set_meta_context. */ + +#include <config.h> + +#include <stdio.h> +#include <stdlib.h> +#include <stdint.h> +#include <stdbool.h> +#include <inttypes.h> +#include <string.h> +#include <errno.h> + +#include <libnbd.h> + +#include "array-size.h" + +struct progress { + int count; + bool seen; +}; + +static int +check (void *user_data, const char *name) +{ + struct progress *p = user_data; + + p->count++; + if (strcmp (name, LIBNBD_CONTEXT_BASE_ALLOCATION) == 0) + p->seen = true; + return 0; +} + +int +main (int argc, char *argv[]) +{ + struct nbd_handle *nbd; + int r; + struct progress p; + /* Leave room for --no-sr in second process */ + char *args[] = { "nbdkit", "-s", "--exit-with-parent", "-v", + "memory", "size=1M", NULL, NULL }; + + /* First process, with structured replies. Get into negotiating state. */ + nbd = nbd_create (); + if (nbd == NULL || + nbd_set_opt_mode (nbd, true) == -1 || + nbd_connect_command (nbd, args) == -1) { + fprintf (stderr, "%s\n", nbd_get_error ()); + exit (EXIT_FAILURE); + } + + /* No contexts negotiated yet; can_meta should be error if any requested */ + if ((r = nbd_get_structured_replies_negotiated (nbd)) != 1) { + fprintf (stderr, "structured replies got %d, expected 1\n", r); + exit (EXIT_FAILURE); + } + if ((r = nbd_can_meta_context (nbd, LIBNBD_CONTEXT_BASE_ALLOCATION)) != 0) { + fprintf (stderr, "can_meta_context got %d, expected 0\n", r); + exit (EXIT_FAILURE); + } + if (nbd_add_meta_context (nbd, LIBNBD_CONTEXT_BASE_ALLOCATION) == -1) { + fprintf (stderr, "%s\n", nbd_get_error ()); + exit (EXIT_FAILURE); + } + if ((r = nbd_can_meta_context (nbd, LIBNBD_CONTEXT_BASE_ALLOCATION)) != -1) { + fprintf (stderr, "can_meta_context got %d, expected -1\n", r); + exit (EXIT_FAILURE); + } + + /* FIXME: Once nbd_opt_structured_reply exists, check that set before + * SR fails server-side, then enable SR for rest of process. + */ + + /* nbdkit does not match wildcard for SET, even though it does for LIST */ + if (nbd_clear_meta_contexts (nbd) == -1 || + nbd_add_meta_context (nbd, "base:") == -1) { + fprintf (stderr, "%s\n", nbd_get_error ()); + exit (EXIT_FAILURE); + } + p = (struct progress) { .count = 0 }; + r = nbd_opt_set_meta_context (nbd, + (nbd_context_callback) { .callback = check, + .user_data = &p}); + if (r == -1) { + fprintf (stderr, "%s\n", nbd_get_error ()); + exit (EXIT_FAILURE); + } + if (r != p.count || r != 0 || p.seen) { + fprintf (stderr, "inconsistent return value %d, expected %d\n", r, p.count); + exit (EXIT_FAILURE); + } + if ((r = nbd_can_meta_context (nbd, LIBNBD_CONTEXT_BASE_ALLOCATION)) != 0) { + fprintf (stderr, "can_meta_context got %d, expected 0\n", r); + exit (EXIT_FAILURE); + } + + /* Negotiating with no contexts is not an error, but selects nothing */ + r = nbd_clear_meta_contexts (nbd); + if (r == -1) { + fprintf (stderr, "%s\n", nbd_get_error ()); + exit (EXIT_FAILURE); + } + p = (struct progress) { .count = 0 }; + r = nbd_opt_set_meta_context (nbd, + (nbd_context_callback) { .callback = check, + .user_data = &p}); + if (r == -1) { + fprintf (stderr, "%s\n", nbd_get_error ()); + exit (EXIT_FAILURE); + } + if (r != 0 || p.count || p.seen) { + fprintf (stderr, "expecting set_meta to select nothing\n"); + exit (EXIT_FAILURE); + } + if ((r = nbd_can_meta_context (nbd, LIBNBD_CONTEXT_BASE_ALLOCATION)) != 0) { + fprintf (stderr, "can_meta_context got %d, expected 0\n", r); + exit (EXIT_FAILURE); + } + + /* Request 2 with expectation of 1; with set_request_meta_context off */ + if (nbd_add_meta_context (nbd, "x-nosuch:context") == -1 || + nbd_add_meta_context (nbd, LIBNBD_CONTEXT_BASE_ALLOCATION) == -1 || + nbd_set_request_meta_context (nbd, 0) == -1) { + fprintf (stderr, "%s\n", nbd_get_error ()); + exit (EXIT_FAILURE); + } + p = (struct progress) { .count = 0 }; + r = nbd_opt_set_meta_context (nbd, + (nbd_context_callback) { .callback = check, + .user_data = &p}); + if (r == -1) { + fprintf (stderr, "%s\n", nbd_get_error ()); + exit (EXIT_FAILURE); + } + if (r != 1 || p.count != 1 || !p.seen) { + fprintf (stderr, "expecting one context, got %d\n", r); + exit (EXIT_FAILURE); + } + if ((r = nbd_can_meta_context (nbd, LIBNBD_CONTEXT_BASE_ALLOCATION)) != 1) { + fprintf (stderr, "can_meta_context got %d, expected 1\n", r); + exit (EXIT_FAILURE); + } + + /* Transition to transmission phase; our last set should remain active */ + if (nbd_clear_meta_contexts (nbd) == -1 || + nbd_add_meta_context (nbd, "x-nosuch:context") == -1 || + nbd_opt_go (nbd) == -1) { + fprintf (stderr, "%s\n", nbd_get_error ()); + exit (EXIT_FAILURE); + } + if ((r = nbd_can_meta_context (nbd, LIBNBD_CONTEXT_BASE_ALLOCATION)) != 1) { + fprintf (stderr, "can_meta_context got %d, expected 1\n", r); + exit (EXIT_FAILURE); + } + + /* Now too late to set; but should not lose earlier state */ + p = (struct progress) { .count = 0 }; + r = nbd_opt_set_meta_context (nbd, + (nbd_context_callback) { .callback = check, + .user_data = &p}); + if (r != -1 || p.count || p.seen) { + fprintf (stderr, "expecting set_meta failure\n"); + exit (EXIT_FAILURE); + } + if ((r = nbd_can_meta_context (nbd, LIBNBD_CONTEXT_BASE_ALLOCATION)) != 1) { + fprintf (stderr, "can_meta_context got %d, expected 1\n", r); + exit (EXIT_FAILURE); + } + + nbd_shutdown (nbd, 0); + nbd_close (nbd); + + /* Second process, this time without structured replies server-side. */ + args[ARRAY_SIZE (args) - 2] = (char *) "--no-sr"; + nbd = nbd_create (); + if (nbd == NULL || + nbd_set_opt_mode (nbd, true) == -1 || + nbd_add_meta_context (nbd, LIBNBD_CONTEXT_BASE_ALLOCATION) == -1 || + nbd_connect_command (nbd, args) == -1) { + fprintf (stderr, "%s\n", nbd_get_error ()); + exit (EXIT_FAILURE); + } + if ((r = nbd_get_structured_replies_negotiated (nbd)) != 0) { + fprintf (stderr, "structured replies got %d, expected 0\n", r); + exit (EXIT_FAILURE); + } + + /* Expect server-side failure here */ + p = (struct progress) { .count = 0 }; + r = nbd_opt_set_meta_context (nbd, + (nbd_context_callback) { .callback = check, + .user_data = &p}); + if (r != -1 || p.count || p.seen) { + fprintf (stderr, "expecting set_meta failure\n"); + exit (EXIT_FAILURE); + } + if ((r = nbd_can_meta_context (nbd, LIBNBD_CONTEXT_BASE_ALLOCATION)) != -1) { + fprintf (stderr, "can_meta_context got %d, expected -1\n", r); + exit (EXIT_FAILURE); + } + + /* Even though can_meta fails after failed SET, it returns 0 after go */ + if (nbd_opt_go (nbd) == -1) { + fprintf (stderr, "%s\n", nbd_get_error ()); + exit (EXIT_FAILURE); + } + if ((r = nbd_can_meta_context (nbd, LIBNBD_CONTEXT_BASE_ALLOCATION)) != 0) { + fprintf (stderr, "can_meta_context got %d, expected 0\n", r); + exit (EXIT_FAILURE); + } + + nbd_shutdown (nbd, 0); + nbd_close (nbd); + + exit (EXIT_SUCCESS); +} diff --git a/.gitignore b/.gitignore index 272d1ec1..50e4616e 100644 --- a/.gitignore +++ b/.gitignore @@ -234,6 +234,8 @@ Makefile.in /tests/opt-list /tests/opt-list-meta /tests/opt-list-meta-queries +/tests/opt-set-meta +/tests/opt-set-meta-queries /tests/pki/ /tests/pread-initialize /tests/private-data -- 2.37.3

Recent commits have lamented that we do not have a way to provoke atypical ordering of option negotiation during server integration testing. This commit adds nbd_opt_structured_reply() to make it possible to fine-tune when structured replies are requested, and fills in a couple of FIXME comments left in previous commits. The new API can be called more than once; the testsuite is also enhanced with a test that shows that nbdkit rejects the second attempt but libnbd still remembers the first one succeeded (this requires moving the wipe of h->structured_reply out of NBD_OPT_STRUCTURED_REPLY error handling, and instead putting it into NBD_OPT_STARTTLS success, which becomes important when a later patch adds nbd_opt_starttls()). The C test changes depend on a new API, so they can't reasonably be applied out of order. However, porting the FIXME changes of the testsuite to other language bindings will be done in the next patch, to ease review of this one. The test opt-structured-twice borders on being an integration test (in fact, nbdkit commit 9418ec58 [upcoming v1.34] changes nbdkit from accepting a second structured reply request to instead diagnosing it as redundant; both behaviors are compatible with the NBD spec), so that one will remain C only. --- generator/API.ml | 70 ++++++++- generator/states-newstyle-opt-starttls.c | 1 + .../states-newstyle-opt-structured-reply.c | 22 ++- generator/states-newstyle.c | 3 + lib/opt.c | 44 ++++++ tests/Makefile.am | 5 + tests/opt-list-meta.c | 29 +++- tests/opt-set-meta.c | 50 ++++-- tests/opt-structured-twice.c | 145 ++++++++++++++++++ .gitignore | 1 + 10 files changed, 347 insertions(+), 23 deletions(-) create mode 100644 tests/opt-structured-twice.c diff --git a/generator/API.ml b/generator/API.ml index 9ffe6516..1c9f890a 100644 --- a/generator/API.ml +++ b/generator/API.ml @@ -794,9 +794,12 @@ "set_request_structured_replies", { L<nbd_can_meta_context(3)> or L<nbd_can_df(3)> can return true. However, for integration testing, it can be useful to clear this flag rather than find a way to alter the server to fail the negotiation -request."; +request. It is also useful to set this to false prior to using +L<nbd_set_opt_mode(3)> if it is desired to control when to send +L<nbd_opt_structured_reply(3)> during negotiation."; see_also = [Link "get_request_structured_replies"; Link "set_handshake_flags"; Link "set_strict_mode"; + Link "opt_structured_reply"; Link "get_structured_replies_negotiated"; Link "can_meta_context"; Link "can_df"]; }; @@ -824,9 +827,12 @@ "get_structured_replies_negotiated", { shortdesc = "see if structured replies are in use"; longdesc = "\ After connecting you may call this to find out if the connection is -using structured replies."; +using structured replies. Note that this setting is sticky; this +can return true even after a second L<nbd_opt_structured_reply(3)> +returns false because the server detected a duplicate request."; see_also = [Link "set_request_structured_replies"; Link "get_request_structured_replies"; + Link "opt_structured_reply"; Link "get_protocol"]; }; @@ -1086,6 +1092,12 @@ "set_opt_mode", { newstyle server. This setting has no effect when connecting to an oldstyle server. +Note that libnbd defaults to attempting +C<NBD_OPT_STRUCTURED_REPLY> before letting you control remaining +negotiation steps; if you need control over this step as well, +first set L<nbd_set_request_structured_replies(3)> to false before +starting the connection attempt. + When option mode is enabled, you have fine-grained control over which options are negotiated, compared to the default of the server negotiating everything on your behalf using settings made before @@ -1099,6 +1111,8 @@ "set_opt_mode", { Link "opt_abort"; Link "opt_go"; Link "opt_list"; Link "opt_info"; Link "opt_list_meta_context"; Link "opt_set_meta_context"; + Link "opt_structured_reply"; + Link "set_request_structured_replies"; Link "aio_connect"]; }; @@ -1152,6 +1166,32 @@ "opt_abort", { see_also = [Link "set_opt_mode"; Link "aio_opt_abort"; Link "opt_go"]; }; + "opt_structured_reply", { + default_call with + args = []; ret = RBool; + permitted_states = [ Negotiating ]; + shortdesc = "request the server to enable structured replies"; + longdesc = "\ +Request that the server use structured replies, by sending +C<NBD_OPT_STRUCTURED_REPLY>. This can only be used if +L<nbd_set_opt_mode(3)> enabled option mode; furthermore, libnbd +defaults to automatically requesting this unless you use +L<nbd_set_request_structured_replies(3)> prior to connecting. +This function is mainly useful for integration testing of corner +cases in server handling. + +This function returns true if the server replies with success, +false if the server replies with an error, and fails only if +the server does not reply (such as for a loss of connection). +Note that some servers fail a second request as redundant; +libnbd assumes that once one request has succeeded, then +structured replies are supported (as visible by +L<nbd_get_structured_replies_negotiated(3)>) regardless if +later calls to this function return false."; + see_also = [Link "set_opt_mode"; Link "aio_opt_structured_reply"; + Link "opt_go"; Link "set_request_structured_replies"] + }; + "opt_list", { default_call with args = [ Closure list_closure ]; ret = RInt; @@ -2775,6 +2815,30 @@ "aio_opt_abort", { see_also = [Link "set_opt_mode"; Link "opt_abort"]; }; + "aio_opt_structured_reply", { + default_call with + args = []; + optargs = [ OClosure completion_closure ]; + ret = RErr; + permitted_states = [ Negotiating ]; + shortdesc = "request the server to enable structured replies"; + longdesc = "\ +Request that the server use structured replies, by sending +C<NBD_OPT_STRUCTURED_REPLY>. This behaves like the synchronous +counterpart L<nbd_opt_structured_reply(3)>, except that it does +not wait for the server's response. + +To determine when the request completes, wait for +L<nbd_aio_is_connecting(3)> to return false. Or supply the optional +C<completion_callback> which will be invoked as described in +L<libnbd(3)/Completion callbacks>, except that it is automatically +retired regardless of return value. Note that detecting whether the +server returns an error (as is done by the return value of the +synchronous counterpart) is only possible with a completion +callback."; + see_also = [Link "set_opt_mode"; Link "opt_structured_reply"]; + }; + "aio_opt_list", { default_call with args = [ Closure list_closure ]; @@ -3678,6 +3742,8 @@ let first_version = "opt_set_meta_context_queries", (1, 16); "aio_opt_set_meta_context", (1, 16); "aio_opt_set_meta_context_queries", (1, 16); + "opt_structured_reply", (1, 16); + "aio_opt_structured_reply", (1, 16); (* These calls are proposed for a future version of libnbd, but * have not been added to any released version so far. diff --git a/generator/states-newstyle-opt-starttls.c b/generator/states-newstyle-opt-starttls.c index a9383ced..afaad85a 100644 --- a/generator/states-newstyle-opt-starttls.c +++ b/generator/states-newstyle-opt-starttls.c @@ -72,6 +72,7 @@ NEWSTYLE.OPT_STARTTLS.CHECK_REPLY: reply = be32toh (h->sbuf.or.option_reply.reply); switch (reply) { case NBD_REP_ACK: + h->structured_replies = false; new_sock = nbd_internal_crypto_create_session (h, h->sock); if (new_sock == NULL) { SET_NEXT_STATE (%.DEAD); diff --git a/generator/states-newstyle-opt-structured-reply.c b/generator/states-newstyle-opt-structured-reply.c index 0ea0fd43..300cf20b 100644 --- a/generator/states-newstyle-opt-structured-reply.c +++ b/generator/states-newstyle-opt-structured-reply.c @@ -21,12 +21,17 @@ STATE_MACHINE { NEWSTYLE.OPT_STRUCTURED_REPLY.START: assert (h->gflags & LIBNBD_HANDSHAKE_FLAG_FIXED_NEWSTYLE); - if (!h->request_sr) { - if (h->opt_mode) - SET_NEXT_STATE (%.NEGOTIATING); - else - SET_NEXT_STATE (%^OPT_META_CONTEXT.START); - return 0; + if (h->opt_current == NBD_OPT_STRUCTURED_REPLY) + assert (h->opt_mode); + else { + assert (CALLBACK_IS_NULL(h->opt_cb.completion)); + if (!h->request_sr) { + if (h->opt_mode) + SET_NEXT_STATE (%.NEGOTIATING); + else + SET_NEXT_STATE (%^OPT_META_CONTEXT.START); + return 0; + } } h->sbuf.option.version = htobe64 (NBD_NEW_VERSION); @@ -69,12 +74,14 @@ NEWSTYLE.OPT_STRUCTURED_REPLY.RECV_REPLY_PAYLOAD: NEWSTYLE.OPT_STRUCTURED_REPLY.CHECK_REPLY: uint32_t reply; + int err = ENOTSUP; reply = be32toh (h->sbuf.or.option_reply.reply); switch (reply) { case NBD_REP_ACK: debug (h, "negotiated structured replies on this connection"); h->structured_replies = true; + err = 0; break; default: if (handle_reply_error (h) == -1) { @@ -83,7 +90,6 @@ NEWSTYLE.OPT_STRUCTURED_REPLY.CHECK_REPLY: } debug (h, "structured replies are not supported by this server"); - h->structured_replies = false; break; } @@ -92,6 +98,8 @@ NEWSTYLE.OPT_STRUCTURED_REPLY.CHECK_REPLY: SET_NEXT_STATE (%.NEGOTIATING); else SET_NEXT_STATE (%^OPT_META_CONTEXT.START); + CALL_CALLBACK (h->opt_cb.completion, &err); + nbd_internal_free_option (h); return 0; } /* END STATE MACHINE */ diff --git a/generator/states-newstyle.c b/generator/states-newstyle.c index 60e0bc50..4652bc21 100644 --- a/generator/states-newstyle.c +++ b/generator/states-newstyle.c @@ -143,6 +143,9 @@ NEWSTYLE.START: case NBD_OPT_SET_META_CONTEXT: SET_NEXT_STATE (%OPT_META_CONTEXT.START); return 0; + case NBD_OPT_STRUCTURED_REPLY: + SET_NEXT_STATE (%OPT_STRUCTURED_REPLY.START); + return 0; case 0: break; default: diff --git a/lib/opt.c b/lib/opt.c index ee036235..1b18920f 100644 --- a/lib/opt.c +++ b/lib/opt.c @@ -127,6 +127,31 @@ nbd_unlocked_opt_abort (struct nbd_handle *h) return wait_for_option (h); } +/* Issue NBD_OPT_STRUCTURED_REPLY and wait for the reply. */ +int +nbd_unlocked_opt_structured_reply (struct nbd_handle *h) +{ + int err; + nbd_completion_callback c = { .callback = go_complete, .user_data = &err }; + int r = nbd_unlocked_aio_opt_structured_reply (h, &c); + + if (r == -1) + return r; + + r = wait_for_option (h); + if (r == 0) { + if (nbd_internal_is_state_negotiating (get_next_state (h))) + r = err == 0; + else { + assert (nbd_internal_is_state_dead (get_next_state (h))); + set_error (err, + "failed to get response to opt_structured_reply request"); + r = -1; + } + } + return r; +} + struct list_helper { int count; nbd_list_callback list; @@ -300,6 +325,25 @@ nbd_unlocked_aio_opt_abort (struct nbd_handle *h) return 0; } +/* Issue NBD_OPT_STRUCTURED_REPLY without waiting. */ +int +nbd_unlocked_aio_opt_structured_reply (struct nbd_handle *h, + nbd_completion_callback *complete) +{ + if ((h->gflags & LIBNBD_HANDSHAKE_FLAG_FIXED_NEWSTYLE) == 0) { + set_error (ENOTSUP, "server is not using fixed newstyle protocol"); + return -1; + } + + h->opt_current = NBD_OPT_STRUCTURED_REPLY; + h->opt_cb.completion = *complete; + SET_CALLBACK_TO_NULL (*complete); + + if (nbd_internal_run (h, cmd_issue) == -1) + debug (h, "option queued, ignoring state machine failure"); + return 0; +} + /* Issue NBD_OPT_LIST without waiting. */ int nbd_unlocked_aio_opt_list (struct nbd_handle *h, nbd_list_callback *list, diff --git a/tests/Makefile.am b/tests/Makefile.am index ec95495e..49ea6864 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -217,6 +217,7 @@ check_PROGRAMS += \ opt-list-meta-queries \ opt-set-meta \ opt-set-meta-queries \ + opt-structured-twice \ connect-systemd-socket-activation \ connect-unix \ connect-tcp \ @@ -286,6 +287,7 @@ TESTS += \ opt-list-meta-queries \ opt-set-meta \ opt-set-meta-queries \ + opt-structured-twice \ connect-systemd-socket-activation \ connect-unix \ connect-tcp \ @@ -557,6 +559,9 @@ opt_set_meta_LDADD = $(top_builddir)/lib/libnbd.la opt_set_meta_queries_SOURCES = opt-set-meta-queries.c opt_set_meta_queries_LDADD = $(top_builddir)/lib/libnbd.la +opt_structured_twice_SOURCES = opt-structured-twice.c +opt_structured_twice_LDADD = $(top_builddir)/lib/libnbd.la + connect_systemd_socket_activation_SOURCES = \ connect-systemd-socket-activation.c \ requires.c \ diff --git a/tests/opt-list-meta.c b/tests/opt-list-meta.c index 05c1a5eb..b32dbf90 100644 --- a/tests/opt-list-meta.c +++ b/tests/opt-list-meta.c @@ -269,7 +269,34 @@ main (int argc, char *argv[]) } } - /* FIXME: Once nbd_opt_structured_reply() exists, use it here and retry. */ + /* Now enable structured replies, and a retry should pass. */ + r = nbd_opt_structured_reply (nbd); + if (r == -1) { + fprintf (stderr, "%s\n", nbd_get_error ()); + exit (EXIT_FAILURE); + } + if (r != 1) { + fprintf (stderr, "expecting structured replies to be supported\n"); + exit (EXIT_FAILURE); + } + + p = (struct progress) { .count = 0 }; + r = nbd_opt_list_meta_context (nbd, + (nbd_context_callback) { .callback = check, + .user_data = &p}); + if (r == -1) { + fprintf (stderr, "%s\n", nbd_get_error ()); + exit (EXIT_FAILURE); + } + if (r != p.count) { + fprintf (stderr, "inconsistent return value %d, expected %d\n", + r, p.count); + exit (EXIT_FAILURE); + } + if (r < 1 || !p.seen) { + fprintf (stderr, "server did not reply with base:allocation\n"); + exit (EXIT_FAILURE); + } nbd_opt_abort (nbd); nbd_close (nbd); diff --git a/tests/opt-set-meta.c b/tests/opt-set-meta.c index a4366d24..48fce9bd 100644 --- a/tests/opt-set-meta.c +++ b/tests/opt-set-meta.c @@ -59,37 +59,61 @@ main (int argc, char *argv[]) char *args[] = { "nbdkit", "-s", "--exit-with-parent", "-v", "memory", "size=1M", NULL, NULL }; - /* First process, with structured replies. Get into negotiating state. */ + /* First process, delay structured replies. Get into negotiating state. */ nbd = nbd_create (); if (nbd == NULL || nbd_set_opt_mode (nbd, true) == -1 || + nbd_set_request_structured_replies (nbd, false) == -1 || nbd_connect_command (nbd, args) == -1) { fprintf (stderr, "%s\n", nbd_get_error ()); exit (EXIT_FAILURE); } /* No contexts negotiated yet; can_meta should be error if any requested */ + if ((r = nbd_get_structured_replies_negotiated (nbd)) != 0) { + fprintf (stderr, "structured replies got %d, expected 0\n", r); + exit (EXIT_FAILURE); + } + if ((r = nbd_can_meta_context (nbd, LIBNBD_CONTEXT_BASE_ALLOCATION)) != 0) { + fprintf (stderr, "can_meta_context got %d, expected 0\n", r); + exit (EXIT_FAILURE); + } + if (nbd_add_meta_context (nbd, LIBNBD_CONTEXT_BASE_ALLOCATION) == -1) { + fprintf (stderr, "%s\n", nbd_get_error ()); + exit (EXIT_FAILURE); + } + if ((r = nbd_can_meta_context (nbd, LIBNBD_CONTEXT_BASE_ALLOCATION)) != -1) { + fprintf (stderr, "can_meta_context got %d, expected -1\n", r); + exit (EXIT_FAILURE); + } + + /* SET cannot succeed until SR is negotiated. */ + p = (struct progress) { .count = 0 }; + r = nbd_opt_set_meta_context (nbd, + (nbd_context_callback) { .callback = check, + .user_data = &p}); + if (r != -1 || p.count || p.seen) { + fprintf (stderr, "expecting failure of set without SR\n"); + exit (EXIT_FAILURE); + } + r = nbd_opt_structured_reply (nbd); + if (r == -1) { + fprintf (stderr, "%s\n", nbd_get_error ()); + exit (EXIT_FAILURE); + } + if (r != 1) { + fprintf (stderr, "expecting server support for SR\n"); + exit (EXIT_FAILURE); + } if ((r = nbd_get_structured_replies_negotiated (nbd)) != 1) { fprintf (stderr, "structured replies got %d, expected 1\n", r); exit (EXIT_FAILURE); } - if ((r = nbd_can_meta_context (nbd, LIBNBD_CONTEXT_BASE_ALLOCATION)) != 0) { - fprintf (stderr, "can_meta_context got %d, expected 0\n", r); - exit (EXIT_FAILURE); - } - if (nbd_add_meta_context (nbd, LIBNBD_CONTEXT_BASE_ALLOCATION) == -1) { - fprintf (stderr, "%s\n", nbd_get_error ()); - exit (EXIT_FAILURE); - } if ((r = nbd_can_meta_context (nbd, LIBNBD_CONTEXT_BASE_ALLOCATION)) != -1) { fprintf (stderr, "can_meta_context got %d, expected -1\n", r); exit (EXIT_FAILURE); } - /* FIXME: Once nbd_opt_structured_reply exists, check that set before - * SR fails server-side, then enable SR for rest of process. - */ - /* nbdkit does not match wildcard for SET, even though it does for LIST */ if (nbd_clear_meta_contexts (nbd) == -1 || nbd_add_meta_context (nbd, "base:") == -1) { diff --git a/tests/opt-structured-twice.c b/tests/opt-structured-twice.c new file mode 100644 index 00000000..5924d22e --- /dev/null +++ b/tests/opt-structured-twice.c @@ -0,0 +1,145 @@ +/* NBD client library in userspace + * Copyright (C) 2013-2022 Red Hat Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/* Demonstrate low-level use of nbd_opt_structured_reply(). */ + +#include <config.h> + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <errno.h> +#include <unistd.h> +#include <sys/stat.h> + +#include <libnbd.h> + + +static int +check_extent (void *data, const char *metacontext, uint64_t offset, + uint32_t *entries, size_t nr_entries, int *error) +{ + /* If we got here, structured replies were negotiated. */ + bool *seen = data; + + *seen = true; + return 0; +} + +int +main (int argc, char *argv[]) +{ + struct nbd_handle *nbd; + const char *cmd[] = { + "nbdkit", "-s", "-v", "--exit-with-parent", "memory", "1048576", NULL + }; + int r; + bool extents_worked = false; + + nbd = nbd_create (); + if (nbd == NULL) { + fprintf (stderr, "%s\n", nbd_get_error ()); + exit (EXIT_FAILURE); + } + + /* Connect to the server in opt mode, without structured replies. */ + if (nbd_set_opt_mode (nbd, true) == -1 || + nbd_set_request_structured_replies (nbd, false) == -1 || + nbd_connect_command (nbd, (char **) cmd) == -1) { + fprintf (stderr, "%s: %s\n", argv[0], nbd_get_error ()); + exit (EXIT_FAILURE); + } + + r = nbd_get_structured_replies_negotiated (nbd); + if (r == -1) { + fprintf (stderr, "%s: %s\n", argv[0], nbd_get_error ()); + exit (EXIT_FAILURE); + } + if (r != 0) { + fprintf (stderr, "%s: not expecting structured replies yet\n", argv[0]); + exit (EXIT_FAILURE); + } + + /* First request should succeed. */ + r = nbd_opt_structured_reply (nbd); + if (r == -1) { + fprintf (stderr, "%s: %s\n", argv[0], nbd_get_error ()); + exit (EXIT_FAILURE); + } + if (r != 1) { + fprintf (stderr, "%s: expecting structured replies\n", argv[0]); + exit (EXIT_FAILURE); + } + r = nbd_get_structured_replies_negotiated (nbd); + if (r == -1) { + fprintf (stderr, "%s: %s\n", argv[0], nbd_get_error ()); + exit (EXIT_FAILURE); + } + if (r != 1) { + fprintf (stderr, "%s: expecting structured replies\n", argv[0]); + exit (EXIT_FAILURE); + } + + /* nbdkit 1.32 allows a second request, nbdkit 1.34 diagnoses it. */ + r = nbd_opt_structured_reply (nbd); + if (r == -1) { + fprintf (stderr, "%s: %s\n", argv[0], nbd_get_error ()); + exit (EXIT_FAILURE); + } + printf ("%s: server's response to second request: %s\n", argv[0], + r ? "accepted" : "rejected"); + + /* Regardless of whether second request passed, structured replies were + * negotiated, so we should be able to do block status. + */ + r = nbd_get_structured_replies_negotiated (nbd); + if (r == -1) { + fprintf (stderr, "%s: %s\n", argv[0], nbd_get_error ()); + exit (EXIT_FAILURE); + } + if (r != 1) { + fprintf (stderr, "%s: expecting structured replies\n", argv[0]); + exit (EXIT_FAILURE); + } + + if (nbd_add_meta_context (nbd, LIBNBD_CONTEXT_BASE_ALLOCATION) == -1 || + nbd_opt_go (nbd) == -1 || + (r = nbd_can_meta_context (nbd, LIBNBD_CONTEXT_BASE_ALLOCATION)) == -1) { + fprintf (stderr, "%s: %s\n", argv[0], nbd_get_error ()); + exit (EXIT_FAILURE); + } + if (r != 1) { + fprintf (stderr, "%s: expecting base:allocation support\n", argv[0]); + exit (EXIT_FAILURE); + } + + if (nbd_block_status (nbd, 65536, 0, + (nbd_extent_callback) { .callback = check_extent, + .user_data = &extents_worked }, + 0) == -1) { + fprintf (stderr, "%s\n", nbd_get_error ()); + exit (EXIT_FAILURE); + } + if (!extents_worked) { + fprintf (stderr, "%s: expecting block_status success\n", argv[0]); + exit (EXIT_FAILURE); + } + + nbd_close (nbd); + exit (EXIT_SUCCESS); +} diff --git a/.gitignore b/.gitignore index 50e4616e..37166b73 100644 --- a/.gitignore +++ b/.gitignore @@ -236,6 +236,7 @@ Makefile.in /tests/opt-list-meta-queries /tests/opt-set-meta /tests/opt-set-meta-queries +/tests/opt-structured-twice /tests/pki/ /tests/pread-initialize /tests/private-data -- 2.37.3