colin/NetworkManager
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
d9968b133b32fbfbc5e726a8fc96e38cc044c831
NetworkManager/libnm-core/nm-setting-sriov.c

1373 lines
39 KiB
C
Raw Blame History

/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
* Copyright (C) 2018 Red Hat, Inc.
*/
#include "libnm-core/nm-default-libnm-core.h"
#include "nm-setting-sriov.h"
#include "nm-setting-private.h"
#include "nm-utils-private.h"
/**
* SECTION:nm-setting-sriov
* @short_description: Describes SR-IOV connection properties
* @include: nm-setting-sriov.h
**/
/*****************************************************************************/
NM_GOBJECT_PROPERTIES_DEFINE(NMSettingSriov, PROP_TOTAL_VFS, PROP_VFS, PROP_AUTOPROBE_DRIVERS, );
/**
* NMSettingSriov:
*
* SR-IOV settings
*
* Since: 1.14
*/
struct _NMSettingSriov {
NMSetting parent;
GPtrArray *vfs;
guint total_vfs;
NMTernary autoprobe_drivers;
};
struct _NMSettingSriovClass {
NMSettingClass parent;
};
G_DEFINE_TYPE(NMSettingSriov, nm_setting_sriov, NM_TYPE_SETTING)
/*****************************************************************************/
G_DEFINE_BOXED_TYPE(NMSriovVF, nm_sriov_vf, nm_sriov_vf_dup, nm_sriov_vf_unref)
struct _NMSriovVF {
guint refcount;
guint index;
GHashTable *attributes;
GHashTable *vlans;
guint * vlan_ids;
};
typedef struct {
guint id;
guint qos;
NMSriovVFVlanProtocol protocol;
} VFVlan;
static guint
_vf_vlan_hash(gconstpointer ptr)
{
return nm_hash_val(1348254767u, *((guint *) ptr));
}
static gboolean
_vf_vlan_equal(gconstpointer a, gconstpointer b)
{
return *((guint *) a) == *((guint *) b);
}
static GHashTable *
_vf_vlan_create_hash(void)
{
G_STATIC_ASSERT_EXPR(G_STRUCT_OFFSET(VFVlan, id) == 0);
return g_hash_table_new_full(_vf_vlan_hash, _vf_vlan_equal, NULL, nm_g_slice_free_fcn(VFVlan));
}
/**
* nm_sriov_vf_new:
* @index: the VF index
*
* Creates a new #NMSriovVF object.
*
* Returns: (transfer full): the new #NMSriovVF object.
*
* Since: 1.14
**/
NMSriovVF *
nm_sriov_vf_new(guint index)
{
NMSriovVF *vf;
vf = g_slice_new(NMSriovVF);
*vf = (NMSriovVF){
.refcount = 1,
.index = index,
.attributes = g_hash_table_new_full(nm_str_hash,
g_str_equal,
g_free,
(GDestroyNotify) g_variant_unref),
};
return vf;
}
/**
* nm_sriov_vf_ref:
* @vf: the #NMSriovVF
*
* Increases the reference count of the object.
*
* Since: 1.14
**/
void
nm_sriov_vf_ref(NMSriovVF *vf)
{
g_return_if_fail(vf);
g_return_if_fail(vf->refcount > 0);
vf->refcount++;
}
/**
* nm_sriov_vf_unref:
* @vf: the #NMSriovVF
*
* Decreases the reference count of the object. If the reference count
* reaches zero, the object will be destroyed.
*
* Since: 1.14
**/
void
nm_sriov_vf_unref(NMSriovVF *vf)
{
g_return_if_fail(vf);
g_return_if_fail(vf->refcount > 0);
vf->refcount--;
if (vf->refcount == 0) {
g_hash_table_unref(vf->attributes);
if (vf->vlans)
g_hash_table_unref(vf->vlans);
g_free(vf->vlan_ids);
nm_g_slice_free(vf);
}
}
/**
* nm_sriov_vf_equal:
* @vf: the #NMSriovVF
* @other: the #NMSriovVF to compare @vf to.
*
* Determines if two #NMSriovVF objects have the same index,
* attributes and VLANs.
*
* Returns: %TRUE if the objects contain the same values, %FALSE
* if they do not.
*
* Since: 1.14
**/
gboolean
nm_sriov_vf_equal(const NMSriovVF *vf, const NMSriovVF *other)
{
GHashTableIter iter;
const char * key;
GVariant * value, *value2;
VFVlan * vlan, *vlan2;
guint n_vlans;
g_return_val_if_fail(vf, FALSE);
g_return_val_if_fail(vf->refcount > 0, FALSE);
g_return_val_if_fail(other, FALSE);
g_return_val_if_fail(other->refcount > 0, FALSE);
if (vf == other)
return TRUE;
if (vf->index != other->index)
return FALSE;
if (g_hash_table_size(vf->attributes) != g_hash_table_size(other->attributes))
return FALSE;
g_hash_table_iter_init(&iter, vf->attributes);
while (g_hash_table_iter_next(&iter, (gpointer *) &key, (gpointer *) &value)) {
value2 = g_hash_table_lookup(other->attributes, key);
if (!value2)
return FALSE;
if (!g_variant_equal(value, value2))
return FALSE;
}
n_vlans = vf->vlans ? g_hash_table_size(vf->vlans) : 0u;
if (n_vlans != (other->vlans ? g_hash_table_size(other->vlans) : 0u))
return FALSE;
if (n_vlans > 0) {
g_hash_table_iter_init(&iter, vf->vlans);
while (g_hash_table_iter_next(&iter, (gpointer *) &vlan, NULL)) {
vlan2 = g_hash_table_lookup(other->vlans, vlan);
if (!vlan2)
return FALSE;
if (vlan->qos != vlan2->qos || vlan->protocol != vlan2->protocol)
return FALSE;
}
}
return TRUE;
}
static void
vf_add_vlan(NMSriovVF *vf, guint vlan_id, guint qos, NMSriovVFVlanProtocol protocol)
{
VFVlan *vlan;
vlan = g_slice_new(VFVlan);
*vlan = (VFVlan){
.id = vlan_id,
.qos = qos,
.protocol = protocol,
};
if (!vf->vlans)
vf->vlans = _vf_vlan_create_hash();
g_hash_table_add(vf->vlans, vlan);
nm_clear_g_free(&vf->vlan_ids);
}
/**
* nm_sriov_vf_dup:
* @vf: the #NMSriovVF
*
* Creates a copy of @vf.
*
* Returns: (transfer full): a copy of @vf
*
* Since: 1.14
**/
NMSriovVF *
nm_sriov_vf_dup(const NMSriovVF *vf)
{
NMSriovVF * copy;
GHashTableIter iter;
const char * name;
GVariant * variant;
VFVlan * vlan;
g_return_val_if_fail(vf, NULL);
g_return_val_if_fail(vf->refcount > 0, NULL);
copy = nm_sriov_vf_new(vf->index);
g_hash_table_iter_init(&iter, vf->attributes);
while (g_hash_table_iter_next(&iter, (gpointer *) &name, (gpointer *) &variant))
nm_sriov_vf_set_attribute(copy, name, variant);
if (vf->vlans) {
g_hash_table_iter_init(&iter, vf->vlans);
while (g_hash_table_iter_next(&iter, (gpointer *) &vlan, NULL))
vf_add_vlan(copy, vlan->id, vlan->qos, vlan->protocol);
}
return copy;
}
/**
* nm_sriov_vf_get_index:
* @vf: the #NMSriovVF
*
* Gets the index property of this VF object.
*
* Returns: the VF index
*
* Since: 1.14
**/
guint
nm_sriov_vf_get_index(const NMSriovVF *vf)
{
g_return_val_if_fail(vf, 0);
g_return_val_if_fail(vf->refcount > 0, 0);
return vf->index;
}
/**
* nm_sriov_vf_set_attribute:
* @vf: the #NMSriovVF
* @name: the name of a route attribute
* @value: (transfer none) (allow-none): the value
*
* Sets the named attribute on @vf to the given value.
*
* Since: 1.14
**/
void
nm_sriov_vf_set_attribute(NMSriovVF *vf, const char *name, GVariant *value)
{
g_return_if_fail(vf);
g_return_if_fail(vf->refcount > 0);
g_return_if_fail(name && *name != '\0');
g_return_if_fail(!nm_streq(name, "index"));
if (value) {
g_hash_table_insert(vf->attributes, g_strdup(name), g_variant_ref_sink(value));
} else
g_hash_table_remove(vf->attributes, name);
}
/**
* nm_sriov_vf_get_attribute_names:
* @vf: the #NMSriovVF
*
* Gets an array of attribute names defined on @vf.
*
* Returns: (transfer container): a %NULL-terminated array of attribute names
*
* Since: 1.14
**/
const char **
nm_sriov_vf_get_attribute_names(const NMSriovVF *vf)
{
g_return_val_if_fail(vf, NULL);
g_return_val_if_fail(vf->refcount > 0, NULL);
return nm_utils_strdict_get_keys(vf->attributes, TRUE, NULL);
}
/**
* nm_sriov_vf_get_attribute:
* @vf: the #NMSriovVF
* @name: the name of a VF attribute
*
* Gets the value of the attribute with name @name on @vf
*
* Returns: (transfer none): the value of the attribute with name @name on
* @vf, or %NULL if @vf has no such attribute.
*
* Since: 1.14
**/
GVariant *
nm_sriov_vf_get_attribute(const NMSriovVF *vf, const char *name)
{
g_return_val_if_fail(vf, NULL);
g_return_val_if_fail(vf->refcount > 0, NULL);
g_return_val_if_fail(name && *name != '\0', NULL);
return g_hash_table_lookup(vf->attributes, name);
}
const NMVariantAttributeSpec *const _nm_sriov_vf_attribute_spec[] = {
NM_VARIANT_ATTRIBUTE_SPEC_DEFINE(NM_SRIOV_VF_ATTRIBUTE_MAC,
G_VARIANT_TYPE_STRING,
.str_type = 'm', ),
NM_VARIANT_ATTRIBUTE_SPEC_DEFINE(NM_SRIOV_VF_ATTRIBUTE_SPOOF_CHECK, G_VARIANT_TYPE_BOOLEAN, ),
NM_VARIANT_ATTRIBUTE_SPEC_DEFINE(NM_SRIOV_VF_ATTRIBUTE_TRUST, G_VARIANT_TYPE_BOOLEAN, ),
NM_VARIANT_ATTRIBUTE_SPEC_DEFINE(NM_SRIOV_VF_ATTRIBUTE_MIN_TX_RATE, G_VARIANT_TYPE_UINT32, ),
NM_VARIANT_ATTRIBUTE_SPEC_DEFINE(NM_SRIOV_VF_ATTRIBUTE_MAX_TX_RATE, G_VARIANT_TYPE_UINT32, ),
/* D-Bus only, synthetic attributes */
NM_VARIANT_ATTRIBUTE_SPEC_DEFINE("vlans", G_VARIANT_TYPE_STRING, .str_type = 'd', ),
NULL,
};
/**
* nm_sriov_vf_attribute_validate:
* @name: the attribute name
* @value: the attribute value
* @known: (out): on return, whether the attribute name is a known one
* @error: (allow-none): return location for a #GError, or %NULL
*
* Validates a VF attribute, i.e. checks that the attribute is a known one,
* the value is of the correct type and well-formed.
*
* Returns: %TRUE if the attribute is valid, %FALSE otherwise
*
* Since: 1.14
*/
gboolean
nm_sriov_vf_attribute_validate(const char *name, GVariant *value, gboolean *known, GError **error)
{
const NMVariantAttributeSpec *const *iter;
const NMVariantAttributeSpec * spec = NULL;
g_return_val_if_fail(name, FALSE);
g_return_val_if_fail(value, FALSE);
g_return_val_if_fail(!error || !*error, FALSE);
for (iter = _nm_sriov_vf_attribute_spec; *iter; iter++) {
if (nm_streq(name, (*iter)->name)) {
spec = *iter;
break;
}
}
if (!spec || spec->str_type == 'd') {
NM_SET_OUT(known, FALSE);
g_set_error_literal(error,
NM_CONNECTION_ERROR,
NM_CONNECTION_ERROR_FAILED,
_("unknown attribute"));
return FALSE;
}
NM_SET_OUT(known, TRUE);
if (!g_variant_is_of_type(value, spec->type)) {
g_set_error(error,
NM_CONNECTION_ERROR,
NM_CONNECTION_ERROR_FAILED,
_("invalid attribute type '%s'"),
g_variant_get_type_string(value));
return FALSE;
}
if (g_variant_type_equal(spec->type, G_VARIANT_TYPE_STRING)) {
const char *string;
switch (spec->str_type) {
case 'm': /* MAC address */
string = g_variant_get_string(value, NULL);
if (!nm_utils_hwaddr_valid(string, -1)) {
g_set_error(error,
NM_CONNECTION_ERROR,
NM_CONNECTION_ERROR_FAILED,
_("'%s' is not a valid MAC address"),
string);
return FALSE;
}
break;
default:
break;
}
}
return TRUE;
}
gboolean
_nm_sriov_vf_attribute_validate_all(const NMSriovVF *vf, GError **error)
{
GHashTableIter iter;
const char * name;
GVariant * variant;
GVariant * min, *max;
g_return_val_if_fail(vf, FALSE);
g_return_val_if_fail(vf->refcount > 0, FALSE);
g_hash_table_iter_init(&iter, vf->attributes);
while (g_hash_table_iter_next(&iter, (gpointer *) &name, (gpointer *) &variant)) {
if (!nm_sriov_vf_attribute_validate(name, variant, NULL, error)) {
g_prefix_error(error, "attribute '%s':", name);
return FALSE;
}
}
min = g_hash_table_lookup(vf->attributes, NM_SRIOV_VF_ATTRIBUTE_MIN_TX_RATE);
max = g_hash_table_lookup(vf->attributes, NM_SRIOV_VF_ATTRIBUTE_MAX_TX_RATE);
if (min && max && g_variant_get_uint32(min) > g_variant_get_uint32(max)) {
g_set_error(error,
NM_CONNECTION_ERROR,
NM_CONNECTION_ERROR_FAILED,
"min_tx_rate is greater than max_tx_rate");
return FALSE;
}
return TRUE;
}
/**
* nm_sriov_vf_add_vlan:
* @vf: the #NMSriovVF
* @vlan_id: the VLAN id
*
* Adds a VLAN to the VF.
*
* Returns: %TRUE if the VLAN was added; %FALSE if it already existed
*
* Since: 1.14
**/
gboolean
nm_sriov_vf_add_vlan(NMSriovVF *vf, guint vlan_id)
{
g_return_val_if_fail(vf, FALSE);
g_return_val_if_fail(vf->refcount > 0, FALSE);
if (vf->vlans && g_hash_table_contains(vf->vlans, &vlan_id))
return FALSE;
vf_add_vlan(vf, vlan_id, 0, NM_SRIOV_VF_VLAN_PROTOCOL_802_1Q);
return TRUE;
}
/**
* nm_sriov_vf_remove_vlan:
* @vf: the #NMSriovVF
* @vlan_id: the VLAN id
*
* Removes a VLAN from a VF.
*
* Returns: %TRUE if the VLAN was removed, %FALSE if the VLAN @vlan_id
* did not belong to the VF.
*
* Since: 1.14
*/
gboolean
nm_sriov_vf_remove_vlan(NMSriovVF *vf, guint vlan_id)
{
g_return_val_if_fail(vf, FALSE);
g_return_val_if_fail(vf->refcount > 0, FALSE);
if (!vf->vlans || !g_hash_table_remove(vf->vlans, &vlan_id))
return FALSE;
nm_clear_g_free(&vf->vlan_ids);
return TRUE;
}
static int
vlan_id_compare(gconstpointer a, gconstpointer b, gpointer user_data)
{
guint id_a = *(guint *) a;
guint id_b = *(guint *) b;
if (id_a < id_b)
return -1;
else if (id_a > id_b)
return 1;
else
return 0;
}
/**
* nm_sriov_vf_get_vlan_ids:
* @vf: the #NMSriovVF
* @length: (out) (allow-none): on return, the number of VLANs configured
*
* Returns the VLANs currently configured on the VF.
*
* Returns: (transfer none) (array length=length): a list of VLAN ids configured on the VF.
*
* Since: 1.14
*/
const guint *
nm_sriov_vf_get_vlan_ids(const NMSriovVF *vf, guint *length)
{
GHashTableIter iter;
VFVlan * vlan;
guint num, i;
g_return_val_if_fail(vf, NULL);
g_return_val_if_fail(vf->refcount > 0, NULL);
num = vf->vlans ? g_hash_table_size(vf->vlans) : 0u;
NM_SET_OUT(length, num);
if (vf->vlan_ids)
return vf->vlan_ids;
if (num == 0)
return NULL;
/* vf is const, however, vlan_ids is a mutable field caching the
* result ("mutable" in C++ terminology) */
((NMSriovVF *) vf)->vlan_ids = g_new0(guint, num);
i = 0;
g_hash_table_iter_init(&iter, vf->vlans);
while (g_hash_table_iter_next(&iter, (gpointer *) &vlan, NULL))
vf->vlan_ids[i++] = vlan->id;
nm_assert(num == i);
g_qsort_with_data(vf->vlan_ids, num, sizeof(guint), vlan_id_compare, NULL);
return vf->vlan_ids;
}
/**
* nm_sriov_vf_set_vlan_qos:
* @vf: the #NMSriovVF
* @vlan_id: the VLAN id
* @qos: a QoS (priority) value
*
* Sets a QoS value for the given VLAN.
*
* Since: 1.14
*/
void
nm_sriov_vf_set_vlan_qos(NMSriovVF *vf, guint vlan_id, guint32 qos)
{
VFVlan *vlan;
g_return_if_fail(vf);
g_return_if_fail(vf->refcount > 0);
if (!vf->vlans || !(vlan = g_hash_table_lookup(vf->vlans, &vlan_id)))
g_return_if_reached();
vlan->qos = qos;
}
/**
* nm_sriov_vf_set_vlan_protocol:
* @vf: the #NMSriovVF
* @vlan_id: the VLAN id
* @protocol: the VLAN protocol
*
* Sets the protocol for the given VLAN.
*
* Since: 1.14
*/
void
nm_sriov_vf_set_vlan_protocol(NMSriovVF *vf, guint vlan_id, NMSriovVFVlanProtocol protocol)
{
VFVlan *vlan;
g_return_if_fail(vf);
g_return_if_fail(vf->refcount > 0);
if (!vf->vlans || !(vlan = g_hash_table_lookup(vf->vlans, &vlan_id)))
g_return_if_reached();
vlan->protocol = protocol;
}
/**
* nm_sriov_vf_get_vlan_qos:
* @vf: the #NMSriovVF
* @vlan_id: the VLAN id
*
* Returns the QoS value for the given VLAN.
*
* Returns: the QoS value
*
* Since: 1.14
*/
guint32
nm_sriov_vf_get_vlan_qos(const NMSriovVF *vf, guint vlan_id)
{
VFVlan *vlan;
g_return_val_if_fail(vf, 0);
g_return_val_if_fail(vf->refcount > 0, 0);
if (!vf->vlans || !(vlan = g_hash_table_lookup(vf->vlans, &vlan_id)))
g_return_val_if_reached(0);
return vlan->qos;
}
/*
* nm_sriov_vf_get_vlan_protocol:
* @vf: the #NMSriovVF
* @vlan_id: the VLAN id
*
* Returns the configured protocol for the given VLAN.
*
* Returns: the configured protocol
*
* Since: 1.14
*/
NMSriovVFVlanProtocol
nm_sriov_vf_get_vlan_protocol(const NMSriovVF *vf, guint vlan_id)
{
VFVlan *vlan;
g_return_val_if_fail(vf, NM_SRIOV_VF_VLAN_PROTOCOL_802_1Q);
g_return_val_if_fail(vf->refcount > 0, NM_SRIOV_VF_VLAN_PROTOCOL_802_1Q);
if (!vf->vlans || !(vlan = g_hash_table_lookup(vf->vlans, &vlan_id)))
g_return_val_if_reached(NM_SRIOV_VF_VLAN_PROTOCOL_802_1Q);
return vlan->protocol;
}
/*****************************************************************************/
/**
* nm_setting_sriov_get_total_vfs:
* @setting: the #NMSettingSriov
*
* Returns the value contained in the #NMSettingSriov:total-vfs
* property.
*
* Returns: the total number of SR-IOV virtual functions to create
*
* Since: 1.14
**/
guint
nm_setting_sriov_get_total_vfs(NMSettingSriov *setting)
{
g_return_val_if_fail(NM_IS_SETTING_SRIOV(setting), 0);
return setting->total_vfs;
}
/**
* nm_setting_sriov_get_num_vfs:
* @setting: the #NMSettingSriov
*
* Returns: the number of configured VFs
*
* Since: 1.14
**/
guint
nm_setting_sriov_get_num_vfs(NMSettingSriov *setting)
{
g_return_val_if_fail(NM_IS_SETTING_SRIOV(setting), 0);
return setting->vfs->len;
}
/**
* nm_setting_sriov_get_vf:
* @setting: the #NMSettingSriov
* @idx: index number of the VF to return
*
* Returns: (transfer none): the VF at index @idx
*
* Since: 1.14
**/
NMSriovVF *
nm_setting_sriov_get_vf(NMSettingSriov *setting, guint idx)
{
g_return_val_if_fail(NM_IS_SETTING_SRIOV(setting), NULL);
g_return_val_if_fail(idx < setting->vfs->len, NULL);
return setting->vfs->pdata[idx];
}
/**
* nm_setting_sriov_add_vf:
* @setting: the #NMSettingSriov
* @vf: the VF to add
*
* Appends a new VF and associated information to the setting. The
* given VF is duplicated internally and is not changed by this function.
*
* Since: 1.14
**/
void
nm_setting_sriov_add_vf(NMSettingSriov *setting, NMSriovVF *vf)
{
g_return_if_fail(NM_IS_SETTING_SRIOV(setting));
g_return_if_fail(vf);
g_return_if_fail(vf->refcount > 0);
g_ptr_array_add(setting->vfs, nm_sriov_vf_dup(vf));
_notify(setting, PROP_VFS);
}
/**
* nm_setting_sriov_remove_vf:
* @setting: the #NMSettingSriov
* @idx: index number of the VF
*
* Removes the VF at index @idx.
*
* Since: 1.14
**/
void
nm_setting_sriov_remove_vf(NMSettingSriov *setting, guint idx)
{
g_return_if_fail(NM_IS_SETTING_SRIOV(setting));
g_return_if_fail(idx < setting->vfs->len);
g_ptr_array_remove_index(setting->vfs, idx);
_notify(setting, PROP_VFS);
}
/**
* nm_setting_sriov_remove_vf_by_index:
* @setting: the #NMSettingSriov
* @index: the VF index of the VF to remove
*
* Removes the VF with VF index @index.
*
* Returns: %TRUE if the VF was found and removed; %FALSE if it was not
*
* Since: 1.14
**/
gboolean
nm_setting_sriov_remove_vf_by_index(NMSettingSriov *setting, guint index)
{
guint i;
g_return_val_if_fail(NM_IS_SETTING_SRIOV(setting), FALSE);
for (i = 0; i < setting->vfs->len; i++) {
if (nm_sriov_vf_get_index(setting->vfs->pdata[i]) == index) {
g_ptr_array_remove_index(setting->vfs, i);
_notify(setting, PROP_VFS);
return TRUE;
}
}
return FALSE;
}
/**
* nm_setting_sriov_clear_vfs:
* @setting: the #NMSettingSriov
*
* Removes all configured VFs.
*
* Since: 1.14
**/
void
nm_setting_sriov_clear_vfs(NMSettingSriov *setting)
{
g_return_if_fail(NM_IS_SETTING_SRIOV(setting));
if (setting->vfs->len != 0) {
g_ptr_array_set_size(setting->vfs, 0);
_notify(setting, PROP_VFS);
}
}
/**
* nm_setting_sriov_get_autoprobe_drivers:
* @setting: the #NMSettingSriov
*
* Returns the value contained in the #NMSettingSriov:autoprobe-drivers
* property.
*
* Returns: the autoprobe-drivers property value
*
* Since: 1.14
**/
NMTernary
nm_setting_sriov_get_autoprobe_drivers(NMSettingSriov *setting)
{
g_return_val_if_fail(NM_IS_SETTING_SRIOV(setting), NM_TERNARY_DEFAULT);
return setting->autoprobe_drivers;
}
static int
vf_index_compare(gconstpointer a, gconstpointer b)
{
NMSriovVF *vf_a = *(NMSriovVF **) a;
NMSriovVF *vf_b = *(NMSriovVF **) b;
if (vf_a->index < vf_b->index)
return -1;
else if (vf_a->index > vf_b->index)
return 1;
else
return 0;
}
gboolean
_nm_setting_sriov_sort_vfs(NMSettingSriov *setting)
{
gboolean need_sort = FALSE;
guint i;
for (i = 1; i < setting->vfs->len; i++) {
NMSriovVF *vf_prev = setting->vfs->pdata[i - 1];
NMSriovVF *vf = setting->vfs->pdata[i];
if (vf->index <= vf_prev->index) {
need_sort = TRUE;
break;
}
}
if (need_sort) {
g_ptr_array_sort(setting->vfs, vf_index_compare);
_notify(setting, PROP_VFS);
}
return need_sort;
}
/*****************************************************************************/
static GVariant *
vfs_to_dbus(const NMSettInfoSetting * sett_info,
guint property_idx,
NMConnection * connection,
NMSetting * setting,
NMConnectionSerializationFlags flags,
const NMConnectionSerializationOptions *options)
{
gs_unref_ptrarray GPtrArray *vfs = NULL;
GVariantBuilder builder;
guint i;
g_object_get(setting, NM_SETTING_SRIOV_VFS, &vfs, NULL);
g_variant_builder_init(&builder, G_VARIANT_TYPE("aa{sv}"));
if (vfs) {
for (i = 0; i < vfs->len; i++) {
gs_free const char **attr_names = NULL;
NMSriovVF * vf = vfs->pdata[i];
GVariantBuilder vf_builder;
const guint * vlan_ids;
const char ** name;
guint num_vlans = 0;
g_variant_builder_init(&vf_builder, G_VARIANT_TYPE_VARDICT);
g_variant_builder_add(&vf_builder,
"{sv}",
"index",
g_variant_new_uint32(nm_sriov_vf_get_index(vf)));
attr_names = nm_utils_strdict_get_keys(vf->attributes, TRUE, NULL);
if (attr_names) {
for (name = attr_names; *name; name++) {
g_variant_builder_add(&vf_builder,
"{sv}",
*name,
nm_sriov_vf_get_attribute(vf, *name));
}
}
/* VLANs are translated into an array of maps, where each map has
* keys 'id', 'qos' and 'proto'. This guarantees enough flexibility
* to accommodate any future new option. */
vlan_ids = nm_sriov_vf_get_vlan_ids(vf, &num_vlans);
if (num_vlans) {
GVariantBuilder vlans_builder;
guint j;
g_variant_builder_init(&vlans_builder, G_VARIANT_TYPE("aa{sv}"));
for (j = 0; j < num_vlans; j++) {
GVariantBuilder vlan_builder;
g_variant_builder_init(&vlan_builder, G_VARIANT_TYPE("a{sv}"));
g_variant_builder_add(&vlan_builder,
"{sv}",
"id",
g_variant_new_uint32(vlan_ids[j]));
g_variant_builder_add(
&vlan_builder,
"{sv}",
"qos",
g_variant_new_uint32(nm_sriov_vf_get_vlan_qos(vf, vlan_ids[j])));
g_variant_builder_add(
&vlan_builder,
"{sv}",
"protocol",
g_variant_new_uint32(nm_sriov_vf_get_vlan_protocol(vf, vlan_ids[j])));
g_variant_builder_add(&vlans_builder, "a{sv}", &vlan_builder);
}
g_variant_builder_add(&vf_builder,
"{sv}",
"vlans",
g_variant_builder_end(&vlans_builder));
}
g_variant_builder_add(&builder, "a{sv}", &vf_builder);
}
}
return g_variant_builder_end(&builder);
}
static gboolean
vfs_from_dbus(NMSetting * setting,
GVariant * connection_dict,
const char * property,
GVariant * value,
NMSettingParseFlags parse_flags,
GError ** error)
{
GPtrArray * vfs;
GVariantIter vf_iter;
GVariant * vf_var;
g_return_val_if_fail(g_variant_is_of_type(value, G_VARIANT_TYPE("aa{sv}")), FALSE);
vfs = g_ptr_array_new_with_free_func((GDestroyNotify) nm_sriov_vf_unref);
g_variant_iter_init(&vf_iter, value);
while (g_variant_iter_next(&vf_iter, "@a{sv}", &vf_var)) {
NMSriovVF * vf;
guint32 index;
GVariantIter attr_iter;
const char * attr_name;
GVariant * attr_var, *vlans_var;
if (!g_variant_lookup(vf_var, "index", "u", &index))
goto next;
vf = nm_sriov_vf_new(index);
g_variant_iter_init(&attr_iter, vf_var);
while (g_variant_iter_next(&attr_iter, "{&sv}", &attr_name, &attr_var)) {
if (!NM_IN_STRSET(attr_name, "index", "vlans"))
nm_sriov_vf_set_attribute(vf, attr_name, attr_var);
g_variant_unref(attr_var);
}
if (g_variant_lookup(vf_var, "vlans", "@aa{sv}", &vlans_var)) {
GVariantIter vlan_iter;
GVariant * vlan_var;
g_variant_iter_init(&vlan_iter, vlans_var);
while (g_variant_iter_next(&vlan_iter, "@a{sv}", &vlan_var)) {
NMSriovVFVlanProtocol proto = NM_SRIOV_VF_VLAN_PROTOCOL_802_1Q;
gint64 vlan_id = -1;
guint qos = 0;
g_variant_iter_init(&attr_iter, vlan_var);
while (g_variant_iter_next(&attr_iter, "{&sv}", &attr_name, &attr_var)) {
if (nm_streq(attr_name, "id")
&& g_variant_is_of_type(attr_var, G_VARIANT_TYPE_UINT32))
vlan_id = g_variant_get_uint32(attr_var);
else if (nm_streq(attr_name, "qos")
&& g_variant_is_of_type(attr_var, G_VARIANT_TYPE_UINT32))
qos = g_variant_get_uint32(attr_var);
else if (nm_streq(attr_name, "protocol")
&& g_variant_is_of_type(attr_var, G_VARIANT_TYPE_UINT32))
proto = g_variant_get_uint32(attr_var);
g_variant_unref(attr_var);
}
if (vlan_id != -1)
vf_add_vlan(vf, vlan_id, qos, proto);
g_variant_unref(vlan_var);
}
g_variant_unref(vlans_var);
}
g_ptr_array_add(vfs, vf);
next:
g_variant_unref(vf_var);
}
g_object_set(setting, NM_SETTING_SRIOV_VFS, vfs, NULL);
g_ptr_array_unref(vfs);
return TRUE;
}
/*****************************************************************************/
static gboolean
verify(NMSetting *setting, NMConnection *connection, GError **error)
{
NMSettingSriov *self = NM_SETTING_SRIOV(setting);
guint i;
if (self->vfs->len) {
gs_unref_hashtable GHashTable *h = NULL;
h = g_hash_table_new(nm_direct_hash, NULL);
for (i = 0; i < self->vfs->len; i++) {
NMSriovVF * vf = self->vfs->pdata[i];
gs_free_error GError *local = NULL;
if (vf->index >= self->total_vfs) {
g_set_error(error,
NM_CONNECTION_ERROR,
NM_CONNECTION_ERROR_INVALID_PROPERTY,
_("VF with index %u, but the total number of VFs is %u"),
vf->index,
self->total_vfs);
g_prefix_error(error,
"%s.%s: ",
NM_SETTING_SRIOV_SETTING_NAME,
NM_SETTING_SRIOV_VFS);
return FALSE;
}
if (!_nm_sriov_vf_attribute_validate_all(vf, &local)) {
g_set_error(error,
NM_CONNECTION_ERROR,
NM_CONNECTION_ERROR_INVALID_PROPERTY,
_("invalid VF %u: %s"),
vf->index,
local->message);
g_prefix_error(error,
"%s.%s: ",
NM_SETTING_SRIOV_SETTING_NAME,
NM_SETTING_SRIOV_VFS);
return FALSE;
}
if (g_hash_table_contains(h, GUINT_TO_POINTER(vf->index))) {
g_set_error(error,
NM_CONNECTION_ERROR,
NM_CONNECTION_ERROR_INVALID_PROPERTY,
_("duplicate VF index %u"),
vf->index);
g_prefix_error(error,
"%s.%s: ",
NM_SETTING_SRIOV_SETTING_NAME,
NM_SETTING_SRIOV_VFS);
return FALSE;
}
g_hash_table_add(h, GUINT_TO_POINTER(vf->index));
}
}
/* Failures from here on are NORMALIZABLE... */
if (self->vfs->len) {
for (i = 1; i < self->vfs->len; i++) {
NMSriovVF *vf_prev = self->vfs->pdata[i - 1];
NMSriovVF *vf = self->vfs->pdata[i];
if (vf->index <= vf_prev->index) {
g_set_error(error,
NM_CONNECTION_ERROR,
NM_CONNECTION_ERROR_INVALID_PROPERTY,
_("VFs %d and %d are not sorted by ascending index"),
vf_prev->index,
vf->index);
g_prefix_error(error,
"%s.%s: ",
NM_SETTING_SRIOV_SETTING_NAME,
NM_SETTING_SRIOV_VFS);
return NM_SETTING_VERIFY_NORMALIZABLE;
}
}
}
return TRUE;
}
static NMTernary
compare_property(const NMSettInfoSetting *sett_info,
guint property_idx,
NMConnection * con_a,
NMSetting * set_a,
NMConnection * con_b,
NMSetting * set_b,
NMSettingCompareFlags flags)
{
NMSettingSriov *a;
NMSettingSriov *b;
guint i;
if (nm_streq(sett_info->property_infos[property_idx].name, NM_SETTING_SRIOV_VFS)) {
if (set_b) {
a = NM_SETTING_SRIOV(set_a);
b = NM_SETTING_SRIOV(set_b);
if (a->vfs->len != b->vfs->len)
return FALSE;
for (i = 0; i < a->vfs->len; i++) {
if (!nm_sriov_vf_equal(a->vfs->pdata[i], b->vfs->pdata[i]))
return FALSE;
}
}
return TRUE;
}
return NM_SETTING_CLASS(nm_setting_sriov_parent_class)
->compare_property(sett_info, property_idx, con_a, set_a, con_b, set_b, flags);
}
/*****************************************************************************/
static void
get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
NMSettingSriov *self = NM_SETTING_SRIOV(object);
switch (prop_id) {
case PROP_TOTAL_VFS:
g_value_set_uint(value, self->total_vfs);
break;
case PROP_VFS:
g_value_take_boxed(value,
_nm_utils_copy_array(self->vfs,
(NMUtilsCopyFunc) nm_sriov_vf_dup,
(GDestroyNotify) nm_sriov_vf_unref));
break;
case PROP_AUTOPROBE_DRIVERS:
g_value_set_enum(value, self->autoprobe_drivers);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
}
}
static void
set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
{
NMSettingSriov *self = NM_SETTING_SRIOV(object);
switch (prop_id) {
case PROP_TOTAL_VFS:
self->total_vfs = g_value_get_uint(value);
break;
case PROP_VFS:
g_ptr_array_unref(self->vfs);
self->vfs = _nm_utils_copy_array(g_value_get_boxed(value),
(NMUtilsCopyFunc) nm_sriov_vf_dup,
(GDestroyNotify) nm_sriov_vf_unref);
break;
case PROP_AUTOPROBE_DRIVERS:
self->autoprobe_drivers = g_value_get_enum(value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
}
}
/*****************************************************************************/
static void
nm_setting_sriov_init(NMSettingSriov *setting)
{
setting->vfs = g_ptr_array_new_with_free_func((GDestroyNotify) nm_sriov_vf_unref);
setting->autoprobe_drivers = NM_TERNARY_DEFAULT;
}
/**
* nm_setting_sriov_new:
*
* Creates a new #NMSettingSriov object with default values.
*
* Returns: (transfer full): the new empty #NMSettingSriov object
*
* Since: 1.14
**/
NMSetting *
nm_setting_sriov_new(void)
{
return g_object_new(NM_TYPE_SETTING_SRIOV, NULL);
}
static void
finalize(GObject *object)
{
NMSettingSriov *self = NM_SETTING_SRIOV(object);
g_ptr_array_unref(self->vfs);
G_OBJECT_CLASS(nm_setting_sriov_parent_class)->finalize(object);
}
static void
nm_setting_sriov_class_init(NMSettingSriovClass *klass)
{
GObjectClass * object_class = G_OBJECT_CLASS(klass);
NMSettingClass *setting_class = NM_SETTING_CLASS(klass);
GArray * properties_override = _nm_sett_info_property_override_create_array();
object_class->get_property = get_property;
object_class->set_property = set_property;
object_class->finalize = finalize;
setting_class->compare_property = compare_property;
setting_class->verify = verify;
/**
* NMSettingSriov:total-vfs
*
* The total number of virtual functions to create.
*
* Note that when the sriov setting is present NetworkManager
* enforces the number of virtual functions on the interface
* (also when it is zero) during activation and resets it
* upon deactivation. To prevent any changes to SR-IOV
* parameters don't add a sriov setting to the connection.
*
* Since: 1.14
**/
/* ---ifcfg-rh---
* property: total-vfs
* variable: SRIOV_TOTAL_VFS(+)
* description: The total number of virtual functions to create
* example: SRIOV_TOTAL_VFS=16
* ---end---
*/
obj_properties[PROP_TOTAL_VFS] = g_param_spec_uint(
NM_SETTING_SRIOV_TOTAL_VFS,
"",
"",
0,
G_MAXUINT32,
0,
NM_SETTING_PARAM_FUZZY_IGNORE | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
/**
* NMSettingSriov:vfs: (type GPtrArray(NMSriovVF))
*
* Array of virtual function descriptors.
*
* Each VF descriptor is a dictionary mapping attribute names
* to GVariant values. The 'index' entry is mandatory for
* each VF.
*
* When represented as string a VF is in the form:
*
* "INDEX [ATTR=VALUE[ ATTR=VALUE]...]".
*
* for example:
*
* "2 mac=00:11:22:33:44:55 spoof-check=true".
*
* Multiple VFs can be specified using a comma as separator.
* Currently, the following attributes are supported: mac,
* spoof-check, trust, min-tx-rate, max-tx-rate, vlans.
*
* The "vlans" attribute is represented as a semicolon-separated
* list of VLAN descriptors, where each descriptor has the form
*
* "ID[.PRIORITY[.PROTO]]".
*
* PROTO can be either 'q' for 802.1Q (the default) or 'ad' for
* 802.1ad.
*
* Since: 1.14
**/
/* ---ifcfg-rh---
* property: vfs
* variable: SRIOV_VF1(+), SRIOV_VF2(+), ...
* description: SR-IOV virtual function descriptors
* example: SRIOV_VF10="mac=00:11:22:33:44:55", ...
* ---end---
*/
obj_properties[PROP_VFS] = g_param_spec_boxed(NM_SETTING_SRIOV_VFS,
"",
"",
G_TYPE_PTR_ARRAY,
G_PARAM_READWRITE | NM_SETTING_PARAM_INFERRABLE
| G_PARAM_STATIC_STRINGS);
_nm_properties_override_gobj(properties_override,
obj_properties[PROP_VFS],
NM_SETT_INFO_PROPERT_TYPE(.dbus_type = NM_G_VARIANT_TYPE("aa{sv}"),
.to_dbus_fcn = vfs_to_dbus,
.from_dbus_fcn = vfs_from_dbus, ));
/**
* NMSettingSriov:autoprobe-drivers
*
* Whether to autoprobe virtual functions by a compatible driver.
*
* If set to %NM_TERNARY_TRUE, the kernel will try to bind VFs to
* a compatible driver and if this succeeds a new network
* interface will be instantiated for each VF.
*
* If set to %NM_TERNARY_FALSE, VFs will not be claimed and no
* network interfaces will be created for them.
*
* When set to %NM_TERNARY_DEFAULT, the global default is used; in
* case the global default is unspecified it is assumed to be
* %NM_TERNARY_TRUE.
*
* Since: 1.14
**/
/* ---ifcfg-rh---
* property: autoprobe-drivers
* variable: SRIOV_AUTOPROBE_DRIVERS(+)
* default: missing variable means global default
* description: Whether to autoprobe virtual functions by a compatible driver
* example: SRIOV_AUTOPROBE_DRIVERS=0,1
* ---end---
*/
obj_properties[PROP_AUTOPROBE_DRIVERS] = g_param_spec_enum(
NM_SETTING_SRIOV_AUTOPROBE_DRIVERS,
"",
"",
NM_TYPE_TERNARY,
NM_TERNARY_DEFAULT,
NM_SETTING_PARAM_FUZZY_IGNORE | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
g_object_class_install_properties(object_class, _PROPERTY_ENUMS_LAST, obj_properties);
_nm_setting_class_commit_full(setting_class,
NM_META_SETTING_TYPE_SRIOV,
NULL,
properties_override);
}
Reference in New Issue View Git Blame Copy Permalink