// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (C) 2017 Red Hat, Inc.
*/
#include "nm-default.h"
#include "nm-manager.h"
#include "nm-ovsdb.h"
#include "nm-device-ovs-interface.h"
#include "nm-device-ovs-port.h"
#include "nm-device-ovs-bridge.h"
#include "platform/nm-platform.h"
#include "nm-core-internal.h"
#include "settings/nm-settings.h"
#include "devices/nm-device-factory.h"
#include "devices/nm-device-private.h"
/*****************************************************************************/
typedef struct {
NMDeviceFactory parent;
} NMOvsFactory;
typedef struct {
NMDeviceFactoryClass parent;
} NMOvsFactoryClass;
#define NM_TYPE_OVS_FACTORY (nm_ovs_factory_get_type ())
#define NM_OVS_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), NM_TYPE_OVS_FACTORY, NMOvsFactory))
#define NM_OVS_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), NM_TYPE_OVS_FACTORY, NMOvsFactoryClass))
#define NM_IS_OVS_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), NM_TYPE_OVS_FACTORY))
#define NM_IS_OVS_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), NM_TYPE_OVS_FACTORY))
#define NM_OVS_FACTORY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), NM_TYPE_OVS_FACTORY, NMOvsFactoryClass))
static GType nm_ovs_factory_get_type (void);
G_DEFINE_TYPE (NMOvsFactory, nm_ovs_factory, NM_TYPE_DEVICE_FACTORY)
/*****************************************************************************/
#define _NMLOG_DOMAIN LOGD_DEVICE
#define _NMLOG(level, ifname, con_uuid, ...) \
G_STMT_START { \
nm_log ((level), _NMLOG_DOMAIN, (ifname), (con_uuid), \
"ovs: " _NM_UTILS_MACRO_FIRST(__VA_ARGS__) \
_NM_UTILS_MACRO_REST(__VA_ARGS__)); \
} G_STMT_END
/*****************************************************************************/
NM_DEVICE_FACTORY_DECLARE_TYPES (
NM_DEVICE_FACTORY_DECLARE_LINK_TYPES (NM_LINK_TYPE_OPENVSWITCH)
NM_DEVICE_FACTORY_DECLARE_SETTING_TYPES (NM_SETTING_OVS_BRIDGE_SETTING_NAME,
NM_SETTING_OVS_INTERFACE_SETTING_NAME,
NM_SETTING_OVS_PORT_SETTING_NAME)
)
G_MODULE_EXPORT NMDeviceFactory *
nm_device_factory_create (GError **error)
{
nm_manager_set_capability (NM_MANAGER_GET, NM_CAPABILITY_OVS);
return (NMDeviceFactory *) g_object_new (NM_TYPE_OVS_FACTORY, NULL);
}
static NMDevice *
new_device_from_type (const char *name, NMDeviceType device_type)
{
GType type;
const char *type_desc;
NMLinkType link_type = NM_LINK_TYPE_NONE;
if (nm_manager_get_device (NM_MANAGER_GET, name, device_type))
return NULL;
if (device_type == NM_DEVICE_TYPE_OVS_INTERFACE) {
type = NM_TYPE_DEVICE_OVS_INTERFACE;
type_desc = "Open vSwitch Interface";
link_type = NM_LINK_TYPE_OPENVSWITCH;
} else if (device_type == NM_DEVICE_TYPE_OVS_PORT) {
type = NM_TYPE_DEVICE_OVS_PORT;
type_desc = "Open vSwitch Port";
} else if (device_type == NM_DEVICE_TYPE_OVS_BRIDGE) {
type = NM_TYPE_DEVICE_OVS_BRIDGE;
type_desc = "Open vSwitch Bridge";
} else {
return NULL;
}
return g_object_new (type,
NM_DEVICE_IFACE, name,
NM_DEVICE_DRIVER, "openvswitch",
NM_DEVICE_DEVICE_TYPE, device_type,
NM_DEVICE_TYPE_DESC, type_desc,
NM_DEVICE_LINK_TYPE, link_type,
NULL);
}
static void
ovsdb_device_added (NMOvsdb *ovsdb, const char *name, NMDeviceType device_type,
NMDeviceFactory *self)
{
NMDevice *device = NULL;
device = new_device_from_type (name, device_type);
if (!device)
return;
g_signal_emit_by_name (self, NM_DEVICE_FACTORY_DEVICE_ADDED, device);
g_object_unref (device);
}
static void
ovsdb_device_removed (NMOvsdb *ovsdb, const char *name, NMDeviceType device_type,
NMDeviceFactory *self)
{
NMDevice *device;
NMDeviceState device_state;
device = nm_manager_get_device (NM_MANAGER_GET, name, device_type);
if (!device)
return;
device_state = nm_device_get_state (device);
if ( device_type == NM_DEVICE_TYPE_OVS_INTERFACE
&& device_state > NM_DEVICE_STATE_DISCONNECTED
&& device_state < NM_DEVICE_STATE_DEACTIVATING) {
nm_device_state_changed (device,
NM_DEVICE_STATE_DEACTIVATING,
NM_DEVICE_STATE_REASON_DEPENDENCY_FAILED);
} else if (device_state == NM_DEVICE_STATE_UNMANAGED) {
nm_device_unrealize (device, TRUE, NULL);
}
}
static void
ovsdb_interface_failed (NMOvsdb *ovsdb,
const char *name,
const char *connection_uuid,
const char *error,
NMDeviceFactory *self)
{
NMDevice *device = NULL;
NMSettingsConnection *connection = NULL;
NMConnection *c;
const char *type;
NMSettingOvsInterface *s_ovs_int;
gboolean is_patch = FALSE;
gboolean ignore;
device = nm_manager_get_device (NM_MANAGER_GET, name, NM_DEVICE_TYPE_OVS_INTERFACE);
if (device && connection_uuid) {
connection = nm_settings_get_connection_by_uuid (nm_device_get_settings (device),
connection_uuid);
}
/* The patch interface which gets created first is expected to
* fail because the second patch doesn't exist yet. Ignore all
* failures of patch interfaces. */
if ( connection
&& (c = nm_settings_connection_get_connection (connection))
&& (type = nm_connection_get_connection_type (c))
&& nm_streq0 (type, NM_SETTING_OVS_INTERFACE_SETTING_NAME)
&& (s_ovs_int = nm_connection_get_setting_ovs_interface (c))
&& nm_streq0 (nm_setting_ovs_interface_get_interface_type (s_ovs_int), "patch"))
is_patch = TRUE;
ignore = !device || is_patch;
_NMLOG (ignore ? LOGL_DEBUG : LOGL_INFO,
name, connection_uuid,
"ovs interface \"%s\" (%s) failed%s: %s",
name, connection_uuid,
ignore ? " (ignored)" : "",
error);
if (ignore)
return;
if (connection) {
nm_settings_connection_autoconnect_blocked_reason_set (connection,
NM_SETTINGS_AUTO_CONNECT_BLOCKED_REASON_FAILED,
TRUE);
}
nm_device_state_changed (device,
NM_DEVICE_STATE_FAILED,
NM_DEVICE_STATE_REASON_OVSDB_FAILED);
}
static void
start (NMDeviceFactory *self)
{
NMOvsdb *ovsdb;
ovsdb = nm_ovsdb_get ();
g_signal_connect_object (ovsdb, NM_OVSDB_DEVICE_ADDED, G_CALLBACK (ovsdb_device_added), self, (GConnectFlags) 0);
g_signal_connect_object (ovsdb, NM_OVSDB_DEVICE_REMOVED, G_CALLBACK (ovsdb_device_removed), self, (GConnectFlags) 0);
g_signal_connect_object (ovsdb, NM_OVSDB_INTERFACE_FAILED, G_CALLBACK (ovsdb_interface_failed), self, (GConnectFlags) 0);
}
static NMDevice *
create_device (NMDeviceFactory *self,
const char *iface,
const NMPlatformLink *plink,
NMConnection *connection,
gboolean *out_ignore)
{
NMDeviceType device_type = NM_DEVICE_TYPE_UNKNOWN;
const char *connection_type = NULL;
if (g_strcmp0 (iface, "ovs-system") == 0) {
*out_ignore = TRUE;
return NULL;
}
if (connection)
connection_type = nm_connection_get_connection_type (connection);
if (plink)
device_type = NM_DEVICE_TYPE_OVS_INTERFACE;
else if (g_strcmp0 (connection_type, NM_SETTING_OVS_INTERFACE_SETTING_NAME) == 0)
device_type = NM_DEVICE_TYPE_OVS_INTERFACE;
else if (g_strcmp0 (connection_type, NM_SETTING_OVS_PORT_SETTING_NAME) == 0)
device_type = NM_DEVICE_TYPE_OVS_PORT;
else if (g_strcmp0 (connection_type, NM_SETTING_OVS_BRIDGE_SETTING_NAME) == 0)
device_type = NM_DEVICE_TYPE_OVS_BRIDGE;
return new_device_from_type (iface, device_type);
}
static void
nm_ovs_factory_init (NMOvsFactory *self)
{
}
static void
nm_ovs_factory_class_init (NMOvsFactoryClass *klass)
{
NMDeviceFactoryClass *factory_class = NM_DEVICE_FACTORY_CLASS (klass);
factory_class->get_supported_types = get_supported_types;
factory_class->start = start;
factory_class->create_device = create_device;
}