#include "patch.h"
#include "hash.h"
+#include "lib/hmap.h"
#include "lib/vswitch-idl.h"
#include "openvswitch/vlog.h"
#include "ovn-controller.h"
VLOG_DEFINE_THIS_MODULE(patch);
static char *
-patch_port_name(const struct ovsrec_bridge *b1, const struct ovsrec_bridge *b2)
+patch_port_name(const char *src, const char *dst)
{
- return xasprintf("patch-%s-to-%s", b1->name, b2->name);
+ return xasprintf("patch-%s-to-%s", src, dst);
}
-/*
- * Return true if the port is a patch port from b1 to b2
- */
+/* Return true if 'port' is a patch port with the specified 'peer'. */
static bool
-match_patch_port(const struct ovsrec_port *port,
- const struct ovsrec_bridge *b1,
- const struct ovsrec_bridge *b2)
+match_patch_port(const struct ovsrec_port *port, const char *peer)
{
- struct ovsrec_interface *iface;
- size_t i;
- char *peer_port_name;
- bool res = false;
-
- peer_port_name = patch_port_name(b2, b1);
-
- for (i = 0; i < port->n_interfaces; i++) {
- iface = port->interfaces[i];
+ for (size_t i = 0; i < port->n_interfaces; i++) {
+ struct ovsrec_interface *iface = port->interfaces[i];
if (strcmp(iface->type, "patch")) {
continue;
}
- const char *peer;
- peer = smap_get(&iface->options, "peer");
- if (peer && !strcmp(peer, peer_port_name)) {
- res = true;
- break;
+ const char *iface_peer = smap_get(&iface->options, "peer");
+ if (peer && !strcmp(iface_peer, peer)) {
+ return true;
}
}
-
- free(peer_port_name);
-
- return res;
+ return false;
}
+/* Creates a patch port in bridge 'src' named 'src_name', whose peer is
+ * 'dst_name' in bridge 'dst'. Initializes the patch port's external-ids:'key'
+ * to 'key'.
+ *
+ * If such a patch port already exists, removes it from 'existing_ports'. */
static void
create_patch_port(struct controller_ctx *ctx,
- const char *network,
- const struct ovsrec_bridge *b1,
- const struct ovsrec_bridge *b2)
+ const char *key, const char *value,
+ const struct ovsrec_bridge *src, const char *src_name,
+ const struct ovsrec_bridge *dst, const char *dst_name,
+ struct shash *existing_ports)
{
- char *port_name = patch_port_name(b1, b2);
- char *peer_port_name = patch_port_name(b2, b1);
+ for (size_t i = 0; i < src->n_ports; i++) {
+ if (match_patch_port(src->ports[i], dst_name)) {
+ /* Patch port already exists on 'src'. */
+ shash_find_and_delete(existing_ports, src->ports[i]->name);
+ return;
+ }
+ }
ovsdb_idl_txn_add_comment(ctx->ovs_idl_txn,
"ovn-controller: creating patch port '%s' from '%s' to '%s'",
- port_name, b1->name, b2->name);
+ src_name, src->name, dst->name);
struct ovsrec_interface *iface;
iface = ovsrec_interface_insert(ctx->ovs_idl_txn);
- ovsrec_interface_set_name(iface, port_name);
+ ovsrec_interface_set_name(iface, src_name);
ovsrec_interface_set_type(iface, "patch");
- const struct smap options = SMAP_CONST1(&options, "peer", peer_port_name);
+ const struct smap options = SMAP_CONST1(&options, "peer", dst_name);
ovsrec_interface_set_options(iface, &options);
struct ovsrec_port *port;
port = ovsrec_port_insert(ctx->ovs_idl_txn);
- ovsrec_port_set_name(port, port_name);
+ ovsrec_port_set_name(port, src_name);
ovsrec_port_set_interfaces(port, &iface, 1);
- const struct smap ids = SMAP_CONST1(&ids, "ovn-patch-port", network);
+ const struct smap ids = SMAP_CONST1(&ids, key, value);
ovsrec_port_set_external_ids(port, &ids);
struct ovsrec_port **ports;
- ports = xmalloc(sizeof *ports * (b1->n_ports + 1));
- memcpy(ports, b1->ports, sizeof *ports * b1->n_ports);
- ports[b1->n_ports] = port;
- ovsrec_bridge_verify_ports(b1);
- ovsrec_bridge_set_ports(b1, ports, b1->n_ports + 1);
+ ports = xmalloc(sizeof *ports * (src->n_ports + 1));
+ memcpy(ports, src->ports, sizeof *ports * src->n_ports);
+ ports[src->n_ports] = port;
+ ovsrec_bridge_verify_ports(src);
+ ovsrec_bridge_set_ports(src, ports, src->n_ports + 1);
free(ports);
- free(port_name);
- free(peer_port_name);
-}
-
-static void
-create_patch_ports(struct controller_ctx *ctx,
- const char *network,
- struct shash *existing_ports,
- const struct ovsrec_bridge *b1,
- const struct ovsrec_bridge *b2)
-{
- size_t i;
-
- for (i = 0; i < b1->n_ports; i++) {
- if (match_patch_port(b1->ports[i], b1, b2)) {
- /* Patch port already exists on b1 */
- shash_find_and_delete(existing_ports, b1->ports[i]->name);
- break;
- }
- }
- if (i == b1->n_ports) {
- create_patch_port(ctx, network, b1, b2);
- }
}
static void
}
}
+/* Obtains external-ids:ovn-bridge-mappings from OVSDB and adds patch ports for
+ * the local bridge mappings. Removes any patch ports for bridge mappings that
+ * already existed from 'existing_ports'. */
static void
-parse_bridge_mappings(struct controller_ctx *ctx,
- const struct ovsrec_bridge *br_int,
- struct shash *existing_ports)
+add_bridge_mappings(struct controller_ctx *ctx,
+ const struct ovsrec_bridge *br_int,
+ struct shash *existing_ports,
+ struct hmap *local_datapaths)
{
/* Get ovn-bridge-mappings. */
const char *mappings_cfg = "";
}
}
- /* Create patch ports. */
+ /* Parse bridge mappings. */
+ struct shash bridge_mappings = SHASH_INITIALIZER(&bridge_mappings);
char *cur, *next, *start;
next = start = xstrdup(mappings_cfg);
while ((cur = strsep(&next, ",")) && *cur) {
continue;
}
- create_patch_ports(ctx, network, existing_ports, br_int, ovs_bridge);
- create_patch_ports(ctx, network, existing_ports, ovs_bridge, br_int);
+ shash_add(&bridge_mappings, network, ovs_bridge);
}
free(start);
+
+ const struct sbrec_port_binding *binding;
+ SBREC_PORT_BINDING_FOR_EACH (binding, ctx->ovnsb_idl) {
+ if (strcmp(binding->type, "localnet")) {
+ /* Not a binding for a localnet port. */
+ continue;
+ }
+
+ struct local_datapath *ld;
+ ld = CONTAINER_OF(hmap_first_with_hash(local_datapaths,
+ binding->datapath->tunnel_key),
+ struct local_datapath, hmap_node);
+ if (!ld) {
+ /* This localnet port is on a datapath with no
+ * logical ports bound to this chassis, so there's no need
+ * to create patch ports for it. */
+ continue;
+ }
+ if (ld->localnet_port) {
+ static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 1);
+ VLOG_WARN_RL(&rl, "localnet port '%s' already set for datapath "
+ "'%"PRId64"', skipping the new port '%s'.",
+ ld->localnet_port->logical_port,
+ binding->datapath->tunnel_key,
+ binding->logical_port);
+ continue;
+ }
+ ld->localnet_port = binding;
+
+ const char *network = smap_get(&binding->options, "network_name");
+ if (!network) {
+ static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 1);
+ VLOG_ERR_RL(&rl, "localnet port '%s' has no network name.",
+ binding->logical_port);
+ continue;
+ }
+ struct ovsrec_bridge *br_ln = shash_find_data(&bridge_mappings, network);
+ if (!br_ln) {
+ static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 1);
+ VLOG_ERR_RL(&rl, "bridge not found for localnet port '%s' "
+ "with network name '%s'", binding->logical_port, network);
+ continue;
+ }
+
+ char *name1 = patch_port_name(br_int->name, binding->logical_port);
+ char *name2 = patch_port_name(binding->logical_port, br_int->name);
+ create_patch_port(ctx, "ovn-localnet-port", binding->logical_port,
+ br_int, name1, br_ln, name2, existing_ports);
+ create_patch_port(ctx, "ovn-localnet-port", binding->logical_port,
+ br_ln, name2, br_int, name1, existing_ports);
+ free(name1);
+ free(name2);
+ }
+
+ shash_destroy(&bridge_mappings);
+}
+
+/* Add one OVS patch port for each OVN logical patch port.
+ *
+ * This is suboptimal for several reasons. First, it creates an OVS port for
+ * every OVN logical patch port, not just for the ones that are actually useful
+ * on this hypervisor. Second, it's wasteful to create an OVS patch port per
+ * OVN logical patch port, when really there's no benefit to them beyond a way
+ * to identify how a packet ingressed into a logical datapath.
+ *
+ * There are two obvious ways to improve the situation here, by modifying
+ * OVS:
+ *
+ * 1. Add a way to configure in OVS which fields are preserved on a hop
+ * across an OVS patch port. If MFF_LOG_DATAPATH and MFF_LOG_INPORT
+ * were preserved, then only a single pair of OVS patch ports would be
+ * required regardless of the number of OVN logical patch ports.
+ *
+ * 2. Add a new OpenFlow extension action modeled on "resubmit" that also
+ * saves and restores the packet data and metadata (the inability to do
+ * this is the only reason that "resubmit" can't be used already). Or
+ * add OpenFlow extension actions to otherwise save and restore packet
+ * data and metadata.
+ */
+static void
+add_logical_patch_ports(struct controller_ctx *ctx,
+ const struct ovsrec_bridge *br_int,
+ struct shash *existing_ports)
+{
+ const struct sbrec_port_binding *binding;
+ SBREC_PORT_BINDING_FOR_EACH (binding, ctx->ovnsb_idl) {
+ if (!strcmp(binding->type, "patch")) {
+ const char *local = binding->logical_port;
+ const char *peer = smap_get(&binding->options, "peer");
+ if (!peer) {
+ continue;
+ }
+
+ char *src_name = patch_port_name(local, peer);
+ char *dst_name = patch_port_name(peer, local);
+ create_patch_port(ctx, "ovn-logical-patch-port", local,
+ br_int, src_name, br_int, dst_name,
+ existing_ports);
+ free(dst_name);
+ free(src_name);
+ }
+ }
}
void
-patch_run(struct controller_ctx *ctx, const struct ovsrec_bridge *br_int)
+patch_run(struct controller_ctx *ctx, const struct ovsrec_bridge *br_int,
+ struct hmap *local_datapaths)
{
if (!ctx->ovs_idl_txn) {
return;
struct shash existing_ports = SHASH_INITIALIZER(&existing_ports);
const struct ovsrec_port *port;
OVSREC_PORT_FOR_EACH (port, ctx->ovs_idl) {
- if (smap_get(&port->external_ids, "ovn-patch-port")) {
+ if (smap_get(&port->external_ids, "ovn-localnet-port") ||
+ smap_get(&port->external_ids, "ovn-logical-patch-port")) {
shash_add(&existing_ports, port->name, port);
}
}
/* Create in the database any patch ports that should exist. Remove from
* 'existing_ports' any patch ports that do exist in the database and
* should be there. */
- parse_bridge_mappings(ctx, br_int, &existing_ports);
+ add_bridge_mappings(ctx, br_int, &existing_ports, local_datapaths);
+ add_logical_patch_ports(ctx, br_int, &existing_ports);
/* Now 'existing_ports' only still contains patch ports that exist in the
* database but shouldn't. Delete them from the database. */
projects / cascardo / ovs.git / blobdiff