UDisksCleanup: Nuke error handling from user-level API

Signed-off-by: David Zeuthen <davidz@redhat.com>

diff --git a/src/udiskscleanup.c b/src/udiskscleanup.c
index b6d4e8f..fe2bba8 100644 (file)
--- a/src/udiskscleanup.c
+++ b/src/udiskscleanup.c
@@ -737,54 +737,41 @@ udisks_cleanup_check_mounted_fs (UDisksCleanup *cleanup,
  * @mount_point: The mount point.
  * @uid: The user id of the process requesting the device to be mounted.
  * @fstab_mount: %TRUE if the device was mounted via /etc/fstab.
- * @error: Return location for error or %NULL.
  *
  * Adds a new entry to the
  * <filename>/var/lib/udisks2/mounted-fs</filename> file.
- *
- * Returns: %TRUE if the entry was added, %FALSE if @error is set.
  */
-gboolean
+void
 udisks_cleanup_add_mounted_fs (UDisksCleanup  *cleanup,
                                const gchar    *mount_point,
                                dev_t           block_device,
                                uid_t           uid,
-                               gboolean        fstab_mount,
-                               GError        **error)
+                               gboolean        fstab_mount)
 {
-  gboolean ret;
   GVariant *value;
   GVariant *new_value;
   GVariant *details_value;
   GVariantBuilder builder;
   GVariantBuilder details_builder;
-  GError *local_error;
+  GError *error;
 
-  g_return_val_if_fail (UDISKS_IS_CLEANUP (cleanup), FALSE);
-  g_return_val_if_fail (mount_point != NULL, FALSE);
-  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+  g_return_if_fail (UDISKS_IS_CLEANUP (cleanup));
+  g_return_if_fail (mount_point != NULL);
 
   g_mutex_lock (&cleanup->lock);
 
-  ret = FALSE;
-
   /* load existing entries */
-  local_error = NULL;
+  error = NULL;
   value = udisks_persistent_store_get (cleanup->persistent_store,
                                        UDISKS_PERSISTENT_FLAGS_NORMAL_STORE,
                                        "mounted-fs",
                                        G_VARIANT_TYPE ("a{sa{sv}}"),
-                                       &local_error);
-  if (local_error != NULL)
+                                       &error);
+  if (error != NULL)
     {
-      g_set_error (error,
-                   UDISKS_ERROR,
-                   UDISKS_ERROR_FAILED,
-                   "Error getting mounted-fs: %s (%s, %d)",
-                   local_error->message,
-                   g_quark_to_string (local_error->domain),
-                   local_error->code);
-      g_error_free (local_error);
+      udisks_warning ("Error getting mounted-fs: %s (%s, %d)",
+                      error->message, g_quark_to_string (error->domain), error->code);
+      g_error_free (error);
       goto out;
     }
 
@@ -828,30 +815,22 @@ udisks_cleanup_add_mounted_fs (UDisksCleanup  *cleanup,
   new_value = g_variant_builder_end (&builder);
 
   /* save new entries */
-  local_error = NULL;
+  error = NULL;
   if (!udisks_persistent_store_set (cleanup->persistent_store,
                                     UDISKS_PERSISTENT_FLAGS_NORMAL_STORE,
                                     "mounted-fs",
                                     G_VARIANT_TYPE ("a{sa{sv}}"),
                                     new_value, /* consumes new_value */
-                                    &local_error))
+                                    &error))
     {
-      g_set_error (error,
-                   UDISKS_ERROR,
-                   UDISKS_ERROR_FAILED,
-                   "Error setting mounted-fs: %s (%s, %d)",
-                   local_error->message,
-                   g_quark_to_string (local_error->domain),
-                   local_error->code);
-      g_error_free (local_error);
+      udisks_warning ("Error setting mounted-fs: %s (%s, %d)",
+                      error->message, g_quark_to_string (error->domain), error->code);
+      g_error_free (error);
       goto out;
     }
 
-  ret = TRUE;
-
  out:
   g_mutex_unlock (&cleanup->lock);
-  return ret;
 }
 
 /**
@@ -860,27 +839,23 @@ udisks_cleanup_add_mounted_fs (UDisksCleanup  *cleanup,
  * @block_device: The block device.
  * @out_uid: Return location for the user id who mounted the device or %NULL.
  * @out_fstab_mount: Return location for whether the device was a fstab mount or %NULL.
- * @error: Return location for error or %NULL.
  *
  * Gets the mount point for @block_device, if it exists in the
  * <filename>/var/lib/udisks2/mounted-fs</filename> file.
  *
- * Returns: The mount point for @block_device or %NULL if not found or
- * if @error is set.
+ * Returns: The mount point for @block_device or %NULL if not found.
  */
 gchar *
 udisks_cleanup_find_mounted_fs (UDisksCleanup   *cleanup,
                                 dev_t            block_device,
                                 uid_t           *out_uid,
-                                gboolean        *out_fstab_mount,
-                                GError         **error)
+                                gboolean        *out_fstab_mount)
 {
   gchar *ret;
   GVariant *value;
-  GError *local_error;
+  GError *error;
 
   g_return_val_if_fail (UDISKS_IS_CLEANUP (cleanup), NULL);
-  g_return_val_if_fail (error == NULL || *error == NULL, NULL);
 
   g_mutex_lock (&cleanup->lock);
 
@@ -888,22 +863,17 @@ udisks_cleanup_find_mounted_fs (UDisksCleanup   *cleanup,
   value = NULL;
 
   /* load existing entries */
-  local_error = NULL;
+  error = NULL;
   value = udisks_persistent_store_get (cleanup->persistent_store,
                                        UDISKS_PERSISTENT_FLAGS_NORMAL_STORE,
                                        "mounted-fs",
                                        G_VARIANT_TYPE ("a{sa{sv}}"),
-                                       &local_error);
-  if (local_error != NULL)
+                                       &error);
+  if (error != NULL)
     {
-      g_set_error (error,
-                   UDISKS_ERROR,
-                   UDISKS_ERROR_FAILED,
-                   "Error getting mounted-fs: %s (%s, %d)",
-                   local_error->message,
-                   g_quark_to_string (local_error->domain),
-                   local_error->code);
-      g_error_free (local_error);
+      udisks_warning ("Error getting mounted-fs: %s (%s, %d)",
+                      error->message, g_quark_to_string (error->domain), error->code);
+      g_error_free (error);
       goto out;
     }
 
@@ -1227,54 +1197,41 @@ udisks_cleanup_check_unlocked_luks (UDisksCleanup *cleanup,
  * @crypto_device: The crypto device.
  * @dm_uuid: The UUID of the unlocked dm device.
  * @uid: The user id of the process requesting the device to be unlocked.
- * @error: Return location for error or %NULL.
  *
  * Adds a new entry to the
  * <filename>/run/udisks2/unlocked-luks</filename> file.
- *
- * Returns: %TRUE if the entry was added, %FALSE if @error is set.
  */
-gboolean
+void
 udisks_cleanup_add_unlocked_luks (UDisksCleanup  *cleanup,
                                   dev_t           cleartext_device,
                                   dev_t           crypto_device,
                                   const gchar    *dm_uuid,
-                                  uid_t           uid,
-                                  GError        **error)
+                                  uid_t           uid)
 {
-  gboolean ret;
   GVariant *value;
   GVariant *new_value;
   GVariant *details_value;
   GVariantBuilder builder;
   GVariantBuilder details_builder;
-  GError *local_error;
+  GError *error;
 
   g_return_val_if_fail (UDISKS_IS_CLEANUP (cleanup), FALSE);
   g_return_val_if_fail (dm_uuid != NULL, FALSE);
-  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
 
   g_mutex_lock (&cleanup->lock);
 
-  ret = FALSE;
-
   /* load existing entries */
-  local_error = NULL;
+  error = NULL;
   value = udisks_persistent_store_get (cleanup->persistent_store,
                                        UDISKS_PERSISTENT_FLAGS_TEMPORARY_STORE,
                                        "unlocked-luks",
                                        G_VARIANT_TYPE ("a{ta{sv}}"),
-                                       &local_error);
-  if (local_error != NULL)
+                                       &error);
+  if (error != NULL)
     {
-      g_set_error (error,
-                   UDISKS_ERROR,
-                   UDISKS_ERROR_FAILED,
-                   "Error getting unlocked-luks: %s (%s, %d)",
-                   local_error->message,
-                   g_quark_to_string (local_error->domain),
-                   local_error->code);
-      g_error_free (local_error);
+      udisks_warning ("Error getting unlocked-luks: %s (%s, %d)",
+                      error->message, g_quark_to_string (error->domain), error->code);
+      g_error_free (error);
       goto out;
     }
 
@@ -1317,30 +1274,22 @@ udisks_cleanup_add_unlocked_luks (UDisksCleanup  *cleanup,
   new_value = g_variant_builder_end (&builder);
 
   /* save new entries */
-  local_error = NULL;
+  error = NULL;
   if (!udisks_persistent_store_set (cleanup->persistent_store,
                                     UDISKS_PERSISTENT_FLAGS_TEMPORARY_STORE,
                                     "unlocked-luks",
                                     G_VARIANT_TYPE ("a{ta{sv}}"),
                                     new_value, /* consumes new_value */
-                                    &local_error))
+                                    &error))
     {
-      g_set_error (error,
-                   UDISKS_ERROR,
-                   UDISKS_ERROR_FAILED,
-                   "Error setting unlocked-luks: %s (%s, %d)",
-                   local_error->message,
-                   g_quark_to_string (local_error->domain),
-                   local_error->code);
-      g_error_free (local_error);
+      udisks_warning ("Error setting unlocked-luks: %s (%s, %d)",
+                      error->message, g_quark_to_string (error->domain), error->code);
+      g_error_free (error);
       goto out;
     }
 
-  ret = TRUE;
-
  out:
   g_mutex_unlock (&cleanup->lock);
-  return ret;
 }
 
 /**
@@ -1348,26 +1297,22 @@ udisks_cleanup_add_unlocked_luks (UDisksCleanup  *cleanup,
  * @cleanup: A #UDisksCleanup.
  * @crypto_device: The block device.
  * @out_uid: Return location for the user id who mounted the device or %NULL.
- * @error: Return location for error or %NULL.
  *
  * Gets the clear-text device for @crypto_device, if it exists in the
  * <filename>/run/udisks2/unlocked-luks</filename> file.
  *
- * Returns: The cleartext device for @crypto_device or 0 if not
- * found or if @error is set.
+ * Returns: The cleartext device for @crypto_device or 0 if not found.
  */
 dev_t
 udisks_cleanup_find_unlocked_luks (UDisksCleanup   *cleanup,
                                    dev_t            crypto_device,
-                                   uid_t           *out_uid,
-                                   GError         **error)
+                                   uid_t           *out_uid)
 {
   dev_t ret;
   GVariant *value;
-  GError *local_error;
+  GError *error;
 
   g_return_val_if_fail (UDISKS_IS_CLEANUP (cleanup), 0);
-  g_return_val_if_fail (error == NULL || *error == NULL, 0);
 
   g_mutex_lock (&cleanup->lock);
 
@@ -1375,22 +1320,17 @@ udisks_cleanup_find_unlocked_luks (UDisksCleanup   *cleanup,
   value = NULL;
 
   /* load existing entries */
-  local_error = NULL;
+  error = NULL;
   value = udisks_persistent_store_get (cleanup->persistent_store,
                                        UDISKS_PERSISTENT_FLAGS_TEMPORARY_STORE,
                                        "unlocked-luks",
                                        G_VARIANT_TYPE ("a{ta{sv}}"),
-                                       &local_error);
-  if (local_error != NULL)
+                                       &error);
+  if (error != NULL)
     {
-      g_set_error (error,
-                   UDISKS_ERROR,
-                   UDISKS_ERROR_FAILED,
-                   "Error getting unlocked-luks: %s (%s, %d)",
-                   local_error->message,
-                   g_quark_to_string (local_error->domain),
-                   local_error->code);
-      g_error_free (local_error);
+      udisks_warning ("Error getting unlocked-luks: %s (%s, %d)",
+                      error->message, g_quark_to_string (error->domain), error->code);
+      g_error_free (error);
       goto out;
     }
 
@@ -1726,55 +1666,42 @@ udisks_cleanup_check_loop (UDisksCleanup *cleanup,
  * @backing_file: The backing file.
  * @backing_file_device: The #dev_t of the backing file.
  * @uid: The user id of the process requesting the loop device.
- * @error: Return location for error or %NULL.
  *
  * Adds a new entry to the <filename>/run/udisks2/loop</filename>
  * file.
- *
- * Returns: %TRUE if the entry was added, %FALSE if @error is set.
  */
-gboolean
+void
 udisks_cleanup_add_loop (UDisksCleanup   *cleanup,
                          const gchar     *device_file,
                          const gchar     *backing_file,
                          dev_t            backing_file_device,
-                         uid_t            uid,
-                         GError         **error)
+                         uid_t            uid)
 {
-  gboolean ret;
   GVariant *value;
   GVariant *new_value;
   GVariant *details_value;
   GVariantBuilder builder;
   GVariantBuilder details_builder;
-  GError *local_error;
+  GError *error;
 
   g_return_val_if_fail (UDISKS_IS_CLEANUP (cleanup), FALSE);
   g_return_val_if_fail (device_file != NULL, FALSE);
   g_return_val_if_fail (backing_file != NULL, FALSE);
-  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
 
   g_mutex_lock (&cleanup->lock);
 
-  ret = FALSE;
-
   /* load existing entries */
-  local_error = NULL;
+  error = NULL;
   value = udisks_persistent_store_get (cleanup->persistent_store,
                                        UDISKS_PERSISTENT_FLAGS_TEMPORARY_STORE,
                                        "loop",
                                        G_VARIANT_TYPE ("a{sa{sv}}"),
-                                       &local_error);
-  if (local_error != NULL)
+                                       &error);
+  if (error != NULL)
     {
-      g_set_error (error,
-                   UDISKS_ERROR,
-                   UDISKS_ERROR_FAILED,
-                   "Error getting loop: %s (%s, %d)",
-                   local_error->message,
-                   g_quark_to_string (local_error->domain),
-                   local_error->code);
-      g_error_free (local_error);
+      udisks_warning ("Error getting loop: %s (%s, %d)",
+                      error->message, g_quark_to_string (error->domain), error->code);
+      g_error_free (error);
       goto out;
     }
 
@@ -1817,30 +1744,22 @@ udisks_cleanup_add_loop (UDisksCleanup   *cleanup,
   new_value = g_variant_builder_end (&builder);
 
   /* save new entries */
-  local_error = NULL;
+  error = NULL;
   if (!udisks_persistent_store_set (cleanup->persistent_store,
                                     UDISKS_PERSISTENT_FLAGS_TEMPORARY_STORE,
                                     "loop",
                                     G_VARIANT_TYPE ("a{sa{sv}}"),
                                     new_value, /* consumes new_value */
-                                    &local_error))
+                                    &error))
     {
-      g_set_error (error,
-                   UDISKS_ERROR,
-                   UDISKS_ERROR_FAILED,
-                   "Error setting loop: %s (%s, %d)",
-                   local_error->message,
-                   g_quark_to_string (local_error->domain),
-                   local_error->code);
-      g_error_free (local_error);
+      udisks_warning ("Error setting loop: %s (%s, %d)",
+                      error->message, g_quark_to_string (error->domain), error->code);
+      g_error_free (error);
       goto out;
     }
 
-  ret = TRUE;
-
  out:
   g_mutex_unlock (&cleanup->lock);
-  return ret;
 }
 
 /**
@@ -1857,15 +1776,13 @@ udisks_cleanup_add_loop (UDisksCleanup   *cleanup,
 gboolean
 udisks_cleanup_has_loop (UDisksCleanup   *cleanup,
                          const gchar     *device_file,
-                         uid_t           *out_uid,
-                         GError         **error)
+                         uid_t           *out_uid)
 {
   gboolean ret;
   GVariant *value;
-  GError *local_error;
+  GError *error;
 
   g_return_val_if_fail (UDISKS_IS_CLEANUP (cleanup), FALSE);
-  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
 
   g_mutex_lock (&cleanup->lock);
 
@@ -1873,22 +1790,17 @@ udisks_cleanup_has_loop (UDisksCleanup   *cleanup,
   value = NULL;
 
   /* load existing entries */
-  local_error = NULL;
+  error = NULL;
   value = udisks_persistent_store_get (cleanup->persistent_store,
                                        UDISKS_PERSISTENT_FLAGS_TEMPORARY_STORE,
                                        "loop",
                                        G_VARIANT_TYPE ("a{sa{sv}}"),
-                                       &local_error);
-  if (local_error != NULL)
+                                       &error);
+  if (error != NULL)
     {
-      g_set_error (error,
-                   UDISKS_ERROR,
-                   UDISKS_ERROR_FAILED,
-                   "Error getting loop: %s (%s, %d)",
-                   local_error->message,
-                   g_quark_to_string (local_error->domain),
-                   local_error->code);
-      g_error_free (local_error);
+      udisks_warning ("Error getting loop: %s (%s, %d)",
+                      error->message, g_quark_to_string (error->domain), error->code);
+      g_error_free (error);
       goto out;
     }
 

diff --git a/src/udiskscleanup.h b/src/udiskscleanup.h
index 127313c..fb0afe4 100644 (file)
--- a/src/udiskscleanup.h
+++ b/src/udiskscleanup.h
@@ -39,45 +39,40 @@ void             udisks_cleanup_check                (UDisksCleanup *cleanup);
 
 /* mounted-fs */
 
-gboolean         udisks_cleanup_add_mounted_fs       (UDisksCleanup   *cleanup,
+void             udisks_cleanup_add_mounted_fs       (UDisksCleanup   *cleanup,
                                                       const gchar     *mount_point,
                                                       dev_t            block_device,
                                                       uid_t            uid,
-                                                      gboolean         fstab_mount,
-                                                      GError         **error);
+                                                      gboolean         fstab_mount);
 
 gchar           *udisks_cleanup_find_mounted_fs      (UDisksCleanup   *cleanup,
                                                       dev_t            block_device,
                                                       uid_t           *out_uid,
-                                                      gboolean        *out_fstab_mount,
-                                                      GError         **error);
+                                                      gboolean        *out_fstab_mount);
 
 /* unlocked-luks */
 
-gboolean         udisks_cleanup_add_unlocked_luks      (UDisksCleanup   *cleanup,
+void             udisks_cleanup_add_unlocked_luks      (UDisksCleanup   *cleanup,
                                                         dev_t            cleartext_device,
                                                         dev_t            crypto_device,
                                                         const gchar     *dm_uuid,
-                                                        uid_t            uid,
-                                                        GError         **error);
+                                                        uid_t            uid);
 
 dev_t            udisks_cleanup_find_unlocked_luks     (UDisksCleanup   *cleanup,
                                                         dev_t            crypto_device,
-                                                        uid_t           *out_uid,
-                                                        GError         **error);
+                                                        uid_t           *out_uid);
 
 /* loop */
 
-gboolean         udisks_cleanup_add_loop      (UDisksCleanup   *cleanup,
+void             udisks_cleanup_add_loop      (UDisksCleanup   *cleanup,
                                                const gchar     *device_file,
                                                const gchar     *backing_file,
                                                dev_t            backing_file_device,
-                                               uid_t            uid,
-                                               GError         **error);
+                                               uid_t            uid);
+
 gboolean         udisks_cleanup_has_loop      (UDisksCleanup   *cleanup,
                                                const gchar     *device_file,
-                                               uid_t           *out_uid,
-                                               GError         **error);
+                                               uid_t           *out_uid);
 
 G_END_DECLS
 

diff --git a/src/udisksdaemonutil.c b/src/udisksdaemonutil.c
index 46f58f1..52c8fad 100644 (file)
--- a/src/udisksdaemonutil.c
+++ b/src/udisksdaemonutil.c
@@ -339,7 +339,7 @@ udisks_daemon_util_setup_by_user (UDisksDaemon *daemon,
   partition = udisks_object_get_partition (object);
 
   /* loop devices */
-  if (udisks_cleanup_has_loop (cleanup, udisks_block_get_device (block), &setup_by_user, NULL))
+  if (udisks_cleanup_has_loop (cleanup, udisks_block_get_device (block), &setup_by_user))
     {
       if (setup_by_user == user)
         {
@@ -373,7 +373,7 @@ udisks_daemon_util_setup_by_user (UDisksDaemon *daemon,
       crypto_block = udisks_object_peek_block (crypto_object);
       if (udisks_cleanup_find_unlocked_luks (cleanup,
                                              udisks_block_get_device_number (crypto_block),
-                                             &setup_by_user, NULL))
+                                             &setup_by_user))
         {
           if (setup_by_user == user)
             {

diff --git a/src/udiskslinuxblock.c b/src/udiskslinuxblock.c
index d1c6a94..a3251bb 100644 (file)
--- a/src/udiskslinuxblock.c
+++ b/src/udiskslinuxblock.c
@@ -1919,13 +1919,11 @@ handle_format (UDisksBlock           *block,
 
       /* update the unlocked-luks file */
       udev_cleartext_device = udisks_linux_block_object_get_device (UDISKS_LINUX_BLOCK_OBJECT (cleartext_object));
-      if (!udisks_cleanup_add_unlocked_luks (cleanup,
-                                             udisks_block_get_device_number (cleartext_block),
-                                             udisks_block_get_device_number (block),
-                                             g_udev_device_get_sysfs_attr (udev_cleartext_device, "dm/uuid"),
-                                             caller_uid,
-                                             &error))
-        goto out;
+      udisks_cleanup_add_unlocked_luks (cleanup,
+                                        udisks_block_get_device_number (cleartext_block),
+                                        udisks_block_get_device_number (block),
+                                        g_udev_device_get_sysfs_attr (udev_cleartext_device, "dm/uuid"),
+                                        caller_uid);
 
       object_to_mkfs = cleartext_object;
       block_to_mkfs = cleartext_block;

diff --git a/src/udiskslinuxencrypted.c b/src/udiskslinuxencrypted.c
index 5061b7f..58177c6 100644 (file)
--- a/src/udiskslinuxencrypted.c
+++ b/src/udiskslinuxencrypted.c
@@ -365,13 +365,11 @@ handle_unlock (UDisksEncrypted        *encrypted,
   udev_cleartext_device = udisks_linux_block_object_get_device (UDISKS_LINUX_BLOCK_OBJECT (cleartext_object));
 
   /* update the unlocked-luks file */
-  if (!udisks_cleanup_add_unlocked_luks (cleanup,
-                                         udisks_block_get_device_number (cleartext_block),
-                                         udisks_block_get_device_number (block),
-                                         g_udev_device_get_sysfs_attr (udev_cleartext_device, "dm/uuid"),
-                                         caller_uid,
-                                         &error))
-    goto out;
+  udisks_cleanup_add_unlocked_luks (cleanup,
+                                    udisks_block_get_device_number (cleartext_block),
+                                    udisks_block_get_device_number (block),
+                                    g_udev_device_get_sysfs_attr (udev_cleartext_device, "dm/uuid"),
+                                    caller_uid);
 
   udisks_encrypted_complete_unlock (encrypted,
                                     invocation,
@@ -466,21 +464,7 @@ handle_lock (UDisksEncrypted        *encrypted,
   error = NULL;
   cleartext_device_from_file = udisks_cleanup_find_unlocked_luks (cleanup,
                                                                   udisks_block_get_device_number (block),
-                                                                  &unlocked_by_uid,
-                                                                  &error);
-  if (error != NULL)
-    {
-      g_dbus_method_invocation_return_error (invocation,
-                                             UDISKS_ERROR,
-                                             UDISKS_ERROR_FAILED,
-                                             "Error when looking for entry `%s' in unlocked-luks: %s (%s, %d)",
-                                             udisks_block_get_device (block),
-                                             error->message,
-                                             g_quark_to_string (error->domain),
-                                             error->code);
-      g_error_free (error);
-      goto out;
-    }
+                                                                  &unlocked_by_uid);
   if (cleartext_device_from_file == 0)
     {
       /* allow locking stuff not mentioned in unlocked-luks, but treat it like root unlocked it */

diff --git a/src/udiskslinuxfilesystem.c b/src/udiskslinuxfilesystem.c
index 7fcc4d7..a0a373a 100644 (file)
--- a/src/udiskslinuxfilesystem.c
+++ b/src/udiskslinuxfilesystem.c
@@ -947,16 +947,11 @@ handle_mount (UDisksFilesystem       *filesystem,
                      caller_uid);
 
       /* update the mounted-fs file */
-      if (!udisks_cleanup_add_mounted_fs (cleanup,
-                                          mount_point_to_use,
-                                          udisks_block_get_device_number (block),
-                                          caller_uid,
-                                          TRUE, /* fstab_mounted */
-                                          &error))
-        {
-          g_dbus_method_invocation_take_error (invocation, error);
-          goto out;
-        }
+      udisks_cleanup_add_mounted_fs (cleanup,
+                                     mount_point_to_use,
+                                     udisks_block_get_device_number (block),
+                                     caller_uid,
+                                     TRUE); /* fstab_mounted */
 
       udisks_filesystem_complete_mount (filesystem, invocation, mount_point_to_use);
       goto out;
@@ -1084,16 +1079,11 @@ handle_mount (UDisksFilesystem       *filesystem,
     }
 
   /* update the mounted-fs file */
-  if (!udisks_cleanup_add_mounted_fs (cleanup,
-                                      mount_point_to_use,
-                                      udisks_block_get_device_number (block),
-                                      caller_uid,
-                                      FALSE, /* fstab_mounted */
-                                      &error))
-    {
-      g_dbus_method_invocation_take_error (invocation, error);
-      goto out;
-    }
+  udisks_cleanup_add_mounted_fs (cleanup,
+                                 mount_point_to_use,
+                                 udisks_block_get_device_number (block),
+                                 caller_uid,
+                                 FALSE); /* fstab_mounted */
 
   udisks_notice ("Mounted %s at %s on behalf of uid %d",
                  udisks_block_get_device (block),
@@ -1254,21 +1244,7 @@ handle_unmount (UDisksFilesystem       *filesystem,
   mount_point = udisks_cleanup_find_mounted_fs (cleanup,
                                                 udisks_block_get_device_number (block),
                                                 &mounted_by_uid,
-                                                &fstab_mounted,
-                                                &error);
-  if (error != NULL)
-    {
-      g_dbus_method_invocation_return_error (invocation,
-                                             UDISKS_ERROR,
-                                             UDISKS_ERROR_FAILED,
-                                             "Error when looking for entry `%s' in mounted-fs: %s (%s, %d)",
-                                             udisks_block_get_device (block),
-                                             error->message,
-                                             g_quark_to_string (error->domain),
-                                             error->code);
-      g_error_free (error);
-      goto out;
-    }
+                                                &fstab_mounted);
   if (mount_point == NULL)
     {
       /* allow unmounting stuff not mentioned in mounted-fs, but treat it like root mounted it */

diff --git a/src/udiskslinuxloop.c b/src/udiskslinuxloop.c
index d36d786..c284139 100644 (file)
--- a/src/udiskslinuxloop.c
+++ b/src/udiskslinuxloop.c
@@ -187,25 +187,10 @@ handle_delete (UDisksLoop             *loop,
       goto out;
     }
 
-  error = NULL;
   if (!udisks_cleanup_has_loop (cleanup,
                                 udisks_block_get_device (block),
-                                &setup_by_uid,
-                                &error))
+                                &setup_by_uid))
     {
-      if (error != NULL)
-        {
-          g_dbus_method_invocation_return_error (invocation,
-                                                 UDISKS_ERROR,
-                                                 UDISKS_ERROR_FAILED,
-                                                 "Error when looking for entry `%s' in loop: %s (%s, %d)",
-                                                 udisks_block_get_device (block),
-                                                 error->message,
-                                                 g_quark_to_string (error->domain),
-                                                 error->code);
-          g_error_free (error);
-          goto out;
-        }
       setup_by_uid = -1;
     }
 

diff --git a/src/udiskslinuxmanager.c b/src/udiskslinuxmanager.c
index c19e7eb..b3986a1 100644 (file)
--- a/src/udiskslinuxmanager.c
+++ b/src/udiskslinuxmanager.c
@@ -417,13 +417,11 @@ handle_loop_setup (UDisksManager          *object,
     }
 
   /* update the loop file */
-  if (!udisks_cleanup_add_loop (udisks_daemon_get_cleanup (manager->daemon),
-                                loop_device,
-                                path,
-                                fd_statbuf.st_dev,
-                                caller_uid,
-                                &error))
-    goto out;
+  udisks_cleanup_add_loop (udisks_daemon_get_cleanup (manager->daemon),
+                           loop_device,
+                           path,
+                           fd_statbuf.st_dev,
+                           caller_uid);
 
   udisks_notice ("Set up loop device %s (backed by %s)",
                  loop_device,