/*!
* Create global message queue
*/
int sys__create_msg_queue ( void *p )
{
/* parameters on thread stack */
msg_q *msgq;
uint min_prio;
/* local variables */
kgmsg_q *gmsgq;
msgq = *( (msg_q **) p ); p += sizeof (msg_q *);
min_prio = *( (uint *) p );
ASSERT_ERRNO_AND_EXIT ( msgq, E_INVALID_HANDLE );
msgq = U2K_GET_ADR ( msgq, k_get_active_process () );
gmsgq = kmalloc ( sizeof ( kgmsg_q ) );
ASSERT_ERRNO_AND_EXIT ( gmsgq, E_NO_MEMORY );
list_init ( &gmsgq->mq.msgs ); /* list for messages */
k_threadq_init ( &gmsgq->mq.thrq ); /* list for blocked threads */
gmsgq->mq.min_prio = min_prio;
msgq->id = gmsgq->id = k_new_unique_id ();
msgq->handle = gmsgq;
list_append ( &kmsg_qs, gmsgq, &gmsgq->all ); /* all msg.q. list */
EXIT ( SUCCESS );
}
/*!
* Delete global message queue
*/
int sys__delete_msg_queue ( void *p )
{
/* parameter on thread stack */
msg_q *msgq;
/* local variables */
kgmsg_q *gmsgq;
msgq = *( (msg_q **) p );
ASSERT_ERRNO_AND_EXIT ( msgq, E_INVALID_HANDLE );
msgq = U2K_GET_ADR ( msgq, k_get_active_process () );
gmsgq = msgq->handle;
ASSERT_ERRNO_AND_EXIT ( gmsgq->id == msgq->id, E_INVALID_HANDLE );
k_msgq_clean ( &gmsgq->mq );
k_release_all_threads ( &gmsgq->mq.thrq );
k_free_unique_id ( gmsgq->id );
kfree ( gmsgq );
msgq->id = 0;
msgq->handle = NULL;
EXIT ( SUCCESS );
}
/*!
* Decrement (lock) semaphore value by 1 (if not 0 when thread is blocked)
* \param sem Semaphore descriptor (user level descriptor)
* \return 0 if successful, -1 otherwise and appropriate error number is set
*/
int sys__sem_wait ( sem_t *sem )
{
ksem_t *ksem;
kobject_t *kobj;
kthread_t *kthread;
SYS_ENTRY();
ASSERT_ERRNO_AND_EXIT ( sem, EINVAL );
kthread = kthread_get_active ();
kobj = sem->ptr;
ASSERT_ERRNO_AND_EXIT ( kobj, EINVAL );
ASSERT_ERRNO_AND_EXIT ( list_find ( &kobjects, &kobj->list ),
EINVAL );
ksem = kobj->kobject;
ASSERT_ERRNO_AND_EXIT ( ksem && ksem->id == sem->id, EINVAL );
kthread_set_errno ( kthread, EXIT_SUCCESS );
kthread_set_syscall_retval ( kthread, EXIT_SUCCESS );
if ( ksem->sem_value > 0 )
{
ksem->sem_value--;
ksem->last_lock = kthread;
}
else {
kthread_enqueue ( kthread, &ksem->queue );
kthreads_schedule ();
}
SYS_EXIT ( kthread_get_errno(NULL), kthread_get_syscall_retval(NULL) );
}
/*!
* Initialize semaphore object
* \param sem Semaphore descriptor (user level descriptor)
* \param pshared Shall semaphore object be shared between processes
* \param value Initial semaphore value
* \return 0 if successful, -1 otherwise and appropriate error number is set
*/
int sys__sem_init ( sem_t *sem, int pshared, int value )
{
ksem_t *ksem;
kobject_t *kobj;
SYS_ENTRY();
ASSERT_ERRNO_AND_EXIT ( sem, EINVAL );
kobj = kmalloc_kobject ( sizeof (ksem_t) );
ASSERT_ERRNO_AND_EXIT ( kobj, ENOMEM );
ksem = kobj->kobject;
ksem->id = k_new_id ();
ksem->sem_value = value;
ksem->last_lock = NULL;
ksem->flags = 0;
ksem->ref_cnt = 1;
kthreadq_init ( &ksem->queue );
if ( pshared )
ksem->flags |= PTHREAD_PROCESS_SHARED;
sem->ptr = kobj;
sem->id = ksem->id;
SYS_EXIT ( EXIT_SUCCESS, EXIT_SUCCESS );
}
/*!
* Lock mutex object
* \param mutex Mutex descriptor (user level descriptor)
* \return 0 if successful, -1 otherwise and appropriate error number is set
*/
int sys__pthread_mutex_lock ( pthread_mutex_t *mutex )
{
kpthread_mutex_t *kmutex;
kobject_t *kobj;
int retval = EXIT_SUCCESS;
SYS_ENTRY();
ASSERT_ERRNO_AND_EXIT ( mutex, EINVAL );
kobj = mutex->ptr;
ASSERT_ERRNO_AND_EXIT ( kobj, EINVAL );
ASSERT_ERRNO_AND_EXIT ( list_find ( &kobjects, &kobj->list ),
EINVAL );
kmutex = kobj->kobject;
ASSERT_ERRNO_AND_EXIT ( kmutex && kmutex->id == mutex->id, EINVAL );
retval = mutex_lock ( kmutex, kthread_get_active () );
if ( retval == 1 )
kthreads_schedule ();
/* errno is already set */
if ( retval != -1 )
SYS_RETURN ( EXIT_SUCCESS );
else
SYS_RETURN ( EXIT_FAILURE );
}
/*!
* Send signal to thread (from thread)
* \param pid Thread descriptor (user level descriptor)
* \param signo Signal number
* \param sigval Parameter to send with signal
* \return 0 if successful, -1 otherwise and appropriate error number is set
*/
int sys__sigqueue ( void *p )
{
pid_t pid;
int signo;
sigval_t sigval;
pthread_t thread, sender;
kthread_t *kthread;
siginfo_t sig;
pid = *( (pid_t *) p ); p += sizeof (pid_t);
signo = *( (int *) p ); p += sizeof (int);
sigval = *( (sigval_t *) p );
ASSERT_ERRNO_AND_EXIT ( signo > 0 && signo <= SIGMAX, EINVAL );
thread = (pthread_t) pid; /* pid_t should be pthread_t */
ASSERT_ERRNO_AND_EXIT ( thread.ptr, EINVAL );
kthread = thread.ptr;
ASSERT_ERRNO_AND_EXIT ( kthread_get_id (kthread) == thread.id, EINVAL );
ASSERT_ERRNO_AND_EXIT ( kthread_check_kthread ( kthread ), EINVAL );
sender.id = kthread_get_id (NULL);
sender.ptr = kthread_get_active ();
sig.si_signo = signo;
sig.si_value = sigval;
sig.si_pid = sender;
sig.si_code = SI_USER;
sig.si_errno = 0;
EXIT ( ksignal_queue ( kthread, &sig ) );
}
/*!
* Change scheduling parameters
* \param thread User level thread descriptor
* \param policy Thread scheduling policy
* \param param Additional scheduling parameters (when policy != SCHED_FIFO)
* \return 0
*/
int sys__pthread_setschedparam ( void *p )
{
pthread_t *thread;
int policy;
sched_param_t *param;
kthread_t *kthread;
thread = *( (pthread_t **) p ); p += sizeof (pthread_t *);
policy = *( (int *) p ); p += sizeof (int);
param = *( (sched_param_t **) p );
kthread = thread->ptr;
ASSERT_ERRNO_AND_EXIT ( kthread, EINVAL );
ASSERT_ERRNO_AND_EXIT ( kthread_get_id (kthread) == thread->id, ESRCH );
ASSERT_ERRNO_AND_EXIT ( kthread_is_alive (kthread), ESRCH );
ASSERT_ERRNO_AND_EXIT ( policy >= 0 && policy < SCHED_NUM, EINVAL );
if ( param )
{
ASSERT_ERRNO_AND_EXIT (
param->sched_priority >= THREAD_MIN_PRIO &&
param->sched_priority <= THREAD_MAX_PRIO, EINVAL );
}
return kthread_setschedparam ( kthread, policy, param );
}
/*!
* Block thread (on conditional variable) and release monitor
*/
int sys__monitor_wait ( monitor_t *monitor, monitor_q *queue )
{
kmonitor_t *kmonitor;
kmonitor_q *kqueue;
ASSERT_ERRNO_AND_EXIT ( monitor && monitor->ptr, E_INVALID_HANDLE );
ASSERT_ERRNO_AND_EXIT ( queue && queue->ptr, E_INVALID_HANDLE );
kmonitor = monitor->ptr;
kqueue = queue->ptr;
ASSERT_ERRNO_AND_EXIT ( kmonitor->owner == k_get_active_thread (),
E_NOT_OWNER );
disable_interrupts ();
SET_ERRNO ( SUCCESS );
k_set_thread_qdata ( NULL, kmonitor );
k_enqueue_thread ( NULL, &kqueue->queue );
kmonitor->owner = k_threadq_get ( &kmonitor->queue );
if ( !k_release_thread ( &kmonitor->queue ) )
kmonitor->lock = FALSE;
k_schedule_threads ();
enable_interrupts ();
EXIT ( SUCCESS );
}
/*! Change thread scheduling parameters ------------------------------------- */
int kthread_setschedparam (kthread_t *kthread, int policy, sched_param_t *param)
{
int sched_priority;
ASSERT_ERRNO_AND_EXIT ( kthread, EINVAL );
ASSERT_ERRNO_AND_EXIT ( kthread_is_alive (kthread), ESRCH );
ASSERT_ERRNO_AND_EXIT ( policy >= 0 && policy < SCHED_NUM, EINVAL );
if ( param )
{
ASSERT_ERRNO_AND_EXIT (
param->sched_priority >= THREAD_MIN_PRIO &&
param->sched_priority <= THREAD_MAX_PRIO, EINVAL );
if ( param->sched_priority )
sched_priority = param->sched_priority;
else
sched_priority = kthread->sched_priority;
}
else {
sched_priority = kthread->sched_priority;
}
/* change in priority? */
if ( kthread->sched_priority != sched_priority )
kthread_set_prio ( kthread, sched_priority );
return EXIT_SUCCESS;
}
/*!
* Unlock mutex object
* \param mutex Mutex descriptor (user level descriptor)
* \return 0 if successful, -1 otherwise and appropriate error number is set
*/
int sys__pthread_mutex_unlock ( void *p )
{
pthread_mutex_t *mutex;
kpthread_mutex_t *kmutex;
kobject_t *kobj;
mutex = *( (pthread_mutex_t **) p );
ASSERT_ERRNO_AND_EXIT ( mutex, EINVAL );
kobj = mutex->ptr;
ASSERT_ERRNO_AND_EXIT ( kobj, EINVAL );
ASSERT_ERRNO_AND_EXIT ( list_find ( &kobjects, &kobj->list ),
EINVAL );
kmutex = kobj->kobject;
ASSERT_ERRNO_AND_EXIT ( kmutex && kmutex->id == mutex->id, EINVAL );
if ( kmutex->owner != kthread_get_active() )
{
SET_ERRNO ( EPERM );
return EXIT_FAILURE;
}
SET_ERRNO ( EXIT_SUCCESS );
kmutex->owner = kthreadq_get ( &kmutex->queue );
if ( kmutex->owner )
{
kthreadq_release ( &kmutex->queue );
kthreads_schedule ();
}
return EXIT_SUCCESS;
}
/*!
* Change scheduling parameters
* \param thread User level thread descriptor
* \param policy Thread scheduling policy
* \param param Additional scheduling parameters (when policy != SCHED_FIFO)
* \return 0
*/
int sys__pthread_setschedparam ( pthread_t *thread, int policy,
sched_param_t *param )
{
kthread_t *kthread;
int retval;
SYS_ENTRY();
kthread = thread->ptr;
ASSERT_ERRNO_AND_EXIT ( kthread, EINVAL );
ASSERT_ERRNO_AND_EXIT ( kthread_get_id (kthread) == thread->id, ESRCH );
ASSERT_ERRNO_AND_EXIT ( kthread_is_alive (kthread), ESRCH );
ASSERT_ERRNO_AND_EXIT ( policy == SCHED_FIFO, ENOTSUP );
if ( param )
{
ASSERT_ERRNO_AND_EXIT (
param->sched_priority >= THREAD_MIN_PRIO &&
param->sched_priority <= THREAD_MAX_PRIO, EINVAL );
}
retval = kthread_setschedparam ( kthread, policy, param );
if ( retval == EXIT_SUCCESS )
SYS_EXIT ( EXIT_SUCCESS, retval );
else
SYS_EXIT ( retval, EXIT_FAILURE );
}
/*!
* Destroy semaphore object
* \param sem Semaphore descriptor (user level descriptor)
* \return 0 if successful, -1 otherwise and appropriate error number is set
*/
int sys__sem_destroy ( void *p )
{
sem_t *sem;
ksem_t *ksem;
kobject_t *kobj;
sem = *( (sem_t **) p );
ASSERT_ERRNO_AND_EXIT ( sem, EINVAL );
kobj = sem->ptr;
ASSERT_ERRNO_AND_EXIT ( kobj, EINVAL );
ASSERT_ERRNO_AND_EXIT ( list_find ( &kobjects, &kobj->list ),
EINVAL );
ksem = kobj->kobject;
ASSERT_ERRNO_AND_EXIT ( ksem && ksem->id == sem->id, EINVAL );
ASSERT_ERRNO_AND_EXIT (kthreadq_get (&ksem->queue) == NULL, ENOTEMPTY);
ksem->ref_cnt--;
/* additional cleanup here (e.g. if semaphore is shared leave it) */
if ( ksem->ref_cnt )
EXIT2 ( EBUSY, EXIT_FAILURE );
kfree_kobject ( kobj );
sem->ptr = NULL;
sem->id = 0;
EXIT2 ( EXIT_SUCCESS, EXIT_SUCCESS );
}
/*!
* Decrement (lock) semaphore value by 1 (if not 0 when thread is blocked)
* \param sem Semaphore descriptor (user level descriptor)
* \return 0 if successful, -1 otherwise and appropriate error number is set
*/
int sys__sem_wait ( void *p )
{
sem_t *sem;
ksem_t *ksem;
kobject_t *kobj;
kthread_t *kthread;
sem = *( (sem_t **) p );
ASSERT_ERRNO_AND_EXIT ( sem, EINVAL );
kthread = kthread_get_active ();
kobj = sem->ptr;
ASSERT_ERRNO_AND_EXIT ( kobj, EINVAL );
ASSERT_ERRNO_AND_EXIT ( list_find ( &kobjects, &kobj->list ),
EINVAL );
ksem = kobj->kobject;
ASSERT_ERRNO_AND_EXIT ( ksem && ksem->id == sem->id, EINVAL );
kthread_set_errno ( kthread, EXIT_SUCCESS );
if ( ksem->sem_value > 0 )
{
ksem->sem_value--;
ksem->last_lock = kthread;
}
else {
kthread_enqueue ( kthread, &ksem->queue, 1, NULL, NULL );
kthreads_schedule ();
}
return EXIT_SUCCESS;
}
/*!
* Create new timer
* \param clockid Clock used in timer
* \param evp Timer expiration action
* \param timerid Timer descriptor is returned in this variable
* \return status 0 for success
*/
int sys__timer_create ( void *p )
{
clockid_t clockid;
sigevent_t *evp;
timer_t *timerid;
ktimer_t *ktimer;
int retval = EXIT_SUCCESS;
kobject_t *kobj;
clockid = *( (clockid_t *) p ); p += sizeof (clockid_t);
evp = *( (sigevent_t **) p ); p += sizeof (sigevent_t *);
timerid = *( (timer_t **) p );
ASSERT_ERRNO_AND_EXIT (
clockid == CLOCK_REALTIME || clockid == CLOCK_MONOTONIC, EINVAL );
ASSERT_ERRNO_AND_EXIT ( evp && timerid, EINVAL );
retval = ktimer_create ( clockid, evp, &ktimer, kthread_get_active() );
if ( retval == EXIT_SUCCESS )
{
kobj = kmalloc_kobject ( 0 );
kobj->kobject = ktimer;
timerid->id = ktimer->id;
timerid->ptr = kobj;
}
EXIT ( retval );
}
/*!
* Initialize semaphore object
* \param sem Semaphore descriptor (user level descriptor)
* \param pshared Shall semaphore object be shared between processes
* \param value Initial semaphore value
* \return 0 if successful, -1 otherwise and appropriate error number is set
*/
int sys__sem_init ( void *p )
{
sem_t *sem;
int pshared;
int value;
ksem_t *ksem;
kobject_t *kobj;
sem = *( (sem_t **) p ); p += sizeof (sem_t *);
pshared = *( (int *) p ); p += sizeof (int);
value = *( (uint *) p );
ASSERT_ERRNO_AND_EXIT ( sem, EINVAL );
kobj = kmalloc_kobject ( sizeof (ksem_t) );
ASSERT_ERRNO_AND_EXIT ( kobj, ENOMEM );
ksem = kobj->kobject;
ksem->id = k_new_id ();
ksem->sem_value = value;
ksem->last_lock = NULL;
ksem->flags = 0;
ksem->ref_cnt = 1;
kthreadq_init ( &ksem->queue );
if ( pshared )
ksem->flags |= PTHREAD_PROCESS_SHARED;
sem->ptr = kobj;
sem->id = ksem->id;
EXIT2 ( EXIT_SUCCESS, EXIT_SUCCESS );
}
/*!
* Destroy conditional variable object
* \param cond conditional variable descriptor (user level descriptor)
* \return 0 if successful, -1 otherwise and appropriate error number is set
*/
int sys__pthread_cond_destroy ( void *p )
{
pthread_cond_t *cond;
kpthread_cond_t *kcond;
kobject_t *kobj;
cond = *( (pthread_cond_t **) p );
ASSERT_ERRNO_AND_EXIT ( cond, EINVAL );
kobj = cond->ptr;
ASSERT_ERRNO_AND_EXIT ( kobj, EINVAL );
ASSERT_ERRNO_AND_EXIT ( list_find ( &kobjects, &kobj->list ),
EINVAL );
kcond = kobj->kobject;
ASSERT_ERRNO_AND_EXIT ( kcond && kcond->id == cond->id, EINVAL );
kcond->ref_cnt--;
/* additional cleanup here (e.g. if cond.var. is shared leave it) */
if ( kcond->ref_cnt )
EXIT2 ( EBUSY, EXIT_FAILURE );
kfree_kobject ( kobj );
cond->ptr = NULL;
cond->id = 0;
EXIT2 ( EXIT_SUCCESS, EXIT_SUCCESS );
}
/*!
* Lock mutex object
* \param mutex Mutex descriptor (user level descriptor)
* \return 0 if successful, -1 otherwise and appropriate error number is set
*/
int sys__pthread_mutex_lock ( void *p )
{
pthread_mutex_t *mutex;
kpthread_mutex_t *kmutex;
kobject_t *kobj;
int retval = EXIT_SUCCESS;
mutex = *( (pthread_mutex_t **) p );
ASSERT_ERRNO_AND_EXIT ( mutex, EINVAL );
kobj = mutex->ptr;
ASSERT_ERRNO_AND_EXIT ( kobj, EINVAL );
ASSERT_ERRNO_AND_EXIT ( list_find ( &kobjects, &kobj->list ),
EINVAL );
kmutex = kobj->kobject;
ASSERT_ERRNO_AND_EXIT ( kmutex && kmutex->id == mutex->id, EINVAL );
retval = mutex_lock ( kmutex, kthread_get_active () );
if ( retval == 1 )
kthreads_schedule ();
return retval != -1;
}
/*!
* Initialize mutex object
* \param mutex Mutex descriptor (user level descriptor)
* \param mutexattr Mutex parameters
* \return 0 if successful, -1 otherwise and appropriate error number is set
*/
int sys__pthread_mutex_init ( void *p )
{
pthread_mutex_t *mutex;
/* pthread_mutexattr_t *mutexattr; not implemented */
kpthread_mutex_t *kmutex;
kobject_t *kobj;
mutex = *( (pthread_mutex_t **) p ); /* p += sizeof (pthread_mutex_t *);
mutexattr = *( (pthread_mutexattr_t *) p ); */
ASSERT_ERRNO_AND_EXIT ( mutex, EINVAL );
kobj = kmalloc_kobject ( sizeof (kpthread_mutex_t) );
ASSERT_ERRNO_AND_EXIT ( kobj, ENOMEM );
kmutex = kobj->kobject;
kmutex->id = k_new_id ();
kmutex->owner = NULL;
kmutex->flags = 0;
kmutex->ref_cnt = 1;
kthreadq_init ( &kmutex->queue );
mutex->ptr = kobj;
mutex->id = kmutex->id;
EXIT2 ( EXIT_SUCCESS, EXIT_SUCCESS );
}
/*!
* Initialize mutex object
* \param mutex Mutex descriptor (user level descriptor)
* \param mutexattr Mutex parameters
* \return 0 if successful, -1 otherwise and appropriate error number is set
*/
int sys__pthread_mutex_init ( pthread_mutex_t *mutex,
pthread_mutexattr_t *mutexattr )
{
kpthread_mutex_t *kmutex;
kobject_t *kobj;
SYS_ENTRY();
ASSERT_ERRNO_AND_EXIT ( mutex, EINVAL );
kobj = kmalloc_kobject ( sizeof (kpthread_mutex_t) );
ASSERT_ERRNO_AND_EXIT ( kobj, ENOMEM );
kmutex = kobj->kobject;
kmutex->id = k_new_id ();
kmutex->owner = NULL;
kmutex->flags = 0;
kmutex->ref_cnt = 1;
kthreadq_init ( &kmutex->queue );
mutex->ptr = kobj;
mutex->id = kmutex->id;
SYS_EXIT ( EXIT_SUCCESS, EXIT_SUCCESS );
}
/*!
* Get timer expiration time
* \param timerid Timer descriptor (user descriptor)
* \param value Where to store time to next timer expiration (+period)
* \return status 0 for success
*/
int sys__timer_gettime ( void *p )
{
timer_t *timerid;
itimerspec_t *value;
ktimer_t *ktimer;
int retval;
kobject_t *kobj;
timerid = *( (timer_t **) p ); p += sizeof (timer_t *);
value = *( (itimerspec_t **) p );
ASSERT_ERRNO_AND_EXIT ( timerid, EINVAL );
kobj = timerid->ptr;
ASSERT_ERRNO_AND_EXIT ( kobj, EINVAL );
ASSERT_ERRNO_AND_EXIT ( list_find ( &kobjects, &kobj->list ),
EINVAL );
ktimer = kobj->kobject;
ASSERT_ERRNO_AND_EXIT ( ktimer && ktimer->id == timerid->id, EINVAL );
retval = ktimer_gettime ( ktimer, value );
EXIT ( retval );
}
/*!
* Delete timer
* \param timerid Timer descriptor (user descriptor)
* \return status 0 for success
*/
int sys__timer_delete ( void *p )
{
timer_t *timerid;
ktimer_t *ktimer;
int retval;
kobject_t *kobj;
timerid = *( (timer_t **) p );
ASSERT_ERRNO_AND_EXIT ( timerid, EINVAL );
kobj = timerid->ptr;
ASSERT_ERRNO_AND_EXIT ( kobj, EINVAL );
ASSERT_ERRNO_AND_EXIT ( list_find ( &kobjects, &kobj->list ),
EINVAL );
ktimer = kobj->kobject;
ASSERT_ERRNO_AND_EXIT ( ktimer && ktimer->id == timerid->id, EINVAL );
retval = ktimer_delete ( ktimer );
kfree_kobject ( kobj );
EXIT ( retval );
}
/*!
* Unlock monitor (or block trying)
*/
int sys__monitor_unlock ( monitor_t *monitor )
{
kmonitor_t *kmonitor;
ASSERT_ERRNO_AND_EXIT ( monitor && monitor->ptr, E_INVALID_HANDLE );
kmonitor = monitor->ptr;
ASSERT_ERRNO_AND_EXIT ( kmonitor->owner == k_get_active_thread (),
E_NOT_OWNER );
disable_interrupts ();
SET_ERRNO ( SUCCESS );
kmonitor->owner = k_threadq_get ( &kmonitor->queue );
if ( !k_release_thread ( &kmonitor->queue ) )
kmonitor->lock = FALSE;
else
k_schedule_threads ();
enable_interrupts ();
EXIT ( SUCCESS );
}
/*!
* Initialize conditional variable object
* \param cond conditional variable descriptor (user level descriptor)
* \param condattr conditional variable descriptor (user level descriptor)
* \return 0 if successful, -1 otherwise and appropriate error number is set
*/
int sys__pthread_cond_init ( void *p )
{
pthread_cond_t *cond;
/* pthread_condattr_t *condattr; not implemented */
kpthread_cond_t *kcond;
kobject_t *kobj;
cond = *( (pthread_cond_t **) p ); /* p += sizeof (pthread_cond_t *);
condattr = *( (pthread_condattr_t *) p ); */
ASSERT_ERRNO_AND_EXIT ( cond, EINVAL );
kobj = kmalloc_kobject ( sizeof (kpthread_cond_t) );
ASSERT_ERRNO_AND_EXIT ( kobj, ENOMEM );
kcond = kobj->kobject;
kcond->id = k_new_id ();
kcond->flags = 0;
kcond->ref_cnt = 1;
kthreadq_init ( &kcond->queue );
cond->ptr = kobj;
cond->id = kcond->id;
EXIT2 ( EXIT_SUCCESS, EXIT_SUCCESS );
}
/*!
* Create new thread (params on user stack!)
* \param thread User level thread descriptor
* \param attr Thread attributes
* \param start_routine Starting function for new thread
* \param arg Parameter sent to starting function
* (parameters are on calling thread stack)
*/
int sys__pthread_create ( void *p )
{
pthread_t *thread;
pthread_attr_t *attr;
void *(*start_routine) (void *);
void *arg;
kthread_t *kthread;
uint flags = 0;
int sched_policy = SCHED_FIFO;
int sched_priority = THREAD_DEF_PRIO;
void *stackaddr = NULL;
size_t stacksize = 0;
thread = *( (pthread_t **) p ); p += sizeof (pthread_t *);
attr = *( (pthread_attr_t **) p ); p += sizeof (pthread_attr_t *);
start_routine = *( (void **) p ); p += sizeof (void *);
arg = *( (void **) p );
if ( attr )
{
flags = attr->flags;
sched_policy = attr->sched_policy;
sched_priority = attr->sched_params.sched_priority;
stackaddr = attr->stackaddr;
stacksize = attr->stacksize;
ASSERT_ERRNO_AND_EXIT (
sched_policy >= 0 && sched_policy < SCHED_NUM,
ENOTSUP
);
ASSERT_ERRNO_AND_EXIT (
sched_priority >= THREAD_MIN_PRIO &&
sched_priority <= THREAD_MAX_PRIO,
ENOMEM
);
/* if ( flags & SOMETHING ) change attributes ... */
}
kthread = kthread_create ( start_routine, arg, flags,
sched_policy, sched_priority,
stackaddr, stacksize );
ASSERT_ERRNO_AND_EXIT ( kthread, ENOMEM );
if ( thread )
{
thread->ptr = kthread;
thread->id = kthread_get_id (kthread);
}
SET_ERRNO ( EXIT_SUCCESS );
kthreads_schedule ();
return EXIT_SUCCESS;
}
/*!
* Close a message queue
* \param mqdes Queue descriptor address (user level descriptor)
* \return 0 if successful, -1 otherwise and appropriate error number is set
*/
int sys__mq_close ( void *p )
{
mqd_t *mqdes;
kmq_queue_t *kq_queue;
kobject_t *kobj;
kmq_msg_t *kmq_msg;
kthread_t *kthread;
mqdes = *( (mqd_t **) p );
ASSERT_ERRNO_AND_EXIT ( mqdes, EBADF );
kobj = mqdes->ptr;
ASSERT_ERRNO_AND_EXIT ( kobj, EBADF );
ASSERT_ERRNO_AND_EXIT ( list_find ( &kobjects, &kobj->list ),
EBADF );
kq_queue = kobj->kobject;
kq_queue = list_find_and_remove ( &kmq_queue, &kq_queue->list );
if ( !kq_queue || kq_queue->id != mqdes->id )
EXIT2 ( EBADF, EXIT_FAILURE );
kq_queue->ref_cnt--;
if ( !kq_queue->ref_cnt )
{
/* remove messages */
while( (kmq_msg = list_remove(&kq_queue->msg_list,FIRST,NULL)) )
kfree (kmq_msg);
/* remove blocked threads */
while ( (kthread = kthreadq_remove (&kq_queue->send_q, NULL)) )
{
kthread_move_to_ready ( kthread, LAST );
kthread_set_errno ( kthread, EBADF );
kthread_set_syscall_retval ( kthread, EXIT_FAILURE );
}
while ( (kthread = kthreadq_remove (&kq_queue->recv_q, NULL)) )
{
kthread_move_to_ready ( kthread, LAST );
kthread_set_errno ( kthread, EBADF );
kthread_set_syscall_retval ( kthread, EXIT_FAILURE );
}
list_remove ( &kmq_queue, 0, &kq_queue->list );
k_free_id ( kq_queue->id );
kfree ( kq_queue->name );
kfree ( kq_queue );
}
/* remove kernel object descriptor */
kfree_kobject ( kobj );
EXIT2 ( EXIT_SUCCESS, EXIT_SUCCESS );
}
/*!
* Wait for signal
* \param set Signals thread is waiting for
* \param info Where to save caught signal
* \return signal number if signal is caught,
* -1 otherwise and appropriate error number is set
*/
int sys__sigwaitinfo ( void *p )
{
sigset_t *set;
siginfo_t *info;
kthread_t *kthread;
ksignal_handling_t *sh;
ksiginfo_t *ksig, *next;
int retval;
set = *( (sigset_t **) p ); p += sizeof (sigset_t *);
info = *( (siginfo_t **) p );
ASSERT_ERRNO_AND_EXIT ( set, EINVAL );
set = U2K_GET_ADR ( set, kthread_get_process (NULL) );
ASSERT_ERRNO_AND_EXIT ( set, EINVAL );
if ( info )
info = U2K_GET_ADR ( info, kthread_get_process (NULL) );
kthread = kthread_get_active ();
sh = kthread_get_sigparams ( kthread );
/* first, search for such signal in pending signals */
ksig = list_get ( &sh->pending_signals, FIRST );
while ( ksig )
{
next = list_get_next ( &ksig->list );
if ( sigtestset ( set, ksig->siginfo.si_signo ) )
{
retval = ksig->siginfo.si_signo;
if ( info )
*info = ksig->siginfo;
list_remove ( &sh->pending_signals, 0, &ksig->list );
kfree ( ksig );
EXIT2 ( EXIT_SUCCESS, retval );
}
ksig = next;
}
/*
* if no pending signal found that matches given mask
* suspend thread until signal is received
*/
kthread_suspend ( kthread, ksignal_received_signal, NULL );
kthreads_schedule ();
EXIT ( EINTR ); /* if other events wake thread */
}
static int cond_release ( void *p, int release_all )
{
pthread_cond_t *cond;
kpthread_cond_t *kcond;
kpthread_mutex_t *kmutex;
kobject_t *kobj_cond, *kobj_mutex;
kthread_t *kthread;
int retval = 0;
cond = *( (pthread_cond_t **) p );
ASSERT_ERRNO_AND_EXIT ( cond, EINVAL );
kobj_cond = cond->ptr;
ASSERT_ERRNO_AND_EXIT ( kobj_cond, EINVAL );
ASSERT_ERRNO_AND_EXIT ( list_find ( &kobjects, &kobj_cond->list ),
EINVAL );
kcond = kobj_cond->kobject;
ASSERT_ERRNO_AND_EXIT ( kcond && kcond->id == cond->id, EINVAL );
kthread_set_errno ( kthread_get_active (), EXIT_SUCCESS );
if ( (kthread = kthreadq_remove ( &kcond->queue, NULL )) )
{
kobj_mutex = kthread_get_private_param ( kthread );
kmutex = kobj_mutex->kobject;
retval = mutex_lock ( kmutex, kthread );
if ( retval == 0 )
kthread_move_to_ready ( kthread, LAST );
/* process other threads in queue */
while ( release_all &&
(kthread = kthreadq_remove ( &kcond->queue, NULL )) )
{
kthread_set_errno ( kthread, EXIT_SUCCESS );
kobj_mutex = kthread_get_private_param ( kthread );
kmutex = kobj_mutex->kobject;
kthread_enqueue(kthread, &kmutex->queue, 0, NULL, NULL);
}
}
if ( retval > -1 )
kthreads_schedule ();
return EXIT_SUCCESS;
}
/*!
* Modify thread signal mask
* \param how How to modify current must
* \param set Mask to use in modification
* \param oset Where to store old mask
* \return 0 if successful, -1 otherwise and appropriate error number is set
*/
int sys__pthread_sigmask ( void *p )
{
int how;
sigset_t *set;
sigset_t *oset;
ksignal_handling_t *sh;
int retval = EXIT_SUCCESS;
how = *( (int *) p ); p += sizeof (int);
set = *( (sigset_t **) p ); p += sizeof (sigset_t *);
oset = *( (sigset_t **) p );
ASSERT_ERRNO_AND_EXIT ( set, EINVAL );
set = U2K_GET_ADR ( set, kthread_get_process (NULL) );
ASSERT_ERRNO_AND_EXIT ( set, EINVAL );
sh = kthread_get_sigparams ( NULL );
if (oset)
oset = U2K_GET_ADR ( oset, kthread_get_process (NULL) );
if (oset)
*oset = *sh->mask;
switch ( how )
{
case SIG_BLOCK:
sigaddsets ( sh->mask, set );
break;
case SIG_UNBLOCK:
sigaddsets ( sh->mask, set );
break;
case SIG_SETMASK:
*sh->mask = *set;
break;
default:
retval = EINVAL;
}
/* reevaluate pending signals with new mask */
if ( retval == EXIT_SUCCESS )
retval = ksignal_process_pending ( kthread_get_active () );
EXIT ( retval );
}
/*!
* Retrieve parameters for existing alarm (get its values)
* \param alarm Pointer where alarm parameters will be stored
* \return status (0 for success)
*/
int sys__alarm_get ( void *id, alarm_t *alarm )
{
kalarm_t *kalarm;
ASSERT_ERRNO_AND_EXIT ( id && alarm, E_INVALID_HANDLE );
kalarm = id;
ASSERT_ERRNO_AND_EXIT ( kalarm && kalarm->magic == ALARM_MAGIC,
E_INVALID_HANDLE );
*alarm = kalarm->alarm;
EXIT ( SUCCESS );
}
/*!
* Lock monitor (or block trying)
*/
int sys__monitor_lock ( monitor_t *monitor )
{
kmonitor_t *kmonitor;
ASSERT_ERRNO_AND_EXIT ( monitor && monitor->ptr, E_INVALID_HANDLE );
disable_interrupts ();
kmonitor = monitor->ptr;
SET_ERRNO ( SUCCESS );
if ( !kmonitor->lock )
{
kmonitor->lock = TRUE;
kmonitor->owner = k_get_active_thread ();
}
else {
k_enqueue_thread ( NULL, &kmonitor->queue );
k_schedule_threads ();
}
enable_interrupts ();
EXIT ( SUCCESS );
}
