Lines Matching refs:thread
33 #include <thread.h>
754 /*! Updates the given thread's Thread::flags field according to what signals are
759 update_thread_signals_flag(Thread* thread)
761 sigset_t mask = ~thread->sig_block_mask;
762 if ((thread->AllPendingSignals() & mask) != 0)
763 atomic_or(&thread->flags, THREAD_FLAGS_SIGNALS_PENDING);
765 atomic_and(&thread->flags, ~THREAD_FLAGS_SIGNALS_PENDING);
769 /*! Updates the current thread's Thread::flags field according to what signals
787 for (Thread* thread = team->thread_list; thread != NULL;
788 thread = thread->team_next) {
789 update_thread_signals_flag(thread);
798 \param thread The current thread.
806 notify_debugger(Thread* thread, Signal* signal, struct sigaction& handler,
811 // first check the ignore signal masks the debugger specified for the thread
812 InterruptsSpinLocker threadDebugInfoLocker(thread->debug_info.lock);
814 if ((thread->debug_info.ignore_signals_once & signalMask) != 0) {
815 thread->debug_info.ignore_signals_once &= ~signalMask;
819 if ((thread->debug_info.ignore_signals & signalMask) != 0)
841 is pending in the given thread or its team.
846 \param thread The thread.
854 dequeue_thread_or_team_signal(Thread* thread, sigset_t nonBlocked,
857 Team* team = thread->team;
860 > thread->HighestPendingSignalPriority(nonBlocked)) {
864 signal = thread->DequeuePendingSignal(nonBlocked, buffer);
865 update_thread_signals_flag(thread);
873 setup_signal_frame(Thread* thread, struct sigaction* action, Signal* signal,
891 frameData.context.uc_link = thread->user_signal_context;
903 // thread flags -- save the and clear the thread's syscall restart related
905 frameData.thread_flags = atomic_and(&thread->flags,
910 thread->syscall_restart.parameters,
914 frameData.commpage_address = thread->team->commpage_address;
919 return arch_setup_signal_frame(thread, action, &frameData);
923 /*! Actually handles pending signals -- i.e. the thread will exit, a custom
926 function will suspend the thread indefinitely, when a stop signal is
929 \param thread The current thread.
932 handle_signals(Thread* thread)
934 Team* team = thread->team;
937 InterruptsSpinLocker locker(thread->team->signal_lock);
941 sigset_t nonBlockedMask = ~thread->sig_block_mask;
942 sigset_t signalMask = thread->AllPendingSignals() & nonBlockedMask;
945 if (thread->user_thread->defer_signals > 0
947 && thread->sigsuspend_original_unblocked_mask == 0) {
948 thread->user_thread->pending_signals = signalMask;
953 thread->user_thread->pending_signals = 0;
957 uint32 restartFlags = atomic_and(&thread->flags,
973 signalMask = thread->AllPendingSignals() & nonBlockedMask;
976 // Unless SIGKILL[THR] are pending, check, if the thread shall stop for
979 if ((atomic_get(&thread->flags) & THREAD_FLAGS_TRAP_FOR_CORE_DUMP)
988 if ((atomic_get(&thread->debug_info.flags) & B_THREAD_DEBUG_STOP)
1002 // get pending non-blocked thread or team signal with the highest
1005 Signal* signal = dequeue_thread_or_team_signal(thread, nonBlockedMask,
1037 TRACE(("Thread %" B_PRId32 " received signal %s\n", thread->id,
1046 notify_debugger(thread, signal, handler, false);
1056 notify_debugger(thread, signal, handler, false);
1067 notify_debugger(thread, signal, handler, false);
1077 handler.sa_handler = thread->cancel_function;
1089 atomic_and(&thread->flags, ~THREAD_FLAGS_RESTART_SYSCALL);
1095 && !notify_debugger(thread, signal, handler, false))
1099 if (thread == team->main_thread) {
1120 && !notify_debugger(thread, signal, handler, false))
1134 if (thread == team->main_thread) {
1159 // Suspend the thread, unless there's already a signal to
1162 bool resume = (thread->AllPendingSignals()
1188 B_PRIu32 " received in thread %" B_PRIu32 " \n",
1189 team->id, signal->Number(), thread->id));
1191 // This signal kills the team regardless which thread
1200 && !notify_debugger(thread, signal, handler, true)) {
1204 if (killTeam || thread == team->main_thread) {
1205 // The signal is terminal for the team or the thread is
1206 // the main thread. In either case the team is going
1220 // If this is not the main thread, send it a SIGKILLTHR
1222 if (thread != team->main_thread) {
1241 if (debugSignal && !notify_debugger(thread, signal, handler, false))
1246 atomic_and(&thread->flags, ~THREAD_FLAGS_RESTART_SYSCALL);
1256 sigset_t oldBlockMask = thread->sigsuspend_original_unblocked_mask != 0
1257 ? ~thread->sigsuspend_original_unblocked_mask
1258 : thread->sig_block_mask;
1262 thread->sig_block_mask |= handler.sa_mask & BLOCKABLE_SIGNALS;
1265 thread->sig_block_mask
1273 setup_signal_frame(thread, &handler, signal, oldBlockMask);
1277 // accordingly so that after the handler returns the thread's signal
1279 thread->sigsuspend_original_unblocked_mask = 0;
1289 if (thread->sigsuspend_original_unblocked_mask != 0) {
1291 atomic_or(&thread->flags, THREAD_FLAGS_RESTART_SYSCALL);
1293 // clear syscall restart thread flag, if we're not supposed to restart
1295 atomic_and(&thread->flags, ~THREAD_FLAGS_RESTART_SYSCALL);
1309 for (Thread* thread = team->thread_list; thread != NULL;
1310 thread = thread->team_next) {
1311 if ((thread->sig_block_mask & mask) == 0)
1319 /*! Gets (guesses) the current thread's currently used stack from the given
1321 Fills in \a stack with either the signal stack or the thread's user stack.
1330 // return the signal stack. In all other cases return the thread's user
1332 Thread* thread = thread_get_current_thread();
1333 if (thread->signal_stack_enabled && address >= thread->signal_stack_base
1334 && address < thread->signal_stack_base + thread->signal_stack_size) {
1335 stack->ss_sp = (void*)thread->signal_stack_base;
1336 stack->ss_size = thread->signal_stack_size;
1338 stack->ss_sp = (void*)thread->user_stack_base;
1339 stack->ss_size = thread->user_stack_size;
1346 /*! Checks whether any non-blocked signal is pending for the current thread.
1348 \param thread The current thread.
1351 has_signals_pending(Thread* thread)
1353 return (thread->AllPendingSignals() & ~thread->sig_block_mask) != 0;
1374 /*! Delivers a signal to the \a thread, but doesn't handle the signal -- it just
1375 makes sure the thread gets the signal, i.e. unblocks it if needed.
1379 \param thread The thread the signal shall be delivered to.
1385 thread.
1388 target thread the signal.
1393 send_signal_to_thread_locked(Thread* thread, uint32 signalNumber,
1398 T(SendSignal(thread->id, signalNumber, flags));
1404 if (!has_permission_to_signal(thread->team))
1411 if (thread->team == team_get_kernel_team()) {
1413 thread_continue(thread);
1418 thread->AddPendingSignal(signal);
1420 thread->AddPendingSignal(signalNumber);
1422 // the thread has the signal reference, now
1428 // If sent to a thread other than the team's main thread, also send
1429 // a SIGKILLTHR to the main thread to kill the team.
1430 Thread* mainThread = thread->team->main_thread;
1431 if (mainThread != NULL && mainThread != thread) {
1434 // wake up main thread
1435 thread->going_to_suspend = false;
1452 thread->going_to_suspend = false;
1454 SpinLocker locker(thread->scheduler_lock);
1455 if (thread->state == B_THREAD_SUSPENDED)
1456 scheduler_enqueue_in_run_queue(thread);
1458 thread_interrupt(thread, true);
1464 // Wake up thread if it was suspended, otherwise interrupt it.
1465 thread->going_to_suspend = false;
1467 SpinLocker locker(thread->scheduler_lock);
1468 if (thread->state == B_THREAD_SUSPENDED)
1469 scheduler_enqueue_in_run_queue(thread);
1471 thread_interrupt(thread, false);
1477 // wake up thread, and interrupt its current syscall
1478 thread->going_to_suspend = false;
1480 SpinLocker locker(thread->scheduler_lock);
1481 if (thread->state == B_THREAD_SUSPENDED)
1482 scheduler_enqueue_in_run_queue(thread);
1484 atomic_or(&thread->flags, THREAD_FLAGS_DONT_RESTART_SYSCALL);
1489 // Wake up thread if it was suspended, otherwise interrupt it, if
1491 thread->going_to_suspend = false;
1493 SpinLocker locker(thread->scheduler_lock);
1494 if (thread->state == B_THREAD_SUSPENDED)
1495 scheduler_enqueue_in_run_queue(thread);
1496 else if ((SIGNAL_TO_MASK(SIGCONT) & ~thread->sig_block_mask) != 0)
1497 thread_interrupt(thread, false);
1500 thread->RemovePendingSignals(STOP_SIGNALS);
1504 // If the signal is not masked, interrupt the thread, if it is
1506 if ((thread->AllPendingSignals()
1507 & (~thread->sig_block_mask | SIGNAL_TO_MASK(SIGCHLD)))
1509 // Interrupt thread if it was waiting
1510 SpinLocker locker(thread->scheduler_lock);
1511 thread_interrupt(thread, false);
1516 update_thread_signals_flag(thread);
1522 /*! Sends the given signal to the given thread.
1524 \param thread The thread the signal shall be sent to.
1530 target thread the signal.
1531 - \c B_DO_NOT_RESCHEDULE: If clear and a higher level thread has been
1534 current thread's time slice runs out.
1539 send_signal_to_thread(Thread* thread, const Signal& signal, uint32 flags)
1549 InterruptsReadSpinLocker teamLocker(thread->team_lock);
1550 SpinLocker locker(thread->team->signal_lock);
1552 error = send_signal_to_thread_locked(thread, signal.Number(), signalToQueue,
1567 /*! Sends the given signal to the thread with the given ID.
1569 \param threadID The ID of the thread the signal shall be sent to.
1575 target thread the signal.
1576 - \c B_DO_NOT_RESCHEDULE: If clear and a higher level thread has been
1579 current thread's time slice runs out.
1586 Thread* thread = Thread::Get(threadID);
1587 if (thread == NULL)
1589 BReference<Thread> threadReference(thread, true);
1591 return send_signal_to_thread(thread, signal, flags);
1605 thread.
1608 target thread the signal.
1609 - \c B_DO_NOT_RESCHEDULE: If clear and a higher level thread has been
1612 current thread's time slice runs out.
1652 // Also add a SIGKILLTHR to the main thread's signals and wake it
1654 // (only the main thread shuts down the team).
1659 // wake up main thread
1674 for (Thread* thread = team->thread_list; thread != NULL;
1675 thread = thread->team_next) {
1676 thread->going_to_suspend = false;
1678 SpinLocker _(thread->scheduler_lock);
1679 if (thread->state == B_THREAD_SUSPENDED) {
1680 scheduler_enqueue_in_run_queue(thread);
1681 } else if ((SIGNAL_TO_MASK(SIGCONT) & ~thread->sig_block_mask)
1683 thread_interrupt(thread, false);
1687 thread->RemovePendingSignals(STOP_SIGNALS);
1699 // TODO: Is that correct or should we only target the main thread?
1700 for (Thread* thread = team->thread_list; thread != NULL;
1701 thread = thread->team_next) {
1702 thread->AddPendingSignal(signalNumber);
1716 for (Thread* thread = team->thread_list; thread != NULL;
1717 thread = thread->team_next) {
1718 sigset_t nonBlocked = ~thread->sig_block_mask
1720 if ((thread->AllPendingSignals() & nonBlocked) != 0) {
1721 SpinLocker _(thread->scheduler_lock);
1722 thread_interrupt(thread, false);
1742 target thread the signal.
1743 - \c B_DO_NOT_RESCHEDULE: If clear and a higher level thread has been
1746 current thread's time slice runs out.
1783 target thread the signal.
1784 - \c B_DO_NOT_RESCHEDULE: If clear and a higher level thread has been
1787 current thread's time slice runs out.
1814 target thread the signal.
1815 - \c B_DO_NOT_RESCHEDULE: If clear and a higher level thread has been
1818 current thread's time slice runs out.
1851 The caller must not hold any process group, team, or thread lock. Interrupts
1860 target thread the signal.
1861 - \c B_DO_NOT_RESCHEDULE: If clear and a higher level thread has been
1864 current thread's time slice runs out.
1901 Thread* thread = thread_get_current_thread();
1905 B_OK, thread->team->id);
1910 // If id is > 0, send the signal to the respective thread.
1914 // If id == 0, send the signal to the current thread.
1916 return send_signal_to_thread(thread, signal, flags);
1923 return send_signal_to_team_id(thread->team->id, signal, flags);
1955 Thread* thread = thread_get_current_thread();
1957 InterruptsSpinLocker _(thread->team->signal_lock);
1959 sigset_t oldMask = thread->sig_block_mask;
1966 thread->sig_block_mask |= *set & BLOCKABLE_SIGNALS;
1969 thread->sig_block_mask &= ~*set;
1972 thread->sig_block_mask = *set & BLOCKABLE_SIGNALS;
2032 for (Thread* thread = team->thread_list; thread != NULL;
2033 thread = thread->team_next) {
2034 thread->RemovePendingSignal(signal);
2068 Thread* thread = thread_get_current_thread();
2070 InterruptsSpinLocker locker(thread->team->signal_lock);
2076 sigset_t pendingSignals = thread->AllPendingSignals();
2085 Signal* signal = dequeue_thread_or_team_signal(thread,
2108 sigset_t blockedSignals = thread->sig_block_mask;
2116 thread->sig_block_mask = blockedSignals & ~requestedSignals;
2118 while (!has_signals_pending(thread)) {
2119 thread_prepare_to_block(thread, flags, THREAD_BLOCK_TYPE_SIGNAL,
2141 thread->sig_block_mask = blockedSignals;
2161 Thread* thread = thread_get_current_thread();
2163 InterruptsSpinLocker locker(thread->team->signal_lock);
2168 sigset_t oldMask = thread->sigsuspend_original_unblocked_mask != 0
2169 ? ~thread->sigsuspend_original_unblocked_mask : thread->sig_block_mask;
2170 thread->sig_block_mask = mask & BLOCKABLE_SIGNALS;
2174 while (!has_signals_pending(thread)) {
2175 thread_prepare_to_block(thread, B_CAN_INTERRUPT,
2187 // handle anymore (e.g. because another thread was faster).
2188 thread->sigsuspend_original_unblocked_mask = ~oldMask;
2200 Thread* thread = thread_get_current_thread();
2205 InterruptsSpinLocker locker(thread->team->signal_lock);
2207 *set = thread->AllPendingSignals() & thread->sig_block_mask;
2216 /*! Sends a signal to a thread, process, or process group.
2219 thread with ID \a id, otherwise the team with the ID \a id.
2221 current thread, otherwise the current team.
2258 // If to be sent to a thread, delegate to send_signal_internal(). Also do
2267 Thread* thread = thread_get_current_thread();
2271 B_OK, thread->team->id);
2357 Thread* thread = thread_get_current_thread();
2358 atomic_or(&thread->flags, THREAD_FLAGS_ALWAYS_RESTART_SYSCALL);
2404 Thread *thread = thread_get_current_thread();
2414 if (thread->signal_stack_enabled) {
2415 // determine whether or not the user thread is currently
2417 onStack = arch_on_signal_stack(thread);
2421 oldStack.ss_sp = (void *)thread->signal_stack_base;
2422 oldStack.ss_size = thread->signal_stack_size;
2423 oldStack.ss_flags = (thread->signal_stack_enabled ? 0 : SS_DISABLE)
2441 thread->signal_stack_base = (addr_t)newStack.ss_sp;
2442 thread->signal_stack_size = newStack.ss_size;
2443 thread->signal_stack_enabled = true;
2445 thread->signal_stack_enabled = false;
2483 Thread *thread = thread_get_current_thread();
2491 // serious problem. Kill the thread.
2492 dprintf("_user_restore_signal_frame(): thread %" B_PRId32 ": Failed to "
2493 "copy signal frame data (%p) from userland. Killing thread...\n",
2494 thread->id, userSignalFrameData);
2495 kill_thread(thread->id);
2500 InterruptsSpinLocker locker(thread->team->signal_lock);
2502 thread->sig_block_mask
2508 // restore the syscall restart related thread flags and the syscall restart
2510 atomic_and(&thread->flags,
2512 atomic_or(&thread->flags, signalFrameData.thread_flags
2515 memcpy(thread->syscall_restart.parameters,
2517 sizeof(thread->syscall_restart.parameters));
2520 thread->user_signal_context = signalFrameData.context.uc_link;
2521 if (thread->user_signal_context != NULL
2522 && !IS_USER_ADDRESS(thread->user_signal_context)) {
2523 thread->user_signal_context = NULL;