static void _osync_trace_init()
{
	const char *noprivacy;
	const char *error;
	trace = g_getenv("OSYNC_TRACE");
	if (!trace)
		return;
	
	noprivacy = g_getenv("OSYNC_NOPRIVACY");
	if (!trace_sensitive)
		trace_sensitive = g_private_new(NULL);

	if (noprivacy)
		g_private_set(trace_sensitive, GINT_TO_POINTER(1));
	else
		g_private_set(trace_sensitive, GINT_TO_POINTER(0));

	error = g_getenv("OSYNC_PRINTERROR");
	if (!print_stderr)
		print_stderr = g_private_new(NULL);

	if (error)
		g_private_set(print_stderr, GINT_TO_POINTER(1));
	else
		g_private_set(print_stderr, GINT_TO_POINTER(0));
	
	if (!g_file_test(trace, G_FILE_TEST_IS_DIR)) {
		printf("OSYNC_TRACE argument is no directory\n");
		return;
	}
}
/**
 * gst_gl_context_activate:
 * @context: a #GstGLContext
 * @activate: %TRUE to activate, %FALSE to deactivate
 *
 * (De)activate the OpenGL context represented by this @context.
 *
 * In OpenGL terms, calls eglMakeCurrent or similar with this context and the
 * currently set window.  See gst_gl_context_set_window() for details.
 *
 * Returns: Whether the activation succeeded
 *
 * Since: 1.4
 */
gboolean
gst_gl_context_activate (GstGLContext * context, gboolean activate)
{
  GstGLContextClass *context_class;
  gboolean result;

  g_return_val_if_fail (GST_IS_GL_CONTEXT (context), FALSE);
  context_class = GST_GL_CONTEXT_GET_CLASS (context);
  g_return_val_if_fail (context_class->activate != NULL, FALSE);

  GST_DEBUG_OBJECT (context, "activate:%d", activate);

  GST_OBJECT_LOCK (context);
  result = context_class->activate (context, activate);

  if (result && activate) {
    context->priv->active_thread = g_thread_self ();
    g_private_set (&current_context_key, context);
  } else {
    context->priv->active_thread = NULL;
    g_private_set (&current_context_key, NULL);
  }
  GST_OBJECT_UNLOCK (context);

  return result;
}
void osync_trace_enable(void)
{
	if (!trace_disabled)
		trace_disabled = g_private_new (NULL);

	if (!trace)
		g_private_set(trace_disabled, GINT_TO_POINTER(1));
	else
		g_private_set(trace_disabled, GINT_TO_POINTER(0));

}
Exemple #4
0
extern void
TLSSetValue(TLSItem pItem, size_t value)
{
    size_t *pNew = (size_t *) malloc(sizeof(size_t));
    *pNew = value;
    g_private_set(pItem, (gpointer) pNew);
}
Exemple #5
0
static void
TLSSetValue(TLSItem pItem, int value)
{
    int *pNew = (int *) malloc(sizeof(int));
    *pNew = value;
    g_private_set(pItem, (gpointer) pNew);
}
void
rb_threads_init (void)
{
	GMutex *m;

	private_is_primary_thread = g_private_new (NULL);
	g_private_set (private_is_primary_thread, GUINT_TO_POINTER (1));

	g_static_rec_mutex_init (&rb_gdk_mutex);
	gdk_threads_set_lock_functions (_threads_enter, _threads_leave);
	gdk_threads_init ();

	m = g_mutex_new ();

	g_mutex_lock (m);
	mutex_recurses = g_mutex_trylock (m);
	if (mutex_recurses)
		g_mutex_unlock (m);
	g_mutex_unlock (m);
	g_mutex_free (m);

	rb_debug ("GMutex %s recursive", mutex_recurses ? "is" : "isn't");

	/* purge useless thread-pool threads occasionally */
	g_timeout_add_seconds (30, purge_useless_threads, NULL);
}
Exemple #7
0
const char *
guid_to_string(const GncGUID * guid)
{
#ifdef G_THREADS_ENABLED
#ifndef HAVE_GLIB_2_32
    static GStaticPrivate guid_buffer_key = G_STATIC_PRIVATE_INIT;
    gchar *string;

    string = static_cast<gchar*>(g_static_private_get (&guid_buffer_key));
    if (string == NULL)
    {
        string = static_cast<gchar*>(malloc(GUID_ENCODING_LENGTH + 1));
        g_static_private_set (&guid_buffer_key, string, g_free);
    }
#else
    static GPrivate guid_buffer_key = G_PRIVATE_INIT(g_free);
    gchar *string;

    string = static_cast<char*>(g_private_get (&guid_buffer_key));
    if (string == NULL)
    {
        string = static_cast<char*>(malloc(GUID_ENCODING_LENGTH + 1));
        g_private_set (&guid_buffer_key, string);
    }
#endif
#else
    static char string[64];
#endif

    encode_md5_data(guid->data, string);
    string[GUID_ENCODING_LENGTH] = '\0';

    return string;
}
Exemple #8
0
gpointer
g_thread_proxy (gpointer data)
{
  GRealThread* thread = data;

  g_assert (data);

  /* This has to happen before G_LOCK, as that might call g_thread_self */
  g_private_set (&g_thread_specific_private, data);

  /* The lock makes sure that g_thread_new_internal() has a chance to
   * setup 'func' and 'data' before we make the call.
   */
  G_LOCK (g_thread_new);
  G_UNLOCK (g_thread_new);

  if (thread->name)
    {
      g_system_thread_set_name (thread->name);
      g_free (thread->name);
      thread->name = NULL;
    }

  thread->retval = thread->thread.func (thread->thread.data);

  return NULL;
}
void
libMary_threadLocalInit ()
{
  #ifdef LIBMARY_MT_SAFE
    _libMary_main_tlocal = new (std::nothrow) LibMary_ThreadLocal;
    assert (_libMary_main_tlocal);

    #ifdef LIBMARY_PTHREAD
      {
          int const res = pthread_key_create (&_libMary_tlocal_key, tlocal_destructor);
          assert (res == 0);
      }

      {
          int const res = pthread_setspecific (_libMary_tlocal_key, _libMary_main_tlocal);
          assert (res == 0);
      }
    #else
      #ifdef LIBMARY__OLD_GTHREAD_API
        _libMary_tlocal_gprivate_dtor = g_private_new (tlocal_destructor);
        #ifndef LIBMARY_TLOCAL
          _libMary_tlocal_gprivate = g_private_new (NULL /* notify */);
        #endif
      #endif

      g_private_set (LIBMARY__TLOCAL_GPRIVATE, _libMary_main_tlocal);
    #endif
  #else
      _libMary_tlocal = new (std::nothrow) LibMary_ThreadLocal;
      assert (_libMary_tlocal);
  #endif
}
static void
tlocal_destructor (_libMary_VoidPtr const _tlocal)
{
    logD_ (_func, "tlocal ", (UintPtr) _tlocal);

  #ifndef LIBMARY_TLOCAL
    #ifndef LIBMARY_PTHREAD
      // All gprivates are reset to NULL by glib/pthreads before tlocal_destructor()
      // is called. We restore the right value for tlocal gprivate, which is safe
      // since it doesn't have an associated destructor callback.
      g_private_set (LIBMARY__TLOCAL_GPRIVATE, _tlocal);
    #endif
  #endif

    // Exception dtors may call arbitrary code, so we're
    // clearing exceptions first.
    exc_none ();

    if (LibMary_ThreadLocal * const tlocal = static_cast <LibMary_ThreadLocal*> (_tlocal))
        delete tlocal;

  #ifdef LIBMARY_TLOCAL
    _libMary_tlocal = NULL;
  #endif
}
static const gchar *
iter_to_string (GtkTreeIter *iter)
{
#ifdef G_THREADS_ENABLED
    static GPrivate gtmits_buffer_key = G_PRIVATE_INIT(g_free);
    gchar *string;

    string = g_private_get (&gtmits_buffer_key);
    if (string == NULL)
    {
        string = g_malloc(ITER_STRING_LEN + 1);
        g_private_set (&gtmits_buffer_key, string);
    }
#else
    static char string[ITER_STRING_LEN + 1];
#endif

    if (iter)
        snprintf(string, ITER_STRING_LEN,
                 "[stamp:%x data:%p (%s), %p, %d]",
                 iter->stamp, iter->user_data,
                 gncOwnerGetName ((GncOwner *) iter->user_data),
                 iter->user_data2, GPOINTER_TO_INT(iter->user_data3));
    else
        strcpy(string, "(null)");
    return string;
}
static int
trg_http_perform_inner(TrgClient * tc, gchar * reqstr,
                       trg_response * response, gboolean recurse)
{
    TrgClientPrivate *priv = tc->priv;
    TrgPrefs *prefs = trg_client_get_prefs(tc);
    gpointer threadLocalStorage = g_private_get(priv->tlsKey);
    trg_tls *tls;
    long httpCode = 0;
    gchar *session_id;
    struct curl_slist *headers = NULL;

    if (!threadLocalStorage) {
        tls = trg_tls_new(tc);
        g_private_set(priv->tlsKey, tls);
    } else {
        tls = (trg_tls *) threadLocalStorage;
    }

    g_mutex_lock(priv->configMutex);

    if (priv->configSerial > tls->serial)
        trg_tls_update(tc, tls, priv->configSerial);

    session_id = trg_client_get_session_id(tc);
    if (session_id) {
        headers = curl_slist_append(NULL, session_id);
        curl_easy_setopt(tls->curl, CURLOPT_HTTPHEADER, headers);
    }

    curl_easy_setopt(tls->curl, CURLOPT_TIMEOUT,
                     (long) trg_prefs_get_int(prefs, TRG_PREFS_KEY_TIMEOUT,
                                              TRG_PREFS_CONNECTION));

    g_mutex_unlock(priv->configMutex);

    response->size = 0;
    response->raw = NULL;

    curl_easy_setopt(tls->curl, CURLOPT_POSTFIELDS, reqstr);
    curl_easy_setopt(tls->curl, CURLOPT_WRITEDATA, (void *) response);
    response->status = curl_easy_perform(tls->curl);

    if (session_id) {
        g_free(session_id);
        curl_slist_free_all(headers);
    }

    curl_easy_getinfo(tls->curl, CURLINFO_RESPONSE_CODE, &httpCode);

    if (response->status == CURLE_OK) {
        if (httpCode == HTTP_CONFLICT && recurse == TRUE)
            return trg_http_perform_inner(tc, reqstr, response, FALSE);
        else if (httpCode != HTTP_OK)
            response->status = (-httpCode) - 100;
    }

    return response->status;
}
Exemple #13
0
static void
log4g_thread_class_init(Log4gThreadClass *klass)
{
	GObjectClass *object_class = G_OBJECT_CLASS(klass);
	g_private_set(&priv, NULL);
	object_class->constructor = constructor;
	object_class->finalize = finalize;
	g_type_class_add_private(klass, sizeof(struct Private));
}
Exemple #14
0
void
gst_srtp_init_event_reporter (void)
{
  struct GstSrtpEventReporterData *dat = g_private_get (&current_callback);

  if (!dat) {
    dat = g_slice_new (struct GstSrtpEventReporterData);
    g_private_set (&current_callback, dat);
  }
static void
g_enumerable_thread_add (GRealThread *thread)
{
  G_LOCK (g_thread);
  g_thread_all_threads = g_slist_prepend (g_thread_all_threads, thread);
  G_UNLOCK (g_thread);

  g_private_set (&enumerable_thread_private, thread);
}
Exemple #16
0
void
vips__buffer_shutdown( void )
{
	VipsBufferThread *buffer_thread;

	if( (buffer_thread = g_private_get( buffer_thread_key )) ) {
		buffer_thread_free( buffer_thread );
		g_private_set( buffer_thread_key, NULL );
	}
}
/* preload_init must be called before this so the worker gets created */
static PreloadWorker* _shadowtorpreload_getWorker() {
	/* get current thread's private worker object */
	PreloadWorker* worker = g_private_get(&threadPreloadWorkerKey);
	if(!worker) {
	    worker = g_new0(PreloadWorker, 1);
        g_private_set(&threadPreloadWorkerKey, worker);
	}
	g_assert(worker);
	return worker;
}
Exemple #18
0
/**
 * g_cancellable_push_current:
 * @cancellable: a #GCancellable object
 *
 * Pushes @cancellable onto the cancellable stack. The current
 * cancellable can then be received using g_cancellable_get_current().
 *
 * This is useful when implementing cancellable operations in
 * code that does not allow you to pass down the cancellable object.
 *
 * This is typically called automatically by e.g. #GFile operations,
 * so you rarely have to call this yourself.
 **/
void
g_cancellable_push_current (GCancellable *cancellable)
{
  GSList *l;

  g_return_if_fail (cancellable != NULL);

  l = g_private_get (&current_cancellable);
  l = g_slist_prepend (l, cancellable);
  g_private_set (&current_cancellable, l);
}
static void
mate_vfs_thread_init (void)
{
	private_is_primary_thread = g_private_new (NULL);
	g_private_set (private_is_primary_thread, GUINT_TO_POINTER (1));
	
	_mate_vfs_module_callback_private_init ();
	
	_mate_vfs_async_job_map_init ();
	_mate_vfs_job_queue_init ();
}
Exemple #20
0
/* Get the buffer cache. 
 */
static VipsBufferCache *
buffer_cache_get( void )
{
	VipsBufferCache *cache;

	if( !(cache = g_private_get( thread_buffer_cache_key )) ) {
		cache = buffer_cache_new();
		g_private_set( thread_buffer_cache_key, cache );
	}

	return( cache );
}
Exemple #21
0
/**
 * g_cancellable_pop_current:
 * @cancellable: a #GCancellable object
 *
 * Pops @cancellable off the cancellable stack (verifying that @cancellable
 * is on the top of the stack).
 **/
void
g_cancellable_pop_current (GCancellable *cancellable)
{
  GSList *l;

  l = g_private_get (&current_cancellable);

  g_return_if_fail (l != NULL);
  g_return_if_fail (l->data == cancellable);

  l = g_slist_delete_link (l, l);
  g_private_set (&current_cancellable, l);
}
Exemple #22
0
static GMainContext *
get_rust_thread_context ()
{
  GMainContext *context;

  context = g_private_get (&rust_thread_context);
  if (context == NULL)
    {
      context = g_main_context_new ();
      g_private_set (&rust_thread_context, context);
    }
  return context;
}
static trg_tls *get_tls(TrgClient *tc) {
	TrgClientPrivate *priv = tc->priv;
	gpointer threadLocalStorage = g_private_get(&priv->tlsKey);
	trg_tls *tls;

    if (!threadLocalStorage) {
        tls = trg_tls_new(tc);
        g_private_set(&priv->tlsKey, tls);
    } else {
        tls = (trg_tls *) threadLocalStorage;
    }

    return tls;
}
Exemple #24
0
static VipsBufferThread *
buffer_thread_get( void )
{
	VipsBufferThread *buffer_thread;

	if( !(buffer_thread = g_private_get( buffer_thread_key )) ) {
		buffer_thread = buffer_thread_new();
		g_private_set( buffer_thread_key, buffer_thread );
	}

	g_assert( buffer_thread->thread == g_thread_self() ); 

	return( buffer_thread );
}
Exemple #25
0
void worker_free(Worker* worker) {
    MAGIC_ASSERT(worker);

    /* calls the destroy functions we specified in g_hash_table_new_full */
    g_hash_table_destroy(worker->privatePrograms);

    if(worker->serialEventQueue) {
        eventqueue_free(worker->serialEventQueue);
    }

    MAGIC_CLEAR(worker);
    g_private_set(&workerKey, NULL);
    g_free(worker);
}
Exemple #26
0
static magic_t get_private_magic(void)
{
	magic_t m;

	m = (magic_t)g_private_get(private_key);

	if (m == NULL) {
		m = magic_open(MAGIC_MIME_TYPE);
		magic_load(m, NULL);

		g_private_set(private_key, (gpointer)m);
	}

	return m;
}
Exemple #27
0
/* This usually happens automatically when a thread shuts down, see 
 * vips__thread_profile_init() where we set a GDestroyNotify, but will not
 * happen for the main thread. 
 *
 * Shut down any stats on the main thread with this, see vips_shutdown()
 */
void
vips__thread_profile_detach( void ) 
{
	VipsThreadProfile *profile;

	VIPS_DEBUG_MSG( "vips__thread_profile_detach:\n" ); 

	if( (profile = vips_thread_profile_get()) ) {
		if( vips__thread_profile ) 
			vips_thread_profile_save( profile ); 

		vips_thread_profile_free( profile );
		g_private_set( vips_thread_profile_key, NULL );
	}
}
Exemple #28
0
static GObject *
constructor(GType type, guint n, GObjectConstructParam *params)
{
	GObject *self = g_private_get(&priv);
	if (!self) {
		self = G_OBJECT_CLASS(log4g_thread_parent_class)->
			constructor(type, n, params);
		if (!self) {
			return NULL;
		}
		g_private_set(&priv, self);
	} else {
		g_object_ref(self);
	}
	return self;
}
/**
 * g_static_private_set:
 * @private_key: a #GStaticPrivate
 * @data: the new pointer
 * @notify: a function to be called with the pointer whenever the
 *     current thread ends or sets this pointer again
 *
 * Sets the pointer keyed to @private_key for the current thread and
 * the function @notify to be called with that pointer (%NULL or
 * non-%NULL), whenever the pointer is set again or whenever the
 * current thread ends.
 *
 * This function works even if g_thread_init() has not yet been called.
 * If g_thread_init() is called later, the @data keyed to @private_key
 * will be inherited only by the main thread, i.e. the one that called
 * g_thread_init().
 *
 * @notify is used quite differently from @destructor in g_private_new().
 */
void
g_static_private_set (GStaticPrivate *private_key,
                      gpointer        data,
                      GDestroyNotify  notify)
{
  GArray *array;
  static guint next_index = 0;
  GStaticPrivateNode *node;

  if (!private_key->index)
    {
      G_LOCK (g_thread);

      if (!private_key->index)
        {
          if (g_thread_free_indices)
            {
              private_key->index = GPOINTER_TO_UINT (g_thread_free_indices->data);
              g_thread_free_indices = g_slist_delete_link (g_thread_free_indices,
                                                           g_thread_free_indices);
            }
          else
            private_key->index = ++next_index;
        }

      G_UNLOCK (g_thread);
    }

  array = g_private_get (&static_private_private);
  if (!array)
    {
      array = g_array_new (FALSE, TRUE, sizeof (GStaticPrivateNode));
      g_private_set (&static_private_private, array);
    }
  if (private_key->index > array->len)
    g_array_set_size (array, private_key->index);

  node = &g_array_index (array, GStaticPrivateNode, private_key->index - 1);

  if (node->destroy)
    node->destroy (node->data);

  node->data = data;
  node->destroy = notify;
  node->owner = private_key;
}
Exemple #30
0
/* Get the buffer cache. 
 */
static im_buffer_cache_t *
buffer_cache_get( void )
{
	im_buffer_cache_t *cache;

#ifdef HAVE_THREADS
	if( !(cache = g_private_get( thread_buffer_cache_key )) ) {
		cache = buffer_cache_new();
		g_private_set( thread_buffer_cache_key, cache );
	}
#else /*!HAVE_THREADS*/
	if( !thread_buffer_cache )
		thread_buffer_cache = buffer_cache_new();
	cache = thread_buffer_cache;
#endif /*HAVE_THREADS*/

	return( cache );
}