colin/NetworkManager
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

core: rename sys-iface-state to managed-type internally

Browse Source 
The previous name was not very self explanatory. Managed type indicates
a bit better what the meaning is.
This commit is contained in:
Íñigo Huguet
2024-08-27 10:26:50 +02:00
committed by Fernando Fernandez Mancera
parent b2930f5361
commit 573c48d034
16 changed files with 176 additions and 179 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
docs/internal/device.md
View File

@@ -304,8 +304,8 @@ Note that the unmanaged flags are tracked via two variables
practice a tri-state variable with possible values TRUE (unmanaged),
FALSE (managed) and UNSET.
External devices and sys-iface-state
------------------------------------
External devices and managed-type
---------------------------------
Even if a device is managed, that doesn't mean that NetworkManager is
actively configuring it. When a device is created externally (for
@@ -314,7 +314,7 @@ creates a in-memory connection representing the configuration
parameters on the interface such as IP addresses, routes, DNS, etc.;
the connection appears as active but NetworkManager doesn't actually
touch the interface. The external status is tracked in the
`sys-iface-state` member, which can have the following values:
`managed-type` member, which can have the following values:
- EXTERNAL: the interface is not touched by NM.
- ASSUME: this value is deprecated; it used to mean that NM should manage the device without fully reconfiguring it. Now, the interface is either managed on external.

4
src/core/devices/nm-device-bond.c
View File

@@ -608,12 +608,12 @@ act_stage1_prepare(NMDevice *device, NMDeviceStateReason *out_failure_reason)
s_bond = nm_connection_get_setting_bond(connection);
g_return_val_if_fail(s_bond, NM_ACT_STAGE_RETURN_FAILURE);
if (nm_device_sys_iface_state_is_external(device))
if (nm_device_managed_type_is_external(device))
return NM_ACT_STAGE_RETURN_SUCCESS;
_balance_slb_setup(self, connection);
if (nm_device_sys_iface_state_is_external_or_assume(device))
if (nm_device_managed_type_is_external_or_assume(device))
return NM_ACT_STAGE_RETURN_SUCCESS;
_platform_lnk_bond_init_from_setting(s_bond, &props);

2
src/core/devices/nm-device-bridge.c
View File

@@ -1049,7 +1049,7 @@ attach_port(NMDevice *device,
nm_assert(s_bridge);
s_port = nm_connection_get_setting_bridge_port(connection);
if (!nm_device_sys_iface_state_is_external(device))
if (!nm_device_managed_type_is_external(device))
bridge_set_vlan_options(device, s_bridge, FALSE);
if (nm_setting_bridge_get_vlan_filtering(s_bridge)) {

4
src/core/devices/nm-device-ethernet.c
View File

@@ -988,8 +988,8 @@ act_stage1_prepare(NMDevice *device, NMDeviceStateReason *out_failure_reason)
NMDeviceEthernet *self = NM_DEVICE_ETHERNET(device);
NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE(self);
if (nm_device_sys_iface_state_is_external_or_assume(device)) {
if (!priv->ethtool_prev_set && !nm_device_sys_iface_state_is_external(device)) {
if (nm_device_managed_type_is_external_or_assume(device)) {
if (!priv->ethtool_prev_set && !nm_device_managed_type_is_external(device)) {
NMSettingWired *s_wired;
/* During restart of NetworkManager service we forget the original auto

13
src/core/devices/nm-device-utils.c
View File

@@ -152,14 +152,13 @@ NM_UTILS_LOOKUP_STR_DEFINE(nm_device_mtu_source_to_string,
NM_UTILS_LOOKUP_STR_ITEM(NM_DEVICE_MTU_SOURCE_CONNECTION,
"connection"), );
NM_UTILS_LOOKUP_STR_DEFINE(nm_device_sys_iface_state_to_string,
NMDeviceSysIfaceState,
NM_UTILS_LOOKUP_STR_DEFINE(nm_device_managed_type_to_string,
NMDeviceManagedType,
NM_UTILS_LOOKUP_DEFAULT_NM_ASSERT("unknown"),
NM_UTILS_LOOKUP_STR_ITEM(NM_DEVICE_SYS_IFACE_STATE_EXTERNAL, "external"),
NM_UTILS_LOOKUP_STR_ITEM(NM_DEVICE_SYS_IFACE_STATE_ASSUME, "assume"),
NM_UTILS_LOOKUP_STR_ITEM(NM_DEVICE_SYS_IFACE_STATE_MANAGED, "managed"),
NM_UTILS_LOOKUP_STR_ITEM(NM_DEVICE_SYS_IFACE_STATE_REMOVED,
"removed"), );
NM_UTILS_LOOKUP_STR_ITEM(NM_DEVICE_MANAGED_TYPE_EXTERNAL, "external"),
NM_UTILS_LOOKUP_STR_ITEM(NM_DEVICE_MANAGED_TYPE_ASSUME, "assume"),
NM_UTILS_LOOKUP_STR_ITEM(NM_DEVICE_MANAGED_TYPE_MANAGED, "managed"),
NM_UTILS_LOOKUP_STR_ITEM(NM_DEVICE_MANAGED_TYPE_REMOVED, "removed"), );
NM_UTILS_LOOKUP_STR_DEFINE(nm_device_ip_state_to_string,
NMDeviceIPState,

12
src/core/devices/nm-device-utils.h
View File

@@ -57,19 +57,19 @@ const char *nm_device_mtu_source_to_string(NMDeviceMtuSource mtu_source);
/*****************************************************************************/
typedef enum _nm_packed {
NM_DEVICE_SYS_IFACE_STATE_EXTERNAL,
NM_DEVICE_SYS_IFACE_STATE_ASSUME,
NM_DEVICE_SYS_IFACE_STATE_MANAGED,
NM_DEVICE_MANAGED_TYPE_EXTERNAL,
NM_DEVICE_MANAGED_TYPE_ASSUME,
NM_DEVICE_MANAGED_TYPE_MANAGED,
/* the REMOVED state applies when the device is manually set to unmanaged
* or the link was externally removed. In both cases, we move the device
* to UNMANAGED state, without touching the link -- be it, because the link
* is already gone or because we want to release it (give it up).
*/
NM_DEVICE_SYS_IFACE_STATE_REMOVED,
} NMDeviceSysIfaceState;
NM_DEVICE_MANAGED_TYPE_REMOVED,
} NMDeviceManagedType;
const char *nm_device_sys_iface_state_to_string(NMDeviceSysIfaceState sys_iface_state);
const char *nm_device_managed_type_to_string(NMDeviceManagedType managed_type);
/*****************************************************************************/

2
src/core/devices/nm-device-vlan.c
View File

@@ -72,7 +72,7 @@ parent_hwaddr_maybe_changed(NMDevice *parent, GParamSpec *pspec, gpointer user_d
const char *new_mac;
/* Never touch assumed devices */
if (nm_device_sys_iface_state_is_external_or_assume(device))
if (nm_device_managed_type_is_external_or_assume(device))
return;
connection = nm_device_get_applied_connection(device);

13
src/core/devices/nm-device-wireguard.c
View File

@@ -1586,26 +1586,25 @@ act_stage2_config(NMDevice *device, NMDeviceStateReason *out_failure_reason)
{
NMDeviceWireGuard *self = NM_DEVICE_WIREGUARD(device);
NMDeviceWireGuardPrivate *priv = NM_DEVICE_WIREGUARD_GET_PRIVATE(self);
NMDeviceSysIfaceState sys_iface_state;
NMDeviceManagedType managed_type;
NMDeviceStateReason failure_reason;
NMActStageReturn ret;
sys_iface_state = nm_device_sys_iface_state_get(device);
managed_type = nm_device_managed_type_get(device);
if (sys_iface_state == NM_DEVICE_SYS_IFACE_STATE_EXTERNAL) {
if (managed_type == NM_DEVICE_MANAGED_TYPE_EXTERNAL) {
NM_SET_OUT(out_failure_reason, NM_DEVICE_STATE_REASON_NONE);
return NM_ACT_STAGE_RETURN_SUCCESS;
}
ret =
link_config(NM_DEVICE_WIREGUARD(device),
ret = link_config(NM_DEVICE_WIREGUARD(device),
"configure",
(sys_iface_state == NM_DEVICE_SYS_IFACE_STATE_ASSUME) ? LINK_CONFIG_MODE_ASSUME
(managed_type == NM_DEVICE_MANAGED_TYPE_ASSUME) ? LINK_CONFIG_MODE_ASSUME
: LINK_CONFIG_MODE_FULL,
&failure_reason);
if (ret == NM_ACT_STAGE_RETURN_FAILURE) {
if (sys_iface_state == NM_DEVICE_SYS_IFACE_STATE_ASSUME) {
if (managed_type == NM_DEVICE_MANAGED_TYPE_ASSUME) {
/* this never fails. */
return NM_ACT_STAGE_RETURN_SUCCESS;
}

219
src/core/devices/nm-device.c
View File

@@ -571,11 +571,11 @@ typedef struct _NMDevicePrivate {
};
union {
const NMDeviceSysIfaceState sys_iface_state;
NMDeviceSysIfaceState sys_iface_state_;
const NMDeviceManagedType managed_type;
NMDeviceManagedType managed_type_;
};
NMDeviceSysIfaceState sys_iface_state_before_sleep;
NMDeviceManagedType managed_type_before_sleep;
bool carrier : 1;
bool ignore_carrier : 1;
@@ -3357,47 +3357,47 @@ nm_device_create_l3_config_data_from_connection(NMDevice *self, NMConnection *co
/*****************************************************************************/
NMDeviceSysIfaceState
nm_device_sys_iface_state_get(NMDevice *self)
NMDeviceManagedType
nm_device_managed_type_get(NMDevice *self)
{
g_return_val_if_fail(NM_IS_DEVICE(self), NM_DEVICE_SYS_IFACE_STATE_EXTERNAL);
g_return_val_if_fail(NM_IS_DEVICE(self), NM_DEVICE_MANAGED_TYPE_EXTERNAL);
return NM_DEVICE_GET_PRIVATE(self)->sys_iface_state;
return NM_DEVICE_GET_PRIVATE(self)->managed_type;
}
gboolean
nm_device_sys_iface_state_is_external(NMDevice *self)
nm_device_managed_type_is_external(NMDevice *self)
{
return NM_IN_SET(nm_device_sys_iface_state_get(self), NM_DEVICE_SYS_IFACE_STATE_EXTERNAL);
return NM_IN_SET(nm_device_managed_type_get(self), NM_DEVICE_MANAGED_TYPE_EXTERNAL);
}
gboolean
nm_device_sys_iface_state_is_external_or_assume(NMDevice *self)
nm_device_managed_type_is_external_or_assume(NMDevice *self)
{
return NM_IN_SET(nm_device_sys_iface_state_get(self),
NM_DEVICE_SYS_IFACE_STATE_EXTERNAL,
NM_DEVICE_SYS_IFACE_STATE_ASSUME);
return NM_IN_SET(nm_device_managed_type_get(self),
NM_DEVICE_MANAGED_TYPE_EXTERNAL,
NM_DEVICE_MANAGED_TYPE_ASSUME);
}
void
nm_device_sys_iface_state_set(NMDevice *self, NMDeviceSysIfaceState sys_iface_state)
nm_device_managed_type_set(NMDevice *self, NMDeviceManagedType managed_type)
{
NMDevicePrivate *priv;
g_return_if_fail(NM_IS_DEVICE(self));
g_return_if_fail(NM_IN_SET(sys_iface_state,
NM_DEVICE_SYS_IFACE_STATE_EXTERNAL,
NM_DEVICE_SYS_IFACE_STATE_ASSUME,
NM_DEVICE_SYS_IFACE_STATE_MANAGED,
NM_DEVICE_SYS_IFACE_STATE_REMOVED));
g_return_if_fail(NM_IN_SET(managed_type,
NM_DEVICE_MANAGED_TYPE_EXTERNAL,
NM_DEVICE_MANAGED_TYPE_ASSUME,
NM_DEVICE_MANAGED_TYPE_MANAGED,
NM_DEVICE_MANAGED_TYPE_REMOVED));
priv = NM_DEVICE_GET_PRIVATE(self);
if (priv->sys_iface_state != sys_iface_state) {
if (priv->managed_type != managed_type) {
_LOGT(LOGD_DEVICE,
"managed-type: %s -> %s",
nm_device_sys_iface_state_to_string(priv->sys_iface_state),
nm_device_sys_iface_state_to_string(sys_iface_state));
priv->sys_iface_state_ = sys_iface_state;
nm_device_managed_type_to_string(priv->managed_type),
nm_device_managed_type_to_string(managed_type));
priv->managed_type_ = managed_type;
_dev_l3_cfg_commit_type_reset(self);
nm_device_l3cfg_commit(self, NM_L3_CFG_COMMIT_TYPE_AUTO, FALSE);
}
@@ -3406,7 +3406,7 @@ nm_device_sys_iface_state_set(NMDevice *self, NMDeviceSysIfaceState sys_iface_st
*
* If you change this, make sure that all callers are fine with such actions. */
nm_assert(priv->sys_iface_state == sys_iface_state);
nm_assert(priv->managed_type == managed_type);
}
void
@@ -3414,15 +3414,15 @@ nm_device_notify_sleeping(NMDevice *self)
{
NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE(self);
priv->sys_iface_state_before_sleep = priv->sys_iface_state;
priv->managed_type_before_sleep = priv->managed_type;
}
NMDeviceSysIfaceState
nm_device_get_sys_iface_state_before_sleep(NMDevice *self)
NMDeviceManagedType
nm_device_get_managed_type_before_sleep(NMDevice *self)
{
NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE(self);
return priv->sys_iface_state_before_sleep;
return priv->managed_type_before_sleep;
}
static void
@@ -3820,7 +3820,7 @@ _dev_ip_state_check(NMDevice *self, int addr_family)
goto got_ip_state;
}
if (nm_device_sys_iface_state_is_external(self)) {
if (nm_device_managed_type_is_external(self)) {
ip_state = NM_DEVICE_IP_STATE_READY;
goto got_ip_state;
}
@@ -4005,7 +4005,7 @@ got_ip_state:
/* If both IP states failed, or one failed and the other is disabled
* then it's a failure. may-fail does not mean that both families may
* fail, instead it means that at least one family must succeed. */
if (nm_device_sys_iface_state_is_external_or_assume(self)) {
if (nm_device_managed_type_is_external_or_assume(self)) {
_dev_ip_state_set_state(self, AF_INET, NM_DEVICE_IP_STATE_READY, "assumed");
_dev_ip_state_set_state(self, AF_INET6, NM_DEVICE_IP_STATE_READY, "assumed");
combinedip_state = NM_DEVICE_IP_STATE_READY;
@@ -4458,7 +4458,7 @@ _dev_l3_register_l3cds(NMDevice *self,
if (!l3cfg)
return FALSE;
is_external = nm_device_sys_iface_state_is_external(self);
is_external = nm_device_managed_type_is_external(self);
changed = FALSE;
for (i = 0; i < (int) G_N_ELEMENTS(priv->l3cds); i++) {
@@ -4530,7 +4530,7 @@ update_external_connection(NMDevice *self)
/* Update external connections with configuration from platform */
if (!nm_device_sys_iface_state_is_external(self))
if (!nm_device_managed_type_is_external(self))
return;
settings_connection = nm_device_get_settings_connection(self);
@@ -4726,17 +4726,17 @@ _dev_l3_cfg_commit_type_reset(NMDevice *self)
if (!priv->l3cfg)
return;
switch (priv->sys_iface_state) {
case NM_DEVICE_SYS_IFACE_STATE_EXTERNAL:
case NM_DEVICE_SYS_IFACE_STATE_REMOVED:
switch (priv->managed_type) {
case NM_DEVICE_MANAGED_TYPE_EXTERNAL:
case NM_DEVICE_MANAGED_TYPE_REMOVED:
commit_type = NM_L3_CFG_COMMIT_TYPE_NONE;
goto do_set;
case NM_DEVICE_SYS_IFACE_STATE_ASSUME:
/* TODO: NM_DEVICE_SYS_IFACE_STATE_ASSUME, will be dropped from the code.
case NM_DEVICE_MANAGED_TYPE_ASSUME:
/* TODO: NM_DEVICE_MANAGED_TYPE_ASSUME, will be dropped from the code.
* Meanwhile, the commit type must be updated. */
commit_type = NM_L3_CFG_COMMIT_TYPE_UPDATE;
goto do_set;
case NM_DEVICE_SYS_IFACE_STATE_MANAGED:
case NM_DEVICE_MANAGED_TYPE_MANAGED:
commit_type = NM_L3_CFG_COMMIT_TYPE_UPDATE;
goto do_set;
}
@@ -6365,7 +6365,7 @@ concheck_update_state(NMDevice *self,
_notify(self, IS_IPv4 ? PROP_IP4_CONNECTIVITY : PROP_IP6_CONNECTIVITY);
if (priv->state == NM_DEVICE_STATE_ACTIVATED && !nm_device_sys_iface_state_is_external(self))
if (priv->state == NM_DEVICE_STATE_ACTIVATED && !nm_device_managed_type_is_external(self))
_dev_l3_register_l3cds(self, priv->l3cfg, TRUE, NM_TERNARY_DEFAULT);
}
@@ -6850,7 +6850,7 @@ nm_device_controller_release_port(NMDevice *self,
nm_clear_g_cancellable(&info->cancellable);
/* first, let subclasses handle the release ... */
if (info->port_is_attached || nm_device_sys_iface_state_is_external(port)
if (info->port_is_attached || nm_device_managed_type_is_external(port)
|| release_type >= RELEASE_PORT_TYPE_CONFIG_FORCE) {
NMTernary ret;
@@ -7286,7 +7286,7 @@ device_update_interface_flags(NMDevice *self, const NMPlatformLink *plink)
/*
* Returns the reason for managing a device. The suffix "external" indicates
* that the reason mainly depends on whether we want to make the device
* sys-iface-state=external or not.
* managed_type=external or not.
*/
NMDeviceStateReason
nm_device_get_manage_reason_external(NMDevice *self)
@@ -7294,14 +7294,14 @@ nm_device_get_manage_reason_external(NMDevice *self)
NMDeviceStateReason reason;
/* By default we return reason NOW_MANAGED, which makes the device fully
* managed by NM (sys-iface-state=managed). */
* managed by NM (managed_type=managed). */
reason = NM_DEVICE_STATE_REASON_NOW_MANAGED;
/* If the device is an external-down candidate but no longer has the flag
* set, then the device is an externally created interface that previously
* had no addresses or no controller and now has.
* We need to set CONNECTION_ASSUMED as the reason, so that the device
* is managed but is not touched by NM (sys-iface-state=external). */
* is managed but is not touched by NM (managed_type=external). */
if (nm_device_get_unmanaged_mask(self, NM_UNMANAGED_EXTERNAL_DOWN)
&& !nm_device_get_unmanaged_flags(self, NM_UNMANAGED_EXTERNAL_DOWN)) {
/* user-udev overwrites external-down, so we only assume the device
@@ -7449,7 +7449,7 @@ device_link_changed(gpointer user_data)
* NMVpnConnection should become like a regular device, akin to NMDevicePpp).
*/
if (priv->state >= NM_DEVICE_STATE_IP_CONFIG && priv->state <= NM_DEVICE_STATE_ACTIVATED
&& !nm_device_sys_iface_state_is_external(self))
&& !nm_device_managed_type_is_external(self))
nm_device_l3cfg_commit(self, NM_L3_CFG_COMMIT_TYPE_REAPPLY, FALSE);
/* If the device is active without a carrier (probably because it is
@@ -8041,7 +8041,7 @@ realize_start_setup(NMDevice *self,
_assume_state_set(self, assume_state_guess_assume, assume_state_connection_uuid);
nm_device_sys_iface_state_set(self, NM_DEVICE_SYS_IFACE_STATE_EXTERNAL);
nm_device_managed_type_set(self, NM_DEVICE_MANAGED_TYPE_EXTERNAL);
if (plink)
nm_device_update_from_platform_link(self, plink);
@@ -8469,9 +8469,9 @@ port_state_changed(NMDevice *port,
}
if (release) {
configure = (priv->sys_iface_state == NM_DEVICE_SYS_IFACE_STATE_MANAGED
&& nm_device_sys_iface_state_get(port) != NM_DEVICE_SYS_IFACE_STATE_EXTERNAL)
|| nm_device_sys_iface_state_get(port) == NM_DEVICE_SYS_IFACE_STATE_MANAGED;
configure = (priv->managed_type == NM_DEVICE_MANAGED_TYPE_MANAGED
&& nm_device_managed_type_get(port) != NM_DEVICE_MANAGED_TYPE_EXTERNAL)
|| nm_device_managed_type_get(port) == NM_DEVICE_MANAGED_TYPE_MANAGED;
nm_device_controller_release_port(self,
port,
@@ -8610,7 +8610,7 @@ nm_device_controller_release_ports_all(NMDevice *self)
PortInfo *safe;
/* Don't release the ports if this connection doesn't belong to NM. */
if (nm_device_sys_iface_state_is_external(self))
if (nm_device_managed_type_is_external(self))
return;
reason = priv->state_reason;
@@ -8619,7 +8619,7 @@ nm_device_controller_release_ports_all(NMDevice *self)
c_list_for_each_entry_safe (info, safe, &priv->ports, lst_port) {
if (priv->activation_state_preserve_external_ports
&& nm_device_sys_iface_state_is_external(info->port)) {
&& nm_device_managed_type_is_external(info->port)) {
_LOGT(LOGD_DEVICE,
"controller: preserve external port %s",
nm_device_get_iface(info->port));
@@ -8821,9 +8821,9 @@ nm_device_removed(NMDevice *self, gboolean unconfigure_ip_config)
* commit type NONE, that doesn't emit a l3cd-changed. Do it manually,
* to ensure that entries are removed from the DNS manager. */
if (priv->l3cfg
&& NM_IN_SET(priv->sys_iface_state,
NM_DEVICE_SYS_IFACE_STATE_REMOVED,
NM_DEVICE_SYS_IFACE_STATE_EXTERNAL)) {
&& NM_IN_SET(priv->managed_type,
NM_DEVICE_MANAGED_TYPE_REMOVED,
NM_DEVICE_MANAGED_TYPE_EXTERNAL)) {
l3cd_old = nm_l3cfg_get_combined_l3cd(priv->l3cfg, TRUE);
if (l3cd_old)
g_signal_emit(self, signals[L3CD_CHANGED], 0, l3cd_old, NULL);
@@ -9937,7 +9937,7 @@ controller_ready(NMDevice *self, NMActiveConnection *active)
/* If the controller didn't change, add-port only rechecks whether to assume a connection. */
nm_device_controller_add_port(controller,
self,
!nm_device_sys_iface_state_is_external_or_assume(self));
!nm_device_managed_type_is_external_or_assume(self));
}
static void
@@ -10093,7 +10093,7 @@ activate_stage1_device_prepare(NMDevice *self)
if (priv->stage1_sriov_state != NM_DEVICE_STAGE_STATE_COMPLETED) {
NMSettingSriov *s_sriov = NULL;
if (nm_device_sys_iface_state_is_external_or_assume(self)) {
if (nm_device_managed_type_is_external_or_assume(self)) {
/* pass */
} else if (priv->stage1_sriov_state == NM_DEVICE_STAGE_STATE_PENDING) {
return;
@@ -10163,7 +10163,7 @@ activate_stage1_device_prepare(NMDevice *self)
klass = NM_DEVICE_GET_CLASS(self);
if (klass->act_stage1_prepare_set_hwaddr_ethernet
&& !nm_device_sys_iface_state_is_external_or_assume(self)) {
&& !nm_device_managed_type_is_external_or_assume(self)) {
if (!nm_device_hw_addr_set_cloned(self, nm_device_get_applied_connection(self), FALSE)) {
nm_device_state_changed(self,
NM_DEVICE_STATE_FAILED,
@@ -10173,7 +10173,7 @@ activate_stage1_device_prepare(NMDevice *self)
}
if (klass->act_stage1_prepare_also_for_external_or_assume
|| !nm_device_sys_iface_state_is_external_or_assume(self)) {
|| !nm_device_managed_type_is_external_or_assume(self)) {
nm_assert(!klass->act_stage1_prepare_also_for_external_or_assume
|| klass->act_stage1_prepare);
if (klass->act_stage1_prepare) {
@@ -10460,12 +10460,12 @@ activate_stage2_device_config(NMDevice *self)
nm_device_state_changed(self, NM_DEVICE_STATE_CONFIG, NM_DEVICE_STATE_REASON_NONE);
if (!nm_device_sys_iface_state_is_external(self)) {
if (!nm_device_managed_type_is_external(self)) {
_ethtool_state_set(self);
nm_device_link_properties_set(self, FALSE);
}
if (!nm_device_sys_iface_state_is_external(self)) {
if (!nm_device_managed_type_is_external(self)) {
if (!priv->tc_committed && !tc_commit(self)) {
_LOGW(LOGD_DEVICE, "failed applying traffic control rules");
nm_device_state_changed(self,
@@ -10478,7 +10478,7 @@ activate_stage2_device_config(NMDevice *self)
_routing_rules_sync(self, NM_TERNARY_TRUE);
if (!nm_device_sys_iface_state_is_external_or_assume(self)) {
if (!nm_device_managed_type_is_external_or_assume(self)) {
if (!nm_device_bring_up_full(self, FALSE, TRUE, &no_firmware)) {
nm_device_state_changed(self,
NM_DEVICE_STATE_FAILED,
@@ -10490,7 +10490,7 @@ activate_stage2_device_config(NMDevice *self)
klass = NM_DEVICE_GET_CLASS(self);
if (klass->act_stage2_config_also_for_external_or_assume
|| !nm_device_sys_iface_state_is_external_or_assume(self)) {
|| !nm_device_managed_type_is_external_or_assume(self)) {
NMDeviceStateReason failure_reason = NM_DEVICE_STATE_REASON_NONE;
ret = klass->act_stage2_config(self, &failure_reason);
@@ -10511,7 +10511,7 @@ activate_stage2_device_config(NMDevice *self)
nm_device_controller_attach_port(self,
info->port,
nm_device_get_applied_connection(info->port));
else if (priv->act_request.obj && nm_device_sys_iface_state_is_external(self)
else if (priv->act_request.obj && nm_device_managed_type_is_external(self)
&& port_state <= NM_DEVICE_STATE_DISCONNECTED)
nm_device_queue_recheck_assume(info->port);
}
@@ -11136,7 +11136,7 @@ _dev_ipdhcpx_start(NMDevice *self, int addr_family)
return;
}
if (nm_device_sys_iface_state_is_external(self)) {
if (nm_device_managed_type_is_external(self)) {
fail_reason = nm_assert_unreachable_val("cannot run DHCP on external interface");
goto out_fail;
}
@@ -11745,7 +11745,7 @@ _dev_ipll6_start(NMDevice *self)
connection = nm_device_get_applied_connection(self);
assume = nm_device_sys_iface_state_is_external_or_assume(self);
assume = nm_device_managed_type_is_external_or_assume(self);
if (_prop_get_ipv6_addr_gen_mode(self) == NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_STABLE_PRIVACY) {
NMUtilsStableType stable_type;
@@ -11977,7 +11977,7 @@ _commit_mtu(NMDevice *self)
if (ifindex <= 0)
return;
if (!nm_device_get_applied_connection(self) || nm_device_sys_iface_state_is_external(self)) {
if (!nm_device_get_applied_connection(self) || nm_device_managed_type_is_external(self)) {
/* we don't tamper with the MTU of disconnected and external devices. */
return;
}
@@ -12703,7 +12703,7 @@ activate_stage3_ip_config_for_addr_family(NMDevice *self, int addr_family, const
NMConnection *connection;
int ip_ifindex;
if (nm_device_sys_iface_state_is_external(self))
if (nm_device_managed_type_is_external(self))
goto out;
connection = nm_device_get_applied_connection(self);
@@ -12940,7 +12940,7 @@ activate_stage3_ip_config(NMDevice *self)
/* Add the interface to the specified firewall zone */
switch (priv->fw_state) {
case FIREWALL_STATE_UNMANAGED:
if (nm_device_sys_iface_state_is_external(self)) {
if (nm_device_managed_type_is_external(self)) {
/* fake success */
priv->fw_state = FIREWALL_STATE_INITIALIZED;
} else if (ifindex > 0) {
@@ -12970,7 +12970,7 @@ activate_stage3_ip_config(NMDevice *self)
ipv6_method = nm_device_get_effective_ip_config_method(self, AF_INET6);
if (!g_file_test("/proc/sys/net/ipv6", G_FILE_TEST_IS_DIR)) {
_NMLOG_ip((nm_device_sys_iface_state_is_external(self)
_NMLOG_ip((nm_device_managed_type_is_external(self)
|| NM_IN_STRSET(ipv6_method,
NM_SETTING_IP6_CONFIG_METHOD_AUTO,
NM_SETTING_IP6_CONFIG_METHOD_DISABLED,
@@ -13010,7 +13010,7 @@ activate_stage3_ip_config(NMDevice *self)
nm_device_state_changed(self, NM_DEVICE_STATE_IP_CONFIG, NM_DEVICE_STATE_REASON_NONE);
/* Device should be up before we can do anything with it */
if (!nm_device_sys_iface_state_is_external(self) && ifindex > 0
if (!nm_device_managed_type_is_external(self) && ifindex > 0
&& !nm_platform_link_is_up(nm_device_get_platform(self), ifindex))
_LOGW(LOGD_DEVICE,
"interface %s not up for IP configuration",
@@ -13026,7 +13026,7 @@ activate_stage3_ip_config(NMDevice *self)
* let's do it! */
_commit_mtu(self);
if (!nm_device_sys_iface_state_is_external(self)
if (!nm_device_managed_type_is_external(self)
&& (!klass->ready_for_ip_config || klass->ready_for_ip_config(self, TRUE))) {
if (priv->ipmanual_data.state_6 == NM_DEVICE_IP_STATE_NONE
&& !NM_IN_STRSET(ipv6_method,
@@ -13042,7 +13042,7 @@ activate_stage3_ip_config(NMDevice *self)
* IPv6LL if this is not an assumed connection, since assumed connections
* will already have IPv6 set up.
*/
if (!nm_device_sys_iface_state_is_external_or_assume(self))
if (!nm_device_managed_type_is_external_or_assume(self))
_dev_addrgenmode6_set(self, NM_IN6_ADDR_GEN_MODE_NONE);
/* Re-enable IPv6 on the interface */
@@ -13396,15 +13396,15 @@ act_request_set(NMDevice *self, NMActRequest *act_request)
case NM_ACTIVATION_TYPE_EXTERNAL:
break;
case NM_ACTIVATION_TYPE_ASSUME:
if (priv->sys_iface_state == NM_DEVICE_SYS_IFACE_STATE_EXTERNAL)
nm_device_sys_iface_state_set(self, NM_DEVICE_SYS_IFACE_STATE_ASSUME);
if (priv->managed_type == NM_DEVICE_MANAGED_TYPE_EXTERNAL)
nm_device_managed_type_set(self, NM_DEVICE_MANAGED_TYPE_ASSUME);
break;
case NM_ACTIVATION_TYPE_MANAGED:
if (NM_IN_SET_TYPED(NMDeviceSysIfaceState,
priv->sys_iface_state,
NM_DEVICE_SYS_IFACE_STATE_EXTERNAL,
NM_DEVICE_SYS_IFACE_STATE_ASSUME))
nm_device_sys_iface_state_set(self, NM_DEVICE_SYS_IFACE_STATE_MANAGED);
if (NM_IN_SET_TYPED(NMDeviceManagedType,
priv->managed_type,
NM_DEVICE_MANAGED_TYPE_EXTERNAL,
NM_DEVICE_MANAGED_TYPE_ASSUME))
nm_device_managed_type_set(self, NM_DEVICE_MANAGED_TYPE_MANAGED);
break;
}
}
@@ -13947,8 +13947,8 @@ reapply_cb(NMDevice *self,
return;
}
if (nm_device_sys_iface_state_is_external(self))
nm_device_sys_iface_state_set(self, NM_DEVICE_SYS_IFACE_STATE_MANAGED);
if (nm_device_managed_type_is_external(self))
nm_device_managed_type_set(self, NM_DEVICE_MANAGED_TYPE_MANAGED);
if (!check_and_reapply_connection(self,
connection
@@ -14432,10 +14432,10 @@ nm_device_disconnect_active_connection(NMActiveConnection *active,
if (NM_ACTIVE_CONNECTION(priv->act_request.obj) == active) {
if (priv->state < NM_DEVICE_STATE_DEACTIVATING) {
/* When the user actively deactivates a profile, we set
* the sys-iface-state to managed so that we deconfigure/cleanup the interface.
* the managed-type to managed so that we deconfigure/cleanup the interface.
* But for external connections that go down otherwise, we don't want to touch the interface. */
if (nm_device_sys_iface_state_is_external(self))
nm_device_sys_iface_state_set(self, NM_DEVICE_SYS_IFACE_STATE_MANAGED);
if (nm_device_managed_type_is_external(self))
nm_device_managed_type_set(self, NM_DEVICE_MANAGED_TYPE_MANAGED);
nm_device_state_changed(self, NM_DEVICE_STATE_DEACTIVATING, device_reason);
} else {
@@ -15702,8 +15702,7 @@ nm_device_update_firewall_zone(NMDevice *self)
priv = NM_DEVICE_GET_PRIVATE(self);
if (priv->fw_state >= FIREWALL_STATE_INITIALIZED
&& !nm_device_sys_iface_state_is_external(self))
if (priv->fw_state >= FIREWALL_STATE_INITIALIZED && !nm_device_managed_type_is_external(self))
fw_change_zone(self);
}
@@ -16350,7 +16349,7 @@ _cleanup_generic_pre(NMDevice *self, CleanupType cleanup_type)
}
if (cleanup_type == CLEANUP_TYPE_DECONFIGURE && priv->fw_state >= FIREWALL_STATE_INITIALIZED
&& priv->fw_mgr && !nm_device_sys_iface_state_is_external(self)) {
&& priv->fw_mgr && !nm_device_managed_type_is_external(self)) {
nm_firewalld_manager_remove_from_zone(priv->fw_mgr,
nm_device_get_ip_iface(self),
NULL,
@@ -16715,7 +16714,7 @@ _set_state_full(NMDevice *self, NMDeviceState state, NMDeviceStateReason reason,
old_state = priv->state;
if (state == NM_DEVICE_STATE_FAILED && nm_device_sys_iface_state_is_external_or_assume(self)) {
if (state == NM_DEVICE_STATE_FAILED && nm_device_managed_type_is_external_or_assume(self)) {
/* Avoid tearing down assumed connection, assume it's connected */
state = NM_DEVICE_STATE_ACTIVATED;
reason = NM_DEVICE_STATE_REASON_CONNECTION_ASSUMED;
@@ -16732,7 +16731,7 @@ _set_state_full(NMDevice *self, NMDeviceState state, NMDeviceStateReason reason,
nm_device_state_to_string(old_state),
nm_device_state_to_string(state),
nm_device_state_reason_to_string_a(reason),
nm_device_sys_iface_state_to_string(priv->sys_iface_state),
nm_device_managed_type_to_string(priv->managed_type),
priv->firmware_missing ? ", missing firmware" : "");
return;
}
@@ -16742,7 +16741,7 @@ _set_state_full(NMDevice *self, NMDeviceState state, NMDeviceStateReason reason,
nm_device_state_to_string(old_state),
nm_device_state_to_string(state),
nm_device_state_reason_to_string_a(reason),
nm_device_sys_iface_state_to_string(priv->sys_iface_state));
nm_device_managed_type_to_string(priv->managed_type));
/* in order to prevent triggering any callback caused
* by the device not having any pending action anymore
@@ -16764,11 +16763,11 @@ _set_state_full(NMDevice *self, NMDeviceState state, NMDeviceStateReason reason,
if (state > NM_DEVICE_STATE_UNMANAGED && state <= NM_DEVICE_STATE_ACTIVATED
&& nm_device_state_reason_check(reason) == NM_DEVICE_STATE_REASON_NOW_MANAGED
&& NM_IN_SET_TYPED(NMDeviceSysIfaceState,
priv->sys_iface_state,
NM_DEVICE_SYS_IFACE_STATE_EXTERNAL,
NM_DEVICE_SYS_IFACE_STATE_ASSUME))
nm_device_sys_iface_state_set(self, NM_DEVICE_SYS_IFACE_STATE_MANAGED);
&& NM_IN_SET_TYPED(NMDeviceManagedType,
priv->managed_type,
NM_DEVICE_MANAGED_TYPE_EXTERNAL,
NM_DEVICE_MANAGED_TYPE_ASSUME))
nm_device_managed_type_set(self, NM_DEVICE_MANAGED_TYPE_MANAGED);
if (state <= NM_DEVICE_STATE_DISCONNECTED || state >= NM_DEVICE_STATE_ACTIVATED)
priv->auth_retries = NM_DEVICE_AUTH_RETRIES_UNSET;
@@ -16810,10 +16809,10 @@ _set_state_full(NMDevice *self, NMDeviceState state, NMDeviceStateReason reason,
case NM_DEVICE_STATE_UNMANAGED:
nm_device_set_firmware_missing(self, FALSE);
if (old_state > NM_DEVICE_STATE_UNMANAGED) {
if (priv->sys_iface_state != NM_DEVICE_SYS_IFACE_STATE_MANAGED) {
if (priv->managed_type != NM_DEVICE_MANAGED_TYPE_MANAGED) {
nm_device_cleanup(self,
reason,
priv->sys_iface_state == NM_DEVICE_SYS_IFACE_STATE_REMOVED
priv->managed_type == NM_DEVICE_MANAGED_TYPE_REMOVED
? CLEANUP_TYPE_REMOVED
: CLEANUP_TYPE_KEEP);
} else {
@@ -16826,12 +16825,12 @@ _set_state_full(NMDevice *self, NMDeviceState state, NMDeviceStateReason reason,
_dev_sysctl_restore_ip6_properties(self);
}
}
nm_device_sys_iface_state_set(self, NM_DEVICE_SYS_IFACE_STATE_EXTERNAL);
nm_device_managed_type_set(self, NM_DEVICE_MANAGED_TYPE_EXTERNAL);
break;
case NM_DEVICE_STATE_UNAVAILABLE:
if (old_state == NM_DEVICE_STATE_UNMANAGED) {
_dev_sysctl_save_ip6_properties(self);
if (priv->sys_iface_state == NM_DEVICE_SYS_IFACE_STATE_MANAGED)
if (priv->managed_type == NM_DEVICE_MANAGED_TYPE_MANAGED)
ip6_managed_setup(self);
device_init_static_sriov_num_vfs(self);
@@ -16843,7 +16842,7 @@ _set_state_full(NMDevice *self, NMDeviceState state, NMDeviceStateReason reason,
carrier_detect_wait(self);
}
if (priv->sys_iface_state == NM_DEVICE_SYS_IFACE_STATE_MANAGED) {
if (priv->managed_type == NM_DEVICE_MANAGED_TYPE_MANAGED) {
if (old_state == NM_DEVICE_STATE_UNMANAGED || priv->firmware_missing) {
if (!nm_device_bring_up_full(self, TRUE, FALSE, &no_firmware) && no_firmware)
_LOGW(LOGD_PLATFORM, "firmware may be missing.");
@@ -16867,13 +16866,13 @@ _set_state_full(NMDevice *self, NMDeviceState state, NMDeviceStateReason reason,
* userspace IPv6LL enabled.
*/
_dev_addrgenmode6_set(self, NM_IN6_ADDR_GEN_MODE_NONE);
if (priv->sys_iface_state == NM_DEVICE_SYS_IFACE_STATE_REMOVED) {
if (priv->managed_type == NM_DEVICE_MANAGED_TYPE_REMOVED) {
nm_device_cleanup(self, reason, CLEANUP_TYPE_REMOVED);
} else
nm_device_cleanup(self, reason, CLEANUP_TYPE_DECONFIGURE);
} else if (old_state < NM_DEVICE_STATE_DISCONNECTED) {
if (priv->sys_iface_state == NM_DEVICE_SYS_IFACE_STATE_MANAGED) {
if (priv->managed_type == NM_DEVICE_MANAGED_TYPE_MANAGED) {
/* Ensure IPv6 is set up as it may not have been done when
* entering the UNAVAILABLE state depending on the reason.
*/
@@ -17036,7 +17035,7 @@ _set_state_full(NMDevice *self, NMDeviceState state, NMDeviceStateReason reason,
{
gboolean change_zone = FALSE;
if (!nm_device_sys_iface_state_is_external(self)) {
if (!nm_device_managed_type_is_external(self)) {
if (priv->ip_iface) {
/* The device now has a @ip_iface different from the
* @iface on which we previously set the zone. */
@@ -18628,14 +18627,14 @@ set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *ps
managed = g_value_get_boolean(value);
if (managed) {
reason = NM_DEVICE_STATE_REASON_CONNECTION_ASSUMED;
if (NM_IN_SET_TYPED(NMDeviceSysIfaceState,
priv->sys_iface_state,
NM_DEVICE_SYS_IFACE_STATE_EXTERNAL,
NM_DEVICE_SYS_IFACE_STATE_REMOVED))
nm_device_sys_iface_state_set(self, NM_DEVICE_SYS_IFACE_STATE_ASSUME);
if (NM_IN_SET_TYPED(NMDeviceManagedType,
priv->managed_type,
NM_DEVICE_MANAGED_TYPE_EXTERNAL,
NM_DEVICE_MANAGED_TYPE_REMOVED))
nm_device_managed_type_set(self, NM_DEVICE_MANAGED_TYPE_ASSUME);
} else {
reason = NM_DEVICE_STATE_REASON_REMOVED;
nm_device_sys_iface_state_set(self, NM_DEVICE_SYS_IFACE_STATE_REMOVED);
nm_device_managed_type_set(self, NM_DEVICE_MANAGED_TYPE_REMOVED);
}
nm_device_set_unmanaged_by_flags(self, NM_UNMANAGED_USER_EXPLICIT, !managed, reason);
}
@@ -18723,10 +18722,10 @@ nm_device_init(NMDevice *self)
priv->available_connections = g_hash_table_new_full(nm_direct_hash, NULL, g_object_unref, NULL);
priv->ip6_saved_properties = g_hash_table_new_full(nm_str_hash, g_str_equal, NULL, g_free);
priv->sys_iface_state_ = NM_DEVICE_SYS_IFACE_STATE_EXTERNAL;
priv->managed_type_ = NM_DEVICE_MANAGED_TYPE_EXTERNAL;
/* If networking is already disabled at boot, we want to manage all devices
* after re-enabling networking; hence, the initial state is MANAGED. */
priv->sys_iface_state_before_sleep = NM_DEVICE_SYS_IFACE_STATE_MANAGED;
priv->managed_type_before_sleep = NM_DEVICE_MANAGED_TYPE_MANAGED;
priv->promisc_reset = NM_OPTION_BOOL_DEFAULT;
}

10
src/core/devices/nm-device.h
View File

@@ -726,16 +726,16 @@ nm_device_autoconnect_blocked_unset(NMDevice *device, NMDeviceAutoconnectBlocked
void nm_device_recheck_auto_activate_schedule(NMDevice *device);
NMDeviceSysIfaceState nm_device_sys_iface_state_get(NMDevice *device);
NMDeviceManagedType nm_device_managed_type_get(NMDevice *device);
gboolean nm_device_sys_iface_state_is_external(NMDevice *self);
gboolean nm_device_sys_iface_state_is_external_or_assume(NMDevice *self);
gboolean nm_device_managed_type_is_external(NMDevice *self);
gboolean nm_device_managed_type_is_external_or_assume(NMDevice *self);
void nm_device_sys_iface_state_set(NMDevice *device, NMDeviceSysIfaceState sys_iface_state);
void nm_device_managed_type_set(NMDevice *device, NMDeviceManagedType managed_type);
void nm_device_notify_sleeping(NMDevice *self);
NMDeviceSysIfaceState nm_device_get_sys_iface_state_before_sleep(NMDevice *self);
NMDeviceManagedType nm_device_get_managed_type_before_sleep(NMDevice *self);
void nm_device_state_changed(NMDevice *device, NMDeviceState state, NMDeviceStateReason reason);

6
src/core/devices/ovs/nm-device-ovs-port.c
View File

@@ -218,9 +218,9 @@ detach_port(NMDevice *device,
gpointer user_data)
{
NMDeviceOvsPort *self = NM_DEVICE_OVS_PORT(device);
bool port_not_managed = !NM_IN_SET(nm_device_sys_iface_state_get(port),
NM_DEVICE_SYS_IFACE_STATE_MANAGED,
NM_DEVICE_SYS_IFACE_STATE_ASSUME);
bool port_not_managed = !NM_IN_SET(nm_device_managed_type_get(port),
NM_DEVICE_MANAGED_TYPE_MANAGED,
NM_DEVICE_MANAGED_TYPE_ASSUME);
NMTernary ret = TRUE;
_LOGI(LOGD_DEVICE, "detaching ovs interface %s", nm_device_get_ip_iface(port));

6
src/core/devices/team/nm-device-team.c
View File

@@ -763,10 +763,10 @@ act_stage1_prepare(NMDevice *device, NMDeviceStateReason *out_failure_reason)
NMSettingTeam *s_team;
const char *cfg;
if (nm_device_sys_iface_state_is_external(device))
if (nm_device_managed_type_is_external(device))
return NM_ACT_STAGE_RETURN_SUCCESS;
if (nm_device_sys_iface_state_is_external_or_assume(device)) {
if (nm_device_managed_type_is_external_or_assume(device)) {
if (ensure_teamd_connection(device, &error))
return NM_ACT_STAGE_RETURN_SUCCESS;
_LOGD(LOGD_TEAM, "could not connect to teamd: %s", error->message);
@@ -832,7 +832,7 @@ deactivate(NMDevice *device)
priv->stage1_state = NM_DEVICE_STAGE_STATE_INIT;
if (nm_device_sys_iface_state_is_external(device))
if (nm_device_managed_type_is_external(device))
return;
if (priv->teamd_pid || priv->tdc)

8
src/core/nm-active-connection.c
View File

@@ -989,10 +989,10 @@ _set_activation_type_managed(NMActiveConnection *self)
_set_activation_type(self, NM_ACTIVATION_TYPE_MANAGED);
if (priv->device && self == NM_ACTIVE_CONNECTION(nm_device_get_act_request(priv->device))
&& NM_IN_SET(nm_device_sys_iface_state_get(priv->device),
NM_DEVICE_SYS_IFACE_STATE_EXTERNAL,
NM_DEVICE_SYS_IFACE_STATE_ASSUME))
nm_device_sys_iface_state_set(priv->device, NM_DEVICE_SYS_IFACE_STATE_MANAGED);
&& NM_IN_SET(nm_device_managed_type_get(priv->device),
NM_DEVICE_MANAGED_TYPE_EXTERNAL,
NM_DEVICE_MANAGED_TYPE_ASSUME))
nm_device_managed_type_set(priv->device, NM_DEVICE_MANAGED_TYPE_MANAGED);
}
NMActivationReason

2
src/core/nm-l3cfg.h
View File

@@ -354,7 +354,7 @@ gboolean nm_l3cfg_remove_config_all_dirty(NML3Cfg *self, gconstpointer tag);
* nm_l3cfg_commit_type_register(). nm_l3cfg_commit_on_idle_schedule() also
* accepts a one-time commit-type argument.
*
* This is related to NMDevice's sys_iface_state, which we use to control whether
* This is related to NMDevice's managed_type, which we use to control whether
* to touch/assume/manage the interface.
*
* The numeric values of the enum matters: higher number mean more "important".

24
src/core/nm-manager.c
View File

@@ -2309,7 +2309,7 @@ remove_device(NMManager *self, NMDevice *device, gboolean quitting)
if (quitting)
nm_device_set_unmanaged_by_quitting(device);
else {
nm_device_sys_iface_state_set(device, NM_DEVICE_SYS_IFACE_STATE_REMOVED);
nm_device_managed_type_set(device, NM_DEVICE_MANAGED_TYPE_REMOVED);
nm_device_set_unmanaged_by_flags(device,
NM_UNMANAGED_PLATFORM_INIT,
NM_UNMAN_FLAG_OP_SET_UNMANAGED,
@@ -3694,9 +3694,9 @@ recheck_assume_connection(NMManager *self, NMDevice *device)
}
}
nm_device_sys_iface_state_set(device,
activation_type_assume ? NM_DEVICE_SYS_IFACE_STATE_ASSUME
: NM_DEVICE_SYS_IFACE_STATE_EXTERNAL);
nm_device_managed_type_set(device,
activation_type_assume ? NM_DEVICE_MANAGED_TYPE_ASSUME
: NM_DEVICE_MANAGED_TYPE_EXTERNAL);
/* Move device to DISCONNECTED to activate the connection */
if (state == NM_DEVICE_STATE_UNMANAGED) {
@@ -3765,8 +3765,8 @@ recheck_assume_connection(NMManager *self, NMDevice *device)
"assume: deleting generated connection after assuming failed");
nm_settings_connection_delete(sett_conn, FALSE);
} else {
if (nm_device_sys_iface_state_get(device) == NM_DEVICE_SYS_IFACE_STATE_ASSUME)
nm_device_sys_iface_state_set(device, NM_DEVICE_SYS_IFACE_STATE_EXTERNAL);
if (nm_device_managed_type_get(device) == NM_DEVICE_MANAGED_TYPE_ASSUME)
nm_device_managed_type_set(device, NM_DEVICE_MANAGED_TYPE_EXTERNAL);
}
return FALSE;
}
@@ -4374,7 +4374,7 @@ _platform_link_cb_idle(PlatformLinkCbData *data)
device = nm_manager_get_device_by_ifindex(self, ifindex);
if (device) {
if (nm_device_is_software(device)) {
nm_device_sys_iface_state_set(device, NM_DEVICE_SYS_IFACE_STATE_REMOVED);
nm_device_managed_type_set(device, NM_DEVICE_MANAGED_TYPE_REMOVED);
if (!nm_device_unrealize(device, FALSE, &error)) {
_LOG2W(LOGD_DEVICE, device, "failed to unrealize: %s", error->message);
g_clear_error(&error);
@@ -5768,7 +5768,7 @@ _internal_activate_device(NMManager *self, NMActiveConnection *active, GError **
}
if (nm_active_connection_get_activation_type(active) == NM_ACTIVATION_TYPE_MANAGED)
nm_device_sys_iface_state_set(device, NM_DEVICE_SYS_IFACE_STATE_MANAGED);
nm_device_managed_type_set(device, NM_DEVICE_MANAGED_TYPE_MANAGED);
/* Try to find the controller connection/device if the connection has a dependency */
if (!find_controller(self,
@@ -7404,11 +7404,11 @@ do_sleep_wake(NMManager *self, gboolean sleeping_changed)
nm_device_set_enabled(device, enabled);
}
/* The reason determines whether the device will be sys-iface-state=managed
* or sys-iface-state=external. Pass the correct reason to restore the state
/* The reason determines whether the device will be managed_type=managed
* or managed_type=external. Pass the correct reason to restore the state
* that was set before sleeping. */
reason = nm_device_get_sys_iface_state_before_sleep(device)
== NM_DEVICE_SYS_IFACE_STATE_EXTERNAL
reason =
nm_device_get_managed_type_before_sleep(device) == NM_DEVICE_MANAGED_TYPE_EXTERNAL
? NM_DEVICE_STATE_REASON_CONNECTION_ASSUMED
: NM_DEVICE_STATE_REASON_NOW_MANAGED;
nm_device_set_unmanaged_by_flags(device,

14
src/core/nm-policy.c
View File

@@ -429,7 +429,7 @@ get_best_active_connection(NMPolicy *self, int addr_family, gboolean fully_activ
if (state <= NM_DEVICE_STATE_DISCONNECTED || state >= NM_DEVICE_STATE_DEACTIVATING)
continue;
if (nm_device_sys_iface_state_is_external(device))
if (nm_device_managed_type_is_external(device))
continue;
r = nm_device_get_best_default_route(device, addr_family);
@@ -482,7 +482,7 @@ any_devices_active(NMPolicy *self)
state = nm_device_get_state(device);
if (state <= NM_DEVICE_STATE_DISCONNECTED || state >= NM_DEVICE_STATE_DEACTIVATING)
continue;
if (nm_device_sys_iface_state_is_external(device))
if (nm_device_managed_type_is_external(device))
continue;
return TRUE;
}
@@ -809,7 +809,7 @@ build_device_hostname_infos(NMPolicy *self)
if (!device)
continue;
if (nm_device_sys_iface_state_is_external(device))
if (nm_device_managed_type_is_external(device))
continue;
only_from_default =
@@ -1307,7 +1307,7 @@ update_ip_dns(NMPolicy *self, int addr_family, NMDevice *changed_device)
/* Tell the DNS manager this config is preferred by re-adding it with
* a different IP config type.
*/
if (device && nm_device_sys_iface_state_is_external(device))
if (device && nm_device_managed_type_is_external(device))
ip_config_type = NM_DNS_IP_CONFIG_TYPE_REMOVED;
else if (vpn || (device && nm_device_is_vpn(device)))
ip_config_type = NM_DNS_IP_CONFIG_TYPE_VPN;
@@ -1447,7 +1447,7 @@ _auto_activate_device(NMPolicy *self, NMDevice *device)
// deactivate the device and activate the new connection instead of just
// bailing if the device is already active
if (nm_device_get_act_request(device)) {
if (nm_device_sys_iface_state_is_external(device)
if (nm_device_managed_type_is_external(device)
&& nm_device_get_allow_autoconnect_on_external(device)) {
/* this is an external activation, and we allow autoconnecting on
* top of that.
@@ -1781,7 +1781,7 @@ nm_policy_device_recheck_auto_activate_schedule(NMPolicy *self, NMDevice *device
nm_manager_for_each_active_connection (priv->manager, ac, tmp_list) {
if (nm_active_connection_get_device(ac) == device) {
if (nm_device_sys_iface_state_is_external(device)
if (nm_device_managed_type_is_external(device)
&& nm_device_get_allow_autoconnect_on_external(device)) {
/* pass */
} else
@@ -2300,7 +2300,7 @@ device_state_changed(NMDevice *device,
* again when the device becomes ACTIVATED, we need also to update
* routing and DNS here. */
nm_dns_manager_begin_updates(priv->dns_manager, __func__);
if (!nm_device_sys_iface_state_is_external(device)) {
if (!nm_device_managed_type_is_external(device)) {
nm_dns_manager_set_ip_config(priv->dns_manager,
AF_UNSPEC,
device,