SymbX/ModemManager
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

base-modem: remove support for parallel enable/disable operations

Browse Source 
Follow up changes will introduce support to run exclusive enable and
disable operations, effectively ensuring that only one enabling or
disabling task is processed at any given time, so the support for
completing parallel operations with the same result is no longer
needed.

That logic was anyway flawed, as it did not consider complex cases
like a disable request received between two enable requests, the order
of incoming requests was not maintained.

The main reason for adding the parallel enable/disable operation logic
was for the case where 2 separate users tried to enable the modem at
the same time. In that case, we did not want to run 2 separate
enabling operations from scratch, and completing one would complete
the second one as well. With the new operation lock logic, the same
result is achieved, as the 2nd enabling operation would find the modem
already enabled, if the 1st one succeeded.

This removal is done before introducing the new exclusive operation
support in the enable/disable path in order to make it easier and more
consistent with other operations that will also be included in the
synchronization.
This commit is contained in:
Aleksander Morgado
2024-09-30 07:55:05 +00:00
parent a24a6ee4c5
commit 8e0cbd9c94
1 changed files with 12 additions and 95 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/mm-base-modem.c
+12 -95
View File
@@ -122,10 +122,6 @@ struct _MMBaseModemPrivate {
/* Some audio-capable devices will have a port for audio specifically */
MMPortSerial *audio;
/* Support for parallel enable/disable operations */
GList *enable_tasks;
GList *disable_tasks;
#if defined WITH_QMI
/* QMI ports */
GList *qmi;
@@ -772,31 +768,7 @@ mm_base_modem_disable_finish (MMBaseModem *self,
GAsyncResult *res,
GError **error)
{
return g_task_propagate_boolean (G_TASK (res), error);
}
static void
disable_ready (MMBaseModem *self,
GAsyncResult *res)
{
GError *error = NULL;
GList *l;
GList *disable_tasks;
g_assert (self->priv->disable_tasks);
disable_tasks = self->priv->disable_tasks;
self->priv->disable_tasks = NULL;
MM_BASE_MODEM_GET_CLASS (self)->disable_finish (self, res, &error);
for (l = disable_tasks; l; l = g_list_next (l)) {
if (error)
g_task_return_error (G_TASK (l->data), g_error_copy (error));
else
g_task_return_boolean (G_TASK (l->data), TRUE);
}
g_clear_error (&error);
g_list_free_full (disable_tasks, g_object_unref);
return MM_BASE_MODEM_GET_CLASS (self)->disable_finish (self, res, error);
}
void
@@ -804,27 +776,13 @@ mm_base_modem_disable (MMBaseModem *self,
GAsyncReadyCallback callback,
gpointer user_data)
{
GTask *task;
gboolean run_disable;
g_assert (MM_BASE_MODEM_GET_CLASS (self)->disable != NULL);
g_assert (MM_BASE_MODEM_GET_CLASS (self)->disable_finish != NULL);
/* If the list of disable tasks is empty, we need to run */
run_disable = !self->priv->disable_tasks;
/* Store task */
task = g_task_new (self, self->priv->cancellable, callback, user_data);
self->priv->disable_tasks = g_list_append (self->priv->disable_tasks, task);
if (!run_disable)
return;
MM_BASE_MODEM_GET_CLASS (self)->disable (
self,
self->priv->cancellable,
(GAsyncReadyCallback) disable_ready,
NULL);
callback,
user_data);
}
gboolean
@@ -832,31 +790,7 @@ mm_base_modem_enable_finish (MMBaseModem *self,
GAsyncResult *res,
GError **error)
{
return g_task_propagate_boolean (G_TASK (res), error);
}
static void
enable_ready (MMBaseModem *self,
GAsyncResult *res)
{
GError *error = NULL;
GList *l;
GList *enable_tasks;
g_assert (self->priv->enable_tasks);
enable_tasks = self->priv->enable_tasks;
self->priv->enable_tasks = NULL;
MM_BASE_MODEM_GET_CLASS (self)->enable_finish (self, res, &error);
for (l = enable_tasks; l; l = g_list_next (l)) {
if (error)
g_task_return_error (G_TASK (l->data), g_error_copy (error));
else
g_task_return_boolean (G_TASK (l->data), TRUE);
}
g_clear_error (&error);
g_list_free_full (enable_tasks, g_object_unref);
return MM_BASE_MODEM_GET_CLASS (self)->enable_finish (self, res, error);
}
void
@@ -864,45 +798,30 @@ mm_base_modem_enable (MMBaseModem *self,
GAsyncReadyCallback callback,
gpointer user_data)
{
GTask *task;
gboolean run_enable;
g_assert (MM_BASE_MODEM_GET_CLASS (self)->enable != NULL);
g_assert (MM_BASE_MODEM_GET_CLASS (self)->enable_finish != NULL);
/* If the list of enable tasks is empty, we need to run */
run_enable = !self->priv->enable_tasks;
/* Store task */
task = g_task_new (self, self->priv->cancellable, callback, user_data);
self->priv->enable_tasks = g_list_append (self->priv->enable_tasks, task);
if (!run_enable)
return;
MM_BASE_MODEM_GET_CLASS (self)->enable (
self,
self->priv->cancellable,
(GAsyncReadyCallback) enable_ready,
NULL);
callback,
user_data);
}
gboolean
mm_base_modem_initialize_finish (MMBaseModem *self,
GAsyncResult *res,
GError **error)
mm_base_modem_initialize_finish (MMBaseModem *self,
GAsyncResult *res,
GError **error)
{
return MM_BASE_MODEM_GET_CLASS (self)->initialize_finish (self, res, error);
}
void
mm_base_modem_initialize (MMBaseModem *self,
GAsyncReadyCallback callback,
gpointer user_data)
mm_base_modem_initialize (MMBaseModem *self,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_assert (MM_BASE_MODEM_GET_CLASS (self)->initialize != NULL);
g_assert (MM_BASE_MODEM_GET_CLASS (self)->initialize_finish != NULL);
MM_BASE_MODEM_GET_CLASS (self)->initialize (
self,
self->priv->cancellable,
@@ -2222,8 +2141,6 @@ finalize (GObject *object)
* mm_auth_provider_cancel_for_owner (self->priv->authp, object);
*/
g_assert (!self->priv->enable_tasks);
g_assert (!self->priv->disable_tasks);
g_assert (!self->priv->scheduled_operations);
mm_obj_dbg (self, "completely disposed");