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_irix_defs_h___ 36 #define nspr_irix_defs_h___ 37 38 #define _PR_HAVE_ATOMIC_CAS 39 40 /* 41 * MipsPro assembler defines _LANGUAGE_ASSEMBLY 42 */ 43 #ifndef _LANGUAGE_ASSEMBLY 44 45 #include "prclist.h" 46 #include "prthread.h" 47 #include <sys/ucontext.h> 48 49 /* 50 * Internal configuration macros 51 */ 52 53 #define PR_LINKER_ARCH "irix" 54 #define _PR_SI_SYSNAME "IRIX" 55 #define _PR_SI_ARCHITECTURE "mips" 56 #define PR_DLL_SUFFIX ".so" 57 58 #define _PR_VMBASE 0x30000000 59 #define _PR_STACK_VMBASE 0x50000000 60 #define _PR_NUM_GCREGS 9 61 #define _MD_MMAP_FLAGS MAP_PRIVATE 62 63 #define _MD_DEFAULT_STACK_SIZE 65536L 64 #define _MD_MIN_STACK_SIZE 16384L 65 66 #undef HAVE_STACK_GROWING_UP 67 #define HAVE_WEAK_IO_SYMBOLS 68 #define HAVE_WEAK_MALLOC_SYMBOLS 69 #define HAVE_DLL 70 #define USE_DLFCN 71 #define _PR_HAVE_ATOMIC_OPS 72 #define _PR_POLL_AVAILABLE 73 #define _PR_USE_POLL 74 #define _PR_STAT_HAS_ST_ATIM 75 #define _PR_HAVE_OFF64_T 76 #define HAVE_POINTER_LOCALTIME_R 77 #define _PR_HAVE_POSIX_SEMAPHORES 78 #define PR_HAVE_POSIX_NAMED_SHARED_MEMORY 79 #define _PR_ACCEPT_INHERIT_NONBLOCK 80 81 #ifdef _PR_INET6 82 #define _PR_HAVE_INET_NTOP 83 #define _PR_HAVE_GETIPNODEBYNAME 84 #define _PR_HAVE_GETIPNODEBYADDR 85 #define _PR_HAVE_GETADDRINFO 86 #endif 87 88 /* Initialization entry points */ 89 NSPR_API(void) _MD_EarlyInit(void); 90 #define _MD_EARLY_INIT _MD_EarlyInit 91 92 NSPR_API(void) _MD_IrixInit(void); 93 #define _MD_FINAL_INIT _MD_IrixInit 94 95 #define _MD_INIT_IO() 96 97 /* Timer operations */ 98 NSPR_API(PRIntervalTime) _MD_IrixGetInterval(void); 99 #define _MD_GET_INTERVAL _MD_IrixGetInterval 100 101 NSPR_API(PRIntervalTime) _MD_IrixIntervalPerSec(void); 102 #define _MD_INTERVAL_PER_SEC _MD_IrixIntervalPerSec 103 104 /* GC operations */ 105 NSPR_API(void *) _MD_GetSP(PRThread *thread); 106 #define _MD_GET_SP _MD_GetSP 107 108 /* The atomic operations */ 109 #include <mutex.h> 110 #define _MD_INIT_ATOMIC() 111 #define _MD_ATOMIC_INCREMENT(val) add_then_test((unsigned long*)val, 1) 112 #define _MD_ATOMIC_ADD(ptr, val) add_then_test((unsigned long*)ptr, (unsigned long)val) 113 #define _MD_ATOMIC_DECREMENT(val) add_then_test((unsigned long*)val, 0xffffffff) 114 #define _MD_ATOMIC_SET(val, newval) test_and_set((unsigned long*)val, newval) 115 116 #if defined(_PR_PTHREADS) 117 #else /* defined(_PR_PTHREADS) */ 118 119 /************************************************************************/ 120 121 #include <setjmp.h> 122 #include <errno.h> 123 #include <unistd.h> 124 #include <bstring.h> 125 #include <sys/time.h> 126 #include <ulocks.h> 127 #include <sys/prctl.h> 128 129 130 /* 131 * Data region private to each sproc. This region is setup by calling 132 * mmap(...,MAP_LOCAL,...). The private data is mapped at the same 133 * address in every sproc, but every sproc gets a private mapping. 134 * 135 * Just make sure that this structure fits in a page, as only one page 136 * is allocated for the private region. 137 */ 138 struct sproc_private_data { 139 struct PRThread *me; 140 struct _PRCPU *cpu; 141 struct PRThread *last; 142 PRUintn intsOff; 143 int sproc_pid; 144 }; 145 146 extern char *_nspr_sproc_private; 147 148 #define _PR_PRDA() ((struct sproc_private_data *) _nspr_sproc_private) 149 #define _MD_SET_CURRENT_THREAD(_thread) _PR_PRDA()->me = (_thread) 150 #define _MD_THIS_THREAD() (_PR_PRDA()->me) 151 #define _MD_LAST_THREAD() (_PR_PRDA()->last) 152 #define _MD_SET_LAST_THREAD(_thread) _PR_PRDA()->last = (_thread) 153 #define _MD_CURRENT_CPU() (_PR_PRDA()->cpu) 154 #define _MD_SET_CURRENT_CPU(_cpu) _PR_PRDA()->cpu = (_cpu) 155 #define _MD_SET_INTSOFF(_val) (_PR_PRDA()->intsOff = _val) 156 #define _MD_GET_INTSOFF() (_PR_PRDA()->intsOff) 157 158 #define _MD_SET_SPROC_PID(_val) (_PR_PRDA()->sproc_pid = _val) 159 #define _MD_GET_SPROC_PID() (_PR_PRDA()->sproc_pid) 160 161 NSPR_API(struct PRThread*) _MD_get_attached_thread(void); 162 NSPR_API(struct PRThread*) _MD_get_current_thread(void); 163 #define _MD_GET_ATTACHED_THREAD() _MD_get_attached_thread() 164 #define _MD_CURRENT_THREAD() _MD_get_current_thread() 165 166 #define _MD_CHECK_FOR_EXIT() { \ 167 if (_pr_irix_exit_now) { \ 168 _PR_POST_SEM(_pr_irix_exit_sem); \ 169 _MD_Wakeup_CPUs(); \ 170 _exit(0); \ 171 } \ 172 } 173 174 #define _MD_ATTACH_THREAD(threadp) 175 176 #define _MD_SAVE_ERRNO(_thread) (_thread)->md.errcode = errno; 177 #define _MD_RESTORE_ERRNO(_thread) errno = (_thread)->md.errcode; 178 179 extern struct _PRCPU *_pr_primordialCPU; 180 extern usema_t *_pr_irix_exit_sem; 181 extern PRInt32 _pr_irix_exit_now; 182 extern int _pr_irix_primoridal_cpu_fd[]; 183 extern PRInt32 _pr_irix_process_exit; 184 extern PRInt32 _pr_irix_process_exit_code; 185 186 /* Thread operations */ 187 #define _PR_LOCK_HEAP() { \ 188 PRIntn _is; \ 189 if (_pr_primordialCPU) { \ 190 if (_MD_GET_ATTACHED_THREAD() && \ 191 !_PR_IS_NATIVE_THREAD( \ 192 _MD_GET_ATTACHED_THREAD())) \ 193 _PR_INTSOFF(_is); \ 194 _PR_LOCK(_pr_heapLock); \ 195 } 196 197 #define _PR_UNLOCK_HEAP() if (_pr_primordialCPU) { \ 198 _PR_UNLOCK(_pr_heapLock); \ 199 if (_MD_GET_ATTACHED_THREAD() && \ 200 !_PR_IS_NATIVE_THREAD( \ 201 _MD_GET_ATTACHED_THREAD())) \ 202 _PR_INTSON(_is); \ 203 } \ 204 } 205 206 #define _PR_OPEN_POLL_SEM(_sem) usopenpollsema(_sem, 0666) 207 #define _PR_WAIT_SEM(_sem) uspsema(_sem) 208 #define _PR_POST_SEM(_sem) usvsema(_sem) 209 210 #define _MD_CVAR_POST_SEM(threadp) usvsema((threadp)->md.cvar_pollsem) 211 212 #define _MD_IOQ_LOCK() 213 #define _MD_IOQ_UNLOCK() 214 215 struct _MDLock { 216 ulock_t lock; 217 usptr_t *arena; 218 }; 219 220 /* 221 * disable pre-emption for the LOCAL threads when calling the arena lock 222 * routines 223 */ 224 225 #define _PR_LOCK(lock) { \ 226 PRIntn _is; \ 227 PRThread *me = _MD_GET_ATTACHED_THREAD(); \ 228 if (me && !_PR_IS_NATIVE_THREAD(me)) \ 229 _PR_INTSOFF(_is); \ 230 ussetlock(lock); \ 231 if (me && !_PR_IS_NATIVE_THREAD(me)) \ 232 _PR_FAST_INTSON(_is); \ 233 } 234 235 #define _PR_UNLOCK(lock) { \ 236 PRIntn _is; \ 237 PRThread *me = _MD_GET_ATTACHED_THREAD(); \ 238 if (me && !_PR_IS_NATIVE_THREAD(me)) \ 239 _PR_INTSOFF(_is); \ 240 usunsetlock(lock); \ 241 if (me && !_PR_IS_NATIVE_THREAD(me)) \ 242 _PR_FAST_INTSON(_is); \ 243 } 244 245 NSPR_API(PRStatus) _MD_NEW_LOCK(struct _MDLock *md); 246 NSPR_API(void) _MD_FREE_LOCK(struct _MDLock *lockp); 247 248 #define _MD_LOCK(_lockp) _PR_LOCK((_lockp)->lock) 249 #define _MD_UNLOCK(_lockp) _PR_UNLOCK((_lockp)->lock) 250 #define _MD_TEST_AND_LOCK(_lockp) (uscsetlock((_lockp)->lock, 1) == 0) 251 252 extern ulock_t _pr_heapLock; 253 254 struct _MDThread { 255 jmp_buf jb; 256 usptr_t *pollsem_arena; 257 usema_t *cvar_pollsem; 258 PRInt32 cvar_pollsemfd; 259 PRInt32 cvar_pollsem_select; /* acquire sem by calling select */ 260 PRInt32 cvar_wait; /* if 1, thread is waiting on cvar Q */ 261 PRInt32 id; 262 PRInt32 suspending_id; 263 int errcode; 264 }; 265 266 struct _MDThreadStack { 267 PRInt8 notused; 268 }; 269 270 struct _MDSemaphore { 271 usema_t *sem; 272 }; 273 274 struct _MDCVar { 275 ulock_t mdcvar_lock; 276 }; 277 278 struct _MDSegment { 279 PRInt8 notused; 280 }; 281 282 /* 283 * md-specific cpu structure field 284 */ 285 #define _PR_MD_MAX_OSFD FD_SETSIZE 286 287 struct _MDCPU_Unix { 288 PRCList ioQ; 289 PRUint32 ioq_timeout; 290 PRInt32 ioq_max_osfd; 291 PRInt32 ioq_osfd_cnt; 292 #ifndef _PR_USE_POLL 293 fd_set fd_read_set, fd_write_set, fd_exception_set; 294 PRInt16 fd_read_cnt[_PR_MD_MAX_OSFD],fd_write_cnt[_PR_MD_MAX_OSFD], 295 fd_exception_cnt[_PR_MD_MAX_OSFD]; 296 #else 297 struct pollfd *ioq_pollfds; 298 int ioq_pollfds_size; 299 #endif /* _PR_USE_POLL */ 300 }; 301 302 #define _PR_IOQ(_cpu) ((_cpu)->md.md_unix.ioQ) 303 #define _PR_ADD_TO_IOQ(_pq, _cpu) PR_APPEND_LINK(&_pq.links, &_PR_IOQ(_cpu)) 304 #define _PR_FD_READ_SET(_cpu) ((_cpu)->md.md_unix.fd_read_set) 305 #define _PR_FD_READ_CNT(_cpu) ((_cpu)->md.md_unix.fd_read_cnt) 306 #define _PR_FD_WRITE_SET(_cpu) ((_cpu)->md.md_unix.fd_write_set) 307 #define _PR_FD_WRITE_CNT(_cpu) ((_cpu)->md.md_unix.fd_write_cnt) 308 #define _PR_FD_EXCEPTION_SET(_cpu) ((_cpu)->md.md_unix.fd_exception_set) 309 #define _PR_FD_EXCEPTION_CNT(_cpu) ((_cpu)->md.md_unix.fd_exception_cnt) 310 #define _PR_IOQ_TIMEOUT(_cpu) ((_cpu)->md.md_unix.ioq_timeout) 311 #define _PR_IOQ_MAX_OSFD(_cpu) ((_cpu)->md.md_unix.ioq_max_osfd) 312 #define _PR_IOQ_OSFD_CNT(_cpu) ((_cpu)->md.md_unix.ioq_osfd_cnt) 313 #define _PR_IOQ_POLLFDS(_cpu) ((_cpu)->md.md_unix.ioq_pollfds) 314 #define _PR_IOQ_POLLFDS_SIZE(_cpu) ((_cpu)->md.md_unix.ioq_pollfds_size) 315 316 #define _PR_IOQ_MIN_POLLFDS_SIZE(_cpu) 32 317 318 319 struct _MDCPU { 320 PRInt32 id; 321 PRInt32 suspending_id; 322 struct _MDCPU_Unix md_unix; 323 }; 324 325 /* 326 ** Initialize the thread context preparing it to execute _main. 327 */ 328 #define _MD_INIT_CONTEXT(_thread, _sp, _main, status) \ 329 PR_BEGIN_MACRO \ 330 int *jb = (_thread)->md.jb; \ 331 *status = PR_TRUE; \ 332 (void) setjmp(jb); \ 333 (_thread)->md.jb[JB_SP] = (int) ((_sp) - 64); \ 334 (_thread)->md.jb[JB_PC] = (int) _main; \ 335 _thread->no_sched = 0; \ 336 PR_END_MACRO 337 338 /* 339 ** Switch away from the current thread context by saving its state and 340 ** calling the thread scheduler. Reload cpu when we come back from the 341 ** context switch because it might have changed. 342 * 343 * XXX RUNQ lock needed before clearing _PR_NO_SCHED flag, because the 344 * thread may be unr RUNQ? 345 */ 346 #define _MD_SWITCH_CONTEXT(_thread) \ 347 PR_BEGIN_MACRO \ 348 PR_ASSERT(_thread->no_sched); \ 349 if (!setjmp(_thread->md.jb)) { \ 350 _MD_SAVE_ERRNO(_thread) \ 351 _MD_SET_LAST_THREAD(_thread); \ 352 _PR_Schedule(); \ 353 } else { \ 354 PR_ASSERT(_MD_LAST_THREAD() !=_MD_CURRENT_THREAD()); \ 355 _MD_LAST_THREAD()->no_sched = 0; \ 356 } \ 357 PR_END_MACRO 358 359 /* 360 ** Restore a thread context that was saved by _MD_SWITCH_CONTEXT or 361 ** initialized by _MD_INIT_CONTEXT. 362 */ 363 #define _MD_RESTORE_CONTEXT(_newThread) \ 364 PR_BEGIN_MACRO \ 365 int *jb = (_newThread)->md.jb; \ 366 _MD_RESTORE_ERRNO(_newThread) \ 367 _MD_SET_CURRENT_THREAD(_newThread); \ 368 _newThread->no_sched = 1; \ 369 longjmp(jb, 1); \ 370 PR_END_MACRO 371 372 NSPR_API(PRStatus) _MD_InitThread(struct PRThread *thread, 373 PRBool wakeup_parent); 374 NSPR_API(PRStatus) _MD_InitAttachedThread(struct PRThread *thread, 375 PRBool wakeup_parent); 376 #define _MD_INIT_THREAD(thread) _MD_InitThread(thread, PR_TRUE) 377 #define _MD_INIT_ATTACHED_THREAD(thread) \ 378 _MD_InitAttachedThread(thread, PR_FALSE) 379 380 NSPR_API(void) _MD_ExitThread(struct PRThread *thread); 381 #define _MD_EXIT_THREAD _MD_ExitThread 382 383 NSPR_API(void) _MD_SuspendThread(struct PRThread *thread); 384 #define _MD_SUSPEND_THREAD _MD_SuspendThread 385 386 NSPR_API(void) _MD_ResumeThread(struct PRThread *thread); 387 #define _MD_RESUME_THREAD _MD_ResumeThread 388 389 NSPR_API(void) _MD_SuspendCPU(struct _PRCPU *thread); 390 #define _MD_SUSPEND_CPU _MD_SuspendCPU 391 392 NSPR_API(void) _MD_ResumeCPU(struct _PRCPU *thread); 393 #define _MD_RESUME_CPU _MD_ResumeCPU 394 395 #define _MD_BEGIN_SUSPEND_ALL() 396 #define _MD_END_SUSPEND_ALL() 397 #define _MD_BEGIN_RESUME_ALL() 398 #define _MD_END_RESUME_ALL() 399 400 NSPR_API(void) _MD_InitLocks(void); 401 #define _MD_INIT_LOCKS _MD_InitLocks 402 403 NSPR_API(void) _MD_CleanThread(struct PRThread *thread); 404 #define _MD_CLEAN_THREAD _MD_CleanThread 405 406 #define _MD_YIELD() sginap(0) 407 408 /* The _PR_MD_WAIT_LOCK and _PR_MD_WAKEUP_WAITER functions put to sleep and 409 * awaken a thread which is waiting on a lock or cvar. 410 */ 411 NSPR_API(PRStatus) _MD_wait(struct PRThread *, PRIntervalTime timeout); 412 #define _MD_WAIT _MD_wait 413 414 NSPR_API(void) _PR_MD_primordial_cpu(); 415 NSPR_API(void) _PR_MD_WAKEUP_PRIMORDIAL_CPU(); 416 417 NSPR_API(PRStatus) _MD_WakeupWaiter(struct PRThread *); 418 #define _MD_WAKEUP_WAITER _MD_WakeupWaiter 419 420 NSPR_API(void ) _MD_exit(PRIntn status); 421 #define _MD_EXIT _MD_exit 422 423 #include "prthread.h" 424 425 NSPR_API(void) _MD_SetPriority(struct _MDThread *thread, 426 PRThreadPriority newPri); 427 #define _MD_SET_PRIORITY _MD_SetPriority 428 429 NSPR_API(PRStatus) _MD_CreateThread( 430 struct PRThread *thread, 431 void (*start) (void *), 432 PRThreadPriority priority, 433 PRThreadScope scope, 434 PRThreadState state, 435 PRUint32 stackSize); 436 #define _MD_CREATE_THREAD _MD_CreateThread 437 438 extern void _MD_CleanupBeforeExit(void); 439 #define _MD_CLEANUP_BEFORE_EXIT _MD_CleanupBeforeExit 440 441 NSPR_API(void) _PR_MD_PRE_CLEANUP(PRThread *me); 442 443 444 /* The following defines the unwrapped versions of select() and poll(). */ 445 extern int _select(int nfds, fd_set *readfds, fd_set *writefds, 446 fd_set *exceptfds, struct timeval *timeout); 447 #define _MD_SELECT _select 448 449 #include <stropts.h> 450 #include <poll.h> 451 #define _MD_POLL _poll 452 extern int _poll(struct pollfd *fds, unsigned long nfds, int timeout); 453 454 455 #define HAVE_THREAD_AFFINITY 1 456 457 NSPR_API(PRInt32) _MD_GetThreadAffinityMask(PRThread *unused, PRUint32 *mask); 458 #define _MD_GETTHREADAFFINITYMASK _MD_GetThreadAffinityMask 459 460 NSPR_API(void) _MD_InitRunningCPU(struct _PRCPU *cpu); 461 #define _MD_INIT_RUNNING_CPU _MD_InitRunningCPU 462 463 #endif /* defined(_PR_PTHREADS) */ 464 465 #endif /* _LANGUAGE_ASSEMBLY */ 466 467 #endif /* nspr_irix_defs_h___ */ 468
