[ovs-dev] [PATCH ovn v10 1/4] lib: Add infrastructure for VIF plug providers.

Frode Nordahl frode.nordahl at canonical.com
Fri Nov 5 14:00:11 UTC 2021


New lib/vif-plug-provider module contains the infrastructure for
registering VIF plug provider classes which may be hosted inside
or outside the core OVN repository.

New controller/vif-plug module adds internal interface for
interacting with the VIF plug providers.

Extend build system to allow building of built-in VIF plug
providers and linking an externally built VIF plug provider.

Signed-off-by: Frode Nordahl <frode.nordahl at canonical.com>
---
 Documentation/automake.mk                     |   2 +
 Documentation/topics/index.rst                |   1 +
 .../topics/vif-plug-providers/index.rst       |  32 +
 .../vif-plug-providers/vif-plug-providers.rst | 209 ++++++
 acinclude.m4                                  |  49 ++
 configure.ac                                  |   2 +
 controller/automake.mk                        |   4 +-
 controller/test-vif-plug.c                    |  72 ++
 controller/vif-plug.c                         | 634 ++++++++++++++++++
 controller/vif-plug.h                         |  80 +++
 lib/automake.mk                               |  10 +-
 lib/vif-plug-provider.c                       | 204 ++++++
 lib/vif-plug-provider.h                       | 163 +++++
 lib/vif-plug-providers/dummy/vif-plug-dummy.c | 120 ++++
 ovn-architecture.7.xml                        |  35 +-
 tests/automake.mk                             |  13 +-
 tests/ovn-vif-plug.at                         |   8 +
 17 files changed, 1622 insertions(+), 16 deletions(-)
 create mode 100644 Documentation/topics/vif-plug-providers/index.rst
 create mode 100644 Documentation/topics/vif-plug-providers/vif-plug-providers.rst
 create mode 100644 controller/test-vif-plug.c
 create mode 100644 controller/vif-plug.c
 create mode 100644 controller/vif-plug.h
 create mode 100644 lib/vif-plug-provider.c
 create mode 100644 lib/vif-plug-provider.h
 create mode 100644 lib/vif-plug-providers/dummy/vif-plug-dummy.c
 create mode 100644 tests/ovn-vif-plug.at

diff --git a/Documentation/automake.mk b/Documentation/automake.mk
index b3fd3d62b..704c80671 100644
--- a/Documentation/automake.mk
+++ b/Documentation/automake.mk
@@ -28,6 +28,8 @@ DOC_SOURCE = \
 	Documentation/topics/ovn-news-2.8.rst \
 	Documentation/topics/role-based-access-control.rst \
 	Documentation/topics/debugging-ddlog.rst \
+	Documentation/topics/vif-plug-providers/index.rst \
+	Documentation/topics/vif-plug-providers/vif-plug-providers.rst \
 	Documentation/howto/index.rst \
 	Documentation/howto/docker.rst \
 	Documentation/howto/firewalld.rst \
diff --git a/Documentation/topics/index.rst b/Documentation/topics/index.rst
index d58d5618b..e9e49c742 100644
--- a/Documentation/topics/index.rst
+++ b/Documentation/topics/index.rst
@@ -41,6 +41,7 @@ OVN
    high-availability
    role-based-access-control
    ovn-news-2.8
+   vif-plug-providers/index
    testing
 
 .. list-table::
diff --git a/Documentation/topics/vif-plug-providers/index.rst b/Documentation/topics/vif-plug-providers/index.rst
new file mode 100644
index 000000000..b7552ac4c
--- /dev/null
+++ b/Documentation/topics/vif-plug-providers/index.rst
@@ -0,0 +1,32 @@
+..
+      Licensed under the Apache License, Version 2.0 (the "License"); you may
+      not use this file except in compliance with the License. You may obtain
+      a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+      Unless required by applicable law or agreed to in writing, software
+      distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+      WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+      License for the specific language governing permissions and limitations
+      under the License.
+
+      Convention for heading levels in OVN documentation:
+
+      =======  Heading 0 (reserved for the title in a document)
+      -------  Heading 1
+      ~~~~~~~  Heading 2
+      +++++++  Heading 3
+      '''''''  Heading 4
+
+      Avoid deeper levels because they do not render well.
+
+==================
+VIF Plug Providers
+==================
+
+
+.. toctree::
+   :maxdepth: 2
+
+   vif-plug-providers
diff --git a/Documentation/topics/vif-plug-providers/vif-plug-providers.rst b/Documentation/topics/vif-plug-providers/vif-plug-providers.rst
new file mode 100644
index 000000000..77ecf7e0f
--- /dev/null
+++ b/Documentation/topics/vif-plug-providers/vif-plug-providers.rst
@@ -0,0 +1,209 @@
+..
+      Licensed under the Apache License, Version 2.0 (the "License"); you may
+      not use this file except in compliance with the License. You may obtain
+      a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+      Unless required by applicable law or agreed to in writing, software
+      distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+      WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+      License for the specific language governing permissions and limitations
+      under the License.
+
+      Convention for heading levels in OVN documentation:
+
+      =======  Heading 0 (reserved for the title in a document)
+      -------  Heading 1
+      ~~~~~~~  Heading 2
+      +++++++  Heading 3
+      '''''''  Heading 4
+
+      Avoid deeper levels because they do not render well.
+
+==================
+VIF Plug Providers
+==================
+
+Traditionally it has been the CMSes responsibility to create VIFs as part of
+instance life cycle, and subsequently manage plug/unplug operations on the
+integration bridge following the conventions described in the
+`Open vSwitch Integration Guide`_ for mapping of VIFs to OVN logical port.
+
+With the advent of NICs connected to multiple distinct CPUs we can have a
+topology where the instance runs on one host and Open vSwitch and OVN runs on
+a different host, the smartnic control plane CPU.  The host facing interfaces
+will be visible to Open vSwitch and OVN as representor ports.
+
+The actions necessary for plugging and unplugging the representor port in
+Open vSwitch running on the smartnic control plane CPU would be the same for
+every CMS.
+
+Instead of every CMS having to develop their own version of an agent to do
+the plugging, we provide a pluggable infrastructure in OVN that allows the
+`ovn-controller` to perform the plugging on CMS direction.
+
+Hardware or platform specific details for initialization and lookup of
+representor ports is provided by an plugging provider library hosted inside or
+outside the core OVN repository, and linked at OVN build time.
+
+Life Cycle of an OVN plugged VIF
+--------------------------------
+
+1. CMS creates a record in the OVN Northbound Logical_Switch_Port table with
+   the options column containing the `vif-plug-type` key with a value
+   corresponding to the `const char *type` provided by the VIF plug provider
+   implementation as well as a `requested-chassis` key with a value pointing at
+   the name or hostname of the chassis it wants the VIF plugged on.  Additional
+   VIF plug provider specific key/value pairs must be provided for successful
+   lookup.
+
+2. `ovn-northd` looks up the name or hostname provided in the
+   `requested-chassis` option and fills the OVN Southbound Port_Binding
+   requested_chassis column, it also copies relevant options over to the
+   Port_Binding record.
+
+3. `ovn-controller` monitors Southbound Port_Binding entries with a
+   requested_chassis column pointing at its chassis UUID.  When it encounters
+   an entry with option `vif-plug-type` and it has registered a VIF plug
+   provider matching that type, it will act on it even if no local binding
+   exists yet.
+
+4. It will fill the `struct vif_plug_port_ctx_in` as defined in
+   `lib/vif-plug.h` with `op_type` set to 'PLUG_OP_CREATE' and make a call to
+   the VIF plug providers `vif_plug_port_prepare` callback function.  VIF plug
+   provider performs lookup and fills the `struct vif_plug_port_ctx_out` as
+   defined in `lib/vif-plug.h`.
+
+5. `ovn-controller` creates a port and interface record in the local OVSDB
+   using the details provided by the VIF plug provider and also adds
+   `external-ids:iface-id` with value matching the logical port name and
+   `external-ids:ovn-plugged` with value matching the logical port
+   `vif-plug-type`.  When the port creation is done a call will first be made
+   to the VIF plug providers `vif_plug_port_finish` function and then to the
+   `vif_plug_port_ctx_destroy` function to free any memory allocated by the VIF
+   plug implementation.
+
+6. The Open vSwitch vswitchd will assign a ofport to the newly created
+   interface and on the next `ovn-controller` main loop iteration flows will be
+   installed.
+
+7. On each main loop iteration the `ovn-controller` will in addition to normal
+   flow processing make a call to the VIF plug provider again similar to the
+   first creation in case anything needs updating for the interface record.
+
+8. The port will be unplugged when an event occurs which would make the
+   `ovn-controller` release a logical port, for example the Logical_Switch_Port
+   and Port_Binding entry disappearing from the database or its
+   `requested_chassis` column being pointed to a different chassis.
+
+
+The VIF plug provider interface
+-------------------------------
+
+The interface between internals of OVN and a VIF plug provider is a set of
+callbacks as defined by the `struct vif_plug_class` in
+`lib/vif-plug-provider.h`.
+
+It is important to note that these callbacks will be called in the critical
+path of the `ovn-controller` processing loop, so care must be taken to make the
+implementation as efficient as possible, and under no circumstance can any of
+the callback functions make calls that block.
+
+On `ovn-controller` startup, VIF plug providers made available at build time
+will be registered by the identifier provided in the `const char *type`
+pointer, at this time the `init` function pointer will be called if it is
+non-NULL.
+
+> **Note**: apart from the `const char *type` pointer, no attempt will be made
+            to access VIF plug provider data or functions before the call to
+            the `init` has been made.
+
+On `ovn-controller` exit, the VIF plug providers registered in the above
+mentioned procedure will have their `destroy` function pointer called if it is
+non-NULL.
+
+If the VIF plug provider has internal lookup tables that need to be maintained
+they can define a `run` function which will be called as part of the
+`ovn-controller` main loop.  If there are any changes encountered the function
+should return 'true' to signal that further processing is necessary, 'false'
+otherwise.
+
+On update of Interface records the `ovn-controller` will pass on a `sset`
+to the `ovsport_update_iface` function containing options the plug
+implementation finds pertinent to maintain for successful operation.  This
+`sset` is retrieved by making a call to the plug implementation
+`vif_plug_get_maintained_iface_options` function pointer if it is non-NULL.
+This allows presence of other users of the OVSDB maintaining a different set of
+options on the same set of Interface records without wiping out their changes.
+
+Before creating or updating an existing interface record the VIF plug provider
+`vif_plug_port_prepare` function pointer will be called with valid pointers to
+`struct vif_plug_port_ctx_in` and `struct vif_plug_port_ctx_out` data
+structures.  If the VIF plug provider implementation is able to perform lookup
+it should fill the `struct vif_plug_port_ctx_out` data structure and return
+'true'.  The `ovn-controller` will then create or update the port/interface
+records and then call `vif_plug_port_finish` when the transactions commits and
+`vif_plug_port_ctx_destroy` to free any allocated memory.  If the VIF plug
+provider implementation is unable to perform lookup or prepare the desired
+resource at this time, it should return 'false' which will tell the
+`ovn-controller` to not plug the port, in this case it will not call
+`vif_plug_port_finish` nor `vif_plug_port_ctx_destroy`.
+
+> **Note**: The VIF plug provider implementation should exhaust all
+            non-blocking options to succeed with lookup from within the
+            `vif_plug_port_prepare` handler, including refreshing lookup
+            tables if necessary.
+
+Before removing port and interface records previously plugged by the
+`ovn-controller` as identified by presence of the Interface
+`external-ids:ovn-plugged` key, the `ovn-controller` will look up the
+`vif-plug-type` from `external-ids:ovn-plugged`, fill
+`struct vif_plug_port_ctx_in` with `op_type` set to 'PLUG_OP_REMOVE' and make a
+call to `vif_plug_port_prepare`.  After the port and interface has been removed
+a call will be made to `vif_plug_port_finish`.  Both calls will be made with
+the pointer to `vif_plug_port_ctx_out` set to 'NULL', and no call will be made
+to `vif_plug_port_ctx_destroy`.
+
+Building with in-tree VIF plug providers
+----------------------------------------
+
+VIF plug providers hosted in the OVN repository live under
+`lib/vif-plug-providers`:
+
+To enable them, provide the `--enable-vif-plug-providers` command line option
+to the configure script when building OVN.
+
+Building with an externally provided VIF plug provider
+------------------------------------------------------
+
+There is also infrastructure in place to support linking OVN with an externally
+built VIF plug provider.
+
+This external VIF plug provider must define a NULL-terminated array of pointers
+to `struct vif_plug_class` data structures named `vif_plug_provider_classes`.
+Example:
+
+.. code-block:: none
+
+   const struct vif_plug_class *vif_plug_provider_classes[] = {
+       &vif_plug_foo,
+       NULL,
+   };
+
+The name of the repository for the external VIF plug provider should be the
+same as the name of the library it produces, and the built library artifact
+should be placed in lib/.libs.  Example:
+
+.. code-block:: none
+
+   ovn-vif-foo/
+   ovn-vif-foo/lib/.libs/libovn-vif-foo.la
+
+To enable such a VIF plug provider provide the
+`--with-vif-plug-provider=/path/to/ovn-vif-foo` command line option to the
+configure script when building OVN.
+
+.. LINKS
+.. _Open vSwitch Integration Guide:
+   https://docs.openvswitch.org/en/latest/topics/integration/
diff --git a/acinclude.m4 b/acinclude.m4
index e7f829520..3e4a54086 100644
--- a/acinclude.m4
+++ b/acinclude.m4
@@ -441,3 +441,52 @@ AC_DEFUN([OVN_CHECK_OVS], [
   AC_MSG_CHECKING([OVS version])
   AC_MSG_RESULT([$OVSVERSION])
 ])
+
+dnl OVN_CHECK_VIF_PLUG_PROVIDER
+dnl
+dnl Check for external VIF plug provider
+AC_DEFUN([OVN_CHECK_VIF_PLUG_PROVIDER], [
+  AC_ARG_VAR([VIF_PLUG_PROVIDER])
+  AC_ARG_WITH(
+    [vif-plug-provider],
+    [AC_HELP_STRING([--with-vif-plug-provider=/path/to/provider/repository],
+                    [Specify path to a configured and built VIF plug provider repository])],
+    [if test "$withval" = yes; then
+       if test -z "$VIF_PLUG_PROVIDER"; then
+         AC_MSG_ERROR([To build with external VIF plug provider, specify the path to a configured and built plug provider repository --with-vif-plug-provider or in \$VIF_PLUG_PROVIDER]),
+       fi
+       VIF_PLUG_PROVIDER="$(realpath $VIF_PLUG_PROVIDER)"
+     else
+       VIF_PLUG_PROVIDER="$(realpath $withval)"
+     fi
+     _vif_plug_provider_name="$(basename $VIF_PLUG_PROVIDER)"
+     if test ! -f "$VIF_PLUG_PROVIDER/lib/.libs/lib${_vif_plug_provider_name}.la"; then
+       AC_MSG_ERROR([$withval is not a configured and built VIF plug provider library repository])
+     fi
+     VIF_PLUG_PROVIDER_LDFLAGS="-L$VIF_PLUG_PROVIDER/lib/.libs -l$_vif_plug_provider_name"
+    ],
+    [VIF_PLUG_PROVIDER=no])
+  AC_MSG_CHECKING([for VIF plug provider])
+  AC_MSG_RESULT([$VIF_PLUG_PROVIDER])
+  AC_SUBST([VIF_PLUG_PROVIDER_LDFLAGS])
+  AM_CONDITIONAL([HAVE_VIF_PLUG_PROVIDER], [test "$VIF_PLUG_PROVIDER" != no])
+  if test "$VIF_PLUG_PROVIDER" != no; then
+    AC_DEFINE([HAVE_VIF_PLUG_PROVIDER], [1],
+              [Build and link with external VIF plug provider])
+  fi
+])
+
+dnl OVN_ENABLE_VIF_PLUG
+dnl
+dnl Enable built-in plug providers
+AC_DEFUN([OVN_ENABLE_VIF_PLUG], [
+    AC_ARG_ENABLE(
+      [vif-plug-providers],
+      [AC_HELP_STRING([--enable-vif-plug-providers], [Enable building of built-in VIF plug providers])],
+      [], [enable_vif_plug=no])
+    AM_CONDITIONAL([ENABLE_VIF_PLUG], [test "$enable_vif_plug" != no])
+    if test "$enable_vif_plug" != no; then
+      AC_DEFINE([ENABLE_VIF_PLUG], [1],
+                [Build built-in VIF plug providers])
+    fi
+])
diff --git a/configure.ac b/configure.ac
index d1b9b4d55..5a3a5987b 100644
--- a/configure.ac
+++ b/configure.ac
@@ -172,6 +172,8 @@ OVS_ENABLE_SPARSE
 OVS_CHECK_DDLOG([0.47])
 OVS_CHECK_PRAGMA_MESSAGE
 OVN_CHECK_OVS
+OVN_CHECK_VIF_PLUG_PROVIDER
+OVN_ENABLE_VIF_PLUG
 OVS_CTAGS_IDENTIFIERS
 AC_SUBST([OVS_CFLAGS])
 AC_SUBST([OVS_LDFLAGS])
diff --git a/controller/automake.mk b/controller/automake.mk
index ad2d68af2..9f9b49fe0 100644
--- a/controller/automake.mk
+++ b/controller/automake.mk
@@ -37,7 +37,9 @@ controller_ovn_controller_SOURCES = \
 	controller/local_data.c \
 	controller/local_data.h \
 	controller/ovsport.h \
-	controller/ovsport.c
+	controller/ovsport.c \
+	controller/vif-plug.h \
+	controller/vif-plug.c
 
 controller_ovn_controller_LDADD = lib/libovn.la $(OVS_LIBDIR)/libopenvswitch.la
 man_MANS += controller/ovn-controller.8
diff --git a/controller/test-vif-plug.c b/controller/test-vif-plug.c
new file mode 100644
index 000000000..01ff37d8f
--- /dev/null
+++ b/controller/test-vif-plug.c
@@ -0,0 +1,72 @@
+/* Copyright (c) 2021, Canonical
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <config.h>
+#include <errno.h>
+
+#include "vif-plug.h"
+#include "vif-plug-provider.h"
+#include "smap.h"
+#include "sset.h"
+#include "tests/ovstest.h"
+
+static void
+test_vif_plug(struct ovs_cmdl_context *ctx OVS_UNUSED)
+{
+    const struct vif_plug_class *vif_plug_class;
+
+    ovs_assert(vif_plug_provider_unregister("dummy") == EINVAL);
+
+    ovs_assert(!vif_plug_provider_register(&vif_plug_dummy_class));
+    vif_plug_class = vif_plug_provider_get("dummy");
+    ovs_assert(vif_plug_provider_register(&vif_plug_dummy_class) == EEXIST);
+
+    ovs_assert(
+        sset_contains(
+            vif_plug_get_maintained_iface_options(vif_plug_class),
+            "plug-dummy-option"));
+
+    struct vif_plug_port_ctx_in ctx_in = {
+        .op_type = PLUG_OP_CREATE,
+        .lport_name = "lsp1",
+        .lport_options = SMAP_INITIALIZER(&ctx_in.lport_options),
+    };
+    struct vif_plug_port_ctx_out ctx_out;
+    vif_plug_port_prepare(vif_plug_class, &ctx_in, &ctx_out);
+    ovs_assert(!strcmp(ctx_out.name, "lsp1"));
+    ovs_assert(!strcmp(ctx_out.type, "internal"));
+    ovs_assert(!strcmp(smap_get(
+            &ctx_out.iface_options, "vif-plug-dummy-option"), "value"));
+
+    vif_plug_port_finish(vif_plug_class, &ctx_in, &ctx_out);
+    vif_plug_port_ctx_destroy(vif_plug_class, &ctx_in, &ctx_out);
+    vif_plug_provider_destroy_all();
+}
+
+static void
+test_vif_plug_main(int argc, char *argv[])
+{
+    set_program_name(argv[0]);
+    static const struct ovs_cmdl_command commands[] = {
+        {"run", NULL, 0, 0, test_vif_plug, OVS_RO},
+        {NULL, NULL, 0, 0, NULL, OVS_RO},
+    };
+    struct ovs_cmdl_context ctx;
+    ctx.argc = argc - 1;
+    ctx.argv = argv + 1;
+    ovs_cmdl_run_command(&ctx, commands);
+}
+
+OVSTEST_REGISTER("test-vif-plug", test_vif_plug_main);
diff --git a/controller/vif-plug.c b/controller/vif-plug.c
new file mode 100644
index 000000000..1015a4c13
--- /dev/null
+++ b/controller/vif-plug.c
@@ -0,0 +1,634 @@
+/*
+ * Copyright (c) 2021 Canonical
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <config.h>
+
+/* OVS includes */
+#include "lib/vswitch-idl.h"
+#include "openvswitch/shash.h"
+#include "openvswitch/vlog.h"
+
+/* OVN includes */
+#include "binding.h"
+#include "lib/ovn-sb-idl.h"
+#include "lport.h"
+#include "ovsport.h"
+#include "vif-plug.h"
+#include "vif-plug-provider.h"
+
+VLOG_DEFINE_THIS_MODULE(vif_plug);
+
+#define OVN_PLUGGED_EXT_ID "ovn-plugged"
+#define VIF_PLUG_OPTION_TYPE "vif-plug-type"
+#define VIF_PLUG_OPTION_MTU_REQUEST "vif-plug-mtu-request"
+
+void
+vif_plug_register_ovs_idl(struct ovsdb_idl *ovs_idl)
+{
+    ovsdb_idl_track_add_column(ovs_idl, &ovsrec_interface_col_mtu_request);
+}
+
+/* Get the class level 'maintained_iface_options' set. */
+const struct sset *
+vif_plug_get_maintained_iface_options(
+        const struct vif_plug_class *vif_plug_class)
+{
+    return vif_plug_class->vif_plug_get_maintained_iface_options ?
+           vif_plug_class->vif_plug_get_maintained_iface_options() : NULL;
+}
+
+/* Prepare the logical port as identified by 'ctx_in' for port creation, update
+ * or removal as specified by 'ctx_in->op_type'.
+ *
+ * When 'ctx_in->op_type' is PLUG_OP_CREATE the plug implementation must fill
+ * 'ctx_out' with data to apply to the interface record maintained by OVN on
+ * its behalf.
+ *
+ * When 'ctx_in_op_type' is PLUG_OP_REMOVE 'ctx_out' should be set to NULL and
+ * the plug implementation must not attempt to use 'ctx_out'.
+ *
+ * The data in 'ctx_out' is owned by the plug implementation, and a call must
+ * be made to vif_plug_port_ctx_destroy when done with it. */
+bool
+vif_plug_port_prepare(const struct vif_plug_class *vif_plug_class,
+                      const struct vif_plug_port_ctx_in *ctx_in,
+                      struct vif_plug_port_ctx_out *ctx_out)
+{
+    return vif_plug_class->vif_plug_port_prepare(ctx_in, ctx_out);
+}
+
+/* Notify the VIF plug implementation that a port creation, update or removal
+ * has been committed to the database. */
+void
+vif_plug_port_finish(const struct vif_plug_class *vif_plug_class,
+                     const struct vif_plug_port_ctx_in *ctx_in,
+                     struct vif_plug_port_ctx_out *ctx_out)
+{
+    vif_plug_class->vif_plug_port_finish(ctx_in, ctx_out);
+}
+
+/* Free any data allocated to 'ctx_out' in a prevous call to
+ * vif_plug_port_prepare. */
+void
+vif_plug_port_ctx_destroy(const struct vif_plug_class *vif_plug_class,
+                          const struct vif_plug_port_ctx_in *ctx_in,
+                          struct vif_plug_port_ctx_out *ctx_out)
+{
+    vif_plug_class->vif_plug_port_ctx_destroy(ctx_in, ctx_out);
+}
+
+static struct vif_plug_port_ctx *
+build_port_ctx(const struct vif_plug_class *vif_plug,
+                  const enum vif_plug_op_type op_type,
+                  const struct vif_plug_ctx_in *vif_plug_ctx_in,
+                  const struct sbrec_port_binding *pb,
+                  const struct ovsrec_interface *iface,
+                  const char *iface_id)
+{
+    struct vif_plug_port_ctx *new_ctx = xzalloc(
+        sizeof *new_ctx);
+
+    new_ctx->vif_plug = vif_plug;
+    new_ctx->vif_plug_port_ctx_in.op_type = op_type;
+    new_ctx->vif_plug_port_ctx_in.ovs_table = vif_plug_ctx_in->ovs_table;
+    new_ctx->vif_plug_port_ctx_in.br_int = vif_plug_ctx_in->br_int;
+    new_ctx->vif_plug_port_ctx_in.lport_name = pb ?
+        xstrdup(pb->logical_port) : iface_id ? xstrdup(iface_id) : NULL;
+    /* Prepare vif_plug_port_ctx_in smaps for use.
+     *
+     * Note that smap_init does not allocate memory.  Any memory allocated by
+     * putting data into the vif_plug_port_ctx_in smaps will be destroyed by
+     * calls to smap_destroy in destroy_port_ctx */
+    smap_init(&new_ctx->vif_plug_port_ctx_in.lport_options);
+    smap_init(&new_ctx->vif_plug_port_ctx_in.iface_options);
+
+    if (pb) {
+        smap_clone(&new_ctx->vif_plug_port_ctx_in.lport_options,
+                   &pb->options);
+    }
+
+    if (iface) {
+        new_ctx->vif_plug_port_ctx_in.iface_name = xstrdup(iface->name);
+        new_ctx->vif_plug_port_ctx_in.iface_type = xstrdup(iface->type);
+        smap_clone(&new_ctx->vif_plug_port_ctx_in.iface_options,
+                   &iface->options);
+    }
+
+    /* Prepare vif_plug_port_ctx_out smaps for use.
+     *
+     * Note that smap_init does not allocate memory.  Any memory allocated by
+     * putting data into the vif_plug_port_ctx_out smaps is the responsibility
+     * of the VIF plug provider through a call to vif_plug_port_ctx_destroy. */
+    smap_init(&new_ctx->vif_plug_port_ctx_out.iface_options);
+
+    return new_ctx;
+}
+
+static void
+destroy_port_ctx(struct vif_plug_port_ctx *ctx)
+{
+    smap_destroy(&ctx->vif_plug_port_ctx_in.lport_options);
+    smap_destroy(&ctx->vif_plug_port_ctx_in.iface_options);
+    if (ctx->vif_plug_port_ctx_in.lport_name) {
+        free((char *)ctx->vif_plug_port_ctx_in.lport_name);
+    }
+    if (ctx->vif_plug_port_ctx_in.iface_name) {
+        free((char *)ctx->vif_plug_port_ctx_in.iface_name);
+    }
+    if (ctx->vif_plug_port_ctx_in.iface_type) {
+        free((char *)ctx->vif_plug_port_ctx_in.iface_type);
+    }
+    /* Note that data associated with ctx->vif_plug_port_ctx_out must be
+     * destroyed by the plug provider implementation with a call to
+     * vif_plug_port_ctx_destroy prior to calling this function */
+    free(ctx);
+}
+
+/* Our contract with the VIF plug provider is that vif_plug_port_finish
+ * will be called with vif_plug_port_ctx_* objects once the transaction
+ * commits.  To handle this we keep track of in-flight deletions
+ * and changes.  The tracking data will be cleared after commit at the end of
+ * the ovn-controller main loop. */
+static void
+transact_delete_port(const struct vif_plug_ctx_in *vif_plug_ctx_in,
+                     const struct vif_plug_ctx_out *vif_plug_ctx_out,
+                     const struct vif_plug_port_ctx *vif_plug_port_ctx,
+                     const struct ovsrec_port *port)
+{
+    shash_add(vif_plug_ctx_out->deleted_iface_ids,
+              vif_plug_port_ctx->vif_plug_port_ctx_in.lport_name,
+              vif_plug_port_ctx);
+    ovsport_remove(vif_plug_ctx_in->br_int, port);
+}
+
+static void
+transact_create_port(const struct vif_plug_ctx_in *vif_plug_ctx_in,
+                     const struct vif_plug_ctx_out *vif_plug_ctx_out,
+                     const struct vif_plug_port_ctx *vif_plug_port_ctx,
+                     const struct smap *iface_external_ids,
+                     const int64_t mtu_request)
+{
+    shash_add(vif_plug_ctx_out->changed_iface_ids,
+              vif_plug_port_ctx->vif_plug_port_ctx_in.lport_name,
+              vif_plug_port_ctx);
+    ovsport_create(vif_plug_ctx_in->ovs_idl_txn, vif_plug_ctx_in->br_int,
+                   vif_plug_port_ctx->vif_plug_port_ctx_out.name,
+                   vif_plug_port_ctx->vif_plug_port_ctx_out.type,
+                   NULL, iface_external_ids,
+                   &vif_plug_port_ctx->vif_plug_port_ctx_out.iface_options,
+                   mtu_request);
+}
+
+static void
+transact_update_port(const struct ovsrec_interface *iface_rec,
+                     const struct vif_plug_ctx_in *vif_plug_ctx_in OVS_UNUSED,
+                     const struct vif_plug_ctx_out *vif_plug_ctx_out,
+                     const struct vif_plug_port_ctx *vif_plug_port_ctx,
+                     const struct smap *iface_external_ids,
+                     const int64_t mtu_request)
+{
+    shash_add(vif_plug_ctx_out->changed_iface_ids,
+              vif_plug_port_ctx->vif_plug_port_ctx_in.lport_name,
+              vif_plug_port_ctx);
+    ovsport_update_iface(
+        iface_rec,
+        vif_plug_port_ctx->vif_plug_port_ctx_out.type,
+        iface_external_ids,
+        NULL,
+        &vif_plug_port_ctx->vif_plug_port_ctx_out.iface_options,
+        vif_plug_get_maintained_iface_options(
+            vif_plug_port_ctx->vif_plug),
+        mtu_request);
+}
+
+
+static bool
+consider_unplug_iface(const struct ovsrec_interface *iface,
+                      const struct sbrec_port_binding *pb,
+                      struct vif_plug_ctx_in *vif_plug_ctx_in,
+                      struct vif_plug_ctx_out *vif_plug_ctx_out)
+{
+    const char *vif_plug_type = smap_get(&iface->external_ids,
+                                         OVN_PLUGGED_EXT_ID);
+    const char *iface_id = smap_get(&iface->external_ids, "iface-id");
+    const struct ovsrec_port *port = ovsport_lookup_by_interface(
+        vif_plug_ctx_in->ovsrec_port_by_interfaces,
+        (struct ovsrec_interface *) iface);
+
+    if (vif_plug_type && iface_id && port) {
+        const struct vif_plug_class *vif_plug;
+        if (!(vif_plug = vif_plug_provider_get(vif_plug_type))) {
+            static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 1);
+            VLOG_WARN_RL(&rl,
+                         "Unable to open VIF plug provider for "
+                         "%s %s iface-id %s",
+                         VIF_PLUG_OPTION_TYPE, vif_plug_type, iface_id);
+            /* While we are unable to handle this, asking for a recompute
+             * will not change that fact. */
+            return true;
+        }
+        if (!vif_plug_ctx_in->chassis_rec || !vif_plug_ctx_in->br_int
+            || !vif_plug_ctx_in->ovs_idl_txn)
+        {
+            /* Some of our prerequisites are not available, ask for a
+             * recompute. */
+            return false;
+        }
+
+        /* Our contract with the VIF plug provider is that vif_plug_port_finish
+         * will be called with a vif_plug_port_ctx_in object once the
+         * transaction commits.
+         *
+         * Since this happens asynchronously we need to allocate memory for
+         * and duplicate any database references so that they stay valid.
+         *
+         * The data is freed with a call to destroy_port_ctx after the
+         * transaction completes at the end of the ovn-controller main
+         * loop. */
+        struct vif_plug_port_ctx *vif_plug_port_ctx = build_port_ctx(
+            vif_plug, PLUG_OP_REMOVE, vif_plug_ctx_in, pb, iface, iface_id);
+
+        if (!vif_plug_port_prepare(vif_plug,
+                                   &vif_plug_port_ctx->vif_plug_port_ctx_in,
+                                   NULL)) {
+            static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 1);
+            VLOG_INFO_RL(&rl,
+                         "Not unplugging iface %s (iface-id %s) on direction "
+                         "from VIF plug provider.",
+                         iface->name, iface_id);
+            destroy_port_ctx(vif_plug_port_ctx);
+            return true;
+        }
+        VLOG_INFO("Unplugging port %s from %s for iface-id %s on this "
+                  "chassis.",
+                  port->name,
+                  vif_plug_ctx_in->br_int->name,
+                  iface_id);
+
+        /* Add and track delete operation to the transaction */
+        transact_delete_port(vif_plug_ctx_in, vif_plug_ctx_out,
+                             vif_plug_port_ctx, port);
+        return true;
+    }
+    return true;
+}
+
+static int64_t
+get_plug_mtu_request(const struct smap *lport_options)
+{
+    return smap_get_int(lport_options, VIF_PLUG_OPTION_MTU_REQUEST, 0);
+}
+
+static bool
+consider_plug_lport_create__(const struct vif_plug_class *vif_plug,
+                             const struct smap *iface_external_ids,
+                             const struct sbrec_port_binding *pb,
+                             struct vif_plug_ctx_in *vif_plug_ctx_in,
+                             struct vif_plug_ctx_out *vif_plug_ctx_out)
+{
+    if (!vif_plug_ctx_in->chassis_rec || !vif_plug_ctx_in->br_int
+        || !vif_plug_ctx_in->ovs_idl_txn) {
+        /* Some of our prerequisites are not available, ask for a recompute. */
+        return false;
+    }
+
+    /* Our contract with the VIF plug provider is that vif_plug_port_finish
+     * will be called with vif_plug_port_ctx_in and vif_plug_port_ctx_out
+     * objects once the transaction commits.
+     *
+     * Since this happens asynchronously we need to allocate memory for
+     * and duplicate any database references so that they stay valid.
+     *
+     * The data is freed with a call to destroy_port_ctx after the
+     * transaction completes at the end of the ovn-controller main
+     * loop. */
+    struct vif_plug_port_ctx *vif_plug_port_ctx = build_port_ctx(
+        vif_plug, PLUG_OP_CREATE, vif_plug_ctx_in, pb, NULL, NULL);
+
+    if (!vif_plug_port_prepare(vif_plug,
+                           &vif_plug_port_ctx->vif_plug_port_ctx_in,
+                           &vif_plug_port_ctx->vif_plug_port_ctx_out)) {
+        static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 1);
+        VLOG_INFO_RL(&rl,
+                     "Not plugging lport %s on direction from VIF plug "
+                     "provider.",
+                     pb->logical_port);
+        destroy_port_ctx(vif_plug_port_ctx);
+        return true;
+    }
+
+    VLOG_INFO("Plugging port %s into %s for lport %s on this "
+              "chassis.",
+              vif_plug_port_ctx->vif_plug_port_ctx_out.name,
+              vif_plug_ctx_in->br_int->name,
+              pb->logical_port);
+    transact_create_port(vif_plug_ctx_in, vif_plug_ctx_out,
+                         vif_plug_port_ctx,
+                         iface_external_ids,
+                         get_plug_mtu_request(&pb->options));
+    return true;
+}
+
+static bool
+consider_plug_lport_update__(const struct vif_plug_class *vif_plug,
+                             const struct smap *iface_external_ids,
+                             const struct sbrec_port_binding *pb,
+                             struct local_binding *lbinding,
+                             struct vif_plug_ctx_in *vif_plug_ctx_in,
+                             struct vif_plug_ctx_out *vif_plug_ctx_out)
+{
+    if (!vif_plug_ctx_in->chassis_rec || !vif_plug_ctx_in->br_int
+        || !vif_plug_ctx_in->ovs_idl_txn) {
+        /* Some of our prerequisites are not available, ask for a recompute. */
+        return false;
+    }
+    /* Our contract with the VIF plug provider is that vif_plug_port_finish
+     * will be called with vif_plug_port_ctx_in and vif_plug_port_ctx_out
+     * objects once the transaction commits.
+     *
+     * Since this happens asynchronously we need to allocate memory for
+     * and duplicate any database references so that they stay valid.
+     *
+     * The data is freed with a call to destroy_port_ctx after the
+     * transaction completes at the end of the ovn-controller main
+     * loop. */
+    struct vif_plug_port_ctx *vif_plug_port_ctx = build_port_ctx(
+        vif_plug, PLUG_OP_CREATE, vif_plug_ctx_in, pb, NULL, NULL);
+
+    if (!vif_plug_port_prepare(vif_plug,
+                               &vif_plug_port_ctx->vif_plug_port_ctx_in,
+                               &vif_plug_port_ctx->vif_plug_port_ctx_out)) {
+        static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 1);
+        VLOG_INFO_RL(&rl,
+                     "Not updating lport %s on direction from VIF plug "
+                     "provider.",
+                     pb->logical_port);
+        destroy_port_ctx(vif_plug_port_ctx);
+        return true;
+    }
+
+    if (strcmp(lbinding->iface->name,
+               vif_plug_port_ctx->vif_plug_port_ctx_out.name)) {
+        VLOG_WARN("Attempt of incompatible change to existing "
+                  "port detected, please recreate port: %s",
+                   pb->logical_port);
+        vif_plug_port_ctx_destroy(vif_plug,
+                                  &vif_plug_port_ctx->vif_plug_port_ctx_in,
+                                  &vif_plug_port_ctx->vif_plug_port_ctx_out);
+        destroy_port_ctx(vif_plug_port_ctx);
+        return false;
+    }
+    VLOG_DBG("updating iface for: %s", pb->logical_port);
+    transact_update_port(lbinding->iface, vif_plug_ctx_in, vif_plug_ctx_out,
+                         vif_plug_port_ctx, iface_external_ids,
+                         get_plug_mtu_request(&pb->options));
+
+    return true;
+}
+
+static bool
+consider_plug_lport(const struct sbrec_port_binding *pb,
+                    struct local_binding *lbinding,
+                    struct vif_plug_ctx_in *vif_plug_ctx_in,
+                    struct vif_plug_ctx_out *vif_plug_ctx_out)
+{
+    bool ret = true;
+    if (lport_can_bind_on_this_chassis(vif_plug_ctx_in->chassis_rec, pb)
+        && pb->requested_chassis == vif_plug_ctx_in->chassis_rec) {
+        const char *vif_plug_type = smap_get(&pb->options,
+                                             VIF_PLUG_OPTION_TYPE);
+        if (!vif_plug_type) {
+            /* Nothing for us to do and we don't need a recompute. */
+            return true;
+        }
+
+        static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 1);
+        const struct vif_plug_class *vif_plug;
+        if (!(vif_plug = vif_plug_provider_get(vif_plug_type))) {
+            VLOG_WARN_RL(&rl,
+                         "Unable to open VIF plug provider for %s: '%s' "
+                         "lport %s",
+                         VIF_PLUG_OPTION_TYPE,
+                         vif_plug_type,
+                         pb->logical_port);
+            /* While we are unable to handle this, asking for a recompute will
+             * not change that fact. */
+            return true;
+        }
+        const struct smap iface_external_ids = SMAP_CONST2(
+                &iface_external_ids,
+                OVN_PLUGGED_EXT_ID, vif_plug_type,
+                "iface-id", pb->logical_port);
+        if (lbinding && lbinding->iface) {
+            if (!smap_get(&lbinding->iface->external_ids,
+                          OVN_PLUGGED_EXT_ID))
+            {
+                VLOG_WARN_RL(&rl,
+                             "CMS requested plugging of lport %s, but a port "
+                             "that is not maintained by OVN already exsist "
+                             "in local vSwitch: "UUID_FMT,
+                             pb->logical_port,
+                             UUID_ARGS(&lbinding->iface->header_.uuid));
+                return false;
+            }
+            ret = consider_plug_lport_update__(vif_plug, &iface_external_ids,
+                                               pb, lbinding, vif_plug_ctx_in,
+                                               vif_plug_ctx_out);
+        } else {
+            ret = consider_plug_lport_create__(vif_plug, &iface_external_ids,
+                                               pb, vif_plug_ctx_in,
+                                               vif_plug_ctx_out);
+        }
+    }
+
+    return ret;
+}
+
+static bool
+vif_plug_iface_touched_this_txn(
+        const struct vif_plug_ctx_out *vif_plug_ctx_out,
+        const char *iface_id)
+{
+    return shash_find(vif_plug_ctx_out->changed_iface_ids, iface_id)
+           || shash_find(vif_plug_ctx_out->deleted_iface_ids, iface_id);
+}
+
+static bool
+vif_plug_handle_lport_vif(const struct sbrec_port_binding *pb,
+                          struct vif_plug_ctx_in *vif_plug_ctx_in,
+                          struct vif_plug_ctx_out *vif_plug_ctx_out,
+                          bool can_unplug)
+{
+    if (vif_plug_iface_touched_this_txn(vif_plug_ctx_out, pb->logical_port)) {
+        return true;
+    }
+    bool handled = true;
+    struct local_binding *lbinding = local_binding_find(
+        vif_plug_ctx_in->local_bindings, pb->logical_port);
+
+    if (lport_can_bind_on_this_chassis(vif_plug_ctx_in->chassis_rec, pb)) {
+        handled &= consider_plug_lport(pb, lbinding,
+                                       vif_plug_ctx_in, vif_plug_ctx_out);
+    } else if (can_unplug && lbinding && lbinding->iface) {
+        handled &= consider_unplug_iface(lbinding->iface, pb,
+                                         vif_plug_ctx_in, vif_plug_ctx_out);
+    }
+    return handled;
+}
+
+static bool
+vif_plug_handle_iface(const struct ovsrec_interface *iface_rec,
+                      struct vif_plug_ctx_in *vif_plug_ctx_in,
+                      struct vif_plug_ctx_out *vif_plug_ctx_out,
+                      bool can_unplug)
+{
+    bool handled = true;
+    const char *vif_plug_type = smap_get(&iface_rec->external_ids,
+                                         OVN_PLUGGED_EXT_ID);
+    const char *iface_id = smap_get(&iface_rec->external_ids, "iface-id");
+    if (!vif_plug_type || !iface_id
+        || vif_plug_iface_touched_this_txn(vif_plug_ctx_out, iface_id)) {
+        return true;
+    }
+    struct local_binding *lbinding = local_binding_find(
+        vif_plug_ctx_in->local_bindings, iface_id);
+    const struct sbrec_port_binding *pb = lport_lookup_by_name(
+        vif_plug_ctx_in->sbrec_port_binding_by_name, iface_id);
+    if (pb && lbinding
+        && lport_can_bind_on_this_chassis(vif_plug_ctx_in->chassis_rec, pb)) {
+        /* Something changed on a interface we have previously plugged,
+         * consider updating it */
+        handled &= consider_plug_lport(pb, lbinding,
+                                       vif_plug_ctx_in, vif_plug_ctx_out);
+    } else if (can_unplug
+               && (!pb
+                   || !lport_can_bind_on_this_chassis(
+                       vif_plug_ctx_in->chassis_rec, pb))) {
+        /* No lport for this interface or it is destined for different chassis,
+         * consuder unplugging it */
+        handled &= consider_unplug_iface(iface_rec, pb,
+                                         vif_plug_ctx_in, vif_plug_ctx_out);
+    }
+    return handled;
+}
+
+/* On initial startup or on IDL reconnect, several rounds of the main loop may
+ * run before data is actually loaded in the IDL.  This situation is currently
+ * not reflected in a call to ovsdb_idl_has_ever_connected().  Until we find
+ * the root of this issue we need this counter so that we do not erronously
+ * unplug ports because the data is just not loaded yet.
+ */
+#define VIF_PLUG_PRIME_IDL_COUNT_SEEED 10
+static int vif_plug_prime_idl_count = VIF_PLUG_PRIME_IDL_COUNT_SEEED;
+
+void
+vif_plug_reset_idl_prime_counter(void)
+{
+    vif_plug_prime_idl_count = VIF_PLUG_PRIME_IDL_COUNT_SEEED;
+}
+
+void
+vif_plug_run(struct vif_plug_ctx_in *vif_plug_ctx_in,
+             struct vif_plug_ctx_out *vif_plug_ctx_out)
+{
+    if (vif_plug_prime_idl_count && --vif_plug_prime_idl_count > 0) {
+        VLOG_DBG("vif_plug_run: vif_plug_prime_idl_count=%d, will not unplug "
+                 "ports in this iteration.", vif_plug_prime_idl_count);
+    }
+
+    if (!vif_plug_ctx_in->chassis_rec) {
+        return;
+    }
+    const struct ovsrec_interface *iface_rec;
+    OVSREC_INTERFACE_TABLE_FOR_EACH (iface_rec,
+                                     vif_plug_ctx_in->iface_table) {
+        vif_plug_handle_iface(iface_rec, vif_plug_ctx_in, vif_plug_ctx_out,
+                              !vif_plug_prime_idl_count);
+    }
+
+    struct sbrec_port_binding *target =
+        sbrec_port_binding_index_init_row(
+            vif_plug_ctx_in->sbrec_port_binding_by_requested_chassis);
+    sbrec_port_binding_index_set_requested_chassis(
+        target,
+        vif_plug_ctx_in->chassis_rec);
+    const struct sbrec_port_binding *pb;
+    SBREC_PORT_BINDING_FOR_EACH_EQUAL (
+            pb, target,
+            vif_plug_ctx_in->sbrec_port_binding_by_requested_chassis) {
+        enum en_lport_type lport_type = get_lport_type(pb);
+        if (lport_type == LP_VIF) {
+            vif_plug_handle_lport_vif(pb, vif_plug_ctx_in, vif_plug_ctx_out,
+                                      !vif_plug_prime_idl_count);
+        }
+    }
+    sbrec_port_binding_index_destroy_row(target);
+}
+
+static void
+vif_plug_finish_deleted__(struct shash *deleted_iface_ids, bool txn_success)
+{
+    struct shash_node *node, *next;
+    SHASH_FOR_EACH_SAFE (node, next, deleted_iface_ids) {
+        struct vif_plug_port_ctx *vif_plug_port_ctx = node->data;
+        if (txn_success) {
+            vif_plug_port_finish(vif_plug_port_ctx->vif_plug,
+                             &vif_plug_port_ctx->vif_plug_port_ctx_in,
+                             NULL);
+        }
+        shash_delete(deleted_iface_ids, node);
+        destroy_port_ctx(vif_plug_port_ctx);
+    }
+}
+
+void
+vif_plug_clear_deleted(struct shash *deleted_iface_ids) {
+    vif_plug_finish_deleted__(deleted_iface_ids, false);
+}
+
+void
+vif_plug_finish_deleted(struct shash *deleted_iface_ids) {
+    vif_plug_finish_deleted__(deleted_iface_ids, true);
+}
+
+static void
+vif_plug_finish_changed__(struct shash *changed_iface_ids, bool txn_success)
+{
+    struct shash_node *node, *next;
+    SHASH_FOR_EACH_SAFE (node, next, changed_iface_ids) {
+        struct vif_plug_port_ctx *vif_plug_port_ctx = node->data;
+        if (txn_success) {
+            vif_plug_port_finish(vif_plug_port_ctx->vif_plug,
+                                 &vif_plug_port_ctx->vif_plug_port_ctx_in,
+                                 &vif_plug_port_ctx->vif_plug_port_ctx_out);
+        }
+        vif_plug_port_ctx_destroy(vif_plug_port_ctx->vif_plug,
+                                  &vif_plug_port_ctx->vif_plug_port_ctx_in,
+                                  &vif_plug_port_ctx->vif_plug_port_ctx_out);
+        shash_delete(changed_iface_ids, node);
+        destroy_port_ctx(vif_plug_port_ctx);
+    }
+}
+
+void
+vif_plug_clear_changed(struct shash *deleted_iface_ids) {
+    vif_plug_finish_changed__(deleted_iface_ids, false);
+}
+
+void
+vif_plug_finish_changed(struct shash *deleted_iface_ids) {
+    vif_plug_finish_changed__(deleted_iface_ids, true);
+}
diff --git a/controller/vif-plug.h b/controller/vif-plug.h
new file mode 100644
index 000000000..76063591b
--- /dev/null
+++ b/controller/vif-plug.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2021 Canonical
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef VIF_PLUG_H
+#define VIF_PLUG_H 1
+
+/*
+ * VIF Plug, the controller internal interface to the VIF plug provider
+ * infrastructure.
+ */
+
+#include "openvswitch/shash.h"
+#include "smap.h"
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+struct vif_plug_ctx_in {
+    struct ovsdb_idl_txn *ovs_idl_txn;
+    struct ovsdb_idl_index *sbrec_port_binding_by_name;
+    struct ovsdb_idl_index *sbrec_port_binding_by_requested_chassis;
+    struct ovsdb_idl_index *ovsrec_port_by_interfaces;
+    const struct ovsrec_open_vswitch_table *ovs_table;
+    const struct ovsrec_bridge *br_int;
+    const struct ovsrec_interface_table *iface_table;
+    const struct sbrec_chassis *chassis_rec;
+    const struct shash *local_bindings;
+};
+
+struct vif_plug_ctx_out {
+    struct shash *deleted_iface_ids;
+    struct shash *changed_iface_ids;
+};
+
+struct vif_plug_class;
+struct vif_plug_port_ctx_out;
+struct vif_plug_port_ctx_in;
+
+const struct sset * vif_plug_get_maintained_iface_options(
+    const struct vif_plug_class *);
+
+bool vif_plug_port_prepare(const struct vif_plug_class *,
+                           const struct vif_plug_port_ctx_in *,
+                           struct vif_plug_port_ctx_out *);
+void vif_plug_port_finish(const struct vif_plug_class *,
+                          const struct vif_plug_port_ctx_in *,
+                          struct vif_plug_port_ctx_out *);
+void vif_plug_port_ctx_destroy(const struct vif_plug_class *,
+                           const struct vif_plug_port_ctx_in *,
+                           struct vif_plug_port_ctx_out *);
+
+struct ovsdb_idl;
+
+void vif_plug_register_ovs_idl(struct ovsdb_idl *ovs_idl);
+void vif_plug_run(struct vif_plug_ctx_in *, struct vif_plug_ctx_out *);
+void vif_plug_clear_changed(struct shash *deleted_iface_ids);
+void vif_plug_finish_changed(struct shash *changed_iface_ids);
+void vif_plug_clear_deleted(struct shash *deleted_iface_ids);
+void vif_plug_finish_deleted(struct shash *changed_iface_ids);
+void vif_plug_reset_idl_prime_counter(void);
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif /* vif-plug.h */
diff --git a/lib/automake.mk b/lib/automake.mk
index 9f9f447d5..829aedfc5 100644
--- a/lib/automake.mk
+++ b/lib/automake.mk
@@ -4,6 +4,11 @@ lib_libovn_la_LDFLAGS = \
         -Wl,--version-script=$(top_builddir)/lib/libovn.sym \
         $(OVS_LIBDIR)/libopenvswitch.la \
         $(AM_LDFLAGS)
+
+if HAVE_VIF_PLUG_PROVIDER
+lib_libovn_la_LDFLAGS += $(VIF_PLUG_PROVIDER_LDFLAGS)
+endif
+
 lib_libovn_la_SOURCES = \
 	lib/acl-log.c \
 	lib/acl-log.h \
@@ -33,7 +38,10 @@ lib_libovn_la_SOURCES = \
 	lib/inc-proc-eng.h \
 	lib/lb.c \
 	lib/lb.h \
-	lib/stopwatch-names.h
+	lib/stopwatch-names.h \
+	lib/vif-plug-provider.h \
+	lib/vif-plug-provider.c \
+	lib/vif-plug-providers/dummy/vif-plug-dummy.c
 nodist_lib_libovn_la_SOURCES = \
 	lib/ovn-dirs.c \
 	lib/ovn-nb-idl.c \
diff --git a/lib/vif-plug-provider.c b/lib/vif-plug-provider.c
new file mode 100644
index 000000000..798e90e26
--- /dev/null
+++ b/lib/vif-plug-provider.c
@@ -0,0 +1,204 @@
+/*
+ * Copyright (c) 2021 Canonical
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <config.h>
+#include "vif-plug-provider.h"
+
+#include <errno.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "openvswitch/vlog.h"
+#include "openvswitch/shash.h"
+#include "smap.h"
+#include "sset.h"
+#include "lib/inc-proc-eng.h"
+
+VLOG_DEFINE_THIS_MODULE(vif_plug_provider);
+
+#ifdef ENABLE_VIF_PLUG
+static const struct vif_plug_class *base_vif_plug_classes[] = {
+};
+#endif
+
+static struct shash vif_plug_classes = SHASH_INITIALIZER(&vif_plug_classes);
+
+/* Protects the 'vif_plug_classes' shash. */
+static struct ovs_mutex vif_plug_classes_mutex = OVS_MUTEX_INITIALIZER;
+
+/* Initialize the the VIF plug infrastructure by registering known classes */
+void
+vif_plug_provider_initialize(void)
+{
+    static struct ovsthread_once once = OVSTHREAD_ONCE_INITIALIZER;
+
+    if (ovsthread_once_start(&once)) {
+#ifdef ENABLE_VIF_PLUG
+        /* Register built-in VIF plug provider classes */
+        for (int i = 0; i < ARRAY_SIZE(base_vif_plug_classes); i++) {
+            vif_plug_provider_register(base_vif_plug_classes[i]);
+        }
+#endif
+#ifdef HAVE_VIF_PLUG_PROVIDER
+        /* Register external VIF plug provider classes.
+         *
+         * Note that we cannot use the ARRAY_SIZE macro here as
+         * vif_plug_provider_classes is defined in external code which is not
+         * available at compile time.  The convention is to use a
+         * NULL-terminated array instead. */
+        for (const struct vif_plug_class **pp = vif_plug_provider_classes;
+             pp && *pp;
+             pp++)
+        {
+            vif_plug_provider_register(*pp);
+        }
+#endif
+        ovsthread_once_done(&once);
+    }
+}
+
+static int
+vif_plug_provider_register__(const struct vif_plug_class *new_class)
+{
+    struct vif_plug_class *vif_plug_class;
+    int error;
+
+    if (shash_find(&vif_plug_classes, new_class->type)) {
+        VLOG_WARN("attempted to register duplicate VIF plug provider: %s",
+                  new_class->type);
+        return EEXIST;
+    }
+
+    error = new_class->init ? new_class->init() : 0;
+    if (error) {
+        VLOG_WARN("failed to initialize %s VIF plug provider class: %s",
+                  new_class->type, ovs_strerror(error));
+        return error;
+    }
+
+    vif_plug_class = xmalloc(sizeof *vif_plug_class);
+    memcpy(vif_plug_class, new_class, sizeof *vif_plug_class);
+
+    shash_add(&vif_plug_classes, new_class->type, vif_plug_class);
+
+    return 0;
+}
+
+/* Register the new VIF plug provider referred to in 'new_class' and perform
+ * any class level initialization as specified in its vif_plug_class. */
+int
+vif_plug_provider_register(const struct vif_plug_class *new_class)
+{
+    int error;
+
+    ovs_mutex_lock(&vif_plug_classes_mutex);
+    error = vif_plug_provider_register__(new_class);
+    ovs_mutex_unlock(&vif_plug_classes_mutex);
+
+    return error;
+}
+
+static int
+vif_plug_provider_unregister__(const char *type)
+{
+    int error;
+    struct shash_node *node;
+    struct vif_plug_class *vif_plug_class;
+
+    node = shash_find(&vif_plug_classes, type);
+    if (!node) {
+        return EINVAL;
+    }
+
+    vif_plug_class = node->data;
+    error = vif_plug_class->destroy ? vif_plug_class->destroy() : 0;
+    if (error) {
+        VLOG_WARN("failed to destroy %s VIF plug class: %s",
+                  vif_plug_class->type, ovs_strerror(error));
+        return error;
+    }
+
+    shash_delete(&vif_plug_classes, node);
+    free(vif_plug_class);
+
+    return 0;
+}
+
+/* Unregister the VIF plug provider identified by 'type' and perform any class
+ * level de-initialization as specified in its vif_plug_class. */
+int
+vif_plug_provider_unregister(const char *type)
+{
+    int error;
+
+    ovs_mutex_lock(&vif_plug_classes_mutex);
+    error = vif_plug_provider_unregister__(type);
+    ovs_mutex_unlock(&vif_plug_classes_mutex);
+
+    return error;
+}
+
+/* Check whether there are any VIF plug providers registered */
+bool
+vif_plug_provider_has_providers(void)
+{
+    return !shash_is_empty(&vif_plug_classes);
+}
+
+const struct vif_plug_class *
+vif_plug_provider_get(const char *type)
+{
+    struct vif_plug_class *vif_plug_class;
+
+    ovs_mutex_lock(&vif_plug_classes_mutex);
+    vif_plug_class = shash_find_data(&vif_plug_classes, type);
+    ovs_mutex_unlock(&vif_plug_classes_mutex);
+
+    return vif_plug_class;
+}
+
+/* Iterate over VIF plug providers and call their run function.
+ *
+ * Returns 'true' if any of the providers run functions return 'true', 'false'
+ * otherwise.
+ *
+ * A return value of 'true' means that data has changed. */
+bool
+vif_plug_provider_run_all(void)
+{
+    struct shash_node *node, *next;
+    bool changed = false;
+
+    SHASH_FOR_EACH_SAFE (node, next, &vif_plug_classes) {
+        struct vif_plug_class *vif_plug_class = node->data;
+        if (vif_plug_class->run && vif_plug_class->run(vif_plug_class)) {
+            changed = true;
+        }
+    }
+    return changed;
+}
+
+/* De-initialize and unregister the VIF plug provider classes. */
+void
+vif_plug_provider_destroy_all(void)
+{
+    struct shash_node *node, *next;
+
+    SHASH_FOR_EACH_SAFE (node, next, &vif_plug_classes) {
+        struct vif_plug_class *vif_plug_class = node->data;
+        vif_plug_provider_unregister(vif_plug_class->type);
+    }
+}
diff --git a/lib/vif-plug-provider.h b/lib/vif-plug-provider.h
new file mode 100644
index 000000000..c0c74b073
--- /dev/null
+++ b/lib/vif-plug-provider.h
@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) 2021 Canonical
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef VIF_PLUG_PROVIDER_H
+#define VIF_PLUG_PROVIDER_H 1
+
+/* Interface for VIF plug providers.
+ *
+ * A VIF plug provider implementation performs lookup and/or initialization of
+ * ports, typically representor ports, using generic non-blocking hardware
+ * interfaces.  This allows the ovn-controller to, upon the CMS's request,
+ * create ports and interfaces in the chassis's Open vSwitch instances (also
+ * known as vif plugging).
+ *
+ * This module contains the infrastructure for registering VIF plug providers
+ * which may be hosted inside or outside the core OVN repository.
+ */
+
+#include <stdbool.h>
+
+#include "smap.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct vif_plug_class;
+struct ovsdb_idl_txn;
+struct ovsrec_bridge;
+
+enum vif_plug_op_type {
+    PLUG_OP_CREATE = 1, /* Port is created or updated */
+    PLUG_OP_REMOVE,     /* Port is removed from this chassis */
+};
+
+struct vif_plug_port_ctx_in {
+    /* Operation being performed */
+    enum vif_plug_op_type op_type;
+
+    /* These are provided so that the plug implementation may make decisions
+     * based on environmental factors such as settings in the open-vswitch
+     * table and datapath type settings on the integration bridge. */
+    const struct ovsrec_open_vswitch_table *ovs_table;
+    const struct ovsrec_bridge *br_int;
+
+    /* Name of logical port, can be useful for plugging library to track any
+     * per port resource initialization. */
+    const char *lport_name;
+
+    /* Logical port options, while OVN will forward the contents verbatim from
+     * the Southbound database, the convention is for the plugging library to
+     * only make decisions based on the vif-plug-* options. */
+    struct smap lport_options;
+
+    /* When OVN knows about an existing interface record associated with this
+     * lport, these will be filled in with information about it. */
+    const char *iface_name;
+    const char *iface_type;
+    struct smap iface_options;
+};
+
+struct vif_plug_port_ctx_out {
+    /* The name to use for port and interface record. */
+    char *name;
+
+    /* Type of interface to create. */
+    char *type;
+
+    /* Options to set on the interface record. */
+    struct smap iface_options;
+};
+
+struct vif_plug_port_ctx {
+    const struct vif_plug_class *vif_plug;
+    struct vif_plug_port_ctx_in vif_plug_port_ctx_in;
+    struct vif_plug_port_ctx_out vif_plug_port_ctx_out;
+};
+
+struct vif_plug_class {
+    /* Type of VIF plug provider in this class. */
+    const char *type;
+
+    /* Called when the VIF plug provider is registered, typically at program
+     * startup.
+     *
+     * This function may be set to null if a VIF plug class needs no
+     * initialization at registration time. */
+    int (*init)(void);
+
+    /* Called when the VIF plug provider is unregistered, typically at program
+     * exit.
+     *
+     * This function may be set to null if a plug class needs no
+     * de-initialization at unregister time.*/
+    int (*destroy)(void);
+
+    /* Performs periodic work needed by VIF plug provider, if any is necessary.
+     * Returns 'true; if anything (i.e. lookup tables) changed, 'false'
+     * otherwise. */
+    bool (*run)(struct vif_plug_class *);
+
+    /* Retrieve Interface options this VIF plug provider will maintain.  This
+     * sset is used to know which items to remove when maintaining the database
+     * record. */
+    const struct sset * (*vif_plug_get_maintained_iface_options)(void);
+
+    /* Pass vif_plug_port_ctx_in to VIF plug provider implementation to prepare
+     * for port creation/update.
+     *
+     * The VIF plug provider implemantation can perform lookup or any per port
+     * initialization and should fill vif_plug_port_ctx_out with data required
+     * for port/interface creation.  The VIF plug implementation should return
+     * 'true' if it wants the caller to create/update a port/interface, 'false'
+     * otherwise.
+     *
+     * Data in the vif_plug_port_ctx_out struct is owned by the VIF plug
+     * provider, and a call must be made to the vif_plug_port_ctx_destroy
+     * callback to free up any allocations when done with port creation/update.
+     */
+    bool (*vif_plug_port_prepare)(const struct vif_plug_port_ctx_in *,
+                                  struct vif_plug_port_ctx_out *);
+
+    /* Notify VIF plug provider that port update is committed to OVSDB. */
+    void (*vif_plug_port_finish)(const struct vif_plug_port_ctx_in *,
+                                 struct vif_plug_port_ctx_out *);
+
+    /* Free any allocations made by the vif_plug_port_prepare callback. */
+    void (*vif_plug_port_ctx_destroy)(const struct vif_plug_port_ctx_in *,
+                                      struct vif_plug_port_ctx_out *);
+};
+
+extern const struct vif_plug_class vif_plug_dummy_class;
+#ifdef HAVE_VIF_PLUG_PROVIDER
+extern const struct vif_plug_class *vif_plug_provider_classes[];
+#endif
+
+void vif_plug_provider_initialize(void);
+int vif_plug_provider_register(const struct vif_plug_class *);
+int vif_plug_provider_unregister(const char *type);
+bool vif_plug_provider_has_providers(void);
+const struct vif_plug_class * vif_plug_provider_get(const char *);
+bool vif_plug_provider_run_all(void);
+void vif_plug_provider_destroy_all(void);
+void vif_plug_dummy_enable(void);
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif /* vif-plug-provider.h */
diff --git a/lib/vif-plug-providers/dummy/vif-plug-dummy.c b/lib/vif-plug-providers/dummy/vif-plug-dummy.c
new file mode 100644
index 000000000..bc8953e98
--- /dev/null
+++ b/lib/vif-plug-providers/dummy/vif-plug-dummy.c
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2021 Canonical
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <config.h>
+#include "lib/vif-plug-provider.h"
+
+#include <stdint.h>
+
+#include "openvswitch/vlog.h"
+#include "smap.h"
+#include "sset.h"
+
+#ifndef IFNAMSIZ
+#define IFNAMSIZ 16
+#endif
+
+VLOG_DEFINE_THIS_MODULE(vif_plug_dummy);
+
+static struct sset vif_plug_dummy_maintained_iface_options;
+
+static int
+vif_plug_dummy_init(void)
+{
+    sset_init(&vif_plug_dummy_maintained_iface_options);
+    sset_add(&vif_plug_dummy_maintained_iface_options,
+             "vif-plug-dummy-option");
+
+    return 0;
+}
+
+static int
+vif_plug_dummy_destroy(void)
+{
+    sset_destroy(&vif_plug_dummy_maintained_iface_options);
+
+    return 0;
+}
+
+static const struct sset*
+vif_plug_dummy_get_maintained_iface_options(void)
+{
+    return &vif_plug_dummy_maintained_iface_options;
+}
+
+static bool
+vif_plug_dummy_run(struct vif_plug_class *plug)
+{
+    VLOG_DBG("vif_plug_dummy_run(%p)", plug);
+
+    return false;
+}
+
+static bool
+vif_plug_dummy_port_prepare(const struct vif_plug_port_ctx_in *ctx_in,
+                            struct vif_plug_port_ctx_out *ctx_out)
+{
+    VLOG_DBG("vif_plug_dummy_port_prepare: %s", ctx_in->lport_name);
+
+    if (ctx_in->op_type == PLUG_OP_CREATE) {
+        size_t lport_name_len = strlen(ctx_in->lport_name);
+        ctx_out->name = xzalloc(IFNAMSIZ);
+        memcpy(ctx_out->name, ctx_in->lport_name,
+               (lport_name_len < IFNAMSIZ) ? lport_name_len : IFNAMSIZ - 1);
+        ctx_out->type = xstrdup("internal");
+        smap_init(&ctx_out->iface_options);
+        smap_add(&ctx_out->iface_options, "vif-plug-dummy-option", "value");
+    }
+
+    return true;
+}
+
+static void
+vif_plug_dummy_port_finish(const struct vif_plug_port_ctx_in *ctx_in,
+                           struct vif_plug_port_ctx_out *ctx_out OVS_UNUSED)
+{
+    VLOG_DBG("vif_plug_dummy_port_finish: %s", ctx_in->lport_name);
+}
+
+static void
+vif_plug_dummy_port_ctx_destroy(const struct vif_plug_port_ctx_in *ctx_in,
+                                struct vif_plug_port_ctx_out *ctx_out)
+{
+    VLOG_DBG("vif_plug_dummy_port_ctx_destroy: %s", ctx_in->lport_name);
+    ovs_assert(ctx_in->op_type == PLUG_OP_CREATE);
+    free(ctx_out->name);
+    free(ctx_out->type);
+    smap_destroy(&ctx_out->iface_options);
+}
+
+const struct vif_plug_class vif_plug_dummy_class = {
+    .type = "dummy",
+    .init = vif_plug_dummy_init,
+    .destroy = vif_plug_dummy_destroy,
+    .vif_plug_get_maintained_iface_options =
+        vif_plug_dummy_get_maintained_iface_options,
+    .run = vif_plug_dummy_run,
+    .vif_plug_port_prepare = vif_plug_dummy_port_prepare,
+    .vif_plug_port_finish = vif_plug_dummy_port_finish,
+    .vif_plug_port_ctx_destroy = vif_plug_dummy_port_ctx_destroy,
+};
+
+void
+vif_plug_dummy_enable(void)
+{
+    vif_plug_provider_register(&vif_plug_dummy_class);
+}
+
diff --git a/ovn-architecture.7.xml b/ovn-architecture.7.xml
index a71798f68..ef8d669a2 100644
--- a/ovn-architecture.7.xml
+++ b/ovn-architecture.7.xml
@@ -67,8 +67,9 @@
     <li>
       One or more (usually many) <dfn>hypervisors</dfn>.  Hypervisors must run
       Open vSwitch and implement the interface described in
-      <code>Documentation/topics/integration.rst</code> in the OVN source tree.
-      Any hypervisor platform supported by Open vSwitch is acceptable.
+      <code>Documentation/topics/integration.rst</code> in the Open vSwitch
+      source tree.  Any hypervisor platform supported by Open vSwitch is
+      acceptable.
     </li>
 
     <li>
@@ -318,11 +319,19 @@
 
     <li>
       On a hypervisor, any VIFs that are to be attached to logical networks.
-      The hypervisor itself, or the integration between Open vSwitch and the
-      hypervisor (described in
-      <code>Documentation/topics/integration.rst</code>) takes care of this.
-      (This is not part of OVN or new to OVN; this is pre-existing integration
-      work that has already been done on hypervisors that support OVS.)
+      For instances connected through software emulated ports such as TUN/TAP
+      or VETH pairs, the hypervisor itself will normally create ports and plug
+      them into the integration bridge.  For instances connected through
+      representor ports, typically used with hardware offload, the
+      <code>ovn-controller</code> may on CMS direction consult a VIF plug
+      provider for representor port lookup and plug them into the integration
+      bridge (please refer to
+      <code>Documentation/topics/vif-plug-providers/vif-plug-providers.rst
+      </code> for more information).  In both cases the conventions described
+      in <code>Documentation/topics/integration.rst</code> in the Open vSwitch
+      source tree is followed to ensure mapping between OVN logical port and
+      VIF.  (This is pre-existing integration work that has already been done
+      on hypervisors that support OVS.)
     </li>
 
     <li>
@@ -921,12 +930,12 @@
       Eventually, a user powers on the VM that owns the VIF.  On the hypervisor
       where the VM is powered on, the integration between the hypervisor and
       Open vSwitch (described in
-      <code>Documentation/topics/integration.rst</code>) adds the VIF to the OVN
-      integration bridge and stores <var>vif-id</var> in
-      <code>external_ids</code>:<code>iface-id</code> to indicate that the
-      interface is an instantiation of the new VIF.  (None of this code is new
-      in OVN; this is pre-existing integration work that has already been done
-      on hypervisors that support OVS.)
+      <code>Documentation/topics/integration.rst</code> in the Open vSwitch
+      source tree) adds the VIF to the OVN integration bridge and stores
+      <var>vif-id</var> in <code>external_ids</code>:<code>iface-id</code> to
+      indicate that the interface is an instantiation of the new VIF.  (None of
+      this code is new in OVN; this is pre-existing integration work that has
+      already been done on hypervisors that support OVS.)
     </li>
 
     <li>
diff --git a/tests/automake.mk b/tests/automake.mk
index c4a7c0a5b..685d78c5b 100644
--- a/tests/automake.mk
+++ b/tests/automake.mk
@@ -38,7 +38,8 @@ TESTSUITE_AT = \
 	tests/ovn-ipam.at \
 	tests/ovn-features.at \
 	tests/ovn-lflow-cache.at \
-	tests/ovn-ipsec.at
+	tests/ovn-ipsec.at \
+	tests/ovn-vif-plug.at
 
 SYSTEM_KMOD_TESTSUITE_AT = \
 	tests/system-common-macros.at \
@@ -243,13 +244,23 @@ tests_ovstest_SOURCES = \
 	tests/test-ovn.c \
 	controller/test-lflow-cache.c \
 	controller/test-ofctrl-seqno.c \
+	controller/test-vif-plug.c \
 	lib/test-ovn-features.c \
 	northd/test-ipam.c
 
 tests_ovstest_LDADD = $(OVS_LIBDIR)/daemon.lo \
     $(OVS_LIBDIR)/libopenvswitch.la lib/libovn.la \
+	controller/binding.$(OBJEXT) \
+	controller/encaps.$(OBJEXT) \
+	controller/ha-chassis.$(OBJEXT) \
+	controller/if-status.$(OBJEXT) \
 	controller/lflow-cache.$(OBJEXT) \
+	controller/local_data.$(OBJEXT) \
+	controller/lport.$(OBJEXT) \
 	controller/ofctrl-seqno.$(OBJEXT) \
+	controller/ovsport.$(OBJEXT) \
+	controller/patch.$(OBJEXT) \
+	controller/vif-plug.$(OBJEXT) \
 	northd/ipam.$(OBJEXT)
 
 # Python tests.
diff --git a/tests/ovn-vif-plug.at b/tests/ovn-vif-plug.at
new file mode 100644
index 000000000..86b0b4b84
--- /dev/null
+++ b/tests/ovn-vif-plug.at
@@ -0,0 +1,8 @@
+#
+# Unit tests for the lib/vif-plug-provider.c and controller/vif-plug.c modules.
+#
+AT_BANNER([OVN unit tests - vif-plug])
+
+AT_SETUP([unit test -- plugging infrastructure tests])
+AT_CHECK([ovstest test-plug run], [0], [])
+AT_CLEANUP
-- 
2.32.0



More information about the dev mailing list