Merge lp:~ubuntu-branches/ubuntu/oneiric/gvfs/oneiric-201109270612 into lp:ubuntu/oneiric/gvfs

[Ubuntu Package Importer]

The package importer has detected a possible inconsistency between the package history in the archive and the history in bzr. As the archive is authoritative the importer has made lp:ubuntu/oneiric/gvfs reflect what is in the archive and the old bzr branch has been pushed to lp:~ubuntu-branches/ubuntu/oneiric/gvfs/oneiric-201109270612. This merge proposal was created so that an Ubuntu developer can review the situations and perform a merge/upload if necessary. There are three typical cases where this can happen.
  1. Where someone pushes a change to bzr and someone else uploads the package without that change. This is the reason that this check is done by the importer. If this appears to be the case then a merge/upload should be done if the changes that were in bzr are still desirable.
  2. The importer incorrectly detected the above situation when someone made a change in bzr and then uploaded it.
  3. The importer incorrectly detected the above situation when someone just uploaded a package and didn't touch bzr.

If this case doesn't appear to be the first situation then set the status of the merge proposal to "Rejected" and help avoid the problem in future by filing a bug at https://bugs.launchpad.net/udd linking to this merge proposal.

(this is an automatically generated message)

Unmerged revisions

173. By Martin Pitt on 2011-09-27

reapply patches

172. By Martin Pitt on 2011-09-27

releasing version 1.10.0-0ubuntu1

171. By Martin Pitt on 2011-09-27

new upstream release 1.10.0

170. By Martin Pitt on 2011-09-27

unapply patches

169. By Martin Pitt on 2011-09-27

clarify changelog

168. By Sebastien Bacher on 2011-09-20

Enable AFP backend

=== added directory '.pc'
=== renamed directory '.pc' => '.pc.moved'
=== added file '.pc/.quilt_patches'
--- .pc/.quilt_patches	1970-01-01 00:00:00 +0000
+++ .pc/.quilt_patches	2011-09-27 06:17:30 +0000
@@ -0,0 +1,1 @@
+debian/patches

=== added file '.pc/.quilt_series'
--- .pc/.quilt_series	1970-01-01 00:00:00 +0000
+++ .pc/.quilt_series	2011-09-27 06:17:30 +0000
@@ -0,0 +1,1 @@
+series

=== added file '.pc/.version'
--- .pc/.version	1970-01-01 00:00:00 +0000
+++ .pc/.version	2011-09-27 06:17:30 +0000
@@ -0,0 +1,1 @@
+2

=== added directory '.pc/03_xdg-mount.patch'
=== added file '.pc/03_xdg-mount.patch/.timestamp'
=== added directory '.pc/03_xdg-mount.patch/monitor'
=== added directory '.pc/03_xdg-mount.patch/monitor/hal'
=== added file '.pc/03_xdg-mount.patch/monitor/hal/ghaldrive.c'
--- .pc/03_xdg-mount.patch/monitor/hal/ghaldrive.c	1970-01-01 00:00:00 +0000
+++ .pc/03_xdg-mount.patch/monitor/hal/ghaldrive.c	2011-09-27 06:17:30 +0000
@@ -0,0 +1,959 @@
+/* GIO - GLib Input, Output and Streaming Library
+ *
+ * Copyright (C) 2006-2007 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Author: David Zeuthen <[e-mail]>
+ */
+
+#include <config.h>
+
+#include <string.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#include <glib.h>
+#include <glib/gi18n-lib.h>
+
+#include "ghalvolumemonitor.h"
+#include "ghaldrive.h"
+#include "ghalvolume.h"
+
+struct _GHalDrive {
+  GObject parent;
+
+  GVolumeMonitor  *volume_monitor; /* owned by volume monitor */
+  GList           *volumes;        /* entries in list are owned by volume_monitor */
+
+  char *name;
+  char *icon;
+  char *device_path;
+
+  gboolean can_eject;
+  gboolean can_poll_for_media;
+  gboolean is_media_check_automatic;
+  gboolean has_media;
+  gboolean uses_removable_media;
+
+  HalDevice *device;
+  HalPool *pool;
+};
+
+static void g_hal_drive_drive_iface_init (GDriveIface *iface);
+
+G_DEFINE_TYPE_EXTENDED (GHalDrive, g_hal_drive, G_TYPE_OBJECT, 0,
+                        G_IMPLEMENT_INTERFACE (G_TYPE_DRIVE,
+                                               g_hal_drive_drive_iface_init))
+
+static void
+g_hal_drive_finalize (GObject *object)
+{
+  GList *l;
+  GHalDrive *drive;
+  
+  drive = G_HAL_DRIVE (object);
+
+  for (l = drive->volumes; l != NULL; l = l->next)
+    {
+      GHalVolume *volume = l->data;
+      g_hal_volume_unset_drive (volume, drive);
+    }
+
+  g_free (drive->device_path);
+  if (drive->device != NULL)
+    g_object_unref (drive->device);
+  if (drive->pool != NULL)
+    g_object_unref (drive->pool);
+
+  g_free (drive->name);
+  g_free (drive->icon);
+
+  if (drive->volume_monitor != NULL)
+    g_object_remove_weak_pointer (G_OBJECT (drive->volume_monitor), (gpointer) &(drive->volume_monitor));
+  
+  if (G_OBJECT_CLASS (g_hal_drive_parent_class)->finalize)
+    (*G_OBJECT_CLASS (g_hal_drive_parent_class)->finalize) (object);
+}
+
+static void
+g_hal_drive_class_init (GHalDriveClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+  gobject_class->finalize = g_hal_drive_finalize;
+}
+
+static void
+g_hal_drive_init (GHalDrive *hal_drive)
+{
+}
+
+static char *
+_drive_get_description (HalDevice *d)
+{
+  char *s = NULL;
+  const char *drive_type;
+  const char *drive_bus;
+  const char *name_from_hal;
+
+  drive_type = hal_device_get_property_string (d, "storage.drive_type");
+  drive_bus = hal_device_get_property_string (d, "storage.bus");
+  name_from_hal = hal_device_get_property_string (d, "info.desktop.name");
+
+  
+  if (strlen (name_from_hal) > 0)
+    {
+      s = g_strdup (name_from_hal);
+    }
+  else if (strcmp (drive_type, "cdrom") == 0)
+    {
+      const char *first;
+      const char *second;
+      
+      first = _("CD-ROM");
+      if (hal_device_get_property_bool (d, "storage.cdrom.cdr"))
+        first = _("CD-R");
+      if (hal_device_get_property_bool (d, "storage.cdrom.cdrw"))
+        first = _("CD-RW");
+      
+      second = NULL;
+      if (hal_device_get_property_bool (d, "storage.cdrom.dvd"))
+        second = _("DVD-ROM");
+      if (hal_device_get_property_bool (d, "storage.cdrom.dvdplusr"))
+        second = _("DVD+R");
+      if (hal_device_get_property_bool (d, "storage.cdrom.dvdplusrw"))
+        second = _("DVD+RW");
+      if (hal_device_get_property_bool (d, "storage.cdrom.dvdr"))
+        second = _("DVD-R");
+      if (hal_device_get_property_bool (d, "storage.cdrom.dvdrw"))
+        second = _("DVD-RW");
+      if (hal_device_get_property_bool (d, "storage.cdrom.dvdram"))
+        second = _("DVD-RAM");
+      if ((hal_device_get_property_bool (d, "storage.cdrom.dvdr")) &&
+          (hal_device_get_property_bool (d, "storage.cdrom.dvdplusr")))
+        second = _("DVD\xc2\xb1R");
+      if (hal_device_get_property_bool (d, "storage.cdrom.dvdrw") &&
+          hal_device_get_property_bool (d, "storage.cdrom.dvdplusrw"))
+        second = _("DVD\xc2\xb1RW");
+      if (hal_device_get_property_bool (d, "storage.cdrom.hddvd"))
+        second = _("HDDVD");
+      if (hal_device_get_property_bool (d, "storage.cdrom.hddvdr"))
+        second = _("HDDVD-r");
+      if (hal_device_get_property_bool (d, "storage.cdrom.hddvdrw"))
+        second = _("HDDVD-RW");
+      if (hal_device_get_property_bool (d, "storage.cdrom.bd"))
+        second = _("Blu-ray");
+      if (hal_device_get_property_bool (d, "storage.cdrom.bdr"))
+        second = _("Blu-ray-R");
+      if (hal_device_get_property_bool (d, "storage.cdrom.bdre"))
+        second = _("Blu-ray-RE");
+      
+      if (second != NULL)
+        {
+          /* translators: This wis something like "CD-ROM/DVD Drive" or
+             "CD-RW/Blue-ray Drive" depending on the properties of the drive */
+          s = g_strdup_printf (_("%s/%s Drive"), first, second);
+        }
+      else
+        {
+          /* translators: This wis something like "CD-ROM Drive" or "CD-RW Drive
+             depending on the properties of the drive */
+          s = g_strdup_printf (_("%s Drive"), first);
+        }
+    } 
+  else if (strcmp (drive_type, "floppy") == 0)
+    s = g_strdup (_("Floppy Drive"));
+  else if (strcmp (drive_type, "disk") == 0)
+    {
+      if (drive_bus != NULL)
+        {
+          if (strcmp (drive_bus, "linux_raid") == 0)
+            s = g_strdup (_("Software RAID Drive"));
+          if (strcmp (drive_bus, "usb") == 0)
+            s = g_strdup (_("USB Drive"));
+          if (strcmp (drive_bus, "ide") == 0)
+            s = g_strdup (_("ATA Drive"));
+          if (strcmp (drive_bus, "scsi") == 0)
+            s = g_strdup (_("SCSI Drive"));
+          if (strcmp (drive_bus, "ieee1394") == 0)
+            s = g_strdup (_("FireWire Drive"));
+        } 
+    } 
+  else if (strcmp (drive_type, "tape") == 0)
+    s = g_strdup (_("Tape Drive"));
+  else if (strcmp (drive_type, "compact_flash") == 0)
+    s = g_strdup (_("CompactFlash Drive"));
+  else if (strcmp (drive_type, "memory_stick") == 0)
+    s = g_strdup (_("MemoryStick Drive"));
+  else if (strcmp (drive_type, "smart_media") == 0)
+    s = g_strdup (_("SmartMedia Drive"));
+  else if (strcmp (drive_type, "sd_mmc") == 0)
+    s = g_strdup (_("SD/MMC Drive"));
+  else if (strcmp (drive_type, "zip") == 0)
+    s = g_strdup (_("Zip Drive"));
+  else if (strcmp (drive_type, "jaz") == 0)
+    s = g_strdup (_("Jaz Drive"));
+  else if (strcmp (drive_type, "flashkey") == 0)
+    s = g_strdup (_("Thumb Drive"));
+
+  if (s == NULL)
+    s = g_strdup (_("Mass Storage Drive"));
+
+  return s;
+}
+
+char *
+_drive_get_icon (HalDevice *d)
+{
+  char *s = NULL;
+  const char *drive_type;
+  const char *drive_bus;
+  const char *icon_from_hal;
+  gboolean is_audio_player;
+
+  drive_type = hal_device_get_property_string (d, "storage.drive_type");
+  drive_bus = hal_device_get_property_string (d, "storage.bus");
+  is_audio_player = hal_device_has_capability (d, "portable_audio_player");
+  icon_from_hal = hal_device_get_property_string (d, "storage.icon.drive");
+
+  if (strlen (icon_from_hal) > 0)
+    s = g_strdup (icon_from_hal);
+  else if (is_audio_player)
+    s = g_strdup ("multimedia-player");
+  else if (strcmp (drive_type, "disk") == 0)
+    {
+      if (strcmp (drive_bus, "ide") == 0)
+        s = g_strdup ("drive-removable-media-ata");
+      else if (strcmp (drive_bus, "scsi") == 0)
+        s = g_strdup ("drive-removable-media-scsi");
+      else if (strcmp (drive_bus, "ieee1394") == 0)
+        s = g_strdup ("drive-removable-media-ieee1394");
+      else if (strcmp (drive_bus, "usb") == 0)
+        s = g_strdup ("drive-removable-media-usb");
+      else
+        s = g_strdup ("drive-removable-media");
+    }
+  else if (strcmp (drive_type, "cdrom") == 0)
+    {
+      /* TODO: maybe there's a better heuristic than this */
+      if (hal_device_get_property_int (d, "storage.cdrom.write_speed") > 0)
+        s = g_strdup ("drive-optical-recorder");
+      else
+        s = g_strdup ("drive-optical");
+    }
+  else if (strcmp (drive_type, "floppy") == 0)
+    s = g_strdup ("drive-removable-media-floppy");
+  else if (strcmp (drive_type, "tape") == 0)
+    s = g_strdup ("drive-removable-media-tape");
+  else if (strcmp (drive_type, "compact_flash") == 0)
+    s = g_strdup ("drive-removable-media-flash-cf");
+  else if (strcmp (drive_type, "memory_stick") == 0)
+    s = g_strdup ("drive-removable-media-flash-ms");
+  else if (strcmp (drive_type, "smart_media") == 0)
+    s = g_strdup ("drive-removable-media-flash-sm");
+  else if (strcmp (drive_type, "sd_mmc") == 0)
+    s = g_strdup ("drive-removable-media-flash-sd");
+
+  if (s == NULL)
+    s = g_strdup ("drive-removable-media");
+  
+  return s;
+}
+
+static void
+_do_update_from_hal (GHalDrive *d)
+{
+  d->name = _drive_get_description (d->device);
+  d->icon = _drive_get_icon (d->device);
+  
+  d->uses_removable_media = hal_device_get_property_bool (d->device, "storage.removable");
+  if (d->uses_removable_media)
+    {
+      d->has_media = hal_device_get_property_bool (d->device, "storage.removable.media_available");
+      d->is_media_check_automatic = hal_device_get_property_bool (d->device, "storage.media_check_enabled");
+      d->can_poll_for_media = hal_device_has_interface (d->device, "org.freedesktop.Hal.Device.Storage.Removable");
+      d->can_eject = hal_device_get_property_bool (d->device, "storage.requires_eject");
+    }
+  else
+    {
+      d->has_media = TRUE;
+      d->is_media_check_automatic = FALSE;
+      d->can_poll_for_media = FALSE;
+      d->can_eject = FALSE;
+    }
+}
+
+static void
+emit_drive_changed (GHalDrive *drive)
+{
+  g_signal_emit_by_name (drive, "changed");
+  if (drive->volume_monitor != NULL)
+    g_signal_emit_by_name (drive->volume_monitor, "drive_changed", drive);
+}
+
+static void
+_update_from_hal (GHalDrive *d, gboolean emit_changed)
+{
+  char *old_name;
+  char *old_icon;
+  gboolean old_uses_removable_media;
+  gboolean old_has_media;
+  gboolean old_is_media_check_automatic;
+  gboolean old_can_poll_for_media;
+  gboolean old_can_eject;
+
+  old_name = g_strdup (d->name);
+  old_icon = g_strdup (d->icon);
+  old_uses_removable_media = d->uses_removable_media;
+  old_has_media = d->has_media;
+  old_is_media_check_automatic = d->is_media_check_automatic;
+  old_can_poll_for_media = d->can_poll_for_media;
+  old_can_eject = d->can_eject;
+
+  g_free (d->name);
+  g_free (d->icon);
+  _do_update_from_hal (d);
+
+  if (emit_changed &&
+      (old_uses_removable_media != d->uses_removable_media ||
+       old_has_media != d->has_media ||
+       old_is_media_check_automatic != d->is_media_check_automatic ||
+       old_can_poll_for_media != d->can_poll_for_media ||
+       old_can_eject != d->can_eject ||
+       old_name == NULL || 
+       old_icon == NULL ||
+       strcmp (old_name, d->name) != 0 ||
+       strcmp (old_icon, d->icon) != 0))
+    emit_drive_changed (d);
+  
+  g_free (old_name);
+  g_free (old_icon);
+}
+
+static void
+hal_condition (HalDevice *device, const char *name, const char *detail, gpointer user_data)
+{
+  GHalDrive *hal_drive = G_HAL_DRIVE (user_data);
+
+  if (strcmp (name, "EjectPressed") == 0)
+    {
+      g_signal_emit_by_name (hal_drive, "eject-button");
+      if (hal_drive->volume_monitor != NULL)
+        g_signal_emit_by_name (hal_drive->volume_monitor, "drive-eject-button", hal_drive);
+    }
+
+}
+
+static void
+hal_changed (HalDevice *device, const char *key, gpointer user_data)
+{
+  GHalDrive *hal_drive = G_HAL_DRIVE (user_data);
+  
+  /*g_warning ("volhal modifying %s (property %s changed)", hal_drive->device_path, key);*/
+  _update_from_hal (hal_drive, TRUE);
+}
+
+GHalDrive *
+g_hal_drive_new (GVolumeMonitor       *volume_monitor,
+                 HalDevice            *device,
+                 HalPool              *pool)
+{
+  GHalDrive *drive;
+
+  drive = g_object_new (G_TYPE_HAL_DRIVE, NULL);
+  drive->volume_monitor = volume_monitor;
+  g_object_add_weak_pointer (G_OBJECT (volume_monitor), (gpointer) &(drive->volume_monitor));
+  drive->device_path = g_strdup (hal_device_get_property_string (device, "block.device"));
+  drive->device = g_object_ref (device);
+  drive->pool = g_object_ref (pool);
+
+  drive->name = g_strdup_printf ("Drive for %s", drive->device_path);
+  drive->icon = g_strdup_printf ("drive-removable-media");
+
+  g_signal_connect_object (device, "hal_property_changed", (GCallback) hal_changed, drive, 0);
+  g_signal_connect_object (device, "hal_condition", (GCallback) hal_condition, drive, 0);
+
+  _update_from_hal (drive, FALSE);
+
+  return drive;
+}
+
+void 
+g_hal_drive_disconnected (GHalDrive *drive)
+{
+  GList *l, *volumes;
+
+  volumes = drive->volumes;
+  drive->volumes = NULL;
+  
+  for (l = volumes; l != NULL; l = l->next)
+    {
+      GHalVolume *volume = l->data;
+      g_hal_volume_unset_drive (volume, drive);
+    }
+
+  g_list_free (volumes);
+}
+
+void 
+g_hal_drive_set_volume (GHalDrive *drive, 
+                        GHalVolume *volume)
+{
+
+  if (g_list_find (drive->volumes, volume) == NULL)
+    {
+      drive->volumes = g_list_prepend (drive->volumes, volume);
+      emit_drive_changed (drive);
+    }
+}
+
+void 
+g_hal_drive_unset_volume (GHalDrive *drive, 
+                          GHalVolume *volume)
+{
+  GList *l;
+
+  l = g_list_find (drive->volumes, volume);
+  if (l != NULL)
+    {
+      drive->volumes = g_list_delete_link (drive->volumes, l);
+
+      emit_drive_changed (drive);
+    }
+}
+
+gboolean 
+g_hal_drive_has_udi (GHalDrive *drive, const char *udi)
+{
+  gboolean res;
+  
+  res = strcmp (udi, hal_device_get_udi (drive->device)) == 0;
+
+  return res;
+}
+
+static GIcon *
+g_hal_drive_get_icon (GDrive *drive)
+{
+  GHalDrive *hal_drive = G_HAL_DRIVE (drive);
+  GIcon *icon;
+
+  icon = g_themed_icon_new_with_default_fallbacks (hal_drive->icon);
+  
+  return icon; 
+}
+
+static char *
+g_hal_drive_get_name (GDrive *drive)
+{
+  GHalDrive *hal_drive = G_HAL_DRIVE (drive);
+  char *name;
+
+  name = g_strdup (hal_drive->name);
+  
+  return name;
+}
+
+static GList *
+g_hal_drive_get_volumes (GDrive *drive)
+{
+  GHalDrive *hal_drive = G_HAL_DRIVE (drive);
+  GList *l;
+
+  l = g_list_copy (hal_drive->volumes);
+  g_list_foreach (l, (GFunc) g_object_ref, NULL);
+
+  return l;
+}
+
+static gboolean
+g_hal_drive_has_volumes (GDrive *drive)
+{
+  GHalDrive *hal_drive = G_HAL_DRIVE (drive);
+
+  return hal_drive->volumes != NULL;
+}
+
+static gboolean
+g_hal_drive_is_media_removable (GDrive *drive)
+{
+  GHalDrive *hal_drive = G_HAL_DRIVE (drive);
+
+  return hal_drive->uses_removable_media;
+}
+
+static gboolean
+g_hal_drive_has_media (GDrive *drive)
+{
+  GHalDrive *hal_drive = G_HAL_DRIVE (drive);
+
+  return hal_drive->has_media;
+}
+
+static gboolean
+g_hal_drive_is_media_check_automatic (GDrive *drive)
+{
+  GHalDrive *hal_drive = G_HAL_DRIVE (drive);
+
+  return hal_drive->is_media_check_automatic;
+}
+
+static gboolean
+g_hal_drive_can_eject (GDrive *drive)
+{
+  GHalDrive *hal_drive = G_HAL_DRIVE (drive);
+  
+  return hal_drive->can_eject;
+}
+
+static gboolean
+g_hal_drive_can_poll_for_media (GDrive *drive)
+{
+  GHalDrive *hal_drive = G_HAL_DRIVE (drive);
+  
+  return hal_drive->can_poll_for_media;
+}
+
+typedef struct {
+  GObject *object;
+  GAsyncReadyCallback callback;
+  gpointer user_data;
+  GCancellable *cancellable;
+} SpawnOp;
+
+static void 
+spawn_cb (GPid pid, gint status, gpointer user_data)
+{
+  SpawnOp *data = user_data;
+  GSimpleAsyncResult *simple;
+
+
+  if (WEXITSTATUS (status) != 0)
+    {
+      GError *error;
+      error = g_error_new_literal (G_IO_ERROR, 
+                                   G_IO_ERROR_FAILED_HANDLED,
+                                   "You are not supposed to show G_IO_ERROR_FAILED_HANDLED in the UI");
+      simple = g_simple_async_result_new_from_error (data->object,
+                                                     data->callback,
+                                                     data->user_data,
+                                                     error);
+      g_error_free (error);
+    }
+  else
+    {
+      simple = g_simple_async_result_new (data->object,
+                                          data->callback,
+                                          data->user_data,
+                                          NULL);
+    }
+  g_simple_async_result_complete (simple);
+  g_object_unref (simple);
+  g_object_unref (data->object);
+  g_free (data);
+}
+
+static void
+g_hal_drive_eject_do (GDrive              *drive,
+                      GCancellable        *cancellable,
+                      GAsyncReadyCallback  callback,
+                      gpointer             user_data)
+{
+  GHalDrive *hal_drive = G_HAL_DRIVE (drive);
+  SpawnOp *data;
+  GPid child_pid;
+  GError *error;
+  char *argv[] = {"gnome-mount", "-e", "-b", "-d", NULL, NULL};
+
+  argv[4] = g_strdup (hal_drive->device_path);
+  
+  data = g_new0 (SpawnOp, 1);
+  data->object = g_object_ref (drive);
+  data->callback = callback;
+  data->user_data = user_data;
+  data->cancellable = cancellable;
+
+  error = NULL;
+  if (!g_spawn_async (NULL,         /* working dir */
+                      argv,
+                      NULL,         /* envp */
+                      G_SPAWN_DO_NOT_REAP_CHILD|G_SPAWN_SEARCH_PATH,
+                      NULL,         /* child_setup */
+                      NULL,         /* user_data for child_setup */
+                      &child_pid,
+                      &error))
+    {
+      GSimpleAsyncResult *simple;
+
+      simple = g_simple_async_result_new_from_error (data->object,
+                                                     data->callback,
+                                                     data->user_data,
+                                                     error);
+      g_simple_async_result_complete (simple);
+      g_object_unref (simple);
+      g_object_unref (drive);
+      g_error_free (error);
+      g_free (data);
+    }
+  else
+    g_child_watch_add (child_pid, spawn_cb, data);
+
+  g_free (argv[4]);
+}
+
+
+typedef struct {
+  GDrive *drive;
+  GAsyncReadyCallback callback;
+  gpointer user_data;
+  GMountOperation *mount_operation;
+  GCancellable *cancellable;
+  GMountUnmountFlags flags;
+
+  GList *pending_mounts;
+} UnmountMountsOp;
+
+static void
+free_unmount_mounts_op (UnmountMountsOp *data)
+{
+  GList *l;
+
+  for (l = data->pending_mounts; l != NULL; l = l->next)
+    {
+      GMount *mount = l->data;
+      g_object_unref (mount);
+    }
+  g_list_free (data->pending_mounts);
+}
+
+static void _eject_unmount_mounts (UnmountMountsOp *data);
+
+static void
+_eject_unmount_mounts_cb (GObject *source_object,
+                          GAsyncResult *res,
+                          gpointer user_data)
+{
+  UnmountMountsOp *data = user_data;
+  GMount *mount = G_MOUNT (source_object);
+  GSimpleAsyncResult *simple;
+  GError *error = NULL;
+
+  if (!g_mount_unmount_with_operation_finish (mount, res, &error))
+    {
+      /* make the error dialog more targeted to the drive.. unless the user has already seen a dialog */
+      if (error->code != G_IO_ERROR_FAILED_HANDLED)
+        {
+          g_error_free (error);
+          error = g_error_new (G_IO_ERROR, G_IO_ERROR_BUSY,
+                               _("Failed to eject media; one or more volumes on the media are busy."));
+        }
+
+      /* unmount failed; need to fail the whole eject operation */
+      simple = g_simple_async_result_new_from_error (G_OBJECT (data->drive),
+                                                     data->callback,
+                                                     data->user_data,
+                                                     error);
+      g_error_free (error);
+      g_simple_async_result_complete (simple);
+      g_object_unref (simple);
+
+      free_unmount_mounts_op (data);
+    }
+  else
+    {
+
+      /*g_warning ("successfully unmounted %p", mount);*/
+
+      /* move on to the next mount.. */
+      _eject_unmount_mounts (data);
+    }
+
+  g_object_unref (mount);
+}
+
+static void
+_eject_unmount_mounts (UnmountMountsOp *data)
+{
+  GMount *mount;
+
+  if (data->pending_mounts == NULL)
+    {
+
+      /*g_warning ("all pending mounts done; ejecting drive");*/
+
+      g_hal_drive_eject_do (data->drive,
+                            data->cancellable,
+                            data->callback,
+                            data->user_data);
+
+      g_object_unref (data->drive);
+      g_free (data);
+    }
+  else
+    {
+      mount = data->pending_mounts->data;
+      data->pending_mounts = g_list_remove (data->pending_mounts, mount);
+
+      /*g_warning ("unmounting %p", mount);*/
+
+      g_mount_unmount_with_operation (mount,
+                                      data->flags,
+                                      data->mount_operation,
+                                      data->cancellable,
+                                      _eject_unmount_mounts_cb,
+                                      data);
+    }
+}
+
+static void
+g_hal_drive_eject_with_operation (GDrive              *drive,
+                                  GMountUnmountFlags   flags,
+                                  GMountOperation     *mount_operation,
+                                  GCancellable        *cancellable,
+                                  GAsyncReadyCallback  callback,
+                                  gpointer             user_data)
+{
+  GHalDrive *hal_drive = G_HAL_DRIVE (drive);
+  UnmountMountsOp *data;
+  GList *l;
+
+  /* first we need to go through all the volumes and unmount their assoicated mounts (if any) */
+
+  data = g_new0 (UnmountMountsOp, 1);
+  data->drive = g_object_ref (drive);
+  data->mount_operation = mount_operation;
+  data->cancellable = cancellable;
+  data->callback = callback;
+  data->user_data = user_data;
+  data->flags = flags;
+
+  for (l = hal_drive->volumes; l != NULL; l = l->next)
+    {
+      GHalVolume *volume = l->data;
+      GMount *mount; /* the mount may be foreign; cannot assume GHalMount */
+
+      mount = g_volume_get_mount (G_VOLUME (volume));
+      if (mount != NULL && g_mount_can_unmount (mount))
+        data->pending_mounts = g_list_prepend (data->pending_mounts, g_object_ref (mount));
+    }
+
+  _eject_unmount_mounts (data);
+}
+
+static gboolean
+g_hal_drive_eject_with_operation_finish (GDrive        *drive,
+                                         GAsyncResult  *result,
+                                         GError       **error)
+{
+  return TRUE;
+}
+
+static void
+g_hal_drive_eject (GDrive              *drive,
+                   GMountUnmountFlags   flags,
+                   GCancellable        *cancellable,
+                   GAsyncReadyCallback  callback,
+                   gpointer             user_data)
+{
+  g_hal_drive_eject (drive, flags, cancellable, callback, user_data);
+}
+
+static gboolean
+g_hal_drive_eject_finish (GDrive        *drive,
+                          GAsyncResult  *result,
+                          GError       **error)
+{
+  return g_hal_drive_eject_with_operation_finish (drive, result, error);
+}
+
+typedef struct {
+  GObject *object;
+  GAsyncReadyCallback callback;
+  gpointer user_data;
+  GCancellable *cancellable;
+} PollOp;
+
+static void
+poll_for_media_cb (DBusPendingCall *pending_call, void *user_data)
+{
+  PollOp *data = (PollOp *) user_data;
+  GSimpleAsyncResult *simple;
+  DBusMessage *reply;
+
+  reply = dbus_pending_call_steal_reply (pending_call);
+
+  if (dbus_message_get_type (reply) == DBUS_MESSAGE_TYPE_ERROR)
+    {
+      GError *error;
+      DBusError dbus_error;
+
+      dbus_error_init (&dbus_error);
+      dbus_set_error_from_message (&dbus_error, reply);
+      error = g_error_new (G_IO_ERROR,
+                           G_IO_ERROR_FAILED,
+                           "Cannot invoke CheckForMedia on HAL: %s: %s", dbus_error.name, dbus_error.message);
+      simple = g_simple_async_result_new_from_error (data->object,
+                                                     data->callback,
+                                                     data->user_data,
+                                                     error);
+      g_simple_async_result_complete (simple);
+      g_object_unref (simple);
+      g_error_free (error);
+      dbus_error_free (&dbus_error);
+      goto out;
+    }
+
+  /* TODO: parse reply and extract result?
+   * (the result is whether the media availability state changed)
+   */
+
+  simple = g_simple_async_result_new (data->object,
+                                      data->callback,
+                                      data->user_data,
+                                      NULL);
+  g_simple_async_result_complete (simple);
+  g_object_unref (simple);
+
+ out:
+  g_object_unref (data->object);
+  dbus_message_unref (reply);
+  dbus_pending_call_unref (pending_call);
+}
+
+
+static void
+g_hal_drive_poll_for_media (GDrive              *drive,
+                            GCancellable        *cancellable,
+                            GAsyncReadyCallback  callback,
+                            gpointer             user_data)
+{
+  GHalDrive *hal_drive = G_HAL_DRIVE (drive);
+  DBusConnection *con;
+  DBusMessage *msg;
+  DBusPendingCall *pending_call;
+  PollOp *data;
+
+  data = g_new0 (PollOp, 1);
+  data->object = g_object_ref (drive);
+  data->callback = callback;
+  data->user_data = user_data;
+  data->cancellable = cancellable;
+
+  /*g_warning ("Rescanning udi %s", hal_device_get_udi (hal_drive->device));*/
+
+  con = hal_pool_get_dbus_connection (hal_drive->pool);
+  msg = dbus_message_new_method_call ("org.freedesktop.Hal",
+                                      hal_device_get_udi (hal_drive->device),
+                                      "org.freedesktop.Hal.Device.Storage.Removable",
+                                      "CheckForMedia");
+
+  if (!dbus_connection_send_with_reply (con, msg, &pending_call, -1))
+    {
+      GError *error;
+      GSimpleAsyncResult *simple;
+      error = g_error_new_literal (G_IO_ERROR,
+                                   G_IO_ERROR_FAILED,
+                                   "Cannot invoke CheckForMedia on HAL");
+      simple = g_simple_async_result_new_from_error (data->object,
+                                                     data->callback,
+                                                     data->user_data,
+                                                     error);
+      g_simple_async_result_complete (simple);
+      g_object_unref (simple);
+      g_error_free (error);
+      g_object_unref (data->object);
+      g_free (data);
+    }
+  else
+    dbus_pending_call_set_notify (pending_call,
+                                  poll_for_media_cb,
+                                  data,
+                                  (DBusFreeFunction) g_free);
+
+  dbus_message_unref (msg);
+}
+
+static gboolean
+g_hal_drive_poll_for_media_finish (GDrive        *drive,
+                                   GAsyncResult  *result,
+                                   GError       **error)
+{
+  /*g_warning ("poll finish");*/
+  return TRUE;
+}
+
+static char *
+g_hal_drive_get_identifier (GDrive              *drive,
+                             const char          *kind)
+{
+  GHalDrive *hal_drive = G_HAL_DRIVE (drive);
+  char *res;
+
+  res = NULL;
+
+  if (strcmp (kind, G_VOLUME_IDENTIFIER_KIND_HAL_UDI) == 0)
+    res = g_strdup (hal_device_get_udi (hal_drive->device));
+  
+  if (strcmp (kind, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE) == 0)
+    res = g_strdup (hal_drive->device_path);
+  
+  return res;
+}
+
+static char **
+g_hal_drive_enumerate_identifiers (GDrive *drive)
+{
+  GHalDrive *hal_drive = G_HAL_DRIVE (drive);
+  GPtrArray *res;
+
+  res = g_ptr_array_new ();
+
+  g_ptr_array_add (res,
+                   g_strdup (G_VOLUME_IDENTIFIER_KIND_HAL_UDI));
+
+  if (hal_drive->device_path && *hal_drive->device_path != 0)
+    g_ptr_array_add (res,
+                     g_strdup (G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE));
+    
+  
+  /* Null-terminate */
+  g_ptr_array_add (res, NULL);
+  
+  return (char **)g_ptr_array_free (res, FALSE);
+}
+
+static void
+g_hal_drive_drive_iface_init (GDriveIface *iface)
+{
+  iface->get_name = g_hal_drive_get_name;
+  iface->get_icon = g_hal_drive_get_icon;
+  iface->has_volumes = g_hal_drive_has_volumes;
+  iface->get_volumes = g_hal_drive_get_volumes;
+  iface->is_media_removable = g_hal_drive_is_media_removable;
+  iface->has_media = g_hal_drive_has_media;
+  iface->is_media_check_automatic = g_hal_drive_is_media_check_automatic;
+  iface->can_eject = g_hal_drive_can_eject;
+  iface->can_poll_for_media = g_hal_drive_can_poll_for_media;
+  iface->eject = g_hal_drive_eject;
+  iface->eject_finish = g_hal_drive_eject_finish;
+  iface->eject_with_operation = g_hal_drive_eject_with_operation;
+  iface->eject_with_operation_finish = g_hal_drive_eject_with_operation_finish;
+  iface->poll_for_media = g_hal_drive_poll_for_media;
+  iface->poll_for_media_finish = g_hal_drive_poll_for_media_finish;
+  iface->get_identifier = g_hal_drive_get_identifier;
+  iface->enumerate_identifiers = g_hal_drive_enumerate_identifiers;
+}

=== added file '.pc/03_xdg-mount.patch/monitor/hal/ghalmount.c'
--- .pc/03_xdg-mount.patch/monitor/hal/ghalmount.c	1970-01-01 00:00:00 +0000
+++ .pc/03_xdg-mount.patch/monitor/hal/ghalmount.c	2011-09-27 06:17:30 +0000
@@ -0,0 +1,1192 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/* GIO - GLib Input, Output and Streaming Library
+ * 
+ * Copyright (C) 2006-2007 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Author: David Zeuthen <[e-mail]>
+ */
+
+#include <config.h>
+
+#include <string.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#include <glib.h>
+#include <glib/gi18n-lib.h>
+#include <gio/gio.h>
+
+#include <gvfsmountinfo.h>
+
+#include "ghalvolumemonitor.h"
+#include "ghalmount.h"
+#include "ghalvolume.h"
+
+#include "hal-utils.h"
+
+struct _GHalMount {
+  GObject parent;
+
+  GVolumeMonitor *volume_monitor; /* owned by volume monitor */
+  GHalVolume *volume;             /* owned by volume monitor */
+
+  char *name;
+  GIcon *icon;
+  char *device_path;
+  char *mount_path;
+
+  char *uuid;
+
+  char *override_name;
+  GIcon *override_icon;
+  GFile *override_root;
+  gboolean cannot_unmount;
+
+  HalDevice *device;
+  HalDevice *drive_device;
+
+  GIcon *autorun_icon;
+  gboolean searched_for_autorun;
+
+  gchar *xdg_volume_info_name;
+  GIcon *xdg_volume_info_icon;
+  gboolean searched_for_xdg_volume_info;
+};
+
+static GFile *get_root (GHalMount *hal_mount);
+
+static void update_from_hal (GHalMount *m, gboolean emit_changed);
+
+static void g_hal_mount_mount_iface_init (GMountIface *iface);
+
+G_DEFINE_TYPE_EXTENDED (GHalMount, g_hal_mount, G_TYPE_OBJECT, 0,
+                        G_IMPLEMENT_INTERFACE (G_TYPE_MOUNT,
+                                               g_hal_mount_mount_iface_init))
+
+static void
+g_hal_mount_finalize (GObject *object)
+{
+  GHalMount *mount;
+  
+  mount = G_HAL_MOUNT (object);
+
+  if (mount->volume != NULL)
+    g_hal_volume_unset_mount (mount->volume, mount);
+
+  g_free (mount->device_path);
+  g_free (mount->mount_path);
+  g_free (mount->uuid);
+
+  if (mount->device != NULL)
+    g_object_unref (mount->device);
+  if (mount->drive_device != NULL)
+    g_object_unref (mount->drive_device);
+
+  g_free (mount->name);
+  if (mount->icon != NULL)
+    g_object_unref (mount->icon);
+
+  g_free (mount->override_name);
+  if (mount->override_icon != NULL)
+    g_object_unref (mount->override_icon);
+
+  if (mount->override_root != NULL)
+    g_object_unref (mount->override_root);
+
+  if (mount->autorun_icon != NULL)
+    g_object_unref (mount->autorun_icon);
+
+  g_free (mount->xdg_volume_info_name);
+  if (mount->xdg_volume_info_icon != NULL)
+    g_object_unref (mount->xdg_volume_info_icon);
+
+  if (mount->volume_monitor != NULL)
+    g_object_remove_weak_pointer (G_OBJECT (mount->volume_monitor), (gpointer) &(mount->volume_monitor));
+  
+  if (G_OBJECT_CLASS (g_hal_mount_parent_class)->finalize)
+    (*G_OBJECT_CLASS (g_hal_mount_parent_class)->finalize) (object);
+}
+
+static void
+g_hal_mount_class_init (GHalMountClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+  gobject_class->finalize = g_hal_mount_finalize;
+}
+
+static void
+g_hal_mount_init (GHalMount *hal_mount)
+{
+}
+
+static void
+emit_mount_changed (GHalMount *mount)
+{
+  g_signal_emit_by_name (mount, "changed");
+  if (mount->volume_monitor != NULL)
+    g_signal_emit_by_name (mount->volume_monitor, "mount_changed", mount);
+}
+
+#define KILOBYTE_FACTOR 1000.0
+#define MEGABYTE_FACTOR (1000.0 * 1000.0)
+#define GIGABYTE_FACTOR (1000.0 * 1000.0 * 1000.0)
+
+static char *
+format_size_for_display (guint64 size)
+{
+  char *str;
+  gdouble displayed_size;
+  
+  if (size < MEGABYTE_FACTOR)
+    {
+      displayed_size = (double) size / KILOBYTE_FACTOR;
+      str = g_strdup_printf (_("%.1f kB"), displayed_size);
+    } 
+  else if (size < GIGABYTE_FACTOR)
+    {
+      displayed_size = (double) size / MEGABYTE_FACTOR;
+      str = g_strdup_printf (_("%.1f MB"), displayed_size);
+    } 
+  else 
+    {
+      displayed_size = (double) size / GIGABYTE_FACTOR;
+      str = g_strdup_printf (_("%.1f GB"), displayed_size);
+    }
+  
+  return str;
+}
+
+static void
+got_autorun_info_cb (GObject      *source_object,
+                     GAsyncResult *res,
+                     gpointer      user_data)
+{
+  GHalMount *mount = G_HAL_MOUNT (user_data);
+
+  mount->autorun_icon = g_vfs_mount_info_query_autorun_info_finish (G_FILE (source_object),
+                                                                    res,
+                                                                    NULL);
+
+  update_from_hal (mount, TRUE);
+
+  g_object_unref (mount);
+}
+
+static void
+got_xdg_volume_info_cb (GObject      *source_object,
+                        GAsyncResult *res,
+                        gpointer      user_data)
+{
+  GHalMount *mount = G_HAL_MOUNT (user_data);
+
+  mount->xdg_volume_info_icon = g_vfs_mount_info_query_xdg_volume_info_finish (G_FILE (source_object),
+                                                                               res,
+                                                                               &(mount->xdg_volume_info_name),
+                                                                               NULL);
+  update_from_hal (mount, TRUE);
+
+  g_object_unref (mount);
+}
+
+static void
+do_update_from_hal (GHalMount *m)
+{
+  HalDevice *volume;
+  HalDevice *drive;
+  char *name;
+  const char *icon_name;
+  const char *icon_name_fallback;
+  const char *drive_type;
+  const char *drive_bus;
+  gboolean drive_uses_removable_media;
+  const char *volume_fs_label;
+  guint64 volume_size;
+  gboolean volume_is_disc;
+  gboolean volume_disc_has_audio;
+  gboolean volume_disc_has_data;
+  const char *volume_disc_type;
+  gboolean volume_disc_is_blank;
+  gboolean is_audio_player;
+  const char *icon_from_hal;
+  const char *volume_icon_from_hal;
+  const char *name_from_hal;
+  const char *volume_name_from_hal;
+  gboolean is_crypto;
+  gboolean is_crypto_cleartext;
+
+  volume = m->device;
+  drive = m->drive_device;
+  
+  drive_type = hal_device_get_property_string (drive, "storage.drive_type");
+  drive_bus = hal_device_get_property_string (drive, "storage.bus");
+  drive_uses_removable_media = hal_device_get_property_bool (drive, "storage.removable");
+  volume_fs_label = hal_device_get_property_string (volume, "volume.label");
+  volume_size = hal_device_get_property_uint64 (volume, "volume.size");
+  volume_is_disc = hal_device_get_property_bool (volume, "volume.is_disc");
+  volume_disc_has_audio = hal_device_get_property_bool (volume, "volume.disc.has_audio");
+  volume_disc_has_data = hal_device_get_property_bool (volume, "volume.disc.has_data");
+  volume_disc_is_blank = hal_device_get_property_bool (volume, "volume.disc.is_blank");
+  volume_disc_type = hal_device_get_property_string (volume, "volume.disc.type");
+  is_audio_player = hal_device_has_capability (drive, "portable_audio_player");
+  icon_from_hal = hal_device_get_property_string (drive, "storage.icon.drive");
+  volume_icon_from_hal = hal_device_get_property_string (volume, "storage.icon.volume");
+  name_from_hal = hal_device_get_property_string (drive, "info.desktop.name");
+  volume_name_from_hal = hal_device_get_property_string (volume, "info.desktop.name");
+
+  is_crypto = FALSE;
+  is_crypto_cleartext = FALSE;
+  if (strcmp (hal_device_get_property_string (volume, "volume.fsusage"), "crypto") == 0)
+      is_crypto = TRUE;
+
+  if (strlen (hal_device_get_property_string (volume, "volume.crypto_luks.clear.backing_volume")) > 0)
+      is_crypto_cleartext = TRUE;
+
+  /*g_warning ("drive_type='%s'", drive_type); */
+  /*g_warning ("drive_bus='%s'", drive_bus); */
+  /*g_warning ("drive_uses_removable_media=%d", drive_uses_removable_media); */
+
+  icon_name_fallback = NULL;
+
+  if (strlen (volume_icon_from_hal) > 0)
+    icon_name = volume_icon_from_hal;
+  else if (strlen (icon_from_hal) > 0)
+    icon_name = icon_from_hal;
+  else if (is_audio_player)
+    icon_name = "multimedia-player";
+  else if (strcmp (drive_type, "disk") == 0)
+    {
+      if (strcmp (drive_bus, "ide") == 0)
+        icon_name = "drive-harddisk-ata";
+      else if (strcmp (drive_bus, "scsi") == 0)
+        icon_name = "drive-harddisk-scsi";
+      else if (strcmp (drive_bus, "ieee1394") == 0)
+        icon_name = "drive-harddisk-ieee1394";
+      else if (strcmp (drive_bus, "usb") == 0)
+        icon_name = "drive-harddisk-usb";
+      else
+        icon_name = "drive-harddisk";
+    }
+  else if (strcmp (drive_type, "cdrom") == 0)
+    icon_name = get_disc_icon (volume_disc_type);
+  else if (strcmp (drive_type, "floppy") == 0)
+    icon_name = "media-floppy";
+  else if (strcmp (drive_type, "tape") == 0)
+    icon_name = "media-tape";
+  else if (strcmp (drive_type, "compact_flash") == 0)
+    icon_name = "media-flash-cf";
+  else if (strcmp (drive_type, "memory_stick") == 0)
+    icon_name = "media-flash-ms";
+  else if (strcmp (drive_type, "smart_media") == 0)
+    icon_name = "media-flash-sm";
+  else if (strcmp (drive_type, "sd_mmc") == 0)
+    icon_name = "media-flash-sd";
+  else
+    icon_name = "drive-harddisk";
+
+  /* Create default fallbacks for the icon_name by default
+   * with get_themed_icon_with_fallbacks () */
+  icon_name_fallback = icon_name;
+
+  /* Note: we are not chaning the default fallbacks
+   * so we get all the fallbacks if the media-encrytped
+   * icon is not there */
+  if (is_crypto || is_crypto_cleartext)
+    icon_name = "media-encrypted";
+
+  if (strlen (volume_name_from_hal) > 0)
+    name = g_strdup (volume_name_from_hal);
+  else if (strlen (name_from_hal) > 0)
+    name = g_strdup (name_from_hal);
+  else if (volume_fs_label != NULL && strlen (volume_fs_label) > 0)
+    name = g_strdup (volume_fs_label);
+  else if (volume_is_disc)
+    {
+      if (volume_disc_has_audio)
+        {
+          if (volume_disc_has_data)
+            name = g_strdup (_("Mixed Audio/Data Disc"));
+          else
+            name = g_strdup (_("Audio Disc"));
+        }
+      else
+        name = g_strdup (get_disc_name (volume_disc_type, volume_disc_is_blank));
+    }
+  else
+    {
+      char *size;
+
+      size = format_size_for_display (volume_size);  
+      /* Translators: %s is the size of the mount (e.g. 512 MB) */
+      name = g_strdup_printf (_("%s Medium"), size);
+      g_free (size);
+    }
+
+  /* order of preference : xdg, override, probed */
+  if (m->xdg_volume_info_name != NULL)
+    {
+      m->name = g_strdup (m->xdg_volume_info_name);
+      g_free (name);
+    }
+  else if (m->override_name != NULL)
+    {
+      m->name = g_strdup (m->override_name);
+      g_free (name);
+    }
+  else
+    m->name = name;
+
+  /* order of preference: xdg, autorun, override, probed */
+  if (m->xdg_volume_info_icon != NULL)
+    m->icon = g_object_ref (m->xdg_volume_info_icon);
+  else if (m->autorun_icon != NULL)
+    m->icon = g_object_ref (m->autorun_icon);
+  else if (m->override_icon != NULL)
+    m->icon = g_object_ref (m->override_icon);
+  else
+    m->icon = get_themed_icon_with_fallbacks (icon_name,
+                                              icon_name_fallback);
+
+  /* search for .xdg-volume-info */
+  if (!m->searched_for_xdg_volume_info)
+    {
+      GFile *root;
+      root = get_root (m);
+      m->searched_for_xdg_volume_info = TRUE;
+      g_vfs_mount_info_query_xdg_volume_info (root,
+                                              NULL,
+                                              got_xdg_volume_info_cb,
+                                              g_object_ref (m));
+      g_object_unref (root);
+    }
+
+  /* search for autorun.inf */
+  if (!m->searched_for_autorun)
+    {
+      GFile *root;
+      root = get_root (m);
+      m->searched_for_autorun = TRUE;
+      g_vfs_mount_info_query_autorun_info (root,
+                                           NULL,
+                                           got_autorun_info_cb,
+                                           g_object_ref (m));
+      g_object_unref (root);
+    }
+}
+
+
+static void
+update_from_hal (GHalMount *m, gboolean emit_changed)
+{
+  char *old_name;
+  GIcon *old_icon;
+
+  old_name = g_strdup (m->name);
+  old_icon = m->icon != NULL ? g_object_ref (m->icon) : NULL;
+
+  g_free (m->name);
+  if (m->icon != NULL)
+    g_object_unref (m->icon);
+  do_update_from_hal (m);
+
+  if (emit_changed)
+    {
+      if (old_name == NULL || 
+          old_icon == NULL ||
+          strcmp (old_name, m->name) != 0 ||
+          (! g_icon_equal (old_icon, m->icon)))
+        emit_mount_changed (m);
+    }
+  g_free (old_name);
+  if (old_icon != NULL)
+    g_object_unref (old_icon);
+}
+
+static void
+hal_changed (HalDevice *device, const char *key, gpointer user_data)
+{
+  GHalMount *hal_mount = G_HAL_MOUNT (user_data);
+  
+  /*g_warning ("mounthal modifying %s (property %s changed)", hal_mount->device_path, key); */
+  update_from_hal (hal_mount, TRUE);
+}
+
+static void
+compute_uuid (GHalMount *mount)
+{
+  const char *fs_uuid;
+  const char *fs_label;
+
+  /* use the FS uuid before falling back to the FS label */
+
+  fs_uuid = hal_device_get_property_string (mount->device, "volume.uuid");
+  fs_label = hal_device_get_property_string (mount->device, "volume.label");
+
+  if (strlen (fs_uuid) == 0)
+    {
+      if (strlen (fs_label) == 0)
+        mount->uuid = NULL;
+      else
+        mount->uuid = g_strdup (fs_label);
+    }
+  else
+    mount->uuid = g_strdup (fs_uuid);
+}
+
+
+GHalMount *
+g_hal_mount_new_for_hal_device    (GVolumeMonitor    *volume_monitor,
+                                   HalDevice         *device,
+                                   GFile             *override_root,
+                                   const char        *override_name,
+                                   GIcon             *override_icon,
+                                   gboolean           cannot_unmount,
+                                   HalPool           *pool,
+                                   GHalVolume        *volume)
+{
+  HalDevice *drive_device;
+  const char *storage_udi;
+  GHalMount *mount;
+
+  storage_udi = hal_device_get_property_string (device, "block.storage_device");
+  if (storage_udi == NULL)
+    goto fail;
+  
+  /* g_warning ("storage_udi = %s", storage_udi); */
+  
+  drive_device = hal_pool_get_device_by_udi (pool, storage_udi);
+  if (drive_device == NULL)
+    goto fail;
+  
+  /* g_warning ("drive_device = %p", drive_device); */
+  
+  mount = g_object_new (G_TYPE_HAL_MOUNT, NULL);
+  mount->volume_monitor = volume_monitor;
+  g_object_add_weak_pointer (G_OBJECT (mount->volume_monitor), (gpointer) &(mount->volume_monitor));
+  mount->device_path = g_strdup (hal_device_get_property_string (device, "block.device"));
+  mount->mount_path = g_strdup ("/");
+  mount->device = g_object_ref (device);
+  mount->drive_device = g_object_ref (drive_device);
+  mount->override_root = override_root != NULL ? g_object_ref (override_root) : NULL;
+  mount->override_icon = override_icon != NULL ? g_object_ref (override_icon) : NULL;
+  mount->override_name = g_strdup (override_name);
+  mount->cannot_unmount = cannot_unmount;
+          
+  g_signal_connect_object (device, "hal_property_changed", (GCallback) hal_changed, mount, 0);
+  g_signal_connect_object (drive_device, "hal_property_changed", (GCallback) hal_changed, mount, 0);
+
+  compute_uuid (mount);
+  update_from_hal (mount, FALSE);
+
+  /* need to do this last */
+  mount->volume = volume;
+  if (volume != NULL)
+    g_hal_volume_set_mount (volume, mount);
+
+  return mount;
+
+ fail:
+  return NULL;
+}
+
+void 
+g_hal_mount_override_name (GHalMount *mount, const char *name)
+{
+  g_free (mount->override_name);
+
+  if (name != NULL)
+    mount->override_name = g_strdup (name);
+  else
+    mount->override_name = NULL;
+  
+  update_from_hal (mount, TRUE);
+}
+
+void
+g_hal_mount_override_icon (GHalMount *mount, GIcon *icon)
+{
+  if (mount->override_icon != NULL)
+    g_object_unref (mount->override_icon);
+
+  if (icon != NULL)
+    mount->override_icon = g_object_ref (icon);
+  else
+    mount->override_icon = NULL;
+
+  update_from_hal (mount, TRUE);
+}
+
+GHalMount *
+g_hal_mount_new (GVolumeMonitor       *volume_monitor,
+                 GUnixMountEntry      *mount_entry,
+                 HalPool              *pool,
+                 GHalVolume           *volume)
+{
+  HalDevice *device;
+  HalDevice *drive_device;
+  const char *storage_udi;
+  GHalMount *mount;
+
+  /* If no volume for mount - Ignore internal things */
+  if (volume == NULL && !g_unix_mount_guess_should_display (mount_entry))
+    return NULL;
+
+  mount = g_object_new (G_TYPE_HAL_MOUNT, NULL);
+  mount->volume_monitor = volume_monitor;
+  g_object_add_weak_pointer (G_OBJECT (volume_monitor), (gpointer) &(mount->volume_monitor));
+  mount->device_path = g_strdup (g_unix_mount_get_device_path (mount_entry));
+  mount->mount_path = g_strdup (g_unix_mount_get_mount_path (mount_entry));
+  mount->device = NULL;
+  mount->drive_device = NULL;
+  mount->uuid = NULL;
+
+  if (pool != NULL)
+    {
+      device = hal_pool_get_device_by_capability_and_string (pool,
+                                                             "volume",
+                                                             "block.device",
+                                                             mount->device_path);
+      /* g_warning ("device = %p for %s", device, mount->device_path); */
+      if (device != NULL)
+        {      
+          /* g_warning ("udi = %s", hal_device_get_udi (device)); */
+          
+          storage_udi = hal_device_get_property_string (device, "block.storage_device");
+          if (storage_udi == NULL)
+            goto not_hal;
+
+          /* g_warning ("storage_udi = %s", storage_udi); */
+          
+          drive_device = hal_pool_get_device_by_udi (pool, storage_udi);
+          if (drive_device == NULL)
+            goto not_hal;
+
+          /* g_warning ("drive_device = %p", drive_device); */
+          
+          mount->device = g_object_ref (device);
+          mount->drive_device = g_object_ref (drive_device);
+          
+          g_signal_connect_object (device, "hal_property_changed", (GCallback) hal_changed, mount, 0);
+          g_signal_connect_object (drive_device, "hal_property_changed", (GCallback) hal_changed, mount, 0);
+          
+          compute_uuid (mount);
+          update_from_hal (mount, FALSE);
+          
+          goto was_hal;
+        }
+    }
+
+ not_hal:
+
+  if (volume != NULL)
+    {
+      g_object_unref (mount);
+      return NULL;
+    }
+  
+  mount->name = g_unix_mount_guess_name (mount_entry);
+  mount->icon = g_unix_mount_guess_icon (mount_entry);
+
+ was_hal:
+
+  /* need to do this last */
+  mount->volume = volume;
+  if (volume != NULL)
+    g_hal_volume_set_mount (volume, mount);
+
+  return mount;
+}
+
+void
+g_hal_mount_unmounted (GHalMount *mount)
+{
+  if (mount->volume != NULL)
+    {
+      g_hal_volume_unset_mount (mount->volume, mount);
+      mount->volume = NULL;
+      emit_mount_changed (mount);
+    }
+}
+
+void
+g_hal_mount_unset_volume (GHalMount *mount,
+                                       GHalVolume  *volume)
+{
+  if (mount->volume == volume)
+    {
+      mount->volume = NULL;
+      emit_mount_changed (mount);
+    }
+}
+
+static GFile *
+get_root (GHalMount *hal_mount)
+{
+  if (hal_mount->override_root != NULL)
+    return g_object_ref (hal_mount->override_root);
+  else
+    return g_file_new_for_path (hal_mount->mount_path);
+}
+
+static GFile *
+g_hal_mount_get_root (GMount *mount)
+{
+  GHalMount *hal_mount = G_HAL_MOUNT (mount);
+  
+  return get_root (hal_mount);
+}
+
+static GIcon *
+g_hal_mount_get_icon (GMount *mount)
+{
+  GHalMount *hal_mount = G_HAL_MOUNT (mount);
+
+  return g_object_ref (hal_mount->icon);
+}
+
+static char *
+g_hal_mount_get_uuid (GMount *mount)
+{
+  GHalMount *hal_mount = G_HAL_MOUNT (mount);
+
+  return g_strdup (hal_mount->uuid);
+}
+
+static char *
+g_hal_mount_get_name (GMount *mount)
+{
+  GHalMount *hal_mount = G_HAL_MOUNT (mount);
+  
+  return g_strdup (hal_mount->name);
+}
+
+gboolean
+g_hal_mount_has_uuid (GHalMount         *mount,
+                       const char        *uuid)
+{
+  gboolean res;
+
+  res = FALSE;
+  if (mount->uuid != NULL)
+    res = strcmp (mount->uuid, uuid) == 0;
+
+  return res;
+}
+
+gboolean
+g_hal_mount_has_mount_path (GHalMount *mount,
+                            const char  *mount_path)
+{
+  return strcmp (mount->mount_path, mount_path) == 0;
+}
+
+gboolean
+g_hal_mount_has_udi (GHalMount *mount,
+                     const char  *udi)
+{
+  gboolean res;
+
+  res = FALSE;
+  if (mount->device != NULL)
+    res = strcmp (hal_device_get_udi (mount->device), udi) == 0;
+
+  return res;
+}
+
+static GDrive *
+g_hal_mount_get_drive (GMount *mount)
+{
+  GHalMount *hal_mount = G_HAL_MOUNT (mount);
+  GDrive *drive;
+
+  drive = NULL;
+  if (hal_mount->volume != NULL)
+    drive = g_volume_get_drive (G_VOLUME (hal_mount->volume));
+
+  return drive;
+}
+
+static GVolume *
+g_hal_mount_get_volume (GMount *mount)
+{
+  GHalMount *hal_mount = G_HAL_MOUNT (mount);
+  GVolume *volume;
+
+  volume = NULL;
+  if (hal_mount->volume)
+    volume = G_VOLUME (g_object_ref (hal_mount->volume));
+  
+  return volume;
+}
+
+static gboolean
+g_hal_mount_can_unmount (GMount *mount)
+{
+  GHalMount *hal_mount = G_HAL_MOUNT (mount);
+  gboolean res;
+
+  res = TRUE;
+  if (hal_mount->cannot_unmount)
+    res = FALSE;
+
+  return res;
+}
+
+static gboolean
+g_hal_mount_can_eject (GMount *mount)
+{
+  GHalMount *hal_mount = G_HAL_MOUNT (mount);
+  GDrive *drive;
+  gboolean can_eject;
+
+  can_eject = FALSE;
+  if (hal_mount->volume != NULL)
+    {
+      drive = g_volume_get_drive (G_VOLUME (hal_mount->volume));
+      if (drive != NULL)
+        can_eject = g_drive_can_eject (drive);
+    }
+
+  return can_eject;
+}
+
+typedef struct {
+  GObject *object;
+  GAsyncReadyCallback callback;
+  gpointer user_data;
+  GCancellable *cancellable;
+  int error_fd;
+  GIOChannel *error_channel;
+  guint error_channel_source_id;
+  GString *error_string;
+  gboolean using_legacy;
+  gchar **argv;
+} UnmountOp;
+
+static void 
+unmount_cb (GPid pid, gint status, gpointer user_data)
+{
+  UnmountOp *data = user_data;
+  GSimpleAsyncResult *simple;
+
+  if (WEXITSTATUS (status) != 0)
+    {
+      if (data->using_legacy)
+        {
+          GError *error;
+          error = g_error_new_literal (G_IO_ERROR, 
+                                       G_IO_ERROR_FAILED,
+                                       data->error_string->str);
+          simple = g_simple_async_result_new_from_error (data->object,
+                                                         data->callback,
+                                                         data->user_data,
+                                                         error);
+          g_error_free (error);
+        }
+      else
+        {
+          GError *error;
+          error = g_error_new_literal (G_IO_ERROR, 
+                                       G_IO_ERROR_FAILED_HANDLED,
+                                       "You are not supposed to show G_IO_ERROR_FAILED_HANDLED in the UI");
+          simple = g_simple_async_result_new_from_error (data->object,
+                                                         data->callback,
+                                                         data->user_data,
+                                                         error);
+          g_error_free (error);
+        }
+    }
+  else
+    {
+      simple = g_simple_async_result_new (data->object,
+                                          data->callback,
+                                          data->user_data,
+                                          NULL);
+    }
+
+  g_simple_async_result_complete (simple);
+  g_object_unref (simple);
+
+  g_source_remove (data->error_channel_source_id);
+  g_io_channel_unref (data->error_channel);
+  g_string_free (data->error_string, TRUE);
+  g_strfreev (data->argv);
+  close (data->error_fd);
+  g_spawn_close_pid (pid);
+
+  g_object_unref (data->object);
+  g_free (data);
+}
+
+static gboolean
+unmount_read_error (GIOChannel *channel,
+                          GIOCondition condition,
+                          gpointer user_data)
+{
+  char *str;
+  gsize str_len;
+  UnmountOp *data = user_data;
+
+  g_io_channel_read_to_end (channel, &str, &str_len, NULL);
+  g_string_append (data->error_string, str);
+  g_free (str);
+  return TRUE;
+}
+
+static gboolean
+unmount_do_cb (gpointer user_data)
+{
+  UnmountOp *data = (UnmountOp *) user_data;
+  GPid child_pid;
+  GError *error;
+
+  error = NULL;
+  if (!g_spawn_async_with_pipes (NULL,         /* working dir */
+                                 data->argv,
+                                 NULL,         /* envp */
+                                 G_SPAWN_DO_NOT_REAP_CHILD|G_SPAWN_SEARCH_PATH,
+                                 NULL,         /* child_setup */
+                                 NULL,         /* user_data for child_setup */
+                                 &child_pid,
+                                 NULL,           /* standard_input */
+                                 NULL,           /* standard_output */
+                                 &(data->error_fd),
+                                 &error))
+    {
+      GSimpleAsyncResult *simple;
+      simple = g_simple_async_result_new_from_error (data->object,
+                                                     data->callback,
+                                                     data->user_data,
+                                                     error);
+      g_simple_async_result_complete (simple);
+      g_object_unref (simple);
+      g_error_free (error);
+      g_strfreev (data->argv);
+      g_free (data);
+
+      return FALSE;
+    }
+  data->error_string = g_string_new ("");
+  data->error_channel = g_io_channel_unix_new (data->error_fd);
+  data->error_channel_source_id = g_io_add_watch (data->error_channel, G_IO_IN, unmount_read_error, data);
+  g_child_watch_add (child_pid, unmount_cb, data);
+
+  return FALSE;
+}
+
+static void
+unmount_do (GMount               *mount,
+            GCancellable         *cancellable,
+            GAsyncReadyCallback   callback,
+            gpointer              user_data,
+            char                **argv,
+            gboolean              using_legacy)
+{
+  GHalMount *hal_mount = G_HAL_MOUNT (mount);
+  UnmountOp *data;
+
+  data = g_new0 (UnmountOp, 1);
+  data->object = g_object_ref (mount);
+  data->callback = callback;
+  data->user_data = user_data;
+  data->cancellable = cancellable;
+  data->using_legacy = using_legacy;
+  data->argv = g_strdupv (argv);
+
+  if (hal_mount->volume_monitor != NULL)
+    g_signal_emit_by_name (hal_mount->volume_monitor, "mount-pre-unmount", mount);
+
+  g_timeout_add (500, unmount_do_cb, data);
+}
+
+static void
+g_hal_mount_unmount_with_operation (GMount              *mount,
+                                    GMountUnmountFlags   flags,
+                                    GMountOperation     *mount_operation,
+                                    GCancellable        *cancellable,
+                                    GAsyncReadyCallback  callback,
+                                    gpointer             user_data)
+{
+  GHalMount *hal_mount = G_HAL_MOUNT (mount);
+  char *argv[] = {"gnome-mount", "-u", "-b", "-d", NULL, NULL};
+  gboolean using_legacy = FALSE;
+  char *d, *m;
+
+  d = g_strdup (hal_mount->device_path);
+  m = g_strdup (hal_mount->mount_path);
+  
+  if (hal_mount->device != NULL)
+    argv[4] = d;
+  else
+    {
+      using_legacy = TRUE;
+      argv[0] = "umount";
+      argv[1] = m;
+      argv[2] = NULL;
+    }
+
+  unmount_do (mount, cancellable, callback, user_data, argv, using_legacy);
+  g_free (d);
+  g_free (m);
+}
+
+static gboolean
+g_hal_mount_unmount_with_operation_finish (GMount       *mount,
+                                           GAsyncResult  *result,
+                                           GError       **error)
+{
+  return TRUE;
+}
+
+static void
+g_hal_mount_unmount (GMount              *mount,
+                     GMountUnmountFlags   flags,
+                     GCancellable        *cancellable,
+                     GAsyncReadyCallback  callback,
+                     gpointer             user_data)
+{
+  return g_hal_mount_unmount_with_operation (mount, flags, NULL, cancellable, callback, user_data);
+}
+
+static gboolean
+g_hal_mount_unmount_finish (GMount        *mount,
+                            GAsyncResult  *result,
+                            GError       **error)
+{
+  return g_hal_mount_unmount_with_operation_finish (mount, result, error);
+}
+
+typedef struct {
+  GObject *object;
+  GAsyncReadyCallback callback;
+  gpointer user_data;
+} EjectWrapperOp;
+
+static void
+eject_wrapper_callback (GObject *source_object,
+                        GAsyncResult *res,
+                        gpointer user_data)
+{
+  EjectWrapperOp *data  = user_data;
+  data->callback (data->object, res, data->user_data);
+  g_object_unref (data->object);
+  g_free (data);
+}
+
+static void
+g_hal_mount_eject_with_operation (GMount              *mount,
+                                  GMountUnmountFlags   flags,
+                                  GMountOperation     *mount_operation,
+                                  GCancellable        *cancellable,
+                                  GAsyncReadyCallback  callback,
+                                  gpointer             user_data)
+{
+  GHalMount *hal_mount = G_HAL_MOUNT (mount);
+  GDrive *drive;
+
+  drive = NULL;
+  if (hal_mount->volume != NULL)
+    drive = g_volume_get_drive (G_VOLUME (hal_mount->volume));
+  
+  if (drive != NULL)
+    {
+      EjectWrapperOp *data;
+      data = g_new0 (EjectWrapperOp, 1);
+      data->object = g_object_ref (mount);
+      data->callback = callback;
+      data->user_data = user_data;
+      g_drive_eject_with_operation (drive, flags, mount_operation, cancellable, eject_wrapper_callback, data);
+      g_object_unref (drive);
+    }
+}
+
+static gboolean
+g_hal_mount_eject_with_operation_finish (GMount        *mount,
+                                         GAsyncResult  *result,
+                                         GError       **error)
+{
+  GHalMount *hal_mount = G_HAL_MOUNT (mount);
+  GDrive *drive;
+  gboolean res;
+
+  res = TRUE;
+  
+  drive = NULL;
+  if (hal_mount->volume != NULL)
+    drive = g_volume_get_drive (G_VOLUME (hal_mount->volume));
+  
+  if (drive != NULL)
+    {
+      res = g_drive_eject_with_operation_finish (drive, result, error);
+      g_object_unref (drive);
+    }
+  return res;
+}
+
+static void
+g_hal_mount_eject (GMount              *mount,
+                   GMountUnmountFlags   flags,
+                   GCancellable        *cancellable,
+                   GAsyncReadyCallback  callback,
+                   gpointer             user_data)
+{
+  return g_hal_mount_eject_with_operation (mount, flags, NULL, cancellable, callback, user_data);
+}
+
+static gboolean
+g_hal_mount_eject_finish (GMount        *mount,
+                          GAsyncResult  *result,
+                          GError       **error)
+{
+  return g_hal_mount_eject_with_operation_finish (mount, result, error);
+}
+
+/* TODO: handle force_rescan */
+static char **
+g_hal_mount_guess_content_type_sync (GMount              *mount,
+                                     gboolean             force_rescan,
+                                     GCancellable        *cancellable,
+                                     GError             **error)
+{
+  GHalMount *hal_mount = G_HAL_MOUNT (mount);
+  const char *disc_type;
+  char **x_content_types;
+  GFile *root;
+  GPtrArray *p;
+  char **result;
+  int n;
+  char **caps;
+  char *uri;
+
+  p = g_ptr_array_new ();
+
+  root = get_root (hal_mount);
+  uri = g_file_get_uri (root);
+  if (g_str_has_prefix (uri, "burn://"))
+    {
+      /* doesn't make sense to probe burn:/// - look at the disc type instead */
+      if (hal_mount->device != NULL)
+        {
+          disc_type = hal_device_get_property_string (hal_mount->device, "volume.disc.type");
+          if (disc_type != NULL)
+            {
+              if (g_str_has_prefix (disc_type, "dvd"))
+                g_ptr_array_add (p, g_strdup ("x-content/blank-dvd"));
+              else if (g_str_has_prefix (disc_type, "hddvd"))
+                g_ptr_array_add (p, g_strdup ("x-content/blank-hddvd"));
+              else if (g_str_has_prefix (disc_type, "bd"))
+                g_ptr_array_add (p, g_strdup ("x-content/blank-bd"));
+              else
+                g_ptr_array_add (p, g_strdup ("x-content/blank-cd")); /* assume CD */
+            }
+        }
+    }
+  else
+    {
+      /* sniff content type */
+      x_content_types = g_content_type_guess_for_tree (root);
+      if (x_content_types != NULL)
+        {
+          for (n = 0; x_content_types[n] != NULL; n++)
+            g_ptr_array_add (p, g_strdup (x_content_types[n]));
+          g_strfreev (x_content_types);
+        }
+    }
+  g_object_unref (root);
+  g_free (uri);
+
+  /* also add content types from hal capabilities */
+  if (hal_mount->drive_device != NULL)
+    {
+      caps = dupv_and_uniqify (hal_device_get_property_strlist (hal_mount->drive_device, "info.capabilities"));
+      if (caps != NULL)
+        {
+          for (n = 0; caps[n] != NULL; n++)
+            {
+              if (strcmp (caps[n], "portable_audio_player") == 0)
+                g_ptr_array_add (p, g_strdup ("x-content/audio-player"));
+            }
+          g_strfreev (caps);
+        }
+    }
+
+  if (p->len == 0)
+    {
+      result = NULL;
+      g_ptr_array_free (p, TRUE);
+    }
+  else
+    {
+      g_ptr_array_add (p, NULL);
+      result = (char **) g_ptr_array_free (p, FALSE);
+    }
+
+  return result;
+}
+
+/* since we're an out-of-process volume monitor we'll just do this sync */
+static void
+g_hal_mount_guess_content_type (GMount              *mount,
+                                gboolean             force_rescan,
+                                GCancellable        *cancellable,
+                                GAsyncReadyCallback  callback,
+                                gpointer             user_data)
+{
+  GSimpleAsyncResult *simple;
+
+  /* TODO: handle force_rescan */
+  simple = g_simple_async_result_new (G_OBJECT (mount),
+                                      callback,
+                                      user_data,
+                                      NULL);
+  g_simple_async_result_complete (simple);
+  g_object_unref (simple);
+}
+
+static char **
+g_hal_mount_guess_content_type_finish (GMount              *mount,
+                                       GAsyncResult        *result,
+                                       GError             **error)
+{
+  /* TODO: handle force_rescan */
+  return g_hal_mount_guess_content_type_sync (mount, FALSE, NULL, error);
+}
+
+static void
+g_hal_mount_mount_iface_init (GMountIface *iface)
+{
+  iface->get_root = g_hal_mount_get_root;
+  iface->get_name = g_hal_mount_get_name;
+  iface->get_icon = g_hal_mount_get_icon;
+  iface->get_uuid = g_hal_mount_get_uuid;
+  iface->get_drive = g_hal_mount_get_drive;
+  iface->get_volume = g_hal_mount_get_volume;
+  iface->can_unmount = g_hal_mount_can_unmount;
+  iface->can_eject = g_hal_mount_can_eject;
+  iface->unmount = g_hal_mount_unmount;
+  iface->unmount_finish = g_hal_mount_unmount_finish;
+  iface->unmount_with_operation = g_hal_mount_unmount_with_operation;
+  iface->unmount_with_operation_finish = g_hal_mount_unmount_with_operation_finish;
+  iface->eject = g_hal_mount_eject;
+  iface->eject_finish = g_hal_mount_eject_finish;
+  iface->eject_with_operation = g_hal_mount_eject_with_operation;
+  iface->eject_with_operation_finish = g_hal_mount_eject_with_operation_finish;
+  iface->guess_content_type = g_hal_mount_guess_content_type;
+  iface->guess_content_type_finish = g_hal_mount_guess_content_type_finish;
+  iface->guess_content_type_sync = g_hal_mount_guess_content_type_sync;
+}

=== added file '.pc/03_xdg-mount.patch/monitor/hal/ghalvolume.c'
--- .pc/03_xdg-mount.patch/monitor/hal/ghalvolume.c	1970-01-01 00:00:00 +0000
+++ .pc/03_xdg-mount.patch/monitor/hal/ghalvolume.c	2011-09-27 06:17:30 +0000
@@ -0,0 +1,1007 @@
+/* GIO - GLib Input, Output and Streaming Library
+ *
+ * Copyright (C) 2006-2007 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Author: David Zeuthen <[e-mail]>
+ */
+
+#include <config.h>
+
+#include <string.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#include <glib.h>
+#include <glib/gi18n-lib.h>
+#include <gio/gio.h>
+
+#include "ghaldrive.h"
+#include "ghalvolume.h"
+#include "ghalmount.h"
+
+#include "hal-utils.h"
+
+struct _GHalVolume {
+  GObject parent;
+
+  GVolumeMonitor *volume_monitor; /* owned by volume monitor */
+  GHalMount      *mount;          /* owned by volume monitor */
+  GHalDrive      *drive;          /* owned by volume monitor */
+
+  char *device_path;
+  char *mount_path;
+  char *uuid;
+  HalDevice *device;
+  HalDevice *drive_device;
+
+  /* set on creation if we won't create a GHalMount object ourselves
+   * and instead except to adopt one, with the given mount root,
+   * via adopt_orphan_mount() 
+   */
+  GFile *foreign_mount_root;
+  GMount *foreign_mount;
+  gboolean is_mountable;
+  gboolean ignore_automount;
+
+  char *name;
+  char *icon;
+  char *icon_fallback;
+};
+
+static void g_hal_volume_volume_iface_init (GVolumeIface *iface);
+
+G_DEFINE_TYPE_EXTENDED (GHalVolume, g_hal_volume, G_TYPE_OBJECT, 0,
+                        G_IMPLEMENT_INTERFACE (G_TYPE_VOLUME,
+                                               g_hal_volume_volume_iface_init))
+
+static void
+g_hal_volume_finalize (GObject *object)
+{
+  GHalVolume *volume;
+  
+  volume = G_HAL_VOLUME (object);
+
+  if (volume->mount != NULL)
+    g_hal_mount_unset_volume (volume->mount, volume);
+
+  if (volume->drive != NULL)
+    g_hal_drive_unset_volume (volume->drive, volume);
+  
+  g_free (volume->mount_path);
+  g_free (volume->device_path);
+  g_free (volume->uuid);
+  if (volume->device != NULL)
+    g_object_unref (volume->device);
+  if (volume->drive_device != NULL)
+    g_object_unref (volume->drive_device);
+
+  if (volume->foreign_mount_root != NULL)
+    g_object_unref (volume->foreign_mount_root);
+
+  if (volume->foreign_mount != NULL)
+    g_object_unref (volume->foreign_mount);
+
+  if (volume->volume_monitor != NULL)
+    g_object_remove_weak_pointer (G_OBJECT (volume->volume_monitor), (gpointer) &(volume->volume_monitor));
+
+  g_free (volume->name);
+  g_free (volume->icon);
+  g_free (volume->icon_fallback);
+
+  if (G_OBJECT_CLASS (g_hal_volume_parent_class)->finalize)
+    (*G_OBJECT_CLASS (g_hal_volume_parent_class)->finalize) (object);
+}
+
+static void
+g_hal_volume_class_init (GHalVolumeClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+  gobject_class->finalize = g_hal_volume_finalize;
+}
+
+static void
+g_hal_volume_init (GHalVolume *hal_volume)
+{
+}
+
+static void
+emit_volume_changed (GHalVolume *volume)
+{
+  g_signal_emit_by_name (volume, "changed");
+  if (volume->volume_monitor != NULL)
+    g_signal_emit_by_name (volume->volume_monitor, "volume_changed", volume);
+}
+
+#define KILOBYTE_FACTOR 1000.0
+#define MEGABYTE_FACTOR (1000.0 * 1000.0)
+#define GIGABYTE_FACTOR (1000.0 * 1000.0 * 1000.0)
+
+/**
+ * format_size_for_display:
+ * @size: a number of octects
+ *
+ * Format a human readable string that can conveys how much storage a
+ * user-visible drive or piece of media can hold.
+ *
+ * As a matter of policy, we want this string to resemble what's on
+ * the packaging of the drive/media. Since all manufacturers use
+ * powers of 10, g_format_size_for_display() is not suitable here.
+ *
+ * TODO: we probably want to round to nearest power of two if @size is
+ * "close" (e.g. within 5%) - this is to avoid e.g. 63.4G when the
+ * packaging says "64G drive". We could also use per-drive or
+ * per-media quirks to make a better guess.
+ *
+ * Returns: A human readable string, caller must free it using
+ * g_free().
+ **/
+static char *
+format_size_for_display (guint64 size)
+{
+  char *str;
+  gdouble displayed_size;
+  
+  if (size < MEGABYTE_FACTOR)
+    {
+      displayed_size = (double) size / KILOBYTE_FACTOR;
+      str = g_strdup_printf (_("%.1f kB"), displayed_size);
+    } 
+  else if (size < GIGABYTE_FACTOR)
+    {
+      displayed_size = (double) size / MEGABYTE_FACTOR;
+      str = g_strdup_printf (_("%.1f MB"), displayed_size);
+    } 
+  else 
+    {
+      displayed_size = (double) size / GIGABYTE_FACTOR;
+      str = g_strdup_printf (_("%.1f GB"), displayed_size);
+    }
+  
+  return str;
+}
+
+static void
+do_update_from_hal (GHalVolume *mv)
+{
+  const char *drive_type;
+  const char *drive_bus;
+  gboolean drive_uses_removable_media;
+  const char *volume_fs_label;
+  guint64 volume_size;
+  gboolean volume_is_disc;
+  gboolean volume_disc_has_audio;
+  gboolean volume_disc_has_data;
+  const char *volume_disc_type;
+  gboolean volume_disc_is_blank;
+  const char *volume_fsusage;
+  const char *volume_fstype;
+  HalDevice *volume;
+  HalDevice *drive;
+  char *name;
+  char *size;
+  gboolean is_crypto;
+  gboolean is_crypto_cleartext;
+
+  volume = mv->device;
+  drive = mv->drive_device;
+  
+  drive_type = hal_device_get_property_string (drive, "storage.drive_type");
+  drive_bus = hal_device_get_property_string (drive, "storage.bus");
+  drive_uses_removable_media = hal_device_get_property_bool (drive, "storage.removable");
+  volume_fs_label = hal_device_get_property_string (volume, "volume.label");
+  volume_size = hal_device_get_property_uint64 (volume, "volume.size");
+  volume_is_disc = hal_device_get_property_bool (volume, "volume.is_disc");
+  volume_disc_has_audio = hal_device_get_property_bool (volume, "volume.disc.has_audio");
+  volume_disc_has_data = hal_device_get_property_bool (volume, "volume.disc.has_data");
+  volume_disc_is_blank = hal_device_get_property_bool (volume, "volume.disc.is_blank");
+  volume_disc_type = hal_device_get_property_string (volume, "volume.disc.type");
+  volume_fsusage = hal_device_get_property_string (volume, "volume.fsusage");
+  volume_fstype = hal_device_get_property_string (volume, "volume.fstype");
+
+  is_crypto = FALSE;
+  is_crypto_cleartext = FALSE;
+  if (strcmp (hal_device_get_property_string (volume, "volume.fsusage"), "crypto") == 0)
+    is_crypto = TRUE;
+  if (strlen (hal_device_get_property_string (volume, "volume.crypto_luks.clear.backing_volume")) > 0)
+    is_crypto_cleartext = TRUE;
+
+  if (volume_is_disc && volume_disc_has_audio && mv->foreign_mount_root != NULL)
+    name = g_strdup (_("Audio Disc"));
+  else
+    {
+      if (strcmp (volume_fsusage, "crypto") == 0 && strcmp (volume_fstype, "crypto_LUKS") == 0)
+        {
+          size = format_size_for_display (volume_size);
+          /* Translators: %s is the size of the volume (e.g. 512 MB) */
+          name = g_strdup_printf (_("%s Encrypted Data"), size);
+          g_free (size);
+        }
+      else
+        {
+          if (volume_fs_label != NULL && strlen (volume_fs_label) > 0)
+            name = g_strdup (volume_fs_label);
+          else if (volume_is_disc)
+            {
+              if (volume_disc_has_audio)
+                {
+                  if (volume_disc_has_data)
+                    name = g_strdup (_("Mixed Audio/Data Disc"));
+                  else
+                    name = g_strdup (_("Audio Disc"));
+                }
+              else
+                name = g_strdup (get_disc_name (volume_disc_type, volume_disc_is_blank));
+            }
+          else
+            {
+              size = format_size_for_display (volume_size);
+              /* Translators: %s is the size of the volume (e.g. 512 MB) */
+              name = g_strdup_printf (_("%s Media"), size);
+              g_free (size);
+            }
+        }
+    }
+
+  mv->name = name;
+  mv->icon = _drive_get_icon (drive); /* use the drive icon since we're unmounted */
+
+  if (is_crypto || is_crypto_cleartext)
+    {
+      mv->icon_fallback = mv->icon;
+      mv->icon = g_strdup ("drive-encrypted");
+    }
+
+  if (hal_device_get_property_bool (volume, "volume.is_mounted"))
+    mv->mount_path = g_strdup (hal_device_get_property_string (volume, "volume.mount_point"));
+  else
+    mv->mount_path = NULL;
+
+  g_object_set_data_full (G_OBJECT (mv), 
+                          "hal-storage-device-capabilities",
+                          dupv_and_uniqify (hal_device_get_property_strlist (mv->drive_device, "info.capabilities")),
+                          (GDestroyNotify) g_strfreev);
+
+  if (volume_disc_type != NULL && strlen (volume_disc_type) == 0)
+    volume_disc_type = NULL;
+  g_object_set_data_full (G_OBJECT (mv), 
+                          "hal-volume.disc.type",
+                          g_strdup (volume_disc_type),
+                          (GDestroyNotify) g_free);
+}
+
+static void
+update_from_hal (GHalVolume *mv, gboolean emit_changed)
+{
+  char *old_name;
+  char *old_icon;
+  char *old_mount_path;
+
+  old_name = g_strdup (mv->name);
+  old_icon = g_strdup (mv->icon);
+  old_mount_path = g_strdup (mv->mount_path);
+
+  g_free (mv->name);
+  g_free (mv->icon);
+  g_free (mv->mount_path);
+  do_update_from_hal (mv);
+
+  if (emit_changed)
+    {
+      gboolean mount_path_changed;
+
+      if ((old_mount_path == NULL && mv->mount_path != NULL) ||
+          (old_mount_path != NULL && mv->mount_path == NULL) ||
+          (old_mount_path != NULL && mv->mount_path != NULL && strcmp (old_mount_path, mv->mount_path) != 0))
+        mount_path_changed = TRUE;
+      else
+        mount_path_changed = FALSE;
+
+      if (mount_path_changed ||
+          (old_name == NULL || 
+           old_icon == NULL ||
+           strcmp (old_name, mv->name) != 0 ||
+           strcmp (old_icon, mv->icon) != 0))
+	emit_volume_changed (mv);
+    }
+  g_free (old_name);
+  g_free (old_icon);
+  g_free (old_mount_path);
+}
+
+static void
+hal_changed (HalDevice *device, const char *key, gpointer user_data)
+{
+  GHalVolume *hal_volume = G_HAL_VOLUME (user_data);
+  
+  /*g_warning ("hal modifying %s (property %s changed)", hal_volume->device_path, key);*/
+  update_from_hal (hal_volume, TRUE);
+}
+
+static void
+compute_uuid (GHalVolume *volume)
+{
+  const char *fs_uuid;
+  const char *fs_label;
+
+  /* use the FS uuid before falling back to the FS label */
+
+  fs_uuid = hal_device_get_property_string (volume->device, "volume.uuid");
+  fs_label = hal_device_get_property_string (volume->device, "volume.label");
+
+  if (strlen (fs_uuid) == 0)
+    {
+      if (strlen (fs_label) == 0)
+        volume->uuid = NULL;
+      else
+        volume->uuid = g_strdup (fs_label);
+    }
+  else
+    volume->uuid = g_strdup (fs_uuid);
+}
+
+GHalVolume *
+g_hal_volume_new (GVolumeMonitor   *volume_monitor,
+                  HalDevice        *device,
+                  HalPool          *pool,
+                  GFile            *foreign_mount_root,
+                  gboolean          is_mountable,
+                  GHalDrive        *drive)
+{
+  GHalVolume *volume;
+  HalDevice *drive_device;
+  const char *storage_udi;
+  const char *device_path;
+  gboolean ignore_automount;
+
+  ignore_automount = FALSE;
+  
+  if (hal_device_has_capability (device, "block"))
+    {
+      storage_udi = hal_device_get_property_string (device, "block.storage_device");
+      if (storage_udi == NULL)
+        return NULL;
+      
+      drive_device = hal_pool_get_device_by_udi (pool, storage_udi);
+      if (drive_device == NULL)
+        return NULL;
+      
+      device_path = hal_device_get_property_string (device, "block.device");
+    }
+  else
+    {
+      return NULL;
+    }
+
+  if (drive_device && 
+      hal_device_has_property (drive_device, "storage.automount_enabled_hint") &&
+      !hal_device_get_property_bool (drive_device, "storage.automount_enabled_hint"))
+    ignore_automount = TRUE;
+  
+  volume = g_object_new (G_TYPE_HAL_VOLUME, NULL);
+  volume->volume_monitor = volume_monitor;
+  g_object_add_weak_pointer (G_OBJECT (volume_monitor), (gpointer) &(volume->volume_monitor));
+  volume->mount_path = NULL;
+  volume->device_path = g_strdup (device_path);
+  volume->device = g_object_ref (device);
+  volume->drive_device = g_object_ref (drive_device);
+  volume->foreign_mount_root = foreign_mount_root != NULL ? g_object_ref (foreign_mount_root) : NULL;
+  volume->is_mountable = is_mountable;
+  volume->ignore_automount = ignore_automount || ! hal_device_is_recently_plugged_in (device);
+  
+  g_signal_connect_object (device, "hal_property_changed", (GCallback) hal_changed, volume, 0);
+  g_signal_connect_object (drive_device, "hal_property_changed", (GCallback) hal_changed, volume, 0);
+
+  compute_uuid (volume);
+  update_from_hal (volume, FALSE);
+
+  /* need to do this last */
+  volume->drive = drive;
+  if (drive != NULL)
+    g_hal_drive_set_volume (drive, volume);
+  
+  return volume;
+}
+
+/**
+ * g_hal_volume_removed:
+ * @volume:
+ * 
+ **/
+void
+g_hal_volume_removed (GHalVolume *volume)
+{
+
+  if (volume->mount != NULL)
+    {
+      g_hal_mount_unset_volume (volume->mount, volume);
+      volume->mount = NULL;
+    }
+
+  if (volume->drive != NULL)
+    {
+      g_hal_drive_unset_volume (volume->drive, volume);
+      volume->drive = NULL;
+    }
+}
+
+void
+g_hal_volume_set_mount (GHalVolume  *volume,
+                        GHalMount *mount)
+{
+  if (volume->mount != mount)
+    {
+      
+      if (volume->mount != NULL)
+        g_hal_mount_unset_volume (volume->mount, volume);
+      
+      volume->mount = mount;
+
+      emit_volume_changed (volume);
+    }
+}
+ 
+void
+g_hal_volume_unset_mount (GHalVolume  *volume,
+                          GHalMount *mount)
+{
+  if (volume->mount == mount)
+    {
+      volume->mount = NULL;
+      emit_volume_changed (volume);
+    }
+}
+
+void
+g_hal_volume_set_drive (GHalVolume  *volume,
+                        GHalDrive *drive)
+{
+  if (volume->drive != drive)
+    {
+      if (volume->drive != NULL)
+        g_hal_drive_unset_volume (volume->drive, volume);
+      
+      volume->drive = drive;
+      
+      emit_volume_changed (volume);
+    }
+}
+
+void
+g_hal_volume_unset_drive (GHalVolume  *volume,
+                          GHalDrive *drive)
+{
+  if (volume->drive == drive)
+    {
+      volume->drive = NULL;
+      emit_volume_changed (volume);
+    }
+}
+
+static GIcon *
+g_hal_volume_get_icon (GVolume *volume)
+{
+  GHalVolume *hal_volume = G_HAL_VOLUME (volume);
+  GIcon *icon;
+  const char *name;
+  const char *fallback;
+
+  name = hal_volume->icon;
+
+  if (hal_volume->icon_fallback)
+    fallback = hal_volume->icon_fallback;
+  else /* if no custom fallbacks are set, use the icon to create them */
+    fallback = name;
+
+  icon = get_themed_icon_with_fallbacks (name, fallback);
+  return icon;
+}
+
+static char *
+g_hal_volume_get_name (GVolume *volume)
+{
+  GHalVolume *hal_volume = G_HAL_VOLUME (volume);
+
+  return g_strdup (hal_volume->name);
+}
+
+static char *
+g_hal_volume_get_uuid (GVolume *volume)
+{
+  GHalVolume *hal_volume = G_HAL_VOLUME (volume);
+
+  return g_strdup (hal_volume->uuid);
+}
+
+static gboolean
+g_hal_volume_can_mount (GVolume *volume)
+{
+  GHalVolume *hal_volume = G_HAL_VOLUME (volume);
+
+  return hal_volume->is_mountable;
+}
+
+static gboolean
+g_hal_volume_can_eject (GVolume *volume)
+{
+  GHalVolume *hal_volume = G_HAL_VOLUME (volume);
+  gboolean res;
+
+  res = FALSE;
+  if (hal_volume->drive != NULL)
+    res = g_drive_can_eject (G_DRIVE (hal_volume->drive));
+  
+  return res;
+}
+
+static gboolean
+g_hal_volume_should_automount (GVolume *volume)
+{
+  GHalVolume *hal_volume = G_HAL_VOLUME (volume);
+
+  return  ! (hal_volume->ignore_automount);
+}
+
+static GDrive *
+g_hal_volume_get_drive (GVolume *volume)
+{
+  GHalVolume *hal_volume = G_HAL_VOLUME (volume);
+  GDrive *drive;
+
+  drive = NULL;
+  if (hal_volume->drive != NULL)
+    drive = g_object_ref (hal_volume->drive);
+  
+  return drive;
+}
+
+static GMount *
+g_hal_volume_get_mount (GVolume *volume)
+{
+  GHalVolume *hal_volume = G_HAL_VOLUME (volume);
+  GMount *mount;
+
+  mount = NULL;
+  if (hal_volume->foreign_mount != NULL)
+    mount = g_object_ref (hal_volume->foreign_mount);
+  else if (hal_volume->mount != NULL)
+    mount = g_object_ref (hal_volume->mount);
+
+  return mount;
+}
+
+gboolean
+g_hal_volume_has_mount_path (GHalVolume *volume,
+                             const char  *mount_path)
+{
+  gboolean res;
+
+  res = FALSE;
+  if (volume->mount_path != NULL)
+    res = strcmp (volume->mount_path, mount_path) == 0;
+
+  return res;
+}
+
+gboolean
+g_hal_volume_has_device_path (GHalVolume *volume,
+                              const char  *device_path)
+{
+  gboolean res;
+
+  res = FALSE;
+  if (volume->device_path != NULL)
+    res = strcmp (volume->device_path, device_path) == 0;
+  return res;
+}
+
+gboolean
+g_hal_volume_has_udi (GHalVolume  *volume,
+                      const char  *udi)
+{
+  GHalVolume *hal_volume = G_HAL_VOLUME (volume);
+  gboolean res;
+  
+  res = FALSE;
+  if (hal_volume->device != NULL)
+    res = strcmp (hal_device_get_udi (hal_volume->device), udi) == 0;
+  return res;
+}
+
+gboolean
+g_hal_volume_has_uuid (GHalVolume  *volume,
+                       const char  *uuid)
+{
+  GHalVolume *hal_volume = G_HAL_VOLUME (volume);
+  gboolean res;
+
+  res = FALSE;
+  if (hal_volume->uuid != NULL)
+    res = strcmp (hal_volume->uuid, uuid) == 0;
+
+  return res;
+}
+
+static void
+foreign_mount_unmounted (GMount *mount, gpointer user_data)
+{
+  GHalVolume *volume = G_HAL_VOLUME (user_data);
+  gboolean check;
+
+  check = volume->foreign_mount == mount;
+  if (check)
+    g_hal_volume_adopt_foreign_mount (volume, NULL);
+}
+
+void
+g_hal_volume_adopt_foreign_mount (GHalVolume *volume, GMount *foreign_mount)
+{
+  if (volume->foreign_mount != NULL)
+    g_object_unref (volume->foreign_mount);
+
+  if (foreign_mount != NULL)
+    {
+      volume->foreign_mount =  g_object_ref (foreign_mount);
+      g_signal_connect_object (foreign_mount, "unmounted", (GCallback) foreign_mount_unmounted, volume, 0);
+    }
+  else
+    volume->foreign_mount =  NULL;
+  
+  emit_volume_changed (volume);
+}
+
+gboolean
+g_hal_volume_has_foreign_mount_root (GHalVolume       *volume,
+                                     GFile            *mount_root)
+{
+  GHalVolume *hal_volume = G_HAL_VOLUME (volume);
+  gboolean res;
+
+  res = FALSE;
+  if (hal_volume->foreign_mount_root != NULL)
+    res = g_file_equal (hal_volume->foreign_mount_root, mount_root);
+  
+  return res;
+}
+
+
+typedef struct {
+  GObject *object;
+  GAsyncReadyCallback callback;
+  gpointer user_data;
+  GCancellable *cancellable;
+} SpawnOp;
+
+static void 
+spawn_cb (GPid pid, gint status, gpointer user_data)
+{
+  SpawnOp *data = user_data;
+  GSimpleAsyncResult *simple;
+
+  /* ensure that the #GHalMount corrosponding to the #GHalVolume we've
+   * mounted is made available before returning to the user (make sure
+   * we don't emit the signals in idle; see #552168).
+   */
+  g_hal_volume_monitor_force_update (G_HAL_VOLUME_MONITOR (G_HAL_VOLUME (data->object)->volume_monitor), FALSE);
+
+  if (WEXITSTATUS (status) != 0)
+    {
+      GError *error;
+      error = g_error_new_literal (G_IO_ERROR, 
+                                   G_IO_ERROR_FAILED_HANDLED,
+                                   "You are not supposed to show G_IO_ERROR_FAILED_HANDLED in the UI");
+      simple = g_simple_async_result_new_from_error (data->object,
+                                                     data->callback,
+                                                     data->user_data,
+                                                     error);
+      g_error_free (error);
+    }
+  else
+    {
+      simple = g_simple_async_result_new (data->object,
+                                          data->callback,
+                                          data->user_data,
+                                          NULL);
+    }
+
+  g_simple_async_result_complete (simple);
+  g_object_unref (simple);
+  g_object_unref (data->object);
+  g_free (data);
+}
+
+static void
+spawn_do (GVolume             *volume,
+          GCancellable        *cancellable,
+          GAsyncReadyCallback  callback,
+          gpointer             user_data,
+          char               **argv)
+{
+  SpawnOp *data;
+  GPid child_pid;
+  GError *error;
+
+  data = g_new0 (SpawnOp, 1);
+  data->object = g_object_ref (volume);
+  data->callback = callback;
+  data->user_data = user_data;
+  data->cancellable = cancellable;
+  
+  error = NULL;
+  if (!g_spawn_async (NULL,         /* working dir */
+                      argv,
+                      NULL,         /* envp */
+                      G_SPAWN_DO_NOT_REAP_CHILD|G_SPAWN_SEARCH_PATH,
+                      NULL,         /* child_setup */
+                      NULL,         /* user_data for child_setup */
+                      &child_pid,
+                      &error))
+    {
+      g_simple_async_report_gerror_in_idle (data->object,
+                                            data->callback,
+                                            data->user_data,
+                                            error);
+      g_object_unref (data->object);
+      g_error_free (error);
+      g_free (data);
+      return;
+    }
+  
+  g_child_watch_add (child_pid, spawn_cb, data);
+}
+
+typedef struct
+{
+  GHalVolume *enclosing_volume;
+  GAsyncReadyCallback  callback;
+  gpointer user_data;
+} ForeignMountOp;
+
+static void
+mount_foreign_callback (GObject *source_object,
+                        GAsyncResult *res,
+                        gpointer user_data)
+{
+  ForeignMountOp *data = user_data;
+  data->callback (G_OBJECT (data->enclosing_volume), res, data->user_data);
+  g_object_unref (data->enclosing_volume);
+  g_free (data);
+}
+
+static void
+g_hal_volume_mount (GVolume             *volume,
+                    GMountMountFlags     flags,
+                    GMountOperation     *mount_operation,
+                    GCancellable        *cancellable,
+                    GAsyncReadyCallback  callback,
+                    gpointer             user_data)
+{
+  GHalVolume *hal_volume = G_HAL_VOLUME (volume);
+
+  /*g_warning ("hal_volume_mount (can_mount=%d foreign=%p device_path=%s)", 
+              g_hal_volume_can_mount (volume),
+              hal_volume->foreign_mount_root,
+              hal_volume->device_path);*/
+
+  if (hal_volume->foreign_mount_root != NULL)
+    {
+      ForeignMountOp *data;
+
+      data = g_new0 (ForeignMountOp, 1);
+      data->enclosing_volume = g_object_ref (hal_volume);
+      data->callback = callback;
+      data->user_data = user_data;
+
+      g_file_mount_enclosing_volume (hal_volume->foreign_mount_root,
+                                     0,
+                                     mount_operation, 
+                                     cancellable, 
+                                     mount_foreign_callback, 
+                                     data);
+    }
+  else
+    {
+      char *argv[] = {"gnome-mount", "-b", "-d", NULL, NULL, NULL};
+      argv[3] = hal_volume->device_path;
+      /* ask for no dialogs if mount_operation is NULL */
+      if (mount_operation == NULL)
+        argv[4] = "-n";
+      spawn_do (volume, cancellable, callback, user_data, argv);
+    }
+}
+
+static gboolean
+g_hal_volume_mount_finish (GVolume       *volume,
+                           GAsyncResult  *result,
+                           GError       **error)
+{
+  GHalVolume *hal_volume = G_HAL_VOLUME (volume);
+  gboolean res;
+
+  res = TRUE;
+  
+  if (hal_volume->foreign_mount_root != NULL)
+    res = g_file_mount_enclosing_volume_finish (hal_volume->foreign_mount_root, result, error);
+  
+  return res;
+}
+
+typedef struct {
+  GObject *object;
+  GAsyncReadyCallback callback;
+  gpointer user_data;
+} EjectWrapperOp;
+
+static void
+eject_wrapper_callback (GObject *source_object,
+                        GAsyncResult *res,
+                        gpointer user_data)
+{
+  EjectWrapperOp *data  = user_data;
+  data->callback (data->object, res, data->user_data);
+  g_object_unref (data->object);
+  g_free (data);
+}
+
+static void
+g_hal_volume_eject_with_operation (GVolume              *volume,
+                                   GMountUnmountFlags   flags,
+                                   GMountOperation     *mount_operation,
+                                   GCancellable        *cancellable,
+                                   GAsyncReadyCallback  callback,
+                                   gpointer             user_data)
+{
+  GHalVolume *hal_volume = G_HAL_VOLUME (volume);
+  GHalDrive *drive;
+
+  /*g_warning ("hal_volume_eject");*/
+
+  drive = NULL;
+  if (hal_volume->drive != NULL)
+    drive = g_object_ref (hal_volume->drive);
+
+  if (drive != NULL)
+    {
+      EjectWrapperOp *data;
+      data = g_new0 (EjectWrapperOp, 1);
+      data->object = g_object_ref (volume);
+      data->callback = callback;
+      data->user_data = user_data;
+      g_drive_eject_with_operation (G_DRIVE (drive), flags, mount_operation, cancellable, eject_wrapper_callback, data);
+      g_object_unref (drive);
+    }
+}
+
+static gboolean
+g_hal_volume_eject_with_operation_finish (GVolume        *volume,
+                                          GAsyncResult  *result,
+                                          GError       **error)
+{
+  GHalVolume *hal_volume = G_HAL_VOLUME (volume);
+  gboolean res;
+
+  res = TRUE;
+  if (hal_volume->drive != NULL)
+    res = g_drive_eject_with_operation_finish (G_DRIVE (hal_volume->drive), result, error);
+  return res;
+}
+
+static void
+g_hal_volume_eject (GVolume              *volume,
+                    GMountUnmountFlags   flags,
+                    GCancellable        *cancellable,
+                    GAsyncReadyCallback  callback,
+                    gpointer             user_data)
+{
+  return g_hal_volume_eject_with_operation (volume, flags, NULL, cancellable, callback, user_data);
+}
+
+static gboolean
+g_hal_volume_eject_finish (GVolume        *volume,
+                           GAsyncResult  *result,
+                           GError       **error)
+{
+  return g_hal_volume_eject_with_operation_finish (volume, result, error);
+}
+
+static char *
+g_hal_volume_get_identifier (GVolume              *volume,
+                             const char          *kind)
+{
+  GHalVolume *hal_volume = G_HAL_VOLUME (volume);
+  char *id;
+
+  id = NULL;
+  if (strcmp (kind, G_VOLUME_IDENTIFIER_KIND_HAL_UDI) == 0)
+    id = g_strdup (hal_device_get_udi (hal_volume->device));
+  else if (strcmp (kind, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE) == 0)
+    id = g_strdup (hal_volume->device_path);
+  else if (strcmp (kind, G_VOLUME_IDENTIFIER_KIND_LABEL) == 0)
+    id = g_strdup (hal_device_get_property_string (hal_volume->device, "volume.label"));
+  else if (strcmp (kind, G_VOLUME_IDENTIFIER_KIND_UUID) == 0)
+    id = g_strdup (hal_device_get_property_string (hal_volume->device, "volume.uuid"));
+  
+  return id;
+}
+
+static char **
+g_hal_volume_enumerate_identifiers (GVolume *volume)
+{
+  GHalVolume *hal_volume = G_HAL_VOLUME (volume);
+  GPtrArray *res;
+  const char *label, *uuid;
+
+  res = g_ptr_array_new ();
+
+  g_ptr_array_add (res,
+                   g_strdup (G_VOLUME_IDENTIFIER_KIND_HAL_UDI));
+
+  if (hal_volume->device_path && *hal_volume->device_path != 0)
+    g_ptr_array_add (res,
+                     g_strdup (G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE));
+
+  label = hal_device_get_property_string (hal_volume->device, "volume.label");
+  uuid = hal_device_get_property_string (hal_volume->device, "volume.uuid");
+
+  if (label && *label != 0)
+    g_ptr_array_add (res,
+                     g_strdup (G_VOLUME_IDENTIFIER_KIND_LABEL));
+
+  if (uuid && *uuid != 0)
+    g_ptr_array_add (res,
+                     g_strdup (G_VOLUME_IDENTIFIER_KIND_UUID));
+
+  /* Null-terminate */
+  g_ptr_array_add (res, NULL);
+
+  return (char **)g_ptr_array_free (res, FALSE);
+}
+
+static GFile *
+g_hal_volume_get_activation_root (GVolume *volume)
+{
+  GHalVolume *hal_volume = G_HAL_VOLUME (volume);
+  GFile *root = NULL;
+
+  if (hal_volume->foreign_mount_root != NULL)
+    root = g_object_ref (hal_volume->foreign_mount_root);
+
+  return root;
+}
+
+static void
+g_hal_volume_volume_iface_init (GVolumeIface *iface)
+{
+  iface->get_name = g_hal_volume_get_name;
+  iface->get_icon = g_hal_volume_get_icon;
+  iface->get_uuid = g_hal_volume_get_uuid;
+  iface->get_drive = g_hal_volume_get_drive;
+  iface->get_mount = g_hal_volume_get_mount;
+  iface->can_mount = g_hal_volume_can_mount;
+  iface->can_eject = g_hal_volume_can_eject;
+  iface->should_automount = g_hal_volume_should_automount;
+  iface->mount_fn = g_hal_volume_mount;
+  iface->mount_finish = g_hal_volume_mount_finish;
+  iface->eject = g_hal_volume_eject;
+  iface->eject_finish = g_hal_volume_eject_finish;
+  iface->eject_with_operation = g_hal_volume_eject_with_operation;
+  iface->eject_with_operation_finish = g_hal_volume_eject_with_operation_finish;
+  iface->get_identifier = g_hal_volume_get_identifier;
+  iface->enumerate_identifiers = g_hal_volume_enumerate_identifiers;
+  iface->get_activation_root = g_hal_volume_get_activation_root;
+}

=== added directory '.pc/04_hurd_path_max.patch'
=== added file '.pc/04_hurd_path_max.patch/.timestamp'
=== added directory '.pc/04_hurd_path_max.patch/monitor'
=== added directory '.pc/04_hurd_path_max.patch/monitor/gdu'
=== added file '.pc/04_hurd_path_max.patch/monitor/gdu/ggduvolumemonitor.c'
--- .pc/04_hurd_path_max.patch/monitor/gdu/ggduvolumemonitor.c	1970-01-01 00:00:00 +0000
+++ .pc/04_hurd_path_max.patch/monitor/gdu/ggduvolumemonitor.c	2011-09-27 06:17:30 +0000
@@ -0,0 +1,1799 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/* gvfs - extensions for gio
+ *
+ * Copyright (C) 2006-2009 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Author: David Zeuthen <[e-mail]>
+ */
+
+#include <config.h>
+
+#include <limits.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include <glib.h>
+#include <glib/gi18n-lib.h>
+#include <gio/gio.h>
+
+#include "ggduvolumemonitor.h"
+#include "ggdumount.h"
+#include "ggduvolume.h"
+#include "ggdudrive.h"
+
+static GGduVolumeMonitor *the_volume_monitor = NULL;
+
+struct _GGduVolumeMonitor {
+  GNativeVolumeMonitor parent;
+
+  GUnixMountMonitor *mount_monitor;
+
+  GduPool *pool;
+
+  GList *last_optical_disc_devices;
+  GList *last_mountpoints;
+  GList *last_mounts;
+
+  GList *drives;
+  GList *volumes;
+  GList *fstab_volumes;
+  GList *mounts;
+
+  /* we keep volumes/mounts for blank and audio discs separate to handle e.g. mixed discs properly */
+  GList *disc_volumes;
+  GList *disc_mounts;
+
+};
+
+static void mountpoints_changed      (GUnixMountMonitor  *mount_monitor,
+                                      gpointer            user_data);
+static void mounts_changed           (GUnixMountMonitor  *mount_monitor,
+                                      gpointer            user_data);
+
+static void presentable_added (GduPool        *pool,
+                               GduPresentable *presentable,
+                               gpointer        user_data);
+static void presentable_removed (GduPool        *pool,
+                                 GduPresentable *presentable,
+                                 gpointer        user_data);
+
+static void update_all               (GGduVolumeMonitor *monitor,
+                                      gboolean emit_changes);
+
+static void update_drives            (GGduVolumeMonitor *monitor,
+                                      GList **added_drives,
+                                      GList **removed_drives);
+static void update_volumes           (GGduVolumeMonitor *monitor,
+                                      GList **added_volumes,
+                                      GList **removed_volumes);
+static void update_fstab_volumes     (GGduVolumeMonitor *monitor,
+                                      GList **added_volumes,
+                                      GList **removed_volumes);
+static void update_mounts            (GGduVolumeMonitor *monitor,
+                                      GList **added_mounts,
+                                      GList **removed_mounts);
+static void update_discs             (GGduVolumeMonitor *monitor,
+                                      GList **added_volumes,
+                                      GList **removed_volumes,
+                                      GList **added_mounts,
+                                      GList **removed_mounts);
+
+
+G_DEFINE_TYPE (GGduVolumeMonitor, g_gdu_volume_monitor, G_TYPE_NATIVE_VOLUME_MONITOR)
+
+static void
+list_free (GList *objects)
+{
+  g_list_foreach (objects, (GFunc)g_object_unref, NULL);
+  g_list_free (objects);
+}
+
+static void
+g_gdu_volume_monitor_dispose (GObject *object)
+{
+  the_volume_monitor = NULL;
+
+  if (G_OBJECT_CLASS (g_gdu_volume_monitor_parent_class)->dispose)
+    (*G_OBJECT_CLASS (g_gdu_volume_monitor_parent_class)->dispose) (object);
+}
+
+static void
+g_gdu_volume_monitor_finalize (GObject *object)
+{
+  GGduVolumeMonitor *monitor;
+
+  monitor = G_GDU_VOLUME_MONITOR (object);
+
+  g_signal_handlers_disconnect_by_func (monitor->mount_monitor, mountpoints_changed, monitor);
+  g_signal_handlers_disconnect_by_func (monitor->mount_monitor, mounts_changed, monitor);
+  g_signal_handlers_disconnect_by_func (monitor->mount_monitor, presentable_added, monitor);
+  g_signal_handlers_disconnect_by_func (monitor->mount_monitor, presentable_removed, monitor);
+
+  g_object_unref (monitor->mount_monitor);
+
+  g_object_unref (monitor->pool);
+
+  list_free (monitor->last_optical_disc_devices);
+  list_free (monitor->last_mountpoints);
+  g_list_foreach (monitor->last_mounts,
+                  (GFunc)g_unix_mount_free, NULL);
+  g_list_free (monitor->last_mounts);
+
+  list_free (monitor->drives);
+  list_free (monitor->fstab_volumes);
+  list_free (monitor->volumes);
+  list_free (monitor->mounts);
+
+  list_free (monitor->disc_volumes);
+  list_free (monitor->disc_mounts);
+
+  if (G_OBJECT_CLASS (g_gdu_volume_monitor_parent_class)->finalize)
+    (*G_OBJECT_CLASS (g_gdu_volume_monitor_parent_class)->finalize) (object);
+}
+
+static GList *
+get_mounts (GVolumeMonitor *volume_monitor)
+{
+  GGduVolumeMonitor *monitor;
+  GList *l, *ll;
+
+  monitor = G_GDU_VOLUME_MONITOR (volume_monitor);
+
+  l = g_list_copy (monitor->mounts);
+  ll = g_list_copy (monitor->disc_mounts);
+  l = g_list_concat (l, ll);
+
+  g_list_foreach (l, (GFunc)g_object_ref, NULL);
+
+  return l;
+}
+
+static GList *
+get_volumes (GVolumeMonitor *volume_monitor)
+{
+  GGduVolumeMonitor *monitor;
+  GList *l, *ll;
+
+  monitor = G_GDU_VOLUME_MONITOR (volume_monitor);
+
+  l = g_list_copy (monitor->volumes);
+  ll = g_list_copy (monitor->fstab_volumes);
+  l = g_list_concat (l, ll);
+  ll = g_list_copy (monitor->disc_volumes);
+  l = g_list_concat (l, ll);
+
+  g_list_foreach (l, (GFunc)g_object_ref, NULL);
+
+  return l;
+}
+
+static GList *
+get_connected_drives (GVolumeMonitor *volume_monitor)
+{
+  GGduVolumeMonitor *monitor;
+  GList *l;
+
+  monitor = G_GDU_VOLUME_MONITOR (volume_monitor);
+
+  l = g_list_copy (monitor->drives);
+  g_list_foreach (l, (GFunc)g_object_ref, NULL);
+
+  return l;
+}
+
+static GVolume *
+get_volume_for_uuid (GVolumeMonitor *volume_monitor, const char *uuid)
+{
+  GGduVolumeMonitor *monitor;
+  GGduVolume *volume;
+  GList *l;
+
+  monitor = G_GDU_VOLUME_MONITOR (volume_monitor);
+
+  volume = NULL;
+
+  for (l = monitor->volumes; l != NULL; l = l->next)
+    {
+      volume = l->data;
+      if (g_gdu_volume_has_uuid (volume, uuid))
+        goto found;
+    }
+
+  for (l = monitor->fstab_volumes; l != NULL; l = l->next)
+    {
+      volume = l->data;
+      if (g_gdu_volume_has_uuid (volume, uuid))
+        goto found;
+    }
+
+  for (l = monitor->disc_volumes; l != NULL; l = l->next)
+    {
+      volume = l->data;
+      if (g_gdu_volume_has_uuid (volume, uuid))
+        goto found;
+    }
+
+  return NULL;
+
+ found:
+
+  g_object_ref (volume);
+
+  return (GVolume *)volume;
+}
+
+static GMount *
+get_mount_for_uuid (GVolumeMonitor *volume_monitor, const char *uuid)
+{
+  GGduVolumeMonitor *monitor;
+  GGduMount *mount;
+  GList *l;
+
+  monitor = G_GDU_VOLUME_MONITOR (volume_monitor);
+
+  mount = NULL;
+
+  for (l = monitor->mounts; l != NULL; l = l->next)
+    {
+      mount = l->data;
+      if (g_gdu_mount_has_uuid (mount, uuid))
+        goto found;
+    }
+
+  for (l = monitor->disc_mounts; l != NULL; l = l->next)
+    {
+      mount = l->data;
+      if (g_gdu_mount_has_uuid (mount, uuid))
+        goto found;
+    }
+
+  return NULL;
+
+ found:
+
+  g_object_ref (mount);
+
+  return (GMount *)mount;
+}
+
+static GMount *
+get_mount_for_mount_path (const char *mount_path,
+                          GCancellable *cancellable)
+{
+  GMount *mount;
+  GGduMount *gdu_mount;
+  GGduVolumeMonitor *volume_monitor;
+
+  if (the_volume_monitor == NULL)
+    {
+      /* Dammit, no monitor is set up.. so we have to create one, find
+       * what the user asks for and throw it away again.
+       *
+       * What a waste - especially considering that there's IO
+       * involved in doing this: connect to the system message bus;
+       * IPC to DeviceKit-disks etc etc
+       */
+      volume_monitor = G_GDU_VOLUME_MONITOR (g_gdu_volume_monitor_new ());
+    }
+  else
+    {
+      volume_monitor = g_object_ref (the_volume_monitor);
+    }
+
+  mount = NULL;
+
+  /* creation of the volume monitor might actually fail */
+  if (volume_monitor != NULL)
+    {
+      GList *l;
+
+      for (l = volume_monitor->mounts; l != NULL; l = l->next)
+        {
+          gdu_mount = l->data;
+
+          if (g_gdu_mount_has_mount_path (gdu_mount, mount_path))
+            {
+              mount = g_object_ref (gdu_mount);
+              break;
+            }
+        }
+    }
+
+  g_object_unref (volume_monitor);
+
+  return (GMount *) mount;
+}
+
+static void
+mountpoints_changed (GUnixMountMonitor *mount_monitor,
+                     gpointer           user_data)
+{
+  GGduVolumeMonitor *monitor = G_GDU_VOLUME_MONITOR (user_data);
+
+  update_all (monitor, TRUE);
+}
+
+static void
+mounts_changed (GUnixMountMonitor *mount_monitor,
+                gpointer           user_data)
+{
+  GGduVolumeMonitor *monitor = G_GDU_VOLUME_MONITOR (user_data);
+
+  update_all (monitor, TRUE);
+}
+
+static void
+presentable_added (GduPool        *pool,
+                   GduPresentable *presentable,
+                   gpointer        user_data)
+{
+  GGduVolumeMonitor *monitor = G_GDU_VOLUME_MONITOR (user_data);
+
+  /*g_debug ("presentable_added %p: %s", presentable, gdu_presentable_get_id (presentable));*/
+
+  update_all (monitor, TRUE);
+}
+
+static void
+presentable_removed (GduPool        *pool,
+                     GduPresentable *presentable,
+                     gpointer        user_data)
+{
+  GGduVolumeMonitor *monitor = G_GDU_VOLUME_MONITOR (user_data);
+
+  /*g_debug ("presentable_removed %p: %s", presentable, gdu_presentable_get_id (presentable));*/
+
+  update_all (monitor, TRUE);
+}
+
+static void
+presentable_changed (GduPool        *pool,
+                     GduPresentable *presentable,
+                     gpointer        user_data)
+{
+  GGduVolumeMonitor *monitor = G_GDU_VOLUME_MONITOR (user_data);
+
+  /*g_debug ("presentable_changed %p: %s", presentable, gdu_presentable_get_id (presentable));*/
+
+  update_all (monitor, TRUE);
+}
+
+static void
+presentable_job_changed (GduPool        *pool,
+                         GduPresentable *presentable,
+                         gpointer        user_data)
+{
+  GGduVolumeMonitor *monitor = G_GDU_VOLUME_MONITOR (user_data);
+
+  /*g_debug ("presentable_job_changed %p: %s", presentable, gdu_presentable_get_id (presentable));*/
+
+  update_all (monitor, TRUE);
+}
+
+static GObject *
+g_gdu_volume_monitor_constructor (GType                  type,
+                                  guint                  n_construct_properties,
+                                  GObjectConstructParam *construct_properties)
+{
+  GObject *object;
+  GGduVolumeMonitor *monitor;
+  GGduVolumeMonitorClass *klass;
+  GObjectClass *parent_class;
+
+  if (the_volume_monitor != NULL)
+    {
+      object = g_object_ref (the_volume_monitor);
+      return object;
+    }
+
+  /*g_warning ("creating gdu vm");*/
+
+  object = NULL;
+
+  /* Invoke parent constructor. */
+  klass = G_GDU_VOLUME_MONITOR_CLASS (g_type_class_peek (G_TYPE_GDU_VOLUME_MONITOR));
+  parent_class = G_OBJECT_CLASS (g_type_class_peek_parent (klass));
+  object = parent_class->constructor (type,
+                                      n_construct_properties,
+                                      construct_properties);
+
+  monitor = G_GDU_VOLUME_MONITOR (object);
+
+  monitor->mount_monitor = g_unix_mount_monitor_new ();
+
+  g_signal_connect (monitor->mount_monitor,
+                    "mounts_changed",
+                    G_CALLBACK (mounts_changed),
+                    monitor);
+
+  g_signal_connect (monitor->mount_monitor,
+                    "mountpoints_changed",
+                    G_CALLBACK (mountpoints_changed),
+                    monitor);
+
+  monitor->pool = gdu_pool_new ();
+
+  g_signal_connect (monitor->pool,
+                    "presentable_added",
+                    G_CALLBACK (presentable_added),
+                    monitor);
+
+  g_signal_connect (monitor->pool,
+                    "presentable_removed",
+                    G_CALLBACK (presentable_removed),
+                    monitor);
+
+  g_signal_connect (monitor->pool,
+                    "presentable_changed",
+                    G_CALLBACK (presentable_changed),
+                    monitor);
+
+  g_signal_connect (monitor->pool,
+                    "presentable_job_changed",
+                    G_CALLBACK (presentable_job_changed),
+                    monitor);
+
+  update_all (monitor, FALSE);
+
+  the_volume_monitor = monitor;
+
+  return object;
+}
+
+static void
+g_gdu_volume_monitor_init (GGduVolumeMonitor *monitor)
+{
+}
+
+static gboolean
+is_supported (void)
+{
+  /* TODO: return FALSE if DeviceKit-disks is not available */
+  return TRUE;
+}
+
+static void
+g_gdu_volume_monitor_class_init (GGduVolumeMonitorClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+  GVolumeMonitorClass *monitor_class = G_VOLUME_MONITOR_CLASS (klass);
+  GNativeVolumeMonitorClass *native_class = G_NATIVE_VOLUME_MONITOR_CLASS (klass);
+
+  gobject_class->constructor = g_gdu_volume_monitor_constructor;
+  gobject_class->finalize = g_gdu_volume_monitor_finalize;
+  gobject_class->dispose = g_gdu_volume_monitor_dispose;
+
+  monitor_class->get_mounts = get_mounts;
+  monitor_class->get_volumes = get_volumes;
+  monitor_class->get_connected_drives = get_connected_drives;
+  monitor_class->get_volume_for_uuid = get_volume_for_uuid;
+  monitor_class->get_mount_for_uuid = get_mount_for_uuid;
+  monitor_class->is_supported = is_supported;
+
+  native_class->get_mount_for_mount_path = get_mount_for_mount_path;
+}
+
+/**
+ * g_gdu_volume_monitor_new:
+ *
+ * Returns:  a new #GVolumeMonitor.
+ **/
+GVolumeMonitor *
+g_gdu_volume_monitor_new (void)
+{
+  GGduVolumeMonitor *monitor;
+
+  monitor = g_object_new (G_TYPE_GDU_VOLUME_MONITOR, NULL);
+
+  return G_VOLUME_MONITOR (monitor);
+}
+
+static void
+diff_sorted_lists (GList         *list1,
+                   GList         *list2,
+                   GCompareFunc   compare,
+                   GList        **added,
+                   GList        **removed)
+{
+  int order;
+
+  *added = *removed = NULL;
+
+  while (list1 != NULL &&
+         list2 != NULL)
+    {
+      order = (*compare) (list1->data, list2->data);
+      if (order < 0)
+        {
+          *removed = g_list_prepend (*removed, list1->data);
+          list1 = list1->next;
+        }
+      else if (order > 0)
+        {
+          *added = g_list_prepend (*added, list2->data);
+          list2 = list2->next;
+        }
+      else
+        { /* same item */
+          list1 = list1->next;
+          list2 = list2->next;
+        }
+    }
+
+  while (list1 != NULL)
+    {
+      *removed = g_list_prepend (*removed, list1->data);
+      list1 = list1->next;
+    }
+  while (list2 != NULL)
+    {
+      *added = g_list_prepend (*added, list2->data);
+      list2 = list2->next;
+    }
+}
+
+static GGduVolume *
+find_volume_for_mount_path (GGduVolumeMonitor *monitor,
+                            const char         *mount_path)
+{
+  GList *l;
+  GGduVolume *found;
+
+  found = NULL;
+
+  for (l = monitor->volumes; l != NULL; l = l->next)
+    {
+      GGduVolume *volume = l->data;
+      if (g_gdu_volume_has_mount_path (volume, mount_path))
+        {
+          found = volume;
+          goto out;
+        }
+    }
+
+  for (l = monitor->fstab_volumes; l != NULL; l = l->next)
+    {
+      GGduVolume *volume = l->data;
+      if (g_gdu_volume_has_mount_path (volume, mount_path))
+        {
+          found = volume;
+          goto out;
+        }
+    }
+
+ out:
+  return found;
+}
+
+static GGduVolume *
+find_volume_for_unix_mount_point (GGduVolumeMonitor *monitor,
+                                  GUnixMountPoint   *unix_mount_point)
+{
+  GList *l;
+  GGduVolume *found;
+
+  found = NULL;
+  for (l = monitor->fstab_volumes; l != NULL; l = l->next)
+    {
+      GGduVolume *volume = l->data;
+      GUnixMountPoint *volume_mount_point;
+
+      volume_mount_point = g_gdu_volume_get_unix_mount_point (volume);
+      if (g_unix_mount_point_compare (unix_mount_point, volume_mount_point) == 0)
+        {
+          found = volume;
+          goto out;
+        }
+    }
+
+ out:
+  return found;
+}
+
+static GGduMount *
+find_mount_by_mount_path (GGduVolumeMonitor *monitor,
+                          const char *mount_path)
+{
+  GList *l;
+
+  for (l = monitor->mounts; l != NULL; l = l->next)
+    {
+      GGduMount *mount = l->data;
+
+      if (g_gdu_mount_has_mount_path (mount, mount_path))
+        return mount;
+    }
+
+  return NULL;
+}
+
+/* TODO: move to gio */
+static gboolean
+_g_unix_mount_point_guess_should_display (GUnixMountPoint *mount_point)
+{
+  const char *mount_path;
+
+  mount_path = g_unix_mount_point_get_mount_path (mount_point);
+
+  /* Never display internal mountpoints */
+  if (g_unix_is_mount_path_system_internal (mount_path))
+    return FALSE;
+
+  /* Hide mounts within a dot path, suppose it was a purpose to hide this mount */
+  if (g_strstr_len (mount_path, -1, "/.") != NULL)
+    return FALSE;
+
+  /* Only display things in /media (which are generally user mountable)
+     and home dir (fuse stuff) */
+  if (g_str_has_prefix (mount_path, "/media/"))
+    return TRUE;
+
+  if (g_str_has_prefix (mount_path, g_get_home_dir ()))
+    return TRUE;
+
+  return FALSE;
+}
+
+static GUnixMountPoint *
+get_mount_point_for_device (GduDevice *d, GList *fstab_mount_points)
+{
+  GList *l;
+  const gchar *device_file;
+  const gchar *mount_path;
+  GUnixMountPoint *ret;
+
+  ret = NULL;
+
+  mount_path = gdu_device_get_mount_path (d);
+
+  device_file = gdu_device_get_device_file (d);
+
+  for (l = fstab_mount_points; l != NULL; l = l->next)
+    {
+      GUnixMountPoint *mount_point = l->data;
+      const gchar *fstab_device_file;
+      const gchar *fstab_mount_path;
+
+      fstab_mount_path = g_unix_mount_point_get_mount_path (mount_point);
+      if (g_strcmp0 (mount_path, fstab_mount_path) == 0)
+        {
+          ret = mount_point;
+          goto out;
+        }
+
+      fstab_device_file = g_unix_mount_point_get_device_path (mount_point);
+      if (g_str_has_prefix (fstab_device_file, "LABEL="))
+        {
+          if (g_strcmp0 (fstab_device_file + 6, gdu_device_id_get_label (d)) == 0)
+            {
+              ret = mount_point;
+              goto out;
+            }
+        }
+      else if (g_str_has_prefix (fstab_device_file, "UUID="))
+        {
+          if (g_ascii_strcasecmp (fstab_device_file + 5, gdu_device_id_get_uuid (d)) == 0)
+            {
+              ret = mount_point;
+              goto out;
+            }
+        }
+      else
+        {
+          char resolved_fstab_device_file[PATH_MAX];
+
+          /* handle symlinks such as /dev/disk/by-uuid/47C2-1994 */
+          if (realpath (fstab_device_file, resolved_fstab_device_file) != NULL &&
+              g_strcmp0 (resolved_fstab_device_file, device_file) == 0)
+            {
+              ret = mount_point;
+              goto out;
+            }
+        }
+    }
+
+ out:
+  return ret;
+}
+
+static gboolean
+should_mount_be_ignored (GduPool *pool, GduDevice *d)
+{
+  gboolean ret;
+  const gchar *mount_path;
+  GUnixMountEntry *mount_entry;
+
+  ret = FALSE;
+
+  if (gdu_device_get_presentation_hide (d))
+    {
+      ret = TRUE;
+      goto out;
+    }
+
+  mount_path = gdu_device_get_mount_path (d);
+  if (mount_path == NULL || strlen (mount_path) == 0)
+    goto out;
+
+  mount_entry = g_unix_mount_at (mount_path, NULL);
+  if (mount_entry != NULL)
+    {
+      if (!g_unix_mount_guess_should_display (mount_entry))
+        {
+          ret = TRUE;
+        }
+      g_unix_mount_free (mount_entry);
+    }
+
+ out:
+  return ret;
+}
+
+gboolean
+_is_pc_floppy_drive (GduDevice *device)
+{
+  gboolean ret;
+  gchar **drive_media_compat;
+  const gchar *drive_connection_interface;
+
+  ret = FALSE;
+
+  if (device != NULL)
+    {
+      drive_media_compat = gdu_device_drive_get_media_compatibility (device);
+      drive_connection_interface = gdu_device_drive_get_connection_interface (device);
+
+      if (g_strcmp0 (drive_connection_interface, "platform") == 0 &&
+          (drive_media_compat != NULL &&
+           g_strv_length (drive_media_compat) > 0 &&
+           g_strcmp0 (drive_media_compat[0], "floppy") == 0))
+        {
+          ret = TRUE;
+        }
+    }
+
+  return ret;
+}
+
+static gboolean
+should_volume_be_ignored (GduPool *pool, GduVolume *volume, GList *fstab_mount_points)
+{
+  GduDevice *device;
+  gboolean ret;
+  const gchar *usage;
+  const gchar *type;
+
+  ret = TRUE;
+
+  device = gdu_presentable_get_device (GDU_PRESENTABLE (volume));
+  if (device == NULL)
+    goto out;
+
+  if (gdu_device_get_presentation_hide (device))
+    goto out;
+
+  usage = gdu_device_id_get_usage (device);
+  type = gdu_device_id_get_type (device);
+
+  if (_is_pc_floppy_drive (device) || g_strcmp0 (usage, "filesystem") == 0)
+    {
+      GUnixMountPoint *mount_point;
+
+      /* don't ignore volumes with a mountable filesystem unless
+       *
+       *  - volume is referenced in /etc/fstab and deemed to be ignored
+       *
+       *  - volume is mounted and should_mount_be_ignored() deems it should be ignored
+       *
+       *  - volume is a cleartext LUKS device as the cryptotext LUKS volume will morph
+       *    into the cleartext volume when unlocked (see ggduvolume.c)
+       */
+
+      if (gdu_device_is_luks_cleartext (device))
+        goto out;
+
+      mount_point = get_mount_point_for_device (device, fstab_mount_points);
+      if (mount_point != NULL && !_g_unix_mount_point_guess_should_display (mount_point))
+        goto out;
+
+      if (gdu_device_is_mounted (device))
+        {
+          ret = should_mount_be_ignored (pool, device);
+          goto out;
+        }
+
+      ret = FALSE;
+
+    }
+  else if (g_strcmp0 (usage, "crypto") == 0 && g_strcmp0 (type, "crypto_LUKS") == 0)
+    {
+      /* don't ignore LUKS volumes */
+      ret = FALSE;
+    }
+
+ out:
+
+  if (device != NULL)
+    g_object_unref (device);
+  return ret;
+}
+
+static gboolean
+should_drive_be_ignored (GduPool *pool, GduDrive *d, GList *fstab_mount_points)
+{
+  GduDevice *device;
+  gboolean ignored;
+  gboolean have_volumes;
+  gboolean all_volumes_are_ignored;
+  GList *enclosed;
+  GList *l;
+
+  ignored = FALSE;
+  enclosed = NULL;
+
+  device = gdu_presentable_get_device (GDU_PRESENTABLE (d));
+
+  /* If there is no GduDevice for a drive, then ignore it unless
+   * we know how to start it (e.g. RAID arrays, Volume Groups)
+   */
+  if (device == NULL)
+    {
+      if (!gdu_drive_is_activatable (d))
+        {
+          ignored = TRUE;
+          goto out;
+        }
+    }
+
+  if (device != NULL && gdu_device_get_presentation_hide (device)) {
+    ignored = TRUE;
+    goto out;
+  }
+
+  have_volumes = FALSE;
+  all_volumes_are_ignored = TRUE;
+
+  /* never ignore a drive if it has volumes that we don't want to ignore */
+  enclosed = gdu_pool_get_enclosed_presentables (pool, GDU_PRESENTABLE (d));
+  for (l = enclosed; l != NULL && all_volumes_are_ignored; l = l->next)
+    {
+      GduPresentable *enclosed_presentable = GDU_PRESENTABLE (l->data);
+
+      /* There might be other presentables that GduVolume objects; for example GduVolumeHole */
+      if (GDU_IS_VOLUME (enclosed_presentable))
+        {
+          GduVolume *volume = GDU_VOLUME (enclosed_presentable);
+          GduDevice *volume_device;
+
+          have_volumes = TRUE;
+
+          if (!should_volume_be_ignored (pool, volume, fstab_mount_points))
+            {
+              all_volumes_are_ignored = FALSE;
+              break;
+            }
+
+          /* The volume may be an extended partition - we need to check all logical
+           * partitions as well (#597041)
+           */
+          volume_device = gdu_presentable_get_device (GDU_PRESENTABLE (volume));
+          if (volume_device != NULL)
+            {
+              if (g_strcmp0 (gdu_device_partition_get_scheme (volume_device), "mbr") == 0)
+                {
+                  gint type;
+
+                  type = strtol (gdu_device_partition_get_type (volume_device), NULL, 0);
+                  if (type == 0x05 || type == 0x0f || type == 0x85)
+                    {
+                      GList *enclosed_logical;
+                      GList *ll;
+
+                      enclosed_logical = gdu_pool_get_enclosed_presentables (pool, GDU_PRESENTABLE (volume));
+                      for (ll = enclosed_logical; ll != NULL && all_volumes_are_ignored; ll = ll->next)
+                        {
+                          GduPresentable *enclosed_logical_presentable = GDU_PRESENTABLE (ll->data);
+
+                          if (GDU_IS_VOLUME (enclosed_logical_presentable))
+                            {
+                              if (!should_volume_be_ignored (pool,
+                                                             GDU_VOLUME (enclosed_logical_presentable),
+                                                             fstab_mount_points))
+                                {
+                                  all_volumes_are_ignored = FALSE;
+                                }
+                            }
+                        }
+                      g_list_foreach (enclosed_logical, (GFunc) g_object_unref, NULL);
+                      g_list_free (enclosed_logical);
+                    }
+                }
+              g_object_unref (volume_device);
+            }
+        }
+    }
+
+  /* we ignore a drive if
+   *
+   * a) no volumes are available AND media is available; OR
+   *
+   * b) the volumes of the drive are all ignored
+   */
+  if (device != NULL)
+    {
+      if (!have_volumes)
+        {
+          if (gdu_device_is_media_available (device))
+            ignored = TRUE;
+        }
+      else
+        {
+          if (all_volumes_are_ignored)
+            ignored = TRUE;
+        }
+
+      /* special case for audio and blank discs: don't ignore the drive since we'll create
+       * a cdda:// or burn:// mount for the drive
+       */
+      if (gdu_device_is_optical_disc (device) && (gdu_device_optical_disc_get_num_audio_tracks (device) > 0 ||
+                                                  gdu_device_optical_disc_get_is_blank (device)))
+        {
+          ignored = FALSE;
+        }
+    }
+
+ out:
+  g_list_foreach (enclosed, (GFunc) g_object_unref, NULL);
+  g_list_free (enclosed);
+
+  if (device != NULL)
+    g_object_unref (device);
+
+  return ignored;
+}
+
+static void
+list_emit (GGduVolumeMonitor *monitor,
+           const char *monitor_signal,
+           const char *object_signal,
+           GList *objects)
+{
+  GList *l;
+
+  for (l = objects; l != NULL; l = l->next)
+    {
+      g_signal_emit_by_name (monitor, monitor_signal, l->data);
+      if (object_signal)
+        g_signal_emit_by_name (l->data, object_signal);
+    }
+}
+
+static void
+update_all (GGduVolumeMonitor *monitor,
+            gboolean emit_changes)
+{
+  GList *added_drives, *removed_drives;
+  GList *added_volumes, *removed_volumes;
+  GList *added_mounts, *removed_mounts;
+
+  added_drives = NULL;
+  removed_drives = NULL;
+  added_volumes = NULL;
+  removed_volumes = NULL;
+  added_mounts = NULL;
+  removed_mounts = NULL;
+
+  update_drives (monitor, &added_drives, &removed_drives);
+  update_volumes (monitor, &added_volumes, &removed_volumes);
+  update_fstab_volumes (monitor, &added_volumes, &removed_volumes);
+  update_mounts (monitor, &added_mounts, &removed_mounts);
+  update_discs (monitor,
+                &added_volumes, &removed_volumes,
+                &added_mounts, &removed_mounts);
+
+  if (emit_changes)
+    {
+      list_emit (monitor,
+                 "drive_disconnected", NULL,
+                 removed_drives);
+      list_emit (monitor,
+                 "drive_connected", NULL,
+                 added_drives);
+
+      list_emit (monitor,
+                 "volume_removed", "removed",
+                 removed_volumes);
+      list_emit (monitor,
+                 "volume_added", NULL,
+                 added_volumes);
+
+      list_emit (monitor,
+                 "mount_removed", "unmounted",
+                 removed_mounts);
+      list_emit (monitor,
+                 "mount_added", NULL,
+                 added_mounts);
+    }
+
+  list_free (removed_drives);
+  list_free (added_drives);
+  list_free (removed_volumes);
+  list_free (added_volumes);
+  list_free (removed_mounts);
+  list_free (added_mounts);
+}
+
+static GGduMount *
+find_disc_mount_for_volume (GGduVolumeMonitor *monitor,
+                            GGduVolume        *volume)
+{
+  GList *l;
+
+  for (l = monitor->disc_mounts; l != NULL; l = l->next)
+    {
+      GGduMount *mount = G_GDU_MOUNT (l->data);
+
+      if (g_gdu_mount_has_volume (mount, volume))
+        return mount;
+    }
+
+  return NULL;
+}
+
+static GGduVolume *
+find_disc_volume_for_device_file (GGduVolumeMonitor *monitor,
+                                  const gchar       *device_file)
+{
+  GList *l;
+  GGduVolume *ret;
+  struct stat stat_buf;
+
+  ret = NULL;
+
+  if (stat (device_file, &stat_buf) == 0)
+    {
+      for (l = monitor->disc_volumes; l != NULL; l = l->next)
+        {
+          GGduVolume *volume = G_GDU_VOLUME (l->data);
+          if (g_gdu_volume_has_dev (volume, stat_buf.st_rdev))
+            {
+              ret = volume;
+              goto out;
+            }
+        }
+    }
+
+  for (l = monitor->disc_volumes; l != NULL; l = l->next)
+    {
+      GGduVolume *volume = G_GDU_VOLUME (l->data);
+
+      if (g_gdu_volume_has_device_file (volume, device_file))
+        {
+          ret = volume;
+          goto out;
+        }
+    }
+
+ out:
+  return ret;
+}
+
+static GGduVolume *
+find_volume_for_device_file (GGduVolumeMonitor *monitor,
+                             const gchar       *device_file)
+{
+  GList *l;
+  GGduVolume *ret;
+  struct stat stat_buf;
+
+  ret = NULL;
+
+  if (stat (device_file, &stat_buf) == 0)
+    {
+      for (l = monitor->volumes; l != NULL; l = l->next)
+        {
+          GGduVolume *volume = G_GDU_VOLUME (l->data);
+          if (g_gdu_volume_has_dev (volume, stat_buf.st_rdev))
+            {
+              ret = volume;
+              goto out;
+            }
+        }
+    }
+
+  for (l = monitor->volumes; l != NULL; l = l->next)
+    {
+      GGduVolume *volume = G_GDU_VOLUME (l->data);
+
+      if (g_gdu_volume_has_device_file (volume, device_file))
+        {
+          ret = volume;
+          goto out;
+        }
+    }
+
+  ret = NULL;
+  for (l = monitor->fstab_volumes; l != NULL; l = l->next)
+    {
+      GGduVolume *volume = G_GDU_VOLUME (l->data);
+
+      if (g_gdu_volume_has_device_file (volume, device_file))
+        {
+          ret = volume;
+          goto out;
+        }
+    }
+
+ out:
+  return ret;
+}
+
+static GGduVolume *
+find_volume_for_presentable (GGduVolumeMonitor *monitor,
+                             GduPresentable    *presentable)
+{
+  GList *l;
+
+  for (l = monitor->volumes; l != NULL; l = l->next)
+    {
+      GGduVolume *volume = G_GDU_VOLUME (l->data);
+
+      if (g_gdu_volume_has_presentable (volume, presentable))
+        return volume;
+    }
+
+  return NULL;
+}
+
+static GGduDrive *
+find_drive_by_device_file (GGduVolumeMonitor *monitor,
+                           const gchar       *device_file)
+{
+  GList *l;
+  struct stat stat_buf;
+
+  if (stat (device_file, &stat_buf) != 0)
+    {
+      g_warning ("%s:%s: Error statting %s: %m", G_STRLOC, G_STRFUNC, device_file);
+      return NULL;
+    }
+
+  for (l = monitor->drives; l != NULL; l = l->next)
+    {
+      GGduDrive *drive = G_GDU_DRIVE (l->data);
+
+      if (g_gdu_drive_has_dev (drive, stat_buf.st_rdev))
+        return drive;
+    }
+
+  return NULL;
+}
+
+static GGduDrive *
+find_drive_by_presentable (GGduVolumeMonitor *monitor,
+                           GduPresentable    *presentable)
+{
+  GList *l;
+
+  for (l = monitor->drives; l != NULL; l = l->next)
+    {
+      GGduDrive *drive = G_GDU_DRIVE (l->data);
+
+      if (g_gdu_drive_has_presentable (drive, presentable))
+        return drive;
+    }
+
+  return NULL;
+}
+
+static void
+update_drives (GGduVolumeMonitor *monitor,
+               GList **added_drives,
+               GList **removed_drives)
+{
+  GList *cur_drives;
+  GList *new_drives;
+  GList *removed, *added;
+  GList *l, *ll;
+  GGduDrive *drive;
+  GList *fstab_mount_points;
+
+  fstab_mount_points = g_unix_mount_points_get (NULL);
+
+  cur_drives = NULL;
+  for (l = monitor->drives; l != NULL; l = l->next)
+    cur_drives = g_list_prepend (cur_drives, g_gdu_drive_get_presentable (G_GDU_DRIVE (l->data)));
+
+  /* remove devices we want to ignore - we do it here so we get to reevaluate
+   * on the next update whether they should still be ignored
+   */
+  new_drives = gdu_pool_get_presentables (monitor->pool);
+  for (l = new_drives; l != NULL; l = ll)
+    {
+      GduPresentable *p = GDU_PRESENTABLE (l->data);
+      ll = l->next;
+      if (!GDU_IS_DRIVE (p) || should_drive_be_ignored (monitor->pool, GDU_DRIVE (p), fstab_mount_points))
+        {
+          g_object_unref (p);
+          new_drives = g_list_delete_link (new_drives, l);
+        }
+    }
+
+  cur_drives = g_list_sort (cur_drives, (GCompareFunc) gdu_presentable_compare);
+  new_drives = g_list_sort (new_drives, (GCompareFunc) gdu_presentable_compare);
+  diff_sorted_lists (cur_drives,
+                     new_drives, (GCompareFunc) gdu_presentable_compare,
+                     &added, &removed);
+
+  for (l = removed; l != NULL; l = l->next)
+    {
+      GduPresentable *p = GDU_PRESENTABLE (l->data);
+
+      drive = find_drive_by_presentable (monitor, p);
+      if (drive != NULL)
+        {
+          /*g_debug ("removing drive %s", gdu_presentable_get_id (p));*/
+          g_gdu_drive_disconnected (drive);
+          monitor->drives = g_list_remove (monitor->drives, drive);
+          *removed_drives = g_list_prepend (*removed_drives, drive);
+        }
+    }
+
+  for (l = added; l != NULL; l = l->next)
+    {
+      GduPresentable *p = GDU_PRESENTABLE (l->data);
+
+      drive = find_drive_by_presentable (monitor, p);
+      if (drive == NULL)
+        {
+          /*g_debug ("adding drive %s", gdu_presentable_get_id (p));*/
+          drive = g_gdu_drive_new (G_VOLUME_MONITOR (monitor), p);
+          if (drive != NULL)
+            {
+              monitor->drives = g_list_prepend (monitor->drives, drive);
+              *added_drives = g_list_prepend (*added_drives, g_object_ref (drive));
+            }
+        }
+    }
+
+  g_list_free (added);
+  g_list_free (removed);
+
+  g_list_free (cur_drives);
+
+  g_list_foreach (new_drives, (GFunc) g_object_unref, NULL);
+  g_list_free (new_drives);
+
+  g_list_foreach (fstab_mount_points, (GFunc) g_unix_mount_point_free, NULL);
+  g_list_free (fstab_mount_points);
+}
+
+static void
+update_volumes (GGduVolumeMonitor *monitor,
+                GList **added_volumes,
+                GList **removed_volumes)
+{
+  GList *cur_volumes;
+  GList *new_volumes;
+  GList *removed, *added;
+  GList *l, *ll;
+  GGduVolume *volume;
+  GGduDrive *drive;
+  GList *fstab_mount_points;
+
+  fstab_mount_points = g_unix_mount_points_get (NULL);
+
+  cur_volumes = NULL;
+  for (l = monitor->volumes; l != NULL; l = l->next)
+    cur_volumes = g_list_prepend (cur_volumes, g_gdu_volume_get_presentable (G_GDU_VOLUME (l->data)));
+
+  /* remove devices we want to ignore - we do it here so we get to reevaluate
+   * on the next update whether they should still be ignored
+   */
+  new_volumes = gdu_pool_get_presentables (monitor->pool);
+  for (l = new_volumes; l != NULL; l = ll)
+    {
+      GduPresentable *p = GDU_PRESENTABLE (l->data);
+      ll = l->next;
+      if (!GDU_IS_VOLUME (p) || should_volume_be_ignored (monitor->pool, GDU_VOLUME (p), fstab_mount_points))
+        {
+          g_object_unref (p);
+          new_volumes = g_list_delete_link (new_volumes, l);
+        }
+    }
+
+  cur_volumes = g_list_sort (cur_volumes, (GCompareFunc) gdu_presentable_compare);
+  new_volumes = g_list_sort (new_volumes, (GCompareFunc) gdu_presentable_compare);
+  diff_sorted_lists (cur_volumes,
+                     new_volumes, (GCompareFunc) gdu_presentable_compare,
+                     &added, &removed);
+
+  for (l = removed; l != NULL; l = l->next)
+    {
+      GduPresentable *p = GDU_PRESENTABLE (l->data);
+
+      volume = find_volume_for_presentable (monitor, p);
+      if (volume != NULL)
+        {
+          /*g_debug ("removing volume %s", gdu_device_get_device_file (d));*/
+          g_gdu_volume_removed (volume);
+          monitor->volumes = g_list_remove (monitor->volumes, volume);
+          *removed_volumes = g_list_prepend (*removed_volumes, volume);
+        }
+    }
+
+  for (l = added; l != NULL; l = l->next)
+    {
+      GduPresentable *p = GDU_PRESENTABLE (l->data);
+      GduDevice *d;
+
+      volume = NULL;
+      d = gdu_presentable_get_device (p);
+
+      if (d != NULL)
+        volume = find_volume_for_device_file (monitor, gdu_device_get_device_file (d));
+
+      if (volume == NULL)
+        {
+          GduDrive *gdu_drive;
+
+          drive = NULL;
+          gdu_drive = gdu_volume_get_drive (GDU_VOLUME (p));
+          if (gdu_drive != NULL)
+            {
+              drive = find_drive_by_presentable (monitor, GDU_PRESENTABLE (gdu_drive));
+              g_object_unref (gdu_drive);
+            }
+
+          volume = g_gdu_volume_new (G_VOLUME_MONITOR (monitor),
+                                     GDU_VOLUME (p),
+                                     drive,
+                                     NULL);
+          if (volume != NULL)
+            {
+              monitor->volumes = g_list_prepend (monitor->volumes, volume);
+              *added_volumes = g_list_prepend (*added_volumes, g_object_ref (volume));
+            }
+         }
+
+       if (d != NULL)
+         g_object_unref (d);
+    }
+
+  g_list_free (added);
+  g_list_free (removed);
+
+  g_list_foreach (new_volumes, (GFunc) g_object_unref, NULL);
+  g_list_free (new_volumes);
+
+  g_list_free (cur_volumes);
+
+  g_list_foreach (fstab_mount_points, (GFunc) g_unix_mount_point_free, NULL);
+  g_list_free (fstab_mount_points);
+}
+
+static void
+update_fstab_volumes (GGduVolumeMonitor *monitor,
+                      GList **added_volumes,
+                      GList **removed_volumes)
+{
+  GList *fstab_mount_points;
+  GList *cur_fstab_mount_points;
+  GList *new_fstab_mount_points;
+  GList *removed, *added;
+  GList *l;
+  GGduVolume *volume;
+
+  fstab_mount_points = g_unix_mount_points_get (NULL);
+
+  cur_fstab_mount_points = NULL;
+  for (l = monitor->fstab_volumes; l != NULL; l = l->next)
+    cur_fstab_mount_points = g_list_prepend (cur_fstab_mount_points, g_gdu_volume_get_unix_mount_point (G_GDU_VOLUME (l->data)));
+
+  new_fstab_mount_points = NULL;
+  for (l = fstab_mount_points; l != NULL; l = l->next)
+    {
+      GUnixMountPoint *mount_point = l->data;
+      const gchar *device_file;
+
+      /* only show user mountable mount points */
+      if (!g_unix_mount_point_is_user_mountable (mount_point))
+        continue;
+
+      /* only show stuff that can be mounted in user-visible locations */
+      if (!_g_unix_mount_point_guess_should_display (mount_point))
+        continue;
+
+      /* ignore mount point if the device doesn't exist or is handled by DeviceKit-disks */
+      device_file = g_unix_mount_point_get_device_path (mount_point);
+      if (g_str_has_prefix (device_file, "/dev/"))
+        {
+          gchar resolved_path[PATH_MAX];
+          GduDevice *device;
+
+          /* doesn't exist */
+          if (realpath (device_file, resolved_path) == NULL)
+            continue;
+
+          /* is handled by DKD */
+          device = gdu_pool_get_by_device_file (monitor->pool, resolved_path);
+          if (device != NULL)
+            {
+              g_object_unref (device);
+              continue;
+            }
+        }
+
+      new_fstab_mount_points = g_list_prepend (new_fstab_mount_points, mount_point);
+    }
+
+  diff_sorted_lists (cur_fstab_mount_points,
+                     new_fstab_mount_points, (GCompareFunc) g_unix_mount_point_compare,
+                     &added, &removed);
+
+  for (l = removed; l != NULL; l = l->next)
+    {
+      GUnixMountPoint *mount_point = l->data;
+      volume = find_volume_for_unix_mount_point (monitor, mount_point);
+      if (volume != NULL)
+        {
+          g_gdu_volume_removed (volume);
+          monitor->fstab_volumes = g_list_remove (monitor->fstab_volumes, volume);
+          *removed_volumes = g_list_prepend (*removed_volumes, volume);
+          /*g_debug ("removed volume for /etc/fstab mount point %s", g_unix_mount_point_get_mount_path (mount_point));*/
+        }
+    }
+
+  for (l = added; l != NULL; l = l->next)
+    {
+      GUnixMountPoint *mount_point = l->data;
+
+      volume = g_gdu_volume_new_for_unix_mount_point (G_VOLUME_MONITOR (monitor), mount_point);
+      if (volume != NULL)
+        {
+          /* steal mount_point since g_gdu_volume_new_for_unix_mount_point() takes ownership of it */
+          fstab_mount_points = g_list_remove (fstab_mount_points, mount_point);
+          monitor->fstab_volumes = g_list_prepend (monitor->fstab_volumes, volume);
+          *added_volumes = g_list_prepend (*added_volumes, g_object_ref (volume));
+          /*g_debug ("added volume for /etc/fstab mount point %s", g_unix_mount_point_get_mount_path (mount_point));*/
+        }
+      else
+        {
+          g_unix_mount_point_free (mount_point);
+        }
+    }
+
+  g_list_free (added);
+  g_list_free (removed);
+
+  g_list_free (cur_fstab_mount_points);
+
+  g_list_foreach (fstab_mount_points, (GFunc) g_unix_mount_point_free, NULL);
+  g_list_free (fstab_mount_points);
+}
+
+static gboolean
+unix_mount_is_cleartext (GGduVolumeMonitor *monitor,
+                         GUnixMountEntry *mount_entry)
+{
+  const char *device_file;
+  const char *mount_path;
+  GGduVolume *volume;
+  GduPresentable *presentable;
+
+  device_file = g_unix_mount_get_device_path (mount_entry);
+  mount_path = g_unix_mount_get_mount_path (mount_entry);
+  volume = find_volume_for_device_file (monitor, device_file);
+  if (volume == NULL)
+    volume = find_volume_for_mount_path (monitor, mount_path);
+
+  if (volume != NULL)
+    {
+      presentable = g_gdu_volume_get_presentable_with_cleartext (volume);
+      return presentable != NULL;
+    }
+
+  return FALSE;
+}
+
+static void
+update_mounts (GGduVolumeMonitor *monitor,
+               GList **added_mounts,
+               GList **removed_mounts)
+{
+  GList *new_mounts;
+  GList *removed, *added;
+  GList *l, *ll;
+  GGduMount *mount;
+  GGduVolume *volume;
+  const char *device_file;
+  const char *mount_path;
+
+  new_mounts = g_unix_mounts_get (NULL);
+
+  /* remove mounts we want to ignore - we do it here so we get to reevaluate
+   * on the next update whether they should still be ignored
+   */
+  for (l = new_mounts; l != NULL; l = ll)
+    {
+      GUnixMountEntry *mount_entry = l->data;
+      ll = l->next;
+
+      /* since we always show crypto volumes, we should also never ignore their mounts */
+      /* keep in sync with should_mount_be_ignored() */
+      if (!g_unix_mount_guess_should_display (mount_entry) &&
+          !unix_mount_is_cleartext (monitor, mount_entry))
+        {
+          g_unix_mount_free (mount_entry);
+          new_mounts = g_list_delete_link (new_mounts, l);
+        }
+    }
+
+  new_mounts = g_list_sort (new_mounts, (GCompareFunc) g_unix_mount_compare);
+
+  diff_sorted_lists (monitor->last_mounts,
+                     new_mounts, (GCompareFunc) g_unix_mount_compare,
+                     &added, &removed);
+
+  for (l = removed; l != NULL; l = l->next)
+    {
+      GUnixMountEntry *mount_entry = l->data;
+
+      mount = find_mount_by_mount_path (monitor, g_unix_mount_get_mount_path (mount_entry));
+      if (mount)
+        {
+          /*g_debug ("removing mount %s", g_unix_mount_get_device_path (mount_entry));*/
+          g_gdu_mount_unmounted (mount);
+          monitor->mounts = g_list_remove (monitor->mounts, mount);
+
+          *removed_mounts = g_list_prepend (*removed_mounts, mount);
+        }
+    }
+
+  for (l = added; l != NULL; l = l->next)
+    {
+      GUnixMountEntry *mount_entry = l->data;
+
+      device_file = g_unix_mount_get_device_path (mount_entry);
+      mount_path = g_unix_mount_get_mount_path (mount_entry);
+      volume = find_volume_for_device_file (monitor, device_file);
+      if (volume == NULL)
+        volume = find_volume_for_mount_path (monitor, mount_path);
+
+      /*g_debug ("adding mount %s (vol %p) (device %s, mount_path %s)", g_unix_mount_get_device_path (mount_entry), volume, device_file, mount_path);*/
+      mount = g_gdu_mount_new (G_VOLUME_MONITOR (monitor), mount_entry, volume);
+      if (mount)
+        {
+          monitor->mounts = g_list_prepend (monitor->mounts, mount);
+          *added_mounts = g_list_prepend (*added_mounts, g_object_ref (mount));
+        }
+    }
+
+  g_list_free (added);
+  g_list_free (removed);
+  g_list_foreach (monitor->last_mounts,
+                  (GFunc)g_unix_mount_free, NULL);
+  g_list_free (monitor->last_mounts);
+  monitor->last_mounts = new_mounts;
+}
+
+static void
+update_discs (GGduVolumeMonitor *monitor,
+              GList **added_volumes,
+              GList **removed_volumes,
+              GList **added_mounts,
+              GList **removed_mounts)
+{
+  GList *cur_discs;
+  GList *new_discs;
+  GList *removed, *added;
+  GList *l, *ll;
+  GGduDrive *drive = NULL;
+  GGduVolume *volume;
+  GGduMount *mount;
+
+  /* we also need to generate GVolume + GMount objects for
+   *
+   * - optical discs that have audio
+   * - optical discs that are blank
+   *
+   */
+
+  cur_discs = NULL;
+  for (l = monitor->disc_volumes; l != NULL; l = l->next)
+    cur_discs = g_list_prepend (cur_discs, g_gdu_volume_get_presentable (G_GDU_VOLUME (l->data)));
+
+  new_discs = gdu_pool_get_presentables (monitor->pool);
+  for (l = new_discs; l != NULL; l = ll)
+    {
+      GduPresentable *p = GDU_PRESENTABLE (l->data);
+      GduDevice *d;
+      gboolean ignore;
+
+      ll = l->next;
+      ignore = TRUE;
+
+      /* filter out everything but discs that are blank or has audio */
+      d = gdu_presentable_get_device (p);
+      if (GDU_IS_VOLUME (p) && d != NULL && gdu_device_is_optical_disc (d))
+        {
+          if (gdu_device_optical_disc_get_num_audio_tracks (d) > 0 || gdu_device_optical_disc_get_is_blank (d))
+            ignore = FALSE;
+        }
+
+      if (ignore)
+        {
+          g_object_unref (p);
+          new_discs = g_list_delete_link (new_discs, l);
+        }
+
+      if (d != NULL)
+        g_object_unref (d);
+    }
+
+  cur_discs = g_list_sort (cur_discs, (GCompareFunc) gdu_presentable_compare);
+  new_discs = g_list_sort (new_discs, (GCompareFunc) gdu_presentable_compare);
+  diff_sorted_lists (cur_discs, new_discs, (GCompareFunc) gdu_presentable_compare, &added, &removed);
+
+  for (l = removed; l != NULL; l = l->next)
+    {
+      GduPresentable *p = GDU_PRESENTABLE (l->data);
+      GduDevice *d;
+
+      volume = NULL;
+      mount = NULL;
+      d = gdu_presentable_get_device (p);
+
+      if (d != NULL)
+        {
+          volume = find_disc_volume_for_device_file (monitor, gdu_device_get_device_file (d));
+          mount = find_disc_mount_for_volume (monitor, volume);
+        }
+
+      if (mount != NULL)
+        {
+          /*g_debug ("removing disc mount %s", gdu_device_get_device_file (d));*/
+          g_gdu_mount_unmounted (mount);
+          monitor->disc_mounts = g_list_remove (monitor->disc_mounts, mount);
+          *removed_mounts = g_list_prepend (*removed_mounts, mount);
+        }
+
+      if (volume != NULL)
+        {
+          /*g_debug ("removing disc volume %s", gdu_device_get_device_file (d));*/
+          g_gdu_volume_removed (volume);
+          monitor->disc_volumes = g_list_remove (monitor->disc_volumes, volume);
+          *removed_volumes = g_list_prepend (*removed_volumes, volume);
+        }
+
+      if (d != NULL)
+        g_object_unref (d);
+    }
+
+  for (l = added; l != NULL; l = l->next)
+    {
+      GduPresentable *p = GDU_PRESENTABLE (l->data);
+      GduDevice *d;
+      gboolean is_blank;
+
+      volume = NULL;
+      is_blank = TRUE;
+      d = gdu_presentable_get_device (p);
+
+      if (d != NULL)
+        {
+          is_blank = gdu_device_optical_disc_get_is_blank (d);
+          volume = find_disc_volume_for_device_file (monitor, gdu_device_get_device_file (d));
+        }
+
+      if (volume == NULL)
+        {
+          GduPresentable *toplevel_drive;
+
+          toplevel_drive = gdu_presentable_get_enclosing_presentable (p);
+          /* handle logical partitions enclosed by an extented partition */
+          if (GDU_IS_VOLUME (toplevel_drive))
+            {
+              GduPresentable *temp;
+              temp = toplevel_drive;
+              toplevel_drive = gdu_presentable_get_enclosing_presentable (toplevel_drive);
+              g_object_unref (temp);
+            }
+
+          if (toplevel_drive != NULL)
+            {
+              if (GDU_IS_DRIVE (toplevel_drive))
+                {
+                  GduDevice *toplevel_drive_device;
+
+                  drive = NULL;
+                  toplevel_drive_device = gdu_presentable_get_device (toplevel_drive);
+                  if (toplevel_drive_device != NULL)
+                    {
+                      drive = find_drive_by_device_file (monitor, gdu_device_get_device_file (toplevel_drive_device));
+                      /*g_debug ("adding volume %s (drive %s)",
+                        gdu_device_get_device_file (d),
+                        gdu_device_get_device_file (toplevel_device));*/
+                      g_object_unref (toplevel_drive_device);
+                    }
+                }
+              g_object_unref (toplevel_drive);
+            }
+          else
+            {
+              drive = NULL;
+              /*g_debug ("adding volume %s (no drive)", gdu_device_get_device_file (d));*/
+            }
+
+          mount = NULL;
+          if (is_blank)
+            {
+              volume = g_gdu_volume_new (G_VOLUME_MONITOR (monitor),
+                                         GDU_VOLUME (p),
+                                         drive,
+                                         NULL);
+              mount = g_gdu_mount_new (G_VOLUME_MONITOR (monitor),
+                                       NULL,
+                                       volume);
+            }
+          else
+            {
+              gchar *uri;
+              gchar *device_basename;
+              GFile *activation_root;
+
+              /* the gvfsd-cdda backend uses URI's like these */
+              device_basename = g_path_get_basename (gdu_device_get_device_file (d));
+              uri = g_strdup_printf ("cdda://%s", device_basename);
+              activation_root = g_file_new_for_uri (uri);
+              g_free (device_basename);
+              g_free (uri);
+
+              volume = g_gdu_volume_new (G_VOLUME_MONITOR (monitor),
+                                         GDU_VOLUME (p),
+                                         drive,
+                                         activation_root);
+
+              g_object_unref (activation_root);
+            }
+
+          if (volume != NULL)
+            {
+              monitor->disc_volumes = g_list_prepend (monitor->disc_volumes, volume);
+              *added_volumes = g_list_prepend (*added_volumes, g_object_ref (volume));
+
+              if (mount != NULL)
+                {
+                  monitor->disc_mounts = g_list_prepend (monitor->disc_mounts, mount);
+                  *added_mounts = g_list_prepend (*added_mounts, g_object_ref (mount));
+                }
+            }
+        }
+
+      if (d != NULL)
+        g_object_unref (d);
+    }
+
+  g_list_free (added);
+  g_list_free (removed);
+
+  g_list_foreach (new_discs, (GFunc) g_object_unref, NULL);