| /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ |
| /* |
| * qmi-firmware-update -- Command line tool to update firmware in QMI devices |
| * |
| * This program is free software: you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation, either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program. If not, see <http://www.gnu.org/licenses/>. |
| * |
| * Copyright (C) 2022 VMware, Inc. |
| */ |
| |
| #include "config.h" |
| #include <stdlib.h> |
| #include <gio/gio.h> |
| |
| #if defined WITH_UDEV |
| # error udev found |
| #endif |
| |
| #include "qfu-helpers.h" |
| #include "qfu-helpers-sysfs.h" |
| |
| /******************************************************************************/ |
| |
| static const gchar *tty_subsys_list[] = { "tty", NULL }; |
| static const gchar *cdc_wdm_subsys_list[] = { "usbmisc", "usb", NULL }; |
| |
| static gboolean |
| has_sysfs_attribute (const gchar *path, |
| const gchar *attribute) |
| { |
| g_autofree gchar *aux_filepath = NULL; |
| |
| aux_filepath = g_strdup_printf ("%s/%s", path, attribute); |
| return g_file_test (aux_filepath, G_FILE_TEST_EXISTS); |
| } |
| |
| static gchar * |
| read_sysfs_attribute_as_string (const gchar *path, |
| const gchar *attribute) |
| { |
| g_autofree gchar *aux = NULL; |
| gchar *contents = NULL; |
| |
| aux = g_strdup_printf ("%s/%s", path, attribute); |
| if (g_file_get_contents (aux, &contents, NULL, NULL)) { |
| g_strdelimit (contents, "\r\n", ' '); |
| g_strstrip (contents); |
| } |
| return contents; |
| } |
| |
| static gulong |
| read_sysfs_attribute_as_num (const gchar *path, |
| const gchar *attribute, |
| guint base) |
| { |
| g_autofree gchar *contents = NULL; |
| gulong val = 0; |
| |
| contents = read_sysfs_attribute_as_string (path, attribute); |
| if (contents) |
| val = strtoul (contents, NULL, base); |
| return val; |
| } |
| |
| static gchar * |
| read_sysfs_attribute_link_basename (const gchar *path, |
| const gchar *attribute) |
| { |
| g_autofree gchar *aux_filepath = NULL; |
| g_autofree gchar *canonicalized_path = NULL; |
| |
| aux_filepath = g_strdup_printf ("%s/%s", path, attribute); |
| if (!g_file_test (aux_filepath, G_FILE_TEST_EXISTS)) |
| return NULL; |
| |
| canonicalized_path = realpath (aux_filepath, NULL); |
| return g_path_get_basename (canonicalized_path); |
| } |
| |
| static gboolean |
| get_device_details (const gchar *port_sysfs_path, |
| gchar **out_sysfs_path, |
| QfuHelpersDeviceMode *out_device_mode, |
| guint16 *out_vid, |
| guint16 *out_pid, |
| guint *out_busnum, |
| guint *out_devnum, |
| GError **error) |
| { |
| g_autofree gchar *iter = NULL; |
| g_autofree gchar *physdev_sysfs_path = NULL; |
| gulong aux; |
| |
| if (out_vid) |
| *out_vid = 0; |
| if (out_pid) |
| *out_pid = 0; |
| if (out_busnum) |
| *out_busnum = 0; |
| if (out_devnum) |
| *out_devnum = 0; |
| if (out_sysfs_path) |
| *out_sysfs_path = NULL; |
| if (out_device_mode) |
| *out_device_mode = QFU_HELPERS_DEVICE_MODE_UNKNOWN; |
| |
| iter = realpath (port_sysfs_path, NULL); |
| |
| while (iter && (g_strcmp0 (iter, "/") != 0)) { |
| gchar *parent; |
| |
| /* is this the USB physdev? */ |
| if (has_sysfs_attribute (iter, "idVendor")) { |
| /* stop traversing as soon as the physical device is found */ |
| physdev_sysfs_path = g_steal_pointer (&iter); |
| break; |
| } |
| |
| parent = g_path_get_dirname (iter); |
| g_clear_pointer (&iter, g_free); |
| iter = parent; |
| } |
| |
| if (!physdev_sysfs_path) { |
| g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "couldn't find parent physical USB device"); |
| return FALSE; |
| } |
| |
| if (out_device_mode) { |
| aux = read_sysfs_attribute_as_num (physdev_sysfs_path, "bNumInterfaces", 10); |
| /* QDL download mode has exactly one single USB interface */ |
| if (aux == 1) |
| *out_device_mode = QFU_HELPERS_DEVICE_MODE_DOWNLOAD; |
| else if (aux > 1) |
| *out_device_mode = QFU_HELPERS_DEVICE_MODE_MODEM; |
| } |
| |
| if (out_vid) { |
| aux = read_sysfs_attribute_as_num (physdev_sysfs_path, "idVendor", 16); |
| if (aux <= G_MAXUINT16) |
| *out_vid = (guint16) aux; |
| } |
| |
| if (out_pid) { |
| aux = read_sysfs_attribute_as_num (physdev_sysfs_path, "idProduct", 16); |
| if (aux <= G_MAXUINT16) |
| *out_pid = (guint16) aux; |
| } |
| |
| if (out_busnum) { |
| aux = read_sysfs_attribute_as_num (physdev_sysfs_path, "busnum", 10); |
| if (aux <= G_MAXUINT) |
| *out_busnum = (guint16) aux; |
| } |
| |
| if (out_devnum) { |
| aux = read_sysfs_attribute_as_num (physdev_sysfs_path, "devnum", 10); |
| if (aux <= G_MAXUINT) |
| *out_devnum = (guint16) aux; |
| } |
| |
| if (out_sysfs_path) |
| *out_sysfs_path = g_steal_pointer (&physdev_sysfs_path); |
| |
| return TRUE; |
| } |
| |
| static gboolean |
| get_interface_details (const gchar *port_sysfs_path, |
| gchar **out_driver, |
| GError **error) |
| { |
| g_autofree gchar *iter = NULL; |
| g_autofree gchar *interface_sysfs_path = NULL; |
| |
| if (out_driver) |
| *out_driver = NULL; |
| |
| iter = realpath (port_sysfs_path, NULL); |
| |
| while (iter && (g_strcmp0 (iter, "/") != 0)) { |
| gchar *parent; |
| |
| /* is this the USB interface? */ |
| if (has_sysfs_attribute (iter, "bInterfaceClass")) { |
| /* stop traversing as soon as the physical device is found */ |
| interface_sysfs_path = g_steal_pointer (&iter); |
| break; |
| } |
| |
| parent = g_path_get_dirname (iter); |
| g_clear_pointer (&iter, g_free); |
| iter = parent; |
| } |
| |
| if (!interface_sysfs_path) { |
| g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "couldn't find parent interface USB device"); |
| return FALSE; |
| } |
| |
| if (out_driver) |
| *out_driver = read_sysfs_attribute_link_basename (interface_sysfs_path, "driver"); |
| |
| return TRUE; |
| } |
| |
| /******************************************************************************/ |
| |
| gchar * |
| qfu_helpers_sysfs_find_by_file (GFile *file, |
| GError **error) |
| { |
| const gchar **subsys_list = NULL; |
| g_autofree gchar *physdev_sysfs_path = NULL; |
| g_autofree gchar *found_port_sysfs_path = NULL; |
| g_autofree gchar *basename = NULL; |
| guint i; |
| |
| basename = g_file_get_basename (file); |
| if (!basename) { |
| g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "couldn't get filename"); |
| return NULL; |
| } |
| |
| if (g_str_has_prefix (basename, "tty")) |
| subsys_list = tty_subsys_list; |
| else if (g_str_has_prefix (basename, "cdc-wdm")) |
| subsys_list = cdc_wdm_subsys_list; |
| else { |
| g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "unknown device file type"); |
| return NULL; |
| } |
| |
| for (i = 0; !found_port_sysfs_path && subsys_list[i]; i++) { |
| g_autofree gchar *tmp = NULL; |
| g_autofree gchar *port_sysfs_path = NULL; |
| |
| tmp = g_strdup_printf ("/sys/class/%s/%s", subsys_list[i], basename); |
| |
| port_sysfs_path = realpath (tmp, NULL); |
| if (port_sysfs_path && g_file_test (port_sysfs_path, G_FILE_TEST_EXISTS)) |
| found_port_sysfs_path = g_steal_pointer (&port_sysfs_path); |
| } |
| |
| if (!found_port_sysfs_path) { |
| g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "device not found"); |
| return NULL; |
| } |
| |
| if (!get_device_details (found_port_sysfs_path, |
| &physdev_sysfs_path, NULL, NULL, NULL, NULL, NULL, |
| error)) |
| return NULL; |
| |
| g_debug ("[qfu-sysfs] sysfs path for '%s' found: %s", basename, physdev_sysfs_path); |
| return g_steal_pointer (&physdev_sysfs_path); |
| } |
| |
| /******************************************************************************/ |
| |
| static gboolean |
| device_already_added (GPtrArray *ptr, |
| const gchar *sysfs_path) |
| { |
| guint i; |
| |
| for (i = 0; i < ptr->len; i++) { |
| if (g_strcmp0 (g_ptr_array_index (ptr, i), sysfs_path) == 0) |
| return TRUE; |
| } |
| |
| return FALSE; |
| } |
| |
| static GPtrArray * |
| find_by_device_info_in_subsystem (GPtrArray *sysfs_paths, |
| const gchar *subsystem, |
| guint16 vid, |
| guint16 pid, |
| guint busnum, |
| guint devnum) |
| { |
| g_autofree gchar *subsys_sysfs_path = NULL; |
| g_autoptr(GFile) subsys_sysfs_file = NULL; |
| g_autoptr(GFileEnumerator) direnum = NULL; |
| |
| subsys_sysfs_path = g_strdup_printf ("/sys/class/%s", subsystem); |
| subsys_sysfs_file = g_file_new_for_path (subsys_sysfs_path); |
| direnum = g_file_enumerate_children (subsys_sysfs_file, |
| G_FILE_ATTRIBUTE_STANDARD_NAME, |
| G_FILE_QUERY_INFO_NONE, |
| NULL, |
| NULL); |
| if (direnum) { |
| while (TRUE) { |
| GFileInfo *info = NULL; |
| g_autoptr(GFile) child = NULL; |
| g_autofree gchar *child_path = NULL; |
| guint16 device_vid = 0; |
| guint16 device_pid = 0; |
| guint device_busnum = 0; |
| guint device_devnum = 0; |
| g_autofree gchar *device_sysfs_path = NULL; |
| |
| if (!g_file_enumerator_iterate (direnum, &info, NULL, NULL, NULL) || !info) |
| break; |
| |
| child = g_file_enumerator_get_child (direnum, info); |
| child_path = g_file_get_path (child); |
| if (get_device_details (child_path, |
| &device_sysfs_path, |
| NULL, |
| &device_vid, |
| &device_pid, |
| &device_busnum, |
| &device_devnum, |
| NULL)) { |
| if ((vid == 0 || vid == device_vid) && |
| (pid == 0 || pid == device_pid) && |
| (busnum == 0 || busnum == device_busnum) && |
| (devnum == 0 || devnum == device_devnum) && |
| (!device_already_added (sysfs_paths, device_sysfs_path))) |
| g_ptr_array_add (sysfs_paths, g_steal_pointer (&device_sysfs_path)); |
| } |
| } |
| } |
| |
| return sysfs_paths; |
| } |
| |
| gchar * |
| qfu_helpers_sysfs_find_by_device_info (guint16 vid, |
| guint16 pid, |
| guint busnum, |
| guint devnum, |
| GError **error) |
| { |
| g_autoptr(GPtrArray) sysfs_paths = NULL; |
| g_autoptr(GString) match_str = NULL; |
| guint i; |
| |
| sysfs_paths = g_ptr_array_new_with_free_func (g_free); |
| |
| match_str = g_string_new (""); |
| if (vid != 0) |
| g_string_append_printf (match_str, "vid 0x%04x", vid); |
| if (pid != 0) |
| g_string_append_printf (match_str, "%spid 0x%04x", match_str->len > 0 ? ", " : "", pid); |
| if (busnum != 0) |
| g_string_append_printf (match_str, "%sbus %03u", match_str->len > 0 ? ", " : "", busnum); |
| if (devnum != 0) |
| g_string_append_printf (match_str, "%sdev %03u", match_str->len > 0 ? ", " : "", devnum); |
| g_assert (match_str->len > 0); |
| |
| for (i = 0; tty_subsys_list[i]; i++) |
| sysfs_paths = find_by_device_info_in_subsystem (sysfs_paths, |
| tty_subsys_list[i], |
| vid, pid, busnum, devnum); |
| |
| for (i = 0; cdc_wdm_subsys_list[i]; i++) |
| sysfs_paths = find_by_device_info_in_subsystem (sysfs_paths, |
| cdc_wdm_subsys_list[i], |
| vid, pid, busnum, devnum); |
| |
| for (i = 0; i < sysfs_paths->len; i++) |
| g_debug ("[%s] sysfs path: %s", match_str->str, (gchar *) g_ptr_array_index (sysfs_paths, i)); |
| |
| if (sysfs_paths->len == 0) { |
| g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, |
| "no device found with matching criteria: %s", |
| match_str->str); |
| return NULL; |
| } |
| |
| if (sysfs_paths->len > 1) { |
| g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, |
| "multiple devices (%u) found with matching criteria: %s", |
| sysfs_paths->len, match_str->str); |
| return NULL; |
| } |
| |
| return g_strdup (g_ptr_array_index (sysfs_paths, 0)); |
| } |
| |
| /******************************************************************************/ |
| |
| static GFile * |
| device_matches (GFile *file, |
| QfuHelpersDeviceType type, |
| QfuHelpersDeviceMode mode, |
| const gchar *sysfs_path) |
| { |
| g_autofree gchar *port_sysfs_path = NULL; |
| g_autofree gchar *device_sysfs_path = NULL; |
| g_autofree gchar *device_driver = NULL; |
| g_autofree gchar *device_path = NULL; |
| QfuHelpersDeviceMode device_mode = QFU_HELPERS_DEVICE_MODE_UNKNOWN; |
| |
| port_sysfs_path = g_file_get_path (file); |
| if (!get_device_details (port_sysfs_path, |
| &device_sysfs_path, &device_mode, NULL, NULL, NULL, NULL, |
| NULL)) |
| return NULL; |
| |
| if (!device_sysfs_path) |
| return NULL; |
| |
| if (g_strcmp0 (device_sysfs_path, sysfs_path) != 0) |
| return NULL; |
| |
| if (device_mode != mode) |
| return NULL; |
| |
| if (!get_interface_details (port_sysfs_path, &device_driver, NULL)) |
| return NULL; |
| |
| switch (type) { |
| case QFU_HELPERS_DEVICE_TYPE_TTY: |
| if (g_strcmp0 (device_driver, "qcserial") != 0) |
| return NULL; |
| break; |
| case QFU_HELPERS_DEVICE_TYPE_CDC_WDM: |
| if (g_strcmp0 (device_driver, "qmi_wwan") != 0 && g_strcmp0 (device_driver, "cdc_mbim") != 0) |
| return NULL; |
| break; |
| case QFU_HELPERS_DEVICE_TYPE_LAST: |
| default: |
| g_assert_not_reached (); |
| } |
| |
| device_path = g_strdup_printf ("/dev/%s", g_file_get_basename (file)); |
| return g_file_new_for_path (device_path); |
| } |
| |
| GList * |
| qfu_helpers_sysfs_list_devices (QfuHelpersDeviceType device_type, |
| QfuHelpersDeviceMode device_mode, |
| const gchar *sysfs_path) |
| { |
| const gchar **subsys_list = NULL; |
| guint i; |
| GList *files = NULL; |
| |
| switch (device_type) { |
| case QFU_HELPERS_DEVICE_TYPE_TTY: |
| subsys_list = tty_subsys_list; |
| break; |
| case QFU_HELPERS_DEVICE_TYPE_CDC_WDM: |
| subsys_list = cdc_wdm_subsys_list; |
| break; |
| case QFU_HELPERS_DEVICE_TYPE_LAST: |
| default: |
| g_assert_not_reached (); |
| } |
| |
| for (i = 0; subsys_list[i]; i++) { |
| g_autofree gchar *subsys_sysfs_path = NULL; |
| g_autoptr(GFile) subsys_sysfs_file = NULL; |
| g_autoptr(GFileEnumerator) direnum = NULL; |
| |
| subsys_sysfs_path = g_strdup_printf ("/sys/class/%s", subsys_list[i]); |
| subsys_sysfs_file = g_file_new_for_path (subsys_sysfs_path); |
| direnum = g_file_enumerate_children (subsys_sysfs_file, |
| G_FILE_ATTRIBUTE_STANDARD_NAME, |
| G_FILE_QUERY_INFO_NONE, |
| NULL, |
| NULL); |
| if (!direnum) |
| continue; |
| |
| while (TRUE) { |
| GFileInfo *info = NULL; |
| g_autoptr(GFile) child = NULL; |
| g_autoptr(GFile) devfile = NULL; |
| |
| if (!g_file_enumerator_iterate (direnum, &info, NULL, NULL, NULL) || !info) |
| break; |
| |
| child = g_file_enumerator_get_child (direnum, info); |
| devfile = device_matches (child, device_type, device_mode, sysfs_path); |
| if (devfile) |
| files = g_list_prepend (files, g_steal_pointer (&devfile)); |
| } |
| } |
| |
| return files; |
| } |
| |
| /******************************************************************************/ |
| |
| /* Check for the new port addition every 10s */ |
| #define WAIT_FOR_DEVICE_CHECK_SECS 10 |
| |
| /* And up to 12 attempts to check (so 120s in total) */ |
| #define WAIT_FOR_DEVICE_CHECK_ATTEMPTS 12 |
| |
| typedef struct { |
| QfuHelpersDeviceType device_type; |
| QfuHelpersDeviceMode device_mode; |
| gchar *sysfs_path; |
| gchar *peer_port; |
| guint check_attempts; |
| guint timeout_id; |
| gulong cancellable_id; |
| } WaitForDeviceContext; |
| |
| static void |
| wait_for_device_context_free (WaitForDeviceContext *ctx) |
| { |
| g_assert (!ctx->timeout_id); |
| g_assert (!ctx->cancellable_id); |
| |
| g_free (ctx->sysfs_path); |
| g_free (ctx->peer_port); |
| g_slice_free (WaitForDeviceContext, ctx); |
| } |
| |
| GFile * |
| qfu_helpers_sysfs_wait_for_device_finish (GAsyncResult *res, |
| GError **error) |
| { |
| return G_FILE (g_task_propagate_pointer (G_TASK (res), error)); |
| } |
| |
| static GFile * |
| wait_for_device_lookup (QfuHelpersDeviceType device_type, |
| QfuHelpersDeviceMode device_mode, |
| const gchar *sysfs_path, |
| const gchar *peer_port) |
| { |
| GList *devices; |
| GFile *file; |
| |
| devices = qfu_helpers_sysfs_list_devices (device_type, device_mode, sysfs_path); |
| if (!devices) { |
| g_autofree gchar *tmp = NULL; |
| g_autofree gchar *path = NULL; |
| |
| if (!peer_port) |
| return NULL; |
| |
| /* Check with peer port */ |
| tmp = g_build_filename (peer_port, "device", NULL); |
| path = realpath (tmp, NULL); |
| if (path) { |
| g_debug ("[qfu-sysfs] peer lookup: %s => %s", peer_port, path); |
| devices = qfu_helpers_sysfs_list_devices (device_type, device_mode, path); |
| if (!devices) |
| return NULL; |
| } |
| } |
| |
| if (g_list_length (devices) > 1) |
| g_warning ("[qfu-sysfs] waiting device (%s) matched multiple times", |
| qfu_helpers_device_type_to_string (device_type)); |
| |
| /* Take the first one from the list */ |
| file = G_FILE (g_object_ref (devices->data)); |
| g_list_free_full (devices, g_object_unref); |
| |
| return file; |
| } |
| |
| static gboolean |
| wait_for_device_check (GTask *task) |
| { |
| WaitForDeviceContext *ctx; |
| g_autoptr(GFile) device = NULL; |
| g_autofree gchar *device_name = NULL; |
| |
| ctx = (WaitForDeviceContext *) g_task_get_task_data (task); |
| |
| /* Check devices matching */ |
| device = wait_for_device_lookup (ctx->device_type, ctx->device_mode, ctx->sysfs_path, ctx->peer_port); |
| if (!device) { |
| /* No devices found */ |
| if (ctx->check_attempts == WAIT_FOR_DEVICE_CHECK_ATTEMPTS) { |
| /* Disconnect this handler */ |
| ctx->timeout_id = 0; |
| |
| /* Disconnect the other handlers */ |
| g_cancellable_disconnect (g_task_get_cancellable (task), ctx->cancellable_id); |
| ctx->cancellable_id = 0; |
| |
| g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_TIMED_OUT, |
| "waiting for device at '%s' timed out", |
| ctx->sysfs_path); |
| g_object_unref (task); |
| return G_SOURCE_REMOVE; |
| } |
| |
| /* go on with next attempt */ |
| ctx->check_attempts++; |
| return G_SOURCE_CONTINUE; |
| } |
| |
| device_name = g_file_get_basename (device); |
| g_debug ("[qfu-sysfs] waiting device (%s) matched: %s", |
| qfu_helpers_device_type_to_string (ctx->device_type), |
| device_name); |
| |
| /* Disconnect the other handlers */ |
| g_cancellable_disconnect (g_task_get_cancellable (task), ctx->cancellable_id); |
| ctx->cancellable_id = 0; |
| |
| /* Disconnect this handler */ |
| ctx->timeout_id = 0; |
| |
| g_task_return_pointer (task, g_steal_pointer (&device), g_object_unref); |
| g_object_unref (task); |
| |
| return G_SOURCE_REMOVE; |
| } |
| |
| static void |
| wait_for_device_cancelled (GCancellable *cancellable, |
| GTask *task) |
| { |
| WaitForDeviceContext *ctx; |
| |
| ctx = (WaitForDeviceContext *) g_task_get_task_data (task); |
| |
| /* Disconnect this handler */ |
| g_cancellable_disconnect (g_task_get_cancellable (task), ctx->cancellable_id); |
| ctx->cancellable_id = 0; |
| |
| /* Disconnect the other handlers */ |
| g_source_remove (ctx->timeout_id); |
| ctx->timeout_id = 0; |
| |
| g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_CANCELLED, |
| "waiting for device at '%s' cancelled", |
| ctx->sysfs_path); |
| g_object_unref (task); |
| } |
| |
| void |
| qfu_helpers_sysfs_wait_for_device (QfuHelpersDeviceType device_type, |
| QfuHelpersDeviceMode device_mode, |
| const gchar *sysfs_path, |
| const gchar *peer_port, |
| GCancellable *cancellable, |
| GAsyncReadyCallback callback, |
| gpointer user_data) |
| { |
| GTask *task; |
| WaitForDeviceContext *ctx; |
| |
| ctx = g_slice_new0 (WaitForDeviceContext); |
| ctx->device_type = device_type; |
| ctx->device_mode = device_mode; |
| ctx->sysfs_path = g_strdup (sysfs_path); |
| ctx->peer_port = g_strdup (peer_port); |
| |
| task = g_task_new (NULL, cancellable, callback, user_data); |
| g_task_set_task_data (task, ctx, (GDestroyNotify) wait_for_device_context_free); |
| |
| /* Allow cancellation */ |
| ctx->cancellable_id = g_cancellable_connect (cancellable, |
| (GCallback) wait_for_device_cancelled, |
| task, |
| NULL); |
| |
| /* Schedule lookup of of port every once in a while */ |
| ctx->timeout_id = g_timeout_add_seconds (WAIT_FOR_DEVICE_CHECK_SECS, |
| (GSourceFunc) wait_for_device_check, |
| task); |
| |
| /* Note: task ownership is shared between the signals and the timeout */ |
| } |
