The Tor Browser: nsprpub/pr/src/md/unix/solaris.c@6474c204b198

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

     1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

     2 /* This Source Code Form is subject to the terms of the Mozilla Public

     3  * License, v. 2.0. If a copy of the MPL was not distributed with this

     4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

     6 #include "primpl.h"

     9 extern PRBool suspendAllOn;

    10 extern PRThread *suspendAllThread;

    12 extern void _MD_SET_PRIORITY(_MDThread *md, PRThreadPriority newPri);

    14 PRIntervalTime _MD_Solaris_TicksPerSecond(void)

    15 {

    16     /*

    17      * Ticks have a 10-microsecond resolution.  So there are

    18      * 100000 ticks per second.

    19      */

    20     return 100000UL;

    21 }

    23 /* Interval timers, implemented using gethrtime() */

    25 PRIntervalTime _MD_Solaris_GetInterval(void)

    26 {

    27     union {

    28 	hrtime_t hrt;  /* hrtime_t is a 64-bit (long long) integer */

    29 	PRInt64 pr64;

    30     } time;

    31     PRInt64 resolution;

    32     PRIntervalTime ticks;

    34     time.hrt = gethrtime();  /* in nanoseconds */

    35     /*

    36      * Convert from nanoseconds to ticks.  A tick's resolution is

    37      * 10 microseconds, or 10000 nanoseconds.

    38      */

    39     LL_I2L(resolution, 10000);

    40     LL_DIV(time.pr64, time.pr64, resolution);

    41     LL_L2UI(ticks, time.pr64);

    42     return ticks;

    43 }

    45 #ifdef _PR_PTHREADS

    46 void _MD_EarlyInit(void)

    47 {

    48 }

    50 PRWord *_MD_HomeGCRegisters(PRThread *t, PRIntn isCurrent, PRIntn *np)

    51 {

    52 	*np = 0;

    53 	return NULL;

    54 }

    55 #endif /* _PR_PTHREADS */

    57 #if defined(_PR_LOCAL_THREADS_ONLY)

    59 void _MD_EarlyInit(void)

    60 {

    61 }

    63 void _MD_SolarisInit()

    64 {

    65     _PR_UnixInit();

    66 }

    68 void

    69 _MD_SET_PRIORITY(_MDThread *thread, PRThreadPriority newPri)

    70 {

    71     return;

    72 }

    74 PRStatus

    75 _MD_InitializeThread(PRThread *thread)

    76 {

    77 	return PR_SUCCESS;

    78 }

    80 PRStatus

    81 _MD_WAIT(PRThread *thread, PRIntervalTime ticks)

    82 {

    83     PR_ASSERT(!(thread->flags & _PR_GLOBAL_SCOPE));

    84     _PR_MD_SWITCH_CONTEXT(thread);

    85     return PR_SUCCESS;

    86 }

    88 PRStatus

    89 _MD_WAKEUP_WAITER(PRThread *thread)

    90 {

    91 	PR_ASSERT((thread == NULL) || (!(thread->flags & _PR_GLOBAL_SCOPE)));

    92     return PR_SUCCESS;

    93 }

    95 /* These functions should not be called for Solaris */

    96 void

    97 _MD_YIELD(void)

    98 {

    99     PR_NOT_REACHED("_MD_YIELD should not be called for Solaris");

   100 }

   102 PRStatus

   103 _MD_CREATE_THREAD(

   104     PRThread *thread,

   105     void (*start) (void *),

   106     PRThreadPriority priority,

   107     PRThreadScope scope,

   108     PRThreadState state,

   109     PRUint32 stackSize)

   110 {

   111     PR_NOT_REACHED("_MD_CREATE_THREAD should not be called for Solaris");

   112 	return(PR_FAILURE);

   113 }

   115 #ifdef USE_SETJMP

   116 PRWord *_MD_HomeGCRegisters(PRThread *t, int isCurrent, int *np)

   117 {

   118     if (isCurrent) {

   119 		(void) setjmp(CONTEXT(t));

   120     }

   121     *np = sizeof(CONTEXT(t)) / sizeof(PRWord);

   122     return (PRWord *) CONTEXT(t);

   123 }

   124 #else

   125 PRWord *_MD_HomeGCRegisters(PRThread *t, PRIntn isCurrent, PRIntn *np)

   126 {

   127     if (isCurrent) {

   128 		(void) getcontext(CONTEXT(t));

   129     }

   130     *np = NGREG;

   131     return (PRWord*) &t->md.context.uc_mcontext.gregs[0];

   132 }

   133 #endif  /* USE_SETJMP */

   135 #endif  /* _PR_LOCAL_THREADS_ONLY */

   137 #ifndef _PR_PTHREADS

   138 #if defined(i386) && defined(SOLARIS2_4)

   139 /*

   140  * Because clock_gettime() on Solaris/x86 2.4 always generates a

   141  * segmentation fault, we use an emulated version _pr_solx86_clock_gettime(),

   142  * which is implemented using gettimeofday().

   143  */

   145 int

   146 _pr_solx86_clock_gettime(clockid_t clock_id, struct timespec *tp)

   147 {

   148     struct timeval tv;

   150     if (clock_id != CLOCK_REALTIME) {

   151 	errno = EINVAL;

   152 	return -1;

   153     }

   155     gettimeofday(&tv, NULL);

   156     tp->tv_sec = tv.tv_sec;

   157     tp->tv_nsec = tv.tv_usec * 1000;

   158     return 0;

   159 }

   160 #endif  /* i386 && SOLARIS2_4 */

   161 #endif  /* _PR_PTHREADS */

The Tor Browser / file revision