void AdvanceTick() { Universe temp = g_queue_pop_head( universe_buffer ); while( temp == NULL ) { // The buffer rendering process is taking too long. // Let's wait until he's done, then try again. G_LOCK( UNIVERSE_RENDER_BUSY ); G_UNLOCK( UNIVERSE_RENDER_BUSY ); temp = g_queue_pop_head( universe_buffer ); } // Swap out the new guy for the "current" step, and free the old guy Universe old = current; current = temp; Universe_freeUniverse( &old ); }
void hamlib_set_ptt(gint ptt) { gint ret; if (!rig || !hamlib_ptt) return; G_LOCK(hamlib_mutex); ret = rig_set_ptt(rig, RIG_VFO_CURR, ptt ? RIG_PTT_ON : RIG_PTT_OFF); if (ret != RIG_OK) { errmsg(_("rig_set_ptt failed: %s.\nHamlib PTT disabled.\n"), rigerror(ret)); hamlib_ptt = FALSE; } G_UNLOCK(hamlib_mutex); }
void nautilus_progress_info_take_status (NautilusProgressInfo *info, char *status) { G_LOCK (progress_info); if (eel_strcmp (info->status, status) != 0) { g_free (info->status); info->status = status; info->changed_at_idle = TRUE; queue_idle (info, FALSE); } else { g_free (status); } G_UNLOCK (progress_info); }
void nautilus_progress_info_take_details (NautilusProgressInfo *info, char *details) { G_LOCK (progress_info); if (eel_strcmp (info->details, details) != 0) { g_free (info->details); info->details = details; info->changed_at_idle = TRUE; queue_idle (info, FALSE); } else { g_free (details); } G_UNLOCK (progress_info); }
static void _shadowtorpreload_cryptoSetup(int numLocks) { G_LOCK(shadowtorpreloadPrimaryLock); if(!shadowtorpreloadGlobalState.initialized) { shadowtorpreloadGlobalState.numCryptoThreadLocks = numLocks; shadowtorpreloadGlobalState.cryptoThreadLocks = g_new0(GRWLock, numLocks); for(gint i = 0; i < numLocks; i++) { g_rw_lock_init(&(shadowtorpreloadGlobalState.cryptoThreadLocks[i])); } shadowtorpreloadGlobalState.initialized = TRUE; } shadowtorpreloadGlobalState.nThreads++; G_UNLOCK(shadowtorpreloadPrimaryLock); }
/** * gst_mini_object_get_qdata: * @object: The GstMiniObject to get a stored user data pointer from * @quark: A #GQuark, naming the user data pointer * * This function gets back user data pointers stored via * gst_mini_object_set_qdata(). * * Returns: (transfer none): The user data pointer set, or %NULL */ gpointer gst_mini_object_get_qdata (GstMiniObject * object, GQuark quark) { guint i; gpointer result; g_return_val_if_fail (object != NULL, NULL); g_return_val_if_fail (quark > 0, NULL); G_LOCK (qdata_mutex); if ((i = find_notify (object, quark, FALSE, NULL, NULL)) != -1) result = QDATA_DATA (object, i); else result = NULL; G_UNLOCK (qdata_mutex); return result; }
static void _shadowtorpreload_cryptoTeardown() { G_LOCK(shadowtorpreloadPrimaryLock); if(shadowtorpreloadGlobalState.initialized && shadowtorpreloadGlobalState.cryptoThreadLocks && --shadowtorpreloadGlobalState.nThreads == 0) { for(int i = 0; i < shadowtorpreloadGlobalState.numCryptoThreadLocks; i++) { g_rw_lock_clear(&(shadowtorpreloadGlobalState.cryptoThreadLocks[i])); } g_free(shadowtorpreloadGlobalState.cryptoThreadLocks); shadowtorpreloadGlobalState.cryptoThreadLocks = NULL; shadowtorpreloadGlobalState.initialized = 0; } G_UNLOCK(shadowtorpreloadPrimaryLock); }
/** * gst_mini_object_weak_unref: (skip) * @object: #GstMiniObject to remove a weak reference from * @notify: callback to search for * @data: data to search for * * Removes a weak reference callback from a mini object. */ void gst_mini_object_weak_unref (GstMiniObject * object, GstMiniObjectNotify notify, gpointer data) { gint i; g_return_if_fail (object != NULL); g_return_if_fail (notify != NULL); G_LOCK (qdata_mutex); if ((i = find_notify (object, weak_ref_quark, TRUE, notify, data)) != -1) { remove_notify (object, i); } else { g_warning ("%s: couldn't find weak ref %p (object:%p data:%p)", G_STRFUNC, notify, object, data); } G_UNLOCK (qdata_mutex); }
static GCacheNode* g_cache_node_new (gpointer value) { GCacheNode *node; G_LOCK (node_mem_chunk); if (!node_mem_chunk) node_mem_chunk = g_mem_chunk_new ("cache node mem chunk", sizeof (GCacheNode), 1024, G_ALLOC_AND_FREE); node = g_chunk_new (GCacheNode, node_mem_chunk); G_UNLOCK (node_mem_chunk); node->value = value; node->ref_count = 1; return node; }
static void gst_net_client_clock_finalize (GObject * object) { GstNetClientClock *self = GST_NET_CLIENT_CLOCK (object); GList *l; if (self->priv->synced_id) g_signal_handler_disconnect (self->priv->internal_clock, self->priv->synced_id); self->priv->synced_id = 0; G_LOCK (clocks_lock); for (l = clocks; l; l = l->next) { ClockCache *cache = l->data; if (cache->clock == self->priv->internal_clock) { cache->clocks = g_list_remove (cache->clocks, self); if (cache->clocks) { update_clock_cache (cache); } else { GstClock *sysclock = gst_system_clock_obtain (); GstClockTime time = gst_clock_get_time (sysclock) + 60 * GST_SECOND; cache->remove_id = gst_clock_new_single_shot_id (sysclock, time); gst_clock_id_wait_async (cache->remove_id, remove_clock_cache, cache, NULL); gst_object_unref (sysclock); } break; } } G_UNLOCK (clocks_lock); g_free (self->priv->address); self->priv->address = NULL; if (self->priv->bus != NULL) { gst_object_unref (self->priv->bus); self->priv->bus = NULL; } G_OBJECT_CLASS (gst_net_client_clock_parent_class)->finalize (object); }
void ev_job_scheduler_update_job (EvJob *job, EvJobPriority priority) { GSList *l; EvSchedulerJob *s_job = NULL; gboolean need_resort = FALSE; /* Main loop jobs are scheduled inmediately */ if (ev_job_get_run_mode (job) == EV_JOB_RUN_MAIN_LOOP) return; ev_debug_message (DEBUG_JOBS, "%s pirority %d", EV_GET_TYPE_NAME (job), priority); G_LOCK (job_list); for (l = job_list; l; l = l->next) { s_job = (EvSchedulerJob *)l->data; if (s_job->job == job) { need_resort = (s_job->priority != priority); break; } } G_UNLOCK (job_list); if (need_resort) { GList *list; g_mutex_lock (&job_queue_mutex); list = g_queue_find (job_queue[s_job->priority], s_job); if (list) { ev_debug_message (DEBUG_JOBS, "Moving job %s from pirority %d to %d", EV_GET_TYPE_NAME (job), s_job->priority, priority); g_queue_delete_link (job_queue[s_job->priority], list); g_queue_push_tail (job_queue[priority], s_job); g_cond_broadcast (&job_queue_cond); } g_mutex_unlock (&job_queue_mutex); } }
static gboolean _parse_uri(const char* uri, gboolean* secure, char** host, char** resource) { static GRegex* regex = NULL; GMatchInfo *match_info = NULL; g_return_val_if_fail(uri != NULL, FALSE); g_return_val_if_fail(secure != NULL, FALSE); g_return_val_if_fail(host != NULL, FALSE); g_return_val_if_fail(resource != NULL, FALSE); // precompile regexp G_LOCK(regex); if (regex == NULL) regex = g_regex_new("^([a-z]+)://([a-z0-9.-]+(:([0-9]+))?)(/.+)?$", G_REGEX_CASELESS, 0, NULL); G_UNLOCK(regex); if (!g_regex_match(regex, uri, 0, &match_info)) { g_match_info_free(match_info); return FALSE; } // check schema char* schema = g_match_info_fetch(match_info, 1); if (!g_ascii_strcasecmp("http", schema)) *secure = 0; else if (!g_ascii_strcasecmp("https", schema)) *secure = 1; else { g_free(schema); g_match_info_free(match_info); return FALSE; } g_free(schema); *host = g_match_info_fetch(match_info, 2); *resource = g_match_info_fetch(match_info, 5); if (*resource == NULL) *resource = g_strdup("/RPC2"); g_match_info_free(match_info); return TRUE; }
gboolean mime_cache_reload( MimeCache* cache ) { int i; gboolean ret = mime_cache_load( cache, cache->file_path ); /* recalculate max magic extent */ for( i = 0; i < n_caches; ++i ) { if( caches[i]->magic_max_extent > mime_cache_max_extent ) mime_cache_max_extent = caches[i]->magic_max_extent; } G_LOCK( mime_magic_buf ); mime_magic_buf = g_realloc( mime_magic_buf, mime_cache_max_extent ); G_UNLOCK( mime_magic_buf ); return ret; }
/** * g_static_private_free: * @private_key: a #GStaticPrivate to be freed * * Releases all resources allocated to @private_key. * * You don't have to call this functions for a #GStaticPrivate with an * unbounded lifetime, i.e. objects declared 'static', but if you have * a #GStaticPrivate as a member of a structure and the structure is * freed, you should also free the #GStaticPrivate. */ void g_static_private_free (GStaticPrivate *private_key) { guint idx = private_key->index; if (!idx) return; private_key->index = 0; /* Freeing the per-thread data is deferred to either the * thread end or the next g_static_private_get() call for * the same index. */ G_LOCK (g_thread); g_thread_free_indices = g_slist_prepend (g_thread_free_indices, GUINT_TO_POINTER (idx)); G_UNLOCK (g_thread); }
int crypto_global_init(int useAccel, const char *accelName, const char *accelDir) { G_LOCK(shadowtorpreloadPrimaryLock); shadowtorpreloadGlobalState.nTorCryptoNodes++; gint result = 0; if(!shadowtorpreloadGlobalState.sslInitializedGlobal) { shadowtorpreloadGlobalState.sslInitializedGlobal = TRUE; if(_shadowtorpreload_getWorker()->tor.tor_ssl_global_init) { _shadowtorpreload_getWorker()->tor.tor_ssl_global_init(); } if(_shadowtorpreload_getWorker()->tor.crypto_global_init) { result = _shadowtorpreload_getWorker()->tor.crypto_global_init(useAccel, accelName, accelDir); } } G_UNLOCK(shadowtorpreloadPrimaryLock); return result; }
static const GList * gst_alsa_device_property_probe_get_properties (GstPropertyProbe * probe) { GObjectClass *klass = G_OBJECT_GET_CLASS (probe); static GList *list = NULL; G_LOCK (probe_lock); if (!list) { GParamSpec *pspec; pspec = g_object_class_find_property (klass, "device"); list = g_list_append (NULL, pspec); } G_UNLOCK (probe_lock); return list; }
void hamlib_close(void) { if (rig == NULL) return; /* tell the hamlib thread to kill it self */ hamlib_exit = TRUE; /* and the wait for it to die */ pthread_join(hamlib_thread, NULL); hamlib_exit = FALSE; G_LOCK(hamlib_mutex); rig_close(rig); rig_cleanup(rig); rig = NULL; G_UNLOCK(hamlib_mutex); }
/** * g_time_zone_unref: * @tz: a #GTimeZone * * Decreases the reference count on @tz. * * Since: 2.26 **/ void g_time_zone_unref (GTimeZone *tz) { g_assert (tz->ref_count > 0); if (g_atomic_int_dec_and_test (&tz->ref_count)) { G_LOCK(time_zones); g_hash_table_remove (time_zones, tz->name); G_UNLOCK(time_zones); if (tz->zoneinfo) g_buffer_unref (tz->zoneinfo); g_free (tz->name); g_slice_free (GTimeZone, tz); } }
/* Return a reference to the #Client for @watcher_id, or %NULL if it’s been * unwatched. This is safe to call from any thread. */ static Client * dup_client (guint watcher_id) { Client *client; G_LOCK (lock); g_assert (watcher_id != 0); g_assert (map_id_to_client != NULL); client = g_hash_table_lookup (map_id_to_client, GUINT_TO_POINTER (watcher_id)); if (client != NULL) client_ref (client); G_UNLOCK (lock); return client; }
static void vfs_connection_closed (GDBusConnection *connection, gboolean remote_peer_vanished, GError *error, gpointer user_data) { VfsConnectionData *connection_data; connection_data = g_object_get_data (G_OBJECT (connection), "connection_data"); g_assert (connection_data != NULL); if (connection_data->async_dbus_id) { _g_daemon_vfs_invalidate_dbus_id (connection_data->async_dbus_id); G_LOCK (async_map); g_hash_table_remove (async_map, connection_data->async_dbus_id); G_UNLOCK (async_map); } }
/** * pka_manager_load_plugins: * @plugins_dir: The directory containing plugins. * * Loads plugins discovered in @plugins_dir. * * Returns: None. * Side effects: Plugins are loaded into process. */ static void pka_manager_load_plugins (const gchar *plugins_dir) /* IN */ { GError *error = NULL; PkaPlugin *plugin; const gchar *name; gchar *path; GDir *dir; ENTRY; INFO(Plugin, "Loading plugins from directory: %s", plugins_dir); if (!(dir = g_dir_open(plugins_dir, 0, &error))) { WARNING(Manager, "%s", error->message); g_error_free(error); GOTO(cleanup); } while ((name = g_dir_read_name(dir))) { if (!g_str_has_suffix(name, G_MODULE_SUFFIX)) { DEBUG(Plugin, "Skipping non-plugin: %s", name); continue; } INFO(Manager, "Discovered plugin: %s", name); path = g_build_filename(plugins_dir, name, NULL); plugin = pka_plugin_new(); if (!pka_plugin_load_from_file(plugin, path, &error)) { WARNING(Plugin, "%s", error->message); g_object_unref(plugin); g_error_free(error); error = NULL; GOTO(next); } G_LOCK(plugins); g_ptr_array_add(manager.plugins, plugin); G_UNLOCK(plugins); next: g_free(path); } cleanup: if (dir) { g_dir_close(dir); } EXIT; }
/** * g_cancellable_release_fd: * @cancellable: a #GCancellable * * Releases a resources previously allocated by g_cancellable_get_fd() * or g_cancellable_make_pollfd(). * * For compatibility reasons with older releases, calling this function * is not strictly required, the resources will be automatically freed * when the @cancellable is finalized. However, the @cancellable will * block scarce file descriptors until it is finalized if this function * is not called. This can cause the application to run out of file * descriptors when many #GCancellables are used at the same time. * * Since: 2.22 **/ void g_cancellable_release_fd (GCancellable *cancellable) { GCancellablePrivate *priv; if (cancellable == NULL) return; g_return_if_fail (G_IS_CANCELLABLE (cancellable)); g_return_if_fail (cancellable->priv->fd_refcount > 0); priv = cancellable->priv; G_LOCK (cancellable); priv->fd_refcount--; if (priv->fd_refcount == 0) g_cancellable_close_pipe (cancellable); G_UNLOCK (cancellable); }
/* called from the main thread on start-up and every 10 minutes or so */ static gboolean on_housekeeping_timeout (gpointer user_data) { UDisksLinuxProvider *provider = UDISKS_LINUX_PROVIDER (user_data); G_LOCK (provider_lock); if (provider->housekeeping_running) goto out; provider->housekeeping_running = TRUE; g_io_scheduler_push_job (housekeeping_thread_func, g_object_ref (provider), (GDestroyNotify) g_object_unref, G_PRIORITY_DEFAULT, NULL); out: G_UNLOCK (provider_lock); return TRUE; /* keep timeout around */ }
/** * g_bus_watch_name: * @bus_type: The type of bus to watch a name on. * @name: The name (well-known or unique) to watch. * @flags: Flags from the #GBusNameWatcherFlags enumeration. * @name_appeared_handler: (nullable): Handler to invoke when @name is known to exist or %NULL. * @name_vanished_handler: (nullable): Handler to invoke when @name is known to not exist or %NULL. * @user_data: User data to pass to handlers. * @user_data_free_func: (nullable): Function for freeing @user_data or %NULL. * * Starts watching @name on the bus specified by @bus_type and calls * @name_appeared_handler and @name_vanished_handler when the name is * known to have a owner respectively known to lose its * owner. Callbacks will be invoked in the * [thread-default main context][g-main-context-push-thread-default] * of the thread you are calling this function from. * * You are guaranteed that one of the handlers will be invoked after * calling this function. When you are done watching the name, just * call g_bus_unwatch_name() with the watcher id this function * returns. * * If the name vanishes or appears (for example the application owning * the name could restart), the handlers are also invoked. If the * #GDBusConnection that is used for watching the name disconnects, then * @name_vanished_handler is invoked since it is no longer * possible to access the name. * * Another guarantee is that invocations of @name_appeared_handler * and @name_vanished_handler are guaranteed to alternate; that * is, if @name_appeared_handler is invoked then you are * guaranteed that the next time one of the handlers is invoked, it * will be @name_vanished_handler. The reverse is also true. * * This behavior makes it very simple to write applications that want * to take action when a certain [name exists][gdbus-watching-names]. * Basically, the application should create object proxies in * @name_appeared_handler and destroy them again (if any) in * @name_vanished_handler. * * Returns: An identifier (never 0) that an be used with * g_bus_unwatch_name() to stop watching the name. * * Since: 2.26 */ guint g_bus_watch_name (GBusType bus_type, const gchar *name, GBusNameWatcherFlags flags, GBusNameAppearedCallback name_appeared_handler, GBusNameVanishedCallback name_vanished_handler, gpointer user_data, GDestroyNotify user_data_free_func) { Client *client; g_return_val_if_fail (g_dbus_is_name (name), 0); G_LOCK (lock); client = g_new0 (Client, 1); client->ref_count = 1; client->id = g_atomic_int_add (&next_global_id, 1); /* TODO: uh oh, handle overflow */ client->name = g_strdup (name); client->flags = flags; client->name_appeared_handler = name_appeared_handler; client->name_vanished_handler = name_vanished_handler; client->user_data = user_data; client->user_data_free_func = user_data_free_func; client->main_context = g_main_context_ref_thread_default (); if (map_id_to_client == NULL) { map_id_to_client = g_hash_table_new (g_direct_hash, g_direct_equal); } g_hash_table_insert (map_id_to_client, GUINT_TO_POINTER (client->id), client); g_bus_get (bus_type, NULL, connection_get_cb, client_ref (client)); G_UNLOCK (lock); return client->id; }
/* HOLDS: main_loop_lock */ static void g_main_dispatch (GTimeVal *dispatch_time) { while (pending_dispatches != NULL) { gboolean need_destroy; GSource *source = pending_dispatches->data; GSList *tmp_list; tmp_list = pending_dispatches; pending_dispatches = g_slist_remove_link (pending_dispatches, pending_dispatches); g_slist_free_1 (tmp_list); if (G_HOOK_IS_VALID (source)) { gboolean was_in_call; gpointer hook_data = source->hook.data; gpointer source_data = source->source_data; gboolean (*dispatch) (gpointer, GTimeVal *, gpointer); dispatch = ((GSourceFuncs *) source->hook.func)->dispatch; was_in_call = G_HOOK_IN_CALL (source); source->hook.flags |= G_HOOK_FLAG_IN_CALL; G_UNLOCK (main_loop); need_destroy = ! dispatch (source_data, dispatch_time, hook_data); G_LOCK (main_loop); if (!was_in_call) source->hook.flags &= ~G_HOOK_FLAG_IN_CALL; if (need_destroy && G_HOOK_IS_VALID (source)) g_hook_destroy_link (&source_list, (GHook *) source); } g_hook_unref (&source_list, (GHook*) source); } }
/* HOLDS: main_loop lock */ static void g_source_destroy_func (GHookList *hook_list, GHook *hook) { GSource *source = (GSource*) hook; GDestroyNotify destroy; G_UNLOCK (main_loop); destroy = hook->destroy; if (destroy) destroy (hook->data); destroy = ((GSourceFuncs*) hook->func)->destroy; if (destroy) destroy (source->source_data); G_LOCK (main_loop); }
static void coordinates_render(OsmGpsMapAis *self, OsmGpsMap *map) { OsdCoordinates_t *coordinates = self->priv->coordinates; OsmGpsMapPoint point; if(!coordinates->surface) return; gfloat lat, lon; g_object_get(G_OBJECT(map), "latitude", &lat, "longitude", &lon, NULL); coordinates->lat = lat; coordinates->lon = lon; gint pixel_x, pixel_y; g_assert(coordinates->surface); cairo_t *cr = cairo_create(coordinates->surface); cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE); cairo_set_source_rgba(cr, 0.0, 0.0, 0.0, 0.0); cairo_paint(cr); cairo_set_operator(cr, CAIRO_OPERATOR_OVER); cairo_set_source_rgba(cr, 0.0, 0.0, 0.0, 1.0); cairo_set_line_width(cr, 1); int i; float theta; printf("Number of vessels: %d\n",numberofships); G_LOCK(updatemap); for(i=0;i<numberofships;i++) { osm_gps_map_point_set_degrees(&point, ships[i]->latitude, ships[i]->longitude); osm_gps_map_convert_geographic_to_screen(map, &point, &pixel_x,&pixel_y); if (ships[i]->heading != 511) theta = ships[i]->heading * M_PI / 180; else theta = ships[i]->course * M_PI / 180; draw_one_boat(cr,(int)pixel_x,(int)pixel_y,theta); printf("%f %f\n",ships[i]->latitude, ships[i]->longitude); } G_UNLOCK(updatemap); cairo_destroy(cr); }
static void test_g_mutex (void) { GThread *thread; g_assert (g_mutex_trylock (&test_g_mutex_mutex)); g_assert (G_TRYLOCK (test_g_mutex)); test_g_mutex_thread_ready = FALSE; thread = g_thread_create (test_g_mutex_thread, GINT_TO_POINTER (42), TRUE, NULL); /* This busy wait is only for testing purposes and not an example of * good code!*/ while (!test_g_mutex_thread_ready) g_usleep (G_USEC_PER_SEC / 5); test_g_mutex_int = 42; G_UNLOCK (test_g_mutex); g_mutex_unlock (&test_g_mutex_mutex); g_assert (GPOINTER_TO_INT (g_thread_join (thread)) == 41); }
/** * catch_log_handler: * @log_domain: A string containing the log section. * @log_level: A #GLogLevelFlags. * @message: The string message. * @user_data: User data supplied to g_log_set_default_handler(). * * Default log handler that will dispatch log messages to configured logging * destinations. */ static void catch_log_handler (const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer user_data) { struct tm tt; time_t t; const gchar *level; gchar ftime[32]; gchar *buffer; guint msec; if (G_LIKELY(channels->len)) { level = catch_log_level_str(log_level); #ifdef __linux__ { struct timespec ts; clock_gettime(CLOCK_REALTIME, &ts); t = (time_t)ts.tv_sec; msec = ts.tv_nsec / 100000; } #else { struct timeval tv; gettimeofday(&tv, NULL); t = tv.tv_sec; msec = tv.tv_usec / 1000; } #endif tt = *localtime(&t); strftime(ftime, sizeof(ftime), "%Y/%m/%d %H:%M:%S", &tt); buffer = g_strdup_printf("%s.%04u %s: %12s[%d]: %8s: %s\n", ftime, msec, hostname, log_domain, catch_log_get_thread(), level, message); G_LOCK(channels_lock); g_ptr_array_foreach(channels, (GFunc)catch_log_write_to_channel, buffer); G_UNLOCK(channels_lock); g_free(buffer); } }
static void g_hash_nodes_destroy (MonoGHashNode *hash_node, MonoGHashGCType type, GFreeFunc key_destroy_func, GFreeFunc value_destroy_func) { if (hash_node) { MonoGHashNode *node = hash_node; while (node->next) { if (key_destroy_func) key_destroy_func (node->key); if (value_destroy_func) value_destroy_func (node->value); node->key = NULL; node->value = NULL; node = node->next; } if (key_destroy_func) key_destroy_func (node->key); if (value_destroy_func) value_destroy_func (node->value); node->key = NULL; node->value = NULL; G_LOCK (g_hash_global); #if defined(HAVE_SGEN_GC) || defined(HAVE_BOEHM_GC) node->next = node_free_lists [type]; node_free_lists [type] = hash_node; #else node->next = node_free_list; node_free_list = hash_node; #endif G_UNLOCK (g_hash_global); } }