1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ 2 /* 3 * The contents of this file are subject to the Mozilla Public 4 * License Version 1.1 (the "License"); you may not use this file 5 * except in compliance with the License. You may obtain a copy of 6 * the License at http://www.mozilla.org/MPL/ 7 * 8 * Software distributed under the License is distributed on an "AS 9 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or 10 * implied. See the License for the specific language governing 11 * rights and limitations under the License. 12 * 13 * The Original Code is the Netscape Portable Runtime (NSPR). 14 * 15 * The Initial Developer of the Original Code is Netscape 16 * Communications Corporation. Portions created by Netscape are 17 * Copyright (C) 1998-2000 Netscape Communications Corporation. All 18 * Rights Reserved. 19 * 20 * Contributor(s): 21 * 22 * Alternatively, the contents of this file may be used under the 23 * terms of the GNU General Public License Version 2 or later (the 24 * "GPL"), in which case the provisions of the GPL are applicable 25 * instead of those above. If you wish to allow use of your 26 * version of this file only under the terms of the GPL and not to 27 * allow others to use your version of this file under the MPL, 28 * indicate your decision by deleting the provisions above and 29 * replace them with the notice and other provisions required by 30 * the GPL. If you do not delete the provisions above, a recipient 31 * may use your version of this file under either the MPL or the 32 * GPL. 33 */ 34 35 #ifndef nspr_solaris_defs_h___ 36 #define nspr_solaris_defs_h___ 37 38 /* 39 * Internal configuration macros 40 */ 41 42 #define PR_LINKER_ARCH "solaris" 43 #define _PR_SI_SYSNAME "SOLARIS" 44 #ifdef sparc 45 #define _PR_SI_ARCHITECTURE "sparc" 46 #elif defined(i386) 47 #define _PR_SI_ARCHITECTURE "x86" 48 #else 49 #error unknown processor 50 #endif 51 #define PR_DLL_SUFFIX ".so" 52 53 #define _PR_VMBASE 0x30000000 54 #define _PR_STACK_VMBASE 0x50000000 55 #define _MD_DEFAULT_STACK_SIZE (2*65536L) 56 #define _MD_MMAP_FLAGS MAP_SHARED 57 58 #undef HAVE_STACK_GROWING_UP 59 60 #ifndef HAVE_WEAK_IO_SYMBOLS 61 #define HAVE_WEAK_IO_SYMBOLS 62 #endif 63 64 #undef HAVE_WEAK_MALLOC_SYMBOLS 65 #define HAVE_DLL 66 #define USE_DLFCN 67 #define NEED_STRFTIME_LOCK 68 69 /* 70 * Intel x86 has atomic instructions. 71 * 72 * Sparc v8 does not have instructions to efficiently implement 73 * atomic increment/decrement operations. In the local threads 74 * only and pthreads versions, we use the default atomic routine 75 * implementation in pratom.c. The obsolete global threads only 76 * version uses a global mutex_t to implement the atomic routines 77 * in solaris.c, which is actually equivalent to the default 78 * implementation. 79 * 80 * 64-bit Solaris requires sparc v9, which has atomic instructions. 81 */ 82 #if defined(i386) || defined(_PR_GLOBAL_THREADS_ONLY) || defined(IS_64) 83 #define _PR_HAVE_ATOMIC_OPS 84 #endif 85 86 #if defined(_PR_GLOBAL_THREADS_ONLY) || defined(_PR_PTHREADS) 87 /* 88 * We have assembly language implementation of atomic 89 * stacks for the 32-bit sparc and x86 architectures only. 90 * 91 * Note: We ran into thread starvation problem with the 92 * 32-bit sparc assembly language implementation of atomic 93 * stacks, so we do not use it now. (Bugzilla bug 113740) 94 */ 95 #if !defined(sparc) 96 #define _PR_HAVE_ATOMIC_CAS 97 #endif 98 #endif 99 100 #define _PR_POLL_AVAILABLE 101 #define _PR_USE_POLL 102 #define _PR_STAT_HAS_ST_ATIM 103 #ifdef SOLARIS2_5 104 #define _PR_HAVE_SYSV_SEMAPHORES 105 #define PR_HAVE_SYSV_NAMED_SHARED_MEMORY 106 #else 107 #define _PR_HAVE_POSIX_SEMAPHORES 108 #define PR_HAVE_POSIX_NAMED_SHARED_MEMORY 109 #endif 110 #define _PR_HAVE_GETIPNODEBYNAME 111 #define _PR_HAVE_GETIPNODEBYADDR 112 #define _PR_HAVE_GETADDRINFO 113 #define _PR_INET6_PROBE 114 #define _PR_ACCEPT_INHERIT_NONBLOCK 115 #ifdef _PR_INET6 116 #define _PR_HAVE_INET_NTOP 117 #else 118 #define AF_INET6 26 119 struct addrinfo { 120 int ai_flags; 121 int ai_family; 122 int ai_socktype; 123 int ai_protocol; 124 size_t ai_addrlen; 125 char *ai_canonname; 126 struct sockaddr *ai_addr; 127 struct addrinfo *ai_next; 128 }; 129 #define AI_CANONNAME 0x0010 130 #define AI_V4MAPPED 0x0001 131 #define AI_ALL 0x0002 132 #define AI_ADDRCONFIG 0x0004 133 #define _PR_HAVE_MD_SOCKADDR_IN6 134 /* isomorphic to struct in6_addr on Solaris 8 */ 135 struct _md_in6_addr { 136 union { 137 PRUint8 _S6_u8[16]; 138 PRUint32 _S6_u32[4]; 139 PRUint32 __S6_align; 140 } _S6_un; 141 }; 142 /* isomorphic to struct sockaddr_in6 on Solaris 8 */ 143 struct _md_sockaddr_in6 { 144 PRUint16 sin6_family; 145 PRUint16 sin6_port; 146 PRUint32 sin6_flowinfo; 147 struct _md_in6_addr sin6_addr; 148 PRUint32 sin6_scope_id; 149 PRUint32 __sin6_src_id; 150 }; 151 #endif 152 #if defined(_PR_GLOBAL_THREADS_ONLY) || defined(_PR_PTHREADS) 153 #define _PR_HAVE_GETHOST_R 154 #define _PR_HAVE_GETHOST_R_POINTER 155 #endif 156 157 #include "prinrval.h" 158 NSPR_API(PRIntervalTime) _MD_Solaris_GetInterval(void); 159 #define _MD_GET_INTERVAL _MD_Solaris_GetInterval 160 NSPR_API(PRIntervalTime) _MD_Solaris_TicksPerSecond(void); 161 #define _MD_INTERVAL_PER_SEC _MD_Solaris_TicksPerSecond 162 163 #if defined(_PR_HAVE_ATOMIC_OPS) 164 /* 165 ** Atomic Operations 166 */ 167 #define _MD_INIT_ATOMIC() 168 169 NSPR_API(PRInt32) _MD_AtomicIncrement(PRInt32 *val); 170 #define _MD_ATOMIC_INCREMENT _MD_AtomicIncrement 171 172 NSPR_API(PRInt32) _MD_AtomicAdd(PRInt32 *ptr, PRInt32 val); 173 #define _MD_ATOMIC_ADD _MD_AtomicAdd 174 175 NSPR_API(PRInt32) _MD_AtomicDecrement(PRInt32 *val); 176 #define _MD_ATOMIC_DECREMENT _MD_AtomicDecrement 177 178 NSPR_API(PRInt32) _MD_AtomicSet(PRInt32 *val, PRInt32 newval); 179 #define _MD_ATOMIC_SET _MD_AtomicSet 180 #endif /* _PR_HAVE_ATOMIC_OPS */ 181 182 #if defined(_PR_PTHREADS) 183 184 NSPR_API(void) _MD_EarlyInit(void); 185 186 #define _MD_EARLY_INIT _MD_EarlyInit 187 #define _MD_FINAL_INIT _PR_UnixInit 188 189 #elif defined(_PR_GLOBAL_THREADS_ONLY) 190 191 #include "prthread.h" 192 193 #include <ucontext.h> 194 195 /* 196 ** Iinitialization Related definitions 197 */ 198 199 NSPR_API(void) _MD_EarlyInit(void); 200 201 #define _MD_EARLY_INIT _MD_EarlyInit 202 #define _MD_FINAL_INIT _PR_UnixInit 203 204 #define _MD_GET_SP(threadp) threadp->md.sp 205 206 /* 207 ** Clean-up the thread machine dependent data structure 208 */ 209 #define _MD_INIT_THREAD _MD_InitializeThread 210 #define _MD_INIT_ATTACHED_THREAD _MD_InitializeThread 211 212 NSPR_API(PRStatus) _MD_CreateThread(PRThread *thread, 213 void (*start)(void *), 214 PRThreadPriority priority, 215 PRThreadScope scope, 216 PRThreadState state, 217 PRUint32 stackSize); 218 #define _MD_CREATE_THREAD _MD_CreateThread 219 220 #define _PR_CONTEXT_TYPE ucontext_t 221 222 #define CONTEXT(_thread) (&(_thread)->md.context) 223 224 #include <thread.h> 225 #include <sys/lwp.h> 226 #include <synch.h> 227 228 extern struct PRLock *_pr_schedLock; 229 230 /* 231 ** Thread Local Storage 232 */ 233 234 #define THREAD_KEY_T thread_key_t 235 236 extern struct PRThread *_pr_attached_thread_tls(); 237 extern struct PRThread *_pr_current_thread_tls(); 238 extern struct _PRCPU *_pr_current_cpu_tls(); 239 extern struct PRThread *_pr_last_thread_tls(); 240 241 extern THREAD_KEY_T threadid_key; 242 extern THREAD_KEY_T cpuid_key; 243 extern THREAD_KEY_T last_thread_key; 244 245 #define _MD_GET_ATTACHED_THREAD() _pr_attached_thread_tls() 246 #define _MD_CURRENT_THREAD() _pr_current_thread_tls() 247 #define _MD_CURRENT_CPU() _pr_current_cpu_tls() 248 #define _MD_LAST_THREAD() _pr_last_thread_tls() 249 250 #define _MD_SET_CURRENT_THREAD(newval) \ 251 PR_BEGIN_MACRO \ 252 thr_setspecific(threadid_key, (void *)newval); \ 253 PR_END_MACRO 254 255 #define _MD_SET_CURRENT_CPU(newval) \ 256 PR_BEGIN_MACRO \ 257 thr_setspecific(cpuid_key, (void *)newval); \ 258 PR_END_MACRO 259 260 #define _MD_SET_LAST_THREAD(newval) \ 261 PR_BEGIN_MACRO \ 262 thr_setspecific(last_thread_key, (void *)newval); \ 263 PR_END_MACRO 264 265 #define _MD_CLEAN_THREAD(_thread) _MD_cleanup_thread(_thread) 266 extern void _MD_exit_thread(PRThread *thread); 267 #define _MD_EXIT_THREAD(thread) _MD_exit_thread(thread) 268 269 #define _MD_SUSPEND_THREAD(thread) _MD_Suspend(thread) 270 #define _MD_RESUME_THREAD(thread) thr_continue((thread)->md.handle) 271 272 /* XXXX Needs to be defined - Prashant */ 273 #define _MD_SUSPEND_CPU(cpu) 274 #define _MD_RESUME_CPU(cpu) 275 276 extern void _MD_Begin_SuspendAll(void); 277 extern void _MD_End_SuspendAll(void); 278 extern void _MD_End_ResumeAll(void); 279 #define _MD_BEGIN_SUSPEND_ALL() _MD_Begin_SuspendAll() 280 #define _MD_BEGIN_RESUME_ALL() 281 #define _MD_END_SUSPEND_ALL() _MD_End_SuspendAll() 282 #define _MD_END_RESUME_ALL() _MD_End_ResumeAll() 283 284 #define _MD_INIT_LOCKS() 285 #define _MD_NEW_LOCK(md_lockp) (mutex_init(&((md_lockp)->lock),USYNC_THREAD,NULL) ? PR_FAILURE : PR_SUCCESS) 286 #define _MD_FREE_LOCK(md_lockp) mutex_destroy(&((md_lockp)->lock)) 287 #define _MD_UNLOCK(md_lockp) mutex_unlock(&((md_lockp)->lock)) 288 #define _MD_TEST_AND_LOCK(md_lockp) mutex_trylock(&((md_lockp)->lock)) 289 struct _MDLock; 290 NSPR_API(void) _MD_lock(struct _MDLock *md_lock); 291 #undef PROFILE_LOCKS 292 #ifndef PROFILE_LOCKS 293 #define _MD_LOCK(md_lockp) _MD_lock(md_lockp) 294 #else 295 #define _MD_LOCK(md_lockp) \ 296 PR_BEGIN_MACRO \ 297 int rv = _MD_TEST_AND_LOCK(md_lockp); \ 298 if (rv == 0) { \ 299 (md_lockp)->hitcount++; \ 300 } else { \ 301 (md_lockp)->misscount++; \ 302 _MD_lock(md_lockp); \ 303 } \ 304 PR_END_MACRO 305 #endif 306 307 #define _PR_LOCK_HEAP() if (_pr_heapLock) _MD_LOCK(&_pr_heapLock->md) 308 #define _PR_UNLOCK_HEAP() if (_pr_heapLock) _MD_UNLOCK(&_pr_heapLock->md) 309 310 #define _MD_ATTACH_THREAD(threadp) 311 312 313 #define THR_KEYCREATE thr_keycreate 314 #define THR_SELF thr_self 315 #define _MD_NEW_CV(condp) cond_init(&((condp)->cv), USYNC_THREAD, 0) 316 #define COND_WAIT(condp, mutexp) cond_wait(condp, mutexp) 317 #define COND_TIMEDWAIT(condp, mutexp, tspec) \ 318 cond_timedwait(condp, mutexp, tspec) 319 #define _MD_NOTIFY_CV(condp, lockp) cond_signal(&((condp)->cv)) 320 #define _MD_NOTIFYALL_CV(condp,unused) cond_broadcast(&((condp)->cv)) 321 #define _MD_FREE_CV(condp) cond_destroy(&((condp)->cv)) 322 #define _MD_YIELD() thr_yield() 323 #include <time.h> 324 /* 325 * Because clock_gettime() on Solaris/x86 2.4 always generates a 326 * segmentation fault, we use an emulated version _pr_solx86_clock_gettime(), 327 * which is implemented using gettimeofday(). 328 */ 329 #if defined(i386) && defined(SOLARIS2_4) 330 extern int _pr_solx86_clock_gettime(clockid_t clock_id, struct timespec *tp); 331 #define GETTIME(tt) _pr_solx86_clock_gettime(CLOCK_REALTIME, (tt)) 332 #else 333 #define GETTIME(tt) clock_gettime(CLOCK_REALTIME, (tt)) 334 #endif /* i386 && SOLARIS2_4 */ 335 336 #define MUTEX_T mutex_t 337 #define COND_T cond_t 338 339 #define _MD_NEW_SEM(md_semp,_val) sema_init(&((md_semp)->sem),_val,USYNC_THREAD,NULL) 340 #define _MD_DESTROY_SEM(md_semp) sema_destroy(&((md_semp)->sem)) 341 #define _MD_WAIT_SEM(md_semp) sema_wait(&((md_semp)->sem)) 342 #define _MD_POST_SEM(md_semp) sema_post(&((md_semp)->sem)) 343 344 #define _MD_SAVE_ERRNO(_thread) 345 #define _MD_RESTORE_ERRNO(_thread) 346 #define _MD_INIT_RUNNING_CPU(cpu) _MD_unix_init_running_cpu(cpu) 347 348 extern struct _MDLock _pr_ioq_lock; 349 #define _MD_IOQ_LOCK() _MD_LOCK(&_pr_ioq_lock) 350 #define _MD_IOQ_UNLOCK() _MD_UNLOCK(&_pr_ioq_lock) 351 352 extern PRStatus _MD_wait(struct PRThread *, PRIntervalTime timeout); 353 #define _MD_WAIT _MD_wait 354 355 extern PRStatus _MD_WakeupWaiter(struct PRThread *); 356 #define _MD_WAKEUP_WAITER _MD_WakeupWaiter 357 358 NSPR_API(void) _MD_InitIO(void); 359 #define _MD_INIT_IO _MD_InitIO 360 361 #define _MD_INIT_CONTEXT(_thread, _sp, _main, status) \ 362 PR_BEGIN_MACRO \ 363 *status = PR_TRUE; \ 364 PR_END_MACRO 365 #define _MD_SWITCH_CONTEXT(_thread) 366 #define _MD_RESTORE_CONTEXT(_newThread) 367 368 struct _MDLock { 369 MUTEX_T lock; 370 #ifdef PROFILE_LOCKS 371 PRInt32 hitcount; 372 PRInt32 misscount; 373 #endif 374 }; 375 376 struct _MDCVar { 377 COND_T cv; 378 }; 379 380 struct _MDSemaphore { 381 sema_t sem; 382 }; 383 384 struct _MDThread { 385 _PR_CONTEXT_TYPE context; 386 thread_t handle; 387 lwpid_t lwpid; 388 uint_t sp; /* stack pointer */ 389 uint_t threadID; /* ptr to solaris-internal thread id structures */ 390 struct _MDSemaphore waiter_sem; 391 }; 392 393 struct _MDThreadStack { 394 PRInt8 notused; 395 }; 396 397 struct _MDSegment { 398 PRInt8 notused; 399 }; 400 401 /* 402 * md-specific cpu structure field, common to all Unix platforms 403 */ 404 #define _PR_MD_MAX_OSFD FD_SETSIZE 405 406 struct _MDCPU_Unix { 407 PRCList ioQ; 408 PRUint32 ioq_timeout; 409 PRInt32 ioq_max_osfd; 410 PRInt32 ioq_osfd_cnt; 411 #ifndef _PR_USE_POLL 412 fd_set fd_read_set, fd_write_set, fd_exception_set; 413 PRInt16 fd_read_cnt[_PR_MD_MAX_OSFD],fd_write_cnt[_PR_MD_MAX_OSFD], 414 fd_exception_cnt[_PR_MD_MAX_OSFD]; 415 #else 416 struct pollfd *ioq_pollfds; 417 int ioq_pollfds_size; 418 #endif /* _PR_USE_POLL */ 419 }; 420 421 #define _PR_IOQ(_cpu) ((_cpu)->md.md_unix.ioQ) 422 #define _PR_ADD_TO_IOQ(_pq, _cpu) PR_APPEND_LINK(&_pq.links, &_PR_IOQ(_cpu)) 423 #define _PR_FD_READ_SET(_cpu) ((_cpu)->md.md_unix.fd_read_set) 424 #define _PR_FD_READ_CNT(_cpu) ((_cpu)->md.md_unix.fd_read_cnt) 425 #define _PR_FD_WRITE_SET(_cpu) ((_cpu)->md.md_unix.fd_write_set) 426 #define _PR_FD_WRITE_CNT(_cpu) ((_cpu)->md.md_unix.fd_write_cnt) 427 #define _PR_FD_EXCEPTION_SET(_cpu) ((_cpu)->md.md_unix.fd_exception_set) 428 #define _PR_FD_EXCEPTION_CNT(_cpu) ((_cpu)->md.md_unix.fd_exception_cnt) 429 #define _PR_IOQ_TIMEOUT(_cpu) ((_cpu)->md.md_unix.ioq_timeout) 430 #define _PR_IOQ_MAX_OSFD(_cpu) ((_cpu)->md.md_unix.ioq_max_osfd) 431 #define _PR_IOQ_OSFD_CNT(_cpu) ((_cpu)->md.md_unix.ioq_osfd_cnt) 432 #define _PR_IOQ_POLLFDS(_cpu) ((_cpu)->md.md_unix.ioq_pollfds) 433 #define _PR_IOQ_POLLFDS_SIZE(_cpu) ((_cpu)->md.md_unix.ioq_pollfds_size) 434 435 #define _PR_IOQ_MIN_POLLFDS_SIZE(_cpu) 32 436 437 438 struct _MDCPU { 439 struct _MDCPU_Unix md_unix; 440 }; 441 442 /* The following defines the unwrapped versions of select() and poll(). */ 443 extern int _select(int nfds, fd_set *readfds, fd_set *writefds, 444 fd_set *exceptfds, struct timeval *timeout); 445 #define _MD_SELECT _select 446 447 #include <poll.h> 448 #define _MD_POLL _poll 449 extern int _poll(struct pollfd *fds, unsigned long nfds, int timeout); 450 451 PR_BEGIN_EXTERN_C 452 453 /* 454 ** Missing function prototypes 455 */ 456 extern int gethostname (char *name, int namelen); 457 458 PR_END_EXTERN_C 459 460 #else /* _PR_GLOBAL_THREADS_ONLY */ 461 462 /* 463 * LOCAL_THREADS_ONLY implementation on Solaris 464 */ 465 466 #include "prthread.h" 467 468 #include <errno.h> 469 #include <ucontext.h> 470 #include <sys/stack.h> 471 #include <synch.h> 472 473 /* 474 ** Iinitialization Related definitions 475 */ 476 477 NSPR_API(void) _MD_EarlyInit(void); 478 NSPR_API(void) _MD_SolarisInit(); 479 #define _MD_EARLY_INIT _MD_EarlyInit 480 #define _MD_FINAL_INIT _MD_SolarisInit 481 #define _MD_INIT_THREAD _MD_InitializeThread 482 483 #ifdef USE_SETJMP 484 485 #include <setjmp.h> 486 487 #define _PR_CONTEXT_TYPE jmp_buf 488 489 #ifdef sparc 490 #define _MD_GET_SP(_t) (_t)->md.context[2] 491 #else 492 #define _MD_GET_SP(_t) (_t)->md.context[4] 493 #endif 494 495 #define PR_NUM_GCREGS _JBLEN 496 #define CONTEXT(_thread) (_thread)->md.context 497 498 #else /* ! USE_SETJMP */ 499 500 #ifdef sparc 501 #define _PR_CONTEXT_TYPE ucontext_t 502 #define _MD_GET_SP(_t) (_t)->md.context.uc_mcontext.gregs[REG_SP] 503 /* 504 ** Sparc's use register windows. the _MD_GetRegisters for the sparc's 505 ** doesn't actually store anything into the argument buffer; instead the 506 ** register windows are homed to the stack. I assume that the stack 507 ** always has room for the registers to spill to... 508 */ 509 #define PR_NUM_GCREGS 0 510 #else 511 #define _PR_CONTEXT_TYPE unsigned int edi; sigset_t oldMask, blockMask; ucontext_t 512 #define _MD_GET_SP(_t) (_t)->md.context.uc_mcontext.gregs[USP] 513 #define PR_NUM_GCREGS _JBLEN 514 #endif 515 516 #define CONTEXT(_thread) (&(_thread)->md.context) 517 518 #endif /* ! USE_SETJMP */ 519 520 #include <time.h> 521 /* 522 * Because clock_gettime() on Solaris/x86 always generates a 523 * segmentation fault, we use an emulated version _pr_solx86_clock_gettime(), 524 * which is implemented using gettimeofday(). 525 */ 526 #ifdef i386 527 #define GETTIME(tt) _pr_solx86_clock_gettime(CLOCK_REALTIME, (tt)) 528 #else 529 #define GETTIME(tt) clock_gettime(CLOCK_REALTIME, (tt)) 530 #endif /* i386 */ 531 532 #define _MD_SAVE_ERRNO(_thread) (_thread)->md.errcode = errno; 533 #define _MD_RESTORE_ERRNO(_thread) errno = (_thread)->md.errcode; 534 535 #ifdef sparc 536 537 #ifdef USE_SETJMP 538 #define _MD_INIT_CONTEXT(_thread, _sp, _main, status) \ 539 PR_BEGIN_MACRO \ 540 int *context = (_thread)->md.context; \ 541 *status = PR_TRUE; \ 542 (void) setjmp(context); \ 543 (_thread)->md.context[1] = (int) ((_sp) - 64); \ 544 (_thread)->md.context[2] = (int) _main; \ 545 (_thread)->md.context[3] = (int) _main + 4; \ 546 _thread->no_sched = 0; \ 547 PR_END_MACRO 548 549 #define _MD_SWITCH_CONTEXT(_thread) \ 550 if (!setjmp(CONTEXT(_thread))) { \ 551 _MD_SAVE_ERRNO(_thread) \ 552 _MD_SET_LAST_THREAD(_thread); \ 553 _MD_SET_CURRENT_THREAD(_thread); \ 554 _PR_Schedule(); \ 555 } 556 557 #define _MD_RESTORE_CONTEXT(_newThread) \ 558 { \ 559 _MD_RESTORE_ERRNO(_newThread) \ 560 _MD_SET_CURRENT_THREAD(_newThread); \ 561 longjmp(CONTEXT(_newThread), 1); \ 562 } 563 564 #else 565 /* 566 ** Initialize the thread context preparing it to execute _main. 567 */ 568 #define _MD_INIT_CONTEXT(_thread, _sp, _main, status) \ 569 PR_BEGIN_MACRO \ 570 ucontext_t *uc = CONTEXT(_thread); \ 571 *status = PR_TRUE; \ 572 getcontext(uc); \ 573 uc->uc_stack.ss_sp = (char *) ((unsigned long)(_sp - WINDOWSIZE - SA(MINFRAME)) & 0xfffffff8); \ 574 uc->uc_stack.ss_size = _thread->stack->stackSize; \ 575 uc->uc_stack.ss_flags = 0; /* ? */ \ 576 uc->uc_mcontext.gregs[REG_SP] = (unsigned int) uc->uc_stack.ss_sp; \ 577 uc->uc_mcontext.gregs[REG_PC] = (unsigned int) _main; \ 578 uc->uc_mcontext.gregs[REG_nPC] = (unsigned int) ((char*)_main)+4; \ 579 uc->uc_flags = UC_ALL; \ 580 _thread->no_sched = 0; \ 581 PR_END_MACRO 582 583 /* 584 ** Switch away from the current thread context by saving its state and 585 ** calling the thread scheduler. Reload cpu when we come back from the 586 ** context switch because it might have changed. 587 */ 588 #define _MD_SWITCH_CONTEXT(_thread) \ 589 PR_BEGIN_MACRO \ 590 if (!getcontext(CONTEXT(_thread))) { \ 591 _MD_SAVE_ERRNO(_thread); \ 592 _MD_SET_LAST_THREAD(_thread); \ 593 _PR_Schedule(); \ 594 } \ 595 PR_END_MACRO 596 597 /* 598 ** Restore a thread context that was saved by _MD_SWITCH_CONTEXT or 599 ** initialized by _MD_INIT_CONTEXT. 600 */ 601 #define _MD_RESTORE_CONTEXT(_newThread) \ 602 PR_BEGIN_MACRO \ 603 ucontext_t *uc = CONTEXT(_newThread); \ 604 uc->uc_mcontext.gregs[11] = 1; \ 605 _MD_RESTORE_ERRNO(_newThread); \ 606 _MD_SET_CURRENT_THREAD(_newThread); \ 607 setcontext(uc); \ 608 PR_END_MACRO 609 #endif 610 611 #else /* x86 solaris */ 612 613 #ifdef USE_SETJMP 614 615 #define _MD_INIT_CONTEXT(_thread, _sp, _main, status) \ 616 PR_BEGIN_MACRO \ 617 *status = PR_TRUE; \ 618 if (setjmp(CONTEXT(_thread))) _main(); \ 619 _MD_GET_SP(_thread) = (int) ((_sp) - 64); \ 620 PR_END_MACRO 621 622 #define _MD_SWITCH_CONTEXT(_thread) \ 623 if (!setjmp(CONTEXT(_thread))) { \ 624 _MD_SAVE_ERRNO(_thread) \ 625 _PR_Schedule(); \ 626 } 627 628 #define _MD_RESTORE_CONTEXT(_newThread) \ 629 { \ 630 _MD_RESTORE_ERRNO(_newThread) \ 631 _MD_SET_CURRENT_THREAD(_newThread); \ 632 longjmp(CONTEXT(_newThread), 1); \ 633 } 634 635 #else /* USE_SETJMP */ 636 637 #define WINDOWSIZE 0 638 639 int getedi(void); 640 void setedi(int); 641 642 #define _MD_INIT_CONTEXT(_thread, _sp, _main, status) \ 643 PR_BEGIN_MACRO \ 644 ucontext_t *uc = CONTEXT(_thread); \ 645 *status = PR_TRUE; \ 646 getcontext(uc); \ 647 /* Force sp to be double aligned! */ \ 648 uc->uc_mcontext.gregs[USP] = (int) ((unsigned long)(_sp - WINDOWSIZE - SA(MINFRAME)) & 0xfffffff8); \ 649 uc->uc_mcontext.gregs[PC] = (int) _main; \ 650 (_thread)->no_sched = 0; \ 651 PR_END_MACRO 652 653 /* getcontext() may return 1, contrary to what the man page says */ 654 #define _MD_SWITCH_CONTEXT(_thread) \ 655 PR_BEGIN_MACRO \ 656 ucontext_t *uc = CONTEXT(_thread); \ 657 PR_ASSERT(_thread->no_sched); \ 658 sigfillset(&((_thread)->md.blockMask)); \ 659 sigprocmask(SIG_BLOCK, &((_thread)->md.blockMask), \ 660 &((_thread)->md.oldMask)); \ 661 (_thread)->md.edi = getedi(); \ 662 if (! getcontext(uc)) { \ 663 sigprocmask(SIG_SETMASK, &((_thread)->md.oldMask), NULL); \ 664 uc->uc_mcontext.gregs[EDI] = (_thread)->md.edi; \ 665 _MD_SAVE_ERRNO(_thread) \ 666 _MD_SET_LAST_THREAD(_thread); \ 667 _PR_Schedule(); \ 668 } else { \ 669 sigprocmask(SIG_SETMASK, &((_thread)->md.oldMask), NULL); \ 670 setedi((_thread)->md.edi); \ 671 PR_ASSERT(_MD_LAST_THREAD() !=_MD_CURRENT_THREAD()); \ 672 _MD_LAST_THREAD()->no_sched = 0; \ 673 } \ 674 PR_END_MACRO 675 676 /* 677 ** Restore a thread context, saved by _PR_SWITCH_CONTEXT 678 */ 679 #define _MD_RESTORE_CONTEXT(_newthread) \ 680 PR_BEGIN_MACRO \ 681 ucontext_t *uc = CONTEXT(_newthread); \ 682 uc->uc_mcontext.gregs[EAX] = 1; \ 683 _MD_RESTORE_ERRNO(_newthread) \ 684 _MD_SET_CURRENT_THREAD(_newthread); \ 685 (_newthread)->no_sched = 1; \ 686 setcontext(uc); \ 687 PR_END_MACRO 688 #endif /* USE_SETJMP */ 689 690 #endif /* sparc */ 691 692 struct _MDLock { 693 PRInt8 notused; 694 }; 695 696 struct _MDCVar { 697 PRInt8 notused; 698 }; 699 700 struct _MDSemaphore { 701 PRInt8 notused; 702 }; 703 704 struct _MDThread { 705 _PR_CONTEXT_TYPE context; 706 int errcode; 707 int id; 708 }; 709 710 struct _MDThreadStack { 711 PRInt8 notused; 712 }; 713 714 struct _MDSegment { 715 PRInt8 notused; 716 }; 717 718 /* 719 * md-specific cpu structure field 720 */ 721 #define _PR_MD_MAX_OSFD FD_SETSIZE 722 723 struct _MDCPU_Unix { 724 PRCList ioQ; 725 PRUint32 ioq_timeout; 726 PRInt32 ioq_max_osfd; 727 PRInt32 ioq_osfd_cnt; 728 #ifndef _PR_USE_POLL 729 fd_set fd_read_set, fd_write_set, fd_exception_set; 730 PRInt16 fd_read_cnt[_PR_MD_MAX_OSFD],fd_write_cnt[_PR_MD_MAX_OSFD], 731 fd_exception_cnt[_PR_MD_MAX_OSFD]; 732 #else 733 struct pollfd *ioq_pollfds; 734 int ioq_pollfds_size; 735 #endif /* _PR_USE_POLL */ 736 }; 737 738 #define _PR_IOQ(_cpu) ((_cpu)->md.md_unix.ioQ) 739 #define _PR_ADD_TO_IOQ(_pq, _cpu) PR_APPEND_LINK(&_pq.links, &_PR_IOQ(_cpu)) 740 #define _PR_FD_READ_SET(_cpu) ((_cpu)->md.md_unix.fd_read_set) 741 #define _PR_FD_READ_CNT(_cpu) ((_cpu)->md.md_unix.fd_read_cnt) 742 #define _PR_FD_WRITE_SET(_cpu) ((_cpu)->md.md_unix.fd_write_set) 743 #define _PR_FD_WRITE_CNT(_cpu) ((_cpu)->md.md_unix.fd_write_cnt) 744 #define _PR_FD_EXCEPTION_SET(_cpu) ((_cpu)->md.md_unix.fd_exception_set) 745 #define _PR_FD_EXCEPTION_CNT(_cpu) ((_cpu)->md.md_unix.fd_exception_cnt) 746 #define _PR_IOQ_TIMEOUT(_cpu) ((_cpu)->md.md_unix.ioq_timeout) 747 #define _PR_IOQ_MAX_OSFD(_cpu) ((_cpu)->md.md_unix.ioq_max_osfd) 748 #define _PR_IOQ_OSFD_CNT(_cpu) ((_cpu)->md.md_unix.ioq_osfd_cnt) 749 #define _PR_IOQ_POLLFDS(_cpu) ((_cpu)->md.md_unix.ioq_pollfds) 750 #define _PR_IOQ_POLLFDS_SIZE(_cpu) ((_cpu)->md.md_unix.ioq_pollfds_size) 751 752 #define _PR_IOQ_MIN_POLLFDS_SIZE(_cpu) 32 753 754 struct _MDCPU { 755 struct _MDCPU_Unix md_unix; 756 }; 757 758 #ifndef _PR_PTHREADS 759 #define _MD_INIT_LOCKS() 760 #endif 761 #define _MD_NEW_LOCK(lock) PR_SUCCESS 762 #define _MD_FREE_LOCK(lock) 763 #define _MD_LOCK(lock) 764 #define _MD_UNLOCK(lock) 765 #define _MD_INIT_IO() 766 #define _MD_IOQ_LOCK() 767 #define _MD_IOQ_UNLOCK() 768 769 #define _MD_INIT_RUNNING_CPU(cpu) _MD_unix_init_running_cpu(cpu) 770 #define _MD_INIT_THREAD _MD_InitializeThread 771 #define _MD_EXIT_THREAD(thread) 772 #define _MD_SUSPEND_THREAD(thread) 773 #define _MD_RESUME_THREAD(thread) 774 #define _MD_CLEAN_THREAD(_thread) 775 776 extern PRStatus _MD_WAIT(struct PRThread *, PRIntervalTime timeout); 777 extern PRStatus _MD_WAKEUP_WAITER(struct PRThread *); 778 extern void _MD_YIELD(void); 779 extern PRStatus _MD_InitializeThread(PRThread *thread); 780 extern void _MD_SET_PRIORITY(struct _MDThread *thread, 781 PRThreadPriority newPri); 782 extern PRStatus _MD_CREATE_THREAD(PRThread *thread, void (*start) (void *), 783 PRThreadPriority priority, PRThreadScope scope, PRThreadState state, 784 PRUint32 stackSize); 785 786 NSPR_API(PRIntervalTime) _MD_Solaris_GetInterval(void); 787 #define _MD_GET_INTERVAL _MD_Solaris_GetInterval 788 NSPR_API(PRIntervalTime) _MD_Solaris_TicksPerSecond(void); 789 #define _MD_INTERVAL_PER_SEC _MD_Solaris_TicksPerSecond 790 791 /* The following defines the unwrapped versions of select() and poll(). */ 792 extern int _select(int nfds, fd_set *readfds, fd_set *writefds, 793 fd_set *exceptfds, struct timeval *timeout); 794 #define _MD_SELECT _select 795 796 #include <stropts.h> 797 #include <poll.h> 798 #define _MD_POLL _poll 799 extern int _poll(struct pollfd *fds, unsigned long nfds, int timeout); 800 801 PR_BEGIN_EXTERN_C 802 803 /* 804 ** Missing function prototypes 805 */ 806 extern int gethostname (char *name, int namelen); 807 808 PR_END_EXTERN_C 809 810 #endif /* _PR_GLOBAL_THREADS_ONLY */ 811 812 extern void _MD_solaris_map_sendfile_error(int err); 813 814 #endif /* nspr_solaris_defs_h___ */ 815 816
