The Tor Browser: nsprpub/pr/src/md/unix/unixware.c@6474c204b198 (annotated)

nsprpub/pr/src/md/unix/unixware.c@6474c204b198 (annotated)

nsprpub/pr/src/md/unix/unixware.c

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include "primpl.h"
 #if !defined (USE_SVR4_THREADS)
 /*
          * using only NSPR threads here
  */
 #include <setjmp.h>
 void _MD_EarlyInit(void)
 {
 }
 PRWord *_MD_HomeGCRegisters(PRThread *t, int isCurrent, int *np)
 {
     if (isCurrent) {
 	(void) setjmp(CONTEXT(t));
     }
     *np = sizeof(CONTEXT(t)) / sizeof(PRWord);
     return (PRWord *) CONTEXT(t);
 }
 #ifdef ALARMS_BREAK_TCP /* I don't think they do */
 PRInt32 _MD_connect(PRInt32 osfd, const PRNetAddr *addr, PRInt32 addrlen,
                         PRIntervalTime timeout)
 {
     PRInt32 rv;
     _MD_BLOCK_CLOCK_INTERRUPTS();
     rv = _connect(osfd,addr,addrlen);
     _MD_UNBLOCK_CLOCK_INTERRUPTS();
 }
 PRInt32 _MD_accept(PRInt32 osfd, PRNetAddr *addr, PRInt32 addrlen,
                         PRIntervalTime timeout)
 {
     PRInt32 rv;
     _MD_BLOCK_CLOCK_INTERRUPTS();
     rv = _accept(osfd,addr,addrlen);
     _MD_UNBLOCK_CLOCK_INTERRUPTS();
     return(rv);
 }
 #endif
 /*
  * These are also implemented in pratom.c using NSPR locks.  Any reason
  * this might be better or worse?  If you like this better, define
  * _PR_HAVE_ATOMIC_OPS in include/md/unixware.h
  */
 #ifdef _PR_HAVE_ATOMIC_OPS
 /* Atomic operations */
 #include  <stdio.h>
 static FILE *_uw_semf;
 void
 _MD_INIT_ATOMIC(void)
 {
     /* Sigh.  Sure wish SYSV semaphores weren't such a pain to use */
     if ((_uw_semf = tmpfile()) == NULL)
         PR_ASSERT(0);
     return;
 }
 void
 _MD_ATOMIC_INCREMENT(PRInt32 *val)
 {
     flockfile(_uw_semf);
     (*val)++;
     unflockfile(_uw_semf);
 }
 void
 _MD_ATOMIC_ADD(PRInt32 *ptr, PRInt32 val)
 {
     flockfile(_uw_semf);
     (*ptr) += val;
     unflockfile(_uw_semf);
 }
 void
 _MD_ATOMIC_DECREMENT(PRInt32 *val)
 {
     flockfile(_uw_semf);
     (*val)--;
     unflockfile(_uw_semf);
 }
 void
 _MD_ATOMIC_SET(PRInt32 *val, PRInt32 newval)
 {
     flockfile(_uw_semf);
     *val = newval;
     unflockfile(_uw_semf);
 }
 #endif
 void
 _MD_SET_PRIORITY(_MDThread *thread, PRUintn newPri)
 {
     return;
 }
 PRStatus
 _MD_InitializeThread(PRThread *thread)
 {
 	return PR_SUCCESS;
 }
 PRStatus
 _MD_WAIT(PRThread *thread, PRIntervalTime ticks)
 {
     PR_ASSERT(!(thread->flags & _PR_GLOBAL_SCOPE));
     _PR_MD_SWITCH_CONTEXT(thread);
     return PR_SUCCESS;
 }
 PRStatus
 _MD_WAKEUP_WAITER(PRThread *thread)
 {
     if (thread) {
 	PR_ASSERT(!(thread->flags & _PR_GLOBAL_SCOPE));
     }
     return PR_SUCCESS;
 }
 /* These functions should not be called for Unixware */
 void
 _MD_YIELD(void)
 {
     PR_NOT_REACHED("_MD_YIELD should not be called for Unixware.");
 }
 PRStatus
 _MD_CREATE_THREAD(
     PRThread *thread,
     void (*start) (void *),
     PRThreadPriority priority,
     PRThreadScope scope,
     PRThreadState state,
     PRUint32 stackSize)
 {
     PR_NOT_REACHED("_MD_CREATE_THREAD should not be called for Unixware.");
 }
 #else  /* USE_SVR4_THREADS */
 /* NOTE:
  * SPARC v9 (Ultras) do have an atomic test-and-set operation.  But
  * SPARC v8 doesn't.  We should detect in the init if we are running on
  * v8 or v9, and then use assembly where we can.
  */
 #include <thread.h>
 #include <synch.h>
 static mutex_t _unixware_atomic = DEFAULTMUTEX;
 #define TEST_THEN_ADD(where, inc) \
     if (mutex_lock(&_unixware_atomic) != 0)\
         PR_ASSERT(0);\
     *where += inc;\
     if (mutex_unlock(&_unixware_atomic) != 0)\
         PR_ASSERT(0);
 #define TEST_THEN_SET(where, val) \
     if (mutex_lock(&_unixware_atomic) != 0)\
         PR_ASSERT(0);\
     *where = val;\
     if (mutex_unlock(&_unixware_atomic) != 0)\
         PR_ASSERT(0);
 void
 _MD_INIT_ATOMIC(void)
 {
 }
 void
 _MD_ATOMIC_INCREMENT(PRInt32 *val)
 {
     TEST_THEN_ADD(val, 1);
 }
 void
 _MD_ATOMIC_ADD(PRInt32 *ptr, PRInt32 val)
 {
     TEST_THEN_ADD(ptr, val);
 }
 void
 _MD_ATOMIC_DECREMENT(PRInt32 *val)
 {
     TEST_THEN_ADD(val, 0xffffffff);
 }
 void
 _MD_ATOMIC_SET(PRInt32 *val, PRInt32 newval)
 {
     TEST_THEN_SET(val, newval);
 }
 #include <signal.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/lwp.h>
 #include <sys/procfs.h>
 #include <sys/syscall.h>
 THREAD_KEY_T threadid_key;
 THREAD_KEY_T cpuid_key;
 THREAD_KEY_T last_thread_key;
 static sigset_t set, oldset;
 void _MD_EarlyInit(void)
 {
     THR_KEYCREATE(&threadid_key, NULL);
     THR_KEYCREATE(&cpuid_key, NULL);
     THR_KEYCREATE(&last_thread_key, NULL);
     sigemptyset(&set);
     sigaddset(&set, SIGALRM);
 }
 PRStatus _MD_CREATE_THREAD(PRThread *thread,
 					void (*start)(void *),
 					PRThreadPriority priority,
 					PRThreadScope scope,
 					PRThreadState state,
 					PRUint32 stackSize)
 {
 	long flags;
     /* mask out SIGALRM for native thread creation */
     thr_sigsetmask(SIG_BLOCK, &set, &oldset);
     flags = (state == PR_JOINABLE_THREAD ? THR_SUSPENDED/*|THR_NEW_LWP*/
 			   : THR_SUSPENDED|THR_DETACHED/*|THR_NEW_LWP*/);
 	if (_PR_IS_GCABLE_THREAD(thread) ||
 							(scope == PR_GLOBAL_BOUND_THREAD))
 		flags |= THR_BOUND;
     if (thr_create(NULL, thread->stack->stackSize,
                   (void *(*)(void *)) start, (void *) thread,
 				  flags,
                   &thread->md.handle)) {
         thr_sigsetmask(SIG_SETMASK, &oldset, NULL);
 	return PR_FAILURE;
     }
     /* When the thread starts running, then the lwpid is set to the right
      * value. Until then we want to mark this as 'uninit' so that
      * its register state is initialized properly for GC */
     thread->md.lwpid = -1;
     thr_sigsetmask(SIG_SETMASK, &oldset, NULL);
     _MD_NEW_SEM(&thread->md.waiter_sem, 0);
 	if ((scope == PR_GLOBAL_THREAD) || (scope == PR_GLOBAL_BOUND_THREAD)) {
 		thread->flags |= _PR_GLOBAL_SCOPE;
     }
     /*
     ** Set the thread priority.  This will also place the thread on
     ** the runQ.
     **
     ** Force PR_SetThreadPriority to set the priority by
     ** setting thread->priority to 100.
     */
     {
     int pri;
     pri = thread->priority;
     thread->priority = 100;
     PR_SetThreadPriority( thread, pri );
     PR_LOG(_pr_thread_lm, PR_LOG_MIN,
             ("(0X%x)[Start]: on to runq at priority %d",
             thread, thread->priority));
     }
     /* Activate the thread */
     if (thr_continue( thread->md.handle ) ) {
 	return PR_FAILURE;
     }
     return PR_SUCCESS;
 }
 void _MD_cleanup_thread(PRThread *thread)
 {
     thread_t hdl;
     PRMonitor *mon;
     hdl = thread->md.handle;
     /*
     ** First, suspend the thread (unless it's the active one)
     ** Because we suspend it first, we don't have to use LOCK_SCHEDULER to
     ** prevent both of us modifying the thread structure at the same time.
     */
     if ( thread != _PR_MD_CURRENT_THREAD() ) {
         thr_suspend(hdl);
     }
     PR_LOG(_pr_thread_lm, PR_LOG_MIN,
             ("(0X%x)[DestroyThread]\n", thread));
     _MD_DESTROY_SEM(&thread->md.waiter_sem);
 }
 void _MD_SET_PRIORITY(_MDThread *md_thread, PRUintn newPri)
 {
 	if(thr_setprio((thread_t)md_thread->handle, newPri)) {
 		PR_LOG(_pr_thread_lm, PR_LOG_MIN,
 		   ("_PR_SetThreadPriority: can't set thread priority\n"));
 	}
 }
 void _MD_WAIT_CV(
     struct _MDCVar *md_cv, struct _MDLock *md_lock, PRIntervalTime timeout)
 {
     struct timespec tt;
     PRUint32 msec;
     int rv;
     PRThread *me = _PR_MD_CURRENT_THREAD();
     msec = PR_IntervalToMilliseconds(timeout);
     GETTIME (&tt);
     tt.tv_sec += msec / PR_MSEC_PER_SEC;
     tt.tv_nsec += (msec % PR_MSEC_PER_SEC) * PR_NSEC_PER_MSEC;
     /* Check for nsec overflow - otherwise we'll get an EINVAL */
     if (tt.tv_nsec >= PR_NSEC_PER_SEC) {
         tt.tv_sec++;
         tt.tv_nsec -= PR_NSEC_PER_SEC;
     }
     me->md.sp = unixware_getsp();
     /* XXX Solaris 2.5.x gives back EINTR occasionally for no reason
      * hence ignore EINTR for now */
     COND_TIMEDWAIT(&md_cv->cv, &md_lock->lock, &tt);
 }
 void _MD_lock(struct _MDLock *md_lock)
 {
     mutex_lock(&md_lock->lock);
 }
 void _MD_unlock(struct _MDLock *md_lock)
 {
     mutex_unlock(&((md_lock)->lock));
 }
 PRThread *_pr_current_thread_tls()
 {
     PRThread *ret;
     thr_getspecific(threadid_key, (void **)&ret);
     return ret;
 }
 PRStatus
 _MD_WAIT(PRThread *thread, PRIntervalTime ticks)
 {
         _MD_WAIT_SEM(&thread->md.waiter_sem);
         return PR_SUCCESS;
 }
 PRStatus
 _MD_WAKEUP_WAITER(PRThread *thread)
 {
 	if (thread == NULL) {
 		return PR_SUCCESS;
 	}
 	_MD_POST_SEM(&thread->md.waiter_sem);
 	return PR_SUCCESS;
 }
 _PRCPU *_pr_current_cpu_tls()
 {
     _PRCPU *ret;
     thr_getspecific(cpuid_key, (void **)&ret);
     return ret;
 }
 PRThread *_pr_last_thread_tls()
 {
     PRThread *ret;
     thr_getspecific(last_thread_key, (void **)&ret);
     return ret;
 }
 _MDLock _pr_ioq_lock;
 void _MD_INIT_IO (void)
 {
     _MD_NEW_LOCK(&_pr_ioq_lock);
 }
 PRStatus _MD_InitializeThread(PRThread *thread)
 {
     if (!_PR_IS_NATIVE_THREAD(thread))
         return;
 		/* prime the sp; substract 4 so we don't hit the assert that
 		 * curr sp > base_stack
 		 */
     thread->md.sp = (uint_t) thread->stack->allocBase - sizeof(long);
     thread->md.lwpid = _lwp_self();
     thread->md.handle = THR_SELF();
 	/* all threads on Solaris are global threads from NSPR's perspective
 	 * since all of them are mapped to Solaris threads.
 	 */
     thread->flags |= _PR_GLOBAL_SCOPE;
  	/* For primordial/attached thread, we don't create an underlying native thread.
  	 * So, _MD_CREATE_THREAD() does not get called.  We need to do initialization
  	 * like allocating thread's synchronization variables and set the underlying
  	 * native thread's priority.
  	 */
 	if (thread->flags & (_PR_PRIMORDIAL | _PR_ATTACHED)) {
 	    _MD_NEW_SEM(&thread->md.waiter_sem, 0);
 	    _MD_SET_PRIORITY(&(thread->md), thread->priority);
 	}
 	return PR_SUCCESS;
 }
 static sigset_t old_mask;	/* store away original gc thread sigmask */
 static int gcprio;		/* store away original gc thread priority */
 static lwpid_t *all_lwps=NULL;	/* list of lwps that we suspended */
 static int num_lwps ;
 static int suspendAllOn = 0;
 #define VALID_SP(sp, bottom, top)	\
        (((uint_t)(sp)) > ((uint_t)(bottom)) && ((uint_t)(sp)) < ((uint_t)(top)))
 void unixware_preempt_off()
 {
     sigset_t set;
     (void)sigfillset(&set);
     sigprocmask (SIG_SETMASK, &set, &old_mask);
 }
 void unixware_preempt_on()
 {
     sigprocmask (SIG_SETMASK, &old_mask, NULL);
 }
 void _MD_Begin_SuspendAll()
 {
     unixware_preempt_off();
     PR_LOG(_pr_gc_lm, PR_LOG_ALWAYS, ("Begin_SuspendAll\n"));
     /* run at highest prio so I cannot be preempted */
     thr_getprio(thr_self(), &gcprio);
     thr_setprio(thr_self(), 0x7fffffff);
     suspendAllOn = 1;
 }
 void _MD_End_SuspendAll()
 {
 }
 void _MD_End_ResumeAll()
 {
     PR_LOG(_pr_gc_lm, PR_LOG_ALWAYS, ("End_ResumeAll\n"));
     thr_setprio(thr_self(), gcprio);
     unixware_preempt_on();
     suspendAllOn = 0;
 }
 void _MD_Suspend(PRThread *thr)
 {
    int lwp_fd, result;
    int lwp_main_proc_fd = 0;
     thr_suspend(thr->md.handle);
     if (!_PR_IS_GCABLE_THREAD(thr))
       return;
     /* XXX Primordial thread can't be bound to an lwp, hence there is no
      * way we can assume that we can get the lwp status for primordial
      * thread reliably. Hence we skip this for primordial thread, hoping
      * that the SP is saved during lock and cond. wait.
      * XXX - Again this is concern only for java interpreter, not for the
      * server, 'cause primordial thread in the server does not do java work
      */
     if (thr->flags & _PR_PRIMORDIAL)
       return;
     /* if the thread is not started yet then don't do anything */
     if (!suspendAllOn || thr->md.lwpid == -1)
       return;
 }
 void _MD_Resume(PRThread *thr)
 {
    if (!_PR_IS_GCABLE_THREAD(thr) || !suspendAllOn){
      /*XXX When the suspendAllOn is set, we will be trying to do lwp_suspend
       * during that time we can't call any thread lib or libc calls. Hence
       * make sure that no resume is requested for Non gcable thread
       * during suspendAllOn */
       PR_ASSERT(!suspendAllOn);
       thr_continue(thr->md.handle);
       return;
    }
    if (thr->md.lwpid == -1)
      return;
    if ( _lwp_continue(thr->md.lwpid) < 0) {
       PR_ASSERT(0);  /* ARGH, we are hosed! */
    }
 }
 PRWord *_MD_HomeGCRegisters(PRThread *t, int isCurrent, int *np)
 {
     if (isCurrent) {
 	(void) getcontext(CONTEXT(t));	/* XXX tune me: set md_IRIX.c */
     }
     *np = NGREG;
     if (t->md.lwpid == -1)
       memset(&t->md.context.uc_mcontext.gregs[0], 0, NGREG * sizeof(PRWord));
     return (PRWord*) &t->md.context.uc_mcontext.gregs[0];
 }
 int
 _pr_unixware_clock_gettime (struct timespec *tp)
 {
     struct timeval tv;
     gettimeofday(&tv, NULL);
     tp->tv_sec = tv.tv_sec;
     tp->tv_nsec = tv.tv_usec * 1000;
     return 0;
 }
 #endif /* USE_SVR4_THREADS */

The Tor Browser / annotate

nsprpub/pr/src/md/unix/unixware.c@6474c204b198 (annotated)

nsprpub/pr/src/md/unix/unixware.c