From 185c4ac9c83aac035d2b49ecd95130aa5167e7c2 Mon Sep 17 00:00:00 2001 From: Tomas Bzatek Date: Tue, 25 Oct 2011 18:41:47 +0200 Subject: [PATCH 1/2] Adapt to glib mutex API changes A continuation to https://bugzilla.gnome.org/show_bug.cgi?id=661148 Upstream-Status: Backport Signed-off-by: Andreas Müller --- client/gvfsfusedaemon.c | 80 ++++++++--------- common/gmountsource.c | 60 ++++++------- daemon/gvfsbackendafc.c | 22 ++--- daemon/gvfsbackendftp.c | 12 +-- daemon/gvfsbackendftp.h | 4 +- daemon/gvfsbackendgphoto2.c | 112 +++++++++++------------- daemon/gvfsbackendnetwork.c | 10 +-- daemon/gvfsbackendobexftp.c | 187 ++++++++++++++++++++-------------------- daemon/gvfsbackendsmbbrowse.c | 39 ++++----- daemon/gvfsdaemon.c | 33 ++++---- daemon/gvfsftpdircache.c | 21 ++--- daemon/gvfsftptask.c | 33 ++++---- daemon/trashlib/trashexpunge.c | 33 ++++---- daemon/trashlib/trashitem.c | 36 ++++---- 14 files changed, 325 insertions(+), 357 deletions(-) diff --git a/client/gvfsfusedaemon.c b/client/gvfsfusedaemon.c index 7cfa81c..c986f69 100644 --- a/client/gvfsfusedaemon.c +++ b/client/gvfsfusedaemon.c @@ -69,7 +69,7 @@ typedef enum { typedef struct { gint refcount; - GMutex *mutex; + GMutex mutex; gchar *path; FileOp op; gpointer stream; @@ -84,13 +84,13 @@ static GVolumeMonitor *volume_monitor = NULL; /* Contains pointers to MountRecord */ static GList *mount_list = NULL; -static GMutex *mount_list_mutex; +static GMutex mount_list_mutex = {NULL}; static time_t daemon_creation_time; static uid_t daemon_uid; static gid_t daemon_gid; -static GStaticMutex global_mutex = G_STATIC_MUTEX_INIT; +static GMutex global_mutex = {NULL}; static GHashTable *global_path_to_fh_map = NULL; static GHashTable *global_active_fh_map = NULL; @@ -212,7 +212,6 @@ file_handle_new (const gchar *path) file_handle = g_new0 (FileHandle, 1); file_handle->refcount = 1; - file_handle->mutex = g_mutex_new (); file_handle->op = FILE_OP_NONE; file_handle->path = g_strdup (path); @@ -235,7 +234,7 @@ file_handle_unref (FileHandle *file_handle) { gint refs; - g_static_mutex_lock (&global_mutex); + g_mutex_lock (&global_mutex); /* Test again, since e.g. get_file_handle_for_path() might have * snatched the global mutex and revived the file handle between @@ -246,7 +245,7 @@ file_handle_unref (FileHandle *file_handle) if (refs == 0) g_hash_table_remove (global_path_to_fh_map, file_handle->path); - g_static_mutex_unlock (&global_mutex); + g_mutex_unlock (&global_mutex); } } @@ -283,7 +282,7 @@ file_handle_free (FileHandle *file_handle) g_hash_table_remove (global_active_fh_map, file_handle); file_handle_close_stream (file_handle); - g_mutex_free (file_handle->mutex); + g_mutex_clear (&file_handle->mutex); g_free (file_handle->path); g_free (file_handle); } @@ -293,14 +292,14 @@ get_file_handle_for_path (const gchar *path) { FileHandle *fh; - g_static_mutex_lock (&global_mutex); + g_mutex_lock (&global_mutex); fh = g_hash_table_lookup (global_path_to_fh_map, path); if (fh) file_handle_ref (fh); - g_static_mutex_unlock (&global_mutex); + g_mutex_unlock (&global_mutex); return fh; } @@ -309,7 +308,7 @@ get_or_create_file_handle_for_path (const gchar *path) { FileHandle *fh; - g_static_mutex_lock (&global_mutex); + g_mutex_lock (&global_mutex); fh = g_hash_table_lookup (global_path_to_fh_map, path); @@ -323,7 +322,7 @@ get_or_create_file_handle_for_path (const gchar *path) g_hash_table_insert (global_path_to_fh_map, fh->path, fh); } - g_static_mutex_unlock (&global_mutex); + g_mutex_unlock (&global_mutex); return fh; } @@ -332,7 +331,7 @@ get_file_handle_from_info (struct fuse_file_info *fi) { FileHandle *fh; - g_static_mutex_lock (&global_mutex); + g_mutex_lock (&global_mutex); fh = GET_FILE_HANDLE (fi); @@ -343,7 +342,7 @@ get_file_handle_from_info (struct fuse_file_info *fi) if (fh) file_handle_ref (fh); - g_static_mutex_unlock (&global_mutex); + g_mutex_unlock (&global_mutex); return fh; } @@ -353,7 +352,7 @@ reindex_file_handle_for_path (const gchar *old_path, const gchar *new_path) gchar *old_path_internal; FileHandle *fh; - g_static_mutex_lock (&global_mutex); + g_mutex_lock (&global_mutex); if (!g_hash_table_lookup_extended (global_path_to_fh_map, old_path, (gpointer *) &old_path_internal, @@ -368,7 +367,7 @@ reindex_file_handle_for_path (const gchar *old_path, const gchar *new_path) g_hash_table_insert (global_path_to_fh_map, fh->path, fh); out: - g_static_mutex_unlock (&global_mutex); + g_mutex_unlock (&global_mutex); } static MountRecord * @@ -405,13 +404,13 @@ mount_record_free (MountRecord *mount_record) static void mount_list_lock (void) { - g_mutex_lock (mount_list_mutex); + g_mutex_lock (&mount_list_mutex); } static void mount_list_unlock (void) { - g_mutex_unlock (mount_list_mutex); + g_mutex_unlock (&mount_list_mutex); } static void @@ -866,9 +865,9 @@ vfs_getattr (const gchar *path, struct stat *sbuf) if (fh != NULL) { - g_mutex_lock (fh->mutex); + g_mutex_lock (&fh->mutex); getattr_for_file_handle (fh, sbuf); - g_mutex_unlock (fh->mutex); + g_mutex_unlock (&fh->mutex); file_handle_unref (fh); result = 0; @@ -995,7 +994,7 @@ open_common (const gchar *path, struct fuse_file_info *fi, GFile *file, int outp gint result; FileHandle *fh = get_or_create_file_handle_for_path (path); - g_mutex_lock (fh->mutex); + g_mutex_lock (&fh->mutex); SET_FILE_HANDLE (fi, fh); @@ -1009,7 +1008,7 @@ open_common (const gchar *path, struct fuse_file_info *fi, GFile *file, int outp else result = setup_input_stream (file, fh); - g_mutex_unlock (fh->mutex); + g_mutex_unlock (&fh->mutex); /* The added reference to the file handle is released in vfs_release() */ return result; @@ -1121,7 +1120,7 @@ vfs_create (const gchar *path, mode_t mode, struct fuse_file_info *fi) /* Success */ - g_mutex_lock (fh->mutex); + g_mutex_lock (&fh->mutex); SET_FILE_HANDLE (fi, fh); @@ -1129,7 +1128,7 @@ vfs_create (const gchar *path, mode_t mode, struct fuse_file_info *fi) fh->stream = file_output_stream; fh->op = FILE_OP_WRITE; - g_mutex_unlock (fh->mutex); + g_mutex_unlock (&fh->mutex); /* The reference added to the file handle is released in vfs_release() */ } @@ -1285,7 +1284,7 @@ vfs_read (const gchar *path, gchar *buf, size_t size, if (fh) { - g_mutex_lock (fh->mutex); + g_mutex_lock (&fh->mutex); result = setup_input_stream (file, fh); @@ -1298,7 +1297,7 @@ vfs_read (const gchar *path, gchar *buf, size_t size, debug_print ("vfs_read: failed to setup input_stream!\n"); } - g_mutex_unlock (fh->mutex); + g_mutex_unlock (&fh->mutex); file_handle_unref (fh); } else @@ -1413,7 +1412,7 @@ vfs_write (const gchar *path, const gchar *buf, size_t len, off_t offset, if (fh) { - g_mutex_lock (fh->mutex); + g_mutex_lock (&fh->mutex); result = setup_output_stream (file, fh, 0); if (result == 0) @@ -1421,7 +1420,7 @@ vfs_write (const gchar *path, const gchar *buf, size_t len, off_t offset, result = write_stream (fh, buf, len, offset); } - g_mutex_unlock (fh->mutex); + g_mutex_unlock (&fh->mutex); file_handle_unref (fh); } else @@ -1453,9 +1452,9 @@ vfs_flush (const gchar *path, struct fuse_file_info *fi) if (fh) { - g_mutex_lock (fh->mutex); + g_mutex_lock (&fh->mutex); file_handle_close_stream (fh); - g_mutex_unlock (fh->mutex); + g_mutex_unlock (&fh->mutex); /* get_file_handle_from_info () adds a "working ref", so release that. */ file_handle_unref (fh); @@ -1474,9 +1473,9 @@ vfs_fsync (const gchar *path, gint sync_data_only, struct fuse_file_info *fi) if (fh) { - g_mutex_lock (fh->mutex); + g_mutex_lock (&fh->mutex); file_handle_close_stream (fh); - g_mutex_unlock (fh->mutex); + g_mutex_unlock (&fh->mutex); /* get_file_handle_from_info () adds a "working ref", so release that. */ file_handle_unref (fh); @@ -1625,7 +1624,7 @@ vfs_rename (const gchar *old_path, const gchar *new_path) if (fh) { - g_mutex_lock (fh->mutex); + g_mutex_lock (&fh->mutex); file_handle_close_stream (fh); } @@ -1645,7 +1644,7 @@ vfs_rename (const gchar *old_path, const gchar *new_path) if (fh) { - g_mutex_unlock (fh->mutex); + g_mutex_unlock (&fh->mutex); file_handle_unref (fh); } @@ -1687,7 +1686,7 @@ vfs_unlink (const gchar *path) if (fh) { - g_mutex_lock (fh->mutex); + g_mutex_lock (&fh->mutex); file_handle_close_stream (fh); } @@ -1695,7 +1694,7 @@ vfs_unlink (const gchar *path) if (fh) { - g_mutex_unlock (fh->mutex); + g_mutex_unlock (&fh->mutex); file_handle_unref (fh); } @@ -1864,7 +1863,7 @@ vfs_ftruncate (const gchar *path, off_t size, struct fuse_file_info *fi) if (fh) { - g_mutex_lock (fh->mutex); + g_mutex_lock (&fh->mutex); result = setup_output_stream (file, fh, 0); @@ -1909,7 +1908,7 @@ vfs_ftruncate (const gchar *path, off_t size, struct fuse_file_info *fi) } } - g_mutex_unlock (fh->mutex); + g_mutex_unlock (&fh->mutex); file_handle_unref (fh); } else @@ -1948,7 +1947,7 @@ vfs_truncate (const gchar *path, off_t size) /* Get a file handle just to lock the path while we're working */ fh = get_file_handle_for_path (path); if (fh) - g_mutex_lock (fh->mutex); + g_mutex_lock (&fh->mutex); if (size == 0) { @@ -1975,7 +1974,7 @@ vfs_truncate (const gchar *path, off_t size) if (fh) { - g_mutex_unlock (fh->mutex); + g_mutex_unlock (&fh->mutex); file_handle_unref (fh); } @@ -2315,7 +2314,6 @@ vfs_init (struct fuse_conn_info *conn) daemon_uid = getuid (); daemon_gid = getgid (); - mount_list_mutex = g_mutex_new (); global_path_to_fh_map = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, (GDestroyNotify) file_handle_free); global_active_fh_map = g_hash_table_new_full (g_direct_hash, g_direct_equal, @@ -2374,7 +2372,7 @@ vfs_destroy (gpointer param) mount_list_free (); if (subthread_main_loop != NULL) g_main_loop_quit (subthread_main_loop); - g_mutex_free (mount_list_mutex); + g_mutex_clear (&mount_list_mutex); g_object_unref (gvfs); } diff --git a/common/gmountsource.c b/common/gmountsource.c index d228726..af89ed2 100644 --- a/common/gmountsource.c +++ b/common/gmountsource.c @@ -27,6 +27,8 @@ #include #include +#include + struct _GMountSource { GObject parent_instance; @@ -137,8 +139,8 @@ typedef struct AskSyncData AskSyncData; struct AskSyncData { /* For sync calls */ - GMutex *mutex; - GCond *cond; + GMutex mutex; + GCond cond; /* results: */ GAsyncResult *result; @@ -356,9 +358,9 @@ ask_reply_sync (GObject *source_object, data->result = g_object_ref (res); /* Wake up sync call thread */ - g_mutex_lock (data->mutex); - g_cond_signal (data->cond); - g_mutex_unlock (data->mutex); + g_mutex_lock (&data->mutex); + g_cond_signal (&data->cond); + g_mutex_unlock (&data->mutex); } gboolean @@ -375,12 +377,10 @@ g_mount_source_ask_password (GMountSource *source, GPasswordSave *password_save_out) { gboolean handled; - AskSyncData data = {NULL}; - - data.mutex = g_mutex_new (); - data.cond = g_cond_new (); + AskSyncData data; - g_mutex_lock (data.mutex); + memset (&data, 0, sizeof (data)); + g_mutex_lock (&data.mutex); g_mount_source_ask_password_async (source, @@ -391,11 +391,11 @@ g_mount_source_ask_password (GMountSource *source, ask_reply_sync, &data); - g_cond_wait(data.cond, data.mutex); - g_mutex_unlock (data.mutex); + g_cond_wait (&data.cond, &data.mutex); + g_mutex_unlock (&data.mutex); - g_cond_free (data.cond); - g_mutex_free (data.mutex); + g_cond_clear (&data.cond); + g_mutex_clear (&data.mutex); handled = g_mount_source_ask_password_finish (source, @@ -546,12 +546,10 @@ g_mount_source_ask_question (GMountSource *source, { gint choice; gboolean handled, aborted; - AskSyncData data = {NULL}; + AskSyncData data; - data.mutex = g_mutex_new (); - data.cond = g_cond_new (); - - g_mutex_lock (data.mutex); + memset (&data, 0, sizeof (data)); + g_mutex_lock (&data.mutex); g_mount_source_ask_question_async (source, message, @@ -560,11 +558,11 @@ g_mount_source_ask_question (GMountSource *source, ask_reply_sync, &data); - g_cond_wait(data.cond, data.mutex); - g_mutex_unlock (data.mutex); + g_cond_wait (&data.cond, &data.mutex); + g_mutex_unlock (&data.mutex); - g_cond_free (data.cond); - g_mutex_free (data.mutex); + g_cond_clear (&data.cond); + g_mutex_clear (&data.mutex); handled = g_mount_source_ask_question_finish (source, data.result, @@ -841,12 +839,10 @@ g_mount_source_show_processes (GMountSource *source, { gint choice; gboolean handled, aborted; - AskSyncData data = {NULL}; - - data.mutex = g_mutex_new (); - data.cond = g_cond_new (); + AskSyncData data; - g_mutex_lock (data.mutex); + memset (&data, 0, sizeof (data)); + g_mutex_lock (&data.mutex); g_mount_source_show_processes_async (source, message, @@ -856,11 +852,11 @@ g_mount_source_show_processes (GMountSource *source, ask_reply_sync, &data); - g_cond_wait (data.cond, data.mutex); - g_mutex_unlock (data.mutex); + g_cond_wait (&data.cond, &data.mutex); + g_mutex_unlock (&data.mutex); - g_cond_free (data.cond); - g_mutex_free (data.mutex); + g_cond_clear (&data.cond); + g_mutex_clear (&data.mutex); handled = g_mount_source_show_processes_finish (source, data.result, diff --git a/daemon/gvfsbackendafc.c b/daemon/gvfsbackendafc.c index 16c8a23..84227ed 100644 --- a/daemon/gvfsbackendafc.c +++ b/daemon/gvfsbackendafc.c @@ -87,7 +87,7 @@ struct _GVfsBackendAfc { GHashTable *apps; /* hash table of AppInfo */ instproxy_client_t inst; sbservices_client_t sbs; - GMutex *apps_lock; + GMutex apps_lock; }; struct afc_error_mapping { @@ -182,11 +182,7 @@ g_vfs_backend_afc_close_connection (GVfsBackendAfc *self) sbservices_client_free (self->sbs); self->sbs = NULL; } - if (self->apps_lock) - { - g_mutex_free (self->apps_lock); - self->apps_lock = NULL; - } + g_mutex_clear (&self->apps_lock); } g_free (self->model); self->model = NULL; @@ -1910,14 +1906,14 @@ g_vfs_backend_afc_enumerate (GVfsBackend *backend, { char *app; - g_mutex_lock (self->apps_lock); + g_mutex_lock (&self->apps_lock); if (g_vfs_backend_load_apps (self) == FALSE) { g_vfs_backend_afc_check (AFC_E_INTERNAL_ERROR, G_VFS_JOB (job)); - g_mutex_unlock (self->apps_lock); + g_mutex_unlock (&self->apps_lock); return; } - g_mutex_unlock (self->apps_lock); + g_mutex_unlock (&self->apps_lock); app = g_vfs_backend_parse_house_arrest_path (self, TRUE, path, &new_path); @@ -2039,14 +2035,14 @@ g_vfs_backend_afc_query_info (GVfsBackend *backend, { char *app; - g_mutex_lock (self->apps_lock); + g_mutex_lock (&self->apps_lock); if (g_vfs_backend_load_apps (self) == FALSE) { g_vfs_backend_afc_check (AFC_E_INTERNAL_ERROR, G_VFS_JOB (job)); - g_mutex_unlock (self->apps_lock); + g_mutex_unlock (&self->apps_lock); return; } - g_mutex_unlock (self->apps_lock); + g_mutex_unlock (&self->apps_lock); app = g_vfs_backend_parse_house_arrest_path (self, TRUE, path, &new_path); @@ -2604,8 +2600,6 @@ g_vfs_backend_afc_init (GVfsBackendAfc *self) /* enable full debugging */ idevice_set_debug_level (1); } - - self->apps_lock = g_mutex_new (); } static void diff --git a/daemon/gvfsbackendftp.c b/daemon/gvfsbackendftp.c index 35e0b71..3883ca3 100644 --- a/daemon/gvfsbackendftp.c +++ b/daemon/gvfsbackendftp.c @@ -382,8 +382,8 @@ g_vfs_backend_ftp_finalize (GObject *object) /* has been cleared on unmount */ g_assert (ftp->queue == NULL); - g_cond_free (ftp->cond); - g_mutex_free (ftp->mutex); + g_cond_clear (&ftp->cond); + g_mutex_clear (&ftp->mutex); g_free (ftp->user); g_free (ftp->password); @@ -395,8 +395,6 @@ g_vfs_backend_ftp_finalize (GObject *object) static void g_vfs_backend_ftp_init (GVfsBackendFtp *ftp) { - ftp->mutex = g_mutex_new (); - ftp->cond = g_cond_new (); } static void @@ -698,7 +696,7 @@ do_unmount (GVfsBackend * backend, GVfsBackendFtp *ftp = G_VFS_BACKEND_FTP (backend); GVfsFtpConnection *conn; - g_mutex_lock (ftp->mutex); + g_mutex_lock (&ftp->mutex); while ((conn = g_queue_pop_head (ftp->queue))) { /* FIXME: properly quit */ @@ -706,8 +704,8 @@ do_unmount (GVfsBackend * backend, } g_queue_free (ftp->queue); ftp->queue = NULL; - g_cond_broadcast (ftp->cond); - g_mutex_unlock (ftp->mutex); + g_cond_broadcast (&ftp->cond); + g_mutex_unlock (&ftp->mutex); g_vfs_job_succeeded (G_VFS_JOB (job)); } diff --git a/daemon/gvfsbackendftp.h b/daemon/gvfsbackendftp.h index f5983b5..767ea35 100644 --- a/daemon/gvfsbackendftp.h +++ b/daemon/gvfsbackendftp.h @@ -100,8 +100,8 @@ struct _GVfsBackendFtp GVfsFtpDirCache * dir_cache; /* directory cache */ /* connection collection - accessed from gvfsftptask.c */ - GMutex * mutex; /* mutex protecting the following variables */ - GCond * cond; /* cond used to signal tasks waiting on the mutex */ + GMutex mutex; /* mutex protecting the following variables */ + GCond cond; /* cond used to signal tasks waiting on the mutex */ GQueue * queue; /* queue containing the connections */ guint connections; /* current number of connections */ guint busy_connections; /* current number of connections being used for reads/writes */ diff --git a/daemon/gvfsbackendgphoto2.c b/daemon/gvfsbackendgphoto2.c index 541dafe..9a1b6d8 100644 --- a/daemon/gvfsbackendgphoto2.c +++ b/daemon/gvfsbackendgphoto2.c @@ -207,7 +207,7 @@ struct _GVfsBackendGphoto2 * * Must only be held for very short amounts of time (e.g. no IO). */ - GMutex *lock; + GMutex lock; /* CACHES */ @@ -433,7 +433,7 @@ caches_invalidate_all (GVfsBackendGphoto2 *gphoto2_backend) { DEBUG ("caches_invalidate_all()"); - g_mutex_lock (gphoto2_backend->lock); + g_mutex_lock (&gphoto2_backend->lock); if (gphoto2_backend->dir_name_cache != NULL) g_hash_table_remove_all (gphoto2_backend->dir_name_cache); if (gphoto2_backend->file_name_cache != NULL) @@ -442,7 +442,7 @@ caches_invalidate_all (GVfsBackendGphoto2 *gphoto2_backend) g_hash_table_remove_all (gphoto2_backend->info_cache); gphoto2_backend->capacity = -1; gphoto2_backend->free_space = -1; - g_mutex_unlock (gphoto2_backend->lock); + g_mutex_unlock (&gphoto2_backend->lock); } /* ------------------------------------------------------------------------------------------------- */ @@ -450,9 +450,9 @@ caches_invalidate_all (GVfsBackendGphoto2 *gphoto2_backend) static void caches_invalidate_free_space (GVfsBackendGphoto2 *gphoto2_backend) { - g_mutex_lock (gphoto2_backend->lock); + g_mutex_lock (&gphoto2_backend->lock); gphoto2_backend->free_space = -1; - g_mutex_unlock (gphoto2_backend->lock); + g_mutex_unlock (&gphoto2_backend->lock); } /* ------------------------------------------------------------------------------------------------- */ @@ -461,11 +461,11 @@ static void caches_invalidate_dir (GVfsBackendGphoto2 *gphoto2_backend, const char *dir) { DEBUG ("caches_invalidate_dir() for '%s'", dir); - g_mutex_lock (gphoto2_backend->lock); + g_mutex_lock (&gphoto2_backend->lock); g_hash_table_remove (gphoto2_backend->dir_name_cache, dir); g_hash_table_remove (gphoto2_backend->file_name_cache, dir); g_hash_table_remove (gphoto2_backend->info_cache, dir); - g_mutex_unlock (gphoto2_backend->lock); + g_mutex_unlock (&gphoto2_backend->lock); } /* ------------------------------------------------------------------------------------------------- */ @@ -477,14 +477,14 @@ caches_invalidate_file (GVfsBackendGphoto2 *gphoto2_backend, const char *dir, co full_name = g_build_filename (dir, name, NULL); - g_mutex_lock (gphoto2_backend->lock); + g_mutex_lock (&gphoto2_backend->lock); /* this is essentially: caches_invalidate_dir (gphoto2_backend, dir); */ g_hash_table_remove (gphoto2_backend->dir_name_cache, dir); g_hash_table_remove (gphoto2_backend->file_name_cache, dir); g_hash_table_remove (gphoto2_backend->info_cache, dir); g_hash_table_remove (gphoto2_backend->info_cache, full_name); - g_mutex_unlock (gphoto2_backend->lock); + g_mutex_unlock (&gphoto2_backend->lock); DEBUG ("caches_invalidate_file() for '%s'", full_name); g_free (full_name); @@ -618,11 +618,7 @@ release_device (GVfsBackendGphoto2 *gphoto2_backend) g_list_free (gphoto2_backend->file_monitor_proxies); gphoto2_backend->file_monitor_proxies = NULL; - if (gphoto2_backend->lock != NULL) - { - g_mutex_free (gphoto2_backend->lock); - gphoto2_backend->lock = NULL; - } + g_mutex_clear (&gphoto2_backend->lock); gphoto2_backend->capacity = -1; gphoto2_backend->free_space = -1; } @@ -1099,17 +1095,17 @@ file_get_info (GVfsBackendGphoto2 *gphoto2_backend, /* first look up cache */ - g_mutex_lock (gphoto2_backend->lock); + g_mutex_lock (&gphoto2_backend->lock); cached_info = g_hash_table_lookup (gphoto2_backend->info_cache, full_path); if (cached_info != NULL) { g_file_info_copy_into (cached_info, info); - g_mutex_unlock (gphoto2_backend->lock); + g_mutex_unlock (&gphoto2_backend->lock); DEBUG (" Using cached info %p for '%s'", cached_info, full_path); ret = TRUE; goto out; } - g_mutex_unlock (gphoto2_backend->lock); + g_mutex_unlock (&gphoto2_backend->lock); if (try_cache_only) goto out; @@ -1307,9 +1303,9 @@ file_get_info (GVfsBackendGphoto2 *gphoto2_backend, #ifndef DEBUG_NO_CACHING cached_info = g_file_info_dup (info); DEBUG (" Storing cached info %p for '%s'", cached_info, full_path); - g_mutex_lock (gphoto2_backend->lock); + g_mutex_lock (&gphoto2_backend->lock); g_hash_table_insert (gphoto2_backend->info_cache, g_strdup (full_path), cached_info); - g_mutex_unlock (gphoto2_backend->lock); + g_mutex_unlock (&gphoto2_backend->lock); #endif } @@ -1716,8 +1712,6 @@ do_mount (GVfsBackend *backend, gphoto2_backend->free_space = -1; - gphoto2_backend->lock = g_mutex_new (); - gphoto2_mount_spec = g_mount_spec_new ("gphoto2"); g_mount_spec_set (gphoto2_mount_spec, "host", host); g_vfs_backend_set_mount_spec (backend, gphoto2_mount_spec); @@ -1860,9 +1854,9 @@ do_open_for_read_real (GVfsBackend *backend, DEBUG (" data=%p size=%ld handle=%p get_preview=%d", read_handle->data, read_handle->size, read_handle, get_preview); - g_mutex_lock (gphoto2_backend->lock); + g_mutex_lock (&gphoto2_backend->lock); gphoto2_backend->open_read_handles = g_list_prepend (gphoto2_backend->open_read_handles, read_handle); - g_mutex_unlock (gphoto2_backend->lock); + g_mutex_unlock (&gphoto2_backend->lock); read_handle->cursor = 0; @@ -2008,9 +2002,9 @@ do_close_read (GVfsBackend *backend, DEBUG ("close_read() handle=%p", handle); - g_mutex_lock (gphoto2_backend->lock); + g_mutex_lock (&gphoto2_backend->lock); gphoto2_backend->open_read_handles = g_list_remove (gphoto2_backend->open_read_handles, read_handle); - g_mutex_unlock (gphoto2_backend->lock); + g_mutex_unlock (&gphoto2_backend->lock); free_read_handle (read_handle); @@ -2140,11 +2134,11 @@ do_enumerate (GVfsBackend *backend, g_free (as_name); /* first, list the folders */ - g_mutex_lock (gphoto2_backend->lock); + g_mutex_lock (&gphoto2_backend->lock); list = g_hash_table_lookup (gphoto2_backend->dir_name_cache, filename); if (list == NULL) { - g_mutex_unlock (gphoto2_backend->lock); + g_mutex_unlock (&gphoto2_backend->lock); ensure_not_dirty (gphoto2_backend); @@ -2169,7 +2163,7 @@ do_enumerate (GVfsBackend *backend, DEBUG (" Using cached dir list for dir '%s'", filename); using_cached_dir_list = TRUE; gp_list_ref (list); - g_mutex_unlock (gphoto2_backend->lock); + g_mutex_unlock (&gphoto2_backend->lock); } for (n = 0; n < gp_list_count (list); n++) { @@ -2193,25 +2187,25 @@ do_enumerate (GVfsBackend *backend, if (!using_cached_dir_list) { #ifndef DEBUG_NO_CACHING - g_mutex_lock (gphoto2_backend->lock); + g_mutex_lock (&gphoto2_backend->lock); g_hash_table_insert (gphoto2_backend->dir_name_cache, g_strdup (filename), list); - g_mutex_unlock (gphoto2_backend->lock); + g_mutex_unlock (&gphoto2_backend->lock); #endif } else { - g_mutex_lock (gphoto2_backend->lock); + g_mutex_lock (&gphoto2_backend->lock); gp_list_unref (list); - g_mutex_unlock (gphoto2_backend->lock); + g_mutex_unlock (&gphoto2_backend->lock); } /* then list the files in each folder */ - g_mutex_lock (gphoto2_backend->lock); + g_mutex_lock (&gphoto2_backend->lock); list = g_hash_table_lookup (gphoto2_backend->file_name_cache, filename); if (list == NULL) { - g_mutex_unlock (gphoto2_backend->lock); + g_mutex_unlock (&gphoto2_backend->lock); ensure_not_dirty (gphoto2_backend); DEBUG (" Generating file list for dir '%s'", filename); @@ -2235,7 +2229,7 @@ do_enumerate (GVfsBackend *backend, DEBUG (" Using cached file list for dir '%s'", filename); using_cached_file_list = TRUE; gp_list_ref (list); - g_mutex_unlock (gphoto2_backend->lock); + g_mutex_unlock (&gphoto2_backend->lock); } for (n = 0; n < gp_list_count (list); n++) { @@ -2260,16 +2254,16 @@ do_enumerate (GVfsBackend *backend, if (!using_cached_file_list) { #ifndef DEBUG_NO_CACHING - g_mutex_lock (gphoto2_backend->lock); + g_mutex_lock (&gphoto2_backend->lock); g_hash_table_insert (gphoto2_backend->file_name_cache, g_strdup (filename), list); - g_mutex_unlock (gphoto2_backend->lock); + g_mutex_unlock (&gphoto2_backend->lock); #endif } else { - g_mutex_lock (gphoto2_backend->lock); + g_mutex_lock (&gphoto2_backend->lock); gp_list_unref (list); - g_mutex_unlock (gphoto2_backend->lock); + g_mutex_unlock (&gphoto2_backend->lock); } /* and we're done */ @@ -2307,15 +2301,15 @@ try_enumerate (GVfsBackend *backend, DEBUG ("try_enumerate (%s)", given_filename); /* first, list the folders */ - g_mutex_lock (gphoto2_backend->lock); + g_mutex_lock (&gphoto2_backend->lock); list = g_hash_table_lookup (gphoto2_backend->dir_name_cache, filename); if (list == NULL) { - g_mutex_unlock (gphoto2_backend->lock); + g_mutex_unlock (&gphoto2_backend->lock); goto error_not_cached; } gp_list_ref (list); - g_mutex_unlock (gphoto2_backend->lock); + g_mutex_unlock (&gphoto2_backend->lock); for (n = 0; n < gp_list_count (list); n++) { gp_list_get_name (list, n, &name); @@ -2323,27 +2317,27 @@ try_enumerate (GVfsBackend *backend, info = g_file_info_new (); if (!file_get_info (gphoto2_backend, filename, name, info, &error, TRUE)) { - g_mutex_lock (gphoto2_backend->lock); + g_mutex_lock (&gphoto2_backend->lock); gp_list_unref (list); - g_mutex_unlock (gphoto2_backend->lock); + g_mutex_unlock (&gphoto2_backend->lock); goto error_not_cached; } l = g_list_append (l, info); } - g_mutex_lock (gphoto2_backend->lock); + g_mutex_lock (&gphoto2_backend->lock); gp_list_unref (list); - g_mutex_unlock (gphoto2_backend->lock); + g_mutex_unlock (&gphoto2_backend->lock); /* then list the files in each folder */ - g_mutex_lock (gphoto2_backend->lock); + g_mutex_lock (&gphoto2_backend->lock); list = g_hash_table_lookup (gphoto2_backend->file_name_cache, filename); if (list == NULL) { - g_mutex_unlock (gphoto2_backend->lock); + g_mutex_unlock (&gphoto2_backend->lock); goto error_not_cached; } gp_list_ref (list); - g_mutex_unlock (gphoto2_backend->lock); + g_mutex_unlock (&gphoto2_backend->lock); for (n = 0; n < gp_list_count (list); n++) { gp_list_get_name (list, n, &name); @@ -2352,16 +2346,16 @@ try_enumerate (GVfsBackend *backend, info = g_file_info_new (); if (!file_get_info (gphoto2_backend, filename, name, info, &error, TRUE)) { - g_mutex_lock (gphoto2_backend->lock); + g_mutex_lock (&gphoto2_backend->lock); gp_list_unref (list); - g_mutex_unlock (gphoto2_backend->lock); + g_mutex_unlock (&gphoto2_backend->lock); goto error_not_cached; } l = g_list_append (l, info); } - g_mutex_lock (gphoto2_backend->lock); + g_mutex_lock (&gphoto2_backend->lock); gp_list_unref (list); - g_mutex_unlock (gphoto2_backend->lock); + g_mutex_unlock (&gphoto2_backend->lock); /* and we're done */ @@ -2412,9 +2406,9 @@ do_query_fs_info (GVfsBackend *backend, /* for now we only support a single storage head */ if (storage_info[0].fields & GP_STORAGEINFO_MAXCAPACITY) { - g_mutex_lock (gphoto2_backend->lock); + g_mutex_lock (&gphoto2_backend->lock); gphoto2_backend->capacity = storage_info[0].capacitykbytes * 1024; - g_mutex_unlock (gphoto2_backend->lock); + g_mutex_unlock (&gphoto2_backend->lock); g_file_info_set_attribute_uint64 (info, G_FILE_ATTRIBUTE_FILESYSTEM_SIZE, (guint64) gphoto2_backend->capacity); @@ -2422,9 +2416,9 @@ do_query_fs_info (GVfsBackend *backend, if (storage_info[0].fields & GP_STORAGEINFO_FREESPACEKBYTES) { - g_mutex_lock (gphoto2_backend->lock); + g_mutex_lock (&gphoto2_backend->lock); gphoto2_backend->free_space = storage_info[0].freekbytes * 1024; - g_mutex_unlock (gphoto2_backend->lock); + g_mutex_unlock (&gphoto2_backend->lock); g_file_info_set_attribute_uint64 (info, G_FILE_ATTRIBUTE_FILESYSTEM_FREE, (guint64) gphoto2_backend->free_space); @@ -2454,10 +2448,10 @@ try_query_fs_info (GVfsBackend *backend, ret = FALSE; - g_mutex_lock (gphoto2_backend->lock); + g_mutex_lock (&gphoto2_backend->lock); free_space = gphoto2_backend->free_space; capacity = gphoto2_backend->capacity; - g_mutex_unlock (gphoto2_backend->lock); + g_mutex_unlock (&gphoto2_backend->lock); if (free_space == -1 || capacity == -1) { diff --git a/daemon/gvfsbackendnetwork.c b/daemon/gvfsbackendnetwork.c index 80273e5..3c38514 100644 --- a/daemon/gvfsbackendnetwork.c +++ b/daemon/gvfsbackendnetwork.c @@ -65,7 +65,7 @@ struct _GVfsBackendNetwork gboolean have_smb; char *current_workgroup; GFileMonitor *smb_monitor; - GMutex *smb_mount_lock; + GMutex smb_mount_lock; GVfsJobMount *mount_job; /* DNS-SD Stuff */ @@ -433,7 +433,7 @@ mount_smb_done_cb (GObject *object, g_vfs_job_succeeded (G_VFS_JOB (backend->mount_job)); g_object_unref (backend->mount_job); } - g_mutex_unlock (backend->smb_mount_lock); + g_mutex_unlock (&backend->smb_mount_lock); } static void @@ -442,7 +442,7 @@ remount_smb (GVfsBackendNetwork *backend, GVfsJobMount *job) GFile *file; char *workgroup; - if (! g_mutex_trylock (backend->smb_mount_lock)) + if (! g_mutex_trylock (&backend->smb_mount_lock)) /* Do nothing when the mount operation is already active */ return; @@ -769,8 +769,6 @@ g_vfs_backend_network_init (GVfsBackendNetwork *network_backend) const char * const* supported_vfs; int i; - network_backend->smb_mount_lock = g_mutex_new (); - supported_vfs = g_vfs_get_supported_uri_schemes (g_vfs_get_default ()); network_backend->have_smb = FALSE; @@ -836,7 +834,7 @@ g_vfs_backend_network_finalize (GObject *object) GVfsBackendNetwork *backend; backend = G_VFS_BACKEND_NETWORK (object); - g_mutex_free (backend->smb_mount_lock); + g_mutex_clear (&backend->smb_mount_lock); g_mount_spec_unref (backend->mount_spec); g_object_unref (backend->root_monitor); g_object_unref (backend->workgroup_icon); diff --git a/daemon/gvfsbackendobexftp.c b/daemon/gvfsbackendobexftp.c index 9630df8..62fe32f 100644 --- a/daemon/gvfsbackendobexftp.c +++ b/daemon/gvfsbackendobexftp.c @@ -85,8 +85,8 @@ struct _GVfsBackendObexftp DBusGProxy *session_proxy; /* Use for the async notifications and errors */ - GCond *cond; - GMutex *mutex; + GCond cond; + GMutex mutex; int status; gboolean doing_io; GError *error; @@ -494,8 +494,8 @@ g_vfs_backend_obexftp_finalize (GObject *object) if (backend->session_proxy != NULL) g_object_unref (backend->session_proxy); - g_mutex_free (backend->mutex); - g_cond_free (backend->cond); + g_mutex_clear (&backend->mutex); + g_cond_clear (&backend->cond); if (G_OBJECT_CLASS (g_vfs_backend_obexftp_parent_class)->finalize) (*G_OBJECT_CLASS (g_vfs_backend_obexftp_parent_class)->finalize) (object); @@ -530,8 +530,6 @@ g_vfs_backend_obexftp_init (GVfsBackendObexftp *backend) return; } - backend->mutex = g_mutex_new (); - backend->cond = g_cond_new (); backend->manager_proxy = dbus_g_proxy_new_for_name (backend->connection, "org.openobex", "/org/openobex", @@ -759,18 +757,18 @@ error_occurred_cb (DBusGProxy *proxy, const gchar *error_name, const gchar *erro } /* Something is waiting on us */ - g_mutex_lock (op_backend->mutex); + g_mutex_lock (&op_backend->mutex); if (op_backend->doing_io) { op_backend->status = ASYNC_ERROR; op_backend->error = g_error_new_literal (DBUS_GERROR, DBUS_GERROR_REMOTE_EXCEPTION, error_message); - g_cond_signal (op_backend->cond); - g_mutex_unlock (op_backend->mutex); + g_cond_signal (&op_backend->cond); + g_mutex_unlock (&op_backend->mutex); return; } - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_message ("Unhandled error, file a bug"); _exit (1); @@ -785,13 +783,13 @@ session_connect_error_cb (DBusGProxy *proxy, { GVfsBackendObexftp *op_backend = G_VFS_BACKEND_OBEXFTP (user_data); - g_mutex_lock (op_backend->mutex); + g_mutex_lock (&op_backend->mutex); op_backend->status = ASYNC_ERROR; op_backend->error = g_error_new_literal (DBUS_GERROR, DBUS_GERROR_REMOTE_EXCEPTION, error_message); - g_cond_signal (op_backend->cond); - g_mutex_unlock (op_backend->mutex); + g_cond_signal (&op_backend->cond); + g_mutex_unlock (&op_backend->mutex); } static void @@ -801,10 +799,10 @@ session_connected_cb (DBusGProxy *proxy, { GVfsBackendObexftp *op_backend = G_VFS_BACKEND_OBEXFTP (user_data); - g_mutex_lock (op_backend->mutex); + g_mutex_lock (&op_backend->mutex); op_backend->status = ASYNC_SUCCESS; - g_cond_signal (op_backend->cond); - g_mutex_unlock (op_backend->mutex); + g_cond_signal (&op_backend->cond); + g_mutex_unlock (&op_backend->mutex); } static void @@ -814,10 +812,10 @@ cancelled_cb (DBusGProxy *proxy, gpointer user_data) g_message ("transfer got cancelled"); - g_mutex_lock (op_backend->mutex); + g_mutex_lock (&op_backend->mutex); op_backend->status = ASYNC_ERROR; - g_cond_signal (op_backend->cond); - g_mutex_unlock (op_backend->mutex); + g_cond_signal (&op_backend->cond); + g_mutex_unlock (&op_backend->mutex); } static void @@ -979,17 +977,16 @@ do_mount (GVfsBackend *backend, /* Now wait until the device is connected */ count = 0; - g_mutex_lock (op_backend->mutex); + g_mutex_lock (&op_backend->mutex); while (op_backend->status == ASYNC_PENDING && count < 100) { - GTimeVal val; - g_get_current_time (&val); - g_time_val_add (&val, 100000); + gint64 end_time; + end_time = g_get_monotonic_time () + 100 * G_TIME_SPAN_MILLISECOND; count++; - if (g_cond_timed_wait (op_backend->cond, op_backend->mutex, &val) != FALSE) + if (g_cond_wait_until (&op_backend->cond, &op_backend->mutex, end_time) != FALSE) break; } - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); if (op_backend->status == ASYNC_ERROR || op_backend->status == ASYNC_PENDING) { @@ -1026,10 +1023,10 @@ transfer_started_cb (DBusGProxy *proxy, const gchar *filename, g_message ("transfer of %s to %s started", filename, local_path); - g_mutex_lock (op_backend->mutex); + g_mutex_lock (&op_backend->mutex); op_backend->status = ASYNC_SUCCESS; - g_cond_signal (op_backend->cond); - g_mutex_unlock (op_backend->mutex); + g_cond_signal (&op_backend->cond); + g_mutex_unlock (&op_backend->mutex); } static void @@ -1047,7 +1044,7 @@ do_open_for_read (GVfsBackend *backend, g_debug ("+ do_open_for_read, filename: %s\n", filename); - g_mutex_lock (op_backend->mutex); + g_mutex_lock (&op_backend->mutex); op_backend->doing_io = TRUE; /* Change into the directory and cache the file size */ @@ -1055,7 +1052,7 @@ do_open_for_read (GVfsBackend *backend, if (_query_file_info_helper (backend, filename, info, &error) == FALSE) { op_backend->doing_io = FALSE; - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_vfs_job_failed_from_error (G_VFS_JOB (job), error); g_error_free (error); g_object_unref (info); @@ -1065,7 +1062,7 @@ do_open_for_read (GVfsBackend *backend, if (g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY) { op_backend->doing_io = FALSE; - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_vfs_job_failed (G_VFS_JOB (job), G_IO_ERROR, G_IO_ERROR_IS_DIRECTORY, _("Can't open directory")); @@ -1079,7 +1076,7 @@ do_open_for_read (GVfsBackend *backend, if (g_vfs_job_is_cancelled (G_VFS_JOB (job))) { op_backend->doing_io = FALSE; - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_vfs_job_failed (G_VFS_JOB (job), G_IO_ERROR, G_IO_ERROR_CANCELLED, _("Operation was cancelled")); @@ -1091,7 +1088,7 @@ do_open_for_read (GVfsBackend *backend, if (fd < 0) { op_backend->doing_io = FALSE; - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_vfs_job_failed_from_error (G_VFS_JOB (job), error); g_error_free (error); return; @@ -1100,7 +1097,7 @@ do_open_for_read (GVfsBackend *backend, if (g_vfs_job_is_cancelled (G_VFS_JOB (job))) { op_backend->doing_io = FALSE; - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_vfs_job_failed (G_VFS_JOB (job), G_IO_ERROR, G_IO_ERROR_CANCELLED, _("Operation was cancelled")); @@ -1134,13 +1131,13 @@ do_open_for_read (GVfsBackend *backend, close (fd); op_backend->doing_io = FALSE; - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); return; } /* Wait for TransferStarted or ErrorOccurred to have happened */ while (op_backend->status == ASYNC_PENDING) - g_cond_wait (op_backend->cond, op_backend->mutex); + g_cond_wait (&op_backend->cond, &op_backend->mutex); success = op_backend->status; dbus_g_proxy_disconnect_signal(op_backend->session_proxy, "TransferStarted", G_CALLBACK(transfer_started_cb), op_backend); @@ -1158,7 +1155,7 @@ do_open_for_read (GVfsBackend *backend, if (success == ASYNC_ERROR) { op_backend->doing_io = FALSE; - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); close (fd); g_vfs_job_failed_from_error (G_VFS_JOB (job), op_backend->error); @@ -1179,7 +1176,7 @@ do_open_for_read (GVfsBackend *backend, g_vfs_job_succeeded (G_VFS_JOB (job)); op_backend->doing_io = FALSE; - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); } static int @@ -1266,7 +1263,7 @@ do_close_read (GVfsBackend *backend, return; } - g_mutex_lock (op_backend->mutex); + g_mutex_lock (&op_backend->mutex); if (busy > 0) { @@ -1276,11 +1273,11 @@ do_close_read (GVfsBackend *backend, G_TYPE_INVALID, G_TYPE_INVALID) != FALSE) { while (op_backend->status == ASYNC_PENDING) - g_cond_wait (op_backend->cond, op_backend->mutex); + g_cond_wait (&op_backend->cond, &op_backend->mutex); } } - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); close (backend_handle->fd); g_free (backend_handle->source); @@ -1304,17 +1301,17 @@ do_query_info (GVfsBackend *backend, g_debug ("+ do_query_info, filename: %s\n", filename); - g_mutex_lock (op_backend->mutex); + g_mutex_lock (&op_backend->mutex); if (_query_file_info_helper (backend, filename, info, &error) == FALSE) { - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_vfs_job_failed_from_error (G_VFS_JOB (job), error); g_error_free (error); return; } - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_vfs_job_succeeded (G_VFS_JOB (job)); @@ -1341,14 +1338,14 @@ do_query_fs_info (GVfsBackend *backend, g_debug ("+ do_query_fs_info, filename: %s\n", filename); - g_mutex_lock (op_backend->mutex); + g_mutex_lock (&op_backend->mutex); /* Get the capabilities */ if (dbus_g_proxy_call (op_backend->session_proxy, "GetCapability", &error, G_TYPE_INVALID, G_TYPE_STRING, &caps_str, G_TYPE_INVALID) == FALSE) { - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_vfs_job_failed_from_error (G_VFS_JOB (job), error); g_error_free (error); return; @@ -1356,7 +1353,7 @@ do_query_fs_info (GVfsBackend *backend, if (g_vfs_job_is_cancelled (G_VFS_JOB (job))) { - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_vfs_job_failed (G_VFS_JOB (job), G_IO_ERROR, G_IO_ERROR_CANCELLED, _("Operation was cancelled")); @@ -1368,7 +1365,7 @@ do_query_fs_info (GVfsBackend *backend, if (caps_str == NULL) { /* Best effort, don't error out */ - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_vfs_job_succeeded (G_VFS_JOB (job)); return; } @@ -1377,7 +1374,7 @@ do_query_fs_info (GVfsBackend *backend, g_free (caps_str); if (caps == NULL) { - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_vfs_job_failed_from_error (G_VFS_JOB (job), error); g_error_free (error); return; @@ -1395,7 +1392,7 @@ do_query_fs_info (GVfsBackend *backend, } if (has_free_memory == FALSE) { - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); /* Best effort, don't error out */ g_vfs_job_succeeded (G_VFS_JOB (job)); return; @@ -1411,7 +1408,7 @@ do_query_fs_info (GVfsBackend *backend, if (_query_file_info_helper (backend, filename, info, &error) == FALSE) { - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_vfs_job_failed_from_error (G_VFS_JOB (job), error); g_error_free (error); ovu_caps_free (caps); @@ -1420,7 +1417,7 @@ do_query_fs_info (GVfsBackend *backend, if (g_vfs_job_is_cancelled (G_VFS_JOB (job))) { - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_vfs_job_failed (G_VFS_JOB (job), G_IO_ERROR, G_IO_ERROR_CANCELLED, _("Operation was cancelled")); @@ -1457,7 +1454,7 @@ set_info_from_memory: g_vfs_job_succeeded (G_VFS_JOB (job)); - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_debug ("- do_query_fs_info\n"); } @@ -1476,11 +1473,11 @@ do_enumerate (GVfsBackend *backend, g_debug ("+ do_enumerate, filename: %s\n", filename); - g_mutex_lock (op_backend->mutex); + g_mutex_lock (&op_backend->mutex); if (_change_directory (op_backend, filename, &error) == FALSE) { - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_vfs_job_failed_from_error (G_VFS_JOB (job), error); g_error_free (error); return; @@ -1489,7 +1486,7 @@ do_enumerate (GVfsBackend *backend, files = NULL; if (_retrieve_folder_listing (backend, filename, &files, &error) == FALSE) { - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_vfs_job_failed_from_error (G_VFS_JOB (job), error); g_error_free (error); return; @@ -1497,7 +1494,7 @@ do_enumerate (GVfsBackend *backend, if (gvfsbackendobexftp_fl_parser_parse (files, strlen (files), &elements, &error) == FALSE) { - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); /* See http://web.archive.org/web/20070826221251/http://docs.kde.org/development/en/extragear-pim/kdebluetooth/components.kio_obex.html#devices * for the reasoning */ if (strstr (files, "SYSTEM\"obex-folder-listing.dtd") != NULL && _is_nokia_3650 (op_backend->bdaddr)) @@ -1525,7 +1522,7 @@ do_enumerate (GVfsBackend *backend, g_list_free (elements); g_vfs_job_enumerate_done (job); - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_debug ("- do_enumerate\n"); } @@ -1549,7 +1546,7 @@ push_transfer_started_cb (DBusGProxy *proxy, g_message ("transfer of %s to %s started", filename, local_path); - g_mutex_lock (op_backend->mutex); + g_mutex_lock (&op_backend->mutex); op_backend->status = ASYNC_RUNNING; job_data->total_bytes = (goffset) total_bytes; @@ -1557,8 +1554,8 @@ push_transfer_started_cb (DBusGProxy *proxy, job_data->progress_callback (0, job_data->total_bytes, job_data->progress_callback_data); - g_cond_signal (op_backend->cond); - g_mutex_unlock (op_backend->mutex); + g_cond_signal (&op_backend->cond); + g_mutex_unlock (&op_backend->mutex); } static void @@ -1570,12 +1567,12 @@ push_transfer_completed_cb (DBusGProxy *proxy, g_message ("transfer completed"); - g_mutex_lock (op_backend->mutex); + g_mutex_lock (&op_backend->mutex); op_backend->status = ASYNC_SUCCESS; - g_cond_signal (op_backend->cond); - g_mutex_unlock (op_backend->mutex); + g_cond_signal (&op_backend->cond); + g_mutex_unlock (&op_backend->mutex); } static void @@ -1657,7 +1654,7 @@ _push_single_file_helper (GVfsBackendObexftp *op_backend, /* wait for the TransferStarted or ErrorOccurred signal */ while (op_backend->status == ASYNC_PENDING) - g_cond_wait (op_backend->cond, op_backend->mutex); + g_cond_wait (&op_backend->cond, &op_backend->mutex); dbus_g_proxy_disconnect_signal (op_backend->session_proxy, "TransferStarted", G_CALLBACK (push_transfer_started_cb), job_data); @@ -1678,7 +1675,7 @@ _push_single_file_helper (GVfsBackendObexftp *op_backend, } while (op_backend->status == ASYNC_RUNNING) - g_cond_wait (op_backend->cond, op_backend->mutex); + g_cond_wait (&op_backend->cond, &op_backend->mutex); dbus_g_proxy_disconnect_signal (op_backend->session_proxy, "TransferCompleted", G_CALLBACK (push_transfer_completed_cb), job_data); @@ -1717,7 +1714,7 @@ do_push (GVfsBackend *backend, g_debug ("+ do_push, destination: %s, local_path: %s\n", destination, local_path); - g_mutex_lock (op_backend->mutex); + g_mutex_lock (&op_backend->mutex); op_backend->doing_io = TRUE; overwrite = (flags & G_FILE_COPY_OVERWRITE); @@ -1728,7 +1725,7 @@ do_push (GVfsBackend *backend, if (g_vfs_job_is_cancelled (G_VFS_JOB (job))) { op_backend->doing_io = FALSE; - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_vfs_job_failed (G_VFS_JOB (job), G_IO_ERROR, G_IO_ERROR_CANCELLED, @@ -1743,7 +1740,7 @@ do_push (GVfsBackend *backend, if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND)) { op_backend->doing_io = FALSE; - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_vfs_job_failed_from_error (G_VFS_JOB (job), error); g_error_free (error); @@ -1766,7 +1763,7 @@ do_push (GVfsBackend *backend, if (is_dir) { op_backend->doing_io = FALSE; - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); if (target_type != 0) { @@ -1799,7 +1796,7 @@ do_push (GVfsBackend *backend, if (target_type != 0) { op_backend->doing_io = FALSE; - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); if (overwrite) { @@ -1831,7 +1828,7 @@ do_push (GVfsBackend *backend, &error, job_data) == FALSE) { op_backend->doing_io = FALSE; - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); push_data_free (job_data); g_vfs_job_failed_from_error (G_VFS_JOB (job), error); @@ -1859,7 +1856,7 @@ do_push (GVfsBackend *backend, g_vfs_job_succeeded (G_VFS_JOB (job)); op_backend->doing_io = FALSE; - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_debug ("- do_push\n"); } @@ -1876,13 +1873,13 @@ do_delete (GVfsBackend *backend, g_debug ("+ do_delete, filename: %s\n", filename); - g_mutex_lock (op_backend->mutex); + g_mutex_lock (&op_backend->mutex); /* Check whether we have a directory */ info = g_file_info_new (); if (_query_file_info_helper (backend, filename, info, &error) == FALSE) { - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_vfs_job_failed_from_error (G_VFS_JOB (job), error); g_error_free (error); g_object_unref (info); @@ -1891,7 +1888,7 @@ do_delete (GVfsBackend *backend, if (g_vfs_job_is_cancelled (G_VFS_JOB (job))) { - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_vfs_job_failed (G_VFS_JOB (job), G_IO_ERROR, G_IO_ERROR_CANCELLED, _("Operation was cancelled")); @@ -1910,7 +1907,7 @@ do_delete (GVfsBackend *backend, if (_change_directory (op_backend, filename, &error) == FALSE) { - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_vfs_job_failed_from_error (G_VFS_JOB (job), error); g_error_free (error); return; @@ -1918,7 +1915,7 @@ do_delete (GVfsBackend *backend, if (g_vfs_job_is_cancelled (G_VFS_JOB (job))) { - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_vfs_job_failed (G_VFS_JOB (job), G_IO_ERROR, G_IO_ERROR_CANCELLED, _("Operation was cancelled")); @@ -1928,7 +1925,7 @@ do_delete (GVfsBackend *backend, files = NULL; if (_retrieve_folder_listing (backend, filename, &files, &error) == FALSE) { - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_vfs_job_failed_from_error (G_VFS_JOB (job), error); g_error_free (error); return; @@ -1936,7 +1933,7 @@ do_delete (GVfsBackend *backend, if (gvfsbackendobexftp_fl_parser_parse (files, strlen (files), &elements, &error) == FALSE) { - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_message ("gvfsbackendobexftp_fl_parser_parse failed"); g_free (files); g_vfs_job_failed_from_error (G_VFS_JOB (job), error); @@ -1951,7 +1948,7 @@ do_delete (GVfsBackend *backend, if (len != 0) { - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_set_error_literal (&error, G_IO_ERROR, G_IO_ERROR_NOT_EMPTY, g_strerror (ENOTEMPTY)); @@ -1969,7 +1966,7 @@ do_delete (GVfsBackend *backend, if (strcmp (basename, G_DIR_SEPARATOR_S) == 0 || strcmp (basename, ".") == 0) { - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_free (basename); g_vfs_job_failed_from_errno (G_VFS_JOB (job), EPERM); return; @@ -1977,7 +1974,7 @@ do_delete (GVfsBackend *backend, if (g_vfs_job_is_cancelled (G_VFS_JOB (job))) { - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_vfs_job_failed (G_VFS_JOB (job), G_IO_ERROR, G_IO_ERROR_CANCELLED, _("Operation was cancelled")); @@ -1988,7 +1985,7 @@ do_delete (GVfsBackend *backend, parent = g_path_get_dirname (filename); if (_change_directory (op_backend, parent, &error) == FALSE) { - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_vfs_job_failed_from_error (G_VFS_JOB (job), error); g_free (basename); g_free (parent); @@ -1999,7 +1996,7 @@ do_delete (GVfsBackend *backend, if (g_vfs_job_is_cancelled (G_VFS_JOB (job))) { - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_vfs_job_failed (G_VFS_JOB (job), G_IO_ERROR, G_IO_ERROR_CANCELLED, _("Operation was cancelled")); @@ -2011,7 +2008,7 @@ do_delete (GVfsBackend *backend, G_TYPE_STRING, basename, G_TYPE_INVALID, G_TYPE_INVALID) == FALSE) { - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_vfs_job_failed_from_error (G_VFS_JOB (job), error); g_error_free (error); return; @@ -2020,7 +2017,7 @@ do_delete (GVfsBackend *backend, g_vfs_job_succeeded (G_VFS_JOB (job)); - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_debug ("- do_delete\n"); } @@ -2037,13 +2034,13 @@ do_make_directory (GVfsBackend *backend, g_debug ("+ do_make_directory, filename: %s\n", filename); - g_mutex_lock (op_backend->mutex); + g_mutex_lock (&op_backend->mutex); /* Check if the folder already exists */ info = g_file_info_new (); if (_query_file_info_helper (backend, filename, info, &error) != FALSE) { - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_object_unref (info); g_vfs_job_failed_from_errno (G_VFS_JOB (job), EEXIST); return; @@ -2051,7 +2048,7 @@ do_make_directory (GVfsBackend *backend, g_object_unref (info); if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND) == FALSE) { - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_vfs_job_failed_from_error (G_VFS_JOB (job), error); g_error_free (error); return; @@ -2062,7 +2059,7 @@ do_make_directory (GVfsBackend *backend, if (g_vfs_job_is_cancelled (G_VFS_JOB (job))) { - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_vfs_job_failed (G_VFS_JOB (job), G_IO_ERROR, G_IO_ERROR_CANCELLED, _("Operation was cancelled")); @@ -2072,7 +2069,7 @@ do_make_directory (GVfsBackend *backend, parent = g_path_get_dirname (filename); if (_change_directory (op_backend, parent, &error) == FALSE) { - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_vfs_job_failed_from_error (G_VFS_JOB (job), error); g_error_free (error); return; @@ -2081,7 +2078,7 @@ do_make_directory (GVfsBackend *backend, if (g_vfs_job_is_cancelled (G_VFS_JOB (job))) { - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_vfs_job_failed (G_VFS_JOB (job), G_IO_ERROR, G_IO_ERROR_CANCELLED, _("Operation was cancelled")); @@ -2093,7 +2090,7 @@ do_make_directory (GVfsBackend *backend, G_TYPE_STRING, basename, G_TYPE_INVALID, G_TYPE_INVALID) == FALSE) { - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_free (basename); g_vfs_job_failed_from_error (G_VFS_JOB (job), error); g_error_free (error); @@ -2108,7 +2105,7 @@ do_make_directory (GVfsBackend *backend, g_vfs_job_succeeded (G_VFS_JOB (job)); - g_mutex_unlock (op_backend->mutex); + g_mutex_unlock (&op_backend->mutex); g_debug ("- do_make_directory\n"); } diff --git a/daemon/gvfsbackendsmbbrowse.c b/daemon/gvfsbackendsmbbrowse.c index 01d7da6..f1055c5 100644 --- a/daemon/gvfsbackendsmbbrowse.c +++ b/daemon/gvfsbackendsmbbrowse.c @@ -94,8 +94,8 @@ struct _GVfsBackendSmbBrowse gboolean password_in_keyring; GPasswordSave password_save; - GMutex *entries_lock; - GMutex *update_cache_lock; + GMutex entries_lock; + GMutex update_cache_lock; time_t last_entry_update; GList *entries; int entry_errno; @@ -226,8 +226,8 @@ g_vfs_backend_smb_browse_finalize (GObject *object) g_free (backend->server); g_free (backend->default_workgroup); - g_mutex_free (backend->entries_lock); - g_mutex_free (backend->update_cache_lock); + g_mutex_clear (&backend->entries_lock); + g_mutex_clear (&backend->update_cache_lock); smbc_free_context (backend->smb_context, TRUE); @@ -244,9 +244,6 @@ g_vfs_backend_smb_browse_init (GVfsBackendSmbBrowse *backend) char *workgroup; GSettings *settings; - backend->entries_lock = g_mutex_new (); - backend->update_cache_lock = g_mutex_new (); - if (mount_tracker == NULL) mount_tracker = g_mount_tracker_new (NULL); @@ -592,7 +589,7 @@ update_cache (GVfsBackendSmbBrowse *backend, SMBCFILE *supplied_dir) entry_errno = 0; res = -1; - g_mutex_lock (backend->update_cache_lock); + g_mutex_lock (&backend->update_cache_lock); DEBUG ("update_cache - updating...\n"); @@ -665,7 +662,7 @@ update_cache (GVfsBackendSmbBrowse *backend, SMBCFILE *supplied_dir) out: - g_mutex_lock (backend->entries_lock); + g_mutex_lock (&backend->entries_lock); /* Clear old cache */ g_list_foreach (backend->entries, (GFunc)browse_entry_free, NULL); @@ -676,8 +673,8 @@ update_cache (GVfsBackendSmbBrowse *backend, SMBCFILE *supplied_dir) DEBUG ("update_cache - done.\n"); - g_mutex_unlock (backend->entries_lock); - g_mutex_unlock (backend->update_cache_lock); + g_mutex_unlock (&backend->entries_lock); + g_mutex_unlock (&backend->update_cache_lock); return (res >= 0); } @@ -780,9 +777,9 @@ has_name (GVfsBackendSmbBrowse *backend, { gboolean res; - g_mutex_lock (backend->entries_lock); + g_mutex_lock (&backend->entries_lock); res = (find_entry_unlocked (backend, filename) != NULL); - g_mutex_unlock (backend->entries_lock); + g_mutex_unlock (&backend->entries_lock); return res; } @@ -793,11 +790,11 @@ cache_needs_updating (GVfsBackendSmbBrowse *backend) gboolean res; /* If there's already cache update in progress, lock and wait until update is finished, then recheck */ - g_mutex_lock (backend->update_cache_lock); + g_mutex_lock (&backend->update_cache_lock); now = time (NULL); res = now < backend->last_entry_update || (now - backend->last_entry_update) > DEFAULT_CACHE_EXPIRATION_TIME; - g_mutex_unlock (backend->update_cache_lock); + g_mutex_unlock (&backend->update_cache_lock); return res; } @@ -1070,7 +1067,7 @@ run_mount_mountable (GVfsBackendSmbBrowse *backend, GError *error = NULL; GMountSpec *mount_spec; - g_mutex_lock (backend->entries_lock); + g_mutex_lock (&backend->entries_lock); entry = find_entry_unlocked (backend, filename); @@ -1093,7 +1090,7 @@ run_mount_mountable (GVfsBackendSmbBrowse *backend, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, _("File doesn't exist")); - g_mutex_unlock (backend->entries_lock); + g_mutex_unlock (&backend->entries_lock); if (error) { @@ -1316,14 +1313,14 @@ run_query_info (GVfsBackendSmbBrowse *backend, { BrowseEntry *entry; - g_mutex_lock (backend->entries_lock); + g_mutex_lock (&backend->entries_lock); entry = find_entry_unlocked (backend, filename); if (entry) get_file_info_from_entry (backend, entry, info); - g_mutex_unlock (backend->entries_lock); + g_mutex_unlock (&backend->entries_lock); if (entry) g_vfs_job_succeeded (G_VFS_JOB (job)); @@ -1408,7 +1405,7 @@ run_enumerate (GVfsBackendSmbBrowse *backend, g_vfs_job_succeeded (G_VFS_JOB (job)); files = NULL; - g_mutex_lock (backend->entries_lock); + g_mutex_lock (&backend->entries_lock); for (l = backend->entries; l != NULL; l = l->next) { BrowseEntry *entry = l->data; @@ -1418,7 +1415,7 @@ run_enumerate (GVfsBackendSmbBrowse *backend, files = g_list_prepend (files, info); } - g_mutex_unlock (backend->entries_lock); + g_mutex_unlock (&backend->entries_lock); files = g_list_reverse (files); diff --git a/daemon/gvfsdaemon.c b/daemon/gvfsdaemon.c index 9714b39..4f59b94 100644 --- a/daemon/gvfsdaemon.c +++ b/daemon/gvfsdaemon.c @@ -58,7 +58,7 @@ struct _GVfsDaemon { GObject parent_instance; - GMutex *lock; + GMutex lock; gboolean main_daemon; GThreadPool *thread_pool; @@ -119,7 +119,7 @@ g_vfs_daemon_finalize (GObject *object) g_assert (daemon->jobs == NULL); g_hash_table_destroy (daemon->registered_paths); - g_mutex_free (daemon->lock); + g_mutex_clear (&daemon->lock); if (G_OBJECT_CLASS (g_vfs_daemon_parent_class)->finalize) (*G_OBJECT_CLASS (g_vfs_daemon_parent_class)->finalize) (object); @@ -150,7 +150,6 @@ g_vfs_daemon_init (GVfsDaemon *daemon) gint max_threads = 1; /* TODO: handle max threads */ DBusError error; - daemon->lock = g_mutex_new (); daemon->session_bus = dbus_bus_get (DBUS_BUS_SESSION, NULL); daemon->thread_pool = g_thread_pool_new (job_handler_callback, daemon, @@ -326,7 +325,7 @@ static void job_source_closed_callback (GVfsJobSource *job_source, GVfsDaemon *daemon) { - g_mutex_lock (daemon->lock); + g_mutex_lock (&daemon->lock); daemon->job_sources = g_list_remove (daemon->job_sources, job_source); @@ -343,7 +342,7 @@ job_source_closed_callback (GVfsJobSource *job_source, if (daemon->job_sources == NULL) daemon_schedule_exit (daemon); - g_mutex_unlock (daemon->lock); + g_mutex_unlock (&daemon->lock); } static void @@ -351,7 +350,7 @@ g_vfs_daemon_re_register_job_sources (GVfsDaemon *daemon) { GList *l; - g_mutex_lock (daemon->lock); + g_mutex_lock (&daemon->lock); for (l = daemon->job_sources; l != NULL; l = l->next) { @@ -366,7 +365,7 @@ g_vfs_daemon_re_register_job_sources (GVfsDaemon *daemon) } } - g_mutex_unlock (daemon->lock); + g_mutex_unlock (&daemon->lock); } void @@ -375,7 +374,7 @@ g_vfs_daemon_add_job_source (GVfsDaemon *daemon, { g_debug ("Added new job source %p (%s)\n", job_source, g_type_name_from_instance ((gpointer)job_source)); - g_mutex_lock (daemon->lock); + g_mutex_lock (&daemon->lock); daemon_unschedule_exit (daemon); @@ -387,7 +386,7 @@ g_vfs_daemon_add_job_source (GVfsDaemon *daemon, g_signal_connect (job_source, "closed", (GCallback)job_source_closed_callback, daemon); - g_mutex_unlock (daemon->lock); + g_mutex_unlock (&daemon->lock); } /* This registers a dbus callback on *all* connections, client and session bus */ @@ -437,9 +436,9 @@ job_finished_callback (GVfsJob *job, (GCallback)job_finished_callback, daemon); - g_mutex_lock (daemon->lock); + g_mutex_lock (&daemon->lock); daemon->jobs = g_list_remove (daemon->jobs, job); - g_mutex_unlock (daemon->lock); + g_mutex_unlock (&daemon->lock); g_object_unref (job); } @@ -454,9 +453,9 @@ g_vfs_daemon_queue_job (GVfsDaemon *daemon, g_signal_connect (job, "finished", (GCallback)job_finished_callback, daemon); g_signal_connect (job, "new_source", (GCallback)job_new_source_callback, daemon); - g_mutex_lock (daemon->lock); + g_mutex_lock (&daemon->lock); daemon->jobs = g_list_prepend (daemon->jobs, job); - g_mutex_unlock (daemon->lock); + g_mutex_unlock (&daemon->lock); /* Can we start the job immediately / async */ if (!g_vfs_job_try (job)) @@ -949,7 +948,7 @@ daemon_message_func (DBusConnection *conn, DBUS_TYPE_UINT32, &serial, DBUS_TYPE_INVALID)) { - g_mutex_lock (daemon->lock); + g_mutex_lock (&daemon->lock); for (l = daemon->jobs; l != NULL; l = l->next) { GVfsJob *job = l->data; @@ -962,7 +961,7 @@ daemon_message_func (DBusConnection *conn, break; } } - g_mutex_unlock (daemon->lock); + g_mutex_unlock (&daemon->lock); if (job_to_cancel) @@ -1007,7 +1006,7 @@ peer_to_peer_filter_func (DBusConnection *conn, { GList *l; - g_mutex_lock (daemon->lock); + g_mutex_lock (&daemon->lock); for (l = daemon->jobs; l != NULL; l = l->next) { GVfsJob *job = l->data; @@ -1016,7 +1015,7 @@ peer_to_peer_filter_func (DBusConnection *conn, G_VFS_JOB_DBUS (job)->connection == conn) g_vfs_job_cancel (job); } - g_mutex_unlock (daemon->lock); + g_mutex_unlock (&daemon->lock); /* The peer-to-peer connection was disconnected */ dbus_connection_unref (conn); diff --git a/daemon/gvfsftpdircache.c b/daemon/gvfsftpdircache.c index cd19c17..49023b1 100644 --- a/daemon/gvfsftpdircache.c +++ b/daemon/gvfsftpdircache.c @@ -98,7 +98,7 @@ struct _GVfsFtpDirCache { GHashTable * directories; /* GVfsFtpFile of directory => GVfsFtpDirCacheEntry mapping */ guint stamp; /* used to identify validity of cache when flushing */ - GMutex * lock; /* mutex for thread safety of stamp and hash table */ + GMutex lock; /* mutex for thread safety of stamp and hash table */ const GVfsFtpDirFuncs *funcs; /* functions to call */ }; @@ -114,7 +114,6 @@ g_vfs_ftp_dir_cache_new (const GVfsFtpDirFuncs *funcs) g_vfs_ftp_file_equal, (GDestroyNotify) g_vfs_ftp_file_free, (GDestroyNotify) g_vfs_ftp_dir_cache_entry_unref); - cache->lock = g_mutex_new(); cache->funcs = funcs; return cache; @@ -126,7 +125,7 @@ g_vfs_ftp_dir_cache_free (GVfsFtpDirCache *cache) g_return_if_fail (cache != NULL); g_hash_table_destroy (cache->directories); - g_mutex_free (cache->lock); + g_mutex_clear (&cache->lock); g_slice_free (GVfsFtpDirCache, cache); } @@ -138,11 +137,11 @@ g_vfs_ftp_dir_cache_lookup_entry (GVfsFtpDirCache * cache, { GVfsFtpDirCacheEntry *entry; - g_mutex_lock (cache->lock); + g_mutex_lock (&cache->lock); entry = g_hash_table_lookup (cache->directories, dir); if (entry) g_vfs_ftp_dir_cache_entry_ref (entry); - g_mutex_unlock (cache->lock); + g_mutex_unlock (&cache->lock); if (entry && entry->stamp < stamp) g_vfs_ftp_dir_cache_entry_unref (entry); else if (entry) @@ -178,11 +177,11 @@ g_vfs_ftp_dir_cache_lookup_entry (GVfsFtpDirCache * cache, g_vfs_ftp_dir_cache_entry_unref (entry); return NULL; } - g_mutex_lock (cache->lock); + g_mutex_lock (&cache->lock); g_hash_table_insert (cache->directories, g_vfs_ftp_file_copy (dir), g_vfs_ftp_dir_cache_entry_ref (entry)); - g_mutex_unlock (cache->lock); + g_mutex_unlock (&cache->lock); return entry; } @@ -357,10 +356,10 @@ g_vfs_ftp_dir_cache_lookup_dir (GVfsFtpDirCache * cache, if (flush) { - g_mutex_lock (cache->lock); + g_mutex_lock (&cache->lock); g_assert (cache->stamp != G_MAXUINT); stamp = ++cache->stamp; - g_mutex_unlock (cache->lock); + g_mutex_unlock (&cache->lock); } else stamp = 0; @@ -390,9 +389,9 @@ g_vfs_ftp_dir_cache_purge_dir (GVfsFtpDirCache * cache, g_return_if_fail (cache != NULL); g_return_if_fail (dir != NULL); - g_mutex_lock (cache->lock); + g_mutex_lock (&cache->lock); g_hash_table_remove (cache->directories, dir); - g_mutex_unlock (cache->lock); + g_mutex_unlock (&cache->lock); } void diff --git a/daemon/gvfsftptask.c b/daemon/gvfsftptask.c index 8c5f7fb..f83882a 100644 --- a/daemon/gvfsftptask.c +++ b/daemon/gvfsftptask.c @@ -180,7 +180,7 @@ static gboolean g_vfs_ftp_task_acquire_connection (GVfsFtpTask *task) { GVfsBackendFtp *ftp; - GTimeVal now; + gint64 end_time; gulong id; g_return_val_if_fail (task != NULL, FALSE); @@ -190,10 +190,10 @@ g_vfs_ftp_task_acquire_connection (GVfsFtpTask *task) return FALSE; ftp = task->backend; - g_mutex_lock (ftp->mutex); + g_mutex_lock (&ftp->mutex); id = g_cancellable_connect (task->cancellable, G_CALLBACK (do_broadcast), - ftp->cond, NULL); + &ftp->cond, NULL); while (task->conn == NULL && ftp->queue != NULL) { if (g_cancellable_is_cancelled (task->cancellable)) @@ -218,7 +218,7 @@ g_vfs_ftp_task_acquire_connection (GVfsFtpTask *task) ftp->connections++; last_thread = g_thread_self (); - g_mutex_unlock (ftp->mutex); + g_mutex_unlock (&ftp->mutex); task->conn = g_vfs_ftp_connection_new (ftp->addr, task->cancellable, &task->error); if (G_LIKELY (task->conn != NULL)) { @@ -231,7 +231,7 @@ g_vfs_ftp_task_acquire_connection (GVfsFtpTask *task) g_vfs_ftp_connection_free (task->conn); task->conn = NULL; - g_mutex_lock (ftp->mutex); + g_mutex_lock (&ftp->mutex); ftp->connections--; /* If this value is still equal to our thread it means there were no races * trying to open connections and the maybe_max_connections value is @@ -253,10 +253,9 @@ g_vfs_ftp_task_acquire_connection (GVfsFtpTask *task) continue; } - g_get_current_time (&now); - g_time_val_add (&now, G_VFS_FTP_TIMEOUT_IN_SECONDS * 1000 * 1000); + end_time = g_get_monotonic_time () + G_VFS_FTP_TIMEOUT_IN_SECONDS * G_TIME_SPAN_SECOND; if (ftp->busy_connections >= ftp->connections || - !g_cond_timed_wait (ftp->cond, ftp->mutex, &now)) + !g_cond_wait_until (&ftp->cond, &ftp->mutex, end_time)) { task->error = g_error_new_literal (G_IO_ERROR, G_IO_ERROR_BUSY, _("The FTP server is busy. Try again later")); @@ -264,7 +263,7 @@ g_vfs_ftp_task_acquire_connection (GVfsFtpTask *task) } } g_cancellable_disconnect (task->cancellable, id); - g_mutex_unlock (ftp->mutex); + g_mutex_unlock (&ftp->mutex); return task->conn != NULL; } @@ -287,18 +286,18 @@ g_vfs_ftp_task_release_connection (GVfsFtpTask *task) if (task->conn == NULL) return; - g_mutex_lock (task->backend->mutex); + g_mutex_lock (&task->backend->mutex); if (task->backend->queue && g_vfs_ftp_connection_is_usable (task->conn)) { g_queue_push_tail (task->backend->queue, task->conn); - g_cond_signal (task->backend->cond); + g_cond_signal (&task->backend->cond); } else { task->backend->connections--; g_vfs_ftp_connection_free (task->conn); } - g_mutex_unlock (task->backend->mutex); + g_mutex_unlock (&task->backend->mutex); task->conn = NULL; } @@ -434,10 +433,10 @@ g_vfs_ftp_task_give_connection (GVfsFtpTask * task, task->conn = conn; /* this connection is not busy anymore */ - g_mutex_lock (task->backend->mutex); + g_mutex_lock (&task->backend->mutex); g_assert (task->backend->busy_connections > 0); task->backend->busy_connections--; - g_mutex_unlock (task->backend->mutex); + g_mutex_unlock (&task->backend->mutex); } /** @@ -465,13 +464,13 @@ g_vfs_ftp_task_take_connection (GVfsFtpTask *task) ftp = task->backend; /* mark this connection as busy */ - g_mutex_lock (ftp->mutex); + g_mutex_lock (&ftp->mutex); ftp->busy_connections++; /* if all connections are busy, signal all waiting threads, * so they stop waiting and return BUSY earlier */ if (ftp->busy_connections >= ftp->connections) - g_cond_broadcast (ftp->cond); - g_mutex_unlock (ftp->mutex); + g_cond_broadcast (&ftp->cond); + g_mutex_unlock (&ftp->mutex); return conn; } diff --git a/daemon/trashlib/trashexpunge.c b/daemon/trashlib/trashexpunge.c index 782be54..a5cf975 100644 --- a/daemon/trashlib/trashexpunge.c +++ b/daemon/trashlib/trashexpunge.c @@ -11,8 +11,8 @@ static gsize trash_expunge_initialised; static GHashTable *trash_expunge_queue; static gboolean trash_expunge_alive; -static GMutex *trash_expunge_lock; -static GCond *trash_expunge_wait; +static GMutex trash_expunge_lock; +static GCond trash_expunge_wait; static void trash_expunge_delete_everything_under (GFile *directory) @@ -66,9 +66,9 @@ just_return_true (gpointer a, static gpointer trash_expunge_thread (gpointer data) { - GTimeVal timeval; + gint64 end_time; - g_mutex_lock (trash_expunge_lock); + g_mutex_lock (&trash_expunge_lock); do { @@ -80,23 +80,22 @@ trash_expunge_thread (gpointer data) just_return_true, NULL); g_hash_table_remove (trash_expunge_queue, directory); - g_mutex_unlock (trash_expunge_lock); + g_mutex_unlock (&trash_expunge_lock); trash_expunge_delete_everything_under (directory); - g_mutex_lock (trash_expunge_lock); + g_mutex_lock (&trash_expunge_lock); g_object_unref (directory); } - g_get_current_time (&timeval); - g_time_val_add (&timeval, 60 * 1000000); /* 1min */ + end_time = g_get_monotonic_time () + 1 * G_TIME_SPAN_MINUTE; } - while (g_cond_timed_wait (trash_expunge_wait, - trash_expunge_lock, - &timeval)); + while (g_cond_wait_until (&trash_expunge_wait, + &trash_expunge_lock, + end_time)); trash_expunge_alive = FALSE; - g_mutex_unlock (trash_expunge_lock); + g_mutex_unlock (&trash_expunge_lock); return NULL; } @@ -108,13 +107,13 @@ trash_expunge (GFile *directory) { trash_expunge_queue = g_hash_table_new (g_file_hash, (GEqualFunc) g_file_equal); - trash_expunge_lock = g_mutex_new (); - trash_expunge_wait = g_cond_new (); + g_mutex_init (&trash_expunge_lock); + g_cond_init (&trash_expunge_wait); g_once_init_leave (&trash_expunge_initialised, 1); } - g_mutex_lock (trash_expunge_lock); + g_mutex_lock (&trash_expunge_lock); if (!g_hash_table_lookup (trash_expunge_queue, directory)) g_hash_table_insert (trash_expunge_queue, @@ -130,7 +129,7 @@ trash_expunge (GFile *directory) trash_expunge_alive = TRUE; } else - g_cond_signal (trash_expunge_wait); + g_cond_signal (&trash_expunge_wait); - g_mutex_unlock (trash_expunge_lock); + g_mutex_unlock (&trash_expunge_lock); } diff --git a/daemon/trashlib/trashitem.c b/daemon/trashlib/trashitem.c index bcfc301..dbc9307 100644 --- a/daemon/trashlib/trashitem.c +++ b/daemon/trashlib/trashitem.c @@ -20,7 +20,7 @@ typedef struct struct OPAQUE_TYPE__TrashRoot { - GStaticRWLock lock; + GRWLock lock; GQueue *notifications; trash_item_notify create_notify; @@ -297,12 +297,12 @@ trash_root_thaw (TrashRoot *root) /* send notifications until we have none */ while (TRUE) { - g_static_rw_lock_writer_lock (&root->lock); + g_rw_lock_writer_lock (&root->lock); if (g_queue_is_empty (root->notifications)) break; closure = g_queue_pop_head (root->notifications); - g_static_rw_lock_writer_unlock (&root->lock); + g_rw_lock_writer_unlock (&root->lock); trash_item_invoke_closure (closure); } @@ -312,7 +312,7 @@ trash_root_thaw (TrashRoot *root) size_changed = root->old_size != size; root->old_size = size; - g_static_rw_lock_writer_unlock (&root->lock); + g_rw_lock_writer_unlock (&root->lock); if (size_changed) root->size_change (root->user_data); @@ -336,7 +336,7 @@ trash_root_new (trash_item_notify create, TrashRoot *root; root = g_slice_new (TrashRoot); - g_static_rw_lock_init (&root->lock); + g_rw_lock_init (&root->lock); root->create_notify = create; root->delete_notify = delete; root->size_change = size_change; @@ -376,11 +376,11 @@ trash_root_add_item (TrashRoot *list, item = trash_item_new (list, file, in_homedir); - g_static_rw_lock_writer_lock (&list->lock); + g_rw_lock_writer_lock (&list->lock); if (g_hash_table_lookup (list->item_table, item->escaped_name)) { - g_static_rw_lock_writer_unlock (&list->lock); + g_rw_lock_writer_unlock (&list->lock); /* already exists... */ trash_item_unref (item); @@ -390,7 +390,7 @@ trash_root_add_item (TrashRoot *list, g_hash_table_insert (list->item_table, item->escaped_name, item); trash_item_queue_notify (item, item->root->create_notify); - g_static_rw_lock_writer_unlock (&list->lock); + g_rw_lock_writer_unlock (&list->lock); } void @@ -402,9 +402,9 @@ trash_root_remove_item (TrashRoot *list, escaped = trash_item_escape_name (file, in_homedir); - g_static_rw_lock_writer_lock (&list->lock); + g_rw_lock_writer_lock (&list->lock); g_hash_table_remove (list->item_table, escaped); - g_static_rw_lock_writer_unlock (&list->lock); + g_rw_lock_writer_unlock (&list->lock); g_free (escaped); } @@ -414,13 +414,13 @@ trash_root_get_items (TrashRoot *root) { GList *items, *node; - g_static_rw_lock_reader_lock (&root->lock); + g_rw_lock_reader_lock (&root->lock); items = g_hash_table_get_values (root->item_table); for (node = items; node; node = node->next) trash_item_ref (node->data); - g_static_rw_lock_reader_unlock (&root->lock); + g_rw_lock_reader_unlock (&root->lock); return items; } @@ -441,12 +441,12 @@ trash_root_lookup_item (TrashRoot *root, { TrashItem *item; - g_static_rw_lock_reader_lock (&root->lock); + g_rw_lock_reader_lock (&root->lock); if ((item = g_hash_table_lookup (root->item_table, escaped))) trash_item_ref (item); - g_static_rw_lock_reader_unlock (&root->lock); + g_rw_lock_reader_unlock (&root->lock); return item; } @@ -456,9 +456,9 @@ trash_root_get_n_items (TrashRoot *root) { int size; - g_static_rw_lock_reader_lock (&root->lock); + g_rw_lock_reader_lock (&root->lock); size = g_hash_table_size (root->item_table); - g_static_rw_lock_reader_unlock (&root->lock); + g_rw_lock_reader_unlock (&root->lock); return size; } @@ -517,9 +517,9 @@ trash_item_restore (TrashItem *item, G_FILE_COPY_NO_FALLBACK_FOR_MOVE, NULL, NULL, NULL, error)) { - g_static_rw_lock_writer_lock (&item->root->lock); + g_rw_lock_writer_lock (&item->root->lock); g_hash_table_remove (item->root->item_table, item->escaped_name); - g_static_rw_lock_writer_unlock (&item->root->lock); + g_rw_lock_writer_unlock (&item->root->lock); { GFile *trashinfo; -- 1.7.6.5