void sc_mdelete(int mid, int opt, int *errp)
{
xnthread_t *owner;
vrtxmx_t *mx;
spl_t s;
if (opt & ~1) {
*errp = ER_IIP;
return;
}
xnlock_get_irqsave(&nklock, s);
mx = xnmap_fetch(vrtx_mx_idmap, mid);
if (mx == NULL) {
*errp = ER_ID;
goto unlock_and_exit;
}
owner = xnsynch_owner(&mx->synchbase);
if (owner && (opt == 0 || xnpod_current_thread() != owner)) {
*errp = ER_PND;
goto unlock_and_exit;
}
*errp = RET_OK;
if (mx_destroy_internal(mx) == XNSYNCH_RESCHED)
xnpod_schedule();
unlock_and_exit:
xnlock_put_irqrestore(&nklock, s);
}
static int vfile_rewind(struct xnvfile_snapshot_iterator *it)
{
struct vfile_priv *priv = xnvfile_iterator_priv(it);
wind_sem_t *sem = xnvfile_priv(it->vfile);
struct xnthread *owner;
sem = wind_h2obj_active((SEM_ID)sem, WIND_SEM_MAGIC, wind_sem_t);
if (sem == NULL)
return -EIDRM;
priv->curr = getheadpq(xnsynch_wait_queue(&sem->synchbase));
priv->type = sem->vtbl->type;
if (sem->vtbl == &semm_vtbl) {
owner = xnsynch_owner(&sem->synchbase);
if (owner)
strncpy(priv->owner, xnthread_name(owner),
sizeof(priv->owner));
else
*priv->owner = 0;
priv->count = -1U;
} else
priv->count = sem->count;
return xnsynch_nsleepers(&sem->synchbase);
}
/* Must be called with nklock locked, interrupts off. */
static STATUS semm_give(wind_sem_t *sem)
{
xnthread_t *cur = xnpod_current_thread();
int resched = 0;
check_NOT_ISR_CALLABLE(return ERROR);
if (cur != xnsynch_owner(&sem->synchbase)) {
wind_errnoset(S_semLib_INVALID_OPERATION);
return ERROR;
}
if (--sem->count > 0)
return OK;
if (xnsynch_release(&sem->synchbase)) {
sem->count = 1;
resched = 1;
}
if (xnsynch_test_flags(&sem->synchbase, WIND_SEM_DEL_SAFE))
if (taskUnsafeInner(cur))
resched = 1;
if (resched)
xnpod_schedule();
return OK;
}
/* Must be called with nklock locked, interrupts off. */
static STATUS semm_take(wind_sem_t *sem, xnticks_t to)
{
xnthread_t *cur = xnpod_current_thread();
if (xnsynch_owner(&sem->synchbase) == NULL) {
xnsynch_set_owner(&sem->synchbase, cur);
goto grab_sem;
}
if (xnsynch_owner(&sem->synchbase) == cur) {
sem->count++;
return OK;
}
error_check(to == XN_NONBLOCK, S_objLib_OBJ_UNAVAILABLE,
return ERROR);
xnsynch_acquire(&sem->synchbase, to, XN_RELATIVE);
error_check(xnthread_test_info(cur, XNBREAK),
-EINTR, return ERROR);
error_check(xnthread_test_info(cur, XNRMID),
S_objLib_OBJ_DELETED, return ERROR);
error_check(xnthread_test_info(cur, XNTIMEO),
S_objLib_OBJ_TIMEOUT, return ERROR);
grab_sem:
/*
* xnsynch_sleep_on() might have stolen the resource, so we
* need to put our internal data in sync.
*/
sem->count = 1;
if (xnsynch_test_flags(&sem->synchbase, WIND_SEM_DEL_SAFE))
taskSafeInner(cur);
return OK;
}
void sc_mpend(int mid, unsigned long timeout, int *errp)
{
xnthread_t *cur = xnpod_current_thread();
vrtxtask_t *task;
vrtxmx_t *mx;
spl_t s;
xnlock_get_irqsave(&nklock, s);
if (xnpod_unblockable_p()) {
*errp = -EPERM;
goto unlock_and_exit;
}
mx = xnmap_fetch(vrtx_mx_idmap, mid);
if (mx == NULL) {
*errp = ER_ID;
goto unlock_and_exit;
}
*errp = RET_OK;
if (xnthread_try_grab(cur, &mx->synchbase))
goto unlock_and_exit;
if (xnsynch_owner(&mx->synchbase) == cur)
goto unlock_and_exit;
task = thread2vrtxtask(cur);
task->vrtxtcb.TCBSTAT = TBSMUTEX;
if (timeout)
task->vrtxtcb.TCBSTAT |= TBSDELAY;
xnsynch_acquire(&mx->synchbase, timeout, XN_RELATIVE);
if (xnthread_test_info(cur, XNBREAK))
*errp = -EINTR;
else if (xnthread_test_info(cur, XNRMID))
*errp = ER_DEL; /* Mutex deleted while pending. */
else if (xnthread_test_info(cur, XNTIMEO))
*errp = ER_TMO; /* Timeout. */
unlock_and_exit:
xnlock_put_irqrestore(&nklock, s);
}
static int vfile_rewind(struct xnvfile_snapshot_iterator *it)
{
struct vfile_priv *priv = xnvfile_iterator_priv(it);
struct vrtxmx *mx = xnvfile_priv(it->vfile);
struct xnthread *owner;
priv->curr = getheadpq(xnsynch_wait_queue(&mx->synchbase));
owner = xnsynch_owner(&mx->synchbase);
if (owner)
strncpy(priv->owner, xnthread_name(owner),
sizeof(priv->owner));
else
*priv->owner = 0;
return xnsynch_nsleepers(&mx->synchbase);
}
int sc_minquiry(int mid, int *errp)
{
vrtxmx_t *mx;
spl_t s;
int rc;
xnlock_get_irqsave(&nklock, s);
mx = xnmap_fetch(vrtx_mx_idmap, mid);
if (mx == NULL) {
rc = 0;
*errp = ER_ID;
goto unlock_and_exit;
}
rc = xnsynch_owner(&mx->synchbase) == NULL;
unlock_and_exit:
xnlock_put_irqrestore(&nklock, s);
return rc;
}
void sc_mpost(int mid, int *errp)
{
xnthread_t *cur = xnpod_current_thread();
vrtxmx_t *mx;
spl_t s;
xnlock_get_irqsave(&nklock, s);
mx = xnmap_fetch(vrtx_mx_idmap, mid);
/* Return ER_ID if the poster does not own the mutex. */
if (mx == NULL || xnsynch_owner(&mx->synchbase) != cur) {
*errp = ER_ID;
goto unlock_and_exit;
}
*errp = RET_OK;
if (xnsynch_release(&mx->synchbase))
xnpod_schedule();
unlock_and_exit:
xnlock_put_irqrestore(&nklock, s);
}
