From 07281f21a71fa333288821ad863accfeedfff567 Mon Sep 17 00:00:00 2001

From: Dan Williams <dcbw@redhat.com>

Date: Mon, 9 Dec 2013 12:55:04 -0600

Subject: [PATCH] core: delay startup complete until carrier is found or

 timeout (rh #1034921) (rh #1030583)

---

 src/devices/nm-device.c    | 177 ++++++++++++++++++++++++++++++++++-----------

 src/nm-active-connection.c |   8 ++

 2 files changed, 142 insertions(+), 43 deletions(-)

diff --git a/src/devices/nm-device.c b/src/devices/nm-device.c

index 578ccb0..96a5d44 100644

--- a/src/devices/nm-device.c

+++ b/src/devices/nm-device.c

@@ -184,15 +184,15 @@ typedef struct {

 	gboolean initialized;

 	gboolean in_state_changed;

 	NMDeviceState state;

 	NMDeviceStateReason state_reason;

 	QueuedState   queued_state;

 	guint queued_ip_config_id;

-	guint pending_actions;

+	GArray *pending_actions;

 	char *        udi;

 	char *        path;

 	char *        iface;   /* may change, could be renamed by user */

 	int           ifindex;

 	gboolean      is_software;

 	char *        ip_iface;

@@ -224,14 +224,15 @@ typedef struct {

 	gpointer        act_source6_func;

 	/* Link stuff */

 	guint           link_connected_id;

 	guint           link_disconnected_id;

 	guint           carrier_defer_id;

 	gboolean        carrier;

+	guint           carrier_wait_id;

 	gboolean        ignore_carrier;

 	/* Generic DHCP stuff */

 	NMDHCPManager * dhcp_manager;

 	guint32         dhcp_timeout;

 	GByteArray *    dhcp_anycast_address;

@@ -390,14 +391,15 @@ nm_device_init (NMDevice *self)

 	priv->capabilities = NM_DEVICE_CAP_NM_SUPPORTED;

 	priv->state = NM_DEVICE_STATE_UNMANAGED;

 	priv->state_reason = NM_DEVICE_STATE_REASON_NONE;

 	priv->dhcp_timeout = 0;

 	priv->rfkill_type = RFKILL_TYPE_UNKNOWN;

 	priv->autoconnect = DEFAULT_AUTOCONNECT;

 	priv->available_connections = g_hash_table_new_full (g_direct_hash, g_direct_equal, g_object_unref, NULL);

+	priv->pending_actions = g_array_sized_new (FALSE, TRUE, sizeof (GQuark), 5);

 }

 static void

 update_accept_ra_save (NMDevice *self)

 {

 	NMDevicePrivate *priv;

 	const char *ip_iface;

@@ -1154,14 +1156,20 @@ nm_device_set_carrier (NMDevice *device, gboolean carrier)

 	if (priv->carrier) {

 		nm_log_info (LOGD_DEVICE, "(%s): link connected", iface);

 		if (priv->carrier_defer_id) {

 			g_source_remove (priv->carrier_defer_id);

 			priv->carrier_defer_id = 0;

 		}

 		klass->carrier_changed (device, TRUE);

+

+		if (priv->carrier_wait_id) {

+			g_source_remove (priv->carrier_wait_id);

+			priv->carrier_wait_id = 0;

+			nm_device_remove_pending_action (device, "carrier wait");

+		}

 	} else if (state <= NM_DEVICE_STATE_DISCONNECTED) {

 		nm_log_info (LOGD_DEVICE, "(%s): link disconnected", iface);

 		klass->carrier_changed (device, FALSE);

 	} else {

 		nm_log_info (LOGD_DEVICE, "(%s): link disconnected (deferring action for %d seconds)",

 		             iface, LINK_DISCONNECT_DELAY);

 		priv->carrier_defer_id = g_timeout_add_seconds (LINK_DISCONNECT_DELAY,

@@ -5110,17 +5118,28 @@ nm_device_start_ip_check (NMDevice *self)

 	/* If no ping was started, just advance to SECONDARIES */

 	if (!priv->gw_ping.pid)

 		nm_device_queue_state (self, NM_DEVICE_STATE_SECONDARIES, NM_DEVICE_STATE_REASON_NONE);

 }

 /****************************************************************/

+static gboolean

+carrier_wait_timeout (gpointer user_data)

+{

+	NMDevice *self = NM_DEVICE (user_data);

+

+	NM_DEVICE_GET_PRIVATE (self)->carrier_wait_id = 0;

+	nm_device_remove_pending_action (self, "carrier wait");

+	return G_SOURCE_REMOVE;

+}

+

 gboolean

 nm_device_bring_up (NMDevice *self, gboolean block, gboolean *no_firmware)

 {

+	NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE (self);

 	gboolean success;

 	guint32 tries = 0;

 	g_return_val_if_fail (NM_IS_DEVICE (self), FALSE);

 	if (nm_device_is_up (self))

 		goto out;

@@ -5138,14 +5157,28 @@ nm_device_bring_up (NMDevice *self, gboolean block, gboolean *no_firmware)

 		g_usleep (200);

 	if (!nm_device_is_up (self)) {

 		nm_log_warn (LOGD_HW, "(%s): device not up after timeout!", nm_device_get_iface (self));

 		return FALSE;

 	}

+	/* Devices that support carrier detect must be IFF_UP to report carrier

+	 * changes; so after setting the device IFF_UP we must suppress startup

+	 * complete (via a pending action) until either the carrier turns on, or

+	 * a timeout is reached.

+	 */

+	if (device_has_capability (self, NM_DEVICE_CAP_CARRIER_DETECT)) {

+		if (priv->carrier_wait_id) {

+			g_source_remove (priv->carrier_wait_id);

+			nm_device_remove_pending_action (self, "carrier wait");

+		}

+		priv->carrier_wait_id = g_timeout_add_seconds (5, carrier_wait_timeout, self);

+		nm_device_add_pending_action (self, "carrier wait");

+	}

+

 out:

 	/* Can only get HW address of some devices when they are up */

 	nm_device_update_hw_address (self);

 	_update_ip4_address (self);

 	return TRUE;

 }

@@ -5301,14 +5334,19 @@ dispose (GObject *object)

 	}

 	if (priv->cp_updated_id) {

 	    g_signal_handler_disconnect (priv->con_provider, priv->cp_updated_id);

 	    priv->cp_updated_id = 0;

 	}

+	if (priv->carrier_wait_id) {

+		g_source_remove (priv->carrier_wait_id);

+		priv->carrier_wait_id = 0;

+	}

+

 	g_hash_table_unref (priv->available_connections);

 	priv->available_connections = NULL;

 	activation_source_clear (self, TRUE, AF_INET);

 	activation_source_clear (self, TRUE, AF_INET6);

 	clear_act_request (self);

@@ -5331,14 +5369,17 @@ finalize (GObject *object)

 	if (priv->dhcp_manager)

 		g_object_unref (priv->dhcp_manager);

 	if (priv->fw_manager)

 		g_object_unref (priv->fw_manager);

+	g_array_free (priv->pending_actions, TRUE);

+	priv->pending_actions = NULL;

+

 	g_free (priv->udi);

 	g_free (priv->path);

 	g_free (priv->iface);

 	g_free (priv->ip_iface);

 	g_free (priv->driver);

 	g_free (priv->driver_version);

 	g_free (priv->firmware_version);

@@ -5931,46 +5972,54 @@ nm_device_set_firmware_missing (NMDevice *self, gboolean new_missing)

 gboolean

 nm_device_get_firmware_missing (NMDevice *self)

 {

 	return NM_DEVICE_GET_PRIVATE (self)->firmware_missing;

 }

+#define QUEUED_PREFIX "queued state change to "

+

 static const char *

-state_to_string (NMDeviceState state)

+queued_state_to_string (NMDeviceState state)

 {

 	switch (state) {

 	case NM_DEVICE_STATE_UNMANAGED:

-		return "unmanaged";

+		return QUEUED_PREFIX "unmanaged";

 	case NM_DEVICE_STATE_UNAVAILABLE:

-		return "unavailable";

+		return QUEUED_PREFIX "unavailable";

 	case NM_DEVICE_STATE_DISCONNECTED:

-		return "disconnected";

+		return QUEUED_PREFIX "disconnected";

 	case NM_DEVICE_STATE_PREPARE:

-		return "prepare";

+		return QUEUED_PREFIX "prepare";

 	case NM_DEVICE_STATE_CONFIG:

-		return "config";

+		return QUEUED_PREFIX "config";

 	case NM_DEVICE_STATE_NEED_AUTH:

-		return "need-auth";

+		return QUEUED_PREFIX "need-auth";

 	case NM_DEVICE_STATE_IP_CONFIG:

-		return "ip-config";

+		return QUEUED_PREFIX "ip-config";

 	case NM_DEVICE_STATE_IP_CHECK:

-		return "ip-check";

+		return QUEUED_PREFIX "ip-check";

 	case NM_DEVICE_STATE_SECONDARIES:

-		return "secondaries";

+		return QUEUED_PREFIX "secondaries";

 	case NM_DEVICE_STATE_ACTIVATED:

-		return "activated";

+		return QUEUED_PREFIX "activated";

 	case NM_DEVICE_STATE_DEACTIVATING:

-		return "deactivating";

+		return QUEUED_PREFIX "deactivating";

 	case NM_DEVICE_STATE_FAILED:

-		return "failed";

+		return QUEUED_PREFIX "failed";

 	default:

 		break;

 	}

-	return "unknown";

+	return QUEUED_PREFIX "unknown";

+}

+

+static const char *

+state_to_string (NMDeviceState state)

+{

+	return queued_state_to_string (state) + strlen (QUEUED_PREFIX);

 }

 static const char *

 reason_to_string (NMDeviceStateReason reason)

 {

 	switch (reason) {

 	case NM_DEVICE_STATE_REASON_NONE:

@@ -6083,21 +6132,14 @@ reason_to_string (NMDeviceStateReason reason)

 		return "secondary-connection-failed";

 	default:

 		break;

 	}

 	return "unknown";

 }

-static inline gboolean

-state_implies_pending_action (NMDeviceState state)

-{

-	return (   state >= NM_DEVICE_STATE_PREPARE

-	        && state < NM_DEVICE_STATE_ACTIVATED);

-}

-

 void

 nm_device_state_changed (NMDevice *device,

                          NMDeviceState state,

                          NMDeviceStateReason reason)

 {

 	NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE (device);

 	NMDeviceState old_state;

@@ -6131,18 +6173,14 @@ nm_device_state_changed (NMDevice *device,

 		return;

 	}

 	old_state = priv->state;

 	priv->state = state;

 	priv->state_reason = reason;

-	if (    state_implies_pending_action (state)

-	    && !state_implies_pending_action (old_state))

-		nm_device_add_pending_action (device, "activation");

-

 	nm_log_info (LOGD_DEVICE, "(%s): device state change: %s -> %s (reason '%s') [%d %d %d]",

 	             nm_device_get_iface (device),

 	             state_to_string (old_state),

 	             state_to_string (state),

 	             reason_to_string (reason),

 	             old_state,

 	             state,

@@ -6300,18 +6338,14 @@ nm_device_state_changed (NMDevice *device,

 	if (old_state == NM_DEVICE_STATE_ACTIVATED)

 		nm_dispatcher_call (DISPATCHER_ACTION_DOWN, nm_act_request_get_connection (req), device, NULL, NULL);

 	/* Dispose of the cached activation request */

 	if (req)

 		g_object_unref (req);

-	if (    state_implies_pending_action (old_state)

-	    && !state_implies_pending_action (state))

-		nm_device_remove_pending_action (device, "activation");

-

 	priv->in_state_changed = FALSE;

 }

 static gboolean

 queued_set_state (gpointer user_data)

 {

 	NMDevice *self = NM_DEVICE (user_data);

@@ -6330,15 +6364,15 @@ queued_set_state (gpointer user_data)

 		 */

 		priv->queued_state.id = 0;

 		new_state = priv->queued_state.state;

 		new_reason = priv->queued_state.reason;

 		nm_device_queued_state_clear (self);

 		nm_device_state_changed (self, new_state, new_reason);

-		nm_device_remove_pending_action (self, "queued state change");

+		nm_device_remove_pending_action (self, queued_state_to_string (new_state));

 	} else {

 		g_warn_if_fail (priv->queued_state.state == NM_DEVICE_STATE_UNKNOWN);

 		g_warn_if_fail (priv->queued_state.reason == NM_DEVICE_STATE_REASON_NONE);

 	}

 	return FALSE;

 }

@@ -6349,29 +6383,37 @@ nm_device_queue_state (NMDevice *self,

 {

 	NMDevicePrivate *priv;

 	g_return_if_fail (NM_IS_DEVICE (self));

 	priv = NM_DEVICE_GET_PRIVATE (self);

+	/* "lock" the pending actions so that if there was a previously

+	 * queued action that's about to be cleared, that doesn't drop

+	 * the pending actions to 0 before we add the new pending action.

+	 */

+	nm_device_add_pending_action (self, "queued state lock");

+

 	/* We should only ever have one delayed state transition at a time */

 	if (priv->queued_state.id) {

 		if (priv->queued_state.state == state)

 			return;

 		nm_log_warn (LOGD_DEVICE, "(%s): overwriting previously queued state change to %s (%s)",

 					 nm_device_get_iface (self),

 					 state_to_string (priv->queued_state.state),

 					 reason_to_string (priv->queued_state.reason));

 		nm_device_queued_state_clear (self);

 	}

 	priv->queued_state.state = state;

 	priv->queued_state.reason = reason;

 	priv->queued_state.id = g_idle_add (queued_set_state, self);

-	nm_device_add_pending_action (self, "queued state change");

+	nm_device_add_pending_action (self, queued_state_to_string (state));

+

+	nm_device_remove_pending_action (self, "queued state lock");

 	nm_log_dbg (LOGD_DEVICE, "(%s): queued state change to %s due to %s (id %d)",

 	            nm_device_get_iface (self), state_to_string (state), reason_to_string (reason),

 	            priv->queued_state.id);

 }

 NMDeviceState

@@ -6391,15 +6433,15 @@ nm_device_queued_state_clear (NMDevice *self)

 {

 	NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE (self);

 	if (priv->queued_state.id) {

 		nm_log_dbg (LOGD_DEVICE, "(%s): clearing queued state transition (id %d)",

 		            nm_device_get_iface (self), priv->queued_state.id);

 		g_source_remove (priv->queued_state.id);

-		nm_device_remove_pending_action (self, "queued state change");

+		nm_device_remove_pending_action (self, queued_state_to_string (priv->queued_state.state));

 	}

 	memset (&priv->queued_state, 0, sizeof (priv->queued_state));

 }

 NMDeviceState

 nm_device_get_state (NMDevice *device)

 {

@@ -7102,40 +7144,89 @@ nm_device_set_hw_addr (NMDevice *device, const guint8 *addr,

 	}

 	nm_device_bring_up (device, TRUE, NULL);

 	g_free (mac_str);

 	return success;

 }

+/**

+ * nm_device_add_pending_action():

+ * @device: the #NMDevice to add the pending action to

+ * @action: a static string that identifies the action

+ *

+ * Adds a pending action to the device.

+ */

 void

 nm_device_add_pending_action (NMDevice *device, const char *action)

 {

 	NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE (device);

+	GQuark qaction;

+	guint i;

-	priv->pending_actions++;

-	nm_log_dbg (LOGD_DEVICE, "(%s): add_pending_action (%d): %s",

-	            nm_device_get_iface (device), priv->pending_actions, action);

+	qaction = g_quark_from_static_string (action);

-	if (priv->pending_actions == 1)

+	/* Shouldn't ever add the same pending action twice */

+	for (i = 0; i < priv->pending_actions->len; i++) {

+		if (qaction == g_array_index (priv->pending_actions, GQuark, i)) {

+			nm_log_warn (LOGD_DEVICE, "(%s): add_pending_action (%d): '%s' already added",

+			             nm_device_get_iface (device),

+			             priv->pending_actions->len,

+			             action);

+			g_warn_if_reached ();

+			return;

+		}

+	}

+

+	g_array_prepend_val (priv->pending_actions, qaction);

+	nm_log_dbg (LOGD_DEVICE, "(%s): add_pending_action (%d): '%s'",

+	            nm_device_get_iface (device),

+	            priv->pending_actions->len,

+	            action);

+

+	if (priv->pending_actions->len == 1)

 		g_object_notify (G_OBJECT (device), NM_DEVICE_HAS_PENDING_ACTION);

 }

+/**

+ * nm_device_remove_pending_action():

+ * @device: the #NMDevice to remove the pending action from

+ * @action: a static string that identifies the action

+ *

+ * Removes a pending action previously added by nm_device_add_pending_action().

+ */

 void

 nm_device_remove_pending_action (NMDevice *device, const char *action)

 {

 	NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE (device);

+	GQuark qaction;

+	guint i;

-	priv->pending_actions--;

-	nm_log_dbg (LOGD_DEVICE, "(%s): remove_pending_action (%d): %s",

-	            nm_device_get_iface (device), priv->pending_actions, action);

+	qaction = g_quark_from_static_string (action);

-	if (priv->pending_actions == 0)

-		g_object_notify (G_OBJECT (device), NM_DEVICE_HAS_PENDING_ACTION);

+	/* Shouldn't ever add the same pending action twice */

+	for (i = 0; i < priv->pending_actions->len; i++) {

+		if (qaction == g_array_index (priv->pending_actions, GQuark, i)) {

+			g_array_remove_index_fast (priv->pending_actions, i);

+			nm_log_dbg (LOGD_DEVICE, "(%s): remove_pending_action (%d): '%s'",

+			            nm_device_get_iface (device),

+			            priv->pending_actions->len,

+			            action);

+

+			if (priv->pending_actions->len == 0)

+				g_object_notify (G_OBJECT (device), NM_DEVICE_HAS_PENDING_ACTION);

+			return;

+		}

+	}

+

+	nm_log_warn (LOGD_DEVICE, "(%s): remove_pending_action (%d): '%s' never added",

+	             nm_device_get_iface (device),

+	             priv->pending_actions->len,

+	             action);

 }

 gboolean

 nm_device_has_pending_action (NMDevice *device)

 {

 	NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE (device);

-	return priv->pending_actions > 0;

+	return priv->pending_actions->len > 0;

 }

diff --git a/src/nm-active-connection.c b/src/nm-active-connection.c

index 6a825bc..34f438c 100644

--- a/src/nm-active-connection.c

+++ b/src/nm-active-connection.c

@@ -135,14 +135,20 @@ nm_active_connection_set_state (NMActiveConnection *self,

 	if (   new_state == NM_ACTIVE_CONNECTION_STATE_ACTIVATED

 	    || old_state == NM_ACTIVE_CONNECTION_STATE_ACTIVATED) {

 		nm_settings_connection_update_timestamp (NM_SETTINGS_CONNECTION (priv->connection),

 		                                         (guint64) time (NULL), TRUE);

 	}

+	if (priv->device) {

+		if (   old_state < NM_ACTIVE_CONNECTION_STATE_ACTIVATED

+		    && new_state >= NM_ACTIVE_CONNECTION_STATE_ACTIVATED)

+			nm_device_remove_pending_action (priv->device, "activation");

+	}

+

 	if (priv->state == NM_ACTIVE_CONNECTION_STATE_DEACTIVATED) {

 		/* Device is no longer relevant when deactivated */

 		g_clear_object (&priv->device);

 		g_object_notify (G_OBJECT (self), NM_ACTIVE_CONNECTION_DEVICES);

 	}

 }

@@ -262,8 +268,10 @@ set_property (GObject *object, guint pro

 	case PROP_INT_DEVICE:

 		g_warn_if_fail (priv->device == NULL);

 		priv->device = g_value_dup_object (value);

-		if (priv->device)

+		if (priv->device) {

 			g_warn_if_fail (priv->device != priv->master);

+			nm_device_add_pending_action (priv->device, "activation");

+		}

 		break;

 	case PROP_INT_USER_REQUESTED:

 		priv->user_requested = g_value_get_boolean (value);

-- 

1.8.3.1

From 813ea5995bb5a35c115c46f30eefe18db2886afb Mon Sep 17 00:00:00 2001

From: Thomas Haller <thaller@redhat.com>

Date: Mon, 16 Dec 2013 16:52:36 +0100

Subject: [PATCH 1/2] core: allow dynamic strings for pending action names

Use a GSList of the string values, instead of an array of GQuarks.

Using GQuarks does not allow to add arbitrary strings, because they

would leak the internalized strings.  The next patch will begin

using unique, non-const action strings.

Given the rather small number of expected pending states, a singly

linked list seems appropriate.

Signed-off-by: Thomas Haller <thaller@redhat.com>

(some fixes and simplifications by dcbw based on patch reviews)

---

 src/devices/nm-device.c | 49 +++++++++++++++++++++++++------------------------

 1 file changed, 25 insertions(+), 24 deletions(-)

diff --git a/src/devices/nm-device.c b/src/devices/nm-device.c

index c1c7c69..e4644bf 100644

--- a/src/devices/nm-device.c

+++ b/src/devices/nm-device.c

@@ -184,15 +184,15 @@ typedef struct {

 	gboolean initialized;

 	gboolean in_state_changed;

 	NMDeviceState state;

 	NMDeviceStateReason state_reason;

 	QueuedState   queued_state;

 	guint queued_ip_config_id;

-	GArray *pending_actions;

+	GSList *pending_actions;

 	char *        udi;

 	char *        path;

 	char *        iface;   /* may change, could be renamed by user */

 	int           ifindex;

 	gboolean      is_software;

 	char *        ip_iface;

@@ -391,15 +391,14 @@ nm_device_init (NMDevice *self)

 	priv->capabilities = NM_DEVICE_CAP_NM_SUPPORTED;

 	priv->state = NM_DEVICE_STATE_UNMANAGED;

 	priv->state_reason = NM_DEVICE_STATE_REASON_NONE;

 	priv->dhcp_timeout = 0;

 	priv->rfkill_type = RFKILL_TYPE_UNKNOWN;

 	priv->autoconnect = DEFAULT_AUTOCONNECT;

 	priv->available_connections = g_hash_table_new_full (g_direct_hash, g_direct_equal, g_object_unref, NULL);

-	priv->pending_actions = g_array_sized_new (FALSE, TRUE, sizeof (GQuark), 5);

 }

 static void

 update_accept_ra_save (NMDevice *self)

 {

 	NMDevicePrivate *priv;

 	const char *ip_iface;

@@ -5368,16 +5367,15 @@ finalize (GObject *object)

 	if (priv->dhcp_manager)

 		g_object_unref (priv->dhcp_manager);

 	if (priv->fw_manager)

 		g_object_unref (priv->fw_manager);

-	g_array_free (priv->pending_actions, TRUE);

-	priv->pending_actions = NULL;

+	g_slist_free_full (priv->pending_actions, g_free);

 	g_free (priv->udi);

 	g_free (priv->path);

 	g_free (priv->iface);

 	g_free (priv->ip_iface);

 	g_free (priv->driver);

 	g_free (priv->driver_version);

@@ -7153,78 +7152,80 @@ nm_device_set_hw_addr (NMDevice *device, const guint8 *addr,

  *

  * Adds a pending action to the device.

  */

 void

 nm_device_add_pending_action (NMDevice *device, const char *action)

 {

 	NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE (device);

-	GQuark qaction;

-	guint i;

+	GSList *iter;

+	guint count;

-	qaction = g_quark_from_static_string (action);

+	g_return_if_fail (action);

 	/* Shouldn't ever add the same pending action twice */

-	for (i = 0; i < priv->pending_actions->len; i++) {

-		if (qaction == g_array_index (priv->pending_actions, GQuark, i)) {

+	for (iter = priv->pending_actions; iter; iter = iter->next) {

+		if (!strcmp (action, iter->data)) {

 			nm_log_warn (LOGD_DEVICE, "(%s): add_pending_action (%d): '%s' already added",

 			             nm_device_get_iface (device),

-			             priv->pending_actions->len,

+			             g_slist_length (priv->pending_actions),

 			             action);

-			g_warn_if_reached ();

-			return;

+			g_return_val_if_reached (FALSE);

 		}

 	}

-	g_array_prepend_val (priv->pending_actions, qaction);

+	priv->pending_actions = g_slist_append (priv->pending_actions, g_strdup (action));

+	count = g_slist_length (priv->pending_actions);

+

 	nm_log_dbg (LOGD_DEVICE, "(%s): add_pending_action (%d): '%s'",

 	            nm_device_get_iface (device),

-	            priv->pending_actions->len,

+	            count,

 	            action);

-	if (priv->pending_actions->len == 1)

+	if (count == 1)

 		g_object_notify (G_OBJECT (device), NM_DEVICE_HAS_PENDING_ACTION);

 }

 /**

  * nm_device_remove_pending_action():

  * @device: the #NMDevice to remove the pending action from

  * @action: a static string that identifies the action

  *

  * Removes a pending action previously added by nm_device_add_pending_action().

  */

 void

 nm_device_remove_pending_action (NMDevice *device, const char *action)

 {

 	NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE (device);

-	GQuark qaction;

-	guint i;

+	GSList *iter;

-	qaction = g_quark_from_static_string (action);

+	g_return_if_fail (action);

 	/* Shouldn't ever add the same pending action twice */

-	for (i = 0; i < priv->pending_actions->len; i++) {

-		if (qaction == g_array_index (priv->pending_actions, GQuark, i)) {

-			g_array_remove_index_fast (priv->pending_actions, i);

+	for (iter = priv->pending_actions; iter; iter = iter->next) {

+		if (!strcmp (action, iter->data)) {

+			g_free (iter->data);

+			priv->pending_actions = g_slist_delete_link (priv->pending_actions, iter);

 			nm_log_dbg (LOGD_DEVICE, "(%s): remove_pending_action (%d): '%s'",

 			            nm_device_get_iface (device),

-			            priv->pending_actions->len,

+			            g_slist_length (priv->pending_actions),

 			            action);

-			if (priv->pending_actions->len == 0)

+			if (priv->pending_actions == NULL)

 				g_object_notify (G_OBJECT (device), NM_DEVICE_HAS_PENDING_ACTION);

 			return;

 		}

 	}

 	nm_log_warn (LOGD_DEVICE, "(%s): remove_pending_action (%d): '%s' never added",

 	             nm_device_get_iface (device),

-	             priv->pending_actions->len,

+	             g_slist_length (priv->pending_actions),

 	             action);

+	g_return_if_reached ();

 }

 gboolean

 nm_device_has_pending_action (NMDevice *device)

 {

 	NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE (device);

-	return priv->pending_actions->len > 0;

+	return !!priv->pending_actions;

 }

-- 

1.8.3.1

From b6ef165cfefba44a496cc336e1f91bb93b28f3ff Mon Sep 17 00:00:00 2001

From: Thomas Haller <thaller@redhat.com>

Date: Mon, 16 Dec 2013 15:02:38 +0100

Subject: [PATCH 2/2] core: fix NMActiveConnection to properly add/remove

 pending action "activation"

When a new activation request is received, NetworkManager creates a new

NMActiveConnection to track that request.  The device may already be activated,

in which case NetworkManager stops the old activation and starts the new one,

but both exist in parallel for a short period of time.  If the old

NMActiveConnection is activating and already has a pending 'activation'

action, when the new NMActiveConnection adds its own 'activating' action,

they will clash.  This is fixed by making each NMActiveConnection's activation