search for: backend_filt

...ver/filters.c @@ -1,5 +1,5 @@ /* nbdkit - * Copyright (C) 2013-2019 Red Hat Inc. + * Copyright (C) 2013-2020 Red Hat Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -49,12 +49,14 @@ struct backend_filter { struct nbdkit_filter filter; }; -/* Literally a backend + a connection pointer. This is the - * implementation of ‘void *nxdata’ in the filter API. +/* Literally a backend, a connection pointer, and the filter's handle. + * This is the implementation of our handle in .open, and serves...

...ary/msg00092.html --- server/filters.c | 217 ++++++++++++++++------------------------------- 1 file changed, 73 insertions(+), 144 deletions(-) diff --git a/server/filters.c b/server/filters.c index c916217c..92b0ceb3 100644 --- a/server/filters.c +++ b/server/filters.c @@ -49,16 +49,6 @@ struct backend_filter { struct nbdkit_filter filter; }; -/* Literally a backend and the filter's handle. - * - * This is the implementation of our handle in .open, and serves as - * a stable ‘void *nxdata’ in the filter API. - */ -struct b_h { - struct backend *b; - void *handle; -}; - /* Note this frees...

...s.c | 170 ++++++++++++++++++++++------------------------- 1 file changed, 79 insertions(+), 91 deletions(-) diff --git a/server/filters.c b/server/filters.c index bb6394fb..287c8747 100644 --- a/server/filters.c +++ b/server/filters.c @@ -68,7 +68,7 @@ filter_free (struct backend *b) { struct backend_filter *f = container_of (b, struct backend_filter, backend); - f->backend.next->free (f->backend.next); + b->next->free (b->next); /* Acquiring this lock prevents any filter callbacks from running * simultaneously. @@ -94,7 +94,7 @@ filter_thread_model (struct backend *b)...

...;string.h> +#include <inttypes.h> +#include <assert.h> +#include <errno.h> + +#include <dlfcn.h> + +#include "nbdkit-filter.h" +#include "internal.h" + +/* We extend the generic backend struct with extra fields relating + * to this filter. + */ +struct backend_filter { + struct backend backend; + char *filename; + void *dl; + struct nbdkit_filter filter; +}; + +/* Note this frees the whole chain. */ +static void +filter_free (struct backend *b) +{ + struct backend_filter *f = container_of (b, struct backend_filter, backend); + + f->backend.next->f...

It's confusing to use the same terminology for a single backend as for the linked list of backends. In particular it's often not clear if we're calling the next backend or the whole chain of backends. --- server/internal.h | 14 ++++++++++-- server/connections.c | 20 ++++++++--------- server/locks.c | 2 +- server/main.c

...;string.h> +#include <inttypes.h> +#include <assert.h> +#include <errno.h> + +#include <dlfcn.h> + +#include "nbdkit-filter.h" +#include "internal.h" + +/* We extend the generic backend struct with extra fields relating + * to this filter. + */ +struct backend_filter { + struct backend backend; + char *filename; + void *dl; + struct nbdkit_filter filter; +}; + +/* Note this frees the whole chain. */ +static void +filter_free (struct backend *b) +{ + struct backend_filter *f = container_of (b, struct backend_filter, backend); + + f->backend.next->f...

...;string.h> +#include <inttypes.h> +#include <assert.h> +#include <errno.h> + +#include <dlfcn.h> + +#include "nbdkit-filter.h" +#include "internal.h" + +/* We extend the generic backend struct with extra fields relating + * to this filter. + */ +struct backend_filter { + struct backend backend; + char *filename; + void *dl; + struct nbdkit_filter filter; +}; + +/* Literally a backend + a connection pointer. This is the + * implementation of ‘void *nxdata’ in the filter API. + */ +struct b_conn { + struct backend *b; + struct connection *conn; +}; + +/*...

I still don't have .prepare/.finalize working cleanly across reopen, but did find a nasty bug where a botched assertion means we failed to notice reads beyond EOF in both the xz and retry filter. Refactoring backend.c will make .finalize work easier. Eric Blake (5): xz: Avoid reading beyond EOF retry: Check size before transactions tests: Test retry when get_size values change

The third patch is a large but mechanical change which gets rid of passing around struct connection * entirely within the server, preferring instead to reference the connection through thread-local storage. I hope this is a gateway to simplifying other parts of the code. Rich.

...*conn, int sockin, int sockout) +crypto_negotiate_tls (int sockin, int sockout) { /* Should never be called because tls == 0. */ abort (); diff --git a/server/filters.c b/server/filters.c index 2f65818e..c916217c 100644 --- a/server/filters.c +++ b/server/filters.c @@ -49,13 +49,13 @@ struct backend_filter { struct nbdkit_filter filter; }; -/* Literally a backend, a connection pointer, and the filter's handle. +/* Literally a backend and the filter's handle. + * * This is the implementation of our handle in .open, and serves as * a stable ‘void *nxdata’ in the filter API. */ -st...

v1 was here: https://www.redhat.com/archives/libguestfs/2020-February/msg00081.html v2 replaces struct connection *conn = GET_CONN; with GET_CONN; which sets conn implicitly and asserts that it is non-NULL. If we actually want to test if conn is non-NULL or behave differently, then you must use threadlocal_get_conn() instead, and some existing uses do that. Rich.

It's easy to use the sh script to demonstrate that nbdkit is inefficiently calling into .get_size, .can_fua, and friends more than necessary. We've also commented on the list in the past that it would be nice to ensure that when filters call into next_ops, they are not violating constraints (as we've have to fix several bugs in the past where we did not have such checking to protect

...ct backend *b) */ lock_unload (); - debug ("%s: unload", f->filename); + debug ("%s: unload", f->name); if (f->filter.unload) f->filter.unload (); @@ -172,7 +172,7 @@ filter_config (struct backend *b, const char *key, const char *value) struct backend_filter *f = container_of (b, struct backend_filter, backend); debug ("%s: config key=%s, value=%s", - f->filename, key, value); + f->name, key, value); if (f->filter.config) { if (f->filter.config (next_config, f->backend.next, key, value) == -1) @...

This is still tentative and needs a lot of work, but: - partition filter works, supporting MBR & GPT - prepare and finalize methods fixed - open method can now be changed (allowing readonly flag to be modified) - thread_model can be limited I believe I made most of the changes which were previously suggested in email. I think the only one I didn't was preventing inclusion of both

...ad) + unload (); + + if (DO_DLCLOSE) + dlclose (b->dl); + free (b->filename); + + unlock_unload (); + + free (b->name); +} diff --git a/server/filters.c b/server/filters.c index 287c8747..1f76bf61 100644 --- a/server/filters.c +++ b/server/filters.c @@ -48,9 +48,6 @@ */ struct backend_filter { struct backend backend; - char *name; /* copy of filter.name */ - char *filename; - void *dl; struct nbdkit_filter filter; }; @@ -70,22 +67,7 @@ filter_free (struct backend *b) b->next->free (b->next); - /* Acquiring this lock prevents any filter call...

Rebased filters patch. Requires current git master + the locks / thread model fix (https://www.redhat.com/archives/libguestfs/2018-January/msg00128.html) So a few changes here since last time: The "introduce filters" and "implement filters" patches are squashed together. I introduced a concept of .prepare and .finalize. These run before and after the data serving phase

..._INFO_INIT_STATE stuff on top of it). Are we sure that there is not going to be a speed penalty (from frequent access to the thread-local storage, compared to previous access through a parameter stored in a register)? A few comments: > +++ b/server/filters.c > @@ -49,13 +49,13 @@ struct backend_filter { > struct nbdkit_filter filter; > }; > > -/* Literally a backend, a connection pointer, and the filter's handle. > +/* Literally a backend and the filter's handle. > + * > * This is the implementation of our handle in .open, and serves as > * a stab...

The first three patches are identical to: https://www.redhat.com/archives/libguestfs/2018-January/msg00079.html "[PATCH nbdkit v2 0/3] Refactor plugin_* functions into a backend" The rest of the patches add filters using the new filter API previously described here: https://www.redhat.com/archives/libguestfs/2018-January/msg00073.html This needs a lot more testing -- and tests --

...c index 40c4913..1003dc7 100644 --- a/src/filters.c +++ b/src/filters.c @@ -107,14 +107,6 @@ filter_thread_model (struct backend *b) /* These are actually passing through to the final plugin, hence * the function names. */ -static int -plugin_errno_is_preserved (struct backend *b) -{ - struct backend_filter *f = container_of (b, struct backend_filter, backend); - - return f->backend.next->errno_is_preserved (f->backend.next); -} - static const char * plugin_name (struct backend *b) { @@ -463,17 +455,23 @@ filter_pread (struct backend *b, struct connection *conn, struct backend_filter...

...can_zero, + .can_fua = next_can_fua, }; static int @@ -455,6 +471,36 @@ filter_can_trim (struct backend *b, struct connection *conn) return f->backend.next->can_trim (f->backend.next, conn); } +static int +filter_can_zero (struct backend *b, struct connection *conn) +{ + struct backend_filter *f = container_of (b, struct backend_filter, backend); + void *handle = connection_get_handle (conn, f->backend.i); + struct b_conn nxdata = { .b = f->backend.next, .conn = conn }; + + debug ("can_zero"); + + if (f->filter.can_zero) + return f->filter.can_zero (&n...