mirror of
https://gitlab.gnome.org/GNOME/glib.git
synced 2024-09-20 09:16:15 +02:00
42b160b19f
I think it is a recursion from the GUnixMountMonitor constructor, to a GLocalFileMonitor on /etc/fstab, and into GUnixMountMonitor again, now with a mutex already held, so it deadlocks. https://bugzilla.gnome.org/page.cgi?id=traceparser/trace.html&trace_id=235354 That mutex in glocalfile.c:g_local_file_find_enclosing_mount() doesn't seem necessary any more IMHO. Inside it, only 'mount' is modified, but that's just a stack variable local to this function. When klass->get_mount_for_mount_path is called, it's given one const parameter and the other is unused, so they're unchanged. 'klass' doesn't seem it could be modified either inside that function. It doesn't recurse infinitely, but seems to work correctly and pass the testsuite after this change. The FreeBSD project already applied my patch in their ports tree, and their users seem happy with it. See https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=712848#64 and https://bugzilla.gnome.org/show_bug.cgi?id=753378
685 lines
20 KiB
C
685 lines
20 KiB
C
/* -*- 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, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
* Author: Alexander Larsson <alexl@redhat.com>
|
|
* David Zeuthen <davidz@redhat.com>
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <string.h>
|
|
|
|
#include <glib.h>
|
|
#include "gunionvolumemonitor.h"
|
|
#include "gmountprivate.h"
|
|
#include "giomodule-priv.h"
|
|
#ifdef G_OS_UNIX
|
|
#include "gunixvolumemonitor.h"
|
|
#endif
|
|
#include "gnativevolumemonitor.h"
|
|
|
|
#include "glibintl.h"
|
|
|
|
|
|
struct _GUnionVolumeMonitor {
|
|
GVolumeMonitor parent;
|
|
|
|
GList *monitors;
|
|
};
|
|
|
|
static void g_union_volume_monitor_remove_monitor (GUnionVolumeMonitor *union_monitor,
|
|
GVolumeMonitor *child_monitor);
|
|
|
|
|
|
#define g_union_volume_monitor_get_type _g_union_volume_monitor_get_type
|
|
G_DEFINE_TYPE (GUnionVolumeMonitor, g_union_volume_monitor, G_TYPE_VOLUME_MONITOR);
|
|
|
|
static GRecMutex the_volume_monitor_mutex;
|
|
|
|
static GUnionVolumeMonitor *the_volume_monitor = NULL;
|
|
|
|
static void
|
|
g_union_volume_monitor_finalize (GObject *object)
|
|
{
|
|
GUnionVolumeMonitor *monitor;
|
|
GVolumeMonitor *child_monitor;
|
|
|
|
monitor = G_UNION_VOLUME_MONITOR (object);
|
|
|
|
while (monitor->monitors != NULL)
|
|
{
|
|
child_monitor = monitor->monitors->data;
|
|
g_union_volume_monitor_remove_monitor (monitor,
|
|
child_monitor);
|
|
g_object_unref (child_monitor);
|
|
}
|
|
|
|
G_OBJECT_CLASS (g_union_volume_monitor_parent_class)->finalize (object);
|
|
}
|
|
|
|
static void
|
|
g_union_volume_monitor_dispose (GObject *object)
|
|
{
|
|
GUnionVolumeMonitor *monitor;
|
|
GVolumeMonitor *child_monitor;
|
|
GList *l;
|
|
|
|
monitor = G_UNION_VOLUME_MONITOR (object);
|
|
|
|
g_rec_mutex_lock (&the_volume_monitor_mutex);
|
|
the_volume_monitor = NULL;
|
|
|
|
for (l = monitor->monitors; l != NULL; l = l->next)
|
|
{
|
|
child_monitor = l->data;
|
|
g_object_run_dispose (G_OBJECT (child_monitor));
|
|
}
|
|
|
|
g_rec_mutex_unlock (&the_volume_monitor_mutex);
|
|
|
|
G_OBJECT_CLASS (g_union_volume_monitor_parent_class)->dispose (object);
|
|
}
|
|
|
|
static GList *
|
|
get_mounts (GVolumeMonitor *volume_monitor)
|
|
{
|
|
GUnionVolumeMonitor *monitor;
|
|
GVolumeMonitor *child_monitor;
|
|
GList *res;
|
|
GList *l;
|
|
|
|
monitor = G_UNION_VOLUME_MONITOR (volume_monitor);
|
|
|
|
res = NULL;
|
|
|
|
g_rec_mutex_lock (&the_volume_monitor_mutex);
|
|
|
|
for (l = monitor->monitors; l != NULL; l = l->next)
|
|
{
|
|
child_monitor = l->data;
|
|
|
|
res = g_list_concat (res, g_volume_monitor_get_mounts (child_monitor));
|
|
}
|
|
|
|
g_rec_mutex_unlock (&the_volume_monitor_mutex);
|
|
|
|
return res;
|
|
}
|
|
|
|
static GList *
|
|
get_volumes (GVolumeMonitor *volume_monitor)
|
|
{
|
|
GUnionVolumeMonitor *monitor;
|
|
GVolumeMonitor *child_monitor;
|
|
GList *res;
|
|
GList *l;
|
|
|
|
monitor = G_UNION_VOLUME_MONITOR (volume_monitor);
|
|
|
|
res = NULL;
|
|
|
|
g_rec_mutex_lock (&the_volume_monitor_mutex);
|
|
|
|
for (l = monitor->monitors; l != NULL; l = l->next)
|
|
{
|
|
child_monitor = l->data;
|
|
|
|
res = g_list_concat (res, g_volume_monitor_get_volumes (child_monitor));
|
|
}
|
|
|
|
g_rec_mutex_unlock (&the_volume_monitor_mutex);
|
|
|
|
return res;
|
|
}
|
|
|
|
static GList *
|
|
get_connected_drives (GVolumeMonitor *volume_monitor)
|
|
{
|
|
GUnionVolumeMonitor *monitor;
|
|
GVolumeMonitor *child_monitor;
|
|
GList *res;
|
|
GList *l;
|
|
|
|
monitor = G_UNION_VOLUME_MONITOR (volume_monitor);
|
|
|
|
res = NULL;
|
|
|
|
g_rec_mutex_lock (&the_volume_monitor_mutex);
|
|
|
|
for (l = monitor->monitors; l != NULL; l = l->next)
|
|
{
|
|
child_monitor = l->data;
|
|
|
|
res = g_list_concat (res, g_volume_monitor_get_connected_drives (child_monitor));
|
|
}
|
|
|
|
g_rec_mutex_unlock (&the_volume_monitor_mutex);
|
|
|
|
return res;
|
|
}
|
|
|
|
static GVolume *
|
|
get_volume_for_uuid (GVolumeMonitor *volume_monitor, const char *uuid)
|
|
{
|
|
GUnionVolumeMonitor *monitor;
|
|
GVolumeMonitor *child_monitor;
|
|
GVolume *volume;
|
|
GList *l;
|
|
|
|
monitor = G_UNION_VOLUME_MONITOR (volume_monitor);
|
|
|
|
volume = NULL;
|
|
|
|
g_rec_mutex_lock (&the_volume_monitor_mutex);
|
|
|
|
for (l = monitor->monitors; l != NULL; l = l->next)
|
|
{
|
|
child_monitor = l->data;
|
|
|
|
volume = g_volume_monitor_get_volume_for_uuid (child_monitor, uuid);
|
|
if (volume != NULL)
|
|
break;
|
|
|
|
}
|
|
|
|
g_rec_mutex_unlock (&the_volume_monitor_mutex);
|
|
|
|
return volume;
|
|
}
|
|
|
|
static GMount *
|
|
get_mount_for_uuid (GVolumeMonitor *volume_monitor, const char *uuid)
|
|
{
|
|
GUnionVolumeMonitor *monitor;
|
|
GVolumeMonitor *child_monitor;
|
|
GMount *mount;
|
|
GList *l;
|
|
|
|
monitor = G_UNION_VOLUME_MONITOR (volume_monitor);
|
|
|
|
mount = NULL;
|
|
|
|
g_rec_mutex_lock (&the_volume_monitor_mutex);
|
|
|
|
for (l = monitor->monitors; l != NULL; l = l->next)
|
|
{
|
|
child_monitor = l->data;
|
|
|
|
mount = g_volume_monitor_get_mount_for_uuid (child_monitor, uuid);
|
|
if (mount != NULL)
|
|
break;
|
|
|
|
}
|
|
|
|
g_rec_mutex_unlock (&the_volume_monitor_mutex);
|
|
|
|
return mount;
|
|
}
|
|
|
|
static void
|
|
g_union_volume_monitor_class_init (GUnionVolumeMonitorClass *klass)
|
|
{
|
|
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
|
|
GVolumeMonitorClass *monitor_class = G_VOLUME_MONITOR_CLASS (klass);
|
|
|
|
gobject_class->finalize = g_union_volume_monitor_finalize;
|
|
gobject_class->dispose = g_union_volume_monitor_dispose;
|
|
|
|
monitor_class->get_connected_drives = get_connected_drives;
|
|
monitor_class->get_volumes = get_volumes;
|
|
monitor_class->get_mounts = get_mounts;
|
|
monitor_class->get_volume_for_uuid = get_volume_for_uuid;
|
|
monitor_class->get_mount_for_uuid = get_mount_for_uuid;
|
|
}
|
|
|
|
static void
|
|
child_volume_added (GVolumeMonitor *child_monitor,
|
|
GVolume *child_volume,
|
|
GUnionVolumeMonitor *union_monitor)
|
|
{
|
|
g_signal_emit_by_name (union_monitor,
|
|
"volume-added",
|
|
child_volume);
|
|
}
|
|
|
|
static void
|
|
child_volume_removed (GVolumeMonitor *child_monitor,
|
|
GVolume *child_volume,
|
|
GUnionVolumeMonitor *union_monitor)
|
|
{
|
|
g_signal_emit_by_name (union_monitor,
|
|
"volume-removed",
|
|
child_volume);
|
|
}
|
|
|
|
static void
|
|
child_volume_changed (GVolumeMonitor *child_monitor,
|
|
GVolume *child_volume,
|
|
GUnionVolumeMonitor *union_monitor)
|
|
{
|
|
g_signal_emit_by_name (union_monitor,
|
|
"volume-changed",
|
|
child_volume);
|
|
}
|
|
|
|
static void
|
|
child_mount_added (GVolumeMonitor *child_monitor,
|
|
GMount *child_mount,
|
|
GUnionVolumeMonitor *union_monitor)
|
|
{
|
|
g_signal_emit_by_name (union_monitor,
|
|
"mount-added",
|
|
child_mount);
|
|
}
|
|
|
|
static void
|
|
child_mount_removed (GVolumeMonitor *child_monitor,
|
|
GMount *child_mount,
|
|
GUnionVolumeMonitor *union_monitor)
|
|
{
|
|
g_signal_emit_by_name (union_monitor,
|
|
"mount-removed",
|
|
child_mount);
|
|
}
|
|
|
|
static void
|
|
child_mount_pre_unmount (GVolumeMonitor *child_monitor,
|
|
GMount *child_mount,
|
|
GUnionVolumeMonitor *union_monitor)
|
|
{
|
|
g_signal_emit_by_name (union_monitor,
|
|
"mount-pre-unmount",
|
|
child_mount);
|
|
}
|
|
|
|
|
|
static void
|
|
child_mount_changed (GVolumeMonitor *child_monitor,
|
|
GMount *child_mount,
|
|
GUnionVolumeMonitor *union_monitor)
|
|
{
|
|
g_signal_emit_by_name (union_monitor,
|
|
"mount-changed",
|
|
child_mount);
|
|
}
|
|
|
|
static void
|
|
child_drive_connected (GVolumeMonitor *child_monitor,
|
|
GDrive *child_drive,
|
|
GUnionVolumeMonitor *union_monitor)
|
|
{
|
|
g_signal_emit_by_name (union_monitor,
|
|
"drive-connected",
|
|
child_drive);
|
|
}
|
|
|
|
static void
|
|
child_drive_disconnected (GVolumeMonitor *child_monitor,
|
|
GDrive *child_drive,
|
|
GUnionVolumeMonitor *union_monitor)
|
|
{
|
|
g_signal_emit_by_name (union_monitor,
|
|
"drive-disconnected",
|
|
child_drive);
|
|
}
|
|
|
|
static void
|
|
child_drive_changed (GVolumeMonitor *child_monitor,
|
|
GDrive *child_drive,
|
|
GUnionVolumeMonitor *union_monitor)
|
|
{
|
|
g_signal_emit_by_name (union_monitor,
|
|
"drive-changed",
|
|
child_drive);
|
|
}
|
|
|
|
static void
|
|
child_drive_eject_button (GVolumeMonitor *child_monitor,
|
|
GDrive *child_drive,
|
|
GUnionVolumeMonitor *union_monitor)
|
|
{
|
|
g_signal_emit_by_name (union_monitor,
|
|
"drive-eject-button",
|
|
child_drive);
|
|
}
|
|
|
|
static void
|
|
child_drive_stop_button (GVolumeMonitor *child_monitor,
|
|
GDrive *child_drive,
|
|
GUnionVolumeMonitor *union_monitor)
|
|
{
|
|
g_signal_emit_by_name (union_monitor,
|
|
"drive-stop-button",
|
|
child_drive);
|
|
}
|
|
|
|
static void
|
|
g_union_volume_monitor_add_monitor (GUnionVolumeMonitor *union_monitor,
|
|
GVolumeMonitor *volume_monitor)
|
|
{
|
|
if (g_list_find (union_monitor->monitors, volume_monitor))
|
|
return;
|
|
|
|
union_monitor->monitors =
|
|
g_list_prepend (union_monitor->monitors,
|
|
g_object_ref (volume_monitor));
|
|
|
|
g_signal_connect (volume_monitor, "volume-added", (GCallback)child_volume_added, union_monitor);
|
|
g_signal_connect (volume_monitor, "volume-removed", (GCallback)child_volume_removed, union_monitor);
|
|
g_signal_connect (volume_monitor, "volume-changed", (GCallback)child_volume_changed, union_monitor);
|
|
g_signal_connect (volume_monitor, "mount-added", (GCallback)child_mount_added, union_monitor);
|
|
g_signal_connect (volume_monitor, "mount-removed", (GCallback)child_mount_removed, union_monitor);
|
|
g_signal_connect (volume_monitor, "mount-pre-unmount", (GCallback)child_mount_pre_unmount, union_monitor);
|
|
g_signal_connect (volume_monitor, "mount-changed", (GCallback)child_mount_changed, union_monitor);
|
|
g_signal_connect (volume_monitor, "drive-connected", (GCallback)child_drive_connected, union_monitor);
|
|
g_signal_connect (volume_monitor, "drive-disconnected", (GCallback)child_drive_disconnected, union_monitor);
|
|
g_signal_connect (volume_monitor, "drive-changed", (GCallback)child_drive_changed, union_monitor);
|
|
g_signal_connect (volume_monitor, "drive-eject-button", (GCallback)child_drive_eject_button, union_monitor);
|
|
g_signal_connect (volume_monitor, "drive-stop-button", (GCallback)child_drive_stop_button, union_monitor);
|
|
}
|
|
|
|
static void
|
|
g_union_volume_monitor_remove_monitor (GUnionVolumeMonitor *union_monitor,
|
|
GVolumeMonitor *child_monitor)
|
|
{
|
|
GList *l;
|
|
|
|
l = g_list_find (union_monitor->monitors, child_monitor);
|
|
if (l == NULL)
|
|
return;
|
|
|
|
union_monitor->monitors = g_list_delete_link (union_monitor->monitors, l);
|
|
|
|
g_signal_handlers_disconnect_by_func (child_monitor, child_volume_added, union_monitor);
|
|
g_signal_handlers_disconnect_by_func (child_monitor, child_volume_removed, union_monitor);
|
|
g_signal_handlers_disconnect_by_func (child_monitor, child_volume_changed, union_monitor);
|
|
g_signal_handlers_disconnect_by_func (child_monitor, child_mount_added, union_monitor);
|
|
g_signal_handlers_disconnect_by_func (child_monitor, child_mount_removed, union_monitor);
|
|
g_signal_handlers_disconnect_by_func (child_monitor, child_mount_pre_unmount, union_monitor);
|
|
g_signal_handlers_disconnect_by_func (child_monitor, child_mount_changed, union_monitor);
|
|
g_signal_handlers_disconnect_by_func (child_monitor, child_drive_connected, union_monitor);
|
|
g_signal_handlers_disconnect_by_func (child_monitor, child_drive_disconnected, union_monitor);
|
|
g_signal_handlers_disconnect_by_func (child_monitor, child_drive_changed, union_monitor);
|
|
g_signal_handlers_disconnect_by_func (child_monitor, child_drive_eject_button, union_monitor);
|
|
g_signal_handlers_disconnect_by_func (child_monitor, child_drive_stop_button, union_monitor);
|
|
}
|
|
|
|
static GType
|
|
get_default_native_class (gpointer data)
|
|
{
|
|
GNativeVolumeMonitorClass *klass, *native_class, **native_class_out;
|
|
const char *use_this;
|
|
GIOExtensionPoint *ep;
|
|
GIOExtension *extension;
|
|
GList *l;
|
|
|
|
native_class_out = data;
|
|
|
|
use_this = g_getenv ("GIO_USE_VOLUME_MONITOR");
|
|
|
|
/* Ensure vfs in modules loaded */
|
|
_g_io_modules_ensure_loaded ();
|
|
|
|
ep = g_io_extension_point_lookup (G_NATIVE_VOLUME_MONITOR_EXTENSION_POINT_NAME);
|
|
|
|
native_class = NULL;
|
|
if (use_this)
|
|
{
|
|
extension = g_io_extension_point_get_extension_by_name (ep, use_this);
|
|
if (extension)
|
|
{
|
|
klass = G_NATIVE_VOLUME_MONITOR_CLASS (g_io_extension_ref_class (extension));
|
|
if (G_VOLUME_MONITOR_CLASS (klass)->is_supported())
|
|
native_class = klass;
|
|
else
|
|
g_type_class_unref (klass);
|
|
}
|
|
}
|
|
|
|
if (native_class == NULL)
|
|
{
|
|
for (l = g_io_extension_point_get_extensions (ep); l != NULL; l = l->next)
|
|
{
|
|
extension = l->data;
|
|
klass = G_NATIVE_VOLUME_MONITOR_CLASS (g_io_extension_ref_class (extension));
|
|
if (G_VOLUME_MONITOR_CLASS (klass)->is_supported())
|
|
{
|
|
native_class = klass;
|
|
break;
|
|
}
|
|
else
|
|
g_type_class_unref (klass);
|
|
}
|
|
}
|
|
|
|
if (native_class)
|
|
{
|
|
*native_class_out = native_class;
|
|
return G_TYPE_FROM_CLASS (native_class);
|
|
}
|
|
else
|
|
return G_TYPE_INVALID;
|
|
}
|
|
|
|
/* We return the class, with a ref taken.
|
|
* This way we avoid unloading the class/module
|
|
* between selecting the type and creating the
|
|
* instance on the first call.
|
|
*/
|
|
static GNativeVolumeMonitorClass *
|
|
get_native_class (void)
|
|
{
|
|
static GOnce once_init = G_ONCE_INIT;
|
|
GTypeClass *type_class;
|
|
|
|
type_class = NULL;
|
|
g_once (&once_init, (GThreadFunc)get_default_native_class, &type_class);
|
|
|
|
if (type_class == NULL && once_init.retval != GUINT_TO_POINTER(G_TYPE_INVALID))
|
|
type_class = g_type_class_ref ((GType)once_init.retval);
|
|
|
|
return (GNativeVolumeMonitorClass *)type_class;
|
|
}
|
|
|
|
static void
|
|
g_union_volume_monitor_init (GUnionVolumeMonitor *union_monitor)
|
|
{
|
|
}
|
|
|
|
static void
|
|
populate_union_monitor (GUnionVolumeMonitor *union_monitor)
|
|
{
|
|
GVolumeMonitor *monitor;
|
|
GNativeVolumeMonitorClass *native_class;
|
|
GVolumeMonitorClass *klass;
|
|
GIOExtensionPoint *ep;
|
|
GIOExtension *extension;
|
|
GList *l;
|
|
|
|
native_class = get_native_class ();
|
|
|
|
if (native_class != NULL)
|
|
{
|
|
monitor = g_object_new (G_TYPE_FROM_CLASS (native_class), NULL);
|
|
g_union_volume_monitor_add_monitor (union_monitor, monitor);
|
|
g_object_unref (monitor);
|
|
g_type_class_unref (native_class);
|
|
}
|
|
|
|
ep = g_io_extension_point_lookup (G_VOLUME_MONITOR_EXTENSION_POINT_NAME);
|
|
for (l = g_io_extension_point_get_extensions (ep); l != NULL; l = l->next)
|
|
{
|
|
extension = l->data;
|
|
|
|
klass = G_VOLUME_MONITOR_CLASS (g_io_extension_ref_class (extension));
|
|
if (klass->is_supported == NULL || klass->is_supported())
|
|
{
|
|
monitor = g_object_new (g_io_extension_get_type (extension), NULL);
|
|
g_union_volume_monitor_add_monitor (union_monitor, monitor);
|
|
g_object_unref (monitor);
|
|
}
|
|
g_type_class_unref (klass);
|
|
}
|
|
}
|
|
|
|
static GUnionVolumeMonitor *
|
|
g_union_volume_monitor_new (void)
|
|
{
|
|
GUnionVolumeMonitor *monitor;
|
|
|
|
monitor = g_object_new (G_TYPE_UNION_VOLUME_MONITOR, NULL);
|
|
|
|
return monitor;
|
|
}
|
|
|
|
/**
|
|
* g_volume_monitor_get:
|
|
*
|
|
* Gets the volume monitor used by gio.
|
|
*
|
|
* Returns: (transfer full): a reference to the #GVolumeMonitor used by gio. Call
|
|
* g_object_unref() when done with it.
|
|
**/
|
|
GVolumeMonitor *
|
|
g_volume_monitor_get (void)
|
|
{
|
|
GVolumeMonitor *vm;
|
|
|
|
g_rec_mutex_lock (&the_volume_monitor_mutex);
|
|
|
|
if (the_volume_monitor)
|
|
vm = G_VOLUME_MONITOR (g_object_ref (the_volume_monitor));
|
|
else
|
|
{
|
|
the_volume_monitor = g_union_volume_monitor_new ();
|
|
populate_union_monitor (the_volume_monitor);
|
|
vm = G_VOLUME_MONITOR (the_volume_monitor);
|
|
}
|
|
|
|
g_rec_mutex_unlock (&the_volume_monitor_mutex);
|
|
|
|
return vm;
|
|
}
|
|
|
|
GMount *
|
|
_g_mount_get_for_mount_path (const gchar *mount_path,
|
|
GCancellable *cancellable)
|
|
{
|
|
GNativeVolumeMonitorClass *klass;
|
|
GMount *mount;
|
|
|
|
klass = get_native_class ();
|
|
if (klass == NULL)
|
|
return NULL;
|
|
|
|
mount = NULL;
|
|
|
|
if (klass->get_mount_for_mount_path)
|
|
mount = klass->get_mount_for_mount_path (mount_path, cancellable);
|
|
|
|
/* TODO: How do we know this succeeded? Keep in mind that the native
|
|
* volume monitor may fail (e.g. not being able to connect to
|
|
* hald). Is the get_mount_for_mount_path() method allowed to
|
|
* return NULL? Seems like it is ... probably the method needs
|
|
* to take a boolean and write if it succeeds or not.. Messy.
|
|
* Very messy.
|
|
*/
|
|
|
|
g_type_class_unref (klass);
|
|
|
|
return mount;
|
|
}
|
|
|
|
/**
|
|
* g_volume_monitor_adopt_orphan_mount:
|
|
* @mount: a #GMount object to find a parent for
|
|
*
|
|
* This function should be called by any #GVolumeMonitor
|
|
* implementation when a new #GMount object is created that is not
|
|
* associated with a #GVolume object. It must be called just before
|
|
* emitting the @mount_added signal.
|
|
*
|
|
* If the return value is not %NULL, the caller must associate the
|
|
* returned #GVolume object with the #GMount. This involves returning
|
|
* it in its g_mount_get_volume() implementation. The caller must
|
|
* also listen for the "removed" signal on the returned object
|
|
* and give up its reference when handling that signal
|
|
*
|
|
* Similary, if implementing g_volume_monitor_adopt_orphan_mount(),
|
|
* the implementor must take a reference to @mount and return it in
|
|
* its g_volume_get_mount() implemented. Also, the implementor must
|
|
* listen for the "unmounted" signal on @mount and give up its
|
|
* reference upon handling that signal.
|
|
*
|
|
* There are two main use cases for this function.
|
|
*
|
|
* One is when implementing a user space file system driver that reads
|
|
* blocks of a block device that is already represented by the native
|
|
* volume monitor (for example a CD Audio file system driver). Such
|
|
* a driver will generate its own #GMount object that needs to be
|
|
* associated with the #GVolume object that represents the volume.
|
|
*
|
|
* The other is for implementing a #GVolumeMonitor whose sole purpose
|
|
* is to return #GVolume objects representing entries in the users
|
|
* "favorite servers" list or similar.
|
|
*
|
|
* Returns: (transfer full): the #GVolume object that is the parent for @mount or %NULL
|
|
* if no wants to adopt the #GMount.
|
|
*
|
|
* Deprecated: 2.20: Instead of using this function, #GVolumeMonitor
|
|
* implementations should instead create shadow mounts with the URI of
|
|
* the mount they intend to adopt. See the proxy volume monitor in
|
|
* gvfs for an example of this. Also see g_mount_is_shadowed(),
|
|
* g_mount_shadow() and g_mount_unshadow() functions.
|
|
*/
|
|
GVolume *
|
|
g_volume_monitor_adopt_orphan_mount (GMount *mount)
|
|
{
|
|
GVolumeMonitor *child_monitor;
|
|
GVolumeMonitorClass *child_monitor_class;
|
|
GVolume *volume;
|
|
GList *l;
|
|
|
|
g_return_val_if_fail (mount != NULL, NULL);
|
|
|
|
if (the_volume_monitor == NULL)
|
|
return NULL;
|
|
|
|
volume = NULL;
|
|
|
|
g_rec_mutex_lock (&the_volume_monitor_mutex);
|
|
|
|
for (l = the_volume_monitor->monitors; l != NULL; l = l->next)
|
|
{
|
|
child_monitor = l->data;
|
|
child_monitor_class = G_VOLUME_MONITOR_GET_CLASS (child_monitor);
|
|
|
|
if (child_monitor_class->adopt_orphan_mount != NULL)
|
|
{
|
|
volume = child_monitor_class->adopt_orphan_mount (mount, child_monitor);
|
|
if (volume != NULL)
|
|
break;
|
|
}
|
|
}
|
|
|
|
g_rec_mutex_unlock (&the_volume_monitor_mutex);
|
|
|
|
return volume;
|
|
}
|