fdo-mirrors/NetworkManager
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/NetworkManager/NetworkManager.git synced 2025-12-25 03:40:07 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

merge: rework unmanaged options into flags (rh #1030947)

Browse source 
Instead of having separate booleans for each unmanaged option, make them
a single flags variable instead.  Also split out user-unmanaged from
internal management like suspend/resume so we can control them separately.
This commit is contained in:
Dan Williams 2014-04-07 09:52:20 -05:00
commit b703b14a6a
4 changed files with 142 additions and 74 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/devices/nm-device-generic.c
View file

@ -127,7 +127,7 @@ nm_device_generic_new (NMPlatformLink *platform_device)
static void
nm_device_generic_init (NMDeviceGeneric *self)
{
nm_device_set_default_unmanaged (NM_DEVICE (self), TRUE);
nm_device_set_initial_unmanaged_flag (NM_DEVICE (self), NM_UNMANAGED_DEFAULT, TRUE);
}
static void

128
src/devices/nm-device.c
View file

@ -221,9 +221,8 @@ typedef struct {
guint hw_addr_len;
char * physical_port_id;
gboolean manager_managed; /* whether managed by NMManager or not */
gboolean default_unmanaged; /* whether unmanaged by default */
gboolean is_nm_owned; /* whether the device is a device owned and created by NM */
NMUnmanagedFlags unmanaged_flags;
gboolean is_nm_owned; /* whether the device is a device owned and created by NM */
DeleteOnDeactivateData *delete_on_deactivate_data; /* data for scheduled cleanup when deleting link (g_idle_add) */
guint32 ip4_address;
@ -5038,7 +5037,7 @@ _device_activate (NMDevice *self, NMActRequest *req)
delete_on_deactivate_unschedule (self);
/* Move default unmanaged devices to DISCONNECTED state here */
if (priv->default_unmanaged && priv->state == NM_DEVICE_STATE_UNMANAGED) {
if (nm_device_get_default_unmanaged (self) && priv->state == NM_DEVICE_STATE_UNMANAGED) {
nm_device_state_changed (self,
NM_DEVICE_STATE_DISCONNECTED,
NM_DEVICE_STATE_REASON_NOW_MANAGED);
@ -6715,7 +6714,8 @@ nm_device_state_changed (NMDevice *device,
if (old_state == NM_DEVICE_STATE_UNMANAGED) {
nm_log_dbg (LOGD_DEVICE, "(%s): device not yet available for transition to DISCONNECTED",
nm_device_get_iface (device));
} else if (old_state > NM_DEVICE_STATE_UNAVAILABLE && priv->default_unmanaged)
} else if ( old_state > NM_DEVICE_STATE_UNAVAILABLE
&& nm_device_get_default_unmanaged (device))
nm_device_queue_state (device, NM_DEVICE_STATE_UNMANAGED, NM_DEVICE_STATE_REASON_NONE);
}
break;
@ -6730,7 +6730,8 @@ nm_device_state_changed (NMDevice *device,
priv->queued_act_request = NULL;
_device_activate (device, queued_req);
g_object_unref (queued_req);
} else if (old_state > NM_DEVICE_STATE_DISCONNECTED && priv->default_unmanaged)
} else if ( old_state > NM_DEVICE_STATE_DISCONNECTED
&& nm_device_get_default_unmanaged (device))
nm_device_queue_state (device, NM_DEVICE_STATE_UNMANAGED, NM_DEVICE_STATE_REASON_NONE);
break;
case NM_DEVICE_STATE_ACTIVATED:
@ -7115,79 +7116,120 @@ nm_device_queued_ip_config_change_clear (NMDevice *self)
}
}
/**
* nm_device_get_managed():
* @device: the #NMDevice
*
* Returns: %TRUE if the device is managed
*/
gboolean
nm_device_get_managed (NMDevice *device)
{
NMDevicePrivate *priv;
gboolean managed;
g_return_val_if_fail (NM_IS_DEVICE (device), FALSE);
priv = NM_DEVICE_GET_PRIVATE (device);
if (!priv->manager_managed)
return FALSE;
else if (priv->default_unmanaged)
return (priv->state != NM_DEVICE_STATE_UNMANAGED);
else
return TRUE;
/* Return the composite of all managed flags. However, if the device
* is a default-unmanaged device, and would be managed except for the
* default-unmanaged flag (eg, only NM_UNMANAGED_DEFAULT is set) then
* the device is managed whenever it's not in the UNMANAGED state.
*/
managed = !(priv->unmanaged_flags & ~NM_UNMANAGED_DEFAULT);
if (managed && (priv->unmanaged_flags & NM_UNMANAGED_DEFAULT))
managed = (priv->state != NM_DEVICE_STATE_UNMANAGED);
return managed;
}
static void
nm_device_set_managed_internal (NMDevice *device,
gboolean managed,
NMDeviceStateReason reason)
/**
* nm_device_get_default_unmanaged():
* @device: the #NMDevice
*
* Returns: %TRUE if the device is by default unmanaged
*/
gboolean
nm_device_get_default_unmanaged (NMDevice *device)
{
nm_log_dbg (LOGD_DEVICE, "(%s): now %s",
nm_device_get_iface (device),
managed ? "managed" : "unmanaged");
return nm_device_get_unmanaged_flag (device, NM_UNMANAGED_DEFAULT);
}
g_object_notify (G_OBJECT (device), NM_DEVICE_MANAGED);
if (managed)
nm_device_state_changed (device, NM_DEVICE_STATE_UNAVAILABLE, reason);
else
nm_device_state_changed (device, NM_DEVICE_STATE_UNMANAGED, reason);
/**
* nm_device_get_unmanaged_flag():
* @device: the #NMDevice
*
* Returns: %TRUE if the device is unmanaged for @flag.
*/
gboolean
nm_device_get_unmanaged_flag (NMDevice *device, NMUnmanagedFlags flag)
{
return NM_DEVICE_GET_PRIVATE (device)->unmanaged_flags & flag;
}
void
nm_device_set_manager_managed (NMDevice *device,
gboolean managed,
NMDeviceStateReason reason)
nm_device_set_unmanaged (NMDevice *device,
NMUnmanagedFlags flag,
gboolean unmanaged,
NMDeviceStateReason reason)
{
NMDevicePrivate *priv;
gboolean was_managed, now_managed;
g_return_if_fail (NM_IS_DEVICE (device));
g_return_if_fail (flag <= NM_UNMANAGED_LAST);
priv = NM_DEVICE_GET_PRIVATE (device);
was_managed = nm_device_get_managed (device);
priv->manager_managed = managed;
if (unmanaged)
priv->unmanaged_flags |= flag;
else
priv->unmanaged_flags &= ~flag;
now_managed = nm_device_get_managed (device);
if (was_managed != now_managed)
nm_device_set_managed_internal (device, now_managed, reason);
if (was_managed != now_managed) {
nm_log_dbg (LOGD_DEVICE, "(%s): now %s",
nm_device_get_iface (device),
unmanaged ? "unmanaged" : "managed");
g_object_notify (G_OBJECT (device), NM_DEVICE_MANAGED);
if (unmanaged)
nm_device_state_changed (device, NM_DEVICE_STATE_UNMANAGED, reason);
else
nm_device_state_changed (device, NM_DEVICE_STATE_UNAVAILABLE, reason);
}
}
/**
* nm_device_set_initial_unmanaged_flag():
* @device: the #NMDevice
* @flag: an #NMUnmanagedFlag
* @unmanaged: %TRUE or %FALSE to set or clear @flag
*
* Like nm_device_set_unmanaged() but must be set before the device is exported
* and does not trigger state changes. Should only be used when initializing
* a device.
*/
void
nm_device_set_default_unmanaged (NMDevice *device,
gboolean default_unmanaged)
nm_device_set_initial_unmanaged_flag (NMDevice *device,
NMUnmanagedFlags flag,
gboolean unmanaged)
{
NMDevicePrivate *priv;
gboolean was_managed, now_managed;
g_return_if_fail (NM_IS_DEVICE (device));
g_return_if_fail (flag <= NM_UNMANAGED_LAST);
priv = NM_DEVICE_GET_PRIVATE (device);
g_return_if_fail (priv->path == NULL);
was_managed = nm_device_get_managed (device);
priv->default_unmanaged = default_unmanaged;
now_managed = nm_device_get_managed (device);
if (was_managed != now_managed)
nm_device_set_managed_internal (device, now_managed,
default_unmanaged ? NM_DEVICE_STATE_REASON_NOW_UNMANAGED :
NM_DEVICE_STATE_REASON_NOW_MANAGED);
if (unmanaged)
priv->unmanaged_flags |= flag;
else
priv->unmanaged_flags &= ~flag;
}
/**
@ -7301,7 +7343,7 @@ nm_device_connection_is_available (NMDevice *device,
NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE (device);
gboolean available = FALSE;
if (priv->default_unmanaged && (priv->state == NM_DEVICE_STATE_UNMANAGED)) {
if (nm_device_get_default_unmanaged (device) && (priv->state == NM_DEVICE_STATE_UNMANAGED)) {
/* default-unmanaged devices in UNMANAGED state have no available connections
* so we must manually check whether the connection is available here.
*/

33
src/devices/nm-device.h
View file

@ -295,12 +295,35 @@ void nm_device_set_enabled (NMDevice *device, gboolean enabled);
RfKillType nm_device_get_rfkill_type (NMDevice *device);
/**
* NMUnmanagedFlags:
* @NM_UNMANAGED_NONE: placeholder value
* @NM_UNMANAGED_DEFAULT: %TRUE when unmanaged by default (ie, Generic devices)
* @NM_UNMANAGED_INTERNAL: %TRUE when unmanaged by internal decision (ie,
* because NM is sleeping or not managed for some other reason)
* @NM_UNMANAGED_USER: %TRUE when unmanaged by user decision (via unmanaged-specs)
*/
typedef enum {
NM_UNMANAGED_NONE = 0x00,
NM_UNMANAGED_DEFAULT = 0x01,
NM_UNMANAGED_INTERNAL = 0x02,
NM_UNMANAGED_USER = 0x04,
/* Boundary value */
__NM_UNMANAGED_LAST,
NM_UNMANAGED_LAST = __NM_UNMANAGED_LAST - 1,
} NMUnmanagedFlags;
gboolean nm_device_get_managed (NMDevice *device);
void nm_device_set_manager_managed (NMDevice *device,
gboolean managed,
NMDeviceStateReason reason);
void nm_device_set_default_unmanaged (NMDevice *device,
gboolean default_unmanaged);
gboolean nm_device_get_default_unmanaged (NMDevice *device);
gboolean nm_device_get_unmanaged_flag (NMDevice *device, NMUnmanagedFlags flag);
void nm_device_set_unmanaged (NMDevice *device,
NMUnmanagedFlags flag,
gboolean unmanaged,
NMDeviceStateReason reason);
void nm_device_set_initial_unmanaged_flag (NMDevice *device,
NMUnmanagedFlags flag,
gboolean unmanaged);
gboolean nm_device_get_is_nm_owned (NMDevice *device);
gboolean nm_device_set_is_nm_owned (NMDevice *device,

53
src/nm-manager.c
View file

@ -758,7 +758,7 @@ remove_device (NMManager *manager, NMDevice *device, gboolean quitting)
NMActRequest *req = nm_device_get_act_request (device);
if (!req || !nm_active_connection_get_assumed (NM_ACTIVE_CONNECTION (req)))
nm_device_set_manager_managed (device, FALSE, NM_DEVICE_STATE_REASON_REMOVED);
nm_device_set_unmanaged (device, NM_UNMANAGED_INTERNAL, TRUE, NM_DEVICE_STATE_REASON_REMOVED);
}
}
@ -1199,13 +1199,14 @@ system_unmanaged_devices_changed_cb (NMSettings *settings,
unmanaged_specs = nm_settings_get_unmanaged_specs (priv->settings);
for (iter = priv->devices; iter; iter = g_slist_next (iter)) {
NMDevice *device = NM_DEVICE (iter->data);
gboolean managed;
gboolean unmanaged;
managed = !nm_device_spec_match_list (device, unmanaged_specs);
nm_device_set_manager_managed (device,
managed,
managed ? NM_DEVICE_STATE_REASON_NOW_MANAGED :
NM_DEVICE_STATE_REASON_NOW_UNMANAGED);
unmanaged = nm_device_spec_match_list (device, unmanaged_specs);
nm_device_set_unmanaged (device,
NM_UNMANAGED_USER,
unmanaged,
unmanaged ? NM_DEVICE_STATE_REASON_NOW_UNMANAGED :
NM_DEVICE_STATE_REASON_NOW_MANAGED);
}
}
@ -1751,6 +1752,7 @@ add_device (NMManager *self, NMDevice *device, gboolean generate_con)
char *path;
static guint32 devcount = 0;
const GSList *unmanaged_specs;
gboolean user_unmanaged, sleeping;
NMConnection *connection = NULL;
gboolean enabled = FALSE;
RfKillType rtype;
@ -1841,6 +1843,13 @@ add_device (NMManager *self, NMDevice *device, gboolean generate_con)
nm_log_info (LOGD_HW, "(%s): new %s device (driver: '%s' ifindex: %d)",
iface, type_desc, driver, nm_device_get_ifindex (device));
unmanaged_specs = nm_settings_get_unmanaged_specs (priv->settings);
user_unmanaged = nm_device_spec_match_list (device, unmanaged_specs);
nm_device_set_initial_unmanaged_flag (device, NM_UNMANAGED_USER, user_unmanaged);
sleeping = manager_sleeping (self);
nm_device_set_initial_unmanaged_flag (device, NM_UNMANAGED_INTERNAL, sleeping);
path = g_strdup_printf ("/org/freedesktop/NetworkManager/Devices/%d", devcount++);
nm_device_set_path (device, path);
nm_dbus_manager_register_object (priv->dbus_mgr, path, device);
@ -1848,18 +1857,18 @@ add_device (NMManager *self, NMDevice *device, gboolean generate_con)
g_free (path);
/* Don't generate a connection e.g. for devices NM just created, or
* for the loopback */
if (generate_con)
* for the loopback, or when we're sleeping. */
if (generate_con && !user_unmanaged && !sleeping)
connection = get_existing_connection (self, device);
/* Start the device if it's supposed to be managed */
unmanaged_specs = nm_settings_get_unmanaged_specs (priv->settings);
if ( !manager_sleeping (self)
&& !nm_device_spec_match_list (device, unmanaged_specs)) {
nm_device_set_manager_managed (device,
TRUE,
connection ? NM_DEVICE_STATE_REASON_CONNECTION_ASSUMED :
NM_DEVICE_STATE_REASON_NOW_MANAGED);
/* Start the device if it's supposed to be managed. Note that this will
* manage default-unmanaged devices if they have a generated connection.
*/
if (nm_device_get_managed (device) || connection) {
nm_device_state_changed (device,
NM_DEVICE_STATE_UNAVAILABLE,
connection ? NM_DEVICE_STATE_REASON_CONNECTION_ASSUMED :
NM_DEVICE_STATE_REASON_NOW_MANAGED);
}
nm_settings_device_added (priv->settings, device);
@ -3587,7 +3596,6 @@ static void
do_sleep_wake (NMManager *self)
{
NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
const GSList *unmanaged_specs;
GSList *iter;
if (manager_sleeping (self)) {
@ -3601,13 +3609,11 @@ do_sleep_wake (NMManager *self)
NMDevice *device = iter->data;
if (!nm_device_is_software (device))
nm_device_set_manager_managed (device, FALSE, NM_DEVICE_STATE_REASON_SLEEPING);
nm_device_set_unmanaged (device, NM_UNMANAGED_INTERNAL, TRUE, NM_DEVICE_STATE_REASON_SLEEPING);
}
} else {
nm_log_info (LOGD_SUSPEND, "waking up and re-enabling...");
unmanaged_specs = nm_settings_get_unmanaged_specs (priv->settings);
/* Ensure rfkill state is up-to-date since we don't respond to state
* changes during sleep.
*/
@ -3640,10 +3646,7 @@ do_sleep_wake (NMManager *self)
g_object_set (G_OBJECT (device), NM_DEVICE_AUTOCONNECT, TRUE, NULL);
if (nm_device_spec_match_list (device, unmanaged_specs))
nm_device_set_manager_managed (device, FALSE, NM_DEVICE_STATE_REASON_NOW_UNMANAGED);
else
nm_device_set_manager_managed (device, TRUE, NM_DEVICE_STATE_REASON_NOW_MANAGED);
nm_device_set_unmanaged (device, NM_UNMANAGED_INTERNAL, FALSE, NM_DEVICE_STATE_REASON_NOW_MANAGED);
}
}