/*
|
* Copyright (C) 2008 Philippe Gerum <rpm@xenomai.org>.
|
*
|
* This library is free software; you can redistribute it and/or
|
* modify it under the terms of the GNU Lesser General Public
|
* License as published by the Free Software Foundation; either
|
* version 2 of the License, or (at your option) any later version.
|
*
|
* This library is distributed in the hope that it will be useful,
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
* Lesser General Public License for more details.
|
|
* You should have received a copy of the GNU Lesser General Public
|
* License along with this library; if not, write to the Free Software
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
|
*/
|
|
#include <stdio.h>
|
#include <stdint.h>
|
#include <errno.h>
|
#include <stdlib.h>
|
#include <string.h>
|
#include <boilerplate/ancillaries.h>
|
#include <copperplate/heapobj.h>
|
#include <copperplate/cluster.h>
|
#include <copperplate/clockobj.h>
|
#include <copperplate/semobj.h>
|
#include "reference.h"
|
#include "task.h"
|
#include "sem.h"
|
#include "tm.h"
|
#include "internal.h"
|
#include <psos/psos.h>
|
|
#define sem_magic 0x8181fbfb
|
|
struct cluster psos_sem_table;
|
|
static unsigned long anon_smids;
|
|
static struct psos_sem *get_sem_from_id(u_long smid, int *err_r)
|
{
|
struct psos_sem *sem = mainheap_deref(smid, struct psos_sem);
|
|
if (sem == NULL || ((uintptr_t)sem & (sizeof(uintptr_t)-1)) != 0)
|
goto objid_error;
|
|
if (sem->magic == sem_magic)
|
return sem;
|
|
if (sem->magic == ~sem_magic) {
|
*err_r = ERR_OBJDEL;
|
return NULL;
|
}
|
|
if ((sem->magic >> 16) == 0x8181) {
|
*err_r = ERR_OBJTYPE;
|
return NULL;
|
}
|
|
objid_error:
|
*err_r = ERR_OBJID;
|
|
return NULL;
|
}
|
|
static void sem_finalize(struct semobj *smobj)
|
{
|
struct psos_sem *sem = container_of(smobj, struct psos_sem, smobj);
|
xnfree(sem);
|
}
|
fnref_register(libpsos, sem_finalize);
|
|
u_long sm_create(const char *name,
|
u_long count, u_long flags, u_long *smid_r)
|
{
|
int smobj_flags = SEMOBJ_WARNDEL;
|
struct psos_sem *sem;
|
struct service svc;
|
char short_name[5];
|
int ret;
|
|
CANCEL_DEFER(svc);
|
|
sem = xnmalloc(sizeof(*sem));
|
if (sem == NULL) {
|
ret = ERR_NOSCB;
|
goto out;
|
}
|
|
if (name == NULL || *name == '\0')
|
sprintf(sem->name, "sm%lu", ++anon_smids);
|
else {
|
name = psos_trunc_name(short_name, name);
|
namecpy(sem->name, name);
|
}
|
|
if (cluster_addobj_dup(&psos_sem_table, sem->name, &sem->cobj)) {
|
warning("cannot register semaphore: %s", sem->name);
|
xnfree(sem);
|
ret = ERR_OBJID;
|
goto out;
|
}
|
|
if (flags & SM_PRIOR)
|
smobj_flags |= SEMOBJ_PRIO;
|
|
sem->magic = sem_magic;
|
ret = semobj_init(&sem->smobj, smobj_flags, count,
|
fnref_put(libpsos, sem_finalize));
|
if (ret) {
|
cluster_delobj(&psos_sem_table, &sem->cobj);
|
xnfree(sem);
|
goto out;
|
}
|
|
*smid_r = mainheap_ref(sem, u_long);
|
out:
|
CANCEL_RESTORE(svc);
|
|
return ret;
|
}
|
|
u_long sm_delete(u_long smid)
|
{
|
struct psos_sem *sem;
|
struct service svc;
|
int ret;
|
|
sem = get_sem_from_id(smid, &ret);
|
if (sem == NULL)
|
return ret;
|
|
CANCEL_DEFER(svc);
|
|
cluster_delobj(&psos_sem_table, &sem->cobj);
|
sem->magic = ~sem_magic; /* Prevent further reference. */
|
ret = semobj_destroy(&sem->smobj);
|
if (ret)
|
ret = ret > 0 ? ERR_TATSDEL : ERR_OBJDEL;
|
|
CANCEL_RESTORE(svc);
|
|
return ret;
|
}
|
|
u_long sm_ident(const char *name, u_long node, u_long *smid_r)
|
{
|
struct clusterobj *cobj;
|
struct psos_sem *sem;
|
struct service svc;
|
char short_name[5];
|
|
if (node)
|
return ERR_NODENO;
|
|
name = psos_trunc_name(short_name, name);
|
|
CANCEL_DEFER(svc);
|
cobj = cluster_findobj(&psos_sem_table, name);
|
CANCEL_RESTORE(svc);
|
if (cobj == NULL)
|
return ERR_OBJNF;
|
|
sem = container_of(cobj, struct psos_sem, cobj);
|
*smid_r = mainheap_ref(sem, u_long);
|
|
return SUCCESS;
|
}
|
|
u_long sm_p(u_long smid, u_long flags, u_long timeout)
|
{
|
struct timespec ts, *timespec = &ts;
|
struct psos_sem *sem;
|
struct service svc;
|
int ret;
|
|
sem = get_sem_from_id(smid, &ret);
|
if (sem == NULL)
|
return ret;
|
|
CANCEL_DEFER(svc);
|
|
if (flags & SM_NOWAIT) {
|
timespec->tv_sec = 0;
|
timespec->tv_nsec = 0;
|
} else if (timeout != 0)
|
clockobj_ticks_to_timeout(&psos_clock, timeout, timespec);
|
else
|
timespec = NULL;
|
|
ret = semobj_wait(&sem->smobj, timespec);
|
if (ret) {
|
if (ret == -EIDRM)
|
ret = ERR_SKILLD;
|
else if (ret == -ETIMEDOUT)
|
ret = ERR_TIMEOUT;
|
else if (ret == -EWOULDBLOCK)
|
ret = ERR_NOSEM;
|
/*
|
* There is no explicit flush operation on pSOS
|
* semaphores, only an implicit one through deletion.
|
*/
|
}
|
|
CANCEL_RESTORE(svc);
|
|
return ret;
|
}
|
|
u_long sm_v(u_long smid)
|
{
|
struct psos_sem *sem;
|
struct service svc;
|
int ret;
|
|
sem = get_sem_from_id(smid, &ret);
|
if (sem == NULL)
|
return ret;
|
|
CANCEL_DEFER(svc);
|
|
ret = semobj_post(&sem->smobj);
|
if (ret == -EIDRM)
|
ret = ERR_OBJDEL;
|
|
CANCEL_RESTORE(svc);
|
|
return ret;
|
}
|
