gio/gcancellable.c

   1 /* GIO - GLib Input, Output and Streaming Library
   2  *
   3  * Copyright (C) 2006-2007 Red Hat, Inc.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General
  16  * Public License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  *
  20  * Author: Alexander Larsson <alexl@redhat.com>
  21  */
  22
  23 #include "config.h"
  24 #ifdef HAVE_UNISTD_H
  25 #include <unistd.h>
  26 #endif
  27 #include <errno.h>
  28 #include <fcntl.h>
  29 #include <gioerror.h>
  30 #ifdef G_OS_WIN32
  31 #include <windows.h>
  32 #include <io.h>
  33 #endif
  34 #include "gcancellable.h"
  35 #include "glibintl.h"
  36
  37 #include "gioalias.h"
  38
  39 /**
  40  * SECTION:gcancellable
  41  * @short_description: Thread-safe Operation Cancellation Stack
  42  * @include: gio/gio.h
  43  *
  44  * GCancellable is a thread-safe operation cancellation stack used
  45  * throughout GIO to allow for cancellation of synchronous and
  46  * asynchronous operations.
  47  */
  48
  49 enum {
  50   CANCELLED,
  51   LAST_SIGNAL
  52 };
  53
  54 struct _GCancellablePrivate
  55 {
  56   guint cancelled : 1;
  57   guint cancelled_running : 1;
  58   guint cancelled_running_waiting : 1;
  59
  60   guint fd_refcount;
  61   int cancel_pipe[2];
  62
  63 #ifdef G_OS_WIN32
  64   HANDLE event;
  65 #endif
  66 };
  67
  68 static guint signals[LAST_SIGNAL] = { 0 };
  69
  70 G_DEFINE_TYPE (GCancellable, g_cancellable, G_TYPE_OBJECT);
  71
  72 static GStaticPrivate current_cancellable = G_STATIC_PRIVATE_INIT;
  73 G_LOCK_DEFINE_STATIC(cancellable);
  74 static GCond *cancellable_cond = NULL;
  75
  76 static void
  77 g_cancellable_close_pipe (GCancellable *cancellable)
  78 {
  79   GCancellablePrivate *priv;
  80
  81   priv = cancellable->priv;
  82
  83   if (priv->cancel_pipe[0] != -1)
  84     {
  85       close (priv->cancel_pipe[0]);
  86       priv->cancel_pipe[0] = -1;
  87     }
  88
  89   if (priv->cancel_pipe[1] != -1)
  90     {
  91       close (priv->cancel_pipe[1]);
  92       priv->cancel_pipe[1] = -1;
  93     }
  94
  95 #ifdef G_OS_WIN32
  96   if (priv->event)
  97     {
  98       CloseHandle (priv->event);
  99       priv->event = NULL;
 100     }
 101 #endif
 102 }
 103
 104 static void
 105 g_cancellable_finalize (GObject *object)
 106 {
 107   GCancellable *cancellable = G_CANCELLABLE (object);
 108
 109   g_cancellable_close_pipe (cancellable);
 110
 111   G_OBJECT_CLASS (g_cancellable_parent_class)->finalize (object);
 112 }
 113
 114 static void
 115 g_cancellable_class_init (GCancellableClass *klass)
 116 {
 117   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 118
 119   g_type_class_add_private (klass, sizeof (GCancellablePrivate));
 120
 121   if (cancellable_cond == NULL && g_thread_supported ())
 122     cancellable_cond = g_cond_new ();
 123
 124   gobject_class->finalize = g_cancellable_finalize;
 125
 126   /**
 127    * GCancellable::cancelled:
 128    * @cancellable: a #GCancellable.
 129    *
 130    * Emitted when the operation has been cancelled.
 131    *
 132    * Can be used by implementations of cancellable operations. If the
 133    * operation is cancelled from another thread, the signal will be
 134    * emitted in the thread that cancelled the operation, not the
 135    * thread that is running the operation.
 136    *
 137    * Note that disconnecting from this signal (or any signal) in a
 138    * multi-threaded program is prone to race conditions. For instance
 139    * it is possible that a signal handler may be invoked even
 140    * <emphasis>after</emphasis> a call to
 141    * g_signal_handler_disconnect() for that handler has already
 142    * returned.
 143    *
 144    * There is also a problem when cancellation happen
 145    * right before connecting to the signal. If this happens the
 146    * signal will unexpectedly not be emitted, and checking before
 147    * connecting to the signal leaves a race condition where this is
 148    * still happening.
 149    *
 150    * In order to make it safe and easy to connect handlers there
 151    * are two helper functions: g_cancellable_connect() and
 152    * g_cancellable_disconnect() which protect against problems
 153    * like this.
 154    *
 155    * An example of how to us this:
 156    * |[
 157    *     /<!-- -->* Make sure we don't do any unnecessary work if already cancelled *<!-- -->/
 158    *     if (g_cancellable_set_error_if_cancelled (cancellable))
 159    *       return;
 160    *
 161    *     /<!-- -->* Set up all the data needed to be able to
 162    *      * handle cancellation of the operation *<!-- -->/
 163    *     my_data = my_data_new (...);
 164    *
 165    *     id = 0;
 166    *     if (cancellable)
 167    *       id = g_cancellable_connect (cancellable,
 168    *                                  G_CALLBACK (cancelled_handler)
 169    *                                  data, NULL);
 170    *
 171    *     /<!-- -->* cancellable operation here... *<!-- -->/
 172    *
 173    *     g_cancellable_disconnect (cancellable, id);
 174    *
 175    *     /<!-- -->* cancelled_handler is never called after this, it
 176    *      * is now safe to free the data *<!-- -->/
 177    *     my_data_free (my_data);
 178    * ]|
 179    *
 180    * Note that the cancelled signal is emitted in the thread that
 181    * the user cancelled from, which may be the main thread. So, the
 182    * cancellable signal should not do something that can block.
 183    */
 184   signals[CANCELLED] =
 185     g_signal_new (I_("cancelled"),
 186                   G_TYPE_FROM_CLASS (gobject_class),
 187                   G_SIGNAL_RUN_LAST,
 188                   G_STRUCT_OFFSET (GCancellableClass, cancelled),
 189                   NULL, NULL,
 190                   g_cclosure_marshal_VOID__VOID,
 191                   G_TYPE_NONE, 0);
 192
 193 }
 194
 195 #ifndef G_OS_WIN32
 196 static void
 197 set_fd_nonblocking (int fd)
 198 {
 199 #ifdef F_GETFL
 200   glong fcntl_flags;
 201   fcntl_flags = fcntl (fd, F_GETFL);
 202
 203 #ifdef O_NONBLOCK
 204   fcntl_flags |= O_NONBLOCK;
 205 #else
 206   fcntl_flags |= O_NDELAY;
 207 #endif
 208
 209   fcntl (fd, F_SETFL, fcntl_flags);
 210 #endif
 211 }
 212
 213 static void
 214 set_fd_close_exec (int fd)
 215 {
 216   int flags;
 217
 218   flags = fcntl (fd, F_GETFD, 0);
 219   if (flags != -1 && (flags & FD_CLOEXEC) == 0)
 220     {
 221       flags |= FD_CLOEXEC;
 222       fcntl (fd, F_SETFD, flags);
 223     }
 224 }
 225
 226
 227 static void
 228 g_cancellable_open_pipe (GCancellable *cancellable)
 229 {
 230   GCancellablePrivate *priv;
 231
 232   priv = cancellable->priv;
 233   if (pipe (priv->cancel_pipe) == 0)
 234     {
 235       /* Make them nonblocking, just to be sure we don't block
 236        * on errors and stuff
 237        */
 238       set_fd_nonblocking (priv->cancel_pipe[0]);
 239       set_fd_nonblocking (priv->cancel_pipe[1]);
 240       set_fd_close_exec (priv->cancel_pipe[0]);
 241       set_fd_close_exec (priv->cancel_pipe[1]);
 242
 243       if (priv->cancelled)
 244         {
 245           const char ch = 'x';
 246           gssize c;
 247
 248           do
 249             c = write (priv->cancel_pipe[1], &ch, 1);
 250           while (c == -1 && errno == EINTR);
 251         }
 252     }
 253 }
 254 #endif
 255
 256 static void
 257 g_cancellable_init (GCancellable *cancellable)
 258 {
 259   cancellable->priv = G_TYPE_INSTANCE_GET_PRIVATE (cancellable,
 260                                                    G_TYPE_CANCELLABLE,
 261                                                    GCancellablePrivate);
 262   cancellable->priv->cancel_pipe[0] = -1;
 263   cancellable->priv->cancel_pipe[1] = -1;
 264 }
 265
 266 /**
 267  * g_cancellable_new:
 268  *
 269  * Creates a new #GCancellable object.
 270  *
 271  * Applications that want to start one or more operations
 272  * that should be cancellable should create a #GCancellable
 273  * and pass it to the operations.
 274  *
 275  * One #GCancellable can be used in multiple consecutive
 276  * operations, but not in multiple concurrent operations.
 277  *
 278  * Returns: a #GCancellable.
 279  **/
 280 GCancellable *
 281 g_cancellable_new (void)
 282 {
 283   return g_object_new (G_TYPE_CANCELLABLE, NULL);
 284 }
 285
 286 /**
 287  * g_cancellable_push_current:
 288  * @cancellable: a #GCancellable object
 289  *
 290  * Pushes @cancellable onto the cancellable stack. The current
 291  * cancllable can then be recieved using g_cancellable_get_current().
 292  *
 293  * This is useful when implementing cancellable operations in
 294  * code that does not allow you to pass down the cancellable object.
 295  *
 296  * This is typically called automatically by e.g. #GFile operations,
 297  * so you rarely have to call this yourself.
 298  **/
 299 void
 300 g_cancellable_push_current (GCancellable *cancellable)
 301 {
 302   GSList *l;
 303
 304   g_return_if_fail (cancellable != NULL);
 305
 306   l = g_static_private_get (&current_cancellable);
 307   l = g_slist_prepend (l, cancellable);
 308   g_static_private_set (&current_cancellable, l, NULL);
 309 }
 310
 311 /**
 312  * g_cancellable_pop_current:
 313  * @cancellable: a #GCancellable object
 314  *
 315  * Pops @cancellable off the cancellable stack (verifying that @cancellable
 316  * is on the top of the stack).
 317  **/
 318 void
 319 g_cancellable_pop_current (GCancellable *cancellable)
 320 {
 321   GSList *l;
 322
 323   l = g_static_private_get (&current_cancellable);
 324
 325   g_return_if_fail (l != NULL);
 326   g_return_if_fail (l->data == cancellable);
 327
 328   l = g_slist_delete_link (l, l);
 329   g_static_private_set (&current_cancellable, l, NULL);
 330 }
 331
 332 /**
 333  * g_cancellable_get_current:
 334  *
 335  * Gets the top cancellable from the stack.
 336  *
 337  * Returns: a #GCancellable from the top of the stack, or %NULL
 338  * if the stack is empty.
 339  **/
 340 GCancellable *
 341 g_cancellable_get_current  (void)
 342 {
 343   GSList *l;
 344
 345   l = g_static_private_get (&current_cancellable);
 346   if (l == NULL)
 347     return NULL;
 348
 349   return G_CANCELLABLE (l->data);
 350 }
 351
 352 /**
 353  * g_cancellable_reset:
 354  * @cancellable: a #GCancellable object.
 355  *
 356  * Resets @cancellable to its uncancelled state.
 357  **/
 358 void
 359 g_cancellable_reset (GCancellable *cancellable)
 360 {
 361   GCancellablePrivate *priv;
 362
 363   g_return_if_fail (G_IS_CANCELLABLE (cancellable));
 364
 365   G_LOCK(cancellable);
 366
 367   priv = cancellable->priv;
 368
 369   while (priv->cancelled_running)
 370     {
 371       priv->cancelled_running_waiting = TRUE;
 372       g_cond_wait (cancellable_cond,
 373                    g_static_mutex_get_mutex (& G_LOCK_NAME (cancellable)));
 374     }
 375
 376   if (priv->cancelled)
 377     {
 378     /* Make sure we're not leaving old cancel state around */
 379
 380 #ifdef G_OS_WIN32
 381       if (priv->event)
 382         ResetEvent (priv->event);
 383 #endif
 384       if (priv->cancel_pipe[0] != -1)
 385         {
 386           gssize c;
 387           char ch;
 388
 389           do
 390             c = read (priv->cancel_pipe[0], &ch, 1);
 391           while (c == -1 && errno == EINTR);
 392         }
 393
 394       priv->cancelled = FALSE;
 395     }
 396   G_UNLOCK(cancellable);
 397 }
 398
 399 /**
 400  * g_cancellable_is_cancelled:
 401  * @cancellable: a #GCancellable or NULL.
 402  *
 403  * Checks if a cancellable job has been cancelled.
 404  *
 405  * Returns: %TRUE if @cancellable is cancelled,
 406  * FALSE if called with %NULL or if item is not cancelled.
 407  **/
 408 gboolean
 409 g_cancellable_is_cancelled (GCancellable *cancellable)
 410 {
 411   return cancellable != NULL && cancellable->priv->cancelled;
 412 }
 413
 414 /**
 415  * g_cancellable_set_error_if_cancelled:
 416  * @cancellable: a #GCancellable object.
 417  * @error: #GError to append error state to.
 418  *
 419  * If the @cancellable is cancelled, sets the error to notify
 420  * that the operation was cancelled.
 421  *
 422  * Returns: %TRUE if @cancellable was cancelled, %FALSE if it was not.
 423  **/
 424 gboolean
 425 g_cancellable_set_error_if_cancelled (GCancellable  *cancellable,
 426                                       GError       **error)
 427 {
 428   if (g_cancellable_is_cancelled (cancellable))
 429     {
 430       g_set_error_literal (error,
 431                            G_IO_ERROR,
 432                            G_IO_ERROR_CANCELLED,
 433                            _("Operation was cancelled"));
 434       return TRUE;
 435     }
 436
 437   return FALSE;
 438 }
 439
 440 /**
 441  * g_cancellable_get_fd:
 442  * @cancellable: a #GCancellable.
 443  *
 444  * Gets the file descriptor for a cancellable job. This can be used to
 445  * implement cancellable operations on Unix systems. The returned fd will
 446  * turn readable when @cancellable is cancelled.
 447  *
 448  * You are not supposed to read from the fd yourself, just check for
 449  * readable status. Reading to unset the readable status is done
 450  * with g_cancellable_reset().
 451  *
 452  * After a successful return from this function, you should use
 453  * g_cancellable_release_fd() to free up resources allocated for
 454  * the returned file descriptor.
 455  *
 456  * See also g_cancellable_make_pollfd().
 457  *
 458  * Returns: A valid file descriptor. %-1 if the file descriptor
 459  * is not supported, or on errors.
 460  **/
 461 int
 462 g_cancellable_get_fd (GCancellable *cancellable)
 463 {
 464   GCancellablePrivate *priv;
 465   int fd;
 466
 467   if (cancellable == NULL)
 468     return -1;
 469
 470   priv = cancellable->priv;
 471
 472 #ifdef G_OS_WIN32
 473   return -1;
 474 #else
 475   G_LOCK(cancellable);
 476   if (priv->cancel_pipe[0] == -1)
 477     g_cancellable_open_pipe (cancellable);
 478   fd = priv->cancel_pipe[0];
 479   if (fd != -1)
 480     priv->fd_refcount++;
 481   G_UNLOCK(cancellable);
 482 #endif
 483
 484   return fd;
 485 }
 486
 487 /**
 488  * g_cancellable_make_pollfd:
 489  * @cancellable: a #GCancellable or %NULL
 490  * @pollfd: a pointer to a #GPollFD
 491  *
 492  * Creates a #GPollFD corresponding to @cancellable; this can be passed
 493  * to g_poll() and used to poll for cancellation. This is useful both
 494  * for unix systems without a native poll and for portability to
 495  * windows.
 496  *
 497  * When this function returns %TRUE, you should use
 498  * g_cancellable_release_fd() to free up resources allocated for the
 499  * @pollfd. After a %FALSE return, do not call g_cancellable_release_fd().
 500  *
 501  * If this function returns %FALSE, either no @cancellable was given or
 502  * resource limits prevent this function from allocating the necessary
 503  * structures for polling. (On Linux, you will likely have reached
 504  * the maximum number of file descriptors.) The suggested way to handle
 505  * these cases is to ignore the @cancellable.
 506  *
 507  * You are not supposed to read from the fd yourself, just check for
 508  * readable status. Reading to unset the readable status is done
 509  * with g_cancellable_reset().
 510  *
 511  * Returns: %TRUE if @pollfd was successfully initialized, %FALSE on
 512  *          failure to prepare the cancellable.
 513  *
 514  * Since: 2.22
 515  **/
 516 gboolean
 517 g_cancellable_make_pollfd (GCancellable *cancellable, GPollFD *pollfd)
 518 {
 519   g_return_val_if_fail (pollfd != NULL, FALSE);
 520   if (cancellable == NULL)
 521     return FALSE;
 522   g_return_val_if_fail (G_IS_CANCELLABLE (cancellable), FALSE);
 523
 524   {
 525 #ifdef G_OS_WIN32
 526     GCancellablePrivate *priv;
 527
 528     priv = cancellable->priv;
 529     G_LOCK(cancellable);
 530     if (priv->event == NULL)
 531       {
 532         /* A manual reset anonymous event, starting unset */
 533         priv->event = CreateEvent (NULL, TRUE, FALSE, NULL);
 534         if (priv->event == NULL)
 535           {
 536             G_UNLOCK(cancellable);
 537             return FALSE;
 538           }
 539         if (priv->cancelled)
 540           SetEvent(priv->event);
 541       }
 542     priv->fd_refcount++;
 543     G_UNLOCK(cancellable);
 544
 545     pollfd->fd = (gintptr)priv->event;
 546 #else /* !G_OS_WIN32 */
 547     int fd = g_cancellable_get_fd (cancellable);
 548
 549     if (fd == -1)
 550       return FALSE;
 551     pollfd->fd = fd;
 552 #endif /* G_OS_WIN32 */
 553   }
 554
 555   pollfd->events = G_IO_IN;
 556   pollfd->revents = 0;
 557
 558   return TRUE;
 559 }
 560
 561 /**
 562  * g_cancellable_release_fd:
 563  * @cancellable: a #GCancellable
 564  *
 565  * Releases a resources previously allocated by g_cancellable_get_fd()
 566  * or g_cancellable_make_pollfd().
 567  *
 568  * For compatibility reasons with older releases, calling this function
 569  * is not strictly required, the resources will be automatically freed
 570  * when the @cancellable is finalized. However, the @cancellable will
 571  * block scarce file descriptors until it is finalized if this function
 572  * is not called. This can cause the application to run out of file
 573  * descriptors when many #GCancellables are used at the same time.
 574  *
 575  * Since: 2.22
 576  **/
 577 void
 578 g_cancellable_release_fd (GCancellable *cancellable)
 579 {
 580   GCancellablePrivate *priv;
 581
 582   g_return_if_fail (G_IS_CANCELLABLE (cancellable));
 583   g_return_if_fail (cancellable->priv->fd_refcount > 0);
 584
 585   priv = cancellable->priv;
 586
 587   G_LOCK (cancellable);
 588   priv->fd_refcount--;
 589   if (priv->fd_refcount == 0)
 590     g_cancellable_close_pipe (cancellable);
 591   G_UNLOCK (cancellable);
 592 }
 593
 594 /**
 595  * g_cancellable_cancel:
 596  * @cancellable: a #GCancellable object.
 597  *
 598  * Will set @cancellable to cancelled, and will emit the
 599  * #GCancellable::cancelled signal. (However, see the warning about
 600  * race conditions in the documentation for that signal if you are
 601  * planning to connect to it.)
 602  *
 603  * This function is thread-safe. In other words, you can safely call
 604  * it from a thread other than the one running the operation that was
 605  * passed the @cancellable.
 606  *
 607  * The convention within gio is that cancelling an asynchronous
 608  * operation causes it to complete asynchronously. That is, if you
 609  * cancel the operation from the same thread in which it is running,
 610  * then the operation's #GAsyncReadyCallback will not be invoked until
 611  * the application returns to the main loop.
 612  **/
 613 void
 614 g_cancellable_cancel (GCancellable *cancellable)
 615 {
 616   gboolean cancel;
 617   GCancellablePrivate *priv;
 618
 619   if (cancellable == NULL ||
 620       cancellable->priv->cancelled)
 621     return;
 622
 623   priv = cancellable->priv;
 624   cancel = FALSE;
 625
 626   G_LOCK(cancellable);
 627   cancel = TRUE;
 628   priv->cancelled = TRUE;
 629   priv->cancelled_running = TRUE;
 630 #ifdef G_OS_WIN32
 631   if (priv->event)
 632     SetEvent (priv->event);
 633 #endif
 634   if (priv->cancel_pipe[1] != -1)
 635     {
 636       const char ch = 'x';
 637       gssize c;
 638
 639       do
 640         c = write (priv->cancel_pipe[1], &ch, 1);
 641       while (c == -1 && errno == EINTR);
 642     }
 643   G_UNLOCK(cancellable);
 644
 645   if (cancel)
 646     {
 647       g_object_ref (cancellable);
 648       g_signal_emit (cancellable, signals[CANCELLED], 0);
 649
 650       G_LOCK(cancellable);
 651
 652       priv->cancelled_running = FALSE;
 653       if (priv->cancelled_running_waiting)
 654         g_cond_broadcast (cancellable_cond);
 655       priv->cancelled_running_waiting = FALSE;
 656
 657       G_UNLOCK(cancellable);
 658
 659       g_object_unref (cancellable);
 660     }
 661 }
 662
 663 /**
 664  * g_cancellable_connect:
 665  * @cancellable: A #GCancellable.
 666  * @callback: The #GCallback to connect.
 667  * @data: Data to pass to @callback.
 668  * @data_destroy_func: Free function for @data or %NULL.
 669  *
 670  * Convenience function to connect to the #GCancellable::cancelled
 671  * signal. Also handles the race condition that may happen
 672  * if the cancellable is cancelled right before connecting.
 673  *
 674  * @callback is called at most once, either directly at the
 675  * time of the connect if @cancellable is already cancelled,
 676  * or when @cancellable is cancelled in some thread.
 677  *
 678  * @data_destroy_func will be called when the handler is
 679  * disconnected, or immediately if the cancellable is already
 680  * cancelled.
 681  *
 682  * See #GCancellable::cancelled for details on how to use this.
 683  *
 684  * Returns: The id of the signal handler or 0 if @cancellable has already
 685  *          been cancelled.
 686  *
 687  * Since: 2.22
 688  */
 689 gulong
 690 g_cancellable_connect (GCancellable   *cancellable,
 691                        GCallback       callback,
 692                        gpointer        data,
 693                        GDestroyNotify  data_destroy_func)
 694 {
 695   gulong id;
 696
 697   g_return_val_if_fail (G_IS_CANCELLABLE (cancellable), 0);
 698
 699   G_LOCK (cancellable);
 700
 701   if (cancellable->priv->cancelled)
 702     {
 703       void (*_callback) (GCancellable *cancellable,
 704                          gpointer      user_data);
 705
 706       _callback = (void *)callback;
 707       id = 0;
 708
 709       _callback (cancellable, data);
 710
 711       if (data_destroy_func)
 712         data_destroy_func (data);
 713     }
 714   else
 715     {
 716       id = g_signal_connect_data (cancellable, "cancelled",
 717                                   callback, data,
 718                                   (GClosureNotify) data_destroy_func,
 719                                   0);
 720     }
 721   G_UNLOCK (cancellable);
 722
 723   return id;
 724 }
 725
 726 /**
 727  * g_cancellable_disconnect:
 728  * @cancellable: A #GCancellable or %NULL.
 729  * @handler_id: Handler id of the handler to be disconnected, or %0.
 730  *
 731  * Disconnects a handler from a cancellable instance similar to
 732  * g_signal_handler_disconnect().  Additionally, in the event that a
 733  * signal handler is currently running, this call will block until the
 734  * handler has finished.  Calling this function from a
 735  * #GCancellable::cancelled signal handler will therefore result in a
 736  * deadlock.
 737  *
 738  * This avoids a race condition where a thread cancels at the
 739  * same time as the cancellable operation is finished and the
 740  * signal handler is removed. See #GCancellable::cancelled for
 741  * details on how to use this.
 742  *
 743  * If @cancellable is %NULL or @handler_id is %0 this function does
 744  * nothing.
 745  *
 746  * Since: 2.22
 747  */
 748 void
 749 g_cancellable_disconnect (GCancellable  *cancellable,
 750                           gulong         handler_id)
 751 {
 752   GCancellablePrivate *priv;
 753
 754   if (handler_id == 0 ||  cancellable == NULL)
 755     return;
 756
 757   G_LOCK (cancellable);
 758
 759   priv = cancellable->priv;
 760
 761   while (priv->cancelled_running)
 762     {
 763       priv->cancelled_running_waiting = TRUE;
 764       g_cond_wait (cancellable_cond,
 765                    g_static_mutex_get_mutex (& G_LOCK_NAME (cancellable)));
 766     }
 767
 768   g_signal_handler_disconnect (cancellable, handler_id);
 769   G_UNLOCK (cancellable);
 770 }
 771
 772 #define __G_CANCELLABLE_C__
 773 #include "gioaliasdef.c"