fdo-mirrors/NetworkManager
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/NetworkManager/NetworkManager.git synced 2026-05-03 07:48:03 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

core: merge branch 'lr/default-unmanaged-bgo746566' (part 3)

Browse source 
Merge some trivial changes early to prepare for later changes.
This commit is contained in:
Thomas Haller 2015-12-04 15:47:02 +01:00
commit 7a4b88d3e4
7 changed files with 113 additions and 107 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/devices/bluetooth/nm-device-bt.c
View file

@ -458,7 +458,7 @@ modem_prepare_result (NMModem *modem,
* the device to be auto-activated anymore, which would risk locking
* the SIM if the incorrect PIN continues to be used.
*/
g_object_set (G_OBJECT (device), NM_DEVICE_AUTOCONNECT, FALSE, NULL);
nm_device_set_autoconnect (device, FALSE);
_LOGI (LOGD_MB, "disabling autoconnect due to failed SIM PIN");
}

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

@ -138,7 +138,7 @@ constructor (GType type,
n_construct_params,
construct_params);
nm_device_set_unmanaged_initial (NM_DEVICE (object), NM_UNMANAGED_DEFAULT, TRUE);
nm_device_set_unmanaged_flags_initial (NM_DEVICE (object), NM_UNMANAGED_DEFAULT, TRUE);
return object;
}

10
src/devices/nm-device-vlan.c
View file

@ -77,7 +77,7 @@ parent_state_changed (NMDevice *parent,
if (reason == NM_DEVICE_STATE_REASON_CARRIER)
return;
nm_device_set_unmanaged (NM_DEVICE (self), NM_UNMANAGED_PARENT, !nm_device_get_managed (parent), reason);
nm_device_set_unmanaged_flags (NM_DEVICE (self), NM_UNMANAGED_PARENT, !nm_device_get_managed (parent), reason);
}
static void
@ -134,10 +134,10 @@ nm_device_vlan_set_parent (NMDeviceVlan *self, NMDevice *parent)
G_CALLBACK (parent_hwaddr_changed), device);
/* Set parent-dependent unmanaged flag */
nm_device_set_unmanaged (device,
NM_UNMANAGED_PARENT,
!nm_device_get_managed (parent),
NM_DEVICE_STATE_REASON_PARENT_MANAGED_CHANGED);
nm_device_set_unmanaged_flags (device,
NM_UNMANAGED_PARENT,
!nm_device_get_managed (parent),
NM_DEVICE_STATE_REASON_PARENT_MANAGED_CHANGED);
}
/* Recheck availability now that the parent has changed */

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

@ -1174,7 +1174,7 @@ nm_device_finish_init (NMDevice *self)
&& priv->ifindex > 0
&& ( !priv->up
|| !priv->platform_link_initialized))
nm_device_set_unmanaged_initial (self, NM_UNMANAGED_EXTERNAL_DOWN, TRUE);
nm_device_set_unmanaged_flags_initial (self, NM_UNMANAGED_EXTERNAL_DOWN, TRUE);
if (priv->master)
nm_device_enslave_slave (priv->master, self, NULL);
@ -1184,19 +1184,19 @@ nm_device_finish_init (NMDevice *self)
/* Unmanaged the loopback device with an explicit NM_UNMANAGED_LOOPBACK flag.
* Later we might want to manage 'lo' too. Currently that doesn't work because
* NetworkManager might down the interface or remove the 127.0.0.1 address. */
nm_device_set_unmanaged_initial (self, NM_UNMANAGED_LOOPBACK, TRUE);
nm_device_set_unmanaged_flags_initial (self, NM_UNMANAGED_LOOPBACK, TRUE);
} else if (priv->platform_link_initialized || (priv->is_nm_owned && nm_device_is_software (self))) {
gboolean platform_unmanaged = FALSE;
if (nm_platform_link_get_unmanaged (NM_PLATFORM_GET, priv->ifindex, &platform_unmanaged))
nm_device_set_unmanaged_initial (self, NM_UNMANAGED_DEFAULT, platform_unmanaged);
nm_device_set_unmanaged_flags_initial (self, NM_UNMANAGED_DEFAULT, platform_unmanaged);
} else {
/* Hardware and externally-created software links stay unmanaged
* until they are fully initialized by the platform. NM created
* links must be available for activation immediately and thus
* do not get the PLATFORM_INIT unmanaged flag set.
*/
nm_device_set_unmanaged_initial (self, NM_UNMANAGED_PLATFORM_INIT, TRUE);
nm_device_set_unmanaged_flags_initial (self, NM_UNMANAGED_PLATFORM_INIT, TRUE);
}
}
@ -1503,16 +1503,16 @@ device_link_changed (NMDevice *self)
priv->platform_link_initialized = TRUE;
if (nm_platform_link_get_unmanaged (NM_PLATFORM_GET, priv->ifindex, &platform_unmanaged)) {
nm_device_set_unmanaged (self,
NM_UNMANAGED_DEFAULT,
platform_unmanaged,
NM_DEVICE_STATE_REASON_USER_REQUESTED);
nm_device_set_unmanaged_flags (self,
NM_UNMANAGED_DEFAULT,
platform_unmanaged,
NM_DEVICE_STATE_REASON_USER_REQUESTED);
}
nm_device_set_unmanaged (self,
NM_UNMANAGED_PLATFORM_INIT,
FALSE,
NM_DEVICE_STATE_REASON_NOW_MANAGED);
nm_device_set_unmanaged_flags (self,
NM_UNMANAGED_PLATFORM_INIT,
FALSE,
NM_DEVICE_STATE_REASON_NOW_MANAGED);
emit_link_initialized = TRUE;
}
@ -1526,7 +1526,7 @@ device_link_changed (NMDevice *self)
/* Manage externally-created software interfaces only when they are IFF_UP */
g_assert (priv->ifindex > 0);
if (NM_DEVICE_GET_CLASS (self)->can_unmanaged_external_down (self)) {
gboolean external_down = nm_device_get_unmanaged (self, NM_UNMANAGED_EXTERNAL_DOWN);
gboolean external_down = !!nm_device_get_unmanaged_flags (self, NM_UNMANAGED_EXTERNAL_DOWN);
if (external_down && NM_FLAGS_HAS (info.flags, IFF_UP)) {
if (nm_device_get_state (self) < NM_DEVICE_STATE_DISCONNECTED) {
@ -1540,10 +1540,10 @@ device_link_changed (NMDevice *self)
* the device before assumption occurs, pass
* NM_DEVICE_STATE_REASON_CONNECTION_ASSUMED as the reason.
*/
nm_device_set_unmanaged (self,
NM_UNMANAGED_EXTERNAL_DOWN,
FALSE,
NM_DEVICE_STATE_REASON_CONNECTION_ASSUMED);
nm_device_set_unmanaged_flags (self,
NM_UNMANAGED_EXTERNAL_DOWN,
FALSE,
NM_DEVICE_STATE_REASON_CONNECTION_ASSUMED);
} else {
/* Don't trigger a state change; if the device is in a
* state higher than UNAVAILABLE, it is already IFF_UP
@ -1555,10 +1555,10 @@ device_link_changed (NMDevice *self)
/* If the device is already disconnected and is set !IFF_UP,
* unmanage it.
*/
nm_device_set_unmanaged (self,
NM_UNMANAGED_EXTERNAL_DOWN,
TRUE,
NM_DEVICE_STATE_REASON_USER_REQUESTED);
nm_device_set_unmanaged_flags (self,
NM_UNMANAGED_EXTERNAL_DOWN,
TRUE,
NM_DEVICE_STATE_REASON_USER_REQUESTED);
}
}
}
@ -2524,7 +2524,7 @@ nm_device_get_autoconnect (NMDevice *self)
return NM_DEVICE_GET_PRIVATE (self)->autoconnect;
}
static void
void
nm_device_set_autoconnect (NMDevice *self, gboolean autoconnect)
{
NMDevicePrivate *priv;
@ -8258,15 +8258,16 @@ nm_device_get_managed (NMDevice *self)
}
/**
* nm_device_get_unmanaged():
* nm_device_get_unmanaged_flags():
* @self: the #NMDevice
* @flag: return only the selected flags
*
* Returns: %TRUE if the device is unmanaged for @flag.
* Returns: the unmanage flags of the device (filtered with @flag)
*/
gboolean
nm_device_get_unmanaged (NMDevice *self, NMUnmanagedFlags flag)
NMUnmanagedFlags
nm_device_get_unmanaged_flags (NMDevice *self, NMUnmanagedFlags flag)
{
return NM_FLAGS_ANY (NM_DEVICE_GET_PRIVATE (self)->unmanaged_flags, flag);
return NM_DEVICE_GET_PRIVATE (self)->unmanaged_flags & flag;
}
/**
@ -8278,7 +8279,7 @@ nm_device_get_unmanaged (NMDevice *self, NMUnmanagedFlags flag)
static gboolean
nm_device_get_default_unmanaged (NMDevice *self)
{
return nm_device_get_unmanaged (self, NM_UNMANAGED_DEFAULT);
return !!nm_device_get_unmanaged_flags (self, NM_UNMANAGED_DEFAULT);
}
static void
@ -8310,10 +8311,10 @@ _set_unmanaged_flags (NMDevice *self,
}
void
nm_device_set_unmanaged (NMDevice *self,
NMUnmanagedFlags flag,
gboolean unmanaged,
NMDeviceStateReason reason)
nm_device_set_unmanaged_flags (NMDevice *self,
NMUnmanagedFlags flag,
gboolean unmanaged,
NMDeviceStateReason reason)
{
NMDevicePrivate *priv;
gboolean was_managed, now_managed;
@ -8340,7 +8341,7 @@ nm_device_set_unmanaged (NMDevice *self,
}
void
nm_device_set_unmanaged_by_device_spec (NMDevice *self, const GSList *unmanaged_specs)
nm_device_set_unmanaged_flags_by_device_spec (NMDevice *self, const GSList *unmanaged_specs)
{
NMDevicePrivate *priv;
gboolean unmanaged;
@ -8353,43 +8354,28 @@ nm_device_set_unmanaged_by_device_spec (NMDevice *self, const GSList *unmanaged_
return;
unmanaged = nm_device_spec_match_list (self, unmanaged_specs);
nm_device_set_unmanaged (self,
NM_UNMANAGED_USER,
unmanaged,
unmanaged
? NM_DEVICE_STATE_REASON_NOW_UNMANAGED
: NM_DEVICE_STATE_REASON_NOW_MANAGED);
}
void
nm_device_set_unmanaged_quitting (NMDevice *self)
{
NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE (self);
/* It's OK to block here because we're quitting */
if (nm_device_is_activating (self) || priv->state == NM_DEVICE_STATE_ACTIVATED)
_set_state_full (self, NM_DEVICE_STATE_DEACTIVATING, NM_DEVICE_STATE_REASON_NOW_UNMANAGED, TRUE);
nm_device_set_unmanaged (self,
NM_UNMANAGED_INTERNAL,
TRUE,
NM_DEVICE_STATE_REASON_NOW_UNMANAGED);
nm_device_set_unmanaged_flags (self,
NM_UNMANAGED_USER,
unmanaged,
unmanaged
? NM_DEVICE_STATE_REASON_NOW_UNMANAGED
: NM_DEVICE_STATE_REASON_NOW_MANAGED);
}
/**
* nm_device_set_unmanaged_initial():
* nm_device_set_unmanaged_flags_initial():
* @self: 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
* Like nm_device_set_unmanaged_flags(), but must be set before the device is
* initialized by nm_device_finish_init(), and does not trigger state changes.
* Should only be used when initializing a device.
*/
void
nm_device_set_unmanaged_initial (NMDevice *self,
NMUnmanagedFlags flag,
gboolean unmanaged)
nm_device_set_unmanaged_flags_initial (NMDevice *self,
NMUnmanagedFlags flag,
gboolean unmanaged)
{
NMDevicePrivate *priv;
@ -8402,6 +8388,23 @@ nm_device_set_unmanaged_initial (NMDevice *self,
_set_unmanaged_flags (self, flag, unmanaged);
}
void
nm_device_set_unmanaged_quitting (NMDevice *self)
{
NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE (self);
/* It's OK to block here because we're quitting */
if (nm_device_is_activating (self) || priv->state == NM_DEVICE_STATE_ACTIVATED)
_set_state_full (self, NM_DEVICE_STATE_DEACTIVATING, NM_DEVICE_STATE_REASON_NOW_UNMANAGED, TRUE);
nm_device_set_unmanaged_flags (self,
NM_UNMANAGED_INTERNAL,
TRUE,
NM_DEVICE_STATE_REASON_NOW_UNMANAGED);
}
/*****************************************************************************/
void
nm_device_set_dhcp_timeout (NMDevice *self, guint32 timeout)
{
@ -8566,7 +8569,7 @@ _nm_device_check_connection_available (NMDevice *self,
if (state < NM_DEVICE_STATE_UNMANAGED)
return FALSE;
if ( state < NM_DEVICE_STATE_UNAVAILABLE
&& nm_device_get_unmanaged (self, NM_UNMANAGED_ALL & ~NM_UNMANAGED_DEFAULT))
&& nm_device_get_unmanaged_flags (self, NM_UNMANAGED_ALL & ~NM_UNMANAGED_DEFAULT))
return FALSE;
if ( state < NM_DEVICE_STATE_DISCONNECTED
&& !nm_device_is_software (self)
@ -10212,10 +10215,10 @@ set_property (GObject *object, guint prop_id,
case PROP_MANAGED:
val_bool = g_value_get_boolean (value);
priv->managed_touched_by_user = TRUE;
nm_device_set_unmanaged (self,
NM_UNMANAGED_USER | (val_bool ? NM_UNMANAGED_DEFAULT : NM_UNMANAGED_NONE),
!val_bool,
NM_DEVICE_STATE_REASON_USER_REQUESTED);
nm_device_set_unmanaged_flags (self,
NM_UNMANAGED_USER | (val_bool ? NM_UNMANAGED_DEFAULT : NM_UNMANAGED_NONE),
!val_bool,
NM_DEVICE_STATE_REASON_USER_REQUESTED);
break;
case PROP_AUTOCONNECT:
nm_device_set_autoconnect (self, g_value_get_boolean (value));

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

@ -444,25 +444,27 @@ 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)
* @NM_UNMANAGED_PARENT: %TRUE when unmanaged due to parent device being unmanaged
* @NM_UNMANAGED_EXTERNAL_DOWN: %TRUE when unmanaged because !IFF_UP and not created by NM
* @NM_UNMANAGED_LOOPBACK: %TRUE for unmanaging loopback device
* @NM_UNMANAGED_PLATFORM_INIT: %TRUE when unmanaged because platform link not
* yet initialized
* @NM_UNMANAGED_LOOPBACK: %TRUE for unmanaging loopback device
* @NM_UNMANAGED_USER: %TRUE when unmanaged by user decision (via unmanaged-specs)
* @NM_UNMANAGED_DEFAULT: %TRUE when unmanaged by default (ie, Generic devices)
* @NM_UNMANAGED_EXTERNAL_DOWN: %TRUE when unmanaged because !IFF_UP and not created by NM
*/
typedef enum {
typedef enum { /*< skip >*/
NM_UNMANAGED_NONE = 0,
NM_UNMANAGED_DEFAULT = (1LL << 0),
NM_UNMANAGED_INTERNAL = (1LL << 1),
NM_UNMANAGED_USER = (1LL << 2),
NM_UNMANAGED_PARENT = (1LL << 3),
NM_UNMANAGED_EXTERNAL_DOWN = (1LL << 4),
NM_UNMANAGED_PLATFORM_INIT = (1LL << 5),
NM_UNMANAGED_LOOPBACK = (1LL << 6),
NM_UNMANAGED_INTERNAL = (1LL << 0),
NM_UNMANAGED_PARENT = (1LL << 1),
NM_UNMANAGED_LOOPBACK = (1LL << 2),
NM_UNMANAGED_PLATFORM_INIT = (1LL << 3),
NM_UNMANAGED_USER = (1LL << 4),
NM_UNMANAGED_DEFAULT = (1LL << 8),
NM_UNMANAGED_EXTERNAL_DOWN = (1LL << 11),
/* Boundary value */
__NM_UNMANAGED_LAST,
@ -471,16 +473,16 @@ typedef enum {
} NMUnmanagedFlags;
gboolean nm_device_get_managed (NMDevice *device);
gboolean nm_device_get_unmanaged (NMDevice *device, NMUnmanagedFlags flag);
void nm_device_set_unmanaged (NMDevice *device,
NMUnmanagedFlags flag,
gboolean unmanaged,
NMDeviceStateReason reason);
void nm_device_set_unmanaged_by_device_spec (NMDevice *self, const GSList *unmanaged_specs);
NMUnmanagedFlags nm_device_get_unmanaged_flags (NMDevice *device, NMUnmanagedFlags flag);
void nm_device_set_unmanaged_flags (NMDevice *device,
NMUnmanagedFlags flag,
gboolean unmanaged,
NMDeviceStateReason reason);
void nm_device_set_unmanaged_flags_by_device_spec (NMDevice *self, const GSList *unmanaged_specs);
void nm_device_set_unmanaged_flags_initial (NMDevice *device,
NMUnmanagedFlags flag,
gboolean unmanaged);
void nm_device_set_unmanaged_quitting (NMDevice *device);
void nm_device_set_unmanaged_initial (NMDevice *device,
NMUnmanagedFlags flag,
gboolean unmanaged);
gboolean nm_device_get_is_nm_owned (NMDevice *device);
@ -501,6 +503,7 @@ gboolean nm_device_unrealize (NMDevice *device,
GError **error);
gboolean nm_device_get_autoconnect (NMDevice *device);
void nm_device_set_autoconnect (NMDevice *device, gboolean autoconnect);
void nm_device_state_changed (NMDevice *device,
NMDeviceState state,

2
src/devices/wwan/nm-device-modem.c
View file

@ -106,7 +106,7 @@ modem_prepare_result (NMModem *modem,
* the device to be auto-activated anymore, which would risk locking
* the SIM if the incorrect PIN continues to be used.
*/
g_object_set (G_OBJECT (device), NM_DEVICE_AUTOCONNECT, FALSE, NULL);
nm_device_set_autoconnect (device, FALSE);
_LOGI (LOGD_MB, "disabling autoconnect due to failed SIM PIN");
}

28
src/nm-manager.c
View file

@ -829,7 +829,7 @@ remove_device (NMManager *manager,
if (quitting)
nm_device_set_unmanaged_quitting (device);
else
nm_device_set_unmanaged (device, NM_UNMANAGED_INTERNAL, TRUE, NM_DEVICE_STATE_REASON_REMOVED);
nm_device_set_unmanaged_flags (device, NM_UNMANAGED_INTERNAL, TRUE, NM_DEVICE_STATE_REASON_REMOVED);
} else if (quitting && nm_config_get_configure_and_quit (nm_config_get ())) {
nm_device_spawn_iface_helper (device);
}
@ -1128,7 +1128,7 @@ 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))
nm_device_set_unmanaged_by_device_spec (NM_DEVICE (iter->data), unmanaged_specs);
nm_device_set_unmanaged_flags_by_device_spec (NM_DEVICE (iter->data), unmanaged_specs);
}
static void
@ -1623,7 +1623,7 @@ can_start_device (NMManager *self, NMDevice *device)
{
return nm_device_is_real (device)
&& !manager_sleeping (self)
&& !nm_device_get_unmanaged (device, NM_UNMANAGED_ALL & ~NM_UNMANAGED_DEFAULT);
&& !nm_device_get_unmanaged_flags (device, NM_UNMANAGED_ALL & ~NM_UNMANAGED_DEFAULT);
}
static gboolean
@ -1665,7 +1665,7 @@ recheck_assume_connection (NMDevice *device, gpointer user_data)
NM_DEVICE_STATE_REASON_CONFIG_FAILED);
/* Return default-unmanaged devices to their original state */
if (nm_device_get_unmanaged (device, NM_UNMANAGED_DEFAULT)) {
if (nm_device_get_unmanaged_flags (device, NM_UNMANAGED_DEFAULT)) {
nm_device_state_changed (device,
NM_DEVICE_STATE_UNMANAGED,
NM_DEVICE_STATE_REASON_CONFIG_FAILED);
@ -1832,12 +1832,12 @@ add_device (NMManager *self, NMDevice *device)
nm_log_info (LOGD_HW, "(%s): new %s device", iface, type_desc);
unmanaged_specs = nm_settings_get_unmanaged_specs (priv->settings);
nm_device_set_unmanaged_initial (device,
NM_UNMANAGED_USER,
nm_device_spec_match_list (device, unmanaged_specs));
nm_device_set_unmanaged_initial (device,
NM_UNMANAGED_INTERNAL,
manager_sleeping (self));
nm_device_set_unmanaged_flags_initial (device,
NM_UNMANAGED_USER,
nm_device_spec_match_list (device, unmanaged_specs));
nm_device_set_unmanaged_flags_initial (device,
NM_UNMANAGED_INTERNAL,
manager_sleeping (self));
dbus_path = nm_exported_object_export (NM_EXPORTED_OBJECT (device));
nm_log_dbg (LOGD_DEVICE, "(%s): exported as %s", nm_device_get_iface (device), dbus_path);
@ -3746,7 +3746,7 @@ do_sleep_wake (NMManager *self, gboolean sleeping_changed)
if (suspending && device_is_wake_on_lan (device))
continue;
nm_device_set_unmanaged (device, NM_UNMANAGED_INTERNAL, TRUE, NM_DEVICE_STATE_REASON_SLEEPING);
nm_device_set_unmanaged_flags (device, NM_UNMANAGED_INTERNAL, TRUE, NM_DEVICE_STATE_REASON_SLEEPING);
}
} else {
nm_log_info (LOGD_SUSPEND, "%s...", waking_from_suspend ? "waking up" : "re-enabling");
@ -3761,7 +3761,7 @@ do_sleep_wake (NMManager *self, gboolean sleeping_changed)
if (nm_device_is_software (device))
continue;
if (device_is_wake_on_lan (device))
nm_device_set_unmanaged (device, NM_UNMANAGED_INTERNAL, TRUE, NM_DEVICE_STATE_REASON_SLEEPING);
nm_device_set_unmanaged_flags (device, NM_UNMANAGED_INTERNAL, TRUE, NM_DEVICE_STATE_REASON_SLEEPING);
}
}
@ -3795,9 +3795,9 @@ do_sleep_wake (NMManager *self, gboolean sleeping_changed)
nm_device_set_enabled (device, enabled);
}
g_object_set (G_OBJECT (device), NM_DEVICE_AUTOCONNECT, TRUE, NULL);
nm_device_set_autoconnect (device, TRUE);
nm_device_set_unmanaged (device, NM_UNMANAGED_INTERNAL, FALSE, NM_DEVICE_STATE_REASON_NOW_MANAGED);
nm_device_set_unmanaged_flags (device, NM_UNMANAGED_INTERNAL, FALSE, NM_DEVICE_STATE_REASON_NOW_MANAGED);
}
}