system/NetworkManager
system/NetworkManager
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/NetworkManager/NetworkManager synced 2024-07-21 18:24:49 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
NetworkManager/libnm-core/nm-setting-sriov.c
Thomas Haller 1cab6367b2 libnm: don't have G_PARAM_CONSTRUCT properties in NMSetting instances 
G_PARAM_CONSTRUCT cause to explicitly initialize the property during
object construction. This is an unnecessary overhead that we can easily
avoid.

The overhead is because G_PARAM_CONSTRUCT parameters are always set with
g_object_set() before calling constructed(). Even if they are not specified
during g_object_new(), in which case it calls set with the property's default
value. This also requires g_object_new() to iterate all properties to
find and sort the construct properties.

NMSetting are supposed to be simple classes. They don't need to have
their properties initialized before object construction completes.
Especially if the default values are NULL or zero, in which case there
is nothing to do. If the default value is not NULL or zero, we need
to initialize the field instead in the nm_setting*_init() function.
2019-12-24 07:47:50 +01:00

1381 lines
35 KiB
C
Raw Blame History

// SPDX-License-Identifier: LGPL-2.1+
/*
* Copyright (C) 2018 Red Hat, Inc.
*/
#include "nm-default.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);
g_clear_pointer (&vf->vlan_ids, g_free);
}
/**
* 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;
g_clear_pointer (&vf->vlan_ids, g_free);
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 gint
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 (NMSetting *) 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. 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 a new issue View git blame Copy permalink