Example #1
0
/* The main function of a freshly creating thread.  It's a wrapper around
   the FUNC and ARG arguments passed to glthread_create_func.  */
static unsigned int WINAPI
wrapper_func (void *varg)
{
  struct gl_thread_struct *thread = (struct gl_thread_struct *)varg;

  EnterCriticalSection (&thread->handle_lock);
  /* Create a new handle for the thread only if the parent thread did not yet
     fill in the handle.  */
  if (thread->handle == NULL)
    thread->handle = get_current_thread_handle ();
  LeaveCriticalSection (&thread->handle_lock);

  if (self_key == (DWORD)-1)
    init_self_key ();
  TlsSetValue (self_key, thread);

  /* Run the thread.  Store the exit value if the thread was not terminated
     otherwise.  */
  thread->result = thread->func (thread->arg);
  return 0;
}
Example #2
0
EASYHOOK_NT_INTERNAL RhSetWakeUpThreadID(ULONG InThreadID)
{
/*
Description:
    
    Used in conjunction with RhCreateAndInject(). If the given thread
    later is resumed in RhWakeUpProcess(), the injection target will
    start its usual execution.

*/
    NTSTATUS            NtStatus;

    if(!TlsSetValue(RhTlsIndex, (LPVOID)(size_t)InThreadID))
        THROW(STATUS_INTERNAL_ERROR, L"Unable to set TLS value.");

    RETURN(STATUS_SUCCESS);

THROW_OUTRO:
FINALLY_OUTRO:
    return NtStatus;
}
Example #3
0
static unsigned long WINAPI _threadstart (
    void * ptd
)
{
    /*
     * Stash the pointer to the per-thread data stucture in TLS
     */
    if ( !TlsSetValue(__tlsindex, ptd) )
        _amsg_exit(_RT_THREAD);

    /*
     * Call fp initialization, if necessary
     */
    if ( _FPmtinit != NULL )
        (*_FPmtinit)();

    /*
     * Guard call to user code with a _try - _except statement to
     * implement runtime errors and signal support
     */
    __try {
        ( (void(__cdecl *)(void *))(((_ptiddata)ptd)->_initaddr) )
        ( ((_ptiddata)ptd)->_initarg );

        _endthread();
    }
    __except ( _XcptFilter(GetExceptionCode(), GetExceptionInformation()) )
    {
        /*
         * Should never reach here
         */
        _exit( GetExceptionCode() );

    } /* end of _try - _except */

    /*
     * Never executed!
     */
    return(0L);
}
pthread_t pthread_self(void)
{
  pthread_t t;
	
  _pthread_once_raw(&_pthread_tls_once, pthread_tls_init);
	
  t = (pthread_t)TlsGetValue(_pthread_tls);
	
  /* Main thread? */
  if (!t)
    {
      t = (pthread_t)malloc(sizeof(struct _pthread_v));
		
      /* If cannot initialize main thread, then the only thing we can do is abort */
      if (!t) abort();
	
      t->ret_arg = NULL;
      t->func = NULL;
      t->clean = NULL;
      t->cancelled = 0;
      t->p_state = PTHREAD_DEFAULT_ATTR;
      t->keymax = 0;
      t->keyval = NULL;
      t->h = GetCurrentThread();
		
      /* Save for later */
      TlsSetValue(_pthread_tls, t);
		
      if (setjmp(t->jb))
	{
	  /* Make sure we free ourselves if we are detached */
	  if (!t->h) free(t);
			
	  /* Time to die */
	  _endthreadex(0);
	}
    }
	
  return t;
}
Example #5
0
static HDC getBitmapDC(void *imageData) {
    HDC hdc;
    HANDLE  *mutex = (HANDLE*) TlsGetValue(tlsId);

    if(mutex == NULL) {
        mutex = (HANDLE*)malloc(sizeof(HANDLE));
        if(mutex == NULL) {
            return NULL;
        }
        TlsSetValue(tlsId, mutex);
        *mutex = CreateMutex(0, JAVACALL_FALSE, "hPhoneBitmapMutex");
    }

    if(lastImage != imageData) {
        if(hMemDC != NULL) {
            DeleteDC(hMemDC);
        }

        hdc = GetDC(hMainWindow);
        hMemDC = CreateCompatibleDC(hdc);
        ReleaseDC(hMainWindow, hdc);
        lastImage = imageData;
    }

    WaitForSingleObject(*mutex, INFINITE);

    if(imageData == NULL) {
        CHECK_RETURN(getBitmapDCtmp = SelectObject(hMemDC, hPhoneBitmap));
        SetWindowOrgEx(hMemDC, -x_offset, -(Y_SCREEN_OFFSET), NULL);
    } else if(imageData == UNTRANSLATED_SCREEN_BITMAP) {
        CHECK_RETURN(getBitmapDCtmp = SelectObject(hMemDC, hPhoneBitmap));
    } else {
        myBitmapStruct *bmp = (myBitmapStruct *)imageData;
        if(bmp->mutable) {
            getBitmapDCtmp = SelectObject(hMemDC, bmp->bitmap);
        }
    }

    return hMemDC;
}
Example #6
0
VOID _PrintExit(const CHAR *psz, ...)
{
	DWORD dwErr = GetLastError();
	
	LONG nIndent = 0;
	LONG nThread = 0;
	if (s_nTlsIndent >= 0) {
		nIndent = (LONG)TlsGetValue(s_nTlsIndent) - 1;
        ASSERT(nIndent >= 0);
		TlsSetValue(s_nTlsIndent, (PVOID)nIndent);
	}
	if (s_nTlsThread >= 0) {
		nThread = (LONG)TlsGetValue(s_nTlsThread);
	}
		
	if (s_bLog && psz) {
		CHAR szBuf[1024];
        PCHAR pszBuf = szBuf;
		LONG nLen = (nIndent > 0) ? (nIndent < 35 ? nIndent * 2 : 70) : 0;
        *pszBuf++ = (CHAR)('0' + ((nThread / 100) % 10));
		*pszBuf++ = (CHAR)('0' + ((nThread / 10) % 10));
		*pszBuf++ = (CHAR)('0' + ((nThread / 1) % 10));
		*pszBuf++ = ' ';
        while (nLen-- > 0) {
            *pszBuf++ = ' ';
        }

		va_list  args;
		va_start(args, psz);

        while ((*pszBuf++ = *psz++) != 0) {
            // Copy characters.
        }
        SyelogV(SYELOG_SEVERITY_INFORMATION,
                szBuf, args);

		va_end(args);
	}
	SetLastError(dwErr);
}
Example #7
0
File: hal.c Project: callcc/tekui
EXPORT TBOOL
hal_initthread(struct THALBase *hal, struct THALObject *thread,
	TTASKENTRY void (*function)(struct TTask *task), TAPTR data)
{
	struct HALThread *wth = THALNewObject(hal, thread, struct HALThread);
	if (wth)
	{
		wth->hth_SigEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
		if (wth->hth_SigEvent)
		{
#ifndef HAL_USE_ATOMICS
			InitializeCriticalSection(&wth->hth_SigLock);
#endif
			wth->hth_SigState = 0;
			wth->hth_HALBase = hal;
			wth->hth_Data = data;
			wth->hth_Function = function;
			THALSetObject(thread, struct HALThread, wth);
			if (function)
			{
				wth->hth_Thread = (TAPTR) _beginthreadex(NULL, 0,
					hal_win32thread_entry, wth, 0, (HANDLE) &wth->hth_ThreadID);
				if (wth->hth_Thread) return TTRUE;
			}
			else
			{
				struct HALSpecific *hws = hal->hmb_Specific;
				TlsSetValue(hws->hsp_TLSIndex, wth);
				return TTRUE;
			}
#ifndef HAL_USE_ATOMICS
			DeleteCriticalSection(&wth->hth_SigLock);
#endif
			CloseHandle(wth->hth_SigEvent);
		}
		THALDestroyObject(hal, wth, struct HALThread);
	}
	TDBPRINTF(20,("could not create thread\n"));
	return TFALSE;
}
Example #8
0
void __cdecl _freeptd (
        _ptiddata ptd
        )
{
        /*
         * Do nothing unless per-thread data has been allocated for this module!
         */

        if ( __flsindex != 0xFFFFFFFF ) {

            /*
             * if parameter "ptd" is NULL, get the per-thread data pointer
             * Must NOT call _getptd because it will allocate one if none exists!
             * If FLS_GETVALUE is NULL then ptd could not have been set
             */

            if ( ptd == NULL
#ifndef _M_AMD64
                 && (FLS_GETVALUE != NULL)
#endif  /* _M_AMD64 */
                )
                ptd = FLS_GETVALUE(__flsindex);

            /*
             * Zero out the one pointer to the per-thread data block
             */

            FLS_SETVALUE(__flsindex, (LPVOID)0);

            _freefls(ptd);
        }

        if ( __getvalueindex != 0xFFFFFFFF ) {
            /*
             * Zero out the FlsGetValue pointer
             */
            TlsSetValue(__getvalueindex, (LPVOID)0);
        }
}
Example #9
0
/* static */
bool JsrtContext::TrySetCurrent(JsrtContext * context)
{
    Assert(s_tlsSlot != TLS_OUT_OF_INDEXES);

    ThreadContext * threadContext;

    //We are not pinning the context after SetCurrentContext, so if the context is not pinned
    //it might be reclaimed half way during execution. In jsrtshell the runtime was optimized out
    //at time of JsrtContext::Run by the compiler.
    //The change is to pin the context at setconcurrentcontext, and unpin the previous one. In
    //JsDisposeRuntime we'll reject if current context is active, so that will make sure all
    //contexts are unpinned at time of JsDisposeRuntime.
    if (context != nullptr)
    {
        threadContext = context->GetScriptContext()->GetThreadContext();

        if (!ThreadContextTLSEntry::TrySetThreadContext(threadContext))
        {
            return false;
        }
        threadContext->GetRecycler()->RootAddRef((LPVOID)context);
    }
    else
    {
        if (!ThreadContextTLSEntry::ClearThreadContext(true))
        {
            return false;
        }
    }

    JsrtContext* originalContext = (JsrtContext*) TlsGetValue(s_tlsSlot);
    if (originalContext != nullptr)
    {
        originalContext->GetScriptContext()->GetRecycler()->RootRelease((LPVOID) originalContext);
    }

    TlsSetValue(s_tlsSlot, context);
    return true;
}
Example #10
0
void iv_init(void)
{
	struct iv_state *st;

	if (iv_state_index == -1) {
		iv_state_index = TlsAlloc();
		if (iv_state_index == TLS_OUT_OF_INDEXES)
			iv_fatal("iv_init: failed to allocate TLS key");
	}

	st = calloc(1, iv_tls_total_state_size());
	TlsSetValue(iv_state_index, st);

	iv_handle_init(st);
	iv_task_init(st);
	iv_time_init(st);
	iv_timer_init(st);

	iv_event_init(st);

	iv_tls_thread_init(st);
}
Example #11
0
int virThreadLocalInit(virThreadLocalPtr l,
                       virThreadLocalCleanup c)
{
    if ((l->key = TlsAlloc()) == TLS_OUT_OF_INDEXES) {
        errno = ESRCH;
        return -1;
    }
    TlsSetValue(l->key, NULL);

    if (c) {
        virMutexLock(&virThreadLocalLock);
        if (VIR_REALLOC_N(virThreadLocalList,
                          virThreadLocalCount + 1) < 0)
            return -1;
        virThreadLocalList[virThreadLocalCount].key = l->key;
        virThreadLocalList[virThreadLocalCount].cleanup = c;
        virThreadLocalCount++;
        virMutexUnlock(&virThreadLocalLock);
    }

    return 0;
}
Example #12
0
static TheCustomHeapType * initializeCustomHeap (void)
{
#if !defined(_WIN32)
  createKey();
  assert (pthread_getspecific (theHeapKey) == NULL);
#endif
  // Allocate a per-thread heap.
  TheCustomHeapType * heap;
  size_t sz = sizeof(TheCustomHeapType) + sizeof(double);
  void * mh = getMainHoardHeap()->malloc(sz);
  heap = new ((char *) mh) TheCustomHeapType (getMainHoardHeap());

  // Store it in the appropriate thread-local area.
#if defined(_WIN32)
  TlsSetValue (LocalTLABIndex, heap);
#else
  int r = pthread_setspecific (theHeapKey, (void *) heap);
  assert (!r);
#endif

  return heap;
}
Example #13
0
// Obtains a manager for the thread, with refcounting
CMenuFocusManager * CMenuFocusManager::AcquireManager()
{
    CMenuFocusManager * obj = NULL;

    if (!TlsIndex)
    {
        if ((TlsIndex = TlsAlloc()) == TLS_OUT_OF_INDEXES)
            return NULL;
    }

    obj = GetManager();

    if (!obj)
    {
        obj = new CComObject<CMenuFocusManager>();
        TlsSetValue(TlsIndex, obj);
    }

    obj->AddRef();

    return obj;
}
Example #14
0
int async_fibre_init_dispatcher(async_fibre *fibre)
{
    LPVOID dispatcher;

    dispatcher = (LPVOID)TlsGetValue(asyncwindispatch);
    if (dispatcher == NULL) {
        fibre->fibre = ConvertThreadToFiber(NULL);
        if (fibre->fibre == NULL) {
            fibre->converted = 0;
            fibre->fibre = GetCurrentFiber();
            if (fibre->fibre == NULL)
                return 0;
        } else {
            fibre->converted = 1;
        }
        if (TlsSetValue(asyncwindispatch, (LPVOID)fibre->fibre) == 0)
            return 0;
    } else {
        fibre->fibre = dispatcher;
    }
    return 1;
}
Example #15
0
int
stresscpu_thread_setspecific(stresscpu_thread_key_t    key, 
                             const void *              value)
{
    int ret;

    if(key!=NULL && value != NULL)
    {
        EnterCriticalSection(&key->cs);
        ret = TlsSetValue(key->tls_index,(void *)value);
        LeaveCriticalSection(&key->cs);
    }
    if (ret == 0)
    {
        ret = EAGAIN;
    }
    else
    {
        ret = 0;
    }
    return ret;
}
Example #16
0
STDMETHODIMP_(VOID) DHContext::Release(SIZE_T cookie)
{
#if LOCK_TRACE
    // If we're tracing, enter a record into the list of currently held locks.
    vector<SIZE_T> *pCurrentLocks = reinterpret_cast<vector<SIZE_T>*>(TlsGetValue(m_dwTlsCurrentLocks));
    if (pCurrentLocks)
    {
        _ASSERTE(!pCurrentLocks->empty() && "Expected a non-empty list");

        if (pCurrentLocks->back() == cookie)
        {
            // This is the fast case (vector is constant time deletion from front/back).
            pCurrentLocks->pop_back();
        }
        else
        {
            // Slow case, we must manually iterate through the list.
            for (vector<SIZE_T>::iterator currentWalker = pCurrentLocks->end();
                currentWalker != pCurrentLocks->begin();
                currentWalker--)
            {
                if (*currentWalker == cookie)
                {
                    pCurrentLocks->erase(currentWalker);
                    break;
                }
            }
        }

        // If the current list is empty, remove it from TLS and delete it. We will lazily
        // re-create it if necessary.
        if (pCurrentLocks->empty())
        {
            TlsSetValue(m_dwTlsCurrentLocks, NULL);
            delete pCurrentLocks;
        }
    }
#endif
}
/*
 *	Initialize a thread's errno
 */
static void Initialize_Thread_Errno(int *Errno_Pointer)
{
	/*
	 *	Make sure we have a slot
	 */
	if (TLS_Errno_Slot == 0xffffffff) {
		/*
		 *	No: Get one
		 */
		TLS_Errno_Slot = (int)TlsAlloc();
		if (TLS_Errno_Slot == 0xffffffff) ExitProcess(3);
	}
	/*
	 *	We can safely check for 0 threads, because
	 *	only the main thread will be initializing
	 *	at this point.  Make sure the critical
	 *	section that protects the number of threads
	 *	is initialized
	 */
	if (Number_Of_Threads == 0)
		InitializeCriticalSection(&Number_Of_Threads_Critical_Section);
	/*
	 *	Store the errno pointer
	 */
	if (TlsSetValue(TLS_Errno_Slot, (LPVOID)Errno_Pointer) == 0) ExitProcess(3);
	/*
	 *	Bump the number of threads
	 */
	EnterCriticalSection(&Number_Of_Threads_Critical_Section);
	Number_Of_Threads++;
	if (Number_Of_Threads > 1) {
		/*
		 *	We have threads other than the main thread:
		 *	  Use thread-local storage
		 */
		__WinCE_Errno_Pointer_Function = Get_Thread_Errno;
	}
	LeaveCriticalSection(&Number_Of_Threads_Critical_Section);
}
Example #18
0
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
SECURITY_STATUS SchannelHook::InitializeSecurityContextW(
    PCredHandle phCredential,
    PCtxtHandle phContext, SEC_WCHAR * pszTargetName, 
    unsigned long fContextReq, unsigned long Reserved1,
    unsigned long TargetDataRep, PSecBufferDesc pInput,
    unsigned long Reserved2, PCtxtHandle phNewContext,
    PSecBufferDesc pOutput, unsigned long * pfContextAttr,
    PTimeStamp ptsExpiry) {
  SECURITY_STATUS ret = SEC_E_INTERNAL_ERROR;
  fContextReq |= ISC_REQ_MANUAL_CRED_VALIDATION;
  if (_InitializeSecurityContextW) {
    ret = _InitializeSecurityContextW(phCredential, phContext,
            pszTargetName, fContextReq, Reserved1, TargetDataRep, pInput,
            Reserved2, phNewContext, pOutput, pfContextAttr, ptsExpiry);
    if (!phContext && phNewContext) {
    }
  }

  if (tlsIndex != TLS_OUT_OF_INDEXES)
    TlsSetValue(tlsIndex, phContext ? phContext : phNewContext);
  return ret;
}
Example #19
0
void *pa_tls_set(pa_tls *t, void *userdata) {
    void *r;

    assert(t);

    r = TlsGetValue(t->index);

    TlsSetValue(t->index, userdata);

    if (t->free_func) {
        struct pa_tls_monitor *m;

        PA_ONCE_BEGIN {
            monitor_tls = pa_tls_new(NULL);
            assert(monitor_tls);
            pa_tls_set(monitor_tls, NULL);
        } PA_ONCE_END;

        m = pa_tls_get(monitor_tls);
        if (!m) {
            HANDLE thread;

            m = pa_xnew(struct pa_tls_monitor, 1);

            DuplicateHandle(GetCurrentProcess(), GetCurrentThread(),
                GetCurrentProcess(), &m->thread, 0, FALSE,
                DUPLICATE_SAME_ACCESS);

            m->free_func = t->free_func;

            pa_tls_set(monitor_tls, m);

            thread = CreateThread(NULL, 0, monitor_thread_func, m, 0, NULL);
            assert(thread);
            CloseHandle(thread);
        }

        m->data = userdata;
    }
Example #20
0
/* Return the tls object.  This function is guaranteed to return a
   valid non-NULL object.  */
struct tls_space_s *
get_tls (void)
{
  struct tls_space_s *tls;

  tls = TlsGetValue (tls_index);
  if (!tls)
    {
      /* Called by a thread which existed before this DLL was loaded.
         Allocate the space.  */
      tls = LocalAlloc (LPTR, sizeof *tls);
      if (!tls)
        {
          /* No way to continue - commit suicide.  */
          abort ();
        }
      tls->gt_use_utf8 = 0;
      TlsSetValue (tls_index, tls);
    }
        
  return tls;
}
Example #21
0
DWORD Distributor::getframes(LPVOID param){
	Thread* current_thread=(Thread*)param;
	Distributor* _this=current_thread->distributor;
	IScriptEnvironment** penv=&_this->_env;
	TlsSetValue(TlsIndex,new ScriptEnvironmentTLS());
	while(true)
	{
		WaitForSingleObject(current_thread->begin,INFINITE);
		_RPT2(0,"Thread %d generating frame %d\n",GetCurrentThreadId(),current_thread->n);
		if(current_thread->endthread)
			break;

		current_thread->result=_this->child->GetFrame(current_thread->n,*penv);

		_RPT2(0,"Thread %d finished generating frame %d\n",GetCurrentThreadId(),current_thread->n);
		current_thread->status=Distributor::Thread::idle;
		SetEvent(current_thread->done);
	}
	delete((ScriptEnvironmentTLS*) TlsGetValue(TlsIndex));
	ExitThread(0);
  return 0;
}
Example #22
0
static void set_error(const char * e)
{
    char * s;
    char * old_s;
    size_t len;

    DWORD slot = get_tl_error_slot();

    if (slot == TLS_OUT_OF_INDEXES)
        return;

    len = strlen(e) * sizeof(char) + sizeof(char);
    s = LocalAlloc(LMEM_FIXED, len);
    if (s == NULL)
        return;

    old_s = (char *) TlsGetValue(slot);
    TlsSetValue(slot, (LPVOID) s);

    if (old_s != NULL)
        LocalFree(old_s);
}
Example #23
0
CxContext* icxGetContext()
{
#ifdef CX_DLL
#ifdef WIN32
    CxContext* pContext = (CxContext*)TlsGetValue( g_TlsIndex );
    if( !pContext )
    {
    pContext = icxCreateContext();

    if( !pContext )
    {
        FatalAppExit( 0, "OpenCX. Problem to allocate memory for TLS OpenCX context." );
    }
    TlsSetValue( g_TlsIndex, pContext );
    }
    return pContext;
#else
    CxContext* pContext = (CxContext*)pthread_getspecific( g_TlsIndex );
    if( !pContext )
    {
    pContext = icxCreateContext();
    if( !pContext )
    {
            fprintf(stderr,"OpenCX. Problem to allocate memory for OpenCX context.");
        exit(1);
    }
    pthread_setspecific( g_TlsIndex, pContext );
    }
    return pContext;
#endif
#else /* CX_DLL */
    static CxContext* pContext = 0;

    if( !pContext )
    pContext = icxCreateContext();

    return pContext;
#endif
}
Example #24
0
/* Deinitialize libgpg-error.  This function is only used in special
   circumstances.  No gpg-error function should be used after this
   function has been called.  A value of 0 passed for MODE
   deinitializes the entire libgpg-error, a value of 1 releases
   resources allocated for the current thread and only that thread may
   not anymore access libgpg-error after such a call.  Under Windows
   this function may be called from the DllMain function of a DLL
   which statically links to libgpg-error.  */
void
_gpg_err_deinit (int mode)
{
#if defined (HAVE_W32_SYSTEM) && !defined(DLL_EXPORT)
  struct tls_space_s *tls;

  tls = TlsGetValue (tls_index);
  if (tls)
    {
      TlsSetValue (tls_index, NULL);
      LocalFree (tls);
    }

  if (mode == 0)
    {
      TlsFree (tls_index);
      tls_index = TLS_OUT_OF_INDEXES;
    }
#else
  (void)mode;
#endif
}
BOOL WINAPI TLS_SetThread(fdcore::UpdateSystemThread* dw)
{
   LPVOID lpvData; 
   fdcore::UpdateSystemThread** pData;  // The stored memory pointer 

   lpvData = TlsGetValue(dwTlsIndex); 
   if (lpvData == NULL)
   {
      lpvData = (LPVOID) LocalAlloc(LPTR, 256); 
      if (lpvData == NULL) 
         return FALSE;
      if (!TlsSetValue(dwTlsIndex, lpvData))
         return FALSE;
   }

   pData = (fdcore::UpdateSystemThread**) lpvData; // Cast to my data type.
   // In this example, it is only a pointer to a DWORD
   // but it can be a structure pointer to contain more complicated data.

   (*pData) = dw;
   return TRUE;
}
Example #26
0
VOID
WSAAPI
WsThreadDelete(IN PWSTHREAD Thread)
{
    /* Remove the blocking hook */
    Thread->BlockingHook = NULL;

    /* Free our buffers */
    if (Thread->Hostent) HeapFree(WsSockHeap, 0, Thread->Hostent);
    if (Thread->Servent) HeapFree(WsSockHeap, 0, Thread->Servent);
    if (Thread->ProtocolInfo) HeapFree(WsSockHeap, 0, Thread->ProtocolInfo);

    /* Clear the TLS */
    TlsSetValue(TlsIndex, NULL);

    /* Close the WAH Handle */
    WahCloseThread(Thread->AsyncHelper, &Thread->WahThreadId);

    /* Unlink the process and free us */
    Thread->Process = NULL;
    HeapFree(WsSockHeap, 0, Thread);
}
Example #27
0
omni_thread::init_t::init_t(void)
{
    if (count++ != 0)   // only do it once however many objects get created.
    return;

    DB(cerr << "omni_thread::init: NT implementation initialising\n");

    self_tls_index = TlsAlloc();

    if (self_tls_index == 0xffffffff)
    throw omni_thread_fatal(GetLastError());

    next_id_mutex = new omni_mutex;

    //
    // Create object for this (i.e. initial) thread.
    //

    omni_thread* t = new omni_thread;

    t->_state = STATE_RUNNING;

    if (!DuplicateHandle(GetCurrentProcess(), GetCurrentThread(),
             GetCurrentProcess(), &t->handle,
             0, FALSE, DUPLICATE_SAME_ACCESS))
    throw omni_thread_fatal(GetLastError());

    t->nt_id = GetCurrentThreadId();

    DB(cerr << "initial thread " << t->id() << " NT thread id " << t->nt_id
       << endl);

    if (!TlsSetValue(self_tls_index, (LPVOID)t))
    throw omni_thread_fatal(GetLastError());

    if (!SetThreadPriority(t->handle, nt_priority(PRIORITY_NORMAL)))
    throw omni_thread_fatal(GetLastError());
}
Example #28
0
void opj_cond_wait(opj_cond_t* cond, opj_mutex_t* mutex)
{
    opj_cond_waiter_list_t* item;
    HANDLE hEvent = (HANDLE) TlsGetValue( TLSKey );
    if (hEvent == NULL)
    {
        hEvent = CreateEvent(NULL, /* security attributes */
                             0,    /* manual reset = no */
                             0,    /* initial state = unsignaled */
                             NULL  /* no name */);
        assert(hEvent);

        TlsSetValue( TLSKey, hEvent );
    }

    /* Insert the waiter into the waiter list of the condition */
    opj_mutex_lock(cond->internal_mutex);

    item = (opj_cond_waiter_list_t*)opj_malloc(sizeof(opj_cond_waiter_list_t));
    assert(item != NULL);

    item->hEvent = hEvent;
    item->next = cond->waiter_list;

    cond->waiter_list = item;

    opj_mutex_unlock(cond->internal_mutex);

    /* Release the client mutex before waiting for the event being signaled */
    opj_mutex_unlock(mutex);

    /* Ideally we would check that we do not get WAIT_FAILED but it is hard */
    /* to report a failure. */
    WaitForSingleObject(hEvent, INFINITE);

    /* Reacquire the client mutex */
    opj_mutex_lock(mutex);
}
Example #29
0
/*
 * Disables the cache.
 */
void fscache_disable(void)
{
	struct fscache *cache;

	if (!core_fscache)
		return;

	/* update the thread specific fscache initialization */
	cache = fscache_getcache();
	if (!cache)
		BUG("fscache_disable() called on a thread where fscache has not been initialized");
	if (!cache->enabled)
		BUG("fscache_disable() called on an fscache that is already disabled");
	cache->enabled--;
	if (!cache->enabled) {
		TlsSetValue(dwTlsIndex, NULL);
		trace_printf_key(&trace_fscache, "fscache_disable: lstat %u, opendir %u, "
			"total requests/misses %u/%u\n",
			cache->lstat_requests, cache->opendir_requests,
			cache->fscache_requests, cache->fscache_misses);
		mem_pool_discard(cache->mem_pool, 0);
		hashmap_free(&cache->map, 0);
		free(cache);
	}

	/* update the global fscache initialization */
	EnterCriticalSection(&fscache_cs);
	initialized--;
	if (!initialized) {
		/* reset opendir and lstat to the original implementations */
		opendir = dirent_opendir;
		lstat = mingw_lstat;
	}
	LeaveCriticalSection(&fscache_cs);

	trace_printf_key(&trace_fscache, "fscache: disable\n");
	return;
}
Example #30
0
/*
 * This function should be called by the user whenever a thread ends, 
 * to free the thread "virtual stack" storage
 */
ITT_EXTERN_C void JITAPI FinalizeThread()
{
    if (threadLocalStorageHandle)
    {
#if ITT_PLATFORM==ITT_PLATFORM_WIN
        pThreadStack threadStack = 
            (pThreadStack)TlsGetValue (threadLocalStorageHandle);
#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
        pThreadStack threadStack = 
            (pThreadStack)pthread_getspecific(threadLocalStorageHandle);
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
        if (threadStack)
        {
            free (threadStack);
            threadStack = NULL;
#if ITT_PLATFORM==ITT_PLATFORM_WIN
            TlsSetValue (threadLocalStorageHandle, threadStack);
#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
            pthread_setspecific(threadLocalStorageHandle, threadStack);
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
        }
    }
}