gio/gunionvolumemonitor.c

   1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
   2
   3 /* GIO - GLib Input, Output and Streaming Library
   4  *
   5  * Copyright (C) 2006-2007 Red Hat, Inc.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General
  18  * Public License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  *
  22  * Author: Alexander Larsson <alexl@redhat.com>
  23  *         David Zeuthen <davidz@redhat.com>
  24  */
  25
  26 #include "config.h"
  27
  28 #include <string.h>
  29
  30 #include <glib.h>
  31 #include "gunionvolumemonitor.h"
  32 #include "gmountprivate.h"
  33 #include "giomodule-priv.h"
  34 #ifdef G_OS_UNIX
  35 #include "gunixvolumemonitor.h"
  36 #endif
  37 #include "gnativevolumemonitor.h"
  38
  39 #include "glibintl.h"
  40
  41
  42 struct _GUnionVolumeMonitor {
  43   GVolumeMonitor parent;
  44
  45   GList *monitors;
  46 };
  47
  48 static void g_union_volume_monitor_remove_monitor (GUnionVolumeMonitor *union_monitor,
  49                                                    GVolumeMonitor *child_monitor);
  50
  51
  52 #define g_union_volume_monitor_get_type _g_union_volume_monitor_get_type
  53 G_DEFINE_TYPE (GUnionVolumeMonitor, g_union_volume_monitor, G_TYPE_VOLUME_MONITOR);
  54
  55 static GStaticRecMutex the_volume_monitor_mutex = G_STATIC_REC_MUTEX_INIT;
  56
  57 static GUnionVolumeMonitor *the_volume_monitor = NULL;
  58
  59 static void
  60 g_union_volume_monitor_finalize (GObject *object)
  61 {
  62   GUnionVolumeMonitor *monitor;
  63   GVolumeMonitor *child_monitor;
  64
  65   monitor = G_UNION_VOLUME_MONITOR (object);
  66
  67   while (monitor->monitors != NULL)
  68     {
  69       child_monitor = monitor->monitors->data;
  70       g_union_volume_monitor_remove_monitor (monitor,
  71                                              child_monitor);
  72       g_object_unref (child_monitor);
  73     }
  74
  75   G_OBJECT_CLASS (g_union_volume_monitor_parent_class)->finalize (object);
  76 }
  77
  78 static void
  79 g_union_volume_monitor_dispose (GObject *object)
  80 {
  81   GUnionVolumeMonitor *monitor;
  82   GVolumeMonitor *child_monitor;
  83   GList *l;
  84
  85   monitor = G_UNION_VOLUME_MONITOR (object);
  86
  87   g_static_rec_mutex_lock (&the_volume_monitor_mutex);
  88   the_volume_monitor = NULL;
  89
  90   for (l = monitor->monitors; l != NULL; l = l->next)
  91     {
  92       child_monitor = l->data;
  93       g_object_run_dispose (G_OBJECT (child_monitor));
  94     }
  95
  96   g_static_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   GUnionVolumeMonitor *monitor;
 105   GVolumeMonitor *child_monitor;
 106   GList *res;
 107   GList *l;
 108
 109   monitor = G_UNION_VOLUME_MONITOR (volume_monitor);
 110
 111   res = NULL;
 112
 113   g_static_rec_mutex_lock (&the_volume_monitor_mutex);
 114
 115   for (l = monitor->monitors; l != NULL; l = l->next)
 116     {
 117       child_monitor = l->data;
 118
 119       res = g_list_concat (res, g_volume_monitor_get_mounts (child_monitor));
 120     }
 121
 122   g_static_rec_mutex_unlock (&the_volume_monitor_mutex);
 123
 124   return res;
 125 }
 126
 127 static GList *
 128 get_volumes (GVolumeMonitor *volume_monitor)
 129 {
 130   GUnionVolumeMonitor *monitor;
 131   GVolumeMonitor *child_monitor;
 132   GList *res;
 133   GList *l;
 134
 135   monitor = G_UNION_VOLUME_MONITOR (volume_monitor);
 136
 137   res = NULL;
 138
 139   g_static_rec_mutex_lock (&the_volume_monitor_mutex);
 140
 141   for (l = monitor->monitors; l != NULL; l = l->next)
 142     {
 143       child_monitor = l->data;
 144
 145       res = g_list_concat (res, g_volume_monitor_get_volumes (child_monitor));
 146     }
 147
 148   g_static_rec_mutex_unlock (&the_volume_monitor_mutex);
 149
 150   return res;
 151 }
 152
 153 static GList *
 154 get_connected_drives (GVolumeMonitor *volume_monitor)
 155 {
 156   GUnionVolumeMonitor *monitor;
 157   GVolumeMonitor *child_monitor;
 158   GList *res;
 159   GList *l;
 160
 161   monitor = G_UNION_VOLUME_MONITOR (volume_monitor);
 162
 163   res = NULL;
 164
 165   g_static_rec_mutex_lock (&the_volume_monitor_mutex);
 166
 167   for (l = monitor->monitors; l != NULL; l = l->next)
 168     {
 169       child_monitor = l->data;
 170
 171       res = g_list_concat (res, g_volume_monitor_get_connected_drives (child_monitor));
 172     }
 173
 174   g_static_rec_mutex_unlock (&the_volume_monitor_mutex);
 175
 176   return res;
 177 }
 178
 179 static GVolume *
 180 get_volume_for_uuid (GVolumeMonitor *volume_monitor, const char *uuid)
 181 {
 182   GUnionVolumeMonitor *monitor;
 183   GVolumeMonitor *child_monitor;
 184   GVolume *volume;
 185   GList *l;
 186
 187   monitor = G_UNION_VOLUME_MONITOR (volume_monitor);
 188
 189   volume = NULL;
 190
 191   g_static_rec_mutex_lock (&the_volume_monitor_mutex);
 192
 193   for (l = monitor->monitors; l != NULL; l = l->next)
 194     {
 195       child_monitor = l->data;
 196
 197       volume = g_volume_monitor_get_volume_for_uuid (child_monitor, uuid);
 198       if (volume != NULL)
 199         break;
 200
 201     }
 202
 203   g_static_rec_mutex_unlock (&the_volume_monitor_mutex);
 204
 205   return volume;
 206 }
 207
 208 static GMount *
 209 get_mount_for_uuid (GVolumeMonitor *volume_monitor, const char *uuid)
 210 {
 211   GUnionVolumeMonitor *monitor;
 212   GVolumeMonitor *child_monitor;
 213   GMount *mount;
 214   GList *l;
 215
 216   monitor = G_UNION_VOLUME_MONITOR (volume_monitor);
 217
 218   mount = NULL;
 219
 220   g_static_rec_mutex_lock (&the_volume_monitor_mutex);
 221
 222   for (l = monitor->monitors; l != NULL; l = l->next)
 223     {
 224       child_monitor = l->data;
 225
 226       mount = g_volume_monitor_get_mount_for_uuid (child_monitor, uuid);
 227       if (mount != NULL)
 228         break;
 229
 230     }
 231
 232   g_static_rec_mutex_unlock (&the_volume_monitor_mutex);
 233
 234   return mount;
 235 }
 236
 237 static void
 238 g_union_volume_monitor_class_init (GUnionVolumeMonitorClass *klass)
 239 {
 240   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 241   GVolumeMonitorClass *monitor_class = G_VOLUME_MONITOR_CLASS (klass);
 242
 243   gobject_class->finalize = g_union_volume_monitor_finalize;
 244   gobject_class->dispose = g_union_volume_monitor_dispose;
 245
 246   monitor_class->get_connected_drives = get_connected_drives;
 247   monitor_class->get_volumes = get_volumes;
 248   monitor_class->get_mounts = get_mounts;
 249   monitor_class->get_volume_for_uuid = get_volume_for_uuid;
 250   monitor_class->get_mount_for_uuid = get_mount_for_uuid;
 251 }
 252
 253 static void
 254 child_volume_added (GVolumeMonitor      *child_monitor,
 255                     GVolume    *child_volume,
 256                     GUnionVolumeMonitor *union_monitor)
 257 {
 258   g_signal_emit_by_name (union_monitor,
 259                          "volume-added",
 260                          child_volume);
 261 }
 262
 263 static void
 264 child_volume_removed (GVolumeMonitor      *child_monitor,
 265                       GVolume    *child_volume,
 266                       GUnionVolumeMonitor *union_monitor)
 267 {
 268   g_signal_emit_by_name (union_monitor,
 269                          "volume-removed",
 270                          child_volume);
 271 }
 272
 273 static void
 274 child_volume_changed (GVolumeMonitor      *child_monitor,
 275                       GVolume    *child_volume,
 276                       GUnionVolumeMonitor *union_monitor)
 277 {
 278   g_signal_emit_by_name (union_monitor,
 279                          "volume-changed",
 280                          child_volume);
 281 }
 282
 283 static void
 284 child_mount_added (GVolumeMonitor      *child_monitor,
 285                    GMount              *child_mount,
 286                    GUnionVolumeMonitor *union_monitor)
 287 {
 288   g_signal_emit_by_name (union_monitor,
 289                          "mount-added",
 290                          child_mount);
 291 }
 292
 293 static void
 294 child_mount_removed (GVolumeMonitor      *child_monitor,
 295                      GMount              *child_mount,
 296                      GUnionVolumeMonitor *union_monitor)
 297 {
 298   g_signal_emit_by_name (union_monitor,
 299                          "mount-removed",
 300                          child_mount);
 301 }
 302
 303 static void
 304 child_mount_pre_unmount (GVolumeMonitor       *child_monitor,
 305                           GMount              *child_mount,
 306                           GUnionVolumeMonitor *union_monitor)
 307 {
 308   g_signal_emit_by_name (union_monitor,
 309                          "mount-pre-unmount",
 310                          child_mount);
 311 }
 312
 313
 314 static void
 315 child_mount_changed (GVolumeMonitor       *child_monitor,
 316                       GMount              *child_mount,
 317                       GUnionVolumeMonitor *union_monitor)
 318 {
 319   g_signal_emit_by_name (union_monitor,
 320                          "mount-changed",
 321                          child_mount);
 322 }
 323
 324 static void
 325 child_drive_connected (GVolumeMonitor      *child_monitor,
 326                        GDrive              *child_drive,
 327                        GUnionVolumeMonitor *union_monitor)
 328 {
 329   g_signal_emit_by_name (union_monitor,
 330                          "drive-connected",
 331                          child_drive);
 332 }
 333
 334 static void
 335 child_drive_disconnected (GVolumeMonitor      *child_monitor,
 336                           GDrive              *child_drive,
 337                           GUnionVolumeMonitor *union_monitor)
 338 {
 339   g_signal_emit_by_name (union_monitor,
 340                          "drive-disconnected",
 341                          child_drive);
 342 }
 343
 344 static void
 345 child_drive_changed (GVolumeMonitor      *child_monitor,
 346                      GDrive             *child_drive,
 347                      GUnionVolumeMonitor *union_monitor)
 348 {
 349   g_signal_emit_by_name (union_monitor,
 350                          "drive-changed",
 351                          child_drive);
 352 }
 353
 354 static void
 355 child_drive_eject_button (GVolumeMonitor      *child_monitor,
 356                           GDrive             *child_drive,
 357                           GUnionVolumeMonitor *union_monitor)
 358 {
 359   g_signal_emit_by_name (union_monitor,
 360                          "drive-eject-button",
 361                          child_drive);
 362 }
 363
 364 static void
 365 child_drive_stop_button (GVolumeMonitor      *child_monitor,
 366                          GDrive             *child_drive,
 367                          GUnionVolumeMonitor *union_monitor)
 368 {
 369   g_signal_emit_by_name (union_monitor,
 370                          "drive-stop-button",
 371                          child_drive);
 372 }
 373
 374 static void
 375 g_union_volume_monitor_add_monitor (GUnionVolumeMonitor *union_monitor,
 376                                     GVolumeMonitor      *volume_monitor)
 377 {
 378   if (g_list_find (union_monitor->monitors, volume_monitor))
 379     return;
 380
 381   union_monitor->monitors =
 382     g_list_prepend (union_monitor->monitors,
 383                     g_object_ref (volume_monitor));
 384
 385   g_signal_connect (volume_monitor, "volume-added", (GCallback)child_volume_added, union_monitor);
 386   g_signal_connect (volume_monitor, "volume-removed", (GCallback)child_volume_removed, union_monitor);
 387   g_signal_connect (volume_monitor, "volume-changed", (GCallback)child_volume_changed, union_monitor);
 388   g_signal_connect (volume_monitor, "mount-added", (GCallback)child_mount_added, union_monitor);
 389   g_signal_connect (volume_monitor, "mount-removed", (GCallback)child_mount_removed, union_monitor);
 390   g_signal_connect (volume_monitor, "mount-pre-unmount", (GCallback)child_mount_pre_unmount, union_monitor);
 391   g_signal_connect (volume_monitor, "mount-changed", (GCallback)child_mount_changed, union_monitor);
 392   g_signal_connect (volume_monitor, "drive-connected", (GCallback)child_drive_connected, union_monitor);
 393   g_signal_connect (volume_monitor, "drive-disconnected", (GCallback)child_drive_disconnected, union_monitor);
 394   g_signal_connect (volume_monitor, "drive-changed", (GCallback)child_drive_changed, union_monitor);
 395   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 static void
 400 g_union_volume_monitor_remove_monitor (GUnionVolumeMonitor *union_monitor,
 401                                        GVolumeMonitor      *child_monitor)
 402 {
 403   GList *l;
 404
 405   l = g_list_find (union_monitor->monitors, child_monitor);
 406   if (l == NULL)
 407     return;
 408
 409   union_monitor->monitors = g_list_delete_link (union_monitor->monitors, l);
 410
 411   g_signal_handlers_disconnect_by_func (child_monitor, child_volume_added, union_monitor);
 412   g_signal_handlers_disconnect_by_func (child_monitor, child_volume_removed, union_monitor);
 413   g_signal_handlers_disconnect_by_func (child_monitor, child_volume_changed, union_monitor);
 414   g_signal_handlers_disconnect_by_func (child_monitor, child_mount_added, union_monitor);
 415   g_signal_handlers_disconnect_by_func (child_monitor, child_mount_removed, union_monitor);
 416   g_signal_handlers_disconnect_by_func (child_monitor, child_mount_pre_unmount, union_monitor);
 417   g_signal_handlers_disconnect_by_func (child_monitor, child_mount_changed, union_monitor);
 418   g_signal_handlers_disconnect_by_func (child_monitor, child_drive_connected, union_monitor);
 419   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   GIOExtensionPoint *ep;
 431   GIOExtension *extension;
 432   GList *l;
 433
 434   native_class_out = data;
 435
 436   use_this = g_getenv ("GIO_USE_VOLUME_MONITOR");
 437
 438   /* Ensure vfs in modules loaded */
 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   if (use_this)
 445     {
 446       extension = g_io_extension_point_get_extension_by_name (ep, use_this);
 447       if (extension)
 448         {
 449           klass = G_NATIVE_VOLUME_MONITOR_CLASS (g_io_extension_ref_class (extension));
 450           if (G_VOLUME_MONITOR_CLASS (klass)->is_supported())
 451             native_class = klass;
 452           else
 453             g_type_class_unref (klass);
 454         }
 455     }
 456
 457   if (native_class == NULL)
 458     {
 459       for (l = g_io_extension_point_get_extensions (ep); l != NULL; l = l->next)
 460         {
 461           extension = l->data;
 462           klass = G_NATIVE_VOLUME_MONITOR_CLASS (g_io_extension_ref_class (extension));
 463           if (G_VOLUME_MONITOR_CLASS (klass)->is_supported())
 464             {
 465               native_class = klass;
 466               break;
 467             }
 468           else
 469             g_type_class_unref (klass);
 470         }
 471     }
 472
 473   if (native_class)
 474     {
 475       *native_class_out = native_class;
 476       return G_TYPE_FROM_CLASS (native_class);
 477     }
 478   else
 479     return G_TYPE_INVALID;
 480 }
 481
 482 /* We return the class, with a ref taken.
 483  * This way we avoid unloading the class/module
 484  * between selecting the type and creating the
 485  * instance on the first call.
 486  */
 487 static GNativeVolumeMonitorClass *
 488 get_native_class (void)
 489 {
 490   static GOnce once_init = G_ONCE_INIT;
 491   GTypeClass *type_class;
 492
 493   type_class = NULL;
 494   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     type_class = g_type_class_ref ((GType)once_init.retval);
 498
 499   return (GNativeVolumeMonitorClass *)type_class;
 500 }
 501
 502 static void
 503 g_union_volume_monitor_init (GUnionVolumeMonitor *union_monitor)
 504 {
 505 }
 506
 507 static void
 508 populate_union_monitor (GUnionVolumeMonitor *union_monitor)
 509 {
 510   GVolumeMonitor *monitor;
 511   GNativeVolumeMonitorClass *native_class;
 512   GVolumeMonitorClass *klass;
 513   GIOExtensionPoint *ep;
 514   GIOExtension *extension;
 515   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       g_union_volume_monitor_add_monitor (union_monitor, monitor);
 523       g_object_unref (monitor);
 524       g_type_class_unref (native_class);
 525     }
 526
 527   ep = g_io_extension_point_lookup (G_VOLUME_MONITOR_EXTENSION_POINT_NAME);
 528   for (l = g_io_extension_point_get_extensions (ep); l != NULL; l = l->next)
 529     {
 530       extension = l->data;
 531
 532       klass = G_VOLUME_MONITOR_CLASS (g_io_extension_ref_class (extension));
 533       if (klass->is_supported == NULL || klass->is_supported())
 534         {
 535           monitor = g_object_new (g_io_extension_get_type (extension), NULL);
 536           g_union_volume_monitor_add_monitor (union_monitor, monitor);
 537           g_object_unref (monitor);
 538         }
 539       g_type_class_unref (klass);
 540     }
 541 }
 542
 543 static GUnionVolumeMonitor *
 544 g_union_volume_monitor_new (void)
 545 {
 546   GUnionVolumeMonitor *monitor;
 547
 548   monitor = g_object_new (G_TYPE_UNION_VOLUME_MONITOR, NULL);
 549
 550   return monitor;
 551 }
 552
 553 /**
 554  * g_volume_monitor_get:
 555  *
 556  * Gets the volume monitor used by gio.
 557  *
 558  * Returns: a reference to the #GVolumeMonitor used by gio. Call
 559  *    g_object_unref() when done with it.
 560  **/
 561 GVolumeMonitor *
 562 g_volume_monitor_get (void)
 563 {
 564   GVolumeMonitor *vm;
 565
 566   g_static_rec_mutex_lock (&the_volume_monitor_mutex);
 567
 568   if (the_volume_monitor)
 569     vm = G_VOLUME_MONITOR (g_object_ref (the_volume_monitor));
 570   else
 571     {
 572       the_volume_monitor = g_union_volume_monitor_new ();
 573       populate_union_monitor (the_volume_monitor);
 574       vm = G_VOLUME_MONITOR (the_volume_monitor);
 575     }
 576
 577   g_static_rec_mutex_unlock (&the_volume_monitor_mutex);
 578
 579   return vm;
 580 }
 581
 582 GMount *
 583 _g_mount_get_for_mount_path (const gchar  *mount_path,
 584                              GCancellable *cancellable)
 585 {
 586   GNativeVolumeMonitorClass *klass;
 587   GMount *mount;
 588
 589   klass = get_native_class ();
 590   if (klass == NULL)
 591     return NULL;
 592
 593   mount = NULL;
 594
 595   if (klass->get_mount_for_mount_path)
 596     {
 597       g_static_rec_mutex_lock (&the_volume_monitor_mutex);
 598       mount = klass->get_mount_for_mount_path (mount_path, cancellable);
 599       g_static_rec_mutex_unlock (&the_volume_monitor_mutex);
 600     }
 601
 602   /* TODO: How do we know this succeeded? Keep in mind that the native
 603    *       volume monitor may fail (e.g. not being able to connect to
 604    *       hald). Is the get_mount_for_mount_path() method allowed to
 605    *       return NULL? Seems like it is ... probably the method needs
 606    *       to take a boolean and write if it succeeds or not.. Messy.
 607    *       Very messy.
 608    */
 609
 610   g_type_class_unref (klass);
 611
 612   return mount;
 613 }
 614
 615 /**
 616  * g_volume_monitor_adopt_orphan_mount:
 617  * @mount: a #GMount object to find a parent for
 618  *
 619  * This function should be called by any #GVolumeMonitor
 620  * implementation when a new #GMount object is created that is not
 621  * associated with a #GVolume object. It must be called just before
 622  * emitting the @mount_added signal.
 623  *
 624  * If the return value is not %NULL, the caller must associate the
 625  * 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  * Similary, if implementing g_volume_monitor_adopt_orphan_mount(),
 631  * the implementor must take a reference to @mount and return it in
 632  * its g_volume_get_mount() implemented. Also, the implementor must
 633  * listen for the "unmounted" signal on @mount and give up its
 634  * reference upon handling that signal.
 635  *
 636  * There are two main use cases for this function.
 637  *
 638  * One is when implementing a user space file system driver that reads
 639  * blocks of a block device that is already represented by the native
 640  * volume monitor (for example a CD Audio file system driver). Such
 641  * a driver will generate its own #GMount object that needs to be
 642  * assoicated with the #GVolume object that represents the volume.
 643  *
 644  * The other is for implementing a #GVolumeMonitor whose sole purpose
 645  * is to return #GVolume objects representing entries in the users
 646  * "favorite servers" list or similar.
 647  *
 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  * Deprecated: 2.20: Instead of using this function, #GVolumeMonitor
 652  * implementations should instead create shadow mounts with the URI of
 653  * the mount they intend to adopt. See the proxy volume monitor in
 654  * gvfs for an example of this. Also see g_mount_is_shadowed(),
 655  * g_mount_shadow() and g_mount_unshadow() functions.
 656  */
 657 GVolume *
 658 g_volume_monitor_adopt_orphan_mount (GMount *mount)
 659 {
 660   GVolumeMonitor *child_monitor;
 661   GVolumeMonitorClass *child_monitor_class;
 662   GVolume *volume;
 663   GList *l;
 664
 665   g_return_val_if_fail (mount != NULL, NULL);
 666
 667   if (the_volume_monitor == NULL)
 668     return NULL;
 669
 670   volume = NULL;
 671
 672   g_static_rec_mutex_lock (&the_volume_monitor_mutex);
 673
 674   for (l = the_volume_monitor->monitors; l != NULL; l = l->next)
 675     {
 676       child_monitor = l->data;
 677       child_monitor_class = G_VOLUME_MONITOR_GET_CLASS (child_monitor);
 678
 679       if (child_monitor_class->adopt_orphan_mount != NULL)
 680         {
 681           volume = child_monitor_class->adopt_orphan_mount (mount, child_monitor);
 682           if (volume != NULL)
 683             break;
 684         }
 685     }
 686
 687   g_static_rec_mutex_unlock (&the_volume_monitor_mutex);
 688
 689   return volume;
 690 }