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

Merge request !1370 from 'base-manager-shutdown-cleanup'

Browse Source 
base-manager: rename manager/device shutdown to manager/device cleanup

https://gitlab.freedesktop.org/mobile-broadband/ModemManager/-/merge_requests/1370
This commit is contained in:
Dan Williams
2025-06-16 08:34:33 -05:00
parent 04c5c1c31f 7029cdba3e
commit 45d817c50f
3 changed files with 112 additions and 100 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/main.c
+13 -4
View File
@@ -64,10 +64,14 @@ sleeping_cb (MMSleepMonitor *sleep_monitor,
{ {
if (mm_context_get_test_low_power_suspend_resume ()) { if (mm_context_get_test_low_power_suspend_resume ()) {
mm_dbg ("removing devices and setting them in low power mode... (sleeping)"); mm_dbg ("removing devices and setting them in low power mode... (sleeping)");
mm_base_manager_shutdown (manager, TRUE, TRUE, TRUE, ctx); mm_base_manager_cleanup (manager,
MM_BASE_MANAGER_CLEANUP_DISABLE |
MM_BASE_MANAGER_CLEANUP_LOW_POWER |
MM_BASE_MANAGER_CLEANUP_REMOVE,
ctx);
} else { } else {
mm_dbg ("removing devices... (sleeping)"); mm_dbg ("removing devices... (sleeping)");
mm_base_manager_shutdown (manager, FALSE, FALSE, TRUE, ctx); mm_base_manager_cleanup (manager, MM_BASE_MANAGER_CLEANUP_REMOVE, ctx);
} }
} }
@@ -84,7 +88,10 @@ sleeping_quick_cb (MMSleepMonitor *sleep_monitor,
{ {
if (mm_context_get_test_low_power_suspend_resume ()) { if (mm_context_get_test_low_power_suspend_resume ()) {
mm_dbg ("setting modem in low power mode... (sleeping)"); mm_dbg ("setting modem in low power mode... (sleeping)");
mm_base_manager_shutdown (manager, TRUE, TRUE, FALSE, ctx); mm_base_manager_cleanup (manager,
MM_BASE_MANAGER_CLEANUP_DISABLE |
MM_BASE_MANAGER_CLEANUP_LOW_POWER,
ctx);
} else { } else {
/* Don't need to wait for anything; just suspend */ /* Don't need to wait for anything; just suspend */
mm_dbg ("leaving modem powered... (sleeping)"); mm_dbg ("leaving modem powered... (sleeping)");
@@ -268,7 +275,9 @@ main (int argc, char *argv[])
(GCallback)shutdown_done, (GCallback)shutdown_done,
inner); inner);
mm_base_manager_shutdown (manager, TRUE, FALSE, TRUE, ctx); mm_base_manager_cleanup (manager,
MM_BASE_MANAGER_CLEANUP_DISABLE | MM_BASE_MANAGER_CLEANUP_REMOVE,
ctx);
/* Wait for all modems to be disabled and removed, but don't wait /* Wait for all modems to be disabled and removed, but don't wait
* forever: if disabling the modems takes longer than 20s, just * forever: if disabling the modems takes longer than 20s, just
src/mm-base-manager.c
+89 -91
View File
@@ -870,48 +870,41 @@ mm_base_manager_start (MMBaseManager *self,
/*****************************************************************************/ /*****************************************************************************/
typedef enum { typedef enum {
DEVICE_SHUTDOWN_STEP_FIRST = 0, DEVICE_CLEANUP_STEP_FIRST = 0,
DEVICE_SHUTDOWN_STEP_DISABLE, DEVICE_CLEANUP_STEP_DISABLE,
DEVICE_SHUTDOWN_STEP_LOW_POWER, DEVICE_CLEANUP_STEP_LOW_POWER,
DEVICE_SHUTDOWN_STEP_REMOVE, DEVICE_CLEANUP_STEP_REMOVE,
DEVICE_SHUTDOWN_STEP_LAST, DEVICE_CLEANUP_STEP_LAST,
} DeviceShutdownStep; } DeviceCleanupStep;
typedef struct { typedef struct {
MMBaseModem *modem; MMBaseModem *modem;
gboolean disable; MMBaseManagerCleanupFlags flags;
gboolean low_power; DeviceCleanupStep step;
gboolean remove; } DeviceCleanupContext;
DeviceShutdownStep step; static void device_cleanup_step (GTask *task);
} DeviceShutdownContext;
static void device_shutdown_step (GTask *task); static DeviceCleanupContext *
device_cleanup_context_new (MMBaseModem *modem,
static DeviceShutdownContext * MMBaseManagerCleanupFlags flags)
device_shutdown_context_new (MMBaseModem *modem,
gboolean disable,
gboolean low_power,
gboolean remove)
{ {
DeviceShutdownContext *ctx; DeviceCleanupContext *ctx;
ctx = g_slice_new0 (DeviceShutdownContext); ctx = g_slice_new0 (DeviceCleanupContext);
if (modem) if (modem)
ctx->modem = g_object_ref (modem); ctx->modem = g_object_ref (modem);
ctx->step = DEVICE_SHUTDOWN_STEP_FIRST; ctx->step = DEVICE_CLEANUP_STEP_FIRST;
ctx->disable = disable; ctx->flags = flags;
ctx->low_power = low_power;
ctx->remove = remove;
return ctx; return ctx;
} }
static void static void
device_shutdown_context_free (DeviceShutdownContext *ctx) device_cleanup_context_free (DeviceCleanupContext *ctx)
{ {
g_clear_object (&ctx->modem); g_clear_object (&ctx->modem);
g_slice_free (DeviceShutdownContext, ctx); g_slice_free (DeviceCleanupContext, ctx);
} }
static void static void
@@ -919,7 +912,7 @@ modem_remove_ready (MMDevice *device,
GAsyncResult *res, GAsyncResult *res,
GTask *task) GTask *task)
{ {
DeviceShutdownContext *ctx; DeviceCleanupContext *ctx;
g_autoptr(GError) error = NULL; g_autoptr(GError) error = NULL;
ctx = g_task_get_task_data (task); ctx = g_task_get_task_data (task);
@@ -928,15 +921,15 @@ modem_remove_ready (MMDevice *device,
mm_obj_warn (device, "removing modem failed: %s", error->message); mm_obj_warn (device, "removing modem failed: %s", error->message);
ctx->step++; ctx->step++;
device_shutdown_step (task); device_cleanup_step (task);
} }
static void static void
shutdown_low_power_ready (MMIfaceModem *modem, cleanup_low_power_ready (MMIfaceModem *modem,
GAsyncResult *res, GAsyncResult *res,
GTask *task) GTask *task)
{ {
DeviceShutdownContext *ctx; DeviceCleanupContext *ctx;
g_autoptr(GError) error = NULL; g_autoptr(GError) error = NULL;
ctx = g_task_get_task_data (task); ctx = g_task_get_task_data (task);
@@ -945,15 +938,15 @@ shutdown_low_power_ready (MMIfaceModem *modem,
mm_obj_info (modem, "changing to low power state failed: %s", error->message); mm_obj_info (modem, "changing to low power state failed: %s", error->message);
ctx->step++; ctx->step++;
device_shutdown_step (task); device_cleanup_step (task);
} }
static void static void
shutdown_disable_ready (MMBaseModem *modem, cleanup_disable_ready (MMBaseModem *modem,
GAsyncResult *res, GAsyncResult *res,
GTask *task) GTask *task)
{ {
DeviceShutdownContext *ctx; DeviceCleanupContext *ctx;
g_autoptr(GError) error = NULL; g_autoptr(GError) error = NULL;
ctx = g_task_get_task_data (task); ctx = g_task_get_task_data (task);
@@ -966,57 +959,64 @@ shutdown_disable_ready (MMBaseModem *modem,
/* If disabling failed there's no point in trying to low-power the /* If disabling failed there's no point in trying to low-power the
* modem; just remove it. * modem; just remove it.
*/ */
ctx->step = DEVICE_SHUTDOWN_STEP_REMOVE; ctx->step = DEVICE_CLEANUP_STEP_REMOVE;
} }
device_shutdown_step (task); device_cleanup_step (task);
}
static gboolean
has_cleanup_flag (MMBaseManagerCleanupFlags flags,
MMBaseManagerCleanupFlags expected)
{
return flags & expected;
} }
static void static void
device_shutdown_step (GTask *task) device_cleanup_step (GTask *task)
{ {
DeviceShutdownContext *ctx; DeviceCleanupContext *ctx;
MMDevice *device; MMDevice *device;
ctx = g_task_get_task_data (task); ctx = g_task_get_task_data (task);
device = g_task_get_source_object (task); device = g_task_get_source_object (task);
switch (ctx->step) { switch (ctx->step) {
case DEVICE_SHUTDOWN_STEP_FIRST: case DEVICE_CLEANUP_STEP_FIRST:
ctx->step++; ctx->step++;
/* fall through */ /* fall through */
case DEVICE_SHUTDOWN_STEP_DISABLE: case DEVICE_CLEANUP_STEP_DISABLE:
if (ctx->disable && ctx->modem) { if (ctx->modem && has_cleanup_flag (ctx->flags, MM_BASE_MANAGER_CLEANUP_DISABLE)) {
mm_obj_dbg (device, mm_obj_dbg (device,
"disabling modem%d", "disabling modem%d",
mm_base_modem_get_dbus_id (ctx->modem)); mm_base_modem_get_dbus_id (ctx->modem));
mm_base_modem_disable (ctx->modem, mm_base_modem_disable (ctx->modem,
MM_OPERATION_LOCK_REQUIRED, MM_OPERATION_LOCK_REQUIRED,
MM_OPERATION_PRIORITY_OVERRIDE, MM_OPERATION_PRIORITY_OVERRIDE,
(GAsyncReadyCallback)shutdown_disable_ready, (GAsyncReadyCallback)cleanup_disable_ready,
task); task);
return; return;
} }
ctx->step++; ctx->step++;
/* fall through */ /* fall through */
case DEVICE_SHUTDOWN_STEP_LOW_POWER: case DEVICE_CLEANUP_STEP_LOW_POWER:
if (ctx->low_power && ctx->modem) { if (ctx->modem && has_cleanup_flag (ctx->flags, MM_BASE_MANAGER_CLEANUP_LOW_POWER)) {
mm_obj_dbg (device, mm_obj_dbg (device,
"setting modem%d to low-power state", "setting modem%d to low-power state",
mm_base_modem_get_dbus_id (ctx->modem)); mm_base_modem_get_dbus_id (ctx->modem));
mm_iface_modem_set_power_state (MM_IFACE_MODEM (ctx->modem), mm_iface_modem_set_power_state (MM_IFACE_MODEM (ctx->modem),
MM_MODEM_POWER_STATE_LOW, MM_MODEM_POWER_STATE_LOW,
(GAsyncReadyCallback)shutdown_low_power_ready, (GAsyncReadyCallback)cleanup_low_power_ready,
task); task);
return; return;
} }
ctx->step++; ctx->step++;
/* fall through */ /* fall through */
case DEVICE_SHUTDOWN_STEP_REMOVE: case DEVICE_CLEANUP_STEP_REMOVE:
if (ctx->remove && ctx->modem) { if (ctx->modem && has_cleanup_flag (ctx->flags, MM_BASE_MANAGER_CLEANUP_REMOVE)) {
mm_obj_dbg (device, mm_obj_dbg (device,
"removing modem%d", "removing modem%d",
mm_base_modem_get_dbus_id (ctx->modem)); mm_base_modem_get_dbus_id (ctx->modem));
@@ -1028,8 +1028,8 @@ device_shutdown_step (GTask *task)
ctx->step++; ctx->step++;
/* fall through */ /* fall through */
case DEVICE_SHUTDOWN_STEP_LAST: case DEVICE_CLEANUP_STEP_LAST:
mm_obj_dbg (device, "device shutdown complete"); mm_obj_dbg (device, "device cleanup complete");
g_task_return_boolean (task, TRUE); g_task_return_boolean (task, TRUE);
g_object_unref (task); g_object_unref (task);
return; return;
@@ -1046,25 +1046,25 @@ typedef struct {
GSList *tasks; GSList *tasks;
GSList *devices_to_remove; GSList *devices_to_remove;
MMSleepContext *sleep_ctx; MMSleepContext *sleep_ctx;
} ManagerShutdownContext; } ManagerCleanupContext;
static ManagerShutdownContext * static ManagerCleanupContext *
manager_shutdown_context_new (MMBaseManager *self, manager_cleanup_context_new (MMBaseManager *self,
MMSleepContext *sleep_ctx) MMSleepContext *sleep_ctx)
{ {
ManagerShutdownContext *ctx; ManagerCleanupContext *ctx;
ctx = g_slice_new0 (ManagerShutdownContext); ctx = g_slice_new0 (ManagerCleanupContext);
ctx->self = g_object_ref (self); ctx->self = g_object_ref (self);
ctx->sleep_ctx = g_object_ref (sleep_ctx); ctx->sleep_ctx = g_object_ref (sleep_ctx);
return ctx; return ctx;
} }
static void static void
manager_shutdown_context_maybe_complete (ManagerShutdownContext *ctx, manager_cleanup_context_maybe_complete (ManagerCleanupContext *ctx,
GTask *task, GTask *task,
MMDevice *device, MMDevice *device,
gboolean remove) gboolean remove)
{ {
if (task) if (task)
ctx->tasks = g_slist_remove (ctx->tasks, task); ctx->tasks = g_slist_remove (ctx->tasks, task);
@@ -1085,50 +1085,48 @@ manager_shutdown_context_maybe_complete (ManagerShutdownContext *ctx,
g_hash_table_remove (ctx->self->priv->devices, mm_device_get_uid (device)); g_hash_table_remove (ctx->self->priv->devices, mm_device_get_uid (device));
g_slist_free (ctx->devices_to_remove); g_slist_free (ctx->devices_to_remove);
mm_obj_dbg (ctx->self, "shutdown complete"); mm_obj_dbg (ctx->self, "cleanup complete");
mm_sleep_context_complete (ctx->sleep_ctx, NULL); mm_sleep_context_complete (ctx->sleep_ctx, NULL);
g_object_unref (ctx->sleep_ctx); g_object_unref (ctx->sleep_ctx);
g_object_unref (ctx->self); g_object_unref (ctx->self);
g_slice_free (ManagerShutdownContext, ctx); g_slice_free (ManagerCleanupContext, ctx);
} }
} }
static void static void
device_shutdown_ready (MMDevice *device, device_cleanup_ready (MMDevice *device,
GAsyncResult *res, GAsyncResult *res,
ManagerShutdownContext *ctx) ManagerCleanupContext *ctx)
{ {
GTask *task; GTask *task;
DeviceShutdownContext *dctx; DeviceCleanupContext *dctx;
g_autoptr(GError) error = NULL; g_autoptr(GError) error = NULL;
gboolean remove;
task = G_TASK (res); task = G_TASK (res);
if (!g_task_propagate_boolean (task, &error)) { if (!g_task_propagate_boolean (task, &error)) {
mm_obj_info (ctx->self, mm_obj_info (ctx->self,
"failed to shutdown device %s: %s", "failed to cleanup device %s: %s",
mm_device_get_uid (device), mm_device_get_uid (device),
error->message); error->message);
} }
dctx = g_task_get_task_data (task); dctx = g_task_get_task_data (task);
manager_shutdown_context_maybe_complete (ctx, remove = has_cleanup_flag (dctx->flags, MM_BASE_MANAGER_CLEANUP_REMOVE);
task, manager_cleanup_context_maybe_complete (ctx, task, device, remove);
device,
dctx->remove);
} }
void void
mm_base_manager_shutdown (MMBaseManager *self, mm_base_manager_cleanup (MMBaseManager *self,
gboolean disable, MMBaseManagerCleanupFlags flags,
gboolean low_power, MMSleepContext *sleep_ctx)
gboolean remove,
MMSleepContext *sleep_ctx)
{ {
ManagerShutdownContext *ctx; ManagerCleanupContext *ctx;
GHashTableIter iter; GHashTableIter iter;
MMDevice *device; MMDevice *device;
gboolean disable, remove, low_power;
g_return_if_fail (self != NULL); g_return_if_fail (self != NULL);
g_return_if_fail (MM_IS_BASE_MANAGER (self)); g_return_if_fail (MM_IS_BASE_MANAGER (self));
@@ -1136,6 +1134,9 @@ mm_base_manager_shutdown (MMBaseManager *self,
/* Cancel all ongoing auth requests */ /* Cancel all ongoing auth requests */
g_cancellable_cancel (self->priv->authp_cancellable); g_cancellable_cancel (self->priv->authp_cancellable);
disable = has_cleanup_flag (flags, MM_BASE_MANAGER_CLEANUP_DISABLE);
low_power = has_cleanup_flag (flags, MM_BASE_MANAGER_CLEANUP_LOW_POWER);
remove = has_cleanup_flag (flags, MM_BASE_MANAGER_CLEANUP_REMOVE);
mm_obj_dbg (self, mm_obj_dbg (self,
"manager shutting down... (%s%s%s%s%s)", "manager shutting down... (%s%s%s%s%s)",
disable ? "disable" : "", disable ? "disable" : "",
@@ -1144,30 +1145,27 @@ mm_base_manager_shutdown (MMBaseManager *self,
(low_power && remove) ? "," : "", (low_power && remove) ? "," : "",
remove ? "remove" : ""); remove ? "remove" : "");
ctx = manager_shutdown_context_new (self, sleep_ctx); ctx = manager_cleanup_context_new (self, sleep_ctx);
g_hash_table_iter_init (&iter, self->priv->devices); g_hash_table_iter_init (&iter, self->priv->devices);
while (g_hash_table_iter_next (&iter, NULL, (gpointer) &device)) { while (g_hash_table_iter_next (&iter, NULL, (gpointer) &device)) {
DeviceShutdownContext *dctx; DeviceCleanupContext *dctx;
GTask *task; GTask *task;
task = g_task_new (device, task = g_task_new (device,
NULL, NULL,
(GAsyncReadyCallback)device_shutdown_ready, (GAsyncReadyCallback)device_cleanup_ready,
ctx); ctx);
ctx->tasks = g_slist_append (ctx->tasks, task); ctx->tasks = g_slist_append (ctx->tasks, task);
dctx = device_shutdown_context_new (mm_device_peek_modem (device), dctx = device_cleanup_context_new (mm_device_peek_modem (device), flags);
disable, g_task_set_task_data (task, dctx, (GDestroyNotify)device_cleanup_context_free);
low_power,
remove);
g_task_set_task_data (task, dctx, (GDestroyNotify)device_shutdown_context_free);
device_shutdown_step (task); device_cleanup_step (task);
} }
/* Complete shutdown if there were no devices */ /* Complete cleanup if there were no devices */
manager_shutdown_context_maybe_complete (ctx, NULL, NULL, FALSE); manager_cleanup_context_maybe_complete (ctx, NULL, NULL, FALSE);
} }
guint32 guint32
src/mm-base-manager.h
+10 -5
View File
@@ -72,11 +72,16 @@ MMBaseManager *mm_base_manager_new (GDBusConnection *bus,
void mm_base_manager_start (MMBaseManager *manager, void mm_base_manager_start (MMBaseManager *manager,
gboolean manual_scan); gboolean manual_scan);
void mm_base_manager_shutdown (MMBaseManager *manager, typedef enum {
gboolean disable, MM_BASE_MANAGER_CLEANUP_NONE = 0x0,
gboolean power_low, MM_BASE_MANAGER_CLEANUP_DISABLE = 0x1,
gboolean remove, MM_BASE_MANAGER_CLEANUP_LOW_POWER = 0x2,
MMSleepContext *ctx); MM_BASE_MANAGER_CLEANUP_REMOVE = 0x4,
} MMBaseManagerCleanupFlags;
void mm_base_manager_cleanup (MMBaseManager *manager,
MMBaseManagerCleanupFlags flags,
MMSleepContext *ctx);
#if defined WITH_SUSPEND_RESUME #if defined WITH_SUSPEND_RESUME
void mm_base_manager_sync (MMBaseManager *manager); void mm_base_manager_sync (MMBaseManager *manager);