gunionvolumemonitor.c 19.8 KB
Newer Older
1 2
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */

3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
/* 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: Alexander Larsson <alexl@redhat.com>
23
 *         David Zeuthen <davidz@redhat.com>
24 25
 */

26
#include "config.h"
27 28 29 30 31

#include <string.h>

#include <glib.h>
#include "gunionvolumemonitor.h"
32
#include "gmountprivate.h"
Alexander Larsson's avatar
Alexander Larsson committed
33
#include "giomodule-priv.h"
34 35 36 37 38 39 40
#ifdef G_OS_UNIX
#include "gunixvolumemonitor.h"
#endif
#include "gnativevolumemonitor.h"

#include "glibintl.h"

41

42 43 44 45 46 47 48 49 50 51
struct _GUnionVolumeMonitor {
  GVolumeMonitor parent;

  GList *monitors;
};

static void g_union_volume_monitor_remove_monitor (GUnionVolumeMonitor *union_monitor,
						   GVolumeMonitor *child_monitor);


Alexander Larsson's avatar
Alexander Larsson committed
52
#define g_union_volume_monitor_get_type _g_union_volume_monitor_get_type
53 54
G_DEFINE_TYPE (GUnionVolumeMonitor, g_union_volume_monitor, G_TYPE_VOLUME_MONITOR);

55
static GRecMutex the_volume_monitor_mutex;
56 57 58 59 60 61 62

static GUnionVolumeMonitor *the_volume_monitor = NULL;

static void
g_union_volume_monitor_finalize (GObject *object)
{
  GUnionVolumeMonitor *monitor;
63 64
  GVolumeMonitor *child_monitor;

65 66
  monitor = G_UNION_VOLUME_MONITOR (object);

67 68 69 70 71 72 73
  while (monitor->monitors != NULL)
    {
      child_monitor = monitor->monitors->data;
      g_union_volume_monitor_remove_monitor (monitor, 
                                             child_monitor);
      g_object_unref (child_monitor);
    }
74

75
  G_OBJECT_CLASS (g_union_volume_monitor_parent_class)->finalize (object);
76 77 78 79 80 81
}

static void
g_union_volume_monitor_dispose (GObject *object)
{
  GUnionVolumeMonitor *monitor;
82 83 84
  GVolumeMonitor *child_monitor;
  GList *l;

85 86
  monitor = G_UNION_VOLUME_MONITOR (object);

87
  g_rec_mutex_lock (&the_volume_monitor_mutex);
88
  the_volume_monitor = NULL;
89 90 91 92 93 94 95

  for (l = monitor->monitors; l != NULL; l = l->next)
    {
      child_monitor = l->data;
      g_object_run_dispose (G_OBJECT (child_monitor));
    }
  
96
  g_rec_mutex_unlock (&the_volume_monitor_mutex);
97 98

  G_OBJECT_CLASS (g_union_volume_monitor_parent_class)->dispose (object);
99 100 101
}

static GList *
102
get_mounts (GVolumeMonitor *volume_monitor)
103 104 105 106 107 108 109 110 111 112
{
  GUnionVolumeMonitor *monitor;
  GVolumeMonitor *child_monitor;
  GList *res;
  GList *l;
  
  monitor = G_UNION_VOLUME_MONITOR (volume_monitor);

  res = NULL;
  
113
  g_rec_mutex_lock (&the_volume_monitor_mutex);
114 115 116 117 118

  for (l = monitor->monitors; l != NULL; l = l->next)
    {
      child_monitor = l->data;

119 120 121
      res = g_list_concat (res, g_volume_monitor_get_mounts (child_monitor));
    }
  
122
  g_rec_mutex_unlock (&the_volume_monitor_mutex);
123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138

  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;
  
139
  g_rec_mutex_lock (&the_volume_monitor_mutex);
140 141 142 143 144 145

  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));
146 147
    }
  
148
  g_rec_mutex_unlock (&the_volume_monitor_mutex);
149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164

  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;
  
165
  g_rec_mutex_lock (&the_volume_monitor_mutex);
166 167 168 169 170

  for (l = monitor->monitors; l != NULL; l = l->next)
    {
      child_monitor = l->data;

171
      res = g_list_concat (res, g_volume_monitor_get_connected_drives (child_monitor));
172 173
    }
  
174
  g_rec_mutex_unlock (&the_volume_monitor_mutex);
175 176 177 178

  return res;
}

179 180 181 182 183 184 185 186 187 188 189 190
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;
  
191
  g_rec_mutex_lock (&the_volume_monitor_mutex);
192 193 194 195 196 197 198 199 200 201 202

  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;

    }
  
203
  g_rec_mutex_unlock (&the_volume_monitor_mutex);
204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219

  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;
  
220
  g_rec_mutex_lock (&the_volume_monitor_mutex);
221 222 223 224 225 226 227 228 229 230 231

  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;

    }
  
232
  g_rec_mutex_unlock (&the_volume_monitor_mutex);
233 234 235 236

  return mount;
}

237 238 239 240 241 242 243 244 245 246
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;
247 248
  monitor_class->get_volumes = get_volumes;
  monitor_class->get_mounts = get_mounts;
249 250
  monitor_class->get_volume_for_uuid = get_volume_for_uuid;
  monitor_class->get_mount_for_uuid = get_mount_for_uuid;
251 252 253
}

static void
254 255 256
child_volume_added (GVolumeMonitor      *child_monitor,
                    GVolume    *child_volume,
                    GUnionVolumeMonitor *union_monitor)
257 258
{
  g_signal_emit_by_name (union_monitor,
259
			 "volume-added",
260 261 262 263
			 child_volume);
}

static void
264 265 266
child_volume_removed (GVolumeMonitor      *child_monitor,
                      GVolume    *child_volume,
                      GUnionVolumeMonitor *union_monitor)
267 268
{
  g_signal_emit_by_name (union_monitor,
269
			 "volume-removed",
270 271 272 273
			 child_volume);
}

static void
274 275 276
child_volume_changed (GVolumeMonitor      *child_monitor,
                      GVolume    *child_volume,
                      GUnionVolumeMonitor *union_monitor)
277 278
{
  g_signal_emit_by_name (union_monitor,
279
			 "volume-changed",
280 281 282
			 child_volume);
}

283 284 285 286 287 288
static void
child_mount_added (GVolumeMonitor      *child_monitor,
                   GMount              *child_mount,
                   GUnionVolumeMonitor *union_monitor)
{
  g_signal_emit_by_name (union_monitor,
289
                         "mount-added",
290 291 292 293 294 295 296 297 298
                         child_mount);
}

static void
child_mount_removed (GVolumeMonitor      *child_monitor,
                     GMount              *child_mount,
                     GUnionVolumeMonitor *union_monitor)
{
  g_signal_emit_by_name (union_monitor,
299
			 "mount-removed",
300 301 302 303 304 305 306 307 308
			 child_mount);
}

static void
child_mount_pre_unmount (GVolumeMonitor       *child_monitor,
                          GMount              *child_mount,
                          GUnionVolumeMonitor *union_monitor)
{
  g_signal_emit_by_name (union_monitor,
309
			 "mount-pre-unmount",
310 311 312 313 314 315 316 317 318 319
			 child_mount);
}


static void
child_mount_changed (GVolumeMonitor       *child_monitor,
                      GMount              *child_mount,
                      GUnionVolumeMonitor *union_monitor)
{
  g_signal_emit_by_name (union_monitor,
320
			 "mount-changed",
321 322 323
			 child_mount);
}

324
static void
Matthias Clasen's avatar
Matthias Clasen committed
325 326 327
child_drive_connected (GVolumeMonitor      *child_monitor,
                       GDrive              *child_drive,
                       GUnionVolumeMonitor *union_monitor)
328 329
{
  g_signal_emit_by_name (union_monitor,
330
			 "drive-connected",
331 332 333 334
			 child_drive);
}

static void
Matthias Clasen's avatar
Matthias Clasen committed
335 336 337
child_drive_disconnected (GVolumeMonitor      *child_monitor,
                          GDrive              *child_drive,
                          GUnionVolumeMonitor *union_monitor)
338 339
{
  g_signal_emit_by_name (union_monitor,
340
			 "drive-disconnected",
341 342 343
			 child_drive);
}

344 345 346 347 348 349
static void
child_drive_changed (GVolumeMonitor      *child_monitor,
                     GDrive             *child_drive,
                     GUnionVolumeMonitor *union_monitor)
{
  g_signal_emit_by_name (union_monitor,
350
                         "drive-changed",
351 352 353
                         child_drive);
}

354 355 356 357 358 359
static void
child_drive_eject_button (GVolumeMonitor      *child_monitor,
                          GDrive             *child_drive,
                          GUnionVolumeMonitor *union_monitor)
{
  g_signal_emit_by_name (union_monitor,
360
                         "drive-eject-button",
361 362 363
                         child_drive);
}

364 365 366 367 368 369 370 371 372 373
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);
}

374 375
static void
g_union_volume_monitor_add_monitor (GUnionVolumeMonitor *union_monitor,
Matthias Clasen's avatar
Matthias Clasen committed
376
                                    GVolumeMonitor      *volume_monitor)
377 378 379 380 381 382 383 384
{
  if (g_list_find (union_monitor->monitors, volume_monitor))
    return;

  union_monitor->monitors =
    g_list_prepend (union_monitor->monitors,
		    g_object_ref (volume_monitor));

385 386 387 388 389 390 391 392 393 394 395
  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);
396
  g_signal_connect (volume_monitor, "drive-stop-button", (GCallback)child_drive_stop_button, union_monitor);
397 398 399 400
}

static void
g_union_volume_monitor_remove_monitor (GUnionVolumeMonitor *union_monitor,
Matthias Clasen's avatar
Matthias Clasen committed
401
                                       GVolumeMonitor      *child_monitor)
402 403 404 405 406 407 408 409 410
{
  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);

411 412 413 414 415 416 417
  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);
418 419
  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);
420
  g_signal_handlers_disconnect_by_func (child_monitor, child_drive_changed, union_monitor);
421
  g_signal_handlers_disconnect_by_func (child_monitor, child_drive_eject_button, union_monitor);
422
  g_signal_handlers_disconnect_by_func (child_monitor, child_drive_stop_button, union_monitor);
423 424
}

425
static GType
426
get_default_native_class (gpointer data)
427
{
428
  GNativeVolumeMonitorClass *klass, *native_class, **native_class_out;
429
  const char *use_this;
430 431 432
  GIOExtensionPoint *ep;
  GIOExtension *extension;
  GList *l;
433

434 435
  native_class_out = data;
  
436 437
  use_this = g_getenv ("GIO_USE_VOLUME_MONITOR");
  
438
  /* Ensure vfs in modules loaded */
Alexander Larsson's avatar
Alexander Larsson committed
439
  _g_io_modules_ensure_loaded ();
440

441
  ep = g_io_extension_point_lookup (G_NATIVE_VOLUME_MONITOR_EXTENSION_POINT_NAME);
442 443

  native_class = NULL;
444 445 446 447
  if (use_this)
    {
      extension = g_io_extension_point_get_extension_by_name (ep, use_this);
      if (extension)
448
	{
449 450 451 452 453
	  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);
454
	}
455 456
    }

457 458 459 460 461 462 463 464 465 466 467 468 469 470 471
  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);
	}
    }
472
 
473 474 475 476 477 478 479
  if (native_class)
    {
      *native_class_out = native_class;
      return G_TYPE_FROM_CLASS (native_class);
    }
  else
    return G_TYPE_INVALID;
480 481
}

482 483 484 485 486 487
/* 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 *
488
get_native_class (void)
489
{
490 491
  static GOnce once_init = G_ONCE_INIT;
  GTypeClass *type_class;
492

493 494
  type_class = NULL;
  g_once (&once_init, (GThreadFunc)get_default_native_class, &type_class);
495

496
  if (type_class == NULL && once_init.retval != GUINT_TO_POINTER(G_TYPE_INVALID))
497 498 499
    type_class = g_type_class_ref ((GType)once_init.retval);
  
  return (GNativeVolumeMonitorClass *)type_class;
500 501 502 503
}

static void
g_union_volume_monitor_init (GUnionVolumeMonitor *union_monitor)
504 505 506 507 508
{
}

static void
populate_union_monitor (GUnionVolumeMonitor *union_monitor)
509 510
{
  GVolumeMonitor *monitor;
511
  GNativeVolumeMonitorClass *native_class;
512
  GVolumeMonitorClass *klass;
513 514 515
  GIOExtensionPoint *ep;
  GIOExtension *extension;
  GList *l;
516

517
  native_class = get_native_class ();
518

519
  if (native_class != NULL)
520
    {
521
      monitor = g_object_new (G_TYPE_FROM_CLASS (native_class), NULL);
522 523
      g_union_volume_monitor_add_monitor (union_monitor, monitor);
      g_object_unref (monitor);
524
      g_type_class_unref (native_class);
525
    }
526

527 528 529 530 531 532
  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));
533 534
      if (klass->is_supported == NULL || klass->is_supported())
	{
535
	  monitor = g_object_new (g_io_extension_get_type (extension), NULL);
536 537 538 539
	  g_union_volume_monitor_add_monitor (union_monitor, monitor);
	  g_object_unref (monitor);
	}
      g_type_class_unref (klass);
540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555
    }
}

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:
 * 
Matthias Clasen's avatar
Matthias Clasen committed
556 557
 * Gets the volume monitor used by gio.
 *
558
 * Returns: (transfer full): a reference to the #GVolumeMonitor used by gio. Call
Matthias Clasen's avatar
Matthias Clasen committed
559
 *    g_object_unref() when done with it.
560 561 562 563 564 565
 **/
GVolumeMonitor *
g_volume_monitor_get (void)
{
  GVolumeMonitor *vm;
  
566
  g_rec_mutex_lock (&the_volume_monitor_mutex);
567

Matthias Clasen's avatar
Matthias Clasen committed
568
  if (the_volume_monitor)
569 570 571 572
    vm = G_VOLUME_MONITOR (g_object_ref (the_volume_monitor));
  else
    {
      the_volume_monitor = g_union_volume_monitor_new ();
573
      populate_union_monitor (the_volume_monitor);
574 575 576
      vm = G_VOLUME_MONITOR (the_volume_monitor);
    }
  
577
  g_rec_mutex_unlock (&the_volume_monitor_mutex);
578 579 580 581

  return vm;
}

582
GMount *
Matthias Clasen's avatar
Matthias Clasen committed
583
_g_mount_get_for_mount_path (const gchar  *mount_path,
584
			     GCancellable *cancellable)
585 586
{
  GNativeVolumeMonitorClass *klass;
587
  GMount *mount;
588
  
589 590
  klass = get_native_class ();
  if (klass == NULL)
591 592
    return NULL;

593
  mount = NULL;
594

595
  if (klass->get_mount_for_mount_path)
596
    {
597
      g_rec_mutex_lock (&the_volume_monitor_mutex);
598
      mount = klass->get_mount_for_mount_path (mount_path, cancellable);
599
      g_rec_mutex_unlock (&the_volume_monitor_mutex);
600 601 602 603 604 605 606 607 608
    }

  /* 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.
   */
609 610 611
  
  g_type_class_unref (klass);

612
  return mount;
613
}
614

615 616 617 618 619 620 621 622 623 624 625
/**
 * 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
626
 * it in its g_mount_get_volume() implementation. The caller must
627
 * also listen for the "removed" signal on the returned object
628
 * and give up its reference when handling that signal
629 630 631
 * 
 * Similary, if implementing g_volume_monitor_adopt_orphan_mount(),
 * the implementor must take a reference to @mount and return it in
632 633
 * its g_volume_get_mount() implemented. Also, the implementor must
 * listen for the "unmounted" signal on @mount and give up its
634 635 636 637 638 639 640
 * 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
641
 * a driver will generate its own #GMount object that needs to be
Matthias Clasen's avatar
Matthias Clasen committed
642
 * associated with the #GVolume object that represents the volume.
643 644 645 646 647
 *
 * 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.
 *
648
 * Returns: (transfer full): the #GVolume object that is the parent for @mount or %NULL
649
 * if no wants to adopt the #GMount.
650 651 652 653
 *
 * 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
654 655
 * gvfs for an example of this. Also see g_mount_is_shadowed(),
 * g_mount_shadow() and g_mount_unshadow() functions.
656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671
 */
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;
  
672
  g_rec_mutex_lock (&the_volume_monitor_mutex);
673 674 675 676 677 678 679 680

  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)
        {
681
          volume = child_monitor_class->adopt_orphan_mount (mount, child_monitor);
682 683 684 685 686
          if (volume != NULL)
            break;
        }
    }
  
687
  g_rec_mutex_unlock (&the_volume_monitor_mutex);
688 689 690

  return volume;
}