[Libguestfs] [nbdkit PATCH v3 08/16] backend: Plumb context through internal callbacks
Eric Blake
eblake at redhat.com
Fri Mar 5 23:31:12 UTC 2021
Refactor all internal backend callbacks that take a 'struct backend
*'/'void *handle' pair to instead take a 'struct context *'. This serves
as a step towards making it easier for filters to create a standalone
context independent of the current client connection.
---
server/internal.h | 44 ++++++++--------
server/backend.c | 44 ++++++++--------
server/filters.c | 113 ++++++++++++++++++++++++----------------
server/plugins.c | 128 +++++++++++++++++++++++++++-------------------
4 files changed, 186 insertions(+), 143 deletions(-)
diff --git a/server/internal.h b/server/internal.h
index 28c65629..e8828506 100644
--- a/server/internal.h
+++ b/server/internal.h
@@ -366,38 +366,38 @@ struct backend {
const char *(*default_export) (struct backend *, int readonly, int is_tls);
void *(*open) (struct backend *, int readonly, const char *exportname,
int is_tls);
- int (*prepare) (struct backend *, void *handle, int readonly);
- int (*finalize) (struct backend *, void *handle);
- void (*close) (struct backend *, void *handle);
+ int (*prepare) (struct context *, int readonly);
+ int (*finalize) (struct context *);
+ void (*close) (struct context *);
- const char *(*export_description) (struct backend *, void *handle);
- int64_t (*get_size) (struct backend *, void *handle);
- int (*can_write) (struct backend *, void *handle);
- int (*can_flush) (struct backend *, void *handle);
- int (*is_rotational) (struct backend *, void *handle);
- int (*can_trim) (struct backend *, void *handle);
- int (*can_zero) (struct backend *, void *handle);
- int (*can_fast_zero) (struct backend *, void *handle);
- int (*can_extents) (struct backend *, void *handle);
- int (*can_fua) (struct backend *, void *handle);
- int (*can_multi_conn) (struct backend *, void *handle);
- int (*can_cache) (struct backend *, void *handle);
+ const char *(*export_description) (struct context *);
+ int64_t (*get_size) (struct context *);
+ int (*can_write) (struct context *);
+ int (*can_flush) (struct context *);
+ int (*is_rotational) (struct context *);
+ int (*can_trim) (struct context *);
+ int (*can_zero) (struct context *);
+ int (*can_fast_zero) (struct context *);
+ int (*can_extents) (struct context *);
+ int (*can_fua) (struct context *);
+ int (*can_multi_conn) (struct context *);
+ int (*can_cache) (struct context *);
- int (*pread) (struct backend *, void *handle,
+ int (*pread) (struct context *,
void *buf, uint32_t count, uint64_t offset,
uint32_t flags, int *err);
- int (*pwrite) (struct backend *, void *handle,
+ int (*pwrite) (struct context *,
const void *buf, uint32_t count, uint64_t offset,
uint32_t flags, int *err);
- int (*flush) (struct backend *, void *handle, uint32_t flags, int *err);
- int (*trim) (struct backend *, void *handle,
+ int (*flush) (struct context *, uint32_t flags, int *err);
+ int (*trim) (struct context *,
uint32_t count, uint64_t offset, uint32_t flags, int *err);
- int (*zero) (struct backend *, void *handle,
+ int (*zero) (struct context *,
uint32_t count, uint64_t offset, uint32_t flags, int *err);
- int (*extents) (struct backend *, void *handle,
+ int (*extents) (struct context *,
uint32_t count, uint64_t offset, uint32_t flags,
struct nbdkit_extents *extents, int *err);
- int (*cache) (struct backend *, void *handle,
+ int (*cache) (struct context *,
uint32_t count, uint64_t offset, uint32_t flags, int *err);
};
diff --git a/server/backend.c b/server/backend.c
index c382c71d..45a6da2f 100644
--- a/server/backend.c
+++ b/server/backend.c
@@ -287,7 +287,7 @@ backend_prepare (struct backend *b)
controlpath_debug ("%s: prepare readonly=%d", b->name, c->can_write == 0);
- if (b->prepare (b, c->handle, c->can_write == 0) == -1)
+ if (b->prepare (c, c->can_write == 0) == -1)
return -1;
c->state |= HANDLE_CONNECTED;
return 0;
@@ -310,7 +310,7 @@ backend_finalize (struct backend *b)
if (c->state & HANDLE_CONNECTED) {
assert (c->state & HANDLE_OPEN && c->handle);
controlpath_debug ("%s: finalize", b->name);
- if (b->finalize (b, c->handle) == -1) {
+ if (b->finalize (c) == -1) {
c->state |= HANDLE_FAILED;
return -1;
}
@@ -331,7 +331,7 @@ backend_close (struct backend *b)
assert (c->handle);
assert (c->state & HANDLE_OPEN);
controlpath_debug ("%s: close", b->name);
- b->close (b, c->handle);
+ b->close (c);
free (c);
set_context (conn, b, NULL);
if (b->i && get_context (conn, b->next))
@@ -390,7 +390,7 @@ backend_export_description (struct backend *b)
assert (c->handle && (c->state & HANDLE_CONNECTED));
/* Caching is not useful for this value. */
- s = b->export_description (b, c->handle);
+ s = b->export_description (c);
/* Ignore over-length strings. XXX Also ignore non-UTF8? */
if (s && strnlen (s, NBD_MAX_STRING + 1) > NBD_MAX_STRING) {
@@ -410,7 +410,7 @@ backend_get_size (struct backend *b)
assert (c->handle && (c->state & HANDLE_CONNECTED));
if (c->exportsize == -1) {
controlpath_debug ("%s: get_size", b->name);
- c->exportsize = b->get_size (b, c->handle);
+ c->exportsize = b->get_size (c);
}
return c->exportsize;
}
@@ -424,7 +424,7 @@ backend_can_write (struct backend *b)
assert (c->handle && (c->state & HANDLE_CONNECTED));
if (c->can_write == -1) {
controlpath_debug ("%s: can_write", b->name);
- c->can_write = b->can_write (b, c->handle);
+ c->can_write = b->can_write (c);
}
return c->can_write;
}
@@ -438,7 +438,7 @@ backend_can_flush (struct backend *b)
assert (c->handle && (c->state & HANDLE_CONNECTED));
if (c->can_flush == -1) {
controlpath_debug ("%s: can_flush", b->name);
- c->can_flush = b->can_flush (b, c->handle);
+ c->can_flush = b->can_flush (c);
}
return c->can_flush;
}
@@ -452,7 +452,7 @@ backend_is_rotational (struct backend *b)
assert (c->handle && (c->state & HANDLE_CONNECTED));
if (c->is_rotational == -1) {
controlpath_debug ("%s: is_rotational", b->name);
- c->is_rotational = b->is_rotational (b, c->handle);
+ c->is_rotational = b->is_rotational (c);
}
return c->is_rotational;
}
@@ -472,7 +472,7 @@ backend_can_trim (struct backend *b)
c->can_trim = 0;
return r;
}
- c->can_trim = b->can_trim (b, c->handle);
+ c->can_trim = b->can_trim (c);
}
return c->can_trim;
}
@@ -492,7 +492,7 @@ backend_can_zero (struct backend *b)
c->can_zero = NBDKIT_ZERO_NONE;
return r; /* Relies on 0 == NBDKIT_ZERO_NONE */
}
- c->can_zero = b->can_zero (b, c->handle);
+ c->can_zero = b->can_zero (c);
}
return c->can_zero;
}
@@ -512,7 +512,7 @@ backend_can_fast_zero (struct backend *b)
c->can_fast_zero = 0;
return r; /* Relies on 0 == NBDKIT_ZERO_NONE */
}
- c->can_fast_zero = b->can_fast_zero (b, c->handle);
+ c->can_fast_zero = b->can_fast_zero (c);
}
return c->can_fast_zero;
}
@@ -526,7 +526,7 @@ backend_can_extents (struct backend *b)
assert (c->handle && (c->state & HANDLE_CONNECTED));
if (c->can_extents == -1) {
controlpath_debug ("%s: can_extents", b->name);
- c->can_extents = b->can_extents (b, c->handle);
+ c->can_extents = b->can_extents (c);
}
return c->can_extents;
}
@@ -546,7 +546,7 @@ backend_can_fua (struct backend *b)
c->can_fua = NBDKIT_FUA_NONE;
return r; /* Relies on 0 == NBDKIT_FUA_NONE */
}
- c->can_fua = b->can_fua (b, c->handle);
+ c->can_fua = b->can_fua (c);
}
return c->can_fua;
}
@@ -560,7 +560,7 @@ backend_can_multi_conn (struct backend *b)
assert (c->handle && (c->state & HANDLE_CONNECTED));
if (c->can_multi_conn == -1) {
controlpath_debug ("%s: can_multi_conn", b->name);
- c->can_multi_conn = b->can_multi_conn (b, c->handle);
+ c->can_multi_conn = b->can_multi_conn (c);
}
return c->can_multi_conn;
}
@@ -574,7 +574,7 @@ backend_can_cache (struct backend *b)
assert (c->handle && (c->state & HANDLE_CONNECTED));
if (c->can_cache == -1) {
controlpath_debug ("%s: can_cache", b->name);
- c->can_cache = b->can_cache (b, c->handle);
+ c->can_cache = b->can_cache (c);
}
return c->can_cache;
}
@@ -594,7 +594,7 @@ backend_pread (struct backend *b,
datapath_debug ("%s: pread count=%" PRIu32 " offset=%" PRIu64,
b->name, count, offset);
- r = b->pread (b, c->handle, buf, count, offset, flags, err);
+ r = b->pread (c, buf, count, offset, flags, err);
if (r == -1)
assert (*err);
return r;
@@ -619,7 +619,7 @@ backend_pwrite (struct backend *b,
datapath_debug ("%s: pwrite count=%" PRIu32 " offset=%" PRIu64 " fua=%d",
b->name, count, offset, fua);
- r = b->pwrite (b, c->handle, buf, count, offset, flags, err);
+ r = b->pwrite (c, buf, count, offset, flags, err);
if (r == -1)
assert (*err);
return r;
@@ -638,7 +638,7 @@ backend_flush (struct backend *b,
assert (flags == 0);
datapath_debug ("%s: flush", b->name);
- r = b->flush (b, c->handle, flags, err);
+ r = b->flush (c, flags, err);
if (r == -1)
assert (*err);
return r;
@@ -664,7 +664,7 @@ backend_trim (struct backend *b,
datapath_debug ("%s: trim count=%" PRIu32 " offset=%" PRIu64 " fua=%d",
b->name, count, offset, fua);
- r = b->trim (b, c->handle, count, offset, flags, err);
+ r = b->trim (c, count, offset, flags, err);
if (r == -1)
assert (*err);
return r;
@@ -696,7 +696,7 @@ backend_zero (struct backend *b,
b->name, count, offset,
!!(flags & NBDKIT_FLAG_MAY_TRIM), fua, fast);
- r = b->zero (b, c->handle, count, offset, flags, err);
+ r = b->zero (c, count, offset, flags, err);
if (r == -1) {
assert (*err);
if (!fast)
@@ -730,7 +730,7 @@ backend_extents (struct backend *b,
*err = errno;
return r;
}
- r = b->extents (b, c->handle, count, offset, flags, extents, err);
+ r = b->extents (c, count, offset, flags, extents, err);
if (r == -1)
assert (*err);
return r;
@@ -764,7 +764,7 @@ backend_cache (struct backend *b,
}
return 0;
}
- r = b->cache (b, c->handle, count, offset, flags, err);
+ r = b->cache (c, count, offset, flags, err);
if (r == -1)
assert (*err);
return r;
diff --git a/server/filters.c b/server/filters.c
index fb123670..7986e56f 100644
--- a/server/filters.c
+++ b/server/filters.c
@@ -293,12 +293,14 @@ filter_open (struct backend *b, int readonly, const char *exportname,
}
static void
-filter_close (struct backend *b, void *handle)
+filter_close (struct context *c)
{
+ struct backend *b = c->b;
struct backend_filter *f = container_of (b, struct backend_filter, backend);
- if (handle && f->filter.close)
- f->filter.close (handle);
+ assert (c->handle);
+ if (f->filter.close)
+ f->filter.close (c->handle);
}
static struct nbdkit_next_ops next_ops = {
@@ -324,236 +326,256 @@ static struct nbdkit_next_ops next_ops = {
};
static int
-filter_prepare (struct backend *b, void *handle, int readonly)
+filter_prepare (struct context *c, int readonly)
{
+ struct backend *b = c->b;
struct backend_filter *f = container_of (b, struct backend_filter, backend);
if (f->filter.prepare &&
- f->filter.prepare (&next_ops, b->next, handle, readonly) == -1)
+ f->filter.prepare (&next_ops, b->next, c->handle, readonly) == -1)
return -1;
return 0;
}
static int
-filter_finalize (struct backend *b, void *handle)
+filter_finalize (struct context *c)
{
+ struct backend *b = c->b;
struct backend_filter *f = container_of (b, struct backend_filter, backend);
if (f->filter.finalize &&
- f->filter.finalize (&next_ops, b->next, handle) == -1)
+ f->filter.finalize (&next_ops, b->next, c->handle) == -1)
return -1;
return 0;
}
static const char *
-filter_export_description (struct backend *b, void *handle)
+filter_export_description (struct context *c)
{
+ struct backend *b = c->b;
struct backend_filter *f = container_of (b, struct backend_filter, backend);
if (f->filter.export_description)
- return f->filter.export_description (&next_ops, b->next, handle);
+ return f->filter.export_description (&next_ops, b->next, c->handle);
else
return backend_export_description (b->next);
}
static int64_t
-filter_get_size (struct backend *b, void *handle)
+filter_get_size (struct context *c)
{
+ struct backend *b = c->b;
struct backend_filter *f = container_of (b, struct backend_filter, backend);
if (f->filter.get_size)
- return f->filter.get_size (&next_ops, b->next, handle);
+ return f->filter.get_size (&next_ops, b->next, c->handle);
else
return backend_get_size (b->next);
}
static int
-filter_can_write (struct backend *b, void *handle)
+filter_can_write (struct context *c)
{
+ struct backend *b = c->b;
struct backend_filter *f = container_of (b, struct backend_filter, backend);
if (f->filter.can_write)
- return f->filter.can_write (&next_ops, b->next, handle);
+ return f->filter.can_write (&next_ops, b->next, c->handle);
else
return backend_can_write (b->next);
}
static int
-filter_can_flush (struct backend *b, void *handle)
+filter_can_flush (struct context *c)
{
+ struct backend *b = c->b;
struct backend_filter *f = container_of (b, struct backend_filter, backend);
if (f->filter.can_flush)
- return f->filter.can_flush (&next_ops, b->next, handle);
+ return f->filter.can_flush (&next_ops, b->next, c->handle);
else
return backend_can_flush (b->next);
}
static int
-filter_is_rotational (struct backend *b, void *handle)
+filter_is_rotational (struct context *c)
{
+ struct backend *b = c->b;
struct backend_filter *f = container_of (b, struct backend_filter, backend);
if (f->filter.is_rotational)
- return f->filter.is_rotational (&next_ops, b->next, handle);
+ return f->filter.is_rotational (&next_ops, b->next, c->handle);
else
return backend_is_rotational (b->next);
}
static int
-filter_can_trim (struct backend *b, void *handle)
+filter_can_trim (struct context *c)
{
+ struct backend *b = c->b;
struct backend_filter *f = container_of (b, struct backend_filter, backend);
if (f->filter.can_trim)
- return f->filter.can_trim (&next_ops, b->next, handle);
+ return f->filter.can_trim (&next_ops, b->next, c->handle);
else
return backend_can_trim (b->next);
}
static int
-filter_can_zero (struct backend *b, void *handle)
+filter_can_zero (struct context *c)
{
+ struct backend *b = c->b;
struct backend_filter *f = container_of (b, struct backend_filter, backend);
if (f->filter.can_zero)
- return f->filter.can_zero (&next_ops, b->next, handle);
+ return f->filter.can_zero (&next_ops, b->next, c->handle);
else
return backend_can_zero (b->next);
}
static int
-filter_can_fast_zero (struct backend *b, void *handle)
+filter_can_fast_zero (struct context *c)
{
+ struct backend *b = c->b;
struct backend_filter *f = container_of (b, struct backend_filter, backend);
if (f->filter.can_fast_zero)
- return f->filter.can_fast_zero (&next_ops, b->next, handle);
+ return f->filter.can_fast_zero (&next_ops, b->next, c->handle);
else
return backend_can_fast_zero (b->next);
}
static int
-filter_can_extents (struct backend *b, void *handle)
+filter_can_extents (struct context *c)
{
+ struct backend *b = c->b;
struct backend_filter *f = container_of (b, struct backend_filter, backend);
if (f->filter.can_extents)
- return f->filter.can_extents (&next_ops, b->next, handle);
+ return f->filter.can_extents (&next_ops, b->next, c->handle);
else
return backend_can_extents (b->next);
}
static int
-filter_can_fua (struct backend *b, void *handle)
+filter_can_fua (struct context *c)
{
+ struct backend *b = c->b;
struct backend_filter *f = container_of (b, struct backend_filter, backend);
if (f->filter.can_fua)
- return f->filter.can_fua (&next_ops, b->next, handle);
+ return f->filter.can_fua (&next_ops, b->next, c->handle);
else
return backend_can_fua (b->next);
}
static int
-filter_can_multi_conn (struct backend *b, void *handle)
+filter_can_multi_conn (struct context *c)
{
+ struct backend *b = c->b;
struct backend_filter *f = container_of (b, struct backend_filter, backend);
if (f->filter.can_multi_conn)
- return f->filter.can_multi_conn (&next_ops, b->next, handle);
+ return f->filter.can_multi_conn (&next_ops, b->next, c->handle);
else
return backend_can_multi_conn (b->next);
}
static int
-filter_can_cache (struct backend *b, void *handle)
+filter_can_cache (struct context *c)
{
+ struct backend *b = c->b;
struct backend_filter *f = container_of (b, struct backend_filter, backend);
if (f->filter.can_cache)
- return f->filter.can_cache (&next_ops, b->next, handle);
+ return f->filter.can_cache (&next_ops, b->next, c->handle);
else
return backend_can_cache (b->next);
}
static int
-filter_pread (struct backend *b, void *handle,
+filter_pread (struct context *c,
void *buf, uint32_t count, uint64_t offset,
uint32_t flags, int *err)
{
+ struct backend *b = c->b;
struct backend_filter *f = container_of (b, struct backend_filter, backend);
if (f->filter.pread)
- return f->filter.pread (&next_ops, b->next, handle,
+ return f->filter.pread (&next_ops, b->next, c->handle,
buf, count, offset, flags, err);
else
return backend_pread (b->next, buf, count, offset, flags, err);
}
static int
-filter_pwrite (struct backend *b, void *handle,
+filter_pwrite (struct context *c,
const void *buf, uint32_t count, uint64_t offset,
uint32_t flags, int *err)
{
+ struct backend *b = c->b;
struct backend_filter *f = container_of (b, struct backend_filter, backend);
if (f->filter.pwrite)
- return f->filter.pwrite (&next_ops, b->next, handle,
+ return f->filter.pwrite (&next_ops, b->next, c->handle,
buf, count, offset, flags, err);
else
return backend_pwrite (b->next, buf, count, offset, flags, err);
}
static int
-filter_flush (struct backend *b, void *handle,
+filter_flush (struct context *c,
uint32_t flags, int *err)
{
+ struct backend *b = c->b;
struct backend_filter *f = container_of (b, struct backend_filter, backend);
if (f->filter.flush)
- return f->filter.flush (&next_ops, b->next, handle, flags, err);
+ return f->filter.flush (&next_ops, b->next, c->handle, flags, err);
else
return backend_flush (b->next, flags, err);
}
static int
-filter_trim (struct backend *b, void *handle,
+filter_trim (struct context *c,
uint32_t count, uint64_t offset,
uint32_t flags, int *err)
{
+ struct backend *b = c->b;
struct backend_filter *f = container_of (b, struct backend_filter, backend);
if (f->filter.trim)
- return f->filter.trim (&next_ops, b->next, handle, count, offset,
+ return f->filter.trim (&next_ops, b->next, c->handle, count, offset,
flags, err);
else
return backend_trim (b->next, count, offset, flags, err);
}
static int
-filter_zero (struct backend *b, void *handle,
+filter_zero (struct context *c,
uint32_t count, uint64_t offset, uint32_t flags, int *err)
{
+ struct backend *b = c->b;
struct backend_filter *f = container_of (b, struct backend_filter, backend);
if (f->filter.zero)
- return f->filter.zero (&next_ops, b->next, handle,
+ return f->filter.zero (&next_ops, b->next, c->handle,
count, offset, flags, err);
else
return backend_zero (b->next, count, offset, flags, err);
}
static int
-filter_extents (struct backend *b, void *handle,
+filter_extents (struct context *c,
uint32_t count, uint64_t offset, uint32_t flags,
struct nbdkit_extents *extents, int *err)
{
+ struct backend *b = c->b;
struct backend_filter *f = container_of (b, struct backend_filter, backend);
if (f->filter.extents)
- return f->filter.extents (&next_ops, b->next, handle,
+ return f->filter.extents (&next_ops, b->next, c->handle,
count, offset, flags,
extents, err);
else
@@ -562,14 +584,15 @@ filter_extents (struct backend *b, void *handle,
}
static int
-filter_cache (struct backend *b, void *handle,
+filter_cache (struct context *c,
uint32_t count, uint64_t offset,
uint32_t flags, int *err)
{
+ struct backend *b = c->b;
struct backend_filter *f = container_of (b, struct backend_filter, backend);
if (f->filter.cache)
- return f->filter.cache (&next_ops, b->next, handle,
+ return f->filter.cache (&next_ops, b->next, c->handle,
count, offset, flags, err);
else
return backend_cache (b->next, count, offset, flags, err);
diff --git a/server/plugins.c b/server/plugins.c
index 010595c7..17126ea1 100644
--- a/server/plugins.c
+++ b/server/plugins.c
@@ -1,5 +1,5 @@
/* nbdkit
- * Copyright (C) 2013-2020 Red Hat Inc.
+ * Copyright (C) 2013-2021 Red Hat Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
@@ -347,48 +347,51 @@ plugin_open (struct backend *b, int readonly, const char *exportname,
* .close.
*/
static int
-plugin_prepare (struct backend *b, void *handle,
- int readonly)
+plugin_prepare (struct context *c, int readonly)
{
return 0;
}
static int
-plugin_finalize (struct backend *b, void *handle)
+plugin_finalize (struct context *c)
{
return 0;
}
static void
-plugin_close (struct backend *b, void *handle)
+plugin_close (struct context *c)
{
GET_CONN;
+ struct backend *b = c->b;
struct backend_plugin *p = container_of (b, struct backend_plugin, backend);
- if (handle && p->plugin.close)
- p->plugin.close (handle);
+ assert (c->handle);
+ if (p->plugin.close)
+ p->plugin.close (c->handle);
conn->exportname = NULL;
}
static const char *
-plugin_export_description (struct backend *b, void *handle)
+plugin_export_description (struct context *c)
{
+ struct backend *b = c->b;
struct backend_plugin *p = container_of (b, struct backend_plugin, backend);
if (p->plugin.export_description)
- return p->plugin.export_description (handle);
+ return p->plugin.export_description (c->handle);
else
return NULL;
}
static int64_t
-plugin_get_size (struct backend *b, void *handle)
+plugin_get_size (struct context *c)
{
+ struct backend *b = c->b;
struct backend_plugin *p = container_of (b, struct backend_plugin, backend);
assert (p->plugin.get_size != NULL);
- return p->plugin.get_size (handle);
+ return p->plugin.get_size (c->handle);
}
static int
@@ -401,52 +404,57 @@ normalize_bool (int value)
}
static int
-plugin_can_write (struct backend *b, void *handle)
+plugin_can_write (struct context *c)
{
+ struct backend *b = c->b;
struct backend_plugin *p = container_of (b, struct backend_plugin, backend);
if (p->plugin.can_write)
- return normalize_bool (p->plugin.can_write (handle));
+ return normalize_bool (p->plugin.can_write (c->handle));
else
return p->plugin.pwrite || p->plugin._pwrite_v1;
}
static int
-plugin_can_flush (struct backend *b, void *handle)
+plugin_can_flush (struct context *c)
{
+ struct backend *b = c->b;
struct backend_plugin *p = container_of (b, struct backend_plugin, backend);
if (p->plugin.can_flush)
- return normalize_bool (p->plugin.can_flush (handle));
+ return normalize_bool (p->plugin.can_flush (c->handle));
else
return p->plugin.flush || p->plugin._flush_v1;
}
static int
-plugin_is_rotational (struct backend *b, void *handle)
+plugin_is_rotational (struct context *c)
{
+ struct backend *b = c->b;
struct backend_plugin *p = container_of (b, struct backend_plugin, backend);
if (p->plugin.is_rotational)
- return normalize_bool (p->plugin.is_rotational (handle));
+ return normalize_bool (p->plugin.is_rotational (c->handle));
else
return 0; /* assume false */
}
static int
-plugin_can_trim (struct backend *b, void *handle)
+plugin_can_trim (struct context *c)
{
+ struct backend *b = c->b;
struct backend_plugin *p = container_of (b, struct backend_plugin, backend);
if (p->plugin.can_trim)
- return normalize_bool (p->plugin.can_trim (handle));
+ return normalize_bool (p->plugin.can_trim (c->handle));
else
return p->plugin.trim || p->plugin._trim_v1;
}
static int
-plugin_can_zero (struct backend *b, void *handle)
+plugin_can_zero (struct context *c)
{
+ struct backend *b = c->b;
struct backend_plugin *p = container_of (b, struct backend_plugin, backend);
int r;
@@ -455,7 +463,7 @@ plugin_can_zero (struct backend *b, void *handle)
* expects .can_zero to return a tri-state on level of support.
*/
if (p->plugin.can_zero) {
- r = p->plugin.can_zero (handle);
+ r = p->plugin.can_zero (c->handle);
if (r == -1)
return -1;
return r ? NBDKIT_ZERO_NATIVE : NBDKIT_ZERO_EMULATE;
@@ -466,13 +474,14 @@ plugin_can_zero (struct backend *b, void *handle)
}
static int
-plugin_can_fast_zero (struct backend *b, void *handle)
+plugin_can_fast_zero (struct context *c)
{
+ struct backend *b = c->b;
struct backend_plugin *p = container_of (b, struct backend_plugin, backend);
int r;
if (p->plugin.can_fast_zero)
- return normalize_bool (p->plugin.can_fast_zero (handle));
+ return normalize_bool (p->plugin.can_fast_zero (c->handle));
/* Advertise support for fast zeroes if no .zero or .can_zero is
* false: in those cases, we fail fast instead of using .pwrite.
* This also works when v1 plugin has only ._zero_v1.
@@ -486,26 +495,28 @@ plugin_can_fast_zero (struct backend *b, void *handle)
}
static int
-plugin_can_extents (struct backend *b, void *handle)
+plugin_can_extents (struct context *c)
{
+ struct backend *b = c->b;
struct backend_plugin *p = container_of (b, struct backend_plugin, backend);
if (p->plugin.can_extents)
- return normalize_bool (p->plugin.can_extents (handle));
+ return normalize_bool (p->plugin.can_extents (c->handle));
else
return p->plugin.extents != NULL;
}
static int
-plugin_can_fua (struct backend *b, void *handle)
+plugin_can_fua (struct context *c)
{
+ struct backend *b = c->b;
struct backend_plugin *p = container_of (b, struct backend_plugin, backend);
int r;
/* The plugin must use API version 2 and have .can_fua return
NBDKIT_FUA_NATIVE before we will pass the FUA flag on. */
if (p->plugin.can_fua) {
- r = p->plugin.can_fua (handle);
+ r = p->plugin.can_fua (c->handle);
if (r > NBDKIT_FUA_EMULATE && p->plugin._api_version == 1)
r = NBDKIT_FUA_EMULATE;
return r;
@@ -517,23 +528,25 @@ plugin_can_fua (struct backend *b, void *handle)
}
static int
-plugin_can_multi_conn (struct backend *b, void *handle)
+plugin_can_multi_conn (struct context *c)
{
+ struct backend *b = c->b;
struct backend_plugin *p = container_of (b, struct backend_plugin, backend);
if (p->plugin.can_multi_conn)
- return normalize_bool (p->plugin.can_multi_conn (handle));
+ return normalize_bool (p->plugin.can_multi_conn (c->handle));
else
return 0; /* assume false */
}
static int
-plugin_can_cache (struct backend *b, void *handle)
+plugin_can_cache (struct context *c)
{
+ struct backend *b = c->b;
struct backend_plugin *p = container_of (b, struct backend_plugin, backend);
if (p->plugin.can_cache)
- return p->plugin.can_cache (handle);
+ return p->plugin.can_cache (c->handle);
if (p->plugin.cache)
return NBDKIT_CACHE_NATIVE;
return NBDKIT_CACHE_NONE;
@@ -561,35 +574,37 @@ get_error (struct backend_plugin *p)
}
static int
-plugin_pread (struct backend *b, void *handle,
+plugin_pread (struct context *c,
void *buf, uint32_t count, uint64_t offset, uint32_t flags,
int *err)
{
+ struct backend *b = c->b;
struct backend_plugin *p = container_of (b, struct backend_plugin, backend);
int r;
assert (p->plugin.pread || p->plugin._pread_v1);
if (p->plugin.pread)
- r = p->plugin.pread (handle, buf, count, offset, 0);
+ r = p->plugin.pread (c->handle, buf, count, offset, 0);
else
- r = p->plugin._pread_v1 (handle, buf, count, offset);
+ r = p->plugin._pread_v1 (c->handle, buf, count, offset);
if (r == -1)
*err = get_error (p);
return r;
}
static int
-plugin_flush (struct backend *b, void *handle,
+plugin_flush (struct context *c,
uint32_t flags, int *err)
{
+ struct backend *b = c->b;
struct backend_plugin *p = container_of (b, struct backend_plugin, backend);
int r;
if (p->plugin.flush)
- r = p->plugin.flush (handle, 0);
+ r = p->plugin.flush (c->handle, 0);
else if (p->plugin._flush_v1)
- r = p->plugin._flush_v1 (handle);
+ r = p->plugin._flush_v1 (c->handle);
else {
*err = EINVAL;
return -1;
@@ -600,10 +615,11 @@ plugin_flush (struct backend *b, void *handle,
}
static int
-plugin_pwrite (struct backend *b, void *handle,
+plugin_pwrite (struct context *c,
const void *buf, uint32_t count, uint64_t offset, uint32_t flags,
int *err)
{
+ struct backend *b = c->b;
int r;
struct backend_plugin *p = container_of (b, struct backend_plugin, backend);
bool fua = flags & NBDKIT_FLAG_FUA;
@@ -614,24 +630,25 @@ plugin_pwrite (struct backend *b, void *handle,
need_flush = true;
}
if (p->plugin.pwrite)
- r = p->plugin.pwrite (handle, buf, count, offset, flags);
+ r = p->plugin.pwrite (c->handle, buf, count, offset, flags);
else if (p->plugin._pwrite_v1)
- r = p->plugin._pwrite_v1 (handle, buf, count, offset);
+ r = p->plugin._pwrite_v1 (c->handle, buf, count, offset);
else {
*err = EROFS;
return -1;
}
if (r != -1 && need_flush)
- r = plugin_flush (b, handle, 0, err);
+ r = plugin_flush (c, 0, err);
if (r == -1 && !*err)
*err = get_error (p);
return r;
}
static int
-plugin_trim (struct backend *b, void *handle,
+plugin_trim (struct context *c,
uint32_t count, uint64_t offset, uint32_t flags, int *err)
{
+ struct backend *b = c->b;
int r;
struct backend_plugin *p = container_of (b, struct backend_plugin, backend);
bool fua = flags & NBDKIT_FLAG_FUA;
@@ -642,24 +659,25 @@ plugin_trim (struct backend *b, void *handle,
need_flush = true;
}
if (p->plugin.trim)
- r = p->plugin.trim (handle, count, offset, flags);
+ r = p->plugin.trim (c->handle, count, offset, flags);
else if (p->plugin._trim_v1)
- r = p->plugin._trim_v1 (handle, count, offset);
+ r = p->plugin._trim_v1 (c->handle, count, offset);
else {
*err = EINVAL;
return -1;
}
if (r != -1 && need_flush)
- r = plugin_flush (b, handle, 0, err);
+ r = plugin_flush (c, 0, err);
if (r == -1 && !*err)
*err = get_error (p);
return r;
}
static int
-plugin_zero (struct backend *b, void *handle,
+plugin_zero (struct context *c,
uint32_t count, uint64_t offset, uint32_t flags, int *err)
{
+ struct backend *b = c->b;
struct backend_plugin *p = container_of (b, struct backend_plugin, backend);
int r = -1;
bool may_trim = flags & NBDKIT_FLAG_MAY_TRIM;
@@ -678,13 +696,13 @@ plugin_zero (struct backend *b, void *handle,
if (backend_can_zero (b) == NBDKIT_ZERO_NATIVE) {
errno = 0;
if (p->plugin.zero)
- r = p->plugin.zero (handle, count, offset, flags);
+ r = p->plugin.zero (c->handle, count, offset, flags);
else if (p->plugin._zero_v1) {
if (fast_zero) {
*err = EOPNOTSUPP;
return -1;
}
- r = p->plugin._zero_v1 (handle, count, offset, may_trim);
+ r = p->plugin._zero_v1 (c->handle, count, offset, may_trim);
}
else
emulate = true;
@@ -711,7 +729,7 @@ plugin_zero (struct backend *b, void *handle,
static /* const */ char buf[MAX_REQUEST_SIZE];
uint32_t limit = MIN (count, sizeof buf);
- r = plugin_pwrite (b, handle, buf, limit, offset, flags, err);
+ r = plugin_pwrite (c, buf, limit, offset, flags, err);
if (r == -1)
break;
count -= limit;
@@ -719,17 +737,18 @@ plugin_zero (struct backend *b, void *handle,
done:
if (r != -1 && need_flush)
- r = plugin_flush (b, handle, 0, err);
+ r = plugin_flush (c, 0, err);
if (r == -1 && !*err)
*err = get_error (p);
return r;
}
static int
-plugin_extents (struct backend *b, void *handle,
+plugin_extents (struct context *c,
uint32_t count, uint64_t offset, uint32_t flags,
struct nbdkit_extents *extents, int *err)
{
+ struct backend *b = c->b;
struct backend_plugin *p = container_of (b, struct backend_plugin, backend);
int r;
@@ -738,7 +757,7 @@ plugin_extents (struct backend *b, void *handle,
return -1;
}
- r = p->plugin.extents (handle, count, offset, flags, extents);
+ r = p->plugin.extents (c->handle, count, offset, flags, extents);
if (r >= 0 && nbdkit_extents_count (extents) < 1) {
nbdkit_error ("extents: plugin must return at least one extent");
nbdkit_set_error (EINVAL);
@@ -750,10 +769,11 @@ plugin_extents (struct backend *b, void *handle,
}
static int
-plugin_cache (struct backend *b, void *handle,
+plugin_cache (struct context *c,
uint32_t count, uint64_t offset, uint32_t flags,
int *err)
{
+ struct backend *b = c->b;
struct backend_plugin *p = container_of (b, struct backend_plugin, backend);
int r;
@@ -762,7 +782,7 @@ plugin_cache (struct backend *b, void *handle,
if (!p->plugin.cache)
return 0;
- r = p->plugin.cache (handle, count, offset, flags);
+ r = p->plugin.cache (c->handle, count, offset, flags);
if (r == -1)
*err = get_error (p);
return r;
--
2.30.1
More information about the Libguestfs
mailing list