7iwind/threadx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Release 6.1.7

Browse Source
This commit is contained in:
Bo Chen
2021-06-02 06:45:05 +00:00
parent d759e6bb9e
commit f5056f4923
1269 changed files with 57325 additions and 55178 deletions
Download Patch File Download Diff File Expand all files Collapse all files

194
utility/rtos_compatibility_layers/posix/px_sig_wait.c Normal file
View File

@@ -0,0 +1,194 @@
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** POSIX wrapper for THREADX */
/** */
/**************************************************************************/
/**************************************************************************/
/* Include necessary system files. */
#include "tx_api.h" /* Threadx API */
#include "pthread.h" /* Posix API */
#include "px_int.h" /* Posix helper functions */
#include "tx_thread.h" /* Internal ThreadX thread management. */
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* sigwait PORTABLE C */
/* 6.x */
/* AUTHOR */
/* */
/* William E. Lamie, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function selects a pending signal from set, atomically */
/* clears it from the system's set of pending signals, and returns the */
/* signal number in the location referenced by sig. */
/* */
/* INPUT */
/* */
/* set Pointer to set of signals */
/* sig Pointer to returned signal number */
/* */
/* OUTPUT */
/* */
/* OK If successful */
/* EINVAL If error occurs */
/* */
/* CALLS */
/* */
/* tx_thread_identify */
/* posix_internal_error */
/* pthread_sigmask */
/* tx_event_flags_get */
/* TX_LOWEST_SET_BIT_CALCULATE */
/* */
/* CALLED BY */
/* */
/* Application Code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* xx-xx-xxxx William E. Lamie Initial Version 6.x */
/* */
/**************************************************************************/
int sigwait(const sigset_t *set, int *sig)
{
UINT status;
ULONG signal_bit_map;
ULONG signal_number;
ULONG saved_mask;
ULONG changed_mask;
ULONG pending_signals;
sigset_t original_set;
POSIX_TCB *base_thread;
/* Pickup base thread, since the base thread and all signal threads will pend off the same
event flag group. */
base_thread = (POSIX_TCB *) tx_thread_identify();
/* Is it non-NULL? */
if (!base_thread)
{
/* System error! */
posix_internal_error(444);
return(EINVAL);
}
/* Determine if the current thread is a signal handler thread. */
if (base_thread -> signals.signal_handler)
{
/* Pickup target thread. */
base_thread = base_thread -> signals.base_thread_ptr;
}
/* Initialize the saved and changed mask values to zero. */
saved_mask = 0;
changed_mask = 0;
/* Determine if there are any pending signals that are pertinent to this request. */
pending_signals = base_thread -> signals.signal_mask.signal_set & base_thread -> signals.signal_pending.signal_set & set -> signal_set;
/* Are there any. */
if (pending_signals)
{
/* Yes, there are signals being masked currently that would satisfy this request. */
/* Save the current mask. */
saved_mask = base_thread -> signals.signal_mask.signal_set;
/* Calculate the changed mask. */
changed_mask = saved_mask & ~(set -> signal_set);
/* Call pthread_sigmask to temporarily unblock these signals which will release them as well. */
pthread_sigmask(SIG_UNBLOCK, set, &original_set);
/* Now determine if the changed mask is still in effect, i.e., there wasn't a pthread_sigmask call from any subsequent signal handlers. */
if (base_thread -> signals.signal_mask.signal_set == changed_mask)
{
/* Yes, restore the previous signal mask. */
base_thread -> signals.signal_mask.signal_set = saved_mask;
}
/* Derived the signal number from the bit map. */
TX_LOWEST_SET_BIT_CALCULATE(pending_signals, signal_number);
/* Return the signal number. */
*sig = (int) signal_number;
/* Return success! */
return(OK);
}
/* Determine if there are any signals that have to be temporarily cleared. */
if (base_thread -> signals.signal_mask.signal_set & set -> signal_set)
{
/* Yes, there are signals being masked needed to satisfy this request. */
/* Save the current mask. */
saved_mask = base_thread -> signals.signal_mask.signal_set;
/* Calculate the changed mask. */
changed_mask = saved_mask & ~(set -> signal_set);
/* Apply the changed signal mask. */
base_thread -> signals.signal_mask.signal_set = changed_mask;
}
/* Suspend on the signal specified by the input. */
status = tx_event_flags_get(&(base_thread -> signals.signal_event_flags), (ULONG) set -> signal_set, TX_OR_CLEAR, &signal_bit_map, TX_WAIT_FOREVER);
/* Determine if we need to restore the signal mask. */
if ((saved_mask) && (changed_mask == base_thread -> signals.signal_mask.signal_set))
{
/* Yes, the signal mask should be restored. */
base_thread -> signals.signal_mask.signal_set = saved_mask;
}
/* Check for successful status. */
if (status == TX_SUCCESS)
{
/* Derived the signal number from the bit map. */
TX_LOWEST_SET_BIT_CALCULATE(signal_bit_map, signal_number);
/* Return the signal number. */
*sig = (int) signal_number;
/* Return success! */
return(OK);
}
else
{
/* Return error! */
return(EINVAL);
}
}