nanny: add device references to policy match (bsc#941611)

Generate a match to all devices a config refers in it's link node
(master device, ovs-bridge, ...) to ensure, that there is already
the complete configuration tree applied to nanny in order to not
start managing a port/slave and fail on unresolvable requirements.

Author: mtomaschewski

client/ifup.c

@@ -73,6 +73,93 @@ __ni_ifup_generate_match_dev(xml_node_t *node, ni_ifworker_t *w)
 	return xml_node_new_element(NI_NANNY_IFPOLICY_MATCH_DEV, node, w->name);
 }
 
+static ni_bool_t
+__ni_ifup_generate_match_link_port_ref(xml_node_t *match, xml_node_t *port)
+{
+	const char *type = xml_node_get_attr(port, NI_CLIENT_IFCONFIG_PORT_TYPE);
+	ni_iftype_t ptype = ni_linktype_name_to_type(type);
+	xml_node_t *ref, *ovsbr;
+
+	switch (ptype) {
+	case NI_IFTYPE_OVS_BRIDGE:
+		ovsbr = xml_node_get_child(port, NI_CLIENT_IFCONFIG_BRIDGE);
+		if (!ovsbr || ni_string_empty(ovsbr->cdata))
+			return FALSE;
+
+		if (!(ref = xml_node_new(NI_NANNY_IFPOLICY_MATCH_REF, match)))
+			return FALSE;
+
+		if (!xml_node_new_element(NI_NANNY_IFPOLICY_MATCH_DEV, ref, ovsbr->cdata)) {
+			xml_node_free(ref);
+			return FALSE;
+		}
+		break;
+
+	default:
+		/* other port types need master only */
+		break;
+	}
+	return TRUE;
+}
+
+static ni_bool_t
+__ni_ifup_generate_match_link_ref(xml_node_t *match, xml_node_t *link)
+{
+	xml_node_t *ref, *master, *port;
+
+	if (!(master = xml_node_get_child(link, NI_CLIENT_IFCONFIG_MASTER)))
+		return TRUE; /* <link> does not contain a <master> node */
+
+	if (ni_string_empty(master->cdata))
+		return FALSE;
+
+	if (!(ref = xml_node_new(NI_NANNY_IFPOLICY_MATCH_REF, match)))
+		return FALSE;
+
+	if (!xml_node_new_element(NI_NANNY_IFPOLICY_MATCH_DEV, ref, master->cdata)) {
+		xml_node_free(ref);
+		return FALSE;
+	}
+
+	if ((port = xml_node_get_child(link, NI_CLIENT_IFCONFIG_LINK_PORT)))
+		return __ni_ifup_generate_match_link_port_ref(match, port);
+
+	return TRUE; /* master ref at least */
+}
+
+static ni_bool_t
+__ni_ifup_generate_match_master_ref(xml_node_t *match, ni_ifworker_t *master)
+{
+	xml_node_t *ref;
+
+	if (!master || ni_string_empty(master->name))
+		return FALSE;
+
+	if (!(ref = xml_node_new(NI_NANNY_IFPOLICY_MATCH_REF, match)))
+		return FALSE;
+
+	if (!xml_node_new_element(NI_NANNY_IFPOLICY_MATCH_DEV, ref, master->name)) {
+		xml_node_free(ref);
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+static ni_bool_t
+__ni_ifup_generate_match_refs(xml_node_t *match, ni_ifworker_t *w)
+{
+	xml_node_t *link;
+
+	if (w->masterdev)
+		return __ni_ifup_generate_match_master_ref(match, w->masterdev);
+
+	if ((link = xml_node_get_child(w->config.node, NI_CLIENT_IFCONFIG_LINK)))
+		return __ni_ifup_generate_match_link_ref(match, link);
+
+	return TRUE; /* no refs is not an error */
+}
+
 static xml_node_t *
 __ni_ifup_generate_match(const char *name, ni_ifworker_t *w)
 {
@@ -81,18 +168,34 @@ __ni_ifup_generate_match(const char *name, ni_ifworker_t *w)
 	if (!(match = xml_node_new(name, NULL)))
 		goto error;
 
+	ni_debug_wicked_xml(w->config.node, NI_LOG_DEBUG,
+		"generate policy match for %s (type %s)", w->name,
+		ni_linktype_type_to_name(w->iftype));
+
 	if (!__ni_ifup_generate_match_dev(match, w))
 		goto error;
 
-	/* Ignore child dependency for following device types */
+	/* Ignore child dependency for following device types:
+	 *  - ovs-system: otherwise ovs-system would require all ports
+	 *    in all ovs-bridges and want to get at least one up ...
+	 *    this is not what we want :-)
+	 */
 	switch (w->iftype) {
 	case NI_IFTYPE_OVS_SYSTEM:
 		goto done;
 		break;
 	default:
+		if (ni_string_eq(w->name, ni_linktype_type_to_name(NI_IFTYPE_OVS_SYSTEM)))
+			goto done;
 		break;
 	}
 
+	if (!__ni_ifup_generate_match_refs(match, w)) {
+		ni_debug_application("%s: unable to generate policy match device references",
+				w->name);
+		goto error;
+	}
+
 	if (w->children.count) {
 		xml_node_t *or;
 		unsigned int i;

src/client/ifconfig.h

@@ -31,6 +31,9 @@
 #define NI_CLIENT_IFCONFIG_MODE		"mode"
 #define NI_CLIENT_IFCONFIG_LINK		"link"
 #define NI_CLIENT_IFCONFIG_MASTER		"master"
+#define NI_CLIENT_IFCONFIG_LINK_PORT		"port"
+#define NI_CLIENT_IFCONFIG_PORT_TYPE			"type"
+#define NI_CLIENT_IFCONFIG_BRIDGE	"bridge"
 #define NI_CLIENT_IFCONFIG_IPV4		"ipv4"
 #define NI_CLIENT_IFCONFIG_IPV6		"ipv6"
 #define NI_CLIENT_IFCONFIG_IP_ENABLED		"enabled"
@@ -45,6 +48,7 @@
 #define NI_NANNY_IFPOLICY_MATCH_COND_CHILD	"child"
 #define NI_NANNY_IFPOLICY_MATCH_ALWAYS_TRUE	"any"
 #define NI_NANNY_IFPOLICY_MATCH_DEV		"device"
+#define NI_NANNY_IFPOLICY_MATCH_REF		"reference"
 #define NI_NANNY_IFPOLICY_MATCH_MIN_STATE	"minimum-device-state"
 #define NI_NANNY_IFPOLICY_MATCH_LINK_TYPE	"link-type"
 #define NI_NANNY_IFPOLICY_MERGE		"merge"

src/fsm-policy.c

@@ -28,7 +28,10 @@ struct ni_ifcondition {
 	ni_ifcondition_free_fn_t *	free;
 
 	union {
-		ni_ifworker_type_t	type;
+		struct {
+			ni_ifworker_type_t	type;
+			ni_ifcondition_t *	ref;
+		};
 		struct {
 			ni_ifcondition_t *left;
 			ni_ifcondition_t *right;
@@ -1037,6 +1040,11 @@ ni_ifcondition_free_args_string(ni_ifcondition_t *cond)
 {
 	ni_string_free(&cond->args.string);
 }
+static void
+ni_ifcondition_free_args_reference(ni_ifcondition_t *cond)
+{
+	ni_ifcondition_free(cond->args.ref);
+}
 
 static ni_ifcondition_t *
 ni_ifcondition_new_cdata(ni_ifcondition_check_fn_t *check_fn, const xml_node_t *node)
@@ -1608,6 +1616,120 @@ ni_ifcondition_modem(xml_node_t *node)
 	return result;
 }
 
+static ni_bool_t
+__ni_fsm_policy_match_reference(const ni_ifcondition_t *cond, const ni_fsm_t *fsm, ni_ifworker_t *w)
+{
+	unsigned int i;
+
+	if (cond && cond->args.ref && fsm) {
+		for (i = 0; i < fsm->workers.count; ++i) {
+			w = fsm->workers.data[i];
+			if (!w || w->type !=  cond->args.type)
+				continue;
+
+			if (ni_ifcondition_check(cond->args.ref, fsm, w))
+				return TRUE;
+		}
+	}
+	return FALSE;
+}
+
+static ni_ifcondition_t *
+ni_ifcondition_new_reference(ni_ifcondition_t *ref, ni_ifworker_type_t type)
+{
+	ni_ifcondition_t *cond;
+
+	if (ref) {
+		cond = ni_ifcondition_new(__ni_fsm_policy_match_reference);
+		cond->free = ni_ifcondition_free_args_reference;
+		cond->args.ref = ref;
+		cond->args.type = type;
+		return cond;
+	}
+	return NULL;
+}
+
+static inline ni_bool_t
+ni_ifcondition_reference_bind_type(ni_ifworker_type_t *bound, ni_ifworker_type_t type)
+{
+	if (*bound == NI_IFWORKER_TYPE_NONE) {
+		*bound = type;
+		return TRUE;
+	} else {
+		return *bound == type;
+	}
+}
+
+static ni_ifcondition_t *
+ni_ifcondition_reference_type_element(ni_ifworker_type_t *type, xml_node_t *node, const char *name)
+{
+	if (ni_string_eq(name, "device")) {
+		if (ni_ifcondition_reference_bind_type(type, NI_IFWORKER_TYPE_NETDEV))
+			return ni_ifcondition_device(node);
+
+		ni_error("%s: invalid <%s> reference element type mix", name, xml_node_location(node));
+		return NULL;
+	}
+	if (ni_string_eq(name, "modem")) {
+		if (ni_ifcondition_reference_bind_type(type, NI_IFWORKER_TYPE_MODEM))
+			return ni_ifcondition_modem(node);
+
+		ni_error("%s: invalid <%s> reference element type mix", name, xml_node_location(node));
+		return NULL;
+	}
+
+	ni_error("%s: unknown reference condition <%s>", xml_node_location(node), name);
+	return NULL;
+}
+
+/*
+ * <reference:device>...</reference:device>
+ * <reference:modem>...</reference:modem>
+ *
+ * Match a single property element of a referenced worker.
+ */
+static ni_ifcondition_t *
+ni_ifcondition_reference_element(xml_node_t *node, const char *name)
+{
+	ni_ifworker_type_t type = NI_IFWORKER_TYPE_NONE;
+	ni_ifcondition_t *cond;
+
+	cond = ni_ifcondition_reference_type_element(&type, node, name);
+	return ni_ifcondition_new_reference(cond, type);
+}
+
+/*
+ * <reference>...and device property match...</reference>
+ * <reference>...and modem property match...</reference>
+ *
+ * Each worker has a type (modem or device) and a reference is bond to
+ * the type of the 1st worker matching it's properties using an and term.
+ */
+static ni_ifcondition_t *
+ni_ifcondition_reference(xml_node_t *node)
+{
+	ni_ifcondition_t *result = NULL;
+	ni_ifworker_type_t type = NI_IFWORKER_TYPE_NONE;
+
+	for (node = node->children; node; node = node->next) {
+		ni_ifcondition_t *cond;
+
+		cond = ni_ifcondition_reference_type_element(&type, node, node->name);
+		if (cond == NULL) {
+			if (result)
+				ni_ifcondition_free(result);
+			return NULL;
+		}
+
+		if (result == NULL)
+			result = cond;
+		else
+			result = ni_ifcondition_and_terms(result, cond);
+	}
+
+	return ni_ifcondition_new_reference(result, type);
+}
+
 /*
  * <wireless>...</wireless>
  * <wireless:foobar>...</wireless:foobar>
@@ -1751,6 +1873,10 @@ ni_ifcondition_from_xml(xml_node_t *node)
 		return ni_ifcondition_device(node);
 	if (!strncmp(node->name, "device:", sizeof("device:")-1))
 		return ni_ifcondition_device_element(node, node->name + sizeof("device:")-1);
+	if (!strcmp(node->name, "reference"))
+		return ni_ifcondition_reference(node);
+	if (!strncmp(node->name, "reference:", sizeof("reference:")-1))
+		return ni_ifcondition_reference_element(node, node->name + sizeof("reference:")-1);
 	if (!strcmp(node->name, "child"))
 		return ni_ifcondition_and_child(node);
 	if (!strcmp(node->name, "modem"))

src/fsm.c

@@ -959,14 +959,11 @@ ni_ifworker_match_netdev_name(const ni_ifworker_t *w, const char *ifname)
 	if (!w || ni_string_empty(ifname))
 		return FALSE;
 
-	/* ifworker name must be same as policy name here.
-	 * If device name matches policy name then we
-	 *  consider such a match as fulfilled.
-	 */
 	if (ni_string_eq(w->name, ifname))
 		return TRUE;
 
-	ni_error("device %s requested via match is not present", ifname);
+	ni_debug_verbose(NI_LOG_DEBUG1, NI_TRACE_APPLICATION,
+			"device %s requested via match is not present", ifname);
 	return FALSE;
 }