Attachment 48847 Details for Bug 114710

[patch] gnome-vfs2-94400-cancelation-rewrite-suse10.diff

gnome-vfs2-94400-cancelation-rewrite-suse10.diff (text/plain), 87.94 KB, created by Federico Mena Quintero on 2005-09-05 18:28:48 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Federico Mena Quintero

Created: 2005-09-05 18:28:48 UTC

Size: 87.94 KB

patch

obsolete

>Index: libgnomevfs/gnome-vfs-async-job-map.c
>===================================================================
>RCS file: /cvs/gnome/gnome-vfs/libgnomevfs/gnome-vfs-async-job-map.c,v
>retrieving revision 1.13
>diff -u -p -r1.13 gnome-vfs-async-job-map.c
>--- libgnomevfs/gnome-vfs-async-job-map.c	17 Sep 2003 09:11:04 -0000	1.13
>+++ libgnomevfs/gnome-vfs-async-job-map.c	10 Aug 2005 16:36:43 -0000
>@@ -21,6 +21,9 @@
>    Author: Pavel Cisler <pavel@eazel.com> */
> 
> #include <config.h>
>+#include <string.h>
>+#include <sys/time.h>
>+#include <glib/gprintf.h>
> #include "gnome-vfs-async-job-map.h"
> 
> #include "gnome-vfs-job.h"
>@@ -34,12 +37,29 @@ static int async_job_map_locked = 0;
> static gboolean async_job_map_shutting_down;
> static GHashTable *async_job_map;
> 
>-/* callback map bits guarded by this lock */
>-static GStaticMutex async_job_callback_map_lock = G_STATIC_MUTEX_INIT;
>-static GHashTable *async_job_callback_map;
>-static guint async_job_callback_map_next_id;
>+static void
>+fmq_log (const char *str, ...)
>+{
>+#if 0
>+	va_list args;
>+	GThread *thread;
>+	struct timeval tv;
>+	double sec;
>+
>+	va_start (args, str);
>+
>+	thread = g_thread_self ();
> 
>-void async_job_callback_map_destroy (void);
>+	gettimeofday (&tv, NULL);
>+	sec = tv.tv_sec + ((double) tv.tv_usec / 1e6);
>+
>+	g_fprintf (stderr, "Thread %p time %.16g: ", thread, sec);
>+	g_vfprintf (stderr, str, args);
>+	g_fprintf (stderr, "\n");
>+
>+	va_end (args);
>+#endif
>+}
> 
> void 
> _gnome_vfs_async_job_map_init (void)
>@@ -92,6 +112,9 @@ _gnome_vfs_async_job_map_remove_job (Gno
> 	g_assert (async_job_map);
> 
> 	g_hash_table_remove (async_job_map, job->job_handle);
>+	fmq_log ("_gnome_vfs_async_job_map_remove_job(): REMOVING job %p with handle %p from async_job_map",
>+		 job,
>+		 job->job_handle);
> 	
> 	_gnome_vfs_async_job_map_unlock ();
> }
>@@ -108,7 +131,7 @@ gnome_vfs_async_job_map_destroy (void)
> 	async_job_map = NULL;
> }
> 
>-gboolean 
>+void
> _gnome_vfs_async_job_completed (GnomeVFSAsyncHandle *handle)
> {
> 	GnomeVFSJob *job;
>@@ -123,6 +146,9 @@ _gnome_vfs_async_job_completed (GnomeVFS
> 	job = _gnome_vfs_async_job_map_get_job (handle);
> 	if (job != NULL) {
> 		g_hash_table_remove (async_job_map, handle);
>+		fmq_log ("_gnome_vfs_async_job_completed(): REMOVING job %p with handle %p from async_job_map",
>+			 job,
>+			 handle);
> 	}
> 	
> 	if (async_job_map_shutting_down && g_hash_table_size (async_job_map) == 0) {
>@@ -131,8 +157,6 @@ _gnome_vfs_async_job_completed (GnomeVFS
> 	}
> 	
> 	_gnome_vfs_async_job_map_unlock ();
>-	
>-	return job != NULL;
> }
> 
> void
>@@ -155,8 +179,6 @@ _gnome_vfs_async_job_map_shutdown (void)
> 
> 	/* The last expiring job will delete the hash table. */
> 	_gnome_vfs_async_job_map_unlock ();
>-	
>-	async_job_callback_map_destroy ();
> }
> 
> void 
>@@ -179,122 +201,32 @@ _gnome_vfs_async_job_map_assert_locked (
> 	g_assert (async_job_map_locked);
> }
> 
>-void 
>-_gnome_vfs_async_job_callback_valid (guint     callback_id,
>-				    gboolean *valid,
>-				    gboolean *cancelled)
>-{
>-	GnomeVFSNotifyResult *notify_result;
>-	
>-	g_static_mutex_lock (&async_job_callback_map_lock);
>-	
>-	if (async_job_callback_map == NULL) {
>-		g_assert (async_job_map_shutting_down);
>-		*valid = FALSE;
>-		*cancelled = FALSE;
>-	}
>-
>-	notify_result = (GnomeVFSNotifyResult *) g_hash_table_lookup
>-		(async_job_callback_map, GUINT_TO_POINTER (callback_id));
>-	
>-	*valid = notify_result != NULL;
>-	*cancelled = notify_result != NULL && notify_result->cancelled;
>-
>-	g_static_mutex_unlock (&async_job_callback_map_lock);
>-}
>-
>-gboolean 
>-_gnome_vfs_async_job_add_callback (GnomeVFSJob *job, GnomeVFSNotifyResult *notify_result)
>+void
>+_gnome_vfs_async_job_cancel_job (GnomeVFSJob *job)
> {
>-	gboolean cancelled;
>-
>-	g_static_mutex_lock (&async_job_callback_map_lock);
>-
>-	g_assert (!async_job_map_shutting_down);
>-	
>-	/* Assign a unique id to each job callback. Use unique IDs instead of the
>-	 * notify_results pointers to avoid aliasing problems.
>-	 */
>-	notify_result->callback_id = ++async_job_callback_map_next_id;
>-
>-	JOB_DEBUG (("adding callback %d ", notify_result->callback_id));
>-
>-	if (async_job_callback_map == NULL) {
>-		/* First job, allocate a new hash table. */
>-		async_job_callback_map = g_hash_table_new (NULL, NULL);
>-	}
>+	GnomeVFSOp *op;
>+	GnomeVFSAsyncHandle *job_handle;
> 
>-	/* we are using async_job_callback_map_lock to ensure atomicity of
>-	 * checking/clearing job->cancelled and adding/cancelling callbacks
>-	 */
>-	cancelled = job->cancelled;
>-	
>-	if (!cancelled) {
>-		g_hash_table_insert (async_job_callback_map, GUINT_TO_POINTER (notify_result->callback_id),
>-			notify_result);
>-	}
>-	g_static_mutex_unlock (&async_job_callback_map_lock);
>-	
>-	return !cancelled;
>-}
>+	g_assert (job != NULL);
> 
>-void 
>-_gnome_vfs_async_job_remove_callback (guint callback_id)
>-{
>-	g_assert (async_job_callback_map != NULL);
>+	g_mutex_lock (job->job_lock);
> 
>-	JOB_DEBUG (("removing callback %d ", callback_id));
>-	g_static_mutex_lock (&async_job_callback_map_lock);
>+	job_handle = job->job_handle;
> 
>-	g_hash_table_remove (async_job_callback_map, GUINT_TO_POINTER (callback_id));
>+	/* Move the current op to the list of pending canceled ops */
> 
>-	g_static_mutex_unlock (&async_job_callback_map_lock);
>-}
>+	g_assert (job->op != NULL);
>+	op = job->op;
>+	op->canceled = TRUE;
> 
>-static void
>-callback_map_cancel_one (gpointer key, gpointer value, gpointer user_data)
>-{
>-	GnomeVFSNotifyResult *notify_result;
>-	
>-	notify_result = (GnomeVFSNotifyResult *) value;
>-	
>-	if (notify_result->job_handle == (GnomeVFSAsyncHandle *)user_data) {
>-		JOB_DEBUG (("cancelling callback %u - job %u cancelled",
>-			    GPOINTER_TO_UINT (key),
>-			    GPOINTER_TO_UINT (user_data)));
>-		notify_result->cancelled = TRUE;
>-	}
>-}
>+	job->op = NULL;
>+	job->canceled_ops = g_slist_append (job->canceled_ops, op);
> 
>-void
>-_gnome_vfs_async_job_cancel_job_and_callbacks (GnomeVFSAsyncHandle *job_handle, GnomeVFSJob *job)
>-{
>-	g_static_mutex_lock (&async_job_callback_map_lock);
>+	fmq_log ("MAIN: _gnome_vfs_async_job_cancel_job_and_callbacks(): job_handle %p, job %p, op %p, and set its job->op->canceled to TRUE",
>+		 job->job_handle,
>+		 job,
>+		 op,
>+		 "and set its job->op->canceled to TRUE");
> 	
>-	if (job != NULL) {
>-		job->cancelled = TRUE;
>-	}
>-	
>-	if (async_job_callback_map == NULL) {
>-		JOB_DEBUG (("job %u, no callbacks scheduled yet",
>-			    GPOINTER_TO_UINT (job_handle)));
>-	} else {
>-		g_hash_table_foreach (async_job_callback_map,
>-				      callback_map_cancel_one, job_handle);
>-	}
>-
>-	g_static_mutex_unlock (&async_job_callback_map_lock);
>-}
>-
>-void
>-async_job_callback_map_destroy (void)
>-{
>-	g_static_mutex_lock (&async_job_callback_map_lock);
>-
>-	if (async_job_callback_map) {
>-		g_hash_table_destroy (async_job_callback_map);
>-		async_job_callback_map = NULL;
>-	}
>-
>-	g_static_mutex_unlock (&async_job_callback_map_lock);
>+	g_mutex_unlock (job->job_lock);
> }
>Index: libgnomevfs/gnome-vfs-async-job-map.h
>===================================================================
>RCS file: /cvs/gnome/gnome-vfs/libgnomevfs/gnome-vfs-async-job-map.h,v
>retrieving revision 1.6
>diff -u -p -r1.6 gnome-vfs-async-job-map.h
>--- libgnomevfs/gnome-vfs-async-job-map.h	19 Dec 2002 17:57:19 -0000	1.6
>+++ libgnomevfs/gnome-vfs-async-job-map.h	10 Aug 2005 16:36:43 -0000
>@@ -32,23 +32,16 @@
> /* async job map calls */
> void		 _gnome_vfs_async_job_map_init		  	(void);
> void	     	 _gnome_vfs_async_job_map_shutdown	  	(void);
>-gboolean     	 _gnome_vfs_async_job_completed 	  	  	(GnomeVFSAsyncHandle		*handle);
>+void     	 _gnome_vfs_async_job_completed			(GnomeVFSAsyncHandle		*handle);
> void 		 _gnome_vfs_async_job_map_add_job  	  	(GnomeVFSJob			*job);
> void 		 _gnome_vfs_async_job_map_remove_job  	  	(GnomeVFSJob			*job);
> GnomeVFSJob	*_gnome_vfs_async_job_map_get_job	  	(const GnomeVFSAsyncHandle	*handle);
> 
> void		 _gnome_vfs_async_job_map_assert_locked	  	(void);
> void		 _gnome_vfs_async_job_map_lock	  	  	(void);
>-void		 _gnome_vfs_async_job_map_unlock	  	  	(void);
>+void		 _gnome_vfs_async_job_map_unlock		(void);
> 
> /* async job callback map calls */
>-void		 _gnome_vfs_async_job_callback_valid		(guint				 callback_id,
>-								 gboolean			*valid,
>-								 gboolean			*cancelled);
>-gboolean	 _gnome_vfs_async_job_add_callback		(GnomeVFSJob			*job,
>-							  	 GnomeVFSNotifyResult		*notify_result);
>-void		 _gnome_vfs_async_job_remove_callback		(guint			 	 callback_id);
>-void		 _gnome_vfs_async_job_cancel_job_and_callbacks	(GnomeVFSAsyncHandle		*job_handle,
>-								 GnomeVFSJob 			*job);
>+void		 _gnome_vfs_async_job_cancel_job		(GnomeVFSJob 			*job);
> 
> #endif
>Index: libgnomevfs/gnome-vfs-async-ops.c
>===================================================================
>RCS file: /cvs/gnome/gnome-vfs/libgnomevfs/gnome-vfs-async-ops.c,v
>retrieving revision 1.15
>diff -u -p -r1.15 gnome-vfs-async-ops.c
>--- libgnomevfs/gnome-vfs-async-ops.c	6 May 2005 12:59:36 -0000	1.15
>+++ libgnomevfs/gnome-vfs-async-ops.c	10 Aug 2005 16:36:44 -0000
>@@ -22,6 +22,9 @@
>    Author: Ettore Perazzoli <ettore@comm2000.it> */
> 
> #include <config.h>
>+#include <string.h>
>+#include <sys/time.h>
>+#include <glib/gprintf.h>
> 
> #include "gnome-vfs-async-ops.h"
> #include "gnome-vfs-async-job-map.h"
>@@ -32,6 +35,30 @@
> #include <glib/gstrfuncs.h>
> #include <unistd.h>
> 
>+static void
>+fmq_log (const char *str, ...)
>+{
>+#if 0
>+	va_list args;
>+	GThread *thread;
>+	struct timeval tv;
>+	double sec;
>+
>+	va_start (args, str);
>+
>+	thread = g_thread_self ();
>+
>+	gettimeofday (&tv, NULL);
>+	sec = tv.tv_sec + ((double) tv.tv_usec / 1e6);
>+
>+	g_fprintf (stderr, "Thread %p time %.16g: ", thread, sec);
>+	g_vfprintf (stderr, str, args);
>+	g_fprintf (stderr, "\n");
>+
>+	va_end (args);
>+#endif
>+}
>+
> /**
>  * gnome_vfs_async_cancel:
>  * @handle: handle of the async operation to be cancelled
>@@ -69,16 +96,24 @@ gnome_vfs_async_cancel (GnomeVFSAsyncHan
> 	_gnome_vfs_async_job_map_lock ();
> 
> 	job = _gnome_vfs_async_job_map_get_job (handle);
>-	if (job == NULL) {
>-		JOB_DEBUG (("job %u - job no longer exists", GPOINTER_TO_UINT (handle)));
>-		/* have to cancel the callbacks because they still can be pending */
>-		_gnome_vfs_async_job_cancel_job_and_callbacks (handle, NULL);
>-	} else {
>+
>+	fmq_log ("MAIN: gnome_vfs_async_cancel() for vfs_handle %p, corresponding job %p",
>+		 handle,
>+		 job);
>+
>+	if (job == NULL)
>+		g_warning ("The job for handle %p no longer exists", handle);
>+	else {
>+		g_mutex_lock (job->job_lock);
>+		if (job->op == NULL)
>+			g_error ("The job for handle %p is not running; cannot cancel it", handle);
>+		g_mutex_unlock (job->job_lock);
>+
> 		/* Cancel the job in progress. OK to do outside of job->job_lock,
> 		 * job lifetime is protected by _gnome_vfs_async_job_map_lock.
> 		 */
> 		_gnome_vfs_job_module_cancel (job);
>-		_gnome_vfs_async_job_cancel_job_and_callbacks (handle, job);
>+		_gnome_vfs_async_job_cancel_job (job);
> 	}
> 
> 	_gnome_vfs_async_job_map_unlock ();
>@@ -529,33 +564,18 @@ gnome_vfs_async_close (GnomeVFSAsyncHand
> 	g_return_if_fail (handle != NULL);
> 	g_return_if_fail (callback != NULL);
> 
>-	for (;;) {
>-		_gnome_vfs_async_job_map_lock ();
>-		job = _gnome_vfs_async_job_map_get_job (handle);
>-		if (job == NULL) {
>-			g_warning ("trying to read a non-existing handle");
>-			_gnome_vfs_async_job_map_unlock ();
>-			return;
>-		}
>-
>-		if (job->op->type != GNOME_VFS_OP_READ &&
>-		    job->op->type != GNOME_VFS_OP_WRITE) {
>-			_gnome_vfs_job_set (job, GNOME_VFS_OP_CLOSE,
>-					   (GFunc) callback, callback_data);
>-			_gnome_vfs_job_go (job);
>-			_gnome_vfs_async_job_map_unlock ();
>-			return;
>-		}
>-		/* Still reading, wait a bit, cancel should be pending.
>-		 * This mostly handles a race condition that can happen
>-		 * on a dual CPU machine where a cancel stops a read before
>-		 * the read thread picks up and a close then gets scheduled
>-		 * on a new thread. Without this the job op type would be
>-		 * close for both threads and two closes would get executed
>-		 */
>+	_gnome_vfs_async_job_map_lock ();
>+	job = _gnome_vfs_async_job_map_get_job (handle);
>+	if (job == NULL) {
>+		g_warning ("trying to close a non-existing handle");
> 		_gnome_vfs_async_job_map_unlock ();
>-		g_usleep (100);
>+		return;
> 	}
>+
>+	_gnome_vfs_job_set (job, GNOME_VFS_OP_CLOSE,
>+			    (GFunc) callback, callback_data);
>+	_gnome_vfs_job_go (job);
>+	_gnome_vfs_async_job_map_unlock ();
> }
> 
> /**
>@@ -1199,60 +1219,3 @@ gnome_vfs_async_file_control (GnomeVFSAs
> 	_gnome_vfs_job_go (job);
> 	_gnome_vfs_async_job_map_unlock ();
> }
>-
>-#ifdef OLD_CONTEXT_DEPRECATED
>-
>-guint
>-gnome_vfs_async_add_status_callback (GnomeVFSAsyncHandle *handle,
>-				     GnomeVFSStatusCallback callback,
>-				     gpointer user_data)
>-{
>-	GnomeVFSJob *job;
>-	guint result;
>-	
>-	g_return_val_if_fail (handle != NULL, 0);
>-	g_return_val_if_fail (callback != NULL, 0);
>-
>-	_gnome_vfs_async_job_map_lock ();
>-	job = _gnome_vfs_async_job_map_get_job (handle);
>-
>-	if (job->op != NULL || job->op->context != NULL) {
>-		g_warning ("job or context not found");
>-		_gnome_vfs_async_job_map_unlock ();
>-		return 0;
>-	}
>-
>-	result = gnome_vfs_message_callbacks_add
>-		(gnome_vfs_context_get_message_callbacks (job->op->context),
>-		 callback, user_data);
>-	_gnome_vfs_async_job_map_unlock ();
>-	
>-	return result;
>-}
>-
>-void
>-gnome_vfs_async_remove_status_callback (GnomeVFSAsyncHandle *handle,
>-					guint callback_id)
>-{
>-	GnomeVFSJob *job;
>-
>-	g_return_if_fail (handle != NULL);
>-	g_return_if_fail (callback_id > 0);
>-
>-	_gnome_vfs_async_job_map_lock ();
>-	job = _gnome_vfs_async_job_map_get_job (handle);
>-
>-	if (job->op != NULL || job->op->context != NULL) {
>-		g_warning ("job or context not found");
>-		_gnome_vfs_async_job_map_unlock ();
>-		return;
>-	}
>-
>-	gnome_vfs_message_callbacks_remove
>-		(gnome_vfs_context_get_message_callbacks (job->op->context),
>-		 callback_id);
>-
>-	_gnome_vfs_async_job_map_unlock ();
>-}
>-
>-#endif /* OLD_CONTEXT_DEPRECATED */
>Index: libgnomevfs/gnome-vfs-job-queue.c
>===================================================================
>RCS file: /cvs/gnome/gnome-vfs/libgnomevfs/gnome-vfs-job-queue.c,v
>retrieving revision 1.7
>diff -u -p -r1.7 gnome-vfs-job-queue.c
>--- libgnomevfs/gnome-vfs-job-queue.c	19 Dec 2002 17:57:19 -0000	1.7
>+++ libgnomevfs/gnome-vfs-job-queue.c	10 Aug 2005 16:36:44 -0000
>@@ -22,6 +22,8 @@
>    Author: László Péter <laca@ireland.sun.com> */
> 
> #include <config.h>
>+#include <sys/time.h>
>+#include <glib/gprintf.h>
> #include "gnome-vfs-job-queue.h"
> #include "gnome-vfs-job-slave.h"
> #include <libgnomevfs/gnome-vfs-job-limit.h>
>@@ -77,8 +79,32 @@ typedef struct JobQueueKey {
> 	int priority;
> } JobQueueKey;
> 
>+static void
>+fmq_log (const char *str, ...)
>+{
>+#if 0
>+	va_list args;
>+	GThread *thread;
>+	struct timeval tv;
>+	double sec;
>+
>+	va_start (args, str);
>+
>+	thread = g_thread_self ();
>+
>+	gettimeofday (&tv, NULL);
>+	sec = tv.tv_sec + ((double) tv.tv_usec / 1e6);
>+
>+	g_fprintf (stderr, "Thread %p time %.16g: ", thread, sec);
>+	g_vfprintf (stderr, str, args);
>+	g_fprintf (stderr, "\n");
>+
>+	va_end (args);
>+#endif
>+}
>+
> static int
>-key_compare (gconstpointer cast_to_key1, gconstpointer cast_to_key2, gpointer user_data)
>+key_compare (gconstpointer cast_to_key1, gconstpointer cast_to_key2)
> {
> 	JobQueueKey *key1 = (JobQueueKey *)cast_to_key1;
> 	JobQueueKey *key2 = (JobQueueKey *)cast_to_key2;
>@@ -100,16 +126,10 @@ key_compare (gconstpointer cast_to_key1,
> 	return key1->job_id - key2->job_id;
> }
> 
>-static void
>-value_destroy (gpointer cast_to_job)
>-{
>-	_gnome_vfs_job_destroy ((GnomeVFSJob *)cast_to_job);
>-}
>-
> static JobQueueType *
> job_queue_new (void)
> {
>-	return g_tree_new_full (key_compare, NULL, g_free, value_destroy);
>+	return g_tree_new (key_compare);
> }
> 
> static void
>@@ -120,13 +140,13 @@ job_queue_destroy (void)
> }
> 
> static void
>-job_queue_add (GnomeVFSJob *job)
>+job_queue_add (GnomeVFSOp *op, int priority)
> {
> 	JobQueueKey *key = g_new (JobQueueKey, 1);
> 	key->job_id = ++job_id;
>-	key->priority = job->priority;
>+	key->priority = priority;
> 
>-	g_tree_insert (job_queue, key, job);
>+	g_tree_insert (job_queue, key, op);
> #ifdef QUEUE_DEBUG
> 	job_queue_length++;
> #endif
>@@ -135,20 +155,20 @@ job_queue_add (GnomeVFSJob *job)
> static int
> find_first_value (gpointer key, gpointer value, gpointer data)
> {
>-	*((GnomeVFSJob **)data) = value;
>+	*((GnomeVFSOp **)data) = value;
> 	return TRUE;
> }
> 
>-static GnomeVFSJob *
>+static GnomeVFSOp *
> job_queue_get_first (void)
> {
>-	GnomeVFSJob *job = NULL;
>+	GnomeVFSOp *op = NULL;
> 
> 	if (job_queue) {
>-		g_tree_foreach (job_queue, find_first_value, &job);
>+		g_tree_foreach (job_queue, find_first_value, &op);
> 	}
> 
>-	return job;
>+	return op;
> }
> 
> static int
>@@ -262,7 +282,7 @@ job_can_start (int priority)
> void
> _gnome_vfs_job_queue_run (void)
> {
>-	GnomeVFSJob *job_to_run;
>+	GnomeVFSOp *op_to_run;
> 
> 	g_static_mutex_lock (&job_queue_lock);
> 
>@@ -271,10 +291,13 @@ _gnome_vfs_job_queue_run (void)
> 		 running_job_count,
> 		 job_queue_length));
> 
>-	job_to_run = job_queue_get_first ();
>-	if (job_to_run != NULL) {
>-		/* The queue is not empty */
>-		if (job_can_start (job_to_run->priority)) {
>+	op_to_run = job_queue_get_first ();
>+	if (op_to_run != NULL) {
>+		int priority;
>+
>+		priority = op_to_run->job->priority;
>+
>+		if (job_can_start (priority)) {
> 			running_job_count++;
> 			job_queue_delete_first ();
> 			Q_DEBUG (("taking a %2d priority job from the queue;"
>@@ -283,7 +306,7 @@ _gnome_vfs_job_queue_run (void)
> 				 running_job_count,
> 				 job_queue_length));
> 			g_static_mutex_unlock (&job_queue_lock);
>-			_gnome_vfs_job_create_slave (job_to_run);
>+			_gnome_vfs_job_create_slave (op_to_run);
> 		} else {
> 			g_static_mutex_unlock (&job_queue_lock);
> 			Q_DEBUG (("waiting job is too low priority (%2d) to start;"
>@@ -301,23 +324,37 @@ _gnome_vfs_job_queue_run (void)
> gboolean
> _gnome_vfs_job_schedule (GnomeVFSJob *job)
> {
>+	GnomeVFSOp *op;
>+	int priority;
>+
> 	g_static_mutex_lock (&job_queue_lock);
>-      	if (!job_can_start (job->priority)) {
>-	  	job_queue_add (job);
>+
>+	g_mutex_lock (job->job_lock);
>+	g_assert (job->op != NULL);
>+	op = job->op;
>+	priority = job->priority;
>+	g_mutex_unlock (job->job_lock);
>+
>+      	if (!job_can_start (priority)) {
>+		fmq_log ("_gnome_vfs_job_schedule(): job %p cannot start yet; calling job_queue_add()",
>+			 job);
>+	  	job_queue_add (op, priority);
> 		Q_DEBUG (("adding a %2d priority job to the queue;"
> 			 "\t       %d jobs running, %d waiting\n",
>-			 job->priority,
>+			 priority,
> 			 running_job_count,
> 			 job_queue_length));
> 		g_static_mutex_unlock (&job_queue_lock);
> 	} else {
>+		fmq_log ("_gnome_vfs_job_schedule(): job %p can start right away; spawning a thread",
>+			 job);
> 		running_job_count++;
> 		Q_DEBUG (("starting a %2d priority job;\t\t       %d jobs running, %d waiting\n",
>-			job->priority,
>+			priority,
> 			running_job_count,
> 			job_queue_length));
> 		g_static_mutex_unlock (&job_queue_lock);
>-		_gnome_vfs_job_create_slave (job);
>+		_gnome_vfs_job_create_slave (op);
> 	}
> 	return TRUE;
> }
>Index: libgnomevfs/gnome-vfs-job-slave.c
>===================================================================
>RCS file: /cvs/gnome/gnome-vfs/libgnomevfs/gnome-vfs-job-slave.c,v
>retrieving revision 1.27
>diff -u -p -r1.27 gnome-vfs-job-slave.c
>--- libgnomevfs/gnome-vfs-job-slave.c	14 Apr 2005 18:48:29 -0000	1.27
>+++ libgnomevfs/gnome-vfs-job-slave.c	10 Aug 2005 16:36:44 -0000
>@@ -22,6 +22,9 @@
>    Author: Ettore Perazzoli <ettore@comm2000.it> */
> 
> #include <config.h>
>+#include <string.h>
>+#include <sys/time.h>
>+#include <glib/gprintf.h>
> #include "gnome-vfs-job-slave.h"
> 
> #include "gnome-vfs-async-job-map.h"
>@@ -34,54 +37,66 @@ static volatile gboolean gnome_vfs_quitt
> static volatile gboolean gnome_vfs_done_quitting = FALSE;
> 
> 
>+static void
>+fmq_log (const char *str, ...)
>+{
>+#if 0
>+	va_list args;
>+	GThread *thread;
>+	struct timeval tv;
>+	double sec;
>+
>+	va_start (args, str);
>+
>+	thread = g_thread_self ();
>+
>+	gettimeofday (&tv, NULL);
>+	sec = tv.tv_sec + ((double) tv.tv_usec / 1e6);
>+
>+	g_fprintf (stderr, "Thread %p time %.16g: ", thread, sec);
>+	g_vfprintf (stderr, str, args);
>+	g_fprintf (stderr, "\n");
>+
>+	va_end (args);
>+#endif
>+}
>+
> static void *
> thread_routine (void *data)
> {
>-	guint id;
>-	GnomeVFSJob *job;
>-	GnomeVFSAsyncHandle *job_handle;
>-	gboolean complete;
>-
>-	job_handle = (GnomeVFSAsyncHandle *) data;
>-
>-	id = GPOINTER_TO_UINT (job_handle);
>-	/* job map must always be locked before the job_lock
>-	 * if both locks are needed */
>-	_gnome_vfs_async_job_map_lock ();
>-	
>-	job = _gnome_vfs_async_job_map_get_job (job_handle);
>-	
>-	if (job == NULL) {
>-		JOB_DEBUG (("job already dead, bail %u", id));
>-		_gnome_vfs_async_job_map_unlock ();
>-		return NULL;
>-	}
>-	
>+	GnomeVFSOp *op;
>+
>+	op = (GnomeVFSOp *) data;
>+
>+	fmq_log ("WORKER: thread_routine() just entered; got op %p, op type %d, job %p, job_handle %p",
>+		 op,
>+		 (int) op->type,
>+		 op->job,
>+		 op->job->job_handle);
>+
> 	JOB_DEBUG (("locking job_lock %u", id));
>-	g_mutex_lock (job->job_lock);
>-	_gnome_vfs_async_job_map_unlock ();
>+	g_mutex_lock (op->job->job_lock);
> 
>-	_gnome_vfs_job_execute (job);
>-	complete = _gnome_vfs_job_complete (job);
>-	
>-	JOB_DEBUG (("Unlocking access lock %u", id));
>-	g_mutex_unlock (job->job_lock);
>+	fmq_log ("WORKER: thread_routine(): about to call _gnome_vfs_job_execute() for op %p",
>+		 op);
> 
>-	if (complete) {
>-		_gnome_vfs_async_job_map_lock ();
>-		JOB_DEBUG (("job %u done, removing from map and destroying", id));
>-		_gnome_vfs_async_job_completed (job_handle);
>-		_gnome_vfs_job_destroy (job);
>-		_gnome_vfs_async_job_map_unlock ();
>-	}
>+	_gnome_vfs_job_execute (op);
>+
>+	fmq_log ("WORKER: thread_routine(): finished with op %p, op type %d, job %p, job_handle %p",
>+		 op,
>+		 (int) op->type,
>+		 op->job,
>+		 op->job->job_handle);
>+
>+	g_mutex_unlock (op->job->job_lock);
> 
> 	return NULL;
> }
> 
> gboolean
>-_gnome_vfs_job_create_slave (GnomeVFSJob *job)
>+_gnome_vfs_job_create_slave (GnomeVFSOp *op)
> {
>-	g_return_val_if_fail (job != NULL, FALSE);
>+	g_assert (op != NULL);
> 
> 	if (gnome_vfs_quitting) {
> 		g_warning ("Someone still starting up GnomeVFS async calls after quit.");
>@@ -96,12 +111,11 @@ _gnome_vfs_job_create_slave (GnomeVFSJob
> 		return FALSE;
> 	}
> 	
>-	if (_gnome_vfs_thread_create (thread_routine, job->job_handle) != 0) {
>+	if (_gnome_vfs_thread_create (thread_routine, op) != 0) {
> 		g_warning ("Impossible to allocate a new GnomeVFSJob thread.");
> 		
> 		/* thread did not start up, remove the job from the hash table */
>-		_gnome_vfs_async_job_completed (job->job_handle);
>-		_gnome_vfs_job_destroy (job);
>+		_gnome_vfs_async_job_completed (op->job->job_handle);
> 		return FALSE;
> 	}
> 
>Index: libgnomevfs/gnome-vfs-job-slave.h
>===================================================================
>RCS file: /cvs/gnome/gnome-vfs/libgnomevfs/gnome-vfs-job-slave.h,v
>retrieving revision 1.5
>diff -u -p -r1.5 gnome-vfs-job-slave.h
>--- libgnomevfs/gnome-vfs-job-slave.h	19 Dec 2002 17:57:19 -0000	1.5
>+++ libgnomevfs/gnome-vfs-job-slave.h	10 Aug 2005 16:36:44 -0000
>@@ -26,7 +26,7 @@
> 
> #include "gnome-vfs-job.h"
> 
>-gboolean _gnome_vfs_job_create_slave        (GnomeVFSJob *job);
>+gboolean _gnome_vfs_job_create_slave        (GnomeVFSOp *op);
> 
> /* Call this before taking down the idle task in the master thread to
>  * give pending slave threads a chance to finish cleanly.
>Index: libgnomevfs/gnome-vfs-job.h
>===================================================================
>RCS file: /cvs/gnome/gnome-vfs/libgnomevfs/gnome-vfs-job.h,v
>retrieving revision 1.53
>diff -u -r1.53 gnome-vfs-job.h
>--- libgnomevfs/gnome-vfs-job.h	14 Apr 2005 18:48:29 -0000	1.53
>+++ libgnomevfs/gnome-vfs-job.h	24 Aug 2005 20:53:49 -0000
>@@ -82,11 +82,6 @@
> 
> #endif
> 
>-/* GNOME_VFS_OP_MODULE_CALLBACK: is not a real OpType; 
>- * its intended to mark GnomeVFSAsyncModuleCallback's in the 
>- * job_callback queue
>- */
>-
> enum GnomeVFSOpType {
> 	GNOME_VFS_OP_OPEN,
> 	GNOME_VFS_OP_OPEN_AS_CHANNEL,
>@@ -97,13 +92,11 @@
> 	GNOME_VFS_OP_READ,
> 	GNOME_VFS_OP_WRITE,
> 	GNOME_VFS_OP_SEEK,
>-	GNOME_VFS_OP_READ_WRITE_DONE,
> 	GNOME_VFS_OP_LOAD_DIRECTORY,
> 	GNOME_VFS_OP_FIND_DIRECTORY,
> 	GNOME_VFS_OP_XFER,
> 	GNOME_VFS_OP_GET_FILE_INFO,
> 	GNOME_VFS_OP_SET_FILE_INFO,
>-	GNOME_VFS_OP_MODULE_CALLBACK,
> 	GNOME_VFS_OP_FILE_CONTROL
> };
> 
>@@ -115,8 +108,6 @@
> } GnomeVFSOpenOp;
> 
> typedef struct {
>-	GnomeVFSAsyncOpenCallback callback;
>-	void *callback_data;
> 	GnomeVFSResult result;
> } GnomeVFSOpenOpResult;
> 
>@@ -127,8 +118,6 @@
> } GnomeVFSOpenAsChannelOp;
> 
> typedef struct {
>-	GnomeVFSAsyncOpenAsChannelCallback callback;
>-	void *callback_data;
> 	GnomeVFSResult result;
> 	GIOChannel *channel;
> } GnomeVFSOpenAsChannelOpResult;
>@@ -141,8 +130,6 @@
> } GnomeVFSCreateOp;
> 
> typedef struct {
>-	GnomeVFSAsyncCreateCallback callback;
>-	void *callback_data;
> 	GnomeVFSResult result;
> } GnomeVFSCreateOpResult;
> 
>@@ -159,8 +146,6 @@
> } GnomeVFSCreateAsChannelOp;
> 
> typedef struct {
>-	GnomeVFSAsyncCreateAsChannelCallback callback;
>-	void *callback_data;
> 	GnomeVFSResult result;
> 	GIOChannel *channel;
> } GnomeVFSCreateAsChannelOpResult;
>@@ -170,8 +155,6 @@
> } GnomeVFSCloseOp;
> 
> typedef struct {
>-	GnomeVFSAsyncCloseCallback callback;
>-	void *callback_data;
> 	GnomeVFSResult result;
> } GnomeVFSCloseOpResult;
> 
>@@ -181,8 +164,6 @@
> } GnomeVFSReadOp;
> 
> typedef struct {
>-	GnomeVFSAsyncReadCallback callback;
>-	void *callback_data;
> 	GnomeVFSFileSize num_bytes;
> 	gpointer buffer;
> 	GnomeVFSResult result;
>@@ -195,8 +176,6 @@
> } GnomeVFSWriteOp;
> 
> typedef struct {
>-	GnomeVFSAsyncWriteCallback callback;
>-	void *callback_data;
> 	GnomeVFSFileSize num_bytes;
> 	gconstpointer buffer;
> 	GnomeVFSResult result;
>@@ -209,8 +188,6 @@
> } GnomeVFSSeekOp;
> 
> typedef struct {
>-	GnomeVFSAsyncSeekCallback callback;
>-	void *callback_data;
> 	GnomeVFSResult result;
> } GnomeVFSSeekOpResult;
> 
>@@ -220,8 +197,6 @@
> } GnomeVFSGetFileInfoOp;
> 
> typedef struct {
>-	GnomeVFSAsyncGetFileInfoCallback callback;
>-	void *callback_data;
> 	GList *result_list; /* GnomeVFSGetFileInfoResult* */
> } GnomeVFSGetFileInfoOpResult;
> 
>@@ -233,8 +208,6 @@
> } GnomeVFSSetFileInfoOp;
> 
> typedef struct {
>-	GnomeVFSAsyncSetFileInfoCallback callback;
>-	void *callback_data;
> 	GnomeVFSResult set_file_info_result;
> 	GnomeVFSResult get_file_info_result;
> 	GnomeVFSFileInfo *info;
>@@ -249,8 +222,7 @@
> } GnomeVFSFindDirectoryOp;
> 
> typedef struct {
>-	GnomeVFSAsyncFindDirectoryCallback callback;
>-	void *callback_data;
>+	GnomeVFSResult result;
> 	GList *result_list; /* GnomeVFSFindDirectoryResult */
> } GnomeVFSFindDirectoryOpResult;
> 
>@@ -261,8 +233,6 @@
> } GnomeVFSLoadDirectoryOp;
> 
> typedef struct {
>-	GnomeVFSAsyncDirectoryLoadCallback callback;
>-	void *callback_data;
> 	GnomeVFSResult result;
> 	GList *list;
> 	guint entries_read;
>@@ -279,8 +249,6 @@
> } GnomeVFSXferOp;
> 
> typedef struct {
>-	GnomeVFSAsyncXferProgressCallback callback;
>-	void *callback_data;
> 	GnomeVFSXferProgressInfo *progress_info;
> 	int reply;
> } GnomeVFSXferOpResult;
>@@ -303,8 +271,6 @@
> } GnomeVFSFileControlOp;
> 
> typedef struct {
>-	GnomeVFSAsyncFileControlCallback callback;
>-	gpointer callback_data;
> 	GnomeVFSResult result;
> 	gpointer operation_data;
> 	GDestroyNotify operation_data_destroy_func;
>@@ -329,9 +295,15 @@
> } GnomeVFSSpecificOp;
> 
> typedef struct {
>+	/* Job corresponding to this operation */
>+	GnomeVFSJob *job;
>+
> 	/* ID of the job (e.g. open, create, close...). */
> 	GnomeVFSOpType type;
> 
>+	/* Whether this operation was canceled */
>+	gboolean canceled;
>+
> 	/* The callback for when the op is completed. */
> 	GFunc callback;
> 	gpointer callback_data;
>@@ -363,37 +335,41 @@
> } GnomeVFSSpecificNotifyResult;
> 
> typedef struct {
>-	GnomeVFSAsyncHandle *job_handle;
>+	/* Operation to which this notification refers */
>+	GnomeVFSOp *op;
> 
>+#if 0
> 	guint callback_id;
>-
> 	/* By the time the callback got reached the job might have been cancelled.
> 	 * We find out by checking this flag.
> 	 */
>-	gboolean cancelled;
>+	gboolean cancelled; /* FMQ: should this be here?  isn't job_has_cancelled_op () for the corresponding op enough? */
> 	
> 	/* ID of the job (e.g. open, create, close...). */
>-	GnomeVFSOpType type;
>-
>+	GnomeVFSOpType type; /* FMQ: this is not needed; we can use op->type, right? */
>+#endif
> 	GnomeVFSSpecificNotifyResult specifics;
>+
>+	/* Does this result actually correspond to a module callback, rather than an op's notification? */
>+	gboolean is_module_callback;
> } GnomeVFSNotifyResult;
> 
> /* FIXME bugzilla.eazel.com 1135: Move private stuff out of the header.  */
> struct GnomeVFSJob {
> 	/* Handle being used for file access.  */
> 	GnomeVFSHandle *handle;
>-
>+#if 0
> 	/* By the time the entry routine for the job got reached
> 	 * the job might have been cancelled. We find out by checking
> 	 * this flag.
> 	 */
>-	gboolean cancelled;
>+	gboolean cancelled; /* FMQ: moved to GnomeVFSOp */
> 
> 	/* Read or create returned with an error - helps
> 	 * flagging that we do not expect a cancel
> 	 */
>-	gboolean failed;
>-
>+	gboolean failed; /* FMQ: move this to GnomeVFSOp? */
>+#endif
> 	/* Global lock for accessing job's 'op' and 'handle' */
> 	GMutex *job_lock;
> 
>@@ -401,11 +377,24 @@
>            notification and wants to acknowledge it.  */
> 	GCond *notify_ack_condition;
> 
>-	/* Operations that are being done and those that are completed and
>-	 * ready for notification to take place.
>+	/* The current operation, which is in progress.  If this is NULL, it
>+	 * means that the current operation is either done or canceled.  "Done"
>+	 * means that the caller has been notified through its callbacks;
>+	 * canceled means the op is now in the job->canceled_ops list.
> 	 */
> 	GnomeVFSOp *op;
>-	
>+
>+	/* List of canceled operations.  job->op gets moved to here when someone calls
>+	 * gnome_vfs_async_cancel().  The list shrinks when we pick up notification in
>+	 * dispatch_job_callback().
>+	 */
>+	GSList *canceled_ops;
>+
>+	/* Whether we must wait for canceled operations to get notification
>+	 * before we can free the job.
>+	 */
>+	gboolean free_when_canceled_ops_complete;
>+
> 	/* Unique identifier of this job (a uint, really) */
> 	GnomeVFSAsyncHandle *job_handle;
> 
>@@ -423,10 +412,8 @@
> 				      		   GFunc           	 callback,
> 				      		   gpointer        	 callback_data);
> void         	 _gnome_vfs_job_go       	  (GnomeVFSJob     	*job);
>-void     	 _gnome_vfs_job_execute  	  (GnomeVFSJob     	*job);
>+void     	 _gnome_vfs_job_execute  	  (GnomeVFSOp     	*op);
> void         	 _gnome_vfs_job_module_cancel  	  (GnomeVFSJob	 	*job);
> int          	 gnome_vfs_job_get_count 	  (void);
>-
>-gboolean	 _gnome_vfs_job_complete	  (GnomeVFSJob 		*job);
> 
> #endif /* GNOME_VFS_JOB_H */
>Index: libgnomevfs/gnome-vfs-job.c
>===================================================================
>RCS file: /cvs/gnome/gnome-vfs/libgnomevfs/gnome-vfs-job.c,v
>retrieving revision 1.105
>diff -u -r1.105 gnome-vfs-job.c
>--- libgnomevfs/gnome-vfs-job.c	8 May 2005 13:04:05 -0000	1.105
>+++ libgnomevfs/gnome-vfs-job.c	5 Sep 2005 18:20:57 -0000
>@@ -28,6 +28,9 @@
>    */
> 
> #include <config.h>
>+#include <string.h>
>+#include <sys/time.h>
>+#include <glib/gprintf.h>
> #include "gnome-vfs-job.h"
> 
> #include "gnome-vfs-async-job-map.h"
>@@ -44,6 +47,7 @@
> #include <string.h>
> #include <unistd.h>
> 
>+/* We store a GnomeVFSOp here */
> static GStaticPrivate job_private = G_STATIC_PRIVATE_INIT;
> 
> #if GNOME_VFS_JOB_DEBUG
>@@ -71,90 +75,64 @@
> static int job_count = 0;
> 
> static void     gnome_vfs_op_destroy                (GnomeVFSOp           *op);
>-static void     _gnome_vfs_job_destroy_notify_result (GnomeVFSNotifyResult *notify_result);
>+static void     _gnome_vfs_job_destroy_notify_result (GnomeVFSNotifyResult *notify_result,
>+						      GnomeVFSOpType	    type);
> static gboolean dispatch_job_callback               (gpointer              data);
> static gboolean dispatch_sync_job_callback          (gpointer              data);
> 
>-static void	clear_current_job 		    (void);
>-static void	set_current_job 		    (GnomeVFSJob *context);
>+static void	clear_current_op 		    (void);
>+static void	set_current_op			    (GnomeVFSOp *op);
> 
>-/*
>- *   Find out whether or not a given job should be left in
>- * the job map, preserving it's open VFS handle, since we
>- * can do more operations on it later.
>- */
>-gboolean
>-_gnome_vfs_job_complete (GnomeVFSJob *job)
>+static void
>+fmq_log (const char *str, ...)
> {
>-	g_assert (job->op != NULL);
>-	
>-	switch (job->op->type) {
>-	case GNOME_VFS_OP_OPEN:
>-	case GNOME_VFS_OP_OPEN_AS_CHANNEL:
>-	case GNOME_VFS_OP_CREATE:
>-	case GNOME_VFS_OP_CREATE_AS_CHANNEL:
>-	case GNOME_VFS_OP_CREATE_SYMBOLIC_LINK:
>-		/* if job got cancelled, no close expected */
>-		return job->cancelled || job->failed;
>+#if 0
>+	va_list args;
>+	GThread *thread;
>+	struct timeval tv;
>+	double sec;
> 
>-	case GNOME_VFS_OP_READ:
>-	case GNOME_VFS_OP_WRITE:
>-		g_assert_not_reached();
>-		return FALSE;
>-	case GNOME_VFS_OP_READ_WRITE_DONE:
>-	case GNOME_VFS_OP_FILE_CONTROL:
>-	case GNOME_VFS_OP_SEEK:
>-		return FALSE;
>-	
>-	default:
>-		return TRUE;
>-	}
>+	va_start (args, str);
>+
>+	thread = g_thread_self ();
>+
>+	gettimeofday (&tv, NULL);
>+	sec = tv.tv_sec + ((double) tv.tv_usec / 1e6);
>+
>+	g_fprintf (stderr, "Thread %p time %.16g: ", thread, sec);
>+	g_vfprintf (stderr, str, args);
>+	g_fprintf (stderr, "\n");
>+
>+	va_end (args);
>+#endif
> }
> 
> /* This notifies the master thread asynchronously, without waiting for an
>  * acknowledgment.
>  */
> static void
>-job_oneway_notify (GnomeVFSJob *job, GnomeVFSNotifyResult *notify_result)
>+job_oneway_notify (GnomeVFSNotifyResult *notify_result)
> {
>-	if (_gnome_vfs_async_job_add_callback (job, notify_result)) {
>-		JOB_DEBUG (("job %u, callback %u type '%s'",
>-			    GPOINTER_TO_UINT (notify_result->job_handle),
>-			    notify_result->callback_id,
>-			    JOB_DEBUG_TYPE (job->op->type)));
>-	
>-		g_idle_add (dispatch_job_callback, notify_result);
>-	} else {
>-		JOB_DEBUG (("Barfing on oneway cancel %u (%d) type '%s'",
>-			    GPOINTER_TO_UINT (notify_result->job_handle),
>-			    job->op->type, JOB_DEBUG_TYPE (job->op->type)));
>-		/* TODO: We can leak handle here, if an open succeded.
>-		 * See bug #123472 */
>-		_gnome_vfs_job_destroy_notify_result (notify_result);
>-	}
>+	JOB_DEBUG (("job %u, type '%s'",
>+		    GPOINTER_TO_UINT (notify_result->op->job->job_handle),
>+		    JOB_DEBUG_TYPE (notify_result->op->type)));
>+
>+	g_idle_add (dispatch_job_callback, notify_result);
> }
> 
> /* This notifies the master threads, waiting until it acknowledges the
>    notification.  */
> static void
>-job_notify (GnomeVFSJob *job, GnomeVFSNotifyResult *notify_result)
>+job_notify (GnomeVFSNotifyResult *notify_result)
> {
>-	if (!_gnome_vfs_async_job_add_callback (job, notify_result)) {
>-		JOB_DEBUG (("Barfing on sync cancel %u (%d)",
>-			    GPOINTER_TO_UINT (notify_result->job_handle),
>-			    job->op->type));
>-		_gnome_vfs_job_destroy_notify_result (notify_result);
>-		return;
>-	}
>-
> 	/* Send the notification.  This will wake up the master thread, which
>          * will in turn signal the notify condition.
>          */
> 	g_idle_add (dispatch_sync_job_callback, notify_result);
> 
>-	JOB_DEBUG (("Wait notify condition %u", GPOINTER_TO_UINT (notify_result->job_handle)));
>+	JOB_DEBUG (("Wait notify condition %u", GPOINTER_TO_UINT (notify_result->op->job->job_handle)));
> 	/* Wait for the notify condition.  */
>-	g_cond_wait (job->notify_ack_condition, job->job_lock);
>+	g_cond_wait (notify_result->op->job->notify_ack_condition, notify_result->op->job->job_lock);
> 
> 	JOB_DEBUG (("Got notify ack condition %u", GPOINTER_TO_UINT (notify_result->job_handle)));
> }
>@@ -162,128 +140,178 @@
> static void
> dispatch_open_callback (GnomeVFSNotifyResult *notify_result)
> {
>-	(* notify_result->specifics.open.callback) (notify_result->job_handle,
>-						    notify_result->specifics.open.result,
>-						    notify_result->specifics.open.callback_data);
>+	GnomeVFSAsyncOpenCallback callback;
>+
>+	callback = (GnomeVFSAsyncOpenCallback) notify_result->op->callback;
>+
>+	(* callback) (notify_result->op->job->job_handle,
>+		      notify_result->specifics.open.result,
>+		      notify_result->op->callback_data);
> }
> 
> static void
> dispatch_create_callback (GnomeVFSNotifyResult *notify_result)
> {
>-	(* notify_result->specifics.create.callback) (notify_result->job_handle,
>-						      notify_result->specifics.create.result,
>-						      notify_result->specifics.create.callback_data);
>+	GnomeVFSAsyncCreateCallback callback;
>+
>+	callback = (GnomeVFSAsyncCreateCallback) notify_result->op->callback;
>+
>+	(* callback) (notify_result->op->job->job_handle,
>+		      notify_result->specifics.create.result,
>+		      notify_result->op->callback_data);
> }
> 
> static void
> dispatch_open_as_channel_callback (GnomeVFSNotifyResult *notify_result)
> {
>-	(* notify_result->specifics.open_as_channel.callback) (notify_result->job_handle,
>-							       notify_result->specifics.open_as_channel.channel,
>-							       notify_result->specifics.open_as_channel.result,
>-							       notify_result->specifics.open_as_channel.callback_data);
>+	GnomeVFSAsyncOpenAsChannelCallback callback;
>+
>+	callback = (GnomeVFSAsyncOpenAsChannelCallback) notify_result->op->callback;
>+
>+	(* callback) (notify_result->op->job->job_handle,
>+		      notify_result->specifics.open_as_channel.channel,
>+		      notify_result->specifics.open_as_channel.result,
>+		      notify_result->op->callback_data);
> }
> 
> static void
> dispatch_create_as_channel_callback (GnomeVFSNotifyResult *notify_result)
> {
>-	(* notify_result->specifics.create_as_channel.callback) (notify_result->job_handle,
>-								 notify_result->specifics.create_as_channel.channel,
>-								 notify_result->specifics.create_as_channel.result,
>-								 notify_result->specifics.create_as_channel.callback_data);
>+	GnomeVFSAsyncCreateAsChannelCallback callback;
>+
>+	callback = (GnomeVFSAsyncCreateAsChannelCallback) notify_result->op->callback;
>+
>+	(* callback) (notify_result->op->job->job_handle,
>+		      notify_result->specifics.create_as_channel.channel,
>+		      notify_result->specifics.create_as_channel.result,
>+		      notify_result->op->callback_data);
> }
> 
> static void
> dispatch_close_callback (GnomeVFSNotifyResult *notify_result)
> {
>-	(* notify_result->specifics.close.callback) (notify_result->job_handle,
>-						     notify_result->specifics.close.result,
>-						     notify_result->specifics.close.callback_data);
>+	GnomeVFSAsyncCloseCallback callback;
>+
>+	callback = (GnomeVFSAsyncCloseCallback) notify_result->op->callback;
>+
>+	(* callback) (notify_result->op->job->job_handle,
>+		      notify_result->specifics.close.result,
>+		      notify_result->op->callback_data);
> }
> 
> static void
> dispatch_read_callback (GnomeVFSNotifyResult *notify_result)
> {
>-	(* notify_result->specifics.read.callback) (notify_result->job_handle,
>-						    notify_result->specifics.read.result,
>-						    notify_result->specifics.read.buffer,
>-						    notify_result->specifics.read.num_bytes,
>-						    notify_result->specifics.read.bytes_read,
>-						    notify_result->specifics.read.callback_data);
>+	GnomeVFSAsyncReadCallback callback;
>+
>+	callback = (GnomeVFSAsyncReadCallback) notify_result->op->callback;
>+
>+	(* callback) (notify_result->op->job->job_handle,
>+		      notify_result->specifics.read.result,
>+		      notify_result->specifics.read.buffer,
>+		      notify_result->specifics.read.num_bytes,
>+		      notify_result->specifics.read.bytes_read,
>+		      notify_result->op->callback_data);
> }
> 
> static void
> dispatch_write_callback (GnomeVFSNotifyResult *notify_result)
> {
>-	(* notify_result->specifics.write.callback) (notify_result->job_handle,
>-						     notify_result->specifics.write.result,
>-						     notify_result->specifics.write.buffer,
>-						     notify_result->specifics.write.num_bytes,
>-						     notify_result->specifics.write.bytes_written,
>-						     notify_result->specifics.write.callback_data);
>+	GnomeVFSAsyncWriteCallback callback;
>+
>+	callback = (GnomeVFSAsyncWriteCallback) notify_result->op->callback;
>+
>+	(* callback) (notify_result->op->job->job_handle,
>+		      notify_result->specifics.write.result,
>+		      notify_result->specifics.write.buffer,
>+		      notify_result->specifics.write.num_bytes,
>+		      notify_result->specifics.write.bytes_written,
>+		      notify_result->op->callback_data);
> }
> 
> static void
> dispatch_seek_callback (GnomeVFSNotifyResult *notify_result)
> {
>-	(* notify_result->specifics.seek.callback) (notify_result->job_handle,
>-						    notify_result->specifics.seek.result,
>-						    notify_result->specifics.seek.callback_data);
>+	GnomeVFSAsyncSeekCallback callback;
>+
>+	callback = (GnomeVFSAsyncSeekCallback) notify_result->op->callback;
>+
>+	(* callback) (notify_result->op->job->job_handle,
>+		      notify_result->specifics.seek.result,
>+		      notify_result->op->callback_data);
> }
> 
> static void
> dispatch_load_directory_callback (GnomeVFSNotifyResult *notify_result)
> {
>-	(* notify_result->specifics.load_directory.callback) (notify_result->job_handle,
>-							      notify_result->specifics.load_directory.result,
>-							      notify_result->specifics.load_directory.list,
>-							      notify_result->specifics.load_directory.entries_read,
>-							      notify_result->specifics.load_directory.callback_data);
>+	GnomeVFSAsyncDirectoryLoadCallback callback;
>+
>+	callback = (GnomeVFSAsyncDirectoryLoadCallback) notify_result->op->callback;
>+
>+	(* callback) (notify_result->op->job->job_handle,
>+		      notify_result->specifics.load_directory.result,
>+		      notify_result->specifics.load_directory.list,
>+		      notify_result->specifics.load_directory.entries_read,
>+		      notify_result->op->callback_data);
> }
> 
> static void
> dispatch_get_file_info_callback (GnomeVFSNotifyResult *notify_result)
> {
>-	(* notify_result->specifics.get_file_info.callback) (notify_result->job_handle,
>-							     notify_result->specifics.get_file_info.result_list,
>-							     notify_result->specifics.get_file_info.callback_data);
>+	GnomeVFSAsyncGetFileInfoCallback callback;
>+
>+	callback = (GnomeVFSAsyncGetFileInfoCallback) notify_result->op->callback;
>+
>+	(* callback) (notify_result->op->job->job_handle,
>+		      notify_result->specifics.get_file_info.result_list,
>+		      notify_result->op->callback_data);
> }
> 
> static void
> dispatch_find_directory_callback (GnomeVFSNotifyResult *notify_result)
> {
>-	(* notify_result->specifics.find_directory.callback) (notify_result->job_handle,
>-							      notify_result->specifics.find_directory.result_list,
>-							      notify_result->specifics.find_directory.callback_data);
>+	GnomeVFSAsyncFindDirectoryCallback callback;
>+
>+	callback = (GnomeVFSAsyncFindDirectoryCallback) notify_result->op->callback;
>+
>+	(* callback) (notify_result->op->job->job_handle,
>+		      notify_result->specifics.find_directory.result_list,
>+		      notify_result->op->callback_data);
> }
> 
> static void
> dispatch_set_file_info_callback (GnomeVFSNotifyResult *notify_result)
> {
>+	GnomeVFSAsyncSetFileInfoCallback callback;
> 	gboolean new_info_is_valid;
> 
>+	callback = (GnomeVFSAsyncSetFileInfoCallback) notify_result->op->callback;
>+
> 	new_info_is_valid = notify_result->specifics.set_file_info.set_file_info_result == GNOME_VFS_OK
> 		&& notify_result->specifics.set_file_info.get_file_info_result == GNOME_VFS_OK;
> 		
>-	(* notify_result->specifics.set_file_info.callback) (notify_result->job_handle,
>-							     notify_result->specifics.set_file_info.set_file_info_result,
>-							     new_info_is_valid ? notify_result->specifics.set_file_info.info : NULL,
>-							     notify_result->specifics.set_file_info.callback_data);
>+	(* callback) (notify_result->op->job->job_handle,
>+		      notify_result->specifics.set_file_info.set_file_info_result,
>+		      new_info_is_valid ? notify_result->specifics.set_file_info.info : NULL,
>+		      notify_result->op->callback_data);
> }
> 
> static void
> dispatch_xfer_callback (GnomeVFSNotifyResult *notify_result, gboolean cancelled)
> {
>+	GnomeVFSAsyncXferProgressCallback callback;
>+
>+	callback = (GnomeVFSAsyncXferProgressCallback) notify_result->op->callback;
>+
> 	if (cancelled) {
> 		/* make the xfer operation stop */
> 		notify_result->specifics.xfer.reply = 0;
> 		return;
> 	}
> 	
>-	notify_result->specifics.xfer.reply = (* notify_result->specifics.xfer.callback) (
>-							    notify_result->job_handle,
>+	notify_result->specifics.xfer.reply = (* callback) (notify_result->op->job->job_handle,
> 							    notify_result->specifics.xfer.progress_info,
>-						            notify_result->specifics.xfer.callback_data);
>+						            notify_result->op->callback_data);
> }
> 
> static void
>@@ -301,10 +329,14 @@
> static void
> dispatch_file_control_callback (GnomeVFSNotifyResult *notify_result)
> {
>-	notify_result->specifics.file_control.callback (notify_result->job_handle,
>-							notify_result->specifics.file_control.result,
>-							notify_result->specifics.file_control.operation_data,
>-							notify_result->specifics.file_control.callback_data);
>+	GnomeVFSAsyncFileControlCallback callback;
>+
>+	callback = (GnomeVFSAsyncFileControlCallback) notify_result->op->callback;
>+
>+	(* callback) (notify_result->op->job->job_handle,
>+		      notify_result->specifics.file_control.result,
>+		      notify_result->specifics.file_control.operation_data,
>+		      notify_result->op->callback_data);
> }
> 
> static void
>@@ -315,8 +347,17 @@
> }
> 
> static void
>+remove_and_free_job (GnomeVFSJob *job)
>+{
>+	_gnome_vfs_async_job_completed (job);
>+	_gnome_vfs_job_destroy (job);
>+}
>+
>+static void
> handle_cancelled_open (GnomeVFSJob *job)
> {
>+	fmq_log ("MAIN: handle_cancelled_open(): RECYCLING job %p to close a file",
>+		 job);
> 	/* schedule a silent close to make sure the handle does not leak */
> 	_gnome_vfs_job_set (job, GNOME_VFS_OP_CLOSE, 
> 			   (GFunc) empty_close_callback, NULL);
>@@ -357,11 +398,14 @@
> }
> 
> static void
>-_gnome_vfs_job_destroy_notify_result (GnomeVFSNotifyResult *notify_result)
>+_gnome_vfs_job_destroy_notify_result (GnomeVFSNotifyResult *notify_result, GnomeVFSOpType type)
> {
> 	JOB_DEBUG (("%u", notify_result->callback_id));
> 
>-	switch (notify_result->type) {
>+	fmq_log ("MAIN: _gnome_vfs_job_destroy_notify_result(): notify_result %p",
>+		 notify_result);
>+
>+	switch (type) {
> 	case GNOME_VFS_OP_CLOSE:
> 	case GNOME_VFS_OP_CREATE:
> 	case GNOME_VFS_OP_CREATE_AS_CHANNEL:
>@@ -406,10 +450,6 @@
> 		/* the XFER result is allocated on the stack */
> 		break;
> 		
>-	case GNOME_VFS_OP_MODULE_CALLBACK:
>-		/* the MODULE_CALLBACK result is allocated on the stack */
>-		break;
>-	
> 	default:
> 		g_assert_not_reached ();
> 		break;
>@@ -422,47 +462,31 @@
> {
> 	GnomeVFSNotifyResult *notify_result;
> 	GnomeVFSJob *job;
>-	gboolean valid;
>-	gboolean cancelled;
> 
> 	notify_result = (GnomeVFSNotifyResult *) data;
> 
>-	_gnome_vfs_async_job_callback_valid (notify_result->callback_id, &valid, &cancelled);
>-
>-	/* Even though the notify result is owned by the async thread and persists
>-	 * all through the notification, we still keep it in the job map to
>-	 * make cancellation easier.
>-	 */
>-	_gnome_vfs_async_job_remove_callback (notify_result->callback_id);
>-
>-	g_assert (valid);
>-
>-	switch (notify_result->type) {
>-	case GNOME_VFS_OP_CREATE_AS_CHANNEL:
>-		dispatch_create_as_channel_callback (notify_result);
>-		break;
>-	case GNOME_VFS_OP_OPEN_AS_CHANNEL:
>-		dispatch_open_as_channel_callback (notify_result);
>-		break;		
>-	case GNOME_VFS_OP_XFER:
>-		dispatch_xfer_callback (notify_result, cancelled);
>-		break;
>-	case GNOME_VFS_OP_MODULE_CALLBACK:
>+	if (notify_result->is_module_callback)
> 		dispatch_module_callback (notify_result);
>-		break;
>-	default:
>-		g_assert_not_reached ();
>-		break;
>-	}
>-	
>-	_gnome_vfs_async_job_map_lock ();
>-	job = _gnome_vfs_async_job_map_get_job (notify_result->job_handle);
>+	else
>+		switch (notify_result->op->type) {
>+		case GNOME_VFS_OP_CREATE_AS_CHANNEL:
>+			dispatch_create_as_channel_callback (notify_result);
>+			break;
>+		case GNOME_VFS_OP_OPEN_AS_CHANNEL:
>+			dispatch_open_as_channel_callback (notify_result);
>+			break;		
>+		case GNOME_VFS_OP_XFER:
>+			dispatch_xfer_callback (notify_result, notify_result->op->canceled);
>+			break;
>+		default:
>+			g_assert_not_reached ();
>+			break;
>+		}
>+
>+	job = notify_result->op->job;
> 	g_mutex_lock (job->job_lock);
>-	_gnome_vfs_async_job_map_unlock ();
>-	
>-	g_assert (job != NULL);
>-	
>-	JOB_DEBUG (("signalling %u", GPOINTER_TO_UINT (notify_result->job_handle)));
>+
>+	JOB_DEBUG (("signalling %u", GPOINTER_TO_UINT (job->job_handle)));
> 	
> 	/* Signal the async thread that we are done with the notification. */
> 	g_cond_signal (job->notify_ack_condition);
>@@ -474,104 +498,252 @@
> /* Entry point for async notification callback */
> static gboolean
> dispatch_job_callback (gpointer data)
>-
> {
> 	GnomeVFSNotifyResult *notify_result;
> 	GnomeVFSJob *job;
>-	gboolean valid;
>-	gboolean cancelled;
>+	gboolean canceled;
>+	GnomeVFSOpType type;
>+	gboolean free_op;
>+	gboolean maybe_remove_job;
> 	
> 	notify_result = (GnomeVFSNotifyResult *) data;
> 
>-	JOB_DEBUG (("%u type '%s'", GPOINTER_TO_UINT (notify_result->job_handle),
>+	fmq_log ("MAIN: dispatch_job_callback(): notify_result %p, op %p, op type %d, job %p, job_handle %p, canceled = %d",
>+		 notify_result,
>+		 notify_result->op,
>+		 (int) notify_result->op->type,
>+		 notify_result->op->job,
>+		 notify_result->op->job->job_handle,
>+		 (int) notify_result->op->canceled);
>+
>+	JOB_DEBUG (("%u type '%s'", GPOINTER_TO_UINT (notify_result->op->job->job_handle),
> 		    JOB_DEBUG_TYPE (notify_result->type)));
>-	
>-	_gnome_vfs_async_job_callback_valid (notify_result->callback_id, &valid, &cancelled);
>-	_gnome_vfs_async_job_remove_callback (notify_result->callback_id);
> 
>-	if (!valid) {
>-		/* this can happen when gnome vfs is shutting down */
>-		JOB_DEBUG (("shutting down: callback %u no longer valid",
>-			    notify_result->callback_id));
>-		_gnome_vfs_job_destroy_notify_result (notify_result);
>-		return FALSE;
>-	}
>+	_gnome_vfs_async_job_map_lock (); /* will unlock after the if() clause below */
>+	job = _gnome_vfs_async_job_map_get_job (notify_result->op->job->job_handle);
>+	g_assert (job == notify_result->op->job);
>+	_gnome_vfs_async_job_map_unlock ();
>+
>+	g_mutex_lock (job->job_lock);
>+	canceled = notify_result->op->canceled;
>+	type = notify_result->op->type;
> 	
>-	if (cancelled) {
>-		/* cancel the job in progress */
>-		JOB_DEBUG (("cancelling job %u %u",
>-			    GPOINTER_TO_UINT (notify_result->job_handle),
>-			    notify_result->callback_id));
>+	if (canceled) {
>+		GSList *canceled_op_link;
>+		gboolean job_unlocked;
> 
>-		_gnome_vfs_async_job_map_lock ();
>+		/* cancel the job in progress */
>+		JOB_DEBUG (("cancelling job %u",
>+			    GPOINTER_TO_UINT (job->job_handle)));
> 
>-		job = _gnome_vfs_async_job_map_get_job (notify_result->job_handle);
>-		
>-		if (job != NULL) {
>-			g_mutex_lock (job->job_lock);
>+		fmq_log ("MAIN: dispatch_job_callback(): handling cancelled job for notify_result %p, op %p, job %p, job_handle %p",
>+			 notify_result,
>+			 notify_result->op,
>+			 job,
>+			 job->job_handle);
>+
>+		g_assert (job->op != notify_result->op);
>+		canceled_op_link = g_slist_find (job->canceled_ops, notify_result->op);
>+		g_assert (canceled_op_link != NULL);
>+
>+		free_op = TRUE;
>+		maybe_remove_job = FALSE;
>+		job_unlocked = FALSE;
> 
>-			switch (job->op->type) {
>-			case GNOME_VFS_OP_OPEN:
>-			case GNOME_VFS_OP_OPEN_AS_CHANNEL:
>-			case GNOME_VFS_OP_CREATE:
>-			case GNOME_VFS_OP_CREATE_AS_CHANNEL:
>-			case GNOME_VFS_OP_CREATE_SYMBOLIC_LINK:
>-				if (job->handle) {
>-					g_mutex_unlock (job->job_lock);
>-					handle_cancelled_open (job);
>-					JOB_DEBUG (("handle cancel open job %u",
>-						    GPOINTER_TO_UINT (notify_result->job_handle)));
>-					break;
>-				} /* else drop through */
>-			default:
>-				/* Remove job from the job map. */
>-				_gnome_vfs_async_job_map_remove_job (job);
>+		switch (type) {
>+		case GNOME_VFS_OP_OPEN:
>+		case GNOME_VFS_OP_OPEN_AS_CHANNEL:
>+		case GNOME_VFS_OP_CREATE:
>+		case GNOME_VFS_OP_CREATE_AS_CHANNEL:
>+		case GNOME_VFS_OP_CREATE_SYMBOLIC_LINK:
>+			/* These operations require special handling, since we
>+			 * may have already succeded in opening a file
>+			 * descriptor.  We cancel this by closing the file
>+			 * descriptor.
>+			 */
>+			if (job->handle) {
> 				g_mutex_unlock (job->job_lock);
>-				break;
>+				job_unlocked = TRUE;
>+				fmq_log ("MAIN: dispatch_job_callback(): handling canceled open job %p",
>+					 job);
>+				handle_cancelled_open (job);
>+				JOB_DEBUG (("handle cancel open job %u",
>+					    GPOINTER_TO_UINT (job->job_handle)));
>+			} else
>+				maybe_remove_job = TRUE;
>+
>+			break;
>+
>+		case GNOME_VFS_OP_CLOSE:
>+		case GNOME_VFS_OP_GET_FILE_INFO:
>+		case GNOME_VFS_OP_SET_FILE_INFO:
>+		case GNOME_VFS_OP_FIND_DIRECTORY:
>+			/* These operations can possibly free the job
>+			 * immediately, since no operations on the handle are
>+			 * possible after it has been cancelled.
>+			 */
>+			fmq_log ("MAIN: Marking job %p for freeing when its canceled ops finish",
>+				 job);
>+			job->free_when_canceled_ops_complete = TRUE;
>+			maybe_remove_job = TRUE;
>+			break;
>+
>+		case GNOME_VFS_OP_LOAD_DIRECTORY:
>+			/* Since this operation invokes multiple callbacks, we
>+			 * can only free it when it returns anything other than
>+			 * GNOME_VFS_OK; that's when it is done emitting all the
>+			 * callbacks and thus terminated.
>+			 */
>+			fmq_log ("dispatch_job_callback(): canceled load_directory, result %d",
>+				 (int) notify_result->specifics.load_directory.result);
>+
>+			if (notify_result->specifics.load_directory.result == GNOME_VFS_OK)
>+				free_op = FALSE;
>+			else
>+				maybe_remove_job = TRUE;
>+
>+			break;
>+
>+		default:
>+			/* All other operations require the job to remain alive
>+			 * unless it has to wait for its pending cancellations
>+			 * to finish.
>+			 */
>+			break;
>+		}
>+
>+		if (free_op) {
>+			if (job_unlocked) {
>+				g_mutex_lock (job->job_lock);
>+				job_unlocked = FALSE;
> 			}
>+
>+			job->canceled_ops = g_slist_remove_link (job->canceled_ops, canceled_op_link);
>+			gnome_vfs_op_destroy (notify_result->op);
> 		}
>-	
>-		_gnome_vfs_async_job_map_unlock ();
>-		_gnome_vfs_job_destroy_notify_result (notify_result);
>+
>+		_gnome_vfs_job_destroy_notify_result (notify_result, type);
>+
>+		if (maybe_remove_job) {
>+			if (job_unlocked) {
>+				g_mutex_lock (job->job_lock);
>+				job_unlocked = FALSE;
>+			}
>+
>+			if (g_slist_length (job->canceled_ops) != 0) {
>+				maybe_remove_job = FALSE;
>+				fmq_log ("MAIN: Wanted to remove job %p, but it still has pending cancellations",
>+					 job);
>+			} else
>+				fmq_log ("MAIN: Will remove job %p",
>+					 job);
>+		} else {
>+			if (job_unlocked) {
>+				g_mutex_lock (job->job_lock);
>+				job_unlocked = FALSE;
>+			}
>+
>+			if (job->free_when_canceled_ops_complete && g_slist_length (job->canceled_ops) == 0) {
>+				maybe_remove_job = TRUE;
>+				fmq_log ("MAIN: will remove job %p; it has no pending cancellations and is marked for destruction",
>+					 job);
>+			}
>+		}
>+
>+		if (!job_unlocked)
>+			g_mutex_unlock (job->job_lock);
>+
>+		if (maybe_remove_job)
>+			remove_and_free_job (job);
>+
> 		return FALSE;
> 	}
>-	
>-		
>-	JOB_DEBUG (("executing callback %u", GPOINTER_TO_UINT (notify_result->job_handle)));	
> 
>-	switch (notify_result->type) {
>+	JOB_DEBUG (("executing callback %u", GPOINTER_TO_UINT (notify_result->job_handle)));
>+
>+	g_assert (job->op == notify_result->op);
>+
>+	/* set the job to "no current operation" here so the user callbacks can
>+	 * queue another operation.  Do this for all except
>+	 * GNOME_VFS_OP_LOAD_DIRECTORY, because that one can emit further
>+	 * notifications after the current one.
>+	 */
>+	if (notify_result->op->type != GNOME_VFS_OP_LOAD_DIRECTORY)
>+		job->op = NULL;
>+
>+	g_mutex_unlock (job->job_lock);
>+
>+	free_op = TRUE;
>+	maybe_remove_job = FALSE;
>+
>+	switch (type) {
> 	case GNOME_VFS_OP_CLOSE:
> 		dispatch_close_callback (notify_result);
>+
>+		g_mutex_lock (job->job_lock);
>+		fmq_log ("MAIN: Marking job %p for freeing when its canceled ops finish",
>+			 job);
>+		job->free_when_canceled_ops_complete = TRUE;
>+		g_mutex_unlock (job->job_lock);
>+
>+		maybe_remove_job = TRUE;
> 		break;
> 	case GNOME_VFS_OP_CREATE:
> 		dispatch_create_callback (notify_result);
>+		if (notify_result->specifics.create.result != GNOME_VFS_OK)
>+			maybe_remove_job = TRUE;
> 		break;
> 	case GNOME_VFS_OP_CREATE_AS_CHANNEL:
> 		dispatch_create_as_channel_callback (notify_result);
>+		if (notify_result->specifics.create_as_channel.result != GNOME_VFS_OK)
>+			maybe_remove_job = TRUE;
> 		break;
> 	case GNOME_VFS_OP_CREATE_SYMBOLIC_LINK:
> 		dispatch_create_callback (notify_result);
>+		maybe_remove_job = TRUE;
> 		break;
> 	case GNOME_VFS_OP_FIND_DIRECTORY:
> 		dispatch_find_directory_callback (notify_result);
>+		maybe_remove_job = TRUE;
> 		break;
> 	case GNOME_VFS_OP_GET_FILE_INFO:
> 		dispatch_get_file_info_callback (notify_result);
>+		maybe_remove_job = TRUE;
> 		break;
> 	case GNOME_VFS_OP_LOAD_DIRECTORY:
> 		dispatch_load_directory_callback (notify_result);
>+		/* Since this operation invokes multiple callbacks, we
>+		 * can only free it when it returns anything other than
>+		 * GNOME_VFS_OK; that's when it is done emitting all the
>+		 * callbacks and thus terminated.
>+		 */
>+		if (notify_result->specifics.load_directory.result == GNOME_VFS_OK)
>+			free_op = FALSE;
>+		else {
>+			g_mutex_lock (job->job_lock);
>+			job->op = NULL;
>+			g_mutex_unlock (job->job_lock);
>+
>+			maybe_remove_job = TRUE;
>+		}
>+
> 		break;
> 	case GNOME_VFS_OP_OPEN:
> 		dispatch_open_callback (notify_result);
>+		if (notify_result->specifics.open.result != GNOME_VFS_OK)
>+			maybe_remove_job = TRUE;
> 		break;
> 	case GNOME_VFS_OP_OPEN_AS_CHANNEL:
> 		dispatch_open_as_channel_callback (notify_result);
>+		if (notify_result->specifics.open_as_channel.result != GNOME_VFS_OK)
>+			maybe_remove_job = TRUE;
> 		break;
> 	case GNOME_VFS_OP_READ:
> 		dispatch_read_callback (notify_result);
> 		break;
> 	case GNOME_VFS_OP_SET_FILE_INFO:
> 		dispatch_set_file_info_callback (notify_result);
>+		maybe_remove_job = TRUE;
> 		break;
> 	case GNOME_VFS_OP_WRITE:
> 		dispatch_write_callback (notify_result);
>@@ -588,7 +760,38 @@
> 	}
> 
> 	JOB_DEBUG (("dispatch callback - done %u", GPOINTER_TO_UINT (notify_result->job_handle)));
>-	_gnome_vfs_job_destroy_notify_result (notify_result);
>+
>+	if (free_op)
>+		gnome_vfs_op_destroy (notify_result->op);
>+
>+	_gnome_vfs_job_destroy_notify_result (notify_result, type);
>+
>+	if (maybe_remove_job) {
>+		g_mutex_lock (job->job_lock);
>+
>+		if (g_slist_length (job->canceled_ops) != 0) {
>+			maybe_remove_job = FALSE;
>+			fmq_log ("MAIN: Wanted to remove job %p, but it still has pending cancellations",
>+				 job);
>+		} else
>+			fmq_log ("MAIN: Will remove job %p",
>+				 job);
>+
>+		g_mutex_unlock (job->job_lock);
>+	} else {
>+		g_mutex_lock (job->job_lock);
>+
>+		if (job->free_when_canceled_ops_complete && g_slist_length (job->canceled_ops) == 0) {
>+			maybe_remove_job = TRUE;
>+			fmq_log ("MAIN: will remove job %p; it has no pending cancellations and is marked for destruction",
>+				 job);
>+		}
>+
>+		g_mutex_unlock (job->job_lock);
>+	}
>+
>+	if (maybe_remove_job)
>+		remove_and_free_job (job);
> 
> 	return FALSE;
> }
>@@ -601,22 +804,33 @@
> {
> 	GnomeVFSOp *op;
> 
>+	g_mutex_lock (job->job_lock);
>+
>+	if (job->op != NULL)
>+		g_error ("Cannot change the current operation of a running job; please cancel it first");
>+
> 	op = g_new (GnomeVFSOp, 1);
>+	op->job = job;
> 	op->type = type;
>+	op->canceled = FALSE;
> 	op->callback = callback;
> 	op->callback_data = callback_data;
> 	op->context = gnome_vfs_context_new ();
> 	op->stack_info = _gnome_vfs_module_callback_get_stack_info ();
> 
>+	fmq_log ("MAIN: _gnome_vfs_job_set(): job %p, job_handle %p, op %p, op type %d, user_callback %p, user_callback_data %p",
>+		 job,
>+		 job->job_handle,
>+		 op,
>+		 (int) type,
>+		 callback,
>+		 callback_data);
>+
> 	g_assert (gnome_vfs_context_get_cancellation (op->context) != NULL);
> 
> 	JOB_DEBUG (("locking access lock %u, op %d", GPOINTER_TO_UINT (job->job_handle), type));
> 
>-	g_mutex_lock (job->job_lock);
>-
>-	gnome_vfs_op_destroy (job->op);
> 	job->op = op;
>-	job->cancelled = FALSE;
> 
> 	g_mutex_unlock (job->job_lock);
> 
>@@ -643,6 +857,10 @@
> 
> 	job_count++;
> 
>+	fmq_log ("_gnome_vfs_job_new(): returning new job %p with op_type %d",
>+		 new_job,
>+		 type);
>+
> 	return new_job;
> }
> 
>@@ -651,6 +869,9 @@
> {
> 	JOB_DEBUG (("destroying job %u", GPOINTER_TO_UINT (job->job_handle)));
> 
>+	fmq_log ("_gnome_vfs_job_destroy(): job %p",
>+		 job);
>+
> 	gnome_vfs_op_destroy (job->op);
> 
> 	g_mutex_free (job->job_lock);
>@@ -725,7 +946,6 @@
> 	case GNOME_VFS_OP_WRITE:
> 	case GNOME_VFS_OP_SEEK:
> 	case GNOME_VFS_OP_CLOSE:
>-	case GNOME_VFS_OP_READ_WRITE_DONE:
> 		break;
> 	case GNOME_VFS_OP_FILE_CONTROL:
> 		g_free (op->specifics.file_control.operation);
>@@ -738,6 +958,8 @@
> 	
> 	gnome_vfs_context_free (op->context);
> 	_gnome_vfs_module_callback_free_stack_info (op->stack_info);
>+
>+	memset (op, 0xaa, sizeof (GnomeVFSOp));
> 	
> 	g_free (op);
> }
>@@ -949,41 +1171,39 @@
> /* Job execution.  This is performed by the slave thread.  */
> 
> static void
>-execute_open (GnomeVFSJob *job)
>+execute_open (GnomeVFSOp *op)
> {
> 	GnomeVFSResult result;
> 	GnomeVFSHandle *handle;
> 	GnomeVFSOpenOp *open_op;
> 	GnomeVFSNotifyResult *notify_result;
> 
>-	open_op = &job->op->specifics.open;
>+	open_op = &op->specifics.open;
> 
> 	if (open_op->uri == NULL) {
> 		result = GNOME_VFS_ERROR_INVALID_URI;
> 	} else {
> 		result = gnome_vfs_open_uri_cancellable (&handle, open_op->uri,
> 							  open_op->open_mode,
>-							  job->op->context);
>-		job->handle = handle;
>+							  op->context);
>+		op->job->handle = handle;
> 	}
> 	
> 	notify_result = g_new0 (GnomeVFSNotifyResult, 1);
>-	notify_result->job_handle = job->job_handle;
>-	notify_result->type = job->op->type;
>+	notify_result->op = op;
> 	notify_result->specifics.open.result = result;
>-	notify_result->specifics.open.callback = (GnomeVFSAsyncOpenCallback) job->op->callback;
>-	notify_result->specifics.open.callback_data = job->op->callback_data;
> 
>-	if (result != GNOME_VFS_OK) {
>-		/* if the open failed, just drop the job */
>-		job->failed = TRUE;
>-	}
>-	
>-	job_oneway_notify (job, notify_result);
>+	fmq_log ("WORKER: execute_open(): creating notify_result %p, job_handle %p, job %p, vfs_result %d",
>+		 notify_result,
>+		 notify_result->op->job->job_handle,
>+		 notify_result->op->job,
>+		 (int) result);
>+
>+	job_oneway_notify (notify_result);
> }
> 
> static void
>-execute_open_as_channel (GnomeVFSJob *job)
>+execute_open_as_channel (GnomeVFSOp *op)
> {
> 	GnomeVFSResult result;
> 	GnomeVFSHandle *handle;
>@@ -993,7 +1213,7 @@
> 	gint pipefd[2];
> 	GnomeVFSNotifyResult *notify_result;
> 
>-	open_as_channel_op = &job->op->specifics.open_as_channel;
>+	open_as_channel_op = &op->specifics.open_as_channel;
> 
> 	if (open_as_channel_op->uri == NULL) {
> 		result = GNOME_VFS_ERROR_INVALID_URI;
>@@ -1002,21 +1222,15 @@
> 			(&handle,
> 			 open_as_channel_op->uri,
> 			 open_as_channel_op->open_mode,
>-			 job->op->context);
>+			 op->context);
> 	}
> 
> 	notify_result = g_new0 (GnomeVFSNotifyResult, 1);
>-	notify_result->job_handle = job->job_handle;
>-	notify_result->type = job->op->type;
>+	notify_result->op = op;
> 	notify_result->specifics.open_as_channel.result = result;
>-	notify_result->specifics.open_as_channel.callback =
>-		(GnomeVFSAsyncOpenAsChannelCallback) job->op->callback;
>-	notify_result->specifics.open_as_channel.callback_data = job->op->callback_data;
> 
> 	if (result != GNOME_VFS_OK) {
>-		/* if the open failed, just drop the job */
>-		job->failed = TRUE;
>-		job_oneway_notify (job, notify_result);
>+		job_oneway_notify (notify_result);
> 		return;
> 	}
> 	
>@@ -1025,9 +1239,7 @@
> 		g_warning (_("Cannot create pipe for open GIOChannel: %s"),
> 			   g_strerror (errno));
> 		notify_result->specifics.open_as_channel.result = GNOME_VFS_ERROR_INTERNAL;
>-		/* if the open failed, just drop the job */
>-		job->failed = TRUE;
>-		job_oneway_notify (job, notify_result);
>+		job_oneway_notify (notify_result);
> 		return;
> 	}
> 
>@@ -1054,27 +1266,28 @@
> 
> 	notify_result->specifics.open_as_channel.result = GNOME_VFS_OK;
> 
>-	job_notify (job, notify_result);
>+	job_notify (notify_result);
>+	/* FMQ: who frees notify_result? */
> 
> 	if (open_mode & GNOME_VFS_OPEN_READ) {
> 		serve_channel_read (handle, channel_in, channel_out,
> 				    open_as_channel_op->advised_block_size,
>-				    job->op->context);
>+				    op->context);
> 	} else {
> 		serve_channel_write (handle, channel_in, channel_out,
>-				     job->op->context);
>+				     op->context);
> 	}
> }
> 
> static void
>-execute_create (GnomeVFSJob *job)
>+execute_create (GnomeVFSOp *op)
> {
> 	GnomeVFSResult result;
> 	GnomeVFSHandle *handle;
> 	GnomeVFSCreateOp *create_op;
> 	GnomeVFSNotifyResult *notify_result;
> 
>-	create_op = &job->op->specifics.create;
>+	create_op = &op->specifics.create;
> 
> 	if (create_op->uri == NULL) {
> 		result = GNOME_VFS_ERROR_INVALID_URI;
>@@ -1085,57 +1298,41 @@
> 			 create_op->open_mode,
> 			 create_op->exclusive,
> 			 create_op->perm,
>-			 job->op->context);
>+			 op->context);
> 		
>-		job->handle = handle;
>+		op->job->handle = handle;
> 	}
> 
> 	notify_result = g_new0 (GnomeVFSNotifyResult, 1);
>-	notify_result->job_handle = job->job_handle;
>-	notify_result->type = job->op->type;
>+	notify_result->op = op;
> 	notify_result->specifics.create.result = result;
>-	notify_result->specifics.create.callback = (GnomeVFSAsyncCreateCallback) job->op->callback;
>-	notify_result->specifics.create.callback_data = job->op->callback_data;
> 
>-	if (result != GNOME_VFS_OK) {
>-		/* if the open failed, just drop the job */
>-		job->failed = TRUE;
>-	}
>-
>-	job_oneway_notify (job, notify_result);
>+	job_oneway_notify (notify_result);
> }
> 
> static void
>-execute_create_symbolic_link (GnomeVFSJob *job)
>+execute_create_symbolic_link (GnomeVFSOp *op)
> {
> 	GnomeVFSResult result;
> 	GnomeVFSCreateLinkOp *create_op;
> 	GnomeVFSNotifyResult *notify_result;
> 
>-	create_op = &job->op->specifics.create_symbolic_link;
>+	create_op = &op->specifics.create_symbolic_link;
> 
> 	result = gnome_vfs_create_symbolic_link_cancellable
> 		(create_op->uri,
> 		 create_op->uri_reference,
>-		 job->op->context);
>+		 op->context);
> 
> 	notify_result = g_new0 (GnomeVFSNotifyResult, 1);
>-	notify_result->job_handle = job->job_handle;
>-	notify_result->type = job->op->type;
>+	notify_result->op = op;
> 	notify_result->specifics.create.result = result;
>-	notify_result->specifics.create.callback = (GnomeVFSAsyncCreateCallback) job->op->callback;
>-	notify_result->specifics.create.callback_data = job->op->callback_data;
> 
>-	if (result != GNOME_VFS_OK) {
>-		/* if the open failed, just drop the job */
>-		job->failed = TRUE;
>-	}
>-
>-	job_oneway_notify (job, notify_result);
>+	job_oneway_notify (notify_result);
> }
> 	
> static void
>-execute_create_as_channel (GnomeVFSJob *job)
>+execute_create_as_channel (GnomeVFSOp *op)
> {
> 	GnomeVFSResult result;
> 	GnomeVFSHandle *handle;
>@@ -1144,7 +1341,7 @@
> 	gint pipefd[2];
> 	GnomeVFSNotifyResult *notify_result;
> 
>-	create_as_channel_op = &job->op->specifics.create_as_channel;
>+	create_as_channel_op = &op->specifics.create_as_channel;
> 
> 	if (create_as_channel_op->uri == NULL) {
> 		result = GNOME_VFS_ERROR_INVALID_URI;
>@@ -1155,20 +1352,15 @@
> 			 create_as_channel_op->open_mode,
>                          create_as_channel_op->exclusive,
>                          create_as_channel_op->perm,
>-			 job->op->context);
>+			 op->context);
> 	}
> 	
> 	notify_result = g_new0 (GnomeVFSNotifyResult, 1);
>-	notify_result->job_handle = job->job_handle;
>-	notify_result->type = job->op->type;
>+	notify_result->op = op;
> 	notify_result->specifics.create_as_channel.result = result;
>-	notify_result->specifics.create_as_channel.callback = (GnomeVFSAsyncCreateAsChannelCallback) job->op->callback;
>-	notify_result->specifics.create_as_channel.callback_data = job->op->callback_data;
> 
> 	if (result != GNOME_VFS_OK) {
>-		/* if the open failed, just drop the job */
>-		job->failed = TRUE;
>-		job_oneway_notify (job, notify_result);
>+		job_oneway_notify (notify_result);
> 		return;
> 	}
> 
>@@ -1176,9 +1368,7 @@
> 		g_warning (_("Cannot create pipe for open GIOChannel: %s"),
> 			   g_strerror (errno));
> 		notify_result->specifics.create_as_channel.result = GNOME_VFS_ERROR_INTERNAL;
>-		/* if the open failed, just drop the job */
>-		job->failed = TRUE;
>-		job_oneway_notify (job, notify_result);
>+		job_oneway_notify (notify_result);
> 		return;
> 	}
> 	
>@@ -1192,124 +1382,104 @@
> 
> 	notify_result->specifics.create_as_channel.channel = channel_out;
> 
>-	job_notify (job, notify_result);
>+	job_notify (notify_result);
>+	_gnome_vfs_job_destroy_notify_result (notify_result, notify_result->op->type);
> 
>-	serve_channel_write (handle, channel_in, channel_out, job->op->context);
>+	serve_channel_write (handle, channel_in, channel_out, op->context);
> }
> 
> static void
>-execute_close (GnomeVFSJob *job)
>+execute_close (GnomeVFSOp *op)
> {
> 	GnomeVFSCloseOp *close_op;
> 	GnomeVFSNotifyResult *notify_result;
> 
>-	close_op = &job->op->specifics.close;
>+	close_op = &op->specifics.close;
> 
> 	notify_result = g_new0 (GnomeVFSNotifyResult, 1);
>-	notify_result->job_handle = job->job_handle;
>-	notify_result->type = job->op->type;
>-	notify_result->specifics.close.callback = (GnomeVFSAsyncCloseCallback) job->op->callback;
>-	notify_result->specifics.close.callback_data = job->op->callback_data;
>-	notify_result->specifics.close.result
>-		= gnome_vfs_close_cancellable (job->handle, job->op->context);
>+	notify_result->op = op;
>+	notify_result->specifics.close.result = gnome_vfs_close_cancellable (op->job->handle, op->context);
> 
>-	job_oneway_notify (job, notify_result);
>+	job_oneway_notify (notify_result);
> }
> 
> static void
>-execute_read (GnomeVFSJob *job)
>+execute_read (GnomeVFSOp *op)
> {
> 	GnomeVFSReadOp *read_op;
> 	GnomeVFSNotifyResult *notify_result;
> 	
>-	read_op = &job->op->specifics.read;
>+	read_op = &op->specifics.read;
> 
> 	notify_result = g_new0 (GnomeVFSNotifyResult, 1);
>-	notify_result->job_handle = job->job_handle;
>-	notify_result->type = job->op->type;
>-	notify_result->specifics.read.callback = (GnomeVFSAsyncReadCallback) job->op->callback;
>-	notify_result->specifics.read.callback_data = job->op->callback_data;
>+	notify_result->op = op;
> 	notify_result->specifics.read.buffer = read_op->buffer;
> 	notify_result->specifics.read.num_bytes = read_op->num_bytes;
> 	
>-	notify_result->specifics.read.result = gnome_vfs_read_cancellable (job->handle,
>+	notify_result->specifics.read.result = gnome_vfs_read_cancellable (op->job->handle,
> 									   read_op->buffer,
> 									   read_op->num_bytes,
> 									   &notify_result->specifics.read.bytes_read,
>-									   job->op->context);
>+									   op->context);
> 
>-	job->op->type = GNOME_VFS_OP_READ_WRITE_DONE;
>-
>-	job_oneway_notify (job, notify_result);
>+	job_oneway_notify (notify_result);
> }
> 
> static void
>-execute_write (GnomeVFSJob *job)
>+execute_write (GnomeVFSOp *op)
> {
> 	GnomeVFSWriteOp *write_op;
> 	GnomeVFSNotifyResult *notify_result;
> 	
>-	write_op = &job->op->specifics.write;
>+	write_op = &op->specifics.write;
> 
> 	notify_result = g_new0 (GnomeVFSNotifyResult, 1);
>-	notify_result->job_handle = job->job_handle;
>-	notify_result->type = job->op->type;
>-	notify_result->specifics.write.callback = (GnomeVFSAsyncWriteCallback) job->op->callback;
>-	notify_result->specifics.write.callback_data = job->op->callback_data;
>+	notify_result->op = op;
> 	notify_result->specifics.write.buffer = write_op->buffer;
> 	notify_result->specifics.write.num_bytes = write_op->num_bytes;
> 
>-	notify_result->specifics.write.result = gnome_vfs_write_cancellable (job->handle,
>+	notify_result->specifics.write.result = gnome_vfs_write_cancellable (op->job->handle,
> 									     write_op->buffer,
> 									     write_op->num_bytes,
> 									     &notify_result->specifics.write.bytes_written,
>-									     job->op->context);
>-
>-	job->op->type = GNOME_VFS_OP_READ_WRITE_DONE;
>+									     op->context);
> 
>-	job_oneway_notify (job, notify_result);
>+	job_oneway_notify (notify_result);
> }
> 
> static void
>-execute_seek (GnomeVFSJob *job)
>+execute_seek (GnomeVFSOp *op)
> {
> 	GnomeVFSResult result;
> 	GnomeVFSSeekOp *seek_op;
> 	GnomeVFSNotifyResult *notify_result;
> 
>-	seek_op = &job->op->specifics.seek;
>+	seek_op = &op->specifics.seek;
> 
>-	result = gnome_vfs_seek_cancellable (job->handle,
>+	result = gnome_vfs_seek_cancellable (op->job->handle,
> 					     seek_op->whence,
> 					     seek_op->offset,
>-					     job->op->context);
>+					     op->context);
> 
> 	notify_result = g_new0 (GnomeVFSNotifyResult, 1);
>-	notify_result->job_handle = job->job_handle;
>-	notify_result->type = job->op->type;
>+	notify_result->op = op;
> 	notify_result->specifics.seek.result = result;
>-	notify_result->specifics.seek.callback = (GnomeVFSAsyncSeekCallback) job->op->callback;
>-	notify_result->specifics.seek.callback_data = job->op->callback_data;
> 
>-	job_oneway_notify (job, notify_result);
>+	job_oneway_notify (notify_result);
> }
> 
> static void
>-execute_get_file_info (GnomeVFSJob *job)
>+execute_get_file_info (GnomeVFSOp *op)
> {
> 	GnomeVFSGetFileInfoOp *get_file_info_op;
> 	GList *p;
> 	GnomeVFSGetFileInfoResult *result_item;
> 	GnomeVFSNotifyResult *notify_result;
> 
>-	get_file_info_op = &job->op->specifics.get_file_info;
>+	get_file_info_op = &op->specifics.get_file_info;
> 
> 	notify_result = g_new0 (GnomeVFSNotifyResult, 1);
>-	notify_result->job_handle = job->job_handle;
>-	notify_result->type = job->op->type;
>-	notify_result->specifics.get_file_info.callback =
>-		(GnomeVFSAsyncGetFileInfoCallback) job->op->callback;
>-	notify_result->specifics.get_file_info.callback_data = job->op->callback_data;
>+	notify_result->op = op;
> 
> 	for (p = get_file_info_op->uris; p != NULL; p = p->next) {
> 		result_item = g_new (GnomeVFSGetFileInfoResult, 1);
>@@ -1321,7 +1491,7 @@
> 			(result_item->uri,
> 			 result_item->file_info,
> 			 get_file_info_op->options,
>-			 job->op->context);
>+			 op->context);
> 
> 		notify_result->specifics.get_file_info.result_list =
> 			g_list_prepend (notify_result->specifics.get_file_info.result_list, result_item);
>@@ -1329,30 +1499,24 @@
> 	notify_result->specifics.get_file_info.result_list =
> 		g_list_reverse (notify_result->specifics.get_file_info.result_list);
> 
>-	job_oneway_notify (job, notify_result);
>+	job_oneway_notify (notify_result);
> }
> 
> static void
>-execute_set_file_info (GnomeVFSJob *job)
>+execute_set_file_info (GnomeVFSOp *op)
> {
> 	GnomeVFSSetFileInfoOp *set_file_info_op;
> 	GnomeVFSURI *parent_uri, *uri_after;
> 	GnomeVFSNotifyResult *notify_result;
> 
>-	set_file_info_op = &job->op->specifics.set_file_info;
>+	set_file_info_op = &op->specifics.set_file_info;
> 
> 	notify_result = g_new0 (GnomeVFSNotifyResult, 1);
>-	notify_result->job_handle = job->job_handle;
>-	notify_result->type = job->op->type;
>-	notify_result->specifics.set_file_info.callback =
>-		(GnomeVFSAsyncSetFileInfoCallback) job->op->callback;
>-	notify_result->specifics.set_file_info.callback_data =
>-		job->op->callback_data;
>-
>+	notify_result->op = op;
> 	notify_result->specifics.set_file_info.set_file_info_result =
> 		gnome_vfs_set_file_info_cancellable (set_file_info_op->uri,
> 			set_file_info_op->info, set_file_info_op->mask,
>-		 	job->op->context);
>+		 	op->context);
> 
> 	/* Get the new URI after the set_file_info. The name may have
> 	 * changed.
>@@ -1382,29 +1546,29 @@
> 			(uri_after,
> 			 notify_result->specifics.set_file_info.info,
> 			 set_file_info_op->options,
>-			 job->op->context);
>+			 op->context);
> 		gnome_vfs_uri_unref (uri_after);
> 	}
> 
>-	job_oneway_notify (job, notify_result);
>+	job_oneway_notify (notify_result);
> }
> 
> static void
>-execute_find_directory (GnomeVFSJob *job)
>+execute_find_directory (GnomeVFSOp *op)
> {
> 	GnomeVFSFindDirectoryOp *find_directory_op;
> 	GList *p;
> 	GnomeVFSFindDirectoryResult *result_item;
> 	GnomeVFSNotifyResult *notify_result;
>+	gboolean cancelled;
> 
> 	notify_result = g_new0 (GnomeVFSNotifyResult, 1);
>-	notify_result->job_handle = job->job_handle;
>-	notify_result->type = job->op->type;
>-	notify_result->specifics.find_directory.callback
>-		= (GnomeVFSAsyncFindDirectoryCallback) job->op->callback;
>-	notify_result->specifics.find_directory.callback_data = job->op->callback_data;
>+	notify_result->op = op;
>+
>+	find_directory_op = &op->specifics.find_directory;
>+
>+	cancelled = FALSE;
> 
>-	find_directory_op = &job->op->specifics.find_directory;
> 	for (p = find_directory_op->uris; p != NULL; p = p->next) {
> 		result_item = g_new0 (GnomeVFSFindDirectoryResult, 1);
> 
>@@ -1415,19 +1579,28 @@
> 			 find_directory_op->create_if_needed,
> 			 find_directory_op->find_if_needed,
> 			 find_directory_op->permissions,
>-			 job->op->context);
>+			 op->context);
>+
>+		if (result_item->result == GNOME_VFS_ERROR_CANCELLED)
>+			cancelled = TRUE;
>+
> 		notify_result->specifics.find_directory.result_list =
> 			g_list_prepend (notify_result->specifics.find_directory.result_list, result_item);
> 	}
> 
> 	notify_result->specifics.find_directory.result_list =
> 		g_list_reverse (notify_result->specifics.find_directory.result_list);
>+
>+	if (cancelled)
>+		notify_result->specifics.find_directory.result = GNOME_VFS_ERROR_CANCELLED;
>+	else
>+		notify_result->specifics.find_directory.result = GNOME_VFS_OK;
> 	
>-	job_oneway_notify (job, notify_result);
>+	job_oneway_notify (notify_result);
> }
> 
> static void
>-load_directory_details (GnomeVFSJob *job)
>+execute_load_directory (GnomeVFSOp *op)
> {
> 	GnomeVFSLoadDirectoryOp *load_directory_op;
> 	GnomeVFSDirectoryHandle *handle;
>@@ -1437,8 +1610,8 @@
> 	guint count;
> 	GnomeVFSNotifyResult *notify_result;
> 
>-	JOB_DEBUG (("%u", GPOINTER_TO_UINT (job->job_handle)));
>-	load_directory_op = &job->op->specifics.load_directory;
>+	JOB_DEBUG (("%u", GPOINTER_TO_UINT (op->job->job_handle)));
>+	load_directory_op = &op->specifics.load_directory;
> 	
> 	if (load_directory_op->uri == NULL) {
> 		result = GNOME_VFS_ERROR_INVALID_URI;
>@@ -1447,18 +1620,14 @@
> 			(&handle,
> 			 load_directory_op->uri,
> 			 load_directory_op->options,
>-			 job->op->context);
>+			 op->context);
> 	}
> 
> 	if (result != GNOME_VFS_OK) {
> 		notify_result = g_new0 (GnomeVFSNotifyResult, 1);
>-		notify_result->job_handle = job->job_handle;
>-		notify_result->type = job->op->type;
>+		notify_result->op = op;
> 		notify_result->specifics.load_directory.result = result;
>-		notify_result->specifics.load_directory.callback =
>-			(GnomeVFSAsyncDirectoryLoadCallback) job->op->callback;
>-		notify_result->specifics.load_directory.callback_data = job->op->callback_data;
>-		job_oneway_notify (job, notify_result);
>+		job_oneway_notify (notify_result);
> 		return;
> 	}
> 
>@@ -1466,19 +1635,24 @@
> 
> 	count = 0;
> 	while (1) {
>-		if (gnome_vfs_context_check_cancellation (job->op->context)) {
>+		if (gnome_vfs_context_check_cancellation (op->context)) {
> 			JOB_DEBUG (("cancelled, bailing %u",
>-				    GPOINTER_TO_UINT (job->job_handle)));
>+				    GPOINTER_TO_UINT (op->job->job_handle)));
> 			gnome_vfs_file_info_list_free (directory_list);
> 			directory_list = NULL;
> 			result = GNOME_VFS_ERROR_CANCELLED;
>+
>+			notify_result = g_new0 (GnomeVFSNotifyResult, 1);
>+			notify_result->op = op;
>+			notify_result->specifics.load_directory.result = result;
>+			job_oneway_notify (notify_result);
>+
> 			break;
> 		}
> 
> 		info = gnome_vfs_file_info_new ();
> 
>-		result = gnome_vfs_directory_read_next_cancellable
>-			(handle, info, job->op->context);
>+		result = gnome_vfs_directory_read_next_cancellable (handle, info, op->context);
> 
> 		if (result == GNOME_VFS_OK) {
> 			directory_list = g_list_prepend (directory_list, info);
>@@ -1491,18 +1665,15 @@
> 			|| result != GNOME_VFS_OK) {
> 
> 			notify_result = g_new0 (GnomeVFSNotifyResult, 1);
>-			notify_result->job_handle = job->job_handle;
>-			notify_result->type = job->op->type;
>+			notify_result->op = op;
> 			notify_result->specifics.load_directory.result = result;
> 			notify_result->specifics.load_directory.entries_read = count;
> 			notify_result->specifics.load_directory.list = 
> 				g_list_reverse (directory_list);
>-			notify_result->specifics.load_directory.callback =
>-				(GnomeVFSAsyncDirectoryLoadCallback) job->op->callback;
>-			notify_result->specifics.load_directory.callback_data =
>-				job->op->callback_data;
> 
>-			job_oneway_notify (job, notify_result);
>+			job_oneway_notify (notify_result);
>+			fmq_log ("load_directory_details(): called job_oneway_notify() result %d",
>+				 (int) notify_result->specifics.load_directory.result);
> 
> 			count = 0;
> 			directory_list = NULL;
>@@ -1517,49 +1688,35 @@
> 	gnome_vfs_directory_close (handle);
> }
> 
>-static void
>-execute_load_directory (GnomeVFSJob *job)
>-{
>-	GnomeVFSLoadDirectoryOp *load_directory_op;
>-
>-	load_directory_op = &job->op->specifics.load_directory;
>-
>-	load_directory_details (job);
>-}
>-
> static gint
> xfer_callback (GnomeVFSXferProgressInfo *info,
> 	       gpointer data)
> {
>-	GnomeVFSJob *job;
>+	GnomeVFSOp *op;
> 	GnomeVFSNotifyResult notify_result;
> 
>-	job = (GnomeVFSJob *) data;
>+	op = (GnomeVFSOp *) data;
> 
> 	/* xfer is fully synchronous, just allocate the notify result struct on the stack */
>-	notify_result.job_handle = job->job_handle;
>-	notify_result.callback_id = 0;
>-	notify_result.cancelled = FALSE;
>-	notify_result.type = job->op->type;
>+	memset (&notify_result, 0, sizeof (notify_result));
>+	notify_result.op = op;
> 	notify_result.specifics.xfer.progress_info = info;
>-	notify_result.specifics.xfer.callback = (GnomeVFSAsyncXferProgressCallback) job->op->callback;
>-	notify_result.specifics.xfer.callback_data = job->op->callback_data;
> 
>-	job_notify (job, &notify_result);
>+	job_notify (&notify_result);
> 
> 	/* Pass the value returned from the callback in the master thread.  */
> 	return notify_result.specifics.xfer.reply;
> }
> 
> static void
>-execute_xfer (GnomeVFSJob *job)
>+execute_xfer (GnomeVFSOp *op)
> {
> 	GnomeVFSXferOp *xfer_op;
> 	GnomeVFSResult result;
> 	GnomeVFSXferProgressInfo info;
> 	GnomeVFSNotifyResult notify_result;
> 
>-	xfer_op = &job->op->specifics.xfer;
>+	xfer_op = &op->specifics.xfer;
> 
> 	result = _gnome_vfs_xfer_private (xfer_op->source_uri_list,
> 					 xfer_op->target_uri_list,
>@@ -1567,7 +1724,7 @@
> 					 xfer_op->error_mode,
> 					 xfer_op->overwrite_mode,
> 					 xfer_callback,
>-					 job,
>+					 op,
> 					 xfer_op->progress_sync_callback,
> 					 xfer_op->sync_callback_data);
> 
>@@ -1588,131 +1745,127 @@
> 		info.bytes_copied = 0;
> 		info.total_bytes_copied = 0;
> 
>-		notify_result.job_handle = job->job_handle;
>-		notify_result.callback_id = 0;
>-		notify_result.cancelled = FALSE;
>-		notify_result.type = job->op->type;
>+		memset (&notify_result, 0, sizeof (notify_result));
>+		notify_result.op = op;
> 		notify_result.specifics.xfer.progress_info = &info;
>-		notify_result.specifics.xfer.callback = (GnomeVFSAsyncXferProgressCallback) job->op->callback;
>-		notify_result.specifics.xfer.callback_data = job->op->callback_data;
> 
>-		job_notify (job, &notify_result);
>+		job_notify (&notify_result);
> 	}
> }
> 
> static void
>-execute_file_control (GnomeVFSJob *job)
>+execute_file_control (GnomeVFSOp *op)
> {
> 	GnomeVFSFileControlOp *file_control_op;
> 	GnomeVFSNotifyResult *notify_result;
> 	
>-	file_control_op = &job->op->specifics.file_control;
>+	file_control_op = &op->specifics.file_control;
> 
> 	notify_result = g_new0 (GnomeVFSNotifyResult, 1);
>-	notify_result->job_handle = job->job_handle;
>-	notify_result->type = job->op->type;
>-	notify_result->specifics.file_control.callback = (GnomeVFSAsyncFileControlCallback) job->op->callback;
>-	notify_result->specifics.file_control.callback_data = job->op->callback_data;
>+	notify_result->op = op;
> 	notify_result->specifics.file_control.operation_data = file_control_op->operation_data;
> 	notify_result->specifics.file_control.operation_data_destroy_func = file_control_op->operation_data_destroy_func;
> 	
>-	notify_result->specifics.file_control.result = gnome_vfs_file_control_cancellable (job->handle,
>+	notify_result->specifics.file_control.result = gnome_vfs_file_control_cancellable (op->job->handle,
> 											   file_control_op->operation,
> 											   file_control_op->operation_data,
>-											   job->op->context);
>+											   op->context);
> 
>-	job->op->type = GNOME_VFS_OP_FILE_CONTROL;
>-
>-	job_oneway_notify (job, notify_result);
>+	job_oneway_notify (notify_result);
> }
> 
>-
> /*
>  * _gnome_vfs_job_execute:
>- * @job: the job to execute
>+ * @op: the operation to execute
>  * 
>  *   This function is called by the slave thread to execute
>  * the job - all work performed by a thread starts here.
>  */
> void
>-_gnome_vfs_job_execute (GnomeVFSJob *job)
>+_gnome_vfs_job_execute (GnomeVFSOp *op)
> {
>-	guint id;
>+	JOB_DEBUG (("exec job %u", GPOINTER_TO_UINT (op->job->job_handle)));
> 
>-	id = GPOINTER_TO_UINT (job->job_handle);
>+	fmq_log ("WORKER: _gnome_vfs_job_execute(): job %p, job->cancelled = %d",
>+		 op->job,
>+		 (int) op->canceled);
> 
>-	JOB_DEBUG (("exec job %u", id));
>+	if (!op->canceled) {
>+		set_current_op (op);
> 
>-	if (!job->cancelled) {
>-		set_current_job (job);
>+		JOB_DEBUG (("executing %u %d type %s", GPOINTER_TO_UINT (op->job->job_handle), op->type,
>+			    JOB_DEBUG_TYPE (op->type)));
> 
>-		JOB_DEBUG (("executing %u %d type %s", id, job->op->type,
>-			    JOB_DEBUG_TYPE (job->op->type)));
>-
>-		switch (job->op->type) {
>+		switch (op->type) {
> 		case GNOME_VFS_OP_OPEN:
>-			execute_open (job);
>+			execute_open (op);
> 			break;
> 		case GNOME_VFS_OP_OPEN_AS_CHANNEL:
>-			execute_open_as_channel (job);
>+			execute_open_as_channel (op);
> 			break;
> 		case GNOME_VFS_OP_CREATE:
>-			execute_create (job);
>+			execute_create (op);
> 			break;
> 		case GNOME_VFS_OP_CREATE_AS_CHANNEL:
>-			execute_create_as_channel (job);
>+			execute_create_as_channel (op);
> 			break;
> 		case GNOME_VFS_OP_CREATE_SYMBOLIC_LINK:
>-			execute_create_symbolic_link (job);
>+			execute_create_symbolic_link (op);
> 			break;
> 		case GNOME_VFS_OP_CLOSE:
>-			execute_close (job);
>+			execute_close (op);
> 			break;
> 		case GNOME_VFS_OP_READ:
>-			execute_read (job);
>+			execute_read (op);
> 			break;
> 		case GNOME_VFS_OP_WRITE:
>-			execute_write (job);
>+			execute_write (op);
> 			break;
> 		case GNOME_VFS_OP_SEEK:
>-			execute_seek (job);
>+			execute_seek (op);
> 			break;
> 		case GNOME_VFS_OP_LOAD_DIRECTORY:
>-			execute_load_directory (job);
>+			execute_load_directory (op);
> 			break;
> 		case GNOME_VFS_OP_FIND_DIRECTORY:
>-			execute_find_directory (job);
>+			execute_find_directory (op);
> 			break;
> 		case GNOME_VFS_OP_XFER:
>-			execute_xfer (job);
>+			execute_xfer (op);
> 			break;
> 		case GNOME_VFS_OP_GET_FILE_INFO:
>-			execute_get_file_info (job);
>+			execute_get_file_info (op);
> 			break;
> 		case GNOME_VFS_OP_SET_FILE_INFO:
>-			execute_set_file_info (job);
>+			execute_set_file_info (op);
> 			break;
> 		case GNOME_VFS_OP_FILE_CONTROL:
>-			execute_file_control (job);
>+			execute_file_control (op);
> 			break;
> 		default:
>-			g_warning (_("Unknown job kind %u"), job->op->type);
>+			g_warning (_("Unknown job kind %u"), op->type);
> 			break;
> 		}
>-		/* NB. 'job' is quite probably invalid now */
>-		clear_current_job ();
>+
>+		clear_current_op ();
> 	} else {
>-		switch (job->op->type) {
>-		case GNOME_VFS_OP_READ:
>-		case GNOME_VFS_OP_WRITE:
>-			job->op->type = GNOME_VFS_OP_READ_WRITE_DONE;
>-			break;
>-		default:
>-			break;
>-		}
>+		GnomeVFSNotifyResult *notify_result;
>+
>+		notify_result = g_new0 (GnomeVFSNotifyResult, 1);
>+		notify_result->op = op;
>+
>+		/* Since LOAD_DIRECTORY can emit multiple notifications, we
>+		 * really need to know about its result, as the last
>+		 * notification for it is identified by !GNOME_VFS_OK.  It's not
>+		 * enough to test op->canceled.
>+		 */
>+		if (op->type == GNOME_VFS_OP_LOAD_DIRECTORY)
>+			notify_result->specifics.load_directory.result = GNOME_VFS_ERROR_CANCELLED;
>+
>+		job_oneway_notify (notify_result);
> 	}
> 	
>-	JOB_DEBUG (("done job %u", id));
>+	JOB_DEBUG (("done job %u", GPOINTER_TO_UINT (op->job->job_handle)));
> }
> 
> void
>@@ -1721,37 +1874,34 @@
> 	GnomeVFSCancellation *cancellation;
> 
> 	JOB_DEBUG (("%u", GPOINTER_TO_UINT (job->job_handle)));
>-	
>+
>+	g_mutex_lock (job->job_lock);
> 	cancellation = gnome_vfs_context_get_cancellation (job->op->context);
>+	g_mutex_unlock (job->job_lock);
>+
>+	fmq_log ("MAIN: _gnome_vfs_job_module_cancel(): canceling cancellation %p of job %p",
>+		 cancellation,
>+		 job);
> 	if (cancellation != NULL) {
> 		JOB_DEBUG (("cancelling %u", GPOINTER_TO_UINT (job->job_handle)));
> 		gnome_vfs_cancellation_cancel (cancellation);
> 	}
>-
>-#ifdef OLD_CONTEXT_DEPRECATED	
>-	gnome_vfs_context_emit_message (job->op->context, _("Operation stopped"));
>-#endif /* OLD_CONTEXT_DEPRECATED */
>-
>-	/* Since we are cancelling, we won't have anyone respond to notifications;
>-	 * set the expectations right.
>-	 */
>-	JOB_DEBUG (("done %u", GPOINTER_TO_UINT (job->job_handle)));
> }
> 
> static void
>-set_current_job (GnomeVFSJob *job)
>+set_current_op (GnomeVFSOp *op)
> {
> 	/* There shouldn't have been anything here. */
> 	g_assert (g_static_private_get (&job_private) == NULL);
> 
>-	g_static_private_set (&job_private, job, NULL);
>+	g_static_private_set (&job_private, op, NULL);
> 
>-	_gnome_vfs_module_callback_use_stack_info (job->op->stack_info);
>+	_gnome_vfs_module_callback_use_stack_info (op->stack_info);
> 	_gnome_vfs_module_callback_set_in_async_thread (TRUE);
> }
> 
> static void
>-clear_current_job (void)
>+clear_current_op (void)
> {
> 	g_static_private_set (&job_private, NULL, NULL);
> 
>@@ -1761,14 +1911,14 @@
> void
> _gnome_vfs_get_current_context (GnomeVFSContext **context)
> {
>-	GnomeVFSJob *job;
>+	GnomeVFSOp *op;
> 	
> 	g_return_if_fail (context != NULL);
> 
>-	job = g_static_private_get (&job_private);
>+	op = g_static_private_get (&job_private);
> 
>-	if (job != NULL) {
>-		*context = job->op->context;
>+	if (op != NULL) {
>+		*context = op->context;
> 	} else {
> 		*context = NULL;
> 	}
>@@ -1782,18 +1932,18 @@
> 				    GnomeVFSModuleCallbackResponse response,
> 				    gpointer response_data)
> {
>-	GnomeVFSJob *job;
>+	GnomeVFSOp *op;
> 	GnomeVFSNotifyResult notify_result;
> 
>-	job = g_static_private_get (&job_private);
>+	op = g_static_private_get (&job_private);
> 
>-	g_return_if_fail (job != NULL);
>+	g_return_if_fail (op != NULL);
> 
> 	memset (&notify_result, 0, sizeof (notify_result));
> 
>-	notify_result.job_handle = job->job_handle;
>+	notify_result.op = op;
> 
>-	notify_result.type = GNOME_VFS_OP_MODULE_CALLBACK;
>+	notify_result.is_module_callback = TRUE;
> 
> 	notify_result.specifics.callback.callback 	= callback;
> 	notify_result.specifics.callback.user_data 	= user_data;
>@@ -1806,5 +1956,5 @@
> 	notify_result.specifics.callback.response	= response;
> 	notify_result.specifics.callback.response_data 	= response_data;
> 
>-	job_notify (job, &notify_result);
>+	job_notify (&notify_result);
> }

Actions: View | Diff

Attachments on bug 114710: 48465 | 48643 | 48847 | 48851 | 48852 | 48853