******************************************************/
-int fosa_mutex_init(frsh_mutex_t *mutex, int prioceiling)
+int fosa_mutex_init(fosa_mutex_t *mutex, int prioceiling)
{
- pthread_mutexattr_t mutex_attr;
+ //pthread_mutexattr_t mutex_attr;
/* prioceiling serves as a flag */
- if (prioceiling) {
- /* We use priority inheritance as the default protocol */
- pthread_mutexattr_init(&mutex_attr);
+ /* if (prioceiling) {
+ pthread_mutexattr_init(&mutex_attr);
pthread_mutexattr_setprotocol(&mutex_attr, PTHREAD_PRIO_INHERIT);
return pthread_mutex_init(mutex, &mutex_attr);
- } else
+ } else */
return pthread_mutex_init(mutex, NULL);
}
-int fosa_mutex_destroy(frsh_mutex_t *mutex)
+int fosa_mutex_destroy(fosa_mutex_t *mutex)
{
return pthread_mutex_destroy(mutex);
}
-int fosa_mutex_set_prioceiling(frsh_mutex_t *mutex,
+int fosa_mutex_set_prioceiling(fosa_mutex_t *mutex,
int new_ceiling,
int *old_ceiling)
{
return -1;
}
-int fosa_mutex_get_prioceiling(const frsh_mutex_t *mutex, int *ceiling)
+int fosa_mutex_get_prioceiling(const fosa_mutex_t *mutex, int *ceiling)
{
return -1;
}
-int fosa_mutex_lock(frsh_mutex_t *mutex)
+int fosa_mutex_lock(fosa_mutex_t *mutex)
{
return pthread_mutex_lock(mutex);
}
-int fosa_mutex_trylock(frsh_mutex_t *mutex)
+int fosa_mutex_trylock(fosa_mutex_t *mutex)
{
return pthread_mutex_trylock(mutex);
}
-int fosa_mutex_unlock(frsh_mutex_t *mutex)
+int fosa_mutex_unlock(fosa_mutex_t *mutex)
{
return pthread_mutex_unlock(mutex);
}
return pthread_cond_broadcast(cond);
}
-int fosa_cond_wait(fosa_cond_t *cond, frsh_mutex_t *mutex)
+int fosa_cond_wait(fosa_cond_t *cond, fosa_mutex_t *mutex)
{
return pthread_cond_wait(cond, mutex);
}
int fosa_cond_timedwait(fosa_cond_t *cond,
- frsh_mutex_t *mutex,
+ fosa_mutex_t *mutex,
const struct timespec *abstime)
{
return pthread_cond_timedwait(cond, mutex, abstime);
* Thread identification
*************************/
-bool fosa_thread_equal(frsh_thread_id_t t1, frsh_thread_id_t t2)
+bool fosa_thread_equal(fosa_thread_id_t t1, fosa_thread_id_t t2)
{
if ( pthread_equal(t1.pthread_id, t2.pthread_id &&
t1.linux_pid == t2.linux_pid &&
return false;
}
-frsh_thread_id_t fosa_thread_self()
+fosa_thread_id_t fosa_thread_self()
{
- frsh_thread_id_t thread_self;
+ fosa_thread_id_t thread_self;
/*
* Fill the user pointer with appropriate data for the calling thread
* NB. Remember:
- * frsh_thread_id_t => struct {
+ * fosa_thread_id_t => struct {
* pthread_t pthread_id;
* pid_t linux_pid;
* tid_t linux_tid;
* Thread creation and termination
*************************/
-int fosa_thread_create(frsh_thread_id_t *tid,
- const frsh_thread_attr_t *attr,
- frsh_thread_code_t code,
+int fosa_thread_create(fosa_thread_id_t *tid,
+ const fosa_thread_attr_t *attr,
+ fosa_thread_code_t code,
void *arg)
{
pthread_t tmp_tid;
**************************************************/
int fosa_thread_set_specific_data(int key,
- frsh_thread_id_t tid,
+ fosa_thread_id_t tid,
const void *value)
{
//if ((key > 0) && (key < (FOSA_MAX_KEYS-1))) {
}
int fosa_thread_get_specific_data(int key,
- frsh_thread_id_t tid,
+ fosa_thread_id_t tid,
void **value)
{
//if ((key > 0) && (key < (FOSA_MAX_KEYS-1))) {
return sched_get_priority_min(0);
}
-int fosa_thread_attr_set_prio(frsh_thread_attr_t *attr, int prio)
+int fosa_thread_attr_set_prio(fosa_thread_attr_t *attr, int prio)
{
//if ((sched_get_priority_min(0)<=prio) || (prio<=sched_get_priority_min(0))) {
// attr->sched_param.sched_priority = prio;
return -1;
}
-int fosa_thread_attr_get_prio (const frsh_thread_attr_t *attr, int *prio)
+int fosa_thread_attr_get_prio (const fosa_thread_attr_t *attr, int *prio)
{
//*prio = attr->sched_param.sched_priority;
//return 0;
return -1;
}
-int fosa_thread_set_prio(frsh_thread_id_t tid, int prio)
+int fosa_thread_set_prio(fosa_thread_id_t tid, int prio)
{
//if ((sched_get_priority_min(0)<=prio) || (prio<=sched_get_priority_min(0))) {
// pthread_setschedprio(tid.pthread_id,prio);
return -1;
}
-int fosa_thread_get_prio (frsh_thread_id_t tid, int *prio)
+int fosa_thread_get_prio (fosa_thread_id_t tid, int *prio)
{
//*prio = tid.pthread_id->sched_param.sched_priority;
//return 0;
* synchronously wait. Signals carry an associated piece of
* information (an integer or a pointer) and are queued until they are
* accepted. Signals are identified by an integer signal number (of
- * the type frsh_signal_t) in the range FOSA_SIGNAL_MIN,
+ * the type fosa_signal_t) in the range FOSA_SIGNAL_MIN,
* FOSA_SIGNAL_MAX. This range is required to have at least <tbd>
* values.
*******************************************************************/
* We need to change the API if we want such a feature!!*/
sigset_t original_mask;
-int fosa_set_accepted_signals(frsh_signal_t set[], int size)
+int fosa_set_accepted_signals(fosa_signal_t set[], int size)
{
int x;
sigset_t new_mask;
return pthread_sigmask(SIG_SETMASK, &new_mask, &original_mask);
}
-int fosa_signal_queue(frsh_signal_t signal,
- frsh_signal_info_t info,
- frsh_thread_id_t receiver)
+int fosa_signal_queue(fosa_signal_t signal,
+ fosa_signal_info_t info,
+ fosa_thread_id_t receiver)
{
union sigval siginfo;
return sigqueue(receiver.linux_pid, signal, siginfo);
}
-int fosa_signal_wait (frsh_signal_t set[],
+int fosa_signal_wait (fosa_signal_t set[],
int size,
- frsh_signal_t *signal_received,
- frsh_signal_info_t *info)
+ fosa_signal_t *signal_received,
+ fosa_signal_info_t *info)
{
int x;
sigset_t wait_mask;
return 0;
}
-int fosa_signal_timedwait(frsh_signal_t set[],
+int fosa_signal_timedwait(fosa_signal_t set[],
int size,
- frsh_signal_t *signal_received,
- frsh_signal_info_t *info,
+ fosa_signal_t *signal_received,
+ fosa_signal_info_t *info,
const struct timespec *timeout)
{
int x;