server/filters.c

   1 /* nbdkit
   2  * Copyright (C) 2013-2018 Red Hat Inc.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  * * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *
  11  * * Redistributions in binary form must reproduce the above copyright
  12  * notice, this list of conditions and the following disclaimer in the
  13  * documentation and/or other materials provided with the distribution.
  14  *
  15  * * Neither the name of Red Hat nor the names of its contributors may be
  16  * used to endorse or promote products derived from this software without
  17  * specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY RED HAT AND CONTRIBUTORS ''AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  21  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  22  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL RED HAT OR
  23  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  26  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  27  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  28  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  29  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  */
  32
  33 #include <config.h>
  34
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37 #include <stdint.h>
  38 #include <string.h>
  39 #include <inttypes.h>
  40 #include <assert.h>
  41
  42 #include <dlfcn.h>
  43
  44 #include "internal.h"
  45
  46 /* We extend the generic backend struct with extra fields relating
  47  * to this filter.
  48  */
  49 struct backend_filter {
  50   struct backend backend;
  51   char *name;                   /* copy of filter.name */
  52   char *filename;
  53   void *dl;
  54   struct nbdkit_filter filter;
  55 };
  56
  57 /* Literally a backend + a connection pointer.  This is the
  58  * implementation of ‘void *nxdata’ in the filter API.
  59  */
  60 struct b_conn {
  61   struct backend *b;
  62   struct connection *conn;
  63 };
  64
  65 /* Note this frees the whole chain. */
  66 static void
  67 filter_free (struct backend *b)
  68 {
  69   struct backend_filter *f = container_of (b, struct backend_filter, backend);
  70
  71   f->backend.next->free (f->backend.next);
  72
  73   /* Acquiring this lock prevents any filter callbacks from running
  74    * simultaneously.
  75    */
  76   lock_unload ();
  77
  78   debug ("%s: unload", f->name);
  79   if (f->filter.unload)
  80     f->filter.unload ();
  81
  82   if (DO_DLCLOSE)
  83     dlclose (f->dl);
  84   free (f->filename);
  85
  86   unlock_unload ();
  87
  88   free (f->name);
  89   free (f);
  90 }
  91
  92 static int
  93 filter_thread_model (struct backend *b)
  94 {
  95   struct backend_filter *f = container_of (b, struct backend_filter, backend);
  96   int filter_thread_model = f->filter._thread_model;
  97   int thread_model = f->backend.next->thread_model (f->backend.next);
  98
  99   if (filter_thread_model < thread_model) /* more serialized */
 100     thread_model = filter_thread_model;
 101
 102   return thread_model;
 103 }
 104
 105 /* This is actually passing the request through to the final plugin,
 106  * hence the function name.
 107  */
 108 static const char *
 109 plugin_name (struct backend *b)
 110 {
 111   struct backend_filter *f = container_of (b, struct backend_filter, backend);
 112
 113   return f->backend.next->plugin_name (f->backend.next);
 114 }
 115
 116 static const char *
 117 filter_name (struct backend *b)
 118 {
 119   struct backend_filter *f = container_of (b, struct backend_filter, backend);
 120
 121   return f->name;
 122 }
 123
 124 static const char *
 125 filter_version (struct backend *b)
 126 {
 127   struct backend_filter *f = container_of (b, struct backend_filter, backend);
 128
 129   return f->filter.version;
 130 }
 131
 132 static void
 133 filter_usage (struct backend *b)
 134 {
 135   struct backend_filter *f = container_of (b, struct backend_filter, backend);
 136   const char *p;
 137
 138   printf ("filter: %s", f->name);
 139   if (f->filter.longname)
 140     printf (" (%s)", f->filter.longname);
 141   printf ("\n");
 142   printf ("(%s)\n", f->filename);
 143   if (f->filter.description) {
 144     printf ("%s", f->filter.description);
 145     if ((p = strrchr (f->filter.description, '\n')) == NULL || p[1])
 146       printf ("\n");
 147   }
 148   if (f->filter.config_help) {
 149     printf ("%s", f->filter.config_help);
 150     if ((p = strrchr (f->filter.config_help, '\n')) == NULL || p[1])
 151       printf ("\n");
 152   }
 153 }
 154
 155 static void
 156 filter_dump_fields (struct backend *b)
 157 {
 158   struct backend_filter *f = container_of (b, struct backend_filter, backend);
 159
 160   f->backend.next->dump_fields (f->backend.next);
 161 }
 162
 163 static int
 164 next_config (void *nxdata, const char *key, const char *value)
 165 {
 166   struct backend *b = nxdata;
 167   b->config (b, key, value);
 168   return 0;
 169 }
 170
 171 static void
 172 filter_config (struct backend *b, const char *key, const char *value)
 173 {
 174   struct backend_filter *f = container_of (b, struct backend_filter, backend);
 175
 176   debug ("%s: config key=%s, value=%s",
 177          f->name, key, value);
 178
 179   if (f->filter.config) {
 180     if (f->filter.config (next_config, f->backend.next, key, value) == -1)
 181       exit (EXIT_FAILURE);
 182   }
 183   else
 184     f->backend.next->config (f->backend.next, key, value);
 185 }
 186
 187 static int
 188 next_config_complete (void *nxdata)
 189 {
 190   struct backend *b = nxdata;
 191   b->config_complete (b);
 192   return 0;
 193 }
 194
 195 static void
 196 filter_config_complete (struct backend *b)
 197 {
 198   struct backend_filter *f = container_of (b, struct backend_filter, backend);
 199
 200   debug ("%s: config_complete", f->name);
 201
 202   if (f->filter.config_complete) {
 203     if (f->filter.config_complete (next_config_complete, f->backend.next) == -1)
 204       exit (EXIT_FAILURE);
 205   }
 206   else
 207     f->backend.next->config_complete (f->backend.next);
 208 }
 209
 210 /* magic_config_key only applies to plugins, so this passes the
 211  * request through to the plugin (hence the name).
 212  */
 213 static const char *
 214 plugin_magic_config_key (struct backend *b)
 215 {
 216   struct backend_filter *f = container_of (b, struct backend_filter, backend);
 217
 218   return f->backend.next->magic_config_key (f->backend.next);
 219 }
 220
 221 static int
 222 next_open (void *nxdata, int readonly)
 223 {
 224   struct b_conn *b_conn = nxdata;
 225
 226   return b_conn->b->open (b_conn->b, b_conn->conn, readonly);
 227 }
 228
 229 static int
 230 filter_open (struct backend *b, struct connection *conn, int readonly)
 231 {
 232   struct backend_filter *f = container_of (b, struct backend_filter, backend);
 233   struct b_conn nxdata = { .b = f->backend.next, .conn = conn };
 234   void *handle;
 235
 236   debug ("%s: open readonly=%d", f->name, readonly);
 237
 238   if (f->filter.open) {
 239     handle = f->filter.open (next_open, &nxdata, readonly);
 240     if (handle == NULL)
 241       return -1;
 242     connection_set_handle (conn, f->backend.i, handle);
 243     return 0;
 244   }
 245   else
 246     return f->backend.next->open (f->backend.next, conn, readonly);
 247 }
 248
 249 static void
 250 filter_close (struct backend *b, struct connection *conn)
 251 {
 252   struct backend_filter *f = container_of (b, struct backend_filter, backend);
 253   void *handle = connection_get_handle (conn, f->backend.i);
 254
 255   debug ("%s: close", f->name);
 256
 257   if (f->filter.close)
 258     f->filter.close (handle);
 259   f->backend.next->close (f->backend.next, conn);
 260 }
 261
 262 /* The next_functions structure contains pointers to backend
 263  * functions.  However because these functions are all expecting a
 264  * backend and a connection, we cannot call them directly, but must
 265  * write some next_* functions that unpack the two parameters from a
 266  * single ‘void *nxdata’ struct pointer (‘b_conn’).
 267  */
 268
 269 static int64_t
 270 next_get_size (void *nxdata)
 271 {
 272   struct b_conn *b_conn = nxdata;
 273   return b_conn->b->get_size (b_conn->b, b_conn->conn);
 274 }
 275
 276 static int
 277 next_can_write (void *nxdata)
 278 {
 279   struct b_conn *b_conn = nxdata;
 280   return b_conn->b->can_write (b_conn->b, b_conn->conn);
 281 }
 282
 283 static int
 284 next_can_flush (void *nxdata)
 285 {
 286   struct b_conn *b_conn = nxdata;
 287   return b_conn->b->can_flush (b_conn->b, b_conn->conn);
 288 }
 289
 290 static int
 291 next_is_rotational (void *nxdata)
 292 {
 293   struct b_conn *b_conn = nxdata;
 294   return b_conn->b->is_rotational (b_conn->b, b_conn->conn);
 295 }
 296
 297 static int
 298 next_can_trim (void *nxdata)
 299 {
 300   struct b_conn *b_conn = nxdata;
 301   return b_conn->b->can_trim (b_conn->b, b_conn->conn);
 302 }
 303
 304 static int
 305 next_can_zero (void *nxdata)
 306 {
 307   struct b_conn *b_conn = nxdata;
 308   return b_conn->b->can_zero (b_conn->b, b_conn->conn);
 309 }
 310
 311 static int
 312 next_can_extents (void *nxdata)
 313 {
 314   struct b_conn *b_conn = nxdata;
 315   return b_conn->b->can_extents (b_conn->b, b_conn->conn);
 316 }
 317
 318 static int
 319 next_can_fua (void *nxdata)
 320 {
 321   struct b_conn *b_conn = nxdata;
 322   return b_conn->b->can_fua (b_conn->b, b_conn->conn);
 323 }
 324
 325 static int
 326 next_can_multi_conn (void *nxdata)
 327 {
 328   struct b_conn *b_conn = nxdata;
 329   return b_conn->b->can_multi_conn (b_conn->b, b_conn->conn);
 330 }
 331
 332 static int
 333 next_pread (void *nxdata, void *buf, uint32_t count, uint64_t offset,
 334             uint32_t flags, int *err)
 335 {
 336   struct b_conn *b_conn = nxdata;
 337   return b_conn->b->pread (b_conn->b, b_conn->conn, buf, count, offset, flags,
 338                            err);
 339 }
 340
 341 static int
 342 next_pwrite (void *nxdata, const void *buf, uint32_t count, uint64_t offset,
 343              uint32_t flags, int *err)
 344 {
 345   struct b_conn *b_conn = nxdata;
 346   return b_conn->b->pwrite (b_conn->b, b_conn->conn, buf, count, offset, flags,
 347                             err);
 348 }
 349
 350 static int
 351 next_flush (void *nxdata, uint32_t flags, int *err)
 352 {
 353   struct b_conn *b_conn = nxdata;
 354   return b_conn->b->flush (b_conn->b, b_conn->conn, flags, err);
 355 }
 356
 357 static int
 358 next_trim (void *nxdata, uint32_t count, uint64_t offset, uint32_t flags,
 359            int *err)
 360 {
 361   struct b_conn *b_conn = nxdata;
 362   return b_conn->b->trim (b_conn->b, b_conn->conn, count, offset, flags, err);
 363 }
 364
 365 static int
 366 next_zero (void *nxdata, uint32_t count, uint64_t offset, uint32_t flags,
 367            int *err)
 368 {
 369   struct b_conn *b_conn = nxdata;
 370   return b_conn->b->zero (b_conn->b, b_conn->conn, count, offset, flags, err);
 371 }
 372
 373 static int
 374 next_extents (void *nxdata, uint32_t count, uint64_t offset, uint32_t flags,
 375               struct nbdkit_extents *extents, int *err)
 376 {
 377   struct b_conn *b_conn = nxdata;
 378   return b_conn->b->extents (b_conn->b, b_conn->conn, count, offset, flags,
 379                              extents, err);
 380 }
 381
 382 static struct nbdkit_next_ops next_ops = {
 383   .get_size = next_get_size,
 384   .can_write = next_can_write,
 385   .can_flush = next_can_flush,
 386   .is_rotational = next_is_rotational,
 387   .can_trim = next_can_trim,
 388   .can_zero = next_can_zero,
 389   .can_extents = next_can_extents,
 390   .can_fua = next_can_fua,
 391   .can_multi_conn = next_can_multi_conn,
 392   .pread = next_pread,
 393   .pwrite = next_pwrite,
 394   .flush = next_flush,
 395   .trim = next_trim,
 396   .zero = next_zero,
 397   .extents = next_extents,
 398 };
 399
 400 static int
 401 filter_prepare (struct backend *b, struct connection *conn)
 402 {
 403   struct backend_filter *f = container_of (b, struct backend_filter, backend);
 404   void *handle = connection_get_handle (conn, f->backend.i);
 405   struct b_conn nxdata = { .b = f->backend.next, .conn = conn };
 406
 407   debug ("%s: prepare", f->name);
 408
 409   /* Call these in order starting from the filter closest to the
 410    * plugin.
 411    */
 412   if (f->backend.next->prepare (f->backend.next, conn) == -1)
 413     return -1;
 414
 415   if (f->filter.prepare &&
 416       f->filter.prepare (&next_ops, &nxdata, handle) == -1)
 417     return -1;
 418
 419   return 0;
 420 }
 421
 422 static int
 423 filter_finalize (struct backend *b, struct connection *conn)
 424 {
 425   struct backend_filter *f = container_of (b, struct backend_filter, backend);
 426   void *handle = connection_get_handle (conn, f->backend.i);
 427   struct b_conn nxdata = { .b = f->backend.next, .conn = conn };
 428
 429   debug ("%s: finalize", f->name);
 430
 431   /* Call these in reverse order to .prepare above, starting from the
 432    * filter furthest away from the plugin.
 433    */
 434   if (f->filter.finalize &&
 435       f->filter.finalize (&next_ops, &nxdata, handle) == -1)
 436     return -1;
 437
 438   return f->backend.next->finalize (f->backend.next, conn);
 439 }
 440
 441 static int64_t
 442 filter_get_size (struct backend *b, struct connection *conn)
 443 {
 444   struct backend_filter *f = container_of (b, struct backend_filter, backend);
 445   void *handle = connection_get_handle (conn, f->backend.i);
 446   struct b_conn nxdata = { .b = f->backend.next, .conn = conn };
 447
 448   debug ("%s: get_size", f->name);
 449
 450   if (f->filter.get_size)
 451     return f->filter.get_size (&next_ops, &nxdata, handle);
 452   else
 453     return f->backend.next->get_size (f->backend.next, conn);
 454 }
 455
 456 static int
 457 filter_can_write (struct backend *b, struct connection *conn)
 458 {
 459   struct backend_filter *f = container_of (b, struct backend_filter, backend);
 460   void *handle = connection_get_handle (conn, f->backend.i);
 461   struct b_conn nxdata = { .b = f->backend.next, .conn = conn };
 462
 463   debug ("%s: can_write", f->name);
 464
 465   if (f->filter.can_write)
 466     return f->filter.can_write (&next_ops, &nxdata, handle);
 467   else
 468     return f->backend.next->can_write (f->backend.next, conn);
 469 }
 470
 471 static int
 472 filter_can_flush (struct backend *b, struct connection *conn)
 473 {
 474   struct backend_filter *f = container_of (b, struct backend_filter, backend);
 475   void *handle = connection_get_handle (conn, f->backend.i);
 476   struct b_conn nxdata = { .b = f->backend.next, .conn = conn };
 477
 478   debug ("%s: can_flush", f->name);
 479
 480   if (f->filter.can_flush)
 481     return f->filter.can_flush (&next_ops, &nxdata, handle);
 482   else
 483     return f->backend.next->can_flush (f->backend.next, conn);
 484 }
 485
 486 static int
 487 filter_is_rotational (struct backend *b, struct connection *conn)
 488 {
 489   struct backend_filter *f = container_of (b, struct backend_filter, backend);
 490   void *handle = connection_get_handle (conn, f->backend.i);
 491   struct b_conn nxdata = { .b = f->backend.next, .conn = conn };
 492
 493   debug ("%s: is_rotational", f->name);
 494
 495   if (f->filter.is_rotational)
 496     return f->filter.is_rotational (&next_ops, &nxdata, handle);
 497   else
 498     return f->backend.next->is_rotational (f->backend.next, conn);
 499 }
 500
 501 static int
 502 filter_can_trim (struct backend *b, struct connection *conn)
 503 {
 504   struct backend_filter *f = container_of (b, struct backend_filter, backend);
 505   void *handle = connection_get_handle (conn, f->backend.i);
 506   struct b_conn nxdata = { .b = f->backend.next, .conn = conn };
 507
 508   debug ("%s: can_trim", f->name);
 509
 510   if (f->filter.can_trim)
 511     return f->filter.can_trim (&next_ops, &nxdata, handle);
 512   else
 513     return f->backend.next->can_trim (f->backend.next, conn);
 514 }
 515
 516 static int
 517 filter_can_zero (struct backend *b, struct connection *conn)
 518 {
 519   struct backend_filter *f = container_of (b, struct backend_filter, backend);
 520   void *handle = connection_get_handle (conn, f->backend.i);
 521   struct b_conn nxdata = { .b = f->backend.next, .conn = conn };
 522
 523   debug ("%s: can_zero", f->name);
 524
 525   if (f->filter.can_zero)
 526     return f->filter.can_zero (&next_ops, &nxdata, handle);
 527   else
 528     return f->backend.next->can_zero (f->backend.next, conn);
 529 }
 530
 531 static int
 532 filter_can_extents (struct backend *b, struct connection *conn)
 533 {
 534   struct backend_filter *f = container_of (b, struct backend_filter, backend);
 535   void *handle = connection_get_handle (conn, f->backend.i);
 536   struct b_conn nxdata = { .b = f->backend.next, .conn = conn };
 537
 538   debug ("%s: can_extents", f->name);
 539
 540   if (f->filter.can_extents)
 541     return f->filter.can_extents (&next_ops, &nxdata, handle);
 542   else
 543     return f->backend.next->can_extents (f->backend.next, conn);
 544 }
 545
 546 static int
 547 filter_can_fua (struct backend *b, struct connection *conn)
 548 {
 549   struct backend_filter *f = container_of (b, struct backend_filter, backend);
 550   void *handle = connection_get_handle (conn, f->backend.i);
 551   struct b_conn nxdata = { .b = f->backend.next, .conn = conn };
 552
 553   debug ("%s: can_fua", f->name);
 554
 555   if (f->filter.can_fua)
 556     return f->filter.can_fua (&next_ops, &nxdata, handle);
 557   else
 558     return f->backend.next->can_fua (f->backend.next, conn);
 559 }
 560
 561 static int
 562 filter_can_multi_conn (struct backend *b, struct connection *conn)
 563 {
 564   struct backend_filter *f = container_of (b, struct backend_filter, backend);
 565   void *handle = connection_get_handle (conn, f->backend.i);
 566   struct b_conn nxdata = { .b = f->backend.next, .conn = conn };
 567
 568   debug ("%s: can_multi_conn", f->name);
 569
 570   if (f->filter.can_multi_conn)
 571     return f->filter.can_multi_conn (&next_ops, &nxdata, handle);
 572   else
 573     return f->backend.next->can_multi_conn (f->backend.next, conn);
 574 }
 575
 576 static int
 577 filter_pread (struct backend *b, struct connection *conn,
 578               void *buf, uint32_t count, uint64_t offset,
 579               uint32_t flags, int *err)
 580 {
 581   struct backend_filter *f = container_of (b, struct backend_filter, backend);
 582   void *handle = connection_get_handle (conn, f->backend.i);
 583   struct b_conn nxdata = { .b = f->backend.next, .conn = conn };
 584
 585   assert (flags == 0);
 586
 587   debug ("%s: pread count=%" PRIu32 " offset=%" PRIu64 " flags=0x%" PRIx32,
 588          f->name, count, offset, flags);
 589
 590   if (f->filter.pread)
 591     return f->filter.pread (&next_ops, &nxdata, handle,
 592                             buf, count, offset, flags, err);
 593   else
 594     return f->backend.next->pread (f->backend.next, conn,
 595                                    buf, count, offset, flags, err);
 596 }
 597
 598 static int
 599 filter_pwrite (struct backend *b, struct connection *conn,
 600                const void *buf, uint32_t count, uint64_t offset,
 601                uint32_t flags, int *err)
 602 {
 603   struct backend_filter *f = container_of (b, struct backend_filter, backend);
 604   void *handle = connection_get_handle (conn, f->backend.i);
 605   struct b_conn nxdata = { .b = f->backend.next, .conn = conn };
 606
 607   assert (!(flags & ~NBDKIT_FLAG_FUA));
 608
 609   debug ("%s: pwrite count=%" PRIu32 " offset=%" PRIu64 " flags=0x%" PRIx32,
 610          f->name, count, offset, flags);
 611
 612   if (f->filter.pwrite)
 613     return f->filter.pwrite (&next_ops, &nxdata, handle,
 614                              buf, count, offset, flags, err);
 615   else
 616     return f->backend.next->pwrite (f->backend.next, conn,
 617                                     buf, count, offset, flags, err);
 618 }
 619
 620 static int
 621 filter_flush (struct backend *b, struct connection *conn, uint32_t flags,
 622               int *err)
 623 {
 624   struct backend_filter *f = container_of (b, struct backend_filter, backend);
 625   void *handle = connection_get_handle (conn, f->backend.i);
 626   struct b_conn nxdata = { .b = f->backend.next, .conn = conn };
 627
 628   assert (flags == 0);
 629
 630   debug ("%s: flush flags=0x%" PRIx32, f->name, flags);
 631
 632   if (f->filter.flush)
 633     return f->filter.flush (&next_ops, &nxdata, handle, flags, err);
 634   else
 635     return f->backend.next->flush (f->backend.next, conn, flags, err);
 636 }
 637
 638 static int
 639 filter_trim (struct backend *b, struct connection *conn,
 640              uint32_t count, uint64_t offset,
 641              uint32_t flags, int *err)
 642 {
 643   struct backend_filter *f = container_of (b, struct backend_filter, backend);
 644   void *handle = connection_get_handle (conn, f->backend.i);
 645   struct b_conn nxdata = { .b = f->backend.next, .conn = conn };
 646
 647   assert (flags == 0);
 648
 649   debug ("%s: trim count=%" PRIu32 " offset=%" PRIu64 " flags=0x%" PRIx32,
 650          f->name, count, offset, flags);
 651
 652   if (f->filter.trim)
 653     return f->filter.trim (&next_ops, &nxdata, handle, count, offset, flags,
 654                            err);
 655   else
 656     return f->backend.next->trim (f->backend.next, conn, count, offset, flags,
 657                                   err);
 658 }
 659
 660 static int
 661 filter_zero (struct backend *b, struct connection *conn,
 662              uint32_t count, uint64_t offset, uint32_t flags, int *err)
 663 {
 664   struct backend_filter *f = container_of (b, struct backend_filter, backend);
 665   void *handle = connection_get_handle (conn, f->backend.i);
 666   struct b_conn nxdata = { .b = f->backend.next, .conn = conn };
 667
 668   assert (!(flags & ~(NBDKIT_FLAG_MAY_TRIM | NBDKIT_FLAG_FUA)));
 669
 670   debug ("%s: zero count=%" PRIu32 " offset=%" PRIu64 " flags=0x%" PRIx32,
 671          f->name, count, offset, flags);
 672
 673   if (f->filter.zero)
 674     return f->filter.zero (&next_ops, &nxdata, handle,
 675                            count, offset, flags, err);
 676   else
 677     return f->backend.next->zero (f->backend.next, conn,
 678                                   count, offset, flags, err);
 679 }
 680
 681 static int
 682 filter_extents (struct backend *b, struct connection *conn,
 683                 uint32_t count, uint64_t offset, uint32_t flags,
 684                 struct nbdkit_extents *extents, int *err)
 685 {
 686   struct backend_filter *f = container_of (b, struct backend_filter, backend);
 687   void *handle = connection_get_handle (conn, f->backend.i);
 688   struct b_conn nxdata = { .b = f->backend.next, .conn = conn };
 689
 690   assert (!(flags & ~NBDKIT_FLAG_REQ_ONE));
 691
 692   debug ("%s: extents count=%" PRIu32 " offset=%" PRIu64 " flags=0x%" PRIx32,
 693          f->name, count, offset, flags);
 694
 695   if (f->filter.extents)
 696     return f->filter.extents (&next_ops, &nxdata, handle,
 697                               count, offset, flags,
 698                               extents, err);
 699   else
 700     return f->backend.next->extents (f->backend.next, conn,
 701                                      count, offset, flags,
 702                                      extents, err);
 703 }
 704
 705 static struct backend filter_functions = {
 706   .free = filter_free,
 707   .thread_model = filter_thread_model,
 708   .name = filter_name,
 709   .plugin_name = plugin_name,
 710   .usage = filter_usage,
 711   .version = filter_version,
 712   .dump_fields = filter_dump_fields,
 713   .config = filter_config,
 714   .config_complete = filter_config_complete,
 715   .magic_config_key = plugin_magic_config_key,
 716   .open = filter_open,
 717   .prepare = filter_prepare,
 718   .finalize = filter_finalize,
 719   .close = filter_close,
 720   .get_size = filter_get_size,
 721   .can_write = filter_can_write,
 722   .can_flush = filter_can_flush,
 723   .is_rotational = filter_is_rotational,
 724   .can_trim = filter_can_trim,
 725   .can_zero = filter_can_zero,
 726   .can_extents = filter_can_extents,
 727   .can_fua = filter_can_fua,
 728   .can_multi_conn = filter_can_multi_conn,
 729   .pread = filter_pread,
 730   .pwrite = filter_pwrite,
 731   .flush = filter_flush,
 732   .trim = filter_trim,
 733   .zero = filter_zero,
 734   .extents = filter_extents,
 735 };
 736
 737 /* Register and load a filter. */
 738 struct backend *
 739 filter_register (struct backend *next, size_t index, const char *filename,
 740                  void *dl, struct nbdkit_filter *(*filter_init) (void))
 741 {
 742   struct backend_filter *f;
 743   const struct nbdkit_filter *filter;
 744   size_t i, len;
 745
 746   f = calloc (1, sizeof *f);
 747   if (f == NULL) {
 748   out_of_memory:
 749     perror ("strdup");
 750     exit (EXIT_FAILURE);
 751   }
 752
 753   f->backend = filter_functions;
 754   f->backend.next = next;
 755   f->backend.i = index;
 756   f->filename = strdup (filename);
 757   if (f->filename == NULL) goto out_of_memory;
 758   f->dl = dl;
 759
 760   debug ("registering filter %s", f->filename);
 761
 762   /* Call the initialization function which returns the address of the
 763    * filter's own 'struct nbdkit_filter'.
 764    */
 765   filter = filter_init ();
 766   if (!filter) {
 767     fprintf (stderr, "%s: %s: filter registration function failed\n",
 768              program_name, f->filename);
 769     exit (EXIT_FAILURE);
 770   }
 771
 772   /* We do not provide API or ABI guarantees for filters, other than
 773    * the ABI position of _api_version that will let us diagnose
 774    * mismatch when the API changes.
 775    */
 776   if (filter->_api_version != NBDKIT_FILTER_API_VERSION) {
 777     fprintf (stderr,
 778              "%s: %s: filter is incompatible with this version of nbdkit "
 779              "(_api_version = %d)\n",
 780              program_name, f->filename, filter->_api_version);
 781     exit (EXIT_FAILURE);
 782   }
 783
 784   f->filter = *filter;
 785
 786   /* Only filter.name is required. */
 787   if (f->filter.name == NULL) {
 788     fprintf (stderr, "%s: %s: filter must have a .name field\n",
 789              program_name, f->filename);
 790     exit (EXIT_FAILURE);
 791   }
 792
 793   len = strlen (f->filter.name);
 794   if (len == 0) {
 795     fprintf (stderr, "%s: %s: filter.name field must not be empty\n",
 796              program_name, f->filename);
 797     exit (EXIT_FAILURE);
 798   }
 799   for (i = 0; i < len; ++i) {
 800     if (!((f->filter.name[i] >= '0' && f->filter.name[i] <= '9') ||
 801           (f->filter.name[i] >= 'a' && f->filter.name[i] <= 'z') ||
 802           (f->filter.name[i] >= 'A' && f->filter.name[i] <= 'Z'))) {
 803       fprintf (stderr,
 804                "%s: %s: filter.name ('%s') field "
 805                "must contain only ASCII alphanumeric characters\n",
 806                program_name, f->filename, f->filter.name);
 807       exit (EXIT_FAILURE);
 808     }
 809   }
 810
 811   /* Copy the module's name into local storage, so that filter.name
 812    * survives past unload.
 813    */
 814   f->name = strdup (f->filter.name);
 815   if (f->name == NULL) {
 816     perror ("strdup");
 817     exit (EXIT_FAILURE);
 818   }
 819
 820   debug ("registered filter %s (name %s)", f->filename, f->name);
 821
 822   /* Set debug flags before calling load. */
 823   set_debug_flags (dl, f->name);
 824
 825   /* Call the on-load callback if it exists. */
 826   debug ("%s: load", f->name);
 827   if (f->filter.load)
 828     f->filter.load ();
 829
 830   return (struct backend *) f;
 831 }