Lines Matching defs:ulwp
174 hash_in_unlocked(ulwp_t *ulwp, int ix, uberdata_t *udp)
176 ulwp->ul_hash = udp->thr_hash_table[ix].hash_bucket;
177 udp->thr_hash_table[ix].hash_bucket = ulwp;
178 ulwp->ul_ix = ix;
182 hash_in(ulwp_t *ulwp, uberdata_t *udp)
184 int ix = TIDHASH(ulwp->ul_lwpid, udp);
188 hash_in_unlocked(ulwp, ix, udp);
196 hash_out_unlocked(ulwp_t *ulwp, int ix, uberdata_t *udp)
201 ulwp != *ulwpp;
204 *ulwpp = ulwp->ul_hash;
205 ulwp->ul_hash = NULL;
206 ulwp->ul_ix = -1;
210 hash_out(ulwp_t *ulwp, uberdata_t *udp)
214 if ((ix = ulwp->ul_ix) >= 0) {
218 hash_out_unlocked(ulwp, ix, udp);
228 ulwp_clean(ulwp_t *ulwp)
230 caddr_t stk = ulwp->ul_stk;
231 size_t mapsiz = ulwp->ul_mapsiz;
232 size_t guardsize = ulwp->ul_guardsize;
233 uintptr_t stktop = ulwp->ul_stktop;
234 size_t stksiz = ulwp->ul_stksiz;
236 (void) memset(ulwp, 0, sizeof (*ulwp));
238 ulwp->ul_stk = stk;
239 ulwp->ul_mapsiz = mapsiz;
240 ulwp->ul_guardsize = guardsize;
241 ulwp->ul_stktop = stktop;
242 ulwp->ul_stksiz = stksiz;
254 dead_and_buried(ulwp_t *ulwp)
256 if (ulwp->ul_lwpid == (lwpid_t)(-1))
258 if (ulwp->ul_dead && ulwp->ul_detached &&
259 _lwp_kill(ulwp->ul_lwpid, 0) == ESRCH) {
260 ulwp->ul_lwpid = (lwpid_t)(-1);
276 ulwp_t *ulwp;
280 while (udp->nfreestack > cache_limit && (ulwp = *ulwpp) != NULL) {
281 if (dead_and_buried(ulwp)) {
282 *ulwpp = ulwp->ul_next;
283 if (ulwp == udp->lwp_laststack)
285 hash_out(ulwp, udp);
287 (void) munmap(ulwp->ul_stk, ulwp->ul_mapsiz);
289 * Now put the free ulwp on the ulwp freelist.
291 ulwp->ul_mapsiz = 0;
292 ulwp->ul_next = NULL;
294 udp->ulwp_freelist = udp->ulwp_lastfree = ulwp;
296 udp->ulwp_lastfree->ul_next = ulwp;
297 udp->ulwp_lastfree = ulwp;
300 prev = ulwp;
301 ulwpp = &ulwp->ul_next;
321 ulwp_t *ulwp;
359 (ulwp = *ulwpp) != NULL;
360 prev = ulwp, ulwpp = &ulwp->ul_next) {
361 if (ulwp->ul_mapsiz == mapsize &&
362 ulwp->ul_guardsize == guardsize &&
363 dead_and_buried(ulwp)) {
366 * Remove the ulwp from the stack list.
368 *ulwpp = ulwp->ul_next;
369 ulwp->ul_next = NULL;
370 if (ulwp == udp->lwp_laststack)
372 hash_out(ulwp, udp);
375 ulwp_clean(ulwp);
376 return (ulwp);
397 * We have allocated our stack. Now allocate the ulwp.
399 ulwp = ulwp_alloc();
400 if (ulwp == NULL)
403 ulwp->ul_stk = stk;
404 ulwp->ul_mapsiz = mapsize;
405 ulwp->ul_guardsize = guardsize;
406 ulwp->ul_stktop = (uintptr_t)stk + mapsize;
407 ulwp->ul_stksiz = stksize;
412 return (ulwp);
426 ulwp_t *ulwp;
432 (ulwp = *ulwpp) != NULL;
433 prev = ulwp, ulwpp = &ulwp->ul_next) {
434 if (dead_and_buried(ulwp)) {
435 *ulwpp = ulwp->ul_next;
436 ulwp->ul_next = NULL;
437 if (ulwp == udp->ulwp_lastfree)
439 hash_out(ulwp, udp);
441 ulwp_clean(ulwp);
442 return (ulwp);
448 data = lmalloc(sizeof (*ulwp) + tls_size);
451 ulwp = (ulwp_t *)(data + tls_size);
453 return (ulwp);
457 * Free a ulwp structure.
460 * Else put it on the ulwp free list and never call lfree() on it.
463 ulwp_free(ulwp_t *ulwp)
468 ulwp->ul_next = NULL;
469 if (ulwp == udp->ulwp_one) /* don't reuse the primoridal stack */
471 else if (ulwp->ul_mapsiz != 0) {
473 udp->lwp_stacks = udp->lwp_laststack = ulwp;
475 udp->lwp_laststack->ul_next = ulwp;
476 udp->lwp_laststack = ulwp;
482 udp->ulwp_freelist = udp->ulwp_lastfree = ulwp;
484 udp->ulwp_lastfree->ul_next = ulwp;
485 udp->ulwp_lastfree = ulwp;
500 ulwp_t *ulwp;
508 (ulwp = *ulwpp) != NULL;
509 ulwpp = &ulwp->ul_hash) {
510 if (ulwp->ul_lwpid == tid)
521 ulwp_broadcast(ulwp_t *ulwp)
526 ASSERT(MUTEX_OWNED(ulwp_mutex(ulwp, udp), self));
527 (void) cond_broadcast(ulwp_condvar(ulwp, udp));
539 ulwp_t *ulwp = NULL;
543 ulwp = self;
544 ulwp_lock(ulwp, udp);
546 ulwp = *ulwpp;
549 if (ulwp && ulwp->ul_dead) {
550 ulwp_unlock(ulwp, udp);
551 ulwp = NULL;
554 return (ulwp);
567 ulwp_t *ulwp;
584 if ((ulwp = find_stack(stksize, guardsize)) == NULL)
586 stksize = ulwp->ul_mapsiz - ulwp->ul_guardsize;
589 if ((ulwp = ulwp_alloc()) == NULL)
591 ulwp->ul_stk = stk;
592 ulwp->ul_stktop = (uintptr_t)stk + stksize;
593 ulwp->ul_stksiz = stksize;
595 /* ulwp is not in the hash table; make sure hash_out() doesn't fail */
596 ulwp->ul_ix = -1;
597 ulwp->ul_errnop = &ulwp->ul_errno;
611 ulwp->ul_queue_fifo = self->ul_queue_fifo;
612 ulwp->ul_cond_wait_defer = self->ul_cond_wait_defer;
613 ulwp->ul_error_detection = self->ul_error_detection;
614 ulwp->ul_async_safe = self->ul_async_safe;
615 ulwp->ul_max_spinners = self->ul_max_spinners;
616 ulwp->ul_adaptive_spin = self->ul_adaptive_spin;
617 ulwp->ul_queue_spin = self->ul_queue_spin;
618 ulwp->ul_door_noreserve = self->ul_door_noreserve;
619 ulwp->ul_misaligned = self->ul_misaligned;
622 ulwp->ul_policy = self->ul_policy;
623 ulwp->ul_pri = (self->ul_epri? self->ul_epri : self->ul_pri);
624 ulwp->ul_cid = self->ul_cid;
625 ulwp->ul_rtclassid = self->ul_rtclassid;
627 ulwp->ul_primarymap = self->ul_primarymap;
628 ulwp->ul_self = ulwp;
629 ulwp->ul_uberdata = udp;
632 ulwp->ul_usropts = flags;
641 ulwp->ul_dsave = 0x9de04000; /* save %g1, %g0, %sp */
642 ulwp->ul_drestore = 0x81e80000; /* restore %g0, %g0, %g0 */
643 ulwp->ul_dftret = 0x91d0203a; /* ta 0x3a */
644 ulwp->ul_dreturn = 0x81ca0000; /* return %o0 */
647 ulwp->ul_startpc = func;
648 ulwp->ul_startarg = arg;
649 _fpinherit(ulwp);
655 ulwp->ul_sigdefer = 1;
657 error = setup_context(&uc, _thrp_setup, ulwp,
658 (caddr_t)ulwp->ul_stk + ulwp->ul_guardsize, stksize);
669 uc.uc_sigmask = ulwp->ul_sigmask = self->ul_sigmask;
673 ulwp->ul_lwpid = (lwpid_t)(-1);
674 ulwp->ul_dead = 1;
675 ulwp->ul_detached = 1;
677 ulwp_free(ulwp);
686 ulwp->ul_detached = 1;
687 ulwp->ul_lwpid = tid;
688 ulwp->ul_stop = TSTP_REGULAR;
690 ulwp->ul_created = 1;
693 ulwp->ul_forw = udp->all_lwps;
694 ulwp->ul_back = udp->all_lwps->ul_back;
695 ulwp->ul_back->ul_forw = ulwp;
696 ulwp->ul_forw->ul_back = ulwp;
697 hash_in(ulwp, udp);
842 * replacement, ulwp structure. Fetching the replacement
844 * original ulwp structure will not be reallocated until
891 ulwp_t *ulwp;
895 if ((ulwp = udp->all_lwps) != NULL) {
897 record_spin_locks(ulwp);
898 } while ((ulwp = ulwp->ul_forw) != udp->all_lwps);
987 ulwp_t *ulwp;
1015 * Remove ulwp from the hash table.
1017 ulwp = *ulwpp;
1018 *ulwpp = ulwp->ul_hash;
1019 ulwp->ul_hash = NULL;
1021 * Remove ulwp from all_zombies list.
1024 if (udp->all_zombies == ulwp)
1025 udp->all_zombies = ulwp->ul_forw;
1026 if (udp->all_zombies == ulwp)
1029 ulwp->ul_forw->ul_back = ulwp->ul_back;
1030 ulwp->ul_back->ul_forw = ulwp->ul_forw;
1032 ulwp->ul_forw = ulwp->ul_back = NULL;
1034 ASSERT(ulwp->ul_dead && !ulwp->ul_detached &&
1035 !(ulwp->ul_usropts & (THR_DETACHED|THR_DAEMON)));
1037 * We can't call ulwp_unlock(ulwp) after we set
1038 * ulwp->ul_ix = -1 so we have to get a pointer to the
1039 * ulwp's hash table mutex now in order to unlock it below.
1041 mp = ulwp_mutex(ulwp, udp);
1042 ulwp->ul_lwpid = (lwpid_t)(-1);
1043 ulwp->ul_ix = -1;
1044 rval = ulwp->ul_rval;
1045 replace = ulwp->ul_replace;
1048 ulwp->ul_next = NULL;
1051 udp->ulwp_replace_last = ulwp;
1053 udp->ulwp_replace_last->ul_next = ulwp;
1054 udp->ulwp_replace_last = ulwp;
1091 ulwp_t *ulwp;
1097 ulwp = *ulwpp;
1099 if (ulwp->ul_dead) {
1100 ulwp_unlock(ulwp, udp);
1104 ulwp->ul_detached = 1;
1105 ulwp->ul_usropts |= THR_DETACHED;
1106 ulwp_unlock(ulwp, udp);
1593 mark_dead_and_buried(ulwp_t *ulwp)
1595 ulwp->ul_dead = 1;
1596 ulwp->ul_lwpid = (lwpid_t)(-1);
1597 ulwp->ul_hash = NULL;
1598 ulwp->ul_ix = -1;
1599 ulwp->ul_schedctl = NULL;
1600 ulwp->ul_schedctl_called = NULL;
1614 ulwp_t *ulwp;
1675 for (ulwp = udp->lwp_stacks; ulwp != NULL; ulwp = ulwp->ul_next)
1676 mark_dead_and_buried(ulwp);
1677 for (ulwp = udp->ulwp_freelist; ulwp != NULL; ulwp = ulwp->ul_next)
1678 mark_dead_and_buried(ulwp);
1679 for (ulwp = self->ul_forw; ulwp != self; ulwp = next) {
1680 next = ulwp->ul_forw;
1681 ulwp->ul_forw = ulwp->ul_back = NULL;
1682 mark_dead_and_buried(ulwp);
1683 tsd_free(ulwp);
1684 tls_free(ulwp);
1685 rwl_free(ulwp);
1686 heldlock_free(ulwp);
1687 ulwp_free(ulwp);
1692 if ((ulwp = udp->all_zombies) != NULL) {
1695 next = ulwp->ul_forw;
1696 ulwp->ul_forw = ulwp->ul_back = NULL;
1697 mark_dead_and_buried(ulwp);
1699 if (ulwp->ul_replace) {
1700 ulwp->ul_next = NULL;
1703 udp->ulwp_replace_last = ulwp;
1705 udp->ulwp_replace_last->ul_next = ulwp;
1706 udp->ulwp_replace_last = ulwp;
1709 } while ((ulwp = next) != udp->all_zombies);
1746 _thrp_stksegment(ulwp_t *ulwp, stack_t *stk)
1748 stk->ss_sp = (void *)ulwp->ul_stktop;
1749 stk->ss_size = ulwp->ul_stksiz;
1762 force_continue(ulwp_t *ulwp)
1772 ASSERT(MUTEX_OWNED(ulwp_mutex(ulwp, udp), self));
1775 error = _lwp_continue(ulwp->ul_lwpid);
1779 if (ulwp->ul_stopping) { /* he is stopping himself */
1784 if (!ulwp->ul_stopping) /* he is running now */
1803 safe_suspend(ulwp_t *ulwp, uchar_t whystopped, int *link_dropped)
1807 cond_t *cvp = ulwp_condvar(ulwp, udp);
1808 mutex_t *mp = ulwp_mutex(ulwp, udp);
1809 thread_t tid = ulwp->ul_lwpid;
1810 int ix = ulwp->ul_ix;
1816 ASSERT(ulwp != self);
1817 ASSERT(!ulwp->ul_stop);
1828 spin_lock_set(&ulwp->ul_spinlock);
1830 spin_lock_clear(&ulwp->ul_spinlock);
1833 if ((ulwp->ul_critical == 0 && ulwp->ul_rtld == 0) ||
1834 ulwp->ul_stopping) {
1836 ulwp->ul_stop |= whystopped;
1845 ulwp->ul_pleasestop |= whystopped;
1846 force_continue(ulwp);
1856 * cannot rely on the ulwp pointer after dropping the lock.
1862 while (ulwp && !ulwp->ul_dead && !ulwp->ul_stop &&
1863 (ulwp->ul_pleasestop & whystopped)) {
1865 for (ulwp = udp->thr_hash_table[ix].hash_bucket;
1866 ulwp != NULL; ulwp = ulwp->ul_hash) {
1867 if (ulwp->ul_lwpid == tid)
1872 if (ulwp == NULL || ulwp->ul_dead)
1885 ASSERT(ulwp->ul_lwpid == tid);
1886 spin_lock_set(&ulwp->ul_spinlock);
1888 spin_lock_clear(&ulwp->ul_spinlock);
1893 if (!ulwp->ul_stopping || !(ulwp->ul_stop & whystopped))
1908 ulwp_t *ulwp;
1922 if ((ulwp = find_lwp(tid)) == NULL)
1924 else if (whystopped == TSTP_MUTATOR && !ulwp->ul_mutator) {
1925 ulwp_unlock(ulwp, udp);
1927 } else if (ulwp->ul_stop) { /* already stopped */
1928 ulwp->ul_stop |= whystopped;
1929 ulwp_broadcast(ulwp);
1930 ulwp_unlock(ulwp, udp);
1931 } else if (ulwp != self) {
1936 * ulwp_broadcast(ulwp) and drops the ulwp lock.
1938 error = safe_suspend(ulwp, whystopped, NULL);
2024 ulwp_t *ulwp;
2031 for (ulwp = self->ul_forw; ulwp != self; ulwp = ulwp->ul_forw) {
2032 ulwp_lock(ulwp, udp);
2033 if (ulwp->ul_stop) { /* already stopped */
2034 ulwp->ul_stop |= TSTP_FORK;
2035 ulwp_broadcast(ulwp);
2036 ulwp_unlock(ulwp, udp);
2041 if (safe_suspend(ulwp, TSTP_FORK, &link_dropped) ||
2055 ulwp_t *ulwp;
2063 for (ulwp = self->ul_forw; ulwp != self; ulwp = ulwp->ul_forw) {
2064 ulwp->ul_schedctl_called =
2065 ulwp->ul_dead? &udp->uberflags : NULL;
2066 ulwp->ul_schedctl = NULL;
2074 for (ulwp = self->ul_forw; ulwp != self; ulwp = ulwp->ul_forw) {
2075 mutex_t *mp = ulwp_mutex(ulwp, udp);
2077 ASSERT(ulwp->ul_stop & TSTP_FORK);
2078 ulwp->ul_stop &= ~TSTP_FORK;
2079 ulwp_broadcast(ulwp);
2080 if (!ulwp->ul_stop)
2081 force_continue(ulwp);
2091 ulwp_t *ulwp;
2103 if ((ulwp = find_lwp(tid)) == NULL) {
2108 mp = ulwp_mutex(ulwp, udp);
2109 if ((whystopped == TSTP_MUTATOR && !ulwp->ul_mutator)) {
2111 } else if (ulwp->ul_stop & whystopped) {
2112 ulwp->ul_stop &= ~whystopped;
2113 ulwp_broadcast(ulwp);
2114 if (!ulwp->ul_stop) {
2115 if (whystopped == TSTP_REGULAR && ulwp->ul_created) {
2116 ulwp->ul_sp = 0;
2117 ulwp->ul_created = 0;
2119 force_continue(ulwp);
2383 ulwp_t *ulwp;
2388 ulwp = self;
2389 ulwp_lock(ulwp, udp);
2391 ulwp = *ulwpp;
2398 if (ulwp->ul_dead) {
2400 } else if (!ulwp->ul_stop && !suspendedallmutators) {
2403 } else if (ulwp->ul_stop) {
2405 getgregs(ulwp, rs);
2413 (void) _thrp_stksegment(ulwp, ss);
2415 ulwp_unlock(ulwp, udp);
2428 ulwp_t *ulwp;
2431 if ((ulwp = find_lwp(tid)) == NULL)
2434 if (!ulwp->ul_stop && !suspendedallmutators)
2440 if (ulwp->ul_stop)
2441 setgregs(ulwp, rs);
2452 ulwp_unlock(ulwp, udp);
2561 ulwp_t *ulwp;
2564 if ((ulwp = find_lwp(tid)) == NULL)
2567 if (ulwp->ul_stop && (result = ulwp->ul_sp) != 0) {
2568 ulwp_unlock(ulwp, udp);
2573 ulwp_unlock(ulwp, udp);
2599 ulwp_t *ulwp;
2606 ulwp = self;
2607 ulwp_lock(ulwp, udp);
2608 } else if ((ulwp = find_lwp(tid)) == NULL) {
2617 if (ulwp != self && !ulwp->ul_stop && enabled)
2619 else if (ulwp->ul_mutator != enabled) {
2622 ulwp_unlock(ulwp, udp);
2631 ulwp->ul_mutator = enabled;
2635 ulwp_unlock(ulwp, udp);
2682 ulwp_t *ulwp;
2700 for (ulwp = self->ul_forw; ulwp != self; ulwp = ulwp->ul_forw) {
2701 ulwp_lock(ulwp, udp);
2702 if (!ulwp->ul_mutator) {
2703 ulwp_unlock(ulwp, udp);
2704 } else if (ulwp->ul_stop) { /* already stopped */
2705 ulwp->ul_stop |= TSTP_MUTATOR;
2706 ulwp_broadcast(ulwp);
2707 ulwp_unlock(ulwp, udp);
2712 if (safe_suspend(ulwp, TSTP_MUTATOR, &link_dropped) ||
2753 ulwp_t *ulwp;
2768 for (ulwp = self->ul_forw; ulwp != self; ulwp = ulwp->ul_forw) {
2769 mutex_t *mp = ulwp_mutex(ulwp, udp);
2771 if (ulwp->ul_stop & TSTP_MUTATOR) {
2772 ulwp->ul_stop &= ~TSTP_MUTATOR;
2773 ulwp_broadcast(ulwp);
2774 if (!ulwp->ul_stop)
2775 force_continue(ulwp);
2800 ulwp_t *ulwp;
2806 if ((ulwp = find_lwp(tid)) == NULL) {
2811 if (!ulwp->ul_mutator)
2814 if (!(ulwp->ul_stop & TSTP_MUTATOR))
2816 } else if (!(ulwp->ul_stop & TSTP_MUTATOR)) {
2817 cond_t *cvp = ulwp_condvar(ulwp, udp);
2818 mutex_t *mp = ulwp_mutex(ulwp, udp);
2825 ulwp_unlock(ulwp, udp);
2848 _resume(ulwp_t *ulwp, caddr_t sp, int dontsave)