Generic fast xnsynch support & more

Index: b/ksrc/skins/native/syscall.c
===================================================================
@@ -52,7 +52,8 @@ int __native_muxid;
 static int __rt_bind_helper(struct task_struct *p,
 			    struct pt_regs *regs,
 			    xnhandle_t *handlep,
-			    unsigned magic, void **objaddrp)
+			    unsigned magic, void **objaddrp,
+			    unsigned long objoffs)
 {
 	char name[XNOBJECT_NAME_LEN];
 	RTIME timeout;

@@ -82,7 +83,7 @@ static int __rt_bind_helper(struct task_
 
 	/* Also validate the type of the bound object. */
 
-	if (xeno_test_magic(objaddr, magic)) {
+	if (xeno_test_magic(objaddr + objoffs, magic)) {
 		if (objaddrp)
 			*objaddrp = objaddr;
 	} else

@@ -93,6 +94,11 @@ static int __rt_bind_helper(struct task_
 	return err;
 }
 
+static RT_TASK *__rt_task_lookup(xnhandle_t threadh)
+{
+	return thread2rtask(xnthread_lookup(threadh));
+}
+
 static RT_TASK *__rt_task_current(struct task_struct *p)
 {
 	xnthread_t *thread = xnshadow_thread(p);

@@ -223,7 +229,9 @@ static int __rt_task_bind(struct pt_regs
 	RT_TASK_PLACEHOLDER ph;
 	int err;
 
-	err = __rt_bind_helper(p, regs, &ph.opaque, XENO_TASK_MAGIC, NULL);
+	err =
+	    __rt_bind_helper(p, regs, &ph.opaque, XENO_TASK_MAGIC, NULL,
+			     -offsetof(RT_TASK, thread_base));
 
 	if (err)
 		return err;

@@ -253,7 +261,7 @@ static int __rt_task_start(struct pt_reg
 				     sizeof(ph)))
 		return -EFAULT;
 
-	task = (RT_TASK *)xnregistry_fetch(ph.opaque);
+	task = __rt_task_lookup(ph.opaque);
 
 	if (!task)
 		return -ESRCH;

@@ -279,7 +287,7 @@ static int __rt_task_suspend(struct pt_r
 					     sizeof(ph)))
 			return -EFAULT;
 
-		task = (RT_TASK *)xnregistry_fetch(ph.opaque);
+		task = __rt_task_lookup(ph.opaque);
 	} else
 		task = __rt_task_current(p);
 

@@ -302,7 +310,7 @@ static int __rt_task_resume(struct pt_re
 				     sizeof(ph)))
 		return -EFAULT;
 
-	task = (RT_TASK *)xnregistry_fetch(ph.opaque);
+	task = __rt_task_lookup(ph.opaque);
 
 	if (!task)
 		return -ESRCH;

@@ -326,7 +334,7 @@ static int __rt_task_delete(struct pt_re
 					     sizeof(ph)))
 			return -EFAULT;
 
-		task = (RT_TASK *)xnregistry_fetch(ph.opaque);
+		task = __rt_task_lookup(ph.opaque);
 	} else
 		task = __rt_task_current(p);
 

@@ -364,7 +372,7 @@ static int __rt_task_set_periodic(struct
 					     sizeof(ph)))
 			return -EFAULT;
 
-		task = (RT_TASK *)xnregistry_fetch(ph.opaque);
+		task = __rt_task_lookup(ph.opaque);
 	} else
 		task = __rt_task_current(p);
 

@@ -418,7 +426,7 @@ static int __rt_task_set_priority(struct
 					     sizeof(ph)))
 			return -EFAULT;
 
-		task = (RT_TASK *)xnregistry_fetch(ph.opaque);
+		task = __rt_task_lookup(ph.opaque);
 	} else
 		task = __rt_task_current(p);
 

@@ -473,7 +481,7 @@ static int __rt_task_unblock(struct pt_r
 				     sizeof(ph)))
 		return -EFAULT;
 
-	task = (RT_TASK *)xnregistry_fetch(ph.opaque);
+	task = __rt_task_lookup(ph.opaque);
 
 	if (!task)
 		return -ESRCH;

@@ -500,7 +508,7 @@ static int __rt_task_inquire(struct pt_r
 					     sizeof(ph)))
 			return -EFAULT;
 
-		task = (RT_TASK *)xnregistry_fetch(ph.opaque);
+		task = __rt_task_lookup(ph.opaque);
 	} else
 		task = __rt_task_current(p);
 

@@ -541,7 +549,7 @@ static int __rt_task_notify(struct pt_re
 					     sizeof(ph)))
 			return -EFAULT;
 
-		task = (RT_TASK *)xnregistry_fetch(ph.opaque);
+		task = __rt_task_lookup(ph.opaque);
 	} else
 		task = __rt_task_current(p);
 

@@ -627,7 +635,7 @@ static int __rt_task_slice(struct pt_reg
 					     sizeof(ph)))
 			return -EFAULT;
 
-		task = (RT_TASK *)xnregistry_fetch(ph.opaque);
+		task = __rt_task_lookup(ph.opaque);
 	} else
 		task = __rt_task_current(current);
 

@@ -667,7 +675,7 @@ static int __rt_task_send(struct pt_regs
 					     sizeof(ph)))
 			return -EFAULT;
 
-		task = (RT_TASK *)xnregistry_fetch(ph.opaque);
+		task = __rt_task_lookup(ph.opaque);
 	} else
 		task = __rt_task_current(current);
 

@@ -1104,7 +1112,9 @@ static int __rt_sem_bind(struct pt_regs
 	RT_SEM_PLACEHOLDER ph;
 	int err;
 
-	err = __rt_bind_helper(current, regs, &ph.opaque, XENO_SEM_MAGIC, NULL);
+	err =
+	    __rt_bind_helper(current, regs, &ph.opaque, XENO_SEM_MAGIC,
+			     NULL, 0);
 
 	if (err)
 		return err;

@@ -1324,7 +1334,8 @@ static int __rt_event_bind(struct pt_reg
 	int err;
 
 	err =
-	    __rt_bind_helper(current, regs, &ph.opaque, XENO_EVENT_MAGIC, NULL);
+	    __rt_bind_helper(current, regs, &ph.opaque, XENO_EVENT_MAGIC,
+			     NULL, 0);
 
 	if (err)
 		return err;

@@ -1567,7 +1578,8 @@ static int __rt_mutex_bind(struct pt_reg
 	int err;
 
 	err =
-	    __rt_bind_helper(current, regs, &ph.opaque, XENO_MUTEX_MAGIC, NULL);
+	    __rt_bind_helper(current, regs, &ph.opaque, XENO_MUTEX_MAGIC,
+			     NULL, 0);
 
 	if (err)
 		return err;

@@ -1758,7 +1770,8 @@ static int __rt_cond_bind(struct pt_regs
 	int err;
 
 	err =
-	    __rt_bind_helper(current, regs, &ph.opaque, XENO_COND_MAGIC, NULL);
+	    __rt_bind_helper(current, regs, &ph.opaque, XENO_COND_MAGIC,
+			     NULL, 0);
 
 	if (err)
 		return err;

@@ -2008,7 +2021,7 @@ static int __rt_queue_bind(struct pt_reg
 
 	err =
 	    __rt_bind_helper(p, regs, &ph.opaque, XENO_QUEUE_MAGIC,
-			     (void **)&q);
+			     (void **)&q, 0);
 
 	if (err)
 		goto unlock_and_exit;

@@ -2507,7 +2520,7 @@ static int __rt_heap_bind(struct pt_regs
 
 	err =
 	    __rt_bind_helper(p, regs, &ph.opaque, XENO_HEAP_MAGIC,
-			     (void **)&heap);
+			     (void **)&heap, 0);
 
 	if (err)
 		goto unlock_and_exit;

@@ -3018,7 +3031,7 @@ static int __rt_intr_bind(struct pt_regs
 	RT_INTR_PLACEHOLDER ph;
 	int err;
 
-	err = __rt_bind_helper(p, regs, &ph.opaque, XENO_INTR_MAGIC, NULL);
+	err = __rt_bind_helper(p, regs, &ph.opaque, XENO_INTR_MAGIC, NULL, 0);
 
 	if (err)
 		return err;

@@ -3275,7 +3288,7 @@ static int __rt_pipe_bind(struct pt_regs
 	RT_PIPE_PLACEHOLDER ph;
 	int err;
 
-	err = __rt_bind_helper(p, regs, &ph.opaque, XENO_PIPE_MAGIC, NULL);
+	err = __rt_bind_helper(p, regs, &ph.opaque, XENO_PIPE_MAGIC, NULL, 0);
 
 	if (err)
 		return err;

@@ -3551,7 +3564,9 @@ static int __rt_buffer_bind(struct pt_re
 	RT_BUFFER_PLACEHOLDER ph;
 	int ret;
 
-	ret = __rt_bind_helper(current, regs, &ph.opaque, XENO_BUFFER_MAGIC, NULL);
+	ret =
+	    __rt_bind_helper(current, regs, &ph.opaque, XENO_BUFFER_MAGIC,
+			     NULL, 0);
 	if (ret)
 		return ret;
 

Index: b/ksrc/skins/native/task.c
===================================================================
@@ -46,7 +46,6 @@
 
 #include <nucleus/pod.h>
 #include <nucleus/heap.h>
-#include <nucleus/registry.h>
 #include <native/task.h>
 #include <native/timer.h>
 

@@ -80,11 +79,6 @@ static void __task_delete_hook(xnthread_
 	xnsynch_destroy(&task->msendq);
 #endif /* CONFIG_XENO_OPT_NATIVE_MPS */
 
-#ifdef CONFIG_XENO_OPT_REGISTRY
-	if (xnthread_handle(&task->thread_base) != XN_NO_HANDLE)
-		xnregistry_remove(xnthread_handle(&task->thread_base));
-#endif /* CONFIG_XENO_OPT_REGISTRY */
-
 	xnsynch_destroy(&task->safesynch);
 
 	removeq(&__xeno_task_q, &task->link);

@@ -285,20 +279,15 @@ int rt_task_create(RT_TASK *task,
 	appendq(&__xeno_task_q, &task->link);
 	xnlock_put_irqrestore(&nklock, s);
 
-#ifdef CONFIG_XENO_OPT_REGISTRY
 	/* <!> Since xnregister_enter() may reschedule, only register
 	   complete objects, so that the registry cannot return handles to
 	   half-baked objects... */
 
 	if (name) {
-		err = xnregistry_enter(task->rname,
-				       task,
-				       &xnthread_handle(&task->thread_base),
-				       NULL);
+		err = xnthread_register(&task->thread_base, task->rname);
 		if (err)
 			xnpod_delete_thread(&task->thread_base);
 	}
-#endif /* CONFIG_XENO_OPT_REGISTRY */
 
 	return err;
 }

Index: b/ksrc/skins/psos+/syscall.c
===================================================================
@@ -44,6 +44,11 @@
 
 int __psos_muxid;
 
+static inline psostask_t *__psos_task_lookup(xnhandle_t taskh)
+{
+	return thread2psostask(xnthread_lookup(taskh));
+}
+
 static psostask_t *__psos_task_current(struct task_struct *p)
 {
 	xnthread_t *thread = xnshadow_thread(p);

@@ -131,7 +136,7 @@ static int __t_start(struct pt_regs *reg
 	psostask_t *task;
 
 	handle = __xn_reg_arg1(regs);
-	task = (psostask_t *)xnregistry_fetch(handle);
+	task = __psos_task_lookup(handle);
 
 	if (!task)
 		return ERR_OBJID;

@@ -162,7 +167,7 @@ static int __t_delete(struct pt_regs *re
 	handle = __xn_reg_arg1(regs);
 
 	if (handle)
-		task = (psostask_t *)xnregistry_fetch(handle);
+		task = __psos_task_lookup(handle);
 	else
 		task = __psos_task_current(current);
 

@@ -182,7 +187,7 @@ static int __t_suspend(struct pt_regs *r
 	psostask_t *task;
 
 	if (handle)
-		task = (psostask_t *)xnregistry_fetch(handle);
+		task = __psos_task_lookup(handle);
 	else
 		task = __psos_task_current(current);
 

@@ -202,7 +207,7 @@ static int __t_resume(struct pt_regs *re
 	psostask_t *task;
 
 	if (handle)
-		task = (psostask_t *)xnregistry_fetch(handle);
+		task = __psos_task_lookup(handle);
 	else
 		task = __psos_task_current(current);
 

@@ -284,7 +289,7 @@ static int __t_setpri(struct pt_regs *re
 	psostask_t *task;
 
 	if (handle)
-		task = (psostask_t *)xnregistry_fetch(handle);
+		task = __psos_task_lookup(handle);
 	else
 		task = __psos_task_current(current);
 

@@ -314,7 +319,7 @@ static int __ev_send(struct pt_regs *reg
 	u_long events;
 
 	if (handle)
-		task = (psostask_t *)xnregistry_fetch(handle);
+		task = __psos_task_lookup(handle);
 	else
 		task = __psos_task_current(current);
 

@@ -1317,7 +1322,7 @@ static int __as_send(struct pt_regs *reg
 	psostask_t *task;
 
 	if (handle)
-		task = (psostask_t *)xnregistry_fetch(handle);
+		task = __psos_task_lookup(handle);
 	else
 		task = __psos_task_current(current);
 

Index: b/ksrc/skins/psos+/task.c
===================================================================
@@ -17,7 +17,6 @@
  * 02111-1307, USA.
  */
 
-#include <nucleus/registry.h>
 #include <psos+/task.h>
 #include <psos+/tm.h>
 

@@ -45,11 +44,6 @@ static void psostask_delete_hook(xnthrea
 	if (xnthread_get_magic(thread) != PSOS_SKIN_MAGIC)
 		return;
 
-#ifdef CONFIG_XENO_OPT_REGISTRY
-	if (xnthread_handle(thread) != XN_NO_HANDLE)
-		xnregistry_remove(xnthread_handle(thread));
-#endif /* CONFIG_XENO_OPT_REGISTRY */
-
 	task = thread2psostask(thread);
 
 	removeq(&psostaskq, &task->link);

@@ -95,6 +89,7 @@ u_long t_create(const char *name,
 {
 	xnflags_t bflags = 0;
 	psostask_t *task;
+	u_long err;
 	spl_t s;
 	int n;
 

@@ -159,16 +154,11 @@ u_long t_create(const char *name,
 	*tid_r = (u_long)task;
 	xnlock_put_irqrestore(&nklock, s);
 
-#ifdef CONFIG_XENO_OPT_REGISTRY
-	{
-		u_long err = xnregistry_enter(task->name,
-					      task, &xnthread_handle(&task->threadbase), NULL);
-		if (err) {
-			t_delete((u_long)task);
-			return err;
-		}
+	err = xnthread_register(&task->threadbase, task->name);
+	if (err) {
+		t_delete((u_long)task);
+		return err;
 	}
-#endif /* CONFIG_XENO_OPT_REGISTRY */
 
 	xnarch_create_display(&task->threadbase, task->name, psostask);
 

Index: b/ksrc/skins/vxworks/syscall.c
===================================================================
@@ -42,6 +42,11 @@
 
 int __wind_muxid;
 
+static inline WIND_TCB *__wind_lookup_task(xnhandle_t threadh)
+{
+	return thread2wind_task(xnthread_lookup(threadh));
+}
+
 static WIND_TCB *__wind_task_current(struct task_struct *p)
 {
 	xnthread_t *thread = xnshadow_thread(p);

@@ -146,7 +151,7 @@ out:
 
 static int __wind_task_activate(struct pt_regs *regs)
 {
-	WIND_TCB *pTcb = (WIND_TCB *)xnregistry_fetch(__xn_reg_arg1(regs));
+	WIND_TCB *pTcb = __wind_lookup_task(__xn_reg_arg1(regs));
 
 	if (!pTcb)
 		return S_objLib_OBJ_ID_ERROR;

@@ -167,7 +172,7 @@ static int __wind_task_deleteforce(struc
 	WIND_TCB *pTcb;
 
 	if (handle)
-		pTcb = (WIND_TCB *)xnregistry_fetch(handle);
+		pTcb = __wind_lookup_task(handle);
 	else
 		pTcb = __wind_task_current(current);
 

@@ -190,7 +195,7 @@ static int __wind_task_delete(struct pt_
 	WIND_TCB *pTcb;
 
 	if (handle)
-		pTcb = (WIND_TCB *)xnregistry_fetch(handle);
+		pTcb = __wind_lookup_task(handle);
 	else
 		pTcb = __wind_task_current(current);
 

@@ -213,7 +218,7 @@ static int __wind_task_suspend(struct pt
 	WIND_TCB *pTcb;
 
 	if (handle)
-		pTcb = (WIND_TCB *)xnregistry_fetch(handle);
+		pTcb = __wind_lookup_task(handle);
 	else
 		pTcb = __wind_task_current(current);
 

@@ -232,7 +237,7 @@ static int __wind_task_suspend(struct pt
 
 static int __wind_task_resume(struct pt_regs *regs)
 {
-	WIND_TCB *pTcb = (WIND_TCB *)xnregistry_fetch(__xn_reg_arg1(regs));
+	WIND_TCB *pTcb = __wind_lookup_task(__xn_reg_arg1(regs));
 
 	if (!pTcb)
 		return S_objLib_OBJ_ID_ERROR;

@@ -275,7 +280,7 @@ static int __wind_task_priorityset(struc
 	WIND_TCB *pTcb;
 
 	if (handle)
-		pTcb = (WIND_TCB *)xnregistry_fetch(handle);
+		pTcb = __wind_lookup_task(handle);
 	else
 		pTcb = __wind_task_current(current);
 

@@ -299,7 +304,7 @@ static int __wind_task_priorityget(struc
 	int prio;
 
 	if (handle)
-		pTcb = (WIND_TCB *)xnregistry_fetch(handle);
+		pTcb = __wind_lookup_task(handle);
 	else
 		pTcb = __wind_task_current(current);
 

@@ -374,7 +379,7 @@ static int __wind_task_verifyid(struct p
 	xnhandle_t handle = __xn_reg_arg1(regs);
 	WIND_TCB *pTcb;
 
-	pTcb = (WIND_TCB *)xnregistry_fetch(handle);
+	pTcb = __wind_lookup_task(handle);
 
 	if (!pTcb)
 		return S_objLib_OBJ_ID_ERROR;

@@ -574,7 +579,7 @@ static int __wind_taskinfo_name(struct p
 	const char *name;
 	WIND_TCB *pTcb;
 
-	pTcb = (WIND_TCB *)xnregistry_fetch(handle);
+	pTcb = __wind_lookup_task(handle);
 
 	if (!pTcb)
 		return S_objLib_OBJ_ID_ERROR;

@@ -618,7 +623,7 @@ static int __wind_taskinfo_status(struct
 
 	xnlock_get_irqsave(&nklock, s);
 
-	pTcb = (WIND_TCB *)xnregistry_fetch(handle);
+	pTcb = __wind_lookup_task(handle);
 
 	if (!pTcb || pTcb->magic != WIND_TASK_MAGIC) {
 		xnlock_put_irqrestore(&nklock, s);

@@ -643,7 +648,7 @@ static int __wind_taskinfo_get(struct pt
 	WIND_TCB *pTcb;
 	int err;
 
-	pTcb = (WIND_TCB *)xnregistry_fetch(handle);
+	pTcb = __wind_lookup_task(handle);
 	if (!pTcb)
 		return S_objLib_OBJ_ID_ERROR;
 

@@ -673,7 +678,7 @@ static int __wind_errno_taskset(struct p
  		return 0;
  	}
  
- 	pTcb = (WIND_TCB *)xnregistry_fetch(handle);
+ 	pTcb = __wind_lookup_task(handle);
 	if (!pTcb)
 		return S_objLib_OBJ_ID_ERROR;
 

@@ -696,7 +701,7 @@ static int __wind_errno_taskget(struct p
  	if (!handle)
  		errcode = wind_errnoget();
  	else {
- 		pTcb = (WIND_TCB *)xnregistry_fetch(handle);
+ 		pTcb = __wind_lookup_task(handle);
  		if (!pTcb)
  			return S_objLib_OBJ_ID_ERROR;
  

Index: b/ksrc/skins/vxworks/taskLib.c
===================================================================
@@ -170,14 +170,11 @@ STATUS taskInit(WIND_TCB *pTcb,
 	appendq(&wind_tasks_q, &pTcb->link);
 	xnlock_put_irqrestore(&nklock, s);
 
-#ifdef CONFIG_XENO_OPT_REGISTRY
-	if (xnregistry_enter(pTcb->name,
-			     pTcb, &xnthread_handle(&pTcb->threadbase), NULL)) {
+	if (xnthread_register(&pTcb->threadbase, pTcb->name)) {
 		wind_errnoset(S_objLib_OBJ_ID_ERROR);
 		taskDeleteForce((TASK_ID) pTcb);
 		return ERROR;
 	}
-#endif /* CONFIG_XENO_OPT_REGISTRY */
 
 	return OK;
 }

@@ -618,11 +615,6 @@ static void wind_task_delete_hook(xnthre
 	if (xnthread_get_magic(thread) != VXWORKS_SKIN_MAGIC)
 		return;
 
-#ifdef CONFIG_XENO_OPT_REGISTRY
-	if (xnthread_handle(thread) != XN_NO_HANDLE)
-	    xnregistry_remove(xnthread_handle(thread));
-#endif /* CONFIG_XENO_OPT_REGISTRY */
-
 	task = thread2wind_task(thread);
 
 	xnsynch_destroy(&task->safesync);

Index: b/include/nucleus/registry.h
===================================================================
@@ -35,7 +35,6 @@
 #if defined(__KERNEL__) || defined(__XENO_SIM__)
 
 #include <nucleus/synch.h>
-#include <nucleus/thread.h>
 
 struct xnpnode;
 

Index: b/include/nucleus/thread.h
===================================================================
@@ -130,6 +130,7 @@
 
 #include <nucleus/stat.h>
 #include <nucleus/timer.h>
+#include <nucleus/registry.h>
 
 #ifdef __XENO_SIM__
 /* Pseudo-status (must not conflict with other bits) */

@@ -392,6 +393,30 @@ static inline xnticks_t xnthread_get_per
 	return period;
 }
 
+#ifdef CONFIG_XENO_OPT_REGISTRY
+static inline int xnthread_register(xnthread_t *thread, const char *name)
+{
+	return xnregistry_enter(name, thread, &xnthread_handle(thread), NULL);
+}
+
+static inline xnthread_t *xnthread_lookup(xnhandle_t threadh)
+{
+	xnthread_t *thread = xnregistry_fetch(threadh);
+
+	return (thread && xnthread_handle(thread) == threadh) ? thread : NULL;
+}
+#else /* !CONFIG_XENO_OPT_REGISTRY */
+static inline int xnthread_register(xnthread_t *thread, const char *name)
+{
+	return 0;
+}
+
+static inline xnthread_t *xnthread_lookup(xnhandle_t threadh)
+{
+	return NULL;
+}
+#endif /* !CONFIG_XENO_OPT_REGISTRY */
+
 #ifdef __cplusplus
 }
 #endif

Index: b/ksrc/nucleus/thread.c
===================================================================
@@ -136,6 +136,8 @@ void xnthread_cleanup_tcb(xnthread_t *th
 #endif
 
 #ifdef CONFIG_XENO_OPT_REGISTRY
+	if (thread->registry.handle != XN_NO_HANDLE)
+		xnregistry_remove(thread->registry.handle);
 	thread->registry.handle = XN_NO_HANDLE;
 #endif /* CONFIG_XENO_OPT_REGISTRY */
 }

Index: b/include/asm-generic/bits/current.h
===================================================================
@@ -2,14 +2,20 @@
 #define _XENO_ASM_GENERIC_CURRENT_H
 
 #include <pthread.h>
+#include <nucleus/types.h>
 
 extern pthread_key_t xeno_current_key;
 
 extern void xeno_set_current(void);
 
-static inline void *xeno_get_current(void)
+static inline xnhandle_t xeno_get_current(void)
 {
-	return pthread_getspecific(xeno_current_key);
+	void *val = pthread_getspecific(xeno_current_key);
+
+	if (!val)
+		return XN_NO_HANDLE;
+
+	return (xnhandle_t)val;
 }
 
 #endif /* _XENO_ASM_GENERIC_CURRENT_H */

Index: b/include/nucleus/types.h
===================================================================
@@ -61,6 +61,19 @@ typedef unsigned long xnhandle_t;
 
 #define XN_NO_HANDLE ((xnhandle_t)0)
 
+#define XN_HANDLE_SPARE0	((xnhandle_t)0x10000000)
+#define XN_HANDLE_SPARE1	((xnhandle_t)0x20000000)
+#define XN_HANDLE_SPARE2	((xnhandle_t)0x40000000)
+#define XN_HANDLE_SPARE3	((xnhandle_t)0x80000000)
+#define XN_HANDLE_SPARE_MASK	((xnhandle_t)0xf0000000)
+
+#define xnhandle_mask_spare(handle)  ((handle) & ~XN_HANDLE_SPARE_MASK)
+#define xnhandle_test_spare(handle, bits)  (!!((handle) & (bits)))
+#define xnhandle_set_spare(handle, bits) \
+	do { (handle) |= (bits); } while (0)
+#define xnhandle_clear_spare(handle, bits) \
+	do { (handle) &= ~(bits); } while (0)
+
 struct xnintr;
 
 typedef int (*xnisr_t)(struct xnintr *intr);

Index: b/ksrc/nucleus/shadow.c
===================================================================
@@ -1908,13 +1908,21 @@ static int xnshadow_sys_sem_heap(struct
 	return __xn_safe_copy_to_user(us_hinfo, &hinfo, sizeof(*us_hinfo));
 }
 
+#ifdef CONFIG_XENO_OPT_REGISTRY
 static int xnshadow_sys_current(struct pt_regs *regs)
 {
-	xnthread_t * __user *us_current, *cur = xnshadow_thread(current);
-	us_current = (xnthread_t *__user *) __xn_reg_arg1(regs);
+	xnthread_t *cur = xnshadow_thread(current);
+	xnhandle_t __user *us_handle;
 
-	return __xn_safe_copy_to_user(us_current, &cur, sizeof(*us_current));
+	if (!cur)
+		return -EPERM;
+
+	us_handle = (xnhandle_t __user *) __xn_reg_arg1(regs);
+
+	return __xn_safe_copy_to_user(us_handle, &xnthread_handle(cur),
+				      sizeof(*us_handle));
 }
+#endif /* CONFIG_XENO_OPT_REGISTRY */
 
 static xnsysent_t __systab[] = {
 	[__xn_sys_migrate] = {&xnshadow_sys_migrate, __xn_exec_current},

@@ -1925,7 +1933,9 @@ static xnsysent_t __systab[] = {
 	[__xn_sys_barrier] = {&xnshadow_sys_barrier, __xn_exec_lostage},
 	[__xn_sys_trace] = {&xnshadow_sys_trace, __xn_exec_any},
 	[__xn_sys_sem_heap] = {&xnshadow_sys_sem_heap, __xn_exec_any},
+#ifdef CONFIG_XENO_OPT_REGISTRY
 	[__xn_sys_current] = {&xnshadow_sys_current, __xn_exec_any},
+#endif /* CONFIG_XENO_OPT_REGISTRY */
 };
 
 static void *xnshadow_sys_event(int event, void *data)

Index: b/ksrc/skins/posix/cb_lock.h
===================================================================
@@ -3,15 +3,22 @@
 
 #include <asm/xenomai/atomic.h>
 #include <nucleus/compiler.h>
+#include <nucleus/types.h>
 
 #ifndef __KERNEL__
 typedef void xnthread_t;
 #endif /* __KERNEL__ */
 
-#define test_claimed(owner) ((long) (owner) & 1)
-#define clear_claimed(owner) ((xnthread_t *) ((long) (owner) & ~1))
-#define set_claimed(owner, bit) \
-        ((xnthread_t *) ((long) clear_claimed(owner) | !!(bit)))
+#define __CLAIMED_BIT		XN_HANDLE_SPARE3
+
+#define test_claimed(owner)	xnhandle_test_spare(owner, __CLAIMED_BIT)
+#define clear_claimed(owner)	xnhandle_mask_spare(owner)
+#define set_claimed(owner, bit) ({ \
+	xnhandle_t __tmp = xnhandle_mask_spare(owner); \
+	if (bit) \
+		xnhandle_set_spare(__tmp, __CLAIMED_BIT); \
+	__tmp; \
+})
 
 #ifdef CONFIG_XENO_FASTSEM
 

Index: b/ksrc/skins/posix/cond.c
===================================================================
@@ -230,18 +230,20 @@ static inline int mutex_save_count(xnthr
 
 	mutex = shadow->mutex;
 
-	if (clear_claimed(xnarch_atomic_intptr_get(mutex->owner)) != cur)
+	if (clear_claimed(xnarch_atomic_get(mutex->owner)) !=
+	    xnthread_handle(cur))
 		return EPERM;
 
 	*count_ptr = shadow->lockcnt;
 
-	if (likely(xnarch_atomic_intptr_cmpxchg(mutex->owner, cur, NULL) == cur))
+	if (likely(xnarch_atomic_cmpxchg(mutex->owner, cur, XN_NO_HANDLE) ==
+		   xnthread_handle(cur)))
 		return 0;
 
 	owner = xnsynch_wakeup_one_sleeper(&mutex->synchbase);
-	xnarch_atomic_intptr_set
-		(mutex->owner,
-		 set_claimed(owner,xnsynch_nsleepers(&mutex->synchbase)));
+	xnarch_atomic_set(mutex->owner,
+			  set_claimed(xnthread_handle(owner),
+				      xnsynch_nsleepers(&mutex->synchbase)));
 
 	/* Do not reschedule here, releasing the mutex and suspension must be
 	   done atomically in pthread_cond_*wait. */

Index: b/ksrc/skins/posix/mutex.c
===================================================================
@@ -82,7 +82,7 @@ int pse51_mutex_check_init(struct __shad
 
 int pse51_mutex_init_internal(struct __shadow_mutex *shadow,
 			      pse51_mutex_t *mutex,
-			      xnarch_atomic_intptr_t *ownerp,
+			      xnarch_atomic_t *ownerp,
 			      const pthread_mutexattr_t *attr)
 {
 	xnflags_t synch_flags = XNSYNCH_PRIO | XNSYNCH_NOPIP;

@@ -118,7 +118,7 @@ int pse51_mutex_init_internal(struct __s
 	mutex->owner = ownerp;
 	mutex->owningq = kq;
 	mutex->sleepers = 0;
-	xnarch_atomic_intptr_set(ownerp, NULL);
+	xnarch_atomic_set(ownerp, XN_NO_HANDLE);
 
 	xnlock_get_irqsave(&nklock, s);
 	appendq(&kq->mutexq, &mutex->link);

@@ -159,7 +159,7 @@ int pthread_mutex_init(pthread_mutex_t *
 	    &((union __xeno_mutex *)mx)->shadow_mutex;
 	DECLARE_CB_LOCK_FLAGS(s);
 	pse51_mutex_t *mutex;
-	xnarch_atomic_intptr_t *ownerp;
+	xnarch_atomic_t *ownerp;
 	int err;
 
 	if (!attr)

@@ -185,9 +185,9 @@ int pthread_mutex_init(pthread_mutex_t *
 	if (!mutex)
 		return ENOMEM;
 
-	ownerp = (xnarch_atomic_intptr_t *)
+	ownerp = (xnarch_atomic_t *)
 		xnheap_alloc(&xnsys_ppd_get(attr->pshared)->sem_heap,
-			     sizeof(xnarch_atomic_intptr_t));
+			     sizeof(xnarch_atomic_t));
 	if (!ownerp) {
 		xnfree(mutex);
 		return EAGAIN;

@@ -266,7 +266,7 @@ int pthread_mutex_destroy(pthread_mutex_
 		return EPERM;
 	}
 
-	if (xnarch_atomic_intptr_get(mutex->owner)) {
+	if (xnarch_atomic_get(mutex->owner) != XN_NO_HANDLE) {
 		cb_write_unlock(&shadow->lock, s);
 		return EBUSY;
 	}

@@ -290,6 +290,10 @@ int pse51_mutex_timedlock_break(struct _
 	spl_t s;
 	int err;
 
+	/* We need a valid thread handle for the fast lock. */
+	if (xnthread_handle(cur) == XN_NO_HANDLE)
+		return -EPERM;
+
 	err = pse51_mutex_timedlock_internal(cur, shadow, 1, timed, abs_to);
 	if (err != -EBUSY)
 		goto unlock_and_return;

@@ -392,7 +396,7 @@ int pthread_mutex_trylock(pthread_mutex_
 		return -PTR_ERR(owner);
 
 	err = EBUSY;
-	if (clear_claimed(owner) == cur) {
+	if (owner == cur) {
 		pse51_mutex_t *mutex = shadow->mutex;
 
 		if (mutex->attr.type == PTHREAD_MUTEX_RECURSIVE) {

@@ -573,7 +577,8 @@ int pthread_mutex_unlock(pthread_mutex_t
 
 	mutex = shadow->mutex;
 	
-	if (clear_claimed(xnarch_atomic_intptr_get(mutex->owner)) != cur) {
+	if (clear_claimed(xnarch_atomic_get(mutex->owner)) !=
+	    xnthread_handle(cur)) {
 		err = EPERM;
 		goto out;
 	}

146 lines not on this page · raw message

Index: b/ksrc/skins/posix/syscall.c
===================================================================
@@ -1060,7 +1060,8 @@ static int __pthread_mutex_unlock(struct
 
 	mutex = shadow->mutex;
 
-	if (clear_claimed(xnarch_atomic_intptr_get(mutex->owner)) != cur) {
+	if (clear_claimed(xnarch_atomic_get(mutex->owner)) !=
+	    xnthread_handle(cur)) {
 		err = -EPERM;
 		goto out;
 	}

@@ -1119,7 +1120,7 @@ static int __pthread_mutex_init(struct p
 	pthread_mutexattr_t locattr, *attr, *uattrp;
 	union __xeno_mutex mx, *umx;
 	pse51_mutex_t *mutex;
-	xnarch_atomic_intptr_t *ownerp;
+	xnarch_atomic_t *ownerp;
 	int err;
 
 	umx = (union __xeno_mutex *)__xn_reg_arg1(regs);

@@ -1144,9 +1145,9 @@ static int __pthread_mutex_init(struct p
 	if (!mutex)
 		return -ENOMEM;
 
-	ownerp = (xnarch_atomic_intptr_t *)
+	ownerp = (xnarch_atomic_t *)
 		xnheap_alloc(&xnsys_ppd_get(attr->pshared)->sem_heap,
-			     sizeof(xnarch_atomic_intptr_t));
+			     sizeof(xnarch_atomic_t));
 	if (!ownerp) {
 		xnfree(mutex);
 		return -EAGAIN;

@@ -1185,7 +1186,7 @@ static int __pthread_mutex_destroy(struc
 	if (pse51_kqueues(mutex->attr.pshared) != mutex->owningq)
 		return -EPERM;
 
-	if (xnarch_atomic_intptr_get(mutex->owner))
+	if (xnarch_atomic_get(mutex->owner) != XN_NO_HANDLE)
 		return -EBUSY;
 
 	pse51_mark_deleted(shadow);

119 lines not on this page · raw message

Index: b/ksrc/skins/posix/thread.c
===================================================================
@@ -234,6 +234,18 @@ int pthread_create(pthread_t *tid,
 	thread->hkey.mm = NULL;
 #endif /* CONFIG_XENO_OPT_PERVASIVE */
 
+#ifdef CONFIG_XENO_FASTSEM
+	/* We need an anonymous registry entry to obtain a handle for fast
+	   mutex locking. */
+	{
+		int err = xnthread_register(&thread->threadbase, "");
+		if (err) {
+			thread_destroy(thread);
+			return err;
+		}
+	}
+#endif /* CONFIG_XENO_FASTSEM */
+
 	*tid = thread;		/* Must be done before the thread is started. */
 
 	if (start)		/* Do not start shadow threads (i.e. start == NULL). */

Index: b/include/asm-generic/bits/bind.h
===================================================================
@@ -15,18 +15,24 @@
 
 __attribute__ ((weak))
 pthread_key_t xeno_current_key;
-__attribute__ ((weak))
-pthread_once_t xeno_init_current_key_once = PTHREAD_ONCE_INIT;
 
 __attribute__ ((weak))
 void xeno_set_current(void)
 {
 	void *kthread_cb;
-	XENOMAI_SYSCALL1(__xn_sys_current, &kthread_cb);
+	int err;
+
+	err = XENOMAI_SYSCALL1(__xn_sys_current, &kthread_cb);
+	if (err) {
+		fprintf(stderr, "Xenomai: error obtaining handle for current "
+			"thread: %s\n", strerror(err));
+		exit(1);
+	}
 	pthread_setspecific(xeno_current_key, kthread_cb);
 }
 
-static void init_current_key(void)
+static __attribute__ ((constructor))
+void init_current_key(void)
 {
 	int err = pthread_key_create(&xeno_current_key, NULL);
 	if (err) {

@@ -168,8 +174,6 @@ xeno_bind_skin(unsigned skin_magic, cons
 	sa.sa_flags = 0;
 	sigaction(SIGXCPU, &sa, NULL);
 
-	pthread_once(&xeno_init_current_key_once, &init_current_key);
-
 #ifdef CONFIG_XENO_FASTSEM
 	/* In case we forked, we need to map the new local semaphore heap */
 	if (xeno_sem_heap[0])

@@ -244,8 +248,6 @@ xeno_bind_skin_opt(unsigned skin_magic,
 	xeno_arch_features_check();
 #endif /* xeno_arch_features_check */
 
-	pthread_once(&xeno_init_current_key_once, &init_current_key);
-
 #ifdef CONFIG_XENO_FASTSEM
 	/* In case we forked, we need to map the new local semaphore heap */
 	if (xeno_sem_heap[0])

Index: b/ksrc/skins/native/task.c
===================================================================
@@ -283,11 +283,9 @@ int rt_task_create(RT_TASK *task,
 	   complete objects, so that the registry cannot return handles to
 	   half-baked objects... */
 
-	if (name) {
-		err = xnthread_register(&task->thread_base, task->rname);
-		if (err)
-			xnpod_delete_thread(&task->thread_base);
-	}
+	err = xnthread_register(&task->thread_base, name ? task->rname : "");
+	if (err)
+		xnpod_delete_thread(&task->thread_base);
 
 	return err;
 }

Index: b/ksrc/skins/uitron/task.c
===================================================================
@@ -16,7 +16,6 @@
  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  */
 
-#include <nucleus/registry.h>
 #include <nucleus/pod.h>
 #include <nucleus/heap.h>
 #include <uitron/task.h>

@@ -151,6 +150,16 @@ ER cre_tsk(ID tskid, T_CTSK *pk_ctsk)
 	xnlock_put_irqrestore(&nklock, s);
 	task->magic = uITRON_TASK_MAGIC;
 
+#ifdef CONFIG_XENO_FASTSEM
+	/* We need an anonymous registry entry to obtain a handle for fast
+	   mutex locking. */
+	if (xnthread_register(&task->threadbase, "")) {
+		xnmap_remove(ui_task_idmap, tskid);
+		xnpod_abort_thread(&task->threadbase);
+		return E_NOMEM;
+	}
+#endif /* CONFIG_XENO_FASTSEM */
+
 	return E_OK;
 }
 

Index: b/ksrc/skins/rtai/task.c
===================================================================
@@ -152,6 +152,16 @@ int rt_task_init(RT_TASK *task,
 	task->magic = RTAI_TASK_MAGIC;
 	appendq(&__rtai_task_q, &task->link);
 
+#ifdef CONFIG_XENO_FASTSEM
+	/* We need an anonymous registry entry to obtain a handle for fast
+	   mutex locking. */
+	err = xnthread_register(&task->thread_base, "");
+	if (err) {
+		xnpod_abort_thread(&task->thread_base);
+		goto unlock_and_exit;
+	}
+#endif /* CONFIG_XENO_FASTSEM */
+
 	/* Add a switch hook only if a signal function has been declared
 	   at least once for some created task. */
 

Index: b/ksrc/skins/vrtx/task.c
===================================================================
@@ -188,12 +188,25 @@ int sc_tecreate_inner(vrtxtask_t *task,
 	if (mode & 0x10)
 		bmode |= XNRRB;
 
-	*errp = RET_OK;
-
 	xnlock_get_irqsave(&nklock, s);
 	appendq(&vrtx_task_q, &task->link);
 	xnlock_put_irqrestore(&nklock, s);
 
+#ifdef CONFIG_XENO_FASTSEM
+	/* We need an anonymous registry entry to obtain a handle for fast
+	   mutex locking. */
+	{
+		int err = xnthread_register(&task->threadbase, "");
+		if (err) {
+			xnpod_abort_thread(&task->threadbase);
+			*errp = ER_MEM;
+			return -1;
+		}
+	}
+#endif /* CONFIG_XENO_FASTSEM */
+
+	*errp = RET_OK;
+
 	xnpod_start_thread(&task->threadbase,
 			   bmode, 0, XNPOD_ALL_CPUS, &vrtxtask_trampoline,
 			   task);

Index: b/ksrc/skins/rtdm/drvlib.c
===================================================================
@@ -145,6 +145,14 @@ int rtdm_task_init(rtdm_task_t *task, co
 	if (err)
 		return err;
 
+#ifdef CONFIG_XENO_FASTSEM
+	/* We need an anonymous registry entry to obtain a handle for fast
+	   mutex locking. */
+	err = xnthread_register(task, "");
+	if (err)
+		goto cleanup_out;
+#endif /* CONFIG_XENO_FASTSEM */
+
 	if (period > 0) {
 		err = xnpod_set_thread_periodic(task, XN_INFINITE,
 						xntbase_ns2ticks_ceil

Index: b/include/asm-arm/atomic.h
===================================================================
@@ -412,9 +412,6 @@ static __inline__ void xnarch_atomic_cle
 
 typedef unsigned long atomic_flags_t;
 
-/* Add support for xnarch_atomic_intptr_t */
-#include <asm-generic/xenomai/atomic.h>
-
 #endif /* !_XENO_ASM_ARM_ATOMIC_H */
 
 // vim: ts=4 et sw=4 sts=4

Index: b/include/asm-blackfin/atomic.h
===================================================================
@@ -42,8 +42,6 @@
 typedef atomic_t atomic_counter_t;
 typedef atomic_t xnarch_atomic_t;
 
-#include <asm-generic/xenomai/atomic.h>
-
 #else /* !__KERNEL__ */
 
 #include <asm/xenomai/syscall.h>

Index: b/include/asm-generic/atomic.h
===================================================================
@@ -1,24 +0,0 @@
-#ifndef _XENO_ASM_GENERIC_ATOMIC_H
-#define _XENO_ASM_GENERIC_ATOMIC_H
-
-typedef xnarch_atomic_t xnarch_atomic_intptr_t;
-
-static inline void *xnarch_atomic_intptr_get(xnarch_atomic_intptr_t *l)
-{
-        xnarch_atomic_t *v = (xnarch_atomic_t *)l;
-
-        return (void *)xnarch_atomic_get(v);
-}
-
-static inline void xnarch_atomic_intptr_set(xnarch_atomic_intptr_t *l, void *i)
-{
-        xnarch_atomic_t *v = (xnarch_atomic_t *)l;
-
-        xnarch_atomic_set(v, (long)i);
-}
-
-#define xnarch_atomic_intptr_cmpxchg(l, old, newval) \
-        (void *)(xnarch_atomic_cmpxchg((xnarch_atomic_t *)(l), \
-				       (long)(old), (long)(newval)))
-
-#endif /* _XENO_ASM_GENERIC_ATOMIC_H */

Index: b/include/asm-ia64/atomic.h
===================================================================
@@ -71,8 +71,6 @@ static inline void atomic_clear_mask(uns
 #define xnarch_atomic_cmpxchg(pcounter,old,new) \
 	cmpxchg((&(pcounter)->counter),(old),(new))
 
-#include <asm-generic/xenomai/atomic.h>
-
 #else /* !__KERNEL__ */
 
 #include <asm/xenomai/features.h>

Index: b/include/asm-powerpc/atomic.h
===================================================================
@@ -262,6 +262,4 @@ xnarch_atomic_cmpxchg(xnarch_atomic_t *p
 
 typedef unsigned long atomic_flags_t;
 
-#include <asm-generic/xenomai/atomic.h>
-
 #endif /* !_XENO_ASM_POWERPC_ATOMIC_H */

Index: b/include/asm-x86/atomic.h
===================================================================
@@ -136,6 +136,4 @@ xnarch_atomic_cmpxchg(xnarch_atomic_t *v
 
 #endif /* __KERNEL__ */
 
-#include <asm-generic/xenomai/atomic.h>
-
 #endif /* !_XENO_ASM_X86_ATOMIC_64_H */

Index: b/src/skins/native/task.c
===================================================================
@@ -26,6 +26,7 @@
 #include <limits.h>
 #include <native/syscall.h>
 #include <native/task.h>
+#include <asm-generic/bits/current.h>
 #include "wrappers.h"
 
 extern pthread_key_t __native_tskey;

@@ -88,6 +89,8 @@ static void *rt_task_trampoline(void *co
 	if (err)
 		goto fail;
 
+	xeno_set_current();
+
 	/* Wait on the barrier for the task to be started. The barrier
 	   could be released in order to process Linux signals while the
 	   Xenomai shadow is still dormant; in such a case, resume wait. */

@@ -169,6 +172,7 @@ int rt_task_shadow(RT_TASK *task, const
 	struct sched_param param;
 	struct rt_arg_bulk bulk;
 	RT_TASK task_desc;
+	int err;
 
 	if (task == NULL)
 		task = &task_desc; /* Discarded. */

@@ -191,8 +195,13 @@ int rt_task_shadow(RT_TASK *task, const
 	bulk.a4 = (u_long)mode;
 	bulk.a5 = (u_long)pthread_self();
 
-	return XENOMAI_SKINCALL2(__native_muxid, __native_task_create, &bulk,
-				 NULL);
+	err = XENOMAI_SKINCALL2(__native_muxid, __native_task_create, &bulk,
+				NULL);
+
+	if (!err)
+		xeno_set_current();
+
+	return err;
 }
 
 int rt_task_bind(RT_TASK *task, const char *name, RTIME timeout)

Index: b/src/skins/psos+/task.c
===================================================================
@@ -26,6 +26,7 @@
 #include <memory.h>
 #include <string.h>
 #include <psos+/psos.h>
+#include <asm-generic/bits/current.h>
 
 extern int __psos_muxid;
 

@@ -89,6 +90,8 @@ static void *psos_task_trampoline(void *
 	if (err)
 		goto fail;
 
+	xeno_set_current();
+
 	/* Wait on the barrier for the task to be started. The barrier
 	   could be released in order to process Linux signals while the
 	   Xenomai shadow is still dormant; in such a case, resume wait. */

@@ -173,14 +176,21 @@ u_long t_shadow(const char *name, /* Xen
 		u_long flags,
 		u_long *tid_r)
 {
+	int err;
+
 	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
 
 	old_sigharden_handler = signal(SIGHARDEN, &psos_task_sigharden);
 
-	return XENOMAI_SKINCALL5(__psos_muxid,
-				 __psos_t_create,
-				 name, prio, flags,
-				 tid_r, NULL);
+	err = XENOMAI_SKINCALL5(__psos_muxid,
+				__psos_t_create,
+				name, prio, flags,
+				tid_r, NULL);
+
+	if (!err)
+		xeno_set_current();
+
+	return err;
 }
 
 u_long t_start(u_long tid,

Index: b/src/skins/uitron/task.c
===================================================================
@@ -25,6 +25,7 @@
 #include <limits.h>
 #include <asm/xenomai/system.h>
 #include <uitron/uitron.h>
+#include <asm-generic/bits/current.h>
 
 extern int __uitron_muxid;
 

@@ -89,6 +90,8 @@ static void *uitron_task_trampoline(void
 	if (err)
 		goto fail;
 
+	xeno_set_current();
+
 	/* iargs->pk_ctsk might not be valid anymore, after our parent
 	   was released from the completion sync, so do not
 	   dereference this pointer. */

@@ -150,7 +153,7 @@ ER cre_tsk(ID tskid, T_CTSK *pk_ctsk)
 ER shd_tsk(ID tskid, T_CTSK *pk_ctsk) /* Xenomai extension. */
 {
 	struct sched_param param;
-	int policy;
+	int policy, err;
 	
 	/* Make sure the POSIX library caches the right priority. */
 	policy = uitron_task_set_posix_priority(pk_ctsk->itskpri, &param);

@@ -160,10 +163,15 @@ ER shd_tsk(ID tskid, T_CTSK *pk_ctsk) /*
 
 	old_sigharden_handler = signal(SIGHARDEN, &uitron_task_sigharden);
 
-	return XENOMAI_SKINCALL3(__uitron_muxid,
-				 __uitron_cre_tsk,
-				 tskid, pk_ctsk,
-				 NULL);
+	err = XENOMAI_SKINCALL3(__uitron_muxid,
+				__uitron_cre_tsk,
+				tskid, pk_ctsk,
+				NULL);
+
+	if (!err)
+		xeno_set_current();
+
+	return err;
 }
 
 ER del_tsk(ID tskid)

Index: b/src/skins/vrtx/task.c
===================================================================
@@ -27,6 +27,7 @@
 #include <errno.h>
 #include <limits.h>
 #include <vrtx/vrtx.h>
+#include <asm-generic/bits/current.h>
 
 extern pthread_key_t __vrtx_tskey;
 

@@ -116,6 +117,8 @@ static void *vrtx_task_trampoline(void *
 	if (err)
 		goto fail;
 
+	xeno_set_current();
+
 	/* Wait on the barrier for the task to be started. The barrier
 	   could be released in order to process Linux signals while the
 	   Xenomai shadow is still dormant; in such a case, resume wait. */

Index: b/src/skins/vxworks/taskLib.c
===================================================================
@@ -27,6 +27,7 @@
 #include <errno.h>
 #include <limits.h>
 #include <vxworks/vxworks.h>
+#include <asm-generic/bits/current.h>
 #include "wrappers.h"
 
 extern pthread_key_t __vxworks_tskey;

@@ -117,6 +118,8 @@ static void *wind_task_trampoline(void *
 	if (err)
 		goto fail;
 
+	xeno_set_current();
+
 	/* Wait on the barrier for the task to be started. The barrier
 	   could be released in order to process Linux signals while the
 	   Xenomai shadow is still dormant; in such a case, resume wait. */

Index: b/include/nucleus/synch.h
===================================================================
@@ -30,10 +30,11 @@
 #define XNSYNCH_NOPIP   0x0
 #define XNSYNCH_PIP     0x2
 #define XNSYNCH_DREORD  0x4
+#define XNSYNCH_OWNER   0x8
 
 #if defined(__KERNEL__) || defined(__XENO_SIM__)
 
-#define XNSYNCH_CLAIMED 0x8	/* Claimed by other thread(s) w/ PIP */
+#define XNSYNCH_CLAIMED 0x10	/* Claimed by other thread(s) w/ PIP */
 
 /* Spare flags usable by upper interfaces */
 #define XNSYNCH_SPARE0  0x01000000

@@ -105,13 +106,18 @@ void xnsynch_sleep_on(xnsynch_t *synch,
 
 struct xnthread *xnsynch_wakeup_one_sleeper(xnsynch_t *synch);
 
-struct xnthread *xnsynch_peek_pendq(xnsynch_t *synch);
-
 xnpholder_t *xnsynch_wakeup_this_sleeper(xnsynch_t *synch,
 					 xnpholder_t *holder);
 
-int xnsynch_flush(xnsynch_t *synch,
-		  xnflags_t reason);
+void xnsynch_acquire(xnsynch_t *synch,
+		     xnticks_t timeout,
+		     xntmode_t timeout_mode);
+
+struct xnthread *xnsynch_release(xnsynch_t *synch);
+
+struct xnthread *xnsynch_peek_pendq(xnsynch_t *synch);
+
+int xnsynch_flush(xnsynch_t *synch, xnflags_t reason);
 
 void xnsynch_release_all_ownerships(struct xnthread *thread);
 

527 lines not on this page · raw message

Index: b/include/rtdm/rtdm_driver.h
===================================================================
@@ -1134,7 +1134,7 @@ static inline void rtdm_mutex_unlock(rtd
 
 	trace_mark(xn_rtdm_mutex_unlock, "mutex %p", mutex);
 
-	if (unlikely(xnsynch_wakeup_one_sleeper(&mutex->synch_base) != NULL))
+	if (unlikely(xnsynch_release(&mutex->synch_base) != NULL))
 		xnpod_schedule();
 }
 

Index: b/ksrc/skins/native/cond.c
===================================================================
@@ -421,7 +421,7 @@ int rt_cond_wait_inner(RT_COND *cond, RT
 
 	mutex->lockcnt = 0;
 
-	if (xnsynch_wakeup_one_sleeper(&mutex->synch_base)) {
+	if (xnsynch_release(&mutex->synch_base)) {
 		mutex->lockcnt = 1;
 		/* Scheduling deferred */
 	}

Index: b/ksrc/skins/native/mutex.c
===================================================================
@@ -170,7 +170,8 @@ int rt_mutex_create(RT_MUTEX *mutex, con
 	if (xnpod_asynch_p())
 		return -EPERM;
 
-	xnsynch_init(&mutex->synch_base, XNSYNCH_PRIO | XNSYNCH_PIP);
+	xnsynch_init(&mutex->synch_base,
+		     XNSYNCH_PRIO | XNSYNCH_PIP | XNSYNCH_OWNER);
 	mutex->handle = 0;	/* i.e. (still) unregistered mutex. */
 	mutex->magic = XENO_MUTEX_MAGIC;
 	mutex->lockcnt = 0;

@@ -309,7 +310,7 @@ int rt_mutex_acquire_inner(RT_MUTEX *mut
 		goto unlock_and_exit;
 	}
 
-	xnsynch_sleep_on(&mutex->synch_base, timeout, timeout_mode);
+	xnsynch_acquire(&mutex->synch_base, timeout, timeout_mode);
 
 	if (xnthread_test_info(thread, XNRMID))
 		err = -EIDRM;	/* Mutex deleted while pending. */

@@ -523,7 +524,7 @@ int rt_mutex_release(RT_MUTEX *mutex)
 	if (--mutex->lockcnt > 0)
 		goto unlock_and_exit;
 
-	if (xnsynch_wakeup_one_sleeper(&mutex->synch_base)) {
+	if (xnsynch_release(&mutex->synch_base)) {
 		mutex->lockcnt = 1;
 		xnpod_schedule();
 	}

Index: b/ksrc/skins/native/task.c
===================================================================
@@ -269,7 +269,8 @@ int rt_task_create(RT_TASK *task,
 
 #ifdef CONFIG_XENO_OPT_NATIVE_MPS
 	xnsynch_init(&task->mrecv, XNSYNCH_FIFO);
-	xnsynch_init(&task->msendq, XNSYNCH_PRIO | XNSYNCH_PIP);
+	xnsynch_init(&task->msendq,
+		     XNSYNCH_PRIO | XNSYNCH_PIP | XNSYNCH_OWNER);
 	xnsynch_set_owner(&task->msendq, &task->thread_base);
 	task->flowgen = 0;
 #endif /* CONFIG_XENO_OPT_NATIVE_MPS */

@@ -1773,7 +1774,7 @@ ssize_t rt_task_send(RT_TASK *task,
 	   client in the case required by the priority inheritance
 	   protocol (i.e. prio(client) > prio(server)). */
 
-	xnsynch_sleep_on(&task->msendq, timeout, XN_RELATIVE);
+	xnsynch_acquire(&task->msendq, timeout, XN_RELATIVE);
 
 	/* At this point, the server task might have exited right
 	 * after having replied to us, so do not make optimistic

Index: b/ksrc/skins/posix/cond.c
===================================================================
@@ -240,7 +240,7 @@ static inline int mutex_save_count(xnthr
 		   xnthread_handle(cur)))
 		return 0;
 
-	owner = xnsynch_wakeup_one_sleeper(&mutex->synchbase);
+	owner = xnsynch_release(&mutex->synchbase);
 	xnarch_atomic_set(mutex->owner,
 			  set_claimed(xnthread_handle(owner),
 				      xnsynch_nsleepers(&mutex->synchbase)));

Index: b/ksrc/skins/posix/mutex.c
===================================================================
@@ -85,7 +85,7 @@ int pse51_mutex_init_internal(struct __s
 			      xnarch_atomic_t *ownerp,
 			      const pthread_mutexattr_t *attr)
 {
-	xnflags_t synch_flags = XNSYNCH_PRIO | XNSYNCH_NOPIP;
+	xnflags_t synch_flags = XNSYNCH_PRIO | XNSYNCH_OWNER;
 	struct xnsys_ppd *sys_ppd;
 	pse51_kqueues_t *kq;
 	spl_t s;

@@ -307,11 +307,11 @@ int pse51_mutex_timedlock_break(struct _
 		for (;;) {
 			++mutex->sleepers;
 			if (timed)
-				xnsynch_sleep_on(&mutex->synchbase,
-						 abs_to, XN_REALTIME);
+				xnsynch_acquire(&mutex->synchbase,
+						abs_to, XN_REALTIME);
 			else
-				xnsynch_sleep_on(&mutex->synchbase,
-						 XN_INFINITE, XN_RELATIVE);
+				xnsynch_acquire(&mutex->synchbase,
+						XN_INFINITE, XN_RELATIVE);
 			--mutex->sleepers;
 
 			if (xnthread_test_info(cur, XNBREAK)) {

Index: b/ksrc/skins/posix/mutex.h
===================================================================
@@ -170,9 +170,9 @@ static inline int pse51_mutex_timedlock_
 	xnsynch_set_owner(&mutex->synchbase, owner);
 	++mutex->sleepers;
 	if (timed)
-		xnsynch_sleep_on(&mutex->synchbase, abs_to, XN_REALTIME);
+		xnsynch_acquire(&mutex->synchbase, abs_to, XN_REALTIME);
 	else
-		xnsynch_sleep_on(&mutex->synchbase, XN_INFINITE, XN_RELATIVE);
+		xnsynch_acquire(&mutex->synchbase, XN_INFINITE, XN_RELATIVE);
 	--mutex->sleepers;
 
 	if (xnthread_test_info(cur, XNBREAK)) {

@@ -216,7 +216,7 @@ static inline void pse51_mutex_unlock_in
 		return;
 
 	xnlock_get_irqsave(&nklock, s);
-	owner = xnsynch_wakeup_one_sleeper(&mutex->synchbase);
+	owner = xnsynch_release(&mutex->synchbase);
 	ownerh = set_claimed(xnthread_handle(owner), mutex->sleepers);
 	xnarch_atomic_set(mutex->owner, ownerh);
 	if (owner)

Index: b/ksrc/skins/rtai/sem.c
===================================================================
@@ -28,7 +28,7 @@ void rt_typed_sem_init(SEM * sem, int va
 	int mode = XNSYNCH_PRIO;
 
 	if ((type & RES_SEM) == RES_SEM) {
-		mode |= XNSYNCH_PIP;
+		mode |= XNSYNCH_PIP | XNSYNCH_OWNER;
 		value = 0;	/* We will use this as a lock count. */
 	} else {
 		if ((type & BIN_SEM) && value > 1)

@@ -98,7 +98,7 @@ int rt_sem_signal(SEM * sem)
 			goto unlock_and_exit;
 
 		sem->owner =
-		    thread2rtask(xnsynch_wakeup_one_sleeper(&sem->synch_base));
+		    thread2rtask(xnsynch_release(&sem->synch_base));
 
 		if (sem->owner != NULL)
 			xnpod_schedule();

@@ -141,12 +141,12 @@ int rt_sem_wait(SEM * sem)
 			err = ++sem->count;
 			goto unlock_and_exit;
 		}
+		xnsynch_acquire(&sem->synch_base, XN_INFINITE, XN_RELATIVE);
 	} else if (sem->count > 0) {
 		err = sem->count--;
 		goto unlock_and_exit;
-	}
-
-	xnsynch_sleep_on(&sem->synch_base, XN_INFINITE, XN_RELATIVE);
+	} else
+		xnsynch_sleep_on(&sem->synch_base, XN_INFINITE, XN_RELATIVE);
 
 	if (xnthread_test_info(&task->thread_base, XNRMID))
 		err = SEM_ERR;	/* Semaphore deleted while pending. */

Index: b/ksrc/skins/rtdm/drvlib.c
===================================================================
@@ -1390,7 +1390,8 @@ void rtdm_mutex_init(rtdm_mutex_t *mutex
 	/* Make atomic for re-initialisation support */
 	xnlock_get_irqsave(&nklock, s);
 
-	xnsynch_init(&mutex->synch_base, XNSYNCH_PRIO | XNSYNCH_PIP);
+	xnsynch_init(&mutex->synch_base,
+		     XNSYNCH_PRIO | XNSYNCH_PIP | XNSYNCH_OWNER);
 
 	xnlock_put_irqrestore(&nklock, s);
 }

@@ -1534,14 +1535,14 @@ int rtdm_mutex_timedlock(rtdm_mutex_t *m
 restart:
 		if (timeout_seq && (timeout > 0)) {
 			/* timeout sequence */
-			xnsynch_sleep_on(&mutex->synch_base, *timeout_seq,
-					 XN_ABSOLUTE);
+			xnsynch_acquire(&mutex->synch_base, *timeout_seq,
+					XN_ABSOLUTE);
 		} else {
 			/* infinite or relative timeout */
-			xnsynch_sleep_on(&mutex->synch_base,
-					 xntbase_ns2ticks_ceil
-					 (xnthread_time_base(curr_thread),
-					  timeout), XN_RELATIVE);
+			xnsynch_acquire(&mutex->synch_base,
+					xntbase_ns2ticks_ceil
+					(xnthread_time_base(curr_thread),
+					 timeout), XN_RELATIVE);
 		}
 
 		if (unlikely(xnthread_test_info(curr_thread,

Index: b/ksrc/skins/vrtx/mx.c
===================================================================
@@ -161,7 +161,7 @@ int sc_mcreate(unsigned int opt, int *er
 	inith(&mx->link);
 	mx->mid = mid;
 	mx->owner = NULL;
-	xnsynch_init(&mx->synchbase, bflags | XNSYNCH_DREORD);
+	xnsynch_init(&mx->synchbase, bflags | XNSYNCH_DREORD | XNSYNCH_OWNER);
 
 	xnlock_get_irqsave(&nklock, s);
 	appendq(&vrtx_mx_q, &mx->link);

@@ -192,7 +192,7 @@ void sc_mpost(int mid, int *errp)
 	}
 
 	/* Undefined behaviour if the poster does not own the mutex. */
-	mx->owner = xnsynch_wakeup_one_sleeper(&mx->synchbase);
+	mx->owner = xnsynch_release(&mx->synchbase);
 
 	*errp = RET_OK;
 

@@ -267,7 +267,7 @@ void sc_mpend(int mid, unsigned long tim
 		if (timeout)
 			task->vrtxtcb.TCBSTAT |= TBSDELAY;
 
-		xnsynch_sleep_on(&mx->synchbase, timeout, XN_RELATIVE);
+		xnsynch_acquire(&mx->synchbase, timeout, XN_RELATIVE);
 
 		if (xnthread_test_info(&task->threadbase, XNBREAK))
 			*errp = -EINTR;

Index: b/ksrc/skins/vxworks/semLib.c
===================================================================
@@ -138,7 +138,7 @@ SEM_ID semCCreate(int flags, int count)
 
 SEM_ID semMCreate(int flags)
 {
-	int bflags = 0;
+	int bflags = XNSYNCH_OWNER;
 
 	error_check(flags & ~WIND_SEMM_OPTION_MASK, S_semLib_INVALID_QUEUE_TYPE,
 		    return 0);

@@ -346,7 +346,7 @@ static STATUS semm_take(wind_sem_t *sem,
 	error_check(to == XN_NONBLOCK, S_objLib_OBJ_UNAVAILABLE,
 		    return ERROR);
 
-	xnsynch_sleep_on(&sem->synchbase, to, XN_RELATIVE);
+	xnsynch_acquire(&sem->synchbase, to, XN_RELATIVE);
 
 	error_check(xnthread_test_info(cur, XNBREAK),
 		    -EINTR, return ERROR);

@@ -385,7 +385,7 @@ static STATUS semm_give(wind_sem_t *sem)
 	if (--sem->count > 0)
 		return OK;
 
-	if (xnsynch_wakeup_one_sleeper(&sem->synchbase)) {
+	if (xnsynch_release(&sem->synchbase)) {
 		sem->count = 1;
 		resched = 1;
 	}

Index: b/ksrc/skins/native/cond.c
===================================================================
@@ -421,10 +421,8 @@ int rt_cond_wait_inner(RT_COND *cond, RT
 
 	mutex->lockcnt = 0;
 
-	if (xnsynch_release(&mutex->synch_base)) {
-		mutex->lockcnt = 1;
-		/* Scheduling deferred */
-	}
+	xnsynch_release(&mutex->synch_base);
+	/* Scheduling deferred */
 
 	xnsynch_sleep_on(&cond->synch_base, timeout, timeout_mode);
 

Index: b/ksrc/skins/native/mutex.c
===================================================================
@@ -320,8 +320,6 @@ int rt_mutex_acquire_inner(RT_MUTEX *mut
 		err = -EINTR;	/* Unblocked. */
 	else {
 	      grab_mutex:
-		/* xnsynch_sleep_on() might have stolen the resource,
-		   so we need to put our internal data in sync. */
 		mutex->lockcnt = 1;
 	}
 

@@ -524,10 +522,8 @@ int rt_mutex_release(RT_MUTEX *mutex)
 	if (--mutex->lockcnt > 0)
 		goto unlock_and_exit;
 
-	if (xnsynch_release(&mutex->synch_base)) {
-		mutex->lockcnt = 1;
+	if (xnsynch_release(&mutex->synch_base))
 		xnpod_schedule();
-	}
 
       unlock_and_exit:
 

@@ -584,7 +580,7 @@ int rt_mutex_inquire(RT_MUTEX *mutex, RT
 	strcpy(info->name, mutex->name);
 	info->lockcnt = mutex->lockcnt;
 	info->nwaiters = xnsynch_nsleepers(&mutex->synch_base);
-	if (mutex->lockcnt)
+	if (xnsynch_owner(&mutex->synch_base))
 		strcpy(info->owner,
 		       xnthread_name(xnsynch_owner(&mutex->synch_base)));
 	else

Index: b/include/asm-generic/bits/bind.h
===================================================================
@@ -42,14 +42,14 @@ void init_current_key(void)
 	}
 }
 
-#ifdef CONFIG_XENO_FASTSEM
+#ifdef CONFIG_XENO_FASTSYNCH
 __attribute__ ((weak))
 unsigned long xeno_sem_heap[2] = { 0, 0 };
-#endif /* CONFIG_XENO_FASTSEM */
+#endif /* CONFIG_XENO_FASTSYNCH */
 
 void xeno_handle_mlock_alert(int sig);
 
-#ifdef CONFIG_XENO_FASTSEM
+#ifdef CONFIG_XENO_FASTSYNCH
 static void *map_sem_heap(unsigned shared)
 {
 	struct heap_info {

@@ -103,7 +103,7 @@ static void unmap_sem_heap(unsigned long
 
 	munmap((void *) heap_addr, hinfo.size);
 }
-#endif /* CONFIG_XENO_FASTSEM */
+#endif /* CONFIG_XENO_FASTSYNCH */
 
 void __attribute__((weak)) xeno_sigill_handler(int sig)
 {

@@ -174,7 +174,7 @@ xeno_bind_skin(unsigned skin_magic, cons
 	sa.sa_flags = 0;
 	sigaction(SIGXCPU, &sa, NULL);
 
-#ifdef CONFIG_XENO_FASTSEM
+#ifdef CONFIG_XENO_FASTSYNCH
 	/* In case we forked, we need to map the new local semaphore heap */
 	if (xeno_sem_heap[0])
 		unmap_sem_heap(xeno_sem_heap[0], 0);

@@ -193,7 +193,7 @@ xeno_bind_skin(unsigned skin_magic, cons
 			exit(EXIT_FAILURE);
 		}
 	}
-#endif /* CONFIG_XENO_FASTSEM */
+#endif /* CONFIG_XENO_FASTSYNCH */
 
 	return muxid;
 }

@@ -248,7 +248,7 @@ xeno_bind_skin_opt(unsigned skin_magic,
 	xeno_arch_features_check();
 #endif /* xeno_arch_features_check */
 
-#ifdef CONFIG_XENO_FASTSEM
+#ifdef CONFIG_XENO_FASTSYNCH
 	/* In case we forked, we need to map the new local semaphore heap */
 	if (xeno_sem_heap[0])
 		unmap_sem_heap(xeno_sem_heap[0], 0);

@@ -267,7 +267,7 @@ xeno_bind_skin_opt(unsigned skin_magic,
 			exit(EXIT_FAILURE);
 		}
 	}
-#endif /* CONFIG_XENO_FASTSEM */
+#endif /* CONFIG_XENO_FASTSYNCH */
 
 	return muxid;
 }

Index: b/include/asm-generic/features.h
===================================================================
@@ -25,9 +25,9 @@
 #include <xeno_config.h>
 #endif /* __KERNEL__ */
 
-#define __xn_feat_smp       0x80000000
-#define __xn_feat_fastsem   0x40000000
-#define __xn_feat_nofastsem 0x20000000
+#define __xn_feat_smp         0x80000000
+#define __xn_feat_fastsynch   0x40000000
+#define __xn_feat_nofastsynch 0x20000000
 
 #ifdef CONFIG_SMP
 #define __xn_feat_smp_mask __xn_feat_smp

@@ -35,25 +35,25 @@
 #define __xn_feat_smp_mask 0
 #endif
 
-#ifdef CONFIG_XENO_FASTSEM
-#define __xn_feat_fastsem_mask __xn_feat_fastsem
+#ifdef CONFIG_XENO_FASTSYNCH
+#define __xn_feat_fastsynch_mask __xn_feat_fastsynch
 #else
-#define __xn_feat_fastsem_mask __xn_feat_nofastsem
+#define __xn_feat_fastsynch_mask __xn_feat_nofastsynch
 #endif
 
-#define __xn_feat_generic_mask     (__xn_feat_smp_mask | __xn_feat_fastsem_mask)
+#define __xn_feat_generic_mask     (__xn_feat_smp_mask | __xn_feat_fastsynch_mask)
 
-#define __xn_feat_generic_man_mask (__xn_feat_fastsem | __xn_feat_nofastsem)
+#define __xn_feat_generic_man_mask (__xn_feat_fastsynch | __xn_feat_nofastsynch)
 
 static inline const char *get_generic_feature_label (unsigned feature)
 {
     switch (feature) {
     	case __xn_feat_smp:
 	    return "smp";
-        case __xn_feat_fastsem:
-	    return "fastsem";
-        case __xn_feat_nofastsem:
-	    return "nofastsem";
+        case __xn_feat_fastsynch:
+	    return "fastsynch";
+        case __xn_feat_nofastsynch:
+	    return "nofastsynch";
     	default:
 	    return 0;
     }

84 lines not on this page · raw message

Index: b/ksrc/skins/posix/cb_lock.h
===================================================================
@@ -20,7 +20,7 @@ typedef void xnthread_t;
 	__tmp; \
 })
 
-#ifdef CONFIG_XENO_FASTSEM
+#ifdef CONFIG_XENO_FASTSYNCH
 
 static  __inline__ int __cb_try_read_lock(xnarch_atomic_t *lock)
 {

@@ -68,7 +68,7 @@ static __inline__ void __cb_write_unlock
 #define cb_try_write_lock(lock, flags) __cb_try_write_lock(lock)
 #define cb_force_write_lock(lock, flags) __cb_force_write_lock(lock)
 #define cb_write_unlock(lock, flags) __cb_write_unlock(lock)
-#else /* !CONFIG_XENO_FASTSEM */
+#else /* !CONFIG_XENO_FASTSYNCH */
 #ifdef __KERNEL__
 #define DECLARE_CB_LOCK_FLAGS(name) spl_t name
 #define cb_try_read_lock(lock, flags) \

@@ -87,6 +87,6 @@ static __inline__ void __cb_write_unlock
 #define cb_force_write_lock(lock, flags) do { } while (0)
 #define cb_write_unlock(lock, flags) do { } while (0)
 #endif /* !__KERNEL__ */
-#endif /* !CONFIG_XENO_FASTSEM */
+#endif /* !CONFIG_XENO_FASTSYNCH */
 
 #endif /* CB_LOCK_H */

Index: b/ksrc/skins/posix/cond.c
===================================================================
@@ -142,7 +142,7 @@ int pthread_cond_init(pthread_cond_t * c
 	shadow->magic = PSE51_COND_MAGIC;
 	shadow->cond = cond;
 
-	xnsynch_init(&cond->synchbase, synch_flags);
+	xnsynch_init(&cond->synchbase, synch_flags, NULL);
 	inith(&cond->link);
 	cond->attr = *attr;
 	cond->mutex = NULL;

@@ -424,10 +424,10 @@ int pthread_cond_wait(pthread_cond_t * c
 	unsigned count;
 	int err;
 
-#ifdef CONFIG_XENO_FASTSEM
+#ifdef CONFIG_XENO_FASTSYNCH
 	if (unlikely(cb_try_read_lock(&mutex->lock, s)))
 		return EINVAL;
-#endif /* CONFIG_XENO_FASTSEM */
+#endif /* CONFIG_XENO_FASTSYNCH */
 
 	err = pse51_cond_timedwait_prologue(cur, cond, mutex,
 					    &count, 0, XN_INFINITE);

@@ -437,9 +437,9 @@ int pthread_cond_wait(pthread_cond_t * c
 							      mutex, count))
 			;
 
-#ifdef CONFIG_XENO_FASTSEM
+#ifdef CONFIG_XENO_FASTSYNCH
 	cb_read_unlock(&mutex->lock, s);
-#endif /* CONFIG_XENO_FASTSEM */
+#endif /* CONFIG_XENO_FASTSYNCH */
 
 	return err != EINTR ? err : 0;
 }

@@ -492,10 +492,10 @@ int pthread_cond_timedwait(pthread_cond_
 	unsigned count;
 	int err;
 
-#ifdef CONFIG_XENO_FASTSEM
+#ifdef CONFIG_XENO_FASTSYNCH
 	if (unlikely(cb_try_read_lock(&mutex->lock, s)))
 		return EINVAL;
-#endif /* CONFIG_XENO_FASTSEM */
+#endif /* CONFIG_XENO_FASTSYNCH */
 
 	err = pse51_cond_timedwait_prologue(cur, cond, mutex, &count, 1,
 					    ts2ticks_ceil(abstime) + 1);

@@ -505,9 +505,9 @@ int pthread_cond_timedwait(pthread_cond_
 							      mutex, count))
 			;
 
-#ifdef CONFIG_XENO_FASTSEM
+#ifdef CONFIG_XENO_FASTSYNCH
 	cb_read_unlock(&mutex->lock, s);
-#endif /* CONFIG_XENO_FASTSEM */
+#endif /* CONFIG_XENO_FASTSYNCH */
 
 	return err != EINTR ? err : 0;
 }

Index: b/ksrc/skins/posix/mutex.c
===================================================================
@@ -103,16 +103,16 @@ int pse51_mutex_init_internal(struct __s
 	shadow->mutex = mutex;
 	shadow->lockcnt = 0;
 
-#ifdef CONFIG_XENO_FASTSEM
+#ifdef CONFIG_XENO_FASTSYNCH
 	xnarch_atomic_set(&shadow->lock, -1);
 	shadow->attr = *attr;
 	shadow->owner_offset = xnheap_mapped_offset(&sys_ppd->sem_heap, ownerp);
-#endif /* CONFIG_XENO_FASTSEM */
+#endif /* CONFIG_XENO_FASTSYNCH */
 
 	if (attr->protocol == PTHREAD_PRIO_INHERIT)
 		synch_flags |= XNSYNCH_PIP;
 
-	xnsynch_init(&mutex->synchbase, synch_flags);
+	xnsynch_init(&mutex->synchbase, synch_flags, NULL);
 	inith(&mutex->link);
 	mutex->attr = *attr;
 	mutex->owner = ownerp;

@@ -169,16 +169,16 @@ int pthread_mutex_init(pthread_mutex_t *
 		goto checked;
 
 	err = pse51_mutex_check_init(shadow, attr);
-#ifndef CONFIG_XENO_FASTSEM
+#ifndef CONFIG_XENO_FASTSYNCH
 	cb_read_unlock(&shadow->lock, s);
 	if (err)
 		return -err;
-#else /* CONFIG_XENO_FASTSEM */
+#else /* CONFIG_XENO_FASTSYNCH */
 	if (err) {
 		cb_read_unlock(&shadow->lock, s);
 		return -err;
 	}
-#endif /* CONFIG_XENO_FASTSEM */
+#endif /* CONFIG_XENO_FASTSYNCH */
 
   checked:
 	mutex = (pse51_mutex_t *) xnmalloc(sizeof(*mutex));

Index: b/ksrc/skins/posix/mutex.h
===================================================================
@@ -30,14 +30,14 @@ union __xeno_mutex {
 		unsigned magic;
 		unsigned lockcnt;
 		struct pse51_mutex *mutex;
-#ifdef CONFIG_XENO_FASTSEM
+#ifdef CONFIG_XENO_FASTSYNCH
 		xnarch_atomic_t lock;
 		union {
 			unsigned owner_offset;
 			xnarch_atomic_t *owner;
 		};
 		struct pse51_mutexattr attr;
-#endif /* CONFIG_XENO_FASTSEM */
+#endif /* CONFIG_XENO_FASTSYNCH */
 	} shadow_mutex;
 };
 

Index: b/ksrc/skins/posix/syscall.c
===================================================================
@@ -886,7 +886,7 @@ static int __pthread_mutexattr_setpshare
 	return __xn_safe_copy_to_user((void __user *)uattrp, &attr, sizeof(*uattrp));
 }
 
-#ifndef CONFIG_XENO_FASTSEM
+#ifndef CONFIG_XENO_FASTSYNCH
 static int __pthread_mutex_init(struct pt_regs *regs)
 {
 	pthread_mutexattr_t locattr, *attr, *uattrp;

@@ -1088,7 +1088,7 @@ static int __pthread_mutex_unlock(struct
 
 	return err;
 }
-#else /* !CONFIG_XENO_FASTSEM */
+#else /* !CONFIG_XENO_FASTSYNCH */
 static int __pthread_mutex_check_init(struct pt_regs *regs)
 {
 	pthread_mutexattr_t locattr, *attr, *uattrp;

@@ -1279,7 +1279,7 @@ static int __pthread_mutex_unlock(struct
 
 	return 0;
 }
-#endif /* !CONFIG_XENO_FASTSEM */
+#endif /* !CONFIG_XENO_FASTSYNCH */
 
 static int __pthread_condattr_init(struct pt_regs *regs)
 {

@@ -1469,11 +1469,11 @@ static int __pthread_cond_wait_prologue(
 
 	if (__xn_safe_copy_from_user(&mx.shadow_mutex,
 				     (void __user *)&umx->shadow_mutex,
-#ifdef CONFIG_XENO_FASTSEM
+#ifdef CONFIG_XENO_FASTSYNCH
 				     offsetof(struct __shadow_mutex, lock)
-#else /* !CONFIG_XENO_FASTSEM */
+#else /* !CONFIG_XENO_FASTSYNCH */
 				     sizeof(mx.shadow_mutex)
-#endif /* !CONFIG_XENO_FASTSEM */
+#endif /* !CONFIG_XENO_FASTSYNCH */
 				     ))
 		return -EFAULT;
 

@@ -1537,11 +1537,11 @@ static int __pthread_cond_wait_epilogue(
 
 	if (__xn_safe_copy_from_user(&mx.shadow_mutex,
 				     (void __user *)&umx->shadow_mutex,
-#ifdef CONFIG_XENO_FASTSEM
+#ifdef CONFIG_XENO_FASTSYNCH
 				     offsetof(struct __shadow_mutex, lock)
-#else /* !CONFIG_XENO_FASTSEM */
+#else /* !CONFIG_XENO_FASTSYNCH */
 				     sizeof(mx.shadow_mutex)
-#endif /* !CONFIG_XENO_FASTSEM */
+#endif /* !CONFIG_XENO_FASTSYNCH */
 				     ))
 		return -EFAULT;
 

@@ -2695,7 +2695,7 @@ static xnsysent_t __systab[] = {
 	[__pse51_mutex_lock] = {&__pthread_mutex_lock, __xn_exec_primary},
 	[__pse51_mutex_timedlock] =
 	    {&__pthread_mutex_timedlock, __xn_exec_primary},
-#ifndef CONFIG_XENO_FASTSEM
+#ifndef CONFIG_XENO_FASTSYNCH
 	[__pse51_mutex_trylock] = {&__pthread_mutex_trylock, __xn_exec_primary},
 #else
         [__pse51_check_init] = {&__pthread_mutex_check_init, __xn_exec_any},

Index: b/ksrc/skins/posix/thread.c
===================================================================
@@ -209,7 +209,7 @@ int pthread_create(pthread_t *tid,
 	thread->magic = PSE51_THREAD_MAGIC;
 	thread->entry = start;
 	thread->arg = arg;
-	xnsynch_init(&thread->join_synch, XNSYNCH_PRIO);
+	xnsynch_init(&thread->join_synch, XNSYNCH_PRIO, NULL);
 	thread->nrt_joiners = 0;
 
 	pse51_cancel_init_thread(thread);

@@ -234,7 +234,7 @@ int pthread_create(pthread_t *tid,
 	thread->hkey.mm = NULL;
 #endif /* CONFIG_XENO_OPT_PERVASIVE */
 
-#ifdef CONFIG_XENO_FASTSEM
+#ifdef CONFIG_XENO_FASTSYNCH
 	/* We need an anonymous registry entry to obtain a handle for fast
 	   mutex locking. */
 	{

@@ -244,7 +244,7 @@ int pthread_create(pthread_t *tid,
 			return err;
 		}
 	}
-#endif /* CONFIG_XENO_FASTSEM */
+#endif /* CONFIG_XENO_FASTSYNCH */
 
 	*tid = thread;		/* Must be done before the thread is started. */
 

Index: b/ksrc/skins/rtai/task.c
===================================================================
@@ -152,7 +152,7 @@ int rt_task_init(RT_TASK *task,
 	task->magic = RTAI_TASK_MAGIC;
 	appendq(&__rtai_task_q, &task->link);
 
-#ifdef CONFIG_XENO_FASTSEM
+#ifdef CONFIG_XENO_FASTSYNCH
 	/* We need an anonymous registry entry to obtain a handle for fast
 	   mutex locking. */
 	err = xnthread_register(&task->thread_base, "");

@@ -160,7 +160,7 @@ int rt_task_init(RT_TASK *task,
 		xnpod_abort_thread(&task->thread_base);
 		goto unlock_and_exit;
 	}
-#endif /* CONFIG_XENO_FASTSEM */
+#endif /* CONFIG_XENO_FASTSYNCH */
 
 	/* Add a switch hook only if a signal function has been declared
 	   at least once for some created task. */

Index: b/ksrc/skins/uitron/task.c
===================================================================
@@ -150,7 +150,7 @@ ER cre_tsk(ID tskid, T_CTSK *pk_ctsk)
 	xnlock_put_irqrestore(&nklock, s);
 	task->magic = uITRON_TASK_MAGIC;
 
-#ifdef CONFIG_XENO_FASTSEM
+#ifdef CONFIG_XENO_FASTSYNCH
 	/* We need an anonymous registry entry to obtain a handle for fast
 	   mutex locking. */
 	if (xnthread_register(&task->threadbase, "")) {

@@ -158,7 +158,7 @@ ER cre_tsk(ID tskid, T_CTSK *pk_ctsk)
 		xnpod_abort_thread(&task->threadbase);
 		return E_NOMEM;
 	}
-#endif /* CONFIG_XENO_FASTSEM */
+#endif /* CONFIG_XENO_FASTSYNCH */
 
 	return E_OK;
 }

151 lines not on this page · raw message

Index: b/ksrc/nucleus/pipe.c
===================================================================
@@ -250,7 +250,7 @@ int xnpipe_connect(int minor,
 
 	__setbits(state->status, XNPIPE_KERN_CONN);
 
-	xnsynch_init(&state->synchbase, XNSYNCH_FIFO);
+	xnsynch_init(&state->synchbase, XNSYNCH_FIFO, NULL);
 	state->output_handler = output_handler;
 	state->input_handler = input_handler;
 	state->alloc_handler = alloc_handler;

Index: b/ksrc/nucleus/registry.c
===================================================================
@@ -186,7 +186,7 @@ int xnregistry_init(void)
 	for (n = 0; n < registry_hash_entries; n++)
 		registry_hash_table[n] = NULL;
 
-	xnsynch_init(&registry_hash_synch, XNSYNCH_FIFO);
+	xnsynch_init(&registry_hash_synch, XNSYNCH_FIFO, NULL);
 
 	return 0;
 }

@@ -615,7 +615,7 @@ int xnregistry_enter(const char *key,
 
 	object = link2xnobj(holder);
 
-	xnsynch_init(&object->safesynch, XNSYNCH_FIFO);
+	xnsynch_init(&object->safesynch, XNSYNCH_FIFO, NULL);
 	object->objaddr = objaddr;
 	object->cstamp = ++registry_obj_stamp;
 	object->safelock = 0;

Index: b/ksrc/nucleus/select.c
===================================================================
@@ -274,7 +274,7 @@ int xnselector_init(struct xnselector *s
 {
 	unsigned i;
 
-	xnsynch_init(&selector->synchbase, XNSYNCH_FIFO | XNSYNCH_NOPIP);
+	xnsynch_init(&selector->synchbase, XNSYNCH_FIFO, NULL);
 	for (i = 0; i < XNSELECT_MAX_TYPES; i++) {
 		__FD_ZERO(&selector->fds[i].expected);
 		__FD_ZERO(&selector->fds[i].pending);

209 lines not on this page · raw message

Index: b/ksrc/drivers/testing/switchtest.c
===================================================================
@@ -219,7 +219,7 @@ static int rtswitch_register_task(rtswit
 	ctx->next_index++;
 	t->base = *arg;
 	sema_init(&t->nrt_synch, 0);
-	xnsynch_init(&t->rt_synch, XNSYNCH_FIFO);
+	xnsynch_init(&t->rt_synch, XNSYNCH_FIFO, NULL);
 
 	up(&ctx->lock);
 

Index: b/ksrc/skins/native/alarm.c
===================================================================
@@ -207,7 +207,7 @@ int rt_alarm_create(RT_ALARM *alarm,
 	xnlock_put_irqrestore(&nklock, s);
 
 #ifdef CONFIG_XENO_OPT_PERVASIVE
-	xnsynch_init(&alarm->synch_base, XNSYNCH_PRIO);
+	xnsynch_init(&alarm->synch_base, XNSYNCH_PRIO, NULL);
 	alarm->cpid = 0;
 #endif /* CONFIG_XENO_OPT_PERVASIVE */
 

Index: b/ksrc/skins/native/buffer.c
===================================================================
@@ -192,8 +192,8 @@ int rt_buffer_create(RT_BUFFER *bf, cons
 	if (bf->bufmem == NULL)
 		return -ENOMEM;
 
-	xnsynch_init(&bf->isynch_base, mode & B_PRIO);
-	xnsynch_init(&bf->osynch_base, mode & B_PRIO);
+	xnsynch_init(&bf->isynch_base, mode & B_PRIO, NULL);
+	xnsynch_init(&bf->osynch_base, mode & B_PRIO, NULL);
 
 	bf->handle = 0;	/* i.e. (still) unregistered buffer. */
 	xnobject_copy_name(bf->name, name);

Index: b/ksrc/skins/native/cond.c
===================================================================
@@ -160,7 +160,7 @@ int rt_cond_create(RT_COND *cond, const
 	if (xnpod_asynch_p())
 		return -EPERM;
 
-	xnsynch_init(&cond->synch_base, XNSYNCH_PRIO);
+	xnsynch_init(&cond->synch_base, XNSYNCH_PRIO, NULL);
 	cond->handle = 0;	/* i.e. (still) unregistered cond. */
 	cond->magic = XENO_COND_MAGIC;
 	xnobject_copy_name(cond->name, name);

Index: b/ksrc/skins/native/event.c
===================================================================
@@ -183,7 +183,7 @@ int rt_event_create(RT_EVENT *event,
 	if (xnpod_asynch_p())
 		return -EPERM;
 
-	xnsynch_init(&event->synch_base, mode & EV_PRIO);
+	xnsynch_init(&event->synch_base, mode & EV_PRIO, NULL);
 	event->value = ivalue;
 	event->handle = 0;	/* i.e. (still) unregistered event. */
 	event->magic = XENO_EVENT_MAGIC;

Index: b/ksrc/skins/native/heap.c
===================================================================
@@ -292,7 +292,7 @@ int rt_heap_create(RT_HEAP *heap, const
 		}
 	}
 
-	xnsynch_init(&heap->synch_base, mode & (H_PRIO | H_FIFO));
+	xnsynch_init(&heap->synch_base, mode & (H_PRIO | H_FIFO), NULL);
 	heap->handle = 0;	/* i.e. (still) unregistered heap. */
 	heap->magic = XENO_HEAP_MAGIC;
 	heap->mode = mode;

Index: b/ksrc/skins/native/intr.c
===================================================================
@@ -266,7 +266,7 @@ int rt_intr_create(RT_INTR *intr,
 
 	xnintr_init(&intr->intr_base, intr->name, irq, isr, iack, mode);
 #ifdef CONFIG_XENO_OPT_PERVASIVE
-	xnsynch_init(&intr->synch_base, XNSYNCH_PRIO);
+	xnsynch_init(&intr->synch_base, XNSYNCH_PRIO, NULL);
 	intr->pending = 0;
 	intr->cpid = 0;
 	intr->mode = 0;

Index: b/ksrc/skins/native/mutex.c
===================================================================
@@ -171,7 +171,7 @@ int rt_mutex_create(RT_MUTEX *mutex, con
 		return -EPERM;
 
 	xnsynch_init(&mutex->synch_base,
-		     XNSYNCH_PRIO | XNSYNCH_PIP | XNSYNCH_OWNER);
+		     XNSYNCH_PRIO | XNSYNCH_PIP | XNSYNCH_OWNER, NULL);
 	mutex->handle = 0;	/* i.e. (still) unregistered mutex. */
 	mutex->magic = XENO_MUTEX_MAGIC;
 	mutex->lockcnt = 0;

Index: b/ksrc/skins/native/queue.c
===================================================================
@@ -255,7 +255,7 @@ int rt_queue_create(RT_QUEUE *q,
 		}
 	}
 
-	xnsynch_init(&q->synch_base, mode & (Q_PRIO | Q_FIFO));
+	xnsynch_init(&q->synch_base, mode & (Q_PRIO | Q_FIFO), NULL);
 	initq(&q->pendq);
 	q->handle = 0;		/* i.e. (still) unregistered queue. */
 	q->magic = XENO_QUEUE_MAGIC;

Index: b/ksrc/skins/native/sem.c
===================================================================
@@ -181,7 +181,7 @@ int rt_sem_create(RT_SEM *sem, const cha
 	if ((mode & S_PULSE) && icount > 0)
 		return -EINVAL;
 
-	xnsynch_init(&sem->synch_base, mode & S_PRIO);
+	xnsynch_init(&sem->synch_base, mode & S_PRIO, NULL);
 	sem->count = icount;
 	sem->mode = mode;
 	sem->handle = 0;	/* i.e. (still) unregistered semaphore. */

Index: b/ksrc/skins/native/task.c
===================================================================
@@ -255,7 +255,7 @@ int rt_task_create(RT_TASK *task,
 	task->overrun = -1;
 	task->cstamp = ++__xeno_task_stamp;
 	task->safelock = 0;
-	xnsynch_init(&task->safesynch, XNSYNCH_FIFO);
+	xnsynch_init(&task->safesynch, XNSYNCH_FIFO, NULL);
 
 	xnarch_cpus_clear(task->affinity);
 

@@ -268,9 +268,9 @@ int rt_task_create(RT_TASK *task,
 		task->affinity = XNPOD_ALL_CPUS;
 
 #ifdef CONFIG_XENO_OPT_NATIVE_MPS
-	xnsynch_init(&task->mrecv, XNSYNCH_FIFO);
+	xnsynch_init(&task->mrecv, XNSYNCH_FIFO, NULL);
 	xnsynch_init(&task->msendq,
-		     XNSYNCH_PRIO | XNSYNCH_PIP | XNSYNCH_OWNER);
+		     XNSYNCH_PRIO | XNSYNCH_PIP | XNSYNCH_OWNER, NULL);
 	xnsynch_set_owner(&task->msendq, &task->thread_base);
 	task->flowgen = 0;
 #endif /* CONFIG_XENO_OPT_NATIVE_MPS */

Index: b/ksrc/skins/posix/intr.c
===================================================================
@@ -116,7 +116,7 @@ int pthread_intr_attach_np(pthread_intr_
 	xnintr_init(&intr->intr_base, NULL, irq, isr, iack, 0);
 
 #ifdef CONFIG_XENO_OPT_PERVASIVE
-	xnsynch_init(&intr->synch_base, XNSYNCH_PRIO);
+	xnsynch_init(&intr->synch_base, XNSYNCH_PRIO, NULL);
 	intr->pending = 0;
 #endif /* CONFIG_XENO_OPT_PERVASIVE */
 	intr->magic = PSE51_INTR_MAGIC;

Index: b/ksrc/skins/posix/mq.c
===================================================================
@@ -129,8 +129,8 @@ static int pse51_mq_init(pse51_mq_t * mq
 
 	mq->memsize = memsize;
 	initpq(&mq->queued);
-	xnsynch_init(&mq->receivers, XNSYNCH_PRIO | XNSYNCH_NOPIP);
-	xnsynch_init(&mq->senders, XNSYNCH_PRIO | XNSYNCH_NOPIP);
+	xnsynch_init(&mq->receivers, XNSYNCH_PRIO | XNSYNCH_NOPIP, NULL);
+	xnsynch_init(&mq->senders, XNSYNCH_PRIO | XNSYNCH_NOPIP, NULL);
 	mq->mem = mem;
 
 	/* Fill the pool. */

Index: b/ksrc/skins/posix/sem.c
===================================================================
@@ -99,7 +99,7 @@ static int pse51_sem_init_inner(pse51_se
 
 	inith(&sem->link);
 	appendq(&pse51_kqueues(pshared)->semq, &sem->link);
-	xnsynch_init(&sem->synchbase, XNSYNCH_PRIO);
+	xnsynch_init(&sem->synchbase, XNSYNCH_PRIO, NULL);
 	sem->value = value;
 	sem->pshared = pshared;
 	sem->is_named = 0;

Index: b/ksrc/skins/psos+/event.c
===================================================================
@@ -21,7 +21,7 @@
 
 void taskev_init(psosevent_t *evgroup)
 {
-	xnsynch_init(&evgroup->synchbase, XNSYNCH_FIFO);
+	xnsynch_init(&evgroup->synchbase, XNSYNCH_FIFO, NULL);
 	evgroup->events = 0;
 }
 

Index: b/ksrc/skins/psos+/queue.c
===================================================================
@@ -259,7 +259,7 @@ static u_long q_create_internal(const ch
 		}
 	}
 
-	xnsynch_init(&queue->synchbase, bflags);
+	xnsynch_init(&queue->synchbase, bflags, NULL);
 
 	queue->magic = PSOS_QUEUE_MAGIC;
 	xnobject_copy_name(queue->name, name);

Index: b/ksrc/skins/psos+/rn.c
===================================================================
@@ -214,7 +214,7 @@ u_long rn_create(const char *name,
 	rn->usize = usize;
 	xnobject_copy_name(rn->name, name);
 
-	xnsynch_init(&rn->synchbase, bflags);
+	xnsynch_init(&rn->synchbase, bflags, NULL);
 	rn->magic = PSOS_RN_MAGIC;
 
 	inith(&rn->rlink);

Index: b/ksrc/skins/psos+/sem.c
===================================================================
@@ -114,7 +114,7 @@ u_long sm_create(const char *name, u_lon
 	if (flags & SM_PRIOR)
 		bflags |= XNSYNCH_PRIO;
 
-	xnsynch_init(&sem->synchbase, bflags);
+	xnsynch_init(&sem->synchbase, bflags, NULL);
 
 	inith(&sem->link);
 	sem->count = icount;

Index: b/ksrc/skins/rtai/sem.c
===================================================================
@@ -38,7 +38,7 @@ void rt_typed_sem_init(SEM * sem, int va
 			mode = XNSYNCH_FIFO;
 	}
 
-	xnsynch_init(&sem->synch_base, mode);
+	xnsynch_init(&sem->synch_base, mode, NULL);
 	sem->count = value;
 	sem->type = type & 0x3;
 	sem->owner = NULL;

Index: b/ksrc/skins/rtdm/drvlib.c
===================================================================
@@ -145,13 +145,13 @@ int rtdm_task_init(rtdm_task_t *task, co
 	if (err)
 		return err;
 
-#ifdef CONFIG_XENO_FASTSEM
+#ifdef CONFIG_XENO_FASTSYNCH
 	/* We need an anonymous registry entry to obtain a handle for fast
 	   mutex locking. */
 	err = xnthread_register(task, "");
 	if (err)
 		goto cleanup_out;
-#endif /* CONFIG_XENO_FASTSEM */
+#endif /* CONFIG_XENO_FASTSYNCH */
 
 	if (period > 0) {
 		err = xnpod_set_thread_periodic(task, XN_INFINITE,

@@ -761,7 +761,7 @@ void rtdm_event_init(rtdm_event_t *event
 	/* Make atomic for re-initialisation support */
 	xnlock_get_irqsave(&nklock, s);
 
-	xnsynch_init(&event->synch_base, XNSYNCH_PRIO);
+	xnsynch_init(&event->synch_base, XNSYNCH_PRIO, NULL);
 	if (pending)
 		xnsynch_set_flags(&event->synch_base, RTDM_EVENT_PENDING);
 	xnselect_init(&event->select_block);

@@ -1109,7 +1109,7 @@ void rtdm_sem_init(rtdm_sem_t *sem, unsi
 	xnlock_get_irqsave(&nklock, s);
 
 	sem->value = value;
-	xnsynch_init(&sem->synch_base, XNSYNCH_PRIO);
+	xnsynch_init(&sem->synch_base, XNSYNCH_PRIO, NULL);
 	xnselect_init(&sem->select_block);
 
 	xnlock_put_irqrestore(&nklock, s);

@@ -1391,7 +1391,7 @@ void rtdm_mutex_init(rtdm_mutex_t *mutex
 	xnlock_get_irqsave(&nklock, s);
 
 	xnsynch_init(&mutex->synch_base,
-		     XNSYNCH_PRIO | XNSYNCH_PIP | XNSYNCH_OWNER);
+		     XNSYNCH_PRIO | XNSYNCH_PIP | XNSYNCH_OWNER, NULL);
 
 	xnlock_put_irqrestore(&nklock, s);
 }

Index: b/ksrc/skins/uitron/flag.c
===================================================================
@@ -122,7 +122,7 @@ ER cre_flg(ID flgid, T_CFLG *pk_cflg)
 		return E_OBJ;
 	}
 
-	xnsynch_init(&flag->synchbase, XNSYNCH_FIFO);
+	xnsynch_init(&flag->synchbase, XNSYNCH_FIFO, NULL);
 	flag->id = flgid;
 	flag->exinf = pk_cflg->exinf;
 	flag->flgatr = pk_cflg->flgatr;

Index: b/ksrc/skins/uitron/mbx.c
===================================================================
@@ -138,7 +138,8 @@ ER cre_mbx(ID mbxid, T_CMBX *pk_cmbx)
 	}
 
 	xnsynch_init(&mbx->synchbase,
-		     (pk_cmbx->mbxatr & TA_TPRI) ? XNSYNCH_PRIO : XNSYNCH_FIFO);
+		     (pk_cmbx->mbxatr & TA_TPRI) ? XNSYNCH_PRIO : XNSYNCH_FIFO,
+		     NULL);
 
 	mbx->id = mbxid;
 	mbx->exinf = pk_cmbx->exinf;

Index: b/ksrc/skins/uitron/sem.c
===================================================================
@@ -127,7 +127,8 @@ ER cre_sem(ID semid, T_CSEM *pk_csem)
 	}
 
 	xnsynch_init(&sem->synchbase,
-		     (pk_csem->sematr & TA_TPRI) ? XNSYNCH_PRIO : XNSYNCH_FIFO);
+		     (pk_csem->sematr & TA_TPRI) ? XNSYNCH_PRIO : XNSYNCH_FIFO,
+		     NULL);
 
 	sem->id = semid;
 	sem->exinf = pk_csem->exinf;

Index: b/ksrc/skins/vrtx/event.c
===================================================================
@@ -151,7 +151,7 @@ int sc_fcreate(int *errp)
 		goto nocb;
 	}
 
-	xnsynch_init(&evgroup->synchbase, XNSYNCH_PRIO | XNSYNCH_DREORD);
+	xnsynch_init(&evgroup->synchbase, XNSYNCH_PRIO | XNSYNCH_DREORD, NULL);
 	inith(&evgroup->link);
 	evgroup->evid = evid;
 	evgroup->magic = VRTX_EVENT_MAGIC;

Index: b/ksrc/skins/vrtx/mb.c
===================================================================
@@ -210,7 +210,7 @@ vrtxmb_t *mb_map(char **mboxp)
 	mb->mboxp = mboxp;
 	mb->msg = NULL;
 	mb->hnext = NULL;
-	xnsynch_init(&mb->synchbase, XNSYNCH_PRIO | XNSYNCH_DREORD);
+	xnsynch_init(&mb->synchbase, XNSYNCH_PRIO | XNSYNCH_DREORD, NULL);
 	appendq(&vrtx_mbox_q, &mb->link);
 	mb_hash(mboxp, mb);
 

Index: b/ksrc/skins/vrtx/mx.c
===================================================================
@@ -161,7 +161,8 @@ int sc_mcreate(unsigned int opt, int *er
 	inith(&mx->link);
 	mx->mid = mid;
 	mx->owner = NULL;
-	xnsynch_init(&mx->synchbase, bflags | XNSYNCH_DREORD | XNSYNCH_OWNER);
+	xnsynch_init(&mx->synchbase, bflags | XNSYNCH_DREORD | XNSYNCH_OWNER,
+		     NULL);
 
 	xnlock_get_irqsave(&nklock, s);
 	appendq(&vrtx_mx_q, &mx->link);

Index: b/ksrc/skins/vrtx/queue.c
===================================================================
@@ -165,7 +165,7 @@ int sc_qecreate(int qid, int qsize, int
 		bflags = XNSYNCH_PRIO;
 
 	inith(&queue->link);
-	xnsynch_init(&queue->synchbase, bflags | XNSYNCH_DREORD);
+	xnsynch_init(&queue->synchbase, bflags | XNSYNCH_DREORD, NULL);
 	queue->magic = VRTX_QUEUE_MAGIC;
 	queue->qid = qid;
 	queue->qsize = qsize;

Index: b/ksrc/skins/vrtx/sem.c
===================================================================
@@ -155,7 +155,7 @@ int sc_screate(unsigned initval, int opt
 	else
 		bflags = XNSYNCH_FIFO;
 
-	xnsynch_init(&sem->synchbase, bflags | XNSYNCH_DREORD);
+	xnsynch_init(&sem->synchbase, bflags | XNSYNCH_DREORD, NULL);
 	inith(&sem->link);
 	sem->semid = semid;
 	sem->magic = VRTX_SEM_MAGIC;

Index: b/ksrc/skins/vxworks/module.c
===================================================================
@@ -59,7 +59,7 @@ int SKIN_INIT(vxworks)
 	/* The following fields are unused in the global holder;
 	   still, we initialize them not to leave such data in an
 	   invalid state. */
-	xnsynch_init(&__wind_global_rholder.wdsynch, XNSYNCH_FIFO);
+	xnsynch_init(&__wind_global_rholder.wdsynch, XNSYNCH_FIFO, NULL);
 	initq(&__wind_global_rholder.wdpending);
 	__wind_global_rholder.wdcount = 0;
 

Index: b/ksrc/skins/vxworks/msgQLib.c
===================================================================
@@ -174,7 +174,7 @@ MSG_Q_ID msgQCreate(int nb_msgs, int len
 	if (flags & MSG_Q_PRIORITY)
 		bflags |= XNSYNCH_PRIO;
 
-	xnsynch_init(&queue->synchbase, bflags);
+	xnsynch_init(&queue->synchbase, bflags, NULL);
 
 	msg_size = sizeof(wind_msg_t) + length;
 

Index: b/ksrc/skins/vxworks/semLib.c
===================================================================
@@ -423,7 +423,7 @@ static SEM_ID sem_create_internal(int fl
 
 	check_alloc(wind_sem_t, sem, return 0);
 
-	xnsynch_init(&sem->synchbase, (xnflags_t)flags);
+	xnsynch_init(&sem->synchbase, (xnflags_t)flags, NULL);
 	sem->magic = WIND_SEM_MAGIC;
 	sem->count = count;
 	sem->vtbl = vtbl;

Index: b/ksrc/skins/vxworks/syscall.c
===================================================================
@@ -1171,7 +1171,7 @@ static void *__wind_shadow_eventcb(int e
 
 		initq(&rh->wdq);
 		/* A single server thread pends on this. */
-		xnsynch_init(&rh->wdsynch, XNSYNCH_FIFO);
+		xnsynch_init(&rh->wdsynch, XNSYNCH_FIFO, NULL);
 		initq(&rh->wdpending);
 		rh->wdcount = 0;
 		initq(&rh->msgQq);

Index: b/ksrc/skins/vxworks/taskLib.c
===================================================================
@@ -146,7 +146,7 @@ STATUS taskInit(WIND_TCB *pTcb,
 	xnthread_time_slice(&pTcb->threadbase) = rrperiod;
 
 	pTcb->safecnt = 0;
-	xnsynch_init(&pTcb->safesync, 0);
+	xnsynch_init(&pTcb->safesync, 0, NULL);
 
 	/* TODO: fill in attributes of wind_task_t:
 	   pTcb->status

Index: b/ksrc/skins/posix/cond.c
===================================================================
@@ -223,27 +223,18 @@ static inline int mutex_save_count(xnthr
 				   unsigned *count_ptr)
 {
 	pse51_mutex_t *mutex;
-	xnthread_t *owner;
 
 	if (!pse51_obj_active(shadow, PSE51_MUTEX_MAGIC, struct __shadow_mutex))
 		 return EINVAL;
 
 	mutex = shadow->mutex;
 
-	if (clear_claimed(xnarch_atomic_get(mutex->owner)) !=
-	    xnthread_handle(cur))
+	if (xnsynch_owner_check(&mutex->synchbase, cur) != 0)
 		return EPERM;
 
 	*count_ptr = shadow->lockcnt;
 
-	if (likely(xnarch_atomic_cmpxchg(mutex->owner, cur, XN_NO_HANDLE) ==
-		   xnthread_handle(cur)))
-		return 0;
-
-	owner = xnsynch_release(&mutex->synchbase);
-	xnarch_atomic_set(mutex->owner,
-			  set_claimed(xnthread_handle(owner),
-				      xnsynch_nsleepers(&mutex->synchbase)));
+	xnsynch_release(&mutex->synchbase);
 
 	/* Do not reschedule here, releasing the mutex and suspension must be
 	   done atomically in pthread_cond_*wait. */

198 lines not on this page · raw message

181 lines not on this page · raw message

Index: b/ksrc/skins/posix/syscall.c
===================================================================
@@ -1060,13 +1060,10 @@ static int __pthread_mutex_unlock(struct
 
 	mutex = shadow->mutex;
 
-	if (clear_claimed(xnarch_atomic_get(mutex->owner)) !=
-	    xnthread_handle(cur)) {
-		err = -EPERM;
+	err = (xnsynch_owner(&mutex->synchbase) == cur) ? 0 : -EPERM;
+	if (err)
 		goto out;
-	}
 
-	err = 0;
 	if (shadow->lockcnt > 1) {
 		/* Mutex is recursive */
 		--shadow->lockcnt;

@@ -1080,8 +1077,9 @@ static int __pthread_mutex_unlock(struct
 
 		return 0;
 	}
-	
-	pse51_mutex_unlock_internal(cur, mutex);
+
+	if (xnsynch_release(&mutex->synchbase))
+		xnpod_schedule();
 
   out:
 	cb_read_unlock(&shadow->lock, s);

@@ -1186,13 +1184,11 @@ static int __pthread_mutex_destroy(struc
 	if (pse51_kqueues(mutex->attr.pshared) != mutex->owningq)
 		return -EPERM;
 
-	if (xnarch_atomic_get(mutex->owner) != XN_NO_HANDLE)
+	if (xnsynch_fast_owner_check(mutex->synchbase.fastlock,
+				     XN_NO_HANDLE) != 0)
 		return -EBUSY;
 
 	pse51_mark_deleted(shadow);
-	if (!mutex->attr.pshared)
-		xnheap_free(&xnsys_ppd_get(mutex->attr.pshared)->sem_heap,
-			    mutex->owner);
 	pse51_mutex_destroy_internal(mutex, mutex->owningq);
 
 	return __xn_safe_copy_to_user((void __user *)&umx->shadow_mutex,

@@ -1262,7 +1258,6 @@ static int __pthread_mutex_timedlock(str
 
 static int __pthread_mutex_unlock(struct pt_regs *regs)
 {
-	xnthread_t *cur = xnpod_current_thread();
 	union __xeno_mutex mx, *umx;
 
 	if (xnpod_root_p())

@@ -1275,7 +1270,8 @@ static int __pthread_mutex_unlock(struct
 				     offsetof(struct __shadow_mutex, lock)))
 		return -EFAULT;
 
-	pse51_mutex_unlock_internal(cur, mx.shadow_mutex.mutex);
+	if (xnsynch_release(&mx.shadow_mutex.mutex->synchbase))
+		xnpod_schedule();
 
 	return 0;
 }

153 lines not on this page · raw message

Index: b/include/native/mutex.h
===================================================================
@@ -32,7 +32,7 @@ struct rt_task;
  */
 typedef struct rt_mutex_info {
 
-	int lockcnt;		/**< Lock nesting level (> 0 means "locked"). */
+	int locked;		/**< > 0 if mutex is locked. */
 
 	int nwaiters;		/**< Number of pending tasks. */
 

@@ -44,7 +44,15 @@ typedef struct rt_mutex_info {
 } RT_MUTEX_INFO;
 
 typedef struct rt_mutex_placeholder {
+
 	xnhandle_t opaque;
+
+#ifdef CONFIG_XENO_FASTSYNCH
+	xnarch_atomic_t *fastlock;
+
+	int lockcnt;
+#endif /* CONFIG_XENO_FASTSYNCH */
+
 } RT_MUTEX_PLACEHOLDER;
 
 #if (defined(__KERNEL__) || defined(__XENO_SIM__)) && !defined(DOXYGEN_CPP)

@@ -54,6 +62,8 @@ typedef struct rt_mutex_placeholder {
 
 #define XENO_MUTEX_MAGIC 0x55550505
 
+#define RT_MUTEX_EXPORTED	XNSYNCH_SPARE0	/* Mutex registered by name */
+
 typedef struct __rt_mutex {
 
 	unsigned magic;		/* !< Magic code - must be first */

@@ -74,7 +84,7 @@ typedef struct __rt_mutex {
 
 #define rlink2mutex(ln)		container_of(ln, RT_MUTEX, rlink)
 
-    xnqueue_t *rqueue;		/* !< Backpointer to resource queue. */
+	xnqueue_t *rqueue;	/* !< Backpointer to resource queue. */
 
 } RT_MUTEX;
 

@@ -93,9 +103,8 @@ static inline void __native_mutex_flush_
 	xeno_flush_rq(RT_MUTEX, rq, mutex);
 }
 
-int rt_mutex_acquire_inner(RT_MUTEX *mutex,
-			   xntmode_t timeout_mode,
-			   RTIME timeout);
+int rt_mutex_acquire_inner(RT_MUTEX *mutex, RTIME timeout,
+			   xntmode_t timeout_mode);
 
 #else /* !CONFIG_XENO_OPT_NATIVE_MUTEX */
 

@@ -138,6 +147,10 @@ static inline int rt_mutex_unbind (RT_MU
 extern "C" {
 #endif
 
+int rt_mutex_create_inner(RT_MUTEX *mutex, const char *name,
+			  xnarch_atomic_t *fastlock);
+int rt_mutex_delete_inner(RT_MUTEX *mutex);
+
 /* Public interface. */
 
 int rt_mutex_create(RT_MUTEX *mutex,

Index: b/ksrc/skins/native/cond.c
===================================================================
@@ -378,7 +378,7 @@ int rt_cond_broadcast(RT_COND *cond)
 int rt_cond_wait_inner(RT_COND *cond, RT_MUTEX *mutex,
 		       xntmode_t timeout_mode, RTIME timeout)
 {
-	int err = 0, kicked = 0;
+	int err, kicked = 0;
 	xnthread_t *thread;
 	int lockcnt;
 	spl_t s;

@@ -407,15 +407,14 @@ int rt_cond_wait_inner(RT_COND *cond, RT
 
 	thread = xnpod_current_thread();
 
-	if (thread != xnsynch_owner(&mutex->synch_base)) {
-		err = -EPERM;
+	err = xnsynch_owner_check(&mutex->synch_base, thread);
+
+	if (err)
 		goto unlock_and_exit;
-	}
 
 	/*
 	 * We can't use rt_mutex_release since that might reschedule
-	 * before enter xnsynch_sleep_on, hence most of the code is
-	 * duplicated here.
+	 * before enter xnsynch_sleep_on.
 	 */
 	lockcnt = mutex->lockcnt; /* Leave even if mutex is nested */
 

427 lines not on this page · raw message

154 lines not on this page · raw message

Index: b/src/skins/native/cond.c
===================================================================
@@ -41,16 +41,46 @@ int rt_cond_delete(RT_COND *cond)
 
 int rt_cond_wait(RT_COND *cond, RT_MUTEX *mutex, RTIME timeout)
 {
+#ifdef CONFIG_XENO_FASTSYNCH
+	int saved_lockcnt, err;
+
+	saved_lockcnt = mutex->lockcnt;
+
+	err = XENOMAI_SKINCALL4(__native_muxid,
+				__native_cond_wait, cond, mutex,
+				XN_RELATIVE, &timeout);
+
+	mutex->lockcnt = saved_lockcnt;
+
+	return err;
+
+#else /* !CONFIG_XENO_FASTSYNCH */
 	return XENOMAI_SKINCALL4(__native_muxid,
 				 __native_cond_wait, cond, mutex,
 				 XN_RELATIVE, &timeout);
+#endif /* !CONFIG_XENO_FASTSYNCH */
 }
 
 int rt_cond_wait_until(RT_COND *cond, RT_MUTEX *mutex, RTIME timeout)
 {
+#ifdef CONFIG_XENO_FASTSYNCH
+	int saved_lockcnt, err;
+
+	saved_lockcnt = mutex->lockcnt;
+
+	err = XENOMAI_SKINCALL4(__native_muxid,
+				__native_cond_wait, cond, mutex,
+				XN_REALTIME, &timeout);
+
+	mutex->lockcnt = saved_lockcnt;
+
+	return err;
+
+#else /* !CONFIG_XENO_FASTSYNCH */
 	return XENOMAI_SKINCALL4(__native_muxid,
 				 __native_cond_wait, cond, mutex,
 				 XN_REALTIME, &timeout);
+#endif /* !CONFIG_XENO_FASTSYNCH */
 }
 
 int rt_cond_signal(RT_COND *cond)

135 lines not on this page · raw message

58 lines not on this page · raw message

Index: b/include/asm-generic/bits/current.h
===================================================================
@@ -4,9 +4,16 @@
 #include <pthread.h>
 #include <nucleus/types.h>
 
-extern pthread_key_t xeno_current_key;
+#ifdef HAVE___THREAD
+extern __thread xnhandle_t xeno_current __attribute__ ((tls_model ("initial-exec")));
 
-extern void xeno_set_current(void);
+static inline xnhandle_t xeno_get_current(void)
+{
+	return xeno_current;
+}
+
+#else /* ! HAVE___THREAD */
+extern pthread_key_t xeno_current_key;
 
 static inline xnhandle_t xeno_get_current(void)
 {

@@ -17,5 +24,8 @@ static inline xnhandle_t xeno_get_curren
 
 	return (xnhandle_t)val;
 }
+#endif /* ! HAVE___THREAD */
+
+void xeno_set_current(void);
 
 #endif /* _XENO_ASM_GENERIC_CURRENT_H */

Index: b/src/skins/native/init.c
===================================================================
@@ -27,11 +27,12 @@
 #include <asm-generic/bits/bind.h>
 #include <asm-generic/bits/mlock_alert.h>
 
-pthread_key_t __native_tskey;
-
 int __native_muxid = -1;
 void native_timer_init(int);
 
+#ifndef HAVE___THREAD
+pthread_key_t __native_tskey;
+
 static void __flush_tsd(void *tsd)
 {
 	/* Free the task descriptor allocated by rt_task_self(). */

@@ -39,6 +40,17 @@ static void __flush_tsd(void *tsd)
 }
 
 static __attribute__ ((constructor))
+void __init_native_tskey(void)
+	/* Allocate a TSD key for indexing self task pointers. */
+
+	if (pthread_key_create(&__native_tskey, &__flush_tsd) != 0) {
+		fprintf(stderr, "Xenomai: failed to allocate new TSD key?!\n");
+		exit(1);
+	}
+}
+#endif /* !HAVE___THREAD */
+
+static __attribute__ ((constructor))
 void __init_xeno_interface(void)
 {
 	__native_muxid =

@@ -49,11 +61,4 @@ void __init_xeno_interface(void)
 #endif /* CONFIG_XENO_HW_DIRECT_TSC */
 	
 	__native_muxid = __xn_mux_shifted_id(__native_muxid);
-
-	/* Allocate a TSD key for indexing self task pointers. */
-
-	if (pthread_key_create(&__native_tskey, &__flush_tsd) != 0) {
-		fprintf(stderr, "Xenomai: failed to allocate new TSD key?!\n");
-		exit(1);
-	}
 }

Index: b/src/skins/native/task.c
===================================================================
@@ -29,7 +29,14 @@
 #include <asm-generic/bits/current.h>
 #include "wrappers.h"
 
+#ifdef HAVE___THREAD
+__thread RT_TASK __native_self __attribute__ ((tls_model ("initial-exec"))) = {
+	.opaque = XN_NO_HANDLE,
+	.opaque2 = 0
+};
+#else /* !HAVE___THREAD */
 extern pthread_key_t __native_tskey;
+#endif /* !HAVE___THREAD */
 
 extern int __native_muxid;
 

@@ -91,6 +98,10 @@ static void *rt_task_trampoline(void *co
 
 	xeno_set_current();
 
+#ifdef HAVE___THREAD
+	__native_self = *iargs->task;
+#endif /* HAVE___THREAD */
+
 	/* Wait on the barrier for the task to be started. The barrier
 	   could be released in order to process Linux signals while the
 	   Xenomai shadow is still dormant; in such a case, resume wait. */

@@ -316,6 +327,15 @@ RT_TASK *rt_task_self(void)
 {
 	RT_TASK *self;
 
+#ifdef HAVE___THREAD
+	self = &__native_self;
+
+	if (self->opaque == XN_NO_HANDLE)
+		return NULL;
+
+#else /* !HAVE___THREAD */
+	RT_TASK *self;
+
 	self = (RT_TASK *)pthread_getspecific(__native_tskey);
 
 	if (self)

@@ -330,6 +350,7 @@ RT_TASK *rt_task_self(void)
 	}
 
 	pthread_setspecific(__native_tskey, self);
+#endif /* !HAVE___THREAD */
 
 	return self;
 }

Index: b/src/skins/vxworks/init.c
===================================================================
@@ -26,10 +26,11 @@
 #include <asm-generic/bits/bind.h>
 #include <asm-generic/bits/mlock_alert.h>
 
-pthread_key_t __vxworks_tskey;
-
 int __vxworks_muxid = -1;
 
+#ifndef HAVE___THREAD
+pthread_key_t __vxworks_tskey;
+
 static void __flush_tsd(void *tsd)
 {
 	/* Free the task descriptor allocated by taskIdSelf(). */

@@ -37,12 +38,8 @@ static void __flush_tsd(void *tsd)
 }
 
 static __attribute__ ((constructor))
-void __init_xeno_interface(void)
+void __init_vxworks_tskey(void)
 {
-	__vxworks_muxid = xeno_bind_skin(VXWORKS_SKIN_MAGIC,
-					 "vxworks", "xeno_vxworks");
-	__vxworks_muxid = __xn_mux_shifted_id(__vxworks_muxid);
-
 	/* Allocate a TSD key for indexing self task pointers. */
 
 	if (pthread_key_create(&__vxworks_tskey, &__flush_tsd) != 0) {

@@ -50,3 +47,12 @@ void __init_xeno_interface(void)
 		exit(1);
 	}
 }
+#endif /* !HAVE___THREAD */
+
+static __attribute__ ((constructor))
+void __init_xeno_interface(void)
+{
+	__vxworks_muxid = xeno_bind_skin(VXWORKS_SKIN_MAGIC,
+					 "vxworks", "xeno_vxworks");
+	__vxworks_muxid = __xn_mux_shifted_id(__vxworks_muxid);
+}

Index: b/src/skins/vxworks/taskLib.c
===================================================================
@@ -30,7 +30,14 @@
 #include <asm-generic/bits/current.h>
 #include "wrappers.h"
 
+#ifdef HAVE___THREAD
+__thread WIND_TCB
+__vxworks_self __attribute__ ((tls_model ("initial-exec"))) = {
+	.handle = XN_NO_HANDLE
+};
+#else /* !HAVE___THREAD */
 extern pthread_key_t __vxworks_tskey;
+#endif /* !HAVE___THREAD */
 
 extern int __vxworks_muxid;
 

@@ -120,6 +127,10 @@ static void *wind_task_trampoline(void *
 
 	xeno_set_current();
 
+#ifdef HAVE___THREAD
+	__vxworks_self = *iargs->pTcb;
+#endif /* HAVE___THREAD */
+
 	/* Wait on the barrier for the task to be started. The barrier
 	   could be released in order to process Linux signals while the
 	   Xenomai shadow is still dormant; in such a case, resume wait. */

@@ -309,9 +320,15 @@ STATUS taskResume(TASK_ID task_id)
 
 TASK_ID taskIdSelf(void)
 {
-	WIND_TCB *self = (WIND_TCB *)pthread_getspecific(__vxworks_tskey);
+#ifdef HAVE___THREAD
+	return __vxworks_self.handle;
+
+#else /* !HAVE___THREAD */
+	WIND_TCB *self;
 	int err;
 
+	self = (WIND_TCB *)pthread_getspecific(__vxworks_tskey);
+
 	if (self)
 		return self->handle;
 

@@ -332,6 +349,7 @@ TASK_ID taskIdSelf(void)
 	pthread_setspecific(__vxworks_tskey, self);
 
 	return self->handle;
+#endif /* !HAVE___THREAD */
 }
 
 STATUS taskPrioritySet(TASK_ID task_id, int prio)

Index: b/src/skins/vrtx/init.c
===================================================================
@@ -26,10 +26,11 @@
 #include <asm-generic/bits/bind.h>
 #include <asm-generic/bits/mlock_alert.h>
 
-pthread_key_t __vrtx_tskey;
-
 int __vrtx_muxid = -1;
 
+#ifndef HAVE___THREAD
+pthread_key_t __vrtx_tskey;
+
 static void __flush_tsd(void *tsd)
 {
 	/* Free the TCB struct. */

@@ -37,12 +38,8 @@ static void __flush_tsd(void *tsd)
 }
 
 static __attribute__ ((constructor))
-void __init_xeno_interface(void)
+void __init_vrtx_tskey(void)
 {
-	__vrtx_muxid =
-	    xeno_bind_skin(VRTX_SKIN_MAGIC, "vrtx", "xeno_vrtx");
-	__vrtx_muxid = __xn_mux_shifted_id(__vrtx_muxid);
-
 	/* Allocate a TSD key for indexing self task pointers. */
 
 	if (pthread_key_create(&__vrtx_tskey, &__flush_tsd) != 0) {

@@ -50,3 +47,12 @@ void __init_xeno_interface(void)
 		exit(1);
 	}
 }
+#endif /* !HAVE___THREAD */
+
+static __attribute__ ((constructor))
+void __init_xeno_interface(void)
+{
+	__vrtx_muxid =
+	    xeno_bind_skin(VRTX_SKIN_MAGIC, "vrtx", "xeno_vrtx");
+	__vrtx_muxid = __xn_mux_shifted_id(__vrtx_muxid);
+}

Index: b/src/skins/vrtx/task.c
===================================================================
@@ -29,7 +29,11 @@
 #include <vrtx/vrtx.h>
 #include <asm-generic/bits/current.h>
 
+#ifdef HAVE___THREAD
+__thread TCB __vrtx_tcb __attribute__ ((tls_model ("initial-exec")));
+#else /* !HAVE___THREAD */
 extern pthread_key_t __vrtx_tskey;
+#endif /* !HAVE___THREAD */
 
 extern int __vrtx_muxid;
 

@@ -81,7 +85,9 @@ static void *vrtx_task_trampoline(void *
 	struct sched_param param;
 	int policy;
 	long err;
+#ifndef HAVE___THREAD
 	TCB *tcb;
+#endif /* !HAVE___THREAD */
 
 	/* Backup the arg struct, it might vanish after completion. */
 	memcpy(&_iargs, iargs, sizeof(_iargs));

@@ -96,6 +102,7 @@ static void *vrtx_task_trampoline(void *
 	/* vrtx_task_delete requires asynchronous cancellation */
 	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
 
+#ifndef HAVE___THREAD
 	tcb = (TCB *) malloc(sizeof(*tcb));
 	if (tcb == NULL) {
 		fprintf(stderr, "Xenomai: failed to allocate local TCB?!\n");

@@ -104,6 +111,7 @@ static void *vrtx_task_trampoline(void *
 	}
 
 	pthread_setspecific(__vrtx_tskey, tcb);
+#endif /* !HAVE___THREAD */
 
 	old_sigharden_handler = signal(SIGHARDEN, &vrtx_task_sigharden);
 

@@ -224,7 +232,11 @@ TCB *sc_tinquiry(int pinfo[], int tid, i
 {
 	TCB *tcb;
 
-	tcb = (TCB *) pthread_getspecific(__vrtx_tskey);	/* Cannot fail. */
+#ifdef HAVE___THREAD
+	tcb = &__vrtx_tcb;
+#else /* !HAVE___THREAD */
+	tcb = (TCB *) pthread_getspecific(__vrtx_tskey); /* Cannot fail. */
+#endif /* !HAVE___THREAD */
 
 	*errp = XENOMAI_SKINCALL3(__vrtx_muxid,
 				  __vrtx_tinquiry, pinfo, tcb, tid);

Index: b/include/native/syscall.h
===================================================================
@@ -134,6 +134,7 @@ struct rt_arg_bulk {
 	u_long a3;
 	u_long a4;
 	u_long a5;
+	u_long a6;
 };
 
 #ifdef __KERNEL__

Index: b/include/nucleus/shadow.h
===================================================================
@@ -69,7 +69,8 @@ void xnshadow_grab_events(void);
 void xnshadow_release_events(void);
 
 int xnshadow_map(struct xnthread *thread,
-		 xncompletion_t __user *u_completion);
+		 xncompletion_t __user *u_completion,
+		 unsigned long __user *u_mode);
 
 void xnshadow_unmap(struct xnthread *thread);
 

Index: b/include/nucleus/thread.h
===================================================================
@@ -248,6 +248,10 @@ typedef struct xnthread {
 
 	void *cookie;		/* Cookie to pass to the entry routine */
 
+#ifdef CONFIG_XENO_OPT_PERVASIVE
+	unsigned long __user *u_mode;	/* Thread mode variable in userland. */
+#endif /* CONFIG_XENO_OPT_PERVASIVE */
+
     XNARCH_DECL_DISPLAY_CONTEXT();
 
 } xnthread_t;

Index: b/ksrc/nucleus/shadow.c
===================================================================
@@ -1079,6 +1079,8 @@ redo:
 		/* Grab the request token. */
 		return -ERESTARTSYS;
 
+	__xn_put_user(0, thread->u_mode);
+
 	preempt_disable();
 
 	/* Assume that we might have been migrated while waiting for

@@ -1250,6 +1252,8 @@ void xnshadow_relax(int notify)
 	/* "current" is now running into the Linux domain on behalf of the
 	   root thread. */
 
+	__xn_put_user(XNRELAX, thread->u_mode);
+
 	trace_mark(xn_nucleus_shadow_relaxed,
 		  "thread %p thread_name %s comm %s",
 		  thread, xnthread_name(thread), current->comm);

@@ -1264,7 +1268,9 @@ void xnshadow_exit(void)
 }
 
 /*!
- * \fn int xnshadow_map(xnthread_t *thread, xncompletion_t __user *u_completion)
+ * \fn int xnshadow_map(xnthread_t *thread,
+ *                      xncompletion_t __user *u_completion,
+ *                      unsigned long __user *u_mode)
  * @internal
  * \brief Create a shadow thread context.
  *

@@ -1288,6 +1294,11 @@ void xnshadow_exit(void)
  * immediately started and "current" immediately resumes in the Xenomai
  * domain from this service.
  *
+ * @param: u_mode is the address of a mode variable in user space that
+ * will reflect the current thread mode (primary or secondary). The
+ * nucleus will try to update the variable before switching to secondary
+ * or after switching from primary mode.
+ *
  * @return 0 is returned on success. Otherwise:
  *
  * - -ERESTARTSYS is returned if the current Linux task has received a

@@ -1313,7 +1324,8 @@ void xnshadow_exit(void)
  *
  */
 
-int xnshadow_map(xnthread_t *thread, xncompletion_t __user *u_completion)
+int xnshadow_map(xnthread_t *thread, xncompletion_t __user *u_completion,
+		 unsigned long __user *u_mode)
 {
 	xnarch_cpumask_t affinity;
 	unsigned muxid, magic;